diff --git a/04_transfer_learning_in_tensorflow_part_1_feature_extraction.ipynb b/04_transfer_learning_in_tensorflow_part_1_feature_extraction.ipynb index a48d45b..29b7400 100644 --- a/04_transfer_learning_in_tensorflow_part_1_feature_extraction.ipynb +++ b/04_transfer_learning_in_tensorflow_part_1_feature_extraction.ipynb @@ -4,29 +4,15 @@ "metadata": { "colab": { "provenance": [], - "machine_shape": "hm", - "gpuType": "A100", - "authorship_tag": "ABX9TyMfSTrYBa7FpMXwjPOrjT7b", - "include_colab_link": true + "gpuType": "T4" }, "kernelspec": { "name": "python3", "display_name": "Python 3" }, - "accelerator": "GPU", - "gpuClass": "standard" + "accelerator": "GPU" }, "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "view-in-github", - "colab_type": "text" - }, - "source": [ - "\"Open" - ] - }, { "cell_type": "markdown", "metadata": { @@ -78,6 +64,30 @@ "Don't worry if you make mistakes, we all do. The way to get better and make less mistakes is to **write more code**." ] }, + { + "cell_type": "code", + "source": [ + "# Load the TensorBoard notebook extension\n", + "%load_ext tensorboard" + ], + "metadata": { + "id": "5oTniUY17uuq" + }, + "execution_count": 1, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Clear any logs from previous runs\n", + "!rm -rf ./logs/" + ], + "metadata": { + "id": "09mLcRXF7wei" + }, + "execution_count": 5, + "outputs": [] + }, { "cell_type": "code", "source": [ @@ -90,15 +100,15 @@ "base_uri": "https://localhost:8080/" }, "id": "cCVdvbhzHoht", - "outputId": "68f85f57-1410-438d-d559-e438952157d1" + "outputId": "93de9c1f-8335-4fed-e73d-2b4c878bb3f4" }, - "execution_count": 23, + "execution_count": 6, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ - "Notebook last run (end-to-end): 2023-05-11 04:43:01.173110\n" + "Notebook last run (end-to-end): 2023-12-09 14:21:35.655154\n" ] } ] @@ -121,29 +131,29 @@ "colab": { "base_uri": "https://localhost:8080/" }, - "outputId": "9ed28bd4-c291-4644-95a2-7fa87f97b18f" + "outputId": "070ba8fb-f1c6-4016-d524-ae8c9cff397b" }, "source": [ "# Are we using a GPU?\n", "!nvidia-smi" ], - "execution_count": 1, + "execution_count": 7, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ - "Thu May 11 04:22:37 2023 \n", + "Sat Dec 9 14:21:36 2023 \n", "+-----------------------------------------------------------------------------+\n", - "| NVIDIA-SMI 525.85.12 Driver Version: 525.85.12 CUDA Version: 12.0 |\n", + "| NVIDIA-SMI 525.105.17 Driver Version: 525.105.17 CUDA Version: 12.0 |\n", "|-------------------------------+----------------------+----------------------+\n", "| GPU Name Persistence-M| Bus-Id Disp.A | Volatile Uncorr. ECC |\n", "| Fan Temp Perf Pwr:Usage/Cap| Memory-Usage | GPU-Util Compute M. |\n", "| | | MIG M. |\n", "|===============================+======================+======================|\n", - "| 0 NVIDIA A100-SXM... Off | 00000000:00:04.0 Off | 0 |\n", - "| N/A 40C P0 46W / 400W | 0MiB / 40960MiB | 0% Default |\n", - "| | | Disabled |\n", + "| 0 Tesla T4 Off | 00000000:00:04.0 Off | 0 |\n", + "| N/A 57C P8 10W / 70W | 0MiB / 15360MiB | 0% Default |\n", + "| | | N/A |\n", "+-------------------------------+----------------------+----------------------+\n", " \n", "+-----------------------------------------------------------------------------+\n", @@ -199,7 +209,7 @@ "source": [ "## Transfer leanring with TensorFlow Hub: Getting great results with 10% of the data\n", "\n", - "If you've been thinking, \"surely someone else has spent the time crafting the right model for the job...\" then you're in luck. \n", + "If you've been thinking, \"surely someone else has spent the time crafting the right model for the job...\" then you're in luck.\n", "\n", "For many of the problems you'll want to use deep learning for, chances are, a working model already exists.\n", "\n", @@ -248,7 +258,7 @@ "colab": { "base_uri": "https://localhost:8080/" }, - "outputId": "173ffe95-bb45-473b-94a7-dafca9158c07" + "outputId": "e3f4186a-9cd2-4b07-de05-54f7d04e9c57" }, "source": [ "# Get data (10% of labels)\n", @@ -262,22 +272,22 @@ "zip_ref.extractall()\n", "zip_ref.close()" ], - "execution_count": 2, + "execution_count": 8, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ - "--2023-05-11 04:22:37-- https://storage.googleapis.com/ztm_tf_course/food_vision/10_food_classes_10_percent.zip\n", - "Resolving storage.googleapis.com (storage.googleapis.com)... 74.125.68.128, 74.125.24.128, 142.250.4.128, ...\n", - "Connecting to storage.googleapis.com (storage.googleapis.com)|74.125.68.128|:443... connected.\n", + "--2023-12-09 14:21:37-- https://storage.googleapis.com/ztm_tf_course/food_vision/10_food_classes_10_percent.zip\n", + "Resolving storage.googleapis.com (storage.googleapis.com)... 74.125.142.207, 74.125.195.207, 172.253.117.207, ...\n", + "Connecting to storage.googleapis.com (storage.googleapis.com)|74.125.142.207|:443... connected.\n", "HTTP request sent, awaiting response... 200 OK\n", "Length: 168546183 (161M) [application/zip]\n", "Saving to: ‘10_food_classes_10_percent.zip’\n", "\n", - "10_food_classes_10_ 100%[===================>] 160.74M 19.2MB/s in 9.7s \n", + "10_food_classes_10_ 100%[===================>] 160.74M 152MB/s in 1.1s \n", "\n", - "2023-05-11 04:22:48 (16.5 MB/s) - ‘10_food_classes_10_percent.zip’ saved [168546183/168546183]\n", + "2023-12-09 14:21:38 (152 MB/s) - ‘10_food_classes_10_percent.zip’ saved [168546183/168546183]\n", "\n" ] } @@ -290,7 +300,7 @@ "colab": { "base_uri": "https://localhost:8080/" }, - "outputId": "269dbc74-88ae-4546-fbed-251133541a85" + "outputId": "43c48c55-b589-443d-c22d-13733abf58b4" }, "source": [ "# How many images in each folder?\n", @@ -300,7 +310,7 @@ "for dirpath, dirnames, filenames in os.walk(\"10_food_classes_10_percent\"):\n", " print(f\"There are {len(dirnames)} directories and {len(filenames)} images in '{dirpath}'.\")" ], - "execution_count": 3, + "execution_count": 9, "outputs": [ { "output_type": "stream", @@ -308,27 +318,27 @@ "text": [ "There are 2 directories and 0 images in '10_food_classes_10_percent'.\n", "There are 10 directories and 0 images in '10_food_classes_10_percent/test'.\n", - "There are 0 directories and 250 images in '10_food_classes_10_percent/test/chicken_wings'.\n", + "There are 0 directories and 250 images in '10_food_classes_10_percent/test/sushi'.\n", "There are 0 directories and 250 images in '10_food_classes_10_percent/test/fried_rice'.\n", - "There are 0 directories and 250 images in '10_food_classes_10_percent/test/ice_cream'.\n", + "There are 0 directories and 250 images in '10_food_classes_10_percent/test/pizza'.\n", + "There are 0 directories and 250 images in '10_food_classes_10_percent/test/ramen'.\n", "There are 0 directories and 250 images in '10_food_classes_10_percent/test/grilled_salmon'.\n", - "There are 0 directories and 250 images in '10_food_classes_10_percent/test/chicken_curry'.\n", + "There are 0 directories and 250 images in '10_food_classes_10_percent/test/chicken_wings'.\n", "There are 0 directories and 250 images in '10_food_classes_10_percent/test/hamburger'.\n", + "There are 0 directories and 250 images in '10_food_classes_10_percent/test/ice_cream'.\n", + "There are 0 directories and 250 images in '10_food_classes_10_percent/test/chicken_curry'.\n", "There are 0 directories and 250 images in '10_food_classes_10_percent/test/steak'.\n", - "There are 0 directories and 250 images in '10_food_classes_10_percent/test/pizza'.\n", - "There are 0 directories and 250 images in '10_food_classes_10_percent/test/sushi'.\n", - "There are 0 directories and 250 images in '10_food_classes_10_percent/test/ramen'.\n", "There are 10 directories and 0 images in '10_food_classes_10_percent/train'.\n", - "There are 0 directories and 75 images in '10_food_classes_10_percent/train/chicken_wings'.\n", + "There are 0 directories and 75 images in '10_food_classes_10_percent/train/sushi'.\n", "There are 0 directories and 75 images in '10_food_classes_10_percent/train/fried_rice'.\n", - "There are 0 directories and 75 images in '10_food_classes_10_percent/train/ice_cream'.\n", + "There are 0 directories and 75 images in '10_food_classes_10_percent/train/pizza'.\n", + "There are 0 directories and 75 images in '10_food_classes_10_percent/train/ramen'.\n", "There are 0 directories and 75 images in '10_food_classes_10_percent/train/grilled_salmon'.\n", - "There are 0 directories and 75 images in '10_food_classes_10_percent/train/chicken_curry'.\n", + "There are 0 directories and 75 images in '10_food_classes_10_percent/train/chicken_wings'.\n", "There are 0 directories and 75 images in '10_food_classes_10_percent/train/hamburger'.\n", - "There are 0 directories and 75 images in '10_food_classes_10_percent/train/steak'.\n", - "There are 0 directories and 75 images in '10_food_classes_10_percent/train/pizza'.\n", - "There are 0 directories and 75 images in '10_food_classes_10_percent/train/sushi'.\n", - "There are 0 directories and 75 images in '10_food_classes_10_percent/train/ramen'.\n" + "There are 0 directories and 75 images in '10_food_classes_10_percent/train/ice_cream'.\n", + "There are 0 directories and 75 images in '10_food_classes_10_percent/train/chicken_curry'.\n", + "There are 0 directories and 75 images in '10_food_classes_10_percent/train/steak'.\n" ] } ] @@ -362,7 +372,7 @@ "colab": { "base_uri": "https://localhost:8080/" }, - "outputId": "e847d896-1d24-40f1-9d8e-4f72fc76471f" + "outputId": "c7e717fd-bdca-44e1-94c1-fb13664435b0" }, "source": [ "# Setup data inputs\n", @@ -389,7 +399,7 @@ " batch_size=BATCH_SIZE,\n", " class_mode=\"categorical\")" ], - "execution_count": 4, + "execution_count": 10, "outputs": [ { "output_type": "stream", @@ -431,7 +441,7 @@ "\n", "We'll explore each of these overtime but for this notebook, we'll see how the TensorBoard callback can be used.\n", "\n", - "The TensorBoard callback can be accessed using [`tf.keras.callbacks.TensorBoard()`](https://www.tensorflow.org/api_docs/python/tf/keras/callbacks/TensorBoard). \n", + "The TensorBoard callback can be accessed using [`tf.keras.callbacks.TensorBoard()`](https://www.tensorflow.org/api_docs/python/tf/keras/callbacks/TensorBoard).\n", "\n", "Its main functionality is saving a model's training performance metrics to a specified `log_dir`.\n", "\n", @@ -451,15 +461,17 @@ "source": [ "# Create tensorboard callback (functionized because need to create a new one for each model)\n", "import datetime\n", - "def create_tensorboard_callback(dir_name, experiment_name):\n", - " log_dir = dir_name + \"/\" + experiment_name + \"/\" + datetime.datetime.now().strftime(\"%Y%m%d-%H%M%S\")\n", + "import os\n", + "def create_tensorboard_callback(experiment_name):\n", + " logfit_dir = \"logs/fit/\"\n", + " path_experiment = os.path.join(logfit_dir, experiment_name, datetime.datetime.now().strftime(\"%Y%m%d-%H%M%S\"))\n", " tensorboard_callback = tf.keras.callbacks.TensorBoard(\n", - " log_dir=log_dir\n", + " log_dir=path_experiment\n", " )\n", - " print(f\"Saving TensorBoard log files to: {log_dir}\")\n", + " print(f\"Saving TensorBoard log files to: {logfit_dir}\")\n", " return tensorboard_callback" ], - "execution_count": 5, + "execution_count": 11, "outputs": [] }, { @@ -504,7 +516,7 @@ "1. Go to [tfhub.dev](https://tfhub.dev/).\n", "2. Choose your problem domain, e.g. \"Image\" (we're using food images).\n", "3. Select your TF version, which in our case is TF2.\n", - "4. Remove all \"Problem domanin\" filters except for the problem you're working on. \n", + "4. Remove all \"Problem domanin\" filters except for the problem you're working on.\n", " * **Note:** \"Image feature vector\" can be used alongside almost any problem, we'll get to this soon.\n", "5. The models listed are all models which could potentially be used for your problem.\n", "\n", @@ -518,9 +530,9 @@ "\n", "To find our models, let's narrow down our search using the Architecture tab.\n", "\n", - "6. Select the Architecture tab on TensorFlow Hub and you'll see a dropdown menu of architecture names appear. \n", + "6. Select the Architecture tab on TensorFlow Hub and you'll see a dropdown menu of architecture names appear.\n", " * The rule of thumb here is generally, names with larger numbers means better performing models. For example, EfficientNetB4 performs better than EfficientNetB0.\n", - " * However, the tradeoff with larger numbers can mean they take longer to compute. \n", + " * However, the tradeoff with larger numbers can mean they take longer to compute.\n", "7. Select EfficientNetB0 and you should see [something like the following](https://tfhub.dev/s?module-type=image-classification,image-feature-vector&network-architecture=efficientnet-b0&tf-version=tf2):\n", "![](https://raw.githubusercontent.com/mrdbourke/tensorflow-deep-learning/main/images/04-tensorflow-hub-efficientnetb0.png)\n", "8. Clicking the one titled \"[efficientnet/b0/feature-vector](https://tfhub.dev/tensorflow/efficientnet/b0/feature-vector/1)\" brings us to a page with a button that says \"Copy URL\". That URL is what we can use to harness the power of EfficientNetB0.\n", @@ -530,19 +542,19 @@ "\n", "Great observation. This is where the differnet types of transfer learning come into play, as is, feature extraction and fine-tuning.\n", "\n", - "1. **\"As is\" transfer learning** is when you take a pretrained model as it is and apply it to your task without any changes. \n", + "1. **\"As is\" transfer learning** is when you take a pretrained model as it is and apply it to your task without any changes.\n", "\n", - " * For example, many computer vision models are pretrained on the ImageNet dataset which contains 1000 different classes of images. This means passing a single image to this model will produce 1000 different prediction probability values (1 for each class). \n", + " * For example, many computer vision models are pretrained on the ImageNet dataset which contains 1000 different classes of images. This means passing a single image to this model will produce 1000 different prediction probability values (1 for each class).\n", "\n", " * This is helpful if you have 1000 classes of image you'd like to classify and they're all the same as the ImageNet classes, however, it's not helpful if you want to classify only a small subset of classes (such as 10 different kinds of food). Model's with `\"/classification\"` in their name on TensorFlow Hub provide this kind of functionality.\n", "\n", - "2. **Feature extraction transfer learning** is when you take the underlying patterns (also called weights) a pretrained model has learned and adjust its outputs to be more suited to your problem. \n", + "2. **Feature extraction transfer learning** is when you take the underlying patterns (also called weights) a pretrained model has learned and adjust its outputs to be more suited to your problem.\n", "\n", - " * For example, say the pretrained model you were using had 236 different layers (EfficientNetB0 has 236 layers), but the top layer outputs 1000 classes because it was pretrained on ImageNet. To adjust this to your own problem, you might remove the original activation layer and replace it with your own but with the right number of output classes. The important part here is that **only the top few layers become trainable, the rest remain frozen**. \n", + " * For example, say the pretrained model you were using had 236 different layers (EfficientNetB0 has 236 layers), but the top layer outputs 1000 classes because it was pretrained on ImageNet. To adjust this to your own problem, you might remove the original activation layer and replace it with your own but with the right number of output classes. The important part here is that **only the top few layers become trainable, the rest remain frozen**.\n", "\n", " * This way all the underlying patterns remain in the rest of the layers and you can utilise them for your own problem. This kind of transfer learning is very helpful when your data is similar to the data a model has been pretrained on.\n", "\n", - "3. **Fine-tuning transfer learning** is when you take the underlying patterns (also called weights) of a pretrained model and adjust (fine-tune) them to your own problem. \n", + "3. **Fine-tuning transfer learning** is when you take the underlying patterns (also called weights) of a pretrained model and adjust (fine-tune) them to your own problem.\n", "\n", " * This usually means training **some, many or all** of the layers in the pretrained model. This is useful when you've got a large dataset (e.g. 100+ images per class) where your data is slightly different to the data the original model was trained on.\n", "\n", @@ -572,7 +584,7 @@ "import tensorflow_hub as hub\n", "from tensorflow.keras import layers" ], - "execution_count": 6, + "execution_count": 12, "outputs": [] }, { @@ -605,7 +617,7 @@ "# # New: EfficientNetB0 feature vector (version 2)\n", "# efficientnet_url = \"https://tfhub.dev/google/imagenet/efficientnet_v2_imagenet1k_b0/feature_vector/2\"" ], - "execution_count": 7, + "execution_count": 13, "outputs": [] }, { @@ -631,7 +643,7 @@ "source": [ "def create_model(model_url, num_classes=10):\n", " \"\"\"Takes a TensorFlow Hub URL and creates a Keras Sequential model with it.\n", - " \n", + "\n", " Args:\n", " model_url (str): A TensorFlow Hub feature extraction URL.\n", " num_classes (int): Number of output neurons in output layer,\n", @@ -646,16 +658,16 @@ " trainable=False, # freeze the underlying patterns\n", " name='feature_extraction_layer',\n", " input_shape=IMAGE_SHAPE+(3,)) # define the input image shape\n", - " \n", + "\n", " # Create our own model\n", " model = tf.keras.Sequential([\n", " feature_extractor_layer, # use the feature extraction layer as the base\n", - " layers.Dense(num_classes, activation='softmax', name='output_layer') # create our own output layer \n", + " layers.Dense(num_classes, activation='softmax', name='output_layer') # create our own output layer\n", " ])\n", "\n", " return model" ], - "execution_count": 8, + "execution_count": 14, "outputs": [] }, { @@ -683,7 +695,7 @@ " optimizer=tf.keras.optimizers.Adam(),\n", " metrics=['accuracy'])" ], - "execution_count": 9, + "execution_count": 15, "outputs": [] }, { @@ -715,7 +727,7 @@ "colab": { "base_uri": "https://localhost:8080/" }, - "outputId": "6fa89e67-d9e7-43c0-f2a9-93cb92a7f011" + "outputId": "7be7711c-d788-4273-b523-b116f831ddf7" }, "source": [ "# Fit the model\n", @@ -725,26 +737,25 @@ " validation_data=test_data,\n", " validation_steps=len(test_data),\n", " # Add TensorBoard callback to model (callbacks parameter takes a list)\n", - " callbacks=[create_tensorboard_callback(dir_name=\"tensorflow_hub\", # save experiment logs here\n", - " experiment_name=\"resnet50V2\")]) # name of log files" + " callbacks=[create_tensorboard_callback(experiment_name=\"resnet50V2\")]) # name of log files" ], - "execution_count": 10, + "execution_count": 16, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ - "Saving TensorBoard log files to: tensorflow_hub/resnet50V2/20230511-042304\n", + "Saving TensorBoard log files to: logs/fit/\n", "Epoch 1/5\n", - "24/24 [==============================] - 28s 680ms/step - loss: 1.7915 - accuracy: 0.3880 - val_loss: 1.1463 - val_accuracy: 0.6368\n", + "24/24 [==============================] - 25s 536ms/step - loss: 1.8709 - accuracy: 0.3787 - val_loss: 1.1472 - val_accuracy: 0.6352\n", "Epoch 2/5\n", - "24/24 [==============================] - 14s 620ms/step - loss: 0.8710 - accuracy: 0.7560 - val_loss: 0.8359 - val_accuracy: 0.7352\n", + "24/24 [==============================] - 10s 427ms/step - loss: 0.8842 - accuracy: 0.7413 - val_loss: 0.8406 - val_accuracy: 0.7360\n", "Epoch 3/5\n", - "24/24 [==============================] - 14s 618ms/step - loss: 0.6160 - accuracy: 0.8373 - val_loss: 0.7385 - val_accuracy: 0.7676\n", + "24/24 [==============================] - 11s 457ms/step - loss: 0.5991 - accuracy: 0.8373 - val_loss: 0.7487 - val_accuracy: 0.7640\n", "Epoch 4/5\n", - "24/24 [==============================] - 15s 624ms/step - loss: 0.4705 - accuracy: 0.8907 - val_loss: 0.7016 - val_accuracy: 0.7728\n", + "24/24 [==============================] - 11s 465ms/step - loss: 0.4632 - accuracy: 0.8760 - val_loss: 0.7091 - val_accuracy: 0.7644\n", "Epoch 5/5\n", - "24/24 [==============================] - 15s 640ms/step - loss: 0.3744 - accuracy: 0.9200 - val_loss: 0.6764 - val_accuracy: 0.7772\n" + "24/24 [==============================] - 12s 526ms/step - loss: 0.3769 - accuracy: 0.9147 - val_loss: 0.6749 - val_accuracy: 0.7828\n" ] } ] @@ -755,7 +766,7 @@ "id": "i5SuOe672UJi" }, "source": [ - "Wow! \n", + "Wow!\n", "\n", "It seems that after only 5 epochs, the ResNetV250 feature extraction model was able to blow any of the architectures we made out of the water, achieving around 90% accuracy on the training set and nearly 80% accuracy on the test set...**with only 10 percent of the training images!**\n", "\n", @@ -777,7 +788,7 @@ "def plot_loss_curves(history):\n", " \"\"\"\n", " Returns separate loss curves for training and validation metrics.\n", - " \"\"\" \n", + " \"\"\"\n", " loss = history.history['loss']\n", " val_loss = history.history['val_loss']\n", "\n", @@ -801,7 +812,7 @@ " plt.xlabel('Epochs')\n", " plt.legend();" ], - "execution_count": 11, + "execution_count": 17, "outputs": [] }, { @@ -812,12 +823,12 @@ "base_uri": "https://localhost:8080/", "height": 927 }, - "outputId": "67fb28a3-7ff5-4d01-d516-b37bd3b3cf2e" + "outputId": "20c25e2d-7bf1-4c56-9622-4d084ce95500" }, "source": [ "plot_loss_curves(resnet_history)" ], - "execution_count": 12, + "execution_count": 18, "outputs": [ { "output_type": "display_data", @@ -825,7 +836,7 @@ "text/plain": [ "
" ], - "image/png": "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\n" + "image/png": "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\n" }, "metadata": {} }, @@ -835,7 +846,7 @@ "text/plain": [ "
" ], - "image/png": "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\n" + "image/png": "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\n" }, "metadata": {} } @@ -857,13 +868,13 @@ "colab": { "base_uri": "https://localhost:8080/" }, - "outputId": "5090ca6c-4fb4-436e-f727-b07412feea17" + "outputId": "51a006ee-fbeb-4be3-be83-2b0e904a2b91" }, "source": [ - "# Resnet summary \n", + "# Resnet summary\n", "resnet_model.summary()" ], - "execution_count": 13, + "execution_count": 19, "outputs": [ { "output_type": "stream", @@ -873,15 +884,15 @@ "_________________________________________________________________\n", " Layer (type) Output Shape Param # \n", "=================================================================\n", - " feature_extraction_layer (K (None, 2048) 23564800 \n", - " erasLayer) \n", + " feature_extraction_layer ( (None, 2048) 23564800 \n", + " KerasLayer) \n", " \n", " output_layer (Dense) (None, 10) 20490 \n", " \n", "=================================================================\n", - "Total params: 23,585,290\n", - "Trainable params: 20,490\n", - "Non-trainable params: 23,564,800\n", + "Total params: 23585290 (89.97 MB)\n", + "Trainable params: 20490 (80.04 KB)\n", + "Non-trainable params: 23564800 (89.89 MB)\n", "_________________________________________________________________\n" ] } @@ -909,7 +920,7 @@ "colab": { "base_uri": "https://localhost:8080/" }, - "outputId": "7c0e639d-2986-401a-e2b3-7214df57645d" + "outputId": "1303a27e-4375-402b-f517-b9491ba35daa" }, "source": [ "# Create model\n", @@ -921,33 +932,31 @@ " optimizer=tf.keras.optimizers.Adam(),\n", " metrics=['accuracy'])\n", "\n", - "# Fit EfficientNet model \n", + "# Fit EfficientNet model\n", "efficientnet_history = efficientnet_model.fit(train_data_10_percent, # only use 10% of training data\n", " epochs=5, # train for 5 epochs\n", " steps_per_epoch=len(train_data_10_percent),\n", " validation_data=test_data,\n", " validation_steps=len(test_data),\n", - " callbacks=[create_tensorboard_callback(dir_name=\"tensorflow_hub\", \n", - " # Track logs under different experiment name\n", - " experiment_name=\"efficientnetB0\")])" + " callbacks=[create_tensorboard_callback(experiment_name=\"efficientnetB0\")])" ], - "execution_count": 14, + "execution_count": 20, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ - "Saving TensorBoard log files to: tensorflow_hub/efficientnetB0/20230511-042443\n", + "Saving TensorBoard log files to: logs/fit/\n", "Epoch 1/5\n", - "24/24 [==============================] - 26s 693ms/step - loss: 1.7622 - accuracy: 0.5053 - val_loss: 1.2434 - val_accuracy: 0.7268\n", + "24/24 [==============================] - 21s 513ms/step - loss: 1.8954 - accuracy: 0.3960 - val_loss: 1.3485 - val_accuracy: 0.7032\n", "Epoch 2/5\n", - "24/24 [==============================] - 15s 634ms/step - loss: 1.0120 - accuracy: 0.7693 - val_loss: 0.8459 - val_accuracy: 0.8240\n", + "24/24 [==============================] - 13s 579ms/step - loss: 1.0871 - accuracy: 0.7827 - val_loss: 0.8911 - val_accuracy: 0.8028\n", "Epoch 3/5\n", - "24/24 [==============================] - 15s 642ms/step - loss: 0.7289 - accuracy: 0.8347 - val_loss: 0.6823 - val_accuracy: 0.8460\n", + "24/24 [==============================] - 13s 555ms/step - loss: 0.7688 - accuracy: 0.8347 - val_loss: 0.7111 - val_accuracy: 0.8380\n", "Epoch 4/5\n", - "24/24 [==============================] - 15s 637ms/step - loss: 0.5871 - accuracy: 0.8667 - val_loss: 0.6004 - val_accuracy: 0.8592\n", + "24/24 [==============================] - 12s 534ms/step - loss: 0.6170 - accuracy: 0.8613 - val_loss: 0.6215 - val_accuracy: 0.8488\n", "Epoch 5/5\n", - "24/24 [==============================] - 14s 620ms/step - loss: 0.5013 - accuracy: 0.8947 - val_loss: 0.5504 - val_accuracy: 0.8636\n" + "24/24 [==============================] - 12s 535ms/step - loss: 0.5195 - accuracy: 0.8827 - val_loss: 0.5655 - val_accuracy: 0.8564\n" ] } ] @@ -975,12 +984,12 @@ "base_uri": "https://localhost:8080/", "height": 927 }, - "outputId": "98a2f8a4-ffaf-48ad-8cab-22f532f8097a" + "outputId": "73e4b2ca-0814-4182-ece6-035e64479698" }, "source": [ "plot_loss_curves(efficientnet_history)" ], - "execution_count": 15, + "execution_count": 21, "outputs": [ { "output_type": "display_data", @@ -988,7 +997,7 @@ "text/plain": [ "
" ], - "image/png": "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\n" + "image/png": "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\n" }, "metadata": {} }, @@ -998,7 +1007,7 @@ "text/plain": [ "
" ], - "image/png": "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\n" + "image/png": "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\n" }, "metadata": {} } @@ -1022,12 +1031,12 @@ "colab": { "base_uri": "https://localhost:8080/" }, - "outputId": "5b8f7da3-f0db-4f8e-fe53-1a2124c223ff" + "outputId": "95ea8168-32de-4cb7-8c16-91b433e1f7ba" }, "source": [ "efficientnet_model.summary()" ], - "execution_count": 16, + "execution_count": 22, "outputs": [ { "output_type": "stream", @@ -1037,15 +1046,15 @@ "_________________________________________________________________\n", " Layer (type) Output Shape Param # \n", "=================================================================\n", - " feature_extraction_layer (K (None, 1280) 4049564 \n", - " erasLayer) \n", + " feature_extraction_layer ( (None, 1280) 4049564 \n", + " KerasLayer) \n", " \n", " output_layer (Dense) (None, 10) 12810 \n", " \n", "=================================================================\n", - "Total params: 4,062,374\n", - "Trainable params: 12,810\n", - "Non-trainable params: 4,049,564\n", + "Total params: 4062374 (15.50 MB)\n", + "Trainable params: 12810 (50.04 KB)\n", + "Non-trainable params: 4049564 (15.45 MB)\n", "_________________________________________________________________\n" ] } @@ -1068,7 +1077,7 @@ "source": [ "## Comparing models using TensorBoard\n", "\n", - "Alright, even though we've already compared the performance of our two models by looking at the accuracy scores. But what if you had more than two models? \n", + "Alright, even though we've already compared the performance of our two models by looking at the accuracy scores. But what if you had more than two models?\n", "\n", "That's where an experiment tracking tool like [TensorBoard](https://www.tensorflow.org/tensorboard) (preinstalled in Google Colab) comes in.\n", "\n", @@ -1086,8 +1095,8 @@ "Upload TensorBoard dev records\n", "\n", "!tensorboard dev upload --logdir ./tensorflow_hub/ \\\n", - " --name \"EfficientNetB0 vs. ResNet50V2\" \\ \n", - " --description \"Comparing two different TF Hub feature extraction models architectures using 10% of training images\" \\ \n", + " --name \"EfficientNetB0 vs. ResNet50V2\" \\\n", + " --description \"Comparing two different TF Hub feature extraction models architectures using 10% of training images\" \\\n", " --one_shot\n", "```\n", "\n", @@ -1100,6 +1109,252 @@ "Running the `tensorboard dev upload` command will first ask you to authorize the upload to TensorBoard.dev. After you've authorized the upload, your log files will be uploaded." ] }, + { + "cell_type": "code", + "source": [ + "%tensorboard --logdir logs/fit" + ], + "metadata": { + "colab": { + "resources": { + "https://localhost:6006/?tensorboardColab=true": { + "data": "<!doctype html><meta name="tb-relative-root" content="./"><!doctype html><!--
@license
Copyright 2019 The TensorFlow Authors. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
--><html><head><meta charset="utf-8">
<title>TensorBoard</title>
<link rel="shortcut icon" href="data:image/png;base64,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">
<link rel="apple-touch-icon" href="data:image/png;base64,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">

<style>
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto'), local('Roboto-Regular'), url(/font-roboto/uYECMKoHcO9x1wdmbyHIm3-_kf6ByYO6CLYdB4HQE-Y.woff2) format('woff2');
  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto'), local('Roboto-Regular'), url(/font-roboto/sTdaA6j0Psb920Vjv-mrzH-_kf6ByYO6CLYdB4HQE-Y.woff2) format('woff2');
  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto'), local('Roboto-Regular'), url(/font-roboto/_VYFx-s824kXq_Ul2BHqYH-_kf6ByYO6CLYdB4HQE-Y.woff2) format('woff2');
  unicode-range: U+0370-03FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto'), local('Roboto-Regular'), url(/font-roboto/tnj4SB6DNbdaQnsM8CFqBX-_kf6ByYO6CLYdB4HQE-Y.woff2) format('woff2');
  unicode-range: U+1F00-1FFF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto'), local('Roboto-Regular'), url(/font-roboto/oMMgfZMQthOryQo9n22dcuvvDin1pK8aKteLpeZ5c0A.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto'), local('Roboto-Regular'), url(/font-roboto/Ks_cVxiCiwUWVsFWFA3Bjn-_kf6ByYO6CLYdB4HQE-Y.woff2) format('woff2');
  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto'), local('Roboto-Regular'), url(/font-roboto/NJ4vxlgWwWbEsv18dAhqnn-_kf6ByYO6CLYdB4HQE-Y.woff2) format('woff2');
  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Bold'), local('Roboto-Bold'), url(/font-roboto/isZ-wbCXNKAbnjo6_TwHToX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Bold'), local('Roboto-Bold'), url(/font-roboto/77FXFjRbGzN4aCrSFhlh3oX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Bold'), local('Roboto-Bold'), url(/font-roboto/jSN2CGVDbcVyCnfJfjSdfIX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0370-03FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Bold'), local('Roboto-Bold'), url(/font-roboto/UX6i4JxQDm3fVTc1CPuwqoX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+1F00-1FFF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Bold'), local('Roboto-Bold'), url(/font-roboto/d-6IYplOFocCacKzxwXSOJBw1xU1rKptJj_0jans920.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Bold'), local('Roboto-Bold'), url(/font-roboto/97uahxiqZRoncBaCEI3aW4X0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Bold'), local('Roboto-Bold'), url(/font-roboto/PwZc-YbIL414wB9rB1IAPYX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 700;
  src: local('Roboto Bold Italic'), local('Roboto-BoldItalic'), url(/font-roboto/t6Nd4cfPRhZP44Q5QAjcC14sYYdJg5dU2qzJEVSuta0.woff2) format('woff2');
  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 700;
  src: local('Roboto Bold Italic'), local('Roboto-BoldItalic'), url(/font-roboto/t6Nd4cfPRhZP44Q5QAjcC_ZraR2Tg8w2lzm7kLNL0-w.woff2) format('woff2');
  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 700;
  src: local('Roboto Bold Italic'), local('Roboto-BoldItalic'), url(/font-roboto/t6Nd4cfPRhZP44Q5QAjcCwt_Rm691LTebKfY2ZkKSmI.woff2) format('woff2');
  unicode-range: U+0370-03FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 700;
  src: local('Roboto Bold Italic'), local('Roboto-BoldItalic'), url(/font-roboto/t6Nd4cfPRhZP44Q5QAjcC1BW26QxpSj-_ZKm_xT4hWw.woff2) format('woff2');
  unicode-range: U+1F00-1FFF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 700;
  src: local('Roboto Bold Italic'), local('Roboto-BoldItalic'), url(/font-roboto/t6Nd4cfPRhZP44Q5QAjcC4gp9Q8gbYrhqGlRav_IXfk.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 700;
  src: local('Roboto Bold Italic'), local('Roboto-BoldItalic'), url(/font-roboto/t6Nd4cfPRhZP44Q5QAjcC6E8kM4xWR1_1bYURRojRGc.woff2) format('woff2');
  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 700;
  src: local('Roboto Bold Italic'), local('Roboto-BoldItalic'), url(/font-roboto/t6Nd4cfPRhZP44Q5QAjcC9DiNsR5a-9Oe_Ivpu8XWlY.woff2) format('woff2');
  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 400;
  src: local('Roboto Italic'), local('Roboto-Italic'), url(/font-roboto/OpXUqTo0UgQQhGj_SFdLWBkAz4rYn47Zy2rvigWQf6w.woff2) format('woff2');
  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 400;
  src: local('Roboto Italic'), local('Roboto-Italic'), url(/font-roboto/WxrXJa0C3KdtC7lMafG4dRkAz4rYn47Zy2rvigWQf6w.woff2) format('woff2');
  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 400;
  src: local('Roboto Italic'), local('Roboto-Italic'), url(/font-roboto/cDKhRaXnQTOVbaoxwdOr9xkAz4rYn47Zy2rvigWQf6w.woff2) format('woff2');
  unicode-range: U+0370-03FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 400;
  src: local('Roboto Italic'), local('Roboto-Italic'), url(/font-roboto/1hZf02POANh32k2VkgEoUBkAz4rYn47Zy2rvigWQf6w.woff2) format('woff2');
  unicode-range: U+1F00-1FFF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 400;
  src: local('Roboto Italic'), local('Roboto-Italic'), url(/font-roboto/vPcynSL0qHq_6dX7lKVByXYhjbSpvc47ee6xR_80Hnw.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 400;
  src: local('Roboto Italic'), local('Roboto-Italic'), url(/font-roboto/vSzulfKSK0LLjjfeaxcREhkAz4rYn47Zy2rvigWQf6w.woff2) format('woff2');
  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 400;
  src: local('Roboto Italic'), local('Roboto-Italic'), url(/font-roboto/K23cxWVTrIFD6DJsEVi07RkAz4rYn47Zy2rvigWQf6w.woff2) format('woff2');
  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 300;
  src: local('Roboto Light'), local('Roboto-Light'), url(/font-roboto/Fl4y0QdOxyyTHEGMXX8kcYX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 300;
  src: local('Roboto Light'), local('Roboto-Light'), url(/font-roboto/0eC6fl06luXEYWpBSJvXCIX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 300;
  src: local('Roboto Light'), local('Roboto-Light'), url(/font-roboto/I3S1wsgSg9YCurV6PUkTOYX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0370-03FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 300;
  src: local('Roboto Light'), local('Roboto-Light'), url(/font-roboto/-L14Jk06m6pUHB-5mXQQnYX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+1F00-1FFF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 300;
  src: local('Roboto Light'), local('Roboto-Light'), url(/font-roboto/Hgo13k-tfSpn0qi1SFdUfZBw1xU1rKptJj_0jans920.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 300;
  src: local('Roboto Light'), local('Roboto-Light'), url(/font-roboto/Pru33qjShpZSmG3z6VYwnYX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 300;
  src: local('Roboto Light'), local('Roboto-Light'), url(/font-roboto/NYDWBdD4gIq26G5XYbHsFIX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 300;
  src: local('Roboto Light Italic'), local('Roboto-LightItalic'), url(/font-roboto/7m8l7TlFO-S3VkhHuR0at14sYYdJg5dU2qzJEVSuta0.woff2) format('woff2');
  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 300;
  src: local('Roboto Light Italic'), local('Roboto-LightItalic'), url(/font-roboto/7m8l7TlFO-S3VkhHuR0at_ZraR2Tg8w2lzm7kLNL0-w.woff2) format('woff2');
  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 300;
  src: local('Roboto Light Italic'), local('Roboto-LightItalic'), url(/font-roboto/7m8l7TlFO-S3VkhHuR0atwt_Rm691LTebKfY2ZkKSmI.woff2) format('woff2');
  unicode-range: U+0370-03FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 300;
  src: local('Roboto Light Italic'), local('Roboto-LightItalic'), url(/font-roboto/7m8l7TlFO-S3VkhHuR0at1BW26QxpSj-_ZKm_xT4hWw.woff2) format('woff2');
  unicode-range: U+1F00-1FFF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 300;
  src: local('Roboto Light Italic'), local('Roboto-LightItalic'), url(/font-roboto/7m8l7TlFO-S3VkhHuR0at4gp9Q8gbYrhqGlRav_IXfk.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 300;
  src: local('Roboto Light Italic'), local('Roboto-LightItalic'), url(/font-roboto/7m8l7TlFO-S3VkhHuR0at6E8kM4xWR1_1bYURRojRGc.woff2) format('woff2');
  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 300;
  src: local('Roboto Light Italic'), local('Roboto-LightItalic'), url(/font-roboto/7m8l7TlFO-S3VkhHuR0at9DiNsR5a-9Oe_Ivpu8XWlY.woff2) format('woff2');
  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 500;
  src: local('Roboto Medium'), local('Roboto-Medium'), url(/font-roboto/oHi30kwQWvpCWqAhzHcCSIX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 500;
  src: local('Roboto Medium'), local('Roboto-Medium'), url(/font-roboto/ZLqKeelYbATG60EpZBSDy4X0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 500;
  src: local('Roboto Medium'), local('Roboto-Medium'), url(/font-roboto/mx9Uck6uB63VIKFYnEMXrYX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0370-03FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 500;
  src: local('Roboto Medium'), local('Roboto-Medium'), url(/font-roboto/rGvHdJnr2l75qb0YND9NyIX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+1F00-1FFF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 500;
  src: local('Roboto Medium'), local('Roboto-Medium'), url(/font-roboto/RxZJdnzeo3R5zSexge8UUZBw1xU1rKptJj_0jans920.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 500;
  src: local('Roboto Medium'), local('Roboto-Medium'), url(/font-roboto/oOeFwZNlrTefzLYmlVV1UIX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 500;
  src: local('Roboto Medium'), local('Roboto-Medium'), url(/font-roboto/mbmhprMH69Zi6eEPBYVFhYX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 500;
  src: local('Roboto Medium Italic'), local('Roboto-MediumItalic'), url(/font-roboto/OLffGBTaF0XFOW1gnuHF0V4sYYdJg5dU2qzJEVSuta0.woff2) format('woff2');
  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 500;
  src: local('Roboto Medium Italic'), local('Roboto-MediumItalic'), url(/font-roboto/OLffGBTaF0XFOW1gnuHF0fZraR2Tg8w2lzm7kLNL0-w.woff2) format('woff2');
  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 500;
  src: local('Roboto Medium Italic'), local('Roboto-MediumItalic'), url(/font-roboto/OLffGBTaF0XFOW1gnuHF0Qt_Rm691LTebKfY2ZkKSmI.woff2) format('woff2');
  unicode-range: U+0370-03FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 500;
  src: local('Roboto Medium Italic'), local('Roboto-MediumItalic'), url(/font-roboto/OLffGBTaF0XFOW1gnuHF0VBW26QxpSj-_ZKm_xT4hWw.woff2) format('woff2');
  unicode-range: U+1F00-1FFF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 500;
  src: local('Roboto Medium Italic'), local('Roboto-MediumItalic'), url(/font-roboto/OLffGBTaF0XFOW1gnuHF0Ygp9Q8gbYrhqGlRav_IXfk.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 500;
  src: local('Roboto Medium Italic'), local('Roboto-MediumItalic'), url(/font-roboto/OLffGBTaF0XFOW1gnuHF0aE8kM4xWR1_1bYURRojRGc.woff2) format('woff2');
  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 500;
  src: local('Roboto Medium Italic'), local('Roboto-MediumItalic'), url(/font-roboto/OLffGBTaF0XFOW1gnuHF0dDiNsR5a-9Oe_Ivpu8XWlY.woff2) format('woff2');
  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto Mono'), local('RobotoMono-Regular'), url(/font-roboto/hMqPNLsu_dywMa4C_DEpY14sYYdJg5dU2qzJEVSuta0.woff2) format('woff2');
  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto Mono'), local('RobotoMono-Regular'), url(/font-roboto/hMqPNLsu_dywMa4C_DEpY_ZraR2Tg8w2lzm7kLNL0-w.woff2) format('woff2');
  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto Mono'), local('RobotoMono-Regular'), url(/font-roboto/hMqPNLsu_dywMa4C_DEpYwt_Rm691LTebKfY2ZkKSmI.woff2) format('woff2');
  unicode-range: U+0370-03FF;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto Mono'), local('RobotoMono-Regular'), url(/font-roboto/hMqPNLsu_dywMa4C_DEpY1BW26QxpSj-_ZKm_xT4hWw.woff2) format('woff2');
  unicode-range: U+1F00-1FFF;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto Mono'), local('RobotoMono-Regular'), url(/font-roboto/hMqPNLsu_dywMa4C_DEpY4gp9Q8gbYrhqGlRav_IXfk.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto Mono'), local('RobotoMono-Regular'), url(/font-roboto/hMqPNLsu_dywMa4C_DEpY6E8kM4xWR1_1bYURRojRGc.woff2) format('woff2');
  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto Mono'), local('RobotoMono-Regular'), url(/font-roboto/hMqPNLsu_dywMa4C_DEpY9DiNsR5a-9Oe_Ivpu8XWlY.woff2) format('woff2');
  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Mono Bold'), local('RobotoMono-Bold'), url(/font-roboto/N4duVc9C58uwPiY8_59Fz1x-M1I1w5OMiqnVF8xBLhU.woff2) format('woff2');
  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Mono Bold'), local('RobotoMono-Bold'), url(/font-roboto/N4duVc9C58uwPiY8_59FzwXaAXup5mZlfK6xRLrhsco.woff2) format('woff2');
  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Mono Bold'), local('RobotoMono-Bold'), url(/font-roboto/N4duVc9C58uwPiY8_59Fzwn6Wqxo-xwxilDXPU8chVU.woff2) format('woff2');
  unicode-range: U+0370-03FF;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Mono Bold'), local('RobotoMono-Bold'), url(/font-roboto/N4duVc9C58uwPiY8_59Fz1T7aJLK6nKpn36IMwTcMMc.woff2) format('woff2');
  unicode-range: U+1F00-1FFF;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Mono Bold'), local('RobotoMono-Bold'), url(/font-roboto/N4duVc9C58uwPiY8_59Fz_79_ZuUxCigM2DespTnFaw.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Mono Bold'), local('RobotoMono-Bold'), url(/font-roboto/N4duVc9C58uwPiY8_59Fz4gd9OEPUCN3AdYW0e8tat4.woff2) format('woff2');
  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Mono Bold'), local('RobotoMono-Bold'), url(/font-roboto/N4duVc9C58uwPiY8_59Fz8bIQSYZnWLaWC9QNCpTK_U.woff2) format('woff2');
  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;
}
</style>



<style>.mat-ripple{overflow:hidden;position:relative}.mat-ripple:not(:empty){transform:translateZ(0)}.mat-ripple.mat-ripple-unbounded{overflow:visible}.mat-ripple-element{position:absolute;border-radius:50%;pointer-events:none;transition:opacity,transform 0ms cubic-bezier(0, 0, 0.2, 1);transform:scale3d(0, 0, 0)}.cdk-high-contrast-active .mat-ripple-element{display:none}.cdk-visually-hidden{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;white-space:nowrap;outline:0;-webkit-appearance:none;-moz-appearance:none;left:0}[dir=rtl] .cdk-visually-hidden{left:auto;right:0}.cdk-overlay-container,.cdk-global-overlay-wrapper{pointer-events:none;top:0;left:0;height:100%;width:100%}.cdk-overlay-container{position:fixed;z-index:1000}.cdk-overlay-container:empty{display:none}.cdk-global-overlay-wrapper{display:flex;position:absolute;z-index:1000}.cdk-overlay-pane{position:absolute;pointer-events:auto;box-sizing:border-box;z-index:1000;display:flex;max-width:100%;max-height:100%}.cdk-overlay-backdrop{position:absolute;top:0;bottom:0;left:0;right:0;z-index:1000;pointer-events:auto;-webkit-tap-highlight-color:rgba(0,0,0,0);transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1);opacity:0}.cdk-overlay-backdrop.cdk-overlay-backdrop-showing{opacity:1}.cdk-high-contrast-active .cdk-overlay-backdrop.cdk-overlay-backdrop-showing{opacity:.6}.cdk-overlay-dark-backdrop{background:rgba(0,0,0,.32)}.cdk-overlay-transparent-backdrop{transition:visibility 1ms linear,opacity 1ms linear;visibility:hidden;opacity:1}.cdk-overlay-transparent-backdrop.cdk-overlay-backdrop-showing{opacity:0;visibility:visible}.cdk-overlay-backdrop-noop-animation{transition:none}.cdk-overlay-connected-position-bounding-box{position:absolute;z-index:1000;display:flex;flex-direction:column;min-width:1px;min-height:1px}.cdk-global-scrollblock{position:fixed;width:100%;overflow-y:scroll}textarea.cdk-textarea-autosize{resize:none}textarea.cdk-textarea-autosize-measuring{padding:2px 0 !important;box-sizing:content-box !important;height:auto !important;overflow:hidden !important}textarea.cdk-textarea-autosize-measuring-firefox{padding:2px 0 !important;box-sizing:content-box !important;height:0 !important}@keyframes cdk-text-field-autofill-start{/*!*/}@keyframes cdk-text-field-autofill-end{/*!*/}.cdk-text-field-autofill-monitored:-webkit-autofill{animation:cdk-text-field-autofill-start 0s 1ms}.cdk-text-field-autofill-monitored:not(:-webkit-autofill){animation:cdk-text-field-autofill-end 0s 1ms}.mat-focus-indicator{position:relative}.mat-focus-indicator::before{top:0;left:0;right:0;bottom:0;position:absolute;box-sizing:border-box;pointer-events:none;display:var(--mat-focus-indicator-display, none);border:var(--mat-focus-indicator-border-width, 3px) var(--mat-focus-indicator-border-style, solid) var(--mat-focus-indicator-border-color, transparent);border-radius:var(--mat-focus-indicator-border-radius, 4px)}.mat-focus-indicator:focus::before{content:""}.cdk-high-contrast-active{--mat-focus-indicator-display: block}.mat-mdc-focus-indicator{position:relative}.mat-mdc-focus-indicator::before{top:0;left:0;right:0;bottom:0;position:absolute;box-sizing:border-box;pointer-events:none;display:var(--mat-mdc-focus-indicator-display, none);border:var(--mat-mdc-focus-indicator-border-width, 3px) var(--mat-mdc-focus-indicator-border-style, solid) var(--mat-mdc-focus-indicator-border-color, transparent);border-radius:var(--mat-mdc-focus-indicator-border-radius, 4px)}.mat-mdc-focus-indicator:focus::before{content:""}.cdk-high-contrast-active{--mat-mdc-focus-indicator-display: block}.mat-h1,.mat-headline,.mat-typography .mat-h1,.mat-typography .mat-headline,.mat-typography h1{font-size:24px;font-weight:400;line-height:32px;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h2,.mat-title,.mat-typography .mat-h2,.mat-typography .mat-title,.mat-typography h2{font-size:20px;font-weight:500;line-height:32px;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h3,.mat-subheading-2,.mat-typography .mat-h3,.mat-typography .mat-subheading-2,.mat-typography h3{font-size:16px;font-weight:400;line-height:28px;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h4,.mat-subheading-1,.mat-typography .mat-h4,.mat-typography .mat-subheading-1,.mat-typography h4{font-size:15px;font-weight:400;line-height:24px;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h5,.mat-typography .mat-h5,.mat-typography h5{font:400 calc(14px * 0.83)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-h6,.mat-typography .mat-h6,.mat-typography h6{font:400 calc(14px * 0.67)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-body-strong,.mat-body-2,.mat-typography .mat-body-strong,.mat-typography .mat-body-2{font-size:14px;font-weight:500;line-height:24px;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body,.mat-body-1,.mat-typography .mat-body,.mat-typography .mat-body-1,.mat-typography{font-size:14px;font-weight:400;line-height:20px;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body p,.mat-body-1 p,.mat-typography .mat-body p,.mat-typography .mat-body-1 p,.mat-typography p{margin:0 0 12px}.mat-small,.mat-caption,.mat-typography .mat-small,.mat-typography .mat-caption{font-size:12px;font-weight:400;line-height:20px;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-display-4,.mat-typography .mat-display-4{font-size:112px;font-weight:300;line-height:112px;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.05em;margin:0 0 56px}.mat-display-3,.mat-typography .mat-display-3{font-size:56px;font-weight:400;line-height:56px;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.02em;margin:0 0 64px}.mat-display-2,.mat-typography .mat-display-2{font-size:45px;font-weight:400;line-height:48px;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.005em;margin:0 0 64px}.mat-display-1,.mat-typography .mat-display-1{font-size:34px;font-weight:400;line-height:40px;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 64px}.mat-badge-content{font-weight:600;font-size:12px;font-family:Roboto, "Helvetica Neue", sans-serif}.mat-badge-small .mat-badge-content{font-size:9px}.mat-badge-large .mat-badge-content{font-size:24px}.mat-bottom-sheet-container{font-size:14px;font-weight:400;line-height:20px;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-button-toggle{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-calendar{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-calendar-body{font-size:13px}.mat-calendar-body-label,.mat-calendar-period-button{font-size:14px;font-weight:500}.mat-calendar-table-header th{font-size:11px;font-weight:400}.mat-expansion-panel-header{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:15px;font-weight:400}.mat-expansion-panel-content{font-size:14px;font-weight:400;line-height:20px;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-grid-tile-header,.mat-grid-tile-footer{font-size:14px}.mat-grid-tile-header .mat-line,.mat-grid-tile-footer .mat-line{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-grid-tile-header .mat-line:nth-child(n+2),.mat-grid-tile-footer .mat-line:nth-child(n+2){font-size:12px}.mat-stepper-vertical,.mat-stepper-horizontal{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-step-label{font-size:14px;font-weight:400}.mat-step-sub-label-error{font-weight:normal}.mat-step-label-error{font-size:14px}.mat-step-label-selected{font-size:14px;font-weight:500}.mat-toolbar,.mat-toolbar h1,.mat-toolbar h2,.mat-toolbar h3,.mat-toolbar h4,.mat-toolbar h5,.mat-toolbar h6{font-size:20px;font-weight:500;line-height:32px;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0}.mat-tree{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tree-node,.mat-nested-tree-node{font-weight:400;font-size:14px}.mat-option{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:16px}.mat-optgroup-label{font-size:14px;font-weight:500;line-height:24px;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-button,.mat-raised-button,.mat-icon-button,.mat-stroked-button,.mat-flat-button,.mat-fab,.mat-mini-fab{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-datepicker-content .mdc-button{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-button-font-family, var(--mdc-typography-font-family, Roboto, "Helvetica Neue", sans-serif));font-size:var(--mdc-typography-button-font-size, 14px);line-height:var(--mdc-typography-button-line-height, 14px);font-weight:var(--mdc-typography-button-font-weight, 500);letter-spacing:var(--mdc-typography-button-letter-spacing, normal);text-decoration:var(--mdc-typography-button-text-decoration, none);text-transform:var(--mdc-typography-button-text-transform, none)}.mat-card{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card-title{font-size:24px;font-weight:500}.mat-card-header .mat-card-title{font-size:20px}.mat-card-subtitle,.mat-card-content{font-size:14px}.mat-tooltip{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:10px;padding-top:6px;padding-bottom:6px}.mat-tooltip-handset{font-size:14px;padding-top:8px;padding-bottom:8px}input.mat-input-element{margin-top:-0.0625em}.mat-form-field{font-size:inherit;font-weight:400;line-height:1.125;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field-wrapper{padding-bottom:1.34375em}.mat-form-field-prefix .mat-icon,.mat-form-field-suffix .mat-icon{font-size:150%;line-height:1.125}.mat-form-field-prefix .mat-icon-button,.mat-form-field-suffix .mat-icon-button{height:1.5em;width:1.5em}.mat-form-field-prefix .mat-icon-button .mat-icon,.mat-form-field-suffix .mat-icon-button .mat-icon{height:1.125em;line-height:1.125}.mat-form-field-infix{padding:.5em 0;border-top:.84375em solid rgba(0,0,0,0)}.mat-form-field-can-float.mat-form-field-should-float .mat-form-field-label,.mat-form-field-can-float .mat-input-server:focus+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.34375em) scale(0.75);width:133.3333333333%}.mat-form-field-can-float .mat-input-server[label]+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.34374em) scale(0.75);width:133.3333433333%}.mat-form-field-label-wrapper{top:-0.84375em;padding-top:.84375em}.mat-form-field-label{top:1.34375em}.mat-form-field-underline{bottom:1.34375em}.mat-form-field-subscript-wrapper{font-size:75%;margin-top:.6666666667em;top:calc(100% - 1.7916666667em)}.mat-form-field-appearance-legacy .mat-form-field-wrapper{padding-bottom:1.25em}.mat-form-field-appearance-legacy .mat-form-field-infix{padding:.4375em 0}.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float .mat-form-field-label,.mat-form-field-appearance-legacy.mat-form-field-can-float .mat-input-server:focus+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.001px);width:133.3333333333%}.mat-form-field-appearance-legacy.mat-form-field-can-float .mat-form-field-autofill-control:-webkit-autofill+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00101px);width:133.3333433333%}.mat-form-field-appearance-legacy.mat-form-field-can-float .mat-input-server[label]+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00102px);width:133.3333533333%}.mat-form-field-appearance-legacy .mat-form-field-label{top:1.28125em}.mat-form-field-appearance-legacy .mat-form-field-underline{bottom:1.25em}.mat-form-field-appearance-legacy .mat-form-field-subscript-wrapper{margin-top:.5416666667em;top:calc(100% - 1.6666666667em)}@media print{.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float .mat-form-field-label,.mat-form-field-appearance-legacy.mat-form-field-can-float .mat-input-server:focus+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.28122em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float .mat-form-field-autofill-control:-webkit-autofill+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.28121em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float .mat-input-server[label]+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.2812em) scale(0.75)}}.mat-form-field-appearance-fill .mat-form-field-infix{padding:.25em 0 .75em 0}.mat-form-field-appearance-fill .mat-form-field-label{top:1.09375em;margin-top:-0.5em}.mat-form-field-appearance-fill.mat-form-field-can-float.mat-form-field-should-float .mat-form-field-label,.mat-form-field-appearance-fill.mat-form-field-can-float .mat-input-server:focus+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-0.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-fill.mat-form-field-can-float .mat-input-server[label]+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-0.59374em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-outline .mat-form-field-infix{padding:1em 0 1em 0}.mat-form-field-appearance-outline .mat-form-field-label{top:1.84375em;margin-top:-0.25em}.mat-form-field-appearance-outline.mat-form-field-can-float.mat-form-field-should-float .mat-form-field-label,.mat-form-field-appearance-outline.mat-form-field-can-float .mat-input-server:focus+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-outline.mat-form-field-can-float .mat-input-server[label]+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.59374em) scale(0.75);width:133.3333433333%}.mat-select{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select-trigger{height:1.125em}.mat-checkbox{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-checkbox-layout .mat-checkbox-label{line-height:24px}.mat-dialog-title{font-size:20px;font-weight:500;line-height:32px;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-chip{font-size:14px;font-weight:500}.mat-chip .mat-chip-trailing-icon.mat-icon,.mat-chip .mat-chip-remove.mat-icon{font-size:18px}.mat-slide-toggle-content{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tab-group{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tab-label,.mat-tab-link{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-radio-button{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-slider-thumb-label-text{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-menu-item{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:400}.mat-list-item{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-option{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-base .mat-list-item{font-size:16px}.mat-list-base .mat-list-item .mat-line{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base .mat-list-item .mat-line:nth-child(n+2){font-size:14px}.mat-list-base .mat-list-option{font-size:16px}.mat-list-base .mat-list-option .mat-line{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base .mat-list-option .mat-line:nth-child(n+2){font-size:14px}.mat-list-base .mat-subheader{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-list-base[dense] .mat-list-item{font-size:12px}.mat-list-base[dense] .mat-list-item .mat-line{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense] .mat-list-item .mat-line:nth-child(n+2){font-size:12px}.mat-list-base[dense] .mat-list-option{font-size:12px}.mat-list-base[dense] .mat-list-option .mat-line{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense] .mat-list-option .mat-line:nth-child(n+2){font-size:12px}.mat-list-base[dense] .mat-subheader{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-paginator,.mat-paginator-page-size .mat-select-trigger{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px}.mat-simple-snackbar{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px}.mat-simple-snackbar-action{line-height:1;font-family:inherit;font-size:inherit;font-weight:500}.mat-table{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-header-cell{font-size:12px;font-weight:500}.mat-cell,.mat-footer-cell{font-size:14px}.mat-button,.mat-icon-button,.mat-stroked-button{color:inherit;background:rgba(0,0,0,0)}.mat-button.mat-primary,.mat-icon-button.mat-primary,.mat-stroked-button.mat-primary{color:#f57c00}.mat-button.mat-accent,.mat-icon-button.mat-accent,.mat-stroked-button.mat-accent{color:#ff9800}.mat-button.mat-warn,.mat-icon-button.mat-warn,.mat-stroked-button.mat-warn{color:#f44336}.mat-button.mat-primary.mat-button-disabled,.mat-button.mat-accent.mat-button-disabled,.mat-button.mat-warn.mat-button-disabled,.mat-button.mat-button-disabled.mat-button-disabled,.mat-icon-button.mat-primary.mat-button-disabled,.mat-icon-button.mat-accent.mat-button-disabled,.mat-icon-button.mat-warn.mat-button-disabled,.mat-icon-button.mat-button-disabled.mat-button-disabled,.mat-stroked-button.mat-primary.mat-button-disabled,.mat-stroked-button.mat-accent.mat-button-disabled,.mat-stroked-button.mat-warn.mat-button-disabled,.mat-stroked-button.mat-button-disabled.mat-button-disabled{color:rgba(0,0,0,.26)}.mat-button.mat-primary .mat-button-focus-overlay,.mat-icon-button.mat-primary .mat-button-focus-overlay,.mat-stroked-button.mat-primary .mat-button-focus-overlay{background-color:#f57c00}.mat-button.mat-accent .mat-button-focus-overlay,.mat-icon-button.mat-accent .mat-button-focus-overlay,.mat-stroked-button.mat-accent .mat-button-focus-overlay{background-color:#ff9800}.mat-button.mat-warn .mat-button-focus-overlay,.mat-icon-button.mat-warn .mat-button-focus-overlay,.mat-stroked-button.mat-warn .mat-button-focus-overlay{background-color:#f44336}.mat-button.mat-button-disabled .mat-button-focus-overlay,.mat-icon-button.mat-button-disabled .mat-button-focus-overlay,.mat-stroked-button.mat-button-disabled .mat-button-focus-overlay{background-color:rgba(0,0,0,0)}.mat-button .mat-ripple-element,.mat-icon-button .mat-ripple-element,.mat-stroked-button .mat-ripple-element{opacity:.1;background-color:currentColor}.mat-button-focus-overlay{background:#000}.mat-stroked-button:not(.mat-button-disabled){border-color:rgba(0,0,0,.12)}.mat-flat-button,.mat-raised-button,.mat-fab,.mat-mini-fab{color:#212121;background-color:#fff}.mat-flat-button.mat-primary,.mat-raised-button.mat-primary,.mat-fab.mat-primary,.mat-mini-fab.mat-primary{color:#fff}.mat-flat-button.mat-accent,.mat-raised-button.mat-accent,.mat-fab.mat-accent,.mat-mini-fab.mat-accent{color:#fff}.mat-flat-button.mat-warn,.mat-raised-button.mat-warn,.mat-fab.mat-warn,.mat-mini-fab.mat-warn{color:#fff}.mat-flat-button.mat-primary.mat-button-disabled,.mat-flat-button.mat-accent.mat-button-disabled,.mat-flat-button.mat-warn.mat-button-disabled,.mat-flat-button.mat-button-disabled.mat-button-disabled,.mat-raised-button.mat-primary.mat-button-disabled,.mat-raised-button.mat-accent.mat-button-disabled,.mat-raised-button.mat-warn.mat-button-disabled,.mat-raised-button.mat-button-disabled.mat-button-disabled,.mat-fab.mat-primary.mat-button-disabled,.mat-fab.mat-accent.mat-button-disabled,.mat-fab.mat-warn.mat-button-disabled,.mat-fab.mat-button-disabled.mat-button-disabled,.mat-mini-fab.mat-primary.mat-button-disabled,.mat-mini-fab.mat-accent.mat-button-disabled,.mat-mini-fab.mat-warn.mat-button-disabled,.mat-mini-fab.mat-button-disabled.mat-button-disabled{color:rgba(0,0,0,.26)}.mat-flat-button.mat-primary,.mat-raised-button.mat-primary,.mat-fab.mat-primary,.mat-mini-fab.mat-primary{background-color:#f57c00}.mat-flat-button.mat-accent,.mat-raised-button.mat-accent,.mat-fab.mat-accent,.mat-mini-fab.mat-accent{background-color:#ff9800}.mat-flat-button.mat-warn,.mat-raised-button.mat-warn,.mat-fab.mat-warn,.mat-mini-fab.mat-warn{background-color:#f44336}.mat-flat-button.mat-primary.mat-button-disabled,.mat-flat-button.mat-accent.mat-button-disabled,.mat-flat-button.mat-warn.mat-button-disabled,.mat-flat-button.mat-button-disabled.mat-button-disabled,.mat-raised-button.mat-primary.mat-button-disabled,.mat-raised-button.mat-accent.mat-button-disabled,.mat-raised-button.mat-warn.mat-button-disabled,.mat-raised-button.mat-button-disabled.mat-button-disabled,.mat-fab.mat-primary.mat-button-disabled,.mat-fab.mat-accent.mat-button-disabled,.mat-fab.mat-warn.mat-button-disabled,.mat-fab.mat-button-disabled.mat-button-disabled,.mat-mini-fab.mat-primary.mat-button-disabled,.mat-mini-fab.mat-accent.mat-button-disabled,.mat-mini-fab.mat-warn.mat-button-disabled,.mat-mini-fab.mat-button-disabled.mat-button-disabled{background-color:rgba(0,0,0,.12)}.mat-flat-button.mat-primary .mat-ripple-element,.mat-raised-button.mat-primary .mat-ripple-element,.mat-fab.mat-primary .mat-ripple-element,.mat-mini-fab.mat-primary .mat-ripple-element{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-accent .mat-ripple-element,.mat-raised-button.mat-accent .mat-ripple-element,.mat-fab.mat-accent .mat-ripple-element,.mat-mini-fab.mat-accent .mat-ripple-element{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-warn .mat-ripple-element,.mat-raised-button.mat-warn .mat-ripple-element,.mat-fab.mat-warn .mat-ripple-element,.mat-mini-fab.mat-warn .mat-ripple-element{background-color:rgba(255,255,255,.1)}.mat-stroked-button:not([class*=mat-elevation-z]),.mat-flat-button:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2), 0px 0px 0px 0px rgba(0, 0, 0, 0.14), 0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2), 0px 2px 2px 0px rgba(0, 0, 0, 0.14), 0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2), 0px 8px 10px 1px rgba(0, 0, 0, 0.14), 0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-raised-button.mat-button-disabled:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2), 0px 0px 0px 0px rgba(0, 0, 0, 0.14), 0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-fab:not([class*=mat-elevation-z]),.mat-mini-fab:not([class*=mat-elevation-z]){box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2), 0px 6px 10px 0px rgba(0, 0, 0, 0.14), 0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-fab:not(.mat-button-disabled):active:not([class*=mat-elevation-z]),.mat-mini-fab:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2), 0px 12px 17px 2px rgba(0, 0, 0, 0.14), 0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-fab.mat-button-disabled:not([class*=mat-elevation-z]),.mat-mini-fab.mat-button-disabled:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2), 0px 0px 0px 0px rgba(0, 0, 0, 0.14), 0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-datepicker-content .mat-mdc-button.mat-unthemed{--mdc-text-button-label-text-color:#000}.mat-datepicker-content .mat-mdc-button.mat-primary{--mdc-text-button-label-text-color:#f57c00}.mat-datepicker-content .mat-mdc-button.mat-accent{--mdc-text-button-label-text-color:#ff9800}.mat-datepicker-content .mat-mdc-button.mat-warn{--mdc-text-button-label-text-color:#f44336}.mat-datepicker-content .mat-mdc-button[disabled][disabled]{--mdc-text-button-disabled-label-text-color:rgba(0, 0, 0, 0.38);--mdc-text-button-label-text-color:rgba(0, 0, 0, 0.38)}.mat-datepicker-content .mat-mdc-unelevated-button.mat-unthemed{--mdc-filled-button-container-color:#fff;--mdc-filled-button-label-text-color:#000}.mat-datepicker-content .mat-mdc-unelevated-button.mat-primary{--mdc-filled-button-container-color:#f57c00;--mdc-filled-button-label-text-color:#000}.mat-datepicker-content .mat-mdc-unelevated-button.mat-accent{--mdc-filled-button-container-color:#ff9800;--mdc-filled-button-label-text-color:#000}.mat-datepicker-content .mat-mdc-unelevated-button.mat-warn{--mdc-filled-button-container-color:#f44336;--mdc-filled-button-label-text-color:#fff}.mat-datepicker-content .mat-mdc-unelevated-button[disabled][disabled]{--mdc-filled-button-disabled-container-color:rgba(0, 0, 0, 0.12);--mdc-filled-button-disabled-label-text-color:rgba(0, 0, 0, 0.38);--mdc-filled-button-container-color:rgba(0, 0, 0, 0.12);--mdc-filled-button-label-text-color:rgba(0, 0, 0, 0.38)}.mat-datepicker-content .mat-mdc-raised-button.mat-unthemed{--mdc-protected-button-container-color:#fff;--mdc-protected-button-label-text-color:#000}.mat-datepicker-content .mat-mdc-raised-button.mat-primary{--mdc-protected-button-container-color:#f57c00;--mdc-protected-button-label-text-color:#000}.mat-datepicker-content .mat-mdc-raised-button.mat-accent{--mdc-protected-button-container-color:#ff9800;--mdc-protected-button-label-text-color:#000}.mat-datepicker-content .mat-mdc-raised-button.mat-warn{--mdc-protected-button-container-color:#f44336;--mdc-protected-button-label-text-color:#fff}.mat-datepicker-content .mat-mdc-raised-button[disabled][disabled]{--mdc-protected-button-disabled-container-color:rgba(0, 0, 0, 0.12);--mdc-protected-button-disabled-label-text-color:rgba(0, 0, 0, 0.38);--mdc-protected-button-container-color:rgba(0, 0, 0, 0.12);--mdc-protected-button-label-text-color:rgba(0, 0, 0, 0.38);--mdc-protected-button-container-elevation:0}.mat-datepicker-content .mat-mdc-outlined-button{--mdc-outlined-button-outline-color:rgba(0, 0, 0, 0.12)}.mat-datepicker-content .mat-mdc-outlined-button.mat-unthemed{--mdc-outlined-button-label-text-color:#000}.mat-datepicker-content .mat-mdc-outlined-button.mat-primary{--mdc-outlined-button-label-text-color:#f57c00}.mat-datepicker-content .mat-mdc-outlined-button.mat-accent{--mdc-outlined-button-label-text-color:#ff9800}.mat-datepicker-content .mat-mdc-outlined-button.mat-warn{--mdc-outlined-button-label-text-color:#f44336}.mat-datepicker-content .mat-mdc-outlined-button[disabled][disabled]{--mdc-outlined-button-label-text-color:rgba(0, 0, 0, 0.38);--mdc-outlined-button-disabled-label-text-color:rgba(0, 0, 0, 0.38);--mdc-outlined-button-outline-color:rgba(0, 0, 0, 0.12);--mdc-outlined-button-disabled-outline-color:rgba(0, 0, 0, 0.12)}.mat-datepicker-content .mat-mdc-button,.mat-datepicker-content .mat-mdc-outlined-button{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}.mat-datepicker-content .mat-mdc-button:hover .mat-mdc-button-persistent-ripple::before,.mat-datepicker-content .mat-mdc-outlined-button:hover .mat-mdc-button-persistent-ripple::before{opacity:.04}.mat-datepicker-content .mat-mdc-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,.mat-datepicker-content .mat-mdc-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before,.mat-datepicker-content .mat-mdc-outlined-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,.mat-datepicker-content .mat-mdc-outlined-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before{opacity:.12}.mat-datepicker-content .mat-mdc-button:active .mat-mdc-button-persistent-ripple::before,.mat-datepicker-content .mat-mdc-outlined-button:active .mat-mdc-button-persistent-ripple::before{opacity:.12}.mat-datepicker-content .mat-mdc-button.mat-primary,.mat-datepicker-content .mat-mdc-outlined-button.mat-primary{--mat-mdc-button-persistent-ripple-color: #f57c00;--mat-mdc-button-ripple-color: rgba(245, 124, 0, 0.1)}.mat-datepicker-content .mat-mdc-button.mat-accent,.mat-datepicker-content .mat-mdc-outlined-button.mat-accent{--mat-mdc-button-persistent-ripple-color: #ff9800;--mat-mdc-button-ripple-color: rgba(255, 152, 0, 0.1)}.mat-datepicker-content .mat-mdc-button.mat-warn,.mat-datepicker-content .mat-mdc-outlined-button.mat-warn{--mat-mdc-button-persistent-ripple-color: #f44336;--mat-mdc-button-ripple-color: rgba(244, 67, 54, 0.1)}.mat-datepicker-content .mat-mdc-raised-button,.mat-datepicker-content .mat-mdc-unelevated-button{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}.mat-datepicker-content .mat-mdc-raised-button:hover .mat-mdc-button-persistent-ripple::before,.mat-datepicker-content .mat-mdc-unelevated-button:hover .mat-mdc-button-persistent-ripple::before{opacity:.04}.mat-datepicker-content .mat-mdc-raised-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,.mat-datepicker-content .mat-mdc-raised-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before,.mat-datepicker-content .mat-mdc-unelevated-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,.mat-datepicker-content .mat-mdc-unelevated-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before{opacity:.12}.mat-datepicker-content .mat-mdc-raised-button:active .mat-mdc-button-persistent-ripple::before,.mat-datepicker-content .mat-mdc-unelevated-button:active .mat-mdc-button-persistent-ripple::before{opacity:.12}.mat-datepicker-content .mat-mdc-raised-button.mat-primary,.mat-datepicker-content .mat-mdc-unelevated-button.mat-primary{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}.mat-datepicker-content .mat-mdc-raised-button.mat-accent,.mat-datepicker-content .mat-mdc-unelevated-button.mat-accent{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}.mat-datepicker-content .mat-mdc-raised-button.mat-warn,.mat-datepicker-content .mat-mdc-unelevated-button.mat-warn{--mat-mdc-button-persistent-ripple-color: #fff;--mat-mdc-button-ripple-color: rgba(255, 255, 255, 0.1)}.mat-datepicker-content .mat-mdc-icon-button{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}.mat-datepicker-content .mat-mdc-icon-button:hover .mat-mdc-button-persistent-ripple::before{opacity:.04}.mat-datepicker-content .mat-mdc-icon-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,.mat-datepicker-content .mat-mdc-icon-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before{opacity:.12}.mat-datepicker-content .mat-mdc-icon-button:active .mat-mdc-button-persistent-ripple::before{opacity:.12}.mat-datepicker-content .mat-mdc-icon-button.mat-primary{--mat-mdc-button-persistent-ripple-color: #f57c00;--mat-mdc-button-ripple-color: rgba(245, 124, 0, 0.1)}.mat-datepicker-content .mat-mdc-icon-button.mat-accent{--mat-mdc-button-persistent-ripple-color: #ff9800;--mat-mdc-button-ripple-color: rgba(255, 152, 0, 0.1)}.mat-datepicker-content .mat-mdc-icon-button.mat-warn{--mat-mdc-button-persistent-ripple-color: #f44336;--mat-mdc-button-ripple-color: rgba(244, 67, 54, 0.1)}.mat-datepicker-content .mat-mdc-icon-button.mat-primary{--mdc-icon-button-icon-color:#f57c00}.mat-datepicker-content .mat-mdc-icon-button.mat-accent{--mdc-icon-button-icon-color:#ff9800}.mat-datepicker-content .mat-mdc-icon-button.mat-warn{--mdc-icon-button-icon-color:#f44336}.mat-datepicker-content .mat-mdc-icon-button[disabled][disabled]{--mdc-icon-button-icon-color:rgba(0, 0, 0, 0.38);--mdc-icon-button-disabled-icon-color:rgba(0, 0, 0, 0.38)}.mat-datepicker-content .mat-mdc-button.mat-mdc-button-base,.mat-datepicker-content .mat-mdc-raised-button.mat-mdc-button-base,.mat-datepicker-content .mat-mdc-unelevated-button.mat-mdc-button-base,.mat-datepicker-content .mat-mdc-outlined-button.mat-mdc-button-base{height:36px}.mat-datepicker-content .mat-mdc-icon-button.mat-mdc-button-base{width:48px;height:48px;padding:12px}.mat-datepicker-content .mat-mdc-icon-button.mat-mdc-button-base .mdc-icon-button__focus-ring{max-height:48px;max-width:48px}.mat-datepicker-content .mat-mdc-icon-button.mat-mdc-button-base.mdc-icon-button--reduced-size .mdc-icon-button__ripple{width:40px;height:40px;margin-top:4px;margin-bottom:4px;margin-right:4px;margin-left:4px}.mat-datepicker-content .mat-mdc-icon-button.mat-mdc-button-base.mdc-icon-button--reduced-size .mdc-icon-button__focus-ring{max-height:40px;max-width:40px}.mat-datepicker-content .mat-mdc-icon-button.mat-mdc-button-base .mdc-icon-button__touch{position:absolute;top:50%;height:48px;left:50%;width:48px;transform:translate(-50%, -50%)}.mat-option{color:#212121}.mat-option:hover:not(.mat-option-disabled),.mat-option:focus:not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-selected:not(.mat-option-multiple):not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-active{background:rgba(0,0,0,.04);color:#212121}.mat-option.mat-option-disabled{color:rgba(0,0,0,.38)}.mat-primary .mat-option.mat-selected:not(.mat-option-disabled){color:#f57c00}.mat-accent .mat-option.mat-selected:not(.mat-option-disabled){color:#ff9800}.mat-warn .mat-option.mat-selected:not(.mat-option-disabled){color:#f44336}.mat-optgroup-label{color:#616161}.mat-optgroup-disabled .mat-optgroup-label{color:rgba(0,0,0,.38)}.mat-ripple-element{background-color:rgba(0,0,0,.1)}.mat-pseudo-checkbox-full{color:#616161}.mat-pseudo-checkbox-full.mat-pseudo-checkbox-disabled{color:#b0b0b0}.mat-primary .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,.mat-primary .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#f57c00}.mat-primary .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,.mat-primary .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#f57c00}.mat-primary .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full::after,.mat-primary .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full::after{color:#fff}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,.mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#ff9800}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,.mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#ff9800}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full::after,.mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full::after{color:#fff}.mat-accent .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,.mat-accent .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#ff9800}.mat-accent .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,.mat-accent .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#ff9800}.mat-accent .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full::after,.mat-accent .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full::after{color:#fff}.mat-warn .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,.mat-warn .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#f44336}.mat-warn .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,.mat-warn .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#f44336}.mat-warn .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full::after,.mat-warn .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full::after{color:#fff}.mat-pseudo-checkbox-disabled.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,.mat-pseudo-checkbox-disabled.mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#b0b0b0}.mat-pseudo-checkbox-disabled.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,.mat-pseudo-checkbox-disabled.mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#b0b0b0}.mat-app-background{background-color:#fff;color:#212121}.mat-elevation-z0{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2), 0px 0px 0px 0px rgba(0, 0, 0, 0.14), 0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z1{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2), 0px 1px 1px 0px rgba(0, 0, 0, 0.14), 0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z2{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2), 0px 2px 2px 0px rgba(0, 0, 0, 0.14), 0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z3{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2), 0px 3px 4px 0px rgba(0, 0, 0, 0.14), 0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z4{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2), 0px 4px 5px 0px rgba(0, 0, 0, 0.14), 0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z5{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2), 0px 5px 8px 0px rgba(0, 0, 0, 0.14), 0px 1px 14px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z6{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2), 0px 6px 10px 0px rgba(0, 0, 0, 0.14), 0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z7{box-shadow:0px 4px 5px -2px rgba(0, 0, 0, 0.2), 0px 7px 10px 1px rgba(0, 0, 0, 0.14), 0px 2px 16px 1px rgba(0, 0, 0, 0.12)}.mat-elevation-z8{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2), 0px 8px 10px 1px rgba(0, 0, 0, 0.14), 0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z9{box-shadow:0px 5px 6px -3px rgba(0, 0, 0, 0.2), 0px 9px 12px 1px rgba(0, 0, 0, 0.14), 0px 3px 16px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z10{box-shadow:0px 6px 6px -3px rgba(0, 0, 0, 0.2), 0px 10px 14px 1px rgba(0, 0, 0, 0.14), 0px 4px 18px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z11{box-shadow:0px 6px 7px -4px rgba(0, 0, 0, 0.2), 0px 11px 15px 1px rgba(0, 0, 0, 0.14), 0px 4px 20px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z12{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2), 0px 12px 17px 2px rgba(0, 0, 0, 0.14), 0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z13{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2), 0px 13px 19px 2px rgba(0, 0, 0, 0.14), 0px 5px 24px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z14{box-shadow:0px 7px 9px -4px rgba(0, 0, 0, 0.2), 0px 14px 21px 2px rgba(0, 0, 0, 0.14), 0px 5px 26px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z15{box-shadow:0px 8px 9px -5px rgba(0, 0, 0, 0.2), 0px 15px 22px 2px rgba(0, 0, 0, 0.14), 0px 6px 28px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z16{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2), 0px 16px 24px 2px rgba(0, 0, 0, 0.14), 0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z17{box-shadow:0px 8px 11px -5px rgba(0, 0, 0, 0.2), 0px 17px 26px 2px rgba(0, 0, 0, 0.14), 0px 6px 32px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z18{box-shadow:0px 9px 11px -5px rgba(0, 0, 0, 0.2), 0px 18px 28px 2px rgba(0, 0, 0, 0.14), 0px 7px 34px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z19{box-shadow:0px 9px 12px -6px rgba(0, 0, 0, 0.2), 0px 19px 29px 2px rgba(0, 0, 0, 0.14), 0px 7px 36px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z20{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2), 0px 20px 31px 3px rgba(0, 0, 0, 0.14), 0px 8px 38px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z21{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2), 0px 21px 33px 3px rgba(0, 0, 0, 0.14), 0px 8px 40px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z22{box-shadow:0px 10px 14px -6px rgba(0, 0, 0, 0.2), 0px 22px 35px 3px rgba(0, 0, 0, 0.14), 0px 8px 42px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z23{box-shadow:0px 11px 14px -7px rgba(0, 0, 0, 0.2), 0px 23px 36px 3px rgba(0, 0, 0, 0.14), 0px 9px 44px 8px rgba(0, 0, 0, 0.12)}.mat-elevation-z24{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2), 0px 24px 38px 3px rgba(0, 0, 0, 0.14), 0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-theme-loaded-marker{display:none}.mat-card{background:#fff;color:#212121}.mat-card:not([class*=mat-elevation-z]){box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2), 0px 1px 1px 0px rgba(0, 0, 0, 0.14), 0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-card.mat-card-flat:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2), 0px 0px 0px 0px rgba(0, 0, 0, 0.14), 0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-card-subtitle{color:#616161}.mat-progress-bar-background{fill:#fddebf}.mat-progress-bar-buffer{background-color:#fddebf}.mat-progress-bar-fill::after{background-color:#f57c00}.mat-progress-bar.mat-accent .mat-progress-bar-background{fill:#ffe5bf}.mat-progress-bar.mat-accent .mat-progress-bar-buffer{background-color:#ffe5bf}.mat-progress-bar.mat-accent .mat-progress-bar-fill::after{background-color:#ff9800}.mat-progress-bar.mat-warn .mat-progress-bar-background{fill:#fcd0cd}.mat-progress-bar.mat-warn .mat-progress-bar-buffer{background-color:#fcd0cd}.mat-progress-bar.mat-warn .mat-progress-bar-fill::after{background-color:#f44336}.mat-progress-spinner circle,.mat-spinner circle{stroke:#f57c00}.mat-progress-spinner.mat-accent circle,.mat-spinner.mat-accent circle{stroke:#ff9800}.mat-progress-spinner.mat-warn circle,.mat-spinner.mat-warn circle{stroke:#f44336}.mat-tooltip{background:rgba(97,97,97,.9)}.mat-form-field-type-mat-native-select .mat-form-field-infix::after{color:#616161}.mat-input-element:disabled,.mat-form-field-type-mat-native-select.mat-form-field-disabled .mat-form-field-infix::after{color:#757575}.mat-input-element{caret-color:#f57c00}.mat-input-element::placeholder{color:rgba(97,97,97,.42)}.mat-input-element::-moz-placeholder{color:rgba(97,97,97,.42)}.mat-input-element::-webkit-input-placeholder{color:rgba(97,97,97,.42)}.mat-input-element:-ms-input-placeholder{color:rgba(97,97,97,.42)}.mat-form-field.mat-accent .mat-input-element{caret-color:#ff9800}.mat-form-field.mat-warn .mat-input-element,.mat-form-field-invalid .mat-input-element{caret-color:#f44336}.mat-form-field-type-mat-native-select.mat-form-field-invalid .mat-form-field-infix::after{color:#f44336}.mat-form-field-disabled .mat-form-field-prefix,.mat-form-field-disabled .mat-form-field-suffix{color:#757575}.mat-form-field-label{color:rgba(97,97,97,.6)}.mat-hint{color:rgba(97,97,97,.6)}.mat-form-field.mat-focused .mat-form-field-label{color:#f57c00}.mat-form-field.mat-focused .mat-form-field-label.mat-accent{color:#ff9800}.mat-form-field.mat-focused .mat-form-field-label.mat-warn{color:#f44336}.mat-focused .mat-form-field-required-marker{color:#ff9800}.mat-form-field-ripple{background-color:rgba(0,0,0,.87)}.mat-form-field.mat-focused .mat-form-field-ripple{background-color:#f57c00}.mat-form-field.mat-focused .mat-form-field-ripple.mat-accent{background-color:#ff9800}.mat-form-field.mat-focused .mat-form-field-ripple.mat-warn{background-color:#f44336}.mat-form-field-type-mat-native-select.mat-focused:not(.mat-form-field-invalid) .mat-form-field-infix::after{color:#f57c00}.mat-form-field-type-mat-native-select.mat-focused:not(.mat-form-field-invalid).mat-accent .mat-form-field-infix::after{color:#ff9800}.mat-form-field-type-mat-native-select.mat-focused:not(.mat-form-field-invalid).mat-warn .mat-form-field-infix::after{color:#f44336}.mat-form-field.mat-form-field-invalid .mat-form-field-label{color:#f44336}.mat-form-field.mat-form-field-invalid .mat-form-field-label.mat-accent,.mat-form-field.mat-form-field-invalid .mat-form-field-label .mat-form-field-required-marker{color:#f44336}.mat-form-field.mat-form-field-invalid .mat-form-field-ripple,.mat-form-field.mat-form-field-invalid .mat-form-field-ripple.mat-accent{background-color:#f44336}.mat-error{color:#f44336}.mat-form-field-appearance-legacy .mat-form-field-label{color:#616161}.mat-form-field-appearance-legacy .mat-hint{color:#616161}.mat-form-field-appearance-legacy .mat-form-field-underline{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-legacy.mat-form-field-disabled .mat-form-field-underline{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-standard .mat-form-field-underline{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-standard.mat-form-field-disabled .mat-form-field-underline{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-fill .mat-form-field-flex{background-color:rgba(0,0,0,.04)}.mat-form-field-appearance-fill.mat-form-field-disabled .mat-form-field-flex{background-color:rgba(0,0,0,.02)}.mat-form-field-appearance-fill .mat-form-field-underline::before{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-fill.mat-form-field-disabled .mat-form-field-label{color:#757575}.mat-form-field-appearance-fill.mat-form-field-disabled .mat-form-field-underline::before{background-color:rgba(0,0,0,0)}.mat-form-field-appearance-outline .mat-form-field-outline{color:rgba(0,0,0,.12)}.mat-form-field-appearance-outline .mat-form-field-outline-thick{color:rgba(0,0,0,.87)}.mat-form-field-appearance-outline.mat-focused .mat-form-field-outline-thick{color:#f57c00}.mat-form-field-appearance-outline.mat-focused.mat-accent .mat-form-field-outline-thick{color:#ff9800}.mat-form-field-appearance-outline.mat-focused.mat-warn .mat-form-field-outline-thick{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-invalid.mat-form-field-invalid .mat-form-field-outline-thick{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-disabled .mat-form-field-label{color:#757575}.mat-form-field-appearance-outline.mat-form-field-disabled .mat-form-field-outline{color:rgba(0,0,0,.06)}.mat-select-value{color:#212121}.mat-select-placeholder{color:rgba(97,97,97,.42)}.mat-select-disabled .mat-select-value{color:#757575}.mat-select-arrow{color:#616161}.mat-select-panel{background:#fff}.mat-select-panel:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2), 0px 4px 5px 0px rgba(0, 0, 0, 0.14), 0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-select-panel .mat-option.mat-selected:not(.mat-option-multiple){background:rgba(0,0,0,.12)}.mat-form-field.mat-focused.mat-primary .mat-select-arrow{color:#f57c00}.mat-form-field.mat-focused.mat-accent .mat-select-arrow{color:#ff9800}.mat-form-field.mat-focused.mat-warn .mat-select-arrow{color:#f44336}.mat-form-field .mat-select.mat-select-invalid .mat-select-arrow{color:#f44336}.mat-form-field .mat-select.mat-select-disabled .mat-select-arrow{color:#757575}.mat-checkbox-frame{border-color:#616161}.mat-checkbox-checkmark{fill:#fff}.mat-checkbox-checkmark-path{stroke:#fff !important}.mat-checkbox-mixedmark{background-color:#fff}.mat-checkbox-indeterminate.mat-primary .mat-checkbox-background,.mat-checkbox-checked.mat-primary .mat-checkbox-background{background-color:#f57c00}.mat-checkbox-indeterminate.mat-accent .mat-checkbox-background,.mat-checkbox-checked.mat-accent .mat-checkbox-background{background-color:#ff9800}.mat-checkbox-indeterminate.mat-warn .mat-checkbox-background,.mat-checkbox-checked.mat-warn .mat-checkbox-background{background-color:#f44336}.mat-checkbox-disabled.mat-checkbox-checked .mat-checkbox-background,.mat-checkbox-disabled.mat-checkbox-indeterminate .mat-checkbox-background{background-color:#b0b0b0}.mat-checkbox-disabled:not(.mat-checkbox-checked) .mat-checkbox-frame{border-color:#b0b0b0}.mat-checkbox-disabled .mat-checkbox-label{color:rgba(0,0,0,.38)}.mat-checkbox .mat-ripple-element{background-color:#000}.mat-checkbox-checked:not(.mat-checkbox-disabled).mat-primary .mat-ripple-element,.mat-checkbox:active:not(.mat-checkbox-disabled).mat-primary .mat-ripple-element{background:#f57c00}.mat-checkbox-checked:not(.mat-checkbox-disabled).mat-accent .mat-ripple-element,.mat-checkbox:active:not(.mat-checkbox-disabled).mat-accent .mat-ripple-element{background:#ff9800}.mat-checkbox-checked:not(.mat-checkbox-disabled).mat-warn .mat-ripple-element,.mat-checkbox:active:not(.mat-checkbox-disabled).mat-warn .mat-ripple-element{background:#f44336}.mat-autocomplete-panel{background:#fff;color:#212121}.mat-autocomplete-panel:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2), 0px 4px 5px 0px rgba(0, 0, 0, 0.14), 0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-autocomplete-panel .mat-option.mat-selected:not(.mat-active):not(:hover){background:#fff}.mat-autocomplete-panel .mat-option.mat-selected:not(.mat-active):not(:hover):not(.mat-option-disabled){color:#212121}.mat-dialog-container{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2), 0px 24px 38px 3px rgba(0, 0, 0, 0.14), 0px 9px 46px 8px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-chip.mat-standard-chip{background-color:#e0e0e0;color:#212121}.mat-chip.mat-standard-chip .mat-chip-remove{color:#212121;opacity:.4}.mat-chip.mat-standard-chip:not(.mat-chip-disabled):active{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2), 0px 3px 4px 0px rgba(0, 0, 0, 0.14), 0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-chip.mat-standard-chip:not(.mat-chip-disabled) .mat-chip-remove:hover{opacity:.54}.mat-chip.mat-standard-chip.mat-chip-disabled{opacity:.4}.mat-chip.mat-standard-chip::after{background:#000}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary{background-color:#f57c00;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary .mat-chip-remove{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary .mat-ripple-element{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn{background-color:#f44336;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn .mat-chip-remove{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn .mat-ripple-element{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent{background-color:#ff9800;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent .mat-chip-remove{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent .mat-ripple-element{background-color:rgba(255,255,255,.1)}.mat-slide-toggle.mat-checked .mat-slide-toggle-thumb{background-color:#ff9800}.mat-slide-toggle.mat-checked .mat-slide-toggle-bar{background-color:rgba(255,152,0,.54)}.mat-slide-toggle.mat-checked .mat-ripple-element{background-color:#ff9800}.mat-slide-toggle.mat-primary.mat-checked .mat-slide-toggle-thumb{background-color:#f57c00}.mat-slide-toggle.mat-primary.mat-checked .mat-slide-toggle-bar{background-color:rgba(245,124,0,.54)}.mat-slide-toggle.mat-primary.mat-checked .mat-ripple-element{background-color:#f57c00}.mat-slide-toggle.mat-warn.mat-checked .mat-slide-toggle-thumb{background-color:#f44336}.mat-slide-toggle.mat-warn.mat-checked .mat-slide-toggle-bar{background-color:rgba(244,67,54,.54)}.mat-slide-toggle.mat-warn.mat-checked .mat-ripple-element{background-color:#f44336}.mat-slide-toggle:not(.mat-checked) .mat-ripple-element{background-color:#000}.mat-slide-toggle-thumb{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2), 0px 1px 1px 0px rgba(0, 0, 0, 0.14), 0px 1px 3px 0px rgba(0, 0, 0, 0.12);background-color:#fafafa}.mat-slide-toggle-bar{background-color:rgba(0,0,0,.38)}.mat-radio-outer-circle{border-color:#616161}.mat-radio-button.mat-primary.mat-radio-checked .mat-radio-outer-circle{border-color:#f57c00}.mat-radio-button.mat-primary .mat-radio-inner-circle,.mat-radio-button.mat-primary .mat-radio-ripple .mat-ripple-element:not(.mat-radio-persistent-ripple),.mat-radio-button.mat-primary.mat-radio-checked .mat-radio-persistent-ripple,.mat-radio-button.mat-primary:active .mat-radio-persistent-ripple{background-color:#f57c00}.mat-radio-button.mat-accent.mat-radio-checked .mat-radio-outer-circle{border-color:#ff9800}.mat-radio-button.mat-accent .mat-radio-inner-circle,.mat-radio-button.mat-accent .mat-radio-ripple .mat-ripple-element:not(.mat-radio-persistent-ripple),.mat-radio-button.mat-accent.mat-radio-checked .mat-radio-persistent-ripple,.mat-radio-button.mat-accent:active .mat-radio-persistent-ripple{background-color:#ff9800}.mat-radio-button.mat-warn.mat-radio-checked .mat-radio-outer-circle{border-color:#f44336}.mat-radio-button.mat-warn .mat-radio-inner-circle,.mat-radio-button.mat-warn .mat-radio-ripple .mat-ripple-element:not(.mat-radio-persistent-ripple),.mat-radio-button.mat-warn.mat-radio-checked .mat-radio-persistent-ripple,.mat-radio-button.mat-warn:active .mat-radio-persistent-ripple{background-color:#f44336}.mat-radio-button.mat-radio-disabled.mat-radio-checked .mat-radio-outer-circle,.mat-radio-button.mat-radio-disabled .mat-radio-outer-circle{border-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled .mat-radio-ripple .mat-ripple-element,.mat-radio-button.mat-radio-disabled .mat-radio-inner-circle{background-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled .mat-radio-label-content{color:rgba(0,0,0,.38)}.mat-radio-button .mat-ripple-element{background-color:#000}.mat-slider-track-background{background-color:rgba(0,0,0,.26)}.mat-slider.mat-primary .mat-slider-track-fill,.mat-slider.mat-primary .mat-slider-thumb,.mat-slider.mat-primary .mat-slider-thumb-label{background-color:#f57c00}.mat-slider.mat-primary .mat-slider-thumb-label-text{color:#fff}.mat-slider.mat-primary .mat-slider-focus-ring{background-color:rgba(245,124,0,.2)}.mat-slider.mat-accent .mat-slider-track-fill,.mat-slider.mat-accent .mat-slider-thumb,.mat-slider.mat-accent .mat-slider-thumb-label{background-color:#ff9800}.mat-slider.mat-accent .mat-slider-thumb-label-text{color:#fff}.mat-slider.mat-accent .mat-slider-focus-ring{background-color:rgba(255,152,0,.2)}.mat-slider.mat-warn .mat-slider-track-fill,.mat-slider.mat-warn .mat-slider-thumb,.mat-slider.mat-warn .mat-slider-thumb-label{background-color:#f44336}.mat-slider.mat-warn .mat-slider-thumb-label-text{color:#fff}.mat-slider.mat-warn .mat-slider-focus-ring{background-color:rgba(244,67,54,.2)}.mat-slider:hover .mat-slider-track-background,.mat-slider.cdk-focused .mat-slider-track-background{background-color:rgba(0,0,0,.38)}.mat-slider.mat-slider-disabled .mat-slider-track-background,.mat-slider.mat-slider-disabled .mat-slider-track-fill,.mat-slider.mat-slider-disabled .mat-slider-thumb{background-color:rgba(0,0,0,.26)}.mat-slider.mat-slider-disabled:hover .mat-slider-track-background{background-color:rgba(0,0,0,.26)}.mat-slider.mat-slider-min-value .mat-slider-focus-ring{background-color:rgba(0,0,0,.12)}.mat-slider.mat-slider-min-value.mat-slider-thumb-label-showing .mat-slider-thumb,.mat-slider.mat-slider-min-value.mat-slider-thumb-label-showing .mat-slider-thumb-label{background-color:rgba(0,0,0,.87)}.mat-slider.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused .mat-slider-thumb,.mat-slider.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused .mat-slider-thumb-label{background-color:rgba(0,0,0,.26)}.mat-slider.mat-slider-min-value:not(.mat-slider-thumb-label-showing) .mat-slider-thumb{border-color:rgba(0,0,0,.26);background-color:rgba(0,0,0,0)}.mat-slider.mat-slider-min-value:not(.mat-slider-thumb-label-showing):hover .mat-slider-thumb,.mat-slider.mat-slider-min-value:not(.mat-slider-thumb-label-showing).cdk-focused .mat-slider-thumb{border-color:rgba(0,0,0,.38)}.mat-slider.mat-slider-min-value:not(.mat-slider-thumb-label-showing):hover.mat-slider-disabled .mat-slider-thumb,.mat-slider.mat-slider-min-value:not(.mat-slider-thumb-label-showing).cdk-focused.mat-slider-disabled .mat-slider-thumb{border-color:rgba(0,0,0,.26)}.mat-slider-has-ticks .mat-slider-wrapper::after{border-color:rgba(0,0,0,.7)}.mat-slider-horizontal .mat-slider-ticks{background-image:repeating-linear-gradient(to right, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent);background-image:-moz-repeating-linear-gradient(0.0001deg, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-slider-vertical .mat-slider-ticks{background-image:repeating-linear-gradient(to bottom, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-menu-panel{background:#fff}.mat-menu-panel:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2), 0px 4px 5px 0px rgba(0, 0, 0, 0.14), 0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-menu-item{background:rgba(0,0,0,0);color:#212121}.mat-menu-item[disabled],.mat-menu-item[disabled] .mat-menu-submenu-icon,.mat-menu-item[disabled] .mat-icon-no-color{color:rgba(0,0,0,.38)}.mat-menu-item .mat-icon-no-color,.mat-menu-submenu-icon{color:rgba(0,0,0,.54)}.mat-menu-item:hover:not([disabled]),.mat-menu-item.cdk-program-focused:not([disabled]),.mat-menu-item.cdk-keyboard-focused:not([disabled]),.mat-menu-item-highlighted:not([disabled]){background:rgba(0,0,0,.04)}.mat-list-base .mat-list-item{color:#212121}.mat-list-base .mat-list-option{color:#212121}.mat-list-base .mat-subheader{color:#616161}.mat-list-base .mat-list-item-disabled{background-color:#eee;color:#757575}.mat-list-option:hover,.mat-list-option:focus,.mat-nav-list .mat-list-item:hover,.mat-nav-list .mat-list-item:focus,.mat-action-list .mat-list-item:hover,.mat-action-list .mat-list-item:focus{background:rgba(0,0,0,.04)}.mat-list-single-selected-option,.mat-list-single-selected-option:hover,.mat-list-single-selected-option:focus{background:rgba(0,0,0,.12)}.mat-paginator{background:#fff}.mat-paginator,.mat-paginator-page-size .mat-select-trigger{color:#616161}.mat-paginator-decrement,.mat-paginator-increment{border-top:2px solid rgba(0,0,0,.54);border-right:2px solid rgba(0,0,0,.54)}.mat-paginator-first,.mat-paginator-last{border-top:2px solid rgba(0,0,0,.54)}.mat-icon-button[disabled] .mat-paginator-decrement,.mat-icon-button[disabled] .mat-paginator-increment,.mat-icon-button[disabled] .mat-paginator-first,.mat-icon-button[disabled] .mat-paginator-last{border-color:rgba(0,0,0,.38)}.mat-paginator-container{min-height:56px}.mat-tab-nav-bar,.mat-tab-header{border-bottom:1px solid rgba(0,0,0,.12)}.mat-tab-group-inverted-header .mat-tab-nav-bar,.mat-tab-group-inverted-header .mat-tab-header{border-top:1px solid rgba(0,0,0,.12);border-bottom:none}.mat-tab-label,.mat-tab-link{color:#212121}.mat-tab-label.mat-tab-disabled,.mat-tab-link.mat-tab-disabled{color:#757575}.mat-tab-header-pagination-chevron{border-color:#212121}.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron{border-color:#757575}.mat-tab-group[class*=mat-background-]>.mat-tab-header,.mat-tab-nav-bar[class*=mat-background-]{border-bottom:none;border-top:none}.mat-tab-group.mat-primary .mat-tab-label.cdk-keyboard-focused,.mat-tab-group.mat-primary .mat-tab-label.cdk-program-focused,.mat-tab-group.mat-primary .mat-tab-link.cdk-keyboard-focused,.mat-tab-group.mat-primary .mat-tab-link.cdk-program-focused,.mat-tab-nav-bar.mat-primary .mat-tab-label.cdk-keyboard-focused,.mat-tab-nav-bar.mat-primary .mat-tab-label.cdk-program-focused,.mat-tab-nav-bar.mat-primary .mat-tab-link.cdk-keyboard-focused,.mat-tab-nav-bar.mat-primary .mat-tab-link.cdk-program-focused{background-color:rgba(255,167,38,.3)}.mat-tab-group.mat-primary .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-group.mat-primary .mat-tab-label.cdk-program-focused.mat-tab-disabled,.mat-tab-group.mat-primary .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-group.mat-primary .mat-tab-link.cdk-program-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-primary .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-primary .mat-tab-label.cdk-program-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-primary .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-primary .mat-tab-link.cdk-program-focused.mat-tab-disabled{background-color:rgba(0,0,0,.1)}.mat-tab-group.mat-primary .mat-ink-bar,.mat-tab-nav-bar.mat-primary .mat-ink-bar{background-color:#f57c00}.mat-tab-group.mat-primary.mat-background-primary>.mat-tab-header .mat-ink-bar,.mat-tab-group.mat-primary.mat-background-primary>.mat-tab-link-container .mat-ink-bar,.mat-tab-nav-bar.mat-primary.mat-background-primary>.mat-tab-header .mat-ink-bar,.mat-tab-nav-bar.mat-primary.mat-background-primary>.mat-tab-link-container .mat-ink-bar{background-color:#fff}.mat-tab-group.mat-accent .mat-tab-label.cdk-keyboard-focused,.mat-tab-group.mat-accent .mat-tab-label.cdk-program-focused,.mat-tab-group.mat-accent .mat-tab-link.cdk-keyboard-focused,.mat-tab-group.mat-accent .mat-tab-link.cdk-program-focused,.mat-tab-nav-bar.mat-accent .mat-tab-label.cdk-keyboard-focused,.mat-tab-nav-bar.mat-accent .mat-tab-label.cdk-program-focused,.mat-tab-nav-bar.mat-accent .mat-tab-link.cdk-keyboard-focused,.mat-tab-nav-bar.mat-accent .mat-tab-link.cdk-program-focused{background-color:rgba(255,224,178,.3)}.mat-tab-group.mat-accent .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-group.mat-accent .mat-tab-label.cdk-program-focused.mat-tab-disabled,.mat-tab-group.mat-accent .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-group.mat-accent .mat-tab-link.cdk-program-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-accent .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-accent .mat-tab-label.cdk-program-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-accent .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-accent .mat-tab-link.cdk-program-focused.mat-tab-disabled{background-color:rgba(0,0,0,.1)}.mat-tab-group.mat-accent .mat-ink-bar,.mat-tab-nav-bar.mat-accent .mat-ink-bar{background-color:#ff9800}.mat-tab-group.mat-accent.mat-background-accent>.mat-tab-header .mat-ink-bar,.mat-tab-group.mat-accent.mat-background-accent>.mat-tab-link-container .mat-ink-bar,.mat-tab-nav-bar.mat-accent.mat-background-accent>.mat-tab-header .mat-ink-bar,.mat-tab-nav-bar.mat-accent.mat-background-accent>.mat-tab-link-container .mat-ink-bar{background-color:#fff}.mat-tab-group.mat-warn .mat-tab-label.cdk-keyboard-focused,.mat-tab-group.mat-warn .mat-tab-label.cdk-program-focused,.mat-tab-group.mat-warn .mat-tab-link.cdk-keyboard-focused,.mat-tab-group.mat-warn .mat-tab-link.cdk-program-focused,.mat-tab-nav-bar.mat-warn .mat-tab-label.cdk-keyboard-focused,.mat-tab-nav-bar.mat-warn .mat-tab-label.cdk-program-focused,.mat-tab-nav-bar.mat-warn .mat-tab-link.cdk-keyboard-focused,.mat-tab-nav-bar.mat-warn .mat-tab-link.cdk-program-focused{background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-warn .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-group.mat-warn .mat-tab-label.cdk-program-focused.mat-tab-disabled,.mat-tab-group.mat-warn .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-group.mat-warn .mat-tab-link.cdk-program-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-warn .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-warn .mat-tab-label.cdk-program-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-warn .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-warn .mat-tab-link.cdk-program-focused.mat-tab-disabled{background-color:rgba(0,0,0,.1)}.mat-tab-group.mat-warn .mat-ink-bar,.mat-tab-nav-bar.mat-warn .mat-ink-bar{background-color:#f44336}.mat-tab-group.mat-warn.mat-background-warn>.mat-tab-header .mat-ink-bar,.mat-tab-group.mat-warn.mat-background-warn>.mat-tab-link-container .mat-ink-bar,.mat-tab-nav-bar.mat-warn.mat-background-warn>.mat-tab-header .mat-ink-bar,.mat-tab-nav-bar.mat-warn.mat-background-warn>.mat-tab-link-container .mat-ink-bar{background-color:#fff}.mat-tab-group.mat-background-primary .mat-tab-label.cdk-keyboard-focused,.mat-tab-group.mat-background-primary .mat-tab-label.cdk-program-focused,.mat-tab-group.mat-background-primary .mat-tab-link.cdk-keyboard-focused,.mat-tab-group.mat-background-primary .mat-tab-link.cdk-program-focused,.mat-tab-nav-bar.mat-background-primary .mat-tab-label.cdk-keyboard-focused,.mat-tab-nav-bar.mat-background-primary .mat-tab-label.cdk-program-focused,.mat-tab-nav-bar.mat-background-primary .mat-tab-link.cdk-keyboard-focused,.mat-tab-nav-bar.mat-background-primary .mat-tab-link.cdk-program-focused{background-color:rgba(255,167,38,.3)}.mat-tab-group.mat-background-primary .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-group.mat-background-primary .mat-tab-label.cdk-program-focused.mat-tab-disabled,.mat-tab-group.mat-background-primary .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-group.mat-background-primary .mat-tab-link.cdk-program-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-background-primary .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-background-primary .mat-tab-label.cdk-program-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-background-primary .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-background-primary .mat-tab-link.cdk-program-focused.mat-tab-disabled{background-color:rgba(0,0,0,.1)}.mat-tab-group.mat-background-primary>.mat-tab-header,.mat-tab-group.mat-background-primary>.mat-tab-link-container,.mat-tab-group.mat-background-primary>.mat-tab-header-pagination,.mat-tab-nav-bar.mat-background-primary>.mat-tab-header,.mat-tab-nav-bar.mat-background-primary>.mat-tab-link-container,.mat-tab-nav-bar.mat-background-primary>.mat-tab-header-pagination{background-color:#f57c00}.mat-tab-group.mat-background-primary>.mat-tab-header .mat-tab-label,.mat-tab-group.mat-background-primary>.mat-tab-link-container .mat-tab-link,.mat-tab-nav-bar.mat-background-primary>.mat-tab-header .mat-tab-label,.mat-tab-nav-bar.mat-background-primary>.mat-tab-link-container .mat-tab-link{color:#fff}.mat-tab-group.mat-background-primary>.mat-tab-header .mat-tab-label.mat-tab-disabled,.mat-tab-group.mat-background-primary>.mat-tab-link-container .mat-tab-link.mat-tab-disabled,.mat-tab-nav-bar.mat-background-primary>.mat-tab-header .mat-tab-label.mat-tab-disabled,.mat-tab-nav-bar.mat-background-primary>.mat-tab-link-container .mat-tab-link.mat-tab-disabled{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary>.mat-tab-header .mat-tab-header-pagination-chevron,.mat-tab-group.mat-background-primary>.mat-tab-header-pagination .mat-tab-header-pagination-chevron,.mat-tab-group.mat-background-primary>.mat-tab-link-container .mat-focus-indicator::before,.mat-tab-group.mat-background-primary>.mat-tab-header .mat-focus-indicator::before,.mat-tab-nav-bar.mat-background-primary>.mat-tab-header .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-primary>.mat-tab-header-pagination .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-primary>.mat-tab-link-container .mat-focus-indicator::before,.mat-tab-nav-bar.mat-background-primary>.mat-tab-header .mat-focus-indicator::before{border-color:#fff}.mat-tab-group.mat-background-primary>.mat-tab-header .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,.mat-tab-group.mat-background-primary>.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-primary>.mat-tab-header .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-primary>.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron{border-color:#fff;opacity:.4}.mat-tab-group.mat-background-primary>.mat-tab-header .mat-ripple-element,.mat-tab-group.mat-background-primary>.mat-tab-link-container .mat-ripple-element,.mat-tab-group.mat-background-primary>.mat-tab-header-pagination .mat-ripple-element,.mat-tab-nav-bar.mat-background-primary>.mat-tab-header .mat-ripple-element,.mat-tab-nav-bar.mat-background-primary>.mat-tab-link-container .mat-ripple-element,.mat-tab-nav-bar.mat-background-primary>.mat-tab-header-pagination .mat-ripple-element{background-color:#fff;opacity:.12}.mat-tab-group.mat-background-accent .mat-tab-label.cdk-keyboard-focused,.mat-tab-group.mat-background-accent .mat-tab-label.cdk-program-focused,.mat-tab-group.mat-background-accent .mat-tab-link.cdk-keyboard-focused,.mat-tab-group.mat-background-accent .mat-tab-link.cdk-program-focused,.mat-tab-nav-bar.mat-background-accent .mat-tab-label.cdk-keyboard-focused,.mat-tab-nav-bar.mat-background-accent .mat-tab-label.cdk-program-focused,.mat-tab-nav-bar.mat-background-accent .mat-tab-link.cdk-keyboard-focused,.mat-tab-nav-bar.mat-background-accent .mat-tab-link.cdk-program-focused{background-color:rgba(255,224,178,.3)}.mat-tab-group.mat-background-accent .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-group.mat-background-accent .mat-tab-label.cdk-program-focused.mat-tab-disabled,.mat-tab-group.mat-background-accent .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-group.mat-background-accent .mat-tab-link.cdk-program-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-background-accent .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-background-accent .mat-tab-label.cdk-program-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-background-accent .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-background-accent .mat-tab-link.cdk-program-focused.mat-tab-disabled{background-color:rgba(0,0,0,.1)}.mat-tab-group.mat-background-accent>.mat-tab-header,.mat-tab-group.mat-background-accent>.mat-tab-link-container,.mat-tab-group.mat-background-accent>.mat-tab-header-pagination,.mat-tab-nav-bar.mat-background-accent>.mat-tab-header,.mat-tab-nav-bar.mat-background-accent>.mat-tab-link-container,.mat-tab-nav-bar.mat-background-accent>.mat-tab-header-pagination{background-color:#ff9800}.mat-tab-group.mat-background-accent>.mat-tab-header .mat-tab-label,.mat-tab-group.mat-background-accent>.mat-tab-link-container .mat-tab-link,.mat-tab-nav-bar.mat-background-accent>.mat-tab-header .mat-tab-label,.mat-tab-nav-bar.mat-background-accent>.mat-tab-link-container .mat-tab-link{color:#fff}.mat-tab-group.mat-background-accent>.mat-tab-header .mat-tab-label.mat-tab-disabled,.mat-tab-group.mat-background-accent>.mat-tab-link-container .mat-tab-link.mat-tab-disabled,.mat-tab-nav-bar.mat-background-accent>.mat-tab-header .mat-tab-label.mat-tab-disabled,.mat-tab-nav-bar.mat-background-accent>.mat-tab-link-container .mat-tab-link.mat-tab-disabled{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent>.mat-tab-header .mat-tab-header-pagination-chevron,.mat-tab-group.mat-background-accent>.mat-tab-header-pagination .mat-tab-header-pagination-chevron,.mat-tab-group.mat-background-accent>.mat-tab-link-container .mat-focus-indicator::before,.mat-tab-group.mat-background-accent>.mat-tab-header .mat-focus-indicator::before,.mat-tab-nav-bar.mat-background-accent>.mat-tab-header .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-accent>.mat-tab-header-pagination .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-accent>.mat-tab-link-container .mat-focus-indicator::before,.mat-tab-nav-bar.mat-background-accent>.mat-tab-header .mat-focus-indicator::before{border-color:#fff}.mat-tab-group.mat-background-accent>.mat-tab-header .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,.mat-tab-group.mat-background-accent>.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-accent>.mat-tab-header .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-accent>.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron{border-color:#fff;opacity:.4}.mat-tab-group.mat-background-accent>.mat-tab-header .mat-ripple-element,.mat-tab-group.mat-background-accent>.mat-tab-link-container .mat-ripple-element,.mat-tab-group.mat-background-accent>.mat-tab-header-pagination .mat-ripple-element,.mat-tab-nav-bar.mat-background-accent>.mat-tab-header .mat-ripple-element,.mat-tab-nav-bar.mat-background-accent>.mat-tab-link-container .mat-ripple-element,.mat-tab-nav-bar.mat-background-accent>.mat-tab-header-pagination .mat-ripple-element{background-color:#fff;opacity:.12}.mat-tab-group.mat-background-warn .mat-tab-label.cdk-keyboard-focused,.mat-tab-group.mat-background-warn .mat-tab-label.cdk-program-focused,.mat-tab-group.mat-background-warn .mat-tab-link.cdk-keyboard-focused,.mat-tab-group.mat-background-warn .mat-tab-link.cdk-program-focused,.mat-tab-nav-bar.mat-background-warn .mat-tab-label.cdk-keyboard-focused,.mat-tab-nav-bar.mat-background-warn .mat-tab-label.cdk-program-focused,.mat-tab-nav-bar.mat-background-warn .mat-tab-link.cdk-keyboard-focused,.mat-tab-nav-bar.mat-background-warn .mat-tab-link.cdk-program-focused{background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-background-warn .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-group.mat-background-warn .mat-tab-label.cdk-program-focused.mat-tab-disabled,.mat-tab-group.mat-background-warn .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-group.mat-background-warn .mat-tab-link.cdk-program-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-background-warn .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-background-warn .mat-tab-label.cdk-program-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-background-warn .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-background-warn .mat-tab-link.cdk-program-focused.mat-tab-disabled{background-color:rgba(0,0,0,.1)}.mat-tab-group.mat-background-warn>.mat-tab-header,.mat-tab-group.mat-background-warn>.mat-tab-link-container,.mat-tab-group.mat-background-warn>.mat-tab-header-pagination,.mat-tab-nav-bar.mat-background-warn>.mat-tab-header,.mat-tab-nav-bar.mat-background-warn>.mat-tab-link-container,.mat-tab-nav-bar.mat-background-warn>.mat-tab-header-pagination{background-color:#f44336}.mat-tab-group.mat-background-warn>.mat-tab-header .mat-tab-label,.mat-tab-group.mat-background-warn>.mat-tab-link-container .mat-tab-link,.mat-tab-nav-bar.mat-background-warn>.mat-tab-header .mat-tab-label,.mat-tab-nav-bar.mat-background-warn>.mat-tab-link-container .mat-tab-link{color:#fff}.mat-tab-group.mat-background-warn>.mat-tab-header .mat-tab-label.mat-tab-disabled,.mat-tab-group.mat-background-warn>.mat-tab-link-container .mat-tab-link.mat-tab-disabled,.mat-tab-nav-bar.mat-background-warn>.mat-tab-header .mat-tab-label.mat-tab-disabled,.mat-tab-nav-bar.mat-background-warn>.mat-tab-link-container .mat-tab-link.mat-tab-disabled{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn>.mat-tab-header .mat-tab-header-pagination-chevron,.mat-tab-group.mat-background-warn>.mat-tab-header-pagination .mat-tab-header-pagination-chevron,.mat-tab-group.mat-background-warn>.mat-tab-link-container .mat-focus-indicator::before,.mat-tab-group.mat-background-warn>.mat-tab-header .mat-focus-indicator::before,.mat-tab-nav-bar.mat-background-warn>.mat-tab-header .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-warn>.mat-tab-header-pagination .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-warn>.mat-tab-link-container .mat-focus-indicator::before,.mat-tab-nav-bar.mat-background-warn>.mat-tab-header .mat-focus-indicator::before{border-color:#fff}.mat-tab-group.mat-background-warn>.mat-tab-header .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,.mat-tab-group.mat-background-warn>.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-warn>.mat-tab-header .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-warn>.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron{border-color:#fff;opacity:.4}.mat-tab-group.mat-background-warn>.mat-tab-header .mat-ripple-element,.mat-tab-group.mat-background-warn>.mat-tab-link-container .mat-ripple-element,.mat-tab-group.mat-background-warn>.mat-tab-header-pagination .mat-ripple-element,.mat-tab-nav-bar.mat-background-warn>.mat-tab-header .mat-ripple-element,.mat-tab-nav-bar.mat-background-warn>.mat-tab-link-container .mat-ripple-element,.mat-tab-nav-bar.mat-background-warn>.mat-tab-header-pagination .mat-ripple-element{background-color:#fff;opacity:.12}.mat-snack-bar-container{color:rgba(255,255,255,.7);background:#323232;box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2), 0px 6px 10px 0px rgba(0, 0, 0, 0.14), 0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-simple-snackbar-action{color:#ff9800}.mat-table{background:#fff}.mat-table thead,.mat-table tbody,.mat-table tfoot,mat-header-row,mat-row,mat-footer-row,[mat-header-row],[mat-row],[mat-footer-row],.mat-table-sticky{background:inherit}mat-row,mat-header-row,mat-footer-row,th.mat-header-cell,td.mat-cell,td.mat-footer-cell{border-bottom-color:rgba(0,0,0,.12)}.mat-header-cell{color:#616161}.mat-cell,.mat-footer-cell{color:#212121}.mat-badge{position:relative}.mat-badge.mat-badge{overflow:visible}.mat-badge-hidden .mat-badge-content{display:none}.mat-badge-content{position:absolute;text-align:center;display:inline-block;border-radius:50%;transition:transform 200ms ease-in-out;transform:scale(0.6);overflow:hidden;white-space:nowrap;text-overflow:ellipsis;pointer-events:none}.ng-animate-disabled .mat-badge-content,.mat-badge-content._mat-animation-noopable{transition:none}.mat-badge-content.mat-badge-active{transform:none}.mat-badge-small .mat-badge-content{width:16px;height:16px;line-height:16px}.mat-badge-small.mat-badge-above .mat-badge-content{top:-8px}.mat-badge-small.mat-badge-below .mat-badge-content{bottom:-8px}.mat-badge-small.mat-badge-before .mat-badge-content{left:-16px}[dir=rtl] .mat-badge-small.mat-badge-before .mat-badge-content{left:auto;right:-16px}.mat-badge-small.mat-badge-after .mat-badge-content{right:-16px}[dir=rtl] .mat-badge-small.mat-badge-after .mat-badge-content{right:auto;left:-16px}.mat-badge-small.mat-badge-overlap.mat-badge-before .mat-badge-content{left:-8px}[dir=rtl] .mat-badge-small.mat-badge-overlap.mat-badge-before .mat-badge-content{left:auto;right:-8px}.mat-badge-small.mat-badge-overlap.mat-badge-after .mat-badge-content{right:-8px}[dir=rtl] .mat-badge-small.mat-badge-overlap.mat-badge-after .mat-badge-content{right:auto;left:-8px}.mat-badge-medium .mat-badge-content{width:22px;height:22px;line-height:22px}.mat-badge-medium.mat-badge-above .mat-badge-content{top:-11px}.mat-badge-medium.mat-badge-below .mat-badge-content{bottom:-11px}.mat-badge-medium.mat-badge-before .mat-badge-content{left:-22px}[dir=rtl] .mat-badge-medium.mat-badge-before .mat-badge-content{left:auto;right:-22px}.mat-badge-medium.mat-badge-after .mat-badge-content{right:-22px}[dir=rtl] .mat-badge-medium.mat-badge-after .mat-badge-content{right:auto;left:-22px}.mat-badge-medium.mat-badge-overlap.mat-badge-before .mat-badge-content{left:-11px}[dir=rtl] .mat-badge-medium.mat-badge-overlap.mat-badge-before .mat-badge-content{left:auto;right:-11px}.mat-badge-medium.mat-badge-overlap.mat-badge-after .mat-badge-content{right:-11px}[dir=rtl] .mat-badge-medium.mat-badge-overlap.mat-badge-after .mat-badge-content{right:auto;left:-11px}.mat-badge-large .mat-badge-content{width:28px;height:28px;line-height:28px}.mat-badge-large.mat-badge-above .mat-badge-content{top:-14px}.mat-badge-large.mat-badge-below .mat-badge-content{bottom:-14px}.mat-badge-large.mat-badge-before .mat-badge-content{left:-28px}[dir=rtl] .mat-badge-large.mat-badge-before .mat-badge-content{left:auto;right:-28px}.mat-badge-large.mat-badge-after .mat-badge-content{right:-28px}[dir=rtl] .mat-badge-large.mat-badge-after .mat-badge-content{right:auto;left:-28px}.mat-badge-large.mat-badge-overlap.mat-badge-before .mat-badge-content{left:-14px}[dir=rtl] .mat-badge-large.mat-badge-overlap.mat-badge-before .mat-badge-content{left:auto;right:-14px}.mat-badge-large.mat-badge-overlap.mat-badge-after .mat-badge-content{right:-14px}[dir=rtl] .mat-badge-large.mat-badge-overlap.mat-badge-after .mat-badge-content{right:auto;left:-14px}.mat-badge-content{color:#fff;background:#f57c00}.cdk-high-contrast-active .mat-badge-content{outline:solid 1px;border-radius:0}.mat-badge-accent .mat-badge-content{background:#ff9800;color:#fff}.mat-badge-warn .mat-badge-content{color:#fff;background:#f44336}.mat-badge-disabled .mat-badge-content{background:#bdbdbd;color:#757575}.mat-bottom-sheet-container{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2), 0px 16px 24px 2px rgba(0, 0, 0, 0.14), 0px 6px 30px 5px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-button-toggle-standalone:not([class*=mat-elevation-z]),.mat-button-toggle-group:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2), 0px 2px 2px 0px rgba(0, 0, 0, 0.14), 0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard:not([class*=mat-elevation-z]),.mat-button-toggle-group-appearance-standard:not([class*=mat-elevation-z]){box-shadow:none}.mat-button-toggle{color:rgba(0,0,0,.38)}.mat-button-toggle .mat-button-toggle-focus-overlay{background-color:rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard{color:#212121;background:#fff}.mat-button-toggle-appearance-standard .mat-button-toggle-focus-overlay{background-color:#000}.mat-button-toggle-group-appearance-standard .mat-button-toggle+.mat-button-toggle{border-left:solid 1px #e0e0e0}[dir=rtl] .mat-button-toggle-group-appearance-standard .mat-button-toggle+.mat-button-toggle{border-left:none;border-right:solid 1px #e0e0e0}.mat-button-toggle-group-appearance-standard.mat-button-toggle-vertical .mat-button-toggle+.mat-button-toggle{border-left:none;border-right:none;border-top:solid 1px #e0e0e0}.mat-button-toggle-checked{background-color:#e0e0e0;color:#616161}.mat-button-toggle-checked.mat-button-toggle-appearance-standard{color:#212121}.mat-button-toggle-disabled{color:rgba(0,0,0,.26);background-color:#eee}.mat-button-toggle-disabled.mat-button-toggle-appearance-standard{background:#fff}.mat-button-toggle-disabled.mat-button-toggle-checked{background-color:#bdbdbd}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard,.mat-button-toggle-group-appearance-standard{border:solid 1px #e0e0e0}.mat-button-toggle-appearance-standard .mat-button-toggle-label-content{line-height:48px}.mat-calendar-arrow{fill:rgba(0,0,0,.54)}.mat-datepicker-toggle,.mat-datepicker-content .mat-calendar-next-button,.mat-datepicker-content .mat-calendar-previous-button{color:rgba(0,0,0,.54)}.mat-calendar-table-header-divider::after{background:rgba(0,0,0,.12)}.mat-calendar-table-header,.mat-calendar-body-label{color:#616161}.mat-calendar-body-cell-content,.mat-date-range-input-separator{color:#212121;border-color:rgba(0,0,0,0)}.mat-calendar-body-disabled>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){color:#757575}.mat-form-field-disabled .mat-date-range-input-separator{color:#757575}.mat-calendar-body-in-preview{color:rgba(0,0,0,.24)}.mat-calendar-body-today:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.38)}.mat-calendar-body-disabled>.mat-calendar-body-today:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.18)}.mat-calendar-body-in-range::before{background:rgba(245,124,0,.2)}.mat-calendar-body-comparison-identical,.mat-calendar-body-in-comparison-range::before{background:rgba(249,171,0,.2)}.mat-calendar-body-comparison-bridge-start::before,[dir=rtl] .mat-calendar-body-comparison-bridge-end::before{background:linear-gradient(to right, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-comparison-bridge-end::before,[dir=rtl] .mat-calendar-body-comparison-bridge-start::before{background:linear-gradient(to left, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-in-range>.mat-calendar-body-comparison-identical,.mat-calendar-body-in-comparison-range.mat-calendar-body-in-range::after{background:#a8dab5}.mat-calendar-body-comparison-identical.mat-calendar-body-selected,.mat-calendar-body-in-comparison-range>.mat-calendar-body-selected{background:#46a35e}.mat-calendar-body-selected{background-color:#f57c00;color:#fff}.mat-calendar-body-disabled>.mat-calendar-body-selected{background-color:rgba(245,124,0,.4)}.mat-calendar-body-today.mat-calendar-body-selected{box-shadow:inset 0 0 0 1px #fff}.cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical),.cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(245,124,0,.3)}@media(hover: hover){.mat-calendar-body-cell:not(.mat-calendar-body-disabled):hover>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(245,124,0,.3)}}.mat-datepicker-content{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2), 0px 4px 5px 0px rgba(0, 0, 0, 0.14), 0px 1px 10px 0px rgba(0, 0, 0, 0.12);background-color:#fff;color:#212121}.mat-datepicker-content.mat-accent .mat-calendar-body-in-range::before{background:rgba(255,152,0,.2)}.mat-datepicker-content.mat-accent .mat-calendar-body-comparison-identical,.mat-datepicker-content.mat-accent .mat-calendar-body-in-comparison-range::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-accent .mat-calendar-body-comparison-bridge-start::before,.mat-datepicker-content.mat-accent [dir=rtl] .mat-calendar-body-comparison-bridge-end::before{background:linear-gradient(to right, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent .mat-calendar-body-comparison-bridge-end::before,.mat-datepicker-content.mat-accent [dir=rtl] .mat-calendar-body-comparison-bridge-start::before{background:linear-gradient(to left, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent .mat-calendar-body-in-range>.mat-calendar-body-comparison-identical,.mat-datepicker-content.mat-accent .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range::after{background:#a8dab5}.mat-datepicker-content.mat-accent .mat-calendar-body-comparison-identical.mat-calendar-body-selected,.mat-datepicker-content.mat-accent .mat-calendar-body-in-comparison-range>.mat-calendar-body-selected{background:#46a35e}.mat-datepicker-content.mat-accent .mat-calendar-body-selected{background-color:#ff9800;color:#fff}.mat-datepicker-content.mat-accent .mat-calendar-body-disabled>.mat-calendar-body-selected{background-color:rgba(255,152,0,.4)}.mat-datepicker-content.mat-accent .mat-calendar-body-today.mat-calendar-body-selected{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content.mat-accent .cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical),.mat-datepicker-content.mat-accent .cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(255,152,0,.3)}@media(hover: hover){.mat-datepicker-content.mat-accent .mat-calendar-body-cell:not(.mat-calendar-body-disabled):hover>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(255,152,0,.3)}}.mat-datepicker-content.mat-warn .mat-calendar-body-in-range::before{background:rgba(244,67,54,.2)}.mat-datepicker-content.mat-warn .mat-calendar-body-comparison-identical,.mat-datepicker-content.mat-warn .mat-calendar-body-in-comparison-range::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-warn .mat-calendar-body-comparison-bridge-start::before,.mat-datepicker-content.mat-warn [dir=rtl] .mat-calendar-body-comparison-bridge-end::before{background:linear-gradient(to right, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn .mat-calendar-body-comparison-bridge-end::before,.mat-datepicker-content.mat-warn [dir=rtl] .mat-calendar-body-comparison-bridge-start::before{background:linear-gradient(to left, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn .mat-calendar-body-in-range>.mat-calendar-body-comparison-identical,.mat-datepicker-content.mat-warn .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range::after{background:#a8dab5}.mat-datepicker-content.mat-warn .mat-calendar-body-comparison-identical.mat-calendar-body-selected,.mat-datepicker-content.mat-warn .mat-calendar-body-in-comparison-range>.mat-calendar-body-selected{background:#46a35e}.mat-datepicker-content.mat-warn .mat-calendar-body-selected{background-color:#f44336;color:#fff}.mat-datepicker-content.mat-warn .mat-calendar-body-disabled>.mat-calendar-body-selected{background-color:rgba(244,67,54,.4)}.mat-datepicker-content.mat-warn .mat-calendar-body-today.mat-calendar-body-selected{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content.mat-warn .cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical),.mat-datepicker-content.mat-warn .cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(244,67,54,.3)}@media(hover: hover){.mat-datepicker-content.mat-warn .mat-calendar-body-cell:not(.mat-calendar-body-disabled):hover>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(244,67,54,.3)}}.mat-datepicker-content-touch{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2), 0px 24px 38px 3px rgba(0, 0, 0, 0.14), 0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-datepicker-toggle-active{color:#f57c00}.mat-datepicker-toggle-active.mat-accent{color:#ff9800}.mat-datepicker-toggle-active.mat-warn{color:#f44336}.mat-date-range-input-inner[disabled]{color:#757575}.mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base{width:40px;height:40px;padding:8px}.mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base .mdc-icon-button__focus-ring{max-height:40px;max-width:40px}.mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base.mdc-icon-button--reduced-size .mdc-icon-button__ripple{width:40px;height:40px;margin-top:0px;margin-bottom:0px;margin-right:0px;margin-left:0px}.mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base.mdc-icon-button--reduced-size .mdc-icon-button__focus-ring{max-height:40px;max-width:40px}.mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base .mdc-icon-button__touch{position:absolute;top:50%;height:40px;left:50%;width:40px;transform:translate(-50%, -50%)}.mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base .mat-mdc-button-touch-target{display:none}.mat-divider{border-top-color:rgba(0,0,0,.12)}.mat-divider-vertical{border-right-color:rgba(0,0,0,.12)}.mat-expansion-panel{background:#fff;color:#212121}.mat-expansion-panel:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2), 0px 2px 2px 0px rgba(0, 0, 0, 0.14), 0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-action-row{border-top-color:rgba(0,0,0,.12)}.mat-expansion-panel .mat-expansion-panel-header.cdk-keyboard-focused:not([aria-disabled=true]),.mat-expansion-panel .mat-expansion-panel-header.cdk-program-focused:not([aria-disabled=true]),.mat-expansion-panel:not(.mat-expanded) .mat-expansion-panel-header:hover:not([aria-disabled=true]){background:rgba(0,0,0,.04)}@media(hover: none){.mat-expansion-panel:not(.mat-expanded):not([aria-disabled=true]) .mat-expansion-panel-header:hover{background:#fff}}.mat-expansion-panel-header-title{color:#212121}.mat-expansion-panel-header-description,.mat-expansion-indicator::after{color:#616161}.mat-expansion-panel-header[aria-disabled=true]{color:rgba(0,0,0,.26)}.mat-expansion-panel-header[aria-disabled=true] .mat-expansion-panel-header-title,.mat-expansion-panel-header[aria-disabled=true] .mat-expansion-panel-header-description{color:inherit}.mat-expansion-panel-header{height:48px}.mat-expansion-panel-header.mat-expanded{height:64px}.mat-icon.mat-primary{color:#f57c00}.mat-icon.mat-accent{color:#ff9800}.mat-icon.mat-warn{color:#f44336}.mat-drawer-container{background-color:#fff;color:#212121}.mat-drawer{background-color:#fff;color:#212121}.mat-drawer.mat-drawer-push{background-color:#fff}.mat-drawer:not(.mat-drawer-side){box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2), 0px 16px 24px 2px rgba(0, 0, 0, 0.14), 0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-drawer-side{border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-side.mat-drawer-end{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl] .mat-drawer-side{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl] .mat-drawer-side.mat-drawer-end{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-backdrop.mat-drawer-shown{background-color:rgba(0,0,0,.6)}.mat-step-header.cdk-keyboard-focused,.mat-step-header.cdk-program-focused,.mat-step-header:hover:not([aria-disabled]),.mat-step-header:hover[aria-disabled=false]{background-color:rgba(0,0,0,.04)}.mat-step-header:hover[aria-disabled=true]{cursor:default}@media(hover: none){.mat-step-header:hover{background:none}}.mat-step-header .mat-step-label,.mat-step-header .mat-step-optional{color:#616161}.mat-step-header .mat-step-icon{background-color:#616161;color:#fff}.mat-step-header .mat-step-icon-selected,.mat-step-header .mat-step-icon-state-done,.mat-step-header .mat-step-icon-state-edit{background-color:#f57c00;color:#fff}.mat-step-header.mat-accent .mat-step-icon{color:#fff}.mat-step-header.mat-accent .mat-step-icon-selected,.mat-step-header.mat-accent .mat-step-icon-state-done,.mat-step-header.mat-accent .mat-step-icon-state-edit{background-color:#ff9800;color:#fff}.mat-step-header.mat-warn .mat-step-icon{color:#fff}.mat-step-header.mat-warn .mat-step-icon-selected,.mat-step-header.mat-warn .mat-step-icon-state-done,.mat-step-header.mat-warn .mat-step-icon-state-edit{background-color:#f44336;color:#fff}.mat-step-header .mat-step-icon-state-error{background-color:rgba(0,0,0,0);color:#f44336}.mat-step-header .mat-step-label.mat-step-label-active{color:#212121}.mat-step-header .mat-step-label.mat-step-label-error{color:#f44336}.mat-stepper-horizontal,.mat-stepper-vertical{background-color:#fff}.mat-stepper-vertical-line::before{border-left-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header::before,.mat-horizontal-stepper-header::after,.mat-stepper-horizontal-line{border-top-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header{height:72px}.mat-stepper-label-position-bottom .mat-horizontal-stepper-header,.mat-vertical-stepper-header{padding:24px 24px}.mat-stepper-vertical-line::before{top:-16px;bottom:-16px}.mat-stepper-label-position-bottom .mat-horizontal-stepper-header::after,.mat-stepper-label-position-bottom .mat-horizontal-stepper-header::before{top:36px}.mat-stepper-label-position-bottom .mat-stepper-horizontal-line{top:36px}.mat-sort-header-arrow{color:#616161}.mat-toolbar{background:#f57c00;color:#212121}.mat-toolbar.mat-primary{background:#f57c00;color:#fff}.mat-toolbar.mat-accent{background:#ff9800;color:#fff}.mat-toolbar.mat-warn{background:#f44336;color:#fff}.mat-toolbar .mat-form-field-underline,.mat-toolbar .mat-form-field-ripple,.mat-toolbar .mat-focused .mat-form-field-ripple{background-color:currentColor}.mat-toolbar .mat-form-field-label,.mat-toolbar .mat-focused .mat-form-field-label,.mat-toolbar .mat-select-value,.mat-toolbar .mat-select-arrow,.mat-toolbar .mat-form-field.mat-focused .mat-select-arrow{color:inherit}.mat-toolbar .mat-input-element{caret-color:currentColor}.mat-toolbar-multiple-rows{min-height:64px}.mat-toolbar-row,.mat-toolbar-single-row{height:64px}@media(max-width: 599px){.mat-toolbar-multiple-rows{min-height:56px}.mat-toolbar-row,.mat-toolbar-single-row{height:56px}}.mat-tree{background:#fff}.mat-tree-node,.mat-nested-tree-node{color:#212121}.mat-tree-node{min-height:48px}body{overflow:hidden}.cdk-overlay-container{contain:strict}a:not(.mat-button,.mat-icon-button){color:#1976d2}a:not(.mat-button,.mat-icon-button):visited{color:#7b1fa2}body.dark-mode{background-color:#303030}body.dark-mode a:not(.mat-button,.mat-icon-button){color:#42a5f5}body.dark-mode a:not(.mat-button,.mat-icon-button):visited{color:#ba68c8}body.dark-mode .mat-button,body.dark-mode .mat-icon-button,body.dark-mode .mat-stroked-button{color:inherit;background:rgba(0,0,0,0)}body.dark-mode .mat-button.mat-primary,body.dark-mode .mat-icon-button.mat-primary,body.dark-mode .mat-stroked-button.mat-primary{color:#ef6c00}body.dark-mode .mat-button.mat-accent,body.dark-mode .mat-icon-button.mat-accent,body.dark-mode .mat-stroked-button.mat-accent{color:#ef6c00}body.dark-mode .mat-button.mat-warn,body.dark-mode .mat-icon-button.mat-warn,body.dark-mode .mat-stroked-button.mat-warn{color:#f44336}body.dark-mode .mat-button.mat-primary.mat-button-disabled,body.dark-mode .mat-button.mat-accent.mat-button-disabled,body.dark-mode .mat-button.mat-warn.mat-button-disabled,body.dark-mode .mat-button.mat-button-disabled.mat-button-disabled,body.dark-mode .mat-icon-button.mat-primary.mat-button-disabled,body.dark-mode .mat-icon-button.mat-accent.mat-button-disabled,body.dark-mode .mat-icon-button.mat-warn.mat-button-disabled,body.dark-mode .mat-icon-button.mat-button-disabled.mat-button-disabled,body.dark-mode .mat-stroked-button.mat-primary.mat-button-disabled,body.dark-mode .mat-stroked-button.mat-accent.mat-button-disabled,body.dark-mode .mat-stroked-button.mat-warn.mat-button-disabled,body.dark-mode .mat-stroked-button.mat-button-disabled.mat-button-disabled{color:rgba(255,255,255,.3)}body.dark-mode .mat-button.mat-primary .mat-button-focus-overlay,body.dark-mode .mat-icon-button.mat-primary .mat-button-focus-overlay,body.dark-mode .mat-stroked-button.mat-primary .mat-button-focus-overlay{background-color:#ef6c00}body.dark-mode .mat-button.mat-accent .mat-button-focus-overlay,body.dark-mode .mat-icon-button.mat-accent .mat-button-focus-overlay,body.dark-mode .mat-stroked-button.mat-accent .mat-button-focus-overlay{background-color:#ef6c00}body.dark-mode .mat-button.mat-warn .mat-button-focus-overlay,body.dark-mode .mat-icon-button.mat-warn .mat-button-focus-overlay,body.dark-mode .mat-stroked-button.mat-warn .mat-button-focus-overlay{background-color:#f44336}body.dark-mode .mat-button.mat-button-disabled .mat-button-focus-overlay,body.dark-mode .mat-icon-button.mat-button-disabled .mat-button-focus-overlay,body.dark-mode .mat-stroked-button.mat-button-disabled .mat-button-focus-overlay{background-color:rgba(0,0,0,0)}body.dark-mode .mat-button .mat-ripple-element,body.dark-mode .mat-icon-button .mat-ripple-element,body.dark-mode .mat-stroked-button .mat-ripple-element{opacity:.1;background-color:currentColor}body.dark-mode .mat-button-focus-overlay{background:#fff}body.dark-mode .mat-stroked-button:not(.mat-button-disabled){border-color:rgba(255,255,255,.12)}body.dark-mode .mat-flat-button,body.dark-mode .mat-raised-button,body.dark-mode .mat-fab,body.dark-mode .mat-mini-fab{color:#fff;background-color:#424242}body.dark-mode .mat-flat-button.mat-primary,body.dark-mode .mat-raised-button.mat-primary,body.dark-mode .mat-fab.mat-primary,body.dark-mode .mat-mini-fab.mat-primary{color:#fff}body.dark-mode .mat-flat-button.mat-accent,body.dark-mode .mat-raised-button.mat-accent,body.dark-mode .mat-fab.mat-accent,body.dark-mode .mat-mini-fab.mat-accent{color:#fff}body.dark-mode .mat-flat-button.mat-warn,body.dark-mode .mat-raised-button.mat-warn,body.dark-mode .mat-fab.mat-warn,body.dark-mode .mat-mini-fab.mat-warn{color:#fff}body.dark-mode .mat-flat-button.mat-primary.mat-button-disabled,body.dark-mode .mat-flat-button.mat-accent.mat-button-disabled,body.dark-mode .mat-flat-button.mat-warn.mat-button-disabled,body.dark-mode .mat-flat-button.mat-button-disabled.mat-button-disabled,body.dark-mode .mat-raised-button.mat-primary.mat-button-disabled,body.dark-mode .mat-raised-button.mat-accent.mat-button-disabled,body.dark-mode .mat-raised-button.mat-warn.mat-button-disabled,body.dark-mode .mat-raised-button.mat-button-disabled.mat-button-disabled,body.dark-mode .mat-fab.mat-primary.mat-button-disabled,body.dark-mode .mat-fab.mat-accent.mat-button-disabled,body.dark-mode .mat-fab.mat-warn.mat-button-disabled,body.dark-mode .mat-fab.mat-button-disabled.mat-button-disabled,body.dark-mode .mat-mini-fab.mat-primary.mat-button-disabled,body.dark-mode .mat-mini-fab.mat-accent.mat-button-disabled,body.dark-mode .mat-mini-fab.mat-warn.mat-button-disabled,body.dark-mode .mat-mini-fab.mat-button-disabled.mat-button-disabled{color:rgba(255,255,255,.3)}body.dark-mode .mat-flat-button.mat-primary,body.dark-mode .mat-raised-button.mat-primary,body.dark-mode .mat-fab.mat-primary,body.dark-mode .mat-mini-fab.mat-primary{background-color:#ef6c00}body.dark-mode .mat-flat-button.mat-accent,body.dark-mode .mat-raised-button.mat-accent,body.dark-mode .mat-fab.mat-accent,body.dark-mode .mat-mini-fab.mat-accent{background-color:#ef6c00}body.dark-mode .mat-flat-button.mat-warn,body.dark-mode .mat-raised-button.mat-warn,body.dark-mode .mat-fab.mat-warn,body.dark-mode .mat-mini-fab.mat-warn{background-color:#f44336}body.dark-mode .mat-flat-button.mat-primary.mat-button-disabled,body.dark-mode .mat-flat-button.mat-accent.mat-button-disabled,body.dark-mode .mat-flat-button.mat-warn.mat-button-disabled,body.dark-mode .mat-flat-button.mat-button-disabled.mat-button-disabled,body.dark-mode .mat-raised-button.mat-primary.mat-button-disabled,body.dark-mode .mat-raised-button.mat-accent.mat-button-disabled,body.dark-mode .mat-raised-button.mat-warn.mat-button-disabled,body.dark-mode .mat-raised-button.mat-button-disabled.mat-button-disabled,body.dark-mode .mat-fab.mat-primary.mat-button-disabled,body.dark-mode .mat-fab.mat-accent.mat-button-disabled,body.dark-mode .mat-fab.mat-warn.mat-button-disabled,body.dark-mode .mat-fab.mat-button-disabled.mat-button-disabled,body.dark-mode .mat-mini-fab.mat-primary.mat-button-disabled,body.dark-mode .mat-mini-fab.mat-accent.mat-button-disabled,body.dark-mode .mat-mini-fab.mat-warn.mat-button-disabled,body.dark-mode .mat-mini-fab.mat-button-disabled.mat-button-disabled{background-color:rgba(255,255,255,.12)}body.dark-mode .mat-flat-button.mat-primary .mat-ripple-element,body.dark-mode .mat-raised-button.mat-primary .mat-ripple-element,body.dark-mode .mat-fab.mat-primary .mat-ripple-element,body.dark-mode .mat-mini-fab.mat-primary .mat-ripple-element{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-flat-button.mat-accent .mat-ripple-element,body.dark-mode .mat-raised-button.mat-accent .mat-ripple-element,body.dark-mode .mat-fab.mat-accent .mat-ripple-element,body.dark-mode .mat-mini-fab.mat-accent .mat-ripple-element{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-flat-button.mat-warn .mat-ripple-element,body.dark-mode .mat-raised-button.mat-warn .mat-ripple-element,body.dark-mode .mat-fab.mat-warn .mat-ripple-element,body.dark-mode .mat-mini-fab.mat-warn .mat-ripple-element{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-stroked-button:not([class*=mat-elevation-z]),body.dark-mode .mat-flat-button:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2), 0px 0px 0px 0px rgba(0, 0, 0, 0.14), 0px 0px 0px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-raised-button:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2), 0px 2px 2px 0px rgba(0, 0, 0, 0.14), 0px 1px 5px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-raised-button:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2), 0px 8px 10px 1px rgba(0, 0, 0, 0.14), 0px 3px 14px 2px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-raised-button.mat-button-disabled:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2), 0px 0px 0px 0px rgba(0, 0, 0, 0.14), 0px 0px 0px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-fab:not([class*=mat-elevation-z]),body.dark-mode .mat-mini-fab:not([class*=mat-elevation-z]){box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2), 0px 6px 10px 0px rgba(0, 0, 0, 0.14), 0px 1px 18px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-fab:not(.mat-button-disabled):active:not([class*=mat-elevation-z]),body.dark-mode .mat-mini-fab:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2), 0px 12px 17px 2px rgba(0, 0, 0, 0.14), 0px 5px 22px 4px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-fab.mat-button-disabled:not([class*=mat-elevation-z]),body.dark-mode .mat-mini-fab.mat-button-disabled:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2), 0px 0px 0px 0px rgba(0, 0, 0, 0.14), 0px 0px 0px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-datepicker-content .mat-mdc-button.mat-unthemed{--mdc-text-button-label-text-color:#fff}body.dark-mode .mat-datepicker-content .mat-mdc-button.mat-primary{--mdc-text-button-label-text-color:#ef6c00}body.dark-mode .mat-datepicker-content .mat-mdc-button.mat-accent{--mdc-text-button-label-text-color:#ef6c00}body.dark-mode .mat-datepicker-content .mat-mdc-button.mat-warn{--mdc-text-button-label-text-color:#f44336}body.dark-mode .mat-datepicker-content .mat-mdc-button[disabled][disabled]{--mdc-text-button-disabled-label-text-color:rgba(255, 255, 255, 0.5);--mdc-text-button-label-text-color:rgba(255, 255, 255, 0.5)}body.dark-mode .mat-datepicker-content .mat-mdc-unelevated-button.mat-unthemed{--mdc-filled-button-container-color:#424242;--mdc-filled-button-label-text-color:#fff}body.dark-mode .mat-datepicker-content .mat-mdc-unelevated-button.mat-primary{--mdc-filled-button-container-color:#ef6c00;--mdc-filled-button-label-text-color:#000}body.dark-mode .mat-datepicker-content .mat-mdc-unelevated-button.mat-accent{--mdc-filled-button-container-color:#ef6c00;--mdc-filled-button-label-text-color:#000}body.dark-mode .mat-datepicker-content .mat-mdc-unelevated-button.mat-warn{--mdc-filled-button-container-color:#f44336;--mdc-filled-button-label-text-color:#fff}body.dark-mode .mat-datepicker-content .mat-mdc-unelevated-button[disabled][disabled]{--mdc-filled-button-disabled-container-color:rgba(255, 255, 255, 0.12);--mdc-filled-button-disabled-label-text-color:rgba(255, 255, 255, 0.5);--mdc-filled-button-container-color:rgba(255, 255, 255, 0.12);--mdc-filled-button-label-text-color:rgba(255, 255, 255, 0.5)}body.dark-mode .mat-datepicker-content .mat-mdc-raised-button.mat-unthemed{--mdc-protected-button-container-color:#424242;--mdc-protected-button-label-text-color:#fff}body.dark-mode .mat-datepicker-content .mat-mdc-raised-button.mat-primary{--mdc-protected-button-container-color:#ef6c00;--mdc-protected-button-label-text-color:#000}body.dark-mode .mat-datepicker-content .mat-mdc-raised-button.mat-accent{--mdc-protected-button-container-color:#ef6c00;--mdc-protected-button-label-text-color:#000}body.dark-mode .mat-datepicker-content .mat-mdc-raised-button.mat-warn{--mdc-protected-button-container-color:#f44336;--mdc-protected-button-label-text-color:#fff}body.dark-mode .mat-datepicker-content .mat-mdc-raised-button[disabled][disabled]{--mdc-protected-button-disabled-container-color:rgba(255, 255, 255, 0.12);--mdc-protected-button-disabled-label-text-color:rgba(255, 255, 255, 0.5);--mdc-protected-button-container-color:rgba(255, 255, 255, 0.12);--mdc-protected-button-label-text-color:rgba(255, 255, 255, 0.5);--mdc-protected-button-container-elevation:0}body.dark-mode .mat-datepicker-content .mat-mdc-outlined-button{--mdc-outlined-button-outline-color:rgba(255, 255, 255, 0.12)}body.dark-mode .mat-datepicker-content .mat-mdc-outlined-button.mat-unthemed{--mdc-outlined-button-label-text-color:#fff}body.dark-mode .mat-datepicker-content .mat-mdc-outlined-button.mat-primary{--mdc-outlined-button-label-text-color:#ef6c00}body.dark-mode .mat-datepicker-content .mat-mdc-outlined-button.mat-accent{--mdc-outlined-button-label-text-color:#ef6c00}body.dark-mode .mat-datepicker-content .mat-mdc-outlined-button.mat-warn{--mdc-outlined-button-label-text-color:#f44336}body.dark-mode .mat-datepicker-content .mat-mdc-outlined-button[disabled][disabled]{--mdc-outlined-button-label-text-color:rgba(255, 255, 255, 0.5);--mdc-outlined-button-disabled-label-text-color:rgba(255, 255, 255, 0.5);--mdc-outlined-button-outline-color:rgba(255, 255, 255, 0.12);--mdc-outlined-button-disabled-outline-color:rgba(255, 255, 255, 0.12)}body.dark-mode .mat-datepicker-content .mat-mdc-button,body.dark-mode .mat-datepicker-content .mat-mdc-outlined-button{--mat-mdc-button-persistent-ripple-color: #fff;--mat-mdc-button-ripple-color: rgba(255, 255, 255, 0.1)}body.dark-mode .mat-datepicker-content .mat-mdc-button:hover .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-datepicker-content .mat-mdc-outlined-button:hover .mat-mdc-button-persistent-ripple::before{opacity:.08}body.dark-mode .mat-datepicker-content .mat-mdc-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-datepicker-content .mat-mdc-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-datepicker-content .mat-mdc-outlined-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-datepicker-content .mat-mdc-outlined-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before{opacity:.24}body.dark-mode .mat-datepicker-content .mat-mdc-button:active .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-datepicker-content .mat-mdc-outlined-button:active .mat-mdc-button-persistent-ripple::before{opacity:.24}body.dark-mode .mat-datepicker-content .mat-mdc-button.mat-primary,body.dark-mode .mat-datepicker-content .mat-mdc-outlined-button.mat-primary{--mat-mdc-button-persistent-ripple-color: #ef6c00;--mat-mdc-button-ripple-color: rgba(239, 108, 0, 0.1)}body.dark-mode .mat-datepicker-content .mat-mdc-button.mat-accent,body.dark-mode .mat-datepicker-content .mat-mdc-outlined-button.mat-accent{--mat-mdc-button-persistent-ripple-color: #ef6c00;--mat-mdc-button-ripple-color: rgba(239, 108, 0, 0.1)}body.dark-mode .mat-datepicker-content .mat-mdc-button.mat-warn,body.dark-mode .mat-datepicker-content .mat-mdc-outlined-button.mat-warn{--mat-mdc-button-persistent-ripple-color: #f44336;--mat-mdc-button-ripple-color: rgba(244, 67, 54, 0.1)}body.dark-mode .mat-datepicker-content .mat-mdc-raised-button,body.dark-mode .mat-datepicker-content .mat-mdc-unelevated-button{--mat-mdc-button-persistent-ripple-color: #fff;--mat-mdc-button-ripple-color: rgba(255, 255, 255, 0.1)}body.dark-mode .mat-datepicker-content .mat-mdc-raised-button:hover .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-datepicker-content .mat-mdc-unelevated-button:hover .mat-mdc-button-persistent-ripple::before{opacity:.08}body.dark-mode .mat-datepicker-content .mat-mdc-raised-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-datepicker-content .mat-mdc-raised-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-datepicker-content .mat-mdc-unelevated-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-datepicker-content .mat-mdc-unelevated-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before{opacity:.24}body.dark-mode .mat-datepicker-content .mat-mdc-raised-button:active .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-datepicker-content .mat-mdc-unelevated-button:active .mat-mdc-button-persistent-ripple::before{opacity:.24}body.dark-mode .mat-datepicker-content .mat-mdc-raised-button.mat-primary,body.dark-mode .mat-datepicker-content .mat-mdc-unelevated-button.mat-primary{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}body.dark-mode .mat-datepicker-content .mat-mdc-raised-button.mat-accent,body.dark-mode .mat-datepicker-content .mat-mdc-unelevated-button.mat-accent{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}body.dark-mode .mat-datepicker-content .mat-mdc-raised-button.mat-warn,body.dark-mode .mat-datepicker-content .mat-mdc-unelevated-button.mat-warn{--mat-mdc-button-persistent-ripple-color: #fff;--mat-mdc-button-ripple-color: rgba(255, 255, 255, 0.1)}body.dark-mode .mat-datepicker-content .mat-mdc-icon-button{--mat-mdc-button-persistent-ripple-color: #fff;--mat-mdc-button-ripple-color: rgba(255, 255, 255, 0.1)}body.dark-mode .mat-datepicker-content .mat-mdc-icon-button:hover .mat-mdc-button-persistent-ripple::before{opacity:.08}body.dark-mode .mat-datepicker-content .mat-mdc-icon-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-datepicker-content .mat-mdc-icon-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before{opacity:.24}body.dark-mode .mat-datepicker-content .mat-mdc-icon-button:active .mat-mdc-button-persistent-ripple::before{opacity:.24}body.dark-mode .mat-datepicker-content .mat-mdc-icon-button.mat-primary{--mat-mdc-button-persistent-ripple-color: #ef6c00;--mat-mdc-button-ripple-color: rgba(239, 108, 0, 0.1)}body.dark-mode .mat-datepicker-content .mat-mdc-icon-button.mat-accent{--mat-mdc-button-persistent-ripple-color: #ef6c00;--mat-mdc-button-ripple-color: rgba(239, 108, 0, 0.1)}body.dark-mode .mat-datepicker-content .mat-mdc-icon-button.mat-warn{--mat-mdc-button-persistent-ripple-color: #f44336;--mat-mdc-button-ripple-color: rgba(244, 67, 54, 0.1)}body.dark-mode .mat-datepicker-content .mat-mdc-icon-button.mat-primary{--mdc-icon-button-icon-color:#ef6c00}body.dark-mode .mat-datepicker-content .mat-mdc-icon-button.mat-accent{--mdc-icon-button-icon-color:#ef6c00}body.dark-mode .mat-datepicker-content .mat-mdc-icon-button.mat-warn{--mdc-icon-button-icon-color:#f44336}body.dark-mode .mat-datepicker-content .mat-mdc-icon-button[disabled][disabled]{--mdc-icon-button-icon-color:rgba(255, 255, 255, 0.5);--mdc-icon-button-disabled-icon-color:rgba(255, 255, 255, 0.5)}body.dark-mode .mat-datepicker-content .mat-mdc-button.mat-mdc-button-base,body.dark-mode .mat-datepicker-content .mat-mdc-raised-button.mat-mdc-button-base,body.dark-mode .mat-datepicker-content .mat-mdc-unelevated-button.mat-mdc-button-base,body.dark-mode .mat-datepicker-content .mat-mdc-outlined-button.mat-mdc-button-base{height:36px}body.dark-mode .mat-datepicker-content .mat-mdc-icon-button.mat-mdc-button-base{width:48px;height:48px;padding:12px}body.dark-mode .mat-datepicker-content .mat-mdc-icon-button.mat-mdc-button-base .mdc-icon-button__focus-ring{max-height:48px;max-width:48px}body.dark-mode .mat-datepicker-content .mat-mdc-icon-button.mat-mdc-button-base.mdc-icon-button--reduced-size .mdc-icon-button__ripple{width:40px;height:40px;margin-top:4px;margin-bottom:4px;margin-right:4px;margin-left:4px}body.dark-mode .mat-datepicker-content .mat-mdc-icon-button.mat-mdc-button-base.mdc-icon-button--reduced-size .mdc-icon-button__focus-ring{max-height:40px;max-width:40px}body.dark-mode .mat-datepicker-content .mat-mdc-icon-button.mat-mdc-button-base .mdc-icon-button__touch{position:absolute;top:50%;height:48px;left:50%;width:48px;transform:translate(-50%, -50%)}body.dark-mode .mat-option{color:#fff}body.dark-mode .mat-option:hover:not(.mat-option-disabled),body.dark-mode .mat-option:focus:not(.mat-option-disabled){background:rgba(255,255,255,.04)}body.dark-mode .mat-option.mat-selected:not(.mat-option-multiple):not(.mat-option-disabled){background:rgba(255,255,255,.04)}body.dark-mode .mat-option.mat-active{background:rgba(255,255,255,.04);color:#fff}body.dark-mode .mat-option.mat-option-disabled{color:rgba(255,255,255,.5)}body.dark-mode .mat-primary .mat-option.mat-selected:not(.mat-option-disabled){color:#ef6c00}body.dark-mode .mat-accent .mat-option.mat-selected:not(.mat-option-disabled){color:#ef6c00}body.dark-mode .mat-warn .mat-option.mat-selected:not(.mat-option-disabled){color:#f44336}body.dark-mode .mat-optgroup-label{color:rgba(255,255,255,.7)}body.dark-mode .mat-optgroup-disabled .mat-optgroup-label{color:rgba(255,255,255,.5)}body.dark-mode .mat-ripple-element{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-pseudo-checkbox-full{color:rgba(255,255,255,.7)}body.dark-mode .mat-pseudo-checkbox-full.mat-pseudo-checkbox-disabled{color:#686868}body.dark-mode .mat-primary .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,body.dark-mode .mat-primary .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#ef6c00}body.dark-mode .mat-primary .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,body.dark-mode .mat-primary .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#ef6c00}body.dark-mode .mat-primary .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full::after,body.dark-mode .mat-primary .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full::after{color:#303030}body.dark-mode .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,body.dark-mode .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#ef6c00}body.dark-mode .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,body.dark-mode .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#ef6c00}body.dark-mode .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full::after,body.dark-mode .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full::after{color:#303030}body.dark-mode .mat-accent .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,body.dark-mode .mat-accent .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#ef6c00}body.dark-mode .mat-accent .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,body.dark-mode .mat-accent .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#ef6c00}body.dark-mode .mat-accent .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full::after,body.dark-mode .mat-accent .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full::after{color:#303030}body.dark-mode .mat-warn .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,body.dark-mode .mat-warn .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#f44336}body.dark-mode .mat-warn .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,body.dark-mode .mat-warn .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#f44336}body.dark-mode .mat-warn .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full::after,body.dark-mode .mat-warn .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full::after{color:#303030}body.dark-mode .mat-pseudo-checkbox-disabled.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,body.dark-mode .mat-pseudo-checkbox-disabled.mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#686868}body.dark-mode .mat-pseudo-checkbox-disabled.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,body.dark-mode .mat-pseudo-checkbox-disabled.mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#686868}body.dark-mode .mat-app-background,body.dark-mode.mat-app-background{background-color:#303030;color:#fff}body.dark-mode .mat-elevation-z0{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2), 0px 0px 0px 0px rgba(0, 0, 0, 0.14), 0px 0px 0px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z1{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2), 0px 1px 1px 0px rgba(0, 0, 0, 0.14), 0px 1px 3px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z2{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2), 0px 2px 2px 0px rgba(0, 0, 0, 0.14), 0px 1px 5px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z3{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2), 0px 3px 4px 0px rgba(0, 0, 0, 0.14), 0px 1px 8px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z4{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2), 0px 4px 5px 0px rgba(0, 0, 0, 0.14), 0px 1px 10px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z5{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2), 0px 5px 8px 0px rgba(0, 0, 0, 0.14), 0px 1px 14px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z6{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2), 0px 6px 10px 0px rgba(0, 0, 0, 0.14), 0px 1px 18px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z7{box-shadow:0px 4px 5px -2px rgba(0, 0, 0, 0.2), 0px 7px 10px 1px rgba(0, 0, 0, 0.14), 0px 2px 16px 1px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z8{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2), 0px 8px 10px 1px rgba(0, 0, 0, 0.14), 0px 3px 14px 2px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z9{box-shadow:0px 5px 6px -3px rgba(0, 0, 0, 0.2), 0px 9px 12px 1px rgba(0, 0, 0, 0.14), 0px 3px 16px 2px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z10{box-shadow:0px 6px 6px -3px rgba(0, 0, 0, 0.2), 0px 10px 14px 1px rgba(0, 0, 0, 0.14), 0px 4px 18px 3px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z11{box-shadow:0px 6px 7px -4px rgba(0, 0, 0, 0.2), 0px 11px 15px 1px rgba(0, 0, 0, 0.14), 0px 4px 20px 3px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z12{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2), 0px 12px 17px 2px rgba(0, 0, 0, 0.14), 0px 5px 22px 4px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z13{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2), 0px 13px 19px 2px rgba(0, 0, 0, 0.14), 0px 5px 24px 4px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z14{box-shadow:0px 7px 9px -4px rgba(0, 0, 0, 0.2), 0px 14px 21px 2px rgba(0, 0, 0, 0.14), 0px 5px 26px 4px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z15{box-shadow:0px 8px 9px -5px rgba(0, 0, 0, 0.2), 0px 15px 22px 2px rgba(0, 0, 0, 0.14), 0px 6px 28px 5px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z16{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2), 0px 16px 24px 2px rgba(0, 0, 0, 0.14), 0px 6px 30px 5px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z17{box-shadow:0px 8px 11px -5px rgba(0, 0, 0, 0.2), 0px 17px 26px 2px rgba(0, 0, 0, 0.14), 0px 6px 32px 5px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z18{box-shadow:0px 9px 11px -5px rgba(0, 0, 0, 0.2), 0px 18px 28px 2px rgba(0, 0, 0, 0.14), 0px 7px 34px 6px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z19{box-shadow:0px 9px 12px -6px rgba(0, 0, 0, 0.2), 0px 19px 29px 2px rgba(0, 0, 0, 0.14), 0px 7px 36px 6px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z20{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2), 0px 20px 31px 3px rgba(0, 0, 0, 0.14), 0px 8px 38px 7px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z21{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2), 0px 21px 33px 3px rgba(0, 0, 0, 0.14), 0px 8px 40px 7px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z22{box-shadow:0px 10px 14px -6px rgba(0, 0, 0, 0.2), 0px 22px 35px 3px rgba(0, 0, 0, 0.14), 0px 8px 42px 7px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z23{box-shadow:0px 11px 14px -7px rgba(0, 0, 0, 0.2), 0px 23px 36px 3px rgba(0, 0, 0, 0.14), 0px 9px 44px 8px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z24{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2), 0px 24px 38px 3px rgba(0, 0, 0, 0.14), 0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-theme-loaded-marker{display:none}body.dark-mode .mat-card{background:#424242;color:#fff}body.dark-mode .mat-card:not([class*=mat-elevation-z]){box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2), 0px 1px 1px 0px rgba(0, 0, 0, 0.14), 0px 1px 3px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-card.mat-card-flat:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2), 0px 0px 0px 0px rgba(0, 0, 0, 0.14), 0px 0px 0px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-card-subtitle{color:rgba(255,255,255,.7)}body.dark-mode .mat-progress-bar-background{fill:#603f24}body.dark-mode .mat-progress-bar-buffer{background-color:#603f24}body.dark-mode .mat-progress-bar-fill::after{background-color:#ef6c00}body.dark-mode .mat-progress-bar.mat-accent .mat-progress-bar-background{fill:#603f24}body.dark-mode .mat-progress-bar.mat-accent .mat-progress-bar-buffer{background-color:#603f24}body.dark-mode .mat-progress-bar.mat-accent .mat-progress-bar-fill::after{background-color:#ef6c00}body.dark-mode .mat-progress-bar.mat-warn .mat-progress-bar-background{fill:#613532}body.dark-mode .mat-progress-bar.mat-warn .mat-progress-bar-buffer{background-color:#613532}body.dark-mode .mat-progress-bar.mat-warn .mat-progress-bar-fill::after{background-color:#f44336}body.dark-mode .mat-progress-spinner circle,body.dark-mode .mat-spinner circle{stroke:#ef6c00}body.dark-mode .mat-progress-spinner.mat-accent circle,body.dark-mode .mat-spinner.mat-accent circle{stroke:#ef6c00}body.dark-mode .mat-progress-spinner.mat-warn circle,body.dark-mode .mat-spinner.mat-warn circle{stroke:#f44336}body.dark-mode .mat-tooltip{background:rgba(97,97,97,.9)}body.dark-mode .mat-form-field-type-mat-native-select .mat-form-field-infix::after{color:rgba(255,255,255,.7)}body.dark-mode .mat-input-element:disabled,body.dark-mode .mat-form-field-type-mat-native-select.mat-form-field-disabled .mat-form-field-infix::after{color:#616161}body.dark-mode .mat-input-element{caret-color:#ef6c00}body.dark-mode .mat-input-element::placeholder{color:rgba(255,255,255,.5)}body.dark-mode .mat-input-element::-moz-placeholder{color:rgba(255,255,255,.5)}body.dark-mode .mat-input-element::-webkit-input-placeholder{color:rgba(255,255,255,.5)}body.dark-mode .mat-input-element:-ms-input-placeholder{color:rgba(255,255,255,.5)}body.dark-mode .mat-input-element:not(.mat-native-select-inline) option{color:rgba(0,0,0,.87)}body.dark-mode .mat-input-element:not(.mat-native-select-inline) option:disabled{color:rgba(0,0,0,.38)}body.dark-mode .mat-form-field.mat-accent .mat-input-element{caret-color:#ef6c00}body.dark-mode .mat-form-field.mat-warn .mat-input-element,body.dark-mode .mat-form-field-invalid .mat-input-element{caret-color:#f44336}body.dark-mode .mat-form-field-type-mat-native-select.mat-form-field-invalid .mat-form-field-infix::after{color:#f44336}body.dark-mode .mat-form-field-disabled .mat-form-field-prefix,body.dark-mode .mat-form-field-disabled .mat-form-field-suffix{color:#616161}body.dark-mode .mat-form-field-label{color:rgba(255,255,255,.7)}body.dark-mode .mat-hint{color:rgba(255,255,255,.7)}body.dark-mode .mat-form-field.mat-focused .mat-form-field-label{color:#ef6c00}body.dark-mode .mat-form-field.mat-focused .mat-form-field-label.mat-accent{color:#ef6c00}body.dark-mode .mat-form-field.mat-focused .mat-form-field-label.mat-warn{color:#f44336}body.dark-mode .mat-focused .mat-form-field-required-marker{color:#ef6c00}body.dark-mode .mat-form-field-ripple{background-color:#fff}body.dark-mode .mat-form-field.mat-focused .mat-form-field-ripple{background-color:#ef6c00}body.dark-mode .mat-form-field.mat-focused .mat-form-field-ripple.mat-accent{background-color:#ef6c00}body.dark-mode .mat-form-field.mat-focused .mat-form-field-ripple.mat-warn{background-color:#f44336}body.dark-mode .mat-form-field-type-mat-native-select.mat-focused:not(.mat-form-field-invalid) .mat-form-field-infix::after{color:#ef6c00}body.dark-mode .mat-form-field-type-mat-native-select.mat-focused:not(.mat-form-field-invalid).mat-accent .mat-form-field-infix::after{color:#ef6c00}body.dark-mode .mat-form-field-type-mat-native-select.mat-focused:not(.mat-form-field-invalid).mat-warn .mat-form-field-infix::after{color:#f44336}body.dark-mode .mat-form-field.mat-form-field-invalid .mat-form-field-label{color:#f44336}body.dark-mode .mat-form-field.mat-form-field-invalid .mat-form-field-label.mat-accent,body.dark-mode .mat-form-field.mat-form-field-invalid .mat-form-field-label .mat-form-field-required-marker{color:#f44336}body.dark-mode .mat-form-field.mat-form-field-invalid .mat-form-field-ripple,body.dark-mode .mat-form-field.mat-form-field-invalid .mat-form-field-ripple.mat-accent{background-color:#f44336}body.dark-mode .mat-error{color:#f44336}body.dark-mode .mat-form-field-appearance-legacy .mat-form-field-label{color:rgba(255,255,255,.7)}body.dark-mode .mat-form-field-appearance-legacy .mat-hint{color:rgba(255,255,255,.7)}body.dark-mode .mat-form-field-appearance-legacy .mat-form-field-underline{background-color:rgba(255,255,255,.7)}body.dark-mode .mat-form-field-appearance-legacy.mat-form-field-disabled .mat-form-field-underline{background-image:linear-gradient(to right, rgba(255, 255, 255, 0.7) 0%, rgba(255, 255, 255, 0.7) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}body.dark-mode .mat-form-field-appearance-standard .mat-form-field-underline{background-color:rgba(255,255,255,.7)}body.dark-mode .mat-form-field-appearance-standard.mat-form-field-disabled .mat-form-field-underline{background-image:linear-gradient(to right, rgba(255, 255, 255, 0.7) 0%, rgba(255, 255, 255, 0.7) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}body.dark-mode .mat-form-field-appearance-fill .mat-form-field-flex{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-form-field-appearance-fill.mat-form-field-disabled .mat-form-field-flex{background-color:rgba(255,255,255,.05)}body.dark-mode .mat-form-field-appearance-fill .mat-form-field-underline::before{background-color:rgba(255,255,255,.5)}body.dark-mode .mat-form-field-appearance-fill.mat-form-field-disabled .mat-form-field-label{color:#616161}body.dark-mode .mat-form-field-appearance-fill.mat-form-field-disabled .mat-form-field-underline::before{background-color:rgba(0,0,0,0)}body.dark-mode .mat-form-field-appearance-outline .mat-form-field-outline{color:rgba(255,255,255,.3)}body.dark-mode .mat-form-field-appearance-outline .mat-form-field-outline-thick{color:#fff}body.dark-mode .mat-form-field-appearance-outline.mat-focused .mat-form-field-outline-thick{color:#ef6c00}body.dark-mode .mat-form-field-appearance-outline.mat-focused.mat-accent .mat-form-field-outline-thick{color:#ef6c00}body.dark-mode .mat-form-field-appearance-outline.mat-focused.mat-warn .mat-form-field-outline-thick{color:#f44336}body.dark-mode .mat-form-field-appearance-outline.mat-form-field-invalid.mat-form-field-invalid .mat-form-field-outline-thick{color:#f44336}body.dark-mode .mat-form-field-appearance-outline.mat-form-field-disabled .mat-form-field-label{color:#616161}body.dark-mode .mat-form-field-appearance-outline.mat-form-field-disabled .mat-form-field-outline{color:rgba(255,255,255,.15)}body.dark-mode .mat-select-value{color:#fff}body.dark-mode .mat-select-placeholder{color:rgba(255,255,255,.5)}body.dark-mode .mat-select-disabled .mat-select-value{color:#616161}body.dark-mode .mat-select-arrow{color:rgba(255,255,255,.7)}body.dark-mode .mat-select-panel{background:#424242}body.dark-mode .mat-select-panel:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2), 0px 4px 5px 0px rgba(0, 0, 0, 0.14), 0px 1px 10px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-select-panel .mat-option.mat-selected:not(.mat-option-multiple){background:rgba(255,255,255,.12)}body.dark-mode .mat-form-field.mat-focused.mat-primary .mat-select-arrow{color:#ef6c00}body.dark-mode .mat-form-field.mat-focused.mat-accent .mat-select-arrow{color:#ef6c00}body.dark-mode .mat-form-field.mat-focused.mat-warn .mat-select-arrow{color:#f44336}body.dark-mode .mat-form-field .mat-select.mat-select-invalid .mat-select-arrow{color:#f44336}body.dark-mode .mat-form-field .mat-select.mat-select-disabled .mat-select-arrow{color:#616161}body.dark-mode .mat-checkbox-frame{border-color:rgba(255,255,255,.7)}body.dark-mode .mat-checkbox-checkmark{fill:#303030}body.dark-mode .mat-checkbox-checkmark-path{stroke:#303030 !important}body.dark-mode .mat-checkbox-mixedmark{background-color:#303030}body.dark-mode .mat-checkbox-indeterminate.mat-primary .mat-checkbox-background,body.dark-mode .mat-checkbox-checked.mat-primary .mat-checkbox-background{background-color:#ef6c00}body.dark-mode .mat-checkbox-indeterminate.mat-accent .mat-checkbox-background,body.dark-mode .mat-checkbox-checked.mat-accent .mat-checkbox-background{background-color:#ef6c00}body.dark-mode .mat-checkbox-indeterminate.mat-warn .mat-checkbox-background,body.dark-mode .mat-checkbox-checked.mat-warn .mat-checkbox-background{background-color:#f44336}body.dark-mode .mat-checkbox-disabled.mat-checkbox-checked .mat-checkbox-background,body.dark-mode .mat-checkbox-disabled.mat-checkbox-indeterminate .mat-checkbox-background{background-color:#686868}body.dark-mode .mat-checkbox-disabled:not(.mat-checkbox-checked) .mat-checkbox-frame{border-color:#686868}body.dark-mode .mat-checkbox-disabled .mat-checkbox-label{color:rgba(255,255,255,.5)}body.dark-mode .mat-checkbox .mat-ripple-element{background-color:#fff}body.dark-mode .mat-checkbox-checked:not(.mat-checkbox-disabled).mat-primary .mat-ripple-element,body.dark-mode .mat-checkbox:active:not(.mat-checkbox-disabled).mat-primary .mat-ripple-element{background:#ef6c00}body.dark-mode .mat-checkbox-checked:not(.mat-checkbox-disabled).mat-accent .mat-ripple-element,body.dark-mode .mat-checkbox:active:not(.mat-checkbox-disabled).mat-accent .mat-ripple-element{background:#ef6c00}body.dark-mode .mat-checkbox-checked:not(.mat-checkbox-disabled).mat-warn .mat-ripple-element,body.dark-mode .mat-checkbox:active:not(.mat-checkbox-disabled).mat-warn .mat-ripple-element{background:#f44336}body.dark-mode .mat-autocomplete-panel{background:#424242;color:#fff}body.dark-mode .mat-autocomplete-panel:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2), 0px 4px 5px 0px rgba(0, 0, 0, 0.14), 0px 1px 10px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-autocomplete-panel .mat-option.mat-selected:not(.mat-active):not(:hover){background:#424242}body.dark-mode .mat-autocomplete-panel .mat-option.mat-selected:not(.mat-active):not(:hover):not(.mat-option-disabled){color:#fff}body.dark-mode .mat-dialog-container{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2), 0px 24px 38px 3px rgba(0, 0, 0, 0.14), 0px 9px 46px 8px rgba(0, 0, 0, 0.12);background:#424242;color:#fff}body.dark-mode .mat-chip.mat-standard-chip{background-color:#616161;color:#fff}body.dark-mode .mat-chip.mat-standard-chip .mat-chip-remove{color:#fff;opacity:.4}body.dark-mode .mat-chip.mat-standard-chip:not(.mat-chip-disabled):active{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2), 0px 3px 4px 0px rgba(0, 0, 0, 0.14), 0px 1px 8px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-chip.mat-standard-chip:not(.mat-chip-disabled) .mat-chip-remove:hover{opacity:.54}body.dark-mode .mat-chip.mat-standard-chip.mat-chip-disabled{opacity:.4}body.dark-mode .mat-chip.mat-standard-chip::after{background:#fff}body.dark-mode .mat-chip.mat-standard-chip.mat-chip-selected.mat-primary{background-color:#ef6c00;color:#fff}body.dark-mode .mat-chip.mat-standard-chip.mat-chip-selected.mat-primary .mat-chip-remove{color:#fff;opacity:.4}body.dark-mode .mat-chip.mat-standard-chip.mat-chip-selected.mat-primary .mat-ripple-element{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-chip.mat-standard-chip.mat-chip-selected.mat-warn{background-color:#f44336;color:#fff}body.dark-mode .mat-chip.mat-standard-chip.mat-chip-selected.mat-warn .mat-chip-remove{color:#fff;opacity:.4}body.dark-mode .mat-chip.mat-standard-chip.mat-chip-selected.mat-warn .mat-ripple-element{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-chip.mat-standard-chip.mat-chip-selected.mat-accent{background-color:#ef6c00;color:#fff}body.dark-mode .mat-chip.mat-standard-chip.mat-chip-selected.mat-accent .mat-chip-remove{color:#fff;opacity:.4}body.dark-mode .mat-chip.mat-standard-chip.mat-chip-selected.mat-accent .mat-ripple-element{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-slide-toggle.mat-checked .mat-slide-toggle-thumb{background-color:#ef6c00}body.dark-mode .mat-slide-toggle.mat-checked .mat-slide-toggle-bar{background-color:rgba(239,108,0,.54)}body.dark-mode .mat-slide-toggle.mat-checked .mat-ripple-element{background-color:#ef6c00}body.dark-mode .mat-slide-toggle.mat-primary.mat-checked .mat-slide-toggle-thumb{background-color:#ef6c00}body.dark-mode .mat-slide-toggle.mat-primary.mat-checked .mat-slide-toggle-bar{background-color:rgba(239,108,0,.54)}body.dark-mode .mat-slide-toggle.mat-primary.mat-checked .mat-ripple-element{background-color:#ef6c00}body.dark-mode .mat-slide-toggle.mat-warn.mat-checked .mat-slide-toggle-thumb{background-color:#f44336}body.dark-mode .mat-slide-toggle.mat-warn.mat-checked .mat-slide-toggle-bar{background-color:rgba(244,67,54,.54)}body.dark-mode .mat-slide-toggle.mat-warn.mat-checked .mat-ripple-element{background-color:#f44336}body.dark-mode .mat-slide-toggle:not(.mat-checked) .mat-ripple-element{background-color:#fff}body.dark-mode .mat-slide-toggle-thumb{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2), 0px 1px 1px 0px rgba(0, 0, 0, 0.14), 0px 1px 3px 0px rgba(0, 0, 0, 0.12);background-color:#bdbdbd}body.dark-mode .mat-slide-toggle-bar{background-color:rgba(255,255,255,.5)}body.dark-mode .mat-radio-outer-circle{border-color:rgba(255,255,255,.7)}body.dark-mode .mat-radio-button.mat-primary.mat-radio-checked .mat-radio-outer-circle{border-color:#ef6c00}body.dark-mode .mat-radio-button.mat-primary .mat-radio-inner-circle,body.dark-mode .mat-radio-button.mat-primary .mat-radio-ripple .mat-ripple-element:not(.mat-radio-persistent-ripple),body.dark-mode .mat-radio-button.mat-primary.mat-radio-checked .mat-radio-persistent-ripple,body.dark-mode .mat-radio-button.mat-primary:active .mat-radio-persistent-ripple{background-color:#ef6c00}body.dark-mode .mat-radio-button.mat-accent.mat-radio-checked .mat-radio-outer-circle{border-color:#ef6c00}body.dark-mode .mat-radio-button.mat-accent .mat-radio-inner-circle,body.dark-mode .mat-radio-button.mat-accent .mat-radio-ripple .mat-ripple-element:not(.mat-radio-persistent-ripple),body.dark-mode .mat-radio-button.mat-accent.mat-radio-checked .mat-radio-persistent-ripple,body.dark-mode .mat-radio-button.mat-accent:active .mat-radio-persistent-ripple{background-color:#ef6c00}body.dark-mode .mat-radio-button.mat-warn.mat-radio-checked .mat-radio-outer-circle{border-color:#f44336}body.dark-mode .mat-radio-button.mat-warn .mat-radio-inner-circle,body.dark-mode .mat-radio-button.mat-warn .mat-radio-ripple .mat-ripple-element:not(.mat-radio-persistent-ripple),body.dark-mode .mat-radio-button.mat-warn.mat-radio-checked .mat-radio-persistent-ripple,body.dark-mode .mat-radio-button.mat-warn:active .mat-radio-persistent-ripple{background-color:#f44336}body.dark-mode .mat-radio-button.mat-radio-disabled.mat-radio-checked .mat-radio-outer-circle,body.dark-mode .mat-radio-button.mat-radio-disabled .mat-radio-outer-circle{border-color:rgba(255,255,255,.5)}body.dark-mode .mat-radio-button.mat-radio-disabled .mat-radio-ripple .mat-ripple-element,body.dark-mode .mat-radio-button.mat-radio-disabled .mat-radio-inner-circle{background-color:rgba(255,255,255,.5)}body.dark-mode .mat-radio-button.mat-radio-disabled .mat-radio-label-content{color:rgba(255,255,255,.5)}body.dark-mode .mat-radio-button .mat-ripple-element{background-color:#fff}body.dark-mode .mat-slider-track-background{background-color:rgba(255,255,255,.3)}body.dark-mode .mat-slider.mat-primary .mat-slider-track-fill,body.dark-mode .mat-slider.mat-primary .mat-slider-thumb,body.dark-mode .mat-slider.mat-primary .mat-slider-thumb-label{background-color:#ef6c00}body.dark-mode .mat-slider.mat-primary .mat-slider-thumb-label-text{color:#fff}body.dark-mode .mat-slider.mat-primary .mat-slider-focus-ring{background-color:rgba(239,108,0,.2)}body.dark-mode .mat-slider.mat-accent .mat-slider-track-fill,body.dark-mode .mat-slider.mat-accent .mat-slider-thumb,body.dark-mode .mat-slider.mat-accent .mat-slider-thumb-label{background-color:#ef6c00}body.dark-mode .mat-slider.mat-accent .mat-slider-thumb-label-text{color:#fff}body.dark-mode .mat-slider.mat-accent .mat-slider-focus-ring{background-color:rgba(239,108,0,.2)}body.dark-mode .mat-slider.mat-warn .mat-slider-track-fill,body.dark-mode .mat-slider.mat-warn .mat-slider-thumb,body.dark-mode .mat-slider.mat-warn .mat-slider-thumb-label{background-color:#f44336}body.dark-mode .mat-slider.mat-warn .mat-slider-thumb-label-text{color:#fff}body.dark-mode .mat-slider.mat-warn .mat-slider-focus-ring{background-color:rgba(244,67,54,.2)}body.dark-mode .mat-slider:hover .mat-slider-track-background,body.dark-mode .mat-slider.cdk-focused .mat-slider-track-background{background-color:rgba(255,255,255,.3)}body.dark-mode .mat-slider.mat-slider-disabled .mat-slider-track-background,body.dark-mode .mat-slider.mat-slider-disabled .mat-slider-track-fill,body.dark-mode .mat-slider.mat-slider-disabled .mat-slider-thumb{background-color:rgba(255,255,255,.3)}body.dark-mode .mat-slider.mat-slider-disabled:hover .mat-slider-track-background{background-color:rgba(255,255,255,.3)}body.dark-mode .mat-slider.mat-slider-min-value .mat-slider-focus-ring{background-color:rgba(255,255,255,.12)}body.dark-mode .mat-slider.mat-slider-min-value.mat-slider-thumb-label-showing .mat-slider-thumb,body.dark-mode .mat-slider.mat-slider-min-value.mat-slider-thumb-label-showing .mat-slider-thumb-label{background-color:#fff}body.dark-mode .mat-slider.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused .mat-slider-thumb,body.dark-mode .mat-slider.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused .mat-slider-thumb-label{background-color:rgba(255,255,255,.3)}body.dark-mode .mat-slider.mat-slider-min-value:not(.mat-slider-thumb-label-showing) .mat-slider-thumb{border-color:rgba(255,255,255,.3);background-color:rgba(0,0,0,0)}body.dark-mode .mat-slider.mat-slider-min-value:not(.mat-slider-thumb-label-showing):hover .mat-slider-thumb,body.dark-mode .mat-slider.mat-slider-min-value:not(.mat-slider-thumb-label-showing).cdk-focused .mat-slider-thumb{border-color:rgba(255,255,255,.3)}body.dark-mode .mat-slider.mat-slider-min-value:not(.mat-slider-thumb-label-showing):hover.mat-slider-disabled .mat-slider-thumb,body.dark-mode .mat-slider.mat-slider-min-value:not(.mat-slider-thumb-label-showing).cdk-focused.mat-slider-disabled .mat-slider-thumb{border-color:rgba(255,255,255,.3)}body.dark-mode .mat-slider-has-ticks .mat-slider-wrapper::after{border-color:rgba(255,255,255,.7)}body.dark-mode .mat-slider-horizontal .mat-slider-ticks{background-image:repeating-linear-gradient(to right, rgba(255, 255, 255, 0.7), rgba(255, 255, 255, 0.7) 2px, transparent 0, transparent);background-image:-moz-repeating-linear-gradient(0.0001deg, rgba(255, 255, 255, 0.7), rgba(255, 255, 255, 0.7) 2px, transparent 0, transparent)}body.dark-mode .mat-slider-vertical .mat-slider-ticks{background-image:repeating-linear-gradient(to bottom, rgba(255, 255, 255, 0.7), rgba(255, 255, 255, 0.7) 2px, transparent 0, transparent)}body.dark-mode .mat-menu-panel{background:#424242}body.dark-mode .mat-menu-panel:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2), 0px 4px 5px 0px rgba(0, 0, 0, 0.14), 0px 1px 10px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-menu-item{background:rgba(0,0,0,0);color:#fff}body.dark-mode .mat-menu-item[disabled],body.dark-mode .mat-menu-item[disabled] .mat-menu-submenu-icon,body.dark-mode .mat-menu-item[disabled] .mat-icon-no-color{color:rgba(255,255,255,.5)}body.dark-mode .mat-menu-item .mat-icon-no-color,body.dark-mode .mat-menu-submenu-icon{color:#fff}body.dark-mode .mat-menu-item:hover:not([disabled]),body.dark-mode .mat-menu-item.cdk-program-focused:not([disabled]),body.dark-mode .mat-menu-item.cdk-keyboard-focused:not([disabled]),body.dark-mode .mat-menu-item-highlighted:not([disabled]){background:rgba(255,255,255,.04)}body.dark-mode .mat-list-base .mat-list-item{color:#fff}body.dark-mode .mat-list-base .mat-list-option{color:#fff}body.dark-mode .mat-list-base .mat-subheader{color:rgba(255,255,255,.7)}body.dark-mode .mat-list-base .mat-list-item-disabled{background-color:rgba(255,255,255,.12);color:#616161}body.dark-mode .mat-list-option:hover,body.dark-mode .mat-list-option:focus,body.dark-mode .mat-nav-list .mat-list-item:hover,body.dark-mode .mat-nav-list .mat-list-item:focus,body.dark-mode .mat-action-list .mat-list-item:hover,body.dark-mode .mat-action-list .mat-list-item:focus{background:rgba(255,255,255,.04)}body.dark-mode .mat-list-single-selected-option,body.dark-mode .mat-list-single-selected-option:hover,body.dark-mode .mat-list-single-selected-option:focus{background:rgba(255,255,255,.12)}body.dark-mode .mat-paginator{background:#424242}body.dark-mode .mat-paginator,body.dark-mode .mat-paginator-page-size .mat-select-trigger{color:rgba(255,255,255,.7)}body.dark-mode .mat-paginator-decrement,body.dark-mode .mat-paginator-increment{border-top:2px solid #fff;border-right:2px solid #fff}body.dark-mode .mat-paginator-first,body.dark-mode .mat-paginator-last{border-top:2px solid #fff}body.dark-mode .mat-icon-button[disabled] .mat-paginator-decrement,body.dark-mode .mat-icon-button[disabled] .mat-paginator-increment,body.dark-mode .mat-icon-button[disabled] .mat-paginator-first,body.dark-mode .mat-icon-button[disabled] .mat-paginator-last{border-color:rgba(255,255,255,.5)}body.dark-mode .mat-paginator-container{min-height:56px}body.dark-mode .mat-tab-nav-bar,body.dark-mode .mat-tab-header{border-bottom:1px solid rgba(255,255,255,.12)}body.dark-mode .mat-tab-group-inverted-header .mat-tab-nav-bar,body.dark-mode .mat-tab-group-inverted-header .mat-tab-header{border-top:1px solid rgba(255,255,255,.12);border-bottom:none}body.dark-mode .mat-tab-label,body.dark-mode .mat-tab-link{color:#fff}body.dark-mode .mat-tab-label.mat-tab-disabled,body.dark-mode .mat-tab-link.mat-tab-disabled{color:#616161}body.dark-mode .mat-tab-header-pagination-chevron{border-color:#fff}body.dark-mode .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron{border-color:#616161}body.dark-mode .mat-tab-group[class*=mat-background-]>.mat-tab-header,body.dark-mode .mat-tab-nav-bar[class*=mat-background-]{border-bottom:none;border-top:none}body.dark-mode .mat-tab-group.mat-primary .mat-tab-label.cdk-keyboard-focused,body.dark-mode .mat-tab-group.mat-primary .mat-tab-label.cdk-program-focused,body.dark-mode .mat-tab-group.mat-primary .mat-tab-link.cdk-keyboard-focused,body.dark-mode .mat-tab-group.mat-primary .mat-tab-link.cdk-program-focused,body.dark-mode .mat-tab-nav-bar.mat-primary .mat-tab-label.cdk-keyboard-focused,body.dark-mode .mat-tab-nav-bar.mat-primary .mat-tab-label.cdk-program-focused,body.dark-mode .mat-tab-nav-bar.mat-primary .mat-tab-link.cdk-keyboard-focused,body.dark-mode .mat-tab-nav-bar.mat-primary .mat-tab-link.cdk-program-focused{background-color:rgba(251,140,0,.3)}body.dark-mode .mat-tab-group.mat-primary .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-primary .mat-tab-label.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-primary .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-primary .mat-tab-link.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-primary .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-primary .mat-tab-label.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-primary .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-primary .mat-tab-link.cdk-program-focused.mat-tab-disabled{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-tab-group.mat-primary .mat-ink-bar,body.dark-mode .mat-tab-nav-bar.mat-primary .mat-ink-bar{background-color:#ef6c00}body.dark-mode .mat-tab-group.mat-primary.mat-background-primary>.mat-tab-header .mat-ink-bar,body.dark-mode .mat-tab-group.mat-primary.mat-background-primary>.mat-tab-link-container .mat-ink-bar,body.dark-mode .mat-tab-nav-bar.mat-primary.mat-background-primary>.mat-tab-header .mat-ink-bar,body.dark-mode .mat-tab-nav-bar.mat-primary.mat-background-primary>.mat-tab-link-container .mat-ink-bar{background-color:#fff}body.dark-mode .mat-tab-group.mat-accent .mat-tab-label.cdk-keyboard-focused,body.dark-mode .mat-tab-group.mat-accent .mat-tab-label.cdk-program-focused,body.dark-mode .mat-tab-group.mat-accent .mat-tab-link.cdk-keyboard-focused,body.dark-mode .mat-tab-group.mat-accent .mat-tab-link.cdk-program-focused,body.dark-mode .mat-tab-nav-bar.mat-accent .mat-tab-label.cdk-keyboard-focused,body.dark-mode .mat-tab-nav-bar.mat-accent .mat-tab-label.cdk-program-focused,body.dark-mode .mat-tab-nav-bar.mat-accent .mat-tab-link.cdk-keyboard-focused,body.dark-mode .mat-tab-nav-bar.mat-accent .mat-tab-link.cdk-program-focused{background-color:rgba(251,140,0,.3)}body.dark-mode .mat-tab-group.mat-accent .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-accent .mat-tab-label.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-accent .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-accent .mat-tab-link.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-accent .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-accent .mat-tab-label.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-accent .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-accent .mat-tab-link.cdk-program-focused.mat-tab-disabled{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-tab-group.mat-accent .mat-ink-bar,body.dark-mode .mat-tab-nav-bar.mat-accent .mat-ink-bar{background-color:#ef6c00}body.dark-mode .mat-tab-group.mat-accent.mat-background-accent>.mat-tab-header .mat-ink-bar,body.dark-mode .mat-tab-group.mat-accent.mat-background-accent>.mat-tab-link-container .mat-ink-bar,body.dark-mode .mat-tab-nav-bar.mat-accent.mat-background-accent>.mat-tab-header .mat-ink-bar,body.dark-mode .mat-tab-nav-bar.mat-accent.mat-background-accent>.mat-tab-link-container .mat-ink-bar{background-color:#fff}body.dark-mode .mat-tab-group.mat-warn .mat-tab-label.cdk-keyboard-focused,body.dark-mode .mat-tab-group.mat-warn .mat-tab-label.cdk-program-focused,body.dark-mode .mat-tab-group.mat-warn .mat-tab-link.cdk-keyboard-focused,body.dark-mode .mat-tab-group.mat-warn .mat-tab-link.cdk-program-focused,body.dark-mode .mat-tab-nav-bar.mat-warn .mat-tab-label.cdk-keyboard-focused,body.dark-mode .mat-tab-nav-bar.mat-warn .mat-tab-label.cdk-program-focused,body.dark-mode .mat-tab-nav-bar.mat-warn .mat-tab-link.cdk-keyboard-focused,body.dark-mode .mat-tab-nav-bar.mat-warn .mat-tab-link.cdk-program-focused{background-color:rgba(255,205,210,.3)}body.dark-mode .mat-tab-group.mat-warn .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-warn .mat-tab-label.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-warn .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-warn .mat-tab-link.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-warn .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-warn .mat-tab-label.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-warn .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-warn .mat-tab-link.cdk-program-focused.mat-tab-disabled{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-tab-group.mat-warn .mat-ink-bar,body.dark-mode .mat-tab-nav-bar.mat-warn .mat-ink-bar{background-color:#f44336}body.dark-mode .mat-tab-group.mat-warn.mat-background-warn>.mat-tab-header .mat-ink-bar,body.dark-mode .mat-tab-group.mat-warn.mat-background-warn>.mat-tab-link-container .mat-ink-bar,body.dark-mode .mat-tab-nav-bar.mat-warn.mat-background-warn>.mat-tab-header .mat-ink-bar,body.dark-mode .mat-tab-nav-bar.mat-warn.mat-background-warn>.mat-tab-link-container .mat-ink-bar{background-color:#fff}body.dark-mode .mat-tab-group.mat-background-primary .mat-tab-label.cdk-keyboard-focused,body.dark-mode .mat-tab-group.mat-background-primary .mat-tab-label.cdk-program-focused,body.dark-mode .mat-tab-group.mat-background-primary .mat-tab-link.cdk-keyboard-focused,body.dark-mode .mat-tab-group.mat-background-primary .mat-tab-link.cdk-program-focused,body.dark-mode .mat-tab-nav-bar.mat-background-primary .mat-tab-label.cdk-keyboard-focused,body.dark-mode .mat-tab-nav-bar.mat-background-primary .mat-tab-label.cdk-program-focused,body.dark-mode .mat-tab-nav-bar.mat-background-primary .mat-tab-link.cdk-keyboard-focused,body.dark-mode .mat-tab-nav-bar.mat-background-primary .mat-tab-link.cdk-program-focused{background-color:rgba(251,140,0,.3)}body.dark-mode .mat-tab-group.mat-background-primary .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-background-primary .mat-tab-label.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-background-primary .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-background-primary .mat-tab-link.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-primary .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-primary .mat-tab-label.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-primary .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-primary .mat-tab-link.cdk-program-focused.mat-tab-disabled{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-header,body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-link-container,body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-header-pagination,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-header,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-link-container,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-header-pagination{background-color:#ef6c00}body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-header .mat-tab-label,body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-link-container .mat-tab-link,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-header .mat-tab-label,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-link-container .mat-tab-link{color:#fff}body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-header .mat-tab-label.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-link-container .mat-tab-link.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-header .mat-tab-label.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-link-container .mat-tab-link.mat-tab-disabled{color:rgba(255,255,255,.4)}body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-header .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-header-pagination .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-link-container .mat-focus-indicator::before,body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-header .mat-focus-indicator::before,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-header .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-header-pagination .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-link-container .mat-focus-indicator::before,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-header .mat-focus-indicator::before{border-color:#fff}body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-header .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-header .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron{border-color:#fff;opacity:.4}body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-header .mat-ripple-element,body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-link-container .mat-ripple-element,body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-header-pagination .mat-ripple-element,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-header .mat-ripple-element,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-link-container .mat-ripple-element,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-header-pagination .mat-ripple-element{background-color:#fff;opacity:.12}body.dark-mode .mat-tab-group.mat-background-accent .mat-tab-label.cdk-keyboard-focused,body.dark-mode .mat-tab-group.mat-background-accent .mat-tab-label.cdk-program-focused,body.dark-mode .mat-tab-group.mat-background-accent .mat-tab-link.cdk-keyboard-focused,body.dark-mode .mat-tab-group.mat-background-accent .mat-tab-link.cdk-program-focused,body.dark-mode .mat-tab-nav-bar.mat-background-accent .mat-tab-label.cdk-keyboard-focused,body.dark-mode .mat-tab-nav-bar.mat-background-accent .mat-tab-label.cdk-program-focused,body.dark-mode .mat-tab-nav-bar.mat-background-accent .mat-tab-link.cdk-keyboard-focused,body.dark-mode .mat-tab-nav-bar.mat-background-accent .mat-tab-link.cdk-program-focused{background-color:rgba(251,140,0,.3)}body.dark-mode .mat-tab-group.mat-background-accent .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-background-accent .mat-tab-label.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-background-accent .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-background-accent .mat-tab-link.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-accent .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-accent .mat-tab-label.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-accent .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-accent .mat-tab-link.cdk-program-focused.mat-tab-disabled{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-header,body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-link-container,body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-header-pagination,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-header,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-link-container,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-header-pagination{background-color:#ef6c00}body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-header .mat-tab-label,body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-link-container .mat-tab-link,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-header .mat-tab-label,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-link-container .mat-tab-link{color:#fff}body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-header .mat-tab-label.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-link-container .mat-tab-link.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-header .mat-tab-label.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-link-container .mat-tab-link.mat-tab-disabled{color:rgba(255,255,255,.4)}body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-header .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-header-pagination .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-link-container .mat-focus-indicator::before,body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-header .mat-focus-indicator::before,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-header .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-header-pagination .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-link-container .mat-focus-indicator::before,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-header .mat-focus-indicator::before{border-color:#fff}body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-header .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-header .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron{border-color:#fff;opacity:.4}body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-header .mat-ripple-element,body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-link-container .mat-ripple-element,body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-header-pagination .mat-ripple-element,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-header .mat-ripple-element,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-link-container .mat-ripple-element,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-header-pagination .mat-ripple-element{background-color:#fff;opacity:.12}body.dark-mode .mat-tab-group.mat-background-warn .mat-tab-label.cdk-keyboard-focused,body.dark-mode .mat-tab-group.mat-background-warn .mat-tab-label.cdk-program-focused,body.dark-mode .mat-tab-group.mat-background-warn .mat-tab-link.cdk-keyboard-focused,body.dark-mode .mat-tab-group.mat-background-warn .mat-tab-link.cdk-program-focused,body.dark-mode .mat-tab-nav-bar.mat-background-warn .mat-tab-label.cdk-keyboard-focused,body.dark-mode .mat-tab-nav-bar.mat-background-warn .mat-tab-label.cdk-program-focused,body.dark-mode .mat-tab-nav-bar.mat-background-warn .mat-tab-link.cdk-keyboard-focused,body.dark-mode .mat-tab-nav-bar.mat-background-warn .mat-tab-link.cdk-program-focused{background-color:rgba(255,205,210,.3)}body.dark-mode .mat-tab-group.mat-background-warn .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-background-warn .mat-tab-label.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-background-warn .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-background-warn .mat-tab-link.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-warn .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-warn .mat-tab-label.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-warn .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-warn .mat-tab-link.cdk-program-focused.mat-tab-disabled{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-header,body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-link-container,body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-header-pagination,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-header,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-link-container,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-header-pagination{background-color:#f44336}body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-header .mat-tab-label,body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-link-container .mat-tab-link,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-header .mat-tab-label,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-link-container .mat-tab-link{color:#fff}body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-header .mat-tab-label.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-link-container .mat-tab-link.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-header .mat-tab-label.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-link-container .mat-tab-link.mat-tab-disabled{color:rgba(255,255,255,.4)}body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-header .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-header-pagination .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-link-container .mat-focus-indicator::before,body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-header .mat-focus-indicator::before,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-header .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-header-pagination .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-link-container .mat-focus-indicator::before,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-header .mat-focus-indicator::before{border-color:#fff}body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-header .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-header .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron{border-color:#fff;opacity:.4}body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-header .mat-ripple-element,body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-link-container .mat-ripple-element,body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-header-pagination .mat-ripple-element,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-header .mat-ripple-element,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-link-container .mat-ripple-element,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-header-pagination .mat-ripple-element{background-color:#fff;opacity:.12}body.dark-mode .mat-snack-bar-container{color:rgba(0,0,0,.87);background:#fafafa;box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2), 0px 6px 10px 0px rgba(0, 0, 0, 0.14), 0px 1px 18px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-simple-snackbar-action{color:inherit}body.dark-mode .mat-table{background:#424242}body.dark-mode .mat-table thead,body.dark-mode .mat-table tbody,body.dark-mode .mat-table tfoot,body.dark-mode mat-header-row,body.dark-mode mat-row,body.dark-mode mat-footer-row,body.dark-mode [mat-header-row],body.dark-mode [mat-row],body.dark-mode [mat-footer-row],body.dark-mode .mat-table-sticky{background:inherit}body.dark-mode mat-row,body.dark-mode mat-header-row,body.dark-mode mat-footer-row,body.dark-mode th.mat-header-cell,body.dark-mode td.mat-cell,body.dark-mode td.mat-footer-cell{border-bottom-color:rgba(255,255,255,.12)}body.dark-mode .mat-header-cell{color:rgba(255,255,255,.7)}body.dark-mode .mat-cell,body.dark-mode .mat-footer-cell{color:#fff}body.dark-mode .mat-badge-content{color:#fff;background:#ef6c00}.cdk-high-contrast-active body.dark-mode .mat-badge-content{outline:solid 1px;border-radius:0}body.dark-mode .mat-badge-accent .mat-badge-content{background:#ef6c00;color:#fff}body.dark-mode .mat-badge-warn .mat-badge-content{color:#fff;background:#f44336}body.dark-mode .mat-badge-disabled .mat-badge-content{background:#6e6e6e;color:#616161}body.dark-mode .mat-bottom-sheet-container{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2), 0px 16px 24px 2px rgba(0, 0, 0, 0.14), 0px 6px 30px 5px rgba(0, 0, 0, 0.12);background:#424242;color:#fff}body.dark-mode .mat-button-toggle-standalone:not([class*=mat-elevation-z]),body.dark-mode .mat-button-toggle-group:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2), 0px 2px 2px 0px rgba(0, 0, 0, 0.14), 0px 1px 5px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-button-toggle-standalone.mat-button-toggle-appearance-standard:not([class*=mat-elevation-z]),body.dark-mode .mat-button-toggle-group-appearance-standard:not([class*=mat-elevation-z]){box-shadow:none}body.dark-mode .mat-button-toggle{color:rgba(255,255,255,.5)}body.dark-mode .mat-button-toggle .mat-button-toggle-focus-overlay{background-color:rgba(255,255,255,.12)}body.dark-mode .mat-button-toggle-appearance-standard{color:#fff;background:#424242}body.dark-mode .mat-button-toggle-appearance-standard .mat-button-toggle-focus-overlay{background-color:#fff}body.dark-mode .mat-button-toggle-group-appearance-standard .mat-button-toggle+.mat-button-toggle{border-left:solid 1px #595959}body.dark-mode [dir=rtl] .mat-button-toggle-group-appearance-standard .mat-button-toggle+.mat-button-toggle{border-left:none;border-right:solid 1px #595959}body.dark-mode .mat-button-toggle-group-appearance-standard.mat-button-toggle-vertical .mat-button-toggle+.mat-button-toggle{border-left:none;border-right:none;border-top:solid 1px #595959}body.dark-mode .mat-button-toggle-checked{background-color:#212121;color:rgba(255,255,255,.7)}body.dark-mode .mat-button-toggle-checked.mat-button-toggle-appearance-standard{color:#fff}body.dark-mode .mat-button-toggle-disabled{color:rgba(255,255,255,.3);background-color:#000}body.dark-mode .mat-button-toggle-disabled.mat-button-toggle-appearance-standard{background:#424242}body.dark-mode .mat-button-toggle-disabled.mat-button-toggle-checked{background-color:#424242}body.dark-mode .mat-button-toggle-standalone.mat-button-toggle-appearance-standard,body.dark-mode .mat-button-toggle-group-appearance-standard{border:solid 1px #595959}body.dark-mode .mat-button-toggle-appearance-standard .mat-button-toggle-label-content{line-height:48px}body.dark-mode .mat-calendar-arrow{fill:#fff}body.dark-mode .mat-datepicker-toggle,body.dark-mode .mat-datepicker-content .mat-calendar-next-button,body.dark-mode .mat-datepicker-content .mat-calendar-previous-button{color:#fff}body.dark-mode .mat-calendar-table-header-divider::after{background:rgba(255,255,255,.12)}body.dark-mode .mat-calendar-table-header,body.dark-mode .mat-calendar-body-label{color:rgba(255,255,255,.7)}body.dark-mode .mat-calendar-body-cell-content,body.dark-mode .mat-date-range-input-separator{color:#fff;border-color:rgba(0,0,0,0)}body.dark-mode .mat-calendar-body-disabled>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){color:#616161}body.dark-mode .mat-form-field-disabled .mat-date-range-input-separator{color:#616161}body.dark-mode .mat-calendar-body-in-preview{color:rgba(255,255,255,.24)}body.dark-mode .mat-calendar-body-today:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(255,255,255,.5)}body.dark-mode .mat-calendar-body-disabled>.mat-calendar-body-today:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(255,255,255,.3)}body.dark-mode .mat-calendar-body-in-range::before{background:rgba(239,108,0,.2)}body.dark-mode .mat-calendar-body-comparison-identical,body.dark-mode .mat-calendar-body-in-comparison-range::before{background:rgba(249,171,0,.2)}body.dark-mode .mat-calendar-body-comparison-bridge-start::before,body.dark-mode [dir=rtl] .mat-calendar-body-comparison-bridge-end::before{background:linear-gradient(to right, rgba(239, 108, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}body.dark-mode .mat-calendar-body-comparison-bridge-end::before,body.dark-mode [dir=rtl] .mat-calendar-body-comparison-bridge-start::before{background:linear-gradient(to left, rgba(239, 108, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}body.dark-mode .mat-calendar-body-in-range>.mat-calendar-body-comparison-identical,body.dark-mode .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range::after{background:#a8dab5}body.dark-mode .mat-calendar-body-comparison-identical.mat-calendar-body-selected,body.dark-mode .mat-calendar-body-in-comparison-range>.mat-calendar-body-selected{background:#46a35e}body.dark-mode .mat-calendar-body-selected{background-color:#ef6c00;color:#fff}body.dark-mode .mat-calendar-body-disabled>.mat-calendar-body-selected{background-color:rgba(239,108,0,.4)}body.dark-mode .mat-calendar-body-today.mat-calendar-body-selected{box-shadow:inset 0 0 0 1px #fff}body.dark-mode .cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical),body.dark-mode .cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(239,108,0,.3)}@media(hover: hover){body.dark-mode .mat-calendar-body-cell:not(.mat-calendar-body-disabled):hover>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(239,108,0,.3)}}body.dark-mode .mat-datepicker-content{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2), 0px 4px 5px 0px rgba(0, 0, 0, 0.14), 0px 1px 10px 0px rgba(0, 0, 0, 0.12);background-color:#424242;color:#fff}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-in-range::before{background:rgba(239,108,0,.2)}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-comparison-identical,body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-in-comparison-range::before{background:rgba(249,171,0,.2)}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-comparison-bridge-start::before,body.dark-mode .mat-datepicker-content.mat-accent [dir=rtl] .mat-calendar-body-comparison-bridge-end::before{background:linear-gradient(to right, rgba(239, 108, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-comparison-bridge-end::before,body.dark-mode .mat-datepicker-content.mat-accent [dir=rtl] .mat-calendar-body-comparison-bridge-start::before{background:linear-gradient(to left, rgba(239, 108, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-in-range>.mat-calendar-body-comparison-identical,body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range::after{background:#a8dab5}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-comparison-identical.mat-calendar-body-selected,body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-in-comparison-range>.mat-calendar-body-selected{background:#46a35e}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-selected{background-color:#ef6c00;color:#fff}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-disabled>.mat-calendar-body-selected{background-color:rgba(239,108,0,.4)}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-today.mat-calendar-body-selected{box-shadow:inset 0 0 0 1px #fff}body.dark-mode .mat-datepicker-content.mat-accent .cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical),body.dark-mode .mat-datepicker-content.mat-accent .cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(239,108,0,.3)}@media(hover: hover){body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-cell:not(.mat-calendar-body-disabled):hover>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(239,108,0,.3)}}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-in-range::before{background:rgba(244,67,54,.2)}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-comparison-identical,body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-in-comparison-range::before{background:rgba(249,171,0,.2)}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-comparison-bridge-start::before,body.dark-mode .mat-datepicker-content.mat-warn [dir=rtl] .mat-calendar-body-comparison-bridge-end::before{background:linear-gradient(to right, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-comparison-bridge-end::before,body.dark-mode .mat-datepicker-content.mat-warn [dir=rtl] .mat-calendar-body-comparison-bridge-start::before{background:linear-gradient(to left, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-in-range>.mat-calendar-body-comparison-identical,body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range::after{background:#a8dab5}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-comparison-identical.mat-calendar-body-selected,body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-in-comparison-range>.mat-calendar-body-selected{background:#46a35e}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-selected{background-color:#f44336;color:#fff}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-disabled>.mat-calendar-body-selected{background-color:rgba(244,67,54,.4)}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-today.mat-calendar-body-selected{box-shadow:inset 0 0 0 1px #fff}body.dark-mode .mat-datepicker-content.mat-warn .cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical),body.dark-mode .mat-datepicker-content.mat-warn .cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(244,67,54,.3)}@media(hover: hover){body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-cell:not(.mat-calendar-body-disabled):hover>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(244,67,54,.3)}}body.dark-mode .mat-datepicker-content-touch{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2), 0px 24px 38px 3px rgba(0, 0, 0, 0.14), 0px 9px 46px 8px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-datepicker-toggle-active{color:#ef6c00}body.dark-mode .mat-datepicker-toggle-active.mat-accent{color:#ef6c00}body.dark-mode .mat-datepicker-toggle-active.mat-warn{color:#f44336}body.dark-mode .mat-date-range-input-inner[disabled]{color:#616161}body.dark-mode .mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base{width:40px;height:40px;padding:8px}body.dark-mode .mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base .mdc-icon-button__focus-ring{max-height:40px;max-width:40px}body.dark-mode .mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base.mdc-icon-button--reduced-size .mdc-icon-button__ripple{width:40px;height:40px;margin-top:0px;margin-bottom:0px;margin-right:0px;margin-left:0px}body.dark-mode .mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base.mdc-icon-button--reduced-size .mdc-icon-button__focus-ring{max-height:40px;max-width:40px}body.dark-mode .mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base .mdc-icon-button__touch{position:absolute;top:50%;height:40px;left:50%;width:40px;transform:translate(-50%, -50%)}body.dark-mode .mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base .mat-mdc-button-touch-target{display:none}body.dark-mode .mat-divider{border-top-color:rgba(255,255,255,.12)}body.dark-mode .mat-divider-vertical{border-right-color:rgba(255,255,255,.12)}body.dark-mode .mat-expansion-panel{background:#424242;color:#fff}body.dark-mode .mat-expansion-panel:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2), 0px 2px 2px 0px rgba(0, 0, 0, 0.14), 0px 1px 5px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-action-row{border-top-color:rgba(255,255,255,.12)}body.dark-mode .mat-expansion-panel .mat-expansion-panel-header.cdk-keyboard-focused:not([aria-disabled=true]),body.dark-mode .mat-expansion-panel .mat-expansion-panel-header.cdk-program-focused:not([aria-disabled=true]),body.dark-mode .mat-expansion-panel:not(.mat-expanded) .mat-expansion-panel-header:hover:not([aria-disabled=true]){background:rgba(255,255,255,.04)}@media(hover: none){body.dark-mode .mat-expansion-panel:not(.mat-expanded):not([aria-disabled=true]) .mat-expansion-panel-header:hover{background:#424242}}body.dark-mode .mat-expansion-panel-header-title{color:#fff}body.dark-mode .mat-expansion-panel-header-description,body.dark-mode .mat-expansion-indicator::after{color:rgba(255,255,255,.7)}body.dark-mode .mat-expansion-panel-header[aria-disabled=true]{color:rgba(255,255,255,.3)}body.dark-mode .mat-expansion-panel-header[aria-disabled=true] .mat-expansion-panel-header-title,body.dark-mode .mat-expansion-panel-header[aria-disabled=true] .mat-expansion-panel-header-description{color:inherit}body.dark-mode .mat-expansion-panel-header{height:48px}body.dark-mode .mat-expansion-panel-header.mat-expanded{height:64px}body.dark-mode .mat-icon.mat-primary{color:#ef6c00}body.dark-mode .mat-icon.mat-accent{color:#ef6c00}body.dark-mode .mat-icon.mat-warn{color:#f44336}body.dark-mode .mat-drawer-container{background-color:#303030;color:#fff}body.dark-mode .mat-drawer{background-color:#424242;color:#fff}body.dark-mode .mat-drawer.mat-drawer-push{background-color:#424242}body.dark-mode .mat-drawer:not(.mat-drawer-side){box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2), 0px 16px 24px 2px rgba(0, 0, 0, 0.14), 0px 6px 30px 5px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-drawer-side{border-right:solid 1px rgba(255,255,255,.12)}body.dark-mode .mat-drawer-side.mat-drawer-end{border-left:solid 1px rgba(255,255,255,.12);border-right:none}body.dark-mode [dir=rtl] .mat-drawer-side{border-left:solid 1px rgba(255,255,255,.12);border-right:none}body.dark-mode [dir=rtl] .mat-drawer-side.mat-drawer-end{border-left:none;border-right:solid 1px rgba(255,255,255,.12)}body.dark-mode .mat-drawer-backdrop.mat-drawer-shown{background-color:rgba(189,189,189,.6)}body.dark-mode .mat-step-header.cdk-keyboard-focused,body.dark-mode .mat-step-header.cdk-program-focused,body.dark-mode .mat-step-header:hover:not([aria-disabled]),body.dark-mode .mat-step-header:hover[aria-disabled=false]{background-color:rgba(255,255,255,.04)}body.dark-mode .mat-step-header:hover[aria-disabled=true]{cursor:default}@media(hover: none){body.dark-mode .mat-step-header:hover{background:none}}body.dark-mode .mat-step-header .mat-step-label,body.dark-mode .mat-step-header .mat-step-optional{color:rgba(255,255,255,.7)}body.dark-mode .mat-step-header .mat-step-icon{background-color:rgba(255,255,255,.7);color:#fff}body.dark-mode .mat-step-header .mat-step-icon-selected,body.dark-mode .mat-step-header .mat-step-icon-state-done,body.dark-mode .mat-step-header .mat-step-icon-state-edit{background-color:#ef6c00;color:#fff}body.dark-mode .mat-step-header.mat-accent .mat-step-icon{color:#fff}body.dark-mode .mat-step-header.mat-accent .mat-step-icon-selected,body.dark-mode .mat-step-header.mat-accent .mat-step-icon-state-done,body.dark-mode .mat-step-header.mat-accent .mat-step-icon-state-edit{background-color:#ef6c00;color:#fff}body.dark-mode .mat-step-header.mat-warn .mat-step-icon{color:#fff}body.dark-mode .mat-step-header.mat-warn .mat-step-icon-selected,body.dark-mode .mat-step-header.mat-warn .mat-step-icon-state-done,body.dark-mode .mat-step-header.mat-warn .mat-step-icon-state-edit{background-color:#f44336;color:#fff}body.dark-mode .mat-step-header .mat-step-icon-state-error{background-color:rgba(0,0,0,0);color:#f44336}body.dark-mode .mat-step-header .mat-step-label.mat-step-label-active{color:#fff}body.dark-mode .mat-step-header .mat-step-label.mat-step-label-error{color:#f44336}body.dark-mode .mat-stepper-horizontal,body.dark-mode .mat-stepper-vertical{background-color:#424242}body.dark-mode .mat-stepper-vertical-line::before{border-left-color:rgba(255,255,255,.12)}body.dark-mode .mat-horizontal-stepper-header::before,body.dark-mode .mat-horizontal-stepper-header::after,body.dark-mode .mat-stepper-horizontal-line{border-top-color:rgba(255,255,255,.12)}body.dark-mode .mat-horizontal-stepper-header{height:72px}body.dark-mode .mat-stepper-label-position-bottom .mat-horizontal-stepper-header,body.dark-mode .mat-vertical-stepper-header{padding:24px 24px}body.dark-mode .mat-stepper-vertical-line::before{top:-16px;bottom:-16px}body.dark-mode .mat-stepper-label-position-bottom .mat-horizontal-stepper-header::after,body.dark-mode .mat-stepper-label-position-bottom .mat-horizontal-stepper-header::before{top:36px}body.dark-mode .mat-stepper-label-position-bottom .mat-stepper-horizontal-line{top:36px}body.dark-mode .mat-sort-header-arrow{color:#c6c6c6}body.dark-mode .mat-toolbar{background:#ef6c00;color:#fff}body.dark-mode .mat-toolbar.mat-primary{background:#ef6c00;color:#fff}body.dark-mode .mat-toolbar.mat-accent{background:#ef6c00;color:#fff}body.dark-mode .mat-toolbar.mat-warn{background:#f44336;color:#fff}body.dark-mode .mat-toolbar .mat-form-field-underline,body.dark-mode .mat-toolbar .mat-form-field-ripple,body.dark-mode .mat-toolbar .mat-focused .mat-form-field-ripple{background-color:currentColor}body.dark-mode .mat-toolbar .mat-form-field-label,body.dark-mode .mat-toolbar .mat-focused .mat-form-field-label,body.dark-mode .mat-toolbar .mat-select-value,body.dark-mode .mat-toolbar .mat-select-arrow,body.dark-mode .mat-toolbar .mat-form-field.mat-focused .mat-select-arrow{color:inherit}body.dark-mode .mat-toolbar .mat-input-element{caret-color:currentColor}body.dark-mode .mat-toolbar-multiple-rows{min-height:64px}body.dark-mode .mat-toolbar-row,body.dark-mode .mat-toolbar-single-row{height:64px}@media(max-width: 599px){body.dark-mode .mat-toolbar-multiple-rows{min-height:56px}body.dark-mode .mat-toolbar-row,body.dark-mode .mat-toolbar-single-row{height:56px}}body.dark-mode .mat-tree{background:#424242}body.dark-mode .mat-tree-node,body.dark-mode .mat-nested-tree-node{color:#fff}body.dark-mode .mat-tree-node{min-height:48px}
</style>

<style>
  html,
  body {
    margin: 0;
    padding: 0;
    height: 100%;
    font-family: Roboto, sans-serif;
    color: var(--primary-text-color);

    /* Legacy mechanism to avoid issues with subpixel anti-aliasing on macOS.
     *
     * In the past [1], macOS subpixel AA caused excessive bolding for light-on-dark text; this rule
     * avoids that by requesting non-subpixel AA always, rather than the default behavior, which is
     * to use subpixel AA when available. The original issue was "fixed" by removing subpixel AA in
     * macOS 14 (Mojave), but for legacy reasons they preserved the bolding effect as an option.
     * Chrome then in turn updated its font rendering to apply that bolding effect [2], which means
     * that even though the `-webkit-font-smoothing` docs [3] suggest that setting `antialiased`
     * would have no effect for recent versions of macOS, it still is needed to avoid the bolding.
     *
     * [1]: http://www.lighterra.com/articles/macosxtextaabug/
     * [2]: https://bugs.chromium.org/p/chromium/issues/detail?id=858861
     * [3]: https://developer.mozilla.org/en-US/docs/Web/CSS/font-smooth
     *
     */

    -webkit-font-smoothing: antialiased;
  }
  noscript {
    display: block;
    margin: 0 auto;
    max-width: 600px;
    padding: 10px;
  }
</style>

</head><body><noscript>
    <h1>TensorBoard requires JavaScript</h1>
    <p>Please enable JavaScript and reload this page.</p>
  </noscript><tb-webapp></tb-webapp><script src="index.js?_file_hash=751a85f7"></script></body></html>", + "ok": true, + "headers": [ + [ + "content-type", + "text/html; charset=utf-8" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6006/index.js?_file_hash=751a85f7": { + "data": "var CLOSURE_NO_DEPS = true;
window.polymerSkipLoadingFontRoboto = true;
// Copyright 2014 Google Inc. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
//     You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//     See the License for the specific language governing permissions and
// limitations under the License.

!function(){var a={},b={},c={};!function(a,b){function c(a){if("number"==typeof a)return a;var b={};for(var c in a)b[c]=a[c];return b}function d(){this._delay=0,this._endDelay=0,this._fill="none",this._iterationStart=0,this._iterations=1,this._duration=0,this._playbackRate=1,this._direction="normal",this._easing="linear",this._easingFunction=x}function e(){return a.isDeprecated("Invalid timing inputs","2016-03-02","TypeError exceptions will be thrown instead.",!0)}function f(b,c,e){var f=new d;return c&&(f.fill="both",f.duration="auto"),"number"!=typeof b||isNaN(b)?void 0!==b&&Object.getOwnPropertyNames(b).forEach(function(c){if("auto"!=b[c]){if(("number"==typeof f[c]||"duration"==c)&&("number"!=typeof b[c]||isNaN(b[c])))return;if("fill"==c&&-1==v.indexOf(b[c]))return;if("direction"==c&&-1==w.indexOf(b[c]))return;if("playbackRate"==c&&1!==b[c]&&a.isDeprecated("AnimationEffectTiming.playbackRate","2014-11-28","Use Animation.playbackRate instead."))return;f[c]=b[c]}}):f.duration=b,f}function g(a){return"number"==typeof a&&(a=isNaN(a)?{duration:0}:{duration:a}),a}function h(b,c){return b=a.numericTimingToObject(b),f(b,c)}function i(a,b,c,d){return a<0||a>1||c<0||c>1?x:function(e){function f(a,b,c){return 3*a*(1-c)*(1-c)*c+3*b*(1-c)*c*c+c*c*c}if(e<=0){var g=0;return a>0?g=b/a:!b&&c>0&&(g=d/c),g*e}if(e>=1){var h=0;return c<1?h=(d-1)/(c-1):1==c&&a<1&&(h=(b-1)/(a-1)),1+h*(e-1)}for(var i=0,j=1;i<j;){var k=(i+j)/2,l=f(a,c,k);if(Math.abs(e-l)<1e-5)return f(b,d,k);l<e?i=k:j=k}return f(b,d,k)}}function j(a,b){return function(c){if(c>=1)return 1;var d=1/a;return(c+=b*d)-c%d}}function k(a){C||(C=document.createElement("div").style),C.animationTimingFunction="",C.animationTimingFunction=a;var b=C.animationTimingFunction;if(""==b&&e())throw new TypeError(a+" is not a valid value for easing");return b}function l(a){if("linear"==a)return x;var b=E.exec(a);if(b)return i.apply(this,b.slice(1).map(Number));var c=F.exec(a);if(c)return j(Number(c[1]),A);var d=G.exec(a);return d?j(Number(d[1]),{start:y,middle:z,end:A}[d[2]]):B[a]||x}function m(a){return Math.abs(n(a)/a.playbackRate)}function n(a){return 0===a.duration||0===a.iterations?0:a.duration*a.iterations}function o(a,b,c){if(null==b)return H;var d=c.delay+a+c.endDelay;return b<Math.min(c.delay,d)?I:b>=Math.min(c.delay+a,d)?J:K}function p(a,b,c,d,e){switch(d){case I:return"backwards"==b||"both"==b?0:null;case K:return c-e;case J:return"forwards"==b||"both"==b?a:null;case H:return null}}function q(a,b,c,d,e){var f=e;return 0===a?b!==I&&(f+=c):f+=d/a,f}function r(a,b,c,d,e,f){var g=a===1/0?b%1:a%1;return 0!==g||c!==J||0===d||0===e&&0!==f||(g=1),g}function s(a,b,c,d){return a===J&&b===1/0?1/0:1===c?Math.floor(d)-1:Math.floor(d)}function t(a,b,c){var d=a;if("normal"!==a&&"reverse"!==a){var e=b;"alternate-reverse"===a&&(e+=1),d="normal",e!==1/0&&e%2!=0&&(d="reverse")}return"normal"===d?c:1-c}function u(a,b,c){var d=o(a,b,c),e=p(a,c.fill,b,d,c.delay);if(null===e)return null;var f=q(c.duration,d,c.iterations,e,c.iterationStart),g=r(f,c.iterationStart,d,c.iterations,e,c.duration),h=s(d,c.iterations,g,f),i=t(c.direction,h,g);return c._easingFunction(i)}var v="backwards|forwards|both|none".split("|"),w="reverse|alternate|alternate-reverse".split("|"),x=function(a){return a};d.prototype={_setMember:function(b,c){this["_"+b]=c,this._effect&&(this._effect._timingInput[b]=c,this._effect._timing=a.normalizeTimingInput(this._effect._timingInput),this._effect.activeDuration=a.calculateActiveDuration(this._effect._timing),this._effect._animation&&this._effect._animation._rebuildUnderlyingAnimation())},get playbackRate(){return this._playbackRate},set delay(a){this._setMember("delay",a)},get delay(){return this._delay},set endDelay(a){this._setMember("endDelay",a)},get endDelay(){return this._endDelay},set fill(a){this._setMember("fill",a)},get fill(){return this._fill},set iterationStart(a){if((isNaN(a)||a<0)&&e())throw new TypeError("iterationStart must be a non-negative number, received: "+a);this._setMember("iterationStart",a)},get iterationStart(){return this._iterationStart},set duration(a){if("auto"!=a&&(isNaN(a)||a<0)&&e())throw new TypeError("duration must be non-negative or auto, received: "+a);this._setMember("duration",a)},get duration(){return this._duration},set direction(a){this._setMember("direction",a)},get direction(){return this._direction},set easing(a){this._easingFunction=l(k(a)),this._setMember("easing",a)},get easing(){return this._easing},set iterations(a){if((isNaN(a)||a<0)&&e())throw new TypeError("iterations must be non-negative, received: "+a);this._setMember("iterations",a)},get iterations(){return this._iterations}};var y=1,z=.5,A=0,B={ease:i(.25,.1,.25,1),"ease-in":i(.42,0,1,1),"ease-out":i(0,0,.58,1),"ease-in-out":i(.42,0,.58,1),"step-start":j(1,y),"step-middle":j(1,z),"step-end":j(1,A)},C=null,D="\\s*(-?\\d+\\.?\\d*|-?\\.\\d+)\\s*",E=new RegExp("cubic-bezier\\("+D+","+D+","+D+","+D+"\\)"),F=/steps\(\s*(\d+)\s*\)/,G=/steps\(\s*(\d+)\s*,\s*(start|middle|end)\s*\)/,H=0,I=1,J=2,K=3;a.cloneTimingInput=c,a.makeTiming=f,a.numericTimingToObject=g,a.normalizeTimingInput=h,a.calculateActiveDuration=m,a.calculateIterationProgress=u,a.calculatePhase=o,a.normalizeEasing=k,a.parseEasingFunction=l}(a),function(a,b){function c(a,b){return a in k?k[a][b]||b:b}function d(a){return"display"===a||0===a.lastIndexOf("animation",0)||0===a.lastIndexOf("transition",0)}function e(a,b,e){if(!d(a)){var f=h[a];if(f){i.style[a]=b;for(var g in f){var j=f[g],k=i.style[j];e[j]=c(j,k)}}else e[a]=c(a,b)}}function f(a){var b=[];for(var c in a)if(!(c in["easing","offset","composite"])){var d=a[c];Array.isArray(d)||(d=[d]);for(var e,f=d.length,g=0;g<f;g++)e={},e.offset="offset"in a?a.offset:1==f?1:g/(f-1),"easing"in a&&(e.easing=a.easing),"composite"in a&&(e.composite=a.composite),e[c]=d[g],b.push(e)}return b.sort(function(a,b){return a.offset-b.offset}),b}function g(b){function c(){var a=d.length;null==d[a-1].offset&&(d[a-1].offset=1),a>1&&null==d[0].offset&&(d[0].offset=0);for(var b=0,c=d[0].offset,e=1;e<a;e++){var f=d[e].offset;if(null!=f){for(var g=1;g<e-b;g++)d[b+g].offset=c+(f-c)*g/(e-b);b=e,c=f}}}if(null==b)return[];window.Symbol&&Symbol.iterator&&Array.prototype.from&&b[Symbol.iterator]&&(b=Array.from(b)),Array.isArray(b)||(b=f(b));for(var d=b.map(function(b){var c={};for(var d in b){var f=b[d];if("offset"==d){if(null!=f){if(f=Number(f),!isFinite(f))throw new TypeError("Keyframe offsets must be numbers.");if(f<0||f>1)throw new TypeError("Keyframe offsets must be between 0 and 1.")}}else if("composite"==d){if("add"==f||"accumulate"==f)throw{type:DOMException.NOT_SUPPORTED_ERR,name:"NotSupportedError",message:"add compositing is not supported"};if("replace"!=f)throw new TypeError("Invalid composite mode "+f+".")}else f="easing"==d?a.normalizeEasing(f):""+f;e(d,f,c)}return void 0==c.offset&&(c.offset=null),void 0==c.easing&&(c.easing="linear"),c}),g=!0,h=-1/0,i=0;i<d.length;i++){var j=d[i].offset;if(null!=j){if(j<h)throw new TypeError("Keyframes are not loosely sorted by offset. Sort or specify offsets.");h=j}else g=!1}return d=d.filter(function(a){return a.offset>=0&&a.offset<=1}),g||c(),d}var h={background:["backgroundImage","backgroundPosition","backgroundSize","backgroundRepeat","backgroundAttachment","backgroundOrigin","backgroundClip","backgroundColor"],border:["borderTopColor","borderTopStyle","borderTopWidth","borderRightColor","borderRightStyle","borderRightWidth","borderBottomColor","borderBottomStyle","borderBottomWidth","borderLeftColor","borderLeftStyle","borderLeftWidth"],borderBottom:["borderBottomWidth","borderBottomStyle","borderBottomColor"],borderColor:["borderTopColor","borderRightColor","borderBottomColor","borderLeftColor"],borderLeft:["borderLeftWidth","borderLeftStyle","borderLeftColor"],borderRadius:["borderTopLeftRadius","borderTopRightRadius","borderBottomRightRadius","borderBottomLeftRadius"],borderRight:["borderRightWidth","borderRightStyle","borderRightColor"],borderTop:["borderTopWidth","borderTopStyle","borderTopColor"],borderWidth:["borderTopWidth","borderRightWidth","borderBottomWidth","borderLeftWidth"],flex:["flexGrow","flexShrink","flexBasis"],font:["fontFamily","fontSize","fontStyle","fontVariant","fontWeight","lineHeight"],margin:["marginTop","marginRight","marginBottom","marginLeft"],outline:["outlineColor","outlineStyle","outlineWidth"],padding:["paddingTop","paddingRight","paddingBottom","paddingLeft"]},i=document.createElementNS("http://www.w3.org/1999/xhtml","div"),j={thin:"1px",medium:"3px",thick:"5px"},k={borderBottomWidth:j,borderLeftWidth:j,borderRightWidth:j,borderTopWidth:j,fontSize:{"xx-small":"60%","x-small":"75%",small:"89%",medium:"100%",large:"120%","x-large":"150%","xx-large":"200%"},fontWeight:{normal:"400",bold:"700"},outlineWidth:j,textShadow:{none:"0px 0px 0px transparent"},boxShadow:{none:"0px 0px 0px 0px transparent"}};a.convertToArrayForm=f,a.normalizeKeyframes=g}(a),function(a){var b={};a.isDeprecated=function(a,c,d,e){var f=e?"are":"is",g=new Date,h=new Date(c);return h.setMonth(h.getMonth()+3),!(g<h&&(a in b||console.warn("Web Animations: "+a+" "+f+" deprecated and will stop working on "+h.toDateString()+". "+d),b[a]=!0,1))},a.deprecated=function(b,c,d,e){var f=e?"are":"is";if(a.isDeprecated(b,c,d,e))throw new Error(b+" "+f+" no longer supported. "+d)}}(a),function(){if(document.documentElement.animate){var c=document.documentElement.animate([],0),d=!0;if(c&&(d=!1,"play|currentTime|pause|reverse|playbackRate|cancel|finish|startTime|playState".split("|").forEach(function(a){void 0===c[a]&&(d=!0)})),!d)return}!function(a,b,c){function d(a){for(var b={},c=0;c<a.length;c++)for(var d in a[c])if("offset"!=d&&"easing"!=d&&"composite"!=d){var e={offset:a[c].offset,easing:a[c].easing,value:a[c][d]};b[d]=b[d]||[],b[d].push(e)}for(var f in b){var g=b[f];if(0!=g[0].offset||1!=g[g.length-1].offset)throw{type:DOMException.NOT_SUPPORTED_ERR,name:"NotSupportedError",message:"Partial keyframes are not supported"}}return b}function e(c){var d=[];for(var e in c)for(var f=c[e],g=0;g<f.length-1;g++){var h=g,i=g+1,j=f[h].offset,k=f[i].offset,l=j,m=k;0==g&&(l=-1/0,0==k&&(i=h)),g==f.length-2&&(m=1/0,1==j&&(h=i)),d.push({applyFrom:l,applyTo:m,startOffset:f[h].offset,endOffset:f[i].offset,easingFunction:a.parseEasingFunction(f[h].easing),property:e,interpolation:b.propertyInterpolation(e,f[h].value,f[i].value)})}return d.sort(function(a,b){return a.startOffset-b.startOffset}),d}b.convertEffectInput=function(c){var f=a.normalizeKeyframes(c),g=d(f),h=e(g);return function(a,c){if(null!=c)h.filter(function(a){return c>=a.applyFrom&&c<a.applyTo}).forEach(function(d){var e=c-d.startOffset,f=d.endOffset-d.startOffset,g=0==f?0:d.easingFunction(e/f);b.apply(a,d.property,d.interpolation(g))});else for(var d in g)"offset"!=d&&"easing"!=d&&"composite"!=d&&b.clear(a,d)}}}(a,b),function(a,b,c){function d(a){return a.replace(/-(.)/g,function(a,b){return b.toUpperCase()})}function e(a,b,c){h[c]=h[c]||[],h[c].push([a,b])}function f(a,b,c){for(var f=0;f<c.length;f++){e(a,b,d(c[f]))}}function g(c,e,f){var g=c;/-/.test(c)&&!a.isDeprecated("Hyphenated property names","2016-03-22","Use camelCase instead.",!0)&&(g=d(c)),"initial"!=e&&"initial"!=f||("initial"==e&&(e=i[g]),"initial"==f&&(f=i[g]));for(var j=e==f?[]:h[g],k=0;j&&k<j.length;k++){var l=j[k][0](e),m=j[k][0](f);if(void 0!==l&&void 0!==m){var n=j[k][1](l,m);if(n){var o=b.Interpolation.apply(null,n);return function(a){return 0==a?e:1==a?f:o(a)}}}}return b.Interpolation(!1,!0,function(a){return a?f:e})}var h={};b.addPropertiesHandler=f;var i={backgroundColor:"transparent",backgroundPosition:"0% 0%",borderBottomColor:"currentColor",borderBottomLeftRadius:"0px",borderBottomRightRadius:"0px",borderBottomWidth:"3px",borderLeftColor:"currentColor",borderLeftWidth:"3px",borderRightColor:"currentColor",borderRightWidth:"3px",borderSpacing:"2px",borderTopColor:"currentColor",borderTopLeftRadius:"0px",borderTopRightRadius:"0px",borderTopWidth:"3px",bottom:"auto",clip:"rect(0px, 0px, 0px, 0px)",color:"black",fontSize:"100%",fontWeight:"400",height:"auto",left:"auto",letterSpacing:"normal",lineHeight:"120%",marginBottom:"0px",marginLeft:"0px",marginRight:"0px",marginTop:"0px",maxHeight:"none",maxWidth:"none",minHeight:"0px",minWidth:"0px",opacity:"1.0",outlineColor:"invert",outlineOffset:"0px",outlineWidth:"3px",paddingBottom:"0px",paddingLeft:"0px",paddingRight:"0px",paddingTop:"0px",right:"auto",strokeDasharray:"none",strokeDashoffset:"0px",textIndent:"0px",textShadow:"0px 0px 0px transparent",top:"auto",transform:"",verticalAlign:"0px",visibility:"visible",width:"auto",wordSpacing:"normal",zIndex:"auto"};b.propertyInterpolation=g}(a,b),function(a,b,c){function d(b){var c=a.calculateActiveDuration(b),d=function(d){return a.calculateIterationProgress(c,d,b)};return d._totalDuration=b.delay+c+b.endDelay,d}b.KeyframeEffect=function(c,e,f,g){var h,i=d(a.normalizeTimingInput(f)),j=b.convertEffectInput(e),k=function(){j(c,h)};return k._update=function(a){return null!==(h=i(a))},k._clear=function(){j(c,null)},k._hasSameTarget=function(a){return c===a},k._target=c,k._totalDuration=i._totalDuration,k._id=g,k}}(a,b),function(a,b){a.apply=function(b,c,d){b.style[a.propertyName(c)]=d},a.clear=function(b,c){b.style[a.propertyName(c)]=""}}(b),function(a){window.Element.prototype.animate=function(b,c){var d="";return c&&c.id&&(d=c.id),a.timeline._play(a.KeyframeEffect(this,b,c,d))}}(b),function(a,b){function c(a,b,d){if("number"==typeof a&&"number"==typeof b)return a*(1-d)+b*d;if("boolean"==typeof a&&"boolean"==typeof b)return d<.5?a:b;if(a.length==b.length){for(var e=[],f=0;f<a.length;f++)e.push(c(a[f],b[f],d));return e}throw"Mismatched interpolation arguments "+a+":"+b}a.Interpolation=function(a,b,d){return function(e){return d(c(a,b,e))}}}(b),function(a,b,c){a.sequenceNumber=0;var d=function(a,b,c){this.target=a,this.currentTime=b,this.timelineTime=c,this.type="finish",this.bubbles=!1,this.cancelable=!1,this.currentTarget=a,this.defaultPrevented=!1,this.eventPhase=Event.AT_TARGET,this.timeStamp=Date.now()};b.Animation=function(b){this.id="",b&&b._id&&(this.id=b._id),this._sequenceNumber=a.sequenceNumber++,this._currentTime=0,this._startTime=null,this._paused=!1,this._playbackRate=1,this._inTimeline=!0,this._finishedFlag=!0,this.onfinish=null,this._finishHandlers=[],this._effect=b,this._inEffect=this._effect._update(0),this._idle=!0,this._currentTimePending=!1},b.Animation.prototype={_ensureAlive:function(){this.playbackRate<0&&0===this.currentTime?this._inEffect=this._effect._update(-1):this._inEffect=this._effect._update(this.currentTime),this._inTimeline||!this._inEffect&&this._finishedFlag||(this._inTimeline=!0,b.timeline._animations.push(this))},_tickCurrentTime:function(a,b){a!=this._currentTime&&(this._currentTime=a,this._isFinished&&!b&&(this._currentTime=this._playbackRate>0?this._totalDuration:0),this._ensureAlive())},get currentTime(){return this._idle||this._currentTimePending?null:this._currentTime},set currentTime(a){a=+a,isNaN(a)||(b.restart(),this._paused||null==this._startTime||(this._startTime=this._timeline.currentTime-a/this._playbackRate),this._currentTimePending=!1,this._currentTime!=a&&(this._idle&&(this._idle=!1,this._paused=!0),this._tickCurrentTime(a,!0),b.applyDirtiedAnimation(this)))},get startTime(){return this._startTime},set startTime(a){a=+a,isNaN(a)||this._paused||this._idle||(this._startTime=a,this._tickCurrentTime((this._timeline.currentTime-this._startTime)*this.playbackRate),b.applyDirtiedAnimation(this))},get playbackRate(){return this._playbackRate},set playbackRate(a){if(a!=this._playbackRate){var c=this.currentTime;this._playbackRate=a,this._startTime=null,"paused"!=this.playState&&"idle"!=this.playState&&(this._finishedFlag=!1,this._idle=!1,this._ensureAlive(),b.applyDirtiedAnimation(this)),null!=c&&(this.currentTime=c)}},get _isFinished(){return!this._idle&&(this._playbackRate>0&&this._currentTime>=this._totalDuration||this._playbackRate<0&&this._currentTime<=0)},get _totalDuration(){return this._effect._totalDuration},get playState(){return this._idle?"idle":null==this._startTime&&!this._paused&&0!=this.playbackRate||this._currentTimePending?"pending":this._paused?"paused":this._isFinished?"finished":"running"},_rewind:function(){if(this._playbackRate>=0)this._currentTime=0;else{if(!(this._totalDuration<1/0))throw new DOMException("Unable to rewind negative playback rate animation with infinite duration","InvalidStateError");this._currentTime=this._totalDuration}},play:function(){this._paused=!1,(this._isFinished||this._idle)&&(this._rewind(),this._startTime=null),this._finishedFlag=!1,this._idle=!1,this._ensureAlive(),b.applyDirtiedAnimation(this)},pause:function(){this._isFinished||this._paused||this._idle?this._idle&&(this._rewind(),this._idle=!1):this._currentTimePending=!0,this._startTime=null,this._paused=!0},finish:function(){this._idle||(this.currentTime=this._playbackRate>0?this._totalDuration:0,this._startTime=this._totalDuration-this.currentTime,this._currentTimePending=!1,b.applyDirtiedAnimation(this))},cancel:function(){this._inEffect&&(this._inEffect=!1,this._idle=!0,this._paused=!1,this._finishedFlag=!0,this._currentTime=0,this._startTime=null,this._effect._update(null),b.applyDirtiedAnimation(this))},reverse:function(){this.playbackRate*=-1,this.play()},addEventListener:function(a,b){"function"==typeof b&&"finish"==a&&this._finishHandlers.push(b)},removeEventListener:function(a,b){if("finish"==a){var c=this._finishHandlers.indexOf(b);c>=0&&this._finishHandlers.splice(c,1)}},_fireEvents:function(a){if(this._isFinished){if(!this._finishedFlag){var b=new d(this,this._currentTime,a),c=this._finishHandlers.concat(this.onfinish?[this.onfinish]:[]);setTimeout(function(){c.forEach(function(a){a.call(b.target,b)})},0),this._finishedFlag=!0}}else this._finishedFlag=!1},_tick:function(a,b){this._idle||this._paused||(null==this._startTime?b&&(this.startTime=a-this._currentTime/this.playbackRate):this._isFinished||this._tickCurrentTime((a-this._startTime)*this.playbackRate)),b&&(this._currentTimePending=!1,this._fireEvents(a))},get _needsTick(){return this.playState in{pending:1,running:1}||!this._finishedFlag},_targetAnimations:function(){var a=this._effect._target;return a._activeAnimations||(a._activeAnimations=[]),a._activeAnimations},_markTarget:function(){var a=this._targetAnimations();-1===a.indexOf(this)&&a.push(this)},_unmarkTarget:function(){var a=this._targetAnimations(),b=a.indexOf(this);-1!==b&&a.splice(b,1)}}}(a,b),function(a,b,c){function d(a){var b=j;j=[],a<q.currentTime&&(a=q.currentTime),q._animations.sort(e),q._animations=h(a,!0,q._animations)[0],b.forEach(function(b){b[1](a)}),g(),l=void 0}function e(a,b){return a._sequenceNumber-b._sequenceNumber}function f(){this._animations=[],this.currentTime=window.performance&&performance.now?performance.now():0}function g(){o.forEach(function(a){a()}),o.length=0}function h(a,c,d){p=!0,n=!1,b.timeline.currentTime=a,m=!1;var e=[],f=[],g=[],h=[];return d.forEach(function(b){b._tick(a,c),b._inEffect?(f.push(b._effect),b._markTarget()):(e.push(b._effect),b._unmarkTarget()),b._needsTick&&(m=!0);var d=b._inEffect||b._needsTick;b._inTimeline=d,d?g.push(b):h.push(b)}),o.push.apply(o,e),o.push.apply(o,f),m&&requestAnimationFrame(function(){}),p=!1,[g,h]}var i=window.requestAnimationFrame,j=[],k=0;window.requestAnimationFrame=function(a){var b=k++;return 0==j.length&&i(d),j.push([b,a]),b},window.cancelAnimationFrame=function(a){j.forEach(function(b){b[0]==a&&(b[1]=function(){})})},f.prototype={_play:function(c){c._timing=a.normalizeTimingInput(c.timing);var d=new b.Animation(c);return d._idle=!1,d._timeline=this,this._animations.push(d),b.restart(),b.applyDirtiedAnimation(d),d}};var l=void 0,m=!1,n=!1;b.restart=function(){return m||(m=!0,requestAnimationFrame(function(){}),n=!0),n},b.applyDirtiedAnimation=function(a){if(!p){a._markTarget();var c=a._targetAnimations();c.sort(e),h(b.timeline.currentTime,!1,c.slice())[1].forEach(function(a){var b=q._animations.indexOf(a);-1!==b&&q._animations.splice(b,1)}),g()}};var o=[],p=!1,q=new f;b.timeline=q}(a,b),function(a){function b(a,b){var c=a.exec(b);if(c)return c=a.ignoreCase?c[0].toLowerCase():c[0],[c,b.substr(c.length)]}function c(a,b){b=b.replace(/^\s*/,"");var c=a(b);if(c)return[c[0],c[1].replace(/^\s*/,"")]}function d(a,d,e){a=c.bind(null,a);for(var f=[];;){var g=a(e);if(!g)return[f,e];if(f.push(g[0]),e=g[1],!(g=b(d,e))||""==g[1])return[f,e];e=g[1]}}function e(a,b){for(var c=0,d=0;d<b.length&&(!/\s|,/.test(b[d])||0!=c);d++)if("("==b[d])c++;else if(")"==b[d]&&(c--,0==c&&d++,c<=0))break;var e=a(b.substr(0,d));return void 0==e?void 0:[e,b.substr(d)]}function f(a,b){for(var c=a,d=b;c&&d;)c>d?c%=d:d%=c;return c=a*b/(c+d)}function g(a){return function(b){var c=a(b);return c&&(c[0]=void 0),c}}function h(a,b){return function(c){return a(c)||[b,c]}}function i(b,c){for(var d=[],e=0;e<b.length;e++){var f=a.consumeTrimmed(b[e],c);if(!f||""==f[0])return;void 0!==f[0]&&d.push(f[0]),c=f[1]}if(""==c)return d}function j(a,b,c,d,e){for(var g=[],h=[],i=[],j=f(d.length,e.length),k=0;k<j;k++){var l=b(d[k%d.length],e[k%e.length]);if(!l)return;g.push(l[0]),h.push(l[1]),i.push(l[2])}return[g,h,function(b){var d=b.map(function(a,b){return i[b](a)}).join(c);return a?a(d):d}]}function k(a,b,c){for(var d=[],e=[],f=[],g=0,h=0;h<c.length;h++)if("function"==typeof c[h]){var i=c[h](a[g],b[g++]);d.push(i[0]),e.push(i[1]),f.push(i[2])}else!function(a){d.push(!1),e.push(!1),f.push(function(){return c[a]})}(h);return[d,e,function(a){for(var b="",c=0;c<a.length;c++)b+=f[c](a[c]);return b}]}a.consumeToken=b,a.consumeTrimmed=c,a.consumeRepeated=d,a.consumeParenthesised=e,a.ignore=g,a.optional=h,a.consumeList=i,a.mergeNestedRepeated=j.bind(null,null),a.mergeWrappedNestedRepeated=j,a.mergeList=k}(b),function(a){function b(b){function c(b){var c=a.consumeToken(/^inset/i,b);return c?(d.inset=!0,c):(c=a.consumeLengthOrPercent(b))?(d.lengths.push(c[0]),c):(c=a.consumeColor(b),c?(d.color=c[0],c):void 0)}var d={inset:!1,lengths:[],color:null},e=a.consumeRepeated(c,/^/,b);if(e&&e[0].length)return[d,e[1]]}function c(c){var d=a.consumeRepeated(b,/^,/,c);if(d&&""==d[1])return d[0]}function d(b,c){for(;b.lengths.length<Math.max(b.lengths.length,c.lengths.length);)b.lengths.push({px:0});for(;c.lengths.length<Math.max(b.lengths.length,c.lengths.length);)c.lengths.push({px:0});if(b.inset==c.inset&&!!b.color==!!c.color){for(var d,e=[],f=[[],0],g=[[],0],h=0;h<b.lengths.length;h++){var i=a.mergeDimensions(b.lengths[h],c.lengths[h],2==h);f[0].push(i[0]),g[0].push(i[1]),e.push(i[2])}if(b.color&&c.color){var j=a.mergeColors(b.color,c.color);f[1]=j[0],g[1]=j[1],d=j[2]}return[f,g,function(a){for(var c=b.inset?"inset ":" ",f=0;f<e.length;f++)c+=e[f](a[0][f])+" ";return d&&(c+=d(a[1])),c}]}}function e(b,c,d,e){function f(a){return{inset:a,color:[0,0,0,0],lengths:[{px:0},{px:0},{px:0},{px:0}]}}for(var g=[],h=[],i=0;i<d.length||i<e.length;i++){var j=d[i]||f(e[i].inset),k=e[i]||f(d[i].inset);g.push(j),h.push(k)}return a.mergeNestedRepeated(b,c,g,h)}var f=e.bind(null,d,", ");a.addPropertiesHandler(c,f,["box-shadow","text-shadow"])}(b),function(a,b){function c(a){return a.toFixed(3).replace(/0+$/,"").replace(/\.$/,"")}function d(a,b,c){return Math.min(b,Math.max(a,c))}function e(a){if(/^\s*[-+]?(\d*\.)?\d+\s*$/.test(a))return Number(a)}function f(a,b){return[a,b,c]}function g(a,b){if(0!=a)return i(0,1/0)(a,b)}function h(a,b){return[a,b,function(a){return Math.round(d(1,1/0,a))}]}function i(a,b){return function(e,f){return[e,f,function(e){return c(d(a,b,e))}]}}function j(a){var b=a.trim().split(/\s*[\s,]\s*/);if(0!==b.length){for(var c=[],d=0;d<b.length;d++){var f=e(b[d]);if(void 0===f)return;c.push(f)}return c}}function k(a,b){if(a.length==b.length)return[a,b,function(a){return a.map(c).join(" ")}]}function l(a,b){return[a,b,Math.round]}a.clamp=d,a.addPropertiesHandler(j,k,["stroke-dasharray"]),a.addPropertiesHandler(e,i(0,1/0),["border-image-width","line-height"]),a.addPropertiesHandler(e,i(0,1),["opacity","shape-image-threshold"]),a.addPropertiesHandler(e,g,["flex-grow","flex-shrink"]),a.addPropertiesHandler(e,h,["orphans","widows"]),a.addPropertiesHandler(e,l,["z-index"]),a.parseNumber=e,a.parseNumberList=j,a.mergeNumbers=f,a.numberToString=c}(b),function(a,b){function c(a,b){if("visible"==a||"visible"==b)return[0,1,function(c){return c<=0?a:c>=1?b:"visible"}]}a.addPropertiesHandler(String,c,["visibility"])}(b),function(a,b){function c(a){a=a.trim(),f.fillStyle="#000",f.fillStyle=a;var b=f.fillStyle;if(f.fillStyle="#fff",f.fillStyle=a,b==f.fillStyle){f.fillRect(0,0,1,1);var c=f.getImageData(0,0,1,1).data;f.clearRect(0,0,1,1);var d=c[3]/255;return[c[0]*d,c[1]*d,c[2]*d,d]}}function d(b,c){return[b,c,function(b){function c(a){return Math.max(0,Math.min(255,a))}if(b[3])for(var d=0;d<3;d++)b[d]=Math.round(c(b[d]/b[3]));return b[3]=a.numberToString(a.clamp(0,1,b[3])),"rgba("+b.join(",")+")"}]}var e=document.createElementNS("http://www.w3.org/1999/xhtml","canvas");e.width=e.height=1;var f=e.getContext("2d");a.addPropertiesHandler(c,d,["background-color","border-bottom-color","border-left-color","border-right-color","border-top-color","color","fill","flood-color","lighting-color","outline-color","stop-color","stroke","text-decoration-color"]),a.consumeColor=a.consumeParenthesised.bind(null,c),a.mergeColors=d}(b),function(a,b){function c(a){function b(){var b=h.exec(a);g=b?b[0]:void 0}function c(){var a=Number(g);return b(),a}function d(){if("("!==g)return c();b();var a=f();return")"!==g?NaN:(b(),a)}function e(){for(var a=d();"*"===g||"/"===g;){var c=g;b();var e=d();"*"===c?a*=e:a/=e}return a}function f(){for(var a=e();"+"===g||"-"===g;){var c=g;b();var d=e();"+"===c?a+=d:a-=d}return a}var g,h=/([\+\-\w\.]+|[\(\)\*\/])/g;return b(),f()}function d(a,b){if("0"==(b=b.trim().toLowerCase())&&"px".search(a)>=0)return{px:0};if(/^[^(]*$|^calc/.test(b)){b=b.replace(/calc\(/g,"(");var d={};b=b.replace(a,function(a){return d[a]=null,"U"+a});for(var e="U("+a.source+")",f=b.replace(/[-+]?(\d*\.)?\d+([Ee][-+]?\d+)?/g,"N").replace(new RegExp("N"+e,"g"),"D").replace(/\s[+-]\s/g,"O").replace(/\s/g,""),g=[/N\*(D)/g,/(N|D)[*\/]N/g,/(N|D)O\1/g,/\((N|D)\)/g],h=0;h<g.length;)g[h].test(f)?(f=f.replace(g[h],"$1"),h=0):h++;if("D"==f){for(var i in d){var j=c(b.replace(new RegExp("U"+i,"g"),"").replace(new RegExp(e,"g"),"*0"));if(!isFinite(j))return;d[i]=j}return d}}}function e(a,b){return f(a,b,!0)}function f(b,c,d){var e,f=[];for(e in b)f.push(e);for(e in c)f.indexOf(e)<0&&f.push(e);return b=f.map(function(a){return b[a]||0}),c=f.map(function(a){return c[a]||0}),[b,c,function(b){var c=b.map(function(c,e){return 1==b.length&&d&&(c=Math.max(c,0)),a.numberToString(c)+f[e]}).join(" + ");return b.length>1?"calc("+c+")":c}]}var g="px|em|ex|ch|rem|vw|vh|vmin|vmax|cm|mm|in|pt|pc",h=d.bind(null,new RegExp(g,"g")),i=d.bind(null,new RegExp(g+"|%","g")),j=d.bind(null,/deg|rad|grad|turn/g);a.parseLength=h,a.parseLengthOrPercent=i,a.consumeLengthOrPercent=a.consumeParenthesised.bind(null,i),a.parseAngle=j,a.mergeDimensions=f;var k=a.consumeParenthesised.bind(null,h),l=a.consumeRepeated.bind(void 0,k,/^/),m=a.consumeRepeated.bind(void 0,l,/^,/);a.consumeSizePairList=m;var n=function(a){var b=m(a);if(b&&""==b[1])return b[0]},o=a.mergeNestedRepeated.bind(void 0,e," "),p=a.mergeNestedRepeated.bind(void 0,o,",");a.mergeNonNegativeSizePair=o,a.addPropertiesHandler(n,p,["background-size"]),a.addPropertiesHandler(i,e,["border-bottom-width","border-image-width","border-left-width","border-right-width","border-top-width","flex-basis","font-size","height","line-height","max-height","max-width","outline-width","width"]),a.addPropertiesHandler(i,f,["border-bottom-left-radius","border-bottom-right-radius","border-top-left-radius","border-top-right-radius","bottom","left","letter-spacing","margin-bottom","margin-left","margin-right","margin-top","min-height","min-width","outline-offset","padding-bottom","padding-left","padding-right","padding-top","perspective","right","shape-margin","stroke-dashoffset","text-indent","top","vertical-align","word-spacing"])}(b),function(a,b){function c(b){return a.consumeLengthOrPercent(b)||a.consumeToken(/^auto/,b)}function d(b){var d=a.consumeList([a.ignore(a.consumeToken.bind(null,/^rect/)),a.ignore(a.consumeToken.bind(null,/^\(/)),a.consumeRepeated.bind(null,c,/^,/),a.ignore(a.consumeToken.bind(null,/^\)/))],b);if(d&&4==d[0].length)return d[0]}function e(b,c){return"auto"==b||"auto"==c?[!0,!1,function(d){var e=d?b:c;if("auto"==e)return"auto";var f=a.mergeDimensions(e,e);return f[2](f[0])}]:a.mergeDimensions(b,c)}function f(a){return"rect("+a+")"}var g=a.mergeWrappedNestedRepeated.bind(null,f,e,", ");a.parseBox=d,a.mergeBoxes=g,a.addPropertiesHandler(d,g,["clip"])}(b),function(a,b){function c(a){return function(b){var c=0;return a.map(function(a){return a===k?b[c++]:a})}}function d(a){return a}function e(b){if("none"==(b=b.toLowerCase().trim()))return[];for(var c,d=/\s*(\w+)\(([^)]*)\)/g,e=[],f=0;c=d.exec(b);){if(c.index!=f)return;f=c.index+c[0].length;var g=c[1],h=n[g];if(!h)return;var i=c[2].split(","),j=h[0];if(j.length<i.length)return;for(var k=[],o=0;o<j.length;o++){var p,q=i[o],r=j[o];if(void 0===(p=q?{A:function(b){return"0"==b.trim()?m:a.parseAngle(b)},N:a.parseNumber,T:a.parseLengthOrPercent,L:a.parseLength}[r.toUpperCase()](q):{a:m,n:k[0],t:l}[r]))return;k.push(p)}if(e.push({t:g,d:k}),d.lastIndex==b.length)return e}}function f(a){return a.toFixed(6).replace(".000000","")}function g(b,c){if(b.decompositionPair!==c){b.decompositionPair=c;var d=a.makeMatrixDecomposition(b)}if(c.decompositionPair!==b){c.decompositionPair=b;var e=a.makeMatrixDecomposition(c)}return null==d[0]||null==e[0]?[[!1],[!0],function(a){return a?c[0].d:b[0].d}]:(d[0].push(0),e[0].push(1),[d,e,function(b){var c=a.quat(d[0][3],e[0][3],b[5]);return a.composeMatrix(b[0],b[1],b[2],c,b[4]).map(f).join(",")}])}function h(a){return a.replace(/[xy]/,"")}function i(a){return a.replace(/(x|y|z|3d)?$/,"3d")}function j(b,c){var d=a.makeMatrixDecomposition&&!0,e=!1;if(!b.length||!c.length){b.length||(e=!0,b=c,c=[]);for(var f=0;f<b.length;f++){var j=b[f].t,k=b[f].d,l="scale"==j.substr(0,5)?1:0;c.push({t:j,d:k.map(function(a){if("number"==typeof a)return l;var b={};for(var c in a)b[c]=l;return b})})}}var m=function(a,b){return"perspective"==a&&"perspective"==b||("matrix"==a||"matrix3d"==a)&&("matrix"==b||"matrix3d"==b)},o=[],p=[],q=[];if(b.length!=c.length){if(!d)return;var r=g(b,c);o=[r[0]],p=[r[1]],q=[["matrix",[r[2]]]]}else for(var f=0;f<b.length;f++){var j,s=b[f].t,t=c[f].t,u=b[f].d,v=c[f].d,w=n[s],x=n[t];if(m(s,t)){if(!d)return;var r=g([b[f]],[c[f]]);o.push(r[0]),p.push(r[1]),q.push(["matrix",[r[2]]])}else{if(s==t)j=s;else if(w[2]&&x[2]&&h(s)==h(t))j=h(s),u=w[2](u),v=x[2](v);else{if(!w[1]||!x[1]||i(s)!=i(t)){if(!d)return;var r=g(b,c);o=[r[0]],p=[r[1]],q=[["matrix",[r[2]]]];break}j=i(s),u=w[1](u),v=x[1](v)}for(var y=[],z=[],A=[],B=0;B<u.length;B++){var C="number"==typeof u[B]?a.mergeNumbers:a.mergeDimensions,r=C(u[B],v[B]);y[B]=r[0],z[B]=r[1],A.push(r[2])}o.push(y),p.push(z),q.push([j,A])}}if(e){var D=o;o=p,p=D}return[o,p,function(a){return a.map(function(a,b){var c=a.map(function(a,c){return q[b][1][c](a)}).join(",");return"matrix"==q[b][0]&&16==c.split(",").length&&(q[b][0]="matrix3d"),q[b][0]+"("+c+")"}).join(" ")}]}var k=null,l={px:0},m={deg:0},n={matrix:["NNNNNN",[k,k,0,0,k,k,0,0,0,0,1,0,k,k,0,1],d],matrix3d:["NNNNNNNNNNNNNNNN",d],rotate:["A"],rotatex:["A"],rotatey:["A"],rotatez:["A"],rotate3d:["NNNA"],perspective:["L"],scale:["Nn",c([k,k,1]),d],scalex:["N",c([k,1,1]),c([k,1])],scaley:["N",c([1,k,1]),c([1,k])],scalez:["N",c([1,1,k])],scale3d:["NNN",d],skew:["Aa",null,d],skewx:["A",null,c([k,m])],skewy:["A",null,c([m,k])],translate:["Tt",c([k,k,l]),d],translatex:["T",c([k,l,l]),c([k,l])],translatey:["T",c([l,k,l]),c([l,k])],translatez:["L",c([l,l,k])],translate3d:["TTL",d]};a.addPropertiesHandler(e,j,["transform"]),a.transformToSvgMatrix=function(b){var c=a.transformListToMatrix(e(b));return"matrix("+f(c[0])+" "+f(c[1])+" "+f(c[4])+" "+f(c[5])+" "+f(c[12])+" "+f(c[13])+")"}}(b),function(a,b){function c(a,b){b.concat([a]).forEach(function(b){b in document.documentElement.style&&(d[a]=b),e[b]=a})}var d={},e={};c("transform",["webkitTransform","msTransform"]),c("transformOrigin",["webkitTransformOrigin"]),c("perspective",["webkitPerspective"]),c("perspectiveOrigin",["webkitPerspectiveOrigin"]),a.propertyName=function(a){return d[a]||a},a.unprefixedPropertyName=function(a){return e[a]||a}}(b)}(),function(){if(void 0===document.createElement("div").animate([]).oncancel){var a;if(window.performance&&performance.now)var a=function(){return performance.now()};else var a=function(){return Date.now()};var b=function(a,b,c){this.target=a,this.currentTime=b,this.timelineTime=c,this.type="cancel",this.bubbles=!1,this.cancelable=!1,this.currentTarget=a,this.defaultPrevented=!1,this.eventPhase=Event.AT_TARGET,this.timeStamp=Date.now()},c=window.Element.prototype.animate;window.Element.prototype.animate=function(d,e){var f=c.call(this,d,e);f._cancelHandlers=[],f.oncancel=null;var g=f.cancel;f.cancel=function(){g.call(this);var c=new b(this,null,a()),d=this._cancelHandlers.concat(this.oncancel?[this.oncancel]:[]);setTimeout(function(){d.forEach(function(a){a.call(c.target,c)})},0)};var h=f.addEventListener;f.addEventListener=function(a,b){"function"==typeof b&&"cancel"==a?this._cancelHandlers.push(b):h.call(this,a,b)};var i=f.removeEventListener;return f.removeEventListener=function(a,b){if("cancel"==a){var c=this._cancelHandlers.indexOf(b);c>=0&&this._cancelHandlers.splice(c,1)}else i.call(this,a,b)},f}}}(),function(a){var b=document.documentElement,c=null,d=!1;try{var e=getComputedStyle(b).getPropertyValue("opacity"),f="0"==e?"1":"0";c=b.animate({opacity:[f,f]},{duration:1}),c.currentTime=0,d=getComputedStyle(b).getPropertyValue("opacity")==f}catch(a){}finally{c&&c.cancel()}if(!d){var g=window.Element.prototype.animate;window.Element.prototype.animate=function(b,c){return window.Symbol&&Symbol.iterator&&Array.prototype.from&&b[Symbol.iterator]&&(b=Array.from(b)),Array.isArray(b)||null===b||(b=a.convertToArrayForm(b)),g.call(this,b,c)}}}(a),function(a,b,c){function d(a){var c=b.timeline;c.currentTime=a,c._discardAnimations(),0==c._animations.length?f=!1:requestAnimationFrame(d)}var e=window.requestAnimationFrame;window.requestAnimationFrame=function(a){return e(function(c){b.timeline._updateAnimationsPromises(),a(c),b.timeline._updateAnimationsPromises()})},b.AnimationTimeline=function(){this._animations=[],this.currentTime=void 0},b.AnimationTimeline.prototype={getAnimations:function(){return this._discardAnimations(),this._animations.slice()},_updateAnimationsPromises:function(){b.animationsWithPromises=b.animationsWithPromises.filter(function(a){return a._updatePromises()})},_discardAnimations:function(){this._updateAnimationsPromises(),this._animations=this._animations.filter(function(a){return"finished"!=a.playState&&"idle"!=a.playState})},_play:function(a){var c=new b.Animation(a,this);return this._animations.push(c),b.restartWebAnimationsNextTick(),c._updatePromises(),c._animation.play(),c._updatePromises(),c},play:function(a){return a&&a.remove(),this._play(a)}};var f=!1;b.restartWebAnimationsNextTick=function(){f||(f=!0,requestAnimationFrame(d))};var g=new b.AnimationTimeline;b.timeline=g;try{Object.defineProperty(window.document,"timeline",{configurable:!0,get:function(){return g}})}catch(a){}try{window.document.timeline=g}catch(a){}}(0,c),function(a,b,c){b.animationsWithPromises=[],b.Animation=function(b,c){if(this.id="",b&&b._id&&(this.id=b._id),this.effect=b,b&&(b._animation=this),!c)throw new Error("Animation with null timeline is not supported");this._timeline=c,this._sequenceNumber=a.sequenceNumber++,this._holdTime=0,this._paused=!1,this._isGroup=!1,this._animation=null,this._childAnimations=[],this._callback=null,this._oldPlayState="idle",this._rebuildUnderlyingAnimation(),this._animation.cancel(),this._updatePromises()},b.Animation.prototype={_updatePromises:function(){var a=this._oldPlayState,b=this.playState;return this._readyPromise&&b!==a&&("idle"==b?(this._rejectReadyPromise(),this._readyPromise=void 0):"pending"==a?this._resolveReadyPromise():"pending"==b&&(this._readyPromise=void 0)),this._finishedPromise&&b!==a&&("idle"==b?(this._rejectFinishedPromise(),this._finishedPromise=void 0):"finished"==b?this._resolveFinishedPromise():"finished"==a&&(this._finishedPromise=void 0)),this._oldPlayState=this.playState,this._readyPromise||this._finishedPromise},_rebuildUnderlyingAnimation:function(){this._updatePromises();var a,c,d,e,f=!!this._animation;f&&(a=this.playbackRate,c=this._paused,d=this.startTime,e=this.currentTime,this._animation.cancel(),this._animation._wrapper=null,this._animation=null),(!this.effect||this.effect instanceof window.KeyframeEffect)&&(this._animation=b.newUnderlyingAnimationForKeyframeEffect(this.effect),b.bindAnimationForKeyframeEffect(this)),(this.effect instanceof window.SequenceEffect||this.effect instanceof window.GroupEffect)&&(this._animation=b.newUnderlyingAnimationForGroup(this.effect),b.bindAnimationForGroup(this)),this.effect&&this.effect._onsample&&b.bindAnimationForCustomEffect(this),f&&(1!=a&&(this.playbackRate=a),null!==d?this.startTime=d:null!==e?this.currentTime=e:null!==this._holdTime&&(this.currentTime=this._holdTime),c&&this.pause()),this._updatePromises()},_updateChildren:function(){if(this.effect&&"idle"!=this.playState){var a=this.effect._timing.delay;this._childAnimations.forEach(function(c){this._arrangeChildren(c,a),this.effect instanceof window.SequenceEffect&&(a+=b.groupChildDuration(c.effect))}.bind(this))}},_setExternalAnimation:function(a){if(this.effect&&this._isGroup)for(var b=0;b<this.effect.children.length;b++)this.effect.children[b]._animation=a,this._childAnimations[b]._setExternalAnimation(a)},_constructChildAnimations:function(){if(this.effect&&this._isGroup){var a=this.effect._timing.delay;this._removeChildAnimations(),this.effect.children.forEach(function(c){var d=b.timeline._play(c);this._childAnimations.push(d),d.playbackRate=this.playbackRate,this._paused&&d.pause(),c._animation=this.effect._animation,this._arrangeChildren(d,a),this.effect instanceof window.SequenceEffect&&(a+=b.groupChildDuration(c))}.bind(this))}},_arrangeChildren:function(a,b){null===this.startTime?a.currentTime=this.currentTime-b/this.playbackRate:a.startTime!==this.startTime+b/this.playbackRate&&(a.startTime=this.startTime+b/this.playbackRate)},get timeline(){return this._timeline},get playState(){return this._animation?this._animation.playState:"idle"},get finished(){return window.Promise?(this._finishedPromise||(-1==b.animationsWithPromises.indexOf(this)&&b.animationsWithPromises.push(this),this._finishedPromise=new Promise(function(a,b){this._resolveFinishedPromise=function(){a(this)},this._rejectFinishedPromise=function(){b({type:DOMException.ABORT_ERR,name:"AbortError"})}}.bind(this)),"finished"==this.playState&&this._resolveFinishedPromise()),this._finishedPromise):(console.warn("Animation Promises require JavaScript Promise constructor"),null)},get ready(){return window.Promise?(this._readyPromise||(-1==b.animationsWithPromises.indexOf(this)&&b.animationsWithPromises.push(this),this._readyPromise=new Promise(function(a,b){this._resolveReadyPromise=function(){a(this)},this._rejectReadyPromise=function(){b({type:DOMException.ABORT_ERR,name:"AbortError"})}}.bind(this)),"pending"!==this.playState&&this._resolveReadyPromise()),this._readyPromise):(console.warn("Animation Promises require JavaScript Promise constructor"),null)},get onfinish(){return this._animation.onfinish},set onfinish(a){this._animation.onfinish="function"==typeof a?function(b){b.target=this,a.call(this,b)}.bind(this):a},get oncancel(){return this._animation.oncancel},set oncancel(a){this._animation.oncancel="function"==typeof a?function(b){b.target=this,a.call(this,b)}.bind(this):a},get currentTime(){this._updatePromises();var a=this._animation.currentTime;return this._updatePromises(),a},set currentTime(a){this._updatePromises(),this._animation.currentTime=isFinite(a)?a:Math.sign(a)*Number.MAX_VALUE,this._register(),this._forEachChild(function(b,c){b.currentTime=a-c}),this._updatePromises()},get startTime(){return this._animation.startTime},set startTime(a){this._updatePromises(),this._animation.startTime=isFinite(a)?a:Math.sign(a)*Number.MAX_VALUE,this._register(),this._forEachChild(function(b,c){b.startTime=a+c}),this._updatePromises()},get playbackRate(){return this._animation.playbackRate},set playbackRate(a){this._updatePromises();var b=this.currentTime;this._animation.playbackRate=a,this._forEachChild(function(b){b.playbackRate=a}),null!==b&&(this.currentTime=b),this._updatePromises()},play:function(){this._updatePromises(),this._paused=!1,this._animation.play(),-1==this._timeline._animations.indexOf(this)&&this._timeline._animations.push(this),this._register(),b.awaitStartTime(this),this._forEachChild(function(a){var b=a.currentTime;a.play(),a.currentTime=b}),this._updatePromises()},pause:function(){this._updatePromises(),this.currentTime&&(this._holdTime=this.currentTime),this._animation.pause(),this._register(),this._forEachChild(function(a){a.pause()}),this._paused=!0,this._updatePromises()},finish:function(){this._updatePromises(),this._animation.finish(),this._register(),this._updatePromises()},cancel:function(){this._updatePromises(),this._animation.cancel(),this._register(),this._removeChildAnimations(),this._updatePromises()},reverse:function(){this._updatePromises();var a=this.currentTime;this._animation.reverse(),this._forEachChild(function(a){a.reverse()}),null!==a&&(this.currentTime=a),this._updatePromises()},addEventListener:function(a,b){var c=b;"function"==typeof b&&(c=function(a){a.target=this,b.call(this,a)}.bind(this),b._wrapper=c),this._animation.addEventListener(a,c)},removeEventListener:function(a,b){this._animation.removeEventListener(a,b&&b._wrapper||b)},_removeChildAnimations:function(){for(;this._childAnimations.length;)this._childAnimations.pop().cancel()},_forEachChild:function(b){var c=0;if(this.effect.children&&this._childAnimations.length<this.effect.children.length&&this._constructChildAnimations(),this._childAnimations.forEach(function(a){b.call(this,a,c),this.effect instanceof window.SequenceEffect&&(c+=a.effect.activeDuration)}.bind(this)),"pending"!=this.playState){var d=this.effect._timing,e=this.currentTime;null!==e&&(e=a.calculateIterationProgress(a.calculateActiveDuration(d),e,d)),(null==e||isNaN(e))&&this._removeChildAnimations()}}},window.Animation=b.Animation}(a,c),function(a,b,c){function d(b){this._frames=a.normalizeKeyframes(b)}function e(){for(var a=!1;i.length;)i.shift()._updateChildren(),a=!0;return a}var f=function(a){if(a._animation=void 0,a instanceof window.SequenceEffect||a instanceof window.GroupEffect)for(var b=0;b<a.children.length;b++)f(a.children[b])};b.removeMulti=function(a){for(var b=[],c=0;c<a.length;c++){var d=a[c];d._parent?(-1==b.indexOf(d._parent)&&b.push(d._parent),d._parent.children.splice(d._parent.children.indexOf(d),1),d._parent=null,f(d)):d._animation&&d._animation.effect==d&&(d._animation.cancel(),d._animation.effect=new KeyframeEffect(null,[]),d._animation._callback&&(d._animation._callback._animation=null),d._animation._rebuildUnderlyingAnimation(),f(d))}for(c=0;c<b.length;c++)b[c]._rebuild()},b.KeyframeEffect=function(b,c,e,f){return this.target=b,this._parent=null,e=a.numericTimingToObject(e),this._timingInput=a.cloneTimingInput(e),this._timing=a.normalizeTimingInput(e),this.timing=a.makeTiming(e,!1,this),this.timing._effect=this,"function"==typeof c?(a.deprecated("Custom KeyframeEffect","2015-06-22","Use KeyframeEffect.onsample instead."),this._normalizedKeyframes=c):this._normalizedKeyframes=new d(c),this._keyframes=c,this.activeDuration=a.calculateActiveDuration(this._timing),this._id=f,this},b.KeyframeEffect.prototype={getFrames:function(){return"function"==typeof this._normalizedKeyframes?this._normalizedKeyframes:this._normalizedKeyframes._frames},set onsample(a){if("function"==typeof this.getFrames())throw new Error("Setting onsample on custom effect KeyframeEffect is not supported.");this._onsample=a,this._animation&&this._animation._rebuildUnderlyingAnimation()},get parent(){return this._parent},clone:function(){if("function"==typeof this.getFrames())throw new Error("Cloning custom effects is not supported.");var b=new KeyframeEffect(this.target,[],a.cloneTimingInput(this._timingInput),this._id);return b._normalizedKeyframes=this._normalizedKeyframes,b._keyframes=this._keyframes,b},remove:function(){b.removeMulti([this])}};var g=Element.prototype.animate;Element.prototype.animate=function(a,c){var d="";return c&&c.id&&(d=c.id),b.timeline._play(new b.KeyframeEffect(this,a,c,d))};var h=document.createElementNS("http://www.w3.org/1999/xhtml","div");b.newUnderlyingAnimationForKeyframeEffect=function(a){if(a){var b=a.target||h,c=a._keyframes;"function"==typeof c&&(c=[]);var d=a._timingInput;d.id=a._id}else var b=h,c=[],d=0;return g.apply(b,[c,d])},b.bindAnimationForKeyframeEffect=function(a){a.effect&&"function"==typeof a.effect._normalizedKeyframes&&b.bindAnimationForCustomEffect(a)};var i=[];b.awaitStartTime=function(a){null===a.startTime&&a._isGroup&&(0==i.length&&requestAnimationFrame(e),i.push(a))};var j=window.getComputedStyle;Object.defineProperty(window,"getComputedStyle",{configurable:!0,enumerable:!0,value:function(){b.timeline._updateAnimationsPromises();var a=j.apply(this,arguments);return e()&&(a=j.apply(this,arguments)),b.timeline._updateAnimationsPromises(),a}}),window.KeyframeEffect=b.KeyframeEffect,window.Element.prototype.getAnimations=function(){return document.timeline.getAnimations().filter(function(a){return null!==a.effect&&a.effect.target==this}.bind(this))}}(a,c),function(a,b,c){function d(a){a._registered||(a._registered=!0,g.push(a),h||(h=!0,requestAnimationFrame(e)))}function e(a){var b=g;g=[],b.sort(function(a,b){return a._sequenceNumber-b._sequenceNumber}),b=b.filter(function(a){a();var b=a._animation?a._animation.playState:"idle";return"running"!=b&&"pending"!=b&&(a._registered=!1),a._registered}),g.push.apply(g,b),g.length?(h=!0,requestAnimationFrame(e)):h=!1}var f=(document.createElementNS("http://www.w3.org/1999/xhtml","div"),0);b.bindAnimationForCustomEffect=function(b){var c,e=b.effect.target,g="function"==typeof b.effect.getFrames();c=g?b.effect.getFrames():b.effect._onsample;var h=b.effect.timing,i=null;h=a.normalizeTimingInput(h);var j=function(){var d=j._animation?j._animation.currentTime:null;null!==d&&(d=a.calculateIterationProgress(a.calculateActiveDuration(h),d,h),isNaN(d)&&(d=null)),d!==i&&(g?c(d,e,b.effect):c(d,b.effect,b.effect._animation)),i=d};j._animation=b,j._registered=!1,j._sequenceNumber=f++,b._callback=j,d(j)};var g=[],h=!1;b.Animation.prototype._register=function(){this._callback&&d(this._callback)}}(a,c),function(a,b,c){function d(a){return a._timing.delay+a.activeDuration+a._timing.endDelay}function e(b,c,d){this._id=d,this._parent=null,this.children=b||[],this._reparent(this.children),c=a.numericTimingToObject(c),this._timingInput=a.cloneTimingInput(c),this._timing=a.normalizeTimingInput(c,!0),this.timing=a.makeTiming(c,!0,this),this.timing._effect=this,"auto"===this._timing.duration&&(this._timing.duration=this.activeDuration)}window.SequenceEffect=function(){e.apply(this,arguments)},window.GroupEffect=function(){e.apply(this,arguments)},e.prototype={_isAncestor:function(a){for(var b=this;null!==b;){if(b==a)return!0;b=b._parent}return!1},_rebuild:function(){for(var a=this;a;)"auto"===a.timing.duration&&(a._timing.duration=a.activeDuration),a=a._parent;this._animation&&this._animation._rebuildUnderlyingAnimation()},_reparent:function(a){b.removeMulti(a);for(var c=0;c<a.length;c++)a[c]._parent=this},_putChild:function(a,b){for(var c=b?"Cannot append an ancestor or self":"Cannot prepend an ancestor or self",d=0;d<a.length;d++)if(this._isAncestor(a[d]))throw{type:DOMException.HIERARCHY_REQUEST_ERR,name:"HierarchyRequestError",message:c};for(var d=0;d<a.length;d++)b?this.children.push(a[d]):this.children.unshift(a[d]);this._reparent(a),this._rebuild()},append:function(){this._putChild(arguments,!0)},prepend:function(){this._putChild(arguments,!1)},get parent(){return this._parent},get firstChild(){return this.children.length?this.children[0]:null},get lastChild(){return this.children.length?this.children[this.children.length-1]:null},clone:function(){for(var b=a.cloneTimingInput(this._timingInput),c=[],d=0;d<this.children.length;d++)c.push(this.children[d].clone());return this instanceof GroupEffect?new GroupEffect(c,b):new SequenceEffect(c,b)},remove:function(){b.removeMulti([this])}},window.SequenceEffect.prototype=Object.create(e.prototype),Object.defineProperty(window.SequenceEffect.prototype,"activeDuration",{get:function(){var a=0;return this.children.forEach(function(b){a+=d(b)}),Math.max(a,0)}}),window.GroupEffect.prototype=Object.create(e.prototype),Object.defineProperty(window.GroupEffect.prototype,"activeDuration",{get:function(){var a=0;return this.children.forEach(function(b){a=Math.max(a,d(b))}),a}}),b.newUnderlyingAnimationForGroup=function(c){var d,e=null,f=function(b){var c=d._wrapper;if(c&&"pending"!=c.playState&&c.effect)return null==b?void c._removeChildAnimations():0==b&&c.playbackRate<0&&(e||(e=a.normalizeTimingInput(c.effect.timing)),b=a.calculateIterationProgress(a.calculateActiveDuration(e),-1,e),isNaN(b)||null==b)?(c._forEachChild(function(a){a.currentTime=-1}),void c._removeChildAnimations()):void 0},g=new KeyframeEffect(null,[],c._timing,c._id);return g.onsample=f,d=b.timeline._play(g)},b.bindAnimationForGroup=function(a){a._animation._wrapper=a,a._isGroup=!0,b.awaitStartTime(a),a._constructChildAnimations(),a._setExternalAnimation(a)},b.groupChildDuration=d}(a,c)}();(()=>{var vve=Object.create;var BM=Object.defineProperty,xve=Object.defineProperties,bve=Object.getOwnPropertyDescriptor,wve=Object.getOwnPropertyDescriptors,Sve=Object.getOwnPropertyNames,hdt=Object.getOwnPropertySymbols,Mve=Object.getPrototypeOf,pdt=Object.prototype.hasOwnProperty,Eve=Object.prototype.propertyIsEnumerable;var TI=Math.pow,fdt=(e,t,r)=>t in e?BM(e,t,{enumerable:!0,configurable:!0,writable:!0,value:r}):e[t]=r,Kl=(e,t)=>{for(var r in t||(t={}))pdt.call(t,r)&&fdt(e,r,t[r]);if(hdt)for(var r of hdt(t))Eve.call(t,r)&&fdt(e,r,t[r]);return e},Mx=(e,t)=>xve(e,wve(t));var Ex=(e=>typeof require!="undefined"?require:typeof Proxy!="undefined"?new Proxy(e,{get:(t,r)=>(typeof require!="undefined"?require:t)[r]}):e)(function(e){if(typeof require!="undefined")return require.apply(this,arguments);throw new Error('Dynamic require of "'+e+'" is not supported')});var M=(e,t)=>()=>(e&&(t=e(e=0)),t);var H=(e,t)=>()=>(t||e((t={exports:{}}).exports,t),t.exports),Ks=(e,t)=>{for(var r in t)BM(e,r,{get:t[r],enumerable:!0})},ddt=(e,t,r,n)=>{if(t&&typeof t=="object"||typeof t=="function")for(let i of Sve(t))!pdt.call(e,i)&&i!==r&&BM(e,i,{get:()=>t[i],enumerable:!(n=bve(t,i))||n.enumerable});return e};var Ee=(e,t,r)=>(r=e!=null?vve(Mve(e)):{},ddt(t||!e||!e.__esModule?BM(r,"default",{value:e,enumerable:!0}):r,e)),Ut=e=>ddt(BM({},"__esModule",{value:!0}),e);var Ri=(e,t,r)=>new Promise((n,i)=>{var o=l=>{try{s(r.next(l))}catch(c){i(c)}},a=l=>{try{s(r.throw(l))}catch(c){i(c)}},s=l=>l.done?n(l.value):Promise.resolve(l.value).then(o,a);s((r=r.apply(e,t)).next())});var Hdt=H((p_r,PI)=>{var mdt,gdt,_dt,ydt,vdt,xdt,bdt,wdt,Sdt,Mdt,Edt,Tdt,Cdt,CI,hG,Adt,Pdt,Idt,Tx,Ldt,kdt,Rdt,Ndt,Ddt,Odt,zdt,Fdt,Bdt,AI;(function(e){var t=typeof global=="object"?global:typeof self=="object"?self:typeof this=="object"?this:{};typeof define=="function"&&define.amd?define("tslib",["exports"],function(n){e(r(t,r(n)))}):typeof PI=="object"&&typeof PI.exports=="object"?e(r(t,r(PI.exports))):e(r(t));function r(n,i){return n!==t&&(typeof Object.create=="function"?Object.defineProperty(n,"__esModule",{value:!0}):n.__esModule=!0),function(o,a){return n[o]=i?i(o,a):a}}})(function(e){var t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(n,i){n.__proto__=i}||function(n,i){for(var o in i)Object.prototype.hasOwnProperty.call(i,o)&&(n[o]=i[o])};mdt=function(n,i){if(typeof i!="function"&&i!==null)throw new TypeError("Class extends value "+String(i)+" is not a constructor or null");t(n,i);function o(){this.constructor=n}n.prototype=i===null?Object.create(i):(o.prototype=i.prototype,new o)},gdt=Object.assign||function(n){for(var i,o=1,a=arguments.length;o<a;o++){i=arguments[o];for(var s in i)Object.prototype.hasOwnProperty.call(i,s)&&(n[s]=i[s])}return n},_dt=function(n,i){var o={};for(var a in n)Object.prototype.hasOwnProperty.call(n,a)&&i.indexOf(a)<0&&(o[a]=n[a]);if(n!=null&&typeof Object.getOwnPropertySymbols=="function")for(var s=0,a=Object.getOwnPropertySymbols(n);s<a.length;s++)i.indexOf(a[s])<0&&Object.prototype.propertyIsEnumerable.call(n,a[s])&&(o[a[s]]=n[a[s]]);return o},ydt=function(n,i,o,a){var s=arguments.length,l=s<3?i:a===null?a=Object.getOwnPropertyDescriptor(i,o):a,c;if(typeof Reflect=="object"&&typeof Reflect.decorate=="function")l=Reflect.decorate(n,i,o,a);else for(var u=n.length-1;u>=0;u--)(c=n[u])&&(l=(s<3?c(l):s>3?c(i,o,l):c(i,o))||l);return s>3&&l&&Object.defineProperty(i,o,l),l},vdt=function(n,i){return function(o,a){i(o,a,n)}},xdt=function(n,i,o,a,s,l){function c(S){if(S!==void 0&&typeof S!="function")throw new TypeError("Function expected");return S}for(var u=a.kind,h=u==="getter"?"get":u==="setter"?"set":"value",f=!i&&n?a.static?n:n.prototype:null,p=i||(f?Object.getOwnPropertyDescriptor(f,a.name):{}),d,g=!1,_=o.length-1;_>=0;_--){var y={};for(var x in a)y[x]=x==="access"?{}:a[x];for(var x in a.access)y.access[x]=a.access[x];y.addInitializer=function(S){if(g)throw new TypeError("Cannot add initializers after decoration has completed");l.push(c(S||null))};var b=(0,o[_])(u==="accessor"?{get:p.get,set:p.set}:p[h],y);if(u==="accessor"){if(b===void 0)continue;if(b===null||typeof b!="object")throw new TypeError("Object expected");(d=c(b.get))&&(p.get=d),(d=c(b.set))&&(p.set=d),(d=c(b.init))&&s.push(d)}else(d=c(b))&&(u==="field"?s.push(d):p[h]=d)}f&&Object.defineProperty(f,a.name,p),g=!0},bdt=function(n,i,o){for(var a=arguments.length>2,s=0;s<i.length;s++)o=a?i[s].call(n,o):i[s].call(n);return a?o:void 0},wdt=function(n){return typeof n=="symbol"?n:"".concat(n)},Sdt=function(n,i,o){return typeof i=="symbol"&&(i=i.description?"[".concat(i.description,"]"):""),Object.defineProperty(n,"name",{configurable:!0,value:o?"".concat(o," ",i):i})},Mdt=function(n,i){if(typeof Reflect=="object"&&typeof Reflect.metadata=="function")return Reflect.metadata(n,i)},Edt=function(n,i,o,a){function s(l){return l instanceof o?l:new o(function(c){c(l)})}return new(o||(o=Promise))(function(l,c){function u(p){try{f(a.next(p))}catch(d){c(d)}}function h(p){try{f(a.throw(p))}catch(d){c(d)}}function f(p){p.done?l(p.value):s(p.value).then(u,h)}f((a=a.apply(n,i||[])).next())})},Tdt=function(n,i){var o={label:0,sent:function(){if(l[0]&1)throw l[1];return l[1]},trys:[],ops:[]},a,s,l,c;return c={next:u(0),throw:u(1),return:u(2)},typeof Symbol=="function"&&(c[Symbol.iterator]=function(){return this}),c;function u(f){return function(p){return h([f,p])}}function h(f){if(a)throw new TypeError("Generator is already executing.");for(;c&&(c=0,f[0]&&(o=0)),o;)try{if(a=1,s&&(l=f[0]&2?s.return:f[0]?s.throw||((l=s.return)&&l.call(s),0):s.next)&&!(l=l.call(s,f[1])).done)return l;switch(s=0,l&&(f=[f[0]&2,l.value]),f[0]){case 0:case 1:l=f;break;case 4:return o.label++,{value:f[1],done:!1};case 5:o.label++,s=f[1],f=[0];continue;case 7:f=o.ops.pop(),o.trys.pop();continue;default:if(l=o.trys,!(l=l.length>0&&l[l.length-1])&&(f[0]===6||f[0]===2)){o=0;continue}if(f[0]===3&&(!l||f[1]>l[0]&&f[1]<l[3])){o.label=f[1];break}if(f[0]===6&&o.label<l[1]){o.label=l[1],l=f;break}if(l&&o.label<l[2]){o.label=l[2],o.ops.push(f);break}l[2]&&o.ops.pop(),o.trys.pop();continue}f=i.call(n,o)}catch(p){f=[6,p],s=0}finally{a=l=0}if(f[0]&5)throw f[1];return{value:f[0]?f[1]:void 0,done:!0}}},Cdt=function(n,i){for(var o in n)o!=="default"&&!Object.prototype.hasOwnProperty.call(i,o)&&AI(i,n,o)},AI=Object.create?function(n,i,o,a){a===void 0&&(a=o);var s=Object.getOwnPropertyDescriptor(i,o);(!s||("get"in s?!i.__esModule:s.writable||s.configurable))&&(s={enumerable:!0,get:function(){return i[o]}}),Object.defineProperty(n,a,s)}:function(n,i,o,a){a===void 0&&(a=o),n[a]=i[o]},CI=function(n){var i=typeof Symbol=="function"&&Symbol.iterator,o=i&&n[i],a=0;if(o)return o.call(n);if(n&&typeof n.length=="number")return{next:function(){return n&&a>=n.length&&(n=void 0),{value:n&&n[a++],done:!n}}};throw new TypeError(i?"Object is not iterable.":"Symbol.iterator is not defined.")},hG=function(n,i){var o=typeof Symbol=="function"&&n[Symbol.iterator];if(!o)return n;var a=o.call(n),s,l=[],c;try{for(;(i===void 0||i-- >0)&&!(s=a.next()).done;)l.push(s.value)}catch(u){c={error:u}}finally{try{s&&!s.done&&(o=a.return)&&o.call(a)}finally{if(c)throw c.error}}return l},Adt=function(){for(var n=[],i=0;i<arguments.length;i++)n=n.concat(hG(arguments[i]));return n},Pdt=function(){for(var n=0,i=0,o=arguments.length;i<o;i++)n+=arguments[i].length;for(var a=Array(n),s=0,i=0;i<o;i++)for(var l=arguments[i],c=0,u=l.length;c<u;c++,s++)a[s]=l[c];return a},Idt=function(n,i,o){if(o||arguments.length===2)for(var a=0,s=i.length,l;a<s;a++)(l||!(a in i))&&(l||(l=Array.prototype.slice.call(i,0,a)),l[a]=i[a]);return n.concat(l||Array.prototype.slice.call(i))},Tx=function(n){return this instanceof Tx?(this.v=n,this):new Tx(n)},Ldt=function(n,i,o){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var a=o.apply(n,i||[]),s,l=[];return s={},c("next"),c("throw"),c("return"),s[Symbol.asyncIterator]=function(){return this},s;function c(g){a[g]&&(s[g]=function(_){return new Promise(function(y,x){l.push([g,_,y,x])>1||u(g,_)})})}function u(g,_){try{h(a[g](_))}catch(y){d(l[0][3],y)}}function h(g){g.value instanceof Tx?Promise.resolve(g.value.v).then(f,p):d(l[0][2],g)}function f(g){u("next",g)}function p(g){u("throw",g)}function d(g,_){g(_),l.shift(),l.length&&u(l[0][0],l[0][1])}},kdt=function(n){var i,o;return i={},a("next"),a("throw",function(s){throw s}),a("return"),i[Symbol.iterator]=function(){return this},i;function a(s,l){i[s]=n[s]?function(c){return(o=!o)?{value:Tx(n[s](c)),done:!1}:l?l(c):c}:l}},Rdt=function(n){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var i=n[Symbol.asyncIterator],o;return i?i.call(n):(n=typeof CI=="function"?CI(n):n[Symbol.iterator](),o={},a("next"),a("throw"),a("return"),o[Symbol.asyncIterator]=function(){return this},o);function a(l){o[l]=n[l]&&function(c){return new Promise(function(u,h){c=n[l](c),s(u,h,c.done,c.value)})}}function s(l,c,u,h){Promise.resolve(h).then(function(f){l({value:f,done:u})},c)}},Ndt=function(n,i){return Object.defineProperty?Object.defineProperty(n,"raw",{value:i}):n.raw=i,n};var r=Object.create?function(n,i){Object.defineProperty(n,"default",{enumerable:!0,value:i})}:function(n,i){n.default=i};Ddt=function(n){if(n&&n.__esModule)return n;var i={};if(n!=null)for(var o in n)o!=="default"&&Object.prototype.hasOwnProperty.call(n,o)&&AI(i,n,o);return r(i,n),i},Odt=function(n){return n&&n.__esModule?n:{default:n}},zdt=function(n,i,o,a){if(o==="a"&&!a)throw new TypeError("Private accessor was defined without a getter");if(typeof i=="function"?n!==i||!a:!i.has(n))throw new TypeError("Cannot read private member from an object whose class did not declare it");return o==="m"?a:o==="a"?a.call(n):a?a.value:i.get(n)},Fdt=function(n,i,o,a,s){if(a==="m")throw new TypeError("Private method is not writable");if(a==="a"&&!s)throw new TypeError("Private accessor was defined without a setter");if(typeof i=="function"?n!==i||!s:!i.has(n))throw new TypeError("Cannot write private member to an object whose class did not declare it");return a==="a"?s.call(n,o):s?s.value=o:i.set(n,o),o},Bdt=function(n,i){if(i===null||typeof i!="object"&&typeof i!="function")throw new TypeError("Cannot use 'in' operator on non-object");return typeof n=="function"?i===n:n.has(i)},e("__extends",mdt),e("__assign",gdt),e("__rest",_dt),e("__decorate",ydt),e("__param",vdt),e("__esDecorate",xdt),e("__runInitializers",bdt),e("__propKey",wdt),e("__setFunctionName",Sdt),e("__metadata",Mdt),e("__awaiter",Edt),e("__generator",Tdt),e("__exportStar",Cdt),e("__createBinding",AI),e("__values",CI),e("__read",hG),e("__spread",Adt),e("__spreadArrays",Pdt),e("__spreadArray",Idt),e("__await",Tx),e("__asyncGenerator",Ldt),e("__asyncDelegator",kdt),e("__asyncValues",Rdt),e("__makeTemplateObject",Ndt),e("__importStar",Ddt),e("__importDefault",Odt),e("__classPrivateFieldGet",zdt),e("__classPrivateFieldSet",Fdt),e("__classPrivateFieldIn",Bdt)})});var Oe=H((Rx,$M)=>{(function(){var e,t="4.17.21",r=200,n="Unsupported core-js use. Try https://npms.io/search?q=ponyfill.",i="Expected a function",o="Invalid `variable` option passed into `_.template`",a="__lodash_hash_undefined__",s=500,l="__lodash_placeholder__",c=1,u=2,h=4,f=1,p=2,d=1,g=2,_=4,y=8,x=16,b=32,S=64,C=128,P=256,k=512,O=30,D="...",B=800,I=16,L=1,R=2,F=3,z=1/0,U=9007199254740991,W=17976931348623157e292,Z=0/0,rt=4294967295,ot=rt-1,st=rt>>>1,St=[["ary",C],["bind",d],["bindKey",g],["curry",y],["curryRight",x],["flip",k],["partial",b],["partialRight",S],["rearg",P]],bt="[object Arguments]",Mt="[object Array]",lt="[object AsyncFunction]",Kt="[object Boolean]",_t="[object Date]",ct="[object DOMException]",X="[object Error]",et="[object Function]",dt="[object GeneratorFunction]",q="[object Map]",pt="[object Number]",ht="[object Null]",wt="[object Object]",kt="[object Promise]",ie="[object Proxy]",ee="[object RegExp]",Le="[object Set]",ar="[object String]",fr="[object Symbol]",tt="[object Undefined]",$="[object WeakMap]",It="[object WeakSet]",$t="[object ArrayBuffer]",he="[object DataView]",Tt="[object Float32Array]",be="[object Float64Array]",nt="[object Int8Array]",Ct="[object Int16Array]",Wt="[object Int32Array]",fe="[object Uint8Array]",at="[object Uint8ClampedArray]",se="[object Uint16Array]",Qt="[object Uint32Array]",Ce=/\b__p \+= '';/g,Pt=/\b(__p \+=) '' \+/g,Nt=/(__e\(.*?\)|\b__t\)) \+\n'';/g,ze=/&(?:amp|lt|gt|quot|#39);/g,yn=/[&<>"']/g,Wi=RegExp(ze.source),Ar=RegExp(yn.source),Pa=/<%-([\s\S]+?)%>/g,ho=/<%([\s\S]+?)%>/g,Ia=/<%=([\s\S]+?)%>/g,lx=/\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,cm=/^\w*$/,J0=/[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g,cn=/[\\^$.*+?()[\]{}|]/g,cx=RegExp(cn.source),rp=/^\s+/,K=/\s/,gt=/\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/,Et=/\{\n\/\* \[wrapped with (.+)\] \*/,xt=/,? & /,Ft=/[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g,Ve=/[()=,{}\[\]\/\s]/,Ue=/\\(\\)?/g,tr=/\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g,Ke=/\w*$/,Xr=/^[-+]0x[0-9a-f]+$/i,_r=/^0b[01]+$/i,Pr=/^\[object .+?Constructor\]$/,jn=/^0o[0-7]+$/i,np=/^(?:0|[1-9]\d*)$/,um=/[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g,mr=/($^)/,Fl=/['\n\r\u2028\u2029\\]/g,Xn="\\ud800-\\udfff",Bl="\\u0300-\\u036f",ux="\\ufe20-\\ufe2f",Hl="\\u20d0-\\u20ff",Vl=Bl+ux+Hl,Yi="\\u2700-\\u27bf",hm="a-z\\xdf-\\xf6\\xf8-\\xff",qs="\\xac\\xb1\\xd7\\xf7",gpe="\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf",_pe="\\u2000-\\u206f",ype=" \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000",qht="A-Z\\xc0-\\xd6\\xd8-\\xde",Ght="\\ufe0e\\ufe0f",Wht=qs+gpe+_pe+ype,eq="['\u2019]",vpe="["+Xn+"]",Yht="["+Wht+"]",H6="["+Vl+"]",jht="\\d+",xpe="["+Yi+"]",Xht="["+hm+"]",$ht="[^"+Xn+Wht+jht+Yi+hm+qht+"]",rq="\\ud83c[\\udffb-\\udfff]",bpe="(?:"+H6+"|"+rq+")",Kht="[^"+Xn+"]",nq="(?:\\ud83c[\\udde6-\\uddff]){2}",iq="[\\ud800-\\udbff][\\udc00-\\udfff]",hx="["+qht+"]",Zht="\\u200d",Jht="(?:"+Xht+"|"+$ht+")",wpe="(?:"+hx+"|"+$ht+")",Qht="(?:"+eq+"(?:d|ll|m|re|s|t|ve))?",tft="(?:"+eq+"(?:D|LL|M|RE|S|T|VE))?",eft=bpe+"?",rft="["+Ght+"]?",Spe="(?:"+Zht+"(?:"+[Kht,nq,iq].join("|")+")"+rft+eft+")*",Mpe="\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])",Epe="\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])",nft=rft+eft+Spe,Tpe="(?:"+[xpe,nq,iq].join("|")+")"+nft,Cpe="(?:"+[Kht+H6+"?",H6,nq,iq,vpe].join("|")+")",Ape=RegExp(eq,"g"),Ppe=RegExp(H6,"g"),oq=RegExp(rq+"(?="+rq+")|"+Cpe+nft,"g"),Ipe=RegExp([hx+"?"+Xht+"+"+Qht+"(?="+[Yht,hx,"$"].join("|")+")",wpe+"+"+tft+"(?="+[Yht,hx+Jht,"$"].join("|")+")",hx+"?"+Jht+"+"+Qht,hx+"+"+tft,Epe,Mpe,jht,Tpe].join("|"),"g"),Lpe=RegExp("["+Zht+Xn+Vl+Ght+"]"),kpe=/[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/,Rpe=["Array","Buffer","DataView","Date","Error","Float32Array","Float64Array","Function","Int8Array","Int16Array","Int32Array","Map","Math","Object","Promise","RegExp","Set","String","Symbol","TypeError","Uint8Array","Uint8ClampedArray","Uint16Array","Uint32Array","WeakMap","_","clearTimeout","isFinite","parseInt","setTimeout"],Npe=-1,kn={};kn[Tt]=kn[be]=kn[nt]=kn[Ct]=kn[Wt]=kn[fe]=kn[at]=kn[se]=kn[Qt]=!0,kn[bt]=kn[Mt]=kn[$t]=kn[Kt]=kn[he]=kn[_t]=kn[X]=kn[et]=kn[q]=kn[pt]=kn[wt]=kn[ee]=kn[Le]=kn[ar]=kn[$]=!1;var Tn={};Tn[bt]=Tn[Mt]=Tn[$t]=Tn[he]=Tn[Kt]=Tn[_t]=Tn[Tt]=Tn[be]=Tn[nt]=Tn[Ct]=Tn[Wt]=Tn[q]=Tn[pt]=Tn[wt]=Tn[ee]=Tn[Le]=Tn[ar]=Tn[fr]=Tn[fe]=Tn[at]=Tn[se]=Tn[Qt]=!0,Tn[X]=Tn[et]=Tn[$]=!1;var Dpe={\u00C0:"A",\u00C1:"A",\u00C2:"A",\u00C3:"A",\u00C4:"A",\u00C5:"A",\u00E0:"a",\u00E1:"a",\u00E2:"a",\u00E3:"a",\u00E4:"a",\u00E5:"a",\u00C7:"C",\u00E7:"c",\u00D0:"D",\u00F0:"d",\u00C8:"E",\u00C9:"E",\u00CA:"E",\u00CB:"E",\u00E8:"e",\u00E9:"e",\u00EA:"e",\u00EB:"e",\u00CC:"I",\u00CD:"I",\u00CE:"I",\u00CF:"I",\u00EC:"i",\u00ED:"i",\u00EE:"i",\u00EF:"i",\u00D1:"N",\u00F1:"n",\u00D2:"O",\u00D3:"O",\u00D4:"O",\u00D5:"O",\u00D6:"O",\u00D8:"O",\u00F2:"o",\u00F3:"o",\u00F4:"o",\u00F5:"o",\u00F6:"o",\u00F8:"o",\u00D9:"U",\u00DA:"U",\u00DB:"U",\u00DC:"U",\u00F9:"u",\u00FA:"u",\u00FB:"u",\u00FC:"u",\u00DD:"Y",\u00FD:"y",\u00FF:"y",\u00C6:"Ae",\u00E6:"ae",\u00DE:"Th",\u00FE:"th",\u00DF:"ss",\u0100:"A",\u0102:"A",\u0104:"A",\u0101:"a",\u0103:"a",\u0105:"a",\u0106:"C",\u0108:"C",\u010A:"C",\u010C:"C",\u0107:"c",\u0109:"c",\u010B:"c",\u010D:"c",\u010E:"D",\u0110:"D",\u010F:"d",\u0111:"d",\u0112:"E",\u0114:"E",\u0116:"E",\u0118:"E",\u011A:"E",\u0113:"e",\u0115:"e",\u0117:"e",\u0119:"e",\u011B:"e",\u011C:"G",\u011E:"G",\u0120:"G",\u0122:"G",\u011D:"g",\u011F:"g",\u0121:"g",\u0123:"g",\u0124:"H",\u0126:"H",\u0125:"h",\u0127:"h",\u0128:"I",\u012A:"I",\u012C:"I",\u012E:"I",\u0130:"I",\u0129:"i",\u012B:"i",\u012D:"i",\u012F:"i",\u0131:"i",\u0134:"J",\u0135:"j",\u0136:"K",\u0137:"k",\u0138:"k",\u0139:"L",\u013B:"L",\u013D:"L",\u013F:"L",\u0141:"L",\u013A:"l",\u013C:"l",\u013E:"l",\u0140:"l",\u0142:"l",\u0143:"N",\u0145:"N",\u0147:"N",\u014A:"N",\u0144:"n",\u0146:"n",\u0148:"n",\u014B:"n",\u014C:"O",\u014E:"O",\u0150:"O",\u014D:"o",\u014F:"o",\u0151:"o",\u0154:"R",\u0156:"R",\u0158:"R",\u0155:"r",\u0157:"r",\u0159:"r",\u015A:"S",\u015C:"S",\u015E:"S",\u0160:"S",\u015B:"s",\u015D:"s",\u015F:"s",\u0161:"s",\u0162:"T",\u0164:"T",\u0166:"T",\u0163:"t",\u0165:"t",\u0167:"t",\u0168:"U",\u016A:"U",\u016C:"U",\u016E:"U",\u0170:"U",\u0172:"U",\u0169:"u",\u016B:"u",\u016D:"u",\u016F:"u",\u0171:"u",\u0173:"u",\u0174:"W",\u0175:"w",\u0176:"Y",\u0177:"y",\u0178:"Y",\u0179:"Z",\u017B:"Z",\u017D:"Z",\u017A:"z",\u017C:"z",\u017E:"z",\u0132:"IJ",\u0133:"ij",\u0152:"Oe",\u0153:"oe",\u0149:"'n",\u017F:"s"},Ope={"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#39;"},zpe={"&amp;":"&","&lt;":"<","&gt;":">","&quot;":'"',"&#39;":"'"},Fpe={"\\":"\\","'":"'","\n":"n","\r":"r","\u2028":"u2028","\u2029":"u2029"},Bpe=parseFloat,Hpe=parseInt,ift=typeof global=="object"&&global&&global.Object===Object&&global,Vpe=typeof self=="object"&&self&&self.Object===Object&&self,fo=ift||Vpe||Function("return this")(),aq=typeof Rx=="object"&&Rx&&!Rx.nodeType&&Rx,Q0=aq&&typeof $M=="object"&&$M&&!$M.nodeType&&$M,oft=Q0&&Q0.exports===aq,sq=oft&&ift.process,Ul=function(){try{var ut=Q0&&Q0.require&&Q0.require("util").types;return ut||sq&&sq.binding&&sq.binding("util")}catch(At){}}(),aft=Ul&&Ul.isArrayBuffer,sft=Ul&&Ul.isDate,lft=Ul&&Ul.isMap,cft=Ul&&Ul.isRegExp,uft=Ul&&Ul.isSet,hft=Ul&&Ul.isTypedArray;function Gs(ut,At,vt){switch(vt.length){case 0:return ut.call(At);case 1:return ut.call(At,vt[0]);case 2:return ut.call(At,vt[0],vt[1]);case 3:return ut.call(At,vt[0],vt[1],vt[2])}return ut.apply(At,vt)}function Upe(ut,At,vt,ge){for(var We=-1,$r=ut==null?0:ut.length;++We<$r;){var ji=ut[We];At(ge,ji,vt(ji),ut)}return ge}function ql(ut,At){for(var vt=-1,ge=ut==null?0:ut.length;++vt<ge&&At(ut[vt],vt,ut)!==!1;);return ut}function qpe(ut,At){for(var vt=ut==null?0:ut.length;vt--&&At(ut[vt],vt,ut)!==!1;);return ut}function fft(ut,At){for(var vt=-1,ge=ut==null?0:ut.length;++vt<ge;)if(!At(ut[vt],vt,ut))return!1;return!0}function fm(ut,At){for(var vt=-1,ge=ut==null?0:ut.length,We=0,$r=[];++vt<ge;){var ji=ut[vt];At(ji,vt,ut)&&($r[We++]=ji)}return $r}function V6(ut,At){var vt=ut==null?0:ut.length;return!!vt&&fx(ut,At,0)>-1}function lq(ut,At,vt){for(var ge=-1,We=ut==null?0:ut.length;++ge<We;)if(vt(At,ut[ge]))return!0;return!1}function $n(ut,At){for(var vt=-1,ge=ut==null?0:ut.length,We=Array(ge);++vt<ge;)We[vt]=At(ut[vt],vt,ut);return We}function pm(ut,At){for(var vt=-1,ge=At.length,We=ut.length;++vt<ge;)ut[We+vt]=At[vt];return ut}function cq(ut,At,vt,ge){var We=-1,$r=ut==null?0:ut.length;for(ge&&$r&&(vt=ut[++We]);++We<$r;)vt=At(vt,ut[We],We,ut);return vt}function Gpe(ut,At,vt,ge){var We=ut==null?0:ut.length;for(ge&&We&&(vt=ut[--We]);We--;)vt=At(vt,ut[We],We,ut);return vt}function uq(ut,At){for(var vt=-1,ge=ut==null?0:ut.length;++vt<ge;)if(At(ut[vt],vt,ut))return!0;return!1}var Wpe=hq("length");function Ype(ut){return ut.split("")}function jpe(ut){return ut.match(Ft)||[]}function pft(ut,At,vt){var ge;return vt(ut,function(We,$r,ji){if(At(We,$r,ji))return ge=$r,!1}),ge}function U6(ut,At,vt,ge){for(var We=ut.length,$r=vt+(ge?1:-1);ge?$r--:++$r<We;)if(At(ut[$r],$r,ut))return $r;return-1}function fx(ut,At,vt){return At===At?ode(ut,At,vt):U6(ut,dft,vt)}function Xpe(ut,At,vt,ge){for(var We=vt-1,$r=ut.length;++We<$r;)if(ge(ut[We],At))return We;return-1}function dft(ut){return ut!==ut}function mft(ut,At){var vt=ut==null?0:ut.length;return vt?pq(ut,At)/vt:Z}function hq(ut){return function(At){return At==null?e:At[ut]}}function fq(ut){return function(At){return ut==null?e:ut[At]}}function gft(ut,At,vt,ge,We){return We(ut,function($r,ji,vn){vt=ge?(ge=!1,$r):At(vt,$r,ji,vn)}),vt}function $pe(ut,At){var vt=ut.length;for(ut.sort(At);vt--;)ut[vt]=ut[vt].value;return ut}function pq(ut,At){for(var vt,ge=-1,We=ut.length;++ge<We;){var $r=At(ut[ge]);$r!==e&&(vt=vt===e?$r:vt+$r)}return vt}function dq(ut,At){for(var vt=-1,ge=Array(ut);++vt<ut;)ge[vt]=At(vt);return ge}function Kpe(ut,At){return $n(At,function(vt){return[vt,ut[vt]]})}function _ft(ut){return ut&&ut.slice(0,bft(ut)+1).replace(rp,"")}function Ws(ut){return function(At){return ut(At)}}function mq(ut,At){return $n(At,function(vt){return ut[vt]})}function MM(ut,At){return ut.has(At)}function yft(ut,At){for(var vt=-1,ge=ut.length;++vt<ge&&fx(At,ut[vt],0)>-1;);return vt}function vft(ut,At){for(var vt=ut.length;vt--&&fx(At,ut[vt],0)>-1;);return vt}function Zpe(ut,At){for(var vt=ut.length,ge=0;vt--;)ut[vt]===At&&++ge;return ge}var Jpe=fq(Dpe),Qpe=fq(Ope);function tde(ut){return"\\"+Fpe[ut]}function ede(ut,At){return ut==null?e:ut[At]}function px(ut){return Lpe.test(ut)}function rde(ut){return kpe.test(ut)}function nde(ut){for(var At,vt=[];!(At=ut.next()).done;)vt.push(At.value);return vt}function gq(ut){var At=-1,vt=Array(ut.size);return ut.forEach(function(ge,We){vt[++At]=[We,ge]}),vt}function xft(ut,At){return function(vt){return ut(At(vt))}}function dm(ut,At){for(var vt=-1,ge=ut.length,We=0,$r=[];++vt<ge;){var ji=ut[vt];(ji===At||ji===l)&&(ut[vt]=l,$r[We++]=vt)}return $r}function q6(ut){var At=-1,vt=Array(ut.size);return ut.forEach(function(ge){vt[++At]=ge}),vt}function ide(ut){var At=-1,vt=Array(ut.size);return ut.forEach(function(ge){vt[++At]=[ge,ge]}),vt}function ode(ut,At,vt){for(var ge=vt-1,We=ut.length;++ge<We;)if(ut[ge]===At)return ge;return-1}function ade(ut,At,vt){for(var ge=vt+1;ge--;)if(ut[ge]===At)return ge;return ge}function dx(ut){return px(ut)?lde(ut):Wpe(ut)}function tu(ut){return px(ut)?cde(ut):Ype(ut)}function bft(ut){for(var At=ut.length;At--&&K.test(ut.charAt(At)););return At}var sde=fq(zpe);function lde(ut){for(var At=oq.lastIndex=0;oq.test(ut);)++At;return At}function cde(ut){return ut.match(oq)||[]}function ude(ut){return ut.match(Ipe)||[]}var hde=function ut(At){At=At==null?fo:mm.defaults(fo.Object(),At,mm.pick(fo,Rpe));var vt=At.Array,ge=At.Date,We=At.Error,$r=At.Function,ji=At.Math,vn=At.Object,_q=At.RegExp,fde=At.String,Gl=At.TypeError,G6=vt.prototype,pde=$r.prototype,mx=vn.prototype,W6=At["__core-js_shared__"],Y6=pde.toString,un=mx.hasOwnProperty,dde=0,wft=function(){var m=/[^.]+$/.exec(W6&&W6.keys&&W6.keys.IE_PROTO||"");return m?"Symbol(src)_1."+m:""}(),j6=mx.toString,mde=Y6.call(vn),gde=fo._,_de=_q("^"+Y6.call(un).replace(cn,"\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g,"$1.*?")+"$"),X6=oft?At.Buffer:e,gm=At.Symbol,$6=At.Uint8Array,Sft=X6?X6.allocUnsafe:e,K6=xft(vn.getPrototypeOf,vn),Mft=vn.create,Eft=mx.propertyIsEnumerable,Z6=G6.splice,Tft=gm?gm.isConcatSpreadable:e,EM=gm?gm.iterator:e,t_=gm?gm.toStringTag:e,J6=function(){try{var m=o_(vn,"defineProperty");return m({},"",{}),m}catch(v){}}(),yde=At.clearTimeout!==fo.clearTimeout&&At.clearTimeout,vde=ge&&ge.now!==fo.Date.now&&ge.now,xde=At.setTimeout!==fo.setTimeout&&At.setTimeout,Q6=ji.ceil,tI=ji.floor,yq=vn.getOwnPropertySymbols,bde=X6?X6.isBuffer:e,Cft=At.isFinite,wde=G6.join,Sde=xft(vn.keys,vn),Xi=ji.max,ra=ji.min,Mde=ge.now,Ede=At.parseInt,Aft=ji.random,Tde=G6.reverse,vq=o_(At,"DataView"),TM=o_(At,"Map"),xq=o_(At,"Promise"),gx=o_(At,"Set"),CM=o_(At,"WeakMap"),AM=o_(vn,"create"),eI=CM&&new CM,_x={},Cde=a_(vq),Ade=a_(TM),Pde=a_(xq),Ide=a_(gx),Lde=a_(CM),rI=gm?gm.prototype:e,PM=rI?rI.valueOf:e,Pft=rI?rI.toString:e;function G(m){if(si(m)&&!$e(m)&&!(m instanceof gr)){if(m instanceof Wl)return m;if(un.call(m,"__wrapped__"))return Ipt(m)}return new Wl(m)}var yx=function(){function m(){}return function(v){if(!ei(v))return{};if(Mft)return Mft(v);m.prototype=v;var T=new m;return m.prototype=e,T}}();function nI(){}function Wl(m,v){this.__wrapped__=m,this.__actions__=[],this.__chain__=!!v,this.__index__=0,this.__values__=e}G.templateSettings={escape:Pa,evaluate:ho,interpolate:Ia,variable:"",imports:{_:G}},G.prototype=nI.prototype,G.prototype.constructor=G,Wl.prototype=yx(nI.prototype),Wl.prototype.constructor=Wl;function gr(m){this.__wrapped__=m,this.__actions__=[],this.__dir__=1,this.__filtered__=!1,this.__iteratees__=[],this.__takeCount__=rt,this.__views__=[]}function kde(){var m=new gr(this.__wrapped__);return m.__actions__=ps(this.__actions__),m.__dir__=this.__dir__,m.__filtered__=this.__filtered__,m.__iteratees__=ps(this.__iteratees__),m.__takeCount__=this.__takeCount__,m.__views__=ps(this.__views__),m}function Rde(){if(this.__filtered__){var m=new gr(this);m.__dir__=-1,m.__filtered__=!0}else m=this.clone(),m.__dir__*=-1;return m}function Nde(){var m=this.__wrapped__.value(),v=this.__dir__,T=$e(m),N=v<0,V=T?m.length:0,Y=Yme(0,V,this.__views__),J=Y.start,it=Y.end,ft=it-J,Dt=N?it:J-1,Ot=this.__iteratees__,Vt=Ot.length,oe=0,Te=ra(ft,this.__takeCount__);if(!T||!N&&V==ft&&Te==ft)return Qft(m,this.__actions__);var Ne=[];t:for(;ft--&&oe<Te;){Dt+=v;for(var er=-1,De=m[Dt];++er<Vt;){var pr=Ot[er],yr=pr.iteratee,Xs=pr.type,Ra=yr(De);if(Xs==R)De=Ra;else if(!Ra){if(Xs==L)continue t;break t}}Ne[oe++]=De}return Ne}gr.prototype=yx(nI.prototype),gr.prototype.constructor=gr;function e_(m){var v=-1,T=m==null?0:m.length;for(this.clear();++v<T;){var N=m[v];this.set(N[0],N[1])}}function Dde(){this.__data__=AM?AM(null):{},this.size=0}function Ode(m){var v=this.has(m)&&delete this.__data__[m];return this.size-=v?1:0,v}function zde(m){var v=this.__data__;if(AM){var T=v[m];return T===a?e:T}return un.call(v,m)?v[m]:e}function Fde(m){var v=this.__data__;return AM?v[m]!==e:un.call(v,m)}function Bde(m,v){var T=this.__data__;return this.size+=this.has(m)?0:1,T[m]=AM&&v===e?a:v,this}e_.prototype.clear=Dde,e_.prototype.delete=Ode,e_.prototype.get=zde,e_.prototype.has=Fde,e_.prototype.set=Bde;function ip(m){var v=-1,T=m==null?0:m.length;for(this.clear();++v<T;){var N=m[v];this.set(N[0],N[1])}}function Hde(){this.__data__=[],this.size=0}function Vde(m){var v=this.__data__,T=iI(v,m);if(T<0)return!1;var N=v.length-1;return T==N?v.pop():Z6.call(v,T,1),--this.size,!0}function Ude(m){var v=this.__data__,T=iI(v,m);return T<0?e:v[T][1]}function qde(m){return iI(this.__data__,m)>-1}function Gde(m,v){var T=this.__data__,N=iI(T,m);return N<0?(++this.size,T.push([m,v])):T[N][1]=v,this}ip.prototype.clear=Hde,ip.prototype.delete=Vde,ip.prototype.get=Ude,ip.prototype.has=qde,ip.prototype.set=Gde;function op(m){var v=-1,T=m==null?0:m.length;for(this.clear();++v<T;){var N=m[v];this.set(N[0],N[1])}}function Wde(){this.size=0,this.__data__={hash:new e_,map:new(TM||ip),string:new e_}}function Yde(m){var v=gI(this,m).delete(m);return this.size-=v?1:0,v}function jde(m){return gI(this,m).get(m)}function Xde(m){return gI(this,m).has(m)}function $de(m,v){var T=gI(this,m),N=T.size;return T.set(m,v),this.size+=T.size==N?0:1,this}op.prototype.clear=Wde,op.prototype.delete=Yde,op.prototype.get=jde,op.prototype.has=Xde,op.prototype.set=$de;function r_(m){var v=-1,T=m==null?0:m.length;for(this.__data__=new op;++v<T;)this.add(m[v])}function Kde(m){return this.__data__.set(m,a),this}function Zde(m){return this.__data__.has(m)}r_.prototype.add=r_.prototype.push=Kde,r_.prototype.has=Zde;function eu(m){var v=this.__data__=new ip(m);this.size=v.size}function Jde(){this.__data__=new ip,this.size=0}function Qde(m){var v=this.__data__,T=v.delete(m);return this.size=v.size,T}function tme(m){return this.__data__.get(m)}function eme(m){return this.__data__.has(m)}function rme(m,v){var T=this.__data__;if(T instanceof ip){var N=T.__data__;if(!TM||N.length<r-1)return N.push([m,v]),this.size=++T.size,this;T=this.__data__=new op(N)}return T.set(m,v),this.size=T.size,this}eu.prototype.clear=Jde,eu.prototype.delete=Qde,eu.prototype.get=tme,eu.prototype.has=eme,eu.prototype.set=rme;function Ift(m,v){var T=$e(m),N=!T&&s_(m),V=!T&&!N&&bm(m),Y=!T&&!N&&!V&&wx(m),J=T||N||V||Y,it=J?dq(m.length,fde):[],ft=it.length;for(var Dt in m)(v||un.call(m,Dt))&&!(J&&(Dt=="length"||V&&(Dt=="offset"||Dt=="parent")||Y&&(Dt=="buffer"||Dt=="byteLength"||Dt=="byteOffset")||cp(Dt,ft)))&&it.push(Dt);return it}function Lft(m){var v=m.length;return v?m[Lq(0,v-1)]:e}function nme(m,v){return _I(ps(m),n_(v,0,m.length))}function ime(m){return _I(ps(m))}function bq(m,v,T){(T!==e&&!ru(m[v],T)||T===e&&!(v in m))&&ap(m,v,T)}function IM(m,v,T){var N=m[v];(!(un.call(m,v)&&ru(N,T))||T===e&&!(v in m))&&ap(m,v,T)}function iI(m,v){for(var T=m.length;T--;)if(ru(m[T][0],v))return T;return-1}function ome(m,v,T,N){return _m(m,function(V,Y,J){v(N,V,T(V),J)}),N}function kft(m,v){return m&&gh(v,po(v),m)}function ame(m,v){return m&&gh(v,ms(v),m)}function ap(m,v,T){v=="__proto__"&&J6?J6(m,v,{configurable:!0,enumerable:!0,value:T,writable:!0}):m[v]=T}function wq(m,v){for(var T=-1,N=v.length,V=vt(N),Y=m==null;++T<N;)V[T]=Y?e:rG(m,v[T]);return V}function n_(m,v,T){return m===m&&(T!==e&&(m=m<=T?m:T),v!==e&&(m=m>=v?m:v)),m}function Yl(m,v,T,N,V,Y){var J,it=v&c,ft=v&u,Dt=v&h;if(T&&(J=V?T(m,N,V,Y):T(m)),J!==e)return J;if(!ei(m))return m;var Ot=$e(m);if(Ot){if(J=Xme(m),!it)return ps(m,J)}else{var Vt=na(m),oe=Vt==et||Vt==dt;if(bm(m))return rpt(m,it);if(Vt==wt||Vt==bt||oe&&!V){if(J=ft||oe?{}:bpt(m),!it)return ft?zme(m,ame(J,m)):Ome(m,kft(J,m))}else{if(!Tn[Vt])return V?m:{};J=$me(m,Vt,it)}}Y||(Y=new eu);var Te=Y.get(m);if(Te)return Te;Y.set(m,J),Kpt(m)?m.forEach(function(De){J.add(Yl(De,v,T,De,m,Y))}):Xpt(m)&&m.forEach(function(De,pr){J.set(pr,Yl(De,v,T,pr,m,Y))});var Ne=Dt?ft?Uq:Vq:ft?ms:po,er=Ot?e:Ne(m);return ql(er||m,function(De,pr){er&&(pr=De,De=m[pr]),IM(J,pr,Yl(De,v,T,pr,m,Y))}),J}function sme(m){var v=po(m);return function(T){return Rft(T,m,v)}}function Rft(m,v,T){var N=T.length;if(m==null)return!N;for(m=vn(m);N--;){var V=T[N],Y=v[V],J=m[V];if(J===e&&!(V in m)||!Y(J))return!1}return!0}function Nft(m,v,T){if(typeof m!="function")throw new Gl(i);return zM(function(){m.apply(e,T)},v)}function LM(m,v,T,N){var V=-1,Y=V6,J=!0,it=m.length,ft=[],Dt=v.length;if(!it)return ft;T&&(v=$n(v,Ws(T))),N?(Y=lq,J=!1):v.length>=r&&(Y=MM,J=!1,v=new r_(v));t:for(;++V<it;){var Ot=m[V],Vt=T==null?Ot:T(Ot);if(Ot=N||Ot!==0?Ot:0,J&&Vt===Vt){for(var oe=Dt;oe--;)if(v[oe]===Vt)continue t;ft.push(Ot)}else Y(v,Vt,N)||ft.push(Ot)}return ft}var _m=spt(mh),Dft=spt(Mq,!0);function lme(m,v){var T=!0;return _m(m,function(N,V,Y){return T=!!v(N,V,Y),T}),T}function oI(m,v,T){for(var N=-1,V=m.length;++N<V;){var Y=m[N],J=v(Y);if(J!=null&&(it===e?J===J&&!js(J):T(J,it)))var it=J,ft=Y}return ft}function cme(m,v,T,N){var V=m.length;for(T=Qe(T),T<0&&(T=-T>V?0:V+T),N=N===e||N>V?V:Qe(N),N<0&&(N+=V),N=T>N?0:Jpt(N);T<N;)m[T++]=v;return m}function Oft(m,v){var T=[];return _m(m,function(N,V,Y){v(N,V,Y)&&T.push(N)}),T}function Ro(m,v,T,N,V){var Y=-1,J=m.length;for(T||(T=Zme),V||(V=[]);++Y<J;){var it=m[Y];v>0&&T(it)?v>1?Ro(it,v-1,T,N,V):pm(V,it):N||(V[V.length]=it)}return V}var Sq=lpt(),zft=lpt(!0);function mh(m,v){return m&&Sq(m,v,po)}function Mq(m,v){return m&&zft(m,v,po)}function aI(m,v){return fm(v,function(T){return up(m[T])})}function i_(m,v){v=vm(v,m);for(var T=0,N=v.length;m!=null&&T<N;)m=m[_h(v[T++])];return T&&T==N?m:e}function Fft(m,v,T){var N=v(m);return $e(m)?N:pm(N,T(m))}function La(m){return m==null?m===e?tt:ht:t_&&t_ in vn(m)?Wme(m):ige(m)}function Eq(m,v){return m>v}function ume(m,v){return m!=null&&un.call(m,v)}function hme(m,v){return m!=null&&v in vn(m)}function fme(m,v,T){return m>=ra(v,T)&&m<Xi(v,T)}function Tq(m,v,T){for(var N=T?lq:V6,V=m[0].length,Y=m.length,J=Y,it=vt(Y),ft=1/0,Dt=[];J--;){var Ot=m[J];J&&v&&(Ot=$n(Ot,Ws(v))),ft=ra(Ot.length,ft),it[J]=!T&&(v||V>=120&&Ot.length>=120)?new r_(J&&Ot):e}Ot=m[0];var Vt=-1,oe=it[0];t:for(;++Vt<V&&Dt.length<ft;){var Te=Ot[Vt],Ne=v?v(Te):Te;if(Te=T||Te!==0?Te:0,!(oe?MM(oe,Ne):N(Dt,Ne,T))){for(J=Y;--J;){var er=it[J];if(!(er?MM(er,Ne):N(m[J],Ne,T)))continue t}oe&&oe.push(Ne),Dt.push(Te)}}return Dt}function pme(m,v,T,N){return mh(m,function(V,Y,J){v(N,T(V),Y,J)}),N}function kM(m,v,T){v=vm(v,m),m=Ept(m,v);var N=m==null?m:m[_h(Xl(v))];return N==null?e:Gs(N,m,T)}function Bft(m){return si(m)&&La(m)==bt}function dme(m){return si(m)&&La(m)==$t}function mme(m){return si(m)&&La(m)==_t}function RM(m,v,T,N,V){return m===v?!0:m==null||v==null||!si(m)&&!si(v)?m!==m&&v!==v:gme(m,v,T,N,RM,V)}function gme(m,v,T,N,V,Y){var J=$e(m),it=$e(v),ft=J?Mt:na(m),Dt=it?Mt:na(v);ft=ft==bt?wt:ft,Dt=Dt==bt?wt:Dt;var Ot=ft==wt,Vt=Dt==wt,oe=ft==Dt;if(oe&&bm(m)){if(!bm(v))return!1;J=!0,Ot=!1}if(oe&&!Ot)return Y||(Y=new eu),J||wx(m)?ypt(m,v,T,N,V,Y):qme(m,v,ft,T,N,V,Y);if(!(T&f)){var Te=Ot&&un.call(m,"__wrapped__"),Ne=Vt&&un.call(v,"__wrapped__");if(Te||Ne){var er=Te?m.value():m,De=Ne?v.value():v;return Y||(Y=new eu),V(er,De,T,N,Y)}}return oe?(Y||(Y=new eu),Gme(m,v,T,N,V,Y)):!1}function _me(m){return si(m)&&na(m)==q}function Cq(m,v,T,N){var V=T.length,Y=V,J=!N;if(m==null)return!Y;for(m=vn(m);V--;){var it=T[V];if(J&&it[2]?it[1]!==m[it[0]]:!(it[0]in m))return!1}for(;++V<Y;){it=T[V];var ft=it[0],Dt=m[ft],Ot=it[1];if(J&&it[2]){if(Dt===e&&!(ft in m))return!1}else{var Vt=new eu;if(N)var oe=N(Dt,Ot,ft,m,v,Vt);if(!(oe===e?RM(Ot,Dt,f|p,N,Vt):oe))return!1}}return!0}function Hft(m){if(!ei(m)||Qme(m))return!1;var v=up(m)?_de:Pr;return v.test(a_(m))}function yme(m){return si(m)&&La(m)==ee}function vme(m){return si(m)&&na(m)==Le}function xme(m){return si(m)&&SI(m.length)&&!!kn[La(m)]}function Vft(m){return typeof m=="function"?m:m==null?gs:typeof m=="object"?$e(m)?Gft(m[0],m[1]):qft(m):cdt(m)}function Aq(m){if(!OM(m))return Sde(m);var v=[];for(var T in vn(m))un.call(m,T)&&T!="constructor"&&v.push(T);return v}function bme(m){if(!ei(m))return nge(m);var v=OM(m),T=[];for(var N in m)N=="constructor"&&(v||!un.call(m,N))||T.push(N);return T}function Pq(m,v){return m<v}function Uft(m,v){var T=-1,N=ds(m)?vt(m.length):[];return _m(m,function(V,Y,J){N[++T]=v(V,Y,J)}),N}function qft(m){var v=Gq(m);return v.length==1&&v[0][2]?Spt(v[0][0],v[0][1]):function(T){return T===m||Cq(T,m,v)}}function Gft(m,v){return Yq(m)&&wpt(v)?Spt(_h(m),v):function(T){var N=rG(T,m);return N===e&&N===v?nG(T,m):RM(v,N,f|p)}}function sI(m,v,T,N,V){m!==v&&Sq(v,function(Y,J){if(V||(V=new eu),ei(Y))wme(m,v,J,T,sI,N,V);else{var it=N?N(Xq(m,J),Y,J+"",m,v,V):e;it===e&&(it=Y),bq(m,J,it)}},ms)}function wme(m,v,T,N,V,Y,J){var it=Xq(m,T),ft=Xq(v,T),Dt=J.get(ft);if(Dt){bq(m,T,Dt);return}var Ot=Y?Y(it,ft,T+"",m,v,J):e,Vt=Ot===e;if(Vt){var oe=$e(ft),Te=!oe&&bm(ft),Ne=!oe&&!Te&&wx(ft);Ot=ft,oe||Te||Ne?$e(it)?Ot=it:xi(it)?Ot=ps(it):Te?(Vt=!1,Ot=rpt(ft,!0)):Ne?(Vt=!1,Ot=npt(ft,!0)):Ot=[]:FM(ft)||s_(ft)?(Ot=it,s_(it)?Ot=Qpt(it):(!ei(it)||up(it))&&(Ot=bpt(ft))):Vt=!1}Vt&&(J.set(ft,Ot),V(Ot,ft,N,Y,J),J.delete(ft)),bq(m,T,Ot)}function Wft(m,v){var T=m.length;if(!!T)return v+=v<0?T:0,cp(v,T)?m[v]:e}function Yft(m,v,T){v.length?v=$n(v,function(Y){return $e(Y)?function(J){return i_(J,Y.length===1?Y[0]:Y)}:Y}):v=[gs];var N=-1;v=$n(v,Ws(ke()));var V=Uft(m,function(Y,J,it){var ft=$n(v,function(Dt){return Dt(Y)});return{criteria:ft,index:++N,value:Y}});return $pe(V,function(Y,J){return Dme(Y,J,T)})}function Sme(m,v){return jft(m,v,function(T,N){return nG(m,N)})}function jft(m,v,T){for(var N=-1,V=v.length,Y={};++N<V;){var J=v[N],it=i_(m,J);T(it,J)&&NM(Y,vm(J,m),it)}return Y}function Mme(m){return function(v){return i_(v,m)}}function Iq(m,v,T,N){var V=N?Xpe:fx,Y=-1,J=v.length,it=m;for(m===v&&(v=ps(v)),T&&(it=$n(m,Ws(T)));++Y<J;)for(var ft=0,Dt=v[Y],Ot=T?T(Dt):Dt;(ft=V(it,Ot,ft,N))>-1;)it!==m&&Z6.call(it,ft,1),Z6.call(m,ft,1);return m}function Xft(m,v){for(var T=m?v.length:0,N=T-1;T--;){var V=v[T];if(T==N||V!==Y){var Y=V;cp(V)?Z6.call(m,V,1):Nq(m,V)}}return m}function Lq(m,v){return m+tI(Aft()*(v-m+1))}function Eme(m,v,T,N){for(var V=-1,Y=Xi(Q6((v-m)/(T||1)),0),J=vt(Y);Y--;)J[N?Y:++V]=m,m+=T;return J}function kq(m,v){var T="";if(!m||v<1||v>U)return T;do v%2&&(T+=m),v=tI(v/2),v&&(m+=m);while(v);return T}function nr(m,v){return $q(Mpt(m,v,gs),m+"")}function Tme(m){return Lft(Sx(m))}function Cme(m,v){var T=Sx(m);return _I(T,n_(v,0,T.length))}function NM(m,v,T,N){if(!ei(m))return m;v=vm(v,m);for(var V=-1,Y=v.length,J=Y-1,it=m;it!=null&&++V<Y;){var ft=_h(v[V]),Dt=T;if(ft==="__proto__"||ft==="constructor"||ft==="prototype")return m;if(V!=J){var Ot=it[ft];Dt=N?N(Ot,ft,it):e,Dt===e&&(Dt=ei(Ot)?Ot:cp(v[V+1])?[]:{})}IM(it,ft,Dt),it=it[ft]}return m}var $ft=eI?function(m,v){return eI.set(m,v),m}:gs,Ame=J6?function(m,v){return J6(m,"toString",{configurable:!0,enumerable:!1,value:oG(v),writable:!0})}:gs;function Pme(m){return _I(Sx(m))}function jl(m,v,T){var N=-1,V=m.length;v<0&&(v=-v>V?0:V+v),T=T>V?V:T,T<0&&(T+=V),V=v>T?0:T-v>>>0,v>>>=0;for(var Y=vt(V);++N<V;)Y[N]=m[N+v];return Y}function Ime(m,v){var T;return _m(m,function(N,V,Y){return T=v(N,V,Y),!T}),!!T}function lI(m,v,T){var N=0,V=m==null?N:m.length;if(typeof v=="number"&&v===v&&V<=st){for(;N<V;){var Y=N+V>>>1,J=m[Y];J!==null&&!js(J)&&(T?J<=v:J<v)?N=Y+1:V=Y}return V}return Rq(m,v,gs,T)}function Rq(m,v,T,N){var V=0,Y=m==null?0:m.length;if(Y===0)return 0;v=T(v);for(var J=v!==v,it=v===null,ft=js(v),Dt=v===e;V<Y;){var Ot=tI((V+Y)/2),Vt=T(m[Ot]),oe=Vt!==e,Te=Vt===null,Ne=Vt===Vt,er=js(Vt);if(J)var De=N||Ne;else Dt?De=Ne&&(N||oe):it?De=Ne&&oe&&(N||!Te):ft?De=Ne&&oe&&!Te&&(N||!er):Te||er?De=!1:De=N?Vt<=v:Vt<v;De?V=Ot+1:Y=Ot}return ra(Y,ot)}function Kft(m,v){for(var T=-1,N=m.length,V=0,Y=[];++T<N;){var J=m[T],it=v?v(J):J;if(!T||!ru(it,ft)){var ft=it;Y[V++]=J===0?0:J}}return Y}function Zft(m){return typeof m=="number"?m:js(m)?Z:+m}function Ys(m){if(typeof m=="string")return m;if($e(m))return $n(m,Ys)+"";if(js(m))return Pft?Pft.call(m):"";var v=m+"";return v=="0"&&1/m==-z?"-0":v}function ym(m,v,T){var N=-1,V=V6,Y=m.length,J=!0,it=[],ft=it;if(T)J=!1,V=lq;else if(Y>=r){var Dt=v?null:Vme(m);if(Dt)return q6(Dt);J=!1,V=MM,ft=new r_}else ft=v?[]:it;t:for(;++N<Y;){var Ot=m[N],Vt=v?v(Ot):Ot;if(Ot=T||Ot!==0?Ot:0,J&&Vt===Vt){for(var oe=ft.length;oe--;)if(ft[oe]===Vt)continue t;v&&ft.push(Vt),it.push(Ot)}else V(ft,Vt,T)||(ft!==it&&ft.push(Vt),it.push(Ot))}return it}function Nq(m,v){return v=vm(v,m),m=Ept(m,v),m==null||delete m[_h(Xl(v))]}function Jft(m,v,T,N){return NM(m,v,T(i_(m,v)),N)}function cI(m,v,T,N){for(var V=m.length,Y=N?V:-1;(N?Y--:++Y<V)&&v(m[Y],Y,m););return T?jl(m,N?0:Y,N?Y+1:V):jl(m,N?Y+1:0,N?V:Y)}function Qft(m,v){var T=m;return T instanceof gr&&(T=T.value()),cq(v,function(N,V){return V.func.apply(V.thisArg,pm([N],V.args))},T)}function Dq(m,v,T){var N=m.length;if(N<2)return N?ym(m[0]):[];for(var V=-1,Y=vt(N);++V<N;)for(var J=m[V],it=-1;++it<N;)it!=V&&(Y[V]=LM(Y[V]||J,m[it],v,T));return ym(Ro(Y,1),v,T)}function tpt(m,v,T){for(var N=-1,V=m.length,Y=v.length,J={};++N<V;){var it=N<Y?v[N]:e;T(J,m[N],it)}return J}function Oq(m){return xi(m)?m:[]}function zq(m){return typeof m=="function"?m:gs}function vm(m,v){return $e(m)?m:Yq(m,v)?[m]:Ppt(on(m))}var Lme=nr;function xm(m,v,T){var N=m.length;return T=T===e?N:T,!v&&T>=N?m:jl(m,v,T)}var ept=yde||function(m){return fo.clearTimeout(m)};function rpt(m,v){if(v)return m.slice();var T=m.length,N=Sft?Sft(T):new m.constructor(T);return m.copy(N),N}function Fq(m){var v=new m.constructor(m.byteLength);return new $6(v).set(new $6(m)),v}function kme(m,v){var T=v?Fq(m.buffer):m.buffer;return new m.constructor(T,m.byteOffset,m.byteLength)}function Rme(m){var v=new m.constructor(m.source,Ke.exec(m));return v.lastIndex=m.lastIndex,v}function Nme(m){return PM?vn(PM.call(m)):{}}function npt(m,v){var T=v?Fq(m.buffer):m.buffer;return new m.constructor(T,m.byteOffset,m.length)}function ipt(m,v){if(m!==v){var T=m!==e,N=m===null,V=m===m,Y=js(m),J=v!==e,it=v===null,ft=v===v,Dt=js(v);if(!it&&!Dt&&!Y&&m>v||Y&&J&&ft&&!it&&!Dt||N&&J&&ft||!T&&ft||!V)return 1;if(!N&&!Y&&!Dt&&m<v||Dt&&T&&V&&!N&&!Y||it&&T&&V||!J&&V||!ft)return-1}return 0}function Dme(m,v,T){for(var N=-1,V=m.criteria,Y=v.criteria,J=V.length,it=T.length;++N<J;){var ft=ipt(V[N],Y[N]);if(ft){if(N>=it)return ft;var Dt=T[N];return ft*(Dt=="desc"?-1:1)}}return m.index-v.index}function opt(m,v,T,N){for(var V=-1,Y=m.length,J=T.length,it=-1,ft=v.length,Dt=Xi(Y-J,0),Ot=vt(ft+Dt),Vt=!N;++it<ft;)Ot[it]=v[it];for(;++V<J;)(Vt||V<Y)&&(Ot[T[V]]=m[V]);for(;Dt--;)Ot[it++]=m[V++];return Ot}function apt(m,v,T,N){for(var V=-1,Y=m.length,J=-1,it=T.length,ft=-1,Dt=v.length,Ot=Xi(Y-it,0),Vt=vt(Ot+Dt),oe=!N;++V<Ot;)Vt[V]=m[V];for(var Te=V;++ft<Dt;)Vt[Te+ft]=v[ft];for(;++J<it;)(oe||V<Y)&&(Vt[Te+T[J]]=m[V++]);return Vt}function ps(m,v){var T=-1,N=m.length;for(v||(v=vt(N));++T<N;)v[T]=m[T];return v}function gh(m,v,T,N){var V=!T;T||(T={});for(var Y=-1,J=v.length;++Y<J;){var it=v[Y],ft=N?N(T[it],m[it],it,T,m):e;ft===e&&(ft=m[it]),V?ap(T,it,ft):IM(T,it,ft)}return T}function Ome(m,v){return gh(m,Wq(m),v)}function zme(m,v){return gh(m,vpt(m),v)}function uI(m,v){return function(T,N){var V=$e(T)?Upe:ome,Y=v?v():{};return V(T,m,ke(N,2),Y)}}function vx(m){return nr(function(v,T){var N=-1,V=T.length,Y=V>1?T[V-1]:e,J=V>2?T[2]:e;for(Y=m.length>3&&typeof Y=="function"?(V--,Y):e,J&&ka(T[0],T[1],J)&&(Y=V<3?e:Y,V=1),v=vn(v);++N<V;){var it=T[N];it&&m(v,it,N,Y)}return v})}function spt(m,v){return function(T,N){if(T==null)return T;if(!ds(T))return m(T,N);for(var V=T.length,Y=v?V:-1,J=vn(T);(v?Y--:++Y<V)&&N(J[Y],Y,J)!==!1;);return T}}function lpt(m){return function(v,T,N){for(var V=-1,Y=vn(v),J=N(v),it=J.length;it--;){var ft=J[m?it:++V];if(T(Y[ft],ft,Y)===!1)break}return v}}function Fme(m,v,T){var N=v&d,V=DM(m);function Y(){var J=this&&this!==fo&&this instanceof Y?V:m;return J.apply(N?T:this,arguments)}return Y}function cpt(m){return function(v){v=on(v);var T=px(v)?tu(v):e,N=T?T[0]:v.charAt(0),V=T?xm(T,1).join(""):v.slice(1);return N[m]()+V}}function xx(m){return function(v){return cq(sdt(adt(v).replace(Ape,"")),m,"")}}function DM(m){return function(){var v=arguments;switch(v.length){case 0:return new m;case 1:return new m(v[0]);case 2:return new m(v[0],v[1]);case 3:return new m(v[0],v[1],v[2]);case 4:return new m(v[0],v[1],v[2],v[3]);case 5:return new m(v[0],v[1],v[2],v[3],v[4]);case 6:return new m(v[0],v[1],v[2],v[3],v[4],v[5]);case 7:return new m(v[0],v[1],v[2],v[3],v[4],v[5],v[6])}var T=yx(m.prototype),N=m.apply(T,v);return ei(N)?N:T}}function Bme(m,v,T){var N=DM(m);function V(){for(var Y=arguments.length,J=vt(Y),it=Y,ft=bx(V);it--;)J[it]=arguments[it];var Dt=Y<3&&J[0]!==ft&&J[Y-1]!==ft?[]:dm(J,ft);if(Y-=Dt.length,Y<T)return dpt(m,v,hI,V.placeholder,e,J,Dt,e,e,T-Y);var Ot=this&&this!==fo&&this instanceof V?N:m;return Gs(Ot,this,J)}return V}function upt(m){return function(v,T,N){var V=vn(v);if(!ds(v)){var Y=ke(T,3);v=po(v),T=function(it){return Y(V[it],it,V)}}var J=m(v,T,N);return J>-1?V[Y?v[J]:J]:e}}function hpt(m){return lp(function(v){var T=v.length,N=T,V=Wl.prototype.thru;for(m&&v.reverse();N--;){var Y=v[N];if(typeof Y!="function")throw new Gl(i);if(V&&!J&&mI(Y)=="wrapper")var J=new Wl([],!0)}for(N=J?N:T;++N<T;){Y=v[N];var it=mI(Y),ft=it=="wrapper"?qq(Y):e;ft&&jq(ft[0])&&ft[1]==(C|y|b|P)&&!ft[4].length&&ft[9]==1?J=J[mI(ft[0])].apply(J,ft[3]):J=Y.length==1&&jq(Y)?J[it]():J.thru(Y)}return function(){var Dt=arguments,Ot=Dt[0];if(J&&Dt.length==1&&$e(Ot))return J.plant(Ot).value();for(var Vt=0,oe=T?v[Vt].apply(this,Dt):Ot;++Vt<T;)oe=v[Vt].call(this,oe);return oe}})}function hI(m,v,T,N,V,Y,J,it,ft,Dt){var Ot=v&C,Vt=v&d,oe=v&g,Te=v&(y|x),Ne=v&k,er=oe?e:DM(m);function De(){for(var pr=arguments.length,yr=vt(pr),Xs=pr;Xs--;)yr[Xs]=arguments[Xs];if(Te)var Ra=bx(De),$s=Zpe(yr,Ra);if(N&&(yr=opt(yr,N,V,Te)),Y&&(yr=apt(yr,Y,J,Te)),pr-=$s,Te&&pr<Dt){var bi=dm(yr,Ra);return dpt(m,v,hI,De.placeholder,T,yr,bi,it,ft,Dt-pr)}var nu=Vt?T:this,fp=oe?nu[m]:m;return pr=yr.length,it?yr=oge(yr,it):Ne&&pr>1&&yr.reverse(),Ot&&ft<pr&&(yr.length=ft),this&&this!==fo&&this instanceof De&&(fp=er||DM(fp)),fp.apply(nu,yr)}return De}function fpt(m,v){return function(T,N){return pme(T,m,v(N),{})}}function fI(m,v){return function(T,N){var V;if(T===e&&N===e)return v;if(T!==e&&(V=T),N!==e){if(V===e)return N;typeof T=="string"||typeof N=="string"?(T=Ys(T),N=Ys(N)):(T=Zft(T),N=Zft(N)),V=m(T,N)}return V}}function Bq(m){return lp(function(v){return v=$n(v,Ws(ke())),nr(function(T){var N=this;return m(v,function(V){return Gs(V,N,T)})})})}function pI(m,v){v=v===e?" ":Ys(v);var T=v.length;if(T<2)return T?kq(v,m):v;var N=kq(v,Q6(m/dx(v)));return px(v)?xm(tu(N),0,m).join(""):N.slice(0,m)}function Hme(m,v,T,N){var V=v&d,Y=DM(m);function J(){for(var it=-1,ft=arguments.length,Dt=-1,Ot=N.length,Vt=vt(Ot+ft),oe=this&&this!==fo&&this instanceof J?Y:m;++Dt<Ot;)Vt[Dt]=N[Dt];for(;ft--;)Vt[Dt++]=arguments[++it];return Gs(oe,V?T:this,Vt)}return J}function ppt(m){return function(v,T,N){return N&&typeof N!="number"&&ka(v,T,N)&&(T=N=e),v=hp(v),T===e?(T=v,v=0):T=hp(T),N=N===e?v<T?1:-1:hp(N),Eme(v,T,N,m)}}function dI(m){return function(v,T){return typeof v=="string"&&typeof T=="string"||(v=$l(v),T=$l(T)),m(v,T)}}function dpt(m,v,T,N,V,Y,J,it,ft,Dt){var Ot=v&y,Vt=Ot?J:e,oe=Ot?e:J,Te=Ot?Y:e,Ne=Ot?e:Y;v|=Ot?b:S,v&=~(Ot?S:b),v&_||(v&=~(d|g));var er=[m,v,V,Te,Vt,Ne,oe,it,ft,Dt],De=T.apply(e,er);return jq(m)&&Tpt(De,er),De.placeholder=N,Cpt(De,m,v)}function Hq(m){var v=ji[m];return function(T,N){if(T=$l(T),N=N==null?0:ra(Qe(N),292),N&&Cft(T)){var V=(on(T)+"e").split("e"),Y=v(V[0]+"e"+(+V[1]+N));return V=(on(Y)+"e").split("e"),+(V[0]+"e"+(+V[1]-N))}return v(T)}}var Vme=gx&&1/q6(new gx([,-0]))[1]==z?function(m){return new gx(m)}:lG;function mpt(m){return function(v){var T=na(v);return T==q?gq(v):T==Le?ide(v):Kpe(v,m(v))}}function sp(m,v,T,N,V,Y,J,it){var ft=v&g;if(!ft&&typeof m!="function")throw new Gl(i);var Dt=N?N.length:0;if(Dt||(v&=~(b|S),N=V=e),J=J===e?J:Xi(Qe(J),0),it=it===e?it:Qe(it),Dt-=V?V.length:0,v&S){var Ot=N,Vt=V;N=V=e}var oe=ft?e:qq(m),Te=[m,v,T,N,V,Ot,Vt,Y,J,it];if(oe&&rge(Te,oe),m=Te[0],v=Te[1],T=Te[2],N=Te[3],V=Te[4],it=Te[9]=Te[9]===e?ft?0:m.length:Xi(Te[9]-Dt,0),!it&&v&(y|x)&&(v&=~(y|x)),!v||v==d)var Ne=Fme(m,v,T);else v==y||v==x?Ne=Bme(m,v,it):(v==b||v==(d|b))&&!V.length?Ne=Hme(m,v,T,N):Ne=hI.apply(e,Te);var er=oe?$ft:Tpt;return Cpt(er(Ne,Te),m,v)}function gpt(m,v,T,N){return m===e||ru(m,mx[T])&&!un.call(N,T)?v:m}function _pt(m,v,T,N,V,Y){return ei(m)&&ei(v)&&(Y.set(v,m),sI(m,v,e,_pt,Y),Y.delete(v)),m}function Ume(m){return FM(m)?e:m}function ypt(m,v,T,N,V,Y){var J=T&f,it=m.length,ft=v.length;if(it!=ft&&!(J&&ft>it))return!1;var Dt=Y.get(m),Ot=Y.get(v);if(Dt&&Ot)return Dt==v&&Ot==m;var Vt=-1,oe=!0,Te=T&p?new r_:e;for(Y.set(m,v),Y.set(v,m);++Vt<it;){var Ne=m[Vt],er=v[Vt];if(N)var De=J?N(er,Ne,Vt,v,m,Y):N(Ne,er,Vt,m,v,Y);if(De!==e){if(De)continue;oe=!1;break}if(Te){if(!uq(v,function(pr,yr){if(!MM(Te,yr)&&(Ne===pr||V(Ne,pr,T,N,Y)))return Te.push(yr)})){oe=!1;break}}else if(!(Ne===er||V(Ne,er,T,N,Y))){oe=!1;break}}return Y.delete(m),Y.delete(v),oe}function qme(m,v,T,N,V,Y,J){switch(T){case he:if(m.byteLength!=v.byteLength||m.byteOffset!=v.byteOffset)return!1;m=m.buffer,v=v.buffer;case $t:return!(m.byteLength!=v.byteLength||!Y(new $6(m),new $6(v)));case Kt:case _t:case pt:return ru(+m,+v);case X:return m.name==v.name&&m.message==v.message;case ee:case ar:return m==v+"";case q:var it=gq;case Le:var ft=N&f;if(it||(it=q6),m.size!=v.size&&!ft)return!1;var Dt=J.get(m);if(Dt)return Dt==v;N|=p,J.set(m,v);var Ot=ypt(it(m),it(v),N,V,Y,J);return J.delete(m),Ot;case fr:if(PM)return PM.call(m)==PM.call(v)}return!1}function Gme(m,v,T,N,V,Y){var J=T&f,it=Vq(m),ft=it.length,Dt=Vq(v),Ot=Dt.length;if(ft!=Ot&&!J)return!1;for(var Vt=ft;Vt--;){var oe=it[Vt];if(!(J?oe in v:un.call(v,oe)))return!1}var Te=Y.get(m),Ne=Y.get(v);if(Te&&Ne)return Te==v&&Ne==m;var er=!0;Y.set(m,v),Y.set(v,m);for(var De=J;++Vt<ft;){oe=it[Vt];var pr=m[oe],yr=v[oe];if(N)var Xs=J?N(yr,pr,oe,v,m,Y):N(pr,yr,oe,m,v,Y);if(!(Xs===e?pr===yr||V(pr,yr,T,N,Y):Xs)){er=!1;break}De||(De=oe=="constructor")}if(er&&!De){var Ra=m.constructor,$s=v.constructor;Ra!=$s&&"constructor"in m&&"constructor"in v&&!(typeof Ra=="function"&&Ra instanceof Ra&&typeof $s=="function"&&$s instanceof $s)&&(er=!1)}return Y.delete(m),Y.delete(v),er}function lp(m){return $q(Mpt(m,e,Rpt),m+"")}function Vq(m){return Fft(m,po,Wq)}function Uq(m){return Fft(m,ms,vpt)}var qq=eI?function(m){return eI.get(m)}:lG;function mI(m){for(var v=m.name+"",T=_x[v],N=un.call(_x,v)?T.length:0;N--;){var V=T[N],Y=V.func;if(Y==null||Y==m)return V.name}return v}function bx(m){var v=un.call(G,"placeholder")?G:m;return v.placeholder}function ke(){var m=G.iteratee||aG;return m=m===aG?Vft:m,arguments.length?m(arguments[0],arguments[1]):m}function gI(m,v){var T=m.__data__;return Jme(v)?T[typeof v=="string"?"string":"hash"]:T.map}function Gq(m){for(var v=po(m),T=v.length;T--;){var N=v[T],V=m[N];v[T]=[N,V,wpt(V)]}return v}function o_(m,v){var T=ede(m,v);return Hft(T)?T:e}function Wme(m){var v=un.call(m,t_),T=m[t_];try{m[t_]=e;var N=!0}catch(Y){}var V=j6.call(m);return N&&(v?m[t_]=T:delete m[t_]),V}var Wq=yq?function(m){return m==null?[]:(m=vn(m),fm(yq(m),function(v){return Eft.call(m,v)}))}:cG,vpt=yq?function(m){for(var v=[];m;)pm(v,Wq(m)),m=K6(m);return v}:cG,na=La;(vq&&na(new vq(new ArrayBuffer(1)))!=he||TM&&na(new TM)!=q||xq&&na(xq.resolve())!=kt||gx&&na(new gx)!=Le||CM&&na(new CM)!=$)&&(na=function(m){var v=La(m),T=v==wt?m.constructor:e,N=T?a_(T):"";if(N)switch(N){case Cde:return he;case Ade:return q;case Pde:return kt;case Ide:return Le;case Lde:return $}return v});function Yme(m,v,T){for(var N=-1,V=T.length;++N<V;){var Y=T[N],J=Y.size;switch(Y.type){case"drop":m+=J;break;case"dropRight":v-=J;break;case"take":v=ra(v,m+J);break;case"takeRight":m=Xi(m,v-J);break}}return{start:m,end:v}}function jme(m){var v=m.match(Et);return v?v[1].split(xt):[]}function xpt(m,v,T){v=vm(v,m);for(var N=-1,V=v.length,Y=!1;++N<V;){var J=_h(v[N]);if(!(Y=m!=null&&T(m,J)))break;m=m[J]}return Y||++N!=V?Y:(V=m==null?0:m.length,!!V&&SI(V)&&cp(J,V)&&($e(m)||s_(m)))}function Xme(m){var v=m.length,T=new m.constructor(v);return v&&typeof m[0]=="string"&&un.call(m,"index")&&(T.index=m.index,T.input=m.input),T}function bpt(m){return typeof m.constructor=="function"&&!OM(m)?yx(K6(m)):{}}function $me(m,v,T){var N=m.constructor;switch(v){case $t:return Fq(m);case Kt:case _t:return new N(+m);case he:return kme(m,T);case Tt:case be:case nt:case Ct:case Wt:case fe:case at:case se:case Qt:return npt(m,T);case q:return new N;case pt:case ar:return new N(m);case ee:return Rme(m);case Le:return new N;case fr:return Nme(m)}}function Kme(m,v){var T=v.length;if(!T)return m;var N=T-1;return v[N]=(T>1?"& ":"")+v[N],v=v.join(T>2?", ":" "),m.replace(gt,`{
/* [wrapped with `+v+`] */
`)}function Zme(m){return $e(m)||s_(m)||!!(Tft&&m&&m[Tft])}function cp(m,v){var T=typeof m;return v=v==null?U:v,!!v&&(T=="number"||T!="symbol"&&np.test(m))&&m>-1&&m%1==0&&m<v}function ka(m,v,T){if(!ei(T))return!1;var N=typeof v;return(N=="number"?ds(T)&&cp(v,T.length):N=="string"&&v in T)?ru(T[v],m):!1}function Yq(m,v){if($e(m))return!1;var T=typeof m;return T=="number"||T=="symbol"||T=="boolean"||m==null||js(m)?!0:cm.test(m)||!lx.test(m)||v!=null&&m in vn(v)}function Jme(m){var v=typeof m;return v=="string"||v=="number"||v=="symbol"||v=="boolean"?m!=="__proto__":m===null}function jq(m){var v=mI(m),T=G[v];if(typeof T!="function"||!(v in gr.prototype))return!1;if(m===T)return!0;var N=qq(T);return!!N&&m===N[0]}function Qme(m){return!!wft&&wft in m}var tge=W6?up:uG;function OM(m){var v=m&&m.constructor,T=typeof v=="function"&&v.prototype||mx;return m===T}function wpt(m){return m===m&&!ei(m)}function Spt(m,v){return function(T){return T==null?!1:T[m]===v&&(v!==e||m in vn(T))}}function ege(m){var v=bI(m,function(N){return T.size===s&&T.clear(),N}),T=v.cache;return v}function rge(m,v){var T=m[1],N=v[1],V=T|N,Y=V<(d|g|C),J=N==C&&T==y||N==C&&T==P&&m[7].length<=v[8]||N==(C|P)&&v[7].length<=v[8]&&T==y;if(!(Y||J))return m;N&d&&(m[2]=v[2],V|=T&d?0:_);var it=v[3];if(it){var ft=m[3];m[3]=ft?opt(ft,it,v[4]):it,m[4]=ft?dm(m[3],l):v[4]}return it=v[5],it&&(ft=m[5],m[5]=ft?apt(ft,it,v[6]):it,m[6]=ft?dm(m[5],l):v[6]),it=v[7],it&&(m[7]=it),N&C&&(m[8]=m[8]==null?v[8]:ra(m[8],v[8])),m[9]==null&&(m[9]=v[9]),m[0]=v[0],m[1]=V,m}function nge(m){var v=[];if(m!=null)for(var T in vn(m))v.push(T);return v}function ige(m){return j6.call(m)}function Mpt(m,v,T){return v=Xi(v===e?m.length-1:v,0),function(){for(var N=arguments,V=-1,Y=Xi(N.length-v,0),J=vt(Y);++V<Y;)J[V]=N[v+V];V=-1;for(var it=vt(v+1);++V<v;)it[V]=N[V];return it[v]=T(J),Gs(m,this,it)}}function Ept(m,v){return v.length<2?m:i_(m,jl(v,0,-1))}function oge(m,v){for(var T=m.length,N=ra(v.length,T),V=ps(m);N--;){var Y=v[N];m[N]=cp(Y,T)?V[Y]:e}return m}function Xq(m,v){if(!(v==="constructor"&&typeof m[v]=="function")&&v!="__proto__")return m[v]}var Tpt=Apt($ft),zM=xde||function(m,v){return fo.setTimeout(m,v)},$q=Apt(Ame);function Cpt(m,v,T){var N=v+"";return $q(m,Kme(N,age(jme(N),T)))}function Apt(m){var v=0,T=0;return function(){var N=Mde(),V=I-(N-T);if(T=N,V>0){if(++v>=B)return arguments[0]}else v=0;return m.apply(e,arguments)}}function _I(m,v){var T=-1,N=m.length,V=N-1;for(v=v===e?N:v;++T<v;){var Y=Lq(T,V),J=m[Y];m[Y]=m[T],m[T]=J}return m.length=v,m}var Ppt=ege(function(m){var v=[];return m.charCodeAt(0)===46&&v.push(""),m.replace(J0,function(T,N,V,Y){v.push(V?Y.replace(Ue,"$1"):N||T)}),v});function _h(m){if(typeof m=="string"||js(m))return m;var v=m+"";return v=="0"&&1/m==-z?"-0":v}function a_(m){if(m!=null){try{return Y6.call(m)}catch(v){}try{return m+""}catch(v){}}return""}function age(m,v){return ql(St,function(T){var N="_."+T[0];v&T[1]&&!V6(m,N)&&m.push(N)}),m.sort()}function Ipt(m){if(m instanceof gr)return m.clone();var v=new Wl(m.__wrapped__,m.__chain__);return v.__actions__=ps(m.__actions__),v.__index__=m.__index__,v.__values__=m.__values__,v}function sge(m,v,T){(T?ka(m,v,T):v===e)?v=1:v=Xi(Qe(v),0);var N=m==null?0:m.length;if(!N||v<1)return[];for(var V=0,Y=0,J=vt(Q6(N/v));V<N;)J[Y++]=jl(m,V,V+=v);return J}function lge(m){for(var v=-1,T=m==null?0:m.length,N=0,V=[];++v<T;){var Y=m[v];Y&&(V[N++]=Y)}return V}function cge(){var m=arguments.length;if(!m)return[];for(var v=vt(m-1),T=arguments[0],N=m;N--;)v[N-1]=arguments[N];return pm($e(T)?ps(T):[T],Ro(v,1))}var uge=nr(function(m,v){return xi(m)?LM(m,Ro(v,1,xi,!0)):[]}),hge=nr(function(m,v){var T=Xl(v);return xi(T)&&(T=e),xi(m)?LM(m,Ro(v,1,xi,!0),ke(T,2)):[]}),fge=nr(function(m,v){var T=Xl(v);return xi(T)&&(T=e),xi(m)?LM(m,Ro(v,1,xi,!0),e,T):[]});function pge(m,v,T){var N=m==null?0:m.length;return N?(v=T||v===e?1:Qe(v),jl(m,v<0?0:v,N)):[]}function dge(m,v,T){var N=m==null?0:m.length;return N?(v=T||v===e?1:Qe(v),v=N-v,jl(m,0,v<0?0:v)):[]}function mge(m,v){return m&&m.length?cI(m,ke(v,3),!0,!0):[]}function gge(m,v){return m&&m.length?cI(m,ke(v,3),!0):[]}function _ge(m,v,T,N){var V=m==null?0:m.length;return V?(T&&typeof T!="number"&&ka(m,v,T)&&(T=0,N=V),cme(m,v,T,N)):[]}function Lpt(m,v,T){var N=m==null?0:m.length;if(!N)return-1;var V=T==null?0:Qe(T);return V<0&&(V=Xi(N+V,0)),U6(m,ke(v,3),V)}function kpt(m,v,T){var N=m==null?0:m.length;if(!N)return-1;var V=N-1;return T!==e&&(V=Qe(T),V=T<0?Xi(N+V,0):ra(V,N-1)),U6(m,ke(v,3),V,!0)}function Rpt(m){var v=m==null?0:m.length;return v?Ro(m,1):[]}function yge(m){var v=m==null?0:m.length;return v?Ro(m,z):[]}function vge(m,v){var T=m==null?0:m.length;return T?(v=v===e?1:Qe(v),Ro(m,v)):[]}function xge(m){for(var v=-1,T=m==null?0:m.length,N={};++v<T;){var V=m[v];N[V[0]]=V[1]}return N}function Npt(m){return m&&m.length?m[0]:e}function bge(m,v,T){var N=m==null?0:m.length;if(!N)return-1;var V=T==null?0:Qe(T);return V<0&&(V=Xi(N+V,0)),fx(m,v,V)}function wge(m){var v=m==null?0:m.length;return v?jl(m,0,-1):[]}var Sge=nr(function(m){var v=$n(m,Oq);return v.length&&v[0]===m[0]?Tq(v):[]}),Mge=nr(function(m){var v=Xl(m),T=$n(m,Oq);return v===Xl(T)?v=e:T.pop(),T.length&&T[0]===m[0]?Tq(T,ke(v,2)):[]}),Ege=nr(function(m){var v=Xl(m),T=$n(m,Oq);return v=typeof v=="function"?v:e,v&&T.pop(),T.length&&T[0]===m[0]?Tq(T,e,v):[]});function Tge(m,v){return m==null?"":wde.call(m,v)}function Xl(m){var v=m==null?0:m.length;return v?m[v-1]:e}function Cge(m,v,T){var N=m==null?0:m.length;if(!N)return-1;var V=N;return T!==e&&(V=Qe(T),V=V<0?Xi(N+V,0):ra(V,N-1)),v===v?ade(m,v,V):U6(m,dft,V,!0)}function Age(m,v){return m&&m.length?Wft(m,Qe(v)):e}var Pge=nr(Dpt);function Dpt(m,v){return m&&m.length&&v&&v.length?Iq(m,v):m}function Ige(m,v,T){return m&&m.length&&v&&v.length?Iq(m,v,ke(T,2)):m}function Lge(m,v,T){return m&&m.length&&v&&v.length?Iq(m,v,e,T):m}var kge=lp(function(m,v){var T=m==null?0:m.length,N=wq(m,v);return Xft(m,$n(v,function(V){return cp(V,T)?+V:V}).sort(ipt)),N});function Rge(m,v){var T=[];if(!(m&&m.length))return T;var N=-1,V=[],Y=m.length;for(v=ke(v,3);++N<Y;){var J=m[N];v(J,N,m)&&(T.push(J),V.push(N))}return Xft(m,V),T}function Kq(m){return m==null?m:Tde.call(m)}function Nge(m,v,T){var N=m==null?0:m.length;return N?(T&&typeof T!="number"&&ka(m,v,T)?(v=0,T=N):(v=v==null?0:Qe(v),T=T===e?N:Qe(T)),jl(m,v,T)):[]}function Dge(m,v){return lI(m,v)}function Oge(m,v,T){return Rq(m,v,ke(T,2))}function zge(m,v){var T=m==null?0:m.length;if(T){var N=lI(m,v);if(N<T&&ru(m[N],v))return N}return-1}function Fge(m,v){return lI(m,v,!0)}function Bge(m,v,T){return Rq(m,v,ke(T,2),!0)}function Hge(m,v){var T=m==null?0:m.length;if(T){var N=lI(m,v,!0)-1;if(ru(m[N],v))return N}return-1}function Vge(m){return m&&m.length?Kft(m):[]}function Uge(m,v){return m&&m.length?Kft(m,ke(v,2)):[]}function qge(m){var v=m==null?0:m.length;return v?jl(m,1,v):[]}function Gge(m,v,T){return m&&m.length?(v=T||v===e?1:Qe(v),jl(m,0,v<0?0:v)):[]}function Wge(m,v,T){var N=m==null?0:m.length;return N?(v=T||v===e?1:Qe(v),v=N-v,jl(m,v<0?0:v,N)):[]}function Yge(m,v){return m&&m.length?cI(m,ke(v,3),!1,!0):[]}function jge(m,v){return m&&m.length?cI(m,ke(v,3)):[]}var Xge=nr(function(m){return ym(Ro(m,1,xi,!0))}),$ge=nr(function(m){var v=Xl(m);return xi(v)&&(v=e),ym(Ro(m,1,xi,!0),ke(v,2))}),Kge=nr(function(m){var v=Xl(m);return v=typeof v=="function"?v:e,ym(Ro(m,1,xi,!0),e,v)});function Zge(m){return m&&m.length?ym(m):[]}function Jge(m,v){return m&&m.length?ym(m,ke(v,2)):[]}function Qge(m,v){return v=typeof v=="function"?v:e,m&&m.length?ym(m,e,v):[]}function Zq(m){if(!(m&&m.length))return[];var v=0;return m=fm(m,function(T){if(xi(T))return v=Xi(T.length,v),!0}),dq(v,function(T){return $n(m,hq(T))})}function Opt(m,v){if(!(m&&m.length))return[];var T=Zq(m);return v==null?T:$n(T,function(N){return Gs(v,e,N)})}var t0e=nr(function(m,v){return xi(m)?LM(m,v):[]}),e0e=nr(function(m){return Dq(fm(m,xi))}),r0e=nr(function(m){var v=Xl(m);return xi(v)&&(v=e),Dq(fm(m,xi),ke(v,2))}),n0e=nr(function(m){var v=Xl(m);return v=typeof v=="function"?v:e,Dq(fm(m,xi),e,v)}),i0e=nr(Zq);function o0e(m,v){return tpt(m||[],v||[],IM)}function a0e(m,v){return tpt(m||[],v||[],NM)}var s0e=nr(function(m){var v=m.length,T=v>1?m[v-1]:e;return T=typeof T=="function"?(m.pop(),T):e,Opt(m,T)});function zpt(m){var v=G(m);return v.__chain__=!0,v}function l0e(m,v){return v(m),m}function yI(m,v){return v(m)}var c0e=lp(function(m){var v=m.length,T=v?m[0]:0,N=this.__wrapped__,V=function(Y){return wq(Y,m)};return v>1||this.__actions__.length||!(N instanceof gr)||!cp(T)?this.thru(V):(N=N.slice(T,+T+(v?1:0)),N.__actions__.push({func:yI,args:[V],thisArg:e}),new Wl(N,this.__chain__).thru(function(Y){return v&&!Y.length&&Y.push(e),Y}))});function u0e(){return zpt(this)}function h0e(){return new Wl(this.value(),this.__chain__)}function f0e(){this.__values__===e&&(this.__values__=Zpt(this.value()));var m=this.__index__>=this.__values__.length,v=m?e:this.__values__[this.__index__++];return{done:m,value:v}}function p0e(){return this}function d0e(m){for(var v,T=this;T instanceof nI;){var N=Ipt(T);N.__index__=0,N.__values__=e,v?V.__wrapped__=N:v=N;var V=N;T=T.__wrapped__}return V.__wrapped__=m,v}function m0e(){var m=this.__wrapped__;if(m instanceof gr){var v=m;return this.__actions__.length&&(v=new gr(this)),v=v.reverse(),v.__actions__.push({func:yI,args:[Kq],thisArg:e}),new Wl(v,this.__chain__)}return this.thru(Kq)}function g0e(){return Qft(this.__wrapped__,this.__actions__)}var _0e=uI(function(m,v,T){un.call(m,T)?++m[T]:ap(m,T,1)});function y0e(m,v,T){var N=$e(m)?fft:lme;return T&&ka(m,v,T)&&(v=e),N(m,ke(v,3))}function v0e(m,v){var T=$e(m)?fm:Oft;return T(m,ke(v,3))}var x0e=upt(Lpt),b0e=upt(kpt);function w0e(m,v){return Ro(vI(m,v),1)}function S0e(m,v){return Ro(vI(m,v),z)}function M0e(m,v,T){return T=T===e?1:Qe(T),Ro(vI(m,v),T)}function Fpt(m,v){var T=$e(m)?ql:_m;return T(m,ke(v,3))}function Bpt(m,v){var T=$e(m)?qpe:Dft;return T(m,ke(v,3))}var E0e=uI(function(m,v,T){un.call(m,T)?m[T].push(v):ap(m,T,[v])});function T0e(m,v,T,N){m=ds(m)?m:Sx(m),T=T&&!N?Qe(T):0;var V=m.length;return T<0&&(T=Xi(V+T,0)),MI(m)?T<=V&&m.indexOf(v,T)>-1:!!V&&fx(m,v,T)>-1}var C0e=nr(function(m,v,T){var N=-1,V=typeof v=="function",Y=ds(m)?vt(m.length):[];return _m(m,function(J){Y[++N]=V?Gs(v,J,T):kM(J,v,T)}),Y}),A0e=uI(function(m,v,T){ap(m,T,v)});function vI(m,v){var T=$e(m)?$n:Uft;return T(m,ke(v,3))}function P0e(m,v,T,N){return m==null?[]:($e(v)||(v=v==null?[]:[v]),T=N?e:T,$e(T)||(T=T==null?[]:[T]),Yft(m,v,T))}var I0e=uI(function(m,v,T){m[T?0:1].push(v)},function(){return[[],[]]});function L0e(m,v,T){var N=$e(m)?cq:gft,V=arguments.length<3;return N(m,ke(v,4),T,V,_m)}function k0e(m,v,T){var N=$e(m)?Gpe:gft,V=arguments.length<3;return N(m,ke(v,4),T,V,Dft)}function R0e(m,v){var T=$e(m)?fm:Oft;return T(m,wI(ke(v,3)))}function N0e(m){var v=$e(m)?Lft:Tme;return v(m)}function D0e(m,v,T){(T?ka(m,v,T):v===e)?v=1:v=Qe(v);var N=$e(m)?nme:Cme;return N(m,v)}function O0e(m){var v=$e(m)?ime:Pme;return v(m)}function z0e(m){if(m==null)return 0;if(ds(m))return MI(m)?dx(m):m.length;var v=na(m);return v==q||v==Le?m.size:Aq(m).length}function F0e(m,v,T){var N=$e(m)?uq:Ime;return T&&ka(m,v,T)&&(v=e),N(m,ke(v,3))}var B0e=nr(function(m,v){if(m==null)return[];var T=v.length;return T>1&&ka(m,v[0],v[1])?v=[]:T>2&&ka(v[0],v[1],v[2])&&(v=[v[0]]),Yft(m,Ro(v,1),[])}),xI=vde||function(){return fo.Date.now()};function H0e(m,v){if(typeof v!="function")throw new Gl(i);return m=Qe(m),function(){if(--m<1)return v.apply(this,arguments)}}function Hpt(m,v,T){return v=T?e:v,v=m&&v==null?m.length:v,sp(m,C,e,e,e,e,v)}function Vpt(m,v){var T;if(typeof v!="function")throw new Gl(i);return m=Qe(m),function(){return--m>0&&(T=v.apply(this,arguments)),m<=1&&(v=e),T}}var Jq=nr(function(m,v,T){var N=d;if(T.length){var V=dm(T,bx(Jq));N|=b}return sp(m,N,v,T,V)}),Upt=nr(function(m,v,T){var N=d|g;if(T.length){var V=dm(T,bx(Upt));N|=b}return sp(v,N,m,T,V)});function qpt(m,v,T){v=T?e:v;var N=sp(m,y,e,e,e,e,e,v);return N.placeholder=qpt.placeholder,N}function Gpt(m,v,T){v=T?e:v;var N=sp(m,x,e,e,e,e,e,v);return N.placeholder=Gpt.placeholder,N}function Wpt(m,v,T){var N,V,Y,J,it,ft,Dt=0,Ot=!1,Vt=!1,oe=!0;if(typeof m!="function")throw new Gl(i);v=$l(v)||0,ei(T)&&(Ot=!!T.leading,Vt="maxWait"in T,Y=Vt?Xi($l(T.maxWait)||0,v):Y,oe="trailing"in T?!!T.trailing:oe);function Te(bi){var nu=N,fp=V;return N=V=e,Dt=bi,J=m.apply(fp,nu),J}function Ne(bi){return Dt=bi,it=zM(pr,v),Ot?Te(bi):J}function er(bi){var nu=bi-ft,fp=bi-Dt,udt=v-nu;return Vt?ra(udt,Y-fp):udt}function De(bi){var nu=bi-ft,fp=bi-Dt;return ft===e||nu>=v||nu<0||Vt&&fp>=Y}function pr(){var bi=xI();if(De(bi))return yr(bi);it=zM(pr,er(bi))}function yr(bi){return it=e,oe&&N?Te(bi):(N=V=e,J)}function Xs(){it!==e&&ept(it),Dt=0,N=ft=V=it=e}function Ra(){return it===e?J:yr(xI())}function $s(){var bi=xI(),nu=De(bi);if(N=arguments,V=this,ft=bi,nu){if(it===e)return Ne(ft);if(Vt)return ept(it),it=zM(pr,v),Te(ft)}return it===e&&(it=zM(pr,v)),J}return $s.cancel=Xs,$s.flush=Ra,$s}var V0e=nr(function(m,v){return Nft(m,1,v)}),U0e=nr(function(m,v,T){return Nft(m,$l(v)||0,T)});function q0e(m){return sp(m,k)}function bI(m,v){if(typeof m!="function"||v!=null&&typeof v!="function")throw new Gl(i);var T=function(){var N=arguments,V=v?v.apply(this,N):N[0],Y=T.cache;if(Y.has(V))return Y.get(V);var J=m.apply(this,N);return T.cache=Y.set(V,J)||Y,J};return T.cache=new(bI.Cache||op),T}bI.Cache=op;function wI(m){if(typeof m!="function")throw new Gl(i);return function(){var v=arguments;switch(v.length){case 0:return!m.call(this);case 1:return!m.call(this,v[0]);case 2:return!m.call(this,v[0],v[1]);case 3:return!m.call(this,v[0],v[1],v[2])}return!m.apply(this,v)}}function G0e(m){return Vpt(2,m)}var W0e=Lme(function(m,v){v=v.length==1&&$e(v[0])?$n(v[0],Ws(ke())):$n(Ro(v,1),Ws(ke()));var T=v.length;return nr(function(N){for(var V=-1,Y=ra(N.length,T);++V<Y;)N[V]=v[V].call(this,N[V]);return Gs(m,this,N)})}),Qq=nr(function(m,v){var T=dm(v,bx(Qq));return sp(m,b,e,v,T)}),Ypt=nr(function(m,v){var T=dm(v,bx(Ypt));return sp(m,S,e,v,T)}),Y0e=lp(function(m,v){return sp(m,P,e,e,e,v)});function j0e(m,v){if(typeof m!="function")throw new Gl(i);return v=v===e?v:Qe(v),nr(m,v)}function X0e(m,v){if(typeof m!="function")throw new Gl(i);return v=v==null?0:Xi(Qe(v),0),nr(function(T){var N=T[v],V=xm(T,0,v);return N&&pm(V,N),Gs(m,this,V)})}function $0e(m,v,T){var N=!0,V=!0;if(typeof m!="function")throw new Gl(i);return ei(T)&&(N="leading"in T?!!T.leading:N,V="trailing"in T?!!T.trailing:V),Wpt(m,v,{leading:N,maxWait:v,trailing:V})}function K0e(m){return Hpt(m,1)}function Z0e(m,v){return Qq(zq(v),m)}function J0e(){if(!arguments.length)return[];var m=arguments[0];return $e(m)?m:[m]}function Q0e(m){return Yl(m,h)}function t_e(m,v){return v=typeof v=="function"?v:e,Yl(m,h,v)}function e_e(m){return Yl(m,c|h)}function r_e(m,v){return v=typeof v=="function"?v:e,Yl(m,c|h,v)}function n_e(m,v){return v==null||Rft(m,v,po(v))}function ru(m,v){return m===v||m!==m&&v!==v}var i_e=dI(Eq),o_e=dI(function(m,v){return m>=v}),s_=Bft(function(){return arguments}())?Bft:function(m){return si(m)&&un.call(m,"callee")&&!Eft.call(m,"callee")},$e=vt.isArray,a_e=aft?Ws(aft):dme;function ds(m){return m!=null&&SI(m.length)&&!up(m)}function xi(m){return si(m)&&ds(m)}function s_e(m){return m===!0||m===!1||si(m)&&La(m)==Kt}var bm=bde||uG,l_e=sft?Ws(sft):mme;function c_e(m){return si(m)&&m.nodeType===1&&!FM(m)}function u_e(m){if(m==null)return!0;if(ds(m)&&($e(m)||typeof m=="string"||typeof m.splice=="function"||bm(m)||wx(m)||s_(m)))return!m.length;var v=na(m);if(v==q||v==Le)return!m.size;if(OM(m))return!Aq(m).length;for(var T in m)if(un.call(m,T))return!1;return!0}function h_e(m,v){return RM(m,v)}function f_e(m,v,T){T=typeof T=="function"?T:e;var N=T?T(m,v):e;return N===e?RM(m,v,e,T):!!N}function tG(m){if(!si(m))return!1;var v=La(m);return v==X||v==ct||typeof m.message=="string"&&typeof m.name=="string"&&!FM(m)}function p_e(m){return typeof m=="number"&&Cft(m)}function up(m){if(!ei(m))return!1;var v=La(m);return v==et||v==dt||v==lt||v==ie}function jpt(m){return typeof m=="number"&&m==Qe(m)}function SI(m){return typeof m=="number"&&m>-1&&m%1==0&&m<=U}function ei(m){var v=typeof m;return m!=null&&(v=="object"||v=="function")}function si(m){return m!=null&&typeof m=="object"}var Xpt=lft?Ws(lft):_me;function d_e(m,v){return m===v||Cq(m,v,Gq(v))}function m_e(m,v,T){return T=typeof T=="function"?T:e,Cq(m,v,Gq(v),T)}function g_e(m){return $pt(m)&&m!=+m}function __e(m){if(tge(m))throw new We(n);return Hft(m)}function y_e(m){return m===null}function v_e(m){return m==null}function $pt(m){return typeof m=="number"||si(m)&&La(m)==pt}function FM(m){if(!si(m)||La(m)!=wt)return!1;var v=K6(m);if(v===null)return!0;var T=un.call(v,"constructor")&&v.constructor;return typeof T=="function"&&T instanceof T&&Y6.call(T)==mde}var eG=cft?Ws(cft):yme;function x_e(m){return jpt(m)&&m>=-U&&m<=U}var Kpt=uft?Ws(uft):vme;function MI(m){return typeof m=="string"||!$e(m)&&si(m)&&La(m)==ar}function js(m){return typeof m=="symbol"||si(m)&&La(m)==fr}var wx=hft?Ws(hft):xme;function b_e(m){return m===e}function w_e(m){return si(m)&&na(m)==$}function S_e(m){return si(m)&&La(m)==It}var M_e=dI(Pq),E_e=dI(function(m,v){return m<=v});function Zpt(m){if(!m)return[];if(ds(m))return MI(m)?tu(m):ps(m);if(EM&&m[EM])return nde(m[EM]());var v=na(m),T=v==q?gq:v==Le?q6:Sx;return T(m)}function hp(m){if(!m)return m===0?m:0;if(m=$l(m),m===z||m===-z){var v=m<0?-1:1;return v*W}return m===m?m:0}function Qe(m){var v=hp(m),T=v%1;return v===v?T?v-T:v:0}function Jpt(m){return m?n_(Qe(m),0,rt):0}function $l(m){if(typeof m=="number")return m;if(js(m))return Z;if(ei(m)){var v=typeof m.valueOf=="function"?m.valueOf():m;m=ei(v)?v+"":v}if(typeof m!="string")return m===0?m:+m;m=_ft(m);var T=_r.test(m);return T||jn.test(m)?Hpe(m.slice(2),T?2:8):Xr.test(m)?Z:+m}function Qpt(m){return gh(m,ms(m))}function T_e(m){return m?n_(Qe(m),-U,U):m===0?m:0}function on(m){return m==null?"":Ys(m)}var C_e=vx(function(m,v){if(OM(v)||ds(v)){gh(v,po(v),m);return}for(var T in v)un.call(v,T)&&IM(m,T,v[T])}),tdt=vx(function(m,v){gh(v,ms(v),m)}),EI=vx(function(m,v,T,N){gh(v,ms(v),m,N)}),A_e=vx(function(m,v,T,N){gh(v,po(v),m,N)}),P_e=lp(wq);function I_e(m,v){var T=yx(m);return v==null?T:kft(T,v)}var L_e=nr(function(m,v){m=vn(m);var T=-1,N=v.length,V=N>2?v[2]:e;for(V&&ka(v[0],v[1],V)&&(N=1);++T<N;)for(var Y=v[T],J=ms(Y),it=-1,ft=J.length;++it<ft;){var Dt=J[it],Ot=m[Dt];(Ot===e||ru(Ot,mx[Dt])&&!un.call(m,Dt))&&(m[Dt]=Y[Dt])}return m}),k_e=nr(function(m){return m.push(e,_pt),Gs(edt,e,m)});function R_e(m,v){return pft(m,ke(v,3),mh)}function N_e(m,v){return pft(m,ke(v,3),Mq)}function D_e(m,v){return m==null?m:Sq(m,ke(v,3),ms)}function O_e(m,v){return m==null?m:zft(m,ke(v,3),ms)}function z_e(m,v){return m&&mh(m,ke(v,3))}function F_e(m,v){return m&&Mq(m,ke(v,3))}function B_e(m){return m==null?[]:aI(m,po(m))}function H_e(m){return m==null?[]:aI(m,ms(m))}function rG(m,v,T){var N=m==null?e:i_(m,v);return N===e?T:N}function V_e(m,v){return m!=null&&xpt(m,v,ume)}function nG(m,v){return m!=null&&xpt(m,v,hme)}var U_e=fpt(function(m,v,T){v!=null&&typeof v.toString!="function"&&(v=j6.call(v)),m[v]=T},oG(gs)),q_e=fpt(function(m,v,T){v!=null&&typeof v.toString!="function"&&(v=j6.call(v)),un.call(m,v)?m[v].push(T):m[v]=[T]},ke),G_e=nr(kM);function po(m){return ds(m)?Ift(m):Aq(m)}function ms(m){return ds(m)?Ift(m,!0):bme(m)}function W_e(m,v){var T={};return v=ke(v,3),mh(m,function(N,V,Y){ap(T,v(N,V,Y),N)}),T}function Y_e(m,v){var T={};return v=ke(v,3),mh(m,function(N,V,Y){ap(T,V,v(N,V,Y))}),T}var j_e=vx(function(m,v,T){sI(m,v,T)}),edt=vx(function(m,v,T,N){sI(m,v,T,N)}),X_e=lp(function(m,v){var T={};if(m==null)return T;var N=!1;v=$n(v,function(Y){return Y=vm(Y,m),N||(N=Y.length>1),Y}),gh(m,Uq(m),T),N&&(T=Yl(T,c|u|h,Ume));for(var V=v.length;V--;)Nq(T,v[V]);return T});function $_e(m,v){return rdt(m,wI(ke(v)))}var K_e=lp(function(m,v){return m==null?{}:Sme(m,v)});function rdt(m,v){if(m==null)return{};var T=$n(Uq(m),function(N){return[N]});return v=ke(v),jft(m,T,function(N,V){return v(N,V[0])})}function Z_e(m,v,T){v=vm(v,m);var N=-1,V=v.length;for(V||(V=1,m=e);++N<V;){var Y=m==null?e:m[_h(v[N])];Y===e&&(N=V,Y=T),m=up(Y)?Y.call(m):Y}return m}function J_e(m,v,T){return m==null?m:NM(m,v,T)}function Q_e(m,v,T,N){return N=typeof N=="function"?N:e,m==null?m:NM(m,v,T,N)}var ndt=mpt(po),idt=mpt(ms);function tye(m,v,T){var N=$e(m),V=N||bm(m)||wx(m);if(v=ke(v,4),T==null){var Y=m&&m.constructor;V?T=N?new Y:[]:ei(m)?T=up(Y)?yx(K6(m)):{}:T={}}return(V?ql:mh)(m,function(J,it,ft){return v(T,J,it,ft)}),T}function eye(m,v){return m==null?!0:Nq(m,v)}function rye(m,v,T){return m==null?m:Jft(m,v,zq(T))}function nye(m,v,T,N){return N=typeof N=="function"?N:e,m==null?m:Jft(m,v,zq(T),N)}function Sx(m){return m==null?[]:mq(m,po(m))}function iye(m){return m==null?[]:mq(m,ms(m))}function oye(m,v,T){return T===e&&(T=v,v=e),T!==e&&(T=$l(T),T=T===T?T:0),v!==e&&(v=$l(v),v=v===v?v:0),n_($l(m),v,T)}function aye(m,v,T){return v=hp(v),T===e?(T=v,v=0):T=hp(T),m=$l(m),fme(m,v,T)}function sye(m,v,T){if(T&&typeof T!="boolean"&&ka(m,v,T)&&(v=T=e),T===e&&(typeof v=="boolean"?(T=v,v=e):typeof m=="boolean"&&(T=m,m=e)),m===e&&v===e?(m=0,v=1):(m=hp(m),v===e?(v=m,m=0):v=hp(v)),m>v){var N=m;m=v,v=N}if(T||m%1||v%1){var V=Aft();return ra(m+V*(v-m+Bpe("1e-"+((V+"").length-1))),v)}return Lq(m,v)}var lye=xx(function(m,v,T){return v=v.toLowerCase(),m+(T?odt(v):v)});function odt(m){return iG(on(m).toLowerCase())}function adt(m){return m=on(m),m&&m.replace(um,Jpe).replace(Ppe,"")}function cye(m,v,T){m=on(m),v=Ys(v);var N=m.length;T=T===e?N:n_(Qe(T),0,N);var V=T;return T-=v.length,T>=0&&m.slice(T,V)==v}function uye(m){return m=on(m),m&&Ar.test(m)?m.replace(yn,Qpe):m}function hye(m){return m=on(m),m&&cx.test(m)?m.replace(cn,"\\$&"):m}var fye=xx(function(m,v,T){return m+(T?"-":"")+v.toLowerCase()}),pye=xx(function(m,v,T){return m+(T?" ":"")+v.toLowerCase()}),dye=cpt("toLowerCase");function mye(m,v,T){m=on(m),v=Qe(v);var N=v?dx(m):0;if(!v||N>=v)return m;var V=(v-N)/2;return pI(tI(V),T)+m+pI(Q6(V),T)}function gye(m,v,T){m=on(m),v=Qe(v);var N=v?dx(m):0;return v&&N<v?m+pI(v-N,T):m}function _ye(m,v,T){m=on(m),v=Qe(v);var N=v?dx(m):0;return v&&N<v?pI(v-N,T)+m:m}function yye(m,v,T){return T||v==null?v=0:v&&(v=+v),Ede(on(m).replace(rp,""),v||0)}function vye(m,v,T){return(T?ka(m,v,T):v===e)?v=1:v=Qe(v),kq(on(m),v)}function xye(){var m=arguments,v=on(m[0]);return m.length<3?v:v.replace(m[1],m[2])}var bye=xx(function(m,v,T){return m+(T?"_":"")+v.toLowerCase()});function wye(m,v,T){return T&&typeof T!="number"&&ka(m,v,T)&&(v=T=e),T=T===e?rt:T>>>0,T?(m=on(m),m&&(typeof v=="string"||v!=null&&!eG(v))&&(v=Ys(v),!v&&px(m))?xm(tu(m),0,T):m.split(v,T)):[]}var Sye=xx(function(m,v,T){return m+(T?" ":"")+iG(v)});function Mye(m,v,T){return m=on(m),T=T==null?0:n_(Qe(T),0,m.length),v=Ys(v),m.slice(T,T+v.length)==v}function Eye(m,v,T){var N=G.templateSettings;T&&ka(m,v,T)&&(v=e),m=on(m),v=EI({},v,N,gpt);var V=EI({},v.imports,N.imports,gpt),Y=po(V),J=mq(V,Y),it,ft,Dt=0,Ot=v.interpolate||mr,Vt="__p += '",oe=_q((v.escape||mr).source+"|"+Ot.source+"|"+(Ot===Ia?tr:mr).source+"|"+(v.evaluate||mr).source+"|$","g"),Te="//# sourceURL="+(un.call(v,"sourceURL")?(v.sourceURL+"").replace(/\s/g," "):"lodash.templateSources["+ ++Npe+"]")+`
`;m.replace(oe,function(De,pr,yr,Xs,Ra,$s){return yr||(yr=Xs),Vt+=m.slice(Dt,$s).replace(Fl,tde),pr&&(it=!0,Vt+=`' +
__e(`+pr+`) +
'`),Ra&&(ft=!0,Vt+=`';
`+Ra+`;
__p += '`),yr&&(Vt+=`' +
((__t = (`+yr+`)) == null ? '' : __t) +
'`),Dt=$s+De.length,De}),Vt+=`';
`;var Ne=un.call(v,"variable")&&v.variable;if(!Ne)Vt=`with (obj) {
`+Vt+`
}
`;else if(Ve.test(Ne))throw new We(o);Vt=(ft?Vt.replace(Ce,""):Vt).replace(Pt,"$1").replace(Nt,"$1;"),Vt="function("+(Ne||"obj")+`) {
`+(Ne?"":`obj || (obj = {});
`)+"var __t, __p = ''"+(it?", __e = _.escape":"")+(ft?`, __j = Array.prototype.join;
function print() { __p += __j.call(arguments, '') }
`:`;
`)+Vt+`return __p
}`;var er=ldt(function(){return $r(Y,Te+"return "+Vt).apply(e,J)});if(er.source=Vt,tG(er))throw er;return er}function Tye(m){return on(m).toLowerCase()}function Cye(m){return on(m).toUpperCase()}function Aye(m,v,T){if(m=on(m),m&&(T||v===e))return _ft(m);if(!m||!(v=Ys(v)))return m;var N=tu(m),V=tu(v),Y=yft(N,V),J=vft(N,V)+1;return xm(N,Y,J).join("")}function Pye(m,v,T){if(m=on(m),m&&(T||v===e))return m.slice(0,bft(m)+1);if(!m||!(v=Ys(v)))return m;var N=tu(m),V=vft(N,tu(v))+1;return xm(N,0,V).join("")}function Iye(m,v,T){if(m=on(m),m&&(T||v===e))return m.replace(rp,"");if(!m||!(v=Ys(v)))return m;var N=tu(m),V=yft(N,tu(v));return xm(N,V).join("")}function Lye(m,v){var T=O,N=D;if(ei(v)){var V="separator"in v?v.separator:V;T="length"in v?Qe(v.length):T,N="omission"in v?Ys(v.omission):N}m=on(m);var Y=m.length;if(px(m)){var J=tu(m);Y=J.length}if(T>=Y)return m;var it=T-dx(N);if(it<1)return N;var ft=J?xm(J,0,it).join(""):m.slice(0,it);if(V===e)return ft+N;if(J&&(it+=ft.length-it),eG(V)){if(m.slice(it).search(V)){var Dt,Ot=ft;for(V.global||(V=_q(V.source,on(Ke.exec(V))+"g")),V.lastIndex=0;Dt=V.exec(Ot);)var Vt=Dt.index;ft=ft.slice(0,Vt===e?it:Vt)}}else if(m.indexOf(Ys(V),it)!=it){var oe=ft.lastIndexOf(V);oe>-1&&(ft=ft.slice(0,oe))}return ft+N}function kye(m){return m=on(m),m&&Wi.test(m)?m.replace(ze,sde):m}var Rye=xx(function(m,v,T){return m+(T?" ":"")+v.toUpperCase()}),iG=cpt("toUpperCase");function sdt(m,v,T){return m=on(m),v=T?e:v,v===e?rde(m)?ude(m):jpe(m):m.match(v)||[]}var ldt=nr(function(m,v){try{return Gs(m,e,v)}catch(T){return tG(T)?T:new We(T)}}),Nye=lp(function(m,v){return ql(v,function(T){T=_h(T),ap(m,T,Jq(m[T],m))}),m});function Dye(m){var v=m==null?0:m.length,T=ke();return m=v?$n(m,function(N){if(typeof N[1]!="function")throw new Gl(i);return[T(N[0]),N[1]]}):[],nr(function(N){for(var V=-1;++V<v;){var Y=m[V];if(Gs(Y[0],this,N))return Gs(Y[1],this,N)}})}function Oye(m){return sme(Yl(m,c))}function oG(m){return function(){return m}}function zye(m,v){return m==null||m!==m?v:m}var Fye=hpt(),Bye=hpt(!0);function gs(m){return m}function aG(m){return Vft(typeof m=="function"?m:Yl(m,c))}function Hye(m){return qft(Yl(m,c))}function Vye(m,v){return Gft(m,Yl(v,c))}var Uye=nr(function(m,v){return function(T){return kM(T,m,v)}}),qye=nr(function(m,v){return function(T){return kM(m,T,v)}});function sG(m,v,T){var N=po(v),V=aI(v,N);T==null&&!(ei(v)&&(V.length||!N.length))&&(T=v,v=m,m=this,V=aI(v,po(v)));var Y=!(ei(T)&&"chain"in T)||!!T.chain,J=up(m);return ql(V,function(it){var ft=v[it];m[it]=ft,J&&(m.prototype[it]=function(){var Dt=this.__chain__;if(Y||Dt){var Ot=m(this.__wrapped__),Vt=Ot.__actions__=ps(this.__actions__);return Vt.push({func:ft,args:arguments,thisArg:m}),Ot.__chain__=Dt,Ot}return ft.apply(m,pm([this.value()],arguments))})}),m}function Gye(){return fo._===this&&(fo._=gde),this}function lG(){}function Wye(m){return m=Qe(m),nr(function(v){return Wft(v,m)})}var Yye=Bq($n),jye=Bq(fft),Xye=Bq(uq);function cdt(m){return Yq(m)?hq(_h(m)):Mme(m)}function $ye(m){return function(v){return m==null?e:i_(m,v)}}var Kye=ppt(),Zye=ppt(!0);function cG(){return[]}function uG(){return!1}function Jye(){return{}}function Qye(){return""}function tve(){return!0}function eve(m,v){if(m=Qe(m),m<1||m>U)return[];var T=rt,N=ra(m,rt);v=ke(v),m-=rt;for(var V=dq(N,v);++T<m;)v(T);return V}function rve(m){return $e(m)?$n(m,_h):js(m)?[m]:ps(Ppt(on(m)))}function nve(m){var v=++dde;return on(m)+v}var ive=fI(function(m,v){return m+v},0),ove=Hq("ceil"),ave=fI(function(m,v){return m/v},1),sve=Hq("floor");function lve(m){return m&&m.length?oI(m,gs,Eq):e}function cve(m,v){return m&&m.length?oI(m,ke(v,2),Eq):e}function uve(m){return mft(m,gs)}function hve(m,v){return mft(m,ke(v,2))}function fve(m){return m&&m.length?oI(m,gs,Pq):e}function pve(m,v){return m&&m.length?oI(m,ke(v,2),Pq):e}var dve=fI(function(m,v){return m*v},1),mve=Hq("round"),gve=fI(function(m,v){return m-v},0);function _ve(m){return m&&m.length?pq(m,gs):0}function yve(m,v){return m&&m.length?pq(m,ke(v,2)):0}return G.after=H0e,G.ary=Hpt,G.assign=C_e,G.assignIn=tdt,G.assignInWith=EI,G.assignWith=A_e,G.at=P_e,G.before=Vpt,G.bind=Jq,G.bindAll=Nye,G.bindKey=Upt,G.castArray=J0e,G.chain=zpt,G.chunk=sge,G.compact=lge,G.concat=cge,G.cond=Dye,G.conforms=Oye,G.constant=oG,G.countBy=_0e,G.create=I_e,G.curry=qpt,G.curryRight=Gpt,G.debounce=Wpt,G.defaults=L_e,G.defaultsDeep=k_e,G.defer=V0e,G.delay=U0e,G.difference=uge,G.differenceBy=hge,G.differenceWith=fge,G.drop=pge,G.dropRight=dge,G.dropRightWhile=mge,G.dropWhile=gge,G.fill=_ge,G.filter=v0e,G.flatMap=w0e,G.flatMapDeep=S0e,G.flatMapDepth=M0e,G.flatten=Rpt,G.flattenDeep=yge,G.flattenDepth=vge,G.flip=q0e,G.flow=Fye,G.flowRight=Bye,G.fromPairs=xge,G.functions=B_e,G.functionsIn=H_e,G.groupBy=E0e,G.initial=wge,G.intersection=Sge,G.intersectionBy=Mge,G.intersectionWith=Ege,G.invert=U_e,G.invertBy=q_e,G.invokeMap=C0e,G.iteratee=aG,G.keyBy=A0e,G.keys=po,G.keysIn=ms,G.map=vI,G.mapKeys=W_e,G.mapValues=Y_e,G.matches=Hye,G.matchesProperty=Vye,G.memoize=bI,G.merge=j_e,G.mergeWith=edt,G.method=Uye,G.methodOf=qye,G.mixin=sG,G.negate=wI,G.nthArg=Wye,G.omit=X_e,G.omitBy=$_e,G.once=G0e,G.orderBy=P0e,G.over=Yye,G.overArgs=W0e,G.overEvery=jye,G.overSome=Xye,G.partial=Qq,G.partialRight=Ypt,G.partition=I0e,G.pick=K_e,G.pickBy=rdt,G.property=cdt,G.propertyOf=$ye,G.pull=Pge,G.pullAll=Dpt,G.pullAllBy=Ige,G.pullAllWith=Lge,G.pullAt=kge,G.range=Kye,G.rangeRight=Zye,G.rearg=Y0e,G.reject=R0e,G.remove=Rge,G.rest=j0e,G.reverse=Kq,G.sampleSize=D0e,G.set=J_e,G.setWith=Q_e,G.shuffle=O0e,G.slice=Nge,G.sortBy=B0e,G.sortedUniq=Vge,G.sortedUniqBy=Uge,G.split=wye,G.spread=X0e,G.tail=qge,G.take=Gge,G.takeRight=Wge,G.takeRightWhile=Yge,G.takeWhile=jge,G.tap=l0e,G.throttle=$0e,G.thru=yI,G.toArray=Zpt,G.toPairs=ndt,G.toPairsIn=idt,G.toPath=rve,G.toPlainObject=Qpt,G.transform=tye,G.unary=K0e,G.union=Xge,G.unionBy=$ge,G.unionWith=Kge,G.uniq=Zge,G.uniqBy=Jge,G.uniqWith=Qge,G.unset=eye,G.unzip=Zq,G.unzipWith=Opt,G.update=rye,G.updateWith=nye,G.values=Sx,G.valuesIn=iye,G.without=t0e,G.words=sdt,G.wrap=Z0e,G.xor=e0e,G.xorBy=r0e,G.xorWith=n0e,G.zip=i0e,G.zipObject=o0e,G.zipObjectDeep=a0e,G.zipWith=s0e,G.entries=ndt,G.entriesIn=idt,G.extend=tdt,G.extendWith=EI,sG(G,G),G.add=ive,G.attempt=ldt,G.camelCase=lye,G.capitalize=odt,G.ceil=ove,G.clamp=oye,G.clone=Q0e,G.cloneDeep=e_e,G.cloneDeepWith=r_e,G.cloneWith=t_e,G.conformsTo=n_e,G.deburr=adt,G.defaultTo=zye,G.divide=ave,G.endsWith=cye,G.eq=ru,G.escape=uye,G.escapeRegExp=hye,G.every=y0e,G.find=x0e,G.findIndex=Lpt,G.findKey=R_e,G.findLast=b0e,G.findLastIndex=kpt,G.findLastKey=N_e,G.floor=sve,G.forEach=Fpt,G.forEachRight=Bpt,G.forIn=D_e,G.forInRight=O_e,G.forOwn=z_e,G.forOwnRight=F_e,G.get=rG,G.gt=i_e,G.gte=o_e,G.has=V_e,G.hasIn=nG,G.head=Npt,G.identity=gs,G.includes=T0e,G.indexOf=bge,G.inRange=aye,G.invoke=G_e,G.isArguments=s_,G.isArray=$e,G.isArrayBuffer=a_e,G.isArrayLike=ds,G.isArrayLikeObject=xi,G.isBoolean=s_e,G.isBuffer=bm,G.isDate=l_e,G.isElement=c_e,G.isEmpty=u_e,G.isEqual=h_e,G.isEqualWith=f_e,G.isError=tG,G.isFinite=p_e,G.isFunction=up,G.isInteger=jpt,G.isLength=SI,G.isMap=Xpt,G.isMatch=d_e,G.isMatchWith=m_e,G.isNaN=g_e,G.isNative=__e,G.isNil=v_e,G.isNull=y_e,G.isNumber=$pt,G.isObject=ei,G.isObjectLike=si,G.isPlainObject=FM,G.isRegExp=eG,G.isSafeInteger=x_e,G.isSet=Kpt,G.isString=MI,G.isSymbol=js,G.isTypedArray=wx,G.isUndefined=b_e,G.isWeakMap=w_e,G.isWeakSet=S_e,G.join=Tge,G.kebabCase=fye,G.last=Xl,G.lastIndexOf=Cge,G.lowerCase=pye,G.lowerFirst=dye,G.lt=M_e,G.lte=E_e,G.max=lve,G.maxBy=cve,G.mean=uve,G.meanBy=hve,G.min=fve,G.minBy=pve,G.stubArray=cG,G.stubFalse=uG,G.stubObject=Jye,G.stubString=Qye,G.stubTrue=tve,G.multiply=dve,G.nth=Age,G.noConflict=Gye,G.noop=lG,G.now=xI,G.pad=mye,G.padEnd=gye,G.padStart=_ye,G.parseInt=yye,G.random=sye,G.reduce=L0e,G.reduceRight=k0e,G.repeat=vye,G.replace=xye,G.result=Z_e,G.round=mve,G.runInContext=ut,G.sample=N0e,G.size=z0e,G.snakeCase=bye,G.some=F0e,G.sortedIndex=Dge,G.sortedIndexBy=Oge,G.sortedIndexOf=zge,G.sortedLastIndex=Fge,G.sortedLastIndexBy=Bge,G.sortedLastIndexOf=Hge,G.startCase=Sye,G.startsWith=Mye,G.subtract=gve,G.sum=_ve,G.sumBy=yve,G.template=Eye,G.times=eve,G.toFinite=hp,G.toInteger=Qe,G.toLength=Jpt,G.toLower=Tye,G.toNumber=$l,G.toSafeInteger=T_e,G.toString=on,G.toUpper=Cye,G.trim=Aye,G.trimEnd=Pye,G.trimStart=Iye,G.truncate=Lye,G.unescape=kye,G.uniqueId=nve,G.upperCase=Rye,G.upperFirst=iG,G.each=Fpt,G.eachRight=Bpt,G.first=Npt,sG(G,function(){var m={};return mh(G,function(v,T){un.call(G.prototype,T)||(m[T]=v)}),m}(),{chain:!1}),G.VERSION=t,ql(["bind","bindKey","curry","curryRight","partial","partialRight"],function(m){G[m].placeholder=G}),ql(["drop","take"],function(m,v){gr.prototype[m]=function(T){T=T===e?1:Xi(Qe(T),0);var N=this.__filtered__&&!v?new gr(this):this.clone();return N.__filtered__?N.__takeCount__=ra(T,N.__takeCount__):N.__views__.push({size:ra(T,rt),type:m+(N.__dir__<0?"Right":"")}),N},gr.prototype[m+"Right"]=function(T){return this.reverse()[m](T).reverse()}}),ql(["filter","map","takeWhile"],function(m,v){var T=v+1,N=T==L||T==F;gr.prototype[m]=function(V){var Y=this.clone();return Y.__iteratees__.push({iteratee:ke(V,3),type:T}),Y.__filtered__=Y.__filtered__||N,Y}}),ql(["head","last"],function(m,v){var T="take"+(v?"Right":"");gr.prototype[m]=function(){return this[T](1).value()[0]}}),ql(["initial","tail"],function(m,v){var T="drop"+(v?"":"Right");gr.prototype[m]=function(){return this.__filtered__?new gr(this):this[T](1)}}),gr.prototype.compact=function(){return this.filter(gs)},gr.prototype.find=function(m){return this.filter(m).head()},gr.prototype.findLast=function(m){return this.reverse().find(m)},gr.prototype.invokeMap=nr(function(m,v){return typeof m=="function"?new gr(this):this.map(function(T){return kM(T,m,v)})}),gr.prototype.reject=function(m){return this.filter(wI(ke(m)))},gr.prototype.slice=function(m,v){m=Qe(m);var T=this;return T.__filtered__&&(m>0||v<0)?new gr(T):(m<0?T=T.takeRight(-m):m&&(T=T.drop(m)),v!==e&&(v=Qe(v),T=v<0?T.dropRight(-v):T.take(v-m)),T)},gr.prototype.takeRightWhile=function(m){return this.reverse().takeWhile(m).reverse()},gr.prototype.toArray=function(){return this.take(rt)},mh(gr.prototype,function(m,v){var T=/^(?:filter|find|map|reject)|While$/.test(v),N=/^(?:head|last)$/.test(v),V=G[N?"take"+(v=="last"?"Right":""):v],Y=N||/^find/.test(v);!V||(G.prototype[v]=function(){var J=this.__wrapped__,it=N?[1]:arguments,ft=J instanceof gr,Dt=it[0],Ot=ft||$e(J),Vt=function(pr){var yr=V.apply(G,pm([pr],it));return N&&oe?yr[0]:yr};Ot&&T&&typeof Dt=="function"&&Dt.length!=1&&(ft=Ot=!1);var oe=this.__chain__,Te=!!this.__actions__.length,Ne=Y&&!oe,er=ft&&!Te;if(!Y&&Ot){J=er?J:new gr(this);var De=m.apply(J,it);return De.__actions__.push({func:yI,args:[Vt],thisArg:e}),new Wl(De,oe)}return Ne&&er?m.apply(this,it):(De=this.thru(Vt),Ne?N?De.value()[0]:De.value():De)})}),ql(["pop","push","shift","sort","splice","unshift"],function(m){var v=G6[m],T=/^(?:push|sort|unshift)$/.test(m)?"tap":"thru",N=/^(?:pop|shift)$/.test(m);G.prototype[m]=function(){var V=arguments;if(N&&!this.__chain__){var Y=this.value();return v.apply($e(Y)?Y:[],V)}return this[T](function(J){return v.apply($e(J)?J:[],V)})}}),mh(gr.prototype,function(m,v){var T=G[v];if(T){var N=T.name+"";un.call(_x,N)||(_x[N]=[]),_x[N].push({name:v,func:T})}}),_x[hI(e,g).name]=[{name:"wrapper",func:e}],gr.prototype.clone=kde,gr.prototype.reverse=Rde,gr.prototype.value=Nde,G.prototype.at=c0e,G.prototype.chain=u0e,G.prototype.commit=h0e,G.prototype.next=f0e,G.prototype.plant=d0e,G.prototype.reverse=m0e,G.prototype.toJSON=G.prototype.valueOf=G.prototype.value=g0e,G.prototype.first=G.prototype.head,EM&&(G.prototype[EM]=p0e),G},mm=hde();typeof define=="function"&&typeof define.amd=="object"&&define.amd?(fo._=mm,define(function(){return mm})):Q0?((Q0.exports=mm)._=mm,aq._=mm):fo._=mm}).call(Rx)});function __t(){for(var e=0,t=arguments.length,r={},n;e<t;++e){if(!(n=arguments[e]+"")||n in r||/[\s.]/.test(n))throw new Error("illegal type: "+n);r[n]=[]}return new J9(r)}function J9(e){this._=e}function g2e(e,t){return e.trim().split(/^|\s+/).map(function(r){var n="",i=r.indexOf(".");if(i>=0&&(n=r.slice(i+1),r=r.slice(0,i)),r&&!t.hasOwnProperty(r))throw new Error("unknown type: "+r);return{type:r,name:n}})}function _2e(e,t){for(var r=0,n=e.length,i;r<n;++r)if((i=e[r]).name===t)return i.value}function g_t(e,t,r){for(var n=0,i=e.length;n<i;++n)if(e[n].name===t){e[n]=m2e,e=e.slice(0,n).concat(e.slice(n+1));break}return r!=null&&e.push({name:t,value:r}),e}var m2e,vs,y_t=M(()=>{m2e={value:function(){}};J9.prototype=__t.prototype={constructor:J9,on:function(e,t){var r=this._,n=g2e(e+"",r),i,o=-1,a=n.length;if(arguments.length<2){for(;++o<a;)if((i=(e=n[o]).type)&&(i=_2e(r[i],e.name)))return i;return}if(t!=null&&typeof t!="function")throw new Error("invalid callback: "+t);for(;++o<a;)if(i=(e=n[o]).type)r[i]=g_t(r[i],e.name,t);else if(t==null)for(i in r)r[i]=g_t(r[i],e.name,null);return this},copy:function(){var e={},t=this._;for(var r in t)e[r]=t[r].slice();return new J9(e)},call:function(e,t){if((i=arguments.length-2)>0)for(var r=new Array(i),n=0,i,o;n<i;++n)r[n]=arguments[n+2];if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(o=this._[e],n=0,i=o.length;n<i;++n)o[n].value.apply(t,r)},apply:function(e,t,r){if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(var n=this._[e],i=0,o=n.length;i<o;++i)n[i].value.apply(t,r)}};vs=__t});var km=M(()=>{y_t()});function _Y(e){return+e}var Cvt=M(()=>{});function yY(e){return e*e}function vY(e){return e*(2-e)}function IL(e){return((e*=2)<=1?e*e:--e*(2-e)+1)/2}var Avt=M(()=>{});function xY(e){return e*e*e}function bY(e){return--e*e*e+1}function xs(e){return((e*=2)<=1?e*e*e:(e-=2)*e*e+2)/2}var Pvt=M(()=>{});var wY,SY,MY,LL,Ivt=M(()=>{wY=3,SY=function e(t){t=+t;function r(n){return Math.pow(n,t)}return r.exponent=e,r}(wY),MY=function e(t){t=+t;function r(n){return 1-Math.pow(1-n,t)}return r.exponent=e,r}(wY),LL=function e(t){t=+t;function r(n){return((n*=2)<=1?Math.pow(n,t):2-Math.pow(2-n,t))/2}return r.exponent=e,r}(wY)});function EY(e){return+e==1?1:1-Math.cos(e*kvt)}function TY(e){return Math.sin(e*kvt)}function kL(e){return(1-Math.cos(Lvt*e))/2}var Lvt,kvt,Rvt=M(()=>{Lvt=Math.PI,kvt=Lvt/2});function Dh(e){return(Math.pow(2,-10*e)-.0009765625)*1.0009775171065494}var CY=M(()=>{});function AY(e){return Dh(1-+e)}function PY(e){return 1-Dh(e)}function RL(e){return((e*=2)<=1?Dh(1-e):2-Dh(e-1))/2}var Nvt=M(()=>{CY()});function IY(e){return 1-Math.sqrt(1-e*e)}function LY(e){return Math.sqrt(1- --e*e)}function NL(e){return((e*=2)<=1?1-Math.sqrt(1-e*e):Math.sqrt(1-(e-=2)*e)+1)/2}var Dvt=M(()=>{});function RY(e){return 1-P_(1-e)}function P_(e){return(e=+e)<kY?DL*e*e:e<uSe?DL*(e-=cSe)*e+hSe:e<pSe?DL*(e-=fSe)*e+dSe:DL*(e-=mSe)*e+gSe}function NY(e){return((e*=2)<=1?1-P_(1-e):P_(e-1)+1)/2}var kY,cSe,uSe,hSe,fSe,pSe,dSe,mSe,gSe,DL,Ovt=M(()=>{kY=.36363636363636365,cSe=6/11,uSe=8/11,hSe=3/4,fSe=9/11,pSe=10/11,dSe=15/16,mSe=21/22,gSe=63/64,DL=1/kY/kY});var DY,OY,zY,OL,zvt=M(()=>{DY=1.70158,OY=function e(t){t=+t;function r(n){return(n=+n)*n*(t*(n-1)+n)}return r.overshoot=e,r}(DY),zY=function e(t){t=+t;function r(n){return--n*n*((n+1)*t+n)+1}return r.overshoot=e,r}(DY),OL=function e(t){t=+t;function r(n){return((n*=2)<1?n*n*((t+1)*n-t):(n-=2)*n*((t+1)*n+t)+2)/2}return r.overshoot=e,r}(DY)});var Sb,FY,BY,HY,zL,VY,Fvt=M(()=>{CY();Sb=2*Math.PI,FY=1,BY=.3,HY=function e(t,r){var n=Math.asin(1/(t=Math.max(1,t)))*(r/=Sb);function i(o){return t*Dh(- --o)*Math.sin((n-o)/r)}return i.amplitude=function(o){return e(o,r*Sb)},i.period=function(o){return e(t,o)},i}(FY,BY),zL=function e(t,r){var n=Math.asin(1/(t=Math.max(1,t)))*(r/=Sb);function i(o){return 1-t*Dh(o=+o)*Math.sin((o+n)/r)}return i.amplitude=function(o){return e(o,r*Sb)},i.period=function(o){return e(t,o)},i}(FY,BY),VY=function e(t,r){var n=Math.asin(1/(t=Math.max(1,t)))*(r/=Sb);function i(o){return((o=o*2-1)<0?t*Dh(-o)*Math.sin((n-o)/r):2-t*Dh(o)*Math.sin((n+o)/r))/2}return i.amplitude=function(o){return e(o,r*Sb)},i.period=function(o){return e(t,o)},i}(FY,BY)});var Bvt={};Ks(Bvt,{easeBack:()=>OL,easeBackIn:()=>OY,easeBackInOut:()=>OL,easeBackOut:()=>zY,easeBounce:()=>P_,easeBounceIn:()=>RY,easeBounceInOut:()=>NY,easeBounceOut:()=>P_,easeCircle:()=>NL,easeCircleIn:()=>IY,easeCircleInOut:()=>NL,easeCircleOut:()=>LY,easeCubic:()=>xs,easeCubicIn:()=>xY,easeCubicInOut:()=>xs,easeCubicOut:()=>bY,easeElastic:()=>zL,easeElasticIn:()=>HY,easeElasticInOut:()=>VY,easeElasticOut:()=>zL,easeExp:()=>RL,easeExpIn:()=>AY,easeExpInOut:()=>RL,easeExpOut:()=>PY,easeLinear:()=>_Y,easePoly:()=>LL,easePolyIn:()=>SY,easePolyInOut:()=>LL,easePolyOut:()=>MY,easeQuad:()=>IL,easeQuadIn:()=>yY,easeQuadInOut:()=>IL,easeQuadOut:()=>vY,easeSin:()=>kL,easeSinIn:()=>EY,easeSinInOut:()=>kL,easeSinOut:()=>TY});var I_=M(()=>{Cvt();Avt();Pvt();Ivt();Rvt();Nvt();Dvt();Ovt();zvt();Fvt()});function YL(){}function Qvt(e,t){var r=new YL;if(e instanceof YL)e.each(function(s,l){r.set(l,s)});else if(Array.isArray(e)){var n=-1,i=e.length,o;if(t==null)for(;++n<i;)r.set(n,e[n]);else for(;++n<i;)r.set(t(o=e[n],n,e),o)}else if(e)for(var a in e)r.set(a,e[a]);return r}var el,Ji,jL=M(()=>{el="$";YL.prototype=Qvt.prototype={constructor:YL,has:function(e){return el+e in this},get:function(e){return this[el+e]},set:function(e,t){return this[el+e]=t,this},remove:function(e){var t=el+e;return t in this&&delete this[t]},clear:function(){for(var e in this)e[0]===el&&delete this[e]},keys:function(){var e=[];for(var t in this)t[0]===el&&e.push(t.slice(1));return e},values:function(){var e=[];for(var t in this)t[0]===el&&e.push(this[t]);return e},entries:function(){var e=[];for(var t in this)t[0]===el&&e.push({key:t.slice(1),value:this[t]});return e},size:function(){var e=0;for(var t in this)t[0]===el&&++e;return e},empty:function(){for(var e in this)if(e[0]===el)return!1;return!0},each:function(e){for(var t in this)t[0]===el&&e(this[t],t.slice(1),this)}};Ji=Qvt});function r1t(){var e=[],t=[],r,n,i;function o(s,l,c,u){if(l>=e.length)return r!=null&&s.sort(r),n!=null?n(s):s;for(var h=-1,f=s.length,p=e[l++],d,g,_=Ji(),y,x=c();++h<f;)(y=_.get(d=p(g=s[h])+""))?y.push(g):_.set(d,[g]);return _.each(function(b,S){u(x,S,o(b,l,c,u))}),x}function a(s,l){if(++l>e.length)return s;var c,u=t[l-1];return n!=null&&l>=e.length?c=s.entries():(c=[],s.each(function(h,f){c.push({key:f,values:a(h,l)})})),u!=null?c.sort(function(h,f){return u(h.key,f.key)}):c}return i={object:function(s){return o(s,0,NSe,DSe)},map:function(s){return o(s,0,t1t,e1t)},entries:function(s){return a(o(s,0,t1t,e1t),0)},key:function(s){return e.push(s),i},sortKeys:function(s){return t[e.length-1]=s,i},sortValues:function(s){return r=s,i},rollup:function(s){return n=s,i}}}function NSe(){return{}}function DSe(e,t,r){e[t]=r}function t1t(){return Ji()}function e1t(e,t,r){e.set(t,r)}var n1t=M(()=>{jL()});function XL(){}function i1t(e,t){var r=new XL;if(e instanceof XL)e.each(function(o){r.add(o)});else if(e){var n=-1,i=e.length;if(t==null)for(;++n<i;)r.add(e[n]);else for(;++n<i;)r.add(t(e[n],n,e))}return r}var k_,o1t,a1t=M(()=>{jL();k_=Ji.prototype;XL.prototype=i1t.prototype={constructor:XL,has:k_.has,add:function(e){return e+="",this[el+e]=e,this},remove:k_.remove,clear:k_.clear,values:k_.keys,size:k_.size,empty:k_.empty,each:k_.each};o1t=i1t});function $L(e){var t=[];for(var r in e)t.push(r);return t}var s1t=M(()=>{});function l1t(e){var t=[];for(var r in e)t.push(e[r]);return t}var c1t=M(()=>{});function u1t(e){var t=[];for(var r in e)t.push({key:r,value:e[r]});return t}var h1t=M(()=>{});var Tb=M(()=>{n1t();a1t();jL();s1t();c1t();h1t()});function v1t(e){return new Function("d","return {"+e.map(function(t,r){return JSON.stringify(t)+": d["+r+'] || ""'}).join(",")+"}")}function GSe(e,t){var r=v1t(e);return function(n,i){return t(r(n),i,e)}}function y1t(e){var t=Object.create(null),r=[];return e.forEach(function(n){for(var i in n)i in t||r.push(t[i]=i)}),r}function ws(e,t){var r=e+"",n=r.length;return n<t?new Array(t-n+1).join(0)+r:r}function WSe(e){return e<0?"-"+ws(-e,6):e>9999?"+"+ws(e,6):ws(e,4)}function YSe(e){var t=e.getUTCHours(),r=e.getUTCMinutes(),n=e.getUTCSeconds(),i=e.getUTCMilliseconds();return isNaN(e)?"Invalid Date":WSe(e.getUTCFullYear(),4)+"-"+ws(e.getUTCMonth()+1,2)+"-"+ws(e.getUTCDate(),2)+(i?"T"+ws(t,2)+":"+ws(r,2)+":"+ws(n,2)+"."+ws(i,3)+"Z":n?"T"+ws(t,2)+":"+ws(r,2)+":"+ws(n,2)+"Z":r||t?"T"+ws(t,2)+":"+ws(r,2)+"Z":"")}function Wm(e){var t=new RegExp('["'+e+`
\r]`),r=e.charCodeAt(0);function n(h,f){var p,d,g=i(h,function(_,y){if(p)return p(_,y-1);d=_,p=f?GSe(_,f):v1t(_)});return g.columns=d||[],g}function i(h,f){var p=[],d=h.length,g=0,_=0,y,x=d<=0,b=!1;h.charCodeAt(d-1)===UE&&--d,h.charCodeAt(d-1)===nj&&--d;function S(){if(x)return ej;if(b)return b=!1,_1t;var P,k=g,O;if(h.charCodeAt(k)===rj){for(;g++<d&&h.charCodeAt(g)!==rj||h.charCodeAt(++g)===rj;);return(P=g)>=d?x=!0:(O=h.charCodeAt(g++))===UE?b=!0:O===nj&&(b=!0,h.charCodeAt(g)===UE&&++g),h.slice(k+1,P-1).replace(/""/g,'"')}for(;g<d;){if((O=h.charCodeAt(P=g++))===UE)b=!0;else if(O===nj)b=!0,h.charCodeAt(g)===UE&&++g;else if(O!==r)continue;return h.slice(k,P)}return x=!0,h.slice(k,d)}for(;(y=S())!==ej;){for(var C=[];y!==_1t&&y!==ej;)C.push(y),y=S();f&&(C=f(C,_++))==null||p.push(C)}return p}function o(h,f){return h.map(function(p){return f.map(function(d){return u(p[d])}).join(e)})}function a(h,f){return f==null&&(f=y1t(h)),[f.map(u).join(e)].concat(o(h,f)).join(`
`)}function s(h,f){return f==null&&(f=y1t(h)),o(h,f).join(`
`)}function l(h){return h.map(c).join(`
`)}function c(h){return h.map(u).join(e)}function u(h){return h==null?"":h instanceof Date?YSe(h):t.test(h+="")?'"'+h.replace(/"/g,'""')+'"':h}return{parse:n,parseRows:i,format:a,formatBody:s,formatRows:l,formatRow:c,formatValue:u}}var _1t,ej,rj,UE,nj,tk=M(()=>{_1t={},ej={},rj=34,UE=10,nj=13});var R_,Cb,x1t,b1t,w1t,S1t,M1t,E1t,T1t=M(()=>{tk();R_=Wm(","),Cb=R_.parse,x1t=R_.parseRows,b1t=R_.format,w1t=R_.formatBody,S1t=R_.formatRows,M1t=R_.formatRow,E1t=R_.formatValue});var N_,Ab,C1t,A1t,P1t,I1t,L1t,k1t,R1t=M(()=>{tk();N_=Wm("	"),Ab=N_.parse,C1t=N_.parseRows,A1t=N_.format,P1t=N_.formatBody,I1t=N_.formatRows,L1t=N_.formatRow,k1t=N_.formatValue});function ij(e){for(var t in e){var r=e[t].trim(),n,i;if(!r)r=null;else if(r==="true")r=!0;else if(r==="false")r=!1;else if(r==="NaN")r=NaN;else if(!isNaN(n=+r))r=n;else if(i=r.match(/^([-+]\d{2})?\d{4}(-\d{2}(-\d{2})?)?(T\d{2}:\d{2}(:\d{2}(\.\d{3})?)?(Z|[-+]\d{2}:\d{2})?)?$/))jSe&&!!i[4]&&!i[7]&&(r=r.replace(/-/g,"/").replace(/T/," ")),r=new Date(r);else continue;e[t]=r}return e}var jSe,N1t=M(()=>{jSe=new Date("2019-01-01T00:00").getHours()||new Date("2019-07-01T00:00").getHours()});var qE=M(()=>{tk();T1t();R1t();N1t()});var pe={};Ks(pe,{__assign:()=>y5e,__asyncDelegator:()=>A5e,__asyncGenerator:()=>C5e,__asyncValues:()=>P5e,__await:()=>U5,__awaiter:()=>S5e,__decorate:()=>x5e,__exportStar:()=>E5e,__extends:()=>_5e,__generator:()=>M5e,__makeTemplateObject:()=>I5e,__metadata:()=>w5e,__param:()=>b5e,__read:()=>nMt,__rest:()=>v5e,__spread:()=>T5e,__values:()=>y$});function _5e(e,t){g5e(e,t);function r(){this.constructor=e}e.prototype=t===null?Object.create(t):(r.prototype=t.prototype,new r)}function v5e(e,t){var r={};for(var n in e)Object.prototype.hasOwnProperty.call(e,n)&&t.indexOf(n)<0&&(r[n]=e[n]);if(e!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,n=Object.getOwnPropertySymbols(e);i<n.length;i++)t.indexOf(n[i])<0&&(r[n[i]]=e[n[i]]);return r}function x5e(e,t,r,n){var i=arguments.length,o=i<3?t:n===null?n=Object.getOwnPropertyDescriptor(t,r):n,a;if(typeof Reflect=="object"&&typeof Reflect.decorate=="function")o=Reflect.decorate(e,t,r,n);else for(var s=e.length-1;s>=0;s--)(a=e[s])&&(o=(i<3?a(o):i>3?a(t,r,o):a(t,r))||o);return i>3&&o&&Object.defineProperty(t,r,o),o}function b5e(e,t){return function(r,n){t(r,n,e)}}function w5e(e,t){if(typeof Reflect=="object"&&typeof Reflect.metadata=="function")return Reflect.metadata(e,t)}function S5e(e,t,r,n){return new(r||(r=Promise))(function(i,o){function a(c){try{l(n.next(c))}catch(u){o(u)}}function s(c){try{l(n.throw(c))}catch(u){o(u)}}function l(c){c.done?i(c.value):new r(function(u){u(c.value)}).then(a,s)}l((n=n.apply(e,t||[])).next())})}function M5e(e,t){var r={label:0,sent:function(){if(o[0]&1)throw o[1];return o[1]},trys:[],ops:[]},n,i,o,a;return a={next:s(0),throw:s(1),return:s(2)},typeof Symbol=="function"&&(a[Symbol.iterator]=function(){return this}),a;function s(c){return function(u){return l([c,u])}}function l(c){if(n)throw new TypeError("Generator is already executing.");for(;r;)try{if(n=1,i&&(o=i[c[0]&2?"return":c[0]?"throw":"next"])&&!(o=o.call(i,c[1])).done)return o;switch(i=0,o&&(c=[0,o.value]),c[0]){case 0:case 1:o=c;break;case 4:return r.label++,{value:c[1],done:!1};case 5:r.label++,i=c[1],c=[0];continue;case 7:c=r.ops.pop(),r.trys.pop();continue;default:if(o=r.trys,!(o=o.length>0&&o[o.length-1])&&(c[0]===6||c[0]===2)){r=0;continue}if(c[0]===3&&(!o||c[1]>o[0]&&c[1]<o[3])){r.label=c[1];break}if(c[0]===6&&r.label<o[1]){r.label=o[1],o=c;break}if(o&&r.label<o[2]){r.label=o[2],r.ops.push(c);break}o[2]&&r.ops.pop(),r.trys.pop();continue}c=t.call(e,r)}catch(u){c=[6,u],i=0}finally{n=o=0}if(c[0]&5)throw c[1];return{value:c[0]?c[1]:void 0,done:!0}}}function E5e(e,t){for(var r in e)t.hasOwnProperty(r)||(t[r]=e[r])}function y$(e){var t=typeof Symbol=="function"&&e[Symbol.iterator],r=0;return t?t.call(e):{next:function(){return e&&r>=e.length&&(e=void 0),{value:e&&e[r++],done:!e}}}}function nMt(e,t){var r=typeof Symbol=="function"&&e[Symbol.iterator];if(!r)return e;var n=r.call(e),i,o=[],a;try{for(;(t===void 0||t-- >0)&&!(i=n.next()).done;)o.push(i.value)}catch(s){a={error:s}}finally{try{i&&!i.done&&(r=n.return)&&r.call(n)}finally{if(a)throw a.error}}return o}function T5e(){for(var e=[],t=0;t<arguments.length;t++)e=e.concat(nMt(arguments[t]));return e}function U5(e){return this instanceof U5?(this.v=e,this):new U5(e)}function C5e(e,t,r){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var n=r.apply(e,t||[]),i,o=[];return i={},a("next"),a("throw"),a("return"),i[Symbol.asyncIterator]=function(){return this},i;function a(f){n[f]&&(i[f]=function(p){return new Promise(function(d,g){o.push([f,p,d,g])>1||s(f,p)})})}function s(f,p){try{l(n[f](p))}catch(d){h(o[0][3],d)}}function l(f){f.value instanceof U5?Promise.resolve(f.value.v).then(c,u):h(o[0][2],f)}function c(f){s("next",f)}function u(f){s("throw",f)}function h(f,p){f(p),o.shift(),o.length&&s(o[0][0],o[0][1])}}function A5e(e){var t,r;return t={},n("next"),n("throw",function(i){throw i}),n("return"),t[Symbol.iterator]=function(){return this},t;function n(i,o){e[i]&&(t[i]=function(a){return(r=!r)?{value:U5(e[i](a)),done:i==="return"}:o?o(a):a})}}function P5e(e){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var t=e[Symbol.asyncIterator];return t?t.call(e):typeof y$=="function"?y$(e):e[Symbol.iterator]()}function I5e(e,t){return Object.defineProperty?Object.defineProperty(e,"raw",{value:t}):e.raw=t,e}var g5e,y5e,de=M(()=>{g5e=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var r in t)t.hasOwnProperty(r)&&(e[r]=t[r])};y5e=Object.assign||function(t){for(var r,n=1,i=arguments.length;n<i;n++){r=arguments[n];for(var o in r)Object.prototype.hasOwnProperty.call(r,o)&&(t[o]=r[o])}return t}});var iMt,oMt=M(()=>{iMt="4.13.0"});function _c(e,t){return e<t?-1:e>t?1:e>=t?0:NaN}var py=M(()=>{});function aR(e){return e.length===1&&(e=L5e(e)),{left:function(t,r,n,i){for(n==null&&(n=0),i==null&&(i=t.length);n<i;){var o=n+i>>>1;e(t[o],r)<0?n=o+1:i=o}return n},right:function(t,r,n,i){for(n==null&&(n=0),i==null&&(i=t.length);n<i;){var o=n+i>>>1;e(t[o],r)>0?i=o:n=o+1}return n}}}function L5e(e){return function(t,r){return _c(e(t),r)}}var v$=M(()=>{py()});var aMt,x$,sMt,sR,b$=M(()=>{py();v$();aMt=aR(_c),x$=aMt.right,sMt=aMt.left,sR=x$});function lMt(e,t){t==null&&(t=w$);for(var r=0,n=e.length-1,i=e[0],o=new Array(n<0?0:n);r<n;)o[r]=t(i,i=e[++r]);return o}function w$(e,t){return[e,t]}var S$=M(()=>{});function cMt(e,t,r){var n=e.length,i=t.length,o=new Array(n*i),a,s,l,c;for(r==null&&(r=w$),a=l=0;a<n;++a)for(c=e[a],s=0;s<i;++s,++l)o[l]=r(c,t[s]);return o}var uMt=M(()=>{S$()});function hMt(e,t){return t<e?-1:t>e?1:t>=e?0:NaN}var fMt=M(()=>{});function al(e){return e===null?NaN:+e}var l2=M(()=>{});function lR(e,t){var r=e.length,n=0,i=-1,o=0,a,s,l=0;if(t==null)for(;++i<r;)isNaN(a=al(e[i]))||(s=a-o,o+=s/++n,l+=s*(a-o));else for(;++i<r;)isNaN(a=al(t(e[i],i,e)))||(s=a-o,o+=s/++n,l+=s*(a-o));if(n>1)return l/(n-1)}var M$=M(()=>{l2()});function cR(e,t){var r=lR(e,t);return r&&Math.sqrt(r)}var E$=M(()=>{M$()});function uR(e,t){var r=e.length,n=-1,i,o,a;if(t==null){for(;++n<r;)if((i=e[n])!=null&&i>=i)for(o=a=i;++n<r;)(i=e[n])!=null&&(o>i&&(o=i),a<i&&(a=i))}else for(;++n<r;)if((i=t(e[n],n,e))!=null&&i>=i)for(o=a=i;++n<r;)(i=t(e[n],n,e))!=null&&(o>i&&(o=i),a<i&&(a=i));return[o,a]}var T$=M(()=>{});var pMt,dMt,mMt,C$=M(()=>{pMt=Array.prototype,dMt=pMt.slice,mMt=pMt.map});function q5(e){return function(){return e}}var gMt=M(()=>{});function _Mt(e){return e}var yMt=M(()=>{});function hR(e,t,r){e=+e,t=+t,r=(i=arguments.length)<2?(t=e,e=0,1):i<3?1:+r;for(var n=-1,i=Math.max(0,Math.ceil((t-e)/r))|0,o=new Array(i);++n<i;)o[n]=e+n*r;return o}var A$=M(()=>{});function vMt(e,t,r){var n,i=-1,o,a,s;if(t=+t,e=+e,r=+r,e===t&&r>0)return[e];if((n=t<e)&&(o=e,e=t,t=o),(s=k$(e,t,r))===0||!isFinite(s))return[];if(s>0)for(e=Math.ceil(e/s),t=Math.floor(t/s),a=new Array(o=Math.ceil(t-e+1));++i<o;)a[i]=(e+i)*s;else for(e=Math.floor(e*s),t=Math.ceil(t*s),a=new Array(o=Math.ceil(e-t+1));++i<o;)a[i]=(e-i)/s;return n&&a.reverse(),a}function k$(e,t,r){var n=(t-e)/Math.max(0,r),i=Math.floor(Math.log(n)/Math.LN10),o=n/Math.pow(10,i);return i>=0?(o>=P$?10:o>=I$?5:o>=L$?2:1)*Math.pow(10,i):-Math.pow(10,-i)/(o>=P$?10:o>=I$?5:o>=L$?2:1)}function fR(e,t,r){var n=Math.abs(t-e)/Math.max(0,r),i=Math.pow(10,Math.floor(Math.log(n)/Math.LN10)),o=n/i;return o>=P$?i*=10:o>=I$?i*=5:o>=L$&&(i*=2),t<e?-i:i}var P$,I$,L$,R$=M(()=>{P$=Math.sqrt(50),I$=Math.sqrt(10),L$=Math.sqrt(2)});function pR(e){return Math.ceil(Math.log(e.length)/Math.LN2)+1}var N$=M(()=>{});function xMt(){var e=_Mt,t=uR,r=pR;function n(i){var o,a=i.length,s,l=new Array(a);for(o=0;o<a;++o)l[o]=e(i[o],o,i);var c=t(l),u=c[0],h=c[1],f=r(l,u,h);Array.isArray(f)||(f=fR(u,h,f),f=hR(Math.ceil(u/f)*f,Math.floor(h/f)*f,f));for(var p=f.length;f[0]<=u;)f.shift(),--p;for(;f[p-1]>h;)f.pop(),--p;var d=new Array(p+1),g;for(o=0;o<=p;++o)g=d[o]=[],g.x0=o>0?f[o-1]:u,g.x1=o<p?f[o]:h;for(o=0;o<a;++o)s=l[o],u<=s&&s<=h&&d[sR(f,s,0,p)].push(i[o]);return d}return n.value=function(i){return arguments.length?(e=typeof i=="function"?i:q5(i),n):e},n.domain=function(i){return arguments.length?(t=typeof i=="function"?i:q5([i[0],i[1]]),n):t},n.thresholds=function(i){return arguments.length?(r=typeof i=="function"?i:Array.isArray(i)?q5(dMt.call(i)):q5(i),n):r},n}var bMt=M(()=>{C$();b$();gMt();T$();yMt();A$();R$();N$()});function dy(e,t,r){if(r==null&&(r=al),!!(n=e.length)){if((t=+t)<=0||n<2)return+r(e[0],0,e);if(t>=1)return+r(e[n-1],n-1,e);var n,i=(n-1)*t,o=Math.floor(i),a=+r(e[o],o,e),s=+r(e[o+1],o+1,e);return a+(s-a)*(i-o)}}var dR=M(()=>{l2()});function wMt(e,t,r){return e=mMt.call(e,al).sort(_c),Math.ceil((r-t)/(2*(dy(e,.75)-dy(e,.25))*Math.pow(e.length,-1/3)))}var SMt=M(()=>{C$();py();l2();dR()});function MMt(e,t,r){return Math.ceil((r-t)/(3.5*cR(e)*Math.pow(e.length,-1/3)))}var EMt=M(()=>{E$()});function TMt(e,t){var r=e.length,n=-1,i,o;if(t==null){for(;++n<r;)if((i=e[n])!=null&&i>=i)for(o=i;++n<r;)(i=e[n])!=null&&i>o&&(o=i)}else for(;++n<r;)if((i=t(e[n],n,e))!=null&&i>=i)for(o=i;++n<r;)(i=t(e[n],n,e))!=null&&i>o&&(o=i);return o}var CMt=M(()=>{});function AMt(e,t){var r=e.length,n=r,i=-1,o,a=0;if(t==null)for(;++i<r;)isNaN(o=al(e[i]))?--n:a+=o;else for(;++i<r;)isNaN(o=al(t(e[i],i,e)))?--n:a+=o;if(n)return a/n}var PMt=M(()=>{l2()});function IMt(e,t){var r=e.length,n=-1,i,o=[];if(t==null)for(;++n<r;)isNaN(i=al(e[n]))||o.push(i);else for(;++n<r;)isNaN(i=al(t(e[n],n,e)))||o.push(i);return dy(o.sort(_c),.5)}var LMt=M(()=>{py();l2();dR()});function kMt(e){for(var t=e.length,r,n=-1,i=0,o,a;++n<t;)i+=e[n].length;for(o=new Array(i);--t>=0;)for(a=e[t],r=a.length;--r>=0;)o[--i]=a[r];return o}var RMt=M(()=>{});function mR(e,t){var r=e.length,n=-1,i,o;if(t==null){for(;++n<r;)if((i=e[n])!=null&&i>=i)for(o=i;++n<r;)(i=e[n])!=null&&o>i&&(o=i)}else for(;++n<r;)if((i=t(e[n],n,e))!=null&&i>=i)for(o=i;++n<r;)(i=t(e[n],n,e))!=null&&o>i&&(o=i);return o}var D$=M(()=>{});function NMt(e,t){for(var r=t.length,n=new Array(r);r--;)n[r]=e[t[r]];return n}var DMt=M(()=>{});function OMt(e,t){if(!!(r=e.length)){var r,n=0,i=0,o,a=e[i];for(t==null&&(t=_c);++n<r;)(t(o=e[n],a)<0||t(a,a)!==0)&&(a=o,i=n);if(t(a,a)===0)return i}}var zMt=M(()=>{py()});function FMt(e,t,r){for(var n=(r==null?e.length:r)-(t=t==null?0:+t),i,o;n;)o=Math.random()*n--|0,i=e[n+t],e[n+t]=e[o+t],e[o+t]=i;return e}var BMt=M(()=>{});function HMt(e,t){var r=e.length,n=-1,i,o=0;if(t==null)for(;++n<r;)(i=+e[n])&&(o+=i);else for(;++n<r;)(i=+t(e[n],n,e))&&(o+=i);return o}var VMt=M(()=>{});function gR(e){if(!(o=e.length))return[];for(var t=-1,r=mR(e,k5e),n=new Array(r);++t<r;)for(var i=-1,o,a=n[t]=new Array(o);++i<o;)a[i]=e[i][t];return n}function k5e(e){return e.length}var O$=M(()=>{D$()});function UMt(){return gR(arguments)}var qMt=M(()=>{O$()});var GMt=M(()=>{b$();py();v$();uMt();fMt();E$();T$();bMt();SMt();EMt();N$();CMt();PMt();LMt();RMt();D$();S$();DMt();dR();A$();zMt();BMt();VMt();R$();O$();M$();qMt()});var _R,WMt=M(()=>{_R=Array.prototype.slice});function YMt(e){return e}var jMt=M(()=>{});function R5e(e){return"translate("+(e+.5)+",0)"}function N5e(e){return"translate(0,"+(e+.5)+")"}function D5e(e){return function(t){return+e(t)}}function O5e(e){var t=Math.max(0,e.bandwidth()-1)/2;return e.round()&&(t=Math.round(t)),function(r){return+e(r)+t}}function z5e(){return!this.__axis}function xR(e,t){var r=[],n=null,i=null,o=6,a=6,s=3,l=e===yR||e===G5?-1:1,c=e===G5||e===vR?"x":"y",u=e===yR||e===z$?R5e:N5e;function h(f){var p=n==null?t.ticks?t.ticks.apply(t,r):t.domain():n,d=i==null?t.tickFormat?t.tickFormat.apply(t,r):YMt:i,g=Math.max(o,0)+s,_=t.range(),y=+_[0]+.5,x=+_[_.length-1]+.5,b=(t.bandwidth?O5e:D5e)(t.copy()),S=f.selection?f.selection():f,C=S.selectAll(".domain").data([null]),P=S.selectAll(".tick").data(p,t).order(),k=P.exit(),O=P.enter().append("g").attr("class","tick"),D=P.select("line"),B=P.select("text");C=C.merge(C.enter().insert("path",".tick").attr("class","domain").attr("stroke","#000")),P=P.merge(O),D=D.merge(O.append("line").attr("stroke","#000").attr(c+"2",l*o)),B=B.merge(O.append("text").attr("fill","#000").attr(c,l*g).attr("dy",e===yR?"0em":e===z$?"0.71em":"0.32em")),f!==S&&(C=C.transition(f),P=P.transition(f),D=D.transition(f),B=B.transition(f),k=k.transition(f).attr("opacity",XMt).attr("transform",function(I){return isFinite(I=b(I))?u(I):this.getAttribute("transform")}),O.attr("opacity",XMt).attr("transform",function(I){var L=this.parentNode.__axis;return u(L&&isFinite(L=L(I))?L:b(I))})),k.remove(),C.attr("d",e===G5||e==vR?"M"+l*a+","+y+"H0.5V"+x+"H"+l*a:"M"+y+","+l*a+"V0.5H"+x+"V"+l*a),P.attr("opacity",1).attr("transform",function(I){return u(b(I))}),D.attr(c+"2",l*o),B.attr(c,l*g).text(d),S.filter(z5e).attr("fill","none").attr("font-size",10).attr("font-family","sans-serif").attr("text-anchor",e===vR?"start":e===G5?"end":"middle"),S.each(function(){this.__axis=b})}return h.scale=function(f){return arguments.length?(t=f,h):t},h.ticks=function(){return r=_R.call(arguments),h},h.tickArguments=function(f){return arguments.length?(r=f==null?[]:_R.call(f),h):r.slice()},h.tickValues=function(f){return arguments.length?(n=f==null?null:_R.call(f),h):n&&n.slice()},h.tickFormat=function(f){return arguments.length?(i=f,h):i},h.tickSize=function(f){return arguments.length?(o=a=+f,h):o},h.tickSizeInner=function(f){return arguments.length?(o=+f,h):o},h.tickSizeOuter=function(f){return arguments.length?(a=+f,h):a},h.tickPadding=function(f){return arguments.length?(s=+f,h):s},h}function $Mt(e){return xR(yR,e)}function KMt(e){return xR(vR,e)}function ZMt(e){return xR(z$,e)}function JMt(e){return xR(G5,e)}var yR,vR,z$,G5,XMt,QMt=M(()=>{WMt();jMt();yR=1,vR=2,z$=3,G5=4,XMt=1e-6});var tEt=M(()=>{QMt()});function rEt(){for(var e=0,t=arguments.length,r={},n;e<t;++e){if(!(n=arguments[e]+"")||n in r||/[\s.]/.test(n))throw new Error("illegal type: "+n);r[n]=[]}return new bR(r)}function bR(e){this._=e}function B5e(e,t){return e.trim().split(/^|\s+/).map(function(r){var n="",i=r.indexOf(".");if(i>=0&&(n=r.slice(i+1),r=r.slice(0,i)),r&&!t.hasOwnProperty(r))throw new Error("unknown type: "+r);return{type:r,name:n}})}function H5e(e,t){for(var r=0,n=e.length,i;r<n;++r)if((i=e[r]).name===t)return i.value}function eEt(e,t,r){for(var n=0,i=e.length;n<i;++n)if(e[n].name===t){e[n]=F5e,e=e.slice(0,n).concat(e.slice(n+1));break}return r!=null&&e.push({name:t,value:r}),e}var F5e,W5,nEt=M(()=>{F5e={value:function(){}};bR.prototype=rEt.prototype={constructor:bR,on:function(e,t){var r=this._,n=B5e(e+"",r),i,o=-1,a=n.length;if(arguments.length<2){for(;++o<a;)if((i=(e=n[o]).type)&&(i=H5e(r[i],e.name)))return i;return}if(t!=null&&typeof t!="function")throw new Error("invalid callback: "+t);for(;++o<a;)if(i=(e=n[o]).type)r[i]=eEt(r[i],e.name,t);else if(t==null)for(i in r)r[i]=eEt(r[i],e.name,null);return this},copy:function(){var e={},t=this._;for(var r in t)e[r]=t[r].slice();return new bR(e)},call:function(e,t){if((i=arguments.length-2)>0)for(var r=new Array(i),n=0,i,o;n<i;++n)r[n]=arguments[n+2];if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(o=this._[e],n=0,i=o.length;n<i;++n)o[n].value.apply(t,r)},apply:function(e,t,r){if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(var n=this._[e],i=0,o=n.length;i<o;++i)n[i].value.apply(t,r)}};W5=rEt});var F$=M(()=>{nEt()});var wR,B$,H$=M(()=>{wR="http://www.w3.org/1999/xhtml",B$={svg:"http://www.w3.org/2000/svg",xhtml:wR,xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/"}});function Vp(e){var t=e+="",r=t.indexOf(":");return r>=0&&(t=e.slice(0,r))!=="xmlns"&&(e=e.slice(r+1)),B$.hasOwnProperty(t)?{space:B$[t],local:e}:e}var SR=M(()=>{H$()});function V5e(e){return function(){var t=this.ownerDocument,r=this.namespaceURI;return r===wR&&t.documentElement.namespaceURI===wR?t.createElement(e):t.createElementNS(r,e)}}function U5e(e){return function(){return this.ownerDocument.createElementNS(e.space,e.local)}}function MR(e){var t=Vp(e);return(t.local?U5e:V5e)(t)}var V$=M(()=>{SR();H$()});function q5e(){}function my(e){return e==null?q5e:function(){return this.querySelector(e)}}var ER=M(()=>{});function iEt(e){typeof e!="function"&&(e=my(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=new Array(a),l,c,u=0;u<a;++u)(l=o[u])&&(c=e.call(l,l.__data__,u,o))&&("__data__"in l&&(c.__data__=l.__data__),s[u]=c);return new fi(n,this._parents)}var oEt=M(()=>{wu();ER()});function G5e(){return[]}function Y5(e){return e==null?G5e:function(){return this.querySelectorAll(e)}}var U$=M(()=>{});function aEt(e){typeof e!="function"&&(e=Y5(e));for(var t=this._groups,r=t.length,n=[],i=[],o=0;o<r;++o)for(var a=t[o],s=a.length,l,c=0;c<s;++c)(l=a[c])&&(n.push(e.call(l,l.__data__,c,a)),i.push(l));return new fi(n,i)}var sEt=M(()=>{wu();U$()});function j5(e){return function(){return this.matches(e)}}var q$=M(()=>{});function lEt(e){typeof e!="function"&&(e=j5(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=[],l,c=0;c<a;++c)(l=o[c])&&e.call(l,l.__data__,c,o)&&s.push(l);return new fi(n,this._parents)}var cEt=M(()=>{wu();q$()});function TR(e){return new Array(e.length)}var G$=M(()=>{});function uEt(){return new fi(this._enter||this._groups.map(TR),this._parents)}function X5(e,t){this.ownerDocument=e.ownerDocument,this.namespaceURI=e.namespaceURI,this._next=null,this._parent=e,this.__data__=t}var W$=M(()=>{G$();wu();X5.prototype={constructor:X5,appendChild:function(e){return this._parent.insertBefore(e,this._next)},insertBefore:function(e,t){return this._parent.insertBefore(e,t)},querySelector:function(e){return this._parent.querySelector(e)},querySelectorAll:function(e){return this._parent.querySelectorAll(e)}}});function hEt(e){return function(){return e}}var fEt=M(()=>{});function W5e(e,t,r,n,i,o){for(var a=0,s,l=t.length,c=o.length;a<c;++a)(s=t[a])?(s.__data__=o[a],n[a]=s):r[a]=new X5(e,o[a]);for(;a<l;++a)(s=t[a])&&(i[a]=s)}function Y5e(e,t,r,n,i,o,a){var s,l,c={},u=t.length,h=o.length,f=new Array(u),p;for(s=0;s<u;++s)(l=t[s])&&(f[s]=p=pEt+a.call(l,l.__data__,s,t),p in c?i[s]=l:c[p]=l);for(s=0;s<h;++s)p=pEt+a.call(e,o[s],s,o),(l=c[p])?(n[s]=l,l.__data__=o[s],c[p]=null):r[s]=new X5(e,o[s]);for(s=0;s<u;++s)(l=t[s])&&c[f[s]]===l&&(i[s]=l)}function dEt(e,t){if(!e)return p=new Array(this.size()),c=-1,this.each(function(P){p[++c]=P}),p;var r=t?Y5e:W5e,n=this._parents,i=this._groups;typeof e!="function"&&(e=hEt(e));for(var o=i.length,a=new Array(o),s=new Array(o),l=new Array(o),c=0;c<o;++c){var u=n[c],h=i[c],f=h.length,p=e.call(u,u&&u.__data__,c,n),d=p.length,g=s[c]=new Array(d),_=a[c]=new Array(d),y=l[c]=new Array(f);r(u,h,g,_,y,p,t);for(var x=0,b=0,S,C;x<d;++x)if(S=g[x]){for(x>=b&&(b=x+1);!(C=_[b])&&++b<d;);S._next=C||null}}return a=new fi(a,n),a._enter=s,a._exit=l,a}var pEt,mEt=M(()=>{wu();W$();fEt();pEt="$"});function gEt(){return new fi(this._exit||this._groups.map(TR),this._parents)}var _Et=M(()=>{G$();wu()});function yEt(e,t,r){var n=this.enter(),i=this,o=this.exit();return n=typeof e=="function"?e(n):n.append(e+""),t!=null&&(i=t(i)),r==null?o.remove():r(o),n&&i?n.merge(i).order():i}var vEt=M(()=>{});function xEt(e){for(var t=this._groups,r=e._groups,n=t.length,i=r.length,o=Math.min(n,i),a=new Array(n),s=0;s<o;++s)for(var l=t[s],c=r[s],u=l.length,h=a[s]=new Array(u),f,p=0;p<u;++p)(f=l[p]||c[p])&&(h[p]=f);for(;s<n;++s)a[s]=t[s];return new fi(a,this._parents)}var bEt=M(()=>{wu()});function wEt(){for(var e=this._groups,t=-1,r=e.length;++t<r;)for(var n=e[t],i=n.length-1,o=n[i],a;--i>=0;)(a=n[i])&&(o&&a.compareDocumentPosition(o)^4&&o.parentNode.insertBefore(a,o),o=a);return this}var SEt=M(()=>{});function MEt(e){e||(e=j5e);function t(h,f){return h&&f?e(h.__data__,f.__data__):!h-!f}for(var r=this._groups,n=r.length,i=new Array(n),o=0;o<n;++o){for(var a=r[o],s=a.length,l=i[o]=new Array(s),c,u=0;u<s;++u)(c=a[u])&&(l[u]=c);l.sort(t)}return new fi(i,this._parents).order()}function j5e(e,t){return e<t?-1:e>t?1:e>=t?0:NaN}var EEt=M(()=>{wu()});function TEt(){var e=arguments[0];return arguments[0]=this,e.apply(null,arguments),this}var CEt=M(()=>{});function AEt(){var e=new Array(this.size()),t=-1;return this.each(function(){e[++t]=this}),e}var PEt=M(()=>{});function IEt(){for(var e=this._groups,t=0,r=e.length;t<r;++t)for(var n=e[t],i=0,o=n.length;i<o;++i){var a=n[i];if(a)return a}return null}var LEt=M(()=>{});function kEt(){var e=0;return this.each(function(){++e}),e}var REt=M(()=>{});function NEt(){return!this.node()}var DEt=M(()=>{});function OEt(e){for(var t=this._groups,r=0,n=t.length;r<n;++r)for(var i=t[r],o=0,a=i.length,s;o<a;++o)(s=i[o])&&e.call(s,s.__data__,o,i);return this}var zEt=M(()=>{});function X5e(e){return function(){this.removeAttribute(e)}}function $5e(e){return function(){this.removeAttributeNS(e.space,e.local)}}function K5e(e,t){return function(){this.setAttribute(e,t)}}function Z5e(e,t){return function(){this.setAttributeNS(e.space,e.local,t)}}function J5e(e,t){return function(){var r=t.apply(this,arguments);r==null?this.removeAttribute(e):this.setAttribute(e,r)}}function Q5e(e,t){return function(){var r=t.apply(this,arguments);r==null?this.removeAttributeNS(e.space,e.local):this.setAttributeNS(e.space,e.local,r)}}function FEt(e,t){var r=Vp(e);if(arguments.length<2){var n=this.node();return r.local?n.getAttributeNS(r.space,r.local):n.getAttribute(r)}return this.each((t==null?r.local?$5e:X5e:typeof t=="function"?r.local?Q5e:J5e:r.local?Z5e:K5e)(r,t))}var BEt=M(()=>{SR()});function CR(e){return e.ownerDocument&&e.ownerDocument.defaultView||e.document&&e||e.defaultView}var Y$=M(()=>{});function tTe(e){return function(){this.style.removeProperty(e)}}function eTe(e,t,r){return function(){this.style.setProperty(e,t,r)}}function rTe(e,t,r){return function(){var n=t.apply(this,arguments);n==null?this.style.removeProperty(e):this.style.setProperty(e,n,r)}}function HEt(e,t,r){return arguments.length>1?this.each((t==null?tTe:typeof t=="function"?rTe:eTe)(e,t,r==null?"":r)):ag(this.node(),e)}function ag(e,t){return e.style.getPropertyValue(t)||CR(e).getComputedStyle(e,null).getPropertyValue(t)}var j$=M(()=>{Y$()});function nTe(e){return function(){delete this[e]}}function iTe(e,t){return function(){this[e]=t}}function oTe(e,t){return function(){var r=t.apply(this,arguments);r==null?delete this[e]:this[e]=r}}function VEt(e,t){return arguments.length>1?this.each((t==null?nTe:typeof t=="function"?oTe:iTe)(e,t)):this.node()[e]}var UEt=M(()=>{});function qEt(e){return e.trim().split(/^|\s+/)}function X$(e){return e.classList||new GEt(e)}function GEt(e){this._node=e,this._names=qEt(e.getAttribute("class")||"")}function WEt(e,t){for(var r=X$(e),n=-1,i=t.length;++n<i;)r.add(t[n])}function YEt(e,t){for(var r=X$(e),n=-1,i=t.length;++n<i;)r.remove(t[n])}function aTe(e){return function(){WEt(this,e)}}function sTe(e){return function(){YEt(this,e)}}function lTe(e,t){return function(){(t.apply(this,arguments)?WEt:YEt)(this,e)}}function jEt(e,t){var r=qEt(e+"");if(arguments.length<2){for(var n=X$(this.node()),i=-1,o=r.length;++i<o;)if(!n.contains(r[i]))return!1;return!0}return this.each((typeof t=="function"?lTe:t?aTe:sTe)(r,t))}var XEt=M(()=>{GEt.prototype={add:function(e){var t=this._names.indexOf(e);t<0&&(this._names.push(e),this._node.setAttribute("class",this._names.join(" ")))},remove:function(e){var t=this._names.indexOf(e);t>=0&&(this._names.splice(t,1),this._node.setAttribute("class",this._names.join(" ")))},contains:function(e){return this._names.indexOf(e)>=0}}});function cTe(){this.textContent=""}function uTe(e){return function(){this.textContent=e}}function hTe(e){return function(){var t=e.apply(this,arguments);this.textContent=t==null?"":t}}function $Et(e){return arguments.length?this.each(e==null?cTe:(typeof e=="function"?hTe:uTe)(e)):this.node().textContent}var KEt=M(()=>{});function fTe(){this.innerHTML=""}function pTe(e){return function(){this.innerHTML=e}}function dTe(e){return function(){var t=e.apply(this,arguments);this.innerHTML=t==null?"":t}}function ZEt(e){return arguments.length?this.each(e==null?fTe:(typeof e=="function"?dTe:pTe)(e)):this.node().innerHTML}var JEt=M(()=>{});function mTe(){this.nextSibling&&this.parentNode.appendChild(this)}function QEt(){return this.each(mTe)}var t5t=M(()=>{});function gTe(){this.previousSibling&&this.parentNode.insertBefore(this,this.parentNode.firstChild)}function e5t(){return this.each(gTe)}var r5t=M(()=>{});function n5t(e){var t=typeof e=="function"?e:MR(e);return this.select(function(){return this.appendChild(t.apply(this,arguments))})}var i5t=M(()=>{V$()});function _Te(){return null}function o5t(e,t){var r=typeof e=="function"?e:MR(e),n=t==null?_Te:typeof t=="function"?t:my(t);return this.select(function(){return this.insertBefore(r.apply(this,arguments),n.apply(this,arguments)||null)})}var a5t=M(()=>{V$();ER()});function yTe(){var e=this.parentNode;e&&e.removeChild(this)}function s5t(){return this.each(yTe)}var l5t=M(()=>{});function vTe(){var e=this.cloneNode(!1),t=this.parentNode;return t?t.insertBefore(e,this.nextSibling):e}function xTe(){var e=this.cloneNode(!0),t=this.parentNode;return t?t.insertBefore(e,this.nextSibling):e}function c5t(e){return this.select(e?xTe:vTe)}var u5t=M(()=>{});function h5t(e){return arguments.length?this.property("__data__",e):this.node().__data__}var f5t=M(()=>{});function bTe(e,t,r){return e=m5t(e,t,r),function(n){var i=n.relatedTarget;(!i||i!==this&&!(i.compareDocumentPosition(this)&8))&&e.call(this,n)}}function m5t(e,t,r){return function(n){var i=wr;wr=n;try{e.call(this,this.__data__,t,r)}finally{wr=i}}}function wTe(e){return e.trim().split(/^|\s+/).map(function(t){var r="",n=t.indexOf(".");return n>=0&&(r=t.slice(n+1),t=t.slice(0,n)),{type:t,name:r}})}function STe(e){return function(){var t=this.__on;if(!!t){for(var r=0,n=-1,i=t.length,o;r<i;++r)o=t[r],(!e.type||o.type===e.type)&&o.name===e.name?this.removeEventListener(o.type,o.listener,o.capture):t[++n]=o;++n?t.length=n:delete this.__on}}}function MTe(e,t,r){var n=d5t.hasOwnProperty(e.type)?bTe:m5t;return function(i,o,a){var s=this.__on,l,c=n(t,o,a);if(s){for(var u=0,h=s.length;u<h;++u)if((l=s[u]).type===e.type&&l.name===e.name){this.removeEventListener(l.type,l.listener,l.capture),this.addEventListener(l.type,l.listener=c,l.capture=r),l.value=t;return}}this.addEventListener(e.type,c,r),l={type:e.type,name:e.name,value:t,listener:c,capture:r},s?s.push(l):this.__on=[l]}}function g5t(e,t,r){var n=wTe(e+""),i,o=n.length,a;if(arguments.length<2){var s=this.node().__on;if(s){for(var l=0,c=s.length,u;l<c;++l)for(i=0,u=s[l];i<o;++i)if((a=n[i]).type===u.type&&a.name===u.name)return u.value}return}for(s=t?MTe:STe,r==null&&(r=!1),i=0;i<o;++i)this.each(s(n[i],t,r));return this}function $$(e,t,r,n){var i=wr;e.sourceEvent=wr,wr=e;try{return t.apply(r,n)}finally{wr=i}}var d5t,wr,p5t,AR=M(()=>{d5t={},wr=null;typeof document!="undefined"&&(p5t=document.documentElement,"onmouseenter"in p5t||(d5t={mouseenter:"mouseover",mouseleave:"mouseout"}))});function _5t(e,t,r){var n=CR(e),i=n.CustomEvent;typeof i=="function"?i=new i(t,r):(i=n.document.createEvent("Event"),r?(i.initEvent(t,r.bubbles,r.cancelable),i.detail=r.detail):i.initEvent(t,!1,!1)),e.dispatchEvent(i)}function ETe(e,t){return function(){return _5t(this,e,t)}}function TTe(e,t){return function(){return _5t(this,e,t.apply(this,arguments))}}function y5t(e,t){return this.each((typeof t=="function"?TTe:ETe)(e,t))}var v5t=M(()=>{Y$()});function fi(e,t){this._groups=e,this._parents=t}function x5t(){return new fi([[document.documentElement]],K$)}var K$,Up,wu=M(()=>{oEt();sEt();cEt();mEt();W$();_Et();vEt();bEt();SEt();EEt();CEt();PEt();LEt();REt();DEt();zEt();BEt();j$();UEt();XEt();KEt();JEt();t5t();r5t();i5t();a5t();l5t();u5t();f5t();AR();v5t();K$=[null];fi.prototype=x5t.prototype={constructor:fi,select:iEt,selectAll:aEt,filter:lEt,data:dEt,enter:uEt,exit:gEt,join:yEt,merge:xEt,order:wEt,sort:MEt,call:TEt,nodes:AEt,node:IEt,size:kEt,empty:NEt,each:OEt,attr:FEt,style:HEt,property:VEt,classed:jEt,text:$Et,html:ZEt,raise:QEt,lower:e5t,append:n5t,insert:o5t,remove:s5t,clone:c5t,datum:h5t,on:g5t,dispatch:y5t};Up=x5t});function qp(e){return typeof e=="string"?new fi([[document.querySelector(e)]],[document.documentElement]):new fi([[e]],K$)}var b5t=M(()=>{wu()});function w5t(){for(var e=wr,t;t=e.sourceEvent;)e=t;return e}var S5t=M(()=>{AR()});function M5t(e,t){var r=e.ownerSVGElement||e;if(r.createSVGPoint){var n=r.createSVGPoint();return n.x=t.clientX,n.y=t.clientY,n=n.matrixTransform(e.getScreenCTM().inverse()),[n.x,n.y]}var i=e.getBoundingClientRect();return[t.clientX-i.left-e.clientLeft,t.clientY-i.top-e.clientTop]}var E5t=M(()=>{});function PR(e){var t=w5t();return t.changedTouches&&(t=t.changedTouches[0]),M5t(e,t)}var T5t=M(()=>{S5t();E5t()});var Es=M(()=>{q$();T5t();SR();b5t();wu();ER();U$();j$();AR()});function IR(){wr.preventDefault(),wr.stopImmediatePropagation()}var C5t=M(()=>{Es()});function Z$(e){var t=e.document.documentElement,r=qp(e).on("dragstart.drag",IR,!0);"onselectstart"in t?r.on("selectstart.drag",IR,!0):(t.__noselect=t.style.MozUserSelect,t.style.MozUserSelect="none")}function J$(e,t){var r=e.document.documentElement,n=qp(e).on("dragstart.drag",null);t&&(n.on("click.drag",IR,!0),setTimeout(function(){n.on("click.drag",null)},0)),"onselectstart"in r?n.on("selectstart.drag",null):(r.style.MozUserSelect=r.__noselect,delete r.__noselect)}var A5t=M(()=>{Es();C5t()});var P5t=M(()=>{A5t()});function LR(e,t,r){e.prototype=t.prototype=r,r.constructor=e}function Q$(e,t){var r=Object.create(e.prototype);for(var n in t)r[n]=t[n];return r}var I5t=M(()=>{});function Z5(){}function k5t(){return this.rgb().formatHex()}function NTe(){return F5t(this).formatHsl()}function R5t(){return this.rgb().formatRgb()}function Su(e){var t,r;return e=(e+"").trim().toLowerCase(),(t=CTe.exec(e))?(r=t[1].length,t=parseInt(t[1],16),r===6?N5t(t):r===3?new sl(t>>8&15|t>>4&240,t>>4&15|t&240,(t&15)<<4|t&15,1):r===8?kR(t>>24&255,t>>16&255,t>>8&255,(t&255)/255):r===4?kR(t>>12&15|t>>8&240,t>>8&15|t>>4&240,t>>4&15|t&240,((t&15)<<4|t&15)/255):null):(t=ATe.exec(e))?new sl(t[1],t[2],t[3],1):(t=PTe.exec(e))?new sl(t[1]*255/100,t[2]*255/100,t[3]*255/100,1):(t=ITe.exec(e))?kR(t[1],t[2],t[3],t[4]):(t=LTe.exec(e))?kR(t[1]*255/100,t[2]*255/100,t[3]*255/100,t[4]):(t=kTe.exec(e))?z5t(t[1],t[2]/100,t[3]/100,1):(t=RTe.exec(e))?z5t(t[1],t[2]/100,t[3]/100,t[4]):L5t.hasOwnProperty(e)?N5t(L5t[e]):e==="transparent"?new sl(NaN,NaN,NaN,0):null}function N5t(e){return new sl(e>>16&255,e>>8&255,e&255,1)}function kR(e,t,r,n){return n<=0&&(e=t=r=NaN),new sl(e,t,r,n)}function DTe(e){return e instanceof Z5||(e=Su(e)),e?(e=e.rgb(),new sl(e.r,e.g,e.b,e.opacity)):new sl}function u2(e,t,r,n){return arguments.length===1?DTe(e):new sl(e,t,r,n==null?1:n)}function sl(e,t,r,n){this.r=+e,this.g=+t,this.b=+r,this.opacity=+n}function D5t(){return"#"+tK(this.r)+tK(this.g)+tK(this.b)}function O5t(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"rgb(":"rgba(")+Math.max(0,Math.min(255,Math.round(this.r)||0))+", "+Math.max(0,Math.min(255,Math.round(this.g)||0))+", "+Math.max(0,Math.min(255,Math.round(this.b)||0))+(e===1?")":", "+e+")")}function tK(e){return e=Math.max(0,Math.min(255,Math.round(e)||0)),(e<16?"0":"")+e.toString(16)}function z5t(e,t,r,n){return n<=0?e=t=r=NaN:r<=0||r>=1?e=t=NaN:t<=0&&(e=NaN),new Kh(e,t,r,n)}function F5t(e){if(e instanceof Kh)return new Kh(e.h,e.s,e.l,e.opacity);if(e instanceof Z5||(e=Su(e)),!e)return new Kh;if(e instanceof Kh)return e;e=e.rgb();var t=e.r/255,r=e.g/255,n=e.b/255,i=Math.min(t,r,n),o=Math.max(t,r,n),a=NaN,s=o-i,l=(o+i)/2;return s?(t===o?a=(r-n)/s+(r<n)*6:r===o?a=(n-t)/s+2:a=(t-r)/s+4,s/=l<.5?o+i:2-o-i,a*=60):s=l>0&&l<1?0:a,new Kh(a,s,l,e.opacity)}function B5t(e,t,r,n){return arguments.length===1?F5t(e):new Kh(e,t,r,n==null?1:n)}function Kh(e,t,r,n){this.h=+e,this.s=+t,this.l=+r,this.opacity=+n}function eK(e,t,r){return(e<60?t+(r-t)*e/60:e<180?r:e<240?t+(r-t)*(240-e)/60:t)*255}var $5,RR,c2,K5,Zh,CTe,ATe,PTe,ITe,LTe,kTe,RTe,L5t,H5t=M(()=>{I5t();$5=.7,RR=1/$5,c2="\\s*([+-]?\\d+)\\s*",K5="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",Zh="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",CTe=/^#([0-9a-f]{3,8})$/,ATe=new RegExp("^rgb\\("+[c2,c2,c2]+"\\)$"),PTe=new RegExp("^rgb\\("+[Zh,Zh,Zh]+"\\)$"),ITe=new RegExp("^rgba\\("+[c2,c2,c2,K5]+"\\)$"),LTe=new RegExp("^rgba\\("+[Zh,Zh,Zh,K5]+"\\)$"),kTe=new RegExp("^hsl\\("+[K5,Zh,Zh]+"\\)$"),RTe=new RegExp("^hsla\\("+[K5,Zh,Zh,K5]+"\\)$"),L5t={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};LR(Z5,Su,{copy:function(e){return Object.assign(new this.constructor,this,e)},displayable:function(){return this.rgb().displayable()},hex:k5t,formatHex:k5t,formatHsl:NTe,formatRgb:R5t,toString:R5t});LR(sl,u2,Q$(Z5,{brighter:function(e){return e=e==null?RR:Math.pow(RR,e),new sl(this.r*e,this.g*e,this.b*e,this.opacity)},darker:function(e){return e=e==null?$5:Math.pow($5,e),new sl(this.r*e,this.g*e,this.b*e,this.opacity)},rgb:function(){return this},displayable:function(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:D5t,formatHex:D5t,formatRgb:O5t,toString:O5t}));LR(Kh,B5t,Q$(Z5,{brighter:function(e){return e=e==null?RR:Math.pow(RR,e),new Kh(this.h,this.s,this.l*e,this.opacity)},darker:function(e){return e=e==null?$5:Math.pow($5,e),new Kh(this.h,this.s,this.l*e,this.opacity)},rgb:function(){var e=this.h%360+(this.h<0)*360,t=isNaN(e)||isNaN(this.s)?0:this.s,r=this.l,n=r+(r<.5?r:1-r)*t,i=2*r-n;return new sl(eK(e>=240?e-240:e+120,i,n),eK(e,i,n),eK(e<120?e+240:e-120,i,n),this.opacity)},displayable:function(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl:function(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"hsl(":"hsla(")+(this.h||0)+", "+(this.s||0)*100+"%, "+(this.l||0)*100+"%"+(e===1?")":", "+e+")")}}))});var NR=M(()=>{H5t()});function rK(e,t,r,n,i){var o=e*e,a=o*e;return((1-3*e+3*o-a)*t+(4-6*o+3*a)*r+(1+3*e+3*o-3*a)*n+a*i)/6}function V5t(e){var t=e.length-1;return function(r){var n=r<=0?r=0:r>=1?(r=1,t-1):Math.floor(r*t),i=e[n],o=e[n+1],a=n>0?e[n-1]:2*i-o,s=n<t-1?e[n+2]:2*o-i;return rK((r-n/t)*t,a,i,o,s)}}var nK=M(()=>{});function U5t(e){var t=e.length;return function(r){var n=Math.floor(((r%=1)<0?++r:r)*t),i=e[(n+t-1)%t],o=e[n%t],a=e[(n+1)%t],s=e[(n+2)%t];return rK((r-n/t)*t,i,o,a,s)}}var q5t=M(()=>{nK()});function J5(e){return function(){return e}}var iK=M(()=>{});function OTe(e,t){return function(r){return e+r*t}}function zTe(e,t,r){return e=Math.pow(e,r),t=Math.pow(t,r)-e,r=1/r,function(n){return Math.pow(e+n*t,r)}}function G5t(e){return(e=+e)==1?DR:function(t,r){return r-t?zTe(t,r,e):J5(isNaN(t)?r:t)}}function DR(e,t){var r=t-e;return r?OTe(e,r):J5(isNaN(e)?t:e)}var W5t=M(()=>{iK()});function Y5t(e){return function(t){var r=t.length,n=new Array(r),i=new Array(r),o=new Array(r),a,s;for(a=0;a<r;++a)s=u2(t[a]),n[a]=s.r||0,i[a]=s.g||0,o[a]=s.b||0;return n=e(n),i=e(i),o=e(o),s.opacity=1,function(l){return s.r=n(l),s.g=i(l),s.b=o(l),s+""}}}var gy,FTe,BTe,oK=M(()=>{NR();nK();q5t();W5t();gy=function e(t){var r=G5t(t);function n(i,o){var a=r((i=u2(i)).r,(o=u2(o)).r),s=r(i.g,o.g),l=r(i.b,o.b),c=DR(i.opacity,o.opacity);return function(u){return i.r=a(u),i.g=s(u),i.b=l(u),i.opacity=c(u),i+""}}return n.gamma=e,n}(1);FTe=Y5t(V5t),BTe=Y5t(U5t)});function j5t(e,t){t||(t=[]);var r=e?Math.min(t.length,e.length):0,n=t.slice(),i;return function(o){for(i=0;i<r;++i)n[i]=e[i]*(1-o)+t[i]*o;return n}}function X5t(e){return ArrayBuffer.isView(e)&&!(e instanceof DataView)}var $5t=M(()=>{});function K5t(e,t){var r=t?t.length:0,n=e?Math.min(r,e.length):0,i=new Array(n),o=new Array(r),a;for(a=0;a<n;++a)i[a]=_y(e[a],t[a]);for(;a<r;++a)o[a]=t[a];return function(s){for(a=0;a<n;++a)o[a]=i[a](s);return o}}var Z5t=M(()=>{OR()});function J5t(e,t){var r=new Date;return e=+e,t=+t,function(n){return r.setTime(e*(1-n)+t*n),r}}var Q5t=M(()=>{});function Ua(e,t){return e=+e,t=+t,function(r){return e*(1-r)+t*r}}var Q5=M(()=>{});function tTt(e,t){var r={},n={},i;(e===null||typeof e!="object")&&(e={}),(t===null||typeof t!="object")&&(t={});for(i in t)i in e?r[i]=_y(e[i],t[i]):n[i]=t[i];return function(o){for(i in r)n[i]=r[i](o);return n}}var eTt=M(()=>{OR()});function HTe(e){return function(){return e}}function VTe(e){return function(t){return e(t)+""}}function tT(e,t){var r=sK.lastIndex=aK.lastIndex=0,n,i,o,a=-1,s=[],l=[];for(e=e+"",t=t+"";(n=sK.exec(e))&&(i=aK.exec(t));)(o=i.index)>r&&(o=t.slice(r,o),s[a]?s[a]+=o:s[++a]=o),(n=n[0])===(i=i[0])?s[a]?s[a]+=i:s[++a]=i:(s[++a]=null,l.push({i:a,x:Ua(n,i)})),r=aK.lastIndex;return r<t.length&&(o=t.slice(r),s[a]?s[a]+=o:s[++a]=o),s.length<2?l[0]?VTe(l[0].x):HTe(t):(t=l.length,function(c){for(var u=0,h;u<t;++u)s[(h=l[u]).i]=h.x(c);return s.join("")})}var sK,aK,lK=M(()=>{Q5();sK=/[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,aK=new RegExp(sK.source,"g")});function _y(e,t){var r=typeof t,n;return t==null||r==="boolean"?J5(t):(r==="number"?Ua:r==="string"?(n=Su(t))?(t=n,gy):tT:t instanceof Su?gy:t instanceof Date?J5t:X5t(t)?j5t:Array.isArray(t)?K5t:typeof t.valueOf!="function"&&typeof t.toString!="function"||isNaN(t)?tTt:Ua)(e,t)}var OR=M(()=>{NR();oK();Z5t();Q5t();Q5();eTt();lK();iK();$5t()});function cK(e,t,r,n,i,o){var a,s,l;return(a=Math.sqrt(e*e+t*t))&&(e/=a,t/=a),(l=e*r+t*n)&&(r-=e*l,n-=t*l),(s=Math.sqrt(r*r+n*n))&&(r/=s,n/=s,l/=s),e*n<t*r&&(e=-e,t=-t,l=-l,a=-a),{translateX:i,translateY:o,rotate:Math.atan2(t,e)*rTt,skewX:Math.atan(l)*rTt,scaleX:a,scaleY:s}}var rTt,zR,nTt=M(()=>{rTt=180/Math.PI,zR={translateX:0,translateY:0,rotate:0,skewX:0,scaleX:1,scaleY:1}});function oTt(e){return e==="none"?zR:(eT||(eT=document.createElement("DIV"),uK=document.documentElement,iTt=document.defaultView),eT.style.transform=e,e=iTt.getComputedStyle(uK.appendChild(eT),null).getPropertyValue("transform"),uK.removeChild(eT),e=e.slice(7,-1).split(","),cK(+e[0],+e[1],+e[2],+e[3],+e[4],+e[5]))}function aTt(e){return e==null?zR:(FR||(FR=document.createElementNS("http://www.w3.org/2000/svg","g")),FR.setAttribute("transform",e),(e=FR.transform.baseVal.consolidate())?(e=e.matrix,cK(e.a,e.b,e.c,e.d,e.e,e.f)):zR)}var eT,uK,iTt,FR,sTt=M(()=>{nTt()});function lTt(e,t,r,n){function i(c){return c.length?c.pop()+" ":""}function o(c,u,h,f,p,d){if(c!==h||u!==f){var g=p.push("translate(",null,t,null,r);d.push({i:g-4,x:Ua(c,h)},{i:g-2,x:Ua(u,f)})}else(h||f)&&p.push("translate("+h+t+f+r)}function a(c,u,h,f){c!==u?(c-u>180?u+=360:u-c>180&&(c+=360),f.push({i:h.push(i(h)+"rotate(",null,n)-2,x:Ua(c,u)})):u&&h.push(i(h)+"rotate("+u+n)}function s(c,u,h,f){c!==u?f.push({i:h.push(i(h)+"skewX(",null,n)-2,x:Ua(c,u)}):u&&h.push(i(h)+"skewX("+u+n)}function l(c,u,h,f,p,d){if(c!==h||u!==f){var g=p.push(i(p)+"scale(",null,",",null,")");d.push({i:g-4,x:Ua(c,h)},{i:g-2,x:Ua(u,f)})}else(h!==1||f!==1)&&p.push(i(p)+"scale("+h+","+f+")")}return function(c,u){var h=[],f=[];return c=e(c),u=e(u),o(c.translateX,c.translateY,u.translateX,u.translateY,h,f),a(c.rotate,u.rotate,h,f),s(c.skewX,u.skewX,h,f),l(c.scaleX,c.scaleY,u.scaleX,u.scaleY,h,f),c=u=null,function(p){for(var d=-1,g=f.length,_;++d<g;)h[(_=f[d]).i]=_.x(p);return h.join("")}}}var hK,fK,cTt=M(()=>{Q5();sTt();hK=lTt(oTt,"px, ","px)","deg)"),fK=lTt(aTt,", ",")",")")});var rT=M(()=>{OR();Q5();lK();cTt();oK()});function f2(){return yy||(fTt(UTe),yy=aT.now()+VR)}function UTe(){yy=0}function sT(){this._call=this._time=this._next=null}function UR(e,t,r){var n=new sT;return n.restart(e,t,r),n}function pTt(){f2(),++h2;for(var e=BR,t;e;)(t=yy-e._time)>=0&&e._call.call(null,t),e=e._next;--h2}function uTt(){yy=(HR=aT.now())+VR,h2=iT=0;try{pTt()}finally{h2=0,GTe(),yy=0}}function qTe(){var e=aT.now(),t=e-HR;t>hTt&&(VR-=t,HR=e)}function GTe(){for(var e,t=BR,r,n=1/0;t;)t._call?(n>t._time&&(n=t._time),e=t,t=t._next):(r=t._next,t._next=null,t=e?e._next=r:BR=r);oT=e,pK(n)}function pK(e){if(!h2){iT&&(iT=clearTimeout(iT));var t=e-yy;t>24?(e<1/0&&(iT=setTimeout(uTt,e-aT.now()-VR)),nT&&(nT=clearInterval(nT))):(nT||(HR=aT.now(),nT=setInterval(qTe,hTt)),h2=1,fTt(uTt))}}var h2,iT,nT,hTt,BR,oT,HR,yy,VR,aT,fTt,dK=M(()=>{h2=0,iT=0,nT=0,hTt=1e3,HR=0,yy=0,VR=0,aT=typeof performance=="object"&&performance.now?performance:Date,fTt=typeof window=="object"&&window.requestAnimationFrame?window.requestAnimationFrame.bind(window):function(e){setTimeout(e,17)};sT.prototype=UR.prototype={constructor:sT,restart:function(e,t,r){if(typeof e!="function")throw new TypeError("callback is not a function");r=(r==null?f2():+r)+(t==null?0:+t),!this._next&&oT!==this&&(oT?oT._next=this:BR=this,oT=this),this._call=e,this._time=r,pK()},stop:function(){this._call&&(this._call=null,this._time=1/0,pK())}}});function qR(e,t,r){var n=new sT;return t=t==null?0:+t,n.restart(function(i){n.stop(),e(i+t)},t,r),n}var dTt=M(()=>{dK()});var mK=M(()=>{dK();dTt()});function sg(e,t,r,n,i,o){var a=e.__transition;if(!a)e.__transition={};else if(r in a)return;jTe(e,r,{name:t,index:n,group:i,on:WTe,tween:YTe,time:o.time,delay:o.delay,duration:o.duration,ease:o.ease,timer:null,state:gTt})}function cT(e,t){var r=Qi(e,t);if(r.state>gTt)throw new Error("too late; already scheduled");return r}function qa(e,t){var r=Qi(e,t);if(r.state>GR)throw new Error("too late; already running");return r}function Qi(e,t){var r=e.__transition;if(!r||!(r=r[t]))throw new Error("transition not found");return r}function jTe(e,t,r){var n=e.__transition,i;n[t]=r,r.timer=UR(o,0,r.time);function o(c){r.state=gK,r.timer.restart(a,r.delay,r.time),r.delay<=c&&a(c-r.delay)}function a(c){var u,h,f,p;if(r.state!==gK)return l();for(u in n)if(p=n[u],p.name===r.name){if(p.state===GR)return qR(a);p.state===mTt?(p.state=lT,p.timer.stop(),p.on.call("interrupt",e,e.__data__,p.index,p.group),delete n[u]):+u<t&&(p.state=lT,p.timer.stop(),p.on.call("cancel",e,e.__data__,p.index,p.group),delete n[u])}if(qR(function(){r.state===GR&&(r.state=mTt,r.timer.restart(s,r.delay,r.time),s(c))}),r.state=WR,r.on.call("start",e,e.__data__,r.index,r.group),r.state===WR){for(r.state=GR,i=new Array(f=r.tween.length),u=0,h=-1;u<f;++u)(p=r.tween[u].value.call(e,e.__data__,r.index,r.group))&&(i[++h]=p);i.length=h+1}}function s(c){for(var u=c<r.duration?r.ease.call(null,c/r.duration):(r.timer.restart(l),r.state=YR,1),h=-1,f=i.length;++h<f;)i[h].call(e,u);r.state===YR&&(r.on.call("end",e,e.__data__,r.index,r.group),l())}function l(){r.state=lT,r.timer.stop(),delete n[t];for(var c in n)return;delete e.__transition}}var WTe,YTe,gTt,gK,WR,GR,mTt,YR,lT,Ts=M(()=>{F$();mK();WTe=W5("start","end","cancel","interrupt"),YTe=[],gTt=0,gK=1,WR=2,GR=3,mTt=4,YR=5,lT=6});function p2(e,t){var r=e.__transition,n,i,o=!0,a;if(!!r){t=t==null?null:t+"";for(a in r){if((n=r[a]).name!==t){o=!1;continue}i=n.state>WR&&n.state<YR,n.state=lT,n.timer.stop(),n.on.call(i?"interrupt":"cancel",e,e.__data__,n.index,n.group),delete r[a]}o&&delete e.__transition}}var _K=M(()=>{Ts()});function _Tt(e){return this.each(function(){p2(this,e)})}var yTt=M(()=>{_K()});function XTe(e,t){var r,n;return function(){var i=qa(this,e),o=i.tween;if(o!==r){n=r=o;for(var a=0,s=n.length;a<s;++a)if(n[a].name===t){n=n.slice(),n.splice(a,1);break}}i.tween=n}}function $Te(e,t,r){var n,i;if(typeof r!="function")throw new Error;return function(){var o=qa(this,e),a=o.tween;if(a!==n){i=(n=a).slice();for(var s={name:t,value:r},l=0,c=i.length;l<c;++l)if(i[l].name===t){i[l]=s;break}l===c&&i.push(s)}o.tween=i}}function vTt(e,t){var r=this._id;if(e+="",arguments.length<2){for(var n=Qi(this.node(),r).tween,i=0,o=n.length,a;i<o;++i)if((a=n[i]).name===e)return a.value;return null}return this.each((t==null?XTe:$Te)(r,e,t))}function d2(e,t,r){var n=e._id;return e.each(function(){var i=qa(this,n);(i.value||(i.value={}))[t]=r.apply(this,arguments)}),function(i){return Qi(i,n).value[t]}}var uT=M(()=>{Ts()});function jR(e,t){var r;return(typeof t=="number"?Ua:t instanceof Su?gy:(r=Su(t))?(t=r,gy):tT)(e,t)}var yK=M(()=>{NR();rT()});function KTe(e){return function(){this.removeAttribute(e)}}function ZTe(e){return function(){this.removeAttributeNS(e.space,e.local)}}function JTe(e,t,r){var n,i=r+"",o;return function(){var a=this.getAttribute(e);return a===i?null:a===n?o:o=t(n=a,r)}}function QTe(e,t,r){var n,i=r+"",o;return function(){var a=this.getAttributeNS(e.space,e.local);return a===i?null:a===n?o:o=t(n=a,r)}}function tCe(e,t,r){var n,i,o;return function(){var a,s=r(this),l;return s==null?void this.removeAttribute(e):(a=this.getAttribute(e),l=s+"",a===l?null:a===n&&l===i?o:(i=l,o=t(n=a,s)))}}function eCe(e,t,r){var n,i,o;return function(){var a,s=r(this),l;return s==null?void this.removeAttributeNS(e.space,e.local):(a=this.getAttributeNS(e.space,e.local),l=s+"",a===l?null:a===n&&l===i?o:(i=l,o=t(n=a,s)))}}function xTt(e,t){var r=Vp(e),n=r==="transform"?fK:jR;return this.attrTween(e,typeof t=="function"?(r.local?eCe:tCe)(r,n,d2(this,"attr."+e,t)):t==null?(r.local?ZTe:KTe)(r):(r.local?QTe:JTe)(r,n,t))}var bTt=M(()=>{rT();Es();uT();yK()});function rCe(e,t){return function(r){this.setAttribute(e,t.call(this,r))}}function nCe(e,t){return function(r){this.setAttributeNS(e.space,e.local,t.call(this,r))}}function iCe(e,t){var r,n;function i(){var o=t.apply(this,arguments);return o!==n&&(r=(n=o)&&nCe(e,o)),r}return i._value=t,i}function oCe(e,t){var r,n;function i(){var o=t.apply(this,arguments);return o!==n&&(r=(n=o)&&rCe(e,o)),r}return i._value=t,i}function wTt(e,t){var r="attr."+e;if(arguments.length<2)return(r=this.tween(r))&&r._value;if(t==null)return this.tween(r,null);if(typeof t!="function")throw new Error;var n=Vp(e);return this.tween(r,(n.local?iCe:oCe)(n,t))}var STt=M(()=>{Es()});function aCe(e,t){return function(){cT(this,e).delay=+t.apply(this,arguments)}}function sCe(e,t){return t=+t,function(){cT(this,e).delay=t}}function MTt(e){var t=this._id;return arguments.length?this.each((typeof e=="function"?aCe:sCe)(t,e)):Qi(this.node(),t).delay}var ETt=M(()=>{Ts()});function lCe(e,t){return function(){qa(this,e).duration=+t.apply(this,arguments)}}function cCe(e,t){return t=+t,function(){qa(this,e).duration=t}}function TTt(e){var t=this._id;return arguments.length?this.each((typeof e=="function"?lCe:cCe)(t,e)):Qi(this.node(),t).duration}var CTt=M(()=>{Ts()});function uCe(e,t){if(typeof t!="function")throw new Error;return function(){qa(this,e).ease=t}}function ATt(e){var t=this._id;return arguments.length?this.each(uCe(t,e)):Qi(this.node(),t).ease}var PTt=M(()=>{Ts()});function ITt(e){typeof e!="function"&&(e=j5(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=[],l,c=0;c<a;++c)(l=o[c])&&e.call(l,l.__data__,c,o)&&s.push(l);return new ua(n,this._parents,this._name,this._id)}var LTt=M(()=>{Es();Gp()});function kTt(e){if(e._id!==this._id)throw new Error;for(var t=this._groups,r=e._groups,n=t.length,i=r.length,o=Math.min(n,i),a=new Array(n),s=0;s<o;++s)for(var l=t[s],c=r[s],u=l.length,h=a[s]=new Array(u),f,p=0;p<u;++p)(f=l[p]||c[p])&&(h[p]=f);for(;s<n;++s)a[s]=t[s];return new ua(a,this._parents,this._name,this._id)}var RTt=M(()=>{Gp()});function hCe(e){return(e+"").trim().split(/^|\s+/).every(function(t){var r=t.indexOf(".");return r>=0&&(t=t.slice(0,r)),!t||t==="start"})}function fCe(e,t,r){var n,i,o=hCe(t)?cT:qa;return function(){var a=o(this,e),s=a.on;s!==n&&(i=(n=s).copy()).on(t,r),a.on=i}}function NTt(e,t){var r=this._id;return arguments.length<2?Qi(this.node(),r).on.on(e):this.each(fCe(r,e,t))}var DTt=M(()=>{Ts()});function pCe(e){return function(){var t=this.parentNode;for(var r in this.__transition)if(+r!==e)return;t&&t.removeChild(this)}}function OTt(){return this.on("end.remove",pCe(this._id))}var zTt=M(()=>{});function FTt(e){var t=this._name,r=this._id;typeof e!="function"&&(e=my(e));for(var n=this._groups,i=n.length,o=new Array(i),a=0;a<i;++a)for(var s=n[a],l=s.length,c=o[a]=new Array(l),u,h,f=0;f<l;++f)(u=s[f])&&(h=e.call(u,u.__data__,f,s))&&("__data__"in u&&(h.__data__=u.__data__),c[f]=h,sg(c[f],t,r,f,c,Qi(u,r)));return new ua(o,this._parents,t,r)}var BTt=M(()=>{Es();Gp();Ts()});function HTt(e){var t=this._name,r=this._id;typeof e!="function"&&(e=Y5(e));for(var n=this._groups,i=n.length,o=[],a=[],s=0;s<i;++s)for(var l=n[s],c=l.length,u,h=0;h<c;++h)if(u=l[h]){for(var f=e.call(u,u.__data__,h,l),p,d=Qi(u,r),g=0,_=f.length;g<_;++g)(p=f[g])&&sg(p,t,r,g,f,d);o.push(f),a.push(u)}return new ua(o,a,t,r)}var VTt=M(()=>{Es();Gp();Ts()});function UTt(){return new dCe(this._groups,this._parents)}var dCe,qTt=M(()=>{Es();dCe=Up.prototype.constructor});function mCe(e,t){var r,n,i;return function(){var o=ag(this,e),a=(this.style.removeProperty(e),ag(this,e));return o===a?null:o===r&&a===n?i:i=t(r=o,n=a)}}function GTt(e){return function(){this.style.removeProperty(e)}}function gCe(e,t,r){var n,i=r+"",o;return function(){var a=ag(this,e);return a===i?null:a===n?o:o=t(n=a,r)}}function _Ce(e,t,r){var n,i,o;return function(){var a=ag(this,e),s=r(this),l=s+"";return s==null&&(l=s=(this.style.removeProperty(e),ag(this,e))),a===l?null:a===n&&l===i?o:(i=l,o=t(n=a,s))}}function yCe(e,t){var r,n,i,o="style."+t,a="end."+o,s;return function(){var l=qa(this,e),c=l.on,u=l.value[o]==null?s||(s=GTt(t)):void 0;(c!==r||i!==u)&&(n=(r=c).copy()).on(a,i=u),l.on=n}}function WTt(e,t,r){var n=(e+="")=="transform"?hK:jR;return t==null?this.styleTween(e,mCe(e,n)).on("end.style."+e,GTt(e)):typeof t=="function"?this.styleTween(e,_Ce(e,n,d2(this,"style."+e,t))).each(yCe(this._id,e)):this.styleTween(e,gCe(e,n,t),r).on("end.style."+e,null)}var YTt=M(()=>{rT();Es();Ts();uT();yK()});function vCe(e,t,r){return function(n){this.style.setProperty(e,t.call(this,n),r)}}function xCe(e,t,r){var n,i;function o(){var a=t.apply(this,arguments);return a!==i&&(n=(i=a)&&vCe(e,a,r)),n}return o._value=t,o}function jTt(e,t,r){var n="style."+(e+="");if(arguments.length<2)return(n=this.tween(n))&&n._value;if(t==null)return this.tween(n,null);if(typeof t!="function")throw new Error;return this.tween(n,xCe(e,t,r==null?"":r))}var XTt=M(()=>{});function bCe(e){return function(){this.textContent=e}}function wCe(e){return function(){var t=e(this);this.textContent=t==null?"":t}}function $Tt(e){return this.tween("text",typeof e=="function"?wCe(d2(this,"text",e)):bCe(e==null?"":e+""))}var KTt=M(()=>{uT()});function SCe(e){return function(t){this.textContent=e.call(this,t)}}function MCe(e){var t,r;function n(){var i=e.apply(this,arguments);return i!==r&&(t=(r=i)&&SCe(i)),t}return n._value=e,n}function ZTt(e){var t="text";if(arguments.length<1)return(t=this.tween(t))&&t._value;if(e==null)return this.tween(t,null);if(typeof e!="function")throw new Error;return this.tween(t,MCe(e))}var JTt=M(()=>{});function QTt(){for(var e=this._name,t=this._id,r=XR(),n=this._groups,i=n.length,o=0;o<i;++o)for(var a=n[o],s=a.length,l,c=0;c<s;++c)if(l=a[c]){var u=Qi(l,t);sg(l,e,r,c,a,{time:u.time+u.delay+u.duration,delay:0,duration:u.duration,ease:u.ease})}return new ua(n,this._parents,e,r)}var tCt=M(()=>{Gp();Ts()});function eCt(){var e,t,r=this,n=r._id,i=r.size();return new Promise(function(o,a){var s={value:a},l={value:function(){--i===0&&o()}};r.each(function(){var c=qa(this,n),u=c.on;u!==e&&(t=(e=u).copy(),t._.cancel.push(s),t._.interrupt.push(s),t._.end.push(l)),c.on=t})})}var rCt=M(()=>{Ts()});function ua(e,t,r,n){this._groups=e,this._parents=t,this._name=r,this._id=n}function vK(e){return Up().transition(e)}function XR(){return++ECe}var ECe,m2,Gp=M(()=>{Es();bTt();STt();ETt();CTt();PTt();LTt();RTt();DTt();zTt();BTt();VTt();qTt();YTt();XTt();KTt();JTt();tCt();uT();rCt();ECe=0;m2=Up.prototype;ua.prototype=vK.prototype={constructor:ua,select:FTt,selectAll:HTt,filter:ITt,merge:kTt,selection:UTt,transition:QTt,call:m2.call,nodes:m2.nodes,node:m2.node,size:m2.size,empty:m2.empty,each:m2.each,on:NTt,attr:xTt,attrTween:wTt,style:WTt,styleTween:jTt,text:$Tt,textTween:ZTt,remove:OTt,tween:vTt,delay:MTt,duration:TTt,ease:ATt,end:eCt}});function TCe(e,t){for(var r;!(r=e.__transition)||!(r=r[t]);)if(!(e=e.parentNode))return xK.time=f2(),xK;return r}function nCt(e){var t,r;e instanceof ua?(t=e._id,e=e._name):(t=XR(),(r=xK).time=f2(),e=e==null?null:e+"");for(var n=this._groups,i=n.length,o=0;o<i;++o)for(var a=n[o],s=a.length,l,c=0;c<s;++c)(l=a[c])&&sg(l,e,t,c,a,r||TCe(l,t));return new ua(n,this._parents,e,t)}var xK,iCt=M(()=>{Gp();Ts();I_();mK();xK={time:null,delay:0,duration:250,ease:xs}});var oCt=M(()=>{Es();yTt();iCt();Up.prototype.interrupt=_Tt;Up.prototype.transition=nCt});var aCt=M(()=>{Gp();Ts()});var sCt=M(()=>{oCt();Gp();aCt();_K()});function bK(e){return function(){return e}}var lCt=M(()=>{});function cCt(e,t,r){this.target=e,this.type=t,this.selection=r}var uCt=M(()=>{});function wK(){wr.stopImmediatePropagation()}function hT(){wr.preventDefault(),wr.stopImmediatePropagation()}var hCt=M(()=>{Es()});function fT(e){return{type:e}}function ICe(){return!wr.button}function LCe(){var e=this.ownerSVGElement||this;return[[0,0],[e.width.baseVal.value,e.height.baseVal.value]]}function MK(e){for(;!e.__brush;)if(!(e=e.parentNode))return;return e.__brush}function EK(e){return e[0][0]===e[1][0]||e[0][1]===e[1][1]}function mCt(e){var t=e.__brush;return t?t.dim.output(t.selection):null}function gCt(){return TK($R)}function _Ct(){return TK(KR)}function yCt(){return TK(CCe)}function TK(e){var t=LCe,r=ICe,n=W5(a,"start","brush","end"),i=6,o;function a(f){var p=f.property("__brush",h).selectAll(".overlay").data([fT("overlay")]);p.enter().append("rect").attr("class","overlay").attr("pointer-events","all").attr("cursor",Wp.overlay).merge(p).each(function(){var g=MK(this).extent;qp(this).attr("x",g[0][0]).attr("y",g[0][1]).attr("width",g[1][0]-g[0][0]).attr("height",g[1][1]-g[0][1])}),f.selectAll(".selection").data([fT("selection")]).enter().append("rect").attr("class","selection").attr("cursor",Wp.selection).attr("fill","#777").attr("fill-opacity",.3).attr("stroke","#fff").attr("shape-rendering","crispEdges");var d=f.selectAll(".handle").data(e.handles,function(g){return g.type});d.exit().remove(),d.enter().append("rect").attr("class",function(g){return"handle handle--"+g.type}).attr("cursor",function(g){return Wp[g.type]}),f.each(s).attr("fill","none").attr("pointer-events","all").style("-webkit-tap-highlight-color","rgba(0,0,0,0)").on("mousedown.brush touchstart.brush",u)}a.move=function(f,p){f.selection?f.on("start.brush",function(){l(this,arguments).beforestart().start()}).on("interrupt.brush end.brush",function(){l(this,arguments).end()}).tween("brush",function(){var d=this,g=d.__brush,_=l(d,arguments),y=g.selection,x=e.input(typeof p=="function"?p.apply(this,arguments):p,g.extent),b=_y(y,x);function S(C){g.selection=C===1&&EK(x)?null:b(C),s.call(d),_.brush()}return y&&x?S:S(1)}):f.each(function(){var d=this,g=arguments,_=d.__brush,y=e.input(typeof p=="function"?p.apply(d,g):p,_.extent),x=l(d,g).beforestart();p2(d),_.selection=y==null||EK(y)?null:y,s.call(d),x.start().brush().end()})};function s(){var f=qp(this),p=MK(this).selection;p?(f.selectAll(".selection").style("display",null).attr("x",p[0][0]).attr("y",p[0][1]).attr("width",p[1][0]-p[0][0]).attr("height",p[1][1]-p[0][1]),f.selectAll(".handle").style("display",null).attr("x",function(d){return d.type[d.type.length-1]==="e"?p[1][0]-i/2:p[0][0]-i/2}).attr("y",function(d){return d.type[0]==="s"?p[1][1]-i/2:p[0][1]-i/2}).attr("width",function(d){return d.type==="n"||d.type==="s"?p[1][0]-p[0][0]+i:i}).attr("height",function(d){return d.type==="e"||d.type==="w"?p[1][1]-p[0][1]+i:i})):f.selectAll(".selection,.handle").style("display","none").attr("x",null).attr("y",null).attr("width",null).attr("height",null)}function l(f,p){return f.__brush.emitter||new c(f,p)}function c(f,p){this.that=f,this.args=p,this.state=f.__brush,this.active=0}c.prototype={beforestart:function(){return++this.active===1&&(this.state.emitter=this,this.starting=!0),this},start:function(){return this.starting&&(this.starting=!1,this.emit("start")),this},brush:function(){return this.emit("brush"),this},end:function(){return--this.active===0&&(delete this.state.emitter,this.emit("end")),this},emit:function(f){$$(new cCt(a,f,e.output(this.state.selection)),n.apply,n,[f,this.that,this.args])}};function u(){if(wr.touches){if(wr.changedTouches.length<wr.touches.length)return hT()}else if(o)return;if(!r.apply(this,arguments))return;var f=this,p=wr.target.__data__.type,d=(wr.metaKey?p="overlay":p)==="selection"?fCt:wr.altKey?_2:g2,g=e===KR?null:ACe[p],_=e===$R?null:PCe[p],y=MK(f),x=y.extent,b=y.selection,S=x[0][0],C,P,k=x[0][1],O,D,B=x[1][0],I,L,R=x[1][1],F,z,U,W,Z,rt=g&&_&&wr.shiftKey,ot,st,St=PR(f),bt=St,Mt=l(f,arguments).beforestart();p==="overlay"?y.selection=b=[[C=e===KR?S:St[0],O=e===$R?k:St[1]],[I=e===KR?B:C,F=e===$R?R:O]]:(C=b[0][0],O=b[0][1],I=b[1][0],F=b[1][1]),P=C,D=O,L=I,z=F;var lt=qp(f).attr("pointer-events","none"),Kt=lt.selectAll(".overlay").attr("cursor",Wp[p]);if(wr.touches)lt.on("touchmove.brush",ct,!0).on("touchend.brush touchcancel.brush",et,!0);else{var _t=qp(wr.view).on("keydown.brush",dt,!0).on("keyup.brush",q,!0).on("mousemove.brush",ct,!0).on("mouseup.brush",et,!0);Z$(wr.view)}wK(),p2(f),s.call(f),Mt.start();function ct(){var pt=PR(f);rt&&!ot&&!st&&(Math.abs(pt[0]-bt[0])>Math.abs(pt[1]-bt[1])?st=!0:ot=!0),bt=pt,Z=!0,hT(),X()}function X(){var pt;switch(U=bt[0]-St[0],W=bt[1]-St[1],d){case SK:case fCt:{g&&(U=Math.max(S-C,Math.min(B-I,U)),P=C+U,L=I+U),_&&(W=Math.max(k-O,Math.min(R-F,W)),D=O+W,z=F+W);break}case g2:{g<0?(U=Math.max(S-C,Math.min(B-C,U)),P=C+U,L=I):g>0&&(U=Math.max(S-I,Math.min(B-I,U)),P=C,L=I+U),_<0?(W=Math.max(k-O,Math.min(R-O,W)),D=O+W,z=F):_>0&&(W=Math.max(k-F,Math.min(R-F,W)),D=O,z=F+W);break}case _2:{g&&(P=Math.max(S,Math.min(B,C-U*g)),L=Math.max(S,Math.min(B,I+U*g))),_&&(D=Math.max(k,Math.min(R,O-W*_)),z=Math.max(k,Math.min(R,F+W*_)));break}}L<P&&(g*=-1,pt=C,C=I,I=pt,pt=P,P=L,L=pt,p in pCt&&Kt.attr("cursor",Wp[p=pCt[p]])),z<D&&(_*=-1,pt=O,O=F,F=pt,pt=D,D=z,z=pt,p in dCt&&Kt.attr("cursor",Wp[p=dCt[p]])),y.selection&&(b=y.selection),ot&&(P=b[0][0],L=b[1][0]),st&&(D=b[0][1],z=b[1][1]),(b[0][0]!==P||b[0][1]!==D||b[1][0]!==L||b[1][1]!==z)&&(y.selection=[[P,D],[L,z]],s.call(f),Mt.brush())}function et(){if(wK(),wr.touches){if(wr.touches.length)return;o&&clearTimeout(o),o=setTimeout(function(){o=null},500),lt.on("touchmove.brush touchend.brush touchcancel.brush",null)}else J$(wr.view,Z),_t.on("keydown.brush keyup.brush mousemove.brush mouseup.brush",null);lt.attr("pointer-events","all"),Kt.attr("cursor",Wp.overlay),y.selection&&(b=y.selection),EK(b)&&(y.selection=null,s.call(f)),Mt.end()}function dt(){switch(wr.keyCode){case 16:{rt=g&&_;break}case 18:{d===g2&&(g&&(I=L-U*g,C=P+U*g),_&&(F=z-W*_,O=D+W*_),d=_2,X());break}case 32:{(d===g2||d===_2)&&(g<0?I=L-U:g>0&&(C=P-U),_<0?F=z-W:_>0&&(O=D-W),d=SK,Kt.attr("cursor",Wp.selection),X());break}default:return}hT()}function q(){switch(wr.keyCode){case 16:{rt&&(ot=st=rt=!1,X());break}case 18:{d===_2&&(g<0?I=L:g>0&&(C=P),_<0?F=z:_>0&&(O=D),d=g2,X());break}case 32:{d===SK&&(wr.altKey?(g&&(I=L-U*g,C=P+U*g),_&&(F=z-W*_,O=D+W*_),d=_2):(g<0?I=L:g>0&&(C=P),_<0?F=z:_>0&&(O=D),d=g2),Kt.attr("cursor",Wp[p]),X());break}default:return}hT()}}function h(){var f=this.__brush||{selection:null};return f.extent=t.apply(this,arguments),f.dim=e,f}return a.extent=function(f){return arguments.length?(t=typeof f=="function"?f:bK([[+f[0][0],+f[0][1]],[+f[1][0],+f[1][1]]]),a):t},a.filter=function(f){return arguments.length?(r=typeof f=="function"?f:bK(!!f),a):r},a.handleSize=function(f){return arguments.length?(i=+f,a):i},a.on=function(){var f=n.on.apply(n,arguments);return f===n?a:f},a}var fCt,SK,g2,_2,$R,KR,CCe,Wp,pCt,dCt,ACe,PCe,vCt=M(()=>{F$();P5t();rT();Es();sCt();lCt();uCt();hCt();fCt={name:"drag"},SK={name:"space"},g2={name:"handle"},_2={name:"center"},$R={name:"x",handles:["e","w"].map(fT),input:function(e,t){return e&&[[e[0],t[0][1]],[e[1],t[1][1]]]},output:function(e){return e&&[e[0][0],e[1][0]]}},KR={name:"y",handles:["n","s"].map(fT),input:function(e,t){return e&&[[t[0][0],e[0]],[t[1][0],e[1]]]},output:function(e){return e&&[e[0][1],e[1][1]]}},CCe={name:"xy",handles:["n","e","s","w","nw","ne","se","sw"].map(fT),input:function(e){return e},output:function(e){return e}},Wp={overlay:"crosshair",selection:"move",n:"ns-resize",e:"ew-resize",s:"ns-resize",w:"ew-resize",nw:"nwse-resize",ne:"nesw-resize",se:"nwse-resize",sw:"nesw-resize"},pCt={e:"w",w:"e",nw:"ne",ne:"nw",se:"sw",sw:"se"},dCt={n:"s",s:"n",nw:"sw",ne:"se",se:"ne",sw:"nw"},ACe={overlay:1,selection:1,n:null,e:1,s:null,w:-1,nw:-1,ne:1,se:1,sw:-1},PCe={overlay:1,selection:1,n:-1,e:null,s:1,w:null,nw:-1,ne:-1,se:1,sw:1}});var xCt=M(()=>{vCt()});function lg(e,t){return e<t?-1:e>t?1:e>=t?0:NaN}var vy=M(()=>{});function CK(e){return e.length===1&&(e=kCe(e)),{left:function(t,r,n,i){for(n==null&&(n=0),i==null&&(i=t.length);n<i;){var o=n+i>>>1;e(t[o],r)<0?n=o+1:i=o}return n},right:function(t,r,n,i){for(n==null&&(n=0),i==null&&(i=t.length);n<i;){var o=n+i>>>1;e(t[o],r)>0?i=o:n=o+1}return n}}}function kCe(e){return function(t,r){return lg(e(t),r)}}var AK=M(()=>{vy()});var bCt,RCe,NCe,PK=M(()=>{vy();AK();bCt=CK(lg),RCe=bCt.right,NCe=bCt.left});var IK=M(()=>{});var wCt=M(()=>{IK()});var SCt=M(()=>{});var y2=M(()=>{});var LK=M(()=>{y2()});var kK=M(()=>{LK()});var RK=M(()=>{});var MCt,OCe,zCe,NK=M(()=>{MCt=Array.prototype,OCe=MCt.slice,zCe=MCt.map});var ECt=M(()=>{});var TCt=M(()=>{});function pT(e,t,r){e=+e,t=+t,r=(i=arguments.length)<2?(t=e,e=0,1):i<3?1:+r;for(var n=-1,i=Math.max(0,Math.ceil((t-e)/r))|0,o=new Array(i);++n<i;)o[n]=e+n*r;return o}var DK=M(()=>{});var Sln,Mln,Eln,OK=M(()=>{Sln=Math.sqrt(50),Mln=Math.sqrt(10),Eln=Math.sqrt(2)});var zK=M(()=>{});var CCt=M(()=>{NK();PK();ECt();RK();TCt();DK();OK();zK()});var JR=M(()=>{y2()});var PCt=M(()=>{NK();vy();y2();JR()});var ICt=M(()=>{kK()});var LCt=M(()=>{});var kCt=M(()=>{y2()});var RCt=M(()=>{vy();y2();JR()});var NCt=M(()=>{});var FK=M(()=>{});var DCt=M(()=>{});var OCt=M(()=>{vy()});var zCt=M(()=>{});var FCt=M(()=>{});var BK=M(()=>{FK()});var BCt=M(()=>{BK()});var HCt=M(()=>{PK();vy();AK();wCt();SCt();kK();RK();CCt();PCt();ICt();zK();LCt();kCt();RCt();NCt();FK();IK();DCt();JR();DK();OCt();zCt();FCt();OK();BK();LK();BCt()});var HK,VK,VCt,dT,UK,qK,GK=M(()=>{HK=Math.cos,VK=Math.sin,VCt=Math.PI,dT=VCt/2,UK=VCt*2,qK=Math.max});function WCe(e){return function(t,r){return e(t.source.value+t.target.value,r.source.value+r.target.value)}}function UCt(){var e=0,t=null,r=null,n=null;function i(o){var a=o.length,s=[],l=pT(a),c=[],u=[],h=u.groups=new Array(a),f=new Array(a*a),p,d,g,_,y,x;for(p=0,y=-1;++y<a;){for(d=0,x=-1;++x<a;)d+=o[y][x];s.push(d),c.push(pT(a)),p+=d}for(t&&l.sort(function(B,I){return t(s[B],s[I])}),r&&c.forEach(function(B,I){B.sort(function(L,R){return r(o[I][L],o[I][R])})}),p=qK(0,UK-e*a)/p,_=p?e:UK/a,d=0,y=-1;++y<a;){for(g=d,x=-1;++x<a;){var b=l[y],S=c[b][x],C=o[b][S],P=d,k=d+=C*p;f[S*a+b]={index:b,subindex:S,startAngle:P,endAngle:k,value:C}}h[b]={index:b,startAngle:g,endAngle:d,value:s[b]},d+=_}for(y=-1;++y<a;)for(x=y-1;++x<a;){var O=f[x*a+y],D=f[y*a+x];(O.value||D.value)&&u.push(O.value<D.value?{source:D,target:O}:{source:O,target:D})}return n?u.sort(n):u}return i.padAngle=function(o){return arguments.length?(e=qK(0,o),i):e},i.sortGroups=function(o){return arguments.length?(t=o,i):t},i.sortSubgroups=function(o){return arguments.length?(r=o,i):r},i.sortChords=function(o){return arguments.length?(o==null?n=null:(n=WCe(o))._=o,i):n&&n._},i}var qCt=M(()=>{HCt();GK()});var GCt,WCt=M(()=>{GCt=Array.prototype.slice});function QR(e){return function(){return e}}var YCt=M(()=>{});function jK(){this._x0=this._y0=this._x1=this._y1=null,this._=""}function jCt(){return new jK}var WK,YK,xy,YCe,XK,XCt=M(()=>{WK=Math.PI,YK=2*WK,xy=1e-6,YCe=YK-xy;jK.prototype=jCt.prototype={constructor:jK,moveTo:function(e,t){this._+="M"+(this._x0=this._x1=+e)+","+(this._y0=this._y1=+t)},closePath:function(){this._x1!==null&&(this._x1=this._x0,this._y1=this._y0,this._+="Z")},lineTo:function(e,t){this._+="L"+(this._x1=+e)+","+(this._y1=+t)},quadraticCurveTo:function(e,t,r,n){this._+="Q"+ +e+","+ +t+","+(this._x1=+r)+","+(this._y1=+n)},bezierCurveTo:function(e,t,r,n,i,o){this._+="C"+ +e+","+ +t+","+ +r+","+ +n+","+(this._x1=+i)+","+(this._y1=+o)},arcTo:function(e,t,r,n,i){e=+e,t=+t,r=+r,n=+n,i=+i;var o=this._x1,a=this._y1,s=r-e,l=n-t,c=o-e,u=a-t,h=c*c+u*u;if(i<0)throw new Error("negative radius: "+i);if(this._x1===null)this._+="M"+(this._x1=e)+","+(this._y1=t);else if(h>xy)if(!(Math.abs(u*s-l*c)>xy)||!i)this._+="L"+(this._x1=e)+","+(this._y1=t);else{var f=r-o,p=n-a,d=s*s+l*l,g=f*f+p*p,_=Math.sqrt(d),y=Math.sqrt(h),x=i*Math.tan((WK-Math.acos((d+h-g)/(2*_*y)))/2),b=x/y,S=x/_;Math.abs(b-1)>xy&&(this._+="L"+(e+b*c)+","+(t+b*u)),this._+="A"+i+","+i+",0,0,"+ +(u*f>c*p)+","+(this._x1=e+S*s)+","+(this._y1=t+S*l)}},arc:function(e,t,r,n,i,o){e=+e,t=+t,r=+r,o=!!o;var a=r*Math.cos(n),s=r*Math.sin(n),l=e+a,c=t+s,u=1^o,h=o?n-i:i-n;if(r<0)throw new Error("negative radius: "+r);this._x1===null?this._+="M"+l+","+c:(Math.abs(this._x1-l)>xy||Math.abs(this._y1-c)>xy)&&(this._+="L"+l+","+c),r&&(h<0&&(h=h%YK+YK),h>YCe?this._+="A"+r+","+r+",0,1,"+u+","+(e-a)+","+(t-s)+"A"+r+","+r+",0,1,"+u+","+(this._x1=l)+","+(this._y1=c):h>xy&&(this._+="A"+r+","+r+",0,"+ +(h>=WK)+","+u+","+(this._x1=e+r*Math.cos(i))+","+(this._y1=t+r*Math.sin(i))))},rect:function(e,t,r,n){this._+="M"+(this._x0=this._x1=+e)+","+(this._y0=this._y1=+t)+"h"+ +r+"v"+ +n+"h"+-r+"Z"},toString:function(){return this._}};XK=jCt});var $Ct=M(()=>{XCt()});function jCe(e){return e.source}function XCe(e){return e.target}function $Ce(e){return e.radius}function KCe(e){return e.startAngle}function ZCe(e){return e.endAngle}function KCt(){var e=jCe,t=XCe,r=$Ce,n=KCe,i=ZCe,o=null;function a(){var s,l=GCt.call(arguments),c=e.apply(this,l),u=t.apply(this,l),h=+r.apply(this,(l[0]=c,l)),f=n.apply(this,l)-dT,p=i.apply(this,l)-dT,d=h*HK(f),g=h*VK(f),_=+r.apply(this,(l[0]=u,l)),y=n.apply(this,l)-dT,x=i.apply(this,l)-dT;if(o||(o=s=XK()),o.moveTo(d,g),o.arc(0,0,h,f,p),(f!==y||p!==x)&&(o.quadraticCurveTo(0,0,_*HK(y),_*VK(y)),o.arc(0,0,_,y,x)),o.quadraticCurveTo(0,0,d,g),o.closePath(),s)return o=null,s+""||null}return a.radius=function(s){return arguments.length?(r=typeof s=="function"?s:QR(+s),a):r},a.startAngle=function(s){return arguments.length?(n=typeof s=="function"?s:QR(+s),a):n},a.endAngle=function(s){return arguments.length?(i=typeof s=="function"?s:QR(+s),a):i},a.source=function(s){return arguments.length?(e=s,a):e},a.target=function(s){return arguments.length?(t=s,a):t},a.context=function(s){return arguments.length?(o=s==null?null:s,a):o},a}var ZCt=M(()=>{WCt();YCt();GK();$Ct()});var JCt=M(()=>{qCt();ZCt()});function tN(){}function QCt(e,t){var r=new tN;if(e instanceof tN)e.each(function(s,l){r.set(l,s)});else if(Array.isArray(e)){var n=-1,i=e.length,o;if(t==null)for(;++n<i;)r.set(n,e[n]);else for(;++n<i;)r.set(t(o=e[n],n,e),o)}else if(e)for(var a in e)r.set(a,e[a]);return r}var ll,by,eN=M(()=>{ll="$";tN.prototype=QCt.prototype={constructor:tN,has:function(e){return ll+e in this},get:function(e){return this[ll+e]},set:function(e,t){return this[ll+e]=t,this},remove:function(e){var t=ll+e;return t in this&&delete this[t]},clear:function(){for(var e in this)e[0]===ll&&delete this[e]},keys:function(){var e=[];for(var t in this)t[0]===ll&&e.push(t.slice(1));return e},values:function(){var e=[];for(var t in this)t[0]===ll&&e.push(this[t]);return e},entries:function(){var e=[];for(var t in this)t[0]===ll&&e.push({key:t.slice(1),value:this[t]});return e},size:function(){var e=0;for(var t in this)t[0]===ll&&++e;return e},empty:function(){for(var e in this)if(e[0]===ll)return!1;return!0},each:function(e){for(var t in this)t[0]===ll&&e(this[t],t.slice(1),this)}};by=QCt});function rAt(){var e=[],t=[],r,n,i;function o(s,l,c,u){if(l>=e.length)return r!=null&&s.sort(r),n!=null?n(s):s;for(var h=-1,f=s.length,p=e[l++],d,g,_=by(),y,x=c();++h<f;)(y=_.get(d=p(g=s[h])+""))?y.push(g):_.set(d,[g]);return _.each(function(b,S){u(x,S,o(b,l,c,u))}),x}function a(s,l){if(++l>e.length)return s;var c,u=t[l-1];return n!=null&&l>=e.length?c=s.entries():(c=[],s.each(function(h,f){c.push({key:f,values:a(h,l)})})),u!=null?c.sort(function(h,f){return u(h.key,f.key)}):c}return i={object:function(s){return o(s,0,JCe,QCe)},map:function(s){return o(s,0,tAt,eAt)},entries:function(s){return a(o(s,0,tAt,eAt),0)},key:function(s){return e.push(s),i},sortKeys:function(s){return t[e.length-1]=s,i},sortValues:function(s){return r=s,i},rollup:function(s){return n=s,i}}}function JCe(){return{}}function QCe(e,t,r){e[t]=r}function tAt(){return by()}function eAt(e,t,r){e.set(t,r)}var nAt=M(()=>{eN()});function rN(){}function iAt(e,t){var r=new rN;if(e instanceof rN)e.each(function(o){r.add(o)});else if(e){var n=-1,i=e.length;if(t==null)for(;++n<i;)r.add(e[n]);else for(;++n<i;)r.add(t(e[n],n,e))}return r}var wy,oAt,aAt=M(()=>{eN();wy=by.prototype;rN.prototype=iAt.prototype={constructor:rN,has:wy.has,add:function(e){return e+="",this[ll+e]=e,this},remove:wy.remove,clear:wy.clear,values:wy.keys,size:wy.size,empty:wy.empty,each:wy.each};oAt=iAt});function sAt(e){var t=[];for(var r in e)t.push(r);return t}var lAt=M(()=>{});function cAt(e){var t=[];for(var r in e)t.push(e[r]);return t}var uAt=M(()=>{});function hAt(e){var t=[];for(var r in e)t.push({key:r,value:e[r]});return t}var fAt=M(()=>{});var pAt=M(()=>{nAt();aAt();eN();lAt();uAt();fAt()});function Yp(e,t,r){e.prototype=t.prototype=r,r.constructor=e}function cg(e,t){var r=Object.create(e.prototype);for(var n in t)r[n]=t[n];return r}var nN=M(()=>{});function tf(){}function x2(e){var t;return e=(e+"").trim().toLowerCase(),(t=tAe.exec(e))?(t=parseInt(t[1],16),new to(t>>8&15|t>>4&240,t>>4&15|t&240,(t&15)<<4|t&15,1)):(t=eAe.exec(e))?mAt(parseInt(t[1],16)):(t=rAe.exec(e))?new to(t[1],t[2],t[3],1):(t=nAe.exec(e))?new to(t[1]*255/100,t[2]*255/100,t[3]*255/100,1):(t=iAe.exec(e))?gAt(t[1],t[2],t[3],t[4]):(t=oAe.exec(e))?gAt(t[1]*255/100,t[2]*255/100,t[3]*255/100,t[4]):(t=aAe.exec(e))?_At(t[1],t[2]/100,t[3]/100,1):(t=sAe.exec(e))?_At(t[1],t[2]/100,t[3]/100,t[4]):dAt.hasOwnProperty(e)?mAt(dAt[e]):e==="transparent"?new to(NaN,NaN,NaN,0):null}function mAt(e){return new to(e>>16&255,e>>8&255,e&255,1)}function gAt(e,t,r,n){return n<=0&&(e=t=r=NaN),new to(e,t,r,n)}function gT(e){return e instanceof tf||(e=x2(e)),e?(e=e.rgb(),new to(e.r,e.g,e.b,e.opacity)):new to}function KK(e,t,r,n){return arguments.length===1?gT(e):new to(e,t,r,n==null?1:n)}function to(e,t,r,n){this.r=+e,this.g=+t,this.b=+r,this.opacity=+n}function _At(e,t,r,n){return n<=0?e=t=r=NaN:r<=0||r>=1?e=t=NaN:t<=0&&(e=NaN),new Jh(e,t,r,n)}function lAe(e){if(e instanceof Jh)return new Jh(e.h,e.s,e.l,e.opacity);if(e instanceof tf||(e=x2(e)),!e)return new Jh;if(e instanceof Jh)return e;e=e.rgb();var t=e.r/255,r=e.g/255,n=e.b/255,i=Math.min(t,r,n),o=Math.max(t,r,n),a=NaN,s=o-i,l=(o+i)/2;return s?(t===o?a=(r-n)/s+(r<n)*6:r===o?a=(n-t)/s+2:a=(t-r)/s+4,s/=l<.5?o+i:2-o-i,a*=60):s=l>0&&l<1?0:a,new Jh(a,s,l,e.opacity)}function ZK(e,t,r,n){return arguments.length===1?lAe(e):new Jh(e,t,r,n==null?1:n)}function Jh(e,t,r,n){this.h=+e,this.s=+t,this.l=+r,this.opacity=+n}function $K(e,t,r){return(e<60?t+(r-t)*e/60:e<180?r:e<240?t+(r-t)*(240-e)/60:t)*255}var ug,Sy,v2,mT,Qh,tAe,eAe,rAe,nAe,iAe,oAe,aAe,sAe,dAt,iN=M(()=>{nN();ug=.7,Sy=1/ug,v2="\\s*([+-]?\\d+)\\s*",mT="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",Qh="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",tAe=/^#([0-9a-f]{3})$/,eAe=/^#([0-9a-f]{6})$/,rAe=new RegExp("^rgb\\("+[v2,v2,v2]+"\\)$"),nAe=new RegExp("^rgb\\("+[Qh,Qh,Qh]+"\\)$"),iAe=new RegExp("^rgba\\("+[v2,v2,v2,mT]+"\\)$"),oAe=new RegExp("^rgba\\("+[Qh,Qh,Qh,mT]+"\\)$"),aAe=new RegExp("^hsl\\("+[mT,Qh,Qh]+"\\)$"),sAe=new RegExp("^hsla\\("+[mT,Qh,Qh,mT]+"\\)$"),dAt={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};Yp(tf,x2,{displayable:function(){return this.rgb().displayable()},toString:function(){return this.rgb()+""}});Yp(to,KK,cg(tf,{brighter:function(e){return e=e==null?Sy:Math.pow(Sy,e),new to(this.r*e,this.g*e,this.b*e,this.opacity)},darker:function(e){return e=e==null?ug:Math.pow(ug,e),new to(this.r*e,this.g*e,this.b*e,this.opacity)},rgb:function(){return this},displayable:function(){return 0<=this.r&&this.r<=255&&0<=this.g&&this.g<=255&&0<=this.b&&this.b<=255&&0<=this.opacity&&this.opacity<=1},toString:function(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"rgb(":"rgba(")+Math.max(0,Math.min(255,Math.round(this.r)||0))+", "+Math.max(0,Math.min(255,Math.round(this.g)||0))+", "+Math.max(0,Math.min(255,Math.round(this.b)||0))+(e===1?")":", "+e+")")}}));Yp(Jh,ZK,cg(tf,{brighter:function(e){return e=e==null?Sy:Math.pow(Sy,e),new Jh(this.h,this.s,this.l*e,this.opacity)},darker:function(e){return e=e==null?ug:Math.pow(ug,e),new Jh(this.h,this.s,this.l*e,this.opacity)},rgb:function(){var e=this.h%360+(this.h<0)*360,t=isNaN(e)||isNaN(this.s)?0:this.s,r=this.l,n=r+(r<.5?r:1-r)*t,i=2*r-n;return new to($K(e>=240?e-240:e+120,i,n),$K(e,i,n),$K(e<120?e+240:e-120,i,n),this.opacity)},displayable:function(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1}}))});var oN,aN,JK=M(()=>{oN=Math.PI/180,aN=180/Math.PI});function nZ(e){if(e instanceof jp)return new jp(e.l,e.a,e.b,e.opacity);if(e instanceof hg){var t=e.h*oN;return new jp(e.l,Math.cos(t)*e.c,Math.sin(t)*e.c,e.opacity)}e instanceof to||(e=gT(e));var r=rZ(e.r),n=rZ(e.g),i=rZ(e.b),o=QK((.4124564*r+.3575761*n+.1804375*i)/yAt),a=QK((.2126729*r+.7151522*n+.072175*i)/vAt),s=QK((.0193339*r+.119192*n+.9503041*i)/xAt);return new jp(116*a-16,500*(o-a),200*(a-s),e.opacity)}function lN(e,t,r,n){return arguments.length===1?nZ(e):new jp(e,t,r,n==null?1:n)}function jp(e,t,r,n){this.l=+e,this.a=+t,this.b=+r,this.opacity=+n}function QK(e){return e>cAe?Math.pow(e,1/3):e/wAt+bAt}function tZ(e){return e>b2?e*e*e:wAt*(e-bAt)}function eZ(e){return 255*(e<=.0031308?12.92*e:1.055*Math.pow(e,1/2.4)-.055)}function rZ(e){return(e/=255)<=.04045?e/12.92:Math.pow((e+.055)/1.055,2.4)}function uAe(e){if(e instanceof hg)return new hg(e.h,e.c,e.l,e.opacity);e instanceof jp||(e=nZ(e));var t=Math.atan2(e.b,e.a)*aN;return new hg(t<0?t+360:t,Math.sqrt(e.a*e.a+e.b*e.b),e.l,e.opacity)}function iZ(e,t,r,n){return arguments.length===1?uAe(e):new hg(e,t,r,n==null?1:n)}function hg(e,t,r,n){this.h=+e,this.c=+t,this.l=+r,this.opacity=+n}var sN,yAt,vAt,xAt,bAt,b2,wAt,cAe,SAt=M(()=>{nN();iN();JK();sN=18,yAt=.95047,vAt=1,xAt=1.08883,bAt=4/29,b2=6/29,wAt=3*b2*b2,cAe=b2*b2*b2;Yp(jp,lN,cg(tf,{brighter:function(e){return new jp(this.l+sN*(e==null?1:e),this.a,this.b,this.opacity)},darker:function(e){return new jp(this.l-sN*(e==null?1:e),this.a,this.b,this.opacity)},rgb:function(){var e=(this.l+16)/116,t=isNaN(this.a)?e:e+this.a/500,r=isNaN(this.b)?e:e-this.b/200;return e=vAt*tZ(e),t=yAt*tZ(t),r=xAt*tZ(r),new to(eZ(3.2404542*t-1.5371385*e-.4985314*r),eZ(-.969266*t+1.8760108*e+.041556*r),eZ(.0556434*t-.2040259*e+1.0572252*r),this.opacity)}}));Yp(hg,iZ,cg(tf,{brighter:function(e){return new hg(this.h,this.c,this.l+sN*(e==null?1:e),this.opacity)},darker:function(e){return new hg(this.h,this.c,this.l-sN*(e==null?1:e),this.opacity)},rgb:function(){return nZ(this).rgb()}}))});function hAe(e){if(e instanceof My)return new My(e.h,e.s,e.l,e.opacity);e instanceof to||(e=gT(e));var t=e.r/255,r=e.g/255,n=e.b/255,i=(TAt*n+MAt*t-EAt*r)/(TAt+MAt-EAt),o=n-i,a=(_T*(r-i)-aZ*o)/cN,s=Math.sqrt(a*a+o*o)/(_T*i*(1-i)),l=s?Math.atan2(a,o)*aN-120:NaN;return new My(l<0?l+360:l,s,i,e.opacity)}function uN(e,t,r,n){return arguments.length===1?hAe(e):new My(e,t,r,n==null?1:n)}function My(e,t,r,n){this.h=+e,this.s=+t,this.l=+r,this.opacity=+n}var CAt,oZ,aZ,cN,_T,MAt,EAt,TAt,AAt=M(()=>{nN();iN();JK();CAt=-.14861,oZ=1.78277,aZ=-.29227,cN=-.90649,_T=1.97294,MAt=_T*cN,EAt=_T*oZ,TAt=oZ*aZ-cN*CAt;Yp(My,uN,cg(tf,{brighter:function(e){return e=e==null?Sy:Math.pow(Sy,e),new My(this.h,this.s,this.l*e,this.opacity)},darker:function(e){return e=e==null?ug:Math.pow(ug,e),new My(this.h,this.s,this.l*e,this.opacity)},rgb:function(){var e=isNaN(this.h)?0:(this.h+120)*oN,t=+this.l,r=isNaN(this.s)?0:this.s*t*(1-t),n=Math.cos(e),i=Math.sin(e);return new to(255*(t+r*(CAt*n+oZ*i)),255*(t+r*(aZ*n+cN*i)),255*(t+r*(_T*n)),this.opacity)}}))});var PAt=M(()=>{iN();SAt();AAt()});function LAt(){for(var e=0,t=arguments.length,r={},n;e<t;++e){if(!(n=arguments[e]+"")||n in r)throw new Error("illegal type: "+n);r[n]=[]}return new hN(r)}function hN(e){this._=e}function pAe(e,t){return e.trim().split(/^|\s+/).map(function(r){var n="",i=r.indexOf(".");if(i>=0&&(n=r.slice(i+1),r=r.slice(0,i)),r&&!t.hasOwnProperty(r))throw new Error("unknown type: "+r);return{type:r,name:n}})}function dAe(e,t){for(var r=0,n=e.length,i;r<n;++r)if((i=e[r]).name===t)return i.value}function IAt(e,t,r){for(var n=0,i=e.length;n<i;++n)if(e[n].name===t){e[n]=fAe,e=e.slice(0,n).concat(e.slice(n+1));break}return r!=null&&e.push({name:t,value:r}),e}var fAe,kAt,RAt=M(()=>{fAe={value:function(){}};hN.prototype=LAt.prototype={constructor:hN,on:function(e,t){var r=this._,n=pAe(e+"",r),i,o=-1,a=n.length;if(arguments.length<2){for(;++o<a;)if((i=(e=n[o]).type)&&(i=dAe(r[i],e.name)))return i;return}if(t!=null&&typeof t!="function")throw new Error("invalid callback: "+t);for(;++o<a;)if(i=(e=n[o]).type)r[i]=IAt(r[i],e.name,t);else if(t==null)for(i in r)r[i]=IAt(r[i],e.name,null);return this},copy:function(){var e={},t=this._;for(var r in t)e[r]=t[r].slice();return new hN(e)},call:function(e,t){if((i=arguments.length-2)>0)for(var r=new Array(i),n=0,i,o;n<i;++n)r[n]=arguments[n+2];if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(o=this._[e],n=0,i=o.length;n<i;++n)o[n].value.apply(t,r)},apply:function(e,t,r){if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(var n=this._[e],i=0,o=n.length;i<o;++i)n[i].value.apply(t,r)}};kAt=LAt});var NAt=M(()=>{RAt()});function OAt(){for(var e=0,t=arguments.length,r={},n;e<t;++e){if(!(n=arguments[e]+"")||n in r||/[\s.]/.test(n))throw new Error("illegal type: "+n);r[n]=[]}return new fN(r)}function fN(e){this._=e}function gAe(e,t){return e.trim().split(/^|\s+/).map(function(r){var n="",i=r.indexOf(".");if(i>=0&&(n=r.slice(i+1),r=r.slice(0,i)),r&&!t.hasOwnProperty(r))throw new Error("unknown type: "+r);return{type:r,name:n}})}function _Ae(e,t){for(var r=0,n=e.length,i;r<n;++r)if((i=e[r]).name===t)return i.value}function DAt(e,t,r){for(var n=0,i=e.length;n<i;++n)if(e[n].name===t){e[n]=mAe,e=e.slice(0,n).concat(e.slice(n+1));break}return r!=null&&e.push({name:t,value:r}),e}var mAe,sZ,zAt=M(()=>{mAe={value:function(){}};fN.prototype=OAt.prototype={constructor:fN,on:function(e,t){var r=this._,n=gAe(e+"",r),i,o=-1,a=n.length;if(arguments.length<2){for(;++o<a;)if((i=(e=n[o]).type)&&(i=_Ae(r[i],e.name)))return i;return}if(t!=null&&typeof t!="function")throw new Error("invalid callback: "+t);for(;++o<a;)if(i=(e=n[o]).type)r[i]=DAt(r[i],e.name,t);else if(t==null)for(i in r)r[i]=DAt(r[i],e.name,null);return this},copy:function(){var e={},t=this._;for(var r in t)e[r]=t[r].slice();return new fN(e)},call:function(e,t){if((i=arguments.length-2)>0)for(var r=new Array(i),n=0,i,o;n<i;++n)r[n]=arguments[n+2];if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(o=this._[e],n=0,i=o.length;n<i;++n)o[n].value.apply(t,r)},apply:function(e,t,r){if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(var n=this._[e],i=0,o=n.length;i<o;++i)n[i].value.apply(t,r)}};sZ=OAt});var FAt=M(()=>{zAt()});var pN,lZ,cZ=M(()=>{pN="http://www.w3.org/1999/xhtml",lZ={svg:"http://www.w3.org/2000/svg",xhtml:pN,xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/"}});function dN(e){var t=e+="",r=t.indexOf(":");return r>=0&&(t=e.slice(0,r))!=="xmlns"&&(e=e.slice(r+1)),lZ.hasOwnProperty(t)?{space:lZ[t],local:e}:e}var uZ=M(()=>{cZ()});function yAe(e){return function(){var t=this.ownerDocument,r=this.namespaceURI;return r===pN&&t.documentElement.namespaceURI===pN?t.createElement(e):t.createElementNS(r,e)}}function vAe(e){return function(){return this.ownerDocument.createElementNS(e.space,e.local)}}function mN(e){var t=dN(e);return(t.local?vAe:yAe)(t)}var hZ=M(()=>{uZ();cZ()});function xAe(){}function gN(e){return e==null?xAe:function(){return this.querySelector(e)}}var fZ=M(()=>{});function BAt(e){typeof e!="function"&&(e=gN(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=new Array(a),l,c,u=0;u<a;++u)(l=o[u])&&(c=e.call(l,l.__data__,u,o))&&("__data__"in l&&(c.__data__=l.__data__),s[u]=c);return new pi(n,this._parents)}var HAt=M(()=>{ef();fZ()});function bAe(){return[]}function VAt(e){return e==null?bAe:function(){return this.querySelectorAll(e)}}var UAt=M(()=>{});function qAt(e){typeof e!="function"&&(e=VAt(e));for(var t=this._groups,r=t.length,n=[],i=[],o=0;o<r;++o)for(var a=t[o],s=a.length,l,c=0;c<s;++c)(l=a[c])&&(n.push(e.call(l,l.__data__,c,a)),i.push(l));return new pi(n,i)}var GAt=M(()=>{ef();UAt()});function WAt(e){return function(){return this.matches(e)}}var YAt=M(()=>{});function jAt(e){typeof e!="function"&&(e=WAt(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=[],l,c=0;c<a;++c)(l=o[c])&&e.call(l,l.__data__,c,o)&&s.push(l);return new pi(n,this._parents)}var XAt=M(()=>{ef();YAt()});function _N(e){return new Array(e.length)}var pZ=M(()=>{});function $At(){return new pi(this._enter||this._groups.map(_N),this._parents)}function yT(e,t){this.ownerDocument=e.ownerDocument,this.namespaceURI=e.namespaceURI,this._next=null,this._parent=e,this.__data__=t}var dZ=M(()=>{pZ();ef();yT.prototype={constructor:yT,appendChild:function(e){return this._parent.insertBefore(e,this._next)},insertBefore:function(e,t){return this._parent.insertBefore(e,t)},querySelector:function(e){return this._parent.querySelector(e)},querySelectorAll:function(e){return this._parent.querySelectorAll(e)}}});function KAt(e){return function(){return e}}var ZAt=M(()=>{});function wAe(e,t,r,n,i,o){for(var a=0,s,l=t.length,c=o.length;a<c;++a)(s=t[a])?(s.__data__=o[a],n[a]=s):r[a]=new yT(e,o[a]);for(;a<l;++a)(s=t[a])&&(i[a]=s)}function SAe(e,t,r,n,i,o,a){var s,l,c={},u=t.length,h=o.length,f=new Array(u),p;for(s=0;s<u;++s)(l=t[s])&&(f[s]=p=JAt+a.call(l,l.__data__,s,t),p in c?i[s]=l:c[p]=l);for(s=0;s<h;++s)p=JAt+a.call(e,o[s],s,o),(l=c[p])?(n[s]=l,l.__data__=o[s],c[p]=null):r[s]=new yT(e,o[s]);for(s=0;s<u;++s)(l=t[s])&&c[f[s]]===l&&(i[s]=l)}function QAt(e,t){if(!e)return p=new Array(this.size()),c=-1,this.each(function(P){p[++c]=P}),p;var r=t?SAe:wAe,n=this._parents,i=this._groups;typeof e!="function"&&(e=KAt(e));for(var o=i.length,a=new Array(o),s=new Array(o),l=new Array(o),c=0;c<o;++c){var u=n[c],h=i[c],f=h.length,p=e.call(u,u&&u.__data__,c,n),d=p.length,g=s[c]=new Array(d),_=a[c]=new Array(d),y=l[c]=new Array(f);r(u,h,g,_,y,p,t);for(var x=0,b=0,S,C;x<d;++x)if(S=g[x]){for(x>=b&&(b=x+1);!(C=_[b])&&++b<d;);S._next=C||null}}return a=new pi(a,n),a._enter=s,a._exit=l,a}var JAt,t4t=M(()=>{ef();dZ();ZAt();JAt="$"});function e4t(){return new pi(this._exit||this._groups.map(_N),this._parents)}var r4t=M(()=>{pZ();ef()});function n4t(e,t,r){var n=this.enter(),i=this,o=this.exit();return n=typeof e=="function"?e(n):n.append(e+""),t!=null&&(i=t(i)),r==null?o.remove():r(o),n&&i?n.merge(i).order():i}var i4t=M(()=>{});function o4t(e){for(var t=this._groups,r=e._groups,n=t.length,i=r.length,o=Math.min(n,i),a=new Array(n),s=0;s<o;++s)for(var l=t[s],c=r[s],u=l.length,h=a[s]=new Array(u),f,p=0;p<u;++p)(f=l[p]||c[p])&&(h[p]=f);for(;s<n;++s)a[s]=t[s];return new pi(a,this._parents)}var a4t=M(()=>{ef()});function s4t(){for(var e=this._groups,t=-1,r=e.length;++t<r;)for(var n=e[t],i=n.length-1,o=n[i],a;--i>=0;)(a=n[i])&&(o&&a.compareDocumentPosition(o)^4&&o.parentNode.insertBefore(a,o),o=a);return this}var l4t=M(()=>{});function c4t(e){e||(e=MAe);function t(h,f){return h&&f?e(h.__data__,f.__data__):!h-!f}for(var r=this._groups,n=r.length,i=new Array(n),o=0;o<n;++o){for(var a=r[o],s=a.length,l=i[o]=new Array(s),c,u=0;u<s;++u)(c=a[u])&&(l[u]=c);l.sort(t)}return new pi(i,this._parents).order()}function MAe(e,t){return e<t?-1:e>t?1:e>=t?0:NaN}var u4t=M(()=>{ef()});function h4t(){var e=arguments[0];return arguments[0]=this,e.apply(null,arguments),this}var f4t=M(()=>{});function p4t(){var e=new Array(this.size()),t=-1;return this.each(function(){e[++t]=this}),e}var d4t=M(()=>{});function m4t(){for(var e=this._groups,t=0,r=e.length;t<r;++t)for(var n=e[t],i=0,o=n.length;i<o;++i){var a=n[i];if(a)return a}return null}var g4t=M(()=>{});function _4t(){var e=0;return this.each(function(){++e}),e}var y4t=M(()=>{});function v4t(){return!this.node()}var x4t=M(()=>{});function b4t(e){for(var t=this._groups,r=0,n=t.length;r<n;++r)for(var i=t[r],o=0,a=i.length,s;o<a;++o)(s=i[o])&&e.call(s,s.__data__,o,i);return this}var w4t=M(()=>{});function EAe(e){return function(){this.removeAttribute(e)}}function TAe(e){return function(){this.removeAttributeNS(e.space,e.local)}}function CAe(e,t){return function(){this.setAttribute(e,t)}}function AAe(e,t){return function(){this.setAttributeNS(e.space,e.local,t)}}function PAe(e,t){return function(){var r=t.apply(this,arguments);r==null?this.removeAttribute(e):this.setAttribute(e,r)}}function IAe(e,t){return function(){var r=t.apply(this,arguments);r==null?this.removeAttributeNS(e.space,e.local):this.setAttributeNS(e.space,e.local,r)}}function S4t(e,t){var r=dN(e);if(arguments.length<2){var n=this.node();return r.local?n.getAttributeNS(r.space,r.local):n.getAttribute(r)}return this.each((t==null?r.local?TAe:EAe:typeof t=="function"?r.local?IAe:PAe:r.local?AAe:CAe)(r,t))}var M4t=M(()=>{uZ()});function yN(e){return e.ownerDocument&&e.ownerDocument.defaultView||e.document&&e||e.defaultView}var mZ=M(()=>{});function LAe(e){return function(){this.style.removeProperty(e)}}function kAe(e,t,r){return function(){this.style.setProperty(e,t,r)}}function RAe(e,t,r){return function(){var n=t.apply(this,arguments);n==null?this.style.removeProperty(e):this.style.setProperty(e,n,r)}}function E4t(e,t,r){return arguments.length>1?this.each((t==null?LAe:typeof t=="function"?RAe:kAe)(e,t,r==null?"":r)):NAe(this.node(),e)}function NAe(e,t){return e.style.getPropertyValue(t)||yN(e).getComputedStyle(e,null).getPropertyValue(t)}var T4t=M(()=>{mZ()});function DAe(e){return function(){delete this[e]}}function OAe(e,t){return function(){this[e]=t}}function zAe(e,t){return function(){var r=t.apply(this,arguments);r==null?delete this[e]:this[e]=r}}function C4t(e,t){return arguments.length>1?this.each((t==null?DAe:typeof t=="function"?zAe:OAe)(e,t)):this.node()[e]}var A4t=M(()=>{});function P4t(e){return e.trim().split(/^|\s+/)}function gZ(e){return e.classList||new I4t(e)}function I4t(e){this._node=e,this._names=P4t(e.getAttribute("class")||"")}function L4t(e,t){for(var r=gZ(e),n=-1,i=t.length;++n<i;)r.add(t[n])}function k4t(e,t){for(var r=gZ(e),n=-1,i=t.length;++n<i;)r.remove(t[n])}function FAe(e){return function(){L4t(this,e)}}function BAe(e){return function(){k4t(this,e)}}function HAe(e,t){return function(){(t.apply(this,arguments)?L4t:k4t)(this,e)}}function R4t(e,t){var r=P4t(e+"");if(arguments.length<2){for(var n=gZ(this.node()),i=-1,o=r.length;++i<o;)if(!n.contains(r[i]))return!1;return!0}return this.each((typeof t=="function"?HAe:t?FAe:BAe)(r,t))}var N4t=M(()=>{I4t.prototype={add:function(e){var t=this._names.indexOf(e);t<0&&(this._names.push(e),this._node.setAttribute("class",this._names.join(" ")))},remove:function(e){var t=this._names.indexOf(e);t>=0&&(this._names.splice(t,1),this._node.setAttribute("class",this._names.join(" ")))},contains:function(e){return this._names.indexOf(e)>=0}}});function VAe(){this.textContent=""}function UAe(e){return function(){this.textContent=e}}function qAe(e){return function(){var t=e.apply(this,arguments);this.textContent=t==null?"":t}}function D4t(e){return arguments.length?this.each(e==null?VAe:(typeof e=="function"?qAe:UAe)(e)):this.node().textContent}var O4t=M(()=>{});function GAe(){this.innerHTML=""}function WAe(e){return function(){this.innerHTML=e}}function YAe(e){return function(){var t=e.apply(this,arguments);this.innerHTML=t==null?"":t}}function z4t(e){return arguments.length?this.each(e==null?GAe:(typeof e=="function"?YAe:WAe)(e)):this.node().innerHTML}var F4t=M(()=>{});function jAe(){this.nextSibling&&this.parentNode.appendChild(this)}function B4t(){return this.each(jAe)}var H4t=M(()=>{});function XAe(){this.previousSibling&&this.parentNode.insertBefore(this,this.parentNode.firstChild)}function V4t(){return this.each(XAe)}var U4t=M(()=>{});function q4t(e){var t=typeof e=="function"?e:mN(e);return this.select(function(){return this.appendChild(t.apply(this,arguments))})}var G4t=M(()=>{hZ()});function $Ae(){return null}function W4t(e,t){var r=typeof e=="function"?e:mN(e),n=t==null?$Ae:typeof t=="function"?t:gN(t);return this.select(function(){return this.insertBefore(r.apply(this,arguments),n.apply(this,arguments)||null)})}var Y4t=M(()=>{hZ();fZ()});function KAe(){var e=this.parentNode;e&&e.removeChild(this)}function j4t(){return this.each(KAe)}var X4t=M(()=>{});function ZAe(){var e=this.cloneNode(!1),t=this.parentNode;return t?t.insertBefore(e,this.nextSibling):e}function JAe(){var e=this.cloneNode(!0),t=this.parentNode;return t?t.insertBefore(e,this.nextSibling):e}function $4t(e){return this.select(e?JAe:ZAe)}var K4t=M(()=>{});function Z4t(e){return arguments.length?this.property("__data__",e):this.node().__data__}var J4t=M(()=>{});function QAe(e,t,r){return e=ePt(e,t,r),function(n){var i=n.relatedTarget;(!i||i!==this&&!(i.compareDocumentPosition(this)&8))&&e.call(this,n)}}function ePt(e,t,r){return function(n){var i=sn;sn=n;try{e.call(this,this.__data__,t,r)}finally{sn=i}}}function t4e(e){return e.trim().split(/^|\s+/).map(function(t){var r="",n=t.indexOf(".");return n>=0&&(r=t.slice(n+1),t=t.slice(0,n)),{type:t,name:r}})}function e4e(e){return function(){var t=this.__on;if(!!t){for(var r=0,n=-1,i=t.length,o;r<i;++r)o=t[r],(!e.type||o.type===e.type)&&o.name===e.name?this.removeEventListener(o.type,o.listener,o.capture):t[++n]=o;++n?t.length=n:delete this.__on}}}function r4e(e,t,r){var n=tPt.hasOwnProperty(e.type)?QAe:ePt;return function(i,o,a){var s=this.__on,l,c=n(t,o,a);if(s){for(var u=0,h=s.length;u<h;++u)if((l=s[u]).type===e.type&&l.name===e.name){this.removeEventListener(l.type,l.listener,l.capture),this.addEventListener(l.type,l.listener=c,l.capture=r),l.value=t;return}}this.addEventListener(e.type,c,r),l={type:e.type,name:e.name,value:t,listener:c,capture:r},s?s.push(l):this.__on=[l]}}function rPt(e,t,r){var n=t4e(e+""),i,o=n.length,a;if(arguments.length<2){var s=this.node().__on;if(s){for(var l=0,c=s.length,u;l<c;++l)for(i=0,u=s[l];i<o;++i)if((a=n[i]).type===u.type&&a.name===u.name)return u.value}return}for(s=t?r4e:e4e,r==null&&(r=!1),i=0;i<o;++i)this.each(s(n[i],t,r));return this}function vN(e,t,r,n){var i=sn;e.sourceEvent=sn,sn=e;try{return t.apply(r,n)}finally{sn=i}}var tPt,sn,Q4t,xN=M(()=>{tPt={},sn=null;typeof document!="undefined"&&(Q4t=document.documentElement,"onmouseenter"in Q4t||(tPt={mouseenter:"mouseover",mouseleave:"mouseout"}))});function nPt(e,t,r){var n=yN(e),i=n.CustomEvent;typeof i=="function"?i=new i(t,r):(i=n.document.createEvent("Event"),r?(i.initEvent(t,r.bubbles,r.cancelable),i.detail=r.detail):i.initEvent(t,!1,!1)),e.dispatchEvent(i)}function n4e(e,t){return function(){return nPt(this,e,t)}}function i4e(e,t){return function(){return nPt(this,e,t.apply(this,arguments))}}function iPt(e,t){return this.each((typeof t=="function"?i4e:n4e)(e,t))}var oPt=M(()=>{mZ()});function pi(e,t){this._groups=e,this._parents=t}function o4e(){return new pi([[document.documentElement]],_Z)}var _Z,ef=M(()=>{HAt();GAt();XAt();t4t();dZ();r4t();i4t();a4t();l4t();u4t();f4t();d4t();g4t();y4t();x4t();w4t();M4t();T4t();A4t();N4t();O4t();F4t();H4t();U4t();G4t();Y4t();X4t();K4t();J4t();xN();oPt();_Z=[null];pi.prototype=o4e.prototype={constructor:pi,select:BAt,selectAll:qAt,filter:jAt,data:QAt,enter:$At,exit:e4t,join:n4t,merge:o4t,order:s4t,sort:c4t,call:h4t,nodes:p4t,node:m4t,size:_4t,empty:v4t,each:b4t,attr:S4t,style:E4t,property:C4t,classed:R4t,text:D4t,html:z4t,raise:B4t,lower:V4t,append:q4t,insert:W4t,remove:j4t,clone:$4t,datum:Z4t,on:rPt,dispatch:iPt}});function Ey(e){return typeof e=="string"?new pi([[document.querySelector(e)]],[document.documentElement]):new pi([[e]],_Z)}var aPt=M(()=>{ef()});function bN(){for(var e=sn,t;t=e.sourceEvent;)e=t;return e}var yZ=M(()=>{xN()});function wN(e,t){var r=e.ownerSVGElement||e;if(r.createSVGPoint){var n=r.createSVGPoint();return n.x=t.clientX,n.y=t.clientY,n=n.matrixTransform(e.getScreenCTM().inverse()),[n.x,n.y]}var i=e.getBoundingClientRect();return[t.clientX-i.left-e.clientLeft,t.clientY-i.top-e.clientTop]}var vZ=M(()=>{});function xZ(e){var t=bN();return t.changedTouches&&(t=t.changedTouches[0]),wN(e,t)}var sPt=M(()=>{yZ();vZ()});function bZ(e,t,r){arguments.length<3&&(r=t,t=bN().changedTouches);for(var n=0,i=t?t.length:0,o;n<i;++n)if((o=t[n]).identifier===r)return wN(e,o);return null}var lPt=M(()=>{yZ();vZ()});var SN=M(()=>{sPt();aPt();lPt();xN()});function MN(){sn.stopImmediatePropagation()}function fg(){sn.preventDefault(),sn.stopImmediatePropagation()}var wZ=M(()=>{SN()});function EN(e){var t=e.document.documentElement,r=Ey(e).on("dragstart.drag",fg,!0);"onselectstart"in t?r.on("selectstart.drag",fg,!0):(t.__noselect=t.style.MozUserSelect,t.style.MozUserSelect="none")}function TN(e,t){var r=e.document.documentElement,n=Ey(e).on("dragstart.drag",null);t&&(n.on("click.drag",fg,!0),setTimeout(function(){n.on("click.drag",null)},0)),"onselectstart"in r?n.on("selectstart.drag",null):(r.style.MozUserSelect=r.__noselect,delete r.__noselect)}var SZ=M(()=>{SN();wZ()});function vT(e){return function(){return e}}var cPt=M(()=>{});function xT(e,t,r,n,i,o,a,s,l,c){this.target=e,this.type=t,this.subject=r,this.identifier=n,this.active=i,this.x=o,this.y=a,this.dx=s,this.dy=l,this._=c}var uPt=M(()=>{xT.prototype.on=function(){var e=this._.on.apply(this._,arguments);return e===this._?this:e}});function a4e(){return!sn.button}function s4e(){return this.parentNode}function l4e(e){return e==null?{x:sn.x,y:sn.y}:e}function c4e(){return"ontouchstart"in this}function hPt(){var e=a4e,t=s4e,r=l4e,n=c4e,i={},o=sZ("start","drag","end"),a=0,s,l,c,u,h=0;function f(S){S.on("mousedown.drag",p).filter(n).on("touchstart.drag",_).on("touchmove.drag",y).on("touchend.drag touchcancel.drag",x).style("touch-action","none").style("-webkit-tap-highlight-color","rgba(0,0,0,0)")}function p(){if(!(u||!e.apply(this,arguments))){var S=b("mouse",t.apply(this,arguments),xZ,this,arguments);!S||(Ey(sn.view).on("mousemove.drag",d,!0).on("mouseup.drag",g,!0),EN(sn.view),MN(),c=!1,s=sn.clientX,l=sn.clientY,S("start"))}}function d(){if(fg(),!c){var S=sn.clientX-s,C=sn.clientY-l;c=S*S+C*C>h}i.mouse("drag")}function g(){Ey(sn.view).on("mousemove.drag mouseup.drag",null),TN(sn.view,c),fg(),i.mouse("end")}function _(){if(!!e.apply(this,arguments)){var S=sn.changedTouches,C=t.apply(this,arguments),P=S.length,k,O;for(k=0;k<P;++k)(O=b(S[k].identifier,C,bZ,this,arguments))&&(MN(),O("start"))}}function y(){var S=sn.changedTouches,C=S.length,P,k;for(P=0;P<C;++P)(k=i[S[P].identifier])&&(fg(),k("drag"))}function x(){var S=sn.changedTouches,C=S.length,P,k;for(u&&clearTimeout(u),u=setTimeout(function(){u=null},500),P=0;P<C;++P)(k=i[S[P].identifier])&&(MN(),k("end"))}function b(S,C,P,k,O){var D=P(C,S),B,I,L,R=o.copy();if(!!vN(new xT(f,"beforestart",B,S,a,D[0],D[1],0,0,R),function(){return(sn.subject=B=r.apply(k,O))==null?!1:(I=B.x-D[0]||0,L=B.y-D[1]||0,!0)}))return function F(z){var U=D,W;switch(z){case"start":i[S]=F,W=a++;break;case"end":delete i[S],--a;case"drag":D=P(C,S),W=a;break}vN(new xT(f,z,B,S,W,D[0]+I,D[1]+L,D[0]-U[0],D[1]-U[1],R),R.apply,R,[z,k,O])}}return f.filter=function(S){return arguments.length?(e=typeof S=="function"?S:vT(!!S),f):e},f.container=function(S){return arguments.length?(t=typeof S=="function"?S:vT(S),f):t},f.subject=function(S){return arguments.length?(r=typeof S=="function"?S:vT(S),f):r},f.touchable=function(S){return arguments.length?(n=typeof S=="function"?S:vT(!!S),f):n},f.on=function(){var S=o.on.apply(o,arguments);return S===o?f:S},f.clickDistance=function(S){return arguments.length?(h=(S=+S)*S,f):Math.sqrt(h)},f}var fPt=M(()=>{FAt();SN();SZ();wZ();cPt();uPt()});var pPt=M(()=>{fPt();SZ()});function mPt(e){return new Function("d","return {"+e.map(function(t,r){return JSON.stringify(t)+": d["+r+"]"}).join(",")+"}")}function u4e(e,t){var r=mPt(e);return function(n,i){return t(r(n),i,e)}}function h4e(e){var t=Object.create(null),r=[];return e.forEach(function(n){for(var i in n)i in t||r.push(t[i]=i)}),r}function w2(e){var t=new RegExp('["'+e+`
\r]`),r=e.charCodeAt(0);function n(c,u){var h,f,p=i(c,function(d,g){if(h)return h(d,g-1);f=d,h=u?u4e(d,u):mPt(d)});return p.columns=f||[],p}function i(c,u){var h=[],f=c.length,p=0,d=0,g,_=f<=0,y=!1;c.charCodeAt(f-1)===bT&&--f,c.charCodeAt(f-1)===TZ&&--f;function x(){if(_)return MZ;if(y)return y=!1,dPt;var S,C=p,P;if(c.charCodeAt(C)===EZ){for(;p++<f&&c.charCodeAt(p)!==EZ||c.charCodeAt(++p)===EZ;);return(S=p)>=f?_=!0:(P=c.charCodeAt(p++))===bT?y=!0:P===TZ&&(y=!0,c.charCodeAt(p)===bT&&++p),c.slice(C+1,S-1).replace(/""/g,'"')}for(;p<f;){if((P=c.charCodeAt(S=p++))===bT)y=!0;else if(P===TZ)y=!0,c.charCodeAt(p)===bT&&++p;else if(P!==r)continue;return c.slice(C,S)}return _=!0,c.slice(C,f)}for(;(g=x())!==MZ;){for(var b=[];g!==dPt&&g!==MZ;)b.push(g),g=x();u&&(b=u(b,d++))==null||h.push(b)}return h}function o(c,u){return u==null&&(u=h4e(c)),[u.map(l).join(e)].concat(c.map(function(h){return u.map(function(f){return l(h[f])}).join(e)})).join(`
`)}function a(c){return c.map(s).join(`
`)}function s(c){return c.map(l).join(e)}function l(c){return c==null?"":t.test(c+="")?'"'+c.replace(/"/g,'""')+'"':c}return{parse:n,parseRows:i,format:o,formatRows:a}}var dPt,MZ,EZ,bT,TZ,CN=M(()=>{dPt={},MZ={},EZ=34,bT=10,TZ=13});var AN,gPt,_Pt,yPt,vPt,xPt=M(()=>{CN();AN=w2(","),gPt=AN.parse,_Pt=AN.parseRows,yPt=AN.format,vPt=AN.formatRows});var PN,bPt,wPt,SPt,MPt,EPt=M(()=>{CN();PN=w2("	"),bPt=PN.parse,wPt=PN.parseRows,SPt=PN.format,MPt=PN.formatRows});var TPt=M(()=>{CN();xPt();EPt()});function CPt(e){return+e}var APt=M(()=>{});function PPt(e){return e*e}function IPt(e){return e*(2-e)}function CZ(e){return((e*=2)<=1?e*e:--e*(2-e)+1)/2}var LPt=M(()=>{});function kPt(e){return e*e*e}function RPt(e){return--e*e*e+1}function AZ(e){return((e*=2)<=1?e*e*e:(e-=2)*e*e+2)/2}var NPt=M(()=>{});var PZ,DPt,OPt,IZ,zPt=M(()=>{PZ=3,DPt=function e(t){t=+t;function r(n){return Math.pow(n,t)}return r.exponent=e,r}(PZ),OPt=function e(t){t=+t;function r(n){return 1-Math.pow(1-n,t)}return r.exponent=e,r}(PZ),IZ=function e(t){t=+t;function r(n){return((n*=2)<=1?Math.pow(n,t):2-Math.pow(2-n,t))/2}return r.exponent=e,r}(PZ)});function HPt(e){return 1-Math.cos(e*BPt)}function VPt(e){return Math.sin(e*BPt)}function LZ(e){return(1-Math.cos(FPt*e))/2}var FPt,BPt,UPt=M(()=>{FPt=Math.PI,BPt=FPt/2});function qPt(e){return Math.pow(2,10*e-10)}function GPt(e){return 1-Math.pow(2,-10*e)}function kZ(e){return((e*=2)<=1?Math.pow(2,10*e-10):2-Math.pow(2,10-10*e))/2}var WPt=M(()=>{});function YPt(e){return 1-Math.sqrt(1-e*e)}function jPt(e){return Math.sqrt(1- --e*e)}function RZ(e){return((e*=2)<=1?1-Math.sqrt(1-e*e):Math.sqrt(1-(e-=2)*e)+1)/2}var XPt=M(()=>{});function $Pt(e){return 1-S2(1-e)}function S2(e){return(e=+e)<NZ?IN*e*e:e<p4e?IN*(e-=f4e)*e+d4e:e<g4e?IN*(e-=m4e)*e+_4e:IN*(e-=y4e)*e+v4e}function KPt(e){return((e*=2)<=1?1-S2(1-e):S2(e-1)+1)/2}var NZ,f4e,p4e,d4e,m4e,g4e,_4e,y4e,v4e,IN,ZPt=M(()=>{NZ=.36363636363636365,f4e=6/11,p4e=8/11,d4e=3/4,m4e=9/11,g4e=10/11,_4e=15/16,y4e=21/22,v4e=63/64,IN=1/NZ/NZ});var DZ,JPt,QPt,OZ,t6t=M(()=>{DZ=1.70158,JPt=function e(t){t=+t;function r(n){return n*n*((t+1)*n-t)}return r.overshoot=e,r}(DZ),QPt=function e(t){t=+t;function r(n){return--n*n*((t+1)*n+t)+1}return r.overshoot=e,r}(DZ),OZ=function e(t){t=+t;function r(n){return((n*=2)<1?n*n*((t+1)*n-t):(n-=2)*n*((t+1)*n+t)+2)/2}return r.overshoot=e,r}(DZ)});var M2,zZ,FZ,e6t,BZ,r6t,n6t=M(()=>{M2=2*Math.PI,zZ=1,FZ=.3,e6t=function e(t,r){var n=Math.asin(1/(t=Math.max(1,t)))*(r/=M2);function i(o){return t*Math.pow(2,10*--o)*Math.sin((n-o)/r)}return i.amplitude=function(o){return e(o,r*M2)},i.period=function(o){return e(t,o)},i}(zZ,FZ),BZ=function e(t,r){var n=Math.asin(1/(t=Math.max(1,t)))*(r/=M2);function i(o){return 1-t*Math.pow(2,-10*(o=+o))*Math.sin((o+n)/r)}return i.amplitude=function(o){return e(o,r*M2)},i.period=function(o){return e(t,o)},i}(zZ,FZ),r6t=function e(t,r){var n=Math.asin(1/(t=Math.max(1,t)))*(r/=M2);function i(o){return((o=o*2-1)<0?t*Math.pow(2,10*o)*Math.sin((n-o)/r):2-t*Math.pow(2,-10*o)*Math.sin((n+o)/r))/2}return i.amplitude=function(o){return e(o,r*M2)},i.period=function(o){return e(t,o)},i}(zZ,FZ)});var i6t=M(()=>{APt();LPt();NPt();zPt();UPt();WPt();XPt();ZPt();t6t();n6t()});function o6t(e,t){var r;e==null&&(e=0),t==null&&(t=0);function n(){var i,o=r.length,a,s=0,l=0;for(i=0;i<o;++i)a=r[i],s+=a.x,l+=a.y;for(s=s/o-e,l=l/o-t,i=0;i<o;++i)a=r[i],a.x-=s,a.y-=l}return n.initialize=function(i){r=i},n.x=function(i){return arguments.length?(e=+i,n):e},n.y=function(i){return arguments.length?(t=+i,n):t},n}var a6t=M(()=>{});function zn(e){return function(){return e}}var Ty=M(()=>{});function Mu(){return(Math.random()-.5)*1e-6}var LN=M(()=>{});function s6t(e){var t=+this._x.call(null,e),r=+this._y.call(null,e);return l6t(this.cover(t,r),t,r,e)}function l6t(e,t,r,n){if(isNaN(t)||isNaN(r))return e;var i,o=e._root,a={data:n},s=e._x0,l=e._y0,c=e._x1,u=e._y1,h,f,p,d,g,_,y,x;if(!o)return e._root=a,e;for(;o.length;)if((g=t>=(h=(s+c)/2))?s=h:c=h,(_=r>=(f=(l+u)/2))?l=f:u=f,i=o,!(o=o[y=_<<1|g]))return i[y]=a,e;if(p=+e._x.call(null,o.data),d=+e._y.call(null,o.data),t===p&&r===d)return a.next=o,i?i[y]=a:e._root=a,e;do i=i?i[y]=new Array(4):e._root=new Array(4),(g=t>=(h=(s+c)/2))?s=h:c=h,(_=r>=(f=(l+u)/2))?l=f:u=f;while((y=_<<1|g)===(x=(d>=f)<<1|p>=h));return i[x]=o,i[y]=a,e}function c6t(e){var t,r,n=e.length,i,o,a=new Array(n),s=new Array(n),l=1/0,c=1/0,u=-1/0,h=-1/0;for(r=0;r<n;++r)isNaN(i=+this._x.call(null,t=e[r]))||isNaN(o=+this._y.call(null,t))||(a[r]=i,s[r]=o,i<l&&(l=i),i>u&&(u=i),o<c&&(c=o),o>h&&(h=o));if(l>u||c>h)return this;for(this.cover(l,c).cover(u,h),r=0;r<n;++r)l6t(this,a[r],s[r],e[r]);return this}var u6t=M(()=>{});function h6t(e,t){if(isNaN(e=+e)||isNaN(t=+t))return this;var r=this._x0,n=this._y0,i=this._x1,o=this._y1;if(isNaN(r))i=(r=Math.floor(e))+1,o=(n=Math.floor(t))+1;else{for(var a=i-r,s=this._root,l,c;r>e||e>=i||n>t||t>=o;)switch(c=(t<n)<<1|e<r,l=new Array(4),l[c]=s,s=l,a*=2,c){case 0:i=r+a,o=n+a;break;case 1:r=i-a,o=n+a;break;case 2:i=r+a,n=o-a;break;case 3:r=i-a,n=o-a;break}this._root&&this._root.length&&(this._root=s)}return this._x0=r,this._y0=n,this._x1=i,this._y1=o,this}var f6t=M(()=>{});function p6t(){var e=[];return this.visit(function(t){if(!t.length)do e.push(t.data);while(t=t.next)}),e}var d6t=M(()=>{});function m6t(e){return arguments.length?this.cover(+e[0][0],+e[0][1]).cover(+e[1][0],+e[1][1]):isNaN(this._x0)?void 0:[[this._x0,this._y0],[this._x1,this._y1]]}var g6t=M(()=>{});function So(e,t,r,n,i){this.node=e,this.x0=t,this.y0=r,this.x1=n,this.y1=i}var kN=M(()=>{});function _6t(e,t,r){var n,i=this._x0,o=this._y0,a,s,l,c,u=this._x1,h=this._y1,f=[],p=this._root,d,g;for(p&&f.push(new So(p,i,o,u,h)),r==null?r=1/0:(i=e-r,o=t-r,u=e+r,h=t+r,r*=r);d=f.pop();)if(!(!(p=d.node)||(a=d.x0)>u||(s=d.y0)>h||(l=d.x1)<i||(c=d.y1)<o))if(p.length){var _=(a+l)/2,y=(s+c)/2;f.push(new So(p[3],_,y,l,c),new So(p[2],a,y,_,c),new So(p[1],_,s,l,y),new So(p[0],a,s,_,y)),(g=(t>=y)<<1|e>=_)&&(d=f[f.length-1],f[f.length-1]=f[f.length-1-g],f[f.length-1-g]=d)}else{var x=e-+this._x.call(null,p.data),b=t-+this._y.call(null,p.data),S=x*x+b*b;if(S<r){var C=Math.sqrt(r=S);i=e-C,o=t-C,u=e+C,h=t+C,n=p.data}}return n}var y6t=M(()=>{kN()});function v6t(e){if(isNaN(u=+this._x.call(null,e))||isNaN(h=+this._y.call(null,e)))return this;var t,r=this._root,n,i,o,a=this._x0,s=this._y0,l=this._x1,c=this._y1,u,h,f,p,d,g,_,y;if(!r)return this;if(r.length)for(;;){if((d=u>=(f=(a+l)/2))?a=f:l=f,(g=h>=(p=(s+c)/2))?s=p:c=p,t=r,!(r=r[_=g<<1|d]))return this;if(!r.length)break;(t[_+1&3]||t[_+2&3]||t[_+3&3])&&(n=t,y=_)}for(;r.data!==e;)if(i=r,!(r=r.next))return this;return(o=r.next)&&delete r.next,i?(o?i.next=o:delete i.next,this):t?(o?t[_]=o:delete t[_],(r=t[0]||t[1]||t[2]||t[3])&&r===(t[3]||t[2]||t[1]||t[0])&&!r.length&&(n?n[y]=r:this._root=r),this):(this._root=o,this)}function x6t(e){for(var t=0,r=e.length;t<r;++t)this.remove(e[t]);return this}var b6t=M(()=>{});function w6t(){return this._root}var S6t=M(()=>{});function M6t(){var e=0;return this.visit(function(t){if(!t.length)do++e;while(t=t.next)}),e}var E6t=M(()=>{});function T6t(e){var t=[],r,n=this._root,i,o,a,s,l;for(n&&t.push(new So(n,this._x0,this._y0,this._x1,this._y1));r=t.pop();)if(!e(n=r.node,o=r.x0,a=r.y0,s=r.x1,l=r.y1)&&n.length){var c=(o+s)/2,u=(a+l)/2;(i=n[3])&&t.push(new So(i,c,u,s,l)),(i=n[2])&&t.push(new So(i,o,u,c,l)),(i=n[1])&&t.push(new So(i,c,a,s,u)),(i=n[0])&&t.push(new So(i,o,a,c,u))}return this}var C6t=M(()=>{kN()});function A6t(e){var t=[],r=[],n;for(this._root&&t.push(new So(this._root,this._x0,this._y0,this._x1,this._y1));n=t.pop();){var i=n.node;if(i.length){var o,a=n.x0,s=n.y0,l=n.x1,c=n.y1,u=(a+l)/2,h=(s+c)/2;(o=i[0])&&t.push(new So(o,a,s,u,h)),(o=i[1])&&t.push(new So(o,u,s,l,h)),(o=i[2])&&t.push(new So(o,a,h,u,c)),(o=i[3])&&t.push(new So(o,u,h,l,c))}r.push(n)}for(;n=r.pop();)e(n.node,n.x0,n.y0,n.x1,n.y1);return this}var P6t=M(()=>{kN()});function I6t(e){return e[0]}function L6t(e){return arguments.length?(this._x=e,this):this._x}var k6t=M(()=>{});function R6t(e){return e[1]}function N6t(e){return arguments.length?(this._y=e,this):this._y}var D6t=M(()=>{});function Cy(e,t,r){var n=new HZ(t==null?I6t:t,r==null?R6t:r,NaN,NaN,NaN,NaN);return e==null?n:n.addAll(e)}function HZ(e,t,r,n,i,o){this._x=e,this._y=t,this._x0=r,this._y0=n,this._x1=i,this._y1=o,this._root=void 0}function O6t(e){for(var t={data:e.data},r=t;e=e.next;)r=r.next={data:e.data};return t}var Ga,z6t=M(()=>{u6t();f6t();d6t();g6t();y6t();b6t();S6t();E6t();C6t();P6t();k6t();D6t();Ga=Cy.prototype=HZ.prototype;Ga.copy=function(){var e=new HZ(this._x,this._y,this._x0,this._y0,this._x1,this._y1),t=this._root,r,n;if(!t)return e;if(!t.length)return e._root=O6t(t),e;for(r=[{source:t,target:e._root=new Array(4)}];t=r.pop();)for(var i=0;i<4;++i)(n=t.source[i])&&(n.length?r.push({source:n,target:t.target[i]=new Array(4)}):t.target[i]=O6t(n));return e};Ga.add=s6t;Ga.addAll=c6t;Ga.cover=h6t;Ga.data=p6t;Ga.extent=m6t;Ga.find=_6t;Ga.remove=v6t;Ga.removeAll=x6t;Ga.root=w6t;Ga.size=M6t;Ga.visit=T6t;Ga.visitAfter=A6t;Ga.x=L6t;Ga.y=N6t});var VZ=M(()=>{z6t()});function x4e(e){return e.x+e.vx}function b4e(e){return e.y+e.vy}function F6t(e){var t,r,n=1,i=1;typeof e!="function"&&(e=zn(e==null?1:+e));function o(){for(var l,c=t.length,u,h,f,p,d,g,_=0;_<i;++_)for(u=Cy(t,x4e,b4e).visitAfter(a),l=0;l<c;++l)h=t[l],d=r[h.index],g=d*d,f=h.x+h.vx,p=h.y+h.vy,u.visit(y);function y(x,b,S,C,P){var k=x.data,O=x.r,D=d+O;if(k){if(k.index>h.index){var B=f-k.x-k.vx,I=p-k.y-k.vy,L=B*B+I*I;L<D*D&&(B===0&&(B=Mu(),L+=B*B),I===0&&(I=Mu(),L+=I*I),L=(D-(L=Math.sqrt(L)))/L*n,h.vx+=(B*=L)*(D=(O*=O)/(g+O)),h.vy+=(I*=L)*D,k.vx-=B*(D=1-D),k.vy-=I*D)}return}return b>f+D||C<f-D||S>p+D||P<p-D}}function a(l){if(l.data)return l.r=r[l.data.index];for(var c=l.r=0;c<4;++c)l[c]&&l[c].r>l.r&&(l.r=l[c].r)}function s(){if(!!t){var l,c=t.length,u;for(r=new Array(c),l=0;l<c;++l)u=t[l],r[u.index]=+e(u,l,t)}}return o.initialize=function(l){t=l,s()},o.iterations=function(l){return arguments.length?(i=+l,o):i},o.strength=function(l){return arguments.length?(n=+l,o):n},o.radius=function(l){return arguments.length?(e=typeof l=="function"?l:zn(+l),s(),o):e},o}var B6t=M(()=>{Ty();LN();VZ()});function RN(){}function H6t(e,t){var r=new RN;if(e instanceof RN)e.each(function(s,l){r.set(l,s)});else if(Array.isArray(e)){var n=-1,i=e.length,o;if(t==null)for(;++n<i;)r.set(n,e[n]);else for(;++n<i;)r.set(t(o=e[n],n,e),o)}else if(e)for(var a in e)r.set(a,e[a]);return r}var cl,pg,NN=M(()=>{cl="$";RN.prototype=H6t.prototype={constructor:RN,has:function(e){return cl+e in this},get:function(e){return this[cl+e]},set:function(e,t){return this[cl+e]=t,this},remove:function(e){var t=cl+e;return t in this&&delete this[t]},clear:function(){for(var e in this)e[0]===cl&&delete this[e]},keys:function(){var e=[];for(var t in this)t[0]===cl&&e.push(t.slice(1));return e},values:function(){var e=[];for(var t in this)t[0]===cl&&e.push(this[t]);return e},entries:function(){var e=[];for(var t in this)t[0]===cl&&e.push({key:t.slice(1),value:this[t]});return e},size:function(){var e=0;for(var t in this)t[0]===cl&&++e;return e},empty:function(){for(var e in this)if(e[0]===cl)return!1;return!0},each:function(e){for(var t in this)t[0]===cl&&e(this[t],t.slice(1),this)}};pg=H6t});var V6t=M(()=>{NN()});function DN(){}function w4e(e,t){var r=new DN;if(e instanceof DN)e.each(function(o){r.add(o)});else if(e){var n=-1,i=e.length;if(t==null)for(;++n<i;)r.add(e[n]);else for(;++n<i;)r.add(t(e[n],n,e))}return r}var Ay,U6t=M(()=>{NN();Ay=pg.prototype;DN.prototype=w4e.prototype={constructor:DN,has:Ay.has,add:function(e){return e+="",this[cl+e]=e,this},remove:Ay.remove,clear:Ay.clear,values:Ay.keys,size:Ay.size,empty:Ay.empty,each:Ay.each}});var q6t=M(()=>{});var G6t=M(()=>{});var W6t=M(()=>{});var UZ=M(()=>{V6t();U6t();NN();q6t();G6t();W6t()});function S4e(e){return e.index}function Y6t(e,t){var r=e.get(t);if(!r)throw new Error("missing: "+t);return r}function j6t(e){var t=S4e,r=u,n,i=zn(30),o,a,s,l,c=1;e==null&&(e=[]);function u(g){return 1/Math.min(s[g.source.index],s[g.target.index])}function h(g){for(var _=0,y=e.length;_<c;++_)for(var x=0,b,S,C,P,k,O,D;x<y;++x)b=e[x],S=b.source,C=b.target,P=C.x+C.vx-S.x-S.vx||Mu(),k=C.y+C.vy-S.y-S.vy||Mu(),O=Math.sqrt(P*P+k*k),O=(O-o[x])/O*g*n[x],P*=O,k*=O,C.vx-=P*(D=l[x]),C.vy-=k*D,S.vx+=P*(D=1-D),S.vy+=k*D}function f(){if(!!a){var g,_=a.length,y=e.length,x=pg(a,t),b;for(g=0,s=new Array(_);g<y;++g)b=e[g],b.index=g,typeof b.source!="object"&&(b.source=Y6t(x,b.source)),typeof b.target!="object"&&(b.target=Y6t(x,b.target)),s[b.source.index]=(s[b.source.index]||0)+1,s[b.target.index]=(s[b.target.index]||0)+1;for(g=0,l=new Array(y);g<y;++g)b=e[g],l[g]=s[b.source.index]/(s[b.source.index]+s[b.target.index]);n=new Array(y),p(),o=new Array(y),d()}}function p(){if(!!a)for(var g=0,_=e.length;g<_;++g)n[g]=+r(e[g],g,e)}function d(){if(!!a)for(var g=0,_=e.length;g<_;++g)o[g]=+i(e[g],g,e)}return h.initialize=function(g){a=g,f()},h.links=function(g){return arguments.length?(e=g,f(),h):e},h.id=function(g){return arguments.length?(t=g,h):t},h.iterations=function(g){return arguments.length?(c=+g,h):c},h.strength=function(g){return arguments.length?(r=typeof g=="function"?g:zn(+g),p(),h):r},h.distance=function(g){return arguments.length?(i=typeof g=="function"?g:zn(+g),d(),h):i},h}var X6t=M(()=>{Ty();LN();UZ()});function K6t(){for(var e=0,t=arguments.length,r={},n;e<t;++e){if(!(n=arguments[e]+"")||n in r||/[\s.]/.test(n))throw new Error("illegal type: "+n);r[n]=[]}return new ON(r)}function ON(e){this._=e}function E4e(e,t){return e.trim().split(/^|\s+/).map(function(r){var n="",i=r.indexOf(".");if(i>=0&&(n=r.slice(i+1),r=r.slice(0,i)),r&&!t.hasOwnProperty(r))throw new Error("unknown type: "+r);return{type:r,name:n}})}function T4e(e,t){for(var r=0,n=e.length,i;r<n;++r)if((i=e[r]).name===t)return i.value}function $6t(e,t,r){for(var n=0,i=e.length;n<i;++n)if(e[n].name===t){e[n]=M4e,e=e.slice(0,n).concat(e.slice(n+1));break}return r!=null&&e.push({name:t,value:r}),e}var M4e,qZ,Z6t=M(()=>{M4e={value:function(){}};ON.prototype=K6t.prototype={constructor:ON,on:function(e,t){var r=this._,n=E4e(e+"",r),i,o=-1,a=n.length;if(arguments.length<2){for(;++o<a;)if((i=(e=n[o]).type)&&(i=T4e(r[i],e.name)))return i;return}if(t!=null&&typeof t!="function")throw new Error("invalid callback: "+t);for(;++o<a;)if(i=(e=n[o]).type)r[i]=$6t(r[i],e.name,t);else if(t==null)for(i in r)r[i]=$6t(r[i],e.name,null);return this},copy:function(){var e={},t=this._;for(var r in t)e[r]=t[r].slice();return new ON(e)},call:function(e,t){if((i=arguments.length-2)>0)for(var r=new Array(i),n=0,i,o;n<i;++n)r[n]=arguments[n+2];if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(o=this._[e],n=0,i=o.length;n<i;++n)o[n].value.apply(t,r)},apply:function(e,t,r){if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(var n=this._[e],i=0,o=n.length;i<o;++i)n[i].value.apply(t,r)}};qZ=K6t});var J6t=M(()=>{Z6t()});function YZ(){return Py||(eIt(C4e),Py=ET.now()+BN)}function C4e(){Py=0}function GZ(){this._call=this._time=this._next=null}function HN(e,t,r){var n=new GZ;return n.restart(e,t,r),n}function rIt(){YZ(),++E2;for(var e=zN,t;e;)(t=Py-e._time)>=0&&e._call.call(null,t),e=e._next;--E2}function Q6t(){Py=(FN=ET.now())+BN,E2=ST=0;try{rIt()}finally{E2=0,P4e(),Py=0}}function A4e(){var e=ET.now(),t=e-FN;t>tIt&&(BN-=t,FN=e)}function P4e(){for(var e,t=zN,r,n=1/0;t;)t._call?(n>t._time&&(n=t._time),e=t,t=t._next):(r=t._next,t._next=null,t=e?e._next=r:zN=r);MT=e,WZ(n)}function WZ(e){if(!E2){ST&&(ST=clearTimeout(ST));var t=e-Py;t>24?(e<1/0&&(ST=setTimeout(Q6t,e-ET.now()-BN)),wT&&(wT=clearInterval(wT))):(wT||(FN=ET.now(),wT=setInterval(A4e,tIt)),E2=1,eIt(Q6t))}}var E2,ST,wT,tIt,zN,MT,FN,Py,BN,ET,eIt,nIt=M(()=>{E2=0,ST=0,wT=0,tIt=1e3,FN=0,Py=0,BN=0,ET=typeof performance=="object"&&performance.now?performance:Date,eIt=typeof window=="object"&&window.requestAnimationFrame?window.requestAnimationFrame.bind(window):function(e){setTimeout(e,17)};GZ.prototype=HN.prototype={constructor:GZ,restart:function(e,t,r){if(typeof e!="function")throw new TypeError("callback is not a function");r=(r==null?YZ():+r)+(t==null?0:+t),!this._next&&MT!==this&&(MT?MT._next=this:zN=this,MT=this),this._call=e,this._time=r,WZ()},stop:function(){this._call&&(this._call=null,this._time=1/0,WZ())}}});var iIt=M(()=>{nIt()});function oIt(e){return e.x}function aIt(e){return e.y}function sIt(e){var t,r=1,n=.001,i=1-Math.pow(n,1/300),o=0,a=.6,s=pg(),l=HN(u),c=qZ("tick","end");e==null&&(e=[]);function u(){h(),c.call("tick",t),r<n&&(l.stop(),c.call("end",t))}function h(){var d,g=e.length,_;for(r+=(o-r)*i,s.each(function(y){y(r)}),d=0;d<g;++d)_=e[d],_.fx==null?_.x+=_.vx*=a:(_.x=_.fx,_.vx=0),_.fy==null?_.y+=_.vy*=a:(_.y=_.fy,_.vy=0)}function f(){for(var d=0,g=e.length,_;d<g;++d){if(_=e[d],_.index=d,isNaN(_.x)||isNaN(_.y)){var y=I4e*Math.sqrt(d),x=d*L4e;_.x=y*Math.cos(x),_.y=y*Math.sin(x)}(isNaN(_.vx)||isNaN(_.vy))&&(_.vx=_.vy=0)}}function p(d){return d.initialize&&d.initialize(e),d}return f(),t={tick:h,restart:function(){return l.restart(u),t},stop:function(){return l.stop(),t},nodes:function(d){return arguments.length?(e=d,f(),s.each(p),t):e},alpha:function(d){return arguments.length?(r=+d,t):r},alphaMin:function(d){return arguments.length?(n=+d,t):n},alphaDecay:function(d){return arguments.length?(i=+d,t):+i},alphaTarget:function(d){return arguments.length?(o=+d,t):o},velocityDecay:function(d){return arguments.length?(a=1-d,t):1-a},force:function(d,g){return arguments.length>1?(g==null?s.remove(d):s.set(d,p(g)),t):s.get(d)},find:function(d,g,_){var y=0,x=e.length,b,S,C,P,k;for(_==null?_=1/0:_*=_,y=0;y<x;++y)P=e[y],b=d-P.x,S=g-P.y,C=b*b+S*S,C<_&&(k=P,_=C);return k},on:function(d,g){return arguments.length>1?(c.on(d,g),t):c.on(d)}}}var I4e,L4e,jZ=M(()=>{J6t();UZ();iIt();I4e=10,L4e=Math.PI*(3-Math.sqrt(5))});function lIt(){var e,t,r,n=zn(-30),i,o=1,a=1/0,s=.81;function l(f){var p,d=e.length,g=Cy(e,oIt,aIt).visitAfter(u);for(r=f,p=0;p<d;++p)t=e[p],g.visit(h)}function c(){if(!!e){var f,p=e.length,d;for(i=new Array(p),f=0;f<p;++f)d=e[f],i[d.index]=+n(d,f,e)}}function u(f){var p=0,d,g,_=0,y,x,b;if(f.length){for(y=x=b=0;b<4;++b)(d=f[b])&&(g=Math.abs(d.value))&&(p+=d.value,_+=g,y+=g*d.x,x+=g*d.y);f.x=y/_,f.y=x/_}else{d=f,d.x=d.data.x,d.y=d.data.y;do p+=i[d.data.index];while(d=d.next)}f.value=p}function h(f,p,d,g){if(!f.value)return!0;var _=f.x-t.x,y=f.y-t.y,x=g-p,b=_*_+y*y;if(x*x/s<b)return b<a&&(_===0&&(_=Mu(),b+=_*_),y===0&&(y=Mu(),b+=y*y),b<o&&(b=Math.sqrt(o*b)),t.vx+=_*f.value*r/b,t.vy+=y*f.value*r/b),!0;if(f.length||b>=a)return;(f.data!==t||f.next)&&(_===0&&(_=Mu(),b+=_*_),y===0&&(y=Mu(),b+=y*y),b<o&&(b=Math.sqrt(o*b)));do f.data!==t&&(x=i[f.data.index]*r/b,t.vx+=_*x,t.vy+=y*x);while(f=f.next)}return l.initialize=function(f){e=f,c()},l.strength=function(f){return arguments.length?(n=typeof f=="function"?f:zn(+f),c(),l):n},l.distanceMin=function(f){return arguments.length?(o=f*f,l):Math.sqrt(o)},l.distanceMax=function(f){return arguments.length?(a=f*f,l):Math.sqrt(a)},l.theta=function(f){return arguments.length?(s=f*f,l):Math.sqrt(s)},l}var cIt=M(()=>{Ty();LN();VZ();jZ()});function uIt(e,t,r){var n,i=zn(.1),o,a;typeof e!="function"&&(e=zn(+e)),t==null&&(t=0),r==null&&(r=0);function s(c){for(var u=0,h=n.length;u<h;++u){var f=n[u],p=f.x-t||1e-6,d=f.y-r||1e-6,g=Math.sqrt(p*p+d*d),_=(a[u]-g)*o[u]*c/g;f.vx+=p*_,f.vy+=d*_}}function l(){if(!!n){var c,u=n.length;for(o=new Array(u),a=new Array(u),c=0;c<u;++c)a[c]=+e(n[c],c,n),o[c]=isNaN(a[c])?0:+i(n[c],c,n)}}return s.initialize=function(c){n=c,l()},s.strength=function(c){return arguments.length?(i=typeof c=="function"?c:zn(+c),l(),s):i},s.radius=function(c){return arguments.length?(e=typeof c=="function"?c:zn(+c),l(),s):e},s.x=function(c){return arguments.length?(t=+c,s):t},s.y=function(c){return arguments.length?(r=+c,s):r},s}var hIt=M(()=>{Ty()});function fIt(e){var t=zn(.1),r,n,i;typeof e!="function"&&(e=zn(e==null?0:+e));function o(s){for(var l=0,c=r.length,u;l<c;++l)u=r[l],u.vx+=(i[l]-u.x)*n[l]*s}function a(){if(!!r){var s,l=r.length;for(n=new Array(l),i=new Array(l),s=0;s<l;++s)n[s]=isNaN(i[s]=+e(r[s],s,r))?0:+t(r[s],s,r)}}return o.initialize=function(s){r=s,a()},o.strength=function(s){return arguments.length?(t=typeof s=="function"?s:zn(+s),a(),o):t},o.x=function(s){return arguments.length?(e=typeof s=="function"?s:zn(+s),a(),o):e},o}var pIt=M(()=>{Ty()});function dIt(e){var t=zn(.1),r,n,i;typeof e!="function"&&(e=zn(e==null?0:+e));function o(s){for(var l=0,c=r.length,u;l<c;++l)u=r[l],u.vy+=(i[l]-u.y)*n[l]*s}function a(){if(!!r){var s,l=r.length;for(n=new Array(l),i=new Array(l),s=0;s<l;++s)n[s]=isNaN(i[s]=+e(r[s],s,r))?0:+t(r[s],s,r)}}return o.initialize=function(s){r=s,a()},o.strength=function(s){return arguments.length?(t=typeof s=="function"?s:zn(+s),a(),o):t},o.y=function(s){return arguments.length?(e=typeof s=="function"?s:zn(+s),a(),o):e},o}var mIt=M(()=>{Ty()});var gIt=M(()=>{a6t();B6t();X6t();cIt();hIt();jZ();pIt();mIt()});function Iy(e,t){if((r=(e=t?e.toExponential(t-1):e.toExponential()).indexOf("e"))<0)return null;var r,n=e.slice(0,r);return[n.length>1?n[0]+n.slice(2):n,+e.slice(r+1)]}var VN=M(()=>{});function rf(e){return e=Iy(Math.abs(e)),e?e[1]:NaN}var TT=M(()=>{VN()});function _It(e,t){return function(r,n){for(var i=r.length,o=[],a=0,s=e[0],l=0;i>0&&s>0&&(l+s+1>n&&(s=Math.max(1,n-l)),o.push(r.substring(i-=s,i+s)),!((l+=s+1)>n));)s=e[a=(a+1)%e.length];return o.reverse().join(t)}}var yIt=M(()=>{});function vIt(e){return function(t){return t.replace(/[0-9]/g,function(r){return e[+r]})}}var xIt=M(()=>{});function bIt(e,t){e=e.toPrecision(t);t:for(var r=e.length,n=1,i=-1,o;n<r;++n)switch(e[n]){case".":i=o=n;break;case"0":i===0&&(i=n),o=n;break;case"e":break t;default:i>0&&(i=0);break}return i>0?e.slice(0,i)+e.slice(o+1):e}var wIt=M(()=>{});function SIt(e,t){var r=Iy(e,t);if(!r)return e+"";var n=r[0],i=r[1],o=i-(XZ=Math.max(-8,Math.min(8,Math.floor(i/3)))*3)+1,a=n.length;return o===a?n:o>a?n+new Array(o-a+1).join("0"):o>0?n.slice(0,o)+"."+n.slice(o):"0."+new Array(1-o).join("0")+Iy(e,Math.max(0,t+o-1))[0]}var XZ,$Z=M(()=>{VN()});function KZ(e,t){var r=Iy(e,t);if(!r)return e+"";var n=r[0],i=r[1];return i<0?"0."+new Array(-i).join("0")+n:n.length>i+1?n.slice(0,i+1)+"."+n.slice(i+1):n+new Array(i-n.length+2).join("0")}var MIt=M(()=>{VN()});var UN,ZZ=M(()=>{wIt();$Z();MIt();UN={"":bIt,"%":function(e,t){return(e*100).toFixed(t)},b:function(e){return Math.round(e).toString(2)},c:function(e){return e+""},d:function(e){return Math.round(e).toString(10)},e:function(e,t){return e.toExponential(t)},f:function(e,t){return e.toFixed(t)},g:function(e,t){return e.toPrecision(t)},o:function(e){return Math.round(e).toString(8)},p:function(e,t){return KZ(e*100,t)},r:KZ,s:SIt,X:function(e){return Math.round(e).toString(16).toUpperCase()},x:function(e){return Math.round(e).toString(16)}}});function Ly(e){return new JZ(e)}function JZ(e){if(!(t=k4e.exec(e)))throw new Error("invalid format: "+e);var t,r=t[1]||" ",n=t[2]||">",i=t[3]||"-",o=t[4]||"",a=!!t[5],s=t[6]&&+t[6],l=!!t[7],c=t[8]&&+t[8].slice(1),u=t[9]||"";u==="n"?(l=!0,u="g"):UN[u]||(u=""),(a||r==="0"&&n==="=")&&(a=!0,r="0",n="="),this.fill=r,this.align=n,this.sign=i,this.symbol=o,this.zero=a,this.width=s,this.comma=l,this.precision=c,this.type=u}var k4e,QZ=M(()=>{ZZ();k4e=/^(?:(.)?([<>=^]))?([+\-\( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?([a-z%])?$/i;Ly.prototype=JZ.prototype;JZ.prototype.toString=function(){return this.fill+this.align+this.sign+this.symbol+(this.zero?"0":"")+(this.width==null?"":Math.max(1,this.width|0))+(this.comma?",":"")+(this.precision==null?"":"."+Math.max(0,this.precision|0))+this.type}});function tJ(e){return e}var EIt=M(()=>{});function qN(e){var t=e.grouping&&e.thousands?_It(e.grouping,e.thousands):tJ,r=e.currency,n=e.decimal,i=e.numerals?vIt(e.numerals):tJ,o=e.percent||"%";function a(l){l=Ly(l);var c=l.fill,u=l.align,h=l.sign,f=l.symbol,p=l.zero,d=l.width,g=l.comma,_=l.precision,y=l.type,x=f==="$"?r[0]:f==="#"&&/[boxX]/.test(y)?"0"+y.toLowerCase():"",b=f==="$"?r[1]:/[%p]/.test(y)?o:"",S=UN[y],C=!y||/[defgprs%]/.test(y);_=_==null?y?6:12:/[gprs]/.test(y)?Math.max(1,Math.min(21,_)):Math.max(0,Math.min(20,_));function P(k){var O=x,D=b,B,I,L;if(y==="c")D=S(k)+D,k="";else{k=+k;var R=k<0;if(k=S(Math.abs(k),_),R&&+k==0&&(R=!1),O=(R?h==="("?h:"-":h==="-"||h==="("?"":h)+O,D=(y==="s"?TIt[8+XZ/3]:"")+D+(R&&h==="("?")":""),C){for(B=-1,I=k.length;++B<I;)if(L=k.charCodeAt(B),48>L||L>57){D=(L===46?n+k.slice(B+1):k.slice(B))+D,k=k.slice(0,B);break}}}g&&!p&&(k=t(k,1/0));var F=O.length+k.length+D.length,z=F<d?new Array(d-F+1).join(c):"";switch(g&&p&&(k=t(z+k,z.length?d-D.length:1/0),z=""),u){case"<":k=O+k+D+z;break;case"=":k=O+z+k+D;break;case"^":k=z.slice(0,F=z.length>>1)+O+k+D+z.slice(F);break;default:k=z+O+k+D;break}return i(k)}return P.toString=function(){return l+""},P}function s(l,c){var u=a((l=Ly(l),l.type="f",l)),h=Math.max(-8,Math.min(8,Math.floor(rf(c)/3)))*3,f=Math.pow(10,-h),p=TIt[8+h/3];return function(d){return u(f*d)+p}}return{format:a,formatPrefix:s}}var TIt,eJ=M(()=>{TT();yIt();xIt();QZ();ZZ();$Z();EIt();TIt=["y","z","a","f","p","n","\xB5","m","","k","M","G","T","P","E","Z","Y"]});function WN(e){return GN=qN(e),rJ=GN.format,nJ=GN.formatPrefix,GN}var GN,rJ,nJ,CIt=M(()=>{eJ();WN({decimal:".",thousands:",",grouping:[3],currency:["$",""]})});function AIt(e){return Math.max(0,-rf(Math.abs(e)))}var PIt=M(()=>{TT()});function IIt(e,t){return Math.max(0,Math.max(-8,Math.min(8,Math.floor(rf(t)/3)))*3-rf(Math.abs(e)))}var LIt=M(()=>{TT()});function kIt(e,t){return e=Math.abs(e),t=Math.abs(t)-e,Math.max(0,rf(t)-rf(e))+1}var RIt=M(()=>{TT()});var NIt=M(()=>{CIt();eJ();QZ();PIt();LIt();RIt()});function Cs(){return new jN}function jN(){this.reset()}function DIt(e,t,r){var n=e.s=t+r,i=n-t,o=n-i;e.t=t-o+(r-i)}var YN,ky=M(()=>{jN.prototype={constructor:jN,reset:function(){this.s=this.t=0},add:function(e){DIt(YN,e,this.t),DIt(this,YN.s,this.s),this.s?this.t+=YN.t:this.s=YN.t},valueOf:function(){return this.s}};YN=new jN});function KN(e){return e>1?0:e<-1?rr:Math.acos(e)}function Zn(e){return e>1?Fn:e<-1?-Fn:Math.asin(e)}function oJ(e){return(e=Jt(e/2))*e}var ce,iJ,rr,Fn,T2,Bi,Ur,we,Ye,yc,Sn,ae,CT,XN,Ry,$N,Jt,dg,Rr,C2,lr=M(()=>{ce=1e-6,iJ=1e-12,rr=Math.PI,Fn=rr/2,T2=rr/4,Bi=rr*2,Ur=180/rr,we=rr/180,Ye=Math.abs,yc=Math.atan,Sn=Math.atan2,ae=Math.cos,CT=Math.ceil,XN=Math.exp,Ry=Math.log,$N=Math.pow,Jt=Math.sin,dg=Math.sign||function(e){return e>0?1:e<0?-1:0},Rr=Math.sqrt,C2=Math.tan});function qr(){}var Xp=M(()=>{});function ZN(e,t){e&&zIt.hasOwnProperty(e.type)&&zIt[e.type](e,t)}function aJ(e,t,r){var n=-1,i=e.length-r,o;for(t.lineStart();++n<i;)o=e[n],t.point(o[0],o[1],o[2]);t.lineEnd()}function FIt(e,t){var r=-1,n=e.length;for(t.polygonStart();++r<n;)aJ(e[r],t,1);t.polygonEnd()}function Mo(e,t){e&&OIt.hasOwnProperty(e.type)?OIt[e.type](e,t):ZN(e,t)}var OIt,zIt,mg=M(()=>{OIt={Feature:function(e,t){ZN(e.geometry,t)},FeatureCollection:function(e,t){for(var r=e.features,n=-1,i=r.length;++n<i;)ZN(r[n].geometry,t)}},zIt={Sphere:function(e,t){t.sphere()},Point:function(e,t){e=e.coordinates,t.point(e[0],e[1],e[2])},MultiPoint:function(e,t){for(var r=e.coordinates,n=-1,i=r.length;++n<i;)e=r[n],t.point(e[0],e[1],e[2])},LineString:function(e,t){aJ(e.coordinates,t,0)},MultiLineString:function(e,t){for(var r=e.coordinates,n=-1,i=r.length;++n<i;)aJ(r[n],t,0)},Polygon:function(e,t){FIt(e.coordinates,t)},MultiPolygon:function(e,t){for(var r=e.coordinates,n=-1,i=r.length;++n<i;)FIt(r[n],t)},GeometryCollection:function(e,t){for(var r=e.geometries,n=-1,i=r.length;++n<i;)ZN(r[n],t)}}});function R4e(){Eu.point=D4e}function N4e(){VIt(BIt,HIt)}function D4e(e,t){Eu.point=VIt,BIt=e,HIt=t,e*=we,t*=we,sJ=e,lJ=ae(t=t/2+T2),cJ=Jt(t)}function VIt(e,t){e*=we,t*=we,t=t/2+T2;var r=e-sJ,n=r>=0?1:-1,i=n*r,o=ae(t),a=Jt(t),s=cJ*a,l=lJ*o+s*ae(i),c=s*n*Jt(i);AT.add(Sn(c,l)),sJ=e,lJ=o,cJ=a}function UIt(e){return JN.reset(),Mo(e,Eu),JN*2}var AT,JN,BIt,HIt,sJ,lJ,cJ,Eu,uJ=M(()=>{ky();lr();Xp();mg();AT=Cs(),JN=Cs(),Eu={point:qr,lineStart:qr,lineEnd:qr,polygonStart:function(){AT.reset(),Eu.lineStart=R4e,Eu.lineEnd=N4e},polygonEnd:function(){var e=+AT;JN.add(e<0?Bi+e:e),this.lineStart=this.lineEnd=this.point=qr},sphere:function(){JN.add(Bi)}}});function Ny(e){return[Sn(e[1],e[0]),Zn(e[2])]}function vc(e){var t=e[0],r=e[1],n=ae(r);return[n*ae(t),n*Jt(t),Jt(r)]}function PT(e,t){return e[0]*t[0]+e[1]*t[1]+e[2]*t[2]}function $p(e,t){return[e[1]*t[2]-e[2]*t[1],e[2]*t[0]-e[0]*t[2],e[0]*t[1]-e[1]*t[0]]}function QN(e,t){e[0]+=t[0],e[1]+=t[1],e[2]+=t[2]}function IT(e,t){return[e[0]*t,e[1]*t,e[2]*t]}function Dy(e){var t=Rr(e[0]*e[0]+e[1]*e[1]+e[2]*e[2]);e[0]/=t,e[1]/=t,e[2]/=t}var A2=M(()=>{lr()});function hJ(e,t){gg.push(Zp=[di=e,Ei=e]),t<hl&&(hl=t),t>xc&&(xc=t)}function XIt(e,t){var r=vc([e*we,t*we]);if(P2){var n=$p(P2,r),i=[n[1],-n[0],0],o=$p(i,n);Dy(o),o=Ny(o);var a=e-Oy,s=a>0?1:-1,l=o[0]*Ur*s,c,u=Ye(a)>180;u^(s*Oy<l&&l<s*e)?(c=o[1]*Ur,c>xc&&(xc=c)):(l=(l+360)%360-180,u^(s*Oy<l&&l<s*e)?(c=-o[1]*Ur,c<hl&&(hl=c)):(t<hl&&(hl=t),t>xc&&(xc=t))),u?e<Oy?ul(di,e)>ul(di,Ei)&&(Ei=e):ul(e,Ei)>ul(di,Ei)&&(di=e):Ei>=di?(e<di&&(di=e),e>Ei&&(Ei=e)):e>Oy?ul(di,e)>ul(di,Ei)&&(Ei=e):ul(e,Ei)>ul(di,Ei)&&(di=e)}else gg.push(Zp=[di=e,Ei=e]);t<hl&&(hl=t),t>xc&&(xc=t),P2=r,Oy=e}function qIt(){Kp.point=XIt}function GIt(){Zp[0]=di,Zp[1]=Ei,Kp.point=hJ,P2=null}function $It(e,t){if(P2){var r=e-Oy;LT.add(Ye(r)>180?r+(r>0?360:-360):r)}else YIt=e,jIt=t;Eu.point(e,t),XIt(e,t)}function O4e(){Eu.lineStart()}function z4e(){$It(YIt,jIt),Eu.lineEnd(),Ye(LT)>ce&&(di=-(Ei=180)),Zp[0]=di,Zp[1]=Ei,P2=null}function ul(e,t){return(t-=e)<0?t+360:t}function F4e(e,t){return e[0]-t[0]}function WIt(e,t){return e[0]<=e[1]?e[0]<=t&&t<=e[1]:t<e[0]||e[1]<t}function KIt(e){var t,r,n,i,o,a,s;if(xc=Ei=-(di=hl=1/0),gg=[],Mo(e,Kp),r=gg.length){for(gg.sort(F4e),t=1,n=gg[0],o=[n];t<r;++t)i=gg[t],WIt(n,i[0])||WIt(n,i[1])?(ul(n[0],i[1])>ul(n[0],n[1])&&(n[1]=i[1]),ul(i[0],n[1])>ul(n[0],n[1])&&(n[0]=i[0])):o.push(n=i);for(a=-1/0,r=o.length-1,t=0,n=o[r];t<=r;n=i,++t)i=o[t],(s=ul(n[1],i[0]))>a&&(a=s,di=i[0],Ei=n[1])}return gg=Zp=null,di===1/0||hl===1/0?[[NaN,NaN],[NaN,NaN]]:[[di,hl],[Ei,xc]]}var di,hl,Ei,xc,Oy,YIt,jIt,P2,LT,gg,Zp,Kp,ZIt=M(()=>{ky();uJ();A2();lr();mg();LT=Cs(),Kp={point:hJ,lineStart:qIt,lineEnd:GIt,polygonStart:function(){Kp.point=$It,Kp.lineStart=O4e,Kp.lineEnd=z4e,LT.reset(),Eu.polygonStart()},polygonEnd:function(){Eu.polygonEnd(),Kp.point=hJ,Kp.lineStart=qIt,Kp.lineEnd=GIt,AT<0?(di=-(Ei=180),hl=-(xc=90)):LT>ce?xc=90:LT<-ce&&(hl=-90),Zp[0]=di,Zp[1]=Ei}}});function mJ(e,t){e*=we,t*=we;var r=ae(t);RT(r*ae(e),r*Jt(e),Jt(t))}function RT(e,t,r){++kT,eD+=(e-eD)/kT,rD+=(t-rD)/kT,nD+=(r-nD)/kT}function JIt(){Tu.point=B4e}function B4e(e,t){e*=we,t*=we;var r=ae(t);Wa=r*ae(e),Ya=r*Jt(e),ja=Jt(t),Tu.point=H4e,RT(Wa,Ya,ja)}function H4e(e,t){e*=we,t*=we;var r=ae(t),n=r*ae(e),i=r*Jt(e),o=Jt(t),a=Sn(Rr((a=Ya*o-ja*i)*a+(a=ja*n-Wa*o)*a+(a=Wa*i-Ya*n)*a),Wa*n+Ya*i+ja*o);tD+=a,iD+=a*(Wa+(Wa=n)),oD+=a*(Ya+(Ya=i)),aD+=a*(ja+(ja=o)),RT(Wa,Ya,ja)}function QIt(){Tu.point=mJ}function V4e(){Tu.point=q4e}function U4e(){r9t(t9t,e9t),Tu.point=mJ}function q4e(e,t){t9t=e,e9t=t,e*=we,t*=we,Tu.point=r9t;var r=ae(t);Wa=r*ae(e),Ya=r*Jt(e),ja=Jt(t),RT(Wa,Ya,ja)}function r9t(e,t){e*=we,t*=we;var r=ae(t),n=r*ae(e),i=r*Jt(e),o=Jt(t),a=Ya*o-ja*i,s=ja*n-Wa*o,l=Wa*i-Ya*n,c=Rr(a*a+s*s+l*l),u=Zn(c),h=c&&-u/c;fJ+=h*a,pJ+=h*s,dJ+=h*l,tD+=u,iD+=u*(Wa+(Wa=n)),oD+=u*(Ya+(Ya=i)),aD+=u*(ja+(ja=o)),RT(Wa,Ya,ja)}function n9t(e){kT=tD=eD=rD=nD=iD=oD=aD=fJ=pJ=dJ=0,Mo(e,Tu);var t=fJ,r=pJ,n=dJ,i=t*t+r*r+n*n;return i<iJ&&(t=iD,r=oD,n=aD,tD<ce&&(t=eD,r=rD,n=nD),i=t*t+r*r+n*n,i<iJ)?[NaN,NaN]:[Sn(r,t)*Ur,Zn(n/Rr(i))*Ur]}var kT,tD,eD,rD,nD,iD,oD,aD,fJ,pJ,dJ,t9t,e9t,Wa,Ya,ja,Tu,i9t=M(()=>{lr();Xp();mg();Tu={sphere:qr,point:mJ,lineStart:JIt,lineEnd:QIt,polygonStart:function(){Tu.lineStart=V4e,Tu.lineEnd=U4e},polygonEnd:function(){Tu.lineStart=JIt,Tu.lineEnd=QIt}}});function zy(e){return function(){return e}}var o9t=M(()=>{});function sD(e,t){function r(n,i){return n=e(n,i),t(n[0],n[1])}return e.invert&&t.invert&&(r.invert=function(n,i){return n=t.invert(n,i),n&&e.invert(n[0],n[1])}),r}var gJ=M(()=>{});function _J(e,t){return[e>rr?e-Bi:e<-rr?e+Bi:e,t]}function NT(e,t,r){return(e%=Bi)?t||r?sD(s9t(e),l9t(t,r)):s9t(e):t||r?l9t(t,r):_J}function a9t(e){return function(t,r){return t+=e,[t>rr?t-Bi:t<-rr?t+Bi:t,r]}}function s9t(e){var t=a9t(e);return t.invert=a9t(-e),t}function l9t(e,t){var r=ae(e),n=Jt(e),i=ae(t),o=Jt(t);function a(s,l){var c=ae(l),u=ae(s)*c,h=Jt(s)*c,f=Jt(l),p=f*r+u*n;return[Sn(h*i-p*o,u*r-f*n),Zn(p*i+h*o)]}return a.invert=function(s,l){var c=ae(l),u=ae(s)*c,h=Jt(s)*c,f=Jt(l),p=f*i-h*o;return[Sn(h*i+f*o,u*r+p*n),Zn(p*r-u*n)]},a}function lD(e){e=NT(e[0]*we,e[1]*we,e.length>2?e[2]*we:0);function t(r){return r=e(r[0]*we,r[1]*we),r[0]*=Ur,r[1]*=Ur,r}return t.invert=function(r){return r=e.invert(r[0]*we,r[1]*we),r[0]*=Ur,r[1]*=Ur,r},t}var DT=M(()=>{gJ();lr();_J.invert=_J});function yJ(e,t,r,n,i,o){if(!!r){var a=ae(t),s=Jt(t),l=n*r;i==null?(i=t+n*Bi,o=t-l/2):(i=c9t(a,i),o=c9t(a,o),(n>0?i<o:i>o)&&(i+=n*Bi));for(var c,u=i;n>0?u>o:u<o;u-=l)c=Ny([a,-s*ae(u),-s*Jt(u)]),e.point(c[0],c[1])}}function c9t(e,t){t=vc(t),t[0]-=e,Dy(t);var r=KN(-t[1]);return((-t[2]<0?-r:r)+Bi-ce)%Bi}function u9t(){var e=zy([0,0]),t=zy(90),r=zy(6),n,i,o={point:a};function a(l,c){n.push(l=i(l,c)),l[0]*=Ur,l[1]*=Ur}function s(){var l=e.apply(this,arguments),c=t.apply(this,arguments)*we,u=r.apply(this,arguments)*we;return n=[],i=NT(-l[0]*we,-l[1]*we,0).invert,yJ(o,c,u,1),l={type:"Polygon",coordinates:[n]},n=i=null,l}return s.center=function(l){return arguments.length?(e=typeof l=="function"?l:zy([+l[0],+l[1]]),s):e},s.radius=function(l){return arguments.length?(t=typeof l=="function"?l:zy(+l),s):t},s.precision=function(l){return arguments.length?(r=typeof l=="function"?l:zy(+l),s):r},s}var vJ=M(()=>{A2();o9t();lr();DT()});function cD(){var e=[],t;return{point:function(r,n){t.push([r,n])},lineStart:function(){e.push(t=[])},lineEnd:qr,rejoin:function(){e.length>1&&e.push(e.pop().concat(e.shift()))},result:function(){var r=e;return e=[],t=null,r}}}var xJ=M(()=>{Xp()});function I2(e,t){return Ye(e[0]-t[0])<ce&&Ye(e[1]-t[1])<ce}var bJ=M(()=>{lr()});function uD(e,t,r,n){this.x=e,this.z=t,this.o=r,this.e=n,this.v=!1,this.n=this.p=null}function hD(e,t,r,n,i){var o=[],a=[],s,l;if(e.forEach(function(d){if(!((g=d.length-1)<=0)){var g,_=d[0],y=d[g],x;if(I2(_,y)){for(i.lineStart(),s=0;s<g;++s)i.point((_=d[s])[0],_[1]);i.lineEnd();return}o.push(x=new uD(_,d,null,!0)),a.push(x.o=new uD(_,null,x,!1)),o.push(x=new uD(y,d,null,!1)),a.push(x.o=new uD(y,null,x,!0))}}),!!o.length){for(a.sort(t),h9t(o),h9t(a),s=0,l=a.length;s<l;++s)a[s].e=r=!r;for(var c=o[0],u,h;;){for(var f=c,p=!0;f.v;)if((f=f.n)===c)return;u=f.z,i.lineStart();do{if(f.v=f.o.v=!0,f.e){if(p)for(s=0,l=u.length;s<l;++s)i.point((h=u[s])[0],h[1]);else n(f.x,f.n.x,1,i);f=f.n}else{if(p)for(u=f.p.z,s=u.length-1;s>=0;--s)i.point((h=u[s])[0],h[1]);else n(f.x,f.p.x,-1,i);f=f.p}f=f.o,u=f.z,p=!p}while(!f.v);i.lineEnd()}}}function h9t(e){if(!!(t=e.length)){for(var t,r=0,n=e[0],i;++r<t;)n.n=i=e[r],i.p=n,n=i;n.n=i=e[0],i.p=n}}var wJ=M(()=>{bJ()});function fD(e,t){var r=t[0],n=t[1],i=[Jt(r),-ae(r),0],o=0,a=0;SJ.reset();for(var s=0,l=e.length;s<l;++s)if(!!(u=(c=e[s]).length))for(var c,u,h=c[u-1],f=h[0],p=h[1]/2+T2,d=Jt(p),g=ae(p),_=0;_<u;++_,f=x,d=S,g=C,h=y){var y=c[_],x=y[0],b=y[1]/2+T2,S=Jt(b),C=ae(b),P=x-f,k=P>=0?1:-1,O=k*P,D=O>rr,B=d*S;if(SJ.add(Sn(B*k*Jt(O),g*C+B*ae(O))),o+=D?P+k*Bi:P,D^f>=r^x>=r){var I=$p(vc(h),vc(y));Dy(I);var L=$p(i,I);Dy(L);var R=(D^P>=0?-1:1)*Zn(L[2]);(n>R||n===R&&(I[0]||I[1]))&&(a+=D^P>=0?1:-1)}}return(o<-ce||o<ce&&SJ<-ce)^a&1}var SJ,MJ=M(()=>{ky();A2();lr();SJ=Cs()});function _g(e,t){return e<t?-1:e>t?1:e>=t?0:NaN}var Fy=M(()=>{});function EJ(e){return e.length===1&&(e=G4e(e)),{left:function(t,r,n,i){for(n==null&&(n=0),i==null&&(i=t.length);n<i;){var o=n+i>>>1;e(t[o],r)<0?n=o+1:i=o}return n},right:function(t,r,n,i){for(n==null&&(n=0),i==null&&(i=t.length);n<i;){var o=n+i>>>1;e(t[o],r)>0?i=o:n=o+1}return n}}}function G4e(e){return function(t,r){return _g(e(t),r)}}var TJ=M(()=>{Fy()});var f9t,W4e,Y4e,CJ=M(()=>{Fy();TJ();f9t=EJ(_g),W4e=f9t.right,Y4e=f9t.left});var AJ=M(()=>{});var p9t=M(()=>{AJ()});var d9t=M(()=>{});var L2=M(()=>{});var PJ=M(()=>{L2()});var IJ=M(()=>{PJ()});var LJ=M(()=>{});var m9t,X4e,$4e,kJ=M(()=>{m9t=Array.prototype,X4e=m9t.slice,$4e=m9t.map});var g9t=M(()=>{});var _9t=M(()=>{});function Jp(e,t,r){e=+e,t=+t,r=(i=arguments.length)<2?(t=e,e=0,1):i<3?1:+r;for(var n=-1,i=Math.max(0,Math.ceil((t-e)/r))|0,o=new Array(i);++n<i;)o[n]=e+n*r;return o}var RJ=M(()=>{});var k0n,R0n,N0n,NJ=M(()=>{k0n=Math.sqrt(50),R0n=Math.sqrt(10),N0n=Math.sqrt(2)});var DJ=M(()=>{});var y9t=M(()=>{kJ();CJ();g9t();LJ();_9t();RJ();NJ();DJ()});var dD=M(()=>{L2()});var x9t=M(()=>{kJ();Fy();L2();dD()});var b9t=M(()=>{IJ()});var w9t=M(()=>{});var S9t=M(()=>{L2()});var M9t=M(()=>{Fy();L2();dD()});function OT(e){for(var t=e.length,r,n=-1,i=0,o,a;++n<t;)i+=e[n].length;for(o=new Array(i);--t>=0;)for(a=e[t],r=a.length;--r>=0;)o[--i]=a[r];return o}var E9t=M(()=>{});var OJ=M(()=>{});var T9t=M(()=>{});var C9t=M(()=>{Fy()});var A9t=M(()=>{});var P9t=M(()=>{});var zJ=M(()=>{OJ()});var I9t=M(()=>{zJ()});var mD=M(()=>{CJ();Fy();TJ();p9t();d9t();IJ();LJ();y9t();x9t();b9t();DJ();w9t();S9t();M9t();E9t();OJ();AJ();T9t();dD();RJ();C9t();A9t();P9t();NJ();zJ();PJ();I9t()});function gD(e,t,r,n){return function(i){var o=t(i),a=cD(),s=t(a),l=!1,c,u,h,f={point:p,lineStart:g,lineEnd:_,polygonStart:function(){f.point=y,f.lineStart=x,f.lineEnd=b,u=[],c=[]},polygonEnd:function(){f.point=p,f.lineStart=g,f.lineEnd=_,u=OT(u);var S=fD(c,n);u.length?(l||(i.polygonStart(),l=!0),hD(u,iPe,S,r,i)):S&&(l||(i.polygonStart(),l=!0),i.lineStart(),r(null,null,1,i),i.lineEnd()),l&&(i.polygonEnd(),l=!1),u=c=null},sphere:function(){i.polygonStart(),i.lineStart(),r(null,null,1,i),i.lineEnd(),i.polygonEnd()}};function p(S,C){e(S,C)&&i.point(S,C)}function d(S,C){o.point(S,C)}function g(){f.point=d,o.lineStart()}function _(){f.point=p,o.lineEnd()}function y(S,C){h.push([S,C]),s.point(S,C)}function x(){s.lineStart(),h=[]}function b(){y(h[0][0],h[0][1]),s.lineEnd();var S=s.clean(),C=a.result(),P,k=C.length,O,D,B;if(h.pop(),c.push(h),h=null,!!k){if(S&1){if(D=C[0],(O=D.length-1)>0){for(l||(i.polygonStart(),l=!0),i.lineStart(),P=0;P<O;++P)i.point((B=D[P])[0],B[1]);i.lineEnd()}return}k>1&&S&2&&C.push(C.pop().concat(C.shift())),u.push(C.filter(nPe))}}return f}}function nPe(e){return e.length>1}function iPe(e,t){return((e=e.x)[0]<0?e[1]-Fn-ce:Fn-e[1])-((t=t.x)[0]<0?t[1]-Fn-ce:Fn-t[1])}var FJ=M(()=>{xJ();wJ();lr();MJ();mD()});function oPe(e){var t=NaN,r=NaN,n=NaN,i;return{lineStart:function(){e.lineStart(),i=1},point:function(o,a){var s=o>0?rr:-rr,l=Ye(o-t);Ye(l-rr)<ce?(e.point(t,r=(r+a)/2>0?Fn:-Fn),e.point(n,r),e.lineEnd(),e.lineStart(),e.point(s,r),e.point(o,r),i=0):n!==s&&l>=rr&&(Ye(t-n)<ce&&(t-=n*ce),Ye(o-s)<ce&&(o-=s*ce),r=aPe(t,r,o,a),e.point(n,r),e.lineEnd(),e.lineStart(),e.point(s,r),i=0),e.point(t=o,r=a),n=s},lineEnd:function(){e.lineEnd(),t=r=NaN},clean:function(){return 2-i}}}function aPe(e,t,r,n){var i,o,a=Jt(e-r);return Ye(a)>ce?yc((Jt(t)*(o=ae(n))*Jt(r)-Jt(n)*(i=ae(t))*Jt(e))/(i*o*a)):(t+n)/2}function sPe(e,t,r,n){var i;if(e==null)i=r*Fn,n.point(-rr,i),n.point(0,i),n.point(rr,i),n.point(rr,0),n.point(rr,-i),n.point(0,-i),n.point(-rr,-i),n.point(-rr,0),n.point(-rr,i);else if(Ye(e[0]-t[0])>ce){var o=e[0]<t[0]?rr:-rr;i=r*o/2,n.point(-o,i),n.point(0,i),n.point(o,i)}else n.point(t[0],t[1])}var zT,BJ=M(()=>{FJ();lr();zT=gD(function(){return!0},oPe,sPe,[-rr,-Fn])});function _D(e){var t=ae(e),r=6*we,n=t>0,i=Ye(t)>ce;function o(u,h,f,p){yJ(p,e,r,f,u,h)}function a(u,h){return ae(u)*ae(h)>t}function s(u){var h,f,p,d,g;return{lineStart:function(){d=p=!1,g=1},point:function(_,y){var x=[_,y],b,S=a(_,y),C=n?S?0:c(_,y):S?c(_+(_<0?rr:-rr),y):0;if(!h&&(d=p=S)&&u.lineStart(),S!==p&&(b=l(h,x),(!b||I2(h,b)||I2(x,b))&&(x[0]+=ce,x[1]+=ce,S=a(x[0],x[1]))),S!==p)g=0,S?(u.lineStart(),b=l(x,h),u.point(b[0],b[1])):(b=l(h,x),u.point(b[0],b[1]),u.lineEnd()),h=b;else if(i&&h&&n^S){var P;!(C&f)&&(P=l(x,h,!0))&&(g=0,n?(u.lineStart(),u.point(P[0][0],P[0][1]),u.point(P[1][0],P[1][1]),u.lineEnd()):(u.point(P[1][0],P[1][1]),u.lineEnd(),u.lineStart(),u.point(P[0][0],P[0][1])))}S&&(!h||!I2(h,x))&&u.point(x[0],x[1]),h=x,p=S,f=C},lineEnd:function(){p&&u.lineEnd(),h=null},clean:function(){return g|(d&&p)<<1}}}function l(u,h,f){var p=vc(u),d=vc(h),g=[1,0,0],_=$p(p,d),y=PT(_,_),x=_[0],b=y-x*x;if(!b)return!f&&u;var S=t*y/b,C=-t*x/b,P=$p(g,_),k=IT(g,S),O=IT(_,C);QN(k,O);var D=P,B=PT(k,D),I=PT(D,D),L=B*B-I*(PT(k,k)-1);if(!(L<0)){var R=Rr(L),F=IT(D,(-B-R)/I);if(QN(F,k),F=Ny(F),!f)return F;var z=u[0],U=h[0],W=u[1],Z=h[1],rt;U<z&&(rt=z,z=U,U=rt);var ot=U-z,st=Ye(ot-rr)<ce,St=st||ot<ce;if(!st&&Z<W&&(rt=W,W=Z,Z=rt),St?st?W+Z>0^F[1]<(Ye(F[0]-z)<ce?W:Z):W<=F[1]&&F[1]<=Z:ot>rr^(z<=F[0]&&F[0]<=U)){var bt=IT(D,(-B+R)/I);return QN(bt,k),[F,Ny(bt)]}}}function c(u,h){var f=n?e:rr-e,p=0;return u<-f?p|=1:u>f&&(p|=2),h<-f?p|=4:h>f&&(p|=8),p}return gD(a,s,o,n?[0,-e]:[-rr,e-rr])}var HJ=M(()=>{A2();vJ();lr();bJ();FJ()});function L9t(e,t,r,n,i,o){var a=e[0],s=e[1],l=t[0],c=t[1],u=0,h=1,f=l-a,p=c-s,d;if(d=r-a,!(!f&&d>0)){if(d/=f,f<0){if(d<u)return;d<h&&(h=d)}else if(f>0){if(d>h)return;d>u&&(u=d)}if(d=i-a,!(!f&&d<0)){if(d/=f,f<0){if(d>h)return;d>u&&(u=d)}else if(f>0){if(d<u)return;d<h&&(h=d)}if(d=n-s,!(!p&&d>0)){if(d/=p,p<0){if(d<u)return;d<h&&(h=d)}else if(p>0){if(d>h)return;d>u&&(u=d)}if(d=o-s,!(!p&&d<0)){if(d/=p,p<0){if(d>h)return;d>u&&(u=d)}else if(p>0){if(d<u)return;d<h&&(h=d)}return u>0&&(e[0]=a+u*f,e[1]=s+u*p),h<1&&(t[0]=a+h*f,t[1]=s+h*p),!0}}}}}var k9t=M(()=>{});function Qp(e,t,r,n){function i(c,u){return e<=c&&c<=r&&t<=u&&u<=n}function o(c,u,h,f){var p=0,d=0;if(c==null||(p=a(c,h))!==(d=a(u,h))||l(c,u)<0^h>0)do f.point(p===0||p===3?e:r,p>1?n:t);while((p=(p+h+4)%4)!==d);else f.point(u[0],u[1])}function a(c,u){return Ye(c[0]-e)<ce?u>0?0:3:Ye(c[0]-r)<ce?u>0?2:1:Ye(c[1]-t)<ce?u>0?1:0:u>0?3:2}function s(c,u){return l(c.x,u.x)}function l(c,u){var h=a(c,1),f=a(u,1);return h!==f?h-f:h===0?u[1]-c[1]:h===1?c[0]-u[0]:h===2?c[1]-u[1]:u[0]-c[0]}return function(c){var u=c,h=cD(),f,p,d,g,_,y,x,b,S,C,P,k={point:O,lineStart:L,lineEnd:R,polygonStart:B,polygonEnd:I};function O(z,U){i(z,U)&&u.point(z,U)}function D(){for(var z=0,U=0,W=p.length;U<W;++U)for(var Z=p[U],rt=1,ot=Z.length,st=Z[0],St,bt,Mt=st[0],lt=st[1];rt<ot;++rt)St=Mt,bt=lt,st=Z[rt],Mt=st[0],lt=st[1],bt<=n?lt>n&&(Mt-St)*(n-bt)>(lt-bt)*(e-St)&&++z:lt<=n&&(Mt-St)*(n-bt)<(lt-bt)*(e-St)&&--z;return z}function B(){u=h,f=[],p=[],P=!0}function I(){var z=D(),U=P&&z,W=(f=OT(f)).length;(U||W)&&(c.polygonStart(),U&&(c.lineStart(),o(null,null,1,c),c.lineEnd()),W&&hD(f,s,z,o,c),c.polygonEnd()),u=c,f=p=d=null}function L(){k.point=F,p&&p.push(d=[]),C=!0,S=!1,x=b=NaN}function R(){f&&(F(g,_),y&&S&&h.rejoin(),f.push(h.result())),k.point=O,S&&u.lineEnd()}function F(z,U){var W=i(z,U);if(p&&d.push([z,U]),C)g=z,_=U,y=W,C=!1,W&&(u.lineStart(),u.point(z,U));else if(W&&S)u.point(z,U);else{var Z=[x=Math.max(yD,Math.min(FT,x)),b=Math.max(yD,Math.min(FT,b))],rt=[z=Math.max(yD,Math.min(FT,z)),U=Math.max(yD,Math.min(FT,U))];L9t(Z,rt,e,t,r,n)?(S||(u.lineStart(),u.point(Z[0],Z[1])),u.point(rt[0],rt[1]),W||u.lineEnd(),P=!1):W&&(u.lineStart(),u.point(z,U),P=!1)}x=z,b=U,S=W}return k}}var FT,yD,BT=M(()=>{lr();xJ();k9t();wJ();mD();FT=1e9,yD=-FT});function R9t(){var e=0,t=0,r=960,n=500,i,o,a;return a={stream:function(s){return i&&o===s?i:i=Qp(e,t,r,n)(o=s)},extent:function(s){return arguments.length?(e=+s[0][0],t=+s[0][1],r=+s[1][0],n=+s[1][1],i=o=null,a):[[e,t],[r,n]]}}}var N9t=M(()=>{BT()});function lPe(){k2.point=uPe,k2.lineEnd=cPe}function cPe(){k2.point=k2.lineEnd=qr}function uPe(e,t){e*=we,t*=we,UJ=e,vD=Jt(t),xD=ae(t),k2.point=hPe}function hPe(e,t){e*=we,t*=we;var r=Jt(t),n=ae(t),i=Ye(e-UJ),o=ae(i),a=Jt(i),s=n*a,l=xD*r-vD*n*o,c=vD*r+xD*n*o;VJ.add(Sn(Rr(s*s+l*l),c)),UJ=e,vD=r,xD=n}function bD(e){return VJ.reset(),Mo(e,k2),+VJ}var VJ,UJ,vD,xD,k2,qJ=M(()=>{ky();lr();Xp();mg();VJ=Cs(),k2={sphere:qr,point:qr,lineStart:lPe,lineEnd:qr,polygonStart:qr,polygonEnd:qr}});function By(e,t){return GJ[0]=e,GJ[1]=t,bD(fPe)}var GJ,fPe,WJ=M(()=>{qJ();GJ=[null,null],fPe={type:"LineString",coordinates:GJ}});function wD(e,t){return e&&O9t.hasOwnProperty(e.type)?O9t[e.type](e,t):!1}function z9t(e,t){return By(e,t)===0}function F9t(e,t){var r=By(e[0],e[1]),n=By(e[0],t),i=By(t,e[1]);return n+i<=r+ce}function B9t(e,t){return!!fD(e.map(pPe),H9t(t))}function pPe(e){return e=e.map(H9t),e.pop(),e}function H9t(e){return[e[0]*we,e[1]*we]}function V9t(e,t){return(e&&D9t.hasOwnProperty(e.type)?D9t[e.type]:wD)(e,t)}var D9t,O9t,U9t=M(()=>{MJ();WJ();lr();D9t={Feature:function(e,t){return wD(e.geometry,t)},FeatureCollection:function(e,t){for(var r=e.features,n=-1,i=r.length;++n<i;)if(wD(r[n].geometry,t))return!0;return!1}},O9t={Sphere:function(){return!0},Point:function(e,t){return z9t(e.coordinates,t)},MultiPoint:function(e,t){for(var r=e.coordinates,n=-1,i=r.length;++n<i;)if(z9t(r[n],t))return!0;return!1},LineString:function(e,t){return F9t(e.coordinates,t)},MultiLineString:function(e,t){for(var r=e.coordinates,n=-1,i=r.length;++n<i;)if(F9t(r[n],t))return!0;return!1},Polygon:function(e,t){return B9t(e.coordinates,t)},MultiPolygon:function(e,t){for(var r=e.coordinates,n=-1,i=r.length;++n<i;)if(B9t(r[n],t))return!0;return!1},GeometryCollection:function(e,t){for(var r=e.geometries,n=-1,i=r.length;++n<i;)if(wD(r[n],t))return!0;return!1}}});function q9t(e,t,r){var n=Jp(e,t-ce,r).concat(t);return function(i){return n.map(function(o){return[i,o]})}}function G9t(e,t,r){var n=Jp(e,t-ce,r).concat(t);return function(i){return n.map(function(o){return[o,i]})}}function SD(){var e,t,r,n,i,o,a,s,l=10,c=l,u=90,h=360,f,p,d,g,_=2.5;function y(){return{type:"MultiLineString",coordinates:x()}}function x(){return Jp(CT(n/u)*u,r,u).map(d).concat(Jp(CT(s/h)*h,a,h).map(g)).concat(Jp(CT(t/l)*l,e,l).filter(function(b){return Ye(b%u)>ce}).map(f)).concat(Jp(CT(o/c)*c,i,c).filter(function(b){return Ye(b%h)>ce}).map(p))}return y.lines=function(){return x().map(function(b){return{type:"LineString",coordinates:b}})},y.outline=function(){return{type:"Polygon",coordinates:[d(n).concat(g(a).slice(1),d(r).reverse().slice(1),g(s).reverse().slice(1))]}},y.extent=function(b){return arguments.length?y.extentMajor(b).extentMinor(b):y.extentMinor()},y.extentMajor=function(b){return arguments.length?(n=+b[0][0],r=+b[1][0],s=+b[0][1],a=+b[1][1],n>r&&(b=n,n=r,r=b),s>a&&(b=s,s=a,a=b),y.precision(_)):[[n,s],[r,a]]},y.extentMinor=function(b){return arguments.length?(t=+b[0][0],e=+b[1][0],o=+b[0][1],i=+b[1][1],t>e&&(b=t,t=e,e=b),o>i&&(b=o,o=i,i=b),y.precision(_)):[[t,o],[e,i]]},y.step=function(b){return arguments.length?y.stepMajor(b).stepMinor(b):y.stepMinor()},y.stepMajor=function(b){return arguments.length?(u=+b[0],h=+b[1],y):[u,h]},y.stepMinor=function(b){return arguments.length?(l=+b[0],c=+b[1],y):[l,c]},y.precision=function(b){return arguments.length?(_=+b,f=q9t(o,i,90),p=G9t(t,e,_),d=q9t(s,a,90),g=G9t(n,r,_),y):_},y.extentMajor([[-180,-90+ce],[180,90-ce]]).extentMinor([[-180,-80-ce],[180,80+ce]])}function W9t(){return SD()()}var Y9t=M(()=>{mD();lr()});function j9t(e,t){var r=e[0]*we,n=e[1]*we,i=t[0]*we,o=t[1]*we,a=ae(n),s=Jt(n),l=ae(o),c=Jt(o),u=a*ae(r),h=a*Jt(r),f=l*ae(i),p=l*Jt(i),d=2*Zn(Rr(oJ(o-n)+a*l*oJ(i-r))),g=Jt(d),_=d?function(y){var x=Jt(y*=d)/g,b=Jt(d-y)/g,S=b*u+x*f,C=b*h+x*p,P=b*s+x*c;return[Sn(C,S)*Ur,Sn(P,Rr(S*S+C*C))*Ur]}:function(){return[r*Ur,n*Ur]};return _.distance=d,_}var X9t=M(()=>{lr()});function nf(e){return e}var MD=M(()=>{});function dPe(){yg.point=mPe}function mPe(e,t){yg.point=Z9t,$9t=XJ=e,K9t=$J=t}function Z9t(e,t){jJ.add($J*e-XJ*t),XJ=e,$J=t}function gPe(){Z9t($9t,K9t)}var YJ,jJ,$9t,K9t,XJ,$J,yg,KJ,J9t=M(()=>{ky();lr();Xp();YJ=Cs(),jJ=Cs(),yg={point:qr,lineStart:qr,lineEnd:qr,polygonStart:function(){yg.lineStart=dPe,yg.lineEnd=gPe},polygonEnd:function(){yg.lineStart=yg.lineEnd=yg.point=qr,YJ.add(Ye(jJ)),jJ.reset()},result:function(){var e=YJ/2;return YJ.reset(),e}};KJ=yg});function yPe(e,t){e<R2&&(R2=e),e>HT&&(HT=e),t<ED&&(ED=t),t>TD&&(TD=t)}var R2,ED,HT,TD,_Pe,N2,ZJ=M(()=>{Xp();R2=1/0,ED=R2,HT=-R2,TD=HT,_Pe={point:yPe,lineStart:qr,lineEnd:qr,polygonStart:qr,polygonEnd:qr,result:function(){var e=[[R2,ED],[HT,TD]];return HT=TD=-(ED=R2=1/0),e}};N2=_Pe});function Hy(e,t){JJ+=e,QJ+=t,++VT}function Q9t(){Cu.point=vPe}function vPe(e,t){Cu.point=xPe,Hy(of=e,af=t)}function xPe(e,t){var r=e-of,n=t-af,i=Rr(r*r+n*n);CD+=i*(of+e)/2,AD+=i*(af+t)/2,D2+=i,Hy(of=e,af=t)}function tLt(){Cu.point=Hy}function bPe(){Cu.point=SPe}function wPe(){nLt(eLt,rLt)}function SPe(e,t){Cu.point=nLt,Hy(eLt=of=e,rLt=af=t)}function nLt(e,t){var r=e-of,n=t-af,i=Rr(r*r+n*n);CD+=i*(of+e)/2,AD+=i*(af+t)/2,D2+=i,i=af*e-of*t,tQ+=i*(of+e),eQ+=i*(af+t),UT+=i*3,Hy(of=e,af=t)}var JJ,QJ,VT,CD,AD,D2,tQ,eQ,UT,eLt,rLt,of,af,Cu,rQ,iLt=M(()=>{lr();JJ=0,QJ=0,VT=0,CD=0,AD=0,D2=0,tQ=0,eQ=0,UT=0,Cu={point:Hy,lineStart:Q9t,lineEnd:tLt,polygonStart:function(){Cu.lineStart=bPe,Cu.lineEnd=wPe},polygonEnd:function(){Cu.point=Hy,Cu.lineStart=Q9t,Cu.lineEnd=tLt},result:function(){var e=UT?[tQ/UT,eQ/UT]:D2?[CD/D2,AD/D2]:VT?[JJ/VT,QJ/VT]:[NaN,NaN];return JJ=QJ=VT=CD=AD=D2=tQ=eQ=UT=0,e}};rQ=Cu});function PD(e){this._context=e}var oLt=M(()=>{lr();Xp();PD.prototype={_radius:4.5,pointRadius:function(e){return this._radius=e,this},polygonStart:function(){this._line=0},polygonEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){this._line===0&&this._context.closePath(),this._point=NaN},point:function(e,t){switch(this._point){case 0:{this._context.moveTo(e,t),this._point=1;break}case 1:{this._context.lineTo(e,t);break}default:{this._context.moveTo(e+this._radius,t),this._context.arc(e,t,this._radius,0,Bi);break}}},result:qr}});function MPe(e,t){ID.point=lLt,aLt=qT=e,sLt=GT=t}function lLt(e,t){qT-=e,GT-=t,iQ.add(Rr(qT*qT+GT*GT)),qT=e,GT=t}var iQ,nQ,aLt,sLt,qT,GT,ID,oQ,cLt=M(()=>{ky();lr();Xp();iQ=Cs(),ID={point:qr,lineStart:function(){ID.point=MPe},lineEnd:function(){nQ&&lLt(aLt,sLt),ID.point=qr},polygonStart:function(){nQ=!0},polygonEnd:function(){nQ=null},result:function(){var e=+iQ;return iQ.reset(),e}};oQ=ID});function LD(){this._string=[]}function uLt(e){return"m0,"+e+"a"+e+","+e+" 0 1,1 0,"+-2*e+"a"+e+","+e+" 0 1,1 0,"+2*e+"z"}var hLt=M(()=>{LD.prototype={_radius:4.5,_circle:uLt(4.5),pointRadius:function(e){return(e=+e)!==this._radius&&(this._radius=e,this._circle=null),this},polygonStart:function(){this._line=0},polygonEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){this._line===0&&this._string.push("Z"),this._point=NaN},point:function(e,t){switch(this._point){case 0:{this._string.push("M",e,",",t),this._point=1;break}case 1:{this._string.push("L",e,",",t);break}default:{this._circle==null&&(this._circle=uLt(this._radius)),this._string.push("M",e,",",t,this._circle);break}}},result:function(){if(this._string.length){var e=this._string.join("");return this._string=[],e}else return null}}});function fLt(e,t){var r=4.5,n,i;function o(a){return a&&(typeof r=="function"&&i.pointRadius(+r.apply(this,arguments)),Mo(a,n(i))),i.result()}return o.area=function(a){return Mo(a,n(KJ)),KJ.result()},o.measure=function(a){return Mo(a,n(oQ)),oQ.result()},o.bounds=function(a){return Mo(a,n(N2)),N2.result()},o.centroid=function(a){return Mo(a,n(rQ)),rQ.result()},o.projection=function(a){return arguments.length?(n=a==null?(e=null,nf):(e=a).stream,o):e},o.context=function(a){return arguments.length?(i=a==null?(t=null,new LD):new PD(t=a),typeof r!="function"&&i.pointRadius(r),o):t},o.pointRadius=function(a){return arguments.length?(r=typeof a=="function"?a:(i.pointRadius(+a),+a),o):r},o.projection(e).context(t)}var pLt=M(()=>{MD();mg();J9t();ZJ();iLt();oLt();cLt();hLt()});function dLt(e){return{stream:vg(e)}}function vg(e){return function(t){var r=new aQ;for(var n in e)r[n]=e[n];return r.stream=t,r}}function aQ(){}var WT=M(()=>{aQ.prototype={constructor:aQ,point:function(e,t){this.stream.point(e,t)},sphere:function(){this.stream.sphere()},lineStart:function(){this.stream.lineStart()},lineEnd:function(){this.stream.lineEnd()},polygonStart:function(){this.stream.polygonStart()},polygonEnd:function(){this.stream.polygonEnd()}}});function sQ(e,t,r){var n=e.clipExtent&&e.clipExtent();return e.scale(150).translate([0,0]),n!=null&&e.clipExtent(null),Mo(r,e.stream(N2)),t(N2.result()),n!=null&&e.clipExtent(n),e}function Vy(e,t,r){return sQ(e,function(n){var i=t[1][0]-t[0][0],o=t[1][1]-t[0][1],a=Math.min(i/(n[1][0]-n[0][0]),o/(n[1][1]-n[0][1])),s=+t[0][0]+(i-a*(n[1][0]+n[0][0]))/2,l=+t[0][1]+(o-a*(n[1][1]+n[0][1]))/2;e.scale(150*a).translate([s,l])},r)}function O2(e,t,r){return Vy(e,[[0,0],t],r)}function z2(e,t,r){return sQ(e,function(n){var i=+t,o=i/(n[1][0]-n[0][0]),a=(i-o*(n[1][0]+n[0][0]))/2,s=-o*n[0][1];e.scale(150*o).translate([a,s])},r)}function F2(e,t,r){return sQ(e,function(n){var i=+t,o=i/(n[1][1]-n[0][1]),a=-o*n[0][0],s=(i-o*(n[1][1]+n[0][1]))/2;e.scale(150*o).translate([a,s])},r)}var kD=M(()=>{mg();ZJ()});function lQ(e,t){return+t?CPe(e,t):TPe(e)}function TPe(e){return vg({point:function(t,r){t=e(t,r),this.stream.point(t[0],t[1])}})}function CPe(e,t){function r(n,i,o,a,s,l,c,u,h,f,p,d,g,_){var y=c-n,x=u-i,b=y*y+x*x;if(b>4*t&&g--){var S=a+f,C=s+p,P=l+d,k=Rr(S*S+C*C+P*P),O=Zn(P/=k),D=Ye(Ye(P)-1)<ce||Ye(o-h)<ce?(o+h)/2:Sn(C,S),B=e(D,O),I=B[0],L=B[1],R=I-n,F=L-i,z=x*R-y*F;(z*z/b>t||Ye((y*R+x*F)/b-.5)>.3||a*f+s*p+l*d<EPe)&&(r(n,i,o,a,s,l,I,L,D,S/=k,C/=k,P,g,_),_.point(I,L),r(I,L,D,S,C,P,c,u,h,f,p,d,g,_))}}return function(n){var i,o,a,s,l,c,u,h,f,p,d,g,_={point:y,lineStart:x,lineEnd:S,polygonStart:function(){n.polygonStart(),_.lineStart=C},polygonEnd:function(){n.polygonEnd(),_.lineStart=x}};function y(O,D){O=e(O,D),n.point(O[0],O[1])}function x(){h=NaN,_.point=b,n.lineStart()}function b(O,D){var B=vc([O,D]),I=e(O,D);r(h,f,u,p,d,g,h=I[0],f=I[1],u=O,p=B[0],d=B[1],g=B[2],mLt,n),n.point(h,f)}function S(){_.point=y,n.lineEnd()}function C(){x(),_.point=P,_.lineEnd=k}function P(O,D){b(i=O,D),o=h,a=f,s=p,l=d,c=g,_.point=b}function k(){r(h,f,u,p,d,g,o,a,i,s,l,c,mLt,n),_.lineEnd=S,S()}return _}}var mLt,EPe,gLt=M(()=>{A2();lr();WT();mLt=16,EPe=ae(30*we)});function PPe(e){return vg({point:function(t,r){var n=e(t,r);return this.stream.point(n[0],n[1])}})}function eo(e){return YT(function(){return e})()}function YT(e){var t,r=150,n=480,i=250,o,a,s=0,l=0,c=0,u=0,h=0,f,p,d=null,g=zT,_=null,y,x,b,S=nf,C=.5,P=lQ(I,C),k,O;function D(F){return F=p(F[0]*we,F[1]*we),[F[0]*r+o,a-F[1]*r]}function B(F){return F=p.invert((F[0]-o)/r,(a-F[1])/r),F&&[F[0]*Ur,F[1]*Ur]}function I(F,z){return F=t(F,z),[F[0]*r+o,a-F[1]*r]}D.stream=function(F){return k&&O===F?k:k=APe(PPe(f)(g(P(S(O=F)))))},D.preclip=function(F){return arguments.length?(g=F,d=void 0,R()):g},D.postclip=function(F){return arguments.length?(S=F,_=y=x=b=null,R()):S},D.clipAngle=function(F){return arguments.length?(g=+F?_D(d=F*we):(d=null,zT),R()):d*Ur},D.clipExtent=function(F){return arguments.length?(S=F==null?(_=y=x=b=null,nf):Qp(_=+F[0][0],y=+F[0][1],x=+F[1][0],b=+F[1][1]),R()):_==null?null:[[_,y],[x,b]]},D.scale=function(F){return arguments.length?(r=+F,L()):r},D.translate=function(F){return arguments.length?(n=+F[0],i=+F[1],L()):[n,i]},D.center=function(F){return arguments.length?(s=F[0]%360*we,l=F[1]%360*we,L()):[s*Ur,l*Ur]},D.rotate=function(F){return arguments.length?(c=F[0]%360*we,u=F[1]%360*we,h=F.length>2?F[2]%360*we:0,L()):[c*Ur,u*Ur,h*Ur]},D.precision=function(F){return arguments.length?(P=lQ(I,C=F*F),R()):Rr(C)},D.fitExtent=function(F,z){return Vy(D,F,z)},D.fitSize=function(F,z){return O2(D,F,z)},D.fitWidth=function(F,z){return z2(D,F,z)},D.fitHeight=function(F,z){return F2(D,F,z)};function L(){p=sD(f=NT(c,u,h),t);var F=t(s,l);return o=n-F[0]*r,a=i+F[1]*r,R()}function R(){return k=O=null,D}return function(){return t=e.apply(this,arguments),D.invert=t.invert&&B,L()}}var APe,Au=M(()=>{BJ();HJ();BT();gJ();MD();lr();DT();WT();kD();gLt();APe=vg({point:function(e,t){this.stream.point(e*we,t*we)}})});function B2(e){var t=0,r=rr/3,n=YT(e),i=n(t,r);return i.parallels=function(o){return arguments.length?n(t=o[0]*we,r=o[1]*we):[t*Ur,r*Ur]},i}var RD=M(()=>{lr();Au()});function _Lt(e){var t=ae(e);function r(n,i){return[n*t,Jt(i)/t]}return r.invert=function(n,i){return[n/t,Zn(i*t)]},r}var yLt=M(()=>{lr()});function cQ(e,t){var r=Jt(e),n=(r+Jt(t))/2;if(Ye(n)<ce)return _Lt(e);var i=1+r*(2*n-r),o=Rr(i)/n;function a(s,l){var c=Rr(i-2*n*Jt(l))/n;return[c*Jt(s*=n),o-c*ae(s)]}return a.invert=function(s,l){var c=o-l;return[Sn(s,Ye(c))/n*dg(c),Zn((i-(s*s+c*c)*n*n)/(2*n))]},a}function Uy(){return B2(cQ).scale(155.424).center([0,33.6442])}var ND=M(()=>{lr();RD();yLt()});function DD(){return Uy().parallels([29.5,45.5]).scale(1070).translate([480,250]).rotate([96,0]).center([-.6,38.7])}var uQ=M(()=>{ND()});function IPe(e){var t=e.length;return{point:function(r,n){for(var i=-1;++i<t;)e[i].point(r,n)},sphere:function(){for(var r=-1;++r<t;)e[r].sphere()},lineStart:function(){for(var r=-1;++r<t;)e[r].lineStart()},lineEnd:function(){for(var r=-1;++r<t;)e[r].lineEnd()},polygonStart:function(){for(var r=-1;++r<t;)e[r].polygonStart()},polygonEnd:function(){for(var r=-1;++r<t;)e[r].polygonEnd()}}}function vLt(){var e,t,r=DD(),n,i=Uy().rotate([154,0]).center([-2,58.5]).parallels([55,65]),o,a=Uy().rotate([157,0]).center([-3,19.9]).parallels([8,18]),s,l,c={point:function(f,p){l=[f,p]}};function u(f){var p=f[0],d=f[1];return l=null,n.point(p,d),l||(o.point(p,d),l)||(s.point(p,d),l)}u.invert=function(f){var p=r.scale(),d=r.translate(),g=(f[0]-d[0])/p,_=(f[1]-d[1])/p;return(_>=.12&&_<.234&&g>=-.425&&g<-.214?i:_>=.166&&_<.234&&g>=-.214&&g<-.115?a:r).invert(f)},u.stream=function(f){return e&&t===f?e:e=IPe([r.stream(t=f),i.stream(f),a.stream(f)])},u.precision=function(f){return arguments.length?(r.precision(f),i.precision(f),a.precision(f),h()):r.precision()},u.scale=function(f){return arguments.length?(r.scale(f),i.scale(f*.35),a.scale(f),u.translate(r.translate())):r.scale()},u.translate=function(f){if(!arguments.length)return r.translate();var p=r.scale(),d=+f[0],g=+f[1];return n=r.translate(f).clipExtent([[d-.455*p,g-.238*p],[d+.455*p,g+.238*p]]).stream(c),o=i.translate([d-.307*p,g+.201*p]).clipExtent([[d-.425*p+ce,g+.12*p+ce],[d-.214*p-ce,g+.234*p-ce]]).stream(c),s=a.translate([d-.205*p,g+.212*p]).clipExtent([[d-.214*p+ce,g+.166*p+ce],[d-.115*p-ce,g+.234*p-ce]]).stream(c),h()},u.fitExtent=function(f,p){return Vy(u,f,p)},u.fitSize=function(f,p){return O2(u,f,p)},u.fitWidth=function(f,p){return z2(u,f,p)},u.fitHeight=function(f,p){return F2(u,f,p)};function h(){return e=t=null,u}return u.scale(1070)}var xLt=M(()=>{lr();uQ();ND();kD()});function OD(e){return function(t,r){var n=ae(t),i=ae(r),o=e(n*i);return[o*i*Jt(t),o*Jt(r)]}}function sf(e){return function(t,r){var n=Rr(t*t+r*r),i=e(n),o=Jt(i),a=ae(i);return[Sn(t*o,n*a),Zn(n&&r*o/n)]}}var H2=M(()=>{lr()});function bLt(){return eo(zD).scale(124.75).clipAngle(180-.001)}var zD,wLt=M(()=>{lr();H2();Au();zD=OD(function(e){return Rr(2/(1+e))});zD.invert=sf(function(e){return 2*Zn(e/2)})});function SLt(){return eo(FD).scale(79.4188).clipAngle(180-.001)}var FD,MLt=M(()=>{lr();H2();Au();FD=OD(function(e){return(e=KN(e))&&e/Jt(e)});FD.invert=sf(function(e){return e})});function qy(e,t){return[e,Ry(C2((Fn+t)/2))]}function ELt(){return hQ(qy).scale(961/Bi)}function hQ(e){var t=eo(e),r=t.center,n=t.scale,i=t.translate,o=t.clipExtent,a=null,s,l,c;t.scale=function(h){return arguments.length?(n(h),u()):n()},t.translate=function(h){return arguments.length?(i(h),u()):i()},t.center=function(h){return arguments.length?(r(h),u()):r()},t.clipExtent=function(h){return arguments.length?(h==null?a=s=l=c=null:(a=+h[0][0],s=+h[0][1],l=+h[1][0],c=+h[1][1]),u()):a==null?null:[[a,s],[l,c]]};function u(){var h=rr*n(),f=t(lD(t.rotate()).invert([0,0]));return o(a==null?[[f[0]-h,f[1]-h],[f[0]+h,f[1]+h]]:e===qy?[[Math.max(f[0]-h,a),s],[Math.min(f[0]+h,l),c]]:[[a,Math.max(f[1]-h,s)],[l,Math.min(f[1]+h,c)]])}return u()}var BD=M(()=>{lr();DT();Au();qy.invert=function(e,t){return[e,2*yc(XN(t))-Fn]}});function HD(e){return C2((Fn+e)/2)}function fQ(e,t){var r=ae(e),n=e===t?Jt(e):Ry(r/ae(t))/Ry(HD(t)/HD(e)),i=r*$N(HD(e),n)/n;if(!n)return qy;function o(a,s){i>0?s<-Fn+ce&&(s=-Fn+ce):s>Fn-ce&&(s=Fn-ce);var l=i/$N(HD(s),n);return[l*Jt(n*a),i-l*ae(n*a)]}return o.invert=function(a,s){var l=i-s,c=dg(n)*Rr(a*a+l*l);return[Sn(a,Ye(l))/n*dg(l),2*yc($N(i/c,1/n))-Fn]},o}function TLt(){return B2(fQ).scale(109.5).parallels([30,30])}var CLt=M(()=>{lr();RD();BD()});function Gy(e,t){return[e,t]}function ALt(){return eo(Gy).scale(152.63)}var pQ=M(()=>{Au();Gy.invert=Gy});function dQ(e,t){var r=ae(e),n=e===t?Jt(e):(r-ae(t))/(t-e),i=r/n+e;if(Ye(n)<ce)return Gy;function o(a,s){var l=i-s,c=n*a;return[l*Jt(c),i-l*ae(c)]}return o.invert=function(a,s){var l=i-s;return[Sn(a,Ye(l))/n*dg(l),i-dg(n)*Rr(a*a+l*l)]},o}function PLt(){return B2(dQ).scale(131.154).center([0,13.9389])}var ILt=M(()=>{lr();RD();pQ()});function VD(e,t){var r=ae(t),n=ae(e)*r;return[r*Jt(e)/n,Jt(t)/n]}function LLt(){return eo(VD).scale(144.049).clipAngle(60)}var kLt=M(()=>{lr();H2();Au();VD.invert=sf(yc)});function UD(e,t,r,n){return e===1&&t===1&&r===0&&n===0?nf:vg({point:function(i,o){this.stream.point(i*e+r,o*t+n)}})}function RLt(){var e=1,t=0,r=0,n=1,i=1,o=nf,a=null,s,l,c,u=nf,h,f,p;function d(){return h=f=null,p}return p={stream:function(g){return h&&f===g?h:h=o(u(f=g))},postclip:function(g){return arguments.length?(u=g,a=s=l=c=null,d()):u},clipExtent:function(g){return arguments.length?(u=g==null?(a=s=l=c=null,nf):Qp(a=+g[0][0],s=+g[0][1],l=+g[1][0],c=+g[1][1]),d()):a==null?null:[[a,s],[l,c]]},scale:function(g){return arguments.length?(o=UD((e=+g)*n,e*i,t,r),d()):e},translate:function(g){return arguments.length?(o=UD(e*n,e*i,t=+g[0],r=+g[1]),d()):[t,r]},reflectX:function(g){return arguments.length?(o=UD(e*(n=g?-1:1),e*i,t,r),d()):n<0},reflectY:function(g){return arguments.length?(o=UD(e*n,e*(i=g?-1:1),t,r),d()):i<0},fitExtent:function(g,_){return Vy(p,g,_)},fitSize:function(g,_){return O2(p,g,_)},fitWidth:function(g,_){return z2(p,g,_)},fitHeight:function(g,_){return F2(p,g,_)}}}var NLt=M(()=>{BT();MD();WT();kD()});function qD(e,t){var r=t*t,n=r*r;return[e*(.8707-.131979*r+n*(-.013791+n*(.003971*r-.001529*n))),t*(1.007226+r*(.015085+n*(-.044475+.028874*r-.005916*n)))]}function DLt(){return eo(qD).scale(175.295)}var OLt=M(()=>{Au();lr();qD.invert=function(e,t){var r=t,n=25,i;do{var o=r*r,a=o*o;r-=i=(r*(1.007226+o*(.015085+a*(-.044475+.028874*o-.005916*a)))-t)/(1.007226+o*(.015085*3+a*(-.044475*7+.028874*9*o-.005916*11*a)))}while(Ye(i)>ce&&--n>0);return[e/(.8707+(o=r*r)*(-.131979+o*(-.013791+o*o*o*(.003971-.001529*o)))),r]}});function GD(e,t){return[ae(t)*Jt(e),Jt(t)]}function zLt(){return eo(GD).scale(249.5).clipAngle(90+ce)}var FLt=M(()=>{lr();H2();Au();GD.invert=sf(Zn)});function WD(e,t){var r=ae(t),n=1+ae(e)*r;return[r*Jt(e)/n,Jt(t)/n]}function BLt(){return eo(WD).scale(250).clipAngle(142)}var HLt=M(()=>{lr();H2();Au();WD.invert=sf(function(e){return 2*yc(e)})});function YD(e,t){return[Ry(C2((Fn+t)/2)),-e]}function VLt(){var e=hQ(YD),t=e.center,r=e.rotate;return e.center=function(n){return arguments.length?t([-n[1],n[0]]):(n=t(),[n[1],-n[0]])},e.rotate=function(n){return arguments.length?r([n[0],n[1],n.length>2?n[2]+90:90]):(n=r(),[n[0],n[1],n[2]-90])},r([0,0,90]).scale(159.155)}var ULt=M(()=>{lr();BD();YD.invert=function(e,t){return[-t,2*yc(XN(e))-Fn]}});var qLt=M(()=>{uJ();ZIt();i9t();vJ();BJ();HJ();N9t();BT();U9t();WJ();Y9t();X9t();qJ();pLt();uQ();xLt();wLt();MLt();CLt();ND();ILt();pQ();kLt();NLt();Au();BD();OLt();FLt();HLt();ULt();DT();mg();WT()});function LPe(e,t){return e.parent===t.parent?1:2}function kPe(e){return e.reduce(RPe,0)/e.length}function RPe(e,t){return e+t.x}function NPe(e){return 1+e.reduce(DPe,0)}function DPe(e,t){return Math.max(e,t.y)}function OPe(e){for(var t;t=e.children;)e=t[0];return e}function zPe(e){for(var t;t=e.children;)e=t[t.length-1];return e}function GLt(){var e=LPe,t=1,r=1,n=!1;function i(o){var a,s=0;o.eachAfter(function(f){var p=f.children;p?(f.x=kPe(p),f.y=NPe(p)):(f.x=a?s+=e(f,a):0,f.y=0,a=f)});var l=OPe(o),c=zPe(o),u=l.x-e(l,c)/2,h=c.x+e(c,l)/2;return o.eachAfter(n?function(f){f.x=(f.x-o.x)*t,f.y=(o.y-f.y)*r}:function(f){f.x=(f.x-u)/(h-u)*t,f.y=(1-(o.y?f.y/o.y:1))*r})}return i.separation=function(o){return arguments.length?(e=o,i):e},i.size=function(o){return arguments.length?(n=!1,t=+o[0],r=+o[1],i):n?null:[t,r]},i.nodeSize=function(o){return arguments.length?(n=!0,t=+o[0],r=+o[1],i):n?[t,r]:null},i}var WLt=M(()=>{});function FPe(e){var t=0,r=e.children,n=r&&r.length;if(!n)t=1;else for(;--n>=0;)t+=r[n].value;e.value=t}function YLt(){return this.eachAfter(FPe)}var jLt=M(()=>{});function XLt(e){var t=this,r,n=[t],i,o,a;do for(r=n.reverse(),n=[];t=r.pop();)if(e(t),i=t.children,i)for(o=0,a=i.length;o<a;++o)n.push(i[o]);while(n.length);return this}var $Lt=M(()=>{});function KLt(e){for(var t=this,r=[t],n,i;t=r.pop();)if(e(t),n=t.children,n)for(i=n.length-1;i>=0;--i)r.push(n[i]);return this}var ZLt=M(()=>{});function JLt(e){for(var t=this,r=[t],n=[],i,o,a;t=r.pop();)if(n.push(t),i=t.children,i)for(o=0,a=i.length;o<a;++o)r.push(i[o]);for(;t=n.pop();)e(t);return this}var QLt=M(()=>{});function tkt(e){return this.eachAfter(function(t){for(var r=+e(t.data)||0,n=t.children,i=n&&n.length;--i>=0;)r+=n[i].value;t.value=r})}var ekt=M(()=>{});function rkt(e){return this.eachBefore(function(t){t.children&&t.children.sort(e)})}var nkt=M(()=>{});function ikt(e){for(var t=this,r=BPe(t,e),n=[t];t!==r;)t=t.parent,n.push(t);for(var i=n.length;e!==r;)n.splice(i,0,e),e=e.parent;return n}function BPe(e,t){if(e===t)return e;var r=e.ancestors(),n=t.ancestors(),i=null;for(e=r.pop(),t=n.pop();e===t;)i=e,e=r.pop(),t=n.pop();return i}var okt=M(()=>{});function akt(){for(var e=this,t=[e];e=e.parent;)t.push(e);return t}var skt=M(()=>{});function lkt(){var e=[];return this.each(function(t){e.push(t)}),e}var ckt=M(()=>{});function ukt(){var e=[];return this.eachBefore(function(t){t.children||e.push(t)}),e}var hkt=M(()=>{});function fkt(){var e=this,t=[];return e.each(function(r){r!==e&&t.push({source:r.parent,target:r})}),t}var pkt=M(()=>{});function jT(e,t){var r=new xg(e),n=+e.value&&(r.value=e.value),i,o=[r],a,s,l,c;for(t==null&&(t=VPe);i=o.pop();)if(n&&(i.value=+i.data.value),(s=t(i.data))&&(c=s.length))for(i.children=new Array(c),l=c-1;l>=0;--l)o.push(a=i.children[l]=new xg(s[l])),a.parent=i,a.depth=i.depth+1;return r.eachBefore(mQ)}function HPe(){return jT(this).eachBefore(UPe)}function VPe(e){return e.children}function UPe(e){e.data=e.data.data}function mQ(e){var t=0;do e.height=t;while((e=e.parent)&&e.height<++t)}function xg(e){this.data=e,this.depth=this.height=0,this.parent=null}var jD=M(()=>{jLt();$Lt();ZLt();QLt();ekt();nkt();okt();skt();ckt();hkt();pkt();xg.prototype=jT.prototype={constructor:xg,count:YLt,each:XLt,eachAfter:JLt,eachBefore:KLt,sum:tkt,sort:rkt,path:ikt,ancestors:akt,descendants:lkt,leaves:ukt,links:fkt,copy:HPe}});function mkt(e){for(var t=e.length,r,n;t;)n=Math.random()*t--|0,r=e[t],e[t]=e[n],e[n]=r;return e}var dkt,gkt=M(()=>{dkt=Array.prototype.slice});function $D(e){for(var t=0,r=(e=mkt(dkt.call(e))).length,n=[],i,o;t<r;)i=e[t],o&&_kt(o,i)?++t:(o=GPe(n=qPe(n,i)),t=0);return o}function qPe(e,t){var r,n;if(gQ(t,e))return[t];for(r=0;r<e.length;++r)if(XD(t,e[r])&&gQ(XT(e[r],t),e))return[e[r],t];for(r=0;r<e.length-1;++r)for(n=r+1;n<e.length;++n)if(XD(XT(e[r],e[n]),t)&&XD(XT(e[r],t),e[n])&&XD(XT(e[n],t),e[r])&&gQ(ykt(e[r],e[n],t),e))return[e[r],e[n],t];throw new Error}function XD(e,t){var r=e.r-t.r,n=t.x-e.x,i=t.y-e.y;return r<0||r*r<n*n+i*i}function _kt(e,t){var r=e.r-t.r+1e-6,n=t.x-e.x,i=t.y-e.y;return r>0&&r*r>n*n+i*i}function gQ(e,t){for(var r=0;r<t.length;++r)if(!_kt(e,t[r]))return!1;return!0}function GPe(e){switch(e.length){case 1:return WPe(e[0]);case 2:return XT(e[0],e[1]);case 3:return ykt(e[0],e[1],e[2])}}function WPe(e){return{x:e.x,y:e.y,r:e.r}}function XT(e,t){var r=e.x,n=e.y,i=e.r,o=t.x,a=t.y,s=t.r,l=o-r,c=a-n,u=s-i,h=Math.sqrt(l*l+c*c);return{x:(r+o+l/h*u)/2,y:(n+a+c/h*u)/2,r:(h+i+s)/2}}function ykt(e,t,r){var n=e.x,i=e.y,o=e.r,a=t.x,s=t.y,l=t.r,c=r.x,u=r.y,h=r.r,f=n-a,p=n-c,d=i-s,g=i-u,_=l-o,y=h-o,x=n*n+i*i-o*o,b=x-a*a-s*s+l*l,S=x-c*c-u*u+h*h,C=p*d-f*g,P=(d*S-g*b)/(C*2)-n,k=(g*_-d*y)/C,O=(p*b-f*S)/(C*2)-i,D=(f*y-p*_)/C,B=k*k+D*D-1,I=2*(o+P*k+O*D),L=P*P+O*O-o*o,R=-(B?(I+Math.sqrt(I*I-4*B*L))/(2*B):L/I);return{x:n+P+k*R,y:i+O+D*R,r:R}}var _Q=M(()=>{gkt()});function vkt(e,t,r){var n=e.x,i=e.y,o=t.r+r.r,a=e.r+r.r,s=t.x-n,l=t.y-i,c=s*s+l*l;if(c){var u=.5+((a*=a)-(o*=o))/(2*c),h=Math.sqrt(Math.max(0,2*o*(a+c)-(a-=c)*a-o*o))/(2*c);r.x=n+u*s+h*l,r.y=i+u*l-h*s}else r.x=n+a,r.y=i}function xkt(e,t){var r=t.x-e.x,n=t.y-e.y,i=e.r+t.r;return i*i-1e-6>r*r+n*n}function bkt(e){var t=e._,r=e.next._,n=t.r+r.r,i=(t.x*r.r+r.x*t.r)/n,o=(t.y*r.r+r.y*t.r)/n;return i*i+o*o}function KD(e){this._=e,this.next=null,this.previous=null}function yQ(e){if(!(i=e.length))return 0;var t,r,n,i,o,a,s,l,c,u,h;if(t=e[0],t.x=0,t.y=0,!(i>1))return t.r;if(r=e[1],t.x=-r.r,r.x=t.r,r.y=0,!(i>2))return t.r+r.r;vkt(r,t,n=e[2]),t=new KD(t),r=new KD(r),n=new KD(n),t.next=n.previous=r,r.next=t.previous=n,n.next=r.previous=t;t:for(s=3;s<i;++s){vkt(t._,r._,n=e[s]),n=new KD(n),l=r.next,c=t.previous,u=r._.r,h=t._.r;do if(u<=h){if(xkt(l._,n._)){r=l,t.next=r,r.previous=t,--s;continue t}u+=l._.r,l=l.next}else{if(xkt(c._,n._)){t=c,t.next=r,r.previous=t,--s;continue t}h+=c._.r,c=c.previous}while(l!==c.next);for(n.previous=t,n.next=r,t.next=r.previous=r=n,o=bkt(t);(n=n.next)!==r;)(a=bkt(n))<o&&(t=n,o=a);r=t.next}for(t=[r._],n=r;(n=n.next)!==r;)t.push(n._);for(n=$D(t),s=0;s<i;++s)t=e[s],t.x-=n.x,t.y-=n.y;return n.r}function wkt(e){return yQ(e),e}var vQ=M(()=>{_Q()});function Skt(e){return e==null?null:V2(e)}function V2(e){if(typeof e!="function")throw new Error;return e}var ZD=M(()=>{});function td(){return 0}function bg(e){return function(){return e}}var xQ=M(()=>{});function YPe(e){return Math.sqrt(e.value)}function Tkt(){var e=null,t=1,r=1,n=td;function i(o){return o.x=t/2,o.y=r/2,e?o.eachBefore(Mkt(e)).eachAfter(bQ(n,.5)).eachBefore(Ekt(1)):o.eachBefore(Mkt(YPe)).eachAfter(bQ(td,1)).eachAfter(bQ(n,o.r/Math.min(t,r))).eachBefore(Ekt(Math.min(t,r)/(2*o.r))),o}return i.radius=function(o){return arguments.length?(e=Skt(o),i):e},i.size=function(o){return arguments.length?(t=+o[0],r=+o[1],i):[t,r]},i.padding=function(o){return arguments.length?(n=typeof o=="function"?o:bg(+o),i):n},i}function Mkt(e){return function(t){t.children||(t.r=Math.max(0,+e(t)||0))}}function bQ(e,t){return function(r){if(n=r.children){var n,i,o=n.length,a=e(r)*t||0,s;if(a)for(i=0;i<o;++i)n[i].r+=a;if(s=yQ(n),a)for(i=0;i<o;++i)n[i].r-=a;r.r=s+a}}}function Ekt(e){return function(t){var r=t.parent;t.r*=e,r&&(t.x=r.x+e*t.x,t.y=r.y+e*t.y)}}var Ckt=M(()=>{vQ();ZD();xQ()});function JD(e){e.x0=Math.round(e.x0),e.y0=Math.round(e.y0),e.x1=Math.round(e.x1),e.y1=Math.round(e.y1)}var wQ=M(()=>{});function lf(e,t,r,n,i){for(var o=e.children,a,s=-1,l=o.length,c=e.value&&(n-t)/e.value;++s<l;)a=o[s],a.y0=r,a.y1=i,a.x0=t,a.x1=t+=a.value*c}var U2=M(()=>{});function Akt(){var e=1,t=1,r=0,n=!1;function i(a){var s=a.height+1;return a.x0=a.y0=r,a.x1=e,a.y1=t/s,a.eachBefore(o(t,s)),n&&a.eachBefore(JD),a}function o(a,s){return function(l){l.children&&lf(l,l.x0,a*(l.depth+1)/s,l.x1,a*(l.depth+2)/s);var c=l.x0,u=l.y0,h=l.x1-r,f=l.y1-r;h<c&&(c=h=(c+h)/2),f<u&&(u=f=(u+f)/2),l.x0=c,l.y0=u,l.x1=h,l.y1=f}}return i.round=function(a){return arguments.length?(n=!!a,i):n},i.size=function(a){return arguments.length?(e=+a[0],t=+a[1],i):[e,t]},i.padding=function(a){return arguments.length?(r=+a,i):r},i}var Pkt=M(()=>{wQ();U2()});function XPe(e){return e.id}function $Pe(e){return e.parentId}function kkt(){var e=XPe,t=$Pe;function r(n){var i,o,a=n.length,s,l,c,u=new Array(a),h,f,p={};for(o=0;o<a;++o)i=n[o],c=u[o]=new xg(i),(h=e(i,o,n))!=null&&(h+="")&&(f=Ikt+(c.id=h),p[f]=f in p?Lkt:c);for(o=0;o<a;++o)if(c=u[o],h=t(n[o],o,n),h==null||!(h+="")){if(s)throw new Error("multiple roots");s=c}else{if(l=p[Ikt+h],!l)throw new Error("missing: "+h);if(l===Lkt)throw new Error("ambiguous: "+h);l.children?l.children.push(c):l.children=[c],c.parent=l}if(!s)throw new Error("no root");if(s.parent=jPe,s.eachBefore(function(d){d.depth=d.parent.depth+1,--a}).eachBefore(mQ),s.parent=null,a>0)throw new Error("cycle");return s}return r.id=function(n){return arguments.length?(e=V2(n),r):e},r.parentId=function(n){return arguments.length?(t=V2(n),r):t},r}var Ikt,jPe,Lkt,Rkt=M(()=>{ZD();jD();Ikt="$",jPe={depth:-1},Lkt={}});function KPe(e,t){return e.parent===t.parent?1:2}function SQ(e){var t=e.children;return t?t[0]:e.t}function MQ(e){var t=e.children;return t?t[t.length-1]:e.t}function ZPe(e,t,r){var n=r/(t.i-e.i);t.c-=n,t.s+=r,e.c+=n,t.z+=r,t.m+=r}function JPe(e){for(var t=0,r=0,n=e.children,i=n.length,o;--i>=0;)o=n[i],o.z+=t,o.m+=t,t+=o.s+(r+=o.c)}function QPe(e,t,r){return e.a.parent===t.parent?e.a:r}function QD(e,t){this._=e,this.parent=null,this.children=null,this.A=null,this.a=this,this.z=0,this.m=0,this.c=0,this.s=0,this.t=null,this.i=t}function t6e(e){for(var t=new QD(e,0),r,n=[t],i,o,a,s;r=n.pop();)if(o=r._.children)for(r.children=new Array(s=o.length),a=s-1;a>=0;--a)n.push(i=r.children[a]=new QD(o[a],a)),i.parent=r;return(t.parent=new QD(null,0)).children=[t],t}function Nkt(){var e=KPe,t=1,r=1,n=null;function i(c){var u=t6e(c);if(u.eachAfter(o),u.parent.m=-u.z,u.eachBefore(a),n)c.eachBefore(l);else{var h=c,f=c,p=c;c.eachBefore(function(x){x.x<h.x&&(h=x),x.x>f.x&&(f=x),x.depth>p.depth&&(p=x)});var d=h===f?1:e(h,f)/2,g=d-h.x,_=t/(f.x+d+g),y=r/(p.depth||1);c.eachBefore(function(x){x.x=(x.x+g)*_,x.y=x.depth*y})}return c}function o(c){var u=c.children,h=c.parent.children,f=c.i?h[c.i-1]:null;if(u){JPe(c);var p=(u[0].z+u[u.length-1].z)/2;f?(c.z=f.z+e(c._,f._),c.m=c.z-p):c.z=p}else f&&(c.z=f.z+e(c._,f._));c.parent.A=s(c,f,c.parent.A||h[0])}function a(c){c._.x=c.z+c.parent.m,c.m+=c.parent.m}function s(c,u,h){if(u){for(var f=c,p=c,d=u,g=f.parent.children[0],_=f.m,y=p.m,x=d.m,b=g.m,S;d=MQ(d),f=SQ(f),d&&f;)g=SQ(g),p=MQ(p),p.a=c,S=d.z+x-f.z-_+e(d._,f._),S>0&&(ZPe(QPe(d,c,h),c,S),_+=S,y+=S),x+=d.m,_+=f.m,b+=g.m,y+=p.m;d&&!MQ(p)&&(p.t=d,p.m+=x-y),f&&!SQ(g)&&(g.t=f,g.m+=_-b,h=c)}return h}function l(c){c.x*=t,c.y=c.depth*r}return i.separation=function(c){return arguments.length?(e=c,i):e},i.size=function(c){return arguments.length?(n=!1,t=+c[0],r=+c[1],i):n?null:[t,r]},i.nodeSize=function(c){return arguments.length?(n=!0,t=+c[0],r=+c[1],i):n?[t,r]:null},i}var Dkt=M(()=>{jD();QD.prototype=Object.create(xg.prototype)});function wg(e,t,r,n,i){for(var o=e.children,a,s=-1,l=o.length,c=e.value&&(i-r)/e.value;++s<l;)a=o[s],a.x0=t,a.x1=n,a.y0=r,a.y1=r+=a.value*c}var $T=M(()=>{});function TQ(e,t,r,n,i,o){for(var a=[],s=t.children,l,c,u=0,h=0,f=s.length,p,d,g=t.value,_,y,x,b,S,C,P;u<f;){p=i-r,d=o-n;do _=s[h++].value;while(!_&&h<f);for(y=x=_,C=Math.max(d/p,p/d)/(g*e),P=_*_*C,S=Math.max(x/P,P/y);h<f;++h){if(_+=c=s[h].value,c<y&&(y=c),c>x&&(x=c),P=_*_*C,b=Math.max(x/P,P/y),b>S){_-=c;break}S=b}a.push(l={value:_,dice:p<d,children:s.slice(u,h)}),l.dice?lf(l,r,n,i,g?n+=d*_/g:o):wg(l,r,n,g?r+=p*_/g:i,o),g-=_,u=h}return a}var EQ,tO,eO=M(()=>{U2();$T();EQ=(1+Math.sqrt(5))/2;tO=function e(t){function r(n,i,o,a,s){TQ(t,n,i,o,a,s)}return r.ratio=function(n){return e((n=+n)>1?n:1)},r}(EQ)});function Okt(){var e=tO,t=!1,r=1,n=1,i=[0],o=td,a=td,s=td,l=td,c=td;function u(f){return f.x0=f.y0=0,f.x1=r,f.y1=n,f.eachBefore(h),i=[0],t&&f.eachBefore(JD),f}function h(f){var p=i[f.depth],d=f.x0+p,g=f.y0+p,_=f.x1-p,y=f.y1-p;_<d&&(d=_=(d+_)/2),y<g&&(g=y=(g+y)/2),f.x0=d,f.y0=g,f.x1=_,f.y1=y,f.children&&(p=i[f.depth+1]=o(f)/2,d+=c(f)-p,g+=a(f)-p,_-=s(f)-p,y-=l(f)-p,_<d&&(d=_=(d+_)/2),y<g&&(g=y=(g+y)/2),e(f,d,g,_,y))}return u.round=function(f){return arguments.length?(t=!!f,u):t},u.size=function(f){return arguments.length?(r=+f[0],n=+f[1],u):[r,n]},u.tile=function(f){return arguments.length?(e=V2(f),u):e},u.padding=function(f){return arguments.length?u.paddingInner(f).paddingOuter(f):u.paddingInner()},u.paddingInner=function(f){return arguments.length?(o=typeof f=="function"?f:bg(+f),u):o},u.paddingOuter=function(f){return arguments.length?u.paddingTop(f).paddingRight(f).paddingBottom(f).paddingLeft(f):u.paddingTop()},u.paddingTop=function(f){return arguments.length?(a=typeof f=="function"?f:bg(+f),u):a},u.paddingRight=function(f){return arguments.length?(s=typeof f=="function"?f:bg(+f),u):s},u.paddingBottom=function(f){return arguments.length?(l=typeof f=="function"?f:bg(+f),u):l},u.paddingLeft=function(f){return arguments.length?(c=typeof f=="function"?f:bg(+f),u):c},u}var zkt=M(()=>{wQ();eO();ZD();xQ()});function Fkt(e,t,r,n,i){var o=e.children,a,s=o.length,l,c=new Array(s+1);for(c[0]=l=a=0;a<s;++a)c[a+1]=l+=o[a].value;u(0,s,e.value,t,r,n,i);function u(h,f,p,d,g,_,y){if(h>=f-1){var x=o[h];x.x0=d,x.y0=g,x.x1=_,x.y1=y;return}for(var b=c[h],S=p/2+b,C=h+1,P=f-1;C<P;){var k=C+P>>>1;c[k]<S?C=k+1:P=k}S-c[C-1]<c[C]-S&&h+1<C&&--C;var O=c[C]-b,D=p-O;if(_-d>y-g){var B=(d*D+_*O)/p;u(h,C,O,d,g,B,y),u(C,f,D,B,g,_,y)}else{var I=(g*D+y*O)/p;u(h,C,O,d,g,_,I),u(C,f,D,d,I,_,y)}}}var Bkt=M(()=>{});function Hkt(e,t,r,n,i){(e.depth&1?wg:lf)(e,t,r,n,i)}var Vkt=M(()=>{U2();$T()});var Ukt,qkt=M(()=>{U2();$T();eO();Ukt=function e(t){function r(n,i,o,a,s){if((l=n._squarify)&&l.ratio===t)for(var l,c,u,h,f=-1,p,d=l.length,g=n.value;++f<d;){for(c=l[f],u=c.children,h=c.value=0,p=u.length;h<p;++h)c.value+=u[h].value;c.dice?lf(c,i,o,a,o+=(s-o)*c.value/g):wg(c,i,o,i+=(a-i)*c.value/g,s),g-=c.value}else n._squarify=l=TQ(t,n,i,o,a,s),l.ratio=t}return r.ratio=function(n){return e((n=+n)>1?n:1)},r}(EQ)});var Gkt=M(()=>{WLt();jD();Ckt();vQ();_Q();Pkt();Rkt();Dkt();zkt();Bkt();U2();$T();Vkt();eO();qkt()});function ed(e,t,r){e.prototype=t.prototype=r,r.constructor=e}function Sg(e,t){var r=Object.create(e.prototype);for(var n in t)r[n]=t[n];return r}var rO=M(()=>{});function hf(){}function Ykt(){return this.rgb().formatHex()}function l6e(){return Jkt(this).formatHsl()}function jkt(){return this.rgb().formatRgb()}function Eg(e){var t,r;return e=(e+"").trim().toLowerCase(),(t=e6e.exec(e))?(r=t[1].length,t=parseInt(t[1],16),r===6?Xkt(t):r===3?new ro(t>>8&15|t>>4&240,t>>4&15|t&240,(t&15)<<4|t&15,1):r===8?nO(t>>24&255,t>>16&255,t>>8&255,(t&255)/255):r===4?nO(t>>12&15|t>>8&240,t>>8&15|t>>4&240,t>>4&15|t&240,((t&15)<<4|t&15)/255):null):(t=r6e.exec(e))?new ro(t[1],t[2],t[3],1):(t=n6e.exec(e))?new ro(t[1]*255/100,t[2]*255/100,t[3]*255/100,1):(t=i6e.exec(e))?nO(t[1],t[2],t[3],t[4]):(t=o6e.exec(e))?nO(t[1]*255/100,t[2]*255/100,t[3]*255/100,t[4]):(t=a6e.exec(e))?Zkt(t[1],t[2]/100,t[3]/100,1):(t=s6e.exec(e))?Zkt(t[1],t[2]/100,t[3]/100,t[4]):Wkt.hasOwnProperty(e)?Xkt(Wkt[e]):e==="transparent"?new ro(NaN,NaN,NaN,0):null}function Xkt(e){return new ro(e>>16&255,e>>8&255,e&255,1)}function nO(e,t,r,n){return n<=0&&(e=t=r=NaN),new ro(e,t,r,n)}function ZT(e){return e instanceof hf||(e=Eg(e)),e?(e=e.rgb(),new ro(e.r,e.g,e.b,e.opacity)):new ro}function G2(e,t,r,n){return arguments.length===1?ZT(e):new ro(e,t,r,n==null?1:n)}function ro(e,t,r,n){this.r=+e,this.g=+t,this.b=+r,this.opacity=+n}function $kt(){return"#"+CQ(this.r)+CQ(this.g)+CQ(this.b)}function Kkt(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"rgb(":"rgba(")+Math.max(0,Math.min(255,Math.round(this.r)||0))+", "+Math.max(0,Math.min(255,Math.round(this.g)||0))+", "+Math.max(0,Math.min(255,Math.round(this.b)||0))+(e===1?")":", "+e+")")}function CQ(e){return e=Math.max(0,Math.min(255,Math.round(e)||0)),(e<16?"0":"")+e.toString(16)}function Zkt(e,t,r,n){return n<=0?e=t=r=NaN:r<=0||r>=1?e=t=NaN:t<=0&&(e=NaN),new cf(e,t,r,n)}function Jkt(e){if(e instanceof cf)return new cf(e.h,e.s,e.l,e.opacity);if(e instanceof hf||(e=Eg(e)),!e)return new cf;if(e instanceof cf)return e;e=e.rgb();var t=e.r/255,r=e.g/255,n=e.b/255,i=Math.min(t,r,n),o=Math.max(t,r,n),a=NaN,s=o-i,l=(o+i)/2;return s?(t===o?a=(r-n)/s+(r<n)*6:r===o?a=(n-t)/s+2:a=(t-r)/s+4,s/=l<.5?o+i:2-o-i,a*=60):s=l>0&&l<1?0:a,new cf(a,s,l,e.opacity)}function JT(e,t,r,n){return arguments.length===1?Jkt(e):new cf(e,t,r,n==null?1:n)}function cf(e,t,r,n){this.h=+e,this.s=+t,this.l=+r,this.opacity=+n}function AQ(e,t,r){return(e<60?t+(r-t)*e/60:e<180?r:e<240?t+(r-t)*(240-e)/60:t)*255}var Mg,Wy,q2,KT,uf,e6e,r6e,n6e,i6e,o6e,a6e,s6e,Wkt,iO=M(()=>{rO();Mg=.7,Wy=1/Mg,q2="\\s*([+-]?\\d+)\\s*",KT="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",uf="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",e6e=/^#([0-9a-f]{3,8})$/,r6e=new RegExp("^rgb\\("+[q2,q2,q2]+"\\)$"),n6e=new RegExp("^rgb\\("+[uf,uf,uf]+"\\)$"),i6e=new RegExp("^rgba\\("+[q2,q2,q2,KT]+"\\)$"),o6e=new RegExp("^rgba\\("+[uf,uf,uf,KT]+"\\)$"),a6e=new RegExp("^hsl\\("+[KT,uf,uf]+"\\)$"),s6e=new RegExp("^hsla\\("+[KT,uf,uf,KT]+"\\)$"),Wkt={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};ed(hf,Eg,{copy:function(e){return Object.assign(new this.constructor,this,e)},displayable:function(){return this.rgb().displayable()},hex:Ykt,formatHex:Ykt,formatHsl:l6e,formatRgb:jkt,toString:jkt});ed(ro,G2,Sg(hf,{brighter:function(e){return e=e==null?Wy:Math.pow(Wy,e),new ro(this.r*e,this.g*e,this.b*e,this.opacity)},darker:function(e){return e=e==null?Mg:Math.pow(Mg,e),new ro(this.r*e,this.g*e,this.b*e,this.opacity)},rgb:function(){return this},displayable:function(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:$kt,formatHex:$kt,formatRgb:Kkt,toString:Kkt}));ed(cf,JT,Sg(hf,{brighter:function(e){return e=e==null?Wy:Math.pow(Wy,e),new cf(this.h,this.s,this.l*e,this.opacity)},darker:function(e){return e=e==null?Mg:Math.pow(Mg,e),new cf(this.h,this.s,this.l*e,this.opacity)},rgb:function(){var e=this.h%360+(this.h<0)*360,t=isNaN(e)||isNaN(this.s)?0:this.s,r=this.l,n=r+(r<.5?r:1-r)*t,i=2*r-n;return new ro(AQ(e>=240?e-240:e+120,i,n),AQ(e,i,n),AQ(e<120?e+240:e-120,i,n),this.opacity)},displayable:function(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl:function(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"hsl(":"hsla(")+(this.h||0)+", "+(this.s||0)*100+"%, "+(this.l||0)*100+"%"+(e===1?")":", "+e+")")}}))});var oO,aO,PQ=M(()=>{oO=Math.PI/180,aO=180/Math.PI});function i8t(e){if(e instanceof ff)return new ff(e.l,e.a,e.b,e.opacity);if(e instanceof rd)return o8t(e);e instanceof ro||(e=ZT(e));var t=RQ(e.r),r=RQ(e.g),n=RQ(e.b),i=IQ((.2225045*t+.7168786*r+.0606169*n)/t8t),o,a;return t===r&&r===n?o=a=i:(o=IQ((.4360747*t+.3850649*r+.1430804*n)/Qkt),a=IQ((.0139322*t+.0971045*r+.7141733*n)/e8t)),new ff(116*i-16,500*(o-i),200*(i-a),e.opacity)}function Y2(e,t,r,n){return arguments.length===1?i8t(e):new ff(e,t,r,n==null?1:n)}function ff(e,t,r,n){this.l=+e,this.a=+t,this.b=+r,this.opacity=+n}function IQ(e){return e>c6e?Math.pow(e,1/3):e/n8t+r8t}function LQ(e){return e>W2?e*e*e:n8t*(e-r8t)}function kQ(e){return 255*(e<=.0031308?12.92*e:1.055*Math.pow(e,1/2.4)-.055)}function RQ(e){return(e/=255)<=.04045?e/12.92:Math.pow((e+.055)/1.055,2.4)}function u6e(e){if(e instanceof rd)return new rd(e.h,e.c,e.l,e.opacity);if(e instanceof ff||(e=i8t(e)),e.a===0&&e.b===0)return new rd(NaN,0<e.l&&e.l<100?0:NaN,e.l,e.opacity);var t=Math.atan2(e.b,e.a)*aO;return new rd(t<0?t+360:t,Math.sqrt(e.a*e.a+e.b*e.b),e.l,e.opacity)}function QT(e,t,r,n){return arguments.length===1?u6e(e):new rd(e,t,r,n==null?1:n)}function rd(e,t,r,n){this.h=+e,this.c=+t,this.l=+r,this.opacity=+n}function o8t(e){if(isNaN(e.h))return new ff(e.l,0,0,e.opacity);var t=e.h*oO;return new ff(e.l,Math.cos(t)*e.c,Math.sin(t)*e.c,e.opacity)}var sO,Qkt,t8t,e8t,r8t,W2,n8t,c6e,a8t=M(()=>{rO();iO();PQ();sO=18,Qkt=.96422,t8t=1,e8t=.82521,r8t=4/29,W2=6/29,n8t=3*W2*W2,c6e=W2*W2*W2;ed(ff,Y2,Sg(hf,{brighter:function(e){return new ff(this.l+sO*(e==null?1:e),this.a,this.b,this.opacity)},darker:function(e){return new ff(this.l-sO*(e==null?1:e),this.a,this.b,this.opacity)},rgb:function(){var e=(this.l+16)/116,t=isNaN(this.a)?e:e+this.a/500,r=isNaN(this.b)?e:e-this.b/200;return t=Qkt*LQ(t),e=t8t*LQ(e),r=e8t*LQ(r),new ro(kQ(3.1338561*t-1.6168667*e-.4906146*r),kQ(-.9787684*t+1.9161415*e+.033454*r),kQ(.0719453*t-.2289914*e+1.4052427*r),this.opacity)}}));ed(rd,QT,Sg(hf,{brighter:function(e){return new rd(this.h,this.c,this.l+sO*(e==null?1:e),this.opacity)},darker:function(e){return new rd(this.h,this.c,this.l-sO*(e==null?1:e),this.opacity)},rgb:function(){return o8t(this).rgb()}}))});function h6e(e){if(e instanceof Yy)return new Yy(e.h,e.s,e.l,e.opacity);e instanceof ro||(e=ZT(e));var t=e.r/255,r=e.g/255,n=e.b/255,i=(c8t*n+s8t*t-l8t*r)/(c8t+s8t-l8t),o=n-i,a=(tC*(r-i)-DQ*o)/lO,s=Math.sqrt(a*a+o*o)/(tC*i*(1-i)),l=s?Math.atan2(a,o)*aO-120:NaN;return new Yy(l<0?l+360:l,s,i,e.opacity)}function j2(e,t,r,n){return arguments.length===1?h6e(e):new Yy(e,t,r,n==null?1:n)}function Yy(e,t,r,n){this.h=+e,this.s=+t,this.l=+r,this.opacity=+n}var u8t,NQ,DQ,lO,tC,s8t,l8t,c8t,h8t=M(()=>{rO();iO();PQ();u8t=-.14861,NQ=1.78277,DQ=-.29227,lO=-.90649,tC=1.97294,s8t=tC*lO,l8t=tC*NQ,c8t=NQ*DQ-lO*u8t;ed(Yy,j2,Sg(hf,{brighter:function(e){return e=e==null?Wy:Math.pow(Wy,e),new Yy(this.h,this.s,this.l*e,this.opacity)},darker:function(e){return e=e==null?Mg:Math.pow(Mg,e),new Yy(this.h,this.s,this.l*e,this.opacity)},rgb:function(){var e=isNaN(this.h)?0:(this.h+120)*oO,t=+this.l,r=isNaN(this.s)?0:this.s*t*(1-t),n=Math.cos(e),i=Math.sin(e);return new ro(255*(t+r*(u8t*n+NQ*i)),255*(t+r*(DQ*n+lO*i)),255*(t+r*(tC*n)),this.opacity)}}))});var jy=M(()=>{iO();a8t();h8t()});function OQ(e,t,r,n,i){var o=e*e,a=o*e;return((1-3*e+3*o-a)*t+(4-6*o+3*a)*r+(1+3*e+3*o-3*a)*n+a*i)/6}function cO(e){var t=e.length-1;return function(r){var n=r<=0?r=0:r>=1?(r=1,t-1):Math.floor(r*t),i=e[n],o=e[n+1],a=n>0?e[n-1]:2*i-o,s=n<t-1?e[n+2]:2*o-i;return OQ((r-n/t)*t,a,i,o,s)}}var uO=M(()=>{});function hO(e){var t=e.length;return function(r){var n=Math.floor(((r%=1)<0?++r:r)*t),i=e[(n+t-1)%t],o=e[n%t],a=e[(n+1)%t],s=e[(n+2)%t];return OQ((r-n/t)*t,i,o,a,s)}}var zQ=M(()=>{uO()});function X2(e){return function(){return e}}var FQ=M(()=>{});function f8t(e,t){return function(r){return e+r*t}}function f6e(e,t,r){return e=Math.pow(e,r),t=Math.pow(t,r)-e,r=1/r,function(n){return Math.pow(e+n*t,r)}}function $2(e,t){var r=t-e;return r?f8t(e,r>180||r<-180?r-360*Math.round(r/360):r):X2(isNaN(e)?t:e)}function p8t(e){return(e=+e)==1?Jn:function(t,r){return r-t?f6e(t,r,e):X2(isNaN(t)?r:t)}}function Jn(e,t){var r=t-e;return r?f8t(e,r):X2(isNaN(e)?t:e)}var K2=M(()=>{FQ()});function d8t(e){return function(t){var r=t.length,n=new Array(r),i=new Array(r),o=new Array(r),a,s;for(a=0;a<r;++a)s=G2(t[a]),n[a]=s.r||0,i[a]=s.g||0,o[a]=s.b||0;return n=e(n),i=e(i),o=e(o),s.opacity=1,function(l){return s.r=n(l),s.g=i(l),s.b=o(l),s+""}}}var eC,m8t,g8t,BQ=M(()=>{jy();uO();zQ();K2();eC=function e(t){var r=p8t(t);function n(i,o){var a=r((i=G2(i)).r,(o=G2(o)).r),s=r(i.g,o.g),l=r(i.b,o.b),c=Jn(i.opacity,o.opacity);return function(u){return i.r=a(u),i.g=s(u),i.b=l(u),i.opacity=c(u),i+""}}return n.gamma=e,n}(1);m8t=d8t(cO),g8t=d8t(hO)});function fO(e,t){var r=t?t.length:0,n=e?Math.min(r,e.length):0,i=new Array(n),o=new Array(r),a;for(a=0;a<n;++a)i[a]=Z2(e[a],t[a]);for(;a<r;++a)o[a]=t[a];return function(s){for(a=0;a<n;++a)o[a]=i[a](s);return o}}var HQ=M(()=>{pO()});function dO(e,t){var r=new Date;return e=+e,t-=e,function(n){return r.setTime(e+t*n),r}}var VQ=M(()=>{});function As(e,t){return e=+e,t-=e,function(r){return e+t*r}}var rC=M(()=>{});function mO(e,t){var r={},n={},i;(e===null||typeof e!="object")&&(e={}),(t===null||typeof t!="object")&&(t={});for(i in t)i in e?r[i]=Z2(e[i],t[i]):n[i]=t[i];return function(o){for(i in r)n[i]=r[i](o);return n}}var UQ=M(()=>{pO()});function p6e(e){return function(){return e}}function d6e(e){return function(t){return e(t)+""}}function gO(e,t){var r=GQ.lastIndex=qQ.lastIndex=0,n,i,o,a=-1,s=[],l=[];for(e=e+"",t=t+"";(n=GQ.exec(e))&&(i=qQ.exec(t));)(o=i.index)>r&&(o=t.slice(r,o),s[a]?s[a]+=o:s[++a]=o),(n=n[0])===(i=i[0])?s[a]?s[a]+=i:s[++a]=i:(s[++a]=null,l.push({i:a,x:As(n,i)})),r=qQ.lastIndex;return r<t.length&&(o=t.slice(r),s[a]?s[a]+=o:s[++a]=o),s.length<2?l[0]?d6e(l[0].x):p6e(t):(t=l.length,function(c){for(var u=0,h;u<t;++u)s[(h=l[u]).i]=h.x(c);return s.join("")})}var GQ,qQ,WQ=M(()=>{rC();GQ=/[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,qQ=new RegExp(GQ.source,"g")});function Z2(e,t){var r=typeof t,n;return t==null||r==="boolean"?X2(t):(r==="number"?As:r==="string"?(n=Eg(t))?(t=n,eC):gO:t instanceof Eg?eC:t instanceof Date?dO:Array.isArray(t)?fO:typeof t.valueOf!="function"&&typeof t.toString!="function"||isNaN(t)?mO:As)(e,t)}var pO=M(()=>{jy();BQ();HQ();VQ();rC();UQ();WQ();FQ()});function _8t(e,t){return e=+e,t-=e,function(r){return Math.round(e+t*r)}}var y8t=M(()=>{});function YQ(e,t,r,n,i,o){var a,s,l;return(a=Math.sqrt(e*e+t*t))&&(e/=a,t/=a),(l=e*r+t*n)&&(r-=e*l,n-=t*l),(s=Math.sqrt(r*r+n*n))&&(r/=s,n/=s,l/=s),e*n<t*r&&(e=-e,t=-t,l=-l,a=-a),{translateX:i,translateY:o,rotate:Math.atan2(t,e)*v8t,skewX:Math.atan(l)*v8t,scaleX:a,scaleY:s}}var v8t,_O,x8t=M(()=>{v8t=180/Math.PI,_O={translateX:0,translateY:0,rotate:0,skewX:0,scaleX:1,scaleY:1}});function w8t(e){return e==="none"?_O:(nC||(nC=document.createElement("DIV"),jQ=document.documentElement,b8t=document.defaultView),nC.style.transform=e,e=b8t.getComputedStyle(jQ.appendChild(nC),null).getPropertyValue("transform"),jQ.removeChild(nC),e=e.slice(7,-1).split(","),YQ(+e[0],+e[1],+e[2],+e[3],+e[4],+e[5]))}function S8t(e){return e==null?_O:(yO||(yO=document.createElementNS("http://www.w3.org/2000/svg","g")),yO.setAttribute("transform",e),(e=yO.transform.baseVal.consolidate())?(e=e.matrix,YQ(e.a,e.b,e.c,e.d,e.e,e.f)):_O)}var nC,jQ,b8t,yO,M8t=M(()=>{x8t()});function E8t(e,t,r,n){function i(c){return c.length?c.pop()+" ":""}function o(c,u,h,f,p,d){if(c!==h||u!==f){var g=p.push("translate(",null,t,null,r);d.push({i:g-4,x:As(c,h)},{i:g-2,x:As(u,f)})}else(h||f)&&p.push("translate("+h+t+f+r)}function a(c,u,h,f){c!==u?(c-u>180?u+=360:u-c>180&&(c+=360),f.push({i:h.push(i(h)+"rotate(",null,n)-2,x:As(c,u)})):u&&h.push(i(h)+"rotate("+u+n)}function s(c,u,h,f){c!==u?f.push({i:h.push(i(h)+"skewX(",null,n)-2,x:As(c,u)}):u&&h.push(i(h)+"skewX("+u+n)}function l(c,u,h,f,p,d){if(c!==h||u!==f){var g=p.push(i(p)+"scale(",null,",",null,")");d.push({i:g-4,x:As(c,h)},{i:g-2,x:As(u,f)})}else(h!==1||f!==1)&&p.push(i(p)+"scale("+h+","+f+")")}return function(c,u){var h=[],f=[];return c=e(c),u=e(u),o(c.translateX,c.translateY,u.translateX,u.translateY,h,f),a(c.rotate,u.rotate,h,f),s(c.skewX,u.skewX,h,f),l(c.scaleX,c.scaleY,u.scaleX,u.scaleY,h,f),c=u=null,function(p){for(var d=-1,g=f.length,_;++d<g;)h[(_=f[d]).i]=_.x(p);return h.join("")}}}var T8t,C8t,A8t=M(()=>{rC();M8t();T8t=E8t(w8t,"px, ","px)","deg)"),C8t=E8t(S8t,", ",")",")")});function I8t(e){return((e=Math.exp(e))+1/e)/2}function g6e(e){return((e=Math.exp(e))-1/e)/2}function _6e(e){return((e=Math.exp(2*e))-1)/(e+1)}function L8t(e,t){var r=e[0],n=e[1],i=e[2],o=t[0],a=t[1],s=t[2],l=o-r,c=a-n,u=l*l+c*c,h,f;if(u<m6e)f=Math.log(s/i)/iC,h=function(x){return[r+x*l,n+x*c,i*Math.exp(iC*x*f)]};else{var p=Math.sqrt(u),d=(s*s-i*i+P8t*u)/(2*i*XQ*p),g=(s*s-i*i-P8t*u)/(2*s*XQ*p),_=Math.log(Math.sqrt(d*d+1)-d),y=Math.log(Math.sqrt(g*g+1)-g);f=(y-_)/iC,h=function(x){var b=x*f,S=I8t(_),C=i/(XQ*p)*(S*_6e(iC*b+_)-g6e(_));return[r+C*l,n+C*c,i*S/I8t(iC*b+_)]}}return h.duration=f*1e3,h}var iC,XQ,P8t,m6e,k8t=M(()=>{iC=Math.SQRT2,XQ=2,P8t=4,m6e=1e-12});function R8t(e){return function(t,r){var n=e((t=JT(t)).h,(r=JT(r)).h),i=Jn(t.s,r.s),o=Jn(t.l,r.l),a=Jn(t.opacity,r.opacity);return function(s){return t.h=n(s),t.s=i(s),t.l=o(s),t.opacity=a(s),t+""}}}var N8t,D8t,O8t=M(()=>{jy();K2();N8t=R8t($2),D8t=R8t(Jn)});function $Q(e,t){var r=Jn((e=Y2(e)).l,(t=Y2(t)).l),n=Jn(e.a,t.a),i=Jn(e.b,t.b),o=Jn(e.opacity,t.opacity);return function(a){return e.l=r(a),e.a=n(a),e.b=i(a),e.opacity=o(a),e+""}}var z8t=M(()=>{jy();K2()});function F8t(e){return function(t,r){var n=e((t=QT(t)).h,(r=QT(r)).h),i=Jn(t.c,r.c),o=Jn(t.l,r.l),a=Jn(t.opacity,r.opacity);return function(s){return t.h=n(s),t.c=i(s),t.l=o(s),t.opacity=a(s),t+""}}}var B8t,H8t,V8t=M(()=>{jy();K2();B8t=F8t($2),H8t=F8t(Jn)});function U8t(e){return function t(r){r=+r;function n(i,o){var a=e((i=j2(i)).h,(o=j2(o)).h),s=Jn(i.s,o.s),l=Jn(i.l,o.l),c=Jn(i.opacity,o.opacity);return function(u){return i.h=a(u),i.s=s(u),i.l=l(Math.pow(u,r)),i.opacity=c(u),i+""}}return n.gamma=t,n}(1)}var q8t,G8t,W8t=M(()=>{jy();K2();q8t=U8t($2),G8t=U8t(Jn)});function Y8t(e,t){for(var r=new Array(t),n=0;n<t;++n)r[n]=e(n/(t-1));return r}var j8t=M(()=>{});var X8t=M(()=>{pO();HQ();uO();zQ();VQ();rC();UQ();y8t();WQ();A8t();k8t();BQ();O8t();z8t();V8t();W8t();j8t()});function JQ(){this._x0=this._y0=this._x1=this._y1=null,this._=""}function $8t(){return new JQ}var KQ,ZQ,Xy,y6e,K8t,Z8t=M(()=>{KQ=Math.PI,ZQ=2*KQ,Xy=1e-6,y6e=ZQ-Xy;JQ.prototype=$8t.prototype={constructor:JQ,moveTo:function(e,t){this._+="M"+(this._x0=this._x1=+e)+","+(this._y0=this._y1=+t)},closePath:function(){this._x1!==null&&(this._x1=this._x0,this._y1=this._y0,this._+="Z")},lineTo:function(e,t){this._+="L"+(this._x1=+e)+","+(this._y1=+t)},quadraticCurveTo:function(e,t,r,n){this._+="Q"+ +e+","+ +t+","+(this._x1=+r)+","+(this._y1=+n)},bezierCurveTo:function(e,t,r,n,i,o){this._+="C"+ +e+","+ +t+","+ +r+","+ +n+","+(this._x1=+i)+","+(this._y1=+o)},arcTo:function(e,t,r,n,i){e=+e,t=+t,r=+r,n=+n,i=+i;var o=this._x1,a=this._y1,s=r-e,l=n-t,c=o-e,u=a-t,h=c*c+u*u;if(i<0)throw new Error("negative radius: "+i);if(this._x1===null)this._+="M"+(this._x1=e)+","+(this._y1=t);else if(h>Xy)if(!(Math.abs(u*s-l*c)>Xy)||!i)this._+="L"+(this._x1=e)+","+(this._y1=t);else{var f=r-o,p=n-a,d=s*s+l*l,g=f*f+p*p,_=Math.sqrt(d),y=Math.sqrt(h),x=i*Math.tan((KQ-Math.acos((d+h-g)/(2*_*y)))/2),b=x/y,S=x/_;Math.abs(b-1)>Xy&&(this._+="L"+(e+b*c)+","+(t+b*u)),this._+="A"+i+","+i+",0,0,"+ +(u*f>c*p)+","+(this._x1=e+S*s)+","+(this._y1=t+S*l)}},arc:function(e,t,r,n,i,o){e=+e,t=+t,r=+r;var a=r*Math.cos(n),s=r*Math.sin(n),l=e+a,c=t+s,u=1^o,h=o?n-i:i-n;if(r<0)throw new Error("negative radius: "+r);this._x1===null?this._+="M"+l+","+c:(Math.abs(this._x1-l)>Xy||Math.abs(this._y1-c)>Xy)&&(this._+="L"+l+","+c),r&&(h<0&&(h=h%ZQ+ZQ),h>y6e?this._+="A"+r+","+r+",0,1,"+u+","+(e-a)+","+(t-s)+"A"+r+","+r+",0,1,"+u+","+(this._x1=l)+","+(this._y1=c):h>Xy&&(this._+="A"+r+","+r+",0,"+ +(h>=KQ)+","+u+","+(this._x1=e+r*Math.cos(i))+","+(this._y1=t+r*Math.sin(i))))},rect:function(e,t,r,n){this._+="M"+(this._x0=this._x1=+e)+","+(this._y0=this._y1=+t)+"h"+ +r+"v"+ +n+"h"+-r+"Z"},toString:function(){return this._}};K8t=$8t});var J8t=M(()=>{Z8t()});function Q8t(e){for(var t=-1,r=e.length,n,i=e[r-1],o=0;++t<r;)n=i,i=e[t],o+=n[1]*i[0]-n[0]*i[1];return o/2}var tRt=M(()=>{});function eRt(e){for(var t=-1,r=e.length,n=0,i=0,o,a=e[r-1],s,l=0;++t<r;)o=a,a=e[t],l+=s=o[0]*a[1]-a[0]*o[1],n+=(o[0]+a[0])*s,i+=(o[1]+a[1])*s;return l*=3,[n/l,i/l]}var rRt=M(()=>{});function nRt(e,t,r){return(t[0]-e[0])*(r[1]-e[1])-(t[1]-e[1])*(r[0]-e[0])}var iRt=M(()=>{});function v6e(e,t){return e[0]-t[0]||e[1]-t[1]}function oRt(e){for(var t=e.length,r=[0,1],n=2,i=2;i<t;++i){for(;n>1&&nRt(e[r[n-2]],e[r[n-1]],e[i])<=0;)--n;r[n++]=i}return r.slice(0,n)}function aRt(e){if((r=e.length)<3)return null;var t,r,n=new Array(r),i=new Array(r);for(t=0;t<r;++t)n[t]=[+e[t][0],+e[t][1],t];for(n.sort(v6e),t=0;t<r;++t)i[t]=[n[t][0],-n[t][1]];var o=oRt(n),a=oRt(i),s=a[0]===o[0],l=a[a.length-1]===o[o.length-1],c=[];for(t=o.length-1;t>=0;--t)c.push(e[n[o[t]][2]]);for(t=+s;t<a.length-l;++t)c.push(e[n[a[t]][2]]);return c}var sRt=M(()=>{iRt()});function lRt(e,t){for(var r=e.length,n=e[r-1],i=t[0],o=t[1],a=n[0],s=n[1],l,c,u=!1,h=0;h<r;++h)n=e[h],l=n[0],c=n[1],c>o!=s>o&&i<(a-l)*(o-c)/(s-c)+l&&(u=!u),a=l,s=c;return u}var cRt=M(()=>{});function uRt(e){for(var t=-1,r=e.length,n=e[r-1],i,o,a=n[0],s=n[1],l=0;++t<r;)i=a,o=s,n=e[t],a=n[0],s=n[1],i-=a,o-=s,l+=Math.sqrt(i*i+o*o);return l}var hRt=M(()=>{});var fRt=M(()=>{tRt();rRt();sRt();cRt();hRt()});function pRt(e){var t=+this._x.call(null,e),r=+this._y.call(null,e);return dRt(this.cover(t,r),t,r,e)}function dRt(e,t,r,n){if(isNaN(t)||isNaN(r))return e;var i,o=e._root,a={data:n},s=e._x0,l=e._y0,c=e._x1,u=e._y1,h,f,p,d,g,_,y,x;if(!o)return e._root=a,e;for(;o.length;)if((g=t>=(h=(s+c)/2))?s=h:c=h,(_=r>=(f=(l+u)/2))?l=f:u=f,i=o,!(o=o[y=_<<1|g]))return i[y]=a,e;if(p=+e._x.call(null,o.data),d=+e._y.call(null,o.data),t===p&&r===d)return a.next=o,i?i[y]=a:e._root=a,e;do i=i?i[y]=new Array(4):e._root=new Array(4),(g=t>=(h=(s+c)/2))?s=h:c=h,(_=r>=(f=(l+u)/2))?l=f:u=f;while((y=_<<1|g)===(x=(d>=f)<<1|p>=h));return i[x]=o,i[y]=a,e}function mRt(e){var t,r,n=e.length,i,o,a=new Array(n),s=new Array(n),l=1/0,c=1/0,u=-1/0,h=-1/0;for(r=0;r<n;++r)isNaN(i=+this._x.call(null,t=e[r]))||isNaN(o=+this._y.call(null,t))||(a[r]=i,s[r]=o,i<l&&(l=i),i>u&&(u=i),o<c&&(c=o),o>h&&(h=o));for(u<l&&(l=this._x0,u=this._x1),h<c&&(c=this._y0,h=this._y1),this.cover(l,c).cover(u,h),r=0;r<n;++r)dRt(this,a[r],s[r],e[r]);return this}var gRt=M(()=>{});function _Rt(e,t){if(isNaN(e=+e)||isNaN(t=+t))return this;var r=this._x0,n=this._y0,i=this._x1,o=this._y1;if(isNaN(r))i=(r=Math.floor(e))+1,o=(n=Math.floor(t))+1;else if(r>e||e>i||n>t||t>o){var a=i-r,s=this._root,l,c;switch(c=(t<(n+o)/2)<<1|e<(r+i)/2){case 0:{do l=new Array(4),l[c]=s,s=l;while(a*=2,i=r+a,o=n+a,e>i||t>o);break}case 1:{do l=new Array(4),l[c]=s,s=l;while(a*=2,r=i-a,o=n+a,r>e||t>o);break}case 2:{do l=new Array(4),l[c]=s,s=l;while(a*=2,i=r+a,n=o-a,e>i||n>t);break}case 3:{do l=new Array(4),l[c]=s,s=l;while(a*=2,r=i-a,n=o-a,r>e||n>t);break}}this._root&&this._root.length&&(this._root=s)}else return this;return this._x0=r,this._y0=n,this._x1=i,this._y1=o,this}var yRt=M(()=>{});function vRt(){var e=[];return this.visit(function(t){if(!t.length)do e.push(t.data);while(t=t.next)}),e}var xRt=M(()=>{});function bRt(e){return arguments.length?this.cover(+e[0][0],+e[0][1]).cover(+e[1][0],+e[1][1]):isNaN(this._x0)?void 0:[[this._x0,this._y0],[this._x1,this._y1]]}var wRt=M(()=>{});function Eo(e,t,r,n,i){this.node=e,this.x0=t,this.y0=r,this.x1=n,this.y1=i}var vO=M(()=>{});function SRt(e,t,r){var n,i=this._x0,o=this._y0,a,s,l,c,u=this._x1,h=this._y1,f=[],p=this._root,d,g;for(p&&f.push(new Eo(p,i,o,u,h)),r==null?r=1/0:(i=e-r,o=t-r,u=e+r,h=t+r,r*=r);d=f.pop();)if(!(!(p=d.node)||(a=d.x0)>u||(s=d.y0)>h||(l=d.x1)<i||(c=d.y1)<o))if(p.length){var _=(a+l)/2,y=(s+c)/2;f.push(new Eo(p[3],_,y,l,c),new Eo(p[2],a,y,_,c),new Eo(p[1],_,s,l,y),new Eo(p[0],a,s,_,y)),(g=(t>=y)<<1|e>=_)&&(d=f[f.length-1],f[f.length-1]=f[f.length-1-g],f[f.length-1-g]=d)}else{var x=e-+this._x.call(null,p.data),b=t-+this._y.call(null,p.data),S=x*x+b*b;if(S<r){var C=Math.sqrt(r=S);i=e-C,o=t-C,u=e+C,h=t+C,n=p.data}}return n}var MRt=M(()=>{vO()});function ERt(e){if(isNaN(u=+this._x.call(null,e))||isNaN(h=+this._y.call(null,e)))return this;var t,r=this._root,n,i,o,a=this._x0,s=this._y0,l=this._x1,c=this._y1,u,h,f,p,d,g,_,y;if(!r)return this;if(r.length)for(;;){if((d=u>=(f=(a+l)/2))?a=f:l=f,(g=h>=(p=(s+c)/2))?s=p:c=p,t=r,!(r=r[_=g<<1|d]))return this;if(!r.length)break;(t[_+1&3]||t[_+2&3]||t[_+3&3])&&(n=t,y=_)}for(;r.data!==e;)if(i=r,!(r=r.next))return this;return(o=r.next)&&delete r.next,i?(o?i.next=o:delete i.next,this):t?(o?t[_]=o:delete t[_],(r=t[0]||t[1]||t[2]||t[3])&&r===(t[3]||t[2]||t[1]||t[0])&&!r.length&&(n?n[y]=r:this._root=r),this):(this._root=o,this)}function TRt(e){for(var t=0,r=e.length;t<r;++t)this.remove(e[t]);return this}var CRt=M(()=>{});function ARt(){return this._root}var PRt=M(()=>{});function IRt(){var e=0;return this.visit(function(t){if(!t.length)do++e;while(t=t.next)}),e}var LRt=M(()=>{});function kRt(e){var t=[],r,n=this._root,i,o,a,s,l;for(n&&t.push(new Eo(n,this._x0,this._y0,this._x1,this._y1));r=t.pop();)if(!e(n=r.node,o=r.x0,a=r.y0,s=r.x1,l=r.y1)&&n.length){var c=(o+s)/2,u=(a+l)/2;(i=n[3])&&t.push(new Eo(i,c,u,s,l)),(i=n[2])&&t.push(new Eo(i,o,u,c,l)),(i=n[1])&&t.push(new Eo(i,c,a,s,u)),(i=n[0])&&t.push(new Eo(i,o,a,c,u))}return this}var RRt=M(()=>{vO()});function NRt(e){var t=[],r=[],n;for(this._root&&t.push(new Eo(this._root,this._x0,this._y0,this._x1,this._y1));n=t.pop();){var i=n.node;if(i.length){var o,a=n.x0,s=n.y0,l=n.x1,c=n.y1,u=(a+l)/2,h=(s+c)/2;(o=i[0])&&t.push(new Eo(o,a,s,u,h)),(o=i[1])&&t.push(new Eo(o,u,s,l,h)),(o=i[2])&&t.push(new Eo(o,a,h,u,c)),(o=i[3])&&t.push(new Eo(o,u,h,l,c))}r.push(n)}for(;n=r.pop();)e(n.node,n.x0,n.y0,n.x1,n.y1);return this}var DRt=M(()=>{vO()});function ORt(e){return e[0]}function zRt(e){return arguments.length?(this._x=e,this):this._x}var FRt=M(()=>{});function BRt(e){return e[1]}function HRt(e){return arguments.length?(this._y=e,this):this._y}var VRt=M(()=>{});function xO(e,t,r){var n=new QQ(t==null?ORt:t,r==null?BRt:r,NaN,NaN,NaN,NaN);return e==null?n:n.addAll(e)}function QQ(e,t,r,n,i,o){this._x=e,this._y=t,this._x0=r,this._y0=n,this._x1=i,this._y1=o,this._root=void 0}function URt(e){for(var t={data:e.data},r=t;e=e.next;)r=r.next={data:e.data};return t}var Xa,qRt=M(()=>{gRt();yRt();xRt();wRt();MRt();CRt();PRt();LRt();RRt();DRt();FRt();VRt();Xa=xO.prototype=QQ.prototype;Xa.copy=function(){var e=new QQ(this._x,this._y,this._x0,this._y0,this._x1,this._y1),t=this._root,r,n;if(!t)return e;if(!t.length)return e._root=URt(t),e;for(r=[{source:t,target:e._root=new Array(4)}];t=r.pop();)for(var i=0;i<4;++i)(n=t.source[i])&&(n.length?r.push({source:n,target:t.target[i]=new Array(4)}):t.target[i]=URt(n));return e};Xa.add=pRt;Xa.addAll=mRt;Xa.cover=_Rt;Xa.data=vRt;Xa.extent=bRt;Xa.find=SRt;Xa.remove=ERt;Xa.removeAll=TRt;Xa.root=ARt;Xa.size=IRt;Xa.visit=kRt;Xa.visitAfter=NRt;Xa.x=zRt;Xa.y=HRt});var GRt=M(()=>{qRt()});var WRt,YRt=M(()=>{WRt=[].slice});function ttt(e){this._size=e,this._call=this._error=null,this._tasks=[],this._data=[],this._waiting=this._active=this._ended=this._start=0}function jRt(e){if(!e._start)try{b6e(e)}catch(t){if(e._tasks[e._ended+e._active-1])ett(e,t);else if(!e._data)throw t}}function b6e(e){for(;e._start=e._waiting&&e._active<e._size;){var t=e._ended+e._active,r=e._tasks[t],n=r.length-1,i=r[n];r[n]=w6e(e,t),--e._waiting,++e._active,r=i.apply(null,r),e._tasks[t]&&(e._tasks[t]=r||x6e)}}function w6e(e,t){return function(r,n){!e._tasks[t]||(--e._active,++e._ended,e._tasks[t]=null,e._error==null&&(r!=null?ett(e,r):(e._data[t]=n,e._waiting?jRt(e):bO(e))))}}function ett(e,t){var r=e._tasks.length,n;for(e._error=t,e._data=void 0,e._waiting=NaN;--r>=0;)if((n=e._tasks[r])&&(e._tasks[r]=null,n.abort))try{n.abort()}catch(i){}e._active=NaN,bO(e)}function bO(e){if(!e._active&&e._call){var t=e._data;e._data=void 0,e._call(e._error,t)}}function wO(e){if(e==null)e=1/0;else if(!((e=+e)>=1))throw new Error("invalid concurrency");return new ttt(e)}var x6e,XRt=M(()=>{YRt();x6e={};ttt.prototype=wO.prototype={constructor:ttt,defer:function(e){if(typeof e!="function")throw new Error("invalid callback");if(this._call)throw new Error("defer after await");if(this._error!=null)return this;var t=WRt.call(arguments,1);return t.push(e),++this._waiting,this._tasks.push(t),jRt(this),this},abort:function(){return this._error==null&&ett(this,new Error("abort")),this},await:function(e){if(typeof e!="function")throw new Error("invalid callback");if(this._call)throw new Error("multiple await");return this._call=function(t,r){e.apply(null,[t].concat(r))},bO(this),this},awaitAll:function(e){if(typeof e!="function")throw new Error("invalid callback");if(this._call)throw new Error("multiple await");return this._call=e,bO(this),this}}});var $Rt=M(()=>{XRt()});function bc(){return Math.random()}var $y=M(()=>{});var KRt,ZRt=M(()=>{$y();KRt=function e(t){function r(n,i){return n=n==null?0:+n,i=i==null?1:+i,arguments.length===1?(i=n,n=0):i-=n,function(){return t()*i+n}}return r.source=e,r}(bc)});var SO,rtt=M(()=>{$y();SO=function e(t){function r(n,i){var o,a;return n=n==null?0:+n,i=i==null?1:+i,function(){var s;if(o!=null)s=o,o=null;else do o=t()*2-1,s=t()*2-1,a=o*o+s*s;while(!a||a>1);return n+i*s*Math.sqrt(-2*Math.log(a)/a)}}return r.source=e,r}(bc)});var JRt,QRt=M(()=>{$y();rtt();JRt=function e(t){function r(){var n=SO.source(t).apply(this,arguments);return function(){return Math.exp(n())}}return r.source=e,r}(bc)});var MO,ntt=M(()=>{$y();MO=function e(t){function r(n){return function(){for(var i=0,o=0;o<n;++o)i+=t();return i}}return r.source=e,r}(bc)});var tNt,eNt=M(()=>{$y();ntt();tNt=function e(t){function r(n){var i=MO.source(t)(n);return function(){return i()/n}}return r.source=e,r}(bc)});var rNt,nNt=M(()=>{$y();rNt=function e(t){function r(n){return function(){return-Math.log(1-t())/n}}return r.source=e,r}(bc)});var iNt=M(()=>{ZRt();rtt();QRt();eNt();ntt();nNt()});function J2(e,t){var r,n=vs("beforesend","progress","load","error"),i,o=Ji(),a=new XMLHttpRequest,s=null,l=null,c,u,h=0;typeof XDomainRequest!="undefined"&&!("withCredentials"in a)&&/^(http(s)?:)?\/\//.test(e)&&(a=new XDomainRequest),"onload"in a?a.onload=a.onerror=a.ontimeout=f:a.onreadystatechange=function(p){a.readyState>3&&f(p)};function f(p){var d=a.status,g;if(!d&&M6e(a)||d>=200&&d<300||d===304){if(c)try{g=c.call(r,a)}catch(_){n.call("error",r,_);return}else g=a;n.call("load",r,g)}else n.call("error",r,p)}if(a.onprogress=function(p){n.call("progress",r,p)},r={header:function(p,d){return p=(p+"").toLowerCase(),arguments.length<2?o.get(p):(d==null?o.remove(p):o.set(p,d+""),r)},mimeType:function(p){return arguments.length?(i=p==null?null:p+"",r):i},responseType:function(p){return arguments.length?(u=p,r):u},timeout:function(p){return arguments.length?(h=+p,r):h},user:function(p){return arguments.length<1?s:(s=p==null?null:p+"",r)},password:function(p){return arguments.length<1?l:(l=p==null?null:p+"",r)},response:function(p){return c=p,r},get:function(p,d){return r.send("GET",p,d)},post:function(p,d){return r.send("POST",p,d)},send:function(p,d,g){return a.open(p,e,!0,s,l),i!=null&&!o.has("accept")&&o.set("accept",i+",*/*"),a.setRequestHeader&&o.each(function(_,y){a.setRequestHeader(y,_)}),i!=null&&a.overrideMimeType&&a.overrideMimeType(i),u!=null&&(a.responseType=u),h>0&&(a.timeout=h),g==null&&typeof d=="function"&&(g=d,d=null),g!=null&&g.length===1&&(g=S6e(g)),g!=null&&r.on("error",g).on("load",function(_){g(null,_)}),n.call("beforesend",r,a),a.send(d==null?null:d),r},abort:function(){return a.abort(),r},on:function(){var p=n.on.apply(n,arguments);return p===n?r:p}},t!=null){if(typeof t!="function")throw new Error("invalid callback: "+t);return r.get(t)}return r}function S6e(e){return function(t,r){e(t==null?r:null)}}function M6e(e){var t=e.responseType;return t&&t!=="text"?e.response:e.responseText}var EO=M(()=>{Tb();km()});function Tg(e,t){return function(r,n){var i=J2(r).mimeType(e).response(t);if(n!=null){if(typeof n!="function")throw new Error("invalid callback: "+n);return i.get(n)}return i}}var oC=M(()=>{EO()});var oNt,aNt=M(()=>{oC();oNt=Tg("text/html",function(e){return document.createRange().createContextualFragment(e.responseText)})});var sNt,lNt=M(()=>{oC();sNt=Tg("application/json",function(e){return JSON.parse(e.responseText)})});var cNt,uNt=M(()=>{oC();cNt=Tg("text/plain",function(e){return e.responseText})});var hNt,fNt=M(()=>{oC();hNt=Tg("application/xml",function(e){var t=e.responseXML;if(!t)throw new Error("parse error");return t})});function TO(e,t){return function(r,n,i){arguments.length<3&&(i=n,n=null);var o=J2(r).mimeType(e);return o.row=function(a){return arguments.length?o.response(E6e(t,n=a)):n},o.row(n),i?o.get(i):o}}function E6e(e,t){return function(r){return e(r.responseText,t)}}var itt=M(()=>{EO()});var pNt,dNt=M(()=>{qE();itt();pNt=TO("text/csv",Cb)});var mNt,gNt=M(()=>{qE();itt();mNt=TO("text/tab-separated-values",Ab)});var _Nt=M(()=>{EO();aNt();lNt();uNt();fNt();dNt();gNt()});function pf(e,t){return e<t?-1:e>t?1:e>=t?0:NaN}var Ky=M(()=>{});function aC(e){return e.length===1&&(e=T6e(e)),{left:function(t,r,n,i){for(n==null&&(n=0),i==null&&(i=t.length);n<i;){var o=n+i>>>1;e(t[o],r)<0?n=o+1:i=o}return n},right:function(t,r,n,i){for(n==null&&(n=0),i==null&&(i=t.length);n<i;){var o=n+i>>>1;e(t[o],r)>0?i=o:n=o+1}return n}}}function T6e(e){return function(t,r){return pf(e(t),r)}}var ott=M(()=>{Ky()});var yNt,vNt,C6e,df,att=M(()=>{Ky();ott();yNt=aC(pf),vNt=yNt.right,C6e=yNt.left,df=vNt});var stt=M(()=>{});var xNt=M(()=>{stt()});var bNt=M(()=>{});function Q2(e){return e===null?NaN:+e}var tw=M(()=>{});var ltt=M(()=>{tw()});var ctt=M(()=>{ltt()});var utt=M(()=>{});var wNt,P6e,I6e,htt=M(()=>{wNt=Array.prototype,P6e=wNt.slice,I6e=wNt.map});var SNt=M(()=>{});var MNt=M(()=>{});function CO(e,t,r){e=+e,t=+t,r=(i=arguments.length)<2?(t=e,e=0,1):i<3?1:+r;for(var n=-1,i=Math.max(0,Math.ceil((t-e)/r))|0,o=new Array(i);++n<i;)o[n]=e+n*r;return o}var ftt=M(()=>{});function sC(e,t,r){var n,i=-1,o,a,s;if(t=+t,e=+e,r=+r,e===t&&r>0)return[e];if((n=t<e)&&(o=e,e=t,t=o),(s=ew(e,t,r))===0||!isFinite(s))return[];if(s>0)for(e=Math.ceil(e/s),t=Math.floor(t/s),a=new Array(o=Math.ceil(t-e+1));++i<o;)a[i]=(e+i)*s;else for(e=Math.floor(e*s),t=Math.ceil(t*s),a=new Array(o=Math.ceil(e-t+1));++i<o;)a[i]=(e-i)/s;return n&&a.reverse(),a}function ew(e,t,r){var n=(t-e)/Math.max(0,r),i=Math.floor(Math.log(n)/Math.LN10),o=n/Math.pow(10,i);return i>=0?(o>=ptt?10:o>=dtt?5:o>=mtt?2:1)*Math.pow(10,i):-Math.pow(10,-i)/(o>=ptt?10:o>=dtt?5:o>=mtt?2:1)}function Zy(e,t,r){var n=Math.abs(t-e)/Math.max(0,r),i=Math.pow(10,Math.floor(Math.log(n)/Math.LN10)),o=n/i;return o>=ptt?i*=10:o>=dtt?i*=5:o>=mtt&&(i*=2),t<e?-i:i}var ptt,dtt,mtt,gtt=M(()=>{ptt=Math.sqrt(50),dtt=Math.sqrt(10),mtt=Math.sqrt(2)});var _tt=M(()=>{});var ENt=M(()=>{htt();att();SNt();utt();MNt();ftt();gtt();_tt()});function lC(e,t,r){if(r==null&&(r=Q2),!!(n=e.length)){if((t=+t)<=0||n<2)return+r(e[0],0,e);if(t>=1)return+r(e[n-1],n-1,e);var n,i=(n-1)*t,o=Math.floor(i),a=+r(e[o],o,e),s=+r(e[o+1],o+1,e);return a+(s-a)*(i-o)}}var AO=M(()=>{tw()});var TNt=M(()=>{htt();Ky();tw();AO()});var CNt=M(()=>{ctt()});var ANt=M(()=>{});var PNt=M(()=>{tw()});var INt=M(()=>{Ky();tw();AO()});var LNt=M(()=>{});var ytt=M(()=>{});var kNt=M(()=>{});var RNt=M(()=>{Ky()});var NNt=M(()=>{});var DNt=M(()=>{});var vtt=M(()=>{ytt()});var ONt=M(()=>{vtt()});var mf=M(()=>{att();Ky();ott();xNt();bNt();ctt();utt();ENt();TNt();CNt();_tt();ANt();PNt();INt();LNt();ytt();stt();kNt();AO();ftt();RNt();NNt();DNt();gtt();vtt();ltt();ONt()});function PO(){}function zNt(e,t){var r=new PO;if(e instanceof PO)e.each(function(s,l){r.set(l,s)});else if(Array.isArray(e)){var n=-1,i=e.length,o;if(t==null)for(;++n<i;)r.set(n,e[n]);else for(;++n<i;)r.set(t(o=e[n],n,e),o)}else if(e)for(var a in e)r.set(a,e[a]);return r}var fl,Jy,IO=M(()=>{fl="$";PO.prototype=zNt.prototype={constructor:PO,has:function(e){return fl+e in this},get:function(e){return this[fl+e]},set:function(e,t){return this[fl+e]=t,this},remove:function(e){var t=fl+e;return t in this&&delete this[t]},clear:function(){for(var e in this)e[0]===fl&&delete this[e]},keys:function(){var e=[];for(var t in this)t[0]===fl&&e.push(t.slice(1));return e},values:function(){var e=[];for(var t in this)t[0]===fl&&e.push(this[t]);return e},entries:function(){var e=[];for(var t in this)t[0]===fl&&e.push({key:t.slice(1),value:this[t]});return e},size:function(){var e=0;for(var t in this)t[0]===fl&&++e;return e},empty:function(){for(var e in this)if(e[0]===fl)return!1;return!0},each:function(e){for(var t in this)t[0]===fl&&e(this[t],t.slice(1),this)}};Jy=zNt});var FNt=M(()=>{IO()});function LO(){}function O6e(e,t){var r=new LO;if(e instanceof LO)e.each(function(o){r.add(o)});else if(e){var n=-1,i=e.length;if(t==null)for(;++n<i;)r.add(e[n]);else for(;++n<i;)r.add(t(e[n],n,e))}return r}var Qy,BNt=M(()=>{IO();Qy=Jy.prototype;LO.prototype=O6e.prototype={constructor:LO,has:Qy.has,add:function(e){return e+="",this[fl+e]=e,this},remove:Qy.remove,clear:Qy.clear,values:Qy.keys,size:Qy.size,empty:Qy.empty,each:Qy.each}});var HNt=M(()=>{});var VNt=M(()=>{});var UNt=M(()=>{});var qNt=M(()=>{FNt();BNt();IO();HNt();VNt();UNt()});var GNt,rw,pl,Cg=M(()=>{GNt=Array.prototype,rw=GNt.map,pl=GNt.slice});function nw(e){var t=Jy(),r=[],n=kO;e=e==null?[]:pl.call(e);function i(o){var a=o+"",s=t.get(a);if(!s){if(n!==kO)return n;t.set(a,s=r.push(o))}return e[(s-1)%e.length]}return i.domain=function(o){if(!arguments.length)return r.slice();r=[],t=Jy();for(var a=-1,s=o.length,l,c;++a<s;)t.has(c=(l=o[a])+"")||t.set(c,r.push(l));return i},i.range=function(o){return arguments.length?(e=pl.call(o),i):e.slice()},i.unknown=function(o){return arguments.length?(n=o,i):n},i.copy=function(){return nw().domain(r).range(e).unknown(n)},i}var kO,xtt=M(()=>{qNt();Cg();kO={name:"implicit"}});function cC(){var e=nw().unknown(void 0),t=e.domain,r=e.range,n=[0,1],i,o,a=!1,s=0,l=0,c=.5;delete e.unknown;function u(){var h=t().length,f=n[1]<n[0],p=n[f-0],d=n[1-f];i=(d-p)/Math.max(1,h-s+l*2),a&&(i=Math.floor(i)),p+=(d-p-i*(h-s))*c,o=i*(1-s),a&&(p=Math.round(p),o=Math.round(o));var g=CO(h).map(function(_){return p+i*_});return r(f?g.reverse():g)}return e.domain=function(h){return arguments.length?(t(h),u()):t()},e.range=function(h){return arguments.length?(n=[+h[0],+h[1]],u()):n.slice()},e.rangeRound=function(h){return n=[+h[0],+h[1]],a=!0,u()},e.bandwidth=function(){return o},e.step=function(){return i},e.round=function(h){return arguments.length?(a=!!h,u()):a},e.padding=function(h){return arguments.length?(s=l=Math.max(0,Math.min(1,h)),u()):s},e.paddingInner=function(h){return arguments.length?(s=Math.max(0,Math.min(1,h)),u()):s},e.paddingOuter=function(h){return arguments.length?(l=Math.max(0,Math.min(1,h)),u()):l},e.align=function(h){return arguments.length?(c=Math.max(0,Math.min(1,h)),u()):c},e.copy=function(){return cC().domain(t()).range(n).round(a).paddingInner(s).paddingOuter(l).align(c)},u()}function WNt(e){var t=e.copy;return e.padding=e.paddingOuter,delete e.paddingInner,delete e.paddingOuter,e.copy=function(){return WNt(t())},e}function YNt(){return WNt(cC().paddingInner(1))}var jNt=M(()=>{mf();xtt()});function iw(e,t,r){e.prototype=t.prototype=r,r.constructor=e}function uC(e,t){var r=Object.create(e.prototype);for(var n in t)r[n]=t[n];return r}var btt=M(()=>{});function ev(){}function $Nt(){return this.rgb().formatHex()}function G6e(){return eDt(this).formatHsl()}function KNt(){return this.rgb().formatRgb()}function Pg(e){var t,r;return e=(e+"").trim().toLowerCase(),(t=z6e.exec(e))?(r=t[1].length,t=parseInt(t[1],16),r===6?ZNt(t):r===3?new ha(t>>8&15|t>>4&240,t>>4&15|t&240,(t&15)<<4|t&15,1):r===8?RO(t>>24&255,t>>16&255,t>>8&255,(t&255)/255):r===4?RO(t>>12&15|t>>8&240,t>>8&15|t>>4&240,t>>4&15|t&240,((t&15)<<4|t&15)/255):null):(t=F6e.exec(e))?new ha(t[1],t[2],t[3],1):(t=B6e.exec(e))?new ha(t[1]*255/100,t[2]*255/100,t[3]*255/100,1):(t=H6e.exec(e))?RO(t[1],t[2],t[3],t[4]):(t=V6e.exec(e))?RO(t[1]*255/100,t[2]*255/100,t[3]*255/100,t[4]):(t=U6e.exec(e))?tDt(t[1],t[2]/100,t[3]/100,1):(t=q6e.exec(e))?tDt(t[1],t[2]/100,t[3]/100,t[4]):XNt.hasOwnProperty(e)?ZNt(XNt[e]):e==="transparent"?new ha(NaN,NaN,NaN,0):null}function ZNt(e){return new ha(e>>16&255,e>>8&255,e&255,1)}function RO(e,t,r,n){return n<=0&&(e=t=r=NaN),new ha(e,t,r,n)}function Mtt(e){return e instanceof ev||(e=Pg(e)),e?(e=e.rgb(),new ha(e.r,e.g,e.b,e.opacity)):new ha}function aw(e,t,r,n){return arguments.length===1?Mtt(e):new ha(e,t,r,n==null?1:n)}function ha(e,t,r,n){this.r=+e,this.g=+t,this.b=+r,this.opacity=+n}function JNt(){return"#"+wtt(this.r)+wtt(this.g)+wtt(this.b)}function QNt(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"rgb(":"rgba(")+Math.max(0,Math.min(255,Math.round(this.r)||0))+", "+Math.max(0,Math.min(255,Math.round(this.g)||0))+", "+Math.max(0,Math.min(255,Math.round(this.b)||0))+(e===1?")":", "+e+")")}function wtt(e){return e=Math.max(0,Math.min(255,Math.round(e)||0)),(e<16?"0":"")+e.toString(16)}function tDt(e,t,r,n){return n<=0?e=t=r=NaN:r<=0||r>=1?e=t=NaN:t<=0&&(e=NaN),new gf(e,t,r,n)}function eDt(e){if(e instanceof gf)return new gf(e.h,e.s,e.l,e.opacity);if(e instanceof ev||(e=Pg(e)),!e)return new gf;if(e instanceof gf)return e;e=e.rgb();var t=e.r/255,r=e.g/255,n=e.b/255,i=Math.min(t,r,n),o=Math.max(t,r,n),a=NaN,s=o-i,l=(o+i)/2;return s?(t===o?a=(r-n)/s+(r<n)*6:r===o?a=(n-t)/s+2:a=(t-r)/s+4,s/=l<.5?o+i:2-o-i,a*=60):s=l>0&&l<1?0:a,new gf(a,s,l,e.opacity)}function rDt(e,t,r,n){return arguments.length===1?eDt(e):new gf(e,t,r,n==null?1:n)}function gf(e,t,r,n){this.h=+e,this.s=+t,this.l=+r,this.opacity=+n}function Stt(e,t,r){return(e<60?t+(r-t)*e/60:e<180?r:e<240?t+(r-t)*(240-e)/60:t)*255}var Ag,tv,ow,hC,_f,z6e,F6e,B6e,H6e,V6e,U6e,q6e,XNt,Ett=M(()=>{btt();Ag=.7,tv=1/Ag,ow="\\s*([+-]?\\d+)\\s*",hC="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",_f="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",z6e=/^#([0-9a-f]{3,8})$/,F6e=new RegExp("^rgb\\("+[ow,ow,ow]+"\\)$"),B6e=new RegExp("^rgb\\("+[_f,_f,_f]+"\\)$"),H6e=new RegExp("^rgba\\("+[ow,ow,ow,hC]+"\\)$"),V6e=new RegExp("^rgba\\("+[_f,_f,_f,hC]+"\\)$"),U6e=new RegExp("^hsl\\("+[hC,_f,_f]+"\\)$"),q6e=new RegExp("^hsla\\("+[hC,_f,_f,hC]+"\\)$"),XNt={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};iw(ev,Pg,{copy:function(e){return Object.assign(new this.constructor,this,e)},displayable:function(){return this.rgb().displayable()},hex:$Nt,formatHex:$Nt,formatHsl:G6e,formatRgb:KNt,toString:KNt});iw(ha,aw,uC(ev,{brighter:function(e){return e=e==null?tv:Math.pow(tv,e),new ha(this.r*e,this.g*e,this.b*e,this.opacity)},darker:function(e){return e=e==null?Ag:Math.pow(Ag,e),new ha(this.r*e,this.g*e,this.b*e,this.opacity)},rgb:function(){return this},displayable:function(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:JNt,formatHex:JNt,formatRgb:QNt,toString:QNt}));iw(gf,rDt,uC(ev,{brighter:function(e){return e=e==null?tv:Math.pow(tv,e),new gf(this.h,this.s,this.l*e,this.opacity)},darker:function(e){return e=e==null?Ag:Math.pow(Ag,e),new gf(this.h,this.s,this.l*e,this.opacity)},rgb:function(){var e=this.h%360+(this.h<0)*360,t=isNaN(e)||isNaN(this.s)?0:this.s,r=this.l,n=r+(r<.5?r:1-r)*t,i=2*r-n;return new ha(Stt(e>=240?e-240:e+120,i,n),Stt(e,i,n),Stt(e<120?e+240:e-120,i,n),this.opacity)},displayable:function(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl:function(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"hsl(":"hsla(")+(this.h||0)+", "+(this.s||0)*100+"%, "+(this.l||0)*100+"%"+(e===1?")":", "+e+")")}}))});var nDt,iDt,oDt=M(()=>{nDt=Math.PI/180,iDt=180/Math.PI});function W6e(e){if(e instanceof rv)return new rv(e.h,e.s,e.l,e.opacity);e instanceof ha||(e=Mtt(e));var t=e.r/255,r=e.g/255,n=e.b/255,i=(lDt*n+aDt*t-sDt*r)/(lDt+aDt-sDt),o=n-i,a=(fC*(r-i)-Ctt*o)/NO,s=Math.sqrt(a*a+o*o)/(fC*i*(1-i)),l=s?Math.atan2(a,o)*iDt-120:NaN;return new rv(l<0?l+360:l,s,i,e.opacity)}function $a(e,t,r,n){return arguments.length===1?W6e(e):new rv(e,t,r,n==null?1:n)}function rv(e,t,r,n){this.h=+e,this.s=+t,this.l=+r,this.opacity=+n}var cDt,Ttt,Ctt,NO,fC,aDt,sDt,lDt,uDt=M(()=>{btt();Ett();oDt();cDt=-.14861,Ttt=1.78277,Ctt=-.29227,NO=-.90649,fC=1.97294,aDt=fC*NO,sDt=fC*Ttt,lDt=Ttt*Ctt-NO*cDt;iw(rv,$a,uC(ev,{brighter:function(e){return e=e==null?tv:Math.pow(tv,e),new rv(this.h,this.s,this.l*e,this.opacity)},darker:function(e){return e=e==null?Ag:Math.pow(Ag,e),new rv(this.h,this.s,this.l*e,this.opacity)},rgb:function(){var e=isNaN(this.h)?0:(this.h+120)*nDt,t=+this.l,r=isNaN(this.s)?0:this.s*t*(1-t),n=Math.cos(e),i=Math.sin(e);return new ha(255*(t+r*(cDt*n+Ttt*i)),255*(t+r*(Ctt*n+NO*i)),255*(t+r*(fC*n)),this.opacity)}}))});var sw=M(()=>{Ett();uDt()});function Att(e,t,r,n,i){var o=e*e,a=o*e;return((1-3*e+3*o-a)*t+(4-6*o+3*a)*r+(1+3*e+3*o-3*a)*n+a*i)/6}function hDt(e){var t=e.length-1;return function(r){var n=r<=0?r=0:r>=1?(r=1,t-1):Math.floor(r*t),i=e[n],o=e[n+1],a=n>0?e[n-1]:2*i-o,s=n<t-1?e[n+2]:2*o-i;return Att((r-n/t)*t,a,i,o,s)}}var Ptt=M(()=>{});function fDt(e){var t=e.length;return function(r){var n=Math.floor(((r%=1)<0?++r:r)*t),i=e[(n+t-1)%t],o=e[n%t],a=e[(n+1)%t],s=e[(n+2)%t];return Att((r-n/t)*t,i,o,a,s)}}var pDt=M(()=>{Ptt()});function lw(e){return function(){return e}}var Itt=M(()=>{});function dDt(e,t){return function(r){return e+r*t}}function Y6e(e,t,r){return e=Math.pow(e,r),t=Math.pow(t,r)-e,r=1/r,function(n){return Math.pow(e+n*t,r)}}function mDt(e,t){var r=t-e;return r?dDt(e,r>180||r<-180?r-360*Math.round(r/360):r):lw(isNaN(e)?t:e)}function gDt(e){return(e=+e)==1?nd:function(t,r){return r-t?Y6e(t,r,e):lw(isNaN(t)?r:t)}}function nd(e,t){var r=t-e;return r?dDt(e,r):lw(isNaN(e)?t:e)}var Ltt=M(()=>{Itt()});function _Dt(e){return function(t){var r=t.length,n=new Array(r),i=new Array(r),o=new Array(r),a,s;for(a=0;a<r;++a)s=aw(t[a]),n[a]=s.r||0,i[a]=s.g||0,o[a]=s.b||0;return n=e(n),i=e(i),o=e(o),s.opacity=1,function(l){return s.r=n(l),s.g=i(l),s.b=o(l),s+""}}}var ktt,_5n,y5n,yDt=M(()=>{sw();Ptt();pDt();Ltt();ktt=function e(t){var r=gDt(t);function n(i,o){var a=r((i=aw(i)).r,(o=aw(o)).r),s=r(i.g,o.g),l=r(i.b,o.b),c=nd(i.opacity,o.opacity);return function(u){return i.r=a(u),i.g=s(u),i.b=l(u),i.opacity=c(u),i+""}}return n.gamma=e,n}(1);_5n=_Dt(hDt),y5n=_Dt(fDt)});function vDt(e,t){t||(t=[]);var r=e?Math.min(t.length,e.length):0,n=t.slice(),i;return function(o){for(i=0;i<r;++i)n[i]=e[i]*(1-o)+t[i]*o;return n}}function xDt(e){return ArrayBuffer.isView(e)&&!(e instanceof DataView)}var bDt=M(()=>{});function wDt(e,t){var r=t?t.length:0,n=e?Math.min(r,e.length):0,i=new Array(n),o=new Array(r),a;for(a=0;a<n;++a)i[a]=nv(e[a],t[a]);for(;a<r;++a)o[a]=t[a];return function(s){for(a=0;a<n;++a)o[a]=i[a](s);return o}}var SDt=M(()=>{DO()});function MDt(e,t){var r=new Date;return e=+e,t=+t,function(n){return r.setTime(e*(1-n)+t*n),r}}var EDt=M(()=>{});function yf(e,t){return e=+e,t=+t,function(r){return e*(1-r)+t*r}}var OO=M(()=>{});function TDt(e,t){var r={},n={},i;(e===null||typeof e!="object")&&(e={}),(t===null||typeof t!="object")&&(t={});for(i in t)i in e?r[i]=nv(e[i],t[i]):n[i]=t[i];return function(o){for(i in r)n[i]=r[i](o);return n}}var CDt=M(()=>{DO()});function j6e(e){return function(){return e}}function X6e(e){return function(t){return e(t)+""}}function ADt(e,t){var r=Ntt.lastIndex=Rtt.lastIndex=0,n,i,o,a=-1,s=[],l=[];for(e=e+"",t=t+"";(n=Ntt.exec(e))&&(i=Rtt.exec(t));)(o=i.index)>r&&(o=t.slice(r,o),s[a]?s[a]+=o:s[++a]=o),(n=n[0])===(i=i[0])?s[a]?s[a]+=i:s[++a]=i:(s[++a]=null,l.push({i:a,x:yf(n,i)})),r=Rtt.lastIndex;return r<t.length&&(o=t.slice(r),s[a]?s[a]+=o:s[++a]=o),s.length<2?l[0]?X6e(l[0].x):j6e(t):(t=l.length,function(c){for(var u=0,h;u<t;++u)s[(h=l[u]).i]=h.x(c);return s.join("")})}var Ntt,Rtt,PDt=M(()=>{OO();Ntt=/[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,Rtt=new RegExp(Ntt.source,"g")});function nv(e,t){var r=typeof t,n;return t==null||r==="boolean"?lw(t):(r==="number"?yf:r==="string"?(n=Pg(t))?(t=n,ktt):ADt:t instanceof Pg?ktt:t instanceof Date?MDt:xDt(t)?vDt:Array.isArray(t)?wDt:typeof t.valueOf!="function"&&typeof t.toString!="function"||isNaN(t)?TDt:yf)(e,t)}var DO=M(()=>{sw();yDt();SDt();EDt();OO();CDt();PDt();Itt();bDt()});function Dtt(e,t){return e=+e,t=+t,function(r){return Math.round(e*(1-r)+t*r)}}var IDt=M(()=>{});function LDt(e){return function t(r){r=+r;function n(i,o){var a=e((i=$a(i)).h,(o=$a(o)).h),s=nd(i.s,o.s),l=nd(i.l,o.l),c=nd(i.opacity,o.opacity);return function(u){return i.h=a(u),i.s=s(u),i.l=l(Math.pow(u,r)),i.opacity=c(u),i+""}}return n.gamma=t,n}(1)}var $6e,cw,kDt=M(()=>{sw();Ltt();$6e=LDt(mDt),cw=LDt(nd)});var uw=M(()=>{DO();OO();IDt();kDt()});function hw(e){return function(){return e}}var zO=M(()=>{});function FO(e){return+e}var Ott=M(()=>{});function pC(e,t){return(t-=e=+e)?function(r){return(r-e)/t}:hw(t)}function K6e(e){return function(t,r){var n=e(t=+t,r=+r);return function(i){return i<=t?0:i>=r?1:n(i)}}}function Z6e(e){return function(t,r){var n=e(t=+t,r=+r);return function(i){return i<=0?t:i>=1?r:n(i)}}}function J6e(e,t,r,n){var i=e[0],o=e[1],a=t[0],s=t[1];return o<i?(i=r(o,i),a=n(s,a)):(i=r(i,o),a=n(a,s)),function(l){return a(i(l))}}function Q6e(e,t,r,n){var i=Math.min(e.length,t.length)-1,o=new Array(i),a=new Array(i),s=-1;for(e[i]<e[0]&&(e=e.slice().reverse(),t=t.slice().reverse());++s<i;)o[s]=r(e[s],e[s+1]),a[s]=n(t[s],t[s+1]);return function(l){var c=df(e,l,1,i)-1;return a[c](o[c](l))}}function Ig(e,t){return t.domain(e.domain()).range(e.range()).interpolate(e.interpolate()).clamp(e.clamp())}function id(e,t){var r=RDt,n=RDt,i=nv,o=!1,a,s,l;function c(){return a=Math.min(r.length,n.length)>2?Q6e:J6e,s=l=null,u}function u(h){return(s||(s=a(r,n,o?K6e(e):e,i)))(+h)}return u.invert=function(h){return(l||(l=a(n,r,pC,o?Z6e(t):t)))(+h)},u.domain=function(h){return arguments.length?(r=rw.call(h,FO),c()):r.slice()},u.range=function(h){return arguments.length?(n=pl.call(h),c()):n.slice()},u.rangeRound=function(h){return n=pl.call(h),i=Dtt,c()},u.clamp=function(h){return arguments.length?(o=!!h,c()):o},u.interpolate=function(h){return arguments.length?(i=h,c()):i},c()}var RDt,dC=M(()=>{mf();uw();Cg();zO();Ott();RDt=[0,1]});function NDt(e){return Math.abs(e=Math.round(e))>=1e21?e.toLocaleString("en").replace(/,/g,""):e.toString(10)}function iv(e,t){if((r=(e=t?e.toExponential(t-1):e.toExponential()).indexOf("e"))<0)return null;var r,n=e.slice(0,r);return[n.length>1?n[0]+n.slice(2):n,+e.slice(r+1)]}var mC=M(()=>{});function vf(e){return e=iv(Math.abs(e)),e?e[1]:NaN}var gC=M(()=>{mC()});function DDt(e,t){return function(r,n){for(var i=r.length,o=[],a=0,s=e[0],l=0;i>0&&s>0&&(l+s+1>n&&(s=Math.max(1,n-l)),o.push(r.substring(i-=s,i+s)),!((l+=s+1)>n));)s=e[a=(a+1)%e.length];return o.reverse().join(t)}}var ODt=M(()=>{});function zDt(e){return function(t){return t.replace(/[0-9]/g,function(r){return e[+r]})}}var FDt=M(()=>{});function Lg(e){if(!(t=tIe.exec(e)))throw new Error("invalid format: "+e);var t;return new BO({fill:t[1],align:t[2],sign:t[3],symbol:t[4],zero:t[5],width:t[6],comma:t[7],precision:t[8]&&t[8].slice(1),trim:t[9],type:t[10]})}function BO(e){this.fill=e.fill===void 0?" ":e.fill+"",this.align=e.align===void 0?">":e.align+"",this.sign=e.sign===void 0?"-":e.sign+"",this.symbol=e.symbol===void 0?"":e.symbol+"",this.zero=!!e.zero,this.width=e.width===void 0?void 0:+e.width,this.comma=!!e.comma,this.precision=e.precision===void 0?void 0:+e.precision,this.trim=!!e.trim,this.type=e.type===void 0?"":e.type+""}var tIe,ztt=M(()=>{tIe=/^(?:(.)?([<>=^]))?([+\-( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?(~)?([a-z%])?$/i;Lg.prototype=BO.prototype;BO.prototype.toString=function(){return this.fill+this.align+this.sign+this.symbol+(this.zero?"0":"")+(this.width===void 0?"":Math.max(1,this.width|0))+(this.comma?",":"")+(this.precision===void 0?"":"."+Math.max(0,this.precision|0))+(this.trim?"~":"")+this.type}});function BDt(e){t:for(var t=e.length,r=1,n=-1,i;r<t;++r)switch(e[r]){case".":n=i=r;break;case"0":n===0&&(n=r),i=r;break;default:if(!+e[r])break t;n>0&&(n=0);break}return n>0?e.slice(0,n)+e.slice(i+1):e}var HDt=M(()=>{});function VDt(e,t){var r=iv(e,t);if(!r)return e+"";var n=r[0],i=r[1],o=i-(Ftt=Math.max(-8,Math.min(8,Math.floor(i/3)))*3)+1,a=n.length;return o===a?n:o>a?n+new Array(o-a+1).join("0"):o>0?n.slice(0,o)+"."+n.slice(o):"0."+new Array(1-o).join("0")+iv(e,Math.max(0,t+o-1))[0]}var Ftt,Btt=M(()=>{mC()});function Htt(e,t){var r=iv(e,t);if(!r)return e+"";var n=r[0],i=r[1];return i<0?"0."+new Array(-i).join("0")+n:n.length>i+1?n.slice(0,i+1)+"."+n.slice(i+1):n+new Array(i-n.length+2).join("0")}var UDt=M(()=>{mC()});var Vtt,qDt=M(()=>{mC();Btt();UDt();Vtt={"%":function(e,t){return(e*100).toFixed(t)},b:function(e){return Math.round(e).toString(2)},c:function(e){return e+""},d:NDt,e:function(e,t){return e.toExponential(t)},f:function(e,t){return e.toFixed(t)},g:function(e,t){return e.toPrecision(t)},o:function(e){return Math.round(e).toString(8)},p:function(e,t){return Htt(e*100,t)},r:Htt,s:VDt,X:function(e){return Math.round(e).toString(16).toUpperCase()},x:function(e){return Math.round(e).toString(16)}}});function Utt(e){return e}var GDt=M(()=>{});function jDt(e){var t=e.grouping===void 0||e.thousands===void 0?Utt:DDt(WDt.call(e.grouping,Number),e.thousands+""),r=e.currency===void 0?"":e.currency[0]+"",n=e.currency===void 0?"":e.currency[1]+"",i=e.decimal===void 0?".":e.decimal+"",o=e.numerals===void 0?Utt:zDt(WDt.call(e.numerals,String)),a=e.percent===void 0?"%":e.percent+"",s=e.minus===void 0?"-":e.minus+"",l=e.nan===void 0?"NaN":e.nan+"";function c(h){h=Lg(h);var f=h.fill,p=h.align,d=h.sign,g=h.symbol,_=h.zero,y=h.width,x=h.comma,b=h.precision,S=h.trim,C=h.type;C==="n"?(x=!0,C="g"):Vtt[C]||(b===void 0&&(b=12),S=!0,C="g"),(_||f==="0"&&p==="=")&&(_=!0,f="0",p="=");var P=g==="$"?r:g==="#"&&/[boxX]/.test(C)?"0"+C.toLowerCase():"",k=g==="$"?n:/[%p]/.test(C)?a:"",O=Vtt[C],D=/[defgprs%]/.test(C);b=b===void 0?6:/[gprs]/.test(C)?Math.max(1,Math.min(21,b)):Math.max(0,Math.min(20,b));function B(I){var L=P,R=k,F,z,U;if(C==="c")R=O(I)+R,I="";else{I=+I;var W=I<0||1/I<0;if(I=isNaN(I)?l:O(Math.abs(I),b),S&&(I=BDt(I)),W&&+I==0&&d!=="+"&&(W=!1),L=(W?d==="("?d:s:d==="-"||d==="("?"":d)+L,R=(C==="s"?YDt[8+Ftt/3]:"")+R+(W&&d==="("?")":""),D){for(F=-1,z=I.length;++F<z;)if(U=I.charCodeAt(F),48>U||U>57){R=(U===46?i+I.slice(F+1):I.slice(F))+R,I=I.slice(0,F);break}}}x&&!_&&(I=t(I,1/0));var Z=L.length+I.length+R.length,rt=Z<y?new Array(y-Z+1).join(f):"";switch(x&&_&&(I=t(rt+I,rt.length?y-R.length:1/0),rt=""),p){case"<":I=L+I+R+rt;break;case"=":I=L+rt+I+R;break;case"^":I=rt.slice(0,Z=rt.length>>1)+L+I+R+rt.slice(Z);break;default:I=rt+L+I+R;break}return o(I)}return B.toString=function(){return h+""},B}function u(h,f){var p=c((h=Lg(h),h.type="f",h)),d=Math.max(-8,Math.min(8,Math.floor(vf(f)/3)))*3,g=Math.pow(10,-d),_=YDt[8+d/3];return function(y){return p(g*y)+_}}return{format:c,formatPrefix:u}}var WDt,YDt,XDt=M(()=>{gC();ODt();FDt();ztt();HDt();qDt();Btt();GDt();WDt=Array.prototype.map,YDt=["y","z","a","f","p","n","\xB5","m","","k","M","G","T","P","E","Z","Y"]});function qtt(e){return HO=jDt(e),fw=HO.format,VO=HO.formatPrefix,HO}var HO,fw,VO,$Dt=M(()=>{XDt();qtt({decimal:".",thousands:",",grouping:[3],currency:["$",""],minus:"-"})});function Gtt(e){return Math.max(0,-vf(Math.abs(e)))}var KDt=M(()=>{gC()});function Wtt(e,t){return Math.max(0,Math.max(-8,Math.min(8,Math.floor(vf(t)/3)))*3-vf(Math.abs(e)))}var ZDt=M(()=>{gC()});function Ytt(e,t){return e=Math.abs(e),t=Math.abs(t)-e,Math.max(0,vf(t)-vf(e))+1}var JDt=M(()=>{gC()});var jtt=M(()=>{$Dt();ztt();KDt();ZDt();JDt()});function QDt(e,t,r){var n=e[0],i=e[e.length-1],o=Zy(n,i,t==null?10:t),a;switch(r=Lg(r==null?",f":r),r.type){case"s":{var s=Math.max(Math.abs(n),Math.abs(i));return r.precision==null&&!isNaN(a=Wtt(o,s))&&(r.precision=a),VO(r,s)}case"":case"e":case"g":case"p":case"r":{r.precision==null&&!isNaN(a=Ytt(o,Math.max(Math.abs(n),Math.abs(i))))&&(r.precision=a-(r.type==="e"));break}case"f":case"%":{r.precision==null&&!isNaN(a=Gtt(o))&&(r.precision=a-(r.type==="%")*2);break}}return fw(r)}var tOt=M(()=>{mf();jtt()});function od(e){var t=e.domain;return e.ticks=function(r){var n=t();return sC(n[0],n[n.length-1],r==null?10:r)},e.tickFormat=function(r,n){return QDt(t(),r,n)},e.nice=function(r){r==null&&(r=10);var n=t(),i=0,o=n.length-1,a=n[i],s=n[o],l;return s<a&&(l=a,a=s,s=l,l=i,i=o,o=l),l=ew(a,s,r),l>0?(a=Math.floor(a/l)*l,s=Math.ceil(s/l)*l,l=ew(a,s,r)):l<0&&(a=Math.ceil(a*l)/l,s=Math.floor(s*l)/l,l=ew(a,s,r)),l>0?(n[i]=Math.floor(a/l)*l,n[o]=Math.ceil(s/l)*l,t(n)):l<0&&(n[i]=Math.ceil(a*l)/l,n[o]=Math.floor(s*l)/l,t(n)),e},e}function UO(){var e=id(pC,yf);return e.copy=function(){return Ig(e,UO())},od(e)}var pw=M(()=>{mf();uw();dC();tOt()});function qO(){var e=[0,1];function t(r){return+r}return t.invert=t,t.domain=t.range=function(r){return arguments.length?(e=rw.call(r,FO),t):e.slice()},t.copy=function(){return qO().domain(e)},od(t)}var eOt=M(()=>{Cg();pw();Ott()});function GO(e,t){e=e.slice();var r=0,n=e.length-1,i=e[r],o=e[n],a;return o<i&&(a=r,r=n,n=a,a=i,i=o,o=a),e[r]=t.floor(i),e[n]=t.ceil(o),e}var Xtt=M(()=>{});function eIe(e,t){return(t=Math.log(t/e))?function(r){return Math.log(r/e)/t}:hw(t)}function rIe(e,t){return e<0?function(r){return-Math.pow(-t,r)*Math.pow(-e,1-r)}:function(r){return Math.pow(t,r)*Math.pow(e,1-r)}}function nIe(e){return isFinite(e)?+("1e"+e):e<0?0:e}function rOt(e){return e===10?nIe:e===Math.E?Math.exp:function(t){return Math.pow(e,t)}}function nOt(e){return e===Math.E?Math.log:e===10&&Math.log10||e===2&&Math.log2||(e=Math.log(e),function(t){return Math.log(t)/e})}function iOt(e){return function(t){return-e(-t)}}function WO(){var e=id(eIe,rIe).domain([1,10]),t=e.domain,r=10,n=nOt(10),i=rOt(10);function o(){return n=nOt(r),i=rOt(r),t()[0]<0&&(n=iOt(n),i=iOt(i)),e}return e.base=function(a){return arguments.length?(r=+a,o()):r},e.domain=function(a){return arguments.length?(t(a),o()):t()},e.ticks=function(a){var s=t(),l=s[0],c=s[s.length-1],u;(u=c<l)&&(h=l,l=c,c=h);var h=n(l),f=n(c),p,d,g,_=a==null?10:+a,y=[];if(!(r%1)&&f-h<_){if(h=Math.round(h)-1,f=Math.round(f)+1,l>0){for(;h<f;++h)for(d=1,p=i(h);d<r;++d)if(g=p*d,!(g<l)){if(g>c)break;y.push(g)}}else for(;h<f;++h)for(d=r-1,p=i(h);d>=1;--d)if(g=p*d,!(g<l)){if(g>c)break;y.push(g)}}else y=sC(h,f,Math.min(f-h,_)).map(i);return u?y.reverse():y},e.tickFormat=function(a,s){if(s==null&&(s=r===10?".0e":","),typeof s!="function"&&(s=fw(s)),a===1/0)return s;a==null&&(a=10);var l=Math.max(1,r*a/e.ticks().length);return function(c){var u=c/i(Math.round(n(c)));return u*r<r-.5&&(u*=r),u<=l?s(c):""}},e.nice=function(){return t(GO(t(),{floor:function(a){return i(Math.floor(n(a)))},ceil:function(a){return i(Math.ceil(n(a)))}}))},e.copy=function(){return Ig(e,WO().base(r))},e}var oOt=M(()=>{mf();jtt();zO();Xtt();dC()});function dw(e,t){return e<0?-Math.pow(-e,t):Math.pow(e,t)}function _C(){var e=1,t=id(n,i),r=t.domain;function n(o,a){return(a=dw(a,e)-(o=dw(o,e)))?function(s){return(dw(s,e)-o)/a}:hw(a)}function i(o,a){return a=dw(a,e)-(o=dw(o,e)),function(s){return dw(o+a*s,1/e)}}return t.exponent=function(o){return arguments.length?(e=+o,r(r())):e},t.copy=function(){return Ig(t,_C().exponent(e))},od(t)}function aOt(){return _C().exponent(.5)}var sOt=M(()=>{zO();pw();dC()});function YO(){var e=[],t=[],r=[];function n(){var o=0,a=Math.max(1,t.length);for(r=new Array(a-1);++o<a;)r[o-1]=lC(e,o/a);return i}function i(o){if(!isNaN(o=+o))return t[df(r,o)]}return i.invertExtent=function(o){var a=t.indexOf(o);return a<0?[NaN,NaN]:[a>0?r[a-1]:e[0],a<r.length?r[a]:e[e.length-1]]},i.domain=function(o){if(!arguments.length)return e.slice();e=[];for(var a=0,s=o.length,l;a<s;++a)l=o[a],l!=null&&!isNaN(l=+l)&&e.push(l);return e.sort(pf),n()},i.range=function(o){return arguments.length?(t=pl.call(o),n()):t.slice()},i.quantiles=function(){return r.slice()},i.copy=function(){return YO().domain(e).range(t)},i}var lOt=M(()=>{mf();Cg()});function jO(){var e=0,t=1,r=1,n=[.5],i=[0,1];function o(s){if(s<=s)return i[df(n,s,0,r)]}function a(){var s=-1;for(n=new Array(r);++s<r;)n[s]=((s+1)*t-(s-r)*e)/(r+1);return o}return o.domain=function(s){return arguments.length?(e=+s[0],t=+s[1],a()):[e,t]},o.range=function(s){return arguments.length?(r=(i=pl.call(s)).length-1,a()):i.slice()},o.invertExtent=function(s){var l=i.indexOf(s);return l<0?[NaN,NaN]:l<1?[e,n[0]]:l>=r?[n[r-1],t]:[n[l-1],n[l]]},o.copy=function(){return jO().domain([e,t]).range(i)},od(o)}var cOt=M(()=>{mf();Cg();pw()});function XO(){var e=[.5],t=[0,1],r=1;function n(i){if(i<=i)return t[df(e,i,0,r)]}return n.domain=function(i){return arguments.length?(e=pl.call(i),r=Math.min(e.length,t.length-1),n):e.slice()},n.range=function(i){return arguments.length?(t=pl.call(i),r=Math.min(e.length,t.length-1),n):t.slice()},n.invertExtent=function(i){var o=t.indexOf(i);return[e[o-1],e[o]]},n.copy=function(){return XO().domain(e).range(t)},n}var uOt=M(()=>{mf();Cg()});function Nr(e,t,r,n){function i(o){return e(o=arguments.length===0?new Date:new Date(+o)),o}return i.floor=function(o){return e(o=new Date(+o)),o},i.ceil=function(o){return e(o=new Date(o-1)),t(o,1),e(o),o},i.round=function(o){var a=i(o),s=i.ceil(o);return o-a<s-o?a:s},i.offset=function(o,a){return t(o=new Date(+o),a==null?1:Math.floor(a)),o},i.range=function(o,a,s){var l=[],c;if(o=i.ceil(o),s=s==null?1:Math.floor(s),!(o<a)||!(s>0))return l;do l.push(c=new Date(+o)),t(o,s),e(o);while(c<o&&o<a);return l},i.filter=function(o){return Nr(function(a){if(a>=a)for(;e(a),!o(a);)a.setTime(a-1)},function(a,s){if(a>=a)if(s<0)for(;++s<=0;)for(;t(a,-1),!o(a););else for(;--s>=0;)for(;t(a,1),!o(a););})},r&&(i.count=function(o,a){return $tt.setTime(+o),Ktt.setTime(+a),e($tt),e(Ktt),Math.floor(r($tt,Ktt))},i.every=function(o){return o=Math.floor(o),!isFinite(o)||!(o>0)?null:o>1?i.filter(n?function(a){return n(a)%o===0}:function(a){return i.count(0,a)%o===0}):i}),i}var $tt,Ktt,Ka=M(()=>{$tt=new Date,Ktt=new Date});var $O,mw,hOt,fOt=M(()=>{Ka();$O=Nr(function(){},function(e,t){e.setTime(+e+t)},function(e,t){return t-e});$O.every=function(e){return e=Math.floor(e),!isFinite(e)||!(e>0)?null:e>1?Nr(function(t){t.setTime(Math.floor(t/e)*e)},function(t,r){t.setTime(+t+r*e)},function(t,r){return(r-t)/e}):$O};mw=$O,hOt=$O.range});var ov,wc,gw,KO,ZO,xf=M(()=>{ov=1e3,wc=6e4,gw=36e5,KO=864e5,ZO=6048e5});var pOt,_w,dOt,mOt=M(()=>{Ka();xf();pOt=Nr(function(e){e.setTime(e-e.getMilliseconds())},function(e,t){e.setTime(+e+t*ov)},function(e,t){return(t-e)/ov},function(e){return e.getUTCSeconds()}),_w=pOt,dOt=pOt.range});var gOt,Ztt,iIe,_Ot=M(()=>{Ka();xf();gOt=Nr(function(e){e.setTime(e-e.getMilliseconds()-e.getSeconds()*ov)},function(e,t){e.setTime(+e+t*wc)},function(e,t){return(t-e)/wc},function(e){return e.getMinutes()}),Ztt=gOt,iIe=gOt.range});var yOt,Jtt,oIe,vOt=M(()=>{Ka();xf();yOt=Nr(function(e){e.setTime(e-e.getMilliseconds()-e.getSeconds()*ov-e.getMinutes()*wc)},function(e,t){e.setTime(+e+t*gw)},function(e,t){return(t-e)/gw},function(e){return e.getHours()}),Jtt=yOt,oIe=yOt.range});var xOt,yw,aIe,bOt=M(()=>{Ka();xf();xOt=Nr(function(e){e.setHours(0,0,0,0)},function(e,t){e.setDate(e.getDate()+t)},function(e,t){return(t-e-(t.getTimezoneOffset()-e.getTimezoneOffset())*wc)/KO},function(e){return e.getDate()-1}),yw=xOt,aIe=xOt.range});function av(e){return Nr(function(t){t.setDate(t.getDate()-(t.getDay()+7-e)%7),t.setHours(0,0,0,0)},function(t,r){t.setDate(t.getDate()+r*7)},function(t,r){return(r-t-(r.getTimezoneOffset()-t.getTimezoneOffset())*wc)/ZO})}var sv,vw,wOt,SOt,kg,MOt,EOt,TOt,sIe,lIe,cIe,uIe,hIe,fIe,COt=M(()=>{Ka();xf();sv=av(0),vw=av(1),wOt=av(2),SOt=av(3),kg=av(4),MOt=av(5),EOt=av(6),TOt=sv.range,sIe=vw.range,lIe=wOt.range,cIe=SOt.range,uIe=kg.range,hIe=MOt.range,fIe=EOt.range});var AOt,Qtt,pIe,POt=M(()=>{Ka();AOt=Nr(function(e){e.setDate(1),e.setHours(0,0,0,0)},function(e,t){e.setMonth(e.getMonth()+t)},function(e,t){return t.getMonth()-e.getMonth()+(t.getFullYear()-e.getFullYear())*12},function(e){return e.getMonth()}),Qtt=AOt,pIe=AOt.range});var tet,ad,dIe,IOt=M(()=>{Ka();tet=Nr(function(e){e.setMonth(0,1),e.setHours(0,0,0,0)},function(e,t){e.setFullYear(e.getFullYear()+t)},function(e,t){return t.getFullYear()-e.getFullYear()},function(e){return e.getFullYear()});tet.every=function(e){return!isFinite(e=Math.floor(e))||!(e>0)?null:Nr(function(t){t.setFullYear(Math.floor(t.getFullYear()/e)*e),t.setMonth(0,1),t.setHours(0,0,0,0)},function(t,r){t.setFullYear(t.getFullYear()+r*e)})};ad=tet,dIe=tet.range});var LOt,eet,mIe,kOt=M(()=>{Ka();xf();LOt=Nr(function(e){e.setUTCSeconds(0,0)},function(e,t){e.setTime(+e+t*wc)},function(e,t){return(t-e)/wc},function(e){return e.getUTCMinutes()}),eet=LOt,mIe=LOt.range});var ROt,ret,gIe,NOt=M(()=>{Ka();xf();ROt=Nr(function(e){e.setUTCMinutes(0,0,0)},function(e,t){e.setTime(+e+t*gw)},function(e,t){return(t-e)/gw},function(e){return e.getUTCHours()}),ret=ROt,gIe=ROt.range});var DOt,xw,_Ie,OOt=M(()=>{Ka();xf();DOt=Nr(function(e){e.setUTCHours(0,0,0,0)},function(e,t){e.setUTCDate(e.getUTCDate()+t)},function(e,t){return(t-e)/KO},function(e){return e.getUTCDate()-1}),xw=DOt,_Ie=DOt.range});function lv(e){return Nr(function(t){t.setUTCDate(t.getUTCDate()-(t.getUTCDay()+7-e)%7),t.setUTCHours(0,0,0,0)},function(t,r){t.setUTCDate(t.getUTCDate()+r*7)},function(t,r){return(r-t)/ZO})}var cv,bw,zOt,FOt,Rg,BOt,HOt,VOt,yIe,vIe,xIe,bIe,wIe,SIe,UOt=M(()=>{Ka();xf();cv=lv(0),bw=lv(1),zOt=lv(2),FOt=lv(3),Rg=lv(4),BOt=lv(5),HOt=lv(6),VOt=cv.range,yIe=bw.range,vIe=zOt.range,xIe=FOt.range,bIe=Rg.range,wIe=BOt.range,SIe=HOt.range});var qOt,net,MIe,GOt=M(()=>{Ka();qOt=Nr(function(e){e.setUTCDate(1),e.setUTCHours(0,0,0,0)},function(e,t){e.setUTCMonth(e.getUTCMonth()+t)},function(e,t){return t.getUTCMonth()-e.getUTCMonth()+(t.getUTCFullYear()-e.getUTCFullYear())*12},function(e){return e.getUTCMonth()}),net=qOt,MIe=qOt.range});var iet,sd,EIe,WOt=M(()=>{Ka();iet=Nr(function(e){e.setUTCMonth(0,1),e.setUTCHours(0,0,0,0)},function(e,t){e.setUTCFullYear(e.getUTCFullYear()+t)},function(e,t){return t.getUTCFullYear()-e.getUTCFullYear()},function(e){return e.getUTCFullYear()});iet.every=function(e){return!isFinite(e=Math.floor(e))||!(e>0)?null:Nr(function(t){t.setUTCFullYear(Math.floor(t.getUTCFullYear()/e)*e),t.setUTCMonth(0,1),t.setUTCHours(0,0,0,0)},function(t,r){t.setUTCFullYear(t.getUTCFullYear()+r*e)})};sd=iet,EIe=iet.range});var JO=M(()=>{fOt();mOt();_Ot();vOt();bOt();COt();POt();IOt();kOt();NOt();OOt();UOt();GOt();WOt()});function oet(e){if(0<=e.y&&e.y<100){var t=new Date(-1,e.m,e.d,e.H,e.M,e.S,e.L);return t.setFullYear(e.y),t}return new Date(e.y,e.m,e.d,e.H,e.M,e.S,e.L)}function aet(e){if(0<=e.y&&e.y<100){var t=new Date(Date.UTC(-1,e.m,e.d,e.H,e.M,e.S,e.L));return t.setUTCFullYear(e.y),t}return new Date(Date.UTC(e.y,e.m,e.d,e.H,e.M,e.S,e.L))}function yC(e,t,r){return{y:e,m:t,d:r,H:0,M:0,S:0,L:0}}function set(e){var t=e.dateTime,r=e.date,n=e.time,i=e.periods,o=e.days,a=e.shortDays,s=e.months,l=e.shortMonths,c=vC(i),u=xC(i),h=vC(o),f=xC(o),p=vC(a),d=xC(a),g=vC(s),_=xC(s),y=vC(l),x=xC(l),b={a:W,A:Z,b:rt,B:ot,c:null,d:ZOt,e:ZOt,f:XIe,g:i9e,G:a9e,H:WIe,I:YIe,j:jIe,L:r7t,m:$Ie,M:KIe,p:st,q:St,Q:t7t,s:e7t,S:ZIe,u:JIe,U:QIe,V:t9e,w:e9e,W:r9e,x:null,X:null,y:n9e,Y:o9e,Z:s9e,"%":QOt},S={a:bt,A:Mt,b:lt,B:Kt,c:null,d:JOt,e:JOt,f:h9e,g:b9e,G:S9e,H:l9e,I:c9e,j:u9e,L:i7t,m:f9e,M:p9e,p:_t,q:ct,Q:t7t,s:e7t,S:d9e,u:m9e,U:g9e,V:_9e,w:y9e,W:v9e,x:null,X:null,y:x9e,Y:w9e,Z:M9e,"%":QOt},C={a:B,A:I,b:L,B:R,c:F,d:$Ot,e:$Ot,f:VIe,g:XOt,G:jOt,H:KOt,I:KOt,j:zIe,L:HIe,m:OIe,M:FIe,p:D,q:DIe,Q:qIe,s:GIe,S:BIe,u:IIe,U:LIe,V:kIe,w:PIe,W:RIe,x:z,X:U,y:XOt,Y:jOt,Z:NIe,"%":UIe};b.x=P(r,b),b.X=P(n,b),b.c=P(t,b),S.x=P(r,S),S.X=P(n,S),S.c=P(t,S);function P(X,et){return function(dt){var q=[],pt=-1,ht=0,wt=X.length,kt,ie,ee;for(dt instanceof Date||(dt=new Date(+dt));++pt<wt;)X.charCodeAt(pt)===37&&(q.push(X.slice(ht,pt)),(ie=YOt[kt=X.charAt(++pt)])!=null?kt=X.charAt(++pt):ie=kt==="e"?" ":"0",(ee=et[kt])&&(kt=ee(dt,ie)),q.push(kt),ht=pt+1);return q.push(X.slice(ht,pt)),q.join("")}}function k(X,et){return function(dt){var q=yC(1900,void 0,1),pt=O(q,X,dt+="",0),ht,wt;if(pt!=dt.length)return null;if("Q"in q)return new Date(q.Q);if("s"in q)return new Date(q.s*1e3+("L"in q?q.L:0));if(et&&!("Z"in q)&&(q.Z=0),"p"in q&&(q.H=q.H%12+q.p*12),q.m===void 0&&(q.m="q"in q?q.q:0),"V"in q){if(q.V<1||q.V>53)return null;"w"in q||(q.w=1),"Z"in q?(ht=aet(yC(q.y,0,1)),wt=ht.getUTCDay(),ht=wt>4||wt===0?bw.ceil(ht):bw(ht),ht=xw.offset(ht,(q.V-1)*7),q.y=ht.getUTCFullYear(),q.m=ht.getUTCMonth(),q.d=ht.getUTCDate()+(q.w+6)%7):(ht=oet(yC(q.y,0,1)),wt=ht.getDay(),ht=wt>4||wt===0?vw.ceil(ht):vw(ht),ht=yw.offset(ht,(q.V-1)*7),q.y=ht.getFullYear(),q.m=ht.getMonth(),q.d=ht.getDate()+(q.w+6)%7)}else("W"in q||"U"in q)&&("w"in q||(q.w="u"in q?q.u%7:"W"in q?1:0),wt="Z"in q?aet(yC(q.y,0,1)).getUTCDay():oet(yC(q.y,0,1)).getDay(),q.m=0,q.d="W"in q?(q.w+6)%7+q.W*7-(wt+5)%7:q.w+q.U*7-(wt+6)%7);return"Z"in q?(q.H+=q.Z/100|0,q.M+=q.Z%100,aet(q)):oet(q)}}function O(X,et,dt,q){for(var pt=0,ht=et.length,wt=dt.length,kt,ie;pt<ht;){if(q>=wt)return-1;if(kt=et.charCodeAt(pt++),kt===37){if(kt=et.charAt(pt++),ie=C[kt in YOt?et.charAt(pt++):kt],!ie||(q=ie(X,dt,q))<0)return-1}else if(kt!=dt.charCodeAt(q++))return-1}return q}function D(X,et,dt){var q=c.exec(et.slice(dt));return q?(X.p=u[q[0].toLowerCase()],dt+q[0].length):-1}function B(X,et,dt){var q=p.exec(et.slice(dt));return q?(X.w=d[q[0].toLowerCase()],dt+q[0].length):-1}function I(X,et,dt){var q=h.exec(et.slice(dt));return q?(X.w=f[q[0].toLowerCase()],dt+q[0].length):-1}function L(X,et,dt){var q=y.exec(et.slice(dt));return q?(X.m=x[q[0].toLowerCase()],dt+q[0].length):-1}function R(X,et,dt){var q=g.exec(et.slice(dt));return q?(X.m=_[q[0].toLowerCase()],dt+q[0].length):-1}function F(X,et,dt){return O(X,t,et,dt)}function z(X,et,dt){return O(X,r,et,dt)}function U(X,et,dt){return O(X,n,et,dt)}function W(X){return a[X.getDay()]}function Z(X){return o[X.getDay()]}function rt(X){return l[X.getMonth()]}function ot(X){return s[X.getMonth()]}function st(X){return i[+(X.getHours()>=12)]}function St(X){return 1+~~(X.getMonth()/3)}function bt(X){return a[X.getUTCDay()]}function Mt(X){return o[X.getUTCDay()]}function lt(X){return l[X.getUTCMonth()]}function Kt(X){return s[X.getUTCMonth()]}function _t(X){return i[+(X.getUTCHours()>=12)]}function ct(X){return 1+~~(X.getUTCMonth()/3)}return{format:function(X){var et=P(X+="",b);return et.toString=function(){return X},et},parse:function(X){var et=k(X+="",!1);return et.toString=function(){return X},et},utcFormat:function(X){var et=P(X+="",S);return et.toString=function(){return X},et},utcParse:function(X){var et=k(X+="",!0);return et.toString=function(){return X},et}}}function Gr(e,t,r){var n=e<0?"-":"",i=(n?-e:e)+"",o=i.length;return n+(o<r?new Array(r-o+1).join(t)+i:i)}function AIe(e){return e.replace(CIe,"\\$&")}function vC(e){return new RegExp("^(?:"+e.map(AIe).join("|")+")","i")}function xC(e){for(var t={},r=-1,n=e.length;++r<n;)t[e[r].toLowerCase()]=r;return t}function PIe(e,t,r){var n=To.exec(t.slice(r,r+1));return n?(e.w=+n[0],r+n[0].length):-1}function IIe(e,t,r){var n=To.exec(t.slice(r,r+1));return n?(e.u=+n[0],r+n[0].length):-1}function LIe(e,t,r){var n=To.exec(t.slice(r,r+2));return n?(e.U=+n[0],r+n[0].length):-1}function kIe(e,t,r){var n=To.exec(t.slice(r,r+2));return n?(e.V=+n[0],r+n[0].length):-1}function RIe(e,t,r){var n=To.exec(t.slice(r,r+2));return n?(e.W=+n[0],r+n[0].length):-1}function jOt(e,t,r){var n=To.exec(t.slice(r,r+4));return n?(e.y=+n[0],r+n[0].length):-1}function XOt(e,t,r){var n=To.exec(t.slice(r,r+2));return n?(e.y=+n[0]+(+n[0]>68?1900:2e3),r+n[0].length):-1}function NIe(e,t,r){var n=/^(Z)|([+-]\d\d)(?::?(\d\d))?/.exec(t.slice(r,r+6));return n?(e.Z=n[1]?0:-(n[2]+(n[3]||"00")),r+n[0].length):-1}function DIe(e,t,r){var n=To.exec(t.slice(r,r+1));return n?(e.q=n[0]*3-3,r+n[0].length):-1}function OIe(e,t,r){var n=To.exec(t.slice(r,r+2));return n?(e.m=n[0]-1,r+n[0].length):-1}function $Ot(e,t,r){var n=To.exec(t.slice(r,r+2));return n?(e.d=+n[0],r+n[0].length):-1}function zIe(e,t,r){var n=To.exec(t.slice(r,r+3));return n?(e.m=0,e.d=+n[0],r+n[0].length):-1}function KOt(e,t,r){var n=To.exec(t.slice(r,r+2));return n?(e.H=+n[0],r+n[0].length):-1}function FIe(e,t,r){var n=To.exec(t.slice(r,r+2));return n?(e.M=+n[0],r+n[0].length):-1}function BIe(e,t,r){var n=To.exec(t.slice(r,r+2));return n?(e.S=+n[0],r+n[0].length):-1}function HIe(e,t,r){var n=To.exec(t.slice(r,r+3));return n?(e.L=+n[0],r+n[0].length):-1}function VIe(e,t,r){var n=To.exec(t.slice(r,r+6));return n?(e.L=Math.floor(n[0]/1e3),r+n[0].length):-1}function UIe(e,t,r){var n=TIe.exec(t.slice(r,r+1));return n?r+n[0].length:-1}function qIe(e,t,r){var n=To.exec(t.slice(r));return n?(e.Q=+n[0],r+n[0].length):-1}function GIe(e,t,r){var n=To.exec(t.slice(r));return n?(e.s=+n[0],r+n[0].length):-1}function ZOt(e,t){return Gr(e.getDate(),t,2)}function WIe(e,t){return Gr(e.getHours(),t,2)}function YIe(e,t){return Gr(e.getHours()%12||12,t,2)}function jIe(e,t){return Gr(1+yw.count(ad(e),e),t,3)}function r7t(e,t){return Gr(e.getMilliseconds(),t,3)}function XIe(e,t){return r7t(e,t)+"000"}function $Ie(e,t){return Gr(e.getMonth()+1,t,2)}function KIe(e,t){return Gr(e.getMinutes(),t,2)}function ZIe(e,t){return Gr(e.getSeconds(),t,2)}function JIe(e){var t=e.getDay();return t===0?7:t}function QIe(e,t){return Gr(sv.count(ad(e)-1,e),t,2)}function n7t(e){var t=e.getDay();return t>=4||t===0?kg(e):kg.ceil(e)}function t9e(e,t){return e=n7t(e),Gr(kg.count(ad(e),e)+(ad(e).getDay()===4),t,2)}function e9e(e){return e.getDay()}function r9e(e,t){return Gr(vw.count(ad(e)-1,e),t,2)}function n9e(e,t){return Gr(e.getFullYear()%100,t,2)}function i9e(e,t){return e=n7t(e),Gr(e.getFullYear()%100,t,2)}function o9e(e,t){return Gr(e.getFullYear()%1e4,t,4)}function a9e(e,t){var r=e.getDay();return e=r>=4||r===0?kg(e):kg.ceil(e),Gr(e.getFullYear()%1e4,t,4)}function s9e(e){var t=e.getTimezoneOffset();return(t>0?"-":(t*=-1,"+"))+Gr(t/60|0,"0",2)+Gr(t%60,"0",2)}function JOt(e,t){return Gr(e.getUTCDate(),t,2)}function l9e(e,t){return Gr(e.getUTCHours(),t,2)}function c9e(e,t){return Gr(e.getUTCHours()%12||12,t,2)}function u9e(e,t){return Gr(1+xw.count(sd(e),e),t,3)}function i7t(e,t){return Gr(e.getUTCMilliseconds(),t,3)}function h9e(e,t){return i7t(e,t)+"000"}function f9e(e,t){return Gr(e.getUTCMonth()+1,t,2)}function p9e(e,t){return Gr(e.getUTCMinutes(),t,2)}function d9e(e,t){return Gr(e.getUTCSeconds(),t,2)}function m9e(e){var t=e.getUTCDay();return t===0?7:t}function g9e(e,t){return Gr(cv.count(sd(e)-1,e),t,2)}function o7t(e){var t=e.getUTCDay();return t>=4||t===0?Rg(e):Rg.ceil(e)}function _9e(e,t){return e=o7t(e),Gr(Rg.count(sd(e),e)+(sd(e).getUTCDay()===4),t,2)}function y9e(e){return e.getUTCDay()}function v9e(e,t){return Gr(bw.count(sd(e)-1,e),t,2)}function x9e(e,t){return Gr(e.getUTCFullYear()%100,t,2)}function b9e(e,t){return e=o7t(e),Gr(e.getUTCFullYear()%100,t,2)}function w9e(e,t){return Gr(e.getUTCFullYear()%1e4,t,4)}function S9e(e,t){var r=e.getUTCDay();return e=r>=4||r===0?Rg(e):Rg.ceil(e),Gr(e.getUTCFullYear()%1e4,t,4)}function M9e(){return"+0000"}function QOt(){return"%"}function t7t(e){return+e}function e7t(e){return Math.floor(+e/1e3)}var YOt,To,TIe,CIe,a7t=M(()=>{JO();YOt={"-":"",_:" ",0:"0"},To=/^\s*\d+/,TIe=/^%/,CIe=/[\\^$*+?|[\]().{}]/g});function cet(e){return ww=set(e),QO=ww.format,s7t=ww.parse,t7=ww.utcFormat,l7t=ww.utcParse,ww}var ww,QO,s7t,t7,l7t,c7t=M(()=>{a7t();cet({dateTime:"%x, %X",date:"%-m/%-d/%Y",time:"%-I:%M:%S %p",periods:["AM","PM"],days:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],shortDays:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],months:["January","February","March","April","May","June","July","August","September","October","November","December"],shortMonths:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]})});var uet=M(()=>{c7t()});function T9e(e){return new Date(e)}function C9e(e){return e instanceof Date?+e:+new Date(+e)}function e7(e,t,r,n,i,o,a,s,l){var c=id(pC,yf),u=c.invert,h=c.domain,f=l(".%L"),p=l(":%S"),d=l("%I:%M"),g=l("%I %p"),_=l("%a %d"),y=l("%b %d"),x=l("%B"),b=l("%Y"),S=[[a,1,bC],[a,5,5*bC],[a,15,15*bC],[a,30,30*bC],[o,1,wC],[o,5,5*wC],[o,15,15*wC],[o,30,30*wC],[i,1,SC],[i,3,3*SC],[i,6,6*SC],[i,12,12*SC],[n,1,MC],[n,2,2*MC],[r,1,E9e],[t,1,u7t],[t,3,3*u7t],[e,1,het]];function C(k){return(a(k)<k?f:o(k)<k?p:i(k)<k?d:n(k)<k?g:t(k)<k?r(k)<k?_:y:e(k)<k?x:b)(k)}function P(k,O,D,B){if(k==null&&(k=10),typeof k=="number"){var I=Math.abs(D-O)/k,L=aC(function(R){return R[2]}).right(S,I);L===S.length?(B=Zy(O/het,D/het,k),k=e):L?(L=S[I/S[L-1][2]<S[L][2]/I?L-1:L],B=L[1],k=L[0]):(B=Math.max(Zy(O,D,k),1),k=s)}return B==null?k:k.every(B)}return c.invert=function(k){return new Date(u(k))},c.domain=function(k){return arguments.length?h(rw.call(k,C9e)):h().map(T9e)},c.ticks=function(k,O){var D=h(),B=D[0],I=D[D.length-1],L=I<B,R;return L&&(R=B,B=I,I=R),R=P(k,B,I,O),R=R?R.range(B,I+1):[],L?R.reverse():R},c.tickFormat=function(k,O){return O==null?C:l(O)},c.nice=function(k,O){var D=h();return(k=P(k,D[0],D[D.length-1],O))?h(GO(D,k)):c},c.copy=function(){return Ig(c,e7(e,t,r,n,i,o,a,s,l))},c}function h7t(){return e7(ad,Qtt,sv,yw,Jtt,Ztt,_w,mw,QO).domain([new Date(2e3,0,1),new Date(2e3,0,2)])}var bC,wC,SC,MC,E9e,u7t,het,fet=M(()=>{mf();uw();JO();uet();Cg();dC();Xtt();bC=1e3,wC=bC*60,SC=wC*60,MC=SC*24,E9e=MC*7,u7t=MC*30,het=MC*365});function f7t(){return e7(sd,net,cv,xw,ret,eet,_w,mw,t7).domain([Date.UTC(2e3,0,1),Date.UTC(2e3,0,2)])}var p7t=M(()=>{fet();uet();JO()});function dl(e){return e.match(/.{6}/g).map(function(t){return"#"+t})}var Sw=M(()=>{});var d7t,m7t=M(()=>{Sw();d7t=dl("1f77b4ff7f0e2ca02cd627289467bd8c564be377c27f7f7fbcbd2217becf")});var g7t,_7t=M(()=>{Sw();g7t=dl("393b795254a36b6ecf9c9ede6379398ca252b5cf6bcedb9c8c6d31bd9e39e7ba52e7cb94843c39ad494ad6616be7969c7b4173a55194ce6dbdde9ed6")});var y7t,v7t=M(()=>{Sw();y7t=dl("3182bd6baed69ecae1c6dbefe6550dfd8d3cfdae6bfdd0a231a35474c476a1d99bc7e9c0756bb19e9ac8bcbddcdadaeb636363969696bdbdbdd9d9d9")});var x7t,b7t=M(()=>{Sw();x7t=dl("1f77b4aec7e8ff7f0effbb782ca02c98df8ad62728ff98969467bdc5b0d58c564bc49c94e377c2f7b6d27f7f7fc7c7c7bcbd22dbdb8d17becf9edae5")});var w7t,S7t=M(()=>{sw();uw();w7t=cw($a(300,.5,0),$a(-240,.5,1))});function T7t(e){(e<0||e>1)&&(e-=Math.floor(e));var t=Math.abs(e-.5);return r7.h=360*e-100,r7.s=1.5-1.5*t,r7.l=.8-.9*t,r7+""}var M7t,E7t,r7,C7t=M(()=>{sw();uw();M7t=cw($a(-100,.75,.35),$a(80,1.5,.8)),E7t=cw($a(260,.75,.35),$a(80,1.5,.8)),r7=$a()});function n7(e){var t=e.length;return function(r){return e[Math.max(0,Math.min(t-1,Math.floor(r*t)))]}}var A7t,P7t,I7t,L7t,k7t=M(()=>{Sw();A7t=n7(dl("44015444025645045745055946075a46085c460a5d460b5e470d60470e6147106347116447136548146748166848176948186a481a6c481b6d481c6e481d6f481f70482071482173482374482475482576482677482878482979472a7a472c7a472d7b472e7c472f7d46307e46327e46337f463480453581453781453882443983443a83443b84433d84433e85423f854240864241864142874144874045884046883f47883f48893e49893e4a893e4c8a3d4d8a3d4e8a3c4f8a3c508b3b518b3b528b3a538b3a548c39558c39568c38588c38598c375a8c375b8d365c8d365d8d355e8d355f8d34608d34618d33628d33638d32648e32658e31668e31678e31688e30698e306a8e2f6b8e2f6c8e2e6d8e2e6e8e2e6f8e2d708e2d718e2c718e2c728e2c738e2b748e2b758e2a768e2a778e2a788e29798e297a8e297b8e287c8e287d8e277e8e277f8e27808e26818e26828e26828e25838e25848e25858e24868e24878e23888e23898e238a8d228b8d228c8d228d8d218e8d218f8d21908d21918c20928c20928c20938c1f948c1f958b1f968b1f978b1f988b1f998a1f9a8a1e9b8a1e9c891e9d891f9e891f9f881fa0881fa1881fa1871fa28720a38620a48621a58521a68522a78522a88423a98324aa8325ab8225ac8226ad8127ad8128ae8029af7f2ab07f2cb17e2db27d2eb37c2fb47c31b57b32b67a34b67935b77937b87838b9773aba763bbb753dbc743fbc7340bd7242be7144bf7046c06f48c16e4ac16d4cc26c4ec36b50c46a52c56954c56856c66758c7655ac8645cc8635ec96260ca6063cb5f65cb5e67cc5c69cd5b6ccd5a6ece5870cf5773d05675d05477d1537ad1517cd2507fd34e81d34d84d44b86d54989d5488bd6468ed64590d74393d74195d84098d83e9bd93c9dd93ba0da39a2da37a5db36a8db34aadc32addc30b0dd2fb2dd2db5de2bb8de29bade28bddf26c0df25c2df23c5e021c8e020cae11fcde11dd0e11cd2e21bd5e21ad8e219dae319dde318dfe318e2e418e5e419e7e419eae51aece51befe51cf1e51df4e61ef6e620f8e621fbe723fde725")),P7t=n7(dl("00000401000501010601010802010902020b02020d03030f03031204041405041606051806051a07061c08071e0907200a08220b09240c09260d0a290e0b2b100b2d110c2f120d31130d34140e36150e38160f3b180f3d19103f1a10421c10441d11471e114920114b21114e22115024125325125527125829115a2a115c2c115f2d11612f116331116533106734106936106b38106c390f6e3b0f703d0f713f0f72400f74420f75440f764510774710784910784a10794c117a4e117b4f127b51127c52137c54137d56147d57157e59157e5a167e5c167f5d177f5f187f601880621980641a80651a80671b80681c816a1c816b1d816d1d816e1e81701f81721f817320817521817621817822817922827b23827c23827e24828025828125818326818426818627818827818928818b29818c29818e2a81902a81912b81932b80942c80962c80982d80992d809b2e7f9c2e7f9e2f7fa02f7fa1307ea3307ea5317ea6317da8327daa337dab337cad347cae347bb0357bb2357bb3367ab5367ab73779b83779ba3878bc3978bd3977bf3a77c03a76c23b75c43c75c53c74c73d73c83e73ca3e72cc3f71cd4071cf4070d0416fd2426fd3436ed5446dd6456cd8456cd9466bdb476adc4869de4968df4a68e04c67e24d66e34e65e44f64e55064e75263e85362e95462ea5661eb5760ec5860ed5a5fee5b5eef5d5ef05f5ef1605df2625df2645cf3655cf4675cf4695cf56b5cf66c5cf66e5cf7705cf7725cf8745cf8765cf9785df9795df97b5dfa7d5efa7f5efa815ffb835ffb8560fb8761fc8961fc8a62fc8c63fc8e64fc9065fd9266fd9467fd9668fd9869fd9a6afd9b6bfe9d6cfe9f6dfea16efea36ffea571fea772fea973feaa74feac76feae77feb078feb27afeb47bfeb67cfeb77efeb97ffebb81febd82febf84fec185fec287fec488fec68afec88cfeca8dfecc8ffecd90fecf92fed194fed395fed597fed799fed89afdda9cfddc9efddea0fde0a1fde2a3fde3a5fde5a7fde7a9fde9aafdebacfcecaefceeb0fcf0b2fcf2b4fcf4b6fcf6b8fcf7b9fcf9bbfcfbbdfcfdbf")),I7t=n7(dl("00000401000501010601010802010a02020c02020e03021004031204031405041706041907051b08051d09061f0a07220b07240c08260d08290e092b10092d110a30120a32140b34150b37160b39180c3c190c3e1b0c411c0c431e0c451f0c48210c4a230c4c240c4f260c51280b53290b552b0b572d0b592f0a5b310a5c320a5e340a5f3609613809623909633b09643d09653e0966400a67420a68440a68450a69470b6a490b6a4a0c6b4c0c6b4d0d6c4f0d6c510e6c520e6d540f6d550f6d57106e59106e5a116e5c126e5d126e5f136e61136e62146e64156e65156e67166e69166e6a176e6c186e6d186e6f196e71196e721a6e741a6e751b6e771c6d781c6d7a1d6d7c1d6d7d1e6d7f1e6c801f6c82206c84206b85216b87216b88226a8a226a8c23698d23698f24699025689225689326679526679727669827669a28659b29649d29649f2a63a02a63a22b62a32c61a52c60a62d60a82e5fa92e5eab2f5ead305dae305cb0315bb1325ab3325ab43359b63458b73557b93556ba3655bc3754bd3853bf3952c03a51c13a50c33b4fc43c4ec63d4dc73e4cc83f4bca404acb4149cc4248ce4347cf4446d04545d24644d34743d44842d54a41d74b3fd84c3ed94d3dda4e3cdb503bdd513ade5238df5337e05536e15635e25734e35933e45a31e55c30e65d2fe75e2ee8602de9612bea632aeb6429eb6628ec6726ed6925ee6a24ef6c23ef6e21f06f20f1711ff1731df2741cf3761bf37819f47918f57b17f57d15f67e14f68013f78212f78410f8850ff8870ef8890cf98b0bf98c0af98e09fa9008fa9207fa9407fb9606fb9706fb9906fb9b06fb9d07fc9f07fca108fca309fca50afca60cfca80dfcaa0ffcac11fcae12fcb014fcb216fcb418fbb61afbb81dfbba1ffbbc21fbbe23fac026fac228fac42afac62df9c72ff9c932f9cb35f8cd37f8cf3af7d13df7d340f6d543f6d746f5d949f5db4cf4dd4ff4df53f4e156f3e35af3e55df2e661f2e865f2ea69f1ec6df1ed71f1ef75f1f179f2f27df2f482f3f586f3f68af4f88ef5f992f6fa96f8fb9af9fc9dfafda1fcffa4")),L7t=n7(dl("0d088710078813078916078a19068c1b068d1d068e20068f2206902406912605912805922a05932c05942e05952f059631059733059735049837049938049a3a049a3c049b3e049c3f049c41049d43039e44039e46039f48039f4903a04b03a14c02a14e02a25002a25102a35302a35502a45601a45801a45901a55b01a55c01a65e01a66001a66100a76300a76400a76600a76700a86900a86a00a86c00a86e00a86f00a87100a87201a87401a87501a87701a87801a87a02a87b02a87d03a87e03a88004a88104a78305a78405a78606a68707a68808a68a09a58b0aa58d0ba58e0ca48f0da4910ea3920fa39410a29511a19613a19814a099159f9a169f9c179e9d189d9e199da01a9ca11b9ba21d9aa31e9aa51f99a62098a72197a82296aa2395ab2494ac2694ad2793ae2892b02991b12a90b22b8fb32c8eb42e8db52f8cb6308bb7318ab83289ba3388bb3488bc3587bd3786be3885bf3984c03a83c13b82c23c81c33d80c43e7fc5407ec6417dc7427cc8437bc9447aca457acb4679cc4778cc4977cd4a76ce4b75cf4c74d04d73d14e72d24f71d35171d45270d5536fd5546ed6556dd7566cd8576bd9586ada5a6ada5b69db5c68dc5d67dd5e66de5f65de6164df6263e06363e16462e26561e26660e3685fe4695ee56a5de56b5de66c5ce76e5be76f5ae87059e97158e97257ea7457eb7556eb7655ec7754ed7953ed7a52ee7b51ef7c51ef7e50f07f4ff0804ef1814df1834cf2844bf3854bf3874af48849f48948f58b47f58c46f68d45f68f44f79044f79143f79342f89441f89540f9973ff9983ef99a3efa9b3dfa9c3cfa9e3bfb9f3afba139fba238fca338fca537fca636fca835fca934fdab33fdac33fdae32fdaf31fdb130fdb22ffdb42ffdb52efeb72dfeb82cfeba2cfebb2bfebd2afebe2afec029fdc229fdc328fdc527fdc627fdc827fdca26fdcb26fccd25fcce25fcd025fcd225fbd324fbd524fbd724fad824fada24f9dc24f9dd25f8df25f8e125f7e225f7e425f6e626f6e826f5e926f5eb27f4ed27f3ee27f3f027f2f227f1f426f1f525f0f724f0f921"))});function i7(e){var t=0,r=1,n=!1;function i(o){var a=(o-t)/(r-t);return e(n?Math.max(0,Math.min(1,a)):a)}return i.domain=function(o){return arguments.length?(t=+o[0],r=+o[1],i):[t,r]},i.clamp=function(o){return arguments.length?(n=!!o,i):n},i.interpolator=function(o){return arguments.length?(e=o,i):e},i.copy=function(){return i7(e).domain([t,r]).clamp(n)},od(i)}var R7t=M(()=>{pw()});var N7t=M(()=>{jNt();eOt();pw();oOt();xtt();sOt();lOt();cOt();uOt();fet();p7t();m7t();_7t();v7t();b7t();S7t();C7t();k7t();R7t()});var o7,EC,a7=M(()=>{o7="http://www.w3.org/1999/xhtml",EC={svg:"http://www.w3.org/2000/svg",xhtml:o7,xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/"}});function Mw(e){var t=e+="",r=t.indexOf(":");return r>=0&&(t=e.slice(0,r))!=="xmlns"&&(e=e.slice(r+1)),EC.hasOwnProperty(t)?{space:EC[t],local:e}:e}var s7=M(()=>{a7()});function A9e(e){return function(){var t=this.ownerDocument,r=this.namespaceURI;return r===o7&&t.documentElement.namespaceURI===o7?t.createElement(e):t.createElementNS(r,e)}}function P9e(e){return function(){return this.ownerDocument.createElementNS(e.space,e.local)}}function Ng(e){var t=Mw(e);return(t.local?P9e:A9e)(t)}var TC=M(()=>{s7();a7()});function I9e(){}function Ew(e){return e==null?I9e:function(){return this.querySelector(e)}}var l7=M(()=>{});function D7t(e){typeof e!="function"&&(e=Ew(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=new Array(a),l,c,u=0;u<a;++u)(l=o[u])&&(c=e.call(l,l.__data__,u,o))&&("__data__"in l&&(c.__data__=l.__data__),s[u]=c);return new Bn(n,this._parents)}var O7t=M(()=>{Sc();l7()});function L9e(){return[]}function c7(e){return e==null?L9e:function(){return this.querySelectorAll(e)}}var pet=M(()=>{});function z7t(e){typeof e!="function"&&(e=c7(e));for(var t=this._groups,r=t.length,n=[],i=[],o=0;o<r;++o)for(var a=t[o],s=a.length,l,c=0;c<s;++c)(l=a[c])&&(n.push(e.call(l,l.__data__,c,a)),i.push(l));return new Bn(n,i)}var F7t=M(()=>{Sc();pet()});var H7t,Tw,B7t,u7,det=M(()=>{H7t=function(e){return function(){return this.matches(e)}};typeof document!="undefined"&&(Tw=document.documentElement,Tw.matches||(B7t=Tw.webkitMatchesSelector||Tw.msMatchesSelector||Tw.mozMatchesSelector||Tw.oMatchesSelector,H7t=function(e){return function(){return B7t.call(this,e)}}));u7=H7t});function V7t(e){typeof e!="function"&&(e=u7(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=[],l,c=0;c<a;++c)(l=o[c])&&e.call(l,l.__data__,c,o)&&s.push(l);return new Bn(n,this._parents)}var U7t=M(()=>{Sc();det()});function h7(e){return new Array(e.length)}var met=M(()=>{});function q7t(){return new Bn(this._enter||this._groups.map(h7),this._parents)}function CC(e,t){this.ownerDocument=e.ownerDocument,this.namespaceURI=e.namespaceURI,this._next=null,this._parent=e,this.__data__=t}var get=M(()=>{met();Sc();CC.prototype={constructor:CC,appendChild:function(e){return this._parent.insertBefore(e,this._next)},insertBefore:function(e,t){return this._parent.insertBefore(e,t)},querySelector:function(e){return this._parent.querySelector(e)},querySelectorAll:function(e){return this._parent.querySelectorAll(e)}}});function G7t(e){return function(){return e}}var W7t=M(()=>{});function k9e(e,t,r,n,i,o){for(var a=0,s,l=t.length,c=o.length;a<c;++a)(s=t[a])?(s.__data__=o[a],n[a]=s):r[a]=new CC(e,o[a]);for(;a<l;++a)(s=t[a])&&(i[a]=s)}function R9e(e,t,r,n,i,o,a){var s,l,c={},u=t.length,h=o.length,f=new Array(u),p;for(s=0;s<u;++s)(l=t[s])&&(f[s]=p=Y7t+a.call(l,l.__data__,s,t),p in c?i[s]=l:c[p]=l);for(s=0;s<h;++s)p=Y7t+a.call(e,o[s],s,o),(l=c[p])?(n[s]=l,l.__data__=o[s],c[p]=null):r[s]=new CC(e,o[s]);for(s=0;s<u;++s)(l=t[s])&&c[f[s]]===l&&(i[s]=l)}function j7t(e,t){if(!e)return p=new Array(this.size()),c=-1,this.each(function(P){p[++c]=P}),p;var r=t?R9e:k9e,n=this._parents,i=this._groups;typeof e!="function"&&(e=G7t(e));for(var o=i.length,a=new Array(o),s=new Array(o),l=new Array(o),c=0;c<o;++c){var u=n[c],h=i[c],f=h.length,p=e.call(u,u&&u.__data__,c,n),d=p.length,g=s[c]=new Array(d),_=a[c]=new Array(d),y=l[c]=new Array(f);r(u,h,g,_,y,p,t);for(var x=0,b=0,S,C;x<d;++x)if(S=g[x]){for(x>=b&&(b=x+1);!(C=_[b])&&++b<d;);S._next=C||null}}return a=new Bn(a,n),a._enter=s,a._exit=l,a}var Y7t,X7t=M(()=>{Sc();get();W7t();Y7t="$"});function $7t(){return new Bn(this._exit||this._groups.map(h7),this._parents)}var K7t=M(()=>{met();Sc()});function Z7t(e){for(var t=this._groups,r=e._groups,n=t.length,i=r.length,o=Math.min(n,i),a=new Array(n),s=0;s<o;++s)for(var l=t[s],c=r[s],u=l.length,h=a[s]=new Array(u),f,p=0;p<u;++p)(f=l[p]||c[p])&&(h[p]=f);for(;s<n;++s)a[s]=t[s];return new Bn(a,this._parents)}var J7t=M(()=>{Sc()});function Q7t(){for(var e=this._groups,t=-1,r=e.length;++t<r;)for(var n=e[t],i=n.length-1,o=n[i],a;--i>=0;)(a=n[i])&&(o&&o!==a.nextSibling&&o.parentNode.insertBefore(a,o),o=a);return this}var tzt=M(()=>{});function ezt(e){e||(e=N9e);function t(h,f){return h&&f?e(h.__data__,f.__data__):!h-!f}for(var r=this._groups,n=r.length,i=new Array(n),o=0;o<n;++o){for(var a=r[o],s=a.length,l=i[o]=new Array(s),c,u=0;u<s;++u)(c=a[u])&&(l[u]=c);l.sort(t)}return new Bn(i,this._parents).order()}function N9e(e,t){return e<t?-1:e>t?1:e>=t?0:NaN}var rzt=M(()=>{Sc()});function nzt(){var e=arguments[0];return arguments[0]=this,e.apply(null,arguments),this}var izt=M(()=>{});function ozt(){var e=new Array(this.size()),t=-1;return this.each(function(){e[++t]=this}),e}var azt=M(()=>{});function szt(){for(var e=this._groups,t=0,r=e.length;t<r;++t)for(var n=e[t],i=0,o=n.length;i<o;++i){var a=n[i];if(a)return a}return null}var lzt=M(()=>{});function czt(){var e=0;return this.each(function(){++e}),e}var uzt=M(()=>{});function hzt(){return!this.node()}var fzt=M(()=>{});function pzt(e){for(var t=this._groups,r=0,n=t.length;r<n;++r)for(var i=t[r],o=0,a=i.length,s;o<a;++o)(s=i[o])&&e.call(s,s.__data__,o,i);return this}var dzt=M(()=>{});function D9e(e){return function(){this.removeAttribute(e)}}function O9e(e){return function(){this.removeAttributeNS(e.space,e.local)}}function z9e(e,t){return function(){this.setAttribute(e,t)}}function F9e(e,t){return function(){this.setAttributeNS(e.space,e.local,t)}}function B9e(e,t){return function(){var r=t.apply(this,arguments);r==null?this.removeAttribute(e):this.setAttribute(e,r)}}function H9e(e,t){return function(){var r=t.apply(this,arguments);r==null?this.removeAttributeNS(e.space,e.local):this.setAttributeNS(e.space,e.local,r)}}function mzt(e,t){var r=Mw(e);if(arguments.length<2){var n=this.node();return r.local?n.getAttributeNS(r.space,r.local):n.getAttribute(r)}return this.each((t==null?r.local?O9e:D9e:typeof t=="function"?r.local?H9e:B9e:r.local?F9e:z9e)(r,t))}var gzt=M(()=>{s7()});function Cw(e){return e.ownerDocument&&e.ownerDocument.defaultView||e.document&&e||e.defaultView}var f7=M(()=>{});function V9e(e){return function(){this.style.removeProperty(e)}}function U9e(e,t,r){return function(){this.style.setProperty(e,t,r)}}function q9e(e,t,r){return function(){var n=t.apply(this,arguments);n==null?this.style.removeProperty(e):this.style.setProperty(e,n,r)}}function _zt(e,t,r){return arguments.length>1?this.each((t==null?V9e:typeof t=="function"?q9e:U9e)(e,t,r==null?"":r)):_et(this.node(),e)}function _et(e,t){return e.style.getPropertyValue(t)||Cw(e).getComputedStyle(e,null).getPropertyValue(t)}var yet=M(()=>{f7()});function G9e(e){return function(){delete this[e]}}function W9e(e,t){return function(){this[e]=t}}function Y9e(e,t){return function(){var r=t.apply(this,arguments);r==null?delete this[e]:this[e]=r}}function yzt(e,t){return arguments.length>1?this.each((t==null?G9e:typeof t=="function"?Y9e:W9e)(e,t)):this.node()[e]}var vzt=M(()=>{});function xzt(e){return e.trim().split(/^|\s+/)}function vet(e){return e.classList||new bzt(e)}function bzt(e){this._node=e,this._names=xzt(e.getAttribute("class")||"")}function wzt(e,t){for(var r=vet(e),n=-1,i=t.length;++n<i;)r.add(t[n])}function Szt(e,t){for(var r=vet(e),n=-1,i=t.length;++n<i;)r.remove(t[n])}function j9e(e){return function(){wzt(this,e)}}function X9e(e){return function(){Szt(this,e)}}function $9e(e,t){return function(){(t.apply(this,arguments)?wzt:Szt)(this,e)}}function Mzt(e,t){var r=xzt(e+"");if(arguments.length<2){for(var n=vet(this.node()),i=-1,o=r.length;++i<o;)if(!n.contains(r[i]))return!1;return!0}return this.each((typeof t=="function"?$9e:t?j9e:X9e)(r,t))}var Ezt=M(()=>{bzt.prototype={add:function(e){var t=this._names.indexOf(e);t<0&&(this._names.push(e),this._node.setAttribute("class",this._names.join(" ")))},remove:function(e){var t=this._names.indexOf(e);t>=0&&(this._names.splice(t,1),this._node.setAttribute("class",this._names.join(" ")))},contains:function(e){return this._names.indexOf(e)>=0}}});function K9e(){this.textContent=""}function Z9e(e){return function(){this.textContent=e}}function J9e(e){return function(){var t=e.apply(this,arguments);this.textContent=t==null?"":t}}function Tzt(e){return arguments.length?this.each(e==null?K9e:(typeof e=="function"?J9e:Z9e)(e)):this.node().textContent}var Czt=M(()=>{});function Q9e(){this.innerHTML=""}function tLe(e){return function(){this.innerHTML=e}}function eLe(e){return function(){var t=e.apply(this,arguments);this.innerHTML=t==null?"":t}}function Azt(e){return arguments.length?this.each(e==null?Q9e:(typeof e=="function"?eLe:tLe)(e)):this.node().innerHTML}var Pzt=M(()=>{});function rLe(){this.nextSibling&&this.parentNode.appendChild(this)}function Izt(){return this.each(rLe)}var Lzt=M(()=>{});function nLe(){this.previousSibling&&this.parentNode.insertBefore(this,this.parentNode.firstChild)}function kzt(){return this.each(nLe)}var Rzt=M(()=>{});function Nzt(e){var t=typeof e=="function"?e:Ng(e);return this.select(function(){return this.appendChild(t.apply(this,arguments))})}var Dzt=M(()=>{TC()});function iLe(){return null}function Ozt(e,t){var r=typeof e=="function"?e:Ng(e),n=t==null?iLe:typeof t=="function"?t:Ew(t);return this.select(function(){return this.insertBefore(r.apply(this,arguments),n.apply(this,arguments)||null)})}var zzt=M(()=>{TC();l7()});function oLe(){var e=this.parentNode;e&&e.removeChild(this)}function Fzt(){return this.each(oLe)}var Bzt=M(()=>{});function aLe(){return this.parentNode.insertBefore(this.cloneNode(!1),this.nextSibling)}function sLe(){return this.parentNode.insertBefore(this.cloneNode(!0),this.nextSibling)}function Hzt(e){return this.select(e?sLe:aLe)}var Vzt=M(()=>{});function Uzt(e){return arguments.length?this.property("__data__",e):this.node().__data__}var qzt=M(()=>{});function lLe(e,t,r){return e=Yzt(e,t,r),function(n){var i=n.relatedTarget;(!i||i!==this&&!(i.compareDocumentPosition(this)&8))&&e.call(this,n)}}function Yzt(e,t,r){return function(n){var i=Pu;Pu=n;try{e.call(this,this.__data__,t,r)}finally{Pu=i}}}function cLe(e){return e.trim().split(/^|\s+/).map(function(t){var r="",n=t.indexOf(".");return n>=0&&(r=t.slice(n+1),t=t.slice(0,n)),{type:t,name:r}})}function uLe(e){return function(){var t=this.__on;if(!!t){for(var r=0,n=-1,i=t.length,o;r<i;++r)o=t[r],(!e.type||o.type===e.type)&&o.name===e.name?this.removeEventListener(o.type,o.listener,o.capture):t[++n]=o;++n?t.length=n:delete this.__on}}}function hLe(e,t,r){var n=Wzt.hasOwnProperty(e.type)?lLe:Yzt;return function(i,o,a){var s=this.__on,l,c=n(t,o,a);if(s){for(var u=0,h=s.length;u<h;++u)if((l=s[u]).type===e.type&&l.name===e.name){this.removeEventListener(l.type,l.listener,l.capture),this.addEventListener(l.type,l.listener=c,l.capture=r),l.value=t;return}}this.addEventListener(e.type,c,r),l={type:e.type,name:e.name,value:t,listener:c,capture:r},s?s.push(l):this.__on=[l]}}function jzt(e,t,r){var n=cLe(e+""),i,o=n.length,a;if(arguments.length<2){var s=this.node().__on;if(s){for(var l=0,c=s.length,u;l<c;++l)for(i=0,u=s[l];i<o;++i)if((a=n[i]).type===u.type&&a.name===u.name)return u.value}return}for(s=t?hLe:uLe,r==null&&(r=!1),i=0;i<o;++i)this.each(s(n[i],t,r));return this}function Xzt(e,t,r,n){var i=Pu;e.sourceEvent=Pu,Pu=e;try{return t.apply(r,n)}finally{Pu=i}}var Wzt,Pu,Gzt,p7=M(()=>{Wzt={},Pu=null;typeof document!="undefined"&&(Gzt=document.documentElement,"onmouseenter"in Gzt||(Wzt={mouseenter:"mouseover",mouseleave:"mouseout"}))});function $zt(e,t,r){var n=Cw(e),i=n.CustomEvent;typeof i=="function"?i=new i(t,r):(i=n.document.createEvent("Event"),r?(i.initEvent(t,r.bubbles,r.cancelable),i.detail=r.detail):i.initEvent(t,!1,!1)),e.dispatchEvent(i)}function fLe(e,t){return function(){return $zt(this,e,t)}}function pLe(e,t){return function(){return $zt(this,e,t.apply(this,arguments))}}function Kzt(e,t){return this.each((typeof t=="function"?pLe:fLe)(e,t))}var Zzt=M(()=>{f7()});function Bn(e,t){this._groups=e,this._parents=t}function Jzt(){return new Bn([[document.documentElement]],AC)}var AC,Qzt,Sc=M(()=>{O7t();F7t();U7t();X7t();get();K7t();J7t();tzt();rzt();izt();azt();lzt();uzt();fzt();dzt();gzt();yet();vzt();Ezt();Czt();Pzt();Lzt();Rzt();Dzt();zzt();Bzt();Vzt();qzt();p7();Zzt();AC=[null];Bn.prototype=Jzt.prototype={constructor:Bn,select:D7t,selectAll:z7t,filter:V7t,data:j7t,enter:q7t,exit:$7t,merge:Z7t,order:Q7t,sort:ezt,call:nzt,nodes:ozt,node:szt,size:czt,empty:hzt,each:pzt,attr:mzt,style:_zt,property:yzt,classed:Mzt,text:Tzt,html:Azt,raise:Izt,lower:kzt,append:Nzt,insert:Ozt,remove:Fzt,clone:Hzt,datum:Uzt,on:jzt,dispatch:Kzt};Qzt=Jzt});function d7(e){return typeof e=="string"?new Bn([[document.querySelector(e)]],[document.documentElement]):new Bn([[e]],AC)}var xet=M(()=>{Sc()});function tFt(e){return d7(Ng(e).call(document.documentElement))}var eFt=M(()=>{TC();xet()});function m7(){return new bet}function bet(){this._="@"+(++dLe).toString(36)}var dLe,rFt=M(()=>{dLe=0;bet.prototype=m7.prototype={constructor:bet,get:function(e){for(var t=this._;!(t in e);)if(!(e=e.parentNode))return;return e[t]},set:function(e,t){return e[this._]=t},remove:function(e){return this._ in e&&delete e[this._]},toString:function(){return this._}}});function Aw(){for(var e=Pu,t;t=e.sourceEvent;)e=t;return e}var g7=M(()=>{p7()});function Dg(e,t){var r=e.ownerSVGElement||e;if(r.createSVGPoint){var n=r.createSVGPoint();return n.x=t.clientX,n.y=t.clientY,n=n.matrixTransform(e.getScreenCTM().inverse()),[n.x,n.y]}var i=e.getBoundingClientRect();return[t.clientX-i.left-e.clientLeft,t.clientY-i.top-e.clientTop]}var PC=M(()=>{});function nFt(e){var t=Aw();return t.changedTouches&&(t=t.changedTouches[0]),Dg(e,t)}var iFt=M(()=>{g7();PC()});function oFt(e){return typeof e=="string"?new Bn([document.querySelectorAll(e)],[document.documentElement]):new Bn([e==null?[]:e],AC)}var aFt=M(()=>{Sc()});function sFt(e,t,r){arguments.length<3&&(r=t,t=Aw().changedTouches);for(var n=0,i=t?t.length:0,o;n<i;++n)if((o=t[n]).identifier===r)return Dg(e,o);return null}var lFt=M(()=>{g7();PC()});function cFt(e,t){t==null&&(t=Aw().touches);for(var r=0,n=t?t.length:0,i=new Array(n);r<n;++r)i[r]=Dg(e,t[r]);return i}var uFt=M(()=>{g7();PC()});var hFt=M(()=>{eFt();TC();rFt();det();iFt();s7();a7();PC();xet();aFt();Sc();l7();pet();yet();lFt();uFt();f7();p7()});function Eet(){this._x0=this._y0=this._x1=this._y1=null,this._=""}function fFt(){return new Eet}var wet,Met,uv,mLe,Iu,pFt=M(()=>{wet=Math.PI,Met=2*wet,uv=1e-6,mLe=Met-uv;Eet.prototype=fFt.prototype={constructor:Eet,moveTo:function(e,t){this._+="M"+(this._x0=this._x1=+e)+","+(this._y0=this._y1=+t)},closePath:function(){this._x1!==null&&(this._x1=this._x0,this._y1=this._y0,this._+="Z")},lineTo:function(e,t){this._+="L"+(this._x1=+e)+","+(this._y1=+t)},quadraticCurveTo:function(e,t,r,n){this._+="Q"+ +e+","+ +t+","+(this._x1=+r)+","+(this._y1=+n)},bezierCurveTo:function(e,t,r,n,i,o){this._+="C"+ +e+","+ +t+","+ +r+","+ +n+","+(this._x1=+i)+","+(this._y1=+o)},arcTo:function(e,t,r,n,i){e=+e,t=+t,r=+r,n=+n,i=+i;var o=this._x1,a=this._y1,s=r-e,l=n-t,c=o-e,u=a-t,h=c*c+u*u;if(i<0)throw new Error("negative radius: "+i);if(this._x1===null)this._+="M"+(this._x1=e)+","+(this._y1=t);else if(h>uv)if(!(Math.abs(u*s-l*c)>uv)||!i)this._+="L"+(this._x1=e)+","+(this._y1=t);else{var f=r-o,p=n-a,d=s*s+l*l,g=f*f+p*p,_=Math.sqrt(d),y=Math.sqrt(h),x=i*Math.tan((wet-Math.acos((d+h-g)/(2*_*y)))/2),b=x/y,S=x/_;Math.abs(b-1)>uv&&(this._+="L"+(e+b*c)+","+(t+b*u)),this._+="A"+i+","+i+",0,0,"+ +(u*f>c*p)+","+(this._x1=e+S*s)+","+(this._y1=t+S*l)}},arc:function(e,t,r,n,i,o){e=+e,t=+t,r=+r,o=!!o;var a=r*Math.cos(n),s=r*Math.sin(n),l=e+a,c=t+s,u=1^o,h=o?n-i:i-n;if(r<0)throw new Error("negative radius: "+r);this._x1===null?this._+="M"+l+","+c:(Math.abs(this._x1-l)>uv||Math.abs(this._y1-c)>uv)&&(this._+="L"+l+","+c),r&&(h<0&&(h=h%Met+Met),h>mLe?this._+="A"+r+","+r+",0,1,"+u+","+(e-a)+","+(t-s)+"A"+r+","+r+",0,1,"+u+","+(this._x1=l)+","+(this._y1=c):h>uv&&(this._+="A"+r+","+r+",0,"+ +(h>=wet)+","+u+","+(this._x1=e+r*Math.cos(i))+","+(this._y1=t+r*Math.sin(i))))},rect:function(e,t,r,n){this._+="M"+(this._x0=this._x1=+e)+","+(this._y0=this._y1=+t)+"h"+ +r+"v"+ +n+"h"+-r+"Z"},toString:function(){return this._}};Iu=fFt});var Pw=M(()=>{pFt()});function Ge(e){return function(){return e}}var Og=M(()=>{});function mFt(e){return e>1?0:e<-1?ku:Math.acos(e)}function Cet(e){return e>=1?IC:e<=-1?-IC:Math.asin(e)}var Tet,Ho,zg,dFt,_7,Lu,hv,Co,ku,IC,Mc,Iw=M(()=>{Tet=Math.abs,Ho=Math.atan2,zg=Math.cos,dFt=Math.max,_7=Math.min,Lu=Math.sin,hv=Math.sqrt,Co=1e-12,ku=Math.PI,IC=ku/2,Mc=2*ku});function gLe(e){return e.innerRadius}function _Le(e){return e.outerRadius}function yLe(e){return e.startAngle}function vLe(e){return e.endAngle}function xLe(e){return e&&e.padAngle}function bLe(e,t,r,n,i,o,a,s){var l=r-e,c=n-t,u=a-i,h=s-o,f=(u*(t-o)-h*(e-i))/(h*l-u*c);return[e+f*l,t+f*c]}function y7(e,t,r,n,i,o,a){var s=e-r,l=t-n,c=(a?o:-o)/hv(s*s+l*l),u=c*l,h=-c*s,f=e+u,p=t+h,d=r+u,g=n+h,_=(f+d)/2,y=(p+g)/2,x=d-f,b=g-p,S=x*x+b*b,C=i-o,P=f*g-d*p,k=(b<0?-1:1)*hv(dFt(0,C*C*S-P*P)),O=(P*b-x*k)/S,D=(-P*x-b*k)/S,B=(P*b+x*k)/S,I=(-P*x+b*k)/S,L=O-_,R=D-y,F=B-_,z=I-y;return L*L+R*R>F*F+z*z&&(O=B,D=I),{cx:O,cy:D,x01:-u,y01:-h,x11:O*(i/C-1),y11:D*(i/C-1)}}function gFt(){var e=gLe,t=_Le,r=Ge(0),n=null,i=yLe,o=vLe,a=xLe,s=null;function l(){var c,u,h=+e.apply(this,arguments),f=+t.apply(this,arguments),p=i.apply(this,arguments)-IC,d=o.apply(this,arguments)-IC,g=Tet(d-p),_=d>p;if(s||(s=c=Iu()),f<h&&(u=f,f=h,h=u),!(f>Co))s.moveTo(0,0);else if(g>Mc-Co)s.moveTo(f*zg(p),f*Lu(p)),s.arc(0,0,f,p,d,!_),h>Co&&(s.moveTo(h*zg(d),h*Lu(d)),s.arc(0,0,h,d,p,_));else{var y=p,x=d,b=p,S=d,C=g,P=g,k=a.apply(this,arguments)/2,O=k>Co&&(n?+n.apply(this,arguments):hv(h*h+f*f)),D=_7(Tet(f-h)/2,+r.apply(this,arguments)),B=D,I=D,L,R;if(O>Co){var F=Cet(O/h*Lu(k)),z=Cet(O/f*Lu(k));(C-=F*2)>Co?(F*=_?1:-1,b+=F,S-=F):(C=0,b=S=(p+d)/2),(P-=z*2)>Co?(z*=_?1:-1,y+=z,x-=z):(P=0,y=x=(p+d)/2)}var U=f*zg(y),W=f*Lu(y),Z=h*zg(S),rt=h*Lu(S);if(D>Co){var ot=f*zg(x),st=f*Lu(x),St=h*zg(b),bt=h*Lu(b);if(g<ku){var Mt=C>Co?bLe(U,W,St,bt,ot,st,Z,rt):[Z,rt],lt=U-Mt[0],Kt=W-Mt[1],_t=ot-Mt[0],ct=st-Mt[1],X=1/Lu(mFt((lt*_t+Kt*ct)/(hv(lt*lt+Kt*Kt)*hv(_t*_t+ct*ct)))/2),et=hv(Mt[0]*Mt[0]+Mt[1]*Mt[1]);B=_7(D,(h-et)/(X-1)),I=_7(D,(f-et)/(X+1))}}P>Co?I>Co?(L=y7(St,bt,U,W,f,I,_),R=y7(ot,st,Z,rt,f,I,_),s.moveTo(L.cx+L.x01,L.cy+L.y01),I<D?s.arc(L.cx,L.cy,I,Ho(L.y01,L.x01),Ho(R.y01,R.x01),!_):(s.arc(L.cx,L.cy,I,Ho(L.y01,L.x01),Ho(L.y11,L.x11),!_),s.arc(0,0,f,Ho(L.cy+L.y11,L.cx+L.x11),Ho(R.cy+R.y11,R.cx+R.x11),!_),s.arc(R.cx,R.cy,I,Ho(R.y11,R.x11),Ho(R.y01,R.x01),!_))):(s.moveTo(U,W),s.arc(0,0,f,y,x,!_)):s.moveTo(U,W),!(h>Co)||!(C>Co)?s.lineTo(Z,rt):B>Co?(L=y7(Z,rt,ot,st,h,-B,_),R=y7(U,W,St,bt,h,-B,_),s.lineTo(L.cx+L.x01,L.cy+L.y01),B<D?s.arc(L.cx,L.cy,B,Ho(L.y01,L.x01),Ho(R.y01,R.x01),!_):(s.arc(L.cx,L.cy,B,Ho(L.y01,L.x01),Ho(L.y11,L.x11),!_),s.arc(0,0,h,Ho(L.cy+L.y11,L.cx+L.x11),Ho(R.cy+R.y11,R.cx+R.x11),_),s.arc(R.cx,R.cy,B,Ho(R.y11,R.x11),Ho(R.y01,R.x01),!_))):s.arc(0,0,h,S,b,_)}if(s.closePath(),c)return s=null,c+""||null}return l.centroid=function(){var c=(+e.apply(this,arguments)+ +t.apply(this,arguments))/2,u=(+i.apply(this,arguments)+ +o.apply(this,arguments))/2-ku/2;return[zg(u)*c,Lu(u)*c]},l.innerRadius=function(c){return arguments.length?(e=typeof c=="function"?c:Ge(+c),l):e},l.outerRadius=function(c){return arguments.length?(t=typeof c=="function"?c:Ge(+c),l):t},l.cornerRadius=function(c){return arguments.length?(r=typeof c=="function"?c:Ge(+c),l):r},l.padRadius=function(c){return arguments.length?(n=c==null?null:typeof c=="function"?c:Ge(+c),l):n},l.startAngle=function(c){return arguments.length?(i=typeof c=="function"?c:Ge(+c),l):i},l.endAngle=function(c){return arguments.length?(o=typeof c=="function"?c:Ge(+c),l):o},l.padAngle=function(c){return arguments.length?(a=typeof c=="function"?c:Ge(+c),l):a},l.context=function(c){return arguments.length?(s=c==null?null:c,l):s},l}var _Ft=M(()=>{Pw();Og();Iw()});function yFt(e){this._context=e}function Fg(e){return new yFt(e)}var LC=M(()=>{yFt.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;default:this._context.lineTo(e,t);break}}}});function Lw(e){return e[0]}function kw(e){return e[1]}var v7=M(()=>{});function Rw(){var e=Lw,t=kw,r=Ge(!0),n=null,i=Fg,o=null;function a(s){var l,c=s.length,u,h=!1,f;for(n==null&&(o=i(f=Iu())),l=0;l<=c;++l)!(l<c&&r(u=s[l],l,s))===h&&((h=!h)?o.lineStart():o.lineEnd()),h&&o.point(+e(u,l,s),+t(u,l,s));if(f)return o=null,f+""||null}return a.x=function(s){return arguments.length?(e=typeof s=="function"?s:Ge(+s),a):e},a.y=function(s){return arguments.length?(t=typeof s=="function"?s:Ge(+s),a):t},a.defined=function(s){return arguments.length?(r=typeof s=="function"?s:Ge(!!s),a):r},a.curve=function(s){return arguments.length?(i=s,n!=null&&(o=i(n)),a):i},a.context=function(s){return arguments.length?(s==null?n=o=null:o=i(n=s),a):n},a}var x7=M(()=>{Pw();Og();LC();v7()});function b7(){var e=Lw,t=null,r=Ge(0),n=kw,i=Ge(!0),o=null,a=Fg,s=null;function l(u){var h,f,p,d=u.length,g,_=!1,y,x=new Array(d),b=new Array(d);for(o==null&&(s=a(y=Iu())),h=0;h<=d;++h){if(!(h<d&&i(g=u[h],h,u))===_)if(_=!_)f=h,s.areaStart(),s.lineStart();else{for(s.lineEnd(),s.lineStart(),p=h-1;p>=f;--p)s.point(x[p],b[p]);s.lineEnd(),s.areaEnd()}_&&(x[h]=+e(g,h,u),b[h]=+r(g,h,u),s.point(t?+t(g,h,u):x[h],n?+n(g,h,u):b[h]))}if(y)return s=null,y+""||null}function c(){return Rw().defined(i).curve(a).context(o)}return l.x=function(u){return arguments.length?(e=typeof u=="function"?u:Ge(+u),t=null,l):e},l.x0=function(u){return arguments.length?(e=typeof u=="function"?u:Ge(+u),l):e},l.x1=function(u){return arguments.length?(t=u==null?null:typeof u=="function"?u:Ge(+u),l):t},l.y=function(u){return arguments.length?(r=typeof u=="function"?u:Ge(+u),n=null,l):r},l.y0=function(u){return arguments.length?(r=typeof u=="function"?u:Ge(+u),l):r},l.y1=function(u){return arguments.length?(n=u==null?null:typeof u=="function"?u:Ge(+u),l):n},l.lineX0=l.lineY0=function(){return c().x(e).y(r)},l.lineY1=function(){return c().x(e).y(n)},l.lineX1=function(){return c().x(t).y(r)},l.defined=function(u){return arguments.length?(i=typeof u=="function"?u:Ge(!!u),l):i},l.curve=function(u){return arguments.length?(a=u,o!=null&&(s=a(o)),l):a},l.context=function(u){return arguments.length?(u==null?o=s=null:s=a(o=u),l):o},l}var Aet=M(()=>{Pw();Og();LC();x7();v7()});function vFt(e,t){return t<e?-1:t>e?1:t>=e?0:NaN}var xFt=M(()=>{});function bFt(e){return e}var wFt=M(()=>{});function SFt(){var e=bFt,t=vFt,r=null,n=Ge(0),i=Ge(Mc),o=Ge(0);function a(s){var l,c=s.length,u,h,f=0,p=new Array(c),d=new Array(c),g=+n.apply(this,arguments),_=Math.min(Mc,Math.max(-Mc,i.apply(this,arguments)-g)),y,x=Math.min(Math.abs(_)/c,o.apply(this,arguments)),b=x*(_<0?-1:1),S;for(l=0;l<c;++l)(S=d[p[l]=l]=+e(s[l],l,s))>0&&(f+=S);for(t!=null?p.sort(function(C,P){return t(d[C],d[P])}):r!=null&&p.sort(function(C,P){return r(s[C],s[P])}),l=0,h=f?(_-c*b)/f:0;l<c;++l,g=y)u=p[l],S=d[u],y=g+(S>0?S*h:0)+b,d[u]={data:s[u],index:l,value:S,startAngle:g,endAngle:y,padAngle:x};return d}return a.value=function(s){return arguments.length?(e=typeof s=="function"?s:Ge(+s),a):e},a.sortValues=function(s){return arguments.length?(t=s,r=null,a):t},a.sort=function(s){return arguments.length?(r=s,t=null,a):r},a.startAngle=function(s){return arguments.length?(n=typeof s=="function"?s:Ge(+s),a):n},a.endAngle=function(s){return arguments.length?(i=typeof s=="function"?s:Ge(+s),a):i},a.padAngle=function(s){return arguments.length?(o=typeof s=="function"?s:Ge(+s),a):o},a}var MFt=M(()=>{Og();xFt();wFt();Iw()});function EFt(e){this._curve=e}function Nw(e){function t(r){return new EFt(e(r))}return t._curve=e,t}var w7,Pet=M(()=>{LC();w7=Nw(Fg);EFt.prototype={areaStart:function(){this._curve.areaStart()},areaEnd:function(){this._curve.areaEnd()},lineStart:function(){this._curve.lineStart()},lineEnd:function(){this._curve.lineEnd()},point:function(e,t){this._curve.point(t*Math.sin(e),t*-Math.cos(e))}}});function Dw(e){var t=e.curve;return e.angle=e.x,delete e.x,e.radius=e.y,delete e.y,e.curve=function(r){return arguments.length?t(Nw(r)):t()._curve},e}function Iet(){return Dw(Rw().curve(w7))}var Let=M(()=>{Pet();x7()});function ket(){var e=b7().curve(w7),t=e.curve,r=e.lineX0,n=e.lineX1,i=e.lineY0,o=e.lineY1;return e.angle=e.x,delete e.x,e.startAngle=e.x0,delete e.x0,e.endAngle=e.x1,delete e.x1,e.radius=e.y,delete e.y,e.innerRadius=e.y0,delete e.y0,e.outerRadius=e.y1,delete e.y1,e.lineStartAngle=function(){return Dw(r())},delete e.lineX0,e.lineEndAngle=function(){return Dw(n())},delete e.lineX1,e.lineInnerRadius=function(){return Dw(i())},delete e.lineY0,e.lineOuterRadius=function(){return Dw(o())},delete e.lineY1,e.curve=function(a){return arguments.length?t(Nw(a)):t()._curve},e}var TFt=M(()=>{Pet();Aet();Let()});function fv(e,t){return[(t=+t)*Math.cos(e-=Math.PI/2),t*Math.sin(e)]}var Ret=M(()=>{});var kC,Net=M(()=>{kC=Array.prototype.slice});function wLe(e){return e.source}function SLe(e){return e.target}function Det(e){var t=wLe,r=SLe,n=Lw,i=kw,o=null;function a(){var s,l=kC.call(arguments),c=t.apply(this,l),u=r.apply(this,l);if(o||(o=s=Iu()),e(o,+n.apply(this,(l[0]=c,l)),+i.apply(this,l),+n.apply(this,(l[0]=u,l)),+i.apply(this,l)),s)return o=null,s+""||null}return a.source=function(s){return arguments.length?(t=s,a):t},a.target=function(s){return arguments.length?(r=s,a):r},a.x=function(s){return arguments.length?(n=typeof s=="function"?s:Ge(+s),a):n},a.y=function(s){return arguments.length?(i=typeof s=="function"?s:Ge(+s),a):i},a.context=function(s){return arguments.length?(o=s==null?null:s,a):o},a}function MLe(e,t,r,n,i){e.moveTo(t,r),e.bezierCurveTo(t=(t+n)/2,r,t,i,n,i)}function ELe(e,t,r,n,i){e.moveTo(t,r),e.bezierCurveTo(t,r=(r+i)/2,n,r,n,i)}function TLe(e,t,r,n,i){var o=fv(t,r),a=fv(t,r=(r+i)/2),s=fv(n,r),l=fv(n,i);e.moveTo(o[0],o[1]),e.bezierCurveTo(a[0],a[1],s[0],s[1],l[0],l[1])}function CFt(){return Det(MLe)}function AFt(){return Det(ELe)}function PFt(){var e=Det(TLe);return e.angle=e.x,delete e.x,e.radius=e.y,delete e.y,e}var IFt=M(()=>{Pw();Net();Og();v7();Ret()});var RC,Oet=M(()=>{Iw();RC={draw:function(e,t){var r=Math.sqrt(t/ku);e.moveTo(r,0),e.arc(0,0,r,0,Mc)}}});var S7,zet=M(()=>{S7={draw:function(e,t){var r=Math.sqrt(t/5)/2;e.moveTo(-3*r,-r),e.lineTo(-r,-r),e.lineTo(-r,-3*r),e.lineTo(r,-3*r),e.lineTo(r,-r),e.lineTo(3*r,-r),e.lineTo(3*r,r),e.lineTo(r,r),e.lineTo(r,3*r),e.lineTo(-r,3*r),e.lineTo(-r,r),e.lineTo(-3*r,r),e.closePath()}}});var LFt,CLe,M7,Fet=M(()=>{LFt=Math.sqrt(.3333333333333333),CLe=LFt*2,M7={draw:function(e,t){var r=Math.sqrt(t/CLe),n=r*LFt;e.moveTo(0,-r),e.lineTo(n,0),e.lineTo(0,r),e.lineTo(-n,0),e.closePath()}}});var ALe,kFt,PLe,ILe,E7,Bet=M(()=>{Iw();ALe=.8908130915292852,kFt=Math.sin(ku/10)/Math.sin(7*ku/10),PLe=Math.sin(Mc/10)*kFt,ILe=-Math.cos(Mc/10)*kFt,E7={draw:function(e,t){var r=Math.sqrt(t*ALe),n=PLe*r,i=ILe*r;e.moveTo(0,-r),e.lineTo(n,i);for(var o=1;o<5;++o){var a=Mc*o/5,s=Math.cos(a),l=Math.sin(a);e.lineTo(l*r,-s*r),e.lineTo(s*n-l*i,l*n+s*i)}e.closePath()}}});var T7,Het=M(()=>{T7={draw:function(e,t){var r=Math.sqrt(t),n=-r/2;e.rect(n,n,r,r)}}});var Vet,C7,Uet=M(()=>{Vet=Math.sqrt(3),C7={draw:function(e,t){var r=-Math.sqrt(t/(Vet*3));e.moveTo(0,r*2),e.lineTo(-Vet*r,-r),e.lineTo(Vet*r,-r),e.closePath()}}});var Ec,Tc,qet,LLe,A7,Get=M(()=>{Ec=-.5,Tc=Math.sqrt(3)/2,qet=1/Math.sqrt(12),LLe=(qet/2+1)*3,A7={draw:function(e,t){var r=Math.sqrt(t/LLe),n=r/2,i=r*qet,o=n,a=r*qet+r,s=-o,l=a;e.moveTo(n,i),e.lineTo(o,a),e.lineTo(s,l),e.lineTo(Ec*n-Tc*i,Tc*n+Ec*i),e.lineTo(Ec*o-Tc*a,Tc*o+Ec*a),e.lineTo(Ec*s-Tc*l,Tc*s+Ec*l),e.lineTo(Ec*n+Tc*i,Ec*i-Tc*n),e.lineTo(Ec*o+Tc*a,Ec*a-Tc*o),e.lineTo(Ec*s+Tc*l,Ec*l-Tc*s),e.closePath()}}});function NFt(){var e=Ge(RC),t=Ge(64),r=null;function n(){var i;if(r||(r=i=Iu()),e.apply(this,arguments).draw(r,+t.apply(this,arguments)),i)return r=null,i+""||null}return n.type=function(i){return arguments.length?(e=typeof i=="function"?i:Ge(i),n):e},n.size=function(i){return arguments.length?(t=typeof i=="function"?i:Ge(+i),n):t},n.context=function(i){return arguments.length?(r=i==null?null:i,n):r},n}var RFt,DFt=M(()=>{Pw();Oet();zet();Fet();Bet();Het();Uet();Get();Og();RFt=[RC,S7,M7,T7,E7,C7,A7]});function Cc(){}var NC=M(()=>{});function Ow(e,t,r){e._context.bezierCurveTo((2*e._x0+e._x1)/3,(2*e._y0+e._y1)/3,(e._x0+2*e._x1)/3,(e._y0+2*e._y1)/3,(e._x0+4*e._x1+t)/6,(e._y0+4*e._y1+r)/6)}function DC(e){this._context=e}function OFt(e){return new DC(e)}var OC=M(()=>{DC.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._y0=this._y1=NaN,this._point=0},lineEnd:function(){switch(this._point){case 3:Ow(this,this._x1,this._y1);case 2:this._context.lineTo(this._x1,this._y1);break}(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;break;case 2:this._point=3,this._context.lineTo((5*this._x0+this._x1)/6,(5*this._y0+this._y1)/6);default:Ow(this,e,t);break}this._x0=this._x1,this._x1=e,this._y0=this._y1,this._y1=t}}});function zFt(e){this._context=e}function FFt(e){return new zFt(e)}var BFt=M(()=>{NC();OC();zFt.prototype={areaStart:Cc,areaEnd:Cc,lineStart:function(){this._x0=this._x1=this._x2=this._x3=this._x4=this._y0=this._y1=this._y2=this._y3=this._y4=NaN,this._point=0},lineEnd:function(){switch(this._point){case 1:{this._context.moveTo(this._x2,this._y2),this._context.closePath();break}case 2:{this._context.moveTo((this._x2+2*this._x3)/3,(this._y2+2*this._y3)/3),this._context.lineTo((this._x3+2*this._x2)/3,(this._y3+2*this._y2)/3),this._context.closePath();break}case 3:{this.point(this._x2,this._y2),this.point(this._x3,this._y3),this.point(this._x4,this._y4);break}}},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._x2=e,this._y2=t;break;case 1:this._point=2,this._x3=e,this._y3=t;break;case 2:this._point=3,this._x4=e,this._y4=t,this._context.moveTo((this._x0+4*this._x1+e)/6,(this._y0+4*this._y1+t)/6);break;default:Ow(this,e,t);break}this._x0=this._x1,this._x1=e,this._y0=this._y1,this._y1=t}}});function HFt(e){this._context=e}function VFt(e){return new HFt(e)}var UFt=M(()=>{OC();HFt.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._y0=this._y1=NaN,this._point=0},lineEnd:function(){(this._line||this._line!==0&&this._point===3)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1;break;case 1:this._point=2;break;case 2:this._point=3;var r=(this._x0+4*this._x1+e)/6,n=(this._y0+4*this._y1+t)/6;this._line?this._context.lineTo(r,n):this._context.moveTo(r,n);break;case 3:this._point=4;default:Ow(this,e,t);break}this._x0=this._x1,this._x1=e,this._y0=this._y1,this._y1=t}}});function qFt(e,t){this._basis=new DC(e),this._beta=t}var GFt,WFt=M(()=>{OC();qFt.prototype={lineStart:function(){this._x=[],this._y=[],this._basis.lineStart()},lineEnd:function(){var e=this._x,t=this._y,r=e.length-1;if(r>0)for(var n=e[0],i=t[0],o=e[r]-n,a=t[r]-i,s=-1,l;++s<=r;)l=s/r,this._basis.point(this._beta*e[s]+(1-this._beta)*(n+l*o),this._beta*t[s]+(1-this._beta)*(i+l*a));this._x=this._y=null,this._basis.lineEnd()},point:function(e,t){this._x.push(+e),this._y.push(+t)}};GFt=function e(t){function r(n){return t===1?new DC(n):new qFt(n,t)}return r.beta=function(n){return e(+n)},r}(.85)});function zw(e,t,r){e._context.bezierCurveTo(e._x1+e._k*(e._x2-e._x0),e._y1+e._k*(e._y2-e._y0),e._x2+e._k*(e._x1-t),e._y2+e._k*(e._y1-r),e._x2,e._y2)}function P7(e,t){this._context=e,this._k=(1-t)/6}var YFt,zC=M(()=>{P7.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x2,this._y2);break;case 3:zw(this,this._x1,this._y1);break}(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2,this._x1=e,this._y1=t;break;case 2:this._point=3;default:zw(this,e,t);break}this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};YFt=function e(t){function r(n){return new P7(n,t)}return r.tension=function(n){return e(+n)},r}(0)});function I7(e,t){this._context=e,this._k=(1-t)/6}var jFt,Wet=M(()=>{NC();zC();I7.prototype={areaStart:Cc,areaEnd:Cc,lineStart:function(){this._x0=this._x1=this._x2=this._x3=this._x4=this._x5=this._y0=this._y1=this._y2=this._y3=this._y4=this._y5=NaN,this._point=0},lineEnd:function(){switch(this._point){case 1:{this._context.moveTo(this._x3,this._y3),this._context.closePath();break}case 2:{this._context.lineTo(this._x3,this._y3),this._context.closePath();break}case 3:{this.point(this._x3,this._y3),this.point(this._x4,this._y4),this.point(this._x5,this._y5);break}}},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._x3=e,this._y3=t;break;case 1:this._point=2,this._context.moveTo(this._x4=e,this._y4=t);break;case 2:this._point=3,this._x5=e,this._y5=t;break;default:zw(this,e,t);break}this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};jFt=function e(t){function r(n){return new I7(n,t)}return r.tension=function(n){return e(+n)},r}(0)});function L7(e,t){this._context=e,this._k=(1-t)/6}var XFt,Yet=M(()=>{zC();L7.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._point=0},lineEnd:function(){(this._line||this._line!==0&&this._point===3)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1;break;case 1:this._point=2;break;case 2:this._point=3,this._line?this._context.lineTo(this._x2,this._y2):this._context.moveTo(this._x2,this._y2);break;case 3:this._point=4;default:zw(this,e,t);break}this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};XFt=function e(t){function r(n){return new L7(n,t)}return r.tension=function(n){return e(+n)},r}(0)});function FC(e,t,r){var n=e._x1,i=e._y1,o=e._x2,a=e._y2;if(e._l01_a>Co){var s=2*e._l01_2a+3*e._l01_a*e._l12_a+e._l12_2a,l=3*e._l01_a*(e._l01_a+e._l12_a);n=(n*s-e._x0*e._l12_2a+e._x2*e._l01_2a)/l,i=(i*s-e._y0*e._l12_2a+e._y2*e._l01_2a)/l}if(e._l23_a>Co){var c=2*e._l23_2a+3*e._l23_a*e._l12_a+e._l12_2a,u=3*e._l23_a*(e._l23_a+e._l12_a);o=(o*c+e._x1*e._l23_2a-t*e._l12_2a)/u,a=(a*c+e._y1*e._l23_2a-r*e._l12_2a)/u}e._context.bezierCurveTo(n,i,o,a,e._x2,e._y2)}function $Ft(e,t){this._context=e,this._alpha=t}var KFt,k7=M(()=>{Iw();zC();$Ft.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._l01_a=this._l12_a=this._l23_a=this._l01_2a=this._l12_2a=this._l23_2a=this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x2,this._y2);break;case 3:this.point(this._x2,this._y2);break}(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){if(e=+e,t=+t,this._point){var r=this._x2-e,n=this._y2-t;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(r*r+n*n,this._alpha))}switch(this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;break;case 2:this._point=3;default:FC(this,e,t);break}this._l01_a=this._l12_a,this._l12_a=this._l23_a,this._l01_2a=this._l12_2a,this._l12_2a=this._l23_2a,this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};KFt=function e(t){function r(n){return t?new $Ft(n,t):new P7(n,0)}return r.alpha=function(n){return e(+n)},r}(.5)});function ZFt(e,t){this._context=e,this._alpha=t}var JFt,QFt=M(()=>{Wet();NC();k7();ZFt.prototype={areaStart:Cc,areaEnd:Cc,lineStart:function(){this._x0=this._x1=this._x2=this._x3=this._x4=this._x5=this._y0=this._y1=this._y2=this._y3=this._y4=this._y5=NaN,this._l01_a=this._l12_a=this._l23_a=this._l01_2a=this._l12_2a=this._l23_2a=this._point=0},lineEnd:function(){switch(this._point){case 1:{this._context.moveTo(this._x3,this._y3),this._context.closePath();break}case 2:{this._context.lineTo(this._x3,this._y3),this._context.closePath();break}case 3:{this.point(this._x3,this._y3),this.point(this._x4,this._y4),this.point(this._x5,this._y5);break}}},point:function(e,t){if(e=+e,t=+t,this._point){var r=this._x2-e,n=this._y2-t;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(r*r+n*n,this._alpha))}switch(this._point){case 0:this._point=1,this._x3=e,this._y3=t;break;case 1:this._point=2,this._context.moveTo(this._x4=e,this._y4=t);break;case 2:this._point=3,this._x5=e,this._y5=t;break;default:FC(this,e,t);break}this._l01_a=this._l12_a,this._l12_a=this._l23_a,this._l01_2a=this._l12_2a,this._l12_2a=this._l23_2a,this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};JFt=function e(t){function r(n){return t?new ZFt(n,t):new I7(n,0)}return r.alpha=function(n){return e(+n)},r}(.5)});function tBt(e,t){this._context=e,this._alpha=t}var eBt,rBt=M(()=>{Yet();k7();tBt.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._l01_a=this._l12_a=this._l23_a=this._l01_2a=this._l12_2a=this._l23_2a=this._point=0},lineEnd:function(){(this._line||this._line!==0&&this._point===3)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){if(e=+e,t=+t,this._point){var r=this._x2-e,n=this._y2-t;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(r*r+n*n,this._alpha))}switch(this._point){case 0:this._point=1;break;case 1:this._point=2;break;case 2:this._point=3,this._line?this._context.lineTo(this._x2,this._y2):this._context.moveTo(this._x2,this._y2);break;case 3:this._point=4;default:FC(this,e,t);break}this._l01_a=this._l12_a,this._l12_a=this._l23_a,this._l01_2a=this._l12_2a,this._l12_2a=this._l23_2a,this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};eBt=function e(t){function r(n){return t?new tBt(n,t):new L7(n,0)}return r.alpha=function(n){return e(+n)},r}(.5)});function nBt(e){this._context=e}function iBt(e){return new nBt(e)}var oBt=M(()=>{NC();nBt.prototype={areaStart:Cc,areaEnd:Cc,lineStart:function(){this._point=0},lineEnd:function(){this._point&&this._context.closePath()},point:function(e,t){e=+e,t=+t,this._point?this._context.lineTo(e,t):(this._point=1,this._context.moveTo(e,t))}}});function aBt(e){return e<0?-1:1}function sBt(e,t,r){var n=e._x1-e._x0,i=t-e._x1,o=(e._y1-e._y0)/(n||i<0&&-0),a=(r-e._y1)/(i||n<0&&-0),s=(o*i+a*n)/(n+i);return(aBt(o)+aBt(a))*Math.min(Math.abs(o),Math.abs(a),.5*Math.abs(s))||0}function lBt(e,t){var r=e._x1-e._x0;return r?(3*(e._y1-e._y0)/r-t)/2:t}function jet(e,t,r){var n=e._x0,i=e._y0,o=e._x1,a=e._y1,s=(o-n)/3;e._context.bezierCurveTo(n+s,i+s*t,o-s,a-s*r,o,a)}function R7(e){this._context=e}function cBt(e){this._context=new uBt(e)}function uBt(e){this._context=e}function hBt(e){return new R7(e)}function fBt(e){return new cBt(e)}var pBt=M(()=>{R7.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._y0=this._y1=this._t0=NaN,this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x1,this._y1);break;case 3:jet(this,this._t0,lBt(this,this._t0));break}(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){var r=NaN;if(e=+e,t=+t,!(e===this._x1&&t===this._y1)){switch(this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;break;case 2:this._point=3,jet(this,lBt(this,r=sBt(this,e,t)),r);break;default:jet(this,this._t0,r=sBt(this,e,t));break}this._x0=this._x1,this._x1=e,this._y0=this._y1,this._y1=t,this._t0=r}}};(cBt.prototype=Object.create(R7.prototype)).point=function(e,t){R7.prototype.point.call(this,t,e)};uBt.prototype={moveTo:function(e,t){this._context.moveTo(t,e)},closePath:function(){this._context.closePath()},lineTo:function(e,t){this._context.lineTo(t,e)},bezierCurveTo:function(e,t,r,n,i,o){this._context.bezierCurveTo(t,e,n,r,o,i)}}});function mBt(e){this._context=e}function dBt(e){var t,r=e.length-1,n,i=new Array(r),o=new Array(r),a=new Array(r);for(i[0]=0,o[0]=2,a[0]=e[0]+2*e[1],t=1;t<r-1;++t)i[t]=1,o[t]=4,a[t]=4*e[t]+2*e[t+1];for(i[r-1]=2,o[r-1]=7,a[r-1]=8*e[r-1]+e[r],t=1;t<r;++t)n=i[t]/o[t-1],o[t]-=n,a[t]-=n*a[t-1];for(i[r-1]=a[r-1]/o[r-1],t=r-2;t>=0;--t)i[t]=(a[t]-i[t+1])/o[t];for(o[r-1]=(e[r]+i[r-1])/2,t=0;t<r-1;++t)o[t]=2*e[t+1]-i[t+1];return[i,o]}function gBt(e){return new mBt(e)}var _Bt=M(()=>{mBt.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x=[],this._y=[]},lineEnd:function(){var e=this._x,t=this._y,r=e.length;if(r)if(this._line?this._context.lineTo(e[0],t[0]):this._context.moveTo(e[0],t[0]),r===2)this._context.lineTo(e[1],t[1]);else for(var n=dBt(e),i=dBt(t),o=0,a=1;a<r;++o,++a)this._context.bezierCurveTo(n[0][o],i[0][o],n[1][o],i[1][o],e[a],t[a]);(this._line||this._line!==0&&r===1)&&this._context.closePath(),this._line=1-this._line,this._x=this._y=null},point:function(e,t){this._x.push(+e),this._y.push(+t)}}});function N7(e,t){this._context=e,this._t=t}function yBt(e){return new N7(e,.5)}function vBt(e){return new N7(e,0)}function xBt(e){return new N7(e,1)}var bBt=M(()=>{N7.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x=this._y=NaN,this._point=0},lineEnd:function(){0<this._t&&this._t<1&&this._point===2&&this._context.lineTo(this._x,this._y),(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line>=0&&(this._t=1-this._t,this._line=1-this._line)},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;default:{if(this._t<=0)this._context.lineTo(this._x,t),this._context.lineTo(e,t);else{var r=this._x*(1-this._t)+e*this._t;this._context.lineTo(r,this._y),this._context.lineTo(r,t)}break}}this._x=e,this._y=t}}});function Ru(e,t){if((a=e.length)>1)for(var r=1,n,i,o=e[t[0]],a,s=o.length;r<a;++r)for(i=o,o=e[t[r]],n=0;n<s;++n)o[n][1]+=o[n][0]=isNaN(i[n][1])?i[n][0]:i[n][1]}var Fw=M(()=>{});function Nu(e){for(var t=e.length,r=new Array(t);--t>=0;)r[t]=t;return r}var Bw=M(()=>{});function kLe(e,t){return e[t]}function wBt(){var e=Ge([]),t=Nu,r=Ru,n=kLe;function i(o){var a=e.apply(this,arguments),s,l=o.length,c=a.length,u=new Array(c),h;for(s=0;s<c;++s){for(var f=a[s],p=u[s]=new Array(l),d=0,g;d<l;++d)p[d]=g=[0,+n(o[d],f,d,o)],g.data=o[d];p.key=f}for(s=0,h=t(u);s<c;++s)u[h[s]].index=s;return r(u,h),u}return i.keys=function(o){return arguments.length?(e=typeof o=="function"?o:Ge(kC.call(o)),i):e},i.value=function(o){return arguments.length?(n=typeof o=="function"?o:Ge(+o),i):n},i.order=function(o){return arguments.length?(t=o==null?Nu:typeof o=="function"?o:Ge(kC.call(o)),i):t},i.offset=function(o){return arguments.length?(r=o==null?Ru:o,i):r},i}var SBt=M(()=>{Net();Og();Fw();Bw()});function MBt(e,t){if((n=e.length)>0){for(var r,n,i=0,o=e[0].length,a;i<o;++i){for(a=r=0;r<n;++r)a+=e[r][i][1]||0;if(a)for(r=0;r<n;++r)e[r][i][1]/=a}Ru(e,t)}}var EBt=M(()=>{Fw()});function TBt(e,t){if((l=e.length)>1)for(var r,n=0,i,o,a,s,l,c=e[t[0]].length;n<c;++n)for(a=s=0,r=0;r<l;++r)(o=(i=e[t[r]][n])[1]-i[0])>=0?(i[0]=a,i[1]=a+=o):o<0?(i[1]=s,i[0]=s+=o):i[0]=a}var CBt=M(()=>{});function ABt(e,t){if((i=e.length)>0){for(var r=0,n=e[t[0]],i,o=n.length;r<o;++r){for(var a=0,s=0;a<i;++a)s+=e[a][r][1]||0;n[r][1]+=n[r][0]=-s/2}Ru(e,t)}}var PBt=M(()=>{Fw()});function IBt(e,t){if(!(!((a=e.length)>0)||!((o=(i=e[t[0]]).length)>0))){for(var r=0,n=1,i,o,a;n<o;++n){for(var s=0,l=0,c=0;s<a;++s){for(var u=e[t[s]],h=u[n][1]||0,f=u[n-1][1]||0,p=(h-f)/2,d=0;d<s;++d){var g=e[t[d]],_=g[n][1]||0,y=g[n-1][1]||0;p+=_-y}l+=h,c+=p*h}i[n-1][1]+=i[n-1][0]=r,l&&(r-=c/l)}i[n-1][1]+=i[n-1][0]=r,Ru(e,t)}}var LBt=M(()=>{Fw()});function D7(e){var t=e.map(Xet);return Nu(e).sort(function(r,n){return t[r]-t[n]})}function Xet(e){for(var t=0,r=-1,n=e.length,i;++r<n;)(i=+e[r][1])&&(t+=i);return t}var O7=M(()=>{Bw()});function kBt(e){return D7(e).reverse()}var RBt=M(()=>{O7()});function NBt(e){var t=e.length,r,n,i=e.map(Xet),o=Nu(e).sort(function(u,h){return i[h]-i[u]}),a=0,s=0,l=[],c=[];for(r=0;r<t;++r)n=o[r],a<s?(a+=i[n],l.push(n)):(s+=i[n],c.push(n));return c.reverse().concat(l)}var DBt=M(()=>{Bw();O7()});function OBt(e){return Nu(e).reverse()}var zBt=M(()=>{Bw()});var FBt=M(()=>{_Ft();Aet();x7();MFt();TFt();Let();Ret();IFt();DFt();Oet();zet();Fet();Het();Bet();Uet();Get();BFt();UFt();OC();WFt();Wet();Yet();zC();QFt();rBt();k7();oBt();LC();pBt();_Bt();bBt();SBt();EBt();CBt();Fw();PBt();LBt();O7();RBt();DBt();Bw();zBt()});function Sr(e,t,r,n){function i(o){return e(o=new Date(+o)),o}return i.floor=i,i.ceil=function(o){return e(o=new Date(o-1)),t(o,1),e(o),o},i.round=function(o){var a=i(o),s=i.ceil(o);return o-a<s-o?a:s},i.offset=function(o,a){return t(o=new Date(+o),a==null?1:Math.floor(a)),o},i.range=function(o,a,s){var l=[],c;if(o=i.ceil(o),s=s==null?1:Math.floor(s),!(o<a)||!(s>0))return l;do l.push(c=new Date(+o)),t(o,s),e(o);while(c<o&&o<a);return l},i.filter=function(o){return Sr(function(a){if(a>=a)for(;e(a),!o(a);)a.setTime(a-1)},function(a,s){if(a>=a)if(s<0)for(;++s<=0;)for(;t(a,-1),!o(a););else for(;--s>=0;)for(;t(a,1),!o(a););})},r&&(i.count=function(o,a){return $et.setTime(+o),Ket.setTime(+a),e($et),e(Ket),Math.floor(r($et,Ket))},i.every=function(o){return o=Math.floor(o),!isFinite(o)||!(o>0)?null:o>1?i.filter(n?function(a){return n(a)%o===0}:function(a){return i.count(0,a)%o===0}):i}),i}var $et,Ket,fa=M(()=>{$et=new Date,Ket=new Date});var z7,Zet,Jet,BBt=M(()=>{fa();z7=Sr(function(){},function(e,t){e.setTime(+e+t)},function(e,t){return t-e});z7.every=function(e){return e=Math.floor(e),!isFinite(e)||!(e>0)?null:e>1?Sr(function(t){t.setTime(Math.floor(t/e)*e)},function(t,r){t.setTime(+t+r*e)},function(t,r){return(r-t)/e}):z7};Zet=z7,Jet=z7.range});var BC,Ps,bf,F7,B7,wf=M(()=>{BC=1e3,Ps=6e4,bf=36e5,F7=864e5,B7=6048e5});var HBt,Qet,trt,VBt=M(()=>{fa();wf();HBt=Sr(function(e){e.setTime(Math.floor(e/BC)*BC)},function(e,t){e.setTime(+e+t*BC)},function(e,t){return(t-e)/BC},function(e){return e.getUTCSeconds()}),Qet=HBt,trt=HBt.range});var UBt,qBt,GBt,WBt=M(()=>{fa();wf();UBt=Sr(function(e){e.setTime(Math.floor(e/Ps)*Ps)},function(e,t){e.setTime(+e+t*Ps)},function(e,t){return(t-e)/Ps},function(e){return e.getMinutes()}),qBt=UBt,GBt=UBt.range});var YBt,jBt,XBt,$Bt=M(()=>{fa();wf();YBt=Sr(function(e){var t=e.getTimezoneOffset()*Ps%bf;t<0&&(t+=bf),e.setTime(Math.floor((+e-t)/bf)*bf+t)},function(e,t){e.setTime(+e+t*bf)},function(e,t){return(t-e)/bf},function(e){return e.getHours()}),jBt=YBt,XBt=YBt.range});var KBt,ZBt,JBt,QBt=M(()=>{fa();wf();KBt=Sr(function(e){e.setHours(0,0,0,0)},function(e,t){e.setDate(e.getDate()+t)},function(e,t){return(t-e-(t.getTimezoneOffset()-e.getTimezoneOffset())*Ps)/F7},function(e){return e.getDate()-1}),ZBt=KBt,JBt=KBt.range});function pv(e){return Sr(function(t){t.setDate(t.getDate()-(t.getDay()+7-e)%7),t.setHours(0,0,0,0)},function(t,r){t.setDate(t.getDate()+r*7)},function(t,r){return(r-t-(r.getTimezoneOffset()-t.getTimezoneOffset())*Ps)/B7})}var H7,ert,rrt,nrt,irt,ort,art,srt,tHt,eHt,rHt,nHt,iHt,oHt,aHt=M(()=>{fa();wf();H7=pv(0),ert=pv(1),rrt=pv(2),nrt=pv(3),irt=pv(4),ort=pv(5),art=pv(6),srt=H7.range,tHt=ert.range,eHt=rrt.range,rHt=nrt.range,nHt=irt.range,iHt=ort.range,oHt=art.range});var sHt,lHt,cHt,uHt=M(()=>{fa();sHt=Sr(function(e){e.setDate(1),e.setHours(0,0,0,0)},function(e,t){e.setMonth(e.getMonth()+t)},function(e,t){return t.getMonth()-e.getMonth()+(t.getFullYear()-e.getFullYear())*12},function(e){return e.getMonth()}),lHt=sHt,cHt=sHt.range});var lrt,hHt,fHt,pHt=M(()=>{fa();lrt=Sr(function(e){e.setMonth(0,1),e.setHours(0,0,0,0)},function(e,t){e.setFullYear(e.getFullYear()+t)},function(e,t){return t.getFullYear()-e.getFullYear()},function(e){return e.getFullYear()});lrt.every=function(e){return!isFinite(e=Math.floor(e))||!(e>0)?null:Sr(function(t){t.setFullYear(Math.floor(t.getFullYear()/e)*e),t.setMonth(0,1),t.setHours(0,0,0,0)},function(t,r){t.setFullYear(t.getFullYear()+r*e)})};hHt=lrt,fHt=lrt.range});var dHt,mHt,gHt,_Ht=M(()=>{fa();wf();dHt=Sr(function(e){e.setUTCSeconds(0,0)},function(e,t){e.setTime(+e+t*Ps)},function(e,t){return(t-e)/Ps},function(e){return e.getUTCMinutes()}),mHt=dHt,gHt=dHt.range});var yHt,vHt,xHt,bHt=M(()=>{fa();wf();yHt=Sr(function(e){e.setUTCMinutes(0,0,0)},function(e,t){e.setTime(+e+t*bf)},function(e,t){return(t-e)/bf},function(e){return e.getUTCHours()}),vHt=yHt,xHt=yHt.range});var wHt,SHt,MHt,EHt=M(()=>{fa();wf();wHt=Sr(function(e){e.setUTCHours(0,0,0,0)},function(e,t){e.setUTCDate(e.getUTCDate()+t)},function(e,t){return(t-e)/F7},function(e){return e.getUTCDate()-1}),SHt=wHt,MHt=wHt.range});function dv(e){return Sr(function(t){t.setUTCDate(t.getUTCDate()-(t.getUTCDay()+7-e)%7),t.setUTCHours(0,0,0,0)},function(t,r){t.setUTCDate(t.getUTCDate()+r*7)},function(t,r){return(r-t)/B7})}var V7,crt,urt,hrt,frt,prt,drt,mrt,THt,CHt,AHt,PHt,IHt,LHt,kHt=M(()=>{fa();wf();V7=dv(0),crt=dv(1),urt=dv(2),hrt=dv(3),frt=dv(4),prt=dv(5),drt=dv(6),mrt=V7.range,THt=crt.range,CHt=urt.range,AHt=hrt.range,PHt=frt.range,IHt=prt.range,LHt=drt.range});var RHt,NHt,DHt,OHt=M(()=>{fa();RHt=Sr(function(e){e.setUTCDate(1),e.setUTCHours(0,0,0,0)},function(e,t){e.setUTCMonth(e.getUTCMonth()+t)},function(e,t){return t.getUTCMonth()-e.getUTCMonth()+(t.getUTCFullYear()-e.getUTCFullYear())*12},function(e){return e.getUTCMonth()}),NHt=RHt,DHt=RHt.range});var grt,zHt,FHt,BHt=M(()=>{fa();grt=Sr(function(e){e.setUTCMonth(0,1),e.setUTCHours(0,0,0,0)},function(e,t){e.setUTCFullYear(e.getUTCFullYear()+t)},function(e,t){return t.getUTCFullYear()-e.getUTCFullYear()},function(e){return e.getUTCFullYear()});grt.every=function(e){return!isFinite(e=Math.floor(e))||!(e>0)?null:Sr(function(t){t.setUTCFullYear(Math.floor(t.getUTCFullYear()/e)*e),t.setUTCMonth(0,1),t.setUTCHours(0,0,0,0)},function(t,r){t.setUTCFullYear(t.getUTCFullYear()+r*e)})};zHt=grt,FHt=grt.range});var HHt=M(()=>{fa();BBt();VBt();WBt();$Bt();QBt();aHt();uHt();pHt();_Ht();bHt();EHt();kHt();OHt();BHt()});function pa(e,t,r,n){function i(o){return e(o=arguments.length===0?new Date:new Date(+o)),o}return i.floor=function(o){return e(o=new Date(+o)),o},i.ceil=function(o){return e(o=new Date(o-1)),t(o,1),e(o),o},i.round=function(o){var a=i(o),s=i.ceil(o);return o-a<s-o?a:s},i.offset=function(o,a){return t(o=new Date(+o),a==null?1:Math.floor(a)),o},i.range=function(o,a,s){var l=[],c;if(o=i.ceil(o),s=s==null?1:Math.floor(s),!(o<a)||!(s>0))return l;do l.push(c=new Date(+o)),t(o,s),e(o);while(c<o&&o<a);return l},i.filter=function(o){return pa(function(a){if(a>=a)for(;e(a),!o(a);)a.setTime(a-1)},function(a,s){if(a>=a)if(s<0)for(;++s<=0;)for(;t(a,-1),!o(a););else for(;--s>=0;)for(;t(a,1),!o(a););})},r&&(i.count=function(o,a){return _rt.setTime(+o),yrt.setTime(+a),e(_rt),e(yrt),Math.floor(r(_rt,yrt))},i.every=function(o){return o=Math.floor(o),!isFinite(o)||!(o>0)?null:o>1?i.filter(n?function(a){return n(a)%o===0}:function(a){return i.count(0,a)%o===0}):i}),i}var _rt,yrt,mv=M(()=>{_rt=new Date,yrt=new Date});var U7,q7,G7,HC=M(()=>{U7=6e4,q7=864e5,G7=6048e5});var VHt,W7,RLe,UHt=M(()=>{mv();HC();VHt=pa(function(e){e.setHours(0,0,0,0)},function(e,t){e.setDate(e.getDate()+t)},function(e,t){return(t-e-(t.getTimezoneOffset()-e.getTimezoneOffset())*U7)/q7},function(e){return e.getDate()-1}),W7=VHt,RLe=VHt.range});function gv(e){return pa(function(t){t.setDate(t.getDate()-(t.getDay()+7-e)%7),t.setHours(0,0,0,0)},function(t,r){t.setDate(t.getDate()+r*7)},function(t,r){return(r-t-(r.getTimezoneOffset()-t.getTimezoneOffset())*U7)/G7})}var VC,Hw,qHt,GHt,Vw,WHt,YHt,jHt,NLe,DLe,OLe,zLe,FLe,BLe,XHt=M(()=>{mv();HC();VC=gv(0),Hw=gv(1),qHt=gv(2),GHt=gv(3),Vw=gv(4),WHt=gv(5),YHt=gv(6),jHt=VC.range,NLe=Hw.range,DLe=qHt.range,OLe=GHt.range,zLe=Vw.range,FLe=WHt.range,BLe=YHt.range});var vrt,_v,HLe,$Ht=M(()=>{mv();vrt=pa(function(e){e.setMonth(0,1),e.setHours(0,0,0,0)},function(e,t){e.setFullYear(e.getFullYear()+t)},function(e,t){return t.getFullYear()-e.getFullYear()},function(e){return e.getFullYear()});vrt.every=function(e){return!isFinite(e=Math.floor(e))||!(e>0)?null:pa(function(t){t.setFullYear(Math.floor(t.getFullYear()/e)*e),t.setMonth(0,1),t.setHours(0,0,0,0)},function(t,r){t.setFullYear(t.getFullYear()+r*e)})};_v=vrt,HLe=vrt.range});var KHt,Y7,VLe,ZHt=M(()=>{mv();HC();KHt=pa(function(e){e.setUTCHours(0,0,0,0)},function(e,t){e.setUTCDate(e.getUTCDate()+t)},function(e,t){return(t-e)/q7},function(e){return e.getUTCDate()-1}),Y7=KHt,VLe=KHt.range});function yv(e){return pa(function(t){t.setUTCDate(t.getUTCDate()-(t.getUTCDay()+7-e)%7),t.setUTCHours(0,0,0,0)},function(t,r){t.setUTCDate(t.getUTCDate()+r*7)},function(t,r){return(r-t)/G7})}var UC,Uw,JHt,QHt,qw,tVt,eVt,rVt,ULe,qLe,GLe,WLe,YLe,jLe,nVt=M(()=>{mv();HC();UC=yv(0),Uw=yv(1),JHt=yv(2),QHt=yv(3),qw=yv(4),tVt=yv(5),eVt=yv(6),rVt=UC.range,ULe=Uw.range,qLe=JHt.range,GLe=QHt.range,WLe=qw.range,YLe=tVt.range,jLe=eVt.range});var xrt,vv,XLe,iVt=M(()=>{mv();xrt=pa(function(e){e.setUTCMonth(0,1),e.setUTCHours(0,0,0,0)},function(e,t){e.setUTCFullYear(e.getUTCFullYear()+t)},function(e,t){return t.getUTCFullYear()-e.getUTCFullYear()},function(e){return e.getUTCFullYear()});xrt.every=function(e){return!isFinite(e=Math.floor(e))||!(e>0)?null:pa(function(t){t.setUTCFullYear(Math.floor(t.getUTCFullYear()/e)*e),t.setUTCMonth(0,1),t.setUTCHours(0,0,0,0)},function(t,r){t.setUTCFullYear(t.getUTCFullYear()+r*e)})};vv=xrt,XLe=xrt.range});var oVt=M(()=>{UHt();XHt();$Ht();ZHt();nVt();iVt()});function $Le(e){if(0<=e.y&&e.y<100){var t=new Date(-1,e.m,e.d,e.H,e.M,e.S,e.L);return t.setFullYear(e.y),t}return new Date(e.y,e.m,e.d,e.H,e.M,e.S,e.L)}function j7(e){if(0<=e.y&&e.y<100){var t=new Date(Date.UTC(-1,e.m,e.d,e.H,e.M,e.S,e.L));return t.setUTCFullYear(e.y),t}return new Date(Date.UTC(e.y,e.m,e.d,e.H,e.M,e.S,e.L))}function qC(e){return{y:e,m:0,d:1,H:0,M:0,S:0,L:0}}function YC(e){var t=e.dateTime,r=e.date,n=e.time,i=e.periods,o=e.days,a=e.shortDays,s=e.months,l=e.shortMonths,c=GC(i),u=WC(i),h=GC(o),f=WC(o),p=GC(a),d=WC(a),g=GC(s),_=WC(s),y=GC(l),x=WC(l),b={a:W,A:Z,b:rt,B:ot,c:null,d:cVt,e:cVt,f:vke,H:gke,I:_ke,j:yke,L:dVt,m:xke,M:bke,p:st,Q:fVt,s:pVt,S:wke,u:Ske,U:Mke,V:Eke,w:Tke,W:Cke,x:null,X:null,y:Ake,Y:Pke,Z:Ike,"%":hVt},S={a:St,A:bt,b:Mt,B:lt,c:null,d:uVt,e:uVt,f:Nke,H:Lke,I:kke,j:Rke,L:mVt,m:Dke,M:Oke,p:Kt,Q:fVt,s:pVt,S:zke,u:Fke,U:Bke,V:Hke,w:Vke,W:Uke,x:null,X:null,y:qke,Y:Gke,Z:Wke,"%":hVt},C={a:B,A:I,b:L,B:R,c:F,d:sVt,e:sVt,f:fke,H:lVt,I:lVt,j:lke,L:hke,m:ske,M:cke,p:D,Q:dke,s:mke,S:uke,u:tke,U:eke,V:rke,w:QLe,W:nke,x:z,X:U,y:oke,Y:ike,Z:ake,"%":pke};b.x=P(r,b),b.X=P(n,b),b.c=P(t,b),S.x=P(r,S),S.X=P(n,S),S.c=P(t,S);function P(_t,ct){return function(X){var et=[],dt=-1,q=0,pt=_t.length,ht,wt,kt;for(X instanceof Date||(X=new Date(+X));++dt<pt;)_t.charCodeAt(dt)===37&&(et.push(_t.slice(q,dt)),(wt=aVt[ht=_t.charAt(++dt)])!=null?ht=_t.charAt(++dt):wt=ht==="e"?" ":"0",(kt=ct[ht])&&(ht=kt(X,wt)),et.push(ht),q=dt+1);return et.push(_t.slice(q,dt)),et.join("")}}function k(_t,ct){return function(X){var et=qC(1900),dt=O(et,_t,X+="",0),q,pt;if(dt!=X.length)return null;if("Q"in et)return new Date(et.Q);if("p"in et&&(et.H=et.H%12+et.p*12),"V"in et){if(et.V<1||et.V>53)return null;"w"in et||(et.w=1),"Z"in et?(q=j7(qC(et.y)),pt=q.getUTCDay(),q=pt>4||pt===0?Uw.ceil(q):Uw(q),q=Y7.offset(q,(et.V-1)*7),et.y=q.getUTCFullYear(),et.m=q.getUTCMonth(),et.d=q.getUTCDate()+(et.w+6)%7):(q=ct(qC(et.y)),pt=q.getDay(),q=pt>4||pt===0?Hw.ceil(q):Hw(q),q=W7.offset(q,(et.V-1)*7),et.y=q.getFullYear(),et.m=q.getMonth(),et.d=q.getDate()+(et.w+6)%7)}else("W"in et||"U"in et)&&("w"in et||(et.w="u"in et?et.u%7:"W"in et?1:0),pt="Z"in et?j7(qC(et.y)).getUTCDay():ct(qC(et.y)).getDay(),et.m=0,et.d="W"in et?(et.w+6)%7+et.W*7-(pt+5)%7:et.w+et.U*7-(pt+6)%7);return"Z"in et?(et.H+=et.Z/100|0,et.M+=et.Z%100,j7(et)):ct(et)}}function O(_t,ct,X,et){for(var dt=0,q=ct.length,pt=X.length,ht,wt;dt<q;){if(et>=pt)return-1;if(ht=ct.charCodeAt(dt++),ht===37){if(ht=ct.charAt(dt++),wt=C[ht in aVt?ct.charAt(dt++):ht],!wt||(et=wt(_t,X,et))<0)return-1}else if(ht!=X.charCodeAt(et++))return-1}return et}function D(_t,ct,X){var et=c.exec(ct.slice(X));return et?(_t.p=u[et[0].toLowerCase()],X+et[0].length):-1}function B(_t,ct,X){var et=p.exec(ct.slice(X));return et?(_t.w=d[et[0].toLowerCase()],X+et[0].length):-1}function I(_t,ct,X){var et=h.exec(ct.slice(X));return et?(_t.w=f[et[0].toLowerCase()],X+et[0].length):-1}function L(_t,ct,X){var et=y.exec(ct.slice(X));return et?(_t.m=x[et[0].toLowerCase()],X+et[0].length):-1}function R(_t,ct,X){var et=g.exec(ct.slice(X));return et?(_t.m=_[et[0].toLowerCase()],X+et[0].length):-1}function F(_t,ct,X){return O(_t,t,ct,X)}function z(_t,ct,X){return O(_t,r,ct,X)}function U(_t,ct,X){return O(_t,n,ct,X)}function W(_t){return a[_t.getDay()]}function Z(_t){return o[_t.getDay()]}function rt(_t){return l[_t.getMonth()]}function ot(_t){return s[_t.getMonth()]}function st(_t){return i[+(_t.getHours()>=12)]}function St(_t){return a[_t.getUTCDay()]}function bt(_t){return o[_t.getUTCDay()]}function Mt(_t){return l[_t.getUTCMonth()]}function lt(_t){return s[_t.getUTCMonth()]}function Kt(_t){return i[+(_t.getUTCHours()>=12)]}return{format:function(_t){var ct=P(_t+="",b);return ct.toString=function(){return _t},ct},parse:function(_t){var ct=k(_t+="",$Le);return ct.toString=function(){return _t},ct},utcFormat:function(_t){var ct=P(_t+="",S);return ct.toString=function(){return _t},ct},utcParse:function(_t){var ct=k(_t,j7);return ct.toString=function(){return _t},ct}}}function gn(e,t,r){var n=e<0?"-":"",i=(n?-e:e)+"",o=i.length;return n+(o<r?new Array(r-o+1).join(t)+i:i)}function JLe(e){return e.replace(ZLe,"\\$&")}function GC(e){return new RegExp("^(?:"+e.map(JLe).join("|")+")","i")}function WC(e){for(var t={},r=-1,n=e.length;++r<n;)t[e[r].toLowerCase()]=r;return t}function QLe(e,t,r){var n=Vo.exec(t.slice(r,r+1));return n?(e.w=+n[0],r+n[0].length):-1}function tke(e,t,r){var n=Vo.exec(t.slice(r,r+1));return n?(e.u=+n[0],r+n[0].length):-1}function eke(e,t,r){var n=Vo.exec(t.slice(r,r+2));return n?(e.U=+n[0],r+n[0].length):-1}function rke(e,t,r){var n=Vo.exec(t.slice(r,r+2));return n?(e.V=+n[0],r+n[0].length):-1}function nke(e,t,r){var n=Vo.exec(t.slice(r,r+2));return n?(e.W=+n[0],r+n[0].length):-1}function ike(e,t,r){var n=Vo.exec(t.slice(r,r+4));return n?(e.y=+n[0],r+n[0].length):-1}function oke(e,t,r){var n=Vo.exec(t.slice(r,r+2));return n?(e.y=+n[0]+(+n[0]>68?1900:2e3),r+n[0].length):-1}function ake(e,t,r){var n=/^(Z)|([+-]\d\d)(?::?(\d\d))?/.exec(t.slice(r,r+6));return n?(e.Z=n[1]?0:-(n[2]+(n[3]||"00")),r+n[0].length):-1}function ske(e,t,r){var n=Vo.exec(t.slice(r,r+2));return n?(e.m=n[0]-1,r+n[0].length):-1}function sVt(e,t,r){var n=Vo.exec(t.slice(r,r+2));return n?(e.d=+n[0],r+n[0].length):-1}function lke(e,t,r){var n=Vo.exec(t.slice(r,r+3));return n?(e.m=0,e.d=+n[0],r+n[0].length):-1}function lVt(e,t,r){var n=Vo.exec(t.slice(r,r+2));return n?(e.H=+n[0],r+n[0].length):-1}function cke(e,t,r){var n=Vo.exec(t.slice(r,r+2));return n?(e.M=+n[0],r+n[0].length):-1}function uke(e,t,r){var n=Vo.exec(t.slice(r,r+2));return n?(e.S=+n[0],r+n[0].length):-1}function hke(e,t,r){var n=Vo.exec(t.slice(r,r+3));return n?(e.L=+n[0],r+n[0].length):-1}function fke(e,t,r){var n=Vo.exec(t.slice(r,r+6));return n?(e.L=Math.floor(n[0]/1e3),r+n[0].length):-1}function pke(e,t,r){var n=KLe.exec(t.slice(r,r+1));return n?r+n[0].length:-1}function dke(e,t,r){var n=Vo.exec(t.slice(r));return n?(e.Q=+n[0],r+n[0].length):-1}function mke(e,t,r){var n=Vo.exec(t.slice(r));return n?(e.Q=+n[0]*1e3,r+n[0].length):-1}function cVt(e,t){return gn(e.getDate(),t,2)}function gke(e,t){return gn(e.getHours(),t,2)}function _ke(e,t){return gn(e.getHours()%12||12,t,2)}function yke(e,t){return gn(1+W7.count(_v(e),e),t,3)}function dVt(e,t){return gn(e.getMilliseconds(),t,3)}function vke(e,t){return dVt(e,t)+"000"}function xke(e,t){return gn(e.getMonth()+1,t,2)}function bke(e,t){return gn(e.getMinutes(),t,2)}function wke(e,t){return gn(e.getSeconds(),t,2)}function Ske(e){var t=e.getDay();return t===0?7:t}function Mke(e,t){return gn(VC.count(_v(e),e),t,2)}function Eke(e,t){var r=e.getDay();return e=r>=4||r===0?Vw(e):Vw.ceil(e),gn(Vw.count(_v(e),e)+(_v(e).getDay()===4),t,2)}function Tke(e){return e.getDay()}function Cke(e,t){return gn(Hw.count(_v(e),e),t,2)}function Ake(e,t){return gn(e.getFullYear()%100,t,2)}function Pke(e,t){return gn(e.getFullYear()%1e4,t,4)}function Ike(e){var t=e.getTimezoneOffset();return(t>0?"-":(t*=-1,"+"))+gn(t/60|0,"0",2)+gn(t%60,"0",2)}function uVt(e,t){return gn(e.getUTCDate(),t,2)}function Lke(e,t){return gn(e.getUTCHours(),t,2)}function kke(e,t){return gn(e.getUTCHours()%12||12,t,2)}function Rke(e,t){return gn(1+Y7.count(vv(e),e),t,3)}function mVt(e,t){return gn(e.getUTCMilliseconds(),t,3)}function Nke(e,t){return mVt(e,t)+"000"}function Dke(e,t){return gn(e.getUTCMonth()+1,t,2)}function Oke(e,t){return gn(e.getUTCMinutes(),t,2)}function zke(e,t){return gn(e.getUTCSeconds(),t,2)}function Fke(e){var t=e.getUTCDay();return t===0?7:t}function Bke(e,t){return gn(UC.count(vv(e),e),t,2)}function Hke(e,t){var r=e.getUTCDay();return e=r>=4||r===0?qw(e):qw.ceil(e),gn(qw.count(vv(e),e)+(vv(e).getUTCDay()===4),t,2)}function Vke(e){return e.getUTCDay()}function Uke(e,t){return gn(Uw.count(vv(e),e),t,2)}function qke(e,t){return gn(e.getUTCFullYear()%100,t,2)}function Gke(e,t){return gn(e.getUTCFullYear()%1e4,t,4)}function Wke(){return"+0000"}function hVt(){return"%"}function fVt(e){return+e}function pVt(e){return Math.floor(+e/1e3)}var aVt,Vo,KLe,ZLe,brt=M(()=>{oVt();aVt={"-":"",_:" ",0:"0"},Vo=/^\s*\d+/,KLe=/^%/,ZLe=/[\\^$*+?|[\]().{}]/g});function X7(e){return Gw=YC(e),wrt=Gw.format,Srt=Gw.parse,jC=Gw.utcFormat,XC=Gw.utcParse,Gw}var Gw,wrt,Srt,jC,XC,$7=M(()=>{brt();X7({dateTime:"%x, %X",date:"%-m/%-d/%Y",time:"%-I:%M:%S %p",periods:["AM","PM"],days:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],shortDays:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],months:["January","February","March","April","May","June","July","August","September","October","November","December"],shortMonths:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]})});function Yke(e){return e.toISOString()}var Mrt,jke,gVt,Ert=M(()=>{$7();Mrt="%Y-%m-%dT%H:%M:%S.%LZ";jke=Date.prototype.toISOString?Yke:jC(Mrt),gVt=jke});function Xke(e){var t=new Date(e);return isNaN(t)?null:t}var $ke,_Vt,yVt=M(()=>{Ert();$7();$ke=+new Date("2000-01-01T00:00:00.000Z")?Xke:XC(Mrt),_Vt=$ke});var vVt=M(()=>{$7();brt();Ert();yVt()});function Yw(){return xv||(wVt(Kke),xv=JC.now()+J7)}function Kke(){xv=0}function bv(){this._call=this._time=this._next=null}function Crt(e,t,r){var n=new bv;return n.restart(e,t,r),n}function Art(){Yw(),++Ww;for(var e=K7,t;e;)(t=xv-e._time)>=0&&e._call.call(null,t),e=e._next;--Ww}function xVt(){xv=(Z7=JC.now())+J7,Ww=KC=0;try{Art()}finally{Ww=0,Jke(),xv=0}}function Zke(){var e=JC.now(),t=e-Z7;t>bVt&&(J7-=t,Z7=e)}function Jke(){for(var e,t=K7,r,n=1/0;t;)t._call?(n>t._time&&(n=t._time),e=t,t=t._next):(r=t._next,t._next=null,t=e?e._next=r:K7=r);ZC=e,Trt(n)}function Trt(e){if(!Ww){KC&&(KC=clearTimeout(KC));var t=e-xv;t>24?(e<1/0&&(KC=setTimeout(xVt,e-JC.now()-J7)),$C&&($C=clearInterval($C))):($C||(Z7=JC.now(),$C=setInterval(Zke,bVt)),Ww=1,wVt(xVt))}}var Ww,KC,$C,bVt,K7,ZC,Z7,xv,J7,JC,wVt,Q7=M(()=>{Ww=0,KC=0,$C=0,bVt=1e3,Z7=0,xv=0,J7=0,JC=typeof performance=="object"&&performance.now?performance:Date,wVt=typeof window=="object"&&window.requestAnimationFrame?window.requestAnimationFrame.bind(window):function(e){setTimeout(e,17)};bv.prototype=Crt.prototype={constructor:bv,restart:function(e,t,r){if(typeof e!="function")throw new TypeError("callback is not a function");r=(r==null?Yw():+r)+(t==null?0:+t),!this._next&&ZC!==this&&(ZC?ZC._next=this:K7=this,ZC=this),this._call=e,this._time=r,Trt()},stop:function(){this._call&&(this._call=null,this._time=1/0,Trt())}}});function SVt(e,t,r){var n=new bv;return t=t==null?0:+t,n.restart(function(i){n.stop(),e(i+t)},t,r),n}var MVt=M(()=>{Q7()});function EVt(e,t,r){var n=new bv,i=t;return t==null?(n.restart(e,t,r),n):(t=+t,r=r==null?Yw():+r,n.restart(function o(a){a+=i,n.restart(o,i+=t,r),e(a)},t,r),n)}var TVt=M(()=>{Q7()});var CVt=M(()=>{Q7();MVt();TVt()});var tz,Prt,Irt=M(()=>{tz="http://www.w3.org/1999/xhtml",Prt={svg:"http://www.w3.org/2000/svg",xhtml:tz,xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/"}});function ld(e){var t=e+="",r=t.indexOf(":");return r>=0&&(t=e.slice(0,r))!=="xmlns"&&(e=e.slice(r+1)),Prt.hasOwnProperty(t)?{space:Prt[t],local:e}:e}var ez=M(()=>{Irt()});function Qke(e){return function(){var t=this.ownerDocument,r=this.namespaceURI;return r===tz&&t.documentElement.namespaceURI===tz?t.createElement(e):t.createElementNS(r,e)}}function t8e(e){return function(){return this.ownerDocument.createElementNS(e.space,e.local)}}function rz(e){var t=ld(e);return(t.local?t8e:Qke)(t)}var Lrt=M(()=>{ez();Irt()});function e8e(){}function wv(e){return e==null?e8e:function(){return this.querySelector(e)}}var nz=M(()=>{});function AVt(e){typeof e!="function"&&(e=wv(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=new Array(a),l,c,u=0;u<a;++u)(l=o[u])&&(c=e.call(l,l.__data__,u,o))&&("__data__"in l&&(c.__data__=l.__data__),s[u]=c);return new no(n,this._parents)}var PVt=M(()=>{Sf();nz()});function r8e(){return[]}function QC(e){return e==null?r8e:function(){return this.querySelectorAll(e)}}var krt=M(()=>{});function IVt(e){typeof e!="function"&&(e=QC(e));for(var t=this._groups,r=t.length,n=[],i=[],o=0;o<r;++o)for(var a=t[o],s=a.length,l,c=0;c<s;++c)(l=a[c])&&(n.push(e.call(l,l.__data__,c,a)),i.push(l));return new no(n,i)}var LVt=M(()=>{Sf();krt()});function tA(e){return function(){return this.matches(e)}}var Rrt=M(()=>{});function kVt(e){typeof e!="function"&&(e=tA(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=[],l,c=0;c<a;++c)(l=o[c])&&e.call(l,l.__data__,c,o)&&s.push(l);return new no(n,this._parents)}var RVt=M(()=>{Sf();Rrt()});function iz(e){return new Array(e.length)}var Nrt=M(()=>{});function NVt(){return new no(this._enter||this._groups.map(iz),this._parents)}function eA(e,t){this.ownerDocument=e.ownerDocument,this.namespaceURI=e.namespaceURI,this._next=null,this._parent=e,this.__data__=t}var Drt=M(()=>{Nrt();Sf();eA.prototype={constructor:eA,appendChild:function(e){return this._parent.insertBefore(e,this._next)},insertBefore:function(e,t){return this._parent.insertBefore(e,t)},querySelector:function(e){return this._parent.querySelector(e)},querySelectorAll:function(e){return this._parent.querySelectorAll(e)}}});function DVt(e){return function(){return e}}var OVt=M(()=>{});function n8e(e,t,r,n,i,o){for(var a=0,s,l=t.length,c=o.length;a<c;++a)(s=t[a])?(s.__data__=o[a],n[a]=s):r[a]=new eA(e,o[a]);for(;a<l;++a)(s=t[a])&&(i[a]=s)}function i8e(e,t,r,n,i,o,a){var s,l,c={},u=t.length,h=o.length,f=new Array(u),p;for(s=0;s<u;++s)(l=t[s])&&(f[s]=p=zVt+a.call(l,l.__data__,s,t),p in c?i[s]=l:c[p]=l);for(s=0;s<h;++s)p=zVt+a.call(e,o[s],s,o),(l=c[p])?(n[s]=l,l.__data__=o[s],c[p]=null):r[s]=new eA(e,o[s]);for(s=0;s<u;++s)(l=t[s])&&c[f[s]]===l&&(i[s]=l)}function FVt(e,t){if(!e)return p=new Array(this.size()),c=-1,this.each(function(P){p[++c]=P}),p;var r=t?i8e:n8e,n=this._parents,i=this._groups;typeof e!="function"&&(e=DVt(e));for(var o=i.length,a=new Array(o),s=new Array(o),l=new Array(o),c=0;c<o;++c){var u=n[c],h=i[c],f=h.length,p=e.call(u,u&&u.__data__,c,n),d=p.length,g=s[c]=new Array(d),_=a[c]=new Array(d),y=l[c]=new Array(f);r(u,h,g,_,y,p,t);for(var x=0,b=0,S,C;x<d;++x)if(S=g[x]){for(x>=b&&(b=x+1);!(C=_[b])&&++b<d;);S._next=C||null}}return a=new no(a,n),a._enter=s,a._exit=l,a}var zVt,BVt=M(()=>{Sf();Drt();OVt();zVt="$"});function HVt(){return new no(this._exit||this._groups.map(iz),this._parents)}var VVt=M(()=>{Nrt();Sf()});function UVt(e,t,r){var n=this.enter(),i=this,o=this.exit();return n=typeof e=="function"?e(n):n.append(e+""),t!=null&&(i=t(i)),r==null?o.remove():r(o),n&&i?n.merge(i).order():i}var qVt=M(()=>{});function GVt(e){for(var t=this._groups,r=e._groups,n=t.length,i=r.length,o=Math.min(n,i),a=new Array(n),s=0;s<o;++s)for(var l=t[s],c=r[s],u=l.length,h=a[s]=new Array(u),f,p=0;p<u;++p)(f=l[p]||c[p])&&(h[p]=f);for(;s<n;++s)a[s]=t[s];return new no(a,this._parents)}var WVt=M(()=>{Sf()});function YVt(){for(var e=this._groups,t=-1,r=e.length;++t<r;)for(var n=e[t],i=n.length-1,o=n[i],a;--i>=0;)(a=n[i])&&(o&&a.compareDocumentPosition(o)^4&&o.parentNode.insertBefore(a,o),o=a);return this}var jVt=M(()=>{});function XVt(e){e||(e=o8e);function t(h,f){return h&&f?e(h.__data__,f.__data__):!h-!f}for(var r=this._groups,n=r.length,i=new Array(n),o=0;o<n;++o){for(var a=r[o],s=a.length,l=i[o]=new Array(s),c,u=0;u<s;++u)(c=a[u])&&(l[u]=c);l.sort(t)}return new no(i,this._parents).order()}function o8e(e,t){return e<t?-1:e>t?1:e>=t?0:NaN}var $Vt=M(()=>{Sf()});function KVt(){var e=arguments[0];return arguments[0]=this,e.apply(null,arguments),this}var ZVt=M(()=>{});function JVt(){var e=new Array(this.size()),t=-1;return this.each(function(){e[++t]=this}),e}var QVt=M(()=>{});function tUt(){for(var e=this._groups,t=0,r=e.length;t<r;++t)for(var n=e[t],i=0,o=n.length;i<o;++i){var a=n[i];if(a)return a}return null}var eUt=M(()=>{});function rUt(){var e=0;return this.each(function(){++e}),e}var nUt=M(()=>{});function iUt(){return!this.node()}var oUt=M(()=>{});function aUt(e){for(var t=this._groups,r=0,n=t.length;r<n;++r)for(var i=t[r],o=0,a=i.length,s;o<a;++o)(s=i[o])&&e.call(s,s.__data__,o,i);return this}var sUt=M(()=>{});function a8e(e){return function(){this.removeAttribute(e)}}function s8e(e){return function(){this.removeAttributeNS(e.space,e.local)}}function l8e(e,t){return function(){this.setAttribute(e,t)}}function c8e(e,t){return function(){this.setAttributeNS(e.space,e.local,t)}}function u8e(e,t){return function(){var r=t.apply(this,arguments);r==null?this.removeAttribute(e):this.setAttribute(e,r)}}function h8e(e,t){return function(){var r=t.apply(this,arguments);r==null?this.removeAttributeNS(e.space,e.local):this.setAttributeNS(e.space,e.local,r)}}function lUt(e,t){var r=ld(e);if(arguments.length<2){var n=this.node();return r.local?n.getAttributeNS(r.space,r.local):n.getAttribute(r)}return this.each((t==null?r.local?s8e:a8e:typeof t=="function"?r.local?h8e:u8e:r.local?c8e:l8e)(r,t))}var cUt=M(()=>{ez()});function oz(e){return e.ownerDocument&&e.ownerDocument.defaultView||e.document&&e||e.defaultView}var Ort=M(()=>{});function f8e(e){return function(){this.style.removeProperty(e)}}function p8e(e,t,r){return function(){this.style.setProperty(e,t,r)}}function d8e(e,t,r){return function(){var n=t.apply(this,arguments);n==null?this.style.removeProperty(e):this.style.setProperty(e,n,r)}}function uUt(e,t,r){return arguments.length>1?this.each((t==null?f8e:typeof t=="function"?d8e:p8e)(e,t,r==null?"":r)):Bg(this.node(),e)}function Bg(e,t){return e.style.getPropertyValue(t)||oz(e).getComputedStyle(e,null).getPropertyValue(t)}var zrt=M(()=>{Ort()});function m8e(e){return function(){delete this[e]}}function g8e(e,t){return function(){this[e]=t}}function _8e(e,t){return function(){var r=t.apply(this,arguments);r==null?delete this[e]:this[e]=r}}function hUt(e,t){return arguments.length>1?this.each((t==null?m8e:typeof t=="function"?_8e:g8e)(e,t)):this.node()[e]}var fUt=M(()=>{});function pUt(e){return e.trim().split(/^|\s+/)}function Frt(e){return e.classList||new dUt(e)}function dUt(e){this._node=e,this._names=pUt(e.getAttribute("class")||"")}function mUt(e,t){for(var r=Frt(e),n=-1,i=t.length;++n<i;)r.add(t[n])}function gUt(e,t){for(var r=Frt(e),n=-1,i=t.length;++n<i;)r.remove(t[n])}function y8e(e){return function(){mUt(this,e)}}function v8e(e){return function(){gUt(this,e)}}function x8e(e,t){return function(){(t.apply(this,arguments)?mUt:gUt)(this,e)}}function _Ut(e,t){var r=pUt(e+"");if(arguments.length<2){for(var n=Frt(this.node()),i=-1,o=r.length;++i<o;)if(!n.contains(r[i]))return!1;return!0}return this.each((typeof t=="function"?x8e:t?y8e:v8e)(r,t))}var yUt=M(()=>{dUt.prototype={add:function(e){var t=this._names.indexOf(e);t<0&&(this._names.push(e),this._node.setAttribute("class",this._names.join(" ")))},remove:function(e){var t=this._names.indexOf(e);t>=0&&(this._names.splice(t,1),this._node.setAttribute("class",this._names.join(" ")))},contains:function(e){return this._names.indexOf(e)>=0}}});function b8e(){this.textContent=""}function w8e(e){return function(){this.textContent=e}}function S8e(e){return function(){var t=e.apply(this,arguments);this.textContent=t==null?"":t}}function vUt(e){return arguments.length?this.each(e==null?b8e:(typeof e=="function"?S8e:w8e)(e)):this.node().textContent}var xUt=M(()=>{});function M8e(){this.innerHTML=""}function E8e(e){return function(){this.innerHTML=e}}function T8e(e){return function(){var t=e.apply(this,arguments);this.innerHTML=t==null?"":t}}function bUt(e){return arguments.length?this.each(e==null?M8e:(typeof e=="function"?T8e:E8e)(e)):this.node().innerHTML}var wUt=M(()=>{});function C8e(){this.nextSibling&&this.parentNode.appendChild(this)}function SUt(){return this.each(C8e)}var MUt=M(()=>{});function A8e(){this.previousSibling&&this.parentNode.insertBefore(this,this.parentNode.firstChild)}function EUt(){return this.each(A8e)}var TUt=M(()=>{});function CUt(e){var t=typeof e=="function"?e:rz(e);return this.select(function(){return this.appendChild(t.apply(this,arguments))})}var AUt=M(()=>{Lrt()});function P8e(){return null}function PUt(e,t){var r=typeof e=="function"?e:rz(e),n=t==null?P8e:typeof t=="function"?t:wv(t);return this.select(function(){return this.insertBefore(r.apply(this,arguments),n.apply(this,arguments)||null)})}var IUt=M(()=>{Lrt();nz()});function I8e(){var e=this.parentNode;e&&e.removeChild(this)}function LUt(){return this.each(I8e)}var kUt=M(()=>{});function L8e(){var e=this.cloneNode(!1),t=this.parentNode;return t?t.insertBefore(e,this.nextSibling):e}function k8e(){var e=this.cloneNode(!0),t=this.parentNode;return t?t.insertBefore(e,this.nextSibling):e}function RUt(e){return this.select(e?k8e:L8e)}var NUt=M(()=>{});function DUt(e){return arguments.length?this.property("__data__",e):this.node().__data__}var OUt=M(()=>{});function R8e(e,t,r){return e=BUt(e,t,r),function(n){var i=n.relatedTarget;(!i||i!==this&&!(i.compareDocumentPosition(this)&8))&&e.call(this,n)}}function BUt(e,t,r){return function(n){var i=Brt;Brt=n;try{e.call(this,this.__data__,t,r)}finally{Brt=i}}}function N8e(e){return e.trim().split(/^|\s+/).map(function(t){var r="",n=t.indexOf(".");return n>=0&&(r=t.slice(n+1),t=t.slice(0,n)),{type:t,name:r}})}function D8e(e){return function(){var t=this.__on;if(!!t){for(var r=0,n=-1,i=t.length,o;r<i;++r)o=t[r],(!e.type||o.type===e.type)&&o.name===e.name?this.removeEventListener(o.type,o.listener,o.capture):t[++n]=o;++n?t.length=n:delete this.__on}}}function O8e(e,t,r){var n=FUt.hasOwnProperty(e.type)?R8e:BUt;return function(i,o,a){var s=this.__on,l,c=n(t,o,a);if(s){for(var u=0,h=s.length;u<h;++u)if((l=s[u]).type===e.type&&l.name===e.name){this.removeEventListener(l.type,l.listener,l.capture),this.addEventListener(l.type,l.listener=c,l.capture=r),l.value=t;return}}this.addEventListener(e.type,c,r),l={type:e.type,name:e.name,value:t,listener:c,capture:r},s?s.push(l):this.__on=[l]}}function HUt(e,t,r){var n=N8e(e+""),i,o=n.length,a;if(arguments.length<2){var s=this.node().__on;if(s){for(var l=0,c=s.length,u;l<c;++l)for(i=0,u=s[l];i<o;++i)if((a=n[i]).type===u.type&&a.name===u.name)return u.value}return}for(s=t?O8e:D8e,r==null&&(r=!1),i=0;i<o;++i)this.each(s(n[i],t,r));return this}var FUt,Brt,zUt,VUt=M(()=>{FUt={},Brt=null;typeof document!="undefined"&&(zUt=document.documentElement,"onmouseenter"in zUt||(FUt={mouseenter:"mouseover",mouseleave:"mouseout"}))});function UUt(e,t,r){var n=oz(e),i=n.CustomEvent;typeof i=="function"?i=new i(t,r):(i=n.document.createEvent("Event"),r?(i.initEvent(t,r.bubbles,r.cancelable),i.detail=r.detail):i.initEvent(t,!1,!1)),e.dispatchEvent(i)}function z8e(e,t){return function(){return UUt(this,e,t)}}function F8e(e,t){return function(){return UUt(this,e,t.apply(this,arguments))}}function qUt(e,t){return this.each((typeof t=="function"?F8e:z8e)(e,t))}var GUt=M(()=>{Ort()});function no(e,t){this._groups=e,this._parents=t}function WUt(){return new no([[document.documentElement]],B8e)}var B8e,cd,Sf=M(()=>{PVt();LVt();RVt();BVt();Drt();VVt();qVt();WVt();jVt();$Vt();ZVt();QVt();eUt();nUt();oUt();sUt();cUt();zrt();fUt();yUt();xUt();wUt();MUt();TUt();AUt();IUt();kUt();NUt();OUt();VUt();GUt();B8e=[null];no.prototype=WUt.prototype={constructor:no,select:AVt,selectAll:IVt,filter:kVt,data:FVt,enter:NVt,exit:HVt,join:UVt,merge:GVt,order:YVt,sort:XVt,call:KVt,nodes:JVt,node:tUt,size:rUt,empty:iUt,each:aUt,attr:lUt,style:uUt,property:hUt,classed:_Ut,text:vUt,html:bUt,raise:SUt,lower:EUt,append:CUt,insert:PUt,remove:LUt,clone:RUt,datum:DUt,on:HUt,dispatch:qUt};cd=WUt});var Mf=M(()=>{Rrt();ez();Sf();nz();krt();zrt()});function jUt(){for(var e=0,t=arguments.length,r={},n;e<t;++e){if(!(n=arguments[e]+"")||n in r||/[\s.]/.test(n))throw new Error("illegal type: "+n);r[n]=[]}return new az(r)}function az(e){this._=e}function V8e(e,t){return e.trim().split(/^|\s+/).map(function(r){var n="",i=r.indexOf(".");if(i>=0&&(n=r.slice(i+1),r=r.slice(0,i)),r&&!t.hasOwnProperty(r))throw new Error("unknown type: "+r);return{type:r,name:n}})}function U8e(e,t){for(var r=0,n=e.length,i;r<n;++r)if((i=e[r]).name===t)return i.value}function YUt(e,t,r){for(var n=0,i=e.length;n<i;++n)if(e[n].name===t){e[n]=H8e,e=e.slice(0,n).concat(e.slice(n+1));break}return r!=null&&e.push({name:t,value:r}),e}var H8e,Hrt,XUt=M(()=>{H8e={value:function(){}};az.prototype=jUt.prototype={constructor:az,on:function(e,t){var r=this._,n=V8e(e+"",r),i,o=-1,a=n.length;if(arguments.length<2){for(;++o<a;)if((i=(e=n[o]).type)&&(i=U8e(r[i],e.name)))return i;return}if(t!=null&&typeof t!="function")throw new Error("invalid callback: "+t);for(;++o<a;)if(i=(e=n[o]).type)r[i]=YUt(r[i],e.name,t);else if(t==null)for(i in r)r[i]=YUt(r[i],e.name,null);return this},copy:function(){var e={},t=this._;for(var r in t)e[r]=t[r].slice();return new az(e)},call:function(e,t){if((i=arguments.length-2)>0)for(var r=new Array(i),n=0,i,o;n<i;++n)r[n]=arguments[n+2];if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(o=this._[e],n=0,i=o.length;n<i;++n)o[n].value.apply(t,r)},apply:function(e,t,r){if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(var n=this._[e],i=0,o=n.length;i<o;++i)n[i].value.apply(t,r)}};Hrt=jUt});var $Ut=M(()=>{XUt()});function Xw(){return Sv||(JUt(q8e),Sv=oA.now()+cz)}function q8e(){Sv=0}function aA(){this._call=this._time=this._next=null}function uz(e,t,r){var n=new aA;return n.restart(e,t,r),n}function QUt(){Xw(),++jw;for(var e=sz,t;e;)(t=Sv-e._time)>=0&&e._call.call(null,t),e=e._next;--jw}function KUt(){Sv=(lz=oA.now())+cz,jw=nA=0;try{QUt()}finally{jw=0,W8e(),Sv=0}}function G8e(){var e=oA.now(),t=e-lz;t>ZUt&&(cz-=t,lz=e)}function W8e(){for(var e,t=sz,r,n=1/0;t;)t._call?(n>t._time&&(n=t._time),e=t,t=t._next):(r=t._next,t._next=null,t=e?e._next=r:sz=r);iA=e,Vrt(n)}function Vrt(e){if(!jw){nA&&(nA=clearTimeout(nA));var t=e-Sv;t>24?(e<1/0&&(nA=setTimeout(KUt,e-oA.now()-cz)),rA&&(rA=clearInterval(rA))):(rA||(lz=oA.now(),rA=setInterval(G8e,ZUt)),jw=1,JUt(KUt))}}var jw,nA,rA,ZUt,sz,iA,lz,Sv,cz,oA,JUt,Urt=M(()=>{jw=0,nA=0,rA=0,ZUt=1e3,lz=0,Sv=0,cz=0,oA=typeof performance=="object"&&performance.now?performance:Date,JUt=typeof window=="object"&&window.requestAnimationFrame?window.requestAnimationFrame.bind(window):function(e){setTimeout(e,17)};aA.prototype=uz.prototype={constructor:aA,restart:function(e,t,r){if(typeof e!="function")throw new TypeError("callback is not a function");r=(r==null?Xw():+r)+(t==null?0:+t),!this._next&&iA!==this&&(iA?iA._next=this:sz=this,iA=this),this._call=e,this._time=r,Vrt()},stop:function(){this._call&&(this._call=null,this._time=1/0,Vrt())}}});function hz(e,t,r){var n=new aA;return t=t==null?0:+t,n.restart(function(i){n.stop(),e(i+t)},t,r),n}var tqt=M(()=>{Urt()});var qrt=M(()=>{Urt();tqt()});function Hg(e,t,r,n,i,o){var a=e.__transition;if(!a)e.__transition={};else if(r in a)return;X8e(e,r,{name:t,index:n,group:i,on:Y8e,tween:j8e,time:o.time,delay:o.delay,duration:o.duration,ease:o.ease,timer:null,state:rqt})}function cA(e,t){var r=io(e,t);if(r.state>rqt)throw new Error("too late; already scheduled");return r}function Du(e,t){var r=io(e,t);if(r.state>lA)throw new Error("too late; already started");return r}function io(e,t){var r=e.__transition;if(!r||!(r=r[t]))throw new Error("transition not found");return r}function X8e(e,t,r){var n=e.__transition,i;n[t]=r,r.timer=uz(o,0,r.time);function o(c){r.state=fz,r.timer.restart(a,r.delay,r.time),r.delay<=c&&a(c-r.delay)}function a(c){var u,h,f,p;if(r.state!==fz)return l();for(u in n)if(p=n[u],p.name===r.name){if(p.state===Grt)return hz(a);p.state===eqt?(p.state=sA,p.timer.stop(),p.on.call("interrupt",e,e.__data__,p.index,p.group),delete n[u]):+u<t&&(p.state=sA,p.timer.stop(),delete n[u])}if(hz(function(){r.state===Grt&&(r.state=eqt,r.timer.restart(s,r.delay,r.time),s(c))}),r.state=lA,r.on.call("start",e,e.__data__,r.index,r.group),r.state===lA){for(r.state=Grt,i=new Array(f=r.tween.length),u=0,h=-1;u<f;++u)(p=r.tween[u].value.call(e,e.__data__,r.index,r.group))&&(i[++h]=p);i.length=h+1}}function s(c){for(var u=c<r.duration?r.ease.call(null,c/r.duration):(r.timer.restart(l),r.state=pz,1),h=-1,f=i.length;++h<f;)i[h].call(null,u);r.state===pz&&(r.on.call("end",e,e.__data__,r.index,r.group),l())}function l(){r.state=sA,r.timer.stop(),delete n[t];for(var c in n)return;delete e.__transition}}var Y8e,j8e,rqt,fz,lA,Grt,eqt,pz,sA,Ac=M(()=>{$Ut();qrt();Y8e=Hrt("start","end","interrupt"),j8e=[],rqt=0,fz=1,lA=2,Grt=3,eqt=4,pz=5,sA=6});function dz(e,t){var r=e.__transition,n,i,o=!0,a;if(!!r){t=t==null?null:t+"";for(a in r){if((n=r[a]).name!==t){o=!1;continue}i=n.state>lA&&n.state<pz,n.state=sA,n.timer.stop(),i&&n.on.call("interrupt",e,e.__data__,n.index,n.group),delete r[a]}o&&delete e.__transition}}var Wrt=M(()=>{Ac()});function nqt(e){return this.each(function(){dz(this,e)})}var iqt=M(()=>{Wrt()});function mz(e,t,r){e.prototype=t.prototype=r,r.constructor=e}function Yrt(e,t){var r=Object.create(e.prototype);for(var n in t)r[n]=t[n];return r}var oqt=M(()=>{});function fA(){}function sqt(){return this.rgb().formatHex()}function rRe(){return pqt(this).formatHsl()}function lqt(){return this.rgb().formatRgb()}function Vg(e){var t,r;return e=(e+"").trim().toLowerCase(),(t=$8e.exec(e))?(r=t[1].length,t=parseInt(t[1],16),r===6?cqt(t):r===3?new ml(t>>8&15|t>>4&240,t>>4&15|t&240,(t&15)<<4|t&15,1):r===8?gz(t>>24&255,t>>16&255,t>>8&255,(t&255)/255):r===4?gz(t>>12&15|t>>8&240,t>>8&15|t>>4&240,t>>4&15|t&240,((t&15)<<4|t&15)/255):null):(t=K8e.exec(e))?new ml(t[1],t[2],t[3],1):(t=Z8e.exec(e))?new ml(t[1]*255/100,t[2]*255/100,t[3]*255/100,1):(t=J8e.exec(e))?gz(t[1],t[2],t[3],t[4]):(t=Q8e.exec(e))?gz(t[1]*255/100,t[2]*255/100,t[3]*255/100,t[4]):(t=tRe.exec(e))?fqt(t[1],t[2]/100,t[3]/100,1):(t=eRe.exec(e))?fqt(t[1],t[2]/100,t[3]/100,t[4]):aqt.hasOwnProperty(e)?cqt(aqt[e]):e==="transparent"?new ml(NaN,NaN,NaN,0):null}function cqt(e){return new ml(e>>16&255,e>>8&255,e&255,1)}function gz(e,t,r,n){return n<=0&&(e=t=r=NaN),new ml(e,t,r,n)}function nRe(e){return e instanceof fA||(e=Vg(e)),e?(e=e.rgb(),new ml(e.r,e.g,e.b,e.opacity)):new ml}function Kw(e,t,r,n){return arguments.length===1?nRe(e):new ml(e,t,r,n==null?1:n)}function ml(e,t,r,n){this.r=+e,this.g=+t,this.b=+r,this.opacity=+n}function uqt(){return"#"+jrt(this.r)+jrt(this.g)+jrt(this.b)}function hqt(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"rgb(":"rgba(")+Math.max(0,Math.min(255,Math.round(this.r)||0))+", "+Math.max(0,Math.min(255,Math.round(this.g)||0))+", "+Math.max(0,Math.min(255,Math.round(this.b)||0))+(e===1?")":", "+e+")")}function jrt(e){return e=Math.max(0,Math.min(255,Math.round(e)||0)),(e<16?"0":"")+e.toString(16)}function fqt(e,t,r,n){return n<=0?e=t=r=NaN:r<=0||r>=1?e=t=NaN:t<=0&&(e=NaN),new Ef(e,t,r,n)}function pqt(e){if(e instanceof Ef)return new Ef(e.h,e.s,e.l,e.opacity);if(e instanceof fA||(e=Vg(e)),!e)return new Ef;if(e instanceof Ef)return e;e=e.rgb();var t=e.r/255,r=e.g/255,n=e.b/255,i=Math.min(t,r,n),o=Math.max(t,r,n),a=NaN,s=o-i,l=(o+i)/2;return s?(t===o?a=(r-n)/s+(r<n)*6:r===o?a=(n-t)/s+2:a=(t-r)/s+4,s/=l<.5?o+i:2-o-i,a*=60):s=l>0&&l<1?0:a,new Ef(a,s,l,e.opacity)}function dqt(e,t,r,n){return arguments.length===1?pqt(e):new Ef(e,t,r,n==null?1:n)}function Ef(e,t,r,n){this.h=+e,this.s=+t,this.l=+r,this.opacity=+n}function Xrt(e,t,r){return(e<60?t+(r-t)*e/60:e<180?r:e<240?t+(r-t)*(240-e)/60:t)*255}var uA,_z,$w,hA,Tf,$8e,K8e,Z8e,J8e,Q8e,tRe,eRe,aqt,mqt=M(()=>{oqt();uA=.7,_z=1/uA,$w="\\s*([+-]?\\d+)\\s*",hA="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",Tf="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",$8e=/^#([0-9a-f]{3,8})$/,K8e=new RegExp("^rgb\\("+[$w,$w,$w]+"\\)$"),Z8e=new RegExp("^rgb\\("+[Tf,Tf,Tf]+"\\)$"),J8e=new RegExp("^rgba\\("+[$w,$w,$w,hA]+"\\)$"),Q8e=new RegExp("^rgba\\("+[Tf,Tf,Tf,hA]+"\\)$"),tRe=new RegExp("^hsl\\("+[hA,Tf,Tf]+"\\)$"),eRe=new RegExp("^hsla\\("+[hA,Tf,Tf,hA]+"\\)$"),aqt={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};mz(fA,Vg,{copy:function(e){return Object.assign(new this.constructor,this,e)},displayable:function(){return this.rgb().displayable()},hex:sqt,formatHex:sqt,formatHsl:rRe,formatRgb:lqt,toString:lqt});mz(ml,Kw,Yrt(fA,{brighter:function(e){return e=e==null?_z:Math.pow(_z,e),new ml(this.r*e,this.g*e,this.b*e,this.opacity)},darker:function(e){return e=e==null?uA:Math.pow(uA,e),new ml(this.r*e,this.g*e,this.b*e,this.opacity)},rgb:function(){return this},displayable:function(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:uqt,formatHex:uqt,formatRgb:hqt,toString:hqt}));mz(Ef,dqt,Yrt(fA,{brighter:function(e){return e=e==null?_z:Math.pow(_z,e),new Ef(this.h,this.s,this.l*e,this.opacity)},darker:function(e){return e=e==null?uA:Math.pow(uA,e),new Ef(this.h,this.s,this.l*e,this.opacity)},rgb:function(){var e=this.h%360+(this.h<0)*360,t=isNaN(e)||isNaN(this.s)?0:this.s,r=this.l,n=r+(r<.5?r:1-r)*t,i=2*r-n;return new ml(Xrt(e>=240?e-240:e+120,i,n),Xrt(e,i,n),Xrt(e<120?e+240:e-120,i,n),this.opacity)},displayable:function(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl:function(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"hsl(":"hsla(")+(this.h||0)+", "+(this.s||0)*100+"%, "+(this.l||0)*100+"%"+(e===1?")":", "+e+")")}}))});var $rt=M(()=>{mqt()});function Krt(e,t,r,n,i){var o=e*e,a=o*e;return((1-3*e+3*o-a)*t+(4-6*o+3*a)*r+(1+3*e+3*o-3*a)*n+a*i)/6}function gqt(e){var t=e.length-1;return function(r){var n=r<=0?r=0:r>=1?(r=1,t-1):Math.floor(r*t),i=e[n],o=e[n+1],a=n>0?e[n-1]:2*i-o,s=n<t-1?e[n+2]:2*o-i;return Krt((r-n/t)*t,a,i,o,s)}}var Zrt=M(()=>{});function _qt(e){var t=e.length;return function(r){var n=Math.floor(((r%=1)<0?++r:r)*t),i=e[(n+t-1)%t],o=e[n%t],a=e[(n+1)%t],s=e[(n+2)%t];return Krt((r-n/t)*t,i,o,a,s)}}var yqt=M(()=>{Zrt()});function Jrt(e){return function(){return e}}var vqt=M(()=>{});function iRe(e,t){return function(r){return e+r*t}}function oRe(e,t,r){return e=Math.pow(e,r),t=Math.pow(t,r)-e,r=1/r,function(n){return Math.pow(e+n*t,r)}}function xqt(e){return(e=+e)==1?yz:function(t,r){return r-t?oRe(t,r,e):Jrt(isNaN(t)?r:t)}}function yz(e,t){var r=t-e;return r?iRe(e,r):Jrt(isNaN(e)?t:e)}var bqt=M(()=>{vqt()});function wqt(e){return function(t){var r=t.length,n=new Array(r),i=new Array(r),o=new Array(r),a,s;for(a=0;a<r;++a)s=Kw(t[a]),n[a]=s.r||0,i[a]=s.g||0,o[a]=s.b||0;return n=e(n),i=e(i),o=e(o),s.opacity=1,function(l){return s.r=n(l),s.g=i(l),s.b=o(l),s+""}}}var vz,aRe,sRe,Sqt=M(()=>{$rt();Zrt();yqt();bqt();vz=function e(t){var r=xqt(t);function n(i,o){var a=r((i=Kw(i)).r,(o=Kw(o)).r),s=r(i.g,o.g),l=r(i.b,o.b),c=yz(i.opacity,o.opacity);return function(u){return i.r=a(u),i.g=s(u),i.b=l(u),i.opacity=c(u),i+""}}return n.gamma=e,n}(1);aRe=wqt(gqt),sRe=wqt(_qt)});function Pc(e,t){return e=+e,t=+t,function(r){return e*(1-r)+t*r}}var xz=M(()=>{});function lRe(e){return function(){return e}}function cRe(e){return function(t){return e(t)+""}}function ent(e,t){var r=tnt.lastIndex=Qrt.lastIndex=0,n,i,o,a=-1,s=[],l=[];for(e=e+"",t=t+"";(n=tnt.exec(e))&&(i=Qrt.exec(t));)(o=i.index)>r&&(o=t.slice(r,o),s[a]?s[a]+=o:s[++a]=o),(n=n[0])===(i=i[0])?s[a]?s[a]+=i:s[++a]=i:(s[++a]=null,l.push({i:a,x:Pc(n,i)})),r=Qrt.lastIndex;return r<t.length&&(o=t.slice(r),s[a]?s[a]+=o:s[++a]=o),s.length<2?l[0]?cRe(l[0].x):lRe(t):(t=l.length,function(c){for(var u=0,h;u<t;++u)s[(h=l[u]).i]=h.x(c);return s.join("")})}var tnt,Qrt,Mqt=M(()=>{xz();tnt=/[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,Qrt=new RegExp(tnt.source,"g")});function rnt(e,t,r,n,i,o){var a,s,l;return(a=Math.sqrt(e*e+t*t))&&(e/=a,t/=a),(l=e*r+t*n)&&(r-=e*l,n-=t*l),(s=Math.sqrt(r*r+n*n))&&(r/=s,n/=s,l/=s),e*n<t*r&&(e=-e,t=-t,l=-l,a=-a),{translateX:i,translateY:o,rotate:Math.atan2(t,e)*Eqt,skewX:Math.atan(l)*Eqt,scaleX:a,scaleY:s}}var Eqt,bz,Tqt=M(()=>{Eqt=180/Math.PI,bz={translateX:0,translateY:0,rotate:0,skewX:0,scaleX:1,scaleY:1}});function Aqt(e){return e==="none"?bz:(pA||(pA=document.createElement("DIV"),nnt=document.documentElement,Cqt=document.defaultView),pA.style.transform=e,e=Cqt.getComputedStyle(nnt.appendChild(pA),null).getPropertyValue("transform"),nnt.removeChild(pA),e=e.slice(7,-1).split(","),rnt(+e[0],+e[1],+e[2],+e[3],+e[4],+e[5]))}function Pqt(e){return e==null?bz:(wz||(wz=document.createElementNS("http://www.w3.org/2000/svg","g")),wz.setAttribute("transform",e),(e=wz.transform.baseVal.consolidate())?(e=e.matrix,rnt(e.a,e.b,e.c,e.d,e.e,e.f)):bz)}var pA,nnt,Cqt,wz,Iqt=M(()=>{Tqt()});function Lqt(e,t,r,n){function i(c){return c.length?c.pop()+" ":""}function o(c,u,h,f,p,d){if(c!==h||u!==f){var g=p.push("translate(",null,t,null,r);d.push({i:g-4,x:Pc(c,h)},{i:g-2,x:Pc(u,f)})}else(h||f)&&p.push("translate("+h+t+f+r)}function a(c,u,h,f){c!==u?(c-u>180?u+=360:u-c>180&&(c+=360),f.push({i:h.push(i(h)+"rotate(",null,n)-2,x:Pc(c,u)})):u&&h.push(i(h)+"rotate("+u+n)}function s(c,u,h,f){c!==u?f.push({i:h.push(i(h)+"skewX(",null,n)-2,x:Pc(c,u)}):u&&h.push(i(h)+"skewX("+u+n)}function l(c,u,h,f,p,d){if(c!==h||u!==f){var g=p.push(i(p)+"scale(",null,",",null,")");d.push({i:g-4,x:Pc(c,h)},{i:g-2,x:Pc(u,f)})}else(h!==1||f!==1)&&p.push(i(p)+"scale("+h+","+f+")")}return function(c,u){var h=[],f=[];return c=e(c),u=e(u),o(c.translateX,c.translateY,u.translateX,u.translateY,h,f),a(c.rotate,u.rotate,h,f),s(c.skewX,u.skewX,h,f),l(c.scaleX,c.scaleY,u.scaleX,u.scaleY,h,f),c=u=null,function(p){for(var d=-1,g=f.length,_;++d<g;)h[(_=f[d]).i]=_.x(p);return h.join("")}}}var int,ont,kqt=M(()=>{xz();Iqt();int=Lqt(Aqt,"px, ","px)","deg)"),ont=Lqt(Pqt,", ",")",")")});var Sz=M(()=>{xz();Mqt();kqt();Sqt()});function uRe(e,t){var r,n;return function(){var i=Du(this,e),o=i.tween;if(o!==r){n=r=o;for(var a=0,s=n.length;a<s;++a)if(n[a].name===t){n=n.slice(),n.splice(a,1);break}}i.tween=n}}function hRe(e,t,r){var n,i;if(typeof r!="function")throw new Error;return function(){var o=Du(this,e),a=o.tween;if(a!==n){i=(n=a).slice();for(var s={name:t,value:r},l=0,c=i.length;l<c;++l)if(i[l].name===t){i[l]=s;break}l===c&&i.push(s)}o.tween=i}}function Rqt(e,t){var r=this._id;if(e+="",arguments.length<2){for(var n=io(this.node(),r).tween,i=0,o=n.length,a;i<o;++i)if((a=n[i]).name===e)return a.value;return null}return this.each((t==null?uRe:hRe)(r,e,t))}function Zw(e,t,r){var n=e._id;return e.each(function(){var i=Du(this,n);(i.value||(i.value={}))[t]=r.apply(this,arguments)}),function(i){return io(i,n).value[t]}}var dA=M(()=>{Ac()});function Mz(e,t){var r;return(typeof t=="number"?Pc:t instanceof Vg?vz:(r=Vg(t))?(t=r,vz):ent)(e,t)}var ant=M(()=>{$rt();Sz()});function fRe(e){return function(){this.removeAttribute(e)}}function pRe(e){return function(){this.removeAttributeNS(e.space,e.local)}}function dRe(e,t,r){var n,i;return function(){var o=this.getAttribute(e);return o===r?null:o===n?i:i=t(n=o,r)}}function mRe(e,t,r){var n,i;return function(){var o=this.getAttributeNS(e.space,e.local);return o===r?null:o===n?i:i=t(n=o,r)}}function gRe(e,t,r){var n,i,o;return function(){var a,s=r(this);return s==null?void this.removeAttribute(e):(a=this.getAttribute(e),a===s?null:a===n&&s===i?o:o=t(n=a,i=s))}}function _Re(e,t,r){var n,i,o;return function(){var a,s=r(this);return s==null?void this.removeAttributeNS(e.space,e.local):(a=this.getAttributeNS(e.space,e.local),a===s?null:a===n&&s===i?o:o=t(n=a,i=s))}}function Nqt(e,t){var r=ld(e),n=r==="transform"?ont:Mz;return this.attrTween(e,typeof t=="function"?(r.local?_Re:gRe)(r,n,Zw(this,"attr."+e,t)):t==null?(r.local?pRe:fRe)(r):(r.local?mRe:dRe)(r,n,t+""))}var Dqt=M(()=>{Sz();Mf();dA();ant()});function yRe(e,t){function r(){var n=this,i=t.apply(n,arguments);return i&&function(o){n.setAttributeNS(e.space,e.local,i(o))}}return r._value=t,r}function vRe(e,t){function r(){var n=this,i=t.apply(n,arguments);return i&&function(o){n.setAttribute(e,i(o))}}return r._value=t,r}function Oqt(e,t){var r="attr."+e;if(arguments.length<2)return(r=this.tween(r))&&r._value;if(t==null)return this.tween(r,null);if(typeof t!="function")throw new Error;var n=ld(e);return this.tween(r,(n.local?yRe:vRe)(n,t))}var zqt=M(()=>{Mf()});function xRe(e,t){return function(){cA(this,e).delay=+t.apply(this,arguments)}}function bRe(e,t){return t=+t,function(){cA(this,e).delay=t}}function Fqt(e){var t=this._id;return arguments.length?this.each((typeof e=="function"?xRe:bRe)(t,e)):io(this.node(),t).delay}var Bqt=M(()=>{Ac()});function wRe(e,t){return function(){Du(this,e).duration=+t.apply(this,arguments)}}function SRe(e,t){return t=+t,function(){Du(this,e).duration=t}}function Hqt(e){var t=this._id;return arguments.length?this.each((typeof e=="function"?wRe:SRe)(t,e)):io(this.node(),t).duration}var Vqt=M(()=>{Ac()});function MRe(e,t){if(typeof t!="function")throw new Error;return function(){Du(this,e).ease=t}}function Uqt(e){var t=this._id;return arguments.length?this.each(MRe(t,e)):io(this.node(),t).ease}var qqt=M(()=>{Ac()});function Gqt(e){typeof e!="function"&&(e=tA(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=[],l,c=0;c<a;++c)(l=o[c])&&e.call(l,l.__data__,c,o)&&s.push(l);return new Uo(n,this._parents,this._name,this._id)}var Wqt=M(()=>{Mf();ud()});function Yqt(e){if(e._id!==this._id)throw new Error;for(var t=this._groups,r=e._groups,n=t.length,i=r.length,o=Math.min(n,i),a=new Array(n),s=0;s<o;++s)for(var l=t[s],c=r[s],u=l.length,h=a[s]=new Array(u),f,p=0;p<u;++p)(f=l[p]||c[p])&&(h[p]=f);for(;s<n;++s)a[s]=t[s];return new Uo(a,this._parents,this._name,this._id)}var jqt=M(()=>{ud()});function ERe(e){return(e+"").trim().split(/^|\s+/).every(function(t){var r=t.indexOf(".");return r>=0&&(t=t.slice(0,r)),!t||t==="start"})}function TRe(e,t,r){var n,i,o=ERe(t)?cA:Du;return function(){var a=o(this,e),s=a.on;s!==n&&(i=(n=s).copy()).on(t,r),a.on=i}}function Xqt(e,t){var r=this._id;return arguments.length<2?io(this.node(),r).on.on(e):this.each(TRe(r,e,t))}var $qt=M(()=>{Ac()});function CRe(e){return function(){var t=this.parentNode;for(var r in this.__transition)if(+r!==e)return;t&&t.removeChild(this)}}function Kqt(){return this.on("end.remove",CRe(this._id))}var Zqt=M(()=>{});function Jqt(e){var t=this._name,r=this._id;typeof e!="function"&&(e=wv(e));for(var n=this._groups,i=n.length,o=new Array(i),a=0;a<i;++a)for(var s=n[a],l=s.length,c=o[a]=new Array(l),u,h,f=0;f<l;++f)(u=s[f])&&(h=e.call(u,u.__data__,f,s))&&("__data__"in u&&(h.__data__=u.__data__),c[f]=h,Hg(c[f],t,r,f,c,io(u,r)));return new Uo(o,this._parents,t,r)}var Qqt=M(()=>{Mf();ud();Ac()});function tGt(e){var t=this._name,r=this._id;typeof e!="function"&&(e=QC(e));for(var n=this._groups,i=n.length,o=[],a=[],s=0;s<i;++s)for(var l=n[s],c=l.length,u,h=0;h<c;++h)if(u=l[h]){for(var f=e.call(u,u.__data__,h,l),p,d=io(u,r),g=0,_=f.length;g<_;++g)(p=f[g])&&Hg(p,t,r,g,f,d);o.push(f),a.push(u)}return new Uo(o,a,t,r)}var eGt=M(()=>{Mf();ud();Ac()});function rGt(){return new ARe(this._groups,this._parents)}var ARe,nGt=M(()=>{Mf();ARe=cd.prototype.constructor});function PRe(e,t){var r,n,i;return function(){var o=Bg(this,e),a=(this.style.removeProperty(e),Bg(this,e));return o===a?null:o===r&&a===n?i:i=t(r=o,n=a)}}function IRe(e){return function(){this.style.removeProperty(e)}}function LRe(e,t,r){var n,i;return function(){var o=Bg(this,e);return o===r?null:o===n?i:i=t(n=o,r)}}function kRe(e,t,r){var n,i,o;return function(){var a=Bg(this,e),s=r(this);return s==null&&(s=(this.style.removeProperty(e),Bg(this,e))),a===s?null:a===n&&s===i?o:o=t(n=a,i=s)}}function iGt(e,t,r){var n=(e+="")=="transform"?int:Mz;return t==null?this.styleTween(e,PRe(e,n)).on("end.style."+e,IRe(e)):this.styleTween(e,typeof t=="function"?kRe(e,n,Zw(this,"style."+e,t)):LRe(e,n,t+""),r)}var oGt=M(()=>{Sz();Mf();dA();ant()});function RRe(e,t,r){function n(){var i=this,o=t.apply(i,arguments);return o&&function(a){i.style.setProperty(e,o(a),r)}}return n._value=t,n}function aGt(e,t,r){var n="style."+(e+="");if(arguments.length<2)return(n=this.tween(n))&&n._value;if(t==null)return this.tween(n,null);if(typeof t!="function")throw new Error;return this.tween(n,RRe(e,t,r==null?"":r))}var sGt=M(()=>{});function NRe(e){return function(){this.textContent=e}}function DRe(e){return function(){var t=e(this);this.textContent=t==null?"":t}}function lGt(e){return this.tween("text",typeof e=="function"?DRe(Zw(this,"text",e)):NRe(e==null?"":e+""))}var cGt=M(()=>{dA()});function uGt(){for(var e=this._name,t=this._id,r=Ez(),n=this._groups,i=n.length,o=0;o<i;++o)for(var a=n[o],s=a.length,l,c=0;c<s;++c)if(l=a[c]){var u=io(l,t);Hg(l,e,r,c,a,{time:u.time+u.delay+u.duration,delay:0,duration:u.duration,ease:u.ease})}return new Uo(n,this._parents,e,r)}var hGt=M(()=>{ud();Ac()});function Uo(e,t,r,n){this._groups=e,this._parents=t,this._name=r,this._id=n}function Tz(e){return cd().transition(e)}function Ez(){return++ORe}var ORe,Jw,ud=M(()=>{Mf();Dqt();zqt();Bqt();Vqt();qqt();Wqt();jqt();$qt();Zqt();Qqt();eGt();nGt();oGt();sGt();cGt();hGt();dA();ORe=0;Jw=cd.prototype;Uo.prototype=Tz.prototype={constructor:Uo,select:Jqt,selectAll:tGt,filter:Gqt,merge:Yqt,selection:rGt,transition:uGt,call:Jw.call,nodes:Jw.nodes,node:Jw.node,size:Jw.size,empty:Jw.empty,each:Jw.each,on:Xqt,attr:Nqt,attrTween:Oqt,style:iGt,styleTween:aGt,text:lGt,remove:Kqt,tween:Rqt,delay:Fqt,duration:Hqt,ease:Uqt}});function zRe(e,t){for(var r;!(r=e.__transition)||!(r=r[t]);)if(!(e=e.parentNode))return snt.time=Xw(),snt;return r}function fGt(e){var t,r;e instanceof Uo?(t=e._id,e=e._name):(t=Ez(),(r=snt).time=Xw(),e=e==null?null:e+"");for(var n=this._groups,i=n.length,o=0;o<i;++o)for(var a=n[o],s=a.length,l,c=0;c<s;++c)(l=a[c])&&Hg(l,e,t,c,a,r||zRe(l,t));return new Uo(n,this._parents,e,t)}var snt,pGt=M(()=>{ud();Ac();I_();qrt();snt={time:null,delay:0,duration:250,ease:xs}});var dGt=M(()=>{Mf();iqt();pGt();cd.prototype.interrupt=nqt;cd.prototype.transition=fGt});function mGt(e,t){var r=e.__transition,n,i;if(r){t=t==null?null:t+"";for(i in r)if((n=r[i]).state>fz&&n.name===t)return new Uo([[e]],FRe,t,+i)}return null}var FRe,gGt=M(()=>{ud();Ac();FRe=[null]});var _Gt=M(()=>{dGt();ud();gGt();Wrt()});function lnt(e){return function(){return e}}var yGt=M(()=>{});function vGt(e){return e[0]}function xGt(e){return e[1]}var bGt=M(()=>{});function cnt(){this._=null}function Qw(e){e.U=e.C=e.L=e.R=e.P=e.N=null}function mA(e,t){var r=t,n=t.R,i=r.U;i?i.L===r?i.L=n:i.R=n:e._=n,n.U=i,r.U=n,r.R=n.L,r.R&&(r.R.U=r),n.L=r}function gA(e,t){var r=t,n=t.L,i=r.U;i?i.L===r?i.L=n:i.R=n:e._=n,n.U=i,r.U=n,r.L=n.R,r.L&&(r.L.U=r),n.R=r}function wGt(e){for(;e.L;)e=e.L;return e}var unt,Cz=M(()=>{cnt.prototype={constructor:cnt,insert:function(e,t){var r,n,i;if(e){if(t.P=e,t.N=e.N,e.N&&(e.N.P=t),e.N=t,e.R){for(e=e.R;e.L;)e=e.L;e.L=t}else e.R=t;r=e}else this._?(e=wGt(this._),t.P=null,t.N=e,e.P=e.L=t,r=e):(t.P=t.N=null,this._=t,r=null);for(t.L=t.R=null,t.U=r,t.C=!0,e=t;r&&r.C;)n=r.U,r===n.L?(i=n.R,i&&i.C?(r.C=i.C=!1,n.C=!0,e=n):(e===r.R&&(mA(this,r),e=r,r=e.U),r.C=!1,n.C=!0,gA(this,n))):(i=n.L,i&&i.C?(r.C=i.C=!1,n.C=!0,e=n):(e===r.L&&(gA(this,r),e=r,r=e.U),r.C=!1,n.C=!0,mA(this,n))),r=e.U;this._.C=!1},remove:function(e){e.N&&(e.N.P=e.P),e.P&&(e.P.N=e.N),e.N=e.P=null;var t=e.U,r,n=e.L,i=e.R,o,a;if(n?i?o=wGt(i):o=n:o=i,t?t.L===e?t.L=o:t.R=o:this._=o,n&&i?(a=o.C,o.C=e.C,o.L=n,n.U=o,o!==i?(t=o.U,o.U=e.U,e=o.R,t.L=e,o.R=i,i.U=o):(o.U=t,t=o,e=o.R)):(a=e.C,e=o),e&&(e.U=t),!a){if(e&&e.C){e.C=!1;return}do{if(e===this._)break;if(e===t.L){if(r=t.R,r.C&&(r.C=!1,t.C=!0,mA(this,t),r=t.R),r.L&&r.L.C||r.R&&r.R.C){(!r.R||!r.R.C)&&(r.L.C=!1,r.C=!0,gA(this,r),r=t.R),r.C=t.C,t.C=r.R.C=!1,mA(this,t),e=this._;break}}else if(r=t.L,r.C&&(r.C=!1,t.C=!0,gA(this,t),r=t.L),r.L&&r.L.C||r.R&&r.R.C){(!r.L||!r.L.C)&&(r.R.C=!1,r.C=!0,mA(this,r),r=t.L),r.C=t.C,t.C=r.L.C=!1,gA(this,t),e=this._;break}r.C=!0,e=t,t=t.U}while(!e.C);e&&(e.C=!1)}}};unt=cnt});function tS(e,t,r,n){var i=[null,null],o=Ao.push(i)-1;return i.left=e,i.right=t,r&&_A(i,e,t,r),n&&_A(i,t,e,n),Za[e.index].halfedges.push(o),Za[t.index].halfedges.push(o),i}function eS(e,t,r){var n=[t,r];return n.left=e,n}function _A(e,t,r,n){!e[0]&&!e[1]?(e[0]=n,e.left=t,e.right=r):e.left===r?e[1]=n:e[0]=n}function BRe(e,t,r,n,i){var o=e[0],a=e[1],s=o[0],l=o[1],c=a[0],u=a[1],h=0,f=1,p=c-s,d=u-l,g;if(g=t-s,!(!p&&g>0)){if(g/=p,p<0){if(g<h)return;g<f&&(f=g)}else if(p>0){if(g>f)return;g>h&&(h=g)}if(g=n-s,!(!p&&g<0)){if(g/=p,p<0){if(g>f)return;g>h&&(h=g)}else if(p>0){if(g<h)return;g<f&&(f=g)}if(g=r-l,!(!d&&g>0)){if(g/=d,d<0){if(g<h)return;g<f&&(f=g)}else if(d>0){if(g>f)return;g>h&&(h=g)}if(g=i-l,!(!d&&g<0)){if(g/=d,d<0){if(g>f)return;g>h&&(h=g)}else if(d>0){if(g<h)return;g<f&&(f=g)}return!(h>0)&&!(f<1)||(h>0&&(e[0]=[s+h*p,l+h*d]),f<1&&(e[1]=[s+f*p,l+f*d])),!0}}}}}function HRe(e,t,r,n,i){var o=e[1];if(o)return!0;var a=e[0],s=e.left,l=e.right,c=s[0],u=s[1],h=l[0],f=l[1],p=(c+h)/2,d=(u+f)/2,g,_;if(f===u){if(p<t||p>=n)return;if(c>h){if(!a)a=[p,r];else if(a[1]>=i)return;o=[p,i]}else{if(!a)a=[p,i];else if(a[1]<r)return;o=[p,r]}}else if(g=(c-h)/(f-u),_=d-g*p,g<-1||g>1)if(c>h){if(!a)a=[(r-_)/g,r];else if(a[1]>=i)return;o=[(i-_)/g,i]}else{if(!a)a=[(i-_)/g,i];else if(a[1]<r)return;o=[(r-_)/g,r]}else if(u<f){if(!a)a=[t,g*t+_];else if(a[0]>=n)return;o=[n,g*n+_]}else{if(!a)a=[n,g*n+_];else if(a[0]<t)return;o=[t,g*t+_]}return e[0]=a,e[1]=o,!0}function SGt(e,t,r,n){for(var i=Ao.length,o;i--;)(!HRe(o=Ao[i],e,t,r,n)||!BRe(o,e,t,r,n)||!(Math.abs(o[0][0]-o[1][0])>Wr||Math.abs(o[0][1]-o[1][1])>Wr))&&delete Ao[i]}var Az=M(()=>{rS()});function MGt(e){return Za[e.index]={site:e,halfedges:[]}}function VRe(e,t){var r=e.site,n=t.left,i=t.right;return r===i&&(i=n,n=r),i?Math.atan2(i[1]-n[1],i[0]-n[0]):(r===n?(n=t[1],i=t[0]):(n=t[0],i=t[1]),Math.atan2(n[0]-i[0],i[1]-n[1]))}function hnt(e,t){return t[+(t.left!==e.site)]}function URe(e,t){return t[+(t.left===e.site)]}function EGt(){for(var e=0,t=Za.length,r,n,i,o;e<t;++e)if((r=Za[e])&&(o=(n=r.halfedges).length)){var a=new Array(o),s=new Array(o);for(i=0;i<o;++i)a[i]=i,s[i]=VRe(r,Ao[n[i]]);for(a.sort(function(l,c){return s[c]-s[l]}),i=0;i<o;++i)s[i]=n[a[i]];for(i=0;i<o;++i)n[i]=s[i]}}function TGt(e,t,r,n){var i=Za.length,o,a,s,l,c,u,h,f,p,d,g,_,y=!0;for(o=0;o<i;++o)if(a=Za[o]){for(s=a.site,c=a.halfedges,l=c.length;l--;)Ao[c[l]]||c.splice(l,1);for(l=0,u=c.length;l<u;)d=URe(a,Ao[c[l]]),g=d[0],_=d[1],h=hnt(a,Ao[c[++l%u]]),f=h[0],p=h[1],(Math.abs(g-f)>Wr||Math.abs(_-p)>Wr)&&(c.splice(l,0,Ao.push(eS(s,d,Math.abs(g-e)<Wr&&n-_>Wr?[e,Math.abs(f-e)<Wr?p:n]:Math.abs(_-n)<Wr&&r-g>Wr?[Math.abs(p-n)<Wr?f:r,n]:Math.abs(g-r)<Wr&&_-t>Wr?[r,Math.abs(f-r)<Wr?p:t]:Math.abs(_-t)<Wr&&g-e>Wr?[Math.abs(p-t)<Wr?f:e,t]:null))-1),++u);u&&(y=!1)}if(y){var x,b,S,C=1/0;for(o=0,y=null;o<i;++o)(a=Za[o])&&(s=a.site,x=s[0]-e,b=s[1]-t,S=x*x+b*b,S<C&&(C=S,y=a));if(y){var P=[e,t],k=[e,n],O=[r,n],D=[r,t];y.halfedges.push(Ao.push(eS(s=y.site,P,k))-1,Ao.push(eS(s,k,O))-1,Ao.push(eS(s,O,D))-1,Ao.push(eS(s,D,P))-1)}}for(o=0;o<i;++o)(a=Za[o])&&(a.halfedges.length||delete Za[o])}var fnt=M(()=>{Az();rS()});function qRe(){Qw(this),this.x=this.y=this.arc=this.site=this.cy=null}function Mv(e){var t=e.P,r=e.N;if(!(!t||!r)){var n=t.site,i=e.site,o=r.site;if(n!==o){var a=i[0],s=i[1],l=n[0]-a,c=n[1]-s,u=o[0]-a,h=o[1]-s,f=2*(l*h-c*u);if(!(f>=-AGt)){var p=l*l+c*c,d=u*u+h*h,g=(h*p-c*d)/f,_=(l*d-u*p)/f,y=CGt.pop()||new qRe;y.arc=e,y.site=i,y.x=g+a,y.y=(y.cy=_+s)+Math.sqrt(g*g+_*_),e.circle=y;for(var x=null,b=nS._;b;)if(y.y<b.y||y.y===b.y&&y.x<=b.x)if(b.L)b=b.L;else{x=b.P;break}else if(b.R)b=b.R;else{x=b;break}nS.insert(x,y),x||(Pz=y)}}}}function Ev(e){var t=e.circle;t&&(t.P||(Pz=t.N),nS.remove(t),CGt.push(t),Qw(t),e.circle=null)}var CGt,Pz,pnt=M(()=>{Cz();rS();CGt=[]});function GRe(){Qw(this),this.edge=this.site=this.circle=null}function PGt(e){var t=IGt.pop()||new GRe;return t.site=e,t}function dnt(e){Ev(e),Tv.remove(e),IGt.push(e),Qw(e)}function LGt(e){var t=e.circle,r=t.x,n=t.cy,i=[r,n],o=e.P,a=e.N,s=[e];dnt(e);for(var l=o;l.circle&&Math.abs(r-l.circle.x)<Wr&&Math.abs(n-l.circle.cy)<Wr;)o=l.P,s.unshift(l),dnt(l),l=o;s.unshift(l),Ev(l);for(var c=a;c.circle&&Math.abs(r-c.circle.x)<Wr&&Math.abs(n-c.circle.cy)<Wr;)a=c.N,s.push(c),dnt(c),c=a;s.push(c),Ev(c);var u=s.length,h;for(h=1;h<u;++h)c=s[h],l=s[h-1],_A(c.edge,l.site,c.site,i);l=s[0],c=s[u-1],c.edge=tS(l.site,c.site,null,i),Mv(l),Mv(c)}function kGt(e){for(var t=e[0],r=e[1],n,i,o,a,s=Tv._;s;)if(o=RGt(s,r)-t,o>Wr)s=s.L;else if(a=t-WRe(s,r),a>Wr){if(!s.R){n=s;break}s=s.R}else{o>-Wr?(n=s.P,i=s):a>-Wr?(n=s,i=s.N):n=i=s;break}MGt(e);var l=PGt(e);if(Tv.insert(n,l),!(!n&&!i)){if(n===i){Ev(n),i=PGt(n.site),Tv.insert(l,i),l.edge=i.edge=tS(n.site,l.site),Mv(n),Mv(i);return}if(!i){l.edge=tS(n.site,l.site);return}Ev(n),Ev(i);var c=n.site,u=c[0],h=c[1],f=e[0]-u,p=e[1]-h,d=i.site,g=d[0]-u,_=d[1]-h,y=2*(f*_-p*g),x=f*f+p*p,b=g*g+_*_,S=[(_*x-p*b)/y+u,(f*b-g*x)/y+h];_A(i.edge,c,d,S),l.edge=tS(c,e,null,S),i.edge=tS(e,d,null,S),Mv(n),Mv(i)}}function RGt(e,t){var r=e.site,n=r[0],i=r[1],o=i-t;if(!o)return n;var a=e.P;if(!a)return-1/0;r=a.site;var s=r[0],l=r[1],c=l-t;if(!c)return s;var u=s-n,h=1/o-1/c,f=u/c;return h?(-f+Math.sqrt(f*f-2*h*(u*u/(-2*c)-l+c/2+i-o/2)))/h+n:(n+s)/2}function WRe(e,t){var r=e.N;if(r)return RGt(r,t);var n=e.site;return n[1]===t?n[0]:1/0}var IGt,NGt=M(()=>{Cz();fnt();pnt();Az();rS();IGt=[]});function YRe(e,t,r){return(e[0]-r[0])*(t[1]-e[1])-(e[0]-t[0])*(r[1]-e[1])}function jRe(e,t){return t[1]-e[1]||t[0]-e[0]}function yA(e,t){var r=e.sort(jRe).pop(),n,i,o;for(Ao=[],Za=new Array(e.length),Tv=new unt,nS=new unt;;)if(o=Pz,r&&(!o||r[1]<o.y||r[1]===o.y&&r[0]<o.x))(r[0]!==n||r[1]!==i)&&(kGt(r),n=r[0],i=r[1]),r=e.pop();else if(o)LGt(o.arc);else break;if(EGt(),t){var a=+t[0][0],s=+t[0][1],l=+t[1][0],c=+t[1][1];SGt(a,s,l,c),TGt(a,s,l,c)}this.edges=Ao,this.cells=Za,Tv=nS=Ao=Za=null}var Wr,AGt,Tv,Za,nS,Ao,rS=M(()=>{NGt();fnt();pnt();Az();Cz();Wr=1e-6,AGt=1e-12;yA.prototype={constructor:yA,polygons:function(){var e=this.edges;return this.cells.map(function(t){var r=t.halfedges.map(function(n){return hnt(t,e[n])});return r.data=t.site.data,r})},triangles:function(){var e=[],t=this.edges;return this.cells.forEach(function(r,n){if(!!(s=(o=r.halfedges).length))for(var i=r.site,o,a=-1,s,l,c=t[o[s-1]],u=c.left===i?c.right:c.left;++a<s;)l=u,c=t[o[a]],u=c.left===i?c.right:c.left,l&&u&&n<l.index&&n<u.index&&YRe(i,l,u)<0&&e.push([i.data,l.data,u.data])}),e},links:function(){return this.edges.filter(function(e){return e.right}).map(function(e){return{source:e.left.data,target:e.right.data}})},find:function(e,t,r){for(var n=this,i,o=n._found||0,a=n.cells.length,s;!(s=n.cells[o]);)if(++o>=a)return null;var l=e-s.site[0],c=t-s.site[1],u=l*l+c*c;do s=n.cells[i=o],o=null,s.halfedges.forEach(function(h){var f=n.edges[h],p=f.left;if(!((p===s.site||!p)&&!(p=f.right))){var d=e-p[0],g=t-p[1],_=d*d+g*g;_<u&&(u=_,o=p.index)}});while(o!==null);return n._found=i,r==null||u<=r*r?s.site:null}}});function DGt(){var e=vGt,t=xGt,r=null;function n(i){return new yA(i.map(function(o,a){var s=[Math.round(e(o,a,i)/Wr)*Wr,Math.round(t(o,a,i)/Wr)*Wr];return s.index=a,s.data=o,s}),r)}return n.polygons=function(i){return n(i).polygons()},n.links=function(i){return n(i).links()},n.triangles=function(i){return n(i).triangles()},n.x=function(i){return arguments.length?(e=typeof i=="function"?i:lnt(+i),n):e},n.y=function(i){return arguments.length?(t=typeof i=="function"?i:lnt(+i),n):t},n.extent=function(i){return arguments.length?(r=i==null?null:[[+i[0][0],+i[0][1]],[+i[1][0],+i[1][1]]],n):r&&[[r[0][0],r[0][1]],[r[1][0],r[1][1]]]},n.size=function(i){return arguments.length?(r=i==null?null:[[0,0],[+i[0],+i[1]]],n):r&&[r[1][0]-r[0][0],r[1][1]-r[0][1]]},n}var OGt=M(()=>{yGt();bGt();rS()});var zGt=M(()=>{OGt()});function BGt(){for(var e=0,t=arguments.length,r={},n;e<t;++e){if(!(n=arguments[e]+"")||n in r||/[\s.]/.test(n))throw new Error("illegal type: "+n);r[n]=[]}return new Iz(r)}function Iz(e){this._=e}function $Re(e,t){return e.trim().split(/^|\s+/).map(function(r){var n="",i=r.indexOf(".");if(i>=0&&(n=r.slice(i+1),r=r.slice(0,i)),r&&!t.hasOwnProperty(r))throw new Error("unknown type: "+r);return{type:r,name:n}})}function KRe(e,t){for(var r=0,n=e.length,i;r<n;++r)if((i=e[r]).name===t)return i.value}function FGt(e,t,r){for(var n=0,i=e.length;n<i;++n)if(e[n].name===t){e[n]=XRe,e=e.slice(0,n).concat(e.slice(n+1));break}return r!=null&&e.push({name:t,value:r}),e}var XRe,vA,HGt=M(()=>{XRe={value:function(){}};Iz.prototype=BGt.prototype={constructor:Iz,on:function(e,t){var r=this._,n=$Re(e+"",r),i,o=-1,a=n.length;if(arguments.length<2){for(;++o<a;)if((i=(e=n[o]).type)&&(i=KRe(r[i],e.name)))return i;return}if(t!=null&&typeof t!="function")throw new Error("invalid callback: "+t);for(;++o<a;)if(i=(e=n[o]).type)r[i]=FGt(r[i],e.name,t);else if(t==null)for(i in r)r[i]=FGt(r[i],e.name,null);return this},copy:function(){var e={},t=this._;for(var r in t)e[r]=t[r].slice();return new Iz(e)},call:function(e,t){if((i=arguments.length-2)>0)for(var r=new Array(i),n=0,i,o;n<i;++n)r[n]=arguments[n+2];if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(o=this._[e],n=0,i=o.length;n<i;++n)o[n].value.apply(t,r)},apply:function(e,t,r){if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(var n=this._[e],i=0,o=n.length;i<o;++i)n[i].value.apply(t,r)}};vA=BGt});var mnt=M(()=>{HGt()});var Lz,gnt,_nt=M(()=>{Lz="http://www.w3.org/1999/xhtml",gnt={svg:"http://www.w3.org/2000/svg",xhtml:Lz,xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/"}});function hd(e){var t=e+="",r=t.indexOf(":");return r>=0&&(t=e.slice(0,r))!=="xmlns"&&(e=e.slice(r+1)),gnt.hasOwnProperty(t)?{space:gnt[t],local:e}:e}var kz=M(()=>{_nt()});function ZRe(e){return function(){var t=this.ownerDocument,r=this.namespaceURI;return r===Lz&&t.documentElement.namespaceURI===Lz?t.createElement(e):t.createElementNS(r,e)}}function JRe(e){return function(){return this.ownerDocument.createElementNS(e.space,e.local)}}function Rz(e){var t=hd(e);return(t.local?JRe:ZRe)(t)}var ynt=M(()=>{kz();_nt()});function QRe(){}function Cv(e){return e==null?QRe:function(){return this.querySelector(e)}}var Nz=M(()=>{});function VGt(e){typeof e!="function"&&(e=Cv(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=new Array(a),l,c,u=0;u<a;++u)(l=o[u])&&(c=e.call(l,l.__data__,u,o))&&("__data__"in l&&(c.__data__=l.__data__),s[u]=c);return new mi(n,this._parents)}var UGt=M(()=>{Ou();Nz()});function tNe(){return[]}function xA(e){return e==null?tNe:function(){return this.querySelectorAll(e)}}var vnt=M(()=>{});function qGt(e){typeof e!="function"&&(e=xA(e));for(var t=this._groups,r=t.length,n=[],i=[],o=0;o<r;++o)for(var a=t[o],s=a.length,l,c=0;c<s;++c)(l=a[c])&&(n.push(e.call(l,l.__data__,c,a)),i.push(l));return new mi(n,i)}var GGt=M(()=>{Ou();vnt()});function bA(e){return function(){return this.matches(e)}}var xnt=M(()=>{});function WGt(e){typeof e!="function"&&(e=bA(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=[],l,c=0;c<a;++c)(l=o[c])&&e.call(l,l.__data__,c,o)&&s.push(l);return new mi(n,this._parents)}var YGt=M(()=>{Ou();xnt()});function Dz(e){return new Array(e.length)}var bnt=M(()=>{});function jGt(){return new mi(this._enter||this._groups.map(Dz),this._parents)}function wA(e,t){this.ownerDocument=e.ownerDocument,this.namespaceURI=e.namespaceURI,this._next=null,this._parent=e,this.__data__=t}var wnt=M(()=>{bnt();Ou();wA.prototype={constructor:wA,appendChild:function(e){return this._parent.insertBefore(e,this._next)},insertBefore:function(e,t){return this._parent.insertBefore(e,t)},querySelector:function(e){return this._parent.querySelector(e)},querySelectorAll:function(e){return this._parent.querySelectorAll(e)}}});function XGt(e){return function(){return e}}var $Gt=M(()=>{});function eNe(e,t,r,n,i,o){for(var a=0,s,l=t.length,c=o.length;a<c;++a)(s=t[a])?(s.__data__=o[a],n[a]=s):r[a]=new wA(e,o[a]);for(;a<l;++a)(s=t[a])&&(i[a]=s)}function rNe(e,t,r,n,i,o,a){var s,l,c={},u=t.length,h=o.length,f=new Array(u),p;for(s=0;s<u;++s)(l=t[s])&&(f[s]=p=KGt+a.call(l,l.__data__,s,t),p in c?i[s]=l:c[p]=l);for(s=0;s<h;++s)p=KGt+a.call(e,o[s],s,o),(l=c[p])?(n[s]=l,l.__data__=o[s],c[p]=null):r[s]=new wA(e,o[s]);for(s=0;s<u;++s)(l=t[s])&&c[f[s]]===l&&(i[s]=l)}function ZGt(e,t){if(!e)return p=new Array(this.size()),c=-1,this.each(function(P){p[++c]=P}),p;var r=t?rNe:eNe,n=this._parents,i=this._groups;typeof e!="function"&&(e=XGt(e));for(var o=i.length,a=new Array(o),s=new Array(o),l=new Array(o),c=0;c<o;++c){var u=n[c],h=i[c],f=h.length,p=e.call(u,u&&u.__data__,c,n),d=p.length,g=s[c]=new Array(d),_=a[c]=new Array(d),y=l[c]=new Array(f);r(u,h,g,_,y,p,t);for(var x=0,b=0,S,C;x<d;++x)if(S=g[x]){for(x>=b&&(b=x+1);!(C=_[b])&&++b<d;);S._next=C||null}}return a=new mi(a,n),a._enter=s,a._exit=l,a}var KGt,JGt=M(()=>{Ou();wnt();$Gt();KGt="$"});function QGt(){return new mi(this._exit||this._groups.map(Dz),this._parents)}var tWt=M(()=>{bnt();Ou()});function eWt(e,t,r){var n=this.enter(),i=this,o=this.exit();return n=typeof e=="function"?e(n):n.append(e+""),t!=null&&(i=t(i)),r==null?o.remove():r(o),n&&i?n.merge(i).order():i}var rWt=M(()=>{});function nWt(e){for(var t=this._groups,r=e._groups,n=t.length,i=r.length,o=Math.min(n,i),a=new Array(n),s=0;s<o;++s)for(var l=t[s],c=r[s],u=l.length,h=a[s]=new Array(u),f,p=0;p<u;++p)(f=l[p]||c[p])&&(h[p]=f);for(;s<n;++s)a[s]=t[s];return new mi(a,this._parents)}var iWt=M(()=>{Ou()});function oWt(){for(var e=this._groups,t=-1,r=e.length;++t<r;)for(var n=e[t],i=n.length-1,o=n[i],a;--i>=0;)(a=n[i])&&(o&&a.compareDocumentPosition(o)^4&&o.parentNode.insertBefore(a,o),o=a);return this}var aWt=M(()=>{});function sWt(e){e||(e=nNe);function t(h,f){return h&&f?e(h.__data__,f.__data__):!h-!f}for(var r=this._groups,n=r.length,i=new Array(n),o=0;o<n;++o){for(var a=r[o],s=a.length,l=i[o]=new Array(s),c,u=0;u<s;++u)(c=a[u])&&(l[u]=c);l.sort(t)}return new mi(i,this._parents).order()}function nNe(e,t){return e<t?-1:e>t?1:e>=t?0:NaN}var lWt=M(()=>{Ou()});function cWt(){var e=arguments[0];return arguments[0]=this,e.apply(null,arguments),this}var uWt=M(()=>{});function hWt(){var e=new Array(this.size()),t=-1;return this.each(function(){e[++t]=this}),e}var fWt=M(()=>{});function pWt(){for(var e=this._groups,t=0,r=e.length;t<r;++t)for(var n=e[t],i=0,o=n.length;i<o;++i){var a=n[i];if(a)return a}return null}var dWt=M(()=>{});function mWt(){var e=0;return this.each(function(){++e}),e}var gWt=M(()=>{});function _Wt(){return!this.node()}var yWt=M(()=>{});function vWt(e){for(var t=this._groups,r=0,n=t.length;r<n;++r)for(var i=t[r],o=0,a=i.length,s;o<a;++o)(s=i[o])&&e.call(s,s.__data__,o,i);return this}var xWt=M(()=>{});function iNe(e){return function(){this.removeAttribute(e)}}function oNe(e){return function(){this.removeAttributeNS(e.space,e.local)}}function aNe(e,t){return function(){this.setAttribute(e,t)}}function sNe(e,t){return function(){this.setAttributeNS(e.space,e.local,t)}}function lNe(e,t){return function(){var r=t.apply(this,arguments);r==null?this.removeAttribute(e):this.setAttribute(e,r)}}function cNe(e,t){return function(){var r=t.apply(this,arguments);r==null?this.removeAttributeNS(e.space,e.local):this.setAttributeNS(e.space,e.local,r)}}function bWt(e,t){var r=hd(e);if(arguments.length<2){var n=this.node();return r.local?n.getAttributeNS(r.space,r.local):n.getAttribute(r)}return this.each((t==null?r.local?oNe:iNe:typeof t=="function"?r.local?cNe:lNe:r.local?sNe:aNe)(r,t))}var wWt=M(()=>{kz()});function Oz(e){return e.ownerDocument&&e.ownerDocument.defaultView||e.document&&e||e.defaultView}var Snt=M(()=>{});function uNe(e){return function(){this.style.removeProperty(e)}}function hNe(e,t,r){return function(){this.style.setProperty(e,t,r)}}function fNe(e,t,r){return function(){var n=t.apply(this,arguments);n==null?this.style.removeProperty(e):this.style.setProperty(e,n,r)}}function SWt(e,t,r){return arguments.length>1?this.each((t==null?uNe:typeof t=="function"?fNe:hNe)(e,t,r==null?"":r)):Ug(this.node(),e)}function Ug(e,t){return e.style.getPropertyValue(t)||Oz(e).getComputedStyle(e,null).getPropertyValue(t)}var Mnt=M(()=>{Snt()});function pNe(e){return function(){delete this[e]}}function dNe(e,t){return function(){this[e]=t}}function mNe(e,t){return function(){var r=t.apply(this,arguments);r==null?delete this[e]:this[e]=r}}function MWt(e,t){return arguments.length>1?this.each((t==null?pNe:typeof t=="function"?mNe:dNe)(e,t)):this.node()[e]}var EWt=M(()=>{});function TWt(e){return e.trim().split(/^|\s+/)}function Ent(e){return e.classList||new CWt(e)}function CWt(e){this._node=e,this._names=TWt(e.getAttribute("class")||"")}function AWt(e,t){for(var r=Ent(e),n=-1,i=t.length;++n<i;)r.add(t[n])}function PWt(e,t){for(var r=Ent(e),n=-1,i=t.length;++n<i;)r.remove(t[n])}function gNe(e){return function(){AWt(this,e)}}function _Ne(e){return function(){PWt(this,e)}}function yNe(e,t){return function(){(t.apply(this,arguments)?AWt:PWt)(this,e)}}function IWt(e,t){var r=TWt(e+"");if(arguments.length<2){for(var n=Ent(this.node()),i=-1,o=r.length;++i<o;)if(!n.contains(r[i]))return!1;return!0}return this.each((typeof t=="function"?yNe:t?gNe:_Ne)(r,t))}var LWt=M(()=>{CWt.prototype={add:function(e){var t=this._names.indexOf(e);t<0&&(this._names.push(e),this._node.setAttribute("class",this._names.join(" ")))},remove:function(e){var t=this._names.indexOf(e);t>=0&&(this._names.splice(t,1),this._node.setAttribute("class",this._names.join(" ")))},contains:function(e){return this._names.indexOf(e)>=0}}});function vNe(){this.textContent=""}function xNe(e){return function(){this.textContent=e}}function bNe(e){return function(){var t=e.apply(this,arguments);this.textContent=t==null?"":t}}function kWt(e){return arguments.length?this.each(e==null?vNe:(typeof e=="function"?bNe:xNe)(e)):this.node().textContent}var RWt=M(()=>{});function wNe(){this.innerHTML=""}function SNe(e){return function(){this.innerHTML=e}}function MNe(e){return function(){var t=e.apply(this,arguments);this.innerHTML=t==null?"":t}}function NWt(e){return arguments.length?this.each(e==null?wNe:(typeof e=="function"?MNe:SNe)(e)):this.node().innerHTML}var DWt=M(()=>{});function ENe(){this.nextSibling&&this.parentNode.appendChild(this)}function OWt(){return this.each(ENe)}var zWt=M(()=>{});function TNe(){this.previousSibling&&this.parentNode.insertBefore(this,this.parentNode.firstChild)}function FWt(){return this.each(TNe)}var BWt=M(()=>{});function HWt(e){var t=typeof e=="function"?e:Rz(e);return this.select(function(){return this.appendChild(t.apply(this,arguments))})}var VWt=M(()=>{ynt()});function CNe(){return null}function UWt(e,t){var r=typeof e=="function"?e:Rz(e),n=t==null?CNe:typeof t=="function"?t:Cv(t);return this.select(function(){return this.insertBefore(r.apply(this,arguments),n.apply(this,arguments)||null)})}var qWt=M(()=>{ynt();Nz()});function ANe(){var e=this.parentNode;e&&e.removeChild(this)}function GWt(){return this.each(ANe)}var WWt=M(()=>{});function PNe(){var e=this.cloneNode(!1),t=this.parentNode;return t?t.insertBefore(e,this.nextSibling):e}function INe(){var e=this.cloneNode(!0),t=this.parentNode;return t?t.insertBefore(e,this.nextSibling):e}function YWt(e){return this.select(e?INe:PNe)}var jWt=M(()=>{});function XWt(e){return arguments.length?this.property("__data__",e):this.node().__data__}var $Wt=M(()=>{});function LNe(e,t,r){return e=JWt(e,t,r),function(n){var i=n.relatedTarget;(!i||i!==this&&!(i.compareDocumentPosition(this)&8))&&e.call(this,n)}}function JWt(e,t,r){return function(n){var i=Yr;Yr=n;try{e.call(this,this.__data__,t,r)}finally{Yr=i}}}function kNe(e){return e.trim().split(/^|\s+/).map(function(t){var r="",n=t.indexOf(".");return n>=0&&(r=t.slice(n+1),t=t.slice(0,n)),{type:t,name:r}})}function RNe(e){return function(){var t=this.__on;if(!!t){for(var r=0,n=-1,i=t.length,o;r<i;++r)o=t[r],(!e.type||o.type===e.type)&&o.name===e.name?this.removeEventListener(o.type,o.listener,o.capture):t[++n]=o;++n?t.length=n:delete this.__on}}}function NNe(e,t,r){var n=ZWt.hasOwnProperty(e.type)?LNe:JWt;return function(i,o,a){var s=this.__on,l,c=n(t,o,a);if(s){for(var u=0,h=s.length;u<h;++u)if((l=s[u]).type===e.type&&l.name===e.name){this.removeEventListener(l.type,l.listener,l.capture),this.addEventListener(l.type,l.listener=c,l.capture=r),l.value=t;return}}this.addEventListener(e.type,c,r),l={type:e.type,name:e.name,value:t,listener:c,capture:r},s?s.push(l):this.__on=[l]}}function QWt(e,t,r){var n=kNe(e+""),i,o=n.length,a;if(arguments.length<2){var s=this.node().__on;if(s){for(var l=0,c=s.length,u;l<c;++l)for(i=0,u=s[l];i<o;++i)if((a=n[i]).type===u.type&&a.name===u.name)return u.value}return}for(s=t?NNe:RNe,r==null&&(r=!1),i=0;i<o;++i)this.each(s(n[i],t,r));return this}function Tnt(e,t,r,n){var i=Yr;e.sourceEvent=Yr,Yr=e;try{return t.apply(r,n)}finally{Yr=i}}var ZWt,Yr,KWt,zz=M(()=>{ZWt={},Yr=null;typeof document!="undefined"&&(KWt=document.documentElement,"onmouseenter"in KWt||(ZWt={mouseenter:"mouseover",mouseleave:"mouseout"}))});function tYt(e,t,r){var n=Oz(e),i=n.CustomEvent;typeof i=="function"?i=new i(t,r):(i=n.document.createEvent("Event"),r?(i.initEvent(t,r.bubbles,r.cancelable),i.detail=r.detail):i.initEvent(t,!1,!1)),e.dispatchEvent(i)}function DNe(e,t){return function(){return tYt(this,e,t)}}function ONe(e,t){return function(){return tYt(this,e,t.apply(this,arguments))}}function eYt(e,t){return this.each((typeof t=="function"?ONe:DNe)(e,t))}var rYt=M(()=>{Snt()});function mi(e,t){this._groups=e,this._parents=t}function nYt(){return new mi([[document.documentElement]],Cnt)}var Cnt,fd,Ou=M(()=>{UGt();GGt();YGt();JGt();wnt();tWt();rWt();iWt();aWt();lWt();uWt();fWt();dWt();gWt();yWt();xWt();wWt();Mnt();EWt();LWt();RWt();DWt();zWt();BWt();VWt();qWt();WWt();jWt();$Wt();zz();rYt();Cnt=[null];mi.prototype=nYt.prototype={constructor:mi,select:VGt,selectAll:qGt,filter:WGt,data:ZGt,enter:jGt,exit:QGt,join:eWt,merge:nWt,order:oWt,sort:sWt,call:cWt,nodes:hWt,node:pWt,size:mWt,empty:_Wt,each:vWt,attr:bWt,style:SWt,property:MWt,classed:IWt,text:kWt,html:NWt,raise:OWt,lower:FWt,append:HWt,insert:UWt,remove:GWt,clone:YWt,datum:XWt,on:QWt,dispatch:eYt};fd=nYt});function pd(e){return typeof e=="string"?new mi([[document.querySelector(e)]],[document.documentElement]):new mi([[e]],Cnt)}var iYt=M(()=>{Ou()});function Fz(){for(var e=Yr,t;t=e.sourceEvent;)e=t;return e}var Ant=M(()=>{zz()});function Bz(e,t){var r=e.ownerSVGElement||e;if(r.createSVGPoint){var n=r.createSVGPoint();return n.x=t.clientX,n.y=t.clientY,n=n.matrixTransform(e.getScreenCTM().inverse()),[n.x,n.y]}var i=e.getBoundingClientRect();return[t.clientX-i.left-e.clientLeft,t.clientY-i.top-e.clientTop]}var Pnt=M(()=>{});function iS(e){var t=Fz();return t.changedTouches&&(t=t.changedTouches[0]),Bz(e,t)}var oYt=M(()=>{Ant();Pnt()});function Hz(e,t,r){arguments.length<3&&(r=t,t=Fz().changedTouches);for(var n=0,i=t?t.length:0,o;n<i;++n)if((o=t[n]).identifier===r)return Bz(e,o);return null}var aYt=M(()=>{Ant();Pnt()});var Is=M(()=>{xnt();oYt();kz();iYt();Ou();Nz();vnt();Mnt();aYt();zz()});function Vz(){Yr.preventDefault(),Yr.stopImmediatePropagation()}var sYt=M(()=>{Is()});function Int(e){var t=e.document.documentElement,r=pd(e).on("dragstart.drag",Vz,!0);"onselectstart"in t?r.on("selectstart.drag",Vz,!0):(t.__noselect=t.style.MozUserSelect,t.style.MozUserSelect="none")}function Lnt(e,t){var r=e.document.documentElement,n=pd(e).on("dragstart.drag",null);t&&(n.on("click.drag",Vz,!0),setTimeout(function(){n.on("click.drag",null)},0)),"onselectstart"in r?n.on("selectstart.drag",null):(r.style.MozUserSelect=r.__noselect,delete r.__noselect)}var lYt=M(()=>{Is();sYt()});var cYt=M(()=>{lYt()});function Uz(e,t,r){e.prototype=t.prototype=r,r.constructor=e}function knt(e,t){var r=Object.create(e.prototype);for(var n in t)r[n]=t[n];return r}var uYt=M(()=>{});function EA(){}function fYt(){return this.rgb().formatHex()}function GNe(){return yYt(this).formatHsl()}function pYt(){return this.rgb().formatRgb()}function qg(e){var t,r;return e=(e+"").trim().toLowerCase(),(t=zNe.exec(e))?(r=t[1].length,t=parseInt(t[1],16),r===6?dYt(t):r===3?new gl(t>>8&15|t>>4&240,t>>4&15|t&240,(t&15)<<4|t&15,1):r===8?qz(t>>24&255,t>>16&255,t>>8&255,(t&255)/255):r===4?qz(t>>12&15|t>>8&240,t>>8&15|t>>4&240,t>>4&15|t&240,((t&15)<<4|t&15)/255):null):(t=FNe.exec(e))?new gl(t[1],t[2],t[3],1):(t=BNe.exec(e))?new gl(t[1]*255/100,t[2]*255/100,t[3]*255/100,1):(t=HNe.exec(e))?qz(t[1],t[2],t[3],t[4]):(t=VNe.exec(e))?qz(t[1]*255/100,t[2]*255/100,t[3]*255/100,t[4]):(t=UNe.exec(e))?_Yt(t[1],t[2]/100,t[3]/100,1):(t=qNe.exec(e))?_Yt(t[1],t[2]/100,t[3]/100,t[4]):hYt.hasOwnProperty(e)?dYt(hYt[e]):e==="transparent"?new gl(NaN,NaN,NaN,0):null}function dYt(e){return new gl(e>>16&255,e>>8&255,e&255,1)}function qz(e,t,r,n){return n<=0&&(e=t=r=NaN),new gl(e,t,r,n)}function WNe(e){return e instanceof EA||(e=qg(e)),e?(e=e.rgb(),new gl(e.r,e.g,e.b,e.opacity)):new gl}function aS(e,t,r,n){return arguments.length===1?WNe(e):new gl(e,t,r,n==null?1:n)}function gl(e,t,r,n){this.r=+e,this.g=+t,this.b=+r,this.opacity=+n}function mYt(){return"#"+Rnt(this.r)+Rnt(this.g)+Rnt(this.b)}function gYt(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"rgb(":"rgba(")+Math.max(0,Math.min(255,Math.round(this.r)||0))+", "+Math.max(0,Math.min(255,Math.round(this.g)||0))+", "+Math.max(0,Math.min(255,Math.round(this.b)||0))+(e===1?")":", "+e+")")}function Rnt(e){return e=Math.max(0,Math.min(255,Math.round(e)||0)),(e<16?"0":"")+e.toString(16)}function _Yt(e,t,r,n){return n<=0?e=t=r=NaN:r<=0||r>=1?e=t=NaN:t<=0&&(e=NaN),new Cf(e,t,r,n)}function yYt(e){if(e instanceof Cf)return new Cf(e.h,e.s,e.l,e.opacity);if(e instanceof EA||(e=qg(e)),!e)return new Cf;if(e instanceof Cf)return e;e=e.rgb();var t=e.r/255,r=e.g/255,n=e.b/255,i=Math.min(t,r,n),o=Math.max(t,r,n),a=NaN,s=o-i,l=(o+i)/2;return s?(t===o?a=(r-n)/s+(r<n)*6:r===o?a=(n-t)/s+2:a=(t-r)/s+4,s/=l<.5?o+i:2-o-i,a*=60):s=l>0&&l<1?0:a,new Cf(a,s,l,e.opacity)}function vYt(e,t,r,n){return arguments.length===1?yYt(e):new Cf(e,t,r,n==null?1:n)}function Cf(e,t,r,n){this.h=+e,this.s=+t,this.l=+r,this.opacity=+n}function Nnt(e,t,r){return(e<60?t+(r-t)*e/60:e<180?r:e<240?t+(r-t)*(240-e)/60:t)*255}var SA,Gz,oS,MA,Af,zNe,FNe,BNe,HNe,VNe,UNe,qNe,hYt,xYt=M(()=>{uYt();SA=.7,Gz=1/SA,oS="\\s*([+-]?\\d+)\\s*",MA="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",Af="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",zNe=/^#([0-9a-f]{3,8})$/,FNe=new RegExp("^rgb\\("+[oS,oS,oS]+"\\)$"),BNe=new RegExp("^rgb\\("+[Af,Af,Af]+"\\)$"),HNe=new RegExp("^rgba\\("+[oS,oS,oS,MA]+"\\)$"),VNe=new RegExp("^rgba\\("+[Af,Af,Af,MA]+"\\)$"),UNe=new RegExp("^hsl\\("+[MA,Af,Af]+"\\)$"),qNe=new RegExp("^hsla\\("+[MA,Af,Af,MA]+"\\)$"),hYt={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};Uz(EA,qg,{copy:function(e){return Object.assign(new this.constructor,this,e)},displayable:function(){return this.rgb().displayable()},hex:fYt,formatHex:fYt,formatHsl:GNe,formatRgb:pYt,toString:pYt});Uz(gl,aS,knt(EA,{brighter:function(e){return e=e==null?Gz:Math.pow(Gz,e),new gl(this.r*e,this.g*e,this.b*e,this.opacity)},darker:function(e){return e=e==null?SA:Math.pow(SA,e),new gl(this.r*e,this.g*e,this.b*e,this.opacity)},rgb:function(){return this},displayable:function(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:mYt,formatHex:mYt,formatRgb:gYt,toString:gYt}));Uz(Cf,vYt,knt(EA,{brighter:function(e){return e=e==null?Gz:Math.pow(Gz,e),new Cf(this.h,this.s,this.l*e,this.opacity)},darker:function(e){return e=e==null?SA:Math.pow(SA,e),new Cf(this.h,this.s,this.l*e,this.opacity)},rgb:function(){var e=this.h%360+(this.h<0)*360,t=isNaN(e)||isNaN(this.s)?0:this.s,r=this.l,n=r+(r<.5?r:1-r)*t,i=2*r-n;return new gl(Nnt(e>=240?e-240:e+120,i,n),Nnt(e,i,n),Nnt(e<120?e+240:e-120,i,n),this.opacity)},displayable:function(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl:function(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"hsl(":"hsla(")+(this.h||0)+", "+(this.s||0)*100+"%, "+(this.l||0)*100+"%"+(e===1?")":", "+e+")")}}))});var Dnt=M(()=>{xYt()});function Ont(e,t,r,n,i){var o=e*e,a=o*e;return((1-3*e+3*o-a)*t+(4-6*o+3*a)*r+(1+3*e+3*o-3*a)*n+a*i)/6}function bYt(e){var t=e.length-1;return function(r){var n=r<=0?r=0:r>=1?(r=1,t-1):Math.floor(r*t),i=e[n],o=e[n+1],a=n>0?e[n-1]:2*i-o,s=n<t-1?e[n+2]:2*o-i;return Ont((r-n/t)*t,a,i,o,s)}}var znt=M(()=>{});function wYt(e){var t=e.length;return function(r){var n=Math.floor(((r%=1)<0?++r:r)*t),i=e[(n+t-1)%t],o=e[n%t],a=e[(n+1)%t],s=e[(n+2)%t];return Ont((r-n/t)*t,i,o,a,s)}}var SYt=M(()=>{znt()});function Fnt(e){return function(){return e}}var MYt=M(()=>{});function YNe(e,t){return function(r){return e+r*t}}function jNe(e,t,r){return e=Math.pow(e,r),t=Math.pow(t,r)-e,r=1/r,function(n){return Math.pow(e+n*t,r)}}function EYt(e){return(e=+e)==1?Wz:function(t,r){return r-t?jNe(t,r,e):Fnt(isNaN(t)?r:t)}}function Wz(e,t){var r=t-e;return r?YNe(e,r):Fnt(isNaN(e)?t:e)}var TYt=M(()=>{MYt()});function CYt(e){return function(t){var r=t.length,n=new Array(r),i=new Array(r),o=new Array(r),a,s;for(a=0;a<r;++a)s=aS(t[a]),n[a]=s.r||0,i[a]=s.g||0,o[a]=s.b||0;return n=e(n),i=e(i),o=e(o),s.opacity=1,function(l){return s.r=n(l),s.g=i(l),s.b=o(l),s+""}}}var Yz,XNe,$Ne,AYt=M(()=>{Dnt();znt();SYt();TYt();Yz=function e(t){var r=EYt(t);function n(i,o){var a=r((i=aS(i)).r,(o=aS(o)).r),s=r(i.g,o.g),l=r(i.b,o.b),c=Wz(i.opacity,o.opacity);return function(u){return i.r=a(u),i.g=s(u),i.b=l(u),i.opacity=c(u),i+""}}return n.gamma=e,n}(1);XNe=CYt(bYt),$Ne=CYt(wYt)});function Ic(e,t){return e=+e,t=+t,function(r){return e*(1-r)+t*r}}var jz=M(()=>{});function KNe(e){return function(){return e}}function ZNe(e){return function(t){return e(t)+""}}function Vnt(e,t){var r=Hnt.lastIndex=Bnt.lastIndex=0,n,i,o,a=-1,s=[],l=[];for(e=e+"",t=t+"";(n=Hnt.exec(e))&&(i=Bnt.exec(t));)(o=i.index)>r&&(o=t.slice(r,o),s[a]?s[a]+=o:s[++a]=o),(n=n[0])===(i=i[0])?s[a]?s[a]+=i:s[++a]=i:(s[++a]=null,l.push({i:a,x:Ic(n,i)})),r=Bnt.lastIndex;return r<t.length&&(o=t.slice(r),s[a]?s[a]+=o:s[++a]=o),s.length<2?l[0]?ZNe(l[0].x):KNe(t):(t=l.length,function(c){for(var u=0,h;u<t;++u)s[(h=l[u]).i]=h.x(c);return s.join("")})}var Hnt,Bnt,PYt=M(()=>{jz();Hnt=/[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,Bnt=new RegExp(Hnt.source,"g")});function Unt(e,t,r,n,i,o){var a,s,l;return(a=Math.sqrt(e*e+t*t))&&(e/=a,t/=a),(l=e*r+t*n)&&(r-=e*l,n-=t*l),(s=Math.sqrt(r*r+n*n))&&(r/=s,n/=s,l/=s),e*n<t*r&&(e=-e,t=-t,l=-l,a=-a),{translateX:i,translateY:o,rotate:Math.atan2(t,e)*IYt,skewX:Math.atan(l)*IYt,scaleX:a,scaleY:s}}var IYt,Xz,LYt=M(()=>{IYt=180/Math.PI,Xz={translateX:0,translateY:0,rotate:0,skewX:0,scaleX:1,scaleY:1}});function RYt(e){return e==="none"?Xz:(TA||(TA=document.createElement("DIV"),qnt=document.documentElement,kYt=document.defaultView),TA.style.transform=e,e=kYt.getComputedStyle(qnt.appendChild(TA),null).getPropertyValue("transform"),qnt.removeChild(TA),e=e.slice(7,-1).split(","),Unt(+e[0],+e[1],+e[2],+e[3],+e[4],+e[5]))}function NYt(e){return e==null?Xz:($z||($z=document.createElementNS("http://www.w3.org/2000/svg","g")),$z.setAttribute("transform",e),(e=$z.transform.baseVal.consolidate())?(e=e.matrix,Unt(e.a,e.b,e.c,e.d,e.e,e.f)):Xz)}var TA,qnt,kYt,$z,DYt=M(()=>{LYt()});function OYt(e,t,r,n){function i(c){return c.length?c.pop()+" ":""}function o(c,u,h,f,p,d){if(c!==h||u!==f){var g=p.push("translate(",null,t,null,r);d.push({i:g-4,x:Ic(c,h)},{i:g-2,x:Ic(u,f)})}else(h||f)&&p.push("translate("+h+t+f+r)}function a(c,u,h,f){c!==u?(c-u>180?u+=360:u-c>180&&(c+=360),f.push({i:h.push(i(h)+"rotate(",null,n)-2,x:Ic(c,u)})):u&&h.push(i(h)+"rotate("+u+n)}function s(c,u,h,f){c!==u?f.push({i:h.push(i(h)+"skewX(",null,n)-2,x:Ic(c,u)}):u&&h.push(i(h)+"skewX("+u+n)}function l(c,u,h,f,p,d){if(c!==h||u!==f){var g=p.push(i(p)+"scale(",null,",",null,")");d.push({i:g-4,x:Ic(c,h)},{i:g-2,x:Ic(u,f)})}else(h!==1||f!==1)&&p.push(i(p)+"scale("+h+","+f+")")}return function(c,u){var h=[],f=[];return c=e(c),u=e(u),o(c.translateX,c.translateY,u.translateX,u.translateY,h,f),a(c.rotate,u.rotate,h,f),s(c.skewX,u.skewX,h,f),l(c.scaleX,c.scaleY,u.scaleX,u.scaleY,h,f),c=u=null,function(p){for(var d=-1,g=f.length,_;++d<g;)h[(_=f[d]).i]=_.x(p);return h.join("")}}}var Gnt,Wnt,zYt=M(()=>{jz();DYt();Gnt=OYt(RYt,"px, ","px)","deg)"),Wnt=OYt(NYt,", ",")",")")});function BYt(e){return((e=Math.exp(e))+1/e)/2}function QNe(e){return((e=Math.exp(e))-1/e)/2}function tDe(e){return((e=Math.exp(2*e))-1)/(e+1)}function jnt(e,t){var r=e[0],n=e[1],i=e[2],o=t[0],a=t[1],s=t[2],l=o-r,c=a-n,u=l*l+c*c,h,f;if(u<JNe)f=Math.log(s/i)/CA,h=function(x){return[r+x*l,n+x*c,i*Math.exp(CA*x*f)]};else{var p=Math.sqrt(u),d=(s*s-i*i+FYt*u)/(2*i*Ynt*p),g=(s*s-i*i-FYt*u)/(2*s*Ynt*p),_=Math.log(Math.sqrt(d*d+1)-d),y=Math.log(Math.sqrt(g*g+1)-g);f=(y-_)/CA,h=function(x){var b=x*f,S=BYt(_),C=i/(Ynt*p)*(S*tDe(CA*b+_)-QNe(_));return[r+C*l,n+C*c,i*S/BYt(CA*b+_)]}}return h.duration=f*1e3,h}var CA,Ynt,FYt,JNe,HYt=M(()=>{CA=Math.SQRT2,Ynt=2,FYt=4,JNe=1e-12});var AA=M(()=>{jz();PYt();zYt();HYt();AYt()});function lS(){return Av||(qYt(eDe),Av=kA.now()+Jz)}function eDe(){Av=0}function RA(){this._call=this._time=this._next=null}function Qz(e,t,r){var n=new RA;return n.restart(e,t,r),n}function GYt(){lS(),++sS;for(var e=Kz,t;e;)(t=Av-e._time)>=0&&e._call.call(null,t),e=e._next;--sS}function VYt(){Av=(Zz=kA.now())+Jz,sS=IA=0;try{GYt()}finally{sS=0,nDe(),Av=0}}function rDe(){var e=kA.now(),t=e-Zz;t>UYt&&(Jz-=t,Zz=e)}function nDe(){for(var e,t=Kz,r,n=1/0;t;)t._call?(n>t._time&&(n=t._time),e=t,t=t._next):(r=t._next,t._next=null,t=e?e._next=r:Kz=r);LA=e,Xnt(n)}function Xnt(e){if(!sS){IA&&(IA=clearTimeout(IA));var t=e-Av;t>24?(e<1/0&&(IA=setTimeout(VYt,e-kA.now()-Jz)),PA&&(PA=clearInterval(PA))):(PA||(Zz=kA.now(),PA=setInterval(rDe,UYt)),sS=1,qYt(VYt))}}var sS,IA,PA,UYt,Kz,LA,Zz,Av,Jz,kA,qYt,$nt=M(()=>{sS=0,IA=0,PA=0,UYt=1e3,Zz=0,Av=0,Jz=0,kA=typeof performance=="object"&&performance.now?performance:Date,qYt=typeof window=="object"&&window.requestAnimationFrame?window.requestAnimationFrame.bind(window):function(e){setTimeout(e,17)};RA.prototype=Qz.prototype={constructor:RA,restart:function(e,t,r){if(typeof e!="function")throw new TypeError("callback is not a function");r=(r==null?lS():+r)+(t==null?0:+t),!this._next&&LA!==this&&(LA?LA._next=this:Kz=this,LA=this),this._call=e,this._time=r,Xnt()},stop:function(){this._call&&(this._call=null,this._time=1/0,Xnt())}}});function tF(e,t,r){var n=new RA;return t=t==null?0:+t,n.restart(function(i){n.stop(),e(i+t)},t,r),n}var WYt=M(()=>{$nt()});var Knt=M(()=>{$nt();WYt()});function Gg(e,t,r,n,i,o){var a=e.__transition;if(!a)e.__transition={};else if(r in a)return;aDe(e,r,{name:t,index:n,group:i,on:iDe,tween:oDe,time:o.time,delay:o.delay,duration:o.duration,ease:o.ease,timer:null,state:jYt})}function DA(e,t){var r=oo(e,t);if(r.state>jYt)throw new Error("too late; already scheduled");return r}function Ja(e,t){var r=oo(e,t);if(r.state>eF)throw new Error("too late; already running");return r}function oo(e,t){var r=e.__transition;if(!r||!(r=r[t]))throw new Error("transition not found");return r}function aDe(e,t,r){var n=e.__transition,i;n[t]=r,r.timer=Qz(o,0,r.time);function o(c){r.state=Znt,r.timer.restart(a,r.delay,r.time),r.delay<=c&&a(c-r.delay)}function a(c){var u,h,f,p;if(r.state!==Znt)return l();for(u in n)if(p=n[u],p.name===r.name){if(p.state===eF)return tF(a);p.state===YYt?(p.state=NA,p.timer.stop(),p.on.call("interrupt",e,e.__data__,p.index,p.group),delete n[u]):+u<t&&(p.state=NA,p.timer.stop(),p.on.call("cancel",e,e.__data__,p.index,p.group),delete n[u])}if(tF(function(){r.state===eF&&(r.state=YYt,r.timer.restart(s,r.delay,r.time),s(c))}),r.state=rF,r.on.call("start",e,e.__data__,r.index,r.group),r.state===rF){for(r.state=eF,i=new Array(f=r.tween.length),u=0,h=-1;u<f;++u)(p=r.tween[u].value.call(e,e.__data__,r.index,r.group))&&(i[++h]=p);i.length=h+1}}function s(c){for(var u=c<r.duration?r.ease.call(null,c/r.duration):(r.timer.restart(l),r.state=nF,1),h=-1,f=i.length;++h<f;)i[h].call(e,u);r.state===nF&&(r.on.call("end",e,e.__data__,r.index,r.group),l())}function l(){r.state=NA,r.timer.stop(),delete n[t];for(var c in n)return;delete e.__transition}}var iDe,oDe,jYt,Znt,rF,eF,YYt,nF,NA,Ls=M(()=>{mnt();Knt();iDe=vA("start","end","cancel","interrupt"),oDe=[],jYt=0,Znt=1,rF=2,eF=3,YYt=4,nF=5,NA=6});function Pv(e,t){var r=e.__transition,n,i,o=!0,a;if(!!r){t=t==null?null:t+"";for(a in r){if((n=r[a]).name!==t){o=!1;continue}i=n.state>rF&&n.state<nF,n.state=NA,n.timer.stop(),n.on.call(i?"interrupt":"cancel",e,e.__data__,n.index,n.group),delete r[a]}o&&delete e.__transition}}var Jnt=M(()=>{Ls()});function XYt(e){return this.each(function(){Pv(this,e)})}var $Yt=M(()=>{Jnt()});function sDe(e,t){var r,n;return function(){var i=Ja(this,e),o=i.tween;if(o!==r){n=r=o;for(var a=0,s=n.length;a<s;++a)if(n[a].name===t){n=n.slice(),n.splice(a,1);break}}i.tween=n}}function lDe(e,t,r){var n,i;if(typeof r!="function")throw new Error;return function(){var o=Ja(this,e),a=o.tween;if(a!==n){i=(n=a).slice();for(var s={name:t,value:r},l=0,c=i.length;l<c;++l)if(i[l].name===t){i[l]=s;break}l===c&&i.push(s)}o.tween=i}}function KYt(e,t){var r=this._id;if(e+="",arguments.length<2){for(var n=oo(this.node(),r).tween,i=0,o=n.length,a;i<o;++i)if((a=n[i]).name===e)return a.value;return null}return this.each((t==null?sDe:lDe)(r,e,t))}function cS(e,t,r){var n=e._id;return e.each(function(){var i=Ja(this,n);(i.value||(i.value={}))[t]=r.apply(this,arguments)}),function(i){return oo(i,n).value[t]}}var OA=M(()=>{Ls()});function iF(e,t){var r;return(typeof t=="number"?Ic:t instanceof qg?Yz:(r=qg(t))?(t=r,Yz):Vnt)(e,t)}var Qnt=M(()=>{Dnt();AA()});function cDe(e){return function(){this.removeAttribute(e)}}function uDe(e){return function(){this.removeAttributeNS(e.space,e.local)}}function hDe(e,t,r){var n,i=r+"",o;return function(){var a=this.getAttribute(e);return a===i?null:a===n?o:o=t(n=a,r)}}function fDe(e,t,r){var n,i=r+"",o;return function(){var a=this.getAttributeNS(e.space,e.local);return a===i?null:a===n?o:o=t(n=a,r)}}function pDe(e,t,r){var n,i,o;return function(){var a,s=r(this),l;return s==null?void this.removeAttribute(e):(a=this.getAttribute(e),l=s+"",a===l?null:a===n&&l===i?o:(i=l,o=t(n=a,s)))}}function dDe(e,t,r){var n,i,o;return function(){var a,s=r(this),l;return s==null?void this.removeAttributeNS(e.space,e.local):(a=this.getAttributeNS(e.space,e.local),l=s+"",a===l?null:a===n&&l===i?o:(i=l,o=t(n=a,s)))}}function ZYt(e,t){var r=hd(e),n=r==="transform"?Wnt:iF;return this.attrTween(e,typeof t=="function"?(r.local?dDe:pDe)(r,n,cS(this,"attr."+e,t)):t==null?(r.local?uDe:cDe)(r):(r.local?fDe:hDe)(r,n,t))}var JYt=M(()=>{AA();Is();OA();Qnt()});function mDe(e,t){return function(r){this.setAttribute(e,t.call(this,r))}}function gDe(e,t){return function(r){this.setAttributeNS(e.space,e.local,t.call(this,r))}}function _De(e,t){var r,n;function i(){var o=t.apply(this,arguments);return o!==n&&(r=(n=o)&&gDe(e,o)),r}return i._value=t,i}function yDe(e,t){var r,n;function i(){var o=t.apply(this,arguments);return o!==n&&(r=(n=o)&&mDe(e,o)),r}return i._value=t,i}function QYt(e,t){var r="attr."+e;if(arguments.length<2)return(r=this.tween(r))&&r._value;if(t==null)return this.tween(r,null);if(typeof t!="function")throw new Error;var n=hd(e);return this.tween(r,(n.local?_De:yDe)(n,t))}var tjt=M(()=>{Is()});function vDe(e,t){return function(){DA(this,e).delay=+t.apply(this,arguments)}}function xDe(e,t){return t=+t,function(){DA(this,e).delay=t}}function ejt(e){var t=this._id;return arguments.length?this.each((typeof e=="function"?vDe:xDe)(t,e)):oo(this.node(),t).delay}var rjt=M(()=>{Ls()});function bDe(e,t){return function(){Ja(this,e).duration=+t.apply(this,arguments)}}function wDe(e,t){return t=+t,function(){Ja(this,e).duration=t}}function njt(e){var t=this._id;return arguments.length?this.each((typeof e=="function"?bDe:wDe)(t,e)):oo(this.node(),t).duration}var ijt=M(()=>{Ls()});function SDe(e,t){if(typeof t!="function")throw new Error;return function(){Ja(this,e).ease=t}}function ojt(e){var t=this._id;return arguments.length?this.each(SDe(t,e)):oo(this.node(),t).ease}var ajt=M(()=>{Ls()});function sjt(e){typeof e!="function"&&(e=bA(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=[],l,c=0;c<a;++c)(l=o[c])&&e.call(l,l.__data__,c,o)&&s.push(l);return new da(n,this._parents,this._name,this._id)}var ljt=M(()=>{Is();dd()});function cjt(e){if(e._id!==this._id)throw new Error;for(var t=this._groups,r=e._groups,n=t.length,i=r.length,o=Math.min(n,i),a=new Array(n),s=0;s<o;++s)for(var l=t[s],c=r[s],u=l.length,h=a[s]=new Array(u),f,p=0;p<u;++p)(f=l[p]||c[p])&&(h[p]=f);for(;s<n;++s)a[s]=t[s];return new da(a,this._parents,this._name,this._id)}var ujt=M(()=>{dd()});function MDe(e){return(e+"").trim().split(/^|\s+/).every(function(t){var r=t.indexOf(".");return r>=0&&(t=t.slice(0,r)),!t||t==="start"})}function EDe(e,t,r){var n,i,o=MDe(t)?DA:Ja;return function(){var a=o(this,e),s=a.on;s!==n&&(i=(n=s).copy()).on(t,r),a.on=i}}function hjt(e,t){var r=this._id;return arguments.length<2?oo(this.node(),r).on.on(e):this.each(EDe(r,e,t))}var fjt=M(()=>{Ls()});function TDe(e){return function(){var t=this.parentNode;for(var r in this.__transition)if(+r!==e)return;t&&t.removeChild(this)}}function pjt(){return this.on("end.remove",TDe(this._id))}var djt=M(()=>{});function mjt(e){var t=this._name,r=this._id;typeof e!="function"&&(e=Cv(e));for(var n=this._groups,i=n.length,o=new Array(i),a=0;a<i;++a)for(var s=n[a],l=s.length,c=o[a]=new Array(l),u,h,f=0;f<l;++f)(u=s[f])&&(h=e.call(u,u.__data__,f,s))&&("__data__"in u&&(h.__data__=u.__data__),c[f]=h,Gg(c[f],t,r,f,c,oo(u,r)));return new da(o,this._parents,t,r)}var gjt=M(()=>{Is();dd();Ls()});function _jt(e){var t=this._name,r=this._id;typeof e!="function"&&(e=xA(e));for(var n=this._groups,i=n.length,o=[],a=[],s=0;s<i;++s)for(var l=n[s],c=l.length,u,h=0;h<c;++h)if(u=l[h]){for(var f=e.call(u,u.__data__,h,l),p,d=oo(u,r),g=0,_=f.length;g<_;++g)(p=f[g])&&Gg(p,t,r,g,f,d);o.push(f),a.push(u)}return new da(o,a,t,r)}var yjt=M(()=>{Is();dd();Ls()});function vjt(){return new CDe(this._groups,this._parents)}var CDe,xjt=M(()=>{Is();CDe=fd.prototype.constructor});function ADe(e,t){var r,n,i;return function(){var o=Ug(this,e),a=(this.style.removeProperty(e),Ug(this,e));return o===a?null:o===r&&a===n?i:i=t(r=o,n=a)}}function bjt(e){return function(){this.style.removeProperty(e)}}function PDe(e,t,r){var n,i=r+"",o;return function(){var a=Ug(this,e);return a===i?null:a===n?o:o=t(n=a,r)}}function IDe(e,t,r){var n,i,o;return function(){var a=Ug(this,e),s=r(this),l=s+"";return s==null&&(l=s=(this.style.removeProperty(e),Ug(this,e))),a===l?null:a===n&&l===i?o:(i=l,o=t(n=a,s))}}function LDe(e,t){var r,n,i,o="style."+t,a="end."+o,s;return function(){var l=Ja(this,e),c=l.on,u=l.value[o]==null?s||(s=bjt(t)):void 0;(c!==r||i!==u)&&(n=(r=c).copy()).on(a,i=u),l.on=n}}function wjt(e,t,r){var n=(e+="")=="transform"?Gnt:iF;return t==null?this.styleTween(e,ADe(e,n)).on("end.style."+e,bjt(e)):typeof t=="function"?this.styleTween(e,IDe(e,n,cS(this,"style."+e,t))).each(LDe(this._id,e)):this.styleTween(e,PDe(e,n,t),r).on("end.style."+e,null)}var Sjt=M(()=>{AA();Is();Ls();OA();Qnt()});function kDe(e,t,r){return function(n){this.style.setProperty(e,t.call(this,n),r)}}function RDe(e,t,r){var n,i;function o(){var a=t.apply(this,arguments);return a!==i&&(n=(i=a)&&kDe(e,a,r)),n}return o._value=t,o}function Mjt(e,t,r){var n="style."+(e+="");if(arguments.length<2)return(n=this.tween(n))&&n._value;if(t==null)return this.tween(n,null);if(typeof t!="function")throw new Error;return this.tween(n,RDe(e,t,r==null?"":r))}var Ejt=M(()=>{});function NDe(e){return function(){this.textContent=e}}function DDe(e){return function(){var t=e(this);this.textContent=t==null?"":t}}function Tjt(e){return this.tween("text",typeof e=="function"?DDe(cS(this,"text",e)):NDe(e==null?"":e+""))}var Cjt=M(()=>{OA()});function ODe(e){return function(t){this.textContent=e.call(this,t)}}function zDe(e){var t,r;function n(){var i=e.apply(this,arguments);return i!==r&&(t=(r=i)&&ODe(i)),t}return n._value=e,n}function Ajt(e){var t="text";if(arguments.length<1)return(t=this.tween(t))&&t._value;if(e==null)return this.tween(t,null);if(typeof e!="function")throw new Error;return this.tween(t,zDe(e))}var Pjt=M(()=>{});function Ijt(){for(var e=this._name,t=this._id,r=oF(),n=this._groups,i=n.length,o=0;o<i;++o)for(var a=n[o],s=a.length,l,c=0;c<s;++c)if(l=a[c]){var u=oo(l,t);Gg(l,e,r,c,a,{time:u.time+u.delay+u.duration,delay:0,duration:u.duration,ease:u.ease})}return new da(n,this._parents,e,r)}var Ljt=M(()=>{dd();Ls()});function kjt(){var e,t,r=this,n=r._id,i=r.size();return new Promise(function(o,a){var s={value:a},l={value:function(){--i===0&&o()}};r.each(function(){var c=Ja(this,n),u=c.on;u!==e&&(t=(e=u).copy(),t._.cancel.push(s),t._.interrupt.push(s),t._.end.push(l)),c.on=t})})}var Rjt=M(()=>{Ls()});function da(e,t,r,n){this._groups=e,this._parents=t,this._name=r,this._id=n}function tit(e){return fd().transition(e)}function oF(){return++FDe}var FDe,uS,dd=M(()=>{Is();JYt();tjt();rjt();ijt();ajt();ljt();ujt();fjt();djt();gjt();yjt();xjt();Sjt();Ejt();Cjt();Pjt();Ljt();OA();Rjt();FDe=0;uS=fd.prototype;da.prototype=tit.prototype={constructor:da,select:mjt,selectAll:_jt,filter:sjt,merge:cjt,selection:vjt,transition:Ijt,call:uS.call,nodes:uS.nodes,node:uS.node,size:uS.size,empty:uS.empty,each:uS.each,on:hjt,attr:ZYt,attrTween:QYt,style:wjt,styleTween:Mjt,text:Tjt,textTween:Ajt,remove:pjt,tween:KYt,delay:ejt,duration:njt,ease:ojt,end:kjt}});function BDe(e,t){for(var r;!(r=e.__transition)||!(r=r[t]);)if(!(e=e.parentNode))return eit.time=lS(),eit;return r}function Njt(e){var t,r;e instanceof da?(t=e._id,e=e._name):(t=oF(),(r=eit).time=lS(),e=e==null?null:e+"");for(var n=this._groups,i=n.length,o=0;o<i;++o)for(var a=n[o],s=a.length,l,c=0;c<s;++c)(l=a[c])&&Gg(l,e,t,c,a,r||BDe(l,t));return new da(n,this._parents,e,t)}var eit,Djt=M(()=>{dd();Ls();I_();Knt();eit={time:null,delay:0,duration:250,ease:xs}});var Ojt=M(()=>{Is();$Yt();Djt();fd.prototype.interrupt=XYt;fd.prototype.transition=Njt});var zjt=M(()=>{dd();Ls()});var Fjt=M(()=>{Ojt();dd();zjt();Jnt()});function zA(e){return function(){return e}}var Bjt=M(()=>{});function rit(e,t,r){this.target=e,this.type=t,this.transform=r}var Hjt=M(()=>{});function Pf(e,t,r){this.k=e,this.x=t,this.y=r}function aF(e){return e.__zoom||hS}var hS,nit=M(()=>{Pf.prototype={constructor:Pf,scale:function(e){return e===1?this:new Pf(this.k*e,this.x,this.y)},translate:function(e,t){return e===0&t===0?this:new Pf(this.k,this.x+this.k*e,this.y+this.k*t)},apply:function(e){return[e[0]*this.k+this.x,e[1]*this.k+this.y]},applyX:function(e){return e*this.k+this.x},applyY:function(e){return e*this.k+this.y},invert:function(e){return[(e[0]-this.x)/this.k,(e[1]-this.y)/this.k]},invertX:function(e){return(e-this.x)/this.k},invertY:function(e){return(e-this.y)/this.k},rescaleX:function(e){return e.copy().domain(e.range().map(this.invertX,this).map(e.invert,e))},rescaleY:function(e){return e.copy().domain(e.range().map(this.invertY,this).map(e.invert,e))},toString:function(){return"translate("+this.x+","+this.y+") scale("+this.k+")"}};hS=new Pf(1,0,0);aF.prototype=Pf.prototype});function sF(){Yr.stopImmediatePropagation()}function fS(){Yr.preventDefault(),Yr.stopImmediatePropagation()}var Vjt=M(()=>{Is()});function HDe(){return!Yr.button}function VDe(){var e=this,t,r;return e instanceof SVGElement?(e=e.ownerSVGElement||e,t=e.width.baseVal.value,r=e.height.baseVal.value):(t=e.clientWidth,r=e.clientHeight),[[0,0],[t,r]]}function Ujt(){return this.__zoom||hS}function UDe(){return-Yr.deltaY*(Yr.deltaMode?120:1)/500}function qDe(){return"ontouchstart"in this}function GDe(e,t,r){var n=e.invertX(t[0][0])-r[0][0],i=e.invertX(t[1][0])-r[1][0],o=e.invertY(t[0][1])-r[0][1],a=e.invertY(t[1][1])-r[1][1];return e.translate(i>n?(n+i)/2:Math.min(0,n)||Math.max(0,i),a>o?(o+a)/2:Math.min(0,o)||Math.max(0,a))}function qjt(){var e=HDe,t=VDe,r=GDe,n=UDe,i=qDe,o=[0,1/0],a=[[-1/0,-1/0],[1/0,1/0]],s=250,l=jnt,c=[],u=vA("start","zoom","end"),h,f,p=500,d=150,g=0;function _(R){R.property("__zoom",Ujt).on("wheel.zoom",k).on("mousedown.zoom",O).on("dblclick.zoom",D).filter(i).on("touchstart.zoom",B).on("touchmove.zoom",I).on("touchend.zoom touchcancel.zoom",L).style("touch-action","none").style("-webkit-tap-highlight-color","rgba(0,0,0,0)")}_.transform=function(R,F){var z=R.selection?R.selection():R;z.property("__zoom",Ujt),R!==z?S(R,F):z.interrupt().each(function(){C(this,arguments).start().zoom(null,typeof F=="function"?F.apply(this,arguments):F).end()})},_.scaleBy=function(R,F){_.scaleTo(R,function(){var z=this.__zoom.k,U=typeof F=="function"?F.apply(this,arguments):F;return z*U})},_.scaleTo=function(R,F){_.transform(R,function(){var z=t.apply(this,arguments),U=this.__zoom,W=b(z),Z=U.invert(W),rt=typeof F=="function"?F.apply(this,arguments):F;return r(x(y(U,rt),W,Z),z,a)})},_.translateBy=function(R,F,z){_.transform(R,function(){return r(this.__zoom.translate(typeof F=="function"?F.apply(this,arguments):F,typeof z=="function"?z.apply(this,arguments):z),t.apply(this,arguments),a)})},_.translateTo=function(R,F,z){_.transform(R,function(){var U=t.apply(this,arguments),W=this.__zoom,Z=b(U);return r(hS.translate(Z[0],Z[1]).scale(W.k).translate(typeof F=="function"?-F.apply(this,arguments):-F,typeof z=="function"?-z.apply(this,arguments):-z),U,a)})};function y(R,F){return F=Math.max(o[0],Math.min(o[1],F)),F===R.k?R:new Pf(F,R.x,R.y)}function x(R,F,z){var U=F[0]-z[0]*R.k,W=F[1]-z[1]*R.k;return U===R.x&&W===R.y?R:new Pf(R.k,U,W)}function b(R){return[(+R[0][0]+ +R[1][0])/2,(+R[0][1]+ +R[1][1])/2]}function S(R,F,z){R.on("start.zoom",function(){C(this,arguments).start()}).on("interrupt.zoom end.zoom",function(){C(this,arguments).end()}).tween("zoom",function(){var U=this,W=arguments,Z=C(U,W),rt=t.apply(U,W),ot=z||b(rt),st=Math.max(rt[1][0]-rt[0][0],rt[1][1]-rt[0][1]),St=U.__zoom,bt=typeof F=="function"?F.apply(U,W):F,Mt=l(St.invert(ot).concat(st/St.k),bt.invert(ot).concat(st/bt.k));return function(lt){if(lt===1)lt=bt;else{var Kt=Mt(lt),_t=st/Kt[2];lt=new Pf(_t,ot[0]-Kt[0]*_t,ot[1]-Kt[1]*_t)}Z.zoom(null,lt)}})}function C(R,F){for(var z=0,U=c.length,W;z<U;++z)if((W=c[z]).that===R)return W;return new P(R,F)}function P(R,F){this.that=R,this.args=F,this.index=-1,this.active=0,this.extent=t.apply(R,F)}P.prototype={start:function(){return++this.active===1&&(this.index=c.push(this)-1,this.emit("start")),this},zoom:function(R,F){return this.mouse&&R!=="mouse"&&(this.mouse[1]=F.invert(this.mouse[0])),this.touch0&&R!=="touch"&&(this.touch0[1]=F.invert(this.touch0[0])),this.touch1&&R!=="touch"&&(this.touch1[1]=F.invert(this.touch1[0])),this.that.__zoom=F,this.emit("zoom"),this},end:function(){return--this.active===0&&(c.splice(this.index,1),this.index=-1,this.emit("end")),this},emit:function(R){Tnt(new rit(_,R,this.that.__zoom),u.apply,u,[R,this.that,this.args])}};function k(){if(!e.apply(this,arguments))return;var R=C(this,arguments),F=this.__zoom,z=Math.max(o[0],Math.min(o[1],F.k*Math.pow(2,n.apply(this,arguments)))),U=iS(this);if(R.wheel)(R.mouse[0][0]!==U[0]||R.mouse[0][1]!==U[1])&&(R.mouse[1]=F.invert(R.mouse[0]=U)),clearTimeout(R.wheel);else{if(F.k===z)return;R.mouse=[U,F.invert(U)],Pv(this),R.start()}fS(),R.wheel=setTimeout(W,d),R.zoom("mouse",r(x(y(F,z),R.mouse[0],R.mouse[1]),R.extent,a));function W(){R.wheel=null,R.end()}}function O(){if(f||!e.apply(this,arguments))return;var R=C(this,arguments),F=pd(Yr.view).on("mousemove.zoom",Z,!0).on("mouseup.zoom",rt,!0),z=iS(this),U=Yr.clientX,W=Yr.clientY;Int(Yr.view),sF(),R.mouse=[z,this.__zoom.invert(z)],Pv(this),R.start();function Z(){if(fS(),!R.moved){var ot=Yr.clientX-U,st=Yr.clientY-W;R.moved=ot*ot+st*st>g}R.zoom("mouse",r(x(R.that.__zoom,R.mouse[0]=iS(R.that),R.mouse[1]),R.extent,a))}function rt(){F.on("mousemove.zoom mouseup.zoom",null),Lnt(Yr.view,R.moved),fS(),R.end()}}function D(){if(!!e.apply(this,arguments)){var R=this.__zoom,F=iS(this),z=R.invert(F),U=R.k*(Yr.shiftKey?.5:2),W=r(x(y(R,U),F,z),t.apply(this,arguments),a);fS(),s>0?pd(this).transition().duration(s).call(S,W,F):pd(this).call(_.transform,W)}}function B(){if(!!e.apply(this,arguments)){var R=C(this,arguments),F=Yr.changedTouches,z,U=F.length,W,Z,rt;for(sF(),W=0;W<U;++W)Z=F[W],rt=Hz(this,F,Z.identifier),rt=[rt,this.__zoom.invert(rt),Z.identifier],R.touch0?R.touch1||(R.touch1=rt):(R.touch0=rt,z=!0);if(h&&(h=clearTimeout(h),!R.touch1)){R.end(),rt=pd(this).on("dblclick.zoom"),rt&&rt.apply(this,arguments);return}z&&(h=setTimeout(function(){h=null},p),Pv(this),R.start())}}function I(){var R=C(this,arguments),F=Yr.changedTouches,z=F.length,U,W,Z,rt;for(fS(),h&&(h=clearTimeout(h)),U=0;U<z;++U)W=F[U],Z=Hz(this,F,W.identifier),R.touch0&&R.touch0[2]===W.identifier?R.touch0[0]=Z:R.touch1&&R.touch1[2]===W.identifier&&(R.touch1[0]=Z);if(W=R.that.__zoom,R.touch1){var ot=R.touch0[0],st=R.touch0[1],St=R.touch1[0],bt=R.touch1[1],Mt=(Mt=St[0]-ot[0])*Mt+(Mt=St[1]-ot[1])*Mt,lt=(lt=bt[0]-st[0])*lt+(lt=bt[1]-st[1])*lt;W=y(W,Math.sqrt(Mt/lt)),Z=[(ot[0]+St[0])/2,(ot[1]+St[1])/2],rt=[(st[0]+bt[0])/2,(st[1]+bt[1])/2]}else if(R.touch0)Z=R.touch0[0],rt=R.touch0[1];else return;R.zoom("touch",r(x(W,Z,rt),R.extent,a))}function L(){var R=C(this,arguments),F=Yr.changedTouches,z=F.length,U,W;for(sF(),f&&clearTimeout(f),f=setTimeout(function(){f=null},p),U=0;U<z;++U)W=F[U],R.touch0&&R.touch0[2]===W.identifier?delete R.touch0:R.touch1&&R.touch1[2]===W.identifier&&delete R.touch1;R.touch1&&!R.touch0&&(R.touch0=R.touch1,delete R.touch1),R.touch0?R.touch0[1]=this.__zoom.invert(R.touch0[0]):R.end()}return _.wheelDelta=function(R){return arguments.length?(n=typeof R=="function"?R:zA(+R),_):n},_.filter=function(R){return arguments.length?(e=typeof R=="function"?R:zA(!!R),_):e},_.touchable=function(R){return arguments.length?(i=typeof R=="function"?R:zA(!!R),_):i},_.extent=function(R){return arguments.length?(t=typeof R=="function"?R:zA([[+R[0][0],+R[0][1]],[+R[1][0],+R[1][1]]]),_):t},_.scaleExtent=function(R){return arguments.length?(o[0]=+R[0],o[1]=+R[1],_):[o[0],o[1]]},_.translateExtent=function(R){return arguments.length?(a[0][0]=+R[0][0],a[1][0]=+R[1][0],a[0][1]=+R[0][1],a[1][1]=+R[1][1],_):[[a[0][0],a[0][1]],[a[1][0],a[1][1]]]},_.constrain=function(R){return arguments.length?(r=R,_):r},_.duration=function(R){return arguments.length?(s=+R,_):s},_.interpolate=function(R){return arguments.length?(l=R,_):l},_.on=function(){var R=u.on.apply(u,arguments);return R===u?_:R},_.clickDistance=function(R){return arguments.length?(g=(R=+R)*R,_):Math.sqrt(g)},_}var Gjt=M(()=>{mnt();cYt();AA();Is();Fjt();Bjt();Hjt();nit();Vjt()});var Wjt=M(()=>{Gjt();nit()});var Mr={};Ks(Mr,{active:()=>mGt,arc:()=>gFt,area:()=>b7,areaRadial:()=>ket,ascending:()=>_c,axisBottom:()=>ZMt,axisLeft:()=>JMt,axisRight:()=>KMt,axisTop:()=>$Mt,bisect:()=>sR,bisectLeft:()=>sMt,bisectRight:()=>x$,bisector:()=>aR,brush:()=>yCt,brushSelection:()=>mCt,brushX:()=>gCt,brushY:()=>_Ct,chord:()=>UCt,clientPoint:()=>Dg,cluster:()=>GLt,color:()=>x2,create:()=>tFt,creator:()=>Ng,cross:()=>cMt,csv:()=>pNt,csvFormat:()=>yPt,csvFormatRows:()=>vPt,csvParse:()=>gPt,csvParseRows:()=>_Pt,cubehelix:()=>uN,curveBasis:()=>OFt,curveBasisClosed:()=>FFt,curveBasisOpen:()=>VFt,curveBundle:()=>GFt,curveCardinal:()=>YFt,curveCardinalClosed:()=>jFt,curveCardinalOpen:()=>XFt,curveCatmullRom:()=>KFt,curveCatmullRomClosed:()=>JFt,curveCatmullRomOpen:()=>eBt,curveLinear:()=>Fg,curveLinearClosed:()=>iBt,curveMonotoneX:()=>hBt,curveMonotoneY:()=>fBt,curveNatural:()=>gBt,curveStep:()=>yBt,curveStepAfter:()=>xBt,curveStepBefore:()=>vBt,customEvent:()=>Xzt,descending:()=>hMt,deviation:()=>cR,dispatch:()=>kAt,drag:()=>hPt,dragDisable:()=>EN,dragEnable:()=>TN,dsvFormat:()=>w2,easeBack:()=>OZ,easeBackIn:()=>JPt,easeBackInOut:()=>OZ,easeBackOut:()=>QPt,easeBounce:()=>S2,easeBounceIn:()=>$Pt,easeBounceInOut:()=>KPt,easeBounceOut:()=>S2,easeCircle:()=>RZ,easeCircleIn:()=>YPt,easeCircleInOut:()=>RZ,easeCircleOut:()=>jPt,easeCubic:()=>AZ,easeCubicIn:()=>kPt,easeCubicInOut:()=>AZ,easeCubicOut:()=>RPt,easeElastic:()=>BZ,easeElasticIn:()=>e6t,easeElasticInOut:()=>r6t,easeElasticOut:()=>BZ,easeExp:()=>kZ,easeExpIn:()=>qPt,easeExpInOut:()=>kZ,easeExpOut:()=>GPt,easeLinear:()=>CPt,easePoly:()=>IZ,easePolyIn:()=>DPt,easePolyInOut:()=>IZ,easePolyOut:()=>OPt,easeQuad:()=>CZ,easeQuadIn:()=>PPt,easeQuadInOut:()=>CZ,easeQuadOut:()=>IPt,easeSin:()=>LZ,easeSinIn:()=>HPt,easeSinInOut:()=>LZ,easeSinOut:()=>VPt,entries:()=>hAt,event:()=>Pu,extent:()=>uR,forceCenter:()=>o6t,forceCollide:()=>F6t,forceLink:()=>j6t,forceManyBody:()=>lIt,forceRadial:()=>uIt,forceSimulation:()=>sIt,forceX:()=>fIt,forceY:()=>dIt,format:()=>rJ,formatDefaultLocale:()=>WN,formatLocale:()=>qN,formatPrefix:()=>nJ,formatSpecifier:()=>Ly,geoAlbers:()=>DD,geoAlbersUsa:()=>vLt,geoArea:()=>UIt,geoAzimuthalEqualArea:()=>bLt,geoAzimuthalEqualAreaRaw:()=>zD,geoAzimuthalEquidistant:()=>SLt,geoAzimuthalEquidistantRaw:()=>FD,geoBounds:()=>KIt,geoCentroid:()=>n9t,geoCircle:()=>u9t,geoClipAntimeridian:()=>zT,geoClipCircle:()=>_D,geoClipExtent:()=>R9t,geoClipRectangle:()=>Qp,geoConicConformal:()=>TLt,geoConicConformalRaw:()=>fQ,geoConicEqualArea:()=>Uy,geoConicEqualAreaRaw:()=>cQ,geoConicEquidistant:()=>PLt,geoConicEquidistantRaw:()=>dQ,geoContains:()=>V9t,geoDistance:()=>By,geoEquirectangular:()=>ALt,geoEquirectangularRaw:()=>Gy,geoGnomonic:()=>LLt,geoGnomonicRaw:()=>VD,geoGraticule:()=>SD,geoGraticule10:()=>W9t,geoIdentity:()=>RLt,geoInterpolate:()=>j9t,geoLength:()=>bD,geoMercator:()=>ELt,geoMercatorRaw:()=>qy,geoNaturalEarth1:()=>DLt,geoNaturalEarth1Raw:()=>qD,geoOrthographic:()=>zLt,geoOrthographicRaw:()=>GD,geoPath:()=>fLt,geoProjection:()=>eo,geoProjectionMutator:()=>YT,geoRotation:()=>lD,geoStereographic:()=>BLt,geoStereographicRaw:()=>WD,geoStream:()=>Mo,geoTransform:()=>dLt,geoTransverseMercator:()=>VLt,geoTransverseMercatorRaw:()=>YD,hcl:()=>iZ,hierarchy:()=>jT,histogram:()=>xMt,hsl:()=>ZK,html:()=>oNt,interpolate:()=>Z2,interpolateArray:()=>fO,interpolateBasis:()=>cO,interpolateBasisClosed:()=>hO,interpolateCool:()=>E7t,interpolateCubehelix:()=>q8t,interpolateCubehelixDefault:()=>w7t,interpolateCubehelixLong:()=>G8t,interpolateDate:()=>dO,interpolateHcl:()=>B8t,interpolateHclLong:()=>H8t,interpolateHsl:()=>N8t,interpolateHslLong:()=>D8t,interpolateInferno:()=>I7t,interpolateLab:()=>$Q,interpolateMagma:()=>P7t,interpolateNumber:()=>As,interpolateObject:()=>mO,interpolatePlasma:()=>L7t,interpolateRainbow:()=>T7t,interpolateRgb:()=>eC,interpolateRgbBasis:()=>m8t,interpolateRgbBasisClosed:()=>g8t,interpolateRound:()=>_8t,interpolateString:()=>gO,interpolateTransformCss:()=>T8t,interpolateTransformSvg:()=>C8t,interpolateViridis:()=>A7t,interpolateWarm:()=>M7t,interpolateZoom:()=>L8t,interrupt:()=>dz,interval:()=>EVt,isoFormat:()=>gVt,isoParse:()=>_Vt,json:()=>sNt,keys:()=>sAt,lab:()=>lN,line:()=>Rw,lineRadial:()=>Iet,linkHorizontal:()=>CFt,linkRadial:()=>PFt,linkVertical:()=>AFt,local:()=>m7,map:()=>by,matcher:()=>u7,max:()=>TMt,mean:()=>AMt,median:()=>IMt,merge:()=>kMt,min:()=>mR,mouse:()=>nFt,namespace:()=>Mw,namespaces:()=>EC,nest:()=>rAt,now:()=>Yw,pack:()=>Tkt,packEnclose:()=>$D,packSiblings:()=>wkt,pairs:()=>lMt,partition:()=>Akt,path:()=>K8t,permute:()=>NMt,pie:()=>SFt,pointRadial:()=>fv,polygonArea:()=>Q8t,polygonCentroid:()=>eRt,polygonContains:()=>lRt,polygonHull:()=>aRt,polygonLength:()=>uRt,precisionFixed:()=>AIt,precisionPrefix:()=>IIt,precisionRound:()=>kIt,quadtree:()=>xO,quantile:()=>dy,quantize:()=>Y8t,queue:()=>wO,radialArea:()=>ket,radialLine:()=>Iet,randomBates:()=>tNt,randomExponential:()=>rNt,randomIrwinHall:()=>MO,randomLogNormal:()=>JRt,randomNormal:()=>SO,randomUniform:()=>KRt,range:()=>hR,request:()=>J2,rgb:()=>KK,ribbon:()=>KCt,scaleBand:()=>cC,scaleIdentity:()=>qO,scaleImplicit:()=>kO,scaleLinear:()=>UO,scaleLog:()=>WO,scaleOrdinal:()=>nw,scalePoint:()=>YNt,scalePow:()=>_C,scaleQuantile:()=>YO,scaleQuantize:()=>jO,scaleSequential:()=>i7,scaleSqrt:()=>aOt,scaleThreshold:()=>XO,scaleTime:()=>h7t,scaleUtc:()=>f7t,scan:()=>OMt,schemeCategory10:()=>d7t,schemeCategory20:()=>x7t,schemeCategory20b:()=>g7t,schemeCategory20c:()=>y7t,select:()=>d7,selectAll:()=>oFt,selection:()=>Qzt,selector:()=>Ew,selectorAll:()=>c7,set:()=>oAt,shuffle:()=>FMt,stack:()=>wBt,stackOffsetDiverging:()=>TBt,stackOffsetExpand:()=>MBt,stackOffsetNone:()=>Ru,stackOffsetSilhouette:()=>ABt,stackOffsetWiggle:()=>IBt,stackOrderAscending:()=>D7,stackOrderDescending:()=>kBt,stackOrderInsideOut:()=>NBt,stackOrderNone:()=>Nu,stackOrderReverse:()=>OBt,stratify:()=>kkt,style:()=>_et,sum:()=>HMt,symbol:()=>NFt,symbolCircle:()=>RC,symbolCross:()=>S7,symbolDiamond:()=>M7,symbolSquare:()=>T7,symbolStar:()=>E7,symbolTriangle:()=>C7,symbolWye:()=>A7,symbols:()=>RFt,text:()=>cNt,thresholdFreedmanDiaconis:()=>wMt,thresholdScott:()=>MMt,thresholdSturges:()=>pR,tickIncrement:()=>k$,tickStep:()=>fR,ticks:()=>vMt,timeDay:()=>ZBt,timeDays:()=>JBt,timeFormat:()=>wrt,timeFormatDefaultLocale:()=>X7,timeFormatLocale:()=>YC,timeFriday:()=>ort,timeFridays:()=>iHt,timeHour:()=>jBt,timeHours:()=>XBt,timeInterval:()=>Sr,timeMillisecond:()=>Zet,timeMilliseconds:()=>Jet,timeMinute:()=>qBt,timeMinutes:()=>GBt,timeMonday:()=>ert,timeMondays:()=>tHt,timeMonth:()=>lHt,timeMonths:()=>cHt,timeParse:()=>Srt,timeSaturday:()=>art,timeSaturdays:()=>oHt,timeSecond:()=>Qet,timeSeconds:()=>trt,timeSunday:()=>H7,timeSundays:()=>srt,timeThursday:()=>irt,timeThursdays:()=>nHt,timeTuesday:()=>rrt,timeTuesdays:()=>eHt,timeWednesday:()=>nrt,timeWednesdays:()=>rHt,timeWeek:()=>H7,timeWeeks:()=>srt,timeYear:()=>hHt,timeYears:()=>fHt,timeout:()=>SVt,timer:()=>Crt,timerFlush:()=>Art,touch:()=>sFt,touches:()=>cFt,transition:()=>Tz,transpose:()=>gR,tree:()=>Nkt,treemap:()=>Okt,treemapBinary:()=>Fkt,treemapDice:()=>lf,treemapResquarify:()=>Ukt,treemapSlice:()=>wg,treemapSliceDice:()=>Hkt,treemapSquarify:()=>tO,tsv:()=>mNt,tsvFormat:()=>SPt,tsvFormatRows:()=>MPt,tsvParse:()=>bPt,tsvParseRows:()=>wPt,utcDay:()=>SHt,utcDays:()=>MHt,utcFormat:()=>jC,utcFriday:()=>prt,utcFridays:()=>IHt,utcHour:()=>vHt,utcHours:()=>xHt,utcMillisecond:()=>Zet,utcMilliseconds:()=>Jet,utcMinute:()=>mHt,utcMinutes:()=>gHt,utcMonday:()=>crt,utcMondays:()=>THt,utcMonth:()=>NHt,utcMonths:()=>DHt,utcParse:()=>XC,utcSaturday:()=>drt,utcSaturdays:()=>LHt,utcSecond:()=>Qet,utcSeconds:()=>trt,utcSunday:()=>V7,utcSundays:()=>mrt,utcThursday:()=>frt,utcThursdays:()=>PHt,utcTuesday:()=>urt,utcTuesdays:()=>CHt,utcWednesday:()=>hrt,utcWednesdays:()=>AHt,utcWeek:()=>V7,utcWeeks:()=>mrt,utcYear:()=>zHt,utcYears:()=>FHt,values:()=>cAt,variance:()=>lR,version:()=>iMt,voronoi:()=>DGt,window:()=>Cw,xml:()=>hNt,zip:()=>UMt,zoom:()=>qjt,zoomIdentity:()=>hS,zoomTransform:()=>aF});var Er=M(()=>{oMt();GMt();tEt();xCt();JCt();pAt();PAt();NAt();pPt();TPt();i6t();gIt();NIt();qLt();Gkt();X8t();J8t();fRt();GRt();$Rt();iNt();_Nt();N7t();hFt();FBt();HHt();vVt();CVt();_Gt();zGt();Wjt()});var $jt=H(Xjt=>{"use strict";Object.defineProperty(Xjt,"__esModule",{value:!0});var Yjt=(Er(),Ut(Mr)),Wg=Yjt,jjt=Yjt;function WDe(e,t){return e.each(function(){var r=t.apply(this,arguments),n=Wg.select(this);for(var i in r)n.attr(i,r[i])})}function YDe(e,t){for(var r in t)e.attr(r,t[r]);return e}function jDe(e){return(typeof e=="function"?WDe:YDe)(this,e)}function XDe(e,t,r){return e.each(function(){var n=t.apply(this,arguments),i=Wg.select(this);for(var o in n)i.style(o,n[o],r)})}function $De(e,t,r){for(var n in t)e.style(n,t[n],r);return e}function KDe(e,t){return(typeof e=="function"?XDe:$De)(this,e,t==null?"":t)}function ZDe(e,t){return e.each(function(){var r=t.apply(this,arguments),n=Wg.select(this);for(var i in r)n.property(i,r[i])})}function JDe(e,t){for(var r in t)e.property(r,t[r]);return e}function QDe(e){return(typeof e=="function"?ZDe:JDe)(this,e)}function tOe(e,t){return e.each(function(){var r=t.apply(this,arguments),n=Wg.select(this).transition(e);for(var i in r)n.attr(i,r[i])})}function eOe(e,t){for(var r in t)e.attr(r,t[r]);return e}function rOe(e){return(typeof e=="function"?tOe:eOe)(this,e)}function nOe(e,t,r){return e.each(function(){var n=t.apply(this,arguments),i=Wg.select(this).transition(e);for(var o in n)i.style(o,n[o],r)})}function iOe(e,t,r){for(var n in t)e.style(n,t[n],r);return e}function oOe(e,t){return(typeof e=="function"?nOe:iOe)(this,e,t==null?"":t)}Wg.selection.prototype.attrs=jDe;Wg.selection.prototype.styles=KDe;Wg.selection.prototype.properties=QDe;jjt.transition.prototype.attrs=rOe;jjt.transition.prototype.styles=oOe});var Yg=H(iit=>{"use strict";Object.defineProperty(iit,"__esModule",{value:!0});var Kjt=(Er(),Ut(Mr));function aOe(e){if(e.attrs==null)if(e.nodes==null){var t=[];return e.each(function(){t.push(this)}),Kjt.selectAll(t)}else return Kjt.selectAll(e.nodes());else return e}iit.coerceExternalD3=aOe});var If=H(oit=>{"use strict";Object.defineProperty(oit,"__esModule",{value:!0});function sOe(e){return e.reduce(function(t,r){return t[r]=r,t},{})}oit.makeEnum=sOe});var Jjt=H(lF=>{"use strict";Object.defineProperty(lF,"__esModule",{value:!0});var dr=(I_(),Ut(Bvt)),lOe=Yg(),cOe=If(),Zjt={linear:dr.easeLinear,quad:dr.easeQuad,quadIn:dr.easeQuadIn,quadOut:dr.easeQuadOut,quadInOut:dr.easeQuadInOut,cubic:dr.easeCubic,cubicIn:dr.easeCubicIn,cubicOut:dr.easeCubicOut,cubicInOut:dr.easeCubicInOut,poly:dr.easePoly,polyIn:dr.easePolyIn,polyOut:dr.easePolyOut,polyInOut:dr.easePolyInOut,sin:dr.easeSin,sinIn:dr.easeSinIn,sinOut:dr.easeSinOut,sinInOut:dr.easeSinInOut,exp:dr.easeExp,expIn:dr.easeExpIn,expOut:dr.easeExpOut,expInOut:dr.easeExpInOut,circle:dr.easeCircle,circleIn:dr.easeCircleIn,circleOut:dr.easeCircleOut,circleInOut:dr.easeCircleInOut,bounce:dr.easeBounce,bounceIn:dr.easeBounceIn,bounceOut:dr.easeBounceOut,bounceInOut:dr.easeBounceInOut,back:dr.easeBack,backIn:dr.easeBackIn,backOut:dr.easeBackOut,backInOut:dr.easeBackInOut,elastic:dr.easeElastic,elasticIn:dr.easeElasticIn,elasticOut:dr.easeElasticOut,elasticInOut:dr.easeElasticInOut};lF.EaseName=cOe.makeEnum(["linear","quad","quadIn","quadOut","quadInOut","cubic","cubicIn","cubicOut","cubicInOut","poly","polyIn","polyOut","polyInOut","sin","sinIn","sinOut","sinInOut","exp","expIn","expOut","expInOut","circle","circleIn","circleOut","circleInOut","bounce","bounceIn","bounceOut","bounceInOut","back","backIn","backOut","backInOut","elastic","elasticIn","elasticOut","elasticInOut"]);var uOe=function(){function e(){this._startDelay=e._DEFAULT_START_DELAY_MILLISECONDS,this._stepDuration=e._DEFAULT_STEP_DURATION_MILLISECONDS,this._stepDelay=e._DEFAULT_ITERATIVE_DELAY_MILLISECONDS,this._maxTotalDuration=e._DEFAULT_MAX_TOTAL_DURATION_MILLISECONDS,this._easingMode=e._DEFAULT_EASING_MODE}return e.prototype.totalTime=function(t){var r=this._getAdjustedIterativeDelay(t);return this.startDelay()+r*Math.max(t-1,0)+this.stepDuration()},e.prototype.animate=function(t,r){var n=this;t=lOe.coerceExternalD3(t);var i=t.size(),o=this._getAdjustedIterativeDelay(i);return t.transition().ease(this._getEaseFactory()).duration(this.stepDuration()).delay(function(a,s){return n.startDelay()+o*s}).attrs(r)},e.prototype.startDelay=function(t){return t==null?this._startDelay:(this._startDelay=t,this)},e.prototype.stepDuration=function(t){return t==null?Math.min(this._stepDuration,this._maxTotalDuration):(this._stepDuration=t,this)},e.prototype.stepDelay=function(t){return t==null?this._stepDelay:(this._stepDelay=t,this)},e.prototype.maxTotalDuration=function(t){return t==null?this._maxTotalDuration:(this._maxTotalDuration=t,this)},e.prototype.easingMode=function(t){return t==null?this._easingMode:(this._easingMode=t,this)},e.prototype._getEaseFactory=function(){var t=this.easingMode();if(typeof t=="string"){var r=Zjt[t];return r==null?Zjt.linear:r}else return t},e.prototype._getAdjustedIterativeDelay=function(t){var r=this.maxTotalDuration()-this.stepDuration();r=Math.max(r,0);var n=r/Math.max(t-1,1);return Math.min(this.stepDelay(),n)},e._DEFAULT_START_DELAY_MILLISECONDS=0,e._DEFAULT_STEP_DURATION_MILLISECONDS=300,e._DEFAULT_ITERATIVE_DELAY_MILLISECONDS=15,e._DEFAULT_MAX_TOTAL_DURATION_MILLISECONDS=1/0,e._DEFAULT_EASING_MODE="expOut",e}();lF.Easing=uOe});var Qjt=H(ait=>{"use strict";Object.defineProperty(ait,"__esModule",{value:!0});var hOe=Yg(),fOe=function(){function e(){}return e.prototype.totalTime=function(t){return 0},e.prototype.animate=function(t,r){return t=hOe.coerceExternalD3(t),t.attrs(r)},e}();ait.Null=fOe});var Lf=H(cF=>{"use strict";Object.defineProperty(cF,"__esModule",{value:!0});var tXt=(de(),Ut(pe));tXt.__exportStar(Jjt(),cF);tXt.__exportStar(Qjt(),cF)});var eXt=H(sit=>{"use strict";Object.defineProperty(sit,"__esModule",{value:!0});var pOe=function(){function e(t){this.cache={},this.compute=t}return e.prototype.get=function(t){return this.cache.hasOwnProperty(t)||(this.cache[t]=this.compute(t)),this.cache[t]},e.prototype.clear=function(){return this.cache={},this},e}();sit.Cache=pOe});var rXt=H(lit=>{"use strict";Object.defineProperty(lit,"__esModule",{value:!0});var dOe=function(){function e(){}return e.arrayEq=function(t,r){if(t==null||r==null)return t===r;if(t.length!==r.length)return!1;for(var n=0;n<t.length;n++)if(t[n]!==r[n])return!1;return!0},e.objEq=function(t,r){if(t==null||r==null)return t===r;var n=Object.keys(t).sort(),i=Object.keys(r).sort(),o=n.map(function(s){return t[s]}),a=i.map(function(s){return r[s]});return e.arrayEq(n,i)&&e.arrayEq(o,a)},e.strictEq=function(t,r){return t===r},e.defaults=function(t){for(var r=[],n=1;n<arguments.length;n++)r[n-1]=arguments[n];if(t==null)throw new TypeError("Cannot convert undefined or null to object");var i=Object(t);return r.forEach(function(o){if(o!=null)for(var a in o)Object.prototype.hasOwnProperty.call(o,a)&&(i[a]=o[a])}),i},e}();lit.Methods=dOe});var nXt=H(cit=>{"use strict";Object.defineProperty(cit,"__esModule",{value:!0});var mOe=function(){function e(){}return e.combineWhitespace=function(t){return t.replace(/[ \t]+/g," ")},e.isNotEmptyString=function(t){return t&&t.trim()!==""},e.trimStart=function(t,r){if(!t)return t;var n=t.split(""),i=r?function(o){return o.split(r).some(e.isNotEmptyString)}:e.isNotEmptyString;return n.reduce(function(o,a){return i(o+a)?o+a:o},"")},e.trimEnd=function(t,r){if(!t)return t;var n=t.split("");return n.reverse(),n=e.trimStart(n.join(""),r).split(""),n.reverse(),n.join("")},e}();cit.StringMethods=mOe});var iXt=H(uit=>{"use strict";Object.defineProperty(uit,"__esModule",{value:!0});var gOe=function(){function e(){this.WordDividerRegExp=new RegExp("\\W"),this.WhitespaceRegExp=new RegExp("\\s")}return e.prototype.tokenize=function(t){var r=this;return t.split("").reduce(function(n,i){return n.slice(0,-1).concat(r.shouldCreateNewToken(n[n.length-1],i))},[""])},e.prototype.shouldCreateNewToken=function(t,r){if(!t)return[r];var n=t[t.length-1];return this.WhitespaceRegExp.test(n)&&this.WhitespaceRegExp.test(r)?[t+r]:this.WhitespaceRegExp.test(n)||this.WhitespaceRegExp.test(r)?[t,r]:this.WordDividerRegExp.test(n)?n===r?[t+r]:[t,r]:[t+r]},e}();uit.Tokenizer=gOe});var pS=H(uF=>{"use strict";function hF(e){for(var t in e)uF.hasOwnProperty(t)||(uF[t]=e[t])}Object.defineProperty(uF,"__esModule",{value:!0});hF(eXt());hF(rXt());hF(nXt());hF(iXt())});var aXt=H(hit=>{"use strict";Object.defineProperty(hit,"__esModule",{value:!0});var oXt=pS(),_Oe={textRotation:0,textShear:0,xAlign:"left",yAlign:"top"},fF=function(){function e(t,r,n){this._measurer=t,this._penFactory=r,this._wrapper=n}return e.prototype.measurer=function(t){return this._measurer=t,this},e.prototype.wrapper=function(t){return this._wrapper=t,this},e.prototype.penFactory=function(t){return this._penFactory=t,this},e.prototype.write=function(t,r,n,i,o){if(i===void 0&&(i={}),i=oXt.Methods.defaults({},_Oe,i),e.SupportedRotation.indexOf(i.textRotation)===-1)throw new Error("unsupported rotation - "+i.textRotation+". Supported rotations are "+e.SupportedRotation.join(", "));if(i.textShear!=null&&i.textShear<-80||i.textShear>80)throw new Error("unsupported shear angle - "+i.textShear+". Must be between -80 and 80");var a=Math.abs(Math.abs(i.textRotation)-90)>45,s=a?r:n,l=a?n:r,c=i.textShear,u=c*Math.PI/180,h=this._measurer.measure().height,f=h*Math.tan(u),p=s/Math.cos(u)-Math.abs(f),d=l*Math.cos(u),g=oXt.StringMethods.combineWhitespace(t),_=this._wrapper?this._wrapper.wrap(g,this._measurer,p,d).wrappedText:g,y=_.split(`
`),x=e.XOffsetFactor[i.xAlign]*p*Math.sin(u),b=e.YOffsetFactor[i.yAlign]*(d-y.length*h),S=x-b,C=[0,0],P=i.textRotation+c;switch(i.textRotation){case 90:C=[r+S,0];break;case-90:C=[-S,n];break;case 180:C=[r,n+S];break;default:C=[0,-S];break}var k=this._penFactory.createPen(t,{translate:C,rotate:P},o);this.writeLines(y,k,p,h,f,i.xAlign),k.destroy!=null&&k.destroy()},e.prototype.writeLines=function(t,r,n,i,o,a){t.forEach(function(s,l){var c=o>0?(l+1)*o:l*o;r.write(s,n,a,c,(l+1)*i)})},e}();fF.XOffsetFactor={center:.5,left:0,right:1};fF.YOffsetFactor={bottom:1,center:.5,top:0};fF.SupportedRotation=[-90,0,180,90];hit.Writer=fF});var FA=H(pF=>{"use strict";function yOe(e){for(var t in e)pF.hasOwnProperty(t)||(pF[t]=e[t])}Object.defineProperty(pF,"__esModule",{value:!0});yOe(aXt())});var fit=H(dF=>{"use strict";Object.defineProperty(dF,"__esModule",{value:!0});var BA=function(){function e(){}return e.append=function(t,r){for(var n=[],i=2;i<arguments.length;i++)n[i-2]=arguments[i];var o=e.create.apply(e,[r].concat(n));return t.appendChild(o),o},e.create=function(t){for(var r=[],n=1;n<arguments.length;n++)r[n-1]=arguments[n];var i=document.createElement(t);return e.addClasses.apply(e,[i].concat(r)),i},e.addClasses=function(t){for(var r=[],n=1;n<arguments.length;n++)r[n-1]=arguments[n];r=r.filter(function(i){return i!=null}),t.classList!=null?r.forEach(function(i){t.classList.add(i)}):t.setAttribute("class",r.join(" "))},e.getDimensions=function(t){if(t.getBoundingClientRect)try{var r=t.getBoundingClientRect(),n=r.width,i=r.height;return{width:n,height:i}}catch(o){}return{height:0,width:0}},e}();dF.HtmlUtils=BA;var vOe=function(){function e(t,r,n){n===void 0&&(n=!1);var i=this;this.element=t,this.className=r,this.addTitle=n,this.createRuler=function(){return function(o){var a=BA.append(i.element,"span","text-tmp",i.className);a.textContent=o;var s=BA.getDimensions(a);return i.element.removeChild(a),s}},this.createPen=function(o,a,s){s==null&&(s=i.element);var l=BA.append(s,"div","text-block",i.className);return l.style.position="relative",l.style.transform="translate(0, -1em) "+("translate("+a.translate[0]+"px, "+a.translate[1]+"px) ")+("rotate("+a.rotate+"deg)"),l.style.transformOrigin="0 1.2em",i.addTitle&&l.setAttribute("title",o),i.createHtmlLinePen(l)}}return e.prototype.setAddTitle=function(t){this.addTitle=t},e.prototype.createHtmlLinePen=function(t){return{write:function(r,n,i,o,a){var s=BA.append(t,"div","text-line");s.textContent=r,s.style.width=n+"px",s.style.textAlign=i,s.style.position="absolute",s.style.whiteSpace="nowrap",s.style.top=a+"px",s.style.left=o+"px"}}},e}();dF.HtmlContext=vOe});var cXt=H(mF=>{"use strict";Object.defineProperty(mF,"__esModule",{value:!0});var xOe=FA(),sXt=fit(),jg=function(){function e(){}return e.append=function(t,r){for(var n=[],i=2;i<arguments.length;i++)n[i-2]=arguments[i];var o=e.create.apply(e,[r].concat(n));return t.appendChild(o),o},e.create=function(t){for(var r=[],n=1;n<arguments.length;n++)r[n-1]=arguments[n];var i=document.createElementNS(e.SVG_NS,t);return sXt.HtmlUtils.addClasses.apply(sXt.HtmlUtils,[i].concat(r)),i},e.getDimensions=function(t){if(t.getBBox)try{var r=t.getBBox(),n=r.width,i=r.height;return{width:n,height:i}}catch(o){}return{height:0,width:0}},e}();jg.SVG_NS="http://www.w3.org/2000/svg";mF.SvgUtils=jg;var lXt=function(){function e(t,r,n){n===void 0&&(n=!1);var i=this;this.element=t,this.className=r,this.addTitleElement=n,this.createRuler=function(){var o=i.getTextElements(i.element),a=o.parentElement,s=o.containerElement,l=o.textElement;return function(c){a.appendChild(s),l.textContent=c;var u=jg.getDimensions(l);return a.removeChild(s),u}},this.createPen=function(o,a,s){s==null&&(s=i.element);var l=jg.append(s,"g","text-container",i.className);i.addTitleElement&&(jg.append(l,"title").textContent=o,l.setAttribute("title",o));var c=jg.append(l,"g","text-area");return c.setAttribute("transform","translate("+a.translate[0]+","+a.translate[1]+")"+("rotate("+a.rotate+")")),i.createSvgLinePen(c)}}return e.prototype.setAddTitleElement=function(t){this.addTitleElement=t},e.prototype.createSvgLinePen=function(t){return{write:function(r,n,i,o,a){o+=n*xOe.Writer.XOffsetFactor[i];var s=jg.append(t,"text","text-line");s.textContent=r,s.setAttribute("text-anchor",e.AnchorMap[i]),s.setAttribute("transform","translate("+o+","+a+")"),s.setAttribute("y","-0.25em")}}},e.prototype.getTextElements=function(t){if(t.tagName==="text"){var r=t.parentElement;return r==null&&(r=t.parentNode),r.removeChild(t),{containerElement:t,parentElement:r,textElement:t}}var n=t.querySelector("text");if(n!=null){var r=n.parentElement;return r==null&&(r=n.parentNode),r.removeChild(n),{containerElement:n,parentElement:r,textElement:n}}var i=jg.create("text",this.className);return{containerElement:i,parentElement:t,textElement:i}},e}();lXt.AnchorMap={center:"middle",left:"start",right:"end"};mF.SvgContext=lXt});var uXt=H(pit=>{"use strict";Object.defineProperty(pit,"__esModule",{value:!0});var bOe=FA(),wOe="#444",SOe=function(){function e(t,r,n){r===void 0&&(r=10),n===void 0&&(n={});var i=this;this.ctx=t,this.lineHeight=r,this.style=n,this.createRuler=function(){return function(o){i.ctx.font=i.style.font;var a=i.ctx.measureText(o).width;return{width:a,height:i.lineHeight}}},this.createPen=function(o,a,s){return s==null&&(s=i.ctx),s.save(),s.translate(a.translate[0],a.translate[1]),s.rotate(a.rotate*Math.PI/180),i.createCanvasPen(s)},this.style.fill===void 0&&(this.style.fill=wOe)}return e.prototype.createCanvasPen=function(t){var r=this;return{destroy:function(){t.restore()},write:function(n,i,o,a,s){a+=i*bOe.Writer.XOffsetFactor[o],t.textAlign=o,r.style.font!=null&&(t.font=r.style.font),r.style.fill!=null&&(t.fillStyle=r.style.fill,t.fillText(n,a,s)),r.style.stroke!=null&&(t.strokeStyle=r.style.fill,t.strokeText(n,a,s))}}},e}();pit.CanvasContext=SOe});var mit=H(gF=>{"use strict";function dit(e){for(var t in e)gF.hasOwnProperty(t)||(gF[t]=e[t])}Object.defineProperty(gF,"__esModule",{value:!0});dit(cXt());dit(uXt());dit(fit())});var _F=H(git=>{"use strict";Object.defineProperty(git,"__esModule",{value:!0});var hXt=function(){function e(t){t.createRuler!=null?this.ruler=t.createRuler():this.ruler=t}return e.prototype.measure=function(t){return t===void 0&&(t=e.HEIGHT_TEXT),this.ruler(t)},e}();hXt.HEIGHT_TEXT="bdpql";git.AbstractMeasurer=hXt});var _it=H(HA=>{"use strict";var MOe=HA&&HA.__extends||function(){var e=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(t,r){t.__proto__=r}||function(t,r){for(var n in r)r.hasOwnProperty(n)&&(t[n]=r[n])};return function(t,r){e(t,r);function n(){this.constructor=t}t.prototype=r===null?Object.create(r):(n.prototype=r.prototype,new n)}}();Object.defineProperty(HA,"__esModule",{value:!0});var yF=_F(),EOe=function(e){MOe(t,e);function t(r,n){n===void 0&&(n=!1);var i=e.call(this,r)||this;return i.useGuards=n,i}return t.prototype._addGuards=function(r){return yF.AbstractMeasurer.HEIGHT_TEXT+r+yF.AbstractMeasurer.HEIGHT_TEXT},t.prototype._measureLine=function(r,n){n===void 0&&(n=!1);var i=this.useGuards||n||/^[\t ]$/.test(r),o=i?this._addGuards(r):r,a=e.prototype.measure.call(this,o);return a.width-=i?2*this.getGuardWidth():0,a},t.prototype.measure=function(r){var n=this;if(r===void 0&&(r=yF.AbstractMeasurer.HEIGHT_TEXT),r.trim()==="")return{width:0,height:0};var i=r.trim().split(`
`).map(function(o){return n._measureLine(o)});return{height:i.reduce(function(o,a){return o+a.height},0),width:i.reduce(function(o,a){return Math.max(o,a.width)},0)}},t.prototype.getGuardWidth=function(){return this.guardWidth==null&&(this.guardWidth=e.prototype.measure.call(this).width),this.guardWidth},t}(yF.AbstractMeasurer);HA.Measurer=EOe});var yit=H(VA=>{"use strict";var TOe=VA&&VA.__extends||function(){var e=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(t,r){t.__proto__=r}||function(t,r){for(var n in r)r.hasOwnProperty(n)&&(t[n]=r[n])};return function(t,r){e(t,r);function n(){this.constructor=t}t.prototype=r===null?Object.create(r):(n.prototype=r.prototype,new n)}}();Object.defineProperty(VA,"__esModule",{value:!0});var COe=_it(),AOe=function(e){TOe(t,e);function t(){return e!==null&&e.apply(this,arguments)||this}return t.prototype._measureCharacter=function(r){return e.prototype._measureLine.call(this,r)},t.prototype._measureLine=function(r){var n=this,i=r.split("").map(function(o){return n._measureCharacter(o)});return{height:i.reduce(function(o,a){return Math.max(o,a.height)},0),width:i.reduce(function(o,a){return o+a.width},0)}},t}(COe.Measurer);VA.CharacterMeasurer=AOe});var vit=H(UA=>{"use strict";var POe=UA&&UA.__extends||function(){var e=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(t,r){t.__proto__=r}||function(t,r){for(var n in r)r.hasOwnProperty(n)&&(t[n]=r[n])};return function(t,r){e(t,r);function n(){this.constructor=t}t.prototype=r===null?Object.create(r):(n.prototype=r.prototype,new n)}}();Object.defineProperty(UA,"__esModule",{value:!0});var IOe=pS(),LOe=yit(),kOe=function(e){POe(t,e);function t(r,n){var i=e.call(this,r,n)||this;return i.cache=new IOe.Cache(function(o){return i._measureCharacterNotFromCache(o)}),i}return t.prototype._measureCharacterNotFromCache=function(r){return e.prototype._measureCharacter.call(this,r)},t.prototype._measureCharacter=function(r){return this.cache.get(r)},t.prototype.reset=function(){this.cache.clear()},t}(LOe.CharacterMeasurer);UA.CacheCharacterMeasurer=kOe});var fXt=H(qA=>{"use strict";var ROe=qA&&qA.__extends||function(){var e=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(t,r){t.__proto__=r}||function(t,r){for(var n in r)r.hasOwnProperty(n)&&(t[n]=r[n])};return function(t,r){e(t,r);function n(){this.constructor=t}t.prototype=r===null?Object.create(r):(n.prototype=r.prototype,new n)}}();Object.defineProperty(qA,"__esModule",{value:!0});var NOe=pS(),DOe=_F(),OOe=vit(),zOe=function(e){ROe(t,e);function t(r){var n=e.call(this,r)||this;return n.dimCache=new NOe.Cache(function(i){return n._measureNotFromCache(i)}),n}return t.prototype._measureNotFromCache=function(r){return e.prototype.measure.call(this,r)},t.prototype.measure=function(r){return r===void 0&&(r=DOe.AbstractMeasurer.HEIGHT_TEXT),this.dimCache.get(r)},t.prototype.reset=function(){this.dimCache.clear(),e.prototype.reset.call(this)},t}(OOe.CacheCharacterMeasurer);qA.CacheMeasurer=zOe});var xit=H(vF=>{"use strict";function GA(e){for(var t in e)vF.hasOwnProperty(t)||(vF[t]=e[t])}Object.defineProperty(vF,"__esModule",{value:!0});GA(_F());GA(vit());GA(fXt());GA(yit());GA(_it())});var wit=H(bit=>{"use strict";Object.defineProperty(bit,"__esModule",{value:!0});var WA=pS(),FOe=function(){function e(){this.maxLines(1/0),this.textTrimming("ellipsis"),this.allowBreakingWords(!1),this._tokenizer=new WA.Tokenizer,this._breakingCharacter="-"}return e.prototype.maxLines=function(t){return t==null?this._maxLines:(this._maxLines=t,this)},e.prototype.textTrimming=function(t){if(t==null)return this._textTrimming;if(t!=="ellipsis"&&t!=="none")throw new Error(t+" - unsupported text trimming option.");return this._textTrimming=t,this},e.prototype.allowBreakingWords=function(t){return t==null?this._allowBreakingWords:(this._allowBreakingWords=t,this)},e.prototype.wrap=function(t,r,n,i){var o=this;i===void 0&&(i=1/0);var a={noBrokeWords:0,noLines:0,originalText:t,truncatedText:"",wrappedText:""},s={availableLines:Math.min(Math.floor(i/r.measure().height),this._maxLines),availableWidth:n,canFitText:!0,currentLine:"",wrapping:a},l=t.split(`
`);return l.reduce(function(c,u,h){return o.breakLineToFitWidth(c,u,h!==l.length-1,r)},s).wrapping},e.prototype.breakLineToFitWidth=function(t,r,n,i){var o=this;!t.canFitText&&t.wrapping.truncatedText!==""&&(t.wrapping.truncatedText+=`
`);var a=this._tokenizer.tokenize(r);t=a.reduce(function(l,c){return o.wrapNextToken(c,l,i)},t);var s=WA.StringMethods.trimEnd(t.currentLine);return t.wrapping.noLines+=+(s!==""),t.wrapping.noLines===t.availableLines&&this._textTrimming!=="none"&&n?t.canFitText=!1:t.wrapping.wrappedText+=s,t.currentLine=`
`,t},e.prototype.canFitToken=function(t,r,n){var i=this,o=t.split("").map(function(a,s){return s!==t.length-1?a+i._breakingCharacter:a});return n.measure(t).width<=r||o.every(function(a){return n.measure(a).width<=r})},e.prototype.addEllipsis=function(t,r,n){if(this._textTrimming==="none")return{remainingToken:"",wrappedToken:t};var i=t.substring(0).trim(),o=n.measure(i).width,a=n.measure("...").width,s=t.length>0&&t[0]===`
`?`
`:"";if(r<=a){var l=a/3,c=Math.floor(r/l);return{remainingToken:t,wrappedToken:s+"...".substr(0,c)}}for(;o+a>r;)i=WA.StringMethods.trimEnd(i.substr(0,i.length-1)),o=n.measure(i).width;return{remainingToken:WA.StringMethods.trimEnd(t.substring(i.length),"-").trim(),wrappedToken:s+i+"..."}},e.prototype.wrapNextToken=function(t,r,n){if(!r.canFitText||r.availableLines===r.wrapping.noLines||!this.canFitToken(t,r.availableWidth,n))return this.finishWrapping(t,r,n);for(var i=t;i;){var o=this.breakTokenToFitInWidth(i,r.currentLine,r.availableWidth,n);if(r.currentLine=o.line,i=o.remainingToken,i!=null)if(r.wrapping.noBrokeWords+=+o.breakWord,++r.wrapping.noLines,r.availableLines===r.wrapping.noLines){var a=this.addEllipsis(r.currentLine,r.availableWidth,n);return r.wrapping.wrappedText+=a.wrappedToken,r.wrapping.truncatedText+=a.remainingToken+i,r.currentLine=`
`,r}else r.wrapping.wrappedText+=WA.StringMethods.trimEnd(r.currentLine),r.currentLine=`
`}return r},e.prototype.finishWrapping=function(t,r,n){if(r.canFitText&&r.availableLines!==r.wrapping.noLines&&this._textTrimming!=="none"){var i=this.addEllipsis(r.currentLine+t,r.availableWidth,n);r.wrapping.wrappedText+=i.wrappedToken,r.wrapping.truncatedText+=i.remainingToken,r.wrapping.noBrokeWords+=+(i.remainingToken.length<t.length),r.wrapping.noLines+=+(i.wrappedToken.length>0),r.currentLine=""}else r.wrapping.truncatedText+=t;return r.canFitText=!1,r},e.prototype.breakTokenToFitInWidth=function(t,r,n,i,o){if(o===void 0&&(o=this._breakingCharacter),i.measure(r+t).width<=n)return{breakWord:!1,line:r+t,remainingToken:null};if(t.trim()==="")return{breakWord:!1,line:r,remainingToken:""};if(!this._allowBreakingWords&&r.trim()!=="")return{breakWord:!1,line:r,remainingToken:t};for(var a=0;a<t.length&&i.measure(r+t.substring(0,a+1)+o).width<=n;)++a;var s="";return a>0&&(s=o),{breakWord:a>0,line:r+t.substring(0,a)+s,remainingToken:t.substring(a)}},e}();bit.Wrapper=FOe});var dXt=H(YA=>{"use strict";var BOe=YA&&YA.__extends||function(){var e=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(t,r){t.__proto__=r}||function(t,r){for(var n in r)r.hasOwnProperty(n)&&(t[n]=r[n])};return function(t,r){e(t,r);function n(){this.constructor=t}t.prototype=r===null?Object.create(r):(n.prototype=r.prototype,new n)}}();Object.defineProperty(YA,"__esModule",{value:!0});var HOe=wit(),pXt=function(e){BOe(t,e);function t(){return e!==null&&e.apply(this,arguments)||this}return t.prototype.wrap=function(r,n,i,o){var a=this;o===void 0&&(o=1/0);var s=r.split(`
`);if(s.length>1)throw new Error("SingleLineWrapper is designed to work only on single line");var l=function(g){return e.prototype.wrap.call(a,r,n,g,o)},c=l(i);if(c.noLines<2)return c;for(var u=0,h=i,f=0;f<t.NO_WRAP_ITERATIONS&&h>u;++f){var p=(h+u)/2,d=l(p);this.areSameResults(c,d)?(h=p,c=d):u=p}return c},t.prototype.areSameResults=function(r,n){return r.noLines===n.noLines&&r.truncatedText===n.truncatedText},t}(HOe.Wrapper);pXt.NO_WRAP_ITERATIONS=5;YA.SingleLineWrapper=pXt});var Sit=H(xF=>{"use strict";function mXt(e){for(var t in e)xF.hasOwnProperty(t)||(xF[t]=e[t])}Object.defineProperty(xF,"__esModule",{value:!0});mXt(dXt());mXt(wit())});var gXt=H(Eit=>{"use strict";Object.defineProperty(Eit,"__esModule",{value:!0});var Mit=mit(),VOe=xit(),UOe=Sit(),qOe=FA(),GOe=function(){function e(t){this.context=t,this.measurer=new VOe.CacheMeasurer(this.context),this.wrapper=new UOe.Wrapper,this.writer=new qOe.Writer(this.measurer,this.context,this.wrapper)}return e.svg=function(t,r,n){return new e(new Mit.SvgContext(t,r,n))},e.canvas=function(t,r,n){return new e(new Mit.CanvasContext(t,r,n))},e.html=function(t,r,n){return new e(new Mit.HtmlContext(t,r,n))},e.prototype.write=function(t,r,n,i,o){this.writer.write(t,r,n,i,o)},e.prototype.clearMeasurerCache=function(){this.measurer.reset()},e}();Eit.Typesetter=GOe});var _l=H(bF=>{"use strict";function dS(e){for(var t in e)bF.hasOwnProperty(t)||(bF[t]=e[t])}Object.defineProperty(bF,"__esModule",{value:!0});dS(mit());dS(xit());dS(gXt());dS(pS());dS(Sit());dS(FA())});var _Xt=H(mS=>{"use strict";Object.defineProperty(mS,"__esModule",{value:!0});var WOe=(Er(),Ut(Mr)),YOe=window.Array;function jOe(e,t){if(e.length!==t.length)throw new Error("attempted to add arrays of unequal length");return e.map(function(r,n){return e[n]+t[n]})}mS.add=jOe;function XOe(e){var t=WOe.set(),r=[];return e.forEach(function(n){t.has(String(n))||(t.add(String(n)),r.push(n))}),r}mS.uniq=XOe;function $Oe(e){return YOe.prototype.concat.apply([],e)}mS.flatten=$Oe;function KOe(e,t){for(var r=[],n=0;n<t;n++)r[n]=typeof e=="function"?e(n):e;return r}mS.createFilledArray=KOe});var xXt=H(jA=>{"use strict";Object.defineProperty(jA,"__esModule",{value:!0});var vXt=(Er(),Ut(Mr)),ZOe=window.Math;function JOe(e,t){var r=yXt(e)+.05,n=yXt(t)+.05;return r>n?r/n:n/r}jA.contrast=JOe;function QOe(e,t){var r=vXt.color(e).brighter(t);return r.rgb().toString()}jA.lightenColor=QOe;function t7e(e,t){e.classed(t,!0);var r=e.style("background-color");if(r==="transparent")return null;var n=/\((.+)\)/.exec(r);if(!n)return null;var i=n[1].split(",").map(function(a){var s=+a,l=s.toString(16);return s<16?"0"+l:l});if(i.length===4&&i[3]==="00")return null;var o="#"+i.join("");return e.classed(t,!1),o}jA.colorTest=t7e;function yXt(e){var t=vXt.rgb(e),r=function(a){return a=a/255,a<=.03928?a/12.92:ZOe.pow((a+.055)/1.055,2.4)},n=r(t.r),i=r(t.g),o=r(t.b);return .2126*n+.7152*i+.0722*o}});var Cit=H(ao=>{"use strict";Object.defineProperty(ao,"__esModule",{value:!0});var Tit=(Er(),Ut(Mr)),ma=window.Math;function e7e(e,t){for(var r=t;r!=null&&r!==e;)r=r.parentNode;return r===e}ao.contains=e7e;function wXt(e){var t;try{t=e.node().getBBox()}catch(r){t={x:0,y:0,width:0,height:0}}return t}ao.elementBBox=wXt;function r7e(e){if(e instanceof SVGElement)return wXt(Tit.select(e));if(e instanceof HTMLElement){var t=e.getBoundingClientRect();return{x:t.left,y:t.top,width:t.width,height:t.height}}else return{x:0,y:0,width:0,height:0}}ao.entityBounds=r7e;ao.SCREEN_REFRESH_RATE_MILLISECONDS=1e3/60;function n7e(e){window.requestAnimationFrame!=null?window.requestAnimationFrame(e):setTimeout(e,ao.SCREEN_REFRESH_RATE_MILLISECONDS)}ao.requestAnimationFramePolyfill=n7e;function i7e(e){var t=e instanceof Tit.selection?e.node():e,r=window.getComputedStyle(t);return kf(r,"width")+kf(r,"padding-left")+kf(r,"padding-right")+kf(r,"border-left-width")+kf(r,"border-right-width")}ao.elementWidth=i7e;function o7e(e){var t=e instanceof Tit.selection?e.node():e,r=window.getComputedStyle(t);return kf(r,"height")+kf(r,"padding-top")+kf(r,"padding-bottom")+kf(r,"border-top-width")+kf(r,"border-bottom-width")}ao.elementHeight=o7e;var Lc="\\s",XA="(?:[-+]?[0-9]*\\.?[0-9]+)",SXt="(?:(?:"+Lc+"+,?"+Lc+"*)|(?:,"+Lc+"*))",a7e=new RegExp("translate"+Lc+"*\\("+Lc+"*("+XA+")(?:"+SXt+"("+XA+"))?"+Lc+"*\\)"),s7e=new RegExp("rotate"+Lc+"*\\("+Lc+"*("+XA+")"+Lc+"*\\)"),l7e=new RegExp("scale"+Lc+"*\\("+Lc+"*("+XA+")(?:"+SXt+"("+XA+"))?"+Lc+"*\\)");function c7e(e){var t=a7e.exec(e.attr("transform"));if(t!=null){var r=t[1],n=t[2],i=n===void 0?0:n;return[+r,+i]}else return[0,0]}ao.getTranslateValues=c7e;function u7e(e){var t=s7e.exec(e.attr("transform"));if(t!=null){var r=t[1];return+r}else return 0}ao.getRotate=u7e;function h7e(e){var t=l7e.exec(e.attr("transform"));if(t!=null){var r=t[1],n=t[2];return[+r,n==null?+r:+n]}else return[0,0]}ao.getScaleValues=h7e;function f7e(e,t){return!(ma.floor(e.right)<=ma.ceil(t.left)||ma.ceil(e.left)>=ma.floor(t.right)||ma.floor(e.bottom)<=ma.ceil(t.top)||ma.ceil(e.top)>=ma.floor(t.bottom))}ao.clientRectsOverlap=f7e;function p7e(e,t){return{left:e.left-t,top:e.top-t,right:e.right+t,bottom:e.bottom+t,width:e.width+t*2,height:e.height+t*2}}ao.expandRect=p7e;function d7e(e,t){return ma.floor(t.left)<=ma.ceil(e.left)&&ma.floor(t.top)<=ma.ceil(e.top)&&ma.floor(e.right)<=ma.ceil(t.right)&&ma.floor(e.bottom)<=ma.ceil(t.bottom)}ao.clientRectInside=d7e;function m7e(e,t,r,n){n===void 0&&(n=.5);var i=bXt(e),o=bXt(t);return r.x+r.width>=i.min-n&&r.x<=i.max+n&&r.y+r.height>=o.min-n&&r.y<=o.max+n}ao.intersectsBBox=m7e;function bXt(e){if(typeof e=="number"){var t=e;return{min:t,max:t}}var r=e;if(r instanceof Object&&"min"in r&&"max"in r)return r;throw new Error("input '"+e+"' can't be parsed as an Range")}function kf(e,t){var r=e.getPropertyValue(t),n=parseFloat(r);return n||0}function g7e(e){for(var t=[];e&&e instanceof HTMLElement;)t.push(e),e=e.parentElement;return t}ao.getHtmlElementAncestors=g7e;function _7e(e){var t=window.getComputedStyle(e,null),r=t.getPropertyValue("-webkit-transform")||t.getPropertyValue("-moz-transform")||t.getPropertyValue("-ms-transform")||t.getPropertyValue("-o-transform")||t.getPropertyValue("transform");return x7e(r)}ao.getElementTransform=_7e;var y7e=/^matrix\(([^)]+)\)$/,v7e=/[, ]+/;function x7e(e){if(e==null||e==="none")return null;var t=e.match(y7e);if(t==null||t.length<2)return null;var r=t[1].split(v7e).map(function(n){return parseFloat(n)});return r.length!=6?null:r}});var Ait=H(so=>{"use strict";Object.defineProperty(so,"__esModule",{value:!0});var SF=(Er(),Ut(Mr)),MXt=Cit(),md=window.Math,b7e=[1,0,0,1,0,0];function w7e(e,t,r){return md.min(t,r)<=e&&e<=md.max(t,r)}so.inRange=w7e;function S7e(e,t,r){return md.min(md.max(t,e),r)}so.clamp=S7e;function M7e(e,t,r){var n=typeof t=="function"?t:null,i=n==null?t:r,o=n==null?SF.max(e):SF.max(e,n);return o!==void 0?o:i}so.max=M7e;function E7e(e,t,r){var n=typeof t=="function"?t:null,i=n==null?t:r,o=n==null?SF.min(e):SF.min(e,n);return o!==void 0?o:i}so.min=E7e;function T7e(e){return e!==e}so.isNaN=T7e;function C7e(e){return typeof e=="number"&&e-e<1}so.isValidNumber=C7e;function A7e(e,t,r){if(r===void 0&&(r=1),r===0)throw new Error("step cannot be 0");for(var n=md.max(md.ceil((t-e)/r),0),i=[],o=0;o<n;++o)i[o]=e+r*o;return i}so.range=A7e;function P7e(e,t){return md.pow(t.y-e.y,2)+md.pow(t.x-e.x,2)}so.distanceSquared=P7e;function I7e(e){return e/360*md.PI*2}so.degreesToRadians=I7e;function L7e(e,t){return t.topLeft.x<=e.x&&t.bottomRight.x>=e.x&&t.topLeft.y<=e.y&&t.bottomRight.y>=e.y}so.within=L7e;function k7e(e,t,r,n,i,o,a,s){return e<=i+a&&i<=e+r&&t<=o+s&&o<=t+n}so.boundsIntersects=k7e;function R7e(e){for(var t=MXt.getHtmlElementAncestors(e),r=b7e,n=null,i=0,o=t;i<o.length;i++){var a=o[i],s=MXt.getElementTransform(a);if(s!=null){var l=a.clientWidth/2,c=a.clientHeight/2;r=wF(r,[l,c]),r=EXt(r,TXt(s)),r=wF(r,[-l,-c])}var u=a.scrollLeft,h=a.scrollTop;(n===null||a===n)&&(u-=a.offsetLeft+a.clientLeft,h-=a.offsetTop+a.clientTop,n=a.offsetParent),r=wF(r,[u,h])}return r}so.getCumulativeTransform=R7e;function EXt(e,t){return[e[0]*t[0]+e[2]*t[1],e[1]*t[0]+e[3]*t[1],e[0]*t[2]+e[2]*t[3],e[1]*t[2]+e[3]*t[3],e[0]*t[4]+e[2]*t[5]+e[4],e[1]*t[4]+e[3]*t[5]+e[5]]}so.multiplyMatrix=EXt;function N7e(e,t){return[t[0],t[1],t[2],t[3],t[4]+e[0],t[5]+e[1]]}so.premultiplyTranslate=N7e;function wF(e,t){return[e[0],e[1],e[2],e[3],e[0]*t[0]+e[2]*t[1]+e[4],e[1]*t[0]+e[3]*t[1]+e[5]]}so.multiplyTranslate=wF;function TXt(e){var t=e[0]*e[3]-e[1]*e[2];if(t===0)throw new Error("singular matrix");var r=1/t;return[r*e[3],r*-e[1],r*-e[2],r*e[0],r*(-e[3]*e[4]+e[2]*e[5]),r*(e[1]*e[4]+-e[0]*e[5])]}so.invertMatrix=TXt;function D7e(e,t){return{x:e[0]*t.x+e[2]*t.y+e[4],y:e[1]*t.x+e[3]*t.y+e[5]}}so.applyTransform=D7e});var CXt=H(MF=>{"use strict";Object.defineProperty(MF,"__esModule",{value:!0});var O7e=function(){function e(){}return e.prototype.split=function(t,r){for(var n=Math.ceil(t.length/2),i=0;i<n;i++)r[0].insert(t[i]);for(var i=n;i<t.length;i++)r[1].insert(t[i])},e}();MF.SplitStrategyTrivial=O7e;var z7e=function(){function e(){}return e.prototype.split=function(t,r){for(t=t.slice(),this.chooseFirstSplit(t,r);t.length>0;)this.addNext(t,r)},e.prototype.chooseFirstSplit=function(t,r){for(var n=0,i=0,o=t.length-1,a=t.length-1,s=1;s<t.length-1;s++){var l=t[s];l.bounds.xl>t[o].bounds.xl?o=s:l.bounds.xh<t[n].bounds.xh&&(n=s),l.bounds.yl>t[a].bounds.yl?a=s:l.bounds.yh<t[i].bounds.yh&&(i=s)}var c=Math.abs(t[n].bounds.xh-t[o].bounds.xl),u=Math.abs(t[i].bounds.yh-t[a].bounds.yl),h=c>u?[n,o]:[i,a],f=h[0],p=h[1];f===p&&(f=0,p=t.length-1),r[0].insert(t.splice(Math.max(f,p),1)[0]),r[1].insert(t.splice(Math.min(f,p),1)[0])},e.prototype.addNext=function(t,r){for(var n=null,i=null,o=null,a=0;a<t.length;a++){var s=t[a],l=r[0].unionAreaDifference(s.bounds),c=r[1].unionAreaDifference(s.bounds);(l<i||n==null)&&(n=a,i=l,o=r[0]),c<i&&(n=a,i=c,o=r[1])}o.insert(t.splice(n,1)[0])},e}();MF.SplitStrategyLinear=z7e});var Iit=H(gd=>{"use strict";Object.defineProperty(gd,"__esModule",{value:!0});var F7e=CXt(),B7e=5,H7e=new F7e.SplitStrategyLinear,Rf;(function(e){e[e.PASS=0]="PASS",e[e.FAIL=1]="FAIL",e[e.PASS_AND_OVERWRITE=2]="PASS_AND_OVERWRITE"})(Rf=gd.QueryPredicateResult||(gd.QueryPredicateResult={}));function EF(e,t,r){var n=1/0,i=1/0,o=1/0;return function(a){var s=t(a.bounds,e),l=r(a.bounds,e);return a.value!=null?s<n?(n=s,i=s,o=l,Rf.PASS_AND_OVERWRITE):s===n?Rf.PASS:Rf.FAIL:s>o?Rf.FAIL:(i=Math.min(s,i),o=Math.max(l,o),Rf.PASS)}}gd.createMinimizingNodePredicate=EF;function Pit(e,t){return function(r,n){return t(n.bounds,e)-t(r.bounds,e)}}gd.createNodeSort=Pit;var V7e=function(){function e(t,r){t===void 0&&(t=B7e),r===void 0&&(r=H7e),this.maxNodeChildren=t,this.splitStrategy=r,this.root=new TF(!0),this.size=0}return e.prototype.getRoot=function(){return this.root},e.prototype.clear=function(){this.root=new TF(!0),this.size=0},e.prototype.insert=function(t,r){for(var n=this.root;!n.leaf;)n=n.subtree(t);var i=TF.valueNode(t,r);for(n.insert(i),this.size+=1;n.overflow(this.maxNodeChildren);)n=n.split(this.splitStrategy),n.parent==null&&(this.root=n);return i},e.prototype.locate=function(t){return this.query(function(r){return r.contains(t)})},e.prototype.locateNearest=function(t){var r=EF(t,Qa.distanceSquaredToNearEdge,Qa.distanceSquaredToFarEdge),n=this.queryNodes(r);return n.map(function(i){return i.value})},e.prototype.locateNearestX=function(t){var r=EF(t,Qa.absoluteDistanceToNearEdgeX,Qa.absoluteDistanceToFarEdgeX),n=this.queryNodes(r);return n.sort(Pit(t,Qa.absoluteDistanceToNearEdgeY)),n.map(function(i){return i.value})},e.prototype.locateNearestY=function(t){var r=EF(t,Qa.absoluteDistanceToNearEdgeY,Qa.absoluteDistanceToFarEdgeY),n=this.queryNodes(r);return n.sort(Pit(t,Qa.absoluteDistanceToNearEdgeX)),n.map(function(i){return i.value})},e.prototype.intersect=function(t){return this.query(function(r){return Qa.isBoundsOverlapBounds(r,t)})},e.prototype.intersectX=function(t){return this.query(function(r){return Qa.isBoundsOverlapX(r,t)})},e.prototype.intersectY=function(t){return this.query(function(r){return Qa.isBoundsOverlapY(r,t)})},e.prototype.query=function(t){var r=[];if(this.root.bounds!=null&&!t(this.root.bounds))return r;for(var n=[this.root];n.length>0;)for(var i=n.shift(),o=0;o<i.entries.length;o++){var a=i.entries[o];t(a.bounds)&&(i.leaf?r.push(a.value):n.push(a))}return r},e.prototype.queryNodes=function(t){var r=[];if(this.root.bounds!=null&&t(this.root)===Rf.FAIL)return r;for(var n=[this.root];n.length>0;)for(var i=n.shift(),o=0;o<i.entries.length;o++){var a=i.entries[o],s=t(a);s===Rf.PASS_AND_OVERWRITE&&(r=[]),(s===Rf.PASS||s===Rf.PASS_AND_OVERWRITE)&&(i.leaf?r.push(a):n.push(a))}return r},e}();gd.RTree=V7e;var TF=function(){function e(t){this.leaf=t,this.bounds=null,this.entries=[],this.parent=null,this.value=null}return e.valueNode=function(t,r){var n=new e(!0);return n.bounds=t,n.value=r,n},e.prototype.overflow=function(t){return this.entries.length>t},e.prototype.insert=function(t){this.entries.push(t),t.parent=this;for(var r=this;r!=null;)r.bounds=Qa.unionAll([r.bounds,t.bounds]),r=r.parent;return this},e.prototype.remove=function(t){var r=this.entries.indexOf(t);if(r>=0){this.entries.splice(r,1);for(var n=this;n!=null;)n.bounds=Qa.unionAll(n.entries.map(function(i){return i.bounds})),n=n.parent}return this},e.prototype.subtree=function(t){for(var r=1/0,n=null,i=0;i<this.entries.length;i++){var o=this.entries[i],a=o.unionAreaDifference(t);(a<r||a===r&&n!=null&&o.entries.length<n.entries.length)&&(n=o)}return n},e.prototype.split=function(t){this.parent!=null&&this.parent.remove(this);var r=[new e(this.leaf),new e(this.leaf)];t.split(this.entries,r);var n=this.parent!=null?this.parent:new e(!1);return n.insert(r[0]),n.insert(r[1]),n.leaf=!1,n},e.prototype.unionAreaDifference=function(t){return Math.abs(Qa.union(this.bounds,t).area()-this.bounds.area())},e.prototype.maxDepth=function(){return this.leaf?1:1+this.entries.map(function(t){return t.maxDepth()}).reduce(function(t,r){return Math.max(t,r)})},e}();gd.RTreeNode=TF;var Qa=function(){function e(t,r,n,i){this.xl=t,this.yl=r,this.xh=n,this.yh=i,this.width=this.xh-this.xl,this.height=this.yh-this.yl}return e.xywh=function(t,r,n,i){return new e(t,r,t+n,r+i)},e.entityBounds=function(t){return new e(t.x,t.y,t.x+t.width,t.y+t.height)},e.bounds=function(t){return e.pointPair(t.topLeft,t.bottomRight)},e.pointPair=function(t,r){return new e(Math.min(t.x,r.x),Math.min(t.y,r.y),Math.max(t.x,r.x),Math.max(t.y,r.y))},e.points=function(t){if(t.length<2)throw new Error("need at least 2 points to create bounds");var r=t.map(function(i){return i.x}),n=t.map(function(i){return i.y});return new e(r.reduce(function(i,o){return Math.min(i,o)}),n.reduce(function(i,o){return Math.min(i,o)}),r.reduce(function(i,o){return Math.max(i,o)}),n.reduce(function(i,o){return Math.max(i,o)}))},e.union=function(t,r){return new e(Math.min(t.xl,r.xl),Math.min(t.yl,r.yl),Math.max(t.xh,r.xh),Math.max(t.yh,r.yh))},e.unionAll=function(t){return t=t.filter(function(r){return r!=null}),t.length===0?null:t.reduce(function(r,n){return e.union(r,n)})},e.isBoundsOverlapBounds=function(t,r){return e.isBoundsOverlapX(t,r)&&e.isBoundsOverlapY(t,r)},e.isBoundsOverlapX=function(t,r){return!(t.xh<r.xl)&&!(t.xl>r.xh)},e.isBoundsOverlapY=function(t,r){return!(t.yh<r.yl)&&!(t.yl>r.yh)},e.absoluteDistanceToNearEdgeX=function(t,r){var n=t.width/2,i=t.xl+n;return Math.max(Math.abs(r.x-i)-n,0)},e.absoluteDistanceToNearEdgeY=function(t,r){var n=t.height/2,i=t.yl+n;return Math.max(Math.abs(r.y-i)-n,0)},e.absoluteDistanceToFarEdgeX=function(t,r){var n=e.absoluteDistanceToNearEdgeX(t,r);return n===0?0:n+t.width},e.absoluteDistanceToFarEdgeY=function(t,r){var n=e.absoluteDistanceToNearEdgeY(t,r);return n===0?0:n+t.height},e.distanceSquaredToNearEdge=function(t,r){var n=e.absoluteDistanceToNearEdgeX(t,r),i=e.absoluteDistanceToNearEdgeY(t,r);return n*n+i*i},e.distanceSquaredToFarEdge=function(t,r){var n=e.absoluteDistanceToFarEdgeX(t,r),i=e.absoluteDistanceToFarEdgeY(t,r);return n*n+i*i},e.prototype.area=function(){return this.areaCached==null&&(this.areaCached=(this.xh-this.xl)*(this.yh-this.yl)),this.areaCached},e.prototype.contains=function(t){return this.xl<=t.x&&this.xh>=t.x&&this.yl<=t.y&&this.yh>=t.y},e}();gd.RTreeBounds=Qa});var IXt=H(_d=>{"use strict";Object.defineProperty(_d,"__esModule",{value:!0});var AXt=(Er(),Ut(Mr)),U7e=Oe(),Xg=Fe(),q7e=If();_d.IStackingOrder=q7e.makeEnum(["topdown","bottomup"]);var PXt=window.Math;function G7e(e,t,r,n){n===void 0&&(n="bottomup");var i=AXt.map(),o=AXt.map(),a=new Xg.Map;n==="topdown"&&(e=e.slice(),e.reverse());for(var s=0,l=e;s<l.length;s++){for(var c=l[s],u=new Xg.Map,h=c.data(),f=h.length,p=0;p<f;p++){var d=h[p],g=t(d,p,c),_=_d.normalizeKey(g),y=+r(d,p,c),x=void 0,b=y>=0?i:o;b.has(_)?(x=b.get(_),b.set(_,x+y)):(x=0,b.set(_,y)),u.set(_,{offset:x,value:y,axisValue:g,originalDatum:d,originalDataset:c,originalIndex:p})}a.set(c,u)}return a}_d.stack=G7e;function W7e(e){var t=new Xg.Map,r=new Xg.Map;return e.forEach(function(n){n.forEach(function(i,o){var a=i.offset+i.value,s=Xg.Math.max([a,i.offset],i.offset),l=Xg.Math.min([a,i.offset],i.offset),c=i.axisValue;t.has(o)?t.get(o).extent<s&&t.set(o,{extent:s,axisValue:c,stackedDatum:i}):t.set(o,{extent:s,axisValue:c,stackedDatum:i}),r.has(o)?r.get(o).extent>l&&r.set(o,{extent:l,axisValue:c,stackedDatum:i}):r.set(o,{extent:l,axisValue:c,stackedDatum:i})})}),{maximumExtents:t,minimumExtents:r}}_d.stackedExtents=W7e;function Y7e(e,t,r){var n=[];e.forEach(function(a,s){for(var l=s.data(),c=l.length,u=0;u<c;u++){var h=l[u];if(!(r!=null&&!r(h,u,s))){var f=a.get(_d.normalizeKey(t(h,u,s)));n.push(f.value+f.offset)}}});var i=Xg.Math.max(n,0),o=Xg.Math.min(n,0);return[PXt.min(o,0),PXt.max(0,i)]}_d.stackedExtent=Y7e;_d.normalizeKey=U7e.memoize(function(e){return String(e)})});var $A=H(CF=>{"use strict";Object.defineProperty(CF,"__esModule",{value:!0});CF.SHOW_WARNINGS=!0;CF.ADD_TITLE_ELEMENTS=!0});var AF=H(gS=>{"use strict";Object.defineProperty(gS,"__esModule",{value:!0});var j7e=$A();function LXt(e){!j7e.SHOW_WARNINGS||console.warn(e)}gS.warn=LXt;function kXt(e,t){for(var r=[],n=2;n<arguments.length;n++)r[n-2]=arguments[n];return t===0?(e(r),-1):window.setTimeout(e,t,r)}gS.setTimeout=kXt;function X7e(e,t,r){var n=null,i=[],o=function(){t.apply(r,i)};return function(){i=Array.prototype.slice.call(arguments),clearTimeout(n),n=kXt(o,e)}}gS.debounce=X7e;function $7e(e,t,r){r===void 0&&(r=""),LXt("Method "+e+" has been deprecated in version "+t+". Please refer to the release notes. "+r)}gS.deprecated=$7e});var RXt=H(Lit=>{"use strict";Object.defineProperty(Lit,"__esModule",{value:!0});var K7e=function(){function e(t,r,n){this.entryIndex=t,this.exitIndex=t,this.minIndex=t,this.maxIndex=t,this.bucketValue=r,this.minValue=n,this.maxValue=n}return e.prototype.isInBucket=function(t){return t==this.bucketValue},e.prototype.addToBucket=function(t,r){t<this.minValue&&(this.minValue=t,this.minIndex=r),t>this.maxValue&&(this.maxValue=t,this.maxIndex=r),this.exitIndex=r},e.prototype.getUniqueIndices=function(){var t=[this.entryIndex,this.maxIndex,this.minIndex,this.exitIndex];return t.filter(function(r,n){return n==0||r!=t[n-1]})},e}();Lit.Bucket=K7e});var Rit=H(kit=>{"use strict";Object.defineProperty(kit,"__esModule",{value:!0});var Z7e=function(){function e(){typeof window.Set=="function"?this._es6Set=new window.Set:this._values=[],this.size=0}return e.prototype.add=function(t){return this._es6Set!=null?(this._es6Set.add(t),this.size=this._es6Set.size,this):(this.has(t)||(this._values.push(t),this.size=this._values.length),this)},e.prototype.delete=function(t){if(this._es6Set!=null){var r=this._es6Set.delete(t);return this.size=this._es6Set.size,r}var n=this._values.indexOf(t);return n!==-1?(this._values.splice(n,1),this.size=this._values.length,!0):!1},e.prototype.has=function(t){return this._es6Set!=null?this._es6Set.has(t):this._values.indexOf(t)!==-1},e.prototype.forEach=function(t,r){var n=this;if(this._es6Set!=null){var i=function(o,a){return t.call(r,o,a,n)};this._es6Set.forEach(i,r);return}this._values.forEach(function(o){t.call(r,o,o,n)})},e}();kit.Set=Z7e});var NXt=H(Nit=>{"use strict";Object.defineProperty(Nit,"__esModule",{value:!0});var J7e=(de(),Ut(pe)),Q7e=Rit(),tze=function(e){J7e.__extends(t,e);function t(){return e!==null&&e.apply(this,arguments)||this}return t.prototype.callCallbacks=function(){for(var r=this,n=[],i=0;i<arguments.length;i++)n[i]=arguments[i];return this.forEach(function(o){o.apply(r,n)}),this},t}(Q7e.Set);Nit.CallbackSet=tze});var DXt=H(Dit=>{"use strict";Object.defineProperty(Dit,"__esModule",{value:!0});var $g=Iit(),eze=function(){function e(){this._entities=[],this._rtree=new $g.RTree}return e.prototype.addAll=function(t,r,n){if(this._entities=this._entities.concat(t),n!==void 0)for(var i=$g.RTreeBounds.bounds(n),o=0;o<t.length;o++){var a=t[o],s=$g.RTreeBounds.entityBounds(r(a));$g.RTreeBounds.isBoundsOverlapBounds(i,s)&&this._rtree.insert(s,a)}else for(var o=0;o<t.length;o++){var a=t[o],s=$g.RTreeBounds.entityBounds(r(a));this._rtree.insert(s,a)}},e.prototype.entityNearest=function(t){return this._rtree.locateNearest(t).pop()},e.prototype.entityNearestX=function(t){return this._rtree.locateNearestX(t).pop()},e.prototype.entityNearestY=function(t){return this._rtree.locateNearestY(t).pop()},e.prototype.entitiesInBounds=function(t){return this._rtree.intersect($g.RTreeBounds.entityBounds(t))},e.prototype.entitiesInXBounds=function(t){return this._rtree.intersectX($g.RTreeBounds.entityBounds(t))},e.prototype.entitiesInYBounds=function(t){return this._rtree.intersectY($g.RTreeBounds.entityBounds(t))},e.prototype.entities=function(){return this._entities},e}();Dit.EntityStore=eze});var OXt=H(Oit=>{"use strict";Object.defineProperty(Oit,"__esModule",{value:!0});var rze=Ait(),nze=function(){function e(){typeof window.Map=="function"?this._es6Map=new window.Map:this._keyValuePairs=[]}return e.prototype.set=function(t,r){if(rze.isNaN(t))throw new Error("NaN may not be used as a key to the Map");if(this._es6Map!=null)return this._es6Map.set(t,r),this;for(var n=0;n<this._keyValuePairs.length;n++)if(this._keyValuePairs[n].key===t)return this._keyValuePairs[n].value=r,this;return this._keyValuePairs.push({key:t,value:r}),this},e.prototype.get=function(t){if(this._es6Map!=null)return this._es6Map.get(t);for(var r=0;r<this._keyValuePairs.length;r++)if(this._keyValuePairs[r].key===t)return this._keyValuePairs[r].value},e.prototype.has=function(t){if(this._es6Map!=null)return this._es6Map.has(t);for(var r=0;r<this._keyValuePairs.length;r++)if(this._keyValuePairs[r].key===t)return!0;return!1},e.prototype.forEach=function(t,r){var n=this;if(this._es6Map!=null){var i=function(o,a){return t.call(r,o,a,n)};this._es6Map.forEach(i,r);return}this._keyValuePairs.forEach(function(o){t.call(r,o.value,o.key,n)})},e.prototype.delete=function(t){if(this._es6Map!=null)return this._es6Map.delete(t);for(var r=0;r<this._keyValuePairs.length;r++)if(this._keyValuePairs[r].key===t)return this._keyValuePairs.splice(r,1),!0;return!1},e}();Oit.Map=nze});var zXt=H(zit=>{"use strict";Object.defineProperty(zit,"__esModule",{value:!0});function ize(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];for(var r={},n=0,i=e;n<i.length;n++)for(var o=i[n],a=Object.keys(o),s=0,l=a;s<l.length;s++){var c=l[s];r[c]=o[c]}return r}zit.assign=ize});var HXt=H(PF=>{"use strict";Object.defineProperty(PF,"__esModule",{value:!0});var Fit=Fe(),FXt="__Plottable_ClientTranslator";function oze(e){var t=e.root().rootElement().node(),r=t[FXt];return r==null&&(r=new BXt(t),t[FXt]=r),r}PF.getTranslator=oze;var BXt=function(){function e(t){this._rootElement=t}return e.prototype.computePosition=function(t,r){var n={x:t,y:r},i=Fit.Math.getCumulativeTransform(this._rootElement);if(i==null)return n;var o=Fit.Math.applyTransform(i,n);return o},e.isEventInside=function(t,r){return Fit.DOM.contains(t.root().rootElement().node(),r.target)},e}();PF.Translator=BXt});var Fe=H(qo=>{"use strict";Object.defineProperty(qo,"__esModule",{value:!0});var Kg=(de(),Ut(pe)),aze=_Xt();qo.Array=aze;var sze=xXt();qo.Color=sze;var lze=Cit();qo.DOM=lze;var cze=Ait();qo.Math=cze;var uze=Iit();qo.RTree=uze;var hze=IXt();qo.Stacking=hze;var fze=AF();qo.Window=fze;Kg.__exportStar(RXt(),qo);Kg.__exportStar(NXt(),qo);Kg.__exportStar(Yg(),qo);Kg.__exportStar(DXt(),qo);Kg.__exportStar(OXt(),qo);Kg.__exportStar(zXt(),qo);Kg.__exportStar(Rit(),qo);Kg.__exportStar(HXt(),qo)});var Hit=H(KA=>{"use strict";Object.defineProperty(KA,"__esModule",{value:!0});var VXt=Fe(),Bit=IF(),pze=function(){function e(){}return e.prototype.render=function(){Bit.flush()},e}();KA.Immediate=pze;var dze=function(){function e(){}return e.prototype.render=function(){VXt.DOM.requestAnimationFramePolyfill(Bit.flush)},e}();KA.AnimationFrame=dze;var mze=function(){function e(){this._timeoutMsec=VXt.DOM.SCREEN_REFRESH_RATE_MILLISECONDS}return e.prototype.render=function(){setTimeout(Bit.flush,this._timeoutMsec)},e}();KA.Timeout=mze});var IF=H(zu=>{"use strict";Object.defineProperty(zu,"__esModule",{value:!0});var _S=Fe(),gze=If(),LF=Hit(),JA=new _S.Set,Vit=new _S.Set,kF=!1,Uit=!1;zu.Policy=gze.makeEnum(["immediate","animationFrame","timeout"]);var ZA=new LF.AnimationFrame;function _ze(e){if(e==null)return ZA;switch(e){case zu.Policy.immediate:ZA=new LF.Immediate;break;case zu.Policy.animationFrame:ZA=new LF.AnimationFrame;break;case zu.Policy.timeout:ZA=new LF.Timeout;break;default:_S.Window.warn("Unrecognized renderPolicy: "+e)}}zu.renderPolicy=_ze;function yze(e){Uit&&_S.Window.warn("Registered to render while other components are flushing: request may be ignored"),JA.add(e),qXt()}zu.registerToRender=yze;function UXt(e){Vit.add(e),JA.add(e),qXt()}zu.registerToComputeLayoutAndRender=UXt;function vze(e){UXt(e)}zu.registerToComputeLayout=vze;function qXt(){kF||(kF=!0,ZA.render())}function xze(){if(kF){Vit.forEach(function(t){return t.computeLayout()}),JA.forEach(function(t){return t.render()}),Uit=!0;var e=new _S.Set;JA.forEach(function(t){try{t.renderImmediately()}catch(r){window.setTimeout(function(){throw r},0),e.add(t)}}),Vit=new _S.Set,JA=e,kF=!1,Uit=!1}}zu.flush=xze});var kc=H(QA=>{"use strict";Object.defineProperty(QA,"__esModule",{value:!0});var GXt=(Er(),Ut(Mr)),RF=IF(),yS=Fe(),bze=Oe(),WXt=Yg(),YXt=If();QA.XAlignment=YXt.makeEnum(["left","center","right"]);QA.YAlignment=YXt.makeEnum(["top","center","bottom"]);var wze=function(){function e(){this._overflowHidden=!1,this._origin={x:0,y:0},this._xAlignment="left",this._yAlignment="top",this._isSetup=!1,this._isAnchored=!1,this._cssClasses=new yS.Set,this._destroyed=!1,this._onAnchorCallbacks=new yS.CallbackSet,this._onDetachCallbacks=new yS.CallbackSet,this._cssClasses.add("component")}return e.prototype.anchor=function(t){if(t=WXt.coerceExternalD3(t),this._destroyed)throw new Error("Can't reuse destroy()-ed Components!");return this.isRoot()&&(this._rootElement=t,this._rootElement.classed("plottable",!0)),this._element!=null?t.node().appendChild(this._element.node()):(this._element=t.append("div"),this._setup()),this._isAnchored=!0,this._onAnchorCallbacks.callCallbacks(this),this},e.prototype.onAnchor=function(t){return this._isAnchored&&t(this),this._onAnchorCallbacks.add(t),this},e.prototype.offAnchor=function(t){return this._onAnchorCallbacks.delete(t),this},e.prototype._setup=function(){var t=this;this._isSetup||(this._cssClasses.forEach(function(r){t._element.classed(r,!0)}),this._cssClasses=new yS.Set,this._backgroundContainer=this._element.append("svg").classed("background-container",!0),this._content=this._element.append("svg").classed("content",!0),this._foregroundContainer=this._element.append("svg").classed("foreground-container",!0),this._overflowHidden?this._content.classed("component-overflow-hidden",!0):this._content.classed("component-overflow-visible",!0),this._isSetup=!0)},e.prototype.requestedSpace=function(t,r){return{minWidth:0,minHeight:0}},e.prototype.computeLayout=function(t,r,n){if(t==null||r==null||n==null){if(this._element==null)throw new Error("anchor() must be called before computeLayout()");if(this._rootElement!=null){t={x:0,y:0};var i=this._rootElement.node();r=yS.DOM.elementWidth(i),n=yS.DOM.elementHeight(i)}else throw new Error("null arguments cannot be passed to computeLayout() on a non-root, unanchored node")}var o=this._sizeFromOffer(r,n),a=o.height,s=o.width,l=e._xAlignToProportion[this._xAlignment],c=e._yAlignToProportion[this._yAlignment],u=t.x+(r-s)*l,h=t.y+(n-a)*c;return this.setBounds(s,a,u,h),this},e.prototype.setBounds=function(t,r,n,i){return n===void 0&&(n=0),i===void 0&&(i=0),this._width=t,this._height=r,this._origin={x:n,y:i},this._element!=null&&this._element.styles({left:n+"px",height:r+"px",top:i+"px",width:t+"px"}),this._resizeHandler!=null&&this._resizeHandler({width:t,height:r}),this},e.prototype._sizeFromOffer=function(t,r){var n=this.requestedSpace(t,r);return{width:this.fixedWidth()?Math.min(t,n.minWidth):t,height:this.fixedHeight()?Math.min(r,n.minHeight):r}},e.prototype.render=function(){return this._isAnchored&&this._isSetup&&this.width()>=0&&this.height()>=0&&RF.registerToRender(this),this},e.prototype.renderLowPriority=function(){return this.render()},e.prototype._scheduleComputeLayout=function(){this._isAnchored&&this._isSetup&&RF.registerToComputeLayoutAndRender(this)},e.prototype.onResize=function(t){return this._resizeHandler=t,this},e.prototype.renderImmediately=function(){return this},e.prototype.redraw=function(){return this._isAnchored&&this._isSetup&&(this.isRoot()?this._scheduleComputeLayout():this.parent().redraw()),this},e.prototype.invalidateCache=function(){},e.prototype.renderTo=function(t){if(this.detach(),t!=null){var r=void 0;if(typeof t=="string"||bze.isElement(t)?r=GXt.select(t):r=WXt.coerceExternalD3(t),!r.node()||r.node().nodeName==null)throw new Error("Plottable requires a valid Element to renderTo");if(r.node().nodeName==="svg")throw new Error("Plottable 3.x and later can only renderTo an HTML component; pass a div instead!");this.anchor(r)}if(this._element==null)throw new Error("If a Component has never been rendered before, then renderTo must be given a node to render to, or a d3.Selection, or a selector string");return RF.registerToComputeLayoutAndRender(this),RF.flush(),this},e.prototype.xAlignment=function(t){if(t==null)return this._xAlignment;if(t=t.toLowerCase(),e._xAlignToProportion[t]==null)throw new Error("Unsupported alignment: "+t);return this._xAlignment=t,this.redraw(),this},e.prototype.yAlignment=function(t){if(t==null)return this._yAlignment;if(t=t.toLowerCase(),e._yAlignToProportion[t]==null)throw new Error("Unsupported alignment: "+t);return this._yAlignment=t,this.redraw(),this},e.prototype.hasClass=function(t){return t==null?!1:this._element==null?this._cssClasses.has(t):this._element.classed(t)},e.prototype.addClass=function(t){return t==null?this:(this._element==null?this._cssClasses.add(t):this._element.classed(t,!0),this)},e.prototype.removeClass=function(t){return t==null?this:(this._element==null?this._cssClasses.delete(t):this._element.classed(t,!1),this)},e.prototype.fixedWidth=function(){return!1},e.prototype.fixedHeight=function(){return!1},e.prototype.detach=function(){return this.parent(null),this._isAnchored&&this._element.remove(),this._isAnchored=!1,this._onDetachCallbacks.callCallbacks(this),this},e.prototype.onDetach=function(t){return this._onDetachCallbacks.add(t),this},e.prototype.offDetach=function(t){return this._onDetachCallbacks.delete(t),this},e.prototype.parent=function(t){if(t===void 0)return this._parent;if(t!==null&&!t.has(this))throw new Error("Passed invalid parent");return this._parent=t,this},e.prototype.bounds=function(){var t=this.origin();return{topLeft:t,bottomRight:{x:t.x+this.width(),y:t.y+this.height()}}},e.prototype.destroy=function(){this._destroyed=!0,this.detach()},e.prototype.width=function(){return this._width},e.prototype.height=function(){return this._height},e.prototype.origin=function(){return{x:this._origin.x,y:this._origin.y}},e.prototype.originToRoot=function(){for(var t=this.origin(),r=this.parent();r!=null;){var n=r.origin();t.x+=n.x,t.y+=n.y,r=r.parent()}return t},e.prototype.root=function(){for(var t=this;!t.isRoot();)t=t.parent();return t},e.prototype.isRoot=function(){return this.parent()==null},e.prototype.foreground=function(){return this._foregroundContainer},e.prototype.content=function(){return this._content},e.prototype.element=function(){return this._element},e.prototype.rootElement=function(){return this.root()._rootElement},e.prototype.background=function(){return this._backgroundContainer},e._xAlignToProportion={left:0,center:.5,right:1},e._yAlignToProportion={top:0,center:.5,bottom:1},e}();QA.Component=wze});var Bu=H(Fu=>{"use strict";Object.defineProperty(Fu,"__esModule",{value:!0});var vS=(Er(),Ut(Mr)),Sze=!1;function Mze(e,t,r){e===void 0&&(e=2),t===void 0&&(t="$"),r===void 0&&(r=!0);var n=qit(e);return function(i){var o=n(Math.abs(i));return o!==""&&(r?o=t+o:o+=t,i<0&&(o="-"+o)),o}}Fu.currency=Mze;function qit(e){return e===void 0&&(e=3),NF(e),function(t){return t.toFixed(e)}}Fu.fixed=qit;function Eze(e){return e===void 0&&(e=3),NF(e),function(t){if(typeof t=="number"){var r=Math.pow(10,e);return String(Math.round(t*r)/r)}else return String(t)}}Fu.general=Eze;function Tze(){return function(e){return String(e)}}Fu.identity=Tze;function Cze(e){e===void 0&&(e=0);var t=qit(e);return function(r){var n=r*100,i=r.toString(),o=Math.pow(10,i.length-(i.indexOf(".")+1));return n=parseInt((n*o).toString(),10)/o,t(n)+"%"}}Fu.percentage=Cze;function Aze(e){return e===void 0&&(e=3),NF(e),function(t){return vS.format("."+e+"s")(t)}}Fu.siSuffix=Aze;function Pze(e){e===void 0&&(e=3),NF(e);var t="KMBTQ",r=vS.format("."+e+"e"),n=vS.format("."+e+"f"),i=Math.pow(10,3*(t.length+1)),o=Math.pow(10,-e);return function(a){var s=Math.abs(a);if((s<o||s>=i)&&s!==0)return r(a);for(var l=-1;s>=Math.pow(1e3,l+2)&&l<t.length-1;)l++;var c="";return l===-1?c=n(a):c=n(a/Math.pow(1e3,l+1))+t[l],(a>0&&c.substr(0,4)==="1000"||a<0&&c.substr(0,5)==="-1000")&&(l<t.length-1?(l++,c=n(a/Math.pow(1e3,l+1))+t[l]):c=r(a)),c}}Fu.shortScale=Pze;function Ize(){var e=[{specifier:".%L",predicate:function(t){return t.getMilliseconds()!==0}},{specifier:":%S",predicate:function(t){return t.getSeconds()!==0}},{specifier:"%I:%M",predicate:function(t){return t.getMinutes()!==0}},{specifier:"%I %p",predicate:function(t){return t.getHours()!==0}},{specifier:"%a %d",predicate:function(t){return t.getDay()!==0&&t.getDate()!==1}},{specifier:"%b %d",predicate:function(t){return t.getDate()!==1}},{specifier:"%b",predicate:function(t){return t.getMonth()!==0}}];return function(t){var r=e.filter(function(i){return i.predicate(t)}),n=r.length>0?r[0].specifier:"%Y";return vS.timeFormat(n)(t)}}Fu.multiTime=Ize;function Lze(e,t){return t===void 0&&(t=Sze),t?vS.utcFormat(e):vS.timeFormat(e)}Fu.time=Lze;function NF(e){if(e<0||e>20)throw new RangeError("Formatter precision must be between 0 and 20");if(e!==Math.floor(e))throw new RangeError("Formatter precision must be an integer")}});var t4=H(DF=>{"use strict";Object.defineProperty(DF,"__esModule",{value:!0});var kze=(de(),Ut(pe)),yd=(Er(),Ut(Mr)),Git=_l(),Rze=kc(),jXt=Bu(),xS=Fe(),Nze=If();DF.AxisOrientation=Nze.makeEnum(["bottom","left","right","top"]);var Dze=function(e){kze.__extends(t,e);function t(r,n){var i=e.call(this)||this;if(i._endTickLength=5,i._innerTickLength=5,i._tickLabelPadding=10,i._margin=15,i._showEndTickLabels=!1,i._annotationsEnabled=!1,i._annotationTierCount=1,r==null||n==null)throw new Error("Axis requires a scale and orientation");return i._scale=r,i.orientation(n),i._setDefaultAlignment(),i.addClass("axis"),i.isHorizontal()?i.addClass("x-axis"):i.addClass("y-axis"),i.formatter(jXt.identity()),i._rescaleCallback=function(o){return i._rescale()},i._scale.onUpdate(i._rescaleCallback),i._annotatedTicks=[],i._annotationFormatter=jXt.identity(),i}return t.prototype.destroy=function(){e.prototype.destroy.call(this),this._scale.offUpdate(this._rescaleCallback)},t.prototype.tickLabelDataOnElement=function(r){if(r!=null){for(var n;r!=null&&r.classList&&n===void 0;)r.classList.contains(t.TICK_LABEL_CLASS)?n=r:r=r.parentNode;return r===void 0?void 0:yd.select(r).datum()}},t.prototype._computeWidth=function(){return this._maxLabelTickLength()},t.prototype._computeHeight=function(){return this._maxLabelTickLength()},t.prototype.requestedSpace=function(r,n){var i=0,o=0;if(this.isHorizontal()){if(o=this._computeHeight()+this._margin,this.annotationsEnabled()){var a=this._annotationMeasurer.measure().height+2*t._ANNOTATION_LABEL_PADDING;o+=a*this.annotationTierCount()}}else if(i=this._computeWidth()+this._margin,this.annotationsEnabled()){var a=this._annotationMeasurer.measure().height+2*t._ANNOTATION_LABEL_PADDING;i+=a*this.annotationTierCount()}return{minWidth:i,minHeight:o}},t.prototype.fixedHeight=function(){return this.isHorizontal()},t.prototype.fixedWidth=function(){return!this.isHorizontal()},t.prototype._rescale=function(){this.render()},t.prototype.computeLayout=function(r,n,i){return e.prototype.computeLayout.call(this,r,n,i),this.isHorizontal()?this._scale.range([0,this.width()]):this._scale.range([this.height(),0]),this},t.prototype._sizeFromOffer=function(r,n){var i=this.requestedSpace(r,n);return this.isHorizontal()?{width:r,height:i.minHeight}:{height:n,width:i.minWidth}},t.prototype._setup=function(){e.prototype._setup.call(this),this._tickMarkContainer=this.content().append("g").classed(t.TICK_MARK_CLASS+"-container",!0),this._tickLabelContainer=this.content().append("g").classed(t.TICK_LABEL_CLASS+"-container",!0),this._baseline=this.content().append("line").classed("baseline",!0),this._annotationContainer=this.content().append("g").classed("annotation-container",!0),this._annotationContainer.append("g").classed("annotation-line-container",!0),this._annotationContainer.append("g").classed("annotation-circle-container",!0),this._annotationContainer.append("g").classed("annotation-rect-container",!0);var r=this._annotationContainer.append("g").classed("annotation-label-container",!0),n=new Git.SvgContext(r.node());this._annotationMeasurer=new Git.CacheMeasurer(n),this._annotationWriter=new Git.Writer(this._annotationMeasurer,n)},t.prototype._getTickValues=function(){return[]},t.prototype.renderImmediately=function(){var r=this._getTickValues(),n=this._tickMarkContainer.selectAll("."+t.TICK_MARK_CLASS).data(r),i=n.enter().append("line").classed(t.TICK_MARK_CLASS,!0).merge(n);return i.attrs(this._generateTickMarkAttrHash()),yd.select(i.nodes()[0]).classed(t.END_TICK_MARK_CLASS,!0).attrs(this._generateTickMarkAttrHash(!0)),yd.select(i.nodes()[r.length-1]).classed(t.END_TICK_MARK_CLASS,!0).attrs(this._generateTickMarkAttrHash(!0)),n.exit().remove(),this._baseline.attrs(this._generateBaselineAttrHash()),this.annotationsEnabled()?this._drawAnnotations():this._removeAnnotations(),this},t.prototype.annotatedTicks=function(r){return r==null?this._annotatedTicks:(this._annotatedTicks=r,this.render(),this)},t.prototype.annotationFormatter=function(r){return r==null?this._annotationFormatter:(this._annotationFormatter=r,this.render(),this)},t.prototype.annotationsEnabled=function(r){return r==null?this._annotationsEnabled:(this._annotationsEnabled=r,this.redraw(),this)},t.prototype.annotationTierCount=function(r){if(r==null)return this._annotationTierCount;if(r<0)throw new Error("annotationTierCount cannot be negative");return this._annotationTierCount=r,this.redraw(),this},t.prototype._drawAnnotations=function(){var r=this,n=t._ANNOTATION_LABEL_PADDING,i=new xS.Map,o=this._annotatedTicksToRender();o.forEach(function(P){var k=r._annotationMeasurer.measure(r.annotationFormatter()(P)),O={width:k.width+2*n,height:k.height+2*n};i.set(P,O)});var a=this._annotationMeasurer.measure().height+2*n,s=this._annotationToTier(i),l=new xS.Set,c=this.isHorizontal()?this.height():this.width(),u=this._coreSize(),h=Math.min(this.annotationTierCount(),Math.floor((c-u)/a));s.forEach(function(P,k){(P===-1||P>=h)&&l.add(k)});var f=function(P,k,O){var D=P.selectAll("."+O).data(o),B=D.enter().append(k).classed(O,!0).merge(D);return D.exit().remove(),B},p=function(P){switch(r.orientation()){case"bottom":case"right":return s.get(P)*a+u;case"top":case"left":return c-u-s.get(P)*a}},d=function(P){return r._scale.scale(P)},g=function(P){return l.has(P)?"hidden":"visible"},_;switch(this.orientation()){case"bottom":case"right":_=0;break;case"top":_=this.height();break;case"left":_=this.width();break}var y=this.isHorizontal();f(this._annotationContainer.select(".annotation-line-container"),"line",t.ANNOTATION_LINE_CLASS).attrs({x1:y?d:_,x2:y?d:p,y1:y?_:d,y2:y?p:d,visibility:g}),f(this._annotationContainer.select(".annotation-circle-container"),"circle",t.ANNOTATION_CIRCLE_CLASS).attrs({cx:y?d:_,cy:y?_:d,r:3});var x=function(P){switch(r.orientation()){case"bottom":case"right":return p(P);case"top":case"left":return p(P)-i.get(P).height}};f(this._annotationContainer.select(".annotation-rect-container"),"rect",t.ANNOTATION_RECT_CLASS).attrs({x:y?d:x,y:y?x:d,width:y?function(P){return i.get(P).width}:function(P){return i.get(P).height},height:y?function(P){return i.get(P).height}:function(P){return i.get(P).width},visibility:g});var b=this._annotationWriter,S=this.annotationFormatter(),C=f(this._annotationContainer.select(".annotation-label-container"),"g",t.ANNOTATION_LABEL_CLASS);C.selectAll(".text-container").remove(),C.attrs({transform:function(P){var k=y?d(P):x(P),O=y?x(P):d(P);return"translate("+k+","+O+")"},visibility:g}).each(function(P){b.write(S(P),y?i.get(P).width:i.get(P).height,y?i.get(P).height:i.get(P).width,{xAlign:"center",yAlign:"center",textRotation:y?0:90},yd.select(this).node())})},t.prototype._annotatedTicksToRender=function(){var r=this,n=this._scale.range();return xS.Array.uniq(this.annotatedTicks().filter(function(i){return i==null?!1:xS.Math.inRange(r._scale.scale(i),n[0],n[1])}))},t.prototype._coreSize=function(){var r=this.isHorizontal()?this.height():this.width(),n=this.isHorizontal()?this._computeHeight():this._computeWidth();return Math.min(n,r)},t.prototype._annotationTierHeight=function(){return this._annotationMeasurer.measure().height+2*t._ANNOTATION_LABEL_PADDING},t.prototype._annotationToTier=function(r){var n=this,i=[[]],o=new xS.Map,a=this.isHorizontal()?this.width():this.height();return this._annotatedTicksToRender().forEach(function(s){var l=n._scale.scale(s),c=r.get(s).width;if(l<0||l+c>a){o.set(s,-1);return}for(var u=function(f){return i[f].some(function(p){var d=n._scale.scale(p),g=r.get(p).width;return l+c>=d&&l<=d+g})},h=0;u(h);)h++,i.length===h&&i.push([]);i[h].push(s),o.set(s,h)}),o},t.prototype._removeAnnotations=function(){this._annotationContainer.selectAll(".annotation-line").remove(),this._annotationContainer.selectAll(".annotation-circle").remove(),this._annotationContainer.selectAll(".annotation-rect").remove(),this._annotationContainer.selectAll(".annotation-label").remove()},t.prototype._generateBaselineAttrHash=function(){var r={x1:0,y1:0,x2:0,y2:0};switch(this._orientation){case"bottom":r.x2=this.width();break;case"top":r.x2=this.width(),r.y1=this.height(),r.y2=this.height();break;case"left":r.x1=this.width(),r.x2=this.width(),r.y2=this.height();break;case"right":r.y2=this.height();break}return r},t.prototype._generateTickMarkAttrHash=function(r){var n=this;r===void 0&&(r=!1);var i={x1:0,y1:0,x2:0,y2:0},o=function(s){return n._scale.scale(s)};this.isHorizontal()?(i.x1=o,i.x2=o):(i.y1=o,i.y2=o);var a=r?this._endTickLength:this._innerTickLength;switch(this._orientation){case"bottom":i.y2=a;break;case"top":i.y1=this.height(),i.y2=this.height()-a;break;case"left":i.x1=this.width(),i.x2=this.width()-a;break;case"right":i.x2=a;break}return i},t.prototype._setDefaultAlignment=function(){switch(this._orientation){case"bottom":this.yAlignment("top");break;case"top":this.yAlignment("bottom");break;case"left":this.xAlignment("right");break;case"right":this.xAlignment("left");break}},t.prototype.isHorizontal=function(){return this._orientation==="top"||this._orientation==="bottom"},t.prototype.getScale=function(){return this._scale},t.prototype.formatter=function(r){return r==null?this._formatter:(this._formatter=r,this.redraw(),this)},t.prototype.innerTickLength=function(r){if(r==null)return this._innerTickLength;if(r<0)throw new Error("inner tick length must be positive");return this._innerTickLength=r,this.redraw(),this},t.prototype.endTickLength=function(r){if(r==null)return this._endTickLength;if(r<0)throw new Error("end tick length must be positive");return this._endTickLength=r,this.redraw(),this},t.prototype._maxLabelTickLength=function(){return this.showEndTickLabels()?Math.max(this.innerTickLength(),this.endTickLength()):this.innerTickLength()},t.prototype.tickLabelPadding=function(r){if(r==null)return this._tickLabelPadding;if(r<0)throw new Error("tick label padding must be positive");return this._tickLabelPadding=r,this.redraw(),this},t.prototype.margin=function(r){if(r==null)return this._margin;if(r<0)throw new Error("margin size must be positive");return this._margin=r,this.redraw(),this},t.prototype.orientation=function(r){if(r==null)return this._orientation;var n=r.toLowerCase();if(n!=="top"&&n!=="bottom"&&n!=="left"&&n!=="right")throw new Error("unsupported orientation");return this._orientation=n,this.redraw(),this},t.prototype.showEndTickLabels=function(r){return r==null?this._showEndTickLabels:(this._showEndTickLabels=r,this.render(),this)},t.prototype._showAllTickMarks=function(){this._tickMarkContainer.selectAll("."+t.TICK_MARK_CLASS).each(function(){yd.select(this).style("visibility","inherit")})},t.prototype._showAllTickLabels=function(){this._tickLabelContainer.selectAll("."+t.TICK_LABEL_CLASS).each(function(){yd.select(this).style("visibility","inherit")})},t.prototype._hideOverflowingTickLabels=function(){var r=this.element().node().getBoundingClientRect(),n=this._tickLabelContainer.selectAll("."+t.TICK_LABEL_CLASS);n.empty()||n.each(function(i,o){xS.DOM.clientRectInside(this.getBoundingClientRect(),r)||yd.select(this).style("visibility","hidden")})},t.prototype._hideTickMarksWithoutLabel=function(){var r=this._tickMarkContainer.selectAll("."+t.TICK_MARK_CLASS),n=this._tickLabelContainer.selectAll("."+t.TICK_LABEL_CLASS).filter(function(o,a){var s=yd.select(this).style("visibility");return s==="inherit"||s==="visible"}),i=n.data();r.each(function(o,a){i.indexOf(o)===-1&&yd.select(this).style("visibility","hidden")})},t.prototype.invalidateCache=function(){e.prototype.invalidateCache.call(this),this._annotationMeasurer.reset()},t.END_TICK_MARK_CLASS="end-tick-mark",t.TICK_MARK_CLASS="tick-mark",t.TICK_LABEL_CLASS="tick-label",t.ANNOTATION_LINE_CLASS="annotation-line",t.ANNOTATION_RECT_CLASS="annotation-rect",t.ANNOTATION_CIRCLE_CLASS="annotation-circle",t.ANNOTATION_LABEL_CLASS="annotation-label",t._ANNOTATION_LABEL_PADDING=4,t}(Rze.Component);DF.Axis=Dze});var $Xt=H(jit=>{"use strict";Object.defineProperty(jit,"__esModule",{value:!0});var Oze=(de(),Ut(pe)),Wit=(Er(),Ut(Mr)),OF=_l(),zze=kc(),XXt=Fe(),Yit=t4(),Fze=function(e){Oze.__extends(t,e);function t(r,n){n===void 0&&(n="bottom");var i=e.call(this,r,n)||this;return i._tickLabelAngle=0,i._tickLabelShearAngle=0,i.addClass("category-axis"),i}return Object.defineProperty(t.prototype,"_wrapper",{get:function(){var r=new OF.Wrapper;return this._tickLabelMaxLines!=null&&r.maxLines(this._tickLabelMaxLines),r},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"_writer",{get:function(){return new OF.Writer(this._measurer,this._typesetterContext,this._wrapper)},enumerable:!0,configurable:!0}),t.prototype._setup=function(){e.prototype._setup.call(this),this._typesetterContext=new OF.SvgContext(this._tickLabelContainer.node()),this._measurer=new OF.CacheMeasurer(this._typesetterContext)},t.prototype._rescale=function(){return this.redraw()},t.prototype.requestedSpace=function(r,n){var i=this.isHorizontal()?0:this._tickSpaceRequired()+this.margin(),o=this.isHorizontal()?this._tickSpaceRequired()+this.margin():0;if(this._scale.domain().length===0)return{minWidth:0,minHeight:0};if(this.annotationsEnabled()){var a=this._annotationTierHeight()*this.annotationTierCount();this.isHorizontal()?o+=a:i+=a}var s=this._measureTickLabels(r,n);return{minWidth:s.usedWidth+i,minHeight:s.usedHeight+o}},t.prototype._coreSize=function(){var r=this.isHorizontal()?this.height():this.width(),n=this.isHorizontal()?this.requestedSpace(this.width(),this.height()).minHeight:this.requestedSpace(this.width(),this.height()).minWidth,i=this.margin()+this._annotationTierHeight(),o=n-i;return Math.min(o,r)},t.prototype._getTickValues=function(){return this.getDownsampleInfo().domain},t.prototype._sizeFromOffer=function(r,n){return zze.Component.prototype._sizeFromOffer.call(this,r,n)},t.prototype.getDownsampleInfo=function(r,n){r===void 0&&(r=this._scale),n===void 0&&(n=r.invertRange());var i=this._tickLabelAngle===0?1:1/Math.cos(this._tickLabelShearAngle/180*Math.PI),o=t._MINIMUM_WIDTH_PER_LABEL_PX*i,a=Math.ceil(o/r.stepWidth());return{domain:n.filter(function(s,l){return l%a===0}),stepWidth:a*r.stepWidth()}},t.prototype.tickLabelAngle=function(r){if(r==null)return this._tickLabelAngle;if(r!==0&&r!==90&&r!==-90)throw new Error("Angle "+r+" not supported; only 0, 90, and -90 are valid values");return this._tickLabelAngle=r,this.redraw(),this},t.prototype.tickLabelShearAngle=function(r){if(r==null)return this._tickLabelShearAngle;if(r<-80||r>80)throw new Error("Angle "+r+" not supported; Must be between [-80, 80]");return this._tickLabelShearAngle=r,this.redraw(),this},t.prototype.tickLabelMaxWidth=function(r){return arguments.length===0?this._tickLabelMaxWidth:(this._tickLabelMaxWidth=r,this.redraw(),this)},t.prototype.tickLabelMaxLines=function(r){return arguments.length===0?this._tickLabelMaxLines:(this._tickLabelMaxLines=r,this.redraw(),this)},t.prototype._tickSpaceRequired=function(){return this._maxLabelTickLength()+this.tickLabelPadding()},t.prototype._drawTicks=function(r,n){var i=this,o,a;switch(this.tickLabelAngle()){case 0:o={left:"right",right:"left",top:"center",bottom:"center"},a={left:"center",right:"center",top:"bottom",bottom:"top"};break;case 90:o={left:"center",right:"center",top:"right",bottom:"left"},a={left:"top",right:"bottom",top:"center",bottom:"center"};break;case-90:o={left:"center",right:"center",top:"left",bottom:"right"},a={left:"bottom",right:"top",top:"center",bottom:"center"};break}n.each(function(s){var l=Wit.select(this),c=i.isHorizontal()?r:i.width()-i._tickSpaceRequired(),u=i.isHorizontal()?i.height()-i._tickSpaceRequired():r,h={xAlign:o[i.orientation()],yAlign:a[i.orientation()],textRotation:i.tickLabelAngle(),textShear:i.tickLabelShearAngle()};if(i._tickLabelMaxWidth!=null){if(i.orientation()==="left"&&c>i._tickLabelMaxWidth){var f=c-i._tickLabelMaxWidth,p=l.attr("transform")+" translate("+f+", 0)";l.attr("transform",p)}c=Math.min(c,i._tickLabelMaxWidth)}i._writer.write(i.formatter()(s),c,u,h,l.node())})},t.prototype._measureTickLabels=function(r,n){var i=this,o=this._scale,a=o.cloneWithoutProviders().range([0,this.isHorizontal()?r:n]),s=this.getDownsampleInfo(a),l=s.domain,c=s.stepWidth,u=r-this._tickSpaceRequired();this.isHorizontal()&&(u=c,this._tickLabelAngle!==0&&(u=n-this._tickSpaceRequired()),u=Math.max(u,0));var h=c;this.isHorizontal()&&(h=n-this._tickSpaceRequired(),this._tickLabelAngle!==0&&(h=r-this._tickSpaceRequired()),h=Math.max(h,0)),this._tickLabelMaxWidth!=null&&(u=Math.min(u,this._tickLabelMaxWidth));var f=l.map(function(x){return i._wrapper.wrap(i.formatter()(x),i._measurer,u,h)}),p=this.isHorizontal()&&this._tickLabelAngle===0?Wit.sum:XXt.Math.max,d=this.isHorizontal()&&this._tickLabelAngle===0?XXt.Math.max:Wit.sum,g=p(f,function(x){return i._measurer.measure(x.wrappedText).width},0),_=d(f,function(x){return i._measurer.measure(x.wrappedText).height},0);return this._tickLabelAngle!==0&&(y=[_,g],g=y[0],_=y[1]),{usedWidth:g,usedHeight:_};var y},t.prototype.renderImmediately=function(){var r=this;e.prototype.renderImmediately.call(this);var n=this._scale,i=this.getDownsampleInfo(n),o=i.domain,a=i.stepWidth,s=a;this.isHorizontal()&&this._tickLabelMaxWidth!=null&&(s=Math.min(s,this._tickLabelMaxWidth));var l=function(p,d){var g=n.scale(p)-s/2,_=r.isHorizontal()?g:0,y=r.isHorizontal()?0:g;return"translate("+_+","+y+")"},c=this._tickLabelContainer.selectAll("."+Yit.Axis.TICK_LABEL_CLASS).data(o),u=c.enter().append("g").classed(Yit.Axis.TICK_LABEL_CLASS,!0).merge(c);c.exit().remove(),u.attr("transform",l),u.text(""),this._drawTicks(a,u);var h=this.orientation()==="right"?this._tickSpaceRequired():0,f=this.orientation()==="bottom"?this._tickSpaceRequired():0;return this._tickLabelContainer.attr("transform","translate("+h+","+f+")"),this._showAllTickMarks(),this._showAllTickLabels(),this._hideTickMarksWithoutLabel(),this},t.prototype.computeLayout=function(r,n,i){return e.prototype.computeLayout.call(this,r,n,i),this.isHorizontal()||this._scale.range([0,this.height()]),this},t.prototype.invalidateCache=function(){e.prototype.invalidateCache.call(this),this._measurer.reset()},t._MINIMUM_WIDTH_PER_LABEL_PX=15,t}(Yit.Axis);jit.Category=Fze});var KXt=H($it=>{"use strict";Object.defineProperty($it,"__esModule",{value:!0});var Bze=(de(),Ut(pe)),zF=(Er(),Ut(Mr)),Xit=_l(),Hze=Bu(),bS=Fe(),wS=t4(),Vze=function(e){Bze.__extends(t,e);function t(r,n){var i=e.call(this,r,n)||this;return i._tickLabelPositioning="center",i._usesTextWidthApproximation=!1,i.formatter(Hze.general()),i}return t.prototype._setup=function(){e.prototype._setup.call(this);var r=new Xit.SvgContext(this._tickLabelContainer.node(),wS.Axis.TICK_LABEL_CLASS);this._measurer=new Xit.CacheMeasurer(r),this._wrapper=new Xit.Wrapper().maxLines(1)},t.prototype._computeWidth=function(){var r=this._usesTextWidthApproximation?this._computeApproximateTextWidth():this._computeExactTextWidth();return this._tickLabelPositioning==="center"?this._maxLabelTickLength()+this.tickLabelPadding()+r:Math.max(this._maxLabelTickLength(),this.tickLabelPadding()+r)},t.prototype._computeExactTextWidth=function(){var r=this,n=this._getTickValues(),i=n.map(function(o){var a=r.formatter()(o);return r._measurer.measure(a).width});return bS.Math.max(i,0)},t.prototype._computeApproximateTextWidth=function(){var r=this,n=this._getTickValues(),i=this._measurer.measure("M").width,o=n.map(function(a){var s=r.formatter()(a);return s.length*i});return bS.Math.max(o,0)},t.prototype._computeHeight=function(){var r=this._measurer.measure().height;return this._tickLabelPositioning==="center"?this._maxLabelTickLength()+this.tickLabelPadding()+r:Math.max(this._maxLabelTickLength(),this.tickLabelPadding()+r)},t.prototype._getTickValues=function(){var r=this._scale,n=r.domain(),i=n[0]<=n[1]?n[0]:n[1],o=n[0]>=n[1]?n[0]:n[1];return r.ticks().filter(function(a){return a>=i&&a<=o})},t.prototype._rescale=function(){if(!!this._isSetup){if(!this.isHorizontal()){var r=this._computeWidth();if(r>this.width()||r<this.width()-this.margin()){this.redraw();return}}this.render()}},t.prototype.renderImmediately=function(){var r=this;e.prototype.renderImmediately.call(this);var n={x:0,y:0,dx:"0em",dy:"0.3em"},i=this._maxLabelTickLength(),o=this.tickLabelPadding(),a="middle",s=0,l=0,c=0,u=0;if(this.isHorizontal())switch(this._tickLabelPositioning){case"left":a="end",s=-o,u=o;break;case"center":u=i+o;break;case"right":a="start",s=o,u=o;break}else switch(this._tickLabelPositioning){case"top":n.dy="-0.3em",c=o,l=-o;break;case"center":c=i+o;break;case"bottom":n.dy="1em",c=o,l=o;break}var h=this._generateTickMarkAttrHash();switch(this.orientation()){case"bottom":n.x=h.x1,n.dy="0.95em",l=h.y1+u;break;case"top":n.x=h.x1,n.dy="-.25em",l=h.y1-u;break;case"left":a="end",s=h.x1-c,n.y=h.y1;break;case"right":a="start",s=h.x1+c,n.y=h.y1;break}var f=this._getTickValues(),p=this._tickLabelContainer.selectAll("."+wS.Axis.TICK_LABEL_CLASS).data(f);p.exit().remove();var d=p.enter().append("text").classed(wS.Axis.TICK_LABEL_CLASS,!0).merge(p);d.style("text-anchor",a).style("visibility","inherit").attrs(n).text(function(_){return r.formatter()(_)});var g="translate("+s+", "+l+")";return this._tickLabelContainer.attr("transform",g),this._showAllTickMarks(),this.showEndTickLabels()||this._hideEndTickLabels(),this._hideOverflowingTickLabels(),this._hideOverlappingTickLabels(),this._tickLabelPositioning!=="center"&&this._hideTickMarksWithoutLabel(),this},t.prototype.tickLabelPosition=function(r){if(r==null)return this._tickLabelPositioning;var n=r.toLowerCase();if(this.isHorizontal()){if(!(n==="left"||n==="center"||n==="right"))throw new Error(n+" is not a valid tick label position for a horizontal NumericAxis")}else if(!(n==="top"||n==="center"||n==="bottom"))throw new Error(n+" is not a valid tick label position for a vertical NumericAxis");return this._tickLabelPositioning=n,this.redraw(),this},t.prototype.usesTextWidthApproximation=function(r){return r==null?this._usesTextWidthApproximation:(this._usesTextWidthApproximation=r,this)},t.prototype._hideEndTickLabels=function(){var r=this.element().node().getBoundingClientRect(),n=this._tickLabelContainer.selectAll("."+wS.Axis.TICK_LABEL_CLASS);if(n.size()!==0){var i=n.nodes()[0];bS.DOM.clientRectInside(i.getBoundingClientRect(),r)||zF.select(i).style("visibility","hidden");var o=n.nodes()[n.size()-1];bS.DOM.clientRectInside(o.getBoundingClientRect(),r)||zF.select(o).style("visibility","hidden")}},t.prototype._hideOverlappingTickLabels=function(){for(var r=this._tickLabelContainer.selectAll("."+wS.Axis.TICK_LABEL_CLASS).filter(function(o,a){var s=zF.select(this).style("visibility");return s==="inherit"||s==="visible"}),n=r.nodes().map(function(o){return o.getBoundingClientRect()}),i=1;!this._hasOverlapWithInterval(i,n)&&i<n.length;)i+=1;r.each(function(o,a){var s=zF.select(this);a%i!==0&&s.style("visibility","hidden")})},t.prototype._hasOverlapWithInterval=function(r,n){for(var i=this._tickLabelPositioning==="center"?this.tickLabelPadding():this.tickLabelPadding()*3,o=n.map(function(c){return bS.DOM.expandRect(c,i)}),a=0;a<o.length-r;a+=r){var s=o[a],l=o[a+r];if(bS.DOM.clientRectsOverlap(s,l))return!1}return!0},t.prototype.invalidateCache=function(){e.prototype.invalidateCache.call(this),this._measurer.reset()},t}(wS.Axis);$it.Numeric=Vze});var ZXt=H(FF=>{"use strict";Object.defineProperty(FF,"__esModule",{value:!0});var Uze=Fe();function qze(e){if(e<=0)throw new Error("interval must be positive number");return function(t){var r=t.domain(),n=Math.min(r[0],r[1]),i=Math.max(r[0],r[1]),o=Math.ceil(n/e)*e,a=Math.floor((i-o)/e)+1,s=n%e===0?[]:[n],l=Uze.Math.range(0,a).map(function(u){return o+u*e}),c=i%e===0?[]:[i];return s.concat(l).concat(c)}}FF.intervalTickGenerator=qze;function Gze(){return function(e){var t=e.defaultTicks();return t.filter(function(r,n){return r%1===0||n===0||n===t.length-1})}}FF.integerTickGenerator=Gze});var e4=H(Iv=>{"use strict";Object.defineProperty(Iv,"__esModule",{value:!0});function Zit(e,t,r){return r-(r-e)*t}Iv.zoomOut=Zit;function Kit(e,t,r){return(e*t-r)/(t-1)}function Wze(e,t,r,n,i,o,a){return t=JXt(e,t,n,i),QXt(e,t,r,o,a)}Iv.constrainedZoom=Wze;function JXt(e,t,r,n){var i=t>1,o=i?n:r;if(o==null)return t;var a=e.getTransformationDomain(),s=a[0],l=a[1],c=Math.abs(l-s),u=i?Math.min:Math.max;return u(t,o/c)}Iv.constrainZoomExtents=JXt;function QXt(e,t,r,n,i){if(t<=1)return{centerPoint:r,zoomAmount:t};if(n==null&&i==null)return{centerPoint:r,zoomAmount:t};var o=t$t(e),a=jze(e),s=a?1/0:-1/0,l=a?-1/0:1/0;n=n==null?s:n,i=i==null?l:i;var c=e.getTransformationDomain(),u=c[0],h=c[1],f=e.scaleTransformation(i),p=e.scaleTransformation(h),d=Zit(p,t,r),g=e.scaleTransformation(n),_=e.scaleTransformation(u),y=Zit(_,t,r),x=Math.abs(f-g),b=Math.abs(d-y);if(b>x){var S=(f-g)/(p-_);if(S!==1){var C=Kit(p,S,f);return{centerPoint:C,zoomAmount:S}}else return{centerPoint:r,zoomAmount:S}}else return d>f!=o?{centerPoint:Kit(p,t,f),zoomAmount:t}:y<g!=o?{centerPoint:Kit(_,t,g),zoomAmount:t}:{centerPoint:r,zoomAmount:t}}Iv.constrainZoomValues=QXt;function Yze(e,t,r,n){var i=e.getTransformationDomain(),o=i[0],a=i[1],s=t$t(e);if(t>0!==s){var l=n;if(l!=null){var c=e.scaleTransformation(a),u=e.scaleTransformation(l);t=(s?Math.max:Math.min)(c+t,u)-c}}else{var l=r;if(l!=null){var h=e.scaleTransformation(o),f=e.scaleTransformation(l);t=(s?Math.min:Math.max)(h+t,f)-h}}return t}Iv.constrainedTranslation=Yze;function t$t(e){var t=e.range();return t[1]<t[0]}function jze(e){var t=e.getTransformationDomain();return t[1]<t[0]}});var Lv=H(Jit=>{"use strict";Object.defineProperty(Jit,"__esModule",{value:!0});var e$t=Fe(),Xze=function(){function e(){this._autoDomainAutomatically=!0,this._domainModificationInProgress=!1,this._updateId=0,this._callbacks=new e$t.CallbackSet,this._includedValuesProviders=new e$t.Set}return e.prototype.extentOfValues=function(t){return[]},e.prototype._getAllIncludedValues=function(t){var r=this;t===void 0&&(t=!1);var n=[];return this._includedValuesProviders.forEach(function(i){var o=i(r,t);n=n.concat(o)}),n},e.prototype._getExtent=function(){return[]},e.prototype.onUpdate=function(t){return this._callbacks.add(t),this},e.prototype.offUpdate=function(t){return this._callbacks.delete(t),this},e.prototype._dispatchUpdate=function(){this._updateId++,this._callbacks.callCallbacks(this)},e.prototype.autoDomain=function(){return this._autoDomainAutomatically=!0,this._setDomain(this._getExtent()),this},e.prototype.autoDomainIfAutomaticMode=function(){this._autoDomainAutomatically&&this.autoDomain()},e.prototype.scale=function(t){throw new Error("Subclasses should override scale")},e.prototype.ticks=function(){return this.domain()},e.prototype.domain=function(t){return t==null?this._getDomain():(this._autoDomainAutomatically=!1,this._setDomain(t),this)},e.prototype._getDomain=function(){throw new Error("Subclasses should override _getDomain")},e.prototype._setDomain=function(t){this._domainModificationInProgress||(this._domainModificationInProgress=!0,this._backingScaleDomain(t),this._dispatchUpdate(),this._domainModificationInProgress=!1)},e.prototype._backingScaleDomain=function(t){throw new Error("Subclasses should override _backingDomain")},e.prototype.range=function(t){return t==null?this._getRange():(this._setRange(t),this)},e.prototype._getRange=function(){throw new Error("Subclasses should override _getRange")},e.prototype._setRange=function(t){throw new Error("Subclasses should override _setRange")},e.prototype.addIncludedValuesProvider=function(t){return this._includedValuesProviders.add(t),this.autoDomainIfAutomaticMode(),this},e.prototype.removeIncludedValuesProvider=function(t){return this._includedValuesProviders.delete(t),this.autoDomainIfAutomaticMode(),this},e.prototype.updateId=function(){return this._updateId},e}();Jit.Scale=Xze});var eot=H(tot=>{"use strict";Object.defineProperty(tot,"__esModule",{value:!0});var $ze=(de(),Ut(pe)),BF=(Er(),Ut(Mr)),Kze=e4(),r$t=Fe(),Zze=Lv(),Qit=[0,1],Jze=function(e){$ze.__extends(t,e);function t(){var r=e.call(this)||this;r._range=[0,1],r._d3Scale=BF.scaleBand(),r._d3Scale.range(Qit),r._d3TransformationScale=BF.scaleLinear(),r._d3TransformationScale.domain(Qit);var n=.3;return r._innerPadding=t._convertToPlottableInnerPadding(n),r._outerPadding=t._convertToPlottableOuterPadding(.5,n),r}return t.prototype.cloneWithoutProviders=function(){var r=new t().domain(this.domain()).range(this.range()).innerPadding(this.innerPadding()).outerPadding(this.outerPadding());return r._d3TransformationScale.domain(this._d3TransformationScale.domain()),r},t.prototype.extentOfValues=function(r){return r$t.Array.uniq(r)},t.prototype._getExtent=function(){return r$t.Array.uniq(this._getAllIncludedValues())},t.prototype.domain=function(r){return e.prototype.domain.call(this,r)},t.prototype.invertRange=function(r){var n=this;r===void 0&&(r=this.range());var i=this._d3Scale.bandwidth(),o=this.invertedTransformation(r[0]),a=this.invertedTransformation(r[1]),s=this._d3Scale.domain(),l=s.map(function(h){return n._d3Scale(h)+i/2}),c=BF.bisect(l,o),u=BF.bisect(l,a);return s.slice(c,u)},t.prototype.range=function(r){return e.prototype.range.call(this,r)},t._convertToPlottableInnerPadding=function(r){return 1/(1-r)-1},t._convertToPlottableOuterPadding=function(r,n){return r/(1-n)},t.prototype._setBands=function(){var r=1-1/(1+this.innerPadding()),n=this.outerPadding()/(1+this.innerPadding());this._d3Scale.paddingInner(r),this._d3Scale.paddingOuter(n)},t.prototype.rangeBand=function(){return this._rescaleBand(this._d3Scale.bandwidth())},t.prototype.stepWidth=function(){return this._rescaleBand(this._d3Scale.bandwidth()*(1+this.innerPadding()))},t.prototype.ticks=function(){return this.domain()},t.prototype.innerPadding=function(r){return r==null?this._innerPadding:(this._innerPadding=r,this.range(this.range()),this._dispatchUpdate(),this)},t.prototype.outerPadding=function(r){return r==null?this._outerPadding:(this._outerPadding=r,this.range(this.range()),this._dispatchUpdate(),this)},t.prototype.scale=function(r){var n=this._d3Scale(r)+this._d3Scale.bandwidth()/2;return this._d3TransformationScale(n)},t.prototype.zoom=function(r,n){var i=this,o=function(a){return i._d3TransformationScale.invert(Kze.zoomOut(a,r,n))};this._d3TransformationScale.domain(this._d3TransformationScale.range().map(o)),this._dispatchUpdate()},t.prototype.pan=function(r){var n=this,i=function(o){return n._d3TransformationScale.invert(o+r)};this._d3TransformationScale.domain(this._d3TransformationScale.range().map(i)),this._dispatchUpdate()},t.prototype.scaleTransformation=function(r){return this._d3TransformationScale(r)},t.prototype.invertedTransformation=function(r){return this._d3TransformationScale.invert(r)},t.prototype.getTransformationExtent=function(){return Qit},t.prototype.getTransformationDomain=function(){return this._d3TransformationScale.domain()},t.prototype.setTransformationDomain=function(r){this._d3TransformationScale.domain(r),this._dispatchUpdate()},t.prototype._getDomain=function(){return this._backingScaleDomain()},t.prototype._backingScaleDomain=function(r){return r==null?this._d3Scale.domain():(this._d3Scale.domain(r),this._setBands(),this)},t.prototype._getRange=function(){return this._range},t.prototype._setRange=function(r){this._range=r,this._d3TransformationScale.range(r),this._setBands()},t.prototype._rescaleBand=function(r){return Math.abs(this._d3TransformationScale(r)-this._d3TransformationScale(0))},t}(Zze.Scale);tot.Category=Jze});var n$t=H(rot=>{"use strict";Object.defineProperty(rot,"__esModule",{value:!0});var Qze=(de(),Ut(pe)),Nf=(Er(),Ut(Mr)),SS=Fe(),tFe=Lv(),eFe=function(){function e(){this.count=0,this.tracker={}}return e.prototype.getIndex=function(t){if(this.tracker[t]!=null)return this.tracker[t];var r=this.count;return this.tracker[t]=r,this.count+=1,r},e.prototype.clear=function(){this.count=0,this.tracker={}},e}(),rFe=function(e){Qze.__extends(t,e);function t(r){var n=e.call(this)||this;n._rangeLength=1,n._tracker=new eFe;var i;switch(r){case null:case void 0:t._plottableColorCache==null&&(t._plottableColorCache=t._getPlottableColors()),i=Nf.scaleOrdinal().range(t._plottableColorCache);break;case"Category10":case"category10":case"10":i=Nf.scaleOrdinal(Nf.schemeCategory10);break;case"Category20":case"category20":case"20":i=Nf.scaleOrdinal(Nf.schemeCategory20);break;case"Category20b":case"category20b":case"20b":i=Nf.scaleOrdinal(Nf.schemeCategory20b);break;case"Category20c":case"category20c":case"20c":i=Nf.scaleOrdinal(Nf.schemeCategory20c);break;default:throw new Error("Unsupported ColorScale type")}return n._d3Scale=i,n._rangeLength=n._d3Scale.range().length,n}return t.prototype.extentOfValues=function(r){return SS.Array.uniq(r)},t.prototype._getExtent=function(){return SS.Array.uniq(this._getAllIncludedValues())},t.invalidateColorCache=function(){t._plottableColorCache=null},t._getPlottableColors=function(){for(var r=[],n=Nf.select("body").append("plottable-color-tester"),i=SS.Color.colorTest(n,""),o=0,a=SS.Color.colorTest(n,"plottable-colors-0");a!=null&&o<this._MAXIMUM_COLORS_FROM_CSS&&!(a===i&&a===r[r.length-1]);)r.push(a),o++,a=SS.Color.colorTest(n,"plottable-colors-"+o);return n.remove(),r},t.prototype.scale=function(r){var n=this._d3Scale(r),i=this._tracker.getIndex(r),o=Math.floor(i/this._rangeLength);if(o===0)return n;var a=Math.log(o*t._LOOP_LIGHTEN_FACTOR+1);return SS.Color.lightenColor(n,a)},t.prototype._getDomain=function(){return this._backingScaleDomain()},t.prototype._backingScaleDomain=function(r){return r==null?this._d3Scale.domain():(this._d3Scale.domain(r),this._tracker.clear(),this)},t.prototype._getRange=function(){return this._d3Scale.range()},t.prototype._setRange=function(r){this._d3Scale.range(r),this._rangeLength=r.length},t._LOOP_LIGHTEN_FACTOR=1.6,t._MAXIMUM_COLORS_FROM_CSS=256,t}(tFe.Scale);rot.Color=rFe});var o$t=H(not=>{"use strict";Object.defineProperty(not,"__esModule",{value:!0});var nFe=(de(),Ut(pe)),MS=(Er(),Ut(Mr)),i$t=Fe(),iFe=Lv(),oFe=function(e){nFe.__extends(t,e);function t(r){r===void 0&&(r="linear");var n=e.call(this)||this;switch(r){case"linear":n._colorScale=MS.scaleLinear();break;case"log":n._colorScale=MS.scaleLog();break;case"sqrt":n._colorScale=MS.scaleSqrt();break;case"pow":n._colorScale=MS.scalePow();break}if(n._colorScale==null)throw new Error("unknown QuantitativeScale scale type "+r);return n.range(t.REDS),n}return t.prototype.extentOfValues=function(r){var n=MS.extent(r);return n[0]==null||n[1]==null?[]:n},t.prototype._d3InterpolatedScale=function(){return this._colorScale.range([0,1]).interpolate(this._interpolateColors())},t.prototype._interpolateColors=function(){var r=this._colorRange;if(r.length<2)throw new Error("Color scale arrays must have at least two elements.");return function(n,i){return function(o){o=Math.max(0,Math.min(1,o));var a=o*(r.length-1),s=Math.floor(a),l=Math.ceil(a),c=a-s;return MS.interpolateLab(r[s],r[l])(c)}}},t.prototype._resetScale=function(){this._d3Scale=this._d3InterpolatedScale(),this.autoDomainIfAutomaticMode(),this._dispatchUpdate()},t.prototype.autoDomain=function(){var r=this._getAllIncludedValues();return r.length>0&&this._setDomain([i$t.Math.min(r,0),i$t.Math.max(r,0)]),this},t.prototype.scale=function(r){return this._d3Scale(r)},t.prototype._getDomain=function(){return this._backingScaleDomain()},t.prototype._backingScaleDomain=function(r){return r==null?this._d3Scale.domain():(this._d3Scale.domain(r),this)},t.prototype._getRange=function(){return this._colorRange},t.prototype._setRange=function(r){this._colorRange=r,this._resetScale()},t.REDS=["#FFFFFF","#FFF6E1","#FEF4C0","#FED976","#FEB24C","#FD8D3C","#FC4E2A","#E31A1C","#B10026"],t.BLUES=["#FFFFFF","#CCFFFF","#A5FFFD","#85F7FB","#6ED3EF","#55A7E0","#417FD0","#2545D3","#0B02E1"],t.POSNEG=["#0B02E1","#2545D3","#417FD0","#55A7E0","#6ED3EF","#85F7FB","#A5FFFD","#CCFFFF","#FFFFFF","#FFF6E1","#FEF4C0","#FED976","#FEB24C","#FD8D3C","#FC4E2A","#E31A1C","#B10026"],t}(iFe.Scale);not.InterpolatedColor=oFe});var vd=H(iot=>{"use strict";Object.defineProperty(iot,"__esModule",{value:!0});var aFe=(de(),Ut(pe)),sFe=(Er(),Ut(Mr)),lFe=e4(),ES=Fe(),cFe=Lv(),uFe=function(e){aFe.__extends(t,e);function t(){var r=e.call(this)||this;return r._tickGenerator=function(n){return n.defaultTicks()},r._padProportion=.05,r._snappingDomainEnabled=!0,r._paddingExceptionsProviders=new ES.Set,r}return t.prototype.autoDomain=function(){return this._domainMin=null,this._domainMax=null,e.prototype.autoDomain.call(this),this},t.prototype.autoDomainIfAutomaticMode=function(){if(this._domainMin!=null&&this._domainMax!=null){this._setDomain([this._domainMin,this._domainMax]);return}var r=this._getExtent();if(this._domainMin!=null){var n=r[1];this._domainMin>=n&&(n=this._expandSingleValueDomain([this._domainMin,this._domainMin])[1]),this._setDomain([this._domainMin,n]);return}if(this._domainMax!=null){var i=r[0];this._domainMax<=i&&(i=this._expandSingleValueDomain([this._domainMax,this._domainMax])[0]),this._setDomain([i,this._domainMax]);return}e.prototype.autoDomainIfAutomaticMode.call(this)},t.prototype._getUnboundedExtent=function(r){r===void 0&&(r=!1);var n=this._getAllIncludedValues(r),i=this._defaultExtent();if(n.length!==0){var o=[ES.Math.min(n,i[0]),ES.Math.max(n,i[1])];i=this._padDomain(o)}return i},t.prototype._getExtent=function(){var r=this._getUnboundedExtent();return this._domainMin!=null&&(r[0]=this._domainMin),this._domainMax!=null&&(r[1]=this._domainMax),r},t.prototype.addPaddingExceptionsProvider=function(r){return this._paddingExceptionsProviders.add(r),this.autoDomainIfAutomaticMode(),this},t.prototype.removePaddingExceptionsProvider=function(r){return this._paddingExceptionsProviders.delete(r),this.autoDomainIfAutomaticMode(),this},t.prototype.padProportion=function(r){if(r==null)return this._padProportion;if(r<0)throw new Error("padProportion must be non-negative");return this._padProportion=r,this.autoDomainIfAutomaticMode(),this},t.prototype._padDomain=function(r){var n=this;if(r[0].valueOf()===r[1].valueOf())return this._expandSingleValueDomain(r);if(this._padProportion===0)return r;var i=this._padProportion/2,o=r[0],a=r[1],s=!1,l=!1;this._paddingExceptionsProviders.forEach(function(f){var p=f(n);p.forEach(function(d){d.valueOf()===o.valueOf()&&(s=!0),d.valueOf()===a.valueOf()&&(l=!0)})});var c=this._backingScaleDomain();this._backingScaleDomain(r);var u=s?o:this.invert(this.scale(o)-(this.scale(a)-this.scale(o))*i),h=l?a:this.invert(this.scale(a)+(this.scale(a)-this.scale(o))*i);return this._backingScaleDomain(c),this._snappingDomainEnabled?this._niceDomain([u,h]):[u,h]},t.prototype.snappingDomainEnabled=function(r){return r==null?this._snappingDomainEnabled:(this._snappingDomainEnabled=r,this.autoDomainIfAutomaticMode(),this)},t.prototype._expandSingleValueDomain=function(r){return r},t.prototype.invert=function(r){throw new Error("Subclasses should override invert")},t.prototype.domain=function(r){return r!=null&&(this._domainMin=r[0],this._domainMax=r[1]),e.prototype.domain.call(this,r)},t.prototype.domainMin=function(r){return r==null?this.domain()[0]:(this._domainMin=r,this.autoDomainIfAutomaticMode(),this)},t.prototype.domainMax=function(r){return r==null?this.domain()[1]:(this._domainMax=r,this.autoDomainIfAutomaticMode(),this)},t.prototype.extentOfValues=function(r){var n=sFe.extent(r.filter(function(i){return ES.Math.isValidNumber(+i)}));return n[0]==null||n[1]==null?[]:n},t.prototype.zoom=function(r,n){var i=this,o=function(a){return i.invert(lFe.zoomOut(a,r,n))};this.domain(this.range().map(o))},t.prototype.pan=function(r){var n=this,i=function(o){return n.invert(o+r)};this.domain(this.range().map(i))},t.prototype.scaleTransformation=function(r){throw new Error("Subclasses should override scaleTransformation")},t.prototype.invertedTransformation=function(r){throw new Error("Subclasses should override invertedTransformation")},t.prototype.getTransformationExtent=function(){throw new Error("Subclasses should override getTransformationExtent")},t.prototype.getTransformationDomain=function(){throw new Error("Subclasses should override getTransformationDomain")},t.prototype.setTransformationDomain=function(r){throw new Error("Subclasses should override setTransformationDomain")},t.prototype._setDomain=function(r){var n=function(i){return ES.Math.isNaN(i)||i===1/0||i===-1/0};if(n(r[0])||n(r[1])){ES.Window.warn("Warning: QuantitativeScales cannot take NaN or Infinity as a domain value. Ignoring.");return}e.prototype._setDomain.call(this,r)},t.prototype.defaultTicks=function(){throw new Error("Subclasses should override _getDefaultTicks")},t.prototype.ticks=function(){return this._tickGenerator(this)},t.prototype._niceDomain=function(r,n){throw new Error("Subclasses should override _niceDomain")},t.prototype._defaultExtent=function(){throw new Error("Subclasses should override _defaultExtent")},t.prototype.tickGenerator=function(r){return r==null?this._tickGenerator:(this._tickGenerator=r,this)},t._DEFAULT_NUM_TICKS=10,t}(cFe.Scale);iot.QuantitativeScale=uFe});var a$t=H(oot=>{"use strict";Object.defineProperty(oot,"__esModule",{value:!0});var hFe=(de(),Ut(pe)),fFe=(Er(),Ut(Mr)),pFe=vd(),dFe=function(e){hFe.__extends(t,e);function t(){var r=e.call(this)||this;return r._d3Scale=fFe.scaleLinear(),r}return t.prototype._defaultExtent=function(){return[0,1]},t.prototype._expandSingleValueDomain=function(r){return r[0]===r[1]?[r[0]-1,r[1]+1]:r},t.prototype.scale=function(r){return this._d3Scale(r)},t.prototype.scaleTransformation=function(r){return this.scale(r)},t.prototype.invertedTransformation=function(r){return this.invert(r)},t.prototype.getTransformationExtent=function(){return this._getUnboundedExtent(!0)},t.prototype.getTransformationDomain=function(){return this.domain()},t.prototype.setTransformationDomain=function(r){this.domain(r)},t.prototype._getDomain=function(){return this._backingScaleDomain()},t.prototype._backingScaleDomain=function(r){return r==null?this._d3Scale.domain():(this._d3Scale.domain(r),this)},t.prototype._getRange=function(){return this._d3Scale.range()},t.prototype._setRange=function(r){this._d3Scale.range(r)},t.prototype.invert=function(r){return this._d3Scale.invert(r)},t.prototype.defaultTicks=function(){return this._d3Scale.ticks(t._DEFAULT_NUM_TICKS)},t.prototype._niceDomain=function(r,n){return this._d3Scale.copy().domain(r).nice(n).domain()},t}(pFe.QuantitativeScale);oot.Linear=dFe});var s$t=H(aot=>{"use strict";Object.defineProperty(aot,"__esModule",{value:!0});var mFe=(de(),Ut(pe)),gFe=(Er(),Ut(Mr)),_Fe=vd(),yFe=function(e){mFe.__extends(t,e);function t(r){r===void 0&&(r=10);var n=e.call(this)||this;return n._d3Scale=gFe.scaleLog().base(r),n._setDomain(n._defaultExtent()),n}return t.prototype._defaultExtent=function(){return[1,this._d3Scale.base()]},t.prototype._expandSingleValueDomain=function(r){return r[0]===r[1]?[r[0]/this._d3Scale.base(),r[1]*this._d3Scale.base()]:r},t.prototype.scale=function(r){return this._d3Scale(r)},t.prototype.scaleTransformation=function(r){return this.scale(r)},t.prototype.invertedTransformation=function(r){return this.invert(r)},t.prototype.getTransformationExtent=function(){return this._getUnboundedExtent(!0)},t.prototype.getTransformationDomain=function(){return this.domain()},t.prototype.setTransformationDomain=function(r){this.domain(r)},t.prototype._getDomain=function(){return this._backingScaleDomain()},t.prototype._backingScaleDomain=function(r){return r==null?this._d3Scale.domain():(this._d3Scale.domain(r),this)},t.prototype._getRange=function(){return this._d3Scale.range()},t.prototype._setRange=function(r){this._d3Scale.range(r)},t.prototype.invert=function(r){return this._d3Scale.invert(r)},t.prototype.defaultTicks=function(){return this._d3Scale.ticks(t._DEFAULT_NUM_TICKS)},t.prototype._niceDomain=function(r,n){return this._d3Scale.copy().domain(r).nice().domain()},t}(_Fe.QuantitativeScale);aot.Log=yFe});var l$t=H(lot=>{"use strict";Object.defineProperty(lot,"__esModule",{value:!0});var vFe=(de(),Ut(pe)),r4=(Er(),Ut(Mr)),TS=Fe(),sot=ks(),xFe=vd(),bFe=function(e){vFe.__extends(t,e);function t(r){r===void 0&&(r=10);var n=e.call(this)||this;if(n._logTickGenerator=function(i){var o=function(x,b,S){return[x,b,S].sort(function(C,P){return C-P})[1]},a=TS.Math.min(n._untransformedDomain,0),s=TS.Math.max(n._untransformedDomain,0),l=a,c=o(a,s,-n._pivot),u=o(a,s,n._pivot),h=s,f=n._logTicks(-c,-l).map(function(x){return-x}).reverse(),p=n._logTicks(u,h),d=Math.max(a,-n._pivot),g=Math.min(s,n._pivot),_=r4.scaleLinear().domain([d,g]).ticks(n._howManyTicks(d,g)),y=f.concat(_).concat(p);return y.length<=1&&(y=r4.scaleLinear().domain([a,s]).ticks(sot.ModifiedLog._DEFAULT_NUM_TICKS)),y},n._d3Scale=r4.scaleLinear(),n._base=r,n._pivot=n._base,n._setDomain(n._defaultExtent()),n.tickGenerator(n._logTickGenerator),r<=1)throw new Error("ModifiedLogScale: The base must be > 1");return n}return t.prototype._adjustedLog=function(r){var n=r<0?-1:1;return r*=n,r<this._pivot&&(r+=(this._pivot-r)/this._pivot),r=Math.log(r)/Math.log(this._base),r*=n,r},t.prototype._invertedAdjustedLog=function(r){var n=r<0?-1:1;return r*=n,r=Math.pow(this._base,r),r<this._pivot&&(r=this._pivot*(r-1)/(this._pivot-1)),r*=n,r},t.prototype.scale=function(r){return this._d3Scale(this._adjustedLog(r))},t.prototype.invert=function(r){return this._invertedAdjustedLog(this._d3Scale.invert(r))},t.prototype.scaleTransformation=function(r){return this.scale(r)},t.prototype.invertedTransformation=function(r){return this.invert(r)},t.prototype.getTransformationExtent=function(){return this._getUnboundedExtent(!0)},t.prototype.getTransformationDomain=function(){return this.domain()},t.prototype.setTransformationDomain=function(r){this.domain(r)},t.prototype._getDomain=function(){return this._untransformedDomain},t.prototype._setDomain=function(r){this._untransformedDomain=r;var n=[this._adjustedLog(r[0]),this._adjustedLog(r[1])];e.prototype._setDomain.call(this,n)},t.prototype._backingScaleDomain=function(r){return r==null?this._d3Scale.domain():(this._d3Scale.domain(r),this)},t.prototype._logTicks=function(r,n){var i=this,o=this._howManyTicks(r,n);if(o===0)return[];var a=Math.floor(Math.log(r)/Math.log(this._base)),s=Math.ceil(Math.log(n)/Math.log(this._base)),l=r4.range(s,a,-Math.ceil((s-a)/o)),c=r4.range(this._base,1,-(this._base-1)).map(Math.floor),u=TS.Array.uniq(c),h=l.map(function(g){return u.map(function(_){return Math.pow(i._base,g-1)*_})}),f=TS.Array.flatten(h),p=f.filter(function(g){return r<=g&&g<=n}),d=p.sort(function(g,_){return g-_});return d},t.prototype._howManyTicks=function(r,n){var i=this._adjustedLog(TS.Math.min(this._untransformedDomain,0)),o=this._adjustedLog(TS.Math.max(this._untransformedDomain,0)),a=this._adjustedLog(r),s=this._adjustedLog(n),l=(s-a)/(o-i),c=Math.ceil(l*sot.ModifiedLog._DEFAULT_NUM_TICKS);return c},t.prototype._niceDomain=function(r,n){return r},t.prototype._defaultExtent=function(){return[0,this._base]},t.prototype._expandSingleValueDomain=function(r){if(r[0]===r[1]){var n=r[0];return n>0?[n/this._base,n*this._base]:n===0?[-this._base,this._base]:[n*this._base,n/this._base]}return r},t.prototype._getRange=function(){return this._d3Scale.range()},t.prototype._setRange=function(r){this._d3Scale.range(r)},t.prototype.defaultTicks=function(){return this._d3Scale.ticks(sot.ModifiedLog._DEFAULT_NUM_TICKS)},t}(xFe.QuantitativeScale);lot.ModifiedLog=bFe});var c$t=H(cot=>{"use strict";Object.defineProperty(cot,"__esModule",{value:!0});var wFe=(de(),Ut(pe)),ga=(Er(),Ut(Mr)),kv=HF(),SFe=vd(),MFe=function(e){wFe.__extends(t,e);function t(){var r=e.call(this)||this;return r._d3Scale=ga.scaleTime(),r.autoDomain(),r}return t.prototype.tickInterval=function(r,n,i){n===void 0&&(n=1),i===void 0&&(i=!1);var o=ga.scaleTime(),a=t.timeIntervalToD3Time(r,i).every(n);return o.domain(this.domain()),o.range(this.range()),o.ticks(a)},t.prototype._setDomain=function(r){if(r[1]<r[0])throw new Error("Scale.Time domain values must be in chronological order");return e.prototype._setDomain.call(this,r)},t.prototype._defaultExtent=function(){return[new Date("1970-01-01"),new Date("1970-01-02")]},t.prototype._expandSingleValueDomain=function(r){var n=r[0].getTime(),i=r[1].getTime();if(n===i){var o=new Date(n);o.setDate(o.getDate()-1);var a=new Date(i);return a.setDate(a.getDate()+1),[o,a]}return r},t.prototype.scale=function(r){return this._d3Scale(r)},t.prototype.scaleTransformation=function(r){return this.scale(new Date(r))},t.prototype.invertedTransformation=function(r){return this.invert(r).getTime()},t.prototype.getTransformationExtent=function(){var r=this._getUnboundedExtent(!0);return[r[0].valueOf(),r[1].valueOf()]},t.prototype.getTransformationDomain=function(){var r=this.domain();return[r[0].valueOf(),r[1].valueOf()]},t.prototype.setTransformationDomain=function(r){var n=r[0],i=r[1];this.domain([new Date(n),new Date(i)])},t.prototype._getDomain=function(){return this._backingScaleDomain()},t.prototype._backingScaleDomain=function(r){return r==null?this._d3Scale.domain():(this._d3Scale.domain(r),this)},t.prototype._getRange=function(){return this._d3Scale.range()},t.prototype._setRange=function(r){this._d3Scale.range(r)},t.prototype.invert=function(r){return this._d3Scale.invert(r)},t.prototype.defaultTicks=function(){return this._d3Scale.ticks(t._DEFAULT_NUM_TICKS)},t.prototype._niceDomain=function(r){return this._d3Scale.copy().domain(r).nice().domain()},t.timeIntervalToD3Time=function(r,n){switch(r){case kv.TimeInterval.second:return n?ga.utcSecond:ga.timeSecond;case kv.TimeInterval.minute:return n?ga.utcMinute:ga.timeMinute;case kv.TimeInterval.hour:return n?ga.utcHour:ga.timeHour;case kv.TimeInterval.day:return n?ga.utcDay:ga.timeDay;case kv.TimeInterval.week:return n?ga.utcWeek:ga.timeWeek;case kv.TimeInterval.month:return n?ga.utcMonth:ga.timeMonth;case kv.TimeInterval.year:return n?ga.utcYear:ga.timeYear;default:throw Error("TimeInterval specified does not exist: "+r)}},t}(SFe.QuantitativeScale);cot.Time=MFe});var ks=H(Hu=>{"use strict";Object.defineProperty(Hu,"__esModule",{value:!0});var Rv=(de(),Ut(pe)),EFe=ZXt();Hu.TickGenerators=EFe;Rv.__exportStar(eot(),Hu);Rv.__exportStar(n$t(),Hu);Rv.__exportStar(o$t(),Hu);Rv.__exportStar(a$t(),Hu);Rv.__exportStar(s$t(),Hu);Rv.__exportStar(l$t(),Hu);Rv.__exportStar(c$t(),Hu);var TFe=eot(),CFe=vd();function AFe(e){return e instanceof CFe.QuantitativeScale||e instanceof TFe.Category}Hu.isTransformable=AFe});var HF=H(Se=>{"use strict";Object.defineProperty(Se,"__esModule",{value:!0});var PFe=(de(),Ut(pe)),Vu=(Er(),Ut(Mr)),u$t=_l(),h$t=Bu(),IFe=ks(),n4=Fe(),uot=If(),ts=t4();Se.TimeInterval=uot.makeEnum(["second","minute","hour","day","week","month","year"]);Se.TimeAxisOrientation=uot.makeEnum(["top","bottom"]);Se.TierLabelPosition=uot.makeEnum(["between","center"]);var LFe=function(e){PFe.__extends(t,e);function t(r,n,i){var o=e.call(this,r,n)||this;return o._maxTimeIntervalPrecision=null,o._tierLabelPositions=[],o._useUTC=i,o.addClass("time-axis"),o.tickLabelPadding(5),o.axisConfigurations(t._DEFAULT_TIME_AXIS_CONFIGURATIONS(o._useUTC)),o.annotationFormatter(h$t.time("%a %b %d, %Y",o._useUTC)),o}return t.prototype.tierLabelPositions=function(r){if(r==null)return this._tierLabelPositions;if(!r.every(function(n){return n.toLowerCase()==="between"||n.toLowerCase()==="center"}))throw new Error("Unsupported position for tier labels");return this._tierLabelPositions=r,this.redraw(),this},t.prototype.maxTimeIntervalPrecision=function(r){return r==null?this._maxTimeIntervalPrecision:(this._maxTimeIntervalPrecision=r,this.redraw(),this)},t.prototype.currentAxisConfiguration=function(){return this._possibleTimeAxisConfigurations[this._mostPreciseConfigIndex]},t.prototype.axisConfigurations=function(r){if(r==null)return this._possibleTimeAxisConfigurations;this._possibleTimeAxisConfigurations=r,this._numTiers=n4.Math.max(this._possibleTimeAxisConfigurations.map(function(a){return a.length}),0),this._isAnchored&&this._setupDomElements();for(var n=this.tierLabelPositions(),i=[],o=0;o<this._numTiers;o++)i.push(n[o]||"between");return this.tierLabelPositions(i),this.redraw(),this},t.prototype._getMostPreciseConfigurationIndex=function(){var r=this,n=this._possibleTimeAxisConfigurations.length;return this._possibleTimeAxisConfigurations.forEach(function(i,o){o<n&&i.every(function(a){return r._checkTimeAxisTierConfiguration(a)})&&(n=o)}),n===this._possibleTimeAxisConfigurations.length&&(n4.Window.warn("zoomed out too far: could not find suitable interval to display labels"),--n),n},t.prototype.orientation=function(r){if(r&&(r.toLowerCase()==="right"||r.toLowerCase()==="left"))throw new Error(r+" is not a supported orientation for TimeAxis - only horizontal orientations are supported");return e.prototype.orientation.call(this,r)},t.prototype._computeHeight=function(){var r=this._measurer.measure().height;this._tierHeights=[];for(var n=0;n<this._numTiers;n++)this._tierHeights.push(r+this.tickLabelPadding()+(this._tierLabelPositions[n]==="between"?0:this._maxLabelTickLength()));return Vu.sum(this._tierHeights)},t.prototype._getIntervalLength=function(r){var n=this._scale.domain()[0],i=IFe.Time.timeIntervalToD3Time(r.interval,this._useUTC),o=i.offset(n,r.step);if(o>this._scale.domain()[1])return this.width();var a=Math.abs(this._scale.scale(o)-this._scale.scale(n));return a},t.prototype._maxWidthForInterval=function(r){return this._measurer.measure(r.formatter(t._LONG_DATE)).width},t.prototype._checkTimeAxisTierConfiguration=function(r){if(this._maxTimeIntervalPrecision!=null){var n=t._SORTED_TIME_INTERVAL_INDEX[this._maxTimeIntervalPrecision],i=t._SORTED_TIME_INTERVAL_INDEX[r.interval];if(n!=null&&i!=null&&i<n)return!1}var o=this._maxWidthForInterval(r)+2*this.tickLabelPadding();return Math.min(this._getIntervalLength(r),this.width())>=o},t.prototype._sizeFromOffer=function(r,n){var i=e.prototype._sizeFromOffer.call(this,r,n),o=this._tierHeights.reduce(function(s,l,c,u){return s+l>i.height?s:s+l}),a=this.margin()+(this.annotationsEnabled()?this.annotationTierCount()*this._annotationTierHeight():0);return i.height=Math.min(i.height,o+a),i},t.prototype._setup=function(){e.prototype._setup.call(this),this._setupDomElements()},t.prototype._setupDomElements=function(){this.content().selectAll("."+t.TIME_AXIS_TIER_CLASS).remove(),this._tierLabelContainers=[],this._tierMarkContainers=[],this._tierBaselines=[],this._tickLabelContainer.remove(),this._baseline.remove();for(var r=0;r<this._numTiers;++r){var n=this.content().append("g").classed(t.TIME_AXIS_TIER_CLASS,!0);this._tierLabelContainers.push(n.append("g").classed(ts.Axis.TICK_LABEL_CLASS+"-container",!0)),this._tierMarkContainers.push(n.append("g").classed(ts.Axis.TICK_MARK_CLASS+"-container",!0)),this._tierBaselines.push(n.append("line").classed("baseline",!0))}var i=new u$t.SvgContext(this._tierLabelContainers[0].node());this._measurer=new u$t.CacheMeasurer(i)},t.prototype._getTickIntervalValues=function(r){return this._scale.tickInterval(r.interval,r.step,this._useUTC)},t.prototype._getTickValues=function(){var r=this;return this._possibleTimeAxisConfigurations[this._mostPreciseConfigIndex].reduce(function(n,i){return n.concat(r._getTickIntervalValues(i))},[])},t.prototype._cleanTiers=function(){for(var r=0;r<this._tierLabelContainers.length;r++)this._tierLabelContainers[r].selectAll("."+ts.Axis.TICK_LABEL_CLASS).remove(),this._tierMarkContainers[r].selectAll("."+ts.Axis.TICK_MARK_CLASS).remove(),this._tierBaselines[r].style("visibility","hidden")},t.prototype._getTickValuesForConfiguration=function(r){var n=this._scale.tickInterval(r.interval,r.step,this._useUTC),i=this._scale.domain(),o=n.map(function(a){return a.valueOf()});return o.indexOf(i[0].valueOf())===-1&&n.unshift(i[0]),o.indexOf(i[1].valueOf())===-1&&n.push(i[1]),n},t.prototype._renderTierLabels=function(r,n,i){var o=this,a=this._getTickValuesForConfiguration(n),s=[];this._tierLabelPositions[i]==="between"&&n.step===1?a.map(function(g,_){_+1>=a.length||s.push(new Date((a[_+1].valueOf()-a[_].valueOf())/2+a[_].valueOf()))}):s=a;var l=r.selectAll("."+ts.Axis.TICK_LABEL_CLASS).data(s,function(g){return String(g.valueOf())}),c=l.enter().append("g").classed(ts.Axis.TICK_LABEL_CLASS,!0);c.append("text");var u=this._tierLabelPositions[i]==="center"||n.step===1?0:this.tickLabelPadding(),h;this.orientation()==="bottom"?h=Vu.sum(this._tierHeights.slice(0,i+1))-this.tickLabelPadding():this._tierLabelPositions[i]==="center"?h=this.height()-Vu.sum(this._tierHeights.slice(0,i))-this.tickLabelPadding()-this._maxLabelTickLength():h=this.height()-Vu.sum(this._tierHeights.slice(0,i))-this.tickLabelPadding();var f=l.merge(c),p=f.selectAll("text");p.size()>0&&p.attr("transform","translate("+u+","+h+")"),l.exit().remove(),f.attr("transform",function(g){return"translate("+o._scale.scale(g)+",0)"});var d=this._tierLabelPositions[i]==="center"||n.step===1?"middle":"start";f.selectAll("text").text(n.formatter).style("text-anchor",d)},t.prototype._renderTickMarks=function(r,n){var i=this._tierMarkContainers[n].selectAll("."+ts.Axis.TICK_MARK_CLASS).data(r),o=i.enter().append("line").classed(ts.Axis.TICK_MARK_CLASS,!0).merge(i),a=this._generateTickMarkAttrHash(),s=this._tierHeights.slice(0,n).reduce(function(l,c){return l+c},0);this.orientation()==="bottom"?(a.y1=s,a.y2=s+(this._tierLabelPositions[n]==="center"?this.innerTickLength():this._tierHeights[n])):(a.y1=this.height()-s,a.y2=this.height()-(s+(this._tierLabelPositions[n]==="center"?this.innerTickLength():this._tierHeights[n]))),o.attrs(a),this.orientation()==="bottom"?(a.y1=s,a.y2=s+(this._tierLabelPositions[n]==="center"?this.endTickLength():this._tierHeights[n])):(a.y1=this.height()-s,a.y2=this.height()-(s+(this._tierLabelPositions[n]==="center"?this.endTickLength():this._tierHeights[n]))),Vu.select(o.nodes()[0]).attrs(a),Vu.select(o.nodes()[o.size()-1]).attrs(a),Vu.select(o.nodes()[0]).classed(ts.Axis.END_TICK_MARK_CLASS,!0),Vu.select(o.nodes()[o.size()-1]).classed(ts.Axis.END_TICK_MARK_CLASS,!0),i.exit().remove()},t.prototype._renderLabellessTickMarks=function(r){var n=this._tickMarkContainer.selectAll("."+ts.Axis.TICK_MARK_CLASS).data(r),i=n.enter().append("line").classed(ts.Axis.TICK_MARK_CLASS,!0).merge(n),o=this._generateTickMarkAttrHash();o.y2=this.orientation()==="bottom"?this.tickLabelPadding():this.height()-this.tickLabelPadding(),i.attrs(o),n.exit().remove()},t.prototype._generateLabellessTicks=function(){return this._mostPreciseConfigIndex<1?[]:this._getTickIntervalValues(this._possibleTimeAxisConfigurations[this._mostPreciseConfigIndex-1][0])},t.prototype.renderImmediately=function(){var r=this;this._mostPreciseConfigIndex=this._getMostPreciseConfigurationIndex();var n=this._possibleTimeAxisConfigurations[this._mostPreciseConfigIndex];this._cleanTiers(),n.forEach(function(h,f){return r._renderTierLabels(r._tierLabelContainers[f],h,f)});for(var i=n.map(function(h,f){return r._getTickValuesForConfiguration(h)}),o=0,a=0;a<Math.max(n.length,1);++a){var s=this._generateBaselineAttrHash();s.y1+=this.orientation()==="bottom"?o:-o,s.y2=s.y1,this._tierBaselines[a].attrs(s).style("visibility","inherit"),o+=this._tierHeights[a]}var l=[],c=this._scale.domain(),u=this._scale.scale(c[1])-this._scale.scale(c[0]);this._getIntervalLength(n[0])*1.5>=u&&(l=this._generateLabellessTicks()),this._renderLabellessTickMarks(l),this._hideOverflowingTiers();for(var a=0;a<n.length;++a)this._renderTickMarks(i[a],a),this._hideOverlappingAndCutOffLabels(a);return this.annotationsEnabled()?this._drawAnnotations():this._removeAnnotations(),this},t.prototype._hideOverflowingTiers=function(){var r=this,n=this.height(),i=0;this.content().selectAll("."+t.TIME_AXIS_TIER_CLASS).attr("visibility",function(o,a){return i+=r._tierHeights[a],i<=n?"inherit":"hidden"})},t.prototype._hideOverlappingAndCutOffLabels=function(r){var n=this,i=this.element().node().getBoundingClientRect(),o=function(u){return Math.floor(i.left)<=Math.ceil(u.left)&&Math.floor(i.top)<=Math.ceil(u.top)&&Math.floor(u.right)<=Math.ceil(i.left+n.width())&&Math.floor(u.bottom)<=Math.ceil(i.top+n.height())},a=this._tierMarkContainers[r].selectAll("."+ts.Axis.TICK_MARK_CLASS).filter(function(u,h){var f=Vu.select(this).style("visibility");return f==="visible"||f==="inherit"}),s=a.nodes().map(function(u){return u.getBoundingClientRect()}),l=this._tierLabelContainers[r].selectAll("."+ts.Axis.TICK_LABEL_CLASS).filter(function(u,h){var f=Vu.select(this).style("visibility");return f==="visible"||f==="inherit"}),c;l.each(function(u,h){var f=this.getBoundingClientRect(),p=Vu.select(this),d=s[h],g=s[h+1],_=c!=null&&n4.DOM.clientRectsOverlap(f,c),y=d!=null&&n4.DOM.clientRectsOverlap(f,d),x=g!=null&&n4.DOM.clientRectsOverlap(f,g);!o(f)||_||y||x?p.style("visibility","hidden"):(c=f,p.style("visibility","inherit"))})},t.prototype.invalidateCache=function(){e.prototype.invalidateCache.call(this),this._measurer.reset()},t.TIME_AXIS_TIER_CLASS="time-axis-tier",t._SORTED_TIME_INTERVAL_INDEX=(xd={},xd[Se.TimeInterval.second]=0,xd[Se.TimeInterval.minute]=1,xd[Se.TimeInterval.hour]=2,xd[Se.TimeInterval.day]=3,xd[Se.TimeInterval.week]=4,xd[Se.TimeInterval.month]=5,xd[Se.TimeInterval.year]=6,xd),t._DEFAULT_TIME_AXIS_CONFIGURATIONS=function(r){var n=function(i){return h$t.time(i,r)};return[[{interval:Se.TimeInterval.second,step:1,formatter:n("%I:%M:%S %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.second,step:5,formatter:n("%I:%M:%S %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.second,step:10,formatter:n("%I:%M:%S %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.second,step:15,formatter:n("%I:%M:%S %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.second,step:30,formatter:n("%I:%M:%S %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.minute,step:1,formatter:n("%I:%M %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.minute,step:5,formatter:n("%I:%M %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.minute,step:10,formatter:n("%I:%M %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.minute,step:15,formatter:n("%I:%M %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.minute,step:30,formatter:n("%I:%M %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.hour,step:1,formatter:n("%I %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.hour,step:3,formatter:n("%I %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.hour,step:6,formatter:n("%I %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.hour,step:12,formatter:n("%I %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.day,step:1,formatter:n("%a %e")},{interval:Se.TimeInterval.month,step:1,formatter:n("%B %Y")}],[{interval:Se.TimeInterval.day,step:1,formatter:n("%e")},{interval:Se.TimeInterval.month,step:1,formatter:n("%B %Y")}],[{interval:Se.TimeInterval.month,step:1,formatter:n("%B")},{interval:Se.TimeInterval.year,step:1,formatter:n("%Y")}],[{interval:Se.TimeInterval.month,step:1,formatter:n("%b")},{interval:Se.TimeInterval.year,step:1,formatter:n("%Y")}],[{interval:Se.TimeInterval.month,step:3,formatter:n("%b")},{interval:Se.TimeInterval.year,step:1,formatter:n("%Y")}],[{interval:Se.TimeInterval.month,step:6,formatter:n("%b")},{interval:Se.TimeInterval.year,step:1,formatter:n("%Y")}],[{interval:Se.TimeInterval.year,step:1,formatter:n("%Y")}],[{interval:Se.TimeInterval.year,step:1,formatter:n("%y")}],[{interval:Se.TimeInterval.year,step:5,formatter:n("%Y")}],[{interval:Se.TimeInterval.year,step:25,formatter:n("%Y")}],[{interval:Se.TimeInterval.year,step:50,formatter:n("%Y")}],[{interval:Se.TimeInterval.year,step:100,formatter:n("%Y")}],[{interval:Se.TimeInterval.year,step:200,formatter:n("%Y")}],[{interval:Se.TimeInterval.year,step:500,formatter:n("%Y")}],[{interval:Se.TimeInterval.year,step:1e3,formatter:n("%Y")}]]},t._LONG_DATE=new Date(9999,8,29,12,59,9999),t}(ts.Axis);Se.Time=LFe;var xd});var f$t=H(i4=>{"use strict";Object.defineProperty(i4,"__esModule",{value:!0});var hot=(de(),Ut(pe));hot.__exportStar($Xt(),i4);hot.__exportStar(KXt(),i4);hot.__exportStar(HF(),i4)});var o4=H(fot=>{"use strict";Object.defineProperty(fot,"__esModule",{value:!0});var kFe=Fe(),RFe=function(){function e(){this._eventToProcessingFunction={},this._eventTarget=document,this._eventNameToCallbackSet={},this._connected=!1}return e.prototype._hasNoCallbacks=function(){for(var t=Object.keys(this._eventNameToCallbackSet),r=0;r<t.length;r++)if(this._eventNameToCallbackSet[t[r]].size!==0)return!1;return!0},e.prototype._connect=function(){var t=this;this._connected||(Object.keys(this._eventToProcessingFunction).forEach(function(r){var n=t._eventToProcessingFunction[r],i=r==="wheel"?{passive:!1}:void 0;t._eventTarget.addEventListener(r,n,i)}),this._connected=!0)},e.prototype._disconnect=function(){var t=this;this._connected&&this._hasNoCallbacks()&&(Object.keys(this._eventToProcessingFunction).forEach(function(r){var n=t._eventToProcessingFunction[r];t._eventTarget.removeEventListener(r,n)}),this._connected=!1)},e.prototype._addCallbackForEvent=function(t,r){this._eventNameToCallbackSet[t]==null&&(this._eventNameToCallbackSet[t]=new kFe.CallbackSet),this._eventNameToCallbackSet[t].add(r),this._connect()},e.prototype._removeCallbackForEvent=function(t,r){this._eventNameToCallbackSet[t]!=null&&this._eventNameToCallbackSet[t].delete(r),this._disconnect()},e.prototype._callCallbacksForEvent=function(t){for(var r=[],n=1;n<arguments.length;n++)r[n-1]=arguments[n];var i=this._eventNameToCallbackSet[t];i!=null&&i.callCallbacks.apply(i,r)},e}();fot.Dispatcher=RFe});var p$t=H(pot=>{"use strict";Object.defineProperty(pot,"__esModule",{value:!0});var NFe=(de(),Ut(pe)),DFe=o4(),OFe=function(e){NFe.__extends(t,e);function t(){var r=e.call(this)||this;return r._eventToProcessingFunction[t._KEYDOWN_EVENT_NAME]=function(n){return r._processKeydown(n)},r._eventToProcessingFunction[t._KEYUP_EVENT_NAME]=function(n){return r._processKeyup(n)},r}return t.getDispatcher=function(){var r=document[t._DISPATCHER_KEY];return r==null&&(r=new t,document[t._DISPATCHER_KEY]=r),r},t.prototype._processKeydown=function(r){this._callCallbacksForEvent(t._KEYDOWN_EVENT_NAME,r.keyCode,r)},t.prototype._processKeyup=function(r){this._callCallbacksForEvent(t._KEYUP_EVENT_NAME,r.keyCode,r)},t.prototype.onKeyDown=function(r){return this._addCallbackForEvent(t._KEYDOWN_EVENT_NAME,r),this},t.prototype.offKeyDown=function(r){return this._removeCallbackForEvent(t._KEYDOWN_EVENT_NAME,r),this},t.prototype.onKeyUp=function(r){return this._addCallbackForEvent(t._KEYUP_EVENT_NAME,r),this},t.prototype.offKeyUp=function(r){return this._removeCallbackForEvent(t._KEYUP_EVENT_NAME,r),this},t._DISPATCHER_KEY="__Plottable_Dispatcher_Key",t._KEYDOWN_EVENT_NAME="keydown",t._KEYUP_EVENT_NAME="keyup",t}(DFe.Dispatcher);pot.Key=OFe});var m$t=H(dot=>{"use strict";Object.defineProperty(dot,"__esModule",{value:!0});var zFe=(de(),Ut(pe)),d$t=Fe(),FFe=o4(),BFe=function(e){zFe.__extends(t,e);function t(r){var n=e.call(this)||this;n._lastMousePosition={x:-1,y:-1},n._translator=d$t.getTranslator(r);var i=function(o){return n._measureAndDispatch(r,o,t._MOUSEMOVE_EVENT_NAME,"page")};return n._eventToProcessingFunction[t._MOUSEOVER_EVENT_NAME]=i,n._eventToProcessingFunction[t._MOUSEMOVE_EVENT_NAME]=i,n._eventToProcessingFunction[t._MOUSEOUT_EVENT_NAME]=i,n._eventToProcessingFunction[t._MOUSEDOWN_EVENT_NAME]=function(o){return n._measureAndDispatch(r,o,t._MOUSEDOWN_EVENT_NAME)},n._eventToProcessingFunction[t._MOUSEUP_EVENT_NAME]=function(o){return n._measureAndDispatch(r,o,t._MOUSEUP_EVENT_NAME,"page")},n._eventToProcessingFunction[t._WHEEL_EVENT_NAME]=function(o){return n._measureAndDispatch(r,o,t._WHEEL_EVENT_NAME)},n._eventToProcessingFunction[t._DBLCLICK_EVENT_NAME]=function(o){return n._measureAndDispatch(r,o,t._DBLCLICK_EVENT_NAME)},n}return t.getDispatcher=function(r){var n=r.root().rootElement(),i=n[t._DISPATCHER_KEY];return i==null&&(i=new t(r),n[t._DISPATCHER_KEY]=i),i},t.prototype.onMouseMove=function(r){return this._addCallbackForEvent(t._MOUSEMOVE_EVENT_NAME,r),this},t.prototype.offMouseMove=function(r){return this._removeCallbackForEvent(t._MOUSEMOVE_EVENT_NAME,r),this},t.prototype.onMouseDown=function(r){return this._addCallbackForEvent(t._MOUSEDOWN_EVENT_NAME,r),this},t.prototype.offMouseDown=function(r){return this._removeCallbackForEvent(t._MOUSEDOWN_EVENT_NAME,r),this},t.prototype.onMouseUp=function(r){return this._addCallbackForEvent(t._MOUSEUP_EVENT_NAME,r),this},t.prototype.offMouseUp=function(r){return this._removeCallbackForEvent(t._MOUSEUP_EVENT_NAME,r),this},t.prototype.onWheel=function(r){return this._addCallbackForEvent(t._WHEEL_EVENT_NAME,r),this},t.prototype.offWheel=function(r){return this._removeCallbackForEvent(t._WHEEL_EVENT_NAME,r),this},t.prototype.onDblClick=function(r){return this._addCallbackForEvent(t._DBLCLICK_EVENT_NAME,r),this},t.prototype.offDblClick=function(r){return this._removeCallbackForEvent(t._DBLCLICK_EVENT_NAME,r),this},t.prototype._measureAndDispatch=function(r,n,i,o){if(o===void 0&&(o="element"),o!=="page"&&o!=="element")throw new Error("Invalid scope '"+o+"', must be 'element' or 'page'");if(o==="page"||this.eventInside(r,n)){var a=this._translator.computePosition(n.clientX,n.clientY);this._lastMousePosition=a,this._callCallbacksForEvent(i,this.lastMousePosition(),n)}},t.prototype.eventInside=function(r,n){return d$t.Translator.isEventInside(r,n)},t.prototype.lastMousePosition=function(){return this._lastMousePosition},t._DISPATCHER_KEY="__Plottable_Dispatcher_Mouse",t._MOUSEOVER_EVENT_NAME="mouseover",t._MOUSEMOVE_EVENT_NAME="mousemove",t._MOUSEOUT_EVENT_NAME="mouseout",t._MOUSEDOWN_EVENT_NAME="mousedown",t._MOUSEUP_EVENT_NAME="mouseup",t._WHEEL_EVENT_NAME="wheel",t._DBLCLICK_EVENT_NAME="dblclick",t}(FFe.Dispatcher);dot.Mouse=BFe});var _$t=H(mot=>{"use strict";Object.defineProperty(mot,"__esModule",{value:!0});var HFe=(de(),Ut(pe)),g$t=Fe(),VFe=o4(),UFe=function(e){HFe.__extends(t,e);function t(r){var n=e.call(this)||this;return n._translator=g$t.getTranslator(r),n._eventToProcessingFunction[t._TOUCHSTART_EVENT_NAME]=function(i){return n._measureAndDispatch(r,i,t._TOUCHSTART_EVENT_NAME,"page")},n._eventToProcessingFunction[t._TOUCHMOVE_EVENT_NAME]=function(i){return n._measureAndDispatch(r,i,t._TOUCHMOVE_EVENT_NAME,"page")},n._eventToProcessingFunction[t._TOUCHEND_EVENT_NAME]=function(i){return n._measureAndDispatch(r,i,t._TOUCHEND_EVENT_NAME,"page")},n._eventToProcessingFunction[t._TOUCHCANCEL_EVENT_NAME]=function(i){return n._measureAndDispatch(r,i,t._TOUCHCANCEL_EVENT_NAME,"page")},n}return t.getDispatcher=function(r){var n=r.root().rootElement(),i=n[t._DISPATCHER_KEY];return i==null&&(i=new t(r),n[t._DISPATCHER_KEY]=i),i},t.prototype.onTouchStart=function(r){return this._addCallbackForEvent(t._TOUCHSTART_EVENT_NAME,r),this},t.prototype.offTouchStart=function(r){return this._removeCallbackForEvent(t._TOUCHSTART_EVENT_NAME,r),this},t.prototype.onTouchMove=function(r){return this._addCallbackForEvent(t._TOUCHMOVE_EVENT_NAME,r),this},t.prototype.offTouchMove=function(r){return this._removeCallbackForEvent(t._TOUCHMOVE_EVENT_NAME,r),this},t.prototype.onTouchEnd=function(r){return this._addCallbackForEvent(t._TOUCHEND_EVENT_NAME,r),this},t.prototype.offTouchEnd=function(r){return this._removeCallbackForEvent(t._TOUCHEND_EVENT_NAME,r),this},t.prototype.onTouchCancel=function(r){return this._addCallbackForEvent(t._TOUCHCANCEL_EVENT_NAME,r),this},t.prototype.offTouchCancel=function(r){return this._removeCallbackForEvent(t._TOUCHCANCEL_EVENT_NAME,r),this},t.prototype._measureAndDispatch=function(r,n,i,o){if(o===void 0&&(o="element"),o!=="page"&&o!=="element")throw new Error("Invalid scope '"+o+"', must be 'element' or 'page'");if(!(o==="element"&&!this.eventInside(r,n))){for(var a=n.changedTouches,s={},l=[],c=0;c<a.length;c++){var u=a[c],h=u.identifier,f=this._translator.computePosition(u.clientX,u.clientY);f!=null&&(s[h]=f,l.push(h))}l.length>0&&this._callCallbacksForEvent(i,l,s,n)}},t.prototype.eventInside=function(r,n){return g$t.Translator.isEventInside(r,n)},t._DISPATCHER_KEY="__Plottable_Dispatcher_Touch",t._TOUCHSTART_EVENT_NAME="touchstart",t._TOUCHMOVE_EVENT_NAME="touchmove",t._TOUCHEND_EVENT_NAME="touchend",t._TOUCHCANCEL_EVENT_NAME="touchcancel",t}(VFe.Dispatcher);mot.Touch=UFe});var Nv=H(a4=>{"use strict";Object.defineProperty(a4,"__esModule",{value:!0});var got=(de(),Ut(pe));got.__exportStar(p$t(),a4);got.__exportStar(m$t(),a4);got.__exportStar(_$t(),a4)});var Dv=H(_ot=>{"use strict";Object.defineProperty(_ot,"__esModule",{value:!0});var qFe=function(){function e(){var t=this;this._anchorCallback=function(r){return t._anchor(r)},this._enabled=!0}return e.prototype.attachTo=function(t){return this._disconnect(),this._componentAttachedTo=t,this._connect(),this},e.prototype.detachFrom=function(t){return this.detach()},e.prototype.detach=function(){return this._disconnect(),this._componentAttachedTo=null,this},e.prototype.enabled=function(t){return t==null?this._enabled:(this._enabled=t,this._enabled?this._connect():this._disconnect(),this)},e.prototype._anchor=function(t){this._isAnchored=!0},e.prototype._unanchor=function(){this._isAnchored=!1},e.prototype._translateToComponentSpace=function(t){var r=this._componentAttachedTo.originToRoot();return{x:t.x-r.x,y:t.y-r.y}},e.prototype._isInsideComponent=function(t){return 0<=t.x&&0<=t.y&&t.x<=this._componentAttachedTo.width()&&t.y<=this._componentAttachedTo.height()},e.prototype._connect=function(){this.enabled()&&this._componentAttachedTo!=null&&!this._isAnchored&&this._componentAttachedTo.onAnchor(this._anchorCallback)},e.prototype._disconnect=function(){this._isAnchored&&this._unanchor(),this._componentAttachedTo!=null&&this._componentAttachedTo.offAnchor(this._anchorCallback)},e}();_ot.Interaction=qFe});var x$t=H(yot=>{"use strict";Object.defineProperty(yot,"__esModule",{value:!0});var GFe=(de(),Ut(pe)),y$t=Nv(),v$t=Fe(),WFe=Dv(),YFe=function(e){GFe.__extends(t,e);function t(){var r=e!==null&&e.apply(this,arguments)||this;return r._clickedDown=!1,r._doubleClicking=!1,r._onClickCallbacks=new v$t.CallbackSet,r._onDoubleClickCallbacks=new v$t.CallbackSet,r._mouseDownCallback=function(n,i){return r._handleClickDown(n,i)},r._mouseUpCallback=function(n,i){return r._handleClickUp(n,i)},r._dblClickCallback=function(n,i){return r._handleDblClick(n,i)},r._touchStartCallback=function(n,i,o){return r._handleClickDown(i[n[0]],o)},r._touchEndCallback=function(n,i,o){return r._handleClickUp(i[n[0]],o)},r._touchCancelCallback=function(n,i){return r._clickedDown=!1},r}return t.prototype._anchor=function(r){e.prototype._anchor.call(this,r),this._mouseDispatcher=y$t.Mouse.getDispatcher(r),this._mouseDispatcher.onMouseDown(this._mouseDownCallback),this._mouseDispatcher.onMouseUp(this._mouseUpCallback),this._mouseDispatcher.onDblClick(this._dblClickCallback),this._touchDispatcher=y$t.Touch.getDispatcher(r),this._touchDispatcher.onTouchStart(this._touchStartCallback),this._touchDispatcher.onTouchEnd(this._touchEndCallback),this._touchDispatcher.onTouchCancel(this._touchCancelCallback)},t.prototype._unanchor=function(){e.prototype._unanchor.call(this),this._mouseDispatcher.offMouseDown(this._mouseDownCallback),this._mouseDispatcher.offMouseUp(this._mouseUpCallback),this._mouseDispatcher.offDblClick(this._dblClickCallback),this._mouseDispatcher=null,this._touchDispatcher.offTouchStart(this._touchStartCallback),this._touchDispatcher.offTouchEnd(this._touchEndCallback),this._touchDispatcher.offTouchCancel(this._touchCancelCallback),this._touchDispatcher=null},t.prototype._handleClickDown=function(r,n){var i=this._translateToComponentSpace(r);this._isInsideComponent(i)&&(this._clickedDown=!0,this._clickedPoint=i)},t.prototype._handleClickUp=function(r,n){var i=this,o=this._translateToComponentSpace(r);this._clickedDown&&t._pointsEqual(o,this._clickedPoint)&&setTimeout(function(){i._doubleClicking||i._onClickCallbacks.callCallbacks(o,n)},0),this._clickedDown=!1},t.prototype._handleDblClick=function(r,n){var i=this,o=this._translateToComponentSpace(r);this._doubleClicking=!0,this._onDoubleClickCallbacks.callCallbacks(o,n),setTimeout(function(){return i._doubleClicking=!1},0)},t._pointsEqual=function(r,n){return r.x===n.x&&r.y===n.y},t.prototype.onClick=function(r){return this._onClickCallbacks.add(r),this},t.prototype.offClick=function(r){return this._onClickCallbacks.delete(r),this},t.prototype.onDoubleClick=function(r){return this._onDoubleClickCallbacks.add(r),this},t.prototype.offDoubleClick=function(r){return this._onDoubleClickCallbacks.delete(r),this},t}(WFe.Interaction);yot.Click=YFe});var w$t=H(vot=>{"use strict";Object.defineProperty(vot,"__esModule",{value:!0});var jFe=(de(),Ut(pe)),b$t=Nv(),s4=Fe(),XFe=Dv(),$Fe=function(e){jFe.__extends(t,e);function t(r){var n=e.call(this)||this;return n._dragging=!1,n._constrainedToComponent=!0,n._mouseFilter=t._DEFAULT_MOUSE_FILTER,n._dragStartCallbacks=new s4.CallbackSet,n._dragCallbacks=new s4.CallbackSet,n._dragEndCallbacks=new s4.CallbackSet,n._mouseDownCallback=function(i,o){return n._startDrag(i,o)},n._mouseMoveCallback=function(i,o){return n._doDrag(i,o)},n._mouseUpCallback=function(i,o){return n._endDrag(i,o)},n._touchStartCallback=function(i,o,a){return n._startDrag(o[i[0]],a)},n._touchMoveCallback=function(i,o,a){return n._doDrag(o[i[0]],a)},n._touchEndCallback=function(i,o,a){return n._endDrag(o[i[0]],a)},n._mouseButton=r!==void 0?r:0,n}return t.prototype._anchor=function(r){e.prototype._anchor.call(this,r),this._mouseDispatcher=b$t.Mouse.getDispatcher(this._componentAttachedTo),this._mouseDispatcher.onMouseDown(this._mouseDownCallback),this._mouseDispatcher.onMouseMove(this._mouseMoveCallback),this._mouseDispatcher.onMouseUp(this._mouseUpCallback),this._touchDispatcher=b$t.Touch.getDispatcher(this._componentAttachedTo),this._touchDispatcher.onTouchStart(this._touchStartCallback),this._touchDispatcher.onTouchMove(this._touchMoveCallback),this._touchDispatcher.onTouchEnd(this._touchEndCallback)},t.prototype._unanchor=function(){e.prototype._unanchor.call(this),this._mouseDispatcher.offMouseDown(this._mouseDownCallback),this._mouseDispatcher.offMouseMove(this._mouseMoveCallback),this._mouseDispatcher.offMouseUp(this._mouseUpCallback),this._mouseDispatcher=null,this._touchDispatcher.offTouchStart(this._touchStartCallback),this._touchDispatcher.offTouchMove(this._touchMoveCallback),this._touchDispatcher.offTouchEnd(this._touchEndCallback),this._touchDispatcher=null},t.prototype._translateAndConstrain=function(r){var n=this._translateToComponentSpace(r);return this._constrainedToComponent?{x:s4.Math.clamp(n.x,0,this._componentAttachedTo.width()),y:s4.Math.clamp(n.y,0,this._componentAttachedTo.height())}:n},t.prototype._startDrag=function(r,n){if(!(n instanceof MouseEvent&&!this._mouseFilter(n))){var i=this._translateToComponentSpace(r);this._isInsideComponent(i)&&(n.preventDefault(),this._dragging=!0,this._dragOrigin=i,this._dragStartCallbacks.callCallbacks(this._dragOrigin))}},t.prototype._doDrag=function(r,n){this._dragging&&this._dragCallbacks.callCallbacks(this._dragOrigin,this._translateAndConstrain(r))},t.prototype._endDrag=function(r,n){n instanceof MouseEvent&&n.button!==this._mouseButton||this._dragging&&(this._dragging=!1,this._dragEndCallbacks.callCallbacks(this._dragOrigin,this._translateAndConstrain(r)))},t.prototype.constrainedToComponent=function(r){return r==null?this._constrainedToComponent:(this._constrainedToComponent=r,this)},t.prototype.mouseFilter=function(r){return arguments.length===0?this._mouseFilter:(this._mouseFilter=r,this)},t.prototype.onDragStart=function(r){return this._dragStartCallbacks.add(r),this},t.prototype.offDragStart=function(r){return this._dragStartCallbacks.delete(r),this},t.prototype.onDrag=function(r){return this._dragCallbacks.add(r),this},t.prototype.offDrag=function(r){return this._dragCallbacks.delete(r),this},t.prototype.onDragEnd=function(r){return this._dragEndCallbacks.add(r),this},t.prototype.offDragEnd=function(r){return this._dragEndCallbacks.delete(r),this},t._DEFAULT_MOUSE_FILTER=function(r){return r.button===0},t}(XFe.Interaction);vot.Drag=$Fe});var wot=H(bot=>{"use strict";Object.defineProperty(bot,"__esModule",{value:!0});var KFe=(de(),Ut(pe)),S$t=Nv(),xot=Fe(),ZFe=Dv(),JFe=function(e){KFe.__extends(t,e);function t(){var r=e!==null&&e.apply(this,arguments)||this;return r._keyPressCallbacks={},r._keyReleaseCallbacks={},r._mouseMoveCallback=function(n){return!1},r._downedKeys=new xot.Set,r._keyDownCallback=function(n,i){return r._handleKeyDownEvent(n,i)},r._keyUpCallback=function(n){return r._handleKeyUpEvent(n)},r}return t.prototype._anchor=function(r){e.prototype._anchor.call(this,r),this._positionDispatcher=S$t.Mouse.getDispatcher(this._componentAttachedTo),this._positionDispatcher.onMouseMove(this._mouseMoveCallback),this._keyDispatcher=S$t.Key.getDispatcher(),this._keyDispatcher.onKeyDown(this._keyDownCallback),this._keyDispatcher.onKeyUp(this._keyUpCallback)},t.prototype._unanchor=function(){e.prototype._unanchor.call(this),this._positionDispatcher.offMouseMove(this._mouseMoveCallback),this._positionDispatcher=null,this._keyDispatcher.offKeyDown(this._keyDownCallback),this._keyDispatcher.offKeyUp(this._keyUpCallback),this._keyDispatcher=null},t.prototype._handleKeyDownEvent=function(r,n){var i=this._translateToComponentSpace(this._positionDispatcher.lastMousePosition());this._isInsideComponent(i)&&!n.repeat&&(this._keyPressCallbacks[r]&&this._keyPressCallbacks[r].callCallbacks(r),this._downedKeys.add(r))},t.prototype._handleKeyUpEvent=function(r){this._downedKeys.has(r)&&this._keyReleaseCallbacks[r]&&this._keyReleaseCallbacks[r].callCallbacks(r),this._downedKeys.delete(r)},t.prototype.onKeyPress=function(r,n){return this._keyPressCallbacks[r]||(this._keyPressCallbacks[r]=new xot.CallbackSet),this._keyPressCallbacks[r].add(n),this},t.prototype.offKeyPress=function(r,n){return this._keyPressCallbacks[r].delete(n),this._keyPressCallbacks[r].size===0&&delete this._keyPressCallbacks[r],this},t.prototype.onKeyRelease=function(r,n){return this._keyReleaseCallbacks[r]||(this._keyReleaseCallbacks[r]=new xot.CallbackSet),this._keyReleaseCallbacks[r].add(n),this},t.prototype.offKeyRelease=function(r,n){return this._keyReleaseCallbacks[r].delete(n),this._keyReleaseCallbacks[r].size===0&&delete this._keyReleaseCallbacks[r],this},t}(ZFe.Interaction);bot.Key=JFe});var C$t=H(Sot=>{"use strict";Object.defineProperty(Sot,"__esModule",{value:!0});var QFe=(de(),Ut(pe)),tBe=(Er(),Ut(Mr)),M$t=Nv(),E$t=ks(),yl=Fe(),eBe=l4(),rBe=Dv(),T$t=e4(),nBe=function(e){QFe.__extends(t,e);function t(r,n){var i=e.call(this)||this;return i._wheelFilter=function(o){return!0},i._wheelCallback=function(o,a){return i._handleWheelEvent(o,a)},i._touchStartCallback=function(o,a,s){return i._handleTouchStart(o,a,s)},i._touchMoveCallback=function(o,a,s){return i._handlePinch(o,a,s)},i._touchEndCallback=function(o,a,s){return i._handleTouchEnd(o,a,s)},i._touchCancelCallback=function(o,a,s){return i._handleTouchEnd(o,a,s)},i._panEndCallbacks=new yl.CallbackSet,i._zoomEndCallbacks=new yl.CallbackSet,i._panZoomUpdateCallbacks=new yl.CallbackSet,i._xScales=new yl.Set,i._yScales=new yl.Set,i._dragInteraction=new eBe.Drag,i._setupDragInteraction(),i._touchIds=tBe.map(),i._minDomainExtents=new yl.Map,i._maxDomainExtents=new yl.Map,i._minDomainValues=new yl.Map,i._maxDomainValues=new yl.Map,r!=null&&i.addXScale(r),n!=null&&i.addYScale(n),i}return t.prototype.dragInteraction=function(){return this._dragInteraction},t.prototype.wheelFilter=function(r){return arguments.length===0?this._wheelFilter:(this._wheelFilter=r,this)},t.prototype.pan=function(r){var n=this;this.xScales().forEach(function(i){i.pan(n._constrainedTranslation(i,r.x))}),this.yScales().forEach(function(i){i.pan(n._constrainedTranslation(i,r.y))}),this._panZoomUpdateCallbacks.callCallbacks()},t.prototype.zoom=function(r,n,i){var o=this;i===void 0&&(i=!0);var a,s;return n!=null&&(a=n.x,s=n.y,i&&(this.xScales().forEach(function(l){var c=o._constrainedZoom(l,r,a);a=c.centerPoint,r=c.zoomAmount}),this.yScales().forEach(function(l){var c=o._constrainedZoom(l,r,s);s=c.centerPoint,r=c.zoomAmount}))),this.xScales().forEach(function(l){var c=l.range(),u=a==null?(c[1]+c[0])/2:a;l.zoom(r,u)}),this.yScales().forEach(function(l){var c=l.range(),u=s==null?(c[1]+c[0])/2:s;l.zoom(r,u)}),this._panZoomUpdateCallbacks.callCallbacks(),{zoomAmount:r,centerValue:{centerX:a,centerY:s}}},t.prototype._anchor=function(r){e.prototype._anchor.call(this,r),this._dragInteraction.attachTo(r),this._mouseDispatcher=M$t.Mouse.getDispatcher(this._componentAttachedTo),this._mouseDispatcher.onWheel(this._wheelCallback),this._touchDispatcher=M$t.Touch.getDispatcher(this._componentAttachedTo),this._touchDispatcher.onTouchStart(this._touchStartCallback),this._touchDispatcher.onTouchMove(this._touchMoveCallback),this._touchDispatcher.onTouchEnd(this._touchEndCallback),this._touchDispatcher.onTouchCancel(this._touchCancelCallback)},t.prototype._unanchor=function(){e.prototype._unanchor.call(this),this._mouseDispatcher.offWheel(this._wheelCallback),this._mouseDispatcher=null,this._touchDispatcher.offTouchStart(this._touchStartCallback),this._touchDispatcher.offTouchMove(this._touchMoveCallback),this._touchDispatcher.offTouchEnd(this._touchEndCallback),this._touchDispatcher.offTouchCancel(this._touchCancelCallback),this._touchDispatcher=null,this._dragInteraction.detach()},t.prototype._handleTouchStart=function(r,n,i){for(var o=0;o<r.length&&this._touchIds.size()<2;o++){var a=r[o];this._touchIds.set(a.toString(),this._translateToComponentSpace(n[a]))}},t.prototype._handlePinch=function(r,n,i){var o=this;if(!(this._touchIds.size()<2)){var a=this._touchIds.values();if(!(!this._isInsideComponent(this._translateToComponentSpace(a[0]))||!this._isInsideComponent(this._translateToComponentSpace(a[1])))){var s=t._pointDistance(a[0],a[1]);if(s!==0){r.forEach(function(S){o._touchIds.has(S.toString())&&o._touchIds.set(S.toString(),o._translateToComponentSpace(n[S]))});var l=this._touchIds.values(),c=t._pointDistance(l[0],l[1]);if(c!==0){var u=s/c,h=l.map(function(S,C){return{x:(S.x-a[C].x)/u,y:(S.y-a[C].y)/u}}),f=t.centerPoint(a[0],a[1]),p=this.zoom(u,f),d=p.centerValue,g=p.zoomAmount,_=d.centerX,y=d.centerY,x=a.map(function(S,C){return{x:h[C].x*g+S.x,y:h[C].y*g+S.y}}),b={x:_-(x[0].x+x[1].x)/2,y:y-(x[0].y+x[1].y)/2};this.pan(b)}}}}},t.centerPoint=function(r,n){var i=Math.min(r.x,n.x),o=Math.max(r.x,n.x),a=Math.min(r.y,n.y),s=Math.max(r.y,n.y);return{x:(i+o)/2,y:(s+a)/2}},t._pointDistance=function(r,n){var i=Math.min(r.x,n.x),o=Math.max(r.x,n.x),a=Math.min(r.y,n.y),s=Math.max(r.y,n.y);return Math.sqrt(Math.pow(o-i,2)+Math.pow(s-a,2))},t.prototype._handleTouchEnd=function(r,n,i){var o=this;r.forEach(function(a){o._touchIds.remove(a.toString())}),this._touchIds.size()>0&&this._zoomEndCallbacks.callCallbacks()},t.prototype._handleWheelEvent=function(r,n){if(!!this._wheelFilter(n)){var i=this._translateToComponentSpace(r);if(this._isInsideComponent(i)){n.preventDefault();var o=n.deltaY!==0?n.deltaY:n.deltaX,a=o*(n.deltaMode?t._PIXELS_PER_LINE:1),s=Math.pow(2,a*.002);this.zoom(s,i),this._zoomEndCallbacks.callCallbacks()}}},t.prototype._constrainedZoom=function(r,n,i){return T$t.constrainedZoom(r,n,i,this.minDomainExtent(r),this.maxDomainExtent(r),this.minDomainValue(r),this.maxDomainValue(r))},t.prototype._constrainedTranslation=function(r,n){return T$t.constrainedTranslation(r,n,this.minDomainValue(r),this.maxDomainValue(r))},t.prototype._setupDragInteraction=function(){var r=this;this._dragInteraction.constrainedToComponent(!1);var n;this._dragInteraction.onDragStart(function(){return n=null}),this._dragInteraction.onDrag(function(i,o){if(!(r._touchIds.size()>=2)){var a={x:(n==null?i.x:n.x)-o.x,y:(n==null?i.y:n.y)-o.y};r.pan(a),n=o}}),this._dragInteraction.onDragEnd(function(){return r._panEndCallbacks.callCallbacks()})},t.prototype._nonLinearScaleWithExtents=function(r){return this.minDomainExtent(r)!=null&&this.maxDomainExtent(r)!=null&&!(r instanceof E$t.Linear)&&!(r instanceof E$t.Time)},t.prototype.xScales=function(r){var n=this;if(r==null){var i=[];return this._xScales.forEach(function(o){i.push(o)}),i}return this._xScales=new yl.Set,r.forEach(function(o){n.addXScale(o)}),this},t.prototype.yScales=function(r){var n=this;if(r==null){var i=[];return this._yScales.forEach(function(o){i.push(o)}),i}return this._yScales=new yl.Set,r.forEach(function(o){n.addYScale(o)}),this},t.prototype.addXScale=function(r){return this._xScales.add(r),this},t.prototype.removeXScale=function(r){return this._xScales.delete(r),this._minDomainExtents.delete(r),this._maxDomainExtents.delete(r),this._minDomainValues.delete(r),this._maxDomainValues.delete(r),this},t.prototype.addYScale=function(r){return this._yScales.add(r),this},t.prototype.removeYScale=function(r){return this._yScales.delete(r),this._minDomainExtents.delete(r),this._maxDomainExtents.delete(r),this._minDomainValues.delete(r),this._maxDomainValues.delete(r),this},t.prototype.minDomainExtent=function(r,n){if(n==null)return this._minDomainExtents.get(r);if(n.valueOf()<0)throw new Error("extent must be non-negative");var i=this.maxDomainExtent(r);if(i!=null&&i.valueOf()<n.valueOf())throw new Error("minDomainExtent must be smaller than maxDomainExtent for the same Scale");return this._nonLinearScaleWithExtents(r)&&yl.Window.warn("Panning and zooming with extents on a nonlinear scale may have unintended behavior."),this._minDomainExtents.set(r,n),this},t.prototype.maxDomainExtent=function(r,n){if(n==null)return this._maxDomainExtents.get(r);if(n.valueOf()<=0)throw new Error("extent must be positive");var i=this.minDomainExtent(r);if(i!=null&&n.valueOf()<i.valueOf())throw new Error("maxDomainExtent must be larger than minDomainExtent for the same Scale");return this._nonLinearScaleWithExtents(r)&&yl.Window.warn("Panning and zooming with extents on a nonlinear scale may have unintended behavior."),this._maxDomainExtents.set(r,n),this},t.prototype.minDomainValue=function(r,n){return n==null?this._minDomainValues.get(r):(this._minDomainValues.set(r,n),this)},t.prototype.maxDomainValue=function(r,n){return n==null?this._maxDomainValues.get(r):(this._maxDomainValues.set(r,n),this)},t.prototype.setMinMaxDomainValuesTo=function(r){this._minDomainValues.delete(r),this._maxDomainValues.delete(r);var n=r.getTransformationDomain(),i=n[0],o=n[1];return this.minDomainValue(r,i),this.maxDomainValue(r,o),this},t.prototype.onPanEnd=function(r){return this._panEndCallbacks.add(r),this},t.prototype.offPanEnd=function(r){return this._panEndCallbacks.delete(r),this},t.prototype.onZoomEnd=function(r){return this._zoomEndCallbacks.add(r),this},t.prototype.offZoomEnd=function(r){return this._zoomEndCallbacks.delete(r),this},t.prototype.onPanZoomUpdate=function(r){return this._panZoomUpdateCallbacks.add(r),this},t.prototype.offPanZoomUpdate=function(r){return this._panZoomUpdateCallbacks.delete(r),this},t._PIXELS_PER_LINE=120,t}(rBe.Interaction);Sot.PanZoom=nBe});var P$t=H(Eot=>{"use strict";Object.defineProperty(Eot,"__esModule",{value:!0});var iBe=(de(),Ut(pe)),A$t=Nv(),Mot=Fe(),oBe=Dv(),aBe=function(e){iBe.__extends(t,e);function t(){var r=e!==null&&e.apply(this,arguments)||this;return r._overComponent=!1,r._pointerEnterCallbacks=new Mot.CallbackSet,r._pointerMoveCallbacks=new Mot.CallbackSet,r._pointerExitCallbacks=new Mot.CallbackSet,r._mouseMoveCallback=function(n,i){return r._handleMouseEvent(n,i)},r._touchStartCallback=function(n,i,o){return r._handleTouchEvent(i[n[0]],o)},r}return t.prototype._anchor=function(r){e.prototype._anchor.call(this,r),this._mouseDispatcher=A$t.Mouse.getDispatcher(this._componentAttachedTo),this._mouseDispatcher.onMouseMove(this._mouseMoveCallback),this._touchDispatcher=A$t.Touch.getDispatcher(this._componentAttachedTo),this._touchDispatcher.onTouchStart(this._touchStartCallback)},t.prototype._unanchor=function(){e.prototype._unanchor.call(this),this._mouseDispatcher.offMouseMove(this._mouseMoveCallback),this._mouseDispatcher=null,this._touchDispatcher.offTouchStart(this._touchStartCallback),this._touchDispatcher=null},t.prototype._handleMouseEvent=function(r,n){var i=this._mouseDispatcher.eventInside(this._componentAttachedTo,n);this._handlePointerEvent(r,i)},t.prototype._handleTouchEvent=function(r,n){var i=this._touchDispatcher.eventInside(this._componentAttachedTo,n);this._handlePointerEvent(r,i)},t.prototype._handlePointerEvent=function(r,n){var i=this._translateToComponentSpace(r),o=this._isInsideComponent(i);o&&n?(this._overComponent||this._pointerEnterCallbacks.callCallbacks(i),this._pointerMoveCallbacks.callCallbacks(i)):this._overComponent&&this._pointerExitCallbacks.callCallbacks(i),this._overComponent=o&&n},t.prototype.onPointerEnter=function(r){return this._pointerEnterCallbacks.add(r),this},t.prototype.offPointerEnter=function(r){return this._pointerEnterCallbacks.delete(r),this},t.prototype.onPointerMove=function(r){return this._pointerMoveCallbacks.add(r),this},t.prototype.offPointerMove=function(r){return this._pointerMoveCallbacks.delete(r),this},t.prototype.onPointerExit=function(r){return this._pointerExitCallbacks.add(r),this},t.prototype.offPointerExit=function(r){return this._pointerExitCallbacks.delete(r),this},t}(oBe.Interaction);Eot.Pointer=aBe});var l4=H(Zg=>{"use strict";Object.defineProperty(Zg,"__esModule",{value:!0});var c4=(de(),Ut(pe));c4.__exportStar(x$t(),Zg);c4.__exportStar(w$t(),Zg);c4.__exportStar(wot(),Zg);c4.__exportStar(C$t(),Zg);c4.__exportStar(P$t(),Zg);var sBe=e4();Zg.zoomOut=sBe.zoomOut});var Tot=H(u4=>{"use strict";Object.defineProperty(u4,"__esModule",{value:!0});var lBe=(de(),Ut(pe)),VF=Fe(),cBe=kc(),es;(function(e){e[e.VALUE=0]="VALUE",e[e.PIXEL=1]="PIXEL"})(es=u4.PropertyMode||(u4.PropertyMode={}));var uBe=function(e){lBe.__extends(t,e);function t(){var r=e.call(this)||this;return r._boxVisible=!1,r._boxBounds={topLeft:{x:0,y:0},bottomRight:{x:0,y:0}},r._xBoundsMode=es.PIXEL,r._yBoundsMode=es.PIXEL,r.addClass("selection-box-layer"),r._adjustBoundsCallback=function(){r.render()},r._overflowHidden=!0,r._xExtent=[void 0,void 0],r._yExtent=[void 0,void 0],r}return t.prototype._setup=function(){e.prototype._setup.call(this),this._box=this.content().append("g").classed("selection-box",!0).remove(),this._boxArea=this._box.append("rect").classed("selection-area",!0)},t.prototype._sizeFromOffer=function(r,n){return{width:r,height:n}},t.prototype.bounds=function(r){return r==null?this._getBounds():(this._setBounds(r),this._xBoundsMode=es.PIXEL,this._yBoundsMode=es.PIXEL,this.render(),this)},t.prototype._setBounds=function(r){var n={x:Math.min(r.topLeft.x,r.bottomRight.x),y:Math.min(r.topLeft.y,r.bottomRight.y)},i={x:Math.max(r.topLeft.x,r.bottomRight.x),y:Math.max(r.topLeft.y,r.bottomRight.y)};this._boxBounds={topLeft:n,bottomRight:i}},t.prototype._getBounds=function(){return{topLeft:{x:this._xBoundsMode===es.PIXEL?this._boxBounds.topLeft.x:this._xScale==null?0:Math.min(this.xScale().scale(this.xExtent()[0]),this.xScale().scale(this.xExtent()[1])),y:this._yBoundsMode===es.PIXEL?this._boxBounds.topLeft.y:this._yScale==null?0:Math.min(this.yScale().scale(this.yExtent()[0]),this.yScale().scale(this.yExtent()[1]))},bottomRight:{x:this._xBoundsMode===es.PIXEL?this._boxBounds.bottomRight.x:this._xScale==null?0:Math.max(this.xScale().scale(this.xExtent()[0]),this.xScale().scale(this.xExtent()[1])),y:this._yBoundsMode===es.PIXEL?this._boxBounds.bottomRight.y:this._yScale==null?0:Math.max(this.yScale().scale(this.yExtent()[0]),this.yScale().scale(this.yExtent()[1]))}}},t.prototype.renderImmediately=function(){if(e.prototype.renderImmediately.call(this),this._boxVisible){var r=this.bounds(),n=r.topLeft.y,i=r.bottomRight.y,o=r.topLeft.x,a=r.bottomRight.x;if(!(VF.Math.isValidNumber(n)&&VF.Math.isValidNumber(i)&&VF.Math.isValidNumber(o)&&VF.Math.isValidNumber(a)))throw new Error("bounds have not been properly set");this._boxArea.attrs({x:o,y:n,width:a-o,height:i-n}),this.content().node().appendChild(this._box.node())}else this._box.remove();return this},t.prototype.boxVisible=function(r){return r==null?this._boxVisible:(this._boxVisible=r,this.render(),this)},t.prototype.fixedWidth=function(){return!0},t.prototype.fixedHeight=function(){return!0},t.prototype.xScale=function(r){return r==null?this._xScale:(this._xScale!=null&&this._xScale.offUpdate(this._adjustBoundsCallback),this._xScale=r,this._xBoundsMode=es.VALUE,this._xScale.onUpdate(this._adjustBoundsCallback),this.render(),this)},t.prototype.yScale=function(r){return r==null?this._yScale:(this._yScale!=null&&this._yScale.offUpdate(this._adjustBoundsCallback),this._yScale=r,this._yBoundsMode=es.VALUE,this._yScale.onUpdate(this._adjustBoundsCallback),this.render(),this)},t.prototype.xExtent=function(r){return r==null?this._getXExtent():(this._setXExtent(r),this._xBoundsMode=es.VALUE,this.render(),this)},t.prototype._getXExtent=function(){return this._xBoundsMode===es.VALUE?this._xExtent:this._xScale==null?[void 0,void 0]:[this._xScale.invert(this._boxBounds.topLeft.x),this._xScale.invert(this._boxBounds.bottomRight.x)]},t.prototype._setXExtent=function(r){this._xExtent=r},t.prototype.yExtent=function(r){return r==null?this._getYExtent():(this._setYExtent(r),this._yBoundsMode=es.VALUE,this.render(),this)},t.prototype._getYExtent=function(){return this._yBoundsMode===es.VALUE?this._yExtent:this._yScale==null?[void 0,void 0]:[this._yScale.invert(this._boxBounds.topLeft.y),this._yScale.invert(this._boxBounds.bottomRight.y)]},t.prototype._setYExtent=function(r){this._yExtent=r},t.prototype.destroy=function(){e.prototype.destroy.call(this),this._xScale!=null&&this.xScale().offUpdate(this._adjustBoundsCallback),this._yScale!=null&&this.yScale().offUpdate(this._adjustBoundsCallback)},t}(cBe.Component);u4.SelectionBoxLayer=uBe});var qF=H(Aot=>{"use strict";Object.defineProperty(Aot,"__esModule",{value:!0});var hBe=(de(),Ut(pe)),fBe=l4(),Cot=Fe(),pBe=Yg(),UF=Pot(),dBe=Tot(),mBe=function(e){hBe.__extends(t,e);function t(){var r=e.call(this)||this;return r._detectionRadius=3,r._resizable=!1,r._movable=!1,r._hasCorners=!0,r.addClass("drag-box-layer"),r._dragInteraction=new fBe.Drag,r._setUpCallbacks(),r._dragInteraction.attachTo(r),r._dragStartCallbacks=new Cot.CallbackSet,r._dragCallbacks=new Cot.CallbackSet,r._dragEndCallbacks=new Cot.CallbackSet,r}return t.prototype._setUpCallbacks=function(){var r=this,n,i,o,a,s={newBox:0,resize:1,move:2},l=s.newBox,c=function(f){n=r._getResizingEdges(f);var p=r.bounds(),d=p.topLeft.x<=f.x&&f.x<=p.bottomRight.x&&p.topLeft.y<=f.y&&f.y<=p.bottomRight.y;r.boxVisible()&&(n.top||n.bottom||n.left||n.right)?l=s.resize:r.boxVisible()&&r.movable()&&d?l=s.move:(l=s.newBox,r._setBounds({topLeft:f,bottomRight:f}),r._xBoundsMode===UF.PropertyMode.VALUE&&r.xScale()!=null&&r._setXExtent([r.xScale().invert(f.x),r.xScale().invert(f.x)]),r._yBoundsMode===UF.PropertyMode.VALUE&&r.yScale()!=null&&r._setYExtent([r.yScale().invert(f.y),r.yScale().invert(f.y)]),r.render()),r.boxVisible(!0),p=r.bounds(),i={x:p.topLeft.x,y:p.topLeft.y},o={x:p.bottomRight.x,y:p.bottomRight.y},a=f,r._dragStartCallbacks.callCallbacks(p)},u=function(f,p){switch(l){case s.newBox:o.x=p.x,o.y=p.y;break;case s.resize:n.bottom?o.y=p.y:n.top&&(i.y=p.y),n.right?o.x=p.x:n.left&&(i.x=p.x);break;case s.move:var d=p.x-a.x,g=p.y-a.y;i.x+=d,i.y+=g,o.x+=d,o.y+=g,a=p;break}r._setBounds({topLeft:i,bottomRight:o}),r._xBoundsMode===UF.PropertyMode.VALUE&&r.xScale()!=null&&r._setXExtent([r.xScale().invert(i.x),r.xScale().invert(o.x)]),r._yBoundsMode===UF.PropertyMode.VALUE&&r.yScale()!=null&&r._setYExtent([r.yScale().invert(i.y),r.yScale().invert(o.y)]),r.render(),r._dragCallbacks.callCallbacks(r.bounds())},h=function(f,p){l===s.newBox&&f.x===p.x&&f.y===p.y&&r.boxVisible(!1),r._dragEndCallbacks.callCallbacks(r.bounds())};this._dragInteraction.onDragStart(c),this._dragInteraction.onDrag(u),this._dragInteraction.onDragEnd(h),this._disconnectInteraction=function(){r._dragInteraction.offDragStart(c),r._dragInteraction.offDrag(u),r._dragInteraction.offDragEnd(h),r._dragInteraction.detach()}},t.prototype._setup=function(){var r=this;e.prototype._setup.call(this);var n=function(){return r._box.append("line").styles({opacity:0,stroke:"pink","pointer-events":"visibleStroke"})};if(this._detectionEdgeT=n().classed("drag-edge-tb",!0),this._detectionEdgeB=n().classed("drag-edge-tb",!0),this._detectionEdgeL=n().classed("drag-edge-lr",!0),this._detectionEdgeR=n().classed("drag-edge-lr",!0),this._hasCorners){var i=function(){return r._box.append("circle").styles({opacity:0,fill:"pink","pointer-events":"visibleFill"})};this._detectionCornerTL=i().classed("drag-corner-tl",!0),this._detectionCornerTR=i().classed("drag-corner-tr",!0),this._detectionCornerBL=i().classed("drag-corner-bl",!0),this._detectionCornerBR=i().classed("drag-corner-br",!0)}},t.prototype._getResizingEdges=function(r){var n={top:!1,bottom:!1,left:!1,right:!1};if(!this.resizable())return n;var i=this.bounds(),o=i.topLeft.y,a=i.bottomRight.y,s=i.topLeft.x,l=i.bottomRight.x,c=this._detectionRadius;return s-c<=r.x&&r.x<=l+c&&(n.top=o-c<=r.y&&r.y<=o+c,n.bottom=a-c<=r.y&&r.y<=a+c),o-c<=r.y&&r.y<=a+c&&(n.left=s-c<=r.x&&r.x<=s+c,n.right=l-c<=r.x&&r.x<=l+c),n},t.prototype.renderImmediately=function(){if(e.prototype.renderImmediately.call(this),this.boxVisible()){var r=this.bounds(),n=r.topLeft.y,i=r.bottomRight.y,o=r.topLeft.x,a=r.bottomRight.x;this._detectionEdgeT.attrs({x1:o,y1:n,x2:a,y2:n,"stroke-width":this._detectionRadius*2}),this._detectionEdgeB.attrs({x1:o,y1:i,x2:a,y2:i,"stroke-width":this._detectionRadius*2}),this._detectionEdgeL.attrs({x1:o,y1:n,x2:o,y2:i,"stroke-width":this._detectionRadius*2}),this._detectionEdgeR.attrs({x1:a,y1:n,x2:a,y2:i,"stroke-width":this._detectionRadius*2}),this._hasCorners&&(this._detectionCornerTL.attrs({cx:o,cy:n,r:this._detectionRadius}),this._detectionCornerTR.attrs({cx:a,cy:n,r:this._detectionRadius}),this._detectionCornerBL.attrs({cx:o,cy:i,r:this._detectionRadius}),this._detectionCornerBR.attrs({cx:a,cy:i,r:this._detectionRadius}))}return this},t.prototype.detectionRadius=function(r){if(r==null)return this._detectionRadius;if(r<0)throw new Error("detection radius cannot be negative.");return this._detectionRadius=r,this.render(),this},t.prototype.resizable=function(r){return r==null?this._resizable:(this._resizable=r,this._setResizableClasses(r),this)},t.prototype._setResizableClasses=function(r){r&&this.enabled()?(this.addClass("x-resizable"),this.addClass("y-resizable")):(this.removeClass("x-resizable"),this.removeClass("y-resizable"))},t.prototype.movable=function(r){return r==null?this._movable:(this._movable=r,this._setMovableClass(),this)},t.prototype._setMovableClass=function(){this.movable()&&this.enabled()?this.addClass("movable"):this.removeClass("movable")},t.prototype.onDragStart=function(r){return this._dragStartCallbacks.add(r),this},t.prototype.offDragStart=function(r){return this._dragStartCallbacks.delete(r),this},t.prototype.onDrag=function(r){return this._dragCallbacks.add(r),this},t.prototype.offDrag=function(r){return this._dragCallbacks.delete(r),this},t.prototype.onDragEnd=function(r){return this._dragEndCallbacks.add(r),this},t.prototype.offDragEnd=function(r){return this._dragEndCallbacks.delete(r),this},t.prototype.dragInteraction=function(){return this._dragInteraction},t.prototype.enabled=function(r){return r==null?this._dragInteraction.enabled():(this._dragInteraction.enabled(r),this._setResizableClasses(this.resizable()),this._setMovableClass(),this)},t.prototype.destroy=function(){var r=this;e.prototype.destroy.call(this),this._dragStartCallbacks.forEach(function(n){return r._dragCallbacks.delete(n)}),this._dragCallbacks.forEach(function(n){return r._dragCallbacks.delete(n)}),this._dragEndCallbacks.forEach(function(n){return r._dragEndCallbacks.delete(n)}),this._disconnectInteraction()},t.prototype.detach=function(){return this._resetState(),this._dragInteraction.detach(),e.prototype.detach.call(this),this},t.prototype.anchor=function(r){return r=pBe.coerceExternalD3(r),this._dragInteraction.attachTo(this),e.prototype.anchor.call(this,r),this},t.prototype._resetState=function(){this.bounds({topLeft:{x:0,y:0},bottomRight:{x:0,y:0}})},t}(dBe.SelectionBoxLayer);Aot.DragBoxLayer=mBe});var Lot=H(Iot=>{"use strict";Object.defineProperty(Iot,"__esModule",{value:!0});var gBe=(de(),Ut(pe)),_Be=Fe(),yBe=kc(),Ov;(function(e){e[e.VALUE=0]="VALUE",e[e.PIXEL=1]="PIXEL"})(Ov||(Ov={}));var vBe=function(e){gBe.__extends(t,e);function t(r){var n=e.call(this)||this;if(n._mode=Ov.VALUE,r!==t.ORIENTATION_VERTICAL&&r!==t.ORIENTATION_HORIZONTAL)throw new Error(r+" is not a valid orientation for GuideLineLayer");return n._orientation=r,n._overflowHidden=!0,n.addClass("guide-line-layer"),n._isVertical()?n.addClass("vertical"):n.addClass("horizontal"),n._scaleUpdateCallback=function(){n._syncPixelPositionAndValue(),n.render()},n}return t.prototype._setup=function(){e.prototype._setup.call(this),this._guideLine=this.content().append("line").classed("guide-line",!0)},t.prototype._sizeFromOffer=function(r,n){return{width:r,height:n}},t.prototype._isVertical=function(){return this._orientation===t.ORIENTATION_VERTICAL},t.prototype.fixedWidth=function(){return!0},t.prototype.fixedHeight=function(){return!0},t.prototype.computeLayout=function(r,n,i){return e.prototype.computeLayout.call(this,r,n,i),this.scale()!=null&&(this._isVertical()?this.scale().range([0,this.width()]):this.scale().range([this.height(),0])),this},t.prototype.renderImmediately=function(){return e.prototype.renderImmediately.call(this),this._syncPixelPositionAndValue(),this._guideLine.attrs({x1:this._isVertical()?this.pixelPosition():0,y1:this._isVertical()?0:this.pixelPosition(),x2:this._isVertical()?this.pixelPosition():this.width(),y2:this._isVertical()?this.height():this.pixelPosition()}),this},t.prototype._syncPixelPositionAndValue=function(){this.scale()!=null&&(this._mode===Ov.VALUE&&this.value()!=null?this._pixelPosition=this.scale().scale(this.value()):this._mode===Ov.PIXEL&&this.pixelPosition()!=null&&(this._value=this.scale().invert(this.pixelPosition())))},t.prototype._setPixelPositionWithoutChangingMode=function(r){this._pixelPosition=r,this.scale()!=null&&(this._value=this.scale().invert(this.pixelPosition())),this.render()},t.prototype.scale=function(r){if(r==null)return this._scale;var n=this._scale;return n!=null&&n.offUpdate(this._scaleUpdateCallback),this._scale=r,this._scale.onUpdate(this._scaleUpdateCallback),this._syncPixelPositionAndValue(),this.redraw(),this},t.prototype.value=function(r){return r==null?this._value:(this._value=r,this._mode=Ov.VALUE,this._syncPixelPositionAndValue(),this.render(),this)},t.prototype.pixelPosition=function(r){if(r==null)return this._pixelPosition;if(!_Be.Math.isValidNumber(r))throw new Error("pixelPosition must be a finite number");return this._pixelPosition=r,this._mode=Ov.PIXEL,this._syncPixelPositionAndValue(),this.render(),this},t.prototype.destroy=function(){e.prototype.destroy.call(this),this.scale()!=null&&this.scale().offUpdate(this._scaleUpdateCallback)},t.ORIENTATION_VERTICAL="vertical",t.ORIENTATION_HORIZONTAL="horizontal",t}(yBe.Component);Iot.GuideLineLayer=vBe});var I$t=H(Rot=>{"use strict";Object.defineProperty(Rot,"__esModule",{value:!0});var xBe=(de(),Ut(pe)),bBe=Lot(),wBe=l4(),kot=Fe(),SBe=function(e){xBe.__extends(t,e);function t(r){var n=e.call(this,r)||this;n._detectionRadius=3,n._enabled=!0,n.addClass("drag-line-layer"),n.addClass("enabled"),n._dragInteraction=new wBe.Drag,n._dragInteraction.attachTo(n);var i=function(c){return n._isVertical()&&n.pixelPosition()-n.detectionRadius()<=c.x&&c.x<=n.pixelPosition()+n.detectionRadius()||!n._isVertical()&&n.pixelPosition()-n.detectionRadius()<=c.y&&c.y<=n.pixelPosition()+n.detectionRadius()},o=!1,a=function(c){i(c)&&(o=!0,n._dragStartCallbacks.callCallbacks(n))};n._dragInteraction.onDragStart(a);var s=function(c,u){o&&(n._setPixelPositionWithoutChangingMode(n._isVertical()?u.x:u.y),n._dragCallbacks.callCallbacks(n))};n._dragInteraction.onDrag(s);var l=function(c,u){o&&(o=!1,n._dragEndCallbacks.callCallbacks(n))};return n._dragInteraction.onDragEnd(l),n._disconnectInteraction=function(){n._dragInteraction.offDragStart(a),n._dragInteraction.offDrag(s),n._dragInteraction.offDragEnd(l),n._dragInteraction.detach()},n._dragStartCallbacks=new kot.CallbackSet,n._dragCallbacks=new kot.CallbackSet,n._dragEndCallbacks=new kot.CallbackSet,n}return t.prototype._setup=function(){e.prototype._setup.call(this),this._detectionEdge=this.content().append("line").styles({opacity:0,stroke:"pink","pointer-events":"visibleStroke"}).classed("drag-edge",!0)},t.prototype.renderImmediately=function(){return e.prototype.renderImmediately.call(this),this._detectionEdge.attrs({x1:this._isVertical()?this.pixelPosition():0,y1:this._isVertical()?0:this.pixelPosition(),x2:this._isVertical()?this.pixelPosition():this.width(),y2:this._isVertical()?this.height():this.pixelPosition(),"stroke-width":this._detectionRadius*2}),this},t.prototype.detectionRadius=function(r){if(r==null)return this._detectionRadius;if(r<0)throw new Error("detection radius cannot be negative.");return this._detectionRadius=r,this.render(),this},t.prototype.enabled=function(r){return r==null?this._enabled:(this._enabled=r,r?this.addClass("enabled"):this.removeClass("enabled"),this._dragInteraction.enabled(r),this)},t.prototype.onDragStart=function(r){return this._dragStartCallbacks.add(r),this},t.prototype.offDragStart=function(r){return this._dragStartCallbacks.delete(r),this},t.prototype.onDrag=function(r){return this._dragCallbacks.add(r),this},t.prototype.offDrag=function(r){return this._dragCallbacks.delete(r),this},t.prototype.onDragEnd=function(r){return this._dragEndCallbacks.add(r),this},t.prototype.offDragEnd=function(r){return this._dragEndCallbacks.delete(r),this},t.prototype.destroy=function(){var r=this;e.prototype.destroy.call(this),this._dragStartCallbacks.forEach(function(n){return r._dragStartCallbacks.delete(n)}),this._dragCallbacks.forEach(function(n){return r._dragCallbacks.delete(n)}),this._dragEndCallbacks.forEach(function(n){return r._dragEndCallbacks.delete(n)}),this._disconnectInteraction()},t}(bBe.GuideLineLayer);Rot.DragLineLayer=SBe});var L$t=H(Not=>{"use strict";Object.defineProperty(Not,"__esModule",{value:!0});var MBe=(de(),Ut(pe)),EBe=kc();function GF(e,t,r){var n={};if(r!==void 0)for(var i=0;i<r.length;i++){var o=r[i-1],a=r[i];n[a]=o}return function(s){var l=e.scale(s);if(!t)return l;var c,u=n[s]===void 0?void 0:e.scale(n[s]);return u!==void 0&&(c=u+(l-u)/2),c}}var TBe=function(e){MBe.__extends(t,e);function t(r,n){var i=e.call(this)||this;return i.addClass("gridlines"),i._xScale=r,i._yScale=n,i._renderCallback=function(o){return i.render()},i._xScale&&i._xScale.onUpdate(i._renderCallback),i._yScale&&i._yScale.onUpdate(i._renderCallback),i}return t.prototype.betweenX=function(r){return r===void 0?this._betweenX:(r!==this._betweenX&&(this._betweenX=r,this.render()),this)},t.prototype.betweenY=function(r){return r===void 0?this._betweenY:(r!==this._betweenY&&(this._betweenY=r,this.render()),this)},t.prototype.destroy=function(){return e.prototype.destroy.call(this),this._xScale&&this._xScale.offUpdate(this._renderCallback),this._yScale&&this._yScale.offUpdate(this._renderCallback),this},t.prototype._setup=function(){e.prototype._setup.call(this),this._xLinesContainer=this.content().append("g").classed("x-gridlines",!0),this._yLinesContainer=this.content().append("g").classed("y-gridlines",!0)},t.prototype.renderImmediately=function(){return e.prototype.renderImmediately.call(this),this._redrawXLines(),this._redrawYLines(),this},t.prototype.computeLayout=function(r,n,i){return e.prototype.computeLayout.call(this,r,n,i),this._xScale!=null&&this._xScale.range([0,this.width()]),this._yScale!=null&&this._yScale.range([this.height(),0]),this},t.prototype._redrawXLines=function(){if(this._xScale){var r=this.betweenX(),n=this._xScale.ticks().slice(r?1:0),i=this._xLinesContainer.selectAll("line").data(n),o=i.enter().append("line").merge(i);o.attr("x1",GF(this._xScale,r,this._xScale.ticks())).attr("y1",0).attr("x2",GF(this._xScale,r,this._xScale.ticks())).attr("y2",this.height()).classed("betweenline",r).classed("zeroline",function(a){return a===0}),i.exit().remove()}},t.prototype._redrawYLines=function(){if(this._yScale){var r=this.betweenY(),n=this._yScale.ticks().slice(r?1:0),i=this._yLinesContainer.selectAll("line").data(n),o=i.enter().append("line").merge(i);o.attr("x1",0).attr("y1",GF(this._yScale,r,this._yScale.ticks())).attr("x2",this.width()).attr("y2",GF(this._yScale,r,this._yScale.ticks())).classed("betweenline",r).classed("zeroline",function(a){return a===0}),i.exit().remove()}},t}(EBe.Component);Not.Gridlines=TBe});var WF=H(Dot=>{"use strict";Object.defineProperty(Dot,"__esModule",{value:!0});var CBe=(de(),Ut(pe)),ABe=Yg(),PBe=kc(),IBe=function(e){CBe.__extends(t,e);function t(){var r=e.call(this)||this;return r._detachCallback=function(n){return r.remove(n)},r}return t.prototype.anchor=function(r){var n=this;return r=ABe.coerceExternalD3(r),e.prototype.anchor.call(this,r),this._forEach(function(i){return i.anchor(n.element())}),this},t.prototype.render=function(){return this._forEach(function(r){return r.render()}),this},t.prototype.has=function(r){throw new Error("has() is not implemented on ComponentContainer")},t.prototype._adoptAndAnchor=function(r){r.parent(this),r.onDetach(this._detachCallback),this._isAnchored&&r.anchor(this.element())},t.prototype.remove=function(r){return this.has(r)&&(r.offDetach(this._detachCallback),this._remove(r),r.detach(),this.redraw()),this},t.prototype._remove=function(r){return!1},t.prototype._forEach=function(r){throw new Error("_forEach() is not implemented on ComponentContainer")},t.prototype.destroy=function(){e.prototype.destroy.call(this),this._forEach(function(r){return r.destroy()})},t.prototype.invalidateCache=function(){this._forEach(function(r){return r.invalidateCache()})},t}(PBe.Component);Dot.ComponentContainer=IBe});var zot=H(Oot=>{"use strict";Object.defineProperty(Oot,"__esModule",{value:!0});var LBe=(de(),Ut(pe)),k$t=Fe(),kBe=WF(),RBe=function(e){LBe.__extends(t,e);function t(r){r===void 0&&(r=[]);var n=e.call(this)||this;return n._components=[],n.addClass("component-group"),r.forEach(function(i){return n.append(i)}),n}return t.prototype._forEach=function(r){this.components().forEach(r)},t.prototype.has=function(r){return this._components.indexOf(r)>=0},t.prototype.requestedSpace=function(r,n){var i=this._components.map(function(o){return o.requestedSpace(r,n)});return{minWidth:k$t.Math.max(i,function(o){return o.minWidth},0),minHeight:k$t.Math.max(i,function(o){return o.minHeight},0)}},t.prototype.computeLayout=function(r,n,i){var o=this;return e.prototype.computeLayout.call(this,r,n,i),this._forEach(function(a){a.computeLayout({x:0,y:0},o.width(),o.height())}),this},t.prototype._sizeFromOffer=function(r,n){return{width:r,height:n}},t.prototype.fixedWidth=function(){return this._components.every(function(r){return r.fixedWidth()})},t.prototype.fixedHeight=function(){return this._components.every(function(r){return r.fixedHeight()})},t.prototype.components=function(){return this._components.slice()},t.prototype.append=function(r){return r!=null&&!this.has(r)&&(r.detach(),this._components.push(r),this._adoptAndAnchor(r),this.redraw()),this},t.prototype._remove=function(r){var n=this._components.indexOf(r);return n>=0?(this._components.splice(n,1),!0):!1},t}(kBe.ComponentContainer);Oot.Group=RBe});var R$t=H(Fot=>{"use strict";Object.defineProperty(Fot,"__esModule",{value:!0});var NBe=(de(),Ut(pe)),YF=_l(),DBe=$A(),OBe=Bu(),zBe=Fe(),FBe=kc(),BBe=function(e){NBe.__extends(t,e);function t(r){var n=e.call(this)||this;if(n._textPadding=5,r==null)throw new Error("InterpolatedColorLegend requires a interpolatedColorScale");return n._scale=r,n._redrawCallback=function(i){return n.redraw()},n._scale.onUpdate(n._redrawCallback),n._formatter=OBe.general(),n._orientation="horizontal",n._expands=!1,n.addClass("legend"),n.addClass("interpolated-color-legend"),n}return t.prototype.destroy=function(){e.prototype.destroy.call(this),this._scale.offUpdate(this._redrawCallback)},t.prototype.formatter=function(r){return r===void 0?this._formatter:(this._formatter=r,this.redraw(),this)},t.prototype.expands=function(r){return r==null?this._expands:(this._expands=r,this.redraw(),this)},t._ensureOrientation=function(r){if(r=r.toLowerCase(),r==="horizontal"||r==="left"||r==="right")return r;throw new Error('"'+r+'" is not a valid orientation for InterpolatedColorLegend')},t.prototype.orientation=function(r){return r==null?this._orientation:(this._orientation=t._ensureOrientation(r),this.redraw(),this)},t.prototype.fixedWidth=function(){return!this.expands()||this._isVertical()},t.prototype.fixedHeight=function(){return!this.expands()||!this._isVertical()},t.prototype._generateTicks=function(r){r===void 0&&(r=t._DEFAULT_NUM_SWATCHES);var n=this._scale.domain();if(r===1)return[n[0]];for(var i=(n[1]-n[0])/(r-1),o=[],a=0;a<r;a++)o.push(n[0]+i*a);return o},t.prototype._setup=function(){e.prototype._setup.call(this),this._swatchContainer=this.content().append("g").classed("swatch-container",!0),this._swatchBoundingBox=this.content().append("rect").classed("swatch-bounding-box",!0),this._lowerLabel=this.content().append("g").classed(t.LEGEND_LABEL_CLASS,!0),this._upperLabel=this.content().append("g").classed(t.LEGEND_LABEL_CLASS,!0);var r=new YF.SvgContext(this.content().node());this._measurer=new YF.Measurer(r),this._wrapper=new YF.Wrapper,this._writer=new YF.Writer(this._measurer,r,this._wrapper)},t.prototype.requestedSpace=function(r,n){var i=this,o=this._measurer.measure().height,a=o,s=this._scale.domain(),l=s.map(function(p){return i._measurer.measure(i._formatter(p)).width}),c,u,h=t._DEFAULT_NUM_SWATCHES;if(this._isVertical()){var f=zBe.Math.max(l,0);u=a+o+this._textPadding+f+this._textPadding,c=h*o}else c=a+o+a,u=this._textPadding+l[0]+h*o+l[1]+this._textPadding;return{minWidth:u,minHeight:c}},t.prototype._isVertical=function(){return this._orientation!=="horizontal"},t.prototype.renderImmediately=function(){var r=this;e.prototype.renderImmediately.call(this);var n=this._scale.domain(),i=this._formatter(n[0]),o=this._measurer.measure(i).width,a=this._formatter(n[1]),s=this._measurer.measure(a).width,l=this._measurer.measure().height,c=this._textPadding,u={x:0,y:0},h={x:0,y:0},f={xAlign:"center",yAlign:"center",textRotation:0},p={xAlign:"center",yAlign:"center",textRotation:0},d,g,_,y,x={x:0,y:0,width:0,height:0},b,S;if(this._isVertical()){S=Math.floor(this.height());var C=Math.max(o,s);b=(this.width()-C-2*this._textPadding)/2,d=Math.max(this.width()-b-2*c-C,0),g=1,y=function(L,R){return r.height()-(R+1)},p.yAlign="top",u.y=0,f.yAlign="bottom",h.y=0,this._orientation==="left"?(_=function(L,R){return c+C+c},p.xAlign="right",u.x=-(b+d+c),f.xAlign="right",h.x=-(b+d+c)):(_=function(L,R){return b},p.xAlign="left",u.x=b+d+c,f.xAlign="left",h.x=b+d+c),x.width=d,x.height=S*g}else b=Math.max(c,(this.height()-l)/2),S=Math.max(Math.floor(this.width()-c*4-o-s),0),d=1,g=Math.max(this.height()-2*b,0),_=function(L,R){return Math.floor(o+2*c)+R},y=function(L,R){return b},p.xAlign="right",u.x=-c,f.xAlign="left",h.x=c,x.y=b,x.width=S*d,x.height=g;x.x=_(null,0),this._upperLabel.text(""),this._writer.write(a,this.width(),this.height(),p,this._upperLabel.node());var P="translate("+u.x+", "+u.y+")";this._upperLabel.attr("transform",P),this._lowerLabel.text(""),this._writer.write(i,this.width(),this.height(),f,this._lowerLabel.node());var k="translate("+h.x+", "+h.y+")";this._lowerLabel.attr("transform",k),this._swatchBoundingBox.attrs(x);var O=this._generateTicks(S),D=this._swatchContainer.selectAll("rect.swatch").data(O),B=D.enter().append("rect").classed("swatch",!0),I=D.merge(B);return D.exit().remove(),I.attrs({fill:function(L,R){return r._scale.scale(L)},width:d,height:g,x:_,y,"shape-rendering":"crispEdges"}),DBe.ADD_TITLE_ELEMENTS&&B.append("title").text(function(L){return r._formatter(L)}),this},t._DEFAULT_NUM_SWATCHES=11,t.LEGEND_LABEL_CLASS="legend-label",t}(FBe.Component);Fot.InterpolatedColorLegend=BBe});var Vot=H(h4=>{"use strict";Object.defineProperty(h4,"__esModule",{value:!0});var Bot=(de(),Ut(pe)),jF=_l(),HBe=kc(),Hot=function(e){Bot.__extends(t,e);function t(r,n){r===void 0&&(r=""),n===void 0&&(n=0);var i=e.call(this)||this;return i.addClass("label"),i.text(r),i.angle(n),i.xAlignment("center").yAlignment("center"),i._padding=0,i}return t.prototype.requestedSpace=function(r,n){var i=this._measurer.measure(this._text),o=(this.angle()===0?i.width:i.height)+2*this.padding(),a=(this.angle()===0?i.height:i.width)+2*this.padding();return{minWidth:o,minHeight:a}},t.prototype._setup=function(){e.prototype._setup.call(this),this._textContainer=this.content().append("g");var r=new jF.SvgContext(this._textContainer.node());this._measurer=new jF.CacheMeasurer(r),this._wrapper=new jF.Wrapper,this._writer=new jF.Writer(this._measurer,r,this._wrapper),this.text(this._text)},t.prototype.text=function(r){if(r==null)return this._text;if(typeof r!="string")throw new Error("Label.text() only takes strings as input");return this._text=r,this.redraw(),this},t.prototype.angle=function(r){if(r==null)return this._angle;if(r%=360,r>180?r-=360:r<-180&&(r+=360),r===-90||r===0||r===90)this._angle=r;else throw new Error(r+" is not a valid angle for Label");return this.redraw(),this},t.prototype.padding=function(r){if(r==null)return this._padding;if(r=+r,r<0)throw new Error(r+" is not a valid padding value. Cannot be less than 0.");return this._padding=r,this.redraw(),this},t.prototype.fixedWidth=function(){return!0},t.prototype.fixedHeight=function(){return!0},t.prototype.renderImmediately=function(){e.prototype.renderImmediately.call(this),this._textContainer.selectAll("g").remove();var r=this._measurer.measure(this._text),n=Math.max(Math.min((this.height()-r.height)/2,this.padding()),0),i=Math.max(Math.min((this.width()-r.width)/2,this.padding()),0);this._textContainer.attr("transform","translate("+i+","+n+")");var o=this.width()-2*i,a=this.height()-2*n,s={xAlign:this.xAlignment(),yAlign:this.yAlignment(),textRotation:this.angle()};return this._writer.write(this._text,o,a,s),this},t.prototype.invalidateCache=function(){e.prototype.invalidateCache.call(this),this._measurer.reset()},t}(HBe.Component);h4.Label=Hot;var VBe=function(e){Bot.__extends(t,e);function t(r,n){var i=e.call(this,r,n)||this;return i.addClass(t.TITLE_LABEL_CLASS),i}return t.TITLE_LABEL_CLASS="title-label",t}(Hot);h4.TitleLabel=VBe;var UBe=function(e){Bot.__extends(t,e);function t(r,n){var i=e.call(this,r,n)||this;return i.addClass(t.AXIS_LABEL_CLASS),i}return t.AXIS_LABEL_CLASS="axis-label",t}(Hot);h4.AxisLabel=UBe});var XF=H(bd=>{"use strict";Object.defineProperty(bd,"__esModule",{value:!0});var Rs=(Er(),Ut(Mr));function qBe(){return function(e){return Rs.symbol().type(Rs.symbolCircle).size(Math.PI*Math.pow(e/2,2))}}bd.circle=qBe;function GBe(){return function(e){return Rs.symbol().type(Rs.symbolSquare).size(Math.pow(e,2))}}bd.square=GBe;function WBe(){return function(e){return Rs.symbol().type(Rs.symbolCross).size(5/9*Math.pow(e,2))}}bd.cross=WBe;function YBe(){return function(e){return Rs.symbol().type(Rs.symbolDiamond).size(Math.tan(Math.PI/6)*Math.pow(e,2)/2)}}bd.diamond=YBe;function jBe(){return function(e){return Rs.symbol().type(Rs.symbolTriangle).size(Math.sqrt(3)*Math.pow(e/2,2))}}bd.triangle=jBe;var XBe=.8908130915292852;function $Be(){return function(e){return Rs.symbol().type(Rs.symbolStar).size(XBe*Math.pow(e/2,2))}}bd.star=$Be;var KBe=(1/Math.sqrt(12)/2+1)*3;function ZBe(){return function(e){return Rs.symbol().type(Rs.symbolWye).size(KBe*Math.pow(e/2.4,2))}}bd.wye=ZBe});var N$t=H(qot=>{"use strict";Object.defineProperty(qot,"__esModule",{value:!0});var JBe=(de(),Ut(pe)),zv=(Er(),Ut(Mr)),$F=_l(),QBe=$A(),tHe=Bu(),eHe=XF(),Jg=Fe(),rHe=kc(),Uot=function(){function e(t,r,n){t===void 0&&(t=[]),r===void 0&&(r=0),n===void 0&&(n=1/0),this.columns=t,this.bottomPadding=r,this.maxWidth=n}return e.prototype.addColumn=function(t){var r=t.width,n=this.getWidthAvailable();t.width=Math.min(n,r),this.columns.push(t)},e.prototype.getBounds=function(t){for(var r=this.columns[t],n=0,i=0;i<t;i++)n+=this.columns[i].width;return{topLeft:{x:n,y:0},bottomRight:{x:n+r.width,y:r.height}}},e.prototype.getHeight=function(){return Jg.Math.max(this.columns.map(function(t){var r=t.height;return r}),0)+this.bottomPadding},e.prototype.getWidth=function(){return Math.min(this.columns.reduce(function(t,r){var n=r.width;return t+n},0),this.maxWidth)},e.prototype.getWidthAvailable=function(){var t=this.getWidth();return Math.max(this.maxWidth-t,0)},e}(),nHe=function(){function e(t,r,n,i){t===void 0&&(t=1/0),r===void 0&&(r=1/0),n===void 0&&(n=0),i===void 0&&(i=[]),this.maxWidth=t,this.maxHeight=r,this.padding=n,this.rows=i}return e.prototype.addRow=function(t){t.maxWidth=this.maxWidth-this.padding*2,this.rows.push(t)},e.prototype.getColumnBounds=function(t,r){var n=this.getRowBounds(t),i=this.rows[t].getBounds(r);return i.topLeft.x+=n.topLeft.x,i.bottomRight.x+=n.topLeft.x,i.topLeft.y+=n.topLeft.y,i.bottomRight.y+=n.topLeft.y,i},e.prototype.getRowBounds=function(t){for(var r=this.padding,n=this.padding,i=0;i<t;i++)n+=this.rows[i].getHeight();var o={topLeft:{x:r,y:n},bottomRight:{x:r+this.rows[t].getWidth(),y:n+this.rows[t].getHeight()}};return o},e.prototype.getHeight=function(){return Math.min(this.rows.reduce(function(t,r){return t+r.getHeight()},0)+this.padding*2,this.maxHeight)},e.prototype.getWidth=function(){return Math.min(Jg.Math.max(this.rows.map(function(t){return t.getWidth()}),0)+this.padding*2,this.maxWidth)},e}(),iHe=function(e){JBe.__extends(t,e);function t(r){var n=e.call(this)||this;if(n._padding=5,n._rowBottomPadding=3,n.addClass("legend"),n.maxEntriesPerRow(1),r==null)throw new Error("Legend requires a colorScale");return n._colorScale=r,n._redrawCallback=function(i){return n.redraw()},n._colorScale.onUpdate(n._redrawCallback),n._formatter=tHe.identity(),n.maxLinesPerEntry(1),n.xAlignment("right").yAlignment("top"),n.comparator(function(i,o){var a=n._colorScale.domain().slice().map(function(s){return n._formatter(s)});return a.indexOf(i)-a.indexOf(o)}),n._symbolFactoryAccessor=function(){return eHe.circle()},n._symbolOpacityAccessor=function(){return 1},n}return t.prototype._setup=function(){e.prototype._setup.call(this);var r=this.content().append("g").classed(t.LEGEND_ROW_CLASS,!0),n=r.append("g").classed(t.LEGEND_ENTRY_CLASS,!0);n.append("text");var i=new $F.SvgContext(r.node(),null,QBe.ADD_TITLE_ELEMENTS);this._measurer=new $F.CacheMeasurer(i),this._wrapper=new $F.Wrapper().maxLines(this.maxLinesPerEntry()),this._writer=new $F.Writer(this._measurer,i,this._wrapper)},t.prototype.formatter=function(r){return r==null?this._formatter:(this._formatter=r,this.redraw(),this)},t.prototype.maxEntriesPerRow=function(r){return r==null?this._maxEntriesPerRow:(this._maxEntriesPerRow=r,this.redraw(),this)},t.prototype.maxLinesPerEntry=function(r){return r==null?this._maxLinesPerEntry:(this._maxLinesPerEntry=r,this.redraw(),this)},t.prototype.maxWidth=function(r){return r==null?this._maxWidth:(this._maxWidth=r,this.redraw(),this)},t.prototype.comparator=function(r){return r==null?this._comparator:(this._comparator=r,this.redraw(),this)},t.prototype.colorScale=function(r){return r!=null?(this._colorScale.offUpdate(this._redrawCallback),this._colorScale=r,this._colorScale.onUpdate(this._redrawCallback),this.redraw(),this):this._colorScale},t.prototype.destroy=function(){e.prototype.destroy.call(this),this._colorScale.offUpdate(this._redrawCallback)},t.prototype._buildLegendTable=function(r,n){var i=this,o=this._measurer.measure().height,a=new nHe(r,n,this._padding),s=this._colorScale.domain().slice().sort(function(c,u){return i._comparator(i._formatter(c),i._formatter(u))}),l=new Uot;return a.addRow(l),l.bottomPadding=this._rowBottomPadding,s.forEach(function(c,u){l.columns.length/2===i.maxEntriesPerRow()&&(l=new Uot,l.bottomPadding=i._rowBottomPadding,a.addRow(l));var h=l.getWidthAvailable(),f=i._formatter(c),p=i._measurer.measure(f).width,d=h-o-p<0;d&&l.columns.length>1&&(l=new Uot,l.bottomPadding=i._rowBottomPadding,a.addRow(l));var g={width:o,height:o,data:{name:c,type:"symbol"}};l.addColumn(g),h=l.getWidthAvailable();var _=Math.min(h,p);i._wrapper.maxLines(i.maxLinesPerEntry());var y=i._wrapper.wrap(f,i._measurer,_).noLines,x=y*o,b={width:_,height:x,data:{name:c,type:"text"}};l.addColumn(b)}),a},t.prototype.requestedSpace=function(r,n){var i=this._buildLegendTable(Jg.Math.min([this.maxWidth(),r],r),n);return{minHeight:i.getHeight(),minWidth:i.getWidth()}},t.prototype.entitiesAt=function(r){var n=this;if(!this._isSetup)return[];var i=this._buildLegendTable(this.width(),this.height());return i.rows.reduce(function(o,a,s){if(o.length!==0)return o;var l=i.getRowBounds(s),c=Jg.Math.within(r,l);return c?a.columns.reduce(function(u,h,f){var p=i.getColumnBounds(s,f),d=Jg.Math.within(r,p);if(d){var g=n.content().selectAll("."+t.LEGEND_ROW_CLASS).nodes()[s],_=zv.select(g).selectAll("."+t.LEGEND_ENTRY_CLASS).nodes()[Math.floor(f/2)],y=zv.select(_).select("."+t.LEGEND_SYMBOL_CLASS),x=Jg.DOM.getTranslateValues(zv.select(g)),b=Jg.DOM.getTranslateValues(y);return[{bounds:Jg.DOM.elementBBox(zv.select(g)),datum:h.data.name,position:{x:x[0]+b[0],y:x[1]+b[1]},selection:zv.select(_),component:n}]}return u},o):o},[])},t.prototype.renderImmediately=function(){e.prototype.renderImmediately.call(this);var r=this._buildLegendTable(this.width(),this.height());this.content().selectAll("*").remove();var n=this.content().selectAll("g."+t.LEGEND_ROW_CLASS).data(r.rows),i=n.enter().append("g").classed(t.LEGEND_ROW_CLASS,!0).merge(n);n.exit().remove(),i.attr("transform",function(a,s){var l=r.getRowBounds(s);return"translate("+l.topLeft.x+", "+l.topLeft.y+")"});var o=this;return i.each(function(a,s){for(var l=[],c=0;c<a.columns.length;c+=2)l.push([a.columns[c],a.columns[c+1]]);var u=zv.select(this).selectAll("g."+t.LEGEND_ENTRY_CLASS).data(l),h=u.enter().append("g").classed(t.LEGEND_ENTRY_CLASS,!0).merge(u);h.append("path").attr("d",function(f,p){var d=f[0];return o.symbol()(d.data.name,s)(d.height*.6)(null)}).attr("transform",function(f,p){var d=f[0],g=r.rows[s].columns.indexOf(d),_=r.getColumnBounds(s,g);return"translate("+(_.topLeft.x+d.width/2)+", "+d.height/2+")"}).attr("fill",function(f){return o._colorScale.scale(f[0].data.name)}).attr("opacity",function(f,p){return o.symbolOpacity()(f[0].data.name,s)}).classed(t.LEGEND_SYMBOL_CLASS,!0),h.append("g").classed("text-container",!0).attr("transform",function(f,p){var d=f[1],g=r.rows[s].columns.indexOf(d),_=r.getColumnBounds(s,g);return"translate("+_.topLeft.x+", 0)"}).each(function(f,p,d){var g=zv.select(this),_=f[1],y={xAlign:"left",yAlign:"top",textRotation:0};o._writer.write(o._formatter(_.data.name),_.width,o.height(),y,g.node())}),u.exit().remove()}),this},t.prototype.symbol=function(r){return r==null?this._symbolFactoryAccessor:(this._symbolFactoryAccessor=r,this.render(),this)},t.prototype.symbolOpacity=function(r){return r==null?this._symbolOpacityAccessor:(typeof r=="number"?this._symbolOpacityAccessor=function(){return r}:this._symbolOpacityAccessor=r,this.render(),this)},t.prototype.fixedWidth=function(){return!0},t.prototype.fixedHeight=function(){return!0},t.prototype.invalidateCache=function(){e.prototype.invalidateCache.call(this),this._measurer.reset()},t.LEGEND_ROW_CLASS="legend-row",t.LEGEND_ENTRY_CLASS="legend-entry",t.LEGEND_SYMBOL_CLASS="legend-symbol",t}(rHe.Component);qot.Legend=iHe});var Got=H(KF=>{"use strict";Object.defineProperty(KF,"__esModule",{value:!0});var oHe;(function(e){e.MAIN="main",e.RESET="reset"})(oHe=KF.Animator||(KF.Animator={}))});var O$t=H((eGn,D$t)=>{"use strict";D$t.exports=function(t){return t!=null&&typeof t=="object"&&Array.isArray(t)===!1}});var B$t=H((rGn,F$t)=>{"use strict";var aHe=O$t();function z$t(e){return aHe(e)===!0&&Object.prototype.toString.call(e)==="[object Object]"}F$t.exports=function(t){var r,n;return!(z$t(t)===!1||(r=t.constructor,typeof r!="function")||(n=r.prototype,z$t(n)===!1)||n.hasOwnProperty("isPrototypeOf")===!1)}});var Yot=H(Wot=>{"use strict";Object.defineProperty(Wot,"__esModule",{value:!0});var sHe=Fe(),H$t=0,lHe=function(){function e(t,r){t===void 0&&(t=[]),r===void 0&&(r={}),this._updateId=H$t++,this._data=t,this._metadata=r,this._callbacks=new sHe.CallbackSet}return e.prototype.onUpdate=function(t){return this._callbacks.add(t),this},e.prototype.offUpdate=function(t){return this._callbacks.delete(t),this},e.prototype.data=function(t){return t==null?this._data:(this._data=t,this._dispatchUpdate(),this)},e.prototype.metadata=function(t){return t==null?this._metadata:(this._metadata=t,this._dispatchUpdate(),this)},e.prototype.updateId=function(){return this._updateId},e.prototype._dispatchUpdate=function(){this._updateId=H$t++,this._callbacks.callCallbacks(this)},e}();Wot.Dataset=lHe});var $ot=H(Rc=>{"use strict";Object.defineProperty(Rc,"__esModule",{value:!0});var jot=(de(),Ut(pe)),cHe=B$t(),uHe=Yot(),hHe=Lv();function Xot(e){return e instanceof p4?e:e instanceof Date?f4(e.valueOf()):e instanceof hHe.Scale?V$t(e):e instanceof uHe.Dataset?U$t(e):cHe(e)?ZF(e):Array.isArray(e)?q$t(e):f4(e)}Rc.sign=Xot;function V$t(e){var t={domain:e.domain(),range:e.range(),updateId:e.updateId(),ref:f4(e)};return ZF(t)}Rc.signScale=V$t;function U$t(e){var t={ref:f4(e),updateId:e.updateId()};return ZF(t)}Rc.signDataset=U$t;function f4(e){return new W$t(e)}Rc.signRef=f4;function q$t(e){return new G$t(e.map(function(t){return Xot(t)}))}Rc.signArray=q$t;function ZF(e){var t={};for(var r in e)e.hasOwnProperty(r)&&(t[r]=Xot(e[r]));return new Y$t(t)}Rc.signObj=ZF;var p4=function(){function e(){}return e.prototype.isDifferent=function(t){return t instanceof this.constructor?this.isSignatureDifferent(t):!0},e}();Rc.Signature=p4;var G$t=function(e){jot.__extends(t,e);function t(r){var n=e.call(this)||this;return n.array=r,n}return t.prototype.isSignatureDifferent=function(r){if(r.array.length!==this.array.length)return!0;for(var n=0;n<this.array.length;n++)if(this.array[n].isDifferent(r.array[n]))return!0;return!1},t}(p4);Rc.ArraySignature=G$t;var W$t=function(e){jot.__extends(t,e);function t(r){var n=e.call(this)||this;return n.ref=r,n}return t.prototype.isSignatureDifferent=function(r){return this.ref!==r.ref},t}(p4);Rc.ReferenceSignature=W$t;var Y$t=function(e){jot.__extends(t,e);function t(r){var n=e.call(this)||this;return n.obj=r,n}return t.prototype.isSignatureDifferent=function(r){var n=Object.keys(this.obj),i=Object.keys(r.obj);if(n.length!==i.length)return!0;for(var o=0,a=n;o<a.length;o++){var s=a[o];if(!r.obj.hasOwnProperty(s)||this.obj[s].isDifferent(r.obj[s]))return!0}return!1},t}(p4);Rc.ObjectSignature=Y$t});var j$t=H(Kot=>{"use strict";Object.defineProperty(Kot,"__esModule",{value:!0});var fHe=$ot();function pHe(e){var t=void 0,r,n=!1,i=!1,o=function(){for(var a=[],s=0;s<arguments.length;s++)a[s]=arguments[s];if(n)return r;var l=fHe.signArray(a);return t===void 0||t.isDifferent(l)?(i&&console.warn("cache miss! computing"),t=l,r=e.apply(this,a)):i&&console.warn("cache hit!"),r};return o.doLocked=function(a){if(n)throw new Error("Locking an already locked memoize function!");n=!0;var s=a.apply(this);return n=!1,s},o.logPerformance=function(a){return a===void 0&&(a=!0),i=a,this},o}Kot.memoize=pHe});var K$t=H(JF=>{"use strict";Object.defineProperty(JF,"__esModule",{value:!0});var dHe=Oe(),Zot=function(){function e(){this.map=Object.create(null),this.exists=Object.create(null)}return e.prototype.delete=function(t){return delete this.map[t],delete this.exists[t],!0},e.prototype.get=function(t){return this.map[t]},e.prototype.has=function(t){return!!this.exists[t]},e.prototype.set=function(t,r){return this.map[t]=r,this.exists[t]=!0,this},e}(),X$t=function(){function e(){this.map=new Zot}return e.prototype.get=function(t){return this.map.get(t[0]).get(t[1])},e.prototype.has=function(t){return this.map.has(t[0])&&this.map.get(t[0]).has(t[1])},e.prototype.set=function(t,r){return this.map.has(t[0])||this.map.set(t[0],new Zot),this.map.get(t[0]).set(t[1],r),this},e.prototype.delete=function(t){return this.map.has(t[0])&&this.map.get(t[0]).delete(t[1]),!0},e.prototype.clear=function(){this.map=new Zot},e.resolver=function(t,r,n){return[n.updateId(),r]},e}();function $$t(e){var t=dHe.memoize(e,X$t.resolver);return t.cache=new X$t,t}JF.memoizeProjector=$$t;function mHe(e){return Object.keys(e).forEach(function(t){e[t]=$$t(e[t])}),e}JF.memoizeProjectors=mHe});var Z$t=H(Jot=>{"use strict";Object.defineProperty(Jot,"__esModule",{value:!0});var gHe=CS();function _He(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=e.slice(0,-1),n=e[e.length-1],i=gHe.memoize(n),o=function(){var a=this,s=r.map(function(l){return l.apply(a)});return i.apply(void 0,s)};return o}Jot.memThunk=_He});var CS=H(AS=>{"use strict";Object.defineProperty(AS,"__esModule",{value:!0});var Qot=(de(),Ut(pe));Qot.__exportStar(j$t(),AS);Qot.__exportStar(K$t(),AS);Qot.__exportStar(Z$t(),AS);var yHe=$ot();AS.sign=yHe.sign});var Fv=H(Nc=>{"use strict";Object.defineProperty(Nc,"__esModule",{value:!0});var J$t=(Er(),Ut(Mr)),vHe=function(){function e(t,r){this._context=t,this._drawStep=r}return e.prototype.getDrawStep=function(){return this._drawStep},e.prototype.draw=function(t,r){var n=r[r.length-1].attrToAppliedProjector;this._context.save(),this._drawStep(this._context,t,n),this._context.restore()},e.prototype.getVisualPrimitives=function(){return[]},e.prototype.getVisualPrimitiveAtIndex=function(t){return null},e.prototype.remove=function(){},e}();Nc.CanvasDrawer=vHe;Nc.ContextStyleAttrs=["fill-opacity","fill","opacity","stroke-opacity","stroke-width","stroke","stroke-dasharray"];function xHe(e,t,r,n){var i=Nc.ContextStyleAttrs.concat(t);return Q$t(e,i,r,n)}Nc.resolveAttributesSubsetWithStyles=xHe;function Q$t(e,t,r,n){for(var i={},o=0,a=t;o<a.length;o++){var s=a[o];e.hasOwnProperty(s)&&(i[s]=e[s](r,n))}return i}Nc.resolveAttributes=Q$t;function bHe(e){var t=e.opacity!=null?parseFloat(e.opacity):1,r=e["stroke-opacity"]!=null?parseFloat(e["stroke-opacity"]):1;return r*t}function wHe(e){var t=e.opacity!=null?parseFloat(e.opacity):1,r=e["fill-opacity"]!=null?parseFloat(e["fill-opacity"]):1;return r*t}function tKt(e){return e["stroke-width"]!=null?parseFloat(e["stroke-width"]):1}Nc.getStrokeWidth=tKt;function eKt(e){var t=e["stroke-dasharray"];if(t!=null)try{return t.split(/[ ,]+/).map(function(r){return parseInt(r,10)})}catch(r){return console.error("getStrokeDashArray failed with: "+r),[]}return[]}Nc.getStrokeDashArray=eKt;function SHe(e,t,r,n){e.save(),e.beginPath(),t.context(e),t(r),e.lineJoin="round",tat(e,n),e.restore()}Nc.renderArea=SHe;function MHe(e,t,r,n){e.save(),e.beginPath(),t.context(e),t(r),e.lineJoin="round",tat(e,n),e.restore()}Nc.renderLine=MHe;function tat(e,t){if(t.stroke){e.lineWidth=tKt(t);var r=J$t.color(t.stroke),n=eKt(t);e.setLineDash(n),r.opacity*=bHe(t),e.strokeStyle=r.toString(),e.stroke()}if(t.fill){var i=J$t.color(t.fill);i.opacity*=wHe(t),e.fillStyle=i.toString(),e.fill()}}Nc.renderPathWithStyle=tat});var Uu=H(eat=>{"use strict";Object.defineProperty(eat,"__esModule",{value:!0});var EHe=function(){function e(t,r){this._svgDrawerFactory=t,this._canvasDrawerFactory=r}return e.prototype.useSVG=function(t){this._currentDrawer!=null&&this._currentDrawer.remove();var r=this._svgDrawerFactory();r.attachTo(t),this._currentDrawer=r},e.prototype.useCanvas=function(t){this._currentDrawer!=null&&this._currentDrawer.remove(),this._currentDrawer=this._canvasDrawerFactory(t.node().getContext("2d"))},e.prototype.getDrawer=function(){return this._currentDrawer},e.prototype.remove=function(){this._currentDrawer!=null&&this._currentDrawer.remove()},e.prototype.draw=function(t,r){this._currentDrawer.draw(t,r)},e.prototype.getVisualPrimitives=function(){return this._currentDrawer.getVisualPrimitives()},e.prototype.getVisualPrimitiveAtIndex=function(t){return this._currentDrawer.getVisualPrimitiveAtIndex(t)},e}();eat.ProxyDrawer=EHe});var Df=H(rat=>{"use strict";Object.defineProperty(rat,"__esModule",{value:!0});var THe=(Er(),Ut(Mr)),rKt=Fe(),CHe=function(){function e(t,r){this._root=THe.select(document.createElementNS("http://www.w3.org/2000/svg","g")),this._className=r,this._svgElementName=t}return e.prototype.draw=function(t,r){var n=this;this._createAndDestroyDOMElements(t);for(var i=0,o=r.length,a=function(l){var c=r[l];rKt.Window.setTimeout(function(){return n._drawStep(c)},i),i+=c.animator.totalTime(t.length)},s=0;s<o;s++)a(s)},e.prototype.getVisualPrimitives=function(){return this._cachedVisualPrimitivesNodes==null&&(this._cachedVisualPrimitivesNodes=this._selection.nodes()),this._cachedVisualPrimitivesNodes},e.prototype.getVisualPrimitiveAtIndex=function(t){return this._cachedVisualPrimitivesNodeMap==null?null:this._cachedVisualPrimitivesNodeMap.get(t)},e.prototype.remove=function(){this._root.remove()},e.prototype.attachTo=function(t){t.node().appendChild(this._root.node())},e.prototype.getRoot=function(){return this._root},e.prototype.selector=function(){return this._svgElementName},e.prototype._applyDefaultAttributes=function(t){},e.prototype._createAndDestroyDOMElements=function(t){var r=t.map(function(a,s){return a!=null?{d:a,i:s}:null}),n=r.filter(function(a){return a!=null}),i=this._root.selectAll(this.selector()).data(n);this._selection=i.enter().append(this._svgElementName).merge(i),i.exit().remove();var o=new rKt.Map;this._selection.each(function(a){o.set(a.i,this)}),this._cachedVisualPrimitivesNodeMap=o,this._cachedVisualPrimitivesNodes=null,this._selection.data(this._selection.data().map(function(a){var s=a.d;return s})),this._className!=null&&this._selection.classed(this._className,!0),this._applyDefaultAttributes(this._selection)},e.prototype._drawStep=function(t){var r=this,n=["fill","stroke"];n.forEach(function(i){t.attrToAppliedProjector[i]!=null&&r._selection.attr(i,t.attrToAppliedProjector[i])}),t.animator.animate(this._selection,t.attrToAppliedProjector),this._className!=null&&this._selection.classed(this._className,!0)},e}();rat.SVGDrawer=CHe});var iat=H(nat=>{"use strict";Object.defineProperty(nat,"__esModule",{value:!0});var nKt=function(){function e(){var t=this;this.scale=0,this.translate=0,this.cachedDomain=[null,null],this.lastSeenDomain=[null,null],this.updateDomain=function(r){t.lastSeenDomain=r.getTransformationDomain();var n=r.scaleTransformation(t.cachedDomain[1])-r.scaleTransformation(t.cachedDomain[0]),i=r.scaleTransformation(t.lastSeenDomain[1])-r.scaleTransformation(t.lastSeenDomain[0]);t.scale=n/i||1,t.translate=r.scaleTransformation(t.cachedDomain[0])-r.scaleTransformation(t.lastSeenDomain[0])*t.scale||0}}return e.prototype.reset=function(){this.scale=1,this.translate=0,this.cachedDomain=this.lastSeenDomain},e.prototype.setDomain=function(t){this.cachedDomain=t.getTransformationDomain()},e}(),AHe=function(){function e(t,r){var n=this;this.renderCallback=t,this.applyTransformCallback=r,this.domainTransformX=new nKt,this.domainTransformY=new nKt,this.renderDeferred=function(){n.applyTransform(),clearTimeout(n.timeoutToken),n.timeoutToken=setTimeout(function(){n.renderCallback()},e.DEFERRED_RENDERING_DELAY)}}return e.prototype.setDomains=function(t,r){t&&this.domainTransformX.setDomain(t),r&&this.domainTransformY.setDomain(r),this.renderDeferred()},e.prototype.updateDomains=function(t,r){t&&this.domainTransformX.updateDomain(t),r&&this.domainTransformY.updateDomain(r),this.renderDeferred()},e.prototype.resetTransforms=function(){this.domainTransformX.reset(),this.domainTransformY.reset(),this.applyTransform()},e.prototype.applyTransform=function(){this.applyTransformCallback(this.domainTransformX.translate,this.domainTransformY.translate,this.domainTransformX.scale,this.domainTransformY.scale)},e.DEFERRED_RENDERING_DELAY=200,e}();nat.DeferredRenderer=AHe});var rs=H(QF=>{"use strict";Object.defineProperty(QF,"__esModule",{value:!0});var PHe=(de(),Ut(pe)),wd=(Er(),Ut(Mr)),d4=Lf(),Sd=Fe(),iKt=Got(),oat=CS(),IHe=kc(),LHe=Fv(),kHe=Uu(),RHe=Df(),NHe=Yg(),DHe=If(),OHe=iat();QF.Renderer=DHe.makeEnum(["svg","canvas"]);var zHe=function(e){PHe.__extends(t,e);function t(){var r=e.call(this)||this;r._dataChanged=!1,r._attrExtents={},r._animate=!1,r._animators={},r._propertyExtents={},r._resetEntityStore=function(){r._cachedEntityStore=void 0},r._overflowHidden=!0,r.addClass("plot"),r._datasetToDrawer=new Sd.Map,r._attrBindings=wd.map(),r._includedValuesProvider=function(i,o){return r._includedValuesForScale(i,o)},r._renderCallback=function(){return r.render()},r._onDatasetUpdateCallback=function(){return r._onDatasetUpdate()},r._propertyBindings=wd.map();var n=new d4.Easing().maxTotalDuration(t._ANIMATION_MAX_DURATION);return r.animator(iKt.Animator.MAIN,n),r.animator(iKt.Animator.RESET,new d4.Null),r._deferredResetEntityStore=Sd.Window.debounce(OHe.DeferredRenderer.DEFERRED_RENDERING_DELAY,r._resetEntityStore),r}return t.getTotalDrawTime=function(r,n){return n.reduce(function(i,o){return i+o.animator.totalTime(r.length)},0)},t.applyDrawSteps=function(r,n){var i=r.map(function(o){var a=o.attrToProjector,s={};return Object.keys(a).forEach(function(l){s[l]=function(c,u){return a[l](c,u,n)}}),{attrToAppliedProjector:s,animator:o.animator}});return i},t.prototype.anchor=function(r){return r=NHe.coerceExternalD3(r),e.prototype.anchor.call(this,r),this._dataChanged=!0,this._resetEntityStore(),this._updateExtents(),this},t.prototype._setup=function(){var r=this;this._isSetup||(e.prototype._setup.call(this),this._canvas!=null&&this._appendCanvasNode(),this._renderArea=this.content().append("g").classed("render-area",!0),this.datasets().forEach(function(n){return r._createNodesForDataset(n)}))},t.prototype._appendCanvasNode=function(){var r=this.element().select(".plot-canvas-container");r.empty()&&(r=this.element().append("div").classed("plot-canvas-container",!0),r.node().appendChild(this._canvas.node()))},t.prototype.setBounds=function(r,n,i,o){if(e.prototype.setBounds.call(this,r,n,i,o),this._updateExtents(),this._canvas!=null){if(this._bufferCanvas&&!this._bufferCanvasValid){this._bufferCanvas.attr("width",this._canvas.attr("width")),this._bufferCanvas.attr("height",this._canvas.attr("height"));var a=this._bufferCanvas.node().getContext("2d");if(a){var s=this._canvas.node();s.width>0&&s.height>0?a.canvas.width>0&&a.canvas.height>0&&a.drawImage(s,0,0):console.warn("Failed to fill buffer canvas with with 0x0 canvas")}this._bufferCanvasValid=!0}var l=window.devicePixelRatio!=null?window.devicePixelRatio:1;this._canvas.attr("width",r*l),this._canvas.attr("height",n*l);var c=this._canvas.node().getContext("2d");if(c&&(c.setTransform(l,0,0,l,0,0),this._bufferCanvas)){var u=this._bufferCanvas.node();u.width>0&&u.height>0?c.canvas.width>0&&c.canvas.height>0&&c.drawImage(u,0,0,r,n):console.warn("Failed to fill canvas with 0x0 buffer canvas")}}return this},t.prototype.destroy=function(){var r=this;e.prototype.destroy.call(this),this._scales().forEach(function(n){return n.offUpdate(r._renderCallback)}),this.datasets([])},t.prototype._createNodesForDataset=function(r){var n=this._datasetToDrawer.get(r);return this.renderer()==="svg"?n.useSVG(this._renderArea):n.useCanvas(this._canvas),n},t.prototype._createDrawer=function(r){return new kHe.ProxyDrawer(function(){return new RHe.SVGDrawer("path","")},function(n){return new LHe.CanvasDrawer(n,function(){})})},t.prototype._getAnimator=function(r){return this._animateOnNextRender()?this._animators[r]||new d4.Null:new d4.Null},t.prototype._onDatasetUpdate=function(){this._updateExtents(),this._dataChanged=!0,this._resetEntityStore(),this.renderLowPriority()},t.prototype.attr=function(r,n,i){return n==null?this._attrBindings.get(r):(this._bindAttr(r,n,i),this.render(),this)},t.prototype._bindProperty=function(r,n,i,o){var a=this._propertyBindings.get(r),s=a!=null?a.scale:null,l=typeof n=="function"?n:function(){return n};this._propertyBindings.set(r,{accessor:l,scale:i,postScale:o}),s!=null&&this._uninstallScaleForKey(s,r),i!=null&&this._installScaleForKey(i,r),this._clearAttrToProjectorCache()},t.prototype._bindAttr=function(r,n,i){var o=this._attrBindings.get(r),a=o!=null?o.scale:null,s=typeof n=="function"?n:function(){return n};this._attrBindings.set(r,{accessor:s,scale:i}),a!=null&&this._uninstallScaleForKey(a,r),i!=null&&this._installScaleForKey(i,r),this._clearAttrToProjectorCache()},t.prototype._clearAttrToProjectorCache=function(){delete this._cachedAttrToProjector},t.prototype._getAttrToProjector=function(){if(this._cachedAttrToProjector==null){var r=this._generateAttrToProjector();t.OPTIMIZE_MEMOIZE_PROJECTORS&&(r=oat.memoizeProjectors(r)),this._cachedAttrToProjector=r}return Sd.assign({},this._cachedAttrToProjector)},t.prototype._generateAttrToProjector=function(){var r={};this._attrBindings.each(function(i,o){r[o]=t._scaledAccessor(i)});var n=this._propertyProjectors();return Object.keys(n).forEach(function(i){r[i]==null&&(r[i]=n[i])}),r},t.prototype.renderImmediately=function(){return e.prototype.renderImmediately.call(this),this._isAnchored&&(this._paint(),this._dataChanged=!1),this},t.prototype.renderLowPriority=function(){return this._renderCallback(),this},t.prototype.animated=function(r){return r==null?this._animate:(this._animate=r,this)},t.prototype.detach=function(){return e.prototype.detach.call(this),this._updateExtents(),this},t.prototype._scales=function(){var r=[];return this._attrBindings.each(function(n,i){var o=n.scale;o!=null&&r.indexOf(o)===-1&&r.push(o)}),this._propertyBindings.each(function(n,i){var o=n.scale;o!=null&&r.indexOf(o)===-1&&r.push(o)}),r},t.prototype._updateExtents=function(){var r=this;this._resetEntityStore(),this._scales().forEach(function(n){return n.addIncludedValuesProvider(r._includedValuesProvider)})},t.prototype._filterForProperty=function(r){return null},t.prototype.getExtentsForAttr=function(r){var n=this;if(this._attrExtents[r]==null){var i=oat.memThunk(function(){return n.datasets()},function(){return n._attrBindings.get(r)},function(o,a){return a==null||a.accessor==null?null:o.map(function(s){return oKt(s,a,null)})});this._attrExtents[r]=i}return this._attrExtents[r]()},t.prototype.getExtentsForProperty=function(r){var n=this;if(this._propertyExtents[r]==null){var i=oat.memThunk(function(){return n.datasets()},function(){return n._propertyBindings.get(r)},function(){return n._filterForProperty(r)},function(o,a,s){return a==null||a.accessor==null?null:o.map(function(l){return oKt(l,a,s)})});this._propertyExtents[r]=i}return this._propertyExtents[r]()},t.prototype._includedValuesForScale=function(r,n){var i=this;if(!this._isAnchored&&!n)return[];var o=[];return this._attrBindings.each(function(a,s){if(a.scale===r){var l=i.getExtentsForAttr(s);l!=null&&(o=o.concat(wd.merge(l)))}}),this._propertyBindings.each(function(a,s){if(a.scale===r){var l=i.getExtentsForProperty(s);l!=null&&(o=o.concat(wd.merge(l)))}}),o},t.prototype.animator=function(r,n){return n===void 0?this._animators[r]:(this._animators[r]=n,this)},t.prototype.renderer=function(r){var n=this;return r===void 0?this._canvas==null?"svg":"canvas":(this._canvas==null&&r==="canvas"?(this._canvas=wd.select(document.createElement("canvas")).classed("plot-canvas",!0),this._bufferCanvas=wd.select(document.createElement("canvas")),this.element()!=null&&this._appendCanvasNode(),this._datasetToDrawer.forEach(function(i){i.useCanvas(n._canvas)}),this.render()):this._canvas!=null&&r=="svg"&&(this._canvas.remove(),this._canvas=null,this._bufferCanvas=null,this._datasetToDrawer.forEach(function(i){i.useSVG(n._renderArea)}),this.render()),this)},t.prototype.addDataset=function(r){return this._addDataset(r),this._onDatasetUpdate(),this},t.prototype._addDataset=function(r){this._removeDataset(r);var n=this._createDrawer(r);return this._datasetToDrawer.set(r,n),this._isSetup&&this._createNodesForDataset(r),r.onUpdate(this._onDatasetUpdateCallback),this},t.prototype.removeDataset=function(r){return this._removeDataset(r),this._onDatasetUpdate(),this},t.prototype._removeDataset=function(r){return this.datasets().indexOf(r)===-1?this:(this._removeDatasetNodes(r),r.offUpdate(this._onDatasetUpdateCallback),this._datasetToDrawer.delete(r),this)},t.prototype._removeDatasetNodes=function(r){var n=this._datasetToDrawer.get(r);n.remove()},t.prototype.datasets=function(r){var n=this,i=[];return this._datasetToDrawer.forEach(function(o,a){return i.push(a)}),r==null?i:(i.forEach(function(o){return n._removeDataset(o)}),r.forEach(function(o){return n._addDataset(o)}),this._onDatasetUpdate(),this)},t.prototype._generateDrawSteps=function(){return[{attrToProjector:this._getAttrToProjector(),animator:new d4.Null}]},t.prototype._additionalPaint=function(r){},t.prototype._buildLightweightPlotEntities=function(r){var n=this,i=[];return r.forEach(function(o,a){for(var s=n._datasetToDrawer.get(o),l=0,c=o.data(),u=c.length,h=function(p){var d=c[p],g=n._pixelPoint(d,p,o);if(Sd.Math.isNaN(g.x)||Sd.Math.isNaN(g.y))return"continue";var _=n;i.push({datum:d,get position(){return _._pixelPoint.call(_,d,p,o)},index:p,dataset:o,datasetIndex:a,component:n,drawer:s,validDatumIndex:l}),l++},f=0;f<u;f++)h(f)}),i},t.prototype._getDataToDraw=function(){var r=new Sd.Map;return this.datasets().forEach(function(n){return r.set(n,n.data())}),r},t.prototype._paint=function(){var r=this;delete this._cachedAttrToProjector;var n=this._generateDrawSteps(),i=this._getDataToDraw(),o=this.datasets().map(function(u){return r._datasetToDrawer.get(u)});if(this.renderer()==="canvas"){var a=this._canvas.node(),s=a.getContext("2d");s.clearRect(0,0,a.clientWidth,a.clientHeight),this._bufferCanvasValid=!1}this.datasets().forEach(function(u,h){var f=t.applyDrawSteps(n,u);o[h].draw(i.get(u),f)});var l=this.datasets().map(function(u,h){return t.getTotalDrawTime(i.get(u),n)}),c=Sd.Math.max(l,0);this._additionalPaint(c)},t.prototype.selections=function(r){var n=this;if(r===void 0&&(r=this.datasets()),this.renderer()==="canvas")return wd.selectAll();var i=[];return r.forEach(function(o){var a=n._datasetToDrawer.get(o);if(a!=null){var s=a.getVisualPrimitives();i.push.apply(i,s)}}),wd.selectAll(i)},t.prototype.entities=function(r){var n=this;return this._getEntityStore(r).entities().map(function(i){return n._lightweightPlotEntityToPlotEntity(i)})},t.prototype.filterEntities=function(r){var n=this;return this._getEntityStore().entities().filter(r).map(function(i){return n._lightweightPlotEntityToPlotEntity(i)})},t.prototype._getEntityStore=function(r){var n=this,i=function(a){return n._entityBounds(a)};if(r!==void 0){var o=new Sd.EntityStore;return o.addAll(this._buildLightweightPlotEntities(r),i,this._localOriginBounds()),o}else if(this._cachedEntityStore===void 0){var o=new Sd.EntityStore;o.addAll(this._buildLightweightPlotEntities(this.datasets()),i,this._localOriginBounds()),this._cachedEntityStore=o}return this._cachedEntityStore},t.prototype._localOriginBounds=function(){return{topLeft:{x:0,y:0},bottomRight:{x:this.width(),y:this.height()}}},t.prototype._entityBounds=function(r){var n=r.datum,i=r.index,o=r.dataset,a=this._pixelPoint(n,i,o),s=a.x,l=a.y;return{x:s,y:l,width:0,height:0}},t.prototype._lightweightPlotEntityToPlotEntity=function(r){var n={bounds:this._entityBounds(r),component:r.component,dataset:r.dataset,datasetIndex:r.datasetIndex,datum:r.datum,index:r.index,position:r.position,selection:wd.select(r.drawer.getVisualPrimitiveAtIndex(r.validDatumIndex))};return n},t.prototype.entitiesAt=function(r){throw new Error("plots must implement entitiesAt")},t.prototype.entityNearest=function(r){var n=this._getEntityStore().entityNearest(r);return n===void 0?void 0:this._lightweightPlotEntityToPlotEntity(n)},t.prototype.entitiesIn=function(r,n){var i;if(n==null){var o=r;i={x:o.topLeft.x,y:o.topLeft.y,width:o.bottomRight.x-o.topLeft.x,height:o.bottomRight.y-o.topLeft.y}}else{var a=r;i={x:a.min,y:n.min,width:a.max-a.min,height:n.max-n.min}}return this.entitiesInBounds(i)},t.prototype.entitiesInBounds=function(r){var n=this,i=this._getEntityStore().entitiesInBounds(r);if(!!i)return i.map(function(o){return n._lightweightPlotEntityToPlotEntity(o)})},t.prototype.entitiesInXBounds=function(r){var n=this,i=this._getEntityStore().entitiesInXBounds(r);if(!!i)return i.map(function(o){return n._lightweightPlotEntityToPlotEntity(o)})},t.prototype.entitiesInYBounds=function(r){var n=this,i=this._getEntityStore().entitiesInYBounds(r);if(!!i)return i.map(function(o){return n._lightweightPlotEntityToPlotEntity(o)})},t.prototype._uninstallScaleForKey=function(r,n){r.offUpdate(this._renderCallback),r.offUpdate(this._deferredResetEntityStore),r.removeIncludedValuesProvider(this._includedValuesProvider)},t.prototype._installScaleForKey=function(r,n){r.onUpdate(this._renderCallback),r.onUpdate(this._deferredResetEntityStore),r.addIncludedValuesProvider(this._includedValuesProvider)},t.prototype._propertyProjectors=function(){return{}},t._scaledAccessor=function(r){var n=r.scale,i=r.accessor,o=r.postScale,a=n==null?i:function(l,c,u){return n.scale(i(l,c,u))},s=o==null?a:function(l,c,u){return o(a(l,c,u),l,c,u)};return s},t.prototype._pixelPoint=function(r,n,i){return{x:0,y:0}},t.prototype._animateOnNextRender=function(){return this._animate&&this._dataChanged},t.OPTIMIZE_MEMOIZE_PROJECTORS=!1,t._ANIMATION_MAX_DURATION=600,t}(IHe.Component);QF.Plot=zHe;function oKt(e,t,r){var n=t.accessor,i=t.scale;if(i==null)return[];var o=e.data();r!=null&&(o=o.filter(function(l,c){return r(l,c,e)}));var a=function(l,c){return n(l,c,e)},s=o.map(a);return i.extentOfValues(s)}});var aKt=H(aat=>{"use strict";Object.defineProperty(aat,"__esModule",{value:!0});var FHe=(de(),Ut(pe)),BHe=rs(),HHe=Fe(),VHe=zot(),UHe=function(e){FHe.__extends(t,e);function t(){return e!==null&&e.apply(this,arguments)||this}return t.prototype.entityNearest=function(r){var n,i=1/0;return this.components().forEach(function(o){var a=o,s=a.entityNearest(r);if(s!=null){var l=HHe.Math.distanceSquared(s.position,r);l<=i&&(i=l,n=s)}}),n},t.prototype.append=function(r){if(r!=null&&!(r instanceof BHe.Plot))throw new Error("Plot Group only accepts plots");return e.prototype.append.call(this,r),this},t}(VHe.Group);aat.PlotGroup=UHe});var sKt=H(sat=>{"use strict";Object.defineProperty(sat,"__esModule",{value:!0});var qHe=(de(),Ut(pe)),qu=(Er(),Ut(Mr)),Go=Fe(),GHe=WF(),WHe=function(e){qHe.__extends(t,e);function t(r){r===void 0&&(r=[]);var n=e.call(this)||this;return n._rowPadding=0,n._columnPadding=0,n._rows=[],n._rowWeights=[],n._columnWeights=[],n._nRows=0,n._nCols=0,n._calculatedLayout=null,n.addClass("table"),r.forEach(function(i,o){i.forEach(function(a,s){a!=null&&n.add(a,o,s)})}),n}return t.prototype._forEach=function(r){for(var n=0;n<this._nRows;n++)for(var i=0;i<this._nCols;i++)this._rows[n][i]!=null&&r(this._rows[n][i])},t.prototype.has=function(r){for(var n=0;n<this._nRows;n++)for(var i=0;i<this._nCols;i++)if(this._rows[n][i]===r)return!0;return!1},t.prototype.componentAt=function(r,n){return r<0||r>=this._nRows||n<0||n>=this._nCols?null:this._rows[r][n]},t.prototype.add=function(r,n,i){if(r==null)throw Error("Cannot add null to a table cell");if(!this.has(r)){var o=this._rows[n]&&this._rows[n][i];if(o!=null)throw new Error("cell is occupied");r.detach(),this._nRows=Math.max(n+1,this._nRows),this._nCols=Math.max(i+1,this._nCols),this._padTableToSize(this._nRows,this._nCols),this._rows[n][i]=r,this._adoptAndAnchor(r),this.redraw()}return this},t.prototype._remove=function(r){for(var n=0;n<this._nRows;n++)for(var i=0;i<this._nCols;i++)if(this._rows[n][i]===r)return this._rows[n][i]=null,!0;return!1},t.prototype._iterateLayout=function(r,n,i){i===void 0&&(i=!1);for(var o=this._rows,a=qu.transpose(this._rows),s=r-this._columnPadding*(this._nCols-1),l=n-this._rowPadding*(this._nRows-1),c=t._calcComponentWeights(this._rowWeights,o,function(z){return z==null||z.fixedHeight()}),u=t._calcComponentWeights(this._columnWeights,a,function(z){return z==null||z.fixedWidth()}),h=u.map(function(z){return z===0?.5:z}),f=c.map(function(z){return z===0?.5:z}),p=t._calcProportionalSpace(h,s),d=t._calcProportionalSpace(f,l),g=Go.Array.createFilledArray(0,this._nCols),_=Go.Array.createFilledArray(0,this._nRows),y,x,b=0,S,C,P;;){var k=Go.Array.add(_,d),O=Go.Array.add(g,p);S=this._determineGuarantees(O,k,i),g=S.guaranteedWidths,_=S.guaranteedHeights,C=S.wantsWidthArr.some(function(z){return z}),P=S.wantsHeightArr.some(function(z){return z});var D=y,B=x;y=s-qu.sum(S.guaranteedWidths),x=l-qu.sum(S.guaranteedHeights);var I=void 0;C?(I=S.wantsWidthArr.map(function(z){return z?.1:0}),I=Go.Array.add(I,u)):I=u;var L=void 0;P?(L=S.wantsHeightArr.map(function(z){return z?.1:0}),L=Go.Array.add(L,c)):L=c,p=t._calcProportionalSpace(I,y),d=t._calcProportionalSpace(L,x),b++;var R=y>0&&y!==D,F=x>0&&x!==B;if(!(R||F)||b>5)break}return y=s-qu.sum(S.guaranteedWidths),x=l-qu.sum(S.guaranteedHeights),p=t._calcProportionalSpace(u,y),d=t._calcProportionalSpace(c,x),{colProportionalSpace:p,rowProportionalSpace:d,guaranteedWidths:S.guaranteedWidths,guaranteedHeights:S.guaranteedHeights,wantsWidth:C,wantsHeight:P}},t.prototype._determineGuarantees=function(r,n,i){i===void 0&&(i=!1);var o=Go.Array.createFilledArray(0,this._nCols),a=Go.Array.createFilledArray(0,this._nRows),s=Go.Array.createFilledArray(!1,this._nCols),l=Go.Array.createFilledArray(!1,this._nRows);return this._rows.forEach(function(c,u){c.forEach(function(h,f){var p;h!=null?p=h.requestedSpace(r[f],n[u]):p={minWidth:0,minHeight:0};var d=i?Math.min(p.minWidth,r[f]):p.minWidth;o[f]=Math.max(o[f],d);var g=i?Math.min(p.minHeight,n[u]):p.minHeight;a[u]=Math.max(a[u],g);var _=p.minWidth>r[f];s[f]=s[f]||_;var y=p.minHeight>n[u];l[u]=l[u]||y})}),{guaranteedWidths:o,guaranteedHeights:a,wantsWidthArr:s,wantsHeightArr:l}},t.prototype.requestedSpace=function(r,n){return this._calculatedLayout=this._iterateLayout(r,n),{minWidth:qu.sum(this._calculatedLayout.guaranteedWidths),minHeight:qu.sum(this._calculatedLayout.guaranteedHeights)}},t.prototype.computeLayout=function(r,n,i){var o=this;e.prototype.computeLayout.call(this,r,n,i);var a=qu.sum(this._calculatedLayout.guaranteedWidths),s=qu.sum(this._calculatedLayout.guaranteedHeights),l=this._calculatedLayout;(a>this.width()||s>this.height())&&(l=this._iterateLayout(this.width(),this.height(),!0));var c=0,u=Go.Array.add(l.rowProportionalSpace,l.guaranteedHeights),h=Go.Array.add(l.colProportionalSpace,l.guaranteedWidths);return this._rows.forEach(function(f,p){var d=0;f.forEach(function(g,_){g!=null&&g.computeLayout({x:d,y:c},h[_],u[p]),d+=h[_]+o._columnPadding}),c+=u[p]+o._rowPadding}),this},t.prototype.rowPadding=function(r){if(r==null)return this._rowPadding;if(!Go.Math.isValidNumber(r)||r<0)throw Error("rowPadding must be a non-negative finite value");return this._rowPadding=r,this.redraw(),this},t.prototype.columnPadding=function(r){if(r==null)return this._columnPadding;if(!Go.Math.isValidNumber(r)||r<0)throw Error("columnPadding must be a non-negative finite value");return this._columnPadding=r,this.redraw(),this},t.prototype.rowWeight=function(r,n){if(n==null)return this._rowWeights[r];if(!Go.Math.isValidNumber(n)||n<0)throw Error("rowWeight must be a non-negative finite value");return this._rowWeights[r]=n,this.redraw(),this},t.prototype.columnWeight=function(r,n){if(n==null)return this._columnWeights[r];if(!Go.Math.isValidNumber(n)||n<0)throw Error("columnWeight must be a non-negative finite value");return this._columnWeights[r]=n,this.redraw(),this},t.prototype.fixedWidth=function(){var r=qu.transpose(this._rows);return t._fixedSpace(r,function(n){return n==null||n.fixedWidth()})},t.prototype.fixedHeight=function(){return t._fixedSpace(this._rows,function(r){return r==null||r.fixedHeight()})},t.prototype._padTableToSize=function(r,n){for(var i=0;i<r;i++){this._rows[i]===void 0&&(this._rows[i]=[],this._rowWeights[i]=null);for(var o=0;o<n;o++)this._rows[i][o]===void 0&&(this._rows[i][o]=null)}for(var o=0;o<n;o++)this._columnWeights[o]===void 0&&(this._columnWeights[o]=null)},t._calcComponentWeights=function(r,n,i){return r.map(function(o,a){if(o!=null)return o;var s=n[a].map(i),l=s.reduce(function(c,u){return c&&u},!0);return l?0:1})},t._calcProportionalSpace=function(r,n){var i=qu.sum(r);return i===0?Go.Array.createFilledArray(0,r.length):r.map(function(o){return n*o/i})},t._fixedSpace=function(r,n){var i=function(a){return a.reduce(function(s,l){return s&&l},!0)},o=function(a){return i(a.map(n))};return i(r.map(o))},t}(GHe.ComponentContainer);sat.Table=WHe});var lKt=H(lat=>{"use strict";Object.defineProperty(lat,"__esModule",{value:!0});var YHe=(de(),Ut(pe)),jHe=Vot(),XHe=2,$He=function(e){YHe.__extends(t,e);function t(){var r=e!==null&&e.apply(this,arguments)||this;return r._maxLines=XHe,r}return t.prototype.requestedSpace=function(r,n){this._wrapper.maxLines(this._maxLines);var i=this.angle()===0?r:n;i===0&&(i=1/0);var o=this._wrapper.wrap(this._text,this._measurer,i),a=this._measurer.measure(o.wrappedText),s=(this.angle()===0?a.width:a.height)+2*this.padding(),l=(this.angle()===0?a.height:a.width)+2*this.padding();return{minWidth:s,minHeight:l}},t.prototype.maxLines=function(r){return arguments.length===0?this._maxLines:(this._maxLines=r,this.redraw(),this)},t}(jHe.Label);lat.WrappedLabel=$He});var cKt=H(cat=>{"use strict";Object.defineProperty(cat,"__esModule",{value:!0});var KHe=(de(),Ut(pe)),ZHe=qF(),JHe=function(e){KHe.__extends(t,e);function t(){var r=e.call(this)||this;return r.addClass("x-drag-box-layer"),r._hasCorners=!1,r}return t.prototype.computeLayout=function(r,n,i){return e.prototype.computeLayout.call(this,r,n,i),this._setBounds(this.bounds()),this},t.prototype._setBounds=function(r){e.prototype._setBounds.call(this,{topLeft:{x:r.topLeft.x,y:0},bottomRight:{x:r.bottomRight.x,y:this.height()}})},t.prototype._setResizableClasses=function(r){r&&this.enabled()?this.addClass("x-resizable"):this.removeClass("x-resizable")},t.prototype.yScale=function(r){if(r==null)return e.prototype.yScale.call(this);throw new Error("yScales cannot be set on an XDragBoxLayer")},t.prototype.yExtent=function(r){if(r==null)return e.prototype.yExtent.call(this);throw new Error("XDragBoxLayer has no yExtent")},t}(ZHe.DragBoxLayer);cat.XDragBoxLayer=JHe});var uKt=H(uat=>{"use strict";Object.defineProperty(uat,"__esModule",{value:!0});var QHe=(de(),Ut(pe)),tVe=qF(),eVe=function(e){QHe.__extends(t,e);function t(){var r=e.call(this)||this;return r.addClass("y-drag-box-layer"),r._hasCorners=!1,r}return t.prototype.computeLayout=function(r,n,i){return e.prototype.computeLayout.call(this,r,n,i),this._setBounds(this.bounds()),this},t.prototype._setBounds=function(r){e.prototype._setBounds.call(this,{topLeft:{x:0,y:r.topLeft.y},bottomRight:{x:this.width(),y:r.bottomRight.y}})},t.prototype._setResizableClasses=function(r){r&&this.enabled()?this.addClass("y-resizable"):this.removeClass("y-resizable")},t.prototype.xScale=function(r){if(r==null)return e.prototype.xScale.call(this);throw new Error("xScales cannot be set on an YDragBoxLayer")},t.prototype.xExtent=function(r){if(r==null)return e.prototype.xExtent.call(this);throw new Error("YDragBoxLayer has no xExtent")},t}(tVe.DragBoxLayer);uat.YDragBoxLayer=eVe});var Pot=H(_a=>{"use strict";Object.defineProperty(_a,"__esModule",{value:!0});var Ns=(de(),Ut(pe));Ns.__exportStar(qF(),_a);Ns.__exportStar(I$t(),_a);Ns.__exportStar(L$t(),_a);Ns.__exportStar(zot(),_a);Ns.__exportStar(Lot(),_a);Ns.__exportStar(R$t(),_a);Ns.__exportStar(Vot(),_a);Ns.__exportStar(N$t(),_a);Ns.__exportStar(aKt(),_a);Ns.__exportStar(Tot(),_a);Ns.__exportStar(sKt(),_a);Ns.__exportStar(lKt(),_a);Ns.__exportStar(cKt(),_a);Ns.__exportStar(uKt(),_a)});var fat=H(hat=>{"use strict";Object.defineProperty(hat,"__esModule",{value:!0});var rVe=(de(),Ut(pe)),nVe=Df(),iVe=function(e){rVe.__extends(t,e);function t(){return e.call(this,"path","arc fill")||this}return t.prototype._applyDefaultAttributes=function(r){r.style("stroke","none")},t}(nVe.SVGDrawer);hat.ArcSVGDrawer=iVe});var dat=H(pat=>{"use strict";Object.defineProperty(pat,"__esModule",{value:!0});var oVe=(de(),Ut(pe)),aVe=Df(),sVe=function(e){oVe.__extends(t,e);function t(){return e.call(this,"path","arc outline")||this}return t.prototype._applyDefaultAttributes=function(r){r.style("fill","none")},t}(aVe.SVGDrawer);pat.ArcOutlineSVGDrawer=sVe});var mat=H(eB=>{"use strict";Object.defineProperty(eB,"__esModule",{value:!0});var lVe=(de(),Ut(pe)),tB=Fv(),cVe=Df(),uVe=function(e){lVe.__extends(t,e);function t(){return e.call(this,"path","area")||this}return t.prototype._applyDefaultAttributes=function(r){r.style("stroke","none")},t.prototype.getVisualPrimitiveAtIndex=function(r){return e.prototype.getVisualPrimitiveAtIndex.call(this,0)},t}(cVe.SVGDrawer);eB.AreaSVGDrawer=uVe;var hVe=["opacity","fill","fill-opacity"],fVe=["opacity","stroke","stroke-width"];function pVe(e,t){return function(r,n,i){var o=tB.resolveAttributes(i,hVe,n[0],0);tB.renderArea(r,e(),n[0],o);var a=tB.resolveAttributes(i,fVe,n[0],0);tB.renderLine(r,t(),n[0],a)}}eB.makeAreaCanvasDrawStep=pVe});var nB=H(rB=>{"use strict";Object.defineProperty(rB,"__esModule",{value:!0});var dVe=(de(),Ut(pe)),hKt=Fv(),mVe=Df(),gVe=function(e){dVe.__extends(t,e);function t(){return e.call(this,"path","line")||this}return t.prototype._applyDefaultAttributes=function(r){r.style("fill","none")},t.prototype.getVisualPrimitiveAtIndex=function(r){return e.prototype.getVisualPrimitiveAtIndex.call(this,0)},t}(mVe.SVGDrawer);rB.LineSVGDrawer=gVe;var _Ve=["opacity","stroke-opacity","stroke-width","stroke","stroke-dasharray"];function yVe(e){return function(t,r,n){var i=hKt.resolveAttributes(n,_Ve,r[0],0);hKt.renderLine(t,e(),r[0],i)}}rB.makeLineCanvasDrawStep=yVe});var oB=H(PS=>{"use strict";Object.defineProperty(PS,"__esModule",{value:!0});var fKt=(de(),Ut(pe)),iB=Fv(),vVe=Df(),xVe=function(e){fKt.__extends(t,e);function t(r){r===void 0&&(r="");var n=e.call(this,"rect","")||this;return n._rootClassName=r,n._root.classed(n._rootClassName,!0),n}return t}(vVe.SVGDrawer);PS.RectangleSVGDrawer=xVe;var bVe=iB.ContextStyleAttrs.concat(["x","y","width","height"]);PS.RectangleCanvasDrawStep=function(e,t,r){e.save();for(var n=t.length,i=0;i<n;i++){var o=t[i];if(o!=null){var a=iB.resolveAttributes(r,bVe,o,i);e.beginPath(),e.rect(a.x,a.y,a.width,a.height),iB.renderPathWithStyle(e,a)}}e.restore()};var wVe=function(e){fKt.__extends(t,e);function t(r){return e.call(this,r,PS.RectangleCanvasDrawStep)||this}return t}(iB.CanvasDrawer);PS.RectangleCanvasDrawer=wVe});var _at=H(gat=>{"use strict";Object.defineProperty(gat,"__esModule",{value:!0});var SVe=(de(),Ut(pe)),MVe=Df(),EVe=function(e){SVe.__extends(t,e);function t(){return e.call(this,"line","")||this}return t}(MVe.SVGDrawer);gat.SegmentSVGDrawer=EVe});var pKt=H(yat=>{"use strict";Object.defineProperty(yat,"__esModule",{value:!0});var TVe=function(){function e(t,r,n){n===void 0&&(n=window.devicePixelRatio),this.screenWidth=t,this.screenHeight=r,this.devicePixelRatio=n,this.pixelWidth=t*n,this.pixelHeight=r*n,this.canvas=document.createElement("canvas"),this.ctx=this.canvas.getContext("2d"),e.sizePixels(this.ctx,t,r,n)}return e.sizePixels=function(t,r,n,i){var o=t.canvas;o.width=r*i,o.height=n*i,o.style.width=r+"px",o.style.height=n+"px",t.setTransform(1,0,0,1,0,0),t.scale(i,i)},e.prototype.blit=function(t,r,n){r===void 0&&(r=0),n===void 0&&(n=0),t.drawImage(this.canvas,r,n,this.screenWidth,this.screenHeight)},e.prototype.blitCenter=function(t,r,n){r===void 0&&(r=0),n===void 0&&(n=0),this.blit(t,Math.floor(r-this.screenWidth/2),Math.floor(n-this.screenHeight/2))},e.prototype.resize=function(t,r,n){n===void 0&&(n=!1);var i=this.devicePixelRatio;return this.screenWidth=t,this.screenHeight=r,this.pixelWidth=t*i,this.pixelHeight=r*i,e.sizePixels(this.ctx,t,r,i),n&&this.ctx.translate(t/2,t/2),this},e.prototype.clear=function(t){var r=this,n=r.pixelWidth,i=r.pixelHeight,o=r.ctx;return o.save(),o.setTransform(1,0,0,1,0,0),t==null?o.clearRect(0,0,n,i):(o.fillStyle=t,o.fillRect(0,0,n,i)),o.restore(),this},e.prototype.getImageData=function(){return this.ctx.getImageData(0,0,this.pixelWidth,this.pixelHeight)},e}();yat.CanvasBuffer=TVe});var vat=H(aB=>{"use strict";Object.defineProperty(aB,"__esModule",{value:!0});var CVe=(de(),Ut(pe)),m4=Fv(),AVe=pKt(),PVe=Df(),IVe=function(e){CVe.__extends(t,e);function t(){return e.call(this,"path","symbol")||this}return t}(PVe.SVGDrawer);aB.SymbolSVGDrawer=IVe;var LVe=m4.ContextStyleAttrs.concat(["x","y"]);function kVe(e,t,r,n){var i=this;return function(o,a,s){for(var l=o.canvas,c=l.clientWidth,u=l.clientHeight,h=n===void 0?new AVe.CanvasBuffer(0,0):n,f=t(),p=r(),d=null,g=null,_=null,y=0;y<a.length;y++){var x=a[y];if(x!=null){var b=m4.resolveAttributes(s,LVe,x,y),S=p(x,y,e);if(!!RVe(c,u,b.x,b.y,S)){var C=NVe(d,b,m4.ContextStyleAttrs),P=f(x,y,i._dataset);if(!(C&&_==S&&g==P)){var k=m4.getStrokeWidth(b),O=S+k+1;(O>h.screenWidth||O>h.screenHeight)&&h.resize(O,O,!0),h.clear();var D=h.ctx;D.beginPath(),P(S).context(D)(null),D.closePath(),m4.renderPathWithStyle(D,b),g=P,_=S,d=b}h.blitCenter(o,b.x,b.y)}}}}}aB.makeSymbolCanvasDrawStep=kVe;function RVe(e,t,r,n,i){return r+i>=0&&r-i<=e&&n+i>=0&&n-i<=t}function NVe(e,t,r){if(e==null)return!1;for(var n=0;n<r.length;n++){var i=r[n];if(e[i]!=t[i])return!1}return!0}});var Bv=H(Dc=>{"use strict";Object.defineProperty(Dc,"__esModule",{value:!0});var Of=(de(),Ut(pe));Of.__exportStar(fat(),Dc);Of.__exportStar(dat(),Dc);Of.__exportStar(mat(),Dc);Of.__exportStar(Fv(),Dc);Of.__exportStar(Uu(),Dc);Of.__exportStar(nB(),Dc);Of.__exportStar(oB(),Dc);Of.__exportStar(_at(),Dc);Of.__exportStar(Df(),Dc);Of.__exportStar(vat(),Dc)});var Hv=H(bat=>{"use strict";Object.defineProperty(bat,"__esModule",{value:!0});var DVe=(de(),Ut(pe)),dKt=ks(),xat=Fe(),OVe=iat(),g4=rs(),zVe=function(e){DVe.__extends(t,e);function t(){var r=e.call(this)||this;return r._autoAdjustXScaleDomain=!1,r._autoAdjustYScaleDomain=!1,r._deferredRendering=!1,r._applyDeferredRenderingTransform=function(n,i,o,a){!r._isAnchored||(r._renderArea!=null&&r._renderArea.attr("transform","translate("+n+", "+i+") scale("+o+", "+a+")"),r._canvas!=null&&r._canvas.style("transform","translate("+n+"px, "+i+"px) scale("+o+", "+a+")"))},r.addClass("xy-plot"),r._adjustYDomainOnChangeFromXCallback=function(n){return r._adjustYDomainOnChangeFromX()},r._adjustXDomainOnChangeFromYCallback=function(n){return r._adjustXDomainOnChangeFromY()},r._renderCallback=function(){if(r.deferredRendering()){var n=r.x()&&r.x().scale,i=r.y()&&r.y().scale;r._deferredRenderer.updateDomains(n,i)}else r.render()},r._deferredRenderer=new OVe.DeferredRenderer(function(){return r.render()},r._applyDeferredRenderingTransform),r}return t.prototype.render=function(){return this.deferredRendering()&&this._deferredRenderer.resetTransforms(),e.prototype.render.call(this)},t.prototype.deferredRendering=function(r){if(r==null)return this._deferredRendering;if(r){var n=this.x()&&this.x().scale,i=this.y()&&this.y().scale;this._deferredRenderer.setDomains(n,i)}return this._deferredRendering=r,this},t.prototype.x=function(r,n,i){if(r==null)return this._propertyBindings.get(t._X_KEY);this._bindProperty(t._X_KEY,r,n,i);var o=this.width();return n!=null&&o!=null&&n.range([0,o]),this._autoAdjustYScaleDomain&&this._updateYExtentsAndAutodomain(),this.render(),this},t.prototype.y=function(r,n,i){if(r==null)return this._propertyBindings.get(t._Y_KEY);this._bindProperty(t._Y_KEY,r,n,i);var o=this.height();return n!=null&&o!=null&&(n instanceof dKt.Category?n.range([0,o]):n.range([o,0])),this._autoAdjustXScaleDomain&&this._updateXExtentsAndAutodomain(),this.render(),this},t.prototype._filterForProperty=function(r){return r==="x"&&this._autoAdjustXScaleDomain?this._makeFilterByProperty("y"):(r==="y"||r==="y0")&&this._autoAdjustYScaleDomain?this._makeFilterByProperty("x"):null},t.prototype._makeFilterByProperty=function(r){var n=this._propertyBindings.get(r);if(n!=null){var i=n.accessor,o=n.scale;if(o!=null)return function(a,s,l){var c=o.range();return xat.Math.inRange(o.scale(i(a,s,l)),c[0],c[1])}}return null},t.prototype._uninstallScaleForKey=function(r,n){e.prototype._uninstallScaleForKey.call(this,r,n);var i=n===t._X_KEY?this._adjustYDomainOnChangeFromXCallback:this._adjustXDomainOnChangeFromYCallback;r.offUpdate(i)},t.prototype._installScaleForKey=function(r,n){e.prototype._installScaleForKey.call(this,r,n);var i=n===t._X_KEY?this._adjustYDomainOnChangeFromXCallback:this._adjustXDomainOnChangeFromYCallback;r.onUpdate(i)},t.prototype.destroy=function(){return e.prototype.destroy.call(this),this.x().scale&&this.x().scale.offUpdate(this._adjustYDomainOnChangeFromXCallback),this.y().scale&&this.y().scale.offUpdate(this._adjustXDomainOnChangeFromYCallback),this},t.prototype.autorangeMode=function(r){if(r==null)return this._autoAdjustXScaleDomain?"x":this._autoAdjustYScaleDomain?"y":"none";switch(r){case"x":this._autoAdjustXScaleDomain=!0,this._autoAdjustYScaleDomain=!1,this._adjustXDomainOnChangeFromY();break;case"y":this._autoAdjustXScaleDomain=!1,this._autoAdjustYScaleDomain=!0,this._adjustYDomainOnChangeFromX();break;case"none":this._autoAdjustXScaleDomain=!1,this._autoAdjustYScaleDomain=!1;break;default:throw new Error("Invalid scale name '"+r+"', must be 'x', 'y' or 'none'")}return this},t.prototype.computeLayout=function(r,n,i){e.prototype.computeLayout.call(this,r,n,i);var o=this.x(),a=o&&o.scale;a!=null&&a.range([0,this.width()]);var s=this.y(),l=s&&s.scale;return l!=null&&(l instanceof dKt.Category?l.range([0,this.height()]):l.range([this.height(),0])),this},t.prototype._updateXExtentsAndAutodomain=function(){var r=this.x().scale;r!=null&&r.autoDomain()},t.prototype._updateYExtentsAndAutodomain=function(){var r=this.y().scale;r!=null&&r.autoDomain()},t.prototype.showAllData=function(){return this._updateXExtentsAndAutodomain(),this._updateYExtentsAndAutodomain(),this},t.prototype._adjustYDomainOnChangeFromX=function(){!this._projectorsReady()||this._autoAdjustYScaleDomain&&this._updateYExtentsAndAutodomain()},t.prototype._adjustXDomainOnChangeFromY=function(){!this._projectorsReady()||this._autoAdjustXScaleDomain&&this._updateXExtentsAndAutodomain()},t.prototype._projectorsReady=function(){var r=this.x(),n=this.y();return r!=null&&r.accessor!=null&&n!=null&&n.accessor!=null},t.prototype._pixelPoint=function(r,n,i){var o=g4.Plot._scaledAccessor(this.x()),a=g4.Plot._scaledAccessor(this.y());return{x:o(r,n,i),y:a(r,n,i)}},t.prototype._getDataToDraw=function(){var r=this,n=e.prototype._getDataToDraw.call(this),i=this.attr("defined"),o=function(a,s,l){var c=g4.Plot._scaledAccessor(r.x())(a,s,l),u=g4.Plot._scaledAccessor(r.y())(a,s,l);return i&&i.accessor(a,s,l)===!1?!1:xat.Math.isValidNumber(c)&&xat.Math.isValidNumber(u)};return this.datasets().forEach(function(a){n.set(a,n.get(a).filter(function(s,l){return o(s,l,a)}))}),n},t._X_KEY="x",t._Y_KEY="y",t}(g4.Plot);bat.XYPlot=zVe});var Sat=H(lB=>{"use strict";Object.defineProperty(lB,"__esModule",{value:!0});var FVe=(de(),Ut(pe)),ya=(Er(),Ut(Mr)),BVe=Lf(),HVe=Bv(),VVe=Uu(),mKt=nB(),UVe=ks(),sB=vd(),Qg=Fe(),qVe=If(),wat=IS(),vl=rs(),GVe=Hv(),gKt={linear:ya.curveLinear,linearClosed:ya.curveLinearClosed,step:ya.curveStep,stepBefore:ya.curveStepBefore,stepAfter:ya.curveStepAfter,basis:ya.curveBasis,basisOpen:ya.curveBasisOpen,basisClosed:ya.curveBasisClosed,bundle:ya.curveBundle,cardinal:ya.curveCardinal,cardinalOpen:ya.curveCardinalOpen,cardinalClosed:ya.curveCardinalClosed,monotone:ya.curveMonotoneX};lB.CurveName=qVe.makeEnum(["linear","linearClosed","step","stepBefore","stepAfter","basis","basisOpen","basisClosed","bundle","cardinal","cardinalOpen","cardinalClosed","monotone"]);var WVe=function(e){FVe.__extends(t,e);function t(){var r=e.call(this)||this;r._curve="linear",r._autorangeSmooth=!1,r._croppedRenderingEnabled=!0,r._collapseDenseVerticalLinesEnabled=!1,r._downsamplingEnabled=!1,r.addClass("line-plot");var n=new BVe.Easing;return n.stepDuration(vl.Plot._ANIMATION_MAX_DURATION),n.easingMode("expInOut"),n.maxTotalDuration(vl.Plot._ANIMATION_MAX_DURATION),r.animator(wat.Animator.MAIN,n),r.attr("stroke",new UVe.Color().range()[0]),r.attr("stroke-width","2px"),r}return t.prototype.x=function(r,n,i){return r==null?e.prototype.x.call(this):(e.prototype.x.call(this,r,n,i),this._setScaleSnapping(),this)},t.prototype.y=function(r,n,i){return r==null?e.prototype.y.call(this):(e.prototype.y.call(this,r,n,i),this._setScaleSnapping(),this)},t.prototype.autorangeMode=function(r){return r==null?e.prototype.autorangeMode.call(this):(e.prototype.autorangeMode.call(this,r),this._setScaleSnapping(),this)},t.prototype.autorangeSmooth=function(r){return r==null?this._autorangeSmooth:(this._autorangeSmooth=r,this._setScaleSnapping(),this)},t.prototype._setScaleSnapping=function(){this.autorangeMode()==="x"&&this.x()&&this.x().scale&&this.x().scale instanceof sB.QuantitativeScale&&this.x().scale.snappingDomainEnabled(!this.autorangeSmooth()),this.autorangeMode()==="y"&&this.y()&&this.y().scale&&this.y().scale instanceof sB.QuantitativeScale&&this.y().scale.snappingDomainEnabled(!this.autorangeSmooth())},t.prototype.curve=function(r){return r==null?this._curve:(this._curve=r,this.render(),this)},t.prototype.downsamplingEnabled=function(r){return r==null?this._downsamplingEnabled:(this._downsamplingEnabled=r,this)},t.prototype.croppedRenderingEnabled=function(r){return r==null?this._croppedRenderingEnabled:(this._croppedRenderingEnabled=r,this.render(),this)},t.prototype.collapseDenseLinesEnabled=function(r){return r==null?this._collapseDenseVerticalLinesEnabled:(this._collapseDenseVerticalLinesEnabled=r,this.render(),this)},t.prototype._createDrawer=function(r){var n=this;return new VVe.ProxyDrawer(function(){return new mKt.LineSVGDrawer},function(i){return new HVe.CanvasDrawer(i,mKt.makeLineCanvasDrawStep(function(){return n._d3LineFactory(r)}))})},t.prototype.getExtentsForProperty=function(r){var n=e.prototype.getExtentsForProperty.call(this,r);if(!this._autorangeSmooth||this.autorangeMode()!==r||this.autorangeMode()!=="x"&&this.autorangeMode()!=="y")return n;var i=this._getEdgeIntersectionPoints(),o;return this.autorangeMode()==="y"?o=i.left.concat(i.right).map(function(a){return a.y}):o=i.top.concat(i.bottom).map(function(a){return a.x}),n.map(function(a){return ya.extent(ya.merge([a,o]))})},t.prototype._getEdgeIntersectionPoints=function(){var r=this;if(!(this.y().scale instanceof sB.QuantitativeScale&&this.x().scale instanceof sB.QuantitativeScale))return{left:[],right:[],top:[],bottom:[]};var n=this.y().scale,i=this.x().scale,o={left:[],right:[],top:[],bottom:[]},a=i.scale(i.domain()[0]),s=i.scale(i.domain()[1]),l=n.scale(n.domain()[0]),c=n.scale(n.domain()[1]);return this.datasets().forEach(function(u){for(var h=u.data(),f,p,d,g,_,y,x,b,S=1;S<h.length;S++)_=x||i.scale(r.x().accessor(h[S-1],S-1,u)),y=b||n.scale(r.y().accessor(h[S-1],S-1,u)),x=i.scale(r.x().accessor(h[S],S,u)),b=n.scale(r.y().accessor(h[S],S,u)),_<a==a<=x&&(f=a-_,p=x-_,g=b-y,d=f*g/p,o.left.push({x:a,y:n.invert(y+d)})),_<s==s<=x&&(f=s-_,p=x-_,g=b-y,d=f*g/p,o.right.push({x:s,y:n.invert(y+d)})),y<c==c<=b&&(p=x-_,d=c-y,g=b-y,f=d*p/g,o.top.push({x:i.invert(_+f),y:c})),y<l==l<=b&&(p=x-_,d=l-y,g=b-y,f=d*p/g,o.bottom.push({x:i.invert(_+f),y:l}))}),o},t.prototype._getResetYFunction=function(){var r=this.y().scale.domain(),n=Math.max(r[0],r[1]),i=Math.min(r[0],r[1]),o=n<0&&n||i>0&&i||0,a=this.y().scale.scale(o);return function(s,l,c){return a}},t.prototype._generateDrawSteps=function(){var r=[];if(this._animateOnNextRender()){var n=this._getAttrToProjector();n.d=this._constructLineProjector(vl.Plot._scaledAccessor(this.x()),this._getResetYFunction()),r.push({attrToProjector:n,animator:this._getAnimator(wat.Animator.RESET)})}return r.push({attrToProjector:this._getAttrToProjector(),animator:this._getAnimator(wat.Animator.MAIN)}),r},t.prototype._generateAttrToProjector=function(){var r=e.prototype._generateAttrToProjector.call(this);return Object.keys(r).forEach(function(n){if(n!=="d"){var i=r[n];r[n]=function(o,a,s){return o.length>0?i(o[0],a,s):null}}}),r},t.prototype.entitiesAt=function(r){var n=this.entityNearestByXThenY(r);return n!=null?[n]:[]},t.prototype.entityNearestByXThenY=function(r){for(var n=1/0,i=1/0,o,a=this.bounds(),s=this.entities(),l=s.length,c=0;c<l;c++){var u=s[c];if(!!Qg.Math.within(u.position,a)){var h=Math.abs(r.x-u.position.x),f=Math.abs(r.y-u.position.y);(h<n||h===n&&f<i)&&(o=u,n=h,i=f)}}return o},t.prototype._propertyProjectors=function(){var r=e.prototype._propertyProjectors.call(this);return r.d=this._constructLineProjector(vl.Plot._scaledAccessor(this.x()),vl.Plot._scaledAccessor(this.y())),r},t.prototype._constructLineProjector=function(r,n){var i=this;return function(o,a,s){return i._d3LineFactory(s,r,n)(o)}},t.prototype._d3LineFactory=function(r,n,i){n===void 0&&(n=vl.Plot._scaledAccessor(this.x())),i===void 0&&(i=vl.Plot._scaledAccessor(this.y()));var o=function(a,s,l){var c=n(a,s,l),u=i(a,s,l);return Qg.Math.isValidNumber(c)&&Qg.Math.isValidNumber(u)};return ya.line().x(function(a,s){return n(a,s,r)}).y(function(a,s){return i(a,s,r)}).curve(this._getCurveFactory()).defined(function(a,s){return o(a,s,r)})},t.prototype._getCurveFactory=function(){var r=this.curve();if(typeof r=="string"){var n=gKt[r];return n==null?gKt.linear:n}else return r},t.prototype._getDataToDraw=function(){var r=this,n=new Qg.Map;return this.datasets().forEach(function(i){var o=i.data();if(!r._croppedRenderingEnabled&&!r._downsamplingEnabled){n.set(i,[o]);return}for(var a=[],s=o.length,l=0;l<s;l++)a[l]=l;r._croppedRenderingEnabled&&(a=r._filterCroppedRendering(i,a)),r._downsamplingEnabled&&(a=r._filterDownsampling(i,a)),r._collapseDenseVerticalLinesEnabled&&(a=r._filterDenseLines(i,a));for(var c=[],u=a.length,l=0;l<u;l++){var h=a[l];c[l]=o[h]}n.set(i,[c])}),n},t.prototype._filterCroppedRendering=function(r,n){for(var i=this,o=vl.Plot._scaledAccessor(this.x()),a=vl.Plot._scaledAccessor(this.y()),s=r.data(),l=[],c=function(x,b){return Qg.Math.inRange(x,0,i.width())&&Qg.Math.inRange(b,0,i.height())},u=0;u<n.length;u++){var h=o(s[n[u]],n[u],r),f=a(s[n[u]],n[u],r),p=c(h,f);if(!p&&n[u-1]!=null&&s[n[u-1]]!=null){var d=o(s[n[u-1]],n[u-1],r),g=a(s[n[u-1]],n[u-1],r);p=p||c(d,g)}if(!p&&n[u+1]!=null&&s[n[u+1]]!=null){var _=o(s[n[u+1]],n[u+1],r),y=a(s[n[u+1]],n[u+1],r);p=p||c(_,y)}p&&l.push(n[u])}return l},t.prototype._filterDownsampling=function(r,n){if(n.length===0)return[];for(var i=r.data(),o=vl.Plot._scaledAccessor(this.x()),a=vl.Plot._scaledAccessor(this.y()),s=[n[0]],l=function(k,O){var D=o(i[n[k]],n[k],r),B=a(i[n[k]],n[k],r),I=o(i[n[k+1]],n[k+1],r),L=a(i[n[k+1]],n[k+1],r);if(O===1/0)return Math.floor(D)===Math.floor(I);var R=B+(I-D)*O;return Math.floor(L)===Math.floor(R)},c=0;c<n.length-1;){for(var u=n[c],h=o(i[n[c]],n[c],r),f=a(i[n[c]],n[c],r),p=o(i[n[c+1]],n[c+1],r),d=a(i[n[c+1]],n[c+1],r),g=Math.floor(h)===Math.floor(p)?1/0:(d-f)/(p-h),_=n[c],y=g===1/0?f:h,x=_,b=y,S=!0;c<n.length-1&&(S||l(c,g));){c++,S=!1;var C=g===1/0?a(i[n[c]],n[c],r):o(i[n[c]],n[c],r);C>b&&(b=C,x=n[c]),C<y&&(y=C,_=n[c])}var P=n[c];_!==u&&s.push(_),x!==_&&x!==u&&s.push(x),P!==u&&P!==_&&P!==x&&s.push(P)}return s},t.prototype._filterDenseLines=function(r,n){if(n.length===0)return[];var i=r.data(),o=vl.Plot._scaledAccessor(this.x()),a=vl.Plot._scaledAccessor(this.y()),s=function(c){return o(i[c],c,r)},l=function(c){return a(i[c],c,r)};return this._bucketByX(r,n,s,l)},t.prototype._bucketByX=function(r,n,i,o){for(var a=[],s=r.data(),l=null,c=n.length,u=0;u<=c;++u){var h=n[u];if(s[h]!=null){var f=Math.floor(i(h)),p=o(h);l==null?l=new Qg.Bucket(h,f,p):l.isInBucket(f)?l.addToBucket(p,h):(a.push.apply(a,l.getUniqueIndices()),l=new Qg.Bucket(h,f,p))}}return l!=null&&a.push.apply(a,l.getUniqueIndices()),a},t}(GVe.XYPlot);lB.Line=WVe});var Tat=H(Eat=>{"use strict";Object.defineProperty(Eat,"__esModule",{value:!0});var YVe=(de(),Ut(pe)),cB=(Er(),Ut(Mr)),jVe=ks(),_4=Fe(),Mat=Bv(),_Kt=mat(),XVe=Uu(),yKt=nB(),uB=IS(),$Ve=Sat(),Ds=rs(),KVe=function(e){YVe.__extends(t,e);function t(){var r=e.call(this)||this;return r.addClass("area-plot"),r.y0(0),r.attr("fill-opacity",.25),r.attr("fill",new jVe.Color().range()[0]),r._lineDrawers=new _4.Map,r}return t.prototype.y=function(r,n){if(r==null)return e.prototype.y.call(this);if(n==null?e.prototype.y.call(this,r):e.prototype.y.call(this,r,n),n!=null){var i=this.y0().accessor;i!=null&&this._bindProperty(t._Y0_KEY,i,n),this._updateYScale()}return this},t.prototype.y0=function(r){if(r==null)return this._propertyBindings.get(t._Y0_KEY);var n=this.y(),i=n&&n.scale;return this._bindProperty(t._Y0_KEY,r,i),this._updateYScale(),this.render(),this},t.prototype._onDatasetUpdate=function(){e.prototype._onDatasetUpdate.call(this),this._updateYScale()},t.prototype._addDataset=function(r){var n=this;return this._lineDrawers.set(r,new Mat.ProxyDrawer(function(){return new yKt.LineSVGDrawer},function(i){return new Mat.CanvasDrawer(i,yKt.makeLineCanvasDrawStep(function(){var o=Ds.Plot._scaledAccessor(n.x()),a=Ds.Plot._scaledAccessor(n.y());return n._d3LineFactory(r,o,a)}))})),e.prototype._addDataset.call(this,r),this},t.prototype._createNodesForDataset=function(r){e.prototype._createNodesForDataset.call(this,r);var n=this._lineDrawers.get(r);return this.renderer()==="svg"?n.useSVG(this._renderArea):n.useCanvas(this._canvas),n},t.prototype._removeDatasetNodes=function(r){e.prototype._removeDatasetNodes.call(this,r),this._lineDrawers.get(r).remove()},t.prototype._additionalPaint=function(){var r=this,n=this._generateLineDrawSteps(),i=this._getDataToDraw();this.datasets().forEach(function(o){var a=Ds.Plot.applyDrawSteps(n,o);r._lineDrawers.get(o).draw(i.get(o),a)})},t.prototype._generateLineDrawSteps=function(){var r=[];if(this._animateOnNextRender()){var n=this._generateLineAttrToProjector();n.d=this._constructLineProjector(Ds.Plot._scaledAccessor(this.x()),this._getResetYFunction()),r.push({attrToProjector:n,animator:this._getAnimator(uB.Animator.RESET)})}return r.push({attrToProjector:this._generateLineAttrToProjector(),animator:this._getAnimator(uB.Animator.MAIN)}),r},t.prototype._generateLineAttrToProjector=function(){var r=this._getAttrToProjector();return r.d=this._constructLineProjector(Ds.Plot._scaledAccessor(this.x()),Ds.Plot._scaledAccessor(this.y())),r},t.prototype._createDrawer=function(r){var n=this;return new XVe.ProxyDrawer(function(){return new _Kt.AreaSVGDrawer},function(i){return new Mat.CanvasDrawer(i,_Kt.makeAreaCanvasDrawStep(function(){var o=n._coordinateProjectors(),a=o[0],s=o[1],l=o[2],c=n._createDefinedProjector(a,s);return n._createAreaGenerator(a,s,l,c,r)},function(){var o=n._coordinateProjectors(),a=o[0],s=o[1],l=n._createDefinedProjector(a,s);return n._createTopLineGenerator(a,s,l,r)}))})},t.prototype._generateDrawSteps=function(){var r=[];if(this._animateOnNextRender()){var n=this._getAttrToProjector();n.d=this._constructAreaProjector(Ds.Plot._scaledAccessor(this.x()),this._getResetYFunction(),Ds.Plot._scaledAccessor(this.y0())),r.push({attrToProjector:n,animator:this._getAnimator(uB.Animator.RESET)})}return r.push({attrToProjector:this._getAttrToProjector(),animator:this._getAnimator(uB.Animator.MAIN)}),r},t.prototype._updateYScale=function(){var r=this.getExtentsForProperty("y0"),n=_4.Array.flatten(r),i=_4.Array.uniq(n),o=i.length===1?i[0]:null,a=this.y(),s=a&&a.scale;s!=null&&(this._constantBaselineValueProvider!=null&&(s.removePaddingExceptionsProvider(this._constantBaselineValueProvider),this._constantBaselineValueProvider=null),o!=null&&(this._constantBaselineValueProvider=function(){return[o]},s.addPaddingExceptionsProvider(this._constantBaselineValueProvider)))},t.prototype._getResetYFunction=function(){return Ds.Plot._scaledAccessor(this.y0())},t.prototype._coordinateProjectors=function(){return[Ds.Plot._scaledAccessor(this.x()),Ds.Plot._scaledAccessor(this.y()),Ds.Plot._scaledAccessor(this.y0())]},t.prototype._propertyProjectors=function(){var r=e.prototype._propertyProjectors.call(this),n=this._coordinateProjectors(),i=n[0],o=n[1],a=n[2];return r.d=this._constructAreaProjector(i,o,a),r},t.prototype.selections=function(r){var n=this;if(r===void 0&&(r=this.datasets()),this.renderer()==="canvas")return cB.selectAll();var i=e.prototype.selections.call(this,r).nodes(),o=r.map(function(a){return n._lineDrawers.get(a)}).filter(function(a){return a!=null});return o.forEach(function(a){return i.push.apply(i,a.getVisualPrimitives())}),cB.selectAll(i)},t.prototype._constructAreaProjector=function(r,n,i){var o=this,a=this._createDefinedProjector(Ds.Plot._scaledAccessor(this.x()),Ds.Plot._scaledAccessor(this.y()));return function(s,l,c){var u=o._createAreaGenerator(r,n,i,a,c);return u(s)}},t.prototype._createDefinedProjector=function(r,n){return function(i,o,a){var s=r(i,o,a),l=n(i,o,a);return _4.Math.isValidNumber(s)&&_4.Math.isValidNumber(l)}},t.prototype._createAreaGenerator=function(r,n,i,o,a){var s=this._getCurveFactory(),l=cB.area().x(function(c,u){return r(c,u,a)}).y1(function(c,u){return n(c,u,a)}).y0(function(c,u){return i(c,u,a)}).curve(s).defined(function(c,u){return o(c,u,a)});return l},t.prototype._createTopLineGenerator=function(r,n,i,o){var a=this._getCurveFactory(),s=cB.line().x(function(l,c){return r(l,c,o)}).y(function(l,c){return n(l,c,o)}).curve(a).defined(function(l,c){return i(l,c,o)});return s},t._Y0_KEY="y0",t}($Ve.Line);Eat.Area=KVe});var y4=H(Gu=>{"use strict";Object.defineProperty(Gu,"__esModule",{value:!0});var ZVe=(de(),Ut(pe)),Aat=(Er(),Ut(Mr)),Cat=_l(),JVe=Lf(),QVe=Bu(),tUe=Bv(),eUe=Uu(),rUe=oB(),nUe=CS(),Pat=ks(),vKt=vd(),xl=Fe(),Lat=If(),xKt=IS(),hB=rs(),iUe=Hv();Gu.BarOrientation=Lat.makeEnum(["vertical","horizontal"]);Gu.LabelsPosition=Lat.makeEnum(["start","middle","end","outside"]);Gu.BarAlignment=Lat.makeEnum(["start","middle","end"]);var Iat=function(e){ZVe.__extends(t,e);function t(r){r===void 0&&(r="vertical");var n=e.call(this)||this;if(n._labelFormatter=QVe.identity(),n._labelsEnabled=!1,n._labelsPosition=Gu.LabelsPosition.end,n._hideBarsIfAnyAreTooWide=!0,n._barAlignment="middle",n._computeBarPixelThickness=nUe.memoize(oUe),n._fixedBarPixelThickness=!0,n.addClass("bar-plot"),r!=="vertical"&&r!=="horizontal")throw new Error(r+" is not a valid orientation for Plots.Bar");return n._isVertical=r==="vertical",n.animator("baseline",new JVe.Null),n.attr("fill",new Pat.Color().range()[0]),n.attr(t._BAR_THICKNESS_KEY,function(){return n._barPixelThickness()}),n._labelConfig=new xl.Map,n._baselineValueProvider=function(){return[n.baselineValue()]},n}return t.prototype.computeLayout=function(r,n,i){return e.prototype.computeLayout.call(this,r,n,i),this._updateExtents(),this},t.prototype.x=function(r,n){return r==null?e.prototype.x.call(this):(n==null?e.prototype.x.call(this,r):e.prototype.x.call(this,r,n),this._updateThicknessAttr(),this._updateLengthScale(),this)},t.prototype.y=function(r,n){return r==null?e.prototype.y.call(this):(n==null?e.prototype.y.call(this,r):e.prototype.y.call(this,r,n),this._updateLengthScale(),this)},t.prototype.length=function(){return this._isVertical?this.y():this.x()},t.prototype.position=function(){return this._isVertical?this.x():this.y()},t.prototype.barEnd=function(r){if(r==null)return this._propertyBindings.get(t._BAR_END_KEY);var n=this.position(),i=n&&n.scale;return this._bindProperty(t._BAR_END_KEY,r,i),this._updateThicknessAttr(),this._updateLengthScale(),this.render(),this},t.prototype.barAlignment=function(r){return r==null?this._barAlignment:(this._barAlignment=r,this._clearAttrToProjectorCache(),this.render(),this)},t.prototype.orientation=function(){return this._isVertical?"vertical":"horizontal"},t.prototype._createDrawer=function(){return new eUe.ProxyDrawer(function(){return new rUe.RectangleSVGDrawer(t._BAR_AREA_CLASS)},function(r){return new tUe.RectangleCanvasDrawer(r)})},t.prototype._setup=function(){e.prototype._setup.call(this),this._baseline=this._renderArea.append("line").classed("baseline",!0)},t.prototype.baselineValue=function(r){if(r==null){if(this._baselineValue!=null)return this._baselineValue;if(!this._projectorsReady())return 0;var n=this.length().scale;return n&&n instanceof Pat.Time?new Date(0):0}return this._baselineValue=r,this._updateLengthScale(),this._clearAttrToProjectorCache(),this.render(),this},t.prototype.addDataset=function(r){return e.prototype.addDataset.call(this,r),this},t.prototype._addDataset=function(r){return e.prototype._addDataset.call(this,r),this},t.prototype.removeDataset=function(r){return e.prototype.removeDataset.call(this,r),this},t.prototype._removeDataset=function(r){return e.prototype._removeDataset.call(this,r),this},t.prototype.datasets=function(r){return r==null?e.prototype.datasets.call(this):(e.prototype.datasets.call(this,r),this)},t.prototype.labelsEnabled=function(r,n){return r==null?this._labelsEnabled:(this._labelsEnabled=r,n!=null&&(this._labelsPosition=n),this._clearAttrToProjectorCache(),this.render(),this)},t.prototype.labelFormatter=function(r){return r==null?this._labelFormatter:(this._labelFormatter=r,this._clearAttrToProjectorCache(),this.render(),this)},t.prototype._createNodesForDataset=function(r){var n=e.prototype._createNodesForDataset.call(this,r),i=this._renderArea.append("g").classed(t._LABEL_AREA_CLASS,!0),o=new Cat.SvgContext(i.node()),a=new Cat.CacheMeasurer(o),s=new Cat.Writer(a,o);return this._labelConfig.set(r,{labelArea:i,measurer:a,writer:s}),n},t.prototype._removeDatasetNodes=function(r){e.prototype._removeDatasetNodes.call(this,r);var n=this._labelConfig.get(r);n!=null&&(n.labelArea.remove(),this._labelConfig.delete(r))},t.prototype.entityNearest=function(r){var n=this,i=function(){var o=n._isVertical?n._getEntityStore().entityNearestX(r):n._getEntityStore().entityNearestY(r);return o===void 0?void 0:n._lightweightPlotEntityToPlotEntity(o)};return this._fixedBarPixelThickness?this._computeBarPixelThickness.doLocked(i):i()},t.prototype.entitiesAt=function(r){var n=this,i=function(){return n._entitiesIntersecting(r.x,r.y)};return this._fixedBarPixelThickness?this._computeBarPixelThickness.doLocked(i):i()},t.prototype.entitiesInBounds=function(r){var n=this,i=function(){return e.prototype.entitiesInBounds.call(n,r)};return this._fixedBarPixelThickness?this._computeBarPixelThickness.doLocked(i):i()},t.prototype.entitiesInXBounds=function(r){var n=this,i=function(){return e.prototype.entitiesInXBounds.call(n,r)};return this._fixedBarPixelThickness?this._computeBarPixelThickness.doLocked(i):i()},t.prototype.entitiesInYBounds=function(r){var n=this,i=function(){return e.prototype.entitiesInYBounds.call(n,r)};return this._fixedBarPixelThickness?this._computeBarPixelThickness.doLocked(i):i()},t.prototype._entitiesIntersecting=function(r,n){for(var i=[],o=this._getEntityStore().entities(),a=o.length,s=0;s<a;s++){var l=o[s];xl.DOM.intersectsBBox(r,n,this._entityBounds(l))&&i.push(this._lightweightPlotEntityToPlotEntity(l))}return i},t.prototype._updateLengthScale=function(){if(!!this._projectorsReady()){var r=this.length().scale;r instanceof vKt.QuantitativeScale&&(r.addPaddingExceptionsProvider(this._baselineValueProvider),r.addIncludedValuesProvider(this._baselineValueProvider))}},t.prototype.renderImmediately=function(){var r=this;return this._barPixelThickness(),this._computeBarPixelThickness.doLocked(function(){return e.prototype.renderImmediately.call(r)})},t.prototype._additionalPaint=function(r){var n=this,i=this.length().scale,o=i.scale(this.baselineValue()),a={x1:this._isVertical?0:o,y1:this._isVertical?o:0,x2:this._isVertical?this.width():o,y2:this._isVertical?o:this.height()};this._getAnimator("baseline").animate(this._baseline,a),this.datasets().forEach(function(s){return n._labelConfig.get(s).labelArea.selectAll("g").remove()}),this._labelsEnabled&&xl.Window.setTimeout(function(){return n._drawLabels()},r)},t.prototype.getExtentsForProperty=function(r){var n=this,i=e.prototype.getExtentsForProperty.call(this,r),o;if(r==="x"&&this._isVertical)o=this.x();else if(r==="y"&&!this._isVertical)o=this.y();else return i;if(!(o&&o.scale&&o.scale instanceof vKt.QuantitativeScale))return i;var a=o.scale,s=this._barPixelThickness();return i=i.map(function(l){return Aat.extent([a.invert(n._getPositionAttr(a.scale(l[0]),s)),a.invert(n._getPositionAttr(a.scale(l[0]),s)+s),a.invert(n._getPositionAttr(a.scale(l[1]),s)),a.invert(n._getPositionAttr(a.scale(l[1]),s)+s)])}),i},t.prototype._getPositionAttr=function(r,n){switch(this._isVertical||(r-=n,n*=-1),this._barAlignment){case"start":return r;case"end":return r-n;case"middle":default:return r-n/2}},t.prototype._drawLabels=function(){var r=this,n=this._getDataToDraw(),i=this._getAttrToProjector(),o=this.datasets().some(function(a){return n.get(a).some(function(s,l){return s==null?!1:r._drawLabel(s,l,a,i)})});this._hideBarsIfAnyAreTooWide&&o&&this.datasets().forEach(function(a){return r._labelConfig.get(a).labelArea.selectAll("g").remove()})},t.prototype._drawLabel=function(r,n,i,o){var a=this._labelConfig.get(i),s=a.labelArea,l=a.measurer,c=a.writer,u=this.length().accessor,h=u(r,n,i),f=this.length().scale,p=f!=null?f.scale(h):h,d=f!=null?f.scale(this.baselineValue()):this.baselineValue(),g={x:o.x(r,n,i),y:o.y(r,n,i)},_={width:o.width(r,n,i),height:o.height(r,n,i)},y=this._labelFormatter(h,r,n,i),x=l.measure(y),b=this._shouldShowLabelOnBar(g,_,x),S=this._isVertical?p<=d:p<d,C=this._calculateLabelProperties(g,_,x,b,S),P=C.containerDimensions,k=C.labelContainerOrigin,O=C.labelOrigin,D=C.alignment,B=o.fill(r,n,i),I=this._createLabelContainer(s,k,O,x,b,B),L={xAlign:D.x,yAlign:D.y};c.write(y,P.width,P.height,L,I.node());var R=this._isVertical?_.width<x.width:_.height<x.height;return R},t.prototype._shouldShowLabelOnBar=function(r,n,i){if(this._labelsPosition===Gu.LabelsPosition.outside)return!1;var o=this._isVertical?r.y:r.x,a=this._isVertical?n.height:n.width,s=this._isVertical?this.height():this.width(),l=this._isVertical?i.height:i.width,c=o+a,u=a;return c>s?u=s-o:o<0&&(u=c),l+t._LABEL_MARGIN_INSIDE_BAR<=u},t.prototype._calculateLabelProperties=function(r,n,i,o,a){var s=this,l=this._isVertical?r.y:r.x,c=this._isVertical?n.height:n.width,u=this._isVertical?i.height:i.width,h="center",f=c,p=l,d=l,g=function(_){switch(_){case"topLeft":h=s._isVertical?"top":"left",p+=t._LABEL_MARGIN_INSIDE_BAR,d+=t._LABEL_MARGIN_INSIDE_BAR;return;case"center":d+=(c+u)/2;return;case"bottomRight":h=s._isVertical?"bottom":"right",p-=t._LABEL_MARGIN_INSIDE_BAR,d+=f-t._LABEL_MARGIN_INSIDE_BAR-u;return}};if(o)switch(this._labelsPosition){case Gu.LabelsPosition.start:g(a?"bottomRight":"topLeft");break;case Gu.LabelsPosition.middle:g("center");break;case Gu.LabelsPosition.end:g(a?"topLeft":"bottomRight");break}else a?(h=this._isVertical?"top":"left",f=c+t._LABEL_MARGIN_INSIDE_BAR+u,p-=t._LABEL_MARGIN_INSIDE_BAR+u,d-=t._LABEL_MARGIN_INSIDE_BAR+u):(h=this._isVertical?"bottom":"right",f=c+t._LABEL_MARGIN_INSIDE_BAR+u,d+=c+t._LABEL_MARGIN_INSIDE_BAR);return{containerDimensions:{width:this._isVertical?n.width:f,height:this._isVertical?f:n.height},labelContainerOrigin:{x:this._isVertical?r.x:p,y:this._isVertical?p:r.y},labelOrigin:{x:this._isVertical?r.x+n.width/2-i.width/2:d,y:this._isVertical?d:r.y+n.height/2-i.height/2},alignment:{x:this._isVertical?"center":h,y:this._isVertical?h:"center"}}},t.prototype._createLabelContainer=function(r,n,i,o,a,s){var l=r.append("g").attr("transform","translate("+n.x+", "+n.y+")");if(a){l.classed("on-bar-label",!0);var c=xl.Color.contrast("white",s)*1.6<xl.Color.contrast("black",s);l.classed(c?"dark-label":"light-label",!0)}else l.classed("off-bar-label",!0);return l},t.prototype._generateDrawSteps=function(){var r=[];if(this._animateOnNextRender()){var n=this._getAttrToProjector(),i=this.length().scale,o=i.scale(this.baselineValue()),a=this._isVertical?"y":"x",s=this._isVertical?"height":"width";n[a]=function(){return o},n[s]=function(){return 0},r.push({attrToProjector:n,animator:this._getAnimator(xKt.Animator.RESET)})}return r.push({attrToProjector:this._getAttrToProjector(),animator:this._getAnimator(xKt.Animator.MAIN)}),r},t.prototype._generateAttrToProjector=function(){var r=this,n=e.prototype._generateAttrToProjector.call(this),i=this.length().scale,o=i.scale(this.baselineValue()),a=this._isVertical?"y":"x",s=this._isVertical?"x":"y",l=hB.Plot._scaledAccessor(this.position()),c=hB.Plot._scaledAccessor(this.length()),u=function(d,g,_){return Math.abs(o-c(d,g,_))},h=n[t._BAR_THICKNESS_KEY],f=n.gap,p=f==null?h:function(d,g,_){var y=h(d,g,_);return y<t._BAR_GAPLESS_THRESHOLD_PX?y:y-f(d,g,_)};return n.width=this._isVertical?p:u,n.height=this._isVertical?u:p,n[a]=function(d,g,_){var y=c(d,g,_);return y>o?o:y},n[s]=function(d,g,_){return r._getPositionAttr(l(d,g,_),h(d,g,_))},n},t.prototype._updateThicknessAttr=function(){var r=this,n=this.position(),i=this.barEnd();n!=null&&i!=null?(this._fixedBarPixelThickness=!1,this.attr(t._BAR_THICKNESS_KEY,function(o,a,s){var l=n.accessor(o,a,s),c=i.accessor(o,a,s);return l=n.scale?n.scale.scale(l):l,c=i.scale?i.scale.scale(c):c,Math.abs(c-l)})):(this._fixedBarPixelThickness=!0,this.attr(t._BAR_THICKNESS_KEY,function(){return r._barPixelThickness()}))},t.prototype._barPixelThickness=function(){return this._fixedBarPixelThickness&&this._projectorsReady()?this._computeBarPixelThickness(this.position(),this.datasets(),this._isVertical?this.width():this.height()):0},t.prototype.entities=function(r){if(r===void 0&&(r=this.datasets()),!this._projectorsReady())return[];var n=e.prototype.entities.call(this,r);return n},t.prototype._entityBounds=function(r){var n=r.datum,i=r.index,o=r.dataset;return this._pixelBounds(n,i,o)},t.prototype._pixelBounds=function(r,n,i){var o=this._getAttrToProjector();return{x:o.x(r,n,i),y:o.y(r,n,i),width:o.width(r,n,i),height:o.height(r,n,i)}},t.prototype._pixelPoint=function(r,n,i){var o=this._pixelBounds(r,n,i),a=(this._isVertical?hB.Plot._scaledAccessor(this.y()):hB.Plot._scaledAccessor(this.x()))(r,n,i),s=(this._isVertical?this.y().scale:this.x().scale).scale(this.baselineValue());return this._pixelPointBar(a,s,o)},t.prototype._pixelPointBar=function(r,n,i){var o,a;return this._isVertical?(o=i.x+i.width/2,a=r<=n?i.y:i.y+i.height):(o=r>=n?i.x+i.width:i.x,a=i.y+i.height/2),{x:o,y:a}},t.prototype._uninstallScaleForKey=function(r,n){e.prototype._uninstallScaleForKey.call(this,r,n)},t.prototype._getDataToDraw=function(){var r=this,n=new xl.Map,i=this._getAttrToProjector(),o=this.width(),a=this.height();return this.datasets().forEach(function(s){var l=s.data().map(function(c,u){var h=r._isDatumOnScreen(i,o,a,c,u,s);return h?c:null});n.set(s,l)}),n},t.prototype._isDatumOnScreen=function(r,n,i,o,a,s){var l=r.x(o,a,s),c=r.y(o,a,s),u=r.width(o,a,s),h=r.height(o,a,s),f=xl.Math.isValidNumber(l)&&xl.Math.isValidNumber(c)&&xl.Math.isValidNumber(u)&&xl.Math.isValidNumber(h);return f?xl.Math.boundsIntersects(l,c,u,h,0,0,n,i):!1},t.prototype.invalidateCache=function(){var r=this;e.prototype.invalidateCache.call(this),this.datasets().forEach(function(n){return r._labelConfig.get(n).measurer.reset()})},t._BAR_THICKNESS_RATIO=.95,t._BAR_GAPLESS_THRESHOLD_PX=3,t._SINGLE_BAR_DIMENSION_RATIO=.4,t._BAR_AREA_CLASS="bar-area",t._BAR_END_KEY="barEnd",t._BAR_THICKNESS_KEY="width",t._LABEL_AREA_CLASS="bar-label-text-area",t._LABEL_MARGIN_INSIDE_BAR=10,t}(iUe.XYPlot);Gu.Bar=Iat;function oUe(e,t,r){var n,i=e.scale;if(i instanceof Pat.Category)n=i.rangeBand();else{var o=e.accessor,a=Aat.set(xl.Array.flatten(t.map(function(c){return c.data().map(function(u,h){return o(u,h,c)}).filter(function(u){return u!=null}).map(function(u){return u.valueOf()})}))).values().map(function(c){return+c});a.sort(function(c,u){return c-u});var s=a.map(function(c){return i.scale(c)}),l=Aat.pairs(s);n=xl.Math.min(l,function(c,u){return Math.abs(c[1]-c[0])},r*Iat._SINGLE_BAR_DIMENSION_RATIO),n*=Iat._BAR_THICKNESS_RATIO}return n}});var wKt=H(kat=>{"use strict";Object.defineProperty(kat,"__esModule",{value:!0});var aUe=(de(),Ut(pe)),sUe=ks(),lUe=Fe(),bKt=y4(),cUe=rs(),uUe=function(e){aUe.__extends(t,e);function t(r){r===void 0&&(r="vertical");var n=e.call(this,r)||this;return n._clusterOffsets=new lUe.Map,n}return t.prototype._generateAttrToProjector=function(){var r=this,n=e.prototype._generateAttrToProjector.call(this),i=this._makeInnerScale(),o=function(l,c){return i.rangeBand()};n.width=this._isVertical?o:n.width,n.height=this._isVertical?n.height:o;var a=n.x,s=n.y;return n.x=this._isVertical?function(l,c,u){return a(l,c,u)+r._clusterOffsets.get(u)}:function(l,c,u){return a(l,c,u)},n.y=this._isVertical?function(l,c,u){return s(l,c,u)}:function(l,c,u){return s(l,c,u)+r._clusterOffsets.get(u)},n},t.prototype._updateClusterPosition=function(){var r=this,n=this._makeInnerScale();this.datasets().forEach(function(i,o){return r._clusterOffsets.set(i,n.scale(String(o))-n.rangeBand()/2)})},t.prototype._makeInnerScale=function(){var r=new sUe.Category;r.domain(this.datasets().map(function(i,o){return String(o)}));var n=cUe.Plot._scaledAccessor(this.attr(bKt.Bar._BAR_THICKNESS_KEY));return r.range([0,n(null,0,null)]),r},t.prototype._getDataToDraw=function(){return this._updateClusterPosition(),e.prototype._getDataToDraw.call(this)},t}(bKt.Bar);kat.ClusteredBar=uUe});var SKt=H(Nat=>{"use strict";Object.defineProperty(Nat,"__esModule",{value:!0});var hUe=(de(),Ut(pe)),v4=(Er(),Ut(Mr)),Rat=_l(),fUe=Lf(),pUe=Bu(),dUe=ks(),Vv=Fe(),mUe=fat(),gUe=dat(),_Ue=Uu(),yUe=AF(),Md=rs(),vUe=function(e){hUe.__extends(t,e);function t(){var r=e.call(this)||this;return r._startAngle=0,r._endAngle=2*Math.PI,r._labelFormatter=pUe.identity(),r._labelsEnabled=!1,r.innerRadius(0),r.outerRadius(function(){var n=r._pieCenter();return Math.min(Math.max(r.width()-n.x,n.x),Math.max(r.height()-n.y,n.y))}),r.addClass("pie-plot"),r.attr("fill",function(n,i){return String(i)},new dUe.Color),r._strokeDrawers=new Vv.Map,r}return t.prototype._setup=function(){var r=this;e.prototype._setup.call(this),this._strokeDrawers.forEach(function(n){return n.attachTo(r._renderArea)})},t.prototype.computeLayout=function(r,n,i){e.prototype.computeLayout.call(this,r,n,i);var o=this._pieCenter();this._renderArea.attr("transform","translate("+o.x+","+o.y+")");var a=Math.min(Math.max(this.width()-o.x,o.x),Math.max(this.height()-o.y,o.y));return this.innerRadius().scale!=null&&this.innerRadius().scale.range([0,a]),this.outerRadius().scale!=null&&this.outerRadius().scale.range([0,a]),this},t.prototype.addDataset=function(r){return e.prototype.addDataset.call(this,r),this},t.prototype._addDataset=function(r){if(this.datasets().length===1)return Vv.Window.warn("Only one dataset is supported in Pie plots"),this;this._updatePieAngles(),e.prototype._addDataset.call(this,r);var n=new gUe.ArcOutlineSVGDrawer;return this._isSetup&&n.attachTo(this._renderArea),this._strokeDrawers.set(r,n),this},t.prototype.removeDataset=function(r){return e.prototype.removeDataset.call(this,r),this},t.prototype._removeDatasetNodes=function(r){e.prototype._removeDatasetNodes.call(this,r),this._strokeDrawers.get(r).remove()},t.prototype._removeDataset=function(r){return e.prototype._removeDataset.call(this,r),this._strokeDrawers.delete(r),this._startAngles=[],this._endAngles=[],this},t.prototype.selections=function(r){var n=this;r===void 0&&(r=this.datasets());var i=e.prototype.selections.call(this,r).nodes();return r.forEach(function(o){var a=n._strokeDrawers.get(o);a!=null&&i.push.apply(i,a.getVisualPrimitives())}),v4.selectAll(i)},t.prototype._onDatasetUpdate=function(){e.prototype._onDatasetUpdate.call(this),this._updatePieAngles(),this.render()},t.prototype._createDrawer=function(){return new _Ue.ProxyDrawer(function(){return new mUe.ArcSVGDrawer},function(){return yUe.warn("canvas renderer is not supported on Pie Plot!"),null})},t.prototype.entities=function(r){var n=this;r===void 0&&(r=this.datasets());var i=e.prototype.entities.call(this,r);return i.map(function(o){o.position.x+=n.width()/2,o.position.y+=n.height()/2;var a=v4.select(n._strokeDrawers.get(o.dataset).getVisualPrimitiveAtIndex(o.index)),s=o;return s.strokeSelection=a,s})},t.prototype.sectorValue=function(r,n){return r==null?this._propertyBindings.get(t._SECTOR_VALUE_KEY):(this._bindProperty(t._SECTOR_VALUE_KEY,r,n),this._updatePieAngles(),this.render(),this)},t.prototype.innerRadius=function(r,n){return r==null?this._propertyBindings.get(t._INNER_RADIUS_KEY):(this._bindProperty(t._INNER_RADIUS_KEY,r,n),this.render(),this)},t.prototype.outerRadius=function(r,n){return r==null?this._propertyBindings.get(t._OUTER_RADIUS_KEY):(this._bindProperty(t._OUTER_RADIUS_KEY,r,n),this.render(),this)},t.prototype.startAngle=function(r){return r==null?this._startAngle:(this._startAngle=r,this._updatePieAngles(),this.render(),this)},t.prototype.endAngle=function(r){return r==null?this._endAngle:(this._endAngle=r,this._updatePieAngles(),this.render(),this)},t.prototype.labelsEnabled=function(r){return r==null?this._labelsEnabled:(this._labelsEnabled=r,this.render(),this)},t.prototype.labelFormatter=function(r){return r==null?this._labelFormatter:(this._labelFormatter=r,this.render(),this)},t.prototype.entitiesAt=function(r){var n={x:this.width()/2,y:this.height()/2},i={x:r.x-n.x,y:r.y-n.y},o=this._sliceIndexForPoint(i);return o==null?[]:[this.entities()[o]]},t.prototype._propertyProjectors=function(){var r=this,n=e.prototype._propertyProjectors.call(this),i=Md.Plot._scaledAccessor(this.innerRadius()),o=Md.Plot._scaledAccessor(this.outerRadius());return n.d=function(a,s,l){return v4.arc().innerRadius(i(a,s,l)).outerRadius(o(a,s,l)).startAngle(r._startAngles[s]).endAngle(r._endAngles[s])(a,s)},n},t.prototype._updatePieAngles=function(){if(this.sectorValue()!=null&&this.datasets().length!==0){var r=Md.Plot._scaledAccessor(this.sectorValue()),n=this.datasets()[0],i=this._getDataToDraw().get(n),o=v4.pie().sort(null).startAngle(this._startAngle).endAngle(this._endAngle).value(function(a,s){return r(a,s,n)})(i);this._startAngles=o.map(function(a){return a.startAngle}),this._endAngles=o.map(function(a){return a.endAngle})}},t.prototype._pieCenter=function(){var r=this._startAngle<this._endAngle?this._startAngle:this._endAngle,n=this._startAngle<this._endAngle?this._endAngle:this._startAngle,i=Math.sin(r),o=Math.cos(r),a=Math.sin(n),s=Math.cos(n),l,c,u,h;return i>=0&&a>=0?o>=0&&s>=0?(l=o,c=0,h=0,u=a):o<0&&s<0?(l=0,c=-s,h=0,u=i):o>=0&&s<0?(l=o,c=-s,h=0,u=i):o<0&&s>=0&&(l=1,c=1,h=1,u=Math.max(i,a)):i>=0&&a<0?o>=0&&s>=0?(l=Math.max(o,s),c=1,h=1,u=1):o<0&&s<0?(l=0,c=1,h=-a,u=i):o>=0&&s<0?(l=o,c=1,h=-a,u=1):o<0&&s>=0&&(l=s,c=1,h=1,u=i):i<0&&a>=0?o>=0&&s>=0?(l=1,c=0,h=-i,u=a):o<0&&s<0?(l=1,c=Math.max(-o,-s),h=1,u=1):o>=0&&s<0?(l=1,c=-s,h=-i,u=1):o<0&&s>=0&&(l=1,c=-o,h=1,u=a):i<0&&a<0&&(o>=0&&s>=0?(l=s,c=0,h=-i,u=0):o<0&&s<0?(l=0,c=-o,h=-a,u=0):o>=0&&s<0?(l=1,c=1,h=Math.max(o,-s),u=1):o<0&&s>=0&&(l=s,c=-o,h=1,u=0)),{x:h+u==0?0:h/(h+u)*this.width(),y:l+c==0?0:l/(l+c)*this.height()}},t.prototype._getDataToDraw=function(){var r=e.prototype._getDataToDraw.call(this);if(this.datasets().length===0)return r;var n=Md.Plot._scaledAccessor(this.sectorValue()),i=this.datasets()[0],o=r.get(i),a=o.filter(function(s,l){return t._isValidData(n(s,l,i))});return r.set(i,a),r},t._isValidData=function(r){return Vv.Math.isValidNumber(r)&&r>=0},t.prototype._pixelPoint=function(r,n,i){var o=Md.Plot._scaledAccessor(this.sectorValue());if(!t._isValidData(o(r,n,i)))return{x:NaN,y:NaN};var a=Md.Plot._scaledAccessor(this.innerRadius())(r,n,i),s=Md.Plot._scaledAccessor(this.outerRadius())(r,n,i),l=(a+s)/2,c=v4.pie().sort(null).value(function(p,d){var g=o(p,d,i);return t._isValidData(g)?g:0}).startAngle(this._startAngle).endAngle(this._endAngle)(i.data()),u=c[n].startAngle,h=c[n].endAngle,f=(u+h)/2;return{x:l*Math.sin(f),y:-l*Math.cos(f)}},t.prototype._additionalPaint=function(r){var n=this;this._renderArea.select(".label-area").remove(),this._labelsEnabled&&Vv.Window.setTimeout(function(){return n._drawLabels()},r);var i=this._generateStrokeDrawSteps(),o=this._getDataToDraw();this.datasets().forEach(function(a){var s=Md.Plot.applyDrawSteps(i,a);n._strokeDrawers.get(a).draw(o.get(a),s)})},t.prototype._generateStrokeDrawSteps=function(){var r=this._getAttrToProjector();return[{attrToProjector:r,animator:new fUe.Null}]},t.prototype._sliceIndexForPoint=function(r){var n=Math.sqrt(Math.pow(r.x,2)+Math.pow(r.y,2)),i=Math.acos(-r.y/n);r.x<0&&(i=Math.PI*2-i);for(var o,a=0;a<this._startAngles.length;a++)if(this._startAngles[a]<i&&this._endAngles[a]>i){o=a;break}if(o!==void 0){var s=this.datasets()[0],l=s.data()[o],c=this.innerRadius().accessor(l,o,s),u=this.outerRadius().accessor(l,o,s);if(n>c&&n<u)return o}return null},t.prototype._drawLabels=function(){for(var r=this,n=this._getAttrToProjector(),i=this._renderArea.append("g").classed("label-area",!0),o=new Rat.SvgContext(i.node()),a=new Rat.CacheMeasurer(o),s=new Rat.Writer(a,o),l=this.datasets()[0],c=this._getDataToDraw().get(l),u=c.length,h=function(d){var g=c[d],_=f.sectorValue().accessor(g,d,l);if(!Vv.Math.isValidNumber(_))return"continue";_=f._labelFormatter(_,g,d,l);var y=a.measure(_),x=(f._endAngles[d]+f._startAngles[d])/2,b=f.outerRadius().accessor(g,d,l);f.outerRadius().scale&&(b=f.outerRadius().scale.scale(b));var S=f.innerRadius().accessor(g,d,l);f.innerRadius().scale&&(S=f.innerRadius().scale.scale(S));var C=(b+S)/2,P=Math.sin(x)*C-y.width/2,k=-Math.cos(x)*C-y.height/2,O=[{x:P,y:k},{x:P,y:k+y.height},{x:P+y.width,y:k},{x:P+y.width,y:k+y.height}],D=O.every(function(z){return Math.abs(z.x)<=r.width()/2&&Math.abs(z.y)<=r.height()/2});if(D){var B=O.map(function(z){return r._sliceIndexForPoint(z)});D=B.every(function(z){return z===d})}var I=n.fill(g,d,l),L=Vv.Color.contrast("white",I)*1.6<Vv.Color.contrast("black",I),R=i.append("g").attr("transform","translate("+P+","+k+")"),F=L?"dark-label":"light-label";R.classed(F,!0),R.style("visibility",D?"inherit":"hidden"),s.write(_,y.width,y.height,{xAlign:"center",yAlign:"center"},R.node())},f=this,p=0;p<u;p++)h(p)},t._INNER_RADIUS_KEY="inner-radius",t._OUTER_RADIUS_KEY="outer-radius",t._SECTOR_VALUE_KEY="sector-value",t}(Md.Plot);Nat.Pie=vUe});var MKt=H(Oat=>{"use strict";Object.defineProperty(Oat,"__esModule",{value:!0});var xUe=(de(),Ut(pe)),bUe=(Er(),Ut(Mr)),Dat=_l(),wUe=Lf(),SUe=Bv(),MUe=Uu(),EUe=oB(),fB=ks(),Oc=Fe(),pB=rs(),TUe=Hv(),CUe=function(e){xUe.__extends(t,e);function t(){var r=e.call(this)||this;return r._labelsEnabled=!1,r._label=null,r.animator("rectangles",new wUe.Null),r.addClass("rectangle-plot"),r.attr("fill",new fB.Color().range()[0]),r}return t.prototype._createDrawer=function(){return new MUe.ProxyDrawer(function(){return new EUe.RectangleSVGDrawer},function(r){return new SUe.RectangleCanvasDrawer(r)})},t.prototype._generateAttrToProjector=function(){var r=this,n=e.prototype._generateAttrToProjector.call(this),i=pB.Plot._scaledAccessor(this.x()),o=n[t._X2_KEY],a=pB.Plot._scaledAccessor(this.y()),s=n[t._Y2_KEY],l=this.x().scale,c=this.y().scale;return o!=null?(n.width=function(u,h,f){return Math.abs(o(u,h,f)-i(u,h,f))},n.x=function(u,h,f){return Math.min(o(u,h,f),i(u,h,f))}):(n.width=function(u,h,f){return r._rectangleWidth(l)},n.x=function(u,h,f){return i(u,h,f)-.5*n.width(u,h,f)}),s!=null?(n.height=function(u,h,f){return Math.abs(s(u,h,f)-a(u,h,f))},n.y=function(u,h,f){return Math.max(s(u,h,f),a(u,h,f))-n.height(u,h,f)}):(n.height=function(u,h,f){return r._rectangleWidth(c)},n.y=function(u,h,f){return a(u,h,f)-.5*n.height(u,h,f)}),delete n[t._X2_KEY],delete n[t._Y2_KEY],n},t.prototype._generateDrawSteps=function(){return[{attrToProjector:this._getAttrToProjector(),animator:this._getAnimator("rectangles")}]},t.prototype._filterForProperty=function(r){return r==="x2"?e.prototype._filterForProperty.call(this,"x"):r==="y2"?e.prototype._filterForProperty.call(this,"y"):e.prototype._filterForProperty.call(this,r)},t.prototype.x=function(r,n,i){if(r==null)return e.prototype.x.call(this);if(n==null?e.prototype.x.call(this,r):e.prototype.x.call(this,r,n,i),n!=null){var o=this.x2(),a=o&&o.accessor;a!=null&&this._bindProperty(t._X2_KEY,a,n,o.postScale)}return n instanceof fB.Category&&n.innerPadding(0).outerPadding(0),this},t.prototype.x2=function(r,n){if(r==null)return this._propertyBindings.get(t._X2_KEY);var i=this.x(),o=i&&i.scale;return this._bindProperty(t._X2_KEY,r,o,n),this.render(),this},t.prototype.y=function(r,n,i){if(r==null)return e.prototype.y.call(this);if(n==null?e.prototype.y.call(this,r):e.prototype.y.call(this,r,n,i),n!=null){var o=this.y2(),a=o&&o.accessor;a!=null&&this._bindProperty(t._Y2_KEY,a,n,o.postScale)}return n instanceof fB.Category&&n.innerPadding(0).outerPadding(0),this},t.prototype.y2=function(r,n){if(r==null)return this._propertyBindings.get(t._Y2_KEY);var i=this.y(),o=i&&i.scale;return this._bindProperty(t._Y2_KEY,r,o,n),this.render(),this},t.prototype.entitiesAt=function(r){var n=this._getAttrToProjector();return this.entities().filter(function(i){var o=i.datum,a=i.index,s=i.dataset,l=n.x(o,a,s),c=n.y(o,a,s),u=n.width(o,a,s),h=n.height(o,a,s);return l<=r.x&&r.x<=l+u&&c<=r.y&&r.y<=c+h})},t.prototype._entityBounds=function(r){var n=r.datum,i=r.index,o=r.dataset;return this._entityBBox(n,i,o,this._getAttrToProjector())},t.prototype._entityBBox=function(r,n,i,o){return{x:o.x(r,n,i),y:o.y(r,n,i),width:o.width(r,n,i),height:o.height(r,n,i)}},t.prototype.label=function(r){return r==null?this._label:(this._label=r,this.render(),this)},t.prototype.labelsEnabled=function(r){return r==null?this._labelsEnabled:(this._labelsEnabled=r,this.render(),this)},t.prototype._propertyProjectors=function(){var r=e.prototype._propertyProjectors.call(this);return this.x2()!=null&&(r.x2=pB.Plot._scaledAccessor(this.x2())),this.y2()!=null&&(r.y2=pB.Plot._scaledAccessor(this.y2())),r},t.prototype._pixelPoint=function(r,n,i){var o=this._getAttrToProjector(),a=o.x(r,n,i),s=o.y(r,n,i),l=o.width(r,n,i),c=o.height(r,n,i),u=a+l/2,h=s+c/2;return{x:u,y:h}},t.prototype._rectangleWidth=function(r){if(r instanceof fB.Category)return r.rangeBand();var n=r===this.x().scale?this.x().accessor:this.y().accessor,i=bUe.set(Oc.Array.flatten(this.datasets().map(function(c){return c.data().map(function(u,h){return n(u,h,c).valueOf()})}))).values().map(function(c){return+c}),o=Oc.Math.min(i,0),a=Oc.Math.max(i,0),s=r.scale(o),l=r.scale(a);return(l-s)/Math.abs(a-o)},t.prototype._getDataToDraw=function(){var r=new Oc.Map,n=this._getAttrToProjector();return this.datasets().forEach(function(i){var o=i.data().map(function(a,s){var l=Oc.Math.isValidNumber(n.x(a,s,i))&&Oc.Math.isValidNumber(n.y(a,s,i))&&Oc.Math.isValidNumber(n.width(a,s,i))&&Oc.Math.isValidNumber(n.height(a,s,i));return l?a:null});r.set(i,o)}),r},t.prototype._additionalPaint=function(r){var n=this;this._renderArea.selectAll(".label-area").remove(),this._labelsEnabled&&this.label()!=null&&Oc.Window.setTimeout(function(){return n._drawLabels()},r)},t.prototype._drawLabels=function(){var r=this,n=this._getDataToDraw();this.datasets().forEach(function(i,o){return r._drawLabel(n,i,o)})},t.prototype._drawLabel=function(r,n,i){for(var o=this._getAttrToProjector(),a=this._renderArea.append("g").classed("label-area",!0),s=new Dat.SvgContext(a.node()),l=new Dat.CacheMeasurer(s),c=new Dat.Writer(l,s),u=this.x().scale.range(),h=this.y().scale.range(),f=Math.min.apply(null,u),p=Math.max.apply(null,u),d=Math.min.apply(null,h),g=Math.max.apply(null,h),_=r.get(n),y=_.length,x=0;x<y;x++){var b=_[x];if(b!=null){var S=""+this.label()(b,x,n),C=l.measure(S),P=o.x(b,x,n),k=o.y(b,x,n),O=o.width(b,x,n),D=o.height(b,x,n);if(C.height<=D&&C.width<=O){var B=(O-C.width)/2,I=(D-C.height)/2;P+=B,k+=I;var L={min:P,max:P+C.width},R={min:k,max:k+C.height};if(L.min<f||L.max>p||R.min<d||R.max>g||this._overlayLabel(L,R,x,i,r))continue;var F=o.fill(b,x,n),z=Oc.Color.contrast("white",F)*1.6<Oc.Color.contrast("black",F),U=a.append("g").attr("transform","translate("+P+","+k+")"),W=z?"dark-label":"light-label";U.classed(W,!0),c.write(S,C.width,C.height,{xAlign:"center",yAlign:"center"},U.node())}}}},t.prototype._overlayLabel=function(r,n,i,o,a){for(var s=this._getAttrToProjector(),l=this.datasets(),c=o;c<l.length;c++)for(var u=l[c],h=a.get(u),f=h.length,p=c===o?i+1:0;p<f;p++)if(Oc.DOM.intersectsBBox(r,n,this._entityBBox(h[p],p,u,s)))return!0;return!1},t._X2_KEY="x2",t._Y2_KEY="y2",t}(TUe.XYPlot);Oat.Rectangle=CUe});var TKt=H(Hat=>{"use strict";Object.defineProperty(Hat,"__esModule",{value:!0});var AUe=(de(),Ut(pe)),zat=_l(),PUe=Bu(),IUe=XF(),LUe=Uu(),EKt=vat(),kUe=Lf(),RUe=Bv(),NUe=ks(),Fat=Fe(),Bat=IS(),bl=rs(),DUe=Hv(),OUe=function(e){AUe.__extends(t,e);function t(){var r=e.call(this)||this;r._labelFormatter=PUe.identity(),r._labelsEnabled=!1,r.addClass("scatter-plot");var n=new kUe.Easing;n.startDelay(5),n.stepDuration(250),n.maxTotalDuration(bl.Plot._ANIMATION_MAX_DURATION),r.animator(Bat.Animator.MAIN,n),r.attr("opacity",.6),r.attr("fill",new NUe.Color().range()[0]),r.size(6);var i=IUe.circle();return r.symbol(function(){return i}),r._labelConfig=new Fat.Map,r}return t.prototype._buildLightweightPlotEntities=function(r){var n=this,i=e.prototype._buildLightweightPlotEntities.call(this,r);return i.map(function(o){var a=bl.Plot._scaledAccessor(n.size())(o.datum,o.index,o.dataset);return o.diameter=a,o})},t.prototype._createDrawer=function(r){var n=this;return new LUe.ProxyDrawer(function(){return new EKt.SymbolSVGDrawer},function(i){return new RUe.CanvasDrawer(i,EKt.makeSymbolCanvasDrawStep(r,function(){return bl.Plot._scaledAccessor(n.symbol())},function(){return bl.Plot._scaledAccessor(n.size())}))})},t.prototype.size=function(r,n){return r==null?this._propertyBindings.get(t._SIZE_KEY):(this._bindProperty(t._SIZE_KEY,r,n),this.render(),this)},t.prototype.symbol=function(r){return r==null?this._propertyBindings.get(t._SYMBOL_KEY):(this._propertyBindings.set(t._SYMBOL_KEY,{accessor:r}),this.render(),this)},t.prototype._generateDrawSteps=function(){var r=[];if(this._animateOnNextRender()){var n=this._getAttrToProjector(),i=bl.Plot._scaledAccessor(this.symbol());n.d=function(o,a,s){return i(o,a,s)(0)(null)},r.push({attrToProjector:n,animator:this._getAnimator(Bat.Animator.RESET)})}return r.push({attrToProjector:this._getAttrToProjector(),animator:this._getAnimator(Bat.Animator.MAIN)}),r},t.prototype._propertyProjectors=function(){var r=e.prototype._propertyProjectors.call(this),n=bl.Plot._scaledAccessor(this.x()),i=bl.Plot._scaledAccessor(this.y());return r.x=n,r.y=i,r.transform=function(o,a,s){return"translate("+n(o,a,s)+","+i(o,a,s)+")"},r.d=this._constructSymbolGenerator(),r},t.prototype._constructSymbolGenerator=function(){var r=bl.Plot._scaledAccessor(this.symbol()),n=bl.Plot._scaledAccessor(this.size());return function(i,o,a){return r(i,o,a)(n(i,o,a))(null)}},t.prototype._entityBounds=function(r){return{x:r.position.x-r.diameter/2,y:r.position.y-r.diameter/2,width:r.diameter,height:r.diameter}},t.prototype._entityVisibleOnPlot=function(r,n){var i={min:n.topLeft.x,max:n.bottomRight.x},o={min:n.topLeft.y,max:n.bottomRight.y},a=this._entityBounds(r);return Fat.DOM.intersectsBBox(i,o,a)},t.prototype.entitiesAt=function(r){var n=bl.Plot._scaledAccessor(this.x()),i=bl.Plot._scaledAccessor(this.y()),o=bl.Plot._scaledAccessor(this.size());return this.entities().filter(function(a){var s=a.datum,l=a.index,c=a.dataset,u=n(s,l,c),h=i(s,l,c),f=o(s,l,c);return u-f/2<=r.x&&r.x<=u+f/2&&h-f/2<=r.y&&r.y<=h+f/2})},t.prototype.labelsEnabled=function(r){return r==null?this._labelsEnabled:(this._labelsEnabled=r,this._clearAttrToProjectorCache(),this.render(),this)},t.prototype._createNodesForDataset=function(r){var n=e.prototype._createNodesForDataset.call(this,r),i=this._renderArea.append("g").classed(t._LABEL_AREA_CLASS,!0),o=new zat.SvgContext(i.node()),a=new zat.CacheMeasurer(o),s=new zat.Writer(a,o);return this._labelConfig.set(r,{labelArea:i,measurer:a,writer:s}),n},t.prototype._removeDatasetNodes=function(r){e.prototype._removeDatasetNodes.call(this,r);var n=this._labelConfig.get(r);n!=null&&(n.labelArea.remove(),this._labelConfig.delete(r))},t.prototype._additionalPaint=function(r){var n=this;this.datasets().forEach(function(i){return n._labelConfig.get(i).labelArea.selectAll("g").remove()}),this._labelsEnabled&&Fat.Window.setTimeout(function(){return n._drawLabels()},r)},t.prototype._drawLabels=function(){var r=this,n=this._getDataToDraw(),i=this._getAttrToProjector();this.datasets().forEach(function(o){for(var a=n.get(o),s=a.length,l=0;l<s;l++){var c=a[l];c!=null&&r._drawLabel(c,l,o,i)}})},t.prototype._drawLabel=function(r,n,i,o){if(r.label!=null){var a=this._labelConfig.get(i),s=a.labelArea,l=a.measurer,c=a.writer,u={x:o.x(r,n,i),y:o.y(r,n,i)},h=bl.Plot._scaledAccessor(this.size()),f=h(r,n,i),p=this._labelFormatter(r.label,r,n,i),d=l.measure(p),g=this._calculateLabelProperties(u,f,d),_=g.containerDimensions,y=g.labelContainerOrigin,x=g.labelOrigin,b=g.alignment,S=this._createLabelContainer(s,y,x,d),C={xAlign:b.x,yAlign:b.y};c.write(p,_.width,_.height,C,S.node())}},t.prototype._calculateLabelProperties=function(r,n,i){var o=n<i.height?n/2+t._LABEL_MARGIN_FROM_BUBBLE:0;return{containerDimensions:{width:i.width,height:i.height},labelContainerOrigin:{x:r.x-i.width/2,y:r.y-i.height/2+o},labelOrigin:{x:r.x,y:r.y},alignment:{x:"center",y:"center"}}},t.prototype._createLabelContainer=function(r,n,i,o){var a=r.append("g").attr("transform","translate("+n.x+", "+n.y+")");return a.classed("on-bar-label",!0),a},t._SIZE_KEY="size",t._SYMBOL_KEY="symbol",t._LABEL_AREA_CLASS="scatter-label-text-area",t._LABEL_MARGIN_FROM_BUBBLE=15,t}(DUe.XYPlot);Hat.Scatter=OUe});var CKt=H(Vat=>{"use strict";Object.defineProperty(Vat,"__esModule",{value:!0});var zUe=(de(),Ut(pe)),FUe=Lf(),BUe=Uu(),HUe=_at(),VUe=ks(),UUe=AF(),LS=rs(),qUe=Hv(),GUe=function(e){zUe.__extends(t,e);function t(){var r=e.call(this)||this;return r.addClass("segment-plot"),r.attr("stroke",new VUe.Color().range()[0]),r.attr("stroke-width","2px"),r}return t.prototype._createDrawer=function(){return new BUe.ProxyDrawer(function(){return new HUe.SegmentSVGDrawer},function(){return UUe.warn("canvas renderer is not supported on Segment Plot!"),null})},t.prototype._generateDrawSteps=function(){return[{attrToProjector:this._getAttrToProjector(),animator:new FUe.Null}]},t.prototype._filterForProperty=function(r){return r==="x2"?e.prototype._filterForProperty.call(this,"x"):r==="y2"?e.prototype._filterForProperty.call(this,"y"):e.prototype._filterForProperty.call(this,r)},t.prototype.x=function(r,n){if(r==null)return e.prototype.x.call(this);if(n==null)e.prototype.x.call(this,r);else{e.prototype.x.call(this,r,n);var i=this.x2(),o=i&&i.accessor;o!=null&&this._bindProperty(t._X2_KEY,o,n)}return this},t.prototype.x2=function(r){if(r==null)return this._propertyBindings.get(t._X2_KEY);var n=this.x(),i=n&&n.scale;return this._bindProperty(t._X2_KEY,r,i),this.render(),this},t.prototype.y=function(r,n){if(r==null)return e.prototype.y.call(this);if(n==null)e.prototype.y.call(this,r);else{e.prototype.y.call(this,r,n);var i=this.y2(),o=i&&i.accessor;o!=null&&this._bindProperty(t._Y2_KEY,o,n)}return this},t.prototype.y2=function(r){if(r==null)return this._propertyBindings.get(t._Y2_KEY);var n=this.y(),i=n&&n.scale;return this._bindProperty(t._Y2_KEY,r,i),this.render(),this},t.prototype._propertyProjectors=function(){var r=e.prototype._propertyProjectors.call(this);return r.x1=LS.Plot._scaledAccessor(this.x()),r.x2=this.x2()==null?LS.Plot._scaledAccessor(this.x()):LS.Plot._scaledAccessor(this.x2()),r.y1=LS.Plot._scaledAccessor(this.y()),r.y2=this.y2()==null?LS.Plot._scaledAccessor(this.y()):LS.Plot._scaledAccessor(this.y2()),r},t.prototype.entitiesAt=function(r){var n=this.entityNearest(r);return n!=null?[n]:[]},t.prototype.entitiesIn=function(r,n){var i,o;if(n==null){var a=r;i={min:a.topLeft.x,max:a.bottomRight.x},o={min:a.topLeft.y,max:a.bottomRight.y}}else i=r,o=n;return this._entitiesIntersecting(i,o)},t.prototype._entitiesIntersecting=function(r,n){for(var i=[],o=this._getAttrToProjector(),a=this.entities(),s=a.length,l=0;l<s;l++){var c=a[l];this._lineIntersectsBox(c,r,n,o)&&i.push(c)}return i},t.prototype._lineIntersectsBox=function(r,n,i,o){var a=this,s=o.x1(r.datum,r.index,r.dataset),l=o.x2(r.datum,r.index,r.dataset),c=o.y1(r.datum,r.index,r.dataset),u=o.y2(r.datum,r.index,r.dataset);if(n.min<=s&&s<=n.max&&i.min<=c&&c<=i.max||n.min<=l&&l<=n.max&&i.min<=u&&u<=i.max)return!0;var h={x:s,y:c},f={x:l,y:u},p=[{x:n.min,y:i.min},{x:n.min,y:i.max},{x:n.max,y:i.max},{x:n.max,y:i.min}],d=p.filter(function(g,_){return _!==0?a._lineIntersectsSegment(h,f,g,p[_-1])&&a._lineIntersectsSegment(g,p[_-1],h,f):!1});return d.length>0},t.prototype._lineIntersectsSegment=function(r,n,i,o){var a=function(s,l,c){return(l.x-s.x)*(c.y-l.y)-(l.y-s.y)*(c.x-l.x)};return a(r,n,i)*a(r,n,o)<0},t._X2_KEY="x2",t._Y2_KEY="y2",t}(qUe.XYPlot);Vat.Segment=GUe});var IKt=H(Uat=>{"use strict";Object.defineProperty(Uat,"__esModule",{value:!0});var WUe=(de(),Ut(pe)),AKt=(Er(),Ut(Mr)),YUe=Lf(),PKt=CS(),t0=Fe(),jUe=Tat(),XUe=rs(),$Ue=function(e){WUe.__extends(t,e);function t(){var r=e.call(this)||this;return r._stackingResult=PKt.memThunk(function(){return r.datasets()},function(){return r.x().accessor},function(){return r.y().accessor},function(){return r._stackingOrder},function(n,i,o,a){return t0.Stacking.stack(n,i,o,a)}),r._stackedExtent=PKt.memThunk(r._stackingResult,function(){return r.x().accessor},function(){return r._filterForProperty("y")},function(n,i,o){return t0.Stacking.stackedExtent(n,i,o)}),r._baselineValue=0,r._stackingOrder="bottomup",r.addClass("stacked-area-plot"),r._baselineValueProvider=function(){return[r._baselineValue]},r.croppedRenderingEnabled(!1),r}return t.prototype.croppedRenderingEnabled=function(r){return r==null?e.prototype.croppedRenderingEnabled.call(this):r?(t0.Window.warn("Warning: Stacked Area Plot does not support cropped rendering."),this):e.prototype.croppedRenderingEnabled.call(this,r)},t.prototype._getAnimator=function(r){return new YUe.Null},t.prototype._setup=function(){e.prototype._setup.call(this),this._baseline=this._renderArea.append("line").classed("baseline",!0)},t.prototype.x=function(r,n){return r==null?e.prototype.x.call(this):(n==null?e.prototype.x.call(this,r):e.prototype.x.call(this,r,n),this._checkSameDomain(),this)},t.prototype.y=function(r,n){return r==null?e.prototype.y.call(this):(n==null?e.prototype.y.call(this,r):e.prototype.y.call(this,r,n),this._checkSameDomain(),this)},t.prototype.yOffset=function(r,n){var i=this._stackingResult();if(i!=null){var o=i.get(r);if(o!=null){var a=o.get(String(n));if(a!=null)return a.offset}}},t.prototype.stackingOrder=function(r){return r==null?this._stackingOrder:(this._stackingOrder=r,this._onDatasetUpdate(),this)},t.prototype.downsamplingEnabled=function(r){return r==null?e.prototype.downsamplingEnabled.call(this):(t0.Window.warn("Warning: Stacked Area Plot does not support downsampling"),this)},t.prototype._additionalPaint=function(){var r=this.y().scale.scale(this._baselineValue),n={x1:0,y1:r,x2:this.width(),y2:r};this._getAnimator("baseline").animate(this._baseline,n)},t.prototype._updateYScale=function(){var r=this.y(),n=r&&r.scale;n!=null&&(n.addPaddingExceptionsProvider(this._baselineValueProvider),n.addIncludedValuesProvider(this._baselineValueProvider))},t.prototype._onDatasetUpdate=function(){return this._checkSameDomain(),e.prototype._onDatasetUpdate.call(this),this},t.prototype.getExtentsForProperty=function(r){var n="y";return r===n?[this._stackedExtent()]:e.prototype.getExtentsForProperty.call(this,r)},t.prototype._checkSameDomain=function(){if(!!this._projectorsReady()){var r=this.datasets(),n=this.x().accessor,i=r.map(function(a){return AKt.set(a.data().map(function(s,l){return t0.Stacking.normalizeKey(n(s,l,a))})).values()}),o=t._domainKeys(r,n);i.some(function(a){return a.length!==o.length})&&t0.Window.warn("the domains across the datasets are not the same. Plot may produce unintended behavior.")}},t._domainKeys=function(r,n){var i=AKt.set();return r.forEach(function(o){for(var a=o.data(),s=a.length,l=0;l<s;l++){var c=a[l];i.add(n(c,l,o))}}),i.values()},t.prototype._coordinateProjectors=function(){var r=this,n=XUe.Plot._scaledAccessor(this.x()),i=this.y().accessor,o=this.x().accessor,a=function(u,h,f){return t0.Stacking.normalizeKey(o(u,h,f))},s=this._stackingResult(),l=function(u,h,f){var p=+i(u,h,f),d=s.get(f).get(a(u,h,f)).offset;return r.y().scale.scale(p+d)},c=function(u,h,f){var p=s.get(f).get(a(u,h,f)).offset;return r.y().scale.scale(p)};return[n,l,c]},t.prototype._propertyProjectors=function(){var r=e.prototype._propertyProjectors.call(this),n=this._coordinateProjectors(),i=n[0],o=n[1],a=n[2];return r.d=this._constructAreaProjector(i,o,a),r},t.prototype._pixelPoint=function(r,n,i){var o=e.prototype._pixelPoint.call(this,r,n,i),a=this.x().accessor(r,n,i),s=this.y().accessor(r,n,i),l=this.y().scale.scale(+s+this._stackingResult().get(i).get(t0.Stacking.normalizeKey(a)).offset);return{x:o.x,y:l}},t}(jUe.Area);Uat.StackedArea=$Ue});var kKt=H(Wat=>{"use strict";Object.defineProperty(Wat,"__esModule",{value:!0});var KUe=(de(),Ut(pe)),qat=_l(),ZUe=Bu(),LKt=CS(),dB=Fe(),Gat=y4(),JUe=rs(),QUe=function(e){KUe.__extends(t,e);function t(r){r===void 0&&(r="vertical");var n=e.call(this,r)||this;return n._extremaFormatter=ZUe.identity(),n._stackingResult=LKt.memThunk(function(){return n.datasets()},function(){return n.position().accessor},function(){return n.length().accessor},function(){return n._stackingOrder},function(i,o,a,s){return dB.Stacking.stack(i,o,a,s)}),n._stackedExtent=LKt.memThunk(n._stackingResult,function(){return n.position().accessor},function(){return n._filterForProperty(n._isVertical?"y":"x")},function(i,o,a){return dB.Stacking.stackedExtent(i,o,a)}),n.addClass("stacked-bar-plot"),n._stackingOrder="bottomup",n}return t.prototype.stackingOrder=function(r){return r==null?this._stackingOrder:(this._stackingOrder=r,this._onDatasetUpdate(),this)},t.prototype.extremaFormatter=function(r){return arguments.length===0?this._extremaFormatter:(this._extremaFormatter=r,this.render(),this)},t.prototype._setup=function(){e.prototype._setup.call(this),this._labelArea=this._renderArea.append("g").classed(Gat.Bar._LABEL_AREA_CLASS,!0);var r=new qat.SvgContext(this._labelArea.node());this._measurer=new qat.CacheMeasurer(r),this._writer=new qat.Writer(this._measurer,r)},t.prototype._drawLabels=function(){var r=this;e.prototype._drawLabels.call(this),this._labelArea.selectAll("g").remove();var n=+this.baselineValue(),i=this.position().scale,o=this.length().scale,a=dB.Stacking.stackedExtents(this._stackingResult()),s=a.maximumExtents,l=a.minimumExtents,c=[],u=function(f,p,d){var g=p.topLeft,_=g.x,y=g.y,x=p.bottomRight.x-p.topLeft.x,b=p.bottomRight.y-p.topLeft.y,S=r._isVertical?x>d:b>d;if(!S){var C=r._labelArea.append("g").attr("transform","translate("+_+", "+y+")");C.classed("stacked-bar-label",!0);var P={xAlign:"center",yAlign:"center"};r._writer.write(f,x,b,P,C.node())}return S},h=function(f,p){var d=r._generateAttrToProjector(),g=r.width(),_=r.height();f.forEach(function(y){if(y.extent!==n){var x=r.extremaFormatter()(y.extent),b=r._measurer.measure(x),S=y.stackedDatum,C=S.originalDatum,P=S.originalIndex,k=S.originalDataset;if(!r._isDatumOnScreen(d,g,_,C,P,k))return;var O=JUe.Plot._scaledAccessor(r.attr(Gat.Bar._BAR_THICKNESS_KEY))(C,P,k),D=o.scale(y.extent),B=r._getPositionAttr(i.scale(y.axisValue),O)+O/2,I=r._isVertical?{x:B,y:D}:{x:D,y:B},L=p(I,b,O),R=u(x,{topLeft:L,bottomRight:{x:L.x+b.width,y:L.y+b.height}},O);c.push(R)}})};h(s,function(f,p,d){var g=r._isVertical?p.width:p.height,_=r._isVertical?p.height:p.width;return{x:r._isVertical?f.x-g/2:f.x+t._EXTREMA_LABEL_MARGIN_FROM_BAR,y:r._isVertical?f.y-_:f.y-g/2}}),h(l,function(f,p,d){var g=r._isVertical?p.width:p.height,_=r._isVertical?p.height:p.width;return{x:r._isVertical?f.x-g/2:f.x-_,y:r._isVertical?f.y+t._EXTREMA_LABEL_MARGIN_FROM_BAR:f.y-g/2}}),c.some(function(f){return f})&&this._labelArea.selectAll("g").remove()},t.prototype._generateAttrToProjector=function(){var r=this,n=e.prototype._generateAttrToProjector.call(this),i=this._isVertical?"y":"x",o=this.length().scale,a=this.length().accessor,s=this.position().accessor,l=function(d,g,_){return dB.Stacking.normalizeKey(s(d,g,_))},c=this._stackingResult(),u=function(d,g,_){return o.scale(c.get(_).get(l(d,g,_)).offset)},h=function(d,g,_){return o.scale(+a(d,g,_)+c.get(_).get(l(d,g,_)).offset)},f=function(d,g,_){return Math.abs(h(d,g,_)-u(d,g,_))};n[this._isVertical?"height":"width"]=f;var p=function(d,g,_){return+a(d,g,_)<0?u(d,g,_):h(d,g,_)};return n[i]=function(d,g,_){return r._isVertical?p(d,g,_):p(d,g,_)-f(d,g,_)},n},t.prototype.getExtentsForProperty=function(r){var n=this._isVertical?"y":"x";return r===n?[this._stackedExtent()]:e.prototype.getExtentsForProperty.call(this,r)},t.prototype.invalidateCache=function(){e.prototype.invalidateCache.call(this),this._measurer.reset()},t._EXTREMA_LABEL_MARGIN_FROM_BAR=5,t}(Gat.Bar);Wat.StackedBar=QUe});var RKt=H(Yat=>{"use strict";Object.defineProperty(Yat,"__esModule",{value:!0});var tqe=(de(),Ut(pe)),eqe=Fe(),rqe=y4(),nqe=rs(),iqe=function(e){tqe.__extends(t,e);function t(){var r=e.call(this)||this;return r._connectorsEnabled=!1,r.addClass("waterfall-plot"),r}return t.prototype.connectorsEnabled=function(r){return r==null?this._connectorsEnabled:(this._connectorsEnabled=r,this)},t.prototype.total=function(r){return r==null?this._propertyBindings.get(t._TOTAL_KEY):(this._bindProperty(t._TOTAL_KEY,r,null),this)},t.prototype._additionalPaint=function(r){var n=this;this._connectorArea.selectAll("line").remove(),this._connectorsEnabled&&eqe.Window.setTimeout(function(){return n._drawConnectors()},r)},t.prototype._createNodesForDataset=function(r){var n=e.prototype._createNodesForDataset.call(this,r);return this._connectorArea=this._renderArea.append("g").classed(t._CONNECTOR_AREA_CLASS,!0),n},t.prototype.getExtentsForProperty=function(r){var n="y";return r===n?[this._extent]:e.prototype.getExtentsForProperty.call(this,r)},t.prototype._generateAttrToProjector=function(){var r=this,n=e.prototype._generateAttrToProjector.call(this),i=this.y().scale,o=nqe.Plot._scaledAccessor(this.total()),a=this.attr("y");a==null&&(n.y=function(l,c,u){var h=r.y().accessor(l,c,u),f=o(l,c,u);if(f)return Math.min(i.scale(h),i.scale(0));var p=r._subtotals[c];if(c===0)return h<0?i.scale(p-h):i.scale(p);var d=r._subtotals[c-1];return p>d?i.scale(p):i.scale(d)});var s=this.attr("height");return s==null&&(n.height=function(l,c,u){var h=o(l,c,u),f=r.y().accessor(l,c,u);if(h)return Math.abs(i.scale(f)-i.scale(0));var p=r._subtotals[c];if(c===0)return Math.abs(i.scale(p)-i.scale(p-f));var d=r._subtotals[c-1];return Math.abs(i.scale(p)-i.scale(d))}),n.class=function(l,c,u){var h="";r.attr("class")!=null&&(h=r.attr("class").accessor(l,c,u)+" ");var f=o(l,c,u);if(f)return h+t._BAR_TOTAL_CLASS;var p=r.y().accessor(l,c,u);return h+(p>0?t._BAR_GROWTH_CLASS:t._BAR_DECLINE_CLASS)},n},t.prototype._onDatasetUpdate=function(){return this._updateSubtotals(),e.prototype._onDatasetUpdate.call(this),this},t.prototype._calculateSubtotalsAndExtent=function(r){for(var n=Number.MAX_VALUE,i=Number.MIN_VALUE,o=0,a=!1,s=r.data(),l=s.length,c=0;c<l;c++){var u=s[c],h=this.y().accessor(u,c,r),f=this.total().accessor(u,c,r);if((!f||c===0)&&(o+=h),this._subtotals.push(o),o<n&&(n=o),o>i&&(i=o),f&&(h<n&&(n=h),h>i&&(i=h)),!a&&f){for(var p=h-o,d=0;d<this._subtotals.length;d++)this._subtotals[d]+=p;a=!0,o+=p,n+=p,i+=p}}this._extent=[n,i]},t.prototype._drawConnectors=function(){for(var r=this._getAttrToProjector(),n=this.datasets()[0],i=1;i<n.data().length;i++){var o=i-1,a=n.data()[i],s=n.data()[o],l=r.x(s,o,n),c=r.x(a,i,n)+r.width(a,i,n),u=r.y(a,i,n);(this._subtotals[i]>0&&this._subtotals[i]>this._subtotals[o]||this._subtotals[i]<0&&this._subtotals[i]>=this._subtotals[o])&&(u=r.y(a,i,n)+r.height(a,i,n)),this._connectorArea.append("line").classed(t._CONNECTOR_CLASS,!0).attr("x1",l).attr("x2",c).attr("y1",u).attr("y2",u)}},t.prototype._updateSubtotals=function(){var r=this.datasets();if(r.length>0){var n=r[r.length-1];this._subtotals=new Array,this._calculateSubtotalsAndExtent(n)}},t._BAR_DECLINE_CLASS="waterfall-decline",t._BAR_GROWTH_CLASS="waterfall-growth",t._BAR_TOTAL_CLASS="waterfall-total",t._CONNECTOR_CLASS="connector",t._CONNECTOR_AREA_CLASS="connector-area",t._TOTAL_KEY="total",t}(rqe.Bar);Yat.Waterfall=iqe});var IS=H(Os=>{"use strict";Object.defineProperty(Os,"__esModule",{value:!0});var zc=(de(),Ut(pe));zc.__exportStar(Tat(),Os);zc.__exportStar(y4(),Os);zc.__exportStar(Got(),Os);zc.__exportStar(wKt(),Os);zc.__exportStar(Sat(),Os);zc.__exportStar(SKt(),Os);zc.__exportStar(MKt(),Os);zc.__exportStar(TKt(),Os);zc.__exportStar(CKt(),Os);zc.__exportStar(IKt(),Os);zc.__exportStar(kKt(),Os);zc.__exportStar(RKt(),Os)});var NKt=H(jat=>{"use strict";Object.defineProperty(jat,"__esModule",{value:!0});jat.version="3.9.0"});var wl=H(ln=>{"use strict";Object.defineProperty(ln,"__esModule",{value:!0});var Fc=(de(),Ut(pe));$jt();var oqe=Lf();ln.Animators=oqe;var aqe=f$t();ln.Axes=aqe;var sqe=Pot();ln.Components=sqe;var lqe=$A();ln.Configs=lqe;var cqe=Bu();ln.Formatters=cqe;var uqe=IF();ln.RenderController=uqe;var hqe=Hit();ln.RenderPolicies=hqe;var fqe=XF();ln.SymbolFactories=fqe;var pqe=Nv();ln.Dispatchers=pqe;var dqe=Bv();ln.Drawers=dqe;var mqe=l4();ln.Interactions=mqe;var gqe=IS();ln.Plots=gqe;var _qe=ks();ln.Scales=_qe;var yqe=Fe();ln.Utils=yqe;Fc.__exportStar(t4(),ln);var vqe=HF();ln.TimeInterval=vqe.TimeInterval;Fc.__exportStar(kc(),ln);Fc.__exportStar(WF(),ln);Fc.__exportStar(Yot(),ln);var xqe=NKt();ln.version=xqe.version;Fc.__exportStar(o4(),ln);Fc.__exportStar(Uu(),ln);Fc.__exportStar(Dv(),ln);Fc.__exportStar(wot(),ln);Fc.__exportStar(Hv(),ln);Fc.__exportStar(rs(),ln);Fc.__exportStar(vd(),ln);Fc.__exportStar(Lv(),ln)});var QKt=H((sXn,JKt)=>{function Bqe(){this.__data__=[],this.size=0}JKt.exports=Bqe});var Yv=H((lXn,tZt)=>{function Hqe(e,t){return e===t||e!==e&&t!==t}tZt.exports=Hqe});var M4=H((cXn,eZt)=>{var Vqe=Yv();function Uqe(e,t){for(var r=e.length;r--;)if(Vqe(e[r][0],t))return r;return-1}eZt.exports=Uqe});var nZt=H((uXn,rZt)=>{var qqe=M4(),Gqe=Array.prototype,Wqe=Gqe.splice;function Yqe(e){var t=this.__data__,r=qqe(t,e);if(r<0)return!1;var n=t.length-1;return r==n?t.pop():Wqe.call(t,r,1),--this.size,!0}rZt.exports=Yqe});var oZt=H((hXn,iZt)=>{var jqe=M4();function Xqe(e){var t=this.__data__,r=jqe(t,e);return r<0?void 0:t[r][1]}iZt.exports=Xqe});var sZt=H((fXn,aZt)=>{var $qe=M4();function Kqe(e){return $qe(this.__data__,e)>-1}aZt.exports=Kqe});var cZt=H((pXn,lZt)=>{var Zqe=M4();function Jqe(e,t){var r=this.__data__,n=Zqe(r,e);return n<0?(++this.size,r.push([e,t])):r[n][1]=t,this}lZt.exports=Jqe});var E4=H((dXn,uZt)=>{var Qqe=QKt(),tGe=nZt(),eGe=oZt(),rGe=sZt(),nGe=cZt();function zS(e){var t=-1,r=e==null?0:e.length;for(this.clear();++t<r;){var n=e[t];this.set(n[0],n[1])}}zS.prototype.clear=Qqe;zS.prototype.delete=tGe;zS.prototype.get=eGe;zS.prototype.has=rGe;zS.prototype.set=nGe;uZt.exports=zS});var fZt=H((mXn,hZt)=>{var iGe=E4();function oGe(){this.__data__=new iGe,this.size=0}hZt.exports=oGe});var dZt=H((gXn,pZt)=>{function aGe(e){var t=this.__data__,r=t.delete(e);return this.size=t.size,r}pZt.exports=aGe});var gZt=H((_Xn,mZt)=>{function sGe(e){return this.__data__.get(e)}mZt.exports=sGe});var yZt=H((yXn,_Zt)=>{function lGe(e){return this.__data__.has(e)}_Zt.exports=lGe});var cst=H((vXn,vZt)=>{var cGe=typeof global=="object"&&global&&global.Object===Object&&global;vZt.exports=cGe});var Hc=H((xXn,xZt)=>{var uGe=cst(),hGe=typeof self=="object"&&self&&self.Object===Object&&self,fGe=uGe||hGe||Function("return this")();xZt.exports=fGe});var jv=H((bXn,bZt)=>{var pGe=Hc(),dGe=pGe.Symbol;bZt.exports=dGe});var EZt=H((wXn,MZt)=>{var wZt=jv(),SZt=Object.prototype,mGe=SZt.hasOwnProperty,gGe=SZt.toString,T4=wZt?wZt.toStringTag:void 0;function _Ge(e){var t=mGe.call(e,T4),r=e[T4];try{e[T4]=void 0;var n=!0}catch(o){}var i=gGe.call(e);return n&&(t?e[T4]=r:delete e[T4]),i}MZt.exports=_Ge});var CZt=H((SXn,TZt)=>{var yGe=Object.prototype,vGe=yGe.toString;function xGe(e){return vGe.call(e)}TZt.exports=xGe});var s0=H((MXn,IZt)=>{var AZt=jv(),bGe=EZt(),wGe=CZt(),SGe="[object Null]",MGe="[object Undefined]",PZt=AZt?AZt.toStringTag:void 0;function EGe(e){return e==null?e===void 0?MGe:SGe:PZt&&PZt in Object(e)?bGe(e):wGe(e)}IZt.exports=EGe});var Ml=H((EXn,LZt)=>{function TGe(e){var t=typeof e;return e!=null&&(t=="object"||t=="function")}LZt.exports=TGe});var FS=H((TXn,kZt)=>{var CGe=s0(),AGe=Ml(),PGe="[object AsyncFunction]",IGe="[object Function]",LGe="[object GeneratorFunction]",kGe="[object Proxy]";function RGe(e){if(!AGe(e))return!1;var t=CGe(e);return t==IGe||t==LGe||t==PGe||t==kGe}kZt.exports=RGe});var NZt=H((CXn,RZt)=>{var NGe=Hc(),DGe=NGe["__core-js_shared__"];RZt.exports=DGe});var zZt=H((AXn,OZt)=>{var ust=NZt(),DZt=function(){var e=/[^.]+$/.exec(ust&&ust.keys&&ust.keys.IE_PROTO||"");return e?"Symbol(src)_1."+e:""}();function OGe(e){return!!DZt&&DZt in e}OZt.exports=OGe});var hst=H((PXn,FZt)=>{var zGe=Function.prototype,FGe=zGe.toString;function BGe(e){if(e!=null){try{return FGe.call(e)}catch(t){}try{return e+""}catch(t){}}return""}FZt.exports=BGe});var HZt=H((IXn,BZt)=>{var HGe=FS(),VGe=zZt(),UGe=Ml(),qGe=hst(),GGe=/[\\^$.*+?()[\]{}|]/g,WGe=/^\[object .+?Constructor\]$/,YGe=Function.prototype,jGe=Object.prototype,XGe=YGe.toString,$Ge=jGe.hasOwnProperty,KGe=RegExp("^"+XGe.call($Ge).replace(GGe,"\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g,"$1.*?")+"$");function ZGe(e){if(!UGe(e)||VGe(e))return!1;var t=HGe(e)?KGe:WGe;return t.test(qGe(e))}BZt.exports=ZGe});var UZt=H((LXn,VZt)=>{function JGe(e,t){return e==null?void 0:e[t]}VZt.exports=JGe});var l0=H((kXn,qZt)=>{var QGe=HZt(),tWe=UZt();function eWe(e,t){var r=tWe(e,t);return QGe(r)?r:void 0}qZt.exports=eWe});var zB=H((RXn,GZt)=>{var rWe=l0(),nWe=Hc(),iWe=rWe(nWe,"Map");GZt.exports=iWe});var C4=H((NXn,WZt)=>{var oWe=l0(),aWe=oWe(Object,"create");WZt.exports=aWe});var XZt=H((DXn,jZt)=>{var YZt=C4();function sWe(){this.__data__=YZt?YZt(null):{},this.size=0}jZt.exports=sWe});var KZt=H((OXn,$Zt)=>{function lWe(e){var t=this.has(e)&&delete this.__data__[e];return this.size-=t?1:0,t}$Zt.exports=lWe});var JZt=H((zXn,ZZt)=>{var cWe=C4(),uWe="__lodash_hash_undefined__",hWe=Object.prototype,fWe=hWe.hasOwnProperty;function pWe(e){var t=this.__data__;if(cWe){var r=t[e];return r===uWe?void 0:r}return fWe.call(t,e)?t[e]:void 0}ZZt.exports=pWe});var tJt=H((FXn,QZt)=>{var dWe=C4(),mWe=Object.prototype,gWe=mWe.hasOwnProperty;function _We(e){var t=this.__data__;return dWe?t[e]!==void 0:gWe.call(t,e)}QZt.exports=_We});var rJt=H((BXn,eJt)=>{var yWe=C4(),vWe="__lodash_hash_undefined__";function xWe(e,t){var r=this.__data__;return this.size+=this.has(e)?0:1,r[e]=yWe&&t===void 0?vWe:t,this}eJt.exports=xWe});var iJt=H((HXn,nJt)=>{var bWe=XZt(),wWe=KZt(),SWe=JZt(),MWe=tJt(),EWe=rJt();function BS(e){var t=-1,r=e==null?0:e.length;for(this.clear();++t<r;){var n=e[t];this.set(n[0],n[1])}}BS.prototype.clear=bWe;BS.prototype.delete=wWe;BS.prototype.get=SWe;BS.prototype.has=MWe;BS.prototype.set=EWe;nJt.exports=BS});var sJt=H((VXn,aJt)=>{var oJt=iJt(),TWe=E4(),CWe=zB();function AWe(){this.size=0,this.__data__={hash:new oJt,map:new(CWe||TWe),string:new oJt}}aJt.exports=AWe});var cJt=H((UXn,lJt)=>{function PWe(e){var t=typeof e;return t=="string"||t=="number"||t=="symbol"||t=="boolean"?e!=="__proto__":e===null}lJt.exports=PWe});var A4=H((qXn,uJt)=>{var IWe=cJt();function LWe(e,t){var r=e.__data__;return IWe(t)?r[typeof t=="string"?"string":"hash"]:r.map}uJt.exports=LWe});var fJt=H((GXn,hJt)=>{var kWe=A4();function RWe(e){var t=kWe(this,e).delete(e);return this.size-=t?1:0,t}hJt.exports=RWe});var dJt=H((WXn,pJt)=>{var NWe=A4();function DWe(e){return NWe(this,e).get(e)}pJt.exports=DWe});var gJt=H((YXn,mJt)=>{var OWe=A4();function zWe(e){return OWe(this,e).has(e)}mJt.exports=zWe});var yJt=H((jXn,_Jt)=>{var FWe=A4();function BWe(e,t){var r=FWe(this,e),n=r.size;return r.set(e,t),this.size+=r.size==n?0:1,this}_Jt.exports=BWe});var FB=H((XXn,vJt)=>{var HWe=sJt(),VWe=fJt(),UWe=dJt(),qWe=gJt(),GWe=yJt();function HS(e){var t=-1,r=e==null?0:e.length;for(this.clear();++t<r;){var n=e[t];this.set(n[0],n[1])}}HS.prototype.clear=HWe;HS.prototype.delete=VWe;HS.prototype.get=UWe;HS.prototype.has=qWe;HS.prototype.set=GWe;vJt.exports=HS});var bJt=H(($Xn,xJt)=>{var WWe=E4(),YWe=zB(),jWe=FB(),XWe=200;function $We(e,t){var r=this.__data__;if(r instanceof WWe){var n=r.__data__;if(!YWe||n.length<XWe-1)return n.push([e,t]),this.size=++r.size,this;r=this.__data__=new jWe(n)}return r.set(e,t),this.size=r.size,this}xJt.exports=$We});var P4=H((KXn,wJt)=>{var KWe=E4(),ZWe=fZt(),JWe=dZt(),QWe=gZt(),tYe=yZt(),eYe=bJt();function VS(e){var t=this.__data__=new KWe(e);this.size=t.size}VS.prototype.clear=ZWe;VS.prototype.delete=JWe;VS.prototype.get=QWe;VS.prototype.has=tYe;VS.prototype.set=eYe;wJt.exports=VS});var BB=H((ZXn,SJt)=>{function rYe(e,t){for(var r=-1,n=e==null?0:e.length;++r<n&&t(e[r],r,e)!==!1;);return e}SJt.exports=rYe});var fst=H((JXn,MJt)=>{var nYe=l0(),iYe=function(){try{var e=nYe(Object,"defineProperty");return e({},"",{}),e}catch(t){}}();MJt.exports=iYe});var I4=H((QXn,TJt)=>{var EJt=fst();function oYe(e,t,r){t=="__proto__"&&EJt?EJt(e,t,{configurable:!0,enumerable:!0,value:r,writable:!0}):e[t]=r}TJt.exports=oYe});var L4=H((t$n,CJt)=>{var aYe=I4(),sYe=Yv(),lYe=Object.prototype,cYe=lYe.hasOwnProperty;function uYe(e,t,r){var n=e[t];(!(cYe.call(e,t)&&sYe(n,r))||r===void 0&&!(t in e))&&aYe(e,t,r)}CJt.exports=uYe});var US=H((e$n,AJt)=>{var hYe=L4(),fYe=I4();function pYe(e,t,r,n){var i=!r;r||(r={});for(var o=-1,a=t.length;++o<a;){var s=t[o],l=n?n(r[s],e[s],s,r,e):void 0;l===void 0&&(l=e[s]),i?fYe(r,s,l):hYe(r,s,l)}return r}AJt.exports=pYe});var IJt=H((r$n,PJt)=>{function dYe(e,t){for(var r=-1,n=Array(e);++r<e;)n[r]=t(r);return n}PJt.exports=dYe});var Yu=H((n$n,LJt)=>{function mYe(e){return e!=null&&typeof e=="object"}LJt.exports=mYe});var RJt=H((i$n,kJt)=>{var gYe=s0(),_Ye=Yu(),yYe="[object Arguments]";function vYe(e){return _Ye(e)&&gYe(e)==yYe}kJt.exports=vYe});var qS=H((o$n,OJt)=>{var NJt=RJt(),xYe=Yu(),DJt=Object.prototype,bYe=DJt.hasOwnProperty,wYe=DJt.propertyIsEnumerable,SYe=NJt(function(){return arguments}())?NJt:function(e){return xYe(e)&&bYe.call(e,"callee")&&!wYe.call(e,"callee")};OJt.exports=SYe});var Ti=H((a$n,zJt)=>{var MYe=Array.isArray;zJt.exports=MYe});var BJt=H((s$n,FJt)=>{function EYe(){return!1}FJt.exports=EYe});var Xv=H((k4,GS)=>{var TYe=Hc(),CYe=BJt(),UJt=typeof k4=="object"&&k4&&!k4.nodeType&&k4,HJt=UJt&&typeof GS=="object"&&GS&&!GS.nodeType&&GS,AYe=HJt&&HJt.exports===UJt,VJt=AYe?TYe.Buffer:void 0,PYe=VJt?VJt.isBuffer:void 0,IYe=PYe||CYe;GS.exports=IYe});var R4=H((l$n,qJt)=>{var LYe=9007199254740991,kYe=/^(?:0|[1-9]\d*)$/;function RYe(e,t){var r=typeof e;return t=t==null?LYe:t,!!t&&(r=="number"||r!="symbol"&&kYe.test(e))&&e>-1&&e%1==0&&e<t}qJt.exports=RYe});var HB=H((c$n,GJt)=>{var NYe=9007199254740991;function DYe(e){return typeof e=="number"&&e>-1&&e%1==0&&e<=NYe}GJt.exports=DYe});var YJt=H((u$n,WJt)=>{var OYe=s0(),zYe=HB(),FYe=Yu(),BYe="[object Arguments]",HYe="[object Array]",VYe="[object Boolean]",UYe="[object Date]",qYe="[object Error]",GYe="[object Function]",WYe="[object Map]",YYe="[object Number]",jYe="[object Object]",XYe="[object RegExp]",$Ye="[object Set]",KYe="[object String]",ZYe="[object WeakMap]",JYe="[object ArrayBuffer]",QYe="[object DataView]",tje="[object Float32Array]",eje="[object Float64Array]",rje="[object Int8Array]",nje="[object Int16Array]",ije="[object Int32Array]",oje="[object Uint8Array]",aje="[object Uint8ClampedArray]",sje="[object Uint16Array]",lje="[object Uint32Array]",Vn={};Vn[tje]=Vn[eje]=Vn[rje]=Vn[nje]=Vn[ije]=Vn[oje]=Vn[aje]=Vn[sje]=Vn[lje]=!0;Vn[BYe]=Vn[HYe]=Vn[JYe]=Vn[VYe]=Vn[QYe]=Vn[UYe]=Vn[qYe]=Vn[GYe]=Vn[WYe]=Vn[YYe]=Vn[jYe]=Vn[XYe]=Vn[$Ye]=Vn[KYe]=Vn[ZYe]=!1;function cje(e){return FYe(e)&&zYe(e.length)&&!!Vn[OYe(e)]}WJt.exports=cje});var N4=H((h$n,jJt)=>{function uje(e){return function(t){return e(t)}}jJt.exports=uje});var VB=H((D4,WS)=>{var hje=cst(),XJt=typeof D4=="object"&&D4&&!D4.nodeType&&D4,O4=XJt&&typeof WS=="object"&&WS&&!WS.nodeType&&WS,fje=O4&&O4.exports===XJt,pst=fje&&hje.process,pje=function(){try{var e=O4&&O4.require&&O4.require("util").types;return e||pst&&pst.binding&&pst.binding("util")}catch(t){}}();WS.exports=pje});var YS=H((f$n,ZJt)=>{var dje=YJt(),mje=N4(),$Jt=VB(),KJt=$Jt&&$Jt.isTypedArray,gje=KJt?mje(KJt):dje;ZJt.exports=gje});var dst=H((p$n,JJt)=>{var _je=IJt(),yje=qS(),vje=Ti(),xje=Xv(),bje=R4(),wje=YS(),Sje=Object.prototype,Mje=Sje.hasOwnProperty;function Eje(e,t){var r=vje(e),n=!r&&yje(e),i=!r&&!n&&xje(e),o=!r&&!n&&!i&&wje(e),a=r||n||i||o,s=a?_je(e.length,String):[],l=s.length;for(var c in e)(t||Mje.call(e,c))&&!(a&&(c=="length"||i&&(c=="offset"||c=="parent")||o&&(c=="buffer"||c=="byteLength"||c=="byteOffset")||bje(c,l)))&&s.push(c);return s}JJt.exports=Eje});var z4=H((d$n,QJt)=>{var Tje=Object.prototype;function Cje(e){var t=e&&e.constructor,r=typeof t=="function"&&t.prototype||Tje;return e===r}QJt.exports=Cje});var mst=H((m$n,tQt)=>{function Aje(e,t){return function(r){return e(t(r))}}tQt.exports=Aje});var rQt=H((g$n,eQt)=>{var Pje=mst(),Ije=Pje(Object.keys,Object);eQt.exports=Ije});var UB=H((_$n,nQt)=>{var Lje=z4(),kje=rQt(),Rje=Object.prototype,Nje=Rje.hasOwnProperty;function Dje(e){if(!Lje(e))return kje(e);var t=[];for(var r in Object(e))Nje.call(e,r)&&r!="constructor"&&t.push(r);return t}nQt.exports=Dje});var Bf=H((y$n,iQt)=>{var Oje=FS(),zje=HB();function Fje(e){return e!=null&&zje(e.length)&&!Oje(e)}iQt.exports=Fje});var Ad=H((v$n,oQt)=>{var Bje=dst(),Hje=UB(),Vje=Bf();function Uje(e){return Vje(e)?Bje(e):Hje(e)}oQt.exports=Uje});var sQt=H((x$n,aQt)=>{var qje=US(),Gje=Ad();function Wje(e,t){return e&&qje(t,Gje(t),e)}aQt.exports=Wje});var cQt=H((b$n,lQt)=>{function Yje(e){var t=[];if(e!=null)for(var r in Object(e))t.push(r);return t}lQt.exports=Yje});var hQt=H((w$n,uQt)=>{var jje=Ml(),Xje=z4(),$je=cQt(),Kje=Object.prototype,Zje=Kje.hasOwnProperty;function Jje(e){if(!jje(e))return $je(e);var t=Xje(e),r=[];for(var n in e)n=="constructor"&&(t||!Zje.call(e,n))||r.push(n);return r}uQt.exports=Jje});var c0=H((S$n,fQt)=>{var Qje=dst(),tXe=hQt(),eXe=Bf();function rXe(e){return eXe(e)?Qje(e,!0):tXe(e)}fQt.exports=rXe});var dQt=H((M$n,pQt)=>{var nXe=US(),iXe=c0();function oXe(e,t){return e&&nXe(t,iXe(t),e)}pQt.exports=oXe});var gst=H((F4,jS)=>{var aXe=Hc(),yQt=typeof F4=="object"&&F4&&!F4.nodeType&&F4,mQt=yQt&&typeof jS=="object"&&jS&&!jS.nodeType&&jS,sXe=mQt&&mQt.exports===yQt,gQt=sXe?aXe.Buffer:void 0,_Qt=gQt?gQt.allocUnsafe:void 0;function lXe(e,t){if(t)return e.slice();var r=e.length,n=_Qt?_Qt(r):new e.constructor(r);return e.copy(n),n}jS.exports=lXe});var _st=H((E$n,vQt)=>{function cXe(e,t){var r=-1,n=e.length;for(t||(t=Array(n));++r<n;)t[r]=e[r];return t}vQt.exports=cXe});var yst=H((T$n,xQt)=>{function uXe(e,t){for(var r=-1,n=e==null?0:e.length,i=0,o=[];++r<n;){var a=e[r];t(a,r,e)&&(o[i++]=a)}return o}xQt.exports=uXe});var vst=H((C$n,bQt)=>{function hXe(){return[]}bQt.exports=hXe});var qB=H((A$n,SQt)=>{var fXe=yst(),pXe=vst(),dXe=Object.prototype,mXe=dXe.propertyIsEnumerable,wQt=Object.getOwnPropertySymbols,gXe=wQt?function(e){return e==null?[]:(e=Object(e),fXe(wQt(e),function(t){return mXe.call(e,t)}))}:pXe;SQt.exports=gXe});var EQt=H((P$n,MQt)=>{var _Xe=US(),yXe=qB();function vXe(e,t){return _Xe(e,yXe(e),t)}MQt.exports=vXe});var GB=H((I$n,TQt)=>{function xXe(e,t){for(var r=-1,n=t.length,i=e.length;++r<n;)e[i+r]=t[r];return e}TQt.exports=xXe});var B4=H((L$n,CQt)=>{var bXe=mst(),wXe=bXe(Object.getPrototypeOf,Object);CQt.exports=wXe});var xst=H((k$n,AQt)=>{var SXe=GB(),MXe=B4(),EXe=qB(),TXe=vst(),CXe=Object.getOwnPropertySymbols,AXe=CXe?function(e){for(var t=[];e;)SXe(t,EXe(e)),e=MXe(e);return t}:TXe;AQt.exports=AXe});var IQt=H((R$n,PQt)=>{var PXe=US(),IXe=xst();function LXe(e,t){return PXe(e,IXe(e),t)}PQt.exports=LXe});var bst=H((N$n,LQt)=>{var kXe=GB(),RXe=Ti();function NXe(e,t,r){var n=t(e);return RXe(e)?n:kXe(n,r(e))}LQt.exports=NXe});var wst=H((D$n,kQt)=>{var DXe=bst(),OXe=qB(),zXe=Ad();function FXe(e){return DXe(e,zXe,OXe)}kQt.exports=FXe});var NQt=H((O$n,RQt)=>{var BXe=bst(),HXe=xst(),VXe=c0();function UXe(e){return BXe(e,VXe,HXe)}RQt.exports=UXe});var OQt=H((z$n,DQt)=>{var qXe=l0(),GXe=Hc(),WXe=qXe(GXe,"DataView");DQt.exports=WXe});var FQt=H((F$n,zQt)=>{var YXe=l0(),jXe=Hc(),XXe=YXe(jXe,"Promise");zQt.exports=XXe});var Sst=H((B$n,BQt)=>{var $Xe=l0(),KXe=Hc(),ZXe=$Xe(KXe,"Set");BQt.exports=ZXe});var VQt=H((H$n,HQt)=>{var JXe=l0(),QXe=Hc(),t$e=JXe(QXe,"WeakMap");HQt.exports=t$e});var Kv=H((V$n,XQt)=>{var Mst=OQt(),Est=zB(),Tst=FQt(),Cst=Sst(),Ast=VQt(),jQt=s0(),XS=hst(),UQt="[object Map]",e$e="[object Object]",qQt="[object Promise]",GQt="[object Set]",WQt="[object WeakMap]",YQt="[object DataView]",r$e=XS(Mst),n$e=XS(Est),i$e=XS(Tst),o$e=XS(Cst),a$e=XS(Ast),$v=jQt;(Mst&&$v(new Mst(new ArrayBuffer(1)))!=YQt||Est&&$v(new Est)!=UQt||Tst&&$v(Tst.resolve())!=qQt||Cst&&$v(new Cst)!=GQt||Ast&&$v(new Ast)!=WQt)&&($v=function(e){var t=jQt(e),r=t==e$e?e.constructor:void 0,n=r?XS(r):"";if(n)switch(n){case r$e:return YQt;case n$e:return UQt;case i$e:return qQt;case o$e:return GQt;case a$e:return WQt}return t});XQt.exports=$v});var KQt=H((U$n,$Qt)=>{var s$e=Object.prototype,l$e=s$e.hasOwnProperty;function c$e(e){var t=e.length,r=new e.constructor(t);return t&&typeof e[0]=="string"&&l$e.call(e,"index")&&(r.index=e.index,r.input=e.input),r}$Qt.exports=c$e});var Pst=H((q$n,ZQt)=>{var u$e=Hc(),h$e=u$e.Uint8Array;ZQt.exports=h$e});var WB=H((G$n,QQt)=>{var JQt=Pst();function f$e(e){var t=new e.constructor(e.byteLength);return new JQt(t).set(new JQt(e)),t}QQt.exports=f$e});var ete=H((W$n,tte)=>{var p$e=WB();function d$e(e,t){var r=t?p$e(e.buffer):e.buffer;return new e.constructor(r,e.byteOffset,e.byteLength)}tte.exports=d$e});var nte=H((Y$n,rte)=>{var m$e=/\w*$/;function g$e(e){var t=new e.constructor(e.source,m$e.exec(e));return t.lastIndex=e.lastIndex,t}rte.exports=g$e});var lte=H((j$n,ste)=>{var ite=jv(),ote=ite?ite.prototype:void 0,ate=ote?ote.valueOf:void 0;function _$e(e){return ate?Object(ate.call(e)):{}}ste.exports=_$e});var Ist=H((X$n,cte)=>{var y$e=WB();function v$e(e,t){var r=t?y$e(e.buffer):e.buffer;return new e.constructor(r,e.byteOffset,e.length)}cte.exports=v$e});var hte=H(($$n,ute)=>{var x$e=WB(),b$e=ete(),w$e=nte(),S$e=lte(),M$e=Ist(),E$e="[object Boolean]",T$e="[object Date]",C$e="[object Map]",A$e="[object Number]",P$e="[object RegExp]",I$e="[object Set]",L$e="[object String]",k$e="[object Symbol]",R$e="[object ArrayBuffer]",N$e="[object DataView]",D$e="[object Float32Array]",O$e="[object Float64Array]",z$e="[object Int8Array]",F$e="[object Int16Array]",B$e="[object Int32Array]",H$e="[object Uint8Array]",V$e="[object Uint8ClampedArray]",U$e="[object Uint16Array]",q$e="[object Uint32Array]";function G$e(e,t,r){var n=e.constructor;switch(t){case R$e:return x$e(e);case E$e:case T$e:return new n(+e);case N$e:return b$e(e,r);case D$e:case O$e:case z$e:case F$e:case B$e:case H$e:case V$e:case U$e:case q$e:return M$e(e,r);case C$e:return new n;case A$e:case L$e:return new n(e);case P$e:return w$e(e);case I$e:return new n;case k$e:return S$e(e)}}ute.exports=G$e});var Lst=H((K$n,pte)=>{var W$e=Ml(),fte=Object.create,Y$e=function(){function e(){}return function(t){if(!W$e(t))return{};if(fte)return fte(t);e.prototype=t;var r=new e;return e.prototype=void 0,r}}();pte.exports=Y$e});var kst=H((Z$n,dte)=>{var j$e=Lst(),X$e=B4(),$$e=z4();function K$e(e){return typeof e.constructor=="function"&&!$$e(e)?j$e(X$e(e)):{}}dte.exports=K$e});var gte=H((J$n,mte)=>{var Z$e=Kv(),J$e=Yu(),Q$e="[object Map]";function tKe(e){return J$e(e)&&Z$e(e)==Q$e}mte.exports=tKe});var xte=H((Q$n,vte)=>{var eKe=gte(),rKe=N4(),_te=VB(),yte=_te&&_te.isMap,nKe=yte?rKe(yte):eKe;vte.exports=nKe});var wte=H((tKn,bte)=>{var iKe=Kv(),oKe=Yu(),aKe="[object Set]";function sKe(e){return oKe(e)&&iKe(e)==aKe}bte.exports=sKe});var Tte=H((eKn,Ete)=>{var lKe=wte(),cKe=N4(),Ste=VB(),Mte=Ste&&Ste.isSet,uKe=Mte?cKe(Mte):lKe;Ete.exports=uKe});var Rst=H((rKn,Ite)=>{var hKe=P4(),fKe=BB(),pKe=L4(),dKe=sQt(),mKe=dQt(),gKe=gst(),_Ke=_st(),yKe=EQt(),vKe=IQt(),xKe=wst(),bKe=NQt(),wKe=Kv(),SKe=KQt(),MKe=hte(),EKe=kst(),TKe=Ti(),CKe=Xv(),AKe=xte(),PKe=Ml(),IKe=Tte(),LKe=Ad(),kKe=c0(),RKe=1,NKe=2,DKe=4,Cte="[object Arguments]",OKe="[object Array]",zKe="[object Boolean]",FKe="[object Date]",BKe="[object Error]",Ate="[object Function]",HKe="[object GeneratorFunction]",VKe="[object Map]",UKe="[object Number]",Pte="[object Object]",qKe="[object RegExp]",GKe="[object Set]",WKe="[object String]",YKe="[object Symbol]",jKe="[object WeakMap]",XKe="[object ArrayBuffer]",$Ke="[object DataView]",KKe="[object Float32Array]",ZKe="[object Float64Array]",JKe="[object Int8Array]",QKe="[object Int16Array]",tZe="[object Int32Array]",eZe="[object Uint8Array]",rZe="[object Uint8ClampedArray]",nZe="[object Uint16Array]",iZe="[object Uint32Array]",Cn={};Cn[Cte]=Cn[OKe]=Cn[XKe]=Cn[$Ke]=Cn[zKe]=Cn[FKe]=Cn[KKe]=Cn[ZKe]=Cn[JKe]=Cn[QKe]=Cn[tZe]=Cn[VKe]=Cn[UKe]=Cn[Pte]=Cn[qKe]=Cn[GKe]=Cn[WKe]=Cn[YKe]=Cn[eZe]=Cn[rZe]=Cn[nZe]=Cn[iZe]=!0;Cn[BKe]=Cn[Ate]=Cn[jKe]=!1;function YB(e,t,r,n,i,o){var a,s=t&RKe,l=t&NKe,c=t&DKe;if(r&&(a=i?r(e,n,i,o):r(e)),a!==void 0)return a;if(!PKe(e))return e;var u=TKe(e);if(u){if(a=SKe(e),!s)return _Ke(e,a)}else{var h=wKe(e),f=h==Ate||h==HKe;if(CKe(e))return gKe(e,s);if(h==Pte||h==Cte||f&&!i){if(a=l||f?{}:EKe(e),!s)return l?vKe(e,mKe(a,e)):yKe(e,dKe(a,e))}else{if(!Cn[h])return i?e:{};a=MKe(e,h,s)}}o||(o=new hKe);var p=o.get(e);if(p)return p;o.set(e,a),IKe(e)?e.forEach(function(_){a.add(YB(_,t,r,_,e,o))}):AKe(e)&&e.forEach(function(_,y){a.set(y,YB(_,t,r,y,e,o))});var d=c?l?bKe:xKe:l?kKe:LKe,g=u?void 0:d(e);return fKe(g||e,function(_,y){g&&(y=_,_=e[y]),pKe(a,y,YB(_,t,r,y,e,o))}),a}Ite.exports=YB});var kte=H((nKn,Lte)=>{var oZe=Rst(),aZe=4;function sZe(e){return oZe(e,aZe)}Lte.exports=sZe});var jB=H((iKn,Rte)=>{function lZe(e){return function(){return e}}Rte.exports=lZe});var Dte=H((oKn,Nte)=>{function cZe(e){return function(t,r,n){for(var i=-1,o=Object(t),a=n(t),s=a.length;s--;){var l=a[e?s:++i];if(r(o[l],l,o)===!1)break}return t}}Nte.exports=cZe});var XB=H((aKn,Ote)=>{var uZe=Dte(),hZe=uZe();Ote.exports=hZe});var $B=H((sKn,zte)=>{var fZe=XB(),pZe=Ad();function dZe(e,t){return e&&fZe(e,t,pZe)}zte.exports=dZe});var Bte=H((lKn,Fte)=>{var mZe=Bf();function gZe(e,t){return function(r,n){if(r==null)return r;if(!mZe(r))return e(r,n);for(var i=r.length,o=t?i:-1,a=Object(r);(t?o--:++o<i)&&n(a[o],o,a)!==!1;);return r}}Fte.exports=gZe});var H4=H((cKn,Hte)=>{var _Ze=$B(),yZe=Bte(),vZe=yZe(_Ze);Hte.exports=vZe});var u0=H((uKn,Vte)=>{function xZe(e){return e}Vte.exports=xZe});var Nst=H((hKn,Ute)=>{var bZe=u0();function wZe(e){return typeof e=="function"?e:bZe}Ute.exports=wZe});var Dst=H((fKn,qte)=>{var SZe=BB(),MZe=H4(),EZe=Nst(),TZe=Ti();function CZe(e,t){var r=TZe(e)?SZe:MZe;return r(e,EZe(t))}qte.exports=CZe});var Ost=H((pKn,Gte)=>{Gte.exports=Dst()});var Yte=H((dKn,Wte)=>{var AZe=H4();function PZe(e,t){var r=[];return AZe(e,function(n,i,o){t(n,i,o)&&r.push(n)}),r}Wte.exports=PZe});var Xte=H((mKn,jte)=>{var IZe="__lodash_hash_undefined__";function LZe(e){return this.__data__.set(e,IZe),this}jte.exports=LZe});var Kte=H((gKn,$te)=>{function kZe(e){return this.__data__.has(e)}$te.exports=kZe});var zst=H((_Kn,Zte)=>{var RZe=FB(),NZe=Xte(),DZe=Kte();function KB(e){var t=-1,r=e==null?0:e.length;for(this.__data__=new RZe;++t<r;)this.add(e[t])}KB.prototype.add=KB.prototype.push=NZe;KB.prototype.has=DZe;Zte.exports=KB});var Qte=H((yKn,Jte)=>{function OZe(e,t){for(var r=-1,n=e==null?0:e.length;++r<n;)if(t(e[r],r,e))return!0;return!1}Jte.exports=OZe});var Fst=H((vKn,tee)=>{function zZe(e,t){return e.has(t)}tee.exports=zZe});var Bst=H((xKn,eee)=>{var FZe=zst(),BZe=Qte(),HZe=Fst(),VZe=1,UZe=2;function qZe(e,t,r,n,i,o){var a=r&VZe,s=e.length,l=t.length;if(s!=l&&!(a&&l>s))return!1;var c=o.get(e),u=o.get(t);if(c&&u)return c==t&&u==e;var h=-1,f=!0,p=r&UZe?new FZe:void 0;for(o.set(e,t),o.set(t,e);++h<s;){var d=e[h],g=t[h];if(n)var _=a?n(g,d,h,t,e,o):n(d,g,h,e,t,o);if(_!==void 0){if(_)continue;f=!1;break}if(p){if(!BZe(t,function(y,x){if(!HZe(p,x)&&(d===y||i(d,y,r,n,o)))return p.push(x)})){f=!1;break}}else if(!(d===g||i(d,g,r,n,o))){f=!1;break}}return o.delete(e),o.delete(t),f}eee.exports=qZe});var nee=H((bKn,ree)=>{function GZe(e){var t=-1,r=Array(e.size);return e.forEach(function(n,i){r[++t]=[i,n]}),r}ree.exports=GZe});var ZB=H((wKn,iee)=>{function WZe(e){var t=-1,r=Array(e.size);return e.forEach(function(n){r[++t]=n}),r}iee.exports=WZe});var cee=H((SKn,lee)=>{var oee=jv(),aee=Pst(),YZe=Yv(),jZe=Bst(),XZe=nee(),$Ze=ZB(),KZe=1,ZZe=2,JZe="[object Boolean]",QZe="[object Date]",tJe="[object Error]",eJe="[object Map]",rJe="[object Number]",nJe="[object RegExp]",iJe="[object Set]",oJe="[object String]",aJe="[object Symbol]",sJe="[object ArrayBuffer]",lJe="[object DataView]",see=oee?oee.prototype:void 0,Hst=see?see.valueOf:void 0;function cJe(e,t,r,n,i,o,a){switch(r){case lJe:if(e.byteLength!=t.byteLength||e.byteOffset!=t.byteOffset)return!1;e=e.buffer,t=t.buffer;case sJe:return!(e.byteLength!=t.byteLength||!o(new aee(e),new aee(t)));case JZe:case QZe:case rJe:return YZe(+e,+t);case tJe:return e.name==t.name&&e.message==t.message;case nJe:case oJe:return e==t+"";case eJe:var s=XZe;case iJe:var l=n&KZe;if(s||(s=$Ze),e.size!=t.size&&!l)return!1;var c=a.get(e);if(c)return c==t;n|=ZZe,a.set(e,t);var u=jZe(s(e),s(t),n,i,o,a);return a.delete(e),u;case aJe:if(Hst)return Hst.call(e)==Hst.call(t)}return!1}lee.exports=cJe});var fee=H((MKn,hee)=>{var uee=wst(),uJe=1,hJe=Object.prototype,fJe=hJe.hasOwnProperty;function pJe(e,t,r,n,i,o){var a=r&uJe,s=uee(e),l=s.length,c=uee(t),u=c.length;if(l!=u&&!a)return!1;for(var h=l;h--;){var f=s[h];if(!(a?f in t:fJe.call(t,f)))return!1}var p=o.get(e),d=o.get(t);if(p&&d)return p==t&&d==e;var g=!0;o.set(e,t),o.set(t,e);for(var _=a;++h<l;){f=s[h];var y=e[f],x=t[f];if(n)var b=a?n(x,y,f,t,e,o):n(y,x,f,e,t,o);if(!(b===void 0?y===x||i(y,x,r,n,o):b)){g=!1;break}_||(_=f=="constructor")}if(g&&!_){var S=e.constructor,C=t.constructor;S!=C&&"constructor"in e&&"constructor"in t&&!(typeof S=="function"&&S instanceof S&&typeof C=="function"&&C instanceof C)&&(g=!1)}return o.delete(e),o.delete(t),g}hee.exports=pJe});var xee=H((EKn,vee)=>{var Vst=P4(),dJe=Bst(),mJe=cee(),gJe=fee(),pee=Kv(),dee=Ti(),mee=Xv(),_Je=YS(),yJe=1,gee="[object Arguments]",_ee="[object Array]",JB="[object Object]",vJe=Object.prototype,yee=vJe.hasOwnProperty;function xJe(e,t,r,n,i,o){var a=dee(e),s=dee(t),l=a?_ee:pee(e),c=s?_ee:pee(t);l=l==gee?JB:l,c=c==gee?JB:c;var u=l==JB,h=c==JB,f=l==c;if(f&&mee(e)){if(!mee(t))return!1;a=!0,u=!1}if(f&&!u)return o||(o=new Vst),a||_Je(e)?dJe(e,t,r,n,i,o):mJe(e,t,l,r,n,i,o);if(!(r&yJe)){var p=u&&yee.call(e,"__wrapped__"),d=h&&yee.call(t,"__wrapped__");if(p||d){var g=p?e.value():e,_=d?t.value():t;return o||(o=new Vst),i(g,_,r,n,o)}}return f?(o||(o=new Vst),gJe(e,t,r,n,i,o)):!1}vee.exports=xJe});var Ust=H((TKn,See)=>{var bJe=xee(),bee=Yu();function wee(e,t,r,n,i){return e===t?!0:e==null||t==null||!bee(e)&&!bee(t)?e!==e&&t!==t:bJe(e,t,r,n,wee,i)}See.exports=wee});var Eee=H((CKn,Mee)=>{var wJe=P4(),SJe=Ust(),MJe=1,EJe=2;function TJe(e,t,r,n){var i=r.length,o=i,a=!n;if(e==null)return!o;for(e=Object(e);i--;){var s=r[i];if(a&&s[2]?s[1]!==e[s[0]]:!(s[0]in e))return!1}for(;++i<o;){s=r[i];var l=s[0],c=e[l],u=s[1];if(a&&s[2]){if(c===void 0&&!(l in e))return!1}else{var h=new wJe;if(n)var f=n(c,u,l,e,t,h);if(!(f===void 0?SJe(u,c,MJe|EJe,n,h):f))return!1}}return!0}Mee.exports=TJe});var qst=H((AKn,Tee)=>{var CJe=Ml();function AJe(e){return e===e&&!CJe(e)}Tee.exports=AJe});var Aee=H((PKn,Cee)=>{var PJe=qst(),IJe=Ad();function LJe(e){for(var t=IJe(e),r=t.length;r--;){var n=t[r],i=e[n];t[r]=[n,i,PJe(i)]}return t}Cee.exports=LJe});var Gst=H((IKn,Pee)=>{function kJe(e,t){return function(r){return r==null?!1:r[e]===t&&(t!==void 0||e in Object(r))}}Pee.exports=kJe});var Lee=H((LKn,Iee)=>{var RJe=Eee(),NJe=Aee(),DJe=Gst();function OJe(e){var t=NJe(e);return t.length==1&&t[0][2]?DJe(t[0][0],t[0][1]):function(r){return r===e||RJe(r,e,t)}}Iee.exports=OJe});var Zv=H((kKn,kee)=>{var zJe=s0(),FJe=Yu(),BJe="[object Symbol]";function HJe(e){return typeof e=="symbol"||FJe(e)&&zJe(e)==BJe}kee.exports=HJe});var QB=H((RKn,Ree)=>{var VJe=Ti(),UJe=Zv(),qJe=/\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,GJe=/^\w*$/;function WJe(e,t){if(VJe(e))return!1;var r=typeof e;return r=="number"||r=="symbol"||r=="boolean"||e==null||UJe(e)?!0:GJe.test(e)||!qJe.test(e)||t!=null&&e in Object(t)}Ree.exports=WJe});var Oee=H((NKn,Dee)=>{var Nee=FB(),YJe="Expected a function";function Wst(e,t){if(typeof e!="function"||t!=null&&typeof t!="function")throw new TypeError(YJe);var r=function(){var n=arguments,i=t?t.apply(this,n):n[0],o=r.cache;if(o.has(i))return o.get(i);var a=e.apply(this,n);return r.cache=o.set(i,a)||o,a};return r.cache=new(Wst.Cache||Nee),r}Wst.Cache=Nee;Dee.exports=Wst});var Fee=H((DKn,zee)=>{var jJe=Oee(),XJe=500;function $Je(e){var t=jJe(e,function(n){return r.size===XJe&&r.clear(),n}),r=t.cache;return t}zee.exports=$Je});var Hee=H((OKn,Bee)=>{var KJe=Fee(),ZJe=/[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g,JJe=/\\(\\)?/g,QJe=KJe(function(e){var t=[];return e.charCodeAt(0)===46&&t.push(""),e.replace(ZJe,function(r,n,i,o){t.push(i?o.replace(JJe,"$1"):n||r)}),t});Bee.exports=QJe});var V4=H((zKn,Vee)=>{function tQe(e,t){for(var r=-1,n=e==null?0:e.length,i=Array(n);++r<n;)i[r]=t(e[r],r,e);return i}Vee.exports=tQe});var jee=H((FKn,Yee)=>{var Uee=jv(),eQe=V4(),rQe=Ti(),nQe=Zv(),iQe=1/0,qee=Uee?Uee.prototype:void 0,Gee=qee?qee.toString:void 0;function Wee(e){if(typeof e=="string")return e;if(rQe(e))return eQe(e,Wee)+"";if(nQe(e))return Gee?Gee.call(e):"";var t=e+"";return t=="0"&&1/e==-iQe?"-0":t}Yee.exports=Wee});var Yst=H((BKn,Xee)=>{var oQe=jee();function aQe(e){return e==null?"":oQe(e)}Xee.exports=aQe});var U4=H((HKn,$ee)=>{var sQe=Ti(),lQe=QB(),cQe=Hee(),uQe=Yst();function hQe(e,t){return sQe(e)?e:lQe(e,t)?[e]:cQe(uQe(e))}$ee.exports=hQe});var $S=H((VKn,Kee)=>{var fQe=Zv(),pQe=1/0;function dQe(e){if(typeof e=="string"||fQe(e))return e;var t=e+"";return t=="0"&&1/e==-pQe?"-0":t}Kee.exports=dQe});var q4=H((UKn,Zee)=>{var mQe=U4(),gQe=$S();function _Qe(e,t){t=mQe(t,e);for(var r=0,n=t.length;e!=null&&r<n;)e=e[gQe(t[r++])];return r&&r==n?e:void 0}Zee.exports=_Qe});var Qee=H((qKn,Jee)=>{var yQe=q4();function vQe(e,t,r){var n=e==null?void 0:yQe(e,t);return n===void 0?r:n}Jee.exports=vQe});var ere=H((GKn,tre)=>{function xQe(e,t){return e!=null&&t in Object(e)}tre.exports=xQe});var jst=H((WKn,rre)=>{var bQe=U4(),wQe=qS(),SQe=Ti(),MQe=R4(),EQe=HB(),TQe=$S();function CQe(e,t,r){t=bQe(t,e);for(var n=-1,i=t.length,o=!1;++n<i;){var a=TQe(t[n]);if(!(o=e!=null&&r(e,a)))break;e=e[a]}return o||++n!=i?o:(i=e==null?0:e.length,!!i&&EQe(i)&&MQe(a,i)&&(SQe(e)||wQe(e)))}rre.exports=CQe});var Xst=H((YKn,nre)=>{var AQe=ere(),PQe=jst();function IQe(e,t){return e!=null&&PQe(e,t,AQe)}nre.exports=IQe});var ore=H((jKn,ire)=>{var LQe=Ust(),kQe=Qee(),RQe=Xst(),NQe=QB(),DQe=qst(),OQe=Gst(),zQe=$S(),FQe=1,BQe=2;function HQe(e,t){return NQe(e)&&DQe(t)?OQe(zQe(e),t):function(r){var n=kQe(r,e);return n===void 0&&n===t?RQe(r,e):LQe(t,n,FQe|BQe)}}ire.exports=HQe});var $st=H((XKn,are)=>{function VQe(e){return function(t){return t==null?void 0:t[e]}}are.exports=VQe});var lre=H(($Kn,sre)=>{var UQe=q4();function qQe(e){return function(t){return UQe(t,e)}}sre.exports=qQe});var ure=H((KKn,cre)=>{var GQe=$st(),WQe=lre(),YQe=QB(),jQe=$S();function XQe(e){return YQe(e)?GQe(jQe(e)):WQe(e)}cre.exports=XQe});var Hf=H((ZKn,hre)=>{var $Qe=Lee(),KQe=ore(),ZQe=u0(),JQe=Ti(),QQe=ure();function ttr(e){return typeof e=="function"?e:e==null?ZQe:typeof e=="object"?JQe(e)?KQe(e[0],e[1]):$Qe(e):QQe(e)}hre.exports=ttr});var Kst=H((JKn,fre)=>{var etr=yst(),rtr=Yte(),ntr=Hf(),itr=Ti();function otr(e,t){var r=itr(e)?etr:rtr;return r(e,ntr(t,3))}fre.exports=otr});var dre=H((QKn,pre)=>{var atr=Object.prototype,str=atr.hasOwnProperty;function ltr(e,t){return e!=null&&str.call(e,t)}pre.exports=ltr});var Zst=H((tZn,mre)=>{var ctr=dre(),utr=jst();function htr(e,t){return e!=null&&utr(e,t,ctr)}mre.exports=htr});var _re=H((eZn,gre)=>{var ftr=UB(),ptr=Kv(),dtr=qS(),mtr=Ti(),gtr=Bf(),_tr=Xv(),ytr=z4(),vtr=YS(),xtr="[object Map]",btr="[object Set]",wtr=Object.prototype,Str=wtr.hasOwnProperty;function Mtr(e){if(e==null)return!0;if(gtr(e)&&(mtr(e)||typeof e=="string"||typeof e.splice=="function"||_tr(e)||vtr(e)||dtr(e)))return!e.length;var t=ptr(e);if(t==xtr||t==btr)return!e.size;if(ytr(e))return!ftr(e).length;for(var r in e)if(Str.call(e,r))return!1;return!0}gre.exports=Mtr});var Jst=H((rZn,yre)=>{function Etr(e){return e===void 0}yre.exports=Etr});var Qst=H((nZn,vre)=>{var Ttr=H4(),Ctr=Bf();function Atr(e,t){var r=-1,n=Ctr(e)?Array(e.length):[];return Ttr(e,function(i,o,a){n[++r]=t(i,o,a)}),n}vre.exports=Atr});var tlt=H((iZn,xre)=>{var Ptr=V4(),Itr=Hf(),Ltr=Qst(),ktr=Ti();function Rtr(e,t){var r=ktr(e)?Ptr:Ltr;return r(e,Itr(t,3))}xre.exports=Rtr});var wre=H((oZn,bre)=>{function Ntr(e,t,r,n){var i=-1,o=e==null?0:e.length;for(n&&o&&(r=e[++i]);++i<o;)r=t(r,e[i],i,e);return r}bre.exports=Ntr});var Mre=H((aZn,Sre)=>{function Dtr(e,t,r,n,i){return i(e,function(o,a,s){r=n?(n=!1,o):t(r,o,a,s)}),r}Sre.exports=Dtr});var elt=H((sZn,Ere)=>{var Otr=wre(),ztr=H4(),Ftr=Hf(),Btr=Mre(),Htr=Ti();function Vtr(e,t,r){var n=Htr(e)?Otr:Btr,i=arguments.length<3;return n(e,Ftr(t,4),r,i,ztr)}Ere.exports=Vtr});var Cre=H((lZn,Tre)=>{var Utr=s0(),qtr=Ti(),Gtr=Yu(),Wtr="[object String]";function Ytr(e){return typeof e=="string"||!qtr(e)&&Gtr(e)&&Utr(e)==Wtr}Tre.exports=Ytr});var Pre=H((cZn,Are)=>{var jtr=$st(),Xtr=jtr("length");Are.exports=Xtr});var Lre=H((uZn,Ire)=>{var $tr="\\ud800-\\udfff",Ktr="\\u0300-\\u036f",Ztr="\\ufe20-\\ufe2f",Jtr="\\u20d0-\\u20ff",Qtr=Ktr+Ztr+Jtr,ter="\\ufe0e\\ufe0f",eer="\\u200d",rer=RegExp("["+eer+$tr+Qtr+ter+"]");function ner(e){return rer.test(e)}Ire.exports=ner});var Hre=H((hZn,Bre)=>{var Rre="\\ud800-\\udfff",ier="\\u0300-\\u036f",oer="\\ufe20-\\ufe2f",aer="\\u20d0-\\u20ff",ser=ier+oer+aer,ler="\\ufe0e\\ufe0f",cer="["+Rre+"]",rlt="["+ser+"]",nlt="\\ud83c[\\udffb-\\udfff]",uer="(?:"+rlt+"|"+nlt+")",Nre="[^"+Rre+"]",Dre="(?:\\ud83c[\\udde6-\\uddff]){2}",Ore="[\\ud800-\\udbff][\\udc00-\\udfff]",her="\\u200d",zre=uer+"?",Fre="["+ler+"]?",fer="(?:"+her+"(?:"+[Nre,Dre,Ore].join("|")+")"+Fre+zre+")*",per=Fre+zre+fer,der="(?:"+[Nre+rlt+"?",rlt,Dre,Ore,cer].join("|")+")",kre=RegExp(nlt+"(?="+nlt+")|"+der+per,"g");function mer(e){for(var t=kre.lastIndex=0;kre.test(e);)++t;return t}Bre.exports=mer});var Ure=H((fZn,Vre)=>{var ger=Pre(),_er=Lre(),yer=Hre();function ver(e){return _er(e)?yer(e):ger(e)}Vre.exports=ver});var Gre=H((pZn,qre)=>{var xer=UB(),ber=Kv(),wer=Bf(),Ser=Cre(),Mer=Ure(),Eer="[object Map]",Ter="[object Set]";function Cer(e){if(e==null)return 0;if(wer(e))return Ser(e)?Mer(e):e.length;var t=ber(e);return t==Eer||t==Ter?e.size:xer(e).length}qre.exports=Cer});var Yre=H((dZn,Wre)=>{var Aer=BB(),Per=Lst(),Ier=$B(),Ler=Hf(),ker=B4(),Rer=Ti(),Ner=Xv(),Der=FS(),Oer=Ml(),zer=YS();function Fer(e,t,r){var n=Rer(e),i=n||Ner(e)||zer(e);if(t=Ler(t,4),r==null){var o=e&&e.constructor;i?r=n?new o:[]:Oer(e)?r=Der(o)?Per(ker(e)):{}:r={}}return(i?Aer:Ier)(e,function(a,s,l){return t(r,a,s,l)}),r}Wre.exports=Fer});var Kre=H((mZn,$re)=>{var jre=jv(),Ber=qS(),Her=Ti(),Xre=jre?jre.isConcatSpreadable:void 0;function Ver(e){return Her(e)||Ber(e)||!!(Xre&&e&&e[Xre])}$re.exports=Ver});var tH=H((gZn,Jre)=>{var Uer=GB(),qer=Kre();function Zre(e,t,r,n,i){var o=-1,a=e.length;for(r||(r=qer),i||(i=[]);++o<a;){var s=e[o];t>0&&r(s)?t>1?Zre(s,t-1,r,n,i):Uer(i,s):n||(i[i.length]=s)}return i}Jre.exports=Zre});var tne=H((_Zn,Qre)=>{function Ger(e,t,r){switch(r.length){case 0:return e.call(t);case 1:return e.call(t,r[0]);case 2:return e.call(t,r[0],r[1]);case 3:return e.call(t,r[0],r[1],r[2])}return e.apply(t,r)}Qre.exports=Ger});var ilt=H((yZn,rne)=>{var Wer=tne(),ene=Math.max;function Yer(e,t,r){return t=ene(t===void 0?e.length-1:t,0),function(){for(var n=arguments,i=-1,o=ene(n.length-t,0),a=Array(o);++i<o;)a[i]=n[t+i];i=-1;for(var s=Array(t+1);++i<t;)s[i]=n[i];return s[t]=r(a),Wer(e,this,s)}}rne.exports=Yer});var one=H((vZn,ine)=>{var jer=jB(),nne=fst(),Xer=u0(),$er=nne?function(e,t){return nne(e,"toString",{configurable:!0,enumerable:!1,value:jer(t),writable:!0})}:Xer;ine.exports=$er});var sne=H((xZn,ane)=>{var Ker=800,Zer=16,Jer=Date.now;function Qer(e){var t=0,r=0;return function(){var n=Jer(),i=Zer-(n-r);if(r=n,i>0){if(++t>=Ker)return arguments[0]}else t=0;return e.apply(void 0,arguments)}}ane.exports=Qer});var olt=H((bZn,lne)=>{var trr=one(),err=sne(),rrr=err(trr);lne.exports=rrr});var G4=H((wZn,cne)=>{var nrr=u0(),irr=ilt(),orr=olt();function arr(e,t){return orr(irr(e,t,nrr),e+"")}cne.exports=arr});var alt=H((SZn,une)=>{function srr(e,t,r,n){for(var i=e.length,o=r+(n?1:-1);n?o--:++o<i;)if(t(e[o],o,e))return o;return-1}une.exports=srr});var fne=H((MZn,hne)=>{function lrr(e){return e!==e}hne.exports=lrr});var dne=H((EZn,pne)=>{function crr(e,t,r){for(var n=r-1,i=e.length;++n<i;)if(e[n]===t)return n;return-1}pne.exports=crr});var gne=H((TZn,mne)=>{var urr=alt(),hrr=fne(),frr=dne();function prr(e,t,r){return t===t?frr(e,t,r):urr(e,hrr,r)}mne.exports=prr});var yne=H((CZn,_ne)=>{var drr=gne();function mrr(e,t){var r=e==null?0:e.length;return!!r&&drr(e,t,0)>-1}_ne.exports=mrr});var xne=H((AZn,vne)=>{function grr(e,t,r){for(var n=-1,i=e==null?0:e.length;++n<i;)if(r(t,e[n]))return!0;return!1}vne.exports=grr});var wne=H((PZn,bne)=>{function _rr(){}bne.exports=_rr});var Mne=H((IZn,Sne)=>{var slt=Sst(),yrr=wne(),vrr=ZB(),xrr=1/0,brr=slt&&1/vrr(new slt([,-0]))[1]==xrr?function(e){return new slt(e)}:yrr;Sne.exports=brr});var Tne=H((LZn,Ene)=>{var wrr=zst(),Srr=yne(),Mrr=xne(),Err=Fst(),Trr=Mne(),Crr=ZB(),Arr=200;function Prr(e,t,r){var n=-1,i=Srr,o=e.length,a=!0,s=[],l=s;if(r)a=!1,i=Mrr;else if(o>=Arr){var c=t?null:Trr(e);if(c)return Crr(c);a=!1,i=Err,l=new wrr}else l=t?[]:s;t:for(;++n<o;){var u=e[n],h=t?t(u):u;if(u=r||u!==0?u:0,a&&h===h){for(var f=l.length;f--;)if(l[f]===h)continue t;t&&l.push(h),s.push(u)}else i(l,h,r)||(l!==s&&l.push(h),s.push(u))}return s}Ene.exports=Prr});var llt=H((kZn,Cne)=>{var Irr=Bf(),Lrr=Yu();function krr(e){return Lrr(e)&&Irr(e)}Cne.exports=krr});var Pne=H((RZn,Ane)=>{var Rrr=tH(),Nrr=G4(),Drr=Tne(),Orr=llt(),zrr=Nrr(function(e){return Drr(Rrr(e,1,Orr,!0))});Ane.exports=zrr});var Lne=H((NZn,Ine)=>{var Frr=V4();function Brr(e,t){return Frr(t,function(r){return e[r]})}Ine.exports=Brr});var clt=H((DZn,kne)=>{var Hrr=Lne(),Vrr=Ad();function Urr(e){return e==null?[]:Hrr(e,Vrr(e))}kne.exports=Urr});var El=H((OZn,Rne)=>{var eH;if(typeof Ex=="function")try{eH={clone:kte(),constant:jB(),each:Ost(),filter:Kst(),has:Zst(),isArray:Ti(),isEmpty:_re(),isFunction:FS(),isUndefined:Jst(),keys:Ad(),map:tlt(),reduce:elt(),size:Gre(),transform:Yre(),union:Pne(),values:clt()}}catch(e){}eH||(eH=window._);Rne.exports=eH});var rH=H((FZn,zne)=>{"use strict";var je=El();zne.exports=cr;var qrr="\0",Jv="\0",Nne="";function cr(e){this._isDirected=je.has(e,"directed")?e.directed:!0,this._isMultigraph=je.has(e,"multigraph")?e.multigraph:!1,this._isCompound=je.has(e,"compound")?e.compound:!1,this._label=void 0,this._defaultNodeLabelFn=je.constant(void 0),this._defaultEdgeLabelFn=je.constant(void 0),this._nodes={},this._isCompound&&(this._parent={},this._children={},this._children[Jv]={}),this._in={},this._preds={},this._out={},this._sucs={},this._edgeObjs={},this._edgeLabels={}}cr.prototype._nodeCount=0;cr.prototype._edgeCount=0;cr.prototype.isDirected=function(){return this._isDirected};cr.prototype.isMultigraph=function(){return this._isMultigraph};cr.prototype.isCompound=function(){return this._isCompound};cr.prototype.setGraph=function(e){return this._label=e,this};cr.prototype.graph=function(){return this._label};cr.prototype.setDefaultNodeLabel=function(e){return je.isFunction(e)||(e=je.constant(e)),this._defaultNodeLabelFn=e,this};cr.prototype.nodeCount=function(){return this._nodeCount};cr.prototype.nodes=function(){return je.keys(this._nodes)};cr.prototype.sources=function(){var e=this;return je.filter(this.nodes(),function(t){return je.isEmpty(e._in[t])})};cr.prototype.sinks=function(){var e=this;return je.filter(this.nodes(),function(t){return je.isEmpty(e._out[t])})};cr.prototype.setNodes=function(e,t){var r=arguments,n=this;return je.each(e,function(i){r.length>1?n.setNode(i,t):n.setNode(i)}),this};cr.prototype.setNode=function(e,t){return je.has(this._nodes,e)?(arguments.length>1&&(this._nodes[e]=t),this):(this._nodes[e]=arguments.length>1?t:this._defaultNodeLabelFn(e),this._isCompound&&(this._parent[e]=Jv,this._children[e]={},this._children[Jv][e]=!0),this._in[e]={},this._preds[e]={},this._out[e]={},this._sucs[e]={},++this._nodeCount,this)};cr.prototype.node=function(e){return this._nodes[e]};cr.prototype.hasNode=function(e){return je.has(this._nodes,e)};cr.prototype.removeNode=function(e){var t=this;if(je.has(this._nodes,e)){var r=function(n){t.removeEdge(t._edgeObjs[n])};delete this._nodes[e],this._isCompound&&(this._removeFromParentsChildList(e),delete this._parent[e],je.each(this.children(e),function(n){t.setParent(n)}),delete this._children[e]),je.each(je.keys(this._in[e]),r),delete this._in[e],delete this._preds[e],je.each(je.keys(this._out[e]),r),delete this._out[e],delete this._sucs[e],--this._nodeCount}return this};cr.prototype.setParent=function(e,t){if(!this._isCompound)throw new Error("Cannot set parent in a non-compound graph");if(je.isUndefined(t))t=Jv;else{t+="";for(var r=t;!je.isUndefined(r);r=this.parent(r))if(r===e)throw new Error("Setting "+t+" as parent of "+e+" would create a cycle");this.setNode(t)}return this.setNode(e),this._removeFromParentsChildList(e),this._parent[e]=t,this._children[t][e]=!0,this};cr.prototype._removeFromParentsChildList=function(e){delete this._children[this._parent[e]][e]};cr.prototype.parent=function(e){if(this._isCompound){var t=this._parent[e];if(t!==Jv)return t}};cr.prototype.children=function(e){if(je.isUndefined(e)&&(e=Jv),this._isCompound){var t=this._children[e];if(t)return je.keys(t)}else{if(e===Jv)return this.nodes();if(this.hasNode(e))return[]}};cr.prototype.predecessors=function(e){var t=this._preds[e];if(t)return je.keys(t)};cr.prototype.successors=function(e){var t=this._sucs[e];if(t)return je.keys(t)};cr.prototype.neighbors=function(e){var t=this.predecessors(e);if(t)return je.union(t,this.successors(e))};cr.prototype.isLeaf=function(e){var t;return this.isDirected()?t=this.successors(e):t=this.neighbors(e),t.length===0};cr.prototype.filterNodes=function(e){var t=new this.constructor({directed:this._isDirected,multigraph:this._isMultigraph,compound:this._isCompound});t.setGraph(this.graph());var r=this;je.each(this._nodes,function(o,a){e(a)&&t.setNode(a,o)}),je.each(this._edgeObjs,function(o){t.hasNode(o.v)&&t.hasNode(o.w)&&t.setEdge(o,r.edge(o))});var n={};function i(o){var a=r.parent(o);return a===void 0||t.hasNode(a)?(n[o]=a,a):a in n?n[a]:i(a)}return this._isCompound&&je.each(t.nodes(),function(o){t.setParent(o,i(o))}),t};cr.prototype.setDefaultEdgeLabel=function(e){return je.isFunction(e)||(e=je.constant(e)),this._defaultEdgeLabelFn=e,this};cr.prototype.edgeCount=function(){return this._edgeCount};cr.prototype.edges=function(){return je.values(this._edgeObjs)};cr.prototype.setPath=function(e,t){var r=this,n=arguments;return je.reduce(e,function(i,o){return n.length>1?r.setEdge(i,o,t):r.setEdge(i,o),o}),this};cr.prototype.setEdge=function(){var e,t,r,n,i=!1,o=arguments[0];typeof o=="object"&&o!==null&&"v"in o?(e=o.v,t=o.w,r=o.name,arguments.length===2&&(n=arguments[1],i=!0)):(e=o,t=arguments[1],r=arguments[3],arguments.length>2&&(n=arguments[2],i=!0)),e=""+e,t=""+t,je.isUndefined(r)||(r=""+r);var a=W4(this._isDirected,e,t,r);if(je.has(this._edgeLabels,a))return i&&(this._edgeLabels[a]=n),this;if(!je.isUndefined(r)&&!this._isMultigraph)throw new Error("Cannot set a named edge when isMultigraph = false");this.setNode(e),this.setNode(t),this._edgeLabels[a]=i?n:this._defaultEdgeLabelFn(e,t,r);var s=Grr(this._isDirected,e,t,r);return e=s.v,t=s.w,Object.freeze(s),this._edgeObjs[a]=s,Dne(this._preds[t],e),Dne(this._sucs[e],t),this._in[t][a]=s,this._out[e][a]=s,this._edgeCount++,this};cr.prototype.edge=function(e,t,r){var n=arguments.length===1?ult(this._isDirected,arguments[0]):W4(this._isDirected,e,t,r);return this._edgeLabels[n]};cr.prototype.hasEdge=function(e,t,r){var n=arguments.length===1?ult(this._isDirected,arguments[0]):W4(this._isDirected,e,t,r);return je.has(this._edgeLabels,n)};cr.prototype.removeEdge=function(e,t,r){var n=arguments.length===1?ult(this._isDirected,arguments[0]):W4(this._isDirected,e,t,r),i=this._edgeObjs[n];return i&&(e=i.v,t=i.w,delete this._edgeLabels[n],delete this._edgeObjs[n],One(this._preds[t],e),One(this._sucs[e],t),delete this._in[t][n],delete this._out[e][n],this._edgeCount--),this};cr.prototype.inEdges=function(e,t){var r=this._in[e];if(r){var n=je.values(r);return t?je.filter(n,function(i){return i.v===t}):n}};cr.prototype.outEdges=function(e,t){var r=this._out[e];if(r){var n=je.values(r);return t?je.filter(n,function(i){return i.w===t}):n}};cr.prototype.nodeEdges=function(e,t){var r=this.inEdges(e,t);if(r)return r.concat(this.outEdges(e,t))};function Dne(e,t){e[t]?e[t]++:e[t]=1}function One(e,t){--e[t]||delete e[t]}function W4(e,t,r,n){var i=""+t,o=""+r;if(!e&&i>o){var a=i;i=o,o=a}return i+Nne+o+Nne+(je.isUndefined(n)?qrr:n)}function Grr(e,t,r,n){var i=""+t,o=""+r;if(!e&&i>o){var a=i;i=o,o=a}var s={v:i,w:o};return n&&(s.name=n),s}function ult(e,t){return W4(e,t.v,t.w,t.name)}});var Bne=H((BZn,Fne)=>{Fne.exports="2.1.8"});var Vne=H((HZn,Hne)=>{Hne.exports={Graph:rH(),version:Bne()}});var qne=H((VZn,Une)=>{var Vf=El(),Wrr=rH();Une.exports={write:Yrr,read:$rr};function Yrr(e){var t={options:{directed:e.isDirected(),multigraph:e.isMultigraph(),compound:e.isCompound()},nodes:jrr(e),edges:Xrr(e)};return Vf.isUndefined(e.graph())||(t.value=Vf.clone(e.graph())),t}function jrr(e){return Vf.map(e.nodes(),function(t){var r=e.node(t),n=e.parent(t),i={v:t};return Vf.isUndefined(r)||(i.value=r),Vf.isUndefined(n)||(i.parent=n),i})}function Xrr(e){return Vf.map(e.edges(),function(t){var r=e.edge(t),n={v:t.v,w:t.w};return Vf.isUndefined(t.name)||(n.name=t.name),Vf.isUndefined(r)||(n.value=r),n})}function $rr(e){var t=new Wrr(e.options).setGraph(e.value);return Vf.each(e.nodes,function(r){t.setNode(r.v,r.value),r.parent&&t.setParent(r.v,r.parent)}),Vf.each(e.edges,function(r){t.setEdge({v:r.v,w:r.w,name:r.name},r.value)}),t}});var Wne=H((UZn,Gne)=>{var nH=El();Gne.exports=Krr;function Krr(e){var t={},r=[],n;function i(o){nH.has(t,o)||(t[o]=!0,n.push(o),nH.each(e.successors(o),i),nH.each(e.predecessors(o),i))}return nH.each(e.nodes(),function(o){n=[],i(o),n.length&&r.push(n)}),r}});var hlt=H((qZn,jne)=>{var Yne=El();jne.exports=Vc;function Vc(){this._arr=[],this._keyIndices={}}Vc.prototype.size=function(){return this._arr.length};Vc.prototype.keys=function(){return this._arr.map(function(e){return e.key})};Vc.prototype.has=function(e){return Yne.has(this._keyIndices,e)};Vc.prototype.priority=function(e){var t=this._keyIndices[e];if(t!==void 0)return this._arr[t].priority};Vc.prototype.min=function(){if(this.size()===0)throw new Error("Queue underflow");return this._arr[0].key};Vc.prototype.add=function(e,t){var r=this._keyIndices;if(e=String(e),!Yne.has(r,e)){var n=this._arr,i=n.length;return r[e]=i,n.push({key:e,priority:t}),this._decrease(i),!0}return!1};Vc.prototype.removeMin=function(){this._swap(0,this._arr.length-1);var e=this._arr.pop();return delete this._keyIndices[e.key],this._heapify(0),e.key};Vc.prototype.decrease=function(e,t){var r=this._keyIndices[e];if(t>this._arr[r].priority)throw new Error("New priority is greater than current priority. Key: "+e+" Old: "+this._arr[r].priority+" New: "+t);this._arr[r].priority=t,this._decrease(r)};Vc.prototype._heapify=function(e){var t=this._arr,r=2*e,n=r+1,i=e;r<t.length&&(i=t[r].priority<t[i].priority?r:i,n<t.length&&(i=t[n].priority<t[i].priority?n:i),i!==e&&(this._swap(e,i),this._heapify(i)))};Vc.prototype._decrease=function(e){for(var t=this._arr,r=t[e].priority,n;e!==0&&(n=e>>1,!(t[n].priority<r));)this._swap(e,n),e=n};Vc.prototype._swap=function(e,t){var r=this._arr,n=this._keyIndices,i=r[e],o=r[t];r[e]=o,r[t]=i,n[o.key]=e,n[i.key]=t}});var flt=H((GZn,Xne)=>{var Zrr=El(),Jrr=hlt();Xne.exports=tnr;var Qrr=Zrr.constant(1);function tnr(e,t,r,n){return enr(e,String(t),r||Qrr,n||function(i){return e.outEdges(i)})}function enr(e,t,r,n){var i={},o=new Jrr,a,s,l=function(c){var u=c.v!==a?c.v:c.w,h=i[u],f=r(c),p=s.distance+f;if(f<0)throw new Error("dijkstra does not allow negative edge weights. Bad edge: "+c+" Weight: "+f);p<h.distance&&(h.distance=p,h.predecessor=a,o.decrease(u,p))};for(e.nodes().forEach(function(c){var u=c===t?0:Number.POSITIVE_INFINITY;i[c]={distance:u},o.add(c,u)});o.size()>0&&(a=o.removeMin(),s=i[a],s.distance!==Number.POSITIVE_INFINITY);)n(a).forEach(l);return i}});var Kne=H((WZn,$ne)=>{var rnr=flt(),nnr=El();$ne.exports=inr;function inr(e,t,r){return nnr.transform(e.nodes(),function(n,i){n[i]=rnr(e,i,t,r)},{})}});var plt=H((YZn,Jne)=>{var Zne=El();Jne.exports=onr;function onr(e){var t=0,r=[],n={},i=[];function o(a){var s=n[a]={onStack:!0,lowlink:t,index:t++};if(r.push(a),e.successors(a).forEach(function(u){Zne.has(n,u)?n[u].onStack&&(s.lowlink=Math.min(s.lowlink,n[u].index)):(o(u),s.lowlink=Math.min(s.lowlink,n[u].lowlink))}),s.lowlink===s.index){var l=[],c;do c=r.pop(),n[c].onStack=!1,l.push(c);while(a!==c);i.push(l)}}return e.nodes().forEach(function(a){Zne.has(n,a)||o(a)}),i}});var tie=H((jZn,Qne)=>{var anr=El(),snr=plt();Qne.exports=lnr;function lnr(e){return anr.filter(snr(e),function(t){return t.length>1||t.length===1&&e.hasEdge(t[0],t[0])})}});var rie=H((XZn,eie)=>{var cnr=El();eie.exports=hnr;var unr=cnr.constant(1);function hnr(e,t,r){return fnr(e,t||unr,r||function(n){return e.outEdges(n)})}function fnr(e,t,r){var n={},i=e.nodes();return i.forEach(function(o){n[o]={},n[o][o]={distance:0},i.forEach(function(a){o!==a&&(n[o][a]={distance:Number.POSITIVE_INFINITY})}),r(o).forEach(function(a){var s=a.v===o?a.w:a.v,l=t(a);n[o][s]={distance:l,predecessor:o}})}),i.forEach(function(o){var a=n[o];i.forEach(function(s){var l=n[s];i.forEach(function(c){var u=l[o],h=a[c],f=l[c],p=u.distance+h.distance;p<f.distance&&(f.distance=p,f.predecessor=h.predecessor)})})}),n}});var dlt=H(($Zn,iie)=>{var Y4=El();iie.exports=nie;nie.CycleException=iH;function nie(e){var t={},r={},n=[];function i(o){if(Y4.has(r,o))throw new iH;Y4.has(t,o)||(r[o]=!0,t[o]=!0,Y4.each(e.predecessors(o),i),delete r[o],n.push(o))}if(Y4.each(e.sinks(),i),Y4.size(t)!==e.nodeCount())throw new iH;return n}function iH(){}iH.prototype=new Error});var sie=H((KZn,aie)=>{var oie=dlt();aie.exports=pnr;function pnr(e){try{oie(e)}catch(t){if(t instanceof oie.CycleException)return!1;throw t}return!0}});var mlt=H((ZZn,cie)=>{var oH=El();cie.exports=dnr;function dnr(e,t,r){oH.isArray(t)||(t=[t]);var n=(e.isDirected()?e.successors:e.neighbors).bind(e),i=[],o={};return oH.each(t,function(a){if(!e.hasNode(a))throw new Error("Graph does not have node: "+a);lie(e,a,r==="post",o,n,i)}),i}function lie(e,t,r,n,i,o){oH.has(n,t)||(n[t]=!0,r||o.push(t),oH.each(i(t),function(a){lie(e,a,r,n,i,o)}),r&&o.push(t))}});var hie=H((JZn,uie)=>{var mnr=mlt();uie.exports=gnr;function gnr(e,t){return mnr(e,t,"post")}});var pie=H((QZn,fie)=>{var _nr=mlt();fie.exports=ynr;function ynr(e,t){return _nr(e,t,"pre")}});var gie=H((tJn,mie)=>{var die=El(),vnr=rH(),xnr=hlt();mie.exports=bnr;function bnr(e,t){var r=new vnr,n={},i=new xnr,o;function a(l){var c=l.v===o?l.w:l.v,u=i.priority(c);if(u!==void 0){var h=t(l);h<u&&(n[c]=o,i.decrease(c,h))}}if(e.nodeCount()===0)return r;die.each(e.nodes(),function(l){i.add(l,Number.POSITIVE_INFINITY),r.setNode(l)}),i.decrease(e.nodes()[0],0);for(var s=!1;i.size()>0;){if(o=i.removeMin(),die.has(n,o))r.setEdge(o,n[o]);else{if(s)throw new Error("Input graph is not connected: "+e);s=!0}e.nodeEdges(o).forEach(a)}return r}});var yie=H((eJn,_ie)=>{_ie.exports={components:Wne(),dijkstra:flt(),dijkstraAll:Kne(),findCycles:tie(),floydWarshall:rie(),isAcyclic:sie(),postorder:hie(),preorder:pie(),prim:gie(),tarjan:plt(),topsort:dlt()}});var bie=H((rJn,xie)=>{var vie=Vne();xie.exports={Graph:vie.Graph,json:qne(),alg:yie(),version:vie.version}});var Uc=H((nJn,wie)=>{var aH;if(typeof Ex=="function")try{aH=bie()}catch(e){}aH||(aH=window.graphlib);wie.exports=aH});var Mie=H((oJn,Sie)=>{var wnr=Rst(),Snr=1,Mnr=4;function Enr(e){return wnr(e,Snr|Mnr)}Sie.exports=Enr});var j4=H((aJn,Eie)=>{var Tnr=Yv(),Cnr=Bf(),Anr=R4(),Pnr=Ml();function Inr(e,t,r){if(!Pnr(r))return!1;var n=typeof t;return(n=="number"?Cnr(r)&&Anr(t,r.length):n=="string"&&t in r)?Tnr(r[t],e):!1}Eie.exports=Inr});var Aie=H((sJn,Cie)=>{var Lnr=G4(),knr=Yv(),Rnr=j4(),Nnr=c0(),Tie=Object.prototype,Dnr=Tie.hasOwnProperty,Onr=Lnr(function(e,t){e=Object(e);var r=-1,n=t.length,i=n>2?t[2]:void 0;for(i&&Rnr(t[0],t[1],i)&&(n=1);++r<n;)for(var o=t[r],a=Nnr(o),s=-1,l=a.length;++s<l;){var c=a[s],u=e[c];(u===void 0||knr(u,Tie[c])&&!Dnr.call(e,c))&&(e[c]=o[c])}return e});Cie.exports=Onr});var Iie=H((lJn,Pie)=>{var znr=Hf(),Fnr=Bf(),Bnr=Ad();function Hnr(e){return function(t,r,n){var i=Object(t);if(!Fnr(t)){var o=znr(r,3);t=Bnr(t),r=function(s){return o(i[s],s,i)}}var a=e(t,r,n);return a>-1?i[o?t[a]:a]:void 0}}Pie.exports=Hnr});var kie=H((cJn,Lie)=>{var Vnr=/\s/;function Unr(e){for(var t=e.length;t--&&Vnr.test(e.charAt(t)););return t}Lie.exports=Unr});var Nie=H((uJn,Rie)=>{var qnr=kie(),Gnr=/^\s+/;function Wnr(e){return e&&e.slice(0,qnr(e)+1).replace(Gnr,"")}Rie.exports=Wnr});var Fie=H((hJn,zie)=>{var Ynr=Nie(),Die=Ml(),jnr=Zv(),Oie=0/0,Xnr=/^[-+]0x[0-9a-f]+$/i,$nr=/^0b[01]+$/i,Knr=/^0o[0-7]+$/i,Znr=parseInt;function Jnr(e){if(typeof e=="number")return e;if(jnr(e))return Oie;if(Die(e)){var t=typeof e.valueOf=="function"?e.valueOf():e;e=Die(t)?t+"":t}if(typeof e!="string")return e===0?e:+e;e=Ynr(e);var r=$nr.test(e);return r||Knr.test(e)?Znr(e.slice(2),r?2:8):Xnr.test(e)?Oie:+e}zie.exports=Jnr});var glt=H((fJn,Hie)=>{var Qnr=Fie(),Bie=1/0,tir=17976931348623157e292;function eir(e){if(!e)return e===0?e:0;if(e=Qnr(e),e===Bie||e===-Bie){var t=e<0?-1:1;return t*tir}return e===e?e:0}Hie.exports=eir});var Uie=H((pJn,Vie)=>{var rir=glt();function nir(e){var t=rir(e),r=t%1;return t===t?r?t-r:t:0}Vie.exports=nir});var Gie=H((dJn,qie)=>{var iir=alt(),oir=Hf(),air=Uie(),sir=Math.max;function lir(e,t,r){var n=e==null?0:e.length;if(!n)return-1;var i=r==null?0:air(r);return i<0&&(i=sir(n+i,0)),iir(e,oir(t,3),i)}qie.exports=lir});var Yie=H((mJn,Wie)=>{var cir=Iie(),uir=Gie(),hir=cir(uir);Wie.exports=hir});var _lt=H((gJn,jie)=>{var fir=tH();function pir(e){var t=e==null?0:e.length;return t?fir(e,1):[]}jie.exports=pir});var $ie=H((_Jn,Xie)=>{var dir=XB(),mir=Nst(),gir=c0();function _ir(e,t){return e==null?e:dir(e,mir(t),gir)}Xie.exports=_ir});var Zie=H((yJn,Kie)=>{function yir(e){var t=e==null?0:e.length;return t?e[t-1]:void 0}Kie.exports=yir});var Qie=H((vJn,Jie)=>{var vir=I4(),xir=$B(),bir=Hf();function wir(e,t){var r={};return t=bir(t,3),xir(e,function(n,i,o){vir(r,i,t(n,i,o))}),r}Jie.exports=wir});var sH=H((xJn,toe)=>{var Sir=Zv();function Mir(e,t,r){for(var n=-1,i=e.length;++n<i;){var o=e[n],a=t(o);if(a!=null&&(s===void 0?a===a&&!Sir(a):r(a,s)))var s=a,l=o}return l}toe.exports=Mir});var roe=H((bJn,eoe)=>{function Eir(e,t){return e>t}eoe.exports=Eir});var ioe=H((wJn,noe)=>{var Tir=sH(),Cir=roe(),Air=u0();function Pir(e){return e&&e.length?Tir(e,Air,Cir):void 0}noe.exports=Pir});var ylt=H((SJn,ooe)=>{var Iir=I4(),Lir=Yv();function kir(e,t,r){(r!==void 0&&!Lir(e[t],r)||r===void 0&&!(t in e))&&Iir(e,t,r)}ooe.exports=kir});var loe=H((MJn,soe)=>{var Rir=s0(),Nir=B4(),Dir=Yu(),Oir="[object Object]",zir=Function.prototype,Fir=Object.prototype,aoe=zir.toString,Bir=Fir.hasOwnProperty,Hir=aoe.call(Object);function Vir(e){if(!Dir(e)||Rir(e)!=Oir)return!1;var t=Nir(e);if(t===null)return!0;var r=Bir.call(t,"constructor")&&t.constructor;return typeof r=="function"&&r instanceof r&&aoe.call(r)==Hir}soe.exports=Vir});var vlt=H((EJn,coe)=>{function Uir(e,t){if(!(t==="constructor"&&typeof e[t]=="function")&&t!="__proto__")return e[t]}coe.exports=Uir});var hoe=H((TJn,uoe)=>{var qir=US(),Gir=c0();function Wir(e){return qir(e,Gir(e))}uoe.exports=Wir});var _oe=H((CJn,goe)=>{var foe=ylt(),Yir=gst(),jir=Ist(),Xir=_st(),$ir=kst(),poe=qS(),doe=Ti(),Kir=llt(),Zir=Xv(),Jir=FS(),Qir=Ml(),tor=loe(),eor=YS(),moe=vlt(),ror=hoe();function nor(e,t,r,n,i,o,a){var s=moe(e,r),l=moe(t,r),c=a.get(l);if(c){foe(e,r,c);return}var u=o?o(s,l,r+"",e,t,a):void 0,h=u===void 0;if(h){var f=doe(l),p=!f&&Zir(l),d=!f&&!p&&eor(l);u=l,f||p||d?doe(s)?u=s:Kir(s)?u=Xir(s):p?(h=!1,u=Yir(l,!0)):d?(h=!1,u=jir(l,!0)):u=[]:tor(l)||poe(l)?(u=s,poe(s)?u=ror(s):(!Qir(s)||Jir(s))&&(u=$ir(l))):h=!1}h&&(a.set(l,u),i(u,l,n,o,a),a.delete(l)),foe(e,r,u)}goe.exports=nor});var xoe=H((AJn,voe)=>{var ior=P4(),oor=ylt(),aor=XB(),sor=_oe(),lor=Ml(),cor=c0(),uor=vlt();function yoe(e,t,r,n,i){e!==t&&aor(t,function(o,a){if(i||(i=new ior),lor(o))sor(e,t,a,r,yoe,n,i);else{var s=n?n(uor(e,a),o,a+"",e,t,i):void 0;s===void 0&&(s=o),oor(e,a,s)}},cor)}voe.exports=yoe});var woe=H((PJn,boe)=>{var hor=G4(),por=j4();function dor(e){return hor(function(t,r){var n=-1,i=r.length,o=i>1?r[i-1]:void 0,a=i>2?r[2]:void 0;for(o=e.length>3&&typeof o=="function"?(i--,o):void 0,a&&por(r[0],r[1],a)&&(o=i<3?void 0:o,i=1),t=Object(t);++n<i;){var s=r[n];s&&e(t,s,n,o)}return t})}boe.exports=dor});var Moe=H((IJn,Soe)=>{var mor=xoe(),gor=woe(),_or=gor(function(e,t,r){mor(e,t,r)});Soe.exports=_or});var xlt=H((LJn,Eoe)=>{function yor(e,t){return e<t}Eoe.exports=yor});var Coe=H((kJn,Toe)=>{var vor=sH(),xor=xlt(),bor=u0();function wor(e){return e&&e.length?vor(e,bor,xor):void 0}Toe.exports=wor});var Poe=H((RJn,Aoe)=>{var Sor=sH(),Mor=Hf(),Eor=xlt();function Tor(e,t){return e&&e.length?Sor(e,Mor(t,2),Eor):void 0}Aoe.exports=Tor});var Loe=H((NJn,Ioe)=>{var Cor=Hc(),Aor=function(){return Cor.Date.now()};Ioe.exports=Aor});var Noe=H((DJn,Roe)=>{var Por=L4(),Ior=U4(),Lor=R4(),koe=Ml(),kor=$S();function Ror(e,t,r,n){if(!koe(e))return e;t=Ior(t,e);for(var i=-1,o=t.length,a=o-1,s=e;s!=null&&++i<o;){var l=kor(t[i]),c=r;if(l==="__proto__"||l==="constructor"||l==="prototype")return e;if(i!=a){var u=s[l];c=n?n(u,l,s):void 0,c===void 0&&(c=koe(u)?u:Lor(t[i+1])?[]:{})}Por(s,l,c),s=s[l]}return e}Roe.exports=Ror});var Ooe=H((OJn,Doe)=>{var Nor=q4(),Dor=Noe(),Oor=U4();function zor(e,t,r){for(var n=-1,i=t.length,o={};++n<i;){var a=t[n],s=Nor(e,a);r(s,a)&&Dor(o,Oor(a,e),s)}return o}Doe.exports=zor});var Foe=H((zJn,zoe)=>{var For=Ooe(),Bor=Xst();function Hor(e,t){return For(e,t,function(r,n){return Bor(e,n)})}zoe.exports=Hor});var Hoe=H((FJn,Boe)=>{var Vor=_lt(),Uor=ilt(),qor=olt();function Gor(e){return qor(Uor(e,void 0,Vor),e+"")}Boe.exports=Gor});var Uoe=H((BJn,Voe)=>{var Wor=Foe(),Yor=Hoe(),jor=Yor(function(e,t){return e==null?{}:Wor(e,t)});Voe.exports=jor});var Goe=H((HJn,qoe)=>{var Xor=Math.ceil,$or=Math.max;function Kor(e,t,r,n){for(var i=-1,o=$or(Xor((t-e)/(r||1)),0),a=Array(o);o--;)a[n?o:++i]=e,e+=r;return a}qoe.exports=Kor});var Yoe=H((VJn,Woe)=>{var Zor=Goe(),Jor=j4(),blt=glt();function Qor(e){return function(t,r,n){return n&&typeof n!="number"&&Jor(t,r,n)&&(r=n=void 0),t=blt(t),r===void 0?(r=t,t=0):r=blt(r),n=n===void 0?t<r?1:-1:blt(n),Zor(t,r,n,e)}}Woe.exports=Qor});var Xoe=H((UJn,joe)=>{var tar=Yoe(),ear=tar();joe.exports=ear});var Koe=H((qJn,$oe)=>{function rar(e,t){var r=e.length;for(e.sort(t);r--;)e[r]=e[r].value;return e}$oe.exports=rar});var Qoe=H((GJn,Joe)=>{var Zoe=Zv();function nar(e,t){if(e!==t){var r=e!==void 0,n=e===null,i=e===e,o=Zoe(e),a=t!==void 0,s=t===null,l=t===t,c=Zoe(t);if(!s&&!c&&!o&&e>t||o&&a&&l&&!s&&!c||n&&a&&l||!r&&l||!i)return 1;if(!n&&!o&&!c&&e<t||c&&r&&i&&!n&&!o||s&&r&&i||!a&&i||!l)return-1}return 0}Joe.exports=nar});var eae=H((WJn,tae)=>{var iar=Qoe();function oar(e,t,r){for(var n=-1,i=e.criteria,o=t.criteria,a=i.length,s=r.length;++n<a;){var l=iar(i[n],o[n]);if(l){if(n>=s)return l;var c=r[n];return l*(c=="desc"?-1:1)}}return e.index-t.index}tae.exports=oar});var nae=H((YJn,rae)=>{var wlt=V4(),aar=q4(),sar=Hf(),lar=Qst(),car=Koe(),uar=N4(),har=eae(),far=u0(),par=Ti();function dar(e,t,r){t.length?t=wlt(t,function(o){return par(o)?function(a){return aar(a,o.length===1?o[0]:o)}:o}):t=[far];var n=-1;t=wlt(t,uar(sar));var i=lar(e,function(o,a,s){var l=wlt(t,function(c){return c(o)});return{criteria:l,index:++n,value:o}});return car(i,function(o,a){return har(o,a,r)})}rae.exports=dar});var aae=H((jJn,oae)=>{var mar=tH(),gar=nae(),_ar=G4(),iae=j4(),yar=_ar(function(e,t){if(e==null)return[];var r=t.length;return r>1&&iae(e,t[0],t[1])?t=[]:r>2&&iae(t[0],t[1],t[2])&&(t=[t[0]]),gar(e,mar(t,1),[])});oae.exports=yar});var lae=H((XJn,sae)=>{var xar=Yst(),bar=0;function war(e){var t=++bar;return xar(e)+t}sae.exports=war});var uae=H(($Jn,cae)=>{function Sar(e,t,r){for(var n=-1,i=e.length,o=t.length,a={};++n<i;){var s=n<o?t[n]:void 0;r(a,e[n],s)}return a}cae.exports=Sar});var fae=H((KJn,hae)=>{var Mar=L4(),Ear=uae();function Tar(e,t){return Ear(e||[],t||[],Mar)}hae.exports=Tar});var Un=H((ZJn,pae)=>{var lH;if(typeof Ex=="function")try{lH={cloneDeep:Mie(),constant:jB(),defaults:Aie(),each:Ost(),filter:Kst(),find:Yie(),flatten:_lt(),forEach:Dst(),forIn:$ie(),has:Zst(),isUndefined:Jst(),last:Zie(),map:tlt(),mapValues:Qie(),max:ioe(),merge:Moe(),min:Coe(),minBy:Poe(),now:Loe(),pick:Uoe(),range:Xoe(),reduce:elt(),sortBy:aae(),uniqueId:lae(),values:clt(),zipObject:fae()}}catch(e){}lH||(lH=window._);pae.exports=lH});var gae=H((QJn,mae)=>{mae.exports=cH;function cH(){var e={};e._next=e._prev=e,this._sentinel=e}cH.prototype.dequeue=function(){var e=this._sentinel,t=e._prev;if(t!==e)return dae(t),t};cH.prototype.enqueue=function(e){var t=this._sentinel;e._prev&&e._next&&dae(e),e._next=t._next,t._next._prev=e,t._next=e,e._prev=t};cH.prototype.toString=function(){for(var e=[],t=this._sentinel,r=t._prev;r!==t;)e.push(JSON.stringify(r,Car)),r=r._prev;return"["+e.join(", ")+"]"};function dae(e){e._prev._next=e._next,e._next._prev=e._prev,delete e._next,delete e._prev}function Car(e,t){if(e!=="_next"&&e!=="_prev")return t}});var yae=H((tQn,_ae)=>{var Pd=Un(),Aar=Uc().Graph,Par=gae();_ae.exports=Lar;var Iar=Pd.constant(1);function Lar(e,t){if(e.nodeCount()<=1)return[];var r=Rar(e,t||Iar),n=kar(r.graph,r.buckets,r.zeroIdx);return Pd.flatten(Pd.map(n,function(i){return e.outEdges(i.v,i.w)}),!0)}function kar(e,t,r){for(var n=[],i=t[t.length-1],o=t[0],a;e.nodeCount();){for(;a=o.dequeue();)Slt(e,t,r,a);for(;a=i.dequeue();)Slt(e,t,r,a);if(e.nodeCount()){for(var s=t.length-2;s>0;--s)if(a=t[s].dequeue(),a){n=n.concat(Slt(e,t,r,a,!0));break}}}return n}function Slt(e,t,r,n,i){var o=i?[]:void 0;return Pd.forEach(e.inEdges(n.v),function(a){var s=e.edge(a),l=e.node(a.v);i&&o.push({v:a.v,w:a.w}),l.out-=s,Mlt(t,r,l)}),Pd.forEach(e.outEdges(n.v),function(a){var s=e.edge(a),l=a.w,c=e.node(l);c.in-=s,Mlt(t,r,c)}),e.removeNode(n.v),o}function Rar(e,t){var r=new Aar,n=0,i=0;Pd.forEach(e.nodes(),function(s){r.setNode(s,{v:s,in:0,out:0})}),Pd.forEach(e.edges(),function(s){var l=r.edge(s.v,s.w)||0,c=t(s),u=l+c;r.setEdge(s.v,s.w,u),i=Math.max(i,r.node(s.v).out+=c),n=Math.max(n,r.node(s.w).in+=c)});var o=Pd.range(i+n+3).map(function(){return new Par}),a=n+1;return Pd.forEach(r.nodes(),function(s){Mlt(o,a,r.node(s))}),{graph:r,buckets:o,zeroIdx:a}}function Mlt(e,t,r){r.out?r.in?e[r.out-r.in+t].enqueue(r):e[e.length-1].enqueue(r):e[0].enqueue(r)}});var xae=H((eQn,vae)=>{"use strict";var Qv=Un(),Nar=yae();vae.exports={run:Dar,undo:zar};function Dar(e){var t=e.graph().acyclicer==="greedy"?Nar(e,r(e)):Oar(e);Qv.forEach(t,function(n){var i=e.edge(n);e.removeEdge(n),i.forwardName=n.name,i.reversed=!0,e.setEdge(n.w,n.v,i,Qv.uniqueId("rev"))});function r(n){return function(i){return n.edge(i).weight}}}function Oar(e){var t=[],r={},n={};function i(o){Qv.has(n,o)||(n[o]=!0,r[o]=!0,Qv.forEach(e.outEdges(o),function(a){Qv.has(r,a.w)?t.push(a):i(a.w)}),delete r[o])}return Qv.forEach(e.nodes(),i),t}function zar(e){Qv.forEach(e.edges(),function(t){var r=e.edge(t);if(r.reversed){e.removeEdge(t);var n=r.forwardName;delete r.reversed,delete r.forwardName,e.setEdge(t.w,t.v,r,n)}})}});var ns=H((rQn,Mae)=>{"use strict";var Qr=Un(),bae=Uc().Graph;Mae.exports={addDummyNode:wae,simplify:Far,asNonCompoundGraph:Bar,successorWeights:Har,predecessorWeights:Var,intersectRect:Uar,buildLayerMatrix:qar,normalizeRanks:Gar,removeEmptyRanks:War,addBorderNode:Yar,maxRank:Sae,partition:jar,time:Xar,notime:$ar};function wae(e,t,r,n){var i;do i=Qr.uniqueId(n);while(e.hasNode(i));return r.dummy=t,e.setNode(i,r),i}function Far(e){var t=new bae().setGraph(e.graph());return Qr.forEach(e.nodes(),function(r){t.setNode(r,e.node(r))}),Qr.forEach(e.edges(),function(r){var n=t.edge(r.v,r.w)||{weight:0,minlen:1},i=e.edge(r);t.setEdge(r.v,r.w,{weight:n.weight+i.weight,minlen:Math.max(n.minlen,i.minlen)})}),t}function Bar(e){var t=new bae({multigraph:e.isMultigraph()}).setGraph(e.graph());return Qr.forEach(e.nodes(),function(r){e.children(r).length||t.setNode(r,e.node(r))}),Qr.forEach(e.edges(),function(r){t.setEdge(r,e.edge(r))}),t}function Har(e){var t=Qr.map(e.nodes(),function(r){var n={};return Qr.forEach(e.outEdges(r),function(i){n[i.w]=(n[i.w]||0)+e.edge(i).weight}),n});return Qr.zipObject(e.nodes(),t)}function Var(e){var t=Qr.map(e.nodes(),function(r){var n={};return Qr.forEach(e.inEdges(r),function(i){n[i.v]=(n[i.v]||0)+e.edge(i).weight}),n});return Qr.zipObject(e.nodes(),t)}function Uar(e,t){var r=e.x,n=e.y,i=t.x-r,o=t.y-n,a=e.width/2,s=e.height/2;if(!i&&!o)throw new Error("Not possible to find intersection inside of the rectangle");var l,c;return Math.abs(o)*a>Math.abs(i)*s?(o<0&&(s=-s),l=s*i/o,c=s):(i<0&&(a=-a),l=a,c=a*o/i),{x:r+l,y:n+c}}function qar(e){var t=Qr.map(Qr.range(Sae(e)+1),function(){return[]});return Qr.forEach(e.nodes(),function(r){var n=e.node(r),i=n.rank;Qr.isUndefined(i)||(t[i][n.order]=r)}),t}function Gar(e){var t=Qr.min(Qr.map(e.nodes(),function(r){return e.node(r).rank}));Qr.forEach(e.nodes(),function(r){var n=e.node(r);Qr.has(n,"rank")&&(n.rank-=t)})}function War(e){var t=Qr.min(Qr.map(e.nodes(),function(o){return e.node(o).rank})),r=[];Qr.forEach(e.nodes(),function(o){var a=e.node(o).rank-t;r[a]||(r[a]=[]),r[a].push(o)});var n=0,i=e.graph().nodeRankFactor;Qr.forEach(r,function(o,a){Qr.isUndefined(o)&&a%i!==0?--n:n&&Qr.forEach(o,function(s){e.node(s).rank+=n})})}function Yar(e,t,r,n){var i={width:0,height:0};return arguments.length>=4&&(i.rank=r,i.order=n),wae(e,"border",i,t)}function Sae(e){return Qr.max(Qr.map(e.nodes(),function(t){var r=e.node(t).rank;if(!Qr.isUndefined(r))return r}))}function jar(e,t){var r={lhs:[],rhs:[]};return Qr.forEach(e,function(n){t(n)?r.lhs.push(n):r.rhs.push(n)}),r}function Xar(e,t){var r=Qr.now();try{return t()}finally{console.log(e+" time: "+(Qr.now()-r)+"ms")}}function $ar(e,t){return t()}});var Cae=H((nQn,Tae)=>{"use strict";var Eae=Un(),Kar=ns();Tae.exports={run:Zar,undo:Qar};function Zar(e){e.graph().dummyChains=[],Eae.forEach(e.edges(),function(t){Jar(e,t)})}function Jar(e,t){var r=t.v,n=e.node(r).rank,i=t.w,o=e.node(i).rank,a=t.name,s=e.edge(t),l=s.labelRank;if(o!==n+1){e.removeEdge(t);var c,u,h;for(h=0,++n;n<o;++h,++n)s.points=[],u={width:0,height:0,edgeLabel:s,edgeObj:t,rank:n},c=Kar.addDummyNode(e,"edge",u,"_d"),n===l&&(u.width=s.width,u.height=s.height,u.dummy="edge-label",u.labelpos=s.labelpos),e.setEdge(r,c,{weight:s.weight},a),h===0&&e.graph().dummyChains.push(c),r=c;e.setEdge(r,i,{weight:s.weight},a)}}function Qar(e){Eae.forEach(e.graph().dummyChains,function(t){var r=e.node(t),n=r.edgeLabel,i;for(e.setEdge(r.edgeObj,n);r.dummy;)i=e.successors(t)[0],e.removeNode(t),n.points.push({x:r.x,y:r.y}),r.dummy==="edge-label"&&(n.x=r.x,n.y=r.y,n.width=r.width,n.height=r.height),t=i,r=e.node(t)})}});var X4=H((iQn,Aae)=>{"use strict";var uH=Un();Aae.exports={longestPath:tsr,slack:esr};function tsr(e){var t={};function r(n){var i=e.node(n);if(uH.has(t,n))return i.rank;t[n]=!0;var o=uH.min(uH.map(e.outEdges(n),function(a){return r(a.w)-e.edge(a).minlen}));return(o===Number.POSITIVE_INFINITY||o===void 0||o===null)&&(o=0),i.rank=o}uH.forEach(e.sources(),r)}function esr(e,t){return e.node(t.w).rank-e.node(t.v).rank-e.edge(t).minlen}});var Elt=H((oQn,Pae)=>{"use strict";var hH=Un(),rsr=Uc().Graph,fH=X4().slack;Pae.exports=nsr;function nsr(e){var t=new rsr({directed:!1}),r=e.nodes()[0],n=e.nodeCount();t.setNode(r,{});for(var i,o;isr(t,e)<n;)i=osr(t,e),o=t.hasNode(i.v)?fH(e,i):-fH(e,i),asr(t,e,o);return t}function isr(e,t){function r(n){hH.forEach(t.nodeEdges(n),function(i){var o=i.v,a=n===o?i.w:o;!e.hasNode(a)&&!fH(t,i)&&(e.setNode(a,{}),e.setEdge(n,a,{}),r(a))})}return hH.forEach(e.nodes(),r),e.nodeCount()}function osr(e,t){return hH.minBy(t.edges(),function(r){if(e.hasNode(r.v)!==e.hasNode(r.w))return fH(t,r)})}function asr(e,t,r){hH.forEach(e.nodes(),function(n){t.node(n).rank+=r})}});var zae=H((aQn,Oae)=>{"use strict";var Id=Un(),ssr=Elt(),lsr=X4().slack,csr=X4().longestPath,usr=Uc().alg.preorder,hsr=Uc().alg.postorder,fsr=ns().simplify;Oae.exports=t1;t1.initLowLimValues=Clt;t1.initCutValues=Tlt;t1.calcCutValue=Lae;t1.leaveEdge=Rae;t1.enterEdge=Nae;t1.exchangeEdges=Dae;function t1(e){e=fsr(e),csr(e);var t=ssr(e);Clt(t),Tlt(t,e);for(var r,n;r=Rae(t);)n=Nae(t,e,r),Dae(t,e,r,n)}function Tlt(e,t){var r=hsr(e,e.nodes());r=r.slice(0,r.length-1),Id.forEach(r,function(n){psr(e,t,n)})}function psr(e,t,r){var n=e.node(r),i=n.parent;e.edge(r,i).cutvalue=Lae(e,t,r)}function Lae(e,t,r){var n=e.node(r),i=n.parent,o=!0,a=t.edge(r,i),s=0;return a||(o=!1,a=t.edge(i,r)),s=a.weight,Id.forEach(t.nodeEdges(r),function(l){var c=l.v===r,u=c?l.w:l.v;if(u!==i){var h=c===o,f=t.edge(l).weight;if(s+=h?f:-f,msr(e,r,u)){var p=e.edge(r,u).cutvalue;s+=h?-p:p}}}),s}function Clt(e,t){arguments.length<2&&(t=e.nodes()[0]),kae(e,{},1,t)}function kae(e,t,r,n,i){var o=r,a=e.node(n);return t[n]=!0,Id.forEach(e.neighbors(n),function(s){Id.has(t,s)||(r=kae(e,t,r,s,n))}),a.low=o,a.lim=r++,i?a.parent=i:delete a.parent,r}function Rae(e){return Id.find(e.edges(),function(t){return e.edge(t).cutvalue<0})}function Nae(e,t,r){var n=r.v,i=r.w;t.hasEdge(n,i)||(n=r.w,i=r.v);var o=e.node(n),a=e.node(i),s=o,l=!1;o.lim>a.lim&&(s=a,l=!0);var c=Id.filter(t.edges(),function(u){return l===Iae(e,e.node(u.v),s)&&l!==Iae(e,e.node(u.w),s)});return Id.minBy(c,function(u){return lsr(t,u)})}function Dae(e,t,r,n){var i=r.v,o=r.w;e.removeEdge(i,o),e.setEdge(n.v,n.w,{}),Clt(e),Tlt(e,t),dsr(e,t)}function dsr(e,t){var r=Id.find(e.nodes(),function(i){return!t.node(i).parent}),n=usr(e,r);n=n.slice(1),Id.forEach(n,function(i){var o=e.node(i).parent,a=t.edge(i,o),s=!1;a||(a=t.edge(o,i),s=!0),t.node(i).rank=t.node(o).rank+(s?a.minlen:-a.minlen)})}function msr(e,t,r){return e.hasEdge(t,r)}function Iae(e,t,r){return r.low<=t.lim&&t.lim<=r.lim}});var Vae=H((sQn,Hae)=>{"use strict";var gsr=X4(),Bae=gsr.longestPath,_sr=Elt(),ysr=zae();Hae.exports=vsr;function vsr(e){switch(e.graph().ranker){case"network-simplex":Fae(e);break;case"tight-tree":bsr(e);break;case"longest-path":xsr(e);break;default:Fae(e)}}var xsr=Bae;function bsr(e){Bae(e),_sr(e)}function Fae(e){ysr(e)}});var qae=H((lQn,Uae)=>{var Alt=Un();Uae.exports=wsr;function wsr(e){var t=Msr(e);Alt.forEach(e.graph().dummyChains,function(r){for(var n=e.node(r),i=n.edgeObj,o=Ssr(e,t,i.v,i.w),a=o.path,s=o.lca,l=0,c=a[l],u=!0;r!==i.w;){if(n=e.node(r),u){for(;(c=a[l])!==s&&e.node(c).maxRank<n.rank;)l++;c===s&&(u=!1)}if(!u){for(;l<a.length-1&&e.node(c=a[l+1]).minRank<=n.rank;)l++;c=a[l]}e.setParent(r,c),r=e.successors(r)[0]}})}function Ssr(e,t,r,n){var i=[],o=[],a=Math.min(t[r].low,t[n].low),s=Math.max(t[r].lim,t[n].lim),l,c;l=r;do l=e.parent(l),i.push(l);while(l&&(t[l].low>a||s>t[l].lim));for(c=l,l=n;(l=e.parent(l))!==c;)o.push(l);return{path:i.concat(o.reverse()),lca:c}}function Msr(e){var t={},r=0;function n(i){var o=r;Alt.forEach(e.children(i),n),t[i]={low:o,lim:r++}}return Alt.forEach(e.children(),n),t}});var Yae=H((cQn,Wae)=>{var Ld=Un(),Plt=ns();Wae.exports={run:Esr,cleanup:Asr};function Esr(e){var t=Plt.addDummyNode(e,"root",{},"_root"),r=Tsr(e),n=Ld.max(Ld.values(r))-1,i=2*n+1;e.graph().nestingRoot=t,Ld.forEach(e.edges(),function(a){e.edge(a).minlen*=i});var o=Csr(e)+1;Ld.forEach(e.children(),function(a){Gae(e,t,i,o,n,r,a)}),e.graph().nodeRankFactor=i}function Gae(e,t,r,n,i,o,a){var s=e.children(a);if(!s.length){a!==t&&e.setEdge(t,a,{weight:0,minlen:r});return}var l=Plt.addBorderNode(e,"_bt"),c=Plt.addBorderNode(e,"_bb"),u=e.node(a);e.setParent(l,a),u.borderTop=l,e.setParent(c,a),u.borderBottom=c,Ld.forEach(s,function(h){Gae(e,t,r,n,i,o,h);var f=e.node(h),p=f.borderTop?f.borderTop:h,d=f.borderBottom?f.borderBottom:h,g=f.borderTop?n:2*n,_=p!==d?1:i-o[a]+1;e.setEdge(l,p,{weight:g,minlen:_,nestingEdge:!0}),e.setEdge(d,c,{weight:g,minlen:_,nestingEdge:!0})}),e.parent(a)||e.setEdge(t,l,{weight:0,minlen:i+o[a]})}function Tsr(e){var t={};function r(n,i){var o=e.children(n);o&&o.length&&Ld.forEach(o,function(a){r(a,i+1)}),t[n]=i}return Ld.forEach(e.children(),function(n){r(n,1)}),t}function Csr(e){return Ld.reduce(e.edges(),function(t,r){return t+e.edge(r).weight},0)}function Asr(e){var t=e.graph();e.removeNode(t.nestingRoot),delete t.nestingRoot,Ld.forEach(e.edges(),function(r){var n=e.edge(r);n.nestingEdge&&e.removeEdge(r)})}});var $ae=H((uQn,Xae)=>{var Ilt=Un(),Psr=ns();Xae.exports=Isr;function Isr(e){function t(r){var n=e.children(r),i=e.node(r);if(n.length&&Ilt.forEach(n,t),Ilt.has(i,"minRank")){i.borderLeft=[],i.borderRight=[];for(var o=i.minRank,a=i.maxRank+1;o<a;++o)jae(e,"borderLeft","_bl",r,i,o),jae(e,"borderRight","_br",r,i,o)}}Ilt.forEach(e.children(),t)}function jae(e,t,r,n,i,o){var a={width:0,height:0,rank:o,borderType:t},s=i[t][o-1],l=Psr.addDummyNode(e,"border",a,r);i[t][o]=l,e.setParent(l,n),s&&e.setEdge(s,l,{weight:1})}});var Qae=H((hQn,Jae)=>{"use strict";var Uf=Un();Jae.exports={adjust:Lsr,undo:ksr};function Lsr(e){var t=e.graph().rankdir.toLowerCase();(t==="lr"||t==="rl")&&Zae(e)}function ksr(e){var t=e.graph().rankdir.toLowerCase();(t==="bt"||t==="rl")&&Rsr(e),(t==="lr"||t==="rl")&&(Nsr(e),Zae(e))}function Zae(e){Uf.forEach(e.nodes(),function(t){Kae(e.node(t))}),Uf.forEach(e.edges(),function(t){Kae(e.edge(t))})}function Kae(e){var t=e.width;e.width=e.height,e.height=t}function Rsr(e){Uf.forEach(e.nodes(),function(t){Llt(e.node(t))}),Uf.forEach(e.edges(),function(t){var r=e.edge(t);Uf.forEach(r.points,Llt),Uf.has(r,"y")&&Llt(r)})}function Llt(e){e.y=-e.y}function Nsr(e){Uf.forEach(e.nodes(),function(t){klt(e.node(t))}),Uf.forEach(e.edges(),function(t){var r=e.edge(t);Uf.forEach(r.points,klt),Uf.has(r,"x")&&klt(r)})}function klt(e){var t=e.x;e.x=e.y,e.y=t}});var ese=H((fQn,tse)=>{"use strict";var kd=Un();tse.exports=Dsr;function Dsr(e){var t={},r=kd.filter(e.nodes(),function(s){return!e.children(s).length}),n=kd.max(kd.map(r,function(s){return e.node(s).rank})),i=kd.map(kd.range(n+1),function(){return[]});function o(s){if(!kd.has(t,s)){t[s]=!0;var l=e.node(s);i[l.rank].push(s),kd.forEach(e.successors(s),o)}}var a=kd.sortBy(r,function(s){return e.node(s).rank});return kd.forEach(a,o),i}});var nse=H((pQn,rse)=>{"use strict";var h0=Un();rse.exports=Osr;function Osr(e,t){for(var r=0,n=1;n<t.length;++n)r+=zsr(e,t[n-1],t[n]);return r}function zsr(e,t,r){for(var n=h0.zipObject(r,h0.map(r,function(c,u){return u})),i=h0.flatten(h0.map(t,function(c){return h0.sortBy(h0.map(e.outEdges(c),function(u){return{pos:n[u.w],weight:e.edge(u).weight}}),"pos")}),!0),o=1;o<r.length;)o<<=1;var a=2*o-1;o-=1;var s=h0.map(new Array(a),function(){return 0}),l=0;return h0.forEach(i.forEach(function(c){var u=c.pos+o;s[u]+=c.weight;for(var h=0;u>0;)u%2&&(h+=s[u+1]),u=u-1>>1,s[u]+=c.weight;l+=c.weight*h})),l}});var ase=H((dQn,ose)=>{var ise=Un();ose.exports=Fsr;function Fsr(e,t){return ise.map(t,function(r){var n=e.inEdges(r);if(n.length){var i=ise.reduce(n,function(o,a){var s=e.edge(a),l=e.node(a.v);return{sum:o.sum+s.weight*l.order,weight:o.weight+s.weight}},{sum:0,weight:0});return{v:r,barycenter:i.sum/i.weight,weight:i.weight}}else return{v:r}})}});var lse=H((mQn,sse)=>{"use strict";var Tl=Un();sse.exports=Bsr;function Bsr(e,t){var r={};Tl.forEach(e,function(i,o){var a=r[i.v]={indegree:0,in:[],out:[],vs:[i.v],i:o};Tl.isUndefined(i.barycenter)||(a.barycenter=i.barycenter,a.weight=i.weight)}),Tl.forEach(t.edges(),function(i){var o=r[i.v],a=r[i.w];!Tl.isUndefined(o)&&!Tl.isUndefined(a)&&(a.indegree++,o.out.push(r[i.w]))});var n=Tl.filter(r,function(i){return!i.indegree});return Hsr(n)}function Hsr(e){var t=[];function r(o){return function(a){a.merged||(Tl.isUndefined(a.barycenter)||Tl.isUndefined(o.barycenter)||a.barycenter>=o.barycenter)&&Vsr(o,a)}}function n(o){return function(a){a.in.push(o),--a.indegree===0&&e.push(a)}}for(;e.length;){var i=e.pop();t.push(i),Tl.forEach(i.in.reverse(),r(i)),Tl.forEach(i.out,n(i))}return Tl.map(Tl.filter(t,function(o){return!o.merged}),function(o){return Tl.pick(o,["vs","i","barycenter","weight"])})}function Vsr(e,t){var r=0,n=0;e.weight&&(r+=e.barycenter*e.weight,n+=e.weight),t.weight&&(r+=t.barycenter*t.weight,n+=t.weight),e.vs=t.vs.concat(e.vs),e.barycenter=r/n,e.weight=n,e.i=Math.min(t.i,e.i),t.merged=!0}});var hse=H((gQn,use)=>{var $4=Un(),Usr=ns();use.exports=qsr;function qsr(e,t){var r=Usr.partition(e,function(u){return $4.has(u,"barycenter")}),n=r.lhs,i=$4.sortBy(r.rhs,function(u){return-u.i}),o=[],a=0,s=0,l=0;n.sort(Gsr(!!t)),l=cse(o,i,l),$4.forEach(n,function(u){l+=u.vs.length,o.push(u.vs),a+=u.barycenter*u.weight,s+=u.weight,l=cse(o,i,l)});var c={vs:$4.flatten(o,!0)};return s&&(c.barycenter=a/s,c.weight=s),c}function cse(e,t,r){for(var n;t.length&&(n=$4.last(t)).i<=r;)t.pop(),e.push(n.vs),r++;return r}function Gsr(e){return function(t,r){return t.barycenter<r.barycenter?-1:t.barycenter>r.barycenter?1:e?r.i-t.i:t.i-r.i}}});var dse=H((_Qn,pse)=>{var f0=Un(),Wsr=ase(),Ysr=lse(),jsr=hse();pse.exports=fse;function fse(e,t,r,n){var i=e.children(t),o=e.node(t),a=o?o.borderLeft:void 0,s=o?o.borderRight:void 0,l={};a&&(i=f0.filter(i,function(d){return d!==a&&d!==s}));var c=Wsr(e,i);f0.forEach(c,function(d){if(e.children(d.v).length){var g=fse(e,d.v,r,n);l[d.v]=g,f0.has(g,"barycenter")&&$sr(d,g)}});var u=Ysr(c,r);Xsr(u,l);var h=jsr(u,n);if(a&&(h.vs=f0.flatten([a,h.vs,s],!0),e.predecessors(a).length)){var f=e.node(e.predecessors(a)[0]),p=e.node(e.predecessors(s)[0]);f0.has(h,"barycenter")||(h.barycenter=0,h.weight=0),h.barycenter=(h.barycenter*h.weight+f.order+p.order)/(h.weight+2),h.weight+=2}return h}function Xsr(e,t){f0.forEach(e,function(r){r.vs=f0.flatten(r.vs.map(function(n){return t[n]?t[n].vs:n}),!0)})}function $sr(e,t){f0.isUndefined(e.barycenter)?(e.barycenter=t.barycenter,e.weight=t.weight):(e.barycenter=(e.barycenter*e.weight+t.barycenter*t.weight)/(e.weight+t.weight),e.weight+=t.weight)}});var gse=H((yQn,mse)=>{var K4=Un(),Ksr=Uc().Graph;mse.exports=Zsr;function Zsr(e,t,r){var n=Jsr(e),i=new Ksr({compound:!0}).setGraph({root:n}).setDefaultNodeLabel(function(o){return e.node(o)});return K4.forEach(e.nodes(),function(o){var a=e.node(o),s=e.parent(o);(a.rank===t||a.minRank<=t&&t<=a.maxRank)&&(i.setNode(o),i.setParent(o,s||n),K4.forEach(e[r](o),function(l){var c=l.v===o?l.w:l.v,u=i.edge(c,o),h=K4.isUndefined(u)?0:u.weight;i.setEdge(c,o,{weight:e.edge(l).weight+h})}),K4.has(a,"minRank")&&i.setNode(o,{borderLeft:a.borderLeft[t],borderRight:a.borderRight[t]}))}),i}function Jsr(e){for(var t;e.hasNode(t=K4.uniqueId("_root")););return t}});var yse=H((vQn,_se)=>{var Qsr=Un();_se.exports=tlr;function tlr(e,t,r){var n={},i;Qsr.forEach(r,function(o){for(var a=e.parent(o),s,l;a;){if(s=e.parent(a),s?(l=n[s],n[s]=a):(l=i,i=a),l&&l!==a){t.setEdge(l,a);return}a=s}})}});var Sse=H((xQn,wse)=>{"use strict";var p0=Un(),elr=ese(),rlr=nse(),nlr=dse(),ilr=gse(),olr=yse(),alr=Uc().Graph,vse=ns();wse.exports=slr;function slr(e){var t=vse.maxRank(e),r=xse(e,p0.range(1,t+1),"inEdges"),n=xse(e,p0.range(t-1,-1,-1),"outEdges"),i=elr(e);bse(e,i);for(var o=Number.POSITIVE_INFINITY,a,s=0,l=0;l<4;++s,++l){llr(s%2?r:n,s%4>=2),i=vse.buildLayerMatrix(e);var c=rlr(e,i);c<o&&(l=0,a=p0.cloneDeep(i),o=c)}bse(e,a)}function xse(e,t,r){return p0.map(t,function(n){return ilr(e,n,r)})}function llr(e,t){var r=new alr;p0.forEach(e,function(n){var i=n.graph().root,o=nlr(n,i,r,t);p0.forEach(o.vs,function(a,s){n.node(a).order=s}),olr(n,r,o.vs)})}function bse(e,t){p0.forEach(t,function(r){p0.forEach(r,function(n,i){e.node(n).order=i})})}});var Rse=H((bQn,kse)=>{"use strict";var Xe=Un(),clr=Uc().Graph,ulr=ns();kse.exports={positionX:plr,findType1Conflicts:Mse,findType2Conflicts:Ese,addConflict:Rlt,hasConflict:Tse,verticalAlignment:Cse,horizontalCompaction:Ase,alignCoordinates:Ise,findSmallestWidthAlignment:Pse,balance:Lse};function Mse(e,t){var r={};function n(i,o){var a=0,s=0,l=i.length,c=Xe.last(o);return Xe.forEach(o,function(u,h){var f=hlr(e,u),p=f?e.node(f).order:l;(f||u===c)&&(Xe.forEach(o.slice(s,h+1),function(d){Xe.forEach(e.predecessors(d),function(g){var _=e.node(g),y=_.order;(y<a||p<y)&&!(_.dummy&&e.node(d).dummy)&&Rlt(r,g,d)})}),s=h+1,a=p)}),o}return Xe.reduce(t,n),r}function Ese(e,t){var r={};function n(o,a,s,l,c){var u;Xe.forEach(Xe.range(a,s),function(h){u=o[h],e.node(u).dummy&&Xe.forEach(e.predecessors(u),function(f){var p=e.node(f);p.dummy&&(p.order<l||p.order>c)&&Rlt(r,f,u)})})}function i(o,a){var s=-1,l,c=0;return Xe.forEach(a,function(u,h){if(e.node(u).dummy==="border"){var f=e.predecessors(u);f.length&&(l=e.node(f[0]).order,n(a,c,h,s,l),c=h,s=l)}n(a,c,a.length,l,o.length)}),a}return Xe.reduce(t,i),r}function hlr(e,t){if(e.node(t).dummy)return Xe.find(e.predecessors(t),function(r){return e.node(r).dummy})}function Rlt(e,t,r){if(t>r){var n=t;t=r,r=n}var i=e[t];i||(e[t]=i={}),i[r]=!0}function Tse(e,t,r){if(t>r){var n=t;t=r,r=n}return Xe.has(e[t],r)}function Cse(e,t,r,n){var i={},o={},a={};return Xe.forEach(t,function(s){Xe.forEach(s,function(l,c){i[l]=l,o[l]=l,a[l]=c})}),Xe.forEach(t,function(s){var l=-1;Xe.forEach(s,function(c){var u=n(c);if(u.length){u=Xe.sortBy(u,function(g){return a[g]});for(var h=(u.length-1)/2,f=Math.floor(h),p=Math.ceil(h);f<=p;++f){var d=u[f];o[c]===c&&l<a[d]&&!Tse(r,c,d)&&(o[d]=c,o[c]=i[c]=i[d],l=a[d])}}})}),{root:i,align:o}}function Ase(e,t,r,n,i){var o={},a=flr(e,t,r,i),s=i?"borderLeft":"borderRight";function l(h,f){for(var p=a.nodes(),d=p.pop(),g={};d;)g[d]?h(d):(g[d]=!0,p.push(d),p=p.concat(f(d))),d=p.pop()}function c(h){o[h]=a.inEdges(h).reduce(function(f,p){return Math.max(f,o[p.v]+a.edge(p))},0)}function u(h){var f=a.outEdges(h).reduce(function(d,g){return Math.min(d,o[g.w]-a.edge(g))},Number.POSITIVE_INFINITY),p=e.node(h);f!==Number.POSITIVE_INFINITY&&p.borderType!==s&&(o[h]=Math.max(o[h],f))}return l(c,a.predecessors.bind(a)),l(u,a.successors.bind(a)),Xe.forEach(n,function(h){o[h]=o[r[h]]}),o}function flr(e,t,r,n){var i=new clr,o=e.graph(),a=dlr(o.nodesep,o.edgesep,n);return Xe.forEach(t,function(s){var l;Xe.forEach(s,function(c){var u=r[c];if(i.setNode(u),l){var h=r[l],f=i.edge(h,u);i.setEdge(h,u,Math.max(a(e,c,l),f||0))}l=c})}),i}function Pse(e,t){return Xe.minBy(Xe.values(t),function(r){var n=Number.NEGATIVE_INFINITY,i=Number.POSITIVE_INFINITY;return Xe.forIn(r,function(o,a){var s=mlr(e,a)/2;n=Math.max(o+s,n),i=Math.min(o-s,i)}),n-i})}function Ise(e,t){var r=Xe.values(t),n=Xe.min(r),i=Xe.max(r);Xe.forEach(["u","d"],function(o){Xe.forEach(["l","r"],function(a){var s=o+a,l=e[s],c;if(l!==t){var u=Xe.values(l);c=a==="l"?n-Xe.min(u):i-Xe.max(u),c&&(e[s]=Xe.mapValues(l,function(h){return h+c}))}})})}function Lse(e,t){return Xe.mapValues(e.ul,function(r,n){if(t)return e[t.toLowerCase()][n];var i=Xe.sortBy(Xe.map(e,n));return(i[1]+i[2])/2})}function plr(e){var t=ulr.buildLayerMatrix(e),r=Xe.merge(Mse(e,t),Ese(e,t)),n={},i;Xe.forEach(["u","d"],function(a){i=a==="u"?t:Xe.values(t).reverse(),Xe.forEach(["l","r"],function(s){s==="r"&&(i=Xe.map(i,function(h){return Xe.values(h).reverse()}));var l=(a==="u"?e.predecessors:e.successors).bind(e),c=Cse(e,i,r,l),u=Ase(e,i,c.root,c.align,s==="r");s==="r"&&(u=Xe.mapValues(u,function(h){return-h})),n[a+s]=u})});var o=Pse(e,n);return Ise(n,o),Lse(n,e.graph().align)}function dlr(e,t,r){return function(n,i,o){var a=n.node(i),s=n.node(o),l=0,c;if(l+=a.width/2,Xe.has(a,"labelpos"))switch(a.labelpos.toLowerCase()){case"l":c=-a.width/2;break;case"r":c=a.width/2;break}if(c&&(l+=r?c:-c),c=0,l+=(a.dummy?t:e)/2,l+=(s.dummy?t:e)/2,l+=s.width/2,Xe.has(s,"labelpos"))switch(s.labelpos.toLowerCase()){case"l":c=s.width/2;break;case"r":c=-s.width/2;break}return c&&(l+=r?c:-c),c=0,l}}function mlr(e,t){return e.node(t).width}});var Ose=H((wQn,Dse)=>{"use strict";var Z4=Un(),Nse=ns(),glr=Rse().positionX;Dse.exports=_lr;function _lr(e){e=Nse.asNonCompoundGraph(e),ylr(e),Z4.forEach(glr(e),function(t,r){e.node(r).x=t})}function ylr(e){var t=Nse.buildLayerMatrix(e),r=e.graph().ranksep,n=0;Z4.forEach(t,function(i){var o=Z4.max(Z4.map(i,function(a){return e.node(a).height}));Z4.forEach(i,function(a){e.node(a).y=n+o/2}),n+=o+r})}});var Use=H((SQn,Vse)=>{"use strict";var ir=Un(),zse=xae(),Fse=Cae(),vlr=Vae(),xlr=ns().normalizeRanks,blr=qae(),wlr=ns().removeEmptyRanks,Bse=Yae(),Slr=$ae(),Hse=Qae(),Mlr=Sse(),Elr=Ose(),d0=ns(),Tlr=Uc().Graph;Vse.exports=Clr;function Clr(e,t){var r=t&&t.debugTiming?d0.time:d0.notime;r("layout",function(){var n=r("  buildLayoutGraph",function(){return Flr(e)});r("  runLayout",function(){Alr(n,r)}),r("  updateInputGraph",function(){Plr(e,n)})})}function Alr(e,t){t("    makeSpaceForEdgeLabels",function(){Blr(e)}),t("    removeSelfEdges",function(){Xlr(e)}),t("    acyclic",function(){zse.run(e)}),t("    nestingGraph.run",function(){Bse.run(e)}),t("    rank",function(){vlr(d0.asNonCompoundGraph(e))}),t("    injectEdgeLabelProxies",function(){Hlr(e)}),t("    removeEmptyRanks",function(){wlr(e)}),t("    nestingGraph.cleanup",function(){Bse.cleanup(e)}),t("    normalizeRanks",function(){xlr(e)}),t("    assignRankMinMax",function(){Vlr(e)}),t("    removeEdgeLabelProxies",function(){Ulr(e)}),t("    normalize.run",function(){Fse.run(e)}),t("    parentDummyChains",function(){blr(e)}),t("    addBorderSegments",function(){Slr(e)}),t("    order",function(){Mlr(e)}),t("    insertSelfEdges",function(){$lr(e)}),t("    adjustCoordinateSystem",function(){Hse.adjust(e)}),t("    position",function(){Elr(e)}),t("    positionSelfEdges",function(){Klr(e)}),t("    removeBorderNodes",function(){jlr(e)}),t("    normalize.undo",function(){Fse.undo(e)}),t("    fixupEdgeLabelCoords",function(){Wlr(e)}),t("    undoCoordinateSystem",function(){Hse.undo(e)}),t("    translateGraph",function(){qlr(e)}),t("    assignNodeIntersects",function(){Glr(e)}),t("    reversePoints",function(){Ylr(e)}),t("    acyclic.undo",function(){zse.undo(e)})}function Plr(e,t){ir.forEach(e.nodes(),function(r){var n=e.node(r),i=t.node(r);n&&(n.x=i.x,n.y=i.y,t.children(r).length&&(n.width=i.width,n.height=i.height))}),ir.forEach(e.edges(),function(r){var n=e.edge(r),i=t.edge(r);n.points=i.points,ir.has(i,"x")&&(n.x=i.x,n.y=i.y)}),e.graph().width=t.graph().width,e.graph().height=t.graph().height}var Ilr=["nodesep","edgesep","ranksep","marginx","marginy"],Llr={ranksep:50,edgesep:20,nodesep:50,rankdir:"tb"},klr=["acyclicer","ranker","rankdir","align"],Rlr=["width","height"],Nlr={width:0,height:0},Dlr=["minlen","weight","width","height","labeloffset"],Olr={minlen:1,weight:1,width:0,height:0,labeloffset:10,labelpos:"r"},zlr=["labelpos"];function Flr(e){var t=new Tlr({multigraph:!0,compound:!0}),r=Dlt(e.graph());return t.setGraph(ir.merge({},Llr,Nlt(r,Ilr),ir.pick(r,klr))),ir.forEach(e.nodes(),function(n){var i=Dlt(e.node(n));t.setNode(n,ir.defaults(Nlt(i,Rlr),Nlr)),t.setParent(n,e.parent(n))}),ir.forEach(e.edges(),function(n){var i=Dlt(e.edge(n));t.setEdge(n,ir.merge({},Olr,Nlt(i,Dlr),ir.pick(i,zlr)))}),t}function Blr(e){var t=e.graph();t.ranksep/=2,ir.forEach(e.edges(),function(r){var n=e.edge(r);n.minlen*=2,n.labelpos.toLowerCase()!=="c"&&(t.rankdir==="TB"||t.rankdir==="BT"?n.width+=n.labeloffset:n.height+=n.labeloffset)})}function Hlr(e){ir.forEach(e.edges(),function(t){var r=e.edge(t);if(r.width&&r.height){var n=e.node(t.v),i=e.node(t.w),o={rank:(i.rank-n.rank)/2+n.rank,e:t};d0.addDummyNode(e,"edge-proxy",o,"_ep")}})}function Vlr(e){var t=0;ir.forEach(e.nodes(),function(r){var n=e.node(r);n.borderTop&&(n.minRank=e.node(n.borderTop).rank,n.maxRank=e.node(n.borderBottom).rank,t=ir.max(t,n.maxRank))}),e.graph().maxRank=t}function Ulr(e){ir.forEach(e.nodes(),function(t){var r=e.node(t);r.dummy==="edge-proxy"&&(e.edge(r.e).labelRank=r.rank,e.removeNode(t))})}function qlr(e){var t=Number.POSITIVE_INFINITY,r=0,n=Number.POSITIVE_INFINITY,i=0,o=e.graph(),a=o.marginx||0,s=o.marginy||0;function l(c){var u=c.x,h=c.y,f=c.width,p=c.height;t=Math.min(t,u-f/2),r=Math.max(r,u+f/2),n=Math.min(n,h-p/2),i=Math.max(i,h+p/2)}ir.forEach(e.nodes(),function(c){l(e.node(c))}),ir.forEach(e.edges(),function(c){var u=e.edge(c);ir.has(u,"x")&&l(u)}),t-=a,n-=s,ir.forEach(e.nodes(),function(c){var u=e.node(c);u.x-=t,u.y-=n}),ir.forEach(e.edges(),function(c){var u=e.edge(c);ir.forEach(u.points,function(h){h.x-=t,h.y-=n}),ir.has(u,"x")&&(u.x-=t),ir.has(u,"y")&&(u.y-=n)}),o.width=r-t+a,o.height=i-n+s}function Glr(e){ir.forEach(e.edges(),function(t){var r=e.edge(t),n=e.node(t.v),i=e.node(t.w),o,a;r.points?(o=r.points[0],a=r.points[r.points.length-1]):(r.points=[],o=i,a=n),r.points.unshift(d0.intersectRect(n,o)),r.points.push(d0.intersectRect(i,a))})}function Wlr(e){ir.forEach(e.edges(),function(t){var r=e.edge(t);if(ir.has(r,"x"))switch((r.labelpos==="l"||r.labelpos==="r")&&(r.width-=r.labeloffset),r.labelpos){case"l":r.x-=r.width/2+r.labeloffset;break;case"r":r.x+=r.width/2+r.labeloffset;break}})}function Ylr(e){ir.forEach(e.edges(),function(t){var r=e.edge(t);r.reversed&&r.points.reverse()})}function jlr(e){ir.forEach(e.nodes(),function(t){if(e.children(t).length){var r=e.node(t),n=e.node(r.borderTop),i=e.node(r.borderBottom),o=e.node(ir.last(r.borderLeft)),a=e.node(ir.last(r.borderRight));r.width=Math.abs(a.x-o.x),r.height=Math.abs(i.y-n.y),r.x=o.x+r.width/2,r.y=n.y+r.height/2}}),ir.forEach(e.nodes(),function(t){e.node(t).dummy==="border"&&e.removeNode(t)})}function Xlr(e){ir.forEach(e.edges(),function(t){if(t.v===t.w){var r=e.node(t.v);r.selfEdges||(r.selfEdges=[]),r.selfEdges.push({e:t,label:e.edge(t)}),e.removeEdge(t)}})}function $lr(e){var t=d0.buildLayerMatrix(e);ir.forEach(t,function(r){var n=0;ir.forEach(r,function(i,o){var a=e.node(i);a.order=o+n,ir.forEach(a.selfEdges,function(s){d0.addDummyNode(e,"selfedge",{width:s.label.width,height:s.label.height,rank:a.rank,order:o+ ++n,e:s.e,label:s.label},"_se")}),delete a.selfEdges})})}function Klr(e){ir.forEach(e.nodes(),function(t){var r=e.node(t);if(r.dummy==="selfedge"){var n=e.node(r.e.v),i=n.x+n.width/2,o=n.y,a=r.x-i,s=n.height/2;e.setEdge(r.e,r.label),e.removeNode(t),r.label.points=[{x:i+2*a/3,y:o-s},{x:i+5*a/6,y:o-s},{x:i+a,y:o},{x:i+5*a/6,y:o+s},{x:i+2*a/3,y:o+s}],r.label.x=r.x,r.label.y=r.y}})}function Nlt(e,t){return ir.mapValues(ir.pick(e,t),Number)}function Dlt(e){var t={};return ir.forEach(e,function(r,n){t[n.toLowerCase()]=r}),t}});var Gse=H((MQn,qse)=>{var pH=Un(),Zlr=ns(),Jlr=Uc().Graph;qse.exports={debugOrdering:Qlr};function Qlr(e){var t=Zlr.buildLayerMatrix(e),r=new Jlr({compound:!0,multigraph:!0}).setGraph({});return pH.forEach(e.nodes(),function(n){r.setNode(n,{label:n}),r.setParent(n,"layer"+e.node(n).rank)}),pH.forEach(e.edges(),function(n){r.setEdge(n.v,n.w,{},n.name)}),pH.forEach(t,function(n,i){var o="layer"+i;r.setNode(o,{rank:"same"}),pH.reduce(n,function(a,s){return r.setEdge(a,s,{style:"invis"}),s})}),r}});var Yse=H((EQn,Wse)=>{Wse.exports="0.8.5"});var Olt=H((TQn,jse)=>{jse.exports={graphlib:Uc(),layout:Use(),debug:Gse(),util:{time:ns().time,notime:ns().notime},version:Yse()}});var Vdt=Ee(Hdt(),1),{__extends:d_r,__assign:m_r,__rest:g_r,__decorate:E,__param:__r,__esDecorate:y_r,__runInitializers:v_r,__propKey:x_r,__setFunctionName:b_r,__metadata:w,__awaiter:w_r,__generator:S_r,__exportStar:M_r,__createBinding:E_r,__values:T_r,__read:C_r,__spread:A_r,__spreadArrays:P_r,__spreadArray:I_r,__await:L_r,__asyncGenerator:k_r,__asyncDelegator:R_r,__asyncValues:N_r,__makeTemplateObject:D_r,__importStar:O_r,__importDefault:z_r,__classPrivateFieldGet:F_r,__classPrivateFieldSet:B_r,__classPrivateFieldIn:H_r}=Vdt.default;function yt(e){return t=>{if(e)if(t.hasOwnProperty("is")){if(e!==t.is)throw new Error(`custom element tag names do not match: (${e} !== ${t.is})`)}else Object.defineProperty(t,"is",{value:e});window.customElements.define(t.is,t)}}function Udt(e,t,r){e.constructor.hasOwnProperty("properties")||Object.defineProperty(e.constructor,"properties",{value:{}}),e.constructor.properties[t]=Object.assign({},e.constructor.properties[t],r)}function A(e){return(t,r)=>{Udt(t,r,e)}}function Bt(...e){return(t,r)=>{t.constructor.hasOwnProperty("observers")||Object.defineProperty(t.constructor,"observers",{value:[]}),t.constructor.observers.push(`${r}(${e.join(",")})`)}}function Rt(e,...t){return(r,n,i)=>{let o=`__compute${n}`;Object.defineProperty(r,o,{value:i.get}),i.get=void 0;let a=[e,...t].join(",");Udt(r,n,{computed:`${o}(${a})`})}}var U_r=qdt((e,t)=>e.querySelector(t)),q_r=qdt((e,t)=>e.querySelectorAll(t));function qdt(e){return t=>(r,n)=>{Object.defineProperty(r,n,{get(){return e(this.shadowRoot,t)},enumerable:!0,configurable:!0})}}window.JSCompiler_renameProperty=function(e,t){return e};var Tve=/(url\()([^)]*)(\))/g,Cve=/(^\/[^\/])|(^#)|(^[\w-\d]*:)/,II,Zs;function l_(e,t){if(e&&Cve.test(e)||e==="//")return e;if(II===void 0){II=!1;try{let r=new URL("b","http://a");r.pathname="c%20d",II=r.href==="http://a/c%20d"}catch(r){}}if(t||(t=document.baseURI||window.location.href),II)try{return new URL(e,t).href}catch(r){return e}return Zs||(Zs=document.implementation.createHTMLDocument("temp"),Zs.base=Zs.createElement("base"),Zs.head.appendChild(Zs.base),Zs.anchor=Zs.createElement("a"),Zs.body.appendChild(Zs.anchor)),Zs.base.href=t,Zs.anchor.href=e,Zs.anchor.href||e}function HM(e,t){return e.replace(Tve,function(r,n,i,o){return n+"'"+l_(i.replace(/["']/g,""),t)+"'"+o})}function Cx(e){return e.substring(0,e.lastIndexOf("/")+1)}var c_=!window.ShadyDOM||!window.ShadyDOM.inUse,$_r=Boolean(!window.ShadyCSS||window.ShadyCSS.nativeCss),K_r=!window.customElements.polyfillWrapFlushCallback,Gdt=c_&&"adoptedStyleSheets"in Document.prototype&&"replaceSync"in CSSStyleSheet.prototype&&(()=>{try{let e=new CSSStyleSheet;e.replaceSync("");let t=document.createElement("div");return t.attachShadow({mode:"open"}),t.shadowRoot.adoptedStyleSheets=[e],t.shadowRoot.adoptedStyleSheets[0]===e}catch(e){return!1}})(),Wdt=window.Polymer&&window.Polymer.rootPath||Cx(document.baseURI||window.location.href);var VM=window.Polymer&&window.Polymer.sanitizeDOMValue||void 0;var Ydt=window.Polymer&&window.Polymer.setPassiveTouchGestures||!1;var iu=window.Polymer&&window.Polymer.strictTemplatePolicy||!1;var jdt=window.Polymer&&window.Polymer.allowTemplateFromDomModule||!1;var pp=window.Polymer&&window.Polymer.legacyOptimizations||!1;var LI=window.Polymer&&window.Polymer.legacyWarnings||!1;var Xdt=window.Polymer&&window.Polymer.syncInitialRender||!1;var kI=window.Polymer&&window.Polymer.legacyUndefined||!1;var $dt=window.Polymer&&window.Polymer.orderedComputed||!1;var fG=!0;var pG=window.Polymer&&window.Polymer.removeNestedTemplates||!1;var RI=window.Polymer&&window.Polymer.fastDomIf||!1;var UM=window.Polymer&&window.Polymer.suppressTemplateNotifications||!1;var qM=window.Polymer&&window.Polymer.legacyNoObservedAttributes||!1;var Kdt=window.Polymer&&window.Polymer.useAdoptedStyleSheetsWithBuiltCSS||!1;var Ave=0;function Zdt(){}Zdt.prototype.__mixinApplications;Zdt.prototype.__mixinSet;var Rn=function(e){let t=e.__mixinApplications;t||(t=new WeakMap,e.__mixinApplications=t);let r=Ave++;function n(i){let o=i.__mixinSet;if(o&&o[r])return i;let a=t,s=a.get(i);if(!s){s=e(i),a.set(i,s);let l=Object.create(s.__mixinSet||o||null);l[r]=!0,s.__mixinSet=l}return s}return n};var dG={},tmt={};function Jdt(e,t){dG[e]=tmt[e.toLowerCase()]=t}function Qdt(e){return dG[e]||tmt[e.toLowerCase()]}function Pve(e){e.querySelector("style")&&console.warn("dom-module %s has style outside template",e.id)}var ou=class extends HTMLElement{static get observedAttributes(){return["id"]}static import(t,r){if(t){let n=Qdt(t);return n&&r?n.querySelector(r):n}return null}attributeChangedCallback(t,r,n,i){r!==n&&this.register()}get assetpath(){if(!this.__assetpath){let t=window.HTMLImports&&HTMLImports.importForElement?HTMLImports.importForElement(this)||document:this.ownerDocument,r=l_(this.getAttribute("assetpath")||"",t.baseURI);this.__assetpath=Cx(r)}return this.__assetpath}register(t){if(t=t||this.id,t){if(iu&&Qdt(t)!==void 0)throw Jdt(t,null),new Error(`strictTemplatePolicy: dom-module ${t} re-registered`);this.id=t,Jdt(t,this),Pve(this)}}};ou.prototype.modules=dG;customElements.define("dom-module",ou);var Ive="link[rel=import][type~=css]",Lve="include",emt="shady-unscoped";function mG(e){return ou.import(e)}function rmt(e){let t=e.body?e.body:e,r=HM(t.textContent,e.baseURI),n=document.createElement("style");return n.textContent=r,n}function kve(e){let t=e.trim().split(/\s+/),r=[];for(let n=0;n<t.length;n++)r.push(...Rve(t[n]));return r}function Rve(e){let t=mG(e);if(!t)return console.warn("Could not find style data in module named",e),[];if(t._styles===void 0){let r=[];r.push(...gG(t));let n=t.querySelector("template");n&&r.push(...NI(n,t.assetpath)),t._styles=r}return t._styles}function NI(e,t){if(!e._styles){let r=[],n=e.content.querySelectorAll("style");for(let i=0;i<n.length;i++){let o=n[i],a=o.getAttribute(Lve);a&&r.push(...kve(a).filter(function(s,l,c){return c.indexOf(s)===l})),t&&(o.textContent=HM(o.textContent,t)),r.push(o)}e._styles=r}return e._styles}function nmt(e){let t=mG(e);return t?gG(t):[]}function gG(e){let t=[],r=e.querySelectorAll(Ive);for(let n=0;n<r.length;n++){let i=r[n];if(i.import){let o=i.import,a=i.hasAttribute(emt);if(a&&!o._unscopedStyle){let s=rmt(o);s.setAttribute(emt,""),o._unscopedStyle=s}else o._style||(o._style=rmt(o));t.push(a?o._unscopedStyle:o._style)}}return t}function imt(e){let t=e.trim().split(/\s+/),r="";for(let n=0;n<t.length;n++)r+=Nve(t[n]);return r}function Nve(e){let t=mG(e);if(t&&t._cssText===void 0){let r=Ove(t),n=t.querySelector("template");n&&(r+=Dve(n,t.assetpath)),t._cssText=r||null}return t||console.warn("Could not find style data in module named",e),t&&t._cssText||""}function Dve(e,t){let r="",n=NI(e,t);for(let i=0;i<n.length;i++){let o=n[i];o.parentNode&&o.parentNode.removeChild(o),r+=o.textContent}return r}function Ove(e){let t="",r=gG(e);for(let n=0;n<r.length;n++)t+=r[n].textContent;return t}var ue=window.ShadyDOM&&window.ShadyDOM.noPatch&&window.ShadyDOM.wrap?window.ShadyDOM.wrap:window.ShadyDOM?e=>ShadyDOM.patch(e):e=>e;function DI(e){return e.indexOf(".")>=0}function au(e){let t=e.indexOf(".");return t===-1?e:e.slice(0,t)}function _G(e,t){return e.indexOf(t+".")===0}function Ax(e,t){return t.indexOf(e+".")===0}function dp(e,t,r){return t+r.slice(e.length)}function OI(e,t){return e===t||_G(e,t)||Ax(e,t)}function Px(e){if(Array.isArray(e)){let t=[];for(let r=0;r<e.length;r++){let n=e[r].toString().split(".");for(let i=0;i<n.length;i++)t.push(n[i])}return t.join(".")}else return e}function omt(e){return Array.isArray(e)?Px(e).split("."):e.toString().split(".")}function No(e,t,r){let n=e,i=omt(t);for(let o=0;o<i.length;o++){if(!n)return;let a=i[o];n=n[a]}return r&&(r.path=i.join(".")),n}function yG(e,t,r){let n=e,i=omt(t),o=i[i.length-1];if(i.length>1){for(let a=0;a<i.length-1;a++){let s=i[a];if(n=n[s],!n)return}n[o]=r}else n[t]=r;return i.join(".")}var zI={},zve=/-[a-z]/g,Fve=/([A-Z])/g;function wm(e){return zI[e]||(zI[e]=e.indexOf("-")<0?e:e.replace(zve,t=>t[1].toUpperCase()))}function Ix(e){return zI[e]||(zI[e]=e.replace(Fve,"-$1").toLowerCase())}var Bve=0,amt=0,Lx=[],Hve=0,vG=!1,smt=document.createTextNode("");new window.MutationObserver(Vve).observe(smt,{characterData:!0});function Vve(){vG=!1;let e=Lx.length;for(let t=0;t<e;t++){let r=Lx[t];if(r)try{r()}catch(n){setTimeout(()=>{throw n})}}Lx.splice(0,e),amt+=e}var mo={after(e){return{run(t){return window.setTimeout(t,e)},cancel(t){window.clearTimeout(t)}}},run(e,t){return window.setTimeout(e,t)},cancel(e){window.clearTimeout(e)}};var Ni={run(e){return window.requestAnimationFrame(e)},cancel(e){window.cancelAnimationFrame(e)}};var kx={run(e){return window.requestIdleCallback?window.requestIdleCallback(e):window.setTimeout(e,16)},cancel(e){window.cancelIdleCallback?window.cancelIdleCallback(e):window.clearTimeout(e)}};var li={run(e){return vG||(vG=!0,smt.textContent=Hve++),Lx.push(e),Bve++},cancel(e){let t=e-amt;if(t>=0){if(!Lx[t])throw new Error("invalid async handle: "+e);Lx[t]=null}}};var Uve=li,FI=Rn(e=>{class t extends e{static createProperties(n){let i=this.prototype;for(let o in n)o in i||i._createPropertyAccessor(o)}static attributeNameForProperty(n){return n.toLowerCase()}static typeForProperty(n){}_createPropertyAccessor(n,i){this._addPropertyToAttributeMap(n),this.hasOwnProperty(JSCompiler_renameProperty("__dataHasAccessor",this))||(this.__dataHasAccessor=Object.assign({},this.__dataHasAccessor)),this.__dataHasAccessor[n]||(this.__dataHasAccessor[n]=!0,this._definePropertyAccessor(n,i))}_addPropertyToAttributeMap(n){this.hasOwnProperty(JSCompiler_renameProperty("__dataAttributes",this))||(this.__dataAttributes=Object.assign({},this.__dataAttributes));let i=this.__dataAttributes[n];return i||(i=this.constructor.attributeNameForProperty(n),this.__dataAttributes[i]=n),i}_definePropertyAccessor(n,i){Object.defineProperty(this,n,{get(){return this.__data[n]},set:i?function(){}:function(o){this._setPendingProperty(n,o,!0)&&this._invalidateProperties()}})}constructor(){super(),this.__dataEnabled=!1,this.__dataReady=!1,this.__dataInvalid=!1,this.__data={},this.__dataPending=null,this.__dataOld=null,this.__dataInstanceProps=null,this.__dataCounter=0,this.__serializing=!1,this._initializeProperties()}ready(){this.__dataReady=!0,this._flushProperties()}_initializeProperties(){for(let n in this.__dataHasAccessor)this.hasOwnProperty(n)&&(this.__dataInstanceProps=this.__dataInstanceProps||{},this.__dataInstanceProps[n]=this[n],delete this[n])}_initializeInstanceProperties(n){Object.assign(this,n)}_setProperty(n,i){this._setPendingProperty(n,i)&&this._invalidateProperties()}_getProperty(n){return this.__data[n]}_setPendingProperty(n,i,o){let a=this.__data[n],s=this._shouldPropertyChange(n,i,a);return s&&(this.__dataPending||(this.__dataPending={},this.__dataOld={}),this.__dataOld&&!(n in this.__dataOld)&&(this.__dataOld[n]=a),this.__data[n]=i,this.__dataPending[n]=i),s}_isPropertyPending(n){return!!(this.__dataPending&&this.__dataPending.hasOwnProperty(n))}_invalidateProperties(){!this.__dataInvalid&&this.__dataReady&&(this.__dataInvalid=!0,Uve.run(()=>{this.__dataInvalid&&(this.__dataInvalid=!1,this._flushProperties())}))}_enableProperties(){this.__dataEnabled||(this.__dataEnabled=!0,this.__dataInstanceProps&&(this._initializeInstanceProperties(this.__dataInstanceProps),this.__dataInstanceProps=null),this.ready())}_flushProperties(){this.__dataCounter++;let n=this.__data,i=this.__dataPending,o=this.__dataOld;this._shouldPropertiesChange(n,i,o)&&(this.__dataPending=null,this.__dataOld=null,this._propertiesChanged(n,i,o)),this.__dataCounter--}_shouldPropertiesChange(n,i,o){return Boolean(i)}_propertiesChanged(n,i,o){}_shouldPropertyChange(n,i,o){return o!==i&&(o===o||i===i)}attributeChangedCallback(n,i,o,a){i!==o&&this._attributeToProperty(n,o),super.attributeChangedCallback&&super.attributeChangedCallback(n,i,o,a)}_attributeToProperty(n,i,o){if(!this.__serializing){let a=this.__dataAttributes,s=a&&a[n]||n;this[s]=this._deserializeValue(i,o||this.constructor.typeForProperty(s))}}_propertyToAttribute(n,i,o){this.__serializing=!0,o=arguments.length<3?this[n]:o,this._valueToNodeAttribute(this,o,i||this.constructor.attributeNameForProperty(n)),this.__serializing=!1}_valueToNodeAttribute(n,i,o){let a=this._serializeValue(i);(o==="class"||o==="name"||o==="slot")&&(n=ue(n)),a===void 0?n.removeAttribute(o):n.setAttribute(o,a)}_serializeValue(n){switch(typeof n){case"boolean":return n?"":void 0;default:return n!=null?n.toString():void 0}}_deserializeValue(n,i){switch(i){case Boolean:return n!==null;case Number:return Number(n);default:return n}}}return t});var lmt={},BI=HTMLElement.prototype;for(;BI;){let e=Object.getOwnPropertyNames(BI);for(let t=0;t<e.length;t++)lmt[e[t]]=!0;BI=Object.getPrototypeOf(BI)}function qve(e,t){if(!lmt[t]){let r=e[t];r!==void 0&&(e.__data?e._setPendingProperty(t,r):(e.__dataProto?e.hasOwnProperty(JSCompiler_renameProperty("__dataProto",e))||(e.__dataProto=Object.create(e.__dataProto)):e.__dataProto={},e.__dataProto[t]=r))}}var HI=Rn(e=>{let t=FI(e);class r extends t{static createPropertiesForAttributes(){let i=this.observedAttributes;for(let o=0;o<i.length;o++)this.prototype._createPropertyAccessor(wm(i[o]))}static attributeNameForProperty(i){return Ix(i)}_initializeProperties(){this.__dataProto&&(this._initializeProtoProperties(this.__dataProto),this.__dataProto=null),super._initializeProperties()}_initializeProtoProperties(i){for(let o in i)this._setProperty(o,i[o])}_ensureAttribute(i,o){let a=this;a.hasAttribute(i)||this._valueToNodeAttribute(a,o,i)}_serializeValue(i){switch(typeof i){case"object":if(i instanceof Date)return i.toString();if(i)try{return JSON.stringify(i)}catch(o){return""}default:return super._serializeValue(i)}}_deserializeValue(i,o){let a;switch(o){case Object:try{a=JSON.parse(i)}catch(s){a=i}break;case Array:try{a=JSON.parse(i)}catch(s){a=null,console.warn(`Polymer::Attributes: couldn't decode Array as JSON: ${i}`)}break;case Date:a=isNaN(i)?String(i):Number(i),a=new Date(a);break;default:a=super._deserializeValue(i,o);break}return a}_definePropertyAccessor(i,o){qve(this,i),super._definePropertyAccessor(i,o)}_hasAccessor(i){return this.__dataHasAccessor&&this.__dataHasAccessor[i]}_isPropertyPending(i){return Boolean(this.__dataPending&&i in this.__dataPending)}}return r});var Gve={"dom-if":!0,"dom-repeat":!0},cmt=!1,umt=!1;function Wve(){if(!cmt){cmt=!0;let e=document.createElement("textarea");e.placeholder="a",umt=e.placeholder===e.textContent}return umt}function Yve(e){Wve()&&e.localName==="textarea"&&e.placeholder&&e.placeholder===e.textContent&&(e.textContent=null)}function jve(e){let t=e.getAttribute("is");if(t&&Gve[t]){let r=e;for(r.removeAttribute("is"),e=r.ownerDocument.createElement(t),r.parentNode.replaceChild(e,r),e.appendChild(r);r.attributes.length;)e.setAttribute(r.attributes[0].name,r.attributes[0].value),r.removeAttribute(r.attributes[0].name)}return e}function hmt(e,t){let r=t.parentInfo&&hmt(e,t.parentInfo);if(r){for(let n=r.firstChild,i=0;n;n=n.nextSibling)if(t.parentIndex===i++)return n}else return e}function Xve(e,t,r,n){n.id&&(t[n.id]=r)}function $ve(e,t,r){if(r.events&&r.events.length)for(let n=0,i=r.events,o;n<i.length&&(o=i[n]);n++)e._addMethodEventListenerToNode(t,o.name,o.value,e)}function Kve(e,t,r,n){r.templateInfo&&(t._templateInfo=r.templateInfo,t._parentTemplateInfo=n)}function Zve(e,t,r){return e=e._methodHost||e,function(i){e[r]?e[r](i,i.detail):console.warn("listener method `"+r+"` not defined")}}var fmt=Rn(e=>{class t extends e{static _parseTemplate(n,i){if(!n._templateInfo){let o=n._templateInfo={};o.nodeInfoList=[],o.nestedTemplate=Boolean(i),o.stripWhiteSpace=i&&i.stripWhiteSpace||n.hasAttribute("strip-whitespace"),this._parseTemplateContent(n,o,{parent:null})}return n._templateInfo}static _parseTemplateContent(n,i,o){return this._parseTemplateNode(n.content,i,o)}static _parseTemplateNode(n,i,o){let a=!1,s=n;return s.localName=="template"&&!s.hasAttribute("preserve-content")?a=this._parseTemplateNestedTemplate(s,i,o)||a:s.localName==="slot"&&(i.hasInsertionPoint=!0),Yve(s),s.firstChild&&this._parseTemplateChildNodes(s,i,o),s.hasAttributes&&s.hasAttributes()&&(a=this._parseTemplateNodeAttributes(s,i,o)||a),a||o.noted}static _parseTemplateChildNodes(n,i,o){if(!(n.localName==="script"||n.localName==="style"))for(let a=n.firstChild,s=0,l;a;a=l){if(a.localName=="template"&&(a=jve(a)),l=a.nextSibling,a.nodeType===Node.TEXT_NODE){let u=l;for(;u&&u.nodeType===Node.TEXT_NODE;)a.textContent+=u.textContent,l=u.nextSibling,n.removeChild(u),u=l;if(i.stripWhiteSpace&&!a.textContent.trim()){n.removeChild(a);continue}}let c={parentIndex:s,parentInfo:o};this._parseTemplateNode(a,i,c)&&(c.infoIndex=i.nodeInfoList.push(c)-1),a.parentNode&&s++}}static _parseTemplateNestedTemplate(n,i,o){let a=n,s=this._parseTemplate(a,i);return(s.content=a.content.ownerDocument.createDocumentFragment()).appendChild(a.content),o.templateInfo=s,!0}static _parseTemplateNodeAttributes(n,i,o){let a=!1,s=Array.from(n.attributes);for(let l=s.length-1,c;c=s[l];l--)a=this._parseTemplateNodeAttribute(n,i,o,c.name,c.value)||a;return a}static _parseTemplateNodeAttribute(n,i,o,a,s){return a.slice(0,3)==="on-"?(n.removeAttribute(a),o.events=o.events||[],o.events.push({name:a.slice(3),value:s}),!0):a==="id"?(o.id=s,!0):!1}static _contentForTemplate(n){let i=n._templateInfo;return i&&i.content||n.content}_stampTemplate(n,i){n&&!n.content&&window.HTMLTemplateElement&&HTMLTemplateElement.decorate&&HTMLTemplateElement.decorate(n),i=i||this.constructor._parseTemplate(n);let o=i.nodeInfoList,a=i.content||n.content,s=document.importNode(a,!0);s.__noInsertionPoint=!i.hasInsertionPoint;let l=s.nodeList=new Array(o.length);s.$={};for(let c=0,u=o.length,h;c<u&&(h=o[c]);c++){let f=l[c]=hmt(s,h);Xve(this,s.$,f,h),Kve(this,f,h,i),$ve(this,f,h)}return s=s,s}_addMethodEventListenerToNode(n,i,o,a){a=a||n;let s=Zve(a,i,o);return this._addEventListenerToNode(n,i,s),s}_addEventListenerToNode(n,i,o){n.addEventListener(i,o)}_removeEventListenerFromNode(n,i,o){n.removeEventListener(i,o)}}return t});var jM=0,XM=[],zr={COMPUTE:"__computeEffects",REFLECT:"__reflectEffects",NOTIFY:"__notifyEffects",PROPAGATE:"__propagateEffects",OBSERVE:"__observeEffects",READ_ONLY:"__readOnly"},xmt="__computeInfo",Jve=/[A-Z]/;function xG(e,t,r){let n=e[t];if(!n)n=e[t]={};else if(!e.hasOwnProperty(t)&&(n=e[t]=Object.create(e[t]),r))for(let i in n){let o=n[i],a=n[i]=Array(o.length);for(let s=0;s<o.length;s++)a[s]=o[s]}return n}function YM(e,t,r,n,i,o){if(t){let a=!1,s=jM++;for(let l in r){let c=i?au(l):l,u=t[c];if(u)for(let h=0,f=u.length,p;h<f&&(p=u[h]);h++)(!p.info||p.info.lastRun!==s)&&(!i||MG(l,p.trigger))&&(p.info&&(p.info.lastRun=s),p.fn(e,l,r,n,p.info,i,o),a=!0)}return a}return!1}function Qve(e,t,r,n,i,o,a,s){let l=!1,c=a?au(n):n,u=t[c];if(u)for(let h=0,f=u.length,p;h<f&&(p=u[h]);h++)(!p.info||p.info.lastRun!==r)&&(!a||MG(n,p.trigger))&&(p.info&&(p.info.lastRun=r),p.fn(e,n,i,o,p.info,a,s),l=!0);return l}function MG(e,t){if(t){let r=t.name;return r==e||!!(t.structured&&_G(r,e))||!!(t.wildcard&&Ax(r,e))}else return!0}function pmt(e,t,r,n,i){let o=typeof i.method=="string"?e[i.method]:i.method,a=i.property;o?o.call(e,e.__data[a],n[a]):i.dynamicFn||console.warn("observer method `"+i.method+"` not defined")}function t1e(e,t,r,n,i){let o=e[zr.NOTIFY],a,s=jM++;for(let c in t)t[c]&&(o&&Qve(e,o,s,c,r,n,i)||i&&e1e(e,c,r))&&(a=!0);let l;a&&(l=e.__dataHost)&&l._invalidateProperties&&l._invalidateProperties()}function e1e(e,t,r){let n=au(t);if(n!==t){let i=Ix(n)+"-changed";return bmt(e,i,r[t],t),!0}return!1}function bmt(e,t,r,n){let i={value:r,queueProperty:!0};n&&(i.path=n),ue(e).dispatchEvent(new CustomEvent(t,{detail:i}))}function r1e(e,t,r,n,i,o){let s=(o?au(t):t)!=t?t:null,l=s?No(e,s):e.__data[t];s&&l===void 0&&(l=r[t]),bmt(e,i.eventName,l,s)}function n1e(e,t,r,n,i){let o,a=e.detail,s=a&&a.path;s?(n=dp(r,n,s),o=a&&a.value):o=e.currentTarget[r],o=i?!o:o,(!t[zr.READ_ONLY]||!t[zr.READ_ONLY][n])&&t._setPendingPropertyOrPath(n,o,!0,Boolean(s))&&(!a||!a.queueProperty)&&t._invalidateProperties()}function i1e(e,t,r,n,i){let o=e.__data[t];VM&&(o=VM(o,i.attrName,"attribute",e)),e._propertyToAttribute(t,i.attrName,o)}function o1e(e,t,r,n){let i=e[zr.COMPUTE];if(i)if($dt){jM++;let o=s1e(e),a=[];for(let l in t)dmt(l,i,a,o,n);let s;for(;s=a.shift();)wmt(e,"",t,r,s)&&dmt(s.methodInfo,i,a,o,n);Object.assign(r,e.__dataOld),Object.assign(t,e.__dataPending),e.__dataPending=null}else{let o=t;for(;YM(e,i,o,r,n);)Object.assign(r,e.__dataOld),Object.assign(t,e.__dataPending),o=e.__dataPending,e.__dataPending=null}}var a1e=(e,t,r)=>{let n=0,i=t.length-1,o=-1;for(;n<=i;){let a=n+i>>1,s=r.get(t[a].methodInfo)-r.get(e.methodInfo);if(s<0)n=a+1;else if(s>0)i=a-1;else{o=a;break}}o<0&&(o=i+1),t.splice(o,0,e)},dmt=(e,t,r,n,i)=>{let o=i?au(e):e,a=t[o];if(a)for(let s=0;s<a.length;s++){let l=a[s];l.info.lastRun!==jM&&(!i||MG(e,l.trigger))&&(l.info.lastRun=jM,a1e(l.info,r,n))}};function s1e(e){let t=e.constructor.__orderedComputedDeps;if(!t){t=new Map;let r=e[zr.COMPUTE],{counts:n,ready:i,total:o}=l1e(e),a;for(;a=i.shift();){t.set(a,t.size);let s=r[a];s&&s.forEach(l=>{let c=l.info.methodInfo;--o,--n[c]===0&&i.push(c)})}o!==0&&console.warn(`Computed graph for ${e.localName} incomplete; circular?`),e.constructor.__orderedComputedDeps=t}return t}function l1e(e){let t=e[xmt],r={},n=e[zr.COMPUTE],i=[],o=0;for(let a in t){let s=t[a];o+=r[a]=s.args.filter(l=>!l.literal).length+(s.dynamicFn?1:0)}for(let a in n)t[a]||i.push(a);return{counts:r,ready:i,total:o}}function wmt(e,t,r,n,i){let o=SG(e,t,r,n,i);if(o===XM)return!1;let a=i.methodInfo;return e.__dataHasAccessor&&e.__dataHasAccessor[a]?e._setPendingProperty(a,o,!0):(e[a]=o,!1)}function c1e(e,t,r){let n=e.__dataLinkedPaths;if(n){let i;for(let o in n){let a=n[o];Ax(o,t)?(i=dp(o,a,t),e._setPendingPropertyOrPath(i,r,!0,!0)):Ax(a,t)&&(i=dp(a,o,t),e._setPendingPropertyOrPath(i,r,!0,!0))}}}function bG(e,t,r,n,i,o,a){r.bindings=r.bindings||[];let s={kind:n,target:i,parts:o,literal:a,isCompound:o.length!==1};if(r.bindings.push(s),d1e(s)){let{event:c,negate:u}=s.parts[0];s.listenerEvent=c||Ix(i)+"-changed",s.listenerNegate=u}let l=t.nodeInfoList.length;for(let c=0;c<s.parts.length;c++){let u=s.parts[c];u.compoundIndex=c,u1e(e,t,s,u,l)}}function u1e(e,t,r,n,i){if(!n.literal)if(r.kind==="attribute"&&r.target[0]==="-")console.warn("Cannot set attribute "+r.target+' because "-" is not a valid attribute starting character');else{let o=n.dependencies,a={index:i,binding:r,part:n,evaluator:e};for(let s=0;s<o.length;s++){let l=o[s];typeof l=="string"&&(l=Mmt(l),l.wildcard=!0),e._addTemplatePropertyEffect(t,l.rootProperty,{fn:h1e,info:a,trigger:l})}}}function h1e(e,t,r,n,i,o,a){let s=a[i.index],l=i.binding,c=i.part;if(o&&c.source&&t.length>c.source.length&&l.kind=="property"&&!l.isCompound&&s.__isPropertyEffectsClient&&s.__dataHasAccessor&&s.__dataHasAccessor[l.target]){let u=r[t];t=dp(c.source,l.target,t),s._setPendingPropertyOrPath(t,u,!1,!0)&&e._enqueueClient(s)}else{let u=i.evaluator._evaluateBinding(e,c,t,r,n,o);u!==XM&&f1e(e,s,l,c,u)}}function f1e(e,t,r,n,i){if(i=p1e(t,i,r,n),VM&&(i=VM(i,r.target,r.kind,t)),r.kind=="attribute")e._valueToNodeAttribute(t,i,r.target);else{let o=r.target;t.__isPropertyEffectsClient&&t.__dataHasAccessor&&t.__dataHasAccessor[o]?(!t[zr.READ_ONLY]||!t[zr.READ_ONLY][o])&&t._setPendingProperty(o,i)&&e._enqueueClient(t):e._setUnmanagedPropertyToNode(t,o,i)}}function p1e(e,t,r,n){if(r.isCompound){let i=e.__dataCompoundStorage[r.target];i[n.compoundIndex]=t,t=i.join("")}return r.kind!=="attribute"&&(r.target==="textContent"||r.target==="value"&&(e.localName==="input"||e.localName==="textarea"))&&(t=t==null?"":t),t}function d1e(e){return Boolean(e.target)&&e.kind!="attribute"&&e.kind!="text"&&!e.isCompound&&e.parts[0].mode==="{"}function m1e(e,t){let{nodeList:r,nodeInfoList:n}=t;if(n.length)for(let i=0;i<n.length;i++){let o=n[i],a=r[i],s=o.bindings;if(s)for(let l=0;l<s.length;l++){let c=s[l];g1e(a,c),_1e(a,e,c)}a.__dataHost=e}}function g1e(e,t){if(t.isCompound){let r=e.__dataCompoundStorage||(e.__dataCompoundStorage={}),n=t.parts,i=new Array(n.length);for(let a=0;a<n.length;a++)i[a]=n[a].literal;let o=t.target;r[o]=i,t.literal&&t.kind=="property"&&(o==="className"&&(e=ue(e)),e[o]=t.literal)}}function _1e(e,t,r){if(r.listenerEvent){let n=r.parts[0];e.addEventListener(r.listenerEvent,function(i){n1e(i,t,r.target,n.source,n.negate)})}}function mmt(e,t,r,n,i,o){o=t.static||o&&(typeof o!="object"||o[t.methodName]);let a={methodName:t.methodName,args:t.args,methodInfo:i,dynamicFn:o};for(let s=0,l;s<t.args.length&&(l=t.args[s]);s++)l.literal||e._addPropertyEffect(l.rootProperty,r,{fn:n,info:a,trigger:l});return o&&e._addPropertyEffect(t.methodName,r,{fn:n,info:a}),a}function SG(e,t,r,n,i){let o=e._methodHost||e,a=o[i.methodName];if(a){let s=e._marshalArgs(i.args,t,r);return s===XM?XM:a.apply(o,s)}else i.dynamicFn||console.warn("method `"+i.methodName+"` not defined")}var y1e=[],Smt="(?:[a-zA-Z_$][\\w.:$\\-*]*)",v1e="(?:[-+]?[0-9]*\\.?[0-9]+(?:[eE][-+]?[0-9]+)?)",x1e="(?:'(?:[^'\\\\]|\\\\.)*')",b1e='(?:"(?:[^"\\\\]|\\\\.)*")',w1e="(?:"+x1e+"|"+b1e+")",gmt="(?:("+Smt+"|"+v1e+"|"+w1e+")\\s*)",S1e="(?:"+gmt+"(?:,\\s*"+gmt+")*)",M1e="(?:\\(\\s*(?:"+S1e+"?)\\)\\s*)",E1e="("+Smt+"\\s*"+M1e+"?)",T1e="(\\[\\[|{{)\\s*",C1e="(?:]]|}})",A1e="(?:(!)\\s*)?",P1e=T1e+A1e+E1e+C1e,_mt=new RegExp(P1e,"g");function ymt(e){let t="";for(let r=0;r<e.length;r++)t+=e[r].literal||"";return t}function wG(e){let t=e.match(/([^\s]+?)\(([\s\S]*)\)/);if(t){let n={methodName:t[1],static:!0,args:y1e};if(t[2].trim()){let i=t[2].replace(/\\,/g,"&comma;").split(",");return I1e(i,n)}else return n}return null}function I1e(e,t){return t.args=e.map(function(r){let n=Mmt(r);return n.literal||(t.static=!1),n},this),t}function Mmt(e){let t=e.trim().replace(/&comma;/g,",").replace(/\\(.)/g,"$1"),r={name:t,value:"",literal:!1},n=t[0];switch(n==="-"&&(n=t[1]),n>="0"&&n<="9"&&(n="#"),n){case"'":case'"':r.value=t.slice(1,-1),r.literal=!0;break;case"#":r.value=Number(t),r.literal=!0;break}return r.literal||(r.rootProperty=au(t),r.structured=DI(t),r.structured&&(r.wildcard=t.slice(-2)==".*",r.wildcard&&(r.name=t.slice(0,-2)))),r}function vmt(e,t,r){let n=No(e,r);return n===void 0&&(n=t[r]),n}function Emt(e,t,r,n){let i={indexSplices:n};kI&&!e._overrideLegacyUndefined&&(t.splices=i),e.notifyPath(r+".splices",i),e.notifyPath(r+".length",t.length),kI&&!e._overrideLegacyUndefined&&(i.indexSplices=[])}function GM(e,t,r,n,i,o){Emt(e,t,r,[{index:n,addedCount:i,removed:o,object:t,type:"splice"}])}function L1e(e){return e[0].toUpperCase()+e.substring(1)}var u_=Rn(e=>{let t=fmt(HI(e));class r extends t{constructor(){super(),this.__isPropertyEffectsClient=!0,this.__dataClientsReady,this.__dataPendingClients,this.__dataToNotify,this.__dataLinkedPaths,this.__dataHasPaths,this.__dataCompoundStorage,this.__dataHost,this.__dataTemp,this.__dataClientsInitialized,this.__data,this.__dataPending,this.__dataOld,this.__computeEffects,this.__computeInfo,this.__reflectEffects,this.__notifyEffects,this.__propagateEffects,this.__observeEffects,this.__readOnly,this.__templateInfo,this._overrideLegacyUndefined}get PROPERTY_EFFECT_TYPES(){return zr}_initializeProperties(){super._initializeProperties(),this._registerHost(),this.__dataClientsReady=!1,this.__dataPendingClients=null,this.__dataToNotify=null,this.__dataLinkedPaths=null,this.__dataHasPaths=!1,this.__dataCompoundStorage=this.__dataCompoundStorage||null,this.__dataHost=this.__dataHost||null,this.__dataTemp={},this.__dataClientsInitialized=!1}_registerHost(){if(WM.length){let i=WM[WM.length-1];i._enqueueClient(this),this.__dataHost=i}}_initializeProtoProperties(i){this.__data=Object.create(i),this.__dataPending=Object.create(i),this.__dataOld={}}_initializeInstanceProperties(i){let o=this[zr.READ_ONLY];for(let a in i)(!o||!o[a])&&(this.__dataPending=this.__dataPending||{},this.__dataOld=this.__dataOld||{},this.__data[a]=this.__dataPending[a]=i[a])}_addPropertyEffect(i,o,a){this._createPropertyAccessor(i,o==zr.READ_ONLY);let s=xG(this,o,!0)[i];s||(s=this[o][i]=[]),s.push(a)}_removePropertyEffect(i,o,a){let s=xG(this,o,!0)[i],l=s.indexOf(a);l>=0&&s.splice(l,1)}_hasPropertyEffect(i,o){let a=this[o];return Boolean(a&&a[i])}_hasReadOnlyEffect(i){return this._hasPropertyEffect(i,zr.READ_ONLY)}_hasNotifyEffect(i){return this._hasPropertyEffect(i,zr.NOTIFY)}_hasReflectEffect(i){return this._hasPropertyEffect(i,zr.REFLECT)}_hasComputedEffect(i){return this._hasPropertyEffect(i,zr.COMPUTE)}_setPendingPropertyOrPath(i,o,a,s){if(s||au(Array.isArray(i)?i[0]:i)!==i){if(!s){let l=No(this,i);if(i=yG(this,i,o),!i||!super._shouldPropertyChange(i,o,l))return!1}if(this.__dataHasPaths=!0,this._setPendingProperty(i,o,a))return c1e(this,i,o),!0}else{if(this.__dataHasAccessor&&this.__dataHasAccessor[i])return this._setPendingProperty(i,o,a);this[i]=o}return!1}_setUnmanagedPropertyToNode(i,o,a){(a!==i[o]||typeof a=="object")&&(o==="className"&&(i=ue(i)),i[o]=a)}_setPendingProperty(i,o,a){let s=this.__dataHasPaths&&DI(i),l=s?this.__dataTemp:this.__data;return this._shouldPropertyChange(i,o,l[i])?(this.__dataPending||(this.__dataPending={},this.__dataOld={}),i in this.__dataOld||(this.__dataOld[i]=this.__data[i]),s?this.__dataTemp[i]=o:this.__data[i]=o,this.__dataPending[i]=o,(s||this[zr.NOTIFY]&&this[zr.NOTIFY][i])&&(this.__dataToNotify=this.__dataToNotify||{},this.__dataToNotify[i]=a),!0):!1}_setProperty(i,o){this._setPendingProperty(i,o,!0)&&this._invalidateProperties()}_invalidateProperties(){this.__dataReady&&this._flushProperties()}_enqueueClient(i){this.__dataPendingClients=this.__dataPendingClients||[],i!==this&&this.__dataPendingClients.push(i)}_flushClients(){this.__dataClientsReady?this.__enableOrFlushClients():(this.__dataClientsReady=!0,this._readyClients(),this.__dataReady=!0)}__enableOrFlushClients(){let i=this.__dataPendingClients;if(i){this.__dataPendingClients=null;for(let o=0;o<i.length;o++){let a=i[o];a.__dataEnabled?a.__dataPending&&a._flushProperties():a._enableProperties()}}}_readyClients(){this.__enableOrFlushClients()}setProperties(i,o){for(let a in i)(o||!this[zr.READ_ONLY]||!this[zr.READ_ONLY][a])&&this._setPendingPropertyOrPath(a,i[a],!0);this._invalidateProperties()}ready(){this._flushProperties(),this.__dataClientsReady||this._flushClients(),this.__dataPending&&this._flushProperties()}_propertiesChanged(i,o,a){let s=this.__dataHasPaths;this.__dataHasPaths=!1;let l;o1e(this,o,a,s),l=this.__dataToNotify,this.__dataToNotify=null,this._propagatePropertyChanges(o,a,s),this._flushClients(),YM(this,this[zr.REFLECT],o,a,s),YM(this,this[zr.OBSERVE],o,a,s),l&&t1e(this,l,o,a,s),this.__dataCounter==1&&(this.__dataTemp={})}_propagatePropertyChanges(i,o,a){this[zr.PROPAGATE]&&YM(this,this[zr.PROPAGATE],i,o,a),this.__templateInfo&&this._runEffectsForTemplate(this.__templateInfo,i,o,a)}_runEffectsForTemplate(i,o,a,s){let l=(c,u)=>{YM(this,i.propertyEffects,c,a,u,i.nodeList);for(let h=i.firstChild;h;h=h.nextSibling)this._runEffectsForTemplate(h,c,a,u)};i.runEffects?i.runEffects(l,o,s):l(o,s)}linkPaths(i,o){i=Px(i),o=Px(o),this.__dataLinkedPaths=this.__dataLinkedPaths||{},this.__dataLinkedPaths[i]=o}unlinkPaths(i){i=Px(i),this.__dataLinkedPaths&&delete this.__dataLinkedPaths[i]}notifySplices(i,o){let a={path:""},s=No(this,i,a);Emt(this,s,a.path,o)}get(i,o){return No(o||this,i)}set(i,o,a){a?yG(a,i,o):(!this[zr.READ_ONLY]||!this[zr.READ_ONLY][i])&&this._setPendingPropertyOrPath(i,o,!0)&&this._invalidateProperties()}push(i,...o){let a={path:""},s=No(this,i,a),l=s.length,c=s.push(...o);return o.length&&GM(this,s,a.path,l,o.length,[]),c}pop(i){let o={path:""},a=No(this,i,o),s=Boolean(a.length),l=a.pop();return s&&GM(this,a,o.path,a.length,0,[l]),l}splice(i,o,a,...s){let l={path:""},c=No(this,i,l);o<0?o=c.length-Math.floor(-o):o&&(o=Math.floor(o));let u;return arguments.length===2?u=c.splice(o):u=c.splice(o,a,...s),(s.length||u.length)&&GM(this,c,l.path,o,s.length,u),u}shift(i){let o={path:""},a=No(this,i,o),s=Boolean(a.length),l=a.shift();return s&&GM(this,a,o.path,0,0,[l]),l}unshift(i,...o){let a={path:""},s=No(this,i,a),l=s.unshift(...o);return o.length&&GM(this,s,a.path,0,o.length,[]),l}notifyPath(i,o){let a;if(arguments.length==1){let s={path:""};o=No(this,i,s),a=s.path}else Array.isArray(i)?a=Px(i):a=i;this._setPendingPropertyOrPath(a,o,!0,!0)&&this._invalidateProperties()}_createReadOnlyProperty(i,o){this._addPropertyEffect(i,zr.READ_ONLY),o&&(this["_set"+L1e(i)]=function(a){this._setProperty(i,a)})}_createPropertyObserver(i,o,a){let s={property:i,method:o,dynamicFn:Boolean(a)};this._addPropertyEffect(i,zr.OBSERVE,{fn:pmt,info:s,trigger:{name:i}}),a&&this._addPropertyEffect(o,zr.OBSERVE,{fn:pmt,info:s,trigger:{name:o}})}_createMethodObserver(i,o){let a=wG(i);if(!a)throw new Error("Malformed observer expression '"+i+"'");mmt(this,a,zr.OBSERVE,SG,null,o)}_createNotifyingProperty(i){this._addPropertyEffect(i,zr.NOTIFY,{fn:r1e,info:{eventName:Ix(i)+"-changed",property:i}})}_createReflectedProperty(i){let o=this.constructor.attributeNameForProperty(i);o[0]==="-"?console.warn("Property "+i+" cannot be reflected to attribute "+o+' because "-" is not a valid starting attribute name. Use a lowercase first letter for the property instead.'):this._addPropertyEffect(i,zr.REFLECT,{fn:i1e,info:{attrName:o}})}_createComputedProperty(i,o,a){let s=wG(o);if(!s)throw new Error("Malformed computed expression '"+o+"'");let l=mmt(this,s,zr.COMPUTE,wmt,i,a);xG(this,xmt)[i]=l}_marshalArgs(i,o,a){let s=this.__data,l=[];for(let c=0,u=i.length;c<u;c++){let{name:h,structured:f,wildcard:p,value:d,literal:g}=i[c];if(!g)if(p){let _=Ax(h,o),y=vmt(s,a,_?o:h);d={path:_?o:h,value:y,base:_?No(s,h):y}}else d=f?vmt(s,a,h):s[h];if(kI&&!this._overrideLegacyUndefined&&d===void 0&&i.length>1)return XM;l[c]=d}return l}static addPropertyEffect(i,o,a){this.prototype._addPropertyEffect(i,o,a)}static createPropertyObserver(i,o,a){this.prototype._createPropertyObserver(i,o,a)}static createMethodObserver(i,o){this.prototype._createMethodObserver(i,o)}static createNotifyingProperty(i){this.prototype._createNotifyingProperty(i)}static createReadOnlyProperty(i,o){this.prototype._createReadOnlyProperty(i,o)}static createReflectedProperty(i){this.prototype._createReflectedProperty(i)}static createComputedProperty(i,o,a){this.prototype._createComputedProperty(i,o,a)}static bindTemplate(i){return this.prototype._bindTemplate(i)}_bindTemplate(i,o){let a=this.constructor._parseTemplate(i),s=this.__preBoundTemplateInfo==a;if(!s)for(let l in a.propertyEffects)this._createPropertyAccessor(l);if(o)if(a=Object.create(a),a.wasPreBound=s,!this.__templateInfo)this.__templateInfo=a;else{let l=i._parentTemplateInfo||this.__templateInfo,c=l.lastChild;a.parent=l,l.lastChild=a,a.previousSibling=c,c?c.nextSibling=a:l.firstChild=a}else this.__preBoundTemplateInfo=a;return a}static _addTemplatePropertyEffect(i,o,a){let s=i.hostProps=i.hostProps||{};s[o]=!0;let l=i.propertyEffects=i.propertyEffects||{};(l[o]=l[o]||[]).push(a)}_stampTemplate(i,o){o=o||this._bindTemplate(i,!0),WM.push(this);let a=super._stampTemplate(i,o);if(WM.pop(),o.nodeList=a.nodeList,!o.wasPreBound){let s=o.childNodes=[];for(let l=a.firstChild;l;l=l.nextSibling)s.push(l)}return a.templateInfo=o,m1e(this,o),this.__dataClientsReady&&(this._runEffectsForTemplate(o,this.__data,null,!1),this._flushClients()),a}_removeBoundDom(i){let o=i.templateInfo,{previousSibling:a,nextSibling:s,parent:l}=o;a?a.nextSibling=s:l&&(l.firstChild=s),s?s.previousSibling=a:l&&(l.lastChild=a),o.nextSibling=o.previousSibling=null;let c=o.childNodes;for(let u=0;u<c.length;u++){let h=c[u];ue(ue(h).parentNode).removeChild(h)}}static _parseTemplateNode(i,o,a){let s=t._parseTemplateNode.call(this,i,o,a);if(i.nodeType===Node.TEXT_NODE){let l=this._parseBindings(i.textContent,o);l&&(i.textContent=ymt(l)||" ",bG(this,o,a,"text","textContent",l),s=!0)}return s}static _parseTemplateNodeAttribute(i,o,a,s,l){let c=this._parseBindings(l,o);if(c){let u=s,h="property";Jve.test(s)?h="attribute":s[s.length-1]=="$"&&(s=s.slice(0,-1),h="attribute");let f=ymt(c);return f&&h=="attribute"&&(s=="class"&&i.hasAttribute("class")&&(f+=" "+i.getAttribute(s)),i.setAttribute(s,f)),h=="attribute"&&u=="disable-upgrade$"&&i.setAttribute(s,""),i.localName==="input"&&u==="value"&&i.setAttribute(u,""),i.removeAttribute(u),h==="property"&&(s=wm(s)),bG(this,o,a,h,s,c,f),!0}else return t._parseTemplateNodeAttribute.call(this,i,o,a,s,l)}static _parseTemplateNestedTemplate(i,o,a){let s=t._parseTemplateNestedTemplate.call(this,i,o,a),l=i.parentNode,c=a.templateInfo,u=l.localName==="dom-if",h=l.localName==="dom-repeat";pG&&(u||h)&&(l.removeChild(i),a=a.parentInfo,a.templateInfo=c,a.noted=!0,s=!1);let f=c.hostProps;if(RI&&u)f&&(o.hostProps=Object.assign(o.hostProps||{},f),pG||(a.parentInfo.noted=!0));else{let p="{";for(let d in f){let g=[{mode:p,source:d,dependencies:[d],hostProp:!0}];bG(this,o,a,"property","_host_"+d,g)}}return s}static _parseBindings(i,o){let a=[],s=0,l;for(;(l=_mt.exec(i))!==null;){l.index>s&&a.push({literal:i.slice(s,l.index)});let c=l[1][0],u=Boolean(l[2]),h=l[3].trim(),f=!1,p="",d=-1;c=="{"&&(d=h.indexOf("::"))>0&&(p=h.substring(d+2),h=h.substring(0,d),f=!0);let g=wG(h),_=[];if(g){let{args:y,methodName:x}=g;for(let S=0;S<y.length;S++){let C=y[S];C.literal||_.push(C)}let b=o.dynamicFns;(b&&b[x]||g.static)&&(_.push(x),g.dynamicFn=!0)}else _.push(h);a.push({source:h,mode:c,negate:u,customEvent:f,signature:g,dependencies:_,event:p}),s=_mt.lastIndex}if(s&&s<i.length){let c=i.substring(s);c&&a.push({literal:c})}return a.length?a:null}static _evaluateBinding(i,o,a,s,l,c){let u;return o.signature?u=SG(i,a,s,l,o.signature):a!=o.source?u=No(i,o.source):c&&DI(a)?u=No(i,a):u=i.__data[a],o.negate&&(u=!u),u}}return r}),WM=[];var k1e=0;function Tmt(){k1e++}var R1e=[];function VI(e){R1e.push(e)}function N1e(e){let t={};for(let r in e){let n=e[r];t[r]=typeof n=="function"?{type:n}:n}return t}var Cmt=Rn(e=>{let t=FI(e);function r(o){let a=Object.getPrototypeOf(o);return a.prototype instanceof i?a:null}function n(o){if(!o.hasOwnProperty(JSCompiler_renameProperty("__ownProperties",o))){let a=null;if(o.hasOwnProperty(JSCompiler_renameProperty("properties",o))){let s=o.properties;s&&(a=N1e(s))}o.__ownProperties=a}return o.__ownProperties}class i extends t{static get observedAttributes(){if(!this.hasOwnProperty(JSCompiler_renameProperty("__observedAttributes",this))){VI(this.prototype);let a=this._properties;this.__observedAttributes=a?Object.keys(a).map(s=>this.prototype._addPropertyToAttributeMap(s)):[]}return this.__observedAttributes}static finalize(){if(!this.hasOwnProperty(JSCompiler_renameProperty("__finalized",this))){let a=r(this);a&&a.finalize(),this.__finalized=!0,this._finalizeClass()}}static _finalizeClass(){let a=n(this);a&&this.createProperties(a)}static get _properties(){if(!this.hasOwnProperty(JSCompiler_renameProperty("__properties",this))){let a=r(this);this.__properties=Object.assign({},a&&a._properties,n(this))}return this.__properties}static typeForProperty(a){let s=this._properties[a];return s&&s.type}_initializeProperties(){Tmt(),this.constructor.finalize(),super._initializeProperties()}connectedCallback(){super.connectedCallback&&super.connectedCallback(),this._enableProperties()}disconnectedCallback(){super.disconnectedCallback&&super.disconnectedCallback()}}return i});var Amt="3.4.1",UI=window.ShadyCSS&&window.ShadyCSS.cssBuild,Sm=Rn(e=>{let t=Cmt(u_(e));function r(l){if(!l.hasOwnProperty(JSCompiler_renameProperty("__propertyDefaults",l))){l.__propertyDefaults=null;let c=l._properties;for(let u in c){let h=c[u];"value"in h&&(l.__propertyDefaults=l.__propertyDefaults||{},l.__propertyDefaults[u]=h)}}return l.__propertyDefaults}function n(l){return l.hasOwnProperty(JSCompiler_renameProperty("__ownObservers",l))||(l.__ownObservers=l.hasOwnProperty(JSCompiler_renameProperty("observers",l))?l.observers:null),l.__ownObservers}function i(l,c,u,h){u.computed&&(u.readOnly=!0),u.computed&&(l._hasReadOnlyEffect(c)?console.warn(`Cannot redefine computed property '${c}'.`):l._createComputedProperty(c,u.computed,h)),u.readOnly&&!l._hasReadOnlyEffect(c)?l._createReadOnlyProperty(c,!u.computed):u.readOnly===!1&&l._hasReadOnlyEffect(c)&&console.warn(`Cannot make readOnly property '${c}' non-readOnly.`),u.reflectToAttribute&&!l._hasReflectEffect(c)?l._createReflectedProperty(c):u.reflectToAttribute===!1&&l._hasReflectEffect(c)&&console.warn(`Cannot make reflected property '${c}' non-reflected.`),u.notify&&!l._hasNotifyEffect(c)?l._createNotifyingProperty(c):u.notify===!1&&l._hasNotifyEffect(c)&&console.warn(`Cannot make notify property '${c}' non-notify.`),u.observer&&l._createPropertyObserver(c,u.observer,h[u.observer]),l._addPropertyToAttributeMap(c)}function o(l,c,u,h){if(!UI){let f=c.content.querySelectorAll("style"),p=NI(c),d=nmt(u),g=c.content.firstElementChild;for(let y=0;y<d.length;y++){let x=d[y];x.textContent=l._processStyleText(x.textContent,h),c.content.insertBefore(x,g)}let _=0;for(let y=0;y<p.length;y++){let x=p[y],b=f[_];b!==x?(x=x.cloneNode(!0),b.parentNode.insertBefore(x,b)):_++,x.textContent=l._processStyleText(x.textContent,h)}}if(window.ShadyCSS&&window.ShadyCSS.prepareTemplate(c,u),Kdt&&UI&&Gdt){let f=c.content.querySelectorAll("style");if(f){let p="";Array.from(f).forEach(d=>{p+=d.textContent,d.parentNode.removeChild(d)}),l._styleSheet=new CSSStyleSheet,l._styleSheet.replaceSync(p)}}}function a(l){let c=null;if(l&&(!iu||jdt)&&(c=ou.import(l,"template"),iu&&!c))throw new Error(`strictTemplatePolicy: expecting dom-module or null template for ${l}`);return c}class s extends t{static get polymerElementVersion(){return Amt}static _finalizeClass(){t._finalizeClass.call(this);let c=n(this);c&&this.createObservers(c,this._properties),this._prepareTemplate()}static _prepareTemplate(){let c=this.template;c&&(typeof c=="string"?(console.error("template getter must return HTMLTemplateElement"),c=null):pp||(c=c.cloneNode(!0))),this.prototype._template=c}static createProperties(c){for(let u in c)i(this.prototype,u,c[u],c)}static createObservers(c,u){let h=this.prototype;for(let f=0;f<c.length;f++)h._createMethodObserver(c[f],u)}static get template(){if(!this.hasOwnProperty(JSCompiler_renameProperty("_template",this))){let c=this.prototype.hasOwnProperty(JSCompiler_renameProperty("_template",this.prototype))?this.prototype._template:void 0;this._template=c!==void 0?c:this.hasOwnProperty(JSCompiler_renameProperty("is",this))&&a(this.is)||Object.getPrototypeOf(this.prototype).constructor.template}return this._template}static set template(c){this._template=c}static get importPath(){if(!this.hasOwnProperty(JSCompiler_renameProperty("_importPath",this))){let c=this.importMeta;if(c)this._importPath=Cx(c.url);else{let u=ou.import(this.is);this._importPath=u&&u.assetpath||Object.getPrototypeOf(this.prototype).constructor.importPath}}return this._importPath}constructor(){super(),this._template,this._importPath,this.rootPath,this.importPath,this.root,this.$}_initializeProperties(){this.constructor.finalize(),this.constructor._finalizeTemplate(this.localName),super._initializeProperties(),this.rootPath=Wdt,this.importPath=this.constructor.importPath;let c=r(this.constructor);if(!!c)for(let u in c){let h=c[u];if(this._canApplyPropertyDefault(u)){let f=typeof h.value=="function"?h.value.call(this):h.value;this._hasAccessor(u)?this._setPendingProperty(u,f,!0):this[u]=f}}}_canApplyPropertyDefault(c){return!this.hasOwnProperty(c)}static _processStyleText(c,u){return HM(c,u)}static _finalizeTemplate(c){let u=this.prototype._template;if(u&&!u.__polymerFinalized){u.__polymerFinalized=!0;let h=this.importPath,f=h?l_(h):"";o(this,u,c,f),this.prototype._bindTemplate(u)}}connectedCallback(){window.ShadyCSS&&this._template&&window.ShadyCSS.styleElement(this),super.connectedCallback()}ready(){this._template&&(this.root=this._stampTemplate(this._template),this.$=this.root.$),super.ready()}_readyClients(){this._template&&(this.root=this._attachDom(this.root)),super._readyClients()}_attachDom(c){let u=ue(this);if(u.attachShadow)return c?(u.shadowRoot||(u.attachShadow({mode:"open",shadyUpgradeFragment:c}),u.shadowRoot.appendChild(c),this.constructor._styleSheet&&(u.shadowRoot.adoptedStyleSheets=[this.constructor._styleSheet])),Xdt&&window.ShadyDOM&&window.ShadyDOM.flushInitial(u.shadowRoot),u.shadowRoot):null;throw new Error("ShadowDOM not available. PolymerElement can create dom as children instead of in ShadowDOM by setting `this.root = this;` before `ready`.")}updateStyles(c){window.ShadyCSS&&window.ShadyCSS.styleSubtree(this,c)}resolveUrl(c,u){return!u&&this.importPath&&(u=l_(this.importPath)),l_(c,u)}static _parseTemplateContent(c,u,h){return u.dynamicFns=u.dynamicFns||this._properties,t._parseTemplateContent.call(this,c,u,h)}static _addTemplatePropertyEffect(c,u,h){return LI&&!(u in this._properties)&&!(h.info.part.signature&&h.info.part.signature.static)&&!h.info.part.hostProp&&!c.nestedTemplate&&console.warn(`Property '${u}' used in template but not declared in 'properties'; attribute will not be observed.`),t._addTemplatePropertyEffect.call(this,c,u,h)}}return s});var qI=class{constructor(t){this.value=t.toString()}toString(){return this.value}};function D1e(e){if(e instanceof qI)return e.value;throw new Error(`non-literal value passed to Polymer's htmlLiteral function: ${e}`)}function O1e(e){if(e instanceof HTMLTemplateElement)return e.innerHTML;if(e instanceof qI)return D1e(e);throw new Error(`non-template value passed to Polymer's html function: ${e}`)}var Q=function(t,...r){let n=document.createElement("template");return n.innerHTML=r.reduce((i,o,a)=>i+O1e(o)+t[a+1],t[0]),n};var mt=Sm(HTMLElement);var fy=Ee(Oe(),1);var h_=!(window.ShadyDOM&&window.ShadyDOM.inUse),GI;function Pmt(e){e&&e.shimcssproperties?GI=!1:GI=h_||Boolean(!navigator.userAgent.match(/AppleWebKit\/601|Edge\/15/)&&window.CSS&&CSS.supports&&CSS.supports("box-shadow","0 0 0 var(--foo)"))}var Mm;window.ShadyCSS&&window.ShadyCSS.cssBuild!==void 0&&(Mm=window.ShadyCSS.cssBuild);var WI=Boolean(window.ShadyCSS&&window.ShadyCSS.disableRuntime);window.ShadyCSS&&window.ShadyCSS.nativeCss!==void 0?GI=window.ShadyCSS.nativeCss:window.ShadyCSS?(Pmt(window.ShadyCSS),window.ShadyCSS=void 0):Pmt(window.WebComponents&&window.WebComponents.flags);var Nx=GI;var YI=class{constructor(){this.start=0,this.end=0,this.previous=null,this.parent=null,this.rules=null,this.parsedCssText="",this.cssText="",this.atRule=!1,this.type=0,this.keyframesName="",this.selector="",this.parsedSelector=""}};function EG(e){return e=z1e(e),Imt(F1e(e),e)}function z1e(e){return e.replace(gp.comments,"").replace(gp.port,"")}function F1e(e){let t=new YI;t.start=0,t.end=e.length;let r=t;for(let n=0,i=e.length;n<i;n++)if(e[n]===Lmt){r.rules||(r.rules=[]);let o=r,a=o.rules[o.rules.length-1]||null;r=new YI,r.start=n+1,r.parent=o,r.previous=a,o.rules.push(r)}else e[n]===kmt&&(r.end=n+1,r=r.parent||t);return t}function Imt(e,t){let r=t.substring(e.start,e.end-1);if(e.parsedCssText=e.cssText=r.trim(),e.parent){let i=e.previous?e.previous.end:e.parent.start;r=t.substring(i,e.start-1),r=B1e(r),r=r.replace(gp.multipleSpaces," "),r=r.substring(r.lastIndexOf(";")+1);let o=e.parsedSelector=e.selector=r.trim();e.atRule=o.indexOf(W1e)===0,e.atRule?o.indexOf(G1e)===0?e.type=mp.MEDIA_RULE:o.match(gp.keyframesRule)&&(e.type=mp.KEYFRAMES_RULE,e.keyframesName=e.selector.split(gp.multipleSpaces).pop()):o.indexOf(Rmt)===0?e.type=mp.MIXIN_RULE:e.type=mp.STYLE_RULE}let n=e.rules;if(n)for(let i=0,o=n.length,a;i<o&&(a=n[i]);i++)Imt(a,t);return e}function B1e(e){return e.replace(/\\([0-9a-f]{1,6})\s/gi,function(){let t=arguments[1],r=6-t.length;for(;r--;)t="0"+t;return"\\"+t})}function TG(e,t,r=""){let n="";if(e.cssText||e.rules){let i=e.rules;if(i&&!H1e(i))for(let o=0,a=i.length,s;o<a&&(s=i[o]);o++)n=TG(s,t,n);else n=t?e.cssText:V1e(e.cssText),n=n.trim(),n&&(n="  "+n+`
`)}return n&&(e.selector&&(r+=e.selector+" "+Lmt+`
`),r+=n,e.selector&&(r+=kmt+`

`)),r}function H1e(e){let t=e[0];return Boolean(t)&&Boolean(t.selector)&&t.selector.indexOf(Rmt)===0}function V1e(e){return e=U1e(e),q1e(e)}function U1e(e){return e.replace(gp.customProp,"").replace(gp.mixinProp,"")}function q1e(e){return e.replace(gp.mixinApply,"").replace(gp.varApply,"")}var mp={STYLE_RULE:1,KEYFRAMES_RULE:7,MEDIA_RULE:4,MIXIN_RULE:1e3},Lmt="{",kmt="}",gp={comments:/\/\*[^*]*\*+([^/*][^*]*\*+)*\//gim,port:/@import[^;]*;/gim,customProp:/(?:^[^;\-\s}]+)?--[^;{}]*?:[^{};]*?(?:[;\n]|$)/gim,mixinProp:/(?:^[^;\-\s}]+)?--[^;{}]*?:[^{};]*?{[^}]*?}(?:[;\n]|$)?/gim,mixinApply:/@apply\s*\(?[^);]*\)?\s*(?:[;\n]|$)?/gim,varApply:/[^;:]*?:[^;]*?var\([^;]*\)(?:[;\n]|$)?/gim,keyframesRule:/^@[^\s]*keyframes/,multipleSpaces:/\s+/g},Rmt="--",G1e="@media",W1e="@";var KM=/(?:^|[;\s{]\s*)(--[\w-]*?)\s*:\s*(?:((?:'(?:\\'|.)*?'|"(?:\\"|.)*?"|\([^)]*?\)|[^};{])+)|\{([^}]*)\}(?:(?=[;\s}])|$))/gi,Dx=/(?:^|\W+)@apply\s*\(?([^);\n]*)\)?/gi;var Nmt=/@media\s(.*)/;var Dmt=new Set,Y1e="shady-unscoped";function Omt(e){let t=e.textContent;if(!Dmt.has(t)){Dmt.add(t);let r=document.createElement("style");r.setAttribute("shady-unscoped",""),r.textContent=t,document.head.appendChild(r)}}function zmt(e){return e.hasAttribute(Y1e)}function ZM(e,t){return e?(typeof e=="string"&&(e=EG(e)),t&&Ox(e,t),TG(e,Nx)):""}function CG(e){return!e.__cssRules&&e.textContent&&(e.__cssRules=EG(e.textContent)),e.__cssRules||null}function Ox(e,t,r,n){if(!e)return;let i=!1,o=e.type;if(n&&o===mp.MEDIA_RULE){let s=e.selector.match(Nmt);s&&(window.matchMedia(s[1]).matches||(i=!0))}o===mp.STYLE_RULE?t(e):r&&o===mp.KEYFRAMES_RULE?r(e):o===mp.MIXIN_RULE&&(i=!0);let a=e.rules;if(a&&!i)for(let s=0,l=a.length,c;s<l&&(c=a[s]);s++)Ox(c,t,r,n)}function j1e(e,t){let r=0;for(let n=t,i=e.length;n<i;n++)if(e[n]==="(")r++;else if(e[n]===")"&&--r===0)return n;return-1}function AG(e,t){let r=e.indexOf("var(");if(r===-1)return t(e,"","","");let n=j1e(e,r+3),i=e.substring(r+4,n),o=e.substring(0,r),a=AG(e.substring(n+1),t),s=i.indexOf(",");if(s===-1)return t(o,i.trim(),"",a);let l=i.substring(0,s).trim(),c=i.substring(s+1).trim();return t(o,l,c,a)}var fvr=window.ShadyDOM&&window.ShadyDOM.wrap||(e=>e);function Fmt(e){let t=e.localName,r="",n="";return t?t.indexOf("-")>-1?r=t:(n=t,r=e.getAttribute&&e.getAttribute("is")||""):(r=e.is,n=e.extends),{is:r,typeExtension:n}}function Bmt(e){let t=[],r=e.querySelectorAll("style");for(let n=0;n<r.length;n++){let i=r[n];zmt(i)?h_||(Omt(i),i.parentNode.removeChild(i)):(t.push(i.textContent),i.parentNode.removeChild(i))}return t.join("").trim()}var Hmt="css-build";function X1e(e){if(Mm!==void 0)return Mm;if(e.__cssBuild===void 0){let t=e.getAttribute(Hmt);if(t)e.__cssBuild=t;else{let r=$1e(e);r!==""&&K1e(e),e.__cssBuild=r}}return e.__cssBuild||""}function PG(e){return X1e(e)!==""}function $1e(e){let t=e.localName==="template"?e.content.firstChild:e.firstChild;if(t instanceof Comment){let r=t.textContent.trim().split(":");if(r[0]===Hmt)return r[1]}return""}function K1e(e){let t=e.localName==="template"?e.content.firstChild:e.firstChild;t.parentNode.removeChild(t)}function JM(e,t){for(let r in t)r===null?e.style.removeProperty(r):e.style.setProperty(r,t[r])}function jI(e,t){let r=window.getComputedStyle(e).getPropertyValue(t);return r?r.trim():""}function Vmt(e){let t=Dx.test(e)||KM.test(e);return Dx.lastIndex=0,KM.lastIndex=0,t}var Z1e=/;\s*/m,J1e=/^\s*(initial)|(inherit)\s*$/,Umt=/\s*!important/,IG="_-_";var LG=class{constructor(){this._map={}}set(t,r){t=t.trim(),this._map[t]={properties:r,dependants:{}}}get(t){return t=t.trim(),this._map[t]||null}},XI=null,Do=class{constructor(){this._currentElement=null,this._measureElement=null,this._map=new LG}detectMixin(t){return Vmt(t)}gatherStyles(t){let r=Bmt(t.content);if(r){let n=document.createElement("style");return n.textContent=r,t.content.insertBefore(n,t.content.firstChild),n}return null}transformTemplate(t,r){t._gatheredStyle===void 0&&(t._gatheredStyle=this.gatherStyles(t));let n=t._gatheredStyle;return n?this.transformStyle(n,r):null}transformStyle(t,r=""){let n=CG(t);return this.transformRules(n,r),t.textContent=ZM(n),n}transformCustomStyle(t){let r=CG(t);return Ox(r,n=>{n.selector===":root"&&(n.selector="html"),this.transformRule(n)}),t.textContent=ZM(r),r}transformRules(t,r){this._currentElement=r,Ox(t,n=>{this.transformRule(n)}),this._currentElement=null}transformRule(t){t.cssText=this.transformCssText(t.parsedCssText,t),t.selector===":root"&&(t.selector=":host > *")}transformCssText(t,r){return t=t.replace(KM,(n,i,o,a)=>this._produceCssProperties(n,i,o,a,r)),this._consumeCssProperties(t,r)}_getInitialValueForProperty(t){return this._measureElement||(this._measureElement=document.createElement("meta"),this._measureElement.setAttribute("apply-shim-measure",""),this._measureElement.style.all="initial",document.head.appendChild(this._measureElement)),window.getComputedStyle(this._measureElement).getPropertyValue(t)}_fallbacksFromPreviousRules(t){let r=t;for(;r.parent;)r=r.parent;let n={},i=!1;return Ox(r,o=>{i=i||o===t,!i&&o.selector===t.selector&&Object.assign(n,this._cssTextToMap(o.parsedCssText))}),n}_consumeCssProperties(t,r){let n=null;for(;n=Dx.exec(t);){let i=n[0],o=n[1],a=n.index,s=a+i.indexOf("@apply"),l=a+i.length,c=t.slice(0,s),u=t.slice(l),h=r?this._fallbacksFromPreviousRules(r):{};Object.assign(h,this._cssTextToMap(c));let f=this._atApplyToCssProperties(o,h);t=`${c}${f}${u}`,Dx.lastIndex=a+f.length}return t}_atApplyToCssProperties(t,r){t=t.replace(Z1e,"");let n=[],i=this._map.get(t);if(i||(this._map.set(t,{}),i=this._map.get(t)),i){this._currentElement&&(i.dependants[this._currentElement]=!0);let o,a,s,l=i.properties;for(o in l)s=r&&r[o],a=[o,": var(",t,IG,o],s&&a.push(",",s.replace(Umt,"")),a.push(")"),Umt.test(l[o])&&a.push(" !important"),n.push(a.join(""))}return n.join("; ")}_replaceInitialOrInherit(t,r){let n=J1e.exec(r);return n&&(n[1]?r=this._getInitialValueForProperty(t):r="apply-shim-inherit"),r}_cssTextToMap(t,r=!1){let n=t.split(";"),i,o,a={};for(let s=0,l,c;s<n.length;s++)l=n[s],l&&(c=l.split(":"),c.length>1&&(i=c[0].trim(),o=c.slice(1).join(":"),r&&(o=this._replaceInitialOrInherit(i,o)),a[i]=o));return a}_invalidateMixinEntry(t){if(!!XI)for(let r in t.dependants)r!==this._currentElement&&XI(r)}_produceCssProperties(t,r,n,i,o){if(n&&AG(n,(_,y)=>{y&&this._map.get(y)&&(i=`@apply ${y};`)}),!i)return t;let a=this._consumeCssProperties(""+i,o),s=t.slice(0,t.indexOf("--")),l=this._cssTextToMap(a,!0),c=l,u=this._map.get(r),h=u&&u.properties;h?c=Object.assign(Object.create(h),l):this._map.set(r,c);let f=[],p,d,g=!1;for(p in c)d=l[p],d===void 0&&(d="initial"),h&&!(p in h)&&(g=!0),f.push(`${r}${IG}${p}: ${d}`);return g&&this._invalidateMixinEntry(u),u&&(u.properties=c),n&&(s=`${t};${s}`),`${s}${f.join("; ")};`}};Do.prototype.detectMixin=Do.prototype.detectMixin;Do.prototype.transformStyle=Do.prototype.transformStyle;Do.prototype.transformCustomStyle=Do.prototype.transformCustomStyle;Do.prototype.transformRules=Do.prototype.transformRules;Do.prototype.transformRule=Do.prototype.transformRule;Do.prototype.transformTemplate=Do.prototype.transformTemplate;Do.prototype._separator=IG;Object.defineProperty(Do.prototype,"invalidCallback",{get(){return XI},set(e){XI=e}});var qmt=Do;var Q1e={},QM=Q1e;var $I="_applyShimCurrentVersion",zx="_applyShimNextVersion",KI="_applyShimValidatingVersion",txe=Promise.resolve();function Gmt(e){let t=QM[e];t&&exe(t)}function exe(e){e[$I]=e[$I]||0,e[KI]=e[KI]||0,e[zx]=(e[zx]||0)+1}function kG(e){return e[$I]===e[zx]}function Wmt(e){return!kG(e)&&e[KI]===e[zx]}function Ymt(e){e[KI]=e[zx],e._validating||(e._validating=!0,txe.then(function(){e[$I]=e[zx],e._validating=!1}))}var RG=null,jmt=window.HTMLImports&&window.HTMLImports.whenReady||null,NG;function ZI(e){requestAnimationFrame(function(){jmt?jmt(e):(RG||(RG=new Promise(t=>{NG=t}),document.readyState==="complete"?NG():document.addEventListener("readystatechange",()=>{document.readyState==="complete"&&NG()})),RG.then(function(){e&&e()}))})}var Xmt="__seenByShadyCSS",JI="__shadyCSSCachedStyle",QI=null,tE=null,Zl=class{constructor(){this.customStyles=[],this.enqueued=!1,ZI(()=>{window.ShadyCSS.flushCustomStyles&&window.ShadyCSS.flushCustomStyles()})}enqueueDocumentValidation(){this.enqueued||!tE||(this.enqueued=!0,ZI(tE))}addCustomStyle(t){t[Xmt]||(t[Xmt]=!0,this.customStyles.push(t),this.enqueueDocumentValidation())}getStyleForCustomStyle(t){if(t[JI])return t[JI];let r;return t.getStyle?r=t.getStyle():r=t,r}processStyles(){let t=this.customStyles;for(let r=0;r<t.length;r++){let n=t[r];if(n[JI])continue;let i=this.getStyleForCustomStyle(n);if(i){let o=i.__appliedElement||i;QI&&QI(o),n[JI]=o}}return t}};Zl.prototype.addCustomStyle=Zl.prototype.addCustomStyle;Zl.prototype.getStyleForCustomStyle=Zl.prototype.getStyleForCustomStyle;Zl.prototype.processStyles=Zl.prototype.processStyles;Object.defineProperties(Zl.prototype,{transformCallback:{get(){return QI},set(e){QI=e}},validateCallback:{get(){return tE},set(e){let t=!1;tE||(t=!0),tE=e,t&&this.enqueueDocumentValidation()}}});var eE=new qmt,DG=class{constructor(){this.customStyleInterface=null,eE.invalidCallback=Gmt}ensure(){this.customStyleInterface||window.ShadyCSS.CustomStyleInterface&&(this.customStyleInterface=window.ShadyCSS.CustomStyleInterface,this.customStyleInterface.transformCallback=t=>{eE.transformCustomStyle(t)},this.customStyleInterface.validateCallback=()=>{requestAnimationFrame(()=>{this.customStyleInterface.enqueued&&this.flushCustomStyles()})})}prepareTemplate(t,r){if(this.ensure(),PG(t))return;QM[r]=t;let n=eE.transformTemplate(t,r);t._styleAst=n}flushCustomStyles(){if(this.ensure(),!this.customStyleInterface)return;let t=this.customStyleInterface.processStyles();if(!!this.customStyleInterface.enqueued){for(let r=0;r<t.length;r++){let n=t[r],i=this.customStyleInterface.getStyleForCustomStyle(n);i&&eE.transformCustomStyle(i)}this.customStyleInterface.enqueued=!1}}styleSubtree(t,r){if(this.ensure(),r&&JM(t,r),t.shadowRoot){this.styleElement(t);let n=t.shadowRoot.children||t.shadowRoot.childNodes;for(let i=0;i<n.length;i++)this.styleSubtree(n[i])}else{let n=t.children||t.childNodes;for(let i=0;i<n.length;i++)this.styleSubtree(n[i])}}styleElement(t){this.ensure();let{is:r}=Fmt(t),n=QM[r];if(!(n&&PG(n))&&n&&!kG(n)){Wmt(n)||(this.prepareTemplate(n,r),Ymt(n));let i=t.shadowRoot;if(i){let o=i.querySelector("style");o&&(o.__cssRules=n._styleAst,o.textContent=ZM(n._styleAst))}}}styleDocument(t){this.ensure(),this.styleSubtree(document.body,t)}};if(!window.ShadyCSS||!window.ShadyCSS.ScopingShim){let e=new DG,t=window.ShadyCSS&&window.ShadyCSS.CustomStyleInterface;window.ShadyCSS={prepareTemplate(r,n,i){e.flushCustomStyles(),e.prepareTemplate(r,n)},prepareTemplateStyles(r,n,i){window.ShadyCSS.prepareTemplate(r,n,i)},prepareTemplateDom(r,n){},styleSubtree(r,n){e.flushCustomStyles(),e.styleSubtree(r,n)},styleElement(r){e.flushCustomStyles(),e.styleElement(r)},styleDocument(r){e.flushCustomStyles(),e.styleDocument(r)},getComputedStyleValue(r,n){return jI(r,n)},flushCustomStyles(){e.flushCustomStyles()},nativeCss:Nx,nativeShadow:h_,cssBuild:Mm,disableRuntime:WI},t&&(window.ShadyCSS.CustomStyleInterface=t)}window.ShadyCSS.ApplyShim=eE;var sr=class{constructor(){this._asyncModule=null,this._callback=null,this._timer=null}setConfig(t,r){this._asyncModule=t,this._callback=r,this._timer=this._asyncModule.run(()=>{this._timer=null,rE.delete(this),this._callback()})}cancel(){this.isActive()&&(this._cancelAsync(),rE.delete(this))}_cancelAsync(){this.isActive()&&(this._asyncModule.cancel(this._timer),this._timer=null)}flush(){this.isActive()&&(this.cancel(),this._callback())}isActive(){return this._timer!=null}static debounce(t,r,n){return t instanceof sr?t._cancelAsync():t=new sr,t.setConfig(r,n),t}},rE=new Set,Jl=function(e){rE.add(e)},$mt=function(){let e=Boolean(rE.size);return rE.forEach(t=>{try{t.flush()}catch(r){setTimeout(()=>{throw r})}}),e};var BG=typeof document.head.style.touchAction=="string",e9="__polymerGestures",t9="__polymerGesturesHandled",zG="__polymerGesturesTouchAction",Kmt=25,Zmt=5,nxe=2,ixe=2500,rgt=["mousedown","mousemove","mouseup","click"],oxe=[0,1,4,2],axe=function(){try{return new MouseEvent("test",{buttons:1}).buttons===1}catch(e){return!1}}();function HG(e){return rgt.indexOf(e)>-1}var VG=!1;(function(){try{let e=Object.defineProperty({},"passive",{get(){VG=!0}});window.addEventListener("test",null,e),window.removeEventListener("test",null,e)}catch(e){}})();function ngt(e){if(!(HG(e)||e==="touchend")&&BG&&VG&&Ydt)return{passive:!0}}var igt=navigator.userAgent.match(/iP(?:[oa]d|hone)|Android/),FG=[],sxe={button:!0,input:!0,keygen:!0,meter:!0,output:!0,textarea:!0,progress:!0,select:!0},lxe={button:!0,command:!0,fieldset:!0,input:!0,keygen:!0,optgroup:!0,option:!0,select:!0,textarea:!0};function cxe(e){return sxe[e.localName]||!1}function uxe(e){let t=Array.prototype.slice.call(e.labels||[]);if(!t.length){t=[];let r=e.getRootNode();if(e.id){let n=r.querySelectorAll(`label[for = ${e.id}]`);for(let i=0;i<n.length;i++)t.push(n[i])}}return t}var Jmt=function(e){let t=e.sourceCapabilities;if(!(t&&!t.firesTouchEvents)&&(e[t9]={skip:!0},e.type==="click")){let r=!1,n=n9(e);for(let i=0;i<n.length;i++){if(n[i].nodeType===Node.ELEMENT_NODE){if(n[i].localName==="label")FG.push(n[i]);else if(cxe(n[i])){let o=uxe(n[i]);for(let a=0;a<o.length;a++)r=r||FG.indexOf(o[a])>-1}}if(n[i]===ia.mouse.target)return}if(r)return;e.preventDefault(),e.stopPropagation()}};function Qmt(e){let t=igt?["click"]:rgt;for(let r=0,n;r<t.length;r++)n=t[r],e?(FG.length=0,document.addEventListener(n,Jmt,!0)):document.removeEventListener(n,Jmt,!0)}function hxe(e){if(!fG)return;ia.mouse.mouseIgnoreJob||Qmt(!0);let t=function(){Qmt(),ia.mouse.target=null,ia.mouse.mouseIgnoreJob=null};ia.mouse.target=n9(e)[0],ia.mouse.mouseIgnoreJob=sr.debounce(ia.mouse.mouseIgnoreJob,mo.after(ixe),t)}function p_(e){let t=e.type;if(!HG(t))return!1;if(t==="mousemove"){let r=e.buttons===void 0?1:e.buttons;return e instanceof window.MouseEvent&&!axe&&(r=oxe[e.which]||0),Boolean(r&1)}else return(e.button===void 0?0:e.button)===0}function fxe(e){if(e.type==="click"){if(e.detail===0)return!0;let t=_p(e);if(!t.nodeType||t.nodeType!==Node.ELEMENT_NODE)return!0;let r=t.getBoundingClientRect(),n=e.pageX,i=e.pageY;return!(n>=r.left&&n<=r.right&&i>=r.top&&i<=r.bottom)}return!1}var ia={mouse:{target:null,mouseIgnoreJob:null},touch:{x:0,y:0,id:-1,scrollDecided:!1}};function pxe(e){let t="auto",r=n9(e);for(let n=0,i;n<r.length;n++)if(i=r[n],i[zG]){t=i[zG];break}return t}function ogt(e,t,r){e.movefn=t,e.upfn=r,document.addEventListener("mousemove",t),document.addEventListener("mouseup",r)}function Fx(e){document.removeEventListener("mousemove",e.movefn),document.removeEventListener("mouseup",e.upfn),e.movefn=null,e.upfn=null}fG&&document.addEventListener("touchend",hxe,VG?{passive:!0}:!1);var n9=window.ShadyDOM&&window.ShadyDOM.noPatch?window.ShadyDOM.composedPath:e=>e.composedPath&&e.composedPath()||[],iE={},f_=[];function dxe(e,t){let r=document.elementFromPoint(e,t),n=r;for(;n&&n.shadowRoot&&!window.ShadyDOM;){let i=n;if(n=n.shadowRoot.elementFromPoint(e,t),i===n)break;n&&(r=n)}return r}function _p(e){let t=n9(e);return t.length>0?t[0]:e.target}function agt(e){let t,r=e.type,i=e.currentTarget[e9];if(!i)return;let o=i[r];if(!!o){if(!e[t9]&&(e[t9]={},r.slice(0,5)==="touch")){e=e;let a=e.changedTouches[0];if(r==="touchstart"&&e.touches.length===1&&(ia.touch.id=a.identifier),ia.touch.id!==a.identifier)return;BG||(r==="touchstart"||r==="touchmove")&&mxe(e)}if(t=e[t9],!t.skip){for(let a=0,s;a<f_.length;a++)s=f_[a],o[s.name]&&!t[s.name]&&s.flow&&s.flow.start.indexOf(e.type)>-1&&s.reset&&s.reset();for(let a=0,s;a<f_.length;a++)s=f_[a],o[s.name]&&!t[s.name]&&(t[s.name]=!0,s[r](e))}}}function mxe(e){let t=e.changedTouches[0],r=e.type;if(r==="touchstart")ia.touch.x=t.clientX,ia.touch.y=t.clientY,ia.touch.scrollDecided=!1;else if(r==="touchmove"){if(ia.touch.scrollDecided)return;ia.touch.scrollDecided=!0;let n=pxe(e),i=!1,o=Math.abs(ia.touch.x-t.clientX),a=Math.abs(ia.touch.y-t.clientY);e.cancelable&&(n==="none"?i=!0:n==="pan-x"?i=a>o:n==="pan-y"&&(i=o>a)),i?e.preventDefault():r9("track")}}function Em(e,t,r){return iE[t]?(gxe(e,t,r),!0):!1}function sgt(e,t,r){return iE[t]?(_xe(e,t,r),!0):!1}function gxe(e,t,r){let n=iE[t],i=n.deps,o=n.name,a=e[e9];a||(e[e9]=a={});for(let s=0,l,c;s<i.length;s++)l=i[s],!(igt&&HG(l)&&l!=="click")&&(c=a[l],c||(a[l]=c={_count:0}),c._count===0&&e.addEventListener(l,agt,ngt(l)),c[o]=(c[o]||0)+1,c._count=(c._count||0)+1);e.addEventListener(t,r),n.touchAction&&d_(e,n.touchAction)}function _xe(e,t,r){let n=iE[t],i=n.deps,o=n.name,a=e[e9];if(a)for(let s=0,l,c;s<i.length;s++)l=i[s],c=a[l],c&&c[o]&&(c[o]=(c[o]||1)-1,c._count=(c._count||1)-1,c._count===0&&e.removeEventListener(l,agt,ngt(l)));e.removeEventListener(t,r)}function UG(e){f_.push(e);for(let t=0;t<e.emits.length;t++)iE[e.emits[t]]=e}function yxe(e){for(let t=0,r;t<f_.length;t++){r=f_[t];for(let n=0,i;n<r.emits.length;n++)if(i=r.emits[n],i===e)return r}return null}function d_(e,t){BG&&e instanceof HTMLElement&&li.run(()=>{e.style.touchAction=t}),e[zG]=t}function qG(e,t,r){let n=new Event(t,{bubbles:!0,cancelable:!0,composed:!0});if(n.detail=r,ue(e).dispatchEvent(n),n.defaultPrevented){let i=r.preventer||r.sourceEvent;i&&i.preventDefault&&i.preventDefault()}}function r9(e){let t=yxe(e);t.info&&(t.info.prevent=!0)}UG({name:"downup",deps:["mousedown","touchstart","touchend"],flow:{start:["mousedown","touchstart"],end:["mouseup","touchend"]},emits:["down","up"],info:{movefn:null,upfn:null},reset:function(){Fx(this.info)},mousedown:function(e){if(!p_(e))return;let t=_p(e),r=this,n=function(a){p_(a)||(nE("up",t,a),Fx(r.info))},i=function(a){p_(a)&&nE("up",t,a),Fx(r.info)};ogt(this.info,n,i),nE("down",t,e)},touchstart:function(e){nE("down",_p(e),e.changedTouches[0],e)},touchend:function(e){nE("up",_p(e),e.changedTouches[0],e)}});function nE(e,t,r,n){!t||qG(t,e,{x:r.clientX,y:r.clientY,sourceEvent:r,preventer:n,prevent:function(i){return r9(i)}})}UG({name:"track",touchAction:"none",deps:["mousedown","touchstart","touchmove","touchend"],flow:{start:["mousedown","touchstart"],end:["mouseup","touchend"]},emits:["track"],info:{x:0,y:0,state:"start",started:!1,moves:[],addMove:function(e){this.moves.length>nxe&&this.moves.shift(),this.moves.push(e)},movefn:null,upfn:null,prevent:!1},reset:function(){this.info.state="start",this.info.started=!1,this.info.moves=[],this.info.x=0,this.info.y=0,this.info.prevent=!1,Fx(this.info)},mousedown:function(e){if(!p_(e))return;let t=_p(e),r=this,n=function(a){let s=a.clientX,l=a.clientY;tgt(r.info,s,l)&&(r.info.state=r.info.started?a.type==="mouseup"?"end":"track":"start",r.info.state==="start"&&r9("tap"),r.info.addMove({x:s,y:l}),p_(a)||(r.info.state="end",Fx(r.info)),t&&OG(r.info,t,a),r.info.started=!0)},i=function(a){r.info.started&&n(a),Fx(r.info)};ogt(this.info,n,i),this.info.x=e.clientX,this.info.y=e.clientY},touchstart:function(e){let t=e.changedTouches[0];this.info.x=t.clientX,this.info.y=t.clientY},touchmove:function(e){let t=_p(e),r=e.changedTouches[0],n=r.clientX,i=r.clientY;tgt(this.info,n,i)&&(this.info.state==="start"&&r9("tap"),this.info.addMove({x:n,y:i}),OG(this.info,t,r),this.info.state="track",this.info.started=!0)},touchend:function(e){let t=_p(e),r=e.changedTouches[0];this.info.started&&(this.info.state="end",this.info.addMove({x:r.clientX,y:r.clientY}),OG(this.info,t,r))}});function tgt(e,t,r){if(e.prevent)return!1;if(e.started)return!0;let n=Math.abs(e.x-t),i=Math.abs(e.y-r);return n>=Zmt||i>=Zmt}function OG(e,t,r){if(!t)return;let n=e.moves[e.moves.length-2],i=e.moves[e.moves.length-1],o=i.x-e.x,a=i.y-e.y,s,l=0;n&&(s=i.x-n.x,l=i.y-n.y),qG(t,"track",{state:e.state,x:r.clientX,y:r.clientY,dx:o,dy:a,ddx:s,ddy:l,sourceEvent:r,hover:function(){return dxe(r.clientX,r.clientY)}})}UG({name:"tap",deps:["mousedown","click","touchstart","touchend"],flow:{start:["mousedown","touchstart"],end:["click","touchend"]},emits:["tap"],info:{x:NaN,y:NaN,prevent:!1},reset:function(){this.info.x=NaN,this.info.y=NaN,this.info.prevent=!1},mousedown:function(e){p_(e)&&(this.info.x=e.clientX,this.info.y=e.clientY)},click:function(e){p_(e)&&egt(this.info,e)},touchstart:function(e){let t=e.changedTouches[0];this.info.x=t.clientX,this.info.y=t.clientY},touchend:function(e){egt(this.info,e.changedTouches[0],e)}});function egt(e,t,r){let n=Math.abs(t.clientX-e.x),i=Math.abs(t.clientY-e.y),o=_p(r||t);!o||lxe[o.localName]&&o.hasAttribute("disabled")||(isNaN(n)||isNaN(i)||n<=Kmt&&i<=Kmt||fxe(t))&&(e.prevent||qG(o,"tap",{x:t.clientX,y:t.clientY,sourceEvent:t,preventer:r}))}var lgt=_p;var yh=Rn(e=>{class t extends e{_addEventListenerToNode(n,i,o){Em(n,i,o)||super._addEventListenerToNode(n,i,o)}_removeEventListenerFromNode(n,i,o){sgt(n,i,o)||super._removeEventListenerFromNode(n,i,o)}}return t});var vxe=/:host\(:dir\((ltr|rtl)\)\)/g,xxe=':host([dir="$1"])',bxe=/([\s\w-#\.\[\]\*]*):dir\((ltr|rtl)\)/g,wxe=':host([dir="$2"]) $1',Sxe=/:dir\((?:ltr|rtl)\)/,ugt=Boolean(window.ShadyDOM&&window.ShadyDOM.inUse),oE=[],aE=null,GG="";function hgt(){GG=document.documentElement.getAttribute("dir")}function fgt(e){e.__autoDirOptOut||e.setAttribute("dir",GG)}function pgt(){hgt(),GG=document.documentElement.getAttribute("dir");for(let e=0;e<oE.length;e++)fgt(oE[e])}function Mxe(){aE&&aE.takeRecords().length&&pgt()}var dgt=Rn(e=>{ugt||aE||(hgt(),aE=new MutationObserver(pgt),aE.observe(document.documentElement,{attributes:!0,attributeFilter:["dir"]}));let t=HI(e);class r extends t{static _processStyleText(i,o){return i=t._processStyleText.call(this,i,o),!ugt&&Sxe.test(i)&&(i=this._replaceDirInCssText(i),this.__activateDir=!0),i}static _replaceDirInCssText(i){let o=i;return o=o.replace(vxe,xxe),o=o.replace(bxe,wxe),o}constructor(){super(),this.__autoDirOptOut=!1}ready(){super.ready(),this.__autoDirOptOut=this.hasAttribute("dir")}connectedCallback(){t.prototype.connectedCallback&&super.connectedCallback(),this.constructor.__activateDir&&(Mxe(),oE.push(this),fgt(this))}disconnectedCallback(){if(t.prototype.disconnectedCallback&&super.disconnectedCallback(),this.constructor.__activateDir){let i=oE.indexOf(this);i>-1&&oE.splice(i,1)}}}return r.__activateDir=!1,r});var i9=!1,mgt=[],ggt=[];function _gt(){i9=!0,requestAnimationFrame(function(){i9=!1,Exe(mgt),setTimeout(function(){Txe(ggt)})})}function Exe(e){for(;e.length;)ygt(e.shift())}function Txe(e){for(let t=0,r=e.length;t<r;t++)ygt(e.shift())}function ygt(e){let t=e[0],r=e[1],n=e[2];try{r.apply(t,n)}catch(i){setTimeout(()=>{throw i})}}function vgt(e,t,r){i9||_gt(),mgt.push([e,t,r])}function Tm(e,t,r){i9||_gt(),ggt.push([e,t,r])}function xgt(){document.body.removeAttribute("unresolved")}document.readyState==="interactive"||document.readyState==="complete"?xgt():window.addEventListener("DOMContentLoaded",xgt);function sE(e,t,r){return{index:e,removed:t,addedCount:r}}var bgt=0,wgt=1,WG=2,YG=3;function Cxe(e,t,r,n,i,o){let a=o-i+1,s=r-t+1,l=new Array(a);for(let c=0;c<a;c++)l[c]=new Array(s),l[c][0]=c;for(let c=0;c<s;c++)l[0][c]=c;for(let c=1;c<a;c++)for(let u=1;u<s;u++)if(jG(e[t+u-1],n[i+c-1]))l[c][u]=l[c-1][u-1];else{let h=l[c-1][u]+1,f=l[c][u-1]+1;l[c][u]=h<f?h:f}return l}function Axe(e){let t=e.length-1,r=e[0].length-1,n=e[t][r],i=[];for(;t>0||r>0;){if(t==0){i.push(WG),r--;continue}if(r==0){i.push(YG),t--;continue}let o=e[t-1][r-1],a=e[t-1][r],s=e[t][r-1],l;a<s?l=a<o?a:o:l=s<o?s:o,l==o?(o==n?i.push(bgt):(i.push(wgt),n=o),t--,r--):l==a?(i.push(YG),t--,n=a):(i.push(WG),r--,n=s)}return i.reverse(),i}function Pxe(e,t,r,n,i,o){let a=0,s=0,l,c=Math.min(r-t,o-i);if(t==0&&i==0&&(a=Ixe(e,n,c)),r==e.length&&o==n.length&&(s=Lxe(e,n,c-a)),t+=a,i+=a,r-=s,o-=s,r-t==0&&o-i==0)return[];if(t==r){for(l=sE(t,[],0);i<o;)l.removed.push(n[i++]);return[l]}else if(i==o)return[sE(t,[],r-t)];let u=Axe(Cxe(e,t,r,n,i,o));l=void 0;let h=[],f=t,p=i;for(let d=0;d<u.length;d++)switch(u[d]){case bgt:l&&(h.push(l),l=void 0),f++,p++;break;case wgt:l||(l=sE(f,[],0)),l.addedCount++,f++,l.removed.push(n[p]),p++;break;case WG:l||(l=sE(f,[],0)),l.addedCount++,f++;break;case YG:l||(l=sE(f,[],0)),l.removed.push(n[p]),p++;break}return l&&h.push(l),h}function Ixe(e,t,r){for(let n=0;n<r;n++)if(!jG(e[n],t[n]))return n;return r}function Lxe(e,t,r){let n=e.length,i=t.length,o=0;for(;o<r&&jG(e[--n],t[--i]);)o++;return o}function o9(e,t){return Pxe(e,0,e.length,t,0,t.length)}function jG(e,t){return e===t}function Bx(e){return e.localName==="slot"}var vh=class{static getFlattenedNodes(e){let t=ue(e);return Bx(e)?(e=e,t.assignedNodes({flatten:!0})):Array.from(t.childNodes).map(r=>Bx(r)?(r=r,ue(r).assignedNodes({flatten:!0})):[r]).reduce((r,n)=>r.concat(n),[])}constructor(e,t){this._shadyChildrenObserver=null,this._nativeChildrenObserver=null,this._connected=!1,this._target=e,this.callback=t,this._effectiveNodes=[],this._observer=null,this._scheduled=!1,this._boundSchedule=()=>{this._schedule()},this.connect(),this._schedule()}connect(){Bx(this._target)?this._listenSlots([this._target]):ue(this._target).children&&(this._listenSlots(ue(this._target).children),window.ShadyDOM?this._shadyChildrenObserver=window.ShadyDOM.observeChildren(this._target,e=>{this._processMutations(e)}):(this._nativeChildrenObserver=new MutationObserver(e=>{this._processMutations(e)}),this._nativeChildrenObserver.observe(this._target,{childList:!0}))),this._connected=!0}disconnect(){Bx(this._target)?this._unlistenSlots([this._target]):ue(this._target).children&&(this._unlistenSlots(ue(this._target).children),window.ShadyDOM&&this._shadyChildrenObserver?(window.ShadyDOM.unobserveChildren(this._shadyChildrenObserver),this._shadyChildrenObserver=null):this._nativeChildrenObserver&&(this._nativeChildrenObserver.disconnect(),this._nativeChildrenObserver=null)),this._connected=!1}_schedule(){this._scheduled||(this._scheduled=!0,li.run(()=>this.flush()))}_processMutations(e){this._processSlotMutations(e),this.flush()}_processSlotMutations(e){if(e)for(let t=0;t<e.length;t++){let r=e[t];r.addedNodes&&this._listenSlots(r.addedNodes),r.removedNodes&&this._unlistenSlots(r.removedNodes)}}flush(){if(!this._connected)return!1;window.ShadyDOM&&ShadyDOM.flush(),this._nativeChildrenObserver?this._processSlotMutations(this._nativeChildrenObserver.takeRecords()):this._shadyChildrenObserver&&this._processSlotMutations(this._shadyChildrenObserver.takeRecords()),this._scheduled=!1;let e={target:this._target,addedNodes:[],removedNodes:[]},t=this.constructor.getFlattenedNodes(this._target),r=o9(t,this._effectiveNodes);for(let i=0,o;i<r.length&&(o=r[i]);i++)for(let a=0,s;a<o.removed.length&&(s=o.removed[a]);a++)e.removedNodes.push(s);for(let i=0,o;i<r.length&&(o=r[i]);i++)for(let a=o.index;a<o.index+o.addedCount;a++)e.addedNodes.push(t[a]);this._effectiveNodes=t;let n=!1;return(e.addedNodes.length||e.removedNodes.length)&&(n=!0,this.callback.call(this._target,e)),n}_listenSlots(e){for(let t=0;t<e.length;t++){let r=e[t];Bx(r)&&r.addEventListener("slotchange",this._boundSchedule)}}_unlistenSlots(e){for(let t=0;t<e.length;t++){let r=e[t];Bx(r)&&r.removeEventListener("slotchange",this._boundSchedule)}}};var ci=function(){let e,t;do e=window.ShadyDOM&&ShadyDOM.flush(),window.ShadyCSS&&window.ShadyCSS.ScopingShim&&window.ShadyCSS.ScopingShim.flush(),t=$mt();while(e||t)};var Hx=Element.prototype,kxe=Hx.matches||Hx.matchesSelector||Hx.mozMatchesSelector||Hx.msMatchesSelector||Hx.oMatchesSelector||Hx.webkitMatchesSelector,$G=function(e,t){return kxe.call(e,t)},Kr=class{constructor(t){window.ShadyDOM&&window.ShadyDOM.inUse&&window.ShadyDOM.patch(t),this.node=t}observeNodes(t){return new vh(this.node,t)}unobserveNodes(t){t.disconnect()}notifyObserver(){}deepContains(t){if(ue(this.node).contains(t))return!0;let r=t,n=t.ownerDocument;for(;r&&r!==n&&r!==this.node;)r=ue(r).parentNode||ue(r).host;return r===this.node}getOwnerRoot(){return ue(this.node).getRootNode()}getDistributedNodes(){return this.node.localName==="slot"?ue(this.node).assignedNodes({flatten:!0}):[]}getDestinationInsertionPoints(){let t=[],r=ue(this.node).assignedSlot;for(;r;)t.push(r),r=ue(r).assignedSlot;return t}importNode(t,r){let n=this.node instanceof Document?this.node:this.node.ownerDocument;return ue(n).importNode(t,r)}getEffectiveChildNodes(){return vh.getFlattenedNodes(this.node)}queryDistributedElements(t){let r=this.getEffectiveChildNodes(),n=[];for(let i=0,o=r.length,a;i<o&&(a=r[i]);i++)a.nodeType===Node.ELEMENT_NODE&&$G(a,t)&&n.push(a);return n}get activeElement(){let t=this.node;return t._activeElement!==void 0?t._activeElement:t.activeElement}};function Rxe(e,t){for(let r=0;r<t.length;r++){let n=t[r];e[n]=function(){return this.node[n].apply(this.node,arguments)}}}function Sgt(e,t){for(let r=0;r<t.length;r++){let n=t[r];Object.defineProperty(e,n,{get:function(){return this.node[n]},configurable:!0})}}function Nxe(e,t){for(let r=0;r<t.length;r++){let n=t[r];Object.defineProperty(e,n,{get:function(){return this.node[n]},set:function(i){this.node[n]=i},configurable:!0})}}var lE=class{constructor(t){this.event=t}get rootTarget(){return this.path[0]}get localTarget(){return this.event.target}get path(){return this.event.composedPath()}};Kr.prototype.cloneNode;Kr.prototype.appendChild;Kr.prototype.insertBefore;Kr.prototype.removeChild;Kr.prototype.replaceChild;Kr.prototype.setAttribute;Kr.prototype.removeAttribute;Kr.prototype.querySelector;Kr.prototype.querySelectorAll;Kr.prototype.parentNode;Kr.prototype.firstChild;Kr.prototype.lastChild;Kr.prototype.nextSibling;Kr.prototype.previousSibling;Kr.prototype.firstElementChild;Kr.prototype.lastElementChild;Kr.prototype.nextElementSibling;Kr.prototype.previousElementSibling;Kr.prototype.childNodes;Kr.prototype.children;Kr.prototype.classList;Kr.prototype.textContent;Kr.prototype.innerHTML;var XG=Kr;if(window.ShadyDOM&&window.ShadyDOM.inUse&&window.ShadyDOM.noPatch&&window.ShadyDOM.Wrapper){class e extends window.ShadyDOM.Wrapper{}Object.getOwnPropertyNames(Kr.prototype).forEach(t=>{t!="activeElement"&&(e.prototype[t]=Kr.prototype[t])}),Sgt(e.prototype,["classList"]),XG=e,Object.defineProperties(lE.prototype,{localTarget:{get(){let t=this.event.currentTarget,r=t&&zt(t).getOwnerRoot(),n=this.path;for(let i=0;i<n.length;i++){let o=n[i];if(zt(o).getOwnerRoot()===r)return o}},configurable:!0},path:{get(){return window.ShadyDOM.composedPath(this.event)},configurable:!0}})}else Rxe(Kr.prototype,["cloneNode","appendChild","insertBefore","removeChild","replaceChild","setAttribute","removeAttribute","querySelector","querySelectorAll"]),Sgt(Kr.prototype,["parentNode","firstChild","lastChild","nextSibling","previousSibling","firstElementChild","lastElementChild","nextElementSibling","previousElementSibling","childNodes","children","classList"]),Nxe(Kr.prototype,["textContent","innerHTML","className"]);var zt=function(e){if(e=e||document,e instanceof XG||e instanceof lE)return e;let t=e.__domApi;return t||(e instanceof Event?t=new lE(e):t=new XG(e),e.__domApi=t),t};var KG=window.ShadyDOM,Mgt=window.ShadyCSS;function Egt(e,t){return ue(e).getRootNode()===t}function Tgt(e,t=!1){if(!KG||!Mgt||!KG.handlesDynamicScoping)return null;let r=Mgt.ScopingShim;if(!r)return null;let n=r.scopeForNode(e),i=ue(e).getRootNode(),o=a=>{if(!Egt(a,i))return;let s=Array.from(KG.nativeMethods.querySelectorAll.call(a,"*"));s.push(a);for(let l=0;l<s.length;l++){let c=s[l];if(!Egt(c,i))continue;let u=r.currentScopeForNode(c);u!==n&&(u!==""&&r.unscopeNode(c,u),r.scopeNode(c,n))}};if(o(e),t){let a=new MutationObserver(s=>{for(let l=0;l<s.length;l++){let c=s[l];for(let u=0;u<c.addedNodes.length;u++){let h=c.addedNodes[u];h.nodeType===Node.ELEMENT_NODE&&o(h)}}});return a.observe(e,{childList:!0,subtree:!0}),a}else return null}var ZG="disable-upgrade",JG=e=>{for(;e;){let t=Object.getOwnPropertyDescriptor(e,"observedAttributes");if(t)return t.get;e=Object.getPrototypeOf(e.prototype).constructor}return()=>[]},E1r=Rn(e=>{let t=Sm(e),r=JG(t);class n extends t{constructor(){super(),this.__isUpgradeDisabled}static get observedAttributes(){return r.call(this).concat(ZG)}_initializeProperties(){this.hasAttribute(ZG)?this.__isUpgradeDisabled=!0:super._initializeProperties()}_enableProperties(){this.__isUpgradeDisabled||super._enableProperties()}_canApplyPropertyDefault(o){return super._canApplyPropertyDefault(o)&&!(this.__isUpgradeDisabled&&this._isPropertyPending(o))}attributeChangedCallback(o,a,s,l){o==ZG?this.__isUpgradeDisabled&&s==null&&(super._initializeProperties(),this.__isUpgradeDisabled=!1,ue(this).isConnected&&super.connectedCallback()):super.attributeChangedCallback(o,a,s,l)}connectedCallback(){this.__isUpgradeDisabled||super.connectedCallback()}disconnectedCallback(){this.__isUpgradeDisabled||super.disconnectedCallback()}}return n});var a9="disable-upgrade",Dxe=window.ShadyCSS,Gt=Rn(e=>{let t=yh(Sm(e)),r=UI?t:dgt(t),n=JG(r),i={x:"pan-x",y:"pan-y",none:"none",all:"auto"};class o extends r{constructor(){super(),this.isAttached,this.__boundListeners,this._debouncers,this.__isUpgradeDisabled,this.__needsAttributesAtConnected,this._legacyForceObservedAttributes}static get importMeta(){return this.prototype.importMeta}created(){}__attributeReaction(s,l,c){(this.__dataAttributes&&this.__dataAttributes[s]||s===a9)&&this.attributeChangedCallback(s,l,c,null)}setAttribute(s,l){if(qM&&!this._legacyForceObservedAttributes){let c=this.getAttribute(s);super.setAttribute(s,l),this.__attributeReaction(s,c,String(l))}else super.setAttribute(s,l)}removeAttribute(s){if(qM&&!this._legacyForceObservedAttributes){let l=this.getAttribute(s);super.removeAttribute(s),this.__attributeReaction(s,l,null)}else super.removeAttribute(s)}static get observedAttributes(){return qM&&!this.prototype._legacyForceObservedAttributes?(this.hasOwnProperty(JSCompiler_renameProperty("__observedAttributes",this))||(this.__observedAttributes=[],VI(this.prototype)),this.__observedAttributes):n.call(this).concat(a9)}_enableProperties(){this.__isUpgradeDisabled||super._enableProperties()}_canApplyPropertyDefault(s){return super._canApplyPropertyDefault(s)&&!(this.__isUpgradeDisabled&&this._isPropertyPending(s))}connectedCallback(){this.__needsAttributesAtConnected&&this._takeAttributes(),this.__isUpgradeDisabled||(super.connectedCallback(),this.isAttached=!0,this.attached())}attached(){}disconnectedCallback(){this.__isUpgradeDisabled||(super.disconnectedCallback(),this.isAttached=!1,this.detached())}detached(){}attributeChangedCallback(s,l,c,u){l!==c&&(s==a9?this.__isUpgradeDisabled&&c==null&&(this._initializeProperties(),this.__isUpgradeDisabled=!1,ue(this).isConnected&&this.connectedCallback()):(super.attributeChangedCallback(s,l,c,u),this.attributeChanged(s,l,c)))}attributeChanged(s,l,c){}_initializeProperties(){if(pp&&this.hasAttribute(a9))this.__isUpgradeDisabled=!0;else{let s=Object.getPrototypeOf(this);s.hasOwnProperty(JSCompiler_renameProperty("__hasRegisterFinished",s))||(this._registered(),s.__hasRegisterFinished=!0),super._initializeProperties(),this.root=this,this.created(),qM&&!this._legacyForceObservedAttributes&&(this.hasAttributes()?this._takeAttributes():this.parentNode||(this.__needsAttributesAtConnected=!0)),this._applyListeners()}}_takeAttributes(){let s=this.attributes;for(let l=0,c=s.length;l<c;l++){let u=s[l];this.__attributeReaction(u.name,null,u.value)}}_registered(){}ready(){this._ensureAttributes(),super.ready()}_ensureAttributes(){}_applyListeners(){}serialize(s){return this._serializeValue(s)}deserialize(s,l){return this._deserializeValue(s,l)}reflectPropertyToAttribute(s,l,c){this._propertyToAttribute(s,l,c)}serializeValueToAttribute(s,l,c){this._valueToNodeAttribute(c||this,s,l)}extend(s,l){if(!(s&&l))return s||l;let c=Object.getOwnPropertyNames(l);for(let u=0,h;u<c.length&&(h=c[u]);u++){let f=Object.getOwnPropertyDescriptor(l,h);f&&Object.defineProperty(s,h,f)}return s}mixin(s,l){for(let c in l)s[c]=l[c];return s}chainObject(s,l){return s&&l&&s!==l&&(s.__proto__=l),s}instanceTemplate(s){let l=this.constructor._contentForTemplate(s);return document.importNode(l,!0)}fire(s,l,c){c=c||{},l=l==null?{}:l;let u=new Event(s,{bubbles:c.bubbles===void 0?!0:c.bubbles,cancelable:Boolean(c.cancelable),composed:c.composed===void 0?!0:c.composed});u.detail=l;let h=c.node||this;return ue(h).dispatchEvent(u),u}listen(s,l,c){s=s||this;let u=this.__boundListeners||(this.__boundListeners=new WeakMap),h=u.get(s);h||(h={},u.set(s,h));let f=l+c;h[f]||(h[f]=this._addMethodEventListenerToNode(s,l,c,this))}unlisten(s,l,c){s=s||this;let u=this.__boundListeners&&this.__boundListeners.get(s),h=l+c,f=u&&u[h];f&&(this._removeEventListenerFromNode(s,l,f),u[h]=null)}setScrollDirection(s,l){d_(l||this,i[s]||"auto")}$$(s){return this.root.querySelector(s)}get domHost(){let s=ue(this).getRootNode();return s instanceof DocumentFragment?s.host:s}distributeContent(){let l=zt(this);window.ShadyDOM&&l.shadowRoot&&ShadyDOM.flush()}getEffectiveChildNodes(){return zt(this).getEffectiveChildNodes()}queryDistributedElements(s){return zt(this).queryDistributedElements(s)}getEffectiveChildren(){return this.getEffectiveChildNodes().filter(function(l){return l.nodeType===Node.ELEMENT_NODE})}getEffectiveTextContent(){let s=this.getEffectiveChildNodes(),l=[];for(let c=0,u;u=s[c];c++)u.nodeType!==Node.COMMENT_NODE&&l.push(u.textContent);return l.join("")}queryEffectiveChildren(s){let l=this.queryDistributedElements(s);return l&&l[0]}queryAllEffectiveChildren(s){return this.queryDistributedElements(s)}getContentChildNodes(s){let l=this.root.querySelector(s||"slot");return l?zt(l).getDistributedNodes():[]}getContentChildren(s){return this.getContentChildNodes(s).filter(function(c){return c.nodeType===Node.ELEMENT_NODE})}isLightDescendant(s){let l=this;return l!==s&&ue(l).contains(s)&&ue(l).getRootNode()===ue(s).getRootNode()}isLocalDescendant(s){return this.root===ue(s).getRootNode()}scopeSubtree(s,l=!1){return Tgt(s,l)}getComputedStyleValue(s){return Dxe.getComputedStyleValue(this,s)}debounce(s,l,c){return this._debouncers=this._debouncers||{},this._debouncers[s]=sr.debounce(this._debouncers[s],c>0?mo.after(c):li,l.bind(this))}isDebouncerActive(s){this._debouncers=this._debouncers||{};let l=this._debouncers[s];return!!(l&&l.isActive())}flushDebouncer(s){this._debouncers=this._debouncers||{};let l=this._debouncers[s];l&&l.flush()}cancelDebouncer(s){this._debouncers=this._debouncers||{};let l=this._debouncers[s];l&&l.cancel()}async(s,l){return l>0?mo.run(s.bind(this),l):~li.run(s.bind(this))}cancelAsync(s){s<0?li.cancel(~s):mo.cancel(s)}create(s,l){let c=document.createElement(s);if(l)if(c.setProperties)c.setProperties(l);else for(let u in l)c[u]=l[u];return c}elementMatches(s,l){return $G(l||this,s)}toggleAttribute(s,l){let c=this;return arguments.length===3&&(c=arguments[2]),arguments.length==1&&(l=!c.hasAttribute(s)),l?(ue(c).setAttribute(s,""),!0):(ue(c).removeAttribute(s),!1)}toggleClass(s,l,c){c=c||this,arguments.length==1&&(l=!c.classList.contains(s)),l?c.classList.add(s):c.classList.remove(s)}transform(s,l){l=l||this,l.style.webkitTransform=s,l.style.transform=s}translate3d(s,l,c,u){u=u||this,this.transform("translate3d("+s+","+l+","+c+")",u)}arrayDelete(s,l){let c;if(Array.isArray(s)){if(c=s.indexOf(l),c>=0)return s.splice(c,1)}else if(c=No(this,s).indexOf(l),c>=0)return this.splice(s,c,1);return null}_logger(s,l){switch(Array.isArray(l)&&l.length===1&&Array.isArray(l[0])&&(l=l[0]),s){case"log":case"warn":case"error":console[s](...l)}}_log(...s){this._logger("log",s)}_warn(...s){this._logger("warn",s)}_error(...s){this._logger("error",s)}_logf(s,...l){return["[%s::%s]",this.is,s,...l]}}return o.prototype.is="",o});var Cm=Ee(Oe(),1);function xh(e,t){let r=0,n=0;for(;;){if(r===e.length)return n===t.length?0:-1;if(n===t.length)return 1;if(m_(e[r])&&m_(t[n])){let i=r,o=n;r=Cgt(e,r+1),n=Cgt(t,n+1);let a=parseFloat(e.slice(i,r)),s=parseFloat(t.slice(o,n));if(a<s)return-1;if(a>s)return 1;continue}if(QG(e[r])){if(!QG(t[n]))return-1}else{if(QG(t[n]))return 1;if(e[r]<t[n])return-1;if(e[r]>t[n])return 1}r++,n++}}function Cgt(e,t){let r;(function(i){i[i.NATURAL=0]="NATURAL",i[i.REAL=1]="REAL",i[i.EXPONENT_SIGN=2]="EXPONENT_SIGN",i[i.EXPONENT=3]="EXPONENT"})(r||(r={}));let n=r.NATURAL;for(;t<e.length;t++)if(n===r.NATURAL){if(e[t]===".")n=r.REAL;else if(e[t]==="e"||e[t]==="E")n=r.EXPONENT_SIGN;else if(!m_(e[t]))break}else if(n===r.REAL){if(e[t]==="e"||e[t]==="E")n=r.EXPONENT_SIGN;else if(!m_(e[t]))break}else if(n===r.EXPONENT_SIGN)if(m_(e[t])||e[t]==="+"||e[t]==="-")n=r.EXPONENT;else break;else if(n===r.EXPONENT&&!m_(e[t]))break;return t}function m_(e){return"0"<=e&&e<="9"}function QG(e){return e==="/"||e==="_"||m_(e)}var Oxe=[];function zxe(e){return Cm.keys(e).sort(xh)}function $i(e){return Cm.union.apply(null,Cm.values(e)).sort(xh)}function Fxe(e,t){let r=[];return t.forEach(n=>r=r.concat(e[n])),Cm.uniq(r).sort(xh)}var Pgt="X-TensorBoard-Feature-Flags",Igt="tensorBoardFeatureFlags";var tW={};Ks(tW,{getFeatureFlags:()=>Hxe,getFeatureFlagsToSendToServer:()=>cE,initializeFeatureFlags:()=>Lgt,setFeatureFlags:()=>Bxe});var s9,l9;Lgt();function Lgt(){s9=null,l9=null}function Bxe(e,t){s9=e,l9=t}function Hxe(){if(s9===null)throw Error("FeatureFlags have not yet been determined by TensorBoard.");return s9}function cE(){if(l9===null)throw Error("FeatureFlags have not yet been determined by TensorBoard.");return l9}var c9=class extends Error{constructor(){super(...arguments),this.name="RequestCancellationError"}},Vx=class extends Error{constructor(t){super(t),this.name="InvalidRequestOptionsError",Object.setPrototypeOf(this,Vx.prototype)}},uE=class extends Error{constructor(t,r){super(),this.message=`RequestNetworkError: ${t.status} at ${r}`,this.name="RequestNetworkError",this.req=t,this.url=r}},Am;(function(e){e.GET="GET",e.POST="POST"})(Am||(Am={}));var Ux=class{validate(){if(this.methodType===Am.GET&&this.body)throw new Vx("body must be missing for a GET request.")}},Ae=class{constructor(t=1e3,r=3){this._queue=[],this._nActiveRequests=0,this._nSimultaneousRequests=t,this._maxRetries=r}request(t,r){let n=Uxe(r);return this.requestWithOptions(t,n)}requestWithOptions(t,r){return r.validate(),new Promise((i,o)=>{let a={resolve:i,reject:o};this._queue.push(a),this.launchRequests()}).then(()=>this.promiseWithRetries(t,this._maxRetries,r)).then(i=>(this._nActiveRequests--,this.launchRequests(),i),i=>(i.name==="RequestNetworkError"&&(this._nActiveRequests--,this.launchRequests()),Promise.reject(i)))}fetch(t,r){return new Promise((n,i)=>{let o={resolve:n,reject:i};this._queue.push(o),this.launchRequests()}).then(()=>{let n=1;return new Promise(i=>{let o=()=>{fetch(t,r).then(a=>{if(!a.ok&&this._maxRetries>n){n++,o();return}i(a),this._nActiveRequests--,this.launchRequests()})};o()})})}clearQueue(){var t;for(;this._queue.length>0;)(t=this._queue.pop())==null||t.reject(new c9("Request cancelled by clearQueue"))}activeRequests(){return this._nActiveRequests}outstandingRequests(){return this._nActiveRequests+this._queue.length}launchRequests(){for(;this._nActiveRequests<this._nSimultaneousRequests&&this._queue.length>0;)this._nActiveRequests++,this._queue.pop().resolve(void 0)}promiseWithRetries(t,r,n){var i=a=>a,o=a=>r>0?this.promiseWithRetries(t,r-1,n):Promise.reject(a);return this._promiseFromUrl(t,n).then(i,o)}_promiseFromUrl(t,r){return new Promise((n,i)=>{let o=Vxe(r.methodType,t,r.withCredentials,r.contentType);o.setRequestHeader(Pgt,JSON.stringify(cE())),o.onload=function(){o.status===200?n(JSON.parse(o.responseText)):i(new uE(o,t))},o.onerror=function(){i(new uE(o,t))},r.body?o.send(r.body):o.send()})}};function Vxe(e,t,r,n){let i=new XMLHttpRequest;return i.open(e,t),r&&(i.withCredentials=r),n&&i.setRequestHeader("Content-Type",n),i}function Uxe(e){let t=new Ux;return e?(t.methodType=Am.POST,t.body=qxe(e),t):(t.methodType=Am.GET,t)}function qxe(e){let t=new FormData;for(let[r,n]of Object.entries(e)){let i=Array.isArray(n)?n:[n];for(let o of i)t.append(r,o)}return t}var kgt="experimentalPlugin",Gxe=new URLSearchParams(window.location.search),Wxe=Rgt();function Rgt(){return{environment:()=>qx("/environment"),experiments:()=>qx("/experiments"),pluginRoute:(e,t,r)=>qx(`/plugin/${e}${t}`,r),pluginRouteForSrc:(e,t,r=new URLSearchParams)=>{let n=cE();return Object.keys(n).length>0&&r.append(Igt,JSON.stringify(n)),qx(`/plugin/${e}${t}`,r)},pluginsListing:()=>qx("/plugins_listing",Ngt({[kgt]:Gxe.getAll(kgt)})),runs:()=>qx("/runs")}}function _e(){return Wxe}function qx(e,t=new URLSearchParams){let r="data"+e;return String(t)&&(r+=(e.includes("?")?"&":"?")+String(t)),r}function Ngt(e={}){let t=Object.keys(e).sort().filter(n=>e[n]),r=new URLSearchParams;return t.forEach(n=>{let i=e[n];(Array.isArray(i)?i:[i]).forEach(a=>r.append(n,a))}),r}var u9=Ee(Oe(),1);var Na;(function(e){e[e.SEARCH_RESULTS=0]="SEARCH_RESULTS",e[e.PREFIX_GROUP=1]="PREFIX_GROUP"})(Na||(Na={}));function Yxe(e,t){let r=(()=>{try{return new RegExp(t)}catch(n){return null}})();return{name:t,metadata:{type:Na.SEARCH_RESULTS,validRegex:!!r,universalRegex:t===".*"},items:r?e.filter(n=>n.match(r)):[]}}function jxe(e,t="/"){let r=[],n={};return e.forEach(i=>{let o=i.indexOf(t),a=o>=0?i.slice(0,o):i;if(!n[a]){let s={name:a,metadata:{type:Na.PREFIX_GROUP},items:[]};n[a]=s,r.push(s)}n[a].items.push(i)}),r}function Xxe(e,t=""){let r=[Yxe(e,t)],n=jxe(e);return Array().concat(r,n)}function hE(e,t,r){let n=$i(e),i=Xxe(n,r),o=$xe(u9.pick(e,t));return i.map(({name:a,metadata:s,items:l})=>({name:a,metadata:s,items:l.map(c=>({tag:c,runs:(o.get(c)||[]).slice()}))}))}function $xe(e){let t=new Map;return Object.keys(e).forEach(r=>{e[r].forEach(n=>{let i=t.get(n)||[];i.push(r),t.set(n,i)})}),t}function Kxe(e,t){let r=xh(e.tag,t.tag);return r!=0?r:xh(e.run,t.run)}function Ql(e,t,r){let n=hE(e,t,r);function i(o){let a=u9.flatten(o.items.map(({tag:s,runs:l})=>l.map(c=>({tag:s,run:c}))));return a.sort(Kxe),{name:o.name,metadata:o.metadata,items:a}}return n.map(i)}var cW={};Ks(cW,{IronResizableBehavior:()=>Js});var Zxe={attached:!0,detached:!0,ready:!0,created:!0,beforeRegister:!0,registered:!0,attributeChanged:!0,listeners:!0,hostAttributes:!0},Fgt={attached:!0,detached:!0,ready:!0,created:!0,beforeRegister:!0,registered:!0,attributeChanged:!0,behaviors:!0,_noAccessors:!0},Jxe=Object.assign({listeners:!0,hostAttributes:!0,properties:!0,observers:!0},Fgt);function Qxe(e,t,r){let n=e._noAccessors,i=Object.getOwnPropertyNames(e);for(let o=0;o<i.length;o++){let a=i[o];if(!(a in r))if(n)t[a]=e[a];else{let s=Object.getOwnPropertyDescriptor(e,a);s&&(s.configurable=!0,Object.defineProperty(t,a,s))}}}function Bgt(e,t){return Ugt({},Gt(t),e)}function tbe(e,t,r){for(let n=0;n<t.length;n++)Hgt(e,t[n],r,Jxe)}function Hgt(e,t,r,n){Qxe(t,e,n);for(let i in Zxe)t[i]&&(r[i]=r[i]||[],r[i].push(t[i]))}function Vgt(e,t,r){t=t||[];for(let n=e.length-1;n>=0;n--){let i=e[n];i?Array.isArray(i)?Vgt(i,t):t.indexOf(i)<0&&(!r||r.indexOf(i)<0)&&t.unshift(i):console.warn("behavior is null, check for missing or 404 import")}return t}function Ogt(e,t){for(let r in t){let n=e[r],i=t[r];!("value"in i)&&n&&"value"in n?e[r]=Object.assign({value:n.value},i):e[r]=i}}var zgt=Gt(HTMLElement);function Ugt(e,t,r){let n,i={};class o extends t{static _finalizeClass(){if(!this.hasOwnProperty(JSCompiler_renameProperty("generatedFrom",this)))t._finalizeClass.call(this);else{if(n)for(let l=0,c;l<n.length;l++)c=n[l],c.properties&&this.createProperties(c.properties),c.observers&&this.createObservers(c.observers,c.properties);e.properties&&this.createProperties(e.properties),e.observers&&this.createObservers(e.observers,e.properties),this._prepareTemplate()}}static get properties(){let l={};if(n)for(let c=0;c<n.length;c++)Ogt(l,n[c].properties);return Ogt(l,e.properties),l}static get observers(){let l=[];if(n)for(let c=0,u;c<n.length;c++)u=n[c],u.observers&&(l=l.concat(u.observers));return e.observers&&(l=l.concat(e.observers)),l}created(){super.created();let l=i.created;if(l)for(let c=0;c<l.length;c++)l[c].call(this)}_registered(){let l=o.prototype;if(!l.hasOwnProperty(JSCompiler_renameProperty("__hasRegisterFinished",l))){l.__hasRegisterFinished=!0,super._registered(),pp&&a(l);let c=Object.getPrototypeOf(this),u=i.beforeRegister;if(u)for(let h=0;h<u.length;h++)u[h].call(c);if(u=i.registered,u)for(let h=0;h<u.length;h++)u[h].call(c)}}_applyListeners(){super._applyListeners();let l=i.listeners;if(l)for(let c=0;c<l.length;c++){let u=l[c];if(u)for(let h in u)this._addMethodEventListenerToNode(this,h,u[h])}}_ensureAttributes(){let l=i.hostAttributes;if(l)for(let c=l.length-1;c>=0;c--){let u=l[c];for(let h in u)this._ensureAttribute(h,u[h])}super._ensureAttributes()}ready(){super.ready();let l=i.ready;if(l)for(let c=0;c<l.length;c++)l[c].call(this)}attached(){super.attached();let l=i.attached;if(l)for(let c=0;c<l.length;c++)l[c].call(this)}detached(){super.detached();let l=i.detached;if(l)for(let c=0;c<l.length;c++)l[c].call(this)}attributeChanged(l,c,u){super.attributeChanged();let h=i.attributeChanged;if(h)for(let f=0;f<h.length;f++)h[f].call(this,l,c,u)}}if(r){Array.isArray(r)||(r=[r]);let s=t.prototype.behaviors;n=Vgt(r,null,s),o.prototype.behaviors=s?s.concat(r):n}let a=s=>{n&&tbe(s,n,i),Hgt(s,e,i,Fgt)};return pp||a(o.prototype),o.generatedFrom=e,o}var h9=function(e,t){e||console.warn("Polymer.Class requires `info` argument");let r=t?t(zgt):zgt;return r=Ugt(e,r,e.behaviors),r.is=r.prototype.is=e.is,r};var Yt=function(e){let t;return typeof e=="function"?t=e:t=Yt.Class(e),e._legacyForceObservedAttributes&&(t.prototype._legacyForceObservedAttributes=e._legacyForceObservedAttributes),customElements.define(t.is,t),t};Yt.Class=h9;function eW(e,t,r,n,i){let o;i&&(o=typeof r=="object"&&r!==null,o&&(n=e.__dataTemp[t]));let a=n!==r&&(n===n||r===r);return o&&a&&(e.__dataTemp[t]=r),a}var Gx=Rn(e=>{class t extends e{_shouldPropertyChange(n,i,o){return eW(this,n,i,o,!0)}}return t}),f9=Rn(e=>{class t extends e{static get properties(){return{mutableData:Boolean}}_shouldPropertyChange(n,i,o){return eW(this,n,i,o,this.mutableData)}}return t});Gx._mutablePropertyChange=eW;var rW=null;function nW(){return rW}nW.prototype=Object.create(HTMLTemplateElement.prototype,{constructor:{value:nW,writable:!0}});var Ggt=u_(nW),ebe=Gx(Ggt);function rbe(e,t){rW=e,Object.setPrototypeOf(e,t.prototype),new t,rW=null}var nbe=u_(class{});function iW(e,t){for(let r=0;r<t.length;r++){let n=t[r];if(Boolean(e)!=Boolean(n.__hideTemplateChildren__))if(n.nodeType===Node.TEXT_NODE)e?(n.__polymerTextContent__=n.textContent,n.textContent=""):n.textContent=n.__polymerTextContent__;else if(n.localName==="slot")if(e)n.__polymerReplaced__=document.createComment("hidden-slot"),ue(ue(n).parentNode).replaceChild(n.__polymerReplaced__,n);else{let i=n.__polymerReplaced__;i&&ue(ue(i).parentNode).replaceChild(n,i)}else n.style&&(e?(n.__polymerDisplay__=n.style.display,n.style.display="none"):n.style.display=n.__polymerDisplay__);n.__hideTemplateChildren__=e,n._showHideChildren&&n._showHideChildren(e)}}var bh=class extends nbe{constructor(t){super(),this._configureProperties(t),this.root=this._stampTemplate(this.__dataHost);let r=[];this.children=r;for(let i=this.root.firstChild;i;i=i.nextSibling)r.push(i),i.__templatizeInstance=this;this.__templatizeOwner&&this.__templatizeOwner.__hideTemplateChildren__&&this._showHideChildren(!0);let n=this.__templatizeOptions;(t&&n.instanceProps||!n.instanceProps)&&this._enableProperties()}_configureProperties(t){if(this.__templatizeOptions.forwardHostProp)for(let n in this.__hostProps)this._setPendingProperty(n,this.__dataHost["_host_"+n]);for(let n in t)this._setPendingProperty(n,t[n])}forwardHostProp(t,r){this._setPendingPropertyOrPath(t,r,!1,!0)&&this.__dataHost._enqueueClient(this)}_addEventListenerToNode(t,r,n){if(this._methodHost&&this.__templatizeOptions.parentModel)this._methodHost._addEventListenerToNode(t,r,i=>{i.model=this,n(i)});else{let i=this.__dataHost.__dataHost;i&&i._addEventListenerToNode(t,r,n)}}_showHideChildren(t){iW(t,this.children)}_setUnmanagedPropertyToNode(t,r,n){t.__hideTemplateChildren__&&t.nodeType==Node.TEXT_NODE&&r=="textContent"?t.__polymerTextContent__=n:super._setUnmanagedPropertyToNode(t,r,n)}get parentModel(){let t=this.__parentModel;if(!t){let r;t=this;do t=t.__dataHost.__dataHost;while((r=t.__templatizeOptions)&&!r.parentModel);this.__parentModel=t}return t}dispatchEvent(t){return!0}};bh.prototype.__dataHost;bh.prototype.__templatizeOptions;bh.prototype._methodHost;bh.prototype.__templatizeOwner;bh.prototype.__hostProps;var ibe=Gx(bh);function qgt(e){let t=e.__dataHost;return t&&t._methodHost||t}function obe(e,t,r){let n=r.mutableData?ibe:bh;tc.mixin&&(n=tc.mixin(n));let i=class extends n{};return i.prototype.__templatizeOptions=r,i.prototype._bindTemplate(e),lbe(i,e,t,r),i}function abe(e,t,r,n){let i=r.forwardHostProp;if(i&&t.hasHostProps){let o=e.localName=="template",a=t.templatizeTemplateClass;if(!a){if(o){let l=r.mutableData?ebe:Ggt;class c extends l{}a=t.templatizeTemplateClass=c}else{let l=e.constructor;class c extends l{}a=t.templatizeTemplateClass=c}let s=t.hostProps;for(let l in s)a.prototype._addPropertyEffect("_host_"+l,a.prototype.PROPERTY_EFFECT_TYPES.PROPAGATE,{fn:sbe(l,i)}),a.prototype._createNotifyingProperty("_host_"+l);LI&&n&&hbe(t,r,n)}if(e.__dataProto&&Object.assign(e.__data,e.__dataProto),o)rbe(e,a),e.__dataTemp={},e.__dataPending=null,e.__dataOld=null,e._enableProperties();else{Object.setPrototypeOf(e,a.prototype);let s=t.hostProps;for(let l in s)if(l="_host_"+l,l in e){let c=e[l];delete e[l],e.__data[l]=c}}}}function sbe(e,t){return function(n,i,o){t.call(n.__templatizeOwner,i.substring(6),o[i])}}function lbe(e,t,r,n){let i=r.hostProps||{};for(let o in n.instanceProps){delete i[o];let a=n.notifyInstanceProp;a&&e.prototype._addPropertyEffect(o,e.prototype.PROPERTY_EFFECT_TYPES.NOTIFY,{fn:cbe(o,a)})}if(n.forwardHostProp&&t.__dataHost)for(let o in i)r.hasHostProps||(r.hasHostProps=!0),e.prototype._addPropertyEffect(o,e.prototype.PROPERTY_EFFECT_TYPES.NOTIFY,{fn:ube()})}function cbe(e,t){return function(n,i,o){t.call(n.__templatizeOwner,n,i,o[i])}}function ube(){return function(t,r,n){t.__dataHost._setPendingPropertyOrPath("_host_"+r,n[r],!0,!0)}}function tc(e,t,r){if(iu&&!qgt(e))throw new Error("strictTemplatePolicy: template owner not trusted");if(r=r||{},e.__templatizeOwner)throw new Error("A <template> can only be templatized once");e.__templatizeOwner=t;let i=(t?t.constructor:bh)._parseTemplate(e),o=i.templatizeInstanceClass;o||(o=obe(e,i,r),i.templatizeInstanceClass=o);let a=qgt(e);abe(e,i,r,a);let s=class extends o{};return s.prototype._methodHost=a,s.prototype.__dataHost=e,s.prototype.__templatizeOwner=t,s.prototype.__hostProps=i.hostProps,s=s,s}function hbe(e,t,r){let n=r.constructor._properties,{propertyEffects:i}=e,{instanceProps:o}=t;for(let a in i)if(!n[a]&&!(o&&o[a])){let s=i[a];for(let l=0;l<s.length;l++){let{part:c}=s[l].info;if(!(c.signature&&c.signature.static)){console.warn(`Property '${a}' used in template but not declared in 'properties'; attribute will not be observed.`);break}}}}function p9(e,t){let r;for(;t;)if(r=t.__dataHost?t:t.__templatizeInstance)if(r.__dataHost!=e)t=r.__dataHost;else return r;else t=ue(t).parentNode;return null}var Wgt={templatize(e,t){this._templatizerTemplate=e,this.ctor=tc(e,this,{mutableData:Boolean(t),parentModel:this._parentModel,instanceProps:this._instanceProps,forwardHostProp:this._forwardHostPropV2,notifyInstanceProp:this._notifyInstancePropV2})},stamp(e){return new this.ctor(e)},modelForElement(e){return p9(this._templatizerTemplate,e)}};var Ygt=!1;function Wx(){if(pp&&!c_){if(!Ygt){Ygt=!0;let e=document.createElement("style");e.textContent="dom-bind,dom-if,dom-repeat{display:none;}",document.head.appendChild(e)}return!0}return!1}var fbe=yh(f9(u_(HTMLElement))),oW=class extends fbe{static get observedAttributes(){return["mutable-data"]}constructor(){if(super(),iu)throw new Error("strictTemplatePolicy: dom-bind not allowed");this.root=null,this.$=null,this.__children=null}attributeChangedCallback(t,r,n,i){this.mutableData=!0}connectedCallback(){Wx()||(this.style.display="none"),this.render()}disconnectedCallback(){this.__removeChildren()}__insertChildren(){ue(ue(this).parentNode).insertBefore(this.root,this)}__removeChildren(){if(this.__children)for(let t=0;t<this.__children.length;t++)this.root.appendChild(this.__children[t])}render(){let t;if(!this.__children){if(t=t||this.querySelector("template"),!t){let r=new MutationObserver(()=>{if(t=this.querySelector("template"),t)r.disconnect(),this.render();else throw new Error("dom-bind requires a <template> child")});r.observe(this,{childList:!0});return}this.root=this._stampTemplate(t),this.$=this.root.$,this.__children=[];for(let r=this.root.firstChild;r;r=r.nextSibling)this.__children[this.__children.length]=r;this._enableProperties()}this.__insertChildren(),this.dispatchEvent(new CustomEvent("dom-change",{bubbles:!0,composed:!0}))}};customElements.define("dom-bind",oW);var pbe=f9(mt),d9=class extends pbe{static get is(){return"dom-repeat"}static get template(){return null}static get properties(){return{items:{type:Array},as:{type:String,value:"item"},indexAs:{type:String,value:"index"},itemsIndexAs:{type:String,value:"itemsIndex"},sort:{type:Function,observer:"__sortChanged"},filter:{type:Function,observer:"__filterChanged"},observe:{type:String,observer:"__observeChanged"},delay:Number,renderedItemCount:{type:Number,notify:!UM,readOnly:!0},initialCount:{type:Number},targetFramerate:{type:Number,value:20},_targetFrameTime:{type:Number,computed:"__computeFrameTime(targetFramerate)"},notifyDomChange:{type:Boolean},reuseChunkedInstances:{type:Boolean}}}static get observers(){return["__itemsChanged(items.*)"]}constructor(){super(),this.__instances=[],this.__renderDebouncer=null,this.__itemsIdxToInstIdx={},this.__chunkCount=null,this.__renderStartTime=null,this.__itemsArrayChanged=!1,this.__shouldMeasureChunk=!1,this.__shouldContinueChunking=!1,this.__chunkingId=0,this.__sortFn=null,this.__filterFn=null,this.__observePaths=null,this.__ctor=null,this.__isDetached=!0,this.template=null,this._templateInfo}disconnectedCallback(){super.disconnectedCallback(),this.__isDetached=!0;for(let t=0;t<this.__instances.length;t++)this.__detachInstance(t)}connectedCallback(){if(super.connectedCallback(),Wx()||(this.style.display="none"),this.__isDetached){this.__isDetached=!1;let t=ue(ue(this).parentNode);for(let r=0;r<this.__instances.length;r++)this.__attachInstance(r,t)}}__ensureTemplatized(){if(!this.__ctor){let t=this,r=this.template=t._templateInfo?t:this.querySelector("template");if(!r){let i=new MutationObserver(()=>{if(this.querySelector("template"))i.disconnect(),this.__render();else throw new Error("dom-repeat requires a <template> child")});return i.observe(this,{childList:!0}),!1}let n={};n[this.as]=!0,n[this.indexAs]=!0,n[this.itemsIndexAs]=!0,this.__ctor=tc(r,this,{mutableData:this.mutableData,parentModel:!0,instanceProps:n,forwardHostProp:function(i,o){let a=this.__instances;for(let s=0,l;s<a.length&&(l=a[s]);s++)l.forwardHostProp(i,o)},notifyInstanceProp:function(i,o,a){if(OI(this.as,o)){let s=i[this.itemsIndexAs];o==this.as&&(this.items[s]=a);let l=dp(this.as,`${JSCompiler_renameProperty("items",this)}.${s}`,o);this.notifyPath(l,a)}}})}return!0}__getMethodHost(){return this.__dataHost._methodHost||this.__dataHost}__functionFromPropertyValue(t){if(typeof t=="string"){let r=t,n=this.__getMethodHost();return function(){return n[r].apply(n,arguments)}}return t}__sortChanged(t){this.__sortFn=this.__functionFromPropertyValue(t),this.items&&this.__debounceRender(this.__render)}__filterChanged(t){this.__filterFn=this.__functionFromPropertyValue(t),this.items&&this.__debounceRender(this.__render)}__computeFrameTime(t){return Math.ceil(1e3/t)}__observeChanged(){this.__observePaths=this.observe&&this.observe.replace(".*",".").split(" ")}__handleObservedPaths(t){if(this.__sortFn||this.__filterFn){if(!t)this.__debounceRender(this.__render,this.delay);else if(this.__observePaths){let r=this.__observePaths;for(let n=0;n<r.length;n++)t.indexOf(r[n])===0&&this.__debounceRender(this.__render,this.delay)}}}__itemsChanged(t){this.items&&!Array.isArray(this.items)&&console.warn("dom-repeat expected array for `items`, found",this.items),this.__handleItemPath(t.path,t.value)||(t.path==="items"&&(this.__itemsArrayChanged=!0),this.__debounceRender(this.__render))}__debounceRender(t,r=0){this.__renderDebouncer=sr.debounce(this.__renderDebouncer,r>0?mo.after(r):li,t.bind(this)),Jl(this.__renderDebouncer)}render(){this.__debounceRender(this.__render),ci()}__render(){if(!this.__ensureTemplatized())return;let t=this.items||[],r=this.__sortAndFilterItems(t),n=this.__calculateLimit(r.length);this.__updateInstances(t,n,r),this.initialCount&&(this.__shouldMeasureChunk||this.__shouldContinueChunking)&&(cancelAnimationFrame(this.__chunkingId),this.__chunkingId=requestAnimationFrame(()=>this.__continueChunking())),this._setRenderedItemCount(this.__instances.length),(!UM||this.notifyDomChange)&&this.dispatchEvent(new CustomEvent("dom-change",{bubbles:!0,composed:!0}))}__sortAndFilterItems(t){let r=new Array(t.length);for(let n=0;n<t.length;n++)r[n]=n;return this.__filterFn&&(r=r.filter((n,i,o)=>this.__filterFn(t[n],i,o))),this.__sortFn&&r.sort((n,i)=>this.__sortFn(t[n],t[i])),r}__calculateLimit(t){let r=t,n=this.__instances.length;if(this.initialCount){let i;!this.__chunkCount||this.__itemsArrayChanged&&!this.reuseChunkedInstances?(r=Math.min(t,this.initialCount),i=Math.max(r-n,0),this.__chunkCount=i||1):(i=Math.min(Math.max(t-n,0),this.__chunkCount),r=Math.min(n+i,t)),this.__shouldMeasureChunk=i===this.__chunkCount,this.__shouldContinueChunking=r<t,this.__renderStartTime=performance.now()}return this.__itemsArrayChanged=!1,r}__continueChunking(){if(this.__shouldMeasureChunk){let t=performance.now()-this.__renderStartTime,r=this._targetFrameTime/t;this.__chunkCount=Math.round(this.__chunkCount*r)||1}this.__shouldContinueChunking&&this.__debounceRender(this.__render)}__updateInstances(t,r,n){let i=this.__itemsIdxToInstIdx={},o;for(o=0;o<r;o++){let a=this.__instances[o],s=n[o],l=t[s];i[s]=o,a?(a._setPendingProperty(this.as,l),a._setPendingProperty(this.indexAs,o),a._setPendingProperty(this.itemsIndexAs,s),a._flushProperties()):this.__insertInstance(l,o,s)}for(let a=this.__instances.length-1;a>=o;a--)this.__detachAndRemoveInstance(a)}__detachInstance(t){let r=this.__instances[t],n=ue(r.root);for(let i=0;i<r.children.length;i++){let o=r.children[i];n.appendChild(o)}return r}__attachInstance(t,r){let n=this.__instances[t];r.insertBefore(n.root,this)}__detachAndRemoveInstance(t){this.__detachInstance(t),this.__instances.splice(t,1)}__stampInstance(t,r,n){let i={};return i[this.as]=t,i[this.indexAs]=r,i[this.itemsIndexAs]=n,new this.__ctor(i)}__insertInstance(t,r,n){let i=this.__stampInstance(t,r,n),o=this.__instances[r+1],a=o?o.children[0]:this;return ue(ue(this).parentNode).insertBefore(i.root,a),this.__instances[r]=i,i}_showHideChildren(t){for(let r=0;r<this.__instances.length;r++)this.__instances[r]._showHideChildren(t)}__handleItemPath(t,r){let n=t.slice(6),i=n.indexOf("."),o=i<0?n:n.substring(0,i);if(o==parseInt(o,10)){let a=i<0?"":n.substring(i+1);this.__handleObservedPaths(a);let s=this.__itemsIdxToInstIdx[o],l=this.__instances[s];if(l){let c=this.as+(a?"."+a:"");l._setPendingPropertyOrPath(c,r,!1,!0),l._flushProperties()}return!0}}itemForElement(t){let r=this.modelForElement(t);return r&&r[this.as]}indexForElement(t){let r=this.modelForElement(t);return r&&r[this.indexAs]}modelForElement(t){return p9(this.template,t)}};customElements.define(d9.is,d9);var m9=class extends mt{static get is(){return"dom-if"}static get template(){return null}static get properties(){return{if:{type:Boolean,observer:"__debounceRender"},restamp:{type:Boolean,observer:"__debounceRender"},notifyDomChange:{type:Boolean}}}constructor(){super(),this.__renderDebouncer=null,this._lastIf=!1,this.__hideTemplateChildren__=!1,this.__template,this._templateInfo}__debounceRender(){this.__renderDebouncer=sr.debounce(this.__renderDebouncer,li,()=>this.__render()),Jl(this.__renderDebouncer)}disconnectedCallback(){super.disconnectedCallback();let t=ue(this).parentNode;(!t||t.nodeType==Node.DOCUMENT_FRAGMENT_NODE&&!ue(t).host)&&this.__teardownInstance()}connectedCallback(){super.connectedCallback(),Wx()||(this.style.display="none"),this.if&&this.__debounceRender()}__ensureTemplate(){if(!this.__template){let t=this,r=t._templateInfo?t:ue(t).querySelector("template");if(!r){let n=new MutationObserver(()=>{if(ue(this).querySelector("template"))n.disconnect(),this.__render();else throw new Error("dom-if requires a <template> child")});return n.observe(this,{childList:!0}),!1}this.__template=r}return!0}__ensureInstance(){let t=ue(this).parentNode;if(this.__hasInstance()){let r=this.__getInstanceNodes();if(r&&r.length&&ue(this).previousSibling!==r[r.length-1])for(let i=0,o;i<r.length&&(o=r[i]);i++)ue(t).insertBefore(o,this)}else{if(!t||!this.__ensureTemplate())return!1;this.__createAndInsertInstance(t)}return!0}render(){ci()}__render(){if(this.if){if(!this.__ensureInstance())return}else this.restamp&&this.__teardownInstance();this._showHideChildren(),(!UM||this.notifyDomChange)&&this.if!=this._lastIf&&(this.dispatchEvent(new CustomEvent("dom-change",{bubbles:!0,composed:!0})),this._lastIf=this.if)}__hasInstance(){}__getInstanceNodes(){}__createAndInsertInstance(t){}__teardownInstance(){}_showHideChildren(){}},aW=class extends m9{constructor(){super(),this.__instance=null,this.__syncInfo=null}__hasInstance(){return Boolean(this.__instance)}__getInstanceNodes(){return this.__instance.templateInfo.childNodes}__createAndInsertInstance(t){let r=this.__dataHost||this;if(iu&&!this.__dataHost)throw new Error("strictTemplatePolicy: template owner not trusted");let n=r._bindTemplate(this.__template,!0);n.runEffects=(i,o,a)=>{let s=this.__syncInfo;if(this.if)s&&(this.__syncInfo=null,this._showHideChildren(),o=Object.assign(s.changedProps,o)),i(o,a);else if(this.__instance)if(s||(s=this.__syncInfo={runEffects:i,changedProps:{}}),a)for(let l in o){let c=au(l);s.changedProps[c]=this.__dataHost[c]}else Object.assign(s.changedProps,o)},this.__instance=r._stampTemplate(this.__template,n),ue(t).insertBefore(this.__instance,this)}__syncHostProperties(){let t=this.__syncInfo;t&&(this.__syncInfo=null,t.runEffects(t.changedProps,!1))}__teardownInstance(){let t=this.__dataHost||this;this.__instance&&(t._removeBoundDom(this.__instance),this.__instance=null,this.__syncInfo=null)}_showHideChildren(){let t=this.__hideTemplateChildren__||!this.if;this.__instance&&Boolean(this.__instance.__hidden)!==t&&(this.__instance.__hidden=t,iW(t,this.__instance.templateInfo.childNodes)),t||this.__syncHostProperties()}},sW=class extends m9{constructor(){super(),this.__ctor=null,this.__instance=null,this.__invalidProps=null}__hasInstance(){return Boolean(this.__instance)}__getInstanceNodes(){return this.__instance.children}__createAndInsertInstance(t){this.__ctor||(this.__ctor=tc(this.__template,this,{mutableData:!0,forwardHostProp:function(r,n){this.__instance&&(this.if?this.__instance.forwardHostProp(r,n):(this.__invalidProps=this.__invalidProps||Object.create(null),this.__invalidProps[au(r)]=!0))}})),this.__instance=new this.__ctor,ue(t).insertBefore(this.__instance.root,this)}__teardownInstance(){if(this.__instance){let t=this.__instance.children;if(t&&t.length){let r=ue(t[0]).parentNode;if(r){r=ue(r);for(let n=0,i;n<t.length&&(i=t[n]);n++)r.removeChild(i)}}this.__invalidProps=null,this.__instance=null}}__syncHostProperties(){let t=this.__invalidProps;if(t){this.__invalidProps=null;for(let r in t)this.__instance._setPendingProperty(r,this.__dataHost[r]);this.__instance._flushProperties()}}_showHideChildren(){let t=this.__hideTemplateChildren__||!this.if;this.__instance&&Boolean(this.__instance.__hidden)!==t&&(this.__instance.__hidden=t,this.__instance._showHideChildren(t)),t||this.__syncHostProperties()}},jgt=RI?aW:sW;customElements.define(jgt.is,jgt);var dbe=Rn(e=>{let t=Sm(e);class r extends t{static get properties(){return{items:{type:Array},multi:{type:Boolean,value:!1},selected:{type:Object,notify:!0},selectedItem:{type:Object,notify:!0},toggle:{type:Boolean,value:!1}}}static get observers(){return["__updateSelection(multi, items.*)"]}constructor(){super(),this.__lastItems=null,this.__lastMulti=null,this.__selectedMap=null}__updateSelection(i,o){let a=o.path;if(a==JSCompiler_renameProperty("items",this)){let s=o.base||[],l=this.__lastItems,c=this.__lastMulti;if(i!==c&&this.clearSelection(),l){let u=o9(s,l);this.__applySplices(u)}this.__lastItems=s,this.__lastMulti=i}else if(o.path==`${JSCompiler_renameProperty("items",this)}.splices`)this.__applySplices(o.value.indexSplices);else{let s=a.slice(`${JSCompiler_renameProperty("items",this)}.`.length),l=parseInt(s,10);s.indexOf(".")<0&&s==l&&this.__deselectChangedIdx(l)}}__applySplices(i){let o=this.__selectedMap;for(let s=0;s<i.length;s++){let l=i[s];o.forEach((c,u)=>{c<l.index||(c>=l.index+l.removed.length?o.set(u,c+l.addedCount-l.removed.length):o.set(u,-1))});for(let c=0;c<l.addedCount;c++){let u=l.index+c;o.has(this.items[u])&&o.set(this.items[u],u)}}this.__updateLinks();let a=0;o.forEach((s,l)=>{s<0?(this.multi?this.splice(JSCompiler_renameProperty("selected",this),a,1):this.selected=this.selectedItem=null,o.delete(l)):a++})}__updateLinks(){if(this.__dataLinkedPaths={},this.multi){let i=0;this.__selectedMap.forEach(o=>{o>=0&&this.linkPaths(`${JSCompiler_renameProperty("items",this)}.${o}`,`${JSCompiler_renameProperty("selected",this)}.${i++}`)})}else this.__selectedMap.forEach(i=>{this.linkPaths(JSCompiler_renameProperty("selected",this),`${JSCompiler_renameProperty("items",this)}.${i}`),this.linkPaths(JSCompiler_renameProperty("selectedItem",this),`${JSCompiler_renameProperty("items",this)}.${i}`)})}clearSelection(){this.__dataLinkedPaths={},this.__selectedMap=new Map,this.selected=this.multi?[]:null,this.selectedItem=null}isSelected(i){return this.__selectedMap.has(i)}isIndexSelected(i){return this.isSelected(this.items[i])}__deselectChangedIdx(i){let o=this.__selectedIndexForItemIndex(i);if(o>=0){let a=0;this.__selectedMap.forEach((s,l)=>{o==a++&&this.deselect(l)})}}__selectedIndexForItemIndex(i){let o=this.__dataLinkedPaths[`${JSCompiler_renameProperty("items",this)}.${i}`];if(o)return parseInt(o.slice(`${JSCompiler_renameProperty("selected",this)}.`.length),10)}deselect(i){let o=this.__selectedMap.get(i);if(o>=0){this.__selectedMap.delete(i);let a;this.multi&&(a=this.__selectedIndexForItemIndex(o)),this.__updateLinks(),this.multi?this.splice(JSCompiler_renameProperty("selected",this),a,1):this.selected=this.selectedItem=null}}deselectIndex(i){this.deselect(this.items[i])}select(i){this.selectIndex(this.items.indexOf(i))}selectIndex(i){let o=this.items[i];this.isSelected(o)?this.toggle&&this.deselectIndex(i):(this.multi||this.__selectedMap.clear(),this.__selectedMap.set(o,i),this.__updateLinks(),this.multi?this.push(JSCompiler_renameProperty("selected",this),o):this.selected=this.selectedItem=o)}}return r});var mbe=dbe(mt),g9=class extends mbe{static get is(){return"array-selector"}static get template(){return null}};customElements.define(g9.is,g9);var _9=new Zl;window.ShadyCSS||(window.ShadyCSS={prepareTemplate(e,t,r){},prepareTemplateDom(e,t){},prepareTemplateStyles(e,t,r){},styleSubtree(e,t){_9.processStyles(),JM(e,t)},styleElement(e){_9.processStyles()},styleDocument(e){_9.processStyles(),JM(document.body,e)},getComputedStyleValue(e,t){return jI(e,t)},flushCustomStyles(){},nativeCss:Nx,nativeShadow:h_,cssBuild:Mm,disableRuntime:WI});window.ShadyCSS.CustomStyleInterface=_9;var Xgt="include",gbe=window.ShadyCSS.CustomStyleInterface,lW=class extends HTMLElement{constructor(){super(),this._style=null,gbe.addCustomStyle(this)}getStyle(){if(this._style)return this._style;let t=this.querySelector("style");if(!t)return null;this._style=t;let r=t.getAttribute(Xgt);return r&&(t.removeAttribute(Xgt),t.textContent=imt(r)+t.textContent),this.ownerDocument!==window.document&&window.document.head.appendChild(this),this._style}};window.customElements.define("custom-style",lW);var $gt;$gt=Gx._mutablePropertyChange;var Kgt={properties:{mutableData:Boolean},_shouldPropertyChange(e,t,r){return $gt(this,e,t,r,this.mutableData)}};var Da=Gt(HTMLElement).prototype;var y9=new Set,Js={properties:{_parentResizable:{type:Object,observer:"_parentResizableChanged"},_notifyingDescendant:{type:Boolean,value:!1}},listeners:{"iron-request-resize-notifications":"_onIronRequestResizeNotifications"},created:function(){this._interestedResizables=[],this._boundNotifyResize=this.notifyResize.bind(this),this._boundOnDescendantIronResize=this._onDescendantIronResize.bind(this)},attached:function(){this._requestResizeNotifications()},detached:function(){this._parentResizable?this._parentResizable.stopResizeNotificationsFor(this):(y9.delete(this),window.removeEventListener("resize",this._boundNotifyResize)),this._parentResizable=null},notifyResize:function(){!this.isAttached||(this._interestedResizables.forEach(function(e){this.resizerShouldNotify(e)&&this._notifyDescendant(e)},this),this._fireResize())},assignParentResizable:function(e){this._parentResizable&&this._parentResizable.stopResizeNotificationsFor(this),this._parentResizable=e,e&&e._interestedResizables.indexOf(this)===-1&&(e._interestedResizables.push(this),e._subscribeIronResize(this))},stopResizeNotificationsFor:function(e){var t=this._interestedResizables.indexOf(e);t>-1&&(this._interestedResizables.splice(t,1),this._unsubscribeIronResize(e))},_subscribeIronResize:function(e){e.addEventListener("iron-resize",this._boundOnDescendantIronResize)},_unsubscribeIronResize:function(e){e.removeEventListener("iron-resize",this._boundOnDescendantIronResize)},resizerShouldNotify:function(e){return!0},_onDescendantIronResize:function(e){if(this._notifyingDescendant){e.stopPropagation();return}c_||this._fireResize()},_fireResize:function(){this.fire("iron-resize",null,{node:this,bubbles:!1})},_onIronRequestResizeNotifications:function(e){var t=zt(e).rootTarget;t!==this&&(t.assignParentResizable(this),this._notifyDescendant(t),e.stopPropagation())},_parentResizableChanged:function(e){e&&window.removeEventListener("resize",this._boundNotifyResize)},_notifyDescendant:function(e){!this.isAttached||(this._notifyingDescendant=!0,e.notifyResize(),this._notifyingDescendant=!1)},_requestResizeNotifications:function(){if(!!this.isAttached)if(document.readyState==="loading"){var e=this._requestResizeNotifications.bind(this);document.addEventListener("readystatechange",function t(){document.removeEventListener("readystatechange",t),e()})}else this._findParent(),this._parentResizable?this._parentResizable._interestedResizables.forEach(function(t){t!==this&&t._findParent()},this):(y9.forEach(function(t){t!==this&&t._findParent()},this),window.addEventListener("resize",this._boundNotifyResize),this.notifyResize())},_findParent:function(){this.assignParentResizable(null),this.fire("iron-request-resize-notifications",null,{node:this,bubbles:!0,cancelable:!0}),this._parentResizable?y9.delete(this):y9.add(this)}};Yt({_template:Q`
    <style>
      :host {
        display: block;
        transition-duration: var(--iron-collapse-transition-duration, 300ms);
        /* Safari 10 needs this property prefixed to correctly apply the custom property */
        -webkit-transition-duration: var(--iron-collapse-transition-duration, 300ms);
        overflow: visible;
      }

      :host(.iron-collapse-closed) {
        display: none;
      }

      :host(:not(.iron-collapse-opened)) {
        overflow: hidden;
      }
    </style>

    <slot></slot>
`,is:"iron-collapse",behaviors:[Js],properties:{horizontal:{type:Boolean,value:!1,observer:"_horizontalChanged"},opened:{type:Boolean,value:!1,notify:!0,observer:"_openedChanged"},transitioning:{type:Boolean,notify:!0,readOnly:!0},noAnimation:{type:Boolean},_desiredSize:{type:String,value:""}},get dimension(){return this.horizontal?"width":"height"},get _dimensionMax(){return this.horizontal?"maxWidth":"maxHeight"},get _dimensionMaxCss(){return this.horizontal?"max-width":"max-height"},hostAttributes:{role:"group","aria-hidden":"true"},listeners:{transitionend:"_onTransitionEnd"},toggle:function(){this.opened=!this.opened},show:function(){this.opened=!0},hide:function(){this.opened=!1},updateSize:function(e,t){e=e==="auto"?"":e;var r=t&&!this.noAnimation&&this.isAttached&&this._desiredSize!==e;if(this._desiredSize=e,this._updateTransition(!1),r){var n=this._calcSize();e===""&&(this.style[this._dimensionMax]="",e=this._calcSize()),this.style[this._dimensionMax]=n,this.scrollTop=this.scrollTop,this._updateTransition(!0),r=e!==n}this.style[this._dimensionMax]=e,r||this._transitionEnd()},enableTransition:function(e){Da._warn("`enableTransition()` is deprecated, use `noAnimation` instead."),this.noAnimation=!e},_updateTransition:function(e){this.style.transitionDuration=e&&!this.noAnimation?"":"0s"},_horizontalChanged:function(){this.style.transitionProperty=this._dimensionMaxCss;var e=this._dimensionMax==="maxWidth"?"maxHeight":"maxWidth";this.style[e]="",this.updateSize(this.opened?"auto":"0px",!1)},_openedChanged:function(){this.setAttribute("aria-hidden",!this.opened),this._setTransitioning(!0),this.toggleClass("iron-collapse-closed",!1),this.toggleClass("iron-collapse-opened",!1),this.updateSize(this.opened?"auto":"0px",!0),this.opened&&this.focus()},_transitionEnd:function(){this.style[this._dimensionMax]=this._desiredSize,this.toggleClass("iron-collapse-closed",!this.opened),this.toggleClass("iron-collapse-opened",this.opened),this._updateTransition(!1),this.notifyResize(),this._setTransitioning(!1)},_onTransitionEnd:function(e){zt(e).rootTarget===this&&this._transitionEnd()},_calcSize:function(){return this.getBoundingClientRect()[this.dimension]+"px"}});var Zgt=Q`
/* Most common used flex styles*/
<dom-module id="iron-flex">
  <template>
    <style>
      .layout.horizontal,
      .layout.vertical {
        display: -ms-flexbox;
        display: -webkit-flex;
        display: flex;
      }

      .layout.inline {
        display: -ms-inline-flexbox;
        display: -webkit-inline-flex;
        display: inline-flex;
      }

      .layout.horizontal {
        -ms-flex-direction: row;
        -webkit-flex-direction: row;
        flex-direction: row;
      }

      .layout.vertical {
        -ms-flex-direction: column;
        -webkit-flex-direction: column;
        flex-direction: column;
      }

      .layout.wrap {
        -ms-flex-wrap: wrap;
        -webkit-flex-wrap: wrap;
        flex-wrap: wrap;
      }

      .layout.no-wrap {
        -ms-flex-wrap: nowrap;
        -webkit-flex-wrap: nowrap;
        flex-wrap: nowrap;
      }

      .layout.center,
      .layout.center-center {
        -ms-flex-align: center;
        -webkit-align-items: center;
        align-items: center;
      }

      .layout.center-justified,
      .layout.center-center {
        -ms-flex-pack: center;
        -webkit-justify-content: center;
        justify-content: center;
      }

      .flex {
        -ms-flex: 1 1 0.000000001px;
        -webkit-flex: 1;
        flex: 1;
        -webkit-flex-basis: 0.000000001px;
        flex-basis: 0.000000001px;
      }

      .flex-auto {
        -ms-flex: 1 1 auto;
        -webkit-flex: 1 1 auto;
        flex: 1 1 auto;
      }

      .flex-none {
        -ms-flex: none;
        -webkit-flex: none;
        flex: none;
      }
    </style>
  </template>
</dom-module>
/* Basic flexbox reverse styles */
<dom-module id="iron-flex-reverse">
  <template>
    <style>
      .layout.horizontal-reverse,
      .layout.vertical-reverse {
        display: -ms-flexbox;
        display: -webkit-flex;
        display: flex;
      }

      .layout.horizontal-reverse {
        -ms-flex-direction: row-reverse;
        -webkit-flex-direction: row-reverse;
        flex-direction: row-reverse;
      }

      .layout.vertical-reverse {
        -ms-flex-direction: column-reverse;
        -webkit-flex-direction: column-reverse;
        flex-direction: column-reverse;
      }

      .layout.wrap-reverse {
        -ms-flex-wrap: wrap-reverse;
        -webkit-flex-wrap: wrap-reverse;
        flex-wrap: wrap-reverse;
      }
    </style>
  </template>
</dom-module>
/* Flexbox alignment */
<dom-module id="iron-flex-alignment">
  <template>
    <style>
      /**
       * Alignment in cross axis.
       */
      .layout.start {
        -ms-flex-align: start;
        -webkit-align-items: flex-start;
        align-items: flex-start;
      }

      .layout.center,
      .layout.center-center {
        -ms-flex-align: center;
        -webkit-align-items: center;
        align-items: center;
      }

      .layout.end {
        -ms-flex-align: end;
        -webkit-align-items: flex-end;
        align-items: flex-end;
      }

      .layout.baseline {
        -ms-flex-align: baseline;
        -webkit-align-items: baseline;
        align-items: baseline;
      }

      /**
       * Alignment in main axis.
       */
      .layout.start-justified {
        -ms-flex-pack: start;
        -webkit-justify-content: flex-start;
        justify-content: flex-start;
      }

      .layout.center-justified,
      .layout.center-center {
        -ms-flex-pack: center;
        -webkit-justify-content: center;
        justify-content: center;
      }

      .layout.end-justified {
        -ms-flex-pack: end;
        -webkit-justify-content: flex-end;
        justify-content: flex-end;
      }

      .layout.around-justified {
        -ms-flex-pack: distribute;
        -webkit-justify-content: space-around;
        justify-content: space-around;
      }

      .layout.justified {
        -ms-flex-pack: justify;
        -webkit-justify-content: space-between;
        justify-content: space-between;
      }

      /**
       * Self alignment.
       */
      .self-start {
        -ms-align-self: flex-start;
        -webkit-align-self: flex-start;
        align-self: flex-start;
      }

      .self-center {
        -ms-align-self: center;
        -webkit-align-self: center;
        align-self: center;
      }

      .self-end {
        -ms-align-self: flex-end;
        -webkit-align-self: flex-end;
        align-self: flex-end;
      }

      .self-stretch {
        -ms-align-self: stretch;
        -webkit-align-self: stretch;
        align-self: stretch;
      }

      .self-baseline {
        -ms-align-self: baseline;
        -webkit-align-self: baseline;
        align-self: baseline;
      }

      /**
       * multi-line alignment in main axis.
       */
      .layout.start-aligned {
        -ms-flex-line-pack: start;  /* IE10 */
        -ms-align-content: flex-start;
        -webkit-align-content: flex-start;
        align-content: flex-start;
      }

      .layout.end-aligned {
        -ms-flex-line-pack: end;  /* IE10 */
        -ms-align-content: flex-end;
        -webkit-align-content: flex-end;
        align-content: flex-end;
      }

      .layout.center-aligned {
        -ms-flex-line-pack: center;  /* IE10 */
        -ms-align-content: center;
        -webkit-align-content: center;
        align-content: center;
      }

      .layout.between-aligned {
        -ms-flex-line-pack: justify;  /* IE10 */
        -ms-align-content: space-between;
        -webkit-align-content: space-between;
        align-content: space-between;
      }

      .layout.around-aligned {
        -ms-flex-line-pack: distribute;  /* IE10 */
        -ms-align-content: space-around;
        -webkit-align-content: space-around;
        align-content: space-around;
      }
    </style>
  </template>
</dom-module>
/* Non-flexbox positioning helper styles */
<dom-module id="iron-flex-factors">
  <template>
    <style>
      .flex,
      .flex-1 {
        -ms-flex: 1 1 0.000000001px;
        -webkit-flex: 1;
        flex: 1;
        -webkit-flex-basis: 0.000000001px;
        flex-basis: 0.000000001px;
      }

      .flex-2 {
        -ms-flex: 2;
        -webkit-flex: 2;
        flex: 2;
      }

      .flex-3 {
        -ms-flex: 3;
        -webkit-flex: 3;
        flex: 3;
      }

      .flex-4 {
        -ms-flex: 4;
        -webkit-flex: 4;
        flex: 4;
      }

      .flex-5 {
        -ms-flex: 5;
        -webkit-flex: 5;
        flex: 5;
      }

      .flex-6 {
        -ms-flex: 6;
        -webkit-flex: 6;
        flex: 6;
      }

      .flex-7 {
        -ms-flex: 7;
        -webkit-flex: 7;
        flex: 7;
      }

      .flex-8 {
        -ms-flex: 8;
        -webkit-flex: 8;
        flex: 8;
      }

      .flex-9 {
        -ms-flex: 9;
        -webkit-flex: 9;
        flex: 9;
      }

      .flex-10 {
        -ms-flex: 10;
        -webkit-flex: 10;
        flex: 10;
      }

      .flex-11 {
        -ms-flex: 11;
        -webkit-flex: 11;
        flex: 11;
      }

      .flex-12 {
        -ms-flex: 12;
        -webkit-flex: 12;
        flex: 12;
      }
    </style>
  </template>
</dom-module>
<dom-module id="iron-positioning">
  <template>
    <style>
      .block {
        display: block;
      }

      [hidden] {
        display: none !important;
      }

      .invisible {
        visibility: hidden !important;
      }

      .relative {
        position: relative;
      }

      .fit {
        position: absolute;
        top: 0;
        right: 0;
        bottom: 0;
        left: 0;
      }

      body.fullbleed {
        margin: 0;
        height: 100vh;
      }

      .scroll {
        -webkit-overflow-scrolling: touch;
        overflow: auto;
      }

      /* fixed position */
      .fixed-bottom,
      .fixed-left,
      .fixed-right,
      .fixed-top {
        position: fixed;
      }

      .fixed-top {
        top: 0;
        left: 0;
        right: 0;
      }

      .fixed-right {
        top: 0;
        right: 0;
        bottom: 0;
      }

      .fixed-bottom {
        right: 0;
        bottom: 0;
        left: 0;
      }

      .fixed-left {
        top: 0;
        bottom: 0;
        left: 0;
      }
    </style>
  </template>
</dom-module>
`;Zgt.setAttribute("style","display: none;");document.head.appendChild(Zgt.content);var Jgt=Q`
<custom-style>
  <style is="custom-style">
    [hidden] {
      display: none !important;
    }
  </style>
</custom-style>
<custom-style>
  <style is="custom-style">
    html {

      --layout: {
        display: -ms-flexbox;
        display: -webkit-flex;
        display: flex;
      };

      --layout-inline: {
        display: -ms-inline-flexbox;
        display: -webkit-inline-flex;
        display: inline-flex;
      };

      --layout-horizontal: {
        @apply --layout;

        -ms-flex-direction: row;
        -webkit-flex-direction: row;
        flex-direction: row;
      };

      --layout-horizontal-reverse: {
        @apply --layout;

        -ms-flex-direction: row-reverse;
        -webkit-flex-direction: row-reverse;
        flex-direction: row-reverse;
      };

      --layout-vertical: {
        @apply --layout;

        -ms-flex-direction: column;
        -webkit-flex-direction: column;
        flex-direction: column;
      };

      --layout-vertical-reverse: {
        @apply --layout;

        -ms-flex-direction: column-reverse;
        -webkit-flex-direction: column-reverse;
        flex-direction: column-reverse;
      };

      --layout-wrap: {
        -ms-flex-wrap: wrap;
        -webkit-flex-wrap: wrap;
        flex-wrap: wrap;
      };

      --layout-wrap-reverse: {
        -ms-flex-wrap: wrap-reverse;
        -webkit-flex-wrap: wrap-reverse;
        flex-wrap: wrap-reverse;
      };

      --layout-flex-auto: {
        -ms-flex: 1 1 auto;
        -webkit-flex: 1 1 auto;
        flex: 1 1 auto;
      };

      --layout-flex-none: {
        -ms-flex: none;
        -webkit-flex: none;
        flex: none;
      };

      --layout-flex: {
        -ms-flex: 1 1 0.000000001px;
        -webkit-flex: 1;
        flex: 1;
        -webkit-flex-basis: 0.000000001px;
        flex-basis: 0.000000001px;
      };

      --layout-flex-2: {
        -ms-flex: 2;
        -webkit-flex: 2;
        flex: 2;
      };

      --layout-flex-3: {
        -ms-flex: 3;
        -webkit-flex: 3;
        flex: 3;
      };

      --layout-flex-4: {
        -ms-flex: 4;
        -webkit-flex: 4;
        flex: 4;
      };

      --layout-flex-5: {
        -ms-flex: 5;
        -webkit-flex: 5;
        flex: 5;
      };

      --layout-flex-6: {
        -ms-flex: 6;
        -webkit-flex: 6;
        flex: 6;
      };

      --layout-flex-7: {
        -ms-flex: 7;
        -webkit-flex: 7;
        flex: 7;
      };

      --layout-flex-8: {
        -ms-flex: 8;
        -webkit-flex: 8;
        flex: 8;
      };

      --layout-flex-9: {
        -ms-flex: 9;
        -webkit-flex: 9;
        flex: 9;
      };

      --layout-flex-10: {
        -ms-flex: 10;
        -webkit-flex: 10;
        flex: 10;
      };

      --layout-flex-11: {
        -ms-flex: 11;
        -webkit-flex: 11;
        flex: 11;
      };

      --layout-flex-12: {
        -ms-flex: 12;
        -webkit-flex: 12;
        flex: 12;
      };

      /* alignment in cross axis */

      --layout-start: {
        -ms-flex-align: start;
        -webkit-align-items: flex-start;
        align-items: flex-start;
      };

      --layout-center: {
        -ms-flex-align: center;
        -webkit-align-items: center;
        align-items: center;
      };

      --layout-end: {
        -ms-flex-align: end;
        -webkit-align-items: flex-end;
        align-items: flex-end;
      };

      --layout-baseline: {
        -ms-flex-align: baseline;
        -webkit-align-items: baseline;
        align-items: baseline;
      };

      /* alignment in main axis */

      --layout-start-justified: {
        -ms-flex-pack: start;
        -webkit-justify-content: flex-start;
        justify-content: flex-start;
      };

      --layout-center-justified: {
        -ms-flex-pack: center;
        -webkit-justify-content: center;
        justify-content: center;
      };

      --layout-end-justified: {
        -ms-flex-pack: end;
        -webkit-justify-content: flex-end;
        justify-content: flex-end;
      };

      --layout-around-justified: {
        -ms-flex-pack: distribute;
        -webkit-justify-content: space-around;
        justify-content: space-around;
      };

      --layout-justified: {
        -ms-flex-pack: justify;
        -webkit-justify-content: space-between;
        justify-content: space-between;
      };

      --layout-center-center: {
        @apply --layout-center;
        @apply --layout-center-justified;
      };

      /* self alignment */

      --layout-self-start: {
        -ms-align-self: flex-start;
        -webkit-align-self: flex-start;
        align-self: flex-start;
      };

      --layout-self-center: {
        -ms-align-self: center;
        -webkit-align-self: center;
        align-self: center;
      };

      --layout-self-end: {
        -ms-align-self: flex-end;
        -webkit-align-self: flex-end;
        align-self: flex-end;
      };

      --layout-self-stretch: {
        -ms-align-self: stretch;
        -webkit-align-self: stretch;
        align-self: stretch;
      };

      --layout-self-baseline: {
        -ms-align-self: baseline;
        -webkit-align-self: baseline;
        align-self: baseline;
      };

      /* multi-line alignment in main axis */

      --layout-start-aligned: {
        -ms-flex-line-pack: start;  /* IE10 */
        -ms-align-content: flex-start;
        -webkit-align-content: flex-start;
        align-content: flex-start;
      };

      --layout-end-aligned: {
        -ms-flex-line-pack: end;  /* IE10 */
        -ms-align-content: flex-end;
        -webkit-align-content: flex-end;
        align-content: flex-end;
      };

      --layout-center-aligned: {
        -ms-flex-line-pack: center;  /* IE10 */
        -ms-align-content: center;
        -webkit-align-content: center;
        align-content: center;
      };

      --layout-between-aligned: {
        -ms-flex-line-pack: justify;  /* IE10 */
        -ms-align-content: space-between;
        -webkit-align-content: space-between;
        align-content: space-between;
      };

      --layout-around-aligned: {
        -ms-flex-line-pack: distribute;  /* IE10 */
        -ms-align-content: space-around;
        -webkit-align-content: space-around;
        align-content: space-around;
      };

      /*******************************
                Other Layout
      *******************************/

      --layout-block: {
        display: block;
      };

      --layout-invisible: {
        visibility: hidden !important;
      };

      --layout-relative: {
        position: relative;
      };

      --layout-fit: {
        position: absolute;
        top: 0;
        right: 0;
        bottom: 0;
        left: 0;
      };

      --layout-scroll: {
        -webkit-overflow-scrolling: touch;
        overflow: auto;
      };

      --layout-fullbleed: {
        margin: 0;
        height: 100vh;
      };

      /* fixed position */

      --layout-fixed-top: {
        position: fixed;
        top: 0;
        left: 0;
        right: 0;
      };

      --layout-fixed-right: {
        position: fixed;
        top: 0;
        right: 0;
        bottom: 0;
      };

      --layout-fixed-bottom: {
        position: fixed;
        right: 0;
        bottom: 0;
        left: 0;
      };

      --layout-fixed-left: {
        position: fixed;
        top: 0;
        bottom: 0;
        left: 0;
      };

    }
  </style>
</custom-style>`;Jgt.setAttribute("style","display: none;");document.head.appendChild(Jgt.content);var Qgt=document.createElement("style");Qgt.textContent="[hidden] { display: none !important; }";document.head.appendChild(Qgt);var go=class{constructor(t){go[" "](t),this.type=t&&t.type||"default",this.key=t&&t.key,t&&"value"in t&&(this.value=t.value)}get value(){var t=this.type,r=this.key;if(t&&r)return go.types[t]&&go.types[t][r]}set value(t){var r=this.type,n=this.key;r&&n&&(r=go.types[r]=go.types[r]||{},t==null?delete r[n]:r[n]=t)}get list(){var t=this.type;if(t){var r=go.types[this.type];return r?Object.keys(r).map(function(n){return _be[this.type][n]},this):[]}}byKey(t){return this.key=t,this.value}};go[" "]=function(){};go.types={};var _be=go.types;Yt({is:"iron-meta",properties:{type:{type:String,value:"default"},key:{type:String},value:{type:String,notify:!0},self:{type:Boolean,observer:"_selfChanged"},__meta:{type:Boolean,computed:"__computeMeta(type, key, value)"}},hostAttributes:{hidden:!0},__computeMeta:function(e,t,r){var n=new go({type:e,key:t});return r!==void 0&&r!==n.value?n.value=r:this.value!==n.value&&(this.value=n.value),n},get list(){return this.__meta&&this.__meta.list},_selfChanged:function(e){e&&(this.value=this)},byKey:function(e){return new go({type:this.type,key:e}).value}});Yt({_template:Q`
    <style>
      :host {
        @apply --layout-inline;
        @apply --layout-center-center;
        position: relative;

        vertical-align: middle;

        fill: var(--iron-icon-fill-color, currentcolor);
        stroke: var(--iron-icon-stroke-color, none);

        width: var(--iron-icon-width, 24px);
        height: var(--iron-icon-height, 24px);
        @apply --iron-icon;
      }

      :host([hidden]) {
        display: none;
      }
    </style>
`,is:"iron-icon",properties:{icon:{type:String},theme:{type:String},src:{type:String},_meta:{value:Da.create("iron-meta",{type:"iconset"})}},observers:["_updateIcon(_meta, isAttached)","_updateIcon(theme, isAttached)","_srcChanged(src, isAttached)","_iconChanged(icon, isAttached)"],_DEFAULT_ICONSET:"icons",_iconChanged:function(e){var t=(e||"").split(":");this._iconName=t.pop(),this._iconsetName=t.pop()||this._DEFAULT_ICONSET,this._updateIcon()},_srcChanged:function(e){this._updateIcon()},_usesIconset:function(){return this.icon||!this.src},_updateIcon:function(){this._usesIconset()?(this._img&&this._img.parentNode&&zt(this.root).removeChild(this._img),this._iconName===""?this._iconset&&this._iconset.removeIcon(this):this._iconsetName&&this._meta&&(this._iconset=this._meta.byKey(this._iconsetName),this._iconset?(this._iconset.applyIcon(this,this._iconName,this.theme),this.unlisten(window,"iron-iconset-added","_updateIcon")):this.listen(window,"iron-iconset-added","_updateIcon"))):(this._iconset&&this._iconset.removeIcon(this),this._img||(this._img=document.createElement("img"),this._img.style.width="100%",this._img.style.height="100%",this._img.draggable=!1),this._img.src=this.src,zt(this.root).appendChild(this._img))}});Yt({is:"iron-iconset-svg",properties:{name:{type:String,observer:"_nameChanged"},size:{type:Number,value:24},rtlMirroring:{type:Boolean,value:!1},useGlobalRtlAttribute:{type:Boolean,value:!1}},created:function(){this._meta=new go({type:"iconset",key:null,value:null})},attached:function(){this.style.display="none"},getIconNames:function(){return this._icons=this._createIconMap(),Object.keys(this._icons).map(function(e){return this.name+":"+e},this)},applyIcon:function(e,t){this.removeIcon(e);var r=this._cloneIcon(t,this.rtlMirroring&&this._targetIsRTL(e));if(r){var n=zt(e.root||e);return n.insertBefore(r,n.childNodes[0]),e._svgIcon=r}return null},removeIcon:function(e){e._svgIcon&&(zt(e.root||e).removeChild(e._svgIcon),e._svgIcon=null)},_targetIsRTL:function(e){if(this.__targetIsRTL==null)if(this.useGlobalRtlAttribute){var t=document.body&&document.body.hasAttribute("dir")?document.body:document.documentElement;this.__targetIsRTL=t.getAttribute("dir")==="rtl"}else e&&e.nodeType!==Node.ELEMENT_NODE&&(e=e.host),this.__targetIsRTL=e&&window.getComputedStyle(e).direction==="rtl";return this.__targetIsRTL},_nameChanged:function(){this._meta.value=null,this._meta.key=this.name,this._meta.value=this,this.async(function(){this.fire("iron-iconset-added",this,{node:window})})},_createIconMap:function(){var e=Object.create(null);return zt(this).querySelectorAll("[id]").forEach(function(t){e[t.id]=t}),e},_cloneIcon:function(e,t){return this._icons=this._icons||this._createIconMap(),this._prepareSvgClone(this._icons[e],this.size,t)},_prepareSvgClone:function(e,t,r){if(e){var n=e.cloneNode(!0),i=document.createElementNS("http://www.w3.org/2000/svg","svg"),o=n.getAttribute("viewBox")||"0 0 "+t+" "+t,a="pointer-events: none; display: block; width: 100%; height: 100%;";return r&&n.hasAttribute("mirror-in-rtl")&&(a+="-webkit-transform:scale(-1,1);transform:scale(-1,1);transform-origin:center;"),i.setAttribute("viewBox",o),i.setAttribute("preserveAspectRatio","xMidYMid meet"),i.setAttribute("focusable","false"),i.style.cssText=a,i.appendChild(n).removeAttribute("id"),i}return null}});var ybe=Q`<iron-iconset-svg name="image" size="24">
<svg><defs>
<g id="add-a-photo"><path d="M3 4V1h2v3h3v2H5v3H3V6H0V4h3zm3 6V7h3V4h7l1.83 2H21c1.1 0 2 .9 2 2v12c0 1.1-.9 2-2 2H5c-1.1 0-2-.9-2-2V10h3zm7 9c2.76 0 5-2.24 5-5s-2.24-5-5-5-5 2.24-5 5 2.24 5 5 5zm-3.2-5c0 1.77 1.43 3.2 3.2 3.2s3.2-1.43 3.2-3.2-1.43-3.2-3.2-3.2-3.2 1.43-3.2 3.2z"></path></g>
<g id="add-to-photos"><path d="M4 6H2v14c0 1.1.9 2 2 2h14v-2H4V6zm16-4H8c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zm-1 9h-4v4h-2v-4H9V9h4V5h2v4h4v2z"></path></g>
<g id="adjust"><path d="M12 2C6.49 2 2 6.49 2 12s4.49 10 10 10 10-4.49 10-10S17.51 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8zm3-8c0 1.66-1.34 3-3 3s-3-1.34-3-3 1.34-3 3-3 3 1.34 3 3z"></path></g>
<g id="assistant"><path d="M19 2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h4l3 3 3-3h4c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zm-5.12 10.88L12 17l-1.88-4.12L6 11l4.12-1.88L12 5l1.88 4.12L18 11l-4.12 1.88z"></path></g>
<g id="assistant-photo"><path d="M14.4 6L14 4H5v17h2v-7h5.6l.4 2h7V6z"></path></g>
<g id="audiotrack"><path d="M12 3v9.28c-.47-.17-.97-.28-1.5-.28C8.01 12 6 14.01 6 16.5S8.01 21 10.5 21c2.31 0 4.2-1.75 4.45-4H15V6h4V3h-7z"></path></g>
<g id="blur-circular"><path d="M10 9c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm0 4c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zM7 9.5c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zm3 7c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zm-3-3c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zm3-6c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zM14 9c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm0-1.5c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zm3 6c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zm0-4c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zM12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8zm2-3.5c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zm0-3.5c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1z"></path></g>
<g id="blur-linear"><path d="M5 17.5c.83 0 1.5-.67 1.5-1.5s-.67-1.5-1.5-1.5-1.5.67-1.5 1.5.67 1.5 1.5 1.5zM9 13c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm0-4c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zM3 21h18v-2H3v2zM5 9.5c.83 0 1.5-.67 1.5-1.5S5.83 6.5 5 6.5 3.5 7.17 3.5 8 4.17 9.5 5 9.5zm0 4c.83 0 1.5-.67 1.5-1.5s-.67-1.5-1.5-1.5-1.5.67-1.5 1.5.67 1.5 1.5 1.5zM9 17c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm8-.5c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zM3 3v2h18V3H3zm14 5.5c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zm0 4c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zM13 9c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm0 4c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm0 4c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1z"></path></g>
<g id="blur-off"><path d="M14 7c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm-.2 4.48l.2.02c.83 0 1.5-.67 1.5-1.5s-.67-1.5-1.5-1.5-1.5.67-1.5 1.5l.02.2c.09.67.61 1.19 1.28 1.28zM14 3.5c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zm-4 0c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zm11 7c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zM10 7c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm8 8c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm0-4c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm0-4c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm-4 13.5c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zM2.5 5.27l3.78 3.78L6 9c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1c0-.1-.03-.19-.06-.28l2.81 2.81c-.71.11-1.25.73-1.25 1.47 0 .83.67 1.5 1.5 1.5.74 0 1.36-.54 1.47-1.25l2.81 2.81c-.09-.03-.18-.06-.28-.06-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1c0-.1-.03-.19-.06-.28l3.78 3.78L20 20.23 3.77 4 2.5 5.27zM10 17c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm11-3.5c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zM6 13c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zM3 9.5c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zm7 11c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zM6 17c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm-3-3.5c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5z"></path></g>
<g id="blur-on"><path d="M6 13c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm0 4c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm0-8c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm-3 .5c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zM6 5c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm15 5.5c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zM14 7c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm0-3.5c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zm-11 10c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zm7 7c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zm0-17c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zM10 7c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm0 5.5c-.83 0-1.5.67-1.5 1.5s.67 1.5 1.5 1.5 1.5-.67 1.5-1.5-.67-1.5-1.5-1.5zm8 .5c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm0 4c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm0-8c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm0-4c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm3 8.5c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zM14 17c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm0 3.5c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zm-4-12c-.83 0-1.5.67-1.5 1.5s.67 1.5 1.5 1.5 1.5-.67 1.5-1.5-.67-1.5-1.5-1.5zm0 8.5c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm4-4.5c-.83 0-1.5.67-1.5 1.5s.67 1.5 1.5 1.5 1.5-.67 1.5-1.5-.67-1.5-1.5-1.5zm0-4c-.83 0-1.5.67-1.5 1.5s.67 1.5 1.5 1.5 1.5-.67 1.5-1.5-.67-1.5-1.5-1.5z"></path></g>
<g id="brightness-1"><circle cx="12" cy="12" r="10"></circle></g>
<g id="brightness-2"><path d="M10 2c-1.82 0-3.53.5-5 1.35C7.99 5.08 10 8.3 10 12s-2.01 6.92-5 8.65C6.47 21.5 8.18 22 10 22c5.52 0 10-4.48 10-10S15.52 2 10 2z"></path></g>
<g id="brightness-3"><path d="M9 2c-1.05 0-2.05.16-3 .46 4.06 1.27 7 5.06 7 9.54 0 4.48-2.94 8.27-7 9.54.95.3 1.95.46 3 .46 5.52 0 10-4.48 10-10S14.52 2 9 2z"></path></g>
<g id="brightness-4"><path d="M20 8.69V4h-4.69L12 .69 8.69 4H4v4.69L.69 12 4 15.31V20h4.69L12 23.31 15.31 20H20v-4.69L23.31 12 20 8.69zM12 18c-.89 0-1.74-.2-2.5-.55C11.56 16.5 13 14.42 13 12s-1.44-4.5-3.5-5.45C10.26 6.2 11.11 6 12 6c3.31 0 6 2.69 6 6s-2.69 6-6 6z"></path></g>
<g id="brightness-5"><path d="M20 15.31L23.31 12 20 8.69V4h-4.69L12 .69 8.69 4H4v4.69L.69 12 4 15.31V20h4.69L12 23.31 15.31 20H20v-4.69zM12 18c-3.31 0-6-2.69-6-6s2.69-6 6-6 6 2.69 6 6-2.69 6-6 6z"></path></g>
<g id="brightness-6"><path d="M20 15.31L23.31 12 20 8.69V4h-4.69L12 .69 8.69 4H4v4.69L.69 12 4 15.31V20h4.69L12 23.31 15.31 20H20v-4.69zM12 18V6c3.31 0 6 2.69 6 6s-2.69 6-6 6z"></path></g>
<g id="brightness-7"><path d="M20 8.69V4h-4.69L12 .69 8.69 4H4v4.69L.69 12 4 15.31V20h4.69L12 23.31 15.31 20H20v-4.69L23.31 12 20 8.69zM12 18c-3.31 0-6-2.69-6-6s2.69-6 6-6 6 2.69 6 6-2.69 6-6 6zm0-10c-2.21 0-4 1.79-4 4s1.79 4 4 4 4-1.79 4-4-1.79-4-4-4z"></path></g>
<g id="broken-image"><path d="M21 5v6.59l-3-3.01-4 4.01-4-4-4 4-3-3.01V5c0-1.1.9-2 2-2h14c1.1 0 2 .9 2 2zm-3 6.42l3 3.01V19c0 1.1-.9 2-2 2H5c-1.1 0-2-.9-2-2v-6.58l3 2.99 4-4 4 4 4-3.99z"></path></g>
<g id="brush"><path d="M7 14c-1.66 0-3 1.34-3 3 0 1.31-1.16 2-2 2 .92 1.22 2.49 2 4 2 2.21 0 4-1.79 4-4 0-1.66-1.34-3-3-3zm13.71-9.37l-1.34-1.34c-.39-.39-1.02-.39-1.41 0L9 12.25 11.75 15l8.96-8.96c.39-.39.39-1.02 0-1.41z"></path></g>
<g id="burst-mode"><path d="M1 5h2v14H1zm4 0h2v14H5zm17 0H10c-.55 0-1 .45-1 1v12c0 .55.45 1 1 1h12c.55 0 1-.45 1-1V6c0-.55-.45-1-1-1zM11 17l2.5-3.15L15.29 16l2.5-3.22L21 17H11z"></path></g>
<g id="camera"><path d="M9.4 10.5l4.77-8.26C13.47 2.09 12.75 2 12 2c-2.4 0-4.6.85-6.32 2.25l3.66 6.35.06-.1zM21.54 9c-.92-2.92-3.15-5.26-6-6.34L11.88 9h9.66zm.26 1h-7.49l.29.5 4.76 8.25C21 16.97 22 14.61 22 12c0-.69-.07-1.35-.2-2zM8.54 12l-3.9-6.75C3.01 7.03 2 9.39 2 12c0 .69.07 1.35.2 2h7.49l-1.15-2zm-6.08 3c.92 2.92 3.15 5.26 6 6.34L12.12 15H2.46zm11.27 0l-3.9 6.76c.7.15 1.42.24 2.17.24 2.4 0 4.6-.85 6.32-2.25l-3.66-6.35-.93 1.6z"></path></g>
<g id="camera-alt"><circle cx="12" cy="12" r="3.2"></circle><path d="M9 2L7.17 4H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2h-3.17L15 2H9zm3 15c-2.76 0-5-2.24-5-5s2.24-5 5-5 5 2.24 5 5-2.24 5-5 5z"></path></g>
<g id="camera-front"><path d="M10 20H5v2h5v2l3-3-3-3v2zm4 0v2h5v-2h-5zM12 8c1.1 0 2-.9 2-2s-.9-2-2-2-1.99.9-1.99 2S10.9 8 12 8zm5-8H7C5.9 0 5 .9 5 2v14c0 1.1.9 2 2 2h10c1.1 0 2-.9 2-2V2c0-1.1-.9-2-2-2zM7 2h10v10.5c0-1.67-3.33-2.5-5-2.5s-5 .83-5 2.5V2z"></path></g>
<g id="camera-rear"><path d="M10 20H5v2h5v2l3-3-3-3v2zm4 0v2h5v-2h-5zm3-20H7C5.9 0 5 .9 5 2v14c0 1.1.9 2 2 2h10c1.1 0 2-.9 2-2V2c0-1.1-.9-2-2-2zm-5 6c-1.11 0-2-.9-2-2s.89-2 1.99-2 2 .9 2 2C14 5.1 13.1 6 12 6z"></path></g>
<g id="camera-roll"><path d="M14 5c0-1.1-.9-2-2-2h-1V2c0-.55-.45-1-1-1H6c-.55 0-1 .45-1 1v1H4c-1.1 0-2 .9-2 2v15c0 1.1.9 2 2 2h8c1.1 0 2-.9 2-2h8V5h-8zm-2 13h-2v-2h2v2zm0-9h-2V7h2v2zm4 9h-2v-2h2v2zm0-9h-2V7h2v2zm4 9h-2v-2h2v2zm0-9h-2V7h2v2z"></path></g>
<g id="center-focus-strong"><path d="M12 8c-2.21 0-4 1.79-4 4s1.79 4 4 4 4-1.79 4-4-1.79-4-4-4zm-7 7H3v4c0 1.1.9 2 2 2h4v-2H5v-4zM5 5h4V3H5c-1.1 0-2 .9-2 2v4h2V5zm14-2h-4v2h4v4h2V5c0-1.1-.9-2-2-2zm0 16h-4v2h4c1.1 0 2-.9 2-2v-4h-2v4z"></path></g>
<g id="center-focus-weak"><path d="M5 15H3v4c0 1.1.9 2 2 2h4v-2H5v-4zM5 5h4V3H5c-1.1 0-2 .9-2 2v4h2V5zm14-2h-4v2h4v4h2V5c0-1.1-.9-2-2-2zm0 16h-4v2h4c1.1 0 2-.9 2-2v-4h-2v4zM12 8c-2.21 0-4 1.79-4 4s1.79 4 4 4 4-1.79 4-4-1.79-4-4-4zm0 6c-1.1 0-2-.9-2-2s.9-2 2-2 2 .9 2 2-.9 2-2 2z"></path></g>
<g id="collections"><path d="M22 16V4c0-1.1-.9-2-2-2H8c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2zm-11-4l2.03 2.71L16 11l4 5H8l3-4zM2 6v14c0 1.1.9 2 2 2h14v-2H4V6H2z"></path></g>
<g id="collections-bookmark"><path d="M4 6H2v14c0 1.1.9 2 2 2h14v-2H4V6zm16-4H8c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zm0 10l-2.5-1.5L15 12V4h5v8z"></path></g>
<g id="color-lens"><path d="M12 3c-4.97 0-9 4.03-9 9s4.03 9 9 9c.83 0 1.5-.67 1.5-1.5 0-.39-.15-.74-.39-1.01-.23-.26-.38-.61-.38-.99 0-.83.67-1.5 1.5-1.5H16c2.76 0 5-2.24 5-5 0-4.42-4.03-8-9-8zm-5.5 9c-.83 0-1.5-.67-1.5-1.5S5.67 9 6.5 9 8 9.67 8 10.5 7.33 12 6.5 12zm3-4C8.67 8 8 7.33 8 6.5S8.67 5 9.5 5s1.5.67 1.5 1.5S10.33 8 9.5 8zm5 0c-.83 0-1.5-.67-1.5-1.5S13.67 5 14.5 5s1.5.67 1.5 1.5S15.33 8 14.5 8zm3 4c-.83 0-1.5-.67-1.5-1.5S16.67 9 17.5 9s1.5.67 1.5 1.5-.67 1.5-1.5 1.5z"></path></g>
<g id="colorize"><path d="M20.71 5.63l-2.34-2.34c-.39-.39-1.02-.39-1.41 0l-3.12 3.12-1.93-1.91-1.41 1.41 1.42 1.42L3 16.25V21h4.75l8.92-8.92 1.42 1.42 1.41-1.41-1.92-1.92 3.12-3.12c.4-.4.4-1.03.01-1.42zM6.92 19L5 17.08l8.06-8.06 1.92 1.92L6.92 19z"></path></g>
<g id="compare"><path d="M10 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h5v2h2V1h-2v2zm0 15H5l5-6v6zm9-15h-5v2h5v13l-5-6v9h5c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2z"></path></g>
<g id="control-point"><path d="M13 7h-2v4H7v2h4v4h2v-4h4v-2h-4V7zm-1-5C6.49 2 2 6.49 2 12s4.49 10 10 10 10-4.49 10-10S17.51 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8z"></path></g>
<g id="control-point-duplicate"><path d="M16 8h-2v3h-3v2h3v3h2v-3h3v-2h-3zM2 12c0-2.79 1.64-5.2 4.01-6.32V3.52C2.52 4.76 0 8.09 0 12s2.52 7.24 6.01 8.48v-2.16C3.64 17.2 2 14.79 2 12zm13-9c-4.96 0-9 4.04-9 9s4.04 9 9 9 9-4.04 9-9-4.04-9-9-9zm0 16c-3.86 0-7-3.14-7-7s3.14-7 7-7 7 3.14 7 7-3.14 7-7 7z"></path></g>
<g id="crop"><path d="M17 15h2V7c0-1.1-.9-2-2-2H9v2h8v8zM7 17V1H5v4H1v2h4v10c0 1.1.9 2 2 2h10v4h2v-4h4v-2H7z"></path></g>
<g id="crop-16-9"><path d="M19 6H5c-1.1 0-2 .9-2 2v8c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V8c0-1.1-.9-2-2-2zm0 10H5V8h14v8z"></path></g>
<g id="crop-3-2"><path d="M19 4H5c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm0 14H5V6h14v12z"></path></g>
<g id="crop-5-4"><path d="M19 5H5c-1.1 0-2 .9-2 2v10c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2zm0 12H5V7h14v10z"></path></g>
<g id="crop-7-5"><path d="M19 7H5c-1.1 0-2 .9-2 2v6c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V9c0-1.1-.9-2-2-2zm0 8H5V9h14v6z"></path></g>
<g id="crop-din"><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16H5V5h14v14z"></path></g>
<g id="crop-free"><path d="M3 5v4h2V5h4V3H5c-1.1 0-2 .9-2 2zm2 10H3v4c0 1.1.9 2 2 2h4v-2H5v-4zm14 4h-4v2h4c1.1 0 2-.9 2-2v-4h-2v4zm0-16h-4v2h4v4h2V5c0-1.1-.9-2-2-2z"></path></g>
<g id="crop-landscape"><path d="M19 5H5c-1.1 0-2 .9-2 2v10c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2zm0 12H5V7h14v10z"></path></g>
<g id="crop-original"><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16H5V5h14v14zm-5.04-6.71l-2.75 3.54-1.96-2.36L6.5 17h11l-3.54-4.71z"></path></g>
<g id="crop-portrait"><path d="M17 3H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h10c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16H7V5h10v14z"></path></g>
<g id="crop-rotate"><path d="M7.47 21.49C4.2 19.93 1.86 16.76 1.5 13H0c.51 6.16 5.66 11 11.95 11 .23 0 .44-.02.66-.03L8.8 20.15l-1.33 1.34zM12.05 0c-.23 0-.44.02-.66.04l3.81 3.81 1.33-1.33C19.8 4.07 22.14 7.24 22.5 11H24c-.51-6.16-5.66-11-11.95-11zM16 14h2V8c0-1.11-.9-2-2-2h-6v2h6v6zm-8 2V4H6v2H4v2h2v8c0 1.1.89 2 2 2h8v2h2v-2h2v-2H8z"></path></g>
<g id="crop-square"><path d="M18 4H6c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm0 14H6V6h12v12z"></path></g>
<g id="dehaze"><path d="M2 15.5v2h20v-2H2zm0-5v2h20v-2H2zm0-5v2h20v-2H2z"></path></g>
<g id="details"><path d="M3 4l9 16 9-16H3zm3.38 2h11.25L12 16 6.38 6z"></path></g>
<g id="edit"><path d="M3 17.25V21h3.75L17.81 9.94l-3.75-3.75L3 17.25zM20.71 7.04c.39-.39.39-1.02 0-1.41l-2.34-2.34c-.39-.39-1.02-.39-1.41 0l-1.83 1.83 3.75 3.75 1.83-1.83z"></path></g>
<g id="exposure"><path d="M15 17v2h2v-2h2v-2h-2v-2h-2v2h-2v2h2zm5-15H4c-1.1 0-2 .9-2 2v16c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zM5 5h6v2H5V5zm15 15H4L20 4v16z"></path></g>
<g id="exposure-neg-1"><path d="M4 11v2h8v-2H4zm15 7h-2V7.38L14 8.4V6.7L18.7 5h.3v13z"></path></g>
<g id="exposure-neg-2"><path d="M15.05 16.29l2.86-3.07c.38-.39.72-.79 1.04-1.18.32-.39.59-.78.82-1.17.23-.39.41-.78.54-1.17s.19-.79.19-1.18c0-.53-.09-1.02-.27-1.46-.18-.44-.44-.81-.78-1.11-.34-.31-.77-.54-1.26-.71-.51-.16-1.08-.24-1.72-.24-.69 0-1.31.11-1.85.32-.54.21-1 .51-1.36.88-.37.37-.65.8-.84 1.3-.18.47-.27.97-.28 1.5h2.14c.01-.31.05-.6.13-.87.09-.29.23-.54.4-.75.18-.21.41-.37.68-.49.27-.12.6-.18.96-.18.31 0 .58.05.81.15.23.1.43.25.59.43.16.18.28.4.37.65.08.25.13.52.13.81 0 .22-.03.43-.08.65-.06.22-.15.45-.29.7-.14.25-.32.53-.56.83-.23.3-.52.65-.88 1.03l-4.17 4.55V18H21v-1.71h-5.95zM2 11v2h8v-2H2z"></path></g>
<g id="exposure-plus-1"><path d="M10 7H8v4H4v2h4v4h2v-4h4v-2h-4V7zm10 11h-2V7.38L15 8.4V6.7L19.7 5h.3v13z"></path></g>
<g id="exposure-plus-2"><path d="M16.05 16.29l2.86-3.07c.38-.39.72-.79 1.04-1.18.32-.39.59-.78.82-1.17.23-.39.41-.78.54-1.17.13-.39.19-.79.19-1.18 0-.53-.09-1.02-.27-1.46-.18-.44-.44-.81-.78-1.11-.34-.31-.77-.54-1.26-.71-.51-.16-1.08-.24-1.72-.24-.69 0-1.31.11-1.85.32-.54.21-1 .51-1.36.88-.37.37-.65.8-.84 1.3-.18.47-.27.97-.28 1.5h2.14c.01-.31.05-.6.13-.87.09-.29.23-.54.4-.75.18-.21.41-.37.68-.49.27-.12.6-.18.96-.18.31 0 .58.05.81.15.23.1.43.25.59.43.16.18.28.4.37.65.08.25.13.52.13.81 0 .22-.03.43-.08.65-.06.22-.15.45-.29.7-.14.25-.32.53-.56.83-.23.3-.52.65-.88 1.03l-4.17 4.55V18H22v-1.71h-5.95zM8 7H6v4H2v2h4v4h2v-4h4v-2H8V7z"></path></g>
<g id="exposure-zero"><path d="M16.14 12.5c0 1-.1 1.85-.3 2.55-.2.7-.48 1.27-.83 1.7-.36.44-.79.75-1.3.95-.51.2-1.07.3-1.7.3-.62 0-1.18-.1-1.69-.3-.51-.2-.95-.51-1.31-.95-.36-.44-.65-1.01-.85-1.7-.2-.7-.3-1.55-.3-2.55v-2.04c0-1 .1-1.85.3-2.55.2-.7.48-1.26.84-1.69.36-.43.8-.74 1.31-.93C10.81 5.1 11.38 5 12 5c.63 0 1.19.1 1.7.29.51.19.95.5 1.31.93.36.43.64.99.84 1.69.2.7.3 1.54.3 2.55v2.04zm-2.11-2.36c0-.64-.05-1.18-.13-1.62-.09-.44-.22-.79-.4-1.06-.17-.27-.39-.46-.64-.58-.25-.13-.54-.19-.86-.19-.32 0-.61.06-.86.18s-.47.31-.64.58c-.17.27-.31.62-.4 1.06s-.13.98-.13 1.62v2.67c0 .64.05 1.18.14 1.62.09.45.23.81.4 1.09s.39.48.64.61.54.19.87.19c.33 0 .62-.06.87-.19s.46-.33.63-.61c.17-.28.3-.64.39-1.09.09-.45.13-.99.13-1.62v-2.66z"></path></g>
<g id="filter"><path d="M15.96 10.29l-2.75 3.54-1.96-2.36L8.5 15h11l-3.54-4.71zM3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm18-4H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14z"></path></g>
<g id="filter-1"><path d="M3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm11 10h2V5h-4v2h2v8zm7-14H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14z"></path></g>
<g id="filter-2"><path d="M3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm18-4H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14zm-4-4h-4v-2h2c1.1 0 2-.89 2-2V7c0-1.11-.9-2-2-2h-4v2h4v2h-2c-1.1 0-2 .89-2 2v4h6v-2z"></path></g>
<g id="filter-3"><path d="M21 1H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14zM3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm14 8v-1.5c0-.83-.67-1.5-1.5-1.5.83 0 1.5-.67 1.5-1.5V7c0-1.11-.9-2-2-2h-4v2h4v2h-2v2h2v2h-4v2h4c1.1 0 2-.89 2-2z"></path></g>
<g id="filter-4"><path d="M3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm12 10h2V5h-2v4h-2V5h-2v6h4v4zm6-14H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14z"></path></g>
<g id="filter-5"><path d="M21 1H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14zM3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm14 8v-2c0-1.11-.9-2-2-2h-2V7h4V5h-6v6h4v2h-4v2h4c1.1 0 2-.89 2-2z"></path></g>
<g id="filter-6"><path d="M3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm18-4H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14zm-8-2h2c1.1 0 2-.89 2-2v-2c0-1.11-.9-2-2-2h-2V7h4V5h-4c-1.1 0-2 .89-2 2v6c0 1.11.9 2 2 2zm0-4h2v2h-2v-2z"></path></g>
<g id="filter-7"><path d="M3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm18-4H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14zm-8-2l4-8V5h-6v2h4l-4 8h2z"></path></g>
<g id="filter-8"><path d="M3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm18-4H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14zm-8-2h2c1.1 0 2-.89 2-2v-1.5c0-.83-.67-1.5-1.5-1.5.83 0 1.5-.67 1.5-1.5V7c0-1.11-.9-2-2-2h-2c-1.1 0-2 .89-2 2v1.5c0 .83.67 1.5 1.5 1.5-.83 0-1.5.67-1.5 1.5V13c0 1.11.9 2 2 2zm0-8h2v2h-2V7zm0 4h2v2h-2v-2z"></path></g>
<g id="filter-9"><path d="M3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm18-4H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14zM15 5h-2c-1.1 0-2 .89-2 2v2c0 1.11.9 2 2 2h2v2h-4v2h4c1.1 0 2-.89 2-2V7c0-1.11-.9-2-2-2zm0 4h-2V7h2v2z"></path></g>
<g id="filter-9-plus"><path d="M3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm11 7V8c0-1.11-.9-2-2-2h-1c-1.1 0-2 .89-2 2v1c0 1.11.9 2 2 2h1v1H9v2h3c1.1 0 2-.89 2-2zm-3-3V8h1v1h-1zm10-8H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 8h-2V7h-2v2h-2v2h2v2h2v-2h2v6H7V3h14v6z"></path></g>
<g id="filter-b-and-w"><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16l-7-8v8H5l7-8V5h7v14z"></path></g>
<g id="filter-center-focus"><path d="M5 15H3v4c0 1.1.9 2 2 2h4v-2H5v-4zM5 5h4V3H5c-1.1 0-2 .9-2 2v4h2V5zm14-2h-4v2h4v4h2V5c0-1.1-.9-2-2-2zm0 16h-4v2h4c1.1 0 2-.9 2-2v-4h-2v4zM12 9c-1.66 0-3 1.34-3 3s1.34 3 3 3 3-1.34 3-3-1.34-3-3-3z"></path></g>
<g id="filter-drama"><path d="M19.35 10.04C18.67 6.59 15.64 4 12 4 9.11 4 6.61 5.64 5.36 8.04 2.35 8.36 0 10.9 0 14c0 3.31 2.69 6 6 6h13c2.76 0 5-2.24 5-5 0-2.64-2.05-4.78-4.65-4.96zM19 18H6c-2.21 0-4-1.79-4-4s1.79-4 4-4 4 1.79 4 4h2c0-2.76-1.86-5.08-4.4-5.78C8.61 6.88 10.2 6 12 6c3.03 0 5.5 2.47 5.5 5.5v.5H19c1.65 0 3 1.35 3 3s-1.35 3-3 3z"></path></g>
<g id="filter-frames"><path d="M20 4h-4l-4-4-4 4H4c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm0 16H4V6h4.52l3.52-3.5L15.52 6H20v14zM18 8H6v10h12"></path></g>
<g id="filter-hdr"><path d="M14 6l-3.75 5 2.85 3.8-1.6 1.2C9.81 13.75 7 10 7 10l-6 8h22L14 6z"></path></g>
<g id="filter-none"><path d="M3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm18-4H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14z"></path></g>
<g id="filter-tilt-shift"><path d="M11 4.07V2.05c-2.01.2-3.84 1-5.32 2.21L7.1 5.69c1.11-.86 2.44-1.44 3.9-1.62zm7.32.19C16.84 3.05 15.01 2.25 13 2.05v2.02c1.46.18 2.79.76 3.9 1.62l1.42-1.43zM19.93 11h2.02c-.2-2.01-1-3.84-2.21-5.32L18.31 7.1c.86 1.11 1.44 2.44 1.62 3.9zM5.69 7.1L4.26 5.68C3.05 7.16 2.25 8.99 2.05 11h2.02c.18-1.46.76-2.79 1.62-3.9zM4.07 13H2.05c.2 2.01 1 3.84 2.21 5.32l1.43-1.43c-.86-1.1-1.44-2.43-1.62-3.89zM15 12c0-1.66-1.34-3-3-3s-3 1.34-3 3 1.34 3 3 3 3-1.34 3-3zm3.31 4.9l1.43 1.43c1.21-1.48 2.01-3.32 2.21-5.32h-2.02c-.18 1.45-.76 2.78-1.62 3.89zM13 19.93v2.02c2.01-.2 3.84-1 5.32-2.21l-1.43-1.43c-1.1.86-2.43 1.44-3.89 1.62zm-7.32-.19C7.16 20.95 9 21.75 11 21.95v-2.02c-1.46-.18-2.79-.76-3.9-1.62l-1.42 1.43z"></path></g>
<g id="filter-vintage"><path d="M18.7 12.4c-.28-.16-.57-.29-.86-.4.29-.11.58-.24.86-.4 1.92-1.11 2.99-3.12 3-5.19-1.79-1.03-4.07-1.11-6 0-.28.16-.54.35-.78.54.05-.31.08-.63.08-.95 0-2.22-1.21-4.15-3-5.19C10.21 1.85 9 3.78 9 6c0 .32.03.64.08.95-.24-.2-.5-.39-.78-.55-1.92-1.11-4.2-1.03-6 0 0 2.07 1.07 4.08 3 5.19.28.16.57.29.86.4-.29.11-.58.24-.86.4-1.92 1.11-2.99 3.12-3 5.19 1.79 1.03 4.07 1.11 6 0 .28-.16.54-.35.78-.54-.05.32-.08.64-.08.96 0 2.22 1.21 4.15 3 5.19 1.79-1.04 3-2.97 3-5.19 0-.32-.03-.64-.08-.95.24.2.5.38.78.54 1.92 1.11 4.2 1.03 6 0-.01-2.07-1.08-4.08-3-5.19zM12 16c-2.21 0-4-1.79-4-4s1.79-4 4-4 4 1.79 4 4-1.79 4-4 4z"></path></g>
<g id="flare"><path d="M7 11H1v2h6v-2zm2.17-3.24L7.05 5.64 5.64 7.05l2.12 2.12 1.41-1.41zM13 1h-2v6h2V1zm5.36 6.05l-1.41-1.41-2.12 2.12 1.41 1.41 2.12-2.12zM17 11v2h6v-2h-6zm-5-2c-1.66 0-3 1.34-3 3s1.34 3 3 3 3-1.34 3-3-1.34-3-3-3zm2.83 7.24l2.12 2.12 1.41-1.41-2.12-2.12-1.41 1.41zm-9.19.71l1.41 1.41 2.12-2.12-1.41-1.41-2.12 2.12zM11 23h2v-6h-2v6z"></path></g>
<g id="flash-auto"><path d="M3 2v12h3v9l7-12H9l4-9H3zm16 0h-2l-3.2 9h1.9l.7-2h3.2l.7 2h1.9L19 2zm-2.15 5.65L18 4l1.15 3.65h-2.3z"></path></g>
<g id="flash-off"><path d="M3.27 3L2 4.27l5 5V13h3v9l3.58-6.14L17.73 20 19 18.73 3.27 3zM17 10h-4l4-8H7v2.18l8.46 8.46L17 10z"></path></g>
<g id="flash-on"><path d="M7 2v11h3v9l7-12h-4l4-8z"></path></g>
<g id="flip"><path d="M15 21h2v-2h-2v2zm4-12h2V7h-2v2zM3 5v14c0 1.1.9 2 2 2h4v-2H5V5h4V3H5c-1.1 0-2 .9-2 2zm16-2v2h2c0-1.1-.9-2-2-2zm-8 20h2V1h-2v22zm8-6h2v-2h-2v2zM15 5h2V3h-2v2zm4 8h2v-2h-2v2zm0 8c1.1 0 2-.9 2-2h-2v2z"></path></g>
<g id="gradient"><path d="M11 9h2v2h-2zm-2 2h2v2H9zm4 0h2v2h-2zm2-2h2v2h-2zM7 9h2v2H7zm12-6H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 18H7v-2h2v2zm4 0h-2v-2h2v2zm4 0h-2v-2h2v2zm2-7h-2v2h2v2h-2v-2h-2v2h-2v-2h-2v2H9v-2H7v2H5v-2h2v-2H5V5h14v6z"></path></g>
<g id="grain"><path d="M10 12c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zM6 8c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm0 8c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm12-8c1.1 0 2-.9 2-2s-.9-2-2-2-2 .9-2 2 .9 2 2 2zm-4 8c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm4-4c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm-4-4c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm-4-4c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2z"></path></g>
<g id="grid-off"><path d="M8 4v1.45l2 2V4h4v4h-3.45l2 2H14v1.45l2 2V10h4v4h-3.45l2 2H20v1.45l2 2V4c0-1.1-.9-2-2-2H4.55l2 2H8zm8 0h4v4h-4V4zM1.27 1.27L0 2.55l2 2V20c0 1.1.9 2 2 2h15.46l2 2 1.27-1.27L1.27 1.27zM10 12.55L11.45 14H10v-1.45zm-6-6L5.45 8H4V6.55zM8 20H4v-4h4v4zm0-6H4v-4h3.45l.55.55V14zm6 6h-4v-4h3.45l.55.54V20zm2 0v-1.46L17.46 20H16z"></path></g>
<g id="grid-on"><path d="M20 2H4c-1.1 0-2 .9-2 2v16c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zM8 20H4v-4h4v4zm0-6H4v-4h4v4zm0-6H4V4h4v4zm6 12h-4v-4h4v4zm0-6h-4v-4h4v4zm0-6h-4V4h4v4zm6 12h-4v-4h4v4zm0-6h-4v-4h4v4zm0-6h-4V4h4v4z"></path></g>
<g id="hdr-off"><path d="M17.5 15v-2h1.1l.9 2H21l-.9-2.1c.5-.2.9-.8.9-1.4v-1c0-.8-.7-1.5-1.5-1.5H16v4.9l1.1 1.1h.4zm0-4.5h2v1h-2v-1zm-4.5 0v.4l1.5 1.5v-1.9c0-.8-.7-1.5-1.5-1.5h-1.9l1.5 1.5h.4zm-3.5-1l-7-7-1.1 1L6.9 9h-.4v2h-2V9H3v6h1.5v-2.5h2V15H8v-4.9l1.5 1.5V15h3.4l7.6 7.6 1.1-1.1-12.1-12z"></path></g>
<g id="hdr-on"><path d="M21 11.5v-1c0-.8-.7-1.5-1.5-1.5H16v6h1.5v-2h1.1l.9 2H21l-.9-2.1c.5-.3.9-.8.9-1.4zm-1.5 0h-2v-1h2v1zm-13-.5h-2V9H3v6h1.5v-2.5h2V15H8V9H6.5v2zM13 9H9.5v6H13c.8 0 1.5-.7 1.5-1.5v-3c0-.8-.7-1.5-1.5-1.5zm0 4.5h-2v-3h2v3z"></path></g>
<g id="hdr-strong"><path d="M17 6c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zM5 8c-2.21 0-4 1.79-4 4s1.79 4 4 4 4-1.79 4-4-1.79-4-4-4zm0 6c-1.1 0-2-.9-2-2s.9-2 2-2 2 .9 2 2-.9 2-2 2z"></path></g>
<g id="hdr-weak"><path d="M5 8c-2.21 0-4 1.79-4 4s1.79 4 4 4 4-1.79 4-4-1.79-4-4-4zm12-2c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm0 10c-2.21 0-4-1.79-4-4s1.79-4 4-4 4 1.79 4 4-1.79 4-4 4z"></path></g>
<g id="healing"><path d="M17.73 12.02l3.98-3.98c.39-.39.39-1.02 0-1.41l-4.34-4.34c-.39-.39-1.02-.39-1.41 0l-3.98 3.98L8 2.29C7.8 2.1 7.55 2 7.29 2c-.25 0-.51.1-.7.29L2.25 6.63c-.39.39-.39 1.02 0 1.41l3.98 3.98L2.25 16c-.39.39-.39 1.02 0 1.41l4.34 4.34c.39.39 1.02.39 1.41 0l3.98-3.98 3.98 3.98c.2.2.45.29.71.29.26 0 .51-.1.71-.29l4.34-4.34c.39-.39.39-1.02 0-1.41l-3.99-3.98zM12 9c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm-4.71 1.96L3.66 7.34l3.63-3.63 3.62 3.62-3.62 3.63zM10 13c-.55 0-1-.45-1-1s.45-1 1-1 1 .45 1 1-.45 1-1 1zm2 2c-.55 0-1-.45-1-1s.45-1 1-1 1 .45 1 1-.45 1-1 1zm2-4c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm2.66 9.34l-3.63-3.62 3.63-3.63 3.62 3.62-3.62 3.63z"></path></g>
<g id="image"><path d="M21 19V5c0-1.1-.9-2-2-2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2zM8.5 13.5l2.5 3.01L14.5 12l4.5 6H5l3.5-4.5z"></path></g>
<g id="image-aspect-ratio"><path d="M16 10h-2v2h2v-2zm0 4h-2v2h2v-2zm-8-4H6v2h2v-2zm4 0h-2v2h2v-2zm8-6H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm0 14H4V6h16v12z"></path></g>
<g id="iso"><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM5.5 7.5h2v-2H9v2h2V9H9v2H7.5V9h-2V7.5zM19 19H5L19 5v14zm-2-2v-1.5h-5V17h5z"></path></g>
<g id="landscape"><path d="M14 6l-3.75 5 2.85 3.8-1.6 1.2C9.81 13.75 7 10 7 10l-6 8h22L14 6z"></path></g>
<g id="leak-add"><path d="M6 3H3v3c1.66 0 3-1.34 3-3zm8 0h-2c0 4.97-4.03 9-9 9v2c6.08 0 11-4.93 11-11zm-4 0H8c0 2.76-2.24 5-5 5v2c3.87 0 7-3.13 7-7zm0 18h2c0-4.97 4.03-9 9-9v-2c-6.07 0-11 4.93-11 11zm8 0h3v-3c-1.66 0-3 1.34-3 3zm-4 0h2c0-2.76 2.24-5 5-5v-2c-3.87 0-7 3.13-7 7z"></path></g>
<g id="leak-remove"><path d="M10 3H8c0 .37-.04.72-.12 1.06l1.59 1.59C9.81 4.84 10 3.94 10 3zM3 4.27l2.84 2.84C5.03 7.67 4.06 8 3 8v2c1.61 0 3.09-.55 4.27-1.46L8.7 9.97C7.14 11.24 5.16 12 3 12v2c2.71 0 5.19-.99 7.11-2.62l2.5 2.5C10.99 15.81 10 18.29 10 21h2c0-2.16.76-4.14 2.03-5.69l1.43 1.43C14.55 17.91 14 19.39 14 21h2c0-1.06.33-2.03.89-2.84L19.73 21 21 19.73 4.27 3 3 4.27zM14 3h-2c0 1.5-.37 2.91-1.02 4.16l1.46 1.46C13.42 6.98 14 5.06 14 3zm5.94 13.12c.34-.08.69-.12 1.06-.12v-2c-.94 0-1.84.19-2.66.52l1.6 1.6zm-4.56-4.56l1.46 1.46C18.09 12.37 19.5 12 21 12v-2c-2.06 0-3.98.58-5.62 1.56z"></path></g>
<g id="lens"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2z"></path></g>
<g id="linked-camera"><circle cx="12" cy="14" r="3.2"></circle><path d="M16 3.33c2.58 0 4.67 2.09 4.67 4.67H22c0-3.31-2.69-6-6-6v1.33M16 6c1.11 0 2 .89 2 2h1.33c0-1.84-1.49-3.33-3.33-3.33V6"></path><path d="M17 9c0-1.11-.89-2-2-2V4H9L7.17 6H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V9h-5zm-5 10c-2.76 0-5-2.24-5-5s2.24-5 5-5 5 2.24 5 5-2.24 5-5 5z"></path></g>
<g id="looks"><path d="M12 10c-3.86 0-7 3.14-7 7h2c0-2.76 2.24-5 5-5s5 2.24 5 5h2c0-3.86-3.14-7-7-7zm0-4C5.93 6 1 10.93 1 17h2c0-4.96 4.04-9 9-9s9 4.04 9 9h2c0-6.07-4.93-11-11-11z"></path></g>
<g id="looks-3"><path d="M19.01 3h-14c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-4 7.5c0 .83-.67 1.5-1.5 1.5.83 0 1.5.67 1.5 1.5V15c0 1.11-.9 2-2 2h-4v-2h4v-2h-2v-2h2V9h-4V7h4c1.1 0 2 .89 2 2v1.5z"></path></g>
<g id="looks-4"><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-4 14h-2v-4H9V7h2v4h2V7h2v10z"></path></g>
<g id="looks-5"><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-4 6h-4v2h2c1.1 0 2 .89 2 2v2c0 1.11-.9 2-2 2H9v-2h4v-2H9V7h6v2z"></path></g>
<g id="looks-6"><path d="M11 15h2v-2h-2v2zm8-12H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-4 6h-4v2h2c1.1 0 2 .89 2 2v2c0 1.11-.9 2-2 2h-2c-1.1 0-2-.89-2-2V9c0-1.11.9-2 2-2h4v2z"></path></g>
<g id="looks-one"><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-5 14h-2V9h-2V7h4v10z"></path></g>
<g id="looks-two"><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-4 8c0 1.11-.9 2-2 2h-2v2h4v2H9v-4c0-1.11.9-2 2-2h2V9H9V7h4c1.1 0 2 .89 2 2v2z"></path></g>
<g id="loupe"><path d="M13 7h-2v4H7v2h4v4h2v-4h4v-2h-4V7zm-1-5C6.49 2 2 6.49 2 12s4.49 10 10 10h8c1.1 0 2-.9 2-2v-8c0-5.51-4.49-10-10-10zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8z"></path></g>
<g id="monochrome-photos"><path d="M20 5h-3.2L15 3H9L7.2 5H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2zm0 14h-8v-1c-2.8 0-5-2.2-5-5s2.2-5 5-5V7h8v12zm-3-6c0-2.8-2.2-5-5-5v1.8c1.8 0 3.2 1.4 3.2 3.2s-1.4 3.2-3.2 3.2V18c2.8 0 5-2.2 5-5zm-8.2 0c0 1.8 1.4 3.2 3.2 3.2V9.8c-1.8 0-3.2 1.4-3.2 3.2z"></path></g>
<g id="movie-creation"><path d="M18 4l2 4h-3l-2-4h-2l2 4h-3l-2-4H8l2 4H7L5 4H4c-1.1 0-1.99.9-1.99 2L2 18c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V4h-4z"></path></g>
<g id="movie-filter"><path d="M18 4l2 3h-3l-2-3h-2l2 3h-3l-2-3H8l2 3H7L5 4H4c-1.1 0-1.99.9-1.99 2L2 18c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V4h-4zm-6.75 11.25L10 18l-1.25-2.75L6 14l2.75-1.25L10 10l1.25 2.75L14 14l-2.75 1.25zm5.69-3.31L16 14l-.94-2.06L13 11l2.06-.94L16 8l.94 2.06L19 11l-2.06.94z"></path></g>
<g id="music-note"><path d="M12 3v10.55c-.59-.34-1.27-.55-2-.55-2.21 0-4 1.79-4 4s1.79 4 4 4 4-1.79 4-4V7h4V3h-6z"></path></g>
<g id="nature"><path d="M13 16.12c3.47-.41 6.17-3.36 6.17-6.95 0-3.87-3.13-7-7-7s-7 3.13-7 7c0 3.47 2.52 6.34 5.83 6.89V20H5v2h14v-2h-6v-3.88z"></path></g>
<g id="nature-people"><path d="M22.17 9.17c0-3.87-3.13-7-7-7s-7 3.13-7 7c0 3.47 2.52 6.34 5.83 6.89V20H6v-3h1v-4c0-.55-.45-1-1-1H3c-.55 0-1 .45-1 1v4h1v5h16v-2h-3v-3.88c3.47-.41 6.17-3.36 6.17-6.95zM4.5 11c.83 0 1.5-.67 1.5-1.5S5.33 8 4.5 8 3 8.67 3 9.5 3.67 11 4.5 11z"></path></g>
<g id="navigate-before"><path d="M15.41 7.41L14 6l-6 6 6 6 1.41-1.41L10.83 12z"></path></g>
<g id="navigate-next"><path d="M10 6L8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z"></path></g>
<g id="palette"><path d="M12 3c-4.97 0-9 4.03-9 9s4.03 9 9 9c.83 0 1.5-.67 1.5-1.5 0-.39-.15-.74-.39-1.01-.23-.26-.38-.61-.38-.99 0-.83.67-1.5 1.5-1.5H16c2.76 0 5-2.24 5-5 0-4.42-4.03-8-9-8zm-5.5 9c-.83 0-1.5-.67-1.5-1.5S5.67 9 6.5 9 8 9.67 8 10.5 7.33 12 6.5 12zm3-4C8.67 8 8 7.33 8 6.5S8.67 5 9.5 5s1.5.67 1.5 1.5S10.33 8 9.5 8zm5 0c-.83 0-1.5-.67-1.5-1.5S13.67 5 14.5 5s1.5.67 1.5 1.5S15.33 8 14.5 8zm3 4c-.83 0-1.5-.67-1.5-1.5S16.67 9 17.5 9s1.5.67 1.5 1.5-.67 1.5-1.5 1.5z"></path></g>
<g id="panorama"><path d="M23 18V6c0-1.1-.9-2-2-2H3c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2zM8.5 12.5l2.5 3.01L14.5 11l4.5 6H5l3.5-4.5z"></path></g>
<g id="panorama-fish-eye"><path d="M12 2C6.47 2 2 6.47 2 12s4.47 10 10 10 10-4.47 10-10S17.53 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8z"></path></g>
<g id="panorama-horizontal"><path d="M20 6.54v10.91c-2.6-.77-5.28-1.16-8-1.16-2.72 0-5.4.39-8 1.16V6.54c2.6.77 5.28 1.16 8 1.16 2.72.01 5.4-.38 8-1.16M21.43 4c-.1 0-.2.02-.31.06C18.18 5.16 15.09 5.7 12 5.7c-3.09 0-6.18-.55-9.12-1.64-.11-.04-.22-.06-.31-.06-.34 0-.57.23-.57.63v14.75c0 .39.23.62.57.62.1 0 .2-.02.31-.06 2.94-1.1 6.03-1.64 9.12-1.64 3.09 0 6.18.55 9.12 1.64.11.04.21.06.31.06.33 0 .57-.23.57-.63V4.63c0-.4-.24-.63-.57-.63z"></path></g>
<g id="panorama-vertical"><path d="M19.94 21.12c-1.1-2.94-1.64-6.03-1.64-9.12 0-3.09.55-6.18 1.64-9.12.04-.11.06-.22.06-.31 0-.34-.23-.57-.63-.57H4.63c-.4 0-.63.23-.63.57 0 .1.02.2.06.31C5.16 5.82 5.71 8.91 5.71 12c0 3.09-.55 6.18-1.64 9.12-.05.11-.07.22-.07.31 0 .33.23.57.63.57h14.75c.39 0 .63-.24.63-.57-.01-.1-.03-.2-.07-.31zM6.54 20c.77-2.6 1.16-5.28 1.16-8 0-2.72-.39-5.4-1.16-8h10.91c-.77 2.6-1.16 5.28-1.16 8 0 2.72.39 5.4 1.16 8H6.54z"></path></g>
<g id="panorama-wide-angle"><path d="M12 6c2.45 0 4.71.2 7.29.64.47 1.78.71 3.58.71 5.36 0 1.78-.24 3.58-.71 5.36-2.58.44-4.84.64-7.29.64s-4.71-.2-7.29-.64C4.24 15.58 4 13.78 4 12c0-1.78.24-3.58.71-5.36C7.29 6.2 9.55 6 12 6m0-2c-2.73 0-5.22.24-7.95.72l-.93.16-.25.9C2.29 7.85 2 9.93 2 12s.29 4.15.87 6.22l.25.89.93.16c2.73.49 5.22.73 7.95.73s5.22-.24 7.95-.72l.93-.16.25-.89c.58-2.08.87-4.16.87-6.23s-.29-4.15-.87-6.22l-.25-.89-.93-.16C17.22 4.24 14.73 4 12 4z"></path></g>
<g id="photo"><path d="M21 19V5c0-1.1-.9-2-2-2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2zM8.5 13.5l2.5 3.01L14.5 12l4.5 6H5l3.5-4.5z"></path></g>
<g id="photo-album"><path d="M18 2H6c-1.1 0-2 .9-2 2v16c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zM6 4h5v8l-2.5-1.5L6 12V4zm0 15l3-3.86 2.14 2.58 3-3.86L18 19H6z"></path></g>
<g id="photo-camera"><circle cx="12" cy="12" r="3.2"></circle><path d="M9 2L7.17 4H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2h-3.17L15 2H9zm3 15c-2.76 0-5-2.24-5-5s2.24-5 5-5 5 2.24 5 5-2.24 5-5 5z"></path></g>
<g id="photo-filter"><path d="M19.02 10v9H5V5h9V3H5.02c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2v-9h-2zM17 10l.94-2.06L20 7l-2.06-.94L17 4l-.94 2.06L14 7l2.06.94zm-3.75.75L12 8l-1.25 2.75L8 12l2.75 1.25L12 16l1.25-2.75L16 12z"></path></g>
<g id="photo-library"><path d="M22 16V4c0-1.1-.9-2-2-2H8c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2zm-11-4l2.03 2.71L16 11l4 5H8l3-4zM2 6v14c0 1.1.9 2 2 2h14v-2H4V6H2z"></path></g>
<g id="photo-size-select-actual"><path d="M21 3H3C2 3 1 4 1 5v14c0 1.1.9 2 2 2h18c1 0 2-1 2-2V5c0-1-1-2-2-2zM5 17l3.5-4.5 2.5 3.01L14.5 11l4.5 6H5z"></path></g>
<g id="photo-size-select-large"><path d="M21 15h2v2h-2v-2zm0-4h2v2h-2v-2zm2 8h-2v2c1 0 2-1 2-2zM13 3h2v2h-2V3zm8 4h2v2h-2V7zm0-4v2h2c0-1-1-2-2-2zM1 7h2v2H1V7zm16-4h2v2h-2V3zm0 16h2v2h-2v-2zM3 3C2 3 1 4 1 5h2V3zm6 0h2v2H9V3zM5 3h2v2H5V3zm-4 8v8c0 1.1.9 2 2 2h12V11H1zm2 8l2.5-3.21 1.79 2.15 2.5-3.22L13 19H3z"></path></g>
<g id="photo-size-select-small"><path d="M23 15h-2v2h2v-2zm0-4h-2v2h2v-2zm0 8h-2v2c1 0 2-1 2-2zM15 3h-2v2h2V3zm8 4h-2v2h2V7zm-2-4v2h2c0-1-1-2-2-2zM3 21h8v-6H1v4c0 1.1.9 2 2 2zM3 7H1v2h2V7zm12 12h-2v2h2v-2zm4-16h-2v2h2V3zm0 16h-2v2h2v-2zM3 3C2 3 1 4 1 5h2V3zm0 8H1v2h2v-2zm8-8H9v2h2V3zM7 3H5v2h2V3z"></path></g>
<g id="picture-as-pdf"><path d="M20 2H8c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zm-8.5 7.5c0 .83-.67 1.5-1.5 1.5H9v2H7.5V7H10c.83 0 1.5.67 1.5 1.5v1zm5 2c0 .83-.67 1.5-1.5 1.5h-2.5V7H15c.83 0 1.5.67 1.5 1.5v3zm4-3H19v1h1.5V11H19v2h-1.5V7h3v1.5zM9 9.5h1v-1H9v1zM4 6H2v14c0 1.1.9 2 2 2h14v-2H4V6zm10 5.5h1v-3h-1v3z"></path></g>
<g id="portrait"><path d="M12 12.25c1.24 0 2.25-1.01 2.25-2.25S13.24 7.75 12 7.75 9.75 8.76 9.75 10s1.01 2.25 2.25 2.25zm4.5 4c0-1.5-3-2.25-4.5-2.25s-4.5.75-4.5 2.25V17h9v-.75zM19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16H5V5h14v14z"></path></g>
<g id="remove-red-eye"><path d="M12 4.5C7 4.5 2.73 7.61 1 12c1.73 4.39 6 7.5 11 7.5s9.27-3.11 11-7.5c-1.73-4.39-6-7.5-11-7.5zM12 17c-2.76 0-5-2.24-5-5s2.24-5 5-5 5 2.24 5 5-2.24 5-5 5zm0-8c-1.66 0-3 1.34-3 3s1.34 3 3 3 3-1.34 3-3-1.34-3-3-3z"></path></g>
<g id="rotate-90-degrees-ccw"><path d="M7.34 6.41L.86 12.9l6.49 6.48 6.49-6.48-6.5-6.49zM3.69 12.9l3.66-3.66L11 12.9l-3.66 3.66-3.65-3.66zm15.67-6.26C17.61 4.88 15.3 4 13 4V.76L8.76 5 13 9.24V6c1.79 0 3.58.68 4.95 2.05 2.73 2.73 2.73 7.17 0 9.9C16.58 19.32 14.79 20 13 20c-.97 0-1.94-.21-2.84-.61l-1.49 1.49C10.02 21.62 11.51 22 13 22c2.3 0 4.61-.88 6.36-2.64 3.52-3.51 3.52-9.21 0-12.72z"></path></g>
<g id="rotate-left"><path d="M7.11 8.53L5.7 7.11C4.8 8.27 4.24 9.61 4.07 11h2.02c.14-.87.49-1.72 1.02-2.47zM6.09 13H4.07c.17 1.39.72 2.73 1.62 3.89l1.41-1.42c-.52-.75-.87-1.59-1.01-2.47zm1.01 5.32c1.16.9 2.51 1.44 3.9 1.61V17.9c-.87-.15-1.71-.49-2.46-1.03L7.1 18.32zM13 4.07V1L8.45 5.55 13 10V6.09c2.84.48 5 2.94 5 5.91s-2.16 5.43-5 5.91v2.02c3.95-.49 7-3.85 7-7.93s-3.05-7.44-7-7.93z"></path></g>
<g id="rotate-right"><path d="M15.55 5.55L11 1v3.07C7.06 4.56 4 7.92 4 12s3.05 7.44 7 7.93v-2.02c-2.84-.48-5-2.94-5-5.91s2.16-5.43 5-5.91V10l4.55-4.45zM19.93 11c-.17-1.39-.72-2.73-1.62-3.89l-1.42 1.42c.54.75.88 1.6 1.02 2.47h2.02zM13 17.9v2.02c1.39-.17 2.74-.71 3.9-1.61l-1.44-1.44c-.75.54-1.59.89-2.46 1.03zm3.89-2.42l1.42 1.41c.9-1.16 1.45-2.5 1.62-3.89h-2.02c-.14.87-.48 1.72-1.02 2.48z"></path></g>
<g id="slideshow"><path d="M10 8v8l5-4-5-4zm9-5H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16H5V5h14v14z"></path></g>
<g id="straighten"><path d="M21 6H3c-1.1 0-2 .9-2 2v8c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2V8c0-1.1-.9-2-2-2zm0 10H3V8h2v4h2V8h2v4h2V8h2v4h2V8h2v4h2V8h2v8z"></path></g>
<g id="style"><path d="M2.53 19.65l1.34.56v-9.03l-2.43 5.86c-.41 1.02.08 2.19 1.09 2.61zm19.5-3.7L17.07 3.98c-.31-.75-1.04-1.21-1.81-1.23-.26 0-.53.04-.79.15L7.1 5.95c-.75.31-1.21 1.03-1.23 1.8-.01.27.04.54.15.8l4.96 11.97c.31.76 1.05 1.22 1.83 1.23.26 0 .52-.05.77-.15l7.36-3.05c1.02-.42 1.51-1.59 1.09-2.6zM7.88 8.75c-.55 0-1-.45-1-1s.45-1 1-1 1 .45 1 1-.45 1-1 1zm-2 11c0 1.1.9 2 2 2h1.45l-3.45-8.34v6.34z"></path></g>
<g id="switch-camera"><path d="M20 4h-3.17L15 2H9L7.17 4H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm-5 11.5V13H9v2.5L5.5 12 9 8.5V11h6V8.5l3.5 3.5-3.5 3.5z"></path></g>
<g id="switch-video"><path d="M18 9.5V6c0-.55-.45-1-1-1H3c-.55 0-1 .45-1 1v12c0 .55.45 1 1 1h14c.55 0 1-.45 1-1v-3.5l4 4v-13l-4 4zm-5 6V13H7v2.5L3.5 12 7 8.5V11h6V8.5l3.5 3.5-3.5 3.5z"></path></g>
<g id="tag-faces"><path d="M11.99 2C6.47 2 2 6.48 2 12s4.47 10 9.99 10C17.52 22 22 17.52 22 12S17.52 2 11.99 2zM12 20c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8zm3.5-9c.83 0 1.5-.67 1.5-1.5S16.33 8 15.5 8 14 8.67 14 9.5s.67 1.5 1.5 1.5zm-7 0c.83 0 1.5-.67 1.5-1.5S9.33 8 8.5 8 7 8.67 7 9.5 7.67 11 8.5 11zm3.5 6.5c2.33 0 4.31-1.46 5.11-3.5H6.89c.8 2.04 2.78 3.5 5.11 3.5z"></path></g>
<g id="texture"><path d="M19.51 3.08L3.08 19.51c.09.34.27.65.51.9.25.24.56.42.9.51L20.93 4.49c-.19-.69-.73-1.23-1.42-1.41zM11.88 3L3 11.88v2.83L14.71 3h-2.83zM5 3c-1.1 0-2 .9-2 2v2l4-4H5zm14 18c.55 0 1.05-.22 1.41-.59.37-.36.59-.86.59-1.41v-2l-4 4h2zm-9.71 0h2.83L21 12.12V9.29L9.29 21z"></path></g>
<g id="timelapse"><path d="M16.24 7.76C15.07 6.59 13.54 6 12 6v6l-4.24 4.24c2.34 2.34 6.14 2.34 8.49 0 2.34-2.34 2.34-6.14-.01-8.48zM12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8z"></path></g>
<g id="timer"><path d="M15 1H9v2h6V1zm-4 13h2V8h-2v6zm8.03-6.61l1.42-1.42c-.43-.51-.9-.99-1.41-1.41l-1.42 1.42C16.07 4.74 14.12 4 12 4c-4.97 0-9 4.03-9 9s4.02 9 9 9 9-4.03 9-9c0-2.12-.74-4.07-1.97-5.61zM12 20c-3.87 0-7-3.13-7-7s3.13-7 7-7 7 3.13 7 7-3.13 7-7 7z"></path></g>
<g id="timer-10"><path d="M0 7.72V9.4l3-1V18h2V6h-.25L0 7.72zm23.78 6.65c-.14-.28-.35-.53-.63-.74-.28-.21-.61-.39-1.01-.53s-.85-.27-1.35-.38c-.35-.07-.64-.15-.87-.23-.23-.08-.41-.16-.55-.25-.14-.09-.23-.19-.28-.3-.05-.11-.08-.24-.08-.39 0-.14.03-.28.09-.41.06-.13.15-.25.27-.34.12-.1.27-.18.45-.24s.4-.09.64-.09c.25 0 .47.04.66.11.19.07.35.17.48.29.13.12.22.26.29.42.06.16.1.32.1.49h1.95c0-.39-.08-.75-.24-1.09-.16-.34-.39-.63-.69-.88-.3-.25-.66-.44-1.09-.59C21.49 9.07 21 9 20.46 9c-.51 0-.98.07-1.39.21-.41.14-.77.33-1.06.57-.29.24-.51.52-.67.84-.16.32-.23.65-.23 1.01s.08.69.23.96c.15.28.36.52.64.73.27.21.6.38.98.53.38.14.81.26 1.27.36.39.08.71.17.95.26s.43.19.57.29c.13.1.22.22.27.34.05.12.07.25.07.39 0 .32-.13.57-.4.77-.27.2-.66.29-1.17.29-.22 0-.43-.02-.64-.08-.21-.05-.4-.13-.56-.24-.17-.11-.3-.26-.41-.44-.11-.18-.17-.41-.18-.67h-1.89c0 .36.08.71.24 1.05.16.34.39.65.7.93.31.27.69.49 1.15.66.46.17.98.25 1.58.25.53 0 1.01-.06 1.44-.19.43-.13.8-.31 1.11-.54.31-.23.54-.51.71-.83.17-.32.25-.67.25-1.06-.02-.4-.09-.74-.24-1.02zm-9.96-7.32c-.34-.4-.75-.7-1.23-.88-.47-.18-1.01-.27-1.59-.27-.58 0-1.11.09-1.59.27-.48.18-.89.47-1.23.88-.34.41-.6.93-.79 1.59-.18.65-.28 1.45-.28 2.39v1.92c0 .94.09 1.74.28 2.39.19.66.45 1.19.8 1.6.34.41.75.71 1.23.89.48.18 1.01.28 1.59.28.59 0 1.12-.09 1.59-.28.48-.18.88-.48 1.22-.89.34-.41.6-.94.78-1.6.18-.65.28-1.45.28-2.39v-1.92c0-.94-.09-1.74-.28-2.39-.18-.66-.44-1.19-.78-1.59zm-.92 6.17c0 .6-.04 1.11-.12 1.53-.08.42-.2.76-.36 1.02-.16.26-.36.45-.59.57-.23.12-.51.18-.82.18-.3 0-.58-.06-.82-.18s-.44-.31-.6-.57c-.16-.26-.29-.6-.38-1.02-.09-.42-.13-.93-.13-1.53v-2.5c0-.6.04-1.11.13-1.52.09-.41.21-.74.38-1 .16-.25.36-.43.6-.55.24-.11.51-.17.81-.17.31 0 .58.06.81.17.24.11.44.29.6.55.16.25.29.58.37.99.08.41.13.92.13 1.52v2.51z"></path></g>
<g id="timer-3"><path d="M11.61 12.97c-.16-.24-.36-.46-.62-.65-.25-.19-.56-.35-.93-.48.3-.14.57-.3.8-.5.23-.2.42-.41.57-.64.15-.23.27-.46.34-.71.08-.24.11-.49.11-.73 0-.55-.09-1.04-.28-1.46-.18-.42-.44-.77-.78-1.06-.33-.28-.73-.5-1.2-.64-.45-.13-.97-.2-1.53-.2-.55 0-1.06.08-1.52.24-.47.17-.87.4-1.2.69-.33.29-.6.63-.78 1.03-.2.39-.29.83-.29 1.29h1.98c0-.26.05-.49.14-.69.09-.2.22-.38.38-.52.17-.14.36-.25.58-.33.22-.08.46-.12.73-.12.61 0 1.06.16 1.36.47.3.31.44.75.44 1.32 0 .27-.04.52-.12.74-.08.22-.21.41-.38.57-.17.16-.38.28-.63.37-.25.09-.55.13-.89.13H6.72v1.57H7.9c.34 0 .64.04.91.11.27.08.5.19.69.35.19.16.34.36.44.61.1.24.16.54.16.87 0 .62-.18 1.09-.53 1.42-.35.33-.84.49-1.45.49-.29 0-.56-.04-.8-.13-.24-.08-.44-.2-.61-.36-.17-.16-.3-.34-.39-.56-.09-.22-.14-.46-.14-.72H4.19c0 .55.11 1.03.32 1.45.21.42.5.77.86 1.05s.77.49 1.24.63.96.21 1.48.21c.57 0 1.09-.08 1.58-.23.49-.15.91-.38 1.26-.68.36-.3.64-.66.84-1.1.2-.43.3-.93.3-1.48 0-.29-.04-.58-.11-.86-.08-.25-.19-.51-.35-.76zm9.26 1.4c-.14-.28-.35-.53-.63-.74-.28-.21-.61-.39-1.01-.53s-.85-.27-1.35-.38c-.35-.07-.64-.15-.87-.23-.23-.08-.41-.16-.55-.25-.14-.09-.23-.19-.28-.3-.05-.11-.08-.24-.08-.39s.03-.28.09-.41c.06-.13.15-.25.27-.34.12-.1.27-.18.45-.24s.4-.09.64-.09c.25 0 .47.04.66.11.19.07.35.17.48.29.13.12.22.26.29.42.06.16.1.32.1.49h1.95c0-.39-.08-.75-.24-1.09-.16-.34-.39-.63-.69-.88-.3-.25-.66-.44-1.09-.59-.43-.15-.92-.22-1.46-.22-.51 0-.98.07-1.39.21-.41.14-.77.33-1.06.57-.29.24-.51.52-.67.84-.16.32-.23.65-.23 1.01s.08.68.23.96c.15.28.37.52.64.73.27.21.6.38.98.53.38.14.81.26 1.27.36.39.08.71.17.95.26s.43.19.57.29c.13.1.22.22.27.34.05.12.07.25.07.39 0 .32-.13.57-.4.77-.27.2-.66.29-1.17.29-.22 0-.43-.02-.64-.08-.21-.05-.4-.13-.56-.24-.17-.11-.3-.26-.41-.44-.11-.18-.17-.41-.18-.67h-1.89c0 .36.08.71.24 1.05.16.34.39.65.7.93.31.27.69.49 1.15.66.46.17.98.25 1.58.25.53 0 1.01-.06 1.44-.19.43-.13.8-.31 1.11-.54.31-.23.54-.51.71-.83.17-.32.25-.67.25-1.06-.02-.4-.09-.74-.24-1.02z"></path></g>
<g id="timer-off"><path d="M19.04 4.55l-1.42 1.42C16.07 4.74 14.12 4 12 4c-1.83 0-3.53.55-4.95 1.48l1.46 1.46C9.53 6.35 10.73 6 12 6c3.87 0 7 3.13 7 7 0 1.27-.35 2.47-.94 3.49l1.45 1.45C20.45 16.53 21 14.83 21 13c0-2.12-.74-4.07-1.97-5.61l1.42-1.42-1.41-1.42zM15 1H9v2h6V1zm-4 8.44l2 2V8h-2v1.44zM3.02 4L1.75 5.27 4.5 8.03C3.55 9.45 3 11.16 3 13c0 4.97 4.02 9 9 9 1.84 0 3.55-.55 4.98-1.5l2.5 2.5 1.27-1.27-7.71-7.71L3.02 4zM12 20c-3.87 0-7-3.13-7-7 0-1.28.35-2.48.95-3.52l9.56 9.56c-1.03.61-2.23.96-3.51.96z"></path></g>
<g id="tonality"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm-1 17.93c-3.94-.49-7-3.85-7-7.93s3.05-7.44 7-7.93v15.86zm2-15.86c1.03.13 2 .45 2.87.93H13v-.93zM13 7h5.24c.25.31.48.65.68 1H13V7zm0 3h6.74c.08.33.15.66.19 1H13v-1zm0 9.93V19h2.87c-.87.48-1.84.8-2.87.93zM18.24 17H13v-1h5.92c-.2.35-.43.69-.68 1zm1.5-3H13v-1h6.93c-.04.34-.11.67-.19 1z"></path></g>
<g id="transform"><path d="M22 18v-2H8V4h2L7 1 4 4h2v2H2v2h4v8c0 1.1.9 2 2 2h8v2h-2l3 3 3-3h-2v-2h4zM10 8h6v6h2V8c0-1.1-.9-2-2-2h-6v2z"></path></g>
<g id="tune"><path d="M3 17v2h6v-2H3zM3 5v2h10V5H3zm10 16v-2h8v-2h-8v-2h-2v6h2zM7 9v2H3v2h4v2h2V9H7zm14 4v-2H11v2h10zm-6-4h2V7h4V5h-4V3h-2v6z"></path></g>
<g id="view-comfy"><path d="M3 9h4V5H3v4zm0 5h4v-4H3v4zm5 0h4v-4H8v4zm5 0h4v-4h-4v4zM8 9h4V5H8v4zm5-4v4h4V5h-4zm5 9h4v-4h-4v4zM3 19h4v-4H3v4zm5 0h4v-4H8v4zm5 0h4v-4h-4v4zm5 0h4v-4h-4v4zm0-14v4h4V5h-4z"></path></g>
<g id="view-compact"><path d="M3 19h6v-7H3v7zm7 0h12v-7H10v7zM3 5v6h19V5H3z"></path></g>
<g id="vignette"><path d="M21 3H3c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-9 15c-4.42 0-8-2.69-8-6s3.58-6 8-6 8 2.69 8 6-3.58 6-8 6z"></path></g>
<g id="wb-auto"><path d="M6.85 12.65h2.3L8 9l-1.15 3.65zM22 7l-1.2 6.29L19.3 7h-1.6l-1.49 6.29L15 7h-.76C12.77 5.17 10.53 4 8 4c-4.42 0-8 3.58-8 8s3.58 8 8 8c3.13 0 5.84-1.81 7.15-4.43l.1.43H17l1.5-6.1L20 16h1.75l2.05-9H22zm-11.7 9l-.7-2H6.4l-.7 2H3.8L7 7h2l3.2 9h-1.9z"></path></g>
<g id="wb-cloudy"><path d="M19.36 10.04C18.67 6.59 15.64 4 12 4 9.11 4 6.6 5.64 5.35 8.04 2.34 8.36 0 10.91 0 14c0 3.31 2.69 6 6 6h13c2.76 0 5-2.24 5-5 0-2.64-2.05-4.78-4.64-4.96z"></path></g>
<g id="wb-incandescent"><path d="M3.55 18.54l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8zM11 22.45h2V19.5h-2v2.95zM4 10.5H1v2h3v-2zm11-4.19V1.5H9v4.81C7.21 7.35 6 9.28 6 11.5c0 3.31 2.69 6 6 6s6-2.69 6-6c0-2.22-1.21-4.15-3-5.19zm5 4.19v2h3v-2h-3zm-2.76 7.66l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4z"></path></g>
<g id="wb-iridescent"><path d="M5 14.5h14v-6H5v6zM11 .55V3.5h2V.55h-2zm8.04 2.5l-1.79 1.79 1.41 1.41 1.8-1.79-1.42-1.41zM13 22.45V19.5h-2v2.95h2zm7.45-3.91l-1.8-1.79-1.41 1.41 1.79 1.8 1.42-1.42zM3.55 4.46l1.79 1.79 1.41-1.41-1.79-1.79-1.41 1.41zm1.41 15.49l1.79-1.8-1.41-1.41-1.79 1.79 1.41 1.42z"></path></g>
<g id="wb-sunny"><path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"></path></g>
</defs></svg>
</iron-iconset-svg>`;document.head.appendChild(ybe.content);var vbe=Q`<iron-iconset-svg name="icons" size="24">
<svg><defs>
<g id="3d-rotation"><path d="M7.52 21.48C4.25 19.94 1.91 16.76 1.55 13H.05C.56 19.16 5.71 24 12 24l.66-.03-3.81-3.81-1.33 1.32zm.89-6.52c-.19 0-.37-.03-.52-.08-.16-.06-.29-.13-.4-.24-.11-.1-.2-.22-.26-.37-.06-.14-.09-.3-.09-.47h-1.3c0 .36.07.68.21.95.14.27.33.5.56.69.24.18.51.32.82.41.3.1.62.15.96.15.37 0 .72-.05 1.03-.15.32-.1.6-.25.83-.44s.42-.43.55-.72c.13-.29.2-.61.2-.97 0-.19-.02-.38-.07-.56-.05-.18-.12-.35-.23-.51-.1-.16-.24-.3-.4-.43-.17-.13-.37-.23-.61-.31.2-.09.37-.2.52-.33.15-.13.27-.27.37-.42.1-.15.17-.3.22-.46.05-.16.07-.32.07-.48 0-.36-.06-.68-.18-.96-.12-.28-.29-.51-.51-.69-.2-.19-.47-.33-.77-.43C9.1 8.05 8.76 8 8.39 8c-.36 0-.69.05-1 .16-.3.11-.57.26-.79.45-.21.19-.38.41-.51.67-.12.26-.18.54-.18.85h1.3c0-.17.03-.32.09-.45s.14-.25.25-.34c.11-.09.23-.17.38-.22.15-.05.3-.08.48-.08.4 0 .7.1.89.31.19.2.29.49.29.86 0 .18-.03.34-.08.49-.05.15-.14.27-.25.37-.11.1-.25.18-.41.24-.16.06-.36.09-.58.09H7.5v1.03h.77c.22 0 .42.02.6.07s.33.13.45.23c.12.11.22.24.29.4.07.16.1.35.1.57 0 .41-.12.72-.35.93-.23.23-.55.33-.95.33zm8.55-5.92c-.32-.33-.7-.59-1.14-.77-.43-.18-.92-.27-1.46-.27H12v8h2.3c.55 0 1.06-.09 1.51-.27.45-.18.84-.43 1.16-.76.32-.33.57-.73.74-1.19.17-.47.26-.99.26-1.57v-.4c0-.58-.09-1.1-.26-1.57-.18-.47-.43-.87-.75-1.2zm-.39 3.16c0 .42-.05.79-.14 1.13-.1.33-.24.62-.43.85-.19.23-.43.41-.71.53-.29.12-.62.18-.99.18h-.91V9.12h.97c.72 0 1.27.23 1.64.69.38.46.57 1.12.57 1.99v.4zM12 0l-.66.03 3.81 3.81 1.33-1.33c3.27 1.55 5.61 4.72 5.96 8.48h1.5C23.44 4.84 18.29 0 12 0z"></path></g>
<g id="accessibility"><path d="M12 2c1.1 0 2 .9 2 2s-.9 2-2 2-2-.9-2-2 .9-2 2-2zm9 7h-6v13h-2v-6h-2v6H9V9H3V7h18v2z"></path></g>
<g id="accessible"><circle cx="12" cy="4" r="2"></circle><path d="M19 13v-2c-1.54.02-3.09-.75-4.07-1.83l-1.29-1.43c-.17-.19-.38-.34-.61-.45-.01 0-.01-.01-.02-.01H13c-.35-.2-.75-.3-1.19-.26C10.76 7.11 10 8.04 10 9.09V15c0 1.1.9 2 2 2h5v5h2v-5.5c0-1.1-.9-2-2-2h-3v-3.45c1.29 1.07 3.25 1.94 5 1.95zm-6.17 5c-.41 1.16-1.52 2-2.83 2-1.66 0-3-1.34-3-3 0-1.31.84-2.41 2-2.83V12.1c-2.28.46-4 2.48-4 4.9 0 2.76 2.24 5 5 5 2.42 0 4.44-1.72 4.9-4h-2.07z"></path></g>
<g id="account-balance"><path d="M4 10v7h3v-7H4zm6 0v7h3v-7h-3zM2 22h19v-3H2v3zm14-12v7h3v-7h-3zm-4.5-9L2 6v2h19V6l-9.5-5z"></path></g>
<g id="account-balance-wallet"><path d="M21 18v1c0 1.1-.9 2-2 2H5c-1.11 0-2-.9-2-2V5c0-1.1.89-2 2-2h14c1.1 0 2 .9 2 2v1h-9c-1.11 0-2 .9-2 2v8c0 1.1.89 2 2 2h9zm-9-2h10V8H12v8zm4-2.5c-.83 0-1.5-.67-1.5-1.5s.67-1.5 1.5-1.5 1.5.67 1.5 1.5-.67 1.5-1.5 1.5z"></path></g>
<g id="account-box"><path d="M3 5v14c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2H5c-1.11 0-2 .9-2 2zm12 4c0 1.66-1.34 3-3 3s-3-1.34-3-3 1.34-3 3-3 3 1.34 3 3zm-9 8c0-2 4-3.1 6-3.1s6 1.1 6 3.1v1H6v-1z"></path></g>
<g id="account-circle"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 3c1.66 0 3 1.34 3 3s-1.34 3-3 3-3-1.34-3-3 1.34-3 3-3zm0 14.2c-2.5 0-4.71-1.28-6-3.22.03-1.99 4-3.08 6-3.08 1.99 0 5.97 1.09 6 3.08-1.29 1.94-3.5 3.22-6 3.22z"></path></g>
<g id="add"><path d="M19 13h-6v6h-2v-6H5v-2h6V5h2v6h6v2z"></path></g>
<g id="add-alert"><path d="M10.01 21.01c0 1.1.89 1.99 1.99 1.99s1.99-.89 1.99-1.99h-3.98zm8.87-4.19V11c0-3.25-2.25-5.97-5.29-6.69v-.72C13.59 2.71 12.88 2 12 2s-1.59.71-1.59 1.59v.72C7.37 5.03 5.12 7.75 5.12 11v5.82L3 18.94V20h18v-1.06l-2.12-2.12zM16 13.01h-3v3h-2v-3H8V11h3V8h2v3h3v2.01z"></path></g>
<g id="add-box"><path d="M19 3H5c-1.11 0-2 .9-2 2v14c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-2 10h-4v4h-2v-4H7v-2h4V7h2v4h4v2z"></path></g>
<g id="add-circle"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm5 11h-4v4h-2v-4H7v-2h4V7h2v4h4v2z"></path></g>
<g id="add-circle-outline"><path d="M13 7h-2v4H7v2h4v4h2v-4h4v-2h-4V7zm-1-5C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8z"></path></g>
<g id="add-shopping-cart"><path d="M11 9h2V6h3V4h-3V1h-2v3H8v2h3v3zm-4 9c-1.1 0-1.99.9-1.99 2S5.9 22 7 22s2-.9 2-2-.9-2-2-2zm10 0c-1.1 0-1.99.9-1.99 2s.89 2 1.99 2 2-.9 2-2-.9-2-2-2zm-9.83-3.25l.03-.12.9-1.63h7.45c.75 0 1.41-.41 1.75-1.03l3.86-7.01L19.42 4h-.01l-1.1 2-2.76 5H8.53l-.13-.27L6.16 6l-.95-2-.94-2H1v2h2l3.6 7.59-1.35 2.45c-.16.28-.25.61-.25.96 0 1.1.9 2 2 2h12v-2H7.42c-.13 0-.25-.11-.25-.25z"></path></g>
<g id="alarm"><path d="M22 5.72l-4.6-3.86-1.29 1.53 4.6 3.86L22 5.72zM7.88 3.39L6.6 1.86 2 5.71l1.29 1.53 4.59-3.85zM12.5 8H11v6l4.75 2.85.75-1.23-4-2.37V8zM12 4c-4.97 0-9 4.03-9 9s4.02 9 9 9c4.97 0 9-4.03 9-9s-4.03-9-9-9zm0 16c-3.87 0-7-3.13-7-7s3.13-7 7-7 7 3.13 7 7-3.13 7-7 7z"></path></g>
<g id="alarm-add"><path d="M7.88 3.39L6.6 1.86 2 5.71l1.29 1.53 4.59-3.85zM22 5.72l-4.6-3.86-1.29 1.53 4.6 3.86L22 5.72zM12 4c-4.97 0-9 4.03-9 9s4.02 9 9 9c4.97 0 9-4.03 9-9s-4.03-9-9-9zm0 16c-3.87 0-7-3.13-7-7s3.13-7 7-7 7 3.13 7 7-3.13 7-7 7zm1-11h-2v3H8v2h3v3h2v-3h3v-2h-3V9z"></path></g>
<g id="alarm-off"><path d="M12 6c3.87 0 7 3.13 7 7 0 .84-.16 1.65-.43 2.4l1.52 1.52c.58-1.19.91-2.51.91-3.92 0-4.97-4.03-9-9-9-1.41 0-2.73.33-3.92.91L9.6 6.43C10.35 6.16 11.16 6 12 6zm10-.28l-4.6-3.86-1.29 1.53 4.6 3.86L22 5.72zM2.92 2.29L1.65 3.57 2.98 4.9l-1.11.93 1.42 1.42 1.11-.94.8.8C3.83 8.69 3 10.75 3 13c0 4.97 4.02 9 9 9 2.25 0 4.31-.83 5.89-2.2l2.2 2.2 1.27-1.27L3.89 3.27l-.97-.98zm13.55 16.1C15.26 19.39 13.7 20 12 20c-3.87 0-7-3.13-7-7 0-1.7.61-3.26 1.61-4.47l9.86 9.86zM8.02 3.28L6.6 1.86l-.86.71 1.42 1.42.86-.71z"></path></g>
<g id="alarm-on"><path d="M22 5.72l-4.6-3.86-1.29 1.53 4.6 3.86L22 5.72zM7.88 3.39L6.6 1.86 2 5.71l1.29 1.53 4.59-3.85zM12 4c-4.97 0-9 4.03-9 9s4.02 9 9 9c4.97 0 9-4.03 9-9s-4.03-9-9-9zm0 16c-3.87 0-7-3.13-7-7s3.13-7 7-7 7 3.13 7 7-3.13 7-7 7zm-1.46-5.47L8.41 12.4l-1.06 1.06 3.18 3.18 6-6-1.06-1.06-4.93 4.95z"></path></g>
<g id="all-out"><path d="M16.21 4.16l4 4v-4zm4 12l-4 4h4zm-12 4l-4-4v4zm-4-12l4-4h-4zm12.95-.95c-2.73-2.73-7.17-2.73-9.9 0s-2.73 7.17 0 9.9 7.17 2.73 9.9 0 2.73-7.16 0-9.9zm-1.1 8.8c-2.13 2.13-5.57 2.13-7.7 0s-2.13-5.57 0-7.7 5.57-2.13 7.7 0 2.13 5.57 0 7.7z"></path></g>
<g id="android"><path d="M6 18c0 .55.45 1 1 1h1v3.5c0 .83.67 1.5 1.5 1.5s1.5-.67 1.5-1.5V19h2v3.5c0 .83.67 1.5 1.5 1.5s1.5-.67 1.5-1.5V19h1c.55 0 1-.45 1-1V8H6v10zM3.5 8C2.67 8 2 8.67 2 9.5v7c0 .83.67 1.5 1.5 1.5S5 17.33 5 16.5v-7C5 8.67 4.33 8 3.5 8zm17 0c-.83 0-1.5.67-1.5 1.5v7c0 .83.67 1.5 1.5 1.5s1.5-.67 1.5-1.5v-7c0-.83-.67-1.5-1.5-1.5zm-4.97-5.84l1.3-1.3c.2-.2.2-.51 0-.71-.2-.2-.51-.2-.71 0l-1.48 1.48C13.85 1.23 12.95 1 12 1c-.96 0-1.86.23-2.66.63L7.85.15c-.2-.2-.51-.2-.71 0-.2.2-.2.51 0 .71l1.31 1.31C6.97 3.26 6 5.01 6 7h12c0-1.99-.97-3.75-2.47-4.84zM10 5H9V4h1v1zm5 0h-1V4h1v1z"></path></g>
<g id="announcement"><path d="M20 2H4c-1.1 0-1.99.9-1.99 2L2 22l4-4h14c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zm-7 9h-2V5h2v6zm0 4h-2v-2h2v2z"></path></g>
<g id="apps"><path d="M4 8h4V4H4v4zm6 12h4v-4h-4v4zm-6 0h4v-4H4v4zm0-6h4v-4H4v4zm6 0h4v-4h-4v4zm6-10v4h4V4h-4zm-6 4h4V4h-4v4zm6 6h4v-4h-4v4zm0 6h4v-4h-4v4z"></path></g>
<g id="archive"><path d="M20.54 5.23l-1.39-1.68C18.88 3.21 18.47 3 18 3H6c-.47 0-.88.21-1.16.55L3.46 5.23C3.17 5.57 3 6.02 3 6.5V19c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V6.5c0-.48-.17-.93-.46-1.27zM12 17.5L6.5 12H10v-2h4v2h3.5L12 17.5zM5.12 5l.81-1h12l.94 1H5.12z"></path></g>
<g id="arrow-back"><path d="M20 11H7.83l5.59-5.59L12 4l-8 8 8 8 1.41-1.41L7.83 13H20v-2z"></path></g>
<g id="arrow-downward"><path d="M20 12l-1.41-1.41L13 16.17V4h-2v12.17l-5.58-5.59L4 12l8 8 8-8z"></path></g>
<g id="arrow-drop-down"><path d="M7 10l5 5 5-5z"></path></g>
<g id="arrow-drop-down-circle"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 12l-4-4h8l-4 4z"></path></g>
<g id="arrow-drop-up"><path d="M7 14l5-5 5 5z"></path></g>
<g id="arrow-forward"><path d="M12 4l-1.41 1.41L16.17 11H4v2h12.17l-5.58 5.59L12 20l8-8z"></path></g>
<g id="arrow-upward"><path d="M4 12l1.41 1.41L11 7.83V20h2V7.83l5.58 5.59L20 12l-8-8-8 8z"></path></g>
<g id="aspect-ratio"><path d="M19 12h-2v3h-3v2h5v-5zM7 9h3V7H5v5h2V9zm14-6H3c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16.01H3V4.99h18v14.02z"></path></g>
<g id="assessment"><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z"></path></g>
<g id="assignment"><path d="M19 3h-4.18C14.4 1.84 13.3 1 12 1c-1.3 0-2.4.84-2.82 2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-7 0c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm2 14H7v-2h7v2zm3-4H7v-2h10v2zm0-4H7V7h10v2z"></path></g>
<g id="assignment-ind"><path d="M19 3h-4.18C14.4 1.84 13.3 1 12 1c-1.3 0-2.4.84-2.82 2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-7 0c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm0 4c1.66 0 3 1.34 3 3s-1.34 3-3 3-3-1.34-3-3 1.34-3 3-3zm6 12H6v-1.4c0-2 4-3.1 6-3.1s6 1.1 6 3.1V19z"></path></g>
<g id="assignment-late"><path d="M19 3h-4.18C14.4 1.84 13.3 1 12 1c-1.3 0-2.4.84-2.82 2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-6 15h-2v-2h2v2zm0-4h-2V8h2v6zm-1-9c-.55 0-1-.45-1-1s.45-1 1-1 1 .45 1 1-.45 1-1 1z"></path></g>
<g id="assignment-return"><path d="M19 3h-4.18C14.4 1.84 13.3 1 12 1c-1.3 0-2.4.84-2.82 2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-7 0c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm4 12h-4v3l-5-5 5-5v3h4v4z"></path></g>
<g id="assignment-returned"><path d="M19 3h-4.18C14.4 1.84 13.3 1 12 1c-1.3 0-2.4.84-2.82 2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-7 0c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm0 15l-5-5h3V9h4v4h3l-5 5z"></path></g>
<g id="assignment-turned-in"><path d="M19 3h-4.18C14.4 1.84 13.3 1 12 1c-1.3 0-2.4.84-2.82 2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-7 0c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm-2 14l-4-4 1.41-1.41L10 14.17l6.59-6.59L18 9l-8 8z"></path></g>
<g id="attachment"><path d="M2 12.5C2 9.46 4.46 7 7.5 7H18c2.21 0 4 1.79 4 4s-1.79 4-4 4H9.5C8.12 15 7 13.88 7 12.5S8.12 10 9.5 10H17v2H9.41c-.55 0-.55 1 0 1H18c1.1 0 2-.9 2-2s-.9-2-2-2H7.5C5.57 9 4 10.57 4 12.5S5.57 16 7.5 16H17v2H7.5C4.46 18 2 15.54 2 12.5z"></path></g>
<g id="autorenew"><path d="M12 6v3l4-4-4-4v3c-4.42 0-8 3.58-8 8 0 1.57.46 3.03 1.24 4.26L6.7 14.8c-.45-.83-.7-1.79-.7-2.8 0-3.31 2.69-6 6-6zm6.76 1.74L17.3 9.2c.44.84.7 1.79.7 2.8 0 3.31-2.69 6-6 6v-3l-4 4 4 4v-3c4.42 0 8-3.58 8-8 0-1.57-.46-3.03-1.24-4.26z"></path></g>
<g id="backspace"><path d="M22 3H7c-.69 0-1.23.35-1.59.88L0 12l5.41 8.11c.36.53.9.89 1.59.89h15c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-3 12.59L17.59 17 14 13.41 10.41 17 9 15.59 12.59 12 9 8.41 10.41 7 14 10.59 17.59 7 19 8.41 15.41 12 19 15.59z"></path></g>
<g id="backup"><path d="M19.35 10.04C18.67 6.59 15.64 4 12 4 9.11 4 6.6 5.64 5.35 8.04 2.34 8.36 0 10.91 0 14c0 3.31 2.69 6 6 6h13c2.76 0 5-2.24 5-5 0-2.64-2.05-4.78-4.65-4.96zM14 13v4h-4v-4H7l5-5 5 5h-3z"></path></g>
<g id="block"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zM4 12c0-4.42 3.58-8 8-8 1.85 0 3.55.63 4.9 1.69L5.69 16.9C4.63 15.55 4 13.85 4 12zm8 8c-1.85 0-3.55-.63-4.9-1.69L18.31 7.1C19.37 8.45 20 10.15 20 12c0 4.42-3.58 8-8 8z"></path></g>
<g id="book"><path d="M18 2H6c-1.1 0-2 .9-2 2v16c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zM6 4h5v8l-2.5-1.5L6 12V4z"></path></g>
<g id="bookmark"><path d="M17 3H7c-1.1 0-1.99.9-1.99 2L5 21l7-3 7 3V5c0-1.1-.9-2-2-2z"></path></g>
<g id="bookmark-border"><path d="M17 3H7c-1.1 0-1.99.9-1.99 2L5 21l7-3 7 3V5c0-1.1-.9-2-2-2zm0 15l-5-2.18L7 18V5h10v13z"></path></g>
<g id="bug-report"><path d="M20 8h-2.81c-.45-.78-1.07-1.45-1.82-1.96L17 4.41 15.59 3l-2.17 2.17C12.96 5.06 12.49 5 12 5c-.49 0-.96.06-1.41.17L8.41 3 7 4.41l1.62 1.63C7.88 6.55 7.26 7.22 6.81 8H4v2h2.09c-.05.33-.09.66-.09 1v1H4v2h2v1c0 .34.04.67.09 1H4v2h2.81c1.04 1.79 2.97 3 5.19 3s4.15-1.21 5.19-3H20v-2h-2.09c.05-.33.09-.66.09-1v-1h2v-2h-2v-1c0-.34-.04-.67-.09-1H20V8zm-6 8h-4v-2h4v2zm0-4h-4v-2h4v2z"></path></g>
<g id="build"><path d="M22.7 19l-9.1-9.1c.9-2.3.4-5-1.5-6.9-2-2-5-2.4-7.4-1.3L9 6 6 9 1.6 4.7C.4 7.1.9 10.1 2.9 12.1c1.9 1.9 4.6 2.4 6.9 1.5l9.1 9.1c.4.4 1 .4 1.4 0l2.3-2.3c.5-.4.5-1.1.1-1.4z"></path></g>
<g id="cached"><path d="M19 8l-4 4h3c0 3.31-2.69 6-6 6-1.01 0-1.97-.25-2.8-.7l-1.46 1.46C8.97 19.54 10.43 20 12 20c4.42 0 8-3.58 8-8h3l-4-4zM6 12c0-3.31 2.69-6 6-6 1.01 0 1.97.25 2.8.7l1.46-1.46C15.03 4.46 13.57 4 12 4c-4.42 0-8 3.58-8 8H1l4 4 4-4H6z"></path></g>
<g id="camera-enhance"><path d="M9 3L7.17 5H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2h-3.17L15 3H9zm3 15c-2.76 0-5-2.24-5-5s2.24-5 5-5 5 2.24 5 5-2.24 5-5 5zm0-1l1.25-2.75L16 13l-2.75-1.25L12 9l-1.25 2.75L8 13l2.75 1.25z"></path></g>
<g id="cancel"><path d="M12 2C6.47 2 2 6.47 2 12s4.47 10 10 10 10-4.47 10-10S17.53 2 12 2zm5 13.59L15.59 17 12 13.41 8.41 17 7 15.59 10.59 12 7 8.41 8.41 7 12 10.59 15.59 7 17 8.41 13.41 12 17 15.59z"></path></g>
<g id="card-giftcard"><path d="M20 6h-2.18c.11-.31.18-.65.18-1 0-1.66-1.34-3-3-3-1.05 0-1.96.54-2.5 1.35l-.5.67-.5-.68C10.96 2.54 10.05 2 9 2 7.34 2 6 3.34 6 5c0 .35.07.69.18 1H4c-1.11 0-1.99.89-1.99 2L2 19c0 1.11.89 2 2 2h16c1.11 0 2-.89 2-2V8c0-1.11-.89-2-2-2zm-5-2c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zM9 4c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm11 15H4v-2h16v2zm0-5H4V8h5.08L7 10.83 8.62 12 11 8.76l1-1.36 1 1.36L15.38 12 17 10.83 14.92 8H20v6z"></path></g>
<g id="card-membership"><path d="M20 2H4c-1.11 0-2 .89-2 2v11c0 1.11.89 2 2 2h4v5l4-2 4 2v-5h4c1.11 0 2-.89 2-2V4c0-1.11-.89-2-2-2zm0 13H4v-2h16v2zm0-5H4V4h16v6z"></path></g>
<g id="card-travel"><path d="M20 6h-3V4c0-1.11-.89-2-2-2H9c-1.11 0-2 .89-2 2v2H4c-1.11 0-2 .89-2 2v11c0 1.11.89 2 2 2h16c1.11 0 2-.89 2-2V8c0-1.11-.89-2-2-2zM9 4h6v2H9V4zm11 15H4v-2h16v2zm0-5H4V8h3v2h2V8h6v2h2V8h3v6z"></path></g>
<g id="change-history"><path d="M12 7.77L18.39 18H5.61L12 7.77M12 4L2 20h20L12 4z"></path></g>
<g id="check"><path d="M9 16.17L4.83 12l-1.42 1.41L9 19 21 7l-1.41-1.41z"></path></g>
<g id="check-box"><path d="M19 3H5c-1.11 0-2 .9-2 2v14c0 1.1.89 2 2 2h14c1.11 0 2-.9 2-2V5c0-1.1-.89-2-2-2zm-9 14l-5-5 1.41-1.41L10 14.17l7.59-7.59L19 8l-9 9z"></path></g>
<g id="check-box-outline-blank"><path d="M19 5v14H5V5h14m0-2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2z"></path></g>
<g id="check-circle"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm-2 15l-5-5 1.41-1.41L10 14.17l7.59-7.59L19 8l-9 9z"></path></g>
<g id="chevron-left"><path d="M15.41 7.41L14 6l-6 6 6 6 1.41-1.41L10.83 12z"></path></g>
<g id="chevron-right"><path d="M10 6L8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z"></path></g>
<g id="chrome-reader-mode"><path d="M13 12h7v1.5h-7zm0-2.5h7V11h-7zm0 5h7V16h-7zM21 4H3c-1.1 0-2 .9-2 2v13c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm0 15h-9V6h9v13z"></path></g>
<g id="class"><path d="M18 2H6c-1.1 0-2 .9-2 2v16c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zM6 4h5v8l-2.5-1.5L6 12V4z"></path></g>
<g id="clear"><path d="M19 6.41L17.59 5 12 10.59 6.41 5 5 6.41 10.59 12 5 17.59 6.41 19 12 13.41 17.59 19 19 17.59 13.41 12z"></path></g>
<g id="close"><path d="M19 6.41L17.59 5 12 10.59 6.41 5 5 6.41 10.59 12 5 17.59 6.41 19 12 13.41 17.59 19 19 17.59 13.41 12z"></path></g>
<g id="cloud"><path d="M19.35 10.04C18.67 6.59 15.64 4 12 4 9.11 4 6.6 5.64 5.35 8.04 2.34 8.36 0 10.91 0 14c0 3.31 2.69 6 6 6h13c2.76 0 5-2.24 5-5 0-2.64-2.05-4.78-4.65-4.96z"></path></g>
<g id="cloud-circle"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm4.5 14H8c-1.66 0-3-1.34-3-3s1.34-3 3-3l.14.01C8.58 8.28 10.13 7 12 7c2.21 0 4 1.79 4 4h.5c1.38 0 2.5 1.12 2.5 2.5S17.88 16 16.5 16z"></path></g>
<g id="cloud-done"><path d="M19.35 10.04C18.67 6.59 15.64 4 12 4 9.11 4 6.6 5.64 5.35 8.04 2.34 8.36 0 10.91 0 14c0 3.31 2.69 6 6 6h13c2.76 0 5-2.24 5-5 0-2.64-2.05-4.78-4.65-4.96zM10 17l-3.5-3.5 1.41-1.41L10 14.17 15.18 9l1.41 1.41L10 17z"></path></g>
<g id="cloud-download"><path d="M19.35 10.04C18.67 6.59 15.64 4 12 4 9.11 4 6.6 5.64 5.35 8.04 2.34 8.36 0 10.91 0 14c0 3.31 2.69 6 6 6h13c2.76 0 5-2.24 5-5 0-2.64-2.05-4.78-4.65-4.96zM17 13l-5 5-5-5h3V9h4v4h3z"></path></g>
<g id="cloud-off"><path d="M19.35 10.04C18.67 6.59 15.64 4 12 4c-1.48 0-2.85.43-4.01 1.17l1.46 1.46C10.21 6.23 11.08 6 12 6c3.04 0 5.5 2.46 5.5 5.5v.5H19c1.66 0 3 1.34 3 3 0 1.13-.64 2.11-1.56 2.62l1.45 1.45C23.16 18.16 24 16.68 24 15c0-2.64-2.05-4.78-4.65-4.96zM3 5.27l2.75 2.74C2.56 8.15 0 10.77 0 14c0 3.31 2.69 6 6 6h11.73l2 2L21 20.73 4.27 4 3 5.27zM7.73 10l8 8H6c-2.21 0-4-1.79-4-4s1.79-4 4-4h1.73z"></path></g>
<g id="cloud-queue"><path d="M19.35 10.04C18.67 6.59 15.64 4 12 4 9.11 4 6.6 5.64 5.35 8.04 2.34 8.36 0 10.91 0 14c0 3.31 2.69 6 6 6h13c2.76 0 5-2.24 5-5 0-2.64-2.05-4.78-4.65-4.96zM19 18H6c-2.21 0-4-1.79-4-4s1.79-4 4-4h.71C7.37 7.69 9.48 6 12 6c3.04 0 5.5 2.46 5.5 5.5v.5H19c1.66 0 3 1.34 3 3s-1.34 3-3 3z"></path></g>
<g id="cloud-upload"><path d="M19.35 10.04C18.67 6.59 15.64 4 12 4 9.11 4 6.6 5.64 5.35 8.04 2.34 8.36 0 10.91 0 14c0 3.31 2.69 6 6 6h13c2.76 0 5-2.24 5-5 0-2.64-2.05-4.78-4.65-4.96zM14 13v4h-4v-4H7l5-5 5 5h-3z"></path></g>
<g id="code"><path d="M9.4 16.6L4.8 12l4.6-4.6L8 6l-6 6 6 6 1.4-1.4zm5.2 0l4.6-4.6-4.6-4.6L16 6l6 6-6 6-1.4-1.4z"></path></g>
<g id="compare-arrows"><path d="M9.01 14H2v2h7.01v3L13 15l-3.99-4v3zm5.98-1v-3H22V8h-7.01V5L11 9l3.99 4z"></path></g>
<g id="content-copy"><path d="M16 1H4c-1.1 0-2 .9-2 2v14h2V3h12V1zm3 4H8c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h11c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2zm0 16H8V7h11v14z"></path></g>
<g id="content-cut"><path d="M9.64 7.64c.23-.5.36-1.05.36-1.64 0-2.21-1.79-4-4-4S2 3.79 2 6s1.79 4 4 4c.59 0 1.14-.13 1.64-.36L10 12l-2.36 2.36C7.14 14.13 6.59 14 6 14c-2.21 0-4 1.79-4 4s1.79 4 4 4 4-1.79 4-4c0-.59-.13-1.14-.36-1.64L12 14l7 7h3v-1L9.64 7.64zM6 8c-1.1 0-2-.89-2-2s.9-2 2-2 2 .89 2 2-.9 2-2 2zm0 12c-1.1 0-2-.89-2-2s.9-2 2-2 2 .89 2 2-.9 2-2 2zm6-7.5c-.28 0-.5-.22-.5-.5s.22-.5.5-.5.5.22.5.5-.22.5-.5.5zM19 3l-6 6 2 2 7-7V3z"></path></g>
<g id="content-paste"><path d="M19 2h-4.18C14.4.84 13.3 0 12 0c-1.3 0-2.4.84-2.82 2H5c-1.1 0-2 .9-2 2v16c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zm-7 0c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm7 18H5V4h2v3h10V4h2v16z"></path></g>
<g id="copyright"><path d="M10.08 10.86c.05-.33.16-.62.3-.87s.34-.46.59-.62c.24-.15.54-.22.91-.23.23.01.44.05.63.13.2.09.38.21.52.36s.25.33.34.53.13.42.14.64h1.79c-.02-.47-.11-.9-.28-1.29s-.4-.73-.7-1.01-.66-.5-1.08-.66-.88-.23-1.39-.23c-.65 0-1.22.11-1.7.34s-.88.53-1.2.92-.56.84-.71 1.36S8 11.29 8 11.87v.27c0 .58.08 1.12.23 1.64s.39.97.71 1.35.72.69 1.2.91 1.05.34 1.7.34c.47 0 .91-.08 1.32-.23s.77-.36 1.08-.63.56-.58.74-.94.29-.74.3-1.15h-1.79c-.01.21-.06.4-.15.58s-.21.33-.36.46-.32.23-.52.3c-.19.07-.39.09-.6.1-.36-.01-.66-.08-.89-.23-.25-.16-.45-.37-.59-.62s-.25-.55-.3-.88-.08-.67-.08-1v-.27c0-.35.03-.68.08-1.01zM12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8z"></path></g>
<g id="create"><path d="M3 17.25V21h3.75L17.81 9.94l-3.75-3.75L3 17.25zM20.71 7.04c.39-.39.39-1.02 0-1.41l-2.34-2.34c-.39-.39-1.02-.39-1.41 0l-1.83 1.83 3.75 3.75 1.83-1.83z"></path></g>
<g id="create-new-folder"><path d="M20 6h-8l-2-2H4c-1.11 0-1.99.89-1.99 2L2 18c0 1.11.89 2 2 2h16c1.11 0 2-.89 2-2V8c0-1.11-.89-2-2-2zm-1 8h-3v3h-2v-3h-3v-2h3V9h2v3h3v2z"></path></g>
<g id="credit-card"><path d="M20 4H4c-1.11 0-1.99.89-1.99 2L2 18c0 1.11.89 2 2 2h16c1.11 0 2-.89 2-2V6c0-1.11-.89-2-2-2zm0 14H4v-6h16v6zm0-10H4V6h16v2z"></path></g>
<g id="dashboard"><path d="M3 13h8V3H3v10zm0 8h8v-6H3v6zm10 0h8V11h-8v10zm0-18v6h8V3h-8z"></path></g>
<g id="date-range"><path d="M9 11H7v2h2v-2zm4 0h-2v2h2v-2zm4 0h-2v2h2v-2zm2-7h-1V2h-2v2H8V2H6v2H5c-1.11 0-1.99.9-1.99 2L3 20c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm0 16H5V9h14v11z"></path></g>
<g id="delete"><path d="M6 19c0 1.1.9 2 2 2h8c1.1 0 2-.9 2-2V7H6v12zM19 4h-3.5l-1-1h-5l-1 1H5v2h14V4z"></path></g>
<g id="delete-forever"><path d="M6 19c0 1.1.9 2 2 2h8c1.1 0 2-.9 2-2V7H6v12zm2.46-7.12l1.41-1.41L12 12.59l2.12-2.12 1.41 1.41L13.41 14l2.12 2.12-1.41 1.41L12 15.41l-2.12 2.12-1.41-1.41L10.59 14l-2.13-2.12zM15.5 4l-1-1h-5l-1 1H5v2h14V4z"></path></g>
<g id="delete-sweep"><path d="M15 16h4v2h-4zm0-8h7v2h-7zm0 4h6v2h-6zM3 18c0 1.1.9 2 2 2h6c1.1 0 2-.9 2-2V8H3v10zM14 5h-3l-1-1H6L5 5H2v2h12z"></path></g>
<g id="description"><path d="M14 2H6c-1.1 0-1.99.9-1.99 2L4 20c0 1.1.89 2 1.99 2H18c1.1 0 2-.9 2-2V8l-6-6zm2 16H8v-2h8v2zm0-4H8v-2h8v2zm-3-5V3.5L18.5 9H13z"></path></g>
<g id="dns"><path d="M20 13H4c-.55 0-1 .45-1 1v6c0 .55.45 1 1 1h16c.55 0 1-.45 1-1v-6c0-.55-.45-1-1-1zM7 19c-1.1 0-2-.9-2-2s.9-2 2-2 2 .9 2 2-.9 2-2 2zM20 3H4c-.55 0-1 .45-1 1v6c0 .55.45 1 1 1h16c.55 0 1-.45 1-1V4c0-.55-.45-1-1-1zM7 9c-1.1 0-2-.9-2-2s.9-2 2-2 2 .9 2 2-.9 2-2 2z"></path></g>
<g id="done"><path d="M9 16.2L4.8 12l-1.4 1.4L9 19 21 7l-1.4-1.4L9 16.2z"></path></g>
<g id="done-all"><path d="M18 7l-1.41-1.41-6.34 6.34 1.41 1.41L18 7zm4.24-1.41L11.66 16.17 7.48 12l-1.41 1.41L11.66 19l12-12-1.42-1.41zM.41 13.41L6 19l1.41-1.41L1.83 12 .41 13.41z"></path></g>
<g id="donut-large"><path d="M11 5.08V2c-5 .5-9 4.81-9 10s4 9.5 9 10v-3.08c-3-.48-6-3.4-6-6.92s3-6.44 6-6.92zM18.97 11H22c-.47-5-4-8.53-9-9v3.08C16 5.51 18.54 8 18.97 11zM13 18.92V22c5-.47 8.53-4 9-9h-3.03c-.43 3-2.97 5.49-5.97 5.92z"></path></g>
<g id="donut-small"><path d="M11 9.16V2c-5 .5-9 4.79-9 10s4 9.5 9 10v-7.16c-1-.41-2-1.52-2-2.84s1-2.43 2-2.84zM14.86 11H22c-.48-4.75-4-8.53-9-9v7.16c1 .3 1.52.98 1.86 1.84zM13 14.84V22c5-.47 8.52-4.25 9-9h-7.14c-.34.86-.86 1.54-1.86 1.84z"></path></g>
<g id="drafts"><path d="M21.99 8c0-.72-.37-1.35-.94-1.7L12 1 2.95 6.3C2.38 6.65 2 7.28 2 8v10c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2l-.01-10zM12 13L3.74 7.84 12 3l8.26 4.84L12 13z"></path></g>
<g id="eject"><path d="M5 17h14v2H5zm7-12L5.33 15h13.34z"></path></g>
<g id="error"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm1 15h-2v-2h2v2zm0-4h-2V7h2v6z"></path></g>
<g id="error-outline"><path d="M11 15h2v2h-2zm0-8h2v6h-2zm.99-5C6.47 2 2 6.48 2 12s4.47 10 9.99 10C17.52 22 22 17.52 22 12S17.52 2 11.99 2zM12 20c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8z"></path></g>
<g id="euro-symbol"><path d="M15 18.5c-2.51 0-4.68-1.42-5.76-3.5H15v-2H8.58c-.05-.33-.08-.66-.08-1s.03-.67.08-1H15V9H9.24C10.32 6.92 12.5 5.5 15 5.5c1.61 0 3.09.59 4.23 1.57L21 5.3C19.41 3.87 17.3 3 15 3c-3.92 0-7.24 2.51-8.48 6H3v2h3.06c-.04.33-.06.66-.06 1 0 .34.02.67.06 1H3v2h3.52c1.24 3.49 4.56 6 8.48 6 2.31 0 4.41-.87 6-2.3l-1.78-1.77c-1.13.98-2.6 1.57-4.22 1.57z"></path></g>
<g id="event"><path d="M17 12h-5v5h5v-5zM16 1v2H8V1H6v2H5c-1.11 0-1.99.9-1.99 2L3 19c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2h-1V1h-2zm3 18H5V8h14v11z"></path></g>
<g id="event-seat"><path d="M4 18v3h3v-3h10v3h3v-6H4zm15-8h3v3h-3zM2 10h3v3H2zm15 3H7V5c0-1.1.9-2 2-2h6c1.1 0 2 .9 2 2v8z"></path></g>
<g id="exit-to-app"><path d="M10.09 15.59L11.5 17l5-5-5-5-1.41 1.41L12.67 11H3v2h9.67l-2.58 2.59zM19 3H5c-1.11 0-2 .9-2 2v4h2V5h14v14H5v-4H3v4c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2z"></path></g>
<g id="expand-less"><path d="M12 8l-6 6 1.41 1.41L12 10.83l4.59 4.58L18 14z"></path></g>
<g id="expand-more"><path d="M16.59 8.59L12 13.17 7.41 8.59 6 10l6 6 6-6z"></path></g>
<g id="explore"><path d="M12 10.9c-.61 0-1.1.49-1.1 1.1s.49 1.1 1.1 1.1c.61 0 1.1-.49 1.1-1.1s-.49-1.1-1.1-1.1zM12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm2.19 12.19L6 18l3.81-8.19L18 6l-3.81 8.19z"></path></g>
<g id="extension"><path d="M20.5 11H19V7c0-1.1-.9-2-2-2h-4V3.5C13 2.12 11.88 1 10.5 1S8 2.12 8 3.5V5H4c-1.1 0-1.99.9-1.99 2v3.8H3.5c1.49 0 2.7 1.21 2.7 2.7s-1.21 2.7-2.7 2.7H2V20c0 1.1.9 2 2 2h3.8v-1.5c0-1.49 1.21-2.7 2.7-2.7 1.49 0 2.7 1.21 2.7 2.7V22H17c1.1 0 2-.9 2-2v-4h1.5c1.38 0 2.5-1.12 2.5-2.5S21.88 11 20.5 11z"></path></g>
<g id="face"><path d="M9 11.75c-.69 0-1.25.56-1.25 1.25s.56 1.25 1.25 1.25 1.25-.56 1.25-1.25-.56-1.25-1.25-1.25zm6 0c-.69 0-1.25.56-1.25 1.25s.56 1.25 1.25 1.25 1.25-.56 1.25-1.25-.56-1.25-1.25-1.25zM12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 0-8-3.59-8-8 0-.29.02-.58.05-.86 2.36-1.05 4.23-2.98 5.21-5.37C11.07 8.33 14.05 10 17.42 10c.78 0 1.53-.09 2.25-.26.21.71.33 1.47.33 2.26 0 4.41-3.59 8-8 8z"></path></g>
<g id="favorite"><path d="M12 21.35l-1.45-1.32C5.4 15.36 2 12.28 2 8.5 2 5.42 4.42 3 7.5 3c1.74 0 3.41.81 4.5 2.09C13.09 3.81 14.76 3 16.5 3 19.58 3 22 5.42 22 8.5c0 3.78-3.4 6.86-8.55 11.54L12 21.35z"></path></g>
<g id="favorite-border"><path d="M16.5 3c-1.74 0-3.41.81-4.5 2.09C10.91 3.81 9.24 3 7.5 3 4.42 3 2 5.42 2 8.5c0 3.78 3.4 6.86 8.55 11.54L12 21.35l1.45-1.32C18.6 15.36 22 12.28 22 8.5 22 5.42 19.58 3 16.5 3zm-4.4 15.55l-.1.1-.1-.1C7.14 14.24 4 11.39 4 8.5 4 6.5 5.5 5 7.5 5c1.54 0 3.04.99 3.57 2.36h1.87C13.46 5.99 14.96 5 16.5 5c2 0 3.5 1.5 3.5 3.5 0 2.89-3.14 5.74-7.9 10.05z"></path></g>
<g id="feedback"><path d="M20 2H4c-1.1 0-1.99.9-1.99 2L2 22l4-4h14c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zm-7 12h-2v-2h2v2zm0-4h-2V6h2v4z"></path></g>
<g id="file-download"><path d="M19 9h-4V3H9v6H5l7 7 7-7zM5 18v2h14v-2H5z"></path></g>
<g id="file-upload"><path d="M9 16h6v-6h4l-7-7-7 7h4zm-4 2h14v2H5z"></path></g>
<g id="filter-list"><path d="M10 18h4v-2h-4v2zM3 6v2h18V6H3zm3 7h12v-2H6v2z"></path></g>
<g id="find-in-page"><path d="M20 19.59V8l-6-6H6c-1.1 0-1.99.9-1.99 2L4 20c0 1.1.89 2 1.99 2H18c.45 0 .85-.15 1.19-.4l-4.43-4.43c-.8.52-1.74.83-2.76.83-2.76 0-5-2.24-5-5s2.24-5 5-5 5 2.24 5 5c0 1.02-.31 1.96-.83 2.75L20 19.59zM9 13c0 1.66 1.34 3 3 3s3-1.34 3-3-1.34-3-3-3-3 1.34-3 3z"></path></g>
<g id="find-replace"><path d="M11 6c1.38 0 2.63.56 3.54 1.46L12 10h6V4l-2.05 2.05C14.68 4.78 12.93 4 11 4c-3.53 0-6.43 2.61-6.92 6H6.1c.46-2.28 2.48-4 4.9-4zm5.64 9.14c.66-.9 1.12-1.97 1.28-3.14H15.9c-.46 2.28-2.48 4-4.9 4-1.38 0-2.63-.56-3.54-1.46L10 12H4v6l2.05-2.05C7.32 17.22 9.07 18 11 18c1.55 0 2.98-.51 4.14-1.36L20 21.49 21.49 20l-4.85-4.86z"></path></g>
<g id="fingerprint"><path d="M17.81 4.47c-.08 0-.16-.02-.23-.06C15.66 3.42 14 3 12.01 3c-1.98 0-3.86.47-5.57 1.41-.24.13-.54.04-.68-.2-.13-.24-.04-.55.2-.68C7.82 2.52 9.86 2 12.01 2c2.13 0 3.99.47 6.03 1.52.25.13.34.43.21.67-.09.18-.26.28-.44.28zM3.5 9.72c-.1 0-.2-.03-.29-.09-.23-.16-.28-.47-.12-.7.99-1.4 2.25-2.5 3.75-3.27C9.98 4.04 14 4.03 17.15 5.65c1.5.77 2.76 1.86 3.75 3.25.16.22.11.54-.12.7-.23.16-.54.11-.7-.12-.9-1.26-2.04-2.25-3.39-2.94-2.87-1.47-6.54-1.47-9.4.01-1.36.7-2.5 1.7-3.4 2.96-.08.14-.23.21-.39.21zm6.25 12.07c-.13 0-.26-.05-.35-.15-.87-.87-1.34-1.43-2.01-2.64-.69-1.23-1.05-2.73-1.05-4.34 0-2.97 2.54-5.39 5.66-5.39s5.66 2.42 5.66 5.39c0 .28-.22.5-.5.5s-.5-.22-.5-.5c0-2.42-2.09-4.39-4.66-4.39-2.57 0-4.66 1.97-4.66 4.39 0 1.44.32 2.77.93 3.85.64 1.15 1.08 1.64 1.85 2.42.19.2.19.51 0 .71-.11.1-.24.15-.37.15zm7.17-1.85c-1.19 0-2.24-.3-3.1-.89-1.49-1.01-2.38-2.65-2.38-4.39 0-.28.22-.5.5-.5s.5.22.5.5c0 1.41.72 2.74 1.94 3.56.71.48 1.54.71 2.54.71.24 0 .64-.03 1.04-.1.27-.05.53.13.58.41.05.27-.13.53-.41.58-.57.11-1.07.12-1.21.12zM14.91 22c-.04 0-.09-.01-.13-.02-1.59-.44-2.63-1.03-3.72-2.1-1.4-1.39-2.17-3.24-2.17-5.22 0-1.62 1.38-2.94 3.08-2.94 1.7 0 3.08 1.32 3.08 2.94 0 1.07.93 1.94 2.08 1.94s2.08-.87 2.08-1.94c0-3.77-3.25-6.83-7.25-6.83-2.84 0-5.44 1.58-6.61 4.03-.39.81-.59 1.76-.59 2.8 0 .78.07 2.01.67 3.61.1.26-.03.55-.29.64-.26.1-.55-.04-.64-.29-.49-1.31-.73-2.61-.73-3.96 0-1.2.23-2.29.68-3.24 1.33-2.79 4.28-4.6 7.51-4.6 4.55 0 8.25 3.51 8.25 7.83 0 1.62-1.38 2.94-3.08 2.94s-3.08-1.32-3.08-2.94c0-1.07-.93-1.94-2.08-1.94s-2.08.87-2.08 1.94c0 1.71.66 3.31 1.87 4.51.95.94 1.86 1.46 3.27 1.85.27.07.42.35.35.61-.05.23-.26.38-.47.38z"></path></g>
<g id="first-page"><path d="M18.41 16.59L13.82 12l4.59-4.59L17 6l-6 6 6 6zM6 6h2v12H6z"></path></g>
<g id="flag"><path d="M14.4 6L14 4H5v17h2v-7h5.6l.4 2h7V6z"></path></g>
<g id="flight-land"><path d="M2.5 19h19v2h-19zm7.18-5.73l4.35 1.16 5.31 1.42c.8.21 1.62-.26 1.84-1.06.21-.8-.26-1.62-1.06-1.84l-5.31-1.42-2.76-9.02L10.12 2v8.28L5.15 8.95l-.93-2.32-1.45-.39v5.17l1.6.43 5.31 1.43z"></path></g>
<g id="flight-takeoff"><path d="M2.5 19h19v2h-19zm19.57-9.36c-.21-.8-1.04-1.28-1.84-1.06L14.92 10l-6.9-6.43-1.93.51 4.14 7.17-4.97 1.33-1.97-1.54-1.45.39 1.82 3.16.77 1.33 1.6-.43 5.31-1.42 4.35-1.16L21 11.49c.81-.23 1.28-1.05 1.07-1.85z"></path></g>
<g id="flip-to-back"><path d="M9 7H7v2h2V7zm0 4H7v2h2v-2zm0-8c-1.11 0-2 .9-2 2h2V3zm4 12h-2v2h2v-2zm6-12v2h2c0-1.1-.9-2-2-2zm-6 0h-2v2h2V3zM9 17v-2H7c0 1.1.89 2 2 2zm10-4h2v-2h-2v2zm0-4h2V7h-2v2zm0 8c1.1 0 2-.9 2-2h-2v2zM5 7H3v12c0 1.1.89 2 2 2h12v-2H5V7zm10-2h2V3h-2v2zm0 12h2v-2h-2v2z"></path></g>
<g id="flip-to-front"><path d="M3 13h2v-2H3v2zm0 4h2v-2H3v2zm2 4v-2H3c0 1.1.89 2 2 2zM3 9h2V7H3v2zm12 12h2v-2h-2v2zm4-18H9c-1.11 0-2 .9-2 2v10c0 1.1.89 2 2 2h10c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 12H9V5h10v10zm-8 6h2v-2h-2v2zm-4 0h2v-2H7v2z"></path></g>
<g id="folder"><path d="M10 4H4c-1.1 0-1.99.9-1.99 2L2 18c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V8c0-1.1-.9-2-2-2h-8l-2-2z"></path></g>
<g id="folder-open"><path d="M20 6h-8l-2-2H4c-1.1 0-1.99.9-1.99 2L2 18c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V8c0-1.1-.9-2-2-2zm0 12H4V8h16v10z"></path></g>
<g id="folder-shared"><path d="M20 6h-8l-2-2H4c-1.1 0-1.99.9-1.99 2L2 18c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V8c0-1.1-.9-2-2-2zm-5 3c1.1 0 2 .9 2 2s-.9 2-2 2-2-.9-2-2 .9-2 2-2zm4 8h-8v-1c0-1.33 2.67-2 4-2s4 .67 4 2v1z"></path></g>
<g id="font-download"><path d="M9.93 13.5h4.14L12 7.98zM20 2H4c-1.1 0-2 .9-2 2v16c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zm-4.05 16.5l-1.14-3H9.17l-1.12 3H5.96l5.11-13h1.86l5.11 13h-2.09z"></path></g>
<g id="forward"><path d="M12 8V4l8 8-8 8v-4H4V8z"></path></g>
<g id="fullscreen"><path d="M7 14H5v5h5v-2H7v-3zm-2-4h2V7h3V5H5v5zm12 7h-3v2h5v-5h-2v3zM14 5v2h3v3h2V5h-5z"></path></g>
<g id="fullscreen-exit"><path d="M5 16h3v3h2v-5H5v2zm3-8H5v2h5V5H8v3zm6 11h2v-3h3v-2h-5v5zm2-11V5h-2v5h5V8h-3z"></path></g>
<g id="g-translate"><path d="M20 5h-9.12L10 2H4c-1.1 0-2 .9-2 2v13c0 1.1.9 2 2 2h7l1 3h8c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2zM7.17 14.59c-2.25 0-4.09-1.83-4.09-4.09s1.83-4.09 4.09-4.09c1.04 0 1.99.37 2.74 1.07l.07.06-1.23 1.18-.06-.05c-.29-.27-.78-.59-1.52-.59-1.31 0-2.38 1.09-2.38 2.42s1.07 2.42 2.38 2.42c1.37 0 1.96-.87 2.12-1.46H7.08V9.91h3.95l.01.07c.04.21.05.4.05.61 0 2.35-1.61 4-3.92 4zm6.03-1.71c.33.6.74 1.18 1.19 1.7l-.54.53-.65-2.23zm.77-.76h-.99l-.31-1.04h3.99s-.34 1.31-1.56 2.74c-.52-.62-.89-1.23-1.13-1.7zM21 20c0 .55-.45 1-1 1h-7l2-2-.81-2.77.92-.92L17.79 18l.73-.73-2.71-2.68c.9-1.03 1.6-2.25 1.92-3.51H19v-1.04h-3.64V9h-1.04v1.04h-1.96L11.18 6H20c.55 0 1 .45 1 1v13z"></path></g>
<g id="gavel"><path d="M1 21h12v2H1zM5.245 8.07l2.83-2.827 14.14 14.142-2.828 2.828zM12.317 1l5.657 5.656-2.83 2.83-5.654-5.66zM3.825 9.485l5.657 5.657-2.828 2.828-5.657-5.657z"></path></g>
<g id="gesture"><path d="M4.59 6.89c.7-.71 1.4-1.35 1.71-1.22.5.2 0 1.03-.3 1.52-.25.42-2.86 3.89-2.86 6.31 0 1.28.48 2.34 1.34 2.98.75.56 1.74.73 2.64.46 1.07-.31 1.95-1.4 3.06-2.77 1.21-1.49 2.83-3.44 4.08-3.44 1.63 0 1.65 1.01 1.76 1.79-3.78.64-5.38 3.67-5.38 5.37 0 1.7 1.44 3.09 3.21 3.09 1.63 0 4.29-1.33 4.69-6.1H21v-2.5h-2.47c-.15-1.65-1.09-4.2-4.03-4.2-2.25 0-4.18 1.91-4.94 2.84-.58.73-2.06 2.48-2.29 2.72-.25.3-.68.84-1.11.84-.45 0-.72-.83-.36-1.92.35-1.09 1.4-2.86 1.85-3.52.78-1.14 1.3-1.92 1.3-3.28C8.95 3.69 7.31 3 6.44 3 5.12 3 3.97 4 3.72 4.25c-.36.36-.66.66-.88.93l1.75 1.71zm9.29 11.66c-.31 0-.74-.26-.74-.72 0-.6.73-2.2 2.87-2.76-.3 2.69-1.43 3.48-2.13 3.48z"></path></g>
<g id="get-app"><path d="M19 9h-4V3H9v6H5l7 7 7-7zM5 18v2h14v-2H5z"></path></g>
<g id="gif"><path d="M11.5 9H13v6h-1.5zM9 9H6c-.6 0-1 .5-1 1v4c0 .5.4 1 1 1h3c.6 0 1-.5 1-1v-2H8.5v1.5h-2v-3H10V10c0-.5-.4-1-1-1zm10 1.5V9h-4.5v6H16v-2h2v-1.5h-2v-1z"></path></g>
<g id="grade"><path d="M12 17.27L18.18 21l-1.64-7.03L22 9.24l-7.19-.61L12 2 9.19 8.63 2 9.24l5.46 4.73L5.82 21z"></path></g>
<g id="group-work"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zM8 17.5c-1.38 0-2.5-1.12-2.5-2.5s1.12-2.5 2.5-2.5 2.5 1.12 2.5 2.5-1.12 2.5-2.5 2.5zM9.5 8c0-1.38 1.12-2.5 2.5-2.5s2.5 1.12 2.5 2.5-1.12 2.5-2.5 2.5S9.5 9.38 9.5 8zm6.5 9.5c-1.38 0-2.5-1.12-2.5-2.5s1.12-2.5 2.5-2.5 2.5 1.12 2.5 2.5-1.12 2.5-2.5 2.5z"></path></g>
<g id="help"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm1 17h-2v-2h2v2zm2.07-7.75l-.9.92C13.45 12.9 13 13.5 13 15h-2v-.5c0-1.1.45-2.1 1.17-2.83l1.24-1.26c.37-.36.59-.86.59-1.41 0-1.1-.9-2-2-2s-2 .9-2 2H8c0-2.21 1.79-4 4-4s4 1.79 4 4c0 .88-.36 1.68-.93 2.25z"></path></g>
<g id="help-outline"><path d="M11 18h2v-2h-2v2zm1-16C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8zm0-14c-2.21 0-4 1.79-4 4h2c0-1.1.9-2 2-2s2 .9 2 2c0 2-3 1.75-3 5h2c0-2.25 3-2.5 3-5 0-2.21-1.79-4-4-4z"></path></g>
<g id="highlight-off"><path d="M14.59 8L12 10.59 9.41 8 8 9.41 10.59 12 8 14.59 9.41 16 12 13.41 14.59 16 16 14.59 13.41 12 16 9.41 14.59 8zM12 2C6.47 2 2 6.47 2 12s4.47 10 10 10 10-4.47 10-10S17.53 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8z"></path></g>
<g id="history"><path d="M13 3c-4.97 0-9 4.03-9 9H1l3.89 3.89.07.14L9 12H6c0-3.87 3.13-7 7-7s7 3.13 7 7-3.13 7-7 7c-1.93 0-3.68-.79-4.94-2.06l-1.42 1.42C8.27 19.99 10.51 21 13 21c4.97 0 9-4.03 9-9s-4.03-9-9-9zm-1 5v5l4.28 2.54.72-1.21-3.5-2.08V8H12z"></path></g>
<g id="home"><path d="M10 20v-6h4v6h5v-8h3L12 3 2 12h3v8z"></path></g>
<g id="hourglass-empty"><path d="M6 2v6h.01L6 8.01 10 12l-4 4 .01.01H6V22h12v-5.99h-.01L18 16l-4-4 4-3.99-.01-.01H18V2H6zm10 14.5V20H8v-3.5l4-4 4 4zm-4-5l-4-4V4h8v3.5l-4 4z"></path></g>
<g id="hourglass-full"><path d="M6 2v6h.01L6 8.01 10 12l-4 4 .01.01H6V22h12v-5.99h-.01L18 16l-4-4 4-3.99-.01-.01H18V2H6z"></path></g>
<g id="http"><path d="M4.5 11h-2V9H1v6h1.5v-2.5h2V15H6V9H4.5v2zm2.5-.5h1.5V15H10v-4.5h1.5V9H7v1.5zm5.5 0H14V15h1.5v-4.5H17V9h-4.5v1.5zm9-1.5H18v6h1.5v-2h2c.8 0 1.5-.7 1.5-1.5v-1c0-.8-.7-1.5-1.5-1.5zm0 2.5h-2v-1h2v1z"></path></g>
<g id="https"><path d="M18 8h-1V6c0-2.76-2.24-5-5-5S7 3.24 7 6v2H6c-1.1 0-2 .9-2 2v10c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V10c0-1.1-.9-2-2-2zm-6 9c-1.1 0-2-.9-2-2s.9-2 2-2 2 .9 2 2-.9 2-2 2zm3.1-9H8.9V6c0-1.71 1.39-3.1 3.1-3.1 1.71 0 3.1 1.39 3.1 3.1v2z"></path></g>
<g id="important-devices"><path d="M23 11.01L18 11c-.55 0-1 .45-1 1v9c0 .55.45 1 1 1h5c.55 0 1-.45 1-1v-9c0-.55-.45-.99-1-.99zM23 20h-5v-7h5v7zM20 2H2C.89 2 0 2.89 0 4v12c0 1.1.89 2 2 2h7v2H7v2h8v-2h-2v-2h2v-2H2V4h18v5h2V4c0-1.11-.9-2-2-2zm-8.03 7L11 6l-.97 3H7l2.47 1.76-.94 2.91 2.47-1.8 2.47 1.8-.94-2.91L15 9h-3.03z"></path></g>
<g id="inbox"><path d="M19 3H4.99c-1.11 0-1.98.89-1.98 2L3 19c0 1.1.88 2 1.99 2H19c1.1 0 2-.9 2-2V5c0-1.11-.9-2-2-2zm0 12h-4c0 1.66-1.35 3-3 3s-3-1.34-3-3H4.99V5H19v10z"></path></g>
<g id="indeterminate-check-box"><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-2 10H7v-2h10v2z"></path></g>
<g id="info"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm1 15h-2v-6h2v6zm0-8h-2V7h2v2z"></path></g>
<g id="info-outline"><path d="M11 17h2v-6h-2v6zm1-15C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8zM11 9h2V7h-2v2z"></path></g>
<g id="input"><path d="M21 3.01H3c-1.1 0-2 .9-2 2V9h2V4.99h18v14.03H3V15H1v4.01c0 1.1.9 1.98 2 1.98h18c1.1 0 2-.88 2-1.98v-14c0-1.11-.9-2-2-2zM11 16l4-4-4-4v3H1v2h10v3z"></path></g>
<g id="invert-colors"><path d="M17.66 7.93L12 2.27 6.34 7.93c-3.12 3.12-3.12 8.19 0 11.31C7.9 20.8 9.95 21.58 12 21.58c2.05 0 4.1-.78 5.66-2.34 3.12-3.12 3.12-8.19 0-11.31zM12 19.59c-1.6 0-3.11-.62-4.24-1.76C6.62 16.69 6 15.19 6 13.59s.62-3.11 1.76-4.24L12 5.1v14.49z"></path></g>
<g id="label"><path d="M17.63 5.84C17.27 5.33 16.67 5 16 5L5 5.01C3.9 5.01 3 5.9 3 7v10c0 1.1.9 1.99 2 1.99L16 19c.67 0 1.27-.33 1.63-.84L22 12l-4.37-6.16z"></path></g>
<g id="label-outline"><path d="M17.63 5.84C17.27 5.33 16.67 5 16 5L5 5.01C3.9 5.01 3 5.9 3 7v10c0 1.1.9 1.99 2 1.99L16 19c.67 0 1.27-.33 1.63-.84L22 12l-4.37-6.16zM16 17H5V7h11l3.55 5L16 17z"></path></g>
<g id="language"><path d="M11.99 2C6.47 2 2 6.48 2 12s4.47 10 9.99 10C17.52 22 22 17.52 22 12S17.52 2 11.99 2zm6.93 6h-2.95c-.32-1.25-.78-2.45-1.38-3.56 1.84.63 3.37 1.91 4.33 3.56zM12 4.04c.83 1.2 1.48 2.53 1.91 3.96h-3.82c.43-1.43 1.08-2.76 1.91-3.96zM4.26 14C4.1 13.36 4 12.69 4 12s.1-1.36.26-2h3.38c-.08.66-.14 1.32-.14 2 0 .68.06 1.34.14 2H4.26zm.82 2h2.95c.32 1.25.78 2.45 1.38 3.56-1.84-.63-3.37-1.9-4.33-3.56zm2.95-8H5.08c.96-1.66 2.49-2.93 4.33-3.56C8.81 5.55 8.35 6.75 8.03 8zM12 19.96c-.83-1.2-1.48-2.53-1.91-3.96h3.82c-.43 1.43-1.08 2.76-1.91 3.96zM14.34 14H9.66c-.09-.66-.16-1.32-.16-2 0-.68.07-1.35.16-2h4.68c.09.65.16 1.32.16 2 0 .68-.07 1.34-.16 2zm.25 5.56c.6-1.11 1.06-2.31 1.38-3.56h2.95c-.96 1.65-2.49 2.93-4.33 3.56zM16.36 14c.08-.66.14-1.32.14-2 0-.68-.06-1.34-.14-2h3.38c.16.64.26 1.31.26 2s-.1 1.36-.26 2h-3.38z"></path></g>
<g id="last-page"><path d="M5.59 7.41L10.18 12l-4.59 4.59L7 18l6-6-6-6zM16 6h2v12h-2z"></path></g>
<g id="launch"><path d="M19 19H5V5h7V3H5c-1.11 0-2 .9-2 2v14c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2v-7h-2v7zM14 3v2h3.59l-9.83 9.83 1.41 1.41L19 6.41V10h2V3h-7z"></path></g>
<g id="lightbulb-outline"><path d="M9 21c0 .55.45 1 1 1h4c.55 0 1-.45 1-1v-1H9v1zm3-19C8.14 2 5 5.14 5 9c0 2.38 1.19 4.47 3 5.74V17c0 .55.45 1 1 1h6c.55 0 1-.45 1-1v-2.26c1.81-1.27 3-3.36 3-5.74 0-3.86-3.14-7-7-7zm2.85 11.1l-.85.6V16h-4v-2.3l-.85-.6C7.8 12.16 7 10.63 7 9c0-2.76 2.24-5 5-5s5 2.24 5 5c0 1.63-.8 3.16-2.15 4.1z"></path></g>
<g id="line-style"><path d="M3 16h5v-2H3v2zm6.5 0h5v-2h-5v2zm6.5 0h5v-2h-5v2zM3 20h2v-2H3v2zm4 0h2v-2H7v2zm4 0h2v-2h-2v2zm4 0h2v-2h-2v2zm4 0h2v-2h-2v2zM3 12h8v-2H3v2zm10 0h8v-2h-8v2zM3 4v4h18V4H3z"></path></g>
<g id="line-weight"><path d="M3 17h18v-2H3v2zm0 3h18v-1H3v1zm0-7h18v-3H3v3zm0-9v4h18V4H3z"></path></g>
<g id="link"><path d="M3.9 12c0-1.71 1.39-3.1 3.1-3.1h4V7H7c-2.76 0-5 2.24-5 5s2.24 5 5 5h4v-1.9H7c-1.71 0-3.1-1.39-3.1-3.1zM8 13h8v-2H8v2zm9-6h-4v1.9h4c1.71 0 3.1 1.39 3.1 3.1s-1.39 3.1-3.1 3.1h-4V17h4c2.76 0 5-2.24 5-5s-2.24-5-5-5z"></path></g>
<g id="list"><path d="M3 13h2v-2H3v2zm0 4h2v-2H3v2zm0-8h2V7H3v2zm4 4h14v-2H7v2zm0 4h14v-2H7v2zM7 7v2h14V7H7z"></path></g>
<g id="lock"><path d="M18 8h-1V6c0-2.76-2.24-5-5-5S7 3.24 7 6v2H6c-1.1 0-2 .9-2 2v10c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V10c0-1.1-.9-2-2-2zm-6 9c-1.1 0-2-.9-2-2s.9-2 2-2 2 .9 2 2-.9 2-2 2zm3.1-9H8.9V6c0-1.71 1.39-3.1 3.1-3.1 1.71 0 3.1 1.39 3.1 3.1v2z"></path></g>
<g id="lock-open"><path d="M12 17c1.1 0 2-.9 2-2s-.9-2-2-2-2 .9-2 2 .9 2 2 2zm6-9h-1V6c0-2.76-2.24-5-5-5S7 3.24 7 6h1.9c0-1.71 1.39-3.1 3.1-3.1 1.71 0 3.1 1.39 3.1 3.1v2H6c-1.1 0-2 .9-2 2v10c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V10c0-1.1-.9-2-2-2zm0 12H6V10h12v10z"></path></g>
<g id="lock-outline"><path d="M12 17c1.1 0 2-.9 2-2s-.9-2-2-2-2 .9-2 2 .9 2 2 2zm6-9h-1V6c0-2.76-2.24-5-5-5S7 3.24 7 6v2H6c-1.1 0-2 .9-2 2v10c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V10c0-1.1-.9-2-2-2zM8.9 6c0-1.71 1.39-3.1 3.1-3.1s3.1 1.39 3.1 3.1v2H8.9V6zM18 20H6V10h12v10z"></path></g>
<g id="low-priority"><path d="M14 5h8v2h-8zm0 5.5h8v2h-8zm0 5.5h8v2h-8zM2 11.5C2 15.08 4.92 18 8.5 18H9v2l3-3-3-3v2h-.5C6.02 16 4 13.98 4 11.5S6.02 7 8.5 7H12V5H8.5C4.92 5 2 7.92 2 11.5z"></path></g>
<g id="loyalty"><path d="M21.41 11.58l-9-9C12.05 2.22 11.55 2 11 2H4c-1.1 0-2 .9-2 2v7c0 .55.22 1.05.59 1.42l9 9c.36.36.86.58 1.41.58.55 0 1.05-.22 1.41-.59l7-7c.37-.36.59-.86.59-1.41 0-.55-.23-1.06-.59-1.42zM5.5 7C4.67 7 4 6.33 4 5.5S4.67 4 5.5 4 7 4.67 7 5.5 6.33 7 5.5 7zm11.77 8.27L13 19.54l-4.27-4.27C8.28 14.81 8 14.19 8 13.5c0-1.38 1.12-2.5 2.5-2.5.69 0 1.32.28 1.77.74l.73.72.73-.73c.45-.45 1.08-.73 1.77-.73 1.38 0 2.5 1.12 2.5 2.5 0 .69-.28 1.32-.73 1.77z"></path></g>
<g id="mail"><path d="M20 4H4c-1.1 0-1.99.9-1.99 2L2 18c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm0 4l-8 5-8-5V6l8 5 8-5v2z"></path></g>
<g id="markunread"><path d="M20 4H4c-1.1 0-1.99.9-1.99 2L2 18c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm0 4l-8 5-8-5V6l8 5 8-5v2z"></path></g>
<g id="markunread-mailbox"><path d="M20 6H10v6H8V4h6V0H6v6H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V8c0-1.1-.9-2-2-2z"></path></g>
<g id="menu"><path d="M3 18h18v-2H3v2zm0-5h18v-2H3v2zm0-7v2h18V6H3z"></path></g>
<g id="more-horiz"><path d="M6 10c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm12 0c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm-6 0c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2z"></path></g>
<g id="more-vert"><path d="M12 8c1.1 0 2-.9 2-2s-.9-2-2-2-2 .9-2 2 .9 2 2 2zm0 2c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm0 6c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2z"></path></g>
<g id="motorcycle"><path d="M19.44 9.03L15.41 5H11v2h3.59l2 2H5c-2.8 0-5 2.2-5 5s2.2 5 5 5c2.46 0 4.45-1.69 4.9-4h1.65l2.77-2.77c-.21.54-.32 1.14-.32 1.77 0 2.8 2.2 5 5 5s5-2.2 5-5c0-2.65-1.97-4.77-4.56-4.97zM7.82 15C7.4 16.15 6.28 17 5 17c-1.63 0-3-1.37-3-3s1.37-3 3-3c1.28 0 2.4.85 2.82 2H5v2h2.82zM19 17c-1.66 0-3-1.34-3-3s1.34-3 3-3 3 1.34 3 3-1.34 3-3 3z"></path></g>
<g id="move-to-inbox"><path d="M19 3H4.99c-1.11 0-1.98.9-1.98 2L3 19c0 1.1.88 2 1.99 2H19c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 12h-4c0 1.66-1.35 3-3 3s-3-1.34-3-3H4.99V5H19v10zm-3-5h-2V7h-4v3H8l4 4 4-4z"></path></g>
<g id="next-week"><path d="M20 7h-4V5c0-.55-.22-1.05-.59-1.41C15.05 3.22 14.55 3 14 3h-4c-1.1 0-2 .9-2 2v2H4c-1.1 0-2 .9-2 2v11c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V9c0-1.1-.9-2-2-2zM10 5h4v2h-4V5zm1 13.5l-1-1 3-3-3-3 1-1 4 4-4 4z"></path></g>
<g id="note-add"><path d="M14 2H6c-1.1 0-1.99.9-1.99 2L4 20c0 1.1.89 2 1.99 2H18c1.1 0 2-.9 2-2V8l-6-6zm2 14h-3v3h-2v-3H8v-2h3v-3h2v3h3v2zm-3-7V3.5L18.5 9H13z"></path></g>
<g id="offline-pin"><path d="M12 2C6.5 2 2 6.5 2 12s4.5 10 10 10 10-4.5 10-10S17.5 2 12 2zm5 16H7v-2h10v2zm-6.7-4L7 10.7l1.4-1.4 1.9 1.9 5.3-5.3L17 7.3 10.3 14z"></path></g>
<g id="opacity"><path d="M17.66 8L12 2.35 6.34 8C4.78 9.56 4 11.64 4 13.64s.78 4.11 2.34 5.67 3.61 2.35 5.66 2.35 4.1-.79 5.66-2.35S20 15.64 20 13.64 19.22 9.56 17.66 8zM6 14c.01-2 .62-3.27 1.76-4.4L12 5.27l4.24 4.38C17.38 10.77 17.99 12 18 14H6z"></path></g>
<g id="open-in-browser"><path d="M19 4H5c-1.11 0-2 .9-2 2v12c0 1.1.89 2 2 2h4v-2H5V8h14v10h-4v2h4c1.1 0 2-.9 2-2V6c0-1.1-.89-2-2-2zm-7 6l-4 4h3v6h2v-6h3l-4-4z"></path></g>
<g id="open-in-new"><path d="M19 19H5V5h7V3H5c-1.11 0-2 .9-2 2v14c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2v-7h-2v7zM14 3v2h3.59l-9.83 9.83 1.41 1.41L19 6.41V10h2V3h-7z"></path></g>
<g id="open-with"><path d="M10 9h4V6h3l-5-5-5 5h3v3zm-1 1H6V7l-5 5 5 5v-3h3v-4zm14 2l-5-5v3h-3v4h3v3l5-5zm-9 3h-4v3H7l5 5 5-5h-3v-3z"></path></g>
<g id="pageview"><path d="M11.5 9C10.12 9 9 10.12 9 11.5s1.12 2.5 2.5 2.5 2.5-1.12 2.5-2.5S12.88 9 11.5 9zM20 4H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm-3.21 14.21l-2.91-2.91c-.69.44-1.51.7-2.39.7C9.01 16 7 13.99 7 11.5S9.01 7 11.5 7 16 9.01 16 11.5c0 .88-.26 1.69-.7 2.39l2.91 2.9-1.42 1.42z"></path></g>
<g id="pan-tool"><path d="M23 5.5V20c0 2.2-1.8 4-4 4h-7.3c-1.08 0-2.1-.43-2.85-1.19L1 14.83s1.26-1.23 1.3-1.25c.22-.19.49-.29.79-.29.22 0 .42.06.6.16.04.01 4.31 2.46 4.31 2.46V4c0-.83.67-1.5 1.5-1.5S11 3.17 11 4v7h1V1.5c0-.83.67-1.5 1.5-1.5S15 .67 15 1.5V11h1V2.5c0-.83.67-1.5 1.5-1.5s1.5.67 1.5 1.5V11h1V5.5c0-.83.67-1.5 1.5-1.5s1.5.67 1.5 1.5z"></path></g>
<g id="payment"><path d="M20 4H4c-1.11 0-1.99.89-1.99 2L2 18c0 1.11.89 2 2 2h16c1.11 0 2-.89 2-2V6c0-1.11-.89-2-2-2zm0 14H4v-6h16v6zm0-10H4V6h16v2z"></path></g>
<g id="perm-camera-mic"><path d="M20 5h-3.17L15 3H9L7.17 5H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h7v-2.09c-2.83-.48-5-2.94-5-5.91h2c0 2.21 1.79 4 4 4s4-1.79 4-4h2c0 2.97-2.17 5.43-5 5.91V21h7c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2zm-6 8c0 1.1-.9 2-2 2s-2-.9-2-2V9c0-1.1.9-2 2-2s2 .9 2 2v4z"></path></g>
<g id="perm-contact-calendar"><path d="M19 3h-1V1h-2v2H8V1H6v2H5c-1.11 0-2 .9-2 2v14c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-7 3c1.66 0 3 1.34 3 3s-1.34 3-3 3-3-1.34-3-3 1.34-3 3-3zm6 12H6v-1c0-2 4-3.1 6-3.1s6 1.1 6 3.1v1z"></path></g>
<g id="perm-data-setting"><path d="M18.99 11.5c.34 0 .67.03 1 .07L20 0 0 20h11.56c-.04-.33-.07-.66-.07-1 0-4.14 3.36-7.5 7.5-7.5zm3.71 7.99c.02-.16.04-.32.04-.49 0-.17-.01-.33-.04-.49l1.06-.83c.09-.08.12-.21.06-.32l-1-1.73c-.06-.11-.19-.15-.31-.11l-1.24.5c-.26-.2-.54-.37-.85-.49l-.19-1.32c-.01-.12-.12-.21-.24-.21h-2c-.12 0-.23.09-.25.21l-.19 1.32c-.3.13-.59.29-.85.49l-1.24-.5c-.11-.04-.24 0-.31.11l-1 1.73c-.06.11-.04.24.06.32l1.06.83c-.02.16-.03.32-.03.49 0 .17.01.33.03.49l-1.06.83c-.09.08-.12.21-.06.32l1 1.73c.06.11.19.15.31.11l1.24-.5c.26.2.54.37.85.49l.19 1.32c.02.12.12.21.25.21h2c.12 0 .23-.09.25-.21l.19-1.32c.3-.13.59-.29.84-.49l1.25.5c.11.04.24 0 .31-.11l1-1.73c.06-.11.03-.24-.06-.32l-1.07-.83zm-3.71 1.01c-.83 0-1.5-.67-1.5-1.5s.67-1.5 1.5-1.5 1.5.67 1.5 1.5-.67 1.5-1.5 1.5z"></path></g>
<g id="perm-device-information"><path d="M13 7h-2v2h2V7zm0 4h-2v6h2v-6zm4-9.99L7 1c-1.1 0-2 .9-2 2v18c0 1.1.9 2 2 2h10c1.1 0 2-.9 2-2V3c0-1.1-.9-1.99-2-1.99zM17 19H7V5h10v14z"></path></g>
<g id="perm-identity"><path d="M12 5.9c1.16 0 2.1.94 2.1 2.1s-.94 2.1-2.1 2.1S9.9 9.16 9.9 8s.94-2.1 2.1-2.1m0 9c2.97 0 6.1 1.46 6.1 2.1v1.1H5.9V17c0-.64 3.13-2.1 6.1-2.1M12 4C9.79 4 8 5.79 8 8s1.79 4 4 4 4-1.79 4-4-1.79-4-4-4zm0 9c-2.67 0-8 1.34-8 4v3h16v-3c0-2.66-5.33-4-8-4z"></path></g>
<g id="perm-media"><path d="M2 6H0v5h.01L0 20c0 1.1.9 2 2 2h18v-2H2V6zm20-2h-8l-2-2H6c-1.1 0-1.99.9-1.99 2L4 16c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zM7 15l4.5-6 3.5 4.51 2.5-3.01L21 15H7z"></path></g>
<g id="perm-phone-msg"><path d="M20 15.5c-1.25 0-2.45-.2-3.57-.57-.35-.11-.74-.03-1.02.24l-2.2 2.2c-2.83-1.44-5.15-3.75-6.59-6.58l2.2-2.21c.28-.27.36-.66.25-1.01C8.7 6.45 8.5 5.25 8.5 4c0-.55-.45-1-1-1H4c-.55 0-1 .45-1 1 0 9.39 7.61 17 17 17 .55 0 1-.45 1-1v-3.5c0-.55-.45-1-1-1zM12 3v10l3-3h6V3h-9z"></path></g>
<g id="perm-scan-wifi"><path d="M12 3C6.95 3 3.15 4.85 0 7.23L12 22 24 7.25C20.85 4.87 17.05 3 12 3zm1 13h-2v-6h2v6zm-2-8V6h2v2h-2z"></path></g>
<g id="pets"><circle cx="4.5" cy="9.5" r="2.5"></circle><circle cx="9" cy="5.5" r="2.5"></circle><circle cx="15" cy="5.5" r="2.5"></circle><circle cx="19.5" cy="9.5" r="2.5"></circle><path d="M17.34 14.86c-.87-1.02-1.6-1.89-2.48-2.91-.46-.54-1.05-1.08-1.75-1.32-.11-.04-.22-.07-.33-.09-.25-.04-.52-.04-.78-.04s-.53 0-.79.05c-.11.02-.22.05-.33.09-.7.24-1.28.78-1.75 1.32-.87 1.02-1.6 1.89-2.48 2.91-1.31 1.31-2.92 2.76-2.62 4.79.29 1.02 1.02 2.03 2.33 2.32.73.15 3.06-.44 5.54-.44h.18c2.48 0 4.81.58 5.54.44 1.31-.29 2.04-1.31 2.33-2.32.31-2.04-1.3-3.49-2.61-4.8z"></path></g>
<g id="picture-in-picture"><path d="M19 7h-8v6h8V7zm2-4H3c-1.1 0-2 .9-2 2v14c0 1.1.9 1.98 2 1.98h18c1.1 0 2-.88 2-1.98V5c0-1.1-.9-2-2-2zm0 16.01H3V4.98h18v14.03z"></path></g>
<g id="picture-in-picture-alt"><path d="M19 11h-8v6h8v-6zm4 8V4.98C23 3.88 22.1 3 21 3H3c-1.1 0-2 .88-2 1.98V19c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2zm-2 .02H3V4.97h18v14.05z"></path></g>
<g id="play-for-work"><path d="M11 5v5.59H7.5l4.5 4.5 4.5-4.5H13V5h-2zm-5 9c0 3.31 2.69 6 6 6s6-2.69 6-6h-2c0 2.21-1.79 4-4 4s-4-1.79-4-4H6z"></path></g>
<g id="polymer"><path d="M19 4h-4L7.11 16.63 4.5 12 9 4H5L.5 12 5 20h4l7.89-12.63L19.5 12 15 20h4l4.5-8z"></path></g>
<g id="power-settings-new"><path d="M13 3h-2v10h2V3zm4.83 2.17l-1.42 1.42C17.99 7.86 19 9.81 19 12c0 3.87-3.13 7-7 7s-7-3.13-7-7c0-2.19 1.01-4.14 2.58-5.42L6.17 5.17C4.23 6.82 3 9.26 3 12c0 4.97 4.03 9 9 9s9-4.03 9-9c0-2.74-1.23-5.18-3.17-6.83z"></path></g>
<g id="pregnant-woman"><path d="M9 4c0-1.11.89-2 2-2s2 .89 2 2-.89 2-2 2-2-.89-2-2zm7 9c-.01-1.34-.83-2.51-2-3 0-1.66-1.34-3-3-3s-3 1.34-3 3v7h2v5h3v-5h3v-4z"></path></g>
<g id="print"><path d="M19 8H5c-1.66 0-3 1.34-3 3v6h4v4h12v-4h4v-6c0-1.66-1.34-3-3-3zm-3 11H8v-5h8v5zm3-7c-.55 0-1-.45-1-1s.45-1 1-1 1 .45 1 1-.45 1-1 1zm-1-9H6v4h12V3z"></path></g>
<g id="query-builder"><path d="M11.99 2C6.47 2 2 6.48 2 12s4.47 10 9.99 10C17.52 22 22 17.52 22 12S17.52 2 11.99 2zM12 20c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8zm.5-13H11v6l5.25 3.15.75-1.23-4.5-2.67z"></path></g>
<g id="question-answer"><path d="M21 6h-2v9H6v2c0 .55.45 1 1 1h11l4 4V7c0-.55-.45-1-1-1zm-4 6V3c0-.55-.45-1-1-1H3c-.55 0-1 .45-1 1v14l4-4h10c.55 0 1-.45 1-1z"></path></g>
<g id="radio-button-checked"><path d="M12 7c-2.76 0-5 2.24-5 5s2.24 5 5 5 5-2.24 5-5-2.24-5-5-5zm0-5C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8z"></path></g>
<g id="radio-button-unchecked"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8z"></path></g>
<g id="receipt"><path d="M18 17H6v-2h12v2zm0-4H6v-2h12v2zm0-4H6V7h12v2zM3 22l1.5-1.5L6 22l1.5-1.5L9 22l1.5-1.5L12 22l1.5-1.5L15 22l1.5-1.5L18 22l1.5-1.5L21 22V2l-1.5 1.5L18 2l-1.5 1.5L15 2l-1.5 1.5L12 2l-1.5 1.5L9 2 7.5 3.5 6 2 4.5 3.5 3 2v20z"></path></g>
<g id="record-voice-over"><circle cx="9" cy="9" r="4"></circle><path d="M9 15c-2.67 0-8 1.34-8 4v2h16v-2c0-2.66-5.33-4-8-4zm7.76-9.64l-1.68 1.69c.84 1.18.84 2.71 0 3.89l1.68 1.69c2.02-2.02 2.02-5.07 0-7.27zM20.07 2l-1.63 1.63c2.77 3.02 2.77 7.56 0 10.74L20.07 16c3.9-3.89 3.91-9.95 0-14z"></path></g>
<g id="redeem"><path d="M20 6h-2.18c.11-.31.18-.65.18-1 0-1.66-1.34-3-3-3-1.05 0-1.96.54-2.5 1.35l-.5.67-.5-.68C10.96 2.54 10.05 2 9 2 7.34 2 6 3.34 6 5c0 .35.07.69.18 1H4c-1.11 0-1.99.89-1.99 2L2 19c0 1.11.89 2 2 2h16c1.11 0 2-.89 2-2V8c0-1.11-.89-2-2-2zm-5-2c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zM9 4c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm11 15H4v-2h16v2zm0-5H4V8h5.08L7 10.83 8.62 12 11 8.76l1-1.36 1 1.36L15.38 12 17 10.83 14.92 8H20v6z"></path></g>
<g id="redo"><path d="M18.4 10.6C16.55 8.99 14.15 8 11.5 8c-4.65 0-8.58 3.03-9.96 7.22L3.9 16c1.05-3.19 4.05-5.5 7.6-5.5 1.95 0 3.73.72 5.12 1.88L13 16h9V7l-3.6 3.6z"></path></g>
<g id="refresh"><path d="M17.65 6.35C16.2 4.9 14.21 4 12 4c-4.42 0-7.99 3.58-7.99 8s3.57 8 7.99 8c3.73 0 6.84-2.55 7.73-6h-2.08c-.82 2.33-3.04 4-5.65 4-3.31 0-6-2.69-6-6s2.69-6 6-6c1.66 0 3.14.69 4.22 1.78L13 11h7V4l-2.35 2.35z"></path></g>
<g id="remove"><path d="M19 13H5v-2h14v2z"></path></g>
<g id="remove-circle"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm5 11H7v-2h10v2z"></path></g>
<g id="remove-circle-outline"><path d="M7 11v2h10v-2H7zm5-9C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8z"></path></g>
<g id="remove-shopping-cart"><path d="M22.73 22.73L2.77 2.77 2 2l-.73-.73L0 2.54l4.39 4.39 2.21 4.66-1.35 2.45c-.16.28-.25.61-.25.96 0 1.1.9 2 2 2h7.46l1.38 1.38c-.5.36-.83.95-.83 1.62 0 1.1.89 2 1.99 2 .67 0 1.26-.33 1.62-.84L21.46 24l1.27-1.27zM7.42 15c-.14 0-.25-.11-.25-.25l.03-.12.9-1.63h2.36l2 2H7.42zm8.13-2c.75 0 1.41-.41 1.75-1.03l3.58-6.49c.08-.14.12-.31.12-.48 0-.55-.45-1-1-1H6.54l9.01 9zM7 18c-1.1 0-1.99.9-1.99 2S5.9 22 7 22s2-.9 2-2-.9-2-2-2z"></path></g>
<g id="reorder"><path d="M3 15h18v-2H3v2zm0 4h18v-2H3v2zm0-8h18V9H3v2zm0-6v2h18V5H3z"></path></g>
<g id="reply"><path d="M10 9V5l-7 7 7 7v-4.1c5 0 8.5 1.6 11 5.1-1-5-4-10-11-11z"></path></g>
<g id="reply-all"><path d="M7 8V5l-7 7 7 7v-3l-4-4 4-4zm6 1V5l-7 7 7 7v-4.1c5 0 8.5 1.6 11 5.1-1-5-4-10-11-11z"></path></g>
<g id="report"><path d="M15.73 3H8.27L3 8.27v7.46L8.27 21h7.46L21 15.73V8.27L15.73 3zM12 17.3c-.72 0-1.3-.58-1.3-1.3 0-.72.58-1.3 1.3-1.3.72 0 1.3.58 1.3 1.3 0 .72-.58 1.3-1.3 1.3zm1-4.3h-2V7h2v6z"></path></g>
<g id="report-problem"><path d="M1 21h22L12 2 1 21zm12-3h-2v-2h2v2zm0-4h-2v-4h2v4z"></path></g>
<g id="restore"><path d="M13 3c-4.97 0-9 4.03-9 9H1l3.89 3.89.07.14L9 12H6c0-3.87 3.13-7 7-7s7 3.13 7 7-3.13 7-7 7c-1.93 0-3.68-.79-4.94-2.06l-1.42 1.42C8.27 19.99 10.51 21 13 21c4.97 0 9-4.03 9-9s-4.03-9-9-9zm-1 5v5l4.28 2.54.72-1.21-3.5-2.08V8H12z"></path></g>
<g id="restore-page"><path d="M14 2H6c-1.1 0-1.99.9-1.99 2L4 20c0 1.1.89 2 1.99 2H18c1.1 0 2-.9 2-2V8l-6-6zm-2 16c-2.05 0-3.81-1.24-4.58-3h1.71c.63.9 1.68 1.5 2.87 1.5 1.93 0 3.5-1.57 3.5-3.5S13.93 9.5 12 9.5c-1.35 0-2.52.78-3.1 1.9l1.6 1.6h-4V9l1.3 1.3C8.69 8.92 10.23 8 12 8c2.76 0 5 2.24 5 5s-2.24 5-5 5z"></path></g>
<g id="room"><path d="M12 2C8.13 2 5 5.13 5 9c0 5.25 7 13 7 13s7-7.75 7-13c0-3.87-3.13-7-7-7zm0 9.5c-1.38 0-2.5-1.12-2.5-2.5s1.12-2.5 2.5-2.5 2.5 1.12 2.5 2.5-1.12 2.5-2.5 2.5z"></path></g>
<g id="rounded-corner"><path d="M19 19h2v2h-2v-2zm0-2h2v-2h-2v2zM3 13h2v-2H3v2zm0 4h2v-2H3v2zm0-8h2V7H3v2zm0-4h2V3H3v2zm4 0h2V3H7v2zm8 16h2v-2h-2v2zm-4 0h2v-2h-2v2zm4 0h2v-2h-2v2zm-8 0h2v-2H7v2zm-4 0h2v-2H3v2zM21 8c0-2.76-2.24-5-5-5h-5v2h5c1.65 0 3 1.35 3 3v5h2V8z"></path></g>
<g id="rowing"><path d="M8.5 14.5L4 19l1.5 1.5L9 17h2l-2.5-2.5zM15 1c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm6 20.01L18 24l-2.99-3.01V19.5l-7.1-7.09c-.31.05-.61.07-.91.07v-2.16c1.66.03 3.61-.87 4.67-2.04l1.4-1.55c.19-.21.43-.38.69-.5.29-.14.62-.23.96-.23h.03C15.99 6.01 17 7.02 17 8.26v5.75c0 .84-.35 1.61-.92 2.16l-3.58-3.58v-2.27c-.63.52-1.43 1.02-2.29 1.39L16.5 18H18l3 3.01z"></path></g>
<g id="save"><path d="M17 3H5c-1.11 0-2 .9-2 2v14c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V7l-4-4zm-5 16c-1.66 0-3-1.34-3-3s1.34-3 3-3 3 1.34 3 3-1.34 3-3 3zm3-10H5V5h10v4z"></path></g>
<g id="schedule"><path d="M11.99 2C6.47 2 2 6.48 2 12s4.47 10 9.99 10C17.52 22 22 17.52 22 12S17.52 2 11.99 2zM12 20c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8zm.5-13H11v6l5.25 3.15.75-1.23-4.5-2.67z"></path></g>
<g id="search"><path d="M15.5 14h-.79l-.28-.27C15.41 12.59 16 11.11 16 9.5 16 5.91 13.09 3 9.5 3S3 5.91 3 9.5 5.91 16 9.5 16c1.61 0 3.09-.59 4.23-1.57l.27.28v.79l5 4.99L20.49 19l-4.99-5zm-6 0C7.01 14 5 11.99 5 9.5S7.01 5 9.5 5 14 7.01 14 9.5 11.99 14 9.5 14z"></path></g>
<g id="select-all"><path d="M3 5h2V3c-1.1 0-2 .9-2 2zm0 8h2v-2H3v2zm4 8h2v-2H7v2zM3 9h2V7H3v2zm10-6h-2v2h2V3zm6 0v2h2c0-1.1-.9-2-2-2zM5 21v-2H3c0 1.1.9 2 2 2zm-2-4h2v-2H3v2zM9 3H7v2h2V3zm2 18h2v-2h-2v2zm8-8h2v-2h-2v2zm0 8c1.1 0 2-.9 2-2h-2v2zm0-12h2V7h-2v2zm0 8h2v-2h-2v2zm-4 4h2v-2h-2v2zm0-16h2V3h-2v2zM7 17h10V7H7v10zm2-8h6v6H9V9z"></path></g>
<g id="send"><path d="M2.01 21L23 12 2.01 3 2 10l15 2-15 2z"></path></g>
<g id="settings"><path d="M19.43 12.98c.04-.32.07-.64.07-.98s-.03-.66-.07-.98l2.11-1.65c.19-.15.24-.42.12-.64l-2-3.46c-.12-.22-.39-.3-.61-.22l-2.49 1c-.52-.4-1.08-.73-1.69-.98l-.38-2.65C14.46 2.18 14.25 2 14 2h-4c-.25 0-.46.18-.49.42l-.38 2.65c-.61.25-1.17.59-1.69.98l-2.49-1c-.23-.09-.49 0-.61.22l-2 3.46c-.13.22-.07.49.12.64l2.11 1.65c-.04.32-.07.65-.07.98s.03.66.07.98l-2.11 1.65c-.19.15-.24.42-.12.64l2 3.46c.12.22.39.3.61.22l2.49-1c.52.4 1.08.73 1.69.98l.38 2.65c.03.24.24.42.49.42h4c.25 0 .46-.18.49-.42l.38-2.65c.61-.25 1.17-.59 1.69-.98l2.49 1c.23.09.49 0 .61-.22l2-3.46c.12-.22.07-.49-.12-.64l-2.11-1.65zM12 15.5c-1.93 0-3.5-1.57-3.5-3.5s1.57-3.5 3.5-3.5 3.5 1.57 3.5 3.5-1.57 3.5-3.5 3.5z"></path></g>
<g id="settings-applications"><path d="M12 10c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm7-7H5c-1.11 0-2 .9-2 2v14c0 1.1.89 2 2 2h14c1.11 0 2-.9 2-2V5c0-1.1-.89-2-2-2zm-1.75 9c0 .23-.02.46-.05.68l1.48 1.16c.13.11.17.3.08.45l-1.4 2.42c-.09.15-.27.21-.43.15l-1.74-.7c-.36.28-.76.51-1.18.69l-.26 1.85c-.03.17-.18.3-.35.3h-2.8c-.17 0-.32-.13-.35-.29l-.26-1.85c-.43-.18-.82-.41-1.18-.69l-1.74.7c-.16.06-.34 0-.43-.15l-1.4-2.42c-.09-.15-.05-.34.08-.45l1.48-1.16c-.03-.23-.05-.46-.05-.69 0-.23.02-.46.05-.68l-1.48-1.16c-.13-.11-.17-.3-.08-.45l1.4-2.42c.09-.15.27-.21.43-.15l1.74.7c.36-.28.76-.51 1.18-.69l.26-1.85c.03-.17.18-.3.35-.3h2.8c.17 0 .32.13.35.29l.26 1.85c.43.18.82.41 1.18.69l1.74-.7c.16-.06.34 0 .43.15l1.4 2.42c.09.15.05.34-.08.45l-1.48 1.16c.03.23.05.46.05.69z"></path></g>
<g id="settings-backup-restore"><path d="M14 12c0-1.1-.9-2-2-2s-2 .9-2 2 .9 2 2 2 2-.9 2-2zm-2-9c-4.97 0-9 4.03-9 9H0l4 4 4-4H5c0-3.87 3.13-7 7-7s7 3.13 7 7-3.13 7-7 7c-1.51 0-2.91-.49-4.06-1.3l-1.42 1.44C8.04 20.3 9.94 21 12 21c4.97 0 9-4.03 9-9s-4.03-9-9-9z"></path></g>
<g id="settings-bluetooth"><path d="M11 24h2v-2h-2v2zm-4 0h2v-2H7v2zm8 0h2v-2h-2v2zm2.71-18.29L12 0h-1v7.59L6.41 3 5 4.41 10.59 10 5 15.59 6.41 17 11 12.41V20h1l5.71-5.71-4.3-4.29 4.3-4.29zM13 3.83l1.88 1.88L13 7.59V3.83zm1.88 10.46L13 16.17v-3.76l1.88 1.88z"></path></g>
<g id="settings-brightness"><path d="M21 3H3c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16.01H3V4.99h18v14.02zM8 16h2.5l1.5 1.5 1.5-1.5H16v-2.5l1.5-1.5-1.5-1.5V8h-2.5L12 6.5 10.5 8H8v2.5L6.5 12 8 13.5V16zm4-7c1.66 0 3 1.34 3 3s-1.34 3-3 3V9z"></path></g>
<g id="settings-cell"><path d="M7 24h2v-2H7v2zm4 0h2v-2h-2v2zm4 0h2v-2h-2v2zM16 .01L8 0C6.9 0 6 .9 6 2v16c0 1.1.9 2 2 2h8c1.1 0 2-.9 2-2V2c0-1.1-.9-1.99-2-1.99zM16 16H8V4h8v12z"></path></g>
<g id="settings-ethernet"><path d="M7.77 6.76L6.23 5.48.82 12l5.41 6.52 1.54-1.28L3.42 12l4.35-5.24zM7 13h2v-2H7v2zm10-2h-2v2h2v-2zm-6 2h2v-2h-2v2zm6.77-7.52l-1.54 1.28L20.58 12l-4.35 5.24 1.54 1.28L23.18 12l-5.41-6.52z"></path></g>
<g id="settings-input-antenna"><path d="M12 5c-3.87 0-7 3.13-7 7h2c0-2.76 2.24-5 5-5s5 2.24 5 5h2c0-3.87-3.13-7-7-7zm1 9.29c.88-.39 1.5-1.26 1.5-2.29 0-1.38-1.12-2.5-2.5-2.5S9.5 10.62 9.5 12c0 1.02.62 1.9 1.5 2.29v3.3L7.59 21 9 22.41l3-3 3 3L16.41 21 13 17.59v-3.3zM12 1C5.93 1 1 5.93 1 12h2c0-4.97 4.03-9 9-9s9 4.03 9 9h2c0-6.07-4.93-11-11-11z"></path></g>
<g id="settings-input-component"><path d="M5 2c0-.55-.45-1-1-1s-1 .45-1 1v4H1v6h6V6H5V2zm4 14c0 1.3.84 2.4 2 2.82V23h2v-4.18c1.16-.41 2-1.51 2-2.82v-2H9v2zm-8 0c0 1.3.84 2.4 2 2.82V23h2v-4.18C6.16 18.4 7 17.3 7 16v-2H1v2zM21 6V2c0-.55-.45-1-1-1s-1 .45-1 1v4h-2v6h6V6h-2zm-8-4c0-.55-.45-1-1-1s-1 .45-1 1v4H9v6h6V6h-2V2zm4 14c0 1.3.84 2.4 2 2.82V23h2v-4.18c1.16-.41 2-1.51 2-2.82v-2h-6v2z"></path></g>
<g id="settings-input-composite"><path d="M5 2c0-.55-.45-1-1-1s-1 .45-1 1v4H1v6h6V6H5V2zm4 14c0 1.3.84 2.4 2 2.82V23h2v-4.18c1.16-.41 2-1.51 2-2.82v-2H9v2zm-8 0c0 1.3.84 2.4 2 2.82V23h2v-4.18C6.16 18.4 7 17.3 7 16v-2H1v2zM21 6V2c0-.55-.45-1-1-1s-1 .45-1 1v4h-2v6h6V6h-2zm-8-4c0-.55-.45-1-1-1s-1 .45-1 1v4H9v6h6V6h-2V2zm4 14c0 1.3.84 2.4 2 2.82V23h2v-4.18c1.16-.41 2-1.51 2-2.82v-2h-6v2z"></path></g>
<g id="settings-input-hdmi"><path d="M18 7V4c0-1.1-.9-2-2-2H8c-1.1 0-2 .9-2 2v3H5v6l3 6v3h8v-3l3-6V7h-1zM8 4h8v3h-2V5h-1v2h-2V5h-1v2H8V4z"></path></g>
<g id="settings-input-svideo"><path d="M8 11.5c0-.83-.67-1.5-1.5-1.5S5 10.67 5 11.5 5.67 13 6.5 13 8 12.33 8 11.5zm7-5c0-.83-.67-1.5-1.5-1.5h-3C9.67 5 9 5.67 9 6.5S9.67 8 10.5 8h3c.83 0 1.5-.67 1.5-1.5zM8.5 15c-.83 0-1.5.67-1.5 1.5S7.67 18 8.5 18s1.5-.67 1.5-1.5S9.33 15 8.5 15zM12 1C5.93 1 1 5.93 1 12s4.93 11 11 11 11-4.93 11-11S18.07 1 12 1zm0 20c-4.96 0-9-4.04-9-9s4.04-9 9-9 9 4.04 9 9-4.04 9-9 9zm5.5-11c-.83 0-1.5.67-1.5 1.5s.67 1.5 1.5 1.5 1.5-.67 1.5-1.5-.67-1.5-1.5-1.5zm-2 5c-.83 0-1.5.67-1.5 1.5s.67 1.5 1.5 1.5 1.5-.67 1.5-1.5-.67-1.5-1.5-1.5z"></path></g>
<g id="settings-overscan"><path d="M12.01 5.5L10 8h4l-1.99-2.5zM18 10v4l2.5-1.99L18 10zM6 10l-2.5 2.01L6 14v-4zm8 6h-4l2.01 2.5L14 16zm7-13H3c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16.01H3V4.99h18v14.02z"></path></g>
<g id="settings-phone"><path d="M13 9h-2v2h2V9zm4 0h-2v2h2V9zm3 6.5c-1.25 0-2.45-.2-3.57-.57-.35-.11-.74-.03-1.02.24l-2.2 2.2c-2.83-1.44-5.15-3.75-6.59-6.58l2.2-2.21c.28-.27.36-.66.25-1.01C8.7 6.45 8.5 5.25 8.5 4c0-.55-.45-1-1-1H4c-.55 0-1 .45-1 1 0 9.39 7.61 17 17 17 .55 0 1-.45 1-1v-3.5c0-.55-.45-1-1-1zM19 9v2h2V9h-2z"></path></g>
<g id="settings-power"><path d="M7 24h2v-2H7v2zm4 0h2v-2h-2v2zm2-22h-2v10h2V2zm3.56 2.44l-1.45 1.45C16.84 6.94 18 8.83 18 11c0 3.31-2.69 6-6 6s-6-2.69-6-6c0-2.17 1.16-4.06 2.88-5.12L7.44 4.44C5.36 5.88 4 8.28 4 11c0 4.42 3.58 8 8 8s8-3.58 8-8c0-2.72-1.36-5.12-3.44-6.56zM15 24h2v-2h-2v2z"></path></g>
<g id="settings-remote"><path d="M15 9H9c-.55 0-1 .45-1 1v12c0 .55.45 1 1 1h6c.55 0 1-.45 1-1V10c0-.55-.45-1-1-1zm-3 6c-1.1 0-2-.9-2-2s.9-2 2-2 2 .9 2 2-.9 2-2 2zM7.05 6.05l1.41 1.41C9.37 6.56 10.62 6 12 6s2.63.56 3.54 1.46l1.41-1.41C15.68 4.78 13.93 4 12 4s-3.68.78-4.95 2.05zM12 0C8.96 0 6.21 1.23 4.22 3.22l1.41 1.41C7.26 3.01 9.51 2 12 2s4.74 1.01 6.36 2.64l1.41-1.41C17.79 1.23 15.04 0 12 0z"></path></g>
<g id="settings-voice"><path d="M7 24h2v-2H7v2zm5-11c1.66 0 2.99-1.34 2.99-3L15 4c0-1.66-1.34-3-3-3S9 2.34 9 4v6c0 1.66 1.34 3 3 3zm-1 11h2v-2h-2v2zm4 0h2v-2h-2v2zm4-14h-1.7c0 3-2.54 5.1-5.3 5.1S6.7 13 6.7 10H5c0 3.41 2.72 6.23 6 6.72V20h2v-3.28c3.28-.49 6-3.31 6-6.72z"></path></g>
<g id="shop"><path d="M16 6V4c0-1.11-.89-2-2-2h-4c-1.11 0-2 .89-2 2v2H2v13c0 1.11.89 2 2 2h16c1.11 0 2-.89 2-2V6h-6zm-6-2h4v2h-4V4zM9 18V9l7.5 4L9 18z"></path></g>
<g id="shop-two"><path d="M3 9H1v11c0 1.11.89 2 2 2h14c1.11 0 2-.89 2-2H3V9zm15-4V3c0-1.11-.89-2-2-2h-4c-1.11 0-2 .89-2 2v2H5v11c0 1.11.89 2 2 2h14c1.11 0 2-.89 2-2V5h-5zm-6-2h4v2h-4V3zm0 12V8l5.5 3-5.5 4z"></path></g>
<g id="shopping-basket"><path d="M17.21 9l-4.38-6.56c-.19-.28-.51-.42-.83-.42-.32 0-.64.14-.83.43L6.79 9H2c-.55 0-1 .45-1 1 0 .09.01.18.04.27l2.54 9.27c.23.84 1 1.46 1.92 1.46h13c.92 0 1.69-.62 1.93-1.46l2.54-9.27L23 10c0-.55-.45-1-1-1h-4.79zM9 9l3-4.4L15 9H9zm3 8c-1.1 0-2-.9-2-2s.9-2 2-2 2 .9 2 2-.9 2-2 2z"></path></g>
<g id="shopping-cart"><path d="M7 18c-1.1 0-1.99.9-1.99 2S5.9 22 7 22s2-.9 2-2-.9-2-2-2zM1 2v2h2l3.6 7.59-1.35 2.45c-.16.28-.25.61-.25.96 0 1.1.9 2 2 2h12v-2H7.42c-.14 0-.25-.11-.25-.25l.03-.12.9-1.63h7.45c.75 0 1.41-.41 1.75-1.03l3.58-6.49c.08-.14.12-.31.12-.48 0-.55-.45-1-1-1H5.21l-.94-2H1zm16 16c-1.1 0-1.99.9-1.99 2s.89 2 1.99 2 2-.9 2-2-.9-2-2-2z"></path></g>
<g id="sort"><path d="M3 18h6v-2H3v2zM3 6v2h18V6H3zm0 7h12v-2H3v2z"></path></g>
<g id="speaker-notes"><path d="M20 2H4c-1.1 0-1.99.9-1.99 2L2 22l4-4h14c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zM8 14H6v-2h2v2zm0-3H6V9h2v2zm0-3H6V6h2v2zm7 6h-5v-2h5v2zm3-3h-8V9h8v2zm0-3h-8V6h8v2z"></path></g>
<g id="speaker-notes-off"><path d="M10.54 11l-.54-.54L7.54 8 6 6.46 2.38 2.84 1.27 1.73 0 3l2.01 2.01L2 22l4-4h9l5.73 5.73L22 22.46 17.54 18l-7-7zM8 14H6v-2h2v2zm-2-3V9l2 2H6zm14-9H4.08L10 7.92V6h8v2h-7.92l1 1H18v2h-4.92l6.99 6.99C21.14 17.95 22 17.08 22 16V4c0-1.1-.9-2-2-2z"></path></g>
<g id="spellcheck"><path d="M12.45 16h2.09L9.43 3H7.57L2.46 16h2.09l1.12-3h5.64l1.14 3zm-6.02-5L8.5 5.48 10.57 11H6.43zm15.16.59l-8.09 8.09L9.83 16l-1.41 1.41 5.09 5.09L23 13l-1.41-1.41z"></path></g>
<g id="star"><path d="M12 17.27L18.18 21l-1.64-7.03L22 9.24l-7.19-.61L12 2 9.19 8.63 2 9.24l5.46 4.73L5.82 21z"></path></g>
<g id="star-border"><path d="M22 9.24l-7.19-.62L12 2 9.19 8.63 2 9.24l5.46 4.73L5.82 21 12 17.27 18.18 21l-1.63-7.03L22 9.24zM12 15.4l-3.76 2.27 1-4.28-3.32-2.88 4.38-.38L12 6.1l1.71 4.04 4.38.38-3.32 2.88 1 4.28L12 15.4z"></path></g>
<g id="star-half"><path d="M22 9.24l-7.19-.62L12 2 9.19 8.63 2 9.24l5.46 4.73L5.82 21 12 17.27 18.18 21l-1.63-7.03L22 9.24zM12 15.4V6.1l1.71 4.04 4.38.38-3.32 2.88 1 4.28L12 15.4z"></path></g>
<g id="stars"><path d="M11.99 2C6.47 2 2 6.48 2 12s4.47 10 9.99 10C17.52 22 22 17.52 22 12S17.52 2 11.99 2zm4.24 16L12 15.45 7.77 18l1.12-4.81-3.73-3.23 4.92-.42L12 5l1.92 4.53 4.92.42-3.73 3.23L16.23 18z"></path></g>
<g id="store"><path d="M20 4H4v2h16V4zm1 10v-2l-1-5H4l-1 5v2h1v6h10v-6h4v6h2v-6h1zm-9 4H6v-4h6v4z"></path></g>
<g id="subdirectory-arrow-left"><path d="M11 9l1.42 1.42L8.83 14H18V4h2v12H8.83l3.59 3.58L11 21l-6-6 6-6z"></path></g>
<g id="subdirectory-arrow-right"><path d="M19 15l-6 6-1.42-1.42L15.17 16H4V4h2v10h9.17l-3.59-3.58L13 9l6 6z"></path></g>
<g id="subject"><path d="M14 17H4v2h10v-2zm6-8H4v2h16V9zM4 15h16v-2H4v2zM4 5v2h16V5H4z"></path></g>
<g id="supervisor-account"><path d="M16.5 12c1.38 0 2.49-1.12 2.49-2.5S17.88 7 16.5 7C15.12 7 14 8.12 14 9.5s1.12 2.5 2.5 2.5zM9 11c1.66 0 2.99-1.34 2.99-3S10.66 5 9 5C7.34 5 6 6.34 6 8s1.34 3 3 3zm7.5 3c-1.83 0-5.5.92-5.5 2.75V19h11v-2.25c0-1.83-3.67-2.75-5.5-2.75zM9 13c-2.33 0-7 1.17-7 3.5V19h7v-2.25c0-.85.33-2.34 2.37-3.47C10.5 13.1 9.66 13 9 13z"></path></g>
<g id="swap-horiz"><path d="M6.99 11L3 15l3.99 4v-3H14v-2H6.99v-3zM21 9l-3.99-4v3H10v2h7.01v3L21 9z"></path></g>
<g id="swap-vert"><path d="M16 17.01V10h-2v7.01h-3L15 21l4-3.99h-3zM9 3L5 6.99h3V14h2V6.99h3L9 3z"></path></g>
<g id="swap-vertical-circle"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zM6.5 9L10 5.5 13.5 9H11v4H9V9H6.5zm11 6L14 18.5 10.5 15H13v-4h2v4h2.5z"></path></g>
<g id="system-update-alt"><path d="M12 16.5l4-4h-3v-9h-2v9H8l4 4zm9-13h-6v1.99h6v14.03H3V5.49h6V3.5H3c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2v-14c0-1.1-.9-2-2-2z"></path></g>
<g id="tab"><path d="M21 3H3c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16H3V5h10v4h8v10z"></path></g>
<g id="tab-unselected"><path d="M1 9h2V7H1v2zm0 4h2v-2H1v2zm0-8h2V3c-1.1 0-2 .9-2 2zm8 16h2v-2H9v2zm-8-4h2v-2H1v2zm2 4v-2H1c0 1.1.9 2 2 2zM21 3h-8v6h10V5c0-1.1-.9-2-2-2zm0 14h2v-2h-2v2zM9 5h2V3H9v2zM5 21h2v-2H5v2zM5 5h2V3H5v2zm16 16c1.1 0 2-.9 2-2h-2v2zm0-8h2v-2h-2v2zm-8 8h2v-2h-2v2zm4 0h2v-2h-2v2z"></path></g>
<g id="text-format"><path d="M5 17v2h14v-2H5zm4.5-4.2h5l.9 2.2h2.1L12.75 4h-1.5L6.5 15h2.1l.9-2.2zM12 5.98L13.87 11h-3.74L12 5.98z"></path></g>
<g id="theaters"><path d="M18 3v2h-2V3H8v2H6V3H4v18h2v-2h2v2h8v-2h2v2h2V3h-2zM8 17H6v-2h2v2zm0-4H6v-2h2v2zm0-4H6V7h2v2zm10 8h-2v-2h2v2zm0-4h-2v-2h2v2zm0-4h-2V7h2v2z"></path></g>
<g id="thumb-down"><path d="M15 3H6c-.83 0-1.54.5-1.84 1.22l-3.02 7.05c-.09.23-.14.47-.14.73v1.91l.01.01L1 14c0 1.1.9 2 2 2h6.31l-.95 4.57-.03.32c0 .41.17.79.44 1.06L9.83 23l6.59-6.59c.36-.36.58-.86.58-1.41V5c0-1.1-.9-2-2-2zm4 0v12h4V3h-4z"></path></g>
<g id="thumb-up"><path d="M1 21h4V9H1v12zm22-11c0-1.1-.9-2-2-2h-6.31l.95-4.57.03-.32c0-.41-.17-.79-.44-1.06L14.17 1 7.59 7.59C7.22 7.95 7 8.45 7 9v10c0 1.1.9 2 2 2h9c.83 0 1.54-.5 1.84-1.22l3.02-7.05c.09-.23.14-.47.14-.73v-1.91l-.01-.01L23 10z"></path></g>
<g id="thumbs-up-down"><path d="M12 6c0-.55-.45-1-1-1H5.82l.66-3.18.02-.23c0-.31-.13-.59-.33-.8L5.38 0 .44 4.94C.17 5.21 0 5.59 0 6v6.5c0 .83.67 1.5 1.5 1.5h6.75c.62 0 1.15-.38 1.38-.91l2.26-5.29c.07-.17.11-.36.11-.55V6zm10.5 4h-6.75c-.62 0-1.15.38-1.38.91l-2.26 5.29c-.07.17-.11.36-.11.55V18c0 .55.45 1 1 1h5.18l-.66 3.18-.02.24c0 .31.13.59.33.8l.79.78 4.94-4.94c.27-.27.44-.65.44-1.06v-6.5c0-.83-.67-1.5-1.5-1.5z"></path></g>
<g id="timeline"><path d="M23 8c0 1.1-.9 2-2 2-.18 0-.35-.02-.51-.07l-3.56 3.55c.05.16.07.34.07.52 0 1.1-.9 2-2 2s-2-.9-2-2c0-.18.02-.36.07-.52l-2.55-2.55c-.16.05-.34.07-.52.07s-.36-.02-.52-.07l-4.55 4.56c.05.16.07.33.07.51 0 1.1-.9 2-2 2s-2-.9-2-2 .9-2 2-2c.18 0 .35.02.51.07l4.56-4.55C8.02 9.36 8 9.18 8 9c0-1.1.9-2 2-2s2 .9 2 2c0 .18-.02.36-.07.52l2.55 2.55c.16-.05.34-.07.52-.07s.36.02.52.07l3.55-3.56C19.02 8.35 19 8.18 19 8c0-1.1.9-2 2-2s2 .9 2 2z"></path></g>
<g id="toc"><path d="M3 9h14V7H3v2zm0 4h14v-2H3v2zm0 4h14v-2H3v2zm16 0h2v-2h-2v2zm0-10v2h2V7h-2zm0 6h2v-2h-2v2z"></path></g>
<g id="today"><path d="M19 3h-1V1h-2v2H8V1H6v2H5c-1.11 0-1.99.9-1.99 2L3 19c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16H5V8h14v11zM7 10h5v5H7z"></path></g>
<g id="toll"><path d="M15 4c-4.42 0-8 3.58-8 8s3.58 8 8 8 8-3.58 8-8-3.58-8-8-8zm0 14c-3.31 0-6-2.69-6-6s2.69-6 6-6 6 2.69 6 6-2.69 6-6 6zM3 12c0-2.61 1.67-4.83 4-5.65V4.26C3.55 5.15 1 8.27 1 12s2.55 6.85 6 7.74v-2.09c-2.33-.82-4-3.04-4-5.65z"></path></g>
<g id="touch-app"><path d="M9 11.24V7.5C9 6.12 10.12 5 11.5 5S14 6.12 14 7.5v3.74c1.21-.81 2-2.18 2-3.74C16 5.01 13.99 3 11.5 3S7 5.01 7 7.5c0 1.56.79 2.93 2 3.74zm9.84 4.63l-4.54-2.26c-.17-.07-.35-.11-.54-.11H13v-6c0-.83-.67-1.5-1.5-1.5S10 6.67 10 7.5v10.74l-3.43-.72c-.08-.01-.15-.03-.24-.03-.31 0-.59.13-.79.33l-.79.8 4.94 4.94c.27.27.65.44 1.06.44h6.79c.75 0 1.33-.55 1.44-1.28l.75-5.27c.01-.07.02-.14.02-.2 0-.62-.38-1.16-.91-1.38z"></path></g>
<g id="track-changes"><path d="M19.07 4.93l-1.41 1.41C19.1 7.79 20 9.79 20 12c0 4.42-3.58 8-8 8s-8-3.58-8-8c0-4.08 3.05-7.44 7-7.93v2.02C8.16 6.57 6 9.03 6 12c0 3.31 2.69 6 6 6s6-2.69 6-6c0-1.66-.67-3.16-1.76-4.24l-1.41 1.41C15.55 9.9 16 10.9 16 12c0 2.21-1.79 4-4 4s-4-1.79-4-4c0-1.86 1.28-3.41 3-3.86v2.14c-.6.35-1 .98-1 1.72 0 1.1.9 2 2 2s2-.9 2-2c0-.74-.4-1.38-1-1.72V2h-1C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10c0-2.76-1.12-5.26-2.93-7.07z"></path></g>
<g id="translate"><path d="M12.87 15.07l-2.54-2.51.03-.03c1.74-1.94 2.98-4.17 3.71-6.53H17V4h-7V2H8v2H1v1.99h11.17C11.5 7.92 10.44 9.75 9 11.35 8.07 10.32 7.3 9.19 6.69 8h-2c.73 1.63 1.73 3.17 2.98 4.56l-5.09 5.02L4 19l5-5 3.11 3.11.76-2.04zM18.5 10h-2L12 22h2l1.12-3h4.75L21 22h2l-4.5-12zm-2.62 7l1.62-4.33L19.12 17h-3.24z"></path></g>
<g id="trending-down"><path d="M16 18l2.29-2.29-4.88-4.88-4 4L2 7.41 3.41 6l6 6 4-4 6.3 6.29L22 12v6z"></path></g>
<g id="trending-flat"><path d="M22 12l-4-4v3H3v2h15v3z"></path></g>
<g id="trending-up"><path d="M16 6l2.29 2.29-4.88 4.88-4-4L2 16.59 3.41 18l6-6 4 4 6.3-6.29L22 12V6z"></path></g>
<g id="turned-in"><path d="M17 3H7c-1.1 0-1.99.9-1.99 2L5 21l7-3 7 3V5c0-1.1-.9-2-2-2z"></path></g>
<g id="turned-in-not"><path d="M17 3H7c-1.1 0-1.99.9-1.99 2L5 21l7-3 7 3V5c0-1.1-.9-2-2-2zm0 15l-5-2.18L7 18V5h10v13z"></path></g>
<g id="unarchive"><path d="M20.55 5.22l-1.39-1.68C18.88 3.21 18.47 3 18 3H6c-.47 0-.88.21-1.15.55L3.46 5.22C3.17 5.57 3 6.01 3 6.5V19c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V6.5c0-.49-.17-.93-.45-1.28zM12 9.5l5.5 5.5H14v2h-4v-2H6.5L12 9.5zM5.12 5l.82-1h12l.93 1H5.12z"></path></g>
<g id="undo"><path d="M12.5 8c-2.65 0-5.05.99-6.9 2.6L2 7v9h9l-3.62-3.62c1.39-1.16 3.16-1.88 5.12-1.88 3.54 0 6.55 2.31 7.6 5.5l2.37-.78C21.08 11.03 17.15 8 12.5 8z"></path></g>
<g id="unfold-less"><path d="M7.41 18.59L8.83 20 12 16.83 15.17 20l1.41-1.41L12 14l-4.59 4.59zm9.18-13.18L15.17 4 12 7.17 8.83 4 7.41 5.41 12 10l4.59-4.59z"></path></g>
<g id="unfold-more"><path d="M12 5.83L15.17 9l1.41-1.41L12 3 7.41 7.59 8.83 9 12 5.83zm0 12.34L8.83 15l-1.41 1.41L12 21l4.59-4.59L15.17 15 12 18.17z"></path></g>
<g id="update"><path d="M21 10.12h-6.78l2.74-2.82c-2.73-2.7-7.15-2.8-9.88-.1-2.73 2.71-2.73 7.08 0 9.79 2.73 2.71 7.15 2.71 9.88 0C18.32 15.65 19 14.08 19 12.1h2c0 1.98-.88 4.55-2.64 6.29-3.51 3.48-9.21 3.48-12.72 0-3.5-3.47-3.53-9.11-.02-12.58 3.51-3.47 9.14-3.47 12.65 0L21 3v7.12zM12.5 8v4.25l3.5 2.08-.72 1.21L11 13V8h1.5z"></path></g>
<g id="verified-user"><path d="M12 1L3 5v6c0 5.55 3.84 10.74 9 12 5.16-1.26 9-6.45 9-12V5l-9-4zm-2 16l-4-4 1.41-1.41L10 14.17l6.59-6.59L18 9l-8 8z"></path></g>
<g id="view-agenda"><path d="M20 13H3c-.55 0-1 .45-1 1v6c0 .55.45 1 1 1h17c.55 0 1-.45 1-1v-6c0-.55-.45-1-1-1zm0-10H3c-.55 0-1 .45-1 1v6c0 .55.45 1 1 1h17c.55 0 1-.45 1-1V4c0-.55-.45-1-1-1z"></path></g>
<g id="view-array"><path d="M4 18h3V5H4v13zM18 5v13h3V5h-3zM8 18h9V5H8v13z"></path></g>
<g id="view-carousel"><path d="M7 19h10V4H7v15zm-5-2h4V6H2v11zM18 6v11h4V6h-4z"></path></g>
<g id="view-column"><path d="M10 18h5V5h-5v13zm-6 0h5V5H4v13zM16 5v13h5V5h-5z"></path></g>
<g id="view-day"><path d="M2 21h19v-3H2v3zM20 8H3c-.55 0-1 .45-1 1v6c0 .55.45 1 1 1h17c.55 0 1-.45 1-1V9c0-.55-.45-1-1-1zM2 3v3h19V3H2z"></path></g>
<g id="view-headline"><path d="M4 15h16v-2H4v2zm0 4h16v-2H4v2zm0-8h16V9H4v2zm0-6v2h16V5H4z"></path></g>
<g id="view-list"><path d="M4 14h4v-4H4v4zm0 5h4v-4H4v4zM4 9h4V5H4v4zm5 5h12v-4H9v4zm0 5h12v-4H9v4zM9 5v4h12V5H9z"></path></g>
<g id="view-module"><path d="M4 11h5V5H4v6zm0 7h5v-6H4v6zm6 0h5v-6h-5v6zm6 0h5v-6h-5v6zm-6-7h5V5h-5v6zm6-6v6h5V5h-5z"></path></g>
<g id="view-quilt"><path d="M10 18h5v-6h-5v6zm-6 0h5V5H4v13zm12 0h5v-6h-5v6zM10 5v6h11V5H10z"></path></g>
<g id="view-stream"><path d="M4 18h17v-6H4v6zM4 5v6h17V5H4z"></path></g>
<g id="view-week"><path d="M6 5H3c-.55 0-1 .45-1 1v12c0 .55.45 1 1 1h3c.55 0 1-.45 1-1V6c0-.55-.45-1-1-1zm14 0h-3c-.55 0-1 .45-1 1v12c0 .55.45 1 1 1h3c.55 0 1-.45 1-1V6c0-.55-.45-1-1-1zm-7 0h-3c-.55 0-1 .45-1 1v12c0 .55.45 1 1 1h3c.55 0 1-.45 1-1V6c0-.55-.45-1-1-1z"></path></g>
<g id="visibility"><path d="M12 4.5C7 4.5 2.73 7.61 1 12c1.73 4.39 6 7.5 11 7.5s9.27-3.11 11-7.5c-1.73-4.39-6-7.5-11-7.5zM12 17c-2.76 0-5-2.24-5-5s2.24-5 5-5 5 2.24 5 5-2.24 5-5 5zm0-8c-1.66 0-3 1.34-3 3s1.34 3 3 3 3-1.34 3-3-1.34-3-3-3z"></path></g>
<g id="visibility-off"><path d="M12 7c2.76 0 5 2.24 5 5 0 .65-.13 1.26-.36 1.83l2.92 2.92c1.51-1.26 2.7-2.89 3.43-4.75-1.73-4.39-6-7.5-11-7.5-1.4 0-2.74.25-3.98.7l2.16 2.16C10.74 7.13 11.35 7 12 7zM2 4.27l2.28 2.28.46.46C3.08 8.3 1.78 10.02 1 12c1.73 4.39 6 7.5 11 7.5 1.55 0 3.03-.3 4.38-.84l.42.42L19.73 22 21 20.73 3.27 3 2 4.27zM7.53 9.8l1.55 1.55c-.05.21-.08.43-.08.65 0 1.66 1.34 3 3 3 .22 0 .44-.03.65-.08l1.55 1.55c-.67.33-1.41.53-2.2.53-2.76 0-5-2.24-5-5 0-.79.2-1.53.53-2.2zm4.31-.78l3.15 3.15.02-.16c0-1.66-1.34-3-3-3l-.17.01z"></path></g>
<g id="warning"><path d="M1 21h22L12 2 1 21zm12-3h-2v-2h2v2zm0-4h-2v-4h2v4z"></path></g>
<g id="watch-later"><path d="M12 2C6.5 2 2 6.5 2 12s4.5 10 10 10 10-4.5 10-10S17.5 2 12 2zm4.2 14.2L11 13V7h1.5v5.2l4.5 2.7-.8 1.3z"></path></g>
<g id="weekend"><path d="M21 10c-1.1 0-2 .9-2 2v3H5v-3c0-1.1-.9-2-2-2s-2 .9-2 2v5c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2v-5c0-1.1-.9-2-2-2zm-3-5H6c-1.1 0-2 .9-2 2v2.15c1.16.41 2 1.51 2 2.82V14h12v-2.03c0-1.3.84-2.4 2-2.82V7c0-1.1-.9-2-2-2z"></path></g>
<g id="work"><path d="M20 6h-4V4c0-1.11-.89-2-2-2h-4c-1.11 0-2 .89-2 2v2H4c-1.11 0-1.99.89-1.99 2L2 19c0 1.11.89 2 2 2h16c1.11 0 2-.89 2-2V8c0-1.11-.89-2-2-2zm-6 0h-4V4h4v2z"></path></g>
<g id="youtube-searched-for"><path d="M17.01 14h-.8l-.27-.27c.98-1.14 1.57-2.61 1.57-4.23 0-3.59-2.91-6.5-6.5-6.5s-6.5 3-6.5 6.5H2l3.84 4 4.16-4H6.51C6.51 7 8.53 5 11.01 5s4.5 2.01 4.5 4.5c0 2.48-2.02 4.5-4.5 4.5-.65 0-1.26-.14-1.82-.38L7.71 15.1c.97.57 2.09.9 3.3.9 1.61 0 3.08-.59 4.22-1.57l.27.27v.79l5.01 4.99L22 19l-4.99-5z"></path></g>
<g id="zoom-in"><path d="M15.5 14h-.79l-.28-.27C15.41 12.59 16 11.11 16 9.5 16 5.91 13.09 3 9.5 3S3 5.91 3 9.5 5.91 16 9.5 16c1.61 0 3.09-.59 4.23-1.57l.27.28v.79l5 4.99L20.49 19l-4.99-5zm-6 0C7.01 14 5 11.99 5 9.5S7.01 5 9.5 5 14 7.01 14 9.5 11.99 14 9.5 14zm2.5-4h-2v2H9v-2H7V9h2V7h1v2h2v1z"></path></g>
<g id="zoom-out"><path d="M15.5 14h-.79l-.28-.27C15.41 12.59 16 11.11 16 9.5 16 5.91 13.09 3 9.5 3S3 5.91 3 9.5 5.91 16 9.5 16c1.61 0 3.09-.59 4.23-1.57l.27.28v.79l5 4.99L20.49 19l-4.99-5zm-6 0C7.01 14 5 11.99 5 9.5S7.01 5 9.5 5 14 7.01 14 9.5 11.99 14 9.5 14zM7 9h5v1H7z"></path></g>
</defs></svg>
</iron-iconset-svg>`;document.head.appendChild(vbe.content);var t0t={"U+0008":"backspace","U+0009":"tab","U+001B":"esc","U+0020":"space","U+007F":"del"},xbe={8:"backspace",9:"tab",13:"enter",27:"esc",33:"pageup",34:"pagedown",35:"end",36:"home",32:"space",37:"left",38:"up",39:"right",40:"down",46:"del",106:"*"},e0t={shift:"shiftKey",ctrl:"ctrlKey",alt:"altKey",meta:"metaKey"},bbe=/[a-z0-9*]/,wbe=/U\+/,Sbe=/^arrow/,Mbe=/^space(bar)?/,Ebe=/^escape$/;function r0t(e,t){var r="";if(e){var n=e.toLowerCase();n===" "||Mbe.test(n)?r="space":Ebe.test(n)?r="esc":n.length==1?(!t||bbe.test(n))&&(r=n):Sbe.test(n)?r=n.replace("arrow",""):n=="multiply"?r="*":r=n}return r}function Tbe(e){var t="";return e&&(e in t0t?t=t0t[e]:wbe.test(e)?(e=parseInt(e.replace("U+","0x"),16),t=String.fromCharCode(e).toLowerCase()):t=e.toLowerCase()),t}function Cbe(e){var t="";return Number(e)&&(e>=65&&e<=90?t=String.fromCharCode(32+e):e>=112&&e<=123?t="f"+(e-112+1):e>=48&&e<=57?t=String(e-48):e>=96&&e<=105?t=String(e-96):t=xbe[e]),t}function Abe(e,t){return e.key?r0t(e.key,t):e.detail&&e.detail.key?r0t(e.detail.key,t):Tbe(e.keyIdentifier)||Cbe(e.keyCode)||""}function n0t(e,t){var r=Abe(t,e.hasModifiers);return r===e.key&&(!e.hasModifiers||!!t.shiftKey==!!e.shiftKey&&!!t.ctrlKey==!!e.ctrlKey&&!!t.altKey==!!e.altKey&&!!t.metaKey==!!e.metaKey)}function Pbe(e){return e.length===1?{combo:e,key:e,event:"keydown"}:e.split("+").reduce(function(t,r){var n=r.split(":"),i=n[0],o=n[1];return i in e0t?(t[e0t[i]]=!0,t.hasModifiers=!0):(t.key=i,t.event=o||"keydown"),t},{combo:e.split(":").shift()})}function i0t(e){return e.trim().split(" ").map(function(t){return Pbe(t)})}var Oo={properties:{keyEventTarget:{type:Object,value:function(){return this}},stopKeyboardEventPropagation:{type:Boolean,value:!1},_boundKeyHandlers:{type:Array,value:function(){return[]}},_imperativeKeyBindings:{type:Object,value:function(){return{}}}},observers:["_resetKeyEventListeners(keyEventTarget, _boundKeyHandlers)"],keyBindings:{},registered:function(){this._prepKeyBindings()},attached:function(){this._listenKeyEventListeners()},detached:function(){this._unlistenKeyEventListeners()},addOwnKeyBinding:function(e,t){this._imperativeKeyBindings[e]=t,this._prepKeyBindings(),this._resetKeyEventListeners()},removeOwnKeyBindings:function(){this._imperativeKeyBindings={},this._prepKeyBindings(),this._resetKeyEventListeners()},keyboardEventMatchesKeys:function(e,t){for(var r=i0t(t),n=0;n<r.length;++n)if(n0t(r[n],e))return!0;return!1},_collectKeyBindings:function(){var e=this.behaviors.map(function(t){return t.keyBindings});return e.indexOf(this.keyBindings)===-1&&e.push(this.keyBindings),e},_prepKeyBindings:function(){this._keyBindings={},this._collectKeyBindings().forEach(function(r){for(var n in r)this._addKeyBinding(n,r[n])},this);for(var e in this._imperativeKeyBindings)this._addKeyBinding(e,this._imperativeKeyBindings[e]);for(var t in this._keyBindings)this._keyBindings[t].sort(function(r,n){var i=r[0].hasModifiers,o=n[0].hasModifiers;return i===o?0:i?-1:1})},_addKeyBinding:function(e,t){i0t(e).forEach(function(r){this._keyBindings[r.event]=this._keyBindings[r.event]||[],this._keyBindings[r.event].push([r,t])},this)},_resetKeyEventListeners:function(){this._unlistenKeyEventListeners(),this.isAttached&&this._listenKeyEventListeners()},_listenKeyEventListeners:function(){!this.keyEventTarget||Object.keys(this._keyBindings).forEach(function(e){var t=this._keyBindings[e],r=this._onKeyBindingEvent.bind(this,t);this._boundKeyHandlers.push([this.keyEventTarget,e,r]),this.keyEventTarget.addEventListener(e,r)},this)},_unlistenKeyEventListeners:function(){for(var e,t,r,n;this._boundKeyHandlers.length;)e=this._boundKeyHandlers.pop(),t=e[0],r=e[1],n=e[2],t.removeEventListener(r,n)},_onKeyBindingEvent:function(e,t){if(this.stopKeyboardEventPropagation&&t.stopPropagation(),!t.defaultPrevented)for(var r=0;r<e.length;r++){var n=e[r][0],i=e[r][1];if(n0t(n,t)&&(this._triggerKeyHandler(n,i,t),t.defaultPrevented))return}},_triggerKeyHandler:function(e,t,r){var n=Object.create(e);n.keyboardEvent=r;var i=new CustomEvent(e.event,{detail:n,cancelable:!0});this[t].call(this,i),i.defaultPrevented&&r.preventDefault()}};var v9={properties:{scrollTarget:{type:HTMLElement,value:function(){return this._defaultScrollTarget}}},observers:["_scrollTargetChanged(scrollTarget, isAttached)"],_shouldHaveListener:!0,_scrollTargetChanged:function(e,t){var r;if(this._oldScrollTarget&&(this._toggleScrollListener(!1,this._oldScrollTarget),this._oldScrollTarget=null),!!t)if(e==="document")this.scrollTarget=this._doc;else if(typeof e=="string"){var n=this.domHost;this.scrollTarget=n&&n.$?n.$[e]:zt(this.ownerDocument).querySelector("#"+e)}else this._isValidScrollTarget()&&(this._oldScrollTarget=e,this._toggleScrollListener(this._shouldHaveListener,e))},_scrollHandler:function(){},get _defaultScrollTarget(){return this._doc},get _doc(){return this.ownerDocument.documentElement},get _scrollTop(){return this._isValidScrollTarget()?this.scrollTarget===this._doc?window.pageYOffset:this.scrollTarget.scrollTop:0},get _scrollLeft(){return this._isValidScrollTarget()?this.scrollTarget===this._doc?window.pageXOffset:this.scrollTarget.scrollLeft:0},set _scrollTop(e){this.scrollTarget===this._doc?window.scrollTo(window.pageXOffset,e):this._isValidScrollTarget()&&(this.scrollTarget.scrollTop=e)},set _scrollLeft(e){this.scrollTarget===this._doc?window.scrollTo(e,window.pageYOffset):this._isValidScrollTarget()&&(this.scrollTarget.scrollLeft=e)},scroll:function(e,t){var r;typeof e=="object"?(r=e.left,t=e.top):r=e,r=r||0,t=t||0,this.scrollTarget===this._doc?window.scrollTo(r,t):this._isValidScrollTarget()&&(this.scrollTarget.scrollLeft=r,this.scrollTarget.scrollTop=t)},get _scrollTargetWidth(){return this._isValidScrollTarget()?this.scrollTarget===this._doc?window.innerWidth:this.scrollTarget.offsetWidth:0},get _scrollTargetHeight(){return this._isValidScrollTarget()?this.scrollTarget===this._doc?window.innerHeight:this.scrollTarget.offsetHeight:0},_isValidScrollTarget:function(){return this.scrollTarget instanceof HTMLElement},_toggleScrollListener:function(e,t){var r=t===this._doc?window:t;e?this._boundScrollHandler||(this._boundScrollHandler=this._scrollHandler.bind(this),r.addEventListener("scroll",this._boundScrollHandler)):this._boundScrollHandler&&(r.removeEventListener("scroll",this._boundScrollHandler),this._boundScrollHandler=null)},toggleScrollListener:function(e){this._shouldHaveListener=e,this._toggleScrollListener(e,this.scrollTarget)}};var o0t=navigator.userAgent.match(/iP(?:hone|ad;(?: U;)? CPU) OS (\d+)/),Ibe=o0t&&o0t[1]>=8,a0t=3,s0t="-10000px",fE=-100;Yt({_template:Q`
    <style>
      :host {
        display: block;
      }

      @media only screen and (-webkit-max-device-pixel-ratio: 1) {
        :host {
          will-change: transform;
        }
      }

      #items {
        @apply --iron-list-items-container;
        position: relative;
      }

      :host(:not([grid])) #items > ::slotted(*) {
        width: 100%;
      }

      #items > ::slotted(*) {
        box-sizing: border-box;
        margin: 0;
        position: absolute;
        top: 0;
        will-change: transform;
      }
    </style>

    <array-selector id="selector" items="{{items}}" selected="{{selectedItems}}" selected-item="{{selectedItem}}"></array-selector>

    <div id="items">
      <slot></slot>
    </div>
`,is:"iron-list",properties:{items:{type:Array},as:{type:String,value:"item"},indexAs:{type:String,value:"index"},selectedAs:{type:String,value:"selected"},grid:{type:Boolean,value:!1,reflectToAttribute:!0,observer:"_gridChanged"},selectionEnabled:{type:Boolean,value:!1},selectedItem:{type:Object,notify:!0},selectedItems:{type:Object,notify:!0},multiSelection:{type:Boolean,value:!1},scrollOffset:{type:Number,value:0}},observers:["_itemsChanged(items.*)","_selectionEnabledChanged(selectionEnabled)","_multiSelectionChanged(multiSelection)","_setOverflow(scrollTarget, scrollOffset)"],behaviors:[Wgt,Js,v9,Kgt],_ratio:.5,_scrollerPaddingTop:0,_scrollPosition:0,_physicalSize:0,_physicalAverage:0,_physicalAverageCount:0,_physicalTop:0,_virtualCount:0,_estScrollHeight:0,_scrollHeight:0,_viewportHeight:0,_viewportWidth:0,_physicalItems:null,_physicalSizes:null,_firstVisibleIndexVal:null,_lastVisibleIndexVal:null,_maxPages:2,_focusedItem:null,_focusedVirtualIndex:-1,_focusedPhysicalIndex:-1,_offscreenFocusedItem:null,_focusBackfillItem:null,_itemsPerRow:1,_itemWidth:0,_rowHeight:0,_templateCost:0,_parentModel:!0,get _physicalBottom(){return this._physicalTop+this._physicalSize},get _scrollBottom(){return this._scrollPosition+this._viewportHeight},get _virtualEnd(){return this._virtualStart+this._physicalCount-1},get _hiddenContentSize(){var e=this.grid?this._physicalRows*this._rowHeight:this._physicalSize;return e-this._viewportHeight},get _itemsParent(){return zt(zt(this._userTemplate).parentNode)},get _maxScrollTop(){return this._estScrollHeight-this._viewportHeight+this._scrollOffset},get _maxVirtualStart(){var e=this._convertIndexToCompleteRow(this._virtualCount);return Math.max(0,e-this._physicalCount)},set _virtualStart(e){e=this._clamp(e,0,this._maxVirtualStart),this.grid&&(e=e-e%this._itemsPerRow),this._virtualStartVal=e},get _virtualStart(){return this._virtualStartVal||0},set _physicalStart(e){e=e%this._physicalCount,e<0&&(e=this._physicalCount+e),this.grid&&(e=e-e%this._itemsPerRow),this._physicalStartVal=e},get _physicalStart(){return this._physicalStartVal||0},get _physicalEnd(){return(this._physicalStart+this._physicalCount-1)%this._physicalCount},set _physicalCount(e){this._physicalCountVal=e},get _physicalCount(){return this._physicalCountVal||0},get _optPhysicalSize(){return this._viewportHeight===0?1/0:this._viewportHeight*this._maxPages},get _isVisible(){return Boolean(this.offsetWidth||this.offsetHeight)},get firstVisibleIndex(){var e=this._firstVisibleIndexVal;if(e==null){var t=this._physicalTop+this._scrollOffset;e=this._iterateItems(function(r,n){if(t+=this._getPhysicalSizeIncrement(r),t>this._scrollPosition)return this.grid?n-n%this._itemsPerRow:n;if(this.grid&&this._virtualCount-1===n)return n-n%this._itemsPerRow})||0,this._firstVisibleIndexVal=e}return e},get lastVisibleIndex(){var e=this._lastVisibleIndexVal;if(e==null){if(this.grid)e=Math.min(this._virtualCount,this.firstVisibleIndex+this._estRowsInView*this._itemsPerRow-1);else{var t=this._physicalTop+this._scrollOffset;this._iterateItems(function(r,n){t<this._scrollBottom&&(e=n),t+=this._getPhysicalSizeIncrement(r)})}this._lastVisibleIndexVal=e}return e},get _defaultScrollTarget(){return this},get _virtualRowCount(){return Math.ceil(this._virtualCount/this._itemsPerRow)},get _estRowsInView(){return Math.ceil(this._viewportHeight/this._rowHeight)},get _physicalRows(){return Math.ceil(this._physicalCount/this._itemsPerRow)},get _scrollOffset(){return this._scrollerPaddingTop+this.scrollOffset},ready:function(){this.addEventListener("focus",this._didFocus.bind(this),!0)},attached:function(){this._debounce("_render",this._render,Ni),this.listen(this,"iron-resize","_resizeHandler"),this.listen(this,"keydown","_keydownHandler")},detached:function(){this.unlisten(this,"iron-resize","_resizeHandler"),this.unlisten(this,"keydown","_keydownHandler")},_setOverflow:function(e){this.style.webkitOverflowScrolling=e===this?"touch":"",this.style.overflowY=e===this?"auto":"",this._lastVisibleIndexVal=null,this._firstVisibleIndexVal=null,this._debounce("_render",this._render,Ni)},updateViewportBoundaries:function(){var e=window.getComputedStyle(this);this._scrollerPaddingTop=this.scrollTarget===this?0:parseInt(e["padding-top"],10),this._isRTL=Boolean(e.direction==="rtl"),this._viewportWidth=this.$.items.offsetWidth,this._viewportHeight=this._scrollTargetHeight,this.grid&&this._updateGridMetrics()},_scrollHandler:function(){var e=Math.max(0,Math.min(this._maxScrollTop,this._scrollTop)),t=e-this._scrollPosition,r=t>=0;if(this._scrollPosition=e,this._firstVisibleIndexVal=null,this._lastVisibleIndexVal=null,Math.abs(t)>this._physicalSize&&this._physicalSize>0){t=t-this._scrollOffset;var n=Math.round(t/this._physicalAverage)*this._itemsPerRow;this._virtualStart=this._virtualStart+n,this._physicalStart=this._physicalStart+n,this._physicalTop=Math.min(Math.floor(this._virtualStart/this._itemsPerRow)*this._physicalAverage,this._scrollPosition),this._update()}else if(this._physicalCount>0){var i=this._getReusables(r);r?(this._physicalTop=i.physicalTop,this._virtualStart=this._virtualStart+i.indexes.length,this._physicalStart=this._physicalStart+i.indexes.length):(this._virtualStart=this._virtualStart-i.indexes.length,this._physicalStart=this._physicalStart-i.indexes.length),this._update(i.indexes,r?null:i.indexes),this._debounce("_increasePoolIfNeeded",this._increasePoolIfNeeded.bind(this,0),li)}},_getReusables:function(e){var t,r,n,i,o=[],a=this._hiddenContentSize*this._ratio,s=this._virtualStart,l=this._virtualEnd,c=this._physicalCount,u=this._physicalTop+this._scrollOffset,h=this._physicalBottom+this._scrollOffset,f=this._scrollPosition,p=this._scrollBottom;for(e?(t=this._physicalStart,r=this._physicalEnd,n=f-u):(t=this._physicalEnd,r=this._physicalStart,n=h-p);i=this._getPhysicalSizeIncrement(t),n=n-i,!(o.length>=c||n<=a);)if(e){if(l+o.length+1>=this._virtualCount||u+i>=f-this._scrollOffset)break;o.push(t),u=u+i,t=(t+1)%c}else{if(s-o.length<=0||u+this._physicalSize-i<=p)break;o.push(t),u=u-i,t=t===0?c-1:t-1}return{indexes:o,physicalTop:u-this._scrollOffset}},_update:function(e,t){if(!(e&&e.length===0||this._physicalCount===0)){if(this._manageFocus(),this._assignModels(e),this._updateMetrics(e),t)for(;t.length;){var r=t.pop();this._physicalTop-=this._getPhysicalSizeIncrement(r)}this._positionItems(),this._updateScrollerSize()}},_createPool:function(e){this._ensureTemplatized();var t,r,n=new Array(e);for(t=0;t<e;t++)r=this.stamp(null),n[t]=r.root.querySelector("*"),this._itemsParent.appendChild(r.root);return n},_isClientFull:function(){return this._scrollBottom!=0&&this._physicalBottom-1>=this._scrollBottom&&this._physicalTop<=this._scrollPosition},_increasePoolIfNeeded:function(e){var t=this._clamp(this._physicalCount+e,a0t,this._virtualCount-this._virtualStart);if(t=this._convertIndexToCompleteRow(t),this.grid){var r=t%this._itemsPerRow;r&&t-r<=this._physicalCount&&(t+=this._itemsPerRow),t-=r}var n=t-this._physicalCount,i=Math.round(this._physicalCount*.5);if(!(n<0)){if(n>0){var o=window.performance.now();[].push.apply(this._physicalItems,this._createPool(n));for(var a=0;a<n;a++)this._physicalSizes.push(0);this._physicalCount=this._physicalCount+n,this._physicalStart>this._physicalEnd&&this._isIndexRendered(this._focusedVirtualIndex)&&this._getPhysicalIndex(this._focusedVirtualIndex)<this._physicalEnd&&(this._physicalStart=this._physicalStart+n),this._update(),this._templateCost=(window.performance.now()-o)/n,i=Math.round(this._physicalCount*.5)}this._virtualEnd>=this._virtualCount-1||i===0||(this._isClientFull()?this._physicalSize<this._optPhysicalSize&&this._debounce("_increasePoolIfNeeded",this._increasePoolIfNeeded.bind(this,this._clamp(Math.round(50/this._templateCost),1,i)),kx):this._debounce("_increasePoolIfNeeded",this._increasePoolIfNeeded.bind(this,i),li))}},_render:function(){if(!(!this.isAttached||!this._isVisible))if(this._physicalCount!==0){var e=this._getReusables(!0);this._physicalTop=e.physicalTop,this._virtualStart=this._virtualStart+e.indexes.length,this._physicalStart=this._physicalStart+e.indexes.length,this._update(e.indexes),this._update(),this._increasePoolIfNeeded(0)}else this._virtualCount>0&&(this.updateViewportBoundaries(),this._increasePoolIfNeeded(a0t))},_ensureTemplatized:function(){if(!this.ctor){this._userTemplate=this.queryEffectiveChildren("template"),this._userTemplate||console.warn("iron-list requires a template to be provided in light-dom");var e={};e.__key__=!0,e[this.as]=!0,e[this.indexAs]=!0,e[this.selectedAs]=!0,e.tabIndex=!0,this._instanceProps=e,this.templatize(this._userTemplate,this.mutableData)}},_gridChanged:function(e,t){typeof t!="undefined"&&(this.notifyResize(),ci(),e&&this._updateGridMetrics())},_itemsChanged:function(e){if(e.path==="items")this._virtualStart=0,this._physicalTop=0,this._virtualCount=this.items?this.items.length:0,this._physicalIndexForKey={},this._firstVisibleIndexVal=null,this._lastVisibleIndexVal=null,this._physicalCount=this._physicalCount||0,this._physicalItems=this._physicalItems||[],this._physicalSizes=this._physicalSizes||[],this._physicalStart=0,this._scrollTop>this._scrollOffset&&this._resetScrollPosition(0),this._removeFocusedItem(),this._debounce("_render",this._render,Ni);else if(e.path==="items.splices"){this._adjustVirtualIndex(e.value.indexSplices),this._virtualCount=this.items?this.items.length:0;var t=e.value.indexSplices.some(function(i){return i.addedCount>0||i.removed.length>0});if(t){var r=this._getActiveElement();this.contains(r)&&r.blur()}var n=e.value.indexSplices.some(function(i){return i.index+i.addedCount>=this._virtualStart&&i.index<=this._virtualEnd},this);(!this._isClientFull()||n)&&this._debounce("_render",this._render,Ni)}else e.path!=="items.length"&&this._forwardItemPath(e.path,e.value)},_forwardItemPath:function(e,t){e=e.slice(6);var r=e.indexOf(".");r===-1&&(r=e.length);var n,i,o,a=this.modelForElement(this._offscreenFocusedItem),s=parseInt(e.substring(0,r),10);n=this._isIndexRendered(s),n?(i=this._getPhysicalIndex(s),o=this.modelForElement(this._physicalItems[i])):a&&(o=a),!(!o||o[this.indexAs]!==s)&&(e=e.substring(r+1),e=this.as+(e?"."+e:""),o._setPendingPropertyOrPath(e,t,!1,!0),o._flushProperties&&o._flushProperties(),n&&(this._updateMetrics([i]),this._positionItems(),this._updateScrollerSize()))},_adjustVirtualIndex:function(e){e.forEach(function(t){if(t.removed.forEach(this._removeItem,this),t.index<this._virtualStart){var r=Math.max(t.addedCount-t.removed.length,t.index-this._virtualStart);this._virtualStart=this._virtualStart+r,this._focusedVirtualIndex>=0&&(this._focusedVirtualIndex=this._focusedVirtualIndex+r)}},this)},_removeItem:function(e){this.$.selector.deselect(e),this._focusedItem&&this.modelForElement(this._focusedItem)[this.as]===e&&this._removeFocusedItem()},_iterateItems:function(e,t){var r,n,i,o;if(arguments.length===2&&t){for(o=0;o<t.length;o++)if(r=t[o],n=this._computeVidx(r),(i=e.call(this,r,n))!=null)return i}else{for(r=this._physicalStart,n=this._virtualStart;r<this._physicalCount;r++,n++)if((i=e.call(this,r,n))!=null)return i;for(r=0;r<this._physicalStart;r++,n++)if((i=e.call(this,r,n))!=null)return i}},_computeVidx:function(e){return e>=this._physicalStart?this._virtualStart+(e-this._physicalStart):this._virtualStart+(this._physicalCount-this._physicalStart)+e},_assignModels:function(e){this._iterateItems(function(t,r){var n=this._physicalItems[t],i=this.items&&this.items[r];if(i!=null){var o=this.modelForElement(n);o.__key__=null,this._forwardProperty(o,this.as,i),this._forwardProperty(o,this.selectedAs,this.$.selector.isSelected(i)),this._forwardProperty(o,this.indexAs,r),this._forwardProperty(o,"tabIndex",this._focusedVirtualIndex===r?0:-1),this._physicalIndexForKey[o.__key__]=t,o._flushProperties&&o._flushProperties(!0),n.removeAttribute("hidden")}else n.setAttribute("hidden","")},e)},_updateMetrics:function(e){ci();var t=0,r=0,n=this._physicalAverageCount,i=this._physicalAverage;this._iterateItems(function(o,a){r+=this._physicalSizes[o],this._physicalSizes[o]=this._physicalItems[o].offsetHeight,t+=this._physicalSizes[o],this._physicalAverageCount+=this._physicalSizes[o]?1:0},e),this.grid?(this._updateGridMetrics(),this._physicalSize=Math.ceil(this._physicalCount/this._itemsPerRow)*this._rowHeight):(r=this._itemsPerRow===1?r:Math.ceil(this._physicalCount/this._itemsPerRow)*this._rowHeight,this._physicalSize=this._physicalSize+t-r,this._itemsPerRow=1),this._physicalAverageCount!==n&&(this._physicalAverage=Math.round((i*n+t)/this._physicalAverageCount))},_updateGridMetrics:function(){this._itemWidth=this._physicalCount>0?this._physicalItems[0].getBoundingClientRect().width:200,this._rowHeight=this._physicalCount>0?this._physicalItems[0].offsetHeight:200,this._itemsPerRow=this._itemWidth?Math.floor(this._viewportWidth/this._itemWidth):this._itemsPerRow},_positionItems:function(){this._adjustScrollPosition();var e=this._physicalTop;if(this.grid){var t=this._itemsPerRow*this._itemWidth,r=(this._viewportWidth-t)/2;this._iterateItems(function(n,i){var o=i%this._itemsPerRow,a=Math.floor(o*this._itemWidth+r);this._isRTL&&(a=a*-1),this.translate3d(a+"px",e+"px",0,this._physicalItems[n]),this._shouldRenderNextRow(i)&&(e+=this._rowHeight)})}else{let n=[];this._iterateItems(function(i,o){let a=this._physicalItems[i];this.translate3d(0,e+"px",0,a),e+=this._physicalSizes[i];let s=a.id;s&&n.push(s)}),n.length&&this.setAttribute("aria-owns",n.join(" "))}},_getPhysicalSizeIncrement:function(e){return this.grid?this._computeVidx(e)%this._itemsPerRow!==this._itemsPerRow-1?0:this._rowHeight:this._physicalSizes[e]},_shouldRenderNextRow:function(e){return e%this._itemsPerRow===this._itemsPerRow-1},_adjustScrollPosition:function(){var e=this._virtualStart===0?this._physicalTop:Math.min(this._scrollPosition+this._physicalTop,0);if(e!==0){this._physicalTop=this._physicalTop-e;var t=this._scrollPosition;!Ibe&&t>0&&this._resetScrollPosition(t-e)}},_resetScrollPosition:function(e){this.scrollTarget&&e>=0&&(this._scrollTop=e,this._scrollPosition=this._scrollTop)},_updateScrollerSize:function(e){this.grid?this._estScrollHeight=this._virtualRowCount*this._rowHeight:this._estScrollHeight=this._physicalBottom+Math.max(this._virtualCount-this._physicalCount-this._virtualStart,0)*this._physicalAverage,e=e||this._scrollHeight===0,e=e||this._scrollPosition>=this._estScrollHeight-this._physicalSize,e=e||this.grid&&this.$.items.style.height<this._estScrollHeight,(e||Math.abs(this._estScrollHeight-this._scrollHeight)>=this._viewportHeight)&&(this.$.items.style.height=this._estScrollHeight+"px",this._scrollHeight=this._estScrollHeight)},scrollToItem:function(e){return this.scrollToIndex(this.items.indexOf(e))},scrollToIndex:function(e){if(!(typeof e!="number"||e<0||e>this.items.length-1)&&(ci(),this._physicalCount!==0)){e=this._clamp(e,0,this._virtualCount-1),(!this._isIndexRendered(e)||e>=this._maxVirtualStart)&&(this._virtualStart=this.grid?e-this._itemsPerRow*2:e-1),this._manageFocus(),this._assignModels(),this._updateMetrics(),this._physicalTop=Math.floor(this._virtualStart/this._itemsPerRow)*this._physicalAverage;for(var t=this._physicalStart,r=this._virtualStart,n=0,i=this._hiddenContentSize;r<e&&n<=i;)n=n+this._getPhysicalSizeIncrement(t),t=(t+1)%this._physicalCount,r++;this._updateScrollerSize(!0),this._positionItems(),this._resetScrollPosition(this._physicalTop+this._scrollOffset+n),this._increasePoolIfNeeded(0),this._firstVisibleIndexVal=null,this._lastVisibleIndexVal=null}},_resetAverage:function(){this._physicalAverage=0,this._physicalAverageCount=0},_resizeHandler:function(){this._debounce("_render",function(){this._firstVisibleIndexVal=null,this._lastVisibleIndexVal=null,this._isVisible?(this.updateViewportBoundaries(),this.toggleScrollListener(!0),this._resetAverage(),this._render()):this.toggleScrollListener(!1)},Ni)},selectItem:function(e){return this.selectIndex(this.items.indexOf(e))},selectIndex:function(e){if(!(e<0||e>=this._virtualCount)){if(!this.multiSelection&&this.selectedItem&&this.clearSelection(),this._isIndexRendered(e)){var t=this.modelForElement(this._physicalItems[this._getPhysicalIndex(e)]);t&&(t[this.selectedAs]=!0),this.updateSizeForIndex(e)}this.$.selector.selectIndex(e)}},deselectItem:function(e){return this.deselectIndex(this.items.indexOf(e))},deselectIndex:function(e){if(!(e<0||e>=this._virtualCount)){if(this._isIndexRendered(e)){var t=this.modelForElement(this._physicalItems[this._getPhysicalIndex(e)]);t[this.selectedAs]=!1,this.updateSizeForIndex(e)}this.$.selector.deselectIndex(e)}},toggleSelectionForItem:function(e){return this.toggleSelectionForIndex(this.items.indexOf(e))},toggleSelectionForIndex:function(e){var t=this.$.selector.isIndexSelected?this.$.selector.isIndexSelected(e):this.$.selector.isSelected(this.items[e]);t?this.deselectIndex(e):this.selectIndex(e)},clearSelection:function(){this._iterateItems(function(e,t){this.modelForElement(this._physicalItems[e])[this.selectedAs]=!1}),this.$.selector.clearSelection()},_selectionEnabledChanged:function(e){var t=e?this.listen:this.unlisten;t.call(this,this,"tap","_selectionHandler")},_selectionHandler:function(e){var t=this.modelForElement(e.target);if(!!t){var r,n,i=zt(e).path[0],o=this._getActiveElement(),a=this._physicalItems[this._getPhysicalIndex(t[this.indexAs])];i.localName==="input"||i.localName==="button"||i.localName==="select"||(r=t.tabIndex,t.tabIndex=fE,n=o?o.tabIndex:-1,t.tabIndex=r,!(o&&a!==o&&a.contains(o)&&n!==fE)&&this.toggleSelectionForItem(t[this.as]))}},_multiSelectionChanged:function(e){this.clearSelection(),this.$.selector.multi=e},updateSizeForItem:function(e){return this.updateSizeForIndex(this.items.indexOf(e))},updateSizeForIndex:function(e){return this._isIndexRendered(e)&&(this._updateMetrics([this._getPhysicalIndex(e)]),this._positionItems()),null},_manageFocus:function(){var e=this._focusedVirtualIndex;e>=0&&e<this._virtualCount?this._isIndexRendered(e)?this._restoreFocusedItem():this._createFocusBackfillItem():this._virtualCount>0&&this._physicalCount>0&&(this._focusedPhysicalIndex=this._physicalStart,this._focusedVirtualIndex=this._virtualStart,this._focusedItem=this._physicalItems[this._physicalStart])},_convertIndexToCompleteRow:function(e){return this._itemsPerRow=this._itemsPerRow||1,this.grid?Math.ceil(e/this._itemsPerRow)*this._itemsPerRow:e},_isIndexRendered:function(e){return e>=this._virtualStart&&e<=this._virtualEnd},_isIndexVisible:function(e){return e>=this.firstVisibleIndex&&e<=this.lastVisibleIndex},_getPhysicalIndex:function(e){return(this._physicalStart+(e-this._virtualStart))%this._physicalCount},focusItem:function(e){this._focusPhysicalItem(e)},_focusPhysicalItem:function(e){if(!(e<0||e>=this._virtualCount)){this._restoreFocusedItem(),this._isIndexRendered(e)||this.scrollToIndex(e);var t=this._physicalItems[this._getPhysicalIndex(e)],r=this.modelForElement(t),n;r.tabIndex=fE,t.tabIndex===fE&&(n=t),n||(n=zt(t).querySelector('[tabindex="'+fE+'"]')),r.tabIndex=0,this._focusedVirtualIndex=e,n&&n.focus()}},_removeFocusedItem:function(){this._offscreenFocusedItem&&this._itemsParent.removeChild(this._offscreenFocusedItem),this._offscreenFocusedItem=null,this._focusBackfillItem=null,this._focusedItem=null,this._focusedVirtualIndex=-1,this._focusedPhysicalIndex=-1},_createFocusBackfillItem:function(){var e=this._focusedPhysicalIndex;if(!(this._offscreenFocusedItem||this._focusedVirtualIndex<0)){if(!this._focusBackfillItem){var t=this.stamp(null);this._focusBackfillItem=t.root.querySelector("*"),this._itemsParent.appendChild(t.root)}this._offscreenFocusedItem=this._physicalItems[e],this.modelForElement(this._offscreenFocusedItem).tabIndex=0,this._physicalItems[e]=this._focusBackfillItem,this._focusedPhysicalIndex=e,this.translate3d(0,s0t,0,this._offscreenFocusedItem)}},_restoreFocusedItem:function(){if(!(!this._offscreenFocusedItem||this._focusedVirtualIndex<0)){this._assignModels();var e=this._focusedPhysicalIndex=this._getPhysicalIndex(this._focusedVirtualIndex),t=this._physicalItems[e];if(!!t){var r=this.modelForElement(t),n=this.modelForElement(this._offscreenFocusedItem);r[this.as]===n[this.as]?(this._focusBackfillItem=t,r.tabIndex=-1,this._physicalItems[e]=this._offscreenFocusedItem,this.translate3d(0,s0t,0,this._focusBackfillItem)):(this._removeFocusedItem(),this._focusBackfillItem=null),this._offscreenFocusedItem=null}}},_didFocus:function(e){var t=this.modelForElement(e.target),r=this.modelForElement(this._focusedItem),n=this._offscreenFocusedItem!==null,i=this._focusedVirtualIndex;!t||(r===t?this._isIndexVisible(i)||this.scrollToIndex(i):(this._restoreFocusedItem(),r&&(r.tabIndex=-1),t.tabIndex=0,i=t[this.indexAs],this._focusedVirtualIndex=i,this._focusedPhysicalIndex=this._getPhysicalIndex(i),this._focusedItem=this._physicalItems[this._focusedPhysicalIndex],n&&!this._offscreenFocusedItem&&this._update()))},_keydownHandler:function(e){switch(e.keyCode){case 40:this._focusedVirtualIndex<this._virtualCount-1&&e.preventDefault(),this._focusPhysicalItem(this._focusedVirtualIndex+(this.grid?this._itemsPerRow:1));break;case 39:this.grid&&this._focusPhysicalItem(this._focusedVirtualIndex+(this._isRTL?-1:1));break;case 38:this._focusedVirtualIndex>0&&e.preventDefault(),this._focusPhysicalItem(this._focusedVirtualIndex-(this.grid?this._itemsPerRow:1));break;case 37:this.grid&&this._focusPhysicalItem(this._focusedVirtualIndex+(this._isRTL?1:-1));break;case 13:this._focusPhysicalItem(this._focusedVirtualIndex),this.selectionEnabled&&this._selectionHandler(e);break}},_clamp:function(e,t,r){return Math.min(r,Math.max(t,e))},_debounce:function(e,t,r){this._debouncers=this._debouncers||{},this._debouncers[e]=sr.debounce(this._debouncers[e],r,t.bind(this)),Jl(this._debouncers[e])},_forwardProperty:function(e,t,r){e._setPendingProperty(t,r)},_forwardHostPropV2:function(e,t){(this._physicalItems||[]).concat([this._offscreenFocusedItem,this._focusBackfillItem]).forEach(function(r){r&&this.modelForElement(r).forwardHostProp(e,t)},this)},_notifyInstancePropV2:function(e,t,r){if(OI(this.as,t)){var n=e[this.indexAs];t==this.as&&(this.items[n]=r),this.notifyPath(dp(this.as,"items."+n,t),r)}},_getStampedChildren:function(){return this._physicalItems},_forwardInstancePath:function(e,t,r){t.indexOf(this.as+".")===0&&this.notifyPath("items."+e.__key__+"."+t.slice(this.as.length+1),r)},_forwardParentPath:function(e,t){(this._physicalItems||[]).concat([this._offscreenFocusedItem,this._focusBackfillItem]).forEach(function(r){r&&this.modelForElement(r).notifyPath(e,t)},this)},_forwardParentProp:function(e,t){(this._physicalItems||[]).concat([this._offscreenFocusedItem,this._focusBackfillItem]).forEach(function(r){r&&(this.modelForElement(r)[e]=t)},this)},_getActiveElement:function(){var e=this._itemsParent.node.domHost;return zt(e?e.root:document).activeElement}});var x9=class{constructor(t){this.selection=[],this.selectCallback=t}get(){return this.multi?this.selection.slice():this.selection[0]}clear(t){this.selection.slice().forEach(function(r){(!t||t.indexOf(r)<0)&&this.setItemSelected(r,!1)},this)}isSelected(t){return this.selection.indexOf(t)>=0}setItemSelected(t,r){if(t!=null&&r!==this.isSelected(t)){if(r)this.selection.push(t);else{var n=this.selection.indexOf(t);n>=0&&this.selection.splice(n,1)}this.selectCallback&&this.selectCallback(t,r)}}select(t){this.multi?this.toggle(t):this.get()!==t&&(this.setItemSelected(this.get(),!1),this.setItemSelected(t,!0))}toggle(t){this.setItemSelected(t,!this.isSelected(t))}};var wh={properties:{attrForSelected:{type:String,value:null},selected:{type:String,notify:!0},selectedItem:{type:Object,readOnly:!0,notify:!0},activateEvent:{type:String,value:"tap",observer:"_activateEventChanged"},selectable:String,selectedClass:{type:String,value:"iron-selected"},selectedAttribute:{type:String,value:null},fallbackSelection:{type:String,value:null},items:{type:Array,readOnly:!0,notify:!0,value:function(){return[]}},_excludedLocalNames:{type:Object,value:function(){return{template:1,"dom-bind":1,"dom-if":1,"dom-repeat":1}}}},observers:["_updateAttrForSelected(attrForSelected)","_updateSelected(selected)","_checkFallback(fallbackSelection)"],created:function(){this._bindFilterItem=this._filterItem.bind(this),this._selection=new x9(this._applySelection.bind(this))},attached:function(){this._observer=this._observeItems(this),this._addListener(this.activateEvent)},detached:function(){this._observer&&zt(this).unobserveNodes(this._observer),this._removeListener(this.activateEvent)},indexOf:function(e){return this.items?this.items.indexOf(e):-1},select:function(e){this.selected=e},selectPrevious:function(){var e=this.items.length,t=e-1;this.selected!==void 0&&(t=(Number(this._valueToIndex(this.selected))-1+e)%e),this.selected=this._indexToValue(t)},selectNext:function(){var e=0;this.selected!==void 0&&(e=(Number(this._valueToIndex(this.selected))+1)%this.items.length),this.selected=this._indexToValue(e)},selectIndex:function(e){this.select(this._indexToValue(e))},forceSynchronousItemUpdate:function(){this._observer&&typeof this._observer.flush=="function"?this._observer.flush():this._updateItems()},get _shouldUpdateSelection(){return this.selected!=null},_checkFallback:function(){this._updateSelected()},_addListener:function(e){this.listen(this,e,"_activateHandler")},_removeListener:function(e){this.unlisten(this,e,"_activateHandler")},_activateEventChanged:function(e,t){this._removeListener(t),this._addListener(e)},_updateItems:function(){var e=zt(this).queryDistributedElements(this.selectable||"*");e=Array.prototype.filter.call(e,this._bindFilterItem),this._setItems(e)},_updateAttrForSelected:function(){this.selectedItem&&(this.selected=this._valueForItem(this.selectedItem))},_updateSelected:function(){this._selectSelected(this.selected)},_selectSelected:function(e){if(!!this.items){var t=this._valueToItem(this.selected);t?this._selection.select(t):this._selection.clear(),this.fallbackSelection&&this.items.length&&this._selection.get()===void 0&&(this.selected=this.fallbackSelection)}},_filterItem:function(e){return!this._excludedLocalNames[e.localName]},_valueToItem:function(e){return e==null?null:this.items[this._valueToIndex(e)]},_valueToIndex:function(e){if(this.attrForSelected){for(var t=0,r;r=this.items[t];t++)if(this._valueForItem(r)==e)return t}else return Number(e)},_indexToValue:function(e){if(this.attrForSelected){var t=this.items[e];if(t)return this._valueForItem(t)}else return e},_valueForItem:function(e){if(!e)return null;if(!this.attrForSelected){var t=this.indexOf(e);return t===-1?null:t}var r=e[wm(this.attrForSelected)];return r!=null?r:e.getAttribute(this.attrForSelected)},_applySelection:function(e,t){this.selectedClass&&this.toggleClass(this.selectedClass,t,e),this.selectedAttribute&&this.toggleAttribute(this.selectedAttribute,t,e),this._selectionChange(),this.fire("iron-"+(t?"select":"deselect"),{item:e})},_selectionChange:function(){this._setSelectedItem(this._selection.get())},_observeItems:function(e){return zt(e).observeNodes(function(t){this._updateItems(),this._updateSelected(),this.fire("iron-items-changed",t,{bubbles:!1,cancelable:!1})})},_activateHandler:function(e){for(var t=e.target,r=this.items;t&&t!=this;){var n=r.indexOf(t);if(n>=0){var i=this._indexToValue(n);this._itemActivate(i,t);return}t=t.parentNode}},_itemActivate:function(e,t){this.fire("iron-activate",{selected:e,item:t},{cancelable:!0}).defaultPrevented||this.select(e)}};Yt({_template:Q`
    <style>
      :host {
        display: block;
      }

      :host > ::slotted(:not(slot):not(.iron-selected)) {
        display: none !important;
      }
    </style>

    <slot></slot>
`,is:"iron-pages",behaviors:[Js,wh],properties:{activateEvent:{type:String,value:null}},observers:["_selectedPageChanged(selected)"],_selectedPageChanged:function(e,t){this.async(this.notifyResize)}});var l0t=Q`
<custom-style>
  <style is="custom-style">
    html {

      --shadow-transition: {
        transition: box-shadow 0.28s cubic-bezier(0.4, 0, 0.2, 1);
      };

      --shadow-none: {
        box-shadow: none;
      };

      /* from http://codepen.io/shyndman/pen/c5394ddf2e8b2a5c9185904b57421cdb */

      --shadow-elevation-2dp: {
        box-shadow: 0 2px 2px 0 rgba(0, 0, 0, 0.14),
                    0 1px 5px 0 rgba(0, 0, 0, 0.12),
                    0 3px 1px -2px rgba(0, 0, 0, 0.2);
      };

      --shadow-elevation-3dp: {
        box-shadow: 0 3px 4px 0 rgba(0, 0, 0, 0.14),
                    0 1px 8px 0 rgba(0, 0, 0, 0.12),
                    0 3px 3px -2px rgba(0, 0, 0, 0.4);
      };

      --shadow-elevation-4dp: {
        box-shadow: 0 4px 5px 0 rgba(0, 0, 0, 0.14),
                    0 1px 10px 0 rgba(0, 0, 0, 0.12),
                    0 2px 4px -1px rgba(0, 0, 0, 0.4);
      };

      --shadow-elevation-6dp: {
        box-shadow: 0 6px 10px 0 rgba(0, 0, 0, 0.14),
                    0 1px 18px 0 rgba(0, 0, 0, 0.12),
                    0 3px 5px -1px rgba(0, 0, 0, 0.4);
      };

      --shadow-elevation-8dp: {
        box-shadow: 0 8px 10px 1px rgba(0, 0, 0, 0.14),
                    0 3px 14px 2px rgba(0, 0, 0, 0.12),
                    0 5px 5px -3px rgba(0, 0, 0, 0.4);
      };

      --shadow-elevation-12dp: {
        box-shadow: 0 12px 16px 1px rgba(0, 0, 0, 0.14),
                    0 4px 22px 3px rgba(0, 0, 0, 0.12),
                    0 6px 7px -4px rgba(0, 0, 0, 0.4);
      };

      --shadow-elevation-16dp: {
        box-shadow: 0 16px 24px 2px rgba(0, 0, 0, 0.14),
                    0  6px 30px 5px rgba(0, 0, 0, 0.12),
                    0  8px 10px -5px rgba(0, 0, 0, 0.4);
      };

      --shadow-elevation-24dp: {
        box-shadow: 0 24px 38px 3px rgba(0, 0, 0, 0.14),
                    0 9px 46px 8px rgba(0, 0, 0, 0.12),
                    0 11px 15px -7px rgba(0, 0, 0, 0.4);
      };
    }
  </style>
</custom-style>`;l0t.setAttribute("style","display: none;");document.head.appendChild(l0t.content);var c0t=Q`
<dom-module id="paper-material-styles">
  <template>
    <style>
      html {
        --paper-material: {
          display: block;
          position: relative;
        };
        --paper-material-elevation-1: {
          @apply --shadow-elevation-2dp;
        };
        --paper-material-elevation-2: {
          @apply --shadow-elevation-4dp;
        };
        --paper-material-elevation-3: {
          @apply --shadow-elevation-6dp;
        };
        --paper-material-elevation-4: {
          @apply --shadow-elevation-8dp;
        };
        --paper-material-elevation-5: {
          @apply --shadow-elevation-16dp;
        };
      }
      .paper-material {
        @apply --paper-material;
      }
      .paper-material[elevation="1"] {
        @apply --paper-material-elevation-1;
      }
      .paper-material[elevation="2"] {
        @apply --paper-material-elevation-2;
      }
      .paper-material[elevation="3"] {
        @apply --paper-material-elevation-3;
      }
      .paper-material[elevation="4"] {
        @apply --paper-material-elevation-4;
      }
      .paper-material[elevation="5"] {
        @apply --paper-material-elevation-5;
      }

      /* Duplicate the styles because of https://github.com/webcomponents/shadycss/issues/193 */
      :host {
        --paper-material: {
          display: block;
          position: relative;
        };
        --paper-material-elevation-1: {
          @apply --shadow-elevation-2dp;
        };
        --paper-material-elevation-2: {
          @apply --shadow-elevation-4dp;
        };
        --paper-material-elevation-3: {
          @apply --shadow-elevation-6dp;
        };
        --paper-material-elevation-4: {
          @apply --shadow-elevation-8dp;
        };
        --paper-material-elevation-5: {
          @apply --shadow-elevation-16dp;
        };
      }
      :host(.paper-material) {
        @apply --paper-material;
      }
      :host(.paper-material[elevation="1"]) {
        @apply --paper-material-elevation-1;
      }
      :host(.paper-material[elevation="2"]) {
        @apply --paper-material-elevation-2;
      }
      :host(.paper-material[elevation="3"]) {
        @apply --paper-material-elevation-3;
      }
      :host(.paper-material[elevation="4"]) {
        @apply --paper-material-elevation-4;
      }
      :host(.paper-material[elevation="5"]) {
        @apply --paper-material-elevation-5;
      }
    </style>
  </template>
</dom-module>`;c0t.setAttribute("style","display: none;");document.head.appendChild(c0t.content);var Di={properties:{focused:{type:Boolean,value:!1,notify:!0,readOnly:!0,reflectToAttribute:!0},disabled:{type:Boolean,value:!1,notify:!0,observer:"_disabledChanged",reflectToAttribute:!0},_oldTabIndex:{type:String},_boundFocusBlurHandler:{type:Function,value:function(){return this._focusBlurHandler.bind(this)}}},observers:["_changedControlState(focused, disabled)"],ready:function(){this.addEventListener("focus",this._boundFocusBlurHandler,!0),this.addEventListener("blur",this._boundFocusBlurHandler,!0)},_focusBlurHandler:function(e){this._setFocused(e.type==="focus")},_disabledChanged:function(e,t){this.setAttribute("aria-disabled",e?"true":"false"),this.style.pointerEvents=e?"none":"",e?(this._oldTabIndex=this.getAttribute("tabindex"),this._setFocused(!1),this.tabIndex=-1,this.blur()):this._oldTabIndex!==void 0&&(this._oldTabIndex===null?this.removeAttribute("tabindex"):this.setAttribute("tabindex",this._oldTabIndex))},_changedControlState:function(){this._controlStateChanged&&this._controlStateChanged()}};var Yx={properties:{pressed:{type:Boolean,readOnly:!0,value:!1,reflectToAttribute:!0,observer:"_pressedChanged"},toggles:{type:Boolean,value:!1,reflectToAttribute:!0},active:{type:Boolean,value:!1,notify:!0,reflectToAttribute:!0},pointerDown:{type:Boolean,readOnly:!0,value:!1},receivedFocusFromKeyboard:{type:Boolean,readOnly:!0},ariaActiveAttribute:{type:String,value:"aria-pressed",observer:"_ariaActiveAttributeChanged"}},listeners:{down:"_downHandler",up:"_upHandler",tap:"_tapHandler"},observers:["_focusChanged(focused)","_activeChanged(active, ariaActiveAttribute)"],keyBindings:{"enter:keydown":"_asyncClick","space:keydown":"_spaceKeyDownHandler","space:keyup":"_spaceKeyUpHandler"},_mouseEventRe:/^mouse/,_tapHandler:function(){this.toggles?this._userActivate(!this.active):this.active=!1},_focusChanged:function(e){this._detectKeyboardFocus(e),e||this._setPressed(!1)},_detectKeyboardFocus:function(e){this._setReceivedFocusFromKeyboard(!this.pointerDown&&e)},_userActivate:function(e){this.active!==e&&(this.active=e,this.fire("change"))},_downHandler:function(e){this._setPointerDown(!0),this._setPressed(!0),this._setReceivedFocusFromKeyboard(!1)},_upHandler:function(){this._setPointerDown(!1),this._setPressed(!1)},_spaceKeyDownHandler:function(e){var t=e.detail.keyboardEvent,r=zt(t).localTarget;this.isLightDescendant(r)||(t.preventDefault(),t.stopImmediatePropagation(),this._setPressed(!0))},_spaceKeyUpHandler:function(e){var t=e.detail.keyboardEvent,r=zt(t).localTarget;this.isLightDescendant(r)||(this.pressed&&this._asyncClick(),this._setPressed(!1))},_asyncClick:function(){this.async(function(){this.click()},1)},_pressedChanged:function(e){this._changedButtonState()},_ariaActiveAttributeChanged:function(e,t){t&&t!=e&&this.hasAttribute(t)&&this.removeAttribute(t)},_activeChanged:function(e,t){this.toggles?this.setAttribute(this.ariaActiveAttribute,e?"true":"false"):this.removeAttribute(this.ariaActiveAttribute),this._changedButtonState()},_controlStateChanged:function(){this.disabled?this._setPressed(!1):this._changedButtonState()},_changedButtonState:function(){this._buttonStateChanged&&this._buttonStateChanged()}},Sh=[Oo,Yx];var Mh={distance:function(e,t,r,n){var i=e-r,o=t-n;return Math.sqrt(i*i+o*o)},now:window.performance&&window.performance.now?window.performance.now.bind(window.performance):Date.now};function u0t(e){this.element=e,this.width=this.boundingRect.width,this.height=this.boundingRect.height,this.size=Math.max(this.width,this.height)}u0t.prototype={get boundingRect(){return this.element.getBoundingClientRect()},furthestCornerDistanceFrom:function(e,t){var r=Mh.distance(e,t,0,0),n=Mh.distance(e,t,this.width,0),i=Mh.distance(e,t,0,this.height),o=Mh.distance(e,t,this.width,this.height);return Math.max(r,n,i,o)}};function g_(e){this.element=e,this.color=window.getComputedStyle(e).color,this.wave=document.createElement("div"),this.waveContainer=document.createElement("div"),this.wave.style.backgroundColor=this.color,this.wave.classList.add("wave"),this.waveContainer.classList.add("wave-container"),zt(this.waveContainer).appendChild(this.wave),this.resetInteractionState()}g_.MAX_RADIUS=300;g_.prototype={get recenters(){return this.element.recenters},get center(){return this.element.center},get mouseDownElapsed(){var e;return this.mouseDownStart?(e=Mh.now()-this.mouseDownStart,this.mouseUpStart&&(e-=this.mouseUpElapsed),e):0},get mouseUpElapsed(){return this.mouseUpStart?Mh.now()-this.mouseUpStart:0},get mouseDownElapsedSeconds(){return this.mouseDownElapsed/1e3},get mouseUpElapsedSeconds(){return this.mouseUpElapsed/1e3},get mouseInteractionSeconds(){return this.mouseDownElapsedSeconds+this.mouseUpElapsedSeconds},get initialOpacity(){return this.element.initialOpacity},get opacityDecayVelocity(){return this.element.opacityDecayVelocity},get radius(){var e=this.containerMetrics.width*this.containerMetrics.width,t=this.containerMetrics.height*this.containerMetrics.height,r=Math.min(Math.sqrt(e+t),g_.MAX_RADIUS)*1.1+5,n=1.1-.2*(r/g_.MAX_RADIUS),i=this.mouseInteractionSeconds/n,o=r*(1-Math.pow(80,-i));return Math.abs(o)},get opacity(){return this.mouseUpStart?Math.max(0,this.initialOpacity-this.mouseUpElapsedSeconds*this.opacityDecayVelocity):this.initialOpacity},get outerOpacity(){var e=this.mouseUpElapsedSeconds*.3,t=this.opacity;return Math.max(0,Math.min(e,t))},get isOpacityFullyDecayed(){return this.opacity<.01&&this.radius>=Math.min(this.maxRadius,g_.MAX_RADIUS)},get isRestingAtMaxRadius(){return this.opacity>=this.initialOpacity&&this.radius>=Math.min(this.maxRadius,g_.MAX_RADIUS)},get isAnimationComplete(){return this.mouseUpStart?this.isOpacityFullyDecayed:this.isRestingAtMaxRadius},get translationFraction(){return Math.min(1,this.radius/this.containerMetrics.size*2/Math.sqrt(2))},get xNow(){return this.xEnd?this.xStart+this.translationFraction*(this.xEnd-this.xStart):this.xStart},get yNow(){return this.yEnd?this.yStart+this.translationFraction*(this.yEnd-this.yStart):this.yStart},get isMouseDown(){return this.mouseDownStart&&!this.mouseUpStart},resetInteractionState:function(){this.maxRadius=0,this.mouseDownStart=0,this.mouseUpStart=0,this.xStart=0,this.yStart=0,this.xEnd=0,this.yEnd=0,this.slideDistance=0,this.containerMetrics=new u0t(this.element)},draw:function(){var e,t,r;this.wave.style.opacity=this.opacity,e=this.radius/(this.containerMetrics.size/2),t=this.xNow-this.containerMetrics.width/2,r=this.yNow-this.containerMetrics.height/2,this.waveContainer.style.webkitTransform="translate("+t+"px, "+r+"px)",this.waveContainer.style.transform="translate3d("+t+"px, "+r+"px, 0)",this.wave.style.webkitTransform="scale("+e+","+e+")",this.wave.style.transform="scale3d("+e+","+e+",1)"},downAction:function(e){var t=this.containerMetrics.width/2,r=this.containerMetrics.height/2;this.resetInteractionState(),this.mouseDownStart=Mh.now(),this.center?(this.xStart=t,this.yStart=r,this.slideDistance=Mh.distance(this.xStart,this.yStart,this.xEnd,this.yEnd)):(this.xStart=e?e.detail.x-this.containerMetrics.boundingRect.left:this.containerMetrics.width/2,this.yStart=e?e.detail.y-this.containerMetrics.boundingRect.top:this.containerMetrics.height/2),this.recenters&&(this.xEnd=t,this.yEnd=r,this.slideDistance=Mh.distance(this.xStart,this.yStart,this.xEnd,this.yEnd)),this.maxRadius=this.containerMetrics.furthestCornerDistanceFrom(this.xStart,this.yStart),this.waveContainer.style.top=(this.containerMetrics.height-this.containerMetrics.size)/2+"px",this.waveContainer.style.left=(this.containerMetrics.width-this.containerMetrics.size)/2+"px",this.waveContainer.style.width=this.containerMetrics.size+"px",this.waveContainer.style.height=this.containerMetrics.size+"px"},upAction:function(e){!this.isMouseDown||(this.mouseUpStart=Mh.now())},remove:function(){zt(zt(this.waveContainer).parentNode).removeChild(this.waveContainer)}};Yt({_template:Q`
    <style>
      :host {
        display: block;
        position: absolute;
        border-radius: inherit;
        overflow: hidden;
        top: 0;
        left: 0;
        right: 0;
        bottom: 0;

        /* See PolymerElements/paper-behaviors/issues/34. On non-Chrome browsers,
         * creating a node (with a position:absolute) in the middle of an event
         * handler "interrupts" that event handler (which happens when the
         * ripple is created on demand) */
        pointer-events: none;
      }

      :host([animating]) {
        /* This resolves a rendering issue in Chrome (as of 40) where the
           ripple is not properly clipped by its parent (which may have
           rounded corners). See: http://jsbin.com/temexa/4

           Note: We only apply this style conditionally. Otherwise, the browser
           will create a new compositing layer for every ripple element on the
           page, and that would be bad. */
        -webkit-transform: translate(0, 0);
        transform: translate3d(0, 0, 0);
      }

      #background,
      #waves,
      .wave-container,
      .wave {
        pointer-events: none;
        position: absolute;
        top: 0;
        left: 0;
        width: 100%;
        height: 100%;
      }

      #background,
      .wave {
        opacity: 0;
      }

      #waves,
      .wave {
        overflow: hidden;
      }

      .wave-container,
      .wave {
        border-radius: 50%;
      }

      :host(.circle) #background,
      :host(.circle) #waves {
        border-radius: 50%;
      }

      :host(.circle) .wave-container {
        overflow: hidden;
      }
    </style>

    <div id="background"></div>
    <div id="waves"></div>
`,is:"paper-ripple",behaviors:[Oo],properties:{initialOpacity:{type:Number,value:.25},opacityDecayVelocity:{type:Number,value:.8},recenters:{type:Boolean,value:!1},center:{type:Boolean,value:!1},ripples:{type:Array,value:function(){return[]}},animating:{type:Boolean,readOnly:!0,reflectToAttribute:!0,value:!1},holdDown:{type:Boolean,value:!1,observer:"_holdDownChanged"},noink:{type:Boolean,value:!1},_animating:{type:Boolean},_boundAnimate:{type:Function,value:function(){return this.animate.bind(this)}}},get target(){return this.keyEventTarget},keyBindings:{"enter:keydown":"_onEnterKeydown","space:keydown":"_onSpaceKeydown","space:keyup":"_onSpaceKeyup"},attached:function(){zt(this).parentNode.nodeType==11?this.keyEventTarget=zt(this).getOwnerRoot().host:this.keyEventTarget=zt(this).parentNode;var e=this.keyEventTarget;this.listen(e,"up","uiUpAction"),this.listen(e,"down","uiDownAction")},detached:function(){this.unlisten(this.keyEventTarget,"up","uiUpAction"),this.unlisten(this.keyEventTarget,"down","uiDownAction"),this.keyEventTarget=null},get shouldKeepAnimating(){for(var e=0;e<this.ripples.length;++e)if(!this.ripples[e].isAnimationComplete)return!0;return!1},simulatedRipple:function(){this.downAction(null),this.async(function(){this.upAction()},1)},uiDownAction:function(e){this.noink||this.downAction(e)},downAction:function(e){if(!(this.holdDown&&this.ripples.length>0)){var t=this.addRipple();t.downAction(e),this._animating||(this._animating=!0,this.animate())}},uiUpAction:function(e){this.noink||this.upAction(e)},upAction:function(e){this.holdDown||(this.ripples.forEach(function(t){t.upAction(e)}),this._animating=!0,this.animate())},onAnimationComplete:function(){this._animating=!1,this.$.background.style.backgroundColor="",this.fire("transitionend")},addRipple:function(){var e=new g_(this);return zt(this.$.waves).appendChild(e.waveContainer),this.$.background.style.backgroundColor=e.color,this.ripples.push(e),this._setAnimating(!0),e},removeRipple:function(e){var t=this.ripples.indexOf(e);t<0||(this.ripples.splice(t,1),e.remove(),this.ripples.length||this._setAnimating(!1))},animate:function(){if(!!this._animating){var e,t;for(e=0;e<this.ripples.length;++e)t=this.ripples[e],t.draw(),this.$.background.style.opacity=t.outerOpacity,t.isOpacityFullyDecayed&&!t.isRestingAtMaxRadius&&this.removeRipple(t);!this.shouldKeepAnimating&&this.ripples.length===0?this.onAnimationComplete():window.requestAnimationFrame(this._boundAnimate)}},animateRipple:function(){return this.animate()},_onEnterKeydown:function(){this.uiDownAction(),this.async(this.uiUpAction,1)},_onSpaceKeydown:function(){this.uiDownAction()},_onSpaceKeyup:function(){this.uiUpAction()},_holdDownChanged:function(e,t){t!==void 0&&(e?this.downAction():this.upAction())}});var su={properties:{noink:{type:Boolean,observer:"_noinkChanged"},_rippleContainer:{type:Object}},_buttonStateChanged:function(){this.focused&&this.ensureRipple()},_downHandler:function(e){Yx._downHandler.call(this,e),this.pressed&&this.ensureRipple(e)},ensureRipple:function(e){if(!this.hasRipple()){this._ripple=this._createRipple(),this._ripple.noink=this.noink;var t=this._rippleContainer||this.root;if(t&&zt(t).appendChild(this._ripple),e){var r=zt(this._rippleContainer||this),n=zt(e).rootTarget;r.deepContains(n)&&this._ripple.uiDownAction(e)}}},getRipple:function(){return this.ensureRipple(),this._ripple},hasRipple:function(){return Boolean(this._ripple)},_createRipple:function(){var e=document.createElement("paper-ripple");return e},_noinkChanged:function(e){this.hasRipple()&&(this._ripple.noink=e)}};var uW={properties:{elevation:{type:Number,reflectToAttribute:!0,readOnly:!0}},observers:["_calculateElevation(focused, disabled, active, pressed, receivedFocusFromKeyboard)","_computeKeyboardClass(receivedFocusFromKeyboard)"],hostAttributes:{role:"button",tabindex:"0",animated:!0},_calculateElevation:function(){var e=1;this.disabled?e=0:this.active||this.pressed?e=4:this.receivedFocusFromKeyboard&&(e=3),this._setElevation(e)},_computeKeyboardClass:function(e){this.toggleClass("keyboard-focus",e)},_spaceKeyDownHandler:function(e){Yx._spaceKeyDownHandler.call(this,e),this.hasRipple()&&this.getRipple().ripples.length<1&&this._ripple.uiDownAction()},_spaceKeyUpHandler:function(e){Yx._spaceKeyUpHandler.call(this,e),this.hasRipple()&&this._ripple.uiUpAction()}},h0t=[Sh,Di,su,uW];var f0t=Q`
  <style include="paper-material-styles">
    /* Need to specify the same specificity as the styles imported from paper-material. */
    :host {
      @apply --layout-inline;
      @apply --layout-center-center;
      position: relative;
      box-sizing: border-box;
      min-width: 5.14em;
      margin: 0 0.29em;
      background: transparent;
      -webkit-tap-highlight-color: rgba(0, 0, 0, 0);
      -webkit-tap-highlight-color: transparent;
      font: inherit;
      text-transform: uppercase;
      outline-width: 0;
      border-radius: 3px;
      -moz-user-select: none;
      -ms-user-select: none;
      -webkit-user-select: none;
      user-select: none;
      cursor: pointer;
      z-index: 0;
      padding: 0.7em 0.57em;

      @apply --paper-font-common-base;
      @apply --paper-button;
    }

    :host([elevation="1"]) {
      @apply --paper-material-elevation-1;
    }

    :host([elevation="2"]) {
      @apply --paper-material-elevation-2;
    }

    :host([elevation="3"]) {
      @apply --paper-material-elevation-3;
    }

    :host([elevation="4"]) {
      @apply --paper-material-elevation-4;
    }

    :host([elevation="5"]) {
      @apply --paper-material-elevation-5;
    }

    :host([hidden]) {
      display: none !important;
    }

    :host([raised].keyboard-focus) {
      font-weight: bold;
      @apply --paper-button-raised-keyboard-focus;
    }

    :host(:not([raised]).keyboard-focus) {
      font-weight: bold;
      @apply --paper-button-flat-keyboard-focus;
    }

    :host([disabled]) {
      background: none;
      color: #a8a8a8;
      cursor: auto;
      pointer-events: none;

      @apply --paper-button-disabled;
    }

    :host([disabled][raised]) {
      background: #eaeaea;
    }


    :host([animated]) {
      @apply --shadow-transition;
    }

    paper-ripple {
      color: var(--paper-button-ink-color);
    }
  </style>

  <slot></slot>`;f0t.setAttribute("strip-whitespace","");Yt({_template:f0t,is:"paper-button",behaviors:[h0t],properties:{raised:{type:Boolean,reflectToAttribute:!0,value:!1,observer:"_calculateElevation"}},_calculateElevation:function(){this.raised?uW._calculateElevation.apply(this):this._setElevation(0)}});var p0t=Q`
<custom-style>
  <style is="custom-style">
    html {

      /* Material Design color palette for Google products */

      --google-red-100: #f4c7c3;
      --google-red-300: #e67c73;
      --google-red-500: #db4437;
      --google-red-700: #c53929;

      --google-blue-100: #c6dafc;
      --google-blue-300: #7baaf7;
      --google-blue-500: #4285f4;
      --google-blue-700: #3367d6;

      --google-green-100: #b7e1cd;
      --google-green-300: #57bb8a;
      --google-green-500: #0f9d58;
      --google-green-700: #0b8043;

      --google-yellow-100: #fce8b2;
      --google-yellow-300: #f7cb4d;
      --google-yellow-500: #f4b400;
      --google-yellow-700: #f09300;

      --google-grey-100: #f5f5f5;
      --google-grey-300: #e0e0e0;
      --google-grey-500: #9e9e9e;
      --google-grey-700: #616161;

      /* Material Design color palette from online spec document */

      --paper-red-50: #ffebee;
      --paper-red-100: #ffcdd2;
      --paper-red-200: #ef9a9a;
      --paper-red-300: #e57373;
      --paper-red-400: #ef5350;
      --paper-red-500: #f44336;
      --paper-red-600: #e53935;
      --paper-red-700: #d32f2f;
      --paper-red-800: #c62828;
      --paper-red-900: #b71c1c;
      --paper-red-a100: #ff8a80;
      --paper-red-a200: #ff5252;
      --paper-red-a400: #ff1744;
      --paper-red-a700: #d50000;

      --paper-pink-50: #fce4ec;
      --paper-pink-100: #f8bbd0;
      --paper-pink-200: #f48fb1;
      --paper-pink-300: #f06292;
      --paper-pink-400: #ec407a;
      --paper-pink-500: #e91e63;
      --paper-pink-600: #d81b60;
      --paper-pink-700: #c2185b;
      --paper-pink-800: #ad1457;
      --paper-pink-900: #880e4f;
      --paper-pink-a100: #ff80ab;
      --paper-pink-a200: #ff4081;
      --paper-pink-a400: #f50057;
      --paper-pink-a700: #c51162;

      --paper-purple-50: #f3e5f5;
      --paper-purple-100: #e1bee7;
      --paper-purple-200: #ce93d8;
      --paper-purple-300: #ba68c8;
      --paper-purple-400: #ab47bc;
      --paper-purple-500: #9c27b0;
      --paper-purple-600: #8e24aa;
      --paper-purple-700: #7b1fa2;
      --paper-purple-800: #6a1b9a;
      --paper-purple-900: #4a148c;
      --paper-purple-a100: #ea80fc;
      --paper-purple-a200: #e040fb;
      --paper-purple-a400: #d500f9;
      --paper-purple-a700: #aa00ff;

      --paper-deep-purple-50: #ede7f6;
      --paper-deep-purple-100: #d1c4e9;
      --paper-deep-purple-200: #b39ddb;
      --paper-deep-purple-300: #9575cd;
      --paper-deep-purple-400: #7e57c2;
      --paper-deep-purple-500: #673ab7;
      --paper-deep-purple-600: #5e35b1;
      --paper-deep-purple-700: #512da8;
      --paper-deep-purple-800: #4527a0;
      --paper-deep-purple-900: #311b92;
      --paper-deep-purple-a100: #b388ff;
      --paper-deep-purple-a200: #7c4dff;
      --paper-deep-purple-a400: #651fff;
      --paper-deep-purple-a700: #6200ea;

      --paper-indigo-50: #e8eaf6;
      --paper-indigo-100: #c5cae9;
      --paper-indigo-200: #9fa8da;
      --paper-indigo-300: #7986cb;
      --paper-indigo-400: #5c6bc0;
      --paper-indigo-500: #3f51b5;
      --paper-indigo-600: #3949ab;
      --paper-indigo-700: #303f9f;
      --paper-indigo-800: #283593;
      --paper-indigo-900: #1a237e;
      --paper-indigo-a100: #8c9eff;
      --paper-indigo-a200: #536dfe;
      --paper-indigo-a400: #3d5afe;
      --paper-indigo-a700: #304ffe;

      --paper-blue-50: #e3f2fd;
      --paper-blue-100: #bbdefb;
      --paper-blue-200: #90caf9;
      --paper-blue-300: #64b5f6;
      --paper-blue-400: #42a5f5;
      --paper-blue-500: #2196f3;
      --paper-blue-600: #1e88e5;
      --paper-blue-700: #1976d2;
      --paper-blue-800: #1565c0;
      --paper-blue-900: #0d47a1;
      --paper-blue-a100: #82b1ff;
      --paper-blue-a200: #448aff;
      --paper-blue-a400: #2979ff;
      --paper-blue-a700: #2962ff;

      --paper-light-blue-50: #e1f5fe;
      --paper-light-blue-100: #b3e5fc;
      --paper-light-blue-200: #81d4fa;
      --paper-light-blue-300: #4fc3f7;
      --paper-light-blue-400: #29b6f6;
      --paper-light-blue-500: #03a9f4;
      --paper-light-blue-600: #039be5;
      --paper-light-blue-700: #0288d1;
      --paper-light-blue-800: #0277bd;
      --paper-light-blue-900: #01579b;
      --paper-light-blue-a100: #80d8ff;
      --paper-light-blue-a200: #40c4ff;
      --paper-light-blue-a400: #00b0ff;
      --paper-light-blue-a700: #0091ea;

      --paper-cyan-50: #e0f7fa;
      --paper-cyan-100: #b2ebf2;
      --paper-cyan-200: #80deea;
      --paper-cyan-300: #4dd0e1;
      --paper-cyan-400: #26c6da;
      --paper-cyan-500: #00bcd4;
      --paper-cyan-600: #00acc1;
      --paper-cyan-700: #0097a7;
      --paper-cyan-800: #00838f;
      --paper-cyan-900: #006064;
      --paper-cyan-a100: #84ffff;
      --paper-cyan-a200: #18ffff;
      --paper-cyan-a400: #00e5ff;
      --paper-cyan-a700: #00b8d4;

      --paper-teal-50: #e0f2f1;
      --paper-teal-100: #b2dfdb;
      --paper-teal-200: #80cbc4;
      --paper-teal-300: #4db6ac;
      --paper-teal-400: #26a69a;
      --paper-teal-500: #009688;
      --paper-teal-600: #00897b;
      --paper-teal-700: #00796b;
      --paper-teal-800: #00695c;
      --paper-teal-900: #004d40;
      --paper-teal-a100: #a7ffeb;
      --paper-teal-a200: #64ffda;
      --paper-teal-a400: #1de9b6;
      --paper-teal-a700: #00bfa5;

      --paper-green-50: #e8f5e9;
      --paper-green-100: #c8e6c9;
      --paper-green-200: #a5d6a7;
      --paper-green-300: #81c784;
      --paper-green-400: #66bb6a;
      --paper-green-500: #4caf50;
      --paper-green-600: #43a047;
      --paper-green-700: #388e3c;
      --paper-green-800: #2e7d32;
      --paper-green-900: #1b5e20;
      --paper-green-a100: #b9f6ca;
      --paper-green-a200: #69f0ae;
      --paper-green-a400: #00e676;
      --paper-green-a700: #00c853;

      --paper-light-green-50: #f1f8e9;
      --paper-light-green-100: #dcedc8;
      --paper-light-green-200: #c5e1a5;
      --paper-light-green-300: #aed581;
      --paper-light-green-400: #9ccc65;
      --paper-light-green-500: #8bc34a;
      --paper-light-green-600: #7cb342;
      --paper-light-green-700: #689f38;
      --paper-light-green-800: #558b2f;
      --paper-light-green-900: #33691e;
      --paper-light-green-a100: #ccff90;
      --paper-light-green-a200: #b2ff59;
      --paper-light-green-a400: #76ff03;
      --paper-light-green-a700: #64dd17;

      --paper-lime-50: #f9fbe7;
      --paper-lime-100: #f0f4c3;
      --paper-lime-200: #e6ee9c;
      --paper-lime-300: #dce775;
      --paper-lime-400: #d4e157;
      --paper-lime-500: #cddc39;
      --paper-lime-600: #c0ca33;
      --paper-lime-700: #afb42b;
      --paper-lime-800: #9e9d24;
      --paper-lime-900: #827717;
      --paper-lime-a100: #f4ff81;
      --paper-lime-a200: #eeff41;
      --paper-lime-a400: #c6ff00;
      --paper-lime-a700: #aeea00;

      --paper-yellow-50: #fffde7;
      --paper-yellow-100: #fff9c4;
      --paper-yellow-200: #fff59d;
      --paper-yellow-300: #fff176;
      --paper-yellow-400: #ffee58;
      --paper-yellow-500: #ffeb3b;
      --paper-yellow-600: #fdd835;
      --paper-yellow-700: #fbc02d;
      --paper-yellow-800: #f9a825;
      --paper-yellow-900: #f57f17;
      --paper-yellow-a100: #ffff8d;
      --paper-yellow-a200: #ffff00;
      --paper-yellow-a400: #ffea00;
      --paper-yellow-a700: #ffd600;

      --paper-amber-50: #fff8e1;
      --paper-amber-100: #ffecb3;
      --paper-amber-200: #ffe082;
      --paper-amber-300: #ffd54f;
      --paper-amber-400: #ffca28;
      --paper-amber-500: #ffc107;
      --paper-amber-600: #ffb300;
      --paper-amber-700: #ffa000;
      --paper-amber-800: #ff8f00;
      --paper-amber-900: #ff6f00;
      --paper-amber-a100: #ffe57f;
      --paper-amber-a200: #ffd740;
      --paper-amber-a400: #ffc400;
      --paper-amber-a700: #ffab00;

      --paper-orange-50: #fff3e0;
      --paper-orange-100: #ffe0b2;
      --paper-orange-200: #ffcc80;
      --paper-orange-300: #ffb74d;
      --paper-orange-400: #ffa726;
      --paper-orange-500: #ff9800;
      --paper-orange-600: #fb8c00;
      --paper-orange-700: #f57c00;
      --paper-orange-800: #ef6c00;
      --paper-orange-900: #e65100;
      --paper-orange-a100: #ffd180;
      --paper-orange-a200: #ffab40;
      --paper-orange-a400: #ff9100;
      --paper-orange-a700: #ff6500;

      --paper-deep-orange-50: #fbe9e7;
      --paper-deep-orange-100: #ffccbc;
      --paper-deep-orange-200: #ffab91;
      --paper-deep-orange-300: #ff8a65;
      --paper-deep-orange-400: #ff7043;
      --paper-deep-orange-500: #ff5722;
      --paper-deep-orange-600: #f4511e;
      --paper-deep-orange-700: #e64a19;
      --paper-deep-orange-800: #d84315;
      --paper-deep-orange-900: #bf360c;
      --paper-deep-orange-a100: #ff9e80;
      --paper-deep-orange-a200: #ff6e40;
      --paper-deep-orange-a400: #ff3d00;
      --paper-deep-orange-a700: #dd2c00;

      --paper-brown-50: #efebe9;
      --paper-brown-100: #d7ccc8;
      --paper-brown-200: #bcaaa4;
      --paper-brown-300: #a1887f;
      --paper-brown-400: #8d6e63;
      --paper-brown-500: #795548;
      --paper-brown-600: #6d4c41;
      --paper-brown-700: #5d4037;
      --paper-brown-800: #4e342e;
      --paper-brown-900: #3e2723;

      --paper-grey-50: #fafafa;
      --paper-grey-100: #f5f5f5;
      --paper-grey-200: #eeeeee;
      --paper-grey-300: #e0e0e0;
      --paper-grey-400: #bdbdbd;
      --paper-grey-500: #9e9e9e;
      --paper-grey-600: #757575;
      --paper-grey-700: #616161;
      --paper-grey-800: #424242;
      --paper-grey-900: #212121;

      --paper-blue-grey-50: #eceff1;
      --paper-blue-grey-100: #cfd8dc;
      --paper-blue-grey-200: #b0bec5;
      --paper-blue-grey-300: #90a4ae;
      --paper-blue-grey-400: #78909c;
      --paper-blue-grey-500: #607d8b;
      --paper-blue-grey-600: #546e7a;
      --paper-blue-grey-700: #455a64;
      --paper-blue-grey-800: #37474f;
      --paper-blue-grey-900: #263238;

      /* opacity for dark text on a light background */
      --dark-divider-opacity: 0.12;
      --dark-disabled-opacity: 0.38; /* or hint text or icon */
      --dark-secondary-opacity: 0.54;
      --dark-primary-opacity: 0.87;

      /* opacity for light text on a dark background */
      --light-divider-opacity: 0.12;
      --light-disabled-opacity: 0.3; /* or hint text or icon */
      --light-secondary-opacity: 0.7;
      --light-primary-opacity: 1.0;

    }

  </style>
</custom-style>
`;p0t.setAttribute("style","display: none;");document.head.appendChild(p0t.content);var d0t=Q`
<custom-style>
  <style is="custom-style">
    html {
      /*
       * You can use these generic variables in your elements for easy theming.
       * For example, if all your elements use \`--primary-text-color\` as its main
       * color, then switching from a light to a dark theme is just a matter of
       * changing the value of \`--primary-text-color\` in your application.
       */
      --primary-text-color: var(--light-theme-text-color);
      --primary-background-color: var(--light-theme-background-color);
      --secondary-text-color: var(--light-theme-secondary-color);
      --disabled-text-color: var(--light-theme-disabled-color);
      --divider-color: var(--light-theme-divider-color);
      --error-color: var(--paper-deep-orange-a700);

      /*
       * Primary and accent colors. Also see color.js for more colors.
       */
      --primary-color: var(--paper-indigo-500);
      --light-primary-color: var(--paper-indigo-100);
      --dark-primary-color: var(--paper-indigo-700);

      --accent-color: var(--paper-pink-a200);
      --light-accent-color: var(--paper-pink-a100);
      --dark-accent-color: var(--paper-pink-a400);


      /*
       * Material Design Light background theme
       */
      --light-theme-background-color: #ffffff;
      --light-theme-base-color: #000000;
      --light-theme-text-color: var(--paper-grey-900);
      --light-theme-secondary-color: #737373;  /* for secondary text and icons */
      --light-theme-disabled-color: #9b9b9b;  /* disabled/hint text */
      --light-theme-divider-color: #dbdbdb;

      /*
       * Material Design Dark background theme
       */
      --dark-theme-background-color: var(--paper-grey-900);
      --dark-theme-base-color: #ffffff;
      --dark-theme-text-color: #ffffff;
      --dark-theme-secondary-color: #bcbcbc;  /* for secondary text and icons */
      --dark-theme-disabled-color: #646464;  /* disabled/hint text */
      --dark-theme-divider-color: #3c3c3c;

      /*
       * Deprecated values because of their confusing names.
       */
      --text-primary-color: var(--dark-theme-text-color);
      --default-primary-color: var(--primary-color);
    }
  </style>
</custom-style>`;d0t.setAttribute("style","display: none;");document.head.appendChild(d0t.content);var Eh={properties:{name:{type:String},value:{notify:!0,type:String},required:{type:Boolean,value:!1}},attached:function(){},detached:function(){}};var hW=null,Th={properties:{validator:{type:String},invalid:{notify:!0,reflectToAttribute:!0,type:Boolean,value:!1,observer:"_invalidChanged"}},registered:function(){hW=new go({type:"validator"})},_invalidChanged:function(){this.invalid?this.setAttribute("aria-invalid","true"):this.removeAttribute("aria-invalid")},get _validator(){return hW&&hW.byKey(this.validator)},hasValidator:function(){return this._validator!=null},validate:function(e){return e===void 0&&this.value!==void 0?this.invalid=!this._getValidity(this.value):this.invalid=!this._getValidity(e),!this.invalid},_getValidity:function(e){return this.hasValidator()?this._validator.validate(e):!0}};var fW={properties:{checked:{type:Boolean,value:!1,reflectToAttribute:!0,notify:!0,observer:"_checkedChanged"},toggles:{type:Boolean,value:!0,reflectToAttribute:!0},value:{type:String,value:"on",observer:"_valueChanged"}},observers:["_requiredChanged(required)"],created:function(){this._hasIronCheckedElementBehavior=!0},_getValidity:function(e){return this.disabled||!this.required||this.checked},_requiredChanged:function(){this.required?this.setAttribute("aria-required","true"):this.removeAttribute("aria-required")},_checkedChanged:function(){this.active=this.checked,this.fire("iron-change")},_valueChanged:function(){(this.value===void 0||this.value===null)&&(this.value="on")}},m0t=[Eh,Th,fW];var pE={observers:["_focusedChanged(receivedFocusFromKeyboard)"],_focusedChanged:function(e){e&&this.ensureRipple(),this.hasRipple()&&(this._ripple.holdDown=e)},_createRipple:function(){var e=su._createRipple();return e.id="ink",e.setAttribute("center",""),e.classList.add("circle"),e}},jx=[Sh,Di,su,pE];var Lbe={_checkedChanged:function(){fW._checkedChanged.call(this),this.hasRipple()&&(this.checked?this._ripple.setAttribute("checked",""):this._ripple.removeAttribute("checked"))},_buttonStateChanged:function(){su._buttonStateChanged.call(this),!this.disabled&&this.isAttached&&(this.checked=this.active)}},Xx=[jx,m0t,Lbe];var g0t=Q`<style>
  :host {
    display: inline-block;
    white-space: nowrap;
    cursor: pointer;
    --calculated-paper-checkbox-size: var(--paper-checkbox-size, 18px);
    /* -1px is a sentinel for the default and is replaced in \`attached\`. */
    --calculated-paper-checkbox-ink-size: var(--paper-checkbox-ink-size, -1px);
    @apply --paper-font-common-base;
    line-height: 0;
    -webkit-tap-highlight-color: transparent;
  }

  :host([hidden]) {
    display: none !important;
  }

  :host(:focus) {
    outline: none;
  }

  .hidden {
    display: none;
  }

  #checkboxContainer {
    display: inline-block;
    position: relative;
    width: var(--calculated-paper-checkbox-size);
    height: var(--calculated-paper-checkbox-size);
    min-width: var(--calculated-paper-checkbox-size);
    margin: var(--paper-checkbox-margin, initial);
    vertical-align: var(--paper-checkbox-vertical-align, middle);
    background-color: var(--paper-checkbox-unchecked-background-color, transparent);
  }

  #ink {
    position: absolute;

    /* Center the ripple in the checkbox by negative offsetting it by
     * (inkWidth - rippleWidth) / 2 */
    top: calc(0px - (var(--calculated-paper-checkbox-ink-size) - var(--calculated-paper-checkbox-size)) / 2);
    left: calc(0px - (var(--calculated-paper-checkbox-ink-size) - var(--calculated-paper-checkbox-size)) / 2);
    width: var(--calculated-paper-checkbox-ink-size);
    height: var(--calculated-paper-checkbox-ink-size);
    color: var(--paper-checkbox-unchecked-ink-color, var(--primary-text-color));
    opacity: 0.6;
    pointer-events: none;
  }

  #ink:dir(rtl) {
    right: calc(0px - (var(--calculated-paper-checkbox-ink-size) - var(--calculated-paper-checkbox-size)) / 2);
    left: auto;
  }

  #ink[checked] {
    color: var(--paper-checkbox-checked-ink-color, var(--primary-color));
  }

  #checkbox {
    position: relative;
    box-sizing: border-box;
    height: 100%;
    border: solid 2px;
    border-color: var(--paper-checkbox-unchecked-color, var(--primary-text-color));
    border-radius: 2px;
    pointer-events: none;
    -webkit-transition: background-color 140ms, border-color 140ms;
    transition: background-color 140ms, border-color 140ms;

    -webkit-transition-duration: var(--paper-checkbox-animation-duration, 140ms);
    transition-duration: var(--paper-checkbox-animation-duration, 140ms);
  }

  /* checkbox checked animations */
  #checkbox.checked #checkmark {
    -webkit-animation: checkmark-expand 140ms ease-out forwards;
    animation: checkmark-expand 140ms ease-out forwards;

    -webkit-animation-duration: var(--paper-checkbox-animation-duration, 140ms);
    animation-duration: var(--paper-checkbox-animation-duration, 140ms);
  }

  @-webkit-keyframes checkmark-expand {
    0% {
      -webkit-transform: scale(0, 0) rotate(45deg);
    }
    100% {
      -webkit-transform: scale(1, 1) rotate(45deg);
    }
  }

  @keyframes checkmark-expand {
    0% {
      transform: scale(0, 0) rotate(45deg);
    }
    100% {
      transform: scale(1, 1) rotate(45deg);
    }
  }

  #checkbox.checked {
    background-color: var(--paper-checkbox-checked-color, var(--primary-color));
    border-color: var(--paper-checkbox-checked-color, var(--primary-color));
  }

  #checkmark {
    position: absolute;
    width: 36%;
    height: 70%;
    border-style: solid;
    border-top: none;
    border-left: none;
    border-right-width: calc(2/15 * var(--calculated-paper-checkbox-size));
    border-bottom-width: calc(2/15 * var(--calculated-paper-checkbox-size));
    border-color: var(--paper-checkbox-checkmark-color, white);
    -webkit-transform-origin: 97% 86%;
    transform-origin: 97% 86%;
    box-sizing: content-box; /* protect against page-level box-sizing */
  }

  #checkmark:dir(rtl) {
    -webkit-transform-origin: 50% 14%;
    transform-origin: 50% 14%;
  }

  /* label */
  #checkboxLabel {
    position: relative;
    display: inline-block;
    vertical-align: middle;
    padding-left: var(--paper-checkbox-label-spacing, 8px);
    white-space: normal;
    line-height: normal;
    color: var(--paper-checkbox-label-color, var(--primary-text-color));
    @apply --paper-checkbox-label;
  }

  :host([checked]) #checkboxLabel {
    color: var(--paper-checkbox-label-checked-color, var(--paper-checkbox-label-color, var(--primary-text-color)));
    @apply --paper-checkbox-label-checked;
  }

  #checkboxLabel:dir(rtl) {
    padding-right: var(--paper-checkbox-label-spacing, 8px);
    padding-left: 0;
  }

  #checkboxLabel[hidden] {
    display: none;
  }

  /* disabled state */

  :host([disabled]) #checkbox {
    opacity: 0.5;
    border-color: var(--paper-checkbox-unchecked-color, var(--primary-text-color));
  }

  :host([disabled][checked]) #checkbox {
    background-color: var(--paper-checkbox-unchecked-color, var(--primary-text-color));
    opacity: 0.5;
  }

  :host([disabled]) #checkboxLabel  {
    opacity: 0.65;
  }

  /* invalid state */
  #checkbox.invalid:not(.checked) {
    border-color: var(--paper-checkbox-error-color, var(--error-color));
  }
</style>

<div id="checkboxContainer">
  <div id="checkbox" class$="[[_computeCheckboxClass(checked, invalid)]]">
    <div id="checkmark" class$="[[_computeCheckmarkClass(checked)]]"></div>
  </div>
</div>

<div id="checkboxLabel"><slot></slot></div>`;g0t.setAttribute("strip-whitespace","");Yt({_template:g0t,is:"paper-checkbox",behaviors:[Xx],hostAttributes:{role:"checkbox","aria-checked":!1,tabindex:0},properties:{ariaActiveAttribute:{type:String,value:"aria-checked"}},attached:function(){Tm(this,function(){var e=this.getComputedStyleValue("--calculated-paper-checkbox-ink-size").trim();if(e==="-1px"){var t=this.getComputedStyleValue("--calculated-paper-checkbox-size").trim(),r="px",n=t.match(/[A-Za-z]+$/);n!==null&&(r=n[0]);var i=parseFloat(t),o=8/3*i;r==="px"&&(o=Math.floor(o),o%2!==i%2&&o++),this.updateStyles({"--paper-checkbox-ink-size":o+r})}})},_computeCheckboxClass:function(e,t){var r="";return e&&(r+="checked "),t&&(r+="invalid"),r},_computeCheckmarkClass:function(e){return e?"":"hidden"},_createRipple:function(){return this._rippleContainer=this.$.checkboxContainer,pE._createRipple.call(this)}});if(!window.polymerSkipLoadingFontRoboto){let e=document.createElement("link");e.rel="stylesheet",e.type="text/css",e.crossOrigin="anonymous",e.href="https://fonts.googleapis.com/css?family=Roboto+Mono:400,700|Roboto:400,300,300italic,400italic,500,500italic,700,700italic",document.head.appendChild(e)}var _0t=Q`<custom-style>
  <style is="custom-style">
    html {

      /* Shared Styles */
      --paper-font-common-base: {
        font-family: 'Roboto', 'Noto', sans-serif;
        -webkit-font-smoothing: antialiased;
      };

      --paper-font-common-code: {
        font-family: 'Roboto Mono', 'Consolas', 'Menlo', monospace;
        -webkit-font-smoothing: antialiased;
      };

      --paper-font-common-expensive-kerning: {
        text-rendering: optimizeLegibility;
      };

      --paper-font-common-nowrap: {
        white-space: nowrap;
        overflow: hidden;
        text-overflow: ellipsis;
      };

      /* Material Font Styles */

      --paper-font-display4: {
        @apply --paper-font-common-base;
        @apply --paper-font-common-nowrap;

        font-size: 112px;
        font-weight: 300;
        letter-spacing: -.044em;
        line-height: 120px;
      };

      --paper-font-display3: {
        @apply --paper-font-common-base;
        @apply --paper-font-common-nowrap;

        font-size: 56px;
        font-weight: 400;
        letter-spacing: -.026em;
        line-height: 60px;
      };

      --paper-font-display2: {
        @apply --paper-font-common-base;

        font-size: 45px;
        font-weight: 400;
        letter-spacing: -.018em;
        line-height: 48px;
      };

      --paper-font-display1: {
        @apply --paper-font-common-base;

        font-size: 34px;
        font-weight: 400;
        letter-spacing: -.01em;
        line-height: 40px;
      };

      --paper-font-headline: {
        @apply --paper-font-common-base;

        font-size: 24px;
        font-weight: 400;
        letter-spacing: -.012em;
        line-height: 32px;
      };

      --paper-font-title: {
        @apply --paper-font-common-base;
        @apply --paper-font-common-nowrap;

        font-size: 20px;
        font-weight: 500;
        line-height: 28px;
      };

      --paper-font-subhead: {
        @apply --paper-font-common-base;

        font-size: 16px;
        font-weight: 400;
        line-height: 24px;
      };

      --paper-font-body2: {
        @apply --paper-font-common-base;

        font-size: 14px;
        font-weight: 500;
        line-height: 24px;
      };

      --paper-font-body1: {
        @apply --paper-font-common-base;

        font-size: 14px;
        font-weight: 400;
        line-height: 20px;
      };

      --paper-font-caption: {
        @apply --paper-font-common-base;
        @apply --paper-font-common-nowrap;

        font-size: 12px;
        font-weight: 400;
        letter-spacing: 0.011em;
        line-height: 20px;
      };

      --paper-font-menu: {
        @apply --paper-font-common-base;
        @apply --paper-font-common-nowrap;

        font-size: 13px;
        font-weight: 500;
        line-height: 24px;
      };

      --paper-font-button: {
        @apply --paper-font-common-base;
        @apply --paper-font-common-nowrap;

        font-size: 14px;
        font-weight: 500;
        letter-spacing: 0.018em;
        line-height: 24px;
        text-transform: uppercase;
      };

      --paper-font-code2: {
        @apply --paper-font-common-code;

        font-size: 14px;
        font-weight: 700;
        line-height: 20px;
      };

      --paper-font-code1: {
        @apply --paper-font-common-code;

        font-size: 14px;
        font-weight: 500;
        line-height: 20px;
      };

    }

  </style>
</custom-style>`;_0t.setAttribute("style","display: none;");document.head.appendChild(_0t.content);var pW=document.createElement("template");pW.setAttribute("style","display: none;");pW.innerHTML=`<dom-module id="paper-dialog-shared-styles">
  <template>
    <style>
      :host {
        display: block;
        margin: 24px 40px;

        background: var(--paper-dialog-background-color, var(--primary-background-color));
        color: var(--paper-dialog-color, var(--primary-text-color));

        @apply --paper-font-body1;
        @apply --shadow-elevation-16dp;
        @apply --paper-dialog;
      }

      :host > ::slotted(*) {
        margin-top: 20px;
        padding: 0 24px;
      }

      :host > ::slotted(.no-padding) {
        padding: 0;
      }

      
      :host > ::slotted(*:first-child) {
        margin-top: 24px;
      }

      :host > ::slotted(*:last-child) {
        margin-bottom: 24px;
      }

      /* In 1.x, this selector was \`:host > ::content h2\`. In 2.x <slot> allows
      to select direct children only, which increases the weight of this
      selector, so we have to re-define first-child/last-child margins below. */
      :host > ::slotted(h2) {
        position: relative;
        margin: 0;

        @apply --paper-font-title;
        @apply --paper-dialog-title;
      }

      /* Apply mixin again, in case it sets margin-top. */
      :host > ::slotted(h2:first-child) {
        margin-top: 24px;
        @apply --paper-dialog-title;
      }

      /* Apply mixin again, in case it sets margin-bottom. */
      :host > ::slotted(h2:last-child) {
        margin-bottom: 24px;
        @apply --paper-dialog-title;
      }

      :host > ::slotted(.paper-dialog-buttons),
      :host > ::slotted(.buttons) {
        position: relative;
        padding: 8px 8px 8px 24px;
        margin: 0;

        color: var(--paper-dialog-button-color, var(--primary-color));

        @apply --layout-horizontal;
        @apply --layout-end-justified;
      }
    </style>
  </template>
</dom-module>`;document.head.appendChild(pW.content);var y0t={properties:{animationConfig:{type:Object},entryAnimation:{observer:"_entryAnimationChanged",type:String},exitAnimation:{observer:"_exitAnimationChanged",type:String}},_entryAnimationChanged:function(){this.animationConfig=this.animationConfig||{},this.animationConfig.entry=[{name:this.entryAnimation,node:this}]},_exitAnimationChanged:function(){this.animationConfig=this.animationConfig||{},this.animationConfig.exit=[{name:this.exitAnimation,node:this}]},_copyProperties:function(e,t){for(var r in t)e[r]=t[r]},_cloneConfig:function(e){var t={isClone:!0};return this._copyProperties(t,e),t},_getAnimationConfigRecursive:function(e,t,r){if(!!this.animationConfig){if(this.animationConfig.value&&typeof this.animationConfig.value=="function"){this._warn(this._logf("playAnimation","Please put 'animationConfig' inside of your components 'properties' object instead of outside of it."));return}var n;if(e?n=this.animationConfig[e]:n=this.animationConfig,Array.isArray(n)||(n=[n]),n)for(var i,o=0;i=n[o];o++)if(i.animatable)i.animatable._getAnimationConfigRecursive(i.type||e,t,r);else if(i.id){var a=t[i.id];a?(a.isClone||(t[i.id]=this._cloneConfig(a),a=t[i.id]),this._copyProperties(a,i)):t[i.id]=i}else r.push(i)}},getAnimationConfig:function(e){var t={},r=[];this._getAnimationConfigRecursive(e,t,r);for(var n in t)r.push(t[n]);return r}};var kbe={_configureAnimations:function(e){var t=[],r=[];if(e.length>0)for(let i,o=0;i=e[o];o++){let a=document.createElement(i.name);if(a.isNeonAnimation){let s=null;a.configure||(a.configure=function(l){return null}),s=a.configure(i),r.push({result:s,config:i,neonAnimation:a})}else console.warn(this.is+":",i.name,"not found!")}for(var n=0;n<r.length;n++){let i=r[n].result,o=r[n].config,a=r[n].neonAnimation;try{typeof i.cancel!="function"&&(i=document.timeline.play(i))}catch(s){i=null,console.warn("Couldnt play","(",o.name,").",s)}i&&t.push({neonAnimation:a,config:o,animation:i})}return t},_shouldComplete:function(e){for(var t=!0,r=0;r<e.length;r++)if(e[r].animation.playState!="finished"){t=!1;break}return t},_complete:function(e){for(var t=0;t<e.length;t++)e[t].neonAnimation.complete(e[t].config);for(var t=0;t<e.length;t++)e[t].animation.cancel()},playAnimation:function(e,t){var r=this.getAnimationConfig(e);if(!!r){this._active=this._active||{},this._active[e]&&(this._complete(this._active[e]),delete this._active[e]);var n=this._configureAnimations(r);if(n.length==0){this.fire("neon-animation-finish",t,{bubbles:!1});return}this._active[e]=n;for(var i=0;i<n.length;i++)n[i].animation.onfinish=function(){this._shouldComplete(n)&&(this._complete(n),delete this._active[e],this.fire("neon-animation-finish",t,{bubbles:!1}))}.bind(this)}},cancelAnimation:function(){for(var e in this._active){var t=this._active[e];for(var r in t)t[r].animation.cancel()}this._active={}}},b9=[y0t,kbe];var w9,Rbe=()=>{if(w9!==void 0)return w9;let e=document.createElement("div");Object.assign(e.style,{overflow:"auto",position:"fixed",left:"0px",top:"0px",maxWidth:"100px",maxHeight:"100px"});let t=document.createElement("div");return t.style.width="200px",t.style.height="200px",e.appendChild(t),document.body.appendChild(e),w9=Math.abs(e.offsetWidth-100)>1?e.offsetWidth-e.clientWidth:0,document.body.removeChild(e),w9},v0t={properties:{sizingTarget:{type:Object,value:function(){return this}},fitInto:{type:Object,value:window},noOverlap:{type:Boolean},positionTarget:{type:Element},horizontalAlign:{type:String},verticalAlign:{type:String},dynamicAlign:{type:Boolean},horizontalOffset:{type:Number,value:0,notify:!0},verticalOffset:{type:Number,value:0,notify:!0},autoFitOnAttach:{type:Boolean,value:!1},expandSizingTargetForScrollbars:{type:Boolean,value:!1},_fitInfo:{type:Object}},get _fitWidth(){var e;return this.fitInto===window?e=this.fitInto.innerWidth:e=this.fitInto.getBoundingClientRect().width,e},get _fitHeight(){var e;return this.fitInto===window?e=this.fitInto.innerHeight:e=this.fitInto.getBoundingClientRect().height,e},get _fitLeft(){var e;return this.fitInto===window?e=0:e=this.fitInto.getBoundingClientRect().left,e},get _fitTop(){var e;return this.fitInto===window?e=0:e=this.fitInto.getBoundingClientRect().top,e},get _defaultPositionTarget(){var e=zt(this).parentNode;return e&&e.nodeType===Node.DOCUMENT_FRAGMENT_NODE&&(e=e.host),e},get _localeHorizontalAlign(){if(this._isRTL){if(this.horizontalAlign==="right")return"left";if(this.horizontalAlign==="left")return"right"}return this.horizontalAlign},get __shouldPosition(){return(this.horizontalAlign||this.verticalAlign)&&this.positionTarget},get _isRTL(){return typeof this._memoizedIsRTL=="undefined"&&(this._memoizedIsRTL=window.getComputedStyle(this).direction=="rtl"),this._memoizedIsRTL},attached:function(){this.positionTarget=this.positionTarget||this._defaultPositionTarget,this.autoFitOnAttach&&(window.getComputedStyle(this).display==="none"?setTimeout(function(){this.fit()}.bind(this)):(window.ShadyDOM&&ShadyDOM.flush(),this.fit()))},detached:function(){this.__deferredFit&&(clearTimeout(this.__deferredFit),this.__deferredFit=null)},fit:function(){this.position(),this.constrain(),this.center()},_discoverInfo:function(){if(!this._fitInfo){var e=window.getComputedStyle(this),t=window.getComputedStyle(this.sizingTarget);this._fitInfo={inlineStyle:{top:this.style.top||"",left:this.style.left||"",position:this.style.position||""},sizerInlineStyle:{maxWidth:this.sizingTarget.style.maxWidth||"",maxHeight:this.sizingTarget.style.maxHeight||"",boxSizing:this.sizingTarget.style.boxSizing||""},positionedBy:{vertically:e.top!=="auto"?"top":e.bottom!=="auto"?"bottom":null,horizontally:e.left!=="auto"?"left":e.right!=="auto"?"right":null},sizedBy:{height:t.maxHeight!=="none",width:t.maxWidth!=="none",minWidth:parseInt(t.minWidth,10)||0,minHeight:parseInt(t.minHeight,10)||0},margin:{top:parseInt(e.marginTop,10)||0,right:parseInt(e.marginRight,10)||0,bottom:parseInt(e.marginBottom,10)||0,left:parseInt(e.marginLeft,10)||0}}}},resetFit:function(){var e=this._fitInfo||{};for(var t in e.sizerInlineStyle)this.sizingTarget.style[t]=e.sizerInlineStyle[t];for(var t in e.inlineStyle)this.style[t]=e.inlineStyle[t];this._fitInfo=null},refit:function(){var e=this.sizingTarget.scrollLeft,t=this.sizingTarget.scrollTop;this.resetFit(),this.fit(),this.sizingTarget.scrollLeft=e,this.sizingTarget.scrollTop=t},position:function(){if(!this.__shouldPosition)return;this._discoverInfo(),window.ShadyDOM&&window.ShadyDOM.flush(),this.style.position="fixed",this.sizingTarget.style.boxSizing="border-box",this.style.left="0px",this.style.top="0px";var e=this.getBoundingClientRect(),t=this.__getNormalizedRect(this.positionTarget),r=this.__getNormalizedRect(this.fitInto);let n,i,o,a;this.expandSizingTargetForScrollbars&&(n=this.sizingTarget.offsetWidth,i=this.sizingTarget.offsetHeight,o=this.sizingTarget.clientWidth,a=this.sizingTarget.clientHeight);var s=this._fitInfo.margin,l={width:e.width+s.left+s.right,height:e.height+s.top+s.bottom},c=this.__getPosition(this._localeHorizontalAlign,this.verticalAlign,l,e,t,r),u=c.left+s.left,h=c.top+s.top,f=Math.min(r.right-s.right,u+e.width),p=Math.min(r.bottom-s.bottom,h+e.height);u=Math.max(r.left+s.left,Math.min(u,f-this._fitInfo.sizedBy.minWidth)),h=Math.max(r.top+s.top,Math.min(h,p-this._fitInfo.sizedBy.minHeight));let d=Math.max(f-u,this._fitInfo.sizedBy.minWidth),g=Math.max(p-h,this._fitInfo.sizedBy.minHeight);this.sizingTarget.style.maxWidth=d+"px",this.sizingTarget.style.maxHeight=g+"px";let _=u-e.left,y=h-e.top;if(this.style.left=`${_}px`,this.style.top=`${y}px`,this.expandSizingTargetForScrollbars){let x=this.sizingTarget.offsetHeight,b=this.sizingTarget.clientHeight,S=i-a,P=x-b-S;if(P>0){let L=r.height-s.top-s.bottom,R=Math.min(L,g+P);this.sizingTarget.style.maxHeight=`${R}px`;let F=this.sizingTarget.offsetHeight,z=F-x,U;c.verticalAlign==="top"?U=y:c.verticalAlign==="middle"?U=y-z/2:c.verticalAlign==="bottom"&&(U=y-z),U=Math.max(r.top+s.top,Math.min(U,r.bottom-s.bottom-F)),this.style.top=`${U}px`}let k=this.sizingTarget.offsetWidth,O=this.sizingTarget.clientWidth,D=n-o,I=k-O-D;if(I>0){let L=Rbe(),R=r.width-s.left-s.right,F=Math.min(R,d+I-L);this.sizingTarget.style.maxWidth=`${F}px`;let z=this.sizingTarget.offsetWidth+L,U=z-k,W;c.horizontalAlign==="left"?W=_:c.horizontalAlign==="center"?W=_-U/2:c.horizontalAlign==="right"&&(W=_-U),W=Math.max(r.left+s.left,Math.min(W,r.right-s.right-z)),this.style.left=`${W}px`}}},constrain:function(){if(!this.__shouldPosition){this._discoverInfo();var e=this._fitInfo;e.positionedBy.vertically||(this.style.position="fixed",this.style.top="0px"),e.positionedBy.horizontally||(this.style.position="fixed",this.style.left="0px"),this.sizingTarget.style.boxSizing="border-box";var t=this.getBoundingClientRect();e.sizedBy.height||this.__sizeDimension(t,e.positionedBy.vertically,"top","bottom","Height"),e.sizedBy.width||this.__sizeDimension(t,e.positionedBy.horizontally,"left","right","Width")}},_sizeDimension:function(e,t,r,n,i){this.__sizeDimension(e,t,r,n,i)},__sizeDimension:function(e,t,r,n,i){var o=this._fitInfo,a=this.__getNormalizedRect(this.fitInto),s=i==="Width"?a.width:a.height,l=t===n,c=l?s-e[n]:e[r],u=o.margin[l?r:n],h="offset"+i,f=this[h]-this.sizingTarget[h];this.sizingTarget.style["max"+i]=s-u-c-f+"px"},center:function(){if(!this.__shouldPosition){this._discoverInfo();var e=this._fitInfo.positionedBy;if(!(e.vertically&&e.horizontally)){this.style.position="fixed",e.vertically||(this.style.top="0px"),e.horizontally||(this.style.left="0px");var t=this.getBoundingClientRect(),r=this.__getNormalizedRect(this.fitInto);if(!e.vertically){var n=r.top-t.top+(r.height-t.height)/2;this.style.top=n+"px"}if(!e.horizontally){var i=r.left-t.left+(r.width-t.width)/2;this.style.left=i+"px"}}}},__getNormalizedRect:function(e){return e===document.documentElement||e===window?{top:0,left:0,width:window.innerWidth,height:window.innerHeight,right:window.innerWidth,bottom:window.innerHeight}:e.getBoundingClientRect()},__getOffscreenArea:function(e,t,r){var n=Math.min(0,e.top)+Math.min(0,r.bottom-(e.top+t.height)),i=Math.min(0,e.left)+Math.min(0,r.right-(e.left+t.width));return Math.abs(n)*t.width+Math.abs(i)*t.height},__getPosition:function(e,t,r,n,i,o){var a=[{verticalAlign:"top",horizontalAlign:"left",top:i.top+this.verticalOffset,left:i.left+this.horizontalOffset},{verticalAlign:"top",horizontalAlign:"right",top:i.top+this.verticalOffset,left:i.right-r.width-this.horizontalOffset},{verticalAlign:"bottom",horizontalAlign:"left",top:i.bottom-r.height-this.verticalOffset,left:i.left+this.horizontalOffset},{verticalAlign:"bottom",horizontalAlign:"right",top:i.bottom-r.height-this.verticalOffset,left:i.right-r.width-this.horizontalOffset}];if(this.noOverlap){for(var s=0,l=a.length;s<l;s++){var c={};for(var u in a[s])c[u]=a[s][u];a.push(c)}a[0].top=a[1].top+=i.height,a[2].top=a[3].top-=i.height,a[4].left=a[6].left+=i.width,a[5].left=a[7].left-=i.width}t=t==="auto"?null:t,e=e==="auto"?null:e,(!e||e==="center")&&(a.push({verticalAlign:"top",horizontalAlign:"center",top:i.top+this.verticalOffset+(this.noOverlap?i.height:0),left:i.left-n.width/2+i.width/2+this.horizontalOffset}),a.push({verticalAlign:"bottom",horizontalAlign:"center",top:i.bottom-r.height-this.verticalOffset-(this.noOverlap?i.height:0),left:i.left-n.width/2+i.width/2+this.horizontalOffset})),(!t||t==="middle")&&(a.push({verticalAlign:"middle",horizontalAlign:"left",top:i.top-n.height/2+i.height/2+this.verticalOffset,left:i.left+this.horizontalOffset+(this.noOverlap?i.width:0)}),a.push({verticalAlign:"middle",horizontalAlign:"right",top:i.top-n.height/2+i.height/2+this.verticalOffset,left:i.right-r.width-this.horizontalOffset-(this.noOverlap?i.width:0)})),t==="middle"&&e==="center"&&a.push({verticalAlign:"middle",horizontalAlign:"center",top:i.top-n.height/2+i.height/2+this.verticalOffset,left:i.left-n.width/2+i.width/2+this.horizontalOffset});for(var h,s=0;s<a.length;s++){var f=a[s],p=f.verticalAlign===t,d=f.horizontalAlign===e;if(!this.dynamicAlign&&!this.noOverlap&&p&&d){h=f;break}var g=(!t||p)&&(!e||d);if(!(!this.dynamicAlign&&!g)){if(f.offscreenArea=this.__getOffscreenArea(f,r,o),f.offscreenArea===0&&g){h=f;break}h=h||f;var _=f.offscreenArea-h.offscreenArea;(_<0||_===0&&(p||d))&&(h=f)}}return h}};var $x=Element.prototype,S9=$x.matches||$x.matchesSelector||$x.mozMatchesSelector||$x.msMatchesSelector||$x.oMatchesSelector||$x.webkitMatchesSelector,dW=class{getTabbableNodes(t){var r=[],n=this._collectTabbableNodes(t,r);return n?this._sortByTabIndex(r):r}isFocusable(t){return S9.call(t,"input, select, textarea, button, object")?S9.call(t,":not([disabled])"):S9.call(t,"a[href], area[href], iframe, [tabindex], [contentEditable]")}isTabbable(t){return this.isFocusable(t)&&S9.call(t,':not([tabindex="-1"])')&&this._isVisible(t)}_normalizedTabIndex(t){if(this.isFocusable(t)){var r=t.getAttribute("tabindex")||0;return Number(r)}return-1}_collectTabbableNodes(t,r){if(t.nodeType!==Node.ELEMENT_NODE)return!1;var n=t;if(!this._isVisible(n))return!1;var i=this._normalizedTabIndex(n),o=i>0;i>=0&&r.push(n);var a;n.localName==="content"||n.localName==="slot"?a=zt(n).getDistributedNodes():a=zt(n.root||n).children;for(var s=0;s<a.length;s++)o=this._collectTabbableNodes(a[s],r)||o;return o}_isVisible(t){var r=t.style;return r.visibility!=="hidden"&&r.display!=="none"?(r=window.getComputedStyle(t),r.visibility!=="hidden"&&r.display!=="none"):!1}_sortByTabIndex(t){var r=t.length;if(r<2)return t;var n=Math.ceil(r/2),i=this._sortByTabIndex(t.slice(0,n)),o=this._sortByTabIndex(t.slice(n));return this._mergeSortByTabIndex(i,o)}_mergeSortByTabIndex(t,r){for(var n=[];t.length>0&&r.length>0;)this._hasLowerTabOrder(t[0],r[0])?n.push(r.shift()):n.push(t.shift());return n.concat(t,r)}_hasLowerTabOrder(t,r){var n=Math.max(t.tabIndex,0),i=Math.max(r.tabIndex,0);return n===0||i===0?i>n:n>i}},x0t=new dW;Yt({_template:Q`
    <style>
      :host {
        position: fixed;
        top: 0;
        left: 0;
        width: 100%;
        height: 100%;
        background-color: var(--iron-overlay-backdrop-background-color, #000);
        opacity: 0;
        transition: opacity 0.2s;
        pointer-events: none;
        @apply --iron-overlay-backdrop;
      }

      :host(.opened) {
        opacity: var(--iron-overlay-backdrop-opacity, 0.6);
        pointer-events: auto;
        @apply --iron-overlay-backdrop-opened;
      }
    </style>

    <slot></slot>
`,is:"iron-overlay-backdrop",properties:{opened:{reflectToAttribute:!0,type:Boolean,value:!1,observer:"_openedChanged"}},listeners:{transitionend:"_onTransitionend"},created:function(){this.__openedRaf=null},attached:function(){this.opened&&this._openedChanged(this.opened)},prepare:function(){this.opened&&!this.parentNode&&zt(document.body).appendChild(this)},open:function(){this.opened=!0},close:function(){this.opened=!1},complete:function(){!this.opened&&this.parentNode===document.body&&zt(this.parentNode).removeChild(this)},_onTransitionend:function(e){e&&e.target===this&&this.complete()},_openedChanged:function(e){if(e)this.prepare();else{var t=window.getComputedStyle(this);(t.transitionDuration==="0s"||t.opacity==0)&&this.complete()}!this.isAttached||(this.__openedRaf&&(window.cancelAnimationFrame(this.__openedRaf),this.__openedRaf=null),this.scrollTop=this.scrollTop,this.__openedRaf=window.requestAnimationFrame(function(){this.__openedRaf=null,this.toggleClass("opened",this.opened)}.bind(this)))}});var mW=class{constructor(){this._overlays=[],this._minimumZ=101,this._backdropElement=null,Em(document.documentElement,"tap",function(){}),document.addEventListener("tap",this._onCaptureClick.bind(this),!0),document.addEventListener("focus",this._onCaptureFocus.bind(this),!0),document.addEventListener("keydown",this._onCaptureKeyDown.bind(this),!0)}get backdropElement(){return this._backdropElement||(this._backdropElement=document.createElement("iron-overlay-backdrop")),this._backdropElement}get deepActiveElement(){var t=document.activeElement;for((!t||!(t instanceof Element))&&(t=document.body);t.root&&zt(t.root).activeElement;)t=zt(t.root).activeElement;return t}_bringOverlayAtIndexToFront(t){var r=this._overlays[t];if(!!r){var n=this._overlays.length-1,i=this._overlays[n];if(i&&this._shouldBeBehindOverlay(r,i)&&n--,!(t>=n)){var o=Math.max(this.currentOverlayZ(),this._minimumZ);for(this._getZ(r)<=o&&this._applyOverlayZ(r,o);t<n;)this._overlays[t]=this._overlays[t+1],t++;this._overlays[n]=r}}}addOrRemoveOverlay(t){t.opened?this.addOverlay(t):this.removeOverlay(t)}addOverlay(t){var r=this._overlays.indexOf(t);if(r>=0){this._bringOverlayAtIndexToFront(r),this.trackBackdrop();return}var n=this._overlays.length,i=this._overlays[n-1],o=Math.max(this._getZ(i),this._minimumZ),a=this._getZ(t);if(i&&this._shouldBeBehindOverlay(t,i)){this._applyOverlayZ(i,o),n--;var s=this._overlays[n-1];o=Math.max(this._getZ(s),this._minimumZ)}a<=o&&this._applyOverlayZ(t,o),this._overlays.splice(n,0,t),this.trackBackdrop()}removeOverlay(t){var r=this._overlays.indexOf(t);r!==-1&&(this._overlays.splice(r,1),this.trackBackdrop())}currentOverlay(){var t=this._overlays.length-1;return this._overlays[t]}currentOverlayZ(){return this._getZ(this.currentOverlay())}ensureMinimumZ(t){this._minimumZ=Math.max(this._minimumZ,t)}focusOverlay(){var t=this.currentOverlay();t&&t._applyFocus()}trackBackdrop(){var t=this._overlayWithBackdrop();!t&&!this._backdropElement||(this.backdropElement.style.zIndex=this._getZ(t)-1,this.backdropElement.opened=!!t,this.backdropElement.prepare())}getBackdrops(){for(var t=[],r=0;r<this._overlays.length;r++)this._overlays[r].withBackdrop&&t.push(this._overlays[r]);return t}backdropZ(){return this._getZ(this._overlayWithBackdrop())-1}_overlayWithBackdrop(){for(var t=this._overlays.length-1;t>=0;t--)if(this._overlays[t].withBackdrop)return this._overlays[t]}_getZ(t){var r=this._minimumZ;if(t){var n=Number(t.style.zIndex||window.getComputedStyle(t).zIndex);n===n&&(r=n)}return r}_setZ(t,r){t.style.zIndex=r}_applyOverlayZ(t,r){this._setZ(t,r+2)}_overlayInPath(t){t=t||[];for(var r=0;r<t.length;r++)if(t[r]._manager===this)return t[r]}_onCaptureClick(t){var r=this._overlays.length-1;if(r!==-1)for(var n=zt(t).path,i;(i=this._overlays[r])&&this._overlayInPath(n)!==i&&(i._onCaptureClick(t),i.allowClickThrough);)r--}_onCaptureFocus(t){var r=this.currentOverlay();r&&r._onCaptureFocus(t)}_onCaptureKeyDown(t){var r=this.currentOverlay();r&&(Oo.keyboardEventMatchesKeys(t,"esc")?r._onCaptureEsc(t):Oo.keyboardEventMatchesKeys(t,"tab")&&r._onCaptureTab(t))}_shouldBeBehindOverlay(t,r){return!t.alwaysOnTop&&r.alwaysOnTop}},b0t=new mW;var E9={pageX:0,pageY:0},w0t=null,gW=[],T9=["wheel","mousewheel","DOMMouseScroll","touchstart","touchmove"],M9,_W;function S0t(e){Ch.indexOf(e)>=0||(Ch.length===0&&Dbe(),Ch.push(e),_W=Ch[Ch.length-1],E0t=[],T0t=[])}function M0t(e){var t=Ch.indexOf(e);t!==-1&&(Ch.splice(t,1),_W=Ch[Ch.length-1],E0t=[],T0t=[],Ch.length===0&&Obe())}var Ch=[],E0t=null,T0t=null;function Nbe(e){if(e.cancelable&&zbe(e)&&e.preventDefault(),e.targetTouches){var t=e.targetTouches[0];E9.pageX=t.pageX,E9.pageY=t.pageY}}function Dbe(){M9=M9||Nbe.bind(void 0);for(var e=0,t=T9.length;e<t;e++)document.addEventListener(T9[e],M9,{capture:!0,passive:!1})}function Obe(){for(var e=0,t=T9.length;e<t;e++)document.removeEventListener(T9[e],M9,{capture:!0,passive:!1})}function zbe(e){var t=zt(e).rootTarget;if(e.type!=="touchmove"&&w0t!==t&&(w0t=t,gW=Fbe(zt(e).path)),!gW.length)return!0;if(e.type==="touchstart")return!1;var r=Hbe(e);return!Bbe(gW,r.deltaX,r.deltaY)}function Fbe(e){for(var t=[],r=e.indexOf(_W),n=0;n<=r;n++)if(e[n].nodeType===Node.ELEMENT_NODE){var i=e[n],o=i.style;o.overflow!=="scroll"&&o.overflow!=="auto"&&(o=window.getComputedStyle(i)),(o.overflow==="scroll"||o.overflow==="auto")&&t.push(i)}return t}function Bbe(e,t,r){if(!(!t&&!r))for(var n=Math.abs(r)>=Math.abs(t),i=0;i<e.length;i++){var o=e[i],a=!1;if(n?a=r<0?o.scrollTop>0:o.scrollTop<o.scrollHeight-o.clientHeight:a=t<0?o.scrollLeft>0:o.scrollLeft<o.scrollWidth-o.clientWidth,a)return o}}function Hbe(e){var t={deltaX:e.deltaX,deltaY:e.deltaY};if(!("deltaX"in e)){if("wheelDeltaX"in e&&"wheelDeltaY"in e)t.deltaX=-e.wheelDeltaX,t.deltaY=-e.wheelDeltaY;else if("wheelDelta"in e)t.deltaX=0,t.deltaY=-e.wheelDelta;else if("axis"in e)t.deltaX=e.axis===1?e.detail:0,t.deltaY=e.axis===2?e.detail:0;else if(e.targetTouches){var r=e.targetTouches[0];t.deltaX=E9.pageX-r.pageX,t.deltaY=E9.pageY-r.pageY}}return t}var Pm={properties:{opened:{observer:"_openedChanged",type:Boolean,value:!1,notify:!0},canceled:{observer:"_canceledChanged",readOnly:!0,type:Boolean,value:!1},withBackdrop:{observer:"_withBackdropChanged",type:Boolean},noAutoFocus:{type:Boolean,value:!1},noCancelOnEscKey:{type:Boolean,value:!1},noCancelOnOutsideClick:{type:Boolean,value:!1},closingReason:{type:Object},restoreFocusOnClose:{type:Boolean,value:!1},allowClickThrough:{type:Boolean},alwaysOnTop:{type:Boolean},scrollAction:{type:String},_manager:{type:Object,value:b0t},_focusedChild:{type:Object}},listeners:{"iron-resize":"_onIronResize"},observers:["__updateScrollObservers(isAttached, opened, scrollAction)"],get backdropElement(){return this._manager.backdropElement},get _focusNode(){return this._focusedChild||zt(this).querySelector("[autofocus]")||this},get _focusableNodes(){return x0t.getTabbableNodes(this)},ready:function(){this.__isAnimating=!1,this.__shouldRemoveTabIndex=!1,this.__firstFocusableNode=this.__lastFocusableNode=null,this.__rafs={},this.__restoreFocusNode=null,this.__scrollTop=this.__scrollLeft=null,this.__onCaptureScroll=this.__onCaptureScroll.bind(this),this.__rootNodes=null,this._ensureSetup()},attached:function(){this.opened&&this._openedChanged(this.opened),this._observer=zt(this).observeNodes(this._onNodesChange)},detached:function(){this._observer&&zt(this).unobserveNodes(this._observer),this._observer=null;for(var e in this.__rafs)this.__rafs[e]!==null&&cancelAnimationFrame(this.__rafs[e]);this.__rafs={},this._manager.removeOverlay(this),this.__isAnimating&&(this.opened?this._finishRenderOpened():(this._applyFocus(),this._finishRenderClosed()))},toggle:function(){this._setCanceled(!1),this.opened=!this.opened},open:function(){this._setCanceled(!1),this.opened=!0},close:function(){this._setCanceled(!1),this.opened=!1},cancel:function(e){var t=this.fire("iron-overlay-canceled",e,{cancelable:!0});t.defaultPrevented||(this._setCanceled(!0),this.opened=!1)},invalidateTabbables:function(){this.__firstFocusableNode=this.__lastFocusableNode=null},_ensureSetup:function(){this._overlaySetup||(this._overlaySetup=!0,this.style.outline="none",this.style.display="none")},_openedChanged:function(e){e?this.removeAttribute("aria-hidden"):this.setAttribute("aria-hidden","true"),this.isAttached&&(this.__isAnimating=!0,this.__deraf("__openedChanged",this.__openedChanged))},_canceledChanged:function(){this.closingReason=this.closingReason||{},this.closingReason.canceled=this.canceled},_withBackdropChanged:function(){this.withBackdrop&&!this.hasAttribute("tabindex")?(this.setAttribute("tabindex","-1"),this.__shouldRemoveTabIndex=!0):this.__shouldRemoveTabIndex&&(this.removeAttribute("tabindex"),this.__shouldRemoveTabIndex=!1),this.opened&&this.isAttached&&this._manager.trackBackdrop()},_prepareRenderOpened:function(){this.__restoreFocusNode=this._manager.deepActiveElement,this._preparePositioning(),this.refit(),this._finishPositioning(),this.noAutoFocus&&document.activeElement===this._focusNode&&(this._focusNode.blur(),this.__restoreFocusNode.focus())},_renderOpened:function(){this._finishRenderOpened()},_renderClosed:function(){this._finishRenderClosed()},_finishRenderOpened:function(){this.notifyResize(),this.__isAnimating=!1,this.fire("iron-overlay-opened")},_finishRenderClosed:function(){this.style.display="none",this.style.zIndex="",this.notifyResize(),this.__isAnimating=!1,this.fire("iron-overlay-closed",this.closingReason)},_preparePositioning:function(){this.style.transition=this.style.webkitTransition="none",this.style.transform=this.style.webkitTransform="none",this.style.display=""},_finishPositioning:function(){this.style.display="none",this.scrollTop=this.scrollTop,this.style.transition=this.style.webkitTransition="",this.style.transform=this.style.webkitTransform="",this.style.display="",this.scrollTop=this.scrollTop},_applyFocus:function(){if(this.opened)this.noAutoFocus||this._focusNode.focus();else{if(this.restoreFocusOnClose&&this.__restoreFocusNode){var e=this._manager.deepActiveElement;(e===document.body||Ube(this,e))&&this.__restoreFocusNode.focus()}this.__restoreFocusNode=null,this._focusNode.blur(),this._focusedChild=null}},_onCaptureClick:function(e){this.noCancelOnOutsideClick||this.cancel(e)},_onCaptureFocus:function(e){if(!!this.withBackdrop){var t=zt(e).path;t.indexOf(this)===-1?(e.stopPropagation(),this._applyFocus()):this._focusedChild=t[0]}},_onCaptureEsc:function(e){this.noCancelOnEscKey||this.cancel(e)},_onCaptureTab:function(e){if(!!this.withBackdrop){this.__ensureFirstLastFocusables();var t=e.shiftKey,r=t?this.__firstFocusableNode:this.__lastFocusableNode,n=t?this.__lastFocusableNode:this.__firstFocusableNode,i=!1;if(r===n)i=!0;else{var o=this._manager.deepActiveElement;i=o===r||o===this}i&&(e.preventDefault(),this._focusedChild=n,this._applyFocus())}},_onIronResize:function(){this.opened&&!this.__isAnimating&&this.__deraf("refit",this.refit)},_onNodesChange:function(){this.opened&&!this.__isAnimating&&(this.invalidateTabbables(),this.notifyResize())},__ensureFirstLastFocusables:function(){var e=this._focusableNodes;this.__firstFocusableNode=e[0],this.__lastFocusableNode=e[e.length-1]},__openedChanged:function(){this.opened?(this._prepareRenderOpened(),this._manager.addOverlay(this),this._applyFocus(),this._renderOpened()):(this._manager.removeOverlay(this),this._applyFocus(),this._renderClosed())},__deraf:function(e,t){var r=this.__rafs;r[e]!==null&&cancelAnimationFrame(r[e]),r[e]=requestAnimationFrame(function(){r[e]=null,t.call(this)}.bind(this))},__updateScrollObservers:function(e,t,r){!e||!t||!this.__isValidScrollAction(r)?(M0t(this),this.__removeScrollListeners()):(r==="lock"&&(this.__saveScrollPosition(),S0t(this)),this.__addScrollListeners())},__addScrollListeners:function(){if(!this.__rootNodes){if(this.__rootNodes=[],c_)for(var e=this;e;)e.nodeType===Node.DOCUMENT_FRAGMENT_NODE&&e.host&&this.__rootNodes.push(e),e=e.host||e.assignedSlot||e.parentNode;this.__rootNodes.push(document)}this.__rootNodes.forEach(function(t){t.addEventListener("scroll",this.__onCaptureScroll,{capture:!0,passive:!0})},this)},__removeScrollListeners:function(){this.__rootNodes&&this.__rootNodes.forEach(function(e){e.removeEventListener("scroll",this.__onCaptureScroll,{capture:!0,passive:!0})},this),this.isAttached||(this.__rootNodes=null)},__isValidScrollAction:function(e){return e==="lock"||e==="refit"||e==="cancel"},__onCaptureScroll:function(e){if(!this.__isAnimating&&!(zt(e).path.indexOf(this)>=0))switch(this.scrollAction){case"lock":this.__restoreScrollPosition();break;case"refit":this.__deraf("refit",this.refit);break;case"cancel":this.cancel(e);break}},__saveScrollPosition:function(){document.scrollingElement?(this.__scrollTop=document.scrollingElement.scrollTop,this.__scrollLeft=document.scrollingElement.scrollLeft):(this.__scrollTop=Math.max(document.documentElement.scrollTop,document.body.scrollTop),this.__scrollLeft=Math.max(document.documentElement.scrollLeft,document.body.scrollLeft))},__restoreScrollPosition:function(){document.scrollingElement?(document.scrollingElement.scrollTop=this.__scrollTop,document.scrollingElement.scrollLeft=this.__scrollLeft):(document.documentElement.scrollTop=document.body.scrollTop=this.__scrollTop,document.documentElement.scrollLeft=document.body.scrollLeft=this.__scrollLeft)}},Vbe=e=>e.assignedSlot||e.parentNode||e.host,Ube=(e,t)=>{for(let r=t;r;r=Vbe(r))if(r===e)return!0;return!1},Kx=[v0t,Js,Pm];var yW={hostAttributes:{role:"dialog",tabindex:"-1"},properties:{modal:{type:Boolean,value:!1},__readied:{type:Boolean,value:!1}},observers:["_modalChanged(modal, __readied)"],listeners:{tap:"_onDialogClick"},ready:function(){this.__prevNoCancelOnOutsideClick=this.noCancelOnOutsideClick,this.__prevNoCancelOnEscKey=this.noCancelOnEscKey,this.__prevWithBackdrop=this.withBackdrop,this.__readied=!0},_modalChanged:function(e,t){!t||(e?(this.__prevNoCancelOnOutsideClick=this.noCancelOnOutsideClick,this.__prevNoCancelOnEscKey=this.noCancelOnEscKey,this.__prevWithBackdrop=this.withBackdrop,this.noCancelOnOutsideClick=!0,this.noCancelOnEscKey=!0,this.withBackdrop=!0):(this.noCancelOnOutsideClick=this.noCancelOnOutsideClick&&this.__prevNoCancelOnOutsideClick,this.noCancelOnEscKey=this.noCancelOnEscKey&&this.__prevNoCancelOnEscKey,this.withBackdrop=this.withBackdrop&&this.__prevWithBackdrop))},_updateClosingReasonConfirmed:function(e){this.closingReason=this.closingReason||{},this.closingReason.confirmed=e},_onDialogClick:function(e){for(var t=zt(e).path,r=0,n=t.indexOf(this);r<n;r++){var i=t[r];if(i.hasAttribute&&(i.hasAttribute("dialog-dismiss")||i.hasAttribute("dialog-confirm"))){this._updateClosingReasonConfirmed(i.hasAttribute("dialog-confirm")),this.close(),e.stopPropagation();break}}}},C0t=[Kx,yW];Yt({_template:Q`
    <style include="paper-dialog-shared-styles"></style>
    <slot></slot>
`,is:"paper-dialog",behaviors:[C0t,b9],listeners:{"neon-animation-finish":"_onNeonAnimationFinish"},_renderOpened:function(){this.cancelAnimation(),this.playAnimation("entry")},_renderClosed:function(){this.cancelAnimation(),this.playAnimation("exit")},_onNeonAnimationFinish:function(){this.opened?this._finishRenderOpened():this._finishRenderClosed()}});Yt({_template:Q`
    <style>

      :host {
        display: block;
        @apply --layout-relative;
      }

      :host(.is-scrolled:not(:first-child))::before {
        content: '';
        position: absolute;
        top: 0;
        left: 0;
        right: 0;
        height: 1px;
        background: var(--divider-color);
      }

      :host(.can-scroll:not(.scrolled-to-bottom):not(:last-child))::after {
        content: '';
        position: absolute;
        bottom: 0;
        left: 0;
        right: 0;
        height: 1px;
        background: var(--divider-color);
      }

      .scrollable {
        padding: 0 24px;

        @apply --layout-scroll;
        @apply --paper-dialog-scrollable;
      }

      .fit {
        @apply --layout-fit;
      }
    </style>

    <div id="scrollable" class="scrollable" on-scroll="updateScrollState">
      <slot></slot>
    </div>
`,is:"paper-dialog-scrollable",properties:{dialogElement:{type:Object}},get scrollTarget(){return this.$.scrollable},ready:function(){this._ensureTarget(),this.classList.add("no-padding")},attached:function(){this._ensureTarget(),requestAnimationFrame(this.updateScrollState.bind(this))},updateScrollState:function(){this.toggleClass("is-scrolled",this.scrollTarget.scrollTop>0),this.toggleClass("can-scroll",this.scrollTarget.offsetHeight<this.scrollTarget.scrollHeight),this.toggleClass("scrolled-to-bottom",this.scrollTarget.scrollTop+this.scrollTarget.offsetHeight>=this.scrollTarget.scrollHeight)},_ensureTarget:function(){this.dialogElement=this.dialogElement||this.parentElement,this.dialogElement&&this.dialogElement.behaviors&&this.dialogElement.behaviors.indexOf(yW)>=0?(this.dialogElement.sizingTarget=this.scrollTarget,this.scrollTarget.classList.remove("fit")):this.dialogElement&&this.scrollTarget.classList.add("fit")}});var ec=Yt({_template:Q`
    <style>
      :host {
        display: inline-block;
        position: fixed;
        clip: rect(0px,0px,0px,0px);
      }
    </style>
    <div aria-live$="[[mode]]">[[_text]]</div>
`,is:"iron-a11y-announcer",properties:{mode:{type:String,value:"polite"},timeout:{type:Number,value:150},_text:{type:String,value:""}},created:function(){ec.instance||(ec.instance=this),document.addEventListener("iron-announce",this._onIronAnnounce.bind(this))},announce:function(e){this._text="",this.async(function(){this._text=e},this.timeout)},_onIronAnnounce:function(e){e.detail&&e.detail.text&&this.announce(e.detail.text)}});ec.instance=null;ec.requestAvailability=function(){ec.instance||(ec.instance=document.createElement("iron-a11y-announcer")),document.body?document.body.appendChild(ec.instance):document.addEventListener("load",function(){document.body.appendChild(ec.instance)})};Yt({_template:Q`
    <style>
      :host {
        display: inline-block;
      }
    </style>
    <slot id="content"></slot>
`,is:"iron-input",behaviors:[Th],properties:{bindValue:{type:String,value:""},value:{type:String,computed:"_computeValue(bindValue)"},allowedPattern:{type:String},autoValidate:{type:Boolean,value:!1},_inputElement:Object},observers:["_bindValueChanged(bindValue, _inputElement)"],listeners:{input:"_onInput",keypress:"_onKeypress"},created:function(){ec.requestAvailability(),this._previousValidInput="",this._patternAlreadyChecked=!1},attached:function(){this._observer=zt(this).observeNodes(function(e){this._initSlottedInput()}.bind(this))},detached:function(){this._observer&&(zt(this).unobserveNodes(this._observer),this._observer=null)},get inputElement(){return this._inputElement},_initSlottedInput:function(){this._inputElement=this.getEffectiveChildren()[0],this.inputElement&&this.inputElement.value&&(this.bindValue=this.inputElement.value),this.fire("iron-input-ready")},get _patternRegExp(){var e;if(this.allowedPattern)e=new RegExp(this.allowedPattern);else switch(this.inputElement.type){case"number":e=/[0-9.,e-]/;break}return e},_bindValueChanged:function(e,t){!t||(e===void 0?t.value=null:e!==t.value&&(this.inputElement.value=e),this.autoValidate&&this.validate(),this.fire("bind-value-changed",{value:e}))},_onInput:function(){if(this.allowedPattern&&!this._patternAlreadyChecked){var e=this._checkPatternValidity();e||(this._announceInvalidCharacter("Invalid string of characters not entered."),this.inputElement.value=this._previousValidInput)}this.bindValue=this._previousValidInput=this.inputElement.value,this._patternAlreadyChecked=!1},_isPrintable:function(e){var t=e.keyCode==8||e.keyCode==9||e.keyCode==13||e.keyCode==27,r=e.keyCode==19||e.keyCode==20||e.keyCode==45||e.keyCode==46||e.keyCode==144||e.keyCode==145||e.keyCode>32&&e.keyCode<41||e.keyCode>111&&e.keyCode<124;return!t&&!(e.charCode==0&&r)},_onKeypress:function(e){if(!(!this.allowedPattern&&this.inputElement.type!=="number")){var t=this._patternRegExp;if(!!t&&!(e.metaKey||e.ctrlKey||e.altKey)){this._patternAlreadyChecked=!0;var r=String.fromCharCode(e.charCode);this._isPrintable(e)&&!t.test(r)&&(e.preventDefault(),this._announceInvalidCharacter("Invalid character "+r+" not entered."))}}},_checkPatternValidity:function(){var e=this._patternRegExp;if(!e)return!0;for(var t=0;t<this.inputElement.value.length;t++)if(!e.test(this.inputElement.value[t]))return!1;return!0},validate:function(){if(!this.inputElement)return this.invalid=!1,!0;var e=this.inputElement.checkValidity();return e&&(this.required&&this.bindValue===""?e=!1:this.hasValidator()&&(e=Th.validate.call(this,this.bindValue))),this.invalid=!e,this.fire("iron-input-validate"),e},_announceInvalidCharacter:function(e){this.fire("iron-announce",{text:e})},_computeValue:function(e){return e}});var C9={attached:function(){this.fire("addon-attached")},update:function(e){}};Yt({_template:Q`
    <style>
      :host {
        display: inline-block;
        float: right;

        @apply --paper-font-caption;
        @apply --paper-input-char-counter;
      }

      :host([hidden]) {
        display: none !important;
      }

      :host(:dir(rtl)) {
        float: left;
      }
    </style>

    <span>[[_charCounterStr]]</span>
`,is:"paper-input-char-counter",behaviors:[C9],properties:{_charCounterStr:{type:String,value:"0"}},update:function(e){if(!!e.inputElement){e.value=e.value||"";var t=e.value.toString().length.toString();e.inputElement.hasAttribute("maxlength")&&(t+="/"+e.inputElement.getAttribute("maxlength")),this._charCounterStr=t}}});var A0t=Q`
<custom-style>
  <style is="custom-style">
    html {
      --paper-input-container-shared-input-style: {
        position: relative; /* to make a stacking context */
        outline: none;
        box-shadow: none;
        padding: 0;
        margin: 0;
        width: 100%;
        max-width: 100%;
        background: transparent;
        border: none;
        color: var(--paper-input-container-input-color, var(--primary-text-color));
        -webkit-appearance: none;
        text-align: inherit;
        vertical-align: var(--paper-input-container-input-align, bottom);

        @apply --paper-font-subhead;
      };
    }
  </style>
</custom-style>
`;A0t.setAttribute("style","display: none;");document.head.appendChild(A0t.content);Yt({_template:Q`
    <style>
      :host {
        display: block;
        padding: 8px 0;
        @apply --paper-input-container;
      }

      :host([inline]) {
        display: inline-block;
      }

      :host([disabled]) {
        pointer-events: none;
        opacity: 0.33;

        @apply --paper-input-container-disabled;
      }

      :host([hidden]) {
        display: none !important;
      }

      [hidden] {
        display: none !important;
      }

      .floated-label-placeholder {
        @apply --paper-font-caption;
      }

      .underline {
        height: 2px;
        position: relative;
      }

      .focused-line {
        @apply --layout-fit;
        border-bottom: 2px solid var(--paper-input-container-focus-color, var(--primary-color));

        -webkit-transform-origin: center center;
        transform-origin: center center;
        -webkit-transform: scale3d(0,1,1);
        transform: scale3d(0,1,1);

        @apply --paper-input-container-underline-focus;
      }

      .underline.is-highlighted .focused-line {
        -webkit-transform: none;
        transform: none;
        -webkit-transition: -webkit-transform 0.25s;
        transition: transform 0.25s;

        @apply --paper-transition-easing;
      }

      .underline.is-invalid .focused-line {
        border-color: var(--paper-input-container-invalid-color, var(--error-color));
        -webkit-transform: none;
        transform: none;
        -webkit-transition: -webkit-transform 0.25s;
        transition: transform 0.25s;

        @apply --paper-transition-easing;
      }

      .unfocused-line {
        @apply --layout-fit;
        border-bottom: 1px solid var(--paper-input-container-color, var(--secondary-text-color));
        @apply --paper-input-container-underline;
      }

      :host([disabled]) .unfocused-line {
        border-bottom: 1px dashed;
        border-color: var(--paper-input-container-color, var(--secondary-text-color));
        @apply --paper-input-container-underline-disabled;
      }

      .input-wrapper {
        @apply --layout-horizontal;
        @apply --layout-center;
        position: relative;
      }

      .input-content {
        @apply --layout-flex-auto;
        @apply --layout-relative;
        max-width: 100%;
      }

      .input-content ::slotted(label),
      .input-content ::slotted(.paper-input-label) {
        position: absolute;
        top: 0;
        left: 0;
        width: 100%;
        font: inherit;
        color: var(--paper-input-container-color, var(--secondary-text-color));
        -webkit-transition: -webkit-transform 0.25s, width 0.25s;
        transition: transform 0.25s, width 0.25s;
        -webkit-transform-origin: left top;
        transform-origin: left top;
        /* Fix for safari not focusing 0-height date/time inputs with -webkit-apperance: none; */
        min-height: 1px;

        @apply --paper-font-common-nowrap;
        @apply --paper-font-subhead;
        @apply --paper-input-container-label;
        @apply --paper-transition-easing;
      }


      .input-content ::slotted(label):before,
      .input-content ::slotted(.paper-input-label):before {
        @apply --paper-input-container-label-before;
      }

      .input-content ::slotted(label):after,
      .input-content ::slotted(.paper-input-label):after {
        @apply --paper-input-container-label-after;
      }

      .input-content.label-is-floating ::slotted(label),
      .input-content.label-is-floating ::slotted(.paper-input-label) {
        -webkit-transform: translateY(-75%) scale(0.75);
        transform: translateY(-75%) scale(0.75);

        /* Since we scale to 75/100 of the size, we actually have 100/75 of the
        original space now available */
        width: 133%;

        @apply --paper-input-container-label-floating;
      }

      :host(:dir(rtl)) .input-content.label-is-floating ::slotted(label),
      :host(:dir(rtl)) .input-content.label-is-floating ::slotted(.paper-input-label) {
        right: 0;
        left: auto;
        -webkit-transform-origin: right top;
        transform-origin: right top;
      }

      .input-content.label-is-highlighted ::slotted(label),
      .input-content.label-is-highlighted ::slotted(.paper-input-label) {
        color: var(--paper-input-container-focus-color, var(--primary-color));

        @apply --paper-input-container-label-focus;
      }

      .input-content.is-invalid ::slotted(label),
      .input-content.is-invalid ::slotted(.paper-input-label) {
        color: var(--paper-input-container-invalid-color, var(--error-color));
      }

      .input-content.label-is-hidden ::slotted(label),
      .input-content.label-is-hidden ::slotted(.paper-input-label) {
        visibility: hidden;
      }

      .input-content ::slotted(input),
      .input-content ::slotted(iron-input),
      .input-content ::slotted(textarea),
      .input-content ::slotted(iron-autogrow-textarea),
      .input-content ::slotted(.paper-input-input) {
        @apply --paper-input-container-shared-input-style;
        /* The apply shim doesn't apply the nested color custom property,
          so we have to re-apply it here. */
        color: var(--paper-input-container-input-color, var(--primary-text-color));
        @apply --paper-input-container-input;
      }

      .input-content ::slotted(input)::-webkit-outer-spin-button,
      .input-content ::slotted(input)::-webkit-inner-spin-button {
        @apply --paper-input-container-input-webkit-spinner;
      }

      .input-content.focused ::slotted(input),
      .input-content.focused ::slotted(iron-input),
      .input-content.focused ::slotted(textarea),
      .input-content.focused ::slotted(iron-autogrow-textarea),
      .input-content.focused ::slotted(.paper-input-input) {
        @apply --paper-input-container-input-focus;
      }

      .input-content.is-invalid ::slotted(input),
      .input-content.is-invalid ::slotted(iron-input),
      .input-content.is-invalid ::slotted(textarea),
      .input-content.is-invalid ::slotted(iron-autogrow-textarea),
      .input-content.is-invalid ::slotted(.paper-input-input) {
        @apply --paper-input-container-input-invalid;
      }

      .prefix ::slotted(*) {
        display: inline-block;
        @apply --paper-font-subhead;
        @apply --layout-flex-none;
        @apply --paper-input-prefix;
      }

      .suffix ::slotted(*) {
        display: inline-block;
        @apply --paper-font-subhead;
        @apply --layout-flex-none;

        @apply --paper-input-suffix;
      }

      /* Firefox sets a min-width on the input, which can cause layout issues */
      .input-content ::slotted(input) {
        min-width: 0;
      }

      .input-content ::slotted(textarea) {
        resize: none;
      }

      .add-on-content {
        position: relative;
      }

      .add-on-content.is-invalid ::slotted(*) {
        color: var(--paper-input-container-invalid-color, var(--error-color));
      }

      .add-on-content.is-highlighted ::slotted(*) {
        color: var(--paper-input-container-focus-color, var(--primary-color));
      }
    </style>

    <div class="floated-label-placeholder" aria-hidden="true" hidden="[[noLabelFloat]]">&nbsp;</div>

    <div class="input-wrapper">
      <span class="prefix"><slot name="prefix"></slot></span>

      <div class$="[[_computeInputContentClass(noLabelFloat,alwaysFloatLabel,focused,invalid,_inputHasContent)]]" id="labelAndInputContainer">
        <slot name="label"></slot>
        <slot name="input"></slot>
      </div>

      <span class="suffix"><slot name="suffix"></slot></span>
    </div>

    <div class$="[[_computeUnderlineClass(focused,invalid)]]">
      <div class="unfocused-line"></div>
      <div class="focused-line"></div>
    </div>

    <div class$="[[_computeAddOnContentClass(focused,invalid)]]">
      <slot name="add-on"></slot>
    </div>
`,is:"paper-input-container",properties:{noLabelFloat:{type:Boolean,value:!1},alwaysFloatLabel:{type:Boolean,value:!1},attrForValue:{type:String,value:"bind-value"},autoValidate:{type:Boolean,value:!1},invalid:{observer:"_invalidChanged",type:Boolean,value:!1},focused:{readOnly:!0,type:Boolean,value:!1,notify:!0},_addons:{type:Array},_inputHasContent:{type:Boolean,value:!1},_inputSelector:{type:String,value:"input,iron-input,textarea,.paper-input-input"},_boundOnFocus:{type:Function,value:function(){return this._onFocus.bind(this)}},_boundOnBlur:{type:Function,value:function(){return this._onBlur.bind(this)}},_boundOnInput:{type:Function,value:function(){return this._onInput.bind(this)}},_boundValueChanged:{type:Function,value:function(){return this._onValueChanged.bind(this)}}},listeners:{"addon-attached":"_onAddonAttached","iron-input-validate":"_onIronInputValidate"},get _valueChangedEvent(){return this.attrForValue+"-changed"},get _propertyForValue(){return wm(this.attrForValue)},get _inputElement(){return zt(this).querySelector(this._inputSelector)},get _inputElementValue(){return this._inputElement[this._propertyForValue]||this._inputElement.value},ready:function(){this.__isFirstValueUpdate=!0,this._addons||(this._addons=[]),this.addEventListener("focus",this._boundOnFocus,!0),this.addEventListener("blur",this._boundOnBlur,!0)},attached:function(){this.attrForValue?this._inputElement.addEventListener(this._valueChangedEvent,this._boundValueChanged):this.addEventListener("input",this._onInput),this._inputElementValue&&this._inputElementValue!=""?this._handleValueAndAutoValidate(this._inputElement):this._handleValue(this._inputElement)},_onAddonAttached:function(e){this._addons||(this._addons=[]);var t=e.target;this._addons.indexOf(t)===-1&&(this._addons.push(t),this.isAttached&&this._handleValue(this._inputElement))},_onFocus:function(){this._setFocused(!0)},_onBlur:function(){this._setFocused(!1),this._handleValueAndAutoValidate(this._inputElement)},_onInput:function(e){this._handleValueAndAutoValidate(e.target)},_onValueChanged:function(e){var t=e.target;this.__isFirstValueUpdate&&(this.__isFirstValueUpdate=!1,t.value===void 0||t.value==="")||this._handleValueAndAutoValidate(e.target)},_handleValue:function(e){var t=this._inputElementValue;t||t===0||e.type==="number"&&!e.checkValidity()?this._inputHasContent=!0:this._inputHasContent=!1,this.updateAddons({inputElement:e,value:t,invalid:this.invalid})},_handleValueAndAutoValidate:function(e){if(this.autoValidate&&e){var t;e.validate?t=e.validate(this._inputElementValue):t=e.checkValidity(),this.invalid=!t}this._handleValue(e)},_onIronInputValidate:function(e){this.invalid=this._inputElement.invalid},_invalidChanged:function(){this._addons&&this.updateAddons({invalid:this.invalid})},updateAddons:function(e){for(var t,r=0;t=this._addons[r];r++)t.update(e)},_computeInputContentClass:function(e,t,r,n,i){var o="input-content";if(e)i&&(o+=" label-is-hidden"),n&&(o+=" is-invalid");else{var a=this.querySelector("label");t||i?(o+=" label-is-floating",this.$.labelAndInputContainer.style.position="static",n?o+=" is-invalid":r&&(o+=" label-is-highlighted")):(a&&(this.$.labelAndInputContainer.style.position="relative"),n&&(o+=" is-invalid"))}return r&&(o+=" focused"),o},_computeUnderlineClass:function(e,t){var r="underline";return t?r+=" is-invalid":e&&(r+=" is-highlighted"),r},_computeAddOnContentClass:function(e,t){var r="add-on-content";return t?r+=" is-invalid":e&&(r+=" is-highlighted"),r}});Yt({_template:Q`
    <style>
      :host {
        display: inline-block;
        visibility: hidden;

        color: var(--paper-input-container-invalid-color, var(--error-color));

        @apply --paper-font-caption;
        @apply --paper-input-error;
        position: absolute;
        left:0;
        right:0;
      }

      :host([invalid]) {
        visibility: visible;
      }

      #a11yWrapper {
        visibility: hidden;
      }

      :host([invalid]) #a11yWrapper {
        visibility: visible;
      }
    </style>

    <!--
    If the paper-input-error element is directly referenced by an
    \`aria-describedby\` attribute, such as when used as a paper-input add-on,
    then applying \`visibility: hidden;\` to the paper-input-error element itself
    does not hide the error.

    For more information, see:
    https://www.w3.org/TR/accname-1.1/#mapping_additional_nd_description
    -->
    <div id="a11yWrapper">
      <slot></slot>
    </div>
`,is:"paper-input-error",behaviors:[C9],properties:{invalid:{readOnly:!0,reflectToAttribute:!0,type:Boolean}},update:function(e){this._setInvalid(e.invalid)}});var Zx={};Zx.NextLabelID=1;Zx.NextAddonID=1;Zx.NextInputID=1;var qbe={properties:{label:{type:String},value:{notify:!0,type:String},disabled:{type:Boolean,value:!1},invalid:{type:Boolean,value:!1,notify:!0},allowedPattern:{type:String},type:{type:String},list:{type:String},pattern:{type:String},required:{type:Boolean,value:!1},errorMessage:{type:String},charCounter:{type:Boolean,value:!1},noLabelFloat:{type:Boolean,value:!1},alwaysFloatLabel:{type:Boolean,value:!1},autoValidate:{type:Boolean,value:!1},validator:{type:String},autocomplete:{type:String,value:"off"},autofocus:{type:Boolean,observer:"_autofocusChanged"},inputmode:{type:String},minlength:{type:Number},maxlength:{type:Number},min:{type:String},max:{type:String},step:{type:String},name:{type:String},placeholder:{type:String,value:""},readonly:{type:Boolean,value:!1},size:{type:Number},autocapitalize:{type:String,value:"none"},autocorrect:{type:String,value:"off"},autosave:{type:String},results:{type:Number},accept:{type:String},multiple:{type:Boolean},_ariaDescribedBy:{type:String,value:""},_ariaLabelledBy:{type:String,value:""},_inputId:{type:String,value:""}},listeners:{"addon-attached":"_onAddonAttached"},keyBindings:{"shift+tab:keydown":"_onShiftTabDown"},hostAttributes:{tabindex:0},get inputElement(){return this.$||(this.$={}),this.$.input||(this._generateInputId(),this.$.input=this.$$("#"+this._inputId)),this.$.input},get _focusableElement(){return this.inputElement},created:function(){this._typesThatHaveText=["date","datetime","datetime-local","month","time","week","file"]},attached:function(){this._updateAriaLabelledBy(),!mt&&this.inputElement&&this._typesThatHaveText.indexOf(this.inputElement.type)!==-1&&(this.alwaysFloatLabel=!0)},_appendStringWithSpace:function(e,t){return e?e=e+" "+t:e=t,e},_onAddonAttached:function(e){var t=zt(e).rootTarget;if(t.id)this._ariaDescribedBy=this._appendStringWithSpace(this._ariaDescribedBy,t.id);else{var r="paper-input-add-on-"+Zx.NextAddonID++;t.id=r,this._ariaDescribedBy=this._appendStringWithSpace(this._ariaDescribedBy,r)}},validate:function(){return this.inputElement.validate()},_focusBlurHandler:function(e){Di._focusBlurHandler.call(this,e),this.focused&&!this._shiftTabPressed&&this._focusableElement&&this._focusableElement.focus()},_onShiftTabDown:function(e){var t=this.getAttribute("tabindex");this._shiftTabPressed=!0,this.setAttribute("tabindex","-1"),this.async(function(){this.setAttribute("tabindex",t),this._shiftTabPressed=!1},1)},_handleAutoValidate:function(){this.autoValidate&&this.validate()},updateValueAndPreserveCaret:function(e){try{var t=this.inputElement.selectionStart;this.value=e,this.inputElement.selectionStart=t,this.inputElement.selectionEnd=t}catch(r){this.value=e}},_computeAlwaysFloatLabel:function(e,t){return t||e},_updateAriaLabelledBy:function(){var e=zt(this.root).querySelector("label");if(!e){this._ariaLabelledBy="";return}var t;e.id?t=e.id:(t="paper-input-label-"+Zx.NextLabelID++,e.id=t),this._ariaLabelledBy=t},_generateInputId:function(){(!this._inputId||this._inputId==="")&&(this._inputId="input-"+Zx.NextInputID++)},_onChange:function(e){this.shadowRoot&&this.fire(e.type,{sourceEvent:e},{node:this,bubbles:e.bubbles,cancelable:e.cancelable})},_autofocusChanged:function(){if(this.autofocus&&this._focusableElement){var e=document.activeElement,t=e instanceof HTMLElement,r=t&&e!==document.body&&e!==document.documentElement;r||this._focusableElement.focus()}}},A9=[Di,Oo,qbe];Yt({is:"paper-input",_template:Q`
    <style>
      :host {
        display: block;
      }

      :host([focused]) {
        outline: none;
      }

      :host([hidden]) {
        display: none !important;
      }

      input {
        /* Firefox sets a min-width on the input, which can cause layout issues */
        min-width: 0;
      }

      /* In 1.x, the <input> is distributed to paper-input-container, which styles it.
      In 2.x the <iron-input> is distributed to paper-input-container, which styles
      it, but in order for this to work correctly, we need to reset some
      of the native input's properties to inherit (from the iron-input) */
      iron-input > input {
        @apply --paper-input-container-shared-input-style;
        font-family: inherit;
        font-weight: inherit;
        font-size: inherit;
        letter-spacing: inherit;
        word-spacing: inherit;
        line-height: inherit;
        text-shadow: inherit;
        color: inherit;
        cursor: inherit;
      }

      input:disabled {
        @apply --paper-input-container-input-disabled;
      }

      input::-webkit-outer-spin-button,
      input::-webkit-inner-spin-button {
        @apply --paper-input-container-input-webkit-spinner;
      }

      input::-webkit-clear-button {
        @apply --paper-input-container-input-webkit-clear;
      }

      input::-webkit-calendar-picker-indicator {
        @apply --paper-input-container-input-webkit-calendar-picker-indicator;
      }

      input::-webkit-input-placeholder {
        color: var(--paper-input-container-color, var(--secondary-text-color));
      }

      input:-moz-placeholder {
        color: var(--paper-input-container-color, var(--secondary-text-color));
      }

      input::-moz-placeholder {
        color: var(--paper-input-container-color, var(--secondary-text-color));
      }

      input::-ms-clear {
        @apply --paper-input-container-ms-clear;
      }

      input::-ms-reveal {
        @apply --paper-input-container-ms-reveal;
      }

      input:-ms-input-placeholder {
        color: var(--paper-input-container-color, var(--secondary-text-color));
      }

      label {
        pointer-events: none;
      }
    </style>

    <paper-input-container id="container" no-label-float="[[noLabelFloat]]" always-float-label="[[_computeAlwaysFloatLabel(alwaysFloatLabel,placeholder)]]" auto-validate$="[[autoValidate]]" disabled$="[[disabled]]" invalid="[[invalid]]">

      <slot name="prefix" slot="prefix"></slot>

      <label hidden$="[[!label]]" aria-hidden="true" for$="[[_inputId]]" slot="label">[[label]]</label>

      <!-- Need to bind maxlength so that the paper-input-char-counter works correctly -->
      <iron-input bind-value="{{value}}" slot="input" class="input-element" id$="[[_inputId]]" maxlength$="[[maxlength]]" allowed-pattern="[[allowedPattern]]" invalid="{{invalid}}" validator="[[validator]]">
        <input aria-labelledby$="[[_ariaLabelledBy]]" aria-describedby$="[[_ariaDescribedBy]]" disabled$="[[disabled]]" title$="[[title]]" type$="[[type]]" pattern$="[[pattern]]" required$="[[required]]" autocomplete$="[[autocomplete]]" autofocus$="[[autofocus]]" inputmode$="[[inputmode]]" minlength$="[[minlength]]" maxlength$="[[maxlength]]" min$="[[min]]" max$="[[max]]" step$="[[step]]" name$="[[name]]" placeholder$="[[placeholder]]" readonly$="[[readonly]]" list$="[[list]]" size$="[[size]]" autocapitalize$="[[autocapitalize]]" autocorrect$="[[autocorrect]]" on-change="_onChange" tabindex$="[[tabIndex]]" autosave$="[[autosave]]" results$="[[results]]" accept$="[[accept]]" multiple$="[[multiple]]" role$="[[inputRole]]" aria-haspopup$="[[inputAriaHaspopup]]">
      </iron-input>

      <slot name="suffix" slot="suffix"></slot>

      <template is="dom-if" if="[[errorMessage]]">
        <paper-input-error aria-live="assertive" slot="add-on">[[errorMessage]]</paper-input-error>
      </template>

      <template is="dom-if" if="[[charCounter]]">
        <paper-input-char-counter slot="add-on"></paper-input-char-counter>
      </template>

    </paper-input-container>
  `,behaviors:[A9,Eh],properties:{value:{type:String},inputRole:{type:String,value:void 0},inputAriaHaspopup:{type:String,value:void 0}},get _focusableElement(){return this.inputElement._inputElement},listeners:{"iron-input-ready":"_onIronInputReady"},_onIronInputReady:function(){this.$.nativeInput||(this.$.nativeInput=this.$$("input")),this.inputElement&&this._typesThatHaveText.indexOf(this.$.nativeInput.type)!==-1&&(this.alwaysFloatLabel=!0),this.inputElement.bindValue&&this.$.container._handleValueAndAutoValidate(this.inputElement)}});Yt({_template:Q`
    <style>
      :host {
        position: fixed;
      }

      #contentWrapper ::slotted(*) {
        overflow: auto;
      }

      #contentWrapper.animating ::slotted(*) {
        overflow: hidden;
        pointer-events: none;
      }
    </style>

    <div id="contentWrapper">
      <slot id="content" name="dropdown-content"></slot>
    </div>
`,is:"iron-dropdown",behaviors:[Di,Oo,Kx,b9],properties:{horizontalAlign:{type:String,value:"left",reflectToAttribute:!0},verticalAlign:{type:String,value:"top",reflectToAttribute:!0},openAnimationConfig:{type:Object},closeAnimationConfig:{type:Object},focusTarget:{type:Object},noAnimations:{type:Boolean,value:!1},allowOutsideScroll:{type:Boolean,value:!1,observer:"_allowOutsideScrollChanged"}},listeners:{"neon-animation-finish":"_onNeonAnimationFinish"},observers:["_updateOverlayPosition(positionTarget, verticalAlign, horizontalAlign, verticalOffset, horizontalOffset)"],get containedElement(){for(var e=zt(this.$.content).getDistributedNodes(),t=0,r=e.length;t<r;t++)if(e[t].nodeType===Node.ELEMENT_NODE)return e[t]},ready:function(){this.scrollAction||(this.scrollAction=this.allowOutsideScroll?"refit":"lock"),this._readied=!0},attached:function(){(!this.sizingTarget||this.sizingTarget===this)&&(this.sizingTarget=this.containedElement||this)},detached:function(){this.cancelAnimation()},_openedChanged:function(){this.opened&&this.disabled?this.cancel():(this.cancelAnimation(),this._updateAnimationConfig(),Pm._openedChanged.apply(this,arguments))},_renderOpened:function(){!this.noAnimations&&this.animationConfig.open?(this.$.contentWrapper.classList.add("animating"),this.playAnimation("open")):Pm._renderOpened.apply(this,arguments)},_renderClosed:function(){!this.noAnimations&&this.animationConfig.close?(this.$.contentWrapper.classList.add("animating"),this.playAnimation("close")):Pm._renderClosed.apply(this,arguments)},_onNeonAnimationFinish:function(){this.$.contentWrapper.classList.remove("animating"),this.opened?this._finishRenderOpened():this._finishRenderClosed()},_updateAnimationConfig:function(){for(var e=this.containedElement,t=[].concat(this.openAnimationConfig||[]).concat(this.closeAnimationConfig||[]),r=0;r<t.length;r++)t[r].node=e;this.animationConfig={open:this.openAnimationConfig,close:this.closeAnimationConfig}},_updateOverlayPosition:function(){this.isAttached&&this.notifyResize()},_allowOutsideScrollChanged:function(e){!this._readied||(e?(!this.scrollAction||this.scrollAction==="lock")&&(this.scrollAction="refit"):this.scrollAction="lock")},_applyFocus:function(){var e=this.focusTarget||this.containedElement;e&&this.opened&&!this.noAutoFocus?e.focus():Pm._applyFocus.apply(this,arguments)}});var yp={properties:{animationTiming:{type:Object,value:function(){return{duration:500,easing:"cubic-bezier(0.4, 0, 0.2, 1)",fill:"both"}}}},isNeonAnimation:!0,created:function(){document.body.animate||console.warn("No web animations detected. This element will not function without a web animations polyfill.")},timingFromConfig:function(e){if(e.timing)for(var t in e.timing)this.animationTiming[t]=e.timing[t];return this.animationTiming},setPrefixedProperty:function(e,t,r){for(var n={transform:["webkitTransform"],transformOrigin:["mozTransformOrigin","webkitTransformOrigin"]},i=n[t],o,a=0;o=i[a];a++)e.style[o]=r;e.style[t]=r},complete:function(e){}};Yt({is:"fade-in-animation",behaviors:[yp],configure:function(e){var t=e.node;return this._effect=new KeyframeEffect(t,[{opacity:"0"},{opacity:"1"}],this.timingFromConfig(e)),this._effect}});Yt({is:"fade-out-animation",behaviors:[yp],configure:function(e){var t=e.node;return this._effect=new KeyframeEffect(t,[{opacity:"1"},{opacity:"0"}],this.timingFromConfig(e)),this._effect}});Yt({is:"paper-menu-grow-height-animation",_template:null,behaviors:[yp],configure:function(e){var t=e.node,r=t.getBoundingClientRect(),n=r.height;return this._effect=new KeyframeEffect(t,[{height:n/2+"px"},{height:n+"px"}],this.timingFromConfig(e)),this._effect}});Yt({is:"paper-menu-grow-width-animation",_template:null,behaviors:[yp],configure:function(e){var t=e.node,r=t.getBoundingClientRect(),n=r.width;return this._effect=new KeyframeEffect(t,[{width:n/2+"px"},{width:n+"px"}],this.timingFromConfig(e)),this._effect}});Yt({is:"paper-menu-shrink-width-animation",_template:null,behaviors:[yp],configure:function(e){var t=e.node,r=t.getBoundingClientRect(),n=r.width;return this._effect=new KeyframeEffect(t,[{width:n+"px"},{width:n-n/20+"px"}],this.timingFromConfig(e)),this._effect}});Yt({is:"paper-menu-shrink-height-animation",_template:null,behaviors:[yp],configure:function(e){var t=e.node,r=t.getBoundingClientRect(),n=r.height;return this.setPrefixedProperty(t,"transformOrigin","0 0"),this._effect=new KeyframeEffect(t,[{height:n+"px",transform:"translateY(0)"},{height:n/2+"px",transform:"translateY(-20px)"}],this.timingFromConfig(e)),this._effect}});var dE={ANIMATION_CUBIC_BEZIER:"cubic-bezier(.3,.95,.5,1)",MAX_ANIMATION_TIME_MS:400},Gbe=Yt({_template:Q`
    <style>
      :host {
        display: inline-block;
        position: relative;
        padding: 8px;
        outline: none;

        @apply --paper-menu-button;
      }

      :host([disabled]) {
        cursor: auto;
        color: var(--disabled-text-color);

        @apply --paper-menu-button-disabled;
      }

      iron-dropdown {
        @apply --paper-menu-button-dropdown;
      }

      .dropdown-content {
        @apply --shadow-elevation-2dp;

        position: relative;
        border-radius: 2px;
        background-color: var(--paper-menu-button-dropdown-background, var(--primary-background-color));

        @apply --paper-menu-button-content;
      }

      :host([vertical-align="top"]) .dropdown-content {
        margin-bottom: 20px;
        margin-top: -10px;
        top: 10px;
      }

      :host([vertical-align="bottom"]) .dropdown-content {
        bottom: 10px;
        margin-bottom: -10px;
        margin-top: 20px;
      }

      #trigger {
        cursor: pointer;
      }
    </style>

    <div id="trigger" on-tap="toggle">
      <slot name="dropdown-trigger"></slot>
    </div>

    <iron-dropdown id="dropdown" opened="{{opened}}" horizontal-align="[[horizontalAlign]]" vertical-align="[[verticalAlign]]" dynamic-align="[[dynamicAlign]]" horizontal-offset="[[horizontalOffset]]" vertical-offset="[[verticalOffset]]" no-overlap="[[noOverlap]]" open-animation-config="[[openAnimationConfig]]" close-animation-config="[[closeAnimationConfig]]" no-animations="[[noAnimations]]" focus-target="[[_dropdownContent]]" allow-outside-scroll="[[allowOutsideScroll]]" restore-focus-on-close="[[restoreFocusOnClose]]" on-iron-overlay-canceled="__onIronOverlayCanceled" expand-sizing-target-for-scrollbars="[[expandSizingTargetForScrollbars]]">
      <div slot="dropdown-content" class="dropdown-content">
        <slot id="content" name="dropdown-content"></slot>
      </div>
    </iron-dropdown>
`,is:"paper-menu-button",behaviors:[Oo,Di],properties:{opened:{type:Boolean,value:!1,notify:!0,observer:"_openedChanged"},horizontalAlign:{type:String,value:"left",reflectToAttribute:!0},verticalAlign:{type:String,value:"top",reflectToAttribute:!0},dynamicAlign:{type:Boolean},horizontalOffset:{type:Number,value:0,notify:!0},verticalOffset:{type:Number,value:0,notify:!0},noOverlap:{type:Boolean},noAnimations:{type:Boolean,value:!1},ignoreSelect:{type:Boolean,value:!1},closeOnActivate:{type:Boolean,value:!1},openAnimationConfig:{type:Object,value:function(){return[{name:"fade-in-animation",timing:{delay:100,duration:200}},{name:"paper-menu-grow-width-animation",timing:{delay:100,duration:150,easing:dE.ANIMATION_CUBIC_BEZIER}},{name:"paper-menu-grow-height-animation",timing:{delay:100,duration:275,easing:dE.ANIMATION_CUBIC_BEZIER}}]}},closeAnimationConfig:{type:Object,value:function(){return[{name:"fade-out-animation",timing:{duration:150}},{name:"paper-menu-shrink-width-animation",timing:{delay:100,duration:50,easing:dE.ANIMATION_CUBIC_BEZIER}},{name:"paper-menu-shrink-height-animation",timing:{duration:200,easing:"ease-in"}}]}},allowOutsideScroll:{type:Boolean,value:!1},restoreFocusOnClose:{type:Boolean,value:!0},expandSizingTargetForScrollbars:{type:Boolean,value:!1},_dropdownContent:{type:Object}},hostAttributes:{role:"group","aria-haspopup":"true"},listeners:{"iron-activate":"_onIronActivate","iron-select":"_onIronSelect"},get contentElement(){for(var e=zt(this.$.content).getDistributedNodes(),t=0,r=e.length;t<r;t++)if(e[t].nodeType===Node.ELEMENT_NODE)return e[t]},toggle:function(){this.opened?this.close():this.open()},open:function(){this.disabled||this.$.dropdown.open()},close:function(){this.$.dropdown.close()},_onIronSelect:function(e){this.ignoreSelect||this.close()},_onIronActivate:function(e){this.closeOnActivate&&this.close()},_openedChanged:function(e,t){e?(this._dropdownContent=this.contentElement,this.fire("paper-dropdown-open")):t!=null&&this.fire("paper-dropdown-close")},_disabledChanged:function(e){Di._disabledChanged.apply(this,arguments),e&&this.opened&&this.close()},__onIronOverlayCanceled:function(e){var t=e.detail,r=this.$.trigger,n=zt(t).path;n.indexOf(r)>-1&&e.preventDefault()}});Object.keys(dE).forEach(function(e){Gbe[e]=dE[e]});var vW=document.createElement("template");vW.setAttribute("style","display: none;");vW.innerHTML=`<iron-iconset-svg name="paper-dropdown-menu" size="24">
<svg><defs>
<g id="arrow-drop-down"><path d="M7 10l5 5 5-5z"></path></g>
</defs></svg>
</iron-iconset-svg>`;document.head.appendChild(vW.content);var xW=document.createElement("template");xW.setAttribute("style","display: none;");xW.innerHTML=`<dom-module id="paper-dropdown-menu-shared-styles">
  <template>
    <style>
      :host {
        display: inline-block;
        position: relative;
        text-align: left;

        /* NOTE(cdata): Both values are needed, since some phones require the
         * value to be \`transparent\`.
         */
        -webkit-tap-highlight-color: rgba(0,0,0,0);
        -webkit-tap-highlight-color: transparent;

        --paper-input-container-input: {
          overflow: hidden;
          white-space: nowrap;
          text-overflow: ellipsis;
          max-width: 100%;
          box-sizing: border-box;
          cursor: pointer;
        };

        @apply --paper-dropdown-menu;
      }

      /* paper-dropdown-menu and paper-dropdown-menu-light both delegate focus
       * to other internal elements which manage focus styling. */
      :host(:focus) {
        outline: none;
      }

      :host(:dir(rtl)) {
        text-align: right;

        @apply(--paper-dropdown-menu);
      }

      :host([disabled]) {
        @apply --paper-dropdown-menu-disabled;
      }

      :host([noink]) paper-ripple {
        display: none;
      }

      :host([no-label-float]) paper-ripple {
        top: 8px;
      }

      paper-ripple {
        top: 12px;
        left: 0px;
        bottom: 8px;
        right: 0px;

        @apply --paper-dropdown-menu-ripple;
      }

      paper-menu-button {
        display: block;
        padding: 0;

        @apply --paper-dropdown-menu-button;
      }

      paper-input {
        @apply --paper-dropdown-menu-input;
      }

      iron-icon {
        color: var(--disabled-text-color);

        @apply --paper-dropdown-menu-icon;
      }
    </style>
  </template>
</dom-module>`;document.head.appendChild(xW.content);var Wbe=Gt(HTMLElement);Yt({_template:Q`
    <style include="paper-dropdown-menu-shared-styles"></style>

    <paper-menu-button id="menuButton" vertical-align="[[verticalAlign]]" horizontal-align="[[horizontalAlign]]" dynamic-align="[[dynamicAlign]]" vertical-offset="[[_computeMenuVerticalOffset(noLabelFloat, verticalOffset)]]" disabled="[[disabled]]" no-animations="[[noAnimations]]" on-iron-select="_onIronSelect" on-iron-deselect="_onIronDeselect" opened="{{opened}}" close-on-activate allow-outside-scroll="[[allowOutsideScroll]]" restore-focus-on-close="[[restoreFocusOnClose]]" expand-sizing-target-for-scrollbars="[[expandSizingTargetForScrollbars]]">
      <!-- support hybrid mode: user might be using paper-menu-button 1.x which distributes via <content> -->
      <div class="dropdown-trigger" slot="dropdown-trigger">
        <paper-ripple></paper-ripple>
        <!-- paper-input has type="text" for a11y, do not remove -->
        <paper-input id="input" type="text" invalid="[[invalid]]" readonly disabled="[[disabled]]" value="[[value]]" placeholder="[[placeholder]]" error-message="[[errorMessage]]" always-float-label="[[alwaysFloatLabel]]" no-label-float="[[noLabelFloat]]" label="[[label]]" input-role="button" input-aria-haspopup="listbox" autocomplete="off">
          <!-- support hybrid mode: user might be using paper-input 1.x which distributes via <content> -->
          <iron-icon icon="paper-dropdown-menu:arrow-drop-down" suffix slot="suffix"></iron-icon>
        </paper-input>
      </div>
      <slot id="content" name="dropdown-content" slot="dropdown-content"></slot>
    </paper-menu-button>
`,is:"paper-dropdown-menu",behaviors:[Sh,Di,Eh,Th],properties:{selectedItemLabel:{type:String,notify:!0,readOnly:!0},selectedItem:{type:Object,notify:!0,readOnly:!0},value:{type:String,notify:!0},label:{type:String},placeholder:{type:String},errorMessage:{type:String},opened:{type:Boolean,notify:!0,value:!1,observer:"_openedChanged"},allowOutsideScroll:{type:Boolean,value:!1},noLabelFloat:{type:Boolean,value:!1,reflectToAttribute:!0},alwaysFloatLabel:{type:Boolean,value:!1},noAnimations:{type:Boolean,value:!1},horizontalAlign:{type:String,value:"right"},verticalAlign:{type:String,value:"top"},verticalOffset:Number,dynamicAlign:{type:Boolean},restoreFocusOnClose:{type:Boolean,value:!0},expandSizingTargetForScrollbars:{type:Boolean,value:!1}},listeners:{tap:"_onTap"},keyBindings:{"up down":"open",esc:"close"},observers:["_selectedItemChanged(selectedItem)"],_attachDom(e){let t=ue(this);return t.attachShadow({mode:"open",delegatesFocus:!0,shadyUpgradeFragment:e}),t.shadowRoot.appendChild(e),Wbe.prototype._attachDom.call(this,e)},focus(){this.$.input._focusableElement.focus()},attached:function(){var e=this.contentElement;e&&e.selectedItem&&this._setSelectedItem(e.selectedItem)},get contentElement(){for(var e=zt(this.$.content).getDistributedNodes(),t=0,r=e.length;t<r;t++)if(e[t].nodeType===Node.ELEMENT_NODE)return e[t]},open:function(){this.$.menuButton.open()},close:function(){this.$.menuButton.close()},_onIronSelect:function(e){this._setSelectedItem(e.detail.item)},_onIronDeselect:function(e){this._setSelectedItem(null)},_onTap:function(e){lgt(e)===this&&this.open()},_selectedItemChanged:function(e){var t="";e?t=e.label||e.getAttribute("label")||e.textContent.trim():t="",this.value=t,this._setSelectedItemLabel(t)},_computeMenuVerticalOffset:function(e,t){return t||(e?-4:8)},_getValidity:function(e){return this.disabled||!this.required||this.required&&!!this.value},_openedChanged:function(){var e=this.opened?"true":"false",t=this.contentElement;t&&t.setAttribute("aria-expanded",e)}});var bW=1,P0t=2,P9={outerScroll:{scroll:!0},shadowMode:{standard:P0t,waterfall:bW,"waterfall-tall":bW},tallMode:{"waterfall-tall":!0}};Yt({_template:Q`
    <style>
      :host {
        @apply --layout-vertical;
        position: relative;
        height: 100%;
        @apply --paper-header-panel;
      }

      #mainContainer {
        @apply --layout-flex;
        position: relative;
        overflow-y: auto;
        overflow-x: hidden;
        -webkit-overflow-scrolling: touch;
      }

      #mainPanel {
        @apply --layout-vertical;
        @apply --layout-flex;
        position: relative;
        min-height: 0;
        @apply --paper-header-panel-body;
      }

      #mainContainer {
        @apply --paper-header-panel-container;
      }

      /*
       * mode: scroll
       */
      :host([mode=scroll]) #mainContainer {
        @apply --paper-header-panel-scroll-container;
        overflow: visible;
      }

      :host([mode=scroll]) {
        overflow-y: auto;
        overflow-x: hidden;
        -webkit-overflow-scrolling: touch;
      }

      /*
       * mode: cover
       */
      :host([mode=cover]) #mainContainer {
        @apply --paper-header-panel-cover-container;
        position: absolute;
        top: 0;
        right: 0;
        bottom: 0;
        left: 0;
      }

      :host([mode=cover]) #mainPanel {
        position: static;
      }

      /*
       * mode: standard
       */
      :host([mode=standard]) #mainContainer {
        @apply --paper-header-panel-standard-container;
      }

      /*
       * mode: seamed
       */
      :host([mode=seamed]) #mainContainer {
        @apply --paper-header-panel-seamed-container;
      }


      /*
       * mode: waterfall
       */
      :host([mode=waterfall]) #mainContainer {
        @apply --paper-header-panel-waterfall-container;
      }

      /*
       * mode: waterfall-tall
       */
      :host([mode=waterfall-tall]) #mainContainer {
        @apply --paper-header-panel-waterfall-tall-container;
      }

      #dropShadow {
        transition: opacity 0.5s;
        height: 6px;
        box-shadow: inset 0px 5px 6px -3px rgba(0, 0, 0, 0.4);
        @apply --paper-header-panel-shadow;
        position: absolute;
        top: 0;
        left: 0;
        right: 0;
        opacity: 0;
        pointer-events: none;
      }

      #dropShadow.has-shadow {
        opacity: 1;
      }

      #mainContainer > ::slotted(.fit) {
        @apply --layout-fit;
      }

    </style>

    <slot id="headerSlot" name="header"></slot>

    <div id="mainPanel">
      <div id="mainContainer" class\$="[[_computeMainContainerClass(mode)]]">
        <slot></slot>
      </div>
      <div id="dropShadow"></div>
    </div>
`,is:"paper-header-panel",properties:{mode:{type:String,value:"standard",observer:"_modeChanged",reflectToAttribute:!0},shadow:{type:Boolean,value:!1},tallClass:{type:String,value:"tall"},atTop:{type:Boolean,value:!0,notify:!0,readOnly:!0,reflectToAttribute:!0}},observers:["_computeDropShadowHidden(atTop, mode, shadow)"],attached:function(){this._addListener(),this._keepScrollingState()},detached:function(){this._removeListener()},ready:function(){this.scrollHandler=this._scroll.bind(this),console.warn(this.is,"is deprecated. Please use app-layout instead!")},get header(){return zt(this.$.headerSlot).getDistributedNodes()[0]},get scroller(){return this._getScrollerForMode(this.mode)},get visibleShadow(){return this.$.dropShadow.classList.contains("has-shadow")},_computeDropShadowHidden:function(e,t,r){var n=P9.shadowMode[t];this.shadow?this.toggleClass("has-shadow",!0,this.$.dropShadow):n===P0t?this.toggleClass("has-shadow",!0,this.$.dropShadow):n===bW&&!e?this.toggleClass("has-shadow",!0,this.$.dropShadow):this.toggleClass("has-shadow",!1,this.$.dropShadow)},_computeMainContainerClass:function(e){var t={};return t.flex=e!=="cover",Object.keys(t).filter(function(r){return t[r]}).join(" ")},_addListener:function(){this.scroller.addEventListener("scroll",this.scrollHandler)},_removeListener:function(){this.scroller.removeEventListener("scroll",this.scrollHandler)},_modeChanged:function(e,t){var r=P9,n=this.header,i=200;n&&(r.tallMode[t]&&!r.tallMode[e]?(n.classList.remove(this.tallClass),this.async(function(){n.classList.remove("animate")},i)):this.toggleClass("animate",r.tallMode[e],n)),this._keepScrollingState()},_keepScrollingState:function(){var e=this.scroller,t=this.header;this._setAtTop(e.scrollTop===0),t&&this.tallClass&&P9.tallMode[this.mode]&&this.toggleClass(this.tallClass,this.atTop||t.classList.contains(this.tallClass)&&e.scrollHeight<this.offsetHeight,t)},_scroll:function(){this._keepScrollingState(),this.fire("content-scroll",{target:this.scroller},{bubbles:!1})},_getScrollerForMode:function(e){return P9.outerScroll[e]?this:this.$.mainContainer}});Yt({is:"paper-icon-button",_template:Q`
    <style>
      :host {
        display: inline-block;
        position: relative;
        padding: 8px;
        outline: none;
        -webkit-user-select: none;
        -moz-user-select: none;
        -ms-user-select: none;
        user-select: none;
        cursor: pointer;
        z-index: 0;
        line-height: 1;

        width: 40px;
        height: 40px;

        /*
          NOTE: Both values are needed, since some phones require the value to
          be \`transparent\`.
        */
        -webkit-tap-highlight-color: rgba(0, 0, 0, 0);
        -webkit-tap-highlight-color: transparent;

        /* Because of polymer/2558, this style has lower specificity than * */
        box-sizing: border-box !important;

        @apply --paper-icon-button;
      }

      :host #ink {
        color: var(--paper-icon-button-ink-color, var(--primary-text-color));
        opacity: 0.6;
      }

      :host([disabled]) {
        color: var(--paper-icon-button-disabled-text, var(--disabled-text-color));
        pointer-events: none;
        cursor: auto;

        @apply --paper-icon-button-disabled;
      }

      :host([hidden]) {
        display: none !important;
      }

      :host(:hover) {
        @apply --paper-icon-button-hover;
      }

      iron-icon {
        --iron-icon-width: 100%;
        --iron-icon-height: 100%;
      }
    </style>

    <iron-icon id="icon" src="[[src]]" icon="[[icon]]"
               alt$="[[alt]]"></iron-icon>
  `,hostAttributes:{role:"button",tabindex:"0"},behaviors:[jx],registered:function(){this._template.setAttribute("strip-whitespace","")},properties:{src:{type:String},icon:{type:String},alt:{type:String,observer:"_altChanged"}},_altChanged:function(e,t){var r=this.getAttribute("aria-label");(!r||t==r)&&this.setAttribute("aria-label",e)}});Yt({_template:Q`
    <style>
      :host {
        display: inline-block;
        position: relative;
        width: 400px;
        border: 1px solid;
        padding: 2px;
        -moz-appearance: textarea;
        -webkit-appearance: textarea;
        overflow: hidden;
      }

      .mirror-text {
        visibility: hidden;
        word-wrap: break-word;
        @apply --iron-autogrow-textarea;
      }

      .fit {
        @apply --layout-fit;
      }

      textarea {
        position: relative;
        outline: none;
        border: none;
        resize: none;
        background: inherit;
        color: inherit;
        /* see comments in template */
        width: 100%;
        height: 100%;
        font-size: inherit;
        font-family: inherit;
        line-height: inherit;
        text-align: inherit;
        @apply --iron-autogrow-textarea;
      }

      textarea::-webkit-input-placeholder {
        @apply --iron-autogrow-textarea-placeholder;
      }

      textarea:-moz-placeholder {
        @apply --iron-autogrow-textarea-placeholder;
      }

      textarea::-moz-placeholder {
        @apply --iron-autogrow-textarea-placeholder;
      }

      textarea:-ms-input-placeholder {
        @apply --iron-autogrow-textarea-placeholder;
      }
    </style>

    <!-- the mirror sizes the input/textarea so it grows with typing -->
    <!-- use &#160; instead &nbsp; of to allow this element to be used in XHTML -->
    <div id="mirror" class="mirror-text" aria-hidden="true">&nbsp;</div>

    <!-- size the input/textarea with a div, because the textarea has intrinsic size in ff -->
    <div class="textarea-container fit">
      <textarea id="textarea" name$="[[name]]" aria-label$="[[label]]" autocomplete$="[[autocomplete]]" autofocus$="[[autofocus]]" autocapitalize$="[[autocapitalize]]" inputmode$="[[inputmode]]" placeholder$="[[placeholder]]" readonly$="[[readonly]]" required$="[[required]]" disabled$="[[disabled]]" rows$="[[rows]]" minlength$="[[minlength]]" maxlength$="[[maxlength]]"></textarea>
    </div>
`,is:"iron-autogrow-textarea",behaviors:[Th,Di],properties:{value:{observer:"_valueChanged",type:String,notify:!0},bindValue:{observer:"_bindValueChanged",type:String,notify:!0},rows:{type:Number,value:1,observer:"_updateCached"},maxRows:{type:Number,value:0,observer:"_updateCached"},autocomplete:{type:String,value:"off"},autofocus:{type:Boolean,value:!1},autocapitalize:{type:String,value:"none"},inputmode:{type:String},placeholder:{type:String},readonly:{type:String},required:{type:Boolean},minlength:{type:Number},maxlength:{type:Number},label:{type:String}},listeners:{input:"_onInput"},get textarea(){return this.$.textarea},get selectionStart(){return this.$.textarea.selectionStart},get selectionEnd(){return this.$.textarea.selectionEnd},set selectionStart(e){this.$.textarea.selectionStart=e},set selectionEnd(e){this.$.textarea.selectionEnd=e},attached:function(){var e=navigator.userAgent.match(/iP(?:[oa]d|hone)/)&&!navigator.userAgent.match(/OS 1[3456789]/);e&&(this.$.textarea.style.marginLeft="-3px")},validate:function(){var e=this.$.textarea.validity.valid;return e&&(this.required&&this.value===""?e=!1:this.hasValidator()&&(e=Th.validate.call(this,this.value))),this.invalid=!e,this.fire("iron-input-validate"),e},_bindValueChanged:function(e){this.value=e},_valueChanged:function(e){var t=this.textarea;!t||(t.value!==e&&(t.value=e||e===0?e:""),this.bindValue=e,this.$.mirror.innerHTML=this._valueForMirror(),this.fire("bind-value-changed",{value:this.bindValue}))},_onInput:function(e){var t=zt(e).path;this.value=t?t[0].value:e.target.value},_constrain:function(e){var t;for(e=e||[""],this.maxRows>0&&e.length>this.maxRows?t=e.slice(0,this.maxRows):t=e.slice(0);this.rows>0&&t.length<this.rows;)t.push("");return t.join("<br/>")+"&#160;"},_valueForMirror:function(){var e=this.textarea;if(!!e)return this.tokens=e&&e.value?e.value.replace(/&/gm,"&amp;").replace(/"/gm,"&quot;").replace(/'/gm,"&#39;").replace(/</gm,"&lt;").replace(/>/gm,"&gt;").split(`
`):[""],this._constrain(this.tokens)},_updateCached:function(){this.$.mirror.innerHTML=this._constrain(this.tokens)}});Yt({_template:Q`
    <style>
      :host {
        display: block;
      }

      :host([hidden]) {
        display: none !important;
      }

      label {
        pointer-events: none;
      }
    </style>

    <paper-input-container no-label-float$="[[noLabelFloat]]" always-float-label="[[_computeAlwaysFloatLabel(alwaysFloatLabel,placeholder)]]" auto-validate$="[[autoValidate]]" disabled$="[[disabled]]" invalid="[[invalid]]">

      <label hidden$="[[!label]]" aria-hidden="true" for$="[[_inputId]]" slot="label">[[label]]</label>

      <iron-autogrow-textarea class="paper-input-input" slot="input" id$="[[_inputId]]" aria-labelledby$="[[_ariaLabelledBy]]" aria-describedby$="[[_ariaDescribedBy]]" bind-value="{{value}}" invalid="{{invalid}}" validator$="[[validator]]" disabled$="[[disabled]]" autocomplete$="[[autocomplete]]" autofocus$="[[autofocus]]" inputmode$="[[inputmode]]" name$="[[name]]" placeholder$="[[placeholder]]" readonly$="[[readonly]]" required$="[[required]]" minlength$="[[minlength]]" maxlength$="[[maxlength]]" autocapitalize$="[[autocapitalize]]" rows$="[[rows]]" max-rows$="[[maxRows]]" on-change="_onChange"></iron-autogrow-textarea>

      <template is="dom-if" if="[[errorMessage]]">
        <paper-input-error aria-live="assertive" slot="add-on">[[errorMessage]]</paper-input-error>
      </template>

      <template is="dom-if" if="[[charCounter]]">
        <paper-input-char-counter slot="add-on"></paper-input-char-counter>
      </template>

    </paper-input-container>
`,is:"paper-textarea",behaviors:[A9,Eh],properties:{_ariaLabelledBy:{observer:"_ariaLabelledByChanged",type:String},_ariaDescribedBy:{observer:"_ariaDescribedByChanged",type:String},value:{type:String},rows:{type:Number,value:1},maxRows:{type:Number,value:0}},get selectionStart(){return this.$.input.textarea.selectionStart},set selectionStart(e){this.$.input.textarea.selectionStart=e},get selectionEnd(){return this.$.input.textarea.selectionEnd},set selectionEnd(e){this.$.input.textarea.selectionEnd=e},_ariaLabelledByChanged:function(e){this._focusableElement.setAttribute("aria-labelledby",e)},_ariaDescribedByChanged:function(e){this._focusableElement.setAttribute("aria-describedby",e)},get _focusableElement(){return this.inputElement.textarea}});var wW=document.createElement("template");wW.setAttribute("style","display: none;");wW.innerHTML=`<dom-module id="paper-item-shared-styles">
  <template>
    <style>
      :host, .paper-item {
        display: block;
        position: relative;
        min-height: var(--paper-item-min-height, 48px);
        padding: 0px 16px;
      }

      .paper-item {
        @apply --paper-font-subhead;
        border:none;
        outline: none;
        background: white;
        width: 100%;
        text-align: left;
      }

      :host([hidden]), .paper-item[hidden] {
        display: none !important;
      }

      :host(.iron-selected), .paper-item.iron-selected {
        font-weight: var(--paper-item-selected-weight, bold);

        @apply --paper-item-selected;
      }

      :host([disabled]), .paper-item[disabled] {
        color: var(--paper-item-disabled-color, var(--disabled-text-color));

        @apply --paper-item-disabled;
      }

      :host(:focus), .paper-item:focus {
        position: relative;
        outline: 0;

        @apply --paper-item-focused;
      }

      :host(:focus):before, .paper-item:focus:before {
        @apply --layout-fit;

        background: currentColor;
        content: '';
        opacity: var(--dark-divider-opacity);
        pointer-events: none;

        @apply --paper-item-focused-before;
      }
    </style>
  </template>
</dom-module>`;document.head.appendChild(wW.content);var Ybe={hostAttributes:{role:"option",tabindex:"0"}},I9=[Sh,Di,Ybe];Yt({_template:Q`
    <style include="paper-item-shared-styles">
      :host {
        @apply --layout-horizontal;
        @apply --layout-center;
        @apply --paper-font-subhead;

        @apply --paper-item;
      }
    </style>
    <slot></slot>
`,is:"paper-item",behaviors:[I9]});Yt({_template:Q`
    <style>
      :host {
        overflow: hidden; /* needed for text-overflow: ellipsis to work on ff */
        @apply --layout-vertical;
        @apply --layout-center-justified;
        @apply --layout-flex;
      }

      :host([two-line]) {
        min-height: var(--paper-item-body-two-line-min-height, 72px);
      }

      :host([three-line]) {
        min-height: var(--paper-item-body-three-line-min-height, 88px);
      }

      :host > ::slotted(*) {
        overflow: hidden;
        text-overflow: ellipsis;
        white-space: nowrap;
      }

      :host > ::slotted([secondary]) {
        @apply --paper-font-body1;

        color: var(--paper-item-body-secondary-color, var(--secondary-text-color));

        @apply --paper-item-body-secondary;
      }
    </style>

    <slot></slot>
`,is:"paper-item-body"});Yt({_template:Q`
    <style include="paper-item-shared-styles"></style>
    <style>
      :host {
        @apply --layout-horizontal;
        @apply --layout-center;
        @apply --paper-font-subhead;

        @apply --paper-item;
        @apply --paper-icon-item;
      }

      .content-icon {
        @apply --layout-horizontal;
        @apply --layout-center;

        width: var(--paper-item-icon-width, 56px);
        @apply --paper-item-icon;
      }
    </style>

    <div id="contentIcon" class="content-icon">
      <slot name="item-icon"></slot>
    </div>
    <slot></slot>
`,is:"paper-icon-item",behaviors:[I9]});var SW={properties:{multi:{type:Boolean,value:!1,observer:"multiChanged"},selectedValues:{type:Array,notify:!0,value:function(){return[]}},selectedItems:{type:Array,readOnly:!0,notify:!0,value:function(){return[]}}},observers:["_updateSelected(selectedValues.splices)"],select:function(e){this.multi?this._toggleSelected(e):this.selected=e},multiChanged:function(e){this._selection.multi=e,this._updateSelected()},get _shouldUpdateSelection(){return this.selected!=null||this.selectedValues!=null&&this.selectedValues.length},_updateAttrForSelected:function(){this.multi?this.selectedItems&&this.selectedItems.length>0&&(this.selectedValues=this.selectedItems.map(function(e){return this._indexToValue(this.indexOf(e))},this).filter(function(e){return e!=null},this)):wh._updateAttrForSelected.apply(this)},_updateSelected:function(){this.multi?this._selectMulti(this.selectedValues):this._selectSelected(this.selected)},_selectMulti:function(e){e=e||[];var t=(this._valuesToItems(e)||[]).filter(function(i){return i!=null});this._selection.clear(t);for(var r=0;r<t.length;r++)this._selection.setItemSelected(t[r],!0);if(this.fallbackSelection&&!this._selection.get().length){var n=this._valueToItem(this.fallbackSelection);n&&this.select(this.fallbackSelection)}},_selectionChange:function(){var e=this._selection.get();this.multi?(this._setSelectedItems(e),this._setSelectedItem(e.length?e[0]:null)):e!=null?(this._setSelectedItems([e]),this._setSelectedItem(e)):(this._setSelectedItems([]),this._setSelectedItem(null))},_toggleSelected:function(e){var t=this.selectedValues.indexOf(e),r=t<0;r?this.push("selectedValues",e):this.splice("selectedValues",t,1)},_valuesToItems:function(e){return e==null?null:e.map(function(t){return this._valueToItem(t)},this)}},I0t=[wh,SW];var __={properties:{focusedItem:{observer:"_focusedItemChanged",readOnly:!0,type:Object},attrForItemTitle:{type:String},disabled:{type:Boolean,value:!1,observer:"_disabledChanged"}},_MODIFIER_KEYS:["Alt","AltGraph","CapsLock","Control","Fn","FnLock","Hyper","Meta","NumLock","OS","ScrollLock","Shift","Super","Symbol","SymbolLock"],_SEARCH_RESET_TIMEOUT_MS:1e3,_previousTabIndex:0,hostAttributes:{role:"menu"},observers:["_updateMultiselectable(multi)"],listeners:{focus:"_onFocus",keydown:"_onKeydown","iron-items-changed":"_onIronItemsChanged"},keyBindings:{up:"_onUpKey",down:"_onDownKey",esc:"_onEscKey","shift+tab:keydown":"_onShiftTabDown"},attached:function(){this._resetTabindices()},select:function(e){this._defaultFocusAsync&&(this.cancelAsync(this._defaultFocusAsync),this._defaultFocusAsync=null);var t=this._valueToItem(e);t&&t.hasAttribute("disabled")||(this._setFocusedItem(t),SW.select.apply(this,arguments))},_resetTabindices:function(){var e=this.multi?this.selectedItems&&this.selectedItems[0]:this.selectedItem;this.items.forEach(function(t){t.setAttribute("tabindex",t===e?"0":"-1"),t.setAttribute("aria-selected",this._selection.isSelected(t))},this)},_updateMultiselectable:function(e){e?this.setAttribute("aria-multiselectable","true"):this.removeAttribute("aria-multiselectable")},_focusWithKeyboardEvent:function(e){if(this._MODIFIER_KEYS.indexOf(e.key)===-1){this.cancelDebouncer("_clearSearchText");var t=this._searchText||"",r=e.key&&e.key.length==1?e.key:String.fromCharCode(e.keyCode);t+=r.toLocaleLowerCase();for(var n=t.length,i=0,o;o=this.items[i];i++)if(!o.hasAttribute("disabled")){var a=this.attrForItemTitle||"textContent",s=(o[a]||o.getAttribute(a)||"").trim();if(!(s.length<n)&&s.slice(0,n).toLocaleLowerCase()==t){this._setFocusedItem(o);break}}this._searchText=t,this.debounce("_clearSearchText",this._clearSearchText,this._SEARCH_RESET_TIMEOUT_MS)}},_clearSearchText:function(){this._searchText=""},_focusPrevious:function(){for(var e=this.items.length,t=Number(this.indexOf(this.focusedItem)),r=1;r<e+1;r++){var n=this.items[(t-r+e)%e];if(!n.hasAttribute("disabled")){var i=zt(n).getOwnerRoot()||document;if(this._setFocusedItem(n),zt(i).activeElement==n)return}}},_focusNext:function(){for(var e=this.items.length,t=Number(this.indexOf(this.focusedItem)),r=1;r<e+1;r++){var n=this.items[(t+r)%e];if(!n.hasAttribute("disabled")){var i=zt(n).getOwnerRoot()||document;if(this._setFocusedItem(n),zt(i).activeElement==n)return}}},_applySelection:function(e,t){t?e.setAttribute("aria-selected","true"):e.setAttribute("aria-selected","false"),wh._applySelection.apply(this,arguments)},_focusedItemChanged:function(e,t){t&&t.setAttribute("tabindex","-1"),e&&!e.hasAttribute("disabled")&&!this.disabled&&(e.setAttribute("tabindex","0"),e.focus())},_onIronItemsChanged:function(e){e.detail.addedNodes.length&&this._resetTabindices()},_onShiftTabDown:function(e){var t=this.getAttribute("tabindex");__._shiftTabPressed=!0,this._setFocusedItem(null),this.setAttribute("tabindex","-1"),this.async(function(){this.setAttribute("tabindex",t),__._shiftTabPressed=!1},1)},_onFocus:function(e){if(!__._shiftTabPressed){var t=zt(e).rootTarget;t!==this&&typeof t.tabIndex!="undefined"&&!this.isLightDescendant(t)||(this._defaultFocusAsync=this.async(function(){var r=this.multi?this.selectedItems&&this.selectedItems[0]:this.selectedItem;this._setFocusedItem(null),r?this._setFocusedItem(r):this.items[0]&&this._focusNext()}))}},_onUpKey:function(e){this._focusPrevious(),e.detail.keyboardEvent.preventDefault()},_onDownKey:function(e){this._focusNext(),e.detail.keyboardEvent.preventDefault()},_onEscKey:function(e){var t=this.focusedItem;t&&t.blur()},_onKeydown:function(e){this.keyboardEventMatchesKeys(e,"up down esc")||this._focusWithKeyboardEvent(e),e.stopPropagation()},_activateHandler:function(e){wh._activateHandler.call(this,e),e.stopPropagation()},_disabledChanged:function(e){e?(this._previousTabIndex=this.hasAttribute("tabindex")?this.tabIndex:0,this.removeAttribute("tabindex")):this.hasAttribute("tabindex")||this.setAttribute("tabindex",this._previousTabIndex)}};__._shiftTabPressed=!1;var L9=[I0t,Oo,__];Yt({_template:Q`
    <style>
      :host {
        display: block;
        padding: 8px 0;

        background: var(--paper-listbox-background-color, var(--primary-background-color));
        color: var(--paper-listbox-color, var(--primary-text-color));

        @apply --paper-listbox;
      }
    </style>

    <slot></slot>
`,is:"paper-listbox",behaviors:[L9],hostAttributes:{role:"listbox"}});var L0t=Q`
<dom-module id="paper-material-shared-styles">
  <template>
    <style>
      :host {
        display: block;
        position: relative;
      }

      :host([elevation="1"]) {
        @apply --shadow-elevation-2dp;
      }

      :host([elevation="2"]) {
        @apply --shadow-elevation-4dp;
      }

      :host([elevation="3"]) {
        @apply --shadow-elevation-6dp;
      }

      :host([elevation="4"]) {
        @apply --shadow-elevation-8dp;
      }

      :host([elevation="5"]) {
        @apply --shadow-elevation-16dp;
      }
    </style>
  </template>
</dom-module>
`;L0t.setAttribute("style","display: none;");document.body.appendChild(L0t.content);Yt({_template:Q`
    <style include="paper-material-shared-styles"></style>
    <style>
      :host([animated]) {
        @apply --shadow-transition;
      }
      :host {
        @apply --paper-material;
      }
    </style>

    <slot></slot>
`,is:"paper-material",properties:{elevation:{type:Number,reflectToAttribute:!0,value:1},animated:{type:Boolean,reflectToAttribute:!0,value:!1}}});var k9={properties:{value:{type:Number,value:0,notify:!0,reflectToAttribute:!0},min:{type:Number,value:0,notify:!0},max:{type:Number,value:100,notify:!0},step:{type:Number,value:1,notify:!0},ratio:{type:Number,value:0,readOnly:!0,notify:!0}},observers:["_update(value, min, max, step)"],_calcRatio:function(e){return(this._clampValue(e)-this.min)/(this.max-this.min)},_clampValue:function(e){return Math.min(this.max,Math.max(this.min,this._calcStep(e)))},_calcStep:function(e){if(e=parseFloat(e),!this.step)return e;var t=Math.round((e-this.min)/this.step);return this.step<1?t/(1/this.step)+this.min:t*this.step+this.min},_validateValue:function(){var e=this._clampValue(this.value);return this.value=this.oldValue=isNaN(e)?this.oldValue:e,this.value!==e},_update:function(){this._validateValue(),this._setRatio(this._calcRatio(this.value)*100)}};Yt({_template:Q`
    <style>
      :host {
        display: block;
        width: 200px;
        position: relative;
        overflow: hidden;
      }

      :host([hidden]), [hidden] {
        display: none !important;
      }

      #progressContainer {
        @apply --paper-progress-container;
        position: relative;
      }

      #progressContainer,
      /* the stripe for the indeterminate animation*/
      .indeterminate::after {
        height: var(--paper-progress-height, 4px);
      }

      #primaryProgress,
      #secondaryProgress,
      .indeterminate::after {
        @apply --layout-fit;
      }

      #progressContainer,
      .indeterminate::after {
        background: var(--paper-progress-container-color, var(--google-grey-300));
      }

      :host(.transiting) #primaryProgress,
      :host(.transiting) #secondaryProgress {
        -webkit-transition-property: -webkit-transform;
        transition-property: transform;

        /* Duration */
        -webkit-transition-duration: var(--paper-progress-transition-duration, 0.08s);
        transition-duration: var(--paper-progress-transition-duration, 0.08s);

        /* Timing function */
        -webkit-transition-timing-function: var(--paper-progress-transition-timing-function, ease);
        transition-timing-function: var(--paper-progress-transition-timing-function, ease);

        /* Delay */
        -webkit-transition-delay: var(--paper-progress-transition-delay, 0s);
        transition-delay: var(--paper-progress-transition-delay, 0s);
      }

      #primaryProgress,
      #secondaryProgress {
        @apply --layout-fit;
        -webkit-transform-origin: left center;
        transform-origin: left center;
        -webkit-transform: scaleX(0);
        transform: scaleX(0);
        will-change: transform;
      }

      #primaryProgress {
        background: var(--paper-progress-active-color, var(--google-green-500));
      }

      #secondaryProgress {
        background: var(--paper-progress-secondary-color, var(--google-green-100));
      }

      :host([disabled]) #primaryProgress {
        background: var(--paper-progress-disabled-active-color, var(--google-grey-500));
      }

      :host([disabled]) #secondaryProgress {
        background: var(--paper-progress-disabled-secondary-color, var(--google-grey-300));
      }

      :host(:not([disabled])) #primaryProgress.indeterminate {
        -webkit-transform-origin: right center;
        transform-origin: right center;
        -webkit-animation: indeterminate-bar var(--paper-progress-indeterminate-cycle-duration, 2s) linear infinite;
        animation: indeterminate-bar var(--paper-progress-indeterminate-cycle-duration, 2s) linear infinite;
      }

      :host(:not([disabled])) #primaryProgress.indeterminate::after {
        content: "";
        -webkit-transform-origin: center center;
        transform-origin: center center;

        -webkit-animation: indeterminate-splitter var(--paper-progress-indeterminate-cycle-duration, 2s) linear infinite;
        animation: indeterminate-splitter var(--paper-progress-indeterminate-cycle-duration, 2s) linear infinite;
      }

      @-webkit-keyframes indeterminate-bar {
        0% {
          -webkit-transform: scaleX(1) translateX(-100%);
        }
        50% {
          -webkit-transform: scaleX(1) translateX(0%);
        }
        75% {
          -webkit-transform: scaleX(1) translateX(0%);
          -webkit-animation-timing-function: cubic-bezier(.28,.62,.37,.91);
        }
        100% {
          -webkit-transform: scaleX(0) translateX(0%);
        }
      }

      @-webkit-keyframes indeterminate-splitter {
        0% {
          -webkit-transform: scaleX(.75) translateX(-125%);
        }
        30% {
          -webkit-transform: scaleX(.75) translateX(-125%);
          -webkit-animation-timing-function: cubic-bezier(.42,0,.6,.8);
        }
        90% {
          -webkit-transform: scaleX(.75) translateX(125%);
        }
        100% {
          -webkit-transform: scaleX(.75) translateX(125%);
        }
      }

      @keyframes indeterminate-bar {
        0% {
          transform: scaleX(1) translateX(-100%);
        }
        50% {
          transform: scaleX(1) translateX(0%);
        }
        75% {
          transform: scaleX(1) translateX(0%);
          animation-timing-function: cubic-bezier(.28,.62,.37,.91);
        }
        100% {
          transform: scaleX(0) translateX(0%);
        }
      }

      @keyframes indeterminate-splitter {
        0% {
          transform: scaleX(.75) translateX(-125%);
        }
        30% {
          transform: scaleX(.75) translateX(-125%);
          animation-timing-function: cubic-bezier(.42,0,.6,.8);
        }
        90% {
          transform: scaleX(.75) translateX(125%);
        }
        100% {
          transform: scaleX(.75) translateX(125%);
        }
      }
    </style>

    <div id="progressContainer">
      <div id="secondaryProgress" hidden\$="[[_hideSecondaryProgress(secondaryRatio)]]"></div>
      <div id="primaryProgress"></div>
    </div>
`,is:"paper-progress",behaviors:[k9],properties:{secondaryProgress:{type:Number,value:0},secondaryRatio:{type:Number,value:0,readOnly:!0},indeterminate:{type:Boolean,value:!1,observer:"_toggleIndeterminate"},disabled:{type:Boolean,value:!1,reflectToAttribute:!0,observer:"_disabledChanged"}},observers:["_progressChanged(secondaryProgress, value, min, max, indeterminate)"],hostAttributes:{role:"progressbar"},_toggleIndeterminate:function(e){this.toggleClass("indeterminate",e,this.$.primaryProgress)},_transformProgress:function(e,t){var r="scaleX("+t/100+")";e.style.transform=e.style.webkitTransform=r},_mainRatioChanged:function(e){this._transformProgress(this.$.primaryProgress,e)},_progressChanged:function(e,t,r,n,i){e=this._clampValue(e),t=this._clampValue(t);var o=this._calcRatio(e)*100,a=this._calcRatio(t)*100;this._setSecondaryRatio(o),this._transformProgress(this.$.secondaryProgress,o),this._transformProgress(this.$.primaryProgress,a),this.secondaryProgress=e,i?this.removeAttribute("aria-valuenow"):this.setAttribute("aria-valuenow",t),this.setAttribute("aria-valuemin",r),this.setAttribute("aria-valuemax",n)},_disabledChanged:function(e){this.setAttribute("aria-disabled",e?"true":"false")},_hideSecondaryProgress:function(e){return e===0}});var k0t=Q`
<style>
  :host {
    display: inline-block;
    line-height: 0;
    white-space: nowrap;
    cursor: pointer;
    @apply --paper-font-common-base;
    --calculated-paper-radio-button-size: var(--paper-radio-button-size, 16px);
    /* -1px is a sentinel for the default and is replace in \`attached\`. */
    --calculated-paper-radio-button-ink-size: var(--paper-radio-button-ink-size, -1px);
  }

  :host(:focus) {
    outline: none;
  }

  #radioContainer {
    @apply --layout-inline;
    @apply --layout-center-center;
    position: relative;
    width: var(--calculated-paper-radio-button-size);
    height: var(--calculated-paper-radio-button-size);
    vertical-align: middle;

    @apply --paper-radio-button-radio-container;
  }

  #ink {
    position: absolute;
    top: 50%;
    left: 50%;
    right: auto;
    width: var(--calculated-paper-radio-button-ink-size);
    height: var(--calculated-paper-radio-button-ink-size);
    color: var(--paper-radio-button-unchecked-ink-color, var(--primary-text-color));
    opacity: 0.6;
    pointer-events: none;
    -webkit-transform: translate(-50%, -50%);
    transform: translate(-50%, -50%);
  }

  #ink[checked] {
    color: var(--paper-radio-button-checked-ink-color, var(--primary-color));
  }

  #offRadio, #onRadio {
    position: absolute;
    box-sizing: border-box;
    top: 0;
    left: 0;
    width: 100%;
    height: 100%;
    border-radius: 50%;
  }

  #offRadio {
    border: 2px solid var(--paper-radio-button-unchecked-color, var(--primary-text-color));
    background-color: var(--paper-radio-button-unchecked-background-color, transparent);
    transition: border-color 0.28s;
  }

  #onRadio {
    background-color: var(--paper-radio-button-checked-color, var(--primary-color));
    -webkit-transform: scale(0);
    transform: scale(0);
    transition: -webkit-transform ease 0.28s;
    transition: transform ease 0.28s;
    will-change: transform;
  }

  :host([checked]) #offRadio {
    border-color: var(--paper-radio-button-checked-color, var(--primary-color));
  }

  :host([checked]) #onRadio {
    -webkit-transform: scale(0.5);
    transform: scale(0.5);
  }

  #radioLabel {
    line-height: normal;
    position: relative;
    display: inline-block;
    vertical-align: middle;
    margin-left: var(--paper-radio-button-label-spacing, 10px);
    white-space: normal;
    color: var(--paper-radio-button-label-color, var(--primary-text-color));

    @apply --paper-radio-button-label;
  }

  :host([checked]) #radioLabel {
    @apply --paper-radio-button-label-checked;
  }

  #radioLabel:dir(rtl) {
    margin-left: 0;
    margin-right: var(--paper-radio-button-label-spacing, 10px);
  }

  #radioLabel[hidden] {
    display: none;
  }

  /* disabled state */

  :host([disabled]) #offRadio {
    border-color: var(--paper-radio-button-unchecked-color, var(--primary-text-color));
    opacity: 0.5;
  }

  :host([disabled][checked]) #onRadio {
    background-color: var(--paper-radio-button-unchecked-color, var(--primary-text-color));
    opacity: 0.5;
  }

  :host([disabled]) #radioLabel {
    /* slightly darker than the button, so that it's readable */
    opacity: 0.65;
  }
</style>

<div id="radioContainer">
  <div id="offRadio"></div>
  <div id="onRadio"></div>
</div>

<div id="radioLabel"><slot></slot></div>`;k0t.setAttribute("strip-whitespace","");Yt({_template:k0t,is:"paper-radio-button",behaviors:[Xx],hostAttributes:{role:"radio","aria-checked":!1,tabindex:0},properties:{ariaActiveAttribute:{type:String,value:"aria-checked"}},ready:function(){this._rippleContainer=this.$.radioContainer},attached:function(){Tm(this,function(){var e=this.getComputedStyleValue("--calculated-paper-radio-button-ink-size").trim();if(e==="-1px"){var t=parseFloat(this.getComputedStyleValue("--calculated-paper-radio-button-size").trim()),r=Math.floor(3*t);r%2!==t%2&&r++,this.updateStyles({"--paper-radio-button-ink-size":r+"px"})}})}});var R9={hostAttributes:{role:"menubar"},keyBindings:{left:"_onLeftKey",right:"_onRightKey"},_onUpKey:function(e){this.focusedItem.click(),e.detail.keyboardEvent.preventDefault()},_onDownKey:function(e){this.focusedItem.click(),e.detail.keyboardEvent.preventDefault()},get _isRTL(){return window.getComputedStyle(this).direction==="rtl"},_onLeftKey:function(e){this._isRTL?this._focusNext():this._focusPrevious(),e.detail.keyboardEvent.preventDefault()},_onRightKey:function(e){this._isRTL?this._focusPrevious():this._focusNext(),e.detail.keyboardEvent.preventDefault()},_onKeydown:function(e){this.keyboardEventMatchesKeys(e,"up down left right esc")||this._focusWithKeyboardEvent(e)}},N9=[L9,R9];Yt({_template:Q`
    <style>
      :host {
        display: inline-block;
      }

      :host ::slotted(*) {
        padding: var(--paper-radio-group-item-padding, 12px);
      }
    </style>

    <slot></slot>
`,is:"paper-radio-group",behaviors:[N9],hostAttributes:{role:"radiogroup"},properties:{attrForSelected:{type:String,value:"name"},selectedAttribute:{type:String,value:"checked"},selectable:{type:String,value:"paper-radio-button"},allowEmptySelection:{type:Boolean,value:!1}},select:function(e){var t=this._valueToItem(e);if(!(t&&t.hasAttribute("disabled"))){if(this.selected){var r=this._valueToItem(this.selected);if(this.selected==e)if(this.allowEmptySelection)e="";else{r&&(r.checked=!0);return}r&&(r.checked=!1)}wh.select.apply(this,[e]),this.fire("paper-radio-group-changed")}},_activateFocusedItem:function(){this._itemActivate(this._valueForItem(this.focusedItem),this.focusedItem)},_onUpKey:function(e){this._focusPrevious(),e.preventDefault(),this._activateFocusedItem()},_onDownKey:function(e){this._focusNext(),e.preventDefault(),this._activateFocusedItem()},_onLeftKey:function(e){R9._onLeftKey.apply(this,arguments),this._activateFocusedItem()},_onRightKey:function(e){R9._onRightKey.apply(this,arguments),this._activateFocusedItem()}});var R0t=Q`
  <style>
    :host {
      @apply --layout;
      @apply --layout-justified;
      @apply --layout-center;
      width: 200px;
      cursor: default;
      -webkit-user-select: none;
      -moz-user-select: none;
      -ms-user-select: none;
      user-select: none;
      -webkit-tap-highlight-color: rgba(0, 0, 0, 0);
      --paper-progress-active-color: var(--paper-slider-active-color, var(--google-blue-700));
      --paper-progress-secondary-color: var(--paper-slider-secondary-color, var(--google-blue-300));
      --paper-progress-disabled-active-color: var(--paper-slider-disabled-active-color, var(--paper-grey-400));
      --paper-progress-disabled-secondary-color: var(--paper-slider-disabled-secondary-color, var(--paper-grey-400));
      --calculated-paper-slider-height: var(--paper-slider-height, 2px);
    }

    /* focus shows the ripple */
    :host(:focus) {
      outline: none;
    }

    /**
      * NOTE(keanulee): Though :host-context is not universally supported, some pages
      * still rely on paper-slider being flipped when dir="rtl" is set on body. For full
      * compatibility, dir="rtl" must be explicitly set on paper-slider.
      */
    :dir(rtl) #sliderContainer {
      -webkit-transform: scaleX(-1);
      transform: scaleX(-1);
    }

    /**
      * NOTE(keanulee): This is separate from the rule above because :host-context may
      * not be recognized.
      */
    :host([dir="rtl"]) #sliderContainer {
      -webkit-transform: scaleX(-1);
      transform: scaleX(-1);
    }

    /**
      * NOTE(keanulee): Needed to override the :host-context rule (where supported)
      * to support LTR sliders in RTL pages.
      */
    :host([dir="ltr"]) #sliderContainer {
      -webkit-transform: scaleX(1);
      transform: scaleX(1);
    }

    #sliderContainer {
      position: relative;
      width: 100%;
      height: calc(30px + var(--calculated-paper-slider-height));
      margin-left: calc(15px + var(--calculated-paper-slider-height)/2);
      margin-right: calc(15px + var(--calculated-paper-slider-height)/2);
    }

    #sliderContainer:focus {
      outline: 0;
    }

    #sliderContainer.editable {
      margin-top: 12px;
      margin-bottom: 12px;
    }

    .bar-container {
      position: absolute;
      top: 0;
      bottom: 0;
      left: 0;
      right: 0;
      overflow: hidden;
    }

    .ring > .bar-container {
      left: calc(5px + var(--calculated-paper-slider-height)/2);
      transition: left 0.18s ease;
    }

    .ring.expand.dragging > .bar-container {
      transition: none;
    }

    .ring.expand:not(.pin) > .bar-container {
      left: calc(8px + var(--calculated-paper-slider-height)/2);
    }

    #sliderBar {
      padding: 15px 0;
      width: 100%;
      background-color: var(--paper-slider-bar-color, transparent);
      --paper-progress-container-color: var(--paper-slider-container-color, var(--paper-grey-400));
      --paper-progress-height: var(--calculated-paper-slider-height);
    }

    .slider-markers {
      position: absolute;
      /* slider-knob is 30px + the slider-height so that the markers should start at a offset of 15px*/
      top: 15px;
      height: var(--calculated-paper-slider-height);
      left: 0;
      right: -1px;
      box-sizing: border-box;
      pointer-events: none;
      @apply --layout-horizontal;
    }

    .slider-marker {
      @apply --layout-flex;
    }
    .slider-markers::after,
    .slider-marker::after {
      content: "";
      display: block;
      margin-left: -1px;
      width: 2px;
      height: var(--calculated-paper-slider-height);
      border-radius: 50%;
      background-color: var(--paper-slider-markers-color, #000);
    }

    .slider-knob {
      position: absolute;
      left: 0;
      top: 0;
      margin-left: calc(-15px - var(--calculated-paper-slider-height)/2);
      width: calc(30px + var(--calculated-paper-slider-height));
      height: calc(30px + var(--calculated-paper-slider-height));
    }

    .transiting > .slider-knob {
      transition: left 0.08s ease;
    }

    .slider-knob:focus {
      outline: none;
    }

    .slider-knob.dragging {
      transition: none;
    }

    .snaps > .slider-knob.dragging {
      transition: -webkit-transform 0.08s ease;
      transition: transform 0.08s ease;
    }

    .slider-knob-inner {
      margin: 10px;
      width: calc(100% - 20px);
      height: calc(100% - 20px);
      background-color: var(--paper-slider-knob-color, var(--google-blue-700));
      border: 2px solid var(--paper-slider-knob-color, var(--google-blue-700));
      border-radius: 50%;

      -moz-box-sizing: border-box;
      box-sizing: border-box;

      transition-property: -webkit-transform, background-color, border;
      transition-property: transform, background-color, border;
      transition-duration: 0.18s;
      transition-timing-function: ease;
    }

    .expand:not(.pin) > .slider-knob > .slider-knob-inner {
      -webkit-transform: scale(1.5);
      transform: scale(1.5);
    }

    .ring > .slider-knob > .slider-knob-inner {
      background-color: var(--paper-slider-knob-start-color, transparent);
      border: 2px solid var(--paper-slider-knob-start-border-color, var(--paper-grey-400));
    }

    .slider-knob-inner::before {
      background-color: var(--paper-slider-pin-color, var(--google-blue-700));
    }

    .pin > .slider-knob > .slider-knob-inner::before {
      content: "";
      position: absolute;
      top: 0;
      left: 50%;
      margin-left: -13px;
      width: 26px;
      height: 26px;
      border-radius: 50% 50% 50% 0;

      -webkit-transform: rotate(-45deg) scale(0) translate(0);
      transform: rotate(-45deg) scale(0) translate(0);
    }

    .slider-knob-inner::before,
    .slider-knob-inner::after {
      transition: -webkit-transform .18s ease, background-color .18s ease;
      transition: transform .18s ease, background-color .18s ease;
    }

    .pin.ring > .slider-knob > .slider-knob-inner::before {
      background-color: var(--paper-slider-pin-start-color, var(--paper-grey-400));
    }

    .pin.expand > .slider-knob > .slider-knob-inner::before {
      -webkit-transform: rotate(-45deg) scale(1) translate(17px, -17px);
      transform: rotate(-45deg) scale(1) translate(17px, -17px);
    }

    .pin > .slider-knob > .slider-knob-inner::after {
      content: attr(value);
      position: absolute;
      top: 0;
      left: 50%;
      margin-left: -16px;
      width: 32px;
      height: 26px;
      text-align: center;
      color: var(--paper-slider-font-color, #fff);
      font-size: 10px;

      -webkit-transform: scale(0) translate(0);
      transform: scale(0) translate(0);
    }

    .pin.expand > .slider-knob > .slider-knob-inner::after {
      -webkit-transform: scale(1) translate(0, -17px);
      transform: scale(1) translate(0, -17px);
    }

    /* paper-input */
    .slider-input {
      width: 50px;
      overflow: hidden;
      --paper-input-container-input: {
        text-align: center;
        @apply --paper-slider-input-container-input;
      };
      @apply --paper-slider-input;
    }

    /* disabled state */
    #sliderContainer.disabled {
      pointer-events: none;
    }

    .disabled > .slider-knob > .slider-knob-inner {
      background-color: var(--paper-slider-disabled-knob-color, var(--paper-grey-400));
      border: 2px solid var(--paper-slider-disabled-knob-color, var(--paper-grey-400));
      -webkit-transform: scale3d(0.75, 0.75, 1);
      transform: scale3d(0.75, 0.75, 1);
    }

    .disabled.ring > .slider-knob > .slider-knob-inner {
      background-color: var(--paper-slider-knob-start-color, transparent);
      border: 2px solid var(--paper-slider-knob-start-border-color, var(--paper-grey-400));
    }

    paper-ripple {
      color: var(--paper-slider-knob-color, var(--google-blue-700));
    }
  </style>

  <div id="sliderContainer" class\$="[[_getClassNames(disabled, pin, snaps, immediateValue, min, expand, dragging, transiting, editable)]]">
    <div class="bar-container">
      <paper-progress disabled\$="[[disabled]]" id="sliderBar" aria-hidden="true" min="[[min]]" max="[[max]]" step="[[step]]" value="[[immediateValue]]" secondary-progress="[[secondaryProgress]]" on-down="_bardown" on-up="_resetKnob" on-track="_bartrack" on-tap="_barclick">
      </paper-progress>
    </div>

    <template is="dom-if" if="[[snaps]]">
      <div class="slider-markers">
        <template is="dom-repeat" items="[[markers]]">
          <div class="slider-marker"></div>
        </template>
      </div>
    </template>

    <div id="sliderKnob" class="slider-knob" on-down="_knobdown" on-up="_resetKnob" on-track="_onTrack" on-transitionend="_knobTransitionEnd">
        <div class="slider-knob-inner" value\$="[[immediateValue]]"></div>
    </div>
  </div>

  <template is="dom-if" if="[[editable]]">
    <paper-input id="input" type="number" step="[[step]]" min="[[min]]" max="[[max]]" class="slider-input" disabled\$="[[disabled]]" value="[[immediateValue]]" on-change="_changeValue" on-keydown="_inputKeyDown" no-label-float>
    </paper-input>
  </template>
`;R0t.setAttribute("strip-whitespace","");Yt({_template:R0t,is:"paper-slider",behaviors:[Oo,Eh,jx,k9],properties:{value:{type:Number,value:0},snaps:{type:Boolean,value:!1,notify:!0},pin:{type:Boolean,value:!1,notify:!0},secondaryProgress:{type:Number,value:0,notify:!0,observer:"_secondaryProgressChanged"},editable:{type:Boolean,value:!1},immediateValue:{type:Number,value:0,readOnly:!0,notify:!0},maxMarkers:{type:Number,value:0,notify:!0},expand:{type:Boolean,value:!1,readOnly:!0},ignoreBarTouch:{type:Boolean,value:!1},dragging:{type:Boolean,value:!1,readOnly:!0,notify:!0},transiting:{type:Boolean,value:!1,readOnly:!0},markers:{type:Array,readOnly:!0,value:function(){return[]}}},observers:["_updateKnob(value, min, max, snaps, step)","_valueChanged(value)","_immediateValueChanged(immediateValue)","_updateMarkers(maxMarkers, min, max, snaps)"],hostAttributes:{role:"slider",tabindex:0},keyBindings:{left:"_leftKey",right:"_rightKey","down pagedown home":"_decrementKey","up pageup end":"_incrementKey"},ready:function(){this.ignoreBarTouch&&d_(this.$.sliderBar,"auto")},increment:function(){this.value=this._clampValue(this.value+this.step)},decrement:function(){this.value=this._clampValue(this.value-this.step)},_updateKnob:function(e,t,r,n,i){this.setAttribute("aria-valuemin",t),this.setAttribute("aria-valuemax",r),this.setAttribute("aria-valuenow",e),this._positionKnob(this._calcRatio(e)*100)},_valueChanged:function(){this.fire("value-change",{composed:!0})},_immediateValueChanged:function(){this.dragging?this.fire("immediate-value-change",{composed:!0}):this.value=this.immediateValue},_secondaryProgressChanged:function(){this.secondaryProgress=this._clampValue(this.secondaryProgress)},_expandKnob:function(){this._setExpand(!0)},_resetKnob:function(){this.cancelDebouncer("expandKnob"),this._setExpand(!1)},_positionKnob:function(e){this._setImmediateValue(this._calcStep(this._calcKnobPosition(e))),this._setRatio(this._calcRatio(this.immediateValue)*100),this.$.sliderKnob.style.left=this.ratio+"%",this.dragging&&(this._knobstartx=this.ratio*this._w/100,this.translate3d(0,0,0,this.$.sliderKnob))},_calcKnobPosition:function(e){return(this.max-this.min)*e/100+this.min},_onTrack:function(e){switch(e.stopPropagation(),e.detail.state){case"start":this._trackStart(e);break;case"track":this._trackX(e);break;case"end":this._trackEnd();break}},_trackStart:function(e){this._setTransiting(!1),this._w=this.$.sliderBar.offsetWidth,this._x=this.ratio*this._w/100,this._startx=this._x,this._knobstartx=this._startx,this._minx=-this._startx,this._maxx=this._w-this._startx,this.$.sliderKnob.classList.add("dragging"),this._setDragging(!0)},_trackX:function(e){this.dragging||this._trackStart(e);var t=this._isRTL?-1:1,r=Math.min(this._maxx,Math.max(this._minx,e.detail.dx*t));this._x=this._startx+r;var n=this._calcStep(this._calcKnobPosition(this._x/this._w*100));this._setImmediateValue(n);var i=this._calcRatio(this.immediateValue)*this._w-this._knobstartx;this.translate3d(i+"px",0,0,this.$.sliderKnob)},_trackEnd:function(){var e=this.$.sliderKnob.style;this.$.sliderKnob.classList.remove("dragging"),this._setDragging(!1),this._resetKnob(),this.value=this.immediateValue,e.transform=e.webkitTransform="",this.fire("change",{composed:!0})},_knobdown:function(e){this._expandKnob(),e.preventDefault(),this.focus()},_bartrack:function(e){this._allowBarEvent(e)&&this._onTrack(e)},_barclick:function(e){this._w=this.$.sliderBar.offsetWidth;var t=this.$.sliderBar.getBoundingClientRect(),r=(e.detail.x-t.left)/this._w*100;this._isRTL&&(r=100-r);var n=this.ratio;this._setTransiting(!0),this._positionKnob(r),n===this.ratio&&this._setTransiting(!1),this.async(function(){this.fire("change",{composed:!0})}),e.preventDefault(),this.focus()},_bardown:function(e){this._allowBarEvent(e)&&(this.debounce("expandKnob",this._expandKnob,60),this._barclick(e))},_knobTransitionEnd:function(e){e.target===this.$.sliderKnob&&this._setTransiting(!1)},_updateMarkers:function(e,t,r,n){n||this._setMarkers([]);var i=Math.round((r-t)/this.step);i>e&&(i=e),(i<0||!isFinite(i))&&(i=0),this._setMarkers(new Array(i))},_mergeClasses:function(e){return Object.keys(e).filter(function(t){return e[t]}).join(" ")},_getClassNames:function(){return this._mergeClasses({disabled:this.disabled,pin:this.pin,snaps:this.snaps,ring:this.immediateValue<=this.min,expand:this.expand,dragging:this.dragging,transiting:this.transiting,editable:this.editable})},_allowBarEvent:function(e){return!this.ignoreBarTouch||e.detail.sourceEvent instanceof MouseEvent},get _isRTL(){return this.__isRTL===void 0&&(this.__isRTL=window.getComputedStyle(this).direction==="rtl"),this.__isRTL},_leftKey:function(e){this._isRTL?this._incrementKey(e):this._decrementKey(e)},_rightKey:function(e){this._isRTL?this._decrementKey(e):this._incrementKey(e)},_incrementKey:function(e){this.disabled||(e.detail.key==="end"?this.value=this.max:this.increment(),this.fire("change"),e.preventDefault())},_decrementKey:function(e){this.disabled||(e.detail.key==="home"?this.value=this.min:this.decrement(),this.fire("change"),e.preventDefault())},_changeValue:function(e){this.value=e.target.value,this.fire("change",{composed:!0})},_inputKeyDown:function(e){e.stopPropagation()},_createRipple:function(){return this._rippleContainer=this.$.sliderKnob,pE._createRipple.call(this)},_focusedChanged:function(e){e&&this.ensureRipple(),this.hasRipple()&&(e?this._ripple.style.display="":this._ripple.style.display="none",this._ripple.holdDown=e)}});var MW=document.createElement("template");MW.setAttribute("style","display: none;");MW.innerHTML=`<dom-module id="paper-spinner-styles">
  <template>
    <style>
      /*
      /**************************/
      /* STYLES FOR THE SPINNER */
      /**************************/

      /*
       * Constants:
       *      ARCSIZE     = 270 degrees (amount of circle the arc takes up)
       *      ARCTIME     = 1333ms (time it takes to expand and contract arc)
       *      ARCSTARTROT = 216 degrees (how much the start location of the arc
       *                                should rotate each time, 216 gives us a
       *                                5 pointed star shape (it's 360/5 * 3).
       *                                For a 7 pointed star, we might do
       *                                360/7 * 3 = 154.286)
       *      SHRINK_TIME = 400ms
       */

      :host {
        display: inline-block;
        position: relative;
        width: 28px;
        height: 28px;

        /* 360 * ARCTIME / (ARCSTARTROT + (360-ARCSIZE)) */
        --paper-spinner-container-rotation-duration: 1568ms;

        /* ARCTIME */
        --paper-spinner-expand-contract-duration: 1333ms;

        /* 4 * ARCTIME */
        --paper-spinner-full-cycle-duration: 5332ms;

        /* SHRINK_TIME */
        --paper-spinner-cooldown-duration: 400ms;
      }

      #spinnerContainer {
        width: 100%;
        height: 100%;

        /* The spinner does not have any contents that would have to be
         * flipped if the direction changes. Always use ltr so that the
         * style works out correctly in both cases. */
        direction: ltr;
      }

      #spinnerContainer.active {
        -webkit-animation: container-rotate var(--paper-spinner-container-rotation-duration) linear infinite;
        animation: container-rotate var(--paper-spinner-container-rotation-duration) linear infinite;
      }

      @-webkit-keyframes container-rotate {
        to { -webkit-transform: rotate(360deg) }
      }

      @keyframes container-rotate {
        to { transform: rotate(360deg) }
      }

      .spinner-layer {
        position: absolute;
        width: 100%;
        height: 100%;
        opacity: 0;
        white-space: nowrap;
        color: var(--paper-spinner-color, var(--google-blue-500));
      }

      .layer-1 {
        color: var(--paper-spinner-layer-1-color, var(--google-blue-500));
      }

      .layer-2 {
        color: var(--paper-spinner-layer-2-color, var(--google-red-500));
      }

      .layer-3 {
        color: var(--paper-spinner-layer-3-color, var(--google-yellow-500));
      }

      .layer-4 {
        color: var(--paper-spinner-layer-4-color, var(--google-green-500));
      }

      /**
       * IMPORTANT NOTE ABOUT CSS ANIMATION PROPERTIES (keanulee):
       *
       * iOS Safari (tested on iOS 8.1) does not handle animation-delay very well - it doesn't
       * guarantee that the animation will start _exactly_ after that value. So we avoid using
       * animation-delay and instead set custom keyframes for each color (as layer-2undant as it
       * seems).
       */
      .active .spinner-layer {
        -webkit-animation-name: fill-unfill-rotate;
        -webkit-animation-duration: var(--paper-spinner-full-cycle-duration);
        -webkit-animation-timing-function: cubic-bezier(0.4, 0.0, 0.2, 1);
        -webkit-animation-iteration-count: infinite;
        animation-name: fill-unfill-rotate;
        animation-duration: var(--paper-spinner-full-cycle-duration);
        animation-timing-function: cubic-bezier(0.4, 0.0, 0.2, 1);
        animation-iteration-count: infinite;
        opacity: 1;
      }

      .active .spinner-layer.layer-1 {
        -webkit-animation-name: fill-unfill-rotate, layer-1-fade-in-out;
        animation-name: fill-unfill-rotate, layer-1-fade-in-out;
      }

      .active .spinner-layer.layer-2 {
        -webkit-animation-name: fill-unfill-rotate, layer-2-fade-in-out;
        animation-name: fill-unfill-rotate, layer-2-fade-in-out;
      }

      .active .spinner-layer.layer-3 {
        -webkit-animation-name: fill-unfill-rotate, layer-3-fade-in-out;
        animation-name: fill-unfill-rotate, layer-3-fade-in-out;
      }

      .active .spinner-layer.layer-4 {
        -webkit-animation-name: fill-unfill-rotate, layer-4-fade-in-out;
        animation-name: fill-unfill-rotate, layer-4-fade-in-out;
      }

      @-webkit-keyframes fill-unfill-rotate {
        12.5% { -webkit-transform: rotate(135deg) } /* 0.5 * ARCSIZE */
        25%   { -webkit-transform: rotate(270deg) } /* 1   * ARCSIZE */
        37.5% { -webkit-transform: rotate(405deg) } /* 1.5 * ARCSIZE */
        50%   { -webkit-transform: rotate(540deg) } /* 2   * ARCSIZE */
        62.5% { -webkit-transform: rotate(675deg) } /* 2.5 * ARCSIZE */
        75%   { -webkit-transform: rotate(810deg) } /* 3   * ARCSIZE */
        87.5% { -webkit-transform: rotate(945deg) } /* 3.5 * ARCSIZE */
        to    { -webkit-transform: rotate(1080deg) } /* 4   * ARCSIZE */
      }

      @keyframes fill-unfill-rotate {
        12.5% { transform: rotate(135deg) } /* 0.5 * ARCSIZE */
        25%   { transform: rotate(270deg) } /* 1   * ARCSIZE */
        37.5% { transform: rotate(405deg) } /* 1.5 * ARCSIZE */
        50%   { transform: rotate(540deg) } /* 2   * ARCSIZE */
        62.5% { transform: rotate(675deg) } /* 2.5 * ARCSIZE */
        75%   { transform: rotate(810deg) } /* 3   * ARCSIZE */
        87.5% { transform: rotate(945deg) } /* 3.5 * ARCSIZE */
        to    { transform: rotate(1080deg) } /* 4   * ARCSIZE */
      }

      @-webkit-keyframes layer-1-fade-in-out {
        0% { opacity: 1 }
        25% { opacity: 1 }
        26% { opacity: 0 }
        89% { opacity: 0 }
        90% { opacity: 1 }
        to { opacity: 1 }
      }

      @keyframes layer-1-fade-in-out {
        0% { opacity: 1 }
        25% { opacity: 1 }
        26% { opacity: 0 }
        89% { opacity: 0 }
        90% { opacity: 1 }
        to { opacity: 1 }
      }

      @-webkit-keyframes layer-2-fade-in-out {
        0% { opacity: 0 }
        15% { opacity: 0 }
        25% { opacity: 1 }
        50% { opacity: 1 }
        51% { opacity: 0 }
        to { opacity: 0 }
      }

      @keyframes layer-2-fade-in-out {
        0% { opacity: 0 }
        15% { opacity: 0 }
        25% { opacity: 1 }
        50% { opacity: 1 }
        51% { opacity: 0 }
        to { opacity: 0 }
      }

      @-webkit-keyframes layer-3-fade-in-out {
        0% { opacity: 0 }
        40% { opacity: 0 }
        50% { opacity: 1 }
        75% { opacity: 1 }
        76% { opacity: 0 }
        to { opacity: 0 }
      }

      @keyframes layer-3-fade-in-out {
        0% { opacity: 0 }
        40% { opacity: 0 }
        50% { opacity: 1 }
        75% { opacity: 1 }
        76% { opacity: 0 }
        to { opacity: 0 }
      }

      @-webkit-keyframes layer-4-fade-in-out {
        0% { opacity: 0 }
        65% { opacity: 0 }
        75% { opacity: 1 }
        90% { opacity: 1 }
        to { opacity: 0 }
      }

      @keyframes layer-4-fade-in-out {
        0% { opacity: 0 }
        65% { opacity: 0 }
        75% { opacity: 1 }
        90% { opacity: 1 }
        to { opacity: 0 }
      }

      .circle-clipper {
        display: inline-block;
        position: relative;
        width: 50%;
        height: 100%;
        overflow: hidden;
      }

      /**
       * Patch the gap that appear between the two adjacent div.circle-clipper while the
       * spinner is rotating (appears on Chrome 50, Safari 9.1.1, and Edge).
       */
      .spinner-layer::after {
        content: '';
        left: 45%;
        width: 10%;
        border-top-style: solid;
      }

      .spinner-layer::after,
      .circle-clipper .circle {
        box-sizing: border-box;
        position: absolute;
        top: 0;
        border-width: var(--paper-spinner-stroke-width, 3px);
        border-radius: 50%;
      }

      .circle-clipper .circle {
        bottom: 0;
        width: 200%;
        border-style: solid;
        border-bottom-color: transparent !important;
      }

      .circle-clipper.left .circle {
        left: 0;
        border-right-color: transparent !important;
        -webkit-transform: rotate(129deg);
        transform: rotate(129deg);
      }

      .circle-clipper.right .circle {
        left: -100%;
        border-left-color: transparent !important;
        -webkit-transform: rotate(-129deg);
        transform: rotate(-129deg);
      }

      .active .gap-patch::after,
      .active .circle-clipper .circle {
        -webkit-animation-duration: var(--paper-spinner-expand-contract-duration);
        -webkit-animation-timing-function: cubic-bezier(0.4, 0.0, 0.2, 1);
        -webkit-animation-iteration-count: infinite;
        animation-duration: var(--paper-spinner-expand-contract-duration);
        animation-timing-function: cubic-bezier(0.4, 0.0, 0.2, 1);
        animation-iteration-count: infinite;
      }

      .active .circle-clipper.left .circle {
        -webkit-animation-name: left-spin;
        animation-name: left-spin;
      }

      .active .circle-clipper.right .circle {
        -webkit-animation-name: right-spin;
        animation-name: right-spin;
      }

      @-webkit-keyframes left-spin {
        0% { -webkit-transform: rotate(130deg) }
        50% { -webkit-transform: rotate(-5deg) }
        to { -webkit-transform: rotate(130deg) }
      }

      @keyframes left-spin {
        0% { transform: rotate(130deg) }
        50% { transform: rotate(-5deg) }
        to { transform: rotate(130deg) }
      }

      @-webkit-keyframes right-spin {
        0% { -webkit-transform: rotate(-130deg) }
        50% { -webkit-transform: rotate(5deg) }
        to { -webkit-transform: rotate(-130deg) }
      }

      @keyframes right-spin {
        0% { transform: rotate(-130deg) }
        50% { transform: rotate(5deg) }
        to { transform: rotate(-130deg) }
      }

      #spinnerContainer.cooldown {
        -webkit-animation: container-rotate var(--paper-spinner-container-rotation-duration) linear infinite, fade-out var(--paper-spinner-cooldown-duration) cubic-bezier(0.4, 0.0, 0.2, 1);
        animation: container-rotate var(--paper-spinner-container-rotation-duration) linear infinite, fade-out var(--paper-spinner-cooldown-duration) cubic-bezier(0.4, 0.0, 0.2, 1);
      }

      @-webkit-keyframes fade-out {
        0% { opacity: 1 }
        to { opacity: 0 }
      }

      @keyframes fade-out {
        0% { opacity: 1 }
        to { opacity: 0 }
      }
    </style>
  </template>
</dom-module>`;document.head.appendChild(MW.content);var D9={properties:{active:{type:Boolean,value:!1,reflectToAttribute:!0,observer:"__activeChanged"},alt:{type:String,value:"loading",observer:"__altChanged"},__coolingDown:{type:Boolean,value:!1}},__computeContainerClasses:function(e,t){return[e||t?"active":"",t?"cooldown":""].join(" ")},__activeChanged:function(e,t){this.__setAriaHidden(!e),this.__coolingDown=!e&&t},__altChanged:function(e){e==="loading"?this.alt=this.getAttribute("aria-label")||e:(this.__setAriaHidden(e===""),this.setAttribute("aria-label",e))},__setAriaHidden:function(e){var t="aria-hidden";e?this.setAttribute(t,"true"):this.removeAttribute(t)},__reset:function(){this.active=!1,this.__coolingDown=!1}};var N0t=Q`
  <style include="paper-spinner-styles"></style>

  <div id="spinnerContainer" class-name="[[__computeContainerClasses(active, __coolingDown)]]" on-animationend="__reset" on-webkit-animation-end="__reset">
    <div class="spinner-layer layer-1">
      <div class="circle-clipper left">
        <div class="circle"></div>
      </div>
      <div class="circle-clipper right">
        <div class="circle"></div>
      </div>
    </div>

    <div class="spinner-layer layer-2">
      <div class="circle-clipper left">
        <div class="circle"></div>
      </div>
      <div class="circle-clipper right">
        <div class="circle"></div>
      </div>
    </div>

    <div class="spinner-layer layer-3">
      <div class="circle-clipper left">
        <div class="circle"></div>
      </div>
      <div class="circle-clipper right">
        <div class="circle"></div>
      </div>
    </div>

    <div class="spinner-layer layer-4">
      <div class="circle-clipper left">
        <div class="circle"></div>
      </div>
      <div class="circle-clipper right">
        <div class="circle"></div>
      </div>
    </div>
  </div>
`;N0t.setAttribute("strip-whitespace","");Yt({_template:N0t,is:"paper-spinner",behaviors:[D9]});var D0t=Q`
  <style include="paper-spinner-styles"></style>

  <div id="spinnerContainer" class-name="[[__computeContainerClasses(active, __coolingDown)]]" on-animationend="__reset" on-webkit-animation-end="__reset">
    <div class="spinner-layer">
      <div class="circle-clipper left">
        <div class="circle"></div>
      </div>
      <div class="circle-clipper right">
        <div class="circle"></div>
      </div>
    </div>
  </div>
`;D0t.setAttribute("strip-whitespace","");Yt({_template:D0t,is:"paper-spinner-lite",behaviors:[D9]});var jbe=Q`<iron-iconset-svg name="paper-tabs" size="24">
<svg><defs>
<g id="chevron-left"><path d="M15.41 7.41L14 6l-6 6 6 6 1.41-1.41L10.83 12z"></path></g>
<g id="chevron-right"><path d="M10 6L8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z"></path></g>
</defs></svg>
</iron-iconset-svg>`;document.head.appendChild(jbe.content);Yt({_template:Q`
    <style>
      :host {
        @apply --layout-inline;
        @apply --layout-center;
        @apply --layout-center-justified;
        @apply --layout-flex-auto;

        position: relative;
        padding: 0 12px;
        overflow: hidden;
        cursor: pointer;
        vertical-align: middle;

        @apply --paper-font-common-base;
        @apply --paper-tab;
      }

      :host(:focus) {
        outline: none;
      }

      :host([link]) {
        padding: 0;
      }

      .tab-content {
        height: 100%;
        transform: translateZ(0);
          -webkit-transform: translateZ(0);
        transition: opacity 0.1s cubic-bezier(0.4, 0.0, 1, 1);
        @apply --layout-horizontal;
        @apply --layout-center-center;
        @apply --layout-flex-auto;
        @apply --paper-tab-content;
      }

      :host(:not(.iron-selected)) > .tab-content {
        opacity: 0.8;

        @apply --paper-tab-content-unselected;
      }

      :host(:focus) .tab-content {
        opacity: 1;
        font-weight: 700;

        @apply --paper-tab-content-focused;
      }

      paper-ripple {
        color: var(--paper-tab-ink, var(--paper-yellow-a100));
      }

      .tab-content > ::slotted(a) {
        @apply --layout-flex-auto;

        height: 100%;
      }
    </style>

    <div class="tab-content">
      <slot></slot>
    </div>
`,is:"paper-tab",behaviors:[Di,Sh,su],properties:{link:{type:Boolean,value:!1,reflectToAttribute:!0}},hostAttributes:{role:"tab"},listeners:{down:"_updateNoink",tap:"_onTap"},attached:function(){this._updateNoink()},get _parentNoink(){var e=zt(this).parentNode;return!!e&&!!e.noink},_updateNoink:function(){this.noink=!!this.noink||!!this._parentNoink},_onTap:function(e){if(this.link){var t=this.queryEffectiveChildren("a");if(!t||e.target===t)return;t.click()}}});Yt({_template:Q`
    <style>
      :host {
        @apply --layout;
        @apply --layout-center;

        height: 48px;
        font-size: 14px;
        font-weight: 500;
        overflow: hidden;
        -moz-user-select: none;
        -ms-user-select: none;
        -webkit-user-select: none;
        user-select: none;

        /* NOTE: Both values are needed, since some phones require the value to be \`transparent\`. */
        -webkit-tap-highlight-color: rgba(0, 0, 0, 0);
        -webkit-tap-highlight-color: transparent;

        @apply --paper-tabs;
      }

      :host(:dir(rtl)) {
        @apply --layout-horizontal-reverse;
      }

      #tabsContainer {
        position: relative;
        height: 100%;
        white-space: nowrap;
        overflow: hidden;
        @apply --layout-flex-auto;
        @apply --paper-tabs-container;
      }

      #tabsContent {
        height: 100%;
        -moz-flex-basis: auto;
        -ms-flex-basis: auto;
        flex-basis: auto;
        @apply --paper-tabs-content;
      }

      #tabsContent.scrollable {
        position: absolute;
        white-space: nowrap;
      }

      #tabsContent:not(.scrollable),
      #tabsContent.scrollable.fit-container {
        @apply --layout-horizontal;
      }

      #tabsContent.scrollable.fit-container {
        min-width: 100%;
      }

      #tabsContent.scrollable.fit-container > ::slotted(*) {
        /* IE - prevent tabs from compressing when they should scroll. */
        -ms-flex: 1 0 auto;
        -webkit-flex: 1 0 auto;
        flex: 1 0 auto;
      }

      .hidden {
        display: none;
      }

      .not-visible {
        opacity: 0;
        cursor: default;
      }

      paper-icon-button {
        width: 48px;
        height: 48px;
        padding: 12px;
        margin: 0 4px;
      }

      #selectionBar {
        position: absolute;
        height: 0;
        bottom: 0;
        left: 0;
        right: 0;
        border-bottom: 2px solid var(--paper-tabs-selection-bar-color, var(--paper-yellow-a100));
          -webkit-transform: scale(0);
        transform: scale(0);
          -webkit-transform-origin: left center;
        transform-origin: left center;
          transition: -webkit-transform;
        transition: transform;

        @apply --paper-tabs-selection-bar;
      }

      #selectionBar.align-bottom {
        top: 0;
        bottom: auto;
      }

      #selectionBar.expand {
        transition-duration: 0.15s;
        transition-timing-function: cubic-bezier(0.4, 0.0, 1, 1);
      }

      #selectionBar.contract {
        transition-duration: 0.18s;
        transition-timing-function: cubic-bezier(0.0, 0.0, 0.2, 1);
      }

      #tabsContent > ::slotted(:not(#selectionBar)) {
        height: 100%;
      }
    </style>

    <paper-icon-button icon="paper-tabs:chevron-left" class$="[[_computeScrollButtonClass(_leftHidden, scrollable, hideScrollButtons)]]" on-up="_onScrollButtonUp" on-down="_onLeftScrollButtonDown" tabindex="-1"></paper-icon-button>

    <div id="tabsContainer" on-track="_scroll" on-down="_down">
      <div id="tabsContent" class$="[[_computeTabsContentClass(scrollable, fitContainer)]]">
        <div id="selectionBar" class$="[[_computeSelectionBarClass(noBar, alignBottom)]]" on-transitionend="_onBarTransitionEnd"></div>
        <slot></slot>
      </div>
    </div>

    <paper-icon-button icon="paper-tabs:chevron-right" class$="[[_computeScrollButtonClass(_rightHidden, scrollable, hideScrollButtons)]]" on-up="_onScrollButtonUp" on-down="_onRightScrollButtonDown" tabindex="-1"></paper-icon-button>
`,is:"paper-tabs",behaviors:[Js,N9],properties:{noink:{type:Boolean,value:!1,observer:"_noinkChanged"},noBar:{type:Boolean,value:!1},noSlide:{type:Boolean,value:!1},scrollable:{type:Boolean,value:!1},fitContainer:{type:Boolean,value:!1},disableDrag:{type:Boolean,value:!1},hideScrollButtons:{type:Boolean,value:!1},alignBottom:{type:Boolean,value:!1},selectable:{type:String,value:"paper-tab"},autoselect:{type:Boolean,value:!1},autoselectDelay:{type:Number,value:0},_step:{type:Number,value:10},_holdDelay:{type:Number,value:1},_leftHidden:{type:Boolean,value:!1},_rightHidden:{type:Boolean,value:!1},_previousTab:{type:Object}},hostAttributes:{role:"tablist"},listeners:{"iron-resize":"_onTabSizingChanged","iron-items-changed":"_onTabSizingChanged","iron-select":"_onIronSelect","iron-deselect":"_onIronDeselect"},keyBindings:{"left:keyup right:keyup":"_onArrowKeyup"},created:function(){this._holdJob=null,this._pendingActivationItem=void 0,this._pendingActivationTimeout=void 0,this._bindDelayedActivationHandler=this._delayedActivationHandler.bind(this),this.addEventListener("blur",this._onBlurCapture.bind(this),!0)},ready:function(){this.setScrollDirection("y",this.$.tabsContainer)},detached:function(){this._cancelPendingActivation()},_noinkChanged:function(e){var t=zt(this).querySelectorAll("paper-tab");t.forEach(e?this._setNoinkAttribute:this._removeNoinkAttribute)},_setNoinkAttribute:function(e){e.setAttribute("noink","")},_removeNoinkAttribute:function(e){e.removeAttribute("noink")},_computeScrollButtonClass:function(e,t,r){return!t||r?"hidden":e?"not-visible":""},_computeTabsContentClass:function(e,t){return e?"scrollable"+(t?" fit-container":""):" fit-container"},_computeSelectionBarClass:function(e,t){return e?"hidden":t?"align-bottom":""},_onTabSizingChanged:function(){this.debounce("_onTabSizingChanged",function(){this._scroll(),this._tabChanged(this.selectedItem)},10)},_onIronSelect:function(e){this._tabChanged(e.detail.item,this._previousTab),this._previousTab=e.detail.item,this.cancelDebouncer("tab-changed")},_onIronDeselect:function(e){this.debounce("tab-changed",function(){this._tabChanged(null,this._previousTab),this._previousTab=null},1)},_activateHandler:function(){this._cancelPendingActivation(),__._activateHandler.apply(this,arguments)},_scheduleActivation:function(e,t){this._pendingActivationItem=e,this._pendingActivationTimeout=this.async(this._bindDelayedActivationHandler,t)},_delayedActivationHandler:function(){var e=this._pendingActivationItem;this._pendingActivationItem=void 0,this._pendingActivationTimeout=void 0,e.fire(this.activateEvent,null,{bubbles:!0,cancelable:!0})},_cancelPendingActivation:function(){this._pendingActivationTimeout!==void 0&&(this.cancelAsync(this._pendingActivationTimeout),this._pendingActivationItem=void 0,this._pendingActivationTimeout=void 0)},_onArrowKeyup:function(e){this.autoselect&&this._scheduleActivation(this.focusedItem,this.autoselectDelay)},_onBlurCapture:function(e){e.target===this._pendingActivationItem&&this._cancelPendingActivation()},get _tabContainerScrollSize(){return Math.max(0,this.$.tabsContainer.scrollWidth-this.$.tabsContainer.offsetWidth)},_scroll:function(e,t){if(!!this.scrollable){var r=t&&-t.ddx||0;this._affectScroll(r)}},_down:function(e){this.async(function(){this._defaultFocusAsync&&(this.cancelAsync(this._defaultFocusAsync),this._defaultFocusAsync=null)},1)},_affectScroll:function(e){this.$.tabsContainer.scrollLeft+=e;var t=this.$.tabsContainer.scrollLeft;this._leftHidden=t===0,this._rightHidden=t===this._tabContainerScrollSize},_onLeftScrollButtonDown:function(){this._scrollToLeft(),this._holdJob=setInterval(this._scrollToLeft.bind(this),this._holdDelay)},_onRightScrollButtonDown:function(){this._scrollToRight(),this._holdJob=setInterval(this._scrollToRight.bind(this),this._holdDelay)},_onScrollButtonUp:function(){clearInterval(this._holdJob),this._holdJob=null},_scrollToLeft:function(){this._affectScroll(-this._step)},_scrollToRight:function(){this._affectScroll(this._step)},_tabChanged:function(e,t){if(!e){this.$.selectionBar.classList.remove("expand"),this.$.selectionBar.classList.remove("contract"),this._positionBar(0,0);return}var r=this.$.tabsContent.getBoundingClientRect(),n=r.width,i=e.getBoundingClientRect(),o=i.left-r.left;if(this._pos={width:this._calcPercent(i.width,n),left:this._calcPercent(o,n)},this.noSlide||t==null){this.$.selectionBar.classList.remove("expand"),this.$.selectionBar.classList.remove("contract"),this._positionBar(this._pos.width,this._pos.left);return}var a=t.getBoundingClientRect(),s=this.items.indexOf(t),l=this.items.indexOf(e),c=5;this.$.selectionBar.classList.add("expand");var u=s<l,h=this._isRTL;h&&(u=!u),u?this._positionBar(this._calcPercent(i.left+i.width-a.left,n)-c,this._left):this._positionBar(this._calcPercent(a.left+a.width-i.left,n)-c,this._calcPercent(o,n)+c),this.scrollable&&this._scrollToSelectedIfNeeded(i.width,o)},_scrollToSelectedIfNeeded:function(e,t){var r=t-this.$.tabsContainer.scrollLeft;r<0?this.$.tabsContainer.scrollLeft+=r:(r+=e-this.$.tabsContainer.offsetWidth,r>0&&(this.$.tabsContainer.scrollLeft+=r))},_calcPercent:function(e,t){return 100*e/t},_positionBar:function(e,t){e=e||0,t=t||0,this._width=e,this._left=t,this.transform("translateX("+t+"%) scaleX("+e/100+")",this.$.selectionBar)},_onBarTransitionEnd:function(e){var t=this.$.selectionBar.classList;t.contains("expand")?(t.remove("expand"),t.add("contract"),this._positionBar(this._pos.width,this._pos.left)):t.contains("contract")&&t.remove("contract")}});var Jx=null;Yt({_template:Q`
    <style>
      :host {
        display: block;
        position: fixed;
        background-color: var(--paper-toast-background-color, #323232);
        color: var(--paper-toast-color, #f1f1f1);
        min-height: 48px;
        min-width: 288px;
        padding: 16px 24px;
        box-sizing: border-box;
        box-shadow: 0 2px 5px 0 rgba(0, 0, 0, 0.26);
        border-radius: 2px;
        margin: 12px;
        font-size: 14px;
        cursor: default;
        -webkit-transition: -webkit-transform 0.3s, opacity 0.3s;
        transition: transform 0.3s, opacity 0.3s;
        opacity: 0;
        -webkit-transform: translateY(100px);
        transform: translateY(100px);
        @apply --paper-font-common-base;
      }

      :host(.capsule) {
        border-radius: 24px;
      }

      :host(.fit-bottom) {
        width: 100%;
        min-width: 0;
        border-radius: 0;
        margin: 0;
      }

      :host(.paper-toast-open) {
        opacity: 1;
        -webkit-transform: translateY(0px);
        transform: translateY(0px);
      }
    </style>

    <span id="label">{{text}}</span>
    <slot></slot>
`,is:"paper-toast",behaviors:[Kx],properties:{fitInto:{type:Object,value:window,observer:"_onFitIntoChanged"},horizontalAlign:{type:String,value:"left"},verticalAlign:{type:String,value:"bottom"},duration:{type:Number,value:3e3},text:{type:String,value:""},noCancelOnOutsideClick:{type:Boolean,value:!0},noAutoFocus:{type:Boolean,value:!0}},listeners:{transitionend:"__onTransitionEnd"},get visible(){return Da._warn("`visible` is deprecated, use `opened` instead"),this.opened},get _canAutoClose(){return this.duration>0&&this.duration!==1/0},created:function(){this._autoClose=null,ec.requestAvailability()},show:function(e){typeof e=="string"&&(e={text:e});for(var t in e)t.indexOf("_")===0?Da._warn('The property "'+t+'" is private and was not set.'):t in this?this[t]=e[t]:Da._warn('The property "'+t+'" is not valid.');this.open()},hide:function(){this.close()},__onTransitionEnd:function(e){e&&e.target===this&&e.propertyName==="opacity"&&(this.opened?this._finishRenderOpened():this._finishRenderClosed())},_openedChanged:function(){this._autoClose!==null&&(this.cancelAsync(this._autoClose),this._autoClose=null),this.opened?(Jx&&Jx!==this&&Jx.close(),Jx=this,this.fire("iron-announce",{text:this.text}),this._canAutoClose&&(this._autoClose=this.async(this.close,this.duration))):Jx===this&&(Jx=null),Pm._openedChanged.apply(this,arguments)},_renderOpened:function(){this.classList.add("paper-toast-open")},_renderClosed:function(){this.classList.remove("paper-toast-open")},_onFitIntoChanged:function(e){this.positionTarget=e}});var O0t=Q`

    <style>
      :host {
        display: inline-block;
        @apply --layout-horizontal;
        @apply --layout-center;
        @apply --paper-font-common-base;
      }

      :host([disabled]) {
        pointer-events: none;
      }

      :host(:focus) {
        outline:none;
      }

      .toggle-bar {
        position: absolute;
        height: 100%;
        width: 100%;
        border-radius: 8px;
        pointer-events: none;
        opacity: 0.4;
        transition: background-color linear .08s;
        background-color: var(--paper-toggle-button-unchecked-bar-color, #000000);

        @apply --paper-toggle-button-unchecked-bar;
      }

      .toggle-button {
        position: absolute;
        top: -3px;
        left: 0;
        height: 20px;
        width: 20px;
        border-radius: 50%;
        box-shadow: 0 1px 5px 0 rgba(0, 0, 0, 0.6);
        transition: -webkit-transform linear .08s, background-color linear .08s;
        transition: transform linear .08s, background-color linear .08s;
        will-change: transform;
        background-color: var(--paper-toggle-button-unchecked-button-color, var(--paper-grey-50));

        @apply --paper-toggle-button-unchecked-button;
      }

      .toggle-button.dragging {
        -webkit-transition: none;
        transition: none;
      }

      :host([checked]:not([disabled])) .toggle-bar {
        opacity: 0.5;
        background-color: var(--paper-toggle-button-checked-bar-color, var(--primary-color));

        @apply --paper-toggle-button-checked-bar;
      }

      :host([disabled]) .toggle-bar {
        background-color: #000;
        opacity: 0.12;
      }

      :host([checked]) .toggle-button {
        -webkit-transform: translate(16px, 0);
        transform: translate(16px, 0);
      }

      :host([checked]:not([disabled])) .toggle-button {
        background-color: var(--paper-toggle-button-checked-button-color, var(--primary-color));

        @apply --paper-toggle-button-checked-button;
      }

      :host([disabled]) .toggle-button {
        background-color: #bdbdbd;
        opacity: 1;
      }

      .toggle-ink {
        position: absolute;
        top: -14px;
        left: -14px;
        right: auto;
        bottom: auto;
        width: 48px;
        height: 48px;
        opacity: 0.5;
        pointer-events: none;
        color: var(--paper-toggle-button-unchecked-ink-color, var(--primary-text-color));

        @apply --paper-toggle-button-unchecked-ink;
      }

      :host([checked]) .toggle-ink {
        color: var(--paper-toggle-button-checked-ink-color, var(--primary-color));

        @apply --paper-toggle-button-checked-ink;
      }

      .toggle-container {
        display: inline-block;
        position: relative;
        width: 36px;
        height: 14px;
        /* The toggle button has an absolute position of -3px; The extra 1px
        /* accounts for the toggle button shadow box. */
        margin: 4px 1px;
      }

      .toggle-label {
        position: relative;
        display: inline-block;
        vertical-align: middle;
        padding-left: var(--paper-toggle-button-label-spacing, 8px);
        pointer-events: none;
        color: var(--paper-toggle-button-label-color, var(--primary-text-color));
      }

      /* invalid state */
      :host([invalid]) .toggle-bar {
        background-color: var(--paper-toggle-button-invalid-bar-color, var(--error-color));
      }

      :host([invalid]) .toggle-button {
        background-color: var(--paper-toggle-button-invalid-button-color, var(--error-color));
      }

      :host([invalid]) .toggle-ink {
        color: var(--paper-toggle-button-invalid-ink-color, var(--error-color));
      }
    </style>

    <div class="toggle-container">
      <div id="toggleBar" class="toggle-bar"></div>
      <div id="toggleButton" class="toggle-button"></div>
    </div>

    <div class="toggle-label"><slot></slot></div>

  `;O0t.setAttribute("strip-whitespace","");Yt({_template:O0t,is:"paper-toggle-button",behaviors:[Xx],hostAttributes:{role:"button","aria-pressed":"false",tabindex:0},properties:{},listeners:{track:"_ontrack"},attached:function(){Tm(this,function(){d_(this,"pan-y")})},_ontrack:function(e){var t=e.detail;t.state==="start"?this._trackStart(t):t.state==="track"?this._trackMove(t):t.state==="end"&&this._trackEnd(t)},_trackStart:function(e){this._width=this.$.toggleBar.offsetWidth/2,this._trackChecked=this.checked,this.$.toggleButton.classList.add("dragging")},_trackMove:function(e){var t=e.dx;this._x=Math.min(this._width,Math.max(0,this._trackChecked?this._width+t:t)),this.translate3d(this._x+"px",0,0,this.$.toggleButton),this._userActivate(this._x>this._width/2)},_trackEnd:function(e){this.$.toggleButton.classList.remove("dragging"),this.transform("",this.$.toggleButton)},_createRipple:function(){this._rippleContainer=this.$.toggleButton;var e=su._createRipple();return e.id="ink",e.setAttribute("recenters",""),e.classList.add("circle","toggle-ink"),e}});Yt({_template:Q`
    <style>
      :host {
        --calculated-paper-toolbar-height: var(--paper-toolbar-height, 64px);
        --calculated-paper-toolbar-sm-height: var(--paper-toolbar-sm-height, 56px);
        display: block;
        position: relative;
        box-sizing: border-box;
        -moz-box-sizing: border-box;
        height: var(--calculated-paper-toolbar-height);
        background: var(--paper-toolbar-background, var(--primary-color));
        color: var(--paper-toolbar-color, var(--dark-theme-text-color));
        @apply --paper-toolbar;
      }

      :host(.animate) {
        transition: var(--paper-toolbar-transition, height 0.18s ease-in);
      }

      :host(.medium-tall) {
        height: calc(var(--calculated-paper-toolbar-height) * 2);
        @apply --paper-toolbar-medium;
      }

      :host(.tall) {
        height: calc(var(--calculated-paper-toolbar-height) * 3);
        @apply --paper-toolbar-tall;
      }

      .toolbar-tools {
        position: relative;
        height: var(--calculated-paper-toolbar-height);
        padding: 0 16px;
        pointer-events: none;
        @apply --layout-horizontal;
        @apply --layout-center;
        @apply --paper-toolbar-content;
      }

      /*
       * TODO: Where should media query breakpoints live so they can be shared between elements?
       */

      @media (max-width: 600px) {
        :host {
          height: var(--calculated-paper-toolbar-sm-height);
        }

        :host(.medium-tall) {
          height: calc(var(--calculated-paper-toolbar-sm-height) * 2);
        }

        :host(.tall) {
          height: calc(var(--calculated-paper-toolbar-sm-height) * 3);
        }

        .toolbar-tools {
          height: var(--calculated-paper-toolbar-sm-height);
        }
      }

      #topBar {
        position: relative;
      }

      /* middle bar */
      #middleBar {
        position: absolute;
        top: 0;
        right: 0;
        left: 0;
      }

      :host(.tall) #middleBar,
      :host(.medium-tall) #middleBar {
        -webkit-transform: translateY(100%);
        transform: translateY(100%);
      }

      /* bottom bar */
      #bottomBar {
        position: absolute;
        right: 0;
        bottom: 0;
        left: 0;
      }

      /*
       * make elements (e.g. buttons) respond to mouse/touch events
       *
       * \`.toolbar-tools\` disables touch events so multiple toolbars can stack and not
       * absorb events. All children must have pointer events re-enabled to work as
       * expected.
       */
      .toolbar-tools > ::slotted(*:not([disabled])) {
        pointer-events: auto;
      }

      .toolbar-tools > ::slotted(.title) {
        @apply --paper-font-common-base;
        white-space: nowrap;
        overflow: hidden;
        text-overflow: ellipsis;
        font-size: 20px;
        font-weight: 400;
        line-height: 1;
        pointer-events: none;
        @apply --layout-flex;
      }

      .toolbar-tools > ::slotted(.title) {
        margin-left: 56px;
      }

      .toolbar-tools > ::slotted(paper-icon-button + .title) {
        margin-left: 0;
      }

      /**
       * The --paper-toolbar-title mixin is applied here instead of above to
       * fix the issue with margin-left being ignored due to css ordering.
       */
      .toolbar-tools > ::slotted(.title) {
        @apply --paper-toolbar-title;
      }

      .toolbar-tools > ::slotted(paper-icon-button[icon=menu]) {
        margin-right: 24px;
      }

      .toolbar-tools > ::slotted(.fit) {
        position: absolute;
        top: auto;
        right: 0;
        bottom: 0;
        left: 0;
        width: auto;
        margin: 0;
      }

      /* TODO(noms): Until we have a better solution for classes that don't use
       * /deep/ create our own.
       */
      .start-justified {
        @apply --layout-start-justified;
      }

      .center-justified {
        @apply --layout-center-justified;
      }

      .end-justified {
        @apply --layout-end-justified;
      }

      .around-justified {
        @apply --layout-around-justified;
      }

      .justified {
        @apply --layout-justified;
      }
    </style>

    <div id="topBar" class\$="toolbar-tools [[_computeBarExtraClasses(justify)]]">
      <slot name="top"></slot>
    </div>

    <div id="middleBar" class\$="toolbar-tools [[_computeBarExtraClasses(middleJustify)]]">
      <slot name="middle"></slot>
    </div>

    <div id="bottomBar" class\$="toolbar-tools [[_computeBarExtraClasses(bottomJustify)]]">
      <slot name="bottom"></slot>
    </div>
`,is:"paper-toolbar",hostAttributes:{role:"toolbar"},properties:{bottomJustify:{type:String,value:""},justify:{type:String,value:""},middleJustify:{type:String,value:""}},ready:function(){console.warn(this.is,"is deprecated. Please use app-layout instead!")},attached:function(){this._observer=this._observe(this),this._updateAriaLabelledBy()},detached:function(){this._observer&&this._observer.disconnect()},_observe:function(e){var t=new MutationObserver(function(){this._updateAriaLabelledBy()}.bind(this));return t.observe(e,{childList:!0,subtree:!0}),t},_updateAriaLabelledBy:function(){ci();for(var e=[],t=Array.prototype.slice.call(zt(this.root).querySelectorAll("slot")).concat(Array.prototype.slice.call(zt(this.root).querySelectorAll("content"))),r,n=0;r=t[n];n++)for(var i=zt(r).getDistributedNodes(),o,a=0;o=i[a];a++)if(o.classList&&o.classList.contains("title"))if(o.id)e.push(o.id);else{var s="paper-toolbar-label-"+Math.floor(Math.random()*1e4);o.id=s,e.push(s)}e.length>0&&this.setAttribute("aria-labelledby",e.join(" "))},_computeBarExtraClasses:function(e){return e?e+(e==="justified"?"":"-justified"):""}});Yt({_template:Q`
    <style>
      :host {
        display: block;
        position: absolute;
        outline: none;
        z-index: 1002;
        -moz-user-select: none;
        -ms-user-select: none;
        -webkit-user-select: none;
        user-select: none;
        cursor: default;
      }

      #tooltip {
        display: block;
        outline: none;
        @apply --paper-font-common-base;
        font-size: 10px;
        line-height: 1;
        background-color: var(--paper-tooltip-background, #616161);
        color: var(--paper-tooltip-text-color, white);
        padding: 8px;
        border-radius: 2px;
        @apply --paper-tooltip;
      }

      @keyframes keyFrameScaleUp {
        0% {
          transform: scale(0.0);
        }
        100% {
          transform: scale(1.0);
        }
      }

      @keyframes keyFrameScaleDown {
        0% {
          transform: scale(1.0);
        }
        100% {
          transform: scale(0.0);
        }
      }

      @keyframes keyFrameFadeInOpacity {
        0% {
          opacity: 0;
        }
        100% {
          opacity: var(--paper-tooltip-opacity, 0.9);
        }
      }

      @keyframes keyFrameFadeOutOpacity {
        0% {
          opacity: var(--paper-tooltip-opacity, 0.9);
        }
        100% {
          opacity: 0;
        }
      }

      @keyframes keyFrameSlideDownIn {
        0% {
          transform: translateY(-2000px);
          opacity: 0;
        }
        10% {
          opacity: 0.2;
        }
        100% {
          transform: translateY(0);
          opacity: var(--paper-tooltip-opacity, 0.9);
        }
      }

      @keyframes keyFrameSlideDownOut {
        0% {
          transform: translateY(0);
          opacity: var(--paper-tooltip-opacity, 0.9);
        }
        10% {
          opacity: 0.2;
        }
        100% {
          transform: translateY(-2000px);
          opacity: 0;
        }
      }

      .fade-in-animation {
        opacity: 0;
        animation-delay: var(--paper-tooltip-delay-in, 500ms);
        animation-name: keyFrameFadeInOpacity;
        animation-iteration-count: 1;
        animation-timing-function: ease-in;
        animation-duration: var(--paper-tooltip-duration-in, 500ms);
        animation-fill-mode: forwards;
        @apply --paper-tooltip-animation;
      }

      .fade-out-animation {
        opacity: var(--paper-tooltip-opacity, 0.9);
        animation-delay: var(--paper-tooltip-delay-out, 0ms);
        animation-name: keyFrameFadeOutOpacity;
        animation-iteration-count: 1;
        animation-timing-function: ease-in;
        animation-duration: var(--paper-tooltip-duration-out, 500ms);
        animation-fill-mode: forwards;
        @apply --paper-tooltip-animation;
      }

      .scale-up-animation {
        transform: scale(0);
        opacity: var(--paper-tooltip-opacity, 0.9);
        animation-delay: var(--paper-tooltip-delay-in, 500ms);
        animation-name: keyFrameScaleUp;
        animation-iteration-count: 1;
        animation-timing-function: ease-in;
        animation-duration: var(--paper-tooltip-duration-in, 500ms);
        animation-fill-mode: forwards;
        @apply --paper-tooltip-animation;
      }

      .scale-down-animation {
        transform: scale(1);
        opacity: var(--paper-tooltip-opacity, 0.9);
        animation-delay: var(--paper-tooltip-delay-out, 500ms);
        animation-name: keyFrameScaleDown;
        animation-iteration-count: 1;
        animation-timing-function: ease-in;
        animation-duration: var(--paper-tooltip-duration-out, 500ms);
        animation-fill-mode: forwards;
        @apply --paper-tooltip-animation;
      }

      .slide-down-animation {
        transform: translateY(-2000px);
        opacity: 0;
        animation-delay: var(--paper-tooltip-delay-out, 500ms);
        animation-name: keyFrameSlideDownIn;
        animation-iteration-count: 1;
        animation-timing-function: cubic-bezier(0.0, 0.0, 0.2, 1);
        animation-duration: var(--paper-tooltip-duration-out, 500ms);
        animation-fill-mode: forwards;
        @apply --paper-tooltip-animation;
      }

      .slide-down-animation-out {
        transform: translateY(0);
        opacity: var(--paper-tooltip-opacity, 0.9);
        animation-delay: var(--paper-tooltip-delay-out, 500ms);
        animation-name: keyFrameSlideDownOut;
        animation-iteration-count: 1;
        animation-timing-function: cubic-bezier(0.4, 0.0, 1, 1);
        animation-duration: var(--paper-tooltip-duration-out, 500ms);
        animation-fill-mode: forwards;
        @apply --paper-tooltip-animation;
      }

      .cancel-animation {
        animation-delay: -30s !important;
      }

      /* Thanks IE 10. */

      .hidden {
        display: none !important;
      }
    </style>

    <div id="tooltip" class="hidden">
      <slot></slot>
    </div>
`,is:"paper-tooltip",hostAttributes:{role:"tooltip",tabindex:-1},properties:{for:{type:String,observer:"_findTarget"},manualMode:{type:Boolean,value:!1,observer:"_manualModeChanged"},position:{type:String,value:"bottom"},fitToVisibleBounds:{type:Boolean,value:!1},offset:{type:Number,value:14},marginTop:{type:Number,value:14},animationDelay:{type:Number,value:500,observer:"_delayChange"},animationEntry:{type:String,value:""},animationExit:{type:String,value:""},animationConfig:{type:Object,value:function(){return{entry:[{name:"fade-in-animation",node:this,timing:{delay:0}}],exit:[{name:"fade-out-animation",node:this}]}}},_showing:{type:Boolean,value:!1}},listeners:{webkitAnimationEnd:"_onAnimationEnd"},get target(){var e=zt(this).parentNode,t=zt(this).getOwnerRoot(),r;return this.for?r=zt(t).querySelector("#"+this.for):r=e.nodeType==Node.DOCUMENT_FRAGMENT_NODE?t.host:e,r},attached:function(){this._findTarget()},detached:function(){this.manualMode||this._removeListeners()},playAnimation:function(e){e==="entry"?this.show():e==="exit"&&this.hide()},cancelAnimation:function(){this.$.tooltip.classList.add("cancel-animation")},show:function(){if(!this._showing){if(zt(this).textContent.trim()===""){for(var e=!0,t=zt(this).getEffectiveChildNodes(),r=0;r<t.length;r++)if(t[r].textContent.trim()!==""){e=!1;break}if(e)return}this._showing=!0,this.$.tooltip.classList.remove("hidden"),this.$.tooltip.classList.remove("cancel-animation"),this.$.tooltip.classList.remove(this._getAnimationType("exit")),this.updatePosition(),this._animationPlaying=!0,this.$.tooltip.classList.add(this._getAnimationType("entry"))}},hide:function(){if(!!this._showing){if(this._animationPlaying){this._showing=!1,this._cancelAnimation();return}else this._onAnimationFinish();this._showing=!1,this._animationPlaying=!0}},updatePosition:function(){if(!(!this._target||!this.offsetParent)){var e=this.offset;this.marginTop!=14&&this.offset==14&&(e=this.marginTop);var t=this.offsetParent.getBoundingClientRect(),r=this._target.getBoundingClientRect(),n=this.getBoundingClientRect(),i=(r.width-n.width)/2,o=(r.height-n.height)/2,a=r.left-t.left,s=r.top-t.top,l,c;switch(this.position){case"top":l=a+i,c=s-n.height-e;break;case"bottom":l=a+i,c=s+r.height+e;break;case"left":l=a-n.width-e,c=s+o;break;case"right":l=a+r.width+e,c=s+o;break}this.fitToVisibleBounds?(t.left+l+n.width>window.innerWidth?(this.style.right="0px",this.style.left="auto"):(this.style.left=Math.max(0,l)+"px",this.style.right="auto"),t.top+c+n.height>window.innerHeight?(this.style.bottom=t.height-s+e+"px",this.style.top="auto"):(this.style.top=Math.max(-t.top,c)+"px",this.style.bottom="auto")):(this.style.left=l+"px",this.style.top=c+"px")}},_addListeners:function(){this._target&&(this.listen(this._target,"mouseenter","show"),this.listen(this._target,"focus","show"),this.listen(this._target,"mouseleave","hide"),this.listen(this._target,"blur","hide"),this.listen(this._target,"tap","hide")),this.listen(this.$.tooltip,"animationend","_onAnimationEnd"),this.listen(this,"mouseenter","hide")},_findTarget:function(){this.manualMode||this._removeListeners(),this._target=this.target,this.manualMode||this._addListeners()},_delayChange:function(e){e!==500&&this.updateStyles({"--paper-tooltip-delay-in":e+"ms"})},_manualModeChanged:function(){this.manualMode?this._removeListeners():this._addListeners()},_cancelAnimation:function(){this.$.tooltip.classList.remove(this._getAnimationType("entry")),this.$.tooltip.classList.remove(this._getAnimationType("exit")),this.$.tooltip.classList.remove("cancel-animation"),this.$.tooltip.classList.add("hidden")},_onAnimationFinish:function(){this._showing&&(this.$.tooltip.classList.remove(this._getAnimationType("entry")),this.$.tooltip.classList.remove("cancel-animation"),this.$.tooltip.classList.add(this._getAnimationType("exit")))},_onAnimationEnd:function(){this._animationPlaying=!1,this._showing||(this.$.tooltip.classList.remove(this._getAnimationType("exit")),this.$.tooltip.classList.add("hidden"))},_getAnimationType:function(e){if(e==="entry"&&this.animationEntry!=="")return this.animationEntry;if(e==="exit"&&this.animationExit!=="")return this.animationExit;if(this.animationConfig[e]&&typeof this.animationConfig[e][0].name=="string"){if(this.animationConfig[e][0].timing&&this.animationConfig[e][0].timing.delay&&this.animationConfig[e][0].timing.delay!==0){var t=this.animationConfig[e][0].timing.delay;e==="entry"?this.updateStyles({"--paper-tooltip-delay-in":t+"ms"}):e==="exit"&&this.updateStyles({"--paper-tooltip-delay-out":t+"ms"})}return this.animationConfig[e][0].name}},_removeListeners:function(){this._target&&(this.unlisten(this._target,"mouseenter","show"),this.unlisten(this._target,"focus","show"),this.unlisten(this._target,"mouseleave","hide"),this.unlisten(this._target,"blur","hide"),this.unlisten(this._target,"tap","hide")),this.unlisten(this.$.tooltip,"animationend","_onAnimationEnd"),this.unlisten(this,"mouseenter","hide")}});var rb=Ee(Oe(),1);var mE=class{constructor(t){this.listener=t}},EW=new Set,O9=new Set;window.addEventListener("hashchange",()=>{EW.forEach(e=>e.listener())});window.addEventListener("storage",()=>{O9.forEach(e=>e.listener())});function gE(e){let t=new mE(e);return EW.add(t),t}function TW(e){let t=new mE(e);return O9.add(t),t}function CW(){O9.forEach(e=>e.listener())}function AW(e){EW.delete(e)}function PW(e){O9.delete(e)}var kW={};Ks(kW,{getFakeHash:()=>LW,setFakeHash:()=>IW,setUseHash:()=>Xbe,useHash:()=>z9});var z0t=!1;function Xbe(e){z0t=e}function z9(){return z0t}var F0t="";function IW(e){F0t=e}function LW(){return F0t}var Qx="__tab__",RW={};function B0t(){return RW}function H0t(e){RW=e}gE(()=>{RW=eb(tb())});function tb(){return z9()?window.location.hash.slice(1):LW()}function eb(e){let t={};return e.split("&").forEach(n=>{let i=n.split("=");i.length===1?t[Qx]=i[0]:i.length===2&&(t[decodeURIComponent(i[0])]=decodeURIComponent(i[1]))}),t}function F9(e,t=!1){if(z9())if(t){let r=new URL(window.location.href);r.hash=e,window.history.replaceState(window.history.state,"",r.toString())}else window.location.hash=e;else IW(e)}function B9(e){let t="";e[Qx]!==void 0&&(t+=e[Qx]);let r=Object.keys(e).map(n=>[n,e[n]]).filter(n=>n[0]!==Qx).map(n=>encodeURIComponent(n[0])+"="+encodeURIComponent(n[1])).join("&");return r.length>0?t+"&"+r:t}function V0t(e,t=!1){let r=eb(tb());delete r[e],F9(B9(r),t)}var q0t="disambiguator",{get:$be,set:Kbe,getInitializer:y_,getObserver:v_,disposeBinding:Zbe}=vE(e=>e,e=>e),{get:Jbe,set:Qbe,getInitializer:vp,getObserver:xp,disposeBinding:t2e}=vE(e=>e==="true"?!0:e==="false"?!1:void 0,e=>e.toString()),{get:NW,set:DW,getInitializer:_E,getObserver:yE,disposeBinding:e2e}=vE(e=>+e,e=>e.toString()),{get:r2e,set:n2e,getInitializer:OW,getObserver:zW,disposeBinding:i2e}=vE(e=>JSON.parse(atob(e)),e=>btoa(JSON.stringify(e)));function vE(e,t){let r=[],n=[];function i(c,u={}){let{defaultValue:h,useLocalStorage:f=!1}=u,p=f?window.localStorage.getItem(c):eb(tb())[c];return p==null?rb.cloneDeep(h):e(p)}function o(c,u,h={}){let{defaultValue:f,useLocalStorage:p=!1,useLocationReplace:d=!1}=h,g=t(u);if(p)window.localStorage.setItem(c,g),CW();else if(!rb.isEqual(u,i(c,{useLocalStorage:p})))if(rb.isEqual(u,f))V0t(c,d);else{let _=eb(tb());_[c]=g,F9(B9(_),d)}}function a(c,u){let h=Kl({defaultValue:u.defaultValue,polymerProperty:c,useLocalStorage:!1},u);return function(){let f=U0t(this,c),p=()=>{let _=i(f,h),y=this[h.polymerProperty];rb.isEqual(_,y)||(this[h.polymerProperty]=_)},g=(h.useLocalStorage?TW:gE)(()=>p());return h.useLocalStorage?n.push(g):r.push(g),p(),this[h.polymerProperty]}}function s(){r.forEach(c=>AW(c)),n.forEach(c=>PW(c))}function l(c,u){let h=Kl({defaultValue:u.defaultValue,polymerProperty:c,useLocalStorage:!1},u);return function(){let f=U0t(this,c),p=this[h.polymerProperty];o(f,p,h)}}return{get:i,set:o,getInitializer:a,getObserver:l,disposeBinding:s}}function o2e(){let e=new Set(["examplesPath","hideModelPane2","modelName1","modelName2","inferenceAddress1","inferenceAddress2","modelType","modelVersion1","modelVersion2","modelSignature1","modelSignature2","maxExamples","labelVocabPath","multiClass","sequenceExamples","maxClassesToDisplay","samplingOdds","usePredictApi","predictInputTensor","predictOutputTensor"]),t=eb(tb());if(t[Qx]==="whatif"){for(let r of e)if(r in t){let n=t[r];t[`p.whatif.${r}`]=n}}F9(B9(t)),H0t(t)}function U0t(e,t){let r=e[q0t];return(r==null?[t]:[r,t]).join(".")}var xE=class extends mt{constructor(){super(...arguments),this._tagFilter=y_("tagFilter",{defaultValue:"",useLocalStorage:!1,polymerProperty:"_tagFilter"}).call(this),this._tagFilterObserver=v_("tagFilter",{defaultValue:"",useLocalStorage:!1,polymerProperty:"_tagFilter"})}_computeTagFilter(){return this._tagFilter}};xE.template=Q`
    <paper-input
      no-label-float=""
      label="Filter tags (regular expressions supported)"
      value="{{_tagFilter}}"
      class="search-input"
    >
      <iron-icon prefix="" icon="search" slot="prefix"></iron-icon>
    </paper-input>
    <style>
      :host {
        display: block;
        margin: 10px 5px 10px 10px;
      }
    </style>
  `;E([A({type:String,notify:!0,computed:"_computeTagFilter(_tagFilter)"}),w("design:type",String)],xE.prototype,"tagFilter",void 0);E([A({type:String,observer:"_tagFilterObserver"}),w("design:type",String)],xE.prototype,"_tagFilter",void 0);xE=E([yt("tf-tag-filterer")],xE);function _s(e){let{moduleName:t,styleContent:r}=e,n=document.createElement("dom-module"),i=document.createElement("template"),o=[];e.styleDependencies&&e.styleDependencies.forEach(s=>{let l=document.createElement("style");l.setAttribute("include",s),o.push(l)});let a=document.createElement("style");Object.assign(a,{textContent:r}),o.forEach(s=>{i.content.appendChild(s)}),i.content.appendChild(a),n.appendChild(i),n.register(t)}_s({moduleName:"dashboard-style",styleDependencies:["iron-flex"],styleContent:`
      :host {
        --sidebar-vertical-padding: 15px;
        --sidebar-left-padding: 30px;
      }

      [slot='sidebar'] {
        box-sizing: border-box;
        display: flex;
        flex-direction: column;
        height: 100%;
        margin-right: 10px;
        overflow-x: hidden;
        padding: 5px 0;
        text-overflow: ellipsis;
      }

      .settings {
        min-height: 50px;
        overflow-x: hidden;
        overflow-y: auto;
        will-change: transform;
      }

      .runs-selector {
        display: flex;
        flex-grow: 1;
        min-height: 200px;
      }

      tf-runs-selector {
        flex-grow: 1;
        flex-shrink: 1;
        left: var(--sidebar-left-padding);
        max-height: calc(100% - var(--sidebar-vertical-padding) * 2);
        overflow: hidden;
        position: absolute;
        right: 0;
      }

      .search-input {
        margin: 10px 5px 0 10px;
      }

      .sidebar-section {
        border-top: solid 1px var(--tb-ui-border);
        margin-right: 10px;
        padding: var(--sidebar-vertical-padding) 0
          var(--sidebar-vertical-padding) var(--sidebar-left-padding);
        position: relative;
        overflow: hidden;
      }

      .sidebar-section:first-of-type {
        border: none;
      }

      .sidebar-section paper-button {
        margin: 5px;
      }

      .sidebar-section paper-button:first-of-type {
        margin-left: 0 !important;
      }

      .sidebar-section paper-button:last-of-type {
        margin-right: 0 !important;
      }

      .sidebar-section > :first-child {
        margin-top: 0;
        padding-top: 0;
      }

      .sidebar-section > :last-child {
        margin-bottom: 0;
        padding-bottom: 0;
      }

      .sidebar-section h3 {
        color: var(--tb-secondary-text-color);
        display: block;
        font-size: 14px;
        font-weight: normal;
        margin: 10px 0 5px;
        pointer-events: none;
      }

      paper-checkbox {
        --paper-checkbox-checked-color: var(--tb-ui-dark-accent);
        --paper-checkbox-unchecked-color: var(--tb-ui-dark-accent);
        font-size: 15px;
        margin-top: 5px;
      }

      a {
        color: var(--tb-link);
      }

      a:visited {
        color: var(--tb-link-visited);
      }
  `});function _o(e){return class extends e{connectedCallback(){super.connectedCallback(),this._maybeSetDarkMode(),this.observer=new MutationObserver(r=>{r.some(i=>i.attributeName==="class")&&this._maybeSetDarkMode()}),this.observer.observe(document.body,{attributes:!0})}disconnectedCallback(){var r;super.disconnectedCallback(),(r=this.observer)==null||r.disconnect()}_maybeSetDarkMode(){this.classList.toggle("dark-mode",document.body.classList.contains("dark-mode"))}}}_s({moduleName:"scrollbar-style",styleContent:`
    .scrollbar::-webkit-scrollbar-track {
      visibility: hidden;
    }

    .scrollbar::-webkit-scrollbar {
      width: 10px;
    }

    .scrollbar::-webkit-scrollbar-thumb {
      border-radius: 10px;
      -webkit-box-shadow: inset 0 0 2px rgba(0, 0, 0, 0.3);
      background-color: var(--paper-grey-500);
      color: var(--paper-grey-900);
    }
    .scrollbar {
      box-sizing: border-box;
    }
  `});var BW=document.createElement("style");BW.setAttribute("is","custom-style");BW.textContent=`
  :root {
    --tb-orange-weak: #ffa726;
    --tb-orange-strong: #f57c00;
    --tb-orange-dark: #dc7320;
    --tb-grey-darker: #e2e2e2;
    --tb-grey-lighter: #f3f3f3;
    --tb-ui-dark-accent: #757575;
    --tb-ui-light-accent: #e0e0e0;
    --tb-ui-border: var(--paper-grey-300);
    --tb-graph-faded: #e0d4b3;
    --tb-secondary-text-color: var(--paper-grey-800);
    --tb-raised-button-shadow-color: rgba(0, 0, 0, 0.2);
    --primary-background-color: #fff;
    --secondary-background-color: #e9e9e9;
    --tb-layout-background-color: #f5f5f5;
    --tb-link: #1976d2; /* material blue 700. */
    --tb-link-visited: #7b1fa2; /* material purple 700. */
  }

  :root .dark-mode {
    --tb-ui-border: var(--paper-grey-700);
    --tb-ui-dark-accent: var(--paper-grey-400);
    --tb-ui-light-accent: var(--paper-grey-600);
    --tb-secondary-text-color: var(--paper-grey-400);
    --tb-raised-button-shadow-color: rgba(255, 255, 255, 0.5);
    --primary-text-color: #fff;
    --secondary-text-color: var(--paper-grey-400);
    --primary-background-color: #303030;  /* material grey A400. */
    --secondary-background-color: #3a3a3a;
    --tb-layout-background-color: #3a3a3a;
    --tb-link: #42a5f5; /* material blue 400. */
    --tb-link-visited: #ba68c8; /* material purple 300. */
    /* Overrides paper-material */
    --shadow-elevation-2dp_-_box-shadow: 0 2px 2px 0 rgba(255, 255, 255, 0.14),
      0 1px 5px 0 rgba(255, 255, 255, 0.12),
      0 3px 1px -2px rgba(255, 255, 255, 0.2);
  }
`;document.head.appendChild(BW);var HW=class extends _o(mt){};HW.template=Q`
    <div id="sidebar">
      <slot name="sidebar"></slot>
    </div>

    <div id="center">
      <slot name="center" class="scollbar"></slot>
    </div>
    <style include="scrollbar-style"></style>
    <style>
      :host {
        background-color: #f5f5f5;
        display: flex;
        flex-direction: row;
        height: 100%;
      }

      :host(.dark-mode) {
        background-color: var(--secondary-background-color);
      }

      #sidebar {
        flex: 0 0 var(--tf-dashboard-layout-sidebar-basis, 25%);
        height: 100%;
        max-width: var(--tf-dashboard-layout-sidebar-max-width, 350px);
        min-width: var(--tf-dashboard-layout-sidebar-min-width, 270px);
        overflow-y: auto;
        text-overflow: ellipsis;
      }

      #center {
        flex-grow: 1;
        flex-shrink: 1;
        height: 100%;
        overflow: hidden;
      }

      ::slotted([slot='center']) {
        contain: strict;
        height: 100%;
        overflow-x: hidden;
        overflow-y: auto;
        width: 100%;
        will-change: transform;
      }

      .tf-graph-dashboard #center {
        background: #fff;
      }
    </style>
  `;HW=E([yt("tf-dashboard-layout")],HW);var G0t="TF.TensorBoard.PaginatedView.limit",a2e=12,Ah=null,VW=new Set;function UW(e){VW.add(e)}function qW(e){VW.delete(e)}function GW(){return Ah==null&&(Ah=NW(G0t,{useLocalStorage:!0}),(Ah==null||!isFinite(Ah)||Ah<=0)&&(Ah=a2e)),Ah}function s2e(e){if(e!==Math.floor(e))throw new Error(`limit must be an integer, but got: ${e}`);if(e<=0)throw new Error(`limit must be positive, but got: ${e}`);e!==Ah&&(Ah=e,DW(G0t,Ah,{useLocalStorage:!0}),VW.forEach(t=>{t()}))}var nb=class extends mt{updateArrayProp(t,r,n){let i=this.get(t),o=r;if(!Array.isArray(o))throw RangeError(`Expected new value to '${t}' to be an array.`);Array.isArray(i)||(i=[],this.set(t,i));let a=new Set(o.map((c,u)=>n(c,u))),s=0,l=0;for(;s<i.length&&l<o.length;){if(a.has(n(i[s],s)))n(i[s],s)==n(o[l],l)?this.set(`${t}.${s}`,o[l]):this.splice(t,s,0,o[l]);else{this.splice(t,s,1);continue}l++,s++}s<i.length&&this.splice(t,s),l<o.length&&this.push(t,...o.slice(l))}};var Oi=class extends nb{constructor(){super(...arguments),this.as="item",this._contentActive=!0,this._domBootstrapped=!1,this._ctor=null,this._renderedItems=[],this._renderedTemplateInst=new Map,this._lruCachedItems=new Map,this._cacheSize=10,this._getItemKey=t=>JSON.stringify(t),this._isConnected=!1}connectedCallback(){super.connectedCallback(),this._isConnected=!0}setCacheSize(t){this._cacheSize=t}setGetItemKey(t){this._getItemKey=t}updateDom(t){this.updateArrayProp("_renderedItems",t,this._getItemKey)}_ensureTemplatized(){if(!this.isConnected)return!1;if(!this._ctor){let t=this.querySelector("template");this._ctor=tc(t,this,{parentModel:!0,instanceProps:{[this.as]:!0,active:this._contentActive},forwardHostProp:function(r,n){this._renderedTemplateInst.forEach(i=>{i.forwardHostProp(r,n)})}})}return!0}_bootstrapDom(){if(!this._ensureTemplatized()||this._domBootstrapped)return;new MutationObserver(r=>{for(let n of r)if(n.type==="childList")for(let i of Array.from(n.addedNodes))i instanceof Element&&i.setAttribute("slot","items")}).observe(this,{childList:!0}),Array.from(this.children).forEach(r=>{this.removeChild(r)}),this._lruCachedItems.clear(),this._renderedItems.forEach((r,n)=>this._insertItem(r,n)),this._domBootstrapped=!0}_updateActive(){!this._domBootstrapped||Array.from(this._renderedTemplateInst.values()).forEach(t=>{t.notifyPath("active",this._contentActive)})}_updateDom(t){if(!!this._domBootstrapped&&!(t.path=="_renderedItems"||t.path=="_renderedItems.length"))if(t.path==="_renderedItems.splices")t.value.indexSplices.forEach(n=>{let{index:i,addedCount:o,object:a,removed:s}=n;s.forEach(l=>{this._removeItem(l,this.children[i])}),a.slice(i,i+o).forEach((l,c)=>this._insertItem(l,i+c)),this._trimCache()});else{let r=this._getItemKey(t.value);this._renderedTemplateInst.has(r)?this._renderedTemplateInst.get(r).notifyPath(this.as,t.value):console.warn(`Expected '${r}' to exist in the DOM but could not find one.`)}}_insertItem(t,r){if(!this._ensureTemplatized())throw new Error("Expected templatized before inserting an item");let n,i=this._getItemKey(t);if(this._lruCachedItems.has(i))n=this._lruCachedItems.get(i),this._lruCachedItems.delete(i),this._renderedTemplateInst.get(i).notifyPath("active",this._contentActive);else{let o={[this.as]:t,active:this._contentActive},a=new this._ctor(o);n=a.root,this._renderedTemplateInst.set(i,a)}this.children[r]?this.insertBefore(n,this.children[r]):((n.nodeType==Node.DOCUMENT_FRAGMENT_NODE?Array.from(n.children):[n]).forEach(a=>a.setAttribute("slot","items")),this.appendChild(n))}_removeItem(t,r){r.parentNode&&r.parentNode.removeChild(r);let n=this._getItemKey(t);this._lruCachedItems.set(n,r),this._renderedTemplateInst.get(n).notifyPath("active",!1)}_trimCache(){for(;this._lruCachedItems.size>this._cacheSize;){let[t]=this._lruCachedItems.keys();this._lruCachedItems.delete(t),this._renderedTemplateInst.delete(t)}}};E([A({type:String}),w("design:type",Object)],Oi.prototype,"as",void 0);E([A({type:Array}),w("design:type",Array)],Oi.prototype,"items",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Oi.prototype,"_contentActive",void 0);E([A({type:Boolean}),w("design:type",Object)],Oi.prototype,"_domBootstrapped",void 0);E([A({type:Object}),w("design:type",Object)],Oi.prototype,"_ctor",void 0);E([A({type:Array}),w("design:type",Array)],Oi.prototype,"_renderedItems",void 0);E([A({type:Object}),w("design:type",Object)],Oi.prototype,"_renderedTemplateInst",void 0);E([A({type:Object}),w("design:type",Object)],Oi.prototype,"_lruCachedItems",void 0);E([A({type:Number}),w("design:type",Object)],Oi.prototype,"_cacheSize",void 0);E([A({type:Object}),w("design:type",Object)],Oi.prototype,"_getItemKey",void 0);E([A({type:Boolean}),w("design:type",Object)],Oi.prototype,"_isConnected",void 0);E([Bt("_isConnected"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Oi.prototype,"_bootstrapDom",null);E([Bt("_contentActive"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Oi.prototype,"_updateActive",null);E([Bt("_renderedItems.*","_domBootstrapped"),w("design:type",Function),w("design:paramtypes",[Object]),w("design:returntype",void 0)],Oi.prototype,"_updateDom",null);E([Bt("_cacheSize"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Oi.prototype,"_trimCache",null);var hn=class extends Oi{constructor(){super(...arguments),this.disablePagination=!1,this.getCategoryItemKey=t=>JSON.stringify(t),this._limit=12,this._activeIndex=0,this._pageInputRawValue="",this._pageInputFocused=!1}_computeCount(){return this.category.items.length}get _hasMultiple(){return this._count>1}_togglePane(){this.opened=!this.opened}_changeContentActive(t){this._contentActive=t}_onPaneRenderedChanged(t,r){t&&t!==r&&this.$.ifRendered.render()}_computePaneRendered(t){return!(t.metadata.type===Na.SEARCH_RESULTS&&t.name==="")}get _itemsRendered(){return this._paneRendered&&this.opened}_computeIsSearchResults(t){return t===Na.SEARCH_RESULTS}_computeIsInvalidSearchResults(t){return t.type===Na.SEARCH_RESULTS&&!t.validRegex}_computeIsUniversalSearchQuery(t){return t.type===Na.SEARCH_RESULTS&&t.universalRegex}_isCompositeSearch(){let{type:t,compositeSearch:r}=this.category.metadata;return r&&t===Na.SEARCH_RESULTS}ready(){super.ready(),this.opened=this.initialOpened==null?!0:this.initialOpened,this._limitListener=()=>{this.set("_limit",GW())},UW(this._limitListener),this._limitListener()}detached(){qW(this._limitListener)}_updateRenderedItems(){var t=this._itemsRendered,r=this._limit,n=this._activeIndex,i=this.disablePagination;if(!t)return;let o=Math.floor(n/r),a=this.category.items||[],s=i?a:a.slice(o*r,(o+1)*r);this.updateDom(s)}_limitChanged(t){this.setCacheSize(t*2)}_getCategoryItemKeyChanged(){this.setGetItemKey(this.getCategoryItemKey)}get _currentPage(){var t=this._limit,r=this._activeIndex;return Math.floor(r/t)+1}_computePageCount(t,r){return this.category?Math.ceil(this.category.items.length/r):0}get _multiplePagesExist(){var t=this._pageCount,r=this.disablePagination;return!r&&t>1}get _hasPreviousPage(){var t=this._currentPage;return t>1}get _hasNextPage(){var t=this._currentPage,r=this._pageCount;return t<r}_computeInputWidth(t){return`calc(${t.toString().length}em + 20px)`}_setActiveIndex(t){let r=(this.category.items||[]).length-1;t>r&&(t=r),t<0&&(t=0),this.set("_activeIndex",t)}_clampActiveIndex(){this._setActiveIndex(this._activeIndex)}_performPreviousPage(){this._setActiveIndex(this._activeIndex-this._limit)}_performNextPage(){this._setActiveIndex(this._activeIndex+this._limit)}_computePageInputValue(t,r,n){return t?r:n.toString()}_handlePageInputEvent(t){this.set("_pageInputRawValue",t.target.value);let r=Number(t.target.value||NaN);if(isNaN(r))return;let n=Math.max(1,Math.min(r,this._pageCount))-1;this._setActiveIndex(this._limit*n)}_handlePageChangeEvent(){this.set("_pageInputRawValue",this._currentPage.toString())}_handlePageFocusEvent(){this.set("_pageInputRawValue",this._pageInputValue),this.set("_pageInputFocused",!0)}_handlePageBlurEvent(){this.set("_pageInputFocused",!1)}_updatePageInputValue(t){var n;let r=(n=this.shadowRoot)==null?void 0:n.querySelector("#page-input input");r&&(r.value=t)}_updateInputWidth(){this.updateStyles({"--tf-category-paginated-view-page-input-width":this._inputWidth})}};hn.template=Q`
    <template is="dom-if" if="[[_paneRendered]]" id="ifRendered">
      <button class="heading" on-tap="_togglePane" open-button$="[[opened]]">
        <span class="name">
          <template is="dom-if" if="[[_isSearchResults]]">
            <template is="dom-if" if="[[_isCompositeSearch(category)]]">
              <span>Tags matching multiple experiments</span>
              <template is="dom-if" if="[[_isInvalidSearchResults]]">
                <span
                  >&nbsp;<strong>(malformed regular expression)</strong></span
                >
              </template>
            </template>
            <template is="dom-if" if="[[!_isCompositeSearch(category)]]">
              <span class="light">Tags matching /</span>
              <span class="category-name" title$="[[category.name]]"
                >[[category.name]]</span
              >
              <span class="light">/</span>
              <template is="dom-if" if="[[_isUniversalSearchQuery]]">
                <span> (all tags)</span>
              </template>
              <template is="dom-if" if="[[_isInvalidSearchResults]]">
                <span> <strong>(malformed regular expression)</strong></span>
              </template>
            </template>
          </template>
          <template is="dom-if" if="[[!_isSearchResults]]">
            <span class="category-name" title$="[[category.name]]"
              >[[category.name]]</span
            >
          </template>
        </span>
        <span class="count">
          <template is="dom-if" if="[[_hasMultiple]]">
            <span>[[_count]]</span>
          </template>
          <iron-icon icon="expand-more" class="expand-arrow"></iron-icon>
        </span>
      </button>
      <!-- TODO(stephanwlee): investigate further. For some reason,
        transitionend that the iron-collapse relies on sometimes does not
        trigger when rendering a chart with a spinner. A toy example cannot
        reproduce this bug. -->
      <iron-collapse opened="[[opened]]" no-animation="">
        <div class="content">
          <span id="top-of-container"></span>
          <template is="dom-if" if="[[_multiplePagesExist]]">
            <div class="big-page-buttons" style="margin-bottom: 10px;">
              <paper-button
                on-tap="_performPreviousPage"
                disabled$="[[!_hasPreviousPage]]"
                >Previous page</paper-button
              >
              <paper-button
                on-tap="_performNextPage"
                disabled$="[[!_hasNextPage]]"
                >Next page</paper-button
              >
            </div>
          </template>

          <div id="items">
            <slot name="items"></slot>
          </div>
          <template is="dom-if" if="[[_multiplePagesExist]]">
            <div id="controls-container">
              <div style="display: inline-block; padding: 0 5px">
                Page
                <paper-input
                  id="page-input"
                  type="number"
                  no-label-float=""
                  min="1"
                  max="[[_pageCount]]"
                  value="[[_pageInputValue]]"
                  on-input="_handlePageInputEvent"
                  on-change="_handlePageChangeEvent"
                  on-focus="_handlePageFocusEvent"
                  on-blur="_handlePageBlurEvent"
                ></paper-input>
                of [[_pageCount]]
              </div>
            </div>

            <div class="big-page-buttons" style="margin-top: 10px;">
              <paper-button
                on-tap="_performPreviousPage"
                disabled$="[[!_hasPreviousPage]]"
                >Previous page</paper-button
              >
              <paper-button
                on-tap="_performNextPage"
                disabled$="[[!_hasNextPage]]"
                >Next page</paper-button
              >
            </div>
          </template>
        </div>
      </iron-collapse>
    </template>
    <style>
      :host {
        display: block;
        margin: 0 5px 1px 10px;
      }

      :host(:first-of-type) {
        margin-top: 10px;
      }

      :host(:last-of-type) {
        margin-bottom: 20px;
      }

      .heading {
        background-color: var(--primary-background-color);
        border: none;
        color: inherit;
        cursor: pointer;
        width: 100%;
        font-size: 15px;
        line-height: 1;
        box-shadow: 0 1px 5px var(--tb-raised-button-shadow-color);
        padding: 10px 15px;
        display: flex;
        align-items: center;
        justify-content: space-between;
      }

      .heading::-moz-focus-inner {
        padding: 10px 15px;
      }

      [open-button] {
        border-bottom-left-radius: 0 !important;
        border-bottom-right-radius: 0 !important;
      }

      [open-button] .expand-arrow {
        transform: rotateZ(180deg);
      }

      .name {
        display: inline-flex;
        overflow: hidden;
      }

      .light {
        color: var(--paper-grey-500);
      }

      .category-name {
        white-space: pre;
        overflow: hidden;
        text-overflow: ellipsis;
        padding: 2px 0;
      }

      .count {
        margin: 0 5px;
        font-size: 12px;
        color: var(--paper-grey-500);
        display: flex;
        align-items: center;
        flex: none;
      }

      .heading::-moz-focus-inner {
        padding: 10px 15px;
      }

      .content {
        display: flex;
        flex-direction: column;
        background-color: var(--primary-background-color);
        border-bottom-left-radius: 2px;
        border-bottom-right-radius: 2px;
        border-top: none;
        border: 1px solid #dedede;
        padding: 15px;
      }

      .light {
        color: var(--paper-grey-500);
      }

      #controls-container {
        justify-content: center;
        display: flex;
        flex-direction: row;
        flex-grow: 0;
        flex-shrink: 0;
        width: 100%;
      }

      #controls-container paper-button {
        display: inline-block;
      }

      .big-page-buttons {
        display: flex;
      }

      .big-page-buttons paper-button {
        background-color: var(--tb-ui-light-accent);
        color: var(--tb-ui-dark-accent);
        display: inline-block;
        flex-basis: 0;
        flex-grow: 1;
        flex-shrink: 1;
        font-size: 13px;
      }

      .big-page-buttons paper-button[disabled] {
        background: none;
      }

      slot {
        display: flex;
        flex-direction: row;
        flex-wrap: wrap;
      }

      ::slotted([slot='items']) {
        /* Tooltip for descriptions and others break with more strict ones. */
        contain: style;
      }

      #page-input {
        display: inline-block;
        width: var(--tf-category-paginated-view-page-input-width, 100%);
      }
    </style>
  `;E([A({type:Object}),w("design:type",Object)],hn.prototype,"category",void 0);E([A({type:Boolean}),w("design:type",Boolean)],hn.prototype,"initialOpened",void 0);E([A({type:Boolean,notify:!0}),w("design:type",Boolean)],hn.prototype,"opened",void 0);E([A({type:Boolean}),w("design:type",Boolean)],hn.prototype,"disablePagination",void 0);E([A({type:Number,computed:"_computeCount(category.items.*)"}),w("design:type",Number)],hn.prototype,"_count",void 0);E([A({type:Boolean,computed:"_computePaneRendered(category)",observer:"_onPaneRenderedChanged"}),w("design:type",Boolean)],hn.prototype,"_paneRendered",void 0);E([A({type:Boolean,computed:"_computeIsSearchResults(category.metadata.type)"}),w("design:type",Boolean)],hn.prototype,"_isSearchResults",void 0);E([A({type:Boolean,computed:"_computeIsInvalidSearchResults(category.metadata)"}),w("design:type",Boolean)],hn.prototype,"_isInvalidSearchResults",void 0);E([A({type:Boolean,computed:"_computeIsUniversalSearchQuery(category.metadata)"}),w("design:type",Boolean)],hn.prototype,"_isUniversalSearchQuery",void 0);E([A({type:Object,observer:"_getCategoryItemKeyChanged"}),w("design:type",Object)],hn.prototype,"getCategoryItemKey",void 0);E([A({type:Number,observer:"_limitChanged"}),w("design:type",Number)],hn.prototype,"_limit",void 0);E([A({type:Number}),w("design:type",Number)],hn.prototype,"_activeIndex",void 0);E([A({type:Number,computed:"_computePageCount(category.items.*, _limit)"}),w("design:type",Number)],hn.prototype,"_pageCount",void 0);E([A({type:String,computed:"_computeInputWidth(_pageCount)",observer:"_updateInputWidth"}),w("design:type",String)],hn.prototype,"_inputWidth",void 0);E([A({type:String,computed:"_computePageInputValue(_pageInputFocused, _pageInputRawValue, _currentPage)",observer:"_updatePageInputValue"}),w("design:type",String)],hn.prototype,"_pageInputValue",void 0);E([A({type:String}),w("design:type",String)],hn.prototype,"_pageInputRawValue",void 0);E([A({type:Boolean}),w("design:type",Boolean)],hn.prototype,"_pageInputFocused",void 0);E([Rt("_count"),w("design:type",Boolean),w("design:paramtypes",[])],hn.prototype,"_hasMultiple",null);E([Bt("opened"),w("design:type",Function),w("design:paramtypes",[Boolean]),w("design:returntype",void 0)],hn.prototype,"_changeContentActive",null);E([Rt("opened","_paneRendered"),w("design:type",Boolean),w("design:paramtypes",[])],hn.prototype,"_itemsRendered",null);E([Bt("_itemsRendered","category.items.*","_limit","_activeIndex","_pageCount","disablePagination"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],hn.prototype,"_updateRenderedItems",null);E([Rt("_limit","_activeIndex"),w("design:type",Number),w("design:paramtypes",[])],hn.prototype,"_currentPage",null);E([Rt("_pageCount","disablePagination"),w("design:type",Boolean),w("design:paramtypes",[])],hn.prototype,"_multiplePagesExist",null);E([Rt("_currentPage"),w("design:type",Boolean),w("design:paramtypes",[])],hn.prototype,"_hasPreviousPage",null);E([Rt("_currentPage","_pageCount"),w("design:type",Boolean),w("design:paramtypes",[])],hn.prototype,"_hasNextPage",null);E([Bt("category.items.*"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],hn.prototype,"_clampActiveIndex",null);hn=E([yt("tf-category-paginated-view")],hn);var W0t=Ee(Oe(),1);var H9=class{constructor(t){this.listener=t}},bp=class{constructor(){this.requestManager=new Ae(1),this._listeners=new Set,this.initialized=!1}refresh(){return this.load().then(()=>{this.initialized=!0})}addListener(t){let r=new H9(t);return this._listeners.add(r),r}removeListenerByKey(t){this._listeners.delete(t)}emitChange(){this._listeners.forEach(t=>{try{t.listener()}catch(r){}})}};var V9=class extends bp{load(){let t=_e().environment();return this.requestManager.request(t).then(r=>{let n={dataLocation:r.data_location,windowTitle:r.window_title};r.experiment_name!==void 0&&(n.experimentName=r.experiment_name),r.experiment_description!==void 0&&(n.experimentDescription=r.experiment_description),r.creation_time!==void 0&&(n.creationTime=r.creation_time),!W0t.isEqual(this.environment,n)&&(this.environment=n,this.emitChange())})}getDataLocation(){return this.environment?this.environment.dataLocation:""}getWindowTitle(){return this.environment?this.environment.windowTitle:""}getExperimentName(){return this.environment?this.environment.experimentName:""}getExperimentDescription(){return this.environment?this.environment.experimentDescription:""}getCreationTime(){return this.environment?this.environment.creationTime:null}},ib=new V9;var Y0t=Ee(Oe(),1);var U9=class extends bp{constructor(){super(...arguments),this._runs=[]}load(){let t=_e().runs();return this.requestManager.request(t).then(r=>{Y0t.isEqual(this._runs,r)||(this._runs=r,this.emitChange())})}getRuns(){return this._runs.slice()}},wp=new U9;var Vr={};Ks(Vr,{FormatSpecifier:()=>GE,active:()=>Vvt,arc:()=>BSt,area:()=>z8,areaRadial:()=>o$,ascending:()=>oa,autoType:()=>ij,axisBottom:()=>Z9,axisLeft:()=>lb,axisRight:()=>m_t,axisTop:()=>d_t,bisect:()=>ys,bisectLeft:()=>$0t,bisectRight:()=>WW,bisector:()=>ob,blob:()=>D1t,brush:()=>GL,brushSelection:()=>UL,brushX:()=>jvt,brushY:()=>qL,buffer:()=>O1t,chord:()=>$vt,clientPoint:()=>Dm,cluster:()=>Wbt,color:()=>rc,contourDensity:()=>g1t,contours:()=>ZL,create:()=>syt,creator:()=>Rm,cross:()=>q9,csv:()=>F1t,csvFormat:()=>b1t,csvFormatBody:()=>w1t,csvFormatRow:()=>M1t,csvFormatRows:()=>S1t,csvFormatValue:()=>E1t,csvParse:()=>Cb,csvParseRows:()=>x1t,cubehelix:()=>la,curveBasis:()=>W8,curveBasisClosed:()=>QSt,curveBasisOpen:()=>e3t,curveBundle:()=>n3t,curveCardinal:()=>i3t,curveCardinalClosed:()=>o3t,curveCardinalOpen:()=>a3t,curveCatmullRom:()=>l3t,curveCatmullRomClosed:()=>u3t,curveCatmullRomOpen:()=>f3t,curveLinear:()=>Yh,curveLinearClosed:()=>d3t,curveMonotoneX:()=>x3t,curveMonotoneY:()=>b3t,curveNatural:()=>M3t,curveStep:()=>E3t,curveStepAfter:()=>C3t,curveStepBefore:()=>T3t,customEvent:()=>Mp,descending:()=>Z0t,deviation:()=>W9,dispatch:()=>vs,drag:()=>pb,dragDisable:()=>zm,dragEnable:()=>Fm,dsv:()=>oj,dsvFormat:()=>Wm,easeBack:()=>OL,easeBackIn:()=>OY,easeBackInOut:()=>OL,easeBackOut:()=>zY,easeBounce:()=>P_,easeBounceIn:()=>RY,easeBounceInOut:()=>NY,easeBounceOut:()=>P_,easeCircle:()=>NL,easeCircleIn:()=>IY,easeCircleInOut:()=>NL,easeCircleOut:()=>LY,easeCubic:()=>xs,easeCubicIn:()=>xY,easeCubicInOut:()=>xs,easeCubicOut:()=>bY,easeElastic:()=>zL,easeElasticIn:()=>HY,easeElasticInOut:()=>VY,easeElasticOut:()=>zL,easeExp:()=>RL,easeExpIn:()=>AY,easeExpInOut:()=>RL,easeExpOut:()=>PY,easeLinear:()=>_Y,easePoly:()=>LL,easePolyIn:()=>SY,easePolyInOut:()=>LL,easePolyOut:()=>MY,easeQuad:()=>IL,easeQuadIn:()=>yY,easeQuadInOut:()=>IL,easeQuadOut:()=>vY,easeSin:()=>kL,easeSinIn:()=>EY,easeSinInOut:()=>kL,easeSinOut:()=>TY,entries:()=>u1t,event:()=>qt,extent:()=>aa,forceCenter:()=>W1t,forceCollide:()=>uxt,forceLink:()=>fxt,forceManyBody:()=>gxt,forceRadial:()=>_xt,forceSimulation:()=>mxt,forceX:()=>yxt,forceY:()=>vxt,format:()=>xn,formatDefaultLocale:()=>nk,formatLocale:()=>ek,formatPrefix:()=>WE,formatSpecifier:()=>Lp,geoAlbers:()=>Uk,geoAlbersUsa:()=>Lbt,geoArea:()=>Nxt,geoAzimuthalEqualArea:()=>kbt,geoAzimuthalEqualAreaRaw:()=>Gk,geoAzimuthalEquidistant:()=>Rbt,geoAzimuthalEquidistantRaw:()=>Wk,geoBounds:()=>Uxt,geoCentroid:()=>Xxt,geoCircle:()=>Qxt,geoClipAntimeridian:()=>e5,geoClipCircle:()=>Ak,geoClipExtent:()=>rbt,geoClipRectangle:()=>Dp,geoConicConformal:()=>Dbt,geoConicConformalRaw:()=>jj,geoConicEqualArea:()=>W_,geoConicEqualAreaRaw:()=>Wj,geoConicEquidistant:()=>zbt,geoConicEquidistantRaw:()=>Xj,geoContains:()=>cbt,geoDistance:()=>Nb,geoEqualEarth:()=>Fbt,geoEqualEarthRaw:()=>Xk,geoEquirectangular:()=>Obt,geoEquirectangularRaw:()=>j_,geoGnomonic:()=>Bbt,geoGnomonicRaw:()=>$k,geoGraticule:()=>Nk,geoGraticule10:()=>fbt,geoIdentity:()=>Hbt,geoInterpolate:()=>pbt,geoLength:()=>kk,geoMercator:()=>Nbt,geoMercatorRaw:()=>Y_,geoNaturalEarth1:()=>Vbt,geoNaturalEarth1Raw:()=>Kk,geoOrthographic:()=>Ubt,geoOrthographicRaw:()=>Zk,geoPath:()=>Tbt,geoProjection:()=>Si,geoProjectionMutator:()=>l5,geoRotation:()=>wk,geoStereographic:()=>qbt,geoStereographicRaw:()=>Jk,geoStream:()=>vo,geoTransform:()=>Cbt,geoTransverseMercator:()=>Gbt,geoTransverseMercatorRaw:()=>Qk,gray:()=>Syt,hcl:()=>gb,hierarchy:()=>p5,histogram:()=>r_t,hsl:()=>Vm,html:()=>q1t,image:()=>H1t,interpolate:()=>nc,interpolateArray:()=>Dyt,interpolateBasis:()=>lL,interpolateBasisClosed:()=>cL,interpolateBlues:()=>xSt,interpolateBrBG:()=>Qwt,interpolateBuGn:()=>lSt,interpolateBuPu:()=>cSt,interpolateCividis:()=>TSt,interpolateCool:()=>PSt,interpolateCubehelix:()=>Jyt,interpolateCubehelixDefault:()=>CSt,interpolateCubehelixLong:()=>E_,interpolateDate:()=>fL,interpolateDiscrete:()=>Oyt,interpolateGnBu:()=>uSt,interpolateGreens:()=>bSt,interpolateGreys:()=>wSt,interpolateHcl:()=>$yt,interpolateHclLong:()=>Kyt,interpolateHsl:()=>Yyt,interpolateHslLong:()=>jyt,interpolateHue:()=>zyt,interpolateInferno:()=>DSt,interpolateLab:()=>M_,interpolateMagma:()=>NSt,interpolateNumber:()=>zi,interpolateNumberArray:()=>yb,interpolateObject:()=>pL,interpolateOrRd:()=>hSt,interpolateOranges:()=>ESt,interpolatePRGn:()=>tSt,interpolatePiYG:()=>eSt,interpolatePlasma:()=>OSt,interpolatePuBu:()=>pSt,interpolatePuBuGn:()=>fSt,interpolatePuOr:()=>rSt,interpolatePuRd:()=>dSt,interpolatePurples:()=>SSt,interpolateRainbow:()=>ISt,interpolateRdBu:()=>nSt,interpolateRdGy:()=>iSt,interpolateRdPu:()=>mSt,interpolateRdYlBu:()=>oSt,interpolateRdYlGn:()=>aSt,interpolateReds:()=>MSt,interpolateRgb:()=>qm,interpolateRgbBasis:()=>uL,interpolateRgbBasisClosed:()=>Nyt,interpolateRound:()=>dL,interpolateSinebow:()=>LSt,interpolateSpectral:()=>sSt,interpolateString:()=>vb,interpolateTransformCss:()=>_L,interpolateTransformSvg:()=>yL,interpolateTurbo:()=>kSt,interpolateViridis:()=>RSt,interpolateWarm:()=>ASt,interpolateYlGn:()=>_St,interpolateYlGnBu:()=>gSt,interpolateYlOrBr:()=>ySt,interpolateYlOrRd:()=>vSt,interpolateZoom:()=>vL,interrupt:()=>hu,interval:()=>nvt,isoFormat:()=>Fwt,isoParse:()=>Bwt,json:()=>V1t,keys:()=>$L,lab:()=>w_,lch:()=>Eyt,line:()=>vu,lineRadial:()=>i$,linkHorizontal:()=>WSt,linkRadial:()=>jSt,linkVertical:()=>YSt,local:()=>eL,map:()=>Ji,matcher:()=>ub,max:()=>lu,mean:()=>o_t,median:()=>a_t,merge:()=>Im,min:()=>Lm,mouse:()=>zo,namespace:()=>Ph,namespaces:()=>SE,nest:()=>r1t,now:()=>Ap,pack:()=>d2t,packEnclose:()=>e8,packSiblings:()=>u2t,pairs:()=>K0t,partition:()=>m2t,path:()=>bs,permute:()=>s_t,pie:()=>qSt,piecewise:()=>dY,pointRadial:()=>ly,polygonArea:()=>M2t,polygonCentroid:()=>E2t,polygonContains:()=>P2t,polygonHull:()=>A2t,polygonLength:()=>I2t,precisionFixed:()=>ik,precisionPrefix:()=>ok,precisionRound:()=>ak,quadtree:()=>zh,quantile:()=>sa,quantize:()=>Qyt,radialArea:()=>o$,radialLine:()=>i$,randomBates:()=>R2t,randomExponential:()=>N2t,randomIrwinHall:()=>s8,randomLogNormal:()=>k2t,randomNormal:()=>a8,randomUniform:()=>L2t,range:()=>Ir,rgb:()=>cu,ribbon:()=>Jvt,scaleBand:()=>Qm,scaleDiverging:()=>I8,scaleDivergingLog:()=>CX,scaleDivergingPow:()=>L8,scaleDivergingSqrt:()=>qwt,scaleDivergingSymlog:()=>AX,scaleIdentity:()=>u8,scaleImplicit:()=>l8,scaleLinear:()=>On,scaleLog:()=>cc,scaleOrdinal:()=>gu,scalePoint:()=>tg,scalePow:()=>K_,scaleQuantile:()=>eg,scaleQuantize:()=>qb,scaleSequential:()=>T8,scaleSequentialLog:()=>EX,scaleSequentialPow:()=>C8,scaleSequentialQuantile:()=>A8,scaleSequentialSqrt:()=>Uwt,scaleSequentialSymlog:()=>TX,scaleSqrt:()=>Y2t,scaleSymlog:()=>f8,scaleThreshold:()=>p8,scaleTime:()=>Yb,scaleUtc:()=>Vwt,scan:()=>l_t,schemeAccent:()=>Gwt,schemeBlues:()=>KX,schemeBrBG:()=>PX,schemeBuGn:()=>FX,schemeBuPu:()=>BX,schemeCategory10:()=>jb,schemeDark2:()=>Wwt,schemeGnBu:()=>HX,schemeGreens:()=>ZX,schemeGreys:()=>JX,schemeOrRd:()=>VX,schemeOranges:()=>e$,schemePRGn:()=>IX,schemePaired:()=>Ywt,schemePastel1:()=>jwt,schemePastel2:()=>Xwt,schemePiYG:()=>LX,schemePuBu:()=>qX,schemePuBuGn:()=>UX,schemePuOr:()=>kX,schemePuRd:()=>GX,schemePurples:()=>QX,schemeRdBu:()=>RX,schemeRdGy:()=>NX,schemeRdPu:()=>WX,schemeRdYlBu:()=>DX,schemeRdYlGn:()=>OX,schemeReds:()=>t$,schemeSet1:()=>$wt,schemeSet2:()=>Kwt,schemeSet3:()=>Zwt,schemeSpectral:()=>zX,schemeTableau10:()=>Jwt,schemeYlGn:()=>jX,schemeYlGnBu:()=>YX,schemeYlOrBr:()=>XX,schemeYlOrRd:()=>$X,select:()=>Ht,selectAll:()=>Ep,selection:()=>Ih,selector:()=>Nm,selectorAll:()=>cb,set:()=>o1t,shuffle:()=>c_t,stack:()=>A3t,stackOffsetDiverging:()=>I3t,stackOffsetExpand:()=>P3t,stackOffsetNone:()=>xu,stackOffsetSilhouette:()=>L3t,stackOffsetWiggle:()=>k3t,stackOrderAppearance:()=>Z8,stackOrderAscending:()=>J8,stackOrderDescending:()=>R3t,stackOrderInsideOut:()=>N3t,stackOrderNone:()=>bu,stackOrderReverse:()=>D3t,stratify:()=>y2t,style:()=>Sp,sum:()=>u_t,svg:()=>G1t,symbol:()=>ZSt,symbolCircle:()=>k5,symbolCross:()=>B8,symbolDiamond:()=>H8,symbolSquare:()=>U8,symbolStar:()=>V8,symbolTriangle:()=>q8,symbolWye:()=>G8,symbols:()=>KSt,text:()=>D_,thresholdFreedmanDiaconis:()=>n_t,thresholdScott:()=>i_t,thresholdSturges:()=>sb,tickFormat:()=>c8,tickIncrement:()=>x_,tickStep:()=>tl,ticks:()=>ab,timeDay:()=>ty,timeDays:()=>Q2t,timeFormat:()=>M5,timeFormatDefaultLocale:()=>S8,timeFormatLocale:()=>S5,timeFriday:()=>uX,timeFridays:()=>iwt,timeHour:()=>y8,timeHours:()=>Z2t,timeInterval:()=>br,timeMillisecond:()=>Z_,timeMilliseconds:()=>aX,timeMinute:()=>_8,timeMinutes:()=>$2t,timeMonday:()=>ry,timeMondays:()=>twt,timeMonth:()=>v8,timeMonths:()=>swt,timeParse:()=>wX,timeSaturday:()=>hX,timeSaturdays:()=>owt,timeSecond:()=>Q_,timeSeconds:()=>sX,timeSunday:()=>rg,timeSundays:()=>fX,timeThursday:()=>zp,timeThursdays:()=>nwt,timeTuesday:()=>lX,timeTuesdays:()=>ewt,timeWednesday:()=>cX,timeWednesdays:()=>rwt,timeWeek:()=>rg,timeWeeks:()=>fX,timeYear:()=>Gh,timeYears:()=>lwt,timeout:()=>zE,timer:()=>A_,timerFlush:()=>gY,touch:()=>Tp,touches:()=>lyt,transition:()=>PL,transpose:()=>Y9,tree:()=>v2t,treemap:()=>x2t,treemapBinary:()=>b2t,treemapDice:()=>Uh,treemapResquarify:()=>S2t,treemapSlice:()=>Jm,treemapSliceDice:()=>w2t,treemapSquarify:()=>o8,tsv:()=>B1t,tsvFormat:()=>A1t,tsvFormatBody:()=>P1t,tsvFormatRow:()=>L1t,tsvFormatRows:()=>I1t,tsvFormatValue:()=>k1t,tsvParse:()=>Ab,tsvParseRows:()=>C1t,utcDay:()=>ny,utcDays:()=>dwt,utcFormat:()=>ay,utcFriday:()=>gX,utcFridays:()=>vwt,utcHour:()=>b8,utcHours:()=>fwt,utcMillisecond:()=>Z_,utcMilliseconds:()=>aX,utcMinute:()=>x8,utcMinutes:()=>uwt,utcMonday:()=>oy,utcMondays:()=>mwt,utcMonth:()=>w8,utcMonths:()=>wwt,utcParse:()=>E5,utcSaturday:()=>_X,utcSaturdays:()=>xwt,utcSecond:()=>Q_,utcSeconds:()=>sX,utcSunday:()=>ng,utcSundays:()=>yX,utcThursday:()=>Fp,utcThursdays:()=>ywt,utcTuesday:()=>dX,utcTuesdays:()=>gwt,utcWednesday:()=>mX,utcWednesdays:()=>_wt,utcWeek:()=>ng,utcWeeks:()=>yX,utcYear:()=>Wh,utcYears:()=>Swt,values:()=>l1t,variance:()=>G9,version:()=>j0t,voronoi:()=>K3t,window:()=>hb,xml:()=>U1t,zip:()=>h_t,zoom:()=>eR,zoomIdentity:()=>Xh,zoomTransform:()=>i2});var j0t="5.7.0";function oa(e,t){return e<t?-1:e>t?1:e>=t?0:NaN}function ob(e){return e.length===1&&(e=l2e(e)),{left:function(t,r,n,i){for(n==null&&(n=0),i==null&&(i=t.length);n<i;){var o=n+i>>>1;e(t[o],r)<0?n=o+1:i=o}return n},right:function(t,r,n,i){for(n==null&&(n=0),i==null&&(i=t.length);n<i;){var o=n+i>>>1;e(t[o],r)>0?i=o:n=o+1}return n}}}function l2e(e){return function(t,r){return oa(e(t),r)}}var X0t=ob(oa),WW=X0t.right,$0t=X0t.left,ys=WW;function K0t(e,t){t==null&&(t=YW);for(var r=0,n=e.length-1,i=e[0],o=new Array(n<0?0:n);r<n;)o[r]=t(i,i=e[++r]);return o}function YW(e,t){return[e,t]}function q9(e,t,r){var n=e.length,i=t.length,o=new Array(n*i),a,s,l,c;for(r==null&&(r=YW),a=l=0;a<n;++a)for(c=e[a],s=0;s<i;++s,++l)o[l]=r(c,t[s]);return o}function Z0t(e,t){return t<e?-1:t>e?1:t>=e?0:NaN}function Qs(e){return e===null?NaN:+e}function G9(e,t){var r=e.length,n=0,i=-1,o=0,a,s,l=0;if(t==null)for(;++i<r;)isNaN(a=Qs(e[i]))||(s=a-o,o+=s/++n,l+=s*(a-o));else for(;++i<r;)isNaN(a=Qs(t(e[i],i,e)))||(s=a-o,o+=s/++n,l+=s*(a-o));if(n>1)return l/(n-1)}function W9(e,t){var r=G9(e,t);return r&&Math.sqrt(r)}function aa(e,t){var r=e.length,n=-1,i,o,a;if(t==null){for(;++n<r;)if((i=e[n])!=null&&i>=i)for(o=a=i;++n<r;)(i=e[n])!=null&&(o>i&&(o=i),a<i&&(a=i))}else for(;++n<r;)if((i=t(e[n],n,e))!=null&&i>=i)for(o=a=i;++n<r;)(i=t(e[n],n,e))!=null&&(o>i&&(o=i),a<i&&(a=i));return[o,a]}var J0t=Array.prototype,Q0t=J0t.slice,t_t=J0t.map;function bE(e){return function(){return e}}function e_t(e){return e}function Ir(e,t,r){e=+e,t=+t,r=(i=arguments.length)<2?(t=e,e=0,1):i<3?1:+r;for(var n=-1,i=Math.max(0,Math.ceil((t-e)/r))|0,o=new Array(i);++n<i;)o[n]=e+n*r;return o}var jW=Math.sqrt(50),XW=Math.sqrt(10),$W=Math.sqrt(2);function ab(e,t,r){var n,i=-1,o,a,s;if(t=+t,e=+e,r=+r,e===t&&r>0)return[e];if((n=t<e)&&(o=e,e=t,t=o),(s=x_(e,t,r))===0||!isFinite(s))return[];if(s>0)for(e=Math.ceil(e/s),t=Math.floor(t/s),a=new Array(o=Math.ceil(t-e+1));++i<o;)a[i]=(e+i)*s;else for(e=Math.floor(e*s),t=Math.ceil(t*s),a=new Array(o=Math.ceil(e-t+1));++i<o;)a[i]=(e-i)/s;return n&&a.reverse(),a}function x_(e,t,r){var n=(t-e)/Math.max(0,r),i=Math.floor(Math.log(n)/Math.LN10),o=n/Math.pow(10,i);return i>=0?(o>=jW?10:o>=XW?5:o>=$W?2:1)*Math.pow(10,i):-Math.pow(10,-i)/(o>=jW?10:o>=XW?5:o>=$W?2:1)}function tl(e,t,r){var n=Math.abs(t-e)/Math.max(0,r),i=Math.pow(10,Math.floor(Math.log(n)/Math.LN10)),o=n/i;return o>=jW?i*=10:o>=XW?i*=5:o>=$W&&(i*=2),t<e?-i:i}function sb(e){return Math.ceil(Math.log(e.length)/Math.LN2)+1}function r_t(){var e=e_t,t=aa,r=sb;function n(i){var o,a=i.length,s,l=new Array(a);for(o=0;o<a;++o)l[o]=e(i[o],o,i);var c=t(l),u=c[0],h=c[1],f=r(l,u,h);Array.isArray(f)||(f=tl(u,h,f),f=Ir(Math.ceil(u/f)*f,h,f));for(var p=f.length;f[0]<=u;)f.shift(),--p;for(;f[p-1]>h;)f.pop(),--p;var d=new Array(p+1),g;for(o=0;o<=p;++o)g=d[o]=[],g.x0=o>0?f[o-1]:u,g.x1=o<p?f[o]:h;for(o=0;o<a;++o)s=l[o],u<=s&&s<=h&&d[ys(f,s,0,p)].push(i[o]);return d}return n.value=function(i){return arguments.length?(e=typeof i=="function"?i:bE(i),n):e},n.domain=function(i){return arguments.length?(t=typeof i=="function"?i:bE([i[0],i[1]]),n):t},n.thresholds=function(i){return arguments.length?(r=typeof i=="function"?i:Array.isArray(i)?bE(Q0t.call(i)):bE(i),n):r},n}function sa(e,t,r){if(r==null&&(r=Qs),!!(n=e.length)){if((t=+t)<=0||n<2)return+r(e[0],0,e);if(t>=1)return+r(e[n-1],n-1,e);var n,i=(n-1)*t,o=Math.floor(i),a=+r(e[o],o,e),s=+r(e[o+1],o+1,e);return a+(s-a)*(i-o)}}function n_t(e,t,r){return e=t_t.call(e,Qs).sort(oa),Math.ceil((r-t)/(2*(sa(e,.75)-sa(e,.25))*Math.pow(e.length,-1/3)))}function i_t(e,t,r){return Math.ceil((r-t)/(3.5*W9(e)*Math.pow(e.length,-1/3)))}function lu(e,t){var r=e.length,n=-1,i,o;if(t==null){for(;++n<r;)if((i=e[n])!=null&&i>=i)for(o=i;++n<r;)(i=e[n])!=null&&i>o&&(o=i)}else for(;++n<r;)if((i=t(e[n],n,e))!=null&&i>=i)for(o=i;++n<r;)(i=t(e[n],n,e))!=null&&i>o&&(o=i);return o}function o_t(e,t){var r=e.length,n=r,i=-1,o,a=0;if(t==null)for(;++i<r;)isNaN(o=Qs(e[i]))?--n:a+=o;else for(;++i<r;)isNaN(o=Qs(t(e[i],i,e)))?--n:a+=o;if(n)return a/n}function a_t(e,t){var r=e.length,n=-1,i,o=[];if(t==null)for(;++n<r;)isNaN(i=Qs(e[n]))||o.push(i);else for(;++n<r;)isNaN(i=Qs(t(e[n],n,e)))||o.push(i);return sa(o.sort(oa),.5)}function Im(e){for(var t=e.length,r,n=-1,i=0,o,a;++n<t;)i+=e[n].length;for(o=new Array(i);--t>=0;)for(a=e[t],r=a.length;--r>=0;)o[--i]=a[r];return o}function Lm(e,t){var r=e.length,n=-1,i,o;if(t==null){for(;++n<r;)if((i=e[n])!=null&&i>=i)for(o=i;++n<r;)(i=e[n])!=null&&o>i&&(o=i)}else for(;++n<r;)if((i=t(e[n],n,e))!=null&&i>=i)for(o=i;++n<r;)(i=t(e[n],n,e))!=null&&o>i&&(o=i);return o}function s_t(e,t){for(var r=t.length,n=new Array(r);r--;)n[r]=e[t[r]];return n}function l_t(e,t){if(!!(r=e.length)){var r,n=0,i=0,o,a=e[i];for(t==null&&(t=oa);++n<r;)(t(o=e[n],a)<0||t(a,a)!==0)&&(a=o,i=n);if(t(a,a)===0)return i}}function c_t(e,t,r){for(var n=(r==null?e.length:r)-(t=t==null?0:+t),i,o;n;)o=Math.random()*n--|0,i=e[n+t],e[n+t]=e[o+t],e[o+t]=i;return e}function u_t(e,t){var r=e.length,n=-1,i,o=0;if(t==null)for(;++n<r;)(i=+e[n])&&(o+=i);else for(;++n<r;)(i=+t(e[n],n,e))&&(o+=i);return o}function Y9(e){if(!(o=e.length))return[];for(var t=-1,r=Lm(e,c2e),n=new Array(r);++t<r;)for(var i=-1,o,a=n[t]=new Array(o);++i<o;)a[i]=e[i][t];return n}function c2e(e){return e.length}function h_t(){return Y9(arguments)}var j9=Array.prototype.slice;function f_t(e){return e}var X9=1,$9=2,KW=3,wE=4,p_t=1e-6;function u2e(e){return"translate("+(e+.5)+",0)"}function h2e(e){return"translate(0,"+(e+.5)+")"}function f2e(e){return function(t){return+e(t)}}function p2e(e){var t=Math.max(0,e.bandwidth()-1)/2;return e.round()&&(t=Math.round(t)),function(r){return+e(r)+t}}function d2e(){return!this.__axis}function K9(e,t){var r=[],n=null,i=null,o=6,a=6,s=3,l=e===X9||e===wE?-1:1,c=e===wE||e===$9?"x":"y",u=e===X9||e===KW?u2e:h2e;function h(f){var p=n==null?t.ticks?t.ticks.apply(t,r):t.domain():n,d=i==null?t.tickFormat?t.tickFormat.apply(t,r):f_t:i,g=Math.max(o,0)+s,_=t.range(),y=+_[0]+.5,x=+_[_.length-1]+.5,b=(t.bandwidth?p2e:f2e)(t.copy()),S=f.selection?f.selection():f,C=S.selectAll(".domain").data([null]),P=S.selectAll(".tick").data(p,t).order(),k=P.exit(),O=P.enter().append("g").attr("class","tick"),D=P.select("line"),B=P.select("text");C=C.merge(C.enter().insert("path",".tick").attr("class","domain").attr("stroke","currentColor")),P=P.merge(O),D=D.merge(O.append("line").attr("stroke","currentColor").attr(c+"2",l*o)),B=B.merge(O.append("text").attr("fill","currentColor").attr(c,l*g).attr("dy",e===X9?"0em":e===KW?"0.71em":"0.32em")),f!==S&&(C=C.transition(f),P=P.transition(f),D=D.transition(f),B=B.transition(f),k=k.transition(f).attr("opacity",p_t).attr("transform",function(I){return isFinite(I=b(I))?u(I):this.getAttribute("transform")}),O.attr("opacity",p_t).attr("transform",function(I){var L=this.parentNode.__axis;return u(L&&isFinite(L=L(I))?L:b(I))})),k.remove(),C.attr("d",e===wE||e==$9?a?"M"+l*a+","+y+"H0.5V"+x+"H"+l*a:"M0.5,"+y+"V"+x:a?"M"+y+","+l*a+"V0.5H"+x+"V"+l*a:"M"+y+",0.5H"+x),P.attr("opacity",1).attr("transform",function(I){return u(b(I))}),D.attr(c+"2",l*o),B.attr(c,l*g).text(d),S.filter(d2e).attr("fill","none").attr("font-size",10).attr("font-family","sans-serif").attr("text-anchor",e===$9?"start":e===wE?"end":"middle"),S.each(function(){this.__axis=b})}return h.scale=function(f){return arguments.length?(t=f,h):t},h.ticks=function(){return r=j9.call(arguments),h},h.tickArguments=function(f){return arguments.length?(r=f==null?[]:j9.call(f),h):r.slice()},h.tickValues=function(f){return arguments.length?(n=f==null?null:j9.call(f),h):n&&n.slice()},h.tickFormat=function(f){return arguments.length?(i=f,h):i},h.tickSize=function(f){return arguments.length?(o=a=+f,h):o},h.tickSizeInner=function(f){return arguments.length?(o=+f,h):o},h.tickSizeOuter=function(f){return arguments.length?(a=+f,h):a},h.tickPadding=function(f){return arguments.length?(s=+f,h):s},h}function d_t(e){return K9(X9,e)}function m_t(e){return K9($9,e)}function Z9(e){return K9(KW,e)}function lb(e){return K9(wE,e)}km();km();var Q9="http://www.w3.org/1999/xhtml",SE={svg:"http://www.w3.org/2000/svg",xhtml:Q9,xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/"};function Ph(e){var t=e+="",r=t.indexOf(":");return r>=0&&(t=e.slice(0,r))!=="xmlns"&&(e=e.slice(r+1)),SE.hasOwnProperty(t)?{space:SE[t],local:e}:e}function y2e(e){return function(){var t=this.ownerDocument,r=this.namespaceURI;return r===Q9&&t.documentElement.namespaceURI===Q9?t.createElement(e):t.createElementNS(r,e)}}function v2e(e){return function(){return this.ownerDocument.createElementNS(e.space,e.local)}}function Rm(e){var t=Ph(e);return(t.local?v2e:y2e)(t)}function x2e(){}function Nm(e){return e==null?x2e:function(){return this.querySelector(e)}}function v_t(e){typeof e!="function"&&(e=Nm(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=new Array(a),l,c,u=0;u<a;++u)(l=o[u])&&(c=e.call(l,l.__data__,u,o))&&("__data__"in l&&(c.__data__=l.__data__),s[u]=c);return new Nn(n,this._parents)}function b2e(){return[]}function cb(e){return e==null?b2e:function(){return this.querySelectorAll(e)}}function x_t(e){typeof e!="function"&&(e=cb(e));for(var t=this._groups,r=t.length,n=[],i=[],o=0;o<r;++o)for(var a=t[o],s=a.length,l,c=0;c<s;++c)(l=a[c])&&(n.push(e.call(l,l.__data__,c,a)),i.push(l));return new Nn(n,i)}function ub(e){return function(){return this.matches(e)}}function b_t(e){typeof e!="function"&&(e=ub(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=[],l,c=0;c<a;++c)(l=o[c])&&e.call(l,l.__data__,c,o)&&s.push(l);return new Nn(n,this._parents)}function tL(e){return new Array(e.length)}function w_t(){return new Nn(this._enter||this._groups.map(tL),this._parents)}function ME(e,t){this.ownerDocument=e.ownerDocument,this.namespaceURI=e.namespaceURI,this._next=null,this._parent=e,this.__data__=t}ME.prototype={constructor:ME,appendChild:function(e){return this._parent.insertBefore(e,this._next)},insertBefore:function(e,t){return this._parent.insertBefore(e,t)},querySelector:function(e){return this._parent.querySelector(e)},querySelectorAll:function(e){return this._parent.querySelectorAll(e)}};function S_t(e){return function(){return e}}var M_t="$";function w2e(e,t,r,n,i,o){for(var a=0,s,l=t.length,c=o.length;a<c;++a)(s=t[a])?(s.__data__=o[a],n[a]=s):r[a]=new ME(e,o[a]);for(;a<l;++a)(s=t[a])&&(i[a]=s)}function S2e(e,t,r,n,i,o,a){var s,l,c={},u=t.length,h=o.length,f=new Array(u),p;for(s=0;s<u;++s)(l=t[s])&&(f[s]=p=M_t+a.call(l,l.__data__,s,t),p in c?i[s]=l:c[p]=l);for(s=0;s<h;++s)p=M_t+a.call(e,o[s],s,o),(l=c[p])?(n[s]=l,l.__data__=o[s],c[p]=null):r[s]=new ME(e,o[s]);for(s=0;s<u;++s)(l=t[s])&&c[f[s]]===l&&(i[s]=l)}function E_t(e,t){if(!e)return p=new Array(this.size()),c=-1,this.each(function(P){p[++c]=P}),p;var r=t?S2e:w2e,n=this._parents,i=this._groups;typeof e!="function"&&(e=S_t(e));for(var o=i.length,a=new Array(o),s=new Array(o),l=new Array(o),c=0;c<o;++c){var u=n[c],h=i[c],f=h.length,p=e.call(u,u&&u.__data__,c,n),d=p.length,g=s[c]=new Array(d),_=a[c]=new Array(d),y=l[c]=new Array(f);r(u,h,g,_,y,p,t);for(var x=0,b=0,S,C;x<d;++x)if(S=g[x]){for(x>=b&&(b=x+1);!(C=_[b])&&++b<d;);S._next=C||null}}return a=new Nn(a,n),a._enter=s,a._exit=l,a}function T_t(){return new Nn(this._exit||this._groups.map(tL),this._parents)}function C_t(e,t,r){var n=this.enter(),i=this,o=this.exit();return n=typeof e=="function"?e(n):n.append(e+""),t!=null&&(i=t(i)),r==null?o.remove():r(o),n&&i?n.merge(i).order():i}function A_t(e){for(var t=this._groups,r=e._groups,n=t.length,i=r.length,o=Math.min(n,i),a=new Array(n),s=0;s<o;++s)for(var l=t[s],c=r[s],u=l.length,h=a[s]=new Array(u),f,p=0;p<u;++p)(f=l[p]||c[p])&&(h[p]=f);for(;s<n;++s)a[s]=t[s];return new Nn(a,this._parents)}function P_t(){for(var e=this._groups,t=-1,r=e.length;++t<r;)for(var n=e[t],i=n.length-1,o=n[i],a;--i>=0;)(a=n[i])&&(o&&a.compareDocumentPosition(o)^4&&o.parentNode.insertBefore(a,o),o=a);return this}function I_t(e){e||(e=M2e);function t(h,f){return h&&f?e(h.__data__,f.__data__):!h-!f}for(var r=this._groups,n=r.length,i=new Array(n),o=0;o<n;++o){for(var a=r[o],s=a.length,l=i[o]=new Array(s),c,u=0;u<s;++u)(c=a[u])&&(l[u]=c);l.sort(t)}return new Nn(i,this._parents).order()}function M2e(e,t){return e<t?-1:e>t?1:e>=t?0:NaN}function L_t(){var e=arguments[0];return arguments[0]=this,e.apply(null,arguments),this}function k_t(){var e=new Array(this.size()),t=-1;return this.each(function(){e[++t]=this}),e}function R_t(){for(var e=this._groups,t=0,r=e.length;t<r;++t)for(var n=e[t],i=0,o=n.length;i<o;++i){var a=n[i];if(a)return a}return null}function N_t(){var e=0;return this.each(function(){++e}),e}function D_t(){return!this.node()}function O_t(e){for(var t=this._groups,r=0,n=t.length;r<n;++r)for(var i=t[r],o=0,a=i.length,s;o<a;++o)(s=i[o])&&e.call(s,s.__data__,o,i);return this}function E2e(e){return function(){this.removeAttribute(e)}}function T2e(e){return function(){this.removeAttributeNS(e.space,e.local)}}function C2e(e,t){return function(){this.setAttribute(e,t)}}function A2e(e,t){return function(){this.setAttributeNS(e.space,e.local,t)}}function P2e(e,t){return function(){var r=t.apply(this,arguments);r==null?this.removeAttribute(e):this.setAttribute(e,r)}}function I2e(e,t){return function(){var r=t.apply(this,arguments);r==null?this.removeAttributeNS(e.space,e.local):this.setAttributeNS(e.space,e.local,r)}}function z_t(e,t){var r=Ph(e);if(arguments.length<2){var n=this.node();return r.local?n.getAttributeNS(r.space,r.local):n.getAttribute(r)}return this.each((t==null?r.local?T2e:E2e:typeof t=="function"?r.local?I2e:P2e:r.local?A2e:C2e)(r,t))}function hb(e){return e.ownerDocument&&e.ownerDocument.defaultView||e.document&&e||e.defaultView}function L2e(e){return function(){this.style.removeProperty(e)}}function k2e(e,t,r){return function(){this.style.setProperty(e,t,r)}}function R2e(e,t,r){return function(){var n=t.apply(this,arguments);n==null?this.style.removeProperty(e):this.style.setProperty(e,n,r)}}function F_t(e,t,r){return arguments.length>1?this.each((t==null?L2e:typeof t=="function"?R2e:k2e)(e,t,r==null?"":r)):Sp(this.node(),e)}function Sp(e,t){return e.style.getPropertyValue(t)||hb(e).getComputedStyle(e,null).getPropertyValue(t)}function N2e(e){return function(){delete this[e]}}function D2e(e,t){return function(){this[e]=t}}function O2e(e,t){return function(){var r=t.apply(this,arguments);r==null?delete this[e]:this[e]=r}}function B_t(e,t){return arguments.length>1?this.each((t==null?N2e:typeof t=="function"?O2e:D2e)(e,t)):this.node()[e]}function H_t(e){return e.trim().split(/^|\s+/)}function ZW(e){return e.classList||new V_t(e)}function V_t(e){this._node=e,this._names=H_t(e.getAttribute("class")||"")}V_t.prototype={add:function(e){var t=this._names.indexOf(e);t<0&&(this._names.push(e),this._node.setAttribute("class",this._names.join(" ")))},remove:function(e){var t=this._names.indexOf(e);t>=0&&(this._names.splice(t,1),this._node.setAttribute("class",this._names.join(" ")))},contains:function(e){return this._names.indexOf(e)>=0}};function U_t(e,t){for(var r=ZW(e),n=-1,i=t.length;++n<i;)r.add(t[n])}function q_t(e,t){for(var r=ZW(e),n=-1,i=t.length;++n<i;)r.remove(t[n])}function z2e(e){return function(){U_t(this,e)}}function F2e(e){return function(){q_t(this,e)}}function B2e(e,t){return function(){(t.apply(this,arguments)?U_t:q_t)(this,e)}}function G_t(e,t){var r=H_t(e+"");if(arguments.length<2){for(var n=ZW(this.node()),i=-1,o=r.length;++i<o;)if(!n.contains(r[i]))return!1;return!0}return this.each((typeof t=="function"?B2e:t?z2e:F2e)(r,t))}function H2e(){this.textContent=""}function V2e(e){return function(){this.textContent=e}}function U2e(e){return function(){var t=e.apply(this,arguments);this.textContent=t==null?"":t}}function W_t(e){return arguments.length?this.each(e==null?H2e:(typeof e=="function"?U2e:V2e)(e)):this.node().textContent}function q2e(){this.innerHTML=""}function G2e(e){return function(){this.innerHTML=e}}function W2e(e){return function(){var t=e.apply(this,arguments);this.innerHTML=t==null?"":t}}function Y_t(e){return arguments.length?this.each(e==null?q2e:(typeof e=="function"?W2e:G2e)(e)):this.node().innerHTML}function Y2e(){this.nextSibling&&this.parentNode.appendChild(this)}function j_t(){return this.each(Y2e)}function j2e(){this.previousSibling&&this.parentNode.insertBefore(this,this.parentNode.firstChild)}function X_t(){return this.each(j2e)}function $_t(e){var t=typeof e=="function"?e:Rm(e);return this.select(function(){return this.appendChild(t.apply(this,arguments))})}function X2e(){return null}function K_t(e,t){var r=typeof e=="function"?e:Rm(e),n=t==null?X2e:typeof t=="function"?t:Nm(t);return this.select(function(){return this.insertBefore(r.apply(this,arguments),n.apply(this,arguments)||null)})}function $2e(){var e=this.parentNode;e&&e.removeChild(this)}function Z_t(){return this.each($2e)}function K2e(){var e=this.cloneNode(!1),t=this.parentNode;return t?t.insertBefore(e,this.nextSibling):e}function Z2e(){var e=this.cloneNode(!0),t=this.parentNode;return t?t.insertBefore(e,this.nextSibling):e}function J_t(e){return this.select(e?Z2e:K2e)}function Q_t(e){return arguments.length?this.property("__data__",e):this.node().__data__}var eyt={},qt=null;typeof document!="undefined"&&(tyt=document.documentElement,"onmouseenter"in tyt||(eyt={mouseenter:"mouseover",mouseleave:"mouseout"}));var tyt;function J2e(e,t,r){return e=ryt(e,t,r),function(n){var i=n.relatedTarget;(!i||i!==this&&!(i.compareDocumentPosition(this)&8))&&e.call(this,n)}}function ryt(e,t,r){return function(n){var i=qt;qt=n;try{e.call(this,this.__data__,t,r)}finally{qt=i}}}function Q2e(e){return e.trim().split(/^|\s+/).map(function(t){var r="",n=t.indexOf(".");return n>=0&&(r=t.slice(n+1),t=t.slice(0,n)),{type:t,name:r}})}function twe(e){return function(){var t=this.__on;if(!!t){for(var r=0,n=-1,i=t.length,o;r<i;++r)o=t[r],(!e.type||o.type===e.type)&&o.name===e.name?this.removeEventListener(o.type,o.listener,o.capture):t[++n]=o;++n?t.length=n:delete this.__on}}}function ewe(e,t,r){var n=eyt.hasOwnProperty(e.type)?J2e:ryt;return function(i,o,a){var s=this.__on,l,c=n(t,o,a);if(s){for(var u=0,h=s.length;u<h;++u)if((l=s[u]).type===e.type&&l.name===e.name){this.removeEventListener(l.type,l.listener,l.capture),this.addEventListener(l.type,l.listener=c,l.capture=r),l.value=t;return}}this.addEventListener(e.type,c,r),l={type:e.type,name:e.name,value:t,listener:c,capture:r},s?s.push(l):this.__on=[l]}}function nyt(e,t,r){var n=Q2e(e+""),i,o=n.length,a;if(arguments.length<2){var s=this.node().__on;if(s){for(var l=0,c=s.length,u;l<c;++l)for(i=0,u=s[l];i<o;++i)if((a=n[i]).type===u.type&&a.name===u.name)return u.value}return}for(s=t?ewe:twe,r==null&&(r=!1),i=0;i<o;++i)this.each(s(n[i],t,r));return this}function Mp(e,t,r,n){var i=qt;e.sourceEvent=qt,qt=e;try{return t.apply(r,n)}finally{qt=i}}function iyt(e,t,r){var n=hb(e),i=n.CustomEvent;typeof i=="function"?i=new i(t,r):(i=n.document.createEvent("Event"),r?(i.initEvent(t,r.bubbles,r.cancelable),i.detail=r.detail):i.initEvent(t,!1,!1)),e.dispatchEvent(i)}function rwe(e,t){return function(){return iyt(this,e,t)}}function nwe(e,t){return function(){return iyt(this,e,t.apply(this,arguments))}}function oyt(e,t){return this.each((typeof t=="function"?nwe:rwe)(e,t))}var EE=[null];function Nn(e,t){this._groups=e,this._parents=t}function ayt(){return new Nn([[document.documentElement]],EE)}Nn.prototype=ayt.prototype={constructor:Nn,select:v_t,selectAll:x_t,filter:b_t,data:E_t,enter:w_t,exit:T_t,join:C_t,merge:A_t,order:P_t,sort:I_t,call:L_t,nodes:k_t,node:R_t,size:N_t,empty:D_t,each:O_t,attr:z_t,style:F_t,property:B_t,classed:G_t,text:W_t,html:Y_t,raise:j_t,lower:X_t,append:$_t,insert:K_t,remove:Z_t,clone:J_t,datum:Q_t,on:nyt,dispatch:oyt};var Ih=ayt;function Ht(e){return typeof e=="string"?new Nn([[document.querySelector(e)]],[document.documentElement]):new Nn([[e]],EE)}function syt(e){return Ht(Rm(e).call(document.documentElement))}var iwe=0;function eL(){return new JW}function JW(){this._="@"+(++iwe).toString(36)}JW.prototype=eL.prototype={constructor:JW,get:function(e){for(var t=this._;!(t in e);)if(!(e=e.parentNode))return;return e[t]},set:function(e,t){return e[this._]=t},remove:function(e){return this._ in e&&delete e[this._]},toString:function(){return this._}};function fb(){for(var e=qt,t;t=e.sourceEvent;)e=t;return e}function Dm(e,t){var r=e.ownerSVGElement||e;if(r.createSVGPoint){var n=r.createSVGPoint();return n.x=t.clientX,n.y=t.clientY,n=n.matrixTransform(e.getScreenCTM().inverse()),[n.x,n.y]}var i=e.getBoundingClientRect();return[t.clientX-i.left-e.clientLeft,t.clientY-i.top-e.clientTop]}function zo(e){var t=fb();return t.changedTouches&&(t=t.changedTouches[0]),Dm(e,t)}function Ep(e){return typeof e=="string"?new Nn([document.querySelectorAll(e)],[document.documentElement]):new Nn([e==null?[]:e],EE)}function Tp(e,t,r){arguments.length<3&&(r=t,t=fb().changedTouches);for(var n=0,i=t?t.length:0,o;n<i;++n)if((o=t[n]).identifier===r)return Dm(e,o);return null}function lyt(e,t){t==null&&(t=fb().touches);for(var r=0,n=t?t.length:0,i=new Array(n);r<n;++r)i[r]=Dm(e,t[r]);return i}function rL(){qt.stopImmediatePropagation()}function Om(){qt.preventDefault(),qt.stopImmediatePropagation()}function zm(e){var t=e.document.documentElement,r=Ht(e).on("dragstart.drag",Om,!0);"onselectstart"in t?r.on("selectstart.drag",Om,!0):(t.__noselect=t.style.MozUserSelect,t.style.MozUserSelect="none")}function Fm(e,t){var r=e.document.documentElement,n=Ht(e).on("dragstart.drag",null);t&&(n.on("click.drag",Om,!0),setTimeout(function(){n.on("click.drag",null)},0)),"onselectstart"in r?n.on("selectstart.drag",null):(r.style.MozUserSelect=r.__noselect,delete r.__noselect)}function TE(e){return function(){return e}}function CE(e,t,r,n,i,o,a,s,l,c){this.target=e,this.type=t,this.subject=r,this.identifier=n,this.active=i,this.x=o,this.y=a,this.dx=s,this.dy=l,this._=c}CE.prototype.on=function(){var e=this._.on.apply(this._,arguments);return e===this._?this:e};function owe(){return!qt.ctrlKey&&!qt.button}function awe(){return this.parentNode}function swe(e){return e==null?{x:qt.x,y:qt.y}:e}function lwe(){return navigator.maxTouchPoints||"ontouchstart"in this}function pb(){var e=owe,t=awe,r=swe,n=lwe,i={},o=vs("start","drag","end"),a=0,s,l,c,u,h=0;function f(S){S.on("mousedown.drag",p).filter(n).on("touchstart.drag",_).on("touchmove.drag",y).on("touchend.drag touchcancel.drag",x).style("touch-action","none").style("-webkit-tap-highlight-color","rgba(0,0,0,0)")}function p(){if(!(u||!e.apply(this,arguments))){var S=b("mouse",t.apply(this,arguments),zo,this,arguments);!S||(Ht(qt.view).on("mousemove.drag",d,!0).on("mouseup.drag",g,!0),zm(qt.view),rL(),c=!1,s=qt.clientX,l=qt.clientY,S("start"))}}function d(){if(Om(),!c){var S=qt.clientX-s,C=qt.clientY-l;c=S*S+C*C>h}i.mouse("drag")}function g(){Ht(qt.view).on("mousemove.drag mouseup.drag",null),Fm(qt.view,c),Om(),i.mouse("end")}function _(){if(!!e.apply(this,arguments)){var S=qt.changedTouches,C=t.apply(this,arguments),P=S.length,k,O;for(k=0;k<P;++k)(O=b(S[k].identifier,C,Tp,this,arguments))&&(rL(),O("start"))}}function y(){var S=qt.changedTouches,C=S.length,P,k;for(P=0;P<C;++P)(k=i[S[P].identifier])&&(Om(),k("drag"))}function x(){var S=qt.changedTouches,C=S.length,P,k;for(u&&clearTimeout(u),u=setTimeout(function(){u=null},500),P=0;P<C;++P)(k=i[S[P].identifier])&&(rL(),k("end"))}function b(S,C,P,k,O){var D=P(C,S),B,I,L,R=o.copy();if(!!Mp(new CE(f,"beforestart",B,S,a,D[0],D[1],0,0,R),function(){return(qt.subject=B=r.apply(k,O))==null?!1:(I=B.x-D[0]||0,L=B.y-D[1]||0,!0)}))return function F(z){var U=D,W;switch(z){case"start":i[S]=F,W=a++;break;case"end":delete i[S],--a;case"drag":D=P(C,S),W=a;break}Mp(new CE(f,z,B,S,W,D[0]+I,D[1]+L,D[0]-U[0],D[1]-U[1],R),R.apply,R,[z,k,O])}}return f.filter=function(S){return arguments.length?(e=typeof S=="function"?S:TE(!!S),f):e},f.container=function(S){return arguments.length?(t=typeof S=="function"?S:TE(S),f):t},f.subject=function(S){return arguments.length?(r=typeof S=="function"?S:TE(S),f):r},f.touchable=function(S){return arguments.length?(n=typeof S=="function"?S:TE(!!S),f):n},f.on=function(){var S=o.on.apply(o,arguments);return S===o?f:S},f.clickDistance=function(S){return arguments.length?(h=(S=+S)*S,f):Math.sqrt(h)},f}function Cp(e,t,r){e.prototype=t.prototype=r,r.constructor=e}function Bm(e,t){var r=Object.create(e.prototype);for(var n in t)r[n]=t[n];return r}function Rh(){}var Hm=.7,b_=1/Hm,db="\\s*([+-]?\\d+)\\s*",AE="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",kh="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",cwe=/^#([0-9a-f]{3,8})$/,uwe=new RegExp("^rgb\\("+[db,db,db]+"\\)$"),hwe=new RegExp("^rgb\\("+[kh,kh,kh]+"\\)$"),fwe=new RegExp("^rgba\\("+[db,db,db,AE]+"\\)$"),pwe=new RegExp("^rgba\\("+[kh,kh,kh,AE]+"\\)$"),dwe=new RegExp("^hsl\\("+[AE,kh,kh]+"\\)$"),mwe=new RegExp("^hsla\\("+[AE,kh,kh,AE]+"\\)$"),cyt={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};Cp(Rh,rc,{copy:function(e){return Object.assign(new this.constructor,this,e)},displayable:function(){return this.rgb().displayable()},hex:uyt,formatHex:uyt,formatHsl:gwe,formatRgb:hyt,toString:hyt});function uyt(){return this.rgb().formatHex()}function gwe(){return gyt(this).formatHsl()}function hyt(){return this.rgb().formatRgb()}function rc(e){var t,r;return e=(e+"").trim().toLowerCase(),(t=cwe.exec(e))?(r=t[1].length,t=parseInt(t[1],16),r===6?fyt(t):r===3?new Ki(t>>8&15|t>>4&240,t>>4&15|t&240,(t&15)<<4|t&15,1):r===8?nL(t>>24&255,t>>16&255,t>>8&255,(t&255)/255):r===4?nL(t>>12&15|t>>8&240,t>>8&15|t>>4&240,t>>4&15|t&240,((t&15)<<4|t&15)/255):null):(t=uwe.exec(e))?new Ki(t[1],t[2],t[3],1):(t=hwe.exec(e))?new Ki(t[1]*255/100,t[2]*255/100,t[3]*255/100,1):(t=fwe.exec(e))?nL(t[1],t[2],t[3],t[4]):(t=pwe.exec(e))?nL(t[1]*255/100,t[2]*255/100,t[3]*255/100,t[4]):(t=dwe.exec(e))?myt(t[1],t[2]/100,t[3]/100,1):(t=mwe.exec(e))?myt(t[1],t[2]/100,t[3]/100,t[4]):cyt.hasOwnProperty(e)?fyt(cyt[e]):e==="transparent"?new Ki(NaN,NaN,NaN,0):null}function fyt(e){return new Ki(e>>16&255,e>>8&255,e&255,1)}function nL(e,t,r,n){return n<=0&&(e=t=r=NaN),new Ki(e,t,r,n)}function PE(e){return e instanceof Rh||(e=rc(e)),e?(e=e.rgb(),new Ki(e.r,e.g,e.b,e.opacity)):new Ki}function cu(e,t,r,n){return arguments.length===1?PE(e):new Ki(e,t,r,n==null?1:n)}function Ki(e,t,r,n){this.r=+e,this.g=+t,this.b=+r,this.opacity=+n}Cp(Ki,cu,Bm(Rh,{brighter:function(e){return e=e==null?b_:Math.pow(b_,e),new Ki(this.r*e,this.g*e,this.b*e,this.opacity)},darker:function(e){return e=e==null?Hm:Math.pow(Hm,e),new Ki(this.r*e,this.g*e,this.b*e,this.opacity)},rgb:function(){return this},displayable:function(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:pyt,formatHex:pyt,formatRgb:dyt,toString:dyt}));function pyt(){return"#"+QW(this.r)+QW(this.g)+QW(this.b)}function dyt(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"rgb(":"rgba(")+Math.max(0,Math.min(255,Math.round(this.r)||0))+", "+Math.max(0,Math.min(255,Math.round(this.g)||0))+", "+Math.max(0,Math.min(255,Math.round(this.b)||0))+(e===1?")":", "+e+")")}function QW(e){return e=Math.max(0,Math.min(255,Math.round(e)||0)),(e<16?"0":"")+e.toString(16)}function myt(e,t,r,n){return n<=0?e=t=r=NaN:r<=0||r>=1?e=t=NaN:t<=0&&(e=NaN),new Lh(e,t,r,n)}function gyt(e){if(e instanceof Lh)return new Lh(e.h,e.s,e.l,e.opacity);if(e instanceof Rh||(e=rc(e)),!e)return new Lh;if(e instanceof Lh)return e;e=e.rgb();var t=e.r/255,r=e.g/255,n=e.b/255,i=Math.min(t,r,n),o=Math.max(t,r,n),a=NaN,s=o-i,l=(o+i)/2;return s?(t===o?a=(r-n)/s+(r<n)*6:r===o?a=(n-t)/s+2:a=(t-r)/s+4,s/=l<.5?o+i:2-o-i,a*=60):s=l>0&&l<1?0:a,new Lh(a,s,l,e.opacity)}function Vm(e,t,r,n){return arguments.length===1?gyt(e):new Lh(e,t,r,n==null?1:n)}function Lh(e,t,r,n){this.h=+e,this.s=+t,this.l=+r,this.opacity=+n}Cp(Lh,Vm,Bm(Rh,{brighter:function(e){return e=e==null?b_:Math.pow(b_,e),new Lh(this.h,this.s,this.l*e,this.opacity)},darker:function(e){return e=e==null?Hm:Math.pow(Hm,e),new Lh(this.h,this.s,this.l*e,this.opacity)},rgb:function(){var e=this.h%360+(this.h<0)*360,t=isNaN(e)||isNaN(this.s)?0:this.s,r=this.l,n=r+(r<.5?r:1-r)*t,i=2*r-n;return new Ki(tY(e>=240?e-240:e+120,i,n),tY(e,i,n),tY(e<120?e+240:e-120,i,n),this.opacity)},displayable:function(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl:function(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"hsl(":"hsla(")+(this.h||0)+", "+(this.s||0)*100+"%, "+(this.l||0)*100+"%"+(e===1?")":", "+e+")")}}));function tY(e,t,r){return(e<60?t+(r-t)*e/60:e<180?r:e<240?t+(r-t)*(240-e)/60:t)*255}var iL=Math.PI/180,oL=180/Math.PI;var aL=18,_yt=.96422,yyt=1,vyt=.82521,xyt=4/29,mb=6/29,byt=3*mb*mb,_we=mb*mb*mb;function wyt(e){if(e instanceof uu)return new uu(e.l,e.a,e.b,e.opacity);if(e instanceof Nh)return Tyt(e);e instanceof Ki||(e=PE(e));var t=iY(e.r),r=iY(e.g),n=iY(e.b),i=eY((.2225045*t+.7168786*r+.0606169*n)/yyt),o,a;return t===r&&r===n?o=a=i:(o=eY((.4360747*t+.3850649*r+.1430804*n)/_yt),a=eY((.0139322*t+.0971045*r+.7141733*n)/vyt)),new uu(116*i-16,500*(o-i),200*(i-a),e.opacity)}function Syt(e,t){return new uu(e,0,0,t==null?1:t)}function w_(e,t,r,n){return arguments.length===1?wyt(e):new uu(e,t,r,n==null?1:n)}function uu(e,t,r,n){this.l=+e,this.a=+t,this.b=+r,this.opacity=+n}Cp(uu,w_,Bm(Rh,{brighter:function(e){return new uu(this.l+aL*(e==null?1:e),this.a,this.b,this.opacity)},darker:function(e){return new uu(this.l-aL*(e==null?1:e),this.a,this.b,this.opacity)},rgb:function(){var e=(this.l+16)/116,t=isNaN(this.a)?e:e+this.a/500,r=isNaN(this.b)?e:e-this.b/200;return t=_yt*rY(t),e=yyt*rY(e),r=vyt*rY(r),new Ki(nY(3.1338561*t-1.6168667*e-.4906146*r),nY(-.9787684*t+1.9161415*e+.033454*r),nY(.0719453*t-.2289914*e+1.4052427*r),this.opacity)}}));function eY(e){return e>_we?Math.pow(e,1/3):e/byt+xyt}function rY(e){return e>mb?e*e*e:byt*(e-xyt)}function nY(e){return 255*(e<=.0031308?12.92*e:1.055*Math.pow(e,1/2.4)-.055)}function iY(e){return(e/=255)<=.04045?e/12.92:Math.pow((e+.055)/1.055,2.4)}function Myt(e){if(e instanceof Nh)return new Nh(e.h,e.c,e.l,e.opacity);if(e instanceof uu||(e=wyt(e)),e.a===0&&e.b===0)return new Nh(NaN,0<e.l&&e.l<100?0:NaN,e.l,e.opacity);var t=Math.atan2(e.b,e.a)*oL;return new Nh(t<0?t+360:t,Math.sqrt(e.a*e.a+e.b*e.b),e.l,e.opacity)}function Eyt(e,t,r,n){return arguments.length===1?Myt(e):new Nh(r,t,e,n==null?1:n)}function gb(e,t,r,n){return arguments.length===1?Myt(e):new Nh(e,t,r,n==null?1:n)}function Nh(e,t,r,n){this.h=+e,this.c=+t,this.l=+r,this.opacity=+n}function Tyt(e){if(isNaN(e.h))return new uu(e.l,0,0,e.opacity);var t=e.h*iL;return new uu(e.l,Math.cos(t)*e.c,Math.sin(t)*e.c,e.opacity)}Cp(Nh,gb,Bm(Rh,{brighter:function(e){return new Nh(this.h,this.c,this.l+aL*(e==null?1:e),this.opacity)},darker:function(e){return new Nh(this.h,this.c,this.l-aL*(e==null?1:e),this.opacity)},rgb:function(){return Tyt(this).rgb()}}));var Iyt=-.14861,oY=1.78277,aY=-.29227,sL=-.90649,IE=1.97294,Cyt=IE*sL,Ayt=IE*oY,Pyt=oY*aY-sL*Iyt;function ywe(e){if(e instanceof S_)return new S_(e.h,e.s,e.l,e.opacity);e instanceof Ki||(e=PE(e));var t=e.r/255,r=e.g/255,n=e.b/255,i=(Pyt*n+Cyt*t-Ayt*r)/(Pyt+Cyt-Ayt),o=n-i,a=(IE*(r-i)-aY*o)/sL,s=Math.sqrt(a*a+o*o)/(IE*i*(1-i)),l=s?Math.atan2(a,o)*oL-120:NaN;return new S_(l<0?l+360:l,s,i,e.opacity)}function la(e,t,r,n){return arguments.length===1?ywe(e):new S_(e,t,r,n==null?1:n)}function S_(e,t,r,n){this.h=+e,this.s=+t,this.l=+r,this.opacity=+n}Cp(S_,la,Bm(Rh,{brighter:function(e){return e=e==null?b_:Math.pow(b_,e),new S_(this.h,this.s,this.l*e,this.opacity)},darker:function(e){return e=e==null?Hm:Math.pow(Hm,e),new S_(this.h,this.s,this.l*e,this.opacity)},rgb:function(){var e=isNaN(this.h)?0:(this.h+120)*iL,t=+this.l,r=isNaN(this.s)?0:this.s*t*(1-t),n=Math.cos(e),i=Math.sin(e);return new Ki(255*(t+r*(Iyt*n+oY*i)),255*(t+r*(aY*n+sL*i)),255*(t+r*(IE*n)),this.opacity)}}));function sY(e,t,r,n,i){var o=e*e,a=o*e;return((1-3*e+3*o-a)*t+(4-6*o+3*a)*r+(1+3*e+3*o-3*a)*n+a*i)/6}function lL(e){var t=e.length-1;return function(r){var n=r<=0?r=0:r>=1?(r=1,t-1):Math.floor(r*t),i=e[n],o=e[n+1],a=n>0?e[n-1]:2*i-o,s=n<t-1?e[n+2]:2*o-i;return sY((r-n/t)*t,a,i,o,s)}}function cL(e){var t=e.length;return function(r){var n=Math.floor(((r%=1)<0?++r:r)*t),i=e[(n+t-1)%t],o=e[n%t],a=e[(n+1)%t],s=e[(n+2)%t];return sY((r-n/t)*t,i,o,a,s)}}function _b(e){return function(){return e}}function Lyt(e,t){return function(r){return e+r*t}}function vwe(e,t,r){return e=Math.pow(e,r),t=Math.pow(t,r)-e,r=1/r,function(n){return Math.pow(e+n*t,r)}}function Um(e,t){var r=t-e;return r?Lyt(e,r>180||r<-180?r-360*Math.round(r/360):r):_b(isNaN(e)?t:e)}function kyt(e){return(e=+e)==1?Kn:function(t,r){return r-t?vwe(t,r,e):_b(isNaN(t)?r:t)}}function Kn(e,t){var r=t-e;return r?Lyt(e,r):_b(isNaN(e)?t:e)}var qm=function e(t){var r=kyt(t);function n(i,o){var a=r((i=cu(i)).r,(o=cu(o)).r),s=r(i.g,o.g),l=r(i.b,o.b),c=Kn(i.opacity,o.opacity);return function(u){return i.r=a(u),i.g=s(u),i.b=l(u),i.opacity=c(u),i+""}}return n.gamma=e,n}(1);function Ryt(e){return function(t){var r=t.length,n=new Array(r),i=new Array(r),o=new Array(r),a,s;for(a=0;a<r;++a)s=cu(t[a]),n[a]=s.r||0,i[a]=s.g||0,o[a]=s.b||0;return n=e(n),i=e(i),o=e(o),s.opacity=1,function(l){return s.r=n(l),s.g=i(l),s.b=o(l),s+""}}}var uL=Ryt(lL),Nyt=Ryt(cL);function yb(e,t){t||(t=[]);var r=e?Math.min(t.length,e.length):0,n=t.slice(),i;return function(o){for(i=0;i<r;++i)n[i]=e[i]*(1-o)+t[i]*o;return n}}function hL(e){return ArrayBuffer.isView(e)&&!(e instanceof DataView)}function Dyt(e,t){return(hL(t)?yb:lY)(e,t)}function lY(e,t){var r=t?t.length:0,n=e?Math.min(r,e.length):0,i=new Array(n),o=new Array(r),a;for(a=0;a<n;++a)i[a]=nc(e[a],t[a]);for(;a<r;++a)o[a]=t[a];return function(s){for(a=0;a<n;++a)o[a]=i[a](s);return o}}function fL(e,t){var r=new Date;return e=+e,t=+t,function(n){return r.setTime(e*(1-n)+t*n),r}}function zi(e,t){return e=+e,t=+t,function(r){return e*(1-r)+t*r}}function pL(e,t){var r={},n={},i;(e===null||typeof e!="object")&&(e={}),(t===null||typeof t!="object")&&(t={});for(i in t)i in e?r[i]=nc(e[i],t[i]):n[i]=t[i];return function(o){for(i in r)n[i]=r[i](o);return n}}var uY=/[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,cY=new RegExp(uY.source,"g");function xwe(e){return function(){return e}}function bwe(e){return function(t){return e(t)+""}}function vb(e,t){var r=uY.lastIndex=cY.lastIndex=0,n,i,o,a=-1,s=[],l=[];for(e=e+"",t=t+"";(n=uY.exec(e))&&(i=cY.exec(t));)(o=i.index)>r&&(o=t.slice(r,o),s[a]?s[a]+=o:s[++a]=o),(n=n[0])===(i=i[0])?s[a]?s[a]+=i:s[++a]=i:(s[++a]=null,l.push({i:a,x:zi(n,i)})),r=cY.lastIndex;return r<t.length&&(o=t.slice(r),s[a]?s[a]+=o:s[++a]=o),s.length<2?l[0]?bwe(l[0].x):xwe(t):(t=l.length,function(c){for(var u=0,h;u<t;++u)s[(h=l[u]).i]=h.x(c);return s.join("")})}function nc(e,t){var r=typeof t,n;return t==null||r==="boolean"?_b(t):(r==="number"?zi:r==="string"?(n=rc(t))?(t=n,qm):vb:t instanceof rc?qm:t instanceof Date?fL:hL(t)?yb:Array.isArray(t)?lY:typeof t.valueOf!="function"&&typeof t.toString!="function"||isNaN(t)?pL:zi)(e,t)}function Oyt(e){var t=e.length;return function(r){return e[Math.max(0,Math.min(t-1,Math.floor(r*t)))]}}function zyt(e,t){var r=Um(+e,+t);return function(n){var i=r(n);return i-360*Math.floor(i/360)}}function dL(e,t){return e=+e,t=+t,function(r){return Math.round(e*(1-r)+t*r)}}var Fyt=180/Math.PI,mL={translateX:0,translateY:0,rotate:0,skewX:0,scaleX:1,scaleY:1};function hY(e,t,r,n,i,o){var a,s,l;return(a=Math.sqrt(e*e+t*t))&&(e/=a,t/=a),(l=e*r+t*n)&&(r-=e*l,n-=t*l),(s=Math.sqrt(r*r+n*n))&&(r/=s,n/=s,l/=s),e*n<t*r&&(e=-e,t=-t,l=-l,a=-a),{translateX:i,translateY:o,rotate:Math.atan2(t,e)*Fyt,skewX:Math.atan(l)*Fyt,scaleX:a,scaleY:s}}var LE,fY,Byt,gL;function Hyt(e){return e==="none"?mL:(LE||(LE=document.createElement("DIV"),fY=document.documentElement,Byt=document.defaultView),LE.style.transform=e,e=Byt.getComputedStyle(fY.appendChild(LE),null).getPropertyValue("transform"),fY.removeChild(LE),e=e.slice(7,-1).split(","),hY(+e[0],+e[1],+e[2],+e[3],+e[4],+e[5]))}function Vyt(e){return e==null?mL:(gL||(gL=document.createElementNS("http://www.w3.org/2000/svg","g")),gL.setAttribute("transform",e),(e=gL.transform.baseVal.consolidate())?(e=e.matrix,hY(e.a,e.b,e.c,e.d,e.e,e.f)):mL)}function Uyt(e,t,r,n){function i(c){return c.length?c.pop()+" ":""}function o(c,u,h,f,p,d){if(c!==h||u!==f){var g=p.push("translate(",null,t,null,r);d.push({i:g-4,x:zi(c,h)},{i:g-2,x:zi(u,f)})}else(h||f)&&p.push("translate("+h+t+f+r)}function a(c,u,h,f){c!==u?(c-u>180?u+=360:u-c>180&&(c+=360),f.push({i:h.push(i(h)+"rotate(",null,n)-2,x:zi(c,u)})):u&&h.push(i(h)+"rotate("+u+n)}function s(c,u,h,f){c!==u?f.push({i:h.push(i(h)+"skewX(",null,n)-2,x:zi(c,u)}):u&&h.push(i(h)+"skewX("+u+n)}function l(c,u,h,f,p,d){if(c!==h||u!==f){var g=p.push(i(p)+"scale(",null,",",null,")");d.push({i:g-4,x:zi(c,h)},{i:g-2,x:zi(u,f)})}else(h!==1||f!==1)&&p.push(i(p)+"scale("+h+","+f+")")}return function(c,u){var h=[],f=[];return c=e(c),u=e(u),o(c.translateX,c.translateY,u.translateX,u.translateY,h,f),a(c.rotate,u.rotate,h,f),s(c.skewX,u.skewX,h,f),l(c.scaleX,c.scaleY,u.scaleX,u.scaleY,h,f),c=u=null,function(p){for(var d=-1,g=f.length,_;++d<g;)h[(_=f[d]).i]=_.x(p);return h.join("")}}}var _L=Uyt(Hyt,"px, ","px)","deg)"),yL=Uyt(Vyt,", ",")",")");var kE=Math.SQRT2,pY=2,qyt=4,wwe=1e-12;function Gyt(e){return((e=Math.exp(e))+1/e)/2}function Swe(e){return((e=Math.exp(e))-1/e)/2}function Mwe(e){return((e=Math.exp(2*e))-1)/(e+1)}function vL(e,t){var r=e[0],n=e[1],i=e[2],o=t[0],a=t[1],s=t[2],l=o-r,c=a-n,u=l*l+c*c,h,f;if(u<wwe)f=Math.log(s/i)/kE,h=function(x){return[r+x*l,n+x*c,i*Math.exp(kE*x*f)]};else{var p=Math.sqrt(u),d=(s*s-i*i+qyt*u)/(2*i*pY*p),g=(s*s-i*i-qyt*u)/(2*s*pY*p),_=Math.log(Math.sqrt(d*d+1)-d),y=Math.log(Math.sqrt(g*g+1)-g);f=(y-_)/kE,h=function(x){var b=x*f,S=Gyt(_),C=i/(pY*p)*(S*Mwe(kE*b+_)-Swe(_));return[r+C*l,n+C*c,i*S/Gyt(kE*b+_)]}}return h.duration=f*1e3,h}function Wyt(e){return function(t,r){var n=e((t=Vm(t)).h,(r=Vm(r)).h),i=Kn(t.s,r.s),o=Kn(t.l,r.l),a=Kn(t.opacity,r.opacity);return function(s){return t.h=n(s),t.s=i(s),t.l=o(s),t.opacity=a(s),t+""}}}var Yyt=Wyt(Um),jyt=Wyt(Kn);function M_(e,t){var r=Kn((e=w_(e)).l,(t=w_(t)).l),n=Kn(e.a,t.a),i=Kn(e.b,t.b),o=Kn(e.opacity,t.opacity);return function(a){return e.l=r(a),e.a=n(a),e.b=i(a),e.opacity=o(a),e+""}}function Xyt(e){return function(t,r){var n=e((t=gb(t)).h,(r=gb(r)).h),i=Kn(t.c,r.c),o=Kn(t.l,r.l),a=Kn(t.opacity,r.opacity);return function(s){return t.h=n(s),t.c=i(s),t.l=o(s),t.opacity=a(s),t+""}}}var $yt=Xyt(Um),Kyt=Xyt(Kn);function Zyt(e){return function t(r){r=+r;function n(i,o){var a=e((i=la(i)).h,(o=la(o)).h),s=Kn(i.s,o.s),l=Kn(i.l,o.l),c=Kn(i.opacity,o.opacity);return function(u){return i.h=a(u),i.s=s(u),i.l=l(Math.pow(u,r)),i.opacity=c(u),i+""}}return n.gamma=t,n}(1)}var Jyt=Zyt(Um),E_=Zyt(Kn);function dY(e,t){for(var r=0,n=t.length-1,i=t[0],o=new Array(n<0?0:n);r<n;)o[r]=e(i,i=t[++r]);return function(a){var s=Math.max(0,Math.min(n-1,Math.floor(a*=n)));return o[s](a-s)}}function Qyt(e,t){for(var r=new Array(t),n=0;n<t;++n)r[n]=e(n/(t-1));return r}km();var xb=0,NE=0,RE=0,evt=1e3,xL,DE,bL=0,T_=0,wL=0,OE=typeof performance=="object"&&performance.now?performance:Date,rvt=typeof window=="object"&&window.requestAnimationFrame?window.requestAnimationFrame.bind(window):function(e){setTimeout(e,17)};function Ap(){return T_||(rvt(Ewe),T_=OE.now()+wL)}function Ewe(){T_=0}function C_(){this._call=this._time=this._next=null}C_.prototype=A_.prototype={constructor:C_,restart:function(e,t,r){if(typeof e!="function")throw new TypeError("callback is not a function");r=(r==null?Ap():+r)+(t==null?0:+t),!this._next&&DE!==this&&(DE?DE._next=this:xL=this,DE=this),this._call=e,this._time=r,mY()},stop:function(){this._call&&(this._call=null,this._time=1/0,mY())}};function A_(e,t,r){var n=new C_;return n.restart(e,t,r),n}function gY(){Ap(),++xb;for(var e=xL,t;e;)(t=T_-e._time)>=0&&e._call.call(null,t),e=e._next;--xb}function tvt(){T_=(bL=OE.now())+wL,xb=NE=0;try{gY()}finally{xb=0,Cwe(),T_=0}}function Twe(){var e=OE.now(),t=e-bL;t>evt&&(wL-=t,bL=e)}function Cwe(){for(var e,t=xL,r,n=1/0;t;)t._call?(n>t._time&&(n=t._time),e=t,t=t._next):(r=t._next,t._next=null,t=e?e._next=r:xL=r);DE=e,mY(n)}function mY(e){if(!xb){NE&&(NE=clearTimeout(NE));var t=e-T_;t>24?(e<1/0&&(NE=setTimeout(tvt,e-OE.now()-wL)),RE&&(RE=clearInterval(RE))):(RE||(bL=OE.now(),RE=setInterval(Twe,evt)),xb=1,rvt(tvt))}}function zE(e,t,r){var n=new C_;return t=t==null?0:+t,n.restart(function(i){n.stop(),e(i+t)},t,r),n}function nvt(e,t,r){var n=new C_,i=t;return t==null?(n.restart(e,t,r),n):(t=+t,r=r==null?Ap():+r,n.restart(function o(a){a+=i,n.restart(o,i+=t,r),e(a)},t,r),n)}var Awe=vs("start","end","cancel","interrupt"),Pwe=[],ovt=0,ML=1,EL=2,SL=3,ivt=4,TL=5,FE=6;function Gm(e,t,r,n,i,o){var a=e.__transition;if(!a)e.__transition={};else if(r in a)return;Iwe(e,r,{name:t,index:n,group:i,on:Awe,tween:Pwe,time:o.time,delay:o.delay,duration:o.duration,ease:o.ease,timer:null,state:ovt})}function BE(e,t){var r=Zi(e,t);if(r.state>ovt)throw new Error("too late; already scheduled");return r}function Oa(e,t){var r=Zi(e,t);if(r.state>SL)throw new Error("too late; already running");return r}function Zi(e,t){var r=e.__transition;if(!r||!(r=r[t]))throw new Error("transition not found");return r}function Iwe(e,t,r){var n=e.__transition,i;n[t]=r,r.timer=A_(o,0,r.time);function o(c){r.state=ML,r.timer.restart(a,r.delay,r.time),r.delay<=c&&a(c-r.delay)}function a(c){var u,h,f,p;if(r.state!==ML)return l();for(u in n)if(p=n[u],p.name===r.name){if(p.state===SL)return zE(a);p.state===ivt?(p.state=FE,p.timer.stop(),p.on.call("interrupt",e,e.__data__,p.index,p.group),delete n[u]):+u<t&&(p.state=FE,p.timer.stop(),p.on.call("cancel",e,e.__data__,p.index,p.group),delete n[u])}if(zE(function(){r.state===SL&&(r.state=ivt,r.timer.restart(s,r.delay,r.time),s(c))}),r.state=EL,r.on.call("start",e,e.__data__,r.index,r.group),r.state===EL){for(r.state=SL,i=new Array(f=r.tween.length),u=0,h=-1;u<f;++u)(p=r.tween[u].value.call(e,e.__data__,r.index,r.group))&&(i[++h]=p);i.length=h+1}}function s(c){for(var u=c<r.duration?r.ease.call(null,c/r.duration):(r.timer.restart(l),r.state=TL,1),h=-1,f=i.length;++h<f;)i[h].call(e,u);r.state===TL&&(r.on.call("end",e,e.__data__,r.index,r.group),l())}function l(){r.state=FE,r.timer.stop(),delete n[t];for(var c in n)return;delete e.__transition}}function hu(e,t){var r=e.__transition,n,i,o=!0,a;if(!!r){t=t==null?null:t+"";for(a in r){if((n=r[a]).name!==t){o=!1;continue}i=n.state>EL&&n.state<TL,n.state=FE,n.timer.stop(),n.on.call(i?"interrupt":"cancel",e,e.__data__,n.index,n.group),delete r[a]}o&&delete e.__transition}}function avt(e){return this.each(function(){hu(this,e)})}function Lwe(e,t){var r,n;return function(){var i=Oa(this,e),o=i.tween;if(o!==r){n=r=o;for(var a=0,s=n.length;a<s;++a)if(n[a].name===t){n=n.slice(),n.splice(a,1);break}}i.tween=n}}function kwe(e,t,r){var n,i;if(typeof r!="function")throw new Error;return function(){var o=Oa(this,e),a=o.tween;if(a!==n){i=(n=a).slice();for(var s={name:t,value:r},l=0,c=i.length;l<c;++l)if(i[l].name===t){i[l]=s;break}l===c&&i.push(s)}o.tween=i}}function svt(e,t){var r=this._id;if(e+="",arguments.length<2){for(var n=Zi(this.node(),r).tween,i=0,o=n.length,a;i<o;++i)if((a=n[i]).name===e)return a.value;return null}return this.each((t==null?Lwe:kwe)(r,e,t))}function bb(e,t,r){var n=e._id;return e.each(function(){var i=Oa(this,n);(i.value||(i.value={}))[t]=r.apply(this,arguments)}),function(i){return Zi(i,n).value[t]}}function CL(e,t){var r;return(typeof t=="number"?zi:t instanceof rc?qm:(r=rc(t))?(t=r,qm):vb)(e,t)}function Rwe(e){return function(){this.removeAttribute(e)}}function Nwe(e){return function(){this.removeAttributeNS(e.space,e.local)}}function Dwe(e,t,r){var n,i=r+"",o;return function(){var a=this.getAttribute(e);return a===i?null:a===n?o:o=t(n=a,r)}}function Owe(e,t,r){var n,i=r+"",o;return function(){var a=this.getAttributeNS(e.space,e.local);return a===i?null:a===n?o:o=t(n=a,r)}}function zwe(e,t,r){var n,i,o;return function(){var a,s=r(this),l;return s==null?void this.removeAttribute(e):(a=this.getAttribute(e),l=s+"",a===l?null:a===n&&l===i?o:(i=l,o=t(n=a,s)))}}function Fwe(e,t,r){var n,i,o;return function(){var a,s=r(this),l;return s==null?void this.removeAttributeNS(e.space,e.local):(a=this.getAttributeNS(e.space,e.local),l=s+"",a===l?null:a===n&&l===i?o:(i=l,o=t(n=a,s)))}}function lvt(e,t){var r=Ph(e),n=r==="transform"?yL:CL;return this.attrTween(e,typeof t=="function"?(r.local?Fwe:zwe)(r,n,bb(this,"attr."+e,t)):t==null?(r.local?Nwe:Rwe)(r):(r.local?Owe:Dwe)(r,n,t))}function Bwe(e,t){return function(r){this.setAttribute(e,t.call(this,r))}}function Hwe(e,t){return function(r){this.setAttributeNS(e.space,e.local,t.call(this,r))}}function Vwe(e,t){var r,n;function i(){var o=t.apply(this,arguments);return o!==n&&(r=(n=o)&&Hwe(e,o)),r}return i._value=t,i}function Uwe(e,t){var r,n;function i(){var o=t.apply(this,arguments);return o!==n&&(r=(n=o)&&Bwe(e,o)),r}return i._value=t,i}function cvt(e,t){var r="attr."+e;if(arguments.length<2)return(r=this.tween(r))&&r._value;if(t==null)return this.tween(r,null);if(typeof t!="function")throw new Error;var n=Ph(e);return this.tween(r,(n.local?Vwe:Uwe)(n,t))}function qwe(e,t){return function(){BE(this,e).delay=+t.apply(this,arguments)}}function Gwe(e,t){return t=+t,function(){BE(this,e).delay=t}}function uvt(e){var t=this._id;return arguments.length?this.each((typeof e=="function"?qwe:Gwe)(t,e)):Zi(this.node(),t).delay}function Wwe(e,t){return function(){Oa(this,e).duration=+t.apply(this,arguments)}}function Ywe(e,t){return t=+t,function(){Oa(this,e).duration=t}}function hvt(e){var t=this._id;return arguments.length?this.each((typeof e=="function"?Wwe:Ywe)(t,e)):Zi(this.node(),t).duration}function jwe(e,t){if(typeof t!="function")throw new Error;return function(){Oa(this,e).ease=t}}function fvt(e){var t=this._id;return arguments.length?this.each(jwe(t,e)):Zi(this.node(),t).ease}function pvt(e){typeof e!="function"&&(e=ub(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=[],l,c=0;c<a;++c)(l=o[c])&&e.call(l,l.__data__,c,o)&&s.push(l);return new Fo(n,this._parents,this._name,this._id)}function dvt(e){if(e._id!==this._id)throw new Error;for(var t=this._groups,r=e._groups,n=t.length,i=r.length,o=Math.min(n,i),a=new Array(n),s=0;s<o;++s)for(var l=t[s],c=r[s],u=l.length,h=a[s]=new Array(u),f,p=0;p<u;++p)(f=l[p]||c[p])&&(h[p]=f);for(;s<n;++s)a[s]=t[s];return new Fo(a,this._parents,this._name,this._id)}function Xwe(e){return(e+"").trim().split(/^|\s+/).every(function(t){var r=t.indexOf(".");return r>=0&&(t=t.slice(0,r)),!t||t==="start"})}function $we(e,t,r){var n,i,o=Xwe(t)?BE:Oa;return function(){var a=o(this,e),s=a.on;s!==n&&(i=(n=s).copy()).on(t,r),a.on=i}}function mvt(e,t){var r=this._id;return arguments.length<2?Zi(this.node(),r).on.on(e):this.each($we(r,e,t))}function Kwe(e){return function(){var t=this.parentNode;for(var r in this.__transition)if(+r!==e)return;t&&t.removeChild(this)}}function gvt(){return this.on("end.remove",Kwe(this._id))}function _vt(e){var t=this._name,r=this._id;typeof e!="function"&&(e=Nm(e));for(var n=this._groups,i=n.length,o=new Array(i),a=0;a<i;++a)for(var s=n[a],l=s.length,c=o[a]=new Array(l),u,h,f=0;f<l;++f)(u=s[f])&&(h=e.call(u,u.__data__,f,s))&&("__data__"in u&&(h.__data__=u.__data__),c[f]=h,Gm(c[f],t,r,f,c,Zi(u,r)));return new Fo(o,this._parents,t,r)}function yvt(e){var t=this._name,r=this._id;typeof e!="function"&&(e=cb(e));for(var n=this._groups,i=n.length,o=[],a=[],s=0;s<i;++s)for(var l=n[s],c=l.length,u,h=0;h<c;++h)if(u=l[h]){for(var f=e.call(u,u.__data__,h,l),p,d=Zi(u,r),g=0,_=f.length;g<_;++g)(p=f[g])&&Gm(p,t,r,g,f,d);o.push(f),a.push(u)}return new Fo(o,a,t,r)}var Zwe=Ih.prototype.constructor;function vvt(){return new Zwe(this._groups,this._parents)}function Jwe(e,t){var r,n,i;return function(){var o=Sp(this,e),a=(this.style.removeProperty(e),Sp(this,e));return o===a?null:o===r&&a===n?i:i=t(r=o,n=a)}}function xvt(e){return function(){this.style.removeProperty(e)}}function Qwe(e,t,r){var n,i=r+"",o;return function(){var a=Sp(this,e);return a===i?null:a===n?o:o=t(n=a,r)}}function tSe(e,t,r){var n,i,o;return function(){var a=Sp(this,e),s=r(this),l=s+"";return s==null&&(l=s=(this.style.removeProperty(e),Sp(this,e))),a===l?null:a===n&&l===i?o:(i=l,o=t(n=a,s))}}function eSe(e,t){var r,n,i,o="style."+t,a="end."+o,s;return function(){var l=Oa(this,e),c=l.on,u=l.value[o]==null?s||(s=xvt(t)):void 0;(c!==r||i!==u)&&(n=(r=c).copy()).on(a,i=u),l.on=n}}function bvt(e,t,r){var n=(e+="")=="transform"?_L:CL;return t==null?this.styleTween(e,Jwe(e,n)).on("end.style."+e,xvt(e)):typeof t=="function"?this.styleTween(e,tSe(e,n,bb(this,"style."+e,t))).each(eSe(this._id,e)):this.styleTween(e,Qwe(e,n,t),r).on("end.style."+e,null)}function rSe(e,t,r){return function(n){this.style.setProperty(e,t.call(this,n),r)}}function nSe(e,t,r){var n,i;function o(){var a=t.apply(this,arguments);return a!==i&&(n=(i=a)&&rSe(e,a,r)),n}return o._value=t,o}function wvt(e,t,r){var n="style."+(e+="");if(arguments.length<2)return(n=this.tween(n))&&n._value;if(t==null)return this.tween(n,null);if(typeof t!="function")throw new Error;return this.tween(n,nSe(e,t,r==null?"":r))}function iSe(e){return function(){this.textContent=e}}function oSe(e){return function(){var t=e(this);this.textContent=t==null?"":t}}function Svt(e){return this.tween("text",typeof e=="function"?oSe(bb(this,"text",e)):iSe(e==null?"":e+""))}function aSe(e){return function(t){this.textContent=e.call(this,t)}}function sSe(e){var t,r;function n(){var i=e.apply(this,arguments);return i!==r&&(t=(r=i)&&aSe(i)),t}return n._value=e,n}function Mvt(e){var t="text";if(arguments.length<1)return(t=this.tween(t))&&t._value;if(e==null)return this.tween(t,null);if(typeof e!="function")throw new Error;return this.tween(t,sSe(e))}function Evt(){for(var e=this._name,t=this._id,r=AL(),n=this._groups,i=n.length,o=0;o<i;++o)for(var a=n[o],s=a.length,l,c=0;c<s;++c)if(l=a[c]){var u=Zi(l,t);Gm(l,e,r,c,a,{time:u.time+u.delay+u.duration,delay:0,duration:u.duration,ease:u.ease})}return new Fo(n,this._parents,e,r)}function Tvt(){var e,t,r=this,n=r._id,i=r.size();return new Promise(function(o,a){var s={value:a},l={value:function(){--i===0&&o()}};r.each(function(){var c=Oa(this,n),u=c.on;u!==e&&(t=(e=u).copy(),t._.cancel.push(s),t._.interrupt.push(s),t._.end.push(l)),c.on=t})})}var lSe=0;function Fo(e,t,r,n){this._groups=e,this._parents=t,this._name=r,this._id=n}function PL(e){return Ih().transition(e)}function AL(){return++lSe}var wb=Ih.prototype;Fo.prototype=PL.prototype={constructor:Fo,select:_vt,selectAll:yvt,filter:pvt,merge:dvt,selection:vvt,transition:Evt,call:wb.call,nodes:wb.nodes,node:wb.node,size:wb.size,empty:wb.empty,each:wb.each,on:mvt,attr:lvt,attrTween:cvt,style:bvt,styleTween:wvt,text:Svt,textTween:Mvt,remove:gvt,tween:svt,delay:uvt,duration:hvt,ease:fvt,end:Tvt};I_();var UY={time:null,delay:0,duration:250,ease:xs};function _Se(e,t){for(var r;!(r=e.__transition)||!(r=r[t]);)if(!(e=e.parentNode))return UY.time=Ap(),UY;return r}function Hvt(e){var t,r;e instanceof Fo?(t=e._id,e=e._name):(t=AL(),(r=UY).time=Ap(),e=e==null?null:e+"");for(var n=this._groups,i=n.length,o=0;o<i;++o)for(var a=n[o],s=a.length,l,c=0;c<s;++c)(l=a[c])&&Gm(l,e,t,c,a,r||_Se(l,t));return new Fo(n,this._parents,e,t)}Ih.prototype.interrupt=avt;Ih.prototype.transition=Hvt;var ySe=[null];function Vvt(e,t){var r=e.__transition,n,i;if(r){t=t==null?null:t+"";for(i in r)if((n=r[i]).state>ML&&n.name===t)return new Fo([[e]],ySe,t,+i)}return null}function FL(e){return function(){return e}}function Uvt(e,t,r){this.target=e,this.type=t,this.selection=r}function qY(){qt.stopImmediatePropagation()}function BL(){qt.preventDefault(),qt.stopImmediatePropagation()}var qvt={name:"drag"},GY={name:"space"},Mb={name:"handle"},Eb={name:"center"};function Gvt(e){return[+e[0],+e[1]]}function YY(e){return[Gvt(e[0]),Gvt(e[1])]}function vSe(e){return function(t){return Tp(t,qt.touches,e)}}var HL={name:"x",handles:["w","e"].map(HE),input:function(e,t){return e==null?null:[[+e[0],t[0][1]],[+e[1],t[1][1]]]},output:function(e){return e&&[e[0][0],e[1][0]]}},VL={name:"y",handles:["n","s"].map(HE),input:function(e,t){return e==null?null:[[t[0][0],+e[0]],[t[1][0],+e[1]]]},output:function(e){return e&&[e[0][1],e[1][1]]}},xSe={name:"xy",handles:["n","w","e","s","nw","ne","sw","se"].map(HE),input:function(e){return e==null?null:YY(e)},output:function(e){return e}},Pp={overlay:"crosshair",selection:"move",n:"ns-resize",e:"ew-resize",s:"ns-resize",w:"ew-resize",nw:"nwse-resize",ne:"nesw-resize",se:"nwse-resize",sw:"nesw-resize"},Wvt={e:"w",w:"e",nw:"ne",ne:"nw",se:"sw",sw:"se"},Yvt={n:"s",s:"n",nw:"sw",ne:"se",se:"ne",sw:"nw"},bSe={overlay:1,selection:1,n:null,e:1,s:null,w:-1,nw:-1,ne:1,se:1,sw:-1},wSe={overlay:1,selection:1,n:-1,e:null,s:1,w:null,nw:-1,ne:-1,se:1,sw:1};function HE(e){return{type:e}}function SSe(){return!qt.ctrlKey&&!qt.button}function MSe(){var e=this.ownerSVGElement||this;return e.hasAttribute("viewBox")?(e=e.viewBox.baseVal,[[e.x,e.y],[e.x+e.width,e.y+e.height]]):[[0,0],[e.width.baseVal.value,e.height.baseVal.value]]}function ESe(){return navigator.maxTouchPoints||"ontouchstart"in this}function WY(e){for(;!e.__brush;)if(!(e=e.parentNode))return;return e.__brush}function TSe(e){return e[0][0]===e[1][0]||e[0][1]===e[1][1]}function UL(e){var t=e.__brush;return t?t.dim.output(t.selection):null}function jvt(){return jY(HL)}function qL(){return jY(VL)}function GL(){return jY(xSe)}function jY(e){var t=MSe,r=SSe,n=ESe,i=!0,o=vs("start","brush","end"),a=6,s;function l(_){var y=_.property("__brush",g).selectAll(".overlay").data([HE("overlay")]);y.enter().append("rect").attr("class","overlay").attr("pointer-events","all").attr("cursor",Pp.overlay).merge(y).each(function(){var b=WY(this).extent;Ht(this).attr("x",b[0][0]).attr("y",b[0][1]).attr("width",b[1][0]-b[0][0]).attr("height",b[1][1]-b[0][1])}),_.selectAll(".selection").data([HE("selection")]).enter().append("rect").attr("class","selection").attr("cursor",Pp.selection).attr("fill","#777").attr("fill-opacity",.3).attr("stroke","#fff").attr("shape-rendering","crispEdges");var x=_.selectAll(".handle").data(e.handles,function(b){return b.type});x.exit().remove(),x.enter().append("rect").attr("class",function(b){return"handle handle--"+b.type}).attr("cursor",function(b){return Pp[b.type]}),_.each(c).attr("fill","none").attr("pointer-events","all").on("mousedown.brush",f).filter(n).on("touchstart.brush",f).on("touchmove.brush",p).on("touchend.brush touchcancel.brush",d).style("touch-action","none").style("-webkit-tap-highlight-color","rgba(0,0,0,0)")}l.move=function(_,y){_.selection?_.on("start.brush",function(){u(this,arguments).beforestart().start()}).on("interrupt.brush end.brush",function(){u(this,arguments).end()}).tween("brush",function(){var x=this,b=x.__brush,S=u(x,arguments),C=b.selection,P=e.input(typeof y=="function"?y.apply(this,arguments):y,b.extent),k=nc(C,P);function O(D){b.selection=D===1&&P===null?null:k(D),c.call(x),S.brush()}return C!==null&&P!==null?O:O(1)}):_.each(function(){var x=this,b=arguments,S=x.__brush,C=e.input(typeof y=="function"?y.apply(x,b):y,S.extent),P=u(x,b).beforestart();hu(x),S.selection=C===null?null:C,c.call(x),P.start().brush().end()})},l.clear=function(_){l.move(_,null)};function c(){var _=Ht(this),y=WY(this).selection;y?(_.selectAll(".selection").style("display",null).attr("x",y[0][0]).attr("y",y[0][1]).attr("width",y[1][0]-y[0][0]).attr("height",y[1][1]-y[0][1]),_.selectAll(".handle").style("display",null).attr("x",function(x){return x.type[x.type.length-1]==="e"?y[1][0]-a/2:y[0][0]-a/2}).attr("y",function(x){return x.type[0]==="s"?y[1][1]-a/2:y[0][1]-a/2}).attr("width",function(x){return x.type==="n"||x.type==="s"?y[1][0]-y[0][0]+a:a}).attr("height",function(x){return x.type==="e"||x.type==="w"?y[1][1]-y[0][1]+a:a})):_.selectAll(".selection,.handle").style("display","none").attr("x",null).attr("y",null).attr("width",null).attr("height",null)}function u(_,y,x){var b=_.__brush.emitter;return b&&(!x||!b.clean)?b:new h(_,y,x)}function h(_,y,x){this.that=_,this.args=y,this.state=_.__brush,this.active=0,this.clean=x}h.prototype={beforestart:function(){return++this.active===1&&(this.state.emitter=this,this.starting=!0),this},start:function(){return this.starting?(this.starting=!1,this.emit("start")):this.emit("brush"),this},brush:function(){return this.emit("brush"),this},end:function(){return--this.active===0&&(delete this.state.emitter,this.emit("end")),this},emit:function(_){Mp(new Uvt(l,_,e.output(this.state.selection)),o.apply,o,[_,this.that,this.args])}};function f(){if(s&&!qt.touches||!r.apply(this,arguments))return;var _=this,y=qt.target.__data__.type,x=(i&&qt.metaKey?y="overlay":y)==="selection"?qvt:i&&qt.altKey?Eb:Mb,b=e===VL?null:bSe[y],S=e===HL?null:wSe[y],C=WY(_),P=C.extent,k=C.selection,O=P[0][0],D,B,I=P[0][1],L,R,F=P[1][0],z,U,W=P[1][1],Z,rt,ot=0,st=0,St,bt=b&&S&&i&&qt.shiftKey,Mt,lt,Kt=qt.touches?vSe(qt.changedTouches[0].identifier):zo,_t=Kt(_),ct=_t,X=u(_,arguments,!0).beforestart();y==="overlay"?(k&&(St=!0),C.selection=k=[[D=e===VL?O:_t[0],L=e===HL?I:_t[1]],[z=e===VL?F:D,Z=e===HL?W:L]]):(D=k[0][0],L=k[0][1],z=k[1][0],Z=k[1][1]),B=D,R=L,U=z,rt=Z;var et=Ht(_).attr("pointer-events","none"),dt=et.selectAll(".overlay").attr("cursor",Pp[y]);if(qt.touches)X.moved=pt,X.ended=wt;else{var q=Ht(qt.view).on("mousemove.brush",pt,!0).on("mouseup.brush",wt,!0);i&&q.on("keydown.brush",kt,!0).on("keyup.brush",ie,!0),zm(qt.view)}qY(),hu(_),c.call(_),X.start();function pt(){var ee=Kt(_);bt&&!Mt&&!lt&&(Math.abs(ee[0]-ct[0])>Math.abs(ee[1]-ct[1])?lt=!0:Mt=!0),ct=ee,St=!0,BL(),ht()}function ht(){var ee;switch(ot=ct[0]-_t[0],st=ct[1]-_t[1],x){case GY:case qvt:{b&&(ot=Math.max(O-D,Math.min(F-z,ot)),B=D+ot,U=z+ot),S&&(st=Math.max(I-L,Math.min(W-Z,st)),R=L+st,rt=Z+st);break}case Mb:{b<0?(ot=Math.max(O-D,Math.min(F-D,ot)),B=D+ot,U=z):b>0&&(ot=Math.max(O-z,Math.min(F-z,ot)),B=D,U=z+ot),S<0?(st=Math.max(I-L,Math.min(W-L,st)),R=L+st,rt=Z):S>0&&(st=Math.max(I-Z,Math.min(W-Z,st)),R=L,rt=Z+st);break}case Eb:{b&&(B=Math.max(O,Math.min(F,D-ot*b)),U=Math.max(O,Math.min(F,z+ot*b))),S&&(R=Math.max(I,Math.min(W,L-st*S)),rt=Math.max(I,Math.min(W,Z+st*S)));break}}U<B&&(b*=-1,ee=D,D=z,z=ee,ee=B,B=U,U=ee,y in Wvt&&dt.attr("cursor",Pp[y=Wvt[y]])),rt<R&&(S*=-1,ee=L,L=Z,Z=ee,ee=R,R=rt,rt=ee,y in Yvt&&dt.attr("cursor",Pp[y=Yvt[y]])),C.selection&&(k=C.selection),Mt&&(B=k[0][0],U=k[1][0]),lt&&(R=k[0][1],rt=k[1][1]),(k[0][0]!==B||k[0][1]!==R||k[1][0]!==U||k[1][1]!==rt)&&(C.selection=[[B,R],[U,rt]],c.call(_),X.brush())}function wt(){if(qY(),qt.touches){if(qt.touches.length)return;s&&clearTimeout(s),s=setTimeout(function(){s=null},500)}else Fm(qt.view,St),q.on("keydown.brush keyup.brush mousemove.brush mouseup.brush",null);et.attr("pointer-events","all"),dt.attr("cursor",Pp.overlay),C.selection&&(k=C.selection),TSe(k)&&(C.selection=null,c.call(_)),X.end()}function kt(){switch(qt.keyCode){case 16:{bt=b&&S;break}case 18:{x===Mb&&(b&&(z=U-ot*b,D=B+ot*b),S&&(Z=rt-st*S,L=R+st*S),x=Eb,ht());break}case 32:{(x===Mb||x===Eb)&&(b<0?z=U-ot:b>0&&(D=B-ot),S<0?Z=rt-st:S>0&&(L=R-st),x=GY,dt.attr("cursor",Pp.selection),ht());break}default:return}BL()}function ie(){switch(qt.keyCode){case 16:{bt&&(Mt=lt=bt=!1,ht());break}case 18:{x===Eb&&(b<0?z=U:b>0&&(D=B),S<0?Z=rt:S>0&&(L=R),x=Mb,ht());break}case 32:{x===GY&&(qt.altKey?(b&&(z=U-ot*b,D=B+ot*b),S&&(Z=rt-st*S,L=R+st*S),x=Eb):(b<0?z=U:b>0&&(D=B),S<0?Z=rt:S>0&&(L=R),x=Mb),dt.attr("cursor",Pp[y]),ht());break}default:return}BL()}}function p(){u(this,arguments).moved()}function d(){u(this,arguments).ended()}function g(){var _=this.__brush||{selection:null};return _.extent=YY(t.apply(this,arguments)),_.dim=e,_}return l.extent=function(_){return arguments.length?(t=typeof _=="function"?_:FL(YY(_)),l):t},l.filter=function(_){return arguments.length?(r=typeof _=="function"?_:FL(!!_),l):r},l.touchable=function(_){return arguments.length?(n=typeof _=="function"?_:FL(!!_),l):n},l.handleSize=function(_){return arguments.length?(a=+_,l):a},l.keyModifiers=function(_){return arguments.length?(i=!!_,l):i},l.on=function(){var _=o.on.apply(o,arguments);return _===o?l:_},l}var XY=Math.cos,$Y=Math.sin,Xvt=Math.PI,VE=Xvt/2,KY=Xvt*2,ZY=Math.max;function CSe(e){return function(t,r){return e(t.source.value+t.target.value,r.source.value+r.target.value)}}function $vt(){var e=0,t=null,r=null,n=null;function i(o){var a=o.length,s=[],l=Ir(a),c=[],u=[],h=u.groups=new Array(a),f=new Array(a*a),p,d,g,_,y,x;for(p=0,y=-1;++y<a;){for(d=0,x=-1;++x<a;)d+=o[y][x];s.push(d),c.push(Ir(a)),p+=d}for(t&&l.sort(function(B,I){return t(s[B],s[I])}),r&&c.forEach(function(B,I){B.sort(function(L,R){return r(o[I][L],o[I][R])})}),p=ZY(0,KY-e*a)/p,_=p?e:KY/a,d=0,y=-1;++y<a;){for(g=d,x=-1;++x<a;){var b=l[y],S=c[b][x],C=o[b][S],P=d,k=d+=C*p;f[S*a+b]={index:b,subindex:S,startAngle:P,endAngle:k,value:C}}h[b]={index:b,startAngle:g,endAngle:d,value:s[b]},d+=_}for(y=-1;++y<a;)for(x=y-1;++x<a;){var O=f[x*a+y],D=f[y*a+x];(O.value||D.value)&&u.push(O.value<D.value?{source:D,target:O}:{source:O,target:D})}return n?u.sort(n):u}return i.padAngle=function(o){return arguments.length?(e=ZY(0,o),i):e},i.sortGroups=function(o){return arguments.length?(t=o,i):t},i.sortSubgroups=function(o){return arguments.length?(r=o,i):r},i.sortChords=function(o){return arguments.length?(o==null?n=null:(n=CSe(o))._=o,i):n&&n._},i}var Kvt=Array.prototype.slice;function WL(e){return function(){return e}}var JY=Math.PI,QY=2*JY,L_=1e-6,ASe=QY-L_;function tj(){this._x0=this._y0=this._x1=this._y1=null,this._=""}function Zvt(){return new tj}tj.prototype=Zvt.prototype={constructor:tj,moveTo:function(e,t){this._+="M"+(this._x0=this._x1=+e)+","+(this._y0=this._y1=+t)},closePath:function(){this._x1!==null&&(this._x1=this._x0,this._y1=this._y0,this._+="Z")},lineTo:function(e,t){this._+="L"+(this._x1=+e)+","+(this._y1=+t)},quadraticCurveTo:function(e,t,r,n){this._+="Q"+ +e+","+ +t+","+(this._x1=+r)+","+(this._y1=+n)},bezierCurveTo:function(e,t,r,n,i,o){this._+="C"+ +e+","+ +t+","+ +r+","+ +n+","+(this._x1=+i)+","+(this._y1=+o)},arcTo:function(e,t,r,n,i){e=+e,t=+t,r=+r,n=+n,i=+i;var o=this._x1,a=this._y1,s=r-e,l=n-t,c=o-e,u=a-t,h=c*c+u*u;if(i<0)throw new Error("negative radius: "+i);if(this._x1===null)this._+="M"+(this._x1=e)+","+(this._y1=t);else if(h>L_)if(!(Math.abs(u*s-l*c)>L_)||!i)this._+="L"+(this._x1=e)+","+(this._y1=t);else{var f=r-o,p=n-a,d=s*s+l*l,g=f*f+p*p,_=Math.sqrt(d),y=Math.sqrt(h),x=i*Math.tan((JY-Math.acos((d+h-g)/(2*_*y)))/2),b=x/y,S=x/_;Math.abs(b-1)>L_&&(this._+="L"+(e+b*c)+","+(t+b*u)),this._+="A"+i+","+i+",0,0,"+ +(u*f>c*p)+","+(this._x1=e+S*s)+","+(this._y1=t+S*l)}},arc:function(e,t,r,n,i,o){e=+e,t=+t,r=+r,o=!!o;var a=r*Math.cos(n),s=r*Math.sin(n),l=e+a,c=t+s,u=1^o,h=o?n-i:i-n;if(r<0)throw new Error("negative radius: "+r);this._x1===null?this._+="M"+l+","+c:(Math.abs(this._x1-l)>L_||Math.abs(this._y1-c)>L_)&&(this._+="L"+l+","+c),r&&(h<0&&(h=h%QY+QY),h>ASe?this._+="A"+r+","+r+",0,1,"+u+","+(e-a)+","+(t-s)+"A"+r+","+r+",0,1,"+u+","+(this._x1=l)+","+(this._y1=c):h>L_&&(this._+="A"+r+","+r+",0,"+ +(h>=JY)+","+u+","+(this._x1=e+r*Math.cos(i))+","+(this._y1=t+r*Math.sin(i))))},rect:function(e,t,r,n){this._+="M"+(this._x0=this._x1=+e)+","+(this._y0=this._y1=+t)+"h"+ +r+"v"+ +n+"h"+-r+"Z"},toString:function(){return this._}};var bs=Zvt;function PSe(e){return e.source}function ISe(e){return e.target}function LSe(e){return e.radius}function kSe(e){return e.startAngle}function RSe(e){return e.endAngle}function Jvt(){var e=PSe,t=ISe,r=LSe,n=kSe,i=RSe,o=null;function a(){var s,l=Kvt.call(arguments),c=e.apply(this,l),u=t.apply(this,l),h=+r.apply(this,(l[0]=c,l)),f=n.apply(this,l)-VE,p=i.apply(this,l)-VE,d=h*XY(f),g=h*$Y(f),_=+r.apply(this,(l[0]=u,l)),y=n.apply(this,l)-VE,x=i.apply(this,l)-VE;if(o||(o=s=bs()),o.moveTo(d,g),o.arc(0,0,h,f,p),(f!==y||p!==x)&&(o.quadraticCurveTo(0,0,_*XY(y),_*$Y(y)),o.arc(0,0,_,y,x)),o.quadraticCurveTo(0,0,d,g),o.closePath(),s)return o=null,s+""||null}return a.radius=function(s){return arguments.length?(r=typeof s=="function"?s:WL(+s),a):r},a.startAngle=function(s){return arguments.length?(n=typeof s=="function"?s:WL(+s),a):n},a.endAngle=function(s){return arguments.length?(i=typeof s=="function"?s:WL(+s),a):i},a.source=function(s){return arguments.length?(e=s,a):e},a.target=function(s){return arguments.length?(t=s,a):t},a.context=function(s){return arguments.length?(o=s==null?null:s,a):o},a}Tb();var OSe=Array.prototype,KL=OSe.slice;function f1t(e,t){return e-t}function p1t(e){for(var t=0,r=e.length,n=e[r-1][1]*e[0][0]-e[r-1][0]*e[0][1];++t<r;)n+=e[t-1][1]*e[t][0]-e[t-1][0]*e[t][1];return n}function Oh(e){return function(){return e}}function d1t(e,t){for(var r=-1,n=t.length,i;++r<n;)if(i=zSe(e,t[r]))return i;return 0}function zSe(e,t){for(var r=t[0],n=t[1],i=-1,o=0,a=e.length,s=a-1;o<a;s=o++){var l=e[o],c=l[0],u=l[1],h=e[s],f=h[0],p=h[1];if(FSe(l,h,t))return 0;u>n!=p>n&&r<(f-c)*(n-u)/(p-u)+c&&(i=-i)}return i}function FSe(e,t,r){var n;return BSe(e,t,r)&&HSe(e[n=+(e[0]===t[0])],r[n],t[n])}function BSe(e,t,r){return(t[0]-e[0])*(r[1]-e[1])===(r[0]-e[0])*(t[1]-e[1])}function HSe(e,t,r){return e<=t&&t<=r||r<=t&&t<=e}function m1t(){}var Ip=[[],[[[1,1.5],[.5,1]]],[[[1.5,1],[1,1.5]]],[[[1.5,1],[.5,1]]],[[[1,.5],[1.5,1]]],[[[1,1.5],[.5,1]],[[1,.5],[1.5,1]]],[[[1,.5],[1,1.5]]],[[[1,.5],[.5,1]]],[[[.5,1],[1,.5]]],[[[1,1.5],[1,.5]]],[[[.5,1],[1,.5]],[[1.5,1],[1,1.5]]],[[[1.5,1],[1,.5]]],[[[.5,1],[1.5,1]]],[[[1,1.5],[1.5,1]]],[[[.5,1],[1,1.5]]],[]];function ZL(){var e=1,t=1,r=sb,n=l;function i(c){var u=r(c);if(Array.isArray(u))u=u.slice().sort(f1t);else{var h=aa(c),f=h[0],p=h[1];u=tl(f,p,u),u=Ir(Math.floor(f/u)*u,Math.floor(p/u)*u,u)}return u.map(function(d){return o(c,d)})}function o(c,u){var h=[],f=[];return a(c,u,function(p){n(p,c,u),p1t(p)>0?h.push([p]):f.push(p)}),f.forEach(function(p){for(var d=0,g=h.length,_;d<g;++d)if(d1t((_=h[d])[0],p)!==-1){_.push(p);return}}),{type:"MultiPolygon",value:u,coordinates:h}}function a(c,u,h){var f=new Array,p=new Array,d,g,_,y,x,b;for(d=g=-1,y=c[0]>=u,Ip[y<<1].forEach(S);++d<e-1;)_=y,y=c[d+1]>=u,Ip[_|y<<1].forEach(S);for(Ip[y<<0].forEach(S);++g<t-1;){for(d=-1,y=c[g*e+e]>=u,x=c[g*e]>=u,Ip[y<<1|x<<2].forEach(S);++d<e-1;)_=y,y=c[g*e+e+d+1]>=u,b=x,x=c[g*e+d+1]>=u,Ip[_|y<<1|x<<2|b<<3].forEach(S);Ip[y|x<<3].forEach(S)}for(d=-1,x=c[g*e]>=u,Ip[x<<2].forEach(S);++d<e-1;)b=x,x=c[g*e+d+1]>=u,Ip[x<<2|b<<3].forEach(S);Ip[x<<3].forEach(S);function S(C){var P=[C[0][0]+d,C[0][1]+g],k=[C[1][0]+d,C[1][1]+g],O=s(P),D=s(k),B,I;(B=p[O])?(I=f[D])?(delete p[B.end],delete f[I.start],B===I?(B.ring.push(k),h(B.ring)):f[B.start]=p[I.end]={start:B.start,end:I.end,ring:B.ring.concat(I.ring)}):(delete p[B.end],B.ring.push(k),p[B.end=D]=B):(B=f[D])?(I=p[O])?(delete f[B.start],delete p[I.end],B===I?(B.ring.push(k),h(B.ring)):f[I.start]=p[B.end]={start:I.start,end:B.end,ring:I.ring.concat(B.ring)}):(delete f[B.start],B.ring.unshift(P),f[B.start=O]=B):f[O]=p[D]={start:O,end:D,ring:[P,k]}}}function s(c){return c[0]*2+c[1]*(e+1)*4}function l(c,u,h){c.forEach(function(f){var p=f[0],d=f[1],g=p|0,_=d|0,y,x=u[_*e+g];p>0&&p<e&&g===p&&(y=u[_*e+g-1],f[0]=p+(h-y)/(x-y)-.5),d>0&&d<t&&_===d&&(y=u[(_-1)*e+g],f[1]=d+(h-y)/(x-y)-.5)})}return i.contour=o,i.size=function(c){if(!arguments.length)return[e,t];var u=Math.ceil(c[0]),h=Math.ceil(c[1]);if(!(u>0)||!(h>0))throw new Error("invalid size");return e=u,t=h,i},i.thresholds=function(c){return arguments.length?(r=typeof c=="function"?c:Array.isArray(c)?Oh(KL.call(c)):Oh(c),i):r},i.smooth=function(c){return arguments.length?(n=c?l:m1t,i):n===l},i}function JL(e,t,r){for(var n=e.width,i=e.height,o=(r<<1)+1,a=0;a<i;++a)for(var s=0,l=0;s<n+r;++s)s<n&&(l+=e.data[s+a*n]),s>=r&&(s>=o&&(l-=e.data[s-o+a*n]),t.data[s-r+a*n]=l/Math.min(s+1,n-1+o-s,o))}function QL(e,t,r){for(var n=e.width,i=e.height,o=(r<<1)+1,a=0;a<n;++a)for(var s=0,l=0;s<i+r;++s)s<i&&(l+=e.data[a+s*n]),s>=r&&(s>=o&&(l-=e.data[a+(s-o)*n]),t.data[a+(s-r)*n]=l/Math.min(s+1,i-1+o-s,o))}function VSe(e){return e[0]}function USe(e){return e[1]}function qSe(){return 1}function g1t(){var e=VSe,t=USe,r=qSe,n=960,i=500,o=20,a=2,s=o*3,l=n+s*2>>a,c=i+s*2>>a,u=Oh(20);function h(y){var x=new Float32Array(l*c),b=new Float32Array(l*c);y.forEach(function(P,k,O){var D=+e(P,k,O)+s>>a,B=+t(P,k,O)+s>>a,I=+r(P,k,O);D>=0&&D<l&&B>=0&&B<c&&(x[D+B*l]+=I)}),JL({width:l,height:c,data:x},{width:l,height:c,data:b},o>>a),QL({width:l,height:c,data:b},{width:l,height:c,data:x},o>>a),JL({width:l,height:c,data:x},{width:l,height:c,data:b},o>>a),QL({width:l,height:c,data:b},{width:l,height:c,data:x},o>>a),JL({width:l,height:c,data:x},{width:l,height:c,data:b},o>>a),QL({width:l,height:c,data:b},{width:l,height:c,data:x},o>>a);var S=u(x);if(!Array.isArray(S)){var C=lu(x);S=tl(0,C,S),S=Ir(0,Math.floor(C/S)*S,S),S.shift()}return ZL().thresholds(S).size([l,c])(x).map(f)}function f(y){return y.value*=Math.pow(2,-2*a),y.coordinates.forEach(p),y}function p(y){y.forEach(d)}function d(y){y.forEach(g)}function g(y){y[0]=y[0]*Math.pow(2,a)-s,y[1]=y[1]*Math.pow(2,a)-s}function _(){return s=o*3,l=n+s*2>>a,c=i+s*2>>a,h}return h.x=function(y){return arguments.length?(e=typeof y=="function"?y:Oh(+y),h):e},h.y=function(y){return arguments.length?(t=typeof y=="function"?y:Oh(+y),h):t},h.weight=function(y){return arguments.length?(r=typeof y=="function"?y:Oh(+y),h):r},h.size=function(y){if(!arguments.length)return[n,i];var x=Math.ceil(y[0]),b=Math.ceil(y[1]);if(!(x>=0)&&!(x>=0))throw new Error("invalid size");return n=x,i=b,_()},h.cellSize=function(y){if(!arguments.length)return 1<<a;if(!((y=+y)>=1))throw new Error("invalid cell size");return a=Math.floor(Math.log(y)/Math.LN2),_()},h.thresholds=function(y){return arguments.length?(u=typeof y=="function"?y:Array.isArray(y)?Oh(KL.call(y)):Oh(y),h):u},h.bandwidth=function(y){if(!arguments.length)return Math.sqrt(o*(o+1));if(!((y=+y)>=0))throw new Error("invalid bandwidth");return o=Math.round((Math.sqrt(4*y*y+1)-1)/2),_()},h}km();qE();I_();function XSe(e){if(!e.ok)throw new Error(e.status+" "+e.statusText);return e.blob()}function D1t(e,t){return fetch(e,t).then(XSe)}function $Se(e){if(!e.ok)throw new Error(e.status+" "+e.statusText);return e.arrayBuffer()}function O1t(e,t){return fetch(e,t).then($Se)}qE();function KSe(e){if(!e.ok)throw new Error(e.status+" "+e.statusText);return e.text()}function D_(e,t){return fetch(e,t).then(KSe)}function z1t(e){return function(t,r,n){return arguments.length===2&&typeof r=="function"&&(n=r,r=void 0),D_(t,r).then(function(i){return e(i,n)})}}function oj(e,t,r,n){arguments.length===3&&typeof r=="function"&&(n=r,r=void 0);var i=Wm(e);return D_(t,r).then(function(o){return i.parse(o,n)})}var F1t=z1t(Cb),B1t=z1t(Ab);function H1t(e,t){return new Promise(function(r,n){var i=new Image;for(var o in t)i[o]=t[o];i.onerror=n,i.onload=function(){r(i)},i.src=e})}function ZSe(e){if(!e.ok)throw new Error(e.status+" "+e.statusText);if(!(e.status===204||e.status===205))return e.json()}function V1t(e,t){return fetch(e,t).then(ZSe)}function aj(e){return function(t,r){return D_(t,r).then(function(n){return new DOMParser().parseFromString(n,e)})}}var U1t=aj("application/xml"),q1t=aj("text/html"),G1t=aj("image/svg+xml");function W1t(e,t){var r;e==null&&(e=0),t==null&&(t=0);function n(){var i,o=r.length,a,s=0,l=0;for(i=0;i<o;++i)a=r[i],s+=a.x,l+=a.y;for(s=s/o-e,l=l/o-t,i=0;i<o;++i)a=r[i],a.x-=s,a.y-=l}return n.initialize=function(i){r=i},n.x=function(i){return arguments.length?(e=+i,n):e},n.y=function(i){return arguments.length?(t=+i,n):t},n}function Dn(e){return function(){return e}}function fu(){return(Math.random()-.5)*1e-6}function Y1t(e){var t=+this._x.call(null,e),r=+this._y.call(null,e);return j1t(this.cover(t,r),t,r,e)}function j1t(e,t,r,n){if(isNaN(t)||isNaN(r))return e;var i,o=e._root,a={data:n},s=e._x0,l=e._y0,c=e._x1,u=e._y1,h,f,p,d,g,_,y,x;if(!o)return e._root=a,e;for(;o.length;)if((g=t>=(h=(s+c)/2))?s=h:c=h,(_=r>=(f=(l+u)/2))?l=f:u=f,i=o,!(o=o[y=_<<1|g]))return i[y]=a,e;if(p=+e._x.call(null,o.data),d=+e._y.call(null,o.data),t===p&&r===d)return a.next=o,i?i[y]=a:e._root=a,e;do i=i?i[y]=new Array(4):e._root=new Array(4),(g=t>=(h=(s+c)/2))?s=h:c=h,(_=r>=(f=(l+u)/2))?l=f:u=f;while((y=_<<1|g)===(x=(d>=f)<<1|p>=h));return i[x]=o,i[y]=a,e}function X1t(e){var t,r,n=e.length,i,o,a=new Array(n),s=new Array(n),l=1/0,c=1/0,u=-1/0,h=-1/0;for(r=0;r<n;++r)isNaN(i=+this._x.call(null,t=e[r]))||isNaN(o=+this._y.call(null,t))||(a[r]=i,s[r]=o,i<l&&(l=i),i>u&&(u=i),o<c&&(c=o),o>h&&(h=o));if(l>u||c>h)return this;for(this.cover(l,c).cover(u,h),r=0;r<n;++r)j1t(this,a[r],s[r],e[r]);return this}function $1t(e,t){if(isNaN(e=+e)||isNaN(t=+t))return this;var r=this._x0,n=this._y0,i=this._x1,o=this._y1;if(isNaN(r))i=(r=Math.floor(e))+1,o=(n=Math.floor(t))+1;else{for(var a=i-r,s=this._root,l,c;r>e||e>=i||n>t||t>=o;)switch(c=(t<n)<<1|e<r,l=new Array(4),l[c]=s,s=l,a*=2,c){case 0:i=r+a,o=n+a;break;case 1:r=i-a,o=n+a;break;case 2:i=r+a,n=o-a;break;case 3:r=i-a,n=o-a;break}this._root&&this._root.length&&(this._root=s)}return this._x0=r,this._y0=n,this._x1=i,this._y1=o,this}function K1t(){var e=[];return this.visit(function(t){if(!t.length)do e.push(t.data);while(t=t.next)}),e}function Z1t(e){return arguments.length?this.cover(+e[0][0],+e[0][1]).cover(+e[1][0],+e[1][1]):isNaN(this._x0)?void 0:[[this._x0,this._y0],[this._x1,this._y1]]}function yo(e,t,r,n,i){this.node=e,this.x0=t,this.y0=r,this.x1=n,this.y1=i}function J1t(e,t,r){var n,i=this._x0,o=this._y0,a,s,l,c,u=this._x1,h=this._y1,f=[],p=this._root,d,g;for(p&&f.push(new yo(p,i,o,u,h)),r==null?r=1/0:(i=e-r,o=t-r,u=e+r,h=t+r,r*=r);d=f.pop();)if(!(!(p=d.node)||(a=d.x0)>u||(s=d.y0)>h||(l=d.x1)<i||(c=d.y1)<o))if(p.length){var _=(a+l)/2,y=(s+c)/2;f.push(new yo(p[3],_,y,l,c),new yo(p[2],a,y,_,c),new yo(p[1],_,s,l,y),new yo(p[0],a,s,_,y)),(g=(t>=y)<<1|e>=_)&&(d=f[f.length-1],f[f.length-1]=f[f.length-1-g],f[f.length-1-g]=d)}else{var x=e-+this._x.call(null,p.data),b=t-+this._y.call(null,p.data),S=x*x+b*b;if(S<r){var C=Math.sqrt(r=S);i=e-C,o=t-C,u=e+C,h=t+C,n=p.data}}return n}function Q1t(e){if(isNaN(u=+this._x.call(null,e))||isNaN(h=+this._y.call(null,e)))return this;var t,r=this._root,n,i,o,a=this._x0,s=this._y0,l=this._x1,c=this._y1,u,h,f,p,d,g,_,y;if(!r)return this;if(r.length)for(;;){if((d=u>=(f=(a+l)/2))?a=f:l=f,(g=h>=(p=(s+c)/2))?s=p:c=p,t=r,!(r=r[_=g<<1|d]))return this;if(!r.length)break;(t[_+1&3]||t[_+2&3]||t[_+3&3])&&(n=t,y=_)}for(;r.data!==e;)if(i=r,!(r=r.next))return this;return(o=r.next)&&delete r.next,i?(o?i.next=o:delete i.next,this):t?(o?t[_]=o:delete t[_],(r=t[0]||t[1]||t[2]||t[3])&&r===(t[3]||t[2]||t[1]||t[0])&&!r.length&&(n?n[y]=r:this._root=r),this):(this._root=o,this)}function txt(e){for(var t=0,r=e.length;t<r;++t)this.remove(e[t]);return this}function ext(){return this._root}function rxt(){var e=0;return this.visit(function(t){if(!t.length)do++e;while(t=t.next)}),e}function nxt(e){var t=[],r,n=this._root,i,o,a,s,l;for(n&&t.push(new yo(n,this._x0,this._y0,this._x1,this._y1));r=t.pop();)if(!e(n=r.node,o=r.x0,a=r.y0,s=r.x1,l=r.y1)&&n.length){var c=(o+s)/2,u=(a+l)/2;(i=n[3])&&t.push(new yo(i,c,u,s,l)),(i=n[2])&&t.push(new yo(i,o,u,c,l)),(i=n[1])&&t.push(new yo(i,c,a,s,u)),(i=n[0])&&t.push(new yo(i,o,a,c,u))}return this}function ixt(e){var t=[],r=[],n;for(this._root&&t.push(new yo(this._root,this._x0,this._y0,this._x1,this._y1));n=t.pop();){var i=n.node;if(i.length){var o,a=n.x0,s=n.y0,l=n.x1,c=n.y1,u=(a+l)/2,h=(s+c)/2;(o=i[0])&&t.push(new yo(o,a,s,u,h)),(o=i[1])&&t.push(new yo(o,u,s,l,h)),(o=i[2])&&t.push(new yo(o,a,h,u,c)),(o=i[3])&&t.push(new yo(o,u,h,l,c))}r.push(n)}for(;n=r.pop();)e(n.node,n.x0,n.y0,n.x1,n.y1);return this}function oxt(e){return e[0]}function axt(e){return arguments.length?(this._x=e,this):this._x}function sxt(e){return e[1]}function lxt(e){return arguments.length?(this._y=e,this):this._y}function zh(e,t,r){var n=new sj(t==null?oxt:t,r==null?sxt:r,NaN,NaN,NaN,NaN);return e==null?n:n.addAll(e)}function sj(e,t,r,n,i,o){this._x=e,this._y=t,this._x0=r,this._y0=n,this._x1=i,this._y1=o,this._root=void 0}function cxt(e){for(var t={data:e.data},r=t;e=e.next;)r=r.next={data:e.data};return t}var za=zh.prototype=sj.prototype;za.copy=function(){var e=new sj(this._x,this._y,this._x0,this._y0,this._x1,this._y1),t=this._root,r,n;if(!t)return e;if(!t.length)return e._root=cxt(t),e;for(r=[{source:t,target:e._root=new Array(4)}];t=r.pop();)for(var i=0;i<4;++i)(n=t.source[i])&&(n.length?r.push({source:n,target:t.target[i]=new Array(4)}):t.target[i]=cxt(n));return e};za.add=Y1t;za.addAll=X1t;za.cover=$1t;za.data=K1t;za.extent=Z1t;za.find=J1t;za.remove=Q1t;za.removeAll=txt;za.root=ext;za.size=rxt;za.visit=nxt;za.visitAfter=ixt;za.x=axt;za.y=lxt;function JSe(e){return e.x+e.vx}function QSe(e){return e.y+e.vy}function uxt(e){var t,r,n=1,i=1;typeof e!="function"&&(e=Dn(e==null?1:+e));function o(){for(var l,c=t.length,u,h,f,p,d,g,_=0;_<i;++_)for(u=zh(t,JSe,QSe).visitAfter(a),l=0;l<c;++l)h=t[l],d=r[h.index],g=d*d,f=h.x+h.vx,p=h.y+h.vy,u.visit(y);function y(x,b,S,C,P){var k=x.data,O=x.r,D=d+O;if(k){if(k.index>h.index){var B=f-k.x-k.vx,I=p-k.y-k.vy,L=B*B+I*I;L<D*D&&(B===0&&(B=fu(),L+=B*B),I===0&&(I=fu(),L+=I*I),L=(D-(L=Math.sqrt(L)))/L*n,h.vx+=(B*=L)*(D=(O*=O)/(g+O)),h.vy+=(I*=L)*D,k.vx-=B*(D=1-D),k.vy-=I*D)}return}return b>f+D||C<f-D||S>p+D||P<p-D}}function a(l){if(l.data)return l.r=r[l.data.index];for(var c=l.r=0;c<4;++c)l[c]&&l[c].r>l.r&&(l.r=l[c].r)}function s(){if(!!t){var l,c=t.length,u;for(r=new Array(c),l=0;l<c;++l)u=t[l],r[u.index]=+e(u,l,t)}}return o.initialize=function(l){t=l,s()},o.iterations=function(l){return arguments.length?(i=+l,o):i},o.strength=function(l){return arguments.length?(n=+l,o):n},o.radius=function(l){return arguments.length?(e=typeof l=="function"?l:Dn(+l),s(),o):e},o}Tb();function t3e(e){return e.index}function hxt(e,t){var r=e.get(t);if(!r)throw new Error("missing: "+t);return r}function fxt(e){var t=t3e,r=u,n,i=Dn(30),o,a,s,l,c=1;e==null&&(e=[]);function u(g){return 1/Math.min(s[g.source.index],s[g.target.index])}function h(g){for(var _=0,y=e.length;_<c;++_)for(var x=0,b,S,C,P,k,O,D;x<y;++x)b=e[x],S=b.source,C=b.target,P=C.x+C.vx-S.x-S.vx||fu(),k=C.y+C.vy-S.y-S.vy||fu(),O=Math.sqrt(P*P+k*k),O=(O-o[x])/O*g*n[x],P*=O,k*=O,C.vx-=P*(D=l[x]),C.vy-=k*D,S.vx+=P*(D=1-D),S.vy+=k*D}function f(){if(!!a){var g,_=a.length,y=e.length,x=Ji(a,t),b;for(g=0,s=new Array(_);g<y;++g)b=e[g],b.index=g,typeof b.source!="object"&&(b.source=hxt(x,b.source)),typeof b.target!="object"&&(b.target=hxt(x,b.target)),s[b.source.index]=(s[b.source.index]||0)+1,s[b.target.index]=(s[b.target.index]||0)+1;for(g=0,l=new Array(y);g<y;++g)b=e[g],l[g]=s[b.source.index]/(s[b.source.index]+s[b.target.index]);n=new Array(y),p(),o=new Array(y),d()}}function p(){if(!!a)for(var g=0,_=e.length;g<_;++g)n[g]=+r(e[g],g,e)}function d(){if(!!a)for(var g=0,_=e.length;g<_;++g)o[g]=+i(e[g],g,e)}return h.initialize=function(g){a=g,f()},h.links=function(g){return arguments.length?(e=g,f(),h):e},h.id=function(g){return arguments.length?(t=g,h):t},h.iterations=function(g){return arguments.length?(c=+g,h):c},h.strength=function(g){return arguments.length?(r=typeof g=="function"?g:Dn(+g),p(),h):r},h.distance=function(g){return arguments.length?(i=typeof g=="function"?g:Dn(+g),d(),h):i},h}km();Tb();function pxt(e){return e.x}function dxt(e){return e.y}var e3e=10,r3e=Math.PI*(3-Math.sqrt(5));function mxt(e){var t,r=1,n=.001,i=1-Math.pow(n,1/300),o=0,a=.6,s=Ji(),l=A_(u),c=vs("tick","end");e==null&&(e=[]);function u(){h(),c.call("tick",t),r<n&&(l.stop(),c.call("end",t))}function h(d){var g,_=e.length,y;d===void 0&&(d=1);for(var x=0;x<d;++x)for(r+=(o-r)*i,s.each(function(b){b(r)}),g=0;g<_;++g)y=e[g],y.fx==null?y.x+=y.vx*=a:(y.x=y.fx,y.vx=0),y.fy==null?y.y+=y.vy*=a:(y.y=y.fy,y.vy=0);return t}function f(){for(var d=0,g=e.length,_;d<g;++d){if(_=e[d],_.index=d,_.fx!=null&&(_.x=_.fx),_.fy!=null&&(_.y=_.fy),isNaN(_.x)||isNaN(_.y)){var y=e3e*Math.sqrt(d),x=d*r3e;_.x=y*Math.cos(x),_.y=y*Math.sin(x)}(isNaN(_.vx)||isNaN(_.vy))&&(_.vx=_.vy=0)}}function p(d){return d.initialize&&d.initialize(e),d}return f(),t={tick:h,restart:function(){return l.restart(u),t},stop:function(){return l.stop(),t},nodes:function(d){return arguments.length?(e=d,f(),s.each(p),t):e},alpha:function(d){return arguments.length?(r=+d,t):r},alphaMin:function(d){return arguments.length?(n=+d,t):n},alphaDecay:function(d){return arguments.length?(i=+d,t):+i},alphaTarget:function(d){return arguments.length?(o=+d,t):o},velocityDecay:function(d){return arguments.length?(a=1-d,t):1-a},force:function(d,g){return arguments.length>1?(g==null?s.remove(d):s.set(d,p(g)),t):s.get(d)},find:function(d,g,_){var y=0,x=e.length,b,S,C,P,k;for(_==null?_=1/0:_*=_,y=0;y<x;++y)P=e[y],b=d-P.x,S=g-P.y,C=b*b+S*S,C<_&&(k=P,_=C);return k},on:function(d,g){return arguments.length>1?(c.on(d,g),t):c.on(d)}}}function gxt(){var e,t,r,n=Dn(-30),i,o=1,a=1/0,s=.81;function l(f){var p,d=e.length,g=zh(e,pxt,dxt).visitAfter(u);for(r=f,p=0;p<d;++p)t=e[p],g.visit(h)}function c(){if(!!e){var f,p=e.length,d;for(i=new Array(p),f=0;f<p;++f)d=e[f],i[d.index]=+n(d,f,e)}}function u(f){var p=0,d,g,_=0,y,x,b;if(f.length){for(y=x=b=0;b<4;++b)(d=f[b])&&(g=Math.abs(d.value))&&(p+=d.value,_+=g,y+=g*d.x,x+=g*d.y);f.x=y/_,f.y=x/_}else{d=f,d.x=d.data.x,d.y=d.data.y;do p+=i[d.data.index];while(d=d.next)}f.value=p}function h(f,p,d,g){if(!f.value)return!0;var _=f.x-t.x,y=f.y-t.y,x=g-p,b=_*_+y*y;if(x*x/s<b)return b<a&&(_===0&&(_=fu(),b+=_*_),y===0&&(y=fu(),b+=y*y),b<o&&(b=Math.sqrt(o*b)),t.vx+=_*f.value*r/b,t.vy+=y*f.value*r/b),!0;if(f.length||b>=a)return;(f.data!==t||f.next)&&(_===0&&(_=fu(),b+=_*_),y===0&&(y=fu(),b+=y*y),b<o&&(b=Math.sqrt(o*b)));do f.data!==t&&(x=i[f.data.index]*r/b,t.vx+=_*x,t.vy+=y*x);while(f=f.next)}return l.initialize=function(f){e=f,c()},l.strength=function(f){return arguments.length?(n=typeof f=="function"?f:Dn(+f),c(),l):n},l.distanceMin=function(f){return arguments.length?(o=f*f,l):Math.sqrt(o)},l.distanceMax=function(f){return arguments.length?(a=f*f,l):Math.sqrt(a)},l.theta=function(f){return arguments.length?(s=f*f,l):Math.sqrt(s)},l}function _xt(e,t,r){var n,i=Dn(.1),o,a;typeof e!="function"&&(e=Dn(+e)),t==null&&(t=0),r==null&&(r=0);function s(c){for(var u=0,h=n.length;u<h;++u){var f=n[u],p=f.x-t||1e-6,d=f.y-r||1e-6,g=Math.sqrt(p*p+d*d),_=(a[u]-g)*o[u]*c/g;f.vx+=p*_,f.vy+=d*_}}function l(){if(!!n){var c,u=n.length;for(o=new Array(u),a=new Array(u),c=0;c<u;++c)a[c]=+e(n[c],c,n),o[c]=isNaN(a[c])?0:+i(n[c],c,n)}}return s.initialize=function(c){n=c,l()},s.strength=function(c){return arguments.length?(i=typeof c=="function"?c:Dn(+c),l(),s):i},s.radius=function(c){return arguments.length?(e=typeof c=="function"?c:Dn(+c),l(),s):e},s.x=function(c){return arguments.length?(t=+c,s):t},s.y=function(c){return arguments.length?(r=+c,s):r},s}function yxt(e){var t=Dn(.1),r,n,i;typeof e!="function"&&(e=Dn(e==null?0:+e));function o(s){for(var l=0,c=r.length,u;l<c;++l)u=r[l],u.vx+=(i[l]-u.x)*n[l]*s}function a(){if(!!r){var s,l=r.length;for(n=new Array(l),i=new Array(l),s=0;s<l;++s)n[s]=isNaN(i[s]=+e(r[s],s,r))?0:+t(r[s],s,r)}}return o.initialize=function(s){r=s,a()},o.strength=function(s){return arguments.length?(t=typeof s=="function"?s:Dn(+s),a(),o):t},o.x=function(s){return arguments.length?(e=typeof s=="function"?s:Dn(+s),a(),o):e},o}function vxt(e){var t=Dn(.1),r,n,i;typeof e!="function"&&(e=Dn(e==null?0:+e));function o(s){for(var l=0,c=r.length,u;l<c;++l)u=r[l],u.vy+=(i[l]-u.y)*n[l]*s}function a(){if(!!r){var s,l=r.length;for(n=new Array(l),i=new Array(l),s=0;s<l;++s)n[s]=isNaN(i[s]=+e(r[s],s,r))?0:+t(r[s],s,r)}}return o.initialize=function(s){r=s,a()},o.strength=function(s){return arguments.length?(t=typeof s=="function"?s:Dn(+s),a(),o):t},o.y=function(s){return arguments.length?(e=typeof s=="function"?s:Dn(+s),a(),o):e},o}function xxt(e){return Math.abs(e=Math.round(e))>=1e21?e.toLocaleString("en").replace(/,/g,""):e.toString(10)}function O_(e,t){if((r=(e=t?e.toExponential(t-1):e.toExponential()).indexOf("e"))<0)return null;var r,n=e.slice(0,r);return[n.length>1?n[0]+n.slice(2):n,+e.slice(r+1)]}function Fh(e){return e=O_(Math.abs(e)),e?e[1]:NaN}function bxt(e,t){return function(r,n){for(var i=r.length,o=[],a=0,s=e[0],l=0;i>0&&s>0&&(l+s+1>n&&(s=Math.max(1,n-l)),o.push(r.substring(i-=s,i+s)),!((l+=s+1)>n));)s=e[a=(a+1)%e.length];return o.reverse().join(t)}}function wxt(e){return function(t){return t.replace(/[0-9]/g,function(r){return e[+r]})}}var n3e=/^(?:(.)?([<>=^]))?([+\-( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?(~)?([a-z%])?$/i;function Lp(e){if(!(t=n3e.exec(e)))throw new Error("invalid format: "+e);var t;return new GE({fill:t[1],align:t[2],sign:t[3],symbol:t[4],zero:t[5],width:t[6],comma:t[7],precision:t[8]&&t[8].slice(1),trim:t[9],type:t[10]})}Lp.prototype=GE.prototype;function GE(e){this.fill=e.fill===void 0?" ":e.fill+"",this.align=e.align===void 0?">":e.align+"",this.sign=e.sign===void 0?"-":e.sign+"",this.symbol=e.symbol===void 0?"":e.symbol+"",this.zero=!!e.zero,this.width=e.width===void 0?void 0:+e.width,this.comma=!!e.comma,this.precision=e.precision===void 0?void 0:+e.precision,this.trim=!!e.trim,this.type=e.type===void 0?"":e.type+""}GE.prototype.toString=function(){return this.fill+this.align+this.sign+this.symbol+(this.zero?"0":"")+(this.width===void 0?"":Math.max(1,this.width|0))+(this.comma?",":"")+(this.precision===void 0?"":"."+Math.max(0,this.precision|0))+(this.trim?"~":"")+this.type};function Sxt(e){t:for(var t=e.length,r=1,n=-1,i;r<t;++r)switch(e[r]){case".":n=i=r;break;case"0":n===0&&(n=r),i=r;break;default:if(!+e[r])break t;n>0&&(n=0);break}return n>0?e.slice(0,n)+e.slice(i+1):e}var lj;function Mxt(e,t){var r=O_(e,t);if(!r)return e+"";var n=r[0],i=r[1],o=i-(lj=Math.max(-8,Math.min(8,Math.floor(i/3)))*3)+1,a=n.length;return o===a?n:o>a?n+new Array(o-a+1).join("0"):o>0?n.slice(0,o)+"."+n.slice(o):"0."+new Array(1-o).join("0")+O_(e,Math.max(0,t+o-1))[0]}function cj(e,t){var r=O_(e,t);if(!r)return e+"";var n=r[0],i=r[1];return i<0?"0."+new Array(-i).join("0")+n:n.length>i+1?n.slice(0,i+1)+"."+n.slice(i+1):n+new Array(i-n.length+2).join("0")}var uj={"%":function(e,t){return(e*100).toFixed(t)},b:function(e){return Math.round(e).toString(2)},c:function(e){return e+""},d:xxt,e:function(e,t){return e.toExponential(t)},f:function(e,t){return e.toFixed(t)},g:function(e,t){return e.toPrecision(t)},o:function(e){return Math.round(e).toString(8)},p:function(e,t){return cj(e*100,t)},r:cj,s:Mxt,X:function(e){return Math.round(e).toString(16).toUpperCase()},x:function(e){return Math.round(e).toString(16)}};function hj(e){return e}var Ext=Array.prototype.map,Txt=["y","z","a","f","p","n","\xB5","m","","k","M","G","T","P","E","Z","Y"];function ek(e){var t=e.grouping===void 0||e.thousands===void 0?hj:bxt(Ext.call(e.grouping,Number),e.thousands+""),r=e.currency===void 0?"":e.currency[0]+"",n=e.currency===void 0?"":e.currency[1]+"",i=e.decimal===void 0?".":e.decimal+"",o=e.numerals===void 0?hj:wxt(Ext.call(e.numerals,String)),a=e.percent===void 0?"%":e.percent+"",s=e.minus===void 0?"-":e.minus+"",l=e.nan===void 0?"NaN":e.nan+"";function c(h){h=Lp(h);var f=h.fill,p=h.align,d=h.sign,g=h.symbol,_=h.zero,y=h.width,x=h.comma,b=h.precision,S=h.trim,C=h.type;C==="n"?(x=!0,C="g"):uj[C]||(b===void 0&&(b=12),S=!0,C="g"),(_||f==="0"&&p==="=")&&(_=!0,f="0",p="=");var P=g==="$"?r:g==="#"&&/[boxX]/.test(C)?"0"+C.toLowerCase():"",k=g==="$"?n:/[%p]/.test(C)?a:"",O=uj[C],D=/[defgprs%]/.test(C);b=b===void 0?6:/[gprs]/.test(C)?Math.max(1,Math.min(21,b)):Math.max(0,Math.min(20,b));function B(I){var L=P,R=k,F,z,U;if(C==="c")R=O(I)+R,I="";else{I=+I;var W=I<0||1/I<0;if(I=isNaN(I)?l:O(Math.abs(I),b),S&&(I=Sxt(I)),W&&+I==0&&d!=="+"&&(W=!1),L=(W?d==="("?d:s:d==="-"||d==="("?"":d)+L,R=(C==="s"?Txt[8+lj/3]:"")+R+(W&&d==="("?")":""),D){for(F=-1,z=I.length;++F<z;)if(U=I.charCodeAt(F),48>U||U>57){R=(U===46?i+I.slice(F+1):I.slice(F))+R,I=I.slice(0,F);break}}}x&&!_&&(I=t(I,1/0));var Z=L.length+I.length+R.length,rt=Z<y?new Array(y-Z+1).join(f):"";switch(x&&_&&(I=t(rt+I,rt.length?y-R.length:1/0),rt=""),p){case"<":I=L+I+R+rt;break;case"=":I=L+rt+I+R;break;case"^":I=rt.slice(0,Z=rt.length>>1)+L+I+R+rt.slice(Z);break;default:I=rt+L+I+R;break}return o(I)}return B.toString=function(){return h+""},B}function u(h,f){var p=c((h=Lp(h),h.type="f",h)),d=Math.max(-8,Math.min(8,Math.floor(Fh(f)/3)))*3,g=Math.pow(10,-d),_=Txt[8+d/3];return function(y){return p(g*y)+_}}return{format:c,formatPrefix:u}}var rk,xn,WE;nk({decimal:".",thousands:",",grouping:[3],currency:["$",""],minus:"-"});function nk(e){return rk=ek(e),xn=rk.format,WE=rk.formatPrefix,rk}function ik(e){return Math.max(0,-Fh(Math.abs(e)))}function ok(e,t){return Math.max(0,Math.max(-8,Math.min(8,Math.floor(Fh(t)/3)))*3-Fh(Math.abs(e)))}function ak(e,t){return e=Math.abs(e),t=Math.abs(t)-e,Math.max(0,Fh(t)-Fh(e))+1}function Ss(){return new lk}function lk(){this.reset()}lk.prototype={constructor:lk,reset:function(){this.s=this.t=0},add:function(e){Cxt(sk,e,this.t),Cxt(this,sk.s,this.s),this.s?this.t+=sk.t:this.s=sk.t},valueOf:function(){return this.s}};var sk=new lk;function Cxt(e,t,r){var n=e.s=t+r,i=n-t,o=n-i;e.t=t-o+(r-i)}var le=1e-6,z_=1e-12,Be=Math.PI,mn=Be/2,Pb=Be/4,wi=Be*2,vr=180/Be,ye=Be/180,Re=Math.abs,ic=Math.atan,bn=Math.atan2,Zt=Math.cos,YE=Math.ceil,ck=Math.exp;var F_=Math.log,uk=Math.pow,Xt=Math.sin,ca=Math.sign||function(e){return e>0?1:e<0?-1:0},xr=Math.sqrt,Ib=Math.tan;function hk(e){return e>1?0:e<-1?Be:Math.acos(e)}function wn(e){return e>1?mn:e<-1?-mn:Math.asin(e)}function fj(e){return(e=Xt(e/2))*e}function Fr(){}function fk(e,t){e&&Pxt.hasOwnProperty(e.type)&&Pxt[e.type](e,t)}var Axt={Feature:function(e,t){fk(e.geometry,t)},FeatureCollection:function(e,t){for(var r=e.features,n=-1,i=r.length;++n<i;)fk(r[n].geometry,t)}},Pxt={Sphere:function(e,t){t.sphere()},Point:function(e,t){e=e.coordinates,t.point(e[0],e[1],e[2])},MultiPoint:function(e,t){for(var r=e.coordinates,n=-1,i=r.length;++n<i;)e=r[n],t.point(e[0],e[1],e[2])},LineString:function(e,t){pj(e.coordinates,t,0)},MultiLineString:function(e,t){for(var r=e.coordinates,n=-1,i=r.length;++n<i;)pj(r[n],t,0)},Polygon:function(e,t){Ixt(e.coordinates,t)},MultiPolygon:function(e,t){for(var r=e.coordinates,n=-1,i=r.length;++n<i;)Ixt(r[n],t)},GeometryCollection:function(e,t){for(var r=e.geometries,n=-1,i=r.length;++n<i;)fk(r[n],t)}};function pj(e,t,r){var n=-1,i=e.length-r,o;for(t.lineStart();++n<i;)o=e[n],t.point(o[0],o[1],o[2]);t.lineEnd()}function Ixt(e,t){var r=-1,n=e.length;for(t.polygonStart();++r<n;)pj(e[r],t,1);t.polygonEnd()}function vo(e,t){e&&Axt.hasOwnProperty(e.type)?Axt[e.type](e,t):fk(e,t)}var jE=Ss(),pk=Ss(),Lxt,kxt,dj,mj,gj,pu={point:Fr,lineStart:Fr,lineEnd:Fr,polygonStart:function(){jE.reset(),pu.lineStart=i3e,pu.lineEnd=o3e},polygonEnd:function(){var e=+jE;pk.add(e<0?wi+e:e),this.lineStart=this.lineEnd=this.point=Fr},sphere:function(){pk.add(wi)}};function i3e(){pu.point=a3e}function o3e(){Rxt(Lxt,kxt)}function a3e(e,t){pu.point=Rxt,Lxt=e,kxt=t,e*=ye,t*=ye,dj=e,mj=Zt(t=t/2+Pb),gj=Xt(t)}function Rxt(e,t){e*=ye,t*=ye,t=t/2+Pb;var r=e-dj,n=r>=0?1:-1,i=n*r,o=Zt(t),a=Xt(t),s=gj*a,l=mj*o+s*Zt(i),c=s*n*Xt(i);jE.add(bn(c,l)),dj=e,mj=o,gj=a}function Nxt(e){return pk.reset(),vo(e,pu),pk*2}function B_(e){return[bn(e[1],e[0]),wn(e[2])]}function oc(e){var t=e[0],r=e[1],n=Zt(r);return[n*Zt(t),n*Xt(t),Xt(r)]}function XE(e,t){return e[0]*t[0]+e[1]*t[1]+e[2]*t[2]}function kp(e,t){return[e[1]*t[2]-e[2]*t[1],e[2]*t[0]-e[0]*t[2],e[0]*t[1]-e[1]*t[0]]}function dk(e,t){e[0]+=t[0],e[1]+=t[1],e[2]+=t[2]}function $E(e,t){return[e[0]*t,e[1]*t,e[2]*t]}function H_(e){var t=xr(e[0]*e[0]+e[1]*e[1]+e[2]*e[2]);e[0]/=t,e[1]/=t,e[2]/=t}var ri,Ms,ui,nl,V_,Fxt,Bxt,Lb,KE=Ss(),Ym,Np,Rp={point:_j,lineStart:Dxt,lineEnd:Oxt,polygonStart:function(){Rp.point=Vxt,Rp.lineStart=s3e,Rp.lineEnd=l3e,KE.reset(),pu.polygonStart()},polygonEnd:function(){pu.polygonEnd(),Rp.point=_j,Rp.lineStart=Dxt,Rp.lineEnd=Oxt,jE<0?(ri=-(ui=180),Ms=-(nl=90)):KE>le?nl=90:KE<-le&&(Ms=-90),Np[0]=ri,Np[1]=ui},sphere:function(){ri=-(ui=180),Ms=-(nl=90)}};function _j(e,t){Ym.push(Np=[ri=e,ui=e]),t<Ms&&(Ms=t),t>nl&&(nl=t)}function Hxt(e,t){var r=oc([e*ye,t*ye]);if(Lb){var n=kp(Lb,r),i=[n[1],-n[0],0],o=kp(i,n);H_(o),o=B_(o);var a=e-V_,s=a>0?1:-1,l=o[0]*vr*s,c,u=Re(a)>180;u^(s*V_<l&&l<s*e)?(c=o[1]*vr,c>nl&&(nl=c)):(l=(l+360)%360-180,u^(s*V_<l&&l<s*e)?(c=-o[1]*vr,c<Ms&&(Ms=c)):(t<Ms&&(Ms=t),t>nl&&(nl=t))),u?e<V_?rl(ri,e)>rl(ri,ui)&&(ui=e):rl(e,ui)>rl(ri,ui)&&(ri=e):ui>=ri?(e<ri&&(ri=e),e>ui&&(ui=e)):e>V_?rl(ri,e)>rl(ri,ui)&&(ui=e):rl(e,ui)>rl(ri,ui)&&(ri=e)}else Ym.push(Np=[ri=e,ui=e]);t<Ms&&(Ms=t),t>nl&&(nl=t),Lb=r,V_=e}function Dxt(){Rp.point=Hxt}function Oxt(){Np[0]=ri,Np[1]=ui,Rp.point=_j,Lb=null}function Vxt(e,t){if(Lb){var r=e-V_;KE.add(Re(r)>180?r+(r>0?360:-360):r)}else Fxt=e,Bxt=t;pu.point(e,t),Hxt(e,t)}function s3e(){pu.lineStart()}function l3e(){Vxt(Fxt,Bxt),pu.lineEnd(),Re(KE)>le&&(ri=-(ui=180)),Np[0]=ri,Np[1]=ui,Lb=null}function rl(e,t){return(t-=e)<0?t+360:t}function c3e(e,t){return e[0]-t[0]}function zxt(e,t){return e[0]<=e[1]?e[0]<=t&&t<=e[1]:t<e[0]||e[1]<t}function Uxt(e){var t,r,n,i,o,a,s;if(nl=ui=-(ri=Ms=1/0),Ym=[],vo(e,Rp),r=Ym.length){for(Ym.sort(c3e),t=1,n=Ym[0],o=[n];t<r;++t)i=Ym[t],zxt(n,i[0])||zxt(n,i[1])?(rl(n[0],i[1])>rl(n[0],n[1])&&(n[1]=i[1]),rl(i[0],n[1])>rl(n[0],n[1])&&(n[0]=i[0])):o.push(n=i);for(a=-1/0,r=o.length-1,t=0,n=o[r];t<=r;n=i,++t)i=o[t],(s=rl(n[1],i[0]))>a&&(a=s,ri=i[0],ui=n[1])}return Ym=Np=null,ri===1/0||Ms===1/0?[[NaN,NaN],[NaN,NaN]]:[[ri,Ms],[ui,nl]]}var ZE,mk,gk,_k,yk,vk,xk,bk,yj,vj,xj,Wxt,Yxt,Fa,Ba,Ha,du={sphere:Fr,point:bj,lineStart:qxt,lineEnd:Gxt,polygonStart:function(){du.lineStart=f3e,du.lineEnd=p3e},polygonEnd:function(){du.lineStart=qxt,du.lineEnd=Gxt}};function bj(e,t){e*=ye,t*=ye;var r=Zt(t);JE(r*Zt(e),r*Xt(e),Xt(t))}function JE(e,t,r){++ZE,gk+=(e-gk)/ZE,_k+=(t-_k)/ZE,yk+=(r-yk)/ZE}function qxt(){du.point=u3e}function u3e(e,t){e*=ye,t*=ye;var r=Zt(t);Fa=r*Zt(e),Ba=r*Xt(e),Ha=Xt(t),du.point=h3e,JE(Fa,Ba,Ha)}function h3e(e,t){e*=ye,t*=ye;var r=Zt(t),n=r*Zt(e),i=r*Xt(e),o=Xt(t),a=bn(xr((a=Ba*o-Ha*i)*a+(a=Ha*n-Fa*o)*a+(a=Fa*i-Ba*n)*a),Fa*n+Ba*i+Ha*o);mk+=a,vk+=a*(Fa+(Fa=n)),xk+=a*(Ba+(Ba=i)),bk+=a*(Ha+(Ha=o)),JE(Fa,Ba,Ha)}function Gxt(){du.point=bj}function f3e(){du.point=d3e}function p3e(){jxt(Wxt,Yxt),du.point=bj}function d3e(e,t){Wxt=e,Yxt=t,e*=ye,t*=ye,du.point=jxt;var r=Zt(t);Fa=r*Zt(e),Ba=r*Xt(e),Ha=Xt(t),JE(Fa,Ba,Ha)}function jxt(e,t){e*=ye,t*=ye;var r=Zt(t),n=r*Zt(e),i=r*Xt(e),o=Xt(t),a=Ba*o-Ha*i,s=Ha*n-Fa*o,l=Fa*i-Ba*n,c=xr(a*a+s*s+l*l),u=wn(c),h=c&&-u/c;yj+=h*a,vj+=h*s,xj+=h*l,mk+=u,vk+=u*(Fa+(Fa=n)),xk+=u*(Ba+(Ba=i)),bk+=u*(Ha+(Ha=o)),JE(Fa,Ba,Ha)}function Xxt(e){ZE=mk=gk=_k=yk=vk=xk=bk=yj=vj=xj=0,vo(e,du);var t=yj,r=vj,n=xj,i=t*t+r*r+n*n;return i<z_&&(t=vk,r=xk,n=bk,mk<le&&(t=gk,r=_k,n=yk),i=t*t+r*r+n*n,i<z_)?[NaN,NaN]:[bn(r,t)*vr,wn(n/xr(i))*vr]}function U_(e){return function(){return e}}function QE(e,t){function r(n,i){return n=e(n,i),t(n[0],n[1])}return e.invert&&t.invert&&(r.invert=function(n,i){return n=t.invert(n,i),n&&e.invert(n[0],n[1])}),r}function wj(e,t){return[Re(e)>Be?e+Math.round(-e/wi)*wi:e,t]}wj.invert=wj;function t5(e,t,r){return(e%=wi)?t||r?QE(Kxt(e),Zxt(t,r)):Kxt(e):t||r?Zxt(t,r):wj}function $xt(e){return function(t,r){return t+=e,[t>Be?t-wi:t<-Be?t+wi:t,r]}}function Kxt(e){var t=$xt(e);return t.invert=$xt(-e),t}function Zxt(e,t){var r=Zt(e),n=Xt(e),i=Zt(t),o=Xt(t);function a(s,l){var c=Zt(l),u=Zt(s)*c,h=Xt(s)*c,f=Xt(l),p=f*r+u*n;return[bn(h*i-p*o,u*r-f*n),wn(p*i+h*o)]}return a.invert=function(s,l){var c=Zt(l),u=Zt(s)*c,h=Xt(s)*c,f=Xt(l),p=f*i-h*o;return[bn(h*i+f*o,u*r+p*n),wn(p*r-u*n)]},a}function wk(e){e=t5(e[0]*ye,e[1]*ye,e.length>2?e[2]*ye:0);function t(r){return r=e(r[0]*ye,r[1]*ye),r[0]*=vr,r[1]*=vr,r}return t.invert=function(r){return r=e.invert(r[0]*ye,r[1]*ye),r[0]*=vr,r[1]*=vr,r},t}function Sj(e,t,r,n,i,o){if(!!r){var a=Zt(t),s=Xt(t),l=n*r;i==null?(i=t+n*wi,o=t-l/2):(i=Jxt(a,i),o=Jxt(a,o),(n>0?i<o:i>o)&&(i+=n*wi));for(var c,u=i;n>0?u>o:u<o;u-=l)c=B_([a,-s*Zt(u),-s*Xt(u)]),e.point(c[0],c[1])}}function Jxt(e,t){t=oc(t),t[0]-=e,H_(t);var r=hk(-t[1]);return((-t[2]<0?-r:r)+wi-le)%wi}function Qxt(){var e=U_([0,0]),t=U_(90),r=U_(6),n,i,o={point:a};function a(l,c){n.push(l=i(l,c)),l[0]*=vr,l[1]*=vr}function s(){var l=e.apply(this,arguments),c=t.apply(this,arguments)*ye,u=r.apply(this,arguments)*ye;return n=[],i=t5(-l[0]*ye,-l[1]*ye,0).invert,Sj(o,c,u,1),l={type:"Polygon",coordinates:[n]},n=i=null,l}return s.center=function(l){return arguments.length?(e=typeof l=="function"?l:U_([+l[0],+l[1]]),s):e},s.radius=function(l){return arguments.length?(t=typeof l=="function"?l:U_(+l),s):t},s.precision=function(l){return arguments.length?(r=typeof l=="function"?l:U_(+l),s):r},s}function Sk(){var e=[],t;return{point:function(r,n,i){t.push([r,n,i])},lineStart:function(){e.push(t=[])},lineEnd:Fr,rejoin:function(){e.length>1&&e.push(e.pop().concat(e.shift()))},result:function(){var r=e;return e=[],t=null,r}}}function kb(e,t){return Re(e[0]-t[0])<le&&Re(e[1]-t[1])<le}function Mk(e,t,r,n){this.x=e,this.z=t,this.o=r,this.e=n,this.v=!1,this.n=this.p=null}function Ek(e,t,r,n,i){var o=[],a=[],s,l;if(e.forEach(function(d){if(!((g=d.length-1)<=0)){var g,_=d[0],y=d[g],x;if(kb(_,y)){if(!_[2]&&!y[2]){for(i.lineStart(),s=0;s<g;++s)i.point((_=d[s])[0],_[1]);i.lineEnd();return}y[0]+=2*le}o.push(x=new Mk(_,d,null,!0)),a.push(x.o=new Mk(_,null,x,!1)),o.push(x=new Mk(y,d,null,!1)),a.push(x.o=new Mk(y,null,x,!0))}}),!!o.length){for(a.sort(t),tbt(o),tbt(a),s=0,l=a.length;s<l;++s)a[s].e=r=!r;for(var c=o[0],u,h;;){for(var f=c,p=!0;f.v;)if((f=f.n)===c)return;u=f.z,i.lineStart();do{if(f.v=f.o.v=!0,f.e){if(p)for(s=0,l=u.length;s<l;++s)i.point((h=u[s])[0],h[1]);else n(f.x,f.n.x,1,i);f=f.n}else{if(p)for(u=f.p.z,s=u.length-1;s>=0;--s)i.point((h=u[s])[0],h[1]);else n(f.x,f.p.x,-1,i);f=f.p}f=f.o,u=f.z,p=!p}while(!f.v);i.lineEnd()}}}function tbt(e){if(!!(t=e.length)){for(var t,r=0,n=e[0],i;++r<t;)n.n=i=e[r],i.p=n,n=i;n.n=i=e[0],i.p=n}}var Mj=Ss();function Ej(e){return Re(e[0])<=Be?e[0]:ca(e[0])*((Re(e[0])+Be)%wi-Be)}function Tk(e,t){var r=Ej(t),n=t[1],i=Xt(n),o=[Xt(r),-Zt(r),0],a=0,s=0;Mj.reset(),i===1?n=mn+le:i===-1&&(n=-mn-le);for(var l=0,c=e.length;l<c;++l)if(!!(h=(u=e[l]).length))for(var u,h,f=u[h-1],p=Ej(f),d=f[1]/2+Pb,g=Xt(d),_=Zt(d),y=0;y<h;++y,p=b,g=C,_=P,f=x){var x=u[y],b=Ej(x),S=x[1]/2+Pb,C=Xt(S),P=Zt(S),k=b-p,O=k>=0?1:-1,D=O*k,B=D>Be,I=g*C;if(Mj.add(bn(I*O*Xt(D),_*P+I*Zt(D))),a+=B?k+O*wi:k,B^p>=r^b>=r){var L=kp(oc(f),oc(x));H_(L);var R=kp(o,L);H_(R);var F=(B^k>=0?-1:1)*wn(R[2]);(n>F||n===F&&(L[0]||L[1]))&&(s+=B^k>=0?1:-1)}}return(a<-le||a<le&&Mj<-le)^s&1}function Ck(e,t,r,n){return function(i){var o=t(i),a=Sk(),s=t(a),l=!1,c,u,h,f={point:p,lineStart:g,lineEnd:_,polygonStart:function(){f.point=y,f.lineStart=x,f.lineEnd=b,u=[],c=[]},polygonEnd:function(){f.point=p,f.lineStart=g,f.lineEnd=_,u=Im(u);var S=Tk(c,n);u.length?(l||(i.polygonStart(),l=!0),Ek(u,g3e,S,r,i)):S&&(l||(i.polygonStart(),l=!0),i.lineStart(),r(null,null,1,i),i.lineEnd()),l&&(i.polygonEnd(),l=!1),u=c=null},sphere:function(){i.polygonStart(),i.lineStart(),r(null,null,1,i),i.lineEnd(),i.polygonEnd()}};function p(S,C){e(S,C)&&i.point(S,C)}function d(S,C){o.point(S,C)}function g(){f.point=d,o.lineStart()}function _(){f.point=p,o.lineEnd()}function y(S,C){h.push([S,C]),s.point(S,C)}function x(){s.lineStart(),h=[]}function b(){y(h[0][0],h[0][1]),s.lineEnd();var S=s.clean(),C=a.result(),P,k=C.length,O,D,B;if(h.pop(),c.push(h),h=null,!!k){if(S&1){if(D=C[0],(O=D.length-1)>0){for(l||(i.polygonStart(),l=!0),i.lineStart(),P=0;P<O;++P)i.point((B=D[P])[0],B[1]);i.lineEnd()}return}k>1&&S&2&&C.push(C.pop().concat(C.shift())),u.push(C.filter(m3e))}}return f}}function m3e(e){return e.length>1}function g3e(e,t){return((e=e.x)[0]<0?e[1]-mn-le:mn-e[1])-((t=t.x)[0]<0?t[1]-mn-le:mn-t[1])}var e5=Ck(function(){return!0},_3e,v3e,[-Be,-mn]);function _3e(e){var t=NaN,r=NaN,n=NaN,i;return{lineStart:function(){e.lineStart(),i=1},point:function(o,a){var s=o>0?Be:-Be,l=Re(o-t);Re(l-Be)<le?(e.point(t,r=(r+a)/2>0?mn:-mn),e.point(n,r),e.lineEnd(),e.lineStart(),e.point(s,r),e.point(o,r),i=0):n!==s&&l>=Be&&(Re(t-n)<le&&(t-=n*le),Re(o-s)<le&&(o-=s*le),r=y3e(t,r,o,a),e.point(n,r),e.lineEnd(),e.lineStart(),e.point(s,r),i=0),e.point(t=o,r=a),n=s},lineEnd:function(){e.lineEnd(),t=r=NaN},clean:function(){return 2-i}}}function y3e(e,t,r,n){var i,o,a=Xt(e-r);return Re(a)>le?ic((Xt(t)*(o=Zt(n))*Xt(r)-Xt(n)*(i=Zt(t))*Xt(e))/(i*o*a)):(t+n)/2}function v3e(e,t,r,n){var i;if(e==null)i=r*mn,n.point(-Be,i),n.point(0,i),n.point(Be,i),n.point(Be,0),n.point(Be,-i),n.point(0,-i),n.point(-Be,-i),n.point(-Be,0),n.point(-Be,i);else if(Re(e[0]-t[0])>le){var o=e[0]<t[0]?Be:-Be;i=r*o/2,n.point(-o,i),n.point(0,i),n.point(o,i)}else n.point(t[0],t[1])}function Ak(e){var t=Zt(e),r=6*ye,n=t>0,i=Re(t)>le;function o(u,h,f,p){Sj(p,e,r,f,u,h)}function a(u,h){return Zt(u)*Zt(h)>t}function s(u){var h,f,p,d,g;return{lineStart:function(){d=p=!1,g=1},point:function(_,y){var x=[_,y],b,S=a(_,y),C=n?S?0:c(_,y):S?c(_+(_<0?Be:-Be),y):0;if(!h&&(d=p=S)&&u.lineStart(),S!==p&&(b=l(h,x),(!b||kb(h,b)||kb(x,b))&&(x[2]=1)),S!==p)g=0,S?(u.lineStart(),b=l(x,h),u.point(b[0],b[1])):(b=l(h,x),u.point(b[0],b[1],2),u.lineEnd()),h=b;else if(i&&h&&n^S){var P;!(C&f)&&(P=l(x,h,!0))&&(g=0,n?(u.lineStart(),u.point(P[0][0],P[0][1]),u.point(P[1][0],P[1][1]),u.lineEnd()):(u.point(P[1][0],P[1][1]),u.lineEnd(),u.lineStart(),u.point(P[0][0],P[0][1],3)))}S&&(!h||!kb(h,x))&&u.point(x[0],x[1]),h=x,p=S,f=C},lineEnd:function(){p&&u.lineEnd(),h=null},clean:function(){return g|(d&&p)<<1}}}function l(u,h,f){var p=oc(u),d=oc(h),g=[1,0,0],_=kp(p,d),y=XE(_,_),x=_[0],b=y-x*x;if(!b)return!f&&u;var S=t*y/b,C=-t*x/b,P=kp(g,_),k=$E(g,S),O=$E(_,C);dk(k,O);var D=P,B=XE(k,D),I=XE(D,D),L=B*B-I*(XE(k,k)-1);if(!(L<0)){var R=xr(L),F=$E(D,(-B-R)/I);if(dk(F,k),F=B_(F),!f)return F;var z=u[0],U=h[0],W=u[1],Z=h[1],rt;U<z&&(rt=z,z=U,U=rt);var ot=U-z,st=Re(ot-Be)<le,St=st||ot<le;if(!st&&Z<W&&(rt=W,W=Z,Z=rt),St?st?W+Z>0^F[1]<(Re(F[0]-z)<le?W:Z):W<=F[1]&&F[1]<=Z:ot>Be^(z<=F[0]&&F[0]<=U)){var bt=$E(D,(-B+R)/I);return dk(bt,k),[F,B_(bt)]}}}function c(u,h){var f=n?e:Be-e,p=0;return u<-f?p|=1:u>f&&(p|=2),h<-f?p|=4:h>f&&(p|=8),p}return Ck(a,s,o,n?[0,-e]:[-Be,e-Be])}function ebt(e,t,r,n,i,o){var a=e[0],s=e[1],l=t[0],c=t[1],u=0,h=1,f=l-a,p=c-s,d;if(d=r-a,!(!f&&d>0)){if(d/=f,f<0){if(d<u)return;d<h&&(h=d)}else if(f>0){if(d>h)return;d>u&&(u=d)}if(d=i-a,!(!f&&d<0)){if(d/=f,f<0){if(d>h)return;d>u&&(u=d)}else if(f>0){if(d<u)return;d<h&&(h=d)}if(d=n-s,!(!p&&d>0)){if(d/=p,p<0){if(d<u)return;d<h&&(h=d)}else if(p>0){if(d>h)return;d>u&&(u=d)}if(d=o-s,!(!p&&d<0)){if(d/=p,p<0){if(d>h)return;d>u&&(u=d)}else if(p>0){if(d<u)return;d<h&&(h=d)}return u>0&&(e[0]=a+u*f,e[1]=s+u*p),h<1&&(t[0]=a+h*f,t[1]=s+h*p),!0}}}}}var r5=1e9,Pk=-r5;function Dp(e,t,r,n){function i(c,u){return e<=c&&c<=r&&t<=u&&u<=n}function o(c,u,h,f){var p=0,d=0;if(c==null||(p=a(c,h))!==(d=a(u,h))||l(c,u)<0^h>0)do f.point(p===0||p===3?e:r,p>1?n:t);while((p=(p+h+4)%4)!==d);else f.point(u[0],u[1])}function a(c,u){return Re(c[0]-e)<le?u>0?0:3:Re(c[0]-r)<le?u>0?2:1:Re(c[1]-t)<le?u>0?1:0:u>0?3:2}function s(c,u){return l(c.x,u.x)}function l(c,u){var h=a(c,1),f=a(u,1);return h!==f?h-f:h===0?u[1]-c[1]:h===1?c[0]-u[0]:h===2?c[1]-u[1]:u[0]-c[0]}return function(c){var u=c,h=Sk(),f,p,d,g,_,y,x,b,S,C,P,k={point:O,lineStart:L,lineEnd:R,polygonStart:B,polygonEnd:I};function O(z,U){i(z,U)&&u.point(z,U)}function D(){for(var z=0,U=0,W=p.length;U<W;++U)for(var Z=p[U],rt=1,ot=Z.length,st=Z[0],St,bt,Mt=st[0],lt=st[1];rt<ot;++rt)St=Mt,bt=lt,st=Z[rt],Mt=st[0],lt=st[1],bt<=n?lt>n&&(Mt-St)*(n-bt)>(lt-bt)*(e-St)&&++z:lt<=n&&(Mt-St)*(n-bt)<(lt-bt)*(e-St)&&--z;return z}function B(){u=h,f=[],p=[],P=!0}function I(){var z=D(),U=P&&z,W=(f=Im(f)).length;(U||W)&&(c.polygonStart(),U&&(c.lineStart(),o(null,null,1,c),c.lineEnd()),W&&Ek(f,s,z,o,c),c.polygonEnd()),u=c,f=p=d=null}function L(){k.point=F,p&&p.push(d=[]),C=!0,S=!1,x=b=NaN}function R(){f&&(F(g,_),y&&S&&h.rejoin(),f.push(h.result())),k.point=O,S&&u.lineEnd()}function F(z,U){var W=i(z,U);if(p&&d.push([z,U]),C)g=z,_=U,y=W,C=!1,W&&(u.lineStart(),u.point(z,U));else if(W&&S)u.point(z,U);else{var Z=[x=Math.max(Pk,Math.min(r5,x)),b=Math.max(Pk,Math.min(r5,b))],rt=[z=Math.max(Pk,Math.min(r5,z)),U=Math.max(Pk,Math.min(r5,U))];ebt(Z,rt,e,t,r,n)?(S||(u.lineStart(),u.point(Z[0],Z[1])),u.point(rt[0],rt[1]),W||u.lineEnd(),P=!1):W&&(u.lineStart(),u.point(z,U),P=!1)}x=z,b=U,S=W}return k}}function rbt(){var e=0,t=0,r=960,n=500,i,o,a;return a={stream:function(s){return i&&o===s?i:i=Dp(e,t,r,n)(o=s)},extent:function(s){return arguments.length?(e=+s[0][0],t=+s[0][1],r=+s[1][0],n=+s[1][1],i=o=null,a):[[e,t],[r,n]]}}}var Tj=Ss(),Cj,Ik,Lk,Rb={sphere:Fr,point:Fr,lineStart:x3e,lineEnd:Fr,polygonStart:Fr,polygonEnd:Fr};function x3e(){Rb.point=w3e,Rb.lineEnd=b3e}function b3e(){Rb.point=Rb.lineEnd=Fr}function w3e(e,t){e*=ye,t*=ye,Cj=e,Ik=Xt(t),Lk=Zt(t),Rb.point=S3e}function S3e(e,t){e*=ye,t*=ye;var r=Xt(t),n=Zt(t),i=Re(e-Cj),o=Zt(i),a=Xt(i),s=n*a,l=Lk*r-Ik*n*o,c=Ik*r+Lk*n*o;Tj.add(bn(xr(s*s+l*l),c)),Cj=e,Ik=r,Lk=n}function kk(e){return Tj.reset(),vo(e,Rb),+Tj}var Aj=[null,null],M3e={type:"LineString",coordinates:Aj};function Nb(e,t){return Aj[0]=e,Aj[1]=t,kk(M3e)}var nbt={Feature:function(e,t){return Rk(e.geometry,t)},FeatureCollection:function(e,t){for(var r=e.features,n=-1,i=r.length;++n<i;)if(Rk(r[n].geometry,t))return!0;return!1}},ibt={Sphere:function(){return!0},Point:function(e,t){return obt(e.coordinates,t)},MultiPoint:function(e,t){for(var r=e.coordinates,n=-1,i=r.length;++n<i;)if(obt(r[n],t))return!0;return!1},LineString:function(e,t){return abt(e.coordinates,t)},MultiLineString:function(e,t){for(var r=e.coordinates,n=-1,i=r.length;++n<i;)if(abt(r[n],t))return!0;return!1},Polygon:function(e,t){return sbt(e.coordinates,t)},MultiPolygon:function(e,t){for(var r=e.coordinates,n=-1,i=r.length;++n<i;)if(sbt(r[n],t))return!0;return!1},GeometryCollection:function(e,t){for(var r=e.geometries,n=-1,i=r.length;++n<i;)if(Rk(r[n],t))return!0;return!1}};function Rk(e,t){return e&&ibt.hasOwnProperty(e.type)?ibt[e.type](e,t):!1}function obt(e,t){return Nb(e,t)===0}function abt(e,t){for(var r,n,i,o=0,a=e.length;o<a;o++){if(n=Nb(e[o],t),n===0||o>0&&(i=Nb(e[o],e[o-1]),i>0&&r<=i&&n<=i&&(r+n-i)*(1-Math.pow((r-n)/i,2))<z_*i))return!0;r=n}return!1}function sbt(e,t){return!!Tk(e.map(E3e),lbt(t))}function E3e(e){return e=e.map(lbt),e.pop(),e}function lbt(e){return[e[0]*ye,e[1]*ye]}function cbt(e,t){return(e&&nbt.hasOwnProperty(e.type)?nbt[e.type]:Rk)(e,t)}function ubt(e,t,r){var n=Ir(e,t-le,r).concat(t);return function(i){return n.map(function(o){return[i,o]})}}function hbt(e,t,r){var n=Ir(e,t-le,r).concat(t);return function(i){return n.map(function(o){return[o,i]})}}function Nk(){var e,t,r,n,i,o,a,s,l=10,c=l,u=90,h=360,f,p,d,g,_=2.5;function y(){return{type:"MultiLineString",coordinates:x()}}function x(){return Ir(YE(n/u)*u,r,u).map(d).concat(Ir(YE(s/h)*h,a,h).map(g)).concat(Ir(YE(t/l)*l,e,l).filter(function(b){return Re(b%u)>le}).map(f)).concat(Ir(YE(o/c)*c,i,c).filter(function(b){return Re(b%h)>le}).map(p))}return y.lines=function(){return x().map(function(b){return{type:"LineString",coordinates:b}})},y.outline=function(){return{type:"Polygon",coordinates:[d(n).concat(g(a).slice(1),d(r).reverse().slice(1),g(s).reverse().slice(1))]}},y.extent=function(b){return arguments.length?y.extentMajor(b).extentMinor(b):y.extentMinor()},y.extentMajor=function(b){return arguments.length?(n=+b[0][0],r=+b[1][0],s=+b[0][1],a=+b[1][1],n>r&&(b=n,n=r,r=b),s>a&&(b=s,s=a,a=b),y.precision(_)):[[n,s],[r,a]]},y.extentMinor=function(b){return arguments.length?(t=+b[0][0],e=+b[1][0],o=+b[0][1],i=+b[1][1],t>e&&(b=t,t=e,e=b),o>i&&(b=o,o=i,i=b),y.precision(_)):[[t,o],[e,i]]},y.step=function(b){return arguments.length?y.stepMajor(b).stepMinor(b):y.stepMinor()},y.stepMajor=function(b){return arguments.length?(u=+b[0],h=+b[1],y):[u,h]},y.stepMinor=function(b){return arguments.length?(l=+b[0],c=+b[1],y):[l,c]},y.precision=function(b){return arguments.length?(_=+b,f=ubt(o,i,90),p=hbt(t,e,_),d=ubt(s,a,90),g=hbt(n,r,_),y):_},y.extentMajor([[-180,-90+le],[180,90-le]]).extentMinor([[-180,-80-le],[180,80+le]])}function fbt(){return Nk()()}function pbt(e,t){var r=e[0]*ye,n=e[1]*ye,i=t[0]*ye,o=t[1]*ye,a=Zt(n),s=Xt(n),l=Zt(o),c=Xt(o),u=a*Zt(r),h=a*Xt(r),f=l*Zt(i),p=l*Xt(i),d=2*wn(xr(fj(o-n)+a*l*fj(i-r))),g=Xt(d),_=d?function(y){var x=Xt(y*=d)/g,b=Xt(d-y)/g,S=b*u+x*f,C=b*h+x*p,P=b*s+x*c;return[bn(C,S)*vr,bn(P,xr(S*S+C*C))*vr]}:function(){return[r*vr,n*vr]};return _.distance=d,_}function jm(e){return e}var Pj=Ss(),Ij=Ss(),dbt,mbt,Lj,kj,Xm={point:Fr,lineStart:Fr,lineEnd:Fr,polygonStart:function(){Xm.lineStart=T3e,Xm.lineEnd=A3e},polygonEnd:function(){Xm.lineStart=Xm.lineEnd=Xm.point=Fr,Pj.add(Re(Ij)),Ij.reset()},result:function(){var e=Pj/2;return Pj.reset(),e}};function T3e(){Xm.point=C3e}function C3e(e,t){Xm.point=gbt,dbt=Lj=e,mbt=kj=t}function gbt(e,t){Ij.add(kj*e-Lj*t),Lj=e,kj=t}function A3e(){gbt(dbt,mbt)}var Rj=Xm;var Db=1/0,Dk=Db,n5=-Db,Ok=n5,P3e={point:I3e,lineStart:Fr,lineEnd:Fr,polygonStart:Fr,polygonEnd:Fr,result:function(){var e=[[Db,Dk],[n5,Ok]];return n5=Ok=-(Dk=Db=1/0),e}};function I3e(e,t){e<Db&&(Db=e),e>n5&&(n5=e),t<Dk&&(Dk=t),t>Ok&&(Ok=t)}var Ob=P3e;var Nj=0,Dj=0,i5=0,zk=0,Fk=0,zb=0,Oj=0,zj=0,o5=0,vbt,xbt,Bh,Hh,mu={point:q_,lineStart:_bt,lineEnd:ybt,polygonStart:function(){mu.lineStart=R3e,mu.lineEnd=N3e},polygonEnd:function(){mu.point=q_,mu.lineStart=_bt,mu.lineEnd=ybt},result:function(){var e=o5?[Oj/o5,zj/o5]:zb?[zk/zb,Fk/zb]:i5?[Nj/i5,Dj/i5]:[NaN,NaN];return Nj=Dj=i5=zk=Fk=zb=Oj=zj=o5=0,e}};function q_(e,t){Nj+=e,Dj+=t,++i5}function _bt(){mu.point=L3e}function L3e(e,t){mu.point=k3e,q_(Bh=e,Hh=t)}function k3e(e,t){var r=e-Bh,n=t-Hh,i=xr(r*r+n*n);zk+=i*(Bh+e)/2,Fk+=i*(Hh+t)/2,zb+=i,q_(Bh=e,Hh=t)}function ybt(){mu.point=q_}function R3e(){mu.point=D3e}function N3e(){bbt(vbt,xbt)}function D3e(e,t){mu.point=bbt,q_(vbt=Bh=e,xbt=Hh=t)}function bbt(e,t){var r=e-Bh,n=t-Hh,i=xr(r*r+n*n);zk+=i*(Bh+e)/2,Fk+=i*(Hh+t)/2,zb+=i,i=Hh*e-Bh*t,Oj+=i*(Bh+e),zj+=i*(Hh+t),o5+=i*3,q_(Bh=e,Hh=t)}var Fj=mu;function Bk(e){this._context=e}Bk.prototype={_radius:4.5,pointRadius:function(e){return this._radius=e,this},polygonStart:function(){this._line=0},polygonEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){this._line===0&&this._context.closePath(),this._point=NaN},point:function(e,t){switch(this._point){case 0:{this._context.moveTo(e,t),this._point=1;break}case 1:{this._context.lineTo(e,t);break}default:{this._context.moveTo(e+this._radius,t),this._context.arc(e,t,this._radius,0,wi);break}}},result:Fr};var Hj=Ss(),Bj,wbt,Sbt,a5,s5,Hk={point:Fr,lineStart:function(){Hk.point=O3e},lineEnd:function(){Bj&&Mbt(wbt,Sbt),Hk.point=Fr},polygonStart:function(){Bj=!0},polygonEnd:function(){Bj=null},result:function(){var e=+Hj;return Hj.reset(),e}};function O3e(e,t){Hk.point=Mbt,wbt=a5=e,Sbt=s5=t}function Mbt(e,t){a5-=e,s5-=t,Hj.add(xr(a5*a5+s5*s5)),a5=e,s5=t}var Vj=Hk;function Vk(){this._string=[]}Vk.prototype={_radius:4.5,_circle:Ebt(4.5),pointRadius:function(e){return(e=+e)!==this._radius&&(this._radius=e,this._circle=null),this},polygonStart:function(){this._line=0},polygonEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){this._line===0&&this._string.push("Z"),this._point=NaN},point:function(e,t){switch(this._point){case 0:{this._string.push("M",e,",",t),this._point=1;break}case 1:{this._string.push("L",e,",",t);break}default:{this._circle==null&&(this._circle=Ebt(this._radius)),this._string.push("M",e,",",t,this._circle);break}}},result:function(){if(this._string.length){var e=this._string.join("");return this._string=[],e}else return null}};function Ebt(e){return"m0,"+e+"a"+e+","+e+" 0 1,1 0,"+-2*e+"a"+e+","+e+" 0 1,1 0,"+2*e+"z"}function Tbt(e,t){var r=4.5,n,i;function o(a){return a&&(typeof r=="function"&&i.pointRadius(+r.apply(this,arguments)),vo(a,n(i))),i.result()}return o.area=function(a){return vo(a,n(Rj)),Rj.result()},o.measure=function(a){return vo(a,n(Vj)),Vj.result()},o.bounds=function(a){return vo(a,n(Ob)),Ob.result()},o.centroid=function(a){return vo(a,n(Fj)),Fj.result()},o.projection=function(a){return arguments.length?(n=a==null?(e=null,jm):(e=a).stream,o):e},o.context=function(a){return arguments.length?(i=a==null?(t=null,new Vk):new Bk(t=a),typeof r!="function"&&i.pointRadius(r),o):t},o.pointRadius=function(a){return arguments.length?(r=typeof a=="function"?a:(i.pointRadius(+a),+a),o):r},o.projection(e).context(t)}function Cbt(e){return{stream:$m(e)}}function $m(e){return function(t){var r=new Uj;for(var n in e)r[n]=e[n];return r.stream=t,r}}function Uj(){}Uj.prototype={constructor:Uj,point:function(e,t){this.stream.point(e,t)},sphere:function(){this.stream.sphere()},lineStart:function(){this.stream.lineStart()},lineEnd:function(){this.stream.lineEnd()},polygonStart:function(){this.stream.polygonStart()},polygonEnd:function(){this.stream.polygonEnd()}};function qj(e,t,r){var n=e.clipExtent&&e.clipExtent();return e.scale(150).translate([0,0]),n!=null&&e.clipExtent(null),vo(r,e.stream(Ob)),t(Ob.result()),n!=null&&e.clipExtent(n),e}function G_(e,t,r){return qj(e,function(n){var i=t[1][0]-t[0][0],o=t[1][1]-t[0][1],a=Math.min(i/(n[1][0]-n[0][0]),o/(n[1][1]-n[0][1])),s=+t[0][0]+(i-a*(n[1][0]+n[0][0]))/2,l=+t[0][1]+(o-a*(n[1][1]+n[0][1]))/2;e.scale(150*a).translate([s,l])},r)}function Fb(e,t,r){return G_(e,[[0,0],t],r)}function Bb(e,t,r){return qj(e,function(n){var i=+t,o=i/(n[1][0]-n[0][0]),a=(i-o*(n[1][0]+n[0][0]))/2,s=-o*n[0][1];e.scale(150*o).translate([a,s])},r)}function Hb(e,t,r){return qj(e,function(n){var i=+t,o=i/(n[1][1]-n[0][1]),a=-o*n[0][0],s=(i-o*(n[1][1]+n[0][1]))/2;e.scale(150*o).translate([a,s])},r)}var Abt=16,z3e=Zt(30*ye);function Gj(e,t){return+t?B3e(e,t):F3e(e)}function F3e(e){return $m({point:function(t,r){t=e(t,r),this.stream.point(t[0],t[1])}})}function B3e(e,t){function r(n,i,o,a,s,l,c,u,h,f,p,d,g,_){var y=c-n,x=u-i,b=y*y+x*x;if(b>4*t&&g--){var S=a+f,C=s+p,P=l+d,k=xr(S*S+C*C+P*P),O=wn(P/=k),D=Re(Re(P)-1)<le||Re(o-h)<le?(o+h)/2:bn(C,S),B=e(D,O),I=B[0],L=B[1],R=I-n,F=L-i,z=x*R-y*F;(z*z/b>t||Re((y*R+x*F)/b-.5)>.3||a*f+s*p+l*d<z3e)&&(r(n,i,o,a,s,l,I,L,D,S/=k,C/=k,P,g,_),_.point(I,L),r(I,L,D,S,C,P,c,u,h,f,p,d,g,_))}}return function(n){var i,o,a,s,l,c,u,h,f,p,d,g,_={point:y,lineStart:x,lineEnd:S,polygonStart:function(){n.polygonStart(),_.lineStart=C},polygonEnd:function(){n.polygonEnd(),_.lineStart=x}};function y(O,D){O=e(O,D),n.point(O[0],O[1])}function x(){h=NaN,_.point=b,n.lineStart()}function b(O,D){var B=oc([O,D]),I=e(O,D);r(h,f,u,p,d,g,h=I[0],f=I[1],u=O,p=B[0],d=B[1],g=B[2],Abt,n),n.point(h,f)}function S(){_.point=y,n.lineEnd()}function C(){x(),_.point=P,_.lineEnd=k}function P(O,D){b(i=O,D),o=h,a=f,s=p,l=d,c=g,_.point=b}function k(){r(h,f,u,p,d,g,o,a,i,s,l,c,Abt,n),_.lineEnd=S,S()}return _}}var H3e=$m({point:function(e,t){this.stream.point(e*ye,t*ye)}});function V3e(e){return $m({point:function(t,r){var n=e(t,r);return this.stream.point(n[0],n[1])}})}function U3e(e,t,r,n,i){function o(a,s){return a*=n,s*=i,[t+e*a,r-e*s]}return o.invert=function(a,s){return[(a-t)/e*n,(r-s)/e*i]},o}function Pbt(e,t,r,n,i,o){var a=Zt(o),s=Xt(o),l=a*e,c=s*e,u=a/e,h=s/e,f=(s*r-a*t)/e,p=(s*t+a*r)/e;function d(g,_){return g*=n,_*=i,[l*g-c*_+t,r-c*g-l*_]}return d.invert=function(g,_){return[n*(u*g-h*_+f),i*(p-h*g-u*_)]},d}function Si(e){return l5(function(){return e})()}function l5(e){var t,r=150,n=480,i=250,o=0,a=0,s=0,l=0,c=0,u,h=0,f=1,p=1,d=null,g=e5,_=null,y,x,b,S=jm,C=.5,P,k,O,D,B;function I(z){return O(z[0]*ye,z[1]*ye)}function L(z){return z=O.invert(z[0],z[1]),z&&[z[0]*vr,z[1]*vr]}I.stream=function(z){return D&&B===z?D:D=H3e(V3e(u)(g(P(S(B=z)))))},I.preclip=function(z){return arguments.length?(g=z,d=void 0,F()):g},I.postclip=function(z){return arguments.length?(S=z,_=y=x=b=null,F()):S},I.clipAngle=function(z){return arguments.length?(g=+z?Ak(d=z*ye):(d=null,e5),F()):d*vr},I.clipExtent=function(z){return arguments.length?(S=z==null?(_=y=x=b=null,jm):Dp(_=+z[0][0],y=+z[0][1],x=+z[1][0],b=+z[1][1]),F()):_==null?null:[[_,y],[x,b]]},I.scale=function(z){return arguments.length?(r=+z,R()):r},I.translate=function(z){return arguments.length?(n=+z[0],i=+z[1],R()):[n,i]},I.center=function(z){return arguments.length?(o=z[0]%360*ye,a=z[1]%360*ye,R()):[o*vr,a*vr]},I.rotate=function(z){return arguments.length?(s=z[0]%360*ye,l=z[1]%360*ye,c=z.length>2?z[2]%360*ye:0,R()):[s*vr,l*vr,c*vr]},I.angle=function(z){return arguments.length?(h=z%360*ye,R()):h*vr},I.reflectX=function(z){return arguments.length?(f=z?-1:1,R()):f<0},I.reflectY=function(z){return arguments.length?(p=z?-1:1,R()):p<0},I.precision=function(z){return arguments.length?(P=Gj(k,C=z*z),F()):xr(C)},I.fitExtent=function(z,U){return G_(I,z,U)},I.fitSize=function(z,U){return Fb(I,z,U)},I.fitWidth=function(z,U){return Bb(I,z,U)},I.fitHeight=function(z,U){return Hb(I,z,U)};function R(){var z=Pbt(r,0,0,f,p,h).apply(null,t(o,a)),U=(h?Pbt:U3e)(r,n-z[0],i-z[1],f,p,h);return u=t5(s,l,c),k=QE(t,U),O=QE(u,k),P=Gj(k,C),F()}function F(){return D=B=null,I}return function(){return t=e.apply(this,arguments),I.invert=t.invert&&L,R()}}function Vb(e){var t=0,r=Be/3,n=l5(e),i=n(t,r);return i.parallels=function(o){return arguments.length?n(t=o[0]*ye,r=o[1]*ye):[t*vr,r*vr]},i}function Ibt(e){var t=Zt(e);function r(n,i){return[n*t,Xt(i)/t]}return r.invert=function(n,i){return[n/t,wn(i*t)]},r}function Wj(e,t){var r=Xt(e),n=(r+Xt(t))/2;if(Re(n)<le)return Ibt(e);var i=1+r*(2*n-r),o=xr(i)/n;function a(s,l){var c=xr(i-2*n*Xt(l))/n;return[c*Xt(s*=n),o-c*Zt(s)]}return a.invert=function(s,l){var c=o-l,u=bn(s,Re(c))*ca(c);return c*n<0&&(u-=Be*ca(s)*ca(c)),[u/n,wn((i-(s*s+c*c)*n*n)/(2*n))]},a}function W_(){return Vb(Wj).scale(155.424).center([0,33.6442])}function Uk(){return W_().parallels([29.5,45.5]).scale(1070).translate([480,250]).rotate([96,0]).center([-.6,38.7])}function q3e(e){var t=e.length;return{point:function(r,n){for(var i=-1;++i<t;)e[i].point(r,n)},sphere:function(){for(var r=-1;++r<t;)e[r].sphere()},lineStart:function(){for(var r=-1;++r<t;)e[r].lineStart()},lineEnd:function(){for(var r=-1;++r<t;)e[r].lineEnd()},polygonStart:function(){for(var r=-1;++r<t;)e[r].polygonStart()},polygonEnd:function(){for(var r=-1;++r<t;)e[r].polygonEnd()}}}function Lbt(){var e,t,r=Uk(),n,i=W_().rotate([154,0]).center([-2,58.5]).parallels([55,65]),o,a=W_().rotate([157,0]).center([-3,19.9]).parallels([8,18]),s,l,c={point:function(f,p){l=[f,p]}};function u(f){var p=f[0],d=f[1];return l=null,n.point(p,d),l||(o.point(p,d),l)||(s.point(p,d),l)}u.invert=function(f){var p=r.scale(),d=r.translate(),g=(f[0]-d[0])/p,_=(f[1]-d[1])/p;return(_>=.12&&_<.234&&g>=-.425&&g<-.214?i:_>=.166&&_<.234&&g>=-.214&&g<-.115?a:r).invert(f)},u.stream=function(f){return e&&t===f?e:e=q3e([r.stream(t=f),i.stream(f),a.stream(f)])},u.precision=function(f){return arguments.length?(r.precision(f),i.precision(f),a.precision(f),h()):r.precision()},u.scale=function(f){return arguments.length?(r.scale(f),i.scale(f*.35),a.scale(f),u.translate(r.translate())):r.scale()},u.translate=function(f){if(!arguments.length)return r.translate();var p=r.scale(),d=+f[0],g=+f[1];return n=r.translate(f).clipExtent([[d-.455*p,g-.238*p],[d+.455*p,g+.238*p]]).stream(c),o=i.translate([d-.307*p,g+.201*p]).clipExtent([[d-.425*p+le,g+.12*p+le],[d-.214*p-le,g+.234*p-le]]).stream(c),s=a.translate([d-.205*p,g+.212*p]).clipExtent([[d-.214*p+le,g+.166*p+le],[d-.115*p-le,g+.234*p-le]]).stream(c),h()},u.fitExtent=function(f,p){return G_(u,f,p)},u.fitSize=function(f,p){return Fb(u,f,p)},u.fitWidth=function(f,p){return Bb(u,f,p)},u.fitHeight=function(f,p){return Hb(u,f,p)};function h(){return e=t=null,u}return u.scale(1070)}function qk(e){return function(t,r){var n=Zt(t),i=Zt(r),o=e(n*i);return[o*i*Xt(t),o*Xt(r)]}}function Vh(e){return function(t,r){var n=xr(t*t+r*r),i=e(n),o=Xt(i),a=Zt(i);return[bn(t*o,n*a),wn(n&&r*o/n)]}}var Gk=qk(function(e){return xr(2/(1+e))});Gk.invert=Vh(function(e){return 2*wn(e/2)});function kbt(){return Si(Gk).scale(124.75).clipAngle(180-.001)}var Wk=qk(function(e){return(e=hk(e))&&e/Xt(e)});Wk.invert=Vh(function(e){return e});function Rbt(){return Si(Wk).scale(79.4188).clipAngle(180-.001)}function Y_(e,t){return[e,F_(Ib((mn+t)/2))]}Y_.invert=function(e,t){return[e,2*ic(ck(t))-mn]};function Nbt(){return Yj(Y_).scale(961/wi)}function Yj(e){var t=Si(e),r=t.center,n=t.scale,i=t.translate,o=t.clipExtent,a=null,s,l,c;t.scale=function(h){return arguments.length?(n(h),u()):n()},t.translate=function(h){return arguments.length?(i(h),u()):i()},t.center=function(h){return arguments.length?(r(h),u()):r()},t.clipExtent=function(h){return arguments.length?(h==null?a=s=l=c=null:(a=+h[0][0],s=+h[0][1],l=+h[1][0],c=+h[1][1]),u()):a==null?null:[[a,s],[l,c]]};function u(){var h=Be*n(),f=t(wk(t.rotate()).invert([0,0]));return o(a==null?[[f[0]-h,f[1]-h],[f[0]+h,f[1]+h]]:e===Y_?[[Math.max(f[0]-h,a),s],[Math.min(f[0]+h,l),c]]:[[a,Math.max(f[1]-h,s)],[l,Math.min(f[1]+h,c)]])}return u()}function Yk(e){return Ib((mn+e)/2)}function jj(e,t){var r=Zt(e),n=e===t?Xt(e):F_(r/Zt(t))/F_(Yk(t)/Yk(e)),i=r*uk(Yk(e),n)/n;if(!n)return Y_;function o(a,s){i>0?s<-mn+le&&(s=-mn+le):s>mn-le&&(s=mn-le);var l=i/uk(Yk(s),n);return[l*Xt(n*a),i-l*Zt(n*a)]}return o.invert=function(a,s){var l=i-s,c=ca(n)*xr(a*a+l*l),u=bn(a,Re(l))*ca(l);return l*n<0&&(u-=Be*ca(a)*ca(l)),[u/n,2*ic(uk(i/c,1/n))-mn]},o}function Dbt(){return Vb(jj).scale(109.5).parallels([30,30])}function j_(e,t){return[e,t]}j_.invert=j_;function Obt(){return Si(j_).scale(152.63)}function Xj(e,t){var r=Zt(e),n=e===t?Xt(e):(r-Zt(t))/(t-e),i=r/n+e;if(Re(n)<le)return j_;function o(a,s){var l=i-s,c=n*a;return[l*Xt(c),i-l*Zt(c)]}return o.invert=function(a,s){var l=i-s,c=bn(a,Re(l))*ca(l);return l*n<0&&(c-=Be*ca(a)*ca(l)),[c/n,i-ca(n)*xr(a*a+l*l)]},o}function zbt(){return Vb(Xj).scale(131.154).center([0,13.9389])}var c5=1.340264,u5=-.081106,h5=893e-6,f5=.003796,jk=xr(3)/2,G3e=12;function Xk(e,t){var r=wn(jk*Xt(t)),n=r*r,i=n*n*n;return[e*Zt(r)/(jk*(c5+3*u5*n+i*(7*h5+9*f5*n))),r*(c5+u5*n+i*(h5+f5*n))]}Xk.invert=function(e,t){for(var r=t,n=r*r,i=n*n*n,o=0,a,s,l;o<G3e&&(s=r*(c5+u5*n+i*(h5+f5*n))-t,l=c5+3*u5*n+i*(7*h5+9*f5*n),r-=a=s/l,n=r*r,i=n*n*n,!(Re(a)<z_));++o);return[jk*e*(c5+3*u5*n+i*(7*h5+9*f5*n))/Zt(r),wn(Xt(r)/jk)]};function Fbt(){return Si(Xk).scale(177.158)}function $k(e,t){var r=Zt(t),n=Zt(e)*r;return[r*Xt(e)/n,Xt(t)/n]}$k.invert=Vh(ic);function Bbt(){return Si($k).scale(144.049).clipAngle(60)}function Hbt(){var e=1,t=0,r=0,n=1,i=1,o=0,a,s,l=null,c,u,h,f=1,p=1,d=$m({point:function(S,C){var P=b([S,C]);this.stream.point(P[0],P[1])}}),g=jm,_,y;function x(){return f=e*n,p=e*i,_=y=null,b}function b(S){var C=S[0]*f,P=S[1]*p;if(o){var k=P*a-C*s;C=C*a+P*s,P=k}return[C+t,P+r]}return b.invert=function(S){var C=S[0]-t,P=S[1]-r;if(o){var k=P*a+C*s;C=C*a-P*s,P=k}return[C/f,P/p]},b.stream=function(S){return _&&y===S?_:_=d(g(y=S))},b.postclip=function(S){return arguments.length?(g=S,l=c=u=h=null,x()):g},b.clipExtent=function(S){return arguments.length?(g=S==null?(l=c=u=h=null,jm):Dp(l=+S[0][0],c=+S[0][1],u=+S[1][0],h=+S[1][1]),x()):l==null?null:[[l,c],[u,h]]},b.scale=function(S){return arguments.length?(e=+S,x()):e},b.translate=function(S){return arguments.length?(t=+S[0],r=+S[1],x()):[t,r]},b.angle=function(S){return arguments.length?(o=S%360*ye,s=Xt(o),a=Zt(o),x()):o*vr},b.reflectX=function(S){return arguments.length?(n=S?-1:1,x()):n<0},b.reflectY=function(S){return arguments.length?(i=S?-1:1,x()):i<0},b.fitExtent=function(S,C){return G_(b,S,C)},b.fitSize=function(S,C){return Fb(b,S,C)},b.fitWidth=function(S,C){return Bb(b,S,C)},b.fitHeight=function(S,C){return Hb(b,S,C)},b}function Kk(e,t){var r=t*t,n=r*r;return[e*(.8707-.131979*r+n*(-.013791+n*(.003971*r-.001529*n))),t*(1.007226+r*(.015085+n*(-.044475+.028874*r-.005916*n)))]}Kk.invert=function(e,t){var r=t,n=25,i;do{var o=r*r,a=o*o;r-=i=(r*(1.007226+o*(.015085+a*(-.044475+.028874*o-.005916*a)))-t)/(1.007226+o*(.015085*3+a*(-.044475*7+.028874*9*o-.005916*11*a)))}while(Re(i)>le&&--n>0);return[e/(.8707+(o=r*r)*(-.131979+o*(-.013791+o*o*o*(.003971-.001529*o)))),r]};function Vbt(){return Si(Kk).scale(175.295)}function Zk(e,t){return[Zt(t)*Xt(e),Xt(t)]}Zk.invert=Vh(wn);function Ubt(){return Si(Zk).scale(249.5).clipAngle(90+le)}function Jk(e,t){var r=Zt(t),n=1+Zt(e)*r;return[r*Xt(e)/n,Xt(t)/n]}Jk.invert=Vh(function(e){return 2*ic(e)});function qbt(){return Si(Jk).scale(250).clipAngle(142)}function Qk(e,t){return[F_(Ib((mn+t)/2)),-e]}Qk.invert=function(e,t){return[-t,2*ic(ck(e))-mn]};function Gbt(){var e=Yj(Qk),t=e.center,r=e.rotate;return e.center=function(n){return arguments.length?t([-n[1],n[0]]):(n=t(),[n[1],-n[0]])},e.rotate=function(n){return arguments.length?r([n[0],n[1],n.length>2?n[2]+90:90]):(n=r(),[n[0],n[1],n[2]-90])},r([0,0,90]).scale(159.155)}function W3e(e,t){return e.parent===t.parent?1:2}function Y3e(e){return e.reduce(j3e,0)/e.length}function j3e(e,t){return e+t.x}function X3e(e){return 1+e.reduce($3e,0)}function $3e(e,t){return Math.max(e,t.y)}function K3e(e){for(var t;t=e.children;)e=t[0];return e}function Z3e(e){for(var t;t=e.children;)e=t[t.length-1];return e}function Wbt(){var e=W3e,t=1,r=1,n=!1;function i(o){var a,s=0;o.eachAfter(function(f){var p=f.children;p?(f.x=Y3e(p),f.y=X3e(p)):(f.x=a?s+=e(f,a):0,f.y=0,a=f)});var l=K3e(o),c=Z3e(o),u=l.x-e(l,c)/2,h=c.x+e(c,l)/2;return o.eachAfter(n?function(f){f.x=(f.x-o.x)*t,f.y=(o.y-f.y)*r}:function(f){f.x=(f.x-u)/(h-u)*t,f.y=(1-(o.y?f.y/o.y:1))*r})}return i.separation=function(o){return arguments.length?(e=o,i):e},i.size=function(o){return arguments.length?(n=!1,t=+o[0],r=+o[1],i):n?null:[t,r]},i.nodeSize=function(o){return arguments.length?(n=!0,t=+o[0],r=+o[1],i):n?[t,r]:null},i}function J3e(e){var t=0,r=e.children,n=r&&r.length;if(!n)t=1;else for(;--n>=0;)t+=r[n].value;e.value=t}function Ybt(){return this.eachAfter(J3e)}function jbt(e){var t=this,r,n=[t],i,o,a;do for(r=n.reverse(),n=[];t=r.pop();)if(e(t),i=t.children,i)for(o=0,a=i.length;o<a;++o)n.push(i[o]);while(n.length);return this}function Xbt(e){for(var t=this,r=[t],n,i;t=r.pop();)if(e(t),n=t.children,n)for(i=n.length-1;i>=0;--i)r.push(n[i]);return this}function $bt(e){for(var t=this,r=[t],n=[],i,o,a;t=r.pop();)if(n.push(t),i=t.children,i)for(o=0,a=i.length;o<a;++o)r.push(i[o]);for(;t=n.pop();)e(t);return this}function Kbt(e){return this.eachAfter(function(t){for(var r=+e(t.data)||0,n=t.children,i=n&&n.length;--i>=0;)r+=n[i].value;t.value=r})}function Zbt(e){return this.eachBefore(function(t){t.children&&t.children.sort(e)})}function Jbt(e){for(var t=this,r=Q3e(t,e),n=[t];t!==r;)t=t.parent,n.push(t);for(var i=n.length;e!==r;)n.splice(i,0,e),e=e.parent;return n}function Q3e(e,t){if(e===t)return e;var r=e.ancestors(),n=t.ancestors(),i=null;for(e=r.pop(),t=n.pop();e===t;)i=e,e=r.pop(),t=n.pop();return i}function Qbt(){for(var e=this,t=[e];e=e.parent;)t.push(e);return t}function t2t(){var e=[];return this.each(function(t){e.push(t)}),e}function e2t(){var e=[];return this.eachBefore(function(t){t.children||e.push(t)}),e}function r2t(){var e=this,t=[];return e.each(function(r){r!==e&&t.push({source:r.parent,target:r})}),t}function p5(e,t){var r=new Km(e),n=+e.value&&(r.value=e.value),i,o=[r],a,s,l,c;for(t==null&&(t=eMe);i=o.pop();)if(n&&(i.value=+i.data.value),(s=t(i.data))&&(c=s.length))for(i.children=new Array(c),l=c-1;l>=0;--l)o.push(a=i.children[l]=new Km(s[l])),a.parent=i,a.depth=i.depth+1;return r.eachBefore($j)}function tMe(){return p5(this).eachBefore(rMe)}function eMe(e){return e.children}function rMe(e){e.data=e.data.data}function $j(e){var t=0;do e.height=t;while((e=e.parent)&&e.height<++t)}function Km(e){this.data=e,this.depth=this.height=0,this.parent=null}Km.prototype=p5.prototype={constructor:Km,count:Ybt,each:jbt,eachAfter:$bt,eachBefore:Xbt,sum:Kbt,sort:Zbt,path:Jbt,ancestors:Qbt,descendants:t2t,leaves:e2t,links:r2t,copy:tMe};var n2t=Array.prototype.slice;function i2t(e){for(var t=e.length,r,n;t;)n=Math.random()*t--|0,r=e[t],e[t]=e[n],e[n]=r;return e}function e8(e){for(var t=0,r=(e=i2t(n2t.call(e))).length,n=[],i,o;t<r;)i=e[t],o&&o2t(o,i)?++t:(o=iMe(n=nMe(n,i)),t=0);return o}function nMe(e,t){var r,n;if(Kj(t,e))return[t];for(r=0;r<e.length;++r)if(t8(t,e[r])&&Kj(d5(e[r],t),e))return[e[r],t];for(r=0;r<e.length-1;++r)for(n=r+1;n<e.length;++n)if(t8(d5(e[r],e[n]),t)&&t8(d5(e[r],t),e[n])&&t8(d5(e[n],t),e[r])&&Kj(a2t(e[r],e[n],t),e))return[e[r],e[n],t];throw new Error}function t8(e,t){var r=e.r-t.r,n=t.x-e.x,i=t.y-e.y;return r<0||r*r<n*n+i*i}function o2t(e,t){var r=e.r-t.r+1e-6,n=t.x-e.x,i=t.y-e.y;return r>0&&r*r>n*n+i*i}function Kj(e,t){for(var r=0;r<t.length;++r)if(!o2t(e,t[r]))return!1;return!0}function iMe(e){switch(e.length){case 1:return oMe(e[0]);case 2:return d5(e[0],e[1]);case 3:return a2t(e[0],e[1],e[2])}}function oMe(e){return{x:e.x,y:e.y,r:e.r}}function d5(e,t){var r=e.x,n=e.y,i=e.r,o=t.x,a=t.y,s=t.r,l=o-r,c=a-n,u=s-i,h=Math.sqrt(l*l+c*c);return{x:(r+o+l/h*u)/2,y:(n+a+c/h*u)/2,r:(h+i+s)/2}}function a2t(e,t,r){var n=e.x,i=e.y,o=e.r,a=t.x,s=t.y,l=t.r,c=r.x,u=r.y,h=r.r,f=n-a,p=n-c,d=i-s,g=i-u,_=l-o,y=h-o,x=n*n+i*i-o*o,b=x-a*a-s*s+l*l,S=x-c*c-u*u+h*h,C=p*d-f*g,P=(d*S-g*b)/(C*2)-n,k=(g*_-d*y)/C,O=(p*b-f*S)/(C*2)-i,D=(f*y-p*_)/C,B=k*k+D*D-1,I=2*(o+P*k+O*D),L=P*P+O*O-o*o,R=-(B?(I+Math.sqrt(I*I-4*B*L))/(2*B):L/I);return{x:n+P+k*R,y:i+O+D*R,r:R}}function s2t(e,t,r){var n=e.x-t.x,i,o,a=e.y-t.y,s,l,c=n*n+a*a;c?(o=t.r+r.r,o*=o,l=e.r+r.r,l*=l,o>l?(i=(c+l-o)/(2*c),s=Math.sqrt(Math.max(0,l/c-i*i)),r.x=e.x-i*n-s*a,r.y=e.y-i*a+s*n):(i=(c+o-l)/(2*c),s=Math.sqrt(Math.max(0,o/c-i*i)),r.x=t.x+i*n-s*a,r.y=t.y+i*a+s*n)):(r.x=t.x+r.r,r.y=t.y)}function l2t(e,t){var r=e.r+t.r-1e-6,n=t.x-e.x,i=t.y-e.y;return r>0&&r*r>n*n+i*i}function c2t(e){var t=e._,r=e.next._,n=t.r+r.r,i=(t.x*r.r+r.x*t.r)/n,o=(t.y*r.r+r.y*t.r)/n;return i*i+o*o}function r8(e){this._=e,this.next=null,this.previous=null}function Zj(e){if(!(i=e.length))return 0;var t,r,n,i,o,a,s,l,c,u,h;if(t=e[0],t.x=0,t.y=0,!(i>1))return t.r;if(r=e[1],t.x=-r.r,r.x=t.r,r.y=0,!(i>2))return t.r+r.r;s2t(r,t,n=e[2]),t=new r8(t),r=new r8(r),n=new r8(n),t.next=n.previous=r,r.next=t.previous=n,n.next=r.previous=t;t:for(s=3;s<i;++s){s2t(t._,r._,n=e[s]),n=new r8(n),l=r.next,c=t.previous,u=r._.r,h=t._.r;do if(u<=h){if(l2t(l._,n._)){r=l,t.next=r,r.previous=t,--s;continue t}u+=l._.r,l=l.next}else{if(l2t(c._,n._)){t=c,t.next=r,r.previous=t,--s;continue t}h+=c._.r,c=c.previous}while(l!==c.next);for(n.previous=t,n.next=r,t.next=r.previous=r=n,o=c2t(t);(n=n.next)!==r;)(a=c2t(n))<o&&(t=n,o=a);r=t.next}for(t=[r._],n=r;(n=n.next)!==r;)t.push(n._);for(n=e8(t),s=0;s<i;++s)t=e[s],t.x-=n.x,t.y-=n.y;return n.r}function u2t(e){return Zj(e),e}function h2t(e){return e==null?null:Ub(e)}function Ub(e){if(typeof e!="function")throw new Error;return e}function Op(){return 0}function Zm(e){return function(){return e}}function aMe(e){return Math.sqrt(e.value)}function d2t(){var e=null,t=1,r=1,n=Op;function i(o){return o.x=t/2,o.y=r/2,e?o.eachBefore(f2t(e)).eachAfter(Jj(n,.5)).eachBefore(p2t(1)):o.eachBefore(f2t(aMe)).eachAfter(Jj(Op,1)).eachAfter(Jj(n,o.r/Math.min(t,r))).eachBefore(p2t(Math.min(t,r)/(2*o.r))),o}return i.radius=function(o){return arguments.length?(e=h2t(o),i):e},i.size=function(o){return arguments.length?(t=+o[0],r=+o[1],i):[t,r]},i.padding=function(o){return arguments.length?(n=typeof o=="function"?o:Zm(+o),i):n},i}function f2t(e){return function(t){t.children||(t.r=Math.max(0,+e(t)||0))}}function Jj(e,t){return function(r){if(n=r.children){var n,i,o=n.length,a=e(r)*t||0,s;if(a)for(i=0;i<o;++i)n[i].r+=a;if(s=Zj(n),a)for(i=0;i<o;++i)n[i].r-=a;r.r=s+a}}}function p2t(e){return function(t){var r=t.parent;t.r*=e,r&&(t.x=r.x+e*t.x,t.y=r.y+e*t.y)}}function n8(e){e.x0=Math.round(e.x0),e.y0=Math.round(e.y0),e.x1=Math.round(e.x1),e.y1=Math.round(e.y1)}function Uh(e,t,r,n,i){for(var o=e.children,a,s=-1,l=o.length,c=e.value&&(n-t)/e.value;++s<l;)a=o[s],a.y0=r,a.y1=i,a.x0=t,a.x1=t+=a.value*c}function m2t(){var e=1,t=1,r=0,n=!1;function i(a){var s=a.height+1;return a.x0=a.y0=r,a.x1=e,a.y1=t/s,a.eachBefore(o(t,s)),n&&a.eachBefore(n8),a}function o(a,s){return function(l){l.children&&Uh(l,l.x0,a*(l.depth+1)/s,l.x1,a*(l.depth+2)/s);var c=l.x0,u=l.y0,h=l.x1-r,f=l.y1-r;h<c&&(c=h=(c+h)/2),f<u&&(u=f=(u+f)/2),l.x0=c,l.y0=u,l.x1=h,l.y1=f}}return i.round=function(a){return arguments.length?(n=!!a,i):n},i.size=function(a){return arguments.length?(e=+a[0],t=+a[1],i):[e,t]},i.padding=function(a){return arguments.length?(r=+a,i):r},i}var g2t="$",sMe={depth:-1},_2t={};function lMe(e){return e.id}function cMe(e){return e.parentId}function y2t(){var e=lMe,t=cMe;function r(n){var i,o,a=n.length,s,l,c,u=new Array(a),h,f,p={};for(o=0;o<a;++o)i=n[o],c=u[o]=new Km(i),(h=e(i,o,n))!=null&&(h+="")&&(f=g2t+(c.id=h),p[f]=f in p?_2t:c);for(o=0;o<a;++o)if(c=u[o],h=t(n[o],o,n),h==null||!(h+="")){if(s)throw new Error("multiple roots");s=c}else{if(l=p[g2t+h],!l)throw new Error("missing: "+h);if(l===_2t)throw new Error("ambiguous: "+h);l.children?l.children.push(c):l.children=[c],c.parent=l}if(!s)throw new Error("no root");if(s.parent=sMe,s.eachBefore(function(d){d.depth=d.parent.depth+1,--a}).eachBefore($j),s.parent=null,a>0)throw new Error("cycle");return s}return r.id=function(n){return arguments.length?(e=Ub(n),r):e},r.parentId=function(n){return arguments.length?(t=Ub(n),r):t},r}function uMe(e,t){return e.parent===t.parent?1:2}function Qj(e){var t=e.children;return t?t[0]:e.t}function tX(e){var t=e.children;return t?t[t.length-1]:e.t}function hMe(e,t,r){var n=r/(t.i-e.i);t.c-=n,t.s+=r,e.c+=n,t.z+=r,t.m+=r}function fMe(e){for(var t=0,r=0,n=e.children,i=n.length,o;--i>=0;)o=n[i],o.z+=t,o.m+=t,t+=o.s+(r+=o.c)}function pMe(e,t,r){return e.a.parent===t.parent?e.a:r}function i8(e,t){this._=e,this.parent=null,this.children=null,this.A=null,this.a=this,this.z=0,this.m=0,this.c=0,this.s=0,this.t=null,this.i=t}i8.prototype=Object.create(Km.prototype);function dMe(e){for(var t=new i8(e,0),r,n=[t],i,o,a,s;r=n.pop();)if(o=r._.children)for(r.children=new Array(s=o.length),a=s-1;a>=0;--a)n.push(i=r.children[a]=new i8(o[a],a)),i.parent=r;return(t.parent=new i8(null,0)).children=[t],t}function v2t(){var e=uMe,t=1,r=1,n=null;function i(c){var u=dMe(c);if(u.eachAfter(o),u.parent.m=-u.z,u.eachBefore(a),n)c.eachBefore(l);else{var h=c,f=c,p=c;c.eachBefore(function(x){x.x<h.x&&(h=x),x.x>f.x&&(f=x),x.depth>p.depth&&(p=x)});var d=h===f?1:e(h,f)/2,g=d-h.x,_=t/(f.x+d+g),y=r/(p.depth||1);c.eachBefore(function(x){x.x=(x.x+g)*_,x.y=x.depth*y})}return c}function o(c){var u=c.children,h=c.parent.children,f=c.i?h[c.i-1]:null;if(u){fMe(c);var p=(u[0].z+u[u.length-1].z)/2;f?(c.z=f.z+e(c._,f._),c.m=c.z-p):c.z=p}else f&&(c.z=f.z+e(c._,f._));c.parent.A=s(c,f,c.parent.A||h[0])}function a(c){c._.x=c.z+c.parent.m,c.m+=c.parent.m}function s(c,u,h){if(u){for(var f=c,p=c,d=u,g=f.parent.children[0],_=f.m,y=p.m,x=d.m,b=g.m,S;d=tX(d),f=Qj(f),d&&f;)g=Qj(g),p=tX(p),p.a=c,S=d.z+x-f.z-_+e(d._,f._),S>0&&(hMe(pMe(d,c,h),c,S),_+=S,y+=S),x+=d.m,_+=f.m,b+=g.m,y+=p.m;d&&!tX(p)&&(p.t=d,p.m+=x-y),f&&!Qj(g)&&(g.t=f,g.m+=_-b,h=c)}return h}function l(c){c.x*=t,c.y=c.depth*r}return i.separation=function(c){return arguments.length?(e=c,i):e},i.size=function(c){return arguments.length?(n=!1,t=+c[0],r=+c[1],i):n?null:[t,r]},i.nodeSize=function(c){return arguments.length?(n=!0,t=+c[0],r=+c[1],i):n?[t,r]:null},i}function Jm(e,t,r,n,i){for(var o=e.children,a,s=-1,l=o.length,c=e.value&&(i-r)/e.value;++s<l;)a=o[s],a.x0=t,a.x1=n,a.y0=r,a.y1=r+=a.value*c}var eX=(1+Math.sqrt(5))/2;function rX(e,t,r,n,i,o){for(var a=[],s=t.children,l,c,u=0,h=0,f=s.length,p,d,g=t.value,_,y,x,b,S,C,P;u<f;){p=i-r,d=o-n;do _=s[h++].value;while(!_&&h<f);for(y=x=_,C=Math.max(d/p,p/d)/(g*e),P=_*_*C,S=Math.max(x/P,P/y);h<f;++h){if(_+=c=s[h].value,c<y&&(y=c),c>x&&(x=c),P=_*_*C,b=Math.max(x/P,P/y),b>S){_-=c;break}S=b}a.push(l={value:_,dice:p<d,children:s.slice(u,h)}),l.dice?Uh(l,r,n,i,g?n+=d*_/g:o):Jm(l,r,n,g?r+=p*_/g:i,o),g-=_,u=h}return a}var o8=function e(t){function r(n,i,o,a,s){rX(t,n,i,o,a,s)}return r.ratio=function(n){return e((n=+n)>1?n:1)},r}(eX);function x2t(){var e=o8,t=!1,r=1,n=1,i=[0],o=Op,a=Op,s=Op,l=Op,c=Op;function u(f){return f.x0=f.y0=0,f.x1=r,f.y1=n,f.eachBefore(h),i=[0],t&&f.eachBefore(n8),f}function h(f){var p=i[f.depth],d=f.x0+p,g=f.y0+p,_=f.x1-p,y=f.y1-p;_<d&&(d=_=(d+_)/2),y<g&&(g=y=(g+y)/2),f.x0=d,f.y0=g,f.x1=_,f.y1=y,f.children&&(p=i[f.depth+1]=o(f)/2,d+=c(f)-p,g+=a(f)-p,_-=s(f)-p,y-=l(f)-p,_<d&&(d=_=(d+_)/2),y<g&&(g=y=(g+y)/2),e(f,d,g,_,y))}return u.round=function(f){return arguments.length?(t=!!f,u):t},u.size=function(f){return arguments.length?(r=+f[0],n=+f[1],u):[r,n]},u.tile=function(f){return arguments.length?(e=Ub(f),u):e},u.padding=function(f){return arguments.length?u.paddingInner(f).paddingOuter(f):u.paddingInner()},u.paddingInner=function(f){return arguments.length?(o=typeof f=="function"?f:Zm(+f),u):o},u.paddingOuter=function(f){return arguments.length?u.paddingTop(f).paddingRight(f).paddingBottom(f).paddingLeft(f):u.paddingTop()},u.paddingTop=function(f){return arguments.length?(a=typeof f=="function"?f:Zm(+f),u):a},u.paddingRight=function(f){return arguments.length?(s=typeof f=="function"?f:Zm(+f),u):s},u.paddingBottom=function(f){return arguments.length?(l=typeof f=="function"?f:Zm(+f),u):l},u.paddingLeft=function(f){return arguments.length?(c=typeof f=="function"?f:Zm(+f),u):c},u}function b2t(e,t,r,n,i){var o=e.children,a,s=o.length,l,c=new Array(s+1);for(c[0]=l=a=0;a<s;++a)c[a+1]=l+=o[a].value;u(0,s,e.value,t,r,n,i);function u(h,f,p,d,g,_,y){if(h>=f-1){var x=o[h];x.x0=d,x.y0=g,x.x1=_,x.y1=y;return}for(var b=c[h],S=p/2+b,C=h+1,P=f-1;C<P;){var k=C+P>>>1;c[k]<S?C=k+1:P=k}S-c[C-1]<c[C]-S&&h+1<C&&--C;var O=c[C]-b,D=p-O;if(_-d>y-g){var B=(d*D+_*O)/p;u(h,C,O,d,g,B,y),u(C,f,D,B,g,_,y)}else{var I=(g*D+y*O)/p;u(h,C,O,d,g,_,I),u(C,f,D,d,I,_,y)}}}function w2t(e,t,r,n,i){(e.depth&1?Jm:Uh)(e,t,r,n,i)}var S2t=function e(t){function r(n,i,o,a,s){if((l=n._squarify)&&l.ratio===t)for(var l,c,u,h,f=-1,p,d=l.length,g=n.value;++f<d;){for(c=l[f],u=c.children,h=c.value=0,p=u.length;h<p;++h)c.value+=u[h].value;c.dice?Uh(c,i,o,a,o+=(s-o)*c.value/g):Jm(c,i,o,i+=(a-i)*c.value/g,s),g-=c.value}else n._squarify=l=rX(t,n,i,o,a,s),l.ratio=t}return r.ratio=function(n){return e((n=+n)>1?n:1)},r}(eX);function M2t(e){for(var t=-1,r=e.length,n,i=e[r-1],o=0;++t<r;)n=i,i=e[t],o+=n[1]*i[0]-n[0]*i[1];return o/2}function E2t(e){for(var t=-1,r=e.length,n=0,i=0,o,a=e[r-1],s,l=0;++t<r;)o=a,a=e[t],l+=s=o[0]*a[1]-a[0]*o[1],n+=(o[0]+a[0])*s,i+=(o[1]+a[1])*s;return l*=3,[n/l,i/l]}function T2t(e,t,r){return(t[0]-e[0])*(r[1]-e[1])-(t[1]-e[1])*(r[0]-e[0])}function mMe(e,t){return e[0]-t[0]||e[1]-t[1]}function C2t(e){for(var t=e.length,r=[0,1],n=2,i=2;i<t;++i){for(;n>1&&T2t(e[r[n-2]],e[r[n-1]],e[i])<=0;)--n;r[n++]=i}return r.slice(0,n)}function A2t(e){if((r=e.length)<3)return null;var t,r,n=new Array(r),i=new Array(r);for(t=0;t<r;++t)n[t]=[+e[t][0],+e[t][1],t];for(n.sort(mMe),t=0;t<r;++t)i[t]=[n[t][0],-n[t][1]];var o=C2t(n),a=C2t(i),s=a[0]===o[0],l=a[a.length-1]===o[o.length-1],c=[];for(t=o.length-1;t>=0;--t)c.push(e[n[o[t]][2]]);for(t=+s;t<a.length-l;++t)c.push(e[n[a[t]][2]]);return c}function P2t(e,t){for(var r=e.length,n=e[r-1],i=t[0],o=t[1],a=n[0],s=n[1],l,c,u=!1,h=0;h<r;++h)n=e[h],l=n[0],c=n[1],c>o!=s>o&&i<(a-l)*(o-c)/(s-c)+l&&(u=!u),a=l,s=c;return u}function I2t(e){for(var t=-1,r=e.length,n=e[r-1],i,o,a=n[0],s=n[1],l=0;++t<r;)i=a,o=s,n=e[t],a=n[0],s=n[1],i-=a,o-=s,l+=Math.sqrt(i*i+o*o);return l}function ac(){return Math.random()}var L2t=function e(t){function r(n,i){return n=n==null?0:+n,i=i==null?1:+i,arguments.length===1?(i=n,n=0):i-=n,function(){return t()*i+n}}return r.source=e,r}(ac);var a8=function e(t){function r(n,i){var o,a;return n=n==null?0:+n,i=i==null?1:+i,function(){var s;if(o!=null)s=o,o=null;else do o=t()*2-1,s=t()*2-1,a=o*o+s*s;while(!a||a>1);return n+i*s*Math.sqrt(-2*Math.log(a)/a)}}return r.source=e,r}(ac);var k2t=function e(t){function r(){var n=a8.source(t).apply(this,arguments);return function(){return Math.exp(n())}}return r.source=e,r}(ac);var s8=function e(t){function r(n){return function(){for(var i=0,o=0;o<n;++o)i+=t();return i}}return r.source=e,r}(ac);var R2t=function e(t){function r(n){var i=s8.source(t)(n);return function(){return i()/n}}return r.source=e,r}(ac);var N2t=function e(t){function r(n){return function(){return-Math.log(1-t())/n}}return r.source=e,r}(ac);function hi(e,t){switch(arguments.length){case 0:break;case 1:this.range(e);break;default:this.range(t).domain(e);break}return this}function sc(e,t){switch(arguments.length){case 0:break;case 1:this.interpolator(e);break;default:this.interpolator(t).domain(e);break}return this}Tb();var D2t=Array.prototype,X_=D2t.map,lc=D2t.slice;var l8={name:"implicit"};function gu(){var e=Ji(),t=[],r=[],n=l8;function i(o){var a=o+"",s=e.get(a);if(!s){if(n!==l8)return n;e.set(a,s=t.push(o))}return r[(s-1)%r.length]}return i.domain=function(o){if(!arguments.length)return t.slice();t=[],e=Ji();for(var a=-1,s=o.length,l,c;++a<s;)e.has(c=(l=o[a])+"")||e.set(c,t.push(l));return i},i.range=function(o){return arguments.length?(r=lc.call(o),i):r.slice()},i.unknown=function(o){return arguments.length?(n=o,i):n},i.copy=function(){return gu(t,r).unknown(n)},hi.apply(i,arguments),i}function Qm(){var e=gu().unknown(void 0),t=e.domain,r=e.range,n=[0,1],i,o,a=!1,s=0,l=0,c=.5;delete e.unknown;function u(){var h=t().length,f=n[1]<n[0],p=n[f-0],d=n[1-f];i=(d-p)/Math.max(1,h-s+l*2),a&&(i=Math.floor(i)),p+=(d-p-i*(h-s))*c,o=i*(1-s),a&&(p=Math.round(p),o=Math.round(o));var g=Ir(h).map(function(_){return p+i*_});return r(f?g.reverse():g)}return e.domain=function(h){return arguments.length?(t(h),u()):t()},e.range=function(h){return arguments.length?(n=[+h[0],+h[1]],u()):n.slice()},e.rangeRound=function(h){return n=[+h[0],+h[1]],a=!0,u()},e.bandwidth=function(){return o},e.step=function(){return i},e.round=function(h){return arguments.length?(a=!!h,u()):a},e.padding=function(h){return arguments.length?(s=Math.min(1,l=+h),u()):s},e.paddingInner=function(h){return arguments.length?(s=Math.min(1,h),u()):s},e.paddingOuter=function(h){return arguments.length?(l=+h,u()):l},e.align=function(h){return arguments.length?(c=Math.max(0,Math.min(1,h)),u()):c},e.copy=function(){return Qm(t(),n).round(a).paddingInner(s).paddingOuter(l).align(c)},hi.apply(u(),arguments)}function O2t(e){var t=e.copy;return e.padding=e.paddingOuter,delete e.paddingInner,delete e.paddingOuter,e.copy=function(){return O2t(t())},e}function tg(){return O2t(Qm.apply(null,arguments).paddingInner(1))}function z2t(e){return function(){return e}}function m5(e){return+e}var F2t=[0,1];function ni(e){return e}function nX(e,t){return(t-=e=+e)?function(r){return(r-e)/t}:z2t(isNaN(t)?NaN:.5)}function B2t(e){var t=e[0],r=e[e.length-1],n;return t>r&&(n=t,t=r,r=n),function(i){return Math.max(t,Math.min(r,i))}}function gMe(e,t,r){var n=e[0],i=e[1],o=t[0],a=t[1];return i<n?(n=nX(i,n),o=r(a,o)):(n=nX(n,i),o=r(o,a)),function(s){return o(n(s))}}function _Me(e,t,r){var n=Math.min(e.length,t.length)-1,i=new Array(n),o=new Array(n),a=-1;for(e[n]<e[0]&&(e=e.slice().reverse(),t=t.slice().reverse());++a<n;)i[a]=nX(e[a],e[a+1]),o[a]=r(t[a],t[a+1]);return function(s){var l=ys(e,s,1,n)-1;return o[l](i[l](s))}}function qh(e,t){return t.domain(e.domain()).range(e.range()).interpolate(e.interpolate()).clamp(e.clamp()).unknown(e.unknown())}function $_(){var e=F2t,t=F2t,r=nc,n,i,o,a=ni,s,l,c;function u(){return s=Math.min(e.length,t.length)>2?_Me:gMe,l=c=null,h}function h(f){return isNaN(f=+f)?o:(l||(l=s(e.map(n),t,r)))(n(a(f)))}return h.invert=function(f){return a(i((c||(c=s(t,e.map(n),zi)))(f)))},h.domain=function(f){return arguments.length?(e=X_.call(f,m5),a===ni||(a=B2t(e)),u()):e.slice()},h.range=function(f){return arguments.length?(t=lc.call(f),u()):t.slice()},h.rangeRound=function(f){return t=lc.call(f),r=dL,u()},h.clamp=function(f){return arguments.length?(a=f?B2t(e):ni,h):a!==ni},h.interpolate=function(f){return arguments.length?(r=f,u()):r},h.unknown=function(f){return arguments.length?(o=f,h):o},function(f,p){return n=f,i=p,u()}}function g5(e,t){return $_()(e,t)}function c8(e,t,r,n){var i=tl(e,t,r),o;switch(n=Lp(n==null?",f":n),n.type){case"s":{var a=Math.max(Math.abs(e),Math.abs(t));return n.precision==null&&!isNaN(o=ok(i,a))&&(n.precision=o),WE(n,a)}case"":case"e":case"g":case"p":case"r":{n.precision==null&&!isNaN(o=ak(i,Math.max(Math.abs(e),Math.abs(t))))&&(n.precision=o-(n.type==="e"));break}case"f":case"%":{n.precision==null&&!isNaN(o=ik(i))&&(n.precision=o-(n.type==="%")*2);break}}return xn(n)}function il(e){var t=e.domain;return e.ticks=function(r){var n=t();return ab(n[0],n[n.length-1],r==null?10:r)},e.tickFormat=function(r,n){var i=t();return c8(i[0],i[i.length-1],r==null?10:r,n)},e.nice=function(r){r==null&&(r=10);var n=t(),i=0,o=n.length-1,a=n[i],s=n[o],l;return s<a&&(l=a,a=s,s=l,l=i,i=o,o=l),l=x_(a,s,r),l>0?(a=Math.floor(a/l)*l,s=Math.ceil(s/l)*l,l=x_(a,s,r)):l<0&&(a=Math.ceil(a*l)/l,s=Math.floor(s*l)/l,l=x_(a,s,r)),l>0?(n[i]=Math.floor(a/l)*l,n[o]=Math.ceil(s/l)*l,t(n)):l<0&&(n[i]=Math.ceil(a*l)/l,n[o]=Math.floor(s*l)/l,t(n)),e},e}function On(){var e=g5(ni,ni);return e.copy=function(){return qh(e,On())},hi.apply(e,arguments),il(e)}function u8(e){var t;function r(n){return isNaN(n=+n)?t:n}return r.invert=r,r.domain=r.range=function(n){return arguments.length?(e=X_.call(n,m5),r):e.slice()},r.unknown=function(n){return arguments.length?(t=n,r):t},r.copy=function(){return u8(e).unknown(t)},e=arguments.length?X_.call(e,m5):[0,1],il(r)}function h8(e,t){e=e.slice();var r=0,n=e.length-1,i=e[r],o=e[n],a;return o<i&&(a=r,r=n,n=a,a=i,i=o,o=a),e[r]=t.floor(i),e[n]=t.ceil(o),e}function H2t(e){return Math.log(e)}function V2t(e){return Math.exp(e)}function yMe(e){return-Math.log(-e)}function vMe(e){return-Math.exp(-e)}function xMe(e){return isFinite(e)?+("1e"+e):e<0?0:e}function bMe(e){return e===10?xMe:e===Math.E?Math.exp:function(t){return Math.pow(e,t)}}function wMe(e){return e===Math.E?Math.log:e===10&&Math.log10||e===2&&Math.log2||(e=Math.log(e),function(t){return Math.log(t)/e})}function U2t(e){return function(t){return-e(-t)}}function _5(e){var t=e(H2t,V2t),r=t.domain,n=10,i,o;function a(){return i=wMe(n),o=bMe(n),r()[0]<0?(i=U2t(i),o=U2t(o),e(yMe,vMe)):e(H2t,V2t),t}return t.base=function(s){return arguments.length?(n=+s,a()):n},t.domain=function(s){return arguments.length?(r(s),a()):r()},t.ticks=function(s){var l=r(),c=l[0],u=l[l.length-1],h;(h=u<c)&&(f=c,c=u,u=f);var f=i(c),p=i(u),d,g,_,y=s==null?10:+s,x=[];if(!(n%1)&&p-f<y){if(f=Math.round(f)-1,p=Math.round(p)+1,c>0){for(;f<p;++f)for(g=1,d=o(f);g<n;++g)if(_=d*g,!(_<c)){if(_>u)break;x.push(_)}}else for(;f<p;++f)for(g=n-1,d=o(f);g>=1;--g)if(_=d*g,!(_<c)){if(_>u)break;x.push(_)}}else x=ab(f,p,Math.min(p-f,y)).map(o);return h?x.reverse():x},t.tickFormat=function(s,l){if(l==null&&(l=n===10?".0e":","),typeof l!="function"&&(l=xn(l)),s===1/0)return l;s==null&&(s=10);var c=Math.max(1,n*s/t.ticks().length);return function(u){var h=u/o(Math.round(i(u)));return h*n<n-.5&&(h*=n),h<=c?l(u):""}},t.nice=function(){return r(h8(r(),{floor:function(s){return o(Math.floor(i(s)))},ceil:function(s){return o(Math.ceil(i(s)))}}))},t}function cc(){var e=_5($_()).domain([1,10]);return e.copy=function(){return qh(e,cc()).base(e.base())},hi.apply(e,arguments),e}function q2t(e){return function(t){return Math.sign(t)*Math.log1p(Math.abs(t/e))}}function G2t(e){return function(t){return Math.sign(t)*Math.expm1(Math.abs(t))*e}}function y5(e){var t=1,r=e(q2t(t),G2t(t));return r.constant=function(n){return arguments.length?e(q2t(t=+n),G2t(t)):t},il(r)}function f8(){var e=y5($_());return e.copy=function(){return qh(e,f8()).constant(e.constant())},hi.apply(e,arguments)}function W2t(e){return function(t){return t<0?-Math.pow(-t,e):Math.pow(t,e)}}function SMe(e){return e<0?-Math.sqrt(-e):Math.sqrt(e)}function MMe(e){return e<0?-e*e:e*e}function v5(e){var t=e(ni,ni),r=1;function n(){return r===1?e(ni,ni):r===.5?e(SMe,MMe):e(W2t(r),W2t(1/r))}return t.exponent=function(i){return arguments.length?(r=+i,n()):r},il(t)}function K_(){var e=v5($_());return e.copy=function(){return qh(e,K_()).exponent(e.exponent())},hi.apply(e,arguments),e}function Y2t(){return K_.apply(null,arguments).exponent(.5)}function eg(){var e=[],t=[],r=[],n;function i(){var a=0,s=Math.max(1,t.length);for(r=new Array(s-1);++a<s;)r[a-1]=sa(e,a/s);return o}function o(a){return isNaN(a=+a)?n:t[ys(r,a)]}return o.invertExtent=function(a){var s=t.indexOf(a);return s<0?[NaN,NaN]:[s>0?r[s-1]:e[0],s<r.length?r[s]:e[e.length-1]]},o.domain=function(a){if(!arguments.length)return e.slice();e=[];for(var s=0,l=a.length,c;s<l;++s)c=a[s],c!=null&&!isNaN(c=+c)&&e.push(c);return e.sort(oa),i()},o.range=function(a){return arguments.length?(t=lc.call(a),i()):t.slice()},o.unknown=function(a){return arguments.length?(n=a,o):n},o.quantiles=function(){return r.slice()},o.copy=function(){return eg().domain(e).range(t).unknown(n)},hi.apply(o,arguments)}function qb(){var e=0,t=1,r=1,n=[.5],i=[0,1],o;function a(l){return l<=l?i[ys(n,l,0,r)]:o}function s(){var l=-1;for(n=new Array(r);++l<r;)n[l]=((l+1)*t-(l-r)*e)/(r+1);return a}return a.domain=function(l){return arguments.length?(e=+l[0],t=+l[1],s()):[e,t]},a.range=function(l){return arguments.length?(r=(i=lc.call(l)).length-1,s()):i.slice()},a.invertExtent=function(l){var c=i.indexOf(l);return c<0?[NaN,NaN]:c<1?[e,n[0]]:c>=r?[n[r-1],t]:[n[c-1],n[c]]},a.unknown=function(l){return arguments.length&&(o=l),a},a.thresholds=function(){return n.slice()},a.copy=function(){return qb().domain([e,t]).range(i).unknown(o)},hi.apply(il(a),arguments)}function p8(){var e=[.5],t=[0,1],r,n=1;function i(o){return o<=o?t[ys(e,o,0,n)]:r}return i.domain=function(o){return arguments.length?(e=lc.call(o),n=Math.min(e.length,t.length-1),i):e.slice()},i.range=function(o){return arguments.length?(t=lc.call(o),n=Math.min(e.length,t.length-1),i):t.slice()},i.invertExtent=function(o){var a=t.indexOf(o);return[e[a-1],e[a]]},i.unknown=function(o){return arguments.length?(r=o,i):r},i.copy=function(){return p8().domain(e).range(t).unknown(r)},hi.apply(i,arguments)}var iX=new Date,oX=new Date;function br(e,t,r,n){function i(o){return e(o=arguments.length===0?new Date:new Date(+o)),o}return i.floor=function(o){return e(o=new Date(+o)),o},i.ceil=function(o){return e(o=new Date(o-1)),t(o,1),e(o),o},i.round=function(o){var a=i(o),s=i.ceil(o);return o-a<s-o?a:s},i.offset=function(o,a){return t(o=new Date(+o),a==null?1:Math.floor(a)),o},i.range=function(o,a,s){var l=[],c;if(o=i.ceil(o),s=s==null?1:Math.floor(s),!(o<a)||!(s>0))return l;do l.push(c=new Date(+o)),t(o,s),e(o);while(c<o&&o<a);return l},i.filter=function(o){return br(function(a){if(a>=a)for(;e(a),!o(a);)a.setTime(a-1)},function(a,s){if(a>=a)if(s<0)for(;++s<=0;)for(;t(a,-1),!o(a););else for(;--s>=0;)for(;t(a,1),!o(a););})},r&&(i.count=function(o,a){return iX.setTime(+o),oX.setTime(+a),e(iX),e(oX),Math.floor(r(iX,oX))},i.every=function(o){return o=Math.floor(o),!isFinite(o)||!(o>0)?null:o>1?i.filter(n?function(a){return n(a)%o===0}:function(a){return i.count(0,a)%o===0}):i}),i}var d8=br(function(){},function(e,t){e.setTime(+e+t)},function(e,t){return t-e});d8.every=function(e){return e=Math.floor(e),!isFinite(e)||!(e>0)?null:e>1?br(function(t){t.setTime(Math.floor(t/e)*e)},function(t,r){t.setTime(+t+r*e)},function(t,r){return(r-t)/e}):d8};var Z_=d8,aX=d8.range;var J_=1e3,uc=6e4,Gb=36e5,m8=864e5,g8=6048e5;var j2t=br(function(e){e.setTime(e-e.getMilliseconds())},function(e,t){e.setTime(+e+t*J_)},function(e,t){return(t-e)/J_},function(e){return e.getUTCSeconds()}),Q_=j2t,sX=j2t.range;var X2t=br(function(e){e.setTime(e-e.getMilliseconds()-e.getSeconds()*J_)},function(e,t){e.setTime(+e+t*uc)},function(e,t){return(t-e)/uc},function(e){return e.getMinutes()}),_8=X2t,$2t=X2t.range;var K2t=br(function(e){e.setTime(e-e.getMilliseconds()-e.getSeconds()*J_-e.getMinutes()*uc)},function(e,t){e.setTime(+e+t*Gb)},function(e,t){return(t-e)/Gb},function(e){return e.getHours()}),y8=K2t,Z2t=K2t.range;var J2t=br(function(e){e.setHours(0,0,0,0)},function(e,t){e.setDate(e.getDate()+t)},function(e,t){return(t-e-(t.getTimezoneOffset()-e.getTimezoneOffset())*uc)/m8},function(e){return e.getDate()-1}),ty=J2t,Q2t=J2t.range;function ey(e){return br(function(t){t.setDate(t.getDate()-(t.getDay()+7-e)%7),t.setHours(0,0,0,0)},function(t,r){t.setDate(t.getDate()+r*7)},function(t,r){return(r-t-(r.getTimezoneOffset()-t.getTimezoneOffset())*uc)/g8})}var rg=ey(0),ry=ey(1),lX=ey(2),cX=ey(3),zp=ey(4),uX=ey(5),hX=ey(6),fX=rg.range,twt=ry.range,ewt=lX.range,rwt=cX.range,nwt=zp.range,iwt=uX.range,owt=hX.range;var awt=br(function(e){e.setDate(1),e.setHours(0,0,0,0)},function(e,t){e.setMonth(e.getMonth()+t)},function(e,t){return t.getMonth()-e.getMonth()+(t.getFullYear()-e.getFullYear())*12},function(e){return e.getMonth()}),v8=awt,swt=awt.range;var pX=br(function(e){e.setMonth(0,1),e.setHours(0,0,0,0)},function(e,t){e.setFullYear(e.getFullYear()+t)},function(e,t){return t.getFullYear()-e.getFullYear()},function(e){return e.getFullYear()});pX.every=function(e){return!isFinite(e=Math.floor(e))||!(e>0)?null:br(function(t){t.setFullYear(Math.floor(t.getFullYear()/e)*e),t.setMonth(0,1),t.setHours(0,0,0,0)},function(t,r){t.setFullYear(t.getFullYear()+r*e)})};var Gh=pX,lwt=pX.range;var cwt=br(function(e){e.setUTCSeconds(0,0)},function(e,t){e.setTime(+e+t*uc)},function(e,t){return(t-e)/uc},function(e){return e.getUTCMinutes()}),x8=cwt,uwt=cwt.range;var hwt=br(function(e){e.setUTCMinutes(0,0,0)},function(e,t){e.setTime(+e+t*Gb)},function(e,t){return(t-e)/Gb},function(e){return e.getUTCHours()}),b8=hwt,fwt=hwt.range;var pwt=br(function(e){e.setUTCHours(0,0,0,0)},function(e,t){e.setUTCDate(e.getUTCDate()+t)},function(e,t){return(t-e)/m8},function(e){return e.getUTCDate()-1}),ny=pwt,dwt=pwt.range;function iy(e){return br(function(t){t.setUTCDate(t.getUTCDate()-(t.getUTCDay()+7-e)%7),t.setUTCHours(0,0,0,0)},function(t,r){t.setUTCDate(t.getUTCDate()+r*7)},function(t,r){return(r-t)/g8})}var ng=iy(0),oy=iy(1),dX=iy(2),mX=iy(3),Fp=iy(4),gX=iy(5),_X=iy(6),yX=ng.range,mwt=oy.range,gwt=dX.range,_wt=mX.range,ywt=Fp.range,vwt=gX.range,xwt=_X.range;var bwt=br(function(e){e.setUTCDate(1),e.setUTCHours(0,0,0,0)},function(e,t){e.setUTCMonth(e.getUTCMonth()+t)},function(e,t){return t.getUTCMonth()-e.getUTCMonth()+(t.getUTCFullYear()-e.getUTCFullYear())*12},function(e){return e.getUTCMonth()}),w8=bwt,wwt=bwt.range;var vX=br(function(e){e.setUTCMonth(0,1),e.setUTCHours(0,0,0,0)},function(e,t){e.setUTCFullYear(e.getUTCFullYear()+t)},function(e,t){return t.getUTCFullYear()-e.getUTCFullYear()},function(e){return e.getUTCFullYear()});vX.every=function(e){return!isFinite(e=Math.floor(e))||!(e>0)?null:br(function(t){t.setUTCFullYear(Math.floor(t.getUTCFullYear()/e)*e),t.setUTCMonth(0,1),t.setUTCHours(0,0,0,0)},function(t,r){t.setUTCFullYear(t.getUTCFullYear()+r*e)})};var Wh=vX,Swt=vX.range;function xX(e){if(0<=e.y&&e.y<100){var t=new Date(-1,e.m,e.d,e.H,e.M,e.S,e.L);return t.setFullYear(e.y),t}return new Date(e.y,e.m,e.d,e.H,e.M,e.S,e.L)}function bX(e){if(0<=e.y&&e.y<100){var t=new Date(Date.UTC(-1,e.m,e.d,e.H,e.M,e.S,e.L));return t.setUTCFullYear(e.y),t}return new Date(Date.UTC(e.y,e.m,e.d,e.H,e.M,e.S,e.L))}function x5(e,t,r){return{y:e,m:t,d:r,H:0,M:0,S:0,L:0}}function S5(e){var t=e.dateTime,r=e.date,n=e.time,i=e.periods,o=e.days,a=e.shortDays,s=e.months,l=e.shortMonths,c=b5(i),u=w5(i),h=b5(o),f=w5(o),p=b5(a),d=w5(a),g=b5(s),_=w5(s),y=b5(l),x=w5(l),b={a:W,A:Z,b:rt,B:ot,c:null,d:Pwt,e:Pwt,f:jMe,g:nEe,G:oEe,H:GMe,I:WMe,j:YMe,L:Nwt,m:XMe,M:$Me,p:st,q:St,Q:kwt,s:Rwt,S:KMe,u:ZMe,U:JMe,V:QMe,w:tEe,W:eEe,x:null,X:null,y:rEe,Y:iEe,Z:aEe,"%":Lwt},S={a:bt,A:Mt,b:lt,B:Kt,c:null,d:Iwt,e:Iwt,f:uEe,g:xEe,G:wEe,H:sEe,I:lEe,j:cEe,L:Owt,m:hEe,M:fEe,p:_t,q:ct,Q:kwt,s:Rwt,S:pEe,u:dEe,U:mEe,V:gEe,w:_Ee,W:yEe,x:null,X:null,y:vEe,Y:bEe,Z:SEe,"%":Lwt},C={a:B,A:I,b:L,B:R,c:F,d:Cwt,e:Cwt,f:HMe,g:Twt,G:Ewt,H:Awt,I:Awt,j:OMe,L:BMe,m:DMe,M:zMe,p:D,q:NMe,Q:UMe,s:qMe,S:FMe,u:PMe,U:IMe,V:LMe,w:AMe,W:kMe,x:z,X:U,y:Twt,Y:Ewt,Z:RMe,"%":VMe};b.x=P(r,b),b.X=P(n,b),b.c=P(t,b),S.x=P(r,S),S.X=P(n,S),S.c=P(t,S);function P(X,et){return function(dt){var q=[],pt=-1,ht=0,wt=X.length,kt,ie,ee;for(dt instanceof Date||(dt=new Date(+dt));++pt<wt;)X.charCodeAt(pt)===37&&(q.push(X.slice(ht,pt)),(ie=Mwt[kt=X.charAt(++pt)])!=null?kt=X.charAt(++pt):ie=kt==="e"?" ":"0",(ee=et[kt])&&(kt=ee(dt,ie)),q.push(kt),ht=pt+1);return q.push(X.slice(ht,pt)),q.join("")}}function k(X,et){return function(dt){var q=x5(1900,void 0,1),pt=O(q,X,dt+="",0),ht,wt;if(pt!=dt.length)return null;if("Q"in q)return new Date(q.Q);if("s"in q)return new Date(q.s*1e3+("L"in q?q.L:0));if(et&&!("Z"in q)&&(q.Z=0),"p"in q&&(q.H=q.H%12+q.p*12),q.m===void 0&&(q.m="q"in q?q.q:0),"V"in q){if(q.V<1||q.V>53)return null;"w"in q||(q.w=1),"Z"in q?(ht=bX(x5(q.y,0,1)),wt=ht.getUTCDay(),ht=wt>4||wt===0?oy.ceil(ht):oy(ht),ht=ny.offset(ht,(q.V-1)*7),q.y=ht.getUTCFullYear(),q.m=ht.getUTCMonth(),q.d=ht.getUTCDate()+(q.w+6)%7):(ht=xX(x5(q.y,0,1)),wt=ht.getDay(),ht=wt>4||wt===0?ry.ceil(ht):ry(ht),ht=ty.offset(ht,(q.V-1)*7),q.y=ht.getFullYear(),q.m=ht.getMonth(),q.d=ht.getDate()+(q.w+6)%7)}else("W"in q||"U"in q)&&("w"in q||(q.w="u"in q?q.u%7:"W"in q?1:0),wt="Z"in q?bX(x5(q.y,0,1)).getUTCDay():xX(x5(q.y,0,1)).getDay(),q.m=0,q.d="W"in q?(q.w+6)%7+q.W*7-(wt+5)%7:q.w+q.U*7-(wt+6)%7);return"Z"in q?(q.H+=q.Z/100|0,q.M+=q.Z%100,bX(q)):xX(q)}}function O(X,et,dt,q){for(var pt=0,ht=et.length,wt=dt.length,kt,ie;pt<ht;){if(q>=wt)return-1;if(kt=et.charCodeAt(pt++),kt===37){if(kt=et.charAt(pt++),ie=C[kt in Mwt?et.charAt(pt++):kt],!ie||(q=ie(X,dt,q))<0)return-1}else if(kt!=dt.charCodeAt(q++))return-1}return q}function D(X,et,dt){var q=c.exec(et.slice(dt));return q?(X.p=u[q[0].toLowerCase()],dt+q[0].length):-1}function B(X,et,dt){var q=p.exec(et.slice(dt));return q?(X.w=d[q[0].toLowerCase()],dt+q[0].length):-1}function I(X,et,dt){var q=h.exec(et.slice(dt));return q?(X.w=f[q[0].toLowerCase()],dt+q[0].length):-1}function L(X,et,dt){var q=y.exec(et.slice(dt));return q?(X.m=x[q[0].toLowerCase()],dt+q[0].length):-1}function R(X,et,dt){var q=g.exec(et.slice(dt));return q?(X.m=_[q[0].toLowerCase()],dt+q[0].length):-1}function F(X,et,dt){return O(X,t,et,dt)}function z(X,et,dt){return O(X,r,et,dt)}function U(X,et,dt){return O(X,n,et,dt)}function W(X){return a[X.getDay()]}function Z(X){return o[X.getDay()]}function rt(X){return l[X.getMonth()]}function ot(X){return s[X.getMonth()]}function st(X){return i[+(X.getHours()>=12)]}function St(X){return 1+~~(X.getMonth()/3)}function bt(X){return a[X.getUTCDay()]}function Mt(X){return o[X.getUTCDay()]}function lt(X){return l[X.getUTCMonth()]}function Kt(X){return s[X.getUTCMonth()]}function _t(X){return i[+(X.getUTCHours()>=12)]}function ct(X){return 1+~~(X.getUTCMonth()/3)}return{format:function(X){var et=P(X+="",b);return et.toString=function(){return X},et},parse:function(X){var et=k(X+="",!1);return et.toString=function(){return X},et},utcFormat:function(X){var et=P(X+="",S);return et.toString=function(){return X},et},utcParse:function(X){var et=k(X+="",!0);return et.toString=function(){return X},et}}}var Mwt={"-":"",_:" ",0:"0"},xo=/^\s*\d+/,EMe=/^%/,TMe=/[\\^$*+?|[\]().{}]/g;function Br(e,t,r){var n=e<0?"-":"",i=(n?-e:e)+"",o=i.length;return n+(o<r?new Array(r-o+1).join(t)+i:i)}function CMe(e){return e.replace(TMe,"\\$&")}function b5(e){return new RegExp("^(?:"+e.map(CMe).join("|")+")","i")}function w5(e){for(var t={},r=-1,n=e.length;++r<n;)t[e[r].toLowerCase()]=r;return t}function AMe(e,t,r){var n=xo.exec(t.slice(r,r+1));return n?(e.w=+n[0],r+n[0].length):-1}function PMe(e,t,r){var n=xo.exec(t.slice(r,r+1));return n?(e.u=+n[0],r+n[0].length):-1}function IMe(e,t,r){var n=xo.exec(t.slice(r,r+2));return n?(e.U=+n[0],r+n[0].length):-1}function LMe(e,t,r){var n=xo.exec(t.slice(r,r+2));return n?(e.V=+n[0],r+n[0].length):-1}function kMe(e,t,r){var n=xo.exec(t.slice(r,r+2));return n?(e.W=+n[0],r+n[0].length):-1}function Ewt(e,t,r){var n=xo.exec(t.slice(r,r+4));return n?(e.y=+n[0],r+n[0].length):-1}function Twt(e,t,r){var n=xo.exec(t.slice(r,r+2));return n?(e.y=+n[0]+(+n[0]>68?1900:2e3),r+n[0].length):-1}function RMe(e,t,r){var n=/^(Z)|([+-]\d\d)(?::?(\d\d))?/.exec(t.slice(r,r+6));return n?(e.Z=n[1]?0:-(n[2]+(n[3]||"00")),r+n[0].length):-1}function NMe(e,t,r){var n=xo.exec(t.slice(r,r+1));return n?(e.q=n[0]*3-3,r+n[0].length):-1}function DMe(e,t,r){var n=xo.exec(t.slice(r,r+2));return n?(e.m=n[0]-1,r+n[0].length):-1}function Cwt(e,t,r){var n=xo.exec(t.slice(r,r+2));return n?(e.d=+n[0],r+n[0].length):-1}function OMe(e,t,r){var n=xo.exec(t.slice(r,r+3));return n?(e.m=0,e.d=+n[0],r+n[0].length):-1}function Awt(e,t,r){var n=xo.exec(t.slice(r,r+2));return n?(e.H=+n[0],r+n[0].length):-1}function zMe(e,t,r){var n=xo.exec(t.slice(r,r+2));return n?(e.M=+n[0],r+n[0].length):-1}function FMe(e,t,r){var n=xo.exec(t.slice(r,r+2));return n?(e.S=+n[0],r+n[0].length):-1}function BMe(e,t,r){var n=xo.exec(t.slice(r,r+3));return n?(e.L=+n[0],r+n[0].length):-1}function HMe(e,t,r){var n=xo.exec(t.slice(r,r+6));return n?(e.L=Math.floor(n[0]/1e3),r+n[0].length):-1}function VMe(e,t,r){var n=EMe.exec(t.slice(r,r+1));return n?r+n[0].length:-1}function UMe(e,t,r){var n=xo.exec(t.slice(r));return n?(e.Q=+n[0],r+n[0].length):-1}function qMe(e,t,r){var n=xo.exec(t.slice(r));return n?(e.s=+n[0],r+n[0].length):-1}function Pwt(e,t){return Br(e.getDate(),t,2)}function GMe(e,t){return Br(e.getHours(),t,2)}function WMe(e,t){return Br(e.getHours()%12||12,t,2)}function YMe(e,t){return Br(1+ty.count(Gh(e),e),t,3)}function Nwt(e,t){return Br(e.getMilliseconds(),t,3)}function jMe(e,t){return Nwt(e,t)+"000"}function XMe(e,t){return Br(e.getMonth()+1,t,2)}function $Me(e,t){return Br(e.getMinutes(),t,2)}function KMe(e,t){return Br(e.getSeconds(),t,2)}function ZMe(e){var t=e.getDay();return t===0?7:t}function JMe(e,t){return Br(rg.count(Gh(e)-1,e),t,2)}function Dwt(e){var t=e.getDay();return t>=4||t===0?zp(e):zp.ceil(e)}function QMe(e,t){return e=Dwt(e),Br(zp.count(Gh(e),e)+(Gh(e).getDay()===4),t,2)}function tEe(e){return e.getDay()}function eEe(e,t){return Br(ry.count(Gh(e)-1,e),t,2)}function rEe(e,t){return Br(e.getFullYear()%100,t,2)}function nEe(e,t){return e=Dwt(e),Br(e.getFullYear()%100,t,2)}function iEe(e,t){return Br(e.getFullYear()%1e4,t,4)}function oEe(e,t){var r=e.getDay();return e=r>=4||r===0?zp(e):zp.ceil(e),Br(e.getFullYear()%1e4,t,4)}function aEe(e){var t=e.getTimezoneOffset();return(t>0?"-":(t*=-1,"+"))+Br(t/60|0,"0",2)+Br(t%60,"0",2)}function Iwt(e,t){return Br(e.getUTCDate(),t,2)}function sEe(e,t){return Br(e.getUTCHours(),t,2)}function lEe(e,t){return Br(e.getUTCHours()%12||12,t,2)}function cEe(e,t){return Br(1+ny.count(Wh(e),e),t,3)}function Owt(e,t){return Br(e.getUTCMilliseconds(),t,3)}function uEe(e,t){return Owt(e,t)+"000"}function hEe(e,t){return Br(e.getUTCMonth()+1,t,2)}function fEe(e,t){return Br(e.getUTCMinutes(),t,2)}function pEe(e,t){return Br(e.getUTCSeconds(),t,2)}function dEe(e){var t=e.getUTCDay();return t===0?7:t}function mEe(e,t){return Br(ng.count(Wh(e)-1,e),t,2)}function zwt(e){var t=e.getUTCDay();return t>=4||t===0?Fp(e):Fp.ceil(e)}function gEe(e,t){return e=zwt(e),Br(Fp.count(Wh(e),e)+(Wh(e).getUTCDay()===4),t,2)}function _Ee(e){return e.getUTCDay()}function yEe(e,t){return Br(oy.count(Wh(e)-1,e),t,2)}function vEe(e,t){return Br(e.getUTCFullYear()%100,t,2)}function xEe(e,t){return e=zwt(e),Br(e.getUTCFullYear()%100,t,2)}function bEe(e,t){return Br(e.getUTCFullYear()%1e4,t,4)}function wEe(e,t){var r=e.getUTCDay();return e=r>=4||r===0?Fp(e):Fp.ceil(e),Br(e.getUTCFullYear()%1e4,t,4)}function SEe(){return"+0000"}function Lwt(){return"%"}function kwt(e){return+e}function Rwt(e){return Math.floor(+e/1e3)}var Wb,M5,wX,ay,E5;S8({dateTime:"%x, %X",date:"%-m/%-d/%Y",time:"%-I:%M:%S %p",periods:["AM","PM"],days:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],shortDays:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],months:["January","February","March","April","May","June","July","August","September","October","November","December"],shortMonths:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]});function S8(e){return Wb=S5(e),M5=Wb.format,wX=Wb.parse,ay=Wb.utcFormat,E5=Wb.utcParse,Wb}var SX="%Y-%m-%dT%H:%M:%S.%LZ";function MEe(e){return e.toISOString()}var EEe=Date.prototype.toISOString?MEe:ay(SX),Fwt=EEe;function TEe(e){var t=new Date(e);return isNaN(t)?null:t}var CEe=+new Date("2000-01-01T00:00:00.000Z")?TEe:E5(SX),Bwt=CEe;var T5=1e3,C5=T5*60,A5=C5*60,P5=A5*24,AEe=P5*7,Hwt=P5*30,MX=P5*365;function PEe(e){return new Date(e)}function IEe(e){return e instanceof Date?+e:+new Date(+e)}function M8(e,t,r,n,i,o,a,s,l){var c=g5(ni,ni),u=c.invert,h=c.domain,f=l(".%L"),p=l(":%S"),d=l("%I:%M"),g=l("%I %p"),_=l("%a %d"),y=l("%b %d"),x=l("%B"),b=l("%Y"),S=[[a,1,T5],[a,5,5*T5],[a,15,15*T5],[a,30,30*T5],[o,1,C5],[o,5,5*C5],[o,15,15*C5],[o,30,30*C5],[i,1,A5],[i,3,3*A5],[i,6,6*A5],[i,12,12*A5],[n,1,P5],[n,2,2*P5],[r,1,AEe],[t,1,Hwt],[t,3,3*Hwt],[e,1,MX]];function C(k){return(a(k)<k?f:o(k)<k?p:i(k)<k?d:n(k)<k?g:t(k)<k?r(k)<k?_:y:e(k)<k?x:b)(k)}function P(k,O,D,B){if(k==null&&(k=10),typeof k=="number"){var I=Math.abs(D-O)/k,L=ob(function(R){return R[2]}).right(S,I);L===S.length?(B=tl(O/MX,D/MX,k),k=e):L?(L=S[I/S[L-1][2]<S[L][2]/I?L-1:L],B=L[1],k=L[0]):(B=Math.max(tl(O,D,k),1),k=s)}return B==null?k:k.every(B)}return c.invert=function(k){return new Date(u(k))},c.domain=function(k){return arguments.length?h(X_.call(k,IEe)):h().map(PEe)},c.ticks=function(k,O){var D=h(),B=D[0],I=D[D.length-1],L=I<B,R;return L&&(R=B,B=I,I=R),R=P(k,B,I,O),R=R?R.range(B,I+1):[],L?R.reverse():R},c.tickFormat=function(k,O){return O==null?C:l(O)},c.nice=function(k,O){var D=h();return(k=P(k,D[0],D[D.length-1],O))?h(h8(D,k)):c},c.copy=function(){return qh(c,M8(e,t,r,n,i,o,a,s,l))},c}function Yb(){return hi.apply(M8(Gh,v8,rg,ty,y8,_8,Q_,Z_,M5).domain([new Date(2e3,0,1),new Date(2e3,0,2)]),arguments)}function Vwt(){return hi.apply(M8(Wh,w8,ng,ny,b8,x8,Q_,Z_,ay).domain([Date.UTC(2e3,0,1),Date.UTC(2e3,0,2)]),arguments)}function E8(){var e=0,t=1,r,n,i,o,a=ni,s=!1,l;function c(u){return isNaN(u=+u)?l:a(i===0?.5:(u=(o(u)-r)*i,s?Math.max(0,Math.min(1,u)):u))}return c.domain=function(u){return arguments.length?(r=o(e=+u[0]),n=o(t=+u[1]),i=r===n?0:1/(n-r),c):[e,t]},c.clamp=function(u){return arguments.length?(s=!!u,c):s},c.interpolator=function(u){return arguments.length?(a=u,c):a},c.unknown=function(u){return arguments.length?(l=u,c):l},function(u){return o=u,r=u(e),n=u(t),i=r===n?0:1/(n-r),c}}function Bp(e,t){return t.domain(e.domain()).interpolator(e.interpolator()).clamp(e.clamp()).unknown(e.unknown())}function T8(){var e=il(E8()(ni));return e.copy=function(){return Bp(e,T8())},sc.apply(e,arguments)}function EX(){var e=_5(E8()).domain([1,10]);return e.copy=function(){return Bp(e,EX()).base(e.base())},sc.apply(e,arguments)}function TX(){var e=y5(E8());return e.copy=function(){return Bp(e,TX()).constant(e.constant())},sc.apply(e,arguments)}function C8(){var e=v5(E8());return e.copy=function(){return Bp(e,C8()).exponent(e.exponent())},sc.apply(e,arguments)}function Uwt(){return C8.apply(null,arguments).exponent(.5)}function A8(){var e=[],t=ni;function r(n){if(!isNaN(n=+n))return t((ys(e,n)-1)/(e.length-1))}return r.domain=function(n){if(!arguments.length)return e.slice();e=[];for(var i=0,o=n.length,a;i<o;++i)a=n[i],a!=null&&!isNaN(a=+a)&&e.push(a);return e.sort(oa),r},r.interpolator=function(n){return arguments.length?(t=n,r):t},r.copy=function(){return A8(t).domain(e)},sc.apply(r,arguments)}function P8(){var e=0,t=.5,r=1,n,i,o,a,s,l=ni,c,u=!1,h;function f(p){return isNaN(p=+p)?h:(p=.5+((p=+c(p))-i)*(p<i?a:s),l(u?Math.max(0,Math.min(1,p)):p))}return f.domain=function(p){return arguments.length?(n=c(e=+p[0]),i=c(t=+p[1]),o=c(r=+p[2]),a=n===i?0:.5/(i-n),s=i===o?0:.5/(o-i),f):[e,t,r]},f.clamp=function(p){return arguments.length?(u=!!p,f):u},f.interpolator=function(p){return arguments.length?(l=p,f):l},f.unknown=function(p){return arguments.length?(h=p,f):h},function(p){return c=p,n=p(e),i=p(t),o=p(r),a=n===i?0:.5/(i-n),s=i===o?0:.5/(o-i),f}}function I8(){var e=il(P8()(ni));return e.copy=function(){return Bp(e,I8())},sc.apply(e,arguments)}function CX(){var e=_5(P8()).domain([.1,1,10]);return e.copy=function(){return Bp(e,CX()).base(e.base())},sc.apply(e,arguments)}function AX(){var e=y5(P8());return e.copy=function(){return Bp(e,AX()).constant(e.constant())},sc.apply(e,arguments)}function L8(){var e=v5(P8());return e.copy=function(){return Bp(e,L8()).exponent(e.exponent())},sc.apply(e,arguments)}function qwt(){return L8.apply(null,arguments).exponent(.5)}function te(e){for(var t=e.length/6|0,r=new Array(t),n=0;n<t;)r[n]="#"+e.slice(n*6,++n*6);return r}var jb=te("1f77b4ff7f0e2ca02cd627289467bd8c564be377c27f7f7fbcbd2217becf");var Gwt=te("7fc97fbeaed4fdc086ffff99386cb0f0027fbf5b17666666");var Wwt=te("1b9e77d95f027570b3e7298a66a61ee6ab02a6761d666666");var Ywt=te("a6cee31f78b4b2df8a33a02cfb9a99e31a1cfdbf6fff7f00cab2d66a3d9affff99b15928");var jwt=te("fbb4aeb3cde3ccebc5decbe4fed9a6ffffcce5d8bdfddaecf2f2f2");var Xwt=te("b3e2cdfdcdaccbd5e8f4cae4e6f5c9fff2aef1e2cccccccc");var $wt=te("e41a1c377eb84daf4a984ea3ff7f00ffff33a65628f781bf999999");var Kwt=te("66c2a5fc8d628da0cbe78ac3a6d854ffd92fe5c494b3b3b3");var Zwt=te("8dd3c7ffffb3bebadafb807280b1d3fdb462b3de69fccde5d9d9d9bc80bdccebc5ffed6f");var Jwt=te("4e79a7f28e2ce1575976b7b259a14fedc949af7aa1ff9da79c755fbab0ab");function Ie(e){return uL(e[e.length-1])}var PX=new Array(3).concat("d8b365f5f5f55ab4ac","a6611adfc27d80cdc1018571","a6611adfc27df5f5f580cdc1018571","8c510ad8b365f6e8c3c7eae55ab4ac01665e","8c510ad8b365f6e8c3f5f5f5c7eae55ab4ac01665e","8c510abf812ddfc27df6e8c3c7eae580cdc135978f01665e","8c510abf812ddfc27df6e8c3f5f5f5c7eae580cdc135978f01665e","5430058c510abf812ddfc27df6e8c3c7eae580cdc135978f01665e003c30","5430058c510abf812ddfc27df6e8c3f5f5f5c7eae580cdc135978f01665e003c30").map(te),Qwt=Ie(PX);var IX=new Array(3).concat("af8dc3f7f7f77fbf7b","7b3294c2a5cfa6dba0008837","7b3294c2a5cff7f7f7a6dba0008837","762a83af8dc3e7d4e8d9f0d37fbf7b1b7837","762a83af8dc3e7d4e8f7f7f7d9f0d37fbf7b1b7837","762a839970abc2a5cfe7d4e8d9f0d3a6dba05aae611b7837","762a839970abc2a5cfe7d4e8f7f7f7d9f0d3a6dba05aae611b7837","40004b762a839970abc2a5cfe7d4e8d9f0d3a6dba05aae611b783700441b","40004b762a839970abc2a5cfe7d4e8f7f7f7d9f0d3a6dba05aae611b783700441b").map(te),tSt=Ie(IX);var LX=new Array(3).concat("e9a3c9f7f7f7a1d76a","d01c8bf1b6dab8e1864dac26","d01c8bf1b6daf7f7f7b8e1864dac26","c51b7de9a3c9fde0efe6f5d0a1d76a4d9221","c51b7de9a3c9fde0eff7f7f7e6f5d0a1d76a4d9221","c51b7dde77aef1b6dafde0efe6f5d0b8e1867fbc414d9221","c51b7dde77aef1b6dafde0eff7f7f7e6f5d0b8e1867fbc414d9221","8e0152c51b7dde77aef1b6dafde0efe6f5d0b8e1867fbc414d9221276419","8e0152c51b7dde77aef1b6dafde0eff7f7f7e6f5d0b8e1867fbc414d9221276419").map(te),eSt=Ie(LX);var kX=new Array(3).concat("998ec3f7f7f7f1a340","5e3c99b2abd2fdb863e66101","5e3c99b2abd2f7f7f7fdb863e66101","542788998ec3d8daebfee0b6f1a340b35806","542788998ec3d8daebf7f7f7fee0b6f1a340b35806","5427888073acb2abd2d8daebfee0b6fdb863e08214b35806","5427888073acb2abd2d8daebf7f7f7fee0b6fdb863e08214b35806","2d004b5427888073acb2abd2d8daebfee0b6fdb863e08214b358067f3b08","2d004b5427888073acb2abd2d8daebf7f7f7fee0b6fdb863e08214b358067f3b08").map(te),rSt=Ie(kX);var RX=new Array(3).concat("ef8a62f7f7f767a9cf","ca0020f4a58292c5de0571b0","ca0020f4a582f7f7f792c5de0571b0","b2182bef8a62fddbc7d1e5f067a9cf2166ac","b2182bef8a62fddbc7f7f7f7d1e5f067a9cf2166ac","b2182bd6604df4a582fddbc7d1e5f092c5de4393c32166ac","b2182bd6604df4a582fddbc7f7f7f7d1e5f092c5de4393c32166ac","67001fb2182bd6604df4a582fddbc7d1e5f092c5de4393c32166ac053061","67001fb2182bd6604df4a582fddbc7f7f7f7d1e5f092c5de4393c32166ac053061").map(te),nSt=Ie(RX);var NX=new Array(3).concat("ef8a62ffffff999999","ca0020f4a582bababa404040","ca0020f4a582ffffffbababa404040","b2182bef8a62fddbc7e0e0e09999994d4d4d","b2182bef8a62fddbc7ffffffe0e0e09999994d4d4d","b2182bd6604df4a582fddbc7e0e0e0bababa8787874d4d4d","b2182bd6604df4a582fddbc7ffffffe0e0e0bababa8787874d4d4d","67001fb2182bd6604df4a582fddbc7e0e0e0bababa8787874d4d4d1a1a1a","67001fb2182bd6604df4a582fddbc7ffffffe0e0e0bababa8787874d4d4d1a1a1a").map(te),iSt=Ie(NX);var DX=new Array(3).concat("fc8d59ffffbf91bfdb","d7191cfdae61abd9e92c7bb6","d7191cfdae61ffffbfabd9e92c7bb6","d73027fc8d59fee090e0f3f891bfdb4575b4","d73027fc8d59fee090ffffbfe0f3f891bfdb4575b4","d73027f46d43fdae61fee090e0f3f8abd9e974add14575b4","d73027f46d43fdae61fee090ffffbfe0f3f8abd9e974add14575b4","a50026d73027f46d43fdae61fee090e0f3f8abd9e974add14575b4313695","a50026d73027f46d43fdae61fee090ffffbfe0f3f8abd9e974add14575b4313695").map(te),oSt=Ie(DX);var OX=new Array(3).concat("fc8d59ffffbf91cf60","d7191cfdae61a6d96a1a9641","d7191cfdae61ffffbfa6d96a1a9641","d73027fc8d59fee08bd9ef8b91cf601a9850","d73027fc8d59fee08bffffbfd9ef8b91cf601a9850","d73027f46d43fdae61fee08bd9ef8ba6d96a66bd631a9850","d73027f46d43fdae61fee08bffffbfd9ef8ba6d96a66bd631a9850","a50026d73027f46d43fdae61fee08bd9ef8ba6d96a66bd631a9850006837","a50026d73027f46d43fdae61fee08bffffbfd9ef8ba6d96a66bd631a9850006837").map(te),aSt=Ie(OX);var zX=new Array(3).concat("fc8d59ffffbf99d594","d7191cfdae61abdda42b83ba","d7191cfdae61ffffbfabdda42b83ba","d53e4ffc8d59fee08be6f59899d5943288bd","d53e4ffc8d59fee08bffffbfe6f59899d5943288bd","d53e4ff46d43fdae61fee08be6f598abdda466c2a53288bd","d53e4ff46d43fdae61fee08bffffbfe6f598abdda466c2a53288bd","9e0142d53e4ff46d43fdae61fee08be6f598abdda466c2a53288bd5e4fa2","9e0142d53e4ff46d43fdae61fee08bffffbfe6f598abdda466c2a53288bd5e4fa2").map(te),sSt=Ie(zX);var FX=new Array(3).concat("e5f5f999d8c92ca25f","edf8fbb2e2e266c2a4238b45","edf8fbb2e2e266c2a42ca25f006d2c","edf8fbccece699d8c966c2a42ca25f006d2c","edf8fbccece699d8c966c2a441ae76238b45005824","f7fcfde5f5f9ccece699d8c966c2a441ae76238b45005824","f7fcfde5f5f9ccece699d8c966c2a441ae76238b45006d2c00441b").map(te),lSt=Ie(FX);var BX=new Array(3).concat("e0ecf49ebcda8856a7","edf8fbb3cde38c96c688419d","edf8fbb3cde38c96c68856a7810f7c","edf8fbbfd3e69ebcda8c96c68856a7810f7c","edf8fbbfd3e69ebcda8c96c68c6bb188419d6e016b","f7fcfde0ecf4bfd3e69ebcda8c96c68c6bb188419d6e016b","f7fcfde0ecf4bfd3e69ebcda8c96c68c6bb188419d810f7c4d004b").map(te),cSt=Ie(BX);var HX=new Array(3).concat("e0f3dba8ddb543a2ca","f0f9e8bae4bc7bccc42b8cbe","f0f9e8bae4bc7bccc443a2ca0868ac","f0f9e8ccebc5a8ddb57bccc443a2ca0868ac","f0f9e8ccebc5a8ddb57bccc44eb3d32b8cbe08589e","f7fcf0e0f3dbccebc5a8ddb57bccc44eb3d32b8cbe08589e","f7fcf0e0f3dbccebc5a8ddb57bccc44eb3d32b8cbe0868ac084081").map(te),uSt=Ie(HX);var VX=new Array(3).concat("fee8c8fdbb84e34a33","fef0d9fdcc8afc8d59d7301f","fef0d9fdcc8afc8d59e34a33b30000","fef0d9fdd49efdbb84fc8d59e34a33b30000","fef0d9fdd49efdbb84fc8d59ef6548d7301f990000","fff7ecfee8c8fdd49efdbb84fc8d59ef6548d7301f990000","fff7ecfee8c8fdd49efdbb84fc8d59ef6548d7301fb300007f0000").map(te),hSt=Ie(VX);var UX=new Array(3).concat("ece2f0a6bddb1c9099","f6eff7bdc9e167a9cf02818a","f6eff7bdc9e167a9cf1c9099016c59","f6eff7d0d1e6a6bddb67a9cf1c9099016c59","f6eff7d0d1e6a6bddb67a9cf3690c002818a016450","fff7fbece2f0d0d1e6a6bddb67a9cf3690c002818a016450","fff7fbece2f0d0d1e6a6bddb67a9cf3690c002818a016c59014636").map(te),fSt=Ie(UX);var qX=new Array(3).concat("ece7f2a6bddb2b8cbe","f1eef6bdc9e174a9cf0570b0","f1eef6bdc9e174a9cf2b8cbe045a8d","f1eef6d0d1e6a6bddb74a9cf2b8cbe045a8d","f1eef6d0d1e6a6bddb74a9cf3690c00570b0034e7b","fff7fbece7f2d0d1e6a6bddb74a9cf3690c00570b0034e7b","fff7fbece7f2d0d1e6a6bddb74a9cf3690c00570b0045a8d023858").map(te),pSt=Ie(qX);var GX=new Array(3).concat("e7e1efc994c7dd1c77","f1eef6d7b5d8df65b0ce1256","f1eef6d7b5d8df65b0dd1c77980043","f1eef6d4b9dac994c7df65b0dd1c77980043","f1eef6d4b9dac994c7df65b0e7298ace125691003f","f7f4f9e7e1efd4b9dac994c7df65b0e7298ace125691003f","f7f4f9e7e1efd4b9dac994c7df65b0e7298ace125698004367001f").map(te),dSt=Ie(GX);var WX=new Array(3).concat("fde0ddfa9fb5c51b8a","feebe2fbb4b9f768a1ae017e","feebe2fbb4b9f768a1c51b8a7a0177","feebe2fcc5c0fa9fb5f768a1c51b8a7a0177","feebe2fcc5c0fa9fb5f768a1dd3497ae017e7a0177","fff7f3fde0ddfcc5c0fa9fb5f768a1dd3497ae017e7a0177","fff7f3fde0ddfcc5c0fa9fb5f768a1dd3497ae017e7a017749006a").map(te),mSt=Ie(WX);var YX=new Array(3).concat("edf8b17fcdbb2c7fb8","ffffcca1dab441b6c4225ea8","ffffcca1dab441b6c42c7fb8253494","ffffccc7e9b47fcdbb41b6c42c7fb8253494","ffffccc7e9b47fcdbb41b6c41d91c0225ea80c2c84","ffffd9edf8b1c7e9b47fcdbb41b6c41d91c0225ea80c2c84","ffffd9edf8b1c7e9b47fcdbb41b6c41d91c0225ea8253494081d58").map(te),gSt=Ie(YX);var jX=new Array(3).concat("f7fcb9addd8e31a354","ffffccc2e69978c679238443","ffffccc2e69978c67931a354006837","ffffccd9f0a3addd8e78c67931a354006837","ffffccd9f0a3addd8e78c67941ab5d238443005a32","ffffe5f7fcb9d9f0a3addd8e78c67941ab5d238443005a32","ffffe5f7fcb9d9f0a3addd8e78c67941ab5d238443006837004529").map(te),_St=Ie(jX);var XX=new Array(3).concat("fff7bcfec44fd95f0e","ffffd4fed98efe9929cc4c02","ffffd4fed98efe9929d95f0e993404","ffffd4fee391fec44ffe9929d95f0e993404","ffffd4fee391fec44ffe9929ec7014cc4c028c2d04","ffffe5fff7bcfee391fec44ffe9929ec7014cc4c028c2d04","ffffe5fff7bcfee391fec44ffe9929ec7014cc4c02993404662506").map(te),ySt=Ie(XX);var $X=new Array(3).concat("ffeda0feb24cf03b20","ffffb2fecc5cfd8d3ce31a1c","ffffb2fecc5cfd8d3cf03b20bd0026","ffffb2fed976feb24cfd8d3cf03b20bd0026","ffffb2fed976feb24cfd8d3cfc4e2ae31a1cb10026","ffffccffeda0fed976feb24cfd8d3cfc4e2ae31a1cb10026","ffffccffeda0fed976feb24cfd8d3cfc4e2ae31a1cbd0026800026").map(te),vSt=Ie($X);var KX=new Array(3).concat("deebf79ecae13182bd","eff3ffbdd7e76baed62171b5","eff3ffbdd7e76baed63182bd08519c","eff3ffc6dbef9ecae16baed63182bd08519c","eff3ffc6dbef9ecae16baed64292c62171b5084594","f7fbffdeebf7c6dbef9ecae16baed64292c62171b5084594","f7fbffdeebf7c6dbef9ecae16baed64292c62171b508519c08306b").map(te),xSt=Ie(KX);var ZX=new Array(3).concat("e5f5e0a1d99b31a354","edf8e9bae4b374c476238b45","edf8e9bae4b374c47631a354006d2c","edf8e9c7e9c0a1d99b74c47631a354006d2c","edf8e9c7e9c0a1d99b74c47641ab5d238b45005a32","f7fcf5e5f5e0c7e9c0a1d99b74c47641ab5d238b45005a32","f7fcf5e5f5e0c7e9c0a1d99b74c47641ab5d238b45006d2c00441b").map(te),bSt=Ie(ZX);var JX=new Array(3).concat("f0f0f0bdbdbd636363","f7f7f7cccccc969696525252","f7f7f7cccccc969696636363252525","f7f7f7d9d9d9bdbdbd969696636363252525","f7f7f7d9d9d9bdbdbd969696737373525252252525","fffffff0f0f0d9d9d9bdbdbd969696737373525252252525","fffffff0f0f0d9d9d9bdbdbd969696737373525252252525000000").map(te),wSt=Ie(JX);var QX=new Array(3).concat("efedf5bcbddc756bb1","f2f0f7cbc9e29e9ac86a51a3","f2f0f7cbc9e29e9ac8756bb154278f","f2f0f7dadaebbcbddc9e9ac8756bb154278f","f2f0f7dadaebbcbddc9e9ac8807dba6a51a34a1486","fcfbfdefedf5dadaebbcbddc9e9ac8807dba6a51a34a1486","fcfbfdefedf5dadaebbcbddc9e9ac8807dba6a51a354278f3f007d").map(te),SSt=Ie(QX);var t$=new Array(3).concat("fee0d2fc9272de2d26","fee5d9fcae91fb6a4acb181d","fee5d9fcae91fb6a4ade2d26a50f15","fee5d9fcbba1fc9272fb6a4ade2d26a50f15","fee5d9fcbba1fc9272fb6a4aef3b2ccb181d99000d","fff5f0fee0d2fcbba1fc9272fb6a4aef3b2ccb181d99000d","fff5f0fee0d2fcbba1fc9272fb6a4aef3b2ccb181da50f1567000d").map(te),MSt=Ie(t$);var e$=new Array(3).concat("fee6cefdae6be6550d","feeddefdbe85fd8d3cd94701","feeddefdbe85fd8d3ce6550da63603","feeddefdd0a2fdae6bfd8d3ce6550da63603","feeddefdd0a2fdae6bfd8d3cf16913d948018c2d04","fff5ebfee6cefdd0a2fdae6bfd8d3cf16913d948018c2d04","fff5ebfee6cefdd0a2fdae6bfd8d3cf16913d94801a636037f2704").map(te),ESt=Ie(e$);function TSt(e){return e=Math.max(0,Math.min(1,e)),"rgb("+Math.max(0,Math.min(255,Math.round(-4.54-e*(35.34-e*(2381.73-e*(6402.7-e*(7024.72-e*2710.57)))))))+", "+Math.max(0,Math.min(255,Math.round(32.49+e*(170.73+e*(52.82-e*(131.46-e*(176.58-e*67.37)))))))+", "+Math.max(0,Math.min(255,Math.round(81.24+e*(442.36-e*(2482.43-e*(6167.24-e*(6614.94-e*2475.67)))))))+")"}var CSt=E_(la(300,.5,0),la(-240,.5,1));var ASt=E_(la(-100,.75,.35),la(80,1.5,.8)),PSt=E_(la(260,.75,.35),la(80,1.5,.8)),k8=la();function ISt(e){(e<0||e>1)&&(e-=Math.floor(e));var t=Math.abs(e-.5);return k8.h=360*e-100,k8.s=1.5-1.5*t,k8.l=.8-.9*t,k8+""}var R8=cu(),LEe=Math.PI/3,kEe=Math.PI*2/3;function LSt(e){var t;return e=(.5-e)*Math.PI,R8.r=255*(t=Math.sin(e))*t,R8.g=255*(t=Math.sin(e+LEe))*t,R8.b=255*(t=Math.sin(e+kEe))*t,R8+""}function kSt(e){return e=Math.max(0,Math.min(1,e)),"rgb("+Math.max(0,Math.min(255,Math.round(34.61+e*(1172.33-e*(10793.56-e*(33300.12-e*(38394.49-e*14825.05)))))))+", "+Math.max(0,Math.min(255,Math.round(23.31+e*(557.33+e*(1225.33-e*(3574.96-e*(1073.77+e*707.56)))))))+", "+Math.max(0,Math.min(255,Math.round(27.2+e*(3211.1-e*(15327.97-e*(27814-e*(22569.18-e*6838.66)))))))+")"}function N8(e){var t=e.length;return function(r){return e[Math.max(0,Math.min(t-1,Math.floor(r*t)))]}}var RSt=N8(te("44015444025645045745055946075a46085c460a5d460b5e470d60470e6147106347116447136548146748166848176948186a481a6c481b6d481c6e481d6f481f70482071482173482374482475482576482677482878482979472a7a472c7a472d7b472e7c472f7d46307e46327e46337f463480453581453781453882443983443a83443b84433d84433e85423f854240864241864142874144874045884046883f47883f48893e49893e4a893e4c8a3d4d8a3d4e8a3c4f8a3c508b3b518b3b528b3a538b3a548c39558c39568c38588c38598c375a8c375b8d365c8d365d8d355e8d355f8d34608d34618d33628d33638d32648e32658e31668e31678e31688e30698e306a8e2f6b8e2f6c8e2e6d8e2e6e8e2e6f8e2d708e2d718e2c718e2c728e2c738e2b748e2b758e2a768e2a778e2a788e29798e297a8e297b8e287c8e287d8e277e8e277f8e27808e26818e26828e26828e25838e25848e25858e24868e24878e23888e23898e238a8d228b8d228c8d228d8d218e8d218f8d21908d21918c20928c20928c20938c1f948c1f958b1f968b1f978b1f988b1f998a1f9a8a1e9b8a1e9c891e9d891f9e891f9f881fa0881fa1881fa1871fa28720a38620a48621a58521a68522a78522a88423a98324aa8325ab8225ac8226ad8127ad8128ae8029af7f2ab07f2cb17e2db27d2eb37c2fb47c31b57b32b67a34b67935b77937b87838b9773aba763bbb753dbc743fbc7340bd7242be7144bf7046c06f48c16e4ac16d4cc26c4ec36b50c46a52c56954c56856c66758c7655ac8645cc8635ec96260ca6063cb5f65cb5e67cc5c69cd5b6ccd5a6ece5870cf5773d05675d05477d1537ad1517cd2507fd34e81d34d84d44b86d54989d5488bd6468ed64590d74393d74195d84098d83e9bd93c9dd93ba0da39a2da37a5db36a8db34aadc32addc30b0dd2fb2dd2db5de2bb8de29bade28bddf26c0df25c2df23c5e021c8e020cae11fcde11dd0e11cd2e21bd5e21ad8e219dae319dde318dfe318e2e418e5e419e7e419eae51aece51befe51cf1e51df4e61ef6e620f8e621fbe723fde725")),NSt=N8(te("00000401000501010601010802010902020b02020d03030f03031204041405041606051806051a07061c08071e0907200a08220b09240c09260d0a290e0b2b100b2d110c2f120d31130d34140e36150e38160f3b180f3d19103f1a10421c10441d11471e114920114b21114e22115024125325125527125829115a2a115c2c115f2d11612f116331116533106734106936106b38106c390f6e3b0f703d0f713f0f72400f74420f75440f764510774710784910784a10794c117a4e117b4f127b51127c52137c54137d56147d57157e59157e5a167e5c167f5d177f5f187f601880621980641a80651a80671b80681c816a1c816b1d816d1d816e1e81701f81721f817320817521817621817822817922827b23827c23827e24828025828125818326818426818627818827818928818b29818c29818e2a81902a81912b81932b80942c80962c80982d80992d809b2e7f9c2e7f9e2f7fa02f7fa1307ea3307ea5317ea6317da8327daa337dab337cad347cae347bb0357bb2357bb3367ab5367ab73779b83779ba3878bc3978bd3977bf3a77c03a76c23b75c43c75c53c74c73d73c83e73ca3e72cc3f71cd4071cf4070d0416fd2426fd3436ed5446dd6456cd8456cd9466bdb476adc4869de4968df4a68e04c67e24d66e34e65e44f64e55064e75263e85362e95462ea5661eb5760ec5860ed5a5fee5b5eef5d5ef05f5ef1605df2625df2645cf3655cf4675cf4695cf56b5cf66c5cf66e5cf7705cf7725cf8745cf8765cf9785df9795df97b5dfa7d5efa7f5efa815ffb835ffb8560fb8761fc8961fc8a62fc8c63fc8e64fc9065fd9266fd9467fd9668fd9869fd9a6afd9b6bfe9d6cfe9f6dfea16efea36ffea571fea772fea973feaa74feac76feae77feb078feb27afeb47bfeb67cfeb77efeb97ffebb81febd82febf84fec185fec287fec488fec68afec88cfeca8dfecc8ffecd90fecf92fed194fed395fed597fed799fed89afdda9cfddc9efddea0fde0a1fde2a3fde3a5fde5a7fde7a9fde9aafdebacfcecaefceeb0fcf0b2fcf2b4fcf4b6fcf6b8fcf7b9fcf9bbfcfbbdfcfdbf")),DSt=N8(te("00000401000501010601010802010a02020c02020e03021004031204031405041706041907051b08051d09061f0a07220b07240c08260d08290e092b10092d110a30120a32140b34150b37160b39180c3c190c3e1b0c411c0c431e0c451f0c48210c4a230c4c240c4f260c51280b53290b552b0b572d0b592f0a5b310a5c320a5e340a5f3609613809623909633b09643d09653e0966400a67420a68440a68450a69470b6a490b6a4a0c6b4c0c6b4d0d6c4f0d6c510e6c520e6d540f6d550f6d57106e59106e5a116e5c126e5d126e5f136e61136e62146e64156e65156e67166e69166e6a176e6c186e6d186e6f196e71196e721a6e741a6e751b6e771c6d781c6d7a1d6d7c1d6d7d1e6d7f1e6c801f6c82206c84206b85216b87216b88226a8a226a8c23698d23698f24699025689225689326679526679727669827669a28659b29649d29649f2a63a02a63a22b62a32c61a52c60a62d60a82e5fa92e5eab2f5ead305dae305cb0315bb1325ab3325ab43359b63458b73557b93556ba3655bc3754bd3853bf3952c03a51c13a50c33b4fc43c4ec63d4dc73e4cc83f4bca404acb4149cc4248ce4347cf4446d04545d24644d34743d44842d54a41d74b3fd84c3ed94d3dda4e3cdb503bdd513ade5238df5337e05536e15635e25734e35933e45a31e55c30e65d2fe75e2ee8602de9612bea632aeb6429eb6628ec6726ed6925ee6a24ef6c23ef6e21f06f20f1711ff1731df2741cf3761bf37819f47918f57b17f57d15f67e14f68013f78212f78410f8850ff8870ef8890cf98b0bf98c0af98e09fa9008fa9207fa9407fb9606fb9706fb9906fb9b06fb9d07fc9f07fca108fca309fca50afca60cfca80dfcaa0ffcac11fcae12fcb014fcb216fcb418fbb61afbb81dfbba1ffbbc21fbbe23fac026fac228fac42afac62df9c72ff9c932f9cb35f8cd37f8cf3af7d13df7d340f6d543f6d746f5d949f5db4cf4dd4ff4df53f4e156f3e35af3e55df2e661f2e865f2ea69f1ec6df1ed71f1ef75f1f179f2f27df2f482f3f586f3f68af4f88ef5f992f6fa96f8fb9af9fc9dfafda1fcffa4")),OSt=N8(te("0d088710078813078916078a19068c1b068d1d068e20068f2206902406912605912805922a05932c05942e05952f059631059733059735049837049938049a3a049a3c049b3e049c3f049c41049d43039e44039e46039f48039f4903a04b03a14c02a14e02a25002a25102a35302a35502a45601a45801a45901a55b01a55c01a65e01a66001a66100a76300a76400a76600a76700a86900a86a00a86c00a86e00a86f00a87100a87201a87401a87501a87701a87801a87a02a87b02a87d03a87e03a88004a88104a78305a78405a78606a68707a68808a68a09a58b0aa58d0ba58e0ca48f0da4910ea3920fa39410a29511a19613a19814a099159f9a169f9c179e9d189d9e199da01a9ca11b9ba21d9aa31e9aa51f99a62098a72197a82296aa2395ab2494ac2694ad2793ae2892b02991b12a90b22b8fb32c8eb42e8db52f8cb6308bb7318ab83289ba3388bb3488bc3587bd3786be3885bf3984c03a83c13b82c23c81c33d80c43e7fc5407ec6417dc7427cc8437bc9447aca457acb4679cc4778cc4977cd4a76ce4b75cf4c74d04d73d14e72d24f71d35171d45270d5536fd5546ed6556dd7566cd8576bd9586ada5a6ada5b69db5c68dc5d67dd5e66de5f65de6164df6263e06363e16462e26561e26660e3685fe4695ee56a5de56b5de66c5ce76e5be76f5ae87059e97158e97257ea7457eb7556eb7655ec7754ed7953ed7a52ee7b51ef7c51ef7e50f07f4ff0804ef1814df1834cf2844bf3854bf3874af48849f48948f58b47f58c46f68d45f68f44f79044f79143f79342f89441f89540f9973ff9983ef99a3efa9b3dfa9c3cfa9e3bfb9f3afba139fba238fca338fca537fca636fca835fca934fdab33fdac33fdae32fdaf31fdb130fdb22ffdb42ffdb52efeb72dfeb82cfeba2cfebb2bfebd2afebe2afec029fdc229fdc328fdc527fdc627fdc827fdca26fdcb26fccd25fcce25fcd025fcd225fbd324fbd524fbd724fad824fada24f9dc24f9dd25f8df25f8e125f7e225f7e425f6e626f6e826f5e926f5eb27f4ed27f3ee27f3f027f2f227f1f426f1f525f0f724f0f921"));function qe(e){return function(){return e}}var r$=Math.abs,Bo=Math.atan2,ig=Math.cos,zSt=Math.max,D8=Math.min,_u=Math.sin,sy=Math.sqrt,bo=1e-12,yu=Math.PI,I5=yu/2,hc=2*yu;function FSt(e){return e>1?0:e<-1?yu:Math.acos(e)}function n$(e){return e>=1?I5:e<=-1?-I5:Math.asin(e)}function REe(e){return e.innerRadius}function NEe(e){return e.outerRadius}function DEe(e){return e.startAngle}function OEe(e){return e.endAngle}function zEe(e){return e&&e.padAngle}function FEe(e,t,r,n,i,o,a,s){var l=r-e,c=n-t,u=a-i,h=s-o,f=h*l-u*c;if(!(f*f<bo))return f=(u*(t-o)-h*(e-i))/f,[e+f*l,t+f*c]}function O8(e,t,r,n,i,o,a){var s=e-r,l=t-n,c=(a?o:-o)/sy(s*s+l*l),u=c*l,h=-c*s,f=e+u,p=t+h,d=r+u,g=n+h,_=(f+d)/2,y=(p+g)/2,x=d-f,b=g-p,S=x*x+b*b,C=i-o,P=f*g-d*p,k=(b<0?-1:1)*sy(zSt(0,C*C*S-P*P)),O=(P*b-x*k)/S,D=(-P*x-b*k)/S,B=(P*b+x*k)/S,I=(-P*x+b*k)/S,L=O-_,R=D-y,F=B-_,z=I-y;return L*L+R*R>F*F+z*z&&(O=B,D=I),{cx:O,cy:D,x01:-u,y01:-h,x11:O*(i/C-1),y11:D*(i/C-1)}}function BSt(){var e=REe,t=NEe,r=qe(0),n=null,i=DEe,o=OEe,a=zEe,s=null;function l(){var c,u,h=+e.apply(this,arguments),f=+t.apply(this,arguments),p=i.apply(this,arguments)-I5,d=o.apply(this,arguments)-I5,g=r$(d-p),_=d>p;if(s||(s=c=bs()),f<h&&(u=f,f=h,h=u),!(f>bo))s.moveTo(0,0);else if(g>hc-bo)s.moveTo(f*ig(p),f*_u(p)),s.arc(0,0,f,p,d,!_),h>bo&&(s.moveTo(h*ig(d),h*_u(d)),s.arc(0,0,h,d,p,_));else{var y=p,x=d,b=p,S=d,C=g,P=g,k=a.apply(this,arguments)/2,O=k>bo&&(n?+n.apply(this,arguments):sy(h*h+f*f)),D=D8(r$(f-h)/2,+r.apply(this,arguments)),B=D,I=D,L,R;if(O>bo){var F=n$(O/h*_u(k)),z=n$(O/f*_u(k));(C-=F*2)>bo?(F*=_?1:-1,b+=F,S-=F):(C=0,b=S=(p+d)/2),(P-=z*2)>bo?(z*=_?1:-1,y+=z,x-=z):(P=0,y=x=(p+d)/2)}var U=f*ig(y),W=f*_u(y),Z=h*ig(S),rt=h*_u(S);if(D>bo){var ot=f*ig(x),st=f*_u(x),St=h*ig(b),bt=h*_u(b),Mt;if(g<yu&&(Mt=FEe(U,W,St,bt,ot,st,Z,rt))){var lt=U-Mt[0],Kt=W-Mt[1],_t=ot-Mt[0],ct=st-Mt[1],X=1/_u(FSt((lt*_t+Kt*ct)/(sy(lt*lt+Kt*Kt)*sy(_t*_t+ct*ct)))/2),et=sy(Mt[0]*Mt[0]+Mt[1]*Mt[1]);B=D8(D,(h-et)/(X-1)),I=D8(D,(f-et)/(X+1))}}P>bo?I>bo?(L=O8(St,bt,U,W,f,I,_),R=O8(ot,st,Z,rt,f,I,_),s.moveTo(L.cx+L.x01,L.cy+L.y01),I<D?s.arc(L.cx,L.cy,I,Bo(L.y01,L.x01),Bo(R.y01,R.x01),!_):(s.arc(L.cx,L.cy,I,Bo(L.y01,L.x01),Bo(L.y11,L.x11),!_),s.arc(0,0,f,Bo(L.cy+L.y11,L.cx+L.x11),Bo(R.cy+R.y11,R.cx+R.x11),!_),s.arc(R.cx,R.cy,I,Bo(R.y11,R.x11),Bo(R.y01,R.x01),!_))):(s.moveTo(U,W),s.arc(0,0,f,y,x,!_)):s.moveTo(U,W),!(h>bo)||!(C>bo)?s.lineTo(Z,rt):B>bo?(L=O8(Z,rt,ot,st,h,-B,_),R=O8(U,W,St,bt,h,-B,_),s.lineTo(L.cx+L.x01,L.cy+L.y01),B<D?s.arc(L.cx,L.cy,B,Bo(L.y01,L.x01),Bo(R.y01,R.x01),!_):(s.arc(L.cx,L.cy,B,Bo(L.y01,L.x01),Bo(L.y11,L.x11),!_),s.arc(0,0,h,Bo(L.cy+L.y11,L.cx+L.x11),Bo(R.cy+R.y11,R.cx+R.x11),_),s.arc(R.cx,R.cy,B,Bo(R.y11,R.x11),Bo(R.y01,R.x01),!_))):s.arc(0,0,h,S,b,_)}if(s.closePath(),c)return s=null,c+""||null}return l.centroid=function(){var c=(+e.apply(this,arguments)+ +t.apply(this,arguments))/2,u=(+i.apply(this,arguments)+ +o.apply(this,arguments))/2-yu/2;return[ig(u)*c,_u(u)*c]},l.innerRadius=function(c){return arguments.length?(e=typeof c=="function"?c:qe(+c),l):e},l.outerRadius=function(c){return arguments.length?(t=typeof c=="function"?c:qe(+c),l):t},l.cornerRadius=function(c){return arguments.length?(r=typeof c=="function"?c:qe(+c),l):r},l.padRadius=function(c){return arguments.length?(n=c==null?null:typeof c=="function"?c:qe(+c),l):n},l.startAngle=function(c){return arguments.length?(i=typeof c=="function"?c:qe(+c),l):i},l.endAngle=function(c){return arguments.length?(o=typeof c=="function"?c:qe(+c),l):o},l.padAngle=function(c){return arguments.length?(a=typeof c=="function"?c:qe(+c),l):a},l.context=function(c){return arguments.length?(s=c==null?null:c,l):s},l}function HSt(e){this._context=e}HSt.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;default:this._context.lineTo(e,t);break}}};function Yh(e){return new HSt(e)}function Xb(e){return e[0]}function $b(e){return e[1]}function vu(){var e=Xb,t=$b,r=qe(!0),n=null,i=Yh,o=null;function a(s){var l,c=s.length,u,h=!1,f;for(n==null&&(o=i(f=bs())),l=0;l<=c;++l)!(l<c&&r(u=s[l],l,s))===h&&((h=!h)?o.lineStart():o.lineEnd()),h&&o.point(+e(u,l,s),+t(u,l,s));if(f)return o=null,f+""||null}return a.x=function(s){return arguments.length?(e=typeof s=="function"?s:qe(+s),a):e},a.y=function(s){return arguments.length?(t=typeof s=="function"?s:qe(+s),a):t},a.defined=function(s){return arguments.length?(r=typeof s=="function"?s:qe(!!s),a):r},a.curve=function(s){return arguments.length?(i=s,n!=null&&(o=i(n)),a):i},a.context=function(s){return arguments.length?(s==null?n=o=null:o=i(n=s),a):n},a}function z8(){var e=Xb,t=null,r=qe(0),n=$b,i=qe(!0),o=null,a=Yh,s=null;function l(u){var h,f,p,d=u.length,g,_=!1,y,x=new Array(d),b=new Array(d);for(o==null&&(s=a(y=bs())),h=0;h<=d;++h){if(!(h<d&&i(g=u[h],h,u))===_)if(_=!_)f=h,s.areaStart(),s.lineStart();else{for(s.lineEnd(),s.lineStart(),p=h-1;p>=f;--p)s.point(x[p],b[p]);s.lineEnd(),s.areaEnd()}_&&(x[h]=+e(g,h,u),b[h]=+r(g,h,u),s.point(t?+t(g,h,u):x[h],n?+n(g,h,u):b[h]))}if(y)return s=null,y+""||null}function c(){return vu().defined(i).curve(a).context(o)}return l.x=function(u){return arguments.length?(e=typeof u=="function"?u:qe(+u),t=null,l):e},l.x0=function(u){return arguments.length?(e=typeof u=="function"?u:qe(+u),l):e},l.x1=function(u){return arguments.length?(t=u==null?null:typeof u=="function"?u:qe(+u),l):t},l.y=function(u){return arguments.length?(r=typeof u=="function"?u:qe(+u),n=null,l):r},l.y0=function(u){return arguments.length?(r=typeof u=="function"?u:qe(+u),l):r},l.y1=function(u){return arguments.length?(n=u==null?null:typeof u=="function"?u:qe(+u),l):n},l.lineX0=l.lineY0=function(){return c().x(e).y(r)},l.lineY1=function(){return c().x(e).y(n)},l.lineX1=function(){return c().x(t).y(r)},l.defined=function(u){return arguments.length?(i=typeof u=="function"?u:qe(!!u),l):i},l.curve=function(u){return arguments.length?(a=u,o!=null&&(s=a(o)),l):a},l.context=function(u){return arguments.length?(u==null?o=s=null:s=a(o=u),l):o},l}function VSt(e,t){return t<e?-1:t>e?1:t>=e?0:NaN}function USt(e){return e}function qSt(){var e=USt,t=VSt,r=null,n=qe(0),i=qe(hc),o=qe(0);function a(s){var l,c=s.length,u,h,f=0,p=new Array(c),d=new Array(c),g=+n.apply(this,arguments),_=Math.min(hc,Math.max(-hc,i.apply(this,arguments)-g)),y,x=Math.min(Math.abs(_)/c,o.apply(this,arguments)),b=x*(_<0?-1:1),S;for(l=0;l<c;++l)(S=d[p[l]=l]=+e(s[l],l,s))>0&&(f+=S);for(t!=null?p.sort(function(C,P){return t(d[C],d[P])}):r!=null&&p.sort(function(C,P){return r(s[C],s[P])}),l=0,h=f?(_-c*b)/f:0;l<c;++l,g=y)u=p[l],S=d[u],y=g+(S>0?S*h:0)+b,d[u]={data:s[u],index:l,value:S,startAngle:g,endAngle:y,padAngle:x};return d}return a.value=function(s){return arguments.length?(e=typeof s=="function"?s:qe(+s),a):e},a.sortValues=function(s){return arguments.length?(t=s,r=null,a):t},a.sort=function(s){return arguments.length?(r=s,t=null,a):r},a.startAngle=function(s){return arguments.length?(n=typeof s=="function"?s:qe(+s),a):n},a.endAngle=function(s){return arguments.length?(i=typeof s=="function"?s:qe(+s),a):i},a.padAngle=function(s){return arguments.length?(o=typeof s=="function"?s:qe(+s),a):o},a}var F8=Kb(Yh);function GSt(e){this._curve=e}GSt.prototype={areaStart:function(){this._curve.areaStart()},areaEnd:function(){this._curve.areaEnd()},lineStart:function(){this._curve.lineStart()},lineEnd:function(){this._curve.lineEnd()},point:function(e,t){this._curve.point(t*Math.sin(e),t*-Math.cos(e))}};function Kb(e){function t(r){return new GSt(e(r))}return t._curve=e,t}function Zb(e){var t=e.curve;return e.angle=e.x,delete e.x,e.radius=e.y,delete e.y,e.curve=function(r){return arguments.length?t(Kb(r)):t()._curve},e}function i$(){return Zb(vu().curve(F8))}function o$(){var e=z8().curve(F8),t=e.curve,r=e.lineX0,n=e.lineX1,i=e.lineY0,o=e.lineY1;return e.angle=e.x,delete e.x,e.startAngle=e.x0,delete e.x0,e.endAngle=e.x1,delete e.x1,e.radius=e.y,delete e.y,e.innerRadius=e.y0,delete e.y0,e.outerRadius=e.y1,delete e.y1,e.lineStartAngle=function(){return Zb(r())},delete e.lineX0,e.lineEndAngle=function(){return Zb(n())},delete e.lineX1,e.lineInnerRadius=function(){return Zb(i())},delete e.lineY0,e.lineOuterRadius=function(){return Zb(o())},delete e.lineY1,e.curve=function(a){return arguments.length?t(Kb(a)):t()._curve},e}function ly(e,t){return[(t=+t)*Math.cos(e-=Math.PI/2),t*Math.sin(e)]}var L5=Array.prototype.slice;function BEe(e){return e.source}function HEe(e){return e.target}function a$(e){var t=BEe,r=HEe,n=Xb,i=$b,o=null;function a(){var s,l=L5.call(arguments),c=t.apply(this,l),u=r.apply(this,l);if(o||(o=s=bs()),e(o,+n.apply(this,(l[0]=c,l)),+i.apply(this,l),+n.apply(this,(l[0]=u,l)),+i.apply(this,l)),s)return o=null,s+""||null}return a.source=function(s){return arguments.length?(t=s,a):t},a.target=function(s){return arguments.length?(r=s,a):r},a.x=function(s){return arguments.length?(n=typeof s=="function"?s:qe(+s),a):n},a.y=function(s){return arguments.length?(i=typeof s=="function"?s:qe(+s),a):i},a.context=function(s){return arguments.length?(o=s==null?null:s,a):o},a}function VEe(e,t,r,n,i){e.moveTo(t,r),e.bezierCurveTo(t=(t+n)/2,r,t,i,n,i)}function UEe(e,t,r,n,i){e.moveTo(t,r),e.bezierCurveTo(t,r=(r+i)/2,n,r,n,i)}function qEe(e,t,r,n,i){var o=ly(t,r),a=ly(t,r=(r+i)/2),s=ly(n,r),l=ly(n,i);e.moveTo(o[0],o[1]),e.bezierCurveTo(a[0],a[1],s[0],s[1],l[0],l[1])}function WSt(){return a$(VEe)}function YSt(){return a$(UEe)}function jSt(){var e=a$(qEe);return e.angle=e.x,delete e.x,e.radius=e.y,delete e.y,e}var k5={draw:function(e,t){var r=Math.sqrt(t/yu);e.moveTo(r,0),e.arc(0,0,r,0,hc)}};var B8={draw:function(e,t){var r=Math.sqrt(t/5)/2;e.moveTo(-3*r,-r),e.lineTo(-r,-r),e.lineTo(-r,-3*r),e.lineTo(r,-3*r),e.lineTo(r,-r),e.lineTo(3*r,-r),e.lineTo(3*r,r),e.lineTo(r,r),e.lineTo(r,3*r),e.lineTo(-r,3*r),e.lineTo(-r,r),e.lineTo(-3*r,r),e.closePath()}};var XSt=Math.sqrt(.3333333333333333),GEe=XSt*2,H8={draw:function(e,t){var r=Math.sqrt(t/GEe),n=r*XSt;e.moveTo(0,-r),e.lineTo(n,0),e.lineTo(0,r),e.lineTo(-n,0),e.closePath()}};var WEe=.8908130915292852,$St=Math.sin(yu/10)/Math.sin(7*yu/10),YEe=Math.sin(hc/10)*$St,jEe=-Math.cos(hc/10)*$St,V8={draw:function(e,t){var r=Math.sqrt(t*WEe),n=YEe*r,i=jEe*r;e.moveTo(0,-r),e.lineTo(n,i);for(var o=1;o<5;++o){var a=hc*o/5,s=Math.cos(a),l=Math.sin(a);e.lineTo(l*r,-s*r),e.lineTo(s*n-l*i,l*n+s*i)}e.closePath()}};var U8={draw:function(e,t){var r=Math.sqrt(t),n=-r/2;e.rect(n,n,r,r)}};var s$=Math.sqrt(3),q8={draw:function(e,t){var r=-Math.sqrt(t/(s$*3));e.moveTo(0,r*2),e.lineTo(-s$*r,-r),e.lineTo(s$*r,-r),e.closePath()}};var fc=-.5,pc=Math.sqrt(3)/2,l$=1/Math.sqrt(12),XEe=(l$/2+1)*3,G8={draw:function(e,t){var r=Math.sqrt(t/XEe),n=r/2,i=r*l$,o=n,a=r*l$+r,s=-o,l=a;e.moveTo(n,i),e.lineTo(o,a),e.lineTo(s,l),e.lineTo(fc*n-pc*i,pc*n+fc*i),e.lineTo(fc*o-pc*a,pc*o+fc*a),e.lineTo(fc*s-pc*l,pc*s+fc*l),e.lineTo(fc*n+pc*i,fc*i-pc*n),e.lineTo(fc*o+pc*a,fc*a-pc*o),e.lineTo(fc*s+pc*l,fc*l-pc*s),e.closePath()}};var KSt=[k5,B8,H8,U8,V8,q8,G8];function ZSt(){var e=qe(k5),t=qe(64),r=null;function n(){var i;if(r||(r=i=bs()),e.apply(this,arguments).draw(r,+t.apply(this,arguments)),i)return r=null,i+""||null}return n.type=function(i){return arguments.length?(e=typeof i=="function"?i:qe(i),n):e},n.size=function(i){return arguments.length?(t=typeof i=="function"?i:qe(+i),n):t},n.context=function(i){return arguments.length?(r=i==null?null:i,n):r},n}function dc(){}function Jb(e,t,r){e._context.bezierCurveTo((2*e._x0+e._x1)/3,(2*e._y0+e._y1)/3,(e._x0+2*e._x1)/3,(e._y0+2*e._y1)/3,(e._x0+4*e._x1+t)/6,(e._y0+4*e._y1+r)/6)}function R5(e){this._context=e}R5.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._y0=this._y1=NaN,this._point=0},lineEnd:function(){switch(this._point){case 3:Jb(this,this._x1,this._y1);case 2:this._context.lineTo(this._x1,this._y1);break}(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;break;case 2:this._point=3,this._context.lineTo((5*this._x0+this._x1)/6,(5*this._y0+this._y1)/6);default:Jb(this,e,t);break}this._x0=this._x1,this._x1=e,this._y0=this._y1,this._y1=t}};function W8(e){return new R5(e)}function JSt(e){this._context=e}JSt.prototype={areaStart:dc,areaEnd:dc,lineStart:function(){this._x0=this._x1=this._x2=this._x3=this._x4=this._y0=this._y1=this._y2=this._y3=this._y4=NaN,this._point=0},lineEnd:function(){switch(this._point){case 1:{this._context.moveTo(this._x2,this._y2),this._context.closePath();break}case 2:{this._context.moveTo((this._x2+2*this._x3)/3,(this._y2+2*this._y3)/3),this._context.lineTo((this._x3+2*this._x2)/3,(this._y3+2*this._y2)/3),this._context.closePath();break}case 3:{this.point(this._x2,this._y2),this.point(this._x3,this._y3),this.point(this._x4,this._y4);break}}},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._x2=e,this._y2=t;break;case 1:this._point=2,this._x3=e,this._y3=t;break;case 2:this._point=3,this._x4=e,this._y4=t,this._context.moveTo((this._x0+4*this._x1+e)/6,(this._y0+4*this._y1+t)/6);break;default:Jb(this,e,t);break}this._x0=this._x1,this._x1=e,this._y0=this._y1,this._y1=t}};function QSt(e){return new JSt(e)}function t3t(e){this._context=e}t3t.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._y0=this._y1=NaN,this._point=0},lineEnd:function(){(this._line||this._line!==0&&this._point===3)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1;break;case 1:this._point=2;break;case 2:this._point=3;var r=(this._x0+4*this._x1+e)/6,n=(this._y0+4*this._y1+t)/6;this._line?this._context.lineTo(r,n):this._context.moveTo(r,n);break;case 3:this._point=4;default:Jb(this,e,t);break}this._x0=this._x1,this._x1=e,this._y0=this._y1,this._y1=t}};function e3t(e){return new t3t(e)}function r3t(e,t){this._basis=new R5(e),this._beta=t}r3t.prototype={lineStart:function(){this._x=[],this._y=[],this._basis.lineStart()},lineEnd:function(){var e=this._x,t=this._y,r=e.length-1;if(r>0)for(var n=e[0],i=t[0],o=e[r]-n,a=t[r]-i,s=-1,l;++s<=r;)l=s/r,this._basis.point(this._beta*e[s]+(1-this._beta)*(n+l*o),this._beta*t[s]+(1-this._beta)*(i+l*a));this._x=this._y=null,this._basis.lineEnd()},point:function(e,t){this._x.push(+e),this._y.push(+t)}};var n3t=function e(t){function r(n){return t===1?new R5(n):new r3t(n,t)}return r.beta=function(n){return e(+n)},r}(.85);function Qb(e,t,r){e._context.bezierCurveTo(e._x1+e._k*(e._x2-e._x0),e._y1+e._k*(e._y2-e._y0),e._x2+e._k*(e._x1-t),e._y2+e._k*(e._y1-r),e._x2,e._y2)}function Y8(e,t){this._context=e,this._k=(1-t)/6}Y8.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x2,this._y2);break;case 3:Qb(this,this._x1,this._y1);break}(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2,this._x1=e,this._y1=t;break;case 2:this._point=3;default:Qb(this,e,t);break}this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};var i3t=function e(t){function r(n){return new Y8(n,t)}return r.tension=function(n){return e(+n)},r}(0);function j8(e,t){this._context=e,this._k=(1-t)/6}j8.prototype={areaStart:dc,areaEnd:dc,lineStart:function(){this._x0=this._x1=this._x2=this._x3=this._x4=this._x5=this._y0=this._y1=this._y2=this._y3=this._y4=this._y5=NaN,this._point=0},lineEnd:function(){switch(this._point){case 1:{this._context.moveTo(this._x3,this._y3),this._context.closePath();break}case 2:{this._context.lineTo(this._x3,this._y3),this._context.closePath();break}case 3:{this.point(this._x3,this._y3),this.point(this._x4,this._y4),this.point(this._x5,this._y5);break}}},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._x3=e,this._y3=t;break;case 1:this._point=2,this._context.moveTo(this._x4=e,this._y4=t);break;case 2:this._point=3,this._x5=e,this._y5=t;break;default:Qb(this,e,t);break}this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};var o3t=function e(t){function r(n){return new j8(n,t)}return r.tension=function(n){return e(+n)},r}(0);function X8(e,t){this._context=e,this._k=(1-t)/6}X8.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._point=0},lineEnd:function(){(this._line||this._line!==0&&this._point===3)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1;break;case 1:this._point=2;break;case 2:this._point=3,this._line?this._context.lineTo(this._x2,this._y2):this._context.moveTo(this._x2,this._y2);break;case 3:this._point=4;default:Qb(this,e,t);break}this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};var a3t=function e(t){function r(n){return new X8(n,t)}return r.tension=function(n){return e(+n)},r}(0);function N5(e,t,r){var n=e._x1,i=e._y1,o=e._x2,a=e._y2;if(e._l01_a>bo){var s=2*e._l01_2a+3*e._l01_a*e._l12_a+e._l12_2a,l=3*e._l01_a*(e._l01_a+e._l12_a);n=(n*s-e._x0*e._l12_2a+e._x2*e._l01_2a)/l,i=(i*s-e._y0*e._l12_2a+e._y2*e._l01_2a)/l}if(e._l23_a>bo){var c=2*e._l23_2a+3*e._l23_a*e._l12_a+e._l12_2a,u=3*e._l23_a*(e._l23_a+e._l12_a);o=(o*c+e._x1*e._l23_2a-t*e._l12_2a)/u,a=(a*c+e._y1*e._l23_2a-r*e._l12_2a)/u}e._context.bezierCurveTo(n,i,o,a,e._x2,e._y2)}function s3t(e,t){this._context=e,this._alpha=t}s3t.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._l01_a=this._l12_a=this._l23_a=this._l01_2a=this._l12_2a=this._l23_2a=this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x2,this._y2);break;case 3:this.point(this._x2,this._y2);break}(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){if(e=+e,t=+t,this._point){var r=this._x2-e,n=this._y2-t;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(r*r+n*n,this._alpha))}switch(this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;break;case 2:this._point=3;default:N5(this,e,t);break}this._l01_a=this._l12_a,this._l12_a=this._l23_a,this._l01_2a=this._l12_2a,this._l12_2a=this._l23_2a,this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};var l3t=function e(t){function r(n){return t?new s3t(n,t):new Y8(n,0)}return r.alpha=function(n){return e(+n)},r}(.5);function c3t(e,t){this._context=e,this._alpha=t}c3t.prototype={areaStart:dc,areaEnd:dc,lineStart:function(){this._x0=this._x1=this._x2=this._x3=this._x4=this._x5=this._y0=this._y1=this._y2=this._y3=this._y4=this._y5=NaN,this._l01_a=this._l12_a=this._l23_a=this._l01_2a=this._l12_2a=this._l23_2a=this._point=0},lineEnd:function(){switch(this._point){case 1:{this._context.moveTo(this._x3,this._y3),this._context.closePath();break}case 2:{this._context.lineTo(this._x3,this._y3),this._context.closePath();break}case 3:{this.point(this._x3,this._y3),this.point(this._x4,this._y4),this.point(this._x5,this._y5);break}}},point:function(e,t){if(e=+e,t=+t,this._point){var r=this._x2-e,n=this._y2-t;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(r*r+n*n,this._alpha))}switch(this._point){case 0:this._point=1,this._x3=e,this._y3=t;break;case 1:this._point=2,this._context.moveTo(this._x4=e,this._y4=t);break;case 2:this._point=3,this._x5=e,this._y5=t;break;default:N5(this,e,t);break}this._l01_a=this._l12_a,this._l12_a=this._l23_a,this._l01_2a=this._l12_2a,this._l12_2a=this._l23_2a,this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};var u3t=function e(t){function r(n){return t?new c3t(n,t):new j8(n,0)}return r.alpha=function(n){return e(+n)},r}(.5);function h3t(e,t){this._context=e,this._alpha=t}h3t.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._l01_a=this._l12_a=this._l23_a=this._l01_2a=this._l12_2a=this._l23_2a=this._point=0},lineEnd:function(){(this._line||this._line!==0&&this._point===3)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){if(e=+e,t=+t,this._point){var r=this._x2-e,n=this._y2-t;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(r*r+n*n,this._alpha))}switch(this._point){case 0:this._point=1;break;case 1:this._point=2;break;case 2:this._point=3,this._line?this._context.lineTo(this._x2,this._y2):this._context.moveTo(this._x2,this._y2);break;case 3:this._point=4;default:N5(this,e,t);break}this._l01_a=this._l12_a,this._l12_a=this._l23_a,this._l01_2a=this._l12_2a,this._l12_2a=this._l23_2a,this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};var f3t=function e(t){function r(n){return t?new h3t(n,t):new X8(n,0)}return r.alpha=function(n){return e(+n)},r}(.5);function p3t(e){this._context=e}p3t.prototype={areaStart:dc,areaEnd:dc,lineStart:function(){this._point=0},lineEnd:function(){this._point&&this._context.closePath()},point:function(e,t){e=+e,t=+t,this._point?this._context.lineTo(e,t):(this._point=1,this._context.moveTo(e,t))}};function d3t(e){return new p3t(e)}function m3t(e){return e<0?-1:1}function g3t(e,t,r){var n=e._x1-e._x0,i=t-e._x1,o=(e._y1-e._y0)/(n||i<0&&-0),a=(r-e._y1)/(i||n<0&&-0),s=(o*i+a*n)/(n+i);return(m3t(o)+m3t(a))*Math.min(Math.abs(o),Math.abs(a),.5*Math.abs(s))||0}function _3t(e,t){var r=e._x1-e._x0;return r?(3*(e._y1-e._y0)/r-t)/2:t}function c$(e,t,r){var n=e._x0,i=e._y0,o=e._x1,a=e._y1,s=(o-n)/3;e._context.bezierCurveTo(n+s,i+s*t,o-s,a-s*r,o,a)}function $8(e){this._context=e}$8.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._y0=this._y1=this._t0=NaN,this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x1,this._y1);break;case 3:c$(this,this._t0,_3t(this,this._t0));break}(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){var r=NaN;if(e=+e,t=+t,!(e===this._x1&&t===this._y1)){switch(this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;break;case 2:this._point=3,c$(this,_3t(this,r=g3t(this,e,t)),r);break;default:c$(this,this._t0,r=g3t(this,e,t));break}this._x0=this._x1,this._x1=e,this._y0=this._y1,this._y1=t,this._t0=r}}};function y3t(e){this._context=new v3t(e)}(y3t.prototype=Object.create($8.prototype)).point=function(e,t){$8.prototype.point.call(this,t,e)};function v3t(e){this._context=e}v3t.prototype={moveTo:function(e,t){this._context.moveTo(t,e)},closePath:function(){this._context.closePath()},lineTo:function(e,t){this._context.lineTo(t,e)},bezierCurveTo:function(e,t,r,n,i,o){this._context.bezierCurveTo(t,e,n,r,o,i)}};function x3t(e){return new $8(e)}function b3t(e){return new y3t(e)}function S3t(e){this._context=e}S3t.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x=[],this._y=[]},lineEnd:function(){var e=this._x,t=this._y,r=e.length;if(r)if(this._line?this._context.lineTo(e[0],t[0]):this._context.moveTo(e[0],t[0]),r===2)this._context.lineTo(e[1],t[1]);else for(var n=w3t(e),i=w3t(t),o=0,a=1;a<r;++o,++a)this._context.bezierCurveTo(n[0][o],i[0][o],n[1][o],i[1][o],e[a],t[a]);(this._line||this._line!==0&&r===1)&&this._context.closePath(),this._line=1-this._line,this._x=this._y=null},point:function(e,t){this._x.push(+e),this._y.push(+t)}};function w3t(e){var t,r=e.length-1,n,i=new Array(r),o=new Array(r),a=new Array(r);for(i[0]=0,o[0]=2,a[0]=e[0]+2*e[1],t=1;t<r-1;++t)i[t]=1,o[t]=4,a[t]=4*e[t]+2*e[t+1];for(i[r-1]=2,o[r-1]=7,a[r-1]=8*e[r-1]+e[r],t=1;t<r;++t)n=i[t]/o[t-1],o[t]-=n,a[t]-=n*a[t-1];for(i[r-1]=a[r-1]/o[r-1],t=r-2;t>=0;--t)i[t]=(a[t]-i[t+1])/o[t];for(o[r-1]=(e[r]+i[r-1])/2,t=0;t<r-1;++t)o[t]=2*e[t+1]-i[t+1];return[i,o]}function M3t(e){return new S3t(e)}function K8(e,t){this._context=e,this._t=t}K8.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x=this._y=NaN,this._point=0},lineEnd:function(){0<this._t&&this._t<1&&this._point===2&&this._context.lineTo(this._x,this._y),(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line>=0&&(this._t=1-this._t,this._line=1-this._line)},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;default:{if(this._t<=0)this._context.lineTo(this._x,t),this._context.lineTo(e,t);else{var r=this._x*(1-this._t)+e*this._t;this._context.lineTo(r,this._y),this._context.lineTo(r,t)}break}}this._x=e,this._y=t}};function E3t(e){return new K8(e,.5)}function T3t(e){return new K8(e,0)}function C3t(e){return new K8(e,1)}function xu(e,t){if((a=e.length)>1)for(var r=1,n,i,o=e[t[0]],a,s=o.length;r<a;++r)for(i=o,o=e[t[r]],n=0;n<s;++n)o[n][1]+=o[n][0]=isNaN(i[n][1])?i[n][0]:i[n][1]}function bu(e){for(var t=e.length,r=new Array(t);--t>=0;)r[t]=t;return r}function $Ee(e,t){return e[t]}function A3t(){var e=qe([]),t=bu,r=xu,n=$Ee;function i(o){var a=e.apply(this,arguments),s,l=o.length,c=a.length,u=new Array(c),h;for(s=0;s<c;++s){for(var f=a[s],p=u[s]=new Array(l),d=0,g;d<l;++d)p[d]=g=[0,+n(o[d],f,d,o)],g.data=o[d];p.key=f}for(s=0,h=t(u);s<c;++s)u[h[s]].index=s;return r(u,h),u}return i.keys=function(o){return arguments.length?(e=typeof o=="function"?o:qe(L5.call(o)),i):e},i.value=function(o){return arguments.length?(n=typeof o=="function"?o:qe(+o),i):n},i.order=function(o){return arguments.length?(t=o==null?bu:typeof o=="function"?o:qe(L5.call(o)),i):t},i.offset=function(o){return arguments.length?(r=o==null?xu:o,i):r},i}function P3t(e,t){if((n=e.length)>0){for(var r,n,i=0,o=e[0].length,a;i<o;++i){for(a=r=0;r<n;++r)a+=e[r][i][1]||0;if(a)for(r=0;r<n;++r)e[r][i][1]/=a}xu(e,t)}}function I3t(e,t){if((l=e.length)>0)for(var r,n=0,i,o,a,s,l,c=e[t[0]].length;n<c;++n)for(a=s=0,r=0;r<l;++r)(o=(i=e[t[r]][n])[1]-i[0])>0?(i[0]=a,i[1]=a+=o):o<0?(i[1]=s,i[0]=s+=o):(i[0]=0,i[1]=o)}function L3t(e,t){if((i=e.length)>0){for(var r=0,n=e[t[0]],i,o=n.length;r<o;++r){for(var a=0,s=0;a<i;++a)s+=e[a][r][1]||0;n[r][1]+=n[r][0]=-s/2}xu(e,t)}}function k3t(e,t){if(!(!((a=e.length)>0)||!((o=(i=e[t[0]]).length)>0))){for(var r=0,n=1,i,o,a;n<o;++n){for(var s=0,l=0,c=0;s<a;++s){for(var u=e[t[s]],h=u[n][1]||0,f=u[n-1][1]||0,p=(h-f)/2,d=0;d<s;++d){var g=e[t[d]],_=g[n][1]||0,y=g[n-1][1]||0;p+=_-y}l+=h,c+=p*h}i[n-1][1]+=i[n-1][0]=r,l&&(r-=c/l)}i[n-1][1]+=i[n-1][0]=r,xu(e,t)}}function Z8(e){var t=e.map(KEe);return bu(e).sort(function(r,n){return t[r]-t[n]})}function KEe(e){for(var t=-1,r=0,n=e.length,i,o=-1/0;++t<n;)(i=+e[t][1])>o&&(o=i,r=t);return r}function J8(e){var t=e.map(u$);return bu(e).sort(function(r,n){return t[r]-t[n]})}function u$(e){for(var t=0,r=-1,n=e.length,i;++r<n;)(i=+e[r][1])&&(t+=i);return t}function R3t(e){return J8(e).reverse()}function N3t(e){var t=e.length,r,n,i=e.map(u$),o=Z8(e),a=0,s=0,l=[],c=[];for(r=0;r<t;++r)n=o[r],a<s?(a+=i[n],l.push(n)):(s+=i[n],c.push(n));return c.reverse().concat(l)}function D3t(e){return bu(e).reverse()}function h$(e){return function(){return e}}function O3t(e){return e[0]}function z3t(e){return e[1]}function f$(){this._=null}function t2(e){e.U=e.C=e.L=e.R=e.P=e.N=null}f$.prototype={constructor:f$,insert:function(e,t){var r,n,i;if(e){if(t.P=e,t.N=e.N,e.N&&(e.N.P=t),e.N=t,e.R){for(e=e.R;e.L;)e=e.L;e.L=t}else e.R=t;r=e}else this._?(e=F3t(this._),t.P=null,t.N=e,e.P=e.L=t,r=e):(t.P=t.N=null,this._=t,r=null);for(t.L=t.R=null,t.U=r,t.C=!0,e=t;r&&r.C;)n=r.U,r===n.L?(i=n.R,i&&i.C?(r.C=i.C=!1,n.C=!0,e=n):(e===r.R&&(D5(this,r),e=r,r=e.U),r.C=!1,n.C=!0,O5(this,n))):(i=n.L,i&&i.C?(r.C=i.C=!1,n.C=!0,e=n):(e===r.L&&(O5(this,r),e=r,r=e.U),r.C=!1,n.C=!0,D5(this,n))),r=e.U;this._.C=!1},remove:function(e){e.N&&(e.N.P=e.P),e.P&&(e.P.N=e.N),e.N=e.P=null;var t=e.U,r,n=e.L,i=e.R,o,a;if(n?i?o=F3t(i):o=n:o=i,t?t.L===e?t.L=o:t.R=o:this._=o,n&&i?(a=o.C,o.C=e.C,o.L=n,n.U=o,o!==i?(t=o.U,o.U=e.U,e=o.R,t.L=e,o.R=i,i.U=o):(o.U=t,t=o,e=o.R)):(a=e.C,e=o),e&&(e.U=t),!a){if(e&&e.C){e.C=!1;return}do{if(e===this._)break;if(e===t.L){if(r=t.R,r.C&&(r.C=!1,t.C=!0,D5(this,t),r=t.R),r.L&&r.L.C||r.R&&r.R.C){(!r.R||!r.R.C)&&(r.L.C=!1,r.C=!0,O5(this,r),r=t.R),r.C=t.C,t.C=r.R.C=!1,D5(this,t),e=this._;break}}else if(r=t.L,r.C&&(r.C=!1,t.C=!0,O5(this,t),r=t.L),r.L&&r.L.C||r.R&&r.R.C){(!r.L||!r.L.C)&&(r.R.C=!1,r.C=!0,D5(this,r),r=t.L),r.C=t.C,t.C=r.L.C=!1,O5(this,t),e=this._;break}r.C=!0,e=t,t=t.U}while(!e.C);e&&(e.C=!1)}}};function D5(e,t){var r=t,n=t.R,i=r.U;i?i.L===r?i.L=n:i.R=n:e._=n,n.U=i,r.U=n,r.R=n.L,r.R&&(r.R.U=r),n.L=r}function O5(e,t){var r=t,n=t.L,i=r.U;i?i.L===r?i.L=n:i.R=n:e._=n,n.U=i,r.U=n,r.L=n.R,r.L&&(r.L.U=r),n.R=r}function F3t(e){for(;e.L;)e=e.L;return e}var p$=f$;function e2(e,t,r,n){var i=[null,null],o=wo.push(i)-1;return i.left=e,i.right=t,r&&z5(i,e,t,r),n&&z5(i,t,e,n),Va[e.index].halfedges.push(o),Va[t.index].halfedges.push(o),i}function r2(e,t,r){var n=[t,r];return n.left=e,n}function z5(e,t,r,n){!e[0]&&!e[1]?(e[0]=n,e.left=t,e.right=r):e.left===r?e[1]=n:e[0]=n}function ZEe(e,t,r,n,i){var o=e[0],a=e[1],s=o[0],l=o[1],c=a[0],u=a[1],h=0,f=1,p=c-s,d=u-l,g;if(g=t-s,!(!p&&g>0)){if(g/=p,p<0){if(g<h)return;g<f&&(f=g)}else if(p>0){if(g>f)return;g>h&&(h=g)}if(g=n-s,!(!p&&g<0)){if(g/=p,p<0){if(g>f)return;g>h&&(h=g)}else if(p>0){if(g<h)return;g<f&&(f=g)}if(g=r-l,!(!d&&g>0)){if(g/=d,d<0){if(g<h)return;g<f&&(f=g)}else if(d>0){if(g>f)return;g>h&&(h=g)}if(g=i-l,!(!d&&g<0)){if(g/=d,d<0){if(g>f)return;g>h&&(h=g)}else if(d>0){if(g<h)return;g<f&&(f=g)}return!(h>0)&&!(f<1)||(h>0&&(e[0]=[s+h*p,l+h*d]),f<1&&(e[1]=[s+f*p,l+f*d])),!0}}}}}function JEe(e,t,r,n,i){var o=e[1];if(o)return!0;var a=e[0],s=e.left,l=e.right,c=s[0],u=s[1],h=l[0],f=l[1],p=(c+h)/2,d=(u+f)/2,g,_;if(f===u){if(p<t||p>=n)return;if(c>h){if(!a)a=[p,r];else if(a[1]>=i)return;o=[p,i]}else{if(!a)a=[p,i];else if(a[1]<r)return;o=[p,r]}}else if(g=(c-h)/(f-u),_=d-g*p,g<-1||g>1)if(c>h){if(!a)a=[(r-_)/g,r];else if(a[1]>=i)return;o=[(i-_)/g,i]}else{if(!a)a=[(i-_)/g,i];else if(a[1]<r)return;o=[(r-_)/g,r]}else if(u<f){if(!a)a=[t,g*t+_];else if(a[0]>=n)return;o=[n,g*n+_]}else{if(!a)a=[n,g*n+_];else if(a[0]<t)return;o=[t,g*t+_]}return e[0]=a,e[1]=o,!0}function B3t(e,t,r,n){for(var i=wo.length,o;i--;)(!JEe(o=wo[i],e,t,r,n)||!ZEe(o,e,t,r,n)||!(Math.abs(o[0][0]-o[1][0])>Hr||Math.abs(o[0][1]-o[1][1])>Hr))&&delete wo[i]}function H3t(e){return Va[e.index]={site:e,halfedges:[]}}function QEe(e,t){var r=e.site,n=t.left,i=t.right;return r===i&&(i=n,n=r),i?Math.atan2(i[1]-n[1],i[0]-n[0]):(r===n?(n=t[1],i=t[0]):(n=t[0],i=t[1]),Math.atan2(n[0]-i[0],i[1]-n[1]))}function d$(e,t){return t[+(t.left!==e.site)]}function t5e(e,t){return t[+(t.left===e.site)]}function V3t(){for(var e=0,t=Va.length,r,n,i,o;e<t;++e)if((r=Va[e])&&(o=(n=r.halfedges).length)){var a=new Array(o),s=new Array(o);for(i=0;i<o;++i)a[i]=i,s[i]=QEe(r,wo[n[i]]);for(a.sort(function(l,c){return s[c]-s[l]}),i=0;i<o;++i)s[i]=n[a[i]];for(i=0;i<o;++i)n[i]=s[i]}}function U3t(e,t,r,n){var i=Va.length,o,a,s,l,c,u,h,f,p,d,g,_,y=!0;for(o=0;o<i;++o)if(a=Va[o]){for(s=a.site,c=a.halfedges,l=c.length;l--;)wo[c[l]]||c.splice(l,1);for(l=0,u=c.length;l<u;)d=t5e(a,wo[c[l]]),g=d[0],_=d[1],h=d$(a,wo[c[++l%u]]),f=h[0],p=h[1],(Math.abs(g-f)>Hr||Math.abs(_-p)>Hr)&&(c.splice(l,0,wo.push(r2(s,d,Math.abs(g-e)<Hr&&n-_>Hr?[e,Math.abs(f-e)<Hr?p:n]:Math.abs(_-n)<Hr&&r-g>Hr?[Math.abs(p-n)<Hr?f:r,n]:Math.abs(g-r)<Hr&&_-t>Hr?[r,Math.abs(f-r)<Hr?p:t]:Math.abs(_-t)<Hr&&g-e>Hr?[Math.abs(p-t)<Hr?f:e,t]:null))-1),++u);u&&(y=!1)}if(y){var x,b,S,C=1/0;for(o=0,y=null;o<i;++o)(a=Va[o])&&(s=a.site,x=s[0]-e,b=s[1]-t,S=x*x+b*b,S<C&&(C=S,y=a));if(y){var P=[e,t],k=[e,n],O=[r,n],D=[r,t];y.halfedges.push(wo.push(r2(s=y.site,P,k))-1,wo.push(r2(s,k,O))-1,wo.push(r2(s,O,D))-1,wo.push(r2(s,D,P))-1)}}for(o=0;o<i;++o)(a=Va[o])&&(a.halfedges.length||delete Va[o])}var q3t=[],Q8;function e5e(){t2(this),this.x=this.y=this.arc=this.site=this.cy=null}function cy(e){var t=e.P,r=e.N;if(!(!t||!r)){var n=t.site,i=e.site,o=r.site;if(n!==o){var a=i[0],s=i[1],l=n[0]-a,c=n[1]-s,u=o[0]-a,h=o[1]-s,f=2*(l*h-c*u);if(!(f>=-G3t)){var p=l*l+c*c,d=u*u+h*h,g=(h*p-c*d)/f,_=(l*d-u*p)/f,y=q3t.pop()||new e5e;y.arc=e,y.site=i,y.x=g+a,y.y=(y.cy=_+s)+Math.sqrt(g*g+_*_),e.circle=y;for(var x=null,b=n2._;b;)if(y.y<b.y||y.y===b.y&&y.x<=b.x)if(b.L)b=b.L;else{x=b.P;break}else if(b.R)b=b.R;else{x=b;break}n2.insert(x,y),x||(Q8=y)}}}}function uy(e){var t=e.circle;t&&(t.P||(Q8=t.N),n2.remove(t),q3t.push(t),t2(t),e.circle=null)}var Y3t=[];function r5e(){t2(this),this.edge=this.site=this.circle=null}function W3t(e){var t=Y3t.pop()||new r5e;return t.site=e,t}function m$(e){uy(e),hy.remove(e),Y3t.push(e),t2(e)}function j3t(e){var t=e.circle,r=t.x,n=t.cy,i=[r,n],o=e.P,a=e.N,s=[e];m$(e);for(var l=o;l.circle&&Math.abs(r-l.circle.x)<Hr&&Math.abs(n-l.circle.cy)<Hr;)o=l.P,s.unshift(l),m$(l),l=o;s.unshift(l),uy(l);for(var c=a;c.circle&&Math.abs(r-c.circle.x)<Hr&&Math.abs(n-c.circle.cy)<Hr;)a=c.N,s.push(c),m$(c),c=a;s.push(c),uy(c);var u=s.length,h;for(h=1;h<u;++h)c=s[h],l=s[h-1],z5(c.edge,l.site,c.site,i);l=s[0],c=s[u-1],c.edge=e2(l.site,c.site,null,i),cy(l),cy(c)}function X3t(e){for(var t=e[0],r=e[1],n,i,o,a,s=hy._;s;)if(o=$3t(s,r)-t,o>Hr)s=s.L;else if(a=t-n5e(s,r),a>Hr){if(!s.R){n=s;break}s=s.R}else{o>-Hr?(n=s.P,i=s):a>-Hr?(n=s,i=s.N):n=i=s;break}H3t(e);var l=W3t(e);if(hy.insert(n,l),!(!n&&!i)){if(n===i){uy(n),i=W3t(n.site),hy.insert(l,i),l.edge=i.edge=e2(n.site,l.site),cy(n),cy(i);return}if(!i){l.edge=e2(n.site,l.site);return}uy(n),uy(i);var c=n.site,u=c[0],h=c[1],f=e[0]-u,p=e[1]-h,d=i.site,g=d[0]-u,_=d[1]-h,y=2*(f*_-p*g),x=f*f+p*p,b=g*g+_*_,S=[(_*x-p*b)/y+u,(f*b-g*x)/y+h];z5(i.edge,c,d,S),l.edge=e2(c,e,null,S),i.edge=e2(e,d,null,S),cy(n),cy(i)}}function $3t(e,t){var r=e.site,n=r[0],i=r[1],o=i-t;if(!o)return n;var a=e.P;if(!a)return-1/0;r=a.site;var s=r[0],l=r[1],c=l-t;if(!c)return s;var u=s-n,h=1/o-1/c,f=u/c;return h?(-f+Math.sqrt(f*f-2*h*(u*u/(-2*c)-l+c/2+i-o/2)))/h+n:(n+s)/2}function n5e(e,t){var r=e.N;if(r)return $3t(r,t);var n=e.site;return n[1]===t?n[0]:1/0}var Hr=1e-6,G3t=1e-12,hy,Va,n2,wo;function i5e(e,t,r){return(e[0]-r[0])*(t[1]-e[1])-(e[0]-t[0])*(r[1]-e[1])}function o5e(e,t){return t[1]-e[1]||t[0]-e[0]}function F5(e,t){var r=e.sort(o5e).pop(),n,i,o;for(wo=[],Va=new Array(e.length),hy=new p$,n2=new p$;;)if(o=Q8,r&&(!o||r[1]<o.y||r[1]===o.y&&r[0]<o.x))(r[0]!==n||r[1]!==i)&&(X3t(r),n=r[0],i=r[1]),r=e.pop();else if(o)j3t(o.arc);else break;if(V3t(),t){var a=+t[0][0],s=+t[0][1],l=+t[1][0],c=+t[1][1];B3t(a,s,l,c),U3t(a,s,l,c)}this.edges=wo,this.cells=Va,hy=n2=wo=Va=null}F5.prototype={constructor:F5,polygons:function(){var e=this.edges;return this.cells.map(function(t){var r=t.halfedges.map(function(n){return d$(t,e[n])});return r.data=t.site.data,r})},triangles:function(){var e=[],t=this.edges;return this.cells.forEach(function(r,n){if(!!(s=(o=r.halfedges).length))for(var i=r.site,o,a=-1,s,l,c=t[o[s-1]],u=c.left===i?c.right:c.left;++a<s;)l=u,c=t[o[a]],u=c.left===i?c.right:c.left,l&&u&&n<l.index&&n<u.index&&i5e(i,l,u)<0&&e.push([i.data,l.data,u.data])}),e},links:function(){return this.edges.filter(function(e){return e.right}).map(function(e){return{source:e.left.data,target:e.right.data}})},find:function(e,t,r){for(var n=this,i,o=n._found||0,a=n.cells.length,s;!(s=n.cells[o]);)if(++o>=a)return null;var l=e-s.site[0],c=t-s.site[1],u=l*l+c*c;do s=n.cells[i=o],o=null,s.halfedges.forEach(function(h){var f=n.edges[h],p=f.left;if(!((p===s.site||!p)&&!(p=f.right))){var d=e-p[0],g=t-p[1],_=d*d+g*g;_<u&&(u=_,o=p.index)}});while(o!==null);return n._found=i,r==null||u<=r*r?s.site:null}};function K3t(){var e=O3t,t=z3t,r=null;function n(i){return new F5(i.map(function(o,a){var s=[Math.round(e(o,a,i)/Hr)*Hr,Math.round(t(o,a,i)/Hr)*Hr];return s.index=a,s.data=o,s}),r)}return n.polygons=function(i){return n(i).polygons()},n.links=function(i){return n(i).links()},n.triangles=function(i){return n(i).triangles()},n.x=function(i){return arguments.length?(e=typeof i=="function"?i:h$(+i),n):e},n.y=function(i){return arguments.length?(t=typeof i=="function"?i:h$(+i),n):t},n.extent=function(i){return arguments.length?(r=i==null?null:[[+i[0][0],+i[0][1]],[+i[1][0],+i[1][1]]],n):r&&[[r[0][0],r[0][1]],[r[1][0],r[1][1]]]},n.size=function(i){return arguments.length?(r=i==null?null:[[0,0],[+i[0],+i[1]]],n):r&&[r[1][0]-r[0][0],r[1][1]-r[0][1]]},n}km();function B5(e){return function(){return e}}function g$(e,t,r){this.target=e,this.type=t,this.transform=r}function jh(e,t,r){this.k=e,this.x=t,this.y=r}jh.prototype={constructor:jh,scale:function(e){return e===1?this:new jh(this.k*e,this.x,this.y)},translate:function(e,t){return e===0&t===0?this:new jh(this.k,this.x+this.k*e,this.y+this.k*t)},apply:function(e){return[e[0]*this.k+this.x,e[1]*this.k+this.y]},applyX:function(e){return e*this.k+this.x},applyY:function(e){return e*this.k+this.y},invert:function(e){return[(e[0]-this.x)/this.k,(e[1]-this.y)/this.k]},invertX:function(e){return(e-this.x)/this.k},invertY:function(e){return(e-this.y)/this.k},rescaleX:function(e){return e.copy().domain(e.range().map(this.invertX,this).map(e.invert,e))},rescaleY:function(e){return e.copy().domain(e.range().map(this.invertY,this).map(e.invert,e))},toString:function(){return"translate("+this.x+","+this.y+") scale("+this.k+")"}};var Xh=new jh(1,0,0);i2.prototype=jh.prototype;function i2(e){for(;!e.__zoom;)if(!(e=e.parentNode))return Xh;return e.__zoom}function tR(){qt.stopImmediatePropagation()}function o2(){qt.preventDefault(),qt.stopImmediatePropagation()}function a5e(){return!qt.ctrlKey&&!qt.button}function s5e(){var e=this;return e instanceof SVGElement?(e=e.ownerSVGElement||e,e.hasAttribute("viewBox")?(e=e.viewBox.baseVal,[[e.x,e.y],[e.x+e.width,e.y+e.height]]):[[0,0],[e.width.baseVal.value,e.height.baseVal.value]]):[[0,0],[e.clientWidth,e.clientHeight]]}function Z3t(){return this.__zoom||Xh}function l5e(){return-qt.deltaY*(qt.deltaMode===1?.05:qt.deltaMode?1:.002)}function c5e(){return navigator.maxTouchPoints||"ontouchstart"in this}function u5e(e,t,r){var n=e.invertX(t[0][0])-r[0][0],i=e.invertX(t[1][0])-r[1][0],o=e.invertY(t[0][1])-r[0][1],a=e.invertY(t[1][1])-r[1][1];return e.translate(i>n?(n+i)/2:Math.min(0,n)||Math.max(0,i),a>o?(o+a)/2:Math.min(0,o)||Math.max(0,a))}function eR(){var e=a5e,t=s5e,r=u5e,n=l5e,i=c5e,o=[0,1/0],a=[[-1/0,-1/0],[1/0,1/0]],s=250,l=vL,c=vs("start","zoom","end"),u,h,f=500,p=150,d=0;function g(L){L.property("__zoom",Z3t).on("wheel.zoom",P).on("mousedown.zoom",k).on("dblclick.zoom",O).filter(i).on("touchstart.zoom",D).on("touchmove.zoom",B).on("touchend.zoom touchcancel.zoom",I).style("touch-action","none").style("-webkit-tap-highlight-color","rgba(0,0,0,0)")}g.transform=function(L,R,F){var z=L.selection?L.selection():L;z.property("__zoom",Z3t),L!==z?b(L,R,F):z.interrupt().each(function(){S(this,arguments).start().zoom(null,typeof R=="function"?R.apply(this,arguments):R).end()})},g.scaleBy=function(L,R,F){g.scaleTo(L,function(){var z=this.__zoom.k,U=typeof R=="function"?R.apply(this,arguments):R;return z*U},F)},g.scaleTo=function(L,R,F){g.transform(L,function(){var z=t.apply(this,arguments),U=this.__zoom,W=F==null?x(z):typeof F=="function"?F.apply(this,arguments):F,Z=U.invert(W),rt=typeof R=="function"?R.apply(this,arguments):R;return r(y(_(U,rt),W,Z),z,a)},F)},g.translateBy=function(L,R,F){g.transform(L,function(){return r(this.__zoom.translate(typeof R=="function"?R.apply(this,arguments):R,typeof F=="function"?F.apply(this,arguments):F),t.apply(this,arguments),a)})},g.translateTo=function(L,R,F,z){g.transform(L,function(){var U=t.apply(this,arguments),W=this.__zoom,Z=z==null?x(U):typeof z=="function"?z.apply(this,arguments):z;return r(Xh.translate(Z[0],Z[1]).scale(W.k).translate(typeof R=="function"?-R.apply(this,arguments):-R,typeof F=="function"?-F.apply(this,arguments):-F),U,a)},z)};function _(L,R){return R=Math.max(o[0],Math.min(o[1],R)),R===L.k?L:new jh(R,L.x,L.y)}function y(L,R,F){var z=R[0]-F[0]*L.k,U=R[1]-F[1]*L.k;return z===L.x&&U===L.y?L:new jh(L.k,z,U)}function x(L){return[(+L[0][0]+ +L[1][0])/2,(+L[0][1]+ +L[1][1])/2]}function b(L,R,F){L.on("start.zoom",function(){S(this,arguments).start()}).on("interrupt.zoom end.zoom",function(){S(this,arguments).end()}).tween("zoom",function(){var z=this,U=arguments,W=S(z,U),Z=t.apply(z,U),rt=F==null?x(Z):typeof F=="function"?F.apply(z,U):F,ot=Math.max(Z[1][0]-Z[0][0],Z[1][1]-Z[0][1]),st=z.__zoom,St=typeof R=="function"?R.apply(z,U):R,bt=l(st.invert(rt).concat(ot/st.k),St.invert(rt).concat(ot/St.k));return function(Mt){if(Mt===1)Mt=St;else{var lt=bt(Mt),Kt=ot/lt[2];Mt=new jh(Kt,rt[0]-lt[0]*Kt,rt[1]-lt[1]*Kt)}W.zoom(null,Mt)}})}function S(L,R,F){return!F&&L.__zooming||new C(L,R)}function C(L,R){this.that=L,this.args=R,this.active=0,this.extent=t.apply(L,R),this.taps=0}C.prototype={start:function(){return++this.active===1&&(this.that.__zooming=this,this.emit("start")),this},zoom:function(L,R){return this.mouse&&L!=="mouse"&&(this.mouse[1]=R.invert(this.mouse[0])),this.touch0&&L!=="touch"&&(this.touch0[1]=R.invert(this.touch0[0])),this.touch1&&L!=="touch"&&(this.touch1[1]=R.invert(this.touch1[0])),this.that.__zoom=R,this.emit("zoom"),this},end:function(){return--this.active===0&&(delete this.that.__zooming,this.emit("end")),this},emit:function(L){Mp(new g$(g,L,this.that.__zoom),c.apply,c,[L,this.that,this.args])}};function P(){if(!e.apply(this,arguments))return;var L=S(this,arguments),R=this.__zoom,F=Math.max(o[0],Math.min(o[1],R.k*Math.pow(2,n.apply(this,arguments)))),z=zo(this);if(L.wheel)(L.mouse[0][0]!==z[0]||L.mouse[0][1]!==z[1])&&(L.mouse[1]=R.invert(L.mouse[0]=z)),clearTimeout(L.wheel);else{if(R.k===F)return;L.mouse=[z,R.invert(z)],hu(this),L.start()}o2(),L.wheel=setTimeout(U,p),L.zoom("mouse",r(y(_(R,F),L.mouse[0],L.mouse[1]),L.extent,a));function U(){L.wheel=null,L.end()}}function k(){if(h||!e.apply(this,arguments))return;var L=S(this,arguments,!0),R=Ht(qt.view).on("mousemove.zoom",W,!0).on("mouseup.zoom",Z,!0),F=zo(this),z=qt.clientX,U=qt.clientY;zm(qt.view),tR(),L.mouse=[F,this.__zoom.invert(F)],hu(this),L.start();function W(){if(o2(),!L.moved){var rt=qt.clientX-z,ot=qt.clientY-U;L.moved=rt*rt+ot*ot>d}L.zoom("mouse",r(y(L.that.__zoom,L.mouse[0]=zo(L.that),L.mouse[1]),L.extent,a))}function Z(){R.on("mousemove.zoom mouseup.zoom",null),Fm(qt.view,L.moved),o2(),L.end()}}function O(){if(!!e.apply(this,arguments)){var L=this.__zoom,R=zo(this),F=L.invert(R),z=L.k*(qt.shiftKey?.5:2),U=r(y(_(L,z),R,F),t.apply(this,arguments),a);o2(),s>0?Ht(this).transition().duration(s).call(b,U,R):Ht(this).call(g.transform,U)}}function D(){if(!!e.apply(this,arguments)){var L=qt.touches,R=L.length,F=S(this,arguments,qt.changedTouches.length===R),z,U,W,Z;for(tR(),U=0;U<R;++U)W=L[U],Z=Tp(this,L,W.identifier),Z=[Z,this.__zoom.invert(Z),W.identifier],F.touch0?!F.touch1&&F.touch0[2]!==Z[2]&&(F.touch1=Z,F.taps=0):(F.touch0=Z,z=!0,F.taps=1+!!u);u&&(u=clearTimeout(u)),z&&(F.taps<2&&(u=setTimeout(function(){u=null},f)),hu(this),F.start())}}function B(){if(!!this.__zooming){var L=S(this,arguments),R=qt.changedTouches,F=R.length,z,U,W,Z;for(o2(),u&&(u=clearTimeout(u)),L.taps=0,z=0;z<F;++z)U=R[z],W=Tp(this,R,U.identifier),L.touch0&&L.touch0[2]===U.identifier?L.touch0[0]=W:L.touch1&&L.touch1[2]===U.identifier&&(L.touch1[0]=W);if(U=L.that.__zoom,L.touch1){var rt=L.touch0[0],ot=L.touch0[1],st=L.touch1[0],St=L.touch1[1],bt=(bt=st[0]-rt[0])*bt+(bt=st[1]-rt[1])*bt,Mt=(Mt=St[0]-ot[0])*Mt+(Mt=St[1]-ot[1])*Mt;U=_(U,Math.sqrt(bt/Mt)),W=[(rt[0]+st[0])/2,(rt[1]+st[1])/2],Z=[(ot[0]+St[0])/2,(ot[1]+St[1])/2]}else if(L.touch0)W=L.touch0[0],Z=L.touch0[1];else return;L.zoom("touch",r(y(U,W,Z),L.extent,a))}}function I(){if(!!this.__zooming){var L=S(this,arguments),R=qt.changedTouches,F=R.length,z,U;for(tR(),h&&clearTimeout(h),h=setTimeout(function(){h=null},f),z=0;z<F;++z)U=R[z],L.touch0&&L.touch0[2]===U.identifier?delete L.touch0:L.touch1&&L.touch1[2]===U.identifier&&delete L.touch1;if(L.touch1&&!L.touch0&&(L.touch0=L.touch1,delete L.touch1),L.touch0)L.touch0[1]=this.__zoom.invert(L.touch0[0]);else if(L.end(),L.taps===2){var W=Ht(this).on("dblclick.zoom");W&&W.apply(this,arguments)}}}return g.wheelDelta=function(L){return arguments.length?(n=typeof L=="function"?L:B5(+L),g):n},g.filter=function(L){return arguments.length?(e=typeof L=="function"?L:B5(!!L),g):e},g.touchable=function(L){return arguments.length?(i=typeof L=="function"?L:B5(!!L),g):i},g.extent=function(L){return arguments.length?(t=typeof L=="function"?L:B5([[+L[0][0],+L[0][1]],[+L[1][0],+L[1][1]]]),g):t},g.scaleExtent=function(L){return arguments.length?(o[0]=+L[0],o[1]=+L[1],g):[o[0],o[1]]},g.translateExtent=function(L){return arguments.length?(a[0][0]=+L[0][0],a[1][0]=+L[1][0],a[0][1]=+L[0][1],a[1][1]=+L[1][1],g):[[a[0][0],a[0][1]],[a[1][0],a[1][1]]]},g.constrain=function(L){return arguments.length?(r=L,g):r},g.duration=function(L){return arguments.length?(s=+L,g):s},g.interpolate=function(L){return arguments.length?(l=L,g):l},g.on=function(){var L=c.on.apply(c,arguments);return L===c?g:L},g.clickDistance=function(L){return arguments.length?(d=(L=+L)*L,g):Math.sqrt(d)},g}var J3t=Ee(Oe(),1);var rR=class extends bp{constructor(){super(...arguments),this._experiments=[]}load(){let t=_e().experiments();return this.requestManager.request(t).then(r=>{J3t.isEqual(this._experiments,r)||(this._experiments=r,this.emitChange())})}getExperiments(){return this._experiments.slice()}},nR=new rR;var h5e={googleStandard:["#db4437","#ff7043","#f4b400","#0f9d58","#00796b","#00acc1","#4285f4","#5c6bc0","#ab47bc"],googleCool:["#9e9d24","#0f9d58","#00796b","#00acc1","#4285f4","#5c6bc0","#607d8b"],googleWarm:["#795548","#ab47bc","#f06292","#c2185b","#db4437","#ff7043","#f4b400"],googleColorBlindAssist:["#ff7043","#00ACC1","#AB47BC","#2A56C6","#0b8043","#F7CB4D","#c0ca33","#5e35b1","#A52714"],tensorboardColorBlindAssist:["#ff7043","#0077bb","#cc3311","#33bbee","#ee3377","#009988","#bbbbbb"],colorBlindAssist1:["#4477aa","#44aaaa","#aaaa44","#aa7744","#aa4455","#aa4488"],colorBlindAssist2:["#88ccee","#44aa99","#117733","#999933","#ddcc77","#cc6677","#882255","#aa4499"],colorBlindAssist3:["#332288","#6699cc","#88ccee","#44aa99","#117733","#999933","#ddcc77","#cc6677","#aa4466","#882255","#661100","#aa4499"],colorBlindAssist4:["#4477aa","#66ccee","#228833","#ccbb44","#ee6677","#aa3377","#bbbbbb"],colorBlindAssist5:["#FF6DB6","#920000","#924900","#DBD100","#24FF24","#006DDB","#490092"],mldash:["#E47EAD","#F4640D","#FAA300","#F5E636","#00A077","#0077B8","#00B7ED"]},iR=h5e.tensorboardColorBlindAssist;var _$=class{constructor(t=iR){this.palette=t,this.identifiers=Ji()}setDomain(t){return this.identifiers=Ji(),t.forEach((r,n)=>{this.identifiers.set(r,this.palette[n%this.palette.length])}),this}getColor(t){if(!this.identifiers.has(t))throw new Error(`String ${t} was not in the domain.`);return this.identifiers.get(t)}};function Q3t(e,t){let r=new _$;function n(){r.setDomain(t())}return e.addListener(n),n(),i=>r.getColor(i)}var fn=Q3t(wp,()=>wp.getRuns()),vQr=Q3t(nR,()=>nR.getExperiments().map(({name:e})=>e));var og=Ee(Oe(),1);_s({moduleName:"run-color-style",styleContent:`
    [color-class='light-blue'] paper-checkbox {
      --paper-checkbox-checked-color: var(--paper-light-blue-500);
      --paper-checkbox-checked-ink-color: var(--paper-light-blue-500);
      --paper-checkbox-unchecked-color: var(--paper-light-blue-900);
      --paper-checkbox-unchecked-ink-color: var(--paper-light-blue-900);
    }
    [color-class='red'] paper-checkbox {
      --paper-checkbox-checked-color: var(--paper-red-500);
      --paper-checkbox-checked-ink-color: var(--paper-red-500);
      --paper-checkbox-unchecked-color: var(--paper-red-900);
      --paper-checkbox-unchecked-ink-color: var(--paper-red-900);
    }
    [color-class='green'] paper-checkbox {
      --paper-checkbox-checked-color: var(--paper-green-500);
      --paper-checkbox-checked-ink-color: var(--paper-green-500);
      --paper-checkbox-unchecked-color: var(--paper-green-900);
      --paper-checkbox-unchecked-ink-color: var(--paper-green-900);
    }
    [color-class='purple'] paper-checkbox {
      --paper-checkbox-checked-color: var(--paper-purple-500);
      --paper-checkbox-checked-ink-color: var(--paper-purple-500);
      --paper-checkbox-unchecked-color: var(--paper-purple-900);
      --paper-checkbox-unchecked-ink-color: var(--paper-purple-900);
    }
    [color-class='teal'] paper-checkbox {
      --paper-checkbox-checked-color: var(--paper-teal-500);
      --paper-checkbox-checked-ink-color: var(--paper-teal-500);
      --paper-checkbox-unchecked-color: var(--paper-teal-900);
      --paper-checkbox-unchecked-ink-color: var(--paper-teal-900);
    }
    [color-class='pink'] paper-checkbox {
      --paper-checkbox-checked-color: var(--paper-pink-500);
      --paper-checkbox-checked-ink-color: var(--paper-pink-500);
      --paper-checkbox-unchecked-color: var(--paper-pink-900);
      --paper-checkbox-unchecked-ink-color: var(--paper-pink-900);
    }
    [color-class='orange'] paper-checkbox {
      --paper-checkbox-checked-color: var(--paper-orange-500);
      --paper-checkbox-checked-ink-color: var(--paper-orange-500);
      --paper-checkbox-unchecked-color: var(--paper-orange-900);
      --paper-checkbox-unchecked-ink-color: var(--paper-orange-900);
    }
    [color-class='brown'] paper-checkbox {
      --paper-checkbox-checked-color: var(--paper-brown-500);
      --paper-checkbox-checked-ink-color: var(--paper-brown-500);
      --paper-checkbox-unchecked-color: var(--paper-brown-900);
      --paper-checkbox-unchecked-ink-color: var(--paper-brown-900);
    }
    [color-class='indigo'] paper-checkbox {
      --paper-checkbox-checked-color: var(--paper-indigo-500);
      --paper-checkbox-checked-ink-color: var(--paper-indigo-500);
      --paper-checkbox-unchecked-color: var(--paper-indigo-900);
      --paper-checkbox-unchecked-ink-color: var(--paper-indigo-900);
    }
  `});var ol=class extends Gt(mt){constructor(){super(...arguments),this.names=[],this.coloring={getColor:()=>""},this.regex="",this.selectionState={},this.maxNamesToEnableByDefault=40,this._debouncedRegexChange=this._debouncedRegexChangeImpl()}_debouncedRegexChangeImpl(){var t=og.debounce(r=>{this.regex=r},150,{leading:!1});return function(){var r=this.$$("#names-regex").value;r==""?this.async(()=>{this.regex=r},30):t(r)}}get _regex(){var t=this.regex;try{return new RegExp(t)}catch(r){return null}}_setIsolatorIcon(){var i;var t=this.selectionState,r=og.filter(og.values(t)).length,n=Array.prototype.slice.call((i=this.root)==null?void 0:i.querySelectorAll(".isolator"));n.forEach(function(o){r===1&&t[o.name]?o.icon="radio-button-checked":o.icon="radio-button-unchecked"})}computeNamesMatchingRegex(t,r){let n=this._regex;return n?this.names.filter(i=>n.test(i)):this.names}computeOutSelected(t,r){var n=this.selectionState,i=this.maxNamesToEnableByDefault,o=this.namesMatchingRegex.length<=i;return this.namesMatchingRegex.filter(a=>n[a]==null?o:n[a])}synchronizeColors(t){var i,o,a,s;this._setIsolatorIcon(),((o=(i=this.root)==null?void 0:i.querySelectorAll("paper-checkbox"))!=null?o:[]).forEach(l=>{let c=this.coloring.getColor(l.name);l.updateStyles({"--paper-checkbox-checked-color":c,"--paper-checkbox-checked-ink-color":c,"--paper-checkbox-unchecked-color":c,"--paper-checkbox-unchecked-ink-color":c})}),((s=(a=this.root)==null?void 0:a.querySelectorAll(".isolator"))!=null?s:[]).forEach(l=>{let c=this.coloring.getColor(l.name);l.style.color=c}),window.requestAnimationFrame(()=>{this.updateStyles()})}_isolateName(t){var r=t.target.name,n={};this.names.forEach(function(i){n[i]=i==r}),this.selectionState=n}_checkboxChange(t){var r=t.target;let n=og.clone(this.selectionState);n[r.name]=r.checked,this.selectionState=n}_isChecked(t,r){return this.outSelected.indexOf(t)!=-1}toggleAll(){let t=this.namesMatchingRegex.some(n=>this.outSelected.includes(n)),r={};this.names.forEach(n=>{r[n]=!t}),this.selectionState=r}};ol.template=Q`
    <style include="scrollbar-style"></style>
    <style include="run-color-style"></style>

    <paper-input
      id="names-regex"
      no-label-float=""
      label="Write a regex to filter runs"
      value="[[regex]]"
      on-bind-value-changed="_debouncedRegexChange"
    ></paper-input>
    <div id="outer-container" class="scrollbar">
      <template
        is="dom-repeat"
        items="[[namesMatchingRegex]]"
        on-dom-change="synchronizeColors"
      >
        <div class="name-row">
          <div
            class="icon-container checkbox-container vertical-align-container"
          >
            <paper-checkbox
              class="checkbox vertical-align-center"
              id$="checkbox-[[item]]"
              name="[[item]]"
              checked$="[[_isChecked(item, selectionState.*)]]"
              on-change="_checkboxChange"
            ></paper-checkbox>
          </div>
          <div
            class="icon-container isolator-container vertical-align-container"
          >
            <paper-icon-button
              icon="radio-button-unchecked"
              class="isolator vertical-align-center"
              on-tap="_isolateName"
              name="[[item]]"
            ></paper-icon-button>
          </div>
          <div class="item-label-container">
            <span>[[item]]</span>
          </div>
        </div>
      </template>
    </div>
    <style>
      paper-input {
        --paper-input-container-focus-color: var(--tb-orange-strong);
        --paper-input-container-input: {
          font-size: 14px;
        }
        --paper-input-container-label: {
          font-size: 14px;
        }
      }
      :host {
        display: flex;
        flex-direction: column;
        height: 100%;
        overflow: hidden;
      }
      #outer-container {
        contain: content;
        flex-grow: 1;
        flex-shrink: 1;
        overflow-x: hidden;
        overflow-y: auto;
        width: 100%;
        will-change: transform;
        word-wrap: break-word;
      }
      .name-row {
        contain: content;
        padding-top: 5px;
        padding-bottom: 5px;
        display: flex;
        flex-direction: row;
        font-size: 13px;
        word-break: break-all; /* makes wrapping of hyperparam strings better */
      }
      .icon-container {
        flex-grow: 0;
        flex-shrink: 0;
        padding-left: 2px;
      }
      .checkbox {
        padding-left: 2px;
        width: 18px;
        height: 18px;
      }
      .isolator {
        width: 18px;
        height: 18px;
        padding: 0px;
      }
      .isolator-container {
        padding-left: 6px;
        padding-right: 3px;
      }
      .checkbox-container {
        padding-left: 2px;
      }
      .item-label-container {
        padding-left: 5px;
        flex-grow: 1;
        flex-shrink: 1;
        width: 0px; /* hack to get the flex-grow to work properly */
      }
      .tooltip-value-container {
        display: flex;
        justify-content: center;
        flex-grow: 0;
        flex-shrink: 0;
        text-align: right;
        padding-left: 2px;
      }
      .vertical-align-container {
        display: flex;
        justify-content: center;
      }
      .vertical-align-container .vertical-align-center {
        align-self: center;
      }
      .vertical-align-container .vertical-align-top {
        align-self: start;
      }
    </style>
  `;E([A({type:Array}),w("design:type",Array)],ol.prototype,"names",void 0);E([A({type:Object}),w("design:type",Object)],ol.prototype,"coloring",void 0);E([A({type:String,notify:!0}),w("design:type",String)],ol.prototype,"regex",void 0);E([A({type:Array,computed:"computeNamesMatchingRegex(names.*, _regex)"}),w("design:type",Array)],ol.prototype,"namesMatchingRegex",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],ol.prototype,"selectionState",void 0);E([A({type:Array,notify:!0,computed:"computeOutSelected(namesMatchingRegex.*, selectionState.*)"}),w("design:type",Array)],ol.prototype,"outSelected",void 0);E([A({type:Number}),w("design:type",Number)],ol.prototype,"maxNamesToEnableByDefault",void 0);E([A({type:Object}),w("design:type",Object)],ol.prototype,"_debouncedRegexChange",void 0);E([Rt("regex"),w("design:type",Object),w("design:paramtypes",[])],ol.prototype,"_regex",null);E([Bt("selectionState","names"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],ol.prototype,"_setIsolatorIcon",null);ol=E([yt("tf-multi-checkbox")],ol);var a2=class extends mt{get _parts(){var t=this.value,r=this.delimiterPattern;let n=[];for(;;){let i=new RegExp(r,"g");if(i.test(t),i.lastIndex===0){n.push(t);break}else n.push(t.slice(0,i.lastIndex)),t=t.slice(i.lastIndex)}return n}};a2.template=Q`
    <!--
      This ugly formatting is required to prevent spaces from slipping
      into the HTML.
    -->
    <template is="dom-repeat" items="[[_parts]]" as="part"
      >[[part]]<wbr
    /></template>
  `;E([A({type:String}),w("design:type",String)],a2.prototype,"value",void 0);E([A({type:String}),w("design:type",String)],a2.prototype,"delimiterPattern",void 0);E([Rt("value","delimiterPattern"),w("design:type",Array),w("design:paramtypes",[])],a2.prototype,"_parts",null);a2=E([yt("tf-wbr-string")],a2);var mc=class extends Gt(mt){constructor(){super(...arguments),this.runSelectionState=OW("runSelectionState",{defaultValue:{}}).call(this),this.regexInput=y_("regexInput",{defaultValue:""}).call(this),this._dataLocationClipLength=250,this._dataLocationDelimiterPattern="[/=_,-]",this.coloring={getColor:fn},this._storeRunSelectionState=zW("runSelectionState",{defaultValue:{}}),this._regexObserver=v_("regexInput",{defaultValue:""})}attached(){this._runStoreListener=wp.addListener(()=>{this.set("runs",wp.getRuns())}),this.set("runs",wp.getRuns()),this._envStoreListener=ib.addListener(()=>{this.set("dataLocation",ib.getDataLocation())}),this.set("dataLocation",ib.getDataLocation())}detached(){wp.removeListenerByKey(this._runStoreListener),ib.removeListenerByKey(this._envStoreListener)}_toggleAll(){this.$.multiCheckbox.toggleAll()}get _clippedDataLocation(){var t=this.dataLocation,r=this._dataLocationClipLength;if(t!==void 0)return t.length>r?t.substring(0,r):t}_openDataLocationDialog(t){t.preventDefault(),this.$$("#data-location-dialog").open()}_shouldShowExpandDataLocationButton(t,r){return t&&t.length>r}};mc.template=Q`
    <paper-dialog with-backdrop="" id="data-location-dialog">
      <h2>Data Location</h2>
      <tf-wbr-string
        value="[[dataLocation]]"
        delimiter-pattern="[[_dataLocationDelimiterPattern]]"
      >
      </tf-wbr-string
    ></paper-dialog>
    <div id="top-text">
      <h3 id="tooltip-help" class="tooltip-container">Runs</h3>
    </div>
    <tf-multi-checkbox
      id="multiCheckbox"
      names="[[runs]]"
      selection-state="{{runSelectionState}}"
      out-selected="{{selectedRuns}}"
      regex="{{regexInput}}"
      coloring="[[coloring]]"
    ></tf-multi-checkbox>
    <paper-button class="x-button" id="toggle-all" on-tap="_toggleAll">
      Toggle All Runs
    </paper-button>
    <template is="dom-if" if="[[dataLocation]]">
      <div id="data-location">
        <tf-wbr-string
          value="[[_clippedDataLocation]]"
          delimiter-pattern="[[_dataLocationDelimiterPattern]]"
        ></tf-wbr-string
        ><!--
          We use HTML comments to remove spaces before the ellipsis.
        --><template
          is="dom-if"
          if="[[_shouldShowExpandDataLocationButton(dataLocation, _dataLocationClipLength)]]"
          ><!--
          --><a href="" on-click="_openDataLocationDialog">…</a>
        </template>
      </div>
    </template>
    <style>
      :host {
        box-sizing: border-box;
        display: flex;
        flex-direction: column;
        padding-bottom: 10px;
      }
      #top-text {
        color: var(--tb-secondary-text-color);
        width: 100%;
        flex-grow: 0;
        flex-shrink: 0;
        padding-right: 16px;
        box-sizing: border-box;
      }
      tf-wbr-string {
        overflow-wrap: break-word;
      }
      tf-multi-checkbox {
        display: flex;
        flex-grow: 1;
        flex-shrink: 1;
        overflow: hidden;
      }
      .x-button {
        font-size: 13px;
        background-color: var(--tb-ui-light-accent);
        color: var(--tb-ui-dark-accent);
      }
      #tooltip-help {
        color: var(--tb-secondary-text-color);
        margin: 0;
        font-weight: normal;
        font-size: 14px;
        margin-bottom: 5px;
      }
      paper-button {
        margin-left: 0;
      }
      #data-location {
        color: var(--tb-ui-dark-accent);
        font-size: 13px;
        margin: 5px 0 0 0;
        max-width: 288px;
      }
    </style>
  `;E([A({type:Object,observer:"_storeRunSelectionState"}),w("design:type",Object)],mc.prototype,"runSelectionState",void 0);E([A({type:String,observer:"_regexObserver"}),w("design:type",String)],mc.prototype,"regexInput",void 0);E([A({type:Array,notify:!0}),w("design:type",Array)],mc.prototype,"selectedRuns",void 0);E([A({type:Array}),w("design:type",Array)],mc.prototype,"runs",void 0);E([A({type:String,notify:!0}),w("design:type",String)],mc.prototype,"dataLocation",void 0);E([A({type:Number}),w("design:type",Number)],mc.prototype,"_dataLocationClipLength",void 0);E([A({type:String}),w("design:type",String)],mc.prototype,"_dataLocationDelimiterPattern",void 0);E([A({type:Object}),w("design:type",Object)],mc.prototype,"coloring",void 0);E([Rt("dataLocation","_dataLocationClipLength"),w("design:type",Object),w("design:paramtypes",[])],mc.prototype,"_clippedDataLocation",null);mc=E([yt("tf-runs-selector")],mc);var an=class{constructor(){this.cancellationCount=0}cancellable(t){let r=this.cancellationCount;return n=>{let i=this.cancellationCount!==r;return t({value:n,cancelled:i})}}cancelAll(){this.cancellationCount++}};var H5=class extends Gt(mt){constructor(){super(...arguments),this.html=""}get sanitizedHtml(){return this.html}attached(){window.requestAnimationFrame(()=>{this.scopeSubtree(this.$.markdown,!0)})}};H5.template=Q`
    <div id="markdown" inner-h-t-m-l="[[sanitizedHtml]]"></div>
    <style>
      /*
       * Reduce topmost and bottommost margins from 16px to 0.3em (renders
       * at about 4.8px) to keep the layout compact. This improves the
       * appearance when there is only one line of text; standard Markdown
       * renderers will still include a \`<p>\` element.
       *
       * By targeting only the top-level, extremal elements, we preserve any
       * actual paragraph breaks and only change the padding against the
       * component edges.
       */
      #markdown > p:first-child {
        margin-top: 0.3em;
      }
      #markdown > p:last-child {
        margin-bottom: 0.3em;
      }

      /* Pleasant styles for Markdown tables. */
      #markdown table {
        border-collapse: collapse;
      }
      #markdown table th {
        font-weight: 600;
      }
      #markdown table th,
      #markdown table td {
        padding: 6px 13px;
        border: 1px solid var(--tb-ui-border, #dfe2e5);
      }
      #markdown table tr {
        background-color: inherit;
        border-top: 1px solid var(--tb-ui-border, #c6cbd1);
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],H5.prototype,"html",void 0);E([Rt("html"),w("design:type",Object),w("design:paramtypes",[])],H5.prototype,"sanitizedHtml",null);H5=E([yt("tf-markdown-view")],H5);_s({moduleName:"tf-card-heading-style",styleContent:`
    figcaption {
      width: 100%;
    }

    /** Horizontal line of labels. */
    .heading-row {
      margin-top: -4px;
      display: flex;
      flex-direction: row;
      flex-wrap: wrap;
    }

    /** Piece of text in the figure caption. */
    .heading-label {
      flex-grow: 1;
      margin-top: 4px;
      max-width: 100%;
      word-wrap: break-word;
    }

    /** Makes label show on the right. */
    .heading-right {
      flex-grow: 0;
    }
  `});function s2(e){return e?e.toString().replace(/GMT-\d+ \(([^)]+)\)/,"$1"):""}function tMt(e){let t=p5e(e);return t?Math.round((t[0]*299+t[1]*587+t[2]*114)/1e3)>125?"inherit":"#eee":"inherit"}function p5e(e){if(!e)return null;let t=e.match(/^#([0-9a-f]{1,2})([0-9a-f]{1,2})([0-9a-f]{1,2})$/);if(!t)return null;if(e.length==4)for(var r=1;r<=3;r++)t[r]=t[r]+t[r];return[parseInt(t[1],16),parseInt(t[2],16),parseInt(t[3],16)]}var gc=class extends mt{constructor(){super(...arguments),this.displayName=null,this.tag=null,this.run=null,this.description=null,this.color=null}_updateHeadingStyle(){this.updateStyles({"--tf-card-heading-background-color":this._runBackground,"--tf-card-heading-color":this._runColor})}_computeRunBackground(t){return t||"none"}_computeRunColor(t){return tMt(t)}get _nameLabel(){var t=this.displayName,r=this.tag;return t||r||""}get _tagLabel(){var t=this.displayName,r=this.tag;return r&&r!==t?r:""}_toggleDescriptionDialog(t){let r=this.$.descriptionDialog;r.positionTarget=t.target,r.toggle()}};gc.template=Q`
    <div class="container">
      <figcaption class="content">
        <div class="heading-row">
          <template is="dom-if" if="[[_nameLabel]]">
            <div itemprop="name" class="heading-label name">[[_nameLabel]]</div>
          </template>
          <template is="dom-if" if="[[run]]">
            <!-- Extra wrapping span needed to avoid flexbox blockification. -->
            <!-- (see flexbox spec, section 4 "Flex Items") -->
            <span>
              <span
                itemprop="run"
                id="heading-run"
                class="heading-label heading-right run"
                >[[run]]</span
              >
            </span>
          </template>
        </div>
        <template is="dom-if" if="[[_tagLabel]]">
          <div class="heading-row">
            <div class="heading-label">
              tag: <span itemprop="tag">[[_tagLabel]]</span>
            </div>
          </div>
        </template>
        <slot></slot>
      </figcaption>
      <template is="dom-if" if="[[description]]">
        <paper-icon-button
          icon="info"
          on-tap="_toggleDescriptionDialog"
          title="Show summary description"
        ></paper-icon-button>
      </template>
      <paper-dialog
        id="descriptionDialog"
        no-overlap=""
        horizontal-align="auto"
        vertical-align="auto"
      >
        <paper-dialog-scrollable>
          <tf-markdown-view html="[[description]]"></tf-markdown-view>
        </paper-dialog-scrollable>
      </paper-dialog>
    </div>
    <style include="tf-card-heading-style">
      .container {
        display: flex;
      }
      .content {
        font-size: 12px;
        flex-grow: 1;
      }
      .name {
        font-size: 14px;
      }
      .run {
        font-size: 11px;
        width: auto;
        border-radius: 3px;
        font-weight: bold;
        padding: 1px 4px 2px;
      }
      paper-icon-button {
        flex-grow: 0;
      }
      paper-dialog-scrollable {
        max-width: 640px;
      }
      #heading-run {
        background: var(--tf-card-heading-background-color);
        color: var(--tf-card-heading-color);
      }
    </style>
  `;E([A({type:String}),w("design:type",Object)],gc.prototype,"displayName",void 0);E([A({type:String}),w("design:type",Object)],gc.prototype,"tag",void 0);E([A({type:String}),w("design:type",Object)],gc.prototype,"run",void 0);E([A({type:String}),w("design:type",Object)],gc.prototype,"description",void 0);E([A({type:String}),w("design:type",Object)],gc.prototype,"color",void 0);E([A({type:String,computed:"_computeRunBackground(color)",readOnly:!0,observer:"_updateHeadingStyle"}),w("design:type",String)],gc.prototype,"_runBackground",void 0);E([A({type:String,computed:"_computeRunColor(color)",readOnly:!0,observer:"_updateHeadingStyle"}),w("design:type",String)],gc.prototype,"_runColor",void 0);E([Rt("displayName","tag"),w("design:type",String),w("design:paramtypes",[])],gc.prototype,"_nameLabel",null);E([Rt("displayName","tag"),w("design:type",String),w("design:paramtypes",[])],gc.prototype,"_tagLabel",null);gc=E([yt("tf-card-heading")],gc);var Fi=class extends Gt(mt){constructor(){super(...arguments),this._metadataCanceller=new an,this._steps=[],this._attached=!1}get _runColor(){var t=this.run;return fn(t)}get _hasAtLeastOneStep(){var t=this._steps;return!!t&&t.length>0}get _hasMultipleSteps(){var t=this._steps;return!!t&&t.length>1}get _maxStepIndex(){var t=this._steps;return t.length-1}get _currentDatum(){var t=this._steps,r=this._stepIndex;return t[r]}get _sampleText(){var t=this.sample;return`${t+1}`}get _hasMultipleSamples(){var t=this.totalSamples;return t>1}attached(){this._attached=!0,this.reload()}_reloadOnRunTagChange(){this.reload()}reload(){if(!this._attached)return;this._metadataCanceller.cancelAll();let r=_e().pluginRoute("audio","/audio",new URLSearchParams({tag:this.tag,run:this.run,sample:String(this.sample)})),n=this._metadataCanceller.cancellable(i=>{if(i.cancelled)return;let a=i.value.map(this._createStepDatum.bind(this));this.set("_steps",a),this.set("_stepIndex",a.length-1)});this.requestManager.request(r).then(n)}_createStepDatum(t){let r=new URLSearchParams(t.query);r.append("ts",String(t.wall_time));let n=_e().pluginRouteForSrc("audio","/individualAudio",r);return{wall_time:s2(new Date(t.wall_time*1e3)),step:t.step,label:t.label,contentType:t.contentType,url:n}}};Fi.template=Q`
    <tf-card-heading
      tag="[[tag]]"
      run="[[run]]"
      display-name="[[tagMetadata.displayName]]"
      description="[[tagMetadata.description]]"
      color="[[_runColor]]"
    >
      <template is="dom-if" if="[[_hasMultipleSamples]]">
        <div class="heading-row">
          <div class="heading-label">
            sample: [[_sampleText]] of [[totalSamples]]
          </div>
        </div>
      </template>
      <template is="dom-if" if="[[_hasAtLeastOneStep]]">
        <div class="heading-row">
          <div class="heading-label">
            step <strong>[[_currentDatum.step]]</strong>
          </div>
          <template is="dom-if" if="[[_currentDatum.wall_time]]">
            <div class="heading-label heading-right">
              [[_currentDatum.wall_time]]
            </div>
          </template>
        </div>
      </template>
      <template is="dom-if" if="[[_hasMultipleSteps]]">
        <div class="heading-row">
          <paper-slider
            id="steps"
            immediate-value="{{_stepIndex}}"
            max="[[_maxStepIndex]]"
            max-markers="[[_maxStepIndex]]"
            snaps=""
            step="1"
            value="{{_stepIndex}}"
          ></paper-slider>
        </div>
      </template>
    </tf-card-heading>
    <template is="dom-if" if="[[_hasAtLeastOneStep]]">
      <audio
        controls=""
        src$="[[_currentDatum.url]]"
        type$="[[_currentDatum.contentType]]"
      ></audio>
      <tf-markdown-view html="[[_currentDatum.label]]"></tf-markdown-view>
    </template>
    <div id="main-audio-container"></div>

    <style include="tf-card-heading-style">
      :host {
        display: block;
        width: 350px;
        height: auto;
        position: relative;
        --step-slider-knob-color: #424242;
        margin-right: 15px;
        margin-bottom: 15px;
      }

      #steps {
        height: 15px;
        margin: 0 0 0 -15px;
        width: 100%;
        box-sizing: border-box;
        padding: 0 5px; /* so the slider knob doesn't butt out */
        margin-top: 5px;
        --paper-slider-active-color: var(--step-slider-knob-color);
        --paper-slider-knob-color: var(--step-slider-knob-color);
        --paper-slider-pin-color: var(--step-slider-knob-color);
        --paper-slider-knob-start-color: var(--step-slider-knob-color);
        --paper-slider-knob-start-border-color: var(--step-slider-knob-color);
        --paper-slider-pin-start-color: var(--step-slider-knob-color);
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],Fi.prototype,"run",void 0);E([A({type:String}),w("design:type",String)],Fi.prototype,"tag",void 0);E([A({type:Number}),w("design:type",Number)],Fi.prototype,"sample",void 0);E([A({type:Number}),w("design:type",Number)],Fi.prototype,"totalSamples",void 0);E([A({type:Object}),w("design:type",Object)],Fi.prototype,"tagMetadata",void 0);E([A({type:Object}),w("design:type",Ae)],Fi.prototype,"requestManager",void 0);E([A({type:Object}),w("design:type",an)],Fi.prototype,"_metadataCanceller",void 0);E([A({type:Array}),w("design:type",Array)],Fi.prototype,"_steps",void 0);E([A({type:Number}),w("design:type",Number)],Fi.prototype,"_stepIndex",void 0);E([Rt("run"),w("design:type",String),w("design:paramtypes",[])],Fi.prototype,"_runColor",null);E([Rt("_steps"),w("design:type",Boolean),w("design:paramtypes",[])],Fi.prototype,"_hasAtLeastOneStep",null);E([Rt("_steps"),w("design:type",Boolean),w("design:paramtypes",[])],Fi.prototype,"_hasMultipleSteps",null);E([Rt("_steps"),w("design:type",Number),w("design:paramtypes",[])],Fi.prototype,"_maxStepIndex",null);E([Rt("_steps","_stepIndex"),w("design:type",Object),w("design:paramtypes",[])],Fi.prototype,"_currentDatum",null);E([Rt("sample"),w("design:type",String),w("design:paramtypes",[])],Fi.prototype,"_sampleText",null);E([Rt("totalSamples"),w("design:type",Boolean),w("design:paramtypes",[])],Fi.prototype,"_hasMultipleSamples",null);E([Bt("run","tag"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Fi.prototype,"_reloadOnRunTagChange",null);Fi=E([yt("tf-audio-loader")],Fi);var $h=class extends Gt(mt){constructor(){super(...arguments),this.reloadOnReady=!0,this._tagFilter="",this._requestManager=new Ae}ready(){super.ready(),this.reloadOnReady&&this.reload()}reload(){this._fetchTags().then(()=>{this._reloadAudio()})}_fetchTags(){let t=_e().pluginRoute("audio","/tags");return this._requestManager.request(t).then(r=>{if(fy.isEqual(r,this._runToTagInfo))return;let n=fy.mapValues(r,o=>Object.keys(o)),i=$i(n);this.set("_dataNotFound",i.length===0),this.set("_runToTagInfo",r)})}_reloadAudio(){var t;(t=this.root)==null||t.querySelectorAll("tf-audio-loader").forEach(r=>{r.reload()})}_shouldOpen(t){return t<=2}get _categories(){var t=this._runToTagInfo,r=this._selectedRuns,n=this._tagFilter;let i=fy.mapValues(t,l=>Object.keys(l)),o=Ql(i,r,n);function a(l){let c=t[l.run][l.tag].samples;return fy.range(c).map(u=>Object.assign({},l,{sample:u,totalSamples:c}))}return o.map(l=>Object.assign({},l,{items:[].concat.apply([],l.items.map(a))}))}_tagMetadata(t,r,n){return t[r][n]}};$h.template=Q`
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <div class="sidebar-section runs-selector">
          <tf-runs-selector
            id="runs-selector"
            selected-runs="{{_selectedRuns}}"
          ></tf-runs-selector>
        </div>
      </div>
      <div class="center" slot="center">
        <template is="dom-if" if="[[_dataNotFound]]">
          <div class="no-data-warning">
            <h3>No audio data was found.</h3>
            <p>Probable causes:</p>
            <ul>
              <li>You haven’t written any audio data to your event files.</li>
              <li>TensorBoard can’t find your event files.</li>
            </ul>

            <p>
              If you’re new to using TensorBoard, and want to find out how to
              add data and set up your event files, check out the
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
                >README</a
              >
              and perhaps the
              <a
                href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
                >TensorBoard tutorial</a
              >.
            </p>

            <p>
              If you think TensorBoard is configured properly, please see
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"
                >the section of the README devoted to missing data problems</a
              >
              and consider filing an issue on GitHub.
            </p>
          </div>
        </template>
        <template is="dom-if" if="[[!_dataNotFound]]">
          <tf-tag-filterer tag-filter="{{_tagFilter}}"></tf-tag-filterer>
          <template is="dom-repeat" items="[[_categories]]" as="category">
            <tf-category-paginated-view
              category="[[category]]"
              initial-opened="[[_shouldOpen(index)]]"
            >
              <template>
                <tf-audio-loader
                  active="[[active]]"
                  run="[[item.run]]"
                  tag="[[item.tag]]"
                  sample="[[item.sample]]"
                  total-samples="[[item.totalSamples]]"
                  tag-metadata="[[_tagMetadata(_runToTagInfo, item.run, item.tag)]]"
                  request-manager="[[_requestManager]]"
                ></tf-audio-loader>
              </template>
            </tf-category-paginated-view>
          </template>
        </template>
      </div>
    </tf-dashboard-layout>
    <style include="dashboard-style"></style>
    <style>
      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }
    </style>
  `;E([A({type:Boolean}),w("design:type",Boolean)],$h.prototype,"reloadOnReady",void 0);E([A({type:Array}),w("design:type",Array)],$h.prototype,"_selectedRuns",void 0);E([A({type:Object}),w("design:type",Object)],$h.prototype,"_runToTagInfo",void 0);E([A({type:Boolean}),w("design:type",Boolean)],$h.prototype,"_dataNotFound",void 0);E([A({type:String}),w("design:type",String)],$h.prototype,"_tagFilter",void 0);E([A({type:Object}),w("design:type",Ae)],$h.prototype,"_requestManager",void 0);E([Rt("_runToTagInfo","_selectedRuns","_tagFilter"),w("design:type",Array),w("design:paramtypes",[])],$h.prototype,"_categories",null);$h=E([yt("tf-audio-dashboard")],$h);var V5=class extends Gt(mt){attached(){this.async(function(){this.getEffectiveChildren().forEach(function(t){this.listen(t,"tap","_selectTarget")}.bind(this))})}_selectTarget(t){this.selectedId=t.currentTarget.id}_selectedIdChanged(){var t=this.queryEffectiveChildren("#"+this.selectedId);!t||(this.getEffectiveChildren().forEach(function(r){r.classList.remove("selected")}),t.classList.add("selected"))}};V5.template=Q`
    <div id="wrap">
      <h3>[[name]]</h3>
      <div class="content-wrapper"><slot></slot></div>
    </div>
    <style>
      .content-wrapper ::slotted(*) {
        background: none;
        color: var(--tb-ui-dark-accent);
        font-size: 13px;
        margin-top: 10px;
      }

      .content-wrapper ::slotted(*) {
        background: none;
        color: var(--tb-ui-dark-accent);
        font-size: 13px;
        margin-top: 10px;
      }

      .content-wrapper ::slotted(.selected) {
        background-color: var(--tb-ui-dark-accent);
        color: white !important;
      }

      h3 {
        color: var(--tb-secondary-text-color);
        display: block;
        font-size: 14px;
        font-weight: normal;
        margin: 0 0 5px;
        pointer-events: none;
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],V5.prototype,"name",void 0);E([A({type:String,notify:!0,observer:"_selectedIdChanged"}),w("design:type",String)],V5.prototype,"selectedId",void 0);V5=E([yt("tf-option-selector")],V5);function oR(e,t){let r,n={};Object.keys(e).forEach(a=>{let s=e[a];r===void 0&&(r=s.displayName),r!==s.displayName&&(r=null),n[s.description]===void 0&&(n[s.description]=[]),n[s.description].push(a)});let i=r!=null?r:t,o=(()=>{let a=Object.keys(n);return a.length===0?"":a.length===1?a[0]:`<p><strong>Multiple descriptions:</strong></p><ul>${a.map(c=>{let u=n[c].map(p=>`<code>${p.replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/&/g,"&amp;")}</code>`),h=u.length>2?u.slice(0,u.length-1).join(", ")+", and "+u[u.length-1]:u.join(" and ");return`<li><p>For ${d5e(u.length,"run","runs")} ${h}:</p>${c}</li>`}).join("")}</ul>`})();return{displayName:i,description:o}}function d5e(e,t,r){return e===1?t:r}var rMt=Ee(Oe(),1);var Hp=class extends mt{constructor(){super(...arguments),this.weight=.6,this._updateWeight=rMt.debounce(function(t){this.weight=t},250)}_immediateWeightNumberForPaperSliderChanged(){this._inputWeightStringForPaperInput=this._immediateWeightNumberForPaperSlider.toString(),this._updateWeight.call(this,this._immediateWeightNumberForPaperSlider)}_inputWeightStringForPaperInputChanged(){+this._inputWeightStringForPaperInput<0?this._inputWeightStringForPaperInput="0":+this._inputWeightStringForPaperInput>1&&(this._inputWeightStringForPaperInput="1");var t=+this._inputWeightStringForPaperInput;isNaN(t)||this._updateWeight.call(this,t)}};Hp.template=Q`
    <h3 class="title">Smoothing</h3>
    <div class="smoothing-block">
      <paper-slider
        id="slider"
        immediate-value="{{_immediateWeightNumberForPaperSlider}}"
        max="[[max]]"
        min="[[min]]"
        pin
        step="[[step]]"
        type="number"
        value="{{weight}}"
      ></paper-slider>
      <paper-input
        id="input"
        label="weight"
        no-label-float
        value="{{_inputWeightStringForPaperInput}}"
        type="number"
        step="[[step]]"
        min="[[min]]"
        max="[[max]]"
      ></paper-input>
    </div>
    <style>
      .title {
        color: var(--tb-secondary-text-color);
        margin: 0;
        font-weight: normal;
        font-size: 14px;
        margin-bottom: 5px;
      }

      .smoothing-block {
        display: flex;
      }

      paper-slider {
        --paper-slider-active-color: var(--tb-orange-strong);
        --paper-slider-knob-color: var(--tb-orange-strong);
        --paper-slider-knob-start-border-color: var(--tb-orange-strong);
        --paper-slider-knob-start-color: var(--tb-orange-strong);
        --paper-slider-markers-color: var(--tb-orange-strong);
        --paper-slider-pin-color: var(--tb-orange-strong);
        --paper-slider-pin-start-color: var(--tb-orange-strong);
        flex-grow: 2;
      }

      paper-input {
        --paper-input-container-focus-color: var(--tb-orange-strong);
        --paper-input-container-input: {
          font-size: 14px;
        }
        --paper-input-container-label: {
          font-size: 14px;
        }
        width: 60px;
      }
    </style>
  `;E([A({type:Number}),w("design:type",Number)],Hp.prototype,"step",void 0);E([A({type:Number}),w("design:type",Number)],Hp.prototype,"max",void 0);E([A({type:Number}),w("design:type",Number)],Hp.prototype,"min",void 0);E([A({type:Number,notify:!0}),w("design:type",Number)],Hp.prototype,"weight",void 0);E([A({type:Number,notify:!0,observer:"_immediateWeightNumberForPaperSliderChanged"}),w("design:type",Number)],Hp.prototype,"_immediateWeightNumberForPaperSlider",void 0);E([A({type:String,notify:!0,observer:"_inputWeightStringForPaperInputChanged"}),w("design:type",String)],Hp.prototype,"_inputWeightStringForPaperInput",void 0);Hp=E([yt("tf-smoothing-input")],Hp);var Yo=Ee(Oe(),1);function Mi(e,t){let r=Object.keys(t).sort().filter(a=>t[a]!==void 0);if(!r.length)return e;let n=e.indexOf("?")!==-1?"&":"?",o=Array().concat(...r.map(a=>{let s=t[a];return(Array.isArray(s)?s:[s]).map(c=>`${a}=${m5e(c)}`)})).join("&");return e+n+o}function m5e(e){return encodeURIComponent(e).replace(/\(/g,"%28").replace(/\)/g,"%29")}var $Kt=Ee(Oe(),1),ZWn=Ee(wl(),1);var DKt=Ee(Oe(),1);var x4;(function(e){e[e.LOADING=0]="LOADING",e[e.LOADED=1]="LOADED"})(x4||(x4={}));function kS(e){return class extends e{constructor(){super(...arguments),this.loadKey="",this.dataToLoad=[],this.getDataLoadName=r=>String(r),this.dataLoading=!1,this.dataLoadedAtLeastOnce=!1,this._isConnected=!1,this._dataLoadState=new Map,this._canceller=new an,this._loadDataAsync=null,this._loadData=DKt.throttle(this._loadDataImpl,100,{leading:!0,trailing:!0})}connectedCallback(){super.connectedCallback(),this._isConnected=!0}disconnectedCallback(){super.disconnectedCallback(),this._isConnected=!1}static get properties(){return{active:{type:Boolean,observer:"_loadDataIfActive"},_isConnected:{type:Boolean},loadKey:{type:String},dataToLoad:{type:Array},getDataLoadName:{type:Object},loadDataCallback:{type:Object},requestData:{type:Object}}}static get observers(){return["_dataToLoadChanged(_isConnected, dataToLoad.*)"]}onLoadFinish(){}reload(){this._dataLoadState.clear(),this._loadData()}reset(){this._loadDataAsync!=null&&(clearTimeout(this._loadDataAsync),this._loadDataAsync=null),this._canceller&&this._canceller.cancelAll(),this._dataLoadState&&this._dataLoadState.clear(),this._isConnected&&this._loadData()}_dataToLoadChanged(){this._isConnected&&this._loadData()}detached(){this._loadDataAsync!=null&&(clearTimeout(this._loadDataAsync),this._loadDataAsync=null)}_loadDataIfActive(){this.active&&this._loadData()}_loadDataImpl(){!this.active||(this._loadDataAsync!==null&&clearTimeout(this._loadDataAsync),this._loadDataAsync=setTimeout(this._canceller.cancellable(r=>{if(r.cancelled)return;this.dataLoading=!0;let n=this.dataToLoad.filter(a=>{let s=this.getDataLoadName(a);return!this._dataLoadState.has(s)});for(let a of n){let s=this.getDataLoadName(a);this._dataLoadState.set(s,x4.LOADING)}let i=this._canceller.cancellable(a=>{if(a.cancelled)return;let{item:s,data:l}=a.value,c=this.getDataLoadName(s);this._dataLoadState.set(c,x4.LOADED),this.loadDataCallback(this,s,l)}),o=this._canceller.cancellable(a=>{if(!a.cancelled){let l=a.value,c=new Set(n.map(h=>this.getDataLoadName(h)));this.dataToLoad.some(h=>c.has(this.getDataLoadName(h)))&&this.onLoadFinish(),this._loadDataAsync=null,this.dataLoadedAtLeastOnce=!0}Array.from(this._dataLoadState.values()).includes(x4.LOADING)||(this.dataLoading=!1)});this.requestData(n,i,()=>o(void 0))})))}}}var bqe=Ee(Oe(),1),Wo=Ee(wl(),1),RS=[{character:"\u25FC",method:Wo.SymbolFactories.square},{character:"\u25C6",method:Wo.SymbolFactories.diamond},{character:"\u25B2",method:Wo.SymbolFactories.triangle},{character:"\u2605",method:Wo.SymbolFactories.star},{character:"\u271A",method:Wo.SymbolFactories.cross}],Ed;(function(e){e.STEP="step",e.RELATIVE="relative",e.WALL_TIME="wall_time"})(Ed||(Ed={}));var e0=4,wqe=4,mB=3,gB=20,_B=4,OKt=6;function Wu(e){return t=>{let r=Math.abs(t);r<1e-15&&(r=0);let n;return r>=1e4?n=xn("."+e+"~e"):r>0&&r<.01?n=xn("."+e+"~e"):n=xn("."+e+"~g"),n(t)}}var b4=xn(`.${wqe}~s`);function Xat(){let e=new Wo.Scales.Linear;e.tickGenerator(Wo.Scales.TickGenerators.integerTickGenerator());let t=new Wo.Axes.Numeric(e,"bottom");return t.formatter(b4),{scale:e,axis:t,accessor:r=>r.step}}var yB=Wo.Formatters.time("%a %b %e, %H:%M:%S");function Sqe(){let e=new Wo.Scales.Time;return{scale:e,axis:new Wo.Axes.Time(e,"bottom"),accessor:t=>t.wall_time}}var r0=(e,t,r)=>{if(e.relative!=null)return e.relative;let n=r.data(),i=n.length>0?+n[0].wall_time:0;return(+e.wall_time-i)/(60*60*1e3)},vB=e=>{let t="",r=Math.floor(e/24);e-=r*24,r&&(t+=r+"d ");let n=Math.floor(e);e-=n,e*=60,(n||r)&&(t+=n+"h ");let i=Math.floor(e);e-=i,e*=60,(i||n||r)&&(t+=i+"m ");let o=Math.floor(e);return t+o+"s"};function Mqe(){let e=new Wo.Scales.Linear;return{scale:e,axis:new Wo.Axes.Numeric(e,"bottom"),accessor:r0}}function xB(e){switch(e){case Ed.STEP:return Xat();case Ed.WALL_TIME:return Sqe();case Ed.RELATIVE:return Mqe();default:throw new Error("invalid xType: "+e)}}var zs=Ee(Oe(),1),Mn=Ee(wl(),1);var va=Ee(wl(),1);function Eqe(e){let t=[],r=e;for(;r&&r instanceof HTMLElement;)if(t.push(r),r.assignedSlot)r=r.assignedSlot;else if(r.parentElement)r=r.parentElement;else{let n=r.parentNode;n instanceof DocumentFragment?r=n.host:r=n!==r?n:null}return t}var Tqe=[1,0,0,1,0,0];function Cqe(e){let t=Eqe(e),r=Tqe,n=null;for(let i of t){let o=va.Utils.DOM.getElementTransform(i);if(o!=null){let l=i.clientWidth/2,c=i.clientHeight/2;r=va.Utils.Math.multiplyTranslate(r,[l,c]),r=va.Utils.Math.multiplyMatrix(r,va.Utils.Math.invertMatrix(o)),r=va.Utils.Math.multiplyTranslate(r,[-l,-c])}let a=i.scrollLeft,s=i.scrollTop;(n===null||i===n)&&(a-=i.offsetLeft+i.clientLeft,s-=i.offsetTop+i.clientTop,n=i.offsetParent),r=va.Utils.Math.multiplyTranslate(r,[a,s])}return r}var wB=class extends va.Utils.Translator{computePosition(t,r){let n={x:t,y:r},i=Cqe(this._rootElement);return i==null?n:va.Utils.Math.applyTransform(i,n)}},Uv=class extends va.Dispatchers.Mouse{constructor(t){super(t),this._eventTarget=t.root().rootElement().node(),this._translator=new wB(t.root().rootElement().node())}static getDispatcher(t){let r=t.root().rootElement(),n=r[Uv._DISPATCHER_KEY];return n||(n=new Uv(t),r[Uv._DISPATCHER_KEY]=n),n}},qv=class extends va.Dispatchers.Touch{constructor(t){super(t),this._eventTarget=t.root().rootElement().node(),this._translator=new wB(t.root().rootElement().node())}static getDispatcher(t){let r=t.root().rootElement(),n=r[qv._DISPATCHER_KEY];return n||(n=new qv(t),r[qv._DISPATCHER_KEY]=n),n}};va.Interaction.prototype._isInsideComponent=function(e){return 0<=e.x&&0<=e.y&&e.x<this._componentAttachedTo.width()&&e.y<this._componentAttachedTo.height()};var SB=class extends va.Interactions.Pointer{_anchor(t){let r=this;r._isAnchored=!0,r._mouseDispatcher=Uv.getDispatcher(r._componentAttachedTo),r._mouseDispatcher.onMouseMove(r._mouseMoveCallback),r._touchDispatcher=qv.getDispatcher(r._componentAttachedTo),r._touchDispatcher.onTouchStart(r._touchStartCallback)}};var zKt=Ee(Oe(),1);var Gv;(function(e){e.AUTO="auto",e.BOTTOM="bottom",e.RIGHT="right"})(Gv||(Gv={}));var Aqe={boxShadow:"0 1px 4px rgba(0, 0, 0, .3)",opacity:0,position:"fixed",willChange:"transform",zIndex:5},w4=class extends Gt(mt){constructor(){super(...arguments),this.position=Gv.AUTO,this.minDistFromEdge=15,this._styleCache=null,this._raf=null,this._tunnel=null}ready(){this._styleCache=null,this._raf=null,this._tunnel=null}attached(){this._tunnel=this._createTunnel(),this._hideOnBlur=()=>{document.hidden&&this.hide()},window.addEventListener("visibilitychange",this._hideOnBlur)}detached(){this.hide(),this._removeTunnel(this._tunnel),this._tunnel=null,window.removeEventListener("visibilitychange",this._hideOnBlur)}content(){return this._tunnel.shadowRoot}hide(){this._raf!==null&&window.cancelAnimationFrame(this._raf),this._styleCache=null,this._tunnel.style.opacity=0}updateAndPosition(t){this._raf!==null&&window.cancelAnimationFrame(this._raf),this._raf=window.requestAnimationFrame(()=>{!this.isAttached||this._repositionImpl(t)})}_repositionImpl(t){let r=this._tunnel,n=t.getBoundingClientRect(),i=r.getBoundingClientRect(),o=window.innerHeight,a=document.body.clientWidth,s=n.top,l=s+n.height,c=i.height+gB,u=null,h=Math.max(this.minDistFromEdge,n.left),f=null,p=s;this.position==Gv.RIGHT?h=n.right:(p=l+gB,a<h+i.width+this.minDistFromEdge&&(h=null,f=this.minDistFromEdge)),this.position==Gv.AUTO&&n.top-c>0&&o<n.top+n.height+c&&(p=null,u=o-s+gB);let d={contain:"content",opacity:1,left:h?`${h}px`:null,right:f?`${f}px`:null,top:p?`${p}px`:null,bottom:u?`${u}px`:null};zKt.isEqual(this._styleCache,d)||(Object.assign(r.style,d),this._styleCache=d)}_createTunnel(){if(!this.contentComponentName)throw new RangeError("Require `contentComponentName` to be a name of a Polymer component");let t=document.createElement(this.contentComponentName);return Object.assign(t.style,Aqe),document.body.appendChild(t),t}_removeTunnel(t){document.body.removeChild(t)}};E([A({type:String}),w("design:type",String)],w4.prototype,"contentComponentName",void 0);E([A({type:String}),w("design:type",String)],w4.prototype,"position",void 0);E([A({type:Number}),w("design:type",Number)],w4.prototype,"minDistFromEdge",void 0);w4=E([yt("vz-chart-tooltip")],w4);var NS=Ee(wl(),1);var HKt=1e4,VKt=.001,UKt=xn(".2~e"),Pqe=xn(".4~r"),FKt=xn(",~");function BKt(e){if(e===0)return"0";let t=Math.abs(e);return t>=HKt||t<VKt?UKt(e):Pqe(e)}var Kat={formatTick:BKt,formatShort:BKt,formatReadable(e){let t=Math.abs(e);return t>=HKt||t<VKt?UKt(e):FKt(e)},formatLong:FKt},iWn=new Intl.NumberFormat(void 0,{maximumFractionDigits:4});var oWn=xn("0.3~s"),aWn=xn(",.3~f");var Iqe=1e3,Lqe=60*Iqe,kqe=60*Lqe,Rqe=24*kqe,sWn=365*Rqe,lWn=xn(".4~");var Nqe=Yb().tickFormat(),$at,qKt={formatTick(e){return Nqe(new Date(e))},formatShort(e){return new Date(e).toLocaleString($at,{year:"numeric",month:"short",day:"numeric",hour:"numeric",minute:"numeric",second:"numeric"})},formatReadable(e){return new Date(e).toLocaleString($at,{year:"numeric",month:"short",day:"numeric",hour:"numeric",minute:"numeric",second:"numeric",timeZoneName:"short"})},formatLong(e){return new Date(e).toLocaleString($at,{year:"numeric",month:"long",day:"numeric",hour:"numeric",minute:"numeric",second:"numeric",timeZoneName:"short",fractionalSecondDigits:3})}};var Td;(function(e){e[e.LINEAR=0]="LINEAR",e[e.LOG10=1]="LOG10",e[e.TIME=2]="TIME"})(Td||(Td={}));function GKt(e){switch(e){case Td.LINEAR:return new Zat;case Td.LOG10:return new Jat;case Td.TIME:return new Qat;default:let t=e;throw new RangeError(`ScaleType ${t} not supported.`)}}var Dqe=.05,Zat=class{constructor(){this.defaultFormatter=Kat}transform(t,r,n){let[i,o]=t,a=o-i,[s,l]=r,c=l-s;return a===0?s:c/a*(n-i)+s}forward(t,r,n){return this.transform(t,r,n)}reverse(t,r,n){return this.transform(r,t,n)}niceDomain(t){let[r,n]=t;if(n<r)throw new Error("Unexpected input: min is larger than max");if(n===r)return r===0?[-1,1]:r<0?[2*r,0]:[0,2*r];let i=On(),o=(n-r+Number.EPSILON)*Dqe,[a,s]=i.domain([r-o,n+o]).nice().domain();return[a,s]}ticks(t,r){return On().domain(t).ticks(r)}isSafeNumber(t){return Number.isFinite(t)}},Jat=class{constructor(){this.defaultFormatter=Kat}transform(t){return Math.log10(t>0?t:Number.MIN_VALUE)}untransform(t){return Math.exp(t/Math.LOG10E)}forward(t,r,n){if(n<=0)return r[0];let[i,o]=t,[a,s]=r,l=this.transform(i),u=this.transform(o)-l,h=s-a;return n=this.transform(n),h/(u+Number.EPSILON)*(n-l)+a}reverse(t,r,n){let[i,o]=t,[a,s]=r,l=this.transform(i),u=this.transform(o)-l,h=s-a,f=u/(h+Number.EPSILON)*(n-a)+l;return this.untransform(f)}niceDomain(t){let[r,n]=t;if(r>n)throw new Error("Unexpected input: min is larger than max");let i=Math.max(r,Number.MIN_VALUE),o=Math.max(n,Number.MIN_VALUE);return n<=0?[Number.MIN_VALUE,1]:[Math.max(Number.MIN_VALUE,i*.5),o*2]}ticks(t,r){let n=t[0]<=0?Number.MIN_VALUE:t[0],i=t[1]<=0?Number.MIN_VALUE:t[1],o=cc().domain([n,i]).ticks(r);return o.length?o:t}isSafeNumber(t){return Number.isFinite(t)&&t>0}},Qat=class{constructor(){this.scale=Yb(),this.defaultFormatter=qKt}forward(t,r,n){return this.scale.domain(t).range(r)(n)}reverse(t,r,n){return this.scale.domain(t).range(r).invert(n).getTime()}niceDomain(t){let[r,n]=this.scale.domain(t).nice().domain();return[r.getTime(),n.getTime()]}ticks(t,r){return this.scale.domain(t).ticks(r).map(n=>n.getTime())}isSafeNumber(t){return Number.isFinite(t)}};var MB=class extends NS.Scales.Linear{constructor(){super(),this._ignoreOutlier=!1,this.padProportion(.2)}setValueProviderForDomain(t){return this._valueProviderForDomain=t,this}_niceDomain(t,r){let[n,i]=t;return GKt(Td.LINEAR).niceDomain([n,i])}_getUnboundedExtent(t){let r=this._getAllIncludedValues(t),n=this._defaultExtent();if(r.length!==0){let i=[NS.Utils.Math.min(r,n[0]),NS.Utils.Math.max(r,n[1])];n=this._niceDomain(i)}return n}_getAllIncludedValues(t=!1){let r=this._valueProviderForDomain?this._valueProviderForDomain():[];return this.extentOfValues(r)}extentOfValues(t){let r=t.filter(o=>NS.Utils.Math.isValidNumber(o)),n=r;if(this.ignoreOutlier()){let o=r.sort((l,c)=>l-c),a=sa(o,.05),s=sa(o,.95);n=r.filter(l=>l>=a&&l<=s)}let i=aa(n);return i[0]==null||i[1]==null?[]:i}ignoreOutlier(t){return typeof t=="boolean"?(this._ignoreOutlier=t,this):this._ignoreOutlier}};var CB=Ee(wl(),1);var WKt=Ee(wl(),1),EB=class extends WKt.QuantitativeScale{constructor(){super(...arguments),this._ignoreOutlier=!1}setValueProviderForDomain(t){return this._valueProviderForDomain=t,this}ignoreOutlier(t){return typeof t=="boolean"?(this._ignoreOutlier=t,this):this._ignoreOutlier}_getAllIncludedValues(t=!1){let r=this._valueProviderForDomain?this._valueProviderForDomain():[];return this.extentOfValues(r)}};var TB=Math.pow(2,-1074);function S4(e){return Math.log10(e)}function tst(e){return Math.pow(10,e)}var AB=class extends EB{constructor(){super(),this._d3LogScale=cc(),this.padProportion(.2)}scale(t){return t<=0?NaN:this._d3LogScale(t)}invert(t){return this._d3LogScale.invert(t)}scaleTransformation(t){return this.scale(t)}invertedTransformation(t){return this.invert(t)}getTransformationDomain(){return this.domain()}setTransformationDomain(t){this.domain(t)}getTransformationExtent(){return this._getUnboundedExtent(!0)}_getDomain(){return this._untransformedDomain}_setDomain(t){this._untransformedDomain=t;let[r,n]=t;super._setDomain([Math.max(TB,r),n])}_niceDomain(t,r){let[n,i]=t,o=Math.max(S4(TB),S4(n)),a=S4(i),s=a-o,l=s?s*this.padProportion():1;return[tst(Math.max(S4(TB),o-l)),tst(a+l)]}_getUnboundedExtent(t){let r=this._getAllIncludedValues(t),n=this._defaultExtent();if(r.length!==0){let i=[CB.Utils.Math.min(r,n[0]),CB.Utils.Math.max(r,n[1])];n=this._niceDomain(i)}return n}_getAllIncludedValues(t=!1){return super._getAllIncludedValues().map(n=>n>0?n:TB)}_defaultExtent(){return[1,10]}_backingScaleDomain(t){return t==null?this._d3LogScale.domain():(this._d3LogScale.domain(t),this)}_getRange(){return this._d3LogScale.range()}_setRange(t){this._d3LogScale.range(t)}defaultTicks(){return this._d3LogScale.ticks(1)}ticks(){return this._d3LogScale.ticks()}extentOfValues(t){let r=t.filter(o=>CB.Utils.Math.isValidNumber(o)&&o>0),n=r;if(this.ignoreOutlier()){let a=r.map(S4).sort((c,u)=>c-u),s=sa(a,.05),l=sa(a,.95);n=a.filter(c=>c>=s&&c<=l).map(tst)}let i=aa(n);return i[0]==null||i[1]==null?[]:i}};var Cd=Ee(wl(),1);var n0=Ee(wl(),1),PB=class extends n0.Components.SelectionBoxLayer{constructor(t,r,n){super(),this.easeFn=xs,this._animationTime=750,this.xScale(t),this.yScale(r),this._dragInteraction=new n0.Interactions.Drag,this._doubleClickInteraction=new n0.Interactions.Click,this.setupCallbacks(),this.unzoomMethod=n,this.onDetach(()=>{this._doubleClickInteraction.detachFrom(this),this._dragInteraction.detachFrom(this)}),this.onAnchor(()=>{this._doubleClickInteraction.attachTo(this),this._dragInteraction.attachTo(this)})}interactionStart(t){this.onStart=t}interactionEnd(t){this.onEnd=t}dragInteraction(){return this._dragInteraction}setupCallbacks(){let t=!1;this._dragInteraction.onDragStart(r=>{this.bounds({topLeft:r,bottomRight:r}),this.onStart()}),this._dragInteraction.onDrag((r,n)=>{this.bounds({topLeft:r,bottomRight:n}),this.boxVisible(!0),t=!0}),this._dragInteraction.onDragEnd((r,n)=>{this.boxVisible(!1),this.bounds({topLeft:r,bottomRight:n}),t?this.zoom():this.onEnd(),t=!1}),this._doubleClickInteraction.onDoubleClick(this.unzoom.bind(this))}animationTime(t){if(t==null)return this._animationTime;if(t<0)throw new Error("animationTime cannot be negative");return this._animationTime=t,this}ease(t){if(typeof t!="function")throw new Error("ease function must be a function");return(t(0)!==0||t(1)!==1)&&n0.Utils.Window.warn("Easing function does not maintain invariant f(0)==0 && f(1)==1. Bad behavior may result."),this.easeFn=t,this}zoom(){let t=this.xExtent()[0].valueOf(),r=this.xExtent()[1].valueOf(),n=this.yExtent()[1].valueOf(),i=this.yExtent()[0].valueOf();t===r||n===i||this.interpolateZoom(t,r,n,i)}unzoom(){let t=this.xScale();t._domainMin=null,t._domainMax=null;let r=t._getExtent();this.xScale().domain(r),this.unzoomMethod()}isZooming(t){this._dragInteraction.enabled(!t),this._doubleClickInteraction.enabled(!t)}interpolateZoom(t,r,n,i){let o=this.xScale().domain()[0].valueOf(),a=this.xScale().domain()[1].valueOf(),s=this.yScale().domain()[0].valueOf(),l=this.yScale().domain()[1].valueOf(),c=this.easeFn,u=(p,d,g)=>zi(p,d)(c(g));this.isZooming(!0);let h=Date.now(),f=()=>{let d=Date.now()-h,g=this._animationTime===0?1:Math.min(1,d/this._animationTime),_=u(o,t,g),y=u(a,r,g),x=u(s,n,g),b=u(l,i,g);this.xScale().domain([_,y]),this.yScale().domain([x,b]),g<1?n0.Utils.DOM.requestAnimationFramePolyfill(f):(this.onEnd(),this.isZooming(!1))};f()}};var xa;(function(e){e[e.NONE=0]="NONE",e[e.DRAG_ZOOMING=1]="DRAG_ZOOMING",e[e.PANNING=2]="PANNING"})(xa||(xa={}));var zf=class extends Cd.Components.Group{constructor(t,r,n){super(),this.state=xa.NONE,this.panStartCallback=new Cd.Utils.CallbackSet,this.panEndCallback=new Cd.Utils.CallbackSet,this.panZoom=new Cd.Interactions.PanZoom(t,r),this.panZoom.dragInteraction().mouseFilter(o=>zf.isPanKey(o)&&o.button===0),this.panZoom.wheelFilter(this.canScrollZoom),this.dragZoomLayer=new PB(t,r,n),this.dragZoomLayer.dragInteraction().mouseFilter(o=>!zf.isPanKey(o)&&o.button===0),this.append(this.dragZoomLayer);let i=this.onWheel.bind(this);this.onAnchor(()=>{this._mouseDispatcher=Cd.Dispatchers.Mouse.getDispatcher(this),this._mouseDispatcher.onWheel(i),this.panZoom.attachTo(this)}),this.onDetach(()=>{this.panZoom.detachFrom(this),this._mouseDispatcher&&(this._mouseDispatcher.offWheel(i),this._mouseDispatcher=null)}),this.panZoom.dragInteraction().onDragStart(()=>{this.state==xa.NONE&&this.setState(xa.PANNING)}),this.panZoom.dragInteraction().onDragEnd(()=>{this.state==xa.PANNING&&this.setState(xa.NONE)}),this.dragZoomLayer.dragInteraction().onDragStart(()=>{this.state==xa.NONE&&this.setState(xa.DRAG_ZOOMING)}),this.dragZoomLayer.dragInteraction().onDragEnd(()=>{this.state==xa.DRAG_ZOOMING&&this.setState(xa.NONE)})}onWheel(t,r){if(this.canScrollZoom(r))return;let n=this.element();if(!n.select(".help").empty())return;let i=n.append("div").classed("help",!0);i.append("span").text("Alt + Scroll to Zoom"),i.on("animationend",()=>void i.remove())}static isPanKey(t){return Boolean(t.altKey)||Boolean(t.shiftKey)}canScrollZoom(t){return t.altKey}setState(t){if(this.state==t)return;let r=this.state;this.state=t,this.root().removeClass(this.stateClassName(r)),this.root().addClass(this.stateClassName(t)),r==xa.PANNING&&this.panEndCallback.callCallbacks(),t==xa.PANNING&&this.panStartCallback.callCallbacks()}stateClassName(t){switch(t){case xa.PANNING:return"panning";case xa.DRAG_ZOOMING:return"drag-zooming";case xa.NONE:default:return""}}onPanStart(t){this.panStartCallback.add(t)}onPanEnd(t){this.panEndCallback.add(t)}onScrollZoom(t){this.panZoom.onZoomEnd(t)}onDragZoomStart(t){this.dragZoomLayer.interactionStart(t)}onDragZoomEnd(t){this.dragZoomLayer.interactionEnd(t)}};var IB;(function(e){e[e.TEXT=0]="TEXT",e[e.DOM=1]="DOM"})(IB||(IB={}));var Ff;(function(e){e.LOG="log",e.LINEAR="linear"})(Ff||(Ff={}));var YKt=20,DS=class{constructor(t,r,n,i,o,a,s,l,c,u,h){this.dirtyDatasets=new Set,this.seriesNames=[],this.name2datasets={},this.colorScale=i,this.tooltip=o,this.datasets=[],this._ignoreYOutliers=!1,this.lastPointsDataset=new Mn.Dataset,this.nanDataset=new Mn.Dataset,this.yValueAccessor=r,this.symbolFunction=u,this._defaultXRange=l,this._defaultYRange=c,this.tooltipColumns=a,this.buildChart(t,r,n,s,h)}buildChart(t,r,n,i,o){this.destroy();let a=t();this.xAccessor=a.accessor,this.xScale=a.scale,this.xAxis=a.axis,this.xAxis.margin(1).tickLabelPadding(3),o&&this.xAxis.formatter(o),this.yScale=DS.getYScaleFromType(n),this.yScale.setValueProviderForDomain(()=>this.getValuesForYAxisDomainCompute()),this.yAxis=new Mn.Axes.Numeric(this.yScale,"left");let s=Wu(mB);this.yAxis.margin(0).tickLabelPadding(5).formatter(s),this.yAxis.usesTextWidthApproximation(!0),this.fillArea=i;let l=new zf(this.xScale,this.yScale,()=>this.resetDomain());this.tooltipInteraction=this.createTooltipInteraction(l),this.tooltipPointsComponent=new Mn.Component;let c=this.buildPlot(this.xScale,this.yScale,i);this.gridlines=new Mn.Components.Gridlines(this.xScale,this.yScale);let u=null;n!==Ff.LOG&&(u=new Mn.Components.GuideLineLayer("horizontal"),u.scale(this.yScale).value(0));let h=new Mn.Components.GuideLineLayer("vertical");h.scale(this.xScale).value(0),this.center=new Mn.Components.Group([this.gridlines,u,h,c,this.tooltipPointsComponent,l]),this.center.addClass("main"),this.outer=new Mn.Components.Table([[this.yAxis,this.center],[null,this.xAxis]])}buildPlot(t,r,n){n&&(this.marginAreaPlot=new Mn.Plots.Area,this.marginAreaPlot.x(this.xAccessor,t),this.marginAreaPlot.y(n.higherAccessor,r),this.marginAreaPlot.y0(n.lowerAccessor),this.marginAreaPlot.attr("fill",(c,u,h)=>this.colorScale.scale(h.metadata().name)),this.marginAreaPlot.attr("fill-opacity",.3),this.marginAreaPlot.attr("stroke-width",0)),this.smoothedAccessor=c=>c.smoothed;let i=new Mn.Plots.Line;i.x(this.xAccessor,t),i.y(this.yValueAccessor,r),i.attr("stroke",(c,u,h)=>this.colorScale.scale(h.metadata().name)),this.linePlot=i,this.setupTooltips(i);let o=new Mn.Plots.Line;if(o.x(this.xAccessor,t),o.y(this.smoothedAccessor,r),o.attr("stroke",(c,u,h)=>this.colorScale.scale(h.metadata().name)),this.smoothLinePlot=o,this.symbolFunction){let c=new Mn.Plots.Scatter;c.x(this.xAccessor,t),c.y(this.yValueAccessor,r),c.attr("fill",(u,h,f)=>this.colorScale.scale(f.metadata().name)),c.attr("opacity",1),c.size(_B*2),c.symbol((u,h,f)=>this.symbolFunction(f.metadata().name)),this.markersScatterPlot=c}let a=new Mn.Plots.Scatter;a.x(this.xAccessor,t),a.y(this.yValueAccessor,r),a.attr("fill",c=>this.colorScale.scale(c.name)),a.attr("opacity",1),a.size(_B*2),a.datasets([this.lastPointsDataset]),this.scatterPlot=a;let s=new Mn.Plots.Scatter;s.x(this.xAccessor,t),s.y(c=>c.displayY,r),s.attr("fill",c=>this.colorScale.scale(c.name)),s.attr("opacity",1),s.size(OKt*2),s.datasets([this.nanDataset]),s.symbol(Mn.SymbolFactories.triangle),this.nanDisplay=s;let l=[s,a,o,i];return this.marginAreaPlot&&l.push(this.marginAreaPlot),this.markersScatterPlot&&l.push(this.markersScatterPlot),new Mn.Components.Group(l)}ignoreYOutliers(t){t!==this._ignoreYOutliers&&(this._ignoreYOutliers=t,this.updateSpecialDatasets(),this.yScale.ignoreOutlier(t),this.resetYDomain())}getValuesForYAxisDomainCompute(){let t=this.getAccessorsForComputingYRange(),r=n=>t.map(i=>n.data().map(o=>i(o,-1,n)));return zs.flattenDeep(this.datasets.map(r)).filter(isFinite)}updateSpecialDatasets(){let t=this.getYAxisAccessor(),r=this.datasets.map(o=>{let a=null,s=o.data().filter(l=>!isNaN(t(l,-1,o)));if(s.length>0){let l=s.length-1;a=s[l],a.name=o.metadata().name,a.relative=r0(a,-1,o)}return a}).filter(o=>o!=null);this.lastPointsDataset.data(r),this.markersScatterPlot&&this.markersScatterPlot.datasets(this.datasets.map(this.createSampledDatasetForMarkers));let n=o=>{let a=null,s=o.data(),l=0;for(;l<s.length&&a==null;)isNaN(t(s[l],-1,o))||(a=t(s[l],-1,o)),l++;a==null&&(a=0);let c=[];for(l=0;l<s.length;l++)isNaN(t(s[l],-1,o))?(s[l].name=o.metadata().name,s[l].displayY=a,s[l].relative=r0(s[l],-1,o),c.push(s[l])):a=t(s[l],-1,o);return c},i=zs.flatten(this.datasets.map(n));this.nanDataset.data(i)}resetDomain(){this.resetXDomain(),this.resetYDomain()}resetXDomain(){let t;if(this._defaultXRange!=null)t=this._defaultXRange;else{let r=this.xScale;r._domainMin=null,r._domainMax=null,t=r._getExtent()}this.xScale.domain(t)}resetYDomain(){this._defaultYRange!=null?this.yScale.domain(this._defaultYRange):(this.yScale.autoDomain(),this.yScale.domain(this.yScale.domain()))}getAccessorsForComputingYRange(){let t=[this.getYAxisAccessor()];return this.fillArea&&t.push(this.fillArea.lowerAccessor,this.fillArea.higherAccessor),t}getYAxisAccessor(){return this.smoothingEnabled?this.smoothedAccessor:this.yValueAccessor}createTooltipInteraction(t){let r=new SB,n=()=>{r.enabled(!1),this.hideTooltips()},i=()=>r.enabled(!0);return t.onPanStart(n),t.onDragZoomStart(n),t.onPanEnd(i),t.onDragZoomEnd(i),t.onScrollZoom(()=>this.updateTooltipContent(this._lastMousePosition)),r.onPointerMove(o=>{this._lastMousePosition=o,this.updateTooltipContent(o)}),r.onPointerExit(()=>this.hideTooltips()),r}updateTooltipContent(t){!this.linePlot||(window.cancelAnimationFrame(this._tooltipUpdateAnimationFrame),this._tooltipUpdateAnimationFrame=window.requestAnimationFrame(()=>{let r={x:t.x,y:t.y},n=this.gridlines.content().node().getBBox(),i=this.linePlot.datasets().map(l=>this.findClosestPoint(r,l)).filter(l=>Boolean(l)),o=Mn.Utils.DOM.intersectsBBox,a=i.filter(l=>o(l.x,l.y,n)||isNaN(this.yValueAccessor(l.datum,0,l.dataset))),s=a.filter(l=>!isNaN(this.yValueAccessor(l.datum,0,l.dataset)));if(i.length!==0){this.scatterPlot.attr("display","none");let l=this.tooltipPointsComponent.content().selectAll(".point").data(s,c=>c.dataset.metadata().name);l.enter().append("circle").classed("point",!0),l.attr("r",_B).attr("cx",c=>c.x).attr("cy",c=>c.y).style("stroke","none").attr("fill",c=>this.colorScale.scale(c.dataset.metadata().name)),l.exit().remove(),this.drawTooltips(a,r,this.tooltipColumns)}else this.hideTooltips()}))}hideTooltips(){window.cancelAnimationFrame(this._tooltipUpdateAnimationFrame),this.tooltip.hide(),this.scatterPlot.attr("display","block"),this.tooltipPointsComponent.content().selectAll(".point").remove()}setupTooltips(t){t.onDetach(()=>{this.tooltipInteraction.detachFrom(t),this.tooltipInteraction.enabled(!1)}),t.onAnchor(()=>{this.tooltipInteraction.attachTo(t),this.tooltipInteraction.enabled(!0)})}drawTooltips(t,r,n){if(!t.length){this.tooltip.hide();return}let{colorScale:i}=this;n=[{title:"",static:!1,evalType:IB.DOM,evaluate(d){return Ht(this).select("span").style("background-color",()=>i.scale(d.dataset.metadata().name)),""},enter(d){Ht(this).append("span").classed("swatch",!0).style("background-color",()=>i.scale(d.dataset.metadata().name))}},...n];let a=Wu(e0),s=d=>Math.pow(d.x-r.x,2)+Math.pow(d.y-r.y,2),l=zs.min(t.map(s)),c=this.smoothingEnabled?this.smoothedAccessor:this.yValueAccessor;this.tooltipSortingMethod==="ascending"?t=zs.sortBy(t,d=>c(d.datum,-1,d.dataset)):this.tooltipSortingMethod==="descending"?t=zs.sortBy(t,d=>c(d.datum,-1,d.dataset)).reverse():this.tooltipSortingMethod==="nearest"?t=zs.sortBy(t,s):t=t.slice(0).reverse();let u=this,h=Ht(this.tooltip.content()).select("table"),f=h.select("thead").selectAll("th").data(n,(d,g,_)=>d.title);f.enter().append("th").text(d=>d.title).nodes(),f.exit().remove();let p=h.select("tbody").selectAll("tr").data(t,(d,g,_)=>d.dataset.metadata().name);p.classed("distant",d=>{let g=d.dataset.data()[0],_=zs.last(d.dataset.data()),y=this.xScale.scale(this.xAccessor(g,0,d.dataset)),x=this.xScale.scale(this.xAccessor(_,0,d.dataset)),b=this.smoothingEnabled?d.datum.smoothed:this.yValueAccessor(d.datum,0,d.dataset);return r.x<y||r.x>x||isNaN(b)}).classed("closest",d=>s(d)===l).each(function(d){u.drawTooltipRow(this,n,d)}).order(),p.exit().remove(),p.enter().append("tr").each(function(d){u.drawTooltipRow(this,n,d)}).nodes(),this.tooltip.updateAndPosition(this.targetSVG.node())}drawTooltipRow(t,r,n){let i=this,o=Ht(t).selectAll("td").data(r);o.each(function(a){a.static||i.drawTooltipColumn.call(i,this,a,n)}),o.exit().remove(),o.enter().append("td").each(function(a){"enter"in a&&a.enter.call(this,n),i.drawTooltipColumn.call(i,this,a,n)})}drawTooltipColumn(t,r,n){let{smoothingEnabled:i}=this;"evalType"in r&&r.evalType==IB.DOM?r.evaluate.call(t,n,{smoothingEnabled:i}):Ht(t).text(r.evaluate.call(t,n,{smoothingEnabled:i}))}findClosestPoint(t,r){let n=r.data().map((s,l)=>this.xScale.scale(this.xAccessor(s,l,r))),i=zs.sortedIndex(n,t.x);if(n.length==0)return null;if(i===n.length)i=i-1;else if(i!==0){let s=Math.abs(n[i-1]-t.x),l=Math.abs(n[i]-t.x);i=s<l?i-1:i}let o=r.data()[i],a=this.smoothingEnabled?this.smoothedAccessor(o,i,r):this.yValueAccessor(o,i,r);return{x:n[i],y:this.yScale.scale(a),datum:o,dataset:r}}resmoothDataset(t){let r=t.data(),n=this.smoothingWeight,i=r.length>0?0:NaN,o=0,a=r.map((l,c)=>this.yValueAccessor(l,c,t)),s=a.every(l=>l==a[0]);r.forEach((l,c)=>{let u=a[c];if(s||!Number.isFinite(u))l.smoothed=u;else{i=i*n+(1-n)*u,o++;let h=1;n!==1&&(h=1-Math.pow(n,o)),l.smoothed=i/h}})}getDataset(t){return this.name2datasets[t]===void 0&&(this.name2datasets[t]=new Mn.Dataset([],{name:t,meta:null})),this.name2datasets[t]}static getYScaleFromType(t){if(t===Ff.LOG)return new AB;if(t===Ff.LINEAR)return new MB;throw new Error("Unrecognized yScale type "+t)}setVisibleSeries(t){this.disableChanges(),t=t.sort(),t.reverse(),this.seriesNames=t}disableChanges(){this.dirtyDatasets.size||(this.linePlot.datasets([]),this.smoothLinePlot&&this.smoothLinePlot.datasets([]),this.marginAreaPlot&&this.marginAreaPlot.datasets([]))}commitChanges(){this.datasets=this.seriesNames.map(t=>this.getDataset(t)),[...this.dirtyDatasets].forEach(t=>{this.smoothingEnabled&&this.resmoothDataset(this.getDataset(t))}),this.updateSpecialDatasets(),this.linePlot.datasets(this.datasets),this.smoothingEnabled&&this.smoothLinePlot.datasets(this.datasets),this.marginAreaPlot&&this.marginAreaPlot.datasets(this.datasets),this.measureBBoxAndMaybeInvalidateLayoutInRaf(),this.dirtyDatasets.clear()}createSampledDatasetForMarkers(t){let r=t.data();if(r.length<=YKt)return t;let n=Math.ceil(r.length/YKt),i=new Array(Math.floor(r.length/n));for(let o=0,a=0;o<i.length;o++,a+=n)i[o]=r[a];return new Mn.Dataset(i,t.metadata())}setSeriesData(t,r){this.disableChanges(),this.getDataset(t).data(r),this.dirtyDatasets.add(t)}setSeriesMetadata(t,r){this.disableChanges(),this.getDataset(t).metadata(Mx(Kl({},this.getDataset(t).metadata()),{meta:r})),this.dirtyDatasets.add(t)}smoothingUpdate(t){this.smoothingWeight=t,this.datasets.forEach(r=>this.resmoothDataset(r)),this.smoothingEnabled||(this.linePlot.addClass("ghost"),this.scatterPlot.y(this.smoothedAccessor,this.yScale),this.smoothingEnabled=!0,this.smoothLinePlot.datasets(this.datasets)),this.markersScatterPlot&&this.markersScatterPlot.y(this.getYAxisAccessor(),this.yScale),this.updateSpecialDatasets()}smoothingDisable(){this.smoothingEnabled&&(this.linePlot.removeClass("ghost"),this.scatterPlot.y(this.yValueAccessor,this.yScale),this.smoothLinePlot.datasets([]),this.smoothingEnabled=!1,this.updateSpecialDatasets()),this.markersScatterPlot&&this.markersScatterPlot.y(this.getYAxisAccessor(),this.yScale)}setColorScale(t){this.colorScale=t}setTooltipColumns(t){this.tooltipColumns=t}setTooltipSortingMethod(t){this.tooltipSortingMethod=t}renderTo(t){this.targetSVG=t,this.outer.renderTo(t),this._defaultXRange!=null&&this.resetXDomain(),this._defaultYRange!=null&&this.resetYDomain(),this.measureBBoxAndMaybeInvalidateLayoutInRaf()}redraw(){window.cancelAnimationFrame(this._redrawRaf),this._redrawRaf=window.requestAnimationFrame(()=>{this.measureBBoxAndMaybeInvalidateLayout(),this.outer.redraw()})}measureBBoxAndMaybeInvalidateLayoutInRaf(){window.cancelAnimationFrame(this._invalidateLayoutRaf),this._invalidateLayoutRaf=window.requestAnimationFrame(()=>{this.measureBBoxAndMaybeInvalidateLayout()})}measureBBoxAndMaybeInvalidateLayout(){if(this._lastDrawBBox){let{width:t}=this._lastDrawBBox,{width:r}=this.targetSVG.node().getBoundingClientRect();t==0&&t<r&&this.outer.invalidateCache()}this._lastDrawBBox=this.targetSVG.node().getBoundingClientRect()}destroy(){window.cancelAnimationFrame(this._redrawRaf),window.cancelAnimationFrame(this._invalidateLayoutRaf),this.outer&&this.outer.destroy()}onAnchor(t){this.outer&&this.outer.onAnchor(t)}isDataFitToDomain(){return t(this.xAxis.getScale())&&t(this.yAxis.getScale());function t(r){let n=r.getTransformationDomain(),i=r.getTransformationExtent();return i[0]===n[0]&&i[1]===n[1]}}};var XKt=Ee(Oe(),1),nst=Ee(wl(),1);_s({moduleName:"plottable-style",styleContent:`
    
.plottable-colors-0 {
  background-color: #5279c7; /* INDIGO */
}

.plottable-colors-1 {
  background-color: #fd373e; /* CORAL_RED */
}

.plottable-colors-2 {
  background-color: #63c261; /* FERN */
}

.plottable-colors-3 {
  background-color: #fad419; /* BRIGHT_SUN */
}

.plottable-colors-4 {
  background-color: #2c2b6f; /* JACARTA */
}

.plottable-colors-5 {
  background-color: #ff7939; /* BURNING_ORANGE */
}

.plottable-colors-6 {
  background-color: #db2e65; /* CERISE_RED */
}

.plottable-colors-7 {
  background-color: #99ce50; /* CONIFER */
}

.plottable-colors-8 {
  background-color: #962565; /* ROYAL_HEATH */
}

.plottable-colors-9 {
  background-color: #06cccc; /* ROBINS_EGG_BLUE */
}

/**
 * User-supplied renderTo element.
 */
.plottable {
  display: block; /* must be block elements for width/height calculations to work in Firefox. */
  pointer-events: visibleFill;
  position: relative;
  /**
   * Pre 3.0, users could set the dimension of the root element in two ways: either using CSS
   * (inline or through a stylesheet), or using the SVG width/height attributes. By default, we
   * set the SVG width/height attributes to 100%.
   *
   * Post 3.0 the root element is always a normal div and the only way to set the dimensions is
   * to use CSS. To replicate the "100%-by-default" behavior, we apply width/height 100%.
   */
  width: 100%;
  height: 100%;
}

/**
 * The _element that roots each Component's DOM.
 */
.plottable .component {
  /* Allow components to be positioned with explicit left/top/width/height styles */
  position: absolute;
}

.plottable .background-container,
.plottable .content,
.plottable .foreground-container {
  position: absolute;
  width: 100%;
  height: 100%;
}

/**
 * Don't allow svg elements above the content to steal events
 */
.plottable .foreground-container {
  pointer-events: none;
}

.plottable .component-overflow-hidden {
  overflow: hidden;
}

.plottable .component-overflow-visible {
  overflow: visible;
}

.plottable .plot-canvas-container {
  width: 100%;
  height: 100%;
  overflow: hidden;
}

.plottable .plot-canvas {
  width: 100%;
  height: 100%;
  /**
   * Play well with deferred rendering.
   */
  transform-origin: 0px 0px 0px;
}

.plottable text {
  text-rendering: geometricPrecision;
}

.plottable .label text {
  fill: #32313F;
}

.plottable .bar-label-text-area text,
.plottable .scatter-label-text-area text {
  font-size: 12px;
}

.plottable .label-area text {
  fill: #32313F;
  font-size: 14px;
}

.plottable .light-label text {
  fill: white;
}

.plottable .dark-label text {
  fill: #32313F;
}

.plottable .off-bar-label text {
  fill: #32313F;
}

.plottable .stacked-bar-label text {
  fill: #32313F;
  font-style: normal;
}

.plottable .stacked-bar-plot .off-bar-label {
  /* HACKHACK #2795: correct off-bar label logic to be implemented on StackedBar */
  visibility: hidden !important;
}

.plottable .axis-label text {
  font-size: 10px;
  font-weight: bold;
  letter-spacing: 1px;
  line-height: normal;
  text-transform: uppercase;
}

.plottable .title-label text {
  font-size: 20px;
  font-weight: bold;
}

.plottable .axis line.baseline {
  stroke: #CCC;
  stroke-width: 1px;
}

.plottable .axis line.tick-mark {
  stroke: #CCC;
  stroke-width: 1px;
}

.plottable .axis text {
  fill: #32313F;
  font-size: 12px;
  font-weight: 200;
  line-height: normal;
}

.plottable .axis .annotation-circle {
  fill: white;
  stroke-width: 1px;
  stroke: #CCC;
}

.plottable .axis .annotation-line {
  stroke: #CCC;
  stroke-width: 1px;
}

.plottable .axis .annotation-rect {
  stroke: #CCC;
  stroke-width: 1px;
  fill: white;
}

.plottable .bar-plot .baseline {
  stroke: #999;
}

.plottable .gridlines line {
  stroke: #3C3C3C; /* hackhack: gridlines should be solid; see #820 */
  opacity: 0.25;
  stroke-width: 1px;
}

.plottable .selection-box-layer .selection-area {
  fill: black;
  fill-opacity: 0.03;
  stroke: #CCC;
}
/* DragBoxLayer */
.plottable .drag-box-layer.x-resizable .drag-edge-lr {
  cursor: ew-resize;
}
.plottable .drag-box-layer.y-resizable .drag-edge-tb {
  cursor: ns-resize;
}

.plottable .drag-box-layer.x-resizable.y-resizable .drag-corner-tl {
  cursor: nwse-resize;
}
.plottable .drag-box-layer.x-resizable.y-resizable .drag-corner-tr {
  cursor: nesw-resize;
}
.plottable .drag-box-layer.x-resizable.y-resizable .drag-corner-bl {
  cursor: nesw-resize;
}
.plottable .drag-box-layer.x-resizable.y-resizable .drag-corner-br {
  cursor: nwse-resize;
}

.plottable .drag-box-layer.movable .selection-area {
  cursor: move; /* IE fallback */
  cursor: -moz-grab;
  cursor: -webkit-grab;
  cursor: grab;
}

.plottable .drag-box-layer.movable .selection-area:active {
  cursor: -moz-grabbing;
  cursor: -webkit-grabbing;
  cursor: grabbing;
}
/* /DragBoxLayer */

.plottable .guide-line-layer line.guide-line {
  stroke: #CCC;
  stroke-width: 1px;
}

.plottable .drag-line-layer.enabled.vertical line.drag-edge {
  cursor: ew-resize;
}

.plottable .drag-line-layer.enabled.horizontal line.drag-edge {
  cursor: ns-resize;
}

.plottable .legend text {
  fill: #32313F;
  font-size: 12px;
  font-weight: bold;
  line-height: normal;
}

.plottable .interpolated-color-legend rect.swatch-bounding-box {
  fill: none;
  stroke: #CCC;
  stroke-width: 1px;
  pointer-events: none;
}

.plottable .waterfall-plot line.connector {
  stroke: #CCC;
  stroke-width: 1px;
}

.plottable .pie-plot .arc.outline {
  stroke-linejoin: round;
}

`});var i0;(function(e){e.GROUP="G",e.DIV="DIV",e.SVG="SVG",e.TEXT="TEXT"})(i0||(i0={}));var est=class{constructor(t){this.uniqueId=0,this.root=t}exportAsString(){let t=this.convert(this.root);if(!t)return"";let r=this.createRootSvg();return r.appendChild(t),r.outerHTML}createUniqueId(t){return`${t}_${this.uniqueId++}`}getSize(){return this.root.getBoundingClientRect()}createRootSvg(){let t=document.createElement("svg"),r=this.getSize();return t.setAttributeNS("svg","viewBox",`0 0 ${r.width} ${r.height}`),t.setAttribute("xmlns","http://www.w3.org/2000/svg"),t}createConvertedNode(t){let r=t.nodeName.toUpperCase();if(t.nodeType==Node.ELEMENT_NODE&&(r==i0.DIV||r==i0.SVG)){let n=document.createElement(i0.GROUP),i=window.getComputedStyle(t),o=parseInt(i.left,10),a=parseInt(i.top,10);if(o||a){let s=this.createUniqueId("clip");n.setAttribute("transform",`translate(${o}, ${a})`),n.setAttribute("clip-path",`url(#${s})`);let l=parseInt(i.width,10),c=parseInt(i.height,10),u=document.createElement("rect");u.setAttribute("width",String(l)),u.setAttribute("height",String(c));let h=document.createElementNS("svg","clipPath");h.id=s,h.appendChild(u),n.appendChild(h)}return n}else return t.cloneNode()}convert(t){let r=this.createConvertedNode(t);return Array.from(t.childNodes).map(i=>this.convert(i)).filter(Boolean).forEach(i=>{r.appendChild(i)}),r.nodeName.toUpperCase()==i0.GROUP&&!r.hasChildNodes()||this.shouldOmitNode(t)?null:this.stripClass(this.transferStyle(t,r))}stripClass(t){return t.nodeType==Node.ELEMENT_NODE&&t.removeAttribute("class"),t}transferStyle(t,r){if(r.nodeType!=Node.ELEMENT_NODE)return r;let n=r,i=r.nodeName.toUpperCase(),o=window.getComputedStyle(t);return i==i0.TEXT&&Object.assign(n.style,{fontFamily:o.fontFamily,fontSize:o.fontSize,fontWeight:o.fontWeight}),i!=i0.GROUP&&(n.setAttribute("fill",o.fill),n.setAttribute("stroke",o.stroke),n.setAttribute("stroke-width",o.strokeWidth)),o.opacity!="1"&&n.setAttribute("opacity",o.opacity),r}shouldOmitNode(t){return!1}},LB=class extends est{shouldOmitNode(t){return t.nodeType==Node.ELEMENT_NODE?t.classList.contains("scatter-plot"):!1}};_s({moduleName:"vz-pan-zoom-style",styleContent:`
    .help {
      align-items: center;
      animation-delay: 1s;
      animation-duration: 1s;
      animation-name: fade-out;
      background: rgba(30, 30, 30, 0.6);
      bottom: 0;
      color: #fff;
      display: flex;
      justify-content: center;
      left: 0;
      opacity: 1;
      padding: 20px;
      pointer-events: none;
      position: absolute;
      right: 0;
      top: 0;
    }

    .help > span {
      white-space: normal;
    }

    @keyframes fade-out {
      0% {
        opacity: 1;
      }

      100% {
        opacity: 0;
      }
    }
  `});var Oqe=Wu(e0),jKt=e=>isNaN(e)?"NaN":Oqe(e),ist=[{title:"Name",evaluate:e=>e.dataset.metadata().name},{title:"Smoothed",evaluate(e,t){let{smoothingEnabled:r}=t;return jKt(r?e.datum.smoothed:e.datum.scalar)}},{title:"Value",evaluate:e=>jKt(e.datum.scalar)},{title:"Step",evaluate:e=>b4(e.datum.step)},{title:"Time",evaluate:e=>yB(e.datum.wall_time)},{title:"Relative",evaluate:e=>vB(r0(e.datum,-1,e.dataset))}],Zr=class extends Gt(mt){constructor(){super(...arguments),this.colorScale=new nst.Scales.Color().range(jb.slice(0)),this.smoothingEnabled=!1,this.smoothingWeight=.6,this.xType=null,this.xComponentsCreationMethod=null,this.yValueAccessor=t=>t.scalar,this.tooltipColumns=ist,this.yScaleType=Ff.LINEAR,this.ignoreYOutliers=!1,this.tooltipSortingMethod="default",this.tooltipPosition=Gv.BOTTOM,this._visibleSeriesCache=[],this._seriesDataCache={},this._seriesMetadataCache={},this._makeChartAsyncCallbackId=null}ready(){super.ready(),this.scopeSubtree(this.$.chartdiv,!0)}attached(){let t={capture:!0,passive:!0};this._listen(this,"mousedown",this._onMouseDown.bind(this),t),this._listen(this,"mouseup",this._onMouseUp.bind(this),t),this._listen(window,"keydown",this._onKeyDown.bind(this),t),this._listen(window,"keyup",this._onKeyUp.bind(this),t)}detached(){this._makeChartAsyncCallbackId!==null&&(this.cancelAsync(this._makeChartAsyncCallbackId),this._makeChartAsyncCallbackId=null),this._chart&&(this._chart.destroy(),this._chart=void 0),this._listeners&&(this._listeners.forEach(({node:t,eventName:r,func:n,option:i})=>{t.removeEventListener(r,n,i)}),this._listeners.clear())}_listen(t,r,n,i={}){this._listeners||(this._listeners=new Set),this._listeners.add({node:t,eventName:r,func:n,option:i}),t.addEventListener(r,n,i)}_onKeyDown(t){this.toggleClass("pankey",zf.isPanKey(t))}_onKeyUp(t){this.toggleClass("pankey",zf.isPanKey(t))}_onMouseDown(t){this.toggleClass("mousedown",!0)}_onMouseUp(t){this.toggleClass("mousedown",!1)}isDataFitToDomain(){return this._chart?this._chart.isDataFitToDomain():!0}setVisibleSeries(t){XKt.isEqual(this._visibleSeriesCache,t)||(this._visibleSeriesCache=t)}setSeriesData(t,r){this._seriesDataCache[t]=r,this._chart&&this._chart.setSeriesData(t,r)}setSeriesMetadata(t,r){this._seriesMetadataCache[t]=r,this._chart&&this._chart.setSeriesMetadata(t,r)}commitChanges(){!this._chart||this._chart.commitChanges()}resetDomain(){this._chart&&this._chart.resetDomain()}redraw(){this._chart&&this._chart.redraw()}_makeChart(){this._makeChartAsyncCallbackId!==null&&(this.cancelAsync(this._makeChartAsyncCallbackId),this._makeChartAsyncCallbackId=null),this._makeChartAsyncCallbackId=this.async(function(){this._makeChartAsyncCallbackId=null;let t=this.xComponentsCreationMethod;if(!this.xType&&!t?t=Xat:this.xType&&(t=()=>xB(this.xType)),!(!t||!this.yValueAccessor||!this.tooltipColumns)){var r=new DS(t,this.yValueAccessor,this.yScaleType,this.colorScale,this.$.tooltip,this.tooltipColumns,this.fillArea,this.defaultXRange,this.defaultYRange,this.symbolFunction,this.xAxisFormatter),n=Ht(this.$.chartdiv);r.renderTo(n),this._chart&&this._chart.destroy(),this._chart=r,this._chart.onAnchor(()=>this.fire("chart-attached"))}},350)}_reloadFromCache(){!this._chart||(this._visibleSeriesCache.forEach(t=>{this._chart.setSeriesData(t,this._seriesDataCache[t]||[])}),this._visibleSeriesCache.filter(t=>this._seriesMetadataCache[t]).forEach(t=>{this._chart.setSeriesMetadata(t,this._seriesMetadataCache[t])}),this._chart.setVisibleSeries(this._visibleSeriesCache),this._chart.commitChanges())}_smoothingChanged(){!this._chart||(this.smoothingEnabled?this._chart.smoothingUpdate(this.smoothingWeight):this._chart.smoothingDisable())}_outliersChanged(){!this._chart||this._chart.ignoreYOutliers(this.ignoreYOutliers)}_colorScaleChanged(){!this._chart||(this._chart.setColorScale(this.colorScale),this._chart.redraw())}_tooltipColumnsChanged(){!this._chart||this._chart.setTooltipColumns(this.tooltipColumns)}_tooltipSortingMethodChanged(){!this._chart||this._chart.setTooltipSortingMethod(this.tooltipSortingMethod)}getExporter(){return new LB(this.$.chartdiv)}};Zr.template=Q`
    <div id="chartdiv"></div>
    <vz-chart-tooltip
      id="tooltip"
      position="[[tooltipPosition]]"
      content-component-name="vz-line-chart-tooltip"
    ></vz-chart-tooltip>
    <style include="plottable-style"></style>
    <style include="vz-pan-zoom-style"></style>
    <style>
      :host {
        -moz-user-select: none;
        -webkit-user-select: none;
        display: flex;
        flex-direction: column;
        flex-grow: 1;
        flex-shrink: 1;
        outline: none;
        position: relative;
        white-space: nowrap;
      }
      div {
        -webkit-user-select: none;
        -moz-user-select: none;
        flex-grow: 1;
        flex-shrink: 1;
      }

      #chartdiv .main {
        contain: strict;
        cursor: crosshair;
      }

      :host(.pankey) #chartdiv :not(.drag-zooming) .main {
        cursor: -webkit-grab;
        cursor: grab;
      }

      :host(.mousedown) #chartdiv .panning .main {
        cursor: -webkit-grabbing;
        cursor: grabbing;
      }

      #chartdiv {
        contain: strict;
      }

      #chartdiv line.guide-line {
        stroke: #999;
        stroke-width: 1.5px;
      }
      #chartdiv:hover .main {
        will-change: transform;
      }

      .ghost {
        opacity: 0.2;
        stroke-width: 1px;
      }

      .plottable .axis text {
        fill: currentColor;
      }

      .plottable .gridlines line {
        stroke: var(--tb-secondary-text-color);
      }
    </style>
  `;E([A({type:Object}),w("design:type",nst.Scales.Color)],Zr.prototype,"colorScale",void 0);E([A({type:Object}),w("design:type",Function)],Zr.prototype,"symbolFunction",void 0);E([A({type:Boolean,notify:!0}),w("design:type",Boolean)],Zr.prototype,"smoothingEnabled",void 0);E([A({type:Number}),w("design:type",Number)],Zr.prototype,"smoothingWeight",void 0);E([A({type:String}),w("design:type",Object)],Zr.prototype,"xType",void 0);E([A({type:Object}),w("design:type",Object)],Zr.prototype,"xComponentsCreationMethod",void 0);E([A({type:Object}),w("design:type",Function)],Zr.prototype,"xAxisFormatter",void 0);E([A({type:Object}),w("design:type",Function)],Zr.prototype,"yValueAccessor",void 0);E([A({type:Array}),w("design:type",Array)],Zr.prototype,"tooltipColumns",void 0);E([A({type:Object}),w("design:type",Object)],Zr.prototype,"fillArea",void 0);E([A({type:Array}),w("design:type",Array)],Zr.prototype,"defaultXRange",void 0);E([A({type:Array}),w("design:type",Array)],Zr.prototype,"defaultYRange",void 0);E([A({type:String}),w("design:type",String)],Zr.prototype,"yScaleType",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Zr.prototype,"ignoreYOutliers",void 0);E([A({type:String}),w("design:type",String)],Zr.prototype,"tooltipSortingMethod",void 0);E([A({type:String}),w("design:type",String)],Zr.prototype,"tooltipPosition",void 0);E([A({type:Object}),w("design:type",Object)],Zr.prototype,"_chart",void 0);E([A({type:Array}),w("design:type",Array)],Zr.prototype,"_visibleSeriesCache",void 0);E([A({type:Object}),w("design:type",Object)],Zr.prototype,"_seriesDataCache",void 0);E([A({type:Object}),w("design:type",Object)],Zr.prototype,"_seriesMetadataCache",void 0);E([A({type:Number}),w("design:type",Object)],Zr.prototype,"_makeChartAsyncCallbackId",void 0);E([Bt("xComponentsCreationMethod","xType","yValueAccessor","yScaleType","isAttached"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Zr.prototype,"_makeChart",null);E([Bt("_chart","_visibleSeriesCache"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Zr.prototype,"_reloadFromCache",null);E([Bt("smoothingEnabled","smoothingWeight","_chart"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Zr.prototype,"_smoothingChanged",null);E([Bt("ignoreYOutliers","_chart"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Zr.prototype,"_outliersChanged",null);E([Bt("colorScale"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Zr.prototype,"_colorScaleChanged",null);E([Bt("tooltipColumns"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Zr.prototype,"_tooltipColumnsChanged",null);E([Bt("tooltipSortingMethod","_chart"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Zr.prototype,"_tooltipSortingMethodChanged",null);Zr=E([yt("vz-line-chart2")],Zr);var rst=class extends mt{};rst.template=Q`
    <div class="content">
      <table>
        <thead></thead>
        <tbody></tbody>
      </table>
    </div>
    <style>
      :host {
        pointer-events: none;
      }

      .content {
        background: rgba(0, 0, 0, 0.8);
        border-radius: 4px;
        color: #fff;
        overflow: hidden;
        pointer-events: none;
      }

      table {
        font-size: 13px;
        line-height: 1.4em;
        margin-top: 10px;
        padding: 8px;
      }

      thead {
        font-size: 14px;
      }

      tbody {
        font-size: 13px;
        line-height: 21px;
        white-space: nowrap;
      }

      td {
        padding: 0 5px;
      }

      .swatch {
        border-radius: 50%;
        display: block;
        height: 18px;
        width: 18px;
      }

      .closest .swatch {
        box-shadow: inset 0 0 0 2px #fff;
      }

      th {
        padding: 0 5px;
        text-align: left;
      }

      .distant td:not(.swatch) {
        opacity: 0.8;
      }

      .ghost {
        opacity: 0.2;
        stroke-width: 1px;
      }
    </style>
  `;rst=E([yt("vz-line-chart-tooltip")],rst);var ost=[],zqe=0,Fqe=$Kt.throttle(function e(){if(ost.length==0)return;let t=ost.shift();t&&t.active&&(t.redraw(),t._maybeRenderedInBadState=!1),window.cancelAnimationFrame(zqe),window.requestAnimationFrame(e)},100),Hn=class extends kS(Gt(mt)){constructor(){super(...arguments),this._redrawRaf=null,this.active=!1,this.logScaleActive=!1,this.colorScale={scale:fn},this._resetDomainOnNextLoad=!0,this._maybeRenderedInBadState=!1}onLoadFinish(){this.commitChanges(),this.dataToLoad.length>0&&this._resetDomainOnNextLoad&&(this._resetDomainOnNextLoad=!1,this.getChart().resetDomain()),this.redraw()}disconnectedCallback(){super.disconnectedCallback(),this._redrawRaf!==null&&cancelAnimationFrame(this._redrawRaf)}exportAsSvgString(){return this.getChart().getExporter().exportAsString()}getChart(){return this.$.chart}resetDomain(){this.getChart().resetDomain()}setSeriesData(t,r){this.getChart().setSeriesData(t,r)}setSeriesMetadata(t,r){this.getChart().setSeriesMetadata(t,r)}commitChanges(){this.getChart().commitChanges()}redraw(){this._redrawRaf!==null&&cancelAnimationFrame(this._redrawRaf),this._redrawRaf=window.requestAnimationFrame(()=>{this.active?this.getChart().redraw():this._maybeRenderedInBadState=!0})}_loadKeyChanged(){this.reset(),this._resetDomainOnNextLoad=!0}_dataSeriesChanged(){this.getChart().setVisibleSeries(this.dataSeries)}_logScaleChanged(t){let r=this.getChart();r.yScaleType=t?Ff.LOG:Ff.LINEAR,this.redraw()}_fixBadStateWhenActive(){this.active&&this._maybeRenderedInBadState&&(ost.push(this),Fqe())}_onChartAttached(){this.active||(this._maybeRenderedInBadState=!0)}};Hn.template=Q`
    <div id="chart-and-spinner-container">
      <vz-line-chart2
        id="chart"
        data-loading$="[[dataLoading]]"
        data-loaded-once$="[[dataLoadedAtLeastOnce]]"
        color-scale="[[colorScale]]"
        default-x-range="[[defaultXRange]]"
        default-y-range="[[defaultYRange]]"
        fill-area="[[fillArea]]"
        ignore-y-outliers="[[ignoreYOutliers]]"
        on-chart-attached="_onChartAttached"
        smoothing-enabled="[[smoothingEnabled]]"
        smoothing-weight="[[smoothingWeight]]"
        symbol-function="[[symbolFunction]]"
        tooltip-columns="[[tooltipColumns]]"
        tooltip-position="[[tooltipPosition]]"
        tooltip-sorting-method="[[tooltipSortingMethod]]"
        x-components-creation-method="[[xComponentsCreationMethod]]"
        x-type="[[xType]]"
        y-value-accessor="[[yValueAccessor]]"
      ></vz-line-chart2>
      <template is="dom-if" if="[[dataLoading]]">
        <div id="loading-spinner-container">
          <paper-spinner-lite active=""></paper-spinner-lite>
        </div>
      </template>
    </div>
    <style>
      :host {
        height: 100%;
        width: 100%;
        display: flex;
        flex-direction: column;
      }

      :host([_maybe-rendered-in-bad-state]) vz-line-chart {
        visibility: hidden;
      }

      #chart-and-spinner-container {
        display: flex;
        flex-grow: 1;
        position: relative;
      }

      #loading-spinner-container {
        align-items: center;
        bottom: 0;
        display: flex;
        display: flex;
        justify-content: center;
        left: 0;
        pointer-events: none;
        position: absolute;
        right: 0;
        top: 0;
      }

      vz-line-chart2 {
        -webkit-user-select: none;
        -moz-user-select: none;
      }

      vz-line-chart2[data-loading] {
        opacity: 0.3;
      }
    </style>
  `;E([A({type:Boolean,observer:"_fixBadStateWhenActive"}),w("design:type",Boolean)],Hn.prototype,"active",void 0);E([A({type:Array}),w("design:type",Array)],Hn.prototype,"dataSeries",void 0);E([A({type:Object}),w("design:type",Ae)],Hn.prototype,"requestManager",void 0);E([A({type:Boolean,observer:"_logScaleChanged"}),w("design:type",Boolean)],Hn.prototype,"logScaleActive",void 0);E([A({type:Object}),w("design:type",Object)],Hn.prototype,"xComponentsCreationMethod",void 0);E([A({type:String}),w("design:type",String)],Hn.prototype,"xType",void 0);E([A({type:Object}),w("design:type",Function)],Hn.prototype,"yValueAccessor",void 0);E([A({type:Object}),w("design:type",Object)],Hn.prototype,"fillArea",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Hn.prototype,"smoothingEnabled",void 0);E([A({type:Number}),w("design:type",Number)],Hn.prototype,"smoothingWeight",void 0);E([A({type:Array}),w("design:type",Array)],Hn.prototype,"tooltipColumns",void 0);E([A({type:String}),w("design:type",Object)],Hn.prototype,"tooltipSortingMethod",void 0);E([A({type:String}),w("design:type",String)],Hn.prototype,"tooltipPosition",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Hn.prototype,"ignoreYOutliers",void 0);E([A({type:Array}),w("design:type",Array)],Hn.prototype,"defaultXRange",void 0);E([A({type:Array}),w("design:type",Array)],Hn.prototype,"defaultYRange",void 0);E([A({type:Object}),w("design:type",Function)],Hn.prototype,"symbolFunction",void 0);E([A({type:Object}),w("design:type",Object)],Hn.prototype,"colorScale",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Hn.prototype,"_resetDomainOnNextLoad",void 0);E([A({type:Boolean,reflectToAttribute:!0}),w("design:type",Boolean)],Hn.prototype,"_maybeRenderedInBadState",void 0);E([Bt("loadKey"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Hn.prototype,"_loadKeyChanged",null);E([Bt("dataSeries.*"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Hn.prototype,"_dataSeriesChanged",null);Hn=E([yt("tf-line-chart-data-loader")],Hn);_s({moduleName:"tf-custom-scalar-card-style",styleContent:`
    :host {
      margin: 5px 10px;
      display: inline-block;
      width: 330px;
      vertical-align: text-top;
    }

    :host([_expanded]) {
      width: 100%;
    }

    :host([_expanded]) #tf-line-chart-data-loader-container {
      height: 400px;
    }

    h1 {
      font-size: 19px;
      font-weight: normal;
    }

    #tf-line-chart-data-loader-container {
      height: 200px;
      width: 100%;
    }

    #buttons {
      display: flex;
      flex-direction: row;
    }

    paper-icon-button {
      color: #2196f3;
      border-radius: 100%;
      width: 32px;
      height: 32px;
      padding: 4px;
    }

    paper-icon-button[selected] {
      background: var(--tb-ui-light-accent);
    }

    .download-links {
      display: flex;
      height: 32px;
    }

    .download-links a {
      font-size: 10px;
      align-self: center;
      margin: 2px;
    }

    .download-links paper-dropdown-menu {
      width: 100px;
      --paper-input-container-label: {
        font-size: 10px;
      }
      --paper-input-container-input: {
        font-size: 10px;
      }
    }
  `});var OS=class{constructor(t,r,n,i,o){this.run=t,this.tag=r,this.name=n,this.scalarData=i,this.symbol=o}getName(){return this.name}setData(t){this.scalarData=t}getData(){return this.scalarData}getRun(){return this.run}getTag(){return this.tag}getSymbol(){return this.symbol}};function kB(e,t){return`${t} (${e})`}var Wv=class{constructor(t){this.runBasedColorScale=t}scale(t){return this.runBasedColorScale.scale(this.parseRunName(t))}parseRunName(t){let r=t.match(/\((.*)\)$/);return r?r[1]:""}};var Jr=class extends Gt(mt){constructor(){super(...arguments),this.active=!0,this._colorScale=new Wv({scale:fn}),this._nameToDataSeries={},this._expanded=!1,this._requestData=(t,r,n)=>{let o=_e().pluginRoute("custom_scalars","/scalars");Promise.all(t.map(a=>{let s=a,l=this._tagFilter,c=Mi(o,{tag:l,run:s});return this.requestManager.request(c).then(u=>void r({item:a,data:u}))})).finally(()=>void n())},this._runToNextAvailableSymbolIndex={},this._matchesListOpened=!1,this._fillArea={lowerAccessor:t=>t.lower,higherAccessor:t=>t.upper},this._tooltipColumns=(()=>{let t=Wu(e0),r=n=>isNaN(n)?"NaN":t(n);return[{title:"Name",evaluate:n=>n.dataset.metadata().name},{title:"Value",evaluate:n=>r(n.datum.scalar)},{title:"Lower Margin",evaluate:n=>r(n.datum.lower)},{title:"Upper Margin",evaluate:n=>r(n.datum.upper)},{title:"Step",evaluate:n=>b4(n.datum.step)},{title:"Time",evaluate:n=>yB(n.datum.wall_time)},{title:"Relative",evaluate:n=>vB(r0(n.datum,-1,n.dataset))}]})(),this._missingTags=[],this._missingTagsCollapsibleOpened=!1}reload(){this.$.loader.reload()}redraw(){this.$.loader.redraw()}_toggleExpanded(t){this.set("_expanded",!this._expanded),this.redraw()}_toggleLogScale(){this.set("_logScaleActive",!this._logScaleActive)}_resetDomain(){let t=this.$.loader;t&&t.resetDomain()}_csvUrl(t,r){if(!r)return"";let n=this._downloadDataUrl(t,r);return Mi(n,{format:"csv"})}_jsonUrl(t,r){if(!r)return"";let n=this._downloadDataUrl(t,r);return Mi(n,{format:"json"})}_downloadDataUrl(t,r){let n=t[r],i=new URLSearchParams({tag:n.getTag(),run:n.getRun()});return _e().pluginRouteForSrc("custom_scalars","/download_data",i)}_createProcessDataFunction(t){return(r,n,i)=>{if(!i.regex_valid){this.set("_tagFilterInvalid",!0);return}let o=Yo.clone(this._nameToDataSeries),a=[];Yo.forEach(t,l=>{let c=!1,u=i.tag_to_events[l.value],h=i.tag_to_events[l.lower],f=i.tag_to_events[l.upper];if(Yo.isUndefined(u)&&(a.push(l.value),c=!0),Yo.isUndefined(h)&&(a.push(l.lower),c=!0),Yo.isUndefined(f)&&(a.push(l.upper),c=!0),c)return;let p=b=>b[1],d=this._findStepMismatch(l,u.map(p),h.map(p),f.map(p));if(d){this.set("_stepsMismatch",d);return}let g=b=>b[2],_=u.map((b,S)=>({wall_time:new Date(b[0]*1e3),step:p(b),scalar:g(b),lower:g(h[S]),upper:g(f[S])})),y=kB(n,l.value),x=o[y];if(x)x.setData(_);else{let b=this._createNewDataSeries(n,l.value,y,_);o[y]=b}}),this.set("_nameToDataSeries",o);let s=Yo.findIndex(this._missingTags,l=>l.run===n);if(a.length&&a.length!=3){let l={run:n,tags:a};s>=0?this.splice("_missingTags",s,1,l):this.push("_missingTags",l)}else s>=0&&this.splice("_missingTags",s,1)}}_findStepMismatch(t,r,n,i){return Yo.isEqual(n,r)&&Yo.isEqual(i,r)?null:{seriesObject:t,valueSteps:r,lowerSteps:n,upperSteps:i}}_createNewDataSeries(t,r,n,i){this._runToNextAvailableSymbolIndex[t]|=0;let o=RS[this._runToNextAvailableSymbolIndex[t]],a=new OS(t,r,n,i,o),s=RS.length;return this._runToNextAvailableSymbolIndex[t]=(this._runToNextAvailableSymbolIndex[t]+1)%s,a}_updateChart(){var t=this._nameToDataSeries;Yo.forOwn(t,r=>{this.$.loader.setSeriesData(r.getName(),r.getData())}),this.$.loader.commitChanges()}get _seriesNames(){let t=new Set(this.runs);return Object.entries(this._nameToDataSeries).filter(([r,n])=>t.has(n.run)).map(([r])=>r)}_determineColor(t,r){return t.scale(r)}_refreshDataSeries(){var t=this._tagFilter;this.set("_nameToDataSeries",{})}_createSymbolFunction(){return t=>this._nameToDataSeries[t].getSymbol().method()}_determineSymbol(t,r){return t[r].getSymbol().character}get _tagFilter(){var t=this.marginChartSeries;return Yo.flatten(t.map(i=>[i.value,i.lower,i.upper])).map(i=>"("+this._escapeRegexCharacters(i)+")").join("|")}_escapeRegexCharacters(t){return t.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}_getToggleCollapsibleIcon(t){return t?"expand-less":"expand-more"}_toggleMatchesOpen(){this.set("_matchesListOpened",!this._matchesListOpened)}get _titleDisplayString(){var t=this.title;return t||"untitled"}_separateWithCommas(t){return t.join(", ")}_toggleMissingTagsCollapsibleOpen(){this.set("_missingTagsCollapsibleOpened",!this._missingTagsCollapsibleOpened)}_matchListEntryColorUpdated(){var r;let t=this.$$("#match-list-repeat");!t||(r=this.root)==null||r.querySelectorAll(".match-list-entry").forEach(n=>{let i=t.itemForElement(n);n.style.color=this._determineColor(this._colorScale,i)})}};Jr.template=Q`
    <tf-card-heading display-name="[[_titleDisplayString]]"></tf-card-heading>
    <div id="tf-line-chart-data-loader-container">
      <tf-line-chart-data-loader
        id="loader"
        active="[[active]]"
        color-scale="[[_colorScale]]"
        data-series="[[_seriesNames]]"
        fill-area="[[_fillArea]]"
        ignore-y-outliers="[[ignoreYOutliers]]"
        load-key="[[_tagFilter]]"
        data-to-load="[[runs]]"
        request-data="[[_requestData]]"
        log-scale-active="[[_logScaleActive]]"
        load-data-callback="[[_createProcessDataFunction(marginChartSeries)]]"
        request-manager="[[requestManager]]"
        symbol-function="[[_createSymbolFunction()]]"
        tooltip-columns="[[_tooltipColumns]]"
        tooltip-sorting-method="[[tooltipSortingMethod]]"
        x-type="[[xType]]"
      >
      </tf-line-chart-data-loader>
    </div>
    <div id="buttons">
      <paper-icon-button
        selected$="[[_expanded]]"
        icon="fullscreen"
        on-tap="_toggleExpanded"
      ></paper-icon-button>
      <paper-icon-button
        selected$="[[_logScaleActive]]"
        icon="line-weight"
        on-tap="_toggleLogScale"
        title="Toggle y-axis log scale"
      ></paper-icon-button>
      <paper-icon-button
        icon="settings-overscan"
        on-tap="_resetDomain"
        title="Fit domain to data"
      ></paper-icon-button>
      <span style="flex-grow: 1"></span>
      <template is="dom-if" if="[[showDownloadLinks]]">
        <div class="download-links">
          <paper-dropdown-menu
            no-label-float="true"
            label="series to download"
            selected-item-label="{{_dataSeriesNameToDownload}}"
          >
            <paper-listbox class="dropdown-content" slot="dropdown-content">
              <template
                is="dom-repeat"
                items="[[_seriesNames]]"
                as="dataSeriesName"
              >
                <paper-item no-label-float="true"
                  >[[dataSeriesName]]</paper-item
                >
              </template>
            </paper-listbox>
          </paper-dropdown-menu>
          <a
            download="[[_dataSeriesNameToDownload]].csv"
            href="[[_csvUrl(_nameToDataSeries, _dataSeriesNameToDownload)]]"
            >CSV</a
          >
          <a
            download="[[_dataSeriesNameToDownload]].json"
            href="[[_jsonUrl(_nameToDataSeries, _dataSeriesNameToDownload)]]"
            >JSON</a
          >
        </div>
      </template>
    </div>

    <!-- here -->
    <template is="dom-if" if="[[_missingTags.length]]">
      <div class="collapsible-list-title">
        <paper-icon-button
          icon="[[_getToggleCollapsibleIcon(_missingTagsCollapsibleOpened)]]"
          on-click="_toggleMissingTagsCollapsibleOpen"
          class="toggle-collapsible-button"
        >
        </paper-icon-button>
        <span class="collapsible-title-text">
          <iron-icon icon="icons:error"></iron-icon> Missing Tags
        </span>
      </div>
      <iron-collapse opened="[[_missingTagsCollapsibleOpened]]">
        <div class="error-content">
          <iron-icon class="error-icon" icon="icons:error"></iron-icon>
          <template is="dom-repeat" items="[[_missingTags]]" as="missingEntry">
            <div class="missing-tags-for-run-container">
              Run "[[missingEntry.run]]" lacks data for tags
              <ul>
                <template
                  is="dom-repeat"
                  items="[[missingEntry.tags]]"
                  as="tag"
                >
                  <li>[[tag]]</li>
                </template>
              </ul>
            </div>
          </template>
        </div>
      </iron-collapse>
    </template>

    <template is="dom-if" if="[[_tagFilterInvalid]]">
      <div class="error-content">
        <iron-icon class="error-icon" icon="icons:error"></iron-icon>
        This regular expresion is invalid:<br />
        <span class="invalid-regex">[[_tagFilter]]</span>
      </div>
    </template>

    <template is="dom-if" if="[[_stepsMismatch]]">
      <div class="error-content">
        <iron-icon class="error-icon" icon="icons:error"></iron-icon>
        The steps for value, lower, and upper tags do not match:
        <ul>
          <li>
            <span class="tag-name">[[_stepsMismatch.seriesObject.value]]</span>:
            [[_separateWithCommas(_stepsMismatch.valueSteps)]]
          </li>
          <li>
            <span class="tag-name">[[_stepsMismatch.seriesObject.lower]]</span>:
            [[_separateWithCommas(_stepsMismatch.lowerSteps)]]
          </li>
          <li>
            <span class="tag-name">[[_stepsMismatch.seriesObject.upper]]</span>:
            [[_separateWithCommas(_stepsMismatch.upperSteps)]]
          </li>
        </ul>
      </div>
    </template>

    <div id="matches-container">
      <div class="collapsible-list-title">
        <template is="dom-if" if="[[_seriesNames.length]]">
          <paper-icon-button
            icon="[[_getToggleCollapsibleIcon(_matchesListOpened)]]"
            on-click="_toggleMatchesOpen"
            class="toggle-matches-button"
          >
          </paper-icon-button>
        </template>

        <span class="collapsible-title-text">
          Matches ([[_seriesNames.length]])
        </span>
      </div>
      <template is="dom-if" if="[[_seriesNames.length]]">
        <iron-collapse opened="[[_matchesListOpened]]">
          <div id="matches-list">
            <template
              is="dom-repeat"
              items="[[_seriesNames]]"
              as="seriesName"
              id="match-list-repeat"
              on-dom-change="_matchListEntryColorUpdated"
            >
              <div class="match-list-entry">
                <span class="match-entry-symbol">
                  [[_determineSymbol(_nameToDataSeries, seriesName)]]
                </span>
                [[seriesName]]
              </div>
            </template>
          </div>
        </iron-collapse>
      </template>
    </div>

    <style include="tf-custom-scalar-card-style"></style>
    <style>
      .error-content {
        background: #f00;
        border-radius: 5px;
        color: #fff;
        margin: 10px 0 0 0;
        padding: 10px;
      }

      .error-icon {
        display: block;
        fill: #fff;
        margin: 0 auto 5px auto;
      }

      .invalid-regex {
        font-weight: bold;
      }

      .error-content ul {
        margin: 1px 0 0 0;
        padding: 0 0 0 19px;
      }

      .tag-name {
        font-weight: bold;
      }

      .collapsible-list-title {
        margin: 10px 0 5px 0;
      }

      .collapsible-title-text {
        vertical-align: middle;
      }

      #matches-list {
        max-height: 200px;
        overflow-y: auto;
      }

      .match-list-entry {
        margin: 0 0 5px 0;
      }

      .match-entry-symbol {
        font-family: arial, sans-serif;
        display: inline-block;
        width: 10px;
      }

      .missing-tags-for-run-container {
        margin: 8px 0 0 0;
      }
    </style>
  `;E([A({type:Array}),w("design:type",Array)],Jr.prototype,"runs",void 0);E([A({type:String}),w("design:type",String)],Jr.prototype,"xType",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Jr.prototype,"active",void 0);E([A({type:String}),w("design:type",String)],Jr.prototype,"title",void 0);E([A({type:Array}),w("design:type",Array)],Jr.prototype,"marginChartSeries",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Jr.prototype,"ignoreYOutliers",void 0);E([A({type:Object}),w("design:type",Ae)],Jr.prototype,"requestManager",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Jr.prototype,"showDownloadLinks",void 0);E([A({type:Object}),w("design:type",Object)],Jr.prototype,"tagMetadata",void 0);E([A({type:String}),w("design:type",String)],Jr.prototype,"tooltipSortingMethod",void 0);E([A({type:Object}),w("design:type",Object)],Jr.prototype,"_colorScale",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Jr.prototype,"_tagFilterInvalid",void 0);E([A({type:Object}),w("design:type",Object)],Jr.prototype,"_nameToDataSeries",void 0);E([A({type:Boolean,reflectToAttribute:!0}),w("design:type",Boolean)],Jr.prototype,"_expanded",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Jr.prototype,"_logScaleActive",void 0);E([A({type:Object}),w("design:type",Function)],Jr.prototype,"_requestData",void 0);E([A({type:Object}),w("design:type",Object)],Jr.prototype,"_runToNextAvailableSymbolIndex",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Jr.prototype,"_matchesListOpened",void 0);E([A({type:Object}),w("design:type",Object)],Jr.prototype,"_fillArea",void 0);E([A({type:Array}),w("design:type",Array)],Jr.prototype,"_tooltipColumns",void 0);E([A({type:Array}),w("design:type",Array)],Jr.prototype,"_missingTags",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Jr.prototype,"_missingTagsCollapsibleOpened",void 0);E([A({type:Object}),w("design:type",Object)],Jr.prototype,"_stepsMismatch",void 0);E([Bt("_nameToDataSeries"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Jr.prototype,"_updateChart",null);E([Rt("_nameToDataSeries","runs"),w("design:type",Object),w("design:paramtypes",[])],Jr.prototype,"_seriesNames",null);E([Bt("_tagFilter"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Jr.prototype,"_refreshDataSeries",null);E([Rt("marginChartSeries"),w("design:type",String),w("design:paramtypes",[])],Jr.prototype,"_tagFilter",null);E([Rt("title"),w("design:type",String),w("design:paramtypes",[])],Jr.prototype,"_titleDisplayString",null);Jr=E([yt("tf-custom-scalar-margin-chart-card")],Jr);var o0=Ee(Oe(),1);var RB={};Ks(RB,{BaseStore:()=>bp,Canceller:()=>an,EnvironmentStore:()=>V9,ExperimentsStore:()=>rR,HttpMethodType:()=>Am,InvalidRequestOptionsError:()=>Vx,ListenKey:()=>H9,RequestCancellationError:()=>c9,RequestManager:()=>Ae,RequestNetworkError:()=>uE,RequestOptions:()=>Ux,RunsStore:()=>U9,TYPES:()=>Oxe,addParams:()=>Mi,createRouter:()=>Rgt,createSearchParam:()=>Ngt,environmentStore:()=>ib,experimentsStore:()=>nR,filterTags:()=>Fxe,getRouter:()=>_e,getRunsNamed:()=>zxe,getTags:()=>$i,runsStore:()=>wp});var En=class extends Gt(mt){constructor(){super(...arguments),this.active=!0,this._colorScale=new Wv({scale:fn}),this._nameToDataSeries={},this._expanded=!1,this._requestData=(t,r,n)=>{let o=_e().pluginRoute("custom_scalars","/scalars");Promise.all(t.map(a=>{let s=a,l=this._tagFilter,c=Mi(o,{tag:l,run:s});return this.requestManager.request(c).then(u=>void r({item:a,data:u}))})).finally(()=>void n())},this._runToNextAvailableSymbolIndex={},this._matchesListOpened=!1}reload(){this.$.loader.reload()}redraw(){this.$.loader.redraw()}_toggleExpanded(t){this.set("_expanded",!this._expanded),this.redraw()}_toggleLogScale(){this.set("_logScaleActive",!this._logScaleActive)}_resetDomain(){let t=this.$.loader;t&&t.resetDomain()}_csvUrl(t,r){if(!r)return"";let n=this._downloadDataUrl(t,r);return Mi(n,{format:"csv"})}_jsonUrl(t,r){if(!r)return"";let n=this._downloadDataUrl(t,r);return Mi(n,{format:"json"})}_downloadDataUrl(t,r){let n=t[r],i=new URLSearchParams({tag:n.getTag(),run:n.getRun()});return _e().pluginRouteForSrc("custom_scalars","/download_data",i)}_createProcessDataFunction(){return(t,r,n)=>{if(n.regex_valid){let i=o0.clone(this._nameToDataSeries);o0.forOwn(n.tag_to_events,(o,a)=>{let s=o.map(u=>({wall_time:new Date(u[0]*1e3),step:u[1],scalar:u[2]})),l=kB(r,a),c=i[l];if(c)c.setData(s);else{o0.isUndefined(this._runToNextAvailableSymbolIndex[r])&&(this._runToNextAvailableSymbolIndex[r]=0);let u=RS[this._runToNextAvailableSymbolIndex[r]],h=new OS(r,a,l,s,u);i[l]=h;let f=RS.length;this._runToNextAvailableSymbolIndex[r]=(this._runToNextAvailableSymbolIndex[r]+1)%f}}),this.set("_nameToDataSeries",i)}}}_updateChart(){var t=this._nameToDataSeries;Object.entries(t).forEach(([r,n])=>{this.$.loader.setSeriesData(r,n.getData())}),this.$.loader.commitChanges()}_computeSelectedRunsSet(t){let r={};return o0.forEach(t,n=>{r[n]=1}),r}get _seriesNames(){let t=new Set(this.runs);return Object.entries(this._nameToDataSeries).filter(([r,n])=>t.has(n.run)).map(([r])=>r)}_determineColor(t,r){return t.scale(r)}_refreshDataSeries(){var t=this._tagFilter;this.set("_nameToDataSeries",{})}_createSymbolFunction(){return t=>this._nameToDataSeries[t].getSymbol().method()}_determineSymbol(t,r){return t[r].getSymbol().character}get _tagFilter(){var t=this.tagRegexes;return t.length===1?t[0]:t.map(r=>"("+r+")").join("|")}_getToggleMatchesIcon(t){return t?"expand-less":"expand-more"}_toggleMatchesOpen(){this.set("_matchesListOpened",!this._matchesListOpened)}get _titleDisplayString(){var t=this.title;return t||"untitled"}_matchListEntryColorUpdated(t){var n;let r=this.$$("#match-list-repeat");!r||(n=this.root)==null||n.querySelectorAll(".match-list-entry").forEach(i=>{let o=r.itemForElement(i);i.style.color=this._determineColor(this._colorScale,o)})}};En.template=Q`
    <tf-card-heading display-name="[[_titleDisplayString]]"></tf-card-heading>
    <div id="tf-line-chart-data-loader-container">
      <tf-line-chart-data-loader
        id="loader"
        active="[[active]]"
        color-scale="[[_colorScale]]"
        data-series="[[_seriesNames]]"
        ignore-y-outliers="[[ignoreYOutliers]]"
        load-key="[[_tagFilter]]"
        data-to-load="[[runs]]"
        request-data="[[_requestData]]"
        log-scale-active="[[_logScaleActive]]"
        load-data-callback="[[_createProcessDataFunction()]]"
        request-manager="[[requestManager]]"
        smoothing-enabled="[[smoothingEnabled]]"
        smoothing-weight="[[smoothingWeight]]"
        symbol-function="[[_createSymbolFunction()]]"
        tooltip-sorting-method="[[tooltipSortingMethod]]"
        x-type="[[xType]]"
      >
      </tf-line-chart-data-loader>
    </div>
    <div id="buttons">
      <paper-icon-button
        selected$="[[_expanded]]"
        icon="fullscreen"
        on-tap="_toggleExpanded"
      ></paper-icon-button>
      <paper-icon-button
        selected$="[[_logScaleActive]]"
        icon="line-weight"
        on-tap="_toggleLogScale"
        title="Toggle y-axis log scale"
      ></paper-icon-button>
      <paper-icon-button
        icon="settings-overscan"
        on-tap="_resetDomain"
        title="Fit domain to data"
      ></paper-icon-button>
      <span style="flex-grow: 1"></span>
      <template is="dom-if" if="[[showDownloadLinks]]">
        <div class="download-links">
          <paper-dropdown-menu
            no-label-float="true"
            label="series to download"
            selected-item-label="{{_dataSeriesNameToDownload}}"
          >
            <paper-listbox class="dropdown-content" slot="dropdown-content">
              <template
                is="dom-repeat"
                items="[[_seriesNames]]"
                as="dataSeriesName"
              >
                <paper-item no-label-float="true"
                  >[[dataSeriesName]]</paper-item
                >
              </template>
            </paper-listbox>
          </paper-dropdown-menu>
          <a
            download="[[_dataSeriesNameToDownload]].csv"
            href="[[_csvUrl(_nameToDataSeries, _dataSeriesNameToDownload)]]"
            >CSV</a
          >
          <a
            download="[[_dataSeriesNameToDownload]].json"
            href="[[_jsonUrl(_nameToDataSeries, _dataSeriesNameToDownload)]]"
            >JSON</a
          >
        </div>
      </template>
    </div>
    <div id="matches-container">
      <div id="matches-list-title">
        <template is="dom-if" if="[[_seriesNames.length]]">
          <paper-icon-button
            icon="[[_getToggleMatchesIcon(_matchesListOpened)]]"
            on-click="_toggleMatchesOpen"
            class="toggle-matches-button"
          >
          </paper-icon-button>
        </template>

        <span class="matches-text"> Matches ([[_seriesNames.length]]) </span>
      </div>
      <template is="dom-if" if="[[_seriesNames.length]]">
        <iron-collapse opened="[[_matchesListOpened]]">
          <div id="matches-list">
            <template
              is="dom-repeat"
              items="[[_seriesNames]]"
              as="seriesName"
              id="match-list-repeat"
              on-dom-change="_matchListEntryColorUpdated"
            >
              <div class="match-list-entry">
                <span class="match-entry-symbol">
                  [[_determineSymbol(_nameToDataSeries, seriesName)]]
                </span>
                [[seriesName]]
              </div>
            </template>
          </div>
        </iron-collapse>
      </template>
    </div>

    <style include="tf-custom-scalar-card-style"></style>
    <style>
      #matches-list-title {
        margin: 10px 0 5px 0;
      }

      #matches-list {
        max-height: 200px;
        overflow-y: auto;
      }

      .match-list-entry {
        margin: 0 0 5px 0;
      }

      .match-entry-symbol {
        font-family: arial, sans-serif;
        display: inline-block;
        width: 10px;
      }

      .matches-text {
        vertical-align: middle;
      }
    </style>
  `;E([A({type:Array}),w("design:type",Array)],En.prototype,"runs",void 0);E([A({type:String}),w("design:type",String)],En.prototype,"xType",void 0);E([A({type:Boolean}),w("design:type",Boolean)],En.prototype,"active",void 0);E([A({type:String}),w("design:type",String)],En.prototype,"title",void 0);E([A({type:Array}),w("design:type",Array)],En.prototype,"tagRegexes",void 0);E([A({type:Boolean}),w("design:type",Boolean)],En.prototype,"ignoreYOutliers",void 0);E([A({type:Object}),w("design:type",Ae)],En.prototype,"requestManager",void 0);E([A({type:Boolean}),w("design:type",Boolean)],En.prototype,"showDownloadLinks",void 0);E([A({type:Boolean}),w("design:type",Boolean)],En.prototype,"smoothingEnabled",void 0);E([A({type:Number}),w("design:type",Number)],En.prototype,"smoothingWeight",void 0);E([A({type:Object}),w("design:type",Object)],En.prototype,"tagMetadata",void 0);E([A({type:String}),w("design:type",String)],En.prototype,"tooltipSortingMethod",void 0);E([A({type:Object}),w("design:type",Wv)],En.prototype,"_colorScale",void 0);E([A({type:Object}),w("design:type",Object)],En.prototype,"_nameToDataSeries",void 0);E([A({type:Boolean,reflectToAttribute:!0}),w("design:type",Boolean)],En.prototype,"_expanded",void 0);E([A({type:Boolean}),w("design:type",Boolean)],En.prototype,"_logScaleActive",void 0);E([A({type:Object}),w("design:type",Function)],En.prototype,"_requestData",void 0);E([A({type:Object}),w("design:type",Object)],En.prototype,"_runToNextAvailableSymbolIndex",void 0);E([A({type:Boolean}),w("design:type",Boolean)],En.prototype,"_matchesListOpened",void 0);E([Bt("_nameToDataSeries"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],En.prototype,"_updateChart",null);E([Rt("_nameToDataSeries","runs"),w("design:type",Object),w("design:paramtypes",[])],En.prototype,"_seriesNames",null);E([Bt("_tagFilter"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],En.prototype,"_refreshDataSeries",null);E([Rt("tagRegexes"),w("design:type",String),w("design:paramtypes",[])],En.prototype,"_tagFilter",null);E([Rt("title"),w("design:type",String),w("design:paramtypes",[])],En.prototype,"_titleDisplayString",null);En=E([yt("tf-custom-scalar-multi-line-chart-card")],En);var jo=class extends mt{constructor(){super(...arguments),this._requestManager=new Ae(50),this._canceller=new an,this._showDownloadLinks=vp("_showDownloadLinks",{defaultValue:!1,useLocalStorage:!0}).call(this),this._smoothingWeight=_E("_smoothingWeight",{defaultValue:.6}).call(this),this._ignoreYOutliers=vp("_ignoreYOutliers",{defaultValue:!0,useLocalStorage:!0}).call(this),this._xType="step",this._active=!0,this.reloadOnReady=!0,this._showDownloadLinksObserver=xp("_showDownloadLinks",{defaultValue:!1,useLocalStorage:!0}),this._smoothingWeightObserver=yE("_smoothingWeight",{defaultValue:.6}),this._ignoreYOutliersObserver=xp("_ignoreYOutliers",{defaultValue:!0,useLocalStorage:!0})}ready(){super.ready(),this.reloadOnReady&&this.reload()}reload(){let t=_e().pluginsListing(),r=this._canceller.cancellable(n=>{n.cancelled||(this.set("_dataNotFound",!n.value.custom_scalars),!this._dataNotFound&&this._retrieveLayoutAndData())});this._requestManager.request(t).then(r)}_reloadCharts(){var r;let t=(r=this.root)==null?void 0:r.querySelectorAll("tf-custom-scalar-margin-chart-card, tf-custom-scalar-multi-line-chart-card");t==null||t.forEach(n=>{n.reload()})}_retrieveLayoutAndData(){let t=_e().pluginRoute("custom_scalars","/layout"),r=this._canceller.cancellable(n=>{n.cancelled||(this.set("_layout",n.value),this._dataNotFound||this._reloadCharts())});this._requestManager.request(t).then(r)}get _smoothingEnabled(){var t=this._smoothingWeight;return t>0}get _categories(){var t=this._layout;if(!t.category)return[];let r=!1;return this._openedCategories||(r=!0,this._openedCategories={}),t.category.map(i=>(r&&!i.closed&&(this._openedCategories[i.title]=!0),{name:i.title,items:i.chart,metadata:{type:Na.PREFIX_GROUP,opened:!!this._openedCategories[i.title]}}))}_categoryOpenedToggled(t){let r=t.target;r.opened?this._openedCategories[r.category.name]=!0:delete this._openedCategories[r.category.name]}};jo.template=Q`
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <div class="settings">
          <div class="sidebar-section">
            <div class="line-item">
              <paper-checkbox checked="{{_showDownloadLinks}}"
                >Show data download links</paper-checkbox
              >
            </div>
            <div class="line-item">
              <paper-checkbox checked="{{_ignoreYOutliers}}"
                >Ignore outliers in chart scaling</paper-checkbox
              >
            </div>
            <div id="tooltip-sorting">
              <div id="tooltip-sorting-label">Tooltip sorting method:</div>
              <paper-dropdown-menu
                no-label-float=""
                selected-item-label="{{_tooltipSortingMethod}}"
              >
                <paper-listbox
                  class="dropdown-content"
                  selected="0"
                  slot="dropdown-content"
                >
                  <paper-item>default</paper-item>
                  <paper-item>descending</paper-item>
                  <paper-item>ascending</paper-item>
                  <paper-item>nearest</paper-item>
                </paper-listbox>
              </paper-dropdown-menu>
            </div>
          </div>
          <div class="sidebar-section">
            <tf-smoothing-input
              weight="{{_smoothingWeight}}"
              step="0.001"
              min="0"
              max="1"
            ></tf-smoothing-input>
          </div>
          <div class="sidebar-section">
            <tf-option-selector
              id="x-type-selector"
              name="Horizontal Axis"
              selected-id="{{_xType}}"
            >
              <paper-button id="step">step</paper-button
              ><!--
            --><paper-button id="relative">relative</paper-button
              ><!--
            --><paper-button id="wall_time">wall</paper-button>
            </tf-option-selector>
          </div>
        </div>
        <div class="sidebar-section runs-selector">
          <tf-runs-selector selected-runs="{{_selectedRuns}}">
          </tf-runs-selector>
        </div>
      </div>
      <div class="center" slot="center" id="categories-container">
        <template is="dom-if" if="[[_dataNotFound]]">
          <div class="no-data-warning">
            <h3>The custom scalars dashboard is inactive.</h3>
            <p>Probable causes:</p>
            <ol>
              <li>You haven't laid out the dashboard.</li>
              <li>You haven’t written any scalar data to your event files.</li>
            </ol>

            <p>
              To lay out the dashboard, pass a <code>Layout</code> protobuffer
              to the <code>set_layout</code> method. For example,
            </p>
            <pre>
from tensorboard import summary
from tensorboard.plugins.custom_scalar import layout_pb2
...
# This action does not have to be performed at every step, so the action is not
# taken care of by an op in the graph. We only need to specify the layout once
# (instead of per step).
layout_summary = summary_lib.custom_scalar_pb(layout_pb2.Layout(
  category=[
    layout_pb2.Category(
      title='losses',
      chart=[
          layout_pb2.Chart(
              title='losses',
              multiline=layout_pb2.MultilineChartContent(
                tag=[r'loss.*'],
              )),
          layout_pb2.Chart(
              title='baz',
              margin=layout_pb2.MarginChartContent(
                series=[
                  layout_pb2.MarginChartContent.Series(
                    value='loss/baz/scalar_summary',
                    lower='baz_lower/baz/scalar_summary',
                    upper='baz_upper/baz/scalar_summary'),
                ],
              )),
      ]),
    layout_pb2.Category(
      title='trig functions',
      chart=[
          layout_pb2.Chart(
              title='wave trig functions',
              multiline=layout_pb2.MultilineChartContent(
                tag=[r'trigFunctions/cosine', r'trigFunctions/sine'],
              )),
          # The range of tangent is different. Let's give it its own chart.
          layout_pb2.Chart(
              title='tan',
              multiline=layout_pb2.MultilineChartContent(
                tag=[r'trigFunctions/tangent'],
              )),
      ],
      # This category we care less about. Let's make it initially closed.
      closed=True),
  ]))
writer.add_summary(layout_summary)
</pre
            >
            <p>
              If you’re new to using TensorBoard, and want to find out how to
              add data and set up your event files, check out the
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
                >README</a
              >
              and perhaps the
              <a
                href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
                >TensorBoard tutorial</a
              >.
            </p>
          </div>
        </template>
        <template is="dom-if" if="[[!_dataNotFound]]">
          <template is="dom-repeat" items="[[_categories]]" as="category">
            <tf-category-paginated-view
              as="chart"
              category="[[category]]"
              disable-pagination
              initial-opened="[[category.metadata.opened]]"
            >
              <template>
                <template is="dom-if" if="[[chart.multiline]]">
                  <tf-custom-scalar-multi-line-chart-card
                    active="[[active]]"
                    request-manager="[[_requestManager]]"
                    runs="[[_selectedRuns]]"
                    title="[[chart.title]]"
                    x-type="[[_xType]]"
                    smoothing-enabled="[[_smoothingEnabled]]"
                    smoothing-weight="[[_smoothingWeight]]"
                    tooltip-sorting-method="[[tooltipSortingMethod]]"
                    ignore-y-outliers="[[_ignoreYOutliers]]"
                    show-download-links="[[_showDownloadLinks]]"
                    tag-regexes="[[chart.multiline.tag]]"
                  ></tf-custom-scalar-multi-line-chart-card>
                </template>
                <template is="dom-if" if="[[chart.margin]]">
                  <tf-custom-scalar-margin-chart-card
                    active="[[active]]"
                    request-manager="[[_requestManager]]"
                    runs="[[_selectedRuns]]"
                    title="[[chart.title]]"
                    x-type="[[_xType]]"
                    tooltip-sorting-method="[[tooltipSortingMethod]]"
                    ignore-y-outliers="[[_ignoreYOutliers]]"
                    show-download-links="[[_showDownloadLinks]]"
                    margin-chart-series="[[chart.margin.series]]"
                  ></tf-custom-scalar-margin-chart-card>
                </template>
              </template>
            </tf-category-paginated-view>
          </template>
        </template>
      </div>
    </tf-dashboard-layout>

    <style include="dashboard-style"></style>
    <style>
      #tooltip-sorting {
        align-items: center;
        display: flex;
        font-size: 14px;
        margin-top: 15px;
      }
      #tooltip-sorting paper-dropdown-menu {
        margin-left: 10px;
        --paper-input-container-focus-color: var(--tb-orange-strong);
        width: 105px;
      }
      .line-item {
        display: block;
        padding-top: 5px;
      }
      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }
    </style>
  `;E([A({type:Object}),w("design:type",Ae)],jo.prototype,"_requestManager",void 0);E([A({type:Object}),w("design:type",an)],jo.prototype,"_canceller",void 0);E([A({type:Array}),w("design:type",Array)],jo.prototype,"_selectedRuns",void 0);E([A({type:Boolean,notify:!0,observer:"_showDownloadLinksObserver"}),w("design:type",Boolean)],jo.prototype,"_showDownloadLinks",void 0);E([A({type:Number,notify:!0,observer:"_smoothingWeightObserver"}),w("design:type",Number)],jo.prototype,"_smoothingWeight",void 0);E([A({type:Boolean,observer:"_ignoreYOutliersObserver"}),w("design:type",Boolean)],jo.prototype,"_ignoreYOutliers",void 0);E([A({type:String}),w("design:type",String)],jo.prototype,"_xType",void 0);E([A({type:Object}),w("design:type",Object)],jo.prototype,"_layout",void 0);E([A({type:Boolean}),w("design:type",Boolean)],jo.prototype,"_dataNotFound",void 0);E([A({type:Object}),w("design:type",Object)],jo.prototype,"_openedCategories",void 0);E([A({type:Boolean}),w("design:type",Boolean)],jo.prototype,"_active",void 0);E([A({type:Boolean}),w("design:type",Boolean)],jo.prototype,"reloadOnReady",void 0);E([Rt("_smoothingWeight"),w("design:type",Boolean),w("design:paramtypes",[])],jo.prototype,"_smoothingEnabled",null);E([Rt("_layout"),w("design:type",Array),w("design:paramtypes",[])],jo.prototype,"_categories",null);jo=E([yt("tf-custom-scalar-dashboard")],jo);var DB=Ee(Oe(),1);var ast=Ee(Oe(),1),ba=Ee(wl(),1);var NB=class{constructor(t,r){this.run2datasets={},this.colorScale=r,this.buildChart(t)}getDataset(t){return this.run2datasets[t]===void 0&&(this.run2datasets[t]=new ba.Dataset([],{run:t})),this.run2datasets[t]}buildChart(t){this.outer&&this.outer.destroy();let r=xB(t);this.xAccessor=r.accessor,this.xScale=r.scale,this.xAxis=r.axis,this.xAxis.margin(0),this.xAxis.tickLabelPadding(3),this.yScale=new ba.Scales.Linear,this.yAxis=new ba.Axes.Numeric(this.yScale,"left");let n=Wu(mB);this.yAxis.margin(0).tickLabelPadding(5).formatter(n),this.yAxis.usesTextWidthApproximation(!0);let i=this.buildPlot(this.xAccessor,this.xScale,this.yScale);this.gridlines=new ba.Components.Gridlines(this.xScale,this.yScale),this.center=new ba.Components.Group([this.gridlines,i]),this.outer=new ba.Components.Table([[this.yAxis,this.center],[null,this.xAxis]])}buildPlot(t,r,n){let i=[0,228,1587,3085,5e3,6915,8413,9772,1e4],o=ast.range(i.length-1).map(h=>(i[h+1]-i[h])/2500),a=i.map((h,f)=>p=>p[f][1]),s=4,l=a[s],c=ast.range(a.length-1).map(h=>{let f=new ba.Plots.Area;f.x(t,r);let p=h>s?a[h]:a[h+1],d=h>s?a[h+1]:a[h];return f.y(d,n),f.y0(p),f.attr("fill",(g,_,y)=>this.colorScale.scale(y.metadata().run)),f.attr("stroke",(g,_,y)=>this.colorScale.scale(y.metadata().run)),f.attr("stroke-weight",(g,_,y)=>"0.5px"),f.attr("stroke-opacity",()=>o[h]),f.attr("fill-opacity",()=>o[h]),f}),u=new ba.Plots.Line;return u.x(t,r),u.y(l,n),u.attr("stroke",(h,f,p)=>this.colorScale.scale(p.run)),this.plots=c,new ba.Components.Group(c)}setVisibleSeries(t){this.runs=t;let r=t.map(n=>this.getDataset(n));this.plots.forEach(n=>n.datasets(r))}setSeriesData(t,r){this.getDataset(t).data(r)}renderTo(t){this.targetSVG=t,this.outer.renderTo(t)}redraw(){this.outer.redraw()}destroy(){this.outer.destroy()}},Bc=class extends Gt(mt){constructor(){super(...arguments),this.colorScale=new ba.Scales.Color().range(jb.slice()),this.xType="step",this._visibleSeriesCache=[],this._seriesDataCache={},this._makeChartAsyncCallbackId=null}setVisibleSeries(t){this._visibleSeriesCache=t,this._chart&&(this._chart.setVisibleSeries(t),this.redraw())}setSeriesData(t,r){this._seriesDataCache[t]=r,this._chart&&this._chart.setSeriesData(t,r)}redraw(){this._chart.redraw()}_makeChart(){var t=this.xType,r=this.colorScale,n=this._attached;this._makeChartAsyncCallbackId!==null&&this.cancelAsync(this._makeChartAsyncCallbackId),this._makeChartAsyncCallbackId=this.async(function(){if(this._makeChartAsyncCallbackId=null,!!n){this._chart&&this._chart.destroy();var i=new NB(t,r),o=Ht(this.$.chartdiv);i.renderTo(o),this._chart=i}},350)}_reloadFromCache(){this._chart&&(this._chart.setVisibleSeries(this._visibleSeriesCache),this._visibleSeriesCache.forEach(function(t){this._chart.setSeriesData(t,this._seriesDataCache[t]||[])}.bind(this)))}attached(){this._attached=!0}detached(){this._attached=!1}};Bc.template=Q`
    <style include="plottable-style"></style>
    <div id="chartdiv"></div>
    <style>
      :host {
        -webkit-user-select: none;
        -moz-user-select: none;
        display: flex;
        flex-direction: column;
        flex-grow: 1;
        flex-shrink: 1;
        position: relative;
      }
      #chartdiv {
        -webkit-user-select: none;
        -moz-user-select: none;
        flex-grow: 1;
        flex-shrink: 1;
      }
      .plottable .axis text {
        fill: currentColor;
      }
    </style>
  `;E([A({type:Object}),w("design:type",ba.Scales.Color)],Bc.prototype,"colorScale",void 0);E([A({type:String}),w("design:type",String)],Bc.prototype,"xType",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Bc.prototype,"_attached",void 0);E([A({type:Object}),w("design:type",NB)],Bc.prototype,"_chart",void 0);E([A({type:Array}),w("design:type",Array)],Bc.prototype,"_visibleSeriesCache",void 0);E([A({type:Object}),w("design:type",Object)],Bc.prototype,"_seriesDataCache",void 0);E([A({type:Number}),w("design:type",Object)],Bc.prototype,"_makeChartAsyncCallbackId",void 0);E([Bt("xType","colorScale","_attached"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Bc.prototype,"_makeChart",null);E([Bt("_chart"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Bc.prototype,"_reloadFromCache",null);Bc=E([yt("vz-distribution-chart")],Bc);var wa=class extends kS(Gt(mt)){constructor(){super(...arguments),this.getDataLoadName=({run:t})=>t,this.requestData=(t,r,n)=>{let o=_e().pluginRoute("distributions","/distributions");Promise.all(t.map(a=>{let s=Mi(o,{tag:a.tag,run:a.run});return this.requestManager.request(s).then(l=>void r({item:a,data:l}))})).finally(()=>void n())},this.loadDataCallback=(t,r,n)=>{let i=n.map(a=>{let[s,l,c]=a;return c.wall_time=new Date(s*1e3),c.step=l,c}),o=this.getDataLoadName(r);this.$.chart.setSeriesData(o,i),this.$.chart.setVisibleSeries([o])},this._colorScale={scale:fn},this._expanded=!1,this._canceller=new an}_reloadOnRunTagChange(){this.reload()}_updateDataToLoad(){var t=this.run,r=this.tag;this.dataToLoad=[{run:t,tag:r}]}get _runColor(){var t=this.run;return this._colorScale.scale(t)}redraw(){this.$.chart.redraw()}_toggleExpanded(t){this.set("_expanded",!this._expanded),this.redraw()}};wa.template=Q`
    <tf-card-heading
      tag="[[tag]]"
      run="[[run]]"
      display-name="[[tagMetadata.displayName]]"
      description="[[tagMetadata.description]]"
      color="[[_runColor]]"
    ></tf-card-heading>
    <!--
      The main distribution that we render. Data is set directly with
      \`setSeriesData\`, not with a bound property.
    -->
    <vz-distribution-chart
      id="chart"
      x-type="[[xType]]"
      color-scale="[[_colorScale]]"
    ></vz-distribution-chart>
    <div style="display: flex; flex-direction: row;">
      <paper-icon-button
        selected$="[[_expanded]]"
        icon="fullscreen"
        on-tap="_toggleExpanded"
      ></paper-icon-button>
    </div>
    <style>
      :host {
        display: flex;
        flex-direction: column;
        width: 330px;
        height: 235px;
        margin-right: 10px;
        margin-bottom: 15px;
      }
      :host([_expanded]) {
        width: 700px;
        height: 500px;
      }

      vz-histogram-timeseries {
        -moz-user-select: none;
        -webkit-user-select: none;
      }

      paper-icon-button {
        color: #2196f3;
        border-radius: 100%;
        width: 32px;
        height: 32px;
        padding: 4px;
      }
      paper-icon-button[selected] {
        background: var(--tb-ui-light-accent);
      }

      tf-card-heading {
        margin-bottom: 10px;
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],wa.prototype,"run",void 0);E([A({type:String}),w("design:type",String)],wa.prototype,"tag",void 0);E([A({type:Object}),w("design:type",Object)],wa.prototype,"tagMetadata",void 0);E([A({type:String}),w("design:type",String)],wa.prototype,"xType",void 0);E([A({type:Object}),w("design:type",Object)],wa.prototype,"getDataLoadName",void 0);E([A({type:Object}),w("design:type",Object)],wa.prototype,"loadDataCallback",void 0);E([A({type:Object}),w("design:type",Object)],wa.prototype,"_colorScale",void 0);E([A({type:Boolean,reflectToAttribute:!0}),w("design:type",Boolean)],wa.prototype,"_expanded",void 0);E([A({type:Object}),w("design:type",Ae)],wa.prototype,"requestManager",void 0);E([A({type:Object}),w("design:type",an)],wa.prototype,"_canceller",void 0);E([Bt("run","tag"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],wa.prototype,"_reloadOnRunTagChange",null);E([Bt("run","tag"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],wa.prototype,"_updateDataToLoad",null);E([Rt("run"),w("design:type",String),w("design:paramtypes",[])],wa.prototype,"_runColor",null);wa=E([yt("tf-distribution-loader")],wa);var Sl=class extends Gt(mt){constructor(){super(...arguments),this.reloadOnReady=!0,this._xType="step",this._requestManager=new Ae}ready(){super.ready(),this.reloadOnReady&&this.reload()}reload(){this._fetchTags().then(()=>{this._reloadDistributions()})}_fetchTags(){let t=_e().pluginRoute("distributions","/tags");return this._requestManager.request(t).then(r=>{if(DB.isEqual(r,this._runToTagInfo))return;let n=DB.mapValues(r,o=>Object.keys(o)),i=$i(n);this.set("_dataNotFound",i.length===0),this.set("_runToTag",n),this.set("_runToTagInfo",r),this.async(()=>{this.set("_categoriesDomReady",!0)})})}_reloadDistributions(){var t;(t=this.root)==null||t.querySelectorAll("tf-distribution-loader").forEach(r=>{r.reload()})}_shouldOpen(t){return t<=2}get _categories(){var t=this._runToTag,r=this._selectedRuns,n=this._tagFilter,i=this._categoriesDomReady;return Ql(t,r,n)}_tagMetadata(t,r,n){return t[r][n]}};Sl.template=Q`
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <div class="settings">
          <div class="sidebar-section">
            <tf-option-selector
              id="xTypeSelector"
              name="Horizontal axis"
              selected-id="{{_xType}}"
            >
              <paper-button id="step">step</paper-button>
              <paper-button id="relative">relative</paper-button>
              <paper-button id="wall_time">wall</paper-button>
            </tf-option-selector>
          </div>
        </div>
        <div class="sidebar-section runs-selector">
          <tf-runs-selector selected-runs="{{_selectedRuns}}">
          </tf-runs-selector>
        </div>
      </div>

      <div class="center" slot="center">
        <template is="dom-if" if="[[_dataNotFound]]">
          <div class="no-data-warning">
            <h3>No distribution data was found.</h3>
            <p>Probable causes:</p>
            <ul>
              <li>
                You haven’t written any histogram data to your event files.
                (Histograms and distributions both use the histogram summary
                operation.)
              </li>

              <li>TensorBoard can’t find your event files.</li>
            </ul>

            <p>
              If you’re new to using TensorBoard, and want to find out how to
              add data and set up your event files, check out the
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
                >README</a
              >
              and perhaps the
              <a
                href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
                >TensorBoard tutorial</a
              >.
            </p>

            <p>
              If you think TensorBoard is configured properly, please see
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"
                >the section of the README devoted to missing data problems</a
              >
              and consider filing an issue on GitHub.
            </p>
          </div>
        </template>
        <template is="dom-if" if="[[!_dataNotFound]]">
          <tf-tag-filterer tag-filter="{{_tagFilter}}"></tf-tag-filterer>
          <template is="dom-repeat" items="[[_categories]]" as="category">
            <tf-category-paginated-view
              category="[[category]]"
              initial-opened="[[_shouldOpen(index)]]"
            >
              <template>
                <tf-distribution-loader
                  active="[[active]]"
                  run="[[item.run]]"
                  tag="[[item.tag]]"
                  tag-metadata="[[_tagMetadata(_runToTagInfo, item.run, item.tag)]]"
                  x-type="[[_xType]]"
                  request-manager="[[_requestManager]]"
                ></tf-distribution-loader>
              </template>
            </tf-category-paginated-view>
          </template>
        </template>
      </div>
    </tf-dashboard-layout>

    <style include="dashboard-style"></style>
    <style>
      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }
    </style>
  `;E([A({type:Boolean}),w("design:type",Boolean)],Sl.prototype,"reloadOnReady",void 0);E([A({type:String}),w("design:type",String)],Sl.prototype,"_xType",void 0);E([A({type:Array}),w("design:type",Array)],Sl.prototype,"_selectedRuns",void 0);E([A({type:Object}),w("design:type",Object)],Sl.prototype,"_runToTag",void 0);E([A({type:Object}),w("design:type",Object)],Sl.prototype,"_runToTagInfo",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Sl.prototype,"_dataNotFound",void 0);E([A({type:String}),w("design:type",String)],Sl.prototype,"_tagFilter",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Sl.prototype,"_categoriesDomReady",void 0);E([A({type:Object}),w("design:type",Ae)],Sl.prototype,"_requestManager",void 0);E([Rt("_runToTag","_selectedRuns","_tagFilter","_categoriesDomReady"),w("design:type",Array),w("design:paramtypes",[])],Sl.prototype,"_categories",null);Sl=E([yt("tf-distribution-dashboard")],Sl);var OB={};Ks(OB,{DISAMBIGUATOR:()=>q0t,ListenKey:()=>mE,addHashListener:()=>gE,addStorageListener:()=>TW,disposeBooleanBinding:()=>t2e,disposeNumberBinding:()=>e2e,disposeObjectBinding:()=>i2e,disposeStringBinding:()=>Zbe,fireStorageChanged:()=>CW,getBoolean:()=>Jbe,getBooleanInitializer:()=>vp,getBooleanObserver:()=>xp,getNumber:()=>NW,getNumberInitializer:()=>_E,getNumberObserver:()=>yE,getObject:()=>r2e,getObjectInitializer:()=>OW,getObjectObserver:()=>zW,getString:()=>$be,getStringInitializer:()=>y_,getStringObserver:()=>v_,getUrlHashDict:()=>B0t,makeBindings:()=>vE,migrateLegacyURLScheme:()=>o2e,removeHashListenerByKey:()=>AW,removeStorageListenerByKey:()=>PW,setBoolean:()=>Qbe,setNumber:()=>DW,setObject:()=>n2e,setString:()=>Kbe});var ict=Ee(Oe(),1);var KKt="Graph dashboard actions",ZKt="Graph dashboard timings",sst;(function(e){e.FETCH_PBTXT_BYTES="FETCH_PBTXT_BYTES",e.FETCH_PBTXT_BYTES_FROM_FILESYSTEM="FETCH_PBTXT_BYTES_FROM_FILESYSTEM",e.FETCH_PBTXT_BYTES_FROM_SERVER="FETCH_PBTXT_BYTES_FROM_SERVER",e.PARSE_PBTXT_INTO_OBJECT="PARSE_PBTXT_INTO_OBJECT",e.FETCH_METADATA_PBTXT_BYTES="FETCH_METADATA_PBTXT_BYTES",e.PARSE_METADATA_PBTXT_INTO_OBJECT="PARSE_METADATA_PBTXT_INTO_OBJECT",e.NORMALIZING_NAMES="NORMALIZING_NAMES",e.BUILD_SLIM_GRAPH="BUILD_SLIM_GRAPH",e.HIERARCHY_ADD_NODES="HIERARCHY_ADD_NODES",e.HIERARCHY_DETECT_SERIES="HIERARCHY_DETECT_SERIES",e.HIERARCHY_ADD_EDGES="HIERARCHY_ADD_EDGES",e.HIERARCHY_FIND_SIMILAR_SUBGRAPHS="HIERARCHY_FIND_SIMILAR_SUBGRAPHS",e.RENDER_BUILD_HIERARCHY="RENDER_BUILD_HIERARCHY",e.RENDER_SCENE_LAYOUT="RENDER_SCENE_LAYOUT",e.RENDER_SCENE_BUILD_SCENE="RENDER_SCENE_BUILD_SCENE",e.GRAPH_LOAD_SUCCEEDED="GRAPH_LOAD_SUCCEEDED",e.GRAPH_LOAD_FAILED="GRAPH_LOAD_FAILED"})(sst||(sst={}));var lst;(function(e){e.NODE_EXPANSION_TOGGLED="NODE_EXPANSION_TOGGLED",e.NODE_SEARCH_RESULT_FOCUSED="NODE_SEARCH_RESULT_FOCUSED",e.NODE_AUXILIARY_EXTRACTION_CHANGED="NODE_AUXILIARY_EXTRACTION_CHANGED",e.GRAPH_TYPE_CHANGED="GRAPH_TYPE_CHANGED",e.TRACE_INPUT_MODE_TOGGLED="TRACE_INPUT_MODE_TOGGLED",e.NODE_COLOR_MODE_CHANGED="NODE_COLOR_MODE_CHANGED",e.UPLOADED_GRAPH_FROM_FILESYSTEM="UPLOADED_GRAPH_FROM_FILESYSTEM"})(lst||(lst={}));var jr=Kl(Kl({},sst),lst);var nle=Ee(Olt(),1),pn=Ee(Oe(),1);var Fs;(function(e){e.OP_GRAPH="op_graph",e.CONCEPTUAL_GRAPH="conceptual_graph",e.PROFILE="profile"})(Fs||(Fs={}));var ve={Node:{CONTAINER:"nodes",GROUP:"node",SHAPE:"nodeshape",COLOR_TARGET:"nodecolortarget",LABEL:"nodelabel",BUTTON_CONTAINER:"buttoncontainer",BUTTON_CIRCLE:"buttoncircle",EXPAND_BUTTON:"expandbutton",COLLAPSE_BUTTON:"collapsebutton"},Edge:{CONTAINER:"edges",GROUP:"edge",LINE:"edgeline",REFERENCE_EDGE:"referenceedge",REF_LINE:"refline",SELECTABLE:"selectableedge",SELECTED:"selectededge",STRUCTURAL:"structural"},Annotation:{OUTBOX:"out-annotations",INBOX:"in-annotations",GROUP:"annotation",NODE:"annotation-node",EDGE:"annotation-edge",CONTROL_EDGE:"annotation-control-edge",LABEL:"annotation-label",ELLIPSIS:"annotation-ellipsis"},Scene:{GROUP:"scene",CORE:"core",FUNCTION_LIBRARY:"function-library",INEXTRACT:"in-extract",OUTEXTRACT:"out-extract"},Subscene:{GROUP:"subscene"},OPNODE:"op",METANODE:"meta",SERIESNODE:"series",BRIDGENODE:"bridge",ELLIPSISNODE:"ellipsis"},J4={Edge:{LABEL:3.5},Annotation:{LABEL:5},Node:{EXPANDED_LABEL:9,SERIES_LABEL:8,OP_LABEL:6,HEALTH_PILL_STAT_LABEL:4}},ju="http://www.w3.org/2000/svg";function m0(e,t,r){let n=e.node().childNodes;for(let i=0;i<n.length;i++){let o=n[i];if(o.tagName===t){if(r instanceof Array){let a=!0;for(let s=0;s<r.length;s++)a=a&&o.classList.contains(r[s]);if(a)return Ht(o)}else if(!r||o.classList.contains(r))return Ht(o)}}return Ht(null)}function An(e,t,r,n){let i=m0(e,t,r);if(!i.empty())return i;let o=document.createElementNS("http://www.w3.org/2000/svg",t);if(r instanceof Array)for(let a=0;a<r.length;a++)o.classList.add(r[a]);else o.classList.add(r);return n?e.node().insertBefore(o,n):e.node().appendChild(o),Ht(o).datum(e.datum())}var KS=class{constructor(t){this.totalBytes=0,this.outputSize=t}addExecutionTime(t,r){this.startTime!=null?this.startTime=Math.min(this.startTime,t):this.startTime=t,this.endTime!=null?this.endTime=Math.max(this.endTime,r):this.endTime=r}addBytesAllocation(t){this.totalBytes!=null?this.totalBytes=Math.max(this.totalBytes,t):this.totalBytes=t}combine(t){t.totalBytes!=null&&(this.totalBytes+=t.totalBytes),t.getTotalMicros()!=null&&this.addExecutionTime(t.startTime,t.endTime)}getTotalMicros(){return this.startTime==null||this.endTime==null?null:this.endTime-this.startTime}},Q4=.75,tP=12,tcr=.3,ecr=[1,5e6],Xse=K_().exponent(tcr).domain(ecr).range([Q4,tP]).clamp(!0);var ZS=Ee(Oe(),1);var Kse=20;function rcr(e){return e.hasOwnProperty("timingId")}function Po(e){rcr(e)?(ZKt,e.timingId,e.eventValue,void 0):(KKt,e.actionId,e.eventLabel,void 0)}function Rd(e,t,r){let n=Date.now(),i=t(),o=Date.now()-n;return console.log(e,":",o,"ms"),r&&Po({timingId:r,eventValue:o}),i}function nP(e){return{setMessage:function(t){e.set("progress",{value:e.progress.value,msg:t})},updateProgress:function(t){e.set("progress",{value:e.progress.value+t,msg:e.progress.msg})},reportError:function(t,r){console.error(r.stack),e.set("progress",{value:e.progress.value,msg:t,error:!0})}}}function JS(e,t,r){return{setMessage:function(n){e.setMessage(r+": "+n)},updateProgress:function(n){e.updateProgress(n*t/100)},reportError:function(n,i){e.reportError(r+": "+n,i)}}}function Zse(e,t,r,n,i){n.setMessage(e);try{let o=Rd(e,r,i);return n.updateProgress(t),o}catch(o){return n.reportError("Failed "+e,o),null}}function e1(e,t,r,n,i){return new Promise((o,a)=>{n.setMessage(e),setTimeout(function(){try{let s=Rd(e,r,i);n.updateProgress(t),o(s)}catch(s){n.reportError("Failed "+e,s)}},Kse)})}function mH(e,t,r,n,i){return new Promise((o,a)=>{let s=function(l){n.reportError("Failed "+e,l),a(l)};n.setMessage(e),setTimeout(function(){try{let l=Date.now();r().then(function(c){let u=Date.now()-l;console.log(e,":",u,"ms"),n.updateProgress(t),Po({timingId:i,eventValue:u}),o(c)}).catch(s)}catch(l){s(l)}},Kse)})}function Jse(e){return e.replace(/([:.\[\],/\\\(\)])/g,"\\$1")}var iP=[{symbol:"B"},{symbol:"KB",numUnits:1024},{symbol:"MB",numUnits:1024},{symbol:"GB",numUnits:1024},{symbol:"TB",numUnits:1024},{symbol:"PB",numUnits:1024}],oP=[{symbol:"\xB5s"},{symbol:"ms",numUnits:1e3},{symbol:"s",numUnits:1e3},{symbol:"min",numUnits:60},{symbol:"hr",numUnits:60},{symbol:"days",numUnits:24}];function Nd(e,t,r=0){return r+1<t.length&&e>=t[r+1].numUnits?Nd(e/t[r+1].numUnits,t,r+1):Number(e.toPrecision(3))+" "+t[r].symbol}function gH(e){return!!(e&&(e.totalBytes>0||e.getTotalMicros()>0||e.outputSize))}function zlt(e){if(e.length<2)return e;let t=0,r=0,n=ZS.min(ZS.map(e,i=>i.length));for(;;){t++;let i=ZS.map(e,a=>a.substring(0,t));if(i.every((a,s)=>s===0?!0:a===i[s-1])){if(t>=n)return e;r=t}else break}return ZS.map(e,i=>i.substring(r))}function Qse(e){var t=+new Date-+new Date(e/1e3);return t<3e4?"just now":t<6e4?Math.floor(t/1e3)+" seconds ago":t<12e4?"a minute ago":t<36e5?Math.floor(t/6e4)+" minutes ago":Math.floor(t/36e5)==1?"an hour ago":t<864e5?Math.floor(t/36e5)+" hours ago":t<1728e5?"yesterday":Math.floor(t/864e5)+" days ago"}var ncr=document.createElement("canvas"),rP=ncr.getContext("2d");function $se(e,t){return rP&&(rP.font=`${t}px Roboto, sans-serif`),rP==null?void 0:rP.measureText(e).width}function tle(e,t,r){if(!e)return"";if($se(e,t)<=r)return e;let n=0,i=e.length;for(;n<i;){let o=n+Math.round((i-n)/2),a=e.slice(0,o)+"\u2026";$se(a,t)<=r?n=o:i=o-1}return n===0?e[0]:e.slice(0,n)+"\u2026"}var dH=class{constructor(){this.eventTypeToListeners=new Map}getListeners(t){return this.eventTypeToListeners.has(t)||this.eventTypeToListeners.set(t,[]),this.eventTypeToListeners.get(t)}addListener(t,r){var n;(n=this.getListeners(t))==null||n.push(r)}removeListener(t,r){var i;let n=(i=this.getListeners(t))==null?void 0:i.filter(o=>o!==r);this.eventTypeToListeners.set(t,n)}dispatchEvent(t,r){for(let n of this.getListeners(t))n(r)}};var Al="/",qc="__root__",Sa="__function_library__",ile="_too_large_attrs";var ole="--",g0;(function(e){e[e.FULL=0]="FULL",e[e.EMBEDDED=1]="EMBEDDED",e[e.META=2]="META",e[e.SERIES=3]="SERIES",e[e.CORE=4]="CORE",e[e.SHADOW=5]="SHADOW",e[e.BRIDGE=6]="BRIDGE",e[e.EDGE=7]="EDGE"})(g0||(g0={}));var jt;(function(e){e[e.META=0]="META",e[e.OP=1]="OP",e[e.SERIES=2]="SERIES",e[e.BRIDGE=3]="BRIDGE",e[e.ELLIPSIS=4]="ELLIPSIS"})(jt||(jt={}));var ur;(function(e){e[e.INCLUDE=0]="INCLUDE",e[e.EXCLUDE=1]="EXCLUDE",e[e.UNSPECIFIED=2]="UNSPECIFIED"})(ur||(ur={}));var is;(function(e){e[e.GROUP=0]="GROUP",e[e.UNGROUP=1]="UNGROUP"})(is||(is={}));var icr="_output_shapes",ocr="_XlaCluster",Xu=class{constructor(){this.nodes={},this.edges=[]}},_H=class{constructor(t){this.type=jt.ELLIPSIS,this.isGroupNode=!1,this.cardinality=1,this.parentNode=null,this.stats=null,this.setNumMoreNodes(t),this.include=ur.UNSPECIFIED}setNumMoreNodes(t){this.numMoreNodes=t,this.name="... "+t+" more"}},_0=class{constructor(t){this.op=t.op,this.name=t.name,this.device=t.device,this.attr=t.attr,this.inputs=ccr(t.input),this.outputShapes=acr(t.attr),this.xlaCluster=scr(t.attr),this.compatible=!1,this.type=jt.OP,this.isGroupNode=!1,this.cardinality=1,this.inEmbeddings=[],this.outEmbeddings=[],this.parentNode=null,this.include=ur.UNSPECIFIED,this.owningSeries=null}};function lP(e,t={}){return new aP(e,t)}function ale(e,t,r){pn.each(e.nodes,n=>{n.stats=null}),pn.each(t.dev_stats,n=>{r&&!r[n.device]||pn.each(n.node_stats,i=>{let o=i.node_name in e.nodes?i.node_name:sP(i.node_name);if(!(o in e.nodes))return;let a=0;i.memory&&pn.each(i.memory,l=>{l.total_bytes&&(l.total_bytes>0?a+=Number(l.total_bytes):console.log("ignoring negative memory allocation for "+o))});let s=null;i.output&&(s=pn.map(i.output,l=>pn.map(l.tensor_description.shape.dim,c=>Number(c.size)))),e.nodes[o].device=n.device,e.nodes[o].stats==null&&(e.nodes[o].stats=new KS(s)),e.nodes[o].stats.addBytesAllocation(a),i.all_end_rel_micros&&(i.all_end_rel_micros>0?e.nodes[o].stats.addExecutionTime(i.all_start_micros,i.all_start_micros+i.all_end_rel_micros):console.log("ignoring negative runtime for "+o))})})}var aP=class{constructor(t,r={}){this.name=t,this.type=jt.META,this.depth=1,this.isGroupNode=!0,this.cardinality=0,this.metagraph=e3(t,g0.META,r),this.bridgegraph=null,this.opHistogram={},this.deviceHistogram={},this.xlaClusterHistogram={},this.compatibilityHistogram={compatible:0,incompatible:0},this.templateId=null,this.parentNode=null,this.hasNonControlEdges=!1,this.include=ur.UNSPECIFIED,this.associatedFunction=""}getFirstChild(){return this.metagraph.node(this.metagraph.nodes()[0])}getRootOp(){let t=this.name.split("/"),r=this.name+"/("+t[t.length-1]+")";return this.metagraph.node(r)}leaves(){let t=[],r=[this],n;for(;r.length;){let i=r.shift();i!=null&&i.isGroupNode?(n=i.metagraph,pn.each(n.nodes(),o=>r.push(n.node(o)))):t.push(i==null?void 0:i.name)}return t}};function Hlt(e,t){return new qf(e,t)}var qf=class{constructor(t,r){this.v=t,this.w=r,this.baseEdgeList=[],this.inbound=null,this.numRegularEdges=0,this.numControlEdges=0,this.numRefEdges=0,this.totalSize=0}addBaseEdge(t,r){this.baseEdgeList.push(t),t.isControlDependency?this.numControlEdges+=1:this.numRegularEdges+=1,t.isReferenceEdge&&(this.numRefEdges+=1),this.totalSize+=qf.computeSizeOfEdge(t,r),r.maxMetaEdgeSize=Math.max(r.maxMetaEdgeSize,this.totalSize)}static computeSizeOfEdge(t,r){let n=r.node(t.v);if(!n.outputShapes)return 1;r.hasShapeInfo=!0;let i=Object.keys(n.outputShapes).map(o=>n.outputShapes[o]).map(o=>o==null?1:o.reduce((a,s)=>(s===-1&&(s=1),a*s),1));return pn.sum(i)}};function QS(e,t,r,n,i,o){return new Blt(e,t,r,n,i,o)}function t3(e,t,r,n,i){let o=typeof n!="undefined"&&typeof i!="undefined"?"["+n+"-"+i+"]":"#",a=e+o+t;return(r?r+"/":"")+a}var Blt=class{constructor(t,r,n,i,o,a){this.name=o||t3(t,r,n),this.type=jt.SERIES,this.hasLoop=!1,this.prefix=t,this.suffix=r,this.clusterId=i,this.ids=[],this.parent=n,this.isGroupNode=!0,this.cardinality=0,this.metagraph=e3(o,g0.SERIES,a),this.bridgegraph=null,this.parentNode=null,this.deviceHistogram={},this.xlaClusterHistogram={},this.compatibilityHistogram={compatible:0,incompatible:0},this.hasNonControlEdges=!1,this.include=ur.UNSPECIFIED}};function acr(e){let t=null;if(!e)return null;for(let r=0;r<e.length;r++){let{key:n,value:i}=e[r];if(n===icr){if(!i.list||!i.list.shape)return null;let o=i.list.shape.map(a=>a.unknown_rank?null:a.dim==null||a.dim.length===1&&a.dim[0].size==null?[]:a.dim.map(s=>s.size||0));return e.splice(r,1),o}}return null}function scr(e){if(!e)return null;for(let t=0;t<e.length;t++)if(e[t].key===ocr)return e[t].value.s||null;return null}var lcr=/^([^:]+):((\w+:|)\d+)$/;function ccr(e){let t=[],r=null;for(let n of e||[]){let i=n.startsWith("^");i&&(n=n.substring(1));let o=n,a="0",s=n.includes(":")&&n.match(lcr);s&&(o=s[1],a=s[2]),r!==o&&(r=o,t.push({name:o,outputTensorKey:a,isControlDependency:i}))}return t}function Flt(e,t,r,n,i,o){if(t===r.name)return;let a=i.refEdges[r.op+" "+o]===!0;e.edges.push({v:t,w:r.name,outputTensorKey:n.outputTensorKey,isControlDependency:n.isControlDependency,isReferenceEdge:a})}var sle={enableEmbedding:!0,inEmbeddingTypes:["Const"],outEmbeddingTypes:["^[a-zA-Z]+Summary$"],refEdges:{"Assign 0":!0,"AssignAdd 0":!0,"AssignSub 0":!0,"assign 0":!0,"assign_add 0":!0,"assign_sub 0":!0,"count_up_to 0":!0,"ScatterAdd 0":!0,"ScatterSub 0":!0,"ScatterUpdate 0":!0,"scatter_add 0":!0,"scatter_sub 0":!0,"scatter_update 0":!0}};function lle(e,t,r){let n={},i={},o={},a=ele(t.inEmbeddingTypes),s=ele(t.outEmbeddingTypes),l=[],c=e.node,u=new Array(c.length);return e1("Normalizing names",30,()=>{let h=new Array(c.length),f=0,p=g=>{let _=new _0(g);return a(_)?(l.push(_.name),n[_.name]=_,_):s(_)?(l.push(_.name),i[_.name]=_,pn.each(_.inputs,y=>{let x=y.name;o[x]=o[x]||[],o[x].push(_)}),_):(h[f]=_,u[f]=_.name,f++,_)};pn.each(c,p);let d=g=>{let _=Sa+g.signature.name;if(p({name:_,input:[],device:"",op:"",attr:[]}),g.signature.input_arg){let b=0,S=C=>{let P=p({name:_+Al+C.name,input:[],device:"",op:"input_arg",attr:[{key:"T",value:{type:C.type}}]});P.functionInputIndex=b,b++};g.signature.input_arg.name?S(g.signature.input_arg):pn.each(g.signature.input_arg,S)}let y=0,x={};if(g.signature.output_arg){let b=S=>{x[_+Al+S.name]=y,y++};g.signature.output_arg.name?b(g.signature.output_arg):pn.each(g.signature.output_arg,b)}pn.each(g.node_def,b=>{b.name=_+"/"+b.name,typeof b.input=="string"&&(b.input=[b.input]);let S=p(b);pn.isNumber(x[b.name])&&(S.functionOutputIndex=x[b.name]),pn.each(S.inputs,C=>{C.name=_+Al+C.name})})};return e.library&&e.library.function&&pn.each(e.library.function,d),h.splice(f),u.splice(f),h},r,jr.NORMALIZING_NAMES).then(h=>e1("Building the data structure",70,()=>{let f=ucr(u,l),p=new Xu;return pn.each(h,d=>{let g=f[d.name]||d.name;p.nodes[g]=d,d.name in o&&(d.outEmbeddings=o[d.name],pn.each(d.outEmbeddings,_=>{_.name=f[_.name]||_.name})),d.name=g}),pn.each(h,d=>{pn.each(d.inputs,(g,_)=>{let y=g.name;if(y in n){let x=n[y];d.inEmbeddings.push(x);for(let b of x.inputs)Flt(p,f[b.name]||b.name,d,b,t,_)}else if(y in i){let x=i[y];for(let b of x.inputs)Flt(p,f[b.name]||b.name,d,g,t,_)}else Flt(p,f[y]||y,d,g,t,_)})}),pn.each(n,(d,g)=>{d.name=f[d.name]||d.name}),p},r,jr.BUILD_SLIM_GRAPH))}function e3(e,t,r={}){let n=new nle.graphlib.Graph(r);return n.setGraph({name:e,rankdir:r.rankdir||"BT",type:t}),n}function ele(e){return function(t){for(let r=0;r<e.length;r++){let n=new RegExp(e[r]);if(typeof t.op=="string"&&t.op.match(n))return!0}return!1}}function sP(e){let t=e.split(Al);return e+Al+"("+t[t.length-1]+")"}function ucr(e,t){let r={},n={};e.sort();for(let i=0;i<e.length-1;++i){let o=e[i];pn.each(cP(o).slice(0,-1),a=>{n[a]=!0});for(let a=i+1;a<e.length;++a){let s=e[a];if(pn.startsWith(s,o)){if(s.length>o.length&&s.charAt(o.length)===Al){r[o]=sP(o);break}}else break}}return pn.each(t,i=>{i in n&&(r[i]=sP(i))}),r}function rle(e){let t=e.nodes().map(function(r){var n;return(n=e.neighbors(r))==null?void 0:n.length});return t.sort(),t}function cle(e,t){let r=rle(e),n=rle(t);for(let i=0;i<r.length;i++)if(r[i]!==n[i])return!1;return!0}function cP(e,t){let r=[],n=e.indexOf(Al);for(;n>=0;)r.push(e.substring(0,n)),n=e.indexOf(Al,n+1);if(t){let i=t[e];i&&r.push(i)}return r.push(e),r}function yH(e){return e===ur.EXCLUDE?"Add to main graph":"Remove from main graph"}function ule(e){return e===is.GROUP?"Ungroup this series of nodes":"Group this series of nodes"}var He=Ee(Oe(),1);var r1=Ee(Oe(),1);function hle(e,t){let r=fcr(e),n=pcr(r,t);return Object.keys(n).sort(i=>n[i].level).reduce((i,o)=>(i[o]=n[o],i),{})}function hcr(e){let t=r1.map({depth:e.depth,"|V|":e.metagraph.nodes().length,"|E|":e.metagraph.edges().length},function(n,i){return i+"="+n}).join(" "),r=r1.map(e.opHistogram,function(n,i){return i+"="+n}).join(",");return t+" [ops] "+r}function fcr(e){let t=e.getNodeMap(),r=Object.keys(t).reduce((n,i)=>{let o=t[i];if(o.type!==jt.META)return n;let a=i.split("/").length-1,s=hcr(o),l=n[s]||{nodes:[],level:a};return n[s]=l,l.nodes.push(o),l.level>a&&(l.level=a),n},{});return Object.keys(r).map(n=>[n,r[n]]).filter(([n,i])=>{let{nodes:o}=i;if(o.length>1)return!0;let a=o[0];return a.type===jt.META&&a.associatedFunction}).sort(([n,i])=>i.nodes[0].depth)}function pcr(e,t){return r1.reduce(e,function(n,i){let o=i[0],a=i[1].nodes,s=[];return a.forEach(function(l){for(let c=0;c<s.length;c++)if(!t||dcr(s[c].metanode.metagraph,l.metagraph)){l.templateId=s[c].metanode.templateId,s[c].members.push(l.name);return}l.templateId=o+"["+s.length+"]",s.push({metanode:l,members:[l.name]})}),s.forEach(function(l){n[l.metanode.templateId]={level:i[1].level,nodes:l.members}}),n},{})}function vH(e,t,r){return r1.sortBy(e,[n=>t.node(n).op,n=>t.node(n).templateId,n=>{var i;return(i=t.neighbors(n))==null?void 0:i.length},n=>{var i;return(i=t.predecessors(n))==null?void 0:i.length},n=>{var i;return(i=t.successors(n))==null?void 0:i.length},n=>n.substr(r.length)])}function dcr(e,t){if(!cle(e,t))return!1;let r=e.graph().name,n=t.graph().name,i={},o={},a=[];function s(u,h){let f=u.substr(r.length),p=h.substr(n.length);return i[f]^o[p]?(console.warn("different visit pattern","["+r+"]",f,"["+n+"]",p),!0):(i[f]||(i[f]=o[p]=!0,a.push({n1:u,n2:h})),!1)}let l=e.sources(),c=t.sources();if(l.length!==c.length)return console.log("different source length"),!1;l=vH(l,e,r),c=vH(c,t,n);for(let u=0;u<l.length;u++)if(s(l[u],c[u]))return!1;for(;a.length>0;){let u=a.pop();if(!mcr(e.node(u==null?void 0:u.n1),t.node(u==null?void 0:u.n2)))return!1;let f=e.successors(u==null?void 0:u.n1),p=t.successors(u==null?void 0:u.n2);if((f==null?void 0:f.length)!==(p==null?void 0:p.length))return console.log("# of successors mismatch",f,p),!1;f=vH(f,e,r),p=vH(p,t,n);for(let d=0;d<(f==null?void 0:f.length);d++)if(s(f==null?void 0:f[d],p==null?void 0:p[d]))return!1}return!0}function mcr(e,t){if(e.type===jt.META){let r=e,n=t;return!!r.templateId&&!!n.templateId&&r.templateId===n.templateId}else{if(e.type===jt.OP&&t.type===jt.OP)return e.op===t.op;if(e.type===jt.SERIES&&t.type===jt.SERIES){let r=e,n=t,i=r.metagraph.nodeCount();return i===n.metagraph.nodeCount()&&(i===0||r.metagraph.node(r.metagraph.nodes()[0]).op===n.metagraph.node(n.metagraph.nodes()[0]).op)}}return!1}var Dd;(function(e){e[e.TEMPLATES_UPDATED=0]="TEMPLATES_UPDATED"})(Dd||(Dd={}));var os=class extends dH{constructor(t){super(),this.hasShapeInfo=!1,this.maxMetaEdgeSize=1,this.graphOptions={},this.templates=null,this.graphOptions.compound=!0,this.graphOptions.rankdir=t.rankDirection,this.root=lP(qc,this.graphOptions),this.libraryFunctions={},this.seriesGroupMap=new Map(t.seriesMap),this.devices=null,this.xlaClusters=null,this.verifyTemplate=t.verifyTemplate,this.index={},this.index[qc]=this.root,this.orderings={}}getSeriesGroupType(t){var r;return(r=this.seriesGroupMap.get(t))!=null?r:is.GROUP}setSeriesGroupType(t,r){return this.seriesGroupMap.set(t,r)}buildSeriesGroupMapToggled(t){let r=this.getSeriesGroupType(t)===is.GROUP?is.UNGROUP:is.GROUP;return new Map([...this.seriesGroupMap,[t,r]])}getNodeMap(){return this.index}node(t){return this.index[t]}setNode(t,r){this.index[t]=r}getBridgegraph(t){let r=this.index[t];if(!r)throw Error("Could not find node in hierarchy: "+t);if(!("metagraph"in r))return null;let n=r;if(n.bridgegraph)return n.bridgegraph;let i=n.bridgegraph=e3("BRIDGEGRAPH",g0.BRIDGE,this.graphOptions);if(!r.parentNode||!("metagraph"in r.parentNode))return i;let o=r.parentNode,a=o.metagraph,s=this.getBridgegraph(o.name);return He.each([a,s],l=>{l.edges().filter(c=>c.v===t||c.w===t).forEach(c=>{let u=c.w===t,h=l.edge(c);He.each(h.baseEdgeList,f=>{let[p,d]=u?[f.w,c.v]:[f.v,c.w],g=this.getChildName(t,p),_={v:u?d:g,w:u?g:d},y=i.edge(_);y||(y=Hlt(_.v,_.w),y.inbound=u,i.setEdge(_.v,_.w,y)),y.addBaseEdge(f,this)})})}),i}getChildName(t,r){let n=this.index[r];for(;n;){if(n.parentNode&&n.parentNode.name===t)return n.name;n=n.parentNode}throw Error("Could not find immediate child for descendant: "+r)}getPredecessors(t){let r=this.index[t];if(!r)throw Error("Could not find node with name: "+t);let n=this.getOneWayEdges(r,!0);return r.isGroupNode||He.each(r.inEmbeddings,i=>{He.each(r.inputs,o=>{if(o.name===i.name){let a=new qf(i.name,t);a.addBaseEdge({isControlDependency:o.isControlDependency,outputTensorKey:o.outputTensorKey,isReferenceEdge:!1,v:i.name,w:t},this),n.regular.push(a)}})}),n}getSuccessors(t){let r=this.index[t];if(!r)throw Error("Could not find node with name: "+t);let n=this.getOneWayEdges(r,!1);return r.isGroupNode||He.each(r.outEmbeddings,i=>{He.each(i.inputs,o=>{if(o.name===t){let a=new qf(t,i.name);a.addBaseEdge({isControlDependency:o.isControlDependency,outputTensorKey:o.outputTensorKey,isReferenceEdge:!1,v:t,w:i.name},this),n.regular.push(a)}})}),n}getOneWayEdges(t,r){let n={control:[],regular:[]};if(!t.parentNode||!t.parentNode.isGroupNode)return n;let i=t.parentNode,o=i.metagraph,a=this.getBridgegraph(i.name);return fle(o,t,r,n),fle(a,t,r,n),n}getTopologicalOrdering(t){let r=this.index[t];if(!r)throw Error("Could not find node with name: "+t);if(!r.isGroupNode)return null;if(t in this.orderings)return this.orderings[t];let n={},i={},o=r.metagraph;He.each(o.edges(),c=>{!o.edge(c).numRegularEdges||(c.v in n||(n[c.v]=[]),n[c.v].push(c.w),i[c.w]=!0)});let a=He.difference(He.keys(n),He.keys(i)),s=this.orderings[t]={},l=0;for(;a.length;){let c=a.shift();s[c]=l++,He.each(n[c],u=>a.push(u)),delete n[c]}return s}getTemplateIndex(){if(!this.templates)return null;let t=$L(this.templates);if(!t.length)return null;let r=gu().domain(t).range(Ir(0,t.length));return n=>r(n)}updateTemplates(){Rd("Finding similar subgraphs",()=>{this.templates=hle(this,this.verifyTemplate),this.dispatchEvent(Dd.TEMPLATES_UPDATED)},jr.HIERARCHY_FIND_SIMILAR_SUBGRAPHS)}};function fle(e,t,r,n){let i=r?e.inEdges(t.name):e.outEdges(t.name);He.each(i,o=>{let a=e.edge(o);(a.numRegularEdges?n.regular:n.control).push(a)})}var r3={verifyTemplate:!0,seriesNodeMinSize:5,seriesMap:new Map,rankDirection:"BT",useGeneralizedSeriesPatterns:!1};function bH(e,t,r){let n=new os(t),i={};return e1("Adding nodes",30,()=>{let o={},a={};He.each(e.nodes,(s,l)=>{s.device&&(o[s.device]=!0),s.xlaCluster&&(a[s.xlaCluster]=!0)}),n.devices=He.keys(o),n.xlaClusters=He.keys(a),_cr(n,e)},r,jr.HIERARCHY_ADD_NODES).then(()=>e1("Detect series",30,()=>{t.seriesNodeMinSize>0&&mle(n.root,n,i,t.seriesNodeMinSize,t.seriesMap,t.useGeneralizedSeriesPatterns)},r,jr.HIERARCHY_DETECT_SERIES)).then(()=>e1("Adding edges",40,()=>{ycr(n,e,i)},r,jr.HIERARCHY_ADD_EDGES)).then(()=>n)}function ple(e,t){let r={},n={};He.each(e.root.leaves(),i=>{let o=e.node(i);o.device!=null&&(r[o.device]=!0),o.xlaCluster!=null&&(n[o.xlaCluster]=!0)}),e.devices=He.keys(r),e.xlaClusters=He.keys(n),He.each(e.getNodeMap(),(i,o)=>{i.isGroupNode&&(i.stats=new KS(null),i.deviceHistogram={})}),He.each(e.root.leaves(),i=>{let o=e.node(i),a=o;for(;a.parentNode!=null;){if(o.device!=null){let s=a.parentNode.deviceHistogram;s[o.device]=(s[o.device]||0)+1}if(o.xlaCluster!=null){let s=a.parentNode.xlaClusterHistogram;s[o.xlaCluster]=(s[o.xlaCluster]||0)+1}o.stats!=null&&a.parentNode.stats.combine(o.stats),a=a.parentNode}})}function dle(e){let t=[],r={};return He.each(e.root.leaves(),n=>{let i=e.node(n);if(i.type==jt.OP){let o=i;if(!o.compatible)if(o.owningSeries){if(e.getSeriesGroupType(o.owningSeries)===is.UNGROUP)t.push(o);else if(!r[o.owningSeries]){let a=e.node(o.owningSeries);a&&(r[o.owningSeries]=a,t.push(a))}}else t.push(o);He.each(o.inEmbeddings,a=>{a.compatible||t.push(a)}),He.each(o.outEmbeddings,a=>{a.compatible||t.push(a)})}}),t}function _cr(e,t){let r={};He.each(t.nodes,(n,i)=>{let o=cP(n.name),a=e.root;a.depth=Math.max(o.length,a.depth),r[n.op]||(r[n.op]=[]),r[n.op].push(n);for(let s=0;s<o.length&&(a.depth=Math.max(a.depth,o.length-s),a.cardinality+=n.cardinality,a.opHistogram[n.op]=(a.opHistogram[n.op]||0)+1,n.device!=null&&(a.deviceHistogram[n.device]=(a.deviceHistogram[n.device]||0)+1),n.xlaCluster!=null&&(a.xlaClusterHistogram[n.xlaCluster]=(a.xlaClusterHistogram[n.xlaCluster]||0)+1),n.compatible?a.compatibilityHistogram.compatible=(a.compatibilityHistogram.compatible||0)+1:a.compatibilityHistogram.incompatible=(a.compatibilityHistogram.incompatible||0)+1,He.each(n.inEmbeddings,u=>{u.compatible?a.compatibilityHistogram.compatible=(a.compatibilityHistogram.compatible||0)+1:a.compatibilityHistogram.incompatible=(a.compatibilityHistogram.incompatible||0)+1}),He.each(n.outEmbeddings,u=>{u.compatible?a.compatibilityHistogram.compatible=(a.compatibilityHistogram.compatible||0)+1:a.compatibilityHistogram.incompatible=(a.compatibilityHistogram.incompatible||0)+1}),s!==o.length-1);s++){let l=o[s],c=e.node(l);if(!c&&(c=lP(l,e.graphOptions),c.parentNode=a,e.setNode(l,c),a.metagraph.setNode(l,c),l.indexOf(Sa)===0&&a.name===qc)){let u=l.substring(Sa.length);r[u]||(r[u]=[]),e.libraryFunctions[u]={node:c,usages:r[u]},c.associatedFunction=u}a=c}e.setNode(n.name,n),n.parentNode=a,a.metagraph.setNode(n.name,n),He.each(n.inEmbeddings,function(s){e.setNode(s.name,s),s.parentNode=n}),He.each(n.outEmbeddings,function(s){e.setNode(s.name,s),s.parentNode=n})})}function ycr(e,t,r){let n=e.getNodeMap(),i=[],o=[],a=(s,l)=>{let c=0;for(;s;)l[c++]=s.name,s=s.parentNode;return c-1};He.each(t.edges,s=>{let l=a(t.nodes[s.v],i),c=a(t.nodes[s.w],o);if(l===-1||c===-1)return;for(;i[l]===o[c];)if(l--,c--,l<0||c<0)throw Error("No difference found between ancestor paths.");let u=n[i[l+1]],h=i[l],f=o[c],p=u.metagraph.edge(h,f);p||(p=Hlt(h,f),u.metagraph.setEdge(h,f,p)),!u.hasNonControlEdges&&!s.isControlDependency&&(u.hasNonControlEdges=!0),p.addBaseEdge(s,e)})}function mle(e,t,r,n,i,o){let a=e.metagraph;He.each(a.nodes(),u=>{let h=a.node(u);h.type===jt.META&&mle(h,t,r,n,i,o)});let s=vcr(a),c=(o?bcr:xcr)(s,a,t.graphOptions);He.each(c,function(u,h){let f=u.metagraph.nodes();He.each(f,p=>{let d=a.node(p);d.owningSeries||(d.owningSeries=h)}),f.length<n&&t.getSeriesGroupType(u.name)===is.GROUP&&t.setSeriesGroupType(u.name,is.UNGROUP),t.getSeriesGroupType(u.name)!==is.UNGROUP&&(t.setNode(h,u),a.setNode(h,u),He.each(f,p=>{let d=a.node(p);u.metagraph.setNode(p,d),u.parentNode=d.parentNode,u.cardinality++,d.device!=null&&(u.deviceHistogram[d.device]=(u.deviceHistogram[d.device]||0)+1),d.xlaCluster!=null&&(u.xlaClusterHistogram[d.xlaCluster]=(u.xlaClusterHistogram[d.xlaCluster]||0)+1),d.compatible?u.compatibilityHistogram.compatible=(u.compatibilityHistogram.compatible||0)+1:u.compatibilityHistogram.incompatible=(u.compatibilityHistogram.incompatible||0)+1,He.each(d.inEmbeddings,g=>{g.compatible?u.compatibilityHistogram.compatible=(u.compatibilityHistogram.compatible||0)+1:u.compatibilityHistogram.incompatible=(u.compatibilityHistogram.incompatible||0)+1}),He.each(d.outEmbeddings,g=>{g.compatible?u.compatibilityHistogram.compatible=(u.compatibilityHistogram.compatible||0)+1:u.compatibilityHistogram.incompatible=(u.compatibilityHistogram.incompatible||0)+1}),d.parentNode=u,r[p]=h,a.removeNode(p)}))})}function vcr(e){let t={};return He.reduce(e.nodes(),(r,n)=>{let i=e.node(n);if(i.type===jt.META)return r;let o=i.op;return o&&(r[o]=r[o]||[],r[o].push(i.name)),r},t)}function xcr(e,t,r){let n={};return He.each(e,function(i,o){if(i.length<=1)return;let a={};He.each(i,function(s){let l=s.charAt(s.length-1)==="*",c=s.split("/"),u=c[c.length-1],h=c.slice(0,c.length-1).join("/"),f=u.match(/^(\D*)(\d+)$/),p,d,g="";f?(p=f[1],d=f[2]):(p=l?u.substr(0,u.length-1):u,d=0,g=l?"*":"");let _=t3(p,g,h);a[_]=a[_]||[];let y=QS(p,g,h,+d,s,r);a[_].push(y)}),He.each(a,function(s,l){if(s.length<2)return;s.sort(function(u,h){return+u.clusterId-+h.clusterId});let c=[s[0]];for(let u=1;u<s.length;u++){let h=s[u];if(h.clusterId===c[c.length-1].clusterId+1){c.push(h);continue}xH(c,n,+o,t,r),c=[h]}xH(c,n,+o,t,r)})}),n}function bcr(e,t,r){let n={};return He.each(e,function(i,o){if(i.length<=1)return;let a={},s={};He.each(i,function(c){let u=c.charAt(c.length-1)==="*",h=c.split("/"),f=h[h.length-1],p=h.slice(0,h.length-1).join("/"),d=/(\d+)/g,g=[],_,y,x,b,S,C=0;for(;_=d.exec(f);)++C,y=f.slice(0,_.index),x=_[0],b=f.slice(_.index+_[0].length),S=t3(y,b,p),a[S]=a[S],a[S]||(a[S]=QS(y,b,p,+x,c,r)),a[S].ids.push(x),s[c]=s[c]||[],s[c].push([S,x]);C<1&&(y=u?f.substr(0,f.length-1):f,x=0,b=u?"*":"",S=t3(y,b,p),a[S]=a[S],a[S]||(a[S]=QS(y,b,p,+x,c,r)),a[S].ids.push(x),s[c]=s[c]||[],s[c].push([S,x]))});var l={};He.each(s,function(c,u){c.sort(function(y,x){return a[x[0]].ids.length-a[y[0]].ids.length});var h=c[0][0],f=c[0][1];l[h]=l[h]||[];let p=u.split("/"),d=p[p.length-1],g=p.slice(0,p.length-1).join("/");var _=QS(a[h].prefix,a[h].suffix,g,+f,u,r);l[h].push(_)}),He.each(l,function(c,u){if(c.length<2)return;c.sort(function(f,p){return+f.clusterId-+p.clusterId});let h=[c[0]];for(let f=1;f<c.length;f++){let p=c[f];if(p.clusterId===h[h.length-1].clusterId+1){h.push(p);continue}xH(h,n,+o,t,r),h=[p]}xH(h,n,+o,t,r)})}),n}function xH(e,t,r,n,i){if(e.length>1){let o=t3(e[0].prefix,e[0].suffix,e[0].parent,e[0].clusterId,e[e.length-1].clusterId),a=QS(e[0].prefix,e[0].suffix,e[0].parent,r,o,i);He.each(e,function(s){a.ids.push(s.clusterId),a.metagraph.setNode(s.name,n.node(s.name))}),t[o]=a}}var me=Ee(Oe(),1);var y0={DEFAULT_FILL:"#ffffff",DEFAULT_STROKE:"#b2b2b2",COMPATIBLE:"#0f9d58",INCOMPATIBLE:"#db4437"},Ku={DEFAULT_FILL:"#d9d9d9",DEFAULT_STROKE:"#a6a6a6",SATURATION:.6,LIGHTNESS:.85,EXPANDED_COLOR:"#f0f0f0",HUES:[220,100,180,40,20,340,260,300,140,60],STRUCTURE_PALETTE(e,t){let r=Ku.HUES,n=r.length,i=r[e%n],o=Math.sin(i*Math.PI/360),a=t?30:90-60*o,s=t?95:80;return Vm(i,.01*a,.01*s).toString()},DEVICE_PALETTE(e){return Ku.STRUCTURE_PALETTE(e)},XLA_CLUSTER_PALETTE(e){return Ku.STRUCTURE_PALETTE(e)},UNKNOWN:"#eee",GRADIENT_OUTLINE:"#888"},Vlt={DEFAULT_FILL:"white",DEFAULT_STROKE:"#b2b2b2"},Xo={minNodeCountForExtraction:15,minDegreeForExtraction:5,maxControlDegree:4,maxBridgePathDegree:4,outExtractTypes:["NoOp"],inExtractTypes:[],detachAllEdgesForHighDegree:!0,extractIsolatedNodesWithAnnotationsOnOneSide:!0,enableBridgegraph:!0,minMaxColors:["#fff5f0","#fb6a4a"],maxAnnotations:5},wcr=new RegExp("^(?:"+Sa+")?(\\w+)_[a-z0-9]{8}(?:_\\d+)?$"),lo=class{constructor(t,r,n){this.hierarchy=t,this.displayingStats=r,this.autoExtractNodes=n,this.index={},this.renderedOpNames=[],this.computeScales(),this.hasSubhierarchy={},this.root=new SH(t.root,t.graphOptions),this.index[t.root.name]=this.root,this.renderedOpNames.push(t.root.name),this.buildSubhierarchy(t.root.name),this.root.expanded=!0,this.traceInputs=!1}computeScales(){this.deviceColorMap=gu().domain(this.hierarchy.devices).range(me.map(Ir(this.hierarchy.devices.length),Ku.DEVICE_PALETTE)),this.xlaClusterColorMap=gu().domain(this.hierarchy.xlaClusters).range(me.map(Ir(this.hierarchy.xlaClusters.length),Ku.XLA_CLUSTER_PALETTE));let t=this.hierarchy.root.metagraph,r=lu(t.nodes(),(i,o)=>{let a=t.node(i);if(a.stats!=null)return a.stats.totalBytes});this.memoryUsageScale=On().domain([0,r]).range(Xo.minMaxColors);let n=lu(t.nodes(),(i,o)=>{let a=t.node(i);if(a.stats!=null)return a.stats.getTotalMicros()});this.computeTimeScale=On().domain([0,n]).range(Xo.minMaxColors),this.edgeWidthSizedBasedScale=this.hierarchy.hasShapeInfo?Xse:On().domain([1,this.hierarchy.maxMetaEdgeSize]).range([Q4,tP])}getRenderNodeByName(t){return this.index[t]}getNodeByName(t){return this.hierarchy.node(t)}colorHistogram(t,r){if(Object.keys(t).length>0){let n=me.sum(Object.keys(t).map(i=>t[i]));return Object.keys(t).map(i=>({color:r(i),proportion:t[i]/n}))}return null}getOrCreateRenderNodeByName(t){if(!t)return null;if(t in this.index)return this.index[t];let r=this.hierarchy.node(t);if(!r)return null;let n=r.isGroupNode?new SH(r,this.hierarchy.graphOptions):new Gf(r);this.index[t]=n,this.renderedOpNames.push(t),r.stats&&(n.memoryColor=this.memoryUsageScale(r.stats.totalBytes),n.computeTimeColor=this.computeTimeScale(r.stats.getTotalMicros())),n.isFadedOut=this.displayingStats&&!gH(r.stats);var i=null,o=null,a=null;if(r.isGroupNode){i=r.deviceHistogram,o=r.xlaClusterHistogram;let s=r.compatibilityHistogram.compatible,l=r.compatibilityHistogram.incompatible;(s!=0||l!=0)&&(a=s/(s+l))}else{let s=n.node.device;s&&(i={[s]:1});let l=n.node.xlaCluster;l&&(o={[l]:1}),n.node.type===jt.OP&&(a=n.node.compatible?1:0)}return i&&(n.deviceColors=this.colorHistogram(i,this.deviceColorMap)),o&&(n.xlaClusterColors=this.colorHistogram(o,this.xlaClusterColorMap)),a!=null&&(n.compatibilityColors=[{color:y0.COMPATIBLE,proportion:a},{color:y0.INCOMPATIBLE,proportion:1-a}]),this.index[t]}getNearestVisibleAncestor(t){let r=cP(t),n=0,i=null,o=t;for(;n<r.length&&(o=r[n],i=this.getRenderNodeByName(o),!!i.expanded);n++);if(n==r.length-2){let a=r[n+1];if(i!=null&&i.inAnnotations.nodeNames[a]||i!=null&&i.outAnnotations.nodeNames[a])return a}return o}setDepth(t){yle(this.root,+t)}isNodeAuxiliary(t){let r=this.getRenderNodeByName(t.node.parentNode.name),n=me.find(r.isolatedInExtract,i=>i.node.name===t.node.name);return n?!0:(n=me.find(r.isolatedOutExtract,i=>i.node.name===t.node.name),!!n)}getNamesOfRenderedOps(){return this.renderedOpNames}cloneAndAddFunctionOpNode(t,r,n,i){let o=n.name.replace(r,i),a=t.metagraph.node(o);if(a)return a;a=new _0({name:o,input:[],device:n.device,op:n.op,attr:me.cloneDeep(n.attr)}),a.cardinality=n.cardinality,a.include=n.include,a.outputShapes=me.cloneDeep(n.outputShapes),a.xlaCluster=n.xlaCluster,a.functionInputIndex=n.functionInputIndex,a.functionOutputIndex=n.functionOutputIndex,a.inputs=n.inputs.map(l=>{let c=me.clone(l);return c.name=l.name.replace(r,i),c}),a.parentNode=t,t.metagraph.setNode(a.name,a),this.hierarchy.setNode(a.name,a);let s=l=>this.cloneAndAddFunctionOpNode(t,r,l,i);return a.inEmbeddings=n.inEmbeddings.map(s),a.outEmbeddings=n.outEmbeddings.map(s),a}cloneFunctionLibraryMetanode(t,r,n,i,o){let a={},s=this.cloneFunctionLibraryMetanodeHelper(t,r,n,i,o,a);return me.isEmpty(a)||this.patchEdgesFromFunctionOutputs(r,a),s}cloneFunctionLibraryMetanodeHelper(t,r,n,i,o,a){let s=lP(n.name.replace(i,o));return s.depth=n.depth,s.cardinality=n.cardinality,s.templateId=n.templateId,s.opHistogram=me.clone(n.opHistogram),s.deviceHistogram=me.clone(n.deviceHistogram),s.xlaClusterHistogram=me.clone(n.xlaClusterHistogram),s.hasNonControlEdges=n.hasNonControlEdges,s.include=n.include,s.nodeAttributes=me.clone(n.nodeAttributes),s.associatedFunction=n.associatedFunction,me.each(n.metagraph.nodes(),l=>{let c=n.metagraph.node(l);switch(c.type){case jt.META:let u=this.cloneFunctionLibraryMetanodeHelper(t,r,c,i,o,a);u.parentNode=s,s.metagraph.setNode(u.name,u),this.hierarchy.setNode(u.name,u);break;case jt.OP:let h=this.cloneAndAddFunctionOpNode(s,i,c,o);me.isNumber(h.functionInputIndex)&&this.patchEdgesIntoFunctionInputs(r,h),me.isNumber(h.functionOutputIndex)&&(a[h.functionOutputIndex]=h);break;default:console.warn(c.name+" is oddly neither a metanode nor an opnode.")}}),this.cloneLibraryMetanodeEdges(n,s,i,o),s}cloneLibraryMetanodeEdges(t,r,n,i){me.each(t.metagraph.edges(),o=>{let a=t.metagraph.edge(o),s=a.v.replace(n,i),l=a.w.replace(n,i),c=new qf(s,l);c.inbound=a.inbound,c.numRegularEdges=a.numRegularEdges,c.numControlEdges=a.numControlEdges,c.numRefEdges=a.numRefEdges,c.totalSize=a.totalSize,a.baseEdgeList&&(c.baseEdgeList=a.baseEdgeList.map(u=>{let h=me.clone(u);return h.v=u.v.replace(n,i),h.w=u.w.replace(n,i),h})),r.metagraph.node(l)?r.metagraph.setEdge(s,l,c):r.metagraph.setEdge(l,s,c)})}patchEdgesIntoFunctionInputs(t,r){let n=Math.min(r.functionInputIndex,t.inputs.length-1),i=me.clone(t.inputs[n]);for(;i.isControlDependency;)n++,i=t.inputs[n];r.inputs.push(i);let o=this.hierarchy.getPredecessors(t.name),a,s=0;me.each(o.regular,l=>{if(s+=l.numRegularEdges,s>n)return a=l,!1}),me.each(a.baseEdgeList,l=>{l.w===t.name&&(l.w=r.name),l.v===t.name&&(l.v=r.name)})}patchEdgesFromFunctionOutputs(t,r){let n=this.hierarchy.getSuccessors(t.name);me.each(n.regular,i=>{me.each(i.baseEdgeList,o=>{let a=this.hierarchy.node(o.w);me.each(a.inputs,s=>{if(s.name===t.name){let l=r[s.outputTensorKey];s.name=l.name,s.outputTensorKey=o.outputTensorKey}})}),me.each(i.baseEdgeList,o=>{o.v=r[o.outputTensorKey].name,o.outputTensorKey="0"})})}buildSubhierarchy(t){if(t in this.hasSubhierarchy)return;this.hasSubhierarchy[t]=!0;let r=this.index[t];if(r.node.type!==jt.META&&r.node.type!==jt.SERIES)return;let n=r,i=n.node.metagraph,o=n.coreGraph,a=[],s=[];me.isEmpty(this.hierarchy.libraryFunctions)||(me.each(i.nodes(),d=>{let g=i.node(d),_=this.hierarchy.libraryFunctions[g.op];if(!_||d.indexOf(Sa)===0)return;let y=this.cloneFunctionLibraryMetanode(i,g,_.node,_.node.name,g.name);a.push(g),s.push(y)}),me.each(s,(d,g)=>{let _=a[g];d.parentNode=_.parentNode,i.setNode(_.name,d),this.hierarchy.setNode(_.name,d)})),me.each(i.nodes(),d=>{let g=this.getOrCreateRenderNodeByName(d),_=g.node;o.setNode(d,g),_.isGroupNode||(me.each(_.inEmbeddings,y=>{let x=new Od(null),b=new Gf(y);gle(g,y,b,x,gi.CONSTANT),this.index[y.name]=b}),me.each(_.outEmbeddings,y=>{let x=new Od(null),b=new Gf(y);_le(g,y,b,x,gi.SUMMARY),this.index[y.name]=b}))}),me.each(i.edges(),d=>{let g=i.edge(d),_=new Od(g);_.isFadedOut=this.index[d.v].isFadedOut||this.index[d.w].isFadedOut,o.setEdge(d.v,d.w,_)}),n.node.type===jt.META&&Pcr(n,this.autoExtractNodes),me.isEmpty(this.hierarchy.libraryFunctions)||this.buildSubhierarchiesForNeededFunctions(i),t===qc&&me.forOwn(this.hierarchy.libraryFunctions,(d,g)=>{let _=d.node,y=this.getOrCreateRenderNodeByName(_.name);n.libraryFunctionsExtract.push(y),y.node.include=ur.EXCLUDE,o.removeNode(_.name)});let l=n.node.parentNode;if(!l)return;let c=this.index[l.name],u=(d,...g)=>g.concat([d?"IN":"OUT"]).join("~~"),h=this.hierarchy.getBridgegraph(t),f={in:{},out:{},control:{}};me.each(h.edges(),d=>{let g=!!i.node(d.w),_=g?d.v:d.w;h.edge(d).numRegularEdges?g?f.out[_]=(f.out[_]||0)+1:f.in[_]=(f.in[_]||0)+1:f.control[_]=(f.control[_]||0)+1});let p=this.hierarchy.getNodeMap();me.each(h.edges(),d=>{let g=h.edge(d),_=!!i.node(d.w),[y,x]=_?[d.w,d.v]:[d.v,d.w],b=this.index[y],S=this.index[x],C=S?S.node:p[x],P=!g.numRegularEdges&&f.control[x]>Xo.maxControlDegree,[,k]=_?[r.inAnnotations,b.inAnnotations]:[r.outAnnotations,b.outAnnotations],D=(_?f.out:f.in)[x]>Xo.maxBridgePathDegree,B=null,I=!1;if(Xo.enableBridgegraph&&!D&&!P&&b.isInCore()){let W=Z=>{let rt=_?{v:Z,w:t}:{v:t,w:Z};return c.coreGraph.edge(rt)};B=W(x),B||(B=W(u(_,x,l.name))),I=!!B}let L=!1;if(B&&!g.numRegularEdges){let W=B,Z=c.node;for(;W.adjoiningMetaedge;)W=W.adjoiningMetaedge,Z=Z.parentNode;let rt=this.hierarchy.getTopologicalOrdering(Z.name),ot=W.metaedge;L=rt[ot.v]>rt[ot.w]}if(I=I&&!L,!I){k.push(new i3(C,S,new Od(g),gi.SHORTCUT,_));return}let R=u(_,t),F=u(_,x,t),z=o.node(F);if(!z){let W=o.node(R);if(!W){let rt={name:R,type:jt.BRIDGE,isGroupNode:!1,cardinality:0,parentNode:null,stats:null,include:ur.UNSPECIFIED,inbound:_,nodeAttributes:{}};W=new Gf(rt),this.index[R]=W,o.setNode(R,W)}let Z={name:F,type:jt.BRIDGE,isGroupNode:!1,cardinality:1,parentNode:null,stats:null,include:ur.UNSPECIFIED,inbound:_,nodeAttributes:{}};z=new Gf(Z),this.index[F]=z,o.setNode(F,z),o.setParent(F,R),W.node.cardinality++}let U=new Od(g);U.adjoiningMetaedge=B,_?o.setEdge(F,y,U):o.setEdge(y,F,U)}),me.each([!0,!1],d=>{let g=u(d,t),_=o.node(g);!_||me.each(o.nodes(),y=>{var k,O;if(o.node(y).node.type===jt.BRIDGE||!(d?!((k=o.predecessors(y))!=null&&k.length):!((O=o.successors(y))!=null&&O.length)))return;let S=u(d,t,"STRUCTURAL_TARGET"),C=o.node(S);if(!C){let D={name:S,type:jt.BRIDGE,isGroupNode:!1,cardinality:1,parentNode:null,stats:null,include:ur.UNSPECIFIED,inbound:d,nodeAttributes:{}};C=new Gf(D),C.structural=!0,this.index[S]=C,o.setNode(S,C),_.node.cardinality++,o.setParent(S,g)}let P=new Od(null);P.structural=!0,P.weight--,d?o.setEdge(S,y,P):o.setEdge(y,S,P)})})}buildSubhierarchiesForNeededFunctions(t){me.each(t.edges(),r=>{let n=t.edge(r),i=new Od(n);me.forEach(i.metaedge.baseEdgeList,o=>{let a=o.v.split(Al);for(let s=a.length;s>=0;s--){let l=a.slice(0,s),c=this.hierarchy.node(l.join(Al));if(c){if(c.type===jt.OP&&this.hierarchy.libraryFunctions[c.op])for(let u=1;u<l.length;u++){let h=l.slice(0,u).join(Al);!h||this.buildSubhierarchy(h)}break}}})})}},i3=class{constructor(t,r,n,i,o){this.node=t,this.renderNodeInfo=r,this.renderMetaedgeInfo=n,this.annotationType=i,this.dx=0,this.dy=0,this.width=0,this.height=0,n&&n.metaedge&&(this.v=n.metaedge.v,this.w=n.metaedge.w),this.isIn=o,this.points=[]}},gi;(function(e){e[e.SHORTCUT=0]="SHORTCUT",e[e.CONSTANT=1]="CONSTANT",e[e.SUMMARY=2]="SUMMARY",e[e.ELLIPSIS=3]="ELLIPSIS"})(gi||(gi={}));var wH=class{constructor(){this.list=[],this.nodeNames={}}push(t){if(t.node.name in this.nodeNames)return;if(this.nodeNames[t.node.name]=!0,this.list.length<Xo.maxAnnotations){this.list.push(t);return}let r=this.list[this.list.length-1];if(r.annotationType===gi.ELLIPSIS){let i=r.node;i.setNumMoreNodes(++i.numMoreNodes);return}let n=new _H(1);this.list.push(new i3(n,new Gf(n),null,gi.ELLIPSIS,t.isIn))}},Gf=class{constructor(t){if(this.node=t,this.expanded=!1,this.inAnnotations=new wH,this.outAnnotations=new wH,this.x=0,this.y=0,this.width=0,this.height=0,this.inboxWidth=0,this.outboxWidth=0,this.excluded=!1,this.structural=!1,this.labelOffset=0,this.radius=0,this.labelHeight=0,this.paddingTop=0,this.paddingLeft=0,this.paddingRight=0,this.paddingBottom=0,this.isInExtract=!1,this.isOutExtract=!1,this.coreBox={width:0,height:0},this.isFadedOut=!1,this.displayName=t.name.substring(t.name.lastIndexOf(Al)+1),t.type===jt.META&&t.associatedFunction){let r=this.displayName.match(wcr);r?this.displayName=r[1]:me.startsWith(this.displayName,Sa)&&(this.displayName=this.displayName.substring(Sa.length))}}isInCore(){return!this.isInExtract&&!this.isOutExtract&&!this.isLibraryFunction}},Od=class{constructor(t){this.metaedge=t,this.adjoiningMetaedge=null,this.structural=!1,this.weight=1,this.isFadedOut=!1}};function gle(e,t,r,n,i){let o=new i3(t,r,n,i,!0);e.inAnnotations.push(o)}function _le(e,t,r,n,i){let o=new i3(t,r,n,i,!1);e.outAnnotations.push(o)}function Scr(e,t){me.each(e.nodes(),r=>{let n=e.node(r);if(n.expanded=t>1,t>0)switch(n.node.type){case jt.META:case jt.SERIES:yle(n,t-1);break}})}var SH=class extends Gf{constructor(t,r){super(t);let i=t.metagraph.graph();this.coreGraph=e3(i.name,g0.CORE,r),this.inExtractBox={width:0,height:0},this.outExtractBox={width:0,height:0},this.libraryFunctionsBox={width:0,height:0},this.isolatedInExtract=[],this.isolatedOutExtract=[],this.libraryFunctionsExtract=[]}};function yle(e,t){e.coreGraph&&Scr(e.coreGraph,t)}function uP(e,t,r){let n=e.node(t),i=e.node(r),o=e.edge(t,r);(n.node.include===ur.INCLUDE||i.node.include===ur.INCLUDE)&&n.node.include!==ur.EXCLUDE&&i.node.include!==ur.EXCLUDE||(_le(n,i.node,i,o,gi.SHORTCUT),gle(i,n.node,n,o,gi.SHORTCUT),e.removeEdge(t,r))}function Ult(e,t,r){var o;let n=e.coreGraph,i=n.node(t);i.isOutExtract=!0,me.each(n.predecessors(t),(a,s)=>{uP(n,a,t)}),(Xo.detachAllEdgesForHighDegree||r)&&me.each(n.successors(t),(a,s)=>{uP(n,t,a)}),((o=n.neighbors(t))==null?void 0:o.length)===0&&(i.node.include=ur.EXCLUDE,e.isolatedOutExtract.push(i),n.removeNode(t))}function qlt(e,t,r){var o;let n=e.coreGraph,i=n.node(t);i.isInExtract=!0,me.each(n.successors(t),(a,s)=>{uP(n,t,a)}),(Xo.detachAllEdgesForHighDegree||r)&&me.each(n.predecessors(t),(a,s)=>{uP(n,a,t)}),((o=n.neighbors(t))==null?void 0:o.length)===0&&(i.node.include=ur.EXCLUDE,e.isolatedInExtract.push(i),n.removeNode(t))}function vle(e,t){if(e.type===jt.OP){for(let r=0;r<t.length;r++)if(e.op===t[r])return!0}else if(e.type===jt.META){let r=e.getRootOp();if(r){for(let n=0;n<t.length;n++)if(r.op===t[n])return!0}}return!1}function Mcr(e){let t=e.coreGraph;me.each(t.nodes(),r=>{var i,o;t.node(r).node.include===ur.EXCLUDE&&!r.startsWith(Sa)&&(((i=e.coreGraph.outEdges(r))==null?void 0:i.length)>((o=e.coreGraph.inEdges(r))==null?void 0:o.length)?Ult(e,r,!0):qlt(e,r,!0))})}function Ecr(e){let t=e.coreGraph;me.each(t.nodes(),r=>{let n=t.node(r);n.node.include===ur.UNSPECIFIED&&vle(n.node,Xo.outExtractTypes)&&Ult(e,r)})}function Tcr(e){let t=e.coreGraph;me.each(t.nodes(),r=>{let n=t.node(r);n.node.include===ur.UNSPECIFIED&&vle(n.node,Xo.inExtractTypes)&&qlt(e,r)})}function Ccr(e){let t=e.coreGraph,r={},n={},i=0;if(me.each(t.nodes(),_=>{var b,S,C,P;if(t.node(_).node.include!==ur.UNSPECIFIED)return;let y=me.reduce(t.predecessors(_),(k,O)=>{let D=t.edge(O,_).metaedge;return k+(D.numRegularEdges?1:0)},0);y===0&&((b=t.predecessors(_))==null?void 0:b.length)>0&&(y=(S=t.predecessors(_))==null?void 0:S.length);let x=me.reduce(t.successors(_),(k,O)=>{let D=t.edge(_,O).metaedge;return k+(D.numRegularEdges?1:0)},0);x===0&&((C=t.successors(_))==null?void 0:C.length)>0&&(x=(P=t.successors(_))==null?void 0:P.length),r[_]=y,n[_]=x,i++}),i<Xo.minNodeCountForExtraction)return;let o=Xo.minDegreeForExtraction-1,a=Math.round(i*.75),s=Math.round(i*.25),l=Object.keys(r).sort((_,y)=>r[_]-r[y]),c=r[l[a]],u=r[l[s]],h=c+c-u;h=Math.max(h,o);for(let _=i-1;r[l[_]]>h;_--)qlt(e,l[_]);let f=Object.keys(n).sort((_,y)=>n[_]-n[y]),p=n[f[a]],d=n[f[s]],g=p+(p-d)*4;g=Math.max(g,o);for(let _=i-1;n[f[_]]>g;_--){let y=t.node(f[_]);!y||y.isInExtract||Ult(e,f[_])}}function Acr(e){let t=e.coreGraph,r={};me.each(t.edges(),n=>{t.edge(n).metaedge.numRegularEdges||((r[n.v]=r[n.v]||[]).push(n),(r[n.w]=r[n.w]||[]).push(n))}),me.each(r,(n,i)=>{n.length>Xo.maxControlDegree&&me.each(n,o=>uP(t,o.v,o.w))})}function Pcr(e,t){Mcr(e),Xo.outExtractTypes.length&&Ecr(e),Xo.inExtractTypes.length&&Tcr(e),t&&Ccr(e),Xo.maxControlDegree&&Acr(e);let r=e.coreGraph;me.each(r.nodes(),n=>{var a;let i=r.node(n),o=(a=r.neighbors(n))==null?void 0:a.length;if(i.node.include===ur.UNSPECIFIED&&o===0){let s=i.outAnnotations.list.length>0,l=i.inAnnotations.list.length>0;i.isInExtract?(e.isolatedInExtract.push(i),i.node.include=ur.EXCLUDE,r.removeNode(n)):i.isOutExtract?(e.isolatedOutExtract.push(i),i.node.include=ur.EXCLUDE,r.removeNode(n)):Xo.extractIsolatedNodesWithAnnotationsOnOneSide&&(s&&!l?(i.isInExtract=!0,e.isolatedInExtract.push(i),i.node.include=ur.EXCLUDE,r.removeNode(n)):l&&!s&&(i.isOutExtract=!0,e.isolatedOutExtract.push(i),i.node.include=ur.EXCLUDE,r.removeNode(n)))}})}function xle(e,t,r){let n=r.split("/"),i=n[n.length-1].match(/(.*):\w+/);(i==null?void 0:i.length)===2&&(n[n.length-1]=i==null?void 0:i[1]);let o=n[0],a=t.getRenderNodeByName(o);for(let s=1;s<n.length&&a.node.type!==jt.OP;s++)t.buildSubhierarchy(o),a.expanded=!0,e.setNodeExpanded(a),o+="/"+n[s],a=t.getRenderNodeByName(o);return a.node.name}var Mle=Ee(Olt(),1),Ze=Ee(Oe(),1);var Tr={animation:{duration:250},graph:{meta:{nodeSep:5,rankSep:25,edgeSep:5},series:{nodeSep:5,rankSep:25,edgeSep:5},padding:{paddingTop:40,paddingLeft:20}},subscene:{meta:{paddingTop:10,paddingBottom:10,paddingLeft:10,paddingRight:10,labelHeight:20,extractXOffset:15,extractYOffset:20},series:{paddingTop:10,paddingBottom:10,paddingLeft:10,paddingRight:10,labelHeight:10}},nodeSize:{meta:{radius:5,width:60,maxLabelWidth:52,height:On().domain([1,200]).range([15,60]).clamp(!0),expandButtonRadius:3},op:{width:15,height:6,radius:3,labelOffset:-8,maxLabelWidth:30},series:{expanded:{radius:10,labelOffset:0},vertical:{width:16,height:13,labelOffset:-13},horizontal:{width:24,height:8,radius:10,labelOffset:-10}},bridge:{width:20,height:20,radius:2,labelOffset:0}},shortcutSize:{op:{width:10,height:4},meta:{width:12,height:4,radius:1},series:{width:14,height:4}},annotations:{inboxWidth:50,outboxWidth:50,xOffset:10,yOffset:3,labelOffset:2,maxLabelWidth:40},constant:{size:{width:4,height:4}},series:{maxStackCount:3,parallelStackOffsetRatio:.2,towerStackOffsetRatio:.5},minimap:{size:150}},o3=140;function MH(e){e.node.isGroupNode&&Lcr(e),e.node.type===jt.META?kcr(e):e.node.type===jt.SERIES&&Rcr(e)}function Icr(e){e.inboxWidth=e.inAnnotations.list.length>0?Tr.annotations.inboxWidth:0,e.outboxWidth=e.outAnnotations.list.length>0?Tr.annotations.outboxWidth:0,e.coreBox.width=e.width,e.coreBox.height=e.height;let t=e.displayName.length,r=3;e.width=Math.max(e.coreBox.width+e.inboxWidth+e.outboxWidth,t*r)}function Lcr(e){let t=e.coreGraph.nodes().map(r=>e.coreGraph.node(r)).concat(e.isolatedInExtract,e.isolatedOutExtract,e.libraryFunctionsExtract);Ze.each(t,r=>{switch(r.node.type){case jt.OP:Ze.extend(r,Tr.nodeSize.op);break;case jt.BRIDGE:Ze.extend(r,Tr.nodeSize.bridge);break;case jt.META:r.expanded?MH(r):(Ze.extend(r,Tr.nodeSize.meta),r.height=Tr.nodeSize.meta.height(r.node.cardinality));break;case jt.SERIES:if(r.expanded)Ze.extend(r,Tr.nodeSize.series.expanded),MH(r);else{let i=r.node.hasNonControlEdges?Tr.nodeSize.series.vertical:Tr.nodeSize.series.horizontal;Ze.extend(r,i)}break;default:throw Error("Unrecognized node type: "+r.node.type)}r.expanded||Icr(r),Ncr(r)})}function Ele(e,t){Ze.extend(e.graph(),{nodesep:t.nodeSep,ranksep:t.rankSep,edgesep:t.edgeSep});let r=[],n=[];if(Ze.each(e.nodes(),l=>{e.node(l).node.type===jt.BRIDGE?r.push(l):n.push(l)}),!n.length)return{width:0,height:0};Mle.layout(e);let i=1/0,o=1/0,a=-1/0,s=-1/0;return Ze.each(n,l=>{let c=e.node(l),u=.5*c.width,h=c.x-u,f=c.x+u;i=h<i?h:i,a=f>a?f:a;let p=.5*c.height,d=c.y-p,g=c.y+p;o=d<o?d:o,s=g>s?g:s}),Ze.each(e.edges(),l=>{let c=e.edge(l);if(c.structural)return;let u=e.node(c.metaedge.v),h=e.node(c.metaedge.w);if(c.points.length===3&&Dcr(c.points)){if(u!=null){let d=u.expanded?u.x:v0(u);c.points[0].x=d}if(h!=null){let d=h.expanded?h.x:v0(h);c.points[2].x=d}c.points=[c.points[0],c.points[1]]}let f=c.points[c.points.length-2];h!=null&&(c.points[c.points.length-1]=Sle(f,h));let p=c.points[1];u!=null&&(c.points[0]=Sle(p,u)),Ze.each(c.points,d=>{i=d.x<i?d.x:i,a=d.x>a?d.x:a,o=d.y<o?d.y:o,s=d.y>s?d.y:s})}),Ze.each(e.nodes(),l=>{let c=e.node(l);c.x-=i,c.y-=o}),Ze.each(e.edges(),l=>{Ze.each(e.edge(l).points,c=>{c.x-=i,c.y-=o})}),{width:a-i,height:s-o}}function kcr(e){let t=Tr.subscene.meta;Ze.extend(e,t),Ze.extend(e.coreBox,Ele(e.coreGraph,Tr.graph.meta));let r=e.isolatedInExtract.length?Ze.maxBy(e.isolatedInExtract,c=>c.width).width:null;e.inExtractBox.width=r!=null?r:0,e.inExtractBox.height=Ze.reduce(e.isolatedInExtract,(c,u,h)=>{let f=h>0?t.extractYOffset:0;return u.x=0,u.y=c+f+u.height/2,c+f+u.height},0);let n=e.isolatedOutExtract.length?Ze.maxBy(e.isolatedOutExtract,c=>c.width).width:null;e.outExtractBox.width=n!=null?n:0,e.outExtractBox.height=Ze.reduce(e.isolatedOutExtract,(c,u,h)=>{let f=h>0?t.extractYOffset:0;return u.x=0,u.y=c+f+u.height/2,c+f+u.height},0);let i=e.libraryFunctionsExtract.length?Ze.maxBy(e.libraryFunctionsExtract,c=>c.width).width:null;e.libraryFunctionsBox.width=i!=null?i:0,e.libraryFunctionsBox.height=Ze.reduce(e.libraryFunctionsExtract,(c,u,h)=>{let f=h>0?t.extractYOffset:0;return u.x=0,u.y=c+f+u.height/2,c+f+u.height},0);let o=0;e.isolatedInExtract.length>0&&o++,e.isolatedOutExtract.length>0&&o++,e.libraryFunctionsExtract.length>0&&o++,e.coreGraph.nodeCount()>0&&o++;let a=Tr.subscene.meta.extractXOffset,s=o<=1?0:o*a,l=Math.max(o3,e.inExtractBox.width+e.outExtractBox.width);e.coreBox.width+=l+s+e.libraryFunctionsBox.width+s,e.coreBox.height=t.labelHeight+Math.max(e.inExtractBox.height,e.coreBox.height,e.libraryFunctionsBox.height,e.outExtractBox.height),e.width=e.coreBox.width+t.paddingLeft+t.paddingRight,e.height=e.paddingTop+e.coreBox.height+e.paddingBottom}function Rcr(e){let t=e.coreGraph,r=Tr.subscene.series;Ze.extend(e,r),Ze.extend(e.coreBox,Ele(e.coreGraph,Tr.graph.series)),Ze.each(t.nodes(),n=>{t.node(n).excluded=!1}),e.width=e.coreBox.width+r.paddingLeft+r.paddingRight,e.height=e.coreBox.height+r.paddingTop+r.paddingBottom}function Ncr(e){if(e.expanded)return;let t=e.inAnnotations.list,r=e.outAnnotations.list;Ze.each(t,u=>ble(u)),Ze.each(r,u=>ble(u));let n=Tr.annotations,i=Ze.reduce(t,(u,h,f)=>{let p=f>0?n.yOffset:0;return h.dx=-(e.coreBox.width+h.width)/2-n.xOffset,h.dy=u+p+h.height/2,u+p+h.height},0);Ze.each(t,u=>{u.dy-=i/2,u.labelOffset=n.labelOffset});let o=Ze.reduce(r,(u,h,f)=>{let p=f>0?n.yOffset:0;return h.dx=(e.coreBox.width+h.width)/2+n.xOffset,h.dy=u+p+h.height/2,u+p+h.height},0);Ze.each(r,u=>{u.dy-=o/2,u.labelOffset=n.labelOffset});let a=Math.min(e.height/2-e.radius,i/2);a=a<0?0:a;let s=On().domain([0,t.length-1]).range([-a,a]);Ze.each(t,(u,h)=>{u.points=[{dx:u.dx+u.width/2,dy:u.dy},{dx:-e.coreBox.width/2,dy:t.length>1?s(h):0}]});let l=Math.min(e.height/2-e.radius,o/2);l=l<0?0:l;let c=On().domain([0,r.length-1]).range([-l,l]);Ze.each(r,(u,h)=>{u.points=[{dx:e.coreBox.width/2,dy:r.length>1?c(h):0},{dx:u.dx-u.width/2,dy:u.dy}]}),e.height=Math.max(e.height,i,o)}function ble(e){switch(e.annotationType){case gi.CONSTANT:Ze.extend(e,Tr.constant.size);break;case gi.SHORTCUT:if(e.node.type===jt.OP)Ze.extend(e,Tr.shortcutSize.op);else if(e.node.type===jt.META)Ze.extend(e,Tr.shortcutSize.meta);else if(e.node.type===jt.SERIES)Ze.extend(e,Tr.shortcutSize.series);else throw Error("Invalid node type: "+e.node.type);break;case gi.SUMMARY:Ze.extend(e,Tr.constant.size);break}}function v0(e){if(e.expanded)return e.x;let t=e.inAnnotations.list.length?e.inboxWidth:0;return e.x-e.width/2+t+e.coreBox.width/2}function wle(e,t){let r=t.x-e.x,n=t.y-e.y;return 180*Math.atan(n/r)/Math.PI}function Dcr(e){let t=wle(e[0],e[1]);for(let r=1;r<e.length-1;r++){let n=wle(e[r],e[r+1]);if(Math.abs(n-t)>1)return!1;t=n}return!0}function Sle(e,t){let r=t.expanded?t.x:v0(t),n=t.y,i=e.x-r,o=e.y-n,a=t.expanded?t.width:t.coreBox.width,s=t.expanded?t.height:t.coreBox.height,l,c;return Math.abs(o)*a/2>Math.abs(i)*s/2?(o<0&&(s=-s),l=o===0?0:s/2*i/o,c=s/2):(i<0&&(a=-a),l=a/2,c=i===0?0:a/2*o/i),{x:r+l,y:n+c}}var Pl=m0,Hi=ve,Ocr=320,zcr=150,fP=[{background_color:"#CC2F2C",label:"NaN"},{background_color:"#FF8D00",label:"-\u221E"},{background_color:"#EAEAEA",label:"-"},{background_color:"#A5A5A5",label:"0"},{background_color:"#262626",label:"+"},{background_color:"#003ED4",label:"+\u221E"}];function Cle(e,t,r,n){let i=e.getBoundingClientRect(),o=null;try{if(o=t.getBBox(),(o==null?void 0:o.width)===0)return}catch(c){return}let a=.9*Math.min(i.width/(o==null?void 0:o.width),i.height/(o==null?void 0:o.height),2),s=Tr.graph,l=Xh.scale(a).translate(s.padding.paddingLeft,s.padding.paddingTop);Ht(e).transition().duration(500).call(r.transform,l).on("end.fitted",()=>{r.on("end.fitted",null),n()})}function Ale(e,t,r,n){let i=Ht(t).select(`[data-name="${e}"]`).node();if(!i)return console.warn(`panToNode() failed for node name "${e}"`),!1;let o=i.getBBox(),a=i.getScreenCTM(),s=t.createSVGPoint(),l=t.createSVGPoint();s.x=o.x,s.y=o.y,l.x=o.x+o.width,l.y=o.y+o.height,s=s.matrixTransform(a),l=l.matrixTransform(a);let c=(p,d,g,_)=>!(p>g&&d<_),u=t.getBoundingClientRect(),h=u.left+u.width-Ocr,f=u.top+u.height-zcr;if(c(s.x,l.x,u.left,h)||c(s.y,l.y,u.top,f)){let p=(s.x+l.x)/2,d=(s.y+l.y)/2,g=u.left+u.width/2-p,_=u.top+u.height/2-d,y=i2(t);return Ht(t).transition().duration(500).call(n.translateBy,g/y.k,_/y.k),!0}return!1}function Ple(e,t){let r=t.node.type===jt.SERIES?0:Tr.subscene.meta.labelHeight;a3(Pl(e,"g",Hi.Scene.CORE),0,r);let n=t.isolatedInExtract.length>0,i=t.isolatedOutExtract.length>0,o=t.libraryFunctionsExtract.length>0,a=Tr.subscene.meta.extractXOffset,s=0;if(n&&(s+=t.outExtractBox.width),i&&(s+=t.outExtractBox.width),n){let l=t.coreBox.width;s<o3?l=l-o3+t.inExtractBox.width/2:l=l-t.inExtractBox.width/2-t.outExtractBox.width-(i?a:0),l=l-t.libraryFunctionsBox.width-(o?a:0),a3(Pl(e,"g",Hi.Scene.INEXTRACT),l,r)}if(i){let l=t.coreBox.width;s<o3?l=l-o3+t.outExtractBox.width/2:l-=t.outExtractBox.width/2,l=l-t.libraryFunctionsBox.width-(o?a:0),a3(Pl(e,"g",Hi.Scene.OUTEXTRACT),l,r)}if(o){let l=t.coreBox.width-t.libraryFunctionsBox.width/2;a3(Pl(e,"g",Hi.Scene.FUNCTION_LIBRARY),l,r)}}function Ile(e,t){Ht(e).on("click",()=>{t.fire("graph-select")})}function a3(e,t,r){e.attr("transform")!=null&&(e=e.transition("position")),e.attr("transform","translate("+t+","+r+")")}function zd(e,t,r,n,i){e.transition().attr("x",t-n/2).attr("y",r-i/2).attr("width",n).attr("height",i)}function Lle(e,t,r,n,i){let o=i/2,a=n/2,s=[[t,r-o],[t+a,r+o],[t-a,r+o]];e.transition().attr("points",s.map(l=>l.join(",")).join(" "))}function kle(e,t){let r=v0(t),n=t.expanded?t.width:t.coreBox.width,i=t.expanded?t.height:t.coreBox.height,o=r+n/2-6,a=t.y-i/2+6;t.node.type===jt.SERIES&&!t.expanded&&(o+=10,a-=2);let s="translate("+o+","+a+")";e.selectAll("path").transition().attr("transform",s),e.select("circle").transition().attr({cx:o,cy:a,r:Tr.nodeSize.meta.expandButtonRadius})}function EH(e,t,r,n,i){e.transition().attr("cx",t).attr("cy",r).attr("rx",n/2).attr("ry",i/2)}function Tle(e,t){return t?e.toFixed(0):Math.abs(e)>=1?e.toFixed(1):e.toExponential(1)}function Fcr(e,t,r,n){let i="Device: "+e.device_name+`
`;i+="dtype: "+e.dtype+`
`;let o="(scalar)";e.shape.length>0&&(o="("+e.shape.join(",")+")"),i+=`
shape: `+o+`

`,i+="#(elements): "+t+`
`;let a=[];for(let s=0;s<r.length;s++)r[s]>0&&a.push("#("+fP[s].label+"): "+r[s]);return i+=a.join(", ")+`

`,n.max>=n.min&&(i+="min: "+n.min+", max: "+n.max+`
`,i+="mean: "+n.mean+", stddev: "+n.stddev),i}function Bcr(e,t,r,n,i=60,o=10,a=0,s){if(Ht(e.parentNode).selectAll(".health-pill").remove(),!t)return;let l=t.value,c=l.slice(2,8),u=c[0],h=c[1],f=c[5],p=l[1],d={min:l[8],max:l[9],mean:l[10],stddev:Math.sqrt(l[11])};i==null&&(i=60),o==null&&(o=10),a==null&&(a=0),r!=null&&r.node.type===jt.OP&&(i/=2,o/=2);let g=document.createElementNS(ju,"g");g.classList.add("health-pill");let _=document.createElementNS(ju,"defs");g.appendChild(_);let y=document.createElementNS(ju,"linearGradient"),x="health-pill-gradient-"+n;y.setAttribute("id",x);let b=0,S="0%";for(let D=0;D<c.length;D++){if(!c[D])continue;b+=c[D];let B=document.createElementNS(ju,"stop");B.setAttribute("offset",S),B.setAttribute("stop-color",fP[D].background_color),y.appendChild(B);let I=document.createElementNS(ju,"stop"),L=b*100/p+"%";I.setAttribute("offset",L),I.setAttribute("stop-color",fP[D].background_color),y.appendChild(I),S=L}_.appendChild(y);let C=document.createElementNS(ju,"rect");C.setAttribute("fill","url(#"+x+")"),C.setAttribute("width",String(i)),C.setAttribute("height",String(o)),C.setAttribute("y",String(a)),g.appendChild(C);let P=document.createElementNS(ju,"title");P.textContent=Fcr(t,p,c,d),g.appendChild(P);let k=!1;if(r!=null){let D=r.x-i/2,B=r.y-o-r.height/2-2;if(r.labelOffset<0&&(B+=r.labelOffset),g.setAttribute("transform","translate("+D+", "+B+")"),c[2]||c[3]||c[4]){let L=r.node.attr;if(L&&L.length){for(let R=0;R<L.length;R++)if(L[R].key==="T"){let F=L[R].value.type;k=F&&/^DT_(BOOL|INT|UINT)/.test(F);break}}}}let O=document.createElementNS(ju,"text");if(Number.isFinite(d.min)&&Number.isFinite(d.max)){let D=Tle(d.min,k),B=Tle(d.max,k);if(p>1?O.textContent=D+" ~ "+B:O.textContent=D,u>0||h>0||f>0){O.textContent+=" (";let I=[];u>0&&I.push(`NaN\xD7${u}`),h>0&&I.push(`-\u221E\xD7${h}`),f>0&&I.push(`+\u221E\xD7${f}`),O.textContent+=I.join("; ")+")"}}else O.textContent="(No finite elements)";O.classList.add("health-pill-stats"),s==null&&(s=i/2),O.setAttribute("x",String(s)),O.setAttribute("y",String(a-2)),g.appendChild(O),zt(e.parentNode).appendChild(g)}function Rle(e,t,r){if(!t)return;let n=1;Ht(e).selectAll("g.nodeshape").each(function(o){let a=t[o.node.name],s=a?a[r]:null;Bcr(this,s,o,n++)})}var qn;(function(e){e.NONE="none",e.COMPUTE_TIME="compute_time",e.DEVICE="device",e.MEMORY="memory",e.OP_COMPATIBILITY="op_compatibility",e.STRUCTURE="structure",e.XLA_CLUSTER="xla_cluster"})(qn||(qn={}));var mP=Ee(Oe(),1);var Vi=Ee(Oe(),1);function Hcr(e){let t=0,r=0,n=e;for(;n&&n.offsetLeft>=0&&n.offsetTop>=0;)t+=n.offsetLeft-n.scrollLeft,r+=n.offsetTop-n.scrollTop,n=n.offsetParent;return{left:t,top:r}}function Wlt(e,t){let r=e.getContextMenu(),n=Ht(e.getContextMenu());return function(i,o){let a=qt,s=Hcr(e);n.style("display","block").style("left",a.clientX-s.left+1+"px").style("top",a.clientY-s.top+1+"px"),a.preventDefault(),a.stopPropagation();function l(u){u&&u.composedPath().includes(r)||(n.style("display","none"),document.body.removeEventListener("mousedown",l,{capture:!0}))}document.body.addEventListener("mousedown",l,{capture:!0}),n.text(""),n.append("ul").selectAll("li").data(t).enter().append("li").on("click",(u,h)=>{u.action(this,i,o),l()}).text(function(u){return u.title(i)})}}var AH=Ee(Oe(),1);var Ucr="\xD7",Nle=qb().domain([Q4,tP]).range(["small","medium","large","xlarge"]),qcr=2.5;function pP(e){return e.v+ole+e.w}function zle(e,t,r){let n=r,i=[];i=AH.reduce(t.edges(),(s,l)=>{let c=t.edge(l);return s.push({v:l.v,w:l.w,label:c}),s},i);let a=An(e,"g",ve.Edge.CONTAINER).selectAll(function(){return this.childNodes}).data(i,pP);return a.enter().append("g").attr("class",ve.Edge.GROUP).attr("data-edge",pP).each(function(s){let l=Ht(this);s.label.edgeGroup=l,n._edgeGroupIndex[pP(s)]=l,n.handleEdgeSelected&&l.on("click",c=>{qt.stopPropagation(),n.fire("edge-select",{edgeData:c,edgeGroup:l})}),Xlt(l,s,n)}).merge(a).each(function(){Wcr(r,this)}).each(function(s){Ycr(Ht(this),s,n)}),a.exit().each(s=>{delete n._edgeGroupIndex[pP(s)]}).remove(),a}function Ylt(e,t){let r=t.getNodeByName(e.v);if(r.outputShapes==null||AH.isEmpty(r.outputShapes))return null;let n=r.outputShapes[e.outputTensorKey];return n==null?null:n.length===0?"scalar":n.map(i=>i===-1?"?":i).join(Ucr)}function jlt(e,t){return t.edgeLabelFunction?t.edgeLabelFunction(e,t):e.baseEdgeList.length>1?e.baseEdgeList.length+" tensors":Ylt(e.baseEdgeList[0],t)}function Dle(e,t,r){let n=document.createElementNS(ju,"path");for(let i=1;i<e.length;i++)if(n.setAttribute("d",r(e.slice(0,i))),n.getTotalLength()>t)return i-1;return e.length-1}function Ole(e,t,r){let n=vu().x(u=>u.x).y(u=>u.y),i=Ht(document.createElementNS("http://www.w3.org/2000/svg","path")).attr("d",n(e)),o=+t.attr("markerWidth"),a=t.attr("viewBox").split(" ").map(Number),s=a[2]-a[0],l=+t.attr("refX"),c=i.node();if(r){let u=1-l/s,h=o*u,f=c.getPointAtLength(h),p=Dle(e,h,n);return e[p-1]={x:f.x,y:f.y},e.slice(p-1)}else{let u=1-l/s,h=c.getTotalLength()-o*u,f=c.getPointAtLength(h),p=Dle(e,h,n);return e[p]={x:f.x,y:f.y},e.slice(0,p+1)}}function Xlt(e,t,r,n){n=n||ve.Edge.LINE,t.label&&t.label.structural&&(n+=" "+ve.Edge.STRUCTURAL),t.label&&t.label.metaedge&&t.label.metaedge.numRefEdges&&(n+=" "+ve.Edge.REFERENCE_EDGE),r.handleEdgeSelected&&(n+=" "+ve.Edge.SELECTABLE);let i="path_"+pP(t),o;if(r.renderHierarchy.edgeWidthFunction)o=r.renderHierarchy.edgeWidthFunction(t,n);else{let c=1;t.label!=null&&t.label.metaedge!=null&&(c=t.label.metaedge.totalSize),o=r.renderHierarchy.edgeWidthSizedBasedScale(c)}let a=e.append("path").attr("id",i).attr("class",n).style("stroke-width",o+"px");if(t.label&&t.label.metaedge)if(t.label.metaedge.numRefEdges){let c=`reference-arrowhead-${Nle(o)}`;a.style("marker-start",`url(#${c})`),t.label.startMarkerId=c}else{let c=`dataflow-arrowhead-${Nle(o)}`;a.style("marker-end",`url(#${c})`),t.label.endMarkerId=c}if(t.label==null||t.label.metaedge==null)return;let s=jlt(t.label.metaedge,r.renderHierarchy);if(s==null)return;let l=o>qcr?"central":"text-after-edge";e.append("text").append("textPath").attr("xlink:href","#"+i).attr("startOffset","50%").attr("text-anchor","middle").attr("dominant-baseline","central").text(s)}var CH=vu().curve(W8).x(e=>e.x).y(e=>e.y);function Gcr(e,t,r,n,i){let o=r.label,a=o.adjoiningMetaedge,s=o.points,{shadowRoot:l}=e;if(r.label.startMarkerId&&(s=Ole(s,Ht(l==null?void 0:l.querySelector("#"+r.label.startMarkerId)),!0)),r.label.endMarkerId&&(s=Ole(s,Ht(l==null?void 0:l.querySelector("#"+r.label.endMarkerId)),!1)),!a)return nc(i,CH(s));let c=a.edgeGroup.node().firstChild,u=o.metaedge.inbound;return function(h){var g;let f=c.getPointAtLength(u?c.getTotalLength():0).matrixTransform(c.getCTM()).matrixTransform((g=t.getCTM())==null?void 0:g.inverse()),p=u?0:s.length-1;return s[p].x=f.x,s[p].y=f.y,CH(s)}}function Wcr(e,t){Ht(t).select("path."+ve.Edge.LINE).transition().attrTween("d",function(r,n,i){return Gcr(e,this,r,n,i)})}function Ycr(e,t,r){e.classed("faded",t.label.isFadedOut);let n=t.label.metaedge;e.select("path."+ve.Edge.LINE).classed("control-dep",n&&!n.numRegularEdges)}function PH(e,t,r){let i=An(e,"g",ve.Node.CONTAINER).selectAll(function(){return this.childNodes}).data(t,o=>o.node.name+":"+o.node.type);return i.enter().append("g").attr("data-name",o=>o.node.name).each(function(o){let a=Ht(this);r.addNodeGroup(o.node.name,a)}).merge(i).attr("class",o=>ve.Node.GROUP+" "+Wle(o)).each(function(o){let a=Ht(this),s=An(a,"g",ve.Annotation.INBOX);Vle(s,o.inAnnotations,o,r);let l=An(a,"g",ve.Annotation.OUTBOX);Vle(l,o.outAnnotations,o,r);let c=Gle(a,o,ve.Node.SHAPE);o.node.isGroupNode&&Xcr(c,o,r),Hle(c,o,r),jcr(a,o,r);let u=Kcr(a,o,r);Hle(u,o,r,o.node.type===jt.META),s3(a,o,r),Jcr(a,o)}),i.exit().each(function(o){r.removeNodeGroup(o.node.name);let a=Ht(this);o.inAnnotations.list.length>0&&a.select("."+ve.Annotation.INBOX).selectAll("."+ve.Annotation.GROUP).each(s=>{r.removeAnnotationGroup(s,o)}),o.outAnnotations.list.length>0&&a.select("."+ve.Annotation.OUTBOX).selectAll("."+ve.Annotation.GROUP).each(s=>{r.removeAnnotationGroup(s,o)})}).remove(),i}function jcr(e,t,r){if(t.node.isGroupNode){if(t.expanded)return ect(e,t,r,ve.Subscene.GROUP);Pl(e,"g",ve.Subscene.GROUP).remove()}return null}function Ble(e,t){let r=t.x-t.width/2+t.paddingLeft,n=t.y-t.height/2+t.paddingTop,i=Pl(e,"g",ve.Subscene.GROUP);a3(i,r,n)}function Xcr(e,t,r){let n=An(e,"g",ve.Node.BUTTON_CONTAINER);An(n,"circle",ve.Node.BUTTON_CIRCLE),An(n,"path",ve.Node.EXPAND_BUTTON).attr("d","M0,-2.2 V2.2 M-2.2,0 H2.2"),An(n,"path",ve.Node.COLLAPSE_BUTTON).attr("d","M-2.2,0 H2.2"),n.on("click",i=>{qt.stopPropagation(),r.fire("node-toggle-expand",{name:i.node.name})}),kle(n,t)}function Hle(e,t,r,n){if(n){e.attr("pointer-events","none");return}let i=Wlt(r,Ule(t.node,r));e.on("dblclick",o=>{r.fire("node-toggle-expand",{name:o.node.name})}).on("mouseover",o=>{r.isNodeExpanded(o)||r.fire("node-highlight",{name:o.node.name})}).on("mouseout",o=>{r.isNodeExpanded(o)||r.fire("node-unhighlight",{name:o.node.name})}).on("click",o=>{qt.stopPropagation(),r.fire("node-select",{name:o.node.name})}).on("contextmenu",(o,a)=>{r.fire("node-select",{name:o.node.name}),i.call(o,a)})}function Ule(e,t){let r=[{title:n=>yH(e.include),action:(n,i,o)=>{t.fire("node-toggle-extract",{name:e.name})}}];return t.nodeContextMenuItems&&(r=r.concat(t.nodeContextMenuItems)),Jlt(e)&&r.push({title:n=>Qlt(e),action:(n,i,o)=>{t.fire("node-toggle-seriesgroup",{name:IH(e)})}}),r}function Jlt(e){return IH(e)!==null}function IH(e){return e?e.type===jt.SERIES?e.name:e.type===jt.OP?e.owningSeries:null:null}function $cr(e){let t=null;if(e)e.type===jt.SERIES?t=e:e.parentNode&&e.parentNode.type===jt.SERIES&&(t=e.parentNode);else return null;return t}function Qlt(e){return ule($cr(e)!==null?is.GROUP:is.UNGROUP)}function Kcr(e,t,r){var c;let n=t.displayName,i=t.node.type===jt.META&&!t.expanded,o=An(e,"text",ve.Node.LABEL),a=o.node();(c=a.parentNode)==null||c.appendChild(a),o.attr("dy",".35em").attr("text-anchor","middle");let s=8;switch(t.node.type){case jt.META:s=t.expanded?J4.Node.EXPANDED_LABEL:J4.Node.SERIES_LABEL;break;case jt.OP:s=J4.Node.OP_LABEL;break}if(i){n.length>r.maxMetanodeLabelLength&&(n=n.substr(0,r.maxMetanodeLabelLength-2)+"\u2026");let u=Zcr(r);o.attr("font-size",u(n.length)+"px"),s=u(n.length)}let l=o.text(n);return qle(l,t.node.type,s,t),o}function qle(e,t,r,n){let i=e.node(),o=i.textContent,a=null;switch(t){case jt.META:n&&!n.expanded&&(a=Tr.nodeSize.meta.maxLabelWidth);break;case jt.OP:a=Tr.nodeSize.op.maxLabelWidth;break;case-1:a=Tr.annotations.maxLabelWidth;break;default:break}if(a!==null)return i.textContent=tle(i.textContent,r,a),e.append("title").text(o)}var $lt=null;function Zcr(e){return $lt||($lt=On().domain([e.maxMetanodeLabelLengthLargeFont,e.maxMetanodeLabelLength]).range([e.maxMetanodeLabelLengthFontSize,e.minMetanodeLabelLengthFontSize]).clamp(!0)),$lt}function dP(e,t,r,n){Pl(e,"text",ve.Node.LABEL).transition().attr("x",t).attr("y",r+n)}function Gle(e,t,r){let n=An(e,"g",r);switch(t.node.type){case jt.OP:let i=t.node;if(Vi.isNumber(i.functionInputIndex)||Vi.isNumber(i.functionOutputIndex)){An(n,"polygon",ve.Node.COLOR_TARGET);break}An(n,"ellipse",ve.Node.COLOR_TARGET);break;case jt.SERIES:let o="annotation",a=t;a.coreGraph&&(o=a.node.hasNonControlEdges?"vertical":"horizontal");let s=[ve.Node.COLOR_TARGET];a.isFadedOut&&s.push("faded-ellipse"),An(n,"use",s).attr("xlink:href","#op-series-"+o+"-stamp"),An(n,"rect",ve.Node.COLOR_TARGET).attr("rx",t.radius).attr("ry",t.radius);break;case jt.BRIDGE:An(n,"rect",ve.Node.COLOR_TARGET).attr("rx",t.radius).attr("ry",t.radius);break;case jt.META:An(n,"rect",ve.Node.COLOR_TARGET).attr("rx",t.radius).attr("ry",t.radius);break;default:throw Error("Unrecognized node type: "+t.node.type)}return n}function Wle(e){switch(e.node.type){case jt.OP:return ve.OPNODE;case jt.META:return ve.METANODE;case jt.SERIES:return ve.SERIESNODE;case jt.BRIDGE:return ve.BRIDGENODE;case jt.ELLIPSIS:return ve.ELLIPSISNODE}throw Error("Unrecognized node type: "+e.node.type)}function Jcr(e,t){let r=Pl(e,"g",ve.Node.SHAPE),n=v0(t);switch(t.node.type){case jt.OP:{let i=t.node;if(Vi.isNumber(i.functionInputIndex)||Vi.isNumber(i.functionOutputIndex)){let o=Pl(r,"polygon");Lle(o,t.x,t.y,t.coreBox.width,t.coreBox.height)}else{let o=Pl(r,"ellipse");EH(o,n,t.y,t.coreBox.width,t.coreBox.height)}dP(e,n,t.y,t.labelOffset);break}case jt.META:{let i=r.selectAll("rect");t.expanded?(zd(i,t.x,t.y,t.width,t.height),Ble(e,t),dP(e,n,t.y,-t.height/2+t.labelHeight/2)):(zd(i,n,t.y,t.coreBox.width,t.coreBox.height),dP(e,n,t.y,0));break}case jt.SERIES:{let i=Pl(r,"use");t.expanded?(zd(i,t.x,t.y,t.width,t.height),Ble(e,t),dP(e,n,t.y,-t.height/2+t.labelHeight/2)):(zd(i,n,t.y,t.coreBox.width,t.coreBox.height),dP(e,n,t.y,t.labelOffset));break}case jt.BRIDGE:{let i=Pl(r,"rect");zd(i,t.x,t.y,t.width,t.height);break}default:throw Error("Unrecognized node type: "+t.node.type)}}function Klt(e,t,r){let n=Jse(e);if(!r)return`url(#${n})`;let i=Ht(r),o=i.select("defs#_graph-gradients");o.empty()&&(o=i.append("defs").attr("id","_graph-gradients"));let a=o.select("linearGradient#"+n);if(a.empty()){a=o.append("linearGradient").attr("id",e),a.selectAll("*").remove();let s=0;Vi.each(t,l=>{let c=l.color;a.append("stop").attr("offset",s).attr("stop-color",c),a.append("stop").attr("offset",s+l.proportion).attr("stop-color",c),s+=l.proportion})}return`url(#${n})`}function LH(e){Ht(e).select("defs#_graph-gradients").remove()}function kH(e,t,r,n,i){let o=Ku;switch(e=e||(()=>0),t){case qn.NONE:case qn.STRUCTURE:if(r.node.type===jt.META){let a=r.node.templateId;return t===qn.STRUCTURE&&a!==null?o.STRUCTURE_PALETTE(e(a),n):o.UNKNOWN}else return r.node.type===jt.SERIES?n?o.EXPANDED_COLOR:"white":r.node.type===jt.BRIDGE?r.structural?"#f0e":r.node.inbound?"#0ef":"#fe0":Vi.isNumber(r.node.functionInputIndex)?"#795548":Vi.isNumber(r.node.functionOutputIndex)?"#009688":"white";case qn.DEVICE:return r.deviceColors==null?o.UNKNOWN:n?o.EXPANDED_COLOR:Klt("device-"+r.node.name,r.deviceColors,i);case qn.XLA_CLUSTER:return r.xlaClusterColors==null?o.UNKNOWN:n?o.EXPANDED_COLOR:Klt("xla-"+r.node.name,r.xlaClusterColors,i);case qn.COMPUTE_TIME:return n?o.EXPANDED_COLOR:r.computeTimeColor||o.UNKNOWN;case qn.MEMORY:return n?o.EXPANDED_COLOR:r.memoryColor||o.UNKNOWN;case qn.OP_COMPATIBILITY:return r.compatibilityColors==null?o.UNKNOWN:n?o.EXPANDED_COLOR:Klt("op-compat-"+r.node.name,r.compatibilityColors,i);default:throw new Error("Unknown case to color nodes by")}}function s3(e,t,r,n){n=n||ve.Node.SHAPE;let i=r.isNodeHighlighted(t.node.name),o=r.isNodeSelected(t.node.name),a=t.isInExtract||t.isOutExtract||t.isLibraryFunction,s=t.expanded&&n!==ve.Annotation.NODE,l=t.isFadedOut;e.classed("highlighted",i),e.classed("selected",o),e.classed("extract",a),e.classed("expanded",s),e.classed("faded",l);let c=e.select("."+n+" ."+ve.Node.COLOR_TARGET),u=kH(r.templateIndex,r.colorBy,t,s,r.getGraphSvgRoot());c.style("fill",u),c.style("stroke",o?null:tct(u))}function tct(e){return e.substring(0,3)==="url"?Ku.GRADIENT_OUTLINE:cu(e).darker().toString()}function Yle(e,t,r,n){let i=Ht(e);if(i.selectAll(".input-highlight").classed("input-highlight",!1),i.selectAll(".non-input").classed("non-input",!1),i.selectAll(".input-parent").classed("input-parent",!1),i.selectAll(".input-child").classed("input-child",!1),i.selectAll(".input-edge-highlight").classed("input-edge-highlight",!1),i.selectAll(".non-input-edge-highlight").classed("non-input-edge-highlight",!1),i.selectAll(".input-highlight-selected").classed("input-highlight-selected",!1),!t||!n||!r)return;let o=jle(r,t),a={};Vi.each(o,function(c){a=Xle(e,t,c,a)});let s=Object.keys(a),l=tur(t,s);eur(e,l),i.selectAll("g.node:not(.selected):not(.input-highlight):not(.input-parent):not(.input-children)").classed("non-input",!0).each(function(c){let u=c.node.name;i.selectAll(`[data-name="${u}"]`).classed("non-input",!0)}),i.selectAll("g.edge:not(.input-edge-highlight)").classed("non-input-edge-highlight",!0)}function jle(e,t){let r=[],n=t.getNodeByName(e);if(n instanceof _0)return[n].concat(n.inEmbeddings);let i=n.metagraph.nodes();return Vi.each(i,function(o){r=r.concat(jle(o,t))}),r}function Xle(e,t,r,n){if(n[r.name])return n;n[r.name]=!0;let i=r.inputs,o=Zlt(t,r);Ht(e).select(`.node[data-name="${o.name}"]`).classed("input-highlight",!0);let a={};Vi.each(i,function(u){let h=t.getNodeByName(u.name);if(h===void 0)return;if(h instanceof aP){let d=sP(h.name);h=t.getNodeByName(d)}let f=Zlt(t,h),p=a[f.name];p?p.opNodes.push(h):a[f.name]={visibleParent:f,opNodes:[h]}});let s={},l=[o];s[o.name]={traced:!1,index:0,connectionEndpoints:[]};let c=o;for(let u=1;c.name!==qc;u++)c=c.parentNode,s[c.name]={traced:!1,index:u,connectionEndpoints:[]},l[u]=c;return Vi.forOwn(a,function(u,h){let f=u.visibleParent;Vi.each(u.opNodes,function(p){n=Xle(e,t,p,n)}),f.name!==o.name&&Qcr(e,f,s,l)}),n}function Qcr(e,t,r,n){let i=t,o=t,a=[];for(;!r[i.name];)o.name!==i.name&&a.push([o,i]),o=i,i=i.parentNode;let s=r[i.name].index,l=n[Math.max(s-1,0)].name,c=l,u=o.name,h=o.name,f=Ht(e);f.selectAll(`[data-edge="${h}--${l}"]`).classed("input-edge-highlight",!0),Vi.each(a,function(p){let d=p[0],g=p[1],_=`[data-edge="${d.name}--${c}~~${g.name}~~OUT"]`;f.selectAll(_).classed("input-edge-highlight",!0)});for(let p=1;p<s;p++){let d=n[p-1],g=n[p],_=`[data-edge="${u}~~${g.name}~~IN--${d.name}"]`;f.selectAll(_).classed("input-edge-highlight",!0)}}function tur(e,t){let r={};return Vi.each(t,function(n){let i=e.getNodeByName(n),o=Zlt(e,i);r[o.name]=o}),r}function eur(e,t){Vi.forOwn(t,function(r){let n=r;for(;n.name!==qc;){let i=Ht(e).select(`.node[data-name="${n.name}"]`);i.nodes().length&&!i.classed("input-highlight")&&!i.classed("selected")&&!i.classed("op")&&i.classed("input-parent",!0),n=n.parentNode}})}function Zlt(e,t){let r=!1,n=t;for(;!r;)if(t=n,n=t.parentNode,n===void 0)r=!0;else{let i=e.getRenderNodeByName(n.name);i&&(i.expanded||n instanceof _0)&&(r=!0)}return t}function Vle(e,t,r,n){let i=e.selectAll(function(){return this.childNodes}).data(t.list,o=>o.node.name);return i.enter().append("g").attr("data-name",o=>o.node.name).each(function(o){let a=Ht(this);n.addAnnotationGroup(o,r,a);let s=ve.Annotation.EDGE,l=o.renderMetaedgeInfo&&o.renderMetaedgeInfo.metaedge;l&&!l.numRegularEdges&&(s+=" "+ve.Annotation.CONTROL_EDGE),l&&l.numRefEdges&&(s+=" "+ve.Edge.REF_LINE),Xlt(a,o,n,s),o.annotationType!==gi.ELLIPSIS?(iur(a,o),nur(a,o)):$le(a,o.node.name,o,ve.Annotation.ELLIPSIS)}).merge(i).attr("class",o=>ve.Annotation.GROUP+" "+rur(o.annotationType)+" "+Wle(o)).each(function(o){let a=Ht(this);aur(a,r,o,n),o.annotationType!==gi.ELLIPSIS&&our(a,r,o,n)}),i.exit().each(function(o){n.removeAnnotationGroup(o,r)}).remove(),i}function rur(e){return(gi[e]||"").toLowerCase()||null}function nur(e,t){if(t.annotationType===gi.SUMMARY)An(e,"use").attr("class","summary").attr("xlink:href","#summary-icon").attr("cursor","pointer");else{let r=Gle(e,t,ve.Annotation.NODE);An(r,"title").text(t.node.name)}}function iur(e,t){let r=t.node.name.split("/"),n=r[r.length-1];return $le(e,n,t,null)}function $le(e,t,r,n){let i=ve.Annotation.LABEL;n&&(i+=" "+n);let o=e.append("text").attr("class",i).attr("dy",".35em").attr("text-anchor",r.isIn?"end":"start").text(t);return qle(o,-1,J4.Annotation.LABEL)}function our(e,t,r,n){e.on("mouseover",i=>{n.fire("annotation-highlight",{name:i.node.name,hostName:t.node.name})}).on("mouseout",i=>{n.fire("annotation-unhighlight",{name:i.node.name,hostName:t.node.name})}).on("click",i=>{qt.stopPropagation(),n.fire("annotation-select",{name:i.node.name,hostName:t.node.name})}),r.annotationType!==gi.SUMMARY&&r.annotationType!==gi.CONSTANT&&e.on("contextmenu",Wlt(n,Ule(r.node,n)))}function aur(e,t,r,n){let i=v0(t);r.renderNodeInfo&&r.annotationType!==gi.ELLIPSIS&&s3(e,r.renderNodeInfo,n,ve.Annotation.NODE),r.annotationType===gi.SUMMARY&&(r.width+=10),e.select("text."+ve.Annotation.LABEL).transition().attr("x",i+r.dx+(r.isIn?-1:1)*(r.width/2+r.labelOffset)).attr("y",t.y+r.dy),e.select("use.summary").transition().attr("x",i+r.dx-3).attr("y",t.y+r.dy-6),EH(e.select("."+ve.Annotation.NODE+" ellipse"),i+r.dx,t.y+r.dy,r.width,r.height),zd(e.select("."+ve.Annotation.NODE+" rect"),i+r.dx,t.y+r.dy,r.width,r.height),zd(e.select("."+ve.Annotation.NODE+" use"),i+r.dx,t.y+r.dy,r.width,r.height),e.select("path."+ve.Annotation.EDGE).transition().attr("d",o=>{let a=o.points.map(s=>({x:s.dx+i,y:s.dy+t.y}));return CH(a)})}function ect(e,t,r,n){n=n||ve.Scene.GROUP;let i=m0(e,"g",n).empty(),o=An(e,"g",n),a=An(o,"g",ve.Scene.CORE),s=Vi.reduce(t.coreGraph.nodes(),(l,c)=>{let u=t.coreGraph.node(c);return u.excluded||l.push(u),l},Array());if(t.node.type===jt.SERIES&&s.reverse(),zle(a,t.coreGraph,r),PH(a,s,r),t.isolatedInExtract.length>0){let l=An(o,"g",ve.Scene.INEXTRACT);PH(l,t.isolatedInExtract,r)}else m0(o,"g",ve.Scene.INEXTRACT).remove();if(t.isolatedOutExtract.length>0){let l=An(o,"g",ve.Scene.OUTEXTRACT);PH(l,t.isolatedOutExtract,r)}else m0(o,"g",ve.Scene.OUTEXTRACT).remove();if(t.libraryFunctionsExtract.length>0){let l=An(o,"g",ve.Scene.FUNCTION_LIBRARY);PH(l,t.libraryFunctionsExtract,r)}else m0(o,"g",ve.Scene.FUNCTION_LIBRARY).remove();return Ple(o,t),i&&o.attr("opacity",0).transition().attr("opacity",1),o}var sur=.8,RH=class{constructor(t,r,n,i,o,a){this.svg=t,this.labelPadding=a,this.zoomG=r,this.mainZoom=n,this.maxWandH=o;let s=Ht(i.shadowRoot),l=s.select("svg"),c=l.select("rect"),u=f=>{this.viewpointCoord.x=qt.x,this.viewpointCoord.y=qt.y,this.updateViewpoint()};this.viewpointCoord={x:0,y:0};let h=pb().subject(Object).on("drag",u);c.datum(this.viewpointCoord).call(h),l.on("click",()=>{if(qt.defaultPrevented)return;let f=Number(c.attr("width")),p=Number(c.attr("height")),d=zo(l.node());this.viewpointCoord.x=d[0]-f/2,this.viewpointCoord.y=d[1]-p/2,this.updateViewpoint()}),this.viewpoint=c.node(),this.minimapSvg=l.node(),this.minimap=i,this.canvas=s.select("canvas.first").node(),this.canvasBuffer=s.select("canvas.second").node(),this.downloadCanvas=s.select("canvas.download").node(),Ht(this.downloadCanvas).style("display","none"),this.update()}updateViewpoint(){Ht(this.viewpoint).attr("x",this.viewpointCoord.x).attr("y",this.viewpointCoord.y);let t=-this.viewpointCoord.x*this.scaleMain/this.scaleMinimap,r=-this.viewpointCoord.y*this.scaleMain/this.scaleMinimap;Ht(this.svg).call(this.mainZoom.transform,Xh.translate(t,r).scale(this.scaleMain))}getImageBlob(){return new Promise(t=>{this.downloadCanvas.toBlob(r=>{t(r)},"image/png")})}update(){let t=null;try{if(t=this.zoomG.getBBox(),t.width===0)return}catch(p){return}let r=Ht(this.svg),n="",i=this.svg,a=(i.getRootNode?i.getRootNode():this.svg.parentNode).styleSheets;for(let p=0;p<a.length;p++)try{let d=a[p].cssRules||a[p].rules;if(d==null)continue;for(let g=0;g<d.length;g++)n+=d[g].cssText.replace(/ ?tf-[\w-]+ ?/g,"")+`
`}catch(d){if(d.name!=="SecurityError")throw d}let s=r.append("style");s.text(n);let l=Ht(this.zoomG),c=l.attr("transform");l.attr("transform",null),t.height+=t.y,t.width+=t.x,t.height+=this.labelPadding*2,t.width+=this.labelPadding*2,r.attr("width",t.width).attr("height",t.height),this.scaleMinimap=this.maxWandH/Math.max(t.width,t.height),this.minimapSize={width:t.width*this.scaleMinimap,height:t.height*this.scaleMinimap},Ht(this.minimapSvg).attr(this.minimapSize),Ht(this.canvasBuffer).attr(this.minimapSize);let u=Ht(this.downloadCanvas);u.style("width",t.width),u.style("height",t.height),u.attr("width",3*t.width),u.attr("height",3*t.height),this.translate!=null&&this.zoom!=null&&requestAnimationFrame(()=>this.zoom());let h=new XMLSerializer().serializeToString(this.svg);s.remove(),r.attr("width",null).attr("height",null),l.attr("transform",c);let f=new Image;f.onload=()=>{let p=this.canvasBuffer.getContext("2d");p==null||p.clearRect(0,0,this.canvasBuffer.width,this.canvasBuffer.height),p==null||p.drawImage(f,0,0,this.minimapSize.width,this.minimapSize.height),requestAnimationFrame(()=>{Ht(this.canvasBuffer).style("display",null),Ht(this.canvas).style("display","none"),[this.canvas,this.canvasBuffer]=[this.canvasBuffer,this.canvas]});let d=this.downloadCanvas.getContext("2d");d==null||d.clearRect(0,0,this.downloadCanvas.width,this.downloadCanvas.height),d==null||d.drawImage(f,0,0,this.downloadCanvas.width,this.downloadCanvas.height)},f.onerror=()=>{let p=new Blob([h],{type:"image/svg+xml;charset=utf-8"});f.src=URL.createObjectURL(p)},f.src="data:image/svg+xml;charset=utf-8,"+encodeURIComponent(h)}zoom(t){if(this.scaleMinimap==null)return;t&&(this.translate=[t.x,t.y],this.scaleMain=t.k);let r=this.svg.getBoundingClientRect(),n=Ht(this.viewpoint);this.viewpointCoord.x=-this.translate[0]*this.scaleMinimap/this.scaleMain,this.viewpointCoord.y=-this.translate[1]*this.scaleMinimap/this.scaleMain;let i=r.width*this.scaleMinimap/this.scaleMain,o=r.height*this.scaleMinimap/this.scaleMain;n.attr("x",this.viewpointCoord.x).attr("y",this.viewpointCoord.y).attr("width",i).attr("height",o);let a=this.minimapSize.width,s=this.minimapSize.height,l=this.viewpointCoord.x,c=this.viewpointCoord.y,u=Math.min(Math.max(0,l+i),a)-Math.min(Math.max(0,l),a),h=Math.min(Math.max(0,c+o),s)-Math.min(Math.max(0,c),s);u*h/(a*s)<sur?this.minimap.classList.remove("hidden"):this.minimap.classList.add("hidden")}};var nct=class extends mt{init(t,r,n,i,o){return new RH(t,r,n,this,i,o)}};nct.template=Q`
    <style>
      :host {
        background-color: white;
        transition: opacity 0.3s linear;
        pointer-events: auto;
      }

      :host(.hidden) {
        opacity: 0;
        pointer-events: none;
      }

      canvas {
        border: 1px solid #999;
      }

      rect {
        fill: white;
        stroke: #111111;
        stroke-width: 1px;
        fill-opacity: 0;
        filter: url(#minimapDropShadow);
        cursor: move;
      }

      svg {
        position: absolute;
      }
    </style>
    <svg>
      <defs>
        <filter
          id="minimapDropShadow"
          x="-20%"
          y="-20%"
          width="150%"
          height="150%"
        >
          <feOffset result="offOut" in="SourceGraphic" dx="1" dy="1"></feOffset>
          <feColorMatrix
            result="matrixOut"
            in="offOut"
            type="matrix"
            values="0.1 0 0 0 0 0 0.1 0 0 0 0 0 0.1 0 0 0 0 0 0.5 0"
          ></feColorMatrix>
          <feGaussianBlur
            result="blurOut"
            in="matrixOut"
            stdDeviation="2"
          ></feGaussianBlur>
          <feBlend in="SourceGraphic" in2="blurOut" mode="normal"></feBlend>
        </filter>
      </defs>
      <rect></rect>
    </svg>
    <canvas class="first"></canvas>
    <!-- Additional canvas to use as buffer to avoid flickering between updates -->
    <canvas class="second"></canvas>
    <canvas class="download"></canvas>
  `;nct=E([yt("tf-graph-minimap")],nct);var Kle=Q`
  <style>
    :host(.dark-mode) {
      filter: invert(1);
    }

    :host {
      display: flex;
      font-size: 20px;
      height: 100%;
      width: 100%;
    }

    #svg {
      flex: 1;
      font-family: Roboto, sans-serif;
      height: 100%;
      overflow: hidden;
      width: 100%;
    }

    #hidden {
      position: fixed;
      top: 0px;
      visibility: hidden;
    }

    text {
      user-select: none;
    }

    /* --- Node and annotation-node for Metanode --- */

    .meta > .nodeshape > rect,
    .meta > .annotation-node > rect {
      cursor: pointer;
      fill: hsl(0, 0%, 70%);
    }
    .node.meta.highlighted > .nodeshape > rect,
    .node.meta.highlighted > .annotation-node > rect {
      stroke-width: 2;
    }
    .annotation.meta.highlighted > .nodeshape > rect,
    .annotation.meta.highlighted > .annotation-node > rect {
      stroke-width: 1;
    }
    .meta.selected > .nodeshape > rect,
    .meta.selected > .annotation-node > rect {
      stroke: red;
      stroke-width: 2;
    }
    .node.meta.selected.expanded > .nodeshape > rect,
    .node.meta.selected.expanded > .annotation-node > rect {
      stroke: red;
      stroke-width: 3;
    }
    .annotation.meta.selected > .nodeshape > rect,
    .annotation.meta.selected > .annotation-node > rect {
      stroke: red;
      stroke-width: 2;
    }
    .node.meta.selected.expanded.highlighted > .nodeshape > rect,
    .node.meta.selected.expanded.highlighted > .annotation-node > rect {
      stroke: red;
      stroke-width: 4;
    }

    .faded,
    .faded rect,
    .faded ellipse,
    .faded path,
    .faded use,
    #rectHatch line,
    #ellipseHatch line {
      color: #e0d4b3 !important;
      fill: white;
      stroke: #e0d4b3 !important;
    }

    .faded path {
      stroke-width: 1px !important;
    }

    .faded rect {
      fill: url(#rectHatch) !important;
    }

    .faded ellipse,
    .faded use {
      fill: url(#ellipseHatch) !important;
    }

    .faded text {
      opacity: 0;
    }

    /* Rules used for input-tracing. */
    .input-highlight > * > rect,
    .input-highlight > * > ellipse,
    .input-highlight > * > use {
      fill: white;
      stroke: #ff9800 !important;
    }

    /*  - Faded non-input styling */
    .non-input > * > rect,
.non-input > * > ellipse,
.non-input > * > use,
/* For Const nodes. */
.non-input > * > .constant:not([class*="input-highlight"]) >
  .annotation-node > ellipse,
/* For styling of annotation nodes of non-input nodes. */
.non-input > g > .annotation > .annotation-node > rect {
      stroke: #e0d4b3 !important;
      stroke-width: inherit;
      stroke-dasharray: inherit;
    }

    .non-input path {
      visibility: hidden;
    }

    .non-input > .nodeshape > rect,
.non-input > .annotation-node > rect,
/* For styling of annotation nodes of non-input nodes. */
.non-input > g > .annotation > .annotation-node > rect {
      fill: url(#rectHatch) !important;
    }

    .non-input ellipse,
    .non-input use {
      fill: url(#ellipseHatch) !important;
    }

    .non-input > text {
      opacity: 0;
    }

    .non-input .annotation > .annotation-edge {
      marker-end: url(#annotation-arrowhead-faded);
    }

    .non-input .annotation > .annotation-edge.refline {
      marker-start: url(#ref-annotation-arrowhead-faded);
    }

    /* Input edges. */
    .input-edge-highlight > text {
      fill: black !important;
    }
    .input-highlight > .in-annotations > .annotation > .annotation-edge,
    .input-highlight-selected
      > .in-annotations
      > .annotation
      > .annotation-edge {
      stroke: #999 !important;
    }

    /* Non-input edges. */
    .non-input-edge-highlight,
.non-input > g > .annotation > path,
/* Annotation styles (label and edges respectively). */
.non-input > g >
.annotation:not(.input-highlight):not(.input-highlight-selected) >
.annotation-label
/*.annotation-edge*/ {
      visibility: hidden;
    }

    /* --- Op Node --- */

    .op > .nodeshape > .nodecolortarget,
    .op > .annotation-node > .nodecolortarget {
      cursor: pointer;
      fill: #fff;
      stroke: #ccc;
    }

    .op.selected > .nodeshape > .nodecolortarget,
    .op.selected > .annotation-node > .nodecolortarget {
      stroke: red;
      stroke-width: 2;
    }

    .op.highlighted > .nodeshape > .nodecolortarget,
    .op.highlighted > .annotation-node > .nodecolortarget {
      stroke-width: 2;
    }

    /* --- Series Node --- */

    /* By default, don't show the series background <rect>. */
    .series > .nodeshape > rect {
      fill: hsl(0, 0%, 70%);
      fill-opacity: 0;
      stroke-dasharray: 5, 5;
      stroke-opacity: 0;
      cursor: pointer;
    }

    /* Once expanded, show the series background <rect> and hide the <use>. */
    .series.expanded > .nodeshape > rect {
      fill-opacity: 0.15;
      stroke: hsl(0, 0%, 70%);
      stroke-opacity: 1;
    }
    .series.expanded > .nodeshape > use {
      visibility: hidden;
    }

    /**
 * TODO: Simplify this by applying a stable class name to all <g>
 * elements that currently have either the nodeshape or annotation-node classes.
 */
    .series > .nodeshape > use,
    .series > .annotation-node > use {
      stroke: #ccc;
    }
    .series.highlighted > .nodeshape > use,
    .series.highlighted > .annotation-node > use {
      stroke-width: 2;
    }
    .series.selected > .nodeshape > use,
    .series.selected > .annotation-node > use {
      stroke: red;
      stroke-width: 2;
    }

    .series.selected > .nodeshape > rect {
      stroke: red;
      stroke-width: 2;
    }

    .annotation.series.selected > .annotation-node > use {
      stroke: red;
      stroke-width: 2;
    }

    /* --- Bridge Node --- */
    .bridge > .nodeshape > rect {
      stroke: #f0f;
      opacity: 0.2;
      display: none;
    }

    /* --- Structural Elements --- */
    .edge > path.edgeline.structural {
      stroke: #f0f;
      opacity: 0.2;
      display: none;
    }

    /* Reference Edge */
    .edge > path.edgeline.referenceedge {
      stroke: #ffb74d;
      opacity: 1;
    }

    /* --- Series Nodes --- */

    /* Hide the rect for a series' annotation. */
    .series > .annotation-node > rect {
      display: none;
    }

    /* --- Node label --- */

    .node {
      /* Provide a hint to browsers to avoid using their static rasterization
      at initial scale, which looks very pixelated on Chromium when zoomed in.
      Note that we intentionally do *not* use 'will-change: transform' and
      'translateZ(0) here, which introduce blurriness on Firefox.
      See https://github.com/tensorflow/tensorboard/issues/4744 */
      transform: translateZ(1px);
    }

    .node > text.nodelabel {
      cursor: pointer;
      fill: #444;
    }

    .meta.expanded > text.nodelabel {
      font-size: 9px;
    }

    .series > text.nodelabel {
      font-size: 8px;
    }

    .op > text.nodelabel {
      font-size: 6px;
    }

    .bridge > text.nodelabel {
      display: none;
    }

    .node.meta.expanded > text.nodelabel {
      cursor: normal;
    }

    .annotation.meta.highlighted > text.annotation-label {
      fill: #50a3f7;
    }

    .annotation.meta.selected > text.annotation-label {
      fill: #4285f4;
    }

    /* --- Annotation --- */

    /* only applied for annotations that are not summary or constant.
(.summary, .constant gets overridden below) */
    .annotation > .annotation-node > * {
      stroke-width: 0.5;
      stroke-dasharray: 1, 1;
    }

    .annotation.summary > .annotation-node > *,
    .annotation.constant > .annotation-node > * {
      stroke-width: 1;
      stroke-dasharray: none;
    }

    .annotation > .annotation-edge {
      fill: none;
      stroke: #aaa;
      stroke-width: 0.5;
      marker-end: url(#annotation-arrowhead);
    }

    .faded .annotation > .annotation-edge {
      marker-end: url(#annotation-arrowhead-faded);
    }

    .annotation > .annotation-edge.refline {
      marker-start: url(#ref-annotation-arrowhead);
    }

    .faded .annotation > .annotation-edge.refline {
      marker-start: url(#ref-annotation-arrowhead-faded);
    }

    .annotation > .annotation-control-edge {
      stroke-dasharray: 1, 1;
    }

    #annotation-arrowhead {
      fill: #aaa;
    }

    #annotation-arrowhead-faded {
      fill: #e0d4b3;
    }

    #ref-annotation-arrowhead {
      fill: #aaa;
    }

    #ref-annotation-arrowhead-faded {
      fill: #e0d4b3;
    }

    .annotation > .annotation-label {
      font-size: 5px;
      cursor: pointer;
    }
    .annotation > .annotation-label.annotation-ellipsis {
      cursor: default;
    }

    /* Hide annotations on expanded meta nodes since they're redundant. */
    .expanded > .in-annotations,
    .expanded > .out-annotations {
      display: none;
    }

    /* --- Annotation: Constant --- */

    .constant > .annotation-node > ellipse {
      cursor: pointer;
      fill: white;
      stroke: #848484;
    }

    .constant.selected > .annotation-node > ellipse {
      fill: white;
      stroke: red;
    }

    .constant.highlighted > .annotation-node > ellipse {
      stroke-width: 1.5;
    }

    /* --- Annotation: Summary --- */

    .summary > .annotation-node > ellipse {
      cursor: pointer;
      fill: #db4437;
      stroke: #db4437;
    }

    .summary.selected > .annotation-node > ellipse {
      fill: #a52714;
      stroke: #a52714;
    }

    .summary.highlighted > .annotation-node > ellipse {
      stroke-width: 1.5;
    }

    /* --- Edge --- */

    .edge > path.edgeline {
      fill: none;
      stroke: #bbb;
      stroke-linecap: round;
      stroke-width: 0.75;
    }

    .edge .selectableedge {
      cursor: pointer;
    }

    .selectededge > path.edgeline {
      cursor: default;
      stroke: #f00;
    }

    .edge.selectededge text {
      fill: #000;
    }

    /* Labels showing tensor shapes on edges */
    .edge > text {
      font-size: 3.5px;
      fill: #666;
    }

    .dataflow-arrowhead {
      fill: #bbb;
    }

    .reference-arrowhead {
      fill: #ffb74d;
    }

    .selected-arrowhead {
      fill: #f00;
    }

    .edge .control-dep {
      stroke-dasharray: 2, 2;
    }

    /* --- Group node expand/collapse button --- */

    /* Hides expand/collapse buttons when a node isn't expanded or highlighted. Using
   incredibly small opacity so that the bounding box of the <g> parent still takes
   this container into account even when it isn't visible */
    .node:not(.highlighted):not(.expanded) > .nodeshape > .buttoncontainer {
      opacity: 0.01;
    }
    .node.highlighted > .nodeshape > .buttoncontainer {
      cursor: pointer;
    }
    .buttoncircle {
      fill: #e7811d;
    }
    .buttoncircle:hover {
      fill: #b96717;
    }
    .expandbutton,
    .collapsebutton {
      stroke: white;
    }
    /* Do not let the path elements in the button take pointer focus */
    .node > .nodeshape > .buttoncontainer > .expandbutton,
    .node > .nodeshape > .buttoncontainer > .collapsebutton {
      pointer-events: none;
    }
    /* Only show the expand button when a node is collapsed and only show the
   collapse button when a node is expanded. */
    .node.expanded > .nodeshape > .buttoncontainer > .expandbutton {
      display: none;
    }
    .node:not(.expanded) > .nodeshape > .buttoncontainer > .collapsebutton {
      display: none;
    }

    .health-pill-stats {
      font-size: 4px;
      text-anchor: middle;
    }

    .health-pill rect {
      filter: url(#health-pill-shadow);
      rx: 3;
      ry: 3;
    }

    .titleContainer {
      position: relative;
      top: 20px;
    }

    .title,
    .auxTitle,
    .functionLibraryTitle {
      position: absolute;
    }

    #minimap {
      position: absolute;
      right: 20px;
      bottom: 20px;
    }

    .context-menu {
      position: absolute;
      display: none;
      background-color: #e2e2e2;
      border-radius: 2px;
      font-size: 14px;
      min-width: 150px;
      border: 1px solid #d4d4d4;
    }

    .context-menu ul {
      list-style-type: none;
      margin: 0;
      padding: 0;
      cursor: default;
    }

    .context-menu ul li {
      padding: 4px 16px;
    }

    .context-menu ul li:hover {
      background-color: #f3913e;
      color: white;
    }
  </style>
  <div class="titleContainer">
    <div id="title" class="title">Main Graph</div>
    <div id="auxTitle" class="auxTitle">Auxiliary Nodes</div>
    <div id="functionLibraryTitle" class="functionLibraryTitle">Functions</div>
  </div>
  <svg id="svg">
    <defs>
      <!-- Arrow heads for reference edge paths of different predefined sizes per color. -->
      <path
        id="reference-arrowhead-path"
        d="M 0,0 L 10,5 L 0,10 C 3,7 3,3 0,0"
      ></path>
      <marker
        class="reference-arrowhead"
        id="reference-arrowhead-small"
        viewBox="0 0 10 10"
        markerWidth="5"
        markerHeight="5"
        refX="2"
        refY="5"
        orient="auto-start-reverse"
        markerUnits="userSpaceOnUse"
      >
        <use xlink:href="#reference-arrowhead-path"></use>
      </marker>
      <marker
        class="reference-arrowhead"
        id="reference-arrowhead-medium"
        viewBox="0 0 10 10"
        markerWidth="13"
        markerHeight="13"
        refX="2"
        refY="5"
        orient="auto-start-reverse"
        markerUnits="userSpaceOnUse"
      >
        <use xlink:href="#reference-arrowhead-path"></use>
      </marker>
      <marker
        class="reference-arrowhead"
        id="reference-arrowhead-large"
        viewBox="0 0 10 10"
        markerWidth="16"
        markerHeight="16"
        refX="2"
        refY="5"
        orient="auto-start-reverse"
        markerUnits="userSpaceOnUse"
      >
        <use xlink:href="#reference-arrowhead-path"></use>
      </marker>
      <marker
        class="reference-arrowhead"
        id="reference-arrowhead-xlarge"
        viewBox="0 0 10 10"
        markerWidth="20"
        markerHeight="20"
        refX="2"
        refY="5"
        orient="auto-start-reverse"
        markerUnits="userSpaceOnUse"
      >
        <use xlink:href="#reference-arrowhead-path"></use>
      </marker>

      <!-- Arrow heads for dataflow edge paths of different predefined sizes per color. -->
      <path
        id="dataflow-arrowhead-path"
        d="M 0,0 L 10,5 L 0,10 C 3,7 3,3 0,0"
      ></path>
      <marker
        class="dataflow-arrowhead"
        id="dataflow-arrowhead-small"
        viewBox="0 0 10 10"
        markerWidth="5"
        markerHeight="5"
        refX="2"
        refY="5"
        orient="auto-start-reverse"
        markerUnits="userSpaceOnUse"
      >
        <use xlink:href="#dataflow-arrowhead-path"></use>
      </marker>
      <marker
        class="dataflow-arrowhead"
        id="dataflow-arrowhead-medium"
        viewBox="0 0 10 10"
        markerWidth="13"
        markerHeight="13"
        refX="2"
        refY="5"
        orient="auto-start-reverse"
        markerUnits="userSpaceOnUse"
      >
        <use xlink:href="#dataflow-arrowhead-path"></use>
      </marker>
      <marker
        class="dataflow-arrowhead"
        id="dataflow-arrowhead-large"
        viewBox="0 0 10 10"
        markerWidth="16"
        markerHeight="16"
        refX="2"
        refY="5"
        orient="auto-start-reverse"
        markerUnits="userSpaceOnUse"
      >
        <use xlink:href="#dataflow-arrowhead-path"></use>
      </marker>
      <marker
        class="dataflow-arrowhead"
        id="dataflow-arrowhead-xlarge"
        viewBox="0 0 10 10"
        markerWidth="20"
        markerHeight="20"
        refX="2"
        refY="5"
        orient="auto-start-reverse"
        markerUnits="userSpaceOnUse"
      >
        <use xlink:href="#dataflow-arrowhead-path"></use>
      </marker>

      <!-- Arrow head for annotation edge paths. -->
      <marker
        id="annotation-arrowhead"
        markerWidth="5"
        markerHeight="5"
        refX="5"
        refY="2.5"
        orient="auto"
      >
        <path d="M 0,0 L 5,2.5 L 0,5 L 0,0"></path>
      </marker>
      <marker
        id="annotation-arrowhead-faded"
        markerWidth="5"
        markerHeight="5"
        refX="5"
        refY="2.5"
        orient="auto"
      >
        <path d="M 0,0 L 5,2.5 L 0,5 L 0,0"></path>
      </marker>
      <marker
        id="ref-annotation-arrowhead"
        markerWidth="5"
        markerHeight="5"
        refX="0"
        refY="2.5"
        orient="auto"
      >
        <path d="M 5,0 L 0,2.5 L 5,5 L 5,0"></path>
      </marker>
      <marker
        id="ref-annotation-arrowhead-faded"
        markerWidth="5"
        markerHeight="5"
        refX="0"
        refY="2.5"
        orient="auto"
      >
        <path d="M 5,0 L 0,2.5 L 5,5 L 5,0"></path>
      </marker>
      <!-- Template for an Op node ellipse. -->
      <ellipse
        id="op-node-stamp"
        rx="7.5"
        ry="3"
        stroke="inherit"
        fill="inherit"
      ></ellipse>
      <!-- Template for an Op node annotation ellipse (smaller). -->
      <ellipse
        id="op-node-annotation-stamp"
        rx="5"
        ry="2"
        stroke="inherit"
        fill="inherit"
      ></ellipse>
      <!-- Vertically stacked series of Op nodes when unexpanded. -->
      <g id="op-series-vertical-stamp">
        <use xlink:href="#op-node-stamp" x="8" y="9"></use>
        <use xlink:href="#op-node-stamp" x="8" y="6"></use>
        <use xlink:href="#op-node-stamp" x="8" y="3"></use>
      </g>
      <!-- Horizontally stacked series of Op nodes when unexpanded. -->
      <g id="op-series-horizontal-stamp">
        <use xlink:href="#op-node-stamp" x="16" y="4"></use>
        <use xlink:href="#op-node-stamp" x="12" y="4"></use>
        <use xlink:href="#op-node-stamp" x="8" y="4"></use>
      </g>
      <!-- Horizontally stacked series of Op nodes for annotation. -->
      <g id="op-series-annotation-stamp">
        <use xlink:href="#op-node-annotation-stamp" x="9" y="2"></use>
        <use xlink:href="#op-node-annotation-stamp" x="7" y="2"></use>
        <use xlink:href="#op-node-annotation-stamp" x="5" y="2"></use>
      </g>
      <svg
        id="summary-icon"
        fill="#848484"
        height="12"
        viewBox="0 0 24 24"
        width="12"
      >
        <path
          d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z"
        ></path>
      </svg>

      <!-- Hatch patterns for faded out nodes. -->
      <pattern
        id="rectHatch"
        patternTransform="rotate(45 0 0)"
        width="5"
        height="5"
        patternUnits="userSpaceOnUse"
      >
        <line x1="0" y1="0" x2="0" y2="5" style="stroke-width: 1"></line>
      </pattern>
      <pattern
        id="ellipseHatch"
        patternTransform="rotate(45 0 0)"
        width="2"
        height="2"
        patternUnits="userSpaceOnUse"
      >
        <line x1="0" y1="0" x2="0" y2="2" style="stroke-width: 1"></line>
      </pattern>

      <!-- A shadow for health pills. -->
      <filter
        id="health-pill-shadow"
        x="-40%"
        y="-40%"
        width="180%"
        height="180%"
      >
        <feGaussianBlur in="SourceAlpha" stdDeviation="0.8"></feGaussianBlur>
        <feOffset dx="0" dy="0" result="offsetblur"></feOffset>
        <feFlood flood-color="#000000"></feFlood>
        <feComposite in2="offsetblur" operator="in"></feComposite>
        <feMerge>
          <feMergeNode></feMergeNode>
          <feMergeNode in="SourceGraphic"></feMergeNode>
        </feMerge>
      </filter>
    </defs>
    <!-- Make a large rectangle that fills the svg space so that
  zoom events get captured on safari -->
    <rect fill="white" width="10000" height="10000"></rect>
    <g id="root"></g>
  </svg>
  <tf-graph-minimap id="minimap"></tf-graph-minimap>
  <div id="contextMenu" class="context-menu"></div>
`;var Lr=class extends Gt(_o(mt)){constructor(){super(...arguments),this._zoomed=!1,this._zoomStartCoords=null,this._zoomTransform=null,this._maxZoomDistanceForClick=20,this._nodeGroupIndex={},this._annotationGroupIndex={},this._edgeGroupIndex={},this.maxMetanodeLabelLengthFontSize=9,this.minMetanodeLabelLengthFontSize=6,this.maxMetanodeLabelLengthLargeFont=11,this.maxMetanodeLabelLength=18}getNode(t){return this.renderHierarchy.getRenderNodeByName(t)}isNodeExpanded(t){return t.expanded}setNodeExpanded(t){this._build(this.renderHierarchy),this._updateLabels(!this._zoomed)}panToNode(t){Ale(t,this.$.svg,this.$.root,this._zoom)&&(this._zoomed=!0)}getGraphSvgRoot(){return this.$.svg}getContextMenu(){return this.$.contextMenu}_resetState(){this._nodeGroupIndex={},this._annotationGroupIndex={},this._edgeGroupIndex={},this._updateLabels(!1),Ht(this.$.svg).select("#root").selectAll("*").remove(),LH(this.$.svg)}_build(t){this.templateIndex=t.hierarchy.getTemplateIndex(),Rd("tf-graph-scene (layout):",function(){MH(t.root)}.bind(this),jr.RENDER_SCENE_LAYOUT),Rd("tf-graph-scene (build scene):",function(){ect(Ht(this.$.root),t.root,this),Ile(this.$.svg,this),this._updateInputTrace()}.bind(this),jr.RENDER_SCENE_BUILD_SCENE),setTimeout(function(){this._updateHealthPills(this.nodeNamesToHealthPills,this.healthPillStepIndex),this.minimap.update()}.bind(this),Tr.animation.duration)}ready(){super.ready(),this._zoom=eR().on("end",function(){if(this._zoomStartCoords){var t=Math.sqrt(Math.pow(this._zoomStartCoords.x-this._zoomTransform.x,2)+Math.pow(this._zoomStartCoords.y-this._zoomTransform.y,2));t<this._maxZoomDistanceForClick?this._fireEnableClick():setTimeout(this._fireEnableClick.bind(this),50)}this._zoomStartCoords=null}.bind(this)).on("zoom",function(){this._zoomTransform=qt.transform,this._zoomStartCoords||(this._zoomStartCoords=this._zoomTransform,this.fire("disable-click")),this._zoomed=!0,Ht(this.$.root).attr("transform",qt.transform),this.minimap.zoom(qt.transform)}.bind(this)),Ht(this.$.svg).call(this._zoom).on("dblclick.zoom",null),Ht(window).on("resize",function(){this.minimap.zoom()}.bind(this)),this.minimap=this.$.minimap.init(this.$.svg,this.$.root,this._zoom,Tr.minimap.size,Tr.subscene.meta.labelHeight)}attached(){this.set("_isAttached",!0)}detached(){this.set("_isAttached",!1)}_renderHierarchyChanged(){var t=this.renderHierarchy;this._hasRenderHierarchyBeenFitOnce=!1,this._resetState(),this._build(t)}_animateAndFit(){var t=this._isAttached;this._hasRenderHierarchyBeenFitOnce||!t||setTimeout(this.fit.bind(this),Tr.animation.duration)}_updateLabels(t){var r=this.$$(".title"),n=r.style,i=this.$$(".auxTitle"),o=i.style,a=this.$$(".functionLibraryTitle").style;let s=Ht(this.$.svg);var l=s.select("."+Hi.Scene.GROUP+">."+Hi.Scene.CORE).node();if(t&&l&&this.progress&&this.progress.value===100){var c=s.select("."+Hi.Scene.GROUP+">."+Hi.Scene.INEXTRACT).node()||s.select("."+Hi.Scene.GROUP+">."+Hi.Scene.OUTEXTRACT).node(),u=l.getCTM().e,h=c?c.getCTM().e:null;n.display="inline",n.left=u+"px",h!==null&&h!==u?(o.display="inline",h=Math.max(u+r.getBoundingClientRect().width,h),o.left=h+"px"):o.display="none";let f=s.select("."+Hi.Scene.GROUP+">."+Hi.Scene.FUNCTION_LIBRARY).node(),p=f?f.getCTM().e:null;p!==null&&p!==h?(a.display="inline",p=Math.max(h+i.getBoundingClientRect().width,p),a.left=p+"px"):a.display="none"}else n.display="none",o.display="none",a.display="none"}nodeColorsChanged(){this.renderHierarchy!=null&&(this.templateIndex=this.renderHierarchy.hierarchy.getTemplateIndex(),mP.each(this._nodeGroupIndex,(t,r)=>{this._updateNodeState(r)}),this.minimap.update())}fit(){this._hasRenderHierarchyBeenFitOnce=!0,Cle(this.$.svg,this.$.root,this._zoom,function(){this._zoomed=!1}.bind(this))}getImageBlob(){return this.minimap.getImageBlob()}isNodeSelected(t){return t===this.selectedNode}isNodeHighlighted(t){return t===this.highlightedNode}addAnnotationGroup(t,r,n){var i=t.node.name;this._annotationGroupIndex[i]=this._annotationGroupIndex[i]||{},this._annotationGroupIndex[i][r.node.name]=n}getAnnotationGroupsIndex(t){return this._annotationGroupIndex[t]}removeAnnotationGroup(t,r){delete this._annotationGroupIndex[t.node.name][r.node.name]}addNodeGroup(t,r){this._nodeGroupIndex[t]=r}getNodeGroup(t){return this._nodeGroupIndex[t]}removeNodeGroup(t){delete this._nodeGroupIndex[t]}addEdgeGroup(t,r){this._edgeGroupIndex[t]=r}getEdgeGroup(t){return this._edgeGroupIndex[t]}_updateHealthPills(){var t=this.nodeNamesToHealthPills,r=this.healthPillStepIndex;Rle(this.$.svg,t,r)}_updateNodeState(t){var r=this.getNode(t),n=this.getNodeGroup(t);if(n&&s3(n,r,this),r.node.type===jt.META&&r.node.associatedFunction&&!r.isLibraryFunction){var i=Sa+r.node.associatedFunction,o=Ht("."+Hi.Scene.GROUP+">."+Hi.Scene.FUNCTION_LIBRARY+' g[data-name="'+i+'"]');s3(o,r,this)}var a=this.getAnnotationGroupsIndex(t);mP.each(a,(s,l)=>{s3(s,r,this,Hi.Annotation.NODE)})}_selectedNodeChanged(t,r){if(t!==r&&(r&&this._updateNodeState(r),!!t)){this.minimap.update();for(var n=this.renderHierarchy.hierarchy.node(t),i=[];n.parentNode!=null&&n.parentNode.name!=qc;)n=n.parentNode,i.push(n.name);var o;mP.forEachRight(i,a=>{this.renderHierarchy.buildSubhierarchy(a);var s=this.renderHierarchy.getRenderNodeByName(a);s.node.isGroupNode&&!s.expanded&&(s.expanded=!0,o||(o=s))}),o&&(this.setNodeExpanded(o),this._zoomed=!0),t&&this._updateNodeState(t),setTimeout(()=>{this.panToNode(t)},Tr.animation.duration)}}_highlightedNodeChanged(t,r){t!==r&&(t&&this._updateNodeState(t),r&&this._updateNodeState(r))}_onZoomChanged(){this._updateLabels(!this._zoomed)}_fireEnableClick(){this.fire("enable-click")}_updateInputTrace(){Yle(this.getGraphSvgRoot(),this.renderHierarchy,this.selectedNode,this.traceInputs)}};Lr.template=Kle;E([A({type:Object}),w("design:type",lo)],Lr.prototype,"renderHierarchy",void 0);E([A({type:String}),w("design:type",String)],Lr.prototype,"name",void 0);E([A({type:String}),w("design:type",String)],Lr.prototype,"colorBy",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Lr.prototype,"traceInputs",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Lr.prototype,"_hasRenderHierarchyBeenFitOnce",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Lr.prototype,"_isAttached",void 0);E([A({type:Object}),w("design:type",Object)],Lr.prototype,"_zoom",void 0);E([A({type:String,observer:"_highlightedNodeChanged"}),w("design:type",String)],Lr.prototype,"highlightedNode",void 0);E([A({type:String,observer:"_selectedNodeChanged"}),w("design:type",String)],Lr.prototype,"selectedNode",void 0);E([A({type:Object}),w("design:type",Object)],Lr.prototype,"handleEdgeSelected",void 0);E([A({type:Boolean,observer:"_onZoomChanged"}),w("design:type",Boolean)],Lr.prototype,"_zoomed",void 0);E([A({type:Object}),w("design:type",Object)],Lr.prototype,"_zoomStartCoords",void 0);E([A({type:Object}),w("design:type",Object)],Lr.prototype,"_zoomTransform",void 0);E([A({type:Number}),w("design:type",Number)],Lr.prototype,"_maxZoomDistanceForClick",void 0);E([A({type:Object}),w("design:type",Function)],Lr.prototype,"templateIndex",void 0);E([A({type:Object}),w("design:type",Object)],Lr.prototype,"_nodeGroupIndex",void 0);E([A({type:Object}),w("design:type",Object)],Lr.prototype,"_annotationGroupIndex",void 0);E([A({type:Object}),w("design:type",Object)],Lr.prototype,"_edgeGroupIndex",void 0);E([A({type:Number}),w("design:type",Number)],Lr.prototype,"maxMetanodeLabelLengthFontSize",void 0);E([A({type:Number}),w("design:type",Number)],Lr.prototype,"minMetanodeLabelLengthFontSize",void 0);E([A({type:Number}),w("design:type",Number)],Lr.prototype,"maxMetanodeLabelLengthLargeFont",void 0);E([A({type:Number}),w("design:type",Number)],Lr.prototype,"maxMetanodeLabelLength",void 0);E([A({type:Object}),w("design:type",Object)],Lr.prototype,"progress",void 0);E([A({type:Array}),w("design:type",Array)],Lr.prototype,"nodeContextMenuItems",void 0);E([A({type:Object}),w("design:type",Object)],Lr.prototype,"nodeNamesToHealthPills",void 0);E([A({type:Number}),w("design:type",Number)],Lr.prototype,"healthPillStepIndex",void 0);E([Bt("renderHierarchy"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Lr.prototype,"_renderHierarchyChanged",null);E([Bt("_isAttached","renderHierarchy"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Lr.prototype,"_animateAndFit",null);E([Bt("colorBy"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Lr.prototype,"nodeColorsChanged",null);E([Bt("nodeNamesToHealthPills","healthPillStepIndex"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Lr.prototype,"_updateHealthPills",null);E([Bt("traceInputs","selectedNode"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Lr.prototype,"_updateInputTrace",null);Lr=E([yt("tf-graph-scene")],Lr);var Dr=class extends Gt(mt){constructor(){super(...arguments),this._renderDepth=1,this._allowGraphSelect=!0,this.edgeWidthFunction="",this.handleNodeSelected="",this.edgeLabelFunction="",this.handleEdgeSelected=""}panToNode(t){this.$$("tf-graph-scene").panToNode(t)}_autoExtractNodesChanged(){var t=this.graphHierarchy;if(!!t){for(let r of Object.values(t.getNodeMap()))r.include=ur.UNSPECIFIED;this._buildRenderHierarchy(t)}}_buildNewRenderHierarchy(){var t=this.graphHierarchy;!t||this._buildRenderHierarchy(t)}_statsChanged(){var t=this.stats,r=this.devicesForStats;this.graphHierarchy&&(t&&r&&(ale(this.basicGraph,t,r),ple(this.graphHierarchy,t)),this._buildRenderHierarchy(this.graphHierarchy))}ready(){super.ready(),this.addEventListener("graph-select",this._graphSelected.bind(this)),this.addEventListener("disable-click",this._disableClick.bind(this)),this.addEventListener("enable-click",this._enableClick.bind(this)),this.addEventListener("node-toggle-expand",this._nodeToggleExpand.bind(this)),this.addEventListener("node-select",this._nodeSelected.bind(this)),this.addEventListener("node-highlight",this._nodeHighlighted.bind(this)),this.addEventListener("node-unhighlight",this._nodeUnhighlighted.bind(this)),this.addEventListener("node-toggle-extract",this._nodeToggleExtract.bind(this)),this.addEventListener("node-toggle-seriesgroup",this._nodeToggleSeriesGroup.bind(this)),this.addEventListener("edge-select",this._edgeSelected.bind(this)),this.addEventListener("annotation-select",this._nodeSelected.bind(this)),this.addEventListener("annotation-highlight",this._nodeHighlighted.bind(this)),this.addEventListener("annotation-unhighlight",this._nodeUnhighlighted.bind(this))}_buildRenderHierarchy(t){if(t.root.type!==jt.META)return;let r=this,n=Rd("new tf_graph_render.Hierarchy",()=>{let i=new lo(t,!!this.stats,this.autoExtractNodes);i.edgeLabelFunction=this.edgeLabelFunction,i.edgeWidthFunction=this.edgeWidthFunction;function o(a){return{minValue:a.domain()[0],maxValue:a.domain()[1],startColor:a.range()[0],endColor:a.range()[1]}}return r._setColorByParams({compute_time:o(i.computeTimeScale),memory:o(i.memoryUsageScale),device:ict.map(i.deviceColorMap.domain(),function(a){return{device:a,color:i.deviceColorMap(a)}}),xla_cluster:ict.map(i.xlaClusterColorMap.domain(),function(a){return{xla_cluster:a,color:i.xlaClusterColorMap(a)}})}),i},jr.RENDER_BUILD_HIERARCHY);r._setRenderHierarchy(n)}_getVisible(t){return t&&this.renderHierarchy.getNearestVisibleAncestor(t)}fit(){this.$.scene.fit()}getImageBlob(){return this.$.scene.getImageBlob()}_graphChanged(){!this.graphHierarchy||(this.graphHierarchy.addListener(Dd.TEMPLATES_UPDATED,()=>{this.$.scene.nodeColorsChanged()}),this.fire("graph-select"))}_graphSelected(t){this._allowGraphSelect&&(this.set("selectedNode",null),this.set("selectedEdge",null)),this._allowGraphSelect=!0}_disableClick(t){this._allowGraphSelect=!1}_enableClick(t){this._allowGraphSelect=!0}_selectedNodeChanged(){var t=this.selectedNode;this.handleNodeSelected&&this.handleNodeSelected(t)}_selectedEdgeChanged(){var t=this.selectedEdge;this._deselectPreviousEdge(),t&&(this._lastSelectedEdgeGroup.classed(Hi.Edge.SELECTED,!0),this._updateMarkerOfSelectedEdge(t)),this.handleEdgeSelected&&this.handleEdgeSelected(t)}_nodeSelected(t){this._allowGraphSelect&&this.set("selectedNode",t.detail.name),this._allowGraphSelect=!0}_edgeSelected(t){this._allowGraphSelect&&(this.set("_lastSelectedEdgeGroup",t.detail.edgeGroup),this.set("selectedEdge",t.detail.edgeData)),this._allowGraphSelect=!0}_nodeHighlighted(t){this.set("highlightedNode",t.detail.name)}_nodeUnhighlighted(t){this.set("highlightedNode",null)}_nodeToggleExpand(t){this._nodeSelected(t);var r=t.detail.name,n=this.renderHierarchy.getRenderNodeByName(r);n.node.type!==jt.OP&&(this.renderHierarchy.buildSubhierarchy(r),n.expanded=!n.expanded,this.async(function(){this.$.scene.setNodeExpanded(n)},75),Po({actionId:jr.NODE_EXPANSION_TOGGLED,eventLabel:n.expanded?"expanded":"collapsed"}))}_nodeToggleExtract(t){var r=t.detail.name;this.nodeToggleExtract(r)}nodeToggleExtract(t){let r=this.renderHierarchy.getRenderNodeByName(t);r.node.include==ur.INCLUDE?r.node.include=ur.EXCLUDE:r.node.include==ur.EXCLUDE?r.node.include=ur.INCLUDE:r.node.include=this.renderHierarchy.isNodeAuxiliary(r)?ur.INCLUDE:ur.EXCLUDE,this._buildRenderHierarchy(this.graphHierarchy),Po({actionId:jr.NODE_AUXILIARY_EXTRACTION_CHANGED,eventLabel:r.node.include===ur.INCLUDE?"Auxiliary to Main":"Main to Auxiliary"})}_nodeToggleSeriesGroup(t){var r=t.detail.name;this.nodeToggleSeriesGroup(r)}nodeToggleSeriesGroup(t){this.set("progress",{value:0,msg:""});var r=nP(this),n=JS(r,100,"Namespace hierarchy");let i=Mx(Kl({},this.hierarchyParams),{seriesMap:this.graphHierarchy.buildSeriesGroupMapToggled(t)});bH(this.basicGraph,i,n).then(function(o){this.set("graphHierarchy",o),this._buildRenderHierarchy(this.graphHierarchy)}.bind(this))}_deselectPreviousEdge(){let t="."+Hi.Edge.SELECTED;Ht(t).classed(Hi.Edge.SELECTED,!1).each((r,n)=>{if(r.label){let i=Ht(this).selectAll("path.edgeline");r.label.startMarkerId&&i.style("marker-start",`url(#${r.label.startMarkerId})`),r.label.endMarkerId&&i.style("marker-end",`url(#${r.label.endMarkerId})`)}})}_updateMarkerOfSelectedEdge(t){var r;if(t.label){let n=t.label.startMarkerId||t.label.endMarkerId;if(n){let i=n.replace("dataflow-","selected-"),o=this.$$("#"+i);if(!o){let s=this.$.scene.querySelector("#"+n);o=s==null?void 0:s.cloneNode(!0),o.setAttribute("id",i),o.classList.add("selected-arrowhead"),(r=s==null?void 0:s.parentNode)==null||r.appendChild(o)}let a=t.label.startMarkerId?"marker-start":"marker-end";this._lastSelectedEdgeGroup.selectAll("path.edgeline").style(a,`url(#${i})`)}}}not(t){return!t}};Dr.template=Q`
    <style>
      .container {
        width: 100%;
        height: 100%;
        background: white;
        box-shadow: 0 1px 5px rgba(0, 0, 0, 0.2);
      }

      .vertical {
        width: 100%;
        height: 100%;
        @apply --layout-vertical;
      }

      .auto {
        @apply --layout-flex-auto;
        @apply --layout-vertical;
      }

      h2 {
        text-align: center;
      }

      paper-button {
        text-transform: none;
      }
    </style>
    <div class="container">
      <div class="vertical">
        <template is="dom-if" if="[[title]]">
          <h2>[[title]]</h2>
        </template>
        <tf-graph-scene
          id="scene"
          class="auto"
          render-hierarchy="[[renderHierarchy]]"
          highlighted-node="[[_getVisible(highlightedNode)]]"
          selected-node="{{selectedNode}}"
          selected-edge="{{selectedEdge}}"
          color-by="[[colorBy]]"
          progress="[[progress]]"
          node-context-menu-items="[[nodeContextMenuItems]]"
          node-names-to-health-pills="[[nodeNamesToHealthPills]]"
          health-pill-step-index="{{healthPillStepIndex}}"
          handle-edge-selected="[[handleEdgeSelected]]"
          trace-inputs="[[traceInputs]]"
        ></tf-graph-scene>
      </div>
    </div>
  `;E([A({type:Object,notify:!0,observer:"_graphChanged"}),w("design:type",os)],Dr.prototype,"graphHierarchy",void 0);E([A({type:Object}),w("design:type",Xu)],Dr.prototype,"basicGraph",void 0);E([A({type:Object}),w("design:type",Object)],Dr.prototype,"stats",void 0);E([A({type:Object}),w("design:type",Object)],Dr.prototype,"devicesForStats",void 0);E([A({type:Object}),w("design:type",Object)],Dr.prototype,"hierarchyParams",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],Dr.prototype,"progress",void 0);E([A({type:String}),w("design:type",String)],Dr.prototype,"title",void 0);E([A({type:String,notify:!0}),w("design:type",String)],Dr.prototype,"selectedNode",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],Dr.prototype,"selectedEdge",void 0);E([A({type:Object}),w("design:type",Object)],Dr.prototype,"_lastSelectedEdgeGroup",void 0);E([A({type:String,notify:!0}),w("design:type",String)],Dr.prototype,"highlightedNode",void 0);E([A({type:String}),w("design:type",String)],Dr.prototype,"colorBy",void 0);E([A({type:Object,notify:!0,readOnly:!0}),w("design:type",Object)],Dr.prototype,"colorByParams",void 0);E([A({type:Object,readOnly:!0,notify:!0}),w("design:type",lo)],Dr.prototype,"renderHierarchy",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Dr.prototype,"traceInputs",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Dr.prototype,"autoExtractNodes",void 0);E([A({type:Array}),w("design:type",Array)],Dr.prototype,"nodeContextMenuItems",void 0);E([A({type:Number}),w("design:type",Number)],Dr.prototype,"_renderDepth",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Dr.prototype,"_allowGraphSelect",void 0);E([A({type:Object}),w("design:type",Object)],Dr.prototype,"nodeNamesToHealthPills",void 0);E([A({type:Number}),w("design:type",Number)],Dr.prototype,"healthPillStepIndex",void 0);E([A({type:Object}),w("design:type",Object)],Dr.prototype,"edgeWidthFunction",void 0);E([A({type:Object}),w("design:type",Object)],Dr.prototype,"handleNodeSelected",void 0);E([A({type:Object}),w("design:type",Object)],Dr.prototype,"edgeLabelFunction",void 0);E([A({type:Object}),w("design:type",Object)],Dr.prototype,"handleEdgeSelected",void 0);E([Bt("autoExtractNodes"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Dr.prototype,"_autoExtractNodesChanged",null);E([Bt("graphHierarchy","edgeWidthFunction","handleNodeSelected","edgeLabelFunction","handleEdgeSelected"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Dr.prototype,"_buildNewRenderHierarchy",null);E([Bt("stats","devicesForStats"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Dr.prototype,"_statsChanged",null);E([Bt("selectedNode"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Dr.prototype,"_selectedNodeChanged",null);E([Bt("selectedEdge"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Dr.prototype,"_selectedEdgeChanged",null);Dr=E([yt("tf-graph")],Dr);var co=class extends Gt(mt){constructor(){super(...arguments),this.specificHealthPillStep=0,this.healthPillEntries=fP}ready(){super.ready();var t=document.getElementById("mainContainer"),r=document.querySelector("tf-dashboard-layout .scrollbar");t&&r&&(t.style.overflow="hidden",r.style.overflow="hidden")}_healthPillsAvailable(t,r){return t&&r}_computeTensorCountString(t,r){return t?t[r].toFixed(0):""}get healthPillValuesForSelectedNode(){var t=this.nodeNamesToHealthPills,r=this.healthPillStepIndex,n=this.selectedNode,i=this.allStepsModeEnabled,o=this.areHealthPillsLoading;if(o||!n)return null;let a=t[n];if(!a)return null;let s=a[i?0:r];return s?s.value.slice(2,8):null}get _currentStepDisplayValue(){var t=this.nodeNamesToHealthPills,r=this.healthPillStepIndex,n=this.allStepsModeEnabled,i=this.specificHealthPillStep,o=this.areHealthPillsLoading;if(n)return i.toFixed(0);if(o)return 0;for(let a in t)return t[a][r].step.toFixed(0);return 0}get _biggestStepEverSeen(){var t=this.nodeNamesToHealthPills;for(let n in t){var r=t[n];return Math.max(this._biggestStepEverSeen,r[r.length-1].step)}return this._biggestStepEverSeen||0}get _maxStepIndex(){var t=this.nodeNamesToHealthPills;for(let r in t)return t[r].length-1;return 0}_hasDebuggerNumericAlerts(t){return t&&t.length}_updateAlertsList(){var t=this.debuggerNumericAlerts,r=this.$$("#numeric-alerts-body");if(!!r){r.innerText="";for(var n=0;n<t.length;n++){var i=t[n],o=document.createElement("tr"),a=document.createElement("td");a.innerText=Qse(i.first_timestamp),a.classList.add("first-offense-td"),o.appendChild(a);var s=document.createElement("td");s.classList.add("tensor-device-td");var l=document.createElement("div");l.classList.add("tensor-section-within-table"),l.innerText=i.tensor_name,this._addOpExpansionListener(l,i.tensor_name),s.appendChild(l);var c=document.createElement("div");c.classList.add("device-section-within-table"),c.innerText="("+i.device_name+")",s.appendChild(c),o.appendChild(s);var u=document.createElement("div");u.classList.add("mini-health-pill");var h=document.createElement("td");if(h.classList.add("mini-health-pill-td"),h.appendChild(u),o.appendChild(h),i.neg_inf_event_count){var f=document.createElement("div");f.classList.add("negative-inf-mini-health-pill-section"),f.innerText=i.neg_inf_event_count,f.setAttribute("title",i.neg_inf_event_count+" events with -\u221E"),u.appendChild(f)}if(i.pos_inf_event_count){var p=document.createElement("div");p.classList.add("positive-inf-mini-health-pill-section"),p.innerText=i.pos_inf_event_count,p.setAttribute("title",i.pos_inf_event_count+" events with +\u221E"),u.appendChild(p)}if(i.nan_event_count){var d=document.createElement("div");d.classList.add("nan-mini-health-pill-section"),d.innerText=i.nan_event_count,d.setAttribute("title",i.nan_event_count+" events with NaN"),u.appendChild(d)}zt(r).appendChild(o)}}}_addOpExpansionListener(t,r){t.addEventListener("click",()=>{var n=xle(document.getElementById("scene"),this.renderHierarchy,r),i,o=document.querySelector("tf-graph-info#graph-info");o&&(i=o.scrollHeight-o.scrollTop);var a=this.selectedNode;this.set("selectedNode",n);var s=()=>{o.scrollTop=o.scrollHeight-i};o&&(a?s():window.setTimeout(s,20))})}};co.template=Q`
    <style>
      :host {
        font-size: 12px;
        margin: 0;
        padding: 0;
        display: block;
      }

      h2 {
        padding: 0;
        text-align: center;
        margin: 0;
      }

      .health-pill-legend {
        padding: 15px;
      }

      .health-pill-legend h2 {
        text-align: left;
      }

      .health-pill-entry {
        margin: 10px 10px 10px 0;
      }

      .health-pill-entry .color-preview {
        width: 26px;
        height: 26px;
        border-radius: 3px;
        display: inline-block;
        margin: 0 10px 0 0;
      }

      .health-pill-entry .color-label,
      .health-pill-entry .tensor-count {
        color: #777;
        display: inline-block;
        height: 26px;
        font-size: 22px;
        line-height: 26px;
        vertical-align: top;
      }

      .health-pill-entry .tensor-count {
        float: right;
      }

      #health-pill-step-slider {
        width: 100%;
        margin: 0 0 0 -15px;
        /* 31 comes from adding a padding of 15px from both sides of the paper-slider, subtracting
   * 1px so that the slider width aligns with the image (the last slider marker takes up 1px),
   * and adding 2px to account for a border of 1px on both sides of the image. 30 - 1 + 2.
   * Apparently, the paper-slider lacks a mixin for those padding values. */
        width: calc(100% + 31px);
      }

      #health-pills-loading-spinner {
        width: 20px;
        height: 20px;
        vertical-align: top;
      }

      #health-pill-step-number-input {
        text-align: center;
        vertical-align: top;
      }

      #numeric-alerts-table-container {
        max-height: 400px;
        overflow-x: hidden;
        overflow-y: auto;
      }

      #numeric-alerts-table {
        text-align: left;
      }

      #numeric-alerts-table td {
        vertical-align: top;
      }

      #numeric-alerts-table .first-offense-td {
        display: inline-block;
      }

      .first-offense-td {
        width: 80px;
      }

      .tensor-device-td {
        max-width: 140px;
        word-wrap: break-word;
      }

      .tensor-section-within-table {
        color: #266236;
        cursor: pointer;
        opacity: 0.8;
        text-decoration: underline;
      }

      .tensor-section-within-table:hover {
        opacity: 1;
      }

      .device-section-within-table {
        color: #666;
      }

      .mini-health-pill {
        width: 130px;
      }

      .mini-health-pill > div {
        height: 100%;
        width: 60px;
        border-radius: 3px;
      }

      #event-counts-th {
        padding: 0 0 0 10px;
      }

      .negative-inf-mini-health-pill-section {
        background: rgb(255, 141, 0);
        width: 20px;
      }

      .positive-inf-mini-health-pill-section {
        background: rgb(0, 62, 212);
        width: 20px;
      }

      .nan-mini-health-pill-section {
        background: rgb(204, 47, 44);
        width: 20px;
      }

      .negative-inf-mini-health-pill-section,
      .positive-inf-mini-health-pill-section,
      .nan-mini-health-pill-section {
        color: #fff;
        display: inline-block;
        height: 100%;
        line-height: 20px;
        margin: 0 0 0 10px;
        text-align: center;
      }

      .no-numeric-alerts-notification {
        margin: 0;
      }
    </style>
    <paper-material elevation="1" class="card health-pill-legend">
      <div class="title">
        Enable all (not just sampled) steps. Requires slow disk read.
      </div>
      <paper-toggle-button
        id="enableAllStepsModeToggle"
        checked="{{allStepsModeEnabled}}"
      >
      </paper-toggle-button>
      <h2>
        Step of Health Pills:
        <template is="dom-if" if="[[allStepsModeEnabled]]">
          <input
            type="number"
            id="health-pill-step-number-input"
            min="0"
            max="[[_biggestStepEverSeen]]"
            value="{{specificHealthPillStep::input}}"
          />
        </template>
        <template is="dom-if" if="[[!allStepsModeEnabled]]">
          [[_currentStepDisplayValue]]
        </template>
        <paper-spinner-lite
          active
          hidden$="[[!areHealthPillsLoading]]"
          id="health-pills-loading-spinner"
        ></paper-spinner-lite>
      </h2>
      <template is="dom-if" if="[[allStepsModeEnabled]]">
        <paper-slider
          id="health-pill-step-slider"
          immediate-value="{{specificHealthPillStep}}"
          max="[[_biggestStepEverSeen]]"
          snaps
          step="1"
          value="{{specificHealthPillStep}}"
        ></paper-slider>
      </template>
      <template is="dom-if" if="[[!allStepsModeEnabled]]">
        <template is="dom-if" if="[[_maxStepIndex]]">
          <paper-slider
            id="health-pill-step-slider"
            immediate-value="{{healthPillStepIndex}}"
            max="[[_maxStepIndex]]"
            snaps
            step="1"
            value="{{healthPillStepIndex}}"
          ></paper-slider>
        </template>
      </template>
      <h2>
        Health Pill
        <template is="dom-if" if="[[healthPillValuesForSelectedNode]]">
          Counts for Selected Node
        </template>
        <template is="dom-if" if="[[!healthPillValuesForSelectedNode]]">
          Legend
        </template>
      </h2>
      <template is="dom-repeat" items="[[healthPillEntries]]">
        <div class="health-pill-entry">
          <div
            class="color-preview"
            style="background:[[item.background_color]]"
          ></div>
          <div class="color-label">[[item.label]]</div>
          <div class="tensor-count">
            [[_computeTensorCountString(healthPillValuesForSelectedNode,
            index)]]
          </div>
        </div>
      </template>
      <div hidden$="[[!_hasDebuggerNumericAlerts(debuggerNumericAlerts)]]">
        <h2 id="numeric-alerts-header">Numeric Alerts</h2>
        <p>Alerts are sorted from top to bottom by increasing timestamp.</p>
        <div id="numeric-alerts-table-container">
          <table id="numeric-alerts-table">
            <thead>
              <tr>
                <th>First Offense</th>
                <th>Tensor (Device)</th>
                <th id="event-counts-th">Event Counts</th>
              </tr>
            </thead>
            <tbody id="numeric-alerts-body"></tbody>
          </table>
        </div>
      </div>
      <template
        is="dom-if"
        if="[[!_hasDebuggerNumericAlerts(debuggerNumericAlerts)]]"
      >
        <p class="no-numeric-alerts-notification">
          No numeric alerts so far. That is likely good. Alerts indicate the
          presence of NaN or (+/-) Infinity values, which may be concerning.
        </p>
      </template>
    </paper-material>
  `;E([A({type:Object}),w("design:type",lo)],co.prototype,"renderHierarchy",void 0);E([A({type:Array,notify:!0}),w("design:type",Object)],co.prototype,"debuggerNumericAlerts",void 0);E([A({type:Object}),w("design:type",Object)],co.prototype,"nodeNamesToHealthPills",void 0);E([A({type:Number,notify:!0}),w("design:type",Object)],co.prototype,"healthPillStepIndex",void 0);E([A({type:Number,notify:!0}),w("design:type",Number)],co.prototype,"specificHealthPillStep",void 0);E([A({type:String,notify:!0}),w("design:type",Object)],co.prototype,"selectedNode",void 0);E([A({type:String,notify:!0}),w("design:type",Object)],co.prototype,"highlightedNode",void 0);E([A({type:Number,notify:!0}),w("design:type",Object)],co.prototype,"selectedNodeInclude",void 0);E([A({type:Boolean}),w("design:type",Object)],co.prototype,"areHealthPillsLoading",void 0);E([A({type:Array}),w("design:type",Array)],co.prototype,"healthPillEntries",void 0);E([A({type:Boolean,notify:!0}),w("design:type",Object)],co.prototype,"allStepsModeEnabled",void 0);E([Rt("nodeNamesToHealthPills","healthPillStepIndex","selectedNode","allStepsModeEnabled","areHealthPillsLoading"),w("design:type",Object),w("design:paramtypes",[])],co.prototype,"healthPillValuesForSelectedNode",null);E([Rt("nodeNamesToHealthPills","healthPillStepIndex","allStepsModeEnabled","specificHealthPillStep","areHealthPillsLoading"),w("design:type",Object),w("design:paramtypes",[])],co.prototype,"_currentStepDisplayValue",null);E([Rt("nodeNamesToHealthPills"),w("design:type",Number),w("design:paramtypes",[])],co.prototype,"_biggestStepEverSeen",null);E([Rt("nodeNamesToHealthPills"),w("design:type",Number),w("design:paramtypes",[])],co.prototype,"_maxStepIndex",null);E([Bt("debuggerNumericAlerts"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],co.prototype,"_updateAlertsList",null);co=E([yt("tf-graph-debugger-data-card")],co);var oct={};Ks(oct,{GraphIconType:()=>n1});var n1;(function(e){e.CONST="CONST",e.META="META",e.OP="OP",e.SERIES="SERIES",e.SUMMARY="SUMMARY"})(n1||(n1={}));var Zu=class extends Gt(_o(mt)){constructor(){super(...arguments),this.vertical=!1,this.fillOverride=null,this.strokeOverride=null,this.height=20,this.faded=!1}getSvgDefinableElement(){return this.$.svgDefs}get _fill(){var t=this.type,r=this.fillOverride;if(r!=null)return r;switch(t){case n1.META:return Ku.DEFAULT_FILL;case n1.SERIES:return Vlt.DEFAULT_FILL;default:return y0.DEFAULT_FILL}}get _stroke(){var t=this.type,r=this.strokeOverride;if(r!=null)return r;switch(t){case n1.META:return Ku.DEFAULT_STROKE;case n1.SERIES:return Vlt.DEFAULT_STROKE;default:return y0.DEFAULT_STROKE}}_isType(t,r){return t===r}_fadedClass(t,r){return t?"faded-"+r:""}};Zu.template=Q`
    <style>
      :host {
        font-size: 0;
      }

      :host(.dark-mode) svg {
        filter: invert(1);
      }

      .faded-rect {
        fill: url(#rectHatch);
      }

      .faded-ellipse {
        fill: url(#ellipseHatch);
      }

      .faded-rect,
      .faded-ellipse,
      .faded-series {
        stroke: var(--tb-graph-faded) !important;
      }
      #rectHatch line,
      #ellipseHatch line {
        color: #e0d4b3 !important;
        fill: white;
        stroke: #e0d4b3 !important;
      }
    </style>
    <!-- SVG for definitions -->
    <svg height="0" width="0" id="svgDefs">
      <defs>
        <!-- Hatch patterns for faded out nodes. -->
        <pattern
          id="rectHatch"
          patternTransform="rotate(45 0 0)"
          width="5"
          height="5"
          patternUnits="userSpaceOnUse"
        >
          <line x1="0" y1="0" x2="0" y2="5" style="stroke-width: 1"></line>
        </pattern>
        <pattern
          id="ellipseHatch"
          patternTransform="rotate(45 0 0)"
          width="2"
          height="2"
          patternUnits="userSpaceOnUse"
        >
          <line x1="0" y1="0" x2="0" y2="2" style="stroke-width: 1"></line>
        </pattern>
        <!-- Template for an Op node ellipse. -->
        <ellipse
          id="op-node-stamp"
          rx="7.5"
          ry="3"
          stroke="inherit"
          fill="inherit"
        ></ellipse>
        <!-- Template for an Op node annotation ellipse (smaller). -->
        <ellipse
          id="op-node-annotation-stamp"
          rx="5"
          ry="2"
          stroke="inherit"
          fill="inherit"
        ></ellipse>
        <!-- Vertically stacked series of Op nodes when unexpanded. -->
        <g id="op-series-vertical-stamp">
          <use xlink:href="#op-node-stamp" x="8" y="9"></use>
          <use xlink:href="#op-node-stamp" x="8" y="6"></use>
          <use xlink:href="#op-node-stamp" x="8" y="3"></use>
        </g>
        <g id="op-series-horizontal-stamp">
          <use xlink:href="#op-node-stamp" x="16" y="4"></use>
          <use xlink:href="#op-node-stamp" x="12" y="4"></use>
          <use xlink:href="#op-node-stamp" x="8" y="4"></use>
        </g>
        <g
          id="summary-icon"
          fill="#848484"
          height="12"
          viewBox="0 0 24 24"
          width="12"
        >
          <path
            d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z"
          ></path>
        </g>
      </defs>
    </svg>
    <template is="dom-if" if="[[_isType(type, 'CONST')]]">
      <svg
        height$="[[height]]"
        preserveAspectRatio="xMinYMid meet"
        viewBox="0 0 10 10"
      >
        <circle
          cx="5"
          cy="5"
          r="3"
          fill$="[[_fill]]"
          stroke$="[[_stroke]]"
        ></circle>
      </svg>
    </template>
    <template is="dom-if" if="[[_isType(type, 'SUMMARY')]]">
      <svg
        width$="[[height]]"
        height$="[[height]]"
        viewBox="0 0 24 24"
        fill="#848484"
      >
        <path
          d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z"
        ></path>
      </svg>
    </template>
    <template is="dom-if" if="[[_isType(type, 'OP')]]">
      <svg
        height$="[[height]]"
        preserveAspectRatio="xMinYMid meet"
        viewBox="0 0 16 8"
      >
        <use
          xmlns:xlink="http://www.w3.org/1999/xlink"
          xlink:href="#op-node-stamp"
          fill$="[[_fill]]"
          stroke$="[[_stroke]]"
          class$="{{_fadedClass(faded, 'ellipse')}}"
          x="8"
          y="4"
        ></use>
      </svg>
    </template>
    <template is="dom-if" if="[[_isType(type, 'META')]]">
      <svg
        height$="[[height]]"
        preserveAspectRatio="xMinYMid meet"
        viewBox="0 0 37 16"
      >
        <rect
          x="1"
          y="1"
          fill$="[[_fill]]"
          stroke$="[[_stroke]]"
          class$="{{_fadedClass(faded, 'rect')}}"
          stroke-width="2px"
          height="14"
          width="35"
          rx="5"
          ry="5"
        ></rect>
      </svg>
    </template>
    <template is="dom-if" if="[[_isType(type, 'SERIES')]]">
      <template is="dom-if" if="[[vertical]]">
        <svg
          height$="[[height]]"
          preserveAspectRatio="xMinYMid meet"
          viewBox="0 0 16 15"
        >
          <use
            xmlns:xlink="http://www.w3.org/1999/xlink"
            xlink:href="#op-series-vertical-stamp"
            fill$="[[_fill]]"
            stroke$="[[_stroke]]"
            class$="{{_fadedClass(faded, 'series')}}"
            x="0"
            y="2"
          ></use>
        </svg>
      </template>
      <template is="dom-if" if="[[!vertical]]">
        <svg
          height$="[[height]]"
          preserveAspectRatio="xMinYMid meet"
          viewBox="0 0 24 10"
        >
          <use
            xmlns:xlink="http://www.w3.org/1999/xlink"
            xlink:href="#op-series-horizontal-stamp"
            fill$="[[_fill]]"
            stroke$="[[_stroke]]"
            class$="{{_fadedClass(faded, 'series')}}"
            x="0"
            y="1"
          ></use>
        </svg>
      </template>
    </template>
  `;E([A({type:String}),w("design:type",String)],Zu.prototype,"type",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Zu.prototype,"vertical",void 0);E([A({type:String}),w("design:type",Object)],Zu.prototype,"fillOverride",void 0);E([A({type:String}),w("design:type",Object)],Zu.prototype,"strokeOverride",void 0);E([A({type:Number}),w("design:type",Number)],Zu.prototype,"height",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Zu.prototype,"faded",void 0);E([Rt("type","fillOverride"),w("design:type",String),w("design:paramtypes",[])],Zu.prototype,"_fill",null);E([Rt("type","strokeOverride"),w("design:type",String),w("design:paramtypes",[])],Zu.prototype,"_stroke",null);Zu=E([yt("tf-graph-icon")],Zu);var Bs=class extends Gt(mt){constructor(){super(...arguments),this.node=null,this.renderInfo=null,this.colorBy=qn.STRUCTURE,this.templateIndex=null,this.type=null,this.vertical=!1,this.const=!1,this.summary=!1,this.fill=null,this.height=20}_computeFillOverride(t,r,n,i,o){return t&&r&&i?kH(i,n,r,!1):o}_getStrokeOverride(t){return t?tct(t):null}_getType(t,r,n,i){let{GraphIconType:o}=oct;if(t)switch(t.type){case jt.OP:{let a=t.op;return typeof a!="string"?o.OP:a==="Const"||n?o.CONST:a.endsWith("Summary")||r?o.SUMMARY:o.OP}case jt.META:return o.META;case jt.SERIES:return o.SERIES}return i}_isVertical(t,r){return t?t.hasNonControlEdges:!!r}_getFaded(t){return t&&t.isFadedOut}_onFillOverrideChanged(t,r){let{node:n,renderInfo:i,colorBy:o,templateIndex:a}=this;t!==r&&LH(this.$.icon.getSvgDefinableElement()),n&&i&&a&&kH(a,o,i,!1,this.$.icon.getSvgDefinableElement())}};Bs.template=Q`
    <style>
      tf-graph-icon {
        --tb-graph-faded: var(--tb-graph-faded);
      }
    </style>
    <tf-graph-icon
      id="icon"
      type="[[_getType(node, summary, const, type)]]"
      height="[[height]]"
      fill-override="[[_fillOverride]]"
      stroke-override="[[_getStrokeOverride(_fillOverride)]]"
      faded="[[_getFaded(renderInfo)]]"
      vertical="[[_isVertical(node, vertical)]]"
    ></tf-graph-icon>
  `;E([A({type:Object}),w("design:type",Object)],Bs.prototype,"node",void 0);E([A({type:Object}),w("design:type",Object)],Bs.prototype,"renderInfo",void 0);E([A({type:Object}),w("design:type",String)],Bs.prototype,"colorBy",void 0);E([A({type:Object}),w("design:type",Object)],Bs.prototype,"templateIndex",void 0);E([A({type:String}),w("design:type",Object)],Bs.prototype,"type",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Bs.prototype,"vertical",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Bs.prototype,"const",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Bs.prototype,"summary",void 0);E([A({type:String}),w("design:type",Object)],Bs.prototype,"fill",void 0);E([A({type:Number}),w("design:type",Number)],Bs.prototype,"height",void 0);E([A({type:String,computed:"_computeFillOverride(node, renderInfo, colorBy, templateIndex, fill)",observer:"_onFillOverrideChanged"}),w("design:type",String)],Bs.prototype,"_fillOverride",void 0);Bs=E([yt("tf-node-icon")],Bs);var Gc=class extends Gt(mt){_itemTypeChanged(){this.itemType!=="subnode"?this.$["list-item"].classList.add("clickable"):this.$["list-item"].classList.remove("clickable")}_nodeListener(t){this.fire("node-list-item-"+t.type,{nodeName:this.name,type:this.itemType})}_fadedClass(t){return t&&t.isFadedOut?"faded":""}};Gc.template=Q`
    <style>
      #list-item {
        width: 100%;
        color: var(--secondary-text-color);
        font-size: 11pt;
        font-weight: 400;
        position: relative;
        display: inline-block;
      }

      #list-item:hover {
        background-color: var(--google-yellow-100);
      }

      .clickable {
        cursor: pointer;
      }

      #list-item span {
        margin-left: 40px;
      }

      #list-item.excluded span {
        color: #999;
      }

      #list-item span.edge-label {
        float: right;
        font-size: 10px;
        margin-left: 3px;
        margin-right: 5px;
      }

      .node-icon {
        position: absolute;
        top: 1px;
        left: 2px;
      }

      .faded span {
        color: var(--tb-graph-faded);
      }
    </style>

    <div
      id="list-item"
      on-mouseover="_nodeListener"
      on-mouseout="_nodeListener"
      on-click="_nodeListener"
    >
      <div class$="{{_fadedClass(itemRenderInfo)}}">
        <tf-node-icon
          class="node-icon"
          height="12"
          color-by="[[colorBy]]"
          color-by-params="[[colorByParams]]"
          node="[[itemNode]]"
          render-info="[[itemRenderInfo]]"
          template-index="[[templateIndex]]"
        >
        </tf-node-icon>
        <span title$="[[name]]">[[name]]</span>
      </div>
    </div>
  `;E([A({type:Object}),w("design:type",Object)],Gc.prototype,"cardNode",void 0);E([A({type:Object}),w("design:type",Object)],Gc.prototype,"itemNode",void 0);E([A({type:String}),w("design:type",String)],Gc.prototype,"edgeLabel",void 0);E([A({type:Object}),w("design:type",Object)],Gc.prototype,"itemRenderInfo",void 0);E([A({type:String}),w("design:type",String)],Gc.prototype,"name",void 0);E([A({type:String,observer:"_itemTypeChanged"}),w("design:type",String)],Gc.prototype,"itemType",void 0);E([A({type:String}),w("design:type",String)],Gc.prototype,"colorBy",void 0);E([A({type:Object}),w("design:type",Object)],Gc.prototype,"colorByParams",void 0);E([A({type:Object}),w("design:type",Function)],Gc.prototype,"templateIndex",void 0);Gc=E([yt("tf-graph-op-compat-list-item")],Gc);var as=class extends Gt(_o(mt)){constructor(){super(...arguments),this._expanded=!0,this._opCompatColor=y0.COMPATIBLE,this._opIncompatColor=y0.INCOMPATIBLE,this._templateIndex=null}_getNode(t,r){return r.node(t)}_getRenderInfo(t,r){return this.renderHierarchy.getOrCreateRenderNodeByName(t)}_toggleExpanded(){this._expanded=!this._expanded}_getToggleIcon(t){return t?"expand-less":"expand-more"}_resizeList(t){var r=document.querySelector(t);r&&r.fire("iron-resize")}get _incompatibleOpNodes(){let t=this.graphHierarchy;return!t||!t.root?[]:(this.async(this._resizeList.bind(this,"#incompatibleOpsList")),dle(t))}get _opCompatScore(){var t=this.graphHierarchy;if(t&&t.root){var r=t.root,n=r.compatibilityHistogram.compatible,i=r.compatibilityHistogram.incompatible;if(n==0&&i==0)return 0;var o=n+i;return Math.floor(100*n/o)/100}return 0}get _opCompatScoreLabel(){var t=this._opCompatScore;return xn(".0%")(t)}get _totalIncompatOps(){var t=this.graphHierarchy;return t&&t.root?t.root.compatibilityHistogram.incompatible:0}_graphHierarchyChanged(){this._templateIndex=this.graphHierarchy.getTemplateIndex(),this.graphHierarchy.addListener(Dd.TEMPLATES_UPDATED,()=>{this._templateIndex=this.graphHierarchy.getTemplateIndex()})}};as.template=Q`
    <style>
      :host {
        max-height: 500px;
      }

      .incompatible-ops-list {
        height: 350px;
        max-height: 400px;
        overflow-y: scroll;
        display: flex;
        flex-direction: column;
      }

      iron-list {
        flex: 1 1 auto;
      }

      paper-item {
        padding: 0;
        background: var(--secondary-background-color);
      }

      paper-item-body[two-line] {
        min-height: 0;
        padding: 8px 12px 4px;
      }

      .expandedInfo {
        padding: 8px 12px;
        font-weight: 500;
        font-size: 12pt;
        width: 100%;
      }

      .node-name {
        white-space: normal;
        word-wrap: break-word;
        font-size: 14pt;
        font-weight: 500;
      }

      .subtitle {
        color: var(--secondary-text-color);
        font-size: 12pt;
      }

      .toggle-button {
        float: right;
        max-height: 20px;
        max-width: 20px;
        padding: 0;
      }

      .non-control-list-item {
        padding-left: 10px;
      }

      div.op-compat-display {
        margin-top: 10px;
        display: inline-block;
      }

      /**
       * Sadly, because the whole body is inverted in color, legends also need
       * to be inverted.
       **/
      :host(.dark-mode) div.op-compat-display {
        filter: invert(1);
      }

      svg.op-compat {
        width: 250px;
        height: 25px;
        float: left;
      }

      div.op-compat-value {
        float: right;
        height: 100%;
        font-size: 14px;
        color: black;
        margin-left: 10px;
      }
    </style>

    <paper-item>
      <paper-item-body two-line>
        <div>
          <paper-icon-button
            icon="{{_getToggleIcon(_expanded)}}"
            on-click="_toggleExpanded"
            class="toggle-button"
          >
          </paper-icon-button>
          <div class="node-name" id="nodetitle">[[nodeTitle]]</div>
        </div>
        <div secondary>
          <div class="subtitle">
            <div class="op-compat-display">
              <svg
                class="op-compat"
                preserveAspectRatio="xMinYMid meet"
                viewBox="0 0 250 25"
              >
                <defs>
                  <linearGradient id="op-compat-fill">
                    <stop offset="0" stop-color$="[[_opCompatColor]]"></stop>
                    <stop
                      offset$="[[_opCompatScore]]"
                      stop-color$="[[_opCompatColor]]"
                    ></stop>
                    <stop
                      offset$="[[_opCompatScore]]"
                      stop-color$="[[_opIncompatColor]]"
                    ></stop>
                    <stop offset="1" stop-color$="[[_opIncompatColor ]]"></stop>
                  </linearGradient>
                </defs>
                <rect
                  height="25"
                  width="250"
                  rx="5"
                  ry="5"
                  style="fill: url('#op-compat-fill');"
                ></rect>
              </svg>
              <div class="op-compat-value">[[_opCompatScoreLabel]]</div>
            </div>
          </div>
        </div>
      </paper-item-body>
    </paper-item>

    <iron-collapse opened="{{_expanded}}">
      <template is="dom-if" if="{{_expanded}}" restamp="true">
        <div class="expandedInfo">
          Incompatible Operations: (<span>[[_totalIncompatOps]]</span>)
          <iron-list
            class="incompatible-ops-list"
            id="incompatibleOpsList"
            items="[[_incompatibleOpNodes]]"
          >
            <template>
              <tf-graph-op-compat-list-item
                class="non-control-list-item"
                item-node="[[item]]"
                item-render-info="[[_getRenderInfo(item.name, renderHierarchy)]]"
                name="[[item.name]]"
                template-index="[[_templateIndex]]"
                color-by="[[colorBy]]"
                item-type="incompatible-ops"
              >
              </tf-graph-op-compat-list-item>
            </template>
          </iron-list>
        </div>
      </template>
    </iron-collapse>
  `;E([A({type:Object}),w("design:type",os)],as.prototype,"graphHierarchy",void 0);E([A({type:Object}),w("design:type",lo)],as.prototype,"renderHierarchy",void 0);E([A({type:String}),w("design:type",String)],as.prototype,"nodeTitle",void 0);E([A({type:Boolean}),w("design:type",Boolean)],as.prototype,"_expanded",void 0);E([A({type:String}),w("design:type",String)],as.prototype,"_opCompatColor",void 0);E([A({type:String}),w("design:type",String)],as.prototype,"_opIncompatColor",void 0);E([A({type:Object}),w("design:type",Object)],as.prototype,"_templateIndex",void 0);E([Rt("graphHierarchy"),w("design:type",Array),w("design:paramtypes",[])],as.prototype,"_incompatibleOpNodes",null);E([Rt("graphHierarchy"),w("design:type",Number),w("design:paramtypes",[])],as.prototype,"_opCompatScore",null);E([Rt("_opCompatScore"),w("design:type",String),w("design:paramtypes",[])],as.prototype,"_opCompatScoreLabel",null);E([Rt("graphHierarchy"),w("design:type",Number),w("design:paramtypes",[])],as.prototype,"_totalIncompatOps",null);E([Bt("graphHierarchy"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],as.prototype,"_graphHierarchyChanged",null);as=E([yt("tf-graph-op-compat-card")],as);var l3=Ee(Oe(),1);var Wc=class extends Gt(_o(mt)){_itemTypeChanged(){this.itemType!=="subnode"?this.$["list-item"].classList.add("clickable"):this.$["list-item"].classList.remove("clickable")}_nodeListener(t){this.fire("node-list-item-"+t.type,{cardNode:this.cardNode.name,nodeName:this.name,type:this.itemType})}_fadedClass(t){return t&&t.isFadedOut?"faded":""}};Wc.template=Q`
    <style>
      #list-item {
        width: 100%;
        color: var(--secondary-text-color);
        font-size: 11pt;
        font-weight: 400;
        position: relative;
        display: inline-block;
      }

      #list-item:hover {
        background-color: var(--google-yellow-100);
      }

      :host(.dark-mode) #list-item:hover {
        background-color: var(--paper-yellow-900);
        color: #fff;
      }

      .clickable {
        cursor: pointer;
      }

      #list-item span {
        margin-left: 40px;
      }

      #list-item.excluded span {
        color: #999;
      }

      #list-item span.edge-label {
        float: right;
        font-size: 10px;
        margin-left: 3px;
        margin-right: 5px;
      }

      .node-icon {
        position: absolute;
        top: 1px;
        left: 2px;
      }

      .faded span {
        color: var(--tb-graph-faded);
      }
    </style>
    <div
      id="list-item"
      on-mouseover="_nodeListener"
      on-mouseout="_nodeListener"
      on-click="_nodeListener"
    >
      <div class$="{{_fadedClass(itemRenderInfo)}}">
        <tf-node-icon
          class="node-icon"
          height="12"
          color-by="[[colorBy]]"
          color-by-params="[[colorByParams]]"
          node="[[itemNode]]"
          render-info="[[itemRenderInfo]]"
          template-index="[[templateIndex]]"
        ></tf-node-icon>
        <span title$="[[name]]">[[name]]</span>
        <span class="edge-label">[[edgeLabel]]</span>
      </div>
    </div>
  `;E([A({type:Object}),w("design:type",Object)],Wc.prototype,"cardNode",void 0);E([A({type:Object}),w("design:type",Object)],Wc.prototype,"itemNode",void 0);E([A({type:String}),w("design:type",String)],Wc.prototype,"edgeLabel",void 0);E([A({type:Object}),w("design:type",Object)],Wc.prototype,"itemRenderInfo",void 0);E([A({type:String}),w("design:type",String)],Wc.prototype,"name",void 0);E([A({type:String,observer:"_itemTypeChanged"}),w("design:type",String)],Wc.prototype,"itemType",void 0);E([A({type:String}),w("design:type",String)],Wc.prototype,"colorBy",void 0);E([A({type:Object}),w("design:type",Object)],Wc.prototype,"colorByParams",void 0);E([A({type:Object}),w("design:type",Object)],Wc.prototype,"templateIndex",void 0);Wc=E([yt("tf-node-list-item")],Wc);var dn=class extends Gt(mt){constructor(){super(...arguments),this._expanded=!0,this._openedControlPred=!1,this._openedControlSucc=!1,this._templateIndex=null}expandNode(){this.fire("_node.expand",this.node)}_getNode(t,r){return r.node(t)}_getNodeStats(t,r){var n=this._getNode(t,r);return n?n.stats:null}_getTotalMicros(t){return t?t.getTotalMicros():0}get _hasDisplayableNodeStats(){var t=this._nodeStats;return gH(t)}get _nodeStatsFormattedBytes(){var t=this._nodeStats;if(!(!t||!t.totalBytes))return Nd(t.totalBytes,iP)}get _nodeStatsFormattedComputeTime(){var t=this._nodeStats;if(!(!t||!t.getTotalMicros()))return Nd(t.getTotalMicros(),oP)}get _nodeStatsFormattedOutputSizes(){var t=this._nodeStats;if(!(!t||!t.outputSize||!t.outputSize.length))return l3.map(t.outputSize,function(r){return r.length===0?"scalar":"["+r.join(", ")+"]"})}_getRenderInfo(t,r){return this.renderHierarchy.getOrCreateRenderNodeByName(t)}get _attributes(){var t=this._node;if(this.async(this._resizeList.bind(this,"#attributesList")),!t||!t.attr)return[];var r=[];return l3.each(t.attr,function(n){n.key===ile?r=r.concat(n.value.list.s.map(function(i){return{key:i,value:"Too large to show..."}})):r.push({key:n.key,value:JSON.stringify(n.value)})}),r}get _device(){var t=this._node;return t?t.device:null}get _successors(){var t=this._node,r=this.graphHierarchy;return this._refreshNodeItemList("inputsList"),t?this._convertEdgeListToEdgeInfoList(r.getSuccessors(t.name),!1,t.isGroupNode):{regular:[],control:[]}}get _predecessors(){var t=this._node,r=this.graphHierarchy;return this._refreshNodeItemList("outputsList"),t?this._convertEdgeListToEdgeInfoList(r.getPredecessors(t.name),!0,t.isGroupNode):{regular:[],control:[]}}get _functionUsages(){var t=this._node,r=this.graphHierarchy;if(this._refreshNodeItemList("functionUsagesList"),!t||t.type!==jt.META)return[];let n=r.libraryFunctions[t.associatedFunction];return n?n.usages:[]}_refreshNodeItemList(t){this.async(this._resizeList.bind(this,`#${t}`))}_convertEdgeListToEdgeInfoList(t,r,n){var i=a=>l3.map(a.baseEdgeList,s=>{var l=r?s.v:s.w;return{name:l,node:this._getNode(l,this.graphHierarchy),edgeLabel:Ylt(s,this.renderHierarchy),renderInfo:this._getRenderInfo(l,this.renderHierarchy)}}),o=function(a){var s=[];return l3.each(a,l=>{var c=r?l.v:l.w;!n||l.baseEdgeList.length==1?s=s.concat(i(l)):s.push({name:c,node:this._getNode(c,this.graphHierarchy),edgeLabel:jlt(l,this.renderHierarchy),renderInfo:this._getRenderInfo(c,this.renderHierarchy)})}),s}.bind(this);return{regular:o(t.regular),control:o(t.control)}}get _subnodes(){var t=this._node;return t&&t.metagraph?t.metagraph.nodes():null}get _totalPredecessors(){var t=this._predecessors;return t.regular.length+t.control.length}get _totalSuccessors(){var t=this._successors;return t.regular.length+t.control.length}_toggleControlPred(){this._openedControlPred=!this._openedControlPred}_toggleControlSucc(){this._openedControlSucc=!this._openedControlSucc}_toggleExpanded(){this._expanded=!this._expanded}_getToggleIcon(t){return t?"expand-less":"expand-more"}_resetState(){this._openedControlPred=!1,this._openedControlSucc=!1,this.set("_groupButtonText",Qlt(this._node))}_resizeList(t){var r=document.querySelector(t);r&&r.fire("iron-resize")}_toggleInclude(){this.fire("node-toggle-inclusion",{name:this.graphNodeName})}_nodeIncludeStateChanged(t,r){this.set("_auxButtonText",yH(t))}_toggleGroup(){var t=IH(this._node);this.fire("node-toggle-seriesgroup",{name:t})}_isLibraryFunction(t){return t&&t.name.startsWith(Sa)}_isInSeries(t){return Jlt(t)}_graphHierarchyChanged(){this._templateIndex=this.graphHierarchy.getTemplateIndex(),this.graphHierarchy.addListener(Dd.TEMPLATES_UPDATED,()=>{this._templateIndex=this.graphHierarchy.getTemplateIndex()})}};dn.template=Q`
    <style>
      .sub-list-group {
        font-weight: 500;
        font-size: 12pt;
        padding-bottom: 8px;
        width: 100%;
      }

      .sub-list {
        max-height: 300px;
        overflow-y: scroll;
      }

      .attr-left {
        float: left;
        width: 30%;
        word-wrap: break-word;
        color: var(--secondary-text-color);
        font-size: 11pt;
        font-weight: 400;
      }

      .attr-right {
        margin-left: 30%;
        word-wrap: break-word;
        color: var(--secondary-text-color);
        font-weight: 400;
      }

      .sub-list-table {
        display: table;
        width: 100%;
      }

      .sub-list-table-row {
        display: table-row;
      }

      .sub-list-table-row .sub-list-table-cell:last-child {
        text-align: right;
      }

      .sub-list-table-cell {
        color: var(--secondary-text-color);
        display: table-cell;
        font-size: 11pt;
        font-weight: 400;
        max-width: 200px;
        padding: 0 4px;
      }

      paper-item {
        padding: 0;
        background: var(--primary-background-color);
      }

      paper-item-body[two-line] {
        min-height: 0;
        padding: 8px 12px 4px;
      }

      .expandedInfo {
        padding: 8px 12px;
      }

      .controlDeps {
        padding: 0 0 0 8px;
      }

      .node-name {
        white-space: normal;
        word-wrap: break-word;
        font-size: 14pt;
        font-weight: 500;
      }

      .node-icon {
        float: right;
      }

      .subtitle {
        color: var(--secondary-text-color);
        font-size: 12pt;
      }

      .controlLine {
        font-size: 11pt;
        font-weight: 400;
      }

      .toggle-button {
        float: right;
        max-height: 20px;
        max-width: 20px;
        padding: 0;
      }

      .control-toggle-button {
        float: left;
        max-height: 20px;
        max-width: 20px;
        padding: 0;
      }

      .toggle-include-group {
        padding-top: 4px;
      }

      .toggle-include {
        margin: 5px 6px;
        text-transform: none;
        padding: 4px 6px;
        font-size: 10pt;
        background-color: #fafafa;
        color: #666;
      }

      .toggle-include:hover {
        background-color: var(--google-yellow-100);
      }

      .non-control-list-item {
        padding-left: 10px;
      }
    </style>
    <paper-item>
      <paper-item-body two-line>
        <div>
          <paper-icon-button
            icon="{{_getToggleIcon(_expanded)}}"
            on-click="_toggleExpanded"
            class="toggle-button"
          >
          </paper-icon-button>
          <div class="node-name">
            <tf-wbr-string value="[[_node.name]]" delimiter-pattern="/">
            </tf-wbr-string>
          </div>
        </div>
        <div secondary>
          <tf-node-icon
            class="node-icon"
            node="[[_node]]"
            render-info="[[_getRenderInfo(graphNodeName, renderHierarchy)]]"
            color-by="[[colorBy]]"
            template-index="[[_templateIndex]]"
          ></tf-node-icon>
          <template is="dom-if" if="{{_node.op}}">
            <div class="subtitle">
              Operation:
              <span>[[_node.op]]</span>
            </div>
          </template>
          <template is="dom-if" if="{{_node.metagraph}}">
            <div class="subtitle">
              Subgraph:
              <span>[[_node.cardinality]]</span> nodes
            </div>
          </template>
        </div>
      </paper-item-body>
    </paper-item>
    <iron-collapse opened="{{_expanded}}">
      <template is="dom-if" if="{{_expanded}}" restamp="true">
        <div class="expandedInfo">
          <div class="sub-list-group attributes">
            Attributes (<span>[[_attributes.length]]</span>)
            <iron-list
              class="sub-list"
              id="attributesList"
              items="[[_attributes]]"
            >
              <template>
                <div>
                  <div class="attr-left">[[item.key]]</div>
                  <div class="attr-right">[[item.value]]</div>
                </div>
              </template>
            </iron-list>
          </div>

          <template is="dom-if" if="{{_device}}">
            <div class="sub-list-group device">
              <div class="attr-left">Device</div>
              <div class="attr-right">[[_device]]</div>
            </div>
          </template>

          <div class="sub-list-group predecessors">
            Inputs (<span>[[_totalPredecessors]]</span>)
            <iron-list
              class="sub-list"
              id="inputsList"
              items="[[_predecessors.regular]]"
            >
              <template>
                <tf-node-list-item
                  class="non-control-list-item"
                  card-node="[[_node]]"
                  item-node="[[item.node]]"
                  edge-label="[[item.edgeLabel]]"
                  item-render-info="[[item.renderInfo]]"
                  name="[[item.name]]"
                  item-type="predecessors"
                  color-by="[[colorBy]]"
                  template-index="[[_templateIndex]]"
                >
                </tf-node-list-item>
              </template>
            </iron-list>
            <template is="dom-if" if="[[_predecessors.control.length]]">
              <div class="controlDeps">
                <div class="controlLine">
                  <paper-icon-button
                    icon="{{_getToggleIcon(_openedControlPred)}}"
                    on-click="_toggleControlPred"
                    class="control-toggle-button"
                  >
                  </paper-icon-button>
                  Control dependencies
                </div>
                <iron-collapse opened="{{_openedControlPred}}" no-animation>
                  <template
                    is="dom-if"
                    if="{{_openedControlPred}}"
                    restamp="true"
                  >
                    <iron-list
                      class="sub-list"
                      items="[[_predecessors.control]]"
                    >
                      <template>
                        <tf-node-list-item
                          card-node="[[_node]]"
                          item-node="[[item.node]]"
                          item-render-info="[[item.renderInfo]]"
                          name="[[item.name]]"
                          item-type="predecessors"
                          color-by="[[colorBy]]"
                          template-index="[[_templateIndex]]"
                        >
                        </tf-node-list-item>
                      </template>
                    </iron-list>
                  </template>
                </iron-collapse>
              </div>
            </template>
          </div>

          <div class="sub-list-group successors">
            Outputs (<span>[[_totalSuccessors]]</span>)
            <iron-list
              class="sub-list"
              id="outputsList"
              items="[[_successors.regular]]"
            >
              <template>
                <tf-node-list-item
                  class="non-control-list-item"
                  card-node="[[_node]]"
                  item-node="[[item.node]]"
                  edge-label="[[item.edgeLabel]]"
                  item-render-info="[[item.renderInfo]]"
                  name="[[item.name]]"
                  item-type="successor"
                  color-by="[[colorBy]]"
                  template-index="[[_templateIndex]]"
                >
                </tf-node-list-item>
              </template>
            </iron-list>
            <template is="dom-if" if="[[_successors.control.length]]">
              <div class="controlDeps">
                <div class="controlLine">
                  <paper-icon-button
                    icon="{{_getToggleIcon(_openedControlSucc)}}"
                    on-click="_toggleControlSucc"
                    class="control-toggle-button"
                  >
                  </paper-icon-button>
                  Control dependencies
                </div>
                <iron-collapse opened="{{_openedControlSucc}}" no-animation>
                  <template
                    is="dom-if"
                    if="{{_openedControlSucc}}"
                    restamp="true"
                  >
                    <iron-list class="sub-list" items="[[_successors.control]]">
                      <template>
                        <tf-node-list-item
                          card-node="[[_node]]"
                          item-node="[[item.node]]"
                          item-render-info="[[item.renderInfo]]"
                          name="[[item.name]]"
                          item-type="successors"
                          color-by="[[colorBy]]"
                          template-index="[[_templateIndex]]"
                        >
                        </tf-node-list-item>
                      </template>
                    </iron-list>
                  </template>
                </iron-collapse>
              </div>
            </template>
          </div>
          <template is="dom-if" if="{{_hasDisplayableNodeStats}}">
            <div class="sub-list-group node-stats">
              Node Stats
              <div class="sub-list-table">
                <template is="dom-if" if="{{_nodeStats.totalBytes}}">
                  <div class="sub-list-table-row">
                    <div class="sub-list-table-cell">Memory</div>
                    <div class="sub-list-table-cell">
                      [[_nodeStatsFormattedBytes]]
                    </div>
                  </div>
                </template>
                <template is="dom-if" if="{{_getTotalMicros(_nodeStats)}}">
                  <div class="sub-list-table-row">
                    <div class="sub-list-table-cell">Compute Time</div>
                    <div class="sub-list-table-cell">
                      [[_nodeStatsFormattedComputeTime]]
                    </div>
                  </div>
                </template>
                <template is="dom-if" if="{{_nodeStats.outputSize}}">
                  <div class="sub-list-table-row">
                    <div class="sub-list-table-cell">Tensor Output Sizes</div>
                    <div class="sub-list-table-cell">
                      <template
                        is="dom-repeat"
                        items="{{_nodeStatsFormattedOutputSizes}}"
                      >
                        [[item]] <br />
                      </template>
                    </div>
                  </div>
                </template>
              </div>
            </div>
          </template>

          <template is="dom-if" if="[[_functionUsages.length]]">
            <div class="sub-list-group predecessors">
              Usages of the Function (<span>[[_functionUsages.length]]</span>)
              <iron-list
                class="sub-list"
                id="functionUsagesList"
                items="[[_functionUsages]]"
              >
                <template>
                  <tf-node-list-item
                    class="non-control-list-item"
                    card-node="[[_node]]"
                    item-node="[[item]]"
                    name="[[item.name]]"
                    item-type="functionUsages"
                    color-by="[[colorBy]]"
                    template-index="[[_templateIndex]]"
                  >
                  </tf-node-list-item>
                </template>
              </iron-list>
            </div>
          </template>

          <template is="dom-if" if="[[!_isLibraryFunction(_node)]]">
            <div class="toggle-include-group">
              <paper-button
                raised
                class="toggle-include"
                on-click="_toggleInclude"
              >
                <span>[[_auxButtonText]]</span>
              </paper-button>
            </div>
          </template>

          <template is="dom-if" if="{{_isInSeries(_node)}}">
            <div class="toggle-include-group">
              <paper-button
                raised
                class="toggle-include"
                on-click="_toggleGroup"
              >
                <span>[[_groupButtonText]]</span>
              </paper-button>
            </div>
          </template>
        </div>
      </template>
    </iron-collapse>
  `;E([A({type:String}),w("design:type",String)],dn.prototype,"graphNodeName",void 0);E([A({type:Object}),w("design:type",os)],dn.prototype,"graphHierarchy",void 0);E([A({type:Object}),w("design:type",Object)],dn.prototype,"renderHierarchy",void 0);E([A({type:String}),w("design:type",String)],dn.prototype,"colorBy",void 0);E([A({type:Object,computed:"_getNode(graphNodeName, graphHierarchy)",observer:"_resetState"}),w("design:type",Object)],dn.prototype,"_node",void 0);E([A({type:Object,computed:"_getNodeStats(graphNodeName, graphHierarchy)",observer:"_resetState"}),w("design:type",Object)],dn.prototype,"_nodeStats",void 0);E([A({type:Number,observer:"_nodeIncludeStateChanged"}),w("design:type",Number)],dn.prototype,"nodeInclude",void 0);E([A({type:Boolean}),w("design:type",Boolean)],dn.prototype,"_expanded",void 0);E([A({type:Boolean}),w("design:type",Boolean)],dn.prototype,"_openedControlPred",void 0);E([A({type:Boolean}),w("design:type",Boolean)],dn.prototype,"_openedControlSucc",void 0);E([A({type:String}),w("design:type",String)],dn.prototype,"_auxButtonText",void 0);E([A({type:String}),w("design:type",String)],dn.prototype,"_groupButtonText",void 0);E([A({type:Object}),w("design:type",Function)],dn.prototype,"_templateIndex",void 0);E([Rt("_nodeStats"),w("design:type",Boolean),w("design:paramtypes",[])],dn.prototype,"_hasDisplayableNodeStats",null);E([Rt("_nodeStats"),w("design:type",Object),w("design:paramtypes",[])],dn.prototype,"_nodeStatsFormattedBytes",null);E([Rt("_nodeStats"),w("design:type",Object),w("design:paramtypes",[])],dn.prototype,"_nodeStatsFormattedComputeTime",null);E([Rt("_nodeStats"),w("design:type",Object),w("design:paramtypes",[])],dn.prototype,"_nodeStatsFormattedOutputSizes",null);E([Rt("_node"),w("design:type",Array),w("design:paramtypes",[])],dn.prototype,"_attributes",null);E([Rt("_node"),w("design:type",String),w("design:paramtypes",[])],dn.prototype,"_device",null);E([Rt("_node","graphHierarchy"),w("design:type",Object),w("design:paramtypes",[])],dn.prototype,"_successors",null);E([Rt("_node","graphHierarchy"),w("design:type",Object),w("design:paramtypes",[])],dn.prototype,"_predecessors",null);E([Rt("_node","graphHierarchy"),w("design:type",Array),w("design:paramtypes",[])],dn.prototype,"_functionUsages",null);E([Rt("_node"),w("design:type",Array),w("design:paramtypes",[])],dn.prototype,"_subnodes",null);E([Rt("_predecessors"),w("design:type",Number),w("design:paramtypes",[])],dn.prototype,"_totalPredecessors",null);E([Rt("_successors"),w("design:type",Number),w("design:paramtypes",[])],dn.prototype,"_totalSuccessors",null);E([Bt("graphHierarchy"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],dn.prototype,"_graphHierarchyChanged",null);dn=E([yt("tf-node-info")],dn);var ss=class extends Gt(mt){ready(){super.ready(),this.addEventListener("node-list-item-click",this._nodeListItemClicked.bind(this)),this.addEventListener("node-list-item-mouseover",this._nodeListItemMouseover.bind(this)),this.addEventListener("node-list-item-mouseout",this._nodeListItemMouseout.bind(this))}_nodeListItemClicked(t){this.selectedNode=t.detail.nodeName}_nodeListItemMouseover(t){this.highlightedNode=t.detail.nodeName}_nodeListItemMouseout(){this.highlightedNode=null}_healthPillsAvailable(t,r){return t&&r&&Object.keys(r).length>0}_equals(t,r){return t===r}};ss.template=Q`
    <style>
      :host {
        background: var(--secondary-background-color);
        font-size: 12px;
        margin: 0;
        padding: 0;
        display: block;
        max-height: 650px;
        overflow-x: hidden;
        overflow-y: auto;
      }

      h2 {
        padding: 0;
        text-align: center;
        margin: 0;
      }
    </style>
    <template is="dom-if" if="{{selectedNode}}">
      <paper-material elevation="1" class="card">
        <tf-node-info
          graph-hierarchy="[[graphHierarchy]]"
          render-hierarchy="[[renderHierarchy]]"
          flat-graph="[[graph]]"
          graph-node-name="[[selectedNode]]"
          node-include="[[selectedNodeInclude]]"
          highlighted-node="{{highlightedNode}}"
          color-by="[[colorBy]]"
        >
        </tf-node-info>
      </paper-material>
    </template>
    <template is="dom-if" if="[[_equals(colorBy, 'op_compatibility')]]">
      <tf-graph-op-compat-card
        graph-hierarchy="[[graphHierarchy]]"
        render-hierarchy="[[renderHierarchy]]"
        color-by="[[colorBy]]"
        node-title="[[compatNodeTitle]]"
      >
      </tf-graph-op-compat-card>
    </template>
    <template
      is="dom-if"
      if="[[_healthPillsAvailable(debuggerDataEnabled, nodeNamesToHealthPills)]]"
    >
      <tf-graph-debugger-data-card
        render-hierarchy="[[renderHierarchy]]"
        debugger-numeric-alerts="[[debuggerNumericAlerts]]"
        node-names-to-health-pills="[[nodeNamesToHealthPills]]"
        selected-node="{{selectedNode}}"
        highlighted-node="{{highlightedNode}}"
        are-health-pills-loading="[[areHealthPillsLoading]]"
        all-steps-mode-enabled="{{allStepsModeEnabled}}"
        specific-health-pill-step="{{specificHealthPillStep}}"
        health-pill-step-index="{{healthPillStepIndex}}"
      >
      </tf-graph-debugger-data-card>
    </template>
  `;E([A({type:String}),w("design:type",String)],ss.prototype,"title",void 0);E([A({type:Object}),w("design:type",os)],ss.prototype,"graphHierarchy",void 0);E([A({type:Object}),w("design:type",Xu)],ss.prototype,"graph",void 0);E([A({type:Object}),w("design:type",lo)],ss.prototype,"renderHierarchy",void 0);E([A({type:Object}),w("design:type",Object)],ss.prototype,"nodeNamesToHealthPills",void 0);E([A({type:Number,notify:!0}),w("design:type",Number)],ss.prototype,"healthPillStepIndex",void 0);E([A({type:String}),w("design:type",String)],ss.prototype,"colorBy",void 0);E([A({type:String}),w("design:type",String)],ss.prototype,"compatNodeTitle",void 0);E([A({type:String,notify:!0}),w("design:type",String)],ss.prototype,"selectedNode",void 0);E([A({type:String,notify:!0}),w("design:type",String)],ss.prototype,"highlightedNode",void 0);E([A({type:Number,notify:!0}),w("design:type",Number)],ss.prototype,"selectedNodeInclude",void 0);E([A({type:Boolean}),w("design:type",Boolean)],ss.prototype,"debuggerDataEnabled",void 0);ss=E([yt("tf-graph-info")],ss);var cur={MAX_NODE_COUNT:1e4,MAX_EDGE_COUNT:1e4},tn=class extends Gt(mt){constructor(){super(...arguments),this.hierarchyParams=r3,this.allStepsModeEnabled=!1,this.specificHealthPillStep=0,this.compatNodeTitle="TPU Compatibility"}fit(){this.$.graph.fit()}downloadAsImage(t){return Ri(this,null,function*(){let r=yield this.$.graph.getImageBlob(),n=document.createElement("a");n.href=URL.createObjectURL(r),n.download=t,n.click(),URL.revokeObjectURL(n.href)})}_isNotComplete(t){return t.value<100}_getContainerClass(t){var r="container";return t.error&&(r+=" error"),this._isNotComplete(t)&&(r+=" loading"),r}_onNodeInclusionToggled(t){this.$.graph.nodeToggleExtract(t.detail.name)}_onNodeSeriesGroupToggled(t){this.$.graph.nodeToggleSeriesGroup(t.detail.name)}_updateNodeInclude(){let t=this.renderHierarchy?this.renderHierarchy.getNodeByName(this.selectedNode):null;this._selectedNodeInclude=t?t.include:ur.UNSPECIFIED}_slimGraphChanged(){if(!this.graph)return;let{MAX_NODE_COUNT:t,MAX_EDGE_COUNT:r}=cur;Object.keys(this.graph.nodes).length>t&&this.graph.edges.length>r&&this.colorBy===qn.STRUCTURE&&(this.colorBy=qn.NONE)}_ensureTemplates(){!this.graphHierarchy||this.colorBy!==qn.STRUCTURE||this.graphHierarchy.getTemplateIndex()||this.graphHierarchy.updateTemplates()}};tn.template=Q`
    <style>
      ::host {
        display: block;
      }

      /deep/ .close {
        position: absolute;
        cursor: pointer;
        left: 15px;
        bottom: 15px;
      }

      .container {
        width: 100%;
        height: 100%;
        opacity: 1;
      }

      .container.loading {
        cursor: progress;
        opacity: 0.1;
      }

      .container.loading.error {
        cursor: auto;
      }

      #info {
        position: absolute;
        right: 5px;
        top: 5px;
        padding: 0px;
        max-width: 380px;
        min-width: 320px;
        background-color: rgba(255, 255, 255, 0.9);
        @apply --shadow-elevation-2dp;
      }

      #main {
        width: 100%;
        height: 100%;
      }

      #progress-bar {
        display: flex;
        flex-direction: column;
        align-items: center;
        justify-content: center;
        width: 100%;
        position: absolute;
        top: 40px;
        left: 0;
        font-size: 13px;
      }

      #progress-msg {
        margin-bottom: 5px;
        white-space: pre-wrap;
        width: 400px;
      }

      paper-progress {
        width: 400px;
        --paper-progress-height: 6px;
        --paper-progress-active-color: #f3913e;
      }

      .context-menu {
        position: absolute;
        display: none;
        background-color: #e2e2e2;
        border-radius: 2px;
        font-size: 14px;
        min-width: 150px;
        border: 1px solid #d4d4d4;
      }

      /deep/ .context-menu ul {
        list-style-type: none;
        margin: 0;
        padding: 0;
        cursor: default;
      }

      /deep/ .context-menu ul li {
        padding: 4px 16px;
      }

      /deep/ .context-menu ul li:hover {
        background-color: #f3913e;
        color: white;
      }
    </style>
    <template is="dom-if" if="[[_isNotComplete(progress)]]">
      <div id="progress-bar">
        <div id="progress-msg">[[progress.msg]]</div>
        <paper-progress value="[[progress.value]]"></paper-progress>
      </div>
    </template>
    <div class$="[[_getContainerClass(progress)]]">
      <div id="main">
        <tf-graph
          id="graph"
          graph-hierarchy="{{graphHierarchy}}"
          basic-graph="[[graph]]"
          hierarchy-params="[[hierarchyParams]]"
          render-hierarchy="{{renderHierarchy}}"
          devices-for-stats="[[devicesForStats]]"
          stats="[[stats]]"
          selected-node="{{selectedNode}}"
          highlighted-node="{{_highlightedNode}}"
          color-by="[[colorBy]]"
          color-by-params="{{colorByParams}}"
          progress="{{progress}}"
          edge-label-function="[[edgeLabelFunction]]"
          edge-width-function="[[edgeWidthFunction]]"
          node-names-to-health-pills="[[nodeNamesToHealthPills]]"
          health-pill-step-index="[[healthPillStepIndex]]"
          handle-node-selected="[[handleNodeSelected]]"
          handle-edge-selected="[[handleEdgeSelected]]"
          trace-inputs="[[traceInputs]]"
          auto-extract-nodes="[[autoExtractNodes]]"
        ></tf-graph>
      </div>
      <div id="info">
        <tf-graph-info
          id="graph-info"
          title="selected"
          graph-hierarchy="[[graphHierarchy]]"
          render-hierarchy="[[renderHierarchy]]"
          graph="[[graph]]"
          selected-node="{{selectedNode}}"
          selected-node-include="{{_selectedNodeInclude}}"
          highlighted-node="{{_highlightedNode}}"
          color-by="[[colorBy]]"
          color-by-params="[[colorByParams]]"
          debugger-data-enabled="[[debuggerDataEnabled]]"
          are-health-pills-loading="[[areHealthPillsLoading]]"
          debugger-numeric-alerts="[[debuggerNumericAlerts]]"
          node-names-to-health-pills="[[nodeNamesToHealthPills]]"
          all-steps-mode-enabled="{{allStepsModeEnabled}}"
          specific-health-pill-step="{{specificHealthPillStep}}"
          health-pill-step-index="{{healthPillStepIndex}}"
          compat-node-title="[[compatNodeTitle]]"
          on-node-toggle-inclusion="_onNodeInclusionToggled"
          on-node-toggle-seriesgroup="_onNodeSeriesGroupToggled"
        ></tf-graph-info>
      </div>
    </div>
  `;E([A({type:Object}),w("design:type",os)],tn.prototype,"graphHierarchy",void 0);E([A({type:Object}),w("design:type",Xu)],tn.prototype,"graph",void 0);E([A({type:Object}),w("design:type",Object)],tn.prototype,"hierarchyParams",void 0);E([A({type:Object}),w("design:type",Object)],tn.prototype,"stats",void 0);E([A({type:Object}),w("design:type",Object)],tn.prototype,"progress",void 0);E([A({type:Boolean}),w("design:type",Boolean)],tn.prototype,"traceInputs",void 0);E([A({type:Boolean}),w("design:type",Boolean)],tn.prototype,"autoExtractNodes",void 0);E([A({type:String,notify:!0}),w("design:type",String)],tn.prototype,"colorBy",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],tn.prototype,"colorByParams",void 0);E([A({type:Object,notify:!0}),w("design:type",lo)],tn.prototype,"renderHierarchy",void 0);E([A({type:Boolean}),w("design:type",Boolean)],tn.prototype,"debuggerDataEnabled",void 0);E([A({type:Boolean}),w("design:type",Boolean)],tn.prototype,"areHealthPillsLoading",void 0);E([A({type:Array,notify:!0}),w("design:type",Array)],tn.prototype,"debuggerNumericAlerts",void 0);E([A({type:Object}),w("design:type",Object)],tn.prototype,"nodeNamesToHealthPills",void 0);E([A({type:Boolean,notify:!0}),w("design:type",Boolean)],tn.prototype,"allStepsModeEnabled",void 0);E([A({type:Number,notify:!0}),w("design:type",Number)],tn.prototype,"specificHealthPillStep",void 0);E([A({type:Number}),w("design:type",Number)],tn.prototype,"healthPillStepIndex",void 0);E([A({type:String,notify:!0}),w("design:type",String)],tn.prototype,"selectedNode",void 0);E([A({type:String}),w("design:type",String)],tn.prototype,"compatNodeTitle",void 0);E([A({type:Object}),w("design:type",Object)],tn.prototype,"edgeWidthFunction",void 0);E([A({type:Number}),w("design:type",Number)],tn.prototype,"_selectedNodeInclude",void 0);E([A({type:String}),w("design:type",String)],tn.prototype,"_highlightedNode",void 0);E([A({type:Object}),w("design:type",Object)],tn.prototype,"handleNodeSelected",void 0);E([A({type:Object}),w("design:type",Object)],tn.prototype,"edgeLabelFunction",void 0);E([A({type:Object}),w("design:type",Object)],tn.prototype,"handleEdgeSelected",void 0);E([Bt("selectedNode","renderHierarchy"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],tn.prototype,"_updateNodeInclude",null);E([Bt("graph"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],tn.prototype,"_slimGraphChanged",null);E([Bt("colorBy","graphHierarchy"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],tn.prototype,"_ensureTemplates",null);tn=E([yt("tf-graph-board")],tn);var c3=Ee(Oe(),1);var Ju=class{isNotTpuOp(t){return t.toLowerCase().search("cpu:")!=-1||t.toLowerCase().search("gpu:")!=-1?!0:t.toLowerCase().search("tpu")==-1}opValid(t){return t.name.search(Sa)==0||!t.op||t.device&&this.isNotTpuOp(t.device)||t.device&&t.device.search("TPU_SYSTEM")!=-1?!0:c3.includes(Ju.WHITELIST,t.op)}};Ju.WHITELIST=["Abs","Acos","Acosh","Add","AddN","AddV2","AdjustContrastv2","AdjustHue","AdjustSaturation","All","AllToAll","Angle","Any","ApproximateEqual","ArgMax","ArgMin","Asin","Asinh","Assert","AssignAddVariableOp","AssignSubVariableOp","AssignVariableOp","Atan","Atan2","Atanh","AvgPool","AvgPool3D","AvgPool3DGrad","AvgPoolGrad","BatchMatMul","BatchMatMulV2","BatchToSpace","BatchToSpaceND","BesselI0e","BesselI1e","Betainc","BiasAdd","BiasAddGrad","BiasAddV1","Bitcast","BitwiseAnd","BitwiseOr","BitwiseXor","BroadcastArgs","BroadcastGradientArgs","BroadcastTo","Bucketize","Case","Cast","Ceil","CheckNumerics","Cholesky","ClipByValue","CollectivePermute","CollectiveReduceV2","Complex","ComplexAbs","Concat","ConcatOffset","ConcatV2","Conj","ConjugateTranspose","Const","ControlTrigger","Conv2D","Conv2DBackpropFilter","Conv2DBackpropInput","Conv3D","Conv3DBackpropFilterV2","Conv3DBackpropInputV2","Cos","Cosh","Cross","CrossReplicaSum","Cumprod","Cumsum","DataFormatDimMap","DataFormatVecPermute","DepthToSpace","DepthwiseConv2dNative","DepthwiseConv2dNativeBackpropFilter","DepthwiseConv2dNativeBackpropInput","Dequantize","DeviceIndex","Diag","DiagPart","Digamma","Div","DivNoNan","DynamicStitch","Einsum","Elu","EluGrad","Empty","EmptyTensorList","EnsureShape","Equal","Erf","Erfc","Erfinv","Exp","ExpandDims","Expm1","ExtractImagePatches","FFT","FFT2D","FFT3D","FakeParam","FakeQuantWithMinMaxArgs","FakeQuantWithMinMaxArgsGradient","FakeQuantWithMinMaxVars","FakeQuantWithMinMaxVarsGradient","Fill","Floor","FloorDiv","FloorMod","FusedBatchNorm","FusedBatchNormGrad","FusedBatchNormGradV2","FusedBatchNormGradV3","FusedBatchNormV2","FusedBatchNormV3","Gather","GatherNd","GatherV2","GetItem","Greater","GreaterEqual","HSVToRGB","IFFT","IFFT2D","IFFT3D","IRFFT","IRFFT2D","IRFFT3D","Identity","IdentityN","If","Igamma","IgammaGradA","Igammac","Imag","InTopKV2","InfeedDequeue","InfeedDequeueTuple","InplaceAdd","InplaceUpdate","Inv","Invert","InvertPermutation","IsFinite","IsInf","IsNan","KthOrderStatistic","L2Loss","LRN","LRNGrad","LeakyRelu","LeakyReluGrad","LeftShift","Less","LessEqual","Lgamma","LinSpace","ListDiff","Log","Log1p","LogSoftmax","LogicalAnd","LogicalNot","LogicalOr","LowerBound","MakeUnique","MatMul","MatrixBandPart","MatrixDiag","MatrixDiagPart","MatrixDiagPartV2","MatrixDiagPartV3","MatrixDiagV2","MatrixDiagV3","MatrixInverse","MatrixSetDiag","MatrixSetDiagV2","MatrixSetDiagV3","MatrixSolve","MatrixTriangularSolve","Max","MaxPool","MaxPool3D","MaxPool3DGrad","MaxPool3DGradGrad","MaxPoolGrad","MaxPoolGradGrad","MaxPoolGradGradV2","MaxPoolGradV2","MaxPoolV2","Maximum","Mean","Min","Minimum","MirrorPad","MirrorPadGrad","Mod","Mul","MulNoNan","Multinomial","Ndtri","Neg","NextAfter","NoOp","NonMaxSuppressionV4","NotEqual","OneHot","OnesLike","OutfeedEnqueue","OutfeedEnqueueTuple","Pack","Pad","PadV2","ParallelDynamicStitch","ParameterizedTruncatedNormal","PartitionedCall","PlaceholderWithDefault","Polygamma","PopulationCount","Pow","PreventGradient","Prod","Qr","QuantizeAndDequantizeV2","QuantizeAndDequantizeV3","RFFT","RFFT2D","RFFT3D","RGBToHSV","RandomGammaGrad","RandomShuffle","RandomStandardNormal","RandomUniform","RandomUniformInt","Range","Rank","ReadVariableOp","Real","RealDiv","Reciprocal","ReciprocalGrad","Relu","Relu6","Relu6Grad","ReluGrad","Reshape","ResizeBilinear","ResizeBilinearGrad","ResizeNearestNeighbor","ResizeNearestNeighborGrad","ResourceApplyAdaMax","ResourceApplyAdadelta","ResourceApplyAdagrad","ResourceApplyAdagradDA","ResourceApplyAdagradV2","ResourceApplyAdam","ResourceApplyAddSign","ResourceApplyCenteredRMSProp","ResourceApplyFtrl","ResourceApplyFtrlV2","ResourceApplyGradientDescent","ResourceApplyKerasMomentum","ResourceApplyMomentum","ResourceApplyPowerSign","ResourceApplyProximalAdagrad","ResourceApplyProximalGradientDescent","ResourceApplyRMSProp","ResourceGather","ResourceScatterAdd","ResourceScatterDiv","ResourceScatterMax","ResourceScatterMin","ResourceScatterMul","ResourceScatterNdAdd","ResourceScatterNdSub","ResourceScatterNdUpdate","ResourceScatterSub","ResourceScatterUpdate","ResourceStridedSliceAssign","Reverse","ReverseSequence","ReverseV2","RightShift","Rint","RngReadAndSkip","RngSkip","Roll","Round","Rsqrt","RsqrtGrad","ScatterNd","Select","SelectV2","SelfAdjointEigV2","Selu","SeluGrad","Shape","ShapeN","Sigmoid","SigmoidGrad","Sign","Sin","Sinh","Size","Slice","Snapshot","Softmax","SoftmaxCrossEntropyWithLogits","Softplus","SoftplusGrad","Softsign","SoftsignGrad","SpaceToBatch","SpaceToBatchND","SpaceToDepth","SparseMatMul","SparseSoftmaxCrossEntropyWithLogits","SparseToDense","Split","SplitV","Sqrt","SqrtGrad","Square","SquaredDifference","Squeeze","StackCloseV2","StackPopV2","StackPushV2","StackV2","StatefulPartitionedCall","StatefulStandardNormalV2","StatefulTruncatedNormal","StatefulUniform","StatefulUniformFullInt","StatefulUniformInt","StatelessCase","StatelessIf","StatelessMultinomial","StatelessRandomGetAlg","StatelessRandomGetKeyCounter","StatelessRandomGetKeyCounterAlg","StatelessRandomNormal","StatelessRandomNormalV2","StatelessRandomUniform","StatelessRandomUniformFullInt","StatelessRandomUniformFullIntV2","StatelessRandomUniformInt","StatelessRandomUniformIntV2","StatelessRandomUniformV2","StatelessTruncatedNormal","StatelessTruncatedNormalV2","StatelessWhile","StopGradient","StridedSlice","StridedSliceGrad","Sub","Sum","Svd","SymbolicGradient","TPUEmbeddingActivations","Tan","Tanh","TanhGrad","TensorArrayCloseV3","TensorArrayConcatV3","TensorArrayGatherV3","TensorArrayGradV3","TensorArrayReadV3","TensorArrayScatterV3","TensorArraySizeV3","TensorArraySplitV3","TensorArrayV3","TensorArrayWriteV3","TensorListConcatV2","TensorListElementShape","TensorListFromTensor","TensorListGather","TensorListGetItem","TensorListLength","TensorListPopBack","TensorListPushBack","TensorListReserve","TensorListSetItem","TensorListSplit","TensorListStack","TensorScatterAdd","TensorScatterMax","TensorScatterMin","TensorScatterSub","TensorScatterUpdate","TensorStridedSliceUpdate","Tile","TopKUnique","TopKV2","TopKWithUnique","Transpose","TridiagonalSolve","TruncateDiv","TruncateMod","TruncatedNormal","Unique","Unpack","UnsortedSegmentMax","UnsortedSegmentMin","UnsortedSegmentProd","UnsortedSegmentSum","UpperBound","VarIsInitializedOp","VariableShape","Where","While","Xdivy","XlaBroadcastHelper","XlaConv","XlaConvV2","XlaDequantize","XlaDot","XlaDotV2","XlaDynamicSlice","XlaDynamicUpdateSlice","XlaEinsum","XlaGather","XlaHostCompute","XlaIf","XlaKeyValueSort","XlaPad","XlaRecv","XlaRecvFromHost","XlaReduce","XlaReduceWindow","XlaReplicaId","XlaScatter","XlaSelectAndScatter","XlaSelfAdjointEig","XlaSend","XlaSendToHost","XlaSetBound","XlaSetDynamicDimensionSize","XlaSharding","XlaSort","XlaSpmdFullToShardShape","XlaSpmdShardToFullShape","XlaSvd","XlaVariadicReduce","XlaVariadicSort","XlaWhile","Xlog1py","Xlogy","ZerosLike","Zeta","Enter","Exit","LoopCond","Merge","NextIteration","Switch","_Arg","_ArrayToList","_FusedBatchNormEx","_ListToArray","_ParallelConcatUpdate","_RecvTPUEmbeddingActivations","_RecvTPUEmbeddingDeduplicationData","_Retval","_SendTPUEmbeddingGradients","_TPUCompile","_TPUExecute","_UnaryOpsComposition","TPUCompilationResult","TPUReplicatedInput","TPUReplicatedOutput","TPUReplicateMetadata","MergeV2Checkpoints","RestoreV2","SaveV2","Abort","Assert","Assign","Placeholder","PlaceholderV2","ShardedFilename","StringJoin","Variable","VariableV2","VarHandleOp","AudioSummary","AudioSummaryV2","DebugNumericSummary","HistogramSummary","ImageSummary","MergeSummary","ScalarSummary","StatsAggregatorSummary"];function Zle(e,t){if(t===null)throw new Error("Compatibility provider required, but got: "+t);c3.each(e.nodes,r=>{r.compatible=t.opValid(r),c3.each(r.inEmbeddings,n=>{n.compatible=t.opValid(n)}),c3.each(r.outEmbeddings,n=>{n.compatible=t.opValid(n)})})}var gP=Ee(Oe(),1);var Jle=Ee(Oe(),1);var Il=class extends Gt(mt){constructor(){super(...arguments),this._rawRegexInput="",this._previousRegexInput="",this._searchTimeoutDelay=150,this._maxRegexResults=42}get _regexInput(){var t=this.renderHierarchy,r=this._rawRegexInput;return r.trim()}_regexInputChanged(){var t=this._regexInput;this._requestSearch()}_clearSearchResults(){this.set("_regexMatches",[])}_requestSearch(){if(!this._searchPending){if(this._regexInput===this._previousRegexInput){this._searchPending=!1;return}this._searchPending=!0,this._executeSearch(),this.async(()=>{this._searchPending=!1,this._requestSearch()},this._searchTimeoutDelay)}}_executeSearch(){if(this._previousRegexInput=this._regexInput,!this._regexInput){this._clearSearchResults();return}try{var t=new RegExp(this._regexInput)}catch(i){this._clearSearchResults();return}let r=[],n=this.renderHierarchy.hierarchy.getNodeMap();Jle.each(n,(i,o)=>{if(r.length>=this._maxRegexResults)return!1;!t.test(o)||r.push(o)}),this.set("_regexMatches",r)}_matchClicked(t){let r=t.model.item;this.set("selectedNode",r),Po({actionId:jr.NODE_SEARCH_RESULT_FOCUSED})}};Il.template=Q`
    <div id="search-container">
      <paper-input
        id="runs-regex"
        label="Search nodes (regex)"
        value="{{_rawRegexInput}}"
      >
      </paper-input>
      <div id="search-results-anchor">
        <div id="search-results">
          <template is="dom-repeat" items="[[_regexMatches]]">
            <div id="search-match" on-click="_matchClicked">[[item]]</div>
          </template>
        </div>
      </div>
    </div>
    <style>
      #search-container {
        width: 100%;
        overflow: visible;
      }

      #runs-regex {
        width: 100%;
      }

      #search-results-anchor {
        position: relative;
      }

      #search-results {
        color: #fff;
        position: absolute;
        max-height: 200px;
        overflow-x: hidden;
        overflow-y: auto;
        text-align: right;
        max-width: 100%;
        box-sizing: border-box;
      }

      #search-match {
        background: var(--tb-orange-strong);
        padding: 3px;
        float: right;
        width: 100%;
        box-sizing: border-box;
        direction: rtl;
      }

      #search-match:hover {
        background: var(--tb-orange-weak);
        cursor: pointer;
      }
    </style>
  `;E([A({type:Object}),w("design:type",Object)],Il.prototype,"renderHierarchy",void 0);E([A({type:String,notify:!0}),w("design:type",String)],Il.prototype,"selectedNode",void 0);E([A({type:String}),w("design:type",String)],Il.prototype,"_rawRegexInput",void 0);E([A({type:String}),w("design:type",String)],Il.prototype,"_previousRegexInput",void 0);E([A({type:Number}),w("design:type",Number)],Il.prototype,"_searchTimeoutDelay",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Il.prototype,"_searchPending",void 0);E([A({type:Number}),w("design:type",Number)],Il.prototype,"_maxRegexResults",void 0);E([A({type:Array}),w("design:type",Array)],Il.prototype,"_regexMatches",void 0);E([Rt("renderHierarchy","_rawRegexInput"),w("design:type",String),w("design:paramtypes",[])],Il.prototype,"_regexInput",null);E([Bt("_regexInput"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Il.prototype,"_regexInputChanged",null);Il=E([yt("tf-graph-node-search")],Il);var lct=/device:([^:]+:[0-9]+)$/,sct=[{regex:lct}],Qle=[],uur=new Set([qn.COMPUTE_TIME,qn.MEMORY]),Pn=class extends Gt(_o(mt)){constructor(){super(...arguments),this.ColorBy=qn,this.stats=null,this.devicesForStats=null,this.colorBy=qn.STRUCTURE,this.datasets=[],this._selectedRunIndex=0,this.traceInputs=!1,this.autoExtractNodes=!0,this._selectedTagIndex=0,this._selectedGraphType=Fs.OP_GRAPH,this.showSessionRunsDropdown=!0,this.showUploadButton=!0,this._legendOpened=!0,this._downloadFilename="graph.png"}_onGraphTypeChangedByUserGesture(){Po({actionId:jr.GRAPH_TYPE_CHANGED,eventLabel:this._selectedGraphType})}_onColorByChangedByUserGesture(){Po({actionId:jr.NODE_COLOR_MODE_CHANGED,eventLabel:this.colorBy})}_onTraceInputsChangedByUserGesture(){Po({actionId:jr.TRACE_INPUT_MODE_TOGGLED})}_xlaClustersProvided(t){return t&&t.hierarchy&&t.hierarchy.xlaClusters.length>0}_statsChanged(t){if(t!=null){var r={},n=gP.each(t.dev_stats,function(i){var o=gP.some(sct,function(s){return s.regex.test(i.device)}),a=gP.some(Qle,function(s){return s.regex.test(i.device)});o&&!a&&(r[i.device]=!0)});this.set("devicesForStats",r)}}get _currentDevices(){var t=this.devicesForStats;let r=this.stats,o=(r?r.dev_stats:[]).map(s=>s.device).filter(s=>sct.some(l=>l.regex.test(s))),a=zlt(o);if(a.length==1){let s=a[0].match(lct);s&&(a[0]=s[1])}return o.map((s,l)=>{let c=null;return Qle.forEach(u=>{u.regex.test(s)&&(c=u.msg)}),{device:s,suffix:a[l],used:t==null?void 0:t[s],ignoredMsg:c}})}_deviceCheckboxClicked(t){let r=t.target,n=Object.assign({},this.devicesForStats),i=r.value;r.checked?n[i]=!0:delete n[i],this.set("devicesForStats",n)}_numTags(t,r){return this._getTags(t,r).length}_getTags(t,r){return!t||!t[r]?[]:t[r].tags}_fit(){this.fire("fit-tap")}_isGradientColoring(t,r){return uur.has(r)&&t!=null}_equals(t,r){return t===r}get _currentDeviceParams(){var t=this.colorByParams;let r=t.device.filter(o=>sct.some(a=>a.regex.test(o.device))),n=zlt(r.map(o=>o.device));if(n.length==1){var i=n[0].match(lct);i&&(n[0]=i[1])}return r.map((o,a)=>({device:n[a],color:o.color}))}get _currentXlaClusterParams(){var t=this.colorByParams;return t.xla_cluster}get _currentGradientParams(){var t=this.colorByParams,r=this.colorBy;if(!this._isGradientColoring(this.stats,r))return null;let n=t[r],i=n.minValue,o=n.maxValue;return r===qn.MEMORY?(i=Nd(i,iP),o=Nd(o,iP)):r===qn.COMPUTE_TIME&&(i=Nd(i,oP),o=Nd(o,oP)),{minValue:i,maxValue:o,startColor:n.startColor,endColor:n.endColor}}download(){this.fire("download-image-requested",this._downloadFilename)}_updateFileInput(t){var a;let r=(a=t.target.files)==null?void 0:a[0];if(!r)return;let n=r.name,i=n.lastIndexOf(".");i>=0&&(n=n.substring(0,i));let o=n.lastIndexOf("/");o>=0&&(n=n.substring(o+1)),this._setDownloadFilename(n),this.set("selectedFile",t),Po({actionId:jr.UPLOADED_GRAPH_FROM_FILESYSTEM})}_datasetsChanged(t,r){var n;r!=null&&(this._selectedRunIndex=0),this._setDownloadFilename((n=this.datasets[this._selectedRunIndex])==null?void 0:n.name)}_computeSelection(t,r,n,i){return!t[r]||!t[r].tags[n]?null:{run:t[r].name,tag:t[r].tags[n].tag,type:i}}_selectedRunIndexChanged(t){var r;!this.datasets||(this.colorBy=qn.STRUCTURE,this._selectedTagIndex=0,this._selectedGraphType=this._getDefaultSelectionType(),this.traceInputs=!1,this._setDownloadFilename((r=this.datasets[t])==null?void 0:r.name))}_selectedTagIndexChanged(){this._selectedGraphType=this._getDefaultSelectionType()}_getDefaultSelectionType(){let{datasets:t,_selectedRunIndex:r,_selectedTagIndex:n}=this;if(!t||!t[r]||!t[r].tags[n]||t[r].tags[n].opGraph)return Fs.OP_GRAPH;let i=t[r];return i.tags[n].profile?Fs.PROFILE:i.tags[n].conceptualGraph?Fs.CONCEPTUAL_GRAPH:Fs.OP_GRAPH}_getFile(){this.$$("#file").click()}_setDownloadFilename(t){this._downloadFilename=(t||"graph")+".png"}_statsNotNull(t){return t!==null}_toggleLegendOpen(){this.set("_legendOpened",!this._legendOpened)}_getToggleLegendIcon(t){return t?"expand-more":"expand-less"}_getSelectionOpGraphDisabled(t,r,n){return!t[r]||!t[r].tags[n]||!t[r].tags[n].opGraph}_getSelectionProfileDisabled(t,r,n){return!t[r]||!t[r].tags[n]||!t[r].tags[n].profile}_getSelectionConceptualGraphDisabled(t,r,n){return!t[r]||!t[r].tags[n]||!t[r].tags[n].conceptualGraph}};Pn.template=Q`
    <style>
      :host {
        color: #555;
        display: flex;
        flex-direction: column;
        font-size: 12px;
        width: 100%;
        --tb-graph-controls-title-color: #000;
        --tb-graph-controls-legend-text-color: #000;
        --tb-graph-controls-text-color: #555;
        --tb-graph-controls-title-font-size: 14px;
        --tb-graph-controls-subtitle-font-size: 14px;
        --paper-input-container-shared-input-style_-_font-size: 14px;
        --paper-font-subhead_-_font-size: 14px;
      }

      :host(.dark-mode) {
        --tb-graph-controls-title-color: #fff;
        --tb-graph-controls-legend-text-color: #f3f3f3;
        --tb-graph-controls-text-color: #eee;
      }

      paper-dropdown-menu {
        --paper-dropdown-menu-input: {
          padding: 0;
          color: gray;
        }
        --iron-icon-width: 15px;
        --iron-icon-height: 15px;
        --primary-text-color: gray;
        --paper-item-min-height: 30px;
      }

      paper-button[raised].keyboard-focus {
        font-weight: normal;
      }

      .run-dropdown {
        --paper-input-container: {
          padding: 5px 0 5px 5px;
        }
      }

      table {
        border-collapse: collapse;
        border-spacing: 0;
      }

      table tr {
        height: 20px;
      }

      table td {
        padding: 0;
        margin: 0;
      }

      .allcontrols {
        padding: 0 20px 20px;
        flex-grow: 1;
        overflow-y: auto;
      }

      .legend-holder {
        background: var(--secondary-background-color);
        box-sizing: border-box;
        color: var(--tb-graph-controls-text-color);
        width: 100%;
      }

      .legend-toolbar {
        appearance: none;
        background-color: inherit;
        border-top: 1px solid #ccc;
        border-bottom: 1px solid #ccc;
        border-right: none;
        border-left: none;
        cursor: pointer;
        color: var(--tb-graph-controls-legend-text-color);
        font: inherit;
        display: flex;
        align-items: center;
        justify-content: space-between;
        width: 100%;
      }

      .legend-toolbar,
      .legend-content {
        padding: 8px 20px;
      }

      .toggle-legend-button {
        max-height: 20px;
        max-width: 20px;
        padding: 0;
      }

      .toggle-legend-text {
        font-size: var(--tb-graph-controls-subtitle-font-size);
      }

      paper-radio-button {
        display: block;
        padding: 5px;
      }
      svg.icon,
      tf-graph-icon {
        width: 60px;
        height: 18px;
      }
      .domainValues {
        margin-bottom: 10px;
        width: 165px;
      }
      .domainStart {
        float: left;
      }
      .domainEnd {
        float: right;
      }
      .colorBox {
        width: 20px;
      }

      .image-icon {
        width: 24px;
        height: 24px;
      }

      .help-icon {
        height: 15px;
        margin: 0;
        padding: 0;
      }

      .gray {
        color: #666;
      }

      .title {
        font-size: var(--tb-graph-controls-title-font-size);
        margin: 8px 5px 8px 0;
        color: var(--tb-graph-controls-title-color);
      }
      .title small {
        font-weight: normal;
      }
      .deviceList,
      .xlaClusterList {
        max-height: 200px;
        overflow-y: auto;
      }

      #file {
        padding: 8px 0;
      }

      .color-legend-row {
        align-items: center;
        clear: both;
        display: flex;
        height: 20px;
        margin-top: 5px;
      }

      .color-legend-row .label,
      .color-legend-row svg,
      .color-legend-row tf-graph-icon {
        flex: 0 0 40px;
        margin-right: 20px;
      }

      .devices-checkbox input {
        text-align: left;
        vertical-align: middle;
      }

      .control-holder .icon-button {
        font-size: var(--tb-graph-controls-subtitle-font-size);
        margin: 0 -5px;
        padding: 5px;
        display: flex;
        justify-content: flex-start;
        color: var(--tb-graph-controls-text-color);
      }

      .button-text {
        padding-left: 20px;
        text-transform: none;
      }

      .upload-button {
        width: 165px;
        height: 25px;
        text-transform: none;
        margin-top: 4px;
      }

      .button-icon {
        width: 26px;
        height: 26px;
        color: var(--paper-orange-500);
      }

      .hidden-input {
        display: none;
      }

      .allcontrols .control-holder {
        clear: both;
        display: flex;
        justify-content: space-between;
      }

      .allcontrols .control-holder.control-options {
        padding: 0 0 15px 15px;
        flex-direction: column;
      }

      .allcontrols .control-holder paper-toggle-button {
        margin-bottom: 5px;
      }

      span.counter {
        font-size: var(--tb-graph-controls-subtitle-font-size);
        color: gray;
        margin-left: 4px;
      }

      .runs-row .title,
      .tags-row .title {
        display: flex;
        align-items: baseline;
      }

      .runs-row paper-item,
      .tags-row paper-item {
        --paper-item: {
          white-space: nowrap;
        }
      }

      table.control-holder {
        border: 0;
        border-collapse: collapse;
      }

      table.tf-graph-controls td.input-element-table-data {
        padding: 0 0 0 20px;
      }

      .spacer {
        flex-grow: 1;
      }

      .color-text {
        overflow: hidden;
      }

      .color-text.gradient-container {
        margin: 0 5px;
      }

      /** Override inline styles that suppress pointer events for disabled buttons. Otherwise, the */
      /*  tooltips do not appear. */
      paper-radio-group paper-radio-button {
        pointer-events: auto !important;
      }

      .legend-clarifier {
        color: #266236;
        cursor: help;
        display: inline-block;
        text-decoration: underline;
      }

      .legend-clarifier paper-tooltip {
        width: 150px;
      }

      /** Otherwise, polymer UI controls appear atop node search. */
      tf-graph-node-search {
        z-index: 1;
        width: 100%;
      }

      paper-dropdown-menu {
        flex-grow: 1;
      }
    </style>

    <div class="allcontrols">
      <div class="control-holder">
        <tf-graph-node-search
          selected-node="{{selectedNode}}"
          render-hierarchy="[[renderHierarchy]]"
        ></tf-graph-node-search>
      </div>
      <div class="control-holder">
        <paper-button class="icon-button" on-tap="_fit" alt="Fit to screen">
          <iron-icon icon="aspect-ratio" class="button-icon"></iron-icon>
          <span class="button-text">Fit to screen</span>
        </paper-button>
      </div>
      <div class="control-holder">
        <paper-button
          class="icon-button"
          on-click="download"
          alt="Download PNG"
        >
          <iron-icon icon="file-download" class="button-icon"></iron-icon>
          <span class="button-text">Download PNG</span>
        </paper-button>
      </div>
      <template is="dom-if" if="[[showUploadButton]]">
        <div class="control-holder">
          <paper-button
            class="icon-button"
            on-click="_getFile"
            alt="Upload file"
            title="Upload a pbtxt file to view a graph from the local filesystem"
          >
            <iron-icon icon="file-upload" class="button-icon"></iron-icon>
            <span class="button-text">Upload file</span>
          </paper-button>

          <div class="hidden-input">
            <input
              type="file"
              id="file"
              name="file"
              on-change="_updateFileInput"
              accept=".pbtxt"
            />
          </div>
        </div>
      </template>
      <div class="control-holder runs-row">
        <div class="title">
          Run <span class="counter">([[datasets.length]])</span>
        </div>
        <paper-dropdown-menu
          no-label-float
          no-animations
          noink
          horizontal-align="left"
          class="run-dropdown"
        >
          <paper-listbox
            class="dropdown-content"
            selected="{{_selectedRunIndex}}"
            slot="dropdown-content"
          >
            <template is="dom-repeat" items="[[datasets]]">
              <paper-item>[[item.name]]</paper-item>
            </template>
          </paper-listbox>
        </paper-dropdown-menu>
      </div>
      <template is="dom-if" if="[[showSessionRunsDropdown]]">
        <div class="control-holder tags-row">
          <div class="title">
            Tag
            <span class="counter"
              >([[_numTags(datasets, _selectedRunIndex)]])</span
            >
          </div>
          <paper-dropdown-menu
            no-label-float
            no-animations
            horizontal-align="left"
            noink
            class="run-dropdown"
          >
            <paper-listbox
              class="dropdown-content"
              selected="{{_selectedTagIndex}}"
              slot="dropdown-content"
            >
              <template
                is="dom-repeat"
                items="[[_getTags(datasets, _selectedRunIndex)]]"
              >
                <paper-item>[[item.displayName]]</paper-item>
              </template>
            </paper-listbox>
          </paper-dropdown-menu>
        </div>
      </template>
      <div class="title">Graph type</div>
      <div class="control-holder control-options">
        <paper-radio-group
          selected="{{_selectedGraphType}}"
          on-paper-radio-group-changed="_onGraphTypeChangedByUserGesture"
        >
          <!-- Note that the name has to match that of tf_graph_common.SelectionType. -->
          <paper-radio-button
            name="op_graph"
            disabled="[[_getSelectionOpGraphDisabled(datasets, _selectedRunIndex, _selectedTagIndex)]]"
            >Op graph</paper-radio-button
          >
          <paper-radio-button
            name="conceptual_graph"
            disabled="[[_getSelectionConceptualGraphDisabled(datasets, _selectedRunIndex, _selectedTagIndex)]]"
            >Conceptual graph</paper-radio-button
          >
          <paper-radio-button
            name="profile"
            disabled="[[_getSelectionProfileDisabled(datasets, _selectedRunIndex, _selectedTagIndex)]]"
            >Profile</paper-radio-button
          >
        </paper-radio-group>
      </div>
      <div class="title">Node options</div>
      <div class="control-holder control-options">
        <paper-toggle-button
          checked="{{traceInputs}}"
          on-change="_onTraceInputsChangedByUserGesture"
        >
          Trace inputs
        </paper-toggle-button>
        <paper-toggle-button checked="{{autoExtractNodes}}">
          Auto-extract high-degree nodes
        </paper-toggle-button>
      </div>
      <template is="dom-if" if="[[healthPillsFeatureEnabled]]">
        <div class="control-holder">
          <paper-toggle-button checked="{{healthPillsToggledOn}}"
            >Show health pills</paper-toggle-button
          >
        </div>
      </template>
      <div class="title">Color by</div>
      <div class="control-holder control-options">
        <paper-radio-group
          selected="{{colorBy}}"
          on-paper-radio-group-changed="_onColorByChangedByUserGesture"
        >
          <paper-radio-button name="[[ColorBy.NONE]]">None</paper-radio-button>

          <paper-radio-button name="[[ColorBy.STRUCTURE]]"
            >Structure</paper-radio-button
          >

          <paper-radio-button name="[[ColorBy.DEVICE]]"
            >Device</paper-radio-button
          >

          <paper-radio-button
            id="xla-cluster-radio-button"
            name="[[ColorBy.XLA_CLUSTER]]"
            disabled="[[!_xlaClustersProvided(renderHierarchy)]]"
          >
            XLA cluster
          </paper-radio-button>
          <paper-tooltip
            animation-delay="0"
            for="xla-cluster-radio-button"
            position="right"
            offset="0"
          >
            Coloring by XLA cluster is only enabled if at least 1 op specifies
            an XLA cluster.
          </paper-tooltip>

          <paper-radio-button
            id="compute-time-radio-button"
            name="[[ColorBy.COMPUTE_TIME]]"
            disabled="[[!stats]]"
          >
            Compute time
          </paper-radio-button>
          <paper-tooltip
            animation-delay="0"
            for="compute-time-radio-button"
            position="right"
            offset="0"
          >
            Coloring by compute time is only enabled if the RunMetadata proto is
            passed to the FileWriter when a specific session is run.
          </paper-tooltip>

          <paper-radio-button
            id="memory-radio-button"
            name="[[ColorBy.MEMORY]]"
            disabled="[[!stats]]"
          >
            Memory
          </paper-radio-button>
          <paper-tooltip
            animation-delay="0"
            for="memory-radio-button"
            position="right"
            offset="0"
          >
            Coloring by memory is only enabled if the RunMetadata proto is
            passed to the FileWriter when a specific session is run.
          </paper-tooltip>

          <paper-radio-button
            id="tpu-compatibility-radio-button"
            name="[[ColorBy.OP_COMPATIBILITY]]"
          >
            TPU compatibility
          </paper-radio-button>
          <paper-tooltip
            animation-delay="0"
            for="tpu-compatibility-radio-button"
            position="right"
            offset="0"
          >
            Coloring by whether an operation is compatible for the TPU device.
          </paper-tooltip>
        </paper-radio-group>
        <span class="spacer"></span>
      </div>
    </div>
    <div class="legend-holder">
      <button class="legend-toolbar" on-click="_toggleLegendOpen">
        <span class="toggle-legend-text">Legend</span>
        <iron-icon
          icon="[[_getToggleLegendIcon(_legendOpened)]]"
          class="toggle-legend-button"
        >
        </iron-icon>
      </button>
      <iron-collapse opened="[[_legendOpened]]" class="legend-content">
        <!-- Color-mode-specific legend items -->
        <div>
          <template is="dom-if" if="[[_isGradientColoring(stats, colorBy)]]">
            <svg width="140" height="20" class="color-text gradient-container">
              <defs>
                <linearGradient
                  id="linearGradient"
                  x1="0%"
                  y1="0%"
                  x2="100%"
                  y2="0%"
                >
                  <stop
                    class="start"
                    offset="0%"
                    stop-color$="[[_currentGradientParams.startColor]]"
                  ></stop>
                  <stop
                    class="end"
                    offset="100%"
                    stop-color$="[[_currentGradientParams.endColor]]"
                  ></stop>
                </linearGradient>
              </defs>
              <rect
                x="0"
                y="0"
                width="135"
                height="20"
                fill="url(#linearGradient)"
                stroke="black"
              ></rect>
            </svg>
            <div class="domainValues color-text">
              <div class="domainStart">[[_currentGradientParams.minValue]]</div>
              <div class="domainEnd">[[_currentGradientParams.maxValue]]</div>
            </div>
            <br style="clear: both" />
            <div>Devices included in stats:</div>
            <div class="deviceList">
              <template is="dom-repeat" items="[[_currentDevices]]">
                <div class="color-legend-row devices-checkbox">
                  <span
                    ><input
                      type="checkbox"
                      value$="[[item.device]]"
                      checked$="[[item.used]]"
                      on-click="_deviceCheckboxClicked"
                  /></span>
                  <span>[[item.suffix]]</span>
                  <template is="dom-if" if="[[item.ignoredMsg]]">
                    <paper-icon-button
                      icon="help"
                      class="help-icon"
                    ></paper-icon-button>
                    <paper-tooltip
                      position="right"
                      offset="0"
                      animation-delay="0"
                      >[[item.ignoredMsg]]</paper-tooltip
                    >
                  </template>
                </div>
              </template>
            </div>
          </template>
          <template is="dom-if" if="[[_equals(colorBy, 'structure')]]">
            <div class="color-text">
              <div class="color-legend-row">
                <span class="label"> colors </span>
                <span class="color-legend-value">same substructure</span>
              </div>
              <div class="color-legend-row">
                <tf-graph-icon
                  type="META"
                  height="16"
                  fill-override="#eee"
                  stroke-override="#a6a6a6"
                ></tf-graph-icon>
                <span class="color-legend-value">unique substructure</span>
              </div>
            </div>
          </template>
          <template is="dom-if" if="[[_equals(colorBy, 'device')]]">
            <div>
              <template is="dom-repeat" items="[[_currentDeviceParams]]">
                <div class="color-legend-row">
                  <tf-graph-icon
                    type="META"
                    height="16"
                    fill-override="[[item.color]]"
                    stroke-override="#a6a6a6"
                  ></tf-graph-icon>
                  <span class="color-legend-value">[[item.device]]</span>
                </div>
              </template>
              <div class="color-legend-row">
                <tf-graph-icon
                  type="META"
                  height="16"
                  fill-override="#eee"
                  stroke-override="#a6a6a6"
                ></tf-graph-icon>
                <span class="color-legend-value">unknown device</span>
              </div>
            </div>
          </template>
          <template is="dom-if" if="[[_equals(colorBy, 'xla_cluster')]]">
            <div>
              <template is="dom-repeat" items="[[_currentXlaClusterParams]]">
                <div class="color-legend-row">
                  <svg>
                    <use
                      xmlns:xlink="http://www.w3.org/1999/xlink"
                      xlink:href="#unfilled-rect"
                      x="0"
                      y="0"
                      style="fill:[[item.color]]"
                    ></use>
                  </svg>
                  <span class="color-legend-value">[[item.xla_cluster]]</span>
                </div>
              </template>
              <div class="color-legend-row">
                <svg>
                  <use
                    xmlns:xlink="http://www.w3.org/1999/xlink"
                    xlink:href="#grey-rect"
                    x="0"
                    y="0"
                  ></use>
                </svg>
                <span class="color-legend-value">unknown XLA cluster</span>
              </div>
            </div>
          </template>
          <template is="dom-if" if="[[_equals(colorBy, 'op_compatibility')]]">
            <div class="color-text">
              <div class="color-legend-row">
                <tf-graph-icon
                  type="OP"
                  height="16"
                  fill-override="#0f9d58"
                  stroke-override="#ccc"
                ></tf-graph-icon>
                <span class="color-legend-value">Valid Op</span>
              </div>
              <div class="color-legend-row">
                <tf-graph-icon
                  type="OP"
                  height="16"
                  fill-override="#db4437"
                  stroke-override="#ccc"
                ></tf-graph-icon>
                <span class="color-legend-value">Invalid Op</span>
              </div>
            </div>
          </template>
          <template is="dom-if" if="[[_statsNotNull(stats)]]">
            <div class="color-legend-row">
              <tf-graph-icon type="META" height="16" faded></tf-graph-icon>
              <span class="color-legend-value">unused substructure</span>
            </div>
          </template>
        </div>

        <!-- Common legend items -->
        <div>
          <table>
            <tbody>
              <tr>
                <td></td>
                <td>(* = expandable)</td>
              </tr>
              <tr>
                <td>
                  <tf-graph-icon
                    type="META"
                    height="16"
                    fill-override="#d9d9d9"
                    stroke-override="#ccc"
                  ></tf-graph-icon>
                </td>
                <td>
                  Namespace<span class="gray">*</span>
                  <div class="legend-clarifier">
                    <span>?</span>
                    <paper-tooltip
                      animation-delay="0"
                      position="right"
                      offset="0"
                    >
                      Encapsulates a set of nodes. Namespace is hierarchical and
                      based on scope.
                    </paper-tooltip>
                  </div>
                </td>
              </tr>
              <tr>
                <td>
                  <tf-graph-icon type="OP" height="16"></tf-graph-icon>
                </td>
                <td>
                  OpNode
                  <div class="legend-clarifier">
                    <span>?</span>
                    <paper-tooltip
                      animation-delay="0"
                      position="right"
                      offset="0"
                    >
                      Node that performs an operation. These nodes cannot
                      expand.
                    </paper-tooltip>
                  </div>
                </td>
              </tr>
              <tr>
                <td>
                  <tf-graph-icon type="SERIES" height="16"></tf-graph-icon>
                </td>
                <td>
                  Unconnected series<span class="gray">*</span>
                  <div class="legend-clarifier">
                    <span>?</span>
                    <paper-tooltip
                      animation-delay="0"
                      position="right"
                      offset="0"
                    >
                      Sequence of numbered nodes that are not connected to each
                      other.
                    </paper-tooltip>
                  </div>
                </td>
              </tr>
              <tr>
                <td>
                  <tf-graph-icon
                    type="SERIES"
                    height="16"
                    vertical
                  ></tf-graph-icon>
                </td>
                <td>
                  Connected series<span class="gray">*</span>
                  <div class="legend-clarifier">
                    <span>?</span>
                    <paper-tooltip
                      animation-delay="0"
                      position="right"
                      offset="0"
                    >
                      Sequence of numbered nodes that are connected to each
                      other.
                    </paper-tooltip>
                  </div>
                </td>
              </tr>
              <tr>
                <td>
                  <svg class="icon">
                    <circle
                      fill="white"
                      stroke="#848484"
                      cx="10"
                      cy="10"
                      r="5"
                    ></circle>
                  </svg>
                </td>
                <td>
                  Constant
                  <div class="legend-clarifier">
                    <span>?</span>
                    <paper-tooltip
                      animation-delay="0"
                      position="right"
                      offset="0"
                    >
                      Node that outputs a constant value.
                    </paper-tooltip>
                  </div>
                </td>
              </tr>
              <tr>
                <td>
                  <tf-graph-icon type="SUMMARY" height="20"></tf-graph-icon>
                </td>
                <td>
                  Summary
                  <div class="legend-clarifier">
                    <span>?</span>
                    <paper-tooltip
                      animation-delay="0"
                      position="right"
                      offset="0"
                    >
                      Node that collects data for visualization within
                      TensorBoard.
                    </paper-tooltip>
                  </div>
                </td>
              </tr>
              <tr>
                <td>
                  <svg
                    class="icon"
                    height="15px"
                    preserveAspectRatio="xMinYMid meet"
                    viewBox="0 0 15 15"
                  >
                    <defs>
                      <marker
                        id="dataflow-arrowhead-legend"
                        fill="#bbb"
                        markerWidth="10"
                        markerHeight="10"
                        refX="9"
                        refY="5"
                        orient="auto-start-reverse"
                      >
                        <path d="M 0,0 L 10,5 L 0,10 C 3,7 3,3 0,0"></path>
                      </marker>
                    </defs>
                    <path
                      marker-end="url(#dataflow-arrowhead-legend)"
                      stroke="#bbb"
                      d="M2 9 l 29 0"
                      stroke-linecap="round"
                    ></path>
                  </svg>
                </td>
                <td>
                  Dataflow edge
                  <div class="legend-clarifier">
                    <span>?</span>
                    <paper-tooltip
                      animation-delay="0"
                      position="right"
                      offset="0"
                    >
                      Edge showing the data flow between operations. Edges flow
                      upwards unless arrowheads specify otherwise.
                    </paper-tooltip>
                  </div>
                </td>
              </tr>
              <tr>
                <td>
                  <svg
                    class="icon"
                    height="15px"
                    preserveAspectRatio="xMinYMid meet"
                    viewBox="0 0 15 15"
                  >
                    <path
                      stroke="#bbb"
                      d="M2 9 l 29 0"
                      stroke-linecap="round"
                      stroke-dasharray="2, 2"
                    ></path>
                  </svg>
                </td>
                <td>
                  Control dependency edge
                  <div class="legend-clarifier">
                    <span>?</span>
                    <paper-tooltip
                      animation-delay="0"
                      position="right"
                      offset="0"
                    >
                      Edge showing the control dependency between operations.
                    </paper-tooltip>
                  </div>
                </td>
              </tr>
              <tr>
                <td>
                  <svg
                    class="icon"
                    height="15px"
                    preserveAspectRatio="xMinYMid meet"
                    viewBox="0 0 15 15"
                  >
                    <defs>
                      <marker
                        id="reference-arrowhead-legend"
                        fill="#FFB74D"
                        markerWidth="10"
                        markerHeight="10"
                        refX="9"
                        refY="5"
                        orient="auto-start-reverse"
                      >
                        <path d="M 0,0 L 10,5 L 0,10 C 3,7 3,3 0,0"></path>
                      </marker>
                    </defs>
                    <path
                      marker-end="url(#reference-arrowhead-legend)"
                      stroke="#FFB74D"
                      d="M2 9 l 29 0"
                      stroke-linecap="round"
                    ></path>
                  </svg>
                </td>
                <td>
                  Reference edge
                  <div class="legend-clarifier">
                    <span>?</span>
                    <paper-tooltip
                      animation-delay="0"
                      position="right"
                      offset="0"
                    >
                      Edge showing that the outgoing operation node can mutate
                      the incoming tensor.
                    </paper-tooltip>
                  </div>
                </td>
              </tr>
            </tbody>
          </table>
        </div>
      </iron-collapse>
    </div>
  `;E([A({type:Object,observer:"_statsChanged"}),w("design:type",Object)],Pn.prototype,"stats",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],Pn.prototype,"devicesForStats",void 0);E([A({type:String,notify:!0}),w("design:type",String)],Pn.prototype,"colorBy",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],Pn.prototype,"colorByParams",void 0);E([A({type:Array,observer:"_datasetsChanged"}),w("design:type",Object)],Pn.prototype,"datasets",void 0);E([A({type:Object}),w("design:type",lo)],Pn.prototype,"renderHierarchy",void 0);E([A({type:Object,notify:!0,readOnly:!0,computed:"_computeSelection(datasets, _selectedRunIndex, _selectedTagIndex, _selectedGraphType)"}),w("design:type",Object)],Pn.prototype,"selection",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],Pn.prototype,"selectedFile",void 0);E([A({type:Number,observer:"_selectedRunIndexChanged"}),w("design:type",Number)],Pn.prototype,"_selectedRunIndex",void 0);E([A({type:Boolean,notify:!0}),w("design:type",Boolean)],Pn.prototype,"traceInputs",void 0);E([A({type:Boolean,notify:!0}),w("design:type",Boolean)],Pn.prototype,"autoExtractNodes",void 0);E([A({type:Number,observer:"_selectedTagIndexChanged"}),w("design:type",Number)],Pn.prototype,"_selectedTagIndex",void 0);E([A({type:String}),w("design:type",String)],Pn.prototype,"_selectedGraphType",void 0);E([A({type:String,notify:!0}),w("design:type",String)],Pn.prototype,"selectedNode",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Pn.prototype,"showSessionRunsDropdown",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Pn.prototype,"showUploadButton",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Pn.prototype,"healthPillsFeatureEnabled",void 0);E([A({type:Boolean,notify:!0}),w("design:type",Boolean)],Pn.prototype,"healthPillsToggledOn",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Pn.prototype,"_legendOpened",void 0);E([Rt("devicesForStats"),w("design:type",Array),w("design:paramtypes",[])],Pn.prototype,"_currentDevices",null);E([Rt("colorByParams"),w("design:type",Array),w("design:paramtypes",[])],Pn.prototype,"_currentDeviceParams",null);E([Rt("colorByParams"),w("design:type",Array),w("design:paramtypes",[])],Pn.prototype,"_currentXlaClusterParams",null);E([Rt("colorByParams","colorBy"),w("design:type",Object),w("design:paramtypes",[])],Pn.prototype,"_currentGradientParams",null);Pn=E([yt("tf-graph-controls")],Pn);function hur(e){if(e==="true")return!0;if(e==="false")return!1;if(e[0]==='"')return e.substring(1,e.length-1);let r=parseFloat(e);return isNaN(r)?e:r}function tce(e){return new Promise((t,r)=>{fetch(e).then(n=>{n.ok?n.arrayBuffer().then(t,r):n.text().then(r,r)})})}function ece(e,t){return Zse("Reading metadata pbtxt",40,()=>e==null?Promise.resolve(null):tce(e),t,jr.FETCH_METADATA_PBTXT_BYTES).then(r=>mH("Parsing metadata.pbtxt",60,()=>r!=null?gur(r):Promise.resolve(null),t,jr.PARSE_METADATA_PBTXT_INTO_OBJECT))}function rce(e,t,r){return mH("Reading graph pbtxt",40,()=>Ri(this,null,function*(){let n=Date.now();if(t){let o=yield new Promise(function(a,s){let l=new FileReader;l.onload=()=>a(l.result),l.onerror=()=>s(l.error),l.readAsArrayBuffer(t)});return Po({timingId:jr.FETCH_PBTXT_BYTES_FROM_FILESYSTEM,eventValue:Date.now()-n}),o}let i=yield tce(e);return Po({timingId:jr.FETCH_PBTXT_BYTES_FROM_SERVER,eventValue:Date.now()-n}),i}),r,jr.FETCH_PBTXT_BYTES).then(n=>mH("Parsing graph.pbtxt",60,()=>mur(n),r,jr.PARSE_PBTXT_INTO_OBJECT))}function fur(e,t,r=1e6,n=`
`){return new Promise(function(i,o){function a(s,l,c){let u=c>=e.byteLength,h=l.split(n);h[0]=s+h[0];let f=u?"":h.pop();for(let g of h)try{t(g)}catch(_){o(_);return}if(u){i(!0);return}let p=new Blob([e.slice(c,c+r)]),d=new FileReader;d.onload=function(g){a(f,g.target.result,c+r)},d.readAsText(p)}a("","",0)})}var pur={"library.function":!0,"library.function.node_def":!0,"library.function.node_def.input":!0,"library.function.node_def.attr":!0,"library.function.node_def.attr.value.list.b":!0,"library.function.node_def.attr.value.list.f":!0,"library.function.node_def.attr.value.list.func":!0,"library.function.node_def.attr.value.list.i":!0,"library.function.node_def.attr.value.list.s":!0,"library.function.node_def.attr.value.list.shape":!0,"library.function.node_def.attr.value.list.shape.dim":!0,"library.function.node_def.attr.value.list.tensor":!0,"library.function.node_def.attr.value.list.type":!0,"library.function.node_def.attr.value.shape.dim":!0,"library.function.node_def.attr.value.tensor.string_val":!0,"library.function.node_def.attr.value.tensor.tensor_shape.dim":!0,"library.function.signature.input_arg":!0,"library.function.signature.output_arg":!0,"library.versions":!0,node:!0,"node.input":!0,"node.attr":!0,"node.attr.value.list.b":!0,"node.attr.value.list.f":!0,"node.attr.value.list.func":!0,"node.attr.value.list.i":!0,"node.attr.value.list.s":!0,"node.attr.value.list.shape":!0,"node.attr.value.list.shape.dim":!0,"node.attr.value.list.tensor":!0,"node.attr.value.list.type":!0,"node.attr.value.shape.dim":!0,"node.attr.value.tensor.string_val":!0,"node.attr.value.tensor.tensor_shape.dim":!0},dur={"step_stats.dev_stats":!0,"step_stats.dev_stats.node_stats":!0,"step_stats.dev_stats.node_stats.output":!0,"step_stats.dev_stats.node_stats.memory":!0,"step_stats.dev_stats.node_stats.output.tensor_description.shape.dim":!0};function mur(e){return nce(e,pur)}function gur(e){return nce(e,dur).then(t=>t.step_stats)}function nce(e,t){let r={},n=[],i=[],o=r;function a(l){let c=l.indexOf(":"),u=l.substring(0,c).trim(),h=hur(l.substring(c+2).trim());return{name:u,value:h}}function s(l,c,u,h){let f=l[c];f==null?l[c]=h.join(".")in t?[u]:u:Array.isArray(f)?f.push(u):l[c]=[f,u]}return fur(e,function(l){if(l=l.trim(),!!l)switch(l[l.length-1]){case"{":let c=l.substring(0,l.length-2).trim(),u={};n.push(o),i.push(c),s(o,c,u,i),o=u;break;case"}":o=n.pop(),i.pop();break;default:let h=a(l);s(o,h.name,h.value,i.concat(h.name));break}}).then(function(){return r})}function oce(e,t,r,n=new Ju,i=r3){let o=JS(e,30,"Data"),a=JS(e,20,"Graph"),s=JS(e,50,"Namespace hierarchy"),l=Date.now();return rce(t,r,o).then(function(c){if(!c.node)throw new Error("The graph is empty. This can happen when TensorFlow could not trace any graph. Please refer to https://github.com/tensorflow/tensorboard/issues/1961 for more information.");return lle(c,sle,a)},()=>{throw new Error("Malformed GraphDef. This can sometimes be caused by a bad network connection or difficulty reconciling multiple GraphDefs; for the latter case, please refer to https://github.com/tensorflow/tensorboard/issues/1929.")}).then(c=>Ri(this,null,function*(){Zle(c,n);let u=yield bH(c,i,s);return Po({timingId:jr.GRAPH_LOAD_SUCCEEDED,eventValue:Date.now()-l}),{graph:c,graphHierarchy:u}})).catch(c=>{let u=`Graph visualization failed.

${c}`;throw e.reportError(u,c),Po({timingId:jr.GRAPH_LOAD_FAILED,eventValue:Date.now()-l}),c})}var Hs=class extends Gt(mt){constructor(){super(...arguments),this.compatibilityProvider=new Ju,this.hierarchyParams=r3,this._template=null}_selectionChanged(){!this.selection||this.debounce("selectionchange",()=>{this._load(this.selection)})}_load(t){let{run:r,tag:n,type:i}=t;switch(i){case Fs.OP_GRAPH:case Fs.CONCEPTUAL_GRAPH:{(function(){this._setOutStats(null)}).bind(this)();let o=new URLSearchParams;o.set("run",r),o.set("conceptual",String(i===Fs.CONCEPTUAL_GRAPH)),n&&o.set("tag",n);let a=_e().pluginRouteForSrc("graphs","/graph",o);return this._fetchAndConstructHierarchicalGraph(a).then(()=>{this._graphRunTag={run:r,tag:n}})}case Fs.PROFILE:{let{tags:o}=this.datasets.find(({name:f})=>f===r),s=o.find(f=>f.tag===n).opGraph?n:null;console.assert(o.find(f=>f.tag===s),`Required tag (${s}) is missing.`);let c=!this._graphRunTag||this._graphRunTag.run!==r||this._graphRunTag.tag!==s?this._load({run:r,tag:s,type:Fs.OP_GRAPH}):Promise.resolve(),u=new URLSearchParams;u.set("tag",n),u.set("run",r);let h=_e().pluginRouteForSrc("graphs","/run_metadata",u);return c.then(()=>this._readAndParseMetadata(h))}default:return Promise.reject(new Error(`Unknown selection type: ${i}`))}}_readAndParseMetadata(t){this.set("progress",{value:0,msg:""});var r=nP(this);ece(t,r).then(function(n){this._setOutStats(n)}.bind(this))}_fetchAndConstructHierarchicalGraph(t,r){this.set("progress",{value:0,msg:""});let n=nP(this);return oce(n,t,r!==void 0?r:null,this.compatibilityProvider,this.hierarchyParams).then(function({graph:i,graphHierarchy:o}){this._setOutGraph(i),this._setOutGraphHierarchy(o)}.bind(this))}_selectedFileChanged(){var i;var t=this.selectedFile;if(!t)return;let r=t.target,n=(i=r.files)==null?void 0:i[0];!n||(r.value="",this._fetchAndConstructHierarchicalGraph(null,n))}};E([A({type:Array}),w("design:type",Array)],Hs.prototype,"datasets",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],Hs.prototype,"progress",void 0);E([A({type:Object}),w("design:type",Object)],Hs.prototype,"selection",void 0);E([A({type:Object}),w("design:type",Object)],Hs.prototype,"selectedFile",void 0);E([A({type:Object}),w("design:type",Object)],Hs.prototype,"compatibilityProvider",void 0);E([A({type:Object}),w("design:type",Object)],Hs.prototype,"hierarchyParams",void 0);E([A({type:Object,readOnly:!0,notify:!0}),w("design:type",os)],Hs.prototype,"outGraphHierarchy",void 0);E([A({type:Object,readOnly:!0,notify:!0}),w("design:type",Xu)],Hs.prototype,"outGraph",void 0);E([A({type:Object,readOnly:!0,notify:!0}),w("design:type",Object)],Hs.prototype,"outStats",void 0);E([A({type:Object}),w("design:type",Object)],Hs.prototype,"_graphRunTag",void 0);E([Bt("selection","compatibilityProvider"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Hs.prototype,"_selectionChanged",null);E([Bt("selectedFile","compatibilityProvider"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Hs.prototype,"_selectedFileChanged",null);Hs=E([yt("tf-graph-dashboard-loader")],Hs);var ace="run";var Or=class extends Gt(mt){constructor(){super(...arguments),this._datasets=[],this._datasetsFetched=!1,this._selectedDataset=0,this._requestManager=new Ae,this._canceller=new an,this.specificHealthPillStep=0,this.healthPillsToggledOn=!1,this._debuggerNumericAlerts=[],this._nodeNamesToHealthPills={},this._healthPillRequestId=1,this._healthPillStepRequestTimerDelay=500,this.run=y_(ace,{defaultValue:"",useLocalStorage:!1}).call(this),this._runObserver=v_(ace,{defaultValue:"",polymerProperty:"run",useLocalStorage:!1})}attached(){this.set("_isAttached",!0)}detached(){this.set("_isAttached",!1)}ready(){super.ready(),this.addEventListener("node-toggle-expand",this._handleNodeToggleExpand.bind(this))}reload(){this._debuggerDataEnabled||this._requestManager.request(_e().pluginsListing()).then(this._canceller.cancellable(t=>{t.cancelled||t.value.debugger&&this.set("_debuggerDataEnabled",!0)})),this._maybeFetchHealthPills()}_fit(){this.$$("#graphboard").fit()}_onDownloadImageRequested(t){this.$$("#graphboard").downloadAsImage(t.detail)}_getGraphDisplayClassName(t,r){return t||r.length?"":"no-graph"}_fetchDataset(){return this._requestManager.request(_e().pluginRoute("graphs","/info"))}_fetchHealthPills(t,r){let n={node_names:JSON.stringify(t),run:"__debugger_data__"};r!==void 0&&(n.step=r);let i=_e().pluginRoute("debugger","/health_pills");return this._requestManager.request(i,n)}_fetchDebuggerNumericsAlerts(){return this._requestManager.request(_e().pluginRoute("debugger","/numerics_alert_report"))}_graphUrl(t,r,n){return _e().pluginRouteForSrc("graphs","/graph",new URLSearchParams({run:t,limit_attr_size:r,large_attrs_key:n}))}_shouldRequestHealthPills(){return this._debuggerDataEnabled&&this.healthPillsToggledOn&&this._renderHierarchy&&this._datasetsState(this._datasetsFetched,this._datasets,"PRESENT")}_maybeInitializeDashboard(){var t=this._isAttached;this._initialized||!t||(this.set("_compatibilityProvider",new Ju),this._initialized=!0,this._fetchDataset().then(r=>{let n=Object.keys(r);this._datasets=n.sort(xh).map(i=>{let o=r[i],s=Object.keys(o.tags).sort(xh).map(c=>o.tags[c]).map(({tag:c,conceptual_graph:u,op_graph:h,profile:f})=>({tag:c,displayName:c,conceptualGraph:u,opGraph:h,profile:f})),l=o.run_graph?[{tag:null,displayName:"Default",conceptualGraph:!1,opGraph:!0,profile:!1},...s]:s;return{name:i,tags:l}}),this._datasetsFetched=!0}))}_determineSelectedDataset(){var t=this._datasetsFetched,r=this._datasets,n=this.run;if(!n){this.set("_selectedDataset",0);return}let i=r.findIndex(o=>o.name===n);if(i===-1){if(t){let o=this.$$("#error-dialog");o.textContent=`No dataset named "${n}" could be found.`,o.open()}return}this.set("_selectedDataset",i)}_updateSelectedDatasetName(){var t=this._datasetsFetched,r=this._datasets,n=this._selectedDataset;!t||r.length<=n||this.set("run",r[n].name)}_requestHealthPills(){this.set("_areHealthPillsLoading",!0);var t=++this._healthPillRequestId;this._healthPillStepRequestTimerId!==null&&(window.clearTimeout(this._healthPillStepRequestTimerId),this._healthPillStepRequestTimerId=null),this.allStepsModeEnabled?this._healthPillStepRequestTimerId=setTimeout(function(){this._healthPillStepRequestTimerId=null,this._initiateNetworkRequestForHealthPills(t)}.bind(this),this._healthPillStepRequestTimerDelay):this._initiateNetworkRequestForHealthPills(t)}_initiateNetworkRequestForHealthPills(t){if(this._healthPillRequestId!==t)return;let r=this.allStepsModeEnabled?this.specificHealthPillStep:void 0,n=this._fetchHealthPills(this._renderHierarchy.getNamesOfRenderedOps(),r),i=this._fetchDebuggerNumericsAlerts();Promise.all([n,i]).then(function(o){var a=o[0],s=o[1];if(!!this.healthPillsToggledOn&&t===this._healthPillRequestId){for(var l in a){this.set("_healthPillStepIndex",a[l].length-1);break}this.set("_debuggerNumericAlerts",s),this.set("_nodeNamesToHealthPills",a),this.set("_areHealthPillsLoading",!1),this.set("_healthPillStepRequestTimerId",null)}}.bind(this))}_datasetsState(t,r,n){return t?!r||!r.length?n==="EMPTY":n==="PRESENT":n==="NOT_LOADED"}_renderHierarchyChanged(t){this.reload()}_handleNodeToggleExpand(){this._maybeFetchHealthPills()}_healthPillsToggledOnChanged(t){t?this.reload():this.set("_nodeNamesToHealthPills",{})}_maybeFetchHealthPills(){!this._shouldRequestHealthPills()||this._requestHealthPills()}};Or.template=Q`
    <paper-dialog id="error-dialog" with-backdrop></paper-dialog>
    <tf-dashboard-layout>
      <tf-graph-controls
        id="controls"
        class="sidebar"
        slot="sidebar"
        devices-for-stats="{{_devicesForStats}}"
        color-by-params="[[_colorByParams]]"
        stats="[[_stats]]"
        color-by="{{_colorBy}}"
        datasets="[[_datasets]]"
        render-hierarchy="[[_renderHierarchy]]"
        selection="{{_selection}}"
        selected-file="{{_selectedFile}}"
        selected-node="{{_selectedNode}}"
        health-pills-feature-enabled="[[_debuggerDataEnabled]]"
        health-pills-toggled-on="{{healthPillsToggledOn}}"
        on-fit-tap="_fit"
        trace-inputs="{{_traceInputs}}"
        auto-extract-nodes="{{_autoExtractNodes}}"
        on-download-image-requested="_onDownloadImageRequested"
      ></tf-graph-controls>
      <div
        class$="center [[_getGraphDisplayClassName(_selectedFile, _datasets)]]"
        slot="center"
      >
        <tf-graph-dashboard-loader
          id="loader"
          datasets="[[_datasets]]"
          selection="[[_selection]]"
          selected-file="[[_selectedFile]]"
          out-graph-hierarchy="{{_graphHierarchy}}"
          out-graph="{{_graph}}"
          out-stats="{{_stats}}"
          progress="{{_progress}}"
          hierarchy-params="[[_hierarchyParams]]"
          compatibility-provider="[[_compatibilityProvider]]"
        ></tf-graph-dashboard-loader>
        <div class="no-data-message">
          <h3>No graph definition files were found.</h3>
          <p>
            To store a graph, create a
            <code>tf.summary.FileWriter</code>
            and pass the graph either via the constructor, or by calling its
            <code>add_graph()</code> method. You may want to check out the
            <a href="https://www.tensorflow.org/tensorboard/graphs"
              >examining the TensorFlow graph tutorial</a
            >.
          </p>

          <p>
            If you’re new to using TensorBoard, and want to find out how to add
            data and set up your event files, check out the
            <a
              href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
              >README</a
            >
            and perhaps the
            <a
              href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
              >TensorBoard tutorial</a
            >.
          </p>

          <p>
            If you think TensorBoard is configured properly, please see
            <a
              href="https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"
              >the section of the README devoted to missing data problems</a
            >
            and consider filing an issue on GitHub.
          </p>
        </div>
        <div class="graphboard">
          <tf-graph-board
            id="graphboard"
            devices-for-stats="[[_devicesForStats]]"
            color-by="{{_colorBy}}"
            color-by-params="{{_colorByParams}}"
            graph-hierarchy="[[_graphHierarchy]]"
            graph="[[_graph]]"
            hierarchy-params="[[_hierarchyParams]]"
            progress="[[_progress]]"
            debugger-data-enabled="[[_debuggerDataEnabled]]"
            are-health-pills-loading="[[_areHealthPillsLoading]]"
            debugger-numeric-alerts="[[_debuggerNumericAlerts]]"
            node-names-to-health-pills="[[_nodeNamesToHealthPills]]"
            all-steps-mode-enabled="{{allStepsModeEnabled}}"
            specific-health-pill-step="{{specificHealthPillStep}}"
            health-pill-step-index="[[_healthPillStepIndex]]"
            render-hierarchy="{{_renderHierarchy}}"
            selected-node="{{_selectedNode}}"
            stats="[[_stats]]"
            trace-inputs="[[_traceInputs]]"
            auto-extract-nodes="[[_autoExtractNodes]]"
          ></tf-graph-board>
        </div>
      </div>
    </tf-dashboard-layout>
    <style>
      :host /deep/ {
        font-family: 'Roboto', sans-serif;
      }

      .sidebar {
        display: flex;
        height: 100%;
      }

      .center {
        position: relative;
        height: 100%;
      }

      paper-dialog {
        padding: 20px;
      }

      .no-data-message {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }

      .graphboard {
        height: 100%;
      }

      .no-graph .graphboard {
        display: none;
      }

      .center:not(.no-graph) .no-data-message {
        display: none;
      }

      a {
        color: var(--tb-link);
      }

      a:visited {
        color: var(--tb-link-visited);
      }
    </style>
  `;E([A({type:Array}),w("design:type",Array)],Or.prototype,"_datasets",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Or.prototype,"_datasetsFetched",void 0);E([A({type:Number}),w("design:type",Number)],Or.prototype,"_selectedDataset",void 0);E([A({type:Object,observer:"_renderHierarchyChanged"}),w("design:type",lo)],Or.prototype,"_renderHierarchy",void 0);E([A({type:Object}),w("design:type",Ae)],Or.prototype,"_requestManager",void 0);E([A({type:Object}),w("design:type",an)],Or.prototype,"_canceller",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Or.prototype,"_debuggerDataEnabled",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Or.prototype,"allStepsModeEnabled",void 0);E([A({type:Number}),w("design:type",Number)],Or.prototype,"specificHealthPillStep",void 0);E([A({type:Boolean,observer:"_healthPillsToggledOnChanged"}),w("design:type",Boolean)],Or.prototype,"healthPillsToggledOn",void 0);E([A({type:String,notify:!0}),w("design:type",String)],Or.prototype,"selectedNode",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Or.prototype,"_isAttached",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Or.prototype,"_initialized",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Or.prototype,"_areHealthPillsLoading",void 0);E([A({type:Array,notify:!0}),w("design:type",Array)],Or.prototype,"_debuggerNumericAlerts",void 0);E([A({type:Object}),w("design:type",Object)],Or.prototype,"_nodeNamesToHealthPills",void 0);E([A({type:Number}),w("design:type",Number)],Or.prototype,"_healthPillStepIndex",void 0);E([A({type:Number}),w("design:type",Number)],Or.prototype,"_healthPillRequestId",void 0);E([A({type:Number}),w("design:type",Object)],Or.prototype,"_healthPillStepRequestTimerId",void 0);E([A({type:Number}),w("design:type",Number)],Or.prototype,"_healthPillStepRequestTimerDelay",void 0);E([A({type:Array}),w("design:type",Array)],Or.prototype,"runs",void 0);E([A({type:String,notify:!0,observer:"_runObserver"}),w("design:type",String)],Or.prototype,"run",void 0);E([A({type:Object}),w("design:type",Object)],Or.prototype,"_selection",void 0);E([A({type:Object}),w("design:type",Object)],Or.prototype,"_compatibilityProvider",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Or.prototype,"_traceInputs",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Or.prototype,"_autoExtractNodes",void 0);E([A({type:Object}),w("design:type",Object)],Or.prototype,"_selectedFile",void 0);E([Bt("_isAttached"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Or.prototype,"_maybeInitializeDashboard",null);E([Bt("_datasetsFetched","_datasets","run"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Or.prototype,"_determineSelectedDataset",null);E([Bt("_datasetsFetched","_datasets","_selectedDataset"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Or.prototype,"_updateSelectedDatasetName",null);Or=E([yt("tf-graph-dashboard")],Or);var NH=Ee(Oe(),1);var kr=Vr,Ma=class extends Gt(_o(mt)){constructor(){super(...arguments),this.mode="offset",this.timeProperty="step",this.bins="bins",this.x="x",this.dx="dx",this.y="y",this.colorScale=kr.scaleOrdinal(kr.schemeCategory10),this.modeTransitionDuration=500,this._name=null,this._data=null}ready(){super.ready(),this.scopeSubtree(this.$.svg,!0)}attached(){this._attached=!0}detached(){this._attached=!1}setSeriesData(t,r){this._name=t,this._data=r,this.redraw()}_redrawOnChange(){this.redraw()}redraw(){this._draw(0)}_modeRedraw(){this._draw(this.modeTransitionDuration)}_draw(t){if(!this._attached||!this._data)return;if(t===void 0)throw new Error("vz-histogram-timeseries _draw needs duration");if(this._data.length<=0)throw new Error("Not enough steps in the data");if(!this._data[0].hasOwnProperty(this.bins))throw new Error("No bins property of '"+this.bins+"' in data");if(this._data[0][this.bins].length<=0)throw new Error("Must have at least one bin in bins in data");if(!this._data[0][this.bins][0].hasOwnProperty(this.x))throw new Error("No x property '"+this.x+"' on bins data");if(!this._data[0][this.bins][0].hasOwnProperty(this.dx))throw new Error("No dx property '"+this.dx+"' on bins data");if(!this._data[0][this.bins][0].hasOwnProperty(this.y))throw new Error("No y property '"+this.y+"' on bins data");var r=this.timeProperty,n=this.x,i=this.bins,o=this.dx,a=this.y,s=this._data,l=this._name,c=this.mode,u=kr.hcl(this.colorScale(l)),h=kr.select(this.$.tooltip),f=function(Nt){return Nt[n]},p=function(Nt){return Nt[a]},d=function(Nt){return Nt[o]},g=function(Nt){return Nt[n]+Nt[o]},_=function(Nt){return Nt[r]};r==="relative"&&(_=function(Nt){return Nt.wall_time-s[0].wall_time});var y=this.$.svg.getBoundingClientRect(),x=y.width,b=y.height,S,C={top:5,right:60,bottom:20,left:24};c==="offset"?(S=b/2.5,C.top=S+5):S=b-C.top-C.bottom;var P=x-C.left-C.right,k=b-C.top-C.bottom,O=kr.min(s,f),D=kr.max(s,g),B=kr.format(".3n"),I=kr.format(".0f");r==="wall_time"?I=kr.timeFormat("%m/%d %X"):r==="relative"&&(I=function(Nt){return kr.format(".1r")(Nt/36e5)+"h"});var L=s.map(function(Nt,ze){return[kr.min(Nt[i],f),kr.max(Nt[i],g)]}),R=s.map(function(Nt){return kr.extent(Nt[i],p)}),F=500,z=kr.extent(s,_),U=(r==="wall_time"?kr.scaleTime():kr.scaleLinear()).domain(z).range([0,c==="offset"?k:0]),W=kr.scaleLinear().domain([0,kr.max(s,function(Nt,ze){return R[ze][1]})]).range([S,0]),Z=kr.scaleLinear().domain(W.domain()).range([F,0]),rt=kr.scaleLinear().domain([kr.min(s,function(Nt,ze){return L[ze][0]}),kr.max(s,function(Nt,ze){return L[ze][1]})]).nice().range([0,P]),ot=kr.scaleLinear().domain(rt.domain()).range([0,F]);let st=kr.scaleLinear().domain(kr.extent(s,_)).range([u.brighter(),u.darker()]).interpolate(kr.interpolateHcl);var St=kr.axisBottom(rt).ticks(Math.max(2,P/20)),bt=kr.axisRight(U).ticks(Math.max(2,k/15)).tickFormat(I),Mt=kr.axisRight(W).ticks(Math.max(2,k/15)).tickSize(P+5).tickFormat(B),lt=function(Nt){return Nt[n]+Nt[o]/2},Kt=kr.line().x(function(Nt){return ot(lt(Nt))}).y(function(Nt){return Z(Nt[a])}),_t=function(Nt){return"M"+ot(lt(Nt[0]))+","+Z(0)+"L"+Kt(Nt).slice(1)+"L"+ot(lt(Nt[Nt.length-1]))+","+Z(0)},ct=this.$.svg,X=kr.select(ct),et=X.transition().duration(t),dt=X.select("g").classed("small",function(){return P>0&&P<=150}).classed("medium",function(){return P>150&&P<=300}).classed("large",function(){return P>300}),q=et.select("g").attr("transform","translate("+C.left+","+C.top+")"),pt=kr.bisector(g).left,ht=dt.select(".stage").on("mouseover",function(){Tt.style("opacity",1),Ct.style("opacity",1),at.style("opacity",1),Ce.style("opacity",1),h.style("opacity",1)}).on("mouseout",function(){Tt.style("opacity",0),Ct.style("opacity",0),at.style("opacity",0),Ce.style("opacity",0),Tt.classed("hover-closest",!1),It.classed("outline-hover",!1),h.style("opacity",0)}).on("mousemove",Pt),wt=ht.select(".background").attr("transform","translate("+-C.left+","+-C.top+")").attr("width",x).attr("height",b),kt=ht.selectAll(".histogram").data(s),ie=kt.exit().remove(),ee=kt.enter().append("g").attr("class","histogram"),Le=ee.merge(kt).sort(function(Nt,ze){return _(Nt)-_(ze)}),ar=q.selectAll(".histogram").attr("transform",function(Nt){return"translate(0, "+(c==="offset"?U(_(Nt))-S:0)+")"}),fr=ee.append("line").attr("class","baseline"),tt=ar.select(".baseline").style("stroke-opacity",function(Nt){return c==="offset"?.1:0}).attr("y1",S).attr("y2",S).attr("x2",P),$=ee.append("path").attr("class","outline"),It=Le.select(".outline").attr("vector-effect","non-scaling-stroke").attr("d",function(Nt){return _t(Nt[i])}).style("stroke-width",1),$t=ar.select(".outline").attr("transform","scale("+P/F+", "+S/F+")").style("stroke",function(Nt){return c==="offset"?"":st(_(Nt))}).style("fill-opacity",function(Nt){return c==="offset"?1:0}).style("fill",function(Nt){return st(_(Nt))}),he=ee.append("g").attr("class","hover"),Tt=Le.select(".hover").style("fill",function(Nt){return st(_(Nt))});he.append("circle").attr("r",2),he.append("text").style("display","none").attr("dx",4);var be=dt.select(".x-axis-hover").selectAll(".label").data(["x"]),nt=be.enter().append("g").attr("class","label"),Ct=be.merge(nt);nt.append("rect").attr("x",-20).attr("y",6).attr("width",40).attr("height",14),nt.append("line").attr("x1",0).attr("x2",0).attr("y1",0).attr("y2",6),nt.append("text").attr("dy",18);var Wt=dt.select(".y-axis-hover").selectAll(".label").data(["y"]),fe=Wt.enter().append("g").attr("class","label"),at=Wt.merge(fe);fe.append("rect").attr("x",8).attr("y",-6).attr("width",40).attr("height",14),fe.append("line").attr("x1",0).attr("x2",6).attr("y1",0).attr("y2",0),fe.append("text").attr("dx",8).attr("dy",4);var se=dt.select(".y-slice-axis-hover").selectAll(".label").data(["y"]),Qt=se.enter().append("g").attr("class","label"),Ce=se.merge(Qt);Qt.append("rect").attr("x",8).attr("y",-6).attr("width",40).attr("height",14),Qt.append("line").attr("x1",0).attr("x2",6).attr("y1",0).attr("y2",0),Qt.append("text").attr("dx",8).attr("dy",4),q.select(".y.axis.slice").style("opacity",c==="offset"?0:1).attr("transform","translate(0, "+(c==="offset"?-S:0)+")").call(Mt),q.select(".x.axis").attr("transform","translate(0, "+k+")").call(St),q.select(".y.axis").style("opacity",c==="offset"?1:0).attr("transform","translate("+P+", "+(c==="offset"?0:k)+")").call(bt),q.selectAll(".tick text").attr("fill","#aaa"),q.selectAll(".axis path.domain").attr("stroke","none");function Pt(){var Nt=kr.mouse(this),ze=rt.invert(Nt[0]),yn=U.invert(Nt[1]);function Wi(cn){return Math.min(cn[i].length-1,pt(cn[i],ze))}var Ar,Pa=1/0,ho;Tt.attr("transform",function(cn,cx){var rp=Wi(cn);ho=cn;var K=rt(cn[i][rp][n]+cn[i][rp][o]/2),gt=W(cn[i][rp][a]),Et=c==="offset"?U(_(cn))-(S-gt):gt,xt=Math.abs(Nt[1]-Et);return xt<Pa&&(Pa=xt,Ar=cn),"translate("+K+","+gt+")"}),Tt.select("text").text(function(cn){var cx=Wi(cn);return cn[i][cx][a]}),Tt.classed("hover-closest",function(cn){return cn===Ar}),It.classed("outline-hover",function(cn){return cn===Ar});var Ia=Wi(ho);Ct.attr("transform",function(cn){return"translate("+rt(ho[i][Ia][n]+ho[i][Ia][o]/2)+", "+k+")"}).select("text").text(function(cn){return B(ho[i][Ia][n]+ho[i][Ia][o]/2)});var lx=bt.tickFormat();at.attr("transform",function(cn){return"translate("+P+", "+(c==="offset"?U(_(Ar)):0)+")"}).style("display",c==="offset"?"":"none").select("text").text(function(cn){return lx(_(Ar))});var cm=Mt.tickFormat();Ce.attr("transform",function(cn){return"translate("+P+", "+(c==="offset"?0:W(Ar[i][Ia][a]))+")"}).style("display",c==="offset"?"none":"").select("text").text(function(cn){return cm(Ar[i][Ia][a])});var J0=kr.mouse(ct);h.style("transform","translate("+(J0[0]+15)+"px,"+(J0[1]-15)+"px)").select("span").text(c==="offset"?cm(Ar[i][Ia][a]):(r==="step"?"step ":"")+lx(_(Ar)))}}};Ma.template=Q`
    <div id="tooltip"><span></span></div>
    <svg id="svg">
      <g>
        <g class="axis x"></g>
        <g class="axis y"></g>
        <g class="axis y slice"></g>
        <g class="stage">
          <rect class="background"></rect>
        </g>
        <g class="x-axis-hover"></g>
        <g class="y-axis-hover"></g>
        <g class="y-slice-axis-hover"></g>
      </g>
    </svg>

    <style>
      :host {
        color: #aaa;
        display: flex;
        flex-direction: column;
        flex-grow: 1;
        flex-shrink: 1;
        position: relative;
        --vz-histogram-timeseries-hover-bg-color: #fff;
        --vz-histogram-timeseries-outline-color: #fff;
        --vz-histogram-timeseries-hover-outline-color: #000;
      }

      :host(.dark-mode) {
        --vz-histogram-timeseries-hover-bg-color: var(
          --primary-background-color
        );
        --vz-histogram-timeseries-outline-color: var(--paper-grey-600);
        --vz-histogram-timeseries-hover-outline-color: #fff;
      }

      svg {
        font-family: roboto, sans-serif;
        overflow: visible;
        display: block;
        width: 100%;
        flex-grow: 1;
        flex-shrink: 1;
      }

      text {
        fill: currentColor;
      }

      #tooltip {
        position: absolute;
        display: block;
        opacity: 0;
        font-weight: bold;
        font-size: 11px;
      }

      .background {
        fill-opacity: 0;
        fill: red;
      }

      .histogram {
        pointer-events: none;
      }

      .hover {
        font-size: 9px;
        dominant-baseline: middle;
        opacity: 0;
      }

      .hover circle {
        stroke: white;
        stroke-opacity: 0.5;
        stroke-width: 1px;
      }

      .hover text {
        fill: black;
        opacity: 0;
      }

      .hover.hover-closest circle {
        fill: var(--vz-histogram-timeseries-hover-outline-color) !important;
      }

      .hover.hover-closest text {
        opacity: 1;
      }

      .baseline {
        stroke: black;
        stroke-opacity: 0.1;
      }

      .outline {
        fill: none;
        stroke: var(--vz-histogram-timeseries-outline-color);
        stroke-opacity: 0.5;
      }

      .outline.outline-hover {
        stroke: var(--vz-histogram-timeseries-hover-outline-color) !important;
        stroke-opacity: 1;
      }

      .x-axis-hover,
      .y-axis-hover,
      .y-slice-axis-hover {
        pointer-events: none;
      }

      .x-axis-hover .label,
      .y-axis-hover .label,
      .y-slice-axis-hover .label {
        opacity: 0;
        font-weight: bold;
        font-size: 11px;
        text-anchor: end;
      }

      .x-axis-hover text {
        text-anchor: middle;
      }

      .y-axis-hover text,
      .y-slice-axis-hover text {
        text-anchor: start;
      }

      .x-axis-hover line,
      .y-axis-hover line,
      .y-slice-axis-hover line {
        stroke: currentColor;
      }

      .x-axis-hover rect,
      .y-axis-hover rect,
      .y-slice-axis-hover rect {
        fill: var(--vz-histogram-timeseries-hover-bg-color);
      }

      #tooltip,
      .x-axis-hover text,
      .y-axis-hover text,
      .y-slice-axis-hover text {
        color: var(--vz-histogram-timeseries-hover-outline-color);
      }

      .axis {
        font-size: 11px;
      }

      .axis path.domain {
        fill: none;
      }

      .axis .tick line {
        stroke: #ddd;
      }

      .axis.slice {
        opacity: 0;
      }

      .axis.slice .tick line {
        stroke-dasharray: 2;
      }

      .small .axis text {
        display: none;
      }
      .small .axis .tick:first-of-type text {
        display: block;
      }
      .small .axis .tick:last-of-type text {
        display: block;
      }
      .medium .axis text {
        display: none;
      }
      .medium .axis .tick:nth-child(2n + 1) text {
        display: block;
      }
      .large .axis text {
        display: none;
      }
      .large .axis .tick:nth-child(2n + 1) text {
        display: block;
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],Ma.prototype,"mode",void 0);E([A({type:String}),w("design:type",String)],Ma.prototype,"timeProperty",void 0);E([A({type:String}),w("design:type",String)],Ma.prototype,"bins",void 0);E([A({type:String}),w("design:type",String)],Ma.prototype,"x",void 0);E([A({type:String}),w("design:type",String)],Ma.prototype,"dx",void 0);E([A({type:String}),w("design:type",String)],Ma.prototype,"y",void 0);E([A({type:Object}),w("design:type",Object)],Ma.prototype,"colorScale",void 0);E([A({type:Number}),w("design:type",Number)],Ma.prototype,"modeTransitionDuration",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Ma.prototype,"_attached",void 0);E([A({type:String}),w("design:type",Object)],Ma.prototype,"_name",void 0);E([A({type:Array}),w("design:type",Object)],Ma.prototype,"_data",void 0);E([Bt("timeProperty","colorScale","_attached"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Ma.prototype,"_redrawOnChange",null);E([Bt("mode"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Ma.prototype,"_modeRedraw",null);Ma=E([yt("vz-histogram-timeseries")],Ma);function yur(e){let[t,r,n]=e;return{wall_time:t,step:r,min:Lm(n.map(([i,,])=>i)),max:lu(n.map(([,i])=>i)),buckets:n.map(([i,o,a])=>({left:i,right:o,count:a}))}}function vur(e,t,r,n=30){(t===void 0||r==null)&&(t=0,r=0),r===t&&(r=t*1.1+1,t=t/1.1-1);let i=(r-t)/n,o=0,a=[];for(let s=0;s<n;s++){let l=t+s*i,c=l+i,u=0;for(;o<e.buckets.length;){let h=Math.min(r,e.buckets[o].right),f=Math.max(t,e.buckets[o].left);if(h-f>0){let d=Math.min(h,c)-Math.max(f,l),g=d/(h-f)*e.buckets[o].count;u+=d>0?g:0}else{let d=c>=r;u+=l<=f&&(d?h<=c:h<c)?e.buckets[o].count:0}if(h>c)break;o++}a.push({x:l,dx:i,y:u})}return a}function sce(e){let t=e.map(yur),r=Lm(t,i=>i.min),n=lu(t,i=>i.max);return t.map(i=>({wall_time:i.wall_time,step:i.step,bins:vur(i,r,n)}))}var Ea=class extends kS(Gt(mt)){constructor(){super(...arguments),this.getDataLoadName=({run:t})=>t,this.requestData=(t,r,n)=>{let o=_e().pluginRoute("histograms","/histograms");Promise.all(t.map(a=>{let s=Mi(o,{tag:a.tag,run:a.run});return this.requestManager.request(s).then(l=>void r({item:a,data:l}))})).finally(()=>void n())},this.loadDataCallback=(t,r,n)=>{let i=sce(n),o=this.getDataLoadName(r);this.$.chart.setSeriesData(o,i)},this._colorScaleFunction=fn,this._expanded=!1}_reloadOnRunTagRequestManagerChange(){this.reload()}_updateDataToLoad(){var t=this.run,r=this.tag;this.dataToLoad=[{run:t,tag:r}]}get _runColor(){var t=this.run;return this._colorScaleFunction(t)}redraw(){this.$.chart.redraw()}_toggleExpanded(t){this.set("_expanded",!this._expanded),this.redraw()}};Ea.template=Q`
    <tf-card-heading
      tag="[[tag]]"
      run="[[run]]"
      display-name="[[tagMetadata.displayName]]"
      description="[[tagMetadata.description]]"
      color="[[_runColor]]"
    ></tf-card-heading>
    <!--
      The main histogram that we render. Data is set directly with
      \`setSeriesData\`, not with a bound property.
    -->
    <vz-histogram-timeseries
      id="chart"
      time-property="[[timeProperty]]"
      mode="[[histogramMode]]"
      color-scale="[[_colorScaleFunction]]"
    ></vz-histogram-timeseries>
    <div style="display: flex; flex-direction: row;">
      <paper-icon-button
        selected$="[[_expanded]]"
        icon="fullscreen"
        on-tap="_toggleExpanded"
      ></paper-icon-button>
    </div>
    <style>
      :host {
        display: flex;
        flex-direction: column;
        width: 330px;
        height: 235px;
        margin-right: 10px;
        margin-bottom: 15px;
      }
      :host([_expanded]) {
        width: 700px;
        height: 500px;
      }

      vz-histogram-timeseries {
        -moz-user-select: none;
        -webkit-user-select: none;
        will-change: transform;
      }

      paper-icon-button {
        color: #2196f3;
        border-radius: 100%;
        width: 32px;
        height: 32px;
        padding: 4px;
      }

      paper-icon-button[selected] {
        background: var(--tb-ui-light-accent);
      }

      tf-card-heading {
        margin-bottom: 10px;
        width: 90%;
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],Ea.prototype,"run",void 0);E([A({type:String}),w("design:type",String)],Ea.prototype,"tag",void 0);E([A({type:Object}),w("design:type",Object)],Ea.prototype,"getDataLoadName",void 0);E([A({type:Object}),w("design:type",Ae)],Ea.prototype,"requestManager",void 0);E([A({type:Object}),w("design:type",Object)],Ea.prototype,"loadDataCallback",void 0);E([A({type:Object}),w("design:type",Object)],Ea.prototype,"tagMetadata",void 0);E([A({type:String}),w("design:type",String)],Ea.prototype,"timeProperty",void 0);E([A({type:String}),w("design:type",String)],Ea.prototype,"histogramMode",void 0);E([A({type:Object}),w("design:type",Function)],Ea.prototype,"_colorScaleFunction",void 0);E([A({type:Boolean,reflectToAttribute:!0}),w("design:type",Boolean)],Ea.prototype,"_expanded",void 0);E([Bt("run","tag","requestManager"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Ea.prototype,"_reloadOnRunTagRequestManagerChange",null);E([Bt("run","tag"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Ea.prototype,"_updateDataToLoad",null);E([Rt("run"),w("design:type",String),w("design:paramtypes",[])],Ea.prototype,"_runColor",null);Ea=E([yt("tf-histogram-loader")],Ea);var ls=class extends Gt(mt){constructor(){super(...arguments),this.reloadOnReady=!0,this._histogramMode="offset",this._timeProperty="step",this._restamp=!1,this._requestManager=new Ae}_redrawCategoryPane(t,r){!r||t.target.querySelectorAll("tf-histogram-loader").forEach(n=>n.redraw())}ready(){super.ready(),this.reloadOnReady&&this.reload()}reload(){this._fetchTags().then(()=>{this._reloadHistograms()})}_fetchTags(){let t=_e().pluginRoute("histograms","/tags");return this._requestManager.request(t).then(r=>{if(NH.isEqual(r,this._runToTagInfo))return;let n=NH.mapValues(r,o=>Object.keys(o)),i=$i(n);this.set("_dataNotFound",i.length===0),this.set("_runToTag",n),this.set("_runToTagInfo",r),this.async(()=>{this.set("_categoriesDomReady",!0)})})}_reloadHistograms(){var t;(t=this.root)==null||t.querySelectorAll("tf-histogram-loader").forEach(r=>{r.reload()})}_shouldOpen(t){return t<=2}get _categories(){var t=this._runToTag,r=this._selectedRuns,n=this._tagFilter,i=this._categoriesDomReady;return Ql(t,r,n)}_tagMetadata(t,r,n){return t[r][n]}};ls.template=Q`
    <tf-dashboard-layout>
      <div slot="sidebar">
        <div class="settings">
          <div class="sidebar-section">
            <tf-option-selector
              id="histogramModeSelector"
              name="Histogram mode"
              selected-id="{{_histogramMode}}"
            >
              <paper-button id="overlay">overlay</paper-button>
              <paper-button id="offset">offset</paper-button>
            </tf-option-selector>
          </div>
          <div class="sidebar-section">
            <tf-option-selector
              id="timePropertySelector"
              name="Offset time axis"
              selected-id="{{_timeProperty}}"
            >
              <paper-button id="step">step</paper-button>
              <paper-button id="relative">relative</paper-button>
              <paper-button id="wall_time">wall</paper-button>
            </tf-option-selector>
          </div>
        </div>
        <div class="sidebar-section runs-selector">
          <tf-runs-selector selected-runs="{{_selectedRuns}}">
          </tf-runs-selector>
        </div>
      </div>
      <div slot="center">
        <template is="dom-if" if="[[_dataNotFound]]">
          <div class="no-data-warning">
            <h3>No histogram data was found.</h3>
            <p>Probable causes:</p>
            <ul>
              <li>
                You haven’t written any histogram data to your event files.
              </li>
              <li>TensorBoard can’t find your event files.</li>
            </ul>

            <p>
              If you’re new to using TensorBoard, and want to find out how to
              add data and set up your event files, check out the
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
                >README</a
              >
              and perhaps the
              <a
                href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
                >TensorBoard tutorial</a
              >.
            </p>

            <p>
              If you think TensorBoard is configured properly, please see
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"
                >the section of the README devoted to missing data problems</a
              >
              and consider filing an issue on GitHub.
            </p>
          </div>
        </template>
        <template is="dom-if" if="[[!_dataNotFound]]">
          <tf-tag-filterer tag-filter="{{_tagFilter}}"></tf-tag-filterer>
          <template is="dom-repeat" items="[[_categories]]" as="category">
            <tf-category-paginated-view
              category="[[category]]"
              initial-opened="[[_shouldOpen(index)]]"
            >
              <template>
                <tf-histogram-loader
                  run="[[item.run]]"
                  tag="[[item.tag]]"
                  active="[[active]]"
                  tag-metadata="[[_tagMetadata(_runToTagInfo, item.run, item.tag)]]"
                  time-property="[[_timeProperty]]"
                  histogram-mode="[[_histogramMode]]"
                  request-manager="[[_requestManager]]"
                ></tf-histogram-loader>
              </template>
            </tf-category-paginated-view>
          </template>
        </template>
      </div>
    </tf-dashboard-layout>

    <style include="dashboard-style"></style>
    <style>
      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }
    </style>
  `;E([A({type:Boolean}),w("design:type",Boolean)],ls.prototype,"reloadOnReady",void 0);E([A({type:String}),w("design:type",String)],ls.prototype,"_histogramMode",void 0);E([A({type:String}),w("design:type",String)],ls.prototype,"_timeProperty",void 0);E([A({type:Array}),w("design:type",Array)],ls.prototype,"_selectedRuns",void 0);E([A({type:Object}),w("design:type",Object)],ls.prototype,"_runToTag",void 0);E([A({type:Object}),w("design:type",Object)],ls.prototype,"_runToTagInfo",void 0);E([A({type:Boolean}),w("design:type",Boolean)],ls.prototype,"_dataNotFound",void 0);E([A({type:String}),w("design:type",String)],ls.prototype,"_tagFilter",void 0);E([A({type:Boolean}),w("design:type",Boolean)],ls.prototype,"_restamp",void 0);E([A({type:Boolean}),w("design:type",Boolean)],ls.prototype,"_categoriesDomReady",void 0);E([A({type:Object}),w("design:type",Ae)],ls.prototype,"_requestManager",void 0);E([Rt("_runToTag","_selectedRuns","_tagFilter","_categoriesDomReady"),w("design:type",Array),w("design:paramtypes",[])],ls.prototype,"_categories",null);ls=E([yt("tf-histogram-dashboard")],ls);var u3=class{constructor(t,r=!0){this._requestManager=t,this._useHttpGet=r}getExperiment(t){return this._sendRequest("/experiment",t)}getDownloadUrl(t,r,n){return _e().pluginRouteForSrc("hparams","/download_data",new URLSearchParams({format:t,columnsVisibility:JSON.stringify(n),request:JSON.stringify(r)}))}listSessionGroups(t){return this._sendRequest("/session_groups",t)}listMetricEvals(t){return this._sendRequest("/metric_evals",t)}_sendRequest(t,r){if(this._useHttpGet){let o=_e().pluginRoute("hparams",t,new URLSearchParams({request:JSON.stringify(r)}));return this._requestManager.request(o)}let n=new Ux;n.withCredentials=!0,n.methodType=Am.POST,n.contentType="text/plain",n.body=JSON.stringify(r);let i=_e().pluginRoute("hparams",t);return this._requestManager.requestWithOptions(i,n)}};var _ce=Ee(Oe(),1);var DH=class extends mt{constructor(){super(...arguments),this.orientation="horizontal"}};DH.template=Q`
    <slot name="content"></slot>

    <style>
      :host {
        display: block;
      }

      :host slot {
        display: flex;
        height: 100%;
        width: 100%;
      }

      :host ::slotted(*) {
        flex: 0 0 auto;
      }

      :host([orientation='horizontal']) slot {
        flex-direction: row;
        overflow-x: auto;
      }

      :host([orientation='vertical']) slot {
        flex-direction: column;
        overflow-y: auto;
      }

      :host ::slotted(*:not(:last-child)) {
        border: 0 solid var(--divider-color, #ccc);
      }

      :host([orientation='vertical']) ::slotted(*:not(:last-child)) {
        border-bottom-width: 5px;
      }

      :host([orientation='horizontal']) ::slotted(*:not(:last-child)) {
        border-right-width: 5px;
      }
    </style>
  `;E([A({type:String,reflectToAttribute:!0}),w("design:type",String)],DH.prototype,"orientation",void 0);DH=E([yt("hparams-split-layout")],DH);var cs={};Ks(cs,{columnValueByIndex:()=>x0,columnValueByVisibleIndex:()=>BH,euclideanDist:()=>h3,filterSet:()=>Pur,getAbsoluteColumnIndex:()=>zH,hashOfString:()=>dct,hparamName:()=>Fd,hparamValueByIndex:()=>hce,hparamValueByName:()=>uce,hparamValueByVisibleIndex:()=>mce,isNullOrUndefined:()=>Tur,l2NormSquared:()=>p3,metricName:()=>Qu,metricValueByIndex:()=>fce,metricValueByName:()=>f3,metricValueByVisibleIndex:()=>FH,numColumns:()=>uct,numHParams:()=>lce,numMetrics:()=>cce,numVisibleColumns:()=>wur,numVisibleHParams:()=>pce,numVisibleMetrics:()=>dce,numericColumnExtent:()=>hct,pointToRectangleDist:()=>gce,prettyPrint:()=>b0,prettyPrintHParamValueByName:()=>Sur,prettyPrintMetricValueByName:()=>Mur,quadTreeVisitPointsInDisk:()=>Aur,quadTreeVisitPointsInRect:()=>Cur,rotateStr:()=>Eur,schemaColumnName:()=>cct,schemaVisibleColumnName:()=>bur,sessionGroupWithName:()=>fct,setArrayObservably:()=>pct,translateStr:()=>yP,visibleNumericColumnExtent:()=>_P});var OH=Ee(Oe(),1);function Fd(e){return e.displayName!==""&&e.displayName!==void 0?e.displayName:e.name}function Qu(e){if(e.displayName!==""&&e.displayName!==void 0)return e.displayName;let t=e.name.group,r=e.name.tag;return t===void 0&&(t=""),r===void 0&&(r=""),t===""?r:t+"."+r}function cct(e,t){if(t<e.hparamColumns.length)return Fd(e.hparamColumns[t].hparamInfo);let r=t-e.hparamColumns.length;return Qu(e.metricColumns[r].metricInfo)}function lce(e){return e.hparamColumns.length}function cce(e){return e.metricColumns.length}function uct(e){return lce(e)+cce(e)}function uce(e,t){return e[t]}function f3(e,t){return e.find(r=>OH.isEqual(r.name,t))}function hce(e,t,r){return t.hparams[e.hparamColumns[r].hparamInfo.name]}function fce(e,t,r){let n=e.metricColumns[r].metricInfo.name,i=f3(t.metricValues,n);return i===void 0||i.value==="NaN"?void 0:i.value}function x0(e,t,r){return r<e.hparamColumns.length?hce(e,t,r):fce(e,t,r-e.hparamColumns.length)}function hct(e,t,r){return aa(t,n=>x0(e,n,r))}function zH(e,t,r){let n;if(r<t.hparamInfos.length)n=e.hparamColumns.findIndex(i=>i.hparamInfo.name===t.hparamInfos[r].name);else{let i=r-t.hparamInfos.length,o=t.metricInfos[i].name;n=e.hparamColumns.length+e.metricColumns.findIndex(a=>a.metricInfo.name===o)}return console.assert(n!==-1),n}function bur(e,t){if(t<e.hparamInfos.length)return Fd(e.hparamInfos[t]);let r=t-e.hparamInfos.length;return Qu(e.metricInfos[r])}function pce(e){return e.hparamInfos.length}function dce(e){return e.metricInfos.length}function wur(e){return pce(e)+dce(e)}function _P(e,t,r){return aa(t,n=>BH(e,n,r))}function Sur(e,t){return b0(uce(e,t))}function Mur(e,t){return b0(f3(e,t))}function fct(e,t){return e.find(r=>r.name===t)}function mce(e,t,r){return t.hparams[e.hparamInfos[r].name]}function FH(e,t,r){let n=e.metricInfos[r].name,i=f3(t.metricValues,n);return i===void 0||i.value==="NaN"?void 0:i.value}function BH(e,t,r){return r<e.hparamInfos.length?mce(e,t,r):FH(e,t,r-e.hparamInfos.length)}function b0(e){return OH.isNumber(e)?e.toPrecision(5):e==null?"":e.toString()}function p3(e,t){return e*e+t*t}function h3(e,t,r,n){return Math.sqrt(p3(e-r,t-n))}function gce(e,t,r,n,i,o){if(e<r&&t<n)return h3(e,t,r,n);if(r<=e&&e<i&&t<n)return n-t;if(i<=e&&t<n)return h3(e,t,i,n);if(e<r&&n<=t&&t<o)return r-e;if(r<=e&&e<i&&n<=t&&t<o)return 0;if(i<=e&&n<=t&&t<o)return e-i;if(e<r&&o<=t)return h3(e,t,r,o);if(r<=e&&e<i&&o<=t)return t-o;if(i<=e&&o<=t)return h3(e,t,i,o);throw"Point (x,y) must be in one of the regions defined above."}function yP(e,t){return t===void 0?"translate("+e+")":"translate("+e+","+t+")"}function Eur(e,t,r){let n="rotate("+e;return t!==void 0&&r!==void 0&&(n=n+","+t+","+r),n=n+")",n}function Tur(e){return e==null}function Cur(e,t,r,n,i,o){e.visit((a,s,l,c,u)=>{if(a.length===void 0){do{let h=e.x()(a.data),f=e.y()(a.data);t<=h&&h<n&&r<=f&&f<i&&o(a.data)}while(a=a.next);return!0}return s>=n||c<=t||l>=i||u<=r})}function Aur(e,t,r,n,i){e.visit((o,a,s,l,c)=>{if(o.length===void 0){do{let u=e.x()(o.data),h=e.y()(o.data),f=h3(t,r,u,h);f<=n&&i(o.data,f)}while(o=o.next);return!0}return gce(t,r,a,s,l,c)>n})}function Pur(e,t){let r=new Set;return e.forEach(n=>{t(n)&&r.add(n)}),r}function pct(e,t,r){let n=e.get(t,e);if(!Array.isArray(n)){e.set(t,r);return}e.splice.apply(e,[t,0,n.length].concat(r))}function dct(e){let t=0;for(let r=0;r<e.length;++r)t=t*31+e.charCodeAt(r)&4294967295;return t+TI(2,31)}var Iur=10,Qn=class extends Gt(mt){constructor(){super(...arguments),this.configuration={schema:{hparamColumns:Array(),metricColumns:Array()},columnsVisibility:Array(),visibleSchema:{hparamInfos:Array(),metricInfos:Array()}},this.sessionGroups=[],this.dataLoadedWithNonEmptyHparams=!1,this.dataLoadedWithEmptyHparams=!1,this._statuses=[{value:"STATUS_UNKNOWN",displayName:"Unknown",allowed:!0},{value:"STATUS_SUCCESS",displayName:"Success",allowed:!0},{value:"STATUS_FAILURE",displayName:"Failure",allowed:!0},{value:"STATUS_RUNNING",displayName:"Running",allowed:!0}],this._getExperimentResolved=new Promise(t=>{this._resolveGetExperiment=t}),this._listSessionGroupsCanceller=new an,this._pageSizeInput={value:"100",invalid:!1},this._pageNumberInput={value:"1",invalid:!1},this._pageCountStr="?",this._hparamName=Fd,this._metricName=Qu,this._prettyPrint=b0}reload(){this._queryServer()}_csvUrl(t,r){return this._downloadDataUrl(t,r,"csv")}_jsonUrl(t,r){return this._downloadDataUrl(t,r,"json")}_latexUrl(t,r){return this._downloadDataUrl(t,r,"latex")}_downloadDataUrl(t,r,n){let i=r.columnsVisibility;return this.backend.getDownloadUrl(n,t,i)}_computeExperimentAndRelatedProps(){let t=cs;if(t.isNullOrUndefined(this.backend)||t.isNullOrUndefined(this.experimentName))return;let r={experimentName:this.experimentName};this.backend.getExperiment(r).then(n=>{_ce.isEqual(n,this._experiment)||(this.set("_experiment",n),this._computeHParams(),this._computeMetrics(),this._queryServer(),this._resolveGetExperiment())}).finally(()=>{this._computeDataFound()})}_computeDataFound(){let t=Boolean(this._experiment&&this._experiment.hparamInfos&&this._experiment.hparamInfos.length>0);this.set("dataLoadedWithNonEmptyHparams",t),this.set("dataLoadedWithEmptyHparams",!t)}_computeHParams(){let t=[];this._experiment.hparamInfos.forEach(i=>{let o={info:i,displayed:!1,filter:{}};o.info.hasOwnProperty("domainDiscrete")?o.info.domainDiscrete.length<Iur?(o.filter.domainDiscrete=[],o.info.domainDiscrete.forEach(a=>{o.filter.domainDiscrete.push({value:a,checked:!0})})):o.filter.regexp="":o.info.type==="DATA_TYPE_FLOAT64"?o.filter.interval={min:{value:"",invalid:!1},max:{value:"",invalid:!1}}:console.warn("cannot process domain type %s without discrete domain values",o.info.type),t.push(o)}),t.sort((i,o)=>i.info.differs===o.info.differs?0:i.info.differs?-1:1);let n=Math.min(5,t.length);for(let i=0;i<n;i++)t[i].displayed=!0;this.set("_hparams",t)}_computeMetrics(){let t=[];this._experiment.metricInfos.forEach((n,i)=>{let o={info:n,filter:{interval:{min:{value:"",invalid:!1},max:{value:"",invalid:!1}}},displayed:i<5};t.push(o)}),this.set("_metrics",t)}_computeSchema(){return!this._hparams||!this._metrics?{hparamColumns:[],metricColumns:[]}:{hparamColumns:this._hparams.map(t=>({hparamInfo:t.info})),metricColumns:this._metrics.map(t=>({metricInfo:t.info}))}}_updateConfiguration(){this.debounce("_updateConfiguration",()=>{this.configuration={schema:this._computeSchema(),columnsVisibility:this._computeColumnsVisibility(),visibleSchema:this._computeVisibleSchema()}})}_computeColumnsVisibility(){return!this._hparams||!this._metrics?[]:this._hparams.map(t=>t.displayed).concat(this._metrics.map(t=>t.displayed))}_computeVisibleSchema(){if(!this._hparams||!this._metrics)return{hparamInfos:[],metricInfos:[]};let t=this._hparams.filter(n=>n.displayed).map(n=>n.info),r=this._metrics.filter(n=>n.displayed).map(n=>n.info);return{hparamInfos:t,metricInfos:r}}_hasRegexpFilter(t){return t.filter.regexp!==void 0}_queryServer(){this.debounce("queryServer",()=>this._queryServerNoDebounce(),100)}_queryServerNoDebounce(){if(!(!this._hparams||!this._metrics))return this._sendListSessionGroupsRequest().then(this._listSessionGroupsCanceller.cancellable(({value:t,cancelled:r})=>{if(!r){if(t.totalSize>=0){let n=+this._pageSizeInput.value;this.set("_pageCountStr",String(Math.ceil(t.totalSize/n))),this.set("_totalSessionGroupsCountStr",t.totalSize)}else this.set("_pageCountStr","?"),this.set("_totalSessionGroupsCountStr","Unknown");pct(this,"sessionGroups",t.sessionGroups)}}))}_sendListSessionGroupsRequest(){let t=this._buildListSessionGroupsRequest();if(t!==null)return this.set("_sessionGroupsRequest",t),this._listSessionGroupsCanceller.cancelAll(),this.backend.listSessionGroups(t)}_buildListSessionGroupsRequest(){let t=this,r=!0;function n(h){return h.min.value!==""||h.max.value!==""}function i(h){let f=t.get(h+".min.value");console.assert(f!==void 0);let p=f===""?"-Infinity":+f,d=isNaN(p);t.set(h+".min.invalid",d),r=r&&!d;let g=t.get(h+".max.value");console.assert(g!==void 0);let _=g===""?"Infinity":+g,y=isNaN(_);return t.set(h+".max.invalid",y),r=r&&!y,d||y?null:{minValue:p,maxValue:_}}function o(h){let f=t.get(h+".value");console.assert(f!==void 0);let p=+f,d=Number.isInteger(p)&&p>0;return t.set(h+".invalid",!d),r=r&&d,d?p:null}let a=this._statuses.filter(h=>h.allowed).map(h=>h.value),s=[];if(this._hparams.forEach((h,f)=>{let p={hparam:h.info.name};h.filter.domainDiscrete?h.filter.domainDiscrete.every(g=>g.checked)||(p.filterDiscrete=[],h.filter.domainDiscrete.forEach(g=>{g.checked&&p.filterDiscrete.push(g.value)})):h.filter.interval?n(h.filter.interval)&&(p.filterInterval=i("_hparams."+f+".filter.interval")):h.filter.regexp&&(p.filterRegexp=h.filter.regexp),s.push(p)}),this._metrics.forEach((h,f)=>{let p={metric:h.info.name};n(h.filter.interval)&&(p.filterInterval=i("_metrics."+f+".filter.interval")),s.push(p)}),this._sortByIndex!==void 0&&this._sortDirection!==void 0){if(!(this._sortByIndex in s))return console.error("No column in colParams with index sortByIndex: %s",this._sortByIndex),null;s[this._sortByIndex].order=this._sortDirection===0?"ORDER_ASC":"ORDER_DESC"}let l=o("_pageNumberInput")||0,c=o("_pageSizeInput")||0;if(!r)return null;let u=c*(l-1);return{experimentName:this.experimentName,allowedStatuses:a,colParams:s,startIndex:u,sliceSize:c}}_metricSortByIndex(t){return t+this._hparams.length}};Qn.template=Q`
    <hparams-split-layout orientation="vertical">
      <div slot="content" class="section hyperparameters">
        <div class="section-title">Hyperparameters</div>
        <template is="dom-repeat" items="{{_hparams}}" as="hparam">
          <div class="hparam">
            <paper-checkbox
              checked="{{hparam.displayed}}"
              class="hparam-checkbox"
            >
              [[_hparamName(hparam.info)]]
            </paper-checkbox>
            <!-- Precisely one of the templates below will be stamped.-->
            <!-- 1. A list of checkboxes -->
            <template is="dom-if" if="[[hparam.filter.domainDiscrete]]">
              <template
                is="dom-repeat"
                items="[[hparam.filter.domainDiscrete]]"
              >
                <paper-checkbox
                  checked="{{item.checked}}"
                  class="discrete-value-checkbox"
                  on-change="_queryServer"
                >
                  [[_prettyPrint(item.value)]]
                </paper-checkbox>
              </template>
            </template>
            <!-- 2. A numeric interval -->
            <template is="dom-if" if="[[hparam.filter.interval]]">
              <paper-input
                label="Min"
                value="{{hparam.filter.interval.min.value}}"
                allowed_pattern="[0-9.e\\-]"
                on-value-changed="_queryServer"
                error-message="Invalid input"
                invalid="[[hparam.filter.interval.min.invalid]]"
                placeholder="-infinity"
              >
              </paper-input>
              <paper-input
                label="Max"
                value="{{hparam.filter.interval.max.value}}"
                allowed_pattern="[0-9.e\\-]"
                on-value-changed="_queryServer"
                error-message="Invalid input"
                invalid="[[hparam.filter.interval.max.invalid]]"
                placeholder="+infinity"
              >
              </paper-input>
            </template>
            <!-- 3. A regexp -->
            <template is="dom-if" if="[[_hasRegexpFilter(hparam)]]">
              <paper-input
                label="Regular expression"
                value="{{hparam.filter.regexp}}"
                on-value-changed="_queryServer"
              >
              </paper-input>
            </template>
          </div>
        </template>
      </div>
      <div slot="content" class="section metrics">
        <div class="section-title">Metrics</div>
        <template is="dom-repeat" items="{{_metrics}}" as="metric">
          <div class="metric">
            <!-- TODO(erez): Make it easier to handle a large number of
                  metrics:
                  1. Add an 'isolator' radio-button to select just one
                  metric and
                  hide all the rest
                  2. Add a 'toggle-all' button that will hide/unhide
                    all the
                  metrics.
                  Use similar logic/appearance to the run-selector of
                  scalars.-->
            <paper-checkbox
              checked="{{metric.displayed}}"
              class="metric-checkbox"
            >
              [[_metricName(metric.info)]]
            </paper-checkbox>
            <div class="inline-element">
              <paper-input
                label="Min"
                value="{{metric.filter.interval.min.value}}"
                allowed-pattern="[0-9.e\\-]"
                on-value-changed="_queryServer"
                error-message="Invalid input"
                invalid="{{metric.filter.interval.min.invalid}}"
                placeholder="-infinity"
              >
              </paper-input>
            </div>
            <div class="inline-element">
              <paper-input
                label="Max"
                allowed-pattern="[0-9.e\\-]"
                value="{{metric.filter.interval.max.value}}"
                on-value-changed="_queryServer"
                error-message="Invalid input"
                invalid="{{metric.filter.interval.max.invalid}}"
                placeholder="+infinity"
              >
              </paper-input>
            </div>
          </div>
        </template>
      </div>
      <div slot="content" class="section status">
        <div class="section-title">Status</div>
        <template is="dom-repeat" items="[[_statuses]]" as="status">
          <paper-checkbox checked="{{status.allowed}}" on-change="_queryServer">
            [[status.displayName]]
          </paper-checkbox>
        </template>
      </div>
      <div slot="content" class="section sorting">
        <div class="section-title">Sorting</div>
        <paper-dropdown-menu
          label="Sort by"
          on-selected-item-changed="_queryServer"
          horizontal-align="left"
        >
          <paper-listbox
            class="dropdown-content"
            slot="dropdown-content"
            selected="{{_sortByIndex}}"
            on-selected-item-changed="_queryServer"
          >
            <template is="dom-repeat" items="[[_hparams]]" as="hparam">
              <paper-item> [[_hparamName(hparam.info)]] </paper-item>
            </template>
            <template is="dom-repeat" items="[[_metrics]]" as="metric">
              <paper-item> [[_metricName(metric.info)]] </paper-item>
            </template>
          </paper-listbox>
        </paper-dropdown-menu>
        <paper-dropdown-menu
          label="Direction"
          on-selected-item-changed="_queryServer"
          horizontal-align="left"
        >
          <paper-listbox
            class="dropdown-content"
            slot="dropdown-content"
            selected="{{_sortDirection}}"
          >
            <paper-item>Ascending</paper-item>
            <paper-item>Descending</paper-item>
          </paper-listbox>
        </paper-dropdown-menu>
      </div>
      <div slot="content" class="section paging">
        <div class="section-title">Paging</div>
        <div>
          Number of matching session groups: [[_totalSessionGroupsCountStr]]
        </div>
        <div class="inline-element page-number-input">
          <paper-input
            label="Page #"
            value="{{_pageNumberInput.value}}"
            allowed-pattern="[0-9]"
            error-message="Invalid input"
            invalid="[[_pageNumberInput.invalid]]"
            on-value-changed="_queryServer"
          >
            <div slot="suffix" class="page-suffix">/ [[_pageCountStr]]</div>
          </paper-input>
        </div>
        <div class="inline-element page-size-input">
          <paper-input
            label="Max # of session groups per page:"
            value="{{_pageSizeInput.value}}"
            allowed-pattern="[0-9]"
            error-message="Invalid input"
            invalid="[[_pageSizeInput.invalid]]"
            on-value-changed="_queryServer"
          >
          </paper-input>
        </div>
      </div>
      <div slot="content" class="section download">
        <template is="dom-if" if="[[_sessionGroupsRequest]]">
          Download data as
          <span>
            <a
              id="csvLink"
              download="hparams_table.csv"
              href="[[_csvUrl(_sessionGroupsRequest, configuration)]]"
              >CSV</a
            >
            <a
              id="jsonLink"
              download="hparams_table.json"
              href="[[_jsonUrl(_sessionGroupsRequest, configuration)]]"
              >JSON</a
            >
            <a
              id="latexLink"
              download="hparams_table.tex"
              href="[[_latexUrl(_sessionGroupsRequest, configuration)]]"
              >LaTeX</a
            >
          </span>
        </template>
      </div>
    </hparams-split-layout>
    <style>
      .section {
        padding: 10px;
      }
      .section-title {
        display: block;
        font-weight: bold;
        text-decoration: underline;
        margin-bottom: 7px;
      }
      .discrete-value-checkbox,
      .metric-checkbox,
      .hparam-checkbox {
        display: block;
      }
      .discrete-value-checkbox {
        margin-left: 20px;
      }
      .hparam,
      .metric {
        display: block;
      }
      .inline-element {
        display: inline-block;
        width: 40%;
        margin-left: 10px;
      }
      .page-number-input {
        width: 20%;
      }
      .page-size-input {
        width: 60%;
      }
      vaadin-split-layout {
        height: 100%;
      }
      paper-listbox {
        max-height: 15em;
      }
      .page-suffix {
        white-space: nowrap;
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],Qn.prototype,"experimentName",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],Qn.prototype,"configuration",void 0);E([A({type:Array,notify:!0}),w("design:type",Object)],Qn.prototype,"sessionGroups",void 0);E([A({type:Boolean,notify:!0}),w("design:type",Boolean)],Qn.prototype,"dataLoadedWithNonEmptyHparams",void 0);E([A({type:Boolean,notify:!0}),w("design:type",Boolean)],Qn.prototype,"dataLoadedWithEmptyHparams",void 0);E([A({type:Object}),w("design:type",Object)],Qn.prototype,"_experiment",void 0);E([A({type:Array}),w("design:type",Array)],Qn.prototype,"_hparams",void 0);E([A({type:Array}),w("design:type",Array)],Qn.prototype,"_metrics",void 0);E([A({type:Array}),w("design:type",Object)],Qn.prototype,"_statuses",void 0);E([A({type:Object}),w("design:type",Object)],Qn.prototype,"_getExperimentResolved",void 0);E([A({type:Object}),w("design:type",Function)],Qn.prototype,"_resolveGetExperiment",void 0);E([A({type:Object}),w("design:type",Object)],Qn.prototype,"_listSessionGroupsCanceller",void 0);E([A({type:Number}),w("design:type",Number)],Qn.prototype,"_sortByIndex",void 0);E([A({type:Number}),w("design:type",Number)],Qn.prototype,"_sortDirection",void 0);E([A({type:Object}),w("design:type",Object)],Qn.prototype,"_pageSizeInput",void 0);E([A({type:Object}),w("design:type",Object)],Qn.prototype,"_pageNumberInput",void 0);E([A({type:String}),w("design:type",String)],Qn.prototype,"_pageCountStr",void 0);E([A({type:String}),w("design:type",String)],Qn.prototype,"_totalSessionGroupsCountStr",void 0);E([A({type:Object}),w("design:type",Object)],Qn.prototype,"_sessionGroupsRequest",void 0);E([Bt("backend","experimentName"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Qn.prototype,"_computeExperimentAndRelatedProps",null);E([Bt("_hparams.*","_metrics.*"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Qn.prototype,"_updateConfiguration",null);Qn=E([yt("tf-hparams-query-pane")],Qn);var Uct=Ee(Oe(),1);var mct=typeof window!="undefined"&&window.customElements!=null&&window.customElements.polyfillWrapFlushCallback!==void 0;var i1=(e,t,r=null)=>{for(;t!==r;){let n=t.nextSibling;e.removeChild(t),t=n}};var Yc=`{{lit-${String(Math.random()).slice(2)}}}`,gct=`<!--${Yc}-->`,yce=new RegExp(`${Yc}|${gct}`),d3="$lit$",o1=class{constructor(t,r){this.parts=[],this.element=r;let n=[],i=[],o=document.createTreeWalker(r.content,133,null,!1),a=0,s=-1,l=0,{strings:c,values:{length:u}}=t;for(;l<u;){let h=o.nextNode();if(h===null){o.currentNode=i.pop();continue}if(s++,h.nodeType===1){if(h.hasAttributes()){let f=h.attributes,{length:p}=f,d=0;for(let g=0;g<p;g++)vce(f[g].name,d3)&&d++;for(;d-- >0;){let g=c[l],_=HH.exec(g)[2],y=_.toLowerCase()+d3,x=h.getAttribute(y);h.removeAttribute(y);let b=x.split(yce);this.parts.push({type:"attribute",index:s,name:_,strings:b}),l+=b.length-1}}h.tagName==="TEMPLATE"&&(i.push(h),o.currentNode=h.content)}else if(h.nodeType===3){let f=h.data;if(f.indexOf(Yc)>=0){let p=h.parentNode,d=f.split(yce),g=d.length-1;for(let _=0;_<g;_++){let y,x=d[_];if(x==="")y=Yf();else{let b=HH.exec(x);b!==null&&vce(b[2],d3)&&(x=x.slice(0,b.index)+b[1]+b[2].slice(0,-d3.length)+b[3]),y=document.createTextNode(x)}p.insertBefore(y,h),this.parts.push({type:"node",index:++s})}d[g]===""?(p.insertBefore(Yf(),h),n.push(h)):h.data=d[g],l+=g}}else if(h.nodeType===8)if(h.data===Yc){let f=h.parentNode;(h.previousSibling===null||s===a)&&(s++,f.insertBefore(Yf(),h)),a=s,this.parts.push({type:"node",index:s}),h.nextSibling===null?h.data="":(n.push(h),s--),l++}else{let f=-1;for(;(f=h.data.indexOf(Yc,f+1))!==-1;)this.parts.push({type:"node",index:-1}),l++}}for(let h of n)h.parentNode.removeChild(h)}},vce=(e,t)=>{let r=e.length-t.length;return r>=0&&e.slice(r)===t},vP=e=>e.index!==-1,Yf=()=>document.createComment(""),HH=/([ \x09\x0a\x0c\x0d])([^\0-\x1F\x7F-\x9F "'>=/]+)([ \x09\x0a\x0c\x0d]*=[ \x09\x0a\x0c\x0d]*(?:[^ \x09\x0a\x0c\x0d"'`<>=]*|"[^"]*|'[^']*))$/;var _ct=133;function yct(e,t){let{element:{content:r},parts:n}=e,i=document.createTreeWalker(r,_ct,null,!1),o=xP(n),a=n[o],s=-1,l=0,c=[],u=null;for(;i.nextNode();){s++;let h=i.currentNode;for(h.previousSibling===u&&(u=null),t.has(h)&&(c.push(h),u===null&&(u=h)),u!==null&&l++;a!==void 0&&a.index===s;)a.index=u!==null?-1:a.index-l,o=xP(n,o),a=n[o]}c.forEach(h=>h.parentNode.removeChild(h))}var Lur=e=>{let t=e.nodeType===11?0:1,r=document.createTreeWalker(e,_ct,null,!1);for(;r.nextNode();)t++;return t},xP=(e,t=-1)=>{for(let r=t+1;r<e.length;r++){let n=e[r];if(vP(n))return r}return-1};function xce(e,t,r=null){let{element:{content:n},parts:i}=e;if(r==null){n.appendChild(t);return}let o=document.createTreeWalker(n,_ct,null,!1),a=xP(i),s=0,l=-1;for(;o.nextNode();)for(l++,o.currentNode===r&&(s=Lur(t),r.parentNode.insertBefore(t,r));a!==-1&&i[a].index===l;){if(s>0){for(;a!==-1;)i[a].index+=s,a=xP(i,a);return}a=xP(i,a)}}var kur=new WeakMap;var a1=e=>typeof e=="function"&&kur.has(e);var Ll={},VH={};var w0=class{constructor(t,r,n){this.__parts=[],this.template=t,this.processor=r,this.options=n}update(t){let r=0;for(let n of this.__parts)n!==void 0&&n.setValue(t[r]),r++;for(let n of this.__parts)n!==void 0&&n.commit()}_clone(){let t=mct?this.template.element.content.cloneNode(!0):document.importNode(this.template.element.content,!0),r=[],n=this.template.parts,i=document.createTreeWalker(t,133,null,!1),o=0,a=0,s,l=i.nextNode();for(;o<n.length;){if(s=n[o],!vP(s)){this.__parts.push(void 0),o++;continue}for(;a<s.index;)a++,l.nodeName==="TEMPLATE"&&(r.push(l),i.currentNode=l.content),(l=i.nextNode())===null&&(i.currentNode=r.pop(),l=i.nextNode());if(s.type==="node"){let c=this.processor.handleTextExpression(this.options);c.insertAfterNode(l.previousSibling),this.__parts.push(c)}else this.__parts.push(...this.processor.handleAttributeExpressions(l,s.name,s.strings,this.options));o++}return mct&&(document.adoptNode(t),customElements.upgrade(t)),t}};var bce=window.trustedTypes&&trustedTypes.createPolicy("lit-html",{createHTML:e=>e}),Nur=` ${Yc} `,S0=class{constructor(t,r,n,i){this.strings=t,this.values=r,this.type=n,this.processor=i}getHTML(){let t=this.strings.length-1,r="",n=!1;for(let i=0;i<t;i++){let o=this.strings[i],a=o.lastIndexOf("<!--");n=(a>-1||n)&&o.indexOf("-->",a+1)===-1;let s=HH.exec(o);s===null?r+=o+(n?Nur:gct):r+=o.substr(0,s.index)+s[1]+s[2]+d3+s[3]+Yc}return r+=this.strings[t],r}getTemplateElement(){let t=document.createElement("template"),r=this.getHTML();return bce!==void 0&&(r=bce.createHTML(r)),t.innerHTML=r,t}};var GH=e=>e===null||!(typeof e=="object"||typeof e=="function"),UH=e=>Array.isArray(e)||!!(e&&e[Symbol.iterator]),m3=class{constructor(t,r,n){this.dirty=!0,this.element=t,this.name=r,this.strings=n,this.parts=[];for(let i=0;i<n.length-1;i++)this.parts[i]=this._createPart()}_createPart(){return new bP(this)}_getValue(){let t=this.strings,r=t.length-1,n=this.parts;if(r===1&&t[0]===""&&t[1]===""){let o=n[0].value;if(typeof o=="symbol")return String(o);if(typeof o=="string"||!UH(o))return o}let i="";for(let o=0;o<r;o++){i+=t[o];let a=n[o];if(a!==void 0){let s=a.value;if(GH(s)||!UH(s))i+=typeof s=="string"?s:String(s);else for(let l of s)i+=typeof l=="string"?l:String(l)}}return i+=t[r],i}commit(){this.dirty&&(this.dirty=!1,this.element.setAttribute(this.name,this._getValue()))}},bP=class{constructor(t){this.value=void 0,this.committer=t}setValue(t){t!==Ll&&(!GH(t)||t!==this.value)&&(this.value=t,a1(t)||(this.committer.dirty=!0))}commit(){for(;a1(this.value);){let t=this.value;this.value=Ll,t(this)}this.value!==Ll&&this.committer.commit()}},Bd=class{constructor(t){this.value=void 0,this.__pendingValue=void 0,this.options=t}appendInto(t){this.startNode=t.appendChild(Yf()),this.endNode=t.appendChild(Yf())}insertAfterNode(t){this.startNode=t,this.endNode=t.nextSibling}appendIntoPart(t){t.__insert(this.startNode=Yf()),t.__insert(this.endNode=Yf())}insertAfterPart(t){t.__insert(this.startNode=Yf()),this.endNode=t.endNode,t.endNode=this.startNode}setValue(t){this.__pendingValue=t}commit(){if(this.startNode.parentNode===null)return;for(;a1(this.__pendingValue);){let r=this.__pendingValue;this.__pendingValue=Ll,r(this)}let t=this.__pendingValue;t!==Ll&&(GH(t)?t!==this.value&&this.__commitText(t):t instanceof S0?this.__commitTemplateResult(t):t instanceof Node?this.__commitNode(t):UH(t)?this.__commitIterable(t):t===VH?(this.value=VH,this.clear()):this.__commitText(t))}__insert(t){this.endNode.parentNode.insertBefore(t,this.endNode)}__commitNode(t){this.value!==t&&(this.clear(),this.__insert(t),this.value=t)}__commitText(t){let r=this.startNode.nextSibling;t=t==null?"":t;let n=typeof t=="string"?t:String(t);r===this.endNode.previousSibling&&r.nodeType===3?r.data=n:this.__commitNode(document.createTextNode(n)),this.value=t}__commitTemplateResult(t){let r=this.options.templateFactory(t);if(this.value instanceof w0&&this.value.template===r)this.value.update(t.values);else{let n=new w0(r,t.processor,this.options),i=n._clone();n.update(t.values),this.__commitNode(i),this.value=n}}__commitIterable(t){Array.isArray(this.value)||(this.value=[],this.clear());let r=this.value,n=0,i;for(let o of t)i=r[n],i===void 0&&(i=new Bd(this.options),r.push(i),n===0?i.appendIntoPart(this):i.insertAfterPart(r[n-1])),i.setValue(o),i.commit(),n++;n<r.length&&(r.length=n,this.clear(i&&i.endNode))}clear(t=this.startNode){i1(this.startNode.parentNode,t.nextSibling,this.endNode)}},wP=class{constructor(t,r,n){if(this.value=void 0,this.__pendingValue=void 0,n.length!==2||n[0]!==""||n[1]!=="")throw new Error("Boolean attributes can only contain a single expression");this.element=t,this.name=r,this.strings=n}setValue(t){this.__pendingValue=t}commit(){for(;a1(this.__pendingValue);){let r=this.__pendingValue;this.__pendingValue=Ll,r(this)}if(this.__pendingValue===Ll)return;let t=!!this.__pendingValue;this.value!==t&&(t?this.element.setAttribute(this.name,""):this.element.removeAttribute(this.name),this.value=t),this.__pendingValue=Ll}},SP=class extends m3{constructor(t,r,n){super(t,r,n),this.single=n.length===2&&n[0]===""&&n[1]===""}_createPart(){return new qH(this)}_getValue(){return this.single?this.parts[0].value:super._getValue()}commit(){this.dirty&&(this.dirty=!1,this.element[this.name]=this._getValue())}},qH=class extends bP{},wce=!1;(()=>{try{let e={get capture(){return wce=!0,!1}};window.addEventListener("test",e,e),window.removeEventListener("test",e,e)}catch(e){}})();var MP=class{constructor(t,r,n){this.value=void 0,this.__pendingValue=void 0,this.element=t,this.eventName=r,this.eventContext=n,this.__boundHandleEvent=i=>this.handleEvent(i)}setValue(t){this.__pendingValue=t}commit(){for(;a1(this.__pendingValue);){let o=this.__pendingValue;this.__pendingValue=Ll,o(this)}if(this.__pendingValue===Ll)return;let t=this.__pendingValue,r=this.value,n=t==null||r!=null&&(t.capture!==r.capture||t.once!==r.once||t.passive!==r.passive),i=t!=null&&(r==null||n);n&&this.element.removeEventListener(this.eventName,this.__boundHandleEvent,this.__options),i&&(this.__options=Dur(t),this.element.addEventListener(this.eventName,this.__boundHandleEvent,this.__options)),this.value=t,this.__pendingValue=Ll}handleEvent(t){typeof this.value=="function"?this.value.call(this.eventContext||this.element,t):this.value.handleEvent(t)}},Dur=e=>e&&(wce?{capture:e.capture,passive:e.passive,once:e.once}:e.capture);function vct(e){let t=s1.get(e.type);t===void 0&&(t={stringsArray:new WeakMap,keyString:new Map},s1.set(e.type,t));let r=t.stringsArray.get(e.strings);if(r!==void 0)return r;let n=e.strings.join(Yc);return r=t.keyString.get(n),r===void 0&&(r=new o1(e,e.getTemplateElement()),t.keyString.set(n,r)),t.stringsArray.set(e.strings,r),r}var s1=new Map;var M0=new WeakMap,xct=(e,t,r)=>{let n=M0.get(t);n===void 0&&(i1(t,t.firstChild),M0.set(t,n=new Bd(Object.assign({templateFactory:vct},r))),n.appendInto(t)),n.setValue(e),n.commit()};var WH=class{handleAttributeExpressions(t,r,n,i){let o=r[0];return o==="."?new SP(t,r.slice(1),n).parts:o==="@"?[new MP(t,r.slice(1),i.eventContext)]:o==="?"?[new wP(t,r.slice(1),n)]:new m3(t,r,n).parts}handleTextExpression(t){return new Bd(t)}},Sce=new WH;typeof window!="undefined"&&(window.litHtmlVersions||(window.litHtmlVersions=[])).push("1.4.1");var Ece=(e,t)=>`${e}--${t}`,YH=!0;typeof window.ShadyCSS=="undefined"?YH=!1:typeof window.ShadyCSS.prepareTemplateDom=="undefined"&&(console.warn("Incompatible ShadyCSS version detected. Please update to at least @webcomponents/webcomponentsjs@2.0.2 and @webcomponents/shadycss@1.3.1."),YH=!1);var Fur=e=>t=>{let r=Ece(t.type,e),n=s1.get(r);n===void 0&&(n={stringsArray:new WeakMap,keyString:new Map},s1.set(r,n));let i=n.stringsArray.get(t.strings);if(i!==void 0)return i;let o=t.strings.join(Yc);if(i=n.keyString.get(o),i===void 0){let a=t.getTemplateElement();YH&&window.ShadyCSS.prepareTemplateDom(a,e),i=new o1(t,a),n.keyString.set(o,i)}return n.stringsArray.set(t.strings,i),i},Bur=["html","svg"],Hur=e=>{Bur.forEach(t=>{let r=s1.get(Ece(t,e));r!==void 0&&r.keyString.forEach(n=>{let{element:{content:i}}=n,o=new Set;Array.from(i.querySelectorAll("style")).forEach(a=>{o.add(a)}),yct(n,o)})})},Tce=new Set,Vur=(e,t,r)=>{Tce.add(e);let n=r?r.element:document.createElement("template"),i=t.querySelectorAll("style"),{length:o}=i;if(o===0){window.ShadyCSS.prepareTemplateStyles(n,e);return}let a=document.createElement("style");for(let c=0;c<o;c++){let u=i[c];u.parentNode.removeChild(u),a.textContent+=u.textContent}Hur(e);let s=n.content;r?xce(r,a,s.firstChild):s.insertBefore(a,s.firstChild),window.ShadyCSS.prepareTemplateStyles(n,e);let l=s.querySelector("style");if(window.ShadyCSS.nativeShadow&&l!==null)t.insertBefore(l.cloneNode(!0),t.firstChild);else if(r){s.insertBefore(a,s.firstChild);let c=new Set;c.add(a),yct(r,c)}},Cce=(e,t,r)=>{if(!r||typeof r!="object"||!r.scopeName)throw new Error("The `scopeName` option is required.");let n=r.scopeName,i=M0.has(t),o=YH&&t.nodeType===11&&!!t.host,a=o&&!Tce.has(n),s=a?document.createDocumentFragment():t;if(xct(e,s,Object.assign({templateFactory:Fur(n)},r)),a){let l=M0.get(s);M0.delete(s);let c=l.value instanceof w0?l.value.template:void 0;Vur(n,s,c),i1(t,t.firstChild),t.appendChild(s),M0.set(t,l)}!i&&o&&window.ShadyCSS.styleElement(t.host)};var Ace;window.JSCompiler_renameProperty=(e,t)=>e;var Tct={toAttribute(e,t){switch(t){case Boolean:return e?"":null;case Object:case Array:return e==null?e:JSON.stringify(e)}return e},fromAttribute(e,t){switch(t){case Boolean:return e!==null;case Number:return e===null?null:Number(e);case Object:case Array:return JSON.parse(e)}return e}},Pce=(e,t)=>t!==e&&(t===t||e===e),bct={attribute:!0,type:String,converter:Tct,reflect:!1,hasChanged:Pce},wct=1,Sct=1<<2,Mct=1<<3,Ect=1<<4,Cct="finalized",g3=class extends HTMLElement{constructor(){super(),this.initialize()}static get observedAttributes(){this.finalize();let t=[];return this._classProperties.forEach((r,n)=>{let i=this._attributeNameForProperty(n,r);i!==void 0&&(this._attributeToPropertyMap.set(i,n),t.push(i))}),t}static _ensureClassProperties(){if(!this.hasOwnProperty(JSCompiler_renameProperty("_classProperties",this))){this._classProperties=new Map;let t=Object.getPrototypeOf(this)._classProperties;t!==void 0&&t.forEach((r,n)=>this._classProperties.set(n,r))}}static createProperty(t,r=bct){if(this._ensureClassProperties(),this._classProperties.set(t,r),r.noAccessor||this.prototype.hasOwnProperty(t))return;let n=typeof t=="symbol"?Symbol():`__${t}`,i=this.getPropertyDescriptor(t,n,r);i!==void 0&&Object.defineProperty(this.prototype,t,i)}static getPropertyDescriptor(t,r,n){return{get(){return this[r]},set(i){let o=this[t];this[r]=i,this.requestUpdateInternal(t,o,n)},configurable:!0,enumerable:!0}}static getPropertyOptions(t){return this._classProperties&&this._classProperties.get(t)||bct}static finalize(){let t=Object.getPrototypeOf(this);if(t.hasOwnProperty(Cct)||t.finalize(),this[Cct]=!0,this._ensureClassProperties(),this._attributeToPropertyMap=new Map,this.hasOwnProperty(JSCompiler_renameProperty("properties",this))){let r=this.properties,n=[...Object.getOwnPropertyNames(r),...typeof Object.getOwnPropertySymbols=="function"?Object.getOwnPropertySymbols(r):[]];for(let i of n)this.createProperty(i,r[i])}}static _attributeNameForProperty(t,r){let n=r.attribute;return n===!1?void 0:typeof n=="string"?n:typeof t=="string"?t.toLowerCase():void 0}static _valueHasChanged(t,r,n=Pce){return n(t,r)}static _propertyValueFromAttribute(t,r){let n=r.type,i=r.converter||Tct,o=typeof i=="function"?i:i.fromAttribute;return o?o(t,n):t}static _propertyValueToAttribute(t,r){if(r.reflect===void 0)return;let n=r.type,i=r.converter;return(i&&i.toAttribute||Tct.toAttribute)(t,n)}initialize(){this._updateState=0,this._updatePromise=new Promise(t=>this._enableUpdatingResolver=t),this._changedProperties=new Map,this._saveInstanceProperties(),this.requestUpdateInternal()}_saveInstanceProperties(){this.constructor._classProperties.forEach((t,r)=>{if(this.hasOwnProperty(r)){let n=this[r];delete this[r],this._instanceProperties||(this._instanceProperties=new Map),this._instanceProperties.set(r,n)}})}_applyInstanceProperties(){this._instanceProperties.forEach((t,r)=>this[r]=t),this._instanceProperties=void 0}connectedCallback(){this.enableUpdating()}enableUpdating(){this._enableUpdatingResolver!==void 0&&(this._enableUpdatingResolver(),this._enableUpdatingResolver=void 0)}disconnectedCallback(){}attributeChangedCallback(t,r,n){r!==n&&this._attributeToProperty(t,n)}_propertyToAttribute(t,r,n=bct){let i=this.constructor,o=i._attributeNameForProperty(t,n);if(o!==void 0){let a=i._propertyValueToAttribute(r,n);if(a===void 0)return;this._updateState=this._updateState|Mct,a==null?this.removeAttribute(o):this.setAttribute(o,a),this._updateState=this._updateState&~Mct}}_attributeToProperty(t,r){if(this._updateState&Mct)return;let n=this.constructor,i=n._attributeToPropertyMap.get(t);if(i!==void 0){let o=n.getPropertyOptions(i);this._updateState=this._updateState|Ect,this[i]=n._propertyValueFromAttribute(r,o),this._updateState=this._updateState&~Ect}}requestUpdateInternal(t,r,n){let i=!0;if(t!==void 0){let o=this.constructor;n=n||o.getPropertyOptions(t),o._valueHasChanged(this[t],r,n.hasChanged)?(this._changedProperties.has(t)||this._changedProperties.set(t,r),n.reflect===!0&&!(this._updateState&Ect)&&(this._reflectingProperties===void 0&&(this._reflectingProperties=new Map),this._reflectingProperties.set(t,n))):i=!1}!this._hasRequestedUpdate&&i&&(this._updatePromise=this._enqueueUpdate())}requestUpdate(t,r){return this.requestUpdateInternal(t,r),this.updateComplete}_enqueueUpdate(){return Ri(this,null,function*(){this._updateState=this._updateState|Sct;try{yield this._updatePromise}catch(r){}let t=this.performUpdate();return t!=null&&(yield t),!this._hasRequestedUpdate})}get _hasRequestedUpdate(){return this._updateState&Sct}get hasUpdated(){return this._updateState&wct}performUpdate(){if(!this._hasRequestedUpdate)return;this._instanceProperties&&this._applyInstanceProperties();let t=!1,r=this._changedProperties;try{t=this.shouldUpdate(r),t?this.update(r):this._markUpdated()}catch(n){throw t=!1,this._markUpdated(),n}t&&(this._updateState&wct||(this._updateState=this._updateState|wct,this.firstUpdated(r)),this.updated(r))}_markUpdated(){this._changedProperties=new Map,this._updateState=this._updateState&~Sct}get updateComplete(){return this._getUpdateComplete()}_getUpdateComplete(){return this.getUpdateComplete()}getUpdateComplete(){return this._updatePromise}shouldUpdate(t){return!0}update(t){this._reflectingProperties!==void 0&&this._reflectingProperties.size>0&&(this._reflectingProperties.forEach((r,n)=>this._propertyToAttribute(n,this[n],r)),this._reflectingProperties=void 0),this._markUpdated()}updated(t){}firstUpdated(t){}};Ace=Cct;g3[Ace]=!0;var Ice=Element.prototype,Iii=Ice.msMatchesSelector||Ice.webkitMatchesSelector;var jH=window.ShadowRoot&&(window.ShadyCSS===void 0||window.ShadyCSS.nativeShadow)&&"adoptedStyleSheets"in Document.prototype&&"replace"in CSSStyleSheet.prototype,Act=Symbol(),l1=class{constructor(t,r){if(r!==Act)throw new Error("CSSResult is not constructable. Use `unsafeCSS` or `css` instead.");this.cssText=t}get styleSheet(){return this._styleSheet===void 0&&(jH?(this._styleSheet=new CSSStyleSheet,this._styleSheet.replaceSync(this.cssText)):this._styleSheet=null),this._styleSheet}toString(){return this.cssText}},Pct=e=>new l1(String(e),Act),Uur=e=>{if(e instanceof l1)return e.cssText;if(typeof e=="number")return e;throw new Error(`Value passed to 'css' function must be a 'css' function result: ${e}. Use 'unsafeCSS' to pass non-literal values, but
            take care to ensure page security.`)},Ci=(e,...t)=>{let r=t.reduce((n,i,o)=>n+Uur(i)+e[o+1],e[0]);return new l1(r,Act)};(window.litElementVersions||(window.litElementVersions=[])).push("2.5.1");var Lce={},EP=class extends g3{static getStyles(){return this.styles}static _getUniqueStyles(){if(this.hasOwnProperty(JSCompiler_renameProperty("_styles",this)))return;let t=this.getStyles();if(Array.isArray(t)){let r=(o,a)=>o.reduceRight((s,l)=>Array.isArray(l)?r(l,s):(s.add(l),s),a),n=r(t,new Set),i=[];n.forEach(o=>i.unshift(o)),this._styles=i}else this._styles=t===void 0?[]:[t];this._styles=this._styles.map(r=>{if(r instanceof CSSStyleSheet&&!jH){let n=Array.prototype.slice.call(r.cssRules).reduce((i,o)=>i+o.cssText,"");return Pct(n)}return r})}initialize(){super.initialize(),this.constructor._getUniqueStyles(),this.renderRoot=this.createRenderRoot(),window.ShadowRoot&&this.renderRoot instanceof window.ShadowRoot&&this.adoptStyles()}createRenderRoot(){return this.attachShadow(this.constructor.shadowRootOptions)}adoptStyles(){let t=this.constructor._styles;t.length!==0&&(window.ShadyCSS!==void 0&&!window.ShadyCSS.nativeShadow?window.ShadyCSS.ScopingShim.prepareAdoptedCssText(t.map(r=>r.cssText),this.localName):jH?this.renderRoot.adoptedStyleSheets=t.map(r=>r instanceof CSSStyleSheet?r:r.styleSheet):this._needsShimAdoptedStyleSheets=!0)}connectedCallback(){super.connectedCallback(),this.hasUpdated&&window.ShadyCSS!==void 0&&window.ShadyCSS.styleElement(this)}update(t){let r=this.render();super.update(t),r!==Lce&&this.constructor.render(r,this.renderRoot,{scopeName:this.localName,eventContext:this}),this._needsShimAdoptedStyleSheets&&(this._needsShimAdoptedStyleSheets=!1,this.constructor._styles.forEach(n=>{let i=document.createElement("style");i.textContent=n.cssText,this.renderRoot.appendChild(i)}))}render(){return Lce}};EP.finalized=!0;EP.render=Cce;EP.shadowRootOptions={mode:"open"};var kce=0,Ict={},jc=(e,t,r)=>{let n=r&&r.moduleId||`custom-style-module-${kce++}`;Array.isArray(t)||(t=t?[t]:[]),t.forEach(a=>{if(!(a instanceof l1))throw new Error("An item in styles is not of type CSSResult. Use `unsafeCSS` or `css`.");if(!Ict[a]){let s=document.createElement("dom-module");s.innerHTML=`
        <template>
          <style>${a.toString()}</style>
        </template>
      `;let l=`custom-style-module-${kce++}`;s.register(l),Ict[a]=l}});let i=document.createElement("dom-module");if(e){let a=customElements.get(e);a&&Object.prototype.hasOwnProperty.call(a,"__finalized")&&console.warn(`The custom element definition for "${e}"
      was finalized before a style module was registered.
      Make sure to add component specific style modules before
      importing the corresponding custom element.`),i.setAttribute("theme-for",e)}let o=r&&r.include||[];i.innerHTML=`
    <template>
      ${o.map(a=>`<style include=${a}></style>`)}
      ${t.map(a=>`<style include=${Ict[a]}></style>`)}
    </template>
  `,i.register(n)};var Lct=class extends HTMLElement{static get version(){return"20.0.2"}};customElements.define("vaadin-lumo-styles",Lct);var qur=Ci`
  :host {
    /* Base (background) */
    --lumo-base-color: #fff;

    /* Tint */
    --lumo-tint-5pct: hsla(0, 0%, 100%, 0.3);
    --lumo-tint-10pct: hsla(0, 0%, 100%, 0.37);
    --lumo-tint-20pct: hsla(0, 0%, 100%, 0.44);
    --lumo-tint-30pct: hsla(0, 0%, 100%, 0.5);
    --lumo-tint-40pct: hsla(0, 0%, 100%, 0.57);
    --lumo-tint-50pct: hsla(0, 0%, 100%, 0.64);
    --lumo-tint-60pct: hsla(0, 0%, 100%, 0.7);
    --lumo-tint-70pct: hsla(0, 0%, 100%, 0.77);
    --lumo-tint-80pct: hsla(0, 0%, 100%, 0.84);
    --lumo-tint-90pct: hsla(0, 0%, 100%, 0.9);
    --lumo-tint: #fff;

    /* Shade */
    --lumo-shade-5pct: hsla(214, 61%, 25%, 0.05);
    --lumo-shade-10pct: hsla(214, 57%, 24%, 0.1);
    --lumo-shade-20pct: hsla(214, 53%, 23%, 0.16);
    --lumo-shade-30pct: hsla(214, 50%, 22%, 0.26);
    --lumo-shade-40pct: hsla(214, 47%, 21%, 0.38);
    --lumo-shade-50pct: hsla(214, 45%, 20%, 0.5);
    --lumo-shade-60pct: hsla(214, 43%, 19%, 0.61);
    --lumo-shade-70pct: hsla(214, 42%, 18%, 0.72);
    --lumo-shade-80pct: hsla(214, 41%, 17%, 0.83);
    --lumo-shade-90pct: hsla(214, 40%, 16%, 0.94);
    --lumo-shade: hsl(214, 35%, 15%);

    /* Contrast */
    --lumo-contrast-5pct: var(--lumo-shade-5pct);
    --lumo-contrast-10pct: var(--lumo-shade-10pct);
    --lumo-contrast-20pct: var(--lumo-shade-20pct);
    --lumo-contrast-30pct: var(--lumo-shade-30pct);
    --lumo-contrast-40pct: var(--lumo-shade-40pct);
    --lumo-contrast-50pct: var(--lumo-shade-50pct);
    --lumo-contrast-60pct: var(--lumo-shade-60pct);
    --lumo-contrast-70pct: var(--lumo-shade-70pct);
    --lumo-contrast-80pct: var(--lumo-shade-80pct);
    --lumo-contrast-90pct: var(--lumo-shade-90pct);
    --lumo-contrast: var(--lumo-shade);

    /* Text */
    --lumo-header-text-color: var(--lumo-contrast);
    --lumo-body-text-color: var(--lumo-contrast-90pct);
    --lumo-secondary-text-color: var(--lumo-contrast-70pct);
    --lumo-tertiary-text-color: var(--lumo-contrast-50pct);
    --lumo-disabled-text-color: var(--lumo-contrast-30pct);

    /* Primary */
    --lumo-primary-color: hsl(214, 90%, 52%);
    --lumo-primary-color-50pct: hsla(214, 90%, 52%, 0.5);
    --lumo-primary-color-10pct: hsla(214, 90%, 52%, 0.1);
    --lumo-primary-text-color: var(--lumo-primary-color);
    --lumo-primary-contrast-color: #fff;

    /* Error */
    --lumo-error-color: hsl(3, 100%, 61%);
    --lumo-error-color-50pct: hsla(3, 100%, 60%, 0.5);
    --lumo-error-color-10pct: hsla(3, 100%, 60%, 0.1);
    --lumo-error-text-color: hsl(3, 92%, 53%);
    --lumo-error-contrast-color: #fff;

    /* Success */
    --lumo-success-color: hsl(145, 80%, 42%); /* hsl(144,82%,37%); */
    --lumo-success-color-50pct: hsla(145, 76%, 44%, 0.55);
    --lumo-success-color-10pct: hsla(145, 76%, 44%, 0.12);
    --lumo-success-text-color: hsl(145, 100%, 32%);
    --lumo-success-contrast-color: #fff;
  }
`,Rce=document.createElement("template");Rce.innerHTML=`<style>${qur.toString().replace(":host","html")}</style>`;document.head.appendChild(Rce.content);var Gur=Ci`
  [theme~='dark'] {
    /* Base (background) */
    --lumo-base-color: hsl(214, 35%, 21%);

    /* Tint */
    --lumo-tint-5pct: hsla(214, 65%, 85%, 0.06);
    --lumo-tint-10pct: hsla(214, 60%, 80%, 0.14);
    --lumo-tint-20pct: hsla(214, 64%, 82%, 0.23);
    --lumo-tint-30pct: hsla(214, 69%, 84%, 0.32);
    --lumo-tint-40pct: hsla(214, 73%, 86%, 0.41);
    --lumo-tint-50pct: hsla(214, 78%, 88%, 0.5);
    --lumo-tint-60pct: hsla(214, 82%, 90%, 0.6);
    --lumo-tint-70pct: hsla(214, 87%, 92%, 0.7);
    --lumo-tint-80pct: hsla(214, 91%, 94%, 0.8);
    --lumo-tint-90pct: hsla(214, 96%, 96%, 0.9);
    --lumo-tint: hsl(214, 100%, 98%);

    /* Shade */
    --lumo-shade-5pct: hsla(214, 0%, 0%, 0.07);
    --lumo-shade-10pct: hsla(214, 4%, 2%, 0.15);
    --lumo-shade-20pct: hsla(214, 8%, 4%, 0.23);
    --lumo-shade-30pct: hsla(214, 12%, 6%, 0.32);
    --lumo-shade-40pct: hsla(214, 16%, 8%, 0.41);
    --lumo-shade-50pct: hsla(214, 20%, 10%, 0.5);
    --lumo-shade-60pct: hsla(214, 24%, 12%, 0.6);
    --lumo-shade-70pct: hsla(214, 28%, 13%, 0.7);
    --lumo-shade-80pct: hsla(214, 32%, 13%, 0.8);
    --lumo-shade-90pct: hsla(214, 33%, 13%, 0.9);
    --lumo-shade: hsl(214, 33%, 13%);

    /* Contrast */
    --lumo-contrast-5pct: var(--lumo-tint-5pct);
    --lumo-contrast-10pct: var(--lumo-tint-10pct);
    --lumo-contrast-20pct: var(--lumo-tint-20pct);
    --lumo-contrast-30pct: var(--lumo-tint-30pct);
    --lumo-contrast-40pct: var(--lumo-tint-40pct);
    --lumo-contrast-50pct: var(--lumo-tint-50pct);
    --lumo-contrast-60pct: var(--lumo-tint-60pct);
    --lumo-contrast-70pct: var(--lumo-tint-70pct);
    --lumo-contrast-80pct: var(--lumo-tint-80pct);
    --lumo-contrast-90pct: var(--lumo-tint-90pct);
    --lumo-contrast: var(--lumo-tint);

    /* Text */
    --lumo-header-text-color: var(--lumo-contrast);
    --lumo-body-text-color: var(--lumo-contrast-90pct);
    --lumo-secondary-text-color: var(--lumo-contrast-70pct);
    --lumo-tertiary-text-color: var(--lumo-contrast-50pct);
    --lumo-disabled-text-color: var(--lumo-contrast-30pct);

    /* Primary */
    --lumo-primary-color: hsl(214, 86%, 55%);
    --lumo-primary-color-50pct: hsla(214, 86%, 55%, 0.5);
    --lumo-primary-color-10pct: hsla(214, 90%, 63%, 0.1);
    --lumo-primary-text-color: hsl(214, 100%, 70%);
    --lumo-primary-contrast-color: #fff;

    /* Error */
    --lumo-error-color: hsl(3, 90%, 63%);
    --lumo-error-color-50pct: hsla(3, 90%, 63%, 0.5);
    --lumo-error-color-10pct: hsla(3, 90%, 63%, 0.1);
    --lumo-error-text-color: hsl(3, 100%, 67%);

    /* Success */
    --lumo-success-color: hsl(145, 65%, 42%);
    --lumo-success-color-50pct: hsla(145, 65%, 42%, 0.5);
    --lumo-success-color-10pct: hsla(145, 65%, 42%, 0.1);
    --lumo-success-text-color: hsl(145, 85%, 47%);
  }

  html {
    color: var(--lumo-body-text-color);
    background-color: var(--lumo-base-color);
  }

  [theme~='dark'] {
    color: var(--lumo-body-text-color);
    background-color: var(--lumo-base-color);
  }

  h1,
  h2,
  h3,
  h4,
  h5,
  h6 {
    color: var(--lumo-header-text-color);
  }

  a {
    color: var(--lumo-primary-text-color);
  }

  blockquote {
    color: var(--lumo-secondary-text-color);
  }

  code,
  pre {
    background-color: var(--lumo-contrast-10pct);
    border-radius: var(--lumo-border-radius-m);
  }
`;jc("",Gur,{moduleId:"lumo-color"});var Wur=Ci`
  :host {
    color: var(--lumo-body-text-color) !important;
    background-color: var(--lumo-base-color) !important;
  }
`;jc("",Wur,{moduleId:"lumo-color-legacy",include:["lumo-color"]});var Nce=document.createElement("template");Nce.innerHTML=`
  <style>
    @font-face {
      font-family: 'lumo-icons';
      src: url(data:application/font-woff;charset=utf-8;base64,d09GRgABAAAAABEcAAsAAAAAIiwAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAABHU1VCAAABCAAAADsAAABUIIslek9TLzIAAAFEAAAAQwAAAFZAIUuKY21hcAAAAYgAAAD4AAADrsCU8d5nbHlmAAACgAAAC2MAABd4h9To2WhlYWQAAA3kAAAAMAAAADZa/6SsaGhlYQAADhQAAAAdAAAAJAbpA35obXR4AAAONAAAABAAAACspBAAAGxvY2EAAA5EAAAAWAAAAFh55IAsbWF4cAAADpwAAAAfAAAAIAFKAXBuYW1lAAAOvAAAATEAAAIuUUJZCHBvc3QAAA/wAAABKwAAAelm8SzVeJxjYGRgYOBiMGCwY2BycfMJYeDLSSzJY5BiYGGAAJA8MpsxJzM9kYEDxgPKsYBpDiBmg4gCACY7BUgAeJxjYGS+yDiBgZWBgamKaQ8DA0MPhGZ8wGDIyAQUZWBlZsAKAtJcUxgcXjG+0mIO+p/FEMUcxDANKMwIkgMABn8MLQB4nO3SWW6DMABF0UtwCEnIPM/zhLK8LqhfXRybSP14XUYtHV9hGYQwQBNIo3cUIPkhQeM7rib1ekqnXg981XuC1qvy84lzojleh3puxL0hPjGjRU473teloEefAUNGjJkwZcacBUtWrNmwZceeA0dOnLlw5cadB09elPGhGf+j0NTI/65KfXerT6JhqKnpRKtgOpuqaTrtKjPUlqHmhto21I7pL6i6hlqY3q7qGWrfUAeGOjTUkaGODXViqFNDnRnq3FAXhro01JWhrg11Y6hbQ90Z6t5QD4Z6NNSToZ4N9WKoV0O9GerdUB+G+jTUl6GWRvkL24BkEXictVh9bFvVFb/nxvbz+7Rf/N6zHcd2bCfP+Wgc1Z9N0jpNnEL6kbRVS6HA2hQYGh9TGR1CbCqa2rXrWOkQE/sHNJgmtZvoVNZqE1B1DNHxzTQxCehUTYiJTQyENui0qSLezr3PduyQfgmRWOfde8+9551z7rnn/O4jLoJ/bRP0UaKQMLFJjpBAvphLZC3Dk0ok7WBzR2/upJs7Ryw/nfFbln/uuN/apCvwrKLrSvUqRufbm5pn0fs0w4gYxnGVP6qHnO4bWiDQGQgwtS6lm3lB3QoX1M2vwEmuzirF39y+Es2+DJ8d1pkyqBIqoze3D1+Zz4DrFoazxI8dWwMrDlZ2DMqQAR9AROsJU+2cmlTPazTco52F1xTa2a2+K8vvq92dVHmtLoPeQX/AZPRYGthDYOeZjBjKoFsVGulR3lWU95WeCK44qHU7MhWUGUKZDT3oKUcG2GWuh+EDDfUYA/jhAhl0TOsJNYSEu7mQmi3UzfXwZKA4BsVsHLXQYGgRW95uEtpJ1Vfn9XiLriRBlFEqxsDjA09yCNUoQxxwd7KWSTt2y3GTKiflqHRSoWZc3m11Wa/fJdFgXD4sSYfleJBKd8GMz7J8dZn/cGRCcKGDnA2Ge3fKzcvlnTDNthGWLXzX/WaXtUAmRgeLlHSr30r0G9UTXMb0AtmwzOoy73fkSlHZkduw/TYuU9cAD4YutPoxTTsA3797wVr4Z/1NC5zARHr4vtxJjxIfiZMhMkbWk+14BnJZKwqGZwDfswLyxWDSg11rFLJF7Nopxjd1h1/QOT+oezgfu3Yq+Hk+duf5x+40o1GTkaIgikK/IEnC6aYxCUBaZJSN4XTYFjU/YMNIKqJwhDGOCCI8FDXnXmXjtGhGJyShqjAOnBOkW2JG9S7GgYeMWAU5JzhnWmBOaOM+CKEPoqSfFDC2Unq+DLlUgUVUFFLZGJg6jtlojsdsa8kPObPuJdi5dnBdBsLJMGTWDa4t2JvtwuPo9s+Y86suv/W33QG1rAaOAUV+vx4K6f2D04PVKlC7WLSrZzAi45ZV6lIC7WoXqmRyvUqoVwrzUoVsIjeTXWQv+RH5GTlBXiB/In8ln0IbBCAFOajAJrgZYyOHWqOfUe/aHjI12R6OQo1jCgt215l+4f6XPb+0MNou0V+43n2F77tSfRb24d7zitgnKmvYHs69zugaPvBwv6ioXkb2LdL65Atw51uLkXlu1bhMMRcXSPcYoqKIRlh34lQP8/5JbuUFye4vxD6/6MxFF11C0uVLr9Ulgw44tS3pMViNLUExbycFgLIct+QDMibRimx1ydUz8FXZiuOIDBOMVX2nUZc+huNE5XUJ81uiJoiabwqaVF0uacKbau/pl4R2VW0XXlJra6boVrYG646TF5NYzwy4vjENVrDlcNpZPl8DH6XX8XWCx0mvWVZY6KFLrvsY66/zPict5FnxaNUR/juvZCM3TvD60E2W1tZizbXTPDuabcm0nbbzpWKpmA1ayBQ8giedLUM+A0kNjBjQjmuYz7YrgIXYvmF63ZLBwSXrpn9Tb9wwdd/U1H0PMQK3XcO8ul3WT7PyPPdpy0TemKxNRcJNauiXJnnUDpUppQWs4SnUIy0EESGYqJYQLGHxzaGWwVIaS6Y7mQFM8ZjYDQ3axjf61SWjU33JwOZA1pwaG1L9mzf71aHRdX1JHw6Fp0aXhNwbqyeGNg4NbdzGCBxoz4ZXjy4Nu69Zr6sDY6vMrLU5nA1P8JkbdWXJ6ERfMryvNh1JfQ9+T4dIhGvK9w3dxjBBzatsQ/MlOHVIDnYpDz6odAXlQ01t2Pa5Iafd8MMpxAeDKP0C6CjgVLT5osB6icUx01lWjXxzT/GyRF2welEM5Z/7jG3VjQ1SrNn5IbyzOG5dobB3/QHxyZvsXcoz8IoEwS7plCg+zxHQk424q9BfEpkESJbFHQusDBSWFkuBkoPO0kLKwRVYjxGXlHTcTDQMJ/H6TX9afkO7mnraTO1feTnZAXLu4cp7HAXMmNG1yeFk9TgS/NHhZR/4QoBTr/ZB+6hCgyl15Nq1UbN6nE1/ZnP1U2cizCBpvs8cJQZJ4LkYx5N/yZPAUZNQQ0V4f3BQllWrK3YRzl30dOT6RVn2upNur6woSa8CqpdT/aKnBM4o3jNur9d9xqtUT6veBEt9Ca9at+ERzEEhUkR8sa5mQ4aVvJoVeEA8zI4ei5mULXFGyU7z/6TAeYLVcpzSWZY8PYYF5yrTV60sT0+XV141vX++Wf16V2bFeGVPZXxFpkvyeKTWLlzfW0mnKxsY6Y3294/0998SCfX1blm5pbcvFGlq/r07MRAMhYIDiW5JFKWW3vdrEpCsZSJG+om7Zu/PSScZJhNkLbmW5Wsr12pWqW5zKtlwRS4bFOxUw17mCzy6lskCDl1WYOGWDYrADrMA7BDDweWWNd5koiJnR1dz+ytLP2q0SqPB1lnK2ccB7RYe4FSoPks3iB3t4txTSHctb2sy1ivk0pvHuCNm6w1f6wxv3+OCgN78LqdQnUVh7R0oTAp0zOf2rbW770Vu5C2dIyGdTnHo8zSji7dppj0USoVCz+lhRMTh53Teq9VbGfbjuSbAooSdXayY4PYHg374C6f7gl1B/DXuJ4/QXxOBdJFJspFsI3egpoWUUCjlTIFnNYNl+ZyZKmBeYKGHkD1QyDlhaKbKwKcIJqJ4TLJ2OmdY/JWXae4DdGBw8HZ7eXcgFF2zr2SoalDry5iKqoa0Puhe3hPQ2s3elTYM+MI+n3rK0KgL7/La3GeMLt6m7u912vGnvtORiIa0qBmhqVi+XW9XNBmqb8eVgKzIHfGI5bNoG7X0UCzeISmqIcO/nY8FH7U8avX9fx/ST+hx0sezPw9Qy8Mum3GWf2N4Uy/yIYGVBXbJHWIZp7dfTcptdMTr9Qmq7DaiK/ukqCL4kt4RUfS5XPnMtmT22/mQFqF7emSqtrlu8SVElxDRJrZODkpuwe0VfTfjdEp1f7A7v+fozNBXUJ/6WTuK2TtFlpFVZAZ3LcFvUi1Z2p2YT+EMAkGJVStOzLTAPg4IqWIAlzRSjOBkl2zxj3TKycpzT/MnvX3uaSMWM+gU0rkXjohhefVRMaps3/kLMSKv23lT23uxQrkQjyOJleMDsdhAnD6ZGElWZ5MjCXzCE/hkWX+WF4knzGhVOyK2eQZekV3eyo0zL8kuYWCnDCvjjhAkcTPOBDXVdoav3HVcFnQjLvtV9S2p0zA6JegPwMQxt+yFb3ll9zGlq/5dRKb3cEyQYoaNYpharJ7xCB7AWxsLY3jjZXY0XsZj0Wjwc9I6PP/dKABnCZaqHpaZEACxk4ZeLZSKNgZABl+lYQX1sJQOSX3n6r410evcoud5JeAGUXVP9H1tZOKejTq4Ono0z0erro1FrnOpohva1d/hTdtVsQdKN5W9RlT3NjD0nznyKNTgKAMfWNWcyodV0IGLPIHOF0o4JyqufaK4z6WIIzuGh3d8c8cwQg8ER+OVxyrjdm8vNuhts4LoOihGxIMuUdgzwiYN7xhh1+oZnJNuTG7gQZvu4XWZ9GAZZjGEubwePqYhtKDTH+9VQkl17/iGybsnJ+8+sKtyPrcll9ty65Zsdst/9iqpEKh7M5VdBxh3csOdNc6tW3I1uyM1PzOXegSOrLFsFNI2O27M+TF2ApnN9MUv5ud6LjxIvEQnHRzxIu4IsA9MLFkJn2tcZoZ7ON7dXe7ujrc8HrusPKamlqXwd77lQUuLpilau4PUMapueBb7irU4RoUXEYXuVuIGlRGmOp+2lNkaRPVziOqmlaZvaqG4dFgSj0jxEJWrv12IUWntmw+rfQarRE0Aph4ocI6nlUlGqs+u3/+T/ethW62PpHp2eHbZstnh/wOO95yDAHicY2BkYGAA4pmJ6QHx/DZfGbiZXwBFGGpUNzQi6P+vmacy3QJyORiYQKIANoULVXicY2BkYGAO+p8FJF8wAAHzVAZGBlSgDQBW9gNvAAAAeJxjYGBgYH4xNDAAzwQmjwAAAAAATgCaAOgBCgEsAU4BcAGaAcQB7gIaApwC6ASaBLwE1gTyBQ4FKgV6BdAF/gZEBmYGtgcYB5AIGAhSCGoI/glGCb4J2goECjwKggq4CvALUAuWC7x4nGNgZGBg0GZMYRBlAAEmIOYCQgaG/2A+AwAYlAG8AHicbZE9TsMwGIbf9A/RSggEYmHxAgtq+jN2ZGj3Dt3T1GlTOXHkuBW9AyfgEByCgTNwCA7BW/NJlVBtyd/jx+8XKwmAa3whwnFE6Ib1OBq44O6Pm6Qb4Rb5QbiNHh6FO/RD4S6eMRHu4RaaT4halzR3eBVu4Apvwk36d+EW+UO4jXt8Cnfov4W7WOBHuIen6MXsCtvPU1vWc73emcSdxIkW2tW5LdUoHp7kTJfaJV6v1PKg6v167H2mMmcLNbWl18ZYVTm71amPN95Xk8EgEx+ntoDBDgUs+siRspaoMef7rukNEriziXNuwS7Hmoe9wggxv+e55IzJMqQTeNYV00scuNbY8+YxrUfGfcaMZb/CNPQe04bT0lThbEuT0sfYhK6K/23Amf3Lx+H24hcj4GScAAAAeJxtjtlugzAQRbkJUEJIuu/7vqR8lGNPAcWx0YAb5e/LklR96EgenSufGY038PqKvf9rhgGG8BEgxA4ijBBjjAQTTLGLPezjAIc4wjFOcIoznOMCl7jCNW5wizvc4wGPeMIzXvCKN7zjAzN8eonQRWZSSaYmjvug6ase98hFltexMJmmVNmV2WBvdNgZUc+ujAWzXW3UDnu1w43asStHc8GpzAXX/py0jqTQZJTgkcxJLpaCF0lD32xNt+43tAsn29Dft02uDKS2cjGUNgsk26qK2lFthYoU27INPqmiDqg5goe0pqR5qSoqMdek/CUZFywL46rEsiImleqiqoMyt4baXlu/1GLdNFf5zbcNmdr1YUWCZe47o+zUmb/DoStbw3cVsef9ALjjiPQA) format('woff');
      font-weight: normal;
      font-style: normal;
    }

    html {
      --lumo-icons-align-center: "\\ea01";
      --lumo-icons-align-left: "\\ea02";
      --lumo-icons-align-right: "\\ea03";
      --lumo-icons-angle-down: "\\ea04";
      --lumo-icons-angle-left: "\\ea05";
      --lumo-icons-angle-right: "\\ea06";
      --lumo-icons-angle-up: "\\ea07";
      --lumo-icons-arrow-down: "\\ea08";
      --lumo-icons-arrow-left: "\\ea09";
      --lumo-icons-arrow-right: "\\ea0a";
      --lumo-icons-arrow-up: "\\ea0b";
      --lumo-icons-bar-chart: "\\ea0c";
      --lumo-icons-bell: "\\ea0d";
      --lumo-icons-calendar: "\\ea0e";
      --lumo-icons-checkmark: "\\ea0f";
      --lumo-icons-chevron-down: "\\ea10";
      --lumo-icons-chevron-left: "\\ea11";
      --lumo-icons-chevron-right: "\\ea12";
      --lumo-icons-chevron-up: "\\ea13";
      --lumo-icons-clock: "\\ea14";
      --lumo-icons-cog: "\\ea15";
      --lumo-icons-cross: "\\ea16";
      --lumo-icons-download: "\\ea17";
      --lumo-icons-dropdown: "\\ea18";
      --lumo-icons-edit: "\\ea19";
      --lumo-icons-error: "\\ea1a";
      --lumo-icons-eye: "\\ea1b";
      --lumo-icons-eye-disabled: "\\ea1c";
      --lumo-icons-menu: "\\ea1d";
      --lumo-icons-minus: "\\ea1e";
      --lumo-icons-ordered-list: "\\ea1f";
      --lumo-icons-phone: "\\ea20";
      --lumo-icons-photo: "\\ea21";
      --lumo-icons-play: "\\ea22";
      --lumo-icons-plus: "\\ea23";
      --lumo-icons-redo: "\\ea24";
      --lumo-icons-reload: "\\ea25";
      --lumo-icons-search: "\\ea26";
      --lumo-icons-undo: "\\ea27";
      --lumo-icons-unordered-list: "\\ea28";
      --lumo-icons-upload: "\\ea29";
      --lumo-icons-user: "\\ea2a";
    }
  </style>
`;document.head.appendChild(Nce.content);var Yur=Ci`
  :host {
    --lumo-size-xs: 1.625rem;
    --lumo-size-s: 1.875rem;
    --lumo-size-m: 2.25rem;
    --lumo-size-l: 2.75rem;
    --lumo-size-xl: 3.5rem;

    /* Icons */
    --lumo-icon-size-s: 1.25em;
    --lumo-icon-size-m: 1.5em;
    --lumo-icon-size-l: 2.25em;
    /* For backwards compatibility */
    --lumo-icon-size: var(--lumo-icon-size-m);
  }
`,Dce=document.createElement("template");Dce.innerHTML=`<style>${Yur.toString().replace(":host","html")}</style>`;document.head.appendChild(Dce.content);var jur=Ci`
  :host {
    /* Square */
    --lumo-space-xs: 0.25rem;
    --lumo-space-s: 0.5rem;
    --lumo-space-m: 1rem;
    --lumo-space-l: 1.5rem;
    --lumo-space-xl: 2.5rem;

    /* Wide */
    --lumo-space-wide-xs: calc(var(--lumo-space-xs) / 2) var(--lumo-space-xs);
    --lumo-space-wide-s: calc(var(--lumo-space-s) / 2) var(--lumo-space-s);
    --lumo-space-wide-m: calc(var(--lumo-space-m) / 2) var(--lumo-space-m);
    --lumo-space-wide-l: calc(var(--lumo-space-l) / 2) var(--lumo-space-l);
    --lumo-space-wide-xl: calc(var(--lumo-space-xl) / 2) var(--lumo-space-xl);

    /* Tall */
    --lumo-space-tall-xs: var(--lumo-space-xs) calc(var(--lumo-space-xs) / 2);
    --lumo-space-tall-s: var(--lumo-space-s) calc(var(--lumo-space-s) / 2);
    --lumo-space-tall-m: var(--lumo-space-m) calc(var(--lumo-space-m) / 2);
    --lumo-space-tall-l: var(--lumo-space-l) calc(var(--lumo-space-l) / 2);
    --lumo-space-tall-xl: var(--lumo-space-xl) calc(var(--lumo-space-xl) / 2);
  }
`,Oce=document.createElement("template");Oce.innerHTML=`<style>${jur.toString().replace(":host","html")}</style>`;document.head.appendChild(Oce.content);var Xur=Ci`
  :host {
    /* Border radius */
    --lumo-border-radius-s: 0.25em; /* Checkbox, badge, date-picker year indicator, etc */
    --lumo-border-radius-m: var(--lumo-border-radius, 0.25em); /* Button, text field, menu overlay, etc */
    --lumo-border-radius-l: 0.5em; /* Dialog, notification, etc */
    --lumo-border-radius: 0.25em; /* Deprecated */

    /* Shadow */
    --lumo-box-shadow-xs: 0 1px 4px -1px var(--lumo-shade-50pct);
    --lumo-box-shadow-s: 0 2px 4px -1px var(--lumo-shade-20pct), 0 3px 12px -1px var(--lumo-shade-30pct);
    --lumo-box-shadow-m: 0 2px 6px -1px var(--lumo-shade-20pct), 0 8px 24px -4px var(--lumo-shade-40pct);
    --lumo-box-shadow-l: 0 3px 18px -2px var(--lumo-shade-20pct), 0 12px 48px -6px var(--lumo-shade-40pct);
    --lumo-box-shadow-xl: 0 4px 24px -3px var(--lumo-shade-20pct), 0 18px 64px -8px var(--lumo-shade-40pct);

    /* Clickable element cursor */
    --lumo-clickable-cursor: default;
  }
`,zce=document.createElement("template");zce.innerHTML=`<style>${Xur.toString().replace(":host","html")}</style>`;document.head.appendChild(zce.content);var $ur=Ci`
  :host {
    /* prettier-ignore */
    --lumo-font-family: -apple-system, BlinkMacSystemFont, 'Roboto', 'Segoe UI', Helvetica, Arial, sans-serif, 'Apple Color Emoji', 'Segoe UI Emoji', 'Segoe UI Symbol';

    /* Font sizes */
    --lumo-font-size-xxs: 0.75rem;
    --lumo-font-size-xs: 0.8125rem;
    --lumo-font-size-s: 0.875rem;
    --lumo-font-size-m: 1rem;
    --lumo-font-size-l: 1.125rem;
    --lumo-font-size-xl: 1.375rem;
    --lumo-font-size-xxl: 1.75rem;
    --lumo-font-size-xxxl: 2.5rem;

    /* Line heights */
    --lumo-line-height-xs: 1.25;
    --lumo-line-height-s: 1.375;
    --lumo-line-height-m: 1.625;
  }
`,Fce=document.createElement("template");Fce.innerHTML=`<style>${$ur.toString().replace(":host","html")}</style>`;document.head.appendChild(Fce.content);var Kur=Ci`
  html {
    font-family: var(--lumo-font-family);
    font-size: var(--lumo-font-size, var(--lumo-font-size-m));
    line-height: var(--lumo-line-height-m);
    -webkit-text-size-adjust: 100%;
    -webkit-font-smoothing: antialiased;
    -moz-osx-font-smoothing: grayscale;
  }

  /* Can’t combine with the above selector because that doesn’t work in browsers without native shadow dom */
  :host {
    font-family: var(--lumo-font-family);
    font-size: var(--lumo-font-size, var(--lumo-font-size-m));
    line-height: var(--lumo-line-height-m);
    -webkit-text-size-adjust: 100%;
    -webkit-font-smoothing: antialiased;
    -moz-osx-font-smoothing: grayscale;
  }

  small,
  [theme~='font-size-s'] {
    font-size: var(--lumo-font-size-s);
    line-height: var(--lumo-line-height-s);
  }

  [theme~='font-size-xs'] {
    font-size: var(--lumo-font-size-xs);
    line-height: var(--lumo-line-height-xs);
  }

  h1,
  h2,
  h3,
  h4,
  h5,
  h6 {
    font-weight: 600;
    line-height: var(--lumo-line-height-xs);
    margin-top: 1.25em;
  }

  h1 {
    font-size: var(--lumo-font-size-xxxl);
    margin-bottom: 0.75em;
  }

  h2 {
    font-size: var(--lumo-font-size-xxl);
    margin-bottom: 0.5em;
  }

  h3 {
    font-size: var(--lumo-font-size-xl);
    margin-bottom: 0.5em;
  }

  h4 {
    font-size: var(--lumo-font-size-l);
    margin-bottom: 0.5em;
  }

  h5 {
    font-size: var(--lumo-font-size-m);
    margin-bottom: 0.25em;
  }

  h6 {
    font-size: var(--lumo-font-size-xs);
    margin-bottom: 0;
    text-transform: uppercase;
    letter-spacing: 0.03em;
  }

  p,
  blockquote {
    margin-top: 0.5em;
    margin-bottom: 0.75em;
  }

  a {
    text-decoration: none;
  }

  a:hover {
    text-decoration: underline;
  }

  hr {
    display: block;
    align-self: stretch;
    height: 1px;
    border: 0;
    padding: 0;
    margin: var(--lumo-space-s) calc(var(--lumo-border-radius-m) / 2);
    background-color: var(--lumo-contrast-10pct);
  }

  blockquote {
    border-left: 2px solid var(--lumo-contrast-30pct);
  }

  b,
  strong {
    font-weight: 600;
  }

  /* RTL specific styles */

  blockquote[dir='rtl'] {
    border-left: none;
    border-right: 2px solid var(--lumo-contrast-30pct);
  }
`;jc("",Kur,{moduleId:"lumo-typography"});jc("vaadin-checkbox",Ci`
    :host {
      -webkit-tap-highlight-color: transparent;
      -webkit-user-select: none;
      -moz-user-select: none;
      user-select: none;
      cursor: default;
      outline: none;
    }

    [part='label']:not([empty]) {
      margin: 0.1875em 0.875em 0.1875em 0.375em;
    }

    [part='checkbox'] {
      width: calc(1em + 2px);
      height: calc(1em + 2px);
      margin: 0.1875em;
      position: relative;
      border-radius: var(--lumo-border-radius-s);
      background-color: var(--lumo-contrast-20pct);
      transition: transform 0.2s cubic-bezier(0.12, 0.32, 0.54, 2), background-color 0.15s;
      pointer-events: none;
      line-height: 1.2;
    }

    :host([indeterminate]) [part='checkbox'],
    :host([checked]) [part='checkbox'] {
      background-color: var(--lumo-primary-color);
    }

    /* Needed to align the checkbox nicely on the baseline */
    [part='checkbox']::before {
      content: '\\2003';
    }

    /* Checkmark */
    [part='checkbox']::after {
      content: '';
      display: inline-block;
      width: 0;
      height: 0;
      border: 0 solid var(--lumo-primary-contrast-color);
      border-width: 0.1875em 0 0 0.1875em;
      box-sizing: border-box;
      transform-origin: 0 0;
      position: absolute;
      top: 0.8125em;
      left: 0.5em;
      transform: scale(0.55) rotate(-135deg);
      opacity: 0;
    }

    :host([checked]) [part='checkbox']::after {
      opacity: 1;
      width: 0.625em;
      height: 1.0625em;
    }

    /* Indeterminate checkmark */
    :host([indeterminate]) [part='checkbox']::after {
      transform: none;
      opacity: 1;
      top: 45%;
      height: 10%;
      left: 22%;
      right: 22%;
      width: auto;
      border: 0;
      background-color: var(--lumo-primary-contrast-color);
      transition: opacity 0.25s;
    }

    /* Focus ring */
    :host([focus-ring]) [part='checkbox'] {
      box-shadow: 0 0 0 3px var(--lumo-primary-color-50pct);
    }

    /* Disabled */
    :host([disabled]) {
      pointer-events: none;
      color: var(--lumo-disabled-text-color);
    }

    :host([disabled]) [part='label'] ::slotted(*) {
      color: inherit;
    }

    :host([disabled]) [part='checkbox'] {
      background-color: var(--lumo-contrast-10pct);
    }

    :host([disabled]) [part='checkbox']::after {
      border-color: var(--lumo-contrast-30pct);
    }

    :host([indeterminate][disabled]) [part='checkbox']::after {
      background-color: var(--lumo-contrast-30pct);
    }

    /* RTL specific styles */
    :host([dir='rtl']) [part='label']:not([empty]) {
      margin: 0.1875em 0.375em 0.1875em 0.875em;
    }

    /* Transition the checkmark if activated with the mouse (disabled for grid select-all this way) */
    :host(:hover) [part='checkbox']::after {
      transition: width 0.1s, height 0.25s;
    }

    /* Used for activation "halo" */
    [part='checkbox']::before {
      color: transparent;
      display: inline-block;
      width: 100%;
      height: 100%;
      border-radius: inherit;
      background-color: inherit;
      transform: scale(1.4);
      opacity: 0;
      transition: transform 0.1s, opacity 0.8s;
    }

    /* Hover */
    :host(:not([checked]):not([indeterminate]):not([disabled]):hover) [part='checkbox'] {
      background-color: var(--lumo-contrast-30pct);
    }

    /* Disable hover for touch devices */
    @media (pointer: coarse) {
      :host(:not([checked]):not([indeterminate]):not([disabled]):hover) [part='checkbox'] {
        background-color: var(--lumo-contrast-20pct);
      }
    }

    /* Active */
    :host([active]) [part='checkbox'] {
      transform: scale(0.9);
      transition-duration: 0.05s;
    }

    :host([active][checked]) [part='checkbox'] {
      transform: scale(1.1);
    }

    :host([active]:not([checked])) [part='checkbox']::before {
      transition-duration: 0.01s, 0.01s;
      transform: scale(0);
      opacity: 0.4;
    }
  `,{moduleId:"lumo-checkbox"});var Bce=e=>class extends e{static get properties(){return{theme:{type:String,readOnly:!0}}}attributeChangedCallback(r,n,i){super.attributeChangedCallback(r,n,i),r==="theme"&&this._setTheme(i)}};var XH=e=>class extends Bce(e){static finalize(){super.finalize();let r=this.prototype._template,n=Object.getPrototypeOf(this.prototype)._template;n&&Array.from(n.content.querySelectorAll("style[include]")).forEach(i=>{this._includeStyle(i.getAttribute("include"),r)}),this._includeMatchingThemes(r)}static _includeMatchingThemes(r){let i=ou.prototype.modules,o=!1,a=this.is+"-default-theme";Object.keys(i).sort((s,l)=>{let c=s.indexOf("vaadin-")===0,u=l.indexOf("vaadin-")===0,h=["lumo-","material-"],f=h.filter(d=>s.indexOf(d)===0).length>0,p=h.filter(d=>l.indexOf(d)===0).length>0;return c!==u?c?-1:1:f!==p?f?-1:1:0}).forEach(s=>{if(s!==a){let l=i[s].getAttribute("theme-for");l&&l.split(" ").forEach(c=>{new RegExp("^"+c.split("*").join(".*")+"$").test(this.is)&&(o=!0,this._includeStyle(s,r))})}}),!o&&i[a]&&this._includeStyle(a,r)}static _includeStyle(r,n){if(n&&!n.content.querySelector(`style[include="${r}"]`)){let i=document.createElement("style");i.setAttribute("include",r),n.content.appendChild(i)}}};var kct=!1;window.addEventListener("keydown",()=>{kct=!0},{capture:!0});window.addEventListener("mousedown",()=>{kct=!1},{capture:!0});var Zur=e=>class extends e{static get properties(){return{tabindex:{type:Number,value:0,reflectToAttribute:!0,observer:"_tabindexChanged"}}}},Hce=e=>class extends Zur(e){static get properties(){return{autofocus:{type:Boolean},_previousTabIndex:{type:Number},disabled:{type:Boolean,observer:"_disabledChanged",reflectToAttribute:!0},_isShiftTabbing:{type:Boolean}}}ready(){this.addEventListener("focusin",r=>{r.composedPath()[0]===this?this.contains(r.relatedTarget)||this._focus():r.composedPath().indexOf(this.focusElement)!==-1&&!this.disabled&&this._setFocused(!0)}),this.addEventListener("focusout",()=>this._setFocused(!1)),super.ready(),this.addEventListener("keydown",r=>{!r.defaultPrevented&&r.keyCode===9&&r.shiftKey&&(this._isShiftTabbing=!0,HTMLElement.prototype.focus.apply(this),this._setFocused(!1),setTimeout(()=>this._isShiftTabbing=!1,0))}),this.autofocus&&!this.disabled&&window.requestAnimationFrame(()=>{this._focus(),this._setFocused(!0),this.setAttribute("focus-ring","")})}disconnectedCallback(){super.disconnectedCallback(),this.hasAttribute("focused")&&this._setFocused(!1)}_setFocused(r){r?this.setAttribute("focused",""):this.removeAttribute("focused"),r&&kct?this.setAttribute("focus-ring",""):this.removeAttribute("focus-ring")}get focusElement(){return window.console.warn(`Please implement the 'focusElement' property in <${this.localName}>`),this}_focus(){!this.focusElement||this._isShiftTabbing||(this.focusElement.focus(),this._setFocused(!0))}focus(){!this.focusElement||this.disabled||(this.focusElement.focus(),this._setFocused(!0))}blur(){!this.focusElement||(this.focusElement.blur(),this._setFocused(!1))}_disabledChanged(r){this.focusElement.disabled=r,r?(this.blur(),this._previousTabIndex=this.tabindex,this.tabindex=-1,this.setAttribute("aria-disabled","true")):(typeof this._previousTabIndex!="undefined"&&(this.tabindex=this._previousTabIndex),this.removeAttribute("aria-disabled"))}_tabindexChanged(r){r!==void 0&&(this.focusElement.tabIndex=r),this.disabled&&this.tabindex&&(this.tabindex!==-1&&(this._previousTabIndex=this.tabindex),this.tabindex=r=void 0)}click(){this.disabled||super.click()}};var Jur=/\/\*\*\s+vaadin-dev-mode:start([\s\S]*)vaadin-dev-mode:end\s+\*\*\//i,$H=window.Vaadin&&window.Vaadin.Flow&&window.Vaadin.Flow.clients;function Qur(){function e(){return!0}return Vce(e)}function thr(){try{return ehr()?!0:rhr()?$H?!nhr():!Qur():!1}catch(e){return!1}}function ehr(){return localStorage.getItem("vaadin.developmentmode.force")}function rhr(){return["localhost","127.0.0.1"].indexOf(window.location.hostname)>=0}function nhr(){return!!($H&&Object.keys($H).map(t=>$H[t]).filter(t=>t.productionMode).length>0)}function Vce(e,t){if(typeof e!="function")return;let r=Jur.exec(e.toString());if(r)try{e=new Function(r[1])}catch(n){console.log("vaadin-development-mode-detector: uncommentAndRun() failed",n)}return e(t)}window.Vaadin=window.Vaadin||{};var Rct=function(e,t){if(window.Vaadin.developmentMode)return Vce(e,t)};window.Vaadin.developmentMode===void 0&&(window.Vaadin.developmentMode=thr());function ihr(){}var Uce=function(){if(typeof Rct=="function")return Rct(ihr)};var _3=class{static detectScrollType(){let t=document.createElement("div");t.textContent="ABCD",t.dir="rtl",t.style.fontSize="14px",t.style.width="4px",t.style.height="1px",t.style.position="absolute",t.style.top="-1000px",t.style.overflow="scroll",document.body.appendChild(t);let r="reverse";return t.scrollLeft>0?r="default":(t.scrollLeft=2,t.scrollLeft<2&&(r="negative")),document.body.removeChild(t),r}static getNormalizedScrollLeft(t,r,n){let{scrollLeft:i}=n;if(r!=="rtl"||!t)return i;switch(t){case"negative":return n.scrollWidth-n.clientWidth+i;case"reverse":return n.scrollWidth-n.clientWidth-i}return i}static setNormalizedScrollLeft(t,r,n,i){if(r!=="rtl"||!t){n.scrollLeft=i;return}switch(t){case"negative":n.scrollLeft=n.clientWidth-n.scrollWidth+i;break;case"reverse":n.scrollLeft=n.scrollWidth-n.clientWidth-i;break;default:n.scrollLeft=i;break}}};var E0=[],ohr=function(){let e=Dct();E0.forEach(t=>{Nct(t,e)})},KH,ahr=new MutationObserver(ohr);ahr.observe(document.documentElement,{attributes:!0,attributeFilter:["dir"]});var Nct=function(e,t,r=e.getAttribute("dir")){t?e.setAttribute("dir",t):r!=null&&e.removeAttribute("dir")},Dct=function(){return document.documentElement.getAttribute("dir")},ZH=e=>class extends e{static get properties(){return{dir:{type:String,value:"",reflectToAttribute:!0}}}static finalize(){super.finalize(),KH||(KH=_3.detectScrollType())}connectedCallback(){super.connectedCallback(),this.hasAttribute("dir")||(this.__subscribe(),Nct(this,Dct(),null))}attributeChangedCallback(r,n,i){if(super.attributeChangedCallback(r,n,i),r!=="dir")return;let o=Dct(),a=i===o&&E0.indexOf(this)===-1,s=!i&&n&&E0.indexOf(this)===-1;a||s?(this.__subscribe(),Nct(this,o,i)):i!==o&&n===o&&this.__subscribe(!1)}disconnectedCallback(){super.disconnectedCallback(),this.__subscribe(!1),this.removeAttribute("dir")}_valueToNodeAttribute(r,n,i){i==="dir"&&n===""&&!r.hasAttribute("dir")||super._valueToNodeAttribute(r,n,i)}_attributeToProperty(r,n,i){r==="dir"&&!n?this.dir="":super._attributeToProperty(r,n,i)}__subscribe(r=!0){r?E0.indexOf(this)===-1&&E0.push(this):E0.indexOf(this)>-1&&E0.splice(E0.indexOf(this),1)}__getNormalizedScrollLeft(r){return _3.getNormalizedScrollLeft(KH,this.getAttribute("dir")||"ltr",r)}__setNormalizedScrollLeft(r,n){return _3.setNormalizedScrollLeft(KH,this.getAttribute("dir")||"ltr",r,n)}};window.Vaadin=window.Vaadin||{};window.Vaadin.registrations=window.Vaadin.registrations||[];window.Vaadin.developmentModeCallback=window.Vaadin.developmentModeCallback||{};window.Vaadin.developmentModeCallback["vaadin-usage-statistics"]=function(){Uce()};var Oct,qce=new Set,JH=e=>class extends ZH(e){static finalize(){super.finalize();let{is:r}=this;r&&!qce.has(r)&&(window.Vaadin.registrations.push(this),qce.add(r),window.Vaadin.developmentModeCallback&&(Oct=sr.debounce(Oct,kx,()=>{window.Vaadin.developmentModeCallback["vaadin-usage-statistics"]()}),Jl(Oct)))}constructor(){super(),document.doctype===null&&console.warn('Vaadin components require the "standards mode" declaration. Please add <!DOCTYPE html> to the HTML document.')}};var QH=class extends JH(Hce(XH(yh(mt)))){static get template(){return Q`
      <style>
        :host {
          display: inline-block;
        }

        :host([hidden]) {
          display: none !important;
        }

        label {
          display: inline-flex;
          align-items: baseline;
          outline: none;
        }

        [part='checkbox'] {
          position: relative;
          display: inline-block;
          flex: none;
        }

        input[type='checkbox'] {
          position: absolute;
          top: 0;
          left: 0;
          right: 0;
          width: 100%;
          height: 100%;
          opacity: 0;
          cursor: inherit;
          margin: 0;
        }

        :host([disabled]) {
          -webkit-tap-highlight-color: transparent;
        }
      </style>

      <label>
        <span part="checkbox">
          <input
            type="checkbox"
            checked="{{checked::change}}"
            disabled$="[[disabled]]"
            indeterminate="{{indeterminate::change}}"
            role="presentation"
            tabindex="-1"
          />
        </span>

        <span part="label">
          <slot></slot>
        </span>
      </label>
    `}static get is(){return"vaadin-checkbox"}static get version(){return"20.0.2"}static get properties(){return{checked:{type:Boolean,value:!1,notify:!0,observer:"_checkedChanged",reflectToAttribute:!0},indeterminate:{type:Boolean,notify:!0,observer:"_indeterminateChanged",reflectToAttribute:!0,value:!1},value:{type:String,value:"on"},_nativeCheckbox:{type:Object}}}constructor(){super(),this.name}get name(){return this.checked?this._storedName:""}set name(t){this._storedName=t}ready(){super.ready(),this.setAttribute("role","checkbox"),this._nativeCheckbox=this.shadowRoot.querySelector('input[type="checkbox"]'),this.addEventListener("click",this._handleClick.bind(this)),this._addActiveListeners();let t=this.getAttribute("name");t&&(this.name=t),this.shadowRoot.querySelector('[part~="label"]').querySelector("slot").addEventListener("slotchange",this._updateLabelAttribute.bind(this)),this._updateLabelAttribute()}_updateLabelAttribute(){let t=this.shadowRoot.querySelector('[part~="label"]'),r=t.firstElementChild.assignedNodes();this._isAssignedNodesEmpty(r)?t.setAttribute("empty",""):t.removeAttribute("empty")}_isAssignedNodesEmpty(t){return t.length===0||t.length==1&&t[0].nodeType==Node.TEXT_NODE&&t[0].textContent.trim()===""}_checkedChanged(t){this.indeterminate?this.setAttribute("aria-checked","mixed"):this.setAttribute("aria-checked",Boolean(t))}_indeterminateChanged(t){t?this.setAttribute("aria-checked","mixed"):this.setAttribute("aria-checked",this.checked)}_addActiveListeners(){this._addEventListenerToNode(this,"down",t=>{this.__interactionsAllowed(t)&&this.setAttribute("active","")}),this._addEventListenerToNode(this,"up",()=>this.removeAttribute("active")),this.addEventListener("keydown",t=>{this.__interactionsAllowed(t)&&t.keyCode===32&&(t.preventDefault(),this.setAttribute("active",""))}),this.addEventListener("keyup",t=>{this.__interactionsAllowed(t)&&t.keyCode===32&&(t.preventDefault(),this._toggleChecked(),this.removeAttribute("active"),this.indeterminate&&(this.indeterminate=!1))})}get focusElement(){return this.shadowRoot.querySelector("input")}__interactionsAllowed(t){return!(this.disabled||t.target.localName==="a")}_handleClick(t){this.__interactionsAllowed(t)&&(this.indeterminate?(this.indeterminate=!1,t.preventDefault(),this._toggleChecked()):t.composedPath()[0]!==this._nativeCheckbox&&(t.preventDefault(),this._toggleChecked()))}_toggleChecked(){this.checked=!this.checked,this.dispatchEvent(new CustomEvent("change",{composed:!1,bubbles:!0}))}};customElements.define(QH.is,QH);jc("vaadin-grid",Ci`
    :host {
      font-family: var(--lumo-font-family);
      font-size: var(--lumo-font-size-m);
      line-height: var(--lumo-line-height-s);
      color: var(--lumo-body-text-color);
      background-color: var(--lumo-base-color);
      box-sizing: border-box;
      -webkit-text-size-adjust: 100%;
      -webkit-tap-highlight-color: transparent;
      -webkit-font-smoothing: antialiased;
      -moz-osx-font-smoothing: grayscale;

      /* For internal use only */
      --_lumo-grid-border-color: var(--lumo-contrast-20pct);
      --_lumo-grid-secondary-border-color: var(--lumo-contrast-10pct);
      --_lumo-grid-border-width: 1px;
      --_lumo-grid-selected-row-color: var(--lumo-primary-color-10pct);
    }

    /* No (outer) border */

    :host(:not([theme~='no-border'])) {
      border: var(--_lumo-grid-border-width) solid var(--_lumo-grid-border-color);
    }

    /* Cell styles */

    [part~='cell'] {
      min-height: var(--lumo-size-m);
      background-color: var(--lumo-base-color);
    }

    [part~='cell'] ::slotted(vaadin-grid-cell-content) {
      cursor: default;
      padding: var(--lumo-space-xs) var(--lumo-space-m);
    }

    /* Apply row borders by default and introduce the "no-row-borders" variant */
    :host(:not([theme~='no-row-borders'])) [part~='cell']:not([part~='details-cell']) {
      border-top: var(--_lumo-grid-border-width) solid var(--_lumo-grid-secondary-border-color);
    }

    /* Hide first body row top border */
    :host(:not([theme~='no-row-borders'])) [part='row'][first] [part~='cell']:not([part~='details-cell']) {
      border-top: 0;
      min-height: calc(var(--lumo-size-m) - var(--_lumo-grid-border-width));
    }

    /* Focus-ring */

    [part~='cell']:focus {
      outline: none;
    }

    :host([navigating]) [part~='cell']:focus::before {
      content: '';
      position: absolute;
      top: 0;
      right: 0;
      bottom: 0;
      left: 0;
      pointer-events: none;
      box-shadow: inset 0 0 0 2px var(--lumo-primary-color-50pct);
    }

    /* Drag and Drop styles */
    :host([dragover])::after {
      content: '';
      position: absolute;
      z-index: 100;
      top: 0;
      right: 0;
      bottom: 0;
      left: 0;
      pointer-events: none;
      box-shadow: inset 0 0 0 2px var(--lumo-primary-color-50pct);
    }

    [part~='row'][dragover] {
      z-index: 100 !important;
    }

    [part~='row'][dragover] [part~='cell'] {
      overflow: visible;
    }

    [part~='row'][dragover] [part~='cell']::after {
      content: '';
      position: absolute;
      top: 0;
      right: 0;
      bottom: 0;
      left: 0;
      height: calc(var(--_lumo-grid-border-width) + 2px);
      pointer-events: none;
      background: var(--lumo-primary-color-50pct);
    }

    :host([theme~='no-row-borders']) [dragover] [part~='cell']::after {
      height: 2px;
    }

    [part~='row'][dragover='below'] [part~='cell']::after {
      top: 100%;
      bottom: auto;
      margin-top: -1px;
    }

    [part~='row'][dragover='above'] [part~='cell']::after {
      top: auto;
      bottom: 100%;
      margin-bottom: -1px;
    }

    [part~='row'][details-opened][dragover='below'] [part~='cell']:not([part~='details-cell'])::after,
    [part~='row'][details-opened][dragover='above'] [part~='details-cell']::after {
      display: none;
    }

    [part~='row'][dragover][dragover='on-top'] [part~='cell']::after {
      height: 100%;
    }

    [part~='row'][dragstart] {
      /* Add bottom-space to the row so the drag number doesn't get clipped. Needed for IE/Edge */
      border-bottom: 100px solid transparent;
      z-index: 100 !important;
      opacity: 0.9;
    }

    [part~='row'][dragstart] [part~='cell'] {
      border: none !important;
      box-shadow: none !important;
    }

    [part~='row'][dragstart] [part~='cell'][last-column] {
      border-radius: 0 var(--lumo-border-radius-s) var(--lumo-border-radius-s) 0;
    }

    [part~='row'][dragstart] [part~='cell'][first-column] {
      border-radius: var(--lumo-border-radius-s) 0 0 var(--lumo-border-radius-s);
    }

    [ios] [part~='row'][dragstart] [part~='cell'] {
      background: var(--lumo-primary-color-50pct);
    }

    #scroller:not([ios]) [part~='row'][dragstart]:not([dragstart=''])::after {
      display: block;
      position: absolute;
      left: var(--_grid-drag-start-x);
      top: var(--_grid-drag-start-y);
      z-index: 100;
      content: attr(dragstart);
      align-items: center;
      justify-content: center;
      box-sizing: border-box;
      padding: calc(var(--lumo-space-xs) * 0.8);
      color: var(--lumo-error-contrast-color);
      background-color: var(--lumo-error-color);
      border-radius: var(--lumo-border-radius-m);
      font-family: var(--lumo-font-family);
      font-size: var(--lumo-font-size-xxs);
      line-height: 1;
      font-weight: 500;
      text-transform: initial;
      letter-spacing: initial;
      min-width: calc(var(--lumo-size-s) * 0.7);
      text-align: center;
    }

    /* Headers and footers */

    [part~='header-cell'] ::slotted(vaadin-grid-cell-content),
    [part~='footer-cell'] ::slotted(vaadin-grid-cell-content),
    [part~='reorder-ghost'] {
      font-size: var(--lumo-font-size-s);
      font-weight: 500;
    }

    [part~='footer-cell'] ::slotted(vaadin-grid-cell-content) {
      font-weight: 400;
    }

    [part='row']:only-child [part~='header-cell'] {
      min-height: var(--lumo-size-xl);
    }

    /* Header borders */

    /* Hide first header row top border */
    :host(:not([theme~='no-row-borders'])) [part='row']:first-child [part~='header-cell'] {
      border-top: 0;
    }

    [part='row']:last-child [part~='header-cell'] {
      border-bottom: var(--_lumo-grid-border-width) solid transparent;
    }

    :host(:not([theme~='no-row-borders'])) [part='row']:last-child [part~='header-cell'] {
      border-bottom-color: var(--_lumo-grid-secondary-border-color);
    }

    /* Overflow uses a stronger border color */
    :host([overflow~='top']) [part='row']:last-child [part~='header-cell'] {
      border-bottom-color: var(--_lumo-grid-border-color);
    }

    /* Footer borders */

    [part='row']:first-child [part~='footer-cell'] {
      border-top: var(--_lumo-grid-border-width) solid transparent;
    }

    :host(:not([theme~='no-row-borders'])) [part='row']:first-child [part~='footer-cell'] {
      border-top-color: var(--_lumo-grid-secondary-border-color);
    }

    /* Overflow uses a stronger border color */
    :host([overflow~='bottom']) [part='row']:first-child [part~='footer-cell'] {
      border-top-color: var(--_lumo-grid-border-color);
    }

    /* Column reordering */

    :host([reordering]) [part~='cell'] {
      background: linear-gradient(var(--lumo-shade-20pct), var(--lumo-shade-20pct)) var(--lumo-base-color);
    }

    :host([reordering]) [part~='cell'][reorder-status='allowed'] {
      background: var(--lumo-base-color);
    }

    :host([reordering]) [part~='cell'][reorder-status='dragging'] {
      background: linear-gradient(var(--lumo-contrast-5pct), var(--lumo-contrast-5pct)) var(--lumo-base-color);
    }

    [part~='reorder-ghost'] {
      opacity: 0.85;
      box-shadow: var(--lumo-box-shadow-s);
      /* TODO Use the same styles as for the cell element (reorder-ghost copies styles from the cell element) */
      padding: var(--lumo-space-s) var(--lumo-space-m) !important;
    }

    /* Column resizing */

    [part='resize-handle'] {
      width: 3px;
      background-color: var(--lumo-primary-color-50pct);
      opacity: 0;
      transition: opacity 0.2s;
    }

    :host(:not([reordering])) *:not([column-resizing]) [part~='cell']:hover [part='resize-handle'],
    [part='resize-handle']:active {
      opacity: 1;
      transition-delay: 0.15s;
    }

    /* Column borders */

    :host([theme~='column-borders']) [part~='cell']:not([last-column]):not([part~='details-cell']) {
      border-right: var(--_lumo-grid-border-width) solid var(--_lumo-grid-secondary-border-color);
    }

    /* Frozen columns */

    [last-frozen] {
      border-right: var(--_lumo-grid-border-width) solid transparent;
      overflow: hidden;
    }

    :host([overflow~='left']) [part~='cell'][last-frozen]:not([part~='details-cell']) {
      border-right-color: var(--_lumo-grid-border-color);
    }

    /* Row stripes */

    :host([theme~='row-stripes']) [part~='row']:not([odd]) [part~='body-cell'],
    :host([theme~='row-stripes']) [part~='row']:not([odd]) [part~='details-cell'] {
      background-image: linear-gradient(var(--lumo-contrast-5pct), var(--lumo-contrast-5pct));
      background-repeat: repeat-x;
    }

    /* Selected row */

    /* Raise the selected rows above unselected rows (so that box-shadow can cover unselected rows) */
    :host(:not([reordering])) [part~='row'][selected] {
      z-index: 1;
    }

    :host(:not([reordering])) [part~='row'][selected] [part~='body-cell']:not([part~='details-cell']) {
      background-image: linear-gradient(var(--_lumo-grid-selected-row-color), var(--_lumo-grid-selected-row-color));
      background-repeat: repeat;
    }

    /* Cover the border of an unselected row */
    :host(:not([theme~='no-row-borders'])) [part~='row'][selected] [part~='cell']:not([part~='details-cell']) {
      box-shadow: 0 var(--_lumo-grid-border-width) 0 0 var(--_lumo-grid-selected-row-color);
    }

    /* Compact */

    :host([theme~='compact']) [part='row']:only-child [part~='header-cell'] {
      min-height: var(--lumo-size-m);
    }

    :host([theme~='compact']) [part~='cell'] {
      min-height: var(--lumo-size-s);
    }

    :host([theme~='compact']) [part='row'][first] [part~='cell']:not([part~='details-cell']) {
      min-height: calc(var(--lumo-size-s) - var(--_lumo-grid-border-width));
    }

    :host([theme~='compact']) [part~='cell'] ::slotted(vaadin-grid-cell-content) {
      padding: var(--lumo-space-xs) var(--lumo-space-s);
    }

    /* Wrap cell contents */

    :host([theme~='wrap-cell-content']) [part~='cell'] ::slotted(vaadin-grid-cell-content) {
      white-space: normal;
    }

    /* RTL specific styles */

    :host([dir='rtl']) [part~='row'][dragstart] [part~='cell'][last-column] {
      border-radius: var(--lumo-border-radius-s) 0 0 var(--lumo-border-radius-s);
    }

    :host([dir='rtl']) [part~='row'][dragstart] [part~='cell'][first-column] {
      border-radius: 0 var(--lumo-border-radius-s) var(--lumo-border-radius-s) 0;
    }

    :host([dir='rtl'][theme~='column-borders']) [part~='cell']:not([last-column]):not([part~='details-cell']) {
      border-right: none;
      border-left: var(--_lumo-grid-border-width) solid var(--_lumo-grid-secondary-border-color);
    }

    :host([dir='rtl']) [last-frozen] {
      border-right: none;
      border-left: var(--_lumo-grid-border-width) solid transparent;
    }

    :host([dir='rtl'][overflow~='right']) [part~='cell'][last-frozen]:not([part~='details-cell']) {
      border-left-color: var(--_lumo-grid-border-color);
    }
  `,{moduleId:"lumo-grid"});jc("vaadin-checkbox",Ci`
    :host(.vaadin-grid-select-all-checkbox) {
      font-size: var(--lumo-font-size-m);
    }
  `,{moduleId:"vaadin-grid-select-all-checkbox-lumo"});var Gce=navigator.userAgent.match(/iP(?:hone|ad;(?: U;)? CPU) OS (\d+)/),shr=Gce&&Gce[1]>=8,Wce=3,Yce=h9({behaviors:[Js,v9],_ratio:.5,_scrollerPaddingTop:0,_scrollPosition:0,_physicalSize:0,_physicalAverage:0,_physicalAverageCount:0,_physicalTop:0,_virtualCount:0,_estScrollHeight:0,_scrollHeight:0,_viewportHeight:0,_viewportWidth:0,_physicalItems:null,_physicalSizes:null,_firstVisibleIndexVal:null,_lastVisibleIndexVal:null,_maxPages:2,_focusedVirtualIndex:-1,_templateCost:0,get _physicalBottom(){return this._physicalTop+this._physicalSize},get _scrollBottom(){return this._scrollPosition+this._viewportHeight},get _virtualEnd(){return this._virtualStart+this._physicalCount-1},get _hiddenContentSize(){return this._physicalSize-this._viewportHeight},get _maxScrollTop(){return this._estScrollHeight-this._viewportHeight+this._scrollOffset},get _maxVirtualStart(){return Math.max(0,this._virtualCount-this._physicalCount)},set _virtualStart(e){e=this._clamp(e,0,this._maxVirtualStart),this._virtualStartVal=e},get _virtualStart(){return this._virtualStartVal||0},set _physicalStart(e){e=e%this._physicalCount,e<0&&(e=this._physicalCount+e),this._physicalStartVal=e},get _physicalStart(){return this._physicalStartVal||0},get _physicalEnd(){return(this._physicalStart+this._physicalCount-1)%this._physicalCount},set _physicalCount(e){this._physicalCountVal=e},get _physicalCount(){return this._physicalCountVal||0},get _optPhysicalSize(){return this._viewportHeight===0?1/0:this._viewportHeight*this._maxPages},get _isVisible(){return Boolean(this.offsetWidth||this.offsetHeight)},get firstVisibleIndex(){let e=this._firstVisibleIndexVal;if(e==null){let t=this._physicalTop+this._scrollOffset;e=this._iterateItems(function(r,n){if(t+=this._physicalSizes[r],t>this._scrollPosition)return n})||0,this._firstVisibleIndexVal=e}return e},get lastVisibleIndex(){let e=this._lastVisibleIndexVal;if(e==null){let t=this._physicalTop+this._scrollOffset;this._iterateItems(function(r,n){t<this._scrollBottom&&(e=n),t+=this._physicalSizes[r]}),this._lastVisibleIndexVal=e}return e},get _scrollOffset(){return this._scrollerPaddingTop},attached:function(){this._debounce("_render",this._render,Ni),this.listen(this,"iron-resize","_resizeHandler")},detached:function(){this.unlisten(this,"iron-resize","_resizeHandler")},updateViewportBoundaries:function(){let e=window.getComputedStyle(this);this._scrollerPaddingTop=this.scrollTarget===this?0:parseInt(e["padding-top"],10),this._isRTL=Boolean(e.direction==="rtl"),this._viewportWidth=this.$.items.offsetWidth,this._viewportHeight=this._scrollTargetHeight},_scrollHandler:function(){let e=Math.max(0,Math.min(this._maxScrollTop,this._scrollTop)),t=e-this._scrollPosition,r=t>=0;if(this._scrollPosition=e,this._firstVisibleIndexVal=null,this._lastVisibleIndexVal=null,Math.abs(t)>this._physicalSize&&this._physicalSize>0){t=t-this._scrollOffset;let n=Math.round(t/this._physicalAverage);this._virtualStart=this._virtualStart+n,this._physicalStart=this._physicalStart+n,this._physicalTop=Math.floor(this._virtualStart)*this._physicalAverage,this._update()}else if(this._physicalCount>0){let{physicalTop:n,indexes:i}=this._getReusables(r);r?(this._physicalTop=n,this._virtualStart=this._virtualStart+i.length,this._physicalStart=this._physicalStart+i.length):(this._virtualStart=this._virtualStart-i.length,this._physicalStart=this._physicalStart-i.length),this._update(i,r?null:i),this._debounce("_increasePoolIfNeeded",this._increasePoolIfNeeded.bind(this,0),li)}},_getReusables:function(e){let t,r,n,i=[],o=this._hiddenContentSize*this._ratio,a=this._virtualStart,s=this._virtualEnd,l=this._physicalCount,c=this._physicalTop+this._scrollOffset,u=this._physicalBottom+this._scrollOffset,h=this._scrollTop,f=this._scrollBottom;for(e?(t=this._physicalStart,r=h-c):(t=this._physicalEnd,r=u-f);n=this._physicalSizes[t],r=r-n,!(i.length>=l||r<=o);)if(e){if(s+i.length+1>=this._virtualCount||c+n>=h-this._scrollOffset)break;i.push(t),c=c+n,t=(t+1)%l}else{if(a-i.length<=0||c+this._physicalSize-n<=f)break;i.push(t),c=c-n,t=t===0?l-1:t-1}return{indexes:i,physicalTop:c-this._scrollOffset}},_update:function(e,t){if(!(e&&e.length===0||this._physicalCount===0)){if(this._assignModels(e),this._updateMetrics(e),t)for(;t.length;){let r=t.pop();this._physicalTop-=this._physicalSizes[r]}this._positionItems(),this._updateScrollerSize()}},_isClientFull:function(){return this._scrollBottom!=0&&this._physicalBottom-1>=this._scrollBottom&&this._physicalTop<=this._scrollPosition},_increasePoolIfNeeded:function(e){let r=this._clamp(this._physicalCount+e,Wce,this._virtualCount-this._virtualStart)-this._physicalCount,n=Math.round(this._physicalCount*.5);if(!(r<0)){if(r>0){let i=window.performance.now();[].push.apply(this._physicalItems,this._createPool(r));for(let o=0;o<r;o++)this._physicalSizes.push(0);this._physicalCount=this._physicalCount+r,this._physicalStart>this._physicalEnd&&this._isIndexRendered(this._focusedVirtualIndex)&&this._getPhysicalIndex(this._focusedVirtualIndex)<this._physicalEnd&&(this._physicalStart=this._physicalStart+r),this._update(),this._templateCost=(window.performance.now()-i)/r,n=Math.round(this._physicalCount*.5)}this._virtualEnd>=this._virtualCount-1||n===0||(this._isClientFull()?this._physicalSize<this._optPhysicalSize&&this._debounce("_increasePoolIfNeeded",this._increasePoolIfNeeded.bind(this,this._clamp(Math.round(50/this._templateCost),1,n)),kx):this._debounce("_increasePoolIfNeeded",this._increasePoolIfNeeded.bind(this,n),li))}},_render:function(){if(!(!this.isAttached||!this._isVisible))if(this._physicalCount!==0){let{physicalTop:e,indexes:t}=this._getReusables(!0);this._physicalTop=e,this._virtualStart=this._virtualStart+t.length,this._physicalStart=this._physicalStart+t.length,this._update(t),this._update(),this._increasePoolIfNeeded(0)}else this._virtualCount>0&&(this.updateViewportBoundaries(),this._increasePoolIfNeeded(Wce))},_itemsChanged:function(e){e.path==="items"&&(this._virtualStart=0,this._physicalTop=0,this._virtualCount=this.items?this.items.length:0,this._physicalIndexForKey={},this._firstVisibleIndexVal=null,this._lastVisibleIndexVal=null,this._physicalCount=this._physicalCount||0,this._physicalItems=this._physicalItems||[],this._physicalSizes=this._physicalSizes||[],this._physicalStart=0,this._scrollTop>this._scrollOffset&&this._resetScrollPosition(0),this._debounce("_render",this._render,Ni))},_iterateItems:function(e,t){let r,n,i,o;if(arguments.length===2&&t){for(o=0;o<t.length;o++)if(r=t[o],n=this._computeVidx(r),(i=e.call(this,r,n))!=null)return i}else{for(r=this._physicalStart,n=this._virtualStart;r<this._physicalCount;r++,n++)if((i=e.call(this,r,n))!=null)return i;for(r=0;r<this._physicalStart;r++,n++)if((i=e.call(this,r,n))!=null)return i}},_computeVidx:function(e){return e>=this._physicalStart?this._virtualStart+(e-this._physicalStart):this._virtualStart+(this._physicalCount-this._physicalStart)+e},_updateMetrics:function(e){if(!this._isVisible)return;ci();let t=0,r=0,n=this._physicalAverageCount,i=this._physicalAverage;this._iterateItems(function(o){r+=this._physicalSizes[o],this._physicalSizes[o]=this._physicalItems[o].offsetHeight,t+=this._physicalSizes[o],this._physicalAverageCount+=this._physicalSizes[o]?1:0},e),this._physicalSize=this._physicalSize+t-r,this._physicalAverageCount!==n&&(this._physicalAverage=Math.round((i*n+t)/this._physicalAverageCount))},_positionItems:function(){this._adjustScrollPosition();let e=this._physicalTop;this._iterateItems(function(t){this.translate3d(0,e+"px",0,this._physicalItems[t]),e+=this._physicalSizes[t]})},_adjustScrollPosition:function(){let e=this._virtualStart===0?this._physicalTop:Math.min(this._scrollPosition+this._physicalTop,0);if(e!==0){this._physicalTop=this._physicalTop-e;let t=this._scrollTop;!shr&&t>0&&this._resetScrollPosition(t-e)}},_resetScrollPosition:function(e){this.scrollTarget&&e>=0&&(this._scrollTop=e,this._scrollPosition=this._scrollTop)},_updateScrollerSize:function(e){this._estScrollHeight=this._physicalBottom+Math.max(this._virtualCount-this._physicalCount-this._virtualStart,0)*this._physicalAverage,e=e||this._scrollHeight===0,e=e||this._scrollPosition>=this._estScrollHeight-this._physicalSize,(e||Math.abs(this._estScrollHeight-this._scrollHeight)>=this._viewportHeight)&&(this.$.items.style.height=this._estScrollHeight+"px",this._scrollHeight=this._estScrollHeight)},scrollToIndex:function(e){if(typeof e!="number"||e<0||e>this.items.length-1||(ci(),this._physicalCount===0))return;e=this._clamp(e,0,this._virtualCount-1),(!this._isIndexRendered(e)||e>=this._maxVirtualStart)&&(this._virtualStart=e-1),this._assignModels(),this._updateMetrics(),this._physicalTop=Math.floor(this._virtualStart)*this._physicalAverage;let t=this._physicalStart,r=this._virtualStart,n=0,i=this._hiddenContentSize;for(;r<e&&n<=i;)n=n+this._physicalSizes[t],t=(t+1)%this._physicalCount,r++;this._updateScrollerSize(!0),this._positionItems(),this._resetScrollPosition(this._physicalTop+this._scrollOffset+n),this._increasePoolIfNeeded(0),this._firstVisibleIndexVal=null,this._lastVisibleIndexVal=null},_resetAverage:function(){this._physicalAverage=0,this._physicalAverageCount=0},_resizeHandler:function(){this._debounce("_render",function(){this._firstVisibleIndexVal=null,this._lastVisibleIndexVal=null,this.updateViewportBoundaries(),this._isVisible?(this.toggleScrollListener(!0),this._resetAverage(),this._render()):this.toggleScrollListener(!1)},Ni)},_isIndexRendered:function(e){return e>=this._virtualStart&&e<=this._virtualEnd},_getPhysicalIndex:function(e){return(this._physicalStart+(e-this._virtualStart))%this._physicalCount},_clamp:function(e,t,r){return Math.min(r,Math.max(t,e))},_debounce:function(e,t,r){this._debouncers=this._debouncers||{},this._debouncers[e]=sr.debounce(this._debouncers[e],r,t.bind(this)),Jl(this._debouncers[e])}});var tV=class extends Yce{static get properties(){return{size:{type:Number,notify:!0},_vidxOffset:{type:Number,value:0}}}static get observers(){return["_effectiveSizeChanged(_effectiveSize)"]}connectedCallback(){super.connectedCallback(),this._scrollHandler()}_updateScrollerItem(){}_afterScroll(){}_getRowTarget(){}_createScrollerRows(){}_canPopulate(){}scrollToIndex(t){this._warnPrivateAPIAccess("scrollToIndex"),this._scrollingToIndex=!0,t=Math.min(Math.max(t,0),this._effectiveSize-1),this.$.table.scrollTop=t/this._effectiveSize*(this.$.table.scrollHeight-this.$.table.offsetHeight),this._scrollHandler(),this._accessIronListAPI(()=>this._maxScrollTop)&&this._virtualCount<this._effectiveSize&&this._adjustVirtualIndexOffset(1e6),this._accessIronListAPI(()=>super.scrollToIndex(t-this._vidxOffset)),this._scrollHandler();let r=Array.from(this.$.items.children).filter(n=>n.index===t)[0];if(r){let n=r.getBoundingClientRect().top-this.$.header.getBoundingClientRect().bottom;Math.abs(n)>1&&(this.$.table.scrollTop+=n,this._scrollHandler())}this._scrollingToIndex=!1}_effectiveSizeChanged(t){let r,n=0;this._iterateItems((i,o)=>{if(o===this._firstVisibleIndex){let a=this._physicalItems[i];r=a.index,n=a.getBoundingClientRect().top}}),this.items&&t<this.items.length&&(this._scrollTop=0),Array.isArray(this.items)||(this.items={length:Math.min(t,1e5)}),this._accessIronListAPI(()=>super._itemsChanged({path:"items"})),this._virtualCount=Math.min(this.items.length,t)||0,this._scrollTop===0&&(this._accessIronListAPI(()=>this._scrollToIndex(Math.min(t-1,r))),this._iterateItems(i=>{let o=this._physicalItems[i];if(o.index===r&&(this.$.table.scrollTop+=Math.round(o.getBoundingClientRect().top-n)),o.index===this._focusedItemIndex&&this._itemsFocusable&&this.$.items.contains(this.shadowRoot.activeElement)){let a=Array.from(this._itemsFocusable.parentElement.children).indexOf(this._itemsFocusable);o.children[a].focus()}})),this._assignModels(),requestAnimationFrame(()=>this._update()),this.__updateFooterPositioning()}_positionItems(){this._adjustScrollPosition();let t;isNaN(this._physicalTop)&&(t=!0,this._physicalTop=0);let r=this._physicalTop;this._iterateItems(n=>{this._physicalItems[n].style.transform=`translateY(${r}px)`,r+=this._physicalSizes[n]}),t&&this._scrollToIndex(0)}_increasePoolIfNeeded(t){t===0&&this._scrollingToIndex||!this._canPopulate()||!this._effectiveSize||(this._initialPoolCreated?this._optPhysicalSize!==1/0&&(this._debounceIncreasePool=sr.debounce(this._debounceIncreasePool,Ni,()=>{this._updateMetrics();let r=this._optPhysicalSize-this._physicalSize,n=Math.ceil(r/this._physicalAverage);this._physicalCount+n>this._effectiveSize&&(n=Math.max(0,this._effectiveSize-this._physicalCount)),this._physicalSize&&n>0&&this._optPhysicalSize!==1/0&&(super._increasePoolIfNeeded(n),this.__reorderChildNodes())})):(this._initialPoolCreated=!0,super._increasePoolIfNeeded(25)))}__reorderChildNodes(){let t=Array.from(this.$.items.childNodes);!!t.reduce((n,i,o,a)=>{if(o===0||a[o-1].index===i.index-1)return n},!0)||t.sort((n,i)=>n.index-i.index).forEach(n=>this.$.items.appendChild(n))}_createPool(t){let r=document.createDocumentFragment(),n=this._createScrollerRows(t);n.forEach(o=>r.appendChild(o)),this._getRowTarget().appendChild(r);let i=this.querySelector("[slot]");if(i){let o=i.getAttribute("slot");i.setAttribute("slot","foo-bar"),i.setAttribute("slot",o)}return Tm(this,()=>this.notifyResize()),n}_assignModels(t){this._iterateItems((r,n)=>{let i=this._physicalItems[r];this._toggleAttribute("hidden",n>=this._effectiveSize,i),this._updateScrollerItem(i,n+(this._vidxOffset||0))},t)}_scrollHandler(){let t=this.$.table.scrollTop-this._scrollPosition;this._accessIronListAPI(super._scrollHandler);let r=this._vidxOffset;this._accessIronListAPI(()=>this._maxScrollTop)&&this._virtualCount<this._effectiveSize?this._adjustVirtualIndexOffset(t):this._vidxOffset=0,this._vidxOffset!==r&&this._update(),this._afterScroll()}_adjustVirtualIndexOffset(t){if(Math.abs(t)>1e4){if(this._noScale){this._noScale=!1;return}let r=this.$.table.scrollTop/(this.$.table.scrollHeight-this.$.table.offsetHeight),n=r*this._effectiveSize;this._vidxOffset=Math.round(n-r*this._virtualCount)}else{let r=this._vidxOffset||0,n=1e3,i=100;this._scrollTop===0?(this._vidxOffset=0,r!==this._vidxOffset&&super.scrollToIndex(0)):this.firstVisibleIndex<n&&this._vidxOffset>0&&(this._vidxOffset-=Math.min(this._vidxOffset,i),r!==this._vidxOffset&&super.scrollToIndex(this.firstVisibleIndex+(r-this._vidxOffset)),this._noScale=!0);let o=this._effectiveSize-this._virtualCount;this._scrollTop>=this._maxScrollTop&&this._maxScrollTop>0?(this._vidxOffset=o,r!==this._vidxOffset&&super.scrollToIndex(this._virtualCount)):this.firstVisibleIndex>this._virtualCount-n&&this._vidxOffset<o&&(this._vidxOffset+=Math.min(o-this._vidxOffset,i),r!==this._vidxOffset&&super.scrollToIndex(this.firstVisibleIndex-(this._vidxOffset-r)),this._noScale=!0)}}_accessIronListAPI(t){this._warnPrivateAPIAccessAsyncEnabled=!1;let r=t.apply(this);return this._debouncerWarnPrivateAPIAccess=sr.debounce(this._debouncerWarnPrivateAPIAccess,Ni,()=>this._warnPrivateAPIAccessAsyncEnabled=!0),r}_debounceRender(t,r){super._debounceRender(()=>this._accessIronListAPI(t),r)}_warnPrivateAPIAccess(t){this._warnPrivateAPIAccessAsyncEnabled&&console.warn(`Accessing private API (${t})!`)}_render(){this._accessIronListAPI(super._render)}_itemsChanged(){}get _firstVisibleIndex(){return this._accessIronListAPI(()=>super.firstVisibleIndex)}get _lastVisibleIndex(){return this._accessIronListAPI(()=>super.lastVisibleIndex)}_scrollToIndex(t){this._accessIronListAPI(()=>this.scrollToIndex(t))}get firstVisibleIndex(){return this._warnPrivateAPIAccess("firstVisibleIndex"),super.firstVisibleIndex}set firstVisibleIndex(t){this._warnPrivateAPIAccess("firstVisibleIndex"),super.firstVisibleIndex=t}get lastVisibleIndex(){return this._warnPrivateAPIAccess("lastVisibleIndex"),super.lastVisibleIndex}set lastVisibleIndex(t){this._warnPrivateAPIAccess("lastVisibleIndex"),super.lastVisibleIndex=t}updateViewportBoundaries(){this._warnPrivateAPIAccess("updateViewportBoundaries"),super.updateViewportBoundaries.apply(this,arguments)}_resizeHandler(){super._resizeHandler(),ci()}};var jce=e=>class extends e{static get observers(){return["_a11yUpdateGridSize(size, _columnTree, _columnTree.*)"]}_a11yGetHeaderRowCount(r){return r.filter(n=>n.some(i=>i._headerTemplate||i.headerRenderer||i.path||i.header)).length}_a11yGetFooterRowCount(r){return r.filter(n=>n.some(i=>i._headerTemplate||i.headerRenderer)).length}_a11yUpdateGridSize(r,n){if(r===void 0||n===void 0)return;let i=n[n.length-1];this.$.table.setAttribute("aria-rowcount",r+this._a11yGetHeaderRowCount(n)+this._a11yGetFooterRowCount(n)),this.$.table.setAttribute("aria-colcount",i&&i.length||0),this._a11yUpdateHeaderRows(),this._a11yUpdateFooterRows()}_a11yUpdateHeaderRows(){Array.from(this.$.header.children).forEach((r,n)=>r.setAttribute("aria-rowindex",n+1))}_a11yUpdateFooterRows(){Array.from(this.$.footer.children).forEach((r,n)=>r.setAttribute("aria-rowindex",this._a11yGetHeaderRowCount(this._columnTree)+this.size+n+1))}_a11yUpdateRowRowindex(r,n){r.setAttribute("aria-rowindex",n+this._a11yGetHeaderRowCount(this._columnTree)+1)}_a11yUpdateRowSelected(r,n){r.setAttribute("aria-selected",Boolean(n)),Array.from(r.children).forEach(i=>i.setAttribute("aria-selected",Boolean(n)))}_a11yUpdateRowLevel(r,n){r.setAttribute("aria-level",n+1)}_a11yUpdateRowDetailsOpened(r,n){Array.from(r.children).forEach(i=>{typeof n=="boolean"?i.setAttribute("aria-expanded",n):i.hasAttribute("aria-expanded")&&i.removeAttribute("aria-expanded")})}_a11ySetRowDetailsCell(r,n){Array.from(r.children).forEach(i=>{i!==n&&i.setAttribute("aria-controls",n.id)})}_a11yUpdateCellColspan(r,n){r.setAttribute("aria-colspan",Number(n))}_a11yUpdateSorters(){Array.from(this.querySelectorAll("vaadin-grid-sorter")).forEach(r=>{let n=r.parentNode;for(;n&&n.localName!=="vaadin-grid-cell-content";)n=n.parentNode;n&&n.assignedSlot&&n.assignedSlot.parentNode.setAttribute("aria-sort",{asc:"ascending",desc:"descending"}[String(r.direction)]||"none")})}};var Xce=e=>class extends e{static get properties(){return{activeItem:{type:Object,notify:!0,value:null}}}ready(){super.ready(),this.$.scroller.addEventListener("click",this._onClick.bind(this)),this.addEventListener("cell-activate",this._activateItem.bind(this))}_activateItem(r){let n=r.detail.model,i=n?n.item:null;i&&(this.activeItem=this._itemsEqual(this.activeItem,i)?null:i)}_onClick(r){if(r.defaultPrevented)return;let n=r.composedPath(),i=n[n.indexOf(this.$.table)-3];if(!i||i.getAttribute("part").indexOf("details-cell")>-1)return;let o=i._content,a=this.getRootNode().activeElement;!o.contains(a)&&!this._isFocusable(r.target)&&this.dispatchEvent(new CustomEvent("cell-activate",{detail:{model:this.__getRowModel(i.parentElement)}}))}_isFocusable(r){return lhr(r)}},lhr=e=>{if(!e.parentNode)return!1;let r=Array.from(e.parentNode.querySelectorAll("[tabindex], button, input, select, textarea, object, iframe, label, a[href], area[href]")).filter(n=>n.getAttribute("part")!=="cell body-cell").indexOf(e)!==-1;return!e.disabled&&r};var $ce=e=>class extends e{static get properties(){return{items:Array}}static get observers(){return["_itemsChanged(items, items.*, isAttached)"]}_itemsChanged(r,n,i){if(!!i){if(!Array.isArray(r)){r==null&&(this.size=0),this.dataProvider===this._arrayDataProvider&&(this.dataProvider=void 0);return}this.size=r.length,this.dataProvider=this.dataProvider||this._arrayDataProvider,this.clearCache(),this._ensureFirstPageLoaded()}}_arrayDataProvider(r,n){let i=(Array.isArray(this.items)?this.items:[]).slice(0);this._filters&&this._checkPaths(this._filters,"filtering",i)&&(i=this._filter(i)),this.size=i.length,r.sortOrders.length&&this._checkPaths(this._sorters,"sorting",i)&&(i=i.sort(this._multiSort.bind(this)));let o=r.page*r.pageSize,a=o+r.pageSize,s=i.slice(o,a);n(s,i.length)}_checkPaths(r,n,i){if(!i.length)return!1;let o=!0;for(let a in r){let s=r[a].path;if(!s||s.indexOf(".")===-1)continue;let l=s.replace(/\.[^.]*$/,"");Da.get(l,i[0])===void 0&&(console.warn(`Path "${s}" used for ${n} does not exist in all of the items, ${n} is disabled.`),o=!1)}return o}_multiSort(r,n){return this._sorters.map(i=>i.direction==="asc"?this._compare(Da.get(i.path,r),Da.get(i.path,n)):i.direction==="desc"?this._compare(Da.get(i.path,n),Da.get(i.path,r)):0).reduce((i,o)=>i||o,0)}_normalizeEmptyValue(r){return[void 0,null].indexOf(r)>=0?"":isNaN(r)?r.toString():r}_compare(r,n){return r=this._normalizeEmptyValue(r),n=this._normalizeEmptyValue(n),r<n?-1:r>n?1:0}_filter(r){return r.filter(n=>this._filters.filter(i=>{let o=this._normalizeEmptyValue(Da.get(i.path,n)),a=this._normalizeEmptyValue(i.value).toString().toLowerCase();return o.toString().toLowerCase().indexOf(a)===-1}).length===0)}};var Kce=e=>class extends yh(e){ready(){super.ready();let r=this.$.scroller;Em(r,"track",this._onHeaderTrack.bind(this)),r.addEventListener("touchmove",n=>r.hasAttribute("column-resizing")&&n.preventDefault()),r.addEventListener("contextmenu",n=>n.target.getAttribute("part")=="resize-handle"&&n.preventDefault()),r.addEventListener("mousedown",n=>n.target.getAttribute("part")==="resize-handle"&&n.preventDefault())}_onHeaderTrack(r){let n=r.target;if(n.getAttribute("part")==="resize-handle"){let o=n.parentElement._column;for(this._toggleAttribute("column-resizing",!0,this.$.scroller);o.localName==="vaadin-grid-column-group";)o=Array.prototype.slice.call(o._childColumns,0).sort(function(l,c){return l._order-c._order}).filter(function(l){return!l.hidden}).pop();let a=Array.from(this.$.header.querySelectorAll('[part~="row"]:last-child [part~="cell"]')),s=a.filter(l=>l._column===o)[0];if(s.offsetWidth){let l=window.getComputedStyle(s),c=10+parseInt(l.paddingLeft)+parseInt(l.paddingRight)+parseInt(l.borderLeftWidth)+parseInt(l.borderRightWidth)+parseInt(l.marginLeft)+parseInt(l.marginRight),u=s.offsetWidth+(this.__isRTL?s.getBoundingClientRect().left-r.detail.x:r.detail.x-s.getBoundingClientRect().right);o.width=Math.max(c,u)+"px",o.flexGrow=0}a.sort(function(l,c){return l._column._order-c._column._order}).forEach(function(l,c,u){c<u.indexOf(s)&&(l._column.width=l.offsetWidth+"px",l._column.flexGrow=0)}),r.detail.state==="end"&&(this._toggleAttribute("column-resizing",!1,this.$.scroller),this.dispatchEvent(new CustomEvent("column-resize",{detail:{resizedColumn:o}}))),this._resizeHandler()}}};var Zce=class Jce{constructor(t,r,n){this.grid=t,this.parentCache=r,this.parentItem=n,this.itemCaches={},this.items={},this.effectiveSize=0,this.size=0,this.pendingRequests={}}isLoading(){return Boolean(Object.keys(this.pendingRequests).length||Object.keys(this.itemCaches).filter(t=>this.itemCaches[t].isLoading())[0])}getItemForIndex(t){let{cache:r,scaledIndex:n}=this.getCacheAndIndex(t);return r.items[n]}updateSize(){this.effectiveSize=!this.parentItem||this.grid._isExpanded(this.parentItem)?this.size+Object.keys(this.itemCaches).reduce((t,r)=>{let n=this.itemCaches[r];return n.updateSize(),t+n.effectiveSize},0):0}ensureSubCacheForScaledIndex(t){if(!this.itemCaches[t]){let r=new Jce(this.grid,this,this.items[t]);this.itemCaches[t]=r,this.grid._loadPage(0,r)}}getCacheAndIndex(t){let r=t,n=Object.keys(this.itemCaches);for(let i=0;i<n.length;i++){let o=Number(n[i]),a=this.itemCaches[o];if(r<=o)return{cache:this,scaledIndex:r};if(r<=o+a.effectiveSize)return a.getCacheAndIndex(r-o-1);r-=a.effectiveSize}return{cache:this,scaledIndex:r}}},Qce=e=>class extends e{static get properties(){return{pageSize:{type:Number,value:50,observer:"_pageSizeChanged"},dataProvider:{type:Object,notify:!0,observer:"_dataProviderChanged"},loading:{type:Boolean,notify:!0,readOnly:!0,reflectToAttribute:!0},_cache:{type:Object,value:function(){return new Zce(this)}},itemIdPath:{type:String,value:null},expandedItems:{type:Object,notify:!0,value:()=>[]}}}static get observers(){return["_sizeChanged(size)","_itemIdPathChanged(itemIdPath)","_expandedItemsChanged(expandedItems.*)"]}_sizeChanged(r){let n=r-this._cache.size;this._cache.size+=n,this._cache.effectiveSize+=n,this._effectiveSize=this._cache.effectiveSize,this._increasePoolIfNeeded(0),this._debounceIncreasePool&&this._debounceIncreasePool.flush()}_getItem(r,n){if(r>=this._effectiveSize)return;n.index=r;let{cache:i,scaledIndex:o}=this._cache.getCacheAndIndex(r),a=i.items[o];a?(this._toggleAttribute("loading",!1,n),this._updateItem(n,a),this._isExpanded(a)&&i.ensureSubCacheForScaledIndex(o)):(this._toggleAttribute("loading",!0,n),this._loadPage(this._getPageForIndex(o),i))}_expandedInstanceChangedCallback(r,n){r.item!==void 0&&(n?this.expandItem(r.item):this.collapseItem(r.item))}getItemId(r){return this.itemIdPath?this.get(this.itemIdPath,r):r}_isExpanded(r){return this.__expandedKeys.has(this.getItemId(r))}_expandedItemsChanged(){this.__cacheExpandedKeys(),this._cache.updateSize(),this._effectiveSize=this._cache.effectiveSize,this._assignModels()}_itemIdPathChanged(){this.__cacheExpandedKeys()}__cacheExpandedKeys(){this.expandedItems&&(this.__expandedKeys=new Set,this.expandedItems.forEach(r=>{this.__expandedKeys.add(this.getItemId(r))}))}expandItem(r){this._isExpanded(r)||(this.expandedItems=[...this.expandedItems,r])}collapseItem(r){this._isExpanded(r)&&(this.expandedItems=this.expandedItems.filter(n=>!this._itemsEqual(n,r)))}_getIndexLevel(r){let{cache:n}=this._cache.getCacheAndIndex(r),i=0;for(;n.parentCache;)n=n.parentCache,i++;return i}_canPopulate(){return Boolean(this._hasData&&this._columnTree)}_loadPage(r,n){if(!n.pendingRequests[r]&&this.dataProvider){this._setLoading(!0),n.pendingRequests[r]=!0;let i={page:r,pageSize:this.pageSize,sortOrders:this._mapSorters(),filters:this._mapFilters(),parentItem:n.parentItem};this._debounceIncreasePool&&this._debounceIncreasePool.flush(),this.dataProvider(i,(o,a)=>{a!==void 0?n.size=a:i.parentItem&&(n.size=o.length);let s=Array.from(this.$.items.children).map(l=>l._item);o.forEach((l,c)=>{let u=r*this.pageSize+c;n.items[u]=l,this._isExpanded(l)&&s.indexOf(l)>-1&&n.ensureSubCacheForScaledIndex(u)}),this._hasData=!0,delete n.pendingRequests[r],this._debouncerApplyCachedData=sr.debounce(this._debouncerApplyCachedData,mo.after(0),()=>{this._setLoading(!1),this._cache.updateSize(),this._effectiveSize=this._cache.effectiveSize,Array.from(this.$.items.children).filter(l=>!l.hidden).forEach(l=>{this._cache.getItemForIndex(l.index)&&this._getItem(l.index,l)}),this._increasePoolIfNeeded(0),this.__scrollToPendingIndex()}),this._cache.isLoading()||this._debouncerApplyCachedData.flush(),this.__itemsReceived()})}}_getPageForIndex(r){return Math.floor(r/this.pageSize)}clearCache(){this._cache=new Zce(this),Array.from(this.$.items.children).forEach(r=>{Array.from(r.children).forEach(n=>{n._instance&&n._instance._setPendingProperty("item",{},!1)})}),this._cache.size=this.size||0,this._cache.updateSize(),this._hasData=!1,this._assignModels(),(!this._effectiveSize||!this._initialPoolCreated)&&this._loadPage(0,this._cache)}_pageSizeChanged(r,n){n!==void 0&&r!==n&&this.clearCache()}_checkSize(){this.size===void 0&&this._effectiveSize===0&&console.warn("The <vaadin-grid> needs the total number of items in order to display rows. Set the total number of items to the `size` property, or provide the total number of items in the second argument of the `dataProvider`\u2019s `callback` call.")}_dataProviderChanged(r,n){n!==void 0&&this.clearCache(),r&&this.items&&this.items.length&&this._scrollToIndex(this._firstVisibleIndex),this._ensureFirstPageLoaded(),this._debouncerCheckSize=sr.debounce(this._debouncerCheckSize,mo.after(2e3),this._checkSize.bind(this)),this._scrollHandler()}_ensureFirstPageLoaded(){this._hasData||this._loadPage(0,this._cache)}_itemsEqual(r,n){return this.getItemId(r)===this.getItemId(n)}_getItemIndexInArray(r,n){let i=-1;return n.forEach((o,a)=>{this._itemsEqual(o,r)&&(i=a)}),i}scrollToIndex(r){super.scrollToIndex(r),!isNaN(r)&&(this._cache.isLoading()||!this.clientHeight)&&(this.__pendingScrollToIndex=r)}__scrollToPendingIndex(){if(this.__pendingScrollToIndex&&this.$.items.children.length){let r=this.__pendingScrollToIndex;delete this.__pendingScrollToIndex,this._debounceIncreasePool&&this._debounceIncreasePool.flush(),this.scrollToIndex(r)}}};var tue=e=>class extends e{ready(){super.ready(),this._addNodeObserver()}_hasColumnGroups(r){for(let n=0;n<r.length;n++)if(r[n].localName==="vaadin-grid-column-group")return!0;return!1}_getChildColumns(r){return vh.getFlattenedNodes(r).filter(this._isColumnElement)}_flattenColumnGroups(r){return r.map(n=>n.localName==="vaadin-grid-column-group"?this._getChildColumns(n):[n]).reduce((n,i)=>n.concat(i),[])}_getColumnTree(){let r=vh.getFlattenedNodes(this).filter(this._isColumnElement),n=[];for(let i=r;n.push(i),!!this._hasColumnGroups(i);)i=this._flattenColumnGroups(i);return n}_updateColumnTree(){let r=this._getColumnTree();this._arrayEquals(r,this._columnTree)||(this._columnTree=r)}_addNodeObserver(){this._observer=new vh(this,r=>{let n=r.addedNodes.filter(o=>o.localName==="template"&&o.classList.contains("row-details"))[0];n&&this._rowDetailsTemplate!==n&&(this._rowDetailsTemplate=n);let i=o=>o.filter(this._isColumnElement).length>0;if(i(r.addedNodes)||i(r.removedNodes)){let o=r.removedNodes.flatMap(s=>s._allCells),a=s=>o.filter(l=>l._content.contains(s)).length;this.__removeSorters(this._sorters.filter(a)),this.__removeFilters(this._filters.filter(a)),this._updateColumnTree()}this._debouncerCheckImports=sr.debounce(this._debouncerCheckImports,mo.after(2e3),this._checkImports.bind(this)),this._ensureFirstPageLoaded()})}_arrayEquals(r,n){if(!r||!n||r.length!=n.length)return!1;for(let i=0,o=r.length;i<o;i++)if(r[i]instanceof Array&&n[i]instanceof Array){if(!this._arrayEquals(r[i],n[i]))return!1}else if(r[i]!=n[i])return!1;return!0}_checkImports(){["vaadin-grid-column-group","vaadin-grid-filter","vaadin-grid-filter-column","vaadin-grid-tree-toggle","vaadin-grid-selection-column","vaadin-grid-sort-column","vaadin-grid-sorter"].forEach(r=>{let n=this.querySelector(r);n&&!(n instanceof mt)&&console.warn(`Make sure you have imported the required module for <${r}> element.`)})}_updateFirstAndLastColumn(){Array.from(this.shadowRoot.querySelectorAll("tr")).forEach(r=>this._updateFirstAndLastColumnForRow(r))}_updateFirstAndLastColumnForRow(r){Array.from(r.querySelectorAll('[part~="cell"]:not([part~="details-cell"])')).sort((n,i)=>n._column._order-i._column._order).forEach((n,i,o)=>{this._toggleAttribute("first-column",i===0,n),this._toggleAttribute("last-column",i===o.length-1,n)})}_isColumnElement(r){return r.nodeType===Node.ELEMENT_NODE&&/\bcolumn\b/.test(r.localName)}};var eue=e=>class extends e{getEventContext(r){let n={},i=r.composedPath(),o=i[i.indexOf(this.$.table)-3];return o&&(n.section=["body","header","footer","details"].filter(a=>o.getAttribute("part").indexOf(a)>-1)[0],o._column&&(n.column=o._column),(n.section==="body"||n.section==="details")&&Object.assign(n,this.__getRowModel(o.parentElement))),n}};var rue=e=>class extends e{static get properties(){return{_filters:{type:Array,value:function(){return[]}}}}ready(){super.ready(),this.addEventListener("filter-changed",this._filterChanged.bind(this))}_filterChanged(r){r.stopPropagation(),this.__addFilter(r.target),this.__applyFilters()}__removeFilters(r){r.length!=0&&(this._filters=this._filters.filter(n=>r.indexOf(n)<0),this.__applyFilters())}__addFilter(r){this._filters.indexOf(r)===-1&&this._filters.push(r)}__applyFilters(){this.dataProvider&&this.isAttached&&this.clearCache()}_mapFilters(){return this._filters.map(r=>({path:r.path,value:r.value}))}};var T0=class extends mt{static get is(){return"vaadin-grid-templatizer"}static get properties(){return{dataHost:Object,template:Object,_templateInstances:{type:Array,value:function(){return[]}},_parentPathValues:{value:function(){return{}}},_grid:Object}}static get observers(){return["_templateInstancesChanged(_templateInstances.*, _parentPathValues.*)"]}constructor(){super(),this._instanceProps={detailsOpened:!0,index:!0,item:!0,selected:!0,expanded:!0,level:!0}}createInstance(){this._ensureTemplatized();let t=new this._TemplateClass({});return this.addInstance(t),t}addInstance(t){this._templateInstances.indexOf(t)===-1&&(this._templateInstances.push(t),requestAnimationFrame(()=>this.notifyPath("_templateInstances.*",this._templateInstances)))}removeInstance(t){let r=this._templateInstances.indexOf(t);this.splice("_templateInstances",r,1)}_ensureTemplatized(){this._TemplateClass||(this._TemplateClass=tc(this.template,this,{instanceProps:this._instanceProps,parentModel:!0,forwardHostProp:function(t,r){this._forwardParentProp(t,r),this._templateInstances&&this._templateInstances.forEach(n=>n.notifyPath(t,r))},notifyInstanceProp:function(t,r,n){if(r==="index"||r==="item")return;let i=`__${r}__`;if(t[i]===n)return;t[i]=n;let o=Array.from(this._grid.$.items.children).filter(l=>this._grid._itemsEqual(l._item,t.item))[0];o&&Array.from(o.children).forEach(l=>{l._instance&&(l._instance[i]=n,l._instance.notifyPath(r,n))});let a="item.";if(Array.isArray(this._grid.items)&&r.indexOf(a)===0){let l=this._grid.items.indexOf(t.item),c=r.slice(a.length);this._grid.notifyPath(`items.${l}.${c}`,n)}let s=`_${r}InstanceChangedCallback`;this._grid&&this._grid[s]&&this._grid[s](t,n)}}))}_forwardParentProp(t,r){this._parentPathValues[t]=r,this._templateInstances.forEach(n=>n.notifyPath(t,r))}_templateInstancesChanged(t){let r,n;if(t.path==="_templateInstances")r=0,n=this._templateInstances.length;else if(t.path==="_templateInstances.splices")r=t.value.index,n=t.value.addedCount;else return;Object.keys(this._parentPathValues||{}).forEach(i=>{for(let o=r;o<r+n;o++)this._templateInstances[o].set(i,this._parentPathValues[i])})}};customElements.define(T0.is,T0);var nue=e=>class extends e{static get properties(){return{detailsOpenedItems:{type:Array,value:function(){return[]}},_rowDetailsTemplate:Object,rowDetailsRenderer:Function,_detailsCells:{type:Array}}}static get observers(){return["_detailsOpenedItemsChanged(detailsOpenedItems.*, _rowDetailsTemplate, rowDetailsRenderer)","_rowDetailsTemplateOrRendererChanged(_rowDetailsTemplate, rowDetailsRenderer)"]}_rowDetailsTemplateOrRendererChanged(r,n){if(r&&n)throw new Error("You should only use either a renderer or a template for row details");if(r||n){if(r&&!r.templatizer){let i=new T0;i._grid=this,i.dataHost=this.dataHost,i.template=r,r.templatizer=i}this._columnTree&&Array.from(this.$.items.children).forEach(i=>{i.querySelector("[part~=details-cell]")||(this._updateRow(i,this._columnTree[this._columnTree.length-1]),this._a11yUpdateRowDetailsOpened(i,!1)),delete i.querySelector("[part~=details-cell]")._instance}),this.detailsOpenedItems.length&&(Array.from(this.$.items.children).forEach(this._toggleDetailsCell,this),this._update())}}_detailsOpenedItemsChanged(r){r.path==="detailsOpenedItems.length"||!r.value||Array.from(this.$.items.children).forEach(n=>{this._toggleDetailsCell(n,n._item),this._a11yUpdateRowDetailsOpened(n,this._isDetailsOpened(n._item)),this._toggleAttribute("details-opened",this._isDetailsOpened(n._item),n)})}_configureDetailsCell(r){r.setAttribute("part","cell details-cell"),this._toggleAttribute("frozen",!0,r)}_toggleDetailsCell(r,n){let i=r.querySelector('[part~="details-cell"]');if(!i)return;let o=!this._isDetailsOpened(n),a=!!i.hidden!==o;(!i._instance&&!i._renderer||i.hidden!==o)&&(i.hidden=o,o?r.style.removeProperty("padding-bottom"):(this.rowDetailsRenderer?(i._renderer=this.rowDetailsRenderer,i._renderer.call(this,i._content,this,{index:r.index,item:n})):this._rowDetailsTemplate&&!i._instance&&(i._instance=this._rowDetailsTemplate.templatizer.createInstance(),i._content.innerHTML="",i._content.appendChild(i._instance.root),this._updateItem(r,n)),ci(),r.style.setProperty("padding-bottom",`${i.offsetHeight}px`),requestAnimationFrame(()=>this.notifyResize()))),a&&(this._updateMetrics(),this._positionItems())}_updateDetailsCellHeights(){Array.from(this.$.items.querySelectorAll('[part~="details-cell"]:not([hidden])')).forEach(r=>{r.parentElement.style.setProperty("padding-bottom",`${r.offsetHeight}px`)})}_isDetailsOpened(r){return this.detailsOpenedItems&&this._getItemIndexInArray(r,this.detailsOpenedItems)!==-1}openItemDetails(r){this._isDetailsOpened(r)||(this.detailsOpenedItems=[...this.detailsOpenedItems,r])}closeItemDetails(r){this._isDetailsOpened(r)&&(this.detailsOpenedItems=this.detailsOpenedItems.filter(n=>!this._itemsEqual(n,r)))}_detailsOpenedInstanceChangedCallback(r,n){n?this.openItemDetails(r.item):this.closeItemDetails(r.item)}};var zct={SCROLLING:500,IGNORE_WHEEL:500},iue=e=>class extends e{static get properties(){return{_frozenCells:{type:Array,value:()=>[]},_rowWithFocusedElement:Element,_deltaYAcc:{type:Number,value:0},_useSticky:{type:Boolean,value:window.CSS&&window.CSS.supports&&(window.CSS.supports("position","sticky")||window.CSS.supports("position","-webkit-sticky"))}}}static get observers(){return["_scrollViewportHeightUpdated(_viewportHeight)"]}set _scrollTop(r){this.$.table.scrollTop=r}get _scrollTop(){return this.$.table.scrollTop}constructor(){super(),this._scrollLineHeight=this._getScrollLineHeight()}_getScrollLineHeight(){let r=document.createElement("div");r.style.fontSize="initial",r.style.display="none",document.body.appendChild(r);let n=window.getComputedStyle(r).fontSize;return document.body.removeChild(r),n?window.parseInt(n):void 0}_scrollViewportHeightUpdated(r){this._scrollPageHeight=r-this.$.header.clientHeight-this.$.footer.clientHeight-this._scrollLineHeight}ready(){super.ready(),this.$.outerscroller=document.createElement("div"),this.scrollTarget=this.$.table,this.addEventListener("wheel",this._onWheel),this.$.items.addEventListener("focusin",r=>{let n=r.composedPath().indexOf(this.$.items);this._rowWithFocusedElement=r.composedPath()[n-1]}),this.$.items.addEventListener("focusout",()=>this._rowWithFocusedElement=void 0),this.scrollTarget.addEventListener("mousedown",()=>this.__mouseDown=!0),this.scrollTarget.addEventListener("mouseup",()=>{this.__mouseDown=!1,this.__pendingReorder&&(this.__pendingReorder=!1,setTimeout(()=>this._reorderRows(),zct.SCROLLING))})}scrollToIndex(r){this._accessIronListAPI(()=>super.scrollToIndex(r))}_onWheel(r){if(r.ctrlKey||this._hasScrolledAncestor(r.target,r.deltaX,r.deltaY))return;let n=this.$.table,i=r.deltaY;if(r.deltaMode===WheelEvent.DOM_DELTA_LINE?i*=this._scrollLineHeight:r.deltaMode===WheelEvent.DOM_DELTA_PAGE&&(i*=this._scrollPageHeight),this._wheelAnimationFrame){this._deltaYAcc+=i,r.preventDefault();return}i+=this._deltaYAcc,this._deltaYAcc=0,this._wheelAnimationFrame=!0,this._debouncerWheelAnimationFrame=sr.debounce(this._debouncerWheelAnimationFrame,Ni,()=>this._wheelAnimationFrame=!1);let o=Math.abs(r.deltaX)+Math.abs(i);this._canScroll(n,r.deltaX,i)?(r.preventDefault(),n.scrollTop+=i,n.scrollLeft+=r.deltaX,this._scrollHandler(),this._hasResidualMomentum=!0,this._ignoreNewWheel=!0,this._debouncerIgnoreNewWheel=sr.debounce(this._debouncerIgnoreNewWheel,mo.after(zct.IGNORE_WHEEL),()=>this._ignoreNewWheel=!1)):this._hasResidualMomentum&&o<=this._previousMomentum||this._ignoreNewWheel?r.preventDefault():o>this._previousMomentum&&(this._hasResidualMomentum=!1),this._previousMomentum=o}_hasScrolledAncestor(r,n,i){if(r.localName==="vaadin-grid-cell-content")return!1;if(this._canScroll(r,n,i)&&["auto","scroll"].indexOf(getComputedStyle(r).overflow)!==-1)return!0;if(r!==this&&r.parentElement)return this._hasScrolledAncestor(r.parentElement,n,i)}_canScroll(r,n,i){return i>0&&r.scrollTop<r.scrollHeight-r.offsetHeight||i<0&&r.scrollTop>0||n>0&&r.scrollLeft<r.scrollWidth-r.offsetWidth||n<0&&r.scrollLeft>0}_scheduleScrolling(){this._scrollingFrame||(this._scrollingFrame=requestAnimationFrame(()=>this._toggleAttribute("scrolling",!0,this.$.scroller))),this._debounceScrolling=sr.debounce(this._debounceScrolling,mo.after(zct.SCROLLING),()=>{cancelAnimationFrame(this._scrollingFrame),delete this._scrollingFrame,this._toggleAttribute("scrolling",!1,this.$.scroller),this._reorderRows()})}_afterScroll(){this._translateStationaryElements(),this.hasAttribute("reordering")||this._scheduleScrolling(),this._updateOverflow()}_updateOverflow(){let r="",n=this.$.table;n.scrollTop<n.scrollHeight-n.clientHeight&&(r+=" bottom"),n.scrollTop>0&&(r+=" top"),n.scrollLeft<n.scrollWidth-n.clientWidth&&(r+=" right"),n.scrollLeft>0&&(r+=" left"),this._debounceOverflow=sr.debounce(this._debounceOverflow,Ni,()=>{let i=r.trim();i.length>0&&this.getAttribute("overflow")!==i?this.setAttribute("overflow",i):i.length==0&&this.hasAttribute("overflow")&&this.removeAttribute("overflow")})}_reorderRows(){if(this.__mouseDown){this.__pendingReorder=!0;return}let r=this.$.items,n=r.querySelectorAll("tr");if(!n.length)return;let i=this._virtualStart+this._vidxOffset,o=this._rowWithFocusedElement||Array.from(n).filter(l=>!l.hidden)[0];if(!o)return;let a=o.index-i,s=Array.from(n).indexOf(o)-a;if(s>0)for(let l=0;l<s;l++)r.appendChild(n[l]);else if(s<0)for(let l=n.length+s;l<n.length;l++)r.insertBefore(n[l],n[0]);if(this._safari){let{transform:l}=this.$.header.style;this.$.header.style.transform="",setTimeout(()=>this.$.header.style.transform=l)}}_frozenCellsChanged(){this._debouncerCacheElements=sr.debounce(this._debouncerCacheElements,li,()=>{Array.from(this.shadowRoot.querySelectorAll('[part~="cell"]')).forEach(function(r){r.style.transform=""}),this._frozenCells=Array.prototype.slice.call(this.$.table.querySelectorAll("[frozen]")),this._updateScrollerMeasurements(),this._translateStationaryElements()}),this._updateLastFrozen()}_updateScrollerMeasurements(){this._frozenCells.length>0&&this.__isRTL&&(this.__scrollerMetrics={scrollWidth:this.$.table.scrollWidth,clientWidth:this.$.table.clientWidth})}_updateLastFrozen(){if(!this._columnTree)return;let r=this._columnTree[this._columnTree.length-1].slice(0);r.sort((i,o)=>i._order-o._order);let n=r.reduce((i,o,a)=>(o._lastFrozen=!1,o.frozen&&!o.hidden?a:i),void 0);n!==void 0&&(r[n]._lastFrozen=!0)}_translateStationaryElements(){let r=Math.max(0,this._scrollLeft),n=Math.max(0,this._scrollTop),i=0,o=0,a=0;if(this._useSticky||(i=r,o=n,a=this.$.table.clientHeight-this.$.footer.offsetHeight-this.$.footer.offsetTop),this.$.header.style.transform=this._getTranslate(-r+i,o),this.$.footer.style.transform=this._getTranslate(-r+i,o+a),this.$.items.style.transform=this._getTranslate(-r+i,0),this._frozenCells.length>0){let s=this.__isRTL?this.__getNormalizedScrollLeft(this.$.table)+this.__scrollerMetrics.clientWidth-this.__scrollerMetrics.scrollWidth:this._scrollLeft,l=this._getTranslate(s,0);for(let c=0;c<this._frozenCells.length;c++)this._frozenCells[c].style.transform=l}}_getTranslate(r,n){return`translate(${r}px, ${n}px)`}};var oue=e=>class extends e{static get properties(){return{selectedItems:{type:Object,notify:!0,value:()=>[]}}}static get observers(){return["_selectedItemsChanged(selectedItems.*)"]}_isSelected(r){return this.selectedItems&&this._getItemIndexInArray(r,this.selectedItems)>-1}selectItem(r){this._isSelected(r)||(this.selectedItems=[...this.selectedItems,r])}deselectItem(r){this._isSelected(r)&&(this.selectedItems=this.selectedItems.filter(n=>!this._itemsEqual(n,r)))}_toggleItem(r){this._getItemIndexInArray(r,this.selectedItems)===-1?this.selectItem(r):this.deselectItem(r)}_selectedItemsChanged(r){this.$.items.children.length&&(r.path==="selectedItems"||r.path==="selectedItems.splices")&&Array.from(this.$.items.children).forEach(n=>{this._updateItem(n,n._item)})}_selectedInstanceChangedCallback(r,n){n?this.selectItem(r.item):this.deselectItem(r.item)}};var aue=e=>class extends e{static get properties(){return{multiSort:{type:Boolean,value:!1},_sorters:{type:Array,value:function(){return[]}},_previousSorters:{type:Array,value:function(){return[]}}}}ready(){super.ready(),this.addEventListener("sorter-changed",this._onSorterChanged)}_onSorterChanged(r){let n=r.target;r.stopPropagation(),this.__updateSorter(n),this.__applySorters()}__removeSorters(r){r.length!=0&&(this._sorters=this._sorters.filter(n=>r.indexOf(n)<0),this.multiSort&&this.__updateSortOrders(),this.__applySorters())}__updateSortOrders(){this._sorters.forEach((r,n)=>r._order=this._sorters.length>1?n:null,this)}__updateSorter(r){if(!(!r.direction&&this._sorters.indexOf(r)===-1)){if(r._order=null,this.multiSort)this._removeArrayItem(this._sorters,r),r.direction&&this._sorters.unshift(r),this.__updateSortOrders();else if(r.direction){let n=this._sorters.filter(i=>i!=r);this._sorters=[r],n.forEach(i=>{i._order=null,i.direction=null})}}}__applySorters(){this.dataProvider&&this.isAttached&&JSON.stringify(this._previousSorters)!==JSON.stringify(this._mapSorters())&&this.clearCache(),this._a11yUpdateSorters(),this._previousSorters=this._mapSorters()}_mapSorters(){return this._sorters.map(r=>({path:r.path,direction:r.direction}))}_removeArrayItem(r,n){let i=r.indexOf(n);i>-1&&r.splice(i,1)}};var sue=e=>class extends e{static get properties(){return{cellClassNameGenerator:Function}}static get observers(){return["__cellClassNameGeneratorChanged(cellClassNameGenerator)"]}__cellClassNameGeneratorChanged(){this.generateCellClassNames()}generateCellClassNames(){Array.from(this.$.items.children).filter(r=>!r.hidden).forEach(r=>this._generateCellClassNames(r,this.__getRowModel(r)))}_generateCellClassNames(r,n){Array.from(r.children).forEach(i=>{if(i.__generatedClasses&&i.__generatedClasses.forEach(o=>i.classList.remove(o)),this.cellClassNameGenerator){let o=this.cellClassNameGenerator(i._column,n);i.__generatedClasses=o&&o.split(" ").filter(a=>a.length>0),i.__generatedClasses&&i.__generatedClasses.forEach(a=>i.classList.add(a))}})}};var TP={BETWEEN:"between",ON_TOP:"on-top",ON_TOP_OR_BETWEEN:"on-top-or-between",ON_GRID:"on-grid"},C0={ON_TOP:"on-top",ABOVE:"above",BELOW:"below",EMPTY:"empty"},lue=e=>class extends e{static get properties(){return{dropMode:String,rowsDraggable:Boolean,dragFilter:Function,dropFilter:Function,__dndAutoScrollThreshold:{value:50}}}static get observers(){return["_dragDropAccessChanged(rowsDraggable, dropMode, dragFilter, dropFilter)"]}ready(){super.ready(),this.$.table.addEventListener("dragstart",this._onDragStart.bind(this)),this.$.table.addEventListener("dragend",this._onDragEnd.bind(this)),this.$.table.addEventListener("dragover",this._onDragOver.bind(this)),this.$.table.addEventListener("dragleave",this._onDragLeave.bind(this)),this.$.table.addEventListener("drop",this._onDrop.bind(this)),this.$.table.addEventListener("dragenter",r=>{this.dropMode&&(r.preventDefault(),r.stopPropagation())})}_onDragStart(r){if(this.rowsDraggable){let n=r.target;if(n.localName==="vaadin-grid-cell-content"&&(n=n.assignedSlot.parentNode.parentNode),n.parentNode!==this.$.items)return;if(r.stopPropagation(),this._toggleAttribute("dragging-rows",!0,this),this._safari){let s=n.style.transform;n.style.top=/translateY\((.*)\)/.exec(s)[1],n.style.transform="none",requestAnimationFrame(()=>{n.style.top="",n.style.transform=s})}let i=n.getBoundingClientRect();this._ios?r.dataTransfer.setDragImage(n):r.dataTransfer.setDragImage(n,r.clientX-i.left,r.clientY-i.top);let o=[n];this._isSelected(n._item)&&(o=this.__getViewportRows().filter(s=>this._isSelected(s._item)).filter(s=>!this.dragFilter||this.dragFilter(this.__getRowModel(s)))),r.dataTransfer.setData("text",this.__formatDefaultTransferData(o)),n.setAttribute("dragstart",o.length>1?o.length:""),this.updateStyles({"--_grid-drag-start-x":`${r.clientX-i.left+20}px`,"--_grid-drag-start-y":`${r.clientY-i.top+10}px`}),requestAnimationFrame(()=>{n.removeAttribute("dragstart"),this.updateStyles({"--_grid-drag-start-x":"","--_grid-drag-start-y":""})});let a=new CustomEvent("grid-dragstart",{detail:{draggedItems:o.map(s=>s._item),setDragData:(s,l)=>r.dataTransfer.setData(s,l),setDraggedItemsCount:s=>n.setAttribute("dragstart",s)}});a.originalEvent=r,this.dispatchEvent(a)}}_onDragEnd(r){this._toggleAttribute("dragging-rows",!1,this),r.stopPropagation();let n=new CustomEvent("grid-dragend");n.originalEvent=r,this.dispatchEvent(n)}_onDragLeave(r){r.stopPropagation(),this._clearDragStyles()}_onDragOver(r){if(this.dropMode){if(this._dropLocation=void 0,this._dragOverItem=void 0,this.__dndAutoScroll(r.clientY)){this._clearDragStyles();return}let n=r.composedPath().filter(i=>i.localName==="tr")[0];if(!this._effectiveSize||this.dropMode===TP.ON_GRID)this._dropLocation=C0.EMPTY;else if(!n||n.parentNode!==this.$.items){if(n)return;if(this.dropMode===TP.BETWEEN||this.dropMode===TP.ON_TOP_OR_BETWEEN)n=Array.from(this.$.items.children).filter(i=>!i.hidden).pop(),this._dropLocation=C0.BELOW;else return}else{let i=n.getBoundingClientRect();if(this._dropLocation=C0.ON_TOP,this.dropMode===TP.BETWEEN){let o=r.clientY-i.top<i.bottom-r.clientY;this._dropLocation=o?C0.ABOVE:C0.BELOW}else this.dropMode===TP.ON_TOP_OR_BETWEEN&&(r.clientY-i.top<i.height/3?this._dropLocation=C0.ABOVE:r.clientY-i.top>i.height/3*2&&(this._dropLocation=C0.BELOW))}if(n&&n.hasAttribute("drop-disabled")){this._dropLocation=void 0;return}r.stopPropagation(),r.preventDefault(),this._dropLocation===C0.EMPTY?this._toggleAttribute("dragover",!0,this):n?(this._dragOverItem=n._item,n.getAttribute("dragover")!==this._dropLocation&&n.setAttribute("dragover",this._dropLocation)):this._clearDragStyles()}}__dndAutoScroll(r){if(this.__dndAutoScrolling)return!0;let n=this.$.header.getBoundingClientRect().bottom,i=this.$.footer.getBoundingClientRect().top,o=n-r+this.__dndAutoScrollThreshold,a=r-i+this.__dndAutoScrollThreshold,s=0;if(a>0?s=a*2:o>0&&(s=-o*2),s){let l=this.$.table.scrollTop;if(this.$.table.scrollTop+=s,l!==this.$.table.scrollTop)return this.__dndAutoScrolling=!0,setTimeout(()=>this.__dndAutoScrolling=!1,20),this._scrollHandler(),!0}}__getViewportRows(){let r=this.$.header.getBoundingClientRect().bottom,n=this.$.footer.getBoundingClientRect().top;return Array.from(this.$.items.children).filter(i=>{let o=i.getBoundingClientRect();return o.bottom>r&&o.top<n})}_clearDragStyles(){this.removeAttribute("dragover"),Array.from(this.$.items.children).forEach(r=>r.removeAttribute("dragover"))}_onDrop(r){if(this.dropMode){r.stopPropagation(),r.preventDefault();let n=r.dataTransfer.types&&Array.from(r.dataTransfer.types).map(o=>({type:o,data:r.dataTransfer.getData(o)}));this._clearDragStyles();let i=new CustomEvent("grid-drop",{bubbles:r.bubbles,cancelable:r.cancelable,detail:{dropTargetItem:this._dragOverItem,dropLocation:this._dropLocation,dragData:n}});i.originalEvent=r,this.dispatchEvent(i)}}__formatDefaultTransferData(r){return r.map(n=>Array.from(n.children).filter(i=>!i.hidden&&i.getAttribute("part").indexOf("details-cell")===-1).sort((i,o)=>i._column._order>o._column._order?1:-1).map(i=>i._content.textContent.trim()).filter(i=>i).join("	")).join(`
`)}_dragDropAccessChanged(){this.filterDragAndDrop()}filterDragAndDrop(){Array.from(this.$.items.children).filter(r=>!r.hidden).forEach(r=>{this._filterDragAndDrop(r,this.__getRowModel(r))})}_filterDragAndDrop(r,n){let i=!this.rowsDraggable||this.dragFilter&&!this.dragFilter(n),o=!this.dropMode||this.dropFilter&&!this.dropFilter(n);Array.from(r.children).map(s=>s._content).forEach(s=>{i?s.removeAttribute("draggable"):s.setAttribute("draggable",!0)}),this._toggleAttribute("drag-disabled",i,r),this._toggleAttribute("drop-disabled",o,r)}};var cue=e=>class extends e{static get properties(){return{_headerFocusable:{type:Object,observer:"_focusableChanged"},_itemsFocusable:{type:Object,observer:"_focusableChanged"},_footerFocusable:{type:Object,observer:"_focusableChanged"},_navigatingIsHidden:Boolean,_focusedItemIndex:{type:Number,value:0},_focusedColumnOrder:Number,interacting:{type:Boolean,value:!1,reflectToAttribute:!0,readOnly:!0,observer:"_interactingChanged"}}}ready(){super.ready(),!(this._ios||this._android)&&(this.addEventListener("keydown",this._onKeyDown),this.addEventListener("keyup",this._onKeyUp),this.addEventListener("focusin",this._onFocusIn),this.addEventListener("focusout",this._onFocusOut),this.$.table.addEventListener("focusin",this._onCellFocusIn.bind(this)),this.$.table.addEventListener("focusout",this._onCellFocusOut.bind(this)),this.addEventListener("mousedown",()=>{this._toggleAttribute("navigating",!1,this),this._isMousedown=!0}),this.addEventListener("mouseup",()=>this._isMousedown=!1))}_focusableChanged(r,n){n&&n.setAttribute("tabindex","-1"),r&&this._updateGridSectionFocusTarget(r)}_interactingChanged(){this._updateGridSectionFocusTarget(this._headerFocusable),this._updateGridSectionFocusTarget(this._itemsFocusable),this._updateGridSectionFocusTarget(this._footerFocusable)}_onKeyDown(r){let n=r.key,i;switch(n){case"ArrowUp":case"ArrowDown":case"ArrowLeft":case"ArrowRight":case"PageUp":case"PageDown":case"Home":case"End":i="Navigation";break;case"Enter":case"Escape":case"F2":i="Interaction";break;case"Tab":i="Tab";break;case" ":i="Space";break}this._detectInteracting(r),this.interacting&&i!=="Interaction"&&(i=void 0),i&&this[`_on${i}KeyDown`](r,n)}_ensureScrolledToIndex(r){Array.from(this.$.items.children).filter(i=>i.index===r)[0]||this._scrollToIndex(r)}_onNavigationKeyDown(r,n){this._scrollHandler(),r.preventDefault();function i(B){return Array.prototype.indexOf.call(B.parentNode.children,B)}let o=this._lastVisibleIndex-this._firstVisibleIndex-1,a=0,s=0;switch(n){case"ArrowRight":a=this.__isRTL?-1:1;break;case"ArrowLeft":a=this.__isRTL?1:-1;break;case"Home":a=-1/0,r.ctrlKey&&(s=-1/0);break;case"End":a=1/0,r.ctrlKey&&(s=1/0);break;case"ArrowDown":s=1;break;case"ArrowUp":s=-1;break;case"PageDown":s=o;break;case"PageUp":s=-o;break}let l=r.composedPath()[0],c=i(l),u=this._elementMatches(l,'[part~="details-cell"]'),h=l.parentNode,f=h.parentNode,p=(f===this.$.items?this._effectiveSize:f.children.length)-1,d=f===this.$.items?this._focusedItemIndex!==void 0?this._focusedItemIndex:h.index:i(h),g=Math.max(0,Math.min(d+s,p)),_=!1;if(f===this.$.items){let B=h._item,I=this._cache.getItemForIndex(g);u?_=s===0:_=s===1&&this._isDetailsOpened(B)||s===-1&&g!==d&&this._isDetailsOpened(I),_!==u&&(s===1&&_||s===-1&&!_)&&(g=d)}if(f!==this.$.items){if(g>d)for(;g<p&&f.children[g].hidden;)g++;else if(g<d)for(;g>0&&f.children[g].hidden;)g--}this._focusedColumnOrder===void 0&&(u?this._focusedColumnOrder=0:this._focusedColumnOrder=this._getColumns(f,d).filter(B=>!B.hidden)[c]._order);let y=this._getColumns(f,g).filter(B=>!B.hidden),x=y.map(B=>B._order).sort((B,I)=>B-I),b=x.length-1,S=x.indexOf(x.slice(0).sort((B,I)=>Math.abs(B-this._focusedColumnOrder)-Math.abs(I-this._focusedColumnOrder))[0]),C=s===0&&u?S:Math.max(0,Math.min(S+a,b));C!==S&&(this._focusedColumnOrder=void 0),f===this.$.items&&this._ensureScrolledToIndex(g),this._toggleAttribute("navigating",!0,this);let k=y.reduce((B,I,L)=>(B[I._order]=L,B),{})[x[C]],O=f===this.$.items?Array.from(f.children).filter(B=>B.index===g)[0]:f.children[g];if(!O)return;let D=_?Array.from(O.children).filter(B=>this._elementMatches(B,'[part~="details-cell"]'))[0]:O.children[k];if(this._scrollHorizontallyToCell(D),f===this.$.items&&(this._focusedItemIndex=g),f===this.$.items){let B=D.getBoundingClientRect(),I=this.$.footer.getBoundingClientRect().top,L=this.$.header.getBoundingClientRect().bottom;B.bottom>I?(this.$.table.scrollTop+=B.bottom-I,this._scrollHandler()):B.top<L&&(this.$.table.scrollTop-=L-B.top,this._scrollHandler())}D.focus()}_onInteractionKeyDown(r,n){let i=r.composedPath()[0],o=i.localName==="input"&&!/^(button|checkbox|color|file|image|radio|range|reset|submit)$/i.test(i.type),a;switch(n){case"Enter":a=this.interacting?!o:!0;break;case"Escape":a=!1;break;case"F2":a=!this.interacting;break}let{cell:s}=this._getGridEventLocation(r);if(this.interacting!==a&&s!==null)if(a){let l=s._content.querySelector("[focus-target]")||s._content.firstElementChild;l&&(r.preventDefault(),l.focus(),this._setInteracting(!0),this._toggleAttribute("navigating",!1,this))}else r.preventDefault(),this._focusedColumnOrder=void 0,s.focus(),this._setInteracting(!1),this._toggleAttribute("navigating",!0,this)}_predictFocusStepTarget(r,n){let i=[this.$.table,this._headerFocusable,this._itemsFocusable,this._footerFocusable,this.$.focusexit],o=i.indexOf(r);for(o+=n;o>=0&&o<=i.length-1&&(!i[o]||i[o].parentNode.hidden);)o+=n;return i[o]}_onTabKeyDown(r){let n=this._predictFocusStepTarget(r.composedPath()[0],r.shiftKey?-1:1);if(n===this.$.table)this.$.table.focus();else if(n===this.$.focusexit)this.$.focusexit.focus();else if(n===this._itemsFocusable){let i=n,o=this._itemsFocusable.parentNode;if(this._ensureScrolledToIndex(this._focusedItemIndex),o.index!==this._focusedItemIndex){let a=Array.from(o.children).indexOf(this._itemsFocusable),s=Array.from(this.$.items.children).filter(l=>l.index===this._focusedItemIndex)[0];s&&(i=s.children[a])}r.preventDefault(),i.focus()}else r.preventDefault(),n.focus();this._toggleAttribute("navigating",!0,this)}_onSpaceKeyDown(r){r.preventDefault();let n=r.composedPath()[0];(!n._content||!n._content.firstElementChild)&&this.dispatchEvent(new CustomEvent("cell-activate",{detail:{model:this.__getRowModel(n.parentElement)}}))}_onKeyUp(r){if(!/^( |SpaceBar)$/.test(r.key))return;r.preventDefault();let n=r.composedPath()[0];if(n._content&&n._content.firstElementChild){let i=this.hasAttribute("navigating");n._content.firstElementChild.click(),this._toggleAttribute("navigating",i,this)}}_onFocusIn(r){this._isMousedown||this._toggleAttribute("navigating",!0,this);let n=r.composedPath()[0];n===this.$.table||n===this.$.focusexit?(this._predictFocusStepTarget(n,n===this.$.table?1:-1).focus(),this._setInteracting(!1)):this._detectInteracting(r)}_onFocusOut(r){this._toggleAttribute("navigating",!1,this),this._detectInteracting(r)}_onCellFocusIn(r){let{section:n,cell:i}=this._getGridEventLocation(r);this._detectInteracting(r),n&&i&&(this._activeRowGroup=n,this.$.header===n?this._headerFocusable=i:this.$.items===n?this._itemsFocusable=i:this.$.footer===n&&(this._footerFocusable=i),i._content.dispatchEvent(new CustomEvent("cell-focusin",{bubbles:!1})),i.dispatchEvent(new CustomEvent("cell-focus",{bubbles:!0,composed:!0}))),this._detectFocusedItemIndex(r)}_onCellFocusOut(r){r.composedPath().indexOf(this.$.table)===3&&r.composedPath()[0]._content.dispatchEvent(new CustomEvent("cell-focusout",{bubbles:!1}))}_detectInteracting(r){let n=r.composedPath().some(i=>i.localName==="vaadin-grid-cell-content");this._setInteracting(n)}_detectFocusedItemIndex(r){let{section:n,row:i}=this._getGridEventLocation(r);n===this.$.items&&(this._focusedItemIndex=i.index)}_updateGridSectionFocusTarget(r){if(!r)return;let n=this._getGridSectionFromFocusTarget(r),i=this.interacting&&n===this._activeRowGroup;r.tabIndex=i?-1:0}_preventScrollerRotatingCellFocus(r,n){r.index===this._focusedItemIndex&&this.hasAttribute("navigating")&&this._activeRowGroup===this.$.items&&(this._navigatingIsHidden=!0,this._toggleAttribute("navigating",!1,this)),n===this._focusedItemIndex&&this._navigatingIsHidden&&(this._navigatingIsHidden=!1,this._toggleAttribute("navigating",!0,this))}_getColumns(r,n){let i=this._columnTree.length-1;return r===this.$.header?i=n:r===this.$.footer&&(i=this._columnTree.length-1-n),this._columnTree[i]}_resetKeyboardNavigation(){if(this.$.header.firstElementChild&&(this._headerFocusable=Array.from(this.$.header.firstElementChild.children).filter(r=>!r.hidden)[0]),this.$.items.firstElementChild){let r=this._iterateItems((n,i)=>{if(this._firstVisibleIndex===i)return this.$.items.children[n]});r&&(this._itemsFocusable=Array.from(r.children).filter(n=>!n.hidden)[0])}this.$.footer.firstElementChild&&(this._footerFocusable=Array.from(this.$.footer.firstElementChild.children).filter(r=>!r.hidden)[0])}_scrollHorizontallyToCell(r){if(r.hasAttribute("frozen")||this._elementMatches(r,'[part~="details-cell"]'))return;let n=r.getBoundingClientRect(),i=r.parentNode,o=Array.from(i.children).indexOf(r),a=this.$.table.getBoundingClientRect(),s=a.left,l=a.right;for(let c=o-1;c>=0;c--){let u=i.children[c];if(!(u.hasAttribute("hidden")||this._elementMatches(u,'[part~="details-cell"]'))&&u.hasAttribute("frozen")){s=u.getBoundingClientRect().right;break}}for(let c=o+1;c<i.children.length;c++){let u=i.children[c];if(!(u.hasAttribute("hidden")||this._elementMatches(u,'[part~="details-cell"]'))&&u.hasAttribute("frozen")){l=u.getBoundingClientRect().left;break}}n.left<s&&(this.$.table.scrollLeft+=Math.round(n.left-s)),n.right>l&&(this.$.table.scrollLeft+=Math.round(n.right-l))}_elementMatches(r,n){return r.matches?r.matches(n):Array.from(r.parentNode.querySelectorAll(n)).indexOf(r)!==-1}_getGridEventLocation(r){let n=r.composedPath(),i=n.indexOf(this.$.table),o=i>=1?n[i-1]:null,a=i>=2?n[i-2]:null,s=i>=3?n[i-3]:null;return{section:o,row:a,cell:s}}_getGridSectionFromFocusTarget(r){return r===this._headerFocusable?this.$.header:r===this._itemsFocusable?this.$.items:r===this._footerFocusable?this.$.footer:null}};function uue(e,t,r){let n=1;e.forEach(i=>{n%10===0&&n++,i._order=r+n*t,n++})}var hue=e=>class extends yh(e){static get properties(){return{columnReorderingAllowed:{type:Boolean,value:!1},_orderBaseScope:{type:Number,value:1e7}}}static get observers(){return["_updateOrders(_columnTree, _columnTree.*)"]}ready(){super.ready(),Em(this,"track",this._onTrackEvent),this._reorderGhost=this.shadowRoot.querySelector('[part="reorder-ghost"]'),this.addEventListener("touchstart",this._onTouchStart.bind(this)),this.addEventListener("touchmove",this._onTouchMove.bind(this)),this.addEventListener("touchend",this._onTouchEnd.bind(this)),this.addEventListener("contextmenu",this._onContextMenu.bind(this))}_onContextMenu(r){this.hasAttribute("reordering")&&r.preventDefault()}_onTouchStart(r){this._startTouchReorderTimeout=setTimeout(()=>{this._onTrackStart({detail:{x:r.touches[0].clientX,y:r.touches[0].clientY}})},100)}_onTouchMove(r){this._draggedColumn&&r.preventDefault(),clearTimeout(this._startTouchReorderTimeout)}_onTouchEnd(){clearTimeout(this._startTouchReorderTimeout),this._onTrackEnd()}_onTrackEvent(r){if(r.detail.state==="start"){let n=r.composedPath(),i=n[n.indexOf(this.$.header)-2];if(!i||!i._content||i._content.contains(this.getRootNode().activeElement)||this.$.scroller.hasAttribute("column-resizing"))return;this._touchDevice||this._onTrackStart(r)}else r.detail.state==="track"?this._onTrack(r):r.detail.state==="end"&&this._onTrackEnd(r)}_onTrackStart(r){if(!this.columnReorderingAllowed)return;let n=r.composedPath&&r.composedPath();if(n&&n.filter(o=>o.hasAttribute&&o.hasAttribute("draggable"))[0])return;let i=this._cellFromPoint(r.detail.x,r.detail.y);if(!(!i||i.getAttribute("part").indexOf("header-cell")===-1)){for(this._toggleAttribute("reordering",!0,this),this._draggedColumn=i._column;this._draggedColumn.parentElement.childElementCount===1;)this._draggedColumn=this._draggedColumn.parentElement;this._setSiblingsReorderStatus(this._draggedColumn,"allowed"),this._draggedColumn._reorderStatus="dragging",this._updateGhost(i),this._reorderGhost.style.visibility="visible",this._updateGhostPosition(r.detail.x,this._touchDevice?r.detail.y-50:r.detail.y),this._autoScroller()}}_onTrack(r){if(!this._draggedColumn)return;let n=this._cellFromPoint(r.detail.x,r.detail.y);if(!n)return;let i=this._getTargetColumn(n,this._draggedColumn);this._isSwapAllowed(this._draggedColumn,i)&&this._isSwappableByPosition(i,r.detail.x)&&this._swapColumnOrders(this._draggedColumn,i),this._updateGhostPosition(r.detail.x,this._touchDevice?r.detail.y-50:r.detail.y),this._lastDragClientX=r.detail.x}_onTrackEnd(){!this._draggedColumn||(this._toggleAttribute("reordering",!1,this),this._draggedColumn._reorderStatus="",this._setSiblingsReorderStatus(this._draggedColumn,""),this._draggedColumn=null,this._lastDragClientX=null,this._reorderGhost.style.visibility="hidden",this.dispatchEvent(new CustomEvent("column-reorder",{detail:{columns:this._getColumnsInOrder()}})))}_getColumnsInOrder(){return this._columnTree.slice(0).pop().filter(r=>!r.hidden).sort((r,n)=>r._order-n._order)}_cellFromPoint(r,n){r=r||0,n=n||0,this._draggedColumn||this._toggleAttribute("no-content-pointer-events",!0,this.$.scroller);let i=this.shadowRoot.elementFromPoint(r,n);if(this._toggleAttribute("no-content-pointer-events",!1,this.$.scroller),i&&i._column)return i}_updateGhostPosition(r,n){let i=this._reorderGhost.getBoundingClientRect(),o=r-i.width/2,a=n-i.height/2,s=parseInt(this._reorderGhost._left||0),l=parseInt(this._reorderGhost._top||0);this._reorderGhost._left=s-(i.left-o),this._reorderGhost._top=l-(i.top-a),this._reorderGhost.style.transform=`translate(${this._reorderGhost._left}px, ${this._reorderGhost._top}px)`}_updateGhost(r){let n=this._reorderGhost;n.textContent=r._content.innerText;let i=window.getComputedStyle(r);return["boxSizing","display","width","height","background","alignItems","padding","border","flex-direction","overflow"].forEach(o=>n.style[o]=i[o]),n}_updateOrders(r,n){r===void 0||n===void 0||(r[0].forEach(i=>i._order=0),uue(r[0],this._orderBaseScope,0))}_setSiblingsReorderStatus(r,n){Array.from(r.parentNode.children).filter(i=>/column/.test(i.localName)&&this._isSwapAllowed(i,r)).forEach(i=>i._reorderStatus=n)}_autoScroller(){if(this._lastDragClientX){let r=this._lastDragClientX-this.getBoundingClientRect().right+50,n=this.getBoundingClientRect().left-this._lastDragClientX+50;r>0?this.$.table.scrollLeft+=r/10:n>0&&(this.$.table.scrollLeft-=n/10),this._scrollHandler()}this._draggedColumn&&this.async(this._autoScroller,10)}_isSwapAllowed(r,n){if(r&&n){let i=r!==n,o=r.parentElement===n.parentElement,a=r.frozen===n.frozen;return i&&o&&a}}_isSwappableByPosition(r,n){let i=Array.from(this.$.header.querySelectorAll('tr:not([hidden]) [part~="cell"]')).filter(s=>r.contains(s._column))[0],o=this.$.header.querySelector("tr:not([hidden]) [reorder-status=dragging]").getBoundingClientRect(),a=i.getBoundingClientRect();return a.left>o.left?n>a.right-o.width:n<a.left+o.width}_swapColumnOrders(r,n){let i=r._order;r._order=n._order,n._order=i,this._updateLastFrozen(),this._updateFirstAndLastColumn()}_getTargetColumn(r,n){if(r&&n){let i=r._column;for(;i.parentElement!==n.parentElement&&i!==this;)i=i.parentElement;return i.parentElement===n.parentElement?i:r._column}}};var chr=e=>class extends e{static get properties(){return{resizable:{type:Boolean,value:function(){if(this.localName==="vaadin-grid-column-group")return;let r=this.parentNode;return r&&r.localName==="vaadin-grid-column-group"&&r.resizable||!1}},_headerTemplate:{type:Object},_footerTemplate:{type:Object},frozen:{type:Boolean,value:!1},hidden:{type:Boolean},header:{type:String},textAlign:{type:String},_lastFrozen:{type:Boolean,value:!1},_order:Number,_reorderStatus:Boolean,_emptyCells:Array,_headerCell:Object,_footerCell:Object,_grid:Object,headerRenderer:Function,footerRenderer:Function}}static get observers(){return["_widthChanged(width, _headerCell, _footerCell, _cells.*)","_frozenChanged(frozen, _headerCell, _footerCell, _cells.*)","_flexGrowChanged(flexGrow, _headerCell, _footerCell, _cells.*)","_pathOrHeaderChanged(path, header, _headerCell, _footerCell, _cells.*, renderer, headerRenderer, _bodyTemplate, _headerTemplate)","_textAlignChanged(textAlign, _cells.*, _headerCell, _footerCell)","_orderChanged(_order, _headerCell, _footerCell, _cells.*)","_lastFrozenChanged(_lastFrozen)","_setBodyTemplateOrRenderer(_bodyTemplate, renderer, _cells, _cells.*)","_setHeaderTemplateOrRenderer(_headerTemplate, headerRenderer, _headerCell)","_setFooterTemplateOrRenderer(_footerTemplate, footerRenderer, _footerCell)","_resizableChanged(resizable, _headerCell)","_reorderStatusChanged(_reorderStatus, _headerCell, _footerCell, _cells.*)","_hiddenChanged(hidden, _headerCell, _footerCell, _cells.*)"]}connectedCallback(){super.connectedCallback(),this._bodyTemplate&&(this._bodyTemplate.templatizer._grid=this._grid),this._headerTemplate&&(this._headerTemplate.templatizer._grid=this._grid),this._footerTemplate&&(this._footerTemplate.templatizer._grid=this._grid),this._templateObserver.flush(),this._bodyTemplate||this._templateObserver.callback(),requestAnimationFrame(()=>{this._allCells.forEach(r=>{r._content.parentNode||this._grid&&this._grid.appendChild(r._content)})})}disconnectedCallback(){super.disconnectedCallback(),requestAnimationFrame(()=>{this._findHostGrid()||this._allCells.forEach(r=>{r._content.parentNode&&r._content.parentNode.removeChild(r._content)})}),this._gridValue=void 0}_findHostGrid(){let r=this;for(;r&&!/^vaadin.*grid(-pro)?$/.test(r.localName);)r=r.assignedSlot?r.assignedSlot.parentNode:r.parentNode;return r||void 0}get _grid(){return this._gridValue||(this._gridValue=this._findHostGrid()),this._gridValue}get _allCells(){return[].concat(this._cells||[]).concat(this._emptyCells||[]).concat(this._headerCell).concat(this._footerCell).filter(r=>r)}constructor(){super(),this._templateObserver=new vh(this,()=>{this._headerTemplate=this._prepareHeaderTemplate(),this._footerTemplate=this._prepareFooterTemplate(),this._bodyTemplate=this._prepareBodyTemplate()})}_prepareHeaderTemplate(){return this._prepareTemplatizer(this._findTemplate(!0)||null,{})}_prepareFooterTemplate(){return this._prepareTemplatizer(this._findTemplate(!1,!0)||null,{})}_prepareBodyTemplate(){return this._prepareTemplatizer(this._findTemplate()||null)}_prepareTemplatizer(r,n){if(r&&!r.templatizer){let i=new T0;i._grid=this._grid,i.dataHost=this.dataHost,i._instanceProps=n||i._instanceProps,i.template=r,r.templatizer=i}return r}_renderHeaderAndFooter(){this.headerRenderer&&this._headerCell&&this.__runRenderer(this.headerRenderer,this._headerCell),this.footerRenderer&&this._footerCell&&this.__runRenderer(this.footerRenderer,this._footerCell)}__runRenderer(r,n,i){let o=[n._content,this];i&&i.item&&o.push(i),r.apply(this,o)}__setColumnTemplateOrRenderer(r,n,i){if(!this.hidden){if(r&&n)throw new Error("You should only use either a renderer or a template");i.forEach(o=>{let a=this._grid.__getRowModel(o.parentElement);if(n)o._renderer=n,(a.item||n===this.headerRenderer||n===this.footerRenderer)&&this.__runRenderer(n,o,a);else if(o._template!==r){o._template=r,o._content.innerHTML="",r.templatizer._grid=r.templatizer._grid||this._grid;let s=r.templatizer.createInstance();o._content.appendChild(s.root),o._instance=s,a.item&&o._instance.setProperties(a)}})}}_setBodyTemplateOrRenderer(r,n,i){(r||n)&&i&&this.__setColumnTemplateOrRenderer(r,n,i)}_setHeaderTemplateOrRenderer(r,n,i){(r||n)&&i&&this.__setColumnTemplateOrRenderer(r,n,[i])}_setFooterTemplateOrRenderer(r,n,i){(r||n)&&i&&(this.__setColumnTemplateOrRenderer(r,n,[i]),this._grid.__updateHeaderFooterRowVisibility(i.parentElement))}_selectFirstTemplate(r=!1,n=!1){return vh.getFlattenedNodes(this).filter(i=>i.localName==="template"&&i.classList.contains("header")===r&&i.classList.contains("footer")===n)[0]}_findTemplate(r,n){let i=this._selectFirstTemplate(r,n);return i&&this.dataHost&&(i._rootDataHost=this.dataHost._rootDataHost||this.dataHost),i}_flexGrowChanged(r){this.parentElement&&this.parentElement._columnPropChanged&&this.parentElement._columnPropChanged("flexGrow"),this._allCells.forEach(n=>n.style.flexGrow=r)}_orderChanged(r){this._allCells.forEach(n=>n.style.order=r)}_widthChanged(r){this.parentElement&&this.parentElement._columnPropChanged&&this.parentElement._columnPropChanged("width"),this._allCells.forEach(n=>n.style.width=r),this._grid&&this._grid.__forceReflow&&this._grid.__forceReflow()}_frozenChanged(r){this.parentElement&&this.parentElement._columnPropChanged&&this.parentElement._columnPropChanged("frozen",r),this._allCells.forEach(n=>this._toggleAttribute("frozen",r,n)),this._grid&&this._grid._frozenCellsChanged&&this._grid._frozenCellsChanged()}_lastFrozenChanged(r){this._allCells.forEach(n=>this._toggleAttribute("last-frozen",r,n)),this.parentElement&&this.parentElement._columnPropChanged&&(this.parentElement._lastFrozen=r)}_pathOrHeaderChanged(r,n,i,o,a,s,l,c,u){let h=n!==void 0;if(!l&&!u&&h&&i&&this.__setTextContent(i._content,n),r&&a.value){if(!s&&!c){let f=(p,d,{item:g})=>this.__setTextContent(p,this.get(r,g));this.__setColumnTemplateOrRenderer(void 0,f,a.value)}!l&&!u&&!h&&i&&n!==null&&this.__setTextContent(i._content,this._generateHeader(r))}i&&this._grid.__updateHeaderFooterRowVisibility(i.parentElement)}__setTextContent(r,n){r.textContent!==n&&(r.textContent=n)}_generateHeader(r){return r.substr(r.lastIndexOf(".")+1).replace(/([A-Z])/g,"-$1").toLowerCase().replace(/-/g," ").replace(/^./,n=>n.toUpperCase())}_toggleAttribute(r,n,i){i.hasAttribute(r)===!n&&(n?i.setAttribute(r,""):i.removeAttribute(r))}_reorderStatusChanged(r){this._allCells.forEach(n=>n.setAttribute("reorder-status",r))}_resizableChanged(r,n){r===void 0||n===void 0||n&&[n].concat(this._emptyCells).forEach(i=>{if(i){let o=i.querySelector('[part~="resize-handle"]');if(o&&i.removeChild(o),r){let a=document.createElement("div");a.setAttribute("part","resize-handle"),i.appendChild(a)}}})}_textAlignChanged(r){if(r===void 0)return;if(["start","end","center"].indexOf(r)===-1){console.warn('textAlign can only be set as "start", "end" or "center"');return}let n;getComputedStyle(this._grid).direction==="ltr"?r==="start"?n="left":r==="end"&&(n="right"):r==="start"?n="right":r==="end"&&(n="left"),this._allCells.forEach(i=>{i._content.style.textAlign=r,getComputedStyle(i._content).textAlign!==r&&(i._content.style.textAlign=n)})}_hiddenChanged(r){this.parentElement&&this.parentElement._columnPropChanged&&this.parentElement._columnPropChanged("hidden",r),!!r!=!!this._previousHidden&&this._grid&&(r===!0&&this._allCells.forEach(n=>{n._content.parentNode&&n._content.parentNode.removeChild(n._content)}),this._grid._debouncerHiddenChanged=sr.debounce(this._grid._debouncerHiddenChanged,Ni,()=>{this._grid&&this._grid._renderColumnTree&&this._grid._renderColumnTree(this._grid._columnTree)}),this._grid._updateLastFrozen&&this._grid._updateLastFrozen(),this._grid.notifyResize&&this._grid.notifyResize(),this._grid._resetKeyboardNavigation&&this._grid._resetKeyboardNavigation()),this._previousHidden=r}},eV=class extends chr(ZH(mt)){static get is(){return"vaadin-grid-column"}static get properties(){return{width:{type:String,value:"100px"},flexGrow:{type:Number,value:1},renderer:Function,path:{type:String},autoWidth:{type:Boolean,value:!1},_bodyTemplate:{type:Object},_cells:Array}}};customElements.define(eV.is,eV);jc("vaadin-grid",Ci`
    @keyframes vaadin-grid-appear {
      to {
        opacity: 1;
      }
    }

    :host {
      display: block;
      animation: 1ms vaadin-grid-appear;
      height: 400px;
      flex: 1 1 auto;
      align-self: stretch;
      position: relative;
    }

    :host([hidden]) {
      display: none !important;
    }

    #scroller {
      display: block;
      transform: translateY(0);
      width: auto;
      height: auto;
      position: absolute;
      top: 0;
      right: 0;
      bottom: 0;
      left: 0;
    }

    :host([height-by-rows]) {
      height: auto;
      align-self: flex-start;
      flex-grow: 0;
      width: 100%;
    }

    :host([height-by-rows]) #scroller {
      width: 100%;
      height: 100%;
      position: relative;
    }

    #table {
      display: flex;
      flex-direction: column;
      width: 100%;
      height: 100%;
      overflow: auto;
      position: relative;
      outline: none;
      /* Workaround for a Desktop Safari bug: new stacking context here prevents the scrollbar from getting hidden */
      z-index: 0;
    }

    #header,
    #footer {
      display: block;
      position: -webkit-sticky;
      position: sticky;
      left: 0;
      overflow: visible;
      width: 100%;
      z-index: 1;
    }

    #header {
      top: 0;
    }

    th {
      text-align: inherit;
    }

    /* Safari doesn't work with "inherit" */
    [safari] th {
      text-align: initial;
    }

    #footer {
      bottom: 0;
    }

    #items {
      flex-grow: 1;
      flex-shrink: 0;
      display: block;
      position: -webkit-sticky;
      position: sticky;
      width: 100%;
      left: 0;
      overflow: visible;
    }

    [part~='row'] {
      display: flex;
      width: 100%;
      box-sizing: border-box;
      margin: 0;
    }

    [part~='row'][loading] [part~='body-cell'] ::slotted(vaadin-grid-cell-content) {
      opacity: 0;
    }

    #items [part~='row'] {
      position: absolute;
    }

    #items [part~='row']:empty {
      height: 1em;
    }

    [part~='cell']:not([part~='details-cell']) {
      flex-shrink: 0;
      flex-grow: 1;
      box-sizing: border-box;
      display: flex;
      width: 100%;
      position: relative;
      align-items: center;
      padding: 0;
      white-space: nowrap;
    }

    [part~='details-cell'] {
      position: absolute;
      bottom: 0;
      width: 100%;
      box-sizing: border-box;
      padding: 0;
    }

    [part~='cell'] ::slotted(vaadin-grid-cell-content) {
      display: block;
      width: 100%;
      box-sizing: border-box;
      overflow: hidden;
      text-overflow: ellipsis;
    }

    [hidden] {
      display: none !important;
    }

    [frozen] {
      z-index: 2;
      will-change: transform;
    }

    [no-scrollbars][safari] #table,
    [no-scrollbars][firefox] #table {
      overflow: hidden;
    }

    /* Reordering styles */
    :host([reordering]) [part~='cell'] ::slotted(vaadin-grid-cell-content),
    :host([reordering]) [part~='resize-handle'],
    #scroller[no-content-pointer-events] [part~='cell'] ::slotted(vaadin-grid-cell-content) {
      pointer-events: none;
    }

    [part~='reorder-ghost'] {
      visibility: hidden;
      position: fixed;
      pointer-events: none;
      opacity: 0.5;

      /* Prevent overflowing the grid in Firefox */
      top: 0;
      left: 0;
    }

    :host([reordering]) {
      -moz-user-select: none;
      -webkit-user-select: none;
      user-select: none;
    }

    /* Resizing styles */
    [part~='resize-handle'] {
      position: absolute;
      top: 0;
      right: 0;
      height: 100%;
      cursor: col-resize;
      z-index: 1;
    }

    [part~='resize-handle']::before {
      position: absolute;
      content: '';
      height: 100%;
      width: 35px;
      transform: translateX(-50%);
    }

    [last-column] [part~='resize-handle']::before,
    [last-frozen] [part~='resize-handle']::before {
      width: 18px;
      transform: none;
      right: 0;
    }

    #scroller[column-resizing] {
      -ms-user-select: none;
      -moz-user-select: none;
      -webkit-user-select: none;
      user-select: none;
    }

    /* Sizer styles */
    #sizer {
      display: flex;
      position: absolute;
      visibility: hidden;
    }

    #sizer [part~='details-cell'] {
      display: none !important;
    }

    #sizer [part~='cell'][hidden] {
      display: none !important;
    }

    #sizer [part~='cell'] {
      display: block;
      flex-shrink: 0;
      line-height: 0;
      height: 0 !important;
      min-height: 0 !important;
      max-height: 0 !important;
      padding: 0 !important;
      border: none !important;
    }

    #sizer [part~='cell']::before {
      content: '-';
    }

    #sizer [part~='cell'] ::slotted(vaadin-grid-cell-content) {
      display: none !important;
    }

    /* RTL specific styles */

    :host([dir='rtl']) #items,
    :host([dir='rtl']) #header,
    :host([dir='rtl']) #footer {
      left: auto;
    }

    :host([dir='rtl']) [part~='reorder-ghost'] {
      left: auto;
      right: 0;
    }

    :host([dir='rtl']) [part~='resize-handle'] {
      left: 0;
      right: auto;
    }

    :host([dir='rtl']) [part~='resize-handle']::before {
      transform: translateX(50%);
    }

    :host([dir='rtl']) [last-column] [part~='resize-handle']::before,
    :host([dir='rtl']) [last-frozen] [part~='resize-handle']::before {
      left: 0;
      right: auto;
    }
  `,{moduleId:"vaadin-grid-styles"});var uhr=(()=>{try{return document.createEvent("TouchEvent"),!0}catch(e){return!1}})(),rV=class extends JH(XH(Qce($ce(tue(Xce(iue(oue(aue(nue(cue(jce(rue(hue(Kce(eue(lue(sue(tV)))))))))))))))))){static get template(){return Q`
      <div
        id="scroller"
        safari$="[[_safari]]"
        ios$="[[_ios]]"
        loading$="[[loading]]"
        column-reordering-allowed$="[[columnReorderingAllowed]]"
      >
        <table id="table" role="grid" aria-multiselectable="true" tabindex="0">
          <caption id="sizer" part="row"></caption>
          <thead id="header" role="rowgroup"></thead>
          <tbody id="items" role="rowgroup"></tbody>
          <tfoot id="footer" role="rowgroup"></tfoot>
        </table>

        <div part="reorder-ghost"></div>
      </div>

      <div id="focusexit" tabindex="0"></div>
    `}static get is(){return"vaadin-grid"}static get version(){return"20.0.2"}static get observers(){return["_columnTreeChanged(_columnTree, _columnTree.*)"]}static get properties(){return{_safari:{type:Boolean,value:/^((?!chrome|android).)*safari/i.test(navigator.userAgent)},_ios:{type:Boolean,value:/iPad|iPhone|iPod/.test(navigator.userAgent)&&!window.MSStream||navigator.platform==="MacIntel"&&navigator.maxTouchPoints>1},_firefox:{type:Boolean,value:navigator.userAgent.toLowerCase().indexOf("firefox")>-1},_android:{type:Boolean,value:/android/i.test(navigator.userAgent)},_touchDevice:{type:Boolean,value:uhr},heightByRows:{type:Boolean,value:!1,reflectToAttribute:!0,observer:"_heightByRowsChanged"},_recalculateColumnWidthOnceLoadingFinished:{type:Boolean,value:!0}}}constructor(){super(),this.addEventListener("animationend",this._onAnimationEnd)}connectedCallback(){super.connectedCallback(),this.recalculateColumnWidths()}attributeChangedCallback(t,r,n){super.attributeChangedCallback(t,r,n),t==="dir"&&(this.__isRTL=n==="rtl",this._updateScrollerMeasurements())}__hasRowsWithClientHeight(){return!!Array.from(this.$.items.children).filter(t=>t.clientHeight).length}__itemsReceived(){this._recalculateColumnWidthOnceLoadingFinished&&!this._cache.isLoading()&&this.__hasRowsWithClientHeight()&&(this._recalculateColumnWidthOnceLoadingFinished=!1,this.recalculateColumnWidths())}_recalculateColumnWidths(t){t.forEach(r=>{r.width="auto",r._origFlexGrow=r.flexGrow,r.flexGrow=0}),t.forEach(r=>{r._currentWidth=0,r._allCells.forEach(n=>{let i=n.offsetWidth+1;r._currentWidth=Math.max(r._currentWidth,i)})}),t.forEach(r=>{r.width=`${r._currentWidth}px`,r.flexGrow=r._origFlexGrow,r._currentWidth=void 0,r._origFlexGrow=void 0})}recalculateColumnWidths(){if(!!this._columnTree)if(this._cache.isLoading())this._recalculateColumnWidthOnceLoadingFinished=!0;else{let t=this._getColumns().filter(r=>!r.hidden&&r.autoWidth);this._recalculateColumnWidths(t)}}_createScrollerRows(t){let r=[];for(let n=0;n<t;n++){let i=document.createElement("tr");i.setAttribute("part","row"),i.setAttribute("role","row"),this._columnTree&&this._updateRow(i,this._columnTree[this._columnTree.length-1],"body",!1,!0),r.push(i)}return this._columnTree&&this._columnTree[this._columnTree.length-1].forEach(n=>n.isConnected&&n.notifyPath&&n.notifyPath("_cells.*",n._cells)),vgt(this,()=>{this._updateFirstAndLastColumn(),this._resetKeyboardNavigation()}),r}_getRowTarget(){return this.$.items}_createCell(t){let r=this._contentIndex=this._contentIndex+1||0,n="vaadin-grid-cell-content-"+r,i=document.createElement("vaadin-grid-cell-content");i.setAttribute("slot",n);let o=document.createElement(t);o.id=n.replace("-content-","-"),o.setAttribute("tabindex","-1"),o.setAttribute("role",t==="td"?"gridcell":"columnheader");let a=document.createElement("slot");return a.setAttribute("name",n),o.appendChild(a),o._content=i,i.addEventListener("mousedown",()=>{if(window.chrome){let s=()=>{i.contains(this.getRootNode().activeElement)||o.focus(),document.removeEventListener("mouseup",s,!0)};document.addEventListener("mouseup",s,!0)}else setTimeout(()=>{i.contains(this.getRootNode().activeElement)||o.focus()})}),o}_updateRow(t,r,n,i,o){n=n||"body";let a=document.createDocumentFragment();Array.from(t.children).forEach(s=>s._vacant=!0),t.innerHTML="",t.id!=="sizer"&&(t.hidden=!0),r.filter(s=>!s.hidden).forEach((s,l,c)=>{let u;if(n==="body"){if(s._cells=s._cells||[],u=s._cells.filter(h=>h._vacant)[0],u||(u=this._createCell("td"),s._cells.push(u)),u.setAttribute("part","cell body-cell"),t.appendChild(u),l===c.length-1&&(this._rowDetailsTemplate||this.rowDetailsRenderer)){this._detailsCells=this._detailsCells||[];let h=this._detailsCells.filter(f=>f._vacant)[0]||this._createCell("td");this._detailsCells.indexOf(h)===-1&&this._detailsCells.push(h),h._content.parentElement||a.appendChild(h._content),this._configureDetailsCell(h),t.appendChild(h),this._a11ySetRowDetailsCell(t,h),h._vacant=!1}s.notifyPath&&!o&&s.notifyPath("_cells.*",s._cells)}else{let h=n==="header"?"th":"td";i||s.localName==="vaadin-grid-column-group"?(u=s[`_${n}Cell`]||this._createCell(h),u._column=s,t.appendChild(u),s[`_${n}Cell`]=u):(s._emptyCells=s._emptyCells||[],u=s._emptyCells.filter(f=>f._vacant)[0]||this._createCell(h),u._column=s,t.appendChild(u),s._emptyCells.indexOf(u)===-1&&s._emptyCells.push(u)),u.setAttribute("part",`cell ${n}-cell`),this.__updateHeaderFooterRowVisibility(t)}u._content.parentElement||a.appendChild(u._content),u._vacant=!1,u._column=s}),this.appendChild(a),this._frozenCellsChanged(),this._updateFirstAndLastColumnForRow(t)}__updateHeaderFooterRowVisibility(t){if(!t)return;let r=Array.from(t.children).filter(n=>{let i=n._column;if(i._emptyCells&&i._emptyCells.indexOf(n)>-1)return!1;if(t.parentElement===this.$.header){if(i.headerRenderer||i._headerTemplate)return!0;if(i.header===null)return!1;if(i.path||i.header!==void 0)return!0}else if(i.footerRenderer||i._footerTemplate)return!0});t.hidden!==!r.length&&(t.hidden=!r.length,this.notifyResize())}_updateScrollerItem(t,r){this._preventScrollerRotatingCellFocus(t,r),this._columnTree&&(this._toggleAttribute("first",r===0,t),this._toggleAttribute("odd",r%2,t),this._a11yUpdateRowRowindex(t,r),this._getItem(r,t))}_columnTreeChanged(t){this._renderColumnTree(t),this.recalculateColumnWidths()}_renderColumnTree(t){for(Array.from(this.$.items.children).forEach(r=>this._updateRow(r,t[t.length-1],null,!1,!0));this.$.header.children.length<t.length;){let r=document.createElement("tr");r.setAttribute("part","row"),r.setAttribute("role","row"),this.$.header.appendChild(r);let n=document.createElement("tr");n.setAttribute("part","row"),n.setAttribute("role","row"),this.$.footer.appendChild(n)}for(;this.$.header.children.length>t.length;)this.$.header.removeChild(this.$.header.firstElementChild),this.$.footer.removeChild(this.$.footer.firstElementChild);Array.from(this.$.header.children).forEach((r,n)=>this._updateRow(r,t[n],"header",n===t.length-1)),Array.from(this.$.footer.children).forEach((r,n)=>this._updateRow(r,t[t.length-1-n],"footer",n===0)),this._updateRow(this.$.sizer,t[t.length-1]),this._resizeHandler(),this._frozenCellsChanged(),this._updateFirstAndLastColumn(),this._resetKeyboardNavigation(),this._a11yUpdateHeaderRows(),this._a11yUpdateFooterRows(),this.__updateFooterPositioning()}__updateFooterPositioning(){this._firefox&&(this.$.items.style.paddingBottom=0,this.heightByRows||(this.$.items.style.paddingBottom=`${this.$.footer.offsetHeight}px`)),this._ios&&!window.CSS.supports("position","sticky")&&(this.$.table.style.height="",this.$.table.style.minHeight="100%",this.$.table.style.maxHeight="100%",setTimeout(()=>this.$.table.style.height=`${this.$.scroller.offsetHeight}px`))}_updateItem(t,r){t._item=r;let n=this.__getRowModel(t);this._toggleAttribute("selected",n.selected,t),this._a11yUpdateRowSelected(t,n.selected),this._a11yUpdateRowLevel(t,n.level),this._toggleAttribute("expanded",n.expanded,t),this._toggleAttribute("details-opened",this._isDetailsOpened(r),t),(this._rowDetailsTemplate||this.rowDetailsRenderer)&&this._toggleDetailsCell(t,r),this._generateCellClassNames(t,n),this._filterDragAndDrop(t,n),Array.from(t.children).forEach(i=>{if(i._renderer){let o=i._column||this;i._renderer.call(o,i._content,o,n)}else i._instance&&(i._instance.__detailsOpened__=n.detailsOpened,i._instance.__selected__=n.selected,i._instance.__level__=n.level,i._instance.__expanded__=n.expanded,i._instance.setProperties(n))}),this._debouncerUpdateHeights=sr.debounce(this._debouncerUpdateHeights,mo.after(1),()=>{this._updateMetrics(),this._positionItems(),this._updateScrollerSize()})}_resizeHandler(){this._updateDetailsCellHeights(),this._accessIronListAPI(super._resizeHandler,!0),this._updateScrollerMeasurements(),this.__updateFooterPositioning()}_onAnimationEnd(t){t.animationName.indexOf("vaadin-grid-appear")===0&&(this._render(),t.stopPropagation(),this.notifyResize(),this.__itemsReceived(),requestAnimationFrame(()=>{this.__scrollToPendingIndex(),this.$.table.style.webkitOverflowScrolling="touch"}))}_toggleAttribute(t,r,n){n.hasAttribute(t)===!r&&(r?n.setAttribute(t,""):n.removeAttribute(t))}__getRowModel(t){return{index:t.index,item:t._item,level:this._getIndexLevel(t.index),expanded:this._isExpanded(t._item),selected:this._isSelected(t._item),detailsOpened:!!(this._rowDetailsTemplate||this.rowDetailsRenderer)&&this._isDetailsOpened(t._item)}}render(){this._columnTree&&(this._columnTree.forEach(t=>{t.forEach(r=>r._renderHeaderAndFooter())}),this._update())}notifyResize(){super.notifyResize()}_heightByRowsChanged(t,r){(t||r)&&this.notifyResize()}__forceReflow(){this._debouncerForceReflow=sr.debounce(this._debouncerForceReflow,Ni,()=>{this.$.scroller.style.overflow="hidden",setTimeout(()=>this.$.scroller.style.overflow="")})}};customElements.define(rV.is,rV);function fue(e,t){return Bgt(e,t)}var c1=class extends mt{constructor(){super(...arguments),this._run=""}_csvUrl(t,r,n){return r?Mi(n(t,r),{format:"csv"}):""}_jsonUrl(t,r,n){return r?n(t,r):""}_csvName(t,r){return r?`run-${r}-tag-${t}.csv`:""}_jsonName(t,r){return r?`run-${r}-tag-${t}.json`:""}};c1.template=Q`
    <paper-dropdown-menu
      no-label-float="true"
      label="run to download"
      selected-item-label="{{_run}}"
    >
      <paper-listbox slot="dropdown-content">
        <template is="dom-repeat" items="[[runs]]">
          <paper-item no-label-float="true">[[item]]</paper-item>
        </template>
      </paper-listbox>
    </paper-dropdown-menu>
    <template is="dom-if" if="[[_run]]">
      <a download="[[_csvName(tag, _run)]]" href="[[_csvUrl(tag, _run, urlFn)]]"
        >CSV</a
      ><!--
      --><a
        download="[[_jsonName(tag, _run)]]"
        href="[[_jsonUrl(tag, _run, urlFn)]]"
        >JSON</a
      >
    </template>
    <style>
      :host {
        display: flex;
        align-items: center;
        height: 32px;
      }
      paper-dropdown-menu {
        width: 100px;
        --paper-input-container-label: {
          font-size: 10px;
        }
        --paper-input-container-input: {
          font-size: 10px;
        }
      }
      a {
        font-size: 10px;
        margin: 0 0.2em;
      }
      paper-input {
        font-size: 22px;
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],c1.prototype,"_run",void 0);E([A({type:Array}),w("design:type",Array)],c1.prototype,"runs",void 0);E([A({type:String}),w("design:type",String)],c1.prototype,"tag",void 0);E([A({type:Object}),w("design:type",Object)],c1.prototype,"urlFn",void 0);c1=E([yt("tf-downloader")],c1);var hhr=64,Eli=new URLSearchParams(window.location.search),Gn=class extends mt{constructor(){super(...arguments),this.colorScale=null,this._loadDataCallback=(t,r,n)=>{if(n==null){console.error("Failed to load data for:",r);return}let i=n.map(a=>({wall_time:new Date(a[0]*1e3),step:a[1],scalar:a[2]})),o=this._getSeriesNameFromDatum(r);t.setSeriesMetadata(o,r),t.setSeriesData(o,i)},this.getDataLoadUrl=({tag:t,run:r})=>_e().pluginRouteForSrc("scalars","/scalars",new URLSearchParams({tag:t,run:r})),this._downloadUrlFn=(t,r)=>this.getDataLoadUrl({tag:t,run:r}),this.requestData=(t,r,n)=>this.inColab?this._requestDataGet(t,r,n):this._requestDataPost(t,r,n),this._requestDataGet=(t,r,n)=>{let o=_e().pluginRoute("scalars","/scalars");Promise.all(t.map(a=>{let s=Mi(o,{tag:a.tag,run:a.run});return this.requestManager.request(s).then(l=>void r({item:a,data:l}))})).finally(()=>void n())},this._requestDataPost=(t,r,n)=>{var c;let o=_e().pluginRoute("scalars","/scalars_multirun"),a=new Map;for(let{tag:u,run:h}of t){let f=a.get(u);f==null&&a.set(u,f=[]),f.push(h)}let s=(c=this.batchSize)!=null?c:hhr,l=[];for(let[u,h]of a)for(let f=0;f<h.length;f+=s)l.push({tag:u,runs:h.slice(f,f+s)});Promise.all(l.map(({tag:u,runs:h})=>this.requestManager.request(o,{tag:u,runs:h}).then(f=>{for(let p of h){let d={tag:u,run:p};Object.prototype.hasOwnProperty.call(f,p)?r({item:d,data:f[p]}):r({item:d,data:null})}}))).finally(()=>void n())},this._getDataLoadName=t=>this._getSeriesNameFromDatum(t),this._expanded=!1,this._tooltipColumns=(()=>{let t=ist.slice(),r=t.findIndex(n=>n.title=="Name");return t.splice(r,1,{title:"Name",evaluate:n=>{let i=n.dataset.metadata().meta;return this._getSeriesDisplayNameFromDatum(i)}}),t})()}_getChartDataLoader(){var t;return(t=this.shadowRoot)==null?void 0:t.querySelector("tf-line-chart-data-loader")}reload(){this._getChartDataLoader().reload()}redraw(){this._getChartDataLoader().redraw()}_toggleExpanded(t){this.set("_expanded",!this._expanded),this.redraw()}_toggleLogScale(){this.set("_logScaleActive",!this._logScaleActive)}_resetDomain(){let t=this._getChartDataLoader();t&&t.resetDomain()}_updateDownloadLink(){var n;let t=this._getChartDataLoader().exportAsSvgString(),r=(n=this.shadowRoot)==null?void 0:n.querySelector("#svgLink");r.href=`data:image/svg+xml;base64,${btoa(t)}`}_runsFromData(t){return t.map(r=>r.run)}_getDataSeries(){return this.dataToLoad.map(t=>this._getSeriesNameFromDatum(t))}_getSeriesNameFromDatum({run:t,experiment:r={name:"_default"}}){return JSON.stringify([r.name,t])}_getSeriesDisplayNameFromDatum(t){return t.run}_getColorScale(){return this.colorScale!==null?this.colorScale:{scale:t=>{let[,r]=JSON.parse(t);return fn(r)}}}};Gn.template=Q`
    <tf-card-heading
      tag="[[tag]]"
      display-name="[[tagMetadata.displayName]]"
      description="[[tagMetadata.description]]"
    ></tf-card-heading>
    <div id="tf-line-chart-data-loader-container">
      <tf-line-chart-data-loader
        active="[[active]]"
        color-scale="[[_getColorScale(colorScale)]]"
        data-series="[[_getDataSeries(dataToLoad.*)]]"
        data-to-load="[[dataToLoad]]"
        get-data-load-name="[[_getDataLoadName]]"
        get-data-load-url="[[getDataLoadUrl]]"
        request-data="[[requestData]]"
        ignore-y-outliers="[[ignoreYOutliers]]"
        load-data-callback="[[_loadDataCallback]]"
        load-key="[[tag]]"
        log-scale-active="[[_logScaleActive]]"
        request-manager="[[requestManager]]"
        smoothing-enabled="[[smoothingEnabled]]"
        smoothing-weight="[[smoothingWeight]]"
        tag-metadata="[[tagMetadata]]"
        tooltip-columns="[[_tooltipColumns]]"
        tooltip-position="auto"
        tooltip-sorting-method="[[tooltipSortingMethod]]"
        x-type="[[xType]]"
      >
      </tf-line-chart-data-loader>
    </div>
    <div id="buttons">
      <paper-icon-button
        selected$="[[_expanded]]"
        icon="fullscreen"
        on-tap="_toggleExpanded"
      ></paper-icon-button>
      <paper-icon-button
        selected$="[[_logScaleActive]]"
        icon="line-weight"
        on-tap="_toggleLogScale"
        title="Toggle y-axis log scale"
      ></paper-icon-button>
      <paper-icon-button
        icon="settings-overscan"
        on-tap="_resetDomain"
        title="Fit domain to data"
      ></paper-icon-button>
      <template is="dom-if" if="[[showDownloadLinks]]">
        <paper-menu-button on-paper-dropdown-open="_updateDownloadLink">
          <paper-icon-button
            class="dropdown-trigger"
            slot="dropdown-trigger"
            icon="file-download"
          ></paper-icon-button>
          <paper-listbox class="dropdown-content" slot="dropdown-content">
            <paper-item>
              <a id="svgLink" download="[[tag]].svg">
                Download Current Chart as SVG
              </a>
            </paper-item>
          </paper-listbox>
        </paper-menu-button>
      </template>
      <span style="flex-grow: 1"></span>
      <template is="dom-if" if="[[showDownloadLinks]]">
        <div class="download-links">
          <tf-downloader
            runs="[[_runsFromData(dataToLoad)]]"
            tag="[[tag]]"
            url-fn="[[_downloadUrlFn]]"
          ></tf-downloader>
        </div>
      </template>
    </div>
    <style>
      :host {
        margin: 5px;
        display: block;
        width: 330px;
      }

      :host([_expanded]) {
        width: 100%;
      }

      :host([_expanded]) #tf-line-chart-data-loader-container {
        height: 400px;
      }

      #tf-line-chart-data-loader-container {
        height: 200px;
        width: 100%;
      }

      tf-card-heading {
        display: block;
        margin-bottom: 10px;
      }

      #buttons {
        display: flex;
        flex-direction: row;
      }

      paper-icon-button {
        color: #2196f3;
        border-radius: 100%;
        width: 32px;
        height: 32px;
        padding: 4px;
      }

      paper-icon-button[selected] {
        background: var(--tb-ui-light-accent);
      }

      .download-links {
        display: flex;
        height: 32px;
      }

      .download-links a {
        align-self: center;
        font-size: 10px;
        margin: 2px;
      }

      .download-links paper-dropdown-menu {
        width: 100px;
        --paper-input-container-label: {
          font-size: 10px;
        }
        --paper-input-container-input: {
          font-size: 10px;
        }
      }

      paper-menu-button {
        padding: 0;
      }
      paper-item a {
        color: inherit;
        text-decoration: none;
        white-space: nowrap;
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],Gn.prototype,"tag",void 0);E([A({type:Array}),w("design:type",Array)],Gn.prototype,"dataToLoad",void 0);E([A({type:String}),w("design:type",String)],Gn.prototype,"xType",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Gn.prototype,"active",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Gn.prototype,"ignoreYOutliers",void 0);E([A({type:Object}),w("design:type",Ae)],Gn.prototype,"requestManager",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Gn.prototype,"showDownLinks",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Gn.prototype,"smoothingEnabled",void 0);E([A({type:Number}),w("design:type",Number)],Gn.prototype,"smoothingWeight",void 0);E([A({type:Object}),w("design:type",Object)],Gn.prototype,"tagMetadata",void 0);E([A({type:Object}),w("design:type",Object)],Gn.prototype,"colorScale",void 0);E([A({type:String}),w("design:type",String)],Gn.prototype,"tooltipSortingMethod",void 0);E([A({type:Number}),w("design:type",Number)],Gn.prototype,"batchSize",void 0);E([A({type:Boolean}),w("design:type",Number)],Gn.prototype,"inColab",void 0);E([A({type:Object}),w("design:type",Object)],Gn.prototype,"_loadDataCallback",void 0);E([A({type:Object}),w("design:type",Function)],Gn.prototype,"getDataLoadUrl",void 0);E([A({type:Object}),w("design:type",Object)],Gn.prototype,"_downloadUrlFn",void 0);E([A({type:Object}),w("design:type",Function)],Gn.prototype,"requestData",void 0);E([A({type:Object}),w("design:type",Object)],Gn.prototype,"_getDataLoadName",void 0);E([A({type:Boolean,reflectToAttribute:!0}),w("design:type",Boolean)],Gn.prototype,"_expanded",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Gn.prototype,"_logScaleActive",void 0);E([A({type:Array}),w("design:type",Array)],Gn.prototype,"_tooltipColumns",void 0);Gn=E([yt("tf-scalar-card")],Gn);var Vs=class extends fue([cW],mt){constructor(){super(...arguments),this.sessionGroup=null,this._xType=Ed.STEP,this._noMultiExperiments=!1,this._requestData=(t,r,n)=>{Promise.all(t.map(i=>{let o={experimentName:this.experimentName,sessionName:i.run,metricName:i.tag};return this.backend.listMetricEvals(o).then(a=>void r({item:i,data:a}))})).finally(()=>void n())},this._colorScale={scale:t=>{let r=JSON.parse(t)[1],n=this._indexOfSession.get(r),i=iR;return i[(this._sessionGroupNameHash+n)%i.length]}}}connectedCallback(){super.connectedCallback(),this.addEventListener("iron-resize",this.redraw.bind(this))}redraw(){var t;(t=this.shadowRoot)==null||t.querySelectorAll("tf-scalar-card").forEach(r=>{r.redraw()})}_sessionGroupChanged(){var t;!this.sessionGroup||Object.keys(this.sessionGroup).length==0?(this._indexOfSession=new Map,this._sessionGroupNameHash=0):(this._indexOfSession=new Map(this.sessionGroup.sessions.map((r,n)=>[r.name,n])),this._sessionGroupNameHash=dct(this.sessionGroup.name)),(t=this.shadowRoot)==null||t.querySelectorAll("tf-scalar-card").forEach(r=>{let n=r,i=n.get("tag");n.set("tag",""),n.set("tag",i)})}_haveMetrics(){return this.visibleSchema&&Array.isArray(this.visibleSchema.metricInfos)&&this.visibleSchema.metricInfos.length>0}_haveMetricsAndSessionGroup(){return this.sessionGroup&&this._haveMetrics()}_computeSeriesForSessionGroupMetric(t,r){return t===null||Object.keys(t).length==0||r===null?[]:t.sessions.filter(n=>f3(n.metricValues,r.name)!==void 0).map(n=>({tag:r.name,run:n.name}))}_computeTagMetadata(t){return{displayName:Qu(t),description:t.description||""}}};Vs.template=Q`
    <template is="dom-if" if="[[!sessionGroup]]">
      <div>
        <h3>No session group selected</h3>
        <p>Please select a session group to see its metric-graphs here.</p>
      </div>
    </template>
    <template is="dom-if" if="[[!_haveMetrics(visibleSchema.*)]]">
      <div>
        <h3>No metrics are enabled</h3>
        <p>Please enable some metrics to see content here.</p>
      </div>
    </template>
    <div class="layout horizontal wrap session-group-details">
      <template
        is="dom-if"
        if="[[_haveMetricsAndSessionGroup(visibleSchema.*, sessionGroup)]]"
      >
        <template
          is="dom-repeat"
          items="[[visibleSchema.metricInfos]]"
          as="metricInfo"
        >
          <!-- Note that we do not provide a request-manager attribute since
               we provide a function in request-data for calling the backend
               to get the metrics data.
            -->
          <tf-scalar-card
            class="scalar-card"
            color-scale="[[_colorScale]]"
            data-to-load="[[_computeSeriesForSessionGroupMetric(sessionGroup, metricInfo)]]"
            tag="[[metricInfo.name.tag]]"
            tag-metadata="[[_computeTagMetadata(metricInfo)]]"
            x-type="[[_xType]]"
            multi-experiments="[[_noMultiExperiments]]"
            request-data="[[_requestData]]"
            active
          >
          </tf-scalar-card>
        </template>
      </template>
    </div>
    <!-- "iron-flex" is needed to use the layout classes in the div above -->
    <style include="iron-flex">
      :host {
        display: block;
      }
    </style>
  `;E([A({type:Object}),w("design:type",Object)],Vs.prototype,"backend",void 0);E([A({type:String}),w("design:type",String)],Vs.prototype,"experimentName",void 0);E([A({type:Object}),w("design:type",Object)],Vs.prototype,"visibleSchema",void 0);E([A({type:Object}),w("design:type",Object)],Vs.prototype,"sessionGroup",void 0);E([A({type:String}),w("design:type",String)],Vs.prototype,"_xType",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Vs.prototype,"_noMultiExperiments",void 0);E([A({type:Object}),w("design:type",Object)],Vs.prototype,"_indexOfSession",void 0);E([A({type:Number}),w("design:type",Number)],Vs.prototype,"_sessionGroupNameHash",void 0);E([A({type:Object}),w("design:type",Function)],Vs.prototype,"_requestData",void 0);E([A({type:Object}),w("design:type",Object)],Vs.prototype,"_colorScale",void 0);E([Bt("sessionGroup.*"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Vs.prototype,"_sessionGroupChanged",null);Vs=E([yt("tf-hparams-session-group-details")],Vs);var Hd=class extends Gt(_o(mt)){constructor(){super(...arguments),this._hparamName=Fd,this._metricName=Qu}_visibleSchemaOrSessionGroupsChanged(){let t=this.$.sessionGroupsTable.get("detailsOpenedItems");this.$.sessionGroupsTable.set("detailsOpenedItems",[]),ci();let r=new Map;this.sessionGroups.forEach(n=>{r.set(n.name,n)}),this.$.sessionGroupsTable.set("detailsOpenedItems",t.map(n=>r.get(n.name)).filter(Boolean))}_sessionGroupHParam(t,r){return t==null||Object.keys(t).length==0||!Object.prototype.hasOwnProperty.call(t.hparams,r)?"":b0(t.hparams[r])}_sessionGroupMetric(t,r){if(t==null||Object.keys(t).length==0)return"";for(let n=0;n<t.metricValues.length;++n){let i=t.metricValues[n];if(i.name.group===r.group&&i.name.tag==r.tag)return b0(i.value)}return""}_rowNumber(t){return t+1}};Hd.template=Q`
    <vaadin-grid
      class="session-group-table"
      id="sessionGroupsTable"
      column-reordering-allowed=""
      items="[[sessionGroups]]"
    >
      <vaadin-grid-column flex-grow="0" width="10em" resizable="">
        <template class="header">
          <div class="table-header table-cell">Trial ID</div>
        </template>
        <template>
          <div class="table-cell">[[item.name]]</div>
        </template>
      </vaadin-grid-column>
      <template is="dom-if" if="[[enableShowMetrics]]">
        <vaadin-grid-column flex-grow="0" autoWidth="" resizable="">
          <template class="header">
            <div class="table-header table-cell">Show Metrics</div>
          </template>
          <template>
            <paper-checkbox class="table-cell" checked="{{detailsOpened}}">
            </paper-checkbox>
          </template>
        </vaadin-grid-column>
      </template>
      <template
        is="dom-repeat"
        items="[[visibleSchema.hparamInfos]]"
        as="hparamInfo"
        index-as="hparamIndex"
      >
        <vaadin-grid-column flex-grow="2" width="10em" resizable="">
          <template class="header">
            <div class="table-header table-cell">
              [[_hparamName(hparamInfo)]]
            </div>
          </template>
          <template>
            <div class="table-cell">
              [[_sessionGroupHParam(item, hparamInfo.name)]]
            </div>
          </template>
        </vaadin-grid-column>
      </template>
      <template
        is="dom-repeat"
        items="{{visibleSchema.metricInfos}}"
        as="metricInfo"
        index-as="metricIndex"
      >
        <vaadin-grid-column flex-grow="2" width="10em" resizable="">
          <template class="header">
            <div class="table-header table-cell">
              [[_metricName(metricInfo)]]
            </div>
          </template>
          <template>
            <div class="table-cell">
              [[_sessionGroupMetric(item, metricInfo.name)]]
            </div>
          </template>
        </vaadin-grid-column>
      </template>
      <template class="row-details">
        <tf-hparams-session-group-details
          backend="[[backend]]"
          experiment-name="[[experimentName]]"
          session-group="[[item]]"
          visible-schema="[[visibleSchema]]"
          class="session-group-details"
        >
        </tf-hparams-session-group-details>
      </template>
    </vaadin-grid>

    <style>
      :host {
        display: inline;
      }

      :host(.dark-mode) {
        --lumo-base-color: #303030;
        --lumo-body-text-color: #fff;
      }

      :host(.dark-mode) vaadin-grid {
        --_lumo-grid-secondary-border-color: #505050;
      }

      .table-cell {
        white-space: nowrap;
        text-overflow: ellipsis;
        overflow: hidden;
      }
      .table-header {
        /* line-break overflowing column headers */
        white-space: normal;
        overflow-wrap: break-word;
      }
      .session-group-table {
        height: 100%;
      }
      .session-group-details {
        height: 360px;
        overflow-y: auto;
      }
    </style>
  `;E([A({type:Object}),w("design:type",Object)],Hd.prototype,"visibleSchema",void 0);E([A({type:Array}),w("design:type",Array)],Hd.prototype,"sessionGroups",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Hd.prototype,"enableShowMetrics",void 0);E([A({type:Object}),w("design:type",Object)],Hd.prototype,"backend",void 0);E([A({type:String}),w("design:type",String)],Hd.prototype,"experimentName",void 0);E([Bt("visibleSchema.*","sessionGroups.*"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Hd.prototype,"_visibleSchemaOrSessionGroupsChanged",null);Hd=E([yt("tf-hparams-table-view")],Hd);var CP=class extends mt{constructor(){super(...arguments),this.sessionGroup=null,this.visibleSchema=null}_propertiesArePopulated(t,r){return t!=null&&r!==void 0&&r!==null}_singletonSessionGroups(t){return t==null?[]:[t]}};CP.template=Q`
    <!-- If sessionGroup or visibleSchema are not populated, do not display
         anything.
      -->
    <template
      is="dom-if"
      if="[[_propertiesArePopulated(visibleSchema, sessionGroup)]]"
    >
      <!-- Display one row without a "show-metrics" column -->
      <tf-hparams-table-view
        visible-schema="[[visibleSchema]]"
        session-groups="[[_singletonSessionGroups(sessionGroup)]]"
      >
      </tf-hparams-table-view>
    </template>
    <template
      is="dom-if"
      if="[[!_propertiesArePopulated(visibleSchema, sessionGroup)]]"
    >
      <div>Click or hover over a session group to display its values here.</div>
    </template>

    <style>
      :host {
        display: block;
      }
    </style>
  `;E([A({type:Object}),w("design:type",Object)],CP.prototype,"sessionGroup",void 0);E([A({type:Object}),w("design:type",Object)],CP.prototype,"visibleSchema",void 0);CP=E([yt("tf-hparams-session-group-values")],CP);var AP=Ee(Oe(),1);function pue(e,t,r,n){if(t.length<2)return console.error("Less than two axes in parallel coordinates plot."),null;let i=r[0],o=r[1];if(i<=t[0]||i>=t[t.length-1])return null;let a=AP.sortedIndex(t,i);console.assert(a>0),console.assert(a<t.length);let s=a-1;function l(h,f,p,d){let g=h-p,_=f-d,y=i-p,x=o-d,b=(g*y+_*x)/(g*g+_*_);if(b<=0)return p3(y,x);if(b>=1){let S=h-i,C=f-o;return p3(S,C)}return p3(y-b*g,x-b*_)}let c=null,u=null;return e.forEach(h=>{let f=l(h.controlPoints[s][0],h.controlPoints[s][1],h.controlPoints[a][0],h.controlPoints[a][1]);f>n||(c===null||f<c)&&(c=f,u=h)}),u}function due(e,t,r){return e.domain().filter(n=>{let i=e(n);return t<=i&&i<=r})}function mue(e,t,r){let n=e.range(),i=n.filter(o=>t<=o&&o<=r).map(o=>{let a=e.invertExtent(o);return o===n[n.length-1]?[a[0],a[1]+1]:a});return i.length==0?[0,0]:aa(Im(i))}function gue(e,t,r){return[e.invert(t),e.invert(r)].sort((n,i)=>n-i)}function Fct(e,t,r){function n(){if(e.length===0)return[1,2];let[i,o]=aa(e);return i!==o?[i,o]:i>0?[i*.5,i*1.5]:i<0?[i*1.5,i*.5]:[-1,1]}if(r==="LINEAR")return On().domain(n()).range([t,0]);if(r==="LOG"){let i=n();return i[0]<=0&&i[1]>=0?Fct(e,t,"LINEAR"):cc().domain(i).range([t,0])}else if(r==="QUANTILE"){let o=Ir(20).map(a=>t-a*t/19);return e.length===0&&(e=[1]),eg().domain(AP.uniq(e)).range(o)}else{if(r==="NON_NUMERIC")return tg().domain(AP.uniq(e.sort())).range([t,0]).padding(.1);throw RangeError("Unknown scale: "+r)}}var u1;(function(e){e.LINEAR="LINEAR",e.LOG="LOG",e.QUANTILE="QUANTILE",e.NON_NUMERIC="NON_NUMERIC"})(u1||(u1={}));var PP=class{isPassing(t){return!0}},nV=class{constructor(t,r,n,i){this._lower=t,this._upper=r,this._lowerOpen=n,this._upperOpen=i}isPassing(t){let r=t;return this._before(this._lower,r,!this._lowerOpen)&&this._before(r,this._upper,!this._upperOpen)}_before(t,r,n){return n?t<=r:t<r}},Hct=class{constructor(t){this._domainSet=t}isPassing(t){return this._domainSet.findIndex(r=>r===t)!==-1}},Vct=class{constructor(t,r,n,i){this._svgProps=t,this._schema=r,this._interactionManager=n,this._colIndex=i,this._isDisplayed=!1,this._yScale=null,this._scaleType=null,this.setBrushSelection(null)}colIndex(){return this._colIndex}yScale(){return this._yScale}scaleType(){return this._scaleType}brushSelection(){return this._brushSelection}isDisplayed(){return this._isDisplayed}setBrushSelection(t){this._brushSelection=t,this._brushFilter=this._buildBrushFilter(this.brushSelection(),this.scaleType(),this.yScale())}setDomainAndScale(t,r){this._scaleType=r,this._yScale=Fct(t.slice(),this._svgProps.height,this.scaleType()),this._brushFilter=this._buildBrushFilter(this.brushSelection(),this.scaleType(),this.yScale())}brushFilter(){return this._brushFilter}updateDOM(t){let r=lb(this.yScale());this.scaleType()===u1.QUANTILE&&(r=r.tickValues(this.yScale().quantiles()).tickFormat(xn("-.6g")));let n=Ht(t);n.selectAll("g").remove(),n.append("g").classed("axis",!0).call(r).append("text").classed("axis-title",!0).style("cursor","move").style("text-anchor","middle").attr("y",-9).text(a=>cct(this._schema,a)),n.call(pb().on("start",()=>{t.setAttribute("is-dragging",""),this._interactionManager.onDragStart(this.colIndex())}).on("drag",()=>this._interactionManager.onDrag(qt.x)).on("end",()=>{this._interactionManager.onDragEnd(),t.removeAttribute("is-dragging")}));let i=qL().extent([[-8,0],[8,this._svgProps.height+1]]).on("start",()=>{!Bct(qt)||(t.setAttribute("is-brushing",""),this._interactionManager.onBrushChanged(this.colIndex(),qt.selection))}).on("brush",()=>{!Bct(qt)||this._interactionManager.onBrushChanged(this.colIndex(),qt.selection)}).on("end",()=>{!Bct(qt)||(this._interactionManager.onBrushChanged(this.colIndex(),qt.selection),t.removeAttribute("is-brushing"))}),o=Ht(t).append("g").classed("brush",!0);o.call(i),i.move(o,this.brushSelection())}setDisplayed(t){this._isDisplayed=t}_buildBrushFilter(t,r,n){if(t===null)return new PP;if(r===null)return console.error("Scale type is null, but brushSelection isn't: ",t),new PP;switch(r){case u1.LINEAR:case u1.LOG:{let[i,o]=gue(n,t[0],t[1]);return new nV(i,o,!1,!1)}case u1.QUANTILE:{let[i,o]=mue(n,t[0],t[1]);return new nV(i,o,!1,!0)}case u1.NON_NUMERIC:return new Hct(due(n,t[0],t[1]))}return console.error("Unknown scale type: ",r),new PP}},iV=class{constructor(t,r,n){this._svgProps=t,this._schema=r,this._axes=this._createAxes(n),this._stationaryAxesPositions=tg().range([1,this._svgProps.width-1]).padding(.5),this._draggedAxis=null,this._svgProps.svgG.selectAll("g.axis-parent").remove(),this._parentsSel=this._svgProps.svgG.selectAll(".axis-parent")}updateAxes(t,r){console.assert(!this.isAxisDragging());let n=new Set;t.columns.forEach(o=>{let a=o.absoluteIndex,s=this._axes[a];s.setDisplayed(!0);let l=r.map(c=>x0(this._schema,c,a));s.setDomainAndScale(l,o.scale),n.add(a)}),this._axes.forEach(o=>{n.has(o.colIndex())||o.setDisplayed(!1)}),this._updateStationaryAxesPositions(n),this._parentsSel=this._parentsSel.data(Array.from(n),o=>o),this._parentsSel.exit().remove(),this._parentsSel=this._parentsSel.enter().append("g").classed("axis-parent",!0).merge(this._parentsSel);let i=this;this._parentsSel.call(o=>this._updateAxesPositionsInDOM(o)).each(function(o){i._axes[o].updateDOM(this)})}mapVisibleAxes(t){return this._stationaryAxesPositions.domain().map(r=>t(this.getAxisPosition(r),this._axes[r]))}allVisibleAxesSatisfy(t){return this._stationaryAxesPositions.domain().every(r=>t(this.getAxisPosition(r),this._axes[r]))}getAxisForColIndex(t){return this._axes[t]}dragStart(t){console.assert(!this.isAxisDragging()),console.assert(this._axes[t].isDisplayed()),this._draggedAxis=this._axes[t],this._draggedAxisPosition=this._stationaryAxesPositions(t)}drag(t){t=Math.min(Math.max(t,0),this._svgProps.width),this._draggedAxisPosition=t;let r=this._stationaryAxesPositions.domain();r.sort((n,i)=>this.getAxisPosition(n)-this.getAxisPosition(i)),this._stationaryAxesPositions.domain(r),this._updateAxesPositionsInDOM(this._parentsSel)}dragEnd(t){console.assert(this.isAxisDragging()),this._draggedAxisPosition=null,this._draggedAxis=null,this._updateAxesPositionsInDOM(this._parentsSel.transition().duration(t))}isAxisDragging(){return this._draggedAxis!==null}getAxisPosition(t){return this._draggedAxis!==null&&this._draggedAxis.colIndex()===t?this._draggedAxisPosition:this._stationaryAxesPositions(t)}_updateStationaryAxesPositions(t){let r=this._stationaryAxesPositions.domain().filter(i=>t.has(i)),n=Array.from(new Set([...r,...Array.from(t)]));this._stationaryAxesPositions.domain(n)}_updateAxesPositionsInDOM(t){t.attr("transform",r=>yP(this.getAxisPosition(r)))}_createAxes(t){return Ir(uct(this._schema)).map(r=>new Vct(this._svgProps,this._schema,t,r))}};function Bct(e){return e.sourceEvent!==null}var jf;(function(e){e[e.FOREGROUND=0]="FOREGROUND",e[e.BACKGROUND=1]="BACKGROUND"})(jf||(jf={}));var th=class{constructor(t){t===void 0&&(t=Ep(null)),console.assert(t.size()<=1),this._sessionGroupSel=t}sessionGroup(){return this._sessionGroupSel.size()===1?this._sessionGroupSel.datum():null}isNull(){return this.sessionGroup()===null}selection(){return this._sessionGroupSel}equalsTo(t){var r,n;return this.isNull()?t.isNull():t.isNull()?!1:((r=t.sessionGroup())==null?void 0:r.name)==((n=this.sessionGroup())==null?void 0:n.name)}},oV=class{constructor(t,r,n){this._svgProps=t,this._schema=r,this._axesCollection=n,this._sessionGroups=[],this._svgProps.svgG.selectAll("g.background").remove(),this._svgProps.svgG.selectAll("g.foreground").remove(),this._bgPathsSel=this._svgProps.svgG.append("g").classed("background",!0).selectAll("path"),this._fgPathsSel=this._svgProps.svgG.append("g").classed("foreground",!0).selectAll("path"),this._updateVisibleFgPathsSel(),this._peakedSessionGroupHandle=new th,this._selectedSessionGroupHandle=new th,this._d3line=vu().curve(Yh)}getSessionGroupHandle(t){return t==null?new th:new th(this._fgPathsSel.filter(r=>r.name===t.name))}hideBackgroundLines(){this._bgPathsSel.attr("visibility","hidden")}showBackgroundLines(){this._bgPathsSel.attr("visibility",null)}peakedSessionGroupHandle(){return this._peakedSessionGroupHandle}selectedSessionGroupHandle(){return this._selectedSessionGroupHandle}recomputeControlPoints(t,r=0){(t===jf.FOREGROUND?this._fgPathsSel:this._bgPathsSel).transition().duration(r).attr("d",i=>this._pathDAttribute(i)),t===jf.FOREGROUND&&window.setTimeout(()=>{let i=this;this._fgPathsSel.each(function(o){i._setControlPointsProperty(this,o)})})}recomputeForegroundLinesVisibility(){this._fgPathsSel.classed("invisible-path",t=>!this._axesCollection.allVisibleAxesSatisfy((r,n)=>n.brushFilter().isPassing(x0(this._schema,t,n.colIndex())))),this._updateVisibleFgPathsSel()}setForegroundLinesColor(t,r,n){let i=this._createLineColorFunction(t,r,n);this._fgPathsSel.attr("stroke",i)}redraw(t,r,n,i){let o=this._peakedSessionGroupHandle.sessionGroup(),a=this._selectedSessionGroupHandle.sessionGroup();this._sessionGroups=t,this._fgPathsSel=this._recomputePathSelection(this._fgPathsSel),this._bgPathsSel=this._recomputePathSelection(this._bgPathsSel),this._peakedSessionGroupHandle=this.getSessionGroupHandle(o),this._selectedSessionGroupHandle=this.getSessionGroupHandle(a),this.recomputeControlPoints(jf.FOREGROUND),this.recomputeControlPoints(jf.BACKGROUND),this.recomputeForegroundLinesVisibility(),this.setForegroundLinesColor(r,n,i)}updatePeakedSessionGroup(t){this._peakedSessionGroupHandle.selection().classed("peaked-path",!1),this._peakedSessionGroupHandle=t,this._peakedSessionGroupHandle.selection().classed("peaked-path",!0)}clearPeakedSessionGroup(){this.updatePeakedSessionGroup(new th)}updateSelectedSessionGroup(t){this._selectedSessionGroupHandle.selection().classed("selected-path",!1),this._selectedSessionGroupHandle=t,this._selectedSessionGroupHandle.selection().classed("selected-path",!0)}findClosestSessionGroup(t,r){let n=this._axesCollection.mapVisibleAxes((o,a)=>o),i=pue(this._visibleFgPathsSel.nodes(),n,[t,r],100);return i===null?new th:new th(Ht(i))}_createLineColorFunction(t,r,n){if(t===null)return()=>"red";let i=On().domain(hct(this._schema,this._sessionGroups,t)).range([r,n]).interpolate(M_);return o=>i(x0(this._schema,o,t))}_recomputePathSelection(t){return t=t.data(this._sessionGroups,r=>r.name),t.exit().remove(),t.enter().append("path").merge(t)}_setControlPointsProperty(t,r){t.controlPoints=this._computeControlPoints(r)}_computeControlPoints(t){return this._axesCollection.mapVisibleAxes((r,n)=>[r,n.yScale()(x0(this._schema,t,n.colIndex()))])}_pathDAttribute(t){return this._d3line(this._computeControlPoints(t))}_updateVisibleFgPathsSel(){this._visibleFgPathsSel=this._fgPathsSel.filter(":not(.invisible-path)")}};var aV=class{constructor(t,r){this.svg=Ht(t);let n={top:30,right:10,bottom:10,left:10},i=100,o=200,a=r*i+n.left+n.right,s=o+n.top+n.bottom;this.svg.attr("viewBox",`0 0 ${a} ${s}`),this.svg.attr("preserveAspectRatio","xMidYMid"),this.svg.style("min-width",a+"px"),this.svg.style("min-height",s+"px"),this.width=a-n.left-n.right,this.height=s-n.top-n.bottom,this.svgG=this.svg.append("g").attr("transform",yP(n.left,n.top))}},sV=class{constructor(t,r,n,i){this._svgProps=t,this._schema=r,this._peakedSessionGroupChangedCB=n,this._selectedSessionGroupChangedCB=i,this._axesCollection=new iV(t,r,this),this._linesCollection=new oV(t,r,this._axesCollection),this._svgProps.svg.on("click",()=>this.onClick()).on("mousemove mouseenter",()=>{let[o,a]=zo(this._svgProps.svgG.node());this.onMouseMoved(o,a)}).on("mouseleave",()=>this.onMouseLeave())}onDragStart(t){this._axesCollection.dragStart(t),this._linesCollection.hideBackgroundLines()}onDrag(t){this._axesCollection.drag(t),this._linesCollection.recomputeControlPoints(jf.FOREGROUND)}onDragEnd(){this._axesCollection.dragEnd(500),this._linesCollection.recomputeControlPoints(jf.FOREGROUND,500),window.setTimeout(()=>{this._linesCollection.recomputeControlPoints(jf.BACKGROUND),this._linesCollection.showBackgroundLines()},500)}onBrushChanged(t,r){this._axesCollection.getAxisForColIndex(t).setBrushSelection(r),this._linesCollection.recomputeForegroundLinesVisibility()}onMouseMoved(t,r){this._linesCollection.updatePeakedSessionGroup(this._linesCollection.findClosestSessionGroup(t,r)),this._peakedSessionGroupChangedCB(this._linesCollection.peakedSessionGroupHandle().sessionGroup())}onMouseLeave(){this._linesCollection.peakedSessionGroupHandle().isNull()||(this._linesCollection.clearPeakedSessionGroup(),this._peakedSessionGroupChangedCB(null))}onClick(){this._linesCollection.peakedSessionGroupHandle().sessionGroup()===this._linesCollection.selectedSessionGroupHandle().sessionGroup()?this._linesCollection.updateSelectedSessionGroup(new th):this._linesCollection.updateSelectedSessionGroup(this._linesCollection.peakedSessionGroupHandle()),this._selectedSessionGroupChangedCB(this._linesCollection.selectedSessionGroupHandle().sessionGroup())}onOptionsOrSessionGroupsChanged(t,r){this._axesCollection.updateAxes(t,r);let n=this._linesCollection.peakedSessionGroupHandle(),i=this._linesCollection.selectedSessionGroupHandle();this._linesCollection.redraw(r,t.colorByColumnIndex!==void 0?t.columns[t.colorByColumnIndex].absoluteIndex:null,t.minColor,t.maxColor),n.equalsTo(this._linesCollection.peakedSessionGroupHandle())||this._peakedSessionGroupChangedCB(this._linesCollection.peakedSessionGroupHandle().sessionGroup()),i.equalsTo(this._linesCollection.selectedSessionGroupHandle())||this._selectedSessionGroupChangedCB(this._linesCollection.selectedSessionGroupHandle().sessionGroup())}schema(){return this._schema}};var eh=class extends Gt(_o(mt)){constructor(){super(...arguments),this.selectedSessionGroup=null,this.closestSessionGroup=null,this.redrawCount=0}_optionsOrSessionGroupsChanged(){var n;if(!this.options)return;let{configuration:t}=(n=this._prevOptions)!=null?n:{},{configuration:r}=this.options;if(this._interactionManager===void 0||!Uct.isEqual(t==null?void 0:t.schema,r.schema)||!Uct.isEqual(t==null?void 0:t.columnsVisibility,r.columnsVisibility)){Ht(this.$.svg).selectAll("*").remove();let i=new aV(this.$.svg,r.columnsVisibility.filter(Boolean).length);this.scopeSubtree(this.$.svg,!0),this._interactionManager=new sV(i,r.schema,o=>this.closestSessionGroupChanged(o),o=>this.selectedSessionGroupChanged(o))}this._computeValidSessionGroups(),this._interactionManager.onOptionsOrSessionGroupsChanged(this.options,this._validSessionGroups),this.redrawCount++,this._prevOptions=this.options}closestSessionGroupChanged(t){this.closestSessionGroup=t}selectedSessionGroupChanged(t){this.selectedSessionGroup=t}_computeValidSessionGroups(){let t=cs;if(this.sessionGroups===void 0){this._validSessionGroups=void 0;return}let r=this.options.configuration.schema;this._validSessionGroups=this.sessionGroups.filter(n=>{for(let i=0;i<t.numColumns(r);++i){if(!this.options.configuration.columnsVisibility[i])continue;let o=t.columnValueByIndex(r,n,i);if(o===void 0||o==="NaN")return!1}return!0})}};eh.template=Q`
    <div id="container">
      <svg id="svg"></svg>
    </div>
    <style>
      :host {
        display: block;
        --tf-hparams-parallel-coords-plot-axis-shadow: 0 1px 0 #fff,
          1px 0 0 #fff, 0 -1px 0 #fff, -1px 0 0 #fff;
      }
      :host(.dark-mode) {
        --tf-hparams-parallel-coords-plot-axis-shadow: 0 1px 0 #000,
          1px 0 0 #000, 0 -1px 0 #000, -1px 0 0 #000;
      }
      svg {
        font: 10px sans-serif;
      }

      .background path {
        fill: none;
        stroke: #ddd;
        shape-rendering: crispEdges;
      }

      .foreground path {
        fill: none;
        stroke-opacity: 0.7;
        stroke-width: 1;
      }

      /* Will be set on foreground paths that are not "contained" in the current
         axes brushes. If no brushes are set, no path will have this class. */
      .foreground .invisible-path {
        display: none;
      }

      /* Style for the path closest to the mouse pointer (typically will become
      the selected path when the user clicks). */
      .foreground .peaked-path {
        stroke-width: 3;
      }

      /* The currently selected path class. We use !important to override the
         inline style that sets the regular color of a path. */
      .foreground .selected-path {
        stroke-width: 3 !important;
        stroke: #0f0 !important;
      }

      #container {
        height: 100%;
        width: 100%;
      }

      svg {
        width: 100%;
        height: 100%;
      }

      .axis text {
        text-shadow: var(--tf-hparams-parallel-coords-plot-axis-shadow);
        fill: currentColor;
        cursor: move;
      }
    </style>
  `;E([A({type:Array}),w("design:type",Array)],eh.prototype,"sessionGroups",void 0);E([A({type:Object}),w("design:type",Object)],eh.prototype,"options",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],eh.prototype,"selectedSessionGroup",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],eh.prototype,"closestSessionGroup",void 0);E([A({type:Number}),w("design:type",Number)],eh.prototype,"redrawCount",void 0);E([A({type:Array}),w("design:type",Object)],eh.prototype,"_validSessionGroups",void 0);E([A({type:Object}),w("design:type",Object)],eh.prototype,"_interactionManager",void 0);E([Bt("options.*","sessionGroups.*"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],eh.prototype,"_optionsOrSessionGroupsChanged",null);eh=E([yt("tf-hparams-parallel-coords-plot")],eh);var A0=class extends mt{constructor(){super(...arguments),this.options=null}_configurationChanged(){let t=this.configuration.visibleSchema,r=this.configuration.schema,n=(a,s)=>({name:Fd(a),index:s,absoluteIndex:zH(r,t,s),scale:this._isNumericColumn(s)?"LINEAR":"NON_NUMERIC"}),i=(a,s)=>{let l=s+t.hparamInfos.length;return{scale:"LINEAR",name:Qu(a),index:l,absoluteIndex:zH(r,t,l)}},o={columns:t.hparamInfos.map(n).concat(t.metricInfos.map(i)),minColor:"#0000FF",maxColor:"#FF0000",configuration:this.configuration};this.set("options",o),ci(),this.set("options.colorByColumnIndex",this._defaultColorByColumnIndex())}_unselectDisabledLogScales(){this.options!==null&&this.options.columns.forEach(t=>{let r="options.columns."+t.index;!this._allowLogScale(t)&&t.scale==="LOG"&&this.set(r+".scale","LINEAR")})}_allowLogScale(t){if(!this._isNumericColumn(t.index)||!this.sessionGroups)return!1;let[r,n]=_P(this.configuration.visibleSchema,this.sessionGroups,t.index);return r>0||n<0}_isNumericColumn(t){return t>=this.configuration.visibleSchema.hparamInfos.length||this.configuration.visibleSchema.hparamInfos[t].type==="DATA_TYPE_FLOAT64"}_defaultColorByColumnIndex(){if(this.configuration.visibleSchema.metricInfos.length>0)return this.configuration.visibleSchema.hparamInfos.length;let t=this.configuration.visibleSchema.hparamInfos.findIndex(r=>r.type==="DATA_TYPE_FLOAT64");if(t!==-1)return t}};A0.template=Q`
    <div class="control-panel">
      <!-- 'Color by' drop down menu -->
      <paper-dropdown-menu
        label="Color by"
        id="colorByDropDownMenu"
        horizontal-align="left"
      >
        <paper-listbox
          class="dropdown-content"
          slot="dropdown-content"
          selected="{{options.colorByColumnIndex}}"
          id="colorByListBox"
        >
          <template
            is="dom-repeat"
            items="[[options.columns]]"
            as="column"
            id="colorByColumnTemplate"
          >
            <paper-item disabled="[[!_isNumericColumn(column.index)]]">
              [[column.name]]
            </paper-item>
          </template>
        </paper-listbox>
      </paper-dropdown-menu>

      <!-- Columns scales -->
      <div class="columns-container">
        <!-- Scale options for each numeric feature -->
        <template is="dom-repeat" items="{{options.columns}}" as="column">
          <template is="dom-if" if="[[_isNumericColumn(column.index)]]">
            <div class="column">
              <div class="column-title">[[column.name]]</div>
              <div>
                <paper-radio-group
                  class="scale-radio-group"
                  selected="{{column.scale}}"
                >
                  <paper-radio-button name="LINEAR">
                    Linear
                  </paper-radio-button>
                  <!-- The id here is used to access this button in unit
                       tests.-->
                  <paper-radio-button
                    id="logScaleButton_[[column.name]]"
                    name="LOG"
                    disabled="[[!_allowLogScale(column, sessionGroups.*)]]"
                  >
                    Logarithmic
                  </paper-radio-button>
                  <paper-radio-button name="QUANTILE">
                    Quantile
                  </paper-radio-button>
                </paper-radio-group>
              </div>
            </div>
          </template>
        </template>
      </div>
    </div>

    <style>
      :host {
        display: block;
      }
      .control-panel {
        overflow: auto;
      }
      .column {
        flex-grow: 1;
        flex-shrink: 1;
        margin-right: 5px;
        border: solid 1px darkgray;
        padding: 3px;
      }
      .column-title {
        /* Fit every title in one line so the radio boxes align vertically. */
        white-space: nowrap;
        text-decoration: underline;
      }
      .columns-container {
        display: flex;
        flex-direction: row;
      }
      .scale-radio-group paper-radio-button {
        padding: 2px;
        display: block;
      }
      paper-listbox {
        max-height: 15em;
      }
    </style>
  `;E([A({type:Object}),w("design:type",Object)],A0.prototype,"configuration",void 0);E([A({type:Array}),w("design:type",Array)],A0.prototype,"sessionGroups",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],A0.prototype,"options",void 0);E([Bt("configuration.*"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],A0.prototype,"_configurationChanged",null);E([Bt("sessionGroups.*"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],A0.prototype,"_unselectDisabledLogScales",null);A0=E([yt("tf-hparams-scale-and-color-controls")],A0);var h1=class extends mt{_closestOrSelected(t,r){return t!==null?t:r}};h1.template=Q`
    <!-- Controls behavior of parallel coordinates plot
         outputs set options to the _options property.
      -->
    <hparams-split-layout orientation="vertical">
      <!-- The scale and color controls. -->
      <tf-hparams-scale-and-color-controls
        id="controls"
        slot="content"
        class="section"
        configuration="[[configuration]]"
        session-groups="[[sessionGroups]]"
        options="{{_options}}"
      >
      </tf-hparams-scale-and-color-controls>
      <!-- The actual parallel coordinates plot -->
      <tf-hparams-parallel-coords-plot
        id="plot"
        slot="content"
        class="section"
        session-groups="[[sessionGroups]]"
        selected-session-group="{{_selectedGroup}}"
        closest-session-group="{{_closestGroup}}"
        options="[[_options]]"
      >
      </tf-hparams-parallel-coords-plot>
      <tf-hparams-session-group-values
        id="values"
        slot="content"
        class="section"
        visible-schema="[[configuration.visibleSchema]]"
        session-group="[[_closestOrSelected(
                             _closestGroup, _selectedGroup)]]"
      >
      </tf-hparams-session-group-values>
      <tf-hparams-session-group-details
        id="details"
        slot="content"
        class="section"
        backend="[[backend]]"
        experiment-name="[[experimentName]]"
        session-group="[[_selectedGroup]]"
        visible-schema="[[configuration.visibleSchema]]"
      >
      </tf-hparams-session-group-details>
    </hparams-split-layout>

    <style>
      .section {
        padding: 10px;
      }
      #values {
        height: 115px;
      }
      #details {
        flex-grow: 1;
        max-height: fit-content;
      }
    </style>
  `;E([A({type:Object}),w("design:type",Object)],h1.prototype,"backend",void 0);E([A({type:String}),w("design:type",String)],h1.prototype,"experimentName",void 0);E([A({type:Object}),w("design:type",Object)],h1.prototype,"configuration",void 0);E([A({type:Array}),w("design:type",Array)],h1.prototype,"sessionGroups",void 0);h1=E([yt("tf-hparams-parallel-coords-view")],h1);var y3=Ee(Oe(),1);var $o=class extends Gt(mt){constructor(){super(...arguments),this.selectedSessionGroup=null,this.closestSessionGroup=null,this._container=null,this._svg=null,this.width=0,this.height=0,this._brushedCellIndex=null,this._brushSelection=null}ready(){super.ready(),this._container=this.$.container,this._svg=Ht(this.$.svg),this._redraw()}_sessionGroupsChanged(){this.selectedSessionGroup!==null&&(this.selectedSessionGroup=fct(this.sessionGroups,this.selectedSessionGroup.name)||null),this._redraw()}_visibleSchemaChanged(){this._brushedCellIndex=null,this._brushSelection=null,this._redraw()}_redraw(){this.debounce("_redraw",()=>{let t=cs,r=1200,n=.4*r,i=150,o=.75*i;this.width=Math.max(i*t.numVisibleColumns(this.visibleSchema),r),this.height=Math.max(o*t.numVisibleMetrics(this.visibleSchema),n),this._container.style.width=this.width+"px",this._container.style.height=this.height+"px",this._svg.attr("width",this.width).attr("height",this.height),this._svg.selectAll("g").remove(),this._draw()},100)}_draw(){let t=cs,r=this;if(!this.sessionGroups||this.sessionGroups.length==0||!this.visibleSchema||this.visibleSchema.metricInfos.length==0)return;let n=Ir(t.numVisibleColumns(r.visibleSchema)),i=Ir(t.numVisibleMetrics(r.visibleSchema)),o=80,a=50,s=5,l=Qm().domain(n).range([o+s,this.width-1-s]).paddingInner(.1),c=Qm().domain(i).range([this.height-1-s-a,s]).paddingInner(.1),u=l.bandwidth(),h=c.bandwidth(),f=n.map(ct=>r._cellScale(ct,[0,u-1])),p=i.map(ct=>r._cellScale(ct+t.numVisibleHParams(r.visibleSchema),[h-1,0])),d=this._svg.selectAll(".x-axis").data(n).enter().append("g").classed("x-axis",!0).attr("transform",ct=>t.translateStr(l(ct),0));function g(ct){return"x-axis-clip-path-"+ct}function _(ct){return"x-label-clip-path-"+ct}d.append("clipPath").attr("id",g).append("rect").attr("x",-s).attr("y",0).attr("width",u+2*s).attr("height",r.height-a/2),d.append("clipPath").attr("id",_).append("rect").attr("x",0).attr("y",r.height-a/2).attr("width",u).attr("height",a/2),d.append("g").attr("clip-path",ct=>"url(#"+g(ct)+")").each(function(ct){Ht(this).call(S,Z9(f[ct]).tickSize(r.height-a),u,40,r.options.columns[ct].scale)}),d.append("g").classed("x-axis-label",!0).attr("clip-path",ct=>"url(#"+_(ct)+")").append("text").attr("text-anchor","middle").attr("x",u/2).attr("y",r.height-1-a/4).text(ct=>t.schemaVisibleColumnName(r.visibleSchema,ct)).append("title").text(ct=>t.schemaVisibleColumnName(r.visibleSchema,ct));let y=this._svg.selectAll(".y-axis").data(i).enter().append("g").classed("y-axis",!0).attr("transform",ct=>t.translateStr(r.width-1,c(ct)));function x(ct){return"y-axis-clip-path-"+ct}function b(ct){return"y-label-clip-path-"+ct}y.append("clipPath").attr("id",x).append("rect").attr("x",-(r.width-o/2-1)).attr("y",-s).attr("width",r.width-o/2).attr("height",h+2*s),y.append("clipPath").attr("id",b).append("rect").attr("x",-(r.width-1)).attr("y",0).attr("width",o/2).attr("height",h),y.append("g").attr("clip-path",ct=>"url(#"+x(ct)+")").each(function(ct){Ht(this).call(S,lb(p[ct]).tickSize(r.width-o),h,20,r.options.columns[ct+t.numVisibleHParams(r.visibleSchema)].scale)}),y.append("g").classed("y-axis-label",!0).attr("clip-path",ct=>"url(#"+b(ct)+")").append("text").attr("text-anchor","middle").attr("x",-(r.width-o/4-1)).attr("y",h/2).attr("transform",t.rotateStr(90,-(r.width-o/4-1),h/2)).text(ct=>t.metricName(r.visibleSchema.metricInfos[ct])).append("title").text(ct=>t.metricName(r.visibleSchema.metricInfos[ct]));function S(ct,X,et,dt,q){let pt=Math.floor(et/dt),ht=X.scale();if(q==="QUANTILE"){let wt=ht.quantiles(),kt=Math.ceil(wt.length/pt);wt=Ir(0,wt.length,kt).map(ie=>wt[ie]),X.tickValues(wt).tickFormat(xn("-.2g"))}(q==="LINEAR"||q==="LOG")&&X.ticks(pt),ct.call(X),ct.selectAll(".domain").remove(),ct.selectAll(".tick line").attr("stroke","#ddd")}let C=this._svg.selectAll(".cell").data(q9(n,i)).enter().append("g").classed("cell",!0).attr("transform",([ct,X])=>t.translateStr(l(ct),c(X))),P=C.append("g").classed("frame",!0).append("rect").attr("x",-s).attr("y",-s).attr("width",u+2*s).attr("height",h+2*s).attr("stroke","#000").attr("fill","none").attr("shape-rendering","crispEdges"),k=null;r.options.colorByColumnIndex!==void 0&&(k=On().domain(this._colExtent(this.options.colorByColumnIndex)).range([this.options.minColor,this.options.maxColor]).interpolate(M_));let O=r.options.colorByColumnIndex===void 0?()=>"red":({sessionGroup:ct})=>k(this._colValue(ct,r.options.colorByColumnIndex));function D(ct,X){return f[X](r._colValue(ct,X))}function B(ct,X){return p[X](r._metricValue(ct,X))}function I(ct,X){let et=ct.selectAll(".data-marker").data(([pt,ht])=>r.sessionGroups.filter(wt=>r._colValue(wt,pt)!==void 0&&r._metricValue(wt,ht)!==void 0).map(wt=>({col:pt,metric:ht,sessionGroup:wt,x:D(wt,pt),y:B(wt,ht),sessionGroupMarkers:null}))).enter().append("circle").classed("data-marker",!0).attr("cx",({x:pt})=>pt).attr("cy",({y:pt})=>pt).attr("r",2).attr("fill",X),dt=new Map;r.sessionGroups.forEach(pt=>{dt.set(pt,[])}),et.each(function(pt){var ht;(ht=dt.get(pt.sessionGroup))==null||ht.push(this)}),et.each(pt=>{let ht=dt.get(pt.sessionGroup);pt.sessionGroupMarkers=new Set(ht)});let q=n.map(pt=>i.map(ht=>et.filter(wt=>wt.col==pt&&wt.metric==ht)));return[et,q,dt]}let[L,R,F]=I(C.append("g"),O);function z(ct,X){let et=[];return R[ct][X].each(function(){et.push(this)}),zh().x(dt=>Ht(dt).datum().x).y(dt=>Ht(dt).datum().y).addAll(et)}let U=n.map(ct=>i.map(X=>z(ct,X))),W=null;bt()&&(W=C.filter(ct=>y3.isEqual(ct,r._brushedCellIndex)),console.assert(W.size()==1,W));let Z=new Set(L.nodes());rt();function rt(){let ct=new Set(L.nodes());Mt()||(ct=ot(r._brushedCellIndex,r._brushSelection)),Ep(Array.from(t.filterSet(ct,X=>!Z.has(X)))).attr("fill",O),Ep(Array.from(t.filterSet(Z,X=>!ct.has(X)))).attr("fill","#ddd"),Z=ct}function ot(ct,X){console.assert(ct!==null),console.assert(X!==null);let[et,dt]=ct,q=new Set;return t.quadTreeVisitPointsInRect(U[et][dt],X[0][0],X[0][1],X[1][0],X[1][1],pt=>{Ht(pt).datum().sessionGroupMarkers.forEach(wt=>{q.add(wt)})}),q}let st=GL().extent([[-s+1,-s+1],[u-1+s-1,h-1+s-1]]).on("start",function(){bt()&&W.node()!=this&&st.move(W,null),St(this)}).on("brush",function(){St(this)}).on("end",function(){St(this)});function St(ct){let X=UL(ct);!bt()&&X===null||bt()&&ct===W.node()&&y3.isEqual(X,r._brushSelection)||(r._brushSelection=X,X!==null?(W=Ht(ct),r._brushedCellIndex=W.datum()):(W=null,r._brushedCellIndex=null),rt())}function bt(){return r._brushedCellIndex!==null&&r._brushSelection!==null}function Mt(){return!bt()||r._brushSelection[0][0]===r._brushSelection[1][0]||r._brushSelection[0][1]===r._brushSelection[1][1]}C.call(st),bt()&&st.move(W,r._brushSelection);let lt=null,Kt=null;this.selectedSessionGroup!==null&&(Kt=Ep(F.get(this.selectedSessionGroup)).classed("selected-marker",!0)),C.on("click",function(){let ct=lt===Kt?null:lt;if(ct===Kt)return;Kt!==null&&Kt.classed("selected-marker",!1),Kt=ct,Kt!==null&&Kt.classed("selected-marker",!0);let X=Kt===null?null:Kt.datum().sessionGroup;r.selectedSessionGroup=X}).on("mousemove mouseenter",function([ct,X]){let[et,dt]=zo(this),q=_t(ct,X,et,dt,20);lt!==q&&(lt!==null&&lt.classed("closest-marker",!1),lt=q,lt!==null?(lt.classed("closest-marker",!0),r.closestSessionGroup=lt.datum().sessionGroup):r.closestSessionGroup=null)}).on("mouseleave",function([ct,X]){lt!==null&&(lt.classed("closest-marker",!1),lt=null,r.closestSessionGroup=null)});function _t(ct,X,et,dt,q){let pt=1/0,ht=null;return t.quadTreeVisitPointsInDisk(U[ct][X],et,dt,q,(wt,kt)=>{if(Z.has(wt)&&kt<pt){let ie=Ht(wt).datum();pt=kt,ht=ie.sessionGroup}}),ht===null?null:Ep(F.get(ht))}this._svg.selectAll("*").classed("tf-hparams-scatter-plot-matrix-plot",!0)}_cellScale(t,r){let n=this._colExtent(t),i=On().domain(n).range(r);if(this.options.columns[t].scale==="LINEAR")return i;if(this.options.columns[t].scale==="LOG")return n[0]<=0&&n[1]>=0?i:cc().domain(n).range(r);if(this.options.columns[t].scale==="QUANTILE"){let o=(r[1]-r[0])/19,a=Ir(20).map(s=>r[0]+o*s);return eg().domain(y3.uniq(this.sessionGroups.map(s=>this._colValue(s,t)))).range(a)}else{if(this.options.columns[t].scale==="NON_NUMERIC")return tg().domain(y3.uniq(this.sessionGroups.map(o=>this._colValue(o,t)).sort())).range(r).padding(.1);throw"Unknown scale for column: "+t+". options: "+this.options}}_colValue(t,r){return BH(this.visibleSchema,t,r)}_metricValue(t,r){return FH(this.visibleSchema,t,r)}_colExtent(t){return _P(this.visibleSchema,this.sessionGroups,t)}};$o.template=Q`
    <div id="container">
      <svg id="svg"></svg>
    </div>

    <style>
      :host {
        display: block;
      }
      svg {
        font: 10px sans-serif;
      }

      text {
        fill: currentColor;
      }

      .frame rect {
        stroke: currentColor;
      }

      /* The closest data point marker to the mouse pointer. We use !important
         to override the inline style that sets the regular style of a marker.
      */
      .closest-marker {
        r: 6 !important;
      }

      /* The currently selected data point marker. We use !important to
         override the inline style that sets the regular style of a marker. */
      .selected-marker {
        r: 6 !important;
        fill: #0f0 !important;
      }
    </style>
  `;E([A({type:Object}),w("design:type",Object)],$o.prototype,"visibleSchema",void 0);E([A({type:Array}),w("design:type",Array)],$o.prototype,"sessionGroups",void 0);E([A({type:Object}),w("design:type",Object)],$o.prototype,"options",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],$o.prototype,"selectedSessionGroup",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],$o.prototype,"closestSessionGroup",void 0);E([A({type:Object}),w("design:type",HTMLElement)],$o.prototype,"_container",void 0);E([A({type:Object}),w("design:type",Object)],$o.prototype,"_svg",void 0);E([A({type:Number}),w("design:type",Number)],$o.prototype,"width",void 0);E([A({type:Number}),w("design:type",Number)],$o.prototype,"height",void 0);E([A({type:Object}),w("design:type",Object)],$o.prototype,"_brushedCellIndex",void 0);E([A({type:Object}),w("design:type",Object)],$o.prototype,"_brushSelection",void 0);E([Bt("sessionGroups.*"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],$o.prototype,"_sessionGroupsChanged",null);E([Bt("visibleSchema.*"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],$o.prototype,"_visibleSchemaChanged",null);E([Bt("options.*"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],$o.prototype,"_redraw",null);$o=E([yt("tf-hparams-scatter-plot-matrix-plot")],$o);var f1=class extends mt{_closestOrSelected(t,r){return t!==null?t:r}};f1.template=Q`
    <hparams-split-layout orientation="vertical">
      <!-- Controls behavior of the scatter plot matrix
             outputs the configured options to the _options property. -->
      <tf-hparams-scale-and-color-controls
        slot="content"
        class="section"
        id="controls"
        configuration="[[configuration]]"
        session-groups="[[sessionGroups]]"
        options="{{_options}}"
      >
      </tf-hparams-scale-and-color-controls>
      <!-- The actual scatter plot matrix -->
      <tf-hparams-scatter-plot-matrix-plot
        slot="content"
        class="section"
        id="plot"
        visible-schema="[[configuration.visibleSchema]]"
        session-groups="[[sessionGroups]]"
        selected-session-group="{{_selectedGroup}}"
        closest-session-group="{{_closestGroup}}"
        options="[[_options]]"
      >
      </tf-hparams-scatter-plot-matrix-plot>
      <tf-hparams-session-group-values
        slot="content"
        class="section"
        id="values"
        visible-schema="[[configuration.visibleSchema]]"
        session-group="[[_closestOrSelected(
                                 _closestGroup, _selectedGroup)]]"
      >
      </tf-hparams-session-group-values>
      <!-- Shows session group details for the clicked marker. -->
      <tf-hparams-session-group-details
        slot="content"
        class="section"
        id="details"
        backend="[[backend]]"
        experiment-name="[[experimentName]]"
        session-group="[[_selectedGroup]]"
        visible-schema="[[configuration.visibleSchema]]"
      >
      </tf-hparams-session-group-details>
    </hparams-split-layout>
    <style>
      .section {
        padding: 10px;
      }
      #controls {
        flex-grow: 0;
        flex-shrink: 0;
        flex-basis: auto;
        height: auto;
        overflow-y: auto;
        max-height: fit-content;
      }
      #plot {
        flex-grow: 1;
        flex-shrink: 1;
        flex-basis: auto;
        height: auto;
        overflow-y: auto;
        max-height: fit-content;
      }
      #values {
        flex-grow: 0;
        flex-shrink: 0;
        flex-basis: auto;
        height: 115px;
        overflow-y: auto;
        max-height: fit-content;
      }
      #details {
        flex-grow: 0;
        flex-shrink: 1;
        flex-basis: auto;
        height: auto;
        overflow-y: auto;
        max-height: fit-content;
      }
      vaadin-split-layout {
        height: 100%;
      }
    </style>
  `;E([A({type:Object}),w("design:type",Object)],f1.prototype,"backend",void 0);E([A({type:String}),w("design:type",String)],f1.prototype,"experimentName",void 0);E([A({type:Object}),w("design:type",Object)],f1.prototype,"configuration",void 0);E([A({type:Array}),w("design:type",Array)],f1.prototype,"sessionGroups",void 0);f1=E([yt("tf-hparams-scatter-plot-matrix-view")],f1);var Xf=class extends mt{constructor(){super(),this._selectedTab=0,this._tableTabClicked=()=>{this.logAction("Tab Clicked","Table")},this._parallelCoordsTabClicked=()=>{this.logAction("Tab Clicked","Parallel Coords")},this._scatterPlotMatrixTabClicked=()=>{this.logAction("Tab Clicked","Scatter Plot Matrix")},this.logAction=(t,r)=>{(window.ga||function(){})("send",{hitType:"event",eventCategory:"HParams",eventAction:t,eventLabel:r})},this.logAction("Plugin Load")}};Xf.template=Q`
    <paper-header-panel>
      <paper-toolbar slot="header" class="tab-bar">
        <paper-tabs selected="{{_selectedTab}}" slot="top">
          <!-- view-id can be used by integration tests to locate a tab.
               It should be the name of the root element implementing the view
               without the 'tf-hparams-' prefix. -->
          <paper-tab on-click="_tableTabClicked" view-id="table-view">
            TABLE VIEW
          </paper-tab>
          <paper-tab
            on-click="_parallelCoordsTabClicked"
            view-id="parallel-coords-view"
          >
            PARALLEL COORDINATES VIEW
          </paper-tab>
          <paper-tab
            on-click="_scatterPlotMatrixTabClicked"
            view-id="scatter-plot-matrix-view"
          >
            SCATTER PLOT MATRIX VIEW
          </paper-tab>
          <div class="help-and-feedback">
            <template is="dom-if" if="[[bugReportUrl]]">
              <a
                href$="[[bugReportUrl]]"
                target="_blank"
                rel="noopener noreferrer"
              >
                <paper-button
                  id="bug-report"
                  raised
                  title="Send a bug report or feature request"
                >
                  Bug Report / Feature Request
                </paper-button>
              </a>
            </template>
            <template is="dom-if" if="[[helpUrl]]">
              <a href$="[[helpUrl]]" target="_blank" rel="noopener noreferrer">
                <paper-icon-button
                  icon="help-outline"
                  title="View documentation"
                >
                </paper-icon-button>
              </a>
            </template>
          </div>
        </paper-tabs>
      </paper-toolbar>
      <iron-pages selected="[[_selectedTab]]" class="fit tab-view">
        <div id="0" class="tab">
          <tf-hparams-table-view
            backend="[[backend]]"
            experiment-name="[[experimentName]]"
            visible-schema="[[configuration.visibleSchema]]"
            session-groups="[[sessionGroups]]"
            enable-show-metrics
          >
          </tf-hparams-table-view>
        </div>
        <div id="1" class="tab">
          <tf-hparams-parallel-coords-view
            backend="[[backend]]"
            experiment-name="[[experimentName]]"
            configuration="[[configuration]]"
            session-groups="[[sessionGroups]]"
          >
          </tf-hparams-parallel-coords-view>
        </div>
        <div id="2" class="tab">
          <tf-hparams-scatter-plot-matrix-view
            backend="[[backend]]"
            experiment-name="[[experimentName]]"
            configuration="[[configuration]]"
            session-groups="[[sessionGroups]]"
          >
          </tf-hparams-scatter-plot-matrix-view>
        </div>
      </iron-pages>
    </paper-header-panel>

    <style>
      .tab-view {
        height: 100%;
      }
      .tab-bar {
        overflow-y: auto;
        color: white;
        background-color: var(
          --tb-toolbar-background-color,
          var(--tb-orange-strong)
        );
      }
      .tab {
        height: 100%;
      }
      paper-tabs {
        flex-grow: 1;
        width: 100%;
        height: 100%;
        --paper-tabs-selection-bar-color: white;
        --paper-tabs-content: {
          -webkit-font-smoothing: antialiased;
        }
      }
      tf-hparams-table-view {
        width: 100%;
        height: 100%;
      }
      .help-and-feedback {
        display: inline-flex; /* Ensure that icons stay aligned */
        justify-content: flex-end;
        align-items: center;
        text-align: right;
        color: white;
      }
      #bug-report {
        border: solid black;
        background: red;
        white-space: normal;
        word-break: break-words;
        font-size: 12px;
        max-width: 150px;
        text-align: left;
      }
      .help-and-feedback a {
        color: white;
        text-decoration: none;
      }
    </style>
  `;E([A({type:Object}),w("design:type",Object)],Xf.prototype,"backend",void 0);E([A({type:String}),w("design:type",String)],Xf.prototype,"helpUrl",void 0);E([A({type:String}),w("design:type",String)],Xf.prototype,"bugReportUrl",void 0);E([A({type:String}),w("design:type",String)],Xf.prototype,"experimentName",void 0);E([A({type:Object}),w("design:type",Object)],Xf.prototype,"configuration",void 0);E([A({type:Array}),w("design:type",Array)],Xf.prototype,"sessionGroups",void 0);E([A({type:Number}),w("design:type",Number)],Xf.prototype,"_selectedTab",void 0);Xf=E([yt("tf-hparams-sessions-pane"),w("design:paramtypes",[])],Xf);var rh=class extends Gt(mt){reload(){this.$["query-pane"].reload()}};rh.template=Q`
    <hparams-split-layout>
      <div slot="content" class="sidebar">
        <tf-hparams-query-pane
          id="query-pane"
          backend="[[backend]]"
          experiment-name="[[experimentName]]"
          configuration="{{_configuration}}"
          session-groups="{{_sessionGroups}}"
          data-loaded-with-non-empty-hparams="{{_dataLoadedWithNonEmptyHparams}}"
          data-loaded-with-empty-hparams="{{_dataLoadedWithEmptyHparams}}"
        >
        </tf-hparams-query-pane>
      </div>
      <div slot="content" class="center">
        <template is="dom-if" if="[[_dataLoadedWithEmptyHparams]]">
          <div class="no-data-warning">
            <h3>No hparams data was found.</h3>
            <p>Probable causes:</p>
            <ul>
              <li>You haven’t written any hparams data to your event files.</li>
              <li>
                Event files are still being loaded (try reloading this page).
              </li>
              <li>TensorBoard can’t find your event files.</li>
            </ul>

            <p>
              If you’re new to using TensorBoard, and want to find out how to
              add data and set up your event files, check out the
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
                >README</a
              >
              and perhaps the
              <a
                href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
                >TensorBoard tutorial</a
              >.
            </p>

            <p>
              If you think TensorBoard is configured properly, please see
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"
                >the section of the README devoted to missing data problems</a
              >
              and consider filing an issue on GitHub.
            </p>
          </div>
        </template>

        <template is="dom-if" if="[[_dataLoadedWithNonEmptyHparams]]">
          <tf-hparams-sessions-pane
            id="sessions-pane"
            backend="[[backend]]"
            help-url="[[helpUrl]]"
            bug-report-url="[[bugReportUrl]]"
            experiment-name="[[experimentName]]"
            configuration="[[_configuration]]"
            session-groups="[[_sessionGroups]]"
          >
          </tf-hparams-sessions-pane>
        </template>
      </div>
    </hparams-split-layout>
    <style>
      hparams-split-layout {
        width: 100%;
      }

      .sidebar {
        width: 20%;
        height: 100%;
        overflow: auto;
        flex-grow: 0;
        flex-shrink: 0;
        min-width: 10%;
      }

      .center {
        height: 100%;
        overflow-y: auto;
        flex-grow: 1;
        flex-shrink: 1;
        width: 80%;
      }

      :host {
        display: flex;
        flex-direction: row;
        height: 100%;
        width: 100%;
      }

      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }

      a {
        color: var(--tb-link);
      }

      a:visited {
        color: var(--tb-link-visited);
      }
    </style>
  `;E([A({type:Object}),w("design:type",u3)],rh.prototype,"backend",void 0);E([A({type:String}),w("design:type",String)],rh.prototype,"experimentName",void 0);E([A({type:String}),w("design:type",String)],rh.prototype,"helpUrl",void 0);E([A({type:String}),w("design:type",String)],rh.prototype,"bugReportUrl",void 0);E([A({type:Object}),w("design:type",Object)],rh.prototype,"_configuration",void 0);E([A({type:Array}),w("design:type",Array)],rh.prototype,"_sessionGroups",void 0);E([A({type:Boolean}),w("design:type",Boolean)],rh.prototype,"_dataLoadedWithNonEmptyHparams",void 0);E([A({type:Boolean}),w("design:type",Boolean)],rh.prototype,"_dataLoadedWithEmptyHparams",void 0);rh=E([yt("tf-hparams-main")],rh);var phr=new URLSearchParams(window.location.search).get("tensorboardColab")==="true",lV=class extends Gt(mt){constructor(){super(...arguments),this._backend=new u3(new Ae,phr)}reload(){this.$["hparams-main"].reload()}};lV.template=Q`
    <!-- TensorBoard does not specify an experimentName. Currently it only
         supports one experiment per invocation. -->
    <tf-hparams-main
      id="hparams-main"
      backend="[[_backend]]"
      experiment-name=""
    >
    </tf-hparams-main>
  `;E([A({type:Object}),w("design:type",Object)],lV.prototype,"_backend",void 0);lV=E([yt("tf-hparams-dashboard")],lV);var p1=Ee(Oe(),1);var _n=class extends Gt(mt){constructor(){super(...arguments),this.actualSize=!1,this.brightnessAdjustment=.5,this.contrastPercentage=0,this._metadataCanceller=new an,this._imageCanceller=new an,this._steps=[],this._isImageLoading=!1}get _runColor(){var t=this.run;return fn(t)}get _hasAtLeastOneStep(){var t=this._steps;return!!t&&t.length>0}get _hasMultipleSteps(){var t=this._steps;return!!t&&t.length>1}get _currentStep(){var t=this._steps,r=this._stepIndex;return t[r]||null}get _stepValue(){var t=this._currentStep;return t?t.step:0}get _currentWallTime(){var t=this._currentStep;return t?s2(t.wall_time):""}get _maxStepIndex(){var t=this._steps;return t.length-1}get _sampleText(){var t=this.sample;return`${t+1}`}get _hasMultipleSamples(){var t=this.ofSamples;return t>1}_getAriaExpanded(){return this.actualSize?"true":"false"}attached(){this.reload()}reload(){if(!this.isAttached)return;this._metadataCanceller.cancelAll();let t=new URLSearchParams({tag:this.tag,run:this.run,sample:this.sample}),r=_e().pluginRoute("images","/images",t),n=this._metadataCanceller.cancellable(i=>{if(i.cancelled)return;let a=i.value.map(this._createStepDatum.bind(this));this.set("_steps",a),this.set("_stepIndex",a.length-1)});this.requestManager.request(r).then(n)}_createStepDatum(t){let r=new URLSearchParams(t.query);r.append("ts",t.wall_time);let n=_e().pluginRouteForSrc("images","/individualImage",r);return{wall_time:new Date(t.wall_time*1e3),step:t.step,url:n}}_updateImageUrl(){var t=this._currentStep,r=this.brightnessAdjustment,n=this.contrastPercentage;if(!t)return;let i=new Image;this._imageCanceller.cancelAll(),i.onload=i.onerror=this._imageCanceller.cancellable(o=>{if(o.cancelled)return;let a=this.$$("#main-image-container");a&&(a.textContent="",zt(a).appendChild(i)),this.set("_isImageLoading",!1)}).bind(this),i.style.filter=`contrast(${n}%) `,i.style.filter+=`brightness(${r})`,this.set("_isImageLoading",!0),i.src=t.url}_handleTap(t){this.set("actualSize",!this.actualSize)}_toLocaleString(t){return t.toLocaleString()}};_n.template=Q`
    <tf-card-heading
      tag="[[tag]]"
      run="[[run]]"
      display-name="[[tagMetadata.displayName]]"
      description="[[tagMetadata.description]]"
      color="[[_runColor]]"
    >
      <template is="dom-if" if="[[_hasMultipleSamples]]">
        <div>sample: [[_sampleText]] of [[ofSamples]]</div>
      </template>
      <template is="dom-if" if="[[_hasAtLeastOneStep]]">
        <div class="heading-row">
          <div class="heading-label">
            step
            <span style="font-weight: bold"
              >[[_toLocaleString(_stepValue)]]</span
            >
          </div>
          <div class="heading-label heading-right datetime">
            <template is="dom-if" if="[[_currentWallTime]]">
              [[_currentWallTime]]
            </template>
          </div>
          <div class="label right">
            <paper-spinner-lite active hidden$="[[!_isImageLoading]]">
            </paper-spinner-lite>
          </div>
        </div>
      </template>
      <template is="dom-if" if="[[_hasMultipleSteps]]">
        <div>
          <paper-slider
            id="steps"
            immediate-value="{{_stepIndex}}"
            max="[[_maxStepIndex]]"
            max-markers="[[_maxStepIndex]]"
            snaps
            step="1"
            value="{{_stepIndex}}"
          ></paper-slider>
        </div>
      </template>
    </tf-card-heading>

    <!-- Semantically a button but <img> inside a <button> disallows user to do
    an interesting operation like "Copy Image" in non-Chromium browsers. -->
    <a
      id="main-image-container"
      role="button"
      aria-label="Toggle actual size"
      aria-expanded$="[[_getAriaExpanded(actualSize)]]"
      on-tap="_handleTap"
    ></a>

    <style include="tf-card-heading-style">
      /** Make button a div. */
      button {
        width: 100%;
        display: block;
        background: none;
        border: 0;
        padding: 0;
      }

      /** Firefox: Get rid of dotted line inside button. */
      button::-moz-focus-inner {
        border: 0;
        padding: 0;
      }

      /** Firefox: Simulate Chrome's outer glow on button when focused. */
      button:-moz-focusring {
        outline: none;
        box-shadow: 0px 0px 1px 2px Highlight;
      }

      :host {
        display: block;
        width: 350px;
        height: auto;
        position: relative;
        margin: 0 15px 40px 0;
        overflow-x: auto;
      }

      /** When actual size shown is on, use the actual image width. */
      :host([actual-size]) {
        max-width: 100%;
        width: auto;
      }

      :host([actual-size]) #main-image-container {
        max-height: none;
        width: auto;
      }

      :host([actual-size]) #main-image-container img {
        width: auto;
      }

      paper-spinner-lite {
        width: 14px;
        height: 14px;
        vertical-align: text-bottom;
        --paper-spinner-color: var(--tb-orange-strong);
      }

      #steps {
        height: 15px;
        margin: 0 0 0 -15px;
        /*
         * 31 comes from adding a padding of 15px from both sides of the
         * paper-slider, subtracting 1px so that the slider width aligns
         * with the image (the last slider marker takes up 1px), and
         * adding 2px to account for a border of 1px on both sides of
         * the image. 30 - 1 + 2.
         */
        width: calc(100% + 31px);
        --paper-slider-active-color: var(--tb-orange-strong);
        --paper-slider-knob-color: var(--tb-orange-strong);
        --paper-slider-knob-start-border-color: var(--tb-orange-strong);
        --paper-slider-knob-start-color: var(--tb-orange-strong);
        --paper-slider-markers-color: var(--tb-orange-strong);
        --paper-slider-pin-color: var(--tb-orange-strong);
        --paper-slider-pin-start-color: var(--tb-orange-strong);
      }

      #main-image-container {
        max-height: 1024px;
        overflow: auto;
      }

      #main-image-container img {
        cursor: pointer;
        display: block;
        image-rendering: -moz-crisp-edges;
        image-rendering: pixelated;
        width: 100%;
        height: auto;
      }

      paper-icon-button {
        color: #2196f3;
        border-radius: 100%;
        width: 32px;
        height: 32px;
        padding: 4px;
      }
      paper-icon-button[selected] {
        background: var(--tb-ui-light-accent);
      }
      [hidden] {
        display: none;
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],_n.prototype,"run",void 0);E([A({type:String}),w("design:type",String)],_n.prototype,"tag",void 0);E([A({type:Number}),w("design:type",Number)],_n.prototype,"sample",void 0);E([A({type:Number}),w("design:type",Number)],_n.prototype,"ofSamples",void 0);E([A({type:Object}),w("design:type",Object)],_n.prototype,"tagMetadata",void 0);E([A({type:Boolean,reflectToAttribute:!0}),w("design:type",Boolean)],_n.prototype,"actualSize",void 0);E([A({type:Number}),w("design:type",Number)],_n.prototype,"brightnessAdjustment",void 0);E([A({type:Number}),w("design:type",Number)],_n.prototype,"contrastPercentage",void 0);E([A({type:Object}),w("design:type",Ae)],_n.prototype,"requestManager",void 0);E([A({type:Object}),w("design:type",Object)],_n.prototype,"_metadataCanceller",void 0);E([A({type:Object}),w("design:type",Object)],_n.prototype,"_imageCanceller",void 0);E([A({type:Array,notify:!0}),w("design:type",Array)],_n.prototype,"_steps",void 0);E([A({type:Number,notify:!0}),w("design:type",Number)],_n.prototype,"_stepIndex",void 0);E([A({type:Boolean}),w("design:type",Boolean)],_n.prototype,"_isImageLoading",void 0);E([Rt("run"),w("design:type",String),w("design:paramtypes",[])],_n.prototype,"_runColor",null);E([Rt("_steps"),w("design:type",Boolean),w("design:paramtypes",[])],_n.prototype,"_hasAtLeastOneStep",null);E([Rt("_steps"),w("design:type",Boolean),w("design:paramtypes",[])],_n.prototype,"_hasMultipleSteps",null);E([Rt("_steps","_stepIndex"),w("design:type",Object),w("design:paramtypes",[])],_n.prototype,"_currentStep",null);E([Rt("_currentStep"),w("design:type",Number),w("design:paramtypes",[])],_n.prototype,"_stepValue",null);E([Rt("_currentStep"),w("design:type",String),w("design:paramtypes",[])],_n.prototype,"_currentWallTime",null);E([Rt("_steps"),w("design:type",Number),w("design:paramtypes",[])],_n.prototype,"_maxStepIndex",null);E([Rt("sample"),w("design:type",String),w("design:paramtypes",[])],_n.prototype,"_sampleText",null);E([Rt("ofSamples"),w("design:type",Boolean),w("design:paramtypes",[])],_n.prototype,"_hasMultipleSamples",null);E([Bt("run","tag"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],_n.prototype,"reload",null);E([Bt("_currentStep","brightnessAdjustment","contrastPercentage"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],_n.prototype,"_updateImageUrl",null);_n=E([yt("tf-image-loader")],_n);var Io=class extends Gt(mt){constructor(){super(...arguments),this.reloadOnReady=!0,this._defaultBrightnessAdjustment=1,this._defaultContrastPercentage=100,this._brightnessAdjustment=1,this._contrastPercentage=100,this._requestManager=new Ae}ready(){super.ready(),this.reloadOnReady&&this.reload()}reload(){this._fetchTags().then(()=>{this._reloadImages()})}_fetchTags(){let t=_e().pluginRoute("images","/tags");return this._requestManager.request(t).then(r=>{if(p1.isEqual(r,this._runToTagInfo))return;let n=p1.mapValues(r,o=>Object.keys(o)),i=$i(n);this.set("_dataNotFound",i.length===0),this.set("_runToTagInfo",r),this.async(()=>{this.set("_categoriesDomReady",!0)})})}_reloadImages(){var t;(t=this.root)==null||t.querySelectorAll("tf-image-loader").forEach(r=>{r.reload()})}_shouldOpen(t){return t<=2}_resetBrightness(){this._brightnessAdjustment=this._defaultBrightnessAdjustment}_resetContrast(){this._contrastPercentage=this._defaultContrastPercentage}get _brightnessIsDefault(){var t=this._brightnessAdjustment;return t===this._defaultBrightnessAdjustment}get _contrastIsDefault(){var t=this._contrastPercentage;return t===this._defaultContrastPercentage}get _categories(){var t=this._runToTagInfo,r=this._selectedRuns,n=this._tagFilter,i=this._categoriesDomReady;let o=p1.mapValues(t,c=>Object.keys(c)),a=Ql(o,r,n);function s(c){let u=t[c.run][c.tag].samples;return p1.range(u).map(h=>Object.assign({},c,{sample:h,ofSamples:u}))}return a.map(c=>Object.assign({},c,{items:[].concat.apply([],c.items.map(s))}))}_tagMetadata(t,r,n){return t[r][n]}};Io.template=Q`
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <div class="settings">
          <div class="sidebar-section">
            <div class="line-item">
              <paper-checkbox checked="{{_actualSize}}"
                >Show actual image size</paper-checkbox
              >
            </div>
          </div>
          <div class="sidebar-section">
            <h3 class="tooltip-container">Brightness adjustment</h3>
            <div class="resettable-slider-container">
              <paper-slider
                min="0"
                max="2"
                snaps
                pin
                step="0.01"
                value="{{_brightnessAdjustment}}"
                immediate-value="{{_brightnessAdjustment}}"
              ></paper-slider>
              <paper-button
                class="x-button"
                on-tap="_resetBrightness"
                disabled="[[_brightnessIsDefault]]"
                >Reset</paper-button
              >
            </div>
          </div>
          <div class="sidebar-section">
            <h3 class="tooltip-container">Contrast adjustment</h3>
            <div class="resettable-slider-container">
              <paper-slider
                min="0"
                max="500"
                snaps
                pin
                step="1"
                value="{{_contrastPercentage}}"
                immediate-value="{{_contrastPercentage}}"
              ></paper-slider>
              <paper-button
                class="x-button"
                on-tap="_resetContrast"
                disabled="[[_contrastIsDefault]]"
                >Reset</paper-button
              >
            </div>
          </div>
        </div>
        <div class="sidebar-section runs-selector">
          <tf-runs-selector
            id="runs-selector"
            selected-runs="{{_selectedRuns}}"
          ></tf-runs-selector>
        </div>
      </div>
      <div class="center" slot="center">
        <template is="dom-if" if="[[_dataNotFound]]">
          <div class="no-data-warning">
            <h3>No image data was found.</h3>
            <p>Probable causes:</p>
            <ul>
              <li>You haven’t written any image data to your event files.</li>
              <li>TensorBoard can’t find your event files.</li>
            </ul>

            <p>
              If you’re new to using TensorBoard, and want to find out how to
              add data and set up your event files, check out the
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
                >README</a
              >
              and perhaps the
              <a
                href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
                >TensorBoard tutorial</a
              >.
            </p>

            <p>
              If you think TensorBoard is configured properly, please see
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"
                >the section of the README devoted to missing data problems</a
              >
              and consider filing an issue on GitHub.
            </p>
          </div>
        </template>
        <template is="dom-if" if="[[!_dataNotFound]]">
          <tf-tag-filterer tag-filter="{{_tagFilter}}"></tf-tag-filterer>
          <template is="dom-repeat" items="[[_categories]]" as="category">
            <tf-category-paginated-view
              category="[[category]]"
              initial-opened="[[_shouldOpen(index)]]"
            >
              <template>
                <tf-image-loader
                  active="[[active]]"
                  run="[[item.run]]"
                  tag="[[item.tag]]"
                  sample="[[item.sample]]"
                  of-samples="[[item.ofSamples]]"
                  tag-metadata="[[_tagMetadata(_runToTagInfo, item.run, item.tag)]]"
                  request-manager="[[_requestManager]]"
                  actual-size="[[_actualSize]]"
                  brightness-adjustment="[[_brightnessAdjustment]]"
                  contrast-percentage="[[_contrastPercentage]]"
                ></tf-image-loader>
              </template>
            </tf-category-paginated-view>
          </template>
        </template>
      </div>
    </tf-dashboard-layout>
    <style include="dashboard-style"></style>
    <style>
      .resettable-slider-container {
        display: flex;
      }
      .resettable-slider-container paper-slider {
        flex-grow: 1;
      }
      .resettable-slider-container paper-button {
        flex-grow: 0;
      }
      .resettable-slider-container paper-button[disabled] {
        background-color: unset;
      }
      .x-button {
        font-size: 13px;
        background-color: var(--tb-ui-light-accent);
        color: var(--tb-ui-dark-accent);
      }
      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }
      paper-slider {
        --paper-slider-active-color: var(--tb-orange-strong);
        --paper-slider-knob-color: var(--tb-orange-strong);
        --paper-slider-knob-start-border-color: var(--tb-orange-strong);
        --paper-slider-knob-start-color: var(--tb-orange-strong);
        --paper-slider-markers-color: var(--tb-orange-strong);
        --paper-slider-pin-color: var(--tb-orange-strong);
        --paper-slider-pin-start-color: var(--tb-orange-strong);
      }
    </style>
  `;E([A({type:Boolean}),w("design:type",Boolean)],Io.prototype,"reloadOnReady",void 0);E([A({type:Array}),w("design:type",Array)],Io.prototype,"_selectedRuns",void 0);E([A({type:Object}),w("design:type",Object)],Io.prototype,"_runToTagInfo",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Io.prototype,"_dataNotFound",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Io.prototype,"_actualSize",void 0);E([A({type:Number}),w("design:type",Number)],Io.prototype,"_defaultBrightnessAdjustment",void 0);E([A({type:Number}),w("design:type",Number)],Io.prototype,"_defaultContrastPercentage",void 0);E([A({type:Number}),w("design:type",Number)],Io.prototype,"_brightnessAdjustment",void 0);E([A({type:Number}),w("design:type",Number)],Io.prototype,"_contrastPercentage",void 0);E([A({type:String}),w("design:type",String)],Io.prototype,"_tagFilter",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Io.prototype,"_categoriesDomReady",void 0);E([A({type:Object}),w("design:type",Object)],Io.prototype,"_requestManager",void 0);E([Rt("_brightnessAdjustment"),w("design:type",Boolean),w("design:paramtypes",[])],Io.prototype,"_brightnessIsDefault",null);E([Rt("_contrastPercentage"),w("design:type",Boolean),w("design:paramtypes",[])],Io.prototype,"_contrastIsDefault",null);E([Rt("_runToTagInfo","_selectedRuns","_tagFilter","_categoriesDomReady"),w("design:type",Array),w("design:paramtypes",[])],Io.prototype,"_categories",null);Io=E([yt("tf-image-dashboard")],Io);var sx=Ee(Oe(),1);var d1;(function(e){e[e.CANCELLED=1]="CANCELLED"})(d1||(d1={}));var cV;(function(e){e[e.VERTEX=1]="VERTEX",e[e.FACE=2]="FACE",e[e.COLOR=3]="COLOR"})(cV||(cV={}));var qct;(function(e){e.VERTEX="float32",e.FACE="int32",e.COLOR="uint8"})(qct||(qct={}));var IP=class{constructor(t){this._canceller=new an,this._requestManager=t}reload(t,r,n){return this._canceller.cancelAll(),this._fetchMetadata(t,r,n)}_fetchDataByStep(t,r,n,i,o,a){let s=_e().pluginRoute("mesh","/data",new URLSearchParams({tag:r,run:t,content_type:n,sample:String(i),step:String(o)})),l=function(u){let f=[];for(let p=0;p<u.length/3;p++){let d=[];for(let g=0;g<3;g++)d.push(u[p*3+g]);f.push(d)}return f},c=this._canceller.cancellable(u=>{if(u.cancelled)return Promise.reject({code:d1.CANCELLED,message:"Response was invalidated."});let h=u.value;switch(n){case"VERTEX":a.vertices=l(new Float32Array(h));break;case"FACE":a.faces=l(new Int32Array(h));break;case"COLOR":a.colors=l(new Uint8Array(h));break}return a});return this._requestManager.fetch(s,{method:"GET",headers:{responseType:"arraybuffer",contentType:qct[n]}}).then(u=>u.arrayBuffer()).then(c)}fetchData(t,r,n,i){let o=[],a=new Map;return Object.keys(cV).forEach(s=>{let l=1<<cV[s];t.components&l&&o.push(this._fetchDataByStep(r,n,s,i,t.step,a))}),Promise.all(o)}_fetchMetadata(t,r,n){this._canceller.cancelAll();let i=_e().pluginRoute("mesh","/meshes",new URLSearchParams({tag:r,run:t,sample:n})),o=this._canceller.cancellable(a=>a.cancelled?Promise.reject({code:d1.CANCELLED,message:"Response was invalidated."}):a.value);return this._requestManager.fetch(i).then(a=>a.json()).then(o).then(this._processMetadata.bind(this))}_processMetadata(t){if(!t)return;let r=new Map;for(let i=0;i<t.length;i++){let o=t[i];r.has(o.step)||r.set(o.step,[]),r.get(o.step).push(o)}let n=[];return r.forEach(i=>{let o=this._createStepDatum(i[0]);n.push(o)}),n}_createStepDatum(t){return{wall_time:new Date(t.wall_time*1e3),step:t.step,config:t.config,content_type:t.content_type,components:t.components}}};var wM={};Ks(wM,{ACESFilmicToneMapping:()=>pfe,AddEquation:()=>M1,AddOperation:()=>cfe,AdditiveAnimationBlendMode:()=>kht,AdditiveBlending:()=>Mut,AlphaFormat:()=>xfe,AlwaysDepth:()=>rfe,AlwaysStencilFunc:()=>Ofe,AmbientLight:()=>L6,AmbientLightProbe:()=>zU,AnimationClip:()=>Q1,AnimationLoader:()=>oht,AnimationMixer:()=>VU,AnimationObjectGroup:()=>HU,AnimationUtils:()=>Yn,ArcCurve:()=>l6,ArrayCamera:()=>n6,ArrowHelper:()=>Mht,Audio:()=>D6,AudioAnalyser:()=>FU,AudioContext:()=>zht,AudioListener:()=>cht,AudioLoader:()=>DU,AxesHelper:()=>vM,AxisHelper:()=>K0r,BackSide:()=>Ii,BasicDepthPacking:()=>Rfe,BasicShadowMap:()=>mhr,BinaryTextureLoader:()=>e_r,Bone:()=>sM,BooleanKeyframeTrack:()=>am,BoundingBoxHelper:()=>Z0r,Box2:()=>$0,Box3:()=>ta,Box3Helper:()=>wht,BoxBufferGeometry:()=>Qf,BoxGeometry:()=>Qf,BoxHelper:()=>yM,BufferAttribute:()=>Je,BufferGeometry:()=>Pe,BufferGeometryLoader:()=>RU,ByteType:()=>mfe,Cache:()=>tx,Camera:()=>R1,CameraHelper:()=>bht,CanvasRenderer:()=>n_r,CanvasTexture:()=>xU,CatmullRomCurve3:()=>c6,CineonToneMapping:()=>ffe,CircleBufferGeometry:()=>F1,CircleGeometry:()=>F1,ClampToEdgeWrapping:()=>Jo,Clock:()=>mM,Color:()=>ne,ColorKeyframeTrack:()=>M6,CompressedTexture:()=>a6,CompressedTextureLoader:()=>aht,ConeBufferGeometry:()=>B1,ConeGeometry:()=>B1,CubeCamera:()=>J3,CubeReflectionMapping:()=>nx,CubeRefractionMapping:()=>ix,CubeTexture:()=>H0,CubeTextureLoader:()=>TU,CubeUVReflectionMapping:()=>xM,CubeUVRefractionMapping:()=>z6,CubicBezierCurve:()=>cM,CubicBezierCurve3:()=>u6,CubicInterpolant:()=>SU,CullFaceBack:()=>Sut,CullFaceFront:()=>Vhe,CullFaceFrontBack:()=>dhr,CullFaceNone:()=>Hhe,Curve:()=>fs,CurvePath:()=>wU,CustomBlending:()=>qhe,CustomToneMapping:()=>dfe,CylinderBufferGeometry:()=>om,CylinderGeometry:()=>om,Cylindrical:()=>mht,DataTexture:()=>Jd,DataTexture2DArray:()=>tM,DataTexture3D:()=>r6,DataTextureLoader:()=>CU,DataUtils:()=>Tht,DecrementStencilOp:()=>Thr,DecrementWrapStencilOp:()=>Ahr,DefaultLoadingManager:()=>ipe,DepthFormat:()=>z0,DepthStencilFormat:()=>k1,DepthTexture:()=>nM,DirectionalLight:()=>I6,DirectionalLightHelper:()=>xht,DiscreteInterpolant:()=>MU,DodecahedronBufferGeometry:()=>H1,DodecahedronGeometry:()=>H1,DoubleSide:()=>L1,DstAlphaFactor:()=>Khe,DstColorFactor:()=>Jhe,DynamicBufferAttribute:()=>H0r,DynamicCopyUsage:()=>Uhr,DynamicDrawUsage:()=>Y3,DynamicReadUsage:()=>Bhr,EdgesGeometry:()=>s6,EdgesHelper:()=>J0r,EllipseCurve:()=>V1,EqualDepth:()=>ife,EqualStencilFunc:()=>khr,EquirectangularReflectionMapping:()=>YP,EquirectangularRefractionMapping:()=>jP,Euler:()=>tm,EventDispatcher:()=>Us,ExtrudeBufferGeometry:()=>hh,ExtrudeGeometry:()=>hh,FaceColors:()=>P0r,FileLoader:()=>Jc,FlatShading:()=>Aht,Float16BufferAttribute:()=>dU,Float32Attribute:()=>X0r,Float32BufferAttribute:()=>xe,Float64Attribute:()=>$0r,Float64BufferAttribute:()=>mU,FloatType:()=>jd,Fog:()=>z1,FogExp2:()=>O1,Font:()=>u_r,FontLoader:()=>c_r,FramebufferTexture:()=>vU,FrontSide:()=>I1,Frustum:()=>N1,GLBufferAttribute:()=>qU,GLSL1:()=>Ghr,GLSL3:()=>Kut,GreaterDepth:()=>afe,GreaterEqualDepth:()=>ofe,GreaterEqualStencilFunc:()=>Ohr,GreaterStencilFunc:()=>Nhr,GridHelper:()=>YU,Group:()=>Xd,HalfFloatType:()=>C1,HemisphereLight:()=>T6,HemisphereLightHelper:()=>yht,HemisphereLightProbe:()=>OU,IcosahedronBufferGeometry:()=>G1,IcosahedronGeometry:()=>G1,ImageBitmapLoader:()=>NU,ImageLoader:()=>ex,ImageUtils:()=>Kf,ImmediateRenderObject:()=>h_r,IncrementStencilOp:()=>Ehr,IncrementWrapStencilOp:()=>Chr,InstancedBufferAttribute:()=>rm,InstancedBufferGeometry:()=>N6,InstancedInterleavedBuffer:()=>UU,InstancedMesh:()=>i6,Int16Attribute:()=>G0r,Int16BufferAttribute:()=>fU,Int32Attribute:()=>Y0r,Int32BufferAttribute:()=>pU,Int8Attribute:()=>V0r,Int8BufferAttribute:()=>cU,IntType:()=>_fe,InterleavedBuffer:()=>em,InterleavedBufferAttribute:()=>tp,Interpolant:()=>fh,InterpolateDiscrete:()=>KP,InterpolateLinear:()=>ZP,InterpolateSmooth:()=>rU,InvertStencilOp:()=>Phr,JSONLoader:()=>i_r,KeepStencilOp:()=>nU,KeyframeTrack:()=>Dl,LOD:()=>_U,LatheBufferGeometry:()=>W1,LatheGeometry:()=>W1,Layers:()=>X3,LensFlare:()=>a_r,LessDepth:()=>nfe,LessEqualDepth:()=>iU,LessEqualStencilFunc:()=>Rhr,LessStencilFunc:()=>Lhr,Light:()=>Ol,LightProbe:()=>rx,Line:()=>ch,Line3:()=>GU,LineBasicMaterial:()=>Gi,LineCurve:()=>U1,LineCurve3:()=>bU,LineDashedMaterial:()=>w6,LineLoop:()=>o6,LinePieces:()=>C0r,LineSegments:()=>Aa,LineStrip:()=>T0r,LinearEncoding:()=>Qd,LinearFilter:()=>ii,LinearInterpolant:()=>S6,LinearMipMapLinearFilter:()=>xhr,LinearMipMapNearestFilter:()=>vhr,LinearMipmapLinearFilter:()=>ox,LinearMipmapNearestFilter:()=>Lht,LinearToneMapping:()=>ufe,Loader:()=>ea,LoaderUtils:()=>dM,LoadingManager:()=>E6,LoopOnce:()=>Pfe,LoopPingPong:()=>Lfe,LoopRepeat:()=>Ife,LuminanceAlphaFormat:()=>wfe,LuminanceFormat:()=>bfe,MOUSE:()=>K0,Material:()=>qi,MaterialLoader:()=>kU,Math:()=>ifr,MathUtils:()=>ifr,Matrix3:()=>ki,Matrix4:()=>Me,MaxEquation:()=>Aut,Mesh:()=>ti,MeshBasicMaterial:()=>sh,MeshDepthMaterial:()=>eM,MeshDistanceMaterial:()=>rM,MeshFaceMaterial:()=>L0r,MeshLambertMaterial:()=>x6,MeshMatcapMaterial:()=>b6,MeshNormalMaterial:()=>v6,MeshPhongMaterial:()=>_6,MeshPhysicalMaterial:()=>g6,MeshStandardMaterial:()=>pM,MeshToonMaterial:()=>y6,MinEquation:()=>Cut,MirroredRepeatWrapping:()=>$P,MixOperation:()=>lfe,MultiMaterial:()=>k0r,MultiplyBlending:()=>Tut,MultiplyOperation:()=>O6,NearestFilter:()=>Li,NearestMipMapLinearFilter:()=>yhr,NearestMipMapNearestFilter:()=>_hr,NearestMipmapLinearFilter:()=>aU,NearestMipmapNearestFilter:()=>oU,NeverDepth:()=>efe,NeverStencilFunc:()=>Ihr,NoBlending:()=>$d,NoColors:()=>A0r,NoToneMapping:()=>Kd,NormalAnimationBlendMode:()=>$U,NormalBlending:()=>V3,NotEqualDepth:()=>sfe,NotEqualStencilFunc:()=>Dhr,NumberKeyframeTrack:()=>Z1,Object3D:()=>or,ObjectLoader:()=>sht,ObjectSpaceNormalMap:()=>Dfe,OctahedronBufferGeometry:()=>W0,OctahedronGeometry:()=>W0,OneFactor:()=>jhe,OneMinusDstAlphaFactor:()=>Zhe,OneMinusDstColorFactor:()=>Qhe,OneMinusSrcAlphaFactor:()=>Iht,OneMinusSrcColorFactor:()=>$he,OrthographicCamera:()=>D1,PCFShadowMap:()=>Cht,PCFSoftShadowMap:()=>Uhe,PMREMGenerator:()=>e6,ParametricGeometry:()=>s_r,Particle:()=>N0r,ParticleBasicMaterial:()=>z0r,ParticleSystem:()=>D0r,ParticleSystemMaterial:()=>F0r,Path:()=>q1,PerspectiveCamera:()=>Ui,Plane:()=>$c,PlaneBufferGeometry:()=>V0,PlaneGeometry:()=>V0,PlaneHelper:()=>Sht,PointCloud:()=>R0r,PointCloudMaterial:()=>O0r,PointLight:()=>P6,PointLightHelper:()=>_ht,Points:()=>im,PointsMaterial:()=>nm,PolarGridHelper:()=>vht,PolyhedronBufferGeometry:()=>uh,PolyhedronGeometry:()=>uh,PositionalAudio:()=>uht,PropertyBinding:()=>Cr,PropertyMixer:()=>BU,QuadraticBezierCurve:()=>uM,QuadraticBezierCurve3:()=>hM,Quaternion:()=>yi,QuaternionKeyframeTrack:()=>X0,QuaternionLinearInterpolant:()=>EU,REVISION:()=>jU,RGBADepthPacking:()=>Nfe,RGBAFormat:()=>Qo,RGBAIntegerFormat:()=>Cfe,RGBA_ASTC_10x10_Format:()=>Yut,RGBA_ASTC_10x5_Format:()=>qut,RGBA_ASTC_10x6_Format:()=>Gut,RGBA_ASTC_10x8_Format:()=>Wut,RGBA_ASTC_12x10_Format:()=>jut,RGBA_ASTC_12x12_Format:()=>Xut,RGBA_ASTC_4x4_Format:()=>Dut,RGBA_ASTC_5x4_Format:()=>Out,RGBA_ASTC_5x5_Format:()=>zut,RGBA_ASTC_6x5_Format:()=>Fut,RGBA_ASTC_6x6_Format:()=>But,RGBA_ASTC_8x5_Format:()=>Hut,RGBA_ASTC_8x6_Format:()=>Vut,RGBA_ASTC_8x8_Format:()=>Uut,RGBA_BPTC_Format:()=>$ut,RGBA_ETC2_EAC_Format:()=>Nut,RGBA_PVRTC_2BPPV1_Format:()=>kut,RGBA_PVRTC_4BPPV1_Format:()=>Lut,RGBA_S3TC_DXT1_Format:()=>QV,RGBA_S3TC_DXT3_Format:()=>tU,RGBA_S3TC_DXT5_Format:()=>eU,RGB_ETC1_Format:()=>Afe,RGB_ETC2_Format:()=>Rut,RGB_PVRTC_2BPPV1_Format:()=>Iut,RGB_PVRTC_4BPPV1_Format:()=>Put,RGB_S3TC_DXT1_Format:()=>JV,RGFormat:()=>Efe,RGIntegerFormat:()=>Tfe,RawShaderMaterial:()=>U0,Ray:()=>Jf,Raycaster:()=>pht,RectAreaLight:()=>k6,RedFormat:()=>Sfe,RedIntegerFormat:()=>Mfe,ReinhardToneMapping:()=>hfe,RepeatWrapping:()=>XP,ReplaceStencilOp:()=>Mhr,ReverseSubtractEquation:()=>Whe,RingBufferGeometry:()=>Y1,RingGeometry:()=>Y1,Scene:()=>q0,SceneUtils:()=>o_r,ShaderChunk:()=>hr,ShaderLib:()=>ah,ShaderMaterial:()=>lh,ShadowMaterial:()=>m6,Shape:()=>Kc,ShapeBufferGeometry:()=>Y0,ShapeGeometry:()=>Y0,ShapePath:()=>Eht,ShapeUtils:()=>Zc,ShortType:()=>gfe,Skeleton:()=>lM,SkeletonHelper:()=>WU,SkinnedMesh:()=>aM,SmoothShading:()=>ghr,Sphere:()=>Zf,SphereBufferGeometry:()=>j0,SphereGeometry:()=>j0,Spherical:()=>_M,SphericalHarmonics3:()=>R6,SplineCurve:()=>fM,SpotLight:()=>A6,SpotLightHelper:()=>ght,Sprite:()=>oM,SpriteMaterial:()=>iM,SrcAlphaFactor:()=>Pht,SrcAlphaSaturateFactor:()=>tfe,SrcColorFactor:()=>Xhe,StaticCopyUsage:()=>Vhr,StaticDrawUsage:()=>W3,StaticReadUsage:()=>Fhr,StereoCamera:()=>lht,StreamCopyUsage:()=>qhr,StreamDrawUsage:()=>zhr,StreamReadUsage:()=>Hhr,StringKeyframeTrack:()=>sm,SubtractEquation:()=>Ghe,SubtractiveBlending:()=>Eut,TOUCH:()=>Z0,TangentSpaceNormalMap:()=>ax,TetrahedronBufferGeometry:()=>j1,TetrahedronGeometry:()=>j1,TextGeometry:()=>l_r,Texture:()=>vi,TextureLoader:()=>AU,TorusBufferGeometry:()=>X1,TorusGeometry:()=>X1,TorusKnotBufferGeometry:()=>$1,TorusKnotGeometry:()=>$1,Triangle:()=>oi,TriangleFanDrawMode:()=>whr,TriangleStripDrawMode:()=>bhr,TrianglesDrawMode:()=>kfe,TubeBufferGeometry:()=>K1,TubeGeometry:()=>K1,UVMapping:()=>XU,Uint16Attribute:()=>W0r,Uint16BufferAttribute:()=>$3,Uint32Attribute:()=>j0r,Uint32BufferAttribute:()=>K3,Uint8Attribute:()=>U0r,Uint8BufferAttribute:()=>uU,Uint8ClampedAttribute:()=>q0r,Uint8ClampedBufferAttribute:()=>hU,Uniform:()=>gM,UniformsLib:()=>re,UniformsUtils:()=>Vfe,UnsignedByteType:()=>Zd,UnsignedInt248Type:()=>A1,UnsignedIntType:()=>VP,UnsignedShort4444Type:()=>yfe,UnsignedShort5551Type:()=>vfe,UnsignedShortType:()=>G3,VSMShadowMap:()=>F3,Vector2:()=>Lt,Vector3:()=>j,Vector4:()=>en,VectorKeyframeTrack:()=>J1,Vertex:()=>B0r,VertexColors:()=>I0r,VideoTexture:()=>yU,WebGL1Renderer:()=>gU,WebGLCubeRenderTarget:()=>Q3,WebGLMultipleRenderTargets:()=>lU,WebGLMultisampleRenderTarget:()=>j3,WebGLRenderTarget:()=>us,WebGLRenderTargetCube:()=>r_r,WebGLRenderer:()=>rn,WebGLUtils:()=>Qfe,WireframeGeometry:()=>d6,WireframeHelper:()=>Q0r,WrapAroundEnding:()=>JP,XHRLoader:()=>t_r,ZeroCurvatureEnding:()=>E1,ZeroFactor:()=>Yhe,ZeroSlopeEnding:()=>T1,ZeroStencilOp:()=>Shr,_SRGBAFormat:()=>sU,sRGBEncoding:()=>Wn});var jU="137",K0={LEFT:0,MIDDLE:1,RIGHT:2,ROTATE:0,DOLLY:1,PAN:2},Z0={ROTATE:0,PAN:1,DOLLY_PAN:2,DOLLY_ROTATE:3},Hhe=0,Sut=1,Vhe=2,dhr=3,mhr=0,Cht=1,Uhe=2,F3=3,I1=0,Ii=1,L1=2,Aht=1,ghr=2,$d=0,V3=1,Mut=2,Eut=3,Tut=4,qhe=5,M1=100,Ghe=101,Whe=102,Cut=103,Aut=104,Yhe=200,jhe=201,Xhe=202,$he=203,Pht=204,Iht=205,Khe=206,Zhe=207,Jhe=208,Qhe=209,tfe=210,efe=0,rfe=1,nfe=2,iU=3,ife=4,ofe=5,afe=6,sfe=7,O6=0,lfe=1,cfe=2,Kd=0,ufe=1,hfe=2,ffe=3,pfe=4,dfe=5,XU=300,nx=301,ix=302,YP=303,jP=304,xM=306,z6=307,XP=1e3,Jo=1001,$P=1002,Li=1003,oU=1004,_hr=1004,aU=1005,yhr=1005,ii=1006,Lht=1007,vhr=1007,ox=1008,xhr=1008,Zd=1009,mfe=1010,gfe=1011,G3=1012,_fe=1013,VP=1014,jd=1015,C1=1016,yfe=1017,vfe=1018,A1=1020,xfe=1021,Qo=1023,bfe=1024,wfe=1025,z0=1026,k1=1027,Sfe=1028,Mfe=1029,Efe=1030,Tfe=1031,Cfe=1033,JV=33776,QV=33777,tU=33778,eU=33779,Put=35840,Iut=35841,Lut=35842,kut=35843,Afe=36196,Rut=37492,Nut=37496,Dut=37808,Out=37809,zut=37810,Fut=37811,But=37812,Hut=37813,Vut=37814,Uut=37815,qut=37816,Gut=37817,Wut=37818,Yut=37819,jut=37820,Xut=37821,$ut=36492,Pfe=2200,Ife=2201,Lfe=2202,KP=2300,ZP=2301,rU=2302,E1=2400,T1=2401,JP=2402,$U=2500,kht=2501,kfe=0,bhr=1,whr=2,Qd=3e3,Wn=3001,Rfe=3200,Nfe=3201,ax=0,Dfe=1,Shr=0,nU=7680,Mhr=7681,Ehr=7682,Thr=7683,Chr=34055,Ahr=34056,Phr=5386,Ihr=512,Lhr=513,khr=514,Rhr=515,Nhr=516,Dhr=517,Ohr=518,Ofe=519,W3=35044,Y3=35048,zhr=35040,Fhr=35045,Bhr=35049,Hhr=35041,Vhr=35046,Uhr=35050,qhr=35042,Ghr="100",Kut="300 es",sU=1035,Us=class{addEventListener(t,r){this._listeners===void 0&&(this._listeners={});let n=this._listeners;n[t]===void 0&&(n[t]=[]),n[t].indexOf(r)===-1&&n[t].push(r)}hasEventListener(t,r){if(this._listeners===void 0)return!1;let n=this._listeners;return n[t]!==void 0&&n[t].indexOf(r)!==-1}removeEventListener(t,r){if(this._listeners===void 0)return;let i=this._listeners[t];if(i!==void 0){let o=i.indexOf(r);o!==-1&&i.splice(o,1)}}dispatchEvent(t){if(this._listeners===void 0)return;let n=this._listeners[t.type];if(n!==void 0){t.target=this;let i=n.slice(0);for(let o=0,a=i.length;o<a;o++)i[o].call(this,t);t.target=null}}},Ko=[];for(let e=0;e<256;e++)Ko[e]=(e<16?"0":"")+e.toString(16);var uV=1234567,P1=Math.PI/180,QP=180/Math.PI;function Nl(){let e=Math.random()*4294967295|0,t=Math.random()*4294967295|0,r=Math.random()*4294967295|0,n=Math.random()*4294967295|0;return(Ko[e&255]+Ko[e>>8&255]+Ko[e>>16&255]+Ko[e>>24&255]+"-"+Ko[t&255]+Ko[t>>8&255]+"-"+Ko[t>>16&15|64]+Ko[t>>24&255]+"-"+Ko[r&63|128]+Ko[r>>8&255]+"-"+Ko[r>>16&255]+Ko[r>>24&255]+Ko[n&255]+Ko[n>>8&255]+Ko[n>>16&255]+Ko[n>>24&255]).toUpperCase()}function Zo(e,t,r){return Math.max(t,Math.min(r,e))}function Rht(e,t){return(e%t+t)%t}function Whr(e,t,r,n,i){return n+(e-t)*(i-n)/(r-t)}function Yhr(e,t,r){return e!==t?(r-e)/(t-e):0}function UP(e,t,r){return(1-r)*e+r*t}function jhr(e,t,r,n){return UP(e,t,1-Math.exp(-r*n))}function Xhr(e,t=1){return t-Math.abs(Rht(e,t*2)-t)}function $hr(e,t,r){return e<=t?0:e>=r?1:(e=(e-t)/(r-t),e*e*(3-2*e))}function Khr(e,t,r){return e<=t?0:e>=r?1:(e=(e-t)/(r-t),e*e*e*(e*(e*6-15)+10))}function Zhr(e,t){return e+Math.floor(Math.random()*(t-e+1))}function Jhr(e,t){return e+Math.random()*(t-e)}function Qhr(e){return e*(.5-Math.random())}function tfr(e){return e!==void 0&&(uV=e%2147483647),uV=uV*16807%2147483647,(uV-1)/2147483646}function efr(e){return e*P1}function rfr(e){return e*QP}function Zut(e){return(e&e-1)===0&&e!==0}function zfe(e){return Math.pow(2,Math.ceil(Math.log(e)/Math.LN2))}function Ffe(e){return Math.pow(2,Math.floor(Math.log(e)/Math.LN2))}function nfr(e,t,r,n,i){let o=Math.cos,a=Math.sin,s=o(r/2),l=a(r/2),c=o((t+n)/2),u=a((t+n)/2),h=o((t-n)/2),f=a((t-n)/2),p=o((n-t)/2),d=a((n-t)/2);switch(i){case"XYX":e.set(s*u,l*h,l*f,s*c);break;case"YZY":e.set(l*f,s*u,l*h,s*c);break;case"ZXZ":e.set(l*h,l*f,s*u,s*c);break;case"XZX":e.set(s*u,l*d,l*p,s*c);break;case"YXY":e.set(l*p,s*u,l*d,s*c);break;case"ZYZ":e.set(l*d,l*p,s*u,s*c);break;default:console.warn("THREE.MathUtils: .setQuaternionFromProperEuler() encountered an unknown order: "+i)}}var ifr=Object.freeze({__proto__:null,DEG2RAD:P1,RAD2DEG:QP,generateUUID:Nl,clamp:Zo,euclideanModulo:Rht,mapLinear:Whr,inverseLerp:Yhr,lerp:UP,damp:jhr,pingpong:Xhr,smoothstep:$hr,smootherstep:Khr,randInt:Zhr,randFloat:Jhr,randFloatSpread:Qhr,seededRandom:tfr,degToRad:efr,radToDeg:rfr,isPowerOfTwo:Zut,ceilPowerOfTwo:zfe,floorPowerOfTwo:Ffe,setQuaternionFromProperEuler:nfr}),Lt=class{constructor(t=0,r=0){this.x=t,this.y=r}get width(){return this.x}set width(t){this.x=t}get height(){return this.y}set height(t){this.y=t}set(t,r){return this.x=t,this.y=r,this}setScalar(t){return this.x=t,this.y=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setComponent(t,r){switch(t){case 0:this.x=r;break;case 1:this.y=r;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y)}copy(t){return this.x=t.x,this.y=t.y,this}add(t,r){return r!==void 0?(console.warn("THREE.Vector2: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(t,r)):(this.x+=t.x,this.y+=t.y,this)}addScalar(t){return this.x+=t,this.y+=t,this}addVectors(t,r){return this.x=t.x+r.x,this.y=t.y+r.y,this}addScaledVector(t,r){return this.x+=t.x*r,this.y+=t.y*r,this}sub(t,r){return r!==void 0?(console.warn("THREE.Vector2: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),this.subVectors(t,r)):(this.x-=t.x,this.y-=t.y,this)}subScalar(t){return this.x-=t,this.y-=t,this}subVectors(t,r){return this.x=t.x-r.x,this.y=t.y-r.y,this}multiply(t){return this.x*=t.x,this.y*=t.y,this}multiplyScalar(t){return this.x*=t,this.y*=t,this}divide(t){return this.x/=t.x,this.y/=t.y,this}divideScalar(t){return this.multiplyScalar(1/t)}applyMatrix3(t){let r=this.x,n=this.y,i=t.elements;return this.x=i[0]*r+i[3]*n+i[6],this.y=i[1]*r+i[4]*n+i[7],this}min(t){return this.x=Math.min(this.x,t.x),this.y=Math.min(this.y,t.y),this}max(t){return this.x=Math.max(this.x,t.x),this.y=Math.max(this.y,t.y),this}clamp(t,r){return this.x=Math.max(t.x,Math.min(r.x,this.x)),this.y=Math.max(t.y,Math.min(r.y,this.y)),this}clampScalar(t,r){return this.x=Math.max(t,Math.min(r,this.x)),this.y=Math.max(t,Math.min(r,this.y)),this}clampLength(t,r){let n=this.length();return this.divideScalar(n||1).multiplyScalar(Math.max(t,Math.min(r,n)))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this}roundToZero(){return this.x=this.x<0?Math.ceil(this.x):Math.floor(this.x),this.y=this.y<0?Math.ceil(this.y):Math.floor(this.y),this}negate(){return this.x=-this.x,this.y=-this.y,this}dot(t){return this.x*t.x+this.y*t.y}cross(t){return this.x*t.y-this.y*t.x}lengthSq(){return this.x*this.x+this.y*this.y}length(){return Math.sqrt(this.x*this.x+this.y*this.y)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)}normalize(){return this.divideScalar(this.length()||1)}angle(){return Math.atan2(-this.y,-this.x)+Math.PI}distanceTo(t){return Math.sqrt(this.distanceToSquared(t))}distanceToSquared(t){let r=this.x-t.x,n=this.y-t.y;return r*r+n*n}manhattanDistanceTo(t){return Math.abs(this.x-t.x)+Math.abs(this.y-t.y)}setLength(t){return this.normalize().multiplyScalar(t)}lerp(t,r){return this.x+=(t.x-this.x)*r,this.y+=(t.y-this.y)*r,this}lerpVectors(t,r,n){return this.x=t.x+(r.x-t.x)*n,this.y=t.y+(r.y-t.y)*n,this}equals(t){return t.x===this.x&&t.y===this.y}fromArray(t,r=0){return this.x=t[r],this.y=t[r+1],this}toArray(t=[],r=0){return t[r]=this.x,t[r+1]=this.y,t}fromBufferAttribute(t,r,n){return n!==void 0&&console.warn("THREE.Vector2: offset has been removed from .fromBufferAttribute()."),this.x=t.getX(r),this.y=t.getY(r),this}rotateAround(t,r){let n=Math.cos(r),i=Math.sin(r),o=this.x-t.x,a=this.y-t.y;return this.x=o*n-a*i+t.x,this.y=o*i+a*n+t.y,this}random(){return this.x=Math.random(),this.y=Math.random(),this}*[Symbol.iterator](){yield this.x,yield this.y}};Lt.prototype.isVector2=!0;var ki=class{constructor(){this.elements=[1,0,0,0,1,0,0,0,1],arguments.length>0&&console.error("THREE.Matrix3: the constructor no longer reads arguments. use .set() instead.")}set(t,r,n,i,o,a,s,l,c){let u=this.elements;return u[0]=t,u[1]=i,u[2]=s,u[3]=r,u[4]=o,u[5]=l,u[6]=n,u[7]=a,u[8]=c,this}identity(){return this.set(1,0,0,0,1,0,0,0,1),this}copy(t){let r=this.elements,n=t.elements;return r[0]=n[0],r[1]=n[1],r[2]=n[2],r[3]=n[3],r[4]=n[4],r[5]=n[5],r[6]=n[6],r[7]=n[7],r[8]=n[8],this}extractBasis(t,r,n){return t.setFromMatrix3Column(this,0),r.setFromMatrix3Column(this,1),n.setFromMatrix3Column(this,2),this}setFromMatrix4(t){let r=t.elements;return this.set(r[0],r[4],r[8],r[1],r[5],r[9],r[2],r[6],r[10]),this}multiply(t){return this.multiplyMatrices(this,t)}premultiply(t){return this.multiplyMatrices(t,this)}multiplyMatrices(t,r){let n=t.elements,i=r.elements,o=this.elements,a=n[0],s=n[3],l=n[6],c=n[1],u=n[4],h=n[7],f=n[2],p=n[5],d=n[8],g=i[0],_=i[3],y=i[6],x=i[1],b=i[4],S=i[7],C=i[2],P=i[5],k=i[8];return o[0]=a*g+s*x+l*C,o[3]=a*_+s*b+l*P,o[6]=a*y+s*S+l*k,o[1]=c*g+u*x+h*C,o[4]=c*_+u*b+h*P,o[7]=c*y+u*S+h*k,o[2]=f*g+p*x+d*C,o[5]=f*_+p*b+d*P,o[8]=f*y+p*S+d*k,this}multiplyScalar(t){let r=this.elements;return r[0]*=t,r[3]*=t,r[6]*=t,r[1]*=t,r[4]*=t,r[7]*=t,r[2]*=t,r[5]*=t,r[8]*=t,this}determinant(){let t=this.elements,r=t[0],n=t[1],i=t[2],o=t[3],a=t[4],s=t[5],l=t[6],c=t[7],u=t[8];return r*a*u-r*s*c-n*o*u+n*s*l+i*o*c-i*a*l}invert(){let t=this.elements,r=t[0],n=t[1],i=t[2],o=t[3],a=t[4],s=t[5],l=t[6],c=t[7],u=t[8],h=u*a-s*c,f=s*l-u*o,p=c*o-a*l,d=r*h+n*f+i*p;if(d===0)return this.set(0,0,0,0,0,0,0,0,0);let g=1/d;return t[0]=h*g,t[1]=(i*c-u*n)*g,t[2]=(s*n-i*a)*g,t[3]=f*g,t[4]=(u*r-i*l)*g,t[5]=(i*o-s*r)*g,t[6]=p*g,t[7]=(n*l-c*r)*g,t[8]=(a*r-n*o)*g,this}transpose(){let t,r=this.elements;return t=r[1],r[1]=r[3],r[3]=t,t=r[2],r[2]=r[6],r[6]=t,t=r[5],r[5]=r[7],r[7]=t,this}getNormalMatrix(t){return this.setFromMatrix4(t).invert().transpose()}transposeIntoArray(t){let r=this.elements;return t[0]=r[0],t[1]=r[3],t[2]=r[6],t[3]=r[1],t[4]=r[4],t[5]=r[7],t[6]=r[2],t[7]=r[5],t[8]=r[8],this}setUvTransform(t,r,n,i,o,a,s){let l=Math.cos(o),c=Math.sin(o);return this.set(n*l,n*c,-n*(l*a+c*s)+a+t,-i*c,i*l,-i*(-c*a+l*s)+s+r,0,0,1),this}scale(t,r){let n=this.elements;return n[0]*=t,n[3]*=t,n[6]*=t,n[1]*=r,n[4]*=r,n[7]*=r,this}rotate(t){let r=Math.cos(t),n=Math.sin(t),i=this.elements,o=i[0],a=i[3],s=i[6],l=i[1],c=i[4],u=i[7];return i[0]=r*o+n*l,i[3]=r*a+n*c,i[6]=r*s+n*u,i[1]=-n*o+r*l,i[4]=-n*a+r*c,i[7]=-n*s+r*u,this}translate(t,r){let n=this.elements;return n[0]+=t*n[2],n[3]+=t*n[5],n[6]+=t*n[8],n[1]+=r*n[2],n[4]+=r*n[5],n[7]+=r*n[8],this}equals(t){let r=this.elements,n=t.elements;for(let i=0;i<9;i++)if(r[i]!==n[i])return!1;return!0}fromArray(t,r=0){for(let n=0;n<9;n++)this.elements[n]=t[n+r];return this}toArray(t=[],r=0){let n=this.elements;return t[r]=n[0],t[r+1]=n[1],t[r+2]=n[2],t[r+3]=n[3],t[r+4]=n[4],t[r+5]=n[5],t[r+6]=n[6],t[r+7]=n[7],t[r+8]=n[8],t}clone(){return new this.constructor().fromArray(this.elements)}};ki.prototype.isMatrix3=!0;function Bfe(e){for(let t=e.length-1;t>=0;--t)if(e[t]>65535)return!0;return!1}var ofr={Int8Array,Uint8Array,Uint8ClampedArray,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array};function B3(e,t){return new ofr[e](t)}function t6(e){return document.createElementNS("http://www.w3.org/1999/xhtml",e)}var Hfe={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074},nh={h:0,s:0,l:0},hV={h:0,s:0,l:0};function Gct(e,t,r){return r<0&&(r+=1),r>1&&(r-=1),r<1/6?e+(t-e)*6*r:r<1/2?t:r<2/3?e+(t-e)*6*(2/3-r):e}function U3(e){return e<.04045?e*.0773993808:Math.pow(e*.9478672986+.0521327014,2.4)}function Wct(e){return e<.0031308?e*12.92:1.055*Math.pow(e,.41666)-.055}var ne=class{constructor(t,r,n){return r===void 0&&n===void 0?this.set(t):this.setRGB(t,r,n)}set(t){return t&&t.isColor?this.copy(t):typeof t=="number"?this.setHex(t):typeof t=="string"&&this.setStyle(t),this}setScalar(t){return this.r=t,this.g=t,this.b=t,this}setHex(t){return t=Math.floor(t),this.r=(t>>16&255)/255,this.g=(t>>8&255)/255,this.b=(t&255)/255,this}setRGB(t,r,n){return this.r=t,this.g=r,this.b=n,this}setHSL(t,r,n){if(t=Rht(t,1),r=Zo(r,0,1),n=Zo(n,0,1),r===0)this.r=this.g=this.b=n;else{let i=n<=.5?n*(1+r):n+r-n*r,o=2*n-i;this.r=Gct(o,i,t+1/3),this.g=Gct(o,i,t),this.b=Gct(o,i,t-1/3)}return this}setStyle(t){function r(i){i!==void 0&&parseFloat(i)<1&&console.warn("THREE.Color: Alpha component of "+t+" will be ignored.")}let n;if(n=/^((?:rgb|hsl)a?)\(([^\)]*)\)/.exec(t)){let i,o=n[1],a=n[2];switch(o){case"rgb":case"rgba":if(i=/^\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(a))return this.r=Math.min(255,parseInt(i[1],10))/255,this.g=Math.min(255,parseInt(i[2],10))/255,this.b=Math.min(255,parseInt(i[3],10))/255,r(i[4]),this;if(i=/^\s*(\d+)\%\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(a))return this.r=Math.min(100,parseInt(i[1],10))/100,this.g=Math.min(100,parseInt(i[2],10))/100,this.b=Math.min(100,parseInt(i[3],10))/100,r(i[4]),this;break;case"hsl":case"hsla":if(i=/^\s*(\d*\.?\d+)\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(a)){let s=parseFloat(i[1])/360,l=parseInt(i[2],10)/100,c=parseInt(i[3],10)/100;return r(i[4]),this.setHSL(s,l,c)}break}}else if(n=/^\#([A-Fa-f\d]+)$/.exec(t)){let i=n[1],o=i.length;if(o===3)return this.r=parseInt(i.charAt(0)+i.charAt(0),16)/255,this.g=parseInt(i.charAt(1)+i.charAt(1),16)/255,this.b=parseInt(i.charAt(2)+i.charAt(2),16)/255,this;if(o===6)return this.r=parseInt(i.charAt(0)+i.charAt(1),16)/255,this.g=parseInt(i.charAt(2)+i.charAt(3),16)/255,this.b=parseInt(i.charAt(4)+i.charAt(5),16)/255,this}return t&&t.length>0?this.setColorName(t):this}setColorName(t){let r=Hfe[t.toLowerCase()];return r!==void 0?this.setHex(r):console.warn("THREE.Color: Unknown color "+t),this}clone(){return new this.constructor(this.r,this.g,this.b)}copy(t){return this.r=t.r,this.g=t.g,this.b=t.b,this}copySRGBToLinear(t){return this.r=U3(t.r),this.g=U3(t.g),this.b=U3(t.b),this}copyLinearToSRGB(t){return this.r=Wct(t.r),this.g=Wct(t.g),this.b=Wct(t.b),this}convertSRGBToLinear(){return this.copySRGBToLinear(this),this}convertLinearToSRGB(){return this.copyLinearToSRGB(this),this}getHex(){return this.r*255<<16^this.g*255<<8^this.b*255<<0}getHexString(){return("000000"+this.getHex().toString(16)).slice(-6)}getHSL(t){let r=this.r,n=this.g,i=this.b,o=Math.max(r,n,i),a=Math.min(r,n,i),s,l,c=(a+o)/2;if(a===o)s=0,l=0;else{let u=o-a;switch(l=c<=.5?u/(o+a):u/(2-o-a),o){case r:s=(n-i)/u+(n<i?6:0);break;case n:s=(i-r)/u+2;break;case i:s=(r-n)/u+4;break}s/=6}return t.h=s,t.s=l,t.l=c,t}getStyle(){return"rgb("+(this.r*255|0)+","+(this.g*255|0)+","+(this.b*255|0)+")"}offsetHSL(t,r,n){return this.getHSL(nh),nh.h+=t,nh.s+=r,nh.l+=n,this.setHSL(nh.h,nh.s,nh.l),this}add(t){return this.r+=t.r,this.g+=t.g,this.b+=t.b,this}addColors(t,r){return this.r=t.r+r.r,this.g=t.g+r.g,this.b=t.b+r.b,this}addScalar(t){return this.r+=t,this.g+=t,this.b+=t,this}sub(t){return this.r=Math.max(0,this.r-t.r),this.g=Math.max(0,this.g-t.g),this.b=Math.max(0,this.b-t.b),this}multiply(t){return this.r*=t.r,this.g*=t.g,this.b*=t.b,this}multiplyScalar(t){return this.r*=t,this.g*=t,this.b*=t,this}lerp(t,r){return this.r+=(t.r-this.r)*r,this.g+=(t.g-this.g)*r,this.b+=(t.b-this.b)*r,this}lerpColors(t,r,n){return this.r=t.r+(r.r-t.r)*n,this.g=t.g+(r.g-t.g)*n,this.b=t.b+(r.b-t.b)*n,this}lerpHSL(t,r){this.getHSL(nh),t.getHSL(hV);let n=UP(nh.h,hV.h,r),i=UP(nh.s,hV.s,r),o=UP(nh.l,hV.l,r);return this.setHSL(n,i,o),this}equals(t){return t.r===this.r&&t.g===this.g&&t.b===this.b}fromArray(t,r=0){return this.r=t[r],this.g=t[r+1],this.b=t[r+2],this}toArray(t=[],r=0){return t[r]=this.r,t[r+1]=this.g,t[r+2]=this.b,t}fromBufferAttribute(t,r){return this.r=t.getX(r),this.g=t.getY(r),this.b=t.getZ(r),t.normalized===!0&&(this.r/=255,this.g/=255,this.b/=255),this}toJSON(){return this.getHex()}};ne.NAMES=Hfe;ne.prototype.isColor=!0;ne.prototype.r=1;ne.prototype.g=1;ne.prototype.b=1;var v3,Kf=class{static getDataURL(t){if(/^data:/i.test(t.src)||typeof HTMLCanvasElement=="undefined")return t.src;let r;if(t instanceof HTMLCanvasElement)r=t;else{v3===void 0&&(v3=t6("canvas")),v3.width=t.width,v3.height=t.height;let n=v3.getContext("2d");t instanceof ImageData?n.putImageData(t,0,0):n.drawImage(t,0,0,t.width,t.height),r=v3}return r.width>2048||r.height>2048?(console.warn("THREE.ImageUtils.getDataURL: Image converted to jpg for performance reasons",t),r.toDataURL("image/jpeg",.6)):r.toDataURL("image/png")}static sRGBToLinear(t){if(typeof HTMLImageElement!="undefined"&&t instanceof HTMLImageElement||typeof HTMLCanvasElement!="undefined"&&t instanceof HTMLCanvasElement||typeof ImageBitmap!="undefined"&&t instanceof ImageBitmap){let r=t6("canvas");r.width=t.width,r.height=t.height;let n=r.getContext("2d");n.drawImage(t,0,0,t.width,t.height);let i=n.getImageData(0,0,t.width,t.height),o=i.data;for(let a=0;a<o.length;a++)o[a]=U3(o[a]/255)*255;return n.putImageData(i,0,0),r}else if(t.data){let r=t.data.slice(0);for(let n=0;n<r.length;n++)r instanceof Uint8Array||r instanceof Uint8ClampedArray?r[n]=Math.floor(U3(r[n]/255)*255):r[n]=U3(r[n]);return{data:r,width:t.width,height:t.height}}else return console.warn("THREE.ImageUtils.sRGBToLinear(): Unsupported image type. No color space conversion applied."),t}},afr=0,vi=class extends Us{constructor(t=vi.DEFAULT_IMAGE,r=vi.DEFAULT_MAPPING,n=Jo,i=Jo,o=ii,a=ox,s=Qo,l=Zd,c=1,u=Qd){super(),Object.defineProperty(this,"id",{value:afr++}),this.uuid=Nl(),this.name="",this.image=t,this.mipmaps=[],this.mapping=r,this.wrapS=n,this.wrapT=i,this.magFilter=o,this.minFilter=a,this.anisotropy=c,this.format=s,this.internalFormat=null,this.type=l,this.offset=new Lt(0,0),this.repeat=new Lt(1,1),this.center=new Lt(0,0),this.rotation=0,this.matrixAutoUpdate=!0,this.matrix=new ki,this.generateMipmaps=!0,this.premultiplyAlpha=!1,this.flipY=!0,this.unpackAlignment=4,this.encoding=u,this.userData={},this.version=0,this.onUpdate=null,this.isRenderTargetTexture=!1,this.needsPMREMUpdate=!1}updateMatrix(){this.matrix.setUvTransform(this.offset.x,this.offset.y,this.repeat.x,this.repeat.y,this.rotation,this.center.x,this.center.y)}clone(){return new this.constructor().copy(this)}copy(t){return this.name=t.name,this.image=t.image,this.mipmaps=t.mipmaps.slice(0),this.mapping=t.mapping,this.wrapS=t.wrapS,this.wrapT=t.wrapT,this.magFilter=t.magFilter,this.minFilter=t.minFilter,this.anisotropy=t.anisotropy,this.format=t.format,this.internalFormat=t.internalFormat,this.type=t.type,this.offset.copy(t.offset),this.repeat.copy(t.repeat),this.center.copy(t.center),this.rotation=t.rotation,this.matrixAutoUpdate=t.matrixAutoUpdate,this.matrix.copy(t.matrix),this.generateMipmaps=t.generateMipmaps,this.premultiplyAlpha=t.premultiplyAlpha,this.flipY=t.flipY,this.unpackAlignment=t.unpackAlignment,this.encoding=t.encoding,this.userData=JSON.parse(JSON.stringify(t.userData)),this}toJSON(t){let r=t===void 0||typeof t=="string";if(!r&&t.textures[this.uuid]!==void 0)return t.textures[this.uuid];let n={metadata:{version:4.5,type:"Texture",generator:"Texture.toJSON"},uuid:this.uuid,name:this.name,mapping:this.mapping,repeat:[this.repeat.x,this.repeat.y],offset:[this.offset.x,this.offset.y],center:[this.center.x,this.center.y],rotation:this.rotation,wrap:[this.wrapS,this.wrapT],format:this.format,type:this.type,encoding:this.encoding,minFilter:this.minFilter,magFilter:this.magFilter,anisotropy:this.anisotropy,flipY:this.flipY,premultiplyAlpha:this.premultiplyAlpha,unpackAlignment:this.unpackAlignment};if(this.image!==void 0){let i=this.image;if(i.uuid===void 0&&(i.uuid=Nl()),!r&&t.images[i.uuid]===void 0){let o;if(Array.isArray(i)){o=[];for(let a=0,s=i.length;a<s;a++)i[a].isDataTexture?o.push(Yct(i[a].image)):o.push(Yct(i[a]))}else o=Yct(i);t.images[i.uuid]={uuid:i.uuid,url:o}}n.image=i.uuid}return JSON.stringify(this.userData)!=="{}"&&(n.userData=this.userData),r||(t.textures[this.uuid]=n),n}dispose(){this.dispatchEvent({type:"dispose"})}transformUv(t){if(this.mapping!==XU)return t;if(t.applyMatrix3(this.matrix),t.x<0||t.x>1)switch(this.wrapS){case XP:t.x=t.x-Math.floor(t.x);break;case Jo:t.x=t.x<0?0:1;break;case $P:Math.abs(Math.floor(t.x)%2)===1?t.x=Math.ceil(t.x)-t.x:t.x=t.x-Math.floor(t.x);break}if(t.y<0||t.y>1)switch(this.wrapT){case XP:t.y=t.y-Math.floor(t.y);break;case Jo:t.y=t.y<0?0:1;break;case $P:Math.abs(Math.floor(t.y)%2)===1?t.y=Math.ceil(t.y)-t.y:t.y=t.y-Math.floor(t.y);break}return this.flipY&&(t.y=1-t.y),t}set needsUpdate(t){t===!0&&this.version++}};vi.DEFAULT_IMAGE=void 0;vi.DEFAULT_MAPPING=XU;vi.prototype.isTexture=!0;function Yct(e){return typeof HTMLImageElement!="undefined"&&e instanceof HTMLImageElement||typeof HTMLCanvasElement!="undefined"&&e instanceof HTMLCanvasElement||typeof ImageBitmap!="undefined"&&e instanceof ImageBitmap?Kf.getDataURL(e):e.data?{data:Array.prototype.slice.call(e.data),width:e.width,height:e.height,type:e.data.constructor.name}:(console.warn("THREE.Texture: Unable to serialize Texture."),{})}var en=class{constructor(t=0,r=0,n=0,i=1){this.x=t,this.y=r,this.z=n,this.w=i}get width(){return this.z}set width(t){this.z=t}get height(){return this.w}set height(t){this.w=t}set(t,r,n,i){return this.x=t,this.y=r,this.z=n,this.w=i,this}setScalar(t){return this.x=t,this.y=t,this.z=t,this.w=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setZ(t){return this.z=t,this}setW(t){return this.w=t,this}setComponent(t,r){switch(t){case 0:this.x=r;break;case 1:this.y=r;break;case 2:this.z=r;break;case 3:this.w=r;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;case 2:return this.z;case 3:return this.w;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y,this.z,this.w)}copy(t){return this.x=t.x,this.y=t.y,this.z=t.z,this.w=t.w!==void 0?t.w:1,this}add(t,r){return r!==void 0?(console.warn("THREE.Vector4: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(t,r)):(this.x+=t.x,this.y+=t.y,this.z+=t.z,this.w+=t.w,this)}addScalar(t){return this.x+=t,this.y+=t,this.z+=t,this.w+=t,this}addVectors(t,r){return this.x=t.x+r.x,this.y=t.y+r.y,this.z=t.z+r.z,this.w=t.w+r.w,this}addScaledVector(t,r){return this.x+=t.x*r,this.y+=t.y*r,this.z+=t.z*r,this.w+=t.w*r,this}sub(t,r){return r!==void 0?(console.warn("THREE.Vector4: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),this.subVectors(t,r)):(this.x-=t.x,this.y-=t.y,this.z-=t.z,this.w-=t.w,this)}subScalar(t){return this.x-=t,this.y-=t,this.z-=t,this.w-=t,this}subVectors(t,r){return this.x=t.x-r.x,this.y=t.y-r.y,this.z=t.z-r.z,this.w=t.w-r.w,this}multiply(t){return this.x*=t.x,this.y*=t.y,this.z*=t.z,this.w*=t.w,this}multiplyScalar(t){return this.x*=t,this.y*=t,this.z*=t,this.w*=t,this}applyMatrix4(t){let r=this.x,n=this.y,i=this.z,o=this.w,a=t.elements;return this.x=a[0]*r+a[4]*n+a[8]*i+a[12]*o,this.y=a[1]*r+a[5]*n+a[9]*i+a[13]*o,this.z=a[2]*r+a[6]*n+a[10]*i+a[14]*o,this.w=a[3]*r+a[7]*n+a[11]*i+a[15]*o,this}divideScalar(t){return this.multiplyScalar(1/t)}setAxisAngleFromQuaternion(t){this.w=2*Math.acos(t.w);let r=Math.sqrt(1-t.w*t.w);return r<1e-4?(this.x=1,this.y=0,this.z=0):(this.x=t.x/r,this.y=t.y/r,this.z=t.z/r),this}setAxisAngleFromRotationMatrix(t){let r,n,i,o,l=t.elements,c=l[0],u=l[4],h=l[8],f=l[1],p=l[5],d=l[9],g=l[2],_=l[6],y=l[10];if(Math.abs(u-f)<.01&&Math.abs(h-g)<.01&&Math.abs(d-_)<.01){if(Math.abs(u+f)<.1&&Math.abs(h+g)<.1&&Math.abs(d+_)<.1&&Math.abs(c+p+y-3)<.1)return this.set(1,0,0,0),this;r=Math.PI;let b=(c+1)/2,S=(p+1)/2,C=(y+1)/2,P=(u+f)/4,k=(h+g)/4,O=(d+_)/4;return b>S&&b>C?b<.01?(n=0,i=.707106781,o=.707106781):(n=Math.sqrt(b),i=P/n,o=k/n):S>C?S<.01?(n=.707106781,i=0,o=.707106781):(i=Math.sqrt(S),n=P/i,o=O/i):C<.01?(n=.707106781,i=.707106781,o=0):(o=Math.sqrt(C),n=k/o,i=O/o),this.set(n,i,o,r),this}let x=Math.sqrt((_-d)*(_-d)+(h-g)*(h-g)+(f-u)*(f-u));return Math.abs(x)<.001&&(x=1),this.x=(_-d)/x,this.y=(h-g)/x,this.z=(f-u)/x,this.w=Math.acos((c+p+y-1)/2),this}min(t){return this.x=Math.min(this.x,t.x),this.y=Math.min(this.y,t.y),this.z=Math.min(this.z,t.z),this.w=Math.min(this.w,t.w),this}max(t){return this.x=Math.max(this.x,t.x),this.y=Math.max(this.y,t.y),this.z=Math.max(this.z,t.z),this.w=Math.max(this.w,t.w),this}clamp(t,r){return this.x=Math.max(t.x,Math.min(r.x,this.x)),this.y=Math.max(t.y,Math.min(r.y,this.y)),this.z=Math.max(t.z,Math.min(r.z,this.z)),this.w=Math.max(t.w,Math.min(r.w,this.w)),this}clampScalar(t,r){return this.x=Math.max(t,Math.min(r,this.x)),this.y=Math.max(t,Math.min(r,this.y)),this.z=Math.max(t,Math.min(r,this.z)),this.w=Math.max(t,Math.min(r,this.w)),this}clampLength(t,r){let n=this.length();return this.divideScalar(n||1).multiplyScalar(Math.max(t,Math.min(r,n)))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this.z=Math.floor(this.z),this.w=Math.floor(this.w),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this.z=Math.ceil(this.z),this.w=Math.ceil(this.w),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this.z=Math.round(this.z),this.w=Math.round(this.w),this}roundToZero(){return this.x=this.x<0?Math.ceil(this.x):Math.floor(this.x),this.y=this.y<0?Math.ceil(this.y):Math.floor(this.y),this.z=this.z<0?Math.ceil(this.z):Math.floor(this.z),this.w=this.w<0?Math.ceil(this.w):Math.floor(this.w),this}negate(){return this.x=-this.x,this.y=-this.y,this.z=-this.z,this.w=-this.w,this}dot(t){return this.x*t.x+this.y*t.y+this.z*t.z+this.w*t.w}lengthSq(){return this.x*this.x+this.y*this.y+this.z*this.z+this.w*this.w}length(){return Math.sqrt(this.x*this.x+this.y*this.y+this.z*this.z+this.w*this.w)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)+Math.abs(this.z)+Math.abs(this.w)}normalize(){return this.divideScalar(this.length()||1)}setLength(t){return this.normalize().multiplyScalar(t)}lerp(t,r){return this.x+=(t.x-this.x)*r,this.y+=(t.y-this.y)*r,this.z+=(t.z-this.z)*r,this.w+=(t.w-this.w)*r,this}lerpVectors(t,r,n){return this.x=t.x+(r.x-t.x)*n,this.y=t.y+(r.y-t.y)*n,this.z=t.z+(r.z-t.z)*n,this.w=t.w+(r.w-t.w)*n,this}equals(t){return t.x===this.x&&t.y===this.y&&t.z===this.z&&t.w===this.w}fromArray(t,r=0){return this.x=t[r],this.y=t[r+1],this.z=t[r+2],this.w=t[r+3],this}toArray(t=[],r=0){return t[r]=this.x,t[r+1]=this.y,t[r+2]=this.z,t[r+3]=this.w,t}fromBufferAttribute(t,r,n){return n!==void 0&&console.warn("THREE.Vector4: offset has been removed from .fromBufferAttribute()."),this.x=t.getX(r),this.y=t.getY(r),this.z=t.getZ(r),this.w=t.getW(r),this}random(){return this.x=Math.random(),this.y=Math.random(),this.z=Math.random(),this.w=Math.random(),this}*[Symbol.iterator](){yield this.x,yield this.y,yield this.z,yield this.w}};en.prototype.isVector4=!0;var us=class extends Us{constructor(t,r,n={}){super(),this.width=t,this.height=r,this.depth=1,this.scissor=new en(0,0,t,r),this.scissorTest=!1,this.viewport=new en(0,0,t,r),this.texture=new vi(void 0,n.mapping,n.wrapS,n.wrapT,n.magFilter,n.minFilter,n.format,n.type,n.anisotropy,n.encoding),this.texture.isRenderTargetTexture=!0,this.texture.image={width:t,height:r,depth:1},this.texture.generateMipmaps=n.generateMipmaps!==void 0?n.generateMipmaps:!1,this.texture.internalFormat=n.internalFormat!==void 0?n.internalFormat:null,this.texture.minFilter=n.minFilter!==void 0?n.minFilter:ii,this.depthBuffer=n.depthBuffer!==void 0?n.depthBuffer:!0,this.stencilBuffer=n.stencilBuffer!==void 0?n.stencilBuffer:!1,this.depthTexture=n.depthTexture!==void 0?n.depthTexture:null}setTexture(t){t.image={width:this.width,height:this.height,depth:this.depth},this.texture=t}setSize(t,r,n=1){(this.width!==t||this.height!==r||this.depth!==n)&&(this.width=t,this.height=r,this.depth=n,this.texture.image.width=t,this.texture.image.height=r,this.texture.image.depth=n,this.dispose()),this.viewport.set(0,0,t,r),this.scissor.set(0,0,t,r)}clone(){return new this.constructor().copy(this)}copy(t){return this.width=t.width,this.height=t.height,this.depth=t.depth,this.viewport.copy(t.viewport),this.texture=t.texture.clone(),this.texture.image=Object.assign({},t.texture.image),this.depthBuffer=t.depthBuffer,this.stencilBuffer=t.stencilBuffer,this.depthTexture=t.depthTexture,this}dispose(){this.dispatchEvent({type:"dispose"})}};us.prototype.isWebGLRenderTarget=!0;var lU=class extends us{constructor(t,r,n){super(t,r);let i=this.texture;this.texture=[];for(let o=0;o<n;o++)this.texture[o]=i.clone()}setSize(t,r,n=1){if(this.width!==t||this.height!==r||this.depth!==n){this.width=t,this.height=r,this.depth=n;for(let i=0,o=this.texture.length;i<o;i++)this.texture[i].image.width=t,this.texture[i].image.height=r,this.texture[i].image.depth=n;this.dispose()}return this.viewport.set(0,0,t,r),this.scissor.set(0,0,t,r),this}copy(t){this.dispose(),this.width=t.width,this.height=t.height,this.depth=t.depth,this.viewport.set(0,0,this.width,this.height),this.scissor.set(0,0,this.width,this.height),this.depthBuffer=t.depthBuffer,this.stencilBuffer=t.stencilBuffer,this.depthTexture=t.depthTexture,this.texture.length=0;for(let r=0,n=t.texture.length;r<n;r++)this.texture[r]=t.texture[r].clone();return this}};lU.prototype.isWebGLMultipleRenderTargets=!0;var j3=class extends us{constructor(t,r,n={}){super(t,r,n),this.samples=4,this.ignoreDepthForMultisampleCopy=n.ignoreDepth!==void 0?n.ignoreDepth:!0,this.useRenderToTexture=n.useRenderToTexture!==void 0?n.useRenderToTexture:!1,this.useRenderbuffer=this.useRenderToTexture===!1}copy(t){return super.copy.call(this,t),this.samples=t.samples,this.useRenderToTexture=t.useRenderToTexture,this.useRenderbuffer=t.useRenderbuffer,this}};j3.prototype.isWebGLMultisampleRenderTarget=!0;var yi=class{constructor(t=0,r=0,n=0,i=1){this._x=t,this._y=r,this._z=n,this._w=i}static slerp(t,r,n,i){return console.warn("THREE.Quaternion: Static .slerp() has been deprecated. Use qm.slerpQuaternions( qa, qb, t ) instead."),n.slerpQuaternions(t,r,i)}static slerpFlat(t,r,n,i,o,a,s){let l=n[i+0],c=n[i+1],u=n[i+2],h=n[i+3],f=o[a+0],p=o[a+1],d=o[a+2],g=o[a+3];if(s===0){t[r+0]=l,t[r+1]=c,t[r+2]=u,t[r+3]=h;return}if(s===1){t[r+0]=f,t[r+1]=p,t[r+2]=d,t[r+3]=g;return}if(h!==g||l!==f||c!==p||u!==d){let _=1-s,y=l*f+c*p+u*d+h*g,x=y>=0?1:-1,b=1-y*y;if(b>Number.EPSILON){let C=Math.sqrt(b),P=Math.atan2(C,y*x);_=Math.sin(_*P)/C,s=Math.sin(s*P)/C}let S=s*x;if(l=l*_+f*S,c=c*_+p*S,u=u*_+d*S,h=h*_+g*S,_===1-s){let C=1/Math.sqrt(l*l+c*c+u*u+h*h);l*=C,c*=C,u*=C,h*=C}}t[r]=l,t[r+1]=c,t[r+2]=u,t[r+3]=h}static multiplyQuaternionsFlat(t,r,n,i,o,a){let s=n[i],l=n[i+1],c=n[i+2],u=n[i+3],h=o[a],f=o[a+1],p=o[a+2],d=o[a+3];return t[r]=s*d+u*h+l*p-c*f,t[r+1]=l*d+u*f+c*h-s*p,t[r+2]=c*d+u*p+s*f-l*h,t[r+3]=u*d-s*h-l*f-c*p,t}get x(){return this._x}set x(t){this._x=t,this._onChangeCallback()}get y(){return this._y}set y(t){this._y=t,this._onChangeCallback()}get z(){return this._z}set z(t){this._z=t,this._onChangeCallback()}get w(){return this._w}set w(t){this._w=t,this._onChangeCallback()}set(t,r,n,i){return this._x=t,this._y=r,this._z=n,this._w=i,this._onChangeCallback(),this}clone(){return new this.constructor(this._x,this._y,this._z,this._w)}copy(t){return this._x=t.x,this._y=t.y,this._z=t.z,this._w=t.w,this._onChangeCallback(),this}setFromEuler(t,r){if(!(t&&t.isEuler))throw new Error("THREE.Quaternion: .setFromEuler() now expects an Euler rotation rather than a Vector3 and order.");let n=t._x,i=t._y,o=t._z,a=t._order,s=Math.cos,l=Math.sin,c=s(n/2),u=s(i/2),h=s(o/2),f=l(n/2),p=l(i/2),d=l(o/2);switch(a){case"XYZ":this._x=f*u*h+c*p*d,this._y=c*p*h-f*u*d,this._z=c*u*d+f*p*h,this._w=c*u*h-f*p*d;break;case"YXZ":this._x=f*u*h+c*p*d,this._y=c*p*h-f*u*d,this._z=c*u*d-f*p*h,this._w=c*u*h+f*p*d;break;case"ZXY":this._x=f*u*h-c*p*d,this._y=c*p*h+f*u*d,this._z=c*u*d+f*p*h,this._w=c*u*h-f*p*d;break;case"ZYX":this._x=f*u*h-c*p*d,this._y=c*p*h+f*u*d,this._z=c*u*d-f*p*h,this._w=c*u*h+f*p*d;break;case"YZX":this._x=f*u*h+c*p*d,this._y=c*p*h+f*u*d,this._z=c*u*d-f*p*h,this._w=c*u*h-f*p*d;break;case"XZY":this._x=f*u*h-c*p*d,this._y=c*p*h-f*u*d,this._z=c*u*d+f*p*h,this._w=c*u*h+f*p*d;break;default:console.warn("THREE.Quaternion: .setFromEuler() encountered an unknown order: "+a)}return r!==!1&&this._onChangeCallback(),this}setFromAxisAngle(t,r){let n=r/2,i=Math.sin(n);return this._x=t.x*i,this._y=t.y*i,this._z=t.z*i,this._w=Math.cos(n),this._onChangeCallback(),this}setFromRotationMatrix(t){let r=t.elements,n=r[0],i=r[4],o=r[8],a=r[1],s=r[5],l=r[9],c=r[2],u=r[6],h=r[10],f=n+s+h;if(f>0){let p=.5/Math.sqrt(f+1);this._w=.25/p,this._x=(u-l)*p,this._y=(o-c)*p,this._z=(a-i)*p}else if(n>s&&n>h){let p=2*Math.sqrt(1+n-s-h);this._w=(u-l)/p,this._x=.25*p,this._y=(i+a)/p,this._z=(o+c)/p}else if(s>h){let p=2*Math.sqrt(1+s-n-h);this._w=(o-c)/p,this._x=(i+a)/p,this._y=.25*p,this._z=(l+u)/p}else{let p=2*Math.sqrt(1+h-n-s);this._w=(a-i)/p,this._x=(o+c)/p,this._y=(l+u)/p,this._z=.25*p}return this._onChangeCallback(),this}setFromUnitVectors(t,r){let n=t.dot(r)+1;return n<Number.EPSILON?(n=0,Math.abs(t.x)>Math.abs(t.z)?(this._x=-t.y,this._y=t.x,this._z=0,this._w=n):(this._x=0,this._y=-t.z,this._z=t.y,this._w=n)):(this._x=t.y*r.z-t.z*r.y,this._y=t.z*r.x-t.x*r.z,this._z=t.x*r.y-t.y*r.x,this._w=n),this.normalize()}angleTo(t){return 2*Math.acos(Math.abs(Zo(this.dot(t),-1,1)))}rotateTowards(t,r){let n=this.angleTo(t);if(n===0)return this;let i=Math.min(1,r/n);return this.slerp(t,i),this}identity(){return this.set(0,0,0,1)}invert(){return this.conjugate()}conjugate(){return this._x*=-1,this._y*=-1,this._z*=-1,this._onChangeCallback(),this}dot(t){return this._x*t._x+this._y*t._y+this._z*t._z+this._w*t._w}lengthSq(){return this._x*this._x+this._y*this._y+this._z*this._z+this._w*this._w}length(){return Math.sqrt(this._x*this._x+this._y*this._y+this._z*this._z+this._w*this._w)}normalize(){let t=this.length();return t===0?(this._x=0,this._y=0,this._z=0,this._w=1):(t=1/t,this._x=this._x*t,this._y=this._y*t,this._z=this._z*t,this._w=this._w*t),this._onChangeCallback(),this}multiply(t,r){return r!==void 0?(console.warn("THREE.Quaternion: .multiply() now only accepts one argument. Use .multiplyQuaternions( a, b ) instead."),this.multiplyQuaternions(t,r)):this.multiplyQuaternions(this,t)}premultiply(t){return this.multiplyQuaternions(t,this)}multiplyQuaternions(t,r){let n=t._x,i=t._y,o=t._z,a=t._w,s=r._x,l=r._y,c=r._z,u=r._w;return this._x=n*u+a*s+i*c-o*l,this._y=i*u+a*l+o*s-n*c,this._z=o*u+a*c+n*l-i*s,this._w=a*u-n*s-i*l-o*c,this._onChangeCallback(),this}slerp(t,r){if(r===0)return this;if(r===1)return this.copy(t);let n=this._x,i=this._y,o=this._z,a=this._w,s=a*t._w+n*t._x+i*t._y+o*t._z;if(s<0?(this._w=-t._w,this._x=-t._x,this._y=-t._y,this._z=-t._z,s=-s):this.copy(t),s>=1)return this._w=a,this._x=n,this._y=i,this._z=o,this;let l=1-s*s;if(l<=Number.EPSILON){let p=1-r;return this._w=p*a+r*this._w,this._x=p*n+r*this._x,this._y=p*i+r*this._y,this._z=p*o+r*this._z,this.normalize(),this._onChangeCallback(),this}let c=Math.sqrt(l),u=Math.atan2(c,s),h=Math.sin((1-r)*u)/c,f=Math.sin(r*u)/c;return this._w=a*h+this._w*f,this._x=n*h+this._x*f,this._y=i*h+this._y*f,this._z=o*h+this._z*f,this._onChangeCallback(),this}slerpQuaternions(t,r,n){return this.copy(t).slerp(r,n)}random(){let t=Math.random(),r=Math.sqrt(1-t),n=Math.sqrt(t),i=2*Math.PI*Math.random(),o=2*Math.PI*Math.random();return this.set(r*Math.cos(i),n*Math.sin(o),n*Math.cos(o),r*Math.sin(i))}equals(t){return t._x===this._x&&t._y===this._y&&t._z===this._z&&t._w===this._w}fromArray(t,r=0){return this._x=t[r],this._y=t[r+1],this._z=t[r+2],this._w=t[r+3],this._onChangeCallback(),this}toArray(t=[],r=0){return t[r]=this._x,t[r+1]=this._y,t[r+2]=this._z,t[r+3]=this._w,t}fromBufferAttribute(t,r){return this._x=t.getX(r),this._y=t.getY(r),this._z=t.getZ(r),this._w=t.getW(r),this}_onChange(t){return this._onChangeCallback=t,this}_onChangeCallback(){}};yi.prototype.isQuaternion=!0;var j=class{constructor(t=0,r=0,n=0){this.x=t,this.y=r,this.z=n}set(t,r,n){return n===void 0&&(n=this.z),this.x=t,this.y=r,this.z=n,this}setScalar(t){return this.x=t,this.y=t,this.z=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setZ(t){return this.z=t,this}setComponent(t,r){switch(t){case 0:this.x=r;break;case 1:this.y=r;break;case 2:this.z=r;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;case 2:return this.z;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y,this.z)}copy(t){return this.x=t.x,this.y=t.y,this.z=t.z,this}add(t,r){return r!==void 0?(console.warn("THREE.Vector3: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(t,r)):(this.x+=t.x,this.y+=t.y,this.z+=t.z,this)}addScalar(t){return this.x+=t,this.y+=t,this.z+=t,this}addVectors(t,r){return this.x=t.x+r.x,this.y=t.y+r.y,this.z=t.z+r.z,this}addScaledVector(t,r){return this.x+=t.x*r,this.y+=t.y*r,this.z+=t.z*r,this}sub(t,r){return r!==void 0?(console.warn("THREE.Vector3: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),this.subVectors(t,r)):(this.x-=t.x,this.y-=t.y,this.z-=t.z,this)}subScalar(t){return this.x-=t,this.y-=t,this.z-=t,this}subVectors(t,r){return this.x=t.x-r.x,this.y=t.y-r.y,this.z=t.z-r.z,this}multiply(t,r){return r!==void 0?(console.warn("THREE.Vector3: .multiply() now only accepts one argument. Use .multiplyVectors( a, b ) instead."),this.multiplyVectors(t,r)):(this.x*=t.x,this.y*=t.y,this.z*=t.z,this)}multiplyScalar(t){return this.x*=t,this.y*=t,this.z*=t,this}multiplyVectors(t,r){return this.x=t.x*r.x,this.y=t.y*r.y,this.z=t.z*r.z,this}applyEuler(t){return t&&t.isEuler||console.error("THREE.Vector3: .applyEuler() now expects an Euler rotation rather than a Vector3 and order."),this.applyQuaternion(yue.setFromEuler(t))}applyAxisAngle(t,r){return this.applyQuaternion(yue.setFromAxisAngle(t,r))}applyMatrix3(t){let r=this.x,n=this.y,i=this.z,o=t.elements;return this.x=o[0]*r+o[3]*n+o[6]*i,this.y=o[1]*r+o[4]*n+o[7]*i,this.z=o[2]*r+o[5]*n+o[8]*i,this}applyNormalMatrix(t){return this.applyMatrix3(t).normalize()}applyMatrix4(t){let r=this.x,n=this.y,i=this.z,o=t.elements,a=1/(o[3]*r+o[7]*n+o[11]*i+o[15]);return this.x=(o[0]*r+o[4]*n+o[8]*i+o[12])*a,this.y=(o[1]*r+o[5]*n+o[9]*i+o[13])*a,this.z=(o[2]*r+o[6]*n+o[10]*i+o[14])*a,this}applyQuaternion(t){let r=this.x,n=this.y,i=this.z,o=t.x,a=t.y,s=t.z,l=t.w,c=l*r+a*i-s*n,u=l*n+s*r-o*i,h=l*i+o*n-a*r,f=-o*r-a*n-s*i;return this.x=c*l+f*-o+u*-s-h*-a,this.y=u*l+f*-a+h*-o-c*-s,this.z=h*l+f*-s+c*-a-u*-o,this}project(t){return this.applyMatrix4(t.matrixWorldInverse).applyMatrix4(t.projectionMatrix)}unproject(t){return this.applyMatrix4(t.projectionMatrixInverse).applyMatrix4(t.matrixWorld)}transformDirection(t){let r=this.x,n=this.y,i=this.z,o=t.elements;return this.x=o[0]*r+o[4]*n+o[8]*i,this.y=o[1]*r+o[5]*n+o[9]*i,this.z=o[2]*r+o[6]*n+o[10]*i,this.normalize()}divide(t){return this.x/=t.x,this.y/=t.y,this.z/=t.z,this}divideScalar(t){return this.multiplyScalar(1/t)}min(t){return this.x=Math.min(this.x,t.x),this.y=Math.min(this.y,t.y),this.z=Math.min(this.z,t.z),this}max(t){return this.x=Math.max(this.x,t.x),this.y=Math.max(this.y,t.y),this.z=Math.max(this.z,t.z),this}clamp(t,r){return this.x=Math.max(t.x,Math.min(r.x,this.x)),this.y=Math.max(t.y,Math.min(r.y,this.y)),this.z=Math.max(t.z,Math.min(r.z,this.z)),this}clampScalar(t,r){return this.x=Math.max(t,Math.min(r,this.x)),this.y=Math.max(t,Math.min(r,this.y)),this.z=Math.max(t,Math.min(r,this.z)),this}clampLength(t,r){let n=this.length();return this.divideScalar(n||1).multiplyScalar(Math.max(t,Math.min(r,n)))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this.z=Math.floor(this.z),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this.z=Math.ceil(this.z),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this.z=Math.round(this.z),this}roundToZero(){return this.x=this.x<0?Math.ceil(this.x):Math.floor(this.x),this.y=this.y<0?Math.ceil(this.y):Math.floor(this.y),this.z=this.z<0?Math.ceil(this.z):Math.floor(this.z),this}negate(){return this.x=-this.x,this.y=-this.y,this.z=-this.z,this}dot(t){return this.x*t.x+this.y*t.y+this.z*t.z}lengthSq(){return this.x*this.x+this.y*this.y+this.z*this.z}length(){return Math.sqrt(this.x*this.x+this.y*this.y+this.z*this.z)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)+Math.abs(this.z)}normalize(){return this.divideScalar(this.length()||1)}setLength(t){return this.normalize().multiplyScalar(t)}lerp(t,r){return this.x+=(t.x-this.x)*r,this.y+=(t.y-this.y)*r,this.z+=(t.z-this.z)*r,this}lerpVectors(t,r,n){return this.x=t.x+(r.x-t.x)*n,this.y=t.y+(r.y-t.y)*n,this.z=t.z+(r.z-t.z)*n,this}cross(t,r){return r!==void 0?(console.warn("THREE.Vector3: .cross() now only accepts one argument. Use .crossVectors( a, b ) instead."),this.crossVectors(t,r)):this.crossVectors(this,t)}crossVectors(t,r){let n=t.x,i=t.y,o=t.z,a=r.x,s=r.y,l=r.z;return this.x=i*l-o*s,this.y=o*a-n*l,this.z=n*s-i*a,this}projectOnVector(t){let r=t.lengthSq();if(r===0)return this.set(0,0,0);let n=t.dot(this)/r;return this.copy(t).multiplyScalar(n)}projectOnPlane(t){return jct.copy(this).projectOnVector(t),this.sub(jct)}reflect(t){return this.sub(jct.copy(t).multiplyScalar(2*this.dot(t)))}angleTo(t){let r=Math.sqrt(this.lengthSq()*t.lengthSq());if(r===0)return Math.PI/2;let n=this.dot(t)/r;return Math.acos(Zo(n,-1,1))}distanceTo(t){return Math.sqrt(this.distanceToSquared(t))}distanceToSquared(t){let r=this.x-t.x,n=this.y-t.y,i=this.z-t.z;return r*r+n*n+i*i}manhattanDistanceTo(t){return Math.abs(this.x-t.x)+Math.abs(this.y-t.y)+Math.abs(this.z-t.z)}setFromSpherical(t){return this.setFromSphericalCoords(t.radius,t.phi,t.theta)}setFromSphericalCoords(t,r,n){let i=Math.sin(r)*t;return this.x=i*Math.sin(n),this.y=Math.cos(r)*t,this.z=i*Math.cos(n),this}setFromCylindrical(t){return this.setFromCylindricalCoords(t.radius,t.theta,t.y)}setFromCylindricalCoords(t,r,n){return this.x=t*Math.sin(r),this.y=n,this.z=t*Math.cos(r),this}setFromMatrixPosition(t){let r=t.elements;return this.x=r[12],this.y=r[13],this.z=r[14],this}setFromMatrixScale(t){let r=this.setFromMatrixColumn(t,0).length(),n=this.setFromMatrixColumn(t,1).length(),i=this.setFromMatrixColumn(t,2).length();return this.x=r,this.y=n,this.z=i,this}setFromMatrixColumn(t,r){return this.fromArray(t.elements,r*4)}setFromMatrix3Column(t,r){return this.fromArray(t.elements,r*3)}equals(t){return t.x===this.x&&t.y===this.y&&t.z===this.z}fromArray(t,r=0){return this.x=t[r],this.y=t[r+1],this.z=t[r+2],this}toArray(t=[],r=0){return t[r]=this.x,t[r+1]=this.y,t[r+2]=this.z,t}fromBufferAttribute(t,r,n){return n!==void 0&&console.warn("THREE.Vector3: offset has been removed from .fromBufferAttribute()."),this.x=t.getX(r),this.y=t.getY(r),this.z=t.getZ(r),this}random(){return this.x=Math.random(),this.y=Math.random(),this.z=Math.random(),this}randomDirection(){let t=(Math.random()-.5)*2,r=Math.random()*Math.PI*2,n=Math.sqrt(1-TI(t,2));return this.x=n*Math.cos(r),this.y=n*Math.sin(r),this.z=t,this}*[Symbol.iterator](){yield this.x,yield this.y,yield this.z}};j.prototype.isVector3=!0;var jct=new j,yue=new yi,ta=class{constructor(t=new j(1/0,1/0,1/0),r=new j(-1/0,-1/0,-1/0)){this.min=t,this.max=r}set(t,r){return this.min.copy(t),this.max.copy(r),this}setFromArray(t){let r=1/0,n=1/0,i=1/0,o=-1/0,a=-1/0,s=-1/0;for(let l=0,c=t.length;l<c;l+=3){let u=t[l],h=t[l+1],f=t[l+2];u<r&&(r=u),h<n&&(n=h),f<i&&(i=f),u>o&&(o=u),h>a&&(a=h),f>s&&(s=f)}return this.min.set(r,n,i),this.max.set(o,a,s),this}setFromBufferAttribute(t){let r=1/0,n=1/0,i=1/0,o=-1/0,a=-1/0,s=-1/0;for(let l=0,c=t.count;l<c;l++){let u=t.getX(l),h=t.getY(l),f=t.getZ(l);u<r&&(r=u),h<n&&(n=h),f<i&&(i=f),u>o&&(o=u),h>a&&(a=h),f>s&&(s=f)}return this.min.set(r,n,i),this.max.set(o,a,s),this}setFromPoints(t){this.makeEmpty();for(let r=0,n=t.length;r<n;r++)this.expandByPoint(t[r]);return this}setFromCenterAndSize(t,r){let n=m1.copy(r).multiplyScalar(.5);return this.min.copy(t).sub(n),this.max.copy(t).add(n),this}setFromObject(t,r=!1){return this.makeEmpty(),this.expandByObject(t,r)}clone(){return new this.constructor().copy(this)}copy(t){return this.min.copy(t.min),this.max.copy(t.max),this}makeEmpty(){return this.min.x=this.min.y=this.min.z=1/0,this.max.x=this.max.y=this.max.z=-1/0,this}isEmpty(){return this.max.x<this.min.x||this.max.y<this.min.y||this.max.z<this.min.z}getCenter(t){return this.isEmpty()?t.set(0,0,0):t.addVectors(this.min,this.max).multiplyScalar(.5)}getSize(t){return this.isEmpty()?t.set(0,0,0):t.subVectors(this.max,this.min)}expandByPoint(t){return this.min.min(t),this.max.max(t),this}expandByVector(t){return this.min.sub(t),this.max.add(t),this}expandByScalar(t){return this.min.addScalar(-t),this.max.addScalar(t),this}expandByObject(t,r=!1){t.updateWorldMatrix(!1,!1);let n=t.geometry;if(n!==void 0)if(r&&n.attributes!=null&&n.attributes.position!==void 0){let o=n.attributes.position;for(let a=0,s=o.count;a<s;a++)m1.fromBufferAttribute(o,a).applyMatrix4(t.matrixWorld),this.expandByPoint(m1)}else n.boundingBox===null&&n.computeBoundingBox(),Xct.copy(n.boundingBox),Xct.applyMatrix4(t.matrixWorld),this.union(Xct);let i=t.children;for(let o=0,a=i.length;o<a;o++)this.expandByObject(i[o],r);return this}containsPoint(t){return!(t.x<this.min.x||t.x>this.max.x||t.y<this.min.y||t.y>this.max.y||t.z<this.min.z||t.z>this.max.z)}containsBox(t){return this.min.x<=t.min.x&&t.max.x<=this.max.x&&this.min.y<=t.min.y&&t.max.y<=this.max.y&&this.min.z<=t.min.z&&t.max.z<=this.max.z}getParameter(t,r){return r.set((t.x-this.min.x)/(this.max.x-this.min.x),(t.y-this.min.y)/(this.max.y-this.min.y),(t.z-this.min.z)/(this.max.z-this.min.z))}intersectsBox(t){return!(t.max.x<this.min.x||t.min.x>this.max.x||t.max.y<this.min.y||t.min.y>this.max.y||t.max.z<this.min.z||t.min.z>this.max.z)}intersectsSphere(t){return this.clampPoint(t.center,m1),m1.distanceToSquared(t.center)<=t.radius*t.radius}intersectsPlane(t){let r,n;return t.normal.x>0?(r=t.normal.x*this.min.x,n=t.normal.x*this.max.x):(r=t.normal.x*this.max.x,n=t.normal.x*this.min.x),t.normal.y>0?(r+=t.normal.y*this.min.y,n+=t.normal.y*this.max.y):(r+=t.normal.y*this.max.y,n+=t.normal.y*this.min.y),t.normal.z>0?(r+=t.normal.z*this.min.z,n+=t.normal.z*this.max.z):(r+=t.normal.z*this.max.z,n+=t.normal.z*this.min.z),r<=-t.constant&&n>=-t.constant}intersectsTriangle(t){if(this.isEmpty())return!1;this.getCenter(LP),fV.subVectors(this.max,LP),x3.subVectors(t.a,LP),b3.subVectors(t.b,LP),w3.subVectors(t.c,LP),P0.subVectors(b3,x3),I0.subVectors(w3,b3),g1.subVectors(x3,w3);let r=[0,-P0.z,P0.y,0,-I0.z,I0.y,0,-g1.z,g1.y,P0.z,0,-P0.x,I0.z,0,-I0.x,g1.z,0,-g1.x,-P0.y,P0.x,0,-I0.y,I0.x,0,-g1.y,g1.x,0];return!$ct(r,x3,b3,w3,fV)||(r=[1,0,0,0,1,0,0,0,1],!$ct(r,x3,b3,w3,fV))?!1:(pV.crossVectors(P0,I0),r=[pV.x,pV.y,pV.z],$ct(r,x3,b3,w3,fV))}clampPoint(t,r){return r.copy(t).clamp(this.min,this.max)}distanceToPoint(t){return m1.copy(t).clamp(this.min,this.max).sub(t).length()}getBoundingSphere(t){return this.getCenter(t.center),t.radius=this.getSize(m1).length()*.5,t}intersect(t){return this.min.max(t.min),this.max.min(t.max),this.isEmpty()&&this.makeEmpty(),this}union(t){return this.min.min(t.min),this.max.max(t.max),this}applyMatrix4(t){return this.isEmpty()?this:(Vd[0].set(this.min.x,this.min.y,this.min.z).applyMatrix4(t),Vd[1].set(this.min.x,this.min.y,this.max.z).applyMatrix4(t),Vd[2].set(this.min.x,this.max.y,this.min.z).applyMatrix4(t),Vd[3].set(this.min.x,this.max.y,this.max.z).applyMatrix4(t),Vd[4].set(this.max.x,this.min.y,this.min.z).applyMatrix4(t),Vd[5].set(this.max.x,this.min.y,this.max.z).applyMatrix4(t),Vd[6].set(this.max.x,this.max.y,this.min.z).applyMatrix4(t),Vd[7].set(this.max.x,this.max.y,this.max.z).applyMatrix4(t),this.setFromPoints(Vd),this)}translate(t){return this.min.add(t),this.max.add(t),this}equals(t){return t.min.equals(this.min)&&t.max.equals(this.max)}};ta.prototype.isBox3=!0;var Vd=[new j,new j,new j,new j,new j,new j,new j,new j],m1=new j,Xct=new ta,x3=new j,b3=new j,w3=new j,P0=new j,I0=new j,g1=new j,LP=new j,fV=new j,pV=new j,_1=new j;function $ct(e,t,r,n,i){for(let o=0,a=e.length-3;o<=a;o+=3){_1.fromArray(e,o);let s=i.x*Math.abs(_1.x)+i.y*Math.abs(_1.y)+i.z*Math.abs(_1.z),l=t.dot(_1),c=r.dot(_1),u=n.dot(_1);if(Math.max(-Math.max(l,c,u),Math.min(l,c,u))>s)return!1}return!0}var sfr=new ta,vue=new j,dV=new j,Kct=new j,Zf=class{constructor(t=new j,r=-1){this.center=t,this.radius=r}set(t,r){return this.center.copy(t),this.radius=r,this}setFromPoints(t,r){let n=this.center;r!==void 0?n.copy(r):sfr.setFromPoints(t).getCenter(n);let i=0;for(let o=0,a=t.length;o<a;o++)i=Math.max(i,n.distanceToSquared(t[o]));return this.radius=Math.sqrt(i),this}copy(t){return this.center.copy(t.center),this.radius=t.radius,this}isEmpty(){return this.radius<0}makeEmpty(){return this.center.set(0,0,0),this.radius=-1,this}containsPoint(t){return t.distanceToSquared(this.center)<=this.radius*this.radius}distanceToPoint(t){return t.distanceTo(this.center)-this.radius}intersectsSphere(t){let r=this.radius+t.radius;return t.center.distanceToSquared(this.center)<=r*r}intersectsBox(t){return t.intersectsSphere(this)}intersectsPlane(t){return Math.abs(t.distanceToPoint(this.center))<=this.radius}clampPoint(t,r){let n=this.center.distanceToSquared(t);return r.copy(t),n>this.radius*this.radius&&(r.sub(this.center).normalize(),r.multiplyScalar(this.radius).add(this.center)),r}getBoundingBox(t){return this.isEmpty()?(t.makeEmpty(),t):(t.set(this.center,this.center),t.expandByScalar(this.radius),t)}applyMatrix4(t){return this.center.applyMatrix4(t),this.radius=this.radius*t.getMaxScaleOnAxis(),this}translate(t){return this.center.add(t),this}expandByPoint(t){Kct.subVectors(t,this.center);let r=Kct.lengthSq();if(r>this.radius*this.radius){let n=Math.sqrt(r),i=(n-this.radius)*.5;this.center.add(Kct.multiplyScalar(i/n)),this.radius+=i}return this}union(t){return this.center.equals(t.center)===!0?dV.set(0,0,1).multiplyScalar(t.radius):dV.subVectors(t.center,this.center).normalize().multiplyScalar(t.radius),this.expandByPoint(vue.copy(t.center).add(dV)),this.expandByPoint(vue.copy(t.center).sub(dV)),this}equals(t){return t.center.equals(this.center)&&t.radius===this.radius}clone(){return new this.constructor().copy(this)}},Ud=new j,Zct=new j,mV=new j,L0=new j,Jct=new j,gV=new j,Qct=new j,Jf=class{constructor(t=new j,r=new j(0,0,-1)){this.origin=t,this.direction=r}set(t,r){return this.origin.copy(t),this.direction.copy(r),this}copy(t){return this.origin.copy(t.origin),this.direction.copy(t.direction),this}at(t,r){return r.copy(this.direction).multiplyScalar(t).add(this.origin)}lookAt(t){return this.direction.copy(t).sub(this.origin).normalize(),this}recast(t){return this.origin.copy(this.at(t,Ud)),this}closestPointToPoint(t,r){r.subVectors(t,this.origin);let n=r.dot(this.direction);return n<0?r.copy(this.origin):r.copy(this.direction).multiplyScalar(n).add(this.origin)}distanceToPoint(t){return Math.sqrt(this.distanceSqToPoint(t))}distanceSqToPoint(t){let r=Ud.subVectors(t,this.origin).dot(this.direction);return r<0?this.origin.distanceToSquared(t):(Ud.copy(this.direction).multiplyScalar(r).add(this.origin),Ud.distanceToSquared(t))}distanceSqToSegment(t,r,n,i){Zct.copy(t).add(r).multiplyScalar(.5),mV.copy(r).sub(t).normalize(),L0.copy(this.origin).sub(Zct);let o=t.distanceTo(r)*.5,a=-this.direction.dot(mV),s=L0.dot(this.direction),l=-L0.dot(mV),c=L0.lengthSq(),u=Math.abs(1-a*a),h,f,p,d;if(u>0)if(h=a*l-s,f=a*s-l,d=o*u,h>=0)if(f>=-d)if(f<=d){let g=1/u;h*=g,f*=g,p=h*(h+a*f+2*s)+f*(a*h+f+2*l)+c}else f=o,h=Math.max(0,-(a*f+s)),p=-h*h+f*(f+2*l)+c;else f=-o,h=Math.max(0,-(a*f+s)),p=-h*h+f*(f+2*l)+c;else f<=-d?(h=Math.max(0,-(-a*o+s)),f=h>0?-o:Math.min(Math.max(-o,-l),o),p=-h*h+f*(f+2*l)+c):f<=d?(h=0,f=Math.min(Math.max(-o,-l),o),p=f*(f+2*l)+c):(h=Math.max(0,-(a*o+s)),f=h>0?o:Math.min(Math.max(-o,-l),o),p=-h*h+f*(f+2*l)+c);else f=a>0?-o:o,h=Math.max(0,-(a*f+s)),p=-h*h+f*(f+2*l)+c;return n&&n.copy(this.direction).multiplyScalar(h).add(this.origin),i&&i.copy(mV).multiplyScalar(f).add(Zct),p}intersectSphere(t,r){Ud.subVectors(t.center,this.origin);let n=Ud.dot(this.direction),i=Ud.dot(Ud)-n*n,o=t.radius*t.radius;if(i>o)return null;let a=Math.sqrt(o-i),s=n-a,l=n+a;return s<0&&l<0?null:s<0?this.at(l,r):this.at(s,r)}intersectsSphere(t){return this.distanceSqToPoint(t.center)<=t.radius*t.radius}distanceToPlane(t){let r=t.normal.dot(this.direction);if(r===0)return t.distanceToPoint(this.origin)===0?0:null;let n=-(this.origin.dot(t.normal)+t.constant)/r;return n>=0?n:null}intersectPlane(t,r){let n=this.distanceToPlane(t);return n===null?null:this.at(n,r)}intersectsPlane(t){let r=t.distanceToPoint(this.origin);return r===0||t.normal.dot(this.direction)*r<0}intersectBox(t,r){let n,i,o,a,s,l,c=1/this.direction.x,u=1/this.direction.y,h=1/this.direction.z,f=this.origin;return c>=0?(n=(t.min.x-f.x)*c,i=(t.max.x-f.x)*c):(n=(t.max.x-f.x)*c,i=(t.min.x-f.x)*c),u>=0?(o=(t.min.y-f.y)*u,a=(t.max.y-f.y)*u):(o=(t.max.y-f.y)*u,a=(t.min.y-f.y)*u),n>a||o>i||((o>n||n!==n)&&(n=o),(a<i||i!==i)&&(i=a),h>=0?(s=(t.min.z-f.z)*h,l=(t.max.z-f.z)*h):(s=(t.max.z-f.z)*h,l=(t.min.z-f.z)*h),n>l||s>i)||((s>n||n!==n)&&(n=s),(l<i||i!==i)&&(i=l),i<0)?null:this.at(n>=0?n:i,r)}intersectsBox(t){return this.intersectBox(t,Ud)!==null}intersectTriangle(t,r,n,i,o){Jct.subVectors(r,t),gV.subVectors(n,t),Qct.crossVectors(Jct,gV);let a=this.direction.dot(Qct),s;if(a>0){if(i)return null;s=1}else if(a<0)s=-1,a=-a;else return null;L0.subVectors(this.origin,t);let l=s*this.direction.dot(gV.crossVectors(L0,gV));if(l<0)return null;let c=s*this.direction.dot(Jct.cross(L0));if(c<0||l+c>a)return null;let u=-s*L0.dot(Qct);return u<0?null:this.at(u/a,o)}applyMatrix4(t){return this.origin.applyMatrix4(t),this.direction.transformDirection(t),this}equals(t){return t.origin.equals(this.origin)&&t.direction.equals(this.direction)}clone(){return new this.constructor().copy(this)}},Me=class{constructor(){this.elements=[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1],arguments.length>0&&console.error("THREE.Matrix4: the constructor no longer reads arguments. use .set() instead.")}set(t,r,n,i,o,a,s,l,c,u,h,f,p,d,g,_){let y=this.elements;return y[0]=t,y[4]=r,y[8]=n,y[12]=i,y[1]=o,y[5]=a,y[9]=s,y[13]=l,y[2]=c,y[6]=u,y[10]=h,y[14]=f,y[3]=p,y[7]=d,y[11]=g,y[15]=_,this}identity(){return this.set(1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1),this}clone(){return new Me().fromArray(this.elements)}copy(t){let r=this.elements,n=t.elements;return r[0]=n[0],r[1]=n[1],r[2]=n[2],r[3]=n[3],r[4]=n[4],r[5]=n[5],r[6]=n[6],r[7]=n[7],r[8]=n[8],r[9]=n[9],r[10]=n[10],r[11]=n[11],r[12]=n[12],r[13]=n[13],r[14]=n[14],r[15]=n[15],this}copyPosition(t){let r=this.elements,n=t.elements;return r[12]=n[12],r[13]=n[13],r[14]=n[14],this}setFromMatrix3(t){let r=t.elements;return this.set(r[0],r[3],r[6],0,r[1],r[4],r[7],0,r[2],r[5],r[8],0,0,0,0,1),this}extractBasis(t,r,n){return t.setFromMatrixColumn(this,0),r.setFromMatrixColumn(this,1),n.setFromMatrixColumn(this,2),this}makeBasis(t,r,n){return this.set(t.x,r.x,n.x,0,t.y,r.y,n.y,0,t.z,r.z,n.z,0,0,0,0,1),this}extractRotation(t){let r=this.elements,n=t.elements,i=1/S3.setFromMatrixColumn(t,0).length(),o=1/S3.setFromMatrixColumn(t,1).length(),a=1/S3.setFromMatrixColumn(t,2).length();return r[0]=n[0]*i,r[1]=n[1]*i,r[2]=n[2]*i,r[3]=0,r[4]=n[4]*o,r[5]=n[5]*o,r[6]=n[6]*o,r[7]=0,r[8]=n[8]*a,r[9]=n[9]*a,r[10]=n[10]*a,r[11]=0,r[12]=0,r[13]=0,r[14]=0,r[15]=1,this}makeRotationFromEuler(t){t&&t.isEuler||console.error("THREE.Matrix4: .makeRotationFromEuler() now expects a Euler rotation rather than a Vector3 and order.");let r=this.elements,n=t.x,i=t.y,o=t.z,a=Math.cos(n),s=Math.sin(n),l=Math.cos(i),c=Math.sin(i),u=Math.cos(o),h=Math.sin(o);if(t.order==="XYZ"){let f=a*u,p=a*h,d=s*u,g=s*h;r[0]=l*u,r[4]=-l*h,r[8]=c,r[1]=p+d*c,r[5]=f-g*c,r[9]=-s*l,r[2]=g-f*c,r[6]=d+p*c,r[10]=a*l}else if(t.order==="YXZ"){let f=l*u,p=l*h,d=c*u,g=c*h;r[0]=f+g*s,r[4]=d*s-p,r[8]=a*c,r[1]=a*h,r[5]=a*u,r[9]=-s,r[2]=p*s-d,r[6]=g+f*s,r[10]=a*l}else if(t.order==="ZXY"){let f=l*u,p=l*h,d=c*u,g=c*h;r[0]=f-g*s,r[4]=-a*h,r[8]=d+p*s,r[1]=p+d*s,r[5]=a*u,r[9]=g-f*s,r[2]=-a*c,r[6]=s,r[10]=a*l}else if(t.order==="ZYX"){let f=a*u,p=a*h,d=s*u,g=s*h;r[0]=l*u,r[4]=d*c-p,r[8]=f*c+g,r[1]=l*h,r[5]=g*c+f,r[9]=p*c-d,r[2]=-c,r[6]=s*l,r[10]=a*l}else if(t.order==="YZX"){let f=a*l,p=a*c,d=s*l,g=s*c;r[0]=l*u,r[4]=g-f*h,r[8]=d*h+p,r[1]=h,r[5]=a*u,r[9]=-s*u,r[2]=-c*u,r[6]=p*h+d,r[10]=f-g*h}else if(t.order==="XZY"){let f=a*l,p=a*c,d=s*l,g=s*c;r[0]=l*u,r[4]=-h,r[8]=c*u,r[1]=f*h+g,r[5]=a*u,r[9]=p*h-d,r[2]=d*h-p,r[6]=s*u,r[10]=g*h+f}return r[3]=0,r[7]=0,r[11]=0,r[12]=0,r[13]=0,r[14]=0,r[15]=1,this}makeRotationFromQuaternion(t){return this.compose(lfr,t,cfr)}lookAt(t,r,n){let i=this.elements;return kl.subVectors(t,r),kl.lengthSq()===0&&(kl.z=1),kl.normalize(),k0.crossVectors(n,kl),k0.lengthSq()===0&&(Math.abs(n.z)===1?kl.x+=1e-4:kl.z+=1e-4,kl.normalize(),k0.crossVectors(n,kl)),k0.normalize(),_V.crossVectors(kl,k0),i[0]=k0.x,i[4]=_V.x,i[8]=kl.x,i[1]=k0.y,i[5]=_V.y,i[9]=kl.y,i[2]=k0.z,i[6]=_V.z,i[10]=kl.z,this}multiply(t,r){return r!==void 0?(console.warn("THREE.Matrix4: .multiply() now only accepts one argument. Use .multiplyMatrices( a, b ) instead."),this.multiplyMatrices(t,r)):this.multiplyMatrices(this,t)}premultiply(t){return this.multiplyMatrices(t,this)}multiplyMatrices(t,r){let n=t.elements,i=r.elements,o=this.elements,a=n[0],s=n[4],l=n[8],c=n[12],u=n[1],h=n[5],f=n[9],p=n[13],d=n[2],g=n[6],_=n[10],y=n[14],x=n[3],b=n[7],S=n[11],C=n[15],P=i[0],k=i[4],O=i[8],D=i[12],B=i[1],I=i[5],L=i[9],R=i[13],F=i[2],z=i[6],U=i[10],W=i[14],Z=i[3],rt=i[7],ot=i[11],st=i[15];return o[0]=a*P+s*B+l*F+c*Z,o[4]=a*k+s*I+l*z+c*rt,o[8]=a*O+s*L+l*U+c*ot,o[12]=a*D+s*R+l*W+c*st,o[1]=u*P+h*B+f*F+p*Z,o[5]=u*k+h*I+f*z+p*rt,o[9]=u*O+h*L+f*U+p*ot,o[13]=u*D+h*R+f*W+p*st,o[2]=d*P+g*B+_*F+y*Z,o[6]=d*k+g*I+_*z+y*rt,o[10]=d*O+g*L+_*U+y*ot,o[14]=d*D+g*R+_*W+y*st,o[3]=x*P+b*B+S*F+C*Z,o[7]=x*k+b*I+S*z+C*rt,o[11]=x*O+b*L+S*U+C*ot,o[15]=x*D+b*R+S*W+C*st,this}multiplyScalar(t){let r=this.elements;return r[0]*=t,r[4]*=t,r[8]*=t,r[12]*=t,r[1]*=t,r[5]*=t,r[9]*=t,r[13]*=t,r[2]*=t,r[6]*=t,r[10]*=t,r[14]*=t,r[3]*=t,r[7]*=t,r[11]*=t,r[15]*=t,this}determinant(){let t=this.elements,r=t[0],n=t[4],i=t[8],o=t[12],a=t[1],s=t[5],l=t[9],c=t[13],u=t[2],h=t[6],f=t[10],p=t[14],d=t[3],g=t[7],_=t[11],y=t[15];return d*(+o*l*h-i*c*h-o*s*f+n*c*f+i*s*p-n*l*p)+g*(+r*l*p-r*c*f+o*a*f-i*a*p+i*c*u-o*l*u)+_*(+r*c*h-r*s*p-o*a*h+n*a*p+o*s*u-n*c*u)+y*(-i*s*u-r*l*h+r*s*f+i*a*h-n*a*f+n*l*u)}transpose(){let t=this.elements,r;return r=t[1],t[1]=t[4],t[4]=r,r=t[2],t[2]=t[8],t[8]=r,r=t[6],t[6]=t[9],t[9]=r,r=t[3],t[3]=t[12],t[12]=r,r=t[7],t[7]=t[13],t[13]=r,r=t[11],t[11]=t[14],t[14]=r,this}setPosition(t,r,n){let i=this.elements;return t.isVector3?(i[12]=t.x,i[13]=t.y,i[14]=t.z):(i[12]=t,i[13]=r,i[14]=n),this}invert(){let t=this.elements,r=t[0],n=t[1],i=t[2],o=t[3],a=t[4],s=t[5],l=t[6],c=t[7],u=t[8],h=t[9],f=t[10],p=t[11],d=t[12],g=t[13],_=t[14],y=t[15],x=h*_*c-g*f*c+g*l*p-s*_*p-h*l*y+s*f*y,b=d*f*c-u*_*c-d*l*p+a*_*p+u*l*y-a*f*y,S=u*g*c-d*h*c+d*s*p-a*g*p-u*s*y+a*h*y,C=d*h*l-u*g*l-d*s*f+a*g*f+u*s*_-a*h*_,P=r*x+n*b+i*S+o*C;if(P===0)return this.set(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0);let k=1/P;return t[0]=x*k,t[1]=(g*f*o-h*_*o-g*i*p+n*_*p+h*i*y-n*f*y)*k,t[2]=(s*_*o-g*l*o+g*i*c-n*_*c-s*i*y+n*l*y)*k,t[3]=(h*l*o-s*f*o-h*i*c+n*f*c+s*i*p-n*l*p)*k,t[4]=b*k,t[5]=(u*_*o-d*f*o+d*i*p-r*_*p-u*i*y+r*f*y)*k,t[6]=(d*l*o-a*_*o-d*i*c+r*_*c+a*i*y-r*l*y)*k,t[7]=(a*f*o-u*l*o+u*i*c-r*f*c-a*i*p+r*l*p)*k,t[8]=S*k,t[9]=(d*h*o-u*g*o-d*n*p+r*g*p+u*n*y-r*h*y)*k,t[10]=(a*g*o-d*s*o+d*n*c-r*g*c-a*n*y+r*s*y)*k,t[11]=(u*s*o-a*h*o-u*n*c+r*h*c+a*n*p-r*s*p)*k,t[12]=C*k,t[13]=(u*g*i-d*h*i+d*n*f-r*g*f-u*n*_+r*h*_)*k,t[14]=(d*s*i-a*g*i-d*n*l+r*g*l+a*n*_-r*s*_)*k,t[15]=(a*h*i-u*s*i+u*n*l-r*h*l-a*n*f+r*s*f)*k,this}scale(t){let r=this.elements,n=t.x,i=t.y,o=t.z;return r[0]*=n,r[4]*=i,r[8]*=o,r[1]*=n,r[5]*=i,r[9]*=o,r[2]*=n,r[6]*=i,r[10]*=o,r[3]*=n,r[7]*=i,r[11]*=o,this}getMaxScaleOnAxis(){let t=this.elements,r=t[0]*t[0]+t[1]*t[1]+t[2]*t[2],n=t[4]*t[4]+t[5]*t[5]+t[6]*t[6],i=t[8]*t[8]+t[9]*t[9]+t[10]*t[10];return Math.sqrt(Math.max(r,n,i))}makeTranslation(t,r,n){return this.set(1,0,0,t,0,1,0,r,0,0,1,n,0,0,0,1),this}makeRotationX(t){let r=Math.cos(t),n=Math.sin(t);return this.set(1,0,0,0,0,r,-n,0,0,n,r,0,0,0,0,1),this}makeRotationY(t){let r=Math.cos(t),n=Math.sin(t);return this.set(r,0,n,0,0,1,0,0,-n,0,r,0,0,0,0,1),this}makeRotationZ(t){let r=Math.cos(t),n=Math.sin(t);return this.set(r,-n,0,0,n,r,0,0,0,0,1,0,0,0,0,1),this}makeRotationAxis(t,r){let n=Math.cos(r),i=Math.sin(r),o=1-n,a=t.x,s=t.y,l=t.z,c=o*a,u=o*s;return this.set(c*a+n,c*s-i*l,c*l+i*s,0,c*s+i*l,u*s+n,u*l-i*a,0,c*l-i*s,u*l+i*a,o*l*l+n,0,0,0,0,1),this}makeScale(t,r,n){return this.set(t,0,0,0,0,r,0,0,0,0,n,0,0,0,0,1),this}makeShear(t,r,n,i,o,a){return this.set(1,n,o,0,t,1,a,0,r,i,1,0,0,0,0,1),this}compose(t,r,n){let i=this.elements,o=r._x,a=r._y,s=r._z,l=r._w,c=o+o,u=a+a,h=s+s,f=o*c,p=o*u,d=o*h,g=a*u,_=a*h,y=s*h,x=l*c,b=l*u,S=l*h,C=n.x,P=n.y,k=n.z;return i[0]=(1-(g+y))*C,i[1]=(p+S)*C,i[2]=(d-b)*C,i[3]=0,i[4]=(p-S)*P,i[5]=(1-(f+y))*P,i[6]=(_+x)*P,i[7]=0,i[8]=(d+b)*k,i[9]=(_-x)*k,i[10]=(1-(f+g))*k,i[11]=0,i[12]=t.x,i[13]=t.y,i[14]=t.z,i[15]=1,this}decompose(t,r,n){let i=this.elements,o=S3.set(i[0],i[1],i[2]).length(),a=S3.set(i[4],i[5],i[6]).length(),s=S3.set(i[8],i[9],i[10]).length();this.determinant()<0&&(o=-o),t.x=i[12],t.y=i[13],t.z=i[14],ih.copy(this);let c=1/o,u=1/a,h=1/s;return ih.elements[0]*=c,ih.elements[1]*=c,ih.elements[2]*=c,ih.elements[4]*=u,ih.elements[5]*=u,ih.elements[6]*=u,ih.elements[8]*=h,ih.elements[9]*=h,ih.elements[10]*=h,r.setFromRotationMatrix(ih),n.x=o,n.y=a,n.z=s,this}makePerspective(t,r,n,i,o,a){a===void 0&&console.warn("THREE.Matrix4: .makePerspective() has been redefined and has a new signature. Please check the docs.");let s=this.elements,l=2*o/(r-t),c=2*o/(n-i),u=(r+t)/(r-t),h=(n+i)/(n-i),f=-(a+o)/(a-o),p=-2*a*o/(a-o);return s[0]=l,s[4]=0,s[8]=u,s[12]=0,s[1]=0,s[5]=c,s[9]=h,s[13]=0,s[2]=0,s[6]=0,s[10]=f,s[14]=p,s[3]=0,s[7]=0,s[11]=-1,s[15]=0,this}makeOrthographic(t,r,n,i,o,a){let s=this.elements,l=1/(r-t),c=1/(n-i),u=1/(a-o),h=(r+t)*l,f=(n+i)*c,p=(a+o)*u;return s[0]=2*l,s[4]=0,s[8]=0,s[12]=-h,s[1]=0,s[5]=2*c,s[9]=0,s[13]=-f,s[2]=0,s[6]=0,s[10]=-2*u,s[14]=-p,s[3]=0,s[7]=0,s[11]=0,s[15]=1,this}equals(t){let r=this.elements,n=t.elements;for(let i=0;i<16;i++)if(r[i]!==n[i])return!1;return!0}fromArray(t,r=0){for(let n=0;n<16;n++)this.elements[n]=t[n+r];return this}toArray(t=[],r=0){let n=this.elements;return t[r]=n[0],t[r+1]=n[1],t[r+2]=n[2],t[r+3]=n[3],t[r+4]=n[4],t[r+5]=n[5],t[r+6]=n[6],t[r+7]=n[7],t[r+8]=n[8],t[r+9]=n[9],t[r+10]=n[10],t[r+11]=n[11],t[r+12]=n[12],t[r+13]=n[13],t[r+14]=n[14],t[r+15]=n[15],t}};Me.prototype.isMatrix4=!0;var S3=new j,ih=new Me,lfr=new j(0,0,0),cfr=new j(1,1,1),k0=new j,_V=new j,kl=new j,xue=new Me,bue=new yi,tm=class{constructor(t=0,r=0,n=0,i=tm.DefaultOrder){this._x=t,this._y=r,this._z=n,this._order=i}get x(){return this._x}set x(t){this._x=t,this._onChangeCallback()}get y(){return this._y}set y(t){this._y=t,this._onChangeCallback()}get z(){return this._z}set z(t){this._z=t,this._onChangeCallback()}get order(){return this._order}set order(t){this._order=t,this._onChangeCallback()}set(t,r,n,i=this._order){return this._x=t,this._y=r,this._z=n,this._order=i,this._onChangeCallback(),this}clone(){return new this.constructor(this._x,this._y,this._z,this._order)}copy(t){return this._x=t._x,this._y=t._y,this._z=t._z,this._order=t._order,this._onChangeCallback(),this}setFromRotationMatrix(t,r=this._order,n=!0){let i=t.elements,o=i[0],a=i[4],s=i[8],l=i[1],c=i[5],u=i[9],h=i[2],f=i[6],p=i[10];switch(r){case"XYZ":this._y=Math.asin(Zo(s,-1,1)),Math.abs(s)<.9999999?(this._x=Math.atan2(-u,p),this._z=Math.atan2(-a,o)):(this._x=Math.atan2(f,c),this._z=0);break;case"YXZ":this._x=Math.asin(-Zo(u,-1,1)),Math.abs(u)<.9999999?(this._y=Math.atan2(s,p),this._z=Math.atan2(l,c)):(this._y=Math.atan2(-h,o),this._z=0);break;case"ZXY":this._x=Math.asin(Zo(f,-1,1)),Math.abs(f)<.9999999?(this._y=Math.atan2(-h,p),this._z=Math.atan2(-a,c)):(this._y=0,this._z=Math.atan2(l,o));break;case"ZYX":this._y=Math.asin(-Zo(h,-1,1)),Math.abs(h)<.9999999?(this._x=Math.atan2(f,p),this._z=Math.atan2(l,o)):(this._x=0,this._z=Math.atan2(-a,c));break;case"YZX":this._z=Math.asin(Zo(l,-1,1)),Math.abs(l)<.9999999?(this._x=Math.atan2(-u,c),this._y=Math.atan2(-h,o)):(this._x=0,this._y=Math.atan2(s,p));break;case"XZY":this._z=Math.asin(-Zo(a,-1,1)),Math.abs(a)<.9999999?(this._x=Math.atan2(f,c),this._y=Math.atan2(s,o)):(this._x=Math.atan2(-u,p),this._y=0);break;default:console.warn("THREE.Euler: .setFromRotationMatrix() encountered an unknown order: "+r)}return this._order=r,n===!0&&this._onChangeCallback(),this}setFromQuaternion(t,r,n){return xue.makeRotationFromQuaternion(t),this.setFromRotationMatrix(xue,r,n)}setFromVector3(t,r=this._order){return this.set(t.x,t.y,t.z,r)}reorder(t){return bue.setFromEuler(this),this.setFromQuaternion(bue,t)}equals(t){return t._x===this._x&&t._y===this._y&&t._z===this._z&&t._order===this._order}fromArray(t){return this._x=t[0],this._y=t[1],this._z=t[2],t[3]!==void 0&&(this._order=t[3]),this._onChangeCallback(),this}toArray(t=[],r=0){return t[r]=this._x,t[r+1]=this._y,t[r+2]=this._z,t[r+3]=this._order,t}toVector3(t){return t?t.set(this._x,this._y,this._z):new j(this._x,this._y,this._z)}_onChange(t){return this._onChangeCallback=t,this}_onChangeCallback(){}};tm.prototype.isEuler=!0;tm.DefaultOrder="XYZ";tm.RotationOrders=["XYZ","YZX","ZXY","XZY","YXZ","ZYX"];var X3=class{constructor(){this.mask=1}set(t){this.mask=(1<<t|0)>>>0}enable(t){this.mask|=1<<t|0}enableAll(){this.mask=-1}toggle(t){this.mask^=1<<t|0}disable(t){this.mask&=~(1<<t|0)}disableAll(){this.mask=0}test(t){return(this.mask&t.mask)!==0}isEnabled(t){return(this.mask&(1<<t|0))!==0}},ufr=0,wue=new j,M3=new yi,qd=new Me,yV=new j,kP=new j,hfr=new j,ffr=new yi,Sue=new j(1,0,0),Mue=new j(0,1,0),Eue=new j(0,0,1),pfr={type:"added"},Tue={type:"removed"},or=class extends Us{constructor(){super(),Object.defineProperty(this,"id",{value:ufr++}),this.uuid=Nl(),this.name="",this.type="Object3D",this.parent=null,this.children=[],this.up=or.DefaultUp.clone();let t=new j,r=new tm,n=new yi,i=new j(1,1,1);function o(){n.setFromEuler(r,!1)}function a(){r.setFromQuaternion(n,void 0,!1)}r._onChange(o),n._onChange(a),Object.defineProperties(this,{position:{configurable:!0,enumerable:!0,value:t},rotation:{configurable:!0,enumerable:!0,value:r},quaternion:{configurable:!0,enumerable:!0,value:n},scale:{configurable:!0,enumerable:!0,value:i},modelViewMatrix:{value:new Me},normalMatrix:{value:new ki}}),this.matrix=new Me,this.matrixWorld=new Me,this.matrixAutoUpdate=or.DefaultMatrixAutoUpdate,this.matrixWorldNeedsUpdate=!1,this.layers=new X3,this.visible=!0,this.castShadow=!1,this.receiveShadow=!1,this.frustumCulled=!0,this.renderOrder=0,this.animations=[],this.userData={}}onBeforeRender(){}onAfterRender(){}applyMatrix4(t){this.matrixAutoUpdate&&this.updateMatrix(),this.matrix.premultiply(t),this.matrix.decompose(this.position,this.quaternion,this.scale)}applyQuaternion(t){return this.quaternion.premultiply(t),this}setRotationFromAxisAngle(t,r){this.quaternion.setFromAxisAngle(t,r)}setRotationFromEuler(t){this.quaternion.setFromEuler(t,!0)}setRotationFromMatrix(t){this.quaternion.setFromRotationMatrix(t)}setRotationFromQuaternion(t){this.quaternion.copy(t)}rotateOnAxis(t,r){return M3.setFromAxisAngle(t,r),this.quaternion.multiply(M3),this}rotateOnWorldAxis(t,r){return M3.setFromAxisAngle(t,r),this.quaternion.premultiply(M3),this}rotateX(t){return this.rotateOnAxis(Sue,t)}rotateY(t){return this.rotateOnAxis(Mue,t)}rotateZ(t){return this.rotateOnAxis(Eue,t)}translateOnAxis(t,r){return wue.copy(t).applyQuaternion(this.quaternion),this.position.add(wue.multiplyScalar(r)),this}translateX(t){return this.translateOnAxis(Sue,t)}translateY(t){return this.translateOnAxis(Mue,t)}translateZ(t){return this.translateOnAxis(Eue,t)}localToWorld(t){return t.applyMatrix4(this.matrixWorld)}worldToLocal(t){return t.applyMatrix4(qd.copy(this.matrixWorld).invert())}lookAt(t,r,n){t.isVector3?yV.copy(t):yV.set(t,r,n);let i=this.parent;this.updateWorldMatrix(!0,!1),kP.setFromMatrixPosition(this.matrixWorld),this.isCamera||this.isLight?qd.lookAt(kP,yV,this.up):qd.lookAt(yV,kP,this.up),this.quaternion.setFromRotationMatrix(qd),i&&(qd.extractRotation(i.matrixWorld),M3.setFromRotationMatrix(qd),this.quaternion.premultiply(M3.invert()))}add(t){if(arguments.length>1){for(let r=0;r<arguments.length;r++)this.add(arguments[r]);return this}return t===this?(console.error("THREE.Object3D.add: object can't be added as a child of itself.",t),this):(t&&t.isObject3D?(t.parent!==null&&t.parent.remove(t),t.parent=this,this.children.push(t),t.dispatchEvent(pfr)):console.error("THREE.Object3D.add: object not an instance of THREE.Object3D.",t),this)}remove(t){if(arguments.length>1){for(let n=0;n<arguments.length;n++)this.remove(arguments[n]);return this}let r=this.children.indexOf(t);return r!==-1&&(t.parent=null,this.children.splice(r,1),t.dispatchEvent(Tue)),this}removeFromParent(){let t=this.parent;return t!==null&&t.remove(this),this}clear(){for(let t=0;t<this.children.length;t++){let r=this.children[t];r.parent=null,r.dispatchEvent(Tue)}return this.children.length=0,this}attach(t){return this.updateWorldMatrix(!0,!1),qd.copy(this.matrixWorld).invert(),t.parent!==null&&(t.parent.updateWorldMatrix(!0,!1),qd.multiply(t.parent.matrixWorld)),t.applyMatrix4(qd),this.add(t),t.updateWorldMatrix(!1,!0),this}getObjectById(t){return this.getObjectByProperty("id",t)}getObjectByName(t){return this.getObjectByProperty("name",t)}getObjectByProperty(t,r){if(this[t]===r)return this;for(let n=0,i=this.children.length;n<i;n++){let a=this.children[n].getObjectByProperty(t,r);if(a!==void 0)return a}}getWorldPosition(t){return this.updateWorldMatrix(!0,!1),t.setFromMatrixPosition(this.matrixWorld)}getWorldQuaternion(t){return this.updateWorldMatrix(!0,!1),this.matrixWorld.decompose(kP,t,hfr),t}getWorldScale(t){return this.updateWorldMatrix(!0,!1),this.matrixWorld.decompose(kP,ffr,t),t}getWorldDirection(t){this.updateWorldMatrix(!0,!1);let r=this.matrixWorld.elements;return t.set(r[8],r[9],r[10]).normalize()}raycast(){}traverse(t){t(this);let r=this.children;for(let n=0,i=r.length;n<i;n++)r[n].traverse(t)}traverseVisible(t){if(this.visible===!1)return;t(this);let r=this.children;for(let n=0,i=r.length;n<i;n++)r[n].traverseVisible(t)}traverseAncestors(t){let r=this.parent;r!==null&&(t(r),r.traverseAncestors(t))}updateMatrix(){this.matrix.compose(this.position,this.quaternion,this.scale),this.matrixWorldNeedsUpdate=!0}updateMatrixWorld(t){this.matrixAutoUpdate&&this.updateMatrix(),(this.matrixWorldNeedsUpdate||t)&&(this.parent===null?this.matrixWorld.copy(this.matrix):this.matrixWorld.multiplyMatrices(this.parent.matrixWorld,this.matrix),this.matrixWorldNeedsUpdate=!1,t=!0);let r=this.children;for(let n=0,i=r.length;n<i;n++)r[n].updateMatrixWorld(t)}updateWorldMatrix(t,r){let n=this.parent;if(t===!0&&n!==null&&n.updateWorldMatrix(!0,!1),this.matrixAutoUpdate&&this.updateMatrix(),this.parent===null?this.matrixWorld.copy(this.matrix):this.matrixWorld.multiplyMatrices(this.parent.matrixWorld,this.matrix),r===!0){let i=this.children;for(let o=0,a=i.length;o<a;o++)i[o].updateWorldMatrix(!1,!0)}}toJSON(t){let r=t===void 0||typeof t=="string",n={};r&&(t={geometries:{},materials:{},textures:{},images:{},shapes:{},skeletons:{},animations:{}},n.metadata={version:4.5,type:"Object",generator:"Object3D.toJSON"});let i={};i.uuid=this.uuid,i.type=this.type,this.name!==""&&(i.name=this.name),this.castShadow===!0&&(i.castShadow=!0),this.receiveShadow===!0&&(i.receiveShadow=!0),this.visible===!1&&(i.visible=!1),this.frustumCulled===!1&&(i.frustumCulled=!1),this.renderOrder!==0&&(i.renderOrder=this.renderOrder),JSON.stringify(this.userData)!=="{}"&&(i.userData=this.userData),i.layers=this.layers.mask,i.matrix=this.matrix.toArray(),this.matrixAutoUpdate===!1&&(i.matrixAutoUpdate=!1),this.isInstancedMesh&&(i.type="InstancedMesh",i.count=this.count,i.instanceMatrix=this.instanceMatrix.toJSON(),this.instanceColor!==null&&(i.instanceColor=this.instanceColor.toJSON()));function o(s,l){return s[l.uuid]===void 0&&(s[l.uuid]=l.toJSON(t)),l.uuid}if(this.isScene)this.background&&(this.background.isColor?i.background=this.background.toJSON():this.background.isTexture&&(i.background=this.background.toJSON(t).uuid)),this.environment&&this.environment.isTexture&&(i.environment=this.environment.toJSON(t).uuid);else if(this.isMesh||this.isLine||this.isPoints){i.geometry=o(t.geometries,this.geometry);let s=this.geometry.parameters;if(s!==void 0&&s.shapes!==void 0){let l=s.shapes;if(Array.isArray(l))for(let c=0,u=l.length;c<u;c++){let h=l[c];o(t.shapes,h)}else o(t.shapes,l)}}if(this.isSkinnedMesh&&(i.bindMode=this.bindMode,i.bindMatrix=this.bindMatrix.toArray(),this.skeleton!==void 0&&(o(t.skeletons,this.skeleton),i.skeleton=this.skeleton.uuid)),this.material!==void 0)if(Array.isArray(this.material)){let s=[];for(let l=0,c=this.material.length;l<c;l++)s.push(o(t.materials,this.material[l]));i.material=s}else i.material=o(t.materials,this.material);if(this.children.length>0){i.children=[];for(let s=0;s<this.children.length;s++)i.children.push(this.children[s].toJSON(t).object)}if(this.animations.length>0){i.animations=[];for(let s=0;s<this.animations.length;s++){let l=this.animations[s];i.animations.push(o(t.animations,l))}}if(r){let s=a(t.geometries),l=a(t.materials),c=a(t.textures),u=a(t.images),h=a(t.shapes),f=a(t.skeletons),p=a(t.animations);s.length>0&&(n.geometries=s),l.length>0&&(n.materials=l),c.length>0&&(n.textures=c),u.length>0&&(n.images=u),h.length>0&&(n.shapes=h),f.length>0&&(n.skeletons=f),p.length>0&&(n.animations=p)}return n.object=i,n;function a(s){let l=[];for(let c in s){let u=s[c];delete u.metadata,l.push(u)}return l}}clone(t){return new this.constructor().copy(this,t)}copy(t,r=!0){if(this.name=t.name,this.up.copy(t.up),this.position.copy(t.position),this.rotation.order=t.rotation.order,this.quaternion.copy(t.quaternion),this.scale.copy(t.scale),this.matrix.copy(t.matrix),this.matrixWorld.copy(t.matrixWorld),this.matrixAutoUpdate=t.matrixAutoUpdate,this.matrixWorldNeedsUpdate=t.matrixWorldNeedsUpdate,this.layers.mask=t.layers.mask,this.visible=t.visible,this.castShadow=t.castShadow,this.receiveShadow=t.receiveShadow,this.frustumCulled=t.frustumCulled,this.renderOrder=t.renderOrder,this.userData=JSON.parse(JSON.stringify(t.userData)),r===!0)for(let n=0;n<t.children.length;n++){let i=t.children[n];this.add(i.clone())}return this}};or.DefaultUp=new j(0,1,0);or.DefaultMatrixAutoUpdate=!0;or.prototype.isObject3D=!0;var oh=new j,Gd=new j,tut=new j,Wd=new j,E3=new j,T3=new j,Cue=new j,eut=new j,rut=new j,nut=new j,oi=class{constructor(t=new j,r=new j,n=new j){this.a=t,this.b=r,this.c=n}static getNormal(t,r,n,i){i.subVectors(n,r),oh.subVectors(t,r),i.cross(oh);let o=i.lengthSq();return o>0?i.multiplyScalar(1/Math.sqrt(o)):i.set(0,0,0)}static getBarycoord(t,r,n,i,o){oh.subVectors(i,r),Gd.subVectors(n,r),tut.subVectors(t,r);let a=oh.dot(oh),s=oh.dot(Gd),l=oh.dot(tut),c=Gd.dot(Gd),u=Gd.dot(tut),h=a*c-s*s;if(h===0)return o.set(-2,-1,-1);let f=1/h,p=(c*l-s*u)*f,d=(a*u-s*l)*f;return o.set(1-p-d,d,p)}static containsPoint(t,r,n,i){return this.getBarycoord(t,r,n,i,Wd),Wd.x>=0&&Wd.y>=0&&Wd.x+Wd.y<=1}static getUV(t,r,n,i,o,a,s,l){return this.getBarycoord(t,r,n,i,Wd),l.set(0,0),l.addScaledVector(o,Wd.x),l.addScaledVector(a,Wd.y),l.addScaledVector(s,Wd.z),l}static isFrontFacing(t,r,n,i){return oh.subVectors(n,r),Gd.subVectors(t,r),oh.cross(Gd).dot(i)<0}set(t,r,n){return this.a.copy(t),this.b.copy(r),this.c.copy(n),this}setFromPointsAndIndices(t,r,n,i){return this.a.copy(t[r]),this.b.copy(t[n]),this.c.copy(t[i]),this}setFromAttributeAndIndices(t,r,n,i){return this.a.fromBufferAttribute(t,r),this.b.fromBufferAttribute(t,n),this.c.fromBufferAttribute(t,i),this}clone(){return new this.constructor().copy(this)}copy(t){return this.a.copy(t.a),this.b.copy(t.b),this.c.copy(t.c),this}getArea(){return oh.subVectors(this.c,this.b),Gd.subVectors(this.a,this.b),oh.cross(Gd).length()*.5}getMidpoint(t){return t.addVectors(this.a,this.b).add(this.c).multiplyScalar(1/3)}getNormal(t){return oi.getNormal(this.a,this.b,this.c,t)}getPlane(t){return t.setFromCoplanarPoints(this.a,this.b,this.c)}getBarycoord(t,r){return oi.getBarycoord(t,this.a,this.b,this.c,r)}getUV(t,r,n,i,o){return oi.getUV(t,this.a,this.b,this.c,r,n,i,o)}containsPoint(t){return oi.containsPoint(t,this.a,this.b,this.c)}isFrontFacing(t){return oi.isFrontFacing(this.a,this.b,this.c,t)}intersectsBox(t){return t.intersectsTriangle(this)}closestPointToPoint(t,r){let n=this.a,i=this.b,o=this.c,a,s;E3.subVectors(i,n),T3.subVectors(o,n),eut.subVectors(t,n);let l=E3.dot(eut),c=T3.dot(eut);if(l<=0&&c<=0)return r.copy(n);rut.subVectors(t,i);let u=E3.dot(rut),h=T3.dot(rut);if(u>=0&&h<=u)return r.copy(i);let f=l*h-u*c;if(f<=0&&l>=0&&u<=0)return a=l/(l-u),r.copy(n).addScaledVector(E3,a);nut.subVectors(t,o);let p=E3.dot(nut),d=T3.dot(nut);if(d>=0&&p<=d)return r.copy(o);let g=p*c-l*d;if(g<=0&&c>=0&&d<=0)return s=c/(c-d),r.copy(n).addScaledVector(T3,s);let _=u*d-p*h;if(_<=0&&h-u>=0&&p-d>=0)return Cue.subVectors(o,i),s=(h-u)/(h-u+(p-d)),r.copy(i).addScaledVector(Cue,s);let y=1/(_+g+f);return a=g*y,s=f*y,r.copy(n).addScaledVector(E3,a).addScaledVector(T3,s)}equals(t){return t.a.equals(this.a)&&t.b.equals(this.b)&&t.c.equals(this.c)}},dfr=0,qi=class extends Us{constructor(){super(),Object.defineProperty(this,"id",{value:dfr++}),this.uuid=Nl(),this.name="",this.type="Material",this.fog=!0,this.blending=V3,this.side=I1,this.vertexColors=!1,this.opacity=1,this.transparent=!1,this.blendSrc=Pht,this.blendDst=Iht,this.blendEquation=M1,this.blendSrcAlpha=null,this.blendDstAlpha=null,this.blendEquationAlpha=null,this.depthFunc=iU,this.depthTest=!0,this.depthWrite=!0,this.stencilWriteMask=255,this.stencilFunc=Ofe,this.stencilRef=0,this.stencilFuncMask=255,this.stencilFail=nU,this.stencilZFail=nU,this.stencilZPass=nU,this.stencilWrite=!1,this.clippingPlanes=null,this.clipIntersection=!1,this.clipShadows=!1,this.shadowSide=null,this.colorWrite=!0,this.alphaWrite=!0,this.precision=null,this.polygonOffset=!1,this.polygonOffsetFactor=0,this.polygonOffsetUnits=0,this.dithering=!1,this.alphaToCoverage=!1,this.premultipliedAlpha=!1,this.visible=!0,this.toneMapped=!0,this.userData={},this.version=0,this._alphaTest=0}get alphaTest(){return this._alphaTest}set alphaTest(t){this._alphaTest>0!=t>0&&this.version++,this._alphaTest=t}onBuild(){}onBeforeRender(){}onBeforeCompile(){}customProgramCacheKey(){return this.onBeforeCompile.toString()}setValues(t){if(t!==void 0)for(let r in t){let n=t[r];if(n===void 0){console.warn("THREE.Material: '"+r+"' parameter is undefined.");continue}if(r==="shading"){console.warn("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead."),this.flatShading=n===Aht;continue}let i=this[r];if(i===void 0){console.warn("THREE."+this.type+": '"+r+"' is not a property of this material.");continue}i&&i.isColor?i.set(n):i&&i.isVector3&&n&&n.isVector3?i.copy(n):this[r]=n}}toJSON(t){let r=t===void 0||typeof t=="string";r&&(t={textures:{},images:{}});let n={metadata:{version:4.5,type:"Material",generator:"Material.toJSON"}};n.uuid=this.uuid,n.type=this.type,this.name!==""&&(n.name=this.name),this.color&&this.color.isColor&&(n.color=this.color.getHex()),this.roughness!==void 0&&(n.roughness=this.roughness),this.metalness!==void 0&&(n.metalness=this.metalness),this.sheen!==void 0&&(n.sheen=this.sheen),this.sheenColor&&this.sheenColor.isColor&&(n.sheenColor=this.sheenColor.getHex()),this.sheenRoughness!==void 0&&(n.sheenRoughness=this.sheenRoughness),this.emissive&&this.emissive.isColor&&(n.emissive=this.emissive.getHex()),this.emissiveIntensity&&this.emissiveIntensity!==1&&(n.emissiveIntensity=this.emissiveIntensity),this.specular&&this.specular.isColor&&(n.specular=this.specular.getHex()),this.specularIntensity!==void 0&&(n.specularIntensity=this.specularIntensity),this.specularColor&&this.specularColor.isColor&&(n.specularColor=this.specularColor.getHex()),this.shininess!==void 0&&(n.shininess=this.shininess),this.clearcoat!==void 0&&(n.clearcoat=this.clearcoat),this.clearcoatRoughness!==void 0&&(n.clearcoatRoughness=this.clearcoatRoughness),this.clearcoatMap&&this.clearcoatMap.isTexture&&(n.clearcoatMap=this.clearcoatMap.toJSON(t).uuid),this.clearcoatRoughnessMap&&this.clearcoatRoughnessMap.isTexture&&(n.clearcoatRoughnessMap=this.clearcoatRoughnessMap.toJSON(t).uuid),this.clearcoatNormalMap&&this.clearcoatNormalMap.isTexture&&(n.clearcoatNormalMap=this.clearcoatNormalMap.toJSON(t).uuid,n.clearcoatNormalScale=this.clearcoatNormalScale.toArray()),this.map&&this.map.isTexture&&(n.map=this.map.toJSON(t).uuid),this.matcap&&this.matcap.isTexture&&(n.matcap=this.matcap.toJSON(t).uuid),this.alphaMap&&this.alphaMap.isTexture&&(n.alphaMap=this.alphaMap.toJSON(t).uuid),this.lightMap&&this.lightMap.isTexture&&(n.lightMap=this.lightMap.toJSON(t).uuid,n.lightMapIntensity=this.lightMapIntensity),this.aoMap&&this.aoMap.isTexture&&(n.aoMap=this.aoMap.toJSON(t).uuid,n.aoMapIntensity=this.aoMapIntensity),this.bumpMap&&this.bumpMap.isTexture&&(n.bumpMap=this.bumpMap.toJSON(t).uuid,n.bumpScale=this.bumpScale),this.normalMap&&this.normalMap.isTexture&&(n.normalMap=this.normalMap.toJSON(t).uuid,n.normalMapType=this.normalMapType,n.normalScale=this.normalScale.toArray()),this.displacementMap&&this.displacementMap.isTexture&&(n.displacementMap=this.displacementMap.toJSON(t).uuid,n.displacementScale=this.displacementScale,n.displacementBias=this.displacementBias),this.roughnessMap&&this.roughnessMap.isTexture&&(n.roughnessMap=this.roughnessMap.toJSON(t).uuid),this.metalnessMap&&this.metalnessMap.isTexture&&(n.metalnessMap=this.metalnessMap.toJSON(t).uuid),this.emissiveMap&&this.emissiveMap.isTexture&&(n.emissiveMap=this.emissiveMap.toJSON(t).uuid),this.specularMap&&this.specularMap.isTexture&&(n.specularMap=this.specularMap.toJSON(t).uuid),this.specularIntensityMap&&this.specularIntensityMap.isTexture&&(n.specularIntensityMap=this.specularIntensityMap.toJSON(t).uuid),this.specularColorMap&&this.specularColorMap.isTexture&&(n.specularColorMap=this.specularColorMap.toJSON(t).uuid),this.envMap&&this.envMap.isTexture&&(n.envMap=this.envMap.toJSON(t).uuid,this.combine!==void 0&&(n.combine=this.combine)),this.envMapIntensity!==void 0&&(n.envMapIntensity=this.envMapIntensity),this.reflectivity!==void 0&&(n.reflectivity=this.reflectivity),this.refractionRatio!==void 0&&(n.refractionRatio=this.refractionRatio),this.gradientMap&&this.gradientMap.isTexture&&(n.gradientMap=this.gradientMap.toJSON(t).uuid),this.transmission!==void 0&&(n.transmission=this.transmission),this.transmissionMap&&this.transmissionMap.isTexture&&(n.transmissionMap=this.transmissionMap.toJSON(t).uuid),this.thickness!==void 0&&(n.thickness=this.thickness),this.thicknessMap&&this.thicknessMap.isTexture&&(n.thicknessMap=this.thicknessMap.toJSON(t).uuid),this.attenuationDistance!==void 0&&(n.attenuationDistance=this.attenuationDistance),this.attenuationColor!==void 0&&(n.attenuationColor=this.attenuationColor.getHex()),this.size!==void 0&&(n.size=this.size),this.shadowSide!==null&&(n.shadowSide=this.shadowSide),this.sizeAttenuation!==void 0&&(n.sizeAttenuation=this.sizeAttenuation),this.blending!==V3&&(n.blending=this.blending),this.side!==I1&&(n.side=this.side),this.vertexColors&&(n.vertexColors=!0),this.opacity<1&&(n.opacity=this.opacity),this.transparent===!0&&(n.transparent=this.transparent),n.depthFunc=this.depthFunc,n.depthTest=this.depthTest,n.depthWrite=this.depthWrite,n.colorWrite=this.colorWrite,n.alphaWrite=this.alphaWrite,n.stencilWrite=this.stencilWrite,n.stencilWriteMask=this.stencilWriteMask,n.stencilFunc=this.stencilFunc,n.stencilRef=this.stencilRef,n.stencilFuncMask=this.stencilFuncMask,n.stencilFail=this.stencilFail,n.stencilZFail=this.stencilZFail,n.stencilZPass=this.stencilZPass,this.rotation&&this.rotation!==0&&(n.rotation=this.rotation),this.polygonOffset===!0&&(n.polygonOffset=!0),this.polygonOffsetFactor!==0&&(n.polygonOffsetFactor=this.polygonOffsetFactor),this.polygonOffsetUnits!==0&&(n.polygonOffsetUnits=this.polygonOffsetUnits),this.linewidth&&this.linewidth!==1&&(n.linewidth=this.linewidth),this.dashSize!==void 0&&(n.dashSize=this.dashSize),this.gapSize!==void 0&&(n.gapSize=this.gapSize),this.scale!==void 0&&(n.scale=this.scale),this.dithering===!0&&(n.dithering=!0),this.alphaTest>0&&(n.alphaTest=this.alphaTest),this.alphaToCoverage===!0&&(n.alphaToCoverage=this.alphaToCoverage),this.premultipliedAlpha===!0&&(n.premultipliedAlpha=this.premultipliedAlpha),this.wireframe===!0&&(n.wireframe=this.wireframe),this.wireframeLinewidth>1&&(n.wireframeLinewidth=this.wireframeLinewidth),this.wireframeLinecap!=="round"&&(n.wireframeLinecap=this.wireframeLinecap),this.wireframeLinejoin!=="round"&&(n.wireframeLinejoin=this.wireframeLinejoin),this.flatShading===!0&&(n.flatShading=this.flatShading),this.visible===!1&&(n.visible=!1),this.toneMapped===!1&&(n.toneMapped=!1),JSON.stringify(this.userData)!=="{}"&&(n.userData=this.userData);function i(o){let a=[];for(let s in o){let l=o[s];delete l.metadata,a.push(l)}return a}if(r){let o=i(t.textures),a=i(t.images);o.length>0&&(n.textures=o),a.length>0&&(n.images=a)}return n}clone(){return new this.constructor().copy(this)}copy(t){this.name=t.name,this.fog=t.fog,this.blending=t.blending,this.side=t.side,this.vertexColors=t.vertexColors,this.opacity=t.opacity,this.transparent=t.transparent,this.blendSrc=t.blendSrc,this.blendDst=t.blendDst,this.blendEquation=t.blendEquation,this.blendSrcAlpha=t.blendSrcAlpha,this.blendDstAlpha=t.blendDstAlpha,this.blendEquationAlpha=t.blendEquationAlpha,this.depthFunc=t.depthFunc,this.depthTest=t.depthTest,this.depthWrite=t.depthWrite,this.stencilWriteMask=t.stencilWriteMask,this.stencilFunc=t.stencilFunc,this.stencilRef=t.stencilRef,this.stencilFuncMask=t.stencilFuncMask,this.stencilFail=t.stencilFail,this.stencilZFail=t.stencilZFail,this.stencilZPass=t.stencilZPass,this.stencilWrite=t.stencilWrite;let r=t.clippingPlanes,n=null;if(r!==null){let i=r.length;n=new Array(i);for(let o=0;o!==i;++o)n[o]=r[o].clone()}return this.clippingPlanes=n,this.clipIntersection=t.clipIntersection,this.clipShadows=t.clipShadows,this.shadowSide=t.shadowSide,this.colorWrite=t.colorWrite,this.alphaWrite=t.alphaWrite,this.precision=t.precision,this.polygonOffset=t.polygonOffset,this.polygonOffsetFactor=t.polygonOffsetFactor,this.polygonOffsetUnits=t.polygonOffsetUnits,this.dithering=t.dithering,this.alphaTest=t.alphaTest,this.alphaToCoverage=t.alphaToCoverage,this.premultipliedAlpha=t.premultipliedAlpha,this.visible=t.visible,this.toneMapped=t.toneMapped,this.userData=JSON.parse(JSON.stringify(t.userData)),this}dispose(){this.dispatchEvent({type:"dispose"})}set needsUpdate(t){t===!0&&this.version++}};qi.prototype.isMaterial=!0;var sh=class extends qi{constructor(t){super(),this.type="MeshBasicMaterial",this.color=new ne(16777215),this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.specularMap=null,this.alphaMap=null,this.envMap=null,this.combine=O6,this.reflectivity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.specularMap=t.specularMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.combine=t.combine,this.reflectivity=t.reflectivity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this}};sh.prototype.isMeshBasicMaterial=!0;var In=new j,vV=new Lt,Je=class{constructor(t,r,n){if(Array.isArray(t))throw new TypeError("THREE.BufferAttribute: array should be a Typed Array.");this.name="",this.array=t,this.itemSize=r,this.count=t!==void 0?t.length/r:0,this.normalized=n===!0,this.usage=W3,this.updateRange={offset:0,count:-1},this.version=0}onUploadCallback(){}set needsUpdate(t){t===!0&&this.version++}setUsage(t){return this.usage=t,this}copy(t){return this.name=t.name,this.array=new t.array.constructor(t.array),this.itemSize=t.itemSize,this.count=t.count,this.normalized=t.normalized,this.usage=t.usage,this}copyAt(t,r,n){t*=this.itemSize,n*=r.itemSize;for(let i=0,o=this.itemSize;i<o;i++)this.array[t+i]=r.array[n+i];return this}copyArray(t){return this.array.set(t),this}copyColorsArray(t){let r=this.array,n=0;for(let i=0,o=t.length;i<o;i++){let a=t[i];a===void 0&&(console.warn("THREE.BufferAttribute.copyColorsArray(): color is undefined",i),a=new ne),r[n++]=a.r,r[n++]=a.g,r[n++]=a.b}return this}copyVector2sArray(t){let r=this.array,n=0;for(let i=0,o=t.length;i<o;i++){let a=t[i];a===void 0&&(console.warn("THREE.BufferAttribute.copyVector2sArray(): vector is undefined",i),a=new Lt),r[n++]=a.x,r[n++]=a.y}return this}copyVector3sArray(t){let r=this.array,n=0;for(let i=0,o=t.length;i<o;i++){let a=t[i];a===void 0&&(console.warn("THREE.BufferAttribute.copyVector3sArray(): vector is undefined",i),a=new j),r[n++]=a.x,r[n++]=a.y,r[n++]=a.z}return this}copyVector4sArray(t){let r=this.array,n=0;for(let i=0,o=t.length;i<o;i++){let a=t[i];a===void 0&&(console.warn("THREE.BufferAttribute.copyVector4sArray(): vector is undefined",i),a=new en),r[n++]=a.x,r[n++]=a.y,r[n++]=a.z,r[n++]=a.w}return this}applyMatrix3(t){if(this.itemSize===2)for(let r=0,n=this.count;r<n;r++)vV.fromBufferAttribute(this,r),vV.applyMatrix3(t),this.setXY(r,vV.x,vV.y);else if(this.itemSize===3)for(let r=0,n=this.count;r<n;r++)In.fromBufferAttribute(this,r),In.applyMatrix3(t),this.setXYZ(r,In.x,In.y,In.z);return this}applyMatrix4(t){for(let r=0,n=this.count;r<n;r++)In.x=this.getX(r),In.y=this.getY(r),In.z=this.getZ(r),In.applyMatrix4(t),this.setXYZ(r,In.x,In.y,In.z);return this}applyNormalMatrix(t){for(let r=0,n=this.count;r<n;r++)In.x=this.getX(r),In.y=this.getY(r),In.z=this.getZ(r),In.applyNormalMatrix(t),this.setXYZ(r,In.x,In.y,In.z);return this}transformDirection(t){for(let r=0,n=this.count;r<n;r++)In.x=this.getX(r),In.y=this.getY(r),In.z=this.getZ(r),In.transformDirection(t),this.setXYZ(r,In.x,In.y,In.z);return this}set(t,r=0){return this.array.set(t,r),this}getX(t){return this.array[t*this.itemSize]}setX(t,r){return this.array[t*this.itemSize]=r,this}getY(t){return this.array[t*this.itemSize+1]}setY(t,r){return this.array[t*this.itemSize+1]=r,this}getZ(t){return this.array[t*this.itemSize+2]}setZ(t,r){return this.array[t*this.itemSize+2]=r,this}getW(t){return this.array[t*this.itemSize+3]}setW(t,r){return this.array[t*this.itemSize+3]=r,this}setXY(t,r,n){return t*=this.itemSize,this.array[t+0]=r,this.array[t+1]=n,this}setXYZ(t,r,n,i){return t*=this.itemSize,this.array[t+0]=r,this.array[t+1]=n,this.array[t+2]=i,this}setXYZW(t,r,n,i,o){return t*=this.itemSize,this.array[t+0]=r,this.array[t+1]=n,this.array[t+2]=i,this.array[t+3]=o,this}onUpload(t){return this.onUploadCallback=t,this}clone(){return new this.constructor(this.array,this.itemSize).copy(this)}toJSON(){let t={itemSize:this.itemSize,type:this.array.constructor.name,array:Array.prototype.slice.call(this.array),normalized:this.normalized};return this.name!==""&&(t.name=this.name),this.usage!==W3&&(t.usage=this.usage),(this.updateRange.offset!==0||this.updateRange.count!==-1)&&(t.updateRange=this.updateRange),t}};Je.prototype.isBufferAttribute=!0;var cU=class extends Je{constructor(t,r,n){super(new Int8Array(t),r,n)}},uU=class extends Je{constructor(t,r,n){super(new Uint8Array(t),r,n)}},hU=class extends Je{constructor(t,r,n){super(new Uint8ClampedArray(t),r,n)}},fU=class extends Je{constructor(t,r,n){super(new Int16Array(t),r,n)}},$3=class extends Je{constructor(t,r,n){super(new Uint16Array(t),r,n)}},pU=class extends Je{constructor(t,r,n){super(new Int32Array(t),r,n)}},K3=class extends Je{constructor(t,r,n){super(new Uint32Array(t),r,n)}},dU=class extends Je{constructor(t,r,n){super(new Uint16Array(t),r,n)}};dU.prototype.isFloat16BufferAttribute=!0;var xe=class extends Je{constructor(t,r,n){super(new Float32Array(t),r,n)}},mU=class extends Je{constructor(t,r,n){super(new Float64Array(t),r,n)}},mfr=0,Xc=new Me,iut=new or,C3=new j,Rl=new ta,RP=new ta,Lo=new j,Pe=class extends Us{constructor(){super(),Object.defineProperty(this,"id",{value:mfr++}),this.uuid=Nl(),this.name="",this.type="BufferGeometry",this.index=null,this.attributes={},this.morphAttributes={},this.morphTargetsRelative=!1,this.groups=[],this.boundingBox=null,this.boundingSphere=null,this.drawRange={start:0,count:1/0},this.userData={}}getIndex(){return this.index}setIndex(t){return Array.isArray(t)?this.index=new(Bfe(t)?K3:$3)(t,1):this.index=t,this}getAttribute(t){return this.attributes[t]}setAttribute(t,r){return this.attributes[t]=r,this}deleteAttribute(t){return delete this.attributes[t],this}hasAttribute(t){return this.attributes[t]!==void 0}addGroup(t,r,n=0){this.groups.push({start:t,count:r,materialIndex:n})}clearGroups(){this.groups=[]}setDrawRange(t,r){this.drawRange.start=t,this.drawRange.count=r}applyMatrix4(t){let r=this.attributes.position;r!==void 0&&(r.applyMatrix4(t),r.needsUpdate=!0);let n=this.attributes.normal;if(n!==void 0){let o=new ki().getNormalMatrix(t);n.applyNormalMatrix(o),n.needsUpdate=!0}let i=this.attributes.tangent;return i!==void 0&&(i.transformDirection(t),i.needsUpdate=!0),this.boundingBox!==null&&this.computeBoundingBox(),this.boundingSphere!==null&&this.computeBoundingSphere(),this}applyQuaternion(t){return Xc.makeRotationFromQuaternion(t),this.applyMatrix4(Xc),this}rotateX(t){return Xc.makeRotationX(t),this.applyMatrix4(Xc),this}rotateY(t){return Xc.makeRotationY(t),this.applyMatrix4(Xc),this}rotateZ(t){return Xc.makeRotationZ(t),this.applyMatrix4(Xc),this}translate(t,r,n){return Xc.makeTranslation(t,r,n),this.applyMatrix4(Xc),this}scale(t,r,n){return Xc.makeScale(t,r,n),this.applyMatrix4(Xc),this}lookAt(t){return iut.lookAt(t),iut.updateMatrix(),this.applyMatrix4(iut.matrix),this}center(){return this.computeBoundingBox(),this.boundingBox.getCenter(C3).negate(),this.translate(C3.x,C3.y,C3.z),this}setFromPoints(t){let r=[];for(let n=0,i=t.length;n<i;n++){let o=t[n];r.push(o.x,o.y,o.z||0)}return this.setAttribute("position",new xe(r,3)),this}computeBoundingBox(){this.boundingBox===null&&(this.boundingBox=new ta);let t=this.attributes.position,r=this.morphAttributes.position;if(t&&t.isGLBufferAttribute){console.error('THREE.BufferGeometry.computeBoundingBox(): GLBufferAttribute requires a manual bounding box. Alternatively set "mesh.frustumCulled" to "false".',this),this.boundingBox.set(new j(-1/0,-1/0,-1/0),new j(1/0,1/0,1/0));return}if(t!==void 0){if(this.boundingBox.setFromBufferAttribute(t),r)for(let n=0,i=r.length;n<i;n++){let o=r[n];Rl.setFromBufferAttribute(o),this.morphTargetsRelative?(Lo.addVectors(this.boundingBox.min,Rl.min),this.boundingBox.expandByPoint(Lo),Lo.addVectors(this.boundingBox.max,Rl.max),this.boundingBox.expandByPoint(Lo)):(this.boundingBox.expandByPoint(Rl.min),this.boundingBox.expandByPoint(Rl.max))}}else this.boundingBox.makeEmpty();(isNaN(this.boundingBox.min.x)||isNaN(this.boundingBox.min.y)||isNaN(this.boundingBox.min.z))&&console.error('THREE.BufferGeometry.computeBoundingBox(): Computed min/max have NaN values. The "position" attribute is likely to have NaN values.',this)}computeBoundingSphere(){this.boundingSphere===null&&(this.boundingSphere=new Zf);let t=this.attributes.position,r=this.morphAttributes.position;if(t&&t.isGLBufferAttribute){console.error('THREE.BufferGeometry.computeBoundingSphere(): GLBufferAttribute requires a manual bounding sphere. Alternatively set "mesh.frustumCulled" to "false".',this),this.boundingSphere.set(new j,1/0);return}if(t){let n=this.boundingSphere.center;if(Rl.setFromBufferAttribute(t),r)for(let o=0,a=r.length;o<a;o++){let s=r[o];RP.setFromBufferAttribute(s),this.morphTargetsRelative?(Lo.addVectors(Rl.min,RP.min),Rl.expandByPoint(Lo),Lo.addVectors(Rl.max,RP.max),Rl.expandByPoint(Lo)):(Rl.expandByPoint(RP.min),Rl.expandByPoint(RP.max))}Rl.getCenter(n);let i=0;for(let o=0,a=t.count;o<a;o++)Lo.fromBufferAttribute(t,o),i=Math.max(i,n.distanceToSquared(Lo));if(r)for(let o=0,a=r.length;o<a;o++){let s=r[o],l=this.morphTargetsRelative;for(let c=0,u=s.count;c<u;c++)Lo.fromBufferAttribute(s,c),l&&(C3.fromBufferAttribute(t,c),Lo.add(C3)),i=Math.max(i,n.distanceToSquared(Lo))}this.boundingSphere.radius=Math.sqrt(i),isNaN(this.boundingSphere.radius)&&console.error('THREE.BufferGeometry.computeBoundingSphere(): Computed radius is NaN. The "position" attribute is likely to have NaN values.',this)}}computeTangents(){let t=this.index,r=this.attributes;if(t===null||r.position===void 0||r.normal===void 0||r.uv===void 0){console.error("THREE.BufferGeometry: .computeTangents() failed. Missing required attributes (index, position, normal or uv)");return}let n=t.array,i=r.position.array,o=r.normal.array,a=r.uv.array,s=i.length/3;r.tangent===void 0&&this.setAttribute("tangent",new Je(new Float32Array(4*s),4));let l=r.tangent.array,c=[],u=[];for(let B=0;B<s;B++)c[B]=new j,u[B]=new j;let h=new j,f=new j,p=new j,d=new Lt,g=new Lt,_=new Lt,y=new j,x=new j;function b(B,I,L){h.fromArray(i,B*3),f.fromArray(i,I*3),p.fromArray(i,L*3),d.fromArray(a,B*2),g.fromArray(a,I*2),_.fromArray(a,L*2),f.sub(h),p.sub(h),g.sub(d),_.sub(d);let R=1/(g.x*_.y-_.x*g.y);!isFinite(R)||(y.copy(f).multiplyScalar(_.y).addScaledVector(p,-g.y).multiplyScalar(R),x.copy(p).multiplyScalar(g.x).addScaledVector(f,-_.x).multiplyScalar(R),c[B].add(y),c[I].add(y),c[L].add(y),u[B].add(x),u[I].add(x),u[L].add(x))}let S=this.groups;S.length===0&&(S=[{start:0,count:n.length}]);for(let B=0,I=S.length;B<I;++B){let L=S[B],R=L.start,F=L.count;for(let z=R,U=R+F;z<U;z+=3)b(n[z+0],n[z+1],n[z+2])}let C=new j,P=new j,k=new j,O=new j;function D(B){k.fromArray(o,B*3),O.copy(k);let I=c[B];C.copy(I),C.sub(k.multiplyScalar(k.dot(I))).normalize(),P.crossVectors(O,I);let R=P.dot(u[B])<0?-1:1;l[B*4]=C.x,l[B*4+1]=C.y,l[B*4+2]=C.z,l[B*4+3]=R}for(let B=0,I=S.length;B<I;++B){let L=S[B],R=L.start,F=L.count;for(let z=R,U=R+F;z<U;z+=3)D(n[z+0]),D(n[z+1]),D(n[z+2])}}computeVertexNormals(){let t=this.index,r=this.getAttribute("position");if(r!==void 0){let n=this.getAttribute("normal");if(n===void 0)n=new Je(new Float32Array(r.count*3),3),this.setAttribute("normal",n);else for(let f=0,p=n.count;f<p;f++)n.setXYZ(f,0,0,0);let i=new j,o=new j,a=new j,s=new j,l=new j,c=new j,u=new j,h=new j;if(t)for(let f=0,p=t.count;f<p;f+=3){let d=t.getX(f+0),g=t.getX(f+1),_=t.getX(f+2);i.fromBufferAttribute(r,d),o.fromBufferAttribute(r,g),a.fromBufferAttribute(r,_),u.subVectors(a,o),h.subVectors(i,o),u.cross(h),s.fromBufferAttribute(n,d),l.fromBufferAttribute(n,g),c.fromBufferAttribute(n,_),s.add(u),l.add(u),c.add(u),n.setXYZ(d,s.x,s.y,s.z),n.setXYZ(g,l.x,l.y,l.z),n.setXYZ(_,c.x,c.y,c.z)}else for(let f=0,p=r.count;f<p;f+=3)i.fromBufferAttribute(r,f+0),o.fromBufferAttribute(r,f+1),a.fromBufferAttribute(r,f+2),u.subVectors(a,o),h.subVectors(i,o),u.cross(h),n.setXYZ(f+0,u.x,u.y,u.z),n.setXYZ(f+1,u.x,u.y,u.z),n.setXYZ(f+2,u.x,u.y,u.z);this.normalizeNormals(),n.needsUpdate=!0}}merge(t,r){if(!(t&&t.isBufferGeometry)){console.error("THREE.BufferGeometry.merge(): geometry not an instance of THREE.BufferGeometry.",t);return}r===void 0&&(r=0,console.warn("THREE.BufferGeometry.merge(): Overwriting original geometry, starting at offset=0. Use BufferGeometryUtils.mergeBufferGeometries() for lossless merge."));let n=this.attributes;for(let i in n){if(t.attributes[i]===void 0)continue;let a=n[i].array,s=t.attributes[i],l=s.array,c=s.itemSize*r,u=Math.min(l.length,a.length-c);for(let h=0,f=c;h<u;h++,f++)a[f]=l[h]}return this}normalizeNormals(){let t=this.attributes.normal;for(let r=0,n=t.count;r<n;r++)Lo.fromBufferAttribute(t,r),Lo.normalize(),t.setXYZ(r,Lo.x,Lo.y,Lo.z)}toNonIndexed(){function t(s,l){let c=s.array,u=s.itemSize,h=s.normalized,f=new c.constructor(l.length*u),p=0,d=0;for(let g=0,_=l.length;g<_;g++){s.isInterleavedBufferAttribute?p=l[g]*s.data.stride+s.offset:p=l[g]*u;for(let y=0;y<u;y++)f[d++]=c[p++]}return new Je(f,u,h)}if(this.index===null)return console.warn("THREE.BufferGeometry.toNonIndexed(): BufferGeometry is already non-indexed."),this;let r=new Pe,n=this.index.array,i=this.attributes;for(let s in i){let l=i[s],c=t(l,n);r.setAttribute(s,c)}let o=this.morphAttributes;for(let s in o){let l=[],c=o[s];for(let u=0,h=c.length;u<h;u++){let f=c[u],p=t(f,n);l.push(p)}r.morphAttributes[s]=l}r.morphTargetsRelative=this.morphTargetsRelative;let a=this.groups;for(let s=0,l=a.length;s<l;s++){let c=a[s];r.addGroup(c.start,c.count,c.materialIndex)}return r}toJSON(){let t={metadata:{version:4.5,type:"BufferGeometry",generator:"BufferGeometry.toJSON"}};if(t.uuid=this.uuid,t.type=this.type,this.name!==""&&(t.name=this.name),Object.keys(this.userData).length>0&&(t.userData=this.userData),this.parameters!==void 0){let l=this.parameters;for(let c in l)l[c]!==void 0&&(t[c]=l[c]);return t}t.data={attributes:{}};let r=this.index;r!==null&&(t.data.index={type:r.array.constructor.name,array:Array.prototype.slice.call(r.array)});let n=this.attributes;for(let l in n){let c=n[l];t.data.attributes[l]=c.toJSON(t.data)}let i={},o=!1;for(let l in this.morphAttributes){let c=this.morphAttributes[l],u=[];for(let h=0,f=c.length;h<f;h++){let p=c[h];u.push(p.toJSON(t.data))}u.length>0&&(i[l]=u,o=!0)}o&&(t.data.morphAttributes=i,t.data.morphTargetsRelative=this.morphTargetsRelative);let a=this.groups;a.length>0&&(t.data.groups=JSON.parse(JSON.stringify(a)));let s=this.boundingSphere;return s!==null&&(t.data.boundingSphere={center:s.center.toArray(),radius:s.radius}),t}clone(){return new this.constructor().copy(this)}copy(t){this.index=null,this.attributes={},this.morphAttributes={},this.groups=[],this.boundingBox=null,this.boundingSphere=null;let r={};this.name=t.name;let n=t.index;n!==null&&this.setIndex(n.clone(r));let i=t.attributes;for(let c in i){let u=i[c];this.setAttribute(c,u.clone(r))}let o=t.morphAttributes;for(let c in o){let u=[],h=o[c];for(let f=0,p=h.length;f<p;f++)u.push(h[f].clone(r));this.morphAttributes[c]=u}this.morphTargetsRelative=t.morphTargetsRelative;let a=t.groups;for(let c=0,u=a.length;c<u;c++){let h=a[c];this.addGroup(h.start,h.count,h.materialIndex)}let s=t.boundingBox;s!==null&&(this.boundingBox=s.clone());let l=t.boundingSphere;return l!==null&&(this.boundingSphere=l.clone()),this.drawRange.start=t.drawRange.start,this.drawRange.count=t.drawRange.count,this.userData=t.userData,t.parameters!==void 0&&(this.parameters=Object.assign({},t.parameters)),this}dispose(){this.dispatchEvent({type:"dispose"})}};Pe.prototype.isBufferGeometry=!0;var Aue=new Me,A3=new Jf,out=new Zf,R0=new j,N0=new j,D0=new j,aut=new j,sut=new j,lut=new j,xV=new j,bV=new j,wV=new j,SV=new Lt,MV=new Lt,EV=new Lt,cut=new j,TV=new j,ti=class extends or{constructor(t=new Pe,r=new sh){super(),this.type="Mesh",this.geometry=t,this.material=r,this.updateMorphTargets()}copy(t){return super.copy(t),t.morphTargetInfluences!==void 0&&(this.morphTargetInfluences=t.morphTargetInfluences.slice()),t.morphTargetDictionary!==void 0&&(this.morphTargetDictionary=Object.assign({},t.morphTargetDictionary)),this.material=t.material,this.geometry=t.geometry,this}updateMorphTargets(){let t=this.geometry;if(t.isBufferGeometry){let r=t.morphAttributes,n=Object.keys(r);if(n.length>0){let i=r[n[0]];if(i!==void 0){this.morphTargetInfluences=[],this.morphTargetDictionary={};for(let o=0,a=i.length;o<a;o++){let s=i[o].name||String(o);this.morphTargetInfluences.push(0),this.morphTargetDictionary[s]=o}}}}else{let r=t.morphTargets;r!==void 0&&r.length>0&&console.error("THREE.Mesh.updateMorphTargets() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}}raycast(t,r){let n=this.geometry,i=this.material,o=this.matrixWorld;if(i===void 0||(n.boundingSphere===null&&n.computeBoundingSphere(),out.copy(n.boundingSphere),out.applyMatrix4(o),t.ray.intersectsSphere(out)===!1)||(Aue.copy(o).invert(),A3.copy(t.ray).applyMatrix4(Aue),n.boundingBox!==null&&A3.intersectsBox(n.boundingBox)===!1))return;let a;if(n.isBufferGeometry){let s=n.index,l=n.attributes.position,c=n.morphAttributes.position,u=n.morphTargetsRelative,h=n.attributes.uv,f=n.attributes.uv2,p=n.groups,d=n.drawRange;if(s!==null)if(Array.isArray(i))for(let g=0,_=p.length;g<_;g++){let y=p[g],x=i[y.materialIndex],b=Math.max(y.start,d.start),S=Math.min(s.count,Math.min(y.start+y.count,d.start+d.count));for(let C=b,P=S;C<P;C+=3){let k=s.getX(C),O=s.getX(C+1),D=s.getX(C+2);a=CV(this,x,t,A3,l,c,u,h,f,k,O,D),a&&(a.faceIndex=Math.floor(C/3),a.face.materialIndex=y.materialIndex,r.push(a))}}else{let g=Math.max(0,d.start),_=Math.min(s.count,d.start+d.count);for(let y=g,x=_;y<x;y+=3){let b=s.getX(y),S=s.getX(y+1),C=s.getX(y+2);a=CV(this,i,t,A3,l,c,u,h,f,b,S,C),a&&(a.faceIndex=Math.floor(y/3),r.push(a))}}else if(l!==void 0)if(Array.isArray(i))for(let g=0,_=p.length;g<_;g++){let y=p[g],x=i[y.materialIndex],b=Math.max(y.start,d.start),S=Math.min(l.count,Math.min(y.start+y.count,d.start+d.count));for(let C=b,P=S;C<P;C+=3){let k=C,O=C+1,D=C+2;a=CV(this,x,t,A3,l,c,u,h,f,k,O,D),a&&(a.faceIndex=Math.floor(C/3),a.face.materialIndex=y.materialIndex,r.push(a))}}else{let g=Math.max(0,d.start),_=Math.min(l.count,d.start+d.count);for(let y=g,x=_;y<x;y+=3){let b=y,S=y+1,C=y+2;a=CV(this,i,t,A3,l,c,u,h,f,b,S,C),a&&(a.faceIndex=Math.floor(y/3),r.push(a))}}}else n.isGeometry&&console.error("THREE.Mesh.raycast() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}};ti.prototype.isMesh=!0;function gfr(e,t,r,n,i,o,a,s){let l;if(t.side===Ii?l=n.intersectTriangle(a,o,i,!0,s):l=n.intersectTriangle(i,o,a,t.side!==L1,s),l===null)return null;TV.copy(s),TV.applyMatrix4(e.matrixWorld);let c=r.ray.origin.distanceTo(TV);return c<r.near||c>r.far?null:{distance:c,point:TV.clone(),object:e}}function CV(e,t,r,n,i,o,a,s,l,c,u,h){R0.fromBufferAttribute(i,c),N0.fromBufferAttribute(i,u),D0.fromBufferAttribute(i,h);let f=e.morphTargetInfluences;if(o&&f){xV.set(0,0,0),bV.set(0,0,0),wV.set(0,0,0);for(let d=0,g=o.length;d<g;d++){let _=f[d],y=o[d];_!==0&&(aut.fromBufferAttribute(y,c),sut.fromBufferAttribute(y,u),lut.fromBufferAttribute(y,h),a?(xV.addScaledVector(aut,_),bV.addScaledVector(sut,_),wV.addScaledVector(lut,_)):(xV.addScaledVector(aut.sub(R0),_),bV.addScaledVector(sut.sub(N0),_),wV.addScaledVector(lut.sub(D0),_)))}R0.add(xV),N0.add(bV),D0.add(wV)}e.isSkinnedMesh&&(e.boneTransform(c,R0),e.boneTransform(u,N0),e.boneTransform(h,D0));let p=gfr(e,t,r,n,R0,N0,D0,cut);if(p){s&&(SV.fromBufferAttribute(s,c),MV.fromBufferAttribute(s,u),EV.fromBufferAttribute(s,h),p.uv=oi.getUV(cut,R0,N0,D0,SV,MV,EV,new Lt)),l&&(SV.fromBufferAttribute(l,c),MV.fromBufferAttribute(l,u),EV.fromBufferAttribute(l,h),p.uv2=oi.getUV(cut,R0,N0,D0,SV,MV,EV,new Lt));let d={a:c,b:u,c:h,normal:new j,materialIndex:0};oi.getNormal(R0,N0,D0,d.normal),p.face=d}return p}var Qf=class extends Pe{constructor(t=1,r=1,n=1,i=1,o=1,a=1){super(),this.type="BoxGeometry",this.parameters={width:t,height:r,depth:n,widthSegments:i,heightSegments:o,depthSegments:a};let s=this;i=Math.floor(i),o=Math.floor(o),a=Math.floor(a);let l=[],c=[],u=[],h=[],f=0,p=0;d("z","y","x",-1,-1,n,r,t,a,o,0),d("z","y","x",1,-1,n,r,-t,a,o,1),d("x","z","y",1,1,t,n,r,i,a,2),d("x","z","y",1,-1,t,n,-r,i,a,3),d("x","y","z",1,-1,t,r,n,i,o,4),d("x","y","z",-1,-1,t,r,-n,i,o,5),this.setIndex(l),this.setAttribute("position",new xe(c,3)),this.setAttribute("normal",new xe(u,3)),this.setAttribute("uv",new xe(h,2));function d(g,_,y,x,b,S,C,P,k,O,D){let B=S/k,I=C/O,L=S/2,R=C/2,F=P/2,z=k+1,U=O+1,W=0,Z=0,rt=new j;for(let ot=0;ot<U;ot++){let st=ot*I-R;for(let St=0;St<z;St++){let bt=St*B-L;rt[g]=bt*x,rt[_]=st*b,rt[y]=F,c.push(rt.x,rt.y,rt.z),rt[g]=0,rt[_]=0,rt[y]=P>0?1:-1,u.push(rt.x,rt.y,rt.z),h.push(St/k),h.push(1-ot/O),W+=1}}for(let ot=0;ot<O;ot++)for(let st=0;st<k;st++){let St=f+st+z*ot,bt=f+st+z*(ot+1),Mt=f+(st+1)+z*(ot+1),lt=f+(st+1)+z*ot;l.push(St,bt,lt),l.push(bt,Mt,lt),Z+=6}s.addGroup(p,Z,D),p+=Z,f+=W}}static fromJSON(t){return new Qf(t.width,t.height,t.depth,t.widthSegments,t.heightSegments,t.depthSegments)}};function Z3(e){let t={};for(let r in e){t[r]={};for(let n in e[r]){let i=e[r][n];i&&(i.isColor||i.isMatrix3||i.isMatrix4||i.isVector2||i.isVector3||i.isVector4||i.isTexture||i.isQuaternion)?t[r][n]=i.clone():Array.isArray(i)?t[r][n]=i.slice():t[r][n]=i}}return t}function Ta(e){let t={};for(let r=0;r<e.length;r++){let n=Z3(e[r]);for(let i in n)t[i]=n[i]}return t}var Vfe={clone:Z3,merge:Ta},_fr=`void main() {
	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
}`,yfr=`void main() {
	gl_FragColor = vec4( 1.0, 0.0, 0.0, 1.0 );
}`,lh=class extends qi{constructor(t){super(),this.type="ShaderMaterial",this.defines={},this.uniforms={},this.vertexShader=_fr,this.fragmentShader=yfr,this.linewidth=1,this.wireframe=!1,this.wireframeLinewidth=1,this.fog=!1,this.lights=!1,this.clipping=!1,this.extensions={derivatives:!1,fragDepth:!1,drawBuffers:!1,shaderTextureLOD:!1},this.defaultAttributeValues={color:[1,1,1],uv:[0,0],uv2:[0,0]},this.index0AttributeName=void 0,this.uniformsNeedUpdate=!1,this.glslVersion=null,t!==void 0&&(t.attributes!==void 0&&console.error("THREE.ShaderMaterial: attributes should now be defined in THREE.BufferGeometry instead."),this.setValues(t))}copy(t){return super.copy(t),this.fragmentShader=t.fragmentShader,this.vertexShader=t.vertexShader,this.uniforms=Z3(t.uniforms),this.defines=Object.assign({},t.defines),this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.lights=t.lights,this.clipping=t.clipping,this.extensions=Object.assign({},t.extensions),this.glslVersion=t.glslVersion,this}toJSON(t){let r=super.toJSON(t);r.glslVersion=this.glslVersion,r.uniforms={};for(let i in this.uniforms){let a=this.uniforms[i].value;a&&a.isTexture?r.uniforms[i]={type:"t",value:a.toJSON(t).uuid}:a&&a.isColor?r.uniforms[i]={type:"c",value:a.getHex()}:a&&a.isVector2?r.uniforms[i]={type:"v2",value:a.toArray()}:a&&a.isVector3?r.uniforms[i]={type:"v3",value:a.toArray()}:a&&a.isVector4?r.uniforms[i]={type:"v4",value:a.toArray()}:a&&a.isMatrix3?r.uniforms[i]={type:"m3",value:a.toArray()}:a&&a.isMatrix4?r.uniforms[i]={type:"m4",value:a.toArray()}:r.uniforms[i]={value:a}}Object.keys(this.defines).length>0&&(r.defines=this.defines),r.vertexShader=this.vertexShader,r.fragmentShader=this.fragmentShader;let n={};for(let i in this.extensions)this.extensions[i]===!0&&(n[i]=!0);return Object.keys(n).length>0&&(r.extensions=n),r}};lh.prototype.isShaderMaterial=!0;var R1=class extends or{constructor(){super(),this.type="Camera",this.matrixWorldInverse=new Me,this.projectionMatrix=new Me,this.projectionMatrixInverse=new Me}copy(t,r){return super.copy(t,r),this.matrixWorldInverse.copy(t.matrixWorldInverse),this.projectionMatrix.copy(t.projectionMatrix),this.projectionMatrixInverse.copy(t.projectionMatrixInverse),this}getWorldDirection(t){this.updateWorldMatrix(!0,!1);let r=this.matrixWorld.elements;return t.set(-r[8],-r[9],-r[10]).normalize()}updateMatrixWorld(t){super.updateMatrixWorld(t),this.matrixWorldInverse.copy(this.matrixWorld).invert()}updateWorldMatrix(t,r){super.updateWorldMatrix(t,r),this.matrixWorldInverse.copy(this.matrixWorld).invert()}clone(){return new this.constructor().copy(this)}};R1.prototype.isCamera=!0;var Ui=class extends R1{constructor(t=50,r=1,n=.1,i=2e3){super(),this.type="PerspectiveCamera",this.fov=t,this.zoom=1,this.near=n,this.far=i,this.focus=10,this.aspect=r,this.view=null,this.filmGauge=35,this.filmOffset=0,this.updateProjectionMatrix()}copy(t,r){return super.copy(t,r),this.fov=t.fov,this.zoom=t.zoom,this.near=t.near,this.far=t.far,this.focus=t.focus,this.aspect=t.aspect,this.view=t.view===null?null:Object.assign({},t.view),this.filmGauge=t.filmGauge,this.filmOffset=t.filmOffset,this}setFocalLength(t){let r=.5*this.getFilmHeight()/t;this.fov=QP*2*Math.atan(r),this.updateProjectionMatrix()}getFocalLength(){let t=Math.tan(P1*.5*this.fov);return .5*this.getFilmHeight()/t}getEffectiveFOV(){return QP*2*Math.atan(Math.tan(P1*.5*this.fov)/this.zoom)}getFilmWidth(){return this.filmGauge*Math.min(this.aspect,1)}getFilmHeight(){return this.filmGauge/Math.max(this.aspect,1)}setViewOffset(t,r,n,i,o,a){this.aspect=t/r,this.view===null&&(this.view={enabled:!0,fullWidth:1,fullHeight:1,offsetX:0,offsetY:0,width:1,height:1}),this.view.enabled=!0,this.view.fullWidth=t,this.view.fullHeight=r,this.view.offsetX=n,this.view.offsetY=i,this.view.width=o,this.view.height=a,this.updateProjectionMatrix()}clearViewOffset(){this.view!==null&&(this.view.enabled=!1),this.updateProjectionMatrix()}updateProjectionMatrix(){let t=this.near,r=t*Math.tan(P1*.5*this.fov)/this.zoom,n=2*r,i=this.aspect*n,o=-.5*i,a=this.view;if(this.view!==null&&this.view.enabled){let l=a.fullWidth,c=a.fullHeight;o+=a.offsetX*i/l,r-=a.offsetY*n/c,i*=a.width/l,n*=a.height/c}let s=this.filmOffset;s!==0&&(o+=t*s/this.getFilmWidth()),this.projectionMatrix.makePerspective(o,o+i,r,r-n,t,this.far),this.projectionMatrixInverse.copy(this.projectionMatrix).invert()}toJSON(t){let r=super.toJSON(t);return r.object.fov=this.fov,r.object.zoom=this.zoom,r.object.near=this.near,r.object.far=this.far,r.object.focus=this.focus,r.object.aspect=this.aspect,this.view!==null&&(r.object.view=Object.assign({},this.view)),r.object.filmGauge=this.filmGauge,r.object.filmOffset=this.filmOffset,r}};Ui.prototype.isPerspectiveCamera=!0;var P3=90,I3=1,J3=class extends or{constructor(t,r,n){if(super(),this.type="CubeCamera",n.isWebGLCubeRenderTarget!==!0){console.error("THREE.CubeCamera: The constructor now expects an instance of WebGLCubeRenderTarget as third parameter.");return}this.renderTarget=n;let i=new Ui(P3,I3,t,r);i.layers=this.layers,i.up.set(0,-1,0),i.lookAt(new j(1,0,0)),this.add(i);let o=new Ui(P3,I3,t,r);o.layers=this.layers,o.up.set(0,-1,0),o.lookAt(new j(-1,0,0)),this.add(o);let a=new Ui(P3,I3,t,r);a.layers=this.layers,a.up.set(0,0,1),a.lookAt(new j(0,1,0)),this.add(a);let s=new Ui(P3,I3,t,r);s.layers=this.layers,s.up.set(0,0,-1),s.lookAt(new j(0,-1,0)),this.add(s);let l=new Ui(P3,I3,t,r);l.layers=this.layers,l.up.set(0,-1,0),l.lookAt(new j(0,0,1)),this.add(l);let c=new Ui(P3,I3,t,r);c.layers=this.layers,c.up.set(0,-1,0),c.lookAt(new j(0,0,-1)),this.add(c)}update(t,r){this.parent===null&&this.updateMatrixWorld();let n=this.renderTarget,[i,o,a,s,l,c]=this.children,u=t.xr.enabled,h=t.getRenderTarget();t.xr.enabled=!1;let f=n.texture.generateMipmaps;n.texture.generateMipmaps=!1,t.setRenderTarget(n,0),t.render(r,i),t.setRenderTarget(n,1),t.render(r,o),t.setRenderTarget(n,2),t.render(r,a),t.setRenderTarget(n,3),t.render(r,s),t.setRenderTarget(n,4),t.render(r,l),n.texture.generateMipmaps=f,t.setRenderTarget(n,5),t.render(r,c),t.setRenderTarget(h),t.xr.enabled=u,n.texture.needsPMREMUpdate=!0}},H0=class extends vi{constructor(t,r,n,i,o,a,s,l,c,u){t=t!==void 0?t:[],r=r!==void 0?r:nx,super(t,r,n,i,o,a,s,l,c,u),this.flipY=!1}get images(){return this.image}set images(t){this.image=t}};H0.prototype.isCubeTexture=!0;var Q3=class extends us{constructor(t,r,n){Number.isInteger(r)&&(console.warn("THREE.WebGLCubeRenderTarget: constructor signature is now WebGLCubeRenderTarget( size, options )"),r=n),super(t,t,r),r=r||{},this.texture=new H0(void 0,r.mapping,r.wrapS,r.wrapT,r.magFilter,r.minFilter,r.format,r.type,r.anisotropy,r.encoding),this.texture.isRenderTargetTexture=!0,this.texture.generateMipmaps=r.generateMipmaps!==void 0?r.generateMipmaps:!1,this.texture.minFilter=r.minFilter!==void 0?r.minFilter:ii}fromEquirectangularTexture(t,r){this.texture.type=r.type,this.texture.format=Qo,this.texture.encoding=r.encoding,this.texture.generateMipmaps=r.generateMipmaps,this.texture.minFilter=r.minFilter,this.texture.magFilter=r.magFilter;let n={uniforms:{tEquirect:{value:null}},vertexShader:`

				varying vec3 vWorldDirection;

				vec3 transformDirection( in vec3 dir, in mat4 matrix ) {

					return normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );

				}

				void main() {

					vWorldDirection = transformDirection( position, modelMatrix );

					#include <begin_vertex>
					#include <project_vertex>

				}
			`,fragmentShader:`

				uniform sampler2D tEquirect;

				varying vec3 vWorldDirection;

				#include <common>

				void main() {

					vec3 direction = normalize( vWorldDirection );

					vec2 sampleUV = equirectUv( direction );

					gl_FragColor = texture2D( tEquirect, sampleUV );

				}
			`},i=new Qf(5,5,5),o=new lh({name:"CubemapFromEquirect",uniforms:Z3(n.uniforms),vertexShader:n.vertexShader,fragmentShader:n.fragmentShader,side:Ii,blending:$d});o.uniforms.tEquirect.value=r;let a=new ti(i,o),s=r.minFilter;return r.minFilter===ox&&(r.minFilter=ii),new J3(1,10,this).update(t,a),r.minFilter=s,a.geometry.dispose(),a.material.dispose(),this}clear(t,r,n,i){let o=t.getRenderTarget();for(let a=0;a<6;a++)t.setRenderTarget(this,a),t.clear(r,n,i);t.setRenderTarget(o)}};Q3.prototype.isWebGLCubeRenderTarget=!0;var uut=new j,vfr=new j,xfr=new ki,$c=class{constructor(t=new j(1,0,0),r=0){this.normal=t,this.constant=r}set(t,r){return this.normal.copy(t),this.constant=r,this}setComponents(t,r,n,i){return this.normal.set(t,r,n),this.constant=i,this}setFromNormalAndCoplanarPoint(t,r){return this.normal.copy(t),this.constant=-r.dot(this.normal),this}setFromCoplanarPoints(t,r,n){let i=uut.subVectors(n,r).cross(vfr.subVectors(t,r)).normalize();return this.setFromNormalAndCoplanarPoint(i,t),this}copy(t){return this.normal.copy(t.normal),this.constant=t.constant,this}normalize(){let t=1/this.normal.length();return this.normal.multiplyScalar(t),this.constant*=t,this}negate(){return this.constant*=-1,this.normal.negate(),this}distanceToPoint(t){return this.normal.dot(t)+this.constant}distanceToSphere(t){return this.distanceToPoint(t.center)-t.radius}projectPoint(t,r){return r.copy(this.normal).multiplyScalar(-this.distanceToPoint(t)).add(t)}intersectLine(t,r){let n=t.delta(uut),i=this.normal.dot(n);if(i===0)return this.distanceToPoint(t.start)===0?r.copy(t.start):null;let o=-(t.start.dot(this.normal)+this.constant)/i;return o<0||o>1?null:r.copy(n).multiplyScalar(o).add(t.start)}intersectsLine(t){let r=this.distanceToPoint(t.start),n=this.distanceToPoint(t.end);return r<0&&n>0||n<0&&r>0}intersectsBox(t){return t.intersectsPlane(this)}intersectsSphere(t){return t.intersectsPlane(this)}coplanarPoint(t){return t.copy(this.normal).multiplyScalar(-this.constant)}applyMatrix4(t,r){let n=r||xfr.getNormalMatrix(t),i=this.coplanarPoint(uut).applyMatrix4(t),o=this.normal.applyMatrix3(n).normalize();return this.constant=-i.dot(o),this}translate(t){return this.constant-=t.dot(this.normal),this}equals(t){return t.normal.equals(this.normal)&&t.constant===this.constant}clone(){return new this.constructor().copy(this)}};$c.prototype.isPlane=!0;var L3=new Zf,AV=new j,N1=class{constructor(t=new $c,r=new $c,n=new $c,i=new $c,o=new $c,a=new $c){this.planes=[t,r,n,i,o,a]}set(t,r,n,i,o,a){let s=this.planes;return s[0].copy(t),s[1].copy(r),s[2].copy(n),s[3].copy(i),s[4].copy(o),s[5].copy(a),this}copy(t){let r=this.planes;for(let n=0;n<6;n++)r[n].copy(t.planes[n]);return this}setFromProjectionMatrix(t){let r=this.planes,n=t.elements,i=n[0],o=n[1],a=n[2],s=n[3],l=n[4],c=n[5],u=n[6],h=n[7],f=n[8],p=n[9],d=n[10],g=n[11],_=n[12],y=n[13],x=n[14],b=n[15];return r[0].setComponents(s-i,h-l,g-f,b-_).normalize(),r[1].setComponents(s+i,h+l,g+f,b+_).normalize(),r[2].setComponents(s+o,h+c,g+p,b+y).normalize(),r[3].setComponents(s-o,h-c,g-p,b-y).normalize(),r[4].setComponents(s-a,h-u,g-d,b-x).normalize(),r[5].setComponents(s+a,h+u,g+d,b+x).normalize(),this}intersectsObject(t){let r=t.geometry;return r.boundingSphere===null&&r.computeBoundingSphere(),L3.copy(r.boundingSphere).applyMatrix4(t.matrixWorld),this.intersectsSphere(L3)}intersectsSprite(t){return L3.center.set(0,0,0),L3.radius=.7071067811865476,L3.applyMatrix4(t.matrixWorld),this.intersectsSphere(L3)}intersectsSphere(t){let r=this.planes,n=t.center,i=-t.radius;for(let o=0;o<6;o++)if(r[o].distanceToPoint(n)<i)return!1;return!0}intersectsBox(t){let r=this.planes;for(let n=0;n<6;n++){let i=r[n];if(AV.x=i.normal.x>0?t.max.x:t.min.x,AV.y=i.normal.y>0?t.max.y:t.min.y,AV.z=i.normal.z>0?t.max.z:t.min.z,i.distanceToPoint(AV)<0)return!1}return!0}containsPoint(t){let r=this.planes;for(let n=0;n<6;n++)if(r[n].distanceToPoint(t)<0)return!1;return!0}clone(){return new this.constructor().copy(this)}};function Ufe(){let e=null,t=!1,r=null,n=null;function i(o,a){r(o,a),n=e.requestAnimationFrame(i)}return{start:function(){t!==!0&&r!==null&&(n=e.requestAnimationFrame(i),t=!0)},stop:function(){e.cancelAnimationFrame(n),t=!1},setAnimationLoop:function(o){r=o},setContext:function(o){e=o}}}function bfr(e,t){let r=t.isWebGL2,n=new WeakMap;function i(c,u){let h=c.array,f=c.usage,p=e.createBuffer();e.bindBuffer(u,p),e.bufferData(u,h,f),c.onUploadCallback();let d=5126;return h instanceof Float32Array?d=5126:h instanceof Float64Array?console.warn("THREE.WebGLAttributes: Unsupported data buffer format: Float64Array."):h instanceof Uint16Array?c.isFloat16BufferAttribute?r?d=5131:console.warn("THREE.WebGLAttributes: Usage of Float16BufferAttribute requires WebGL2."):d=5123:h instanceof Int16Array?d=5122:h instanceof Uint32Array?d=5125:h instanceof Int32Array?d=5124:h instanceof Int8Array?d=5120:(h instanceof Uint8Array||h instanceof Uint8ClampedArray)&&(d=5121),{buffer:p,type:d,bytesPerElement:h.BYTES_PER_ELEMENT,version:c.version}}function o(c,u,h){let f=u.array,p=u.updateRange;e.bindBuffer(h,c),p.count===-1?e.bufferSubData(h,0,f):(r?e.bufferSubData(h,p.offset*f.BYTES_PER_ELEMENT,f,p.offset,p.count):e.bufferSubData(h,p.offset*f.BYTES_PER_ELEMENT,f.subarray(p.offset,p.offset+p.count)),p.count=-1)}function a(c){return c.isInterleavedBufferAttribute&&(c=c.data),n.get(c)}function s(c){c.isInterleavedBufferAttribute&&(c=c.data);let u=n.get(c);u&&(e.deleteBuffer(u.buffer),n.delete(c))}function l(c,u){if(c.isGLBufferAttribute){let f=n.get(c);(!f||f.version<c.version)&&n.set(c,{buffer:c.buffer,type:c.type,bytesPerElement:c.elementSize,version:c.version});return}c.isInterleavedBufferAttribute&&(c=c.data);let h=n.get(c);h===void 0?n.set(c,i(c,u)):h.version<c.version&&(o(h.buffer,c,u),h.version=c.version)}return{get:a,remove:s,update:l}}var V0=class extends Pe{constructor(t=1,r=1,n=1,i=1){super(),this.type="PlaneGeometry",this.parameters={width:t,height:r,widthSegments:n,heightSegments:i};let o=t/2,a=r/2,s=Math.floor(n),l=Math.floor(i),c=s+1,u=l+1,h=t/s,f=r/l,p=[],d=[],g=[],_=[];for(let y=0;y<u;y++){let x=y*f-a;for(let b=0;b<c;b++){let S=b*h-o;d.push(S,-x,0),g.push(0,0,1),_.push(b/s),_.push(1-y/l)}}for(let y=0;y<l;y++)for(let x=0;x<s;x++){let b=x+c*y,S=x+c*(y+1),C=x+1+c*(y+1),P=x+1+c*y;p.push(b,S,P),p.push(S,C,P)}this.setIndex(p),this.setAttribute("position",new xe(d,3)),this.setAttribute("normal",new xe(g,3)),this.setAttribute("uv",new xe(_,2))}static fromJSON(t){return new V0(t.width,t.height,t.widthSegments,t.heightSegments)}},wfr=`#ifdef USE_ALPHAMAP
	diffuseColor.a *= texture2D( alphaMap, vUv ).g;
#endif`,Sfr=`#ifdef USE_ALPHAMAP
	uniform sampler2D alphaMap;
#endif`,Mfr=`#ifdef USE_ALPHATEST
	if ( diffuseColor.a < alphaTest ) discard;
#endif`,Efr=`#ifdef USE_ALPHATEST
	uniform float alphaTest;
#endif`,Tfr=`#ifdef USE_AOMAP
	float ambientOcclusion = ( texture2D( aoMap, vUv2 ).r - 1.0 ) * aoMapIntensity + 1.0;
	reflectedLight.indirectDiffuse *= ambientOcclusion;
	#if defined( USE_ENVMAP ) && defined( STANDARD )
		float dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );
		reflectedLight.indirectSpecular *= computeSpecularOcclusion( dotNV, ambientOcclusion, material.roughness );
	#endif
#endif`,Cfr=`#ifdef USE_AOMAP
	uniform sampler2D aoMap;
	uniform float aoMapIntensity;
#endif`,Afr="vec3 transformed = vec3( position );",Pfr=`vec3 objectNormal = vec3( normal );
#ifdef USE_TANGENT
	vec3 objectTangent = vec3( tangent.xyz );
#endif`,Ifr=`vec3 BRDF_Lambert( const in vec3 diffuseColor ) {
	return RECIPROCAL_PI * diffuseColor;
}
vec3 F_Schlick( const in vec3 f0, const in float f90, const in float dotVH ) {
	float fresnel = exp2( ( - 5.55473 * dotVH - 6.98316 ) * dotVH );
	return f0 * ( 1.0 - fresnel ) + ( f90 * fresnel );
}
float V_GGX_SmithCorrelated( const in float alpha, const in float dotNL, const in float dotNV ) {
	float a2 = pow2( alpha );
	float gv = dotNL * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );
	float gl = dotNV * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );
	return 0.5 / max( gv + gl, EPSILON );
}
float D_GGX( const in float alpha, const in float dotNH ) {
	float a2 = pow2( alpha );
	float denom = pow2( dotNH ) * ( a2 - 1.0 ) + 1.0;
	return RECIPROCAL_PI * a2 / pow2( denom );
}
vec3 BRDF_GGX( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in vec3 f0, const in float f90, const in float roughness ) {
	float alpha = pow2( roughness );
	vec3 halfDir = normalize( lightDir + viewDir );
	float dotNL = saturate( dot( normal, lightDir ) );
	float dotNV = saturate( dot( normal, viewDir ) );
	float dotNH = saturate( dot( normal, halfDir ) );
	float dotVH = saturate( dot( viewDir, halfDir ) );
	vec3 F = F_Schlick( f0, f90, dotVH );
	float V = V_GGX_SmithCorrelated( alpha, dotNL, dotNV );
	float D = D_GGX( alpha, dotNH );
	return F * ( V * D );
}
vec2 LTC_Uv( const in vec3 N, const in vec3 V, const in float roughness ) {
	const float LUT_SIZE = 64.0;
	const float LUT_SCALE = ( LUT_SIZE - 1.0 ) / LUT_SIZE;
	const float LUT_BIAS = 0.5 / LUT_SIZE;
	float dotNV = saturate( dot( N, V ) );
	vec2 uv = vec2( roughness, sqrt( 1.0 - dotNV ) );
	uv = uv * LUT_SCALE + LUT_BIAS;
	return uv;
}
float LTC_ClippedSphereFormFactor( const in vec3 f ) {
	float l = length( f );
	return max( ( l * l + f.z ) / ( l + 1.0 ), 0.0 );
}
vec3 LTC_EdgeVectorFormFactor( const in vec3 v1, const in vec3 v2 ) {
	float x = dot( v1, v2 );
	float y = abs( x );
	float a = 0.8543985 + ( 0.4965155 + 0.0145206 * y ) * y;
	float b = 3.4175940 + ( 4.1616724 + y ) * y;
	float v = a / b;
	float theta_sintheta = ( x > 0.0 ) ? v : 0.5 * inversesqrt( max( 1.0 - x * x, 1e-7 ) ) - v;
	return cross( v1, v2 ) * theta_sintheta;
}
vec3 LTC_Evaluate( const in vec3 N, const in vec3 V, const in vec3 P, const in mat3 mInv, const in vec3 rectCoords[ 4 ] ) {
	vec3 v1 = rectCoords[ 1 ] - rectCoords[ 0 ];
	vec3 v2 = rectCoords[ 3 ] - rectCoords[ 0 ];
	vec3 lightNormal = cross( v1, v2 );
	if( dot( lightNormal, P - rectCoords[ 0 ] ) < 0.0 ) return vec3( 0.0 );
	vec3 T1, T2;
	T1 = normalize( V - N * dot( V, N ) );
	T2 = - cross( N, T1 );
	mat3 mat = mInv * transposeMat3( mat3( T1, T2, N ) );
	vec3 coords[ 4 ];
	coords[ 0 ] = mat * ( rectCoords[ 0 ] - P );
	coords[ 1 ] = mat * ( rectCoords[ 1 ] - P );
	coords[ 2 ] = mat * ( rectCoords[ 2 ] - P );
	coords[ 3 ] = mat * ( rectCoords[ 3 ] - P );
	coords[ 0 ] = normalize( coords[ 0 ] );
	coords[ 1 ] = normalize( coords[ 1 ] );
	coords[ 2 ] = normalize( coords[ 2 ] );
	coords[ 3 ] = normalize( coords[ 3 ] );
	vec3 vectorFormFactor = vec3( 0.0 );
	vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 0 ], coords[ 1 ] );
	vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 1 ], coords[ 2 ] );
	vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 2 ], coords[ 3 ] );
	vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 3 ], coords[ 0 ] );
	float result = LTC_ClippedSphereFormFactor( vectorFormFactor );
	return vec3( result );
}
float G_BlinnPhong_Implicit( ) {
	return 0.25;
}
float D_BlinnPhong( const in float shininess, const in float dotNH ) {
	return RECIPROCAL_PI * ( shininess * 0.5 + 1.0 ) * pow( dotNH, shininess );
}
vec3 BRDF_BlinnPhong( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in vec3 specularColor, const in float shininess ) {
	vec3 halfDir = normalize( lightDir + viewDir );
	float dotNH = saturate( dot( normal, halfDir ) );
	float dotVH = saturate( dot( viewDir, halfDir ) );
	vec3 F = F_Schlick( specularColor, 1.0, dotVH );
	float G = G_BlinnPhong_Implicit( );
	float D = D_BlinnPhong( shininess, dotNH );
	return F * ( G * D );
}
#if defined( USE_SHEEN )
float D_Charlie( float roughness, float dotNH ) {
	float alpha = pow2( roughness );
	float invAlpha = 1.0 / alpha;
	float cos2h = dotNH * dotNH;
	float sin2h = max( 1.0 - cos2h, 0.0078125 );
	return ( 2.0 + invAlpha ) * pow( sin2h, invAlpha * 0.5 ) / ( 2.0 * PI );
}
float V_Neubelt( float dotNV, float dotNL ) {
	return saturate( 1.0 / ( 4.0 * ( dotNL + dotNV - dotNL * dotNV ) ) );
}
vec3 BRDF_Sheen( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, vec3 sheenColor, const in float sheenRoughness ) {
	vec3 halfDir = normalize( lightDir + viewDir );
	float dotNL = saturate( dot( normal, lightDir ) );
	float dotNV = saturate( dot( normal, viewDir ) );
	float dotNH = saturate( dot( normal, halfDir ) );
	float D = D_Charlie( sheenRoughness, dotNH );
	float V = V_Neubelt( dotNV, dotNL );
	return sheenColor * ( D * V );
}
#endif`,Lfr=`#ifdef USE_BUMPMAP
	uniform sampler2D bumpMap;
	uniform float bumpScale;
	vec2 dHdxy_fwd() {
		vec2 dSTdx = dFdx( vUv );
		vec2 dSTdy = dFdy( vUv );
		float Hll = bumpScale * texture2D( bumpMap, vUv ).x;
		float dBx = bumpScale * texture2D( bumpMap, vUv + dSTdx ).x - Hll;
		float dBy = bumpScale * texture2D( bumpMap, vUv + dSTdy ).x - Hll;
		return vec2( dBx, dBy );
	}
	vec3 perturbNormalArb( vec3 surf_pos, vec3 surf_norm, vec2 dHdxy, float faceDirection ) {
		vec3 vSigmaX = vec3( dFdx( surf_pos.x ), dFdx( surf_pos.y ), dFdx( surf_pos.z ) );
		vec3 vSigmaY = vec3( dFdy( surf_pos.x ), dFdy( surf_pos.y ), dFdy( surf_pos.z ) );
		vec3 vN = surf_norm;
		vec3 R1 = cross( vSigmaY, vN );
		vec3 R2 = cross( vN, vSigmaX );
		float fDet = dot( vSigmaX, R1 ) * faceDirection;
		vec3 vGrad = sign( fDet ) * ( dHdxy.x * R1 + dHdxy.y * R2 );
		return normalize( abs( fDet ) * surf_norm - vGrad );
	}
#endif`,kfr=`#if NUM_CLIPPING_PLANES > 0
	vec4 plane;
	#pragma unroll_loop_start
	for ( int i = 0; i < UNION_CLIPPING_PLANES; i ++ ) {
		plane = clippingPlanes[ i ];
		if ( dot( vClipPosition, plane.xyz ) > plane.w ) discard;
	}
	#pragma unroll_loop_end
	#if UNION_CLIPPING_PLANES < NUM_CLIPPING_PLANES
		bool clipped = true;
		#pragma unroll_loop_start
		for ( int i = UNION_CLIPPING_PLANES; i < NUM_CLIPPING_PLANES; i ++ ) {
			plane = clippingPlanes[ i ];
			clipped = ( dot( vClipPosition, plane.xyz ) > plane.w ) && clipped;
		}
		#pragma unroll_loop_end
		if ( clipped ) discard;
	#endif
#endif`,Rfr=`#if NUM_CLIPPING_PLANES > 0
	varying vec3 vClipPosition;
	uniform vec4 clippingPlanes[ NUM_CLIPPING_PLANES ];
#endif`,Nfr=`#if NUM_CLIPPING_PLANES > 0
	varying vec3 vClipPosition;
#endif`,Dfr=`#if NUM_CLIPPING_PLANES > 0
	vClipPosition = - mvPosition.xyz;
#endif`,Ofr=`#if defined( USE_COLOR_ALPHA )
	diffuseColor *= vColor;
#elif defined( USE_COLOR )
	diffuseColor.rgb *= vColor;
#endif`,zfr=`#if defined( USE_COLOR_ALPHA )
	varying vec4 vColor;
#elif defined( USE_COLOR )
	varying vec3 vColor;
#endif`,Ffr=`#if defined( USE_COLOR_ALPHA )
	varying vec4 vColor;
#elif defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR )
	varying vec3 vColor;
#endif`,Bfr=`#if defined( USE_COLOR_ALPHA )
	vColor = vec4( 1.0 );
#elif defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR )
	vColor = vec3( 1.0 );
#endif
#ifdef USE_COLOR
	vColor *= color;
#endif
#ifdef USE_INSTANCING_COLOR
	vColor.xyz *= instanceColor.xyz;
#endif`,Hfr=`#define PI 3.141592653589793
#define PI2 6.283185307179586
#define PI_HALF 1.5707963267948966
#define RECIPROCAL_PI 0.3183098861837907
#define RECIPROCAL_PI2 0.15915494309189535
#define EPSILON 1e-6
#ifndef saturate
#define saturate( a ) clamp( a, 0.0, 1.0 )
#endif
#define whiteComplement( a ) ( 1.0 - saturate( a ) )
float pow2( const in float x ) { return x*x; }
float pow3( const in float x ) { return x*x*x; }
float pow4( const in float x ) { float x2 = x*x; return x2*x2; }
float max3( const in vec3 v ) { return max( max( v.x, v.y ), v.z ); }
float average( const in vec3 color ) { return dot( color, vec3( 0.3333 ) ); }
highp float rand( const in vec2 uv ) {
	const highp float a = 12.9898, b = 78.233, c = 43758.5453;
	highp float dt = dot( uv.xy, vec2( a,b ) ), sn = mod( dt, PI );
	return fract( sin( sn ) * c );
}
#ifdef HIGH_PRECISION
	float precisionSafeLength( vec3 v ) { return length( v ); }
#else
	float precisionSafeLength( vec3 v ) {
		float maxComponent = max3( abs( v ) );
		return length( v / maxComponent ) * maxComponent;
	}
#endif
struct IncidentLight {
	vec3 color;
	vec3 direction;
	bool visible;
};
struct ReflectedLight {
	vec3 directDiffuse;
	vec3 directSpecular;
	vec3 indirectDiffuse;
	vec3 indirectSpecular;
};
struct GeometricContext {
	vec3 position;
	vec3 normal;
	vec3 viewDir;
#ifdef USE_CLEARCOAT
	vec3 clearcoatNormal;
#endif
};
vec3 transformDirection( in vec3 dir, in mat4 matrix ) {
	return normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );
}
vec3 inverseTransformDirection( in vec3 dir, in mat4 matrix ) {
	return normalize( ( vec4( dir, 0.0 ) * matrix ).xyz );
}
mat3 transposeMat3( const in mat3 m ) {
	mat3 tmp;
	tmp[ 0 ] = vec3( m[ 0 ].x, m[ 1 ].x, m[ 2 ].x );
	tmp[ 1 ] = vec3( m[ 0 ].y, m[ 1 ].y, m[ 2 ].y );
	tmp[ 2 ] = vec3( m[ 0 ].z, m[ 1 ].z, m[ 2 ].z );
	return tmp;
}
float linearToRelativeLuminance( const in vec3 color ) {
	vec3 weights = vec3( 0.2126, 0.7152, 0.0722 );
	return dot( weights, color.rgb );
}
bool isPerspectiveMatrix( mat4 m ) {
	return m[ 2 ][ 3 ] == - 1.0;
}
vec2 equirectUv( in vec3 dir ) {
	float u = atan( dir.z, dir.x ) * RECIPROCAL_PI2 + 0.5;
	float v = asin( clamp( dir.y, - 1.0, 1.0 ) ) * RECIPROCAL_PI + 0.5;
	return vec2( u, v );
}`,Vfr=`#ifdef ENVMAP_TYPE_CUBE_UV
	#define cubeUV_maxMipLevel 8.0
	#define cubeUV_minMipLevel 4.0
	#define cubeUV_maxTileSize 256.0
	#define cubeUV_minTileSize 16.0
	float getFace( vec3 direction ) {
		vec3 absDirection = abs( direction );
		float face = - 1.0;
		if ( absDirection.x > absDirection.z ) {
			if ( absDirection.x > absDirection.y )
				face = direction.x > 0.0 ? 0.0 : 3.0;
			else
				face = direction.y > 0.0 ? 1.0 : 4.0;
		} else {
			if ( absDirection.z > absDirection.y )
				face = direction.z > 0.0 ? 2.0 : 5.0;
			else
				face = direction.y > 0.0 ? 1.0 : 4.0;
		}
		return face;
	}
	vec2 getUV( vec3 direction, float face ) {
		vec2 uv;
		if ( face == 0.0 ) {
			uv = vec2( direction.z, direction.y ) / abs( direction.x );
		} else if ( face == 1.0 ) {
			uv = vec2( - direction.x, - direction.z ) / abs( direction.y );
		} else if ( face == 2.0 ) {
			uv = vec2( - direction.x, direction.y ) / abs( direction.z );
		} else if ( face == 3.0 ) {
			uv = vec2( - direction.z, direction.y ) / abs( direction.x );
		} else if ( face == 4.0 ) {
			uv = vec2( - direction.x, direction.z ) / abs( direction.y );
		} else {
			uv = vec2( direction.x, direction.y ) / abs( direction.z );
		}
		return 0.5 * ( uv + 1.0 );
	}
	vec3 bilinearCubeUV( sampler2D envMap, vec3 direction, float mipInt ) {
		float face = getFace( direction );
		float filterInt = max( cubeUV_minMipLevel - mipInt, 0.0 );
		mipInt = max( mipInt, cubeUV_minMipLevel );
		float faceSize = exp2( mipInt );
		float texelSize = 1.0 / ( 3.0 * cubeUV_maxTileSize );
		vec2 uv = getUV( direction, face ) * ( faceSize - 1.0 ) + 0.5;
		if ( face > 2.0 ) {
			uv.y += faceSize;
			face -= 3.0;
		}
		uv.x += face * faceSize;
		if ( mipInt < cubeUV_maxMipLevel ) {
			uv.y += 2.0 * cubeUV_maxTileSize;
		}
		uv.y += filterInt * 2.0 * cubeUV_minTileSize;
		uv.x += 3.0 * max( 0.0, cubeUV_maxTileSize - 2.0 * faceSize );
		uv *= texelSize;
		return texture2D( envMap, uv ).rgb;
	}
	#define r0 1.0
	#define v0 0.339
	#define m0 - 2.0
	#define r1 0.8
	#define v1 0.276
	#define m1 - 1.0
	#define r4 0.4
	#define v4 0.046
	#define m4 2.0
	#define r5 0.305
	#define v5 0.016
	#define m5 3.0
	#define r6 0.21
	#define v6 0.0038
	#define m6 4.0
	float roughnessToMip( float roughness ) {
		float mip = 0.0;
		if ( roughness >= r1 ) {
			mip = ( r0 - roughness ) * ( m1 - m0 ) / ( r0 - r1 ) + m0;
		} else if ( roughness >= r4 ) {
			mip = ( r1 - roughness ) * ( m4 - m1 ) / ( r1 - r4 ) + m1;
		} else if ( roughness >= r5 ) {
			mip = ( r4 - roughness ) * ( m5 - m4 ) / ( r4 - r5 ) + m4;
		} else if ( roughness >= r6 ) {
			mip = ( r5 - roughness ) * ( m6 - m5 ) / ( r5 - r6 ) + m5;
		} else {
			mip = - 2.0 * log2( 1.16 * roughness );		}
		return mip;
	}
	vec4 textureCubeUV( sampler2D envMap, vec3 sampleDir, float roughness ) {
		float mip = clamp( roughnessToMip( roughness ), m0, cubeUV_maxMipLevel );
		float mipF = fract( mip );
		float mipInt = floor( mip );
		vec3 color0 = bilinearCubeUV( envMap, sampleDir, mipInt );
		if ( mipF == 0.0 ) {
			return vec4( color0, 1.0 );
		} else {
			vec3 color1 = bilinearCubeUV( envMap, sampleDir, mipInt + 1.0 );
			return vec4( mix( color0, color1, mipF ), 1.0 );
		}
	}
#endif`,Ufr=`vec3 transformedNormal = objectNormal;
#ifdef USE_INSTANCING
	mat3 m = mat3( instanceMatrix );
	transformedNormal /= vec3( dot( m[ 0 ], m[ 0 ] ), dot( m[ 1 ], m[ 1 ] ), dot( m[ 2 ], m[ 2 ] ) );
	transformedNormal = m * transformedNormal;
#endif
transformedNormal = normalMatrix * transformedNormal;
#ifdef FLIP_SIDED
	transformedNormal = - transformedNormal;
#endif
#ifdef USE_TANGENT
	vec3 transformedTangent = ( modelViewMatrix * vec4( objectTangent, 0.0 ) ).xyz;
	#ifdef FLIP_SIDED
		transformedTangent = - transformedTangent;
	#endif
#endif`,qfr=`#ifdef USE_DISPLACEMENTMAP
	uniform sampler2D displacementMap;
	uniform float displacementScale;
	uniform float displacementBias;
#endif`,Gfr=`#ifdef USE_DISPLACEMENTMAP
	transformed += normalize( objectNormal ) * ( texture2D( displacementMap, vUv ).x * displacementScale + displacementBias );
#endif`,Wfr=`#ifdef USE_EMISSIVEMAP
	vec4 emissiveColor = texture2D( emissiveMap, vUv );
	totalEmissiveRadiance *= emissiveColor.rgb;
#endif`,Yfr=`#ifdef USE_EMISSIVEMAP
	uniform sampler2D emissiveMap;
#endif`,jfr="gl_FragColor = linearToOutputTexel( gl_FragColor );",Xfr=`vec4 LinearToLinear( in vec4 value ) {
	return value;
}
vec4 LinearTosRGB( in vec4 value ) {
	return vec4( mix( pow( value.rgb, vec3( 0.41666 ) ) * 1.055 - vec3( 0.055 ), value.rgb * 12.92, vec3( lessThanEqual( value.rgb, vec3( 0.0031308 ) ) ) ), value.a );
}`,$fr=`#ifdef USE_ENVMAP
	#ifdef ENV_WORLDPOS
		vec3 cameraToFrag;
		if ( isOrthographic ) {
			cameraToFrag = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );
		} else {
			cameraToFrag = normalize( vWorldPosition - cameraPosition );
		}
		vec3 worldNormal = inverseTransformDirection( normal, viewMatrix );
		#ifdef ENVMAP_MODE_REFLECTION
			vec3 reflectVec = reflect( cameraToFrag, worldNormal );
		#else
			vec3 reflectVec = refract( cameraToFrag, worldNormal, refractionRatio );
		#endif
	#else
		vec3 reflectVec = vReflect;
	#endif
	#ifdef ENVMAP_TYPE_CUBE
		vec4 envColor = textureCube( envMap, vec3( flipEnvMap * reflectVec.x, reflectVec.yz ) );
	#elif defined( ENVMAP_TYPE_CUBE_UV )
		vec4 envColor = textureCubeUV( envMap, reflectVec, 0.0 );
	#else
		vec4 envColor = vec4( 0.0 );
	#endif
	#ifdef ENVMAP_BLENDING_MULTIPLY
		outgoingLight = mix( outgoingLight, outgoingLight * envColor.xyz, specularStrength * reflectivity );
	#elif defined( ENVMAP_BLENDING_MIX )
		outgoingLight = mix( outgoingLight, envColor.xyz, specularStrength * reflectivity );
	#elif defined( ENVMAP_BLENDING_ADD )
		outgoingLight += envColor.xyz * specularStrength * reflectivity;
	#endif
#endif`,Kfr=`#ifdef USE_ENVMAP
	uniform float envMapIntensity;
	uniform float flipEnvMap;
	#ifdef ENVMAP_TYPE_CUBE
		uniform samplerCube envMap;
	#else
		uniform sampler2D envMap;
	#endif
	
#endif`,Zfr=`#ifdef USE_ENVMAP
	uniform float reflectivity;
	#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG )
		#define ENV_WORLDPOS
	#endif
	#ifdef ENV_WORLDPOS
		varying vec3 vWorldPosition;
		uniform float refractionRatio;
	#else
		varying vec3 vReflect;
	#endif
#endif`,Jfr=`#ifdef USE_ENVMAP
	#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) ||defined( PHONG )
		#define ENV_WORLDPOS
	#endif
	#ifdef ENV_WORLDPOS
		
		varying vec3 vWorldPosition;
	#else
		varying vec3 vReflect;
		uniform float refractionRatio;
	#endif
#endif`,Qfr=`#ifdef USE_ENVMAP
	#ifdef ENV_WORLDPOS
		vWorldPosition = worldPosition.xyz;
	#else
		vec3 cameraToVertex;
		if ( isOrthographic ) {
			cameraToVertex = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );
		} else {
			cameraToVertex = normalize( worldPosition.xyz - cameraPosition );
		}
		vec3 worldNormal = inverseTransformDirection( transformedNormal, viewMatrix );
		#ifdef ENVMAP_MODE_REFLECTION
			vReflect = reflect( cameraToVertex, worldNormal );
		#else
			vReflect = refract( cameraToVertex, worldNormal, refractionRatio );
		#endif
	#endif
#endif`,tpr=`#ifdef USE_FOG
	vFogDepth = - mvPosition.z;
#endif`,epr=`#ifdef USE_FOG
	varying float vFogDepth;
#endif`,rpr=`#ifdef USE_FOG
	#ifdef FOG_EXP2
		float fogFactor = 1.0 - exp( - fogDensity * fogDensity * vFogDepth * vFogDepth );
	#else
		float fogFactor = smoothstep( fogNear, fogFar, vFogDepth );
	#endif
	gl_FragColor.rgb = mix( gl_FragColor.rgb, fogColor, fogFactor );
#endif`,npr=`#ifdef USE_FOG
	uniform vec3 fogColor;
	varying float vFogDepth;
	#ifdef FOG_EXP2
		uniform float fogDensity;
	#else
		uniform float fogNear;
		uniform float fogFar;
	#endif
#endif`,ipr=`#ifdef USE_GRADIENTMAP
	uniform sampler2D gradientMap;
#endif
vec3 getGradientIrradiance( vec3 normal, vec3 lightDirection ) {
	float dotNL = dot( normal, lightDirection );
	vec2 coord = vec2( dotNL * 0.5 + 0.5, 0.0 );
	#ifdef USE_GRADIENTMAP
		return vec3( texture2D( gradientMap, coord ).r );
	#else
		return ( coord.x < 0.7 ) ? vec3( 0.7 ) : vec3( 1.0 );
	#endif
}`,opr=`#ifdef USE_LIGHTMAP
	vec4 lightMapTexel = texture2D( lightMap, vUv2 );
	vec3 lightMapIrradiance = lightMapTexel.rgb * lightMapIntensity;
	#ifndef PHYSICALLY_CORRECT_LIGHTS
		lightMapIrradiance *= PI;
	#endif
	reflectedLight.indirectDiffuse += lightMapIrradiance;
#endif`,apr=`#ifdef USE_LIGHTMAP
	uniform sampler2D lightMap;
	uniform float lightMapIntensity;
#endif`,spr=`vec3 diffuse = vec3( 1.0 );
GeometricContext geometry;
geometry.position = mvPosition.xyz;
geometry.normal = normalize( transformedNormal );
geometry.viewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( -mvPosition.xyz );
GeometricContext backGeometry;
backGeometry.position = geometry.position;
backGeometry.normal = -geometry.normal;
backGeometry.viewDir = geometry.viewDir;
vLightFront = vec3( 0.0 );
vIndirectFront = vec3( 0.0 );
#ifdef DOUBLE_SIDED
	vLightBack = vec3( 0.0 );
	vIndirectBack = vec3( 0.0 );
#endif
IncidentLight directLight;
float dotNL;
vec3 directLightColor_Diffuse;
vIndirectFront += getAmbientLightIrradiance( ambientLightColor );
vIndirectFront += getLightProbeIrradiance( lightProbe, geometry.normal );
#ifdef DOUBLE_SIDED
	vIndirectBack += getAmbientLightIrradiance( ambientLightColor );
	vIndirectBack += getLightProbeIrradiance( lightProbe, backGeometry.normal );
#endif
#if NUM_POINT_LIGHTS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {
		getPointLightInfo( pointLights[ i ], geometry, directLight );
		dotNL = dot( geometry.normal, directLight.direction );
		directLightColor_Diffuse = directLight.color;
		vLightFront += saturate( dotNL ) * directLightColor_Diffuse;
		#ifdef DOUBLE_SIDED
			vLightBack += saturate( - dotNL ) * directLightColor_Diffuse;
		#endif
	}
	#pragma unroll_loop_end
#endif
#if NUM_SPOT_LIGHTS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {
		getSpotLightInfo( spotLights[ i ], geometry, directLight );
		dotNL = dot( geometry.normal, directLight.direction );
		directLightColor_Diffuse = directLight.color;
		vLightFront += saturate( dotNL ) * directLightColor_Diffuse;
		#ifdef DOUBLE_SIDED
			vLightBack += saturate( - dotNL ) * directLightColor_Diffuse;
		#endif
	}
	#pragma unroll_loop_end
#endif
#if NUM_DIR_LIGHTS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {
		getDirectionalLightInfo( directionalLights[ i ], geometry, directLight );
		dotNL = dot( geometry.normal, directLight.direction );
		directLightColor_Diffuse = directLight.color;
		vLightFront += saturate( dotNL ) * directLightColor_Diffuse;
		#ifdef DOUBLE_SIDED
			vLightBack += saturate( - dotNL ) * directLightColor_Diffuse;
		#endif
	}
	#pragma unroll_loop_end
#endif
#if NUM_HEMI_LIGHTS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {
		vIndirectFront += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry.normal );
		#ifdef DOUBLE_SIDED
			vIndirectBack += getHemisphereLightIrradiance( hemisphereLights[ i ], backGeometry.normal );
		#endif
	}
	#pragma unroll_loop_end
#endif`,lpr=`uniform bool receiveShadow;
uniform vec3 ambientLightColor;
uniform vec3 lightProbe[ 9 ];
vec3 shGetIrradianceAt( in vec3 normal, in vec3 shCoefficients[ 9 ] ) {
	float x = normal.x, y = normal.y, z = normal.z;
	vec3 result = shCoefficients[ 0 ] * 0.886227;
	result += shCoefficients[ 1 ] * 2.0 * 0.511664 * y;
	result += shCoefficients[ 2 ] * 2.0 * 0.511664 * z;
	result += shCoefficients[ 3 ] * 2.0 * 0.511664 * x;
	result += shCoefficients[ 4 ] * 2.0 * 0.429043 * x * y;
	result += shCoefficients[ 5 ] * 2.0 * 0.429043 * y * z;
	result += shCoefficients[ 6 ] * ( 0.743125 * z * z - 0.247708 );
	result += shCoefficients[ 7 ] * 2.0 * 0.429043 * x * z;
	result += shCoefficients[ 8 ] * 0.429043 * ( x * x - y * y );
	return result;
}
vec3 getLightProbeIrradiance( const in vec3 lightProbe[ 9 ], const in vec3 normal ) {
	vec3 worldNormal = inverseTransformDirection( normal, viewMatrix );
	vec3 irradiance = shGetIrradianceAt( worldNormal, lightProbe );
	return irradiance;
}
vec3 getAmbientLightIrradiance( const in vec3 ambientLightColor ) {
	vec3 irradiance = ambientLightColor;
	return irradiance;
}
float getDistanceAttenuation( const in float lightDistance, const in float cutoffDistance, const in float decayExponent ) {
	#if defined ( PHYSICALLY_CORRECT_LIGHTS )
		float distanceFalloff = 1.0 / max( pow( lightDistance, decayExponent ), 0.01 );
		if ( cutoffDistance > 0.0 ) {
			distanceFalloff *= pow2( saturate( 1.0 - pow4( lightDistance / cutoffDistance ) ) );
		}
		return distanceFalloff;
	#else
		if ( cutoffDistance > 0.0 && decayExponent > 0.0 ) {
			return pow( saturate( - lightDistance / cutoffDistance + 1.0 ), decayExponent );
		}
		return 1.0;
	#endif
}
float getSpotAttenuation( const in float coneCosine, const in float penumbraCosine, const in float angleCosine ) {
	return smoothstep( coneCosine, penumbraCosine, angleCosine );
}
#if NUM_DIR_LIGHTS > 0
	struct DirectionalLight {
		vec3 direction;
		vec3 color;
	};
	uniform DirectionalLight directionalLights[ NUM_DIR_LIGHTS ];
	void getDirectionalLightInfo( const in DirectionalLight directionalLight, const in GeometricContext geometry, out IncidentLight light ) {
		light.color = directionalLight.color;
		light.direction = directionalLight.direction;
		light.visible = true;
	}
#endif
#if NUM_POINT_LIGHTS > 0
	struct PointLight {
		vec3 position;
		vec3 color;
		float distance;
		float decay;
	};
	uniform PointLight pointLights[ NUM_POINT_LIGHTS ];
	void getPointLightInfo( const in PointLight pointLight, const in GeometricContext geometry, out IncidentLight light ) {
		vec3 lVector = pointLight.position - geometry.position;
		light.direction = normalize( lVector );
		float lightDistance = length( lVector );
		light.color = pointLight.color;
		light.color *= getDistanceAttenuation( lightDistance, pointLight.distance, pointLight.decay );
		light.visible = ( light.color != vec3( 0.0 ) );
	}
#endif
#if NUM_SPOT_LIGHTS > 0
	struct SpotLight {
		vec3 position;
		vec3 direction;
		vec3 color;
		float distance;
		float decay;
		float coneCos;
		float penumbraCos;
	};
	uniform SpotLight spotLights[ NUM_SPOT_LIGHTS ];
	void getSpotLightInfo( const in SpotLight spotLight, const in GeometricContext geometry, out IncidentLight light ) {
		vec3 lVector = spotLight.position - geometry.position;
		light.direction = normalize( lVector );
		float angleCos = dot( light.direction, spotLight.direction );
		float spotAttenuation = getSpotAttenuation( spotLight.coneCos, spotLight.penumbraCos, angleCos );
		if ( spotAttenuation > 0.0 ) {
			float lightDistance = length( lVector );
			light.color = spotLight.color * spotAttenuation;
			light.color *= getDistanceAttenuation( lightDistance, spotLight.distance, spotLight.decay );
			light.visible = ( light.color != vec3( 0.0 ) );
		} else {
			light.color = vec3( 0.0 );
			light.visible = false;
		}
	}
#endif
#if NUM_RECT_AREA_LIGHTS > 0
	struct RectAreaLight {
		vec3 color;
		vec3 position;
		vec3 halfWidth;
		vec3 halfHeight;
	};
	uniform sampler2D ltc_1;	uniform sampler2D ltc_2;
	uniform RectAreaLight rectAreaLights[ NUM_RECT_AREA_LIGHTS ];
#endif
#if NUM_HEMI_LIGHTS > 0
	struct HemisphereLight {
		vec3 direction;
		vec3 skyColor;
		vec3 groundColor;
	};
	uniform HemisphereLight hemisphereLights[ NUM_HEMI_LIGHTS ];
	vec3 getHemisphereLightIrradiance( const in HemisphereLight hemiLight, const in vec3 normal ) {
		float dotNL = dot( normal, hemiLight.direction );
		float hemiDiffuseWeight = 0.5 * dotNL + 0.5;
		vec3 irradiance = mix( hemiLight.groundColor, hemiLight.skyColor, hemiDiffuseWeight );
		return irradiance;
	}
#endif`,cpr=`#if defined( USE_ENVMAP )
	#ifdef ENVMAP_MODE_REFRACTION
		uniform float refractionRatio;
	#endif
	vec3 getIBLIrradiance( const in vec3 normal ) {
		#if defined( ENVMAP_TYPE_CUBE_UV )
			vec3 worldNormal = inverseTransformDirection( normal, viewMatrix );
			vec4 envMapColor = textureCubeUV( envMap, worldNormal, 1.0 );
			return PI * envMapColor.rgb * envMapIntensity;
		#else
			return vec3( 0.0 );
		#endif
	}
	vec3 getIBLRadiance( const in vec3 viewDir, const in vec3 normal, const in float roughness ) {
		#if defined( ENVMAP_TYPE_CUBE_UV )
			vec3 reflectVec;
			#ifdef ENVMAP_MODE_REFLECTION
				reflectVec = reflect( - viewDir, normal );
				reflectVec = normalize( mix( reflectVec, normal, roughness * roughness) );
			#else
				reflectVec = refract( - viewDir, normal, refractionRatio );
			#endif
			reflectVec = inverseTransformDirection( reflectVec, viewMatrix );
			vec4 envMapColor = textureCubeUV( envMap, reflectVec, roughness );
			return envMapColor.rgb * envMapIntensity;
		#else
			return vec3( 0.0 );
		#endif
	}
#endif`,upr=`ToonMaterial material;
material.diffuseColor = diffuseColor.rgb;`,hpr=`varying vec3 vViewPosition;
struct ToonMaterial {
	vec3 diffuseColor;
};
void RE_Direct_Toon( const in IncidentLight directLight, const in GeometricContext geometry, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {
	vec3 irradiance = getGradientIrradiance( geometry.normal, directLight.direction ) * directLight.color;
	reflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
}
void RE_IndirectDiffuse_Toon( const in vec3 irradiance, const in GeometricContext geometry, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {
	reflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
}
#define RE_Direct				RE_Direct_Toon
#define RE_IndirectDiffuse		RE_IndirectDiffuse_Toon
#define Material_LightProbeLOD( material )	(0)`,fpr=`BlinnPhongMaterial material;
material.diffuseColor = diffuseColor.rgb;
material.specularColor = specular;
material.specularShininess = shininess;
material.specularStrength = specularStrength;`,ppr=`varying vec3 vViewPosition;
struct BlinnPhongMaterial {
	vec3 diffuseColor;
	vec3 specularColor;
	float specularShininess;
	float specularStrength;
};
void RE_Direct_BlinnPhong( const in IncidentLight directLight, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {
	float dotNL = saturate( dot( geometry.normal, directLight.direction ) );
	vec3 irradiance = dotNL * directLight.color;
	reflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
	reflectedLight.directSpecular += irradiance * BRDF_BlinnPhong( directLight.direction, geometry.viewDir, geometry.normal, material.specularColor, material.specularShininess ) * material.specularStrength;
}
void RE_IndirectDiffuse_BlinnPhong( const in vec3 irradiance, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {
	reflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
}
#define RE_Direct				RE_Direct_BlinnPhong
#define RE_IndirectDiffuse		RE_IndirectDiffuse_BlinnPhong
#define Material_LightProbeLOD( material )	(0)`,dpr=`PhysicalMaterial material;
material.diffuseColor = diffuseColor.rgb * ( 1.0 - metalnessFactor );
vec3 dxy = max( abs( dFdx( geometryNormal ) ), abs( dFdy( geometryNormal ) ) );
float geometryRoughness = max( max( dxy.x, dxy.y ), dxy.z );
material.roughness = max( roughnessFactor, 0.0525 );material.roughness += geometryRoughness;
material.roughness = min( material.roughness, 1.0 );
#ifdef IOR
	#ifdef SPECULAR
		float specularIntensityFactor = specularIntensity;
		vec3 specularColorFactor = specularColor;
		#ifdef USE_SPECULARINTENSITYMAP
			specularIntensityFactor *= texture2D( specularIntensityMap, vUv ).a;
		#endif
		#ifdef USE_SPECULARCOLORMAP
			specularColorFactor *= texture2D( specularColorMap, vUv ).rgb;
		#endif
		material.specularF90 = mix( specularIntensityFactor, 1.0, metalnessFactor );
	#else
		float specularIntensityFactor = 1.0;
		vec3 specularColorFactor = vec3( 1.0 );
		material.specularF90 = 1.0;
	#endif
	material.specularColor = mix( min( pow2( ( ior - 1.0 ) / ( ior + 1.0 ) ) * specularColorFactor, vec3( 1.0 ) ) * specularIntensityFactor, diffuseColor.rgb, metalnessFactor );
#else
	material.specularColor = mix( vec3( 0.04 ), diffuseColor.rgb, metalnessFactor );
	material.specularF90 = 1.0;
#endif
#ifdef USE_CLEARCOAT
	material.clearcoat = clearcoat;
	material.clearcoatRoughness = clearcoatRoughness;
	material.clearcoatF0 = vec3( 0.04 );
	material.clearcoatF90 = 1.0;
	#ifdef USE_CLEARCOATMAP
		material.clearcoat *= texture2D( clearcoatMap, vUv ).x;
	#endif
	#ifdef USE_CLEARCOAT_ROUGHNESSMAP
		material.clearcoatRoughness *= texture2D( clearcoatRoughnessMap, vUv ).y;
	#endif
	material.clearcoat = saturate( material.clearcoat );	material.clearcoatRoughness = max( material.clearcoatRoughness, 0.0525 );
	material.clearcoatRoughness += geometryRoughness;
	material.clearcoatRoughness = min( material.clearcoatRoughness, 1.0 );
#endif
#ifdef USE_SHEEN
	material.sheenColor = sheenColor;
	#ifdef USE_SHEENCOLORMAP
		material.sheenColor *= texture2D( sheenColorMap, vUv ).rgb;
	#endif
	material.sheenRoughness = clamp( sheenRoughness, 0.07, 1.0 );
	#ifdef USE_SHEENROUGHNESSMAP
		material.sheenRoughness *= texture2D( sheenRoughnessMap, vUv ).a;
	#endif
#endif`,mpr=`struct PhysicalMaterial {
	vec3 diffuseColor;
	float roughness;
	vec3 specularColor;
	float specularF90;
	#ifdef USE_CLEARCOAT
		float clearcoat;
		float clearcoatRoughness;
		vec3 clearcoatF0;
		float clearcoatF90;
	#endif
	#ifdef USE_SHEEN
		vec3 sheenColor;
		float sheenRoughness;
	#endif
};
vec3 clearcoatSpecular = vec3( 0.0 );
vec3 sheenSpecular = vec3( 0.0 );
float IBLSheenBRDF( const in vec3 normal, const in vec3 viewDir, const in float roughness) {
	float dotNV = saturate( dot( normal, viewDir ) );
	float r2 = roughness * roughness;
	float a = roughness < 0.25 ? -339.2 * r2 + 161.4 * roughness - 25.9 : -8.48 * r2 + 14.3 * roughness - 9.95;
	float b = roughness < 0.25 ? 44.0 * r2 - 23.7 * roughness + 3.26 : 1.97 * r2 - 3.27 * roughness + 0.72;
	float DG = exp( a * dotNV + b ) + ( roughness < 0.25 ? 0.0 : 0.1 * ( roughness - 0.25 ) );
	return saturate( DG * RECIPROCAL_PI );
}
vec2 DFGApprox( const in vec3 normal, const in vec3 viewDir, const in float roughness ) {
	float dotNV = saturate( dot( normal, viewDir ) );
	const vec4 c0 = vec4( - 1, - 0.0275, - 0.572, 0.022 );
	const vec4 c1 = vec4( 1, 0.0425, 1.04, - 0.04 );
	vec4 r = roughness * c0 + c1;
	float a004 = min( r.x * r.x, exp2( - 9.28 * dotNV ) ) * r.x + r.y;
	vec2 fab = vec2( - 1.04, 1.04 ) * a004 + r.zw;
	return fab;
}
vec3 EnvironmentBRDF( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float roughness ) {
	vec2 fab = DFGApprox( normal, viewDir, roughness );
	return specularColor * fab.x + specularF90 * fab.y;
}
void computeMultiscattering( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float roughness, inout vec3 singleScatter, inout vec3 multiScatter ) {
	vec2 fab = DFGApprox( normal, viewDir, roughness );
	vec3 FssEss = specularColor * fab.x + specularF90 * fab.y;
	float Ess = fab.x + fab.y;
	float Ems = 1.0 - Ess;
	vec3 Favg = specularColor + ( 1.0 - specularColor ) * 0.047619;	vec3 Fms = FssEss * Favg / ( 1.0 - Ems * Favg );
	singleScatter += FssEss;
	multiScatter += Fms * Ems;
}
#if NUM_RECT_AREA_LIGHTS > 0
	void RE_Direct_RectArea_Physical( const in RectAreaLight rectAreaLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {
		vec3 normal = geometry.normal;
		vec3 viewDir = geometry.viewDir;
		vec3 position = geometry.position;
		vec3 lightPos = rectAreaLight.position;
		vec3 halfWidth = rectAreaLight.halfWidth;
		vec3 halfHeight = rectAreaLight.halfHeight;
		vec3 lightColor = rectAreaLight.color;
		float roughness = material.roughness;
		vec3 rectCoords[ 4 ];
		rectCoords[ 0 ] = lightPos + halfWidth - halfHeight;		rectCoords[ 1 ] = lightPos - halfWidth - halfHeight;
		rectCoords[ 2 ] = lightPos - halfWidth + halfHeight;
		rectCoords[ 3 ] = lightPos + halfWidth + halfHeight;
		vec2 uv = LTC_Uv( normal, viewDir, roughness );
		vec4 t1 = texture2D( ltc_1, uv );
		vec4 t2 = texture2D( ltc_2, uv );
		mat3 mInv = mat3(
			vec3( t1.x, 0, t1.y ),
			vec3(    0, 1,    0 ),
			vec3( t1.z, 0, t1.w )
		);
		vec3 fresnel = ( material.specularColor * t2.x + ( vec3( 1.0 ) - material.specularColor ) * t2.y );
		reflectedLight.directSpecular += lightColor * fresnel * LTC_Evaluate( normal, viewDir, position, mInv, rectCoords );
		reflectedLight.directDiffuse += lightColor * material.diffuseColor * LTC_Evaluate( normal, viewDir, position, mat3( 1.0 ), rectCoords );
	}
#endif
void RE_Direct_Physical( const in IncidentLight directLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {
	float dotNL = saturate( dot( geometry.normal, directLight.direction ) );
	vec3 irradiance = dotNL * directLight.color;
	#ifdef USE_CLEARCOAT
		float dotNLcc = saturate( dot( geometry.clearcoatNormal, directLight.direction ) );
		vec3 ccIrradiance = dotNLcc * directLight.color;
		clearcoatSpecular += ccIrradiance * BRDF_GGX( directLight.direction, geometry.viewDir, geometry.clearcoatNormal, material.clearcoatF0, material.clearcoatF90, material.clearcoatRoughness );
	#endif
	#ifdef USE_SHEEN
		sheenSpecular += irradiance * BRDF_Sheen( directLight.direction, geometry.viewDir, geometry.normal, material.sheenColor, material.sheenRoughness );
	#endif
	reflectedLight.directSpecular += irradiance * BRDF_GGX( directLight.direction, geometry.viewDir, geometry.normal, material.specularColor, material.specularF90, material.roughness );
	reflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
}
void RE_IndirectDiffuse_Physical( const in vec3 irradiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {
	reflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
}
void RE_IndirectSpecular_Physical( const in vec3 radiance, const in vec3 irradiance, const in vec3 clearcoatRadiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight) {
	#ifdef USE_CLEARCOAT
		clearcoatSpecular += clearcoatRadiance * EnvironmentBRDF( geometry.clearcoatNormal, geometry.viewDir, material.clearcoatF0, material.clearcoatF90, material.clearcoatRoughness );
	#endif
	#ifdef USE_SHEEN
		sheenSpecular += irradiance * material.sheenColor * IBLSheenBRDF( geometry.normal, geometry.viewDir, material.sheenRoughness );
	#endif
	vec3 singleScattering = vec3( 0.0 );
	vec3 multiScattering = vec3( 0.0 );
	vec3 cosineWeightedIrradiance = irradiance * RECIPROCAL_PI;
	computeMultiscattering( geometry.normal, geometry.viewDir, material.specularColor, material.specularF90, material.roughness, singleScattering, multiScattering );
	vec3 diffuse = material.diffuseColor * ( 1.0 - ( singleScattering + multiScattering ) );
	reflectedLight.indirectSpecular += radiance * singleScattering;
	reflectedLight.indirectSpecular += multiScattering * cosineWeightedIrradiance;
	reflectedLight.indirectDiffuse += diffuse * cosineWeightedIrradiance;
}
#define RE_Direct				RE_Direct_Physical
#define RE_Direct_RectArea		RE_Direct_RectArea_Physical
#define RE_IndirectDiffuse		RE_IndirectDiffuse_Physical
#define RE_IndirectSpecular		RE_IndirectSpecular_Physical
float computeSpecularOcclusion( const in float dotNV, const in float ambientOcclusion, const in float roughness ) {
	return saturate( pow( dotNV + ambientOcclusion, exp2( - 16.0 * roughness - 1.0 ) ) - 1.0 + ambientOcclusion );
}`,gpr=`
GeometricContext geometry;
geometry.position = - vViewPosition;
geometry.normal = normal;
geometry.viewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( vViewPosition );
#ifdef USE_CLEARCOAT
	geometry.clearcoatNormal = clearcoatNormal;
#endif
IncidentLight directLight;
#if ( NUM_POINT_LIGHTS > 0 ) && defined( RE_Direct )
	PointLight pointLight;
	#if defined( USE_SHADOWMAP ) && NUM_POINT_LIGHT_SHADOWS > 0
	PointLightShadow pointLightShadow;
	#endif
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {
		pointLight = pointLights[ i ];
		getPointLightInfo( pointLight, geometry, directLight );
		#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_POINT_LIGHT_SHADOWS )
		pointLightShadow = pointLightShadows[ i ];
		directLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getPointShadow( pointShadowMap[ i ], pointLightShadow.shadowMapSize, pointLightShadow.shadowBias, pointLightShadow.shadowRadius, vPointShadowCoord[ i ], pointLightShadow.shadowCameraNear, pointLightShadow.shadowCameraFar ) : 1.0;
		#endif
		RE_Direct( directLight, geometry, material, reflectedLight );
	}
	#pragma unroll_loop_end
#endif
#if ( NUM_SPOT_LIGHTS > 0 ) && defined( RE_Direct )
	SpotLight spotLight;
	#if defined( USE_SHADOWMAP ) && NUM_SPOT_LIGHT_SHADOWS > 0
	SpotLightShadow spotLightShadow;
	#endif
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {
		spotLight = spotLights[ i ];
		getSpotLightInfo( spotLight, geometry, directLight );
		#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )
		spotLightShadow = spotLightShadows[ i ];
		directLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getShadow( spotShadowMap[ i ], spotLightShadow.shadowMapSize, spotLightShadow.shadowBias, spotLightShadow.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;
		#endif
		RE_Direct( directLight, geometry, material, reflectedLight );
	}
	#pragma unroll_loop_end
#endif
#if ( NUM_DIR_LIGHTS > 0 ) && defined( RE_Direct )
	DirectionalLight directionalLight;
	#if defined( USE_SHADOWMAP ) && NUM_DIR_LIGHT_SHADOWS > 0
	DirectionalLightShadow directionalLightShadow;
	#endif
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {
		directionalLight = directionalLights[ i ];
		getDirectionalLightInfo( directionalLight, geometry, directLight );
		#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS )
		directionalLightShadow = directionalLightShadows[ i ];
		directLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getShadow( directionalShadowMap[ i ], directionalLightShadow.shadowMapSize, directionalLightShadow.shadowBias, directionalLightShadow.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;
		#endif
		RE_Direct( directLight, geometry, material, reflectedLight );
	}
	#pragma unroll_loop_end
#endif
#if ( NUM_RECT_AREA_LIGHTS > 0 ) && defined( RE_Direct_RectArea )
	RectAreaLight rectAreaLight;
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_RECT_AREA_LIGHTS; i ++ ) {
		rectAreaLight = rectAreaLights[ i ];
		RE_Direct_RectArea( rectAreaLight, geometry, material, reflectedLight );
	}
	#pragma unroll_loop_end
#endif
#if defined( RE_IndirectDiffuse )
	vec3 iblIrradiance = vec3( 0.0 );
	vec3 irradiance = getAmbientLightIrradiance( ambientLightColor );
	irradiance += getLightProbeIrradiance( lightProbe, geometry.normal );
	#if ( NUM_HEMI_LIGHTS > 0 )
		#pragma unroll_loop_start
		for ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {
			irradiance += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry.normal );
		}
		#pragma unroll_loop_end
	#endif
#endif
#if defined( RE_IndirectSpecular )
	vec3 radiance = vec3( 0.0 );
	vec3 clearcoatRadiance = vec3( 0.0 );
#endif`,_pr=`#if defined( RE_IndirectDiffuse )
	#ifdef USE_LIGHTMAP
		vec4 lightMapTexel = texture2D( lightMap, vUv2 );
		vec3 lightMapIrradiance = lightMapTexel.rgb * lightMapIntensity;
		#ifndef PHYSICALLY_CORRECT_LIGHTS
			lightMapIrradiance *= PI;
		#endif
		irradiance += lightMapIrradiance;
	#endif
	#if defined( USE_ENVMAP ) && defined( STANDARD ) && defined( ENVMAP_TYPE_CUBE_UV )
		iblIrradiance += getIBLIrradiance( geometry.normal );
	#endif
#endif
#if defined( USE_ENVMAP ) && defined( RE_IndirectSpecular )
	radiance += getIBLRadiance( geometry.viewDir, geometry.normal, material.roughness );
	#ifdef USE_CLEARCOAT
		clearcoatRadiance += getIBLRadiance( geometry.viewDir, geometry.clearcoatNormal, material.clearcoatRoughness );
	#endif
#endif`,ypr=`#if defined( RE_IndirectDiffuse )
	RE_IndirectDiffuse( irradiance, geometry, material, reflectedLight );
#endif
#if defined( RE_IndirectSpecular )
	RE_IndirectSpecular( radiance, iblIrradiance, clearcoatRadiance, geometry, material, reflectedLight );
#endif`,vpr=`#if defined( USE_LOGDEPTHBUF ) && defined( USE_LOGDEPTHBUF_EXT )
	gl_FragDepthEXT = vIsPerspective == 0.0 ? gl_FragCoord.z : log2( vFragDepth ) * logDepthBufFC * 0.5;
#endif`,xpr=`#if defined( USE_LOGDEPTHBUF ) && defined( USE_LOGDEPTHBUF_EXT )
	uniform float logDepthBufFC;
	varying float vFragDepth;
	varying float vIsPerspective;
#endif`,bpr=`#ifdef USE_LOGDEPTHBUF
	#ifdef USE_LOGDEPTHBUF_EXT
		varying float vFragDepth;
		varying float vIsPerspective;
	#else
		uniform float logDepthBufFC;
	#endif
#endif`,wpr=`#ifdef USE_LOGDEPTHBUF
	#ifdef USE_LOGDEPTHBUF_EXT
		vFragDepth = 1.0 + gl_Position.w;
		vIsPerspective = float( isPerspectiveMatrix( projectionMatrix ) );
	#else
		if ( isPerspectiveMatrix( projectionMatrix ) ) {
			gl_Position.z = log2( max( EPSILON, gl_Position.w + 1.0 ) ) * logDepthBufFC - 1.0;
			gl_Position.z *= gl_Position.w;
		}
	#endif
#endif`,Spr=`#ifdef USE_MAP
	vec4 sampledDiffuseColor = texture2D( map, vUv );
	#ifdef DECODE_VIDEO_TEXTURE
		sampledDiffuseColor = vec4( mix( pow( sampledDiffuseColor.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), sampledDiffuseColor.rgb * 0.0773993808, vec3( lessThanEqual( sampledDiffuseColor.rgb, vec3( 0.04045 ) ) ) ), sampledDiffuseColor.w );
	#endif
	diffuseColor *= sampledDiffuseColor;
#endif`,Mpr=`#ifdef USE_MAP
	uniform sampler2D map;
#endif`,Epr=`#if defined( USE_MAP ) || defined( USE_ALPHAMAP )
	vec2 uv = ( uvTransform * vec3( gl_PointCoord.x, 1.0 - gl_PointCoord.y, 1 ) ).xy;
#endif
#ifdef USE_MAP
	diffuseColor *= texture2D( map, uv );
#endif
#ifdef USE_ALPHAMAP
	diffuseColor.a *= texture2D( alphaMap, uv ).g;
#endif`,Tpr=`#if defined( USE_MAP ) || defined( USE_ALPHAMAP )
	uniform mat3 uvTransform;
#endif
#ifdef USE_MAP
	uniform sampler2D map;
#endif
#ifdef USE_ALPHAMAP
	uniform sampler2D alphaMap;
#endif`,Cpr=`float metalnessFactor = metalness;
#ifdef USE_METALNESSMAP
	vec4 texelMetalness = texture2D( metalnessMap, vUv );
	metalnessFactor *= texelMetalness.b;
#endif`,Apr=`#ifdef USE_METALNESSMAP
	uniform sampler2D metalnessMap;
#endif`,Ppr=`#ifdef USE_MORPHNORMALS
	objectNormal *= morphTargetBaseInfluence;
	#ifdef MORPHTARGETS_TEXTURE
		for ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {
			if ( morphTargetInfluences[ i ] != 0.0 ) objectNormal += getMorph( gl_VertexID, i, 1, 2 ) * morphTargetInfluences[ i ];
		}
	#else
		objectNormal += morphNormal0 * morphTargetInfluences[ 0 ];
		objectNormal += morphNormal1 * morphTargetInfluences[ 1 ];
		objectNormal += morphNormal2 * morphTargetInfluences[ 2 ];
		objectNormal += morphNormal3 * morphTargetInfluences[ 3 ];
	#endif
#endif`,Ipr=`#ifdef USE_MORPHTARGETS
	uniform float morphTargetBaseInfluence;
	#ifdef MORPHTARGETS_TEXTURE
		uniform float morphTargetInfluences[ MORPHTARGETS_COUNT ];
		uniform sampler2DArray morphTargetsTexture;
		uniform vec2 morphTargetsTextureSize;
		vec3 getMorph( const in int vertexIndex, const in int morphTargetIndex, const in int offset, const in int stride ) {
			float texelIndex = float( vertexIndex * stride + offset );
			float y = floor( texelIndex / morphTargetsTextureSize.x );
			float x = texelIndex - y * morphTargetsTextureSize.x;
			vec3 morphUV = vec3( ( x + 0.5 ) / morphTargetsTextureSize.x, y / morphTargetsTextureSize.y, morphTargetIndex );
			return texture( morphTargetsTexture, morphUV ).xyz;
		}
	#else
		#ifndef USE_MORPHNORMALS
			uniform float morphTargetInfluences[ 8 ];
		#else
			uniform float morphTargetInfluences[ 4 ];
		#endif
	#endif
#endif`,Lpr=`#ifdef USE_MORPHTARGETS
	transformed *= morphTargetBaseInfluence;
	#ifdef MORPHTARGETS_TEXTURE
		for ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {
			#ifndef USE_MORPHNORMALS
				if ( morphTargetInfluences[ i ] != 0.0 ) transformed += getMorph( gl_VertexID, i, 0, 1 ) * morphTargetInfluences[ i ];
			#else
				if ( morphTargetInfluences[ i ] != 0.0 ) transformed += getMorph( gl_VertexID, i, 0, 2 ) * morphTargetInfluences[ i ];
			#endif
		}
	#else
		transformed += morphTarget0 * morphTargetInfluences[ 0 ];
		transformed += morphTarget1 * morphTargetInfluences[ 1 ];
		transformed += morphTarget2 * morphTargetInfluences[ 2 ];
		transformed += morphTarget3 * morphTargetInfluences[ 3 ];
		#ifndef USE_MORPHNORMALS
			transformed += morphTarget4 * morphTargetInfluences[ 4 ];
			transformed += morphTarget5 * morphTargetInfluences[ 5 ];
			transformed += morphTarget6 * morphTargetInfluences[ 6 ];
			transformed += morphTarget7 * morphTargetInfluences[ 7 ];
		#endif
	#endif
#endif`,kpr=`float faceDirection = gl_FrontFacing ? 1.0 : - 1.0;
#ifdef FLAT_SHADED
	vec3 fdx = vec3( dFdx( vViewPosition.x ), dFdx( vViewPosition.y ), dFdx( vViewPosition.z ) );
	vec3 fdy = vec3( dFdy( vViewPosition.x ), dFdy( vViewPosition.y ), dFdy( vViewPosition.z ) );
	vec3 normal = normalize( cross( fdx, fdy ) );
#else
	vec3 normal = normalize( vNormal );
	#ifdef DOUBLE_SIDED
		normal = normal * faceDirection;
	#endif
	#ifdef USE_TANGENT
		vec3 tangent = normalize( vTangent );
		vec3 bitangent = normalize( vBitangent );
		#ifdef DOUBLE_SIDED
			tangent = tangent * faceDirection;
			bitangent = bitangent * faceDirection;
		#endif
		#if defined( TANGENTSPACE_NORMALMAP ) || defined( USE_CLEARCOAT_NORMALMAP )
			mat3 vTBN = mat3( tangent, bitangent, normal );
		#endif
	#endif
#endif
vec3 geometryNormal = normal;`,Rpr=`#ifdef OBJECTSPACE_NORMALMAP
	normal = texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;
	#ifdef FLIP_SIDED
		normal = - normal;
	#endif
	#ifdef DOUBLE_SIDED
		normal = normal * faceDirection;
	#endif
	normal = normalize( normalMatrix * normal );
#elif defined( TANGENTSPACE_NORMALMAP )
	vec3 mapN = texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;
	mapN.xy *= normalScale;
	#ifdef USE_TANGENT
		normal = normalize( vTBN * mapN );
	#else
		normal = perturbNormal2Arb( - vViewPosition, normal, mapN, faceDirection );
	#endif
#elif defined( USE_BUMPMAP )
	normal = perturbNormalArb( - vViewPosition, normal, dHdxy_fwd(), faceDirection );
#endif`,Npr=`#ifndef FLAT_SHADED
	varying vec3 vNormal;
	#ifdef USE_TANGENT
		varying vec3 vTangent;
		varying vec3 vBitangent;
	#endif
#endif`,Dpr=`#ifndef FLAT_SHADED
	varying vec3 vNormal;
	#ifdef USE_TANGENT
		varying vec3 vTangent;
		varying vec3 vBitangent;
	#endif
#endif`,Opr=`#ifndef FLAT_SHADED
	vNormal = normalize( transformedNormal );
	#ifdef USE_TANGENT
		vTangent = normalize( transformedTangent );
		vBitangent = normalize( cross( vNormal, vTangent ) * tangent.w );
	#endif
#endif`,zpr=`#ifdef USE_NORMALMAP
	uniform sampler2D normalMap;
	uniform vec2 normalScale;
#endif
#ifdef OBJECTSPACE_NORMALMAP
	uniform mat3 normalMatrix;
#endif
#if ! defined ( USE_TANGENT ) && ( defined ( TANGENTSPACE_NORMALMAP ) || defined ( USE_CLEARCOAT_NORMALMAP ) )
	vec3 perturbNormal2Arb( vec3 eye_pos, vec3 surf_norm, vec3 mapN, float faceDirection ) {
		vec3 q0 = vec3( dFdx( eye_pos.x ), dFdx( eye_pos.y ), dFdx( eye_pos.z ) );
		vec3 q1 = vec3( dFdy( eye_pos.x ), dFdy( eye_pos.y ), dFdy( eye_pos.z ) );
		vec2 st0 = dFdx( vUv.st );
		vec2 st1 = dFdy( vUv.st );
		vec3 N = surf_norm;
		vec3 q1perp = cross( q1, N );
		vec3 q0perp = cross( N, q0 );
		vec3 T = q1perp * st0.x + q0perp * st1.x;
		vec3 B = q1perp * st0.y + q0perp * st1.y;
		float det = max( dot( T, T ), dot( B, B ) );
		float scale = ( det == 0.0 ) ? 0.0 : faceDirection * inversesqrt( det );
		return normalize( T * ( mapN.x * scale ) + B * ( mapN.y * scale ) + N * mapN.z );
	}
#endif`,Fpr=`#ifdef USE_CLEARCOAT
	vec3 clearcoatNormal = geometryNormal;
#endif`,Bpr=`#ifdef USE_CLEARCOAT_NORMALMAP
	vec3 clearcoatMapN = texture2D( clearcoatNormalMap, vUv ).xyz * 2.0 - 1.0;
	clearcoatMapN.xy *= clearcoatNormalScale;
	#ifdef USE_TANGENT
		clearcoatNormal = normalize( vTBN * clearcoatMapN );
	#else
		clearcoatNormal = perturbNormal2Arb( - vViewPosition, clearcoatNormal, clearcoatMapN, faceDirection );
	#endif
#endif`,Hpr=`#ifdef USE_CLEARCOATMAP
	uniform sampler2D clearcoatMap;
#endif
#ifdef USE_CLEARCOAT_ROUGHNESSMAP
	uniform sampler2D clearcoatRoughnessMap;
#endif
#ifdef USE_CLEARCOAT_NORMALMAP
	uniform sampler2D clearcoatNormalMap;
	uniform vec2 clearcoatNormalScale;
#endif`,Vpr=`#ifdef OPAQUE
diffuseColor.a = 1.0;
#endif
#ifdef USE_TRANSMISSION
diffuseColor.a *= transmissionAlpha + 0.1;
#endif
gl_FragColor = vec4( outgoingLight, diffuseColor.a );`,Upr=`vec3 packNormalToRGB( const in vec3 normal ) {
	return normalize( normal ) * 0.5 + 0.5;
}
vec3 unpackRGBToNormal( const in vec3 rgb ) {
	return 2.0 * rgb.xyz - 1.0;
}
const float PackUpscale = 256. / 255.;const float UnpackDownscale = 255. / 256.;
const vec3 PackFactors = vec3( 256. * 256. * 256., 256. * 256., 256. );
const vec4 UnpackFactors = UnpackDownscale / vec4( PackFactors, 1. );
const float ShiftRight8 = 1. / 256.;
vec4 packDepthToRGBA( const in float v ) {
	vec4 r = vec4( fract( v * PackFactors ), v );
	r.yzw -= r.xyz * ShiftRight8;	return r * PackUpscale;
}
float unpackRGBAToDepth( const in vec4 v ) {
	return dot( v, UnpackFactors );
}
vec4 pack2HalfToRGBA( vec2 v ) {
	vec4 r = vec4( v.x, fract( v.x * 255.0 ), v.y, fract( v.y * 255.0 ) );
	return vec4( r.x - r.y / 255.0, r.y, r.z - r.w / 255.0, r.w );
}
vec2 unpackRGBATo2Half( vec4 v ) {
	return vec2( v.x + ( v.y / 255.0 ), v.z + ( v.w / 255.0 ) );
}
float viewZToOrthographicDepth( const in float viewZ, const in float near, const in float far ) {
	return ( viewZ + near ) / ( near - far );
}
float orthographicDepthToViewZ( const in float linearClipZ, const in float near, const in float far ) {
	return linearClipZ * ( near - far ) - near;
}
float viewZToPerspectiveDepth( const in float viewZ, const in float near, const in float far ) {
	return ( ( near + viewZ ) * far ) / ( ( far - near ) * viewZ );
}
float perspectiveDepthToViewZ( const in float invClipZ, const in float near, const in float far ) {
	return ( near * far ) / ( ( far - near ) * invClipZ - far );
}`,qpr=`#ifdef PREMULTIPLIED_ALPHA
	gl_FragColor.rgb *= gl_FragColor.a;
#endif`,Gpr=`vec4 mvPosition = vec4( transformed, 1.0 );
#ifdef USE_INSTANCING
	mvPosition = instanceMatrix * mvPosition;
#endif
mvPosition = modelViewMatrix * mvPosition;
gl_Position = projectionMatrix * mvPosition;`,Wpr=`#ifdef DITHERING
	gl_FragColor.rgb = dithering( gl_FragColor.rgb );
#endif`,Ypr=`#ifdef DITHERING
	vec3 dithering( vec3 color ) {
		float grid_position = rand( gl_FragCoord.xy );
		vec3 dither_shift_RGB = vec3( 0.25 / 255.0, -0.25 / 255.0, 0.25 / 255.0 );
		dither_shift_RGB = mix( 2.0 * dither_shift_RGB, -2.0 * dither_shift_RGB, grid_position );
		return color + dither_shift_RGB;
	}
#endif`,jpr=`float roughnessFactor = roughness;
#ifdef USE_ROUGHNESSMAP
	vec4 texelRoughness = texture2D( roughnessMap, vUv );
	roughnessFactor *= texelRoughness.g;
#endif`,Xpr=`#ifdef USE_ROUGHNESSMAP
	uniform sampler2D roughnessMap;
#endif`,$pr=`#ifdef USE_SHADOWMAP
	#if NUM_DIR_LIGHT_SHADOWS > 0
		uniform sampler2D directionalShadowMap[ NUM_DIR_LIGHT_SHADOWS ];
		varying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];
		struct DirectionalLightShadow {
			float shadowBias;
			float shadowNormalBias;
			float shadowRadius;
			vec2 shadowMapSize;
		};
		uniform DirectionalLightShadow directionalLightShadows[ NUM_DIR_LIGHT_SHADOWS ];
	#endif
	#if NUM_SPOT_LIGHT_SHADOWS > 0
		uniform sampler2D spotShadowMap[ NUM_SPOT_LIGHT_SHADOWS ];
		varying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHT_SHADOWS ];
		struct SpotLightShadow {
			float shadowBias;
			float shadowNormalBias;
			float shadowRadius;
			vec2 shadowMapSize;
		};
		uniform SpotLightShadow spotLightShadows[ NUM_SPOT_LIGHT_SHADOWS ];
	#endif
	#if NUM_POINT_LIGHT_SHADOWS > 0
		uniform sampler2D pointShadowMap[ NUM_POINT_LIGHT_SHADOWS ];
		varying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];
		struct PointLightShadow {
			float shadowBias;
			float shadowNormalBias;
			float shadowRadius;
			vec2 shadowMapSize;
			float shadowCameraNear;
			float shadowCameraFar;
		};
		uniform PointLightShadow pointLightShadows[ NUM_POINT_LIGHT_SHADOWS ];
	#endif
	float texture2DCompare( sampler2D depths, vec2 uv, float compare ) {
		return step( compare, unpackRGBAToDepth( texture2D( depths, uv ) ) );
	}
	vec2 texture2DDistribution( sampler2D shadow, vec2 uv ) {
		return unpackRGBATo2Half( texture2D( shadow, uv ) );
	}
	float VSMShadow (sampler2D shadow, vec2 uv, float compare ){
		float occlusion = 1.0;
		vec2 distribution = texture2DDistribution( shadow, uv );
		float hard_shadow = step( compare , distribution.x );
		if (hard_shadow != 1.0 ) {
			float distance = compare - distribution.x ;
			float variance = max( 0.00000, distribution.y * distribution.y );
			float softness_probability = variance / (variance + distance * distance );			softness_probability = clamp( ( softness_probability - 0.3 ) / ( 0.95 - 0.3 ), 0.0, 1.0 );			occlusion = clamp( max( hard_shadow, softness_probability ), 0.0, 1.0 );
		}
		return occlusion;
	}
	float getShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord ) {
		float shadow = 1.0;
		shadowCoord.xyz /= shadowCoord.w;
		shadowCoord.z += shadowBias;
		bvec4 inFrustumVec = bvec4 ( shadowCoord.x >= 0.0, shadowCoord.x <= 1.0, shadowCoord.y >= 0.0, shadowCoord.y <= 1.0 );
		bool inFrustum = all( inFrustumVec );
		bvec2 frustumTestVec = bvec2( inFrustum, shadowCoord.z <= 1.0 );
		bool frustumTest = all( frustumTestVec );
		if ( frustumTest ) {
		#if defined( SHADOWMAP_TYPE_PCF )
			vec2 texelSize = vec2( 1.0 ) / shadowMapSize;
			float dx0 = - texelSize.x * shadowRadius;
			float dy0 = - texelSize.y * shadowRadius;
			float dx1 = + texelSize.x * shadowRadius;
			float dy1 = + texelSize.y * shadowRadius;
			float dx2 = dx0 / 2.0;
			float dy2 = dy0 / 2.0;
			float dx3 = dx1 / 2.0;
			float dy3 = dy1 / 2.0;
			shadow = (
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, dy2 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy2 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, dy2 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, 0.0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, 0.0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, 0.0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, 0.0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, dy3 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy3 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, dy3 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy1 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy1 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy1 ), shadowCoord.z )
			) * ( 1.0 / 17.0 );
		#elif defined( SHADOWMAP_TYPE_PCF_SOFT )
			vec2 texelSize = vec2( 1.0 ) / shadowMapSize;
			float dx = texelSize.x;
			float dy = texelSize.y;
			vec2 uv = shadowCoord.xy;
			vec2 f = fract( uv * shadowMapSize + 0.5 );
			uv -= f * texelSize;
			shadow = (
				texture2DCompare( shadowMap, uv, shadowCoord.z ) +
				texture2DCompare( shadowMap, uv + vec2( dx, 0.0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, uv + vec2( 0.0, dy ), shadowCoord.z ) +
				texture2DCompare( shadowMap, uv + texelSize, shadowCoord.z ) +
				mix( texture2DCompare( shadowMap, uv + vec2( -dx, 0.0 ), shadowCoord.z ), 
					 texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, 0.0 ), shadowCoord.z ),
					 f.x ) +
				mix( texture2DCompare( shadowMap, uv + vec2( -dx, dy ), shadowCoord.z ), 
					 texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, dy ), shadowCoord.z ),
					 f.x ) +
				mix( texture2DCompare( shadowMap, uv + vec2( 0.0, -dy ), shadowCoord.z ), 
					 texture2DCompare( shadowMap, uv + vec2( 0.0, 2.0 * dy ), shadowCoord.z ),
					 f.y ) +
				mix( texture2DCompare( shadowMap, uv + vec2( dx, -dy ), shadowCoord.z ), 
					 texture2DCompare( shadowMap, uv + vec2( dx, 2.0 * dy ), shadowCoord.z ),
					 f.y ) +
				mix( mix( texture2DCompare( shadowMap, uv + vec2( -dx, -dy ), shadowCoord.z ), 
						  texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, -dy ), shadowCoord.z ),
						  f.x ),
					 mix( texture2DCompare( shadowMap, uv + vec2( -dx, 2.0 * dy ), shadowCoord.z ), 
						  texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, 2.0 * dy ), shadowCoord.z ),
						  f.x ),
					 f.y )
			) * ( 1.0 / 9.0 );
		#elif defined( SHADOWMAP_TYPE_VSM )
			shadow = VSMShadow( shadowMap, shadowCoord.xy, shadowCoord.z );
		#else
			shadow = texture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z );
		#endif
		}
		return shadow;
	}
	vec2 cubeToUV( vec3 v, float texelSizeY ) {
		vec3 absV = abs( v );
		float scaleToCube = 1.0 / max( absV.x, max( absV.y, absV.z ) );
		absV *= scaleToCube;
		v *= scaleToCube * ( 1.0 - 2.0 * texelSizeY );
		vec2 planar = v.xy;
		float almostATexel = 1.5 * texelSizeY;
		float almostOne = 1.0 - almostATexel;
		if ( absV.z >= almostOne ) {
			if ( v.z > 0.0 )
				planar.x = 4.0 - v.x;
		} else if ( absV.x >= almostOne ) {
			float signX = sign( v.x );
			planar.x = v.z * signX + 2.0 * signX;
		} else if ( absV.y >= almostOne ) {
			float signY = sign( v.y );
			planar.x = v.x + 2.0 * signY + 2.0;
			planar.y = v.z * signY - 2.0;
		}
		return vec2( 0.125, 0.25 ) * planar + vec2( 0.375, 0.75 );
	}
	float getPointShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord, float shadowCameraNear, float shadowCameraFar ) {
		vec2 texelSize = vec2( 1.0 ) / ( shadowMapSize * vec2( 4.0, 2.0 ) );
		vec3 lightToPosition = shadowCoord.xyz;
		float dp = ( length( lightToPosition ) - shadowCameraNear ) / ( shadowCameraFar - shadowCameraNear );		dp += shadowBias;
		vec3 bd3D = normalize( lightToPosition );
		#if defined( SHADOWMAP_TYPE_PCF ) || defined( SHADOWMAP_TYPE_PCF_SOFT ) || defined( SHADOWMAP_TYPE_VSM )
			vec2 offset = vec2( - 1, 1 ) * shadowRadius * texelSize.y;
			return (
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyy, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyy, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyx, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyx, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxy, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxy, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxx, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxx, texelSize.y ), dp )
			) * ( 1.0 / 9.0 );
		#else
			return texture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp );
		#endif
	}
#endif`,Kpr=`#ifdef USE_SHADOWMAP
	#if NUM_DIR_LIGHT_SHADOWS > 0
		uniform mat4 directionalShadowMatrix[ NUM_DIR_LIGHT_SHADOWS ];
		varying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];
		struct DirectionalLightShadow {
			float shadowBias;
			float shadowNormalBias;
			float shadowRadius;
			vec2 shadowMapSize;
		};
		uniform DirectionalLightShadow directionalLightShadows[ NUM_DIR_LIGHT_SHADOWS ];
	#endif
	#if NUM_SPOT_LIGHT_SHADOWS > 0
		uniform mat4 spotShadowMatrix[ NUM_SPOT_LIGHT_SHADOWS ];
		varying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHT_SHADOWS ];
		struct SpotLightShadow {
			float shadowBias;
			float shadowNormalBias;
			float shadowRadius;
			vec2 shadowMapSize;
		};
		uniform SpotLightShadow spotLightShadows[ NUM_SPOT_LIGHT_SHADOWS ];
	#endif
	#if NUM_POINT_LIGHT_SHADOWS > 0
		uniform mat4 pointShadowMatrix[ NUM_POINT_LIGHT_SHADOWS ];
		varying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];
		struct PointLightShadow {
			float shadowBias;
			float shadowNormalBias;
			float shadowRadius;
			vec2 shadowMapSize;
			float shadowCameraNear;
			float shadowCameraFar;
		};
		uniform PointLightShadow pointLightShadows[ NUM_POINT_LIGHT_SHADOWS ];
	#endif
#endif`,Zpr=`#ifdef USE_SHADOWMAP
	#if NUM_DIR_LIGHT_SHADOWS > 0 || NUM_SPOT_LIGHT_SHADOWS > 0 || NUM_POINT_LIGHT_SHADOWS > 0
		vec3 shadowWorldNormal = inverseTransformDirection( transformedNormal, viewMatrix );
		vec4 shadowWorldPosition;
	#endif
	#if NUM_DIR_LIGHT_SHADOWS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {
		shadowWorldPosition = worldPosition + vec4( shadowWorldNormal * directionalLightShadows[ i ].shadowNormalBias, 0 );
		vDirectionalShadowCoord[ i ] = directionalShadowMatrix[ i ] * shadowWorldPosition;
	}
	#pragma unroll_loop_end
	#endif
	#if NUM_SPOT_LIGHT_SHADOWS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_SPOT_LIGHT_SHADOWS; i ++ ) {
		shadowWorldPosition = worldPosition + vec4( shadowWorldNormal * spotLightShadows[ i ].shadowNormalBias, 0 );
		vSpotShadowCoord[ i ] = spotShadowMatrix[ i ] * shadowWorldPosition;
	}
	#pragma unroll_loop_end
	#endif
	#if NUM_POINT_LIGHT_SHADOWS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {
		shadowWorldPosition = worldPosition + vec4( shadowWorldNormal * pointLightShadows[ i ].shadowNormalBias, 0 );
		vPointShadowCoord[ i ] = pointShadowMatrix[ i ] * shadowWorldPosition;
	}
	#pragma unroll_loop_end
	#endif
#endif`,Jpr=`float getShadowMask() {
	float shadow = 1.0;
	#ifdef USE_SHADOWMAP
	#if NUM_DIR_LIGHT_SHADOWS > 0
	DirectionalLightShadow directionalLight;
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {
		directionalLight = directionalLightShadows[ i ];
		shadow *= receiveShadow ? getShadow( directionalShadowMap[ i ], directionalLight.shadowMapSize, directionalLight.shadowBias, directionalLight.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;
	}
	#pragma unroll_loop_end
	#endif
	#if NUM_SPOT_LIGHT_SHADOWS > 0
	SpotLightShadow spotLight;
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_SPOT_LIGHT_SHADOWS; i ++ ) {
		spotLight = spotLightShadows[ i ];
		shadow *= receiveShadow ? getShadow( spotShadowMap[ i ], spotLight.shadowMapSize, spotLight.shadowBias, spotLight.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;
	}
	#pragma unroll_loop_end
	#endif
	#if NUM_POINT_LIGHT_SHADOWS > 0
	PointLightShadow pointLight;
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {
		pointLight = pointLightShadows[ i ];
		shadow *= receiveShadow ? getPointShadow( pointShadowMap[ i ], pointLight.shadowMapSize, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ i ], pointLight.shadowCameraNear, pointLight.shadowCameraFar ) : 1.0;
	}
	#pragma unroll_loop_end
	#endif
	#endif
	return shadow;
}`,Qpr=`#ifdef USE_SKINNING
	mat4 boneMatX = getBoneMatrix( skinIndex.x );
	mat4 boneMatY = getBoneMatrix( skinIndex.y );
	mat4 boneMatZ = getBoneMatrix( skinIndex.z );
	mat4 boneMatW = getBoneMatrix( skinIndex.w );
#endif`,tdr=`#ifdef USE_SKINNING
	uniform mat4 bindMatrix;
	uniform mat4 bindMatrixInverse;
	#ifdef BONE_TEXTURE
		uniform highp sampler2D boneTexture;
		uniform int boneTextureSize;
		mat4 getBoneMatrix( const in float i ) {
			float j = i * 4.0;
			float x = mod( j, float( boneTextureSize ) );
			float y = floor( j / float( boneTextureSize ) );
			float dx = 1.0 / float( boneTextureSize );
			float dy = 1.0 / float( boneTextureSize );
			y = dy * ( y + 0.5 );
			vec4 v1 = texture2D( boneTexture, vec2( dx * ( x + 0.5 ), y ) );
			vec4 v2 = texture2D( boneTexture, vec2( dx * ( x + 1.5 ), y ) );
			vec4 v3 = texture2D( boneTexture, vec2( dx * ( x + 2.5 ), y ) );
			vec4 v4 = texture2D( boneTexture, vec2( dx * ( x + 3.5 ), y ) );
			mat4 bone = mat4( v1, v2, v3, v4 );
			return bone;
		}
	#else
		uniform mat4 boneMatrices[ MAX_BONES ];
		mat4 getBoneMatrix( const in float i ) {
			mat4 bone = boneMatrices[ int(i) ];
			return bone;
		}
	#endif
#endif`,edr=`#ifdef USE_SKINNING
	vec4 skinVertex = bindMatrix * vec4( transformed, 1.0 );
	vec4 skinned = vec4( 0.0 );
	skinned += boneMatX * skinVertex * skinWeight.x;
	skinned += boneMatY * skinVertex * skinWeight.y;
	skinned += boneMatZ * skinVertex * skinWeight.z;
	skinned += boneMatW * skinVertex * skinWeight.w;
	transformed = ( bindMatrixInverse * skinned ).xyz;
#endif`,rdr=`#ifdef USE_SKINNING
	mat4 skinMatrix = mat4( 0.0 );
	skinMatrix += skinWeight.x * boneMatX;
	skinMatrix += skinWeight.y * boneMatY;
	skinMatrix += skinWeight.z * boneMatZ;
	skinMatrix += skinWeight.w * boneMatW;
	skinMatrix = bindMatrixInverse * skinMatrix * bindMatrix;
	objectNormal = vec4( skinMatrix * vec4( objectNormal, 0.0 ) ).xyz;
	#ifdef USE_TANGENT
		objectTangent = vec4( skinMatrix * vec4( objectTangent, 0.0 ) ).xyz;
	#endif
#endif`,ndr=`float specularStrength;
#ifdef USE_SPECULARMAP
	vec4 texelSpecular = texture2D( specularMap, vUv );
	specularStrength = texelSpecular.r;
#else
	specularStrength = 1.0;
#endif`,idr=`#ifdef USE_SPECULARMAP
	uniform sampler2D specularMap;
#endif`,odr=`#if defined( TONE_MAPPING )
	gl_FragColor.rgb = toneMapping( gl_FragColor.rgb );
#endif`,adr=`#ifndef saturate
#define saturate( a ) clamp( a, 0.0, 1.0 )
#endif
uniform float toneMappingExposure;
vec3 LinearToneMapping( vec3 color ) {
	return toneMappingExposure * color;
}
vec3 ReinhardToneMapping( vec3 color ) {
	color *= toneMappingExposure;
	return saturate( color / ( vec3( 1.0 ) + color ) );
}
vec3 OptimizedCineonToneMapping( vec3 color ) {
	color *= toneMappingExposure;
	color = max( vec3( 0.0 ), color - 0.004 );
	return pow( ( color * ( 6.2 * color + 0.5 ) ) / ( color * ( 6.2 * color + 1.7 ) + 0.06 ), vec3( 2.2 ) );
}
vec3 RRTAndODTFit( vec3 v ) {
	vec3 a = v * ( v + 0.0245786 ) - 0.000090537;
	vec3 b = v * ( 0.983729 * v + 0.4329510 ) + 0.238081;
	return a / b;
}
vec3 ACESFilmicToneMapping( vec3 color ) {
	const mat3 ACESInputMat = mat3(
		vec3( 0.59719, 0.07600, 0.02840 ),		vec3( 0.35458, 0.90834, 0.13383 ),
		vec3( 0.04823, 0.01566, 0.83777 )
	);
	const mat3 ACESOutputMat = mat3(
		vec3(  1.60475, -0.10208, -0.00327 ),		vec3( -0.53108,  1.10813, -0.07276 ),
		vec3( -0.07367, -0.00605,  1.07602 )
	);
	color *= toneMappingExposure / 0.6;
	color = ACESInputMat * color;
	color = RRTAndODTFit( color );
	color = ACESOutputMat * color;
	return saturate( color );
}
vec3 CustomToneMapping( vec3 color ) { return color; }`,sdr=`#ifdef USE_TRANSMISSION
	float transmissionAlpha = 1.0;
	float transmissionFactor = transmission;
	float thicknessFactor = thickness;
	#ifdef USE_TRANSMISSIONMAP
		transmissionFactor *= texture2D( transmissionMap, vUv ).r;
	#endif
	#ifdef USE_THICKNESSMAP
		thicknessFactor *= texture2D( thicknessMap, vUv ).g;
	#endif
	vec3 pos = vWorldPosition;
	vec3 v = normalize( cameraPosition - pos );
	vec3 n = inverseTransformDirection( normal, viewMatrix );
	vec4 transmission = getIBLVolumeRefraction(
		n, v, roughnessFactor, material.diffuseColor, material.specularColor, material.specularF90,
		pos, modelMatrix, viewMatrix, projectionMatrix, ior, thicknessFactor,
		attenuationColor, attenuationDistance );
	totalDiffuse = mix( totalDiffuse, transmission.rgb, transmissionFactor );
	transmissionAlpha = mix( transmissionAlpha, transmission.a, transmissionFactor );
#endif`,ldr=`#ifdef USE_TRANSMISSION
	uniform float transmission;
	uniform float thickness;
	uniform float attenuationDistance;
	uniform vec3 attenuationColor;
	#ifdef USE_TRANSMISSIONMAP
		uniform sampler2D transmissionMap;
	#endif
	#ifdef USE_THICKNESSMAP
		uniform sampler2D thicknessMap;
	#endif
	uniform vec2 transmissionSamplerSize;
	uniform sampler2D transmissionSamplerMap;
	uniform mat4 modelMatrix;
	uniform mat4 projectionMatrix;
	varying vec3 vWorldPosition;
	vec3 getVolumeTransmissionRay( const in vec3 n, const in vec3 v, const in float thickness, const in float ior, const in mat4 modelMatrix ) {
		vec3 refractionVector = refract( - v, normalize( n ), 1.0 / ior );
		vec3 modelScale;
		modelScale.x = length( vec3( modelMatrix[ 0 ].xyz ) );
		modelScale.y = length( vec3( modelMatrix[ 1 ].xyz ) );
		modelScale.z = length( vec3( modelMatrix[ 2 ].xyz ) );
		return normalize( refractionVector ) * thickness * modelScale;
	}
	float applyIorToRoughness( const in float roughness, const in float ior ) {
		return roughness * clamp( ior * 2.0 - 2.0, 0.0, 1.0 );
	}
	vec4 getTransmissionSample( const in vec2 fragCoord, const in float roughness, const in float ior ) {
		float framebufferLod = log2( transmissionSamplerSize.x ) * applyIorToRoughness( roughness, ior );
		#ifdef TEXTURE_LOD_EXT
			return texture2DLodEXT( transmissionSamplerMap, fragCoord.xy, framebufferLod );
		#else
			return texture2D( transmissionSamplerMap, fragCoord.xy, framebufferLod );
		#endif
	}
	vec3 applyVolumeAttenuation( const in vec3 radiance, const in float transmissionDistance, const in vec3 attenuationColor, const in float attenuationDistance ) {
		if ( attenuationDistance == 0.0 ) {
			return radiance;
		} else {
			vec3 attenuationCoefficient = -log( attenuationColor ) / attenuationDistance;
			vec3 transmittance = exp( - attenuationCoefficient * transmissionDistance );			return transmittance * radiance;
		}
	}
	vec4 getIBLVolumeRefraction( const in vec3 n, const in vec3 v, const in float roughness, const in vec3 diffuseColor,
		const in vec3 specularColor, const in float specularF90, const in vec3 position, const in mat4 modelMatrix,
		const in mat4 viewMatrix, const in mat4 projMatrix, const in float ior, const in float thickness,
		const in vec3 attenuationColor, const in float attenuationDistance ) {
		vec3 transmissionRay = getVolumeTransmissionRay( n, v, thickness, ior, modelMatrix );
		vec3 refractedRayExit = position + transmissionRay;
		vec4 ndcPos = projMatrix * viewMatrix * vec4( refractedRayExit, 1.0 );
		vec2 refractionCoords = ndcPos.xy / ndcPos.w;
		refractionCoords += 1.0;
		refractionCoords /= 2.0;
		vec4 transmittedLight = getTransmissionSample( refractionCoords, roughness, ior );
		vec3 attenuatedColor = applyVolumeAttenuation( transmittedLight.rgb, length( transmissionRay ), attenuationColor, attenuationDistance );
		vec3 F = EnvironmentBRDF( n, v, specularColor, specularF90, roughness );
		return vec4( ( 1.0 - F ) * attenuatedColor * diffuseColor, transmittedLight.a );
	}
#endif`,cdr=`#if ( defined( USE_UV ) && ! defined( UVS_VERTEX_ONLY ) )
	varying vec2 vUv;
#endif`,udr=`#ifdef USE_UV
	#ifdef UVS_VERTEX_ONLY
		vec2 vUv;
	#else
		varying vec2 vUv;
	#endif
	uniform mat3 uvTransform;
#endif`,hdr=`#ifdef USE_UV
	vUv = ( uvTransform * vec3( uv, 1 ) ).xy;
#endif`,fdr=`#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )
	varying vec2 vUv2;
#endif`,pdr=`#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )
	attribute vec2 uv2;
	varying vec2 vUv2;
	uniform mat3 uv2Transform;
#endif`,ddr=`#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )
	vUv2 = ( uv2Transform * vec3( uv2, 1 ) ).xy;
#endif`,mdr=`#if defined( USE_ENVMAP ) || defined( DISTANCE ) || defined ( USE_SHADOWMAP ) || defined ( USE_TRANSMISSION )
	vec4 worldPosition = vec4( transformed, 1.0 );
	#ifdef USE_INSTANCING
		worldPosition = instanceMatrix * worldPosition;
	#endif
	worldPosition = modelMatrix * worldPosition;
#endif`,gdr=`varying vec2 vUv;
uniform mat3 uvTransform;
void main() {
	vUv = ( uvTransform * vec3( uv, 1 ) ).xy;
	gl_Position = vec4( position.xy, 1.0, 1.0 );
}`,_dr=`uniform sampler2D t2D;
varying vec2 vUv;
void main() {
	gl_FragColor = texture2D( t2D, vUv );
	#include <tonemapping_fragment>
	#include <encodings_fragment>
}`,ydr=`varying vec3 vWorldDirection;
#include <common>
void main() {
	vWorldDirection = transformDirection( position, modelMatrix );
	#include <begin_vertex>
	#include <project_vertex>
	gl_Position.z = gl_Position.w;
}`,vdr=`#include <envmap_common_pars_fragment>
uniform float opacity;
varying vec3 vWorldDirection;
#include <cube_uv_reflection_fragment>
void main() {
	vec3 vReflect = vWorldDirection;
	#include <envmap_fragment>
	gl_FragColor = envColor;
	gl_FragColor.a *= opacity;
	#include <tonemapping_fragment>
	#include <encodings_fragment>
}`,xdr=`#include <common>
#include <uv_pars_vertex>
#include <displacementmap_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
varying vec2 vHighPrecisionZW;
void main() {
	#include <uv_vertex>
	#include <skinbase_vertex>
	#ifdef USE_DISPLACEMENTMAP
		#include <beginnormal_vertex>
		#include <morphnormal_vertex>
		#include <skinnormal_vertex>
	#endif
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	vHighPrecisionZW = gl_Position.zw;
}`,bdr=`#if DEPTH_PACKING == 3200
	uniform float opacity;
#endif
#include <common>
#include <packing>
#include <uv_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
varying vec2 vHighPrecisionZW;
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( 1.0 );
	#if DEPTH_PACKING == 3200
		diffuseColor.a = opacity;
	#endif
	#include <map_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <logdepthbuf_fragment>
	float fragCoordZ = 0.5 * vHighPrecisionZW[0] / vHighPrecisionZW[1] + 0.5;
	#if DEPTH_PACKING == 3200
		gl_FragColor = vec4( vec3( 1.0 - fragCoordZ ), opacity );
	#elif DEPTH_PACKING == 3201
		gl_FragColor = packDepthToRGBA( fragCoordZ );
	#endif
}`,wdr=`#define DISTANCE
varying vec3 vWorldPosition;
#include <common>
#include <uv_pars_vertex>
#include <displacementmap_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <skinbase_vertex>
	#ifdef USE_DISPLACEMENTMAP
		#include <beginnormal_vertex>
		#include <morphnormal_vertex>
		#include <skinnormal_vertex>
	#endif
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <worldpos_vertex>
	#include <clipping_planes_vertex>
	vWorldPosition = worldPosition.xyz;
}`,Sdr=`#define DISTANCE
uniform vec3 referencePosition;
uniform float nearDistance;
uniform float farDistance;
varying vec3 vWorldPosition;
#include <common>
#include <packing>
#include <uv_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <clipping_planes_pars_fragment>
void main () {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( 1.0 );
	#include <map_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	float dist = length( vWorldPosition - referencePosition );
	dist = ( dist - nearDistance ) / ( farDistance - nearDistance );
	dist = saturate( dist );
	gl_FragColor = packDepthToRGBA( dist );
}`,Mdr=`varying vec3 vWorldDirection;
#include <common>
void main() {
	vWorldDirection = transformDirection( position, modelMatrix );
	#include <begin_vertex>
	#include <project_vertex>
}`,Edr=`uniform sampler2D tEquirect;
varying vec3 vWorldDirection;
#include <common>
void main() {
	vec3 direction = normalize( vWorldDirection );
	vec2 sampleUV = equirectUv( direction );
	gl_FragColor = texture2D( tEquirect, sampleUV );
	#include <tonemapping_fragment>
	#include <encodings_fragment>
}`,Tdr=`uniform float scale;
attribute float lineDistance;
varying float vLineDistance;
#include <common>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <morphtarget_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	vLineDistance = scale * lineDistance;
	#include <color_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	#include <fog_vertex>
}`,Cdr=`uniform vec3 diffuse;
uniform float opacity;
uniform float dashSize;
uniform float totalSize;
varying float vLineDistance;
#include <common>
#include <color_pars_fragment>
#include <fog_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	if ( mod( vLineDistance, totalSize ) > dashSize ) {
		discard;
	}
	vec3 outgoingLight = vec3( 0.0 );
	vec4 diffuseColor = vec4( diffuse, opacity );
	#include <logdepthbuf_fragment>
	#include <color_fragment>
	outgoingLight = diffuseColor.rgb;
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
}`,Adr=`#include <common>
#include <uv_pars_vertex>
#include <uv2_pars_vertex>
#include <envmap_pars_vertex>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <uv2_vertex>
	#include <color_vertex>
	#if defined ( USE_ENVMAP ) || defined ( USE_SKINNING )
		#include <beginnormal_vertex>
		#include <morphnormal_vertex>
		#include <skinbase_vertex>
		#include <skinnormal_vertex>
		#include <defaultnormal_vertex>
	#endif
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	#include <worldpos_vertex>
	#include <envmap_vertex>
	#include <fog_vertex>
}`,Pdr=`uniform vec3 diffuse;
uniform float opacity;
#ifndef FLAT_SHADED
	varying vec3 vNormal;
#endif
#include <common>
#include <dithering_pars_fragment>
#include <color_pars_fragment>
#include <uv_pars_fragment>
#include <uv2_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <aomap_pars_fragment>
#include <lightmap_pars_fragment>
#include <envmap_common_pars_fragment>
#include <envmap_pars_fragment>
#include <cube_uv_reflection_fragment>
#include <fog_pars_fragment>
#include <specularmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( diffuse, opacity );
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <color_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <specularmap_fragment>
	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
	#ifdef USE_LIGHTMAP
		vec4 lightMapTexel= texture2D( lightMap, vUv2 );
		reflectedLight.indirectDiffuse += lightMapTexel.rgb * lightMapIntensity;
	#else
		reflectedLight.indirectDiffuse += vec3( 1.0 );
	#endif
	#include <aomap_fragment>
	reflectedLight.indirectDiffuse *= diffuseColor.rgb;
	vec3 outgoingLight = reflectedLight.indirectDiffuse;
	#include <envmap_fragment>
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
	#include <dithering_fragment>
}`,Idr=`#define LAMBERT
varying vec3 vLightFront;
varying vec3 vIndirectFront;
#ifdef DOUBLE_SIDED
	varying vec3 vLightBack;
	varying vec3 vIndirectBack;
#endif
#include <common>
#include <uv_pars_vertex>
#include <uv2_pars_vertex>
#include <envmap_pars_vertex>
#include <bsdfs>
#include <lights_pars_begin>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <shadowmap_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <uv2_vertex>
	#include <color_vertex>
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	#include <worldpos_vertex>
	#include <envmap_vertex>
	#include <lights_lambert_vertex>
	#include <shadowmap_vertex>
	#include <fog_vertex>
}`,Ldr=`uniform vec3 diffuse;
uniform vec3 emissive;
uniform float opacity;
varying vec3 vLightFront;
varying vec3 vIndirectFront;
#ifdef DOUBLE_SIDED
	varying vec3 vLightBack;
	varying vec3 vIndirectBack;
#endif
#include <common>
#include <packing>
#include <dithering_pars_fragment>
#include <color_pars_fragment>
#include <uv_pars_fragment>
#include <uv2_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <aomap_pars_fragment>
#include <lightmap_pars_fragment>
#include <emissivemap_pars_fragment>
#include <envmap_common_pars_fragment>
#include <envmap_pars_fragment>
#include <cube_uv_reflection_fragment>
#include <bsdfs>
#include <lights_pars_begin>
#include <fog_pars_fragment>
#include <shadowmap_pars_fragment>
#include <shadowmask_pars_fragment>
#include <specularmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( diffuse, opacity );
	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
	vec3 totalEmissiveRadiance = emissive;
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <color_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <specularmap_fragment>
	#include <emissivemap_fragment>
	#ifdef DOUBLE_SIDED
		reflectedLight.indirectDiffuse += ( gl_FrontFacing ) ? vIndirectFront : vIndirectBack;
	#else
		reflectedLight.indirectDiffuse += vIndirectFront;
	#endif
	#include <lightmap_fragment>
	reflectedLight.indirectDiffuse *= BRDF_Lambert( diffuseColor.rgb );
	#ifdef DOUBLE_SIDED
		reflectedLight.directDiffuse = ( gl_FrontFacing ) ? vLightFront : vLightBack;
	#else
		reflectedLight.directDiffuse = vLightFront;
	#endif
	reflectedLight.directDiffuse *= BRDF_Lambert( diffuseColor.rgb ) * getShadowMask();
	#include <aomap_fragment>
	vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;
	#include <envmap_fragment>
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
	#include <dithering_fragment>
}`,kdr=`#define MATCAP
varying vec3 vViewPosition;
#include <common>
#include <uv_pars_vertex>
#include <color_pars_vertex>
#include <displacementmap_pars_vertex>
#include <fog_pars_vertex>
#include <normal_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <color_vertex>
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <normal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	#include <fog_vertex>
	vViewPosition = - mvPosition.xyz;
}`,Rdr=`#define MATCAP
uniform vec3 diffuse;
uniform float opacity;
uniform sampler2D matcap;
varying vec3 vViewPosition;
#include <common>
#include <dithering_pars_fragment>
#include <color_pars_fragment>
#include <uv_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <fog_pars_fragment>
#include <normal_pars_fragment>
#include <bumpmap_pars_fragment>
#include <normalmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( diffuse, opacity );
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <color_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <normal_fragment_begin>
	#include <normal_fragment_maps>
	vec3 viewDir = normalize( vViewPosition );
	vec3 x = normalize( vec3( viewDir.z, 0.0, - viewDir.x ) );
	vec3 y = cross( viewDir, x );
	vec2 uv = vec2( dot( x, normal ), dot( y, normal ) ) * 0.495 + 0.5;
	#ifdef USE_MATCAP
		vec4 matcapColor = texture2D( matcap, uv );
	#else
		vec4 matcapColor = vec4( vec3( mix( 0.2, 0.8, uv.y ) ), 1.0 );
	#endif
	vec3 outgoingLight = diffuseColor.rgb * matcapColor.rgb;
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
	#include <dithering_fragment>
}`,Ndr=`#define NORMAL
#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )
	varying vec3 vViewPosition;
#endif
#include <common>
#include <uv_pars_vertex>
#include <displacementmap_pars_vertex>
#include <normal_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <normal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )
	vViewPosition = - mvPosition.xyz;
#endif
}`,Ddr=`#define NORMAL
uniform float opacity;
#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )
	varying vec3 vViewPosition;
#endif
#include <packing>
#include <uv_pars_fragment>
#include <normal_pars_fragment>
#include <bumpmap_pars_fragment>
#include <normalmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	#include <logdepthbuf_fragment>
	#include <normal_fragment_begin>
	#include <normal_fragment_maps>
	gl_FragColor = vec4( packNormalToRGB( normal ), opacity );
}`,Odr=`#define PHONG
varying vec3 vViewPosition;
#include <common>
#include <uv_pars_vertex>
#include <uv2_pars_vertex>
#include <displacementmap_pars_vertex>
#include <envmap_pars_vertex>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <normal_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <shadowmap_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <uv2_vertex>
	#include <color_vertex>
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <normal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	vViewPosition = - mvPosition.xyz;
	#include <worldpos_vertex>
	#include <envmap_vertex>
	#include <shadowmap_vertex>
	#include <fog_vertex>
}`,zdr=`#define PHONG
uniform vec3 diffuse;
uniform vec3 emissive;
uniform vec3 specular;
uniform float shininess;
uniform float opacity;
#include <common>
#include <packing>
#include <dithering_pars_fragment>
#include <color_pars_fragment>
#include <uv_pars_fragment>
#include <uv2_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <aomap_pars_fragment>
#include <lightmap_pars_fragment>
#include <emissivemap_pars_fragment>
#include <envmap_common_pars_fragment>
#include <envmap_pars_fragment>
#include <cube_uv_reflection_fragment>
#include <fog_pars_fragment>
#include <bsdfs>
#include <lights_pars_begin>
#include <normal_pars_fragment>
#include <lights_phong_pars_fragment>
#include <shadowmap_pars_fragment>
#include <bumpmap_pars_fragment>
#include <normalmap_pars_fragment>
#include <specularmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( diffuse, opacity );
	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
	vec3 totalEmissiveRadiance = emissive;
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <color_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <specularmap_fragment>
	#include <normal_fragment_begin>
	#include <normal_fragment_maps>
	#include <emissivemap_fragment>
	#include <lights_phong_fragment>
	#include <lights_fragment_begin>
	#include <lights_fragment_maps>
	#include <lights_fragment_end>
	#include <aomap_fragment>
	vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance;
	#include <envmap_fragment>
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
	#include <dithering_fragment>
}`,Fdr=`#define STANDARD
varying vec3 vViewPosition;
#ifdef USE_TRANSMISSION
	varying vec3 vWorldPosition;
#endif
#include <common>
#include <uv_pars_vertex>
#include <uv2_pars_vertex>
#include <displacementmap_pars_vertex>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <normal_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <shadowmap_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <uv2_vertex>
	#include <color_vertex>
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <normal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	vViewPosition = - mvPosition.xyz;
	#include <worldpos_vertex>
	#include <shadowmap_vertex>
	#include <fog_vertex>
#ifdef USE_TRANSMISSION
	vWorldPosition = worldPosition.xyz;
#endif
}`,Bdr=`#define STANDARD
#ifdef PHYSICAL
	#define IOR
	#define SPECULAR
#endif
uniform vec3 diffuse;
uniform vec3 emissive;
uniform float roughness;
uniform float metalness;
uniform float opacity;
#ifdef IOR
	uniform float ior;
#endif
#ifdef SPECULAR
	uniform float specularIntensity;
	uniform vec3 specularColor;
	#ifdef USE_SPECULARINTENSITYMAP
		uniform sampler2D specularIntensityMap;
	#endif
	#ifdef USE_SPECULARCOLORMAP
		uniform sampler2D specularColorMap;
	#endif
#endif
#ifdef USE_CLEARCOAT
	uniform float clearcoat;
	uniform float clearcoatRoughness;
#endif
#ifdef USE_SHEEN
	uniform vec3 sheenColor;
	uniform float sheenRoughness;
	#ifdef USE_SHEENCOLORMAP
		uniform sampler2D sheenColorMap;
	#endif
	#ifdef USE_SHEENROUGHNESSMAP
		uniform sampler2D sheenRoughnessMap;
	#endif
#endif
varying vec3 vViewPosition;
#include <common>
#include <packing>
#include <dithering_pars_fragment>
#include <color_pars_fragment>
#include <uv_pars_fragment>
#include <uv2_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <aomap_pars_fragment>
#include <lightmap_pars_fragment>
#include <emissivemap_pars_fragment>
#include <bsdfs>
#include <cube_uv_reflection_fragment>
#include <envmap_common_pars_fragment>
#include <envmap_physical_pars_fragment>
#include <fog_pars_fragment>
#include <lights_pars_begin>
#include <normal_pars_fragment>
#include <lights_physical_pars_fragment>
#include <transmission_pars_fragment>
#include <shadowmap_pars_fragment>
#include <bumpmap_pars_fragment>
#include <normalmap_pars_fragment>
#include <clearcoat_pars_fragment>
#include <roughnessmap_pars_fragment>
#include <metalnessmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( diffuse, opacity );
	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
	vec3 totalEmissiveRadiance = emissive;
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <color_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <roughnessmap_fragment>
	#include <metalnessmap_fragment>
	#include <normal_fragment_begin>
	#include <normal_fragment_maps>
	#include <clearcoat_normal_fragment_begin>
	#include <clearcoat_normal_fragment_maps>
	#include <emissivemap_fragment>
	#include <lights_physical_fragment>
	#include <lights_fragment_begin>
	#include <lights_fragment_maps>
	#include <lights_fragment_end>
	#include <aomap_fragment>
	vec3 totalDiffuse = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse;
	vec3 totalSpecular = reflectedLight.directSpecular + reflectedLight.indirectSpecular;
	#include <transmission_fragment>
	vec3 outgoingLight = totalDiffuse + totalSpecular + totalEmissiveRadiance;
	#ifdef USE_SHEEN
		float sheenEnergyComp = 1.0 - 0.157 * max3( material.sheenColor );
		outgoingLight = outgoingLight * sheenEnergyComp + sheenSpecular;
	#endif
	#ifdef USE_CLEARCOAT
		float dotNVcc = saturate( dot( geometry.clearcoatNormal, geometry.viewDir ) );
		vec3 Fcc = F_Schlick( material.clearcoatF0, material.clearcoatF90, dotNVcc );
		outgoingLight = outgoingLight * ( 1.0 - material.clearcoat * Fcc ) + clearcoatSpecular * material.clearcoat;
	#endif
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
	#include <dithering_fragment>
}`,Hdr=`#define TOON
varying vec3 vViewPosition;
#include <common>
#include <uv_pars_vertex>
#include <uv2_pars_vertex>
#include <displacementmap_pars_vertex>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <normal_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <shadowmap_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <uv2_vertex>
	#include <color_vertex>
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <normal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	vViewPosition = - mvPosition.xyz;
	#include <worldpos_vertex>
	#include <shadowmap_vertex>
	#include <fog_vertex>
}`,Vdr=`#define TOON
uniform vec3 diffuse;
uniform vec3 emissive;
uniform float opacity;
#include <common>
#include <packing>
#include <dithering_pars_fragment>
#include <color_pars_fragment>
#include <uv_pars_fragment>
#include <uv2_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <aomap_pars_fragment>
#include <lightmap_pars_fragment>
#include <emissivemap_pars_fragment>
#include <gradientmap_pars_fragment>
#include <fog_pars_fragment>
#include <bsdfs>
#include <lights_pars_begin>
#include <normal_pars_fragment>
#include <lights_toon_pars_fragment>
#include <shadowmap_pars_fragment>
#include <bumpmap_pars_fragment>
#include <normalmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( diffuse, opacity );
	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
	vec3 totalEmissiveRadiance = emissive;
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <color_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <normal_fragment_begin>
	#include <normal_fragment_maps>
	#include <emissivemap_fragment>
	#include <lights_toon_fragment>
	#include <lights_fragment_begin>
	#include <lights_fragment_maps>
	#include <lights_fragment_end>
	#include <aomap_fragment>
	vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
	#include <dithering_fragment>
}`,Udr=`uniform float size;
uniform float scale;
#include <common>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <morphtarget_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <color_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <project_vertex>
	gl_PointSize = size;
	#ifdef USE_SIZEATTENUATION
		bool isPerspective = isPerspectiveMatrix( projectionMatrix );
		if ( isPerspective ) gl_PointSize *= ( scale / - mvPosition.z );
	#endif
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	#include <worldpos_vertex>
	#include <fog_vertex>
}`,qdr=`uniform vec3 diffuse;
uniform float opacity;
#include <common>
#include <color_pars_fragment>
#include <map_particle_pars_fragment>
#include <alphatest_pars_fragment>
#include <fog_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec3 outgoingLight = vec3( 0.0 );
	vec4 diffuseColor = vec4( diffuse, opacity );
	#include <logdepthbuf_fragment>
	#include <map_particle_fragment>
	#include <color_fragment>
	#include <alphatest_fragment>
	outgoingLight = diffuseColor.rgb;
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
}`,Gdr=`#include <common>
#include <fog_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <shadowmap_pars_vertex>
void main() {
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <project_vertex>
	#include <worldpos_vertex>
	#include <shadowmap_vertex>
	#include <fog_vertex>
}`,Wdr=`uniform vec3 color;
uniform float opacity;
#include <common>
#include <packing>
#include <fog_pars_fragment>
#include <bsdfs>
#include <lights_pars_begin>
#include <shadowmap_pars_fragment>
#include <shadowmask_pars_fragment>
void main() {
	gl_FragColor = vec4( color, opacity * ( 1.0 - getShadowMask() ) );
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
}`,Ydr=`uniform float rotation;
uniform vec2 center;
#include <common>
#include <uv_pars_vertex>
#include <fog_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	vec4 mvPosition = modelViewMatrix * vec4( 0.0, 0.0, 0.0, 1.0 );
	vec2 scale;
	scale.x = length( vec3( modelMatrix[ 0 ].x, modelMatrix[ 0 ].y, modelMatrix[ 0 ].z ) );
	scale.y = length( vec3( modelMatrix[ 1 ].x, modelMatrix[ 1 ].y, modelMatrix[ 1 ].z ) );
	#ifndef USE_SIZEATTENUATION
		bool isPerspective = isPerspectiveMatrix( projectionMatrix );
		if ( isPerspective ) scale *= - mvPosition.z;
	#endif
	vec2 alignedPosition = ( position.xy - ( center - vec2( 0.5 ) ) ) * scale;
	vec2 rotatedPosition;
	rotatedPosition.x = cos( rotation ) * alignedPosition.x - sin( rotation ) * alignedPosition.y;
	rotatedPosition.y = sin( rotation ) * alignedPosition.x + cos( rotation ) * alignedPosition.y;
	mvPosition.xy += rotatedPosition;
	gl_Position = projectionMatrix * mvPosition;
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	#include <fog_vertex>
}`,jdr=`uniform vec3 diffuse;
uniform float opacity;
#include <common>
#include <uv_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <fog_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec3 outgoingLight = vec3( 0.0 );
	vec4 diffuseColor = vec4( diffuse, opacity );
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	outgoingLight = diffuseColor.rgb;
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
}`,hr={alphamap_fragment:wfr,alphamap_pars_fragment:Sfr,alphatest_fragment:Mfr,alphatest_pars_fragment:Efr,aomap_fragment:Tfr,aomap_pars_fragment:Cfr,begin_vertex:Afr,beginnormal_vertex:Pfr,bsdfs:Ifr,bumpmap_pars_fragment:Lfr,clipping_planes_fragment:kfr,clipping_planes_pars_fragment:Rfr,clipping_planes_pars_vertex:Nfr,clipping_planes_vertex:Dfr,color_fragment:Ofr,color_pars_fragment:zfr,color_pars_vertex:Ffr,color_vertex:Bfr,common:Hfr,cube_uv_reflection_fragment:Vfr,defaultnormal_vertex:Ufr,displacementmap_pars_vertex:qfr,displacementmap_vertex:Gfr,emissivemap_fragment:Wfr,emissivemap_pars_fragment:Yfr,encodings_fragment:jfr,encodings_pars_fragment:Xfr,envmap_fragment:$fr,envmap_common_pars_fragment:Kfr,envmap_pars_fragment:Zfr,envmap_pars_vertex:Jfr,envmap_physical_pars_fragment:cpr,envmap_vertex:Qfr,fog_vertex:tpr,fog_pars_vertex:epr,fog_fragment:rpr,fog_pars_fragment:npr,gradientmap_pars_fragment:ipr,lightmap_fragment:opr,lightmap_pars_fragment:apr,lights_lambert_vertex:spr,lights_pars_begin:lpr,lights_toon_fragment:upr,lights_toon_pars_fragment:hpr,lights_phong_fragment:fpr,lights_phong_pars_fragment:ppr,lights_physical_fragment:dpr,lights_physical_pars_fragment:mpr,lights_fragment_begin:gpr,lights_fragment_maps:_pr,lights_fragment_end:ypr,logdepthbuf_fragment:vpr,logdepthbuf_pars_fragment:xpr,logdepthbuf_pars_vertex:bpr,logdepthbuf_vertex:wpr,map_fragment:Spr,map_pars_fragment:Mpr,map_particle_fragment:Epr,map_particle_pars_fragment:Tpr,metalnessmap_fragment:Cpr,metalnessmap_pars_fragment:Apr,morphnormal_vertex:Ppr,morphtarget_pars_vertex:Ipr,morphtarget_vertex:Lpr,normal_fragment_begin:kpr,normal_fragment_maps:Rpr,normal_pars_fragment:Npr,normal_pars_vertex:Dpr,normal_vertex:Opr,normalmap_pars_fragment:zpr,clearcoat_normal_fragment_begin:Fpr,clearcoat_normal_fragment_maps:Bpr,clearcoat_pars_fragment:Hpr,output_fragment:Vpr,packing:Upr,premultiplied_alpha_fragment:qpr,project_vertex:Gpr,dithering_fragment:Wpr,dithering_pars_fragment:Ypr,roughnessmap_fragment:jpr,roughnessmap_pars_fragment:Xpr,shadowmap_pars_fragment:$pr,shadowmap_pars_vertex:Kpr,shadowmap_vertex:Zpr,shadowmask_pars_fragment:Jpr,skinbase_vertex:Qpr,skinning_pars_vertex:tdr,skinning_vertex:edr,skinnormal_vertex:rdr,specularmap_fragment:ndr,specularmap_pars_fragment:idr,tonemapping_fragment:odr,tonemapping_pars_fragment:adr,transmission_fragment:sdr,transmission_pars_fragment:ldr,uv_pars_fragment:cdr,uv_pars_vertex:udr,uv_vertex:hdr,uv2_pars_fragment:fdr,uv2_pars_vertex:pdr,uv2_vertex:ddr,worldpos_vertex:mdr,background_vert:gdr,background_frag:_dr,cube_vert:ydr,cube_frag:vdr,depth_vert:xdr,depth_frag:bdr,distanceRGBA_vert:wdr,distanceRGBA_frag:Sdr,equirect_vert:Mdr,equirect_frag:Edr,linedashed_vert:Tdr,linedashed_frag:Cdr,meshbasic_vert:Adr,meshbasic_frag:Pdr,meshlambert_vert:Idr,meshlambert_frag:Ldr,meshmatcap_vert:kdr,meshmatcap_frag:Rdr,meshnormal_vert:Ndr,meshnormal_frag:Ddr,meshphong_vert:Odr,meshphong_frag:zdr,meshphysical_vert:Fdr,meshphysical_frag:Bdr,meshtoon_vert:Hdr,meshtoon_frag:Vdr,points_vert:Udr,points_frag:qdr,shadow_vert:Gdr,shadow_frag:Wdr,sprite_vert:Ydr,sprite_frag:jdr},re={common:{diffuse:{value:new ne(16777215)},opacity:{value:1},map:{value:null},uvTransform:{value:new ki},uv2Transform:{value:new ki},alphaMap:{value:null},alphaTest:{value:0}},specularmap:{specularMap:{value:null}},envmap:{envMap:{value:null},flipEnvMap:{value:-1},reflectivity:{value:1},ior:{value:1.5},refractionRatio:{value:.98}},aomap:{aoMap:{value:null},aoMapIntensity:{value:1}},lightmap:{lightMap:{value:null},lightMapIntensity:{value:1}},emissivemap:{emissiveMap:{value:null}},bumpmap:{bumpMap:{value:null},bumpScale:{value:1}},normalmap:{normalMap:{value:null},normalScale:{value:new Lt(1,1)}},displacementmap:{displacementMap:{value:null},displacementScale:{value:1},displacementBias:{value:0}},roughnessmap:{roughnessMap:{value:null}},metalnessmap:{metalnessMap:{value:null}},gradientmap:{gradientMap:{value:null}},fog:{fogDensity:{value:25e-5},fogNear:{value:1},fogFar:{value:2e3},fogColor:{value:new ne(16777215)}},lights:{ambientLightColor:{value:[]},lightProbe:{value:[]},directionalLights:{value:[],properties:{direction:{},color:{}}},directionalLightShadows:{value:[],properties:{shadowBias:{},shadowNormalBias:{},shadowRadius:{},shadowMapSize:{}}},directionalShadowMap:{value:[]},directionalShadowMatrix:{value:[]},spotLights:{value:[],properties:{color:{},position:{},direction:{},distance:{},coneCos:{},penumbraCos:{},decay:{}}},spotLightShadows:{value:[],properties:{shadowBias:{},shadowNormalBias:{},shadowRadius:{},shadowMapSize:{}}},spotShadowMap:{value:[]},spotShadowMatrix:{value:[]},pointLights:{value:[],properties:{color:{},position:{},decay:{},distance:{}}},pointLightShadows:{value:[],properties:{shadowBias:{},shadowNormalBias:{},shadowRadius:{},shadowMapSize:{},shadowCameraNear:{},shadowCameraFar:{}}},pointShadowMap:{value:[]},pointShadowMatrix:{value:[]},hemisphereLights:{value:[],properties:{direction:{},skyColor:{},groundColor:{}}},rectAreaLights:{value:[],properties:{color:{},position:{},width:{},height:{}}},ltc_1:{value:null},ltc_2:{value:null}},points:{diffuse:{value:new ne(16777215)},opacity:{value:1},size:{value:1},scale:{value:1},map:{value:null},alphaMap:{value:null},alphaTest:{value:0},uvTransform:{value:new ki}},sprite:{diffuse:{value:new ne(16777215)},opacity:{value:1},center:{value:new Lt(.5,.5)},rotation:{value:0},map:{value:null},alphaMap:{value:null},alphaTest:{value:0},uvTransform:{value:new ki}}},ah={basic:{uniforms:Ta([re.common,re.specularmap,re.envmap,re.aomap,re.lightmap,re.fog]),vertexShader:hr.meshbasic_vert,fragmentShader:hr.meshbasic_frag},lambert:{uniforms:Ta([re.common,re.specularmap,re.envmap,re.aomap,re.lightmap,re.emissivemap,re.fog,re.lights,{emissive:{value:new ne(0)}}]),vertexShader:hr.meshlambert_vert,fragmentShader:hr.meshlambert_frag},phong:{uniforms:Ta([re.common,re.specularmap,re.envmap,re.aomap,re.lightmap,re.emissivemap,re.bumpmap,re.normalmap,re.displacementmap,re.fog,re.lights,{emissive:{value:new ne(0)},specular:{value:new ne(1118481)},shininess:{value:30}}]),vertexShader:hr.meshphong_vert,fragmentShader:hr.meshphong_frag},standard:{uniforms:Ta([re.common,re.envmap,re.aomap,re.lightmap,re.emissivemap,re.bumpmap,re.normalmap,re.displacementmap,re.roughnessmap,re.metalnessmap,re.fog,re.lights,{emissive:{value:new ne(0)},roughness:{value:1},metalness:{value:0},envMapIntensity:{value:1}}]),vertexShader:hr.meshphysical_vert,fragmentShader:hr.meshphysical_frag},toon:{uniforms:Ta([re.common,re.aomap,re.lightmap,re.emissivemap,re.bumpmap,re.normalmap,re.displacementmap,re.gradientmap,re.fog,re.lights,{emissive:{value:new ne(0)}}]),vertexShader:hr.meshtoon_vert,fragmentShader:hr.meshtoon_frag},matcap:{uniforms:Ta([re.common,re.bumpmap,re.normalmap,re.displacementmap,re.fog,{matcap:{value:null}}]),vertexShader:hr.meshmatcap_vert,fragmentShader:hr.meshmatcap_frag},points:{uniforms:Ta([re.points,re.fog]),vertexShader:hr.points_vert,fragmentShader:hr.points_frag},dashed:{uniforms:Ta([re.common,re.fog,{scale:{value:1},dashSize:{value:1},totalSize:{value:2}}]),vertexShader:hr.linedashed_vert,fragmentShader:hr.linedashed_frag},depth:{uniforms:Ta([re.common,re.displacementmap]),vertexShader:hr.depth_vert,fragmentShader:hr.depth_frag},normal:{uniforms:Ta([re.common,re.bumpmap,re.normalmap,re.displacementmap,{opacity:{value:1}}]),vertexShader:hr.meshnormal_vert,fragmentShader:hr.meshnormal_frag},sprite:{uniforms:Ta([re.sprite,re.fog]),vertexShader:hr.sprite_vert,fragmentShader:hr.sprite_frag},background:{uniforms:{uvTransform:{value:new ki},t2D:{value:null}},vertexShader:hr.background_vert,fragmentShader:hr.background_frag},cube:{uniforms:Ta([re.envmap,{opacity:{value:1}}]),vertexShader:hr.cube_vert,fragmentShader:hr.cube_frag},equirect:{uniforms:{tEquirect:{value:null}},vertexShader:hr.equirect_vert,fragmentShader:hr.equirect_frag},distanceRGBA:{uniforms:Ta([re.common,re.displacementmap,{referencePosition:{value:new j},nearDistance:{value:1},farDistance:{value:1e3}}]),vertexShader:hr.distanceRGBA_vert,fragmentShader:hr.distanceRGBA_frag},shadow:{uniforms:Ta([re.lights,re.fog,{color:{value:new ne(0)},opacity:{value:1}}]),vertexShader:hr.shadow_vert,fragmentShader:hr.shadow_frag}};ah.physical={uniforms:Ta([ah.standard.uniforms,{clearcoat:{value:0},clearcoatMap:{value:null},clearcoatRoughness:{value:0},clearcoatRoughnessMap:{value:null},clearcoatNormalScale:{value:new Lt(1,1)},clearcoatNormalMap:{value:null},sheen:{value:0},sheenColor:{value:new ne(0)},sheenColorMap:{value:null},sheenRoughness:{value:1},sheenRoughnessMap:{value:null},transmission:{value:0},transmissionMap:{value:null},transmissionSamplerSize:{value:new Lt},transmissionSamplerMap:{value:null},thickness:{value:0},thicknessMap:{value:null},attenuationDistance:{value:0},attenuationColor:{value:new ne(0)},specularIntensity:{value:1},specularIntensityMap:{value:null},specularColor:{value:new ne(1,1,1)},specularColorMap:{value:null}}]),vertexShader:hr.meshphysical_vert,fragmentShader:hr.meshphysical_frag};function Xdr(e,t,r,n,i,o){let a=new ne(0),s=i===!0?0:1,l,c,u=null,h=0,f=null;function p(g,_){let y=!1,x=_.isScene===!0?_.background:null;x&&x.isTexture&&(x=t.get(x));let b=e.xr,S=b.getSession&&b.getSession();S&&S.environmentBlendMode==="additive"&&(x=null),x===null?d(a,s):x&&x.isColor&&(d(x,1),y=!0),(e.autoClear||y)&&e.clear(e.autoClearColor,e.autoClearDepth,e.autoClearStencil),x&&(x.isCubeTexture||x.mapping===xM)?(c===void 0&&(c=new ti(new Qf(1,1,1),new lh({name:"BackgroundCubeMaterial",uniforms:Z3(ah.cube.uniforms),vertexShader:ah.cube.vertexShader,fragmentShader:ah.cube.fragmentShader,side:Ii,depthTest:!1,depthWrite:!1,fog:!1})),c.geometry.deleteAttribute("normal"),c.geometry.deleteAttribute("uv"),c.onBeforeRender=function(C,P,k){this.matrixWorld.copyPosition(k.matrixWorld)},Object.defineProperty(c.material,"envMap",{get:function(){return this.uniforms.envMap.value}}),n.update(c)),c.material.uniforms.envMap.value=x,c.material.uniforms.flipEnvMap.value=x.isCubeTexture&&x.isRenderTargetTexture===!1?-1:1,(u!==x||h!==x.version||f!==e.toneMapping)&&(c.material.needsUpdate=!0,u=x,h=x.version,f=e.toneMapping),g.unshift(c,c.geometry,c.material,0,0,null)):x&&x.isTexture&&(l===void 0&&(l=new ti(new V0(2,2),new lh({name:"BackgroundMaterial",uniforms:Z3(ah.background.uniforms),vertexShader:ah.background.vertexShader,fragmentShader:ah.background.fragmentShader,side:I1,depthTest:!1,depthWrite:!1,fog:!1})),l.geometry.deleteAttribute("normal"),Object.defineProperty(l.material,"map",{get:function(){return this.uniforms.t2D.value}}),n.update(l)),l.material.uniforms.t2D.value=x,x.matrixAutoUpdate===!0&&x.updateMatrix(),l.material.uniforms.uvTransform.value.copy(x.matrix),(u!==x||h!==x.version||f!==e.toneMapping)&&(l.material.needsUpdate=!0,u=x,h=x.version,f=e.toneMapping),g.unshift(l,l.geometry,l.material,0,0,null))}function d(g,_){r.buffers.color.setClear(g.r,g.g,g.b,_,o)}return{getClearColor:function(){return a},setClearColor:function(g,_=1){a.set(g),s=_,d(a,s)},getClearAlpha:function(){return s},setClearAlpha:function(g){s=g,d(a,s)},render:p}}function $dr(e,t,r,n){let i=e.getParameter(34921),o=n.isWebGL2?null:t.get("OES_vertex_array_object"),a=n.isWebGL2||o!==null,s={},l=g(null),c=l;function u(R,F,z,U,W){let Z=!1;if(a){let rt=d(U,z,F);c!==rt&&(c=rt,f(c.object)),Z=_(U,W),Z&&y(U,W)}else{let rt=F.wireframe===!0;(c.geometry!==U.id||c.program!==z.id||c.wireframe!==rt)&&(c.geometry=U.id,c.program=z.id,c.wireframe=rt,Z=!0)}R.isInstancedMesh===!0&&(Z=!0),W!==null&&r.update(W,34963),Z&&(k(R,F,z,U),W!==null&&e.bindBuffer(34963,r.get(W).buffer))}function h(){return n.isWebGL2?e.createVertexArray():o.createVertexArrayOES()}function f(R){return n.isWebGL2?e.bindVertexArray(R):o.bindVertexArrayOES(R)}function p(R){return n.isWebGL2?e.deleteVertexArray(R):o.deleteVertexArrayOES(R)}function d(R,F,z){let U=z.wireframe===!0,W=s[R.id];W===void 0&&(W={},s[R.id]=W);let Z=W[F.id];Z===void 0&&(Z={},W[F.id]=Z);let rt=Z[U];return rt===void 0&&(rt=g(h()),Z[U]=rt),rt}function g(R){let F=[],z=[],U=[];for(let W=0;W<i;W++)F[W]=0,z[W]=0,U[W]=0;return{geometry:null,program:null,wireframe:!1,newAttributes:F,enabledAttributes:z,attributeDivisors:U,object:R,attributes:{},index:null}}function _(R,F){let z=c.attributes,U=R.attributes,W=0;for(let Z in U){let rt=z[Z],ot=U[Z];if(rt===void 0||rt.attribute!==ot||rt.data!==ot.data)return!0;W++}return c.attributesNum!==W||c.index!==F}function y(R,F){let z={},U=R.attributes,W=0;for(let Z in U){let rt=U[Z],ot={};ot.attribute=rt,rt.data&&(ot.data=rt.data),z[Z]=ot,W++}c.attributes=z,c.attributesNum=W,c.index=F}function x(){let R=c.newAttributes;for(let F=0,z=R.length;F<z;F++)R[F]=0}function b(R){S(R,0)}function S(R,F){let z=c.newAttributes,U=c.enabledAttributes,W=c.attributeDivisors;z[R]=1,U[R]===0&&(e.enableVertexAttribArray(R),U[R]=1),W[R]!==F&&((n.isWebGL2?e:t.get("ANGLE_instanced_arrays"))[n.isWebGL2?"vertexAttribDivisor":"vertexAttribDivisorANGLE"](R,F),W[R]=F)}function C(){let R=c.newAttributes,F=c.enabledAttributes;for(let z=0,U=F.length;z<U;z++)F[z]!==R[z]&&(e.disableVertexAttribArray(z),F[z]=0)}function P(R,F,z,U,W,Z){n.isWebGL2===!0&&(z===5124||z===5125)?e.vertexAttribIPointer(R,F,z,W,Z):e.vertexAttribPointer(R,F,z,U,W,Z)}function k(R,F,z,U){if(n.isWebGL2===!1&&(R.isInstancedMesh||U.isInstancedBufferGeometry)&&t.get("ANGLE_instanced_arrays")===null)return;x();let W=U.attributes,Z=z.getAttributes(),rt=F.defaultAttributeValues;for(let ot in Z){let st=Z[ot];if(st.location>=0){let St=W[ot];if(St===void 0&&(ot==="instanceMatrix"&&R.instanceMatrix&&(St=R.instanceMatrix),ot==="instanceColor"&&R.instanceColor&&(St=R.instanceColor)),St!==void 0){let bt=St.normalized,Mt=St.itemSize,lt=r.get(St);if(lt===void 0)continue;let Kt=lt.buffer,_t=lt.type,ct=lt.bytesPerElement;if(St.isInterleavedBufferAttribute){let X=St.data,et=X.stride,dt=St.offset;if(X&&X.isInstancedInterleavedBuffer){for(let q=0;q<st.locationSize;q++)S(st.location+q,X.meshPerAttribute);R.isInstancedMesh!==!0&&U._maxInstanceCount===void 0&&(U._maxInstanceCount=X.meshPerAttribute*X.count)}else for(let q=0;q<st.locationSize;q++)b(st.location+q);e.bindBuffer(34962,Kt);for(let q=0;q<st.locationSize;q++)P(st.location+q,Mt/st.locationSize,_t,bt,et*ct,(dt+Mt/st.locationSize*q)*ct)}else{if(St.isInstancedBufferAttribute){for(let X=0;X<st.locationSize;X++)S(st.location+X,St.meshPerAttribute);R.isInstancedMesh!==!0&&U._maxInstanceCount===void 0&&(U._maxInstanceCount=St.meshPerAttribute*St.count)}else for(let X=0;X<st.locationSize;X++)b(st.location+X);e.bindBuffer(34962,Kt);for(let X=0;X<st.locationSize;X++)P(st.location+X,Mt/st.locationSize,_t,bt,Mt*ct,Mt/st.locationSize*X*ct)}}else if(rt!==void 0){let bt=rt[ot];if(bt!==void 0)switch(bt.length){case 2:e.vertexAttrib2fv(st.location,bt);break;case 3:e.vertexAttrib3fv(st.location,bt);break;case 4:e.vertexAttrib4fv(st.location,bt);break;default:e.vertexAttrib1fv(st.location,bt)}}}}C()}function O(){I();for(let R in s){let F=s[R];for(let z in F){let U=F[z];for(let W in U)p(U[W].object),delete U[W];delete F[z]}delete s[R]}}function D(R){if(s[R.id]===void 0)return;let F=s[R.id];for(let z in F){let U=F[z];for(let W in U)p(U[W].object),delete U[W];delete F[z]}delete s[R.id]}function B(R){for(let F in s){let z=s[F];if(z[R.id]===void 0)continue;let U=z[R.id];for(let W in U)p(U[W].object),delete U[W];delete z[R.id]}}function I(){L(),c!==l&&(c=l,f(c.object))}function L(){l.geometry=null,l.program=null,l.wireframe=!1}return{setup:u,reset:I,resetDefaultState:L,dispose:O,releaseStatesOfGeometry:D,releaseStatesOfProgram:B,initAttributes:x,enableAttribute:b,disableUnusedAttributes:C}}function Kdr(e,t,r,n){let i=n.isWebGL2,o;function a(c){o=c}function s(c,u){e.drawArrays(o,c,u),r.update(u,o,1)}function l(c,u,h){if(h===0)return;let f,p;if(i)f=e,p="drawArraysInstanced";else if(f=t.get("ANGLE_instanced_arrays"),p="drawArraysInstancedANGLE",f===null){console.error("THREE.WebGLBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.");return}f[p](o,c,u,h),r.update(u,o,h)}this.setMode=a,this.render=s,this.renderInstances=l}function Zdr(e,t,r){let n;function i(){if(n!==void 0)return n;if(t.has("EXT_texture_filter_anisotropic")===!0){let k=t.get("EXT_texture_filter_anisotropic");n=e.getParameter(k.MAX_TEXTURE_MAX_ANISOTROPY_EXT)}else n=0;return n}function o(k){if(k==="highp"){if(e.getShaderPrecisionFormat(35633,36338).precision>0&&e.getShaderPrecisionFormat(35632,36338).precision>0)return"highp";k="mediump"}return k==="mediump"&&e.getShaderPrecisionFormat(35633,36337).precision>0&&e.getShaderPrecisionFormat(35632,36337).precision>0?"mediump":"lowp"}let a=typeof WebGL2RenderingContext!="undefined"&&e instanceof WebGL2RenderingContext||typeof WebGL2ComputeRenderingContext!="undefined"&&e instanceof WebGL2ComputeRenderingContext,s=r.precision!==void 0?r.precision:"highp",l=o(s);l!==s&&(console.warn("THREE.WebGLRenderer:",s,"not supported, using",l,"instead."),s=l);let c=a||t.has("WEBGL_draw_buffers"),u=r.logarithmicDepthBuffer===!0,h=e.getParameter(34930),f=e.getParameter(35660),p=e.getParameter(3379),d=e.getParameter(34076),g=e.getParameter(34921),_=e.getParameter(36347),y=e.getParameter(36348),x=e.getParameter(36349),b=f>0,S=a||t.has("OES_texture_float"),C=b&&S,P=a?e.getParameter(36183):0;return{isWebGL2:a,drawBuffers:c,getMaxAnisotropy:i,getMaxPrecision:o,precision:s,logarithmicDepthBuffer:u,maxTextures:h,maxVertexTextures:f,maxTextureSize:p,maxCubemapSize:d,maxAttributes:g,maxVertexUniforms:_,maxVaryings:y,maxFragmentUniforms:x,vertexTextures:b,floatFragmentTextures:S,floatVertexTextures:C,maxSamples:P}}function Jdr(e){let t=this,r=null,n=0,i=!1,o=!1,a=new $c,s=new ki,l={value:null,needsUpdate:!1};this.uniform=l,this.numPlanes=0,this.numIntersection=0,this.init=function(h,f,p){let d=h.length!==0||f||n!==0||i;return i=f,r=u(h,p,0),n=h.length,d},this.beginShadows=function(){o=!0,u(null)},this.endShadows=function(){o=!1,c()},this.setState=function(h,f,p){let d=h.clippingPlanes,g=h.clipIntersection,_=h.clipShadows,y=e.get(h);if(!i||d===null||d.length===0||o&&!_)o?u(null):c();else{let x=o?0:n,b=x*4,S=y.clippingState||null;l.value=S,S=u(d,f,b,p);for(let C=0;C!==b;++C)S[C]=r[C];y.clippingState=S,this.numIntersection=g?this.numPlanes:0,this.numPlanes+=x}};function c(){l.value!==r&&(l.value=r,l.needsUpdate=n>0),t.numPlanes=n,t.numIntersection=0}function u(h,f,p,d){let g=h!==null?h.length:0,_=null;if(g!==0){if(_=l.value,d!==!0||_===null){let y=p+g*4,x=f.matrixWorldInverse;s.getNormalMatrix(x),(_===null||_.length<y)&&(_=new Float32Array(y));for(let b=0,S=p;b!==g;++b,S+=4)a.copy(h[b]).applyMatrix4(x,s),a.normal.toArray(_,S),_[S+3]=a.constant}l.value=_,l.needsUpdate=!0}return t.numPlanes=g,t.numIntersection=0,_}}function Qdr(e){let t=new WeakMap;function r(a,s){return s===YP?a.mapping=nx:s===jP&&(a.mapping=ix),a}function n(a){if(a&&a.isTexture&&a.isRenderTargetTexture===!1){let s=a.mapping;if(s===YP||s===jP)if(t.has(a)){let l=t.get(a).texture;return r(l,a.mapping)}else{let l=a.image;if(l&&l.height>0){let c=new Q3(l.height/2);return c.fromEquirectangularTexture(e,a),t.set(a,c),a.addEventListener("dispose",i),r(c.texture,a.mapping)}else return null}}return a}function i(a){let s=a.target;s.removeEventListener("dispose",i);let l=t.get(s);l!==void 0&&(t.delete(s),l.dispose())}function o(){t=new WeakMap}return{get:n,dispose:o}}var D1=class extends R1{constructor(t=-1,r=1,n=1,i=-1,o=.1,a=2e3){super(),this.type="OrthographicCamera",this.zoom=1,this.view=null,this.left=t,this.right=r,this.top=n,this.bottom=i,this.near=o,this.far=a,this.updateProjectionMatrix()}copy(t,r){return super.copy(t,r),this.left=t.left,this.right=t.right,this.top=t.top,this.bottom=t.bottom,this.near=t.near,this.far=t.far,this.zoom=t.zoom,this.view=t.view===null?null:Object.assign({},t.view),this}setViewOffset(t,r,n,i,o,a){this.view===null&&(this.view={enabled:!0,fullWidth:1,fullHeight:1,offsetX:0,offsetY:0,width:1,height:1}),this.view.enabled=!0,this.view.fullWidth=t,this.view.fullHeight=r,this.view.offsetX=n,this.view.offsetY=i,this.view.width=o,this.view.height=a,this.updateProjectionMatrix()}clearViewOffset(){this.view!==null&&(this.view.enabled=!1),this.updateProjectionMatrix()}updateProjectionMatrix(){let t=(this.right-this.left)/(2*this.zoom),r=(this.top-this.bottom)/(2*this.zoom),n=(this.right+this.left)/2,i=(this.top+this.bottom)/2,o=n-t,a=n+t,s=i+r,l=i-r;if(this.view!==null&&this.view.enabled){let c=(this.right-this.left)/this.view.fullWidth/this.zoom,u=(this.top-this.bottom)/this.view.fullHeight/this.zoom;o+=c*this.view.offsetX,a=o+c*this.view.width,s-=u*this.view.offsetY,l=s-u*this.view.height}this.projectionMatrix.makeOrthographic(o,a,s,l,this.near,this.far),this.projectionMatrixInverse.copy(this.projectionMatrix).invert()}toJSON(t){let r=super.toJSON(t);return r.object.zoom=this.zoom,r.object.left=this.left,r.object.right=this.right,r.object.top=this.top,r.object.bottom=this.bottom,r.object.near=this.near,r.object.far=this.far,this.view!==null&&(r.object.view=Object.assign({},this.view)),r}};D1.prototype.isOrthographicCamera=!0;var U0=class extends lh{constructor(t){super(t),this.type="RawShaderMaterial"}};U0.prototype.isRawShaderMaterial=!0;var q3=4,F0=8,$f=Math.pow(2,F0),qfe=[.125,.215,.35,.446,.526,.582],Gfe=F0-q3+1+qfe.length,k3=20,hut=new D1,{_lodPlanes:NP,_sizeLods:Pue,_sigmas:PV}=tmr(),Iue=new ne,fut=null,S1=(1+Math.sqrt(5))/2,R3=1/S1,Lue=[new j(1,1,1),new j(-1,1,1),new j(1,1,-1),new j(-1,1,-1),new j(0,S1,R3),new j(0,S1,-R3),new j(R3,0,S1),new j(-R3,0,S1),new j(S1,R3,0),new j(-S1,R3,0)],e6=class{constructor(t){this._renderer=t,this._pingPongRenderTarget=null,this._blurMaterial=emr(k3),this._equirectShader=null,this._cubemapShader=null,this._compileMaterial(this._blurMaterial)}fromScene(t,r=0,n=.1,i=100){fut=this._renderer.getRenderTarget();let o=this._allocateTargets();return this._sceneToCubeUV(t,n,i,o),r>0&&this._blur(o,0,0,r),this._applyPMREM(o),this._cleanup(o),o}fromEquirectangular(t,r=null){return this._fromTexture(t,r)}fromCubemap(t,r=null){return this._fromTexture(t,r)}compileCubemapShader(){this._cubemapShader===null&&(this._cubemapShader=Nue(),this._compileMaterial(this._cubemapShader))}compileEquirectangularShader(){this._equirectShader===null&&(this._equirectShader=Rue(),this._compileMaterial(this._equirectShader))}dispose(){this._blurMaterial.dispose(),this._pingPongRenderTarget!==null&&this._pingPongRenderTarget.dispose(),this._cubemapShader!==null&&this._cubemapShader.dispose(),this._equirectShader!==null&&this._equirectShader.dispose();for(let t=0;t<NP.length;t++)NP[t].dispose()}_cleanup(t){this._renderer.setRenderTarget(fut),t.scissorTest=!1,IV(t,0,0,t.width,t.height)}_fromTexture(t,r){fut=this._renderer.getRenderTarget();let n=r||this._allocateTargets(t);return this._textureToCubeUV(t,n),this._applyPMREM(n),this._cleanup(n),n}_allocateTargets(t){let r={magFilter:ii,minFilter:ii,generateMipmaps:!1,type:C1,format:Qo,encoding:Qd,depthBuffer:!1},n=kue(r);return n.depthBuffer=!t,this._pingPongRenderTarget===null&&(this._pingPongRenderTarget=kue(r)),n}_compileMaterial(t){let r=new ti(NP[0],t);this._renderer.compile(r,hut)}_sceneToCubeUV(t,r,n,i){let s=new Ui(90,1,r,n),l=[1,-1,1,1,1,1],c=[1,1,1,-1,-1,-1],u=this._renderer,h=u.autoClear,f=u.toneMapping;u.getClearColor(Iue),u.toneMapping=Kd,u.autoClear=!1;let p=new sh({name:"PMREM.Background",side:Ii,depthWrite:!1,depthTest:!1}),d=new ti(new Qf,p),g=!1,_=t.background;_?_.isColor&&(p.color.copy(_),t.background=null,g=!0):(p.color.copy(Iue),g=!0);for(let y=0;y<6;y++){let x=y%3;x===0?(s.up.set(0,l[y],0),s.lookAt(c[y],0,0)):x===1?(s.up.set(0,0,l[y]),s.lookAt(0,c[y],0)):(s.up.set(0,l[y],0),s.lookAt(0,0,c[y])),IV(i,x*$f,y>2?$f:0,$f,$f),u.setRenderTarget(i),g&&u.render(d,s),u.render(t,s)}d.geometry.dispose(),d.material.dispose(),u.toneMapping=f,u.autoClear=h,t.background=_}_textureToCubeUV(t,r){let n=this._renderer,i=t.mapping===nx||t.mapping===ix;i?(this._cubemapShader===null&&(this._cubemapShader=Nue()),this._cubemapShader.uniforms.flipEnvMap.value=t.isRenderTargetTexture===!1?-1:1):this._equirectShader===null&&(this._equirectShader=Rue());let o=i?this._cubemapShader:this._equirectShader,a=new ti(NP[0],o),s=o.uniforms;s.envMap.value=t,i||s.texelSize.value.set(1/t.image.width,1/t.image.height),IV(r,0,0,3*$f,2*$f),n.setRenderTarget(r),n.render(a,hut)}_applyPMREM(t){let r=this._renderer,n=r.autoClear;r.autoClear=!1;for(let i=1;i<Gfe;i++){let o=Math.sqrt(PV[i]*PV[i]-PV[i-1]*PV[i-1]),a=Lue[(i-1)%Lue.length];this._blur(t,i-1,i,o,a)}r.autoClear=n}_blur(t,r,n,i,o){let a=this._pingPongRenderTarget;this._halfBlur(t,a,r,n,i,"latitudinal",o),this._halfBlur(a,t,n,n,i,"longitudinal",o)}_halfBlur(t,r,n,i,o,a,s){let l=this._renderer,c=this._blurMaterial;a!=="latitudinal"&&a!=="longitudinal"&&console.error("blur direction must be either latitudinal or longitudinal!");let u=3,h=new ti(NP[i],c),f=c.uniforms,p=Pue[n]-1,d=isFinite(o)?Math.PI/(2*p):2*Math.PI/(2*k3-1),g=o/d,_=isFinite(o)?1+Math.floor(u*g):k3;_>k3&&console.warn(`sigmaRadians, ${o}, is too large and will clip, as it requested ${_} samples when the maximum is set to ${k3}`);let y=[],x=0;for(let P=0;P<k3;++P){let k=P/g,O=Math.exp(-k*k/2);y.push(O),P===0?x+=O:P<_&&(x+=2*O)}for(let P=0;P<y.length;P++)y[P]=y[P]/x;f.envMap.value=t.texture,f.samples.value=_,f.weights.value=y,f.latitudinal.value=a==="latitudinal",s&&(f.poleAxis.value=s),f.dTheta.value=d,f.mipInt.value=F0-n;let b=Pue[i],S=3*Math.max(0,$f-2*b),C=(i===0?0:2*$f)+2*b*(i>F0-q3?i-F0+q3:0);IV(r,S,C,3*b,2*b),l.setRenderTarget(r),l.render(h,hut)}};function tmr(){let e=[],t=[],r=[],n=F0;for(let i=0;i<Gfe;i++){let o=Math.pow(2,n);t.push(o);let a=1/o;i>F0-q3?a=qfe[i-F0+q3-1]:i===0&&(a=0),r.push(a);let s=1/(o-1),l=-s/2,c=1+s/2,u=[l,l,c,l,c,c,l,l,c,c,l,c],h=6,f=6,p=3,d=2,g=1,_=new Float32Array(p*f*h),y=new Float32Array(d*f*h),x=new Float32Array(g*f*h);for(let S=0;S<h;S++){let C=S%3*2/3-1,P=S>2?0:-1,k=[C,P,0,C+2/3,P,0,C+2/3,P+1,0,C,P,0,C+2/3,P+1,0,C,P+1,0];_.set(k,p*f*S),y.set(u,d*f*S);let O=[S,S,S,S,S,S];x.set(O,g*f*S)}let b=new Pe;b.setAttribute("position",new Je(_,p)),b.setAttribute("uv",new Je(y,d)),b.setAttribute("faceIndex",new Je(x,g)),e.push(b),n>q3&&n--}return{_lodPlanes:e,_sizeLods:t,_sigmas:r}}function kue(e){let t=new us(3*$f,3*$f,e);return t.texture.mapping=xM,t.texture.name="PMREM.cubeUv",t.scissorTest=!0,t}function IV(e,t,r,n,i){e.viewport.set(t,r,n,i),e.scissor.set(t,r,n,i)}function emr(e){let t=new Float32Array(e),r=new j(0,1,0);return new U0({name:"SphericalGaussianBlur",defines:{n:e},uniforms:{envMap:{value:null},samples:{value:1},weights:{value:t},latitudinal:{value:!1},dTheta:{value:0},mipInt:{value:0},poleAxis:{value:r}},vertexShader:Nht(),fragmentShader:`

			precision mediump float;
			precision mediump int;

			varying vec3 vOutputDirection;

			uniform sampler2D envMap;
			uniform int samples;
			uniform float weights[ n ];
			uniform bool latitudinal;
			uniform float dTheta;
			uniform float mipInt;
			uniform vec3 poleAxis;

			#define ENVMAP_TYPE_CUBE_UV
			#include <cube_uv_reflection_fragment>

			vec3 getSample( float theta, vec3 axis ) {

				float cosTheta = cos( theta );
				// Rodrigues' axis-angle rotation
				vec3 sampleDirection = vOutputDirection * cosTheta
					+ cross( axis, vOutputDirection ) * sin( theta )
					+ axis * dot( axis, vOutputDirection ) * ( 1.0 - cosTheta );

				return bilinearCubeUV( envMap, sampleDirection, mipInt );

			}

			void main() {

				vec3 axis = latitudinal ? poleAxis : cross( poleAxis, vOutputDirection );

				if ( all( equal( axis, vec3( 0.0 ) ) ) ) {

					axis = vec3( vOutputDirection.z, 0.0, - vOutputDirection.x );

				}

				axis = normalize( axis );

				gl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 );
				gl_FragColor.rgb += weights[ 0 ] * getSample( 0.0, axis );

				for ( int i = 1; i < n; i++ ) {

					if ( i >= samples ) {

						break;

					}

					float theta = dTheta * float( i );
					gl_FragColor.rgb += weights[ i ] * getSample( -1.0 * theta, axis );
					gl_FragColor.rgb += weights[ i ] * getSample( theta, axis );

				}

			}
		`,blending:$d,depthTest:!1,depthWrite:!1})}function Rue(){let e=new Lt(1,1);return new U0({name:"EquirectangularToCubeUV",uniforms:{envMap:{value:null},texelSize:{value:e}},vertexShader:Nht(),fragmentShader:`

			precision mediump float;
			precision mediump int;

			varying vec3 vOutputDirection;

			uniform sampler2D envMap;
			uniform vec2 texelSize;

			#include <common>

			void main() {

				gl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 );

				vec3 outputDirection = normalize( vOutputDirection );
				vec2 uv = equirectUv( outputDirection );

				vec2 f = fract( uv / texelSize - 0.5 );
				uv -= f * texelSize;
				vec3 tl = texture2D ( envMap, uv ).rgb;
				uv.x += texelSize.x;
				vec3 tr = texture2D ( envMap, uv ).rgb;
				uv.y += texelSize.y;
				vec3 br = texture2D ( envMap, uv ).rgb;
				uv.x -= texelSize.x;
				vec3 bl = texture2D ( envMap, uv ).rgb;

				vec3 tm = mix( tl, tr, f.x );
				vec3 bm = mix( bl, br, f.x );
				gl_FragColor.rgb = mix( tm, bm, f.y );

			}
		`,blending:$d,depthTest:!1,depthWrite:!1})}function Nue(){return new U0({name:"CubemapToCubeUV",uniforms:{envMap:{value:null},flipEnvMap:{value:-1}},vertexShader:Nht(),fragmentShader:`

			precision mediump float;
			precision mediump int;

			uniform float flipEnvMap;

			varying vec3 vOutputDirection;

			uniform samplerCube envMap;

			void main() {

				gl_FragColor = textureCube( envMap, vec3( flipEnvMap * vOutputDirection.x, vOutputDirection.yz ) );

			}
		`,blending:$d,depthTest:!1,depthWrite:!1})}function Nht(){return`

		precision mediump float;
		precision mediump int;

		attribute vec3 position;
		attribute vec2 uv;
		attribute float faceIndex;

		varying vec3 vOutputDirection;

		// RH coordinate system; PMREM face-indexing convention
		vec3 getDirection( vec2 uv, float face ) {

			uv = 2.0 * uv - 1.0;

			vec3 direction = vec3( uv, 1.0 );

			if ( face == 0.0 ) {

				direction = direction.zyx; // ( 1, v, u ) pos x

			} else if ( face == 1.0 ) {

				direction = direction.xzy;
				direction.xz *= -1.0; // ( -u, 1, -v ) pos y

			} else if ( face == 2.0 ) {

				direction.x *= -1.0; // ( -u, v, 1 ) pos z

			} else if ( face == 3.0 ) {

				direction = direction.zyx;
				direction.xz *= -1.0; // ( -1, v, -u ) neg x

			} else if ( face == 4.0 ) {

				direction = direction.xzy;
				direction.xy *= -1.0; // ( -u, -1, v ) neg y

			} else if ( face == 5.0 ) {

				direction.z *= -1.0; // ( u, v, -1 ) neg z

			}

			return direction;

		}

		void main() {

			vOutputDirection = getDirection( uv, faceIndex );
			gl_Position = vec4( position, 1.0 );

		}
	`}function rmr(e){let t=new WeakMap,r=null;function n(s){if(s&&s.isTexture){let l=s.mapping,c=l===YP||l===jP,u=l===nx||l===ix;if(c||u)if(s.isRenderTargetTexture&&s.needsPMREMUpdate===!0){s.needsPMREMUpdate=!1;let h=t.get(s);return r===null&&(r=new e6(e)),h=c?r.fromEquirectangular(s,h):r.fromCubemap(s,h),t.set(s,h),h.texture}else{if(t.has(s))return t.get(s).texture;{let h=s.image;if(c&&h&&h.height>0||u&&h&&i(h)){r===null&&(r=new e6(e));let f=c?r.fromEquirectangular(s):r.fromCubemap(s);return t.set(s,f),s.addEventListener("dispose",o),f.texture}else return null}}}return s}function i(s){let l=0,c=6;for(let u=0;u<c;u++)s[u]!==void 0&&l++;return l===c}function o(s){let l=s.target;l.removeEventListener("dispose",o);let c=t.get(l);c!==void 0&&(t.delete(l),c.dispose())}function a(){t=new WeakMap,r!==null&&(r.dispose(),r=null)}return{get:n,dispose:a}}function nmr(e){let t={};function r(n){if(t[n]!==void 0)return t[n];let i;switch(n){case"WEBGL_depth_texture":i=e.getExtension("WEBGL_depth_texture")||e.getExtension("MOZ_WEBGL_depth_texture")||e.getExtension("WEBKIT_WEBGL_depth_texture");break;case"EXT_texture_filter_anisotropic":i=e.getExtension("EXT_texture_filter_anisotropic")||e.getExtension("MOZ_EXT_texture_filter_anisotropic")||e.getExtension("WEBKIT_EXT_texture_filter_anisotropic");break;case"WEBGL_compressed_texture_s3tc":i=e.getExtension("WEBGL_compressed_texture_s3tc")||e.getExtension("MOZ_WEBGL_compressed_texture_s3tc")||e.getExtension("WEBKIT_WEBGL_compressed_texture_s3tc");break;case"WEBGL_compressed_texture_pvrtc":i=e.getExtension("WEBGL_compressed_texture_pvrtc")||e.getExtension("WEBKIT_WEBGL_compressed_texture_pvrtc");break;default:i=e.getExtension(n)}return t[n]=i,i}return{has:function(n){return r(n)!==null},init:function(n){n.isWebGL2?r("EXT_color_buffer_float"):(r("WEBGL_depth_texture"),r("OES_texture_float"),r("OES_texture_half_float"),r("OES_texture_half_float_linear"),r("OES_standard_derivatives"),r("OES_element_index_uint"),r("OES_vertex_array_object"),r("ANGLE_instanced_arrays")),r("OES_texture_float_linear"),r("EXT_color_buffer_half_float"),r("WEBGL_multisampled_render_to_texture")},get:function(n){let i=r(n);return i===null&&console.warn("THREE.WebGLRenderer: "+n+" extension not supported."),i}}}function imr(e,t,r,n){let i={},o=new WeakMap;function a(h){let f=h.target;f.index!==null&&t.remove(f.index);for(let d in f.attributes)t.remove(f.attributes[d]);f.removeEventListener("dispose",a),delete i[f.id];let p=o.get(f);p&&(t.remove(p),o.delete(f)),n.releaseStatesOfGeometry(f),f.isInstancedBufferGeometry===!0&&delete f._maxInstanceCount,r.memory.geometries--}function s(h,f){return i[f.id]===!0||(f.addEventListener("dispose",a),i[f.id]=!0,r.memory.geometries++),f}function l(h){let f=h.attributes;for(let d in f)t.update(f[d],34962);let p=h.morphAttributes;for(let d in p){let g=p[d];for(let _=0,y=g.length;_<y;_++)t.update(g[_],34962)}}function c(h){let f=[],p=h.index,d=h.attributes.position,g=0;if(p!==null){let x=p.array;g=p.version;for(let b=0,S=x.length;b<S;b+=3){let C=x[b+0],P=x[b+1],k=x[b+2];f.push(C,P,P,k,k,C)}}else{let x=d.array;g=d.version;for(let b=0,S=x.length/3-1;b<S;b+=3){let C=b+0,P=b+1,k=b+2;f.push(C,P,P,k,k,C)}}let _=new(Bfe(f)?K3:$3)(f,1);_.version=g;let y=o.get(h);y&&t.remove(y),o.set(h,_)}function u(h){let f=o.get(h);if(f){let p=h.index;p!==null&&f.version<p.version&&c(h)}else c(h);return o.get(h)}return{get:s,update:l,getWireframeAttribute:u}}function omr(e,t,r,n){let i=n.isWebGL2,o;function a(f){o=f}let s,l;function c(f){s=f.type,l=f.bytesPerElement}function u(f,p){e.drawElements(o,p,s,f*l),r.update(p,o,1)}function h(f,p,d){if(d===0)return;let g,_;if(i)g=e,_="drawElementsInstanced";else if(g=t.get("ANGLE_instanced_arrays"),_="drawElementsInstancedANGLE",g===null){console.error("THREE.WebGLIndexedBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.");return}g[_](o,p,s,f*l,d),r.update(p,o,d)}this.setMode=a,this.setIndex=c,this.render=u,this.renderInstances=h}function amr(e){let t={geometries:0,textures:0},r={frame:0,calls:0,triangles:0,points:0,lines:0};function n(o,a,s){switch(r.calls++,a){case 4:r.triangles+=s*(o/3);break;case 1:r.lines+=s*(o/2);break;case 3:r.lines+=s*(o-1);break;case 2:r.lines+=s*o;break;case 0:r.points+=s*o;break;default:console.error("THREE.WebGLInfo: Unknown draw mode:",a);break}}function i(){r.frame++,r.calls=0,r.triangles=0,r.points=0,r.lines=0}return{memory:t,render:r,programs:null,autoReset:!0,reset:i,update:n}}var tM=class extends vi{constructor(t=null,r=1,n=1,i=1){super(null),this.image={data:t,width:r,height:n,depth:i},this.magFilter=Li,this.minFilter=Li,this.wrapR=Jo,this.generateMipmaps=!1,this.flipY=!1,this.unpackAlignment=1}};tM.prototype.isDataTexture2DArray=!0;function smr(e,t){return e[0]-t[0]}function lmr(e,t){return Math.abs(t[1])-Math.abs(e[1])}function Due(e,t){let r=1,n=t.isInterleavedBufferAttribute?t.data.array:t.array;n instanceof Int8Array?r=127:n instanceof Int16Array?r=32767:n instanceof Int32Array?r=2147483647:console.error("THREE.WebGLMorphtargets: Unsupported morph attribute data type: ",n),e.divideScalar(r)}function cmr(e,t,r){let n={},i=new Float32Array(8),o=new WeakMap,a=new j,s=[];for(let c=0;c<8;c++)s[c]=[c,0];function l(c,u,h,f){let p=c.morphTargetInfluences;if(t.isWebGL2===!0){let d=u.morphAttributes.position.length,g=o.get(u);if(g===void 0||g.count!==d){let L=function(){B.dispose(),o.delete(u),u.removeEventListener("dispose",L)};g!==void 0&&g.texture.dispose();let x=u.morphAttributes.normal!==void 0,b=u.morphAttributes.position,S=u.morphAttributes.normal||[],C=u.attributes.position.count,P=x===!0?2:1,k=C*P,O=1;k>t.maxTextureSize&&(O=Math.ceil(k/t.maxTextureSize),k=t.maxTextureSize);let D=new Float32Array(k*O*4*d),B=new tM(D,k,O,d);B.format=Qo,B.type=jd,B.needsUpdate=!0;let I=P*4;for(let R=0;R<d;R++){let F=b[R],z=S[R],U=k*O*4*R;for(let W=0;W<F.count;W++){a.fromBufferAttribute(F,W),F.normalized===!0&&Due(a,F);let Z=W*I;D[U+Z+0]=a.x,D[U+Z+1]=a.y,D[U+Z+2]=a.z,D[U+Z+3]=0,x===!0&&(a.fromBufferAttribute(z,W),z.normalized===!0&&Due(a,z),D[U+Z+4]=a.x,D[U+Z+5]=a.y,D[U+Z+6]=a.z,D[U+Z+7]=0)}}g={count:d,texture:B,size:new Lt(k,O)},o.set(u,g),u.addEventListener("dispose",L)}let _=0;for(let x=0;x<p.length;x++)_+=p[x];let y=u.morphTargetsRelative?1:1-_;f.getUniforms().setValue(e,"morphTargetBaseInfluence",y),f.getUniforms().setValue(e,"morphTargetInfluences",p),f.getUniforms().setValue(e,"morphTargetsTexture",g.texture,r),f.getUniforms().setValue(e,"morphTargetsTextureSize",g.size)}else{let d=p===void 0?0:p.length,g=n[u.id];if(g===void 0||g.length!==d){g=[];for(let S=0;S<d;S++)g[S]=[S,0];n[u.id]=g}for(let S=0;S<d;S++){let C=g[S];C[0]=S,C[1]=p[S]}g.sort(lmr);for(let S=0;S<8;S++)S<d&&g[S][1]?(s[S][0]=g[S][0],s[S][1]=g[S][1]):(s[S][0]=Number.MAX_SAFE_INTEGER,s[S][1]=0);s.sort(smr);let _=u.morphAttributes.position,y=u.morphAttributes.normal,x=0;for(let S=0;S<8;S++){let C=s[S],P=C[0],k=C[1];P!==Number.MAX_SAFE_INTEGER&&k?(_&&u.getAttribute("morphTarget"+S)!==_[P]&&u.setAttribute("morphTarget"+S,_[P]),y&&u.getAttribute("morphNormal"+S)!==y[P]&&u.setAttribute("morphNormal"+S,y[P]),i[S]=k,x+=k):(_&&u.hasAttribute("morphTarget"+S)===!0&&u.deleteAttribute("morphTarget"+S),y&&u.hasAttribute("morphNormal"+S)===!0&&u.deleteAttribute("morphNormal"+S),i[S]=0)}let b=u.morphTargetsRelative?1:1-x;f.getUniforms().setValue(e,"morphTargetBaseInfluence",b),f.getUniforms().setValue(e,"morphTargetInfluences",i)}}return{update:l}}function umr(e,t,r,n){let i=new WeakMap;function o(l){let c=n.render.frame,u=l.geometry,h=t.get(l,u);return i.get(h)!==c&&(t.update(h),i.set(h,c)),l.isInstancedMesh&&(l.hasEventListener("dispose",s)===!1&&l.addEventListener("dispose",s),r.update(l.instanceMatrix,34962),l.instanceColor!==null&&r.update(l.instanceColor,34962)),h}function a(){i=new WeakMap}function s(l){let c=l.target;c.removeEventListener("dispose",s),r.remove(c.instanceMatrix),c.instanceColor!==null&&r.remove(c.instanceColor)}return{update:o,dispose:a}}var r6=class extends vi{constructor(t=null,r=1,n=1,i=1){super(null),this.image={data:t,width:r,height:n,depth:i},this.magFilter=Li,this.minFilter=Li,this.wrapR=Jo,this.generateMipmaps=!1,this.flipY=!1,this.unpackAlignment=1}};r6.prototype.isDataTexture3D=!0;var Wfe=new vi,Yfe=new tM,jfe=new r6,Xfe=new H0,Oue=[],zue=[],Fue=new Float32Array(16),Bue=new Float32Array(9),Hue=new Float32Array(4);function bM(e,t,r){let n=e[0];if(n<=0||n>0)return e;let i=t*r,o=Oue[i];if(o===void 0&&(o=new Float32Array(i),Oue[i]=o),t!==0){n.toArray(o,0);for(let a=1,s=0;a!==t;++a)s+=r,e[a].toArray(o,s)}return o}function hs(e,t){if(e.length!==t.length)return!1;for(let r=0,n=e.length;r<n;r++)if(e[r]!==t[r])return!1;return!0}function Ca(e,t){for(let r=0,n=t.length;r<n;r++)e[r]=t[r]}function KU(e,t){let r=zue[t];r===void 0&&(r=new Int32Array(t),zue[t]=r);for(let n=0;n!==t;++n)r[n]=e.allocateTextureUnit();return r}function hmr(e,t){let r=this.cache;r[0]!==t&&(e.uniform1f(this.addr,t),r[0]=t)}function fmr(e,t){let r=this.cache;if(t.x!==void 0)(r[0]!==t.x||r[1]!==t.y)&&(e.uniform2f(this.addr,t.x,t.y),r[0]=t.x,r[1]=t.y);else{if(hs(r,t))return;e.uniform2fv(this.addr,t),Ca(r,t)}}function pmr(e,t){let r=this.cache;if(t.x!==void 0)(r[0]!==t.x||r[1]!==t.y||r[2]!==t.z)&&(e.uniform3f(this.addr,t.x,t.y,t.z),r[0]=t.x,r[1]=t.y,r[2]=t.z);else if(t.r!==void 0)(r[0]!==t.r||r[1]!==t.g||r[2]!==t.b)&&(e.uniform3f(this.addr,t.r,t.g,t.b),r[0]=t.r,r[1]=t.g,r[2]=t.b);else{if(hs(r,t))return;e.uniform3fv(this.addr,t),Ca(r,t)}}function dmr(e,t){let r=this.cache;if(t.x!==void 0)(r[0]!==t.x||r[1]!==t.y||r[2]!==t.z||r[3]!==t.w)&&(e.uniform4f(this.addr,t.x,t.y,t.z,t.w),r[0]=t.x,r[1]=t.y,r[2]=t.z,r[3]=t.w);else{if(hs(r,t))return;e.uniform4fv(this.addr,t),Ca(r,t)}}function mmr(e,t){let r=this.cache,n=t.elements;if(n===void 0){if(hs(r,t))return;e.uniformMatrix2fv(this.addr,!1,t),Ca(r,t)}else{if(hs(r,n))return;Hue.set(n),e.uniformMatrix2fv(this.addr,!1,Hue),Ca(r,n)}}function gmr(e,t){let r=this.cache,n=t.elements;if(n===void 0){if(hs(r,t))return;e.uniformMatrix3fv(this.addr,!1,t),Ca(r,t)}else{if(hs(r,n))return;Bue.set(n),e.uniformMatrix3fv(this.addr,!1,Bue),Ca(r,n)}}function _mr(e,t){let r=this.cache,n=t.elements;if(n===void 0){if(hs(r,t))return;e.uniformMatrix4fv(this.addr,!1,t),Ca(r,t)}else{if(hs(r,n))return;Fue.set(n),e.uniformMatrix4fv(this.addr,!1,Fue),Ca(r,n)}}function ymr(e,t){let r=this.cache;r[0]!==t&&(e.uniform1i(this.addr,t),r[0]=t)}function vmr(e,t){let r=this.cache;hs(r,t)||(e.uniform2iv(this.addr,t),Ca(r,t))}function xmr(e,t){let r=this.cache;hs(r,t)||(e.uniform3iv(this.addr,t),Ca(r,t))}function bmr(e,t){let r=this.cache;hs(r,t)||(e.uniform4iv(this.addr,t),Ca(r,t))}function wmr(e,t){let r=this.cache;r[0]!==t&&(e.uniform1ui(this.addr,t),r[0]=t)}function Smr(e,t){let r=this.cache;hs(r,t)||(e.uniform2uiv(this.addr,t),Ca(r,t))}function Mmr(e,t){let r=this.cache;hs(r,t)||(e.uniform3uiv(this.addr,t),Ca(r,t))}function Emr(e,t){let r=this.cache;hs(r,t)||(e.uniform4uiv(this.addr,t),Ca(r,t))}function Tmr(e,t,r){let n=this.cache,i=r.allocateTextureUnit();n[0]!==i&&(e.uniform1i(this.addr,i),n[0]=i),r.safeSetTexture2D(t||Wfe,i)}function Cmr(e,t,r){let n=this.cache,i=r.allocateTextureUnit();n[0]!==i&&(e.uniform1i(this.addr,i),n[0]=i),r.setTexture3D(t||jfe,i)}function Amr(e,t,r){let n=this.cache,i=r.allocateTextureUnit();n[0]!==i&&(e.uniform1i(this.addr,i),n[0]=i),r.safeSetTextureCube(t||Xfe,i)}function Pmr(e,t,r){let n=this.cache,i=r.allocateTextureUnit();n[0]!==i&&(e.uniform1i(this.addr,i),n[0]=i),r.setTexture2DArray(t||Yfe,i)}function Imr(e){switch(e){case 5126:return hmr;case 35664:return fmr;case 35665:return pmr;case 35666:return dmr;case 35674:return mmr;case 35675:return gmr;case 35676:return _mr;case 5124:case 35670:return ymr;case 35667:case 35671:return vmr;case 35668:case 35672:return xmr;case 35669:case 35673:return bmr;case 5125:return wmr;case 36294:return Smr;case 36295:return Mmr;case 36296:return Emr;case 35678:case 36198:case 36298:case 36306:case 35682:return Tmr;case 35679:case 36299:case 36307:return Cmr;case 35680:case 36300:case 36308:case 36293:return Amr;case 36289:case 36303:case 36311:case 36292:return Pmr}}function Lmr(e,t){e.uniform1fv(this.addr,t)}function kmr(e,t){let r=bM(t,this.size,2);e.uniform2fv(this.addr,r)}function Rmr(e,t){let r=bM(t,this.size,3);e.uniform3fv(this.addr,r)}function Nmr(e,t){let r=bM(t,this.size,4);e.uniform4fv(this.addr,r)}function Dmr(e,t){let r=bM(t,this.size,4);e.uniformMatrix2fv(this.addr,!1,r)}function Omr(e,t){let r=bM(t,this.size,9);e.uniformMatrix3fv(this.addr,!1,r)}function zmr(e,t){let r=bM(t,this.size,16);e.uniformMatrix4fv(this.addr,!1,r)}function Fmr(e,t){e.uniform1iv(this.addr,t)}function Bmr(e,t){e.uniform2iv(this.addr,t)}function Hmr(e,t){e.uniform3iv(this.addr,t)}function Vmr(e,t){e.uniform4iv(this.addr,t)}function Umr(e,t){e.uniform1uiv(this.addr,t)}function qmr(e,t){e.uniform2uiv(this.addr,t)}function Gmr(e,t){e.uniform3uiv(this.addr,t)}function Wmr(e,t){e.uniform4uiv(this.addr,t)}function Ymr(e,t,r){let n=t.length,i=KU(r,n);e.uniform1iv(this.addr,i);for(let o=0;o!==n;++o)r.safeSetTexture2D(t[o]||Wfe,i[o])}function jmr(e,t,r){let n=t.length,i=KU(r,n);e.uniform1iv(this.addr,i);for(let o=0;o!==n;++o)r.setTexture3D(t[o]||jfe,i[o])}function Xmr(e,t,r){let n=t.length,i=KU(r,n);e.uniform1iv(this.addr,i);for(let o=0;o!==n;++o)r.safeSetTextureCube(t[o]||Xfe,i[o])}function $mr(e,t,r){let n=t.length,i=KU(r,n);e.uniform1iv(this.addr,i);for(let o=0;o!==n;++o)r.setTexture2DArray(t[o]||Yfe,i[o])}function Kmr(e){switch(e){case 5126:return Lmr;case 35664:return kmr;case 35665:return Rmr;case 35666:return Nmr;case 35674:return Dmr;case 35675:return Omr;case 35676:return zmr;case 5124:case 35670:return Fmr;case 35667:case 35671:return Bmr;case 35668:case 35672:return Hmr;case 35669:case 35673:return Vmr;case 5125:return Umr;case 36294:return qmr;case 36295:return Gmr;case 36296:return Wmr;case 35678:case 36198:case 36298:case 36306:case 35682:return Ymr;case 35679:case 36299:case 36307:return jmr;case 35680:case 36300:case 36308:case 36293:return Xmr;case 36289:case 36303:case 36311:case 36292:return $mr}}function Zmr(e,t,r){this.id=e,this.addr=r,this.cache=[],this.setValue=Imr(t.type)}function $fe(e,t,r){this.id=e,this.addr=r,this.cache=[],this.size=t.size,this.setValue=Kmr(t.type)}$fe.prototype.updateCache=function(e){let t=this.cache;e instanceof Float32Array&&t.length!==e.length&&(this.cache=new Float32Array(e.length)),Ca(t,e)};function Kfe(e){this.id=e,this.seq=[],this.map={}}Kfe.prototype.setValue=function(e,t,r){let n=this.seq;for(let i=0,o=n.length;i!==o;++i){let a=n[i];a.setValue(e,t[a.id],r)}};var put=/(\w+)(\])?(\[|\.)?/g;function Vue(e,t){e.seq.push(t),e.map[t.id]=t}function Jmr(e,t,r){let n=e.name,i=n.length;for(put.lastIndex=0;;){let o=put.exec(n),a=put.lastIndex,s=o[1],l=o[2]==="]",c=o[3];if(l&&(s=s|0),c===void 0||c==="["&&a+2===i){Vue(r,c===void 0?new Zmr(s,e,t):new $fe(s,e,t));break}else{let h=r.map[s];h===void 0&&(h=new Kfe(s),Vue(r,h)),r=h}}}function B0(e,t){this.seq=[],this.map={};let r=e.getProgramParameter(t,35718);for(let n=0;n<r;++n){let i=e.getActiveUniform(t,n),o=e.getUniformLocation(t,i.name);Jmr(i,o,this)}}B0.prototype.setValue=function(e,t,r,n){let i=this.map[t];i!==void 0&&i.setValue(e,r,n)};B0.prototype.setOptional=function(e,t,r){let n=t[r];n!==void 0&&this.setValue(e,r,n)};B0.upload=function(e,t,r,n){for(let i=0,o=t.length;i!==o;++i){let a=t[i],s=r[a.id];s.needsUpdate!==!1&&a.setValue(e,s.value,n)}};B0.seqWithValue=function(e,t){let r=[];for(let n=0,i=e.length;n!==i;++n){let o=e[n];o.id in t&&r.push(o)}return r};function Uue(e,t,r){let n=e.createShader(t);return e.shaderSource(n,r),e.compileShader(n),n}var Qmr=0;function tgr(e){let t=e.split(`
`);for(let r=0;r<t.length;r++)t[r]=r+1+": "+t[r];return t.join(`
`)}function egr(e){switch(e){case Qd:return["Linear","( value )"];case Wn:return["sRGB","( value )"];default:return console.warn("THREE.WebGLProgram: Unsupported encoding:",e),["Linear","( value )"]}}function que(e,t,r){let n=e.getShaderParameter(t,35713),i=e.getShaderInfoLog(t).trim();return n&&i===""?"":r.toUpperCase()+`

`+i+`

`+tgr(e.getShaderSource(t))}function rgr(e,t){let r=egr(t);return"vec4 "+e+"( vec4 value ) { return LinearTo"+r[0]+r[1]+"; }"}function ngr(e,t){let r;switch(t){case ufe:r="Linear";break;case hfe:r="Reinhard";break;case ffe:r="OptimizedCineon";break;case pfe:r="ACESFilmic";break;case dfe:r="Custom";break;default:console.warn("THREE.WebGLProgram: Unsupported toneMapping:",t),r="Linear"}return"vec3 "+e+"( vec3 color ) { return "+r+"ToneMapping( color ); }"}function igr(e){return[e.extensionDerivatives||e.envMapCubeUV||e.bumpMap||e.tangentSpaceNormalMap||e.clearcoatNormalMap||e.flatShading||e.shaderID==="physical"?"#extension GL_OES_standard_derivatives : enable":"",(e.extensionFragDepth||e.logarithmicDepthBuffer)&&e.rendererExtensionFragDepth?"#extension GL_EXT_frag_depth : enable":"",e.extensionDrawBuffers&&e.rendererExtensionDrawBuffers?"#extension GL_EXT_draw_buffers : require":"",(e.extensionShaderTextureLOD||e.envMap||e.transmission)&&e.rendererExtensionShaderTextureLod?"#extension GL_EXT_shader_texture_lod : enable":""].filter(HP).join(`
`)}function ogr(e){let t=[];for(let r in e){let n=e[r];n!==!1&&t.push("#define "+r+" "+n)}return t.join(`
`)}function agr(e,t){let r={},n=e.getProgramParameter(t,35721);for(let i=0;i<n;i++){let o=e.getActiveAttrib(t,i),a=o.name,s=1;o.type===35674&&(s=2),o.type===35675&&(s=3),o.type===35676&&(s=4),r[a]={type:o.type,location:e.getAttribLocation(t,a),locationSize:s}}return r}function HP(e){return e!==""}function Gue(e,t){return e.replace(/NUM_DIR_LIGHTS/g,t.numDirLights).replace(/NUM_SPOT_LIGHTS/g,t.numSpotLights).replace(/NUM_RECT_AREA_LIGHTS/g,t.numRectAreaLights).replace(/NUM_POINT_LIGHTS/g,t.numPointLights).replace(/NUM_HEMI_LIGHTS/g,t.numHemiLights).replace(/NUM_DIR_LIGHT_SHADOWS/g,t.numDirLightShadows).replace(/NUM_SPOT_LIGHT_SHADOWS/g,t.numSpotLightShadows).replace(/NUM_POINT_LIGHT_SHADOWS/g,t.numPointLightShadows)}function Wue(e,t){return e.replace(/NUM_CLIPPING_PLANES/g,t.numClippingPlanes).replace(/UNION_CLIPPING_PLANES/g,t.numClippingPlanes-t.numClipIntersection)}var sgr=/^[ \t]*#include +<([\w\d./]+)>/gm;function Jut(e){return e.replace(sgr,lgr)}function lgr(e,t){let r=hr[t];if(r===void 0)throw new Error("Can not resolve #include <"+t+">");return Jut(r)}var cgr=/#pragma unroll_loop[\s]+?for \( int i \= (\d+)\; i < (\d+)\; i \+\+ \) \{([\s\S]+?)(?=\})\}/g,ugr=/#pragma unroll_loop_start\s+for\s*\(\s*int\s+i\s*=\s*(\d+)\s*;\s*i\s*<\s*(\d+)\s*;\s*i\s*\+\+\s*\)\s*{([\s\S]+?)}\s+#pragma unroll_loop_end/g;function Yue(e){return e.replace(ugr,Zfe).replace(cgr,hgr)}function hgr(e,t,r,n){return console.warn("WebGLProgram: #pragma unroll_loop shader syntax is deprecated. Please use #pragma unroll_loop_start syntax instead."),Zfe(e,t,r,n)}function Zfe(e,t,r,n){let i="";for(let o=parseInt(t);o<parseInt(r);o++)i+=n.replace(/\[\s*i\s*\]/g,"[ "+o+" ]").replace(/UNROLLED_LOOP_INDEX/g,o);return i}function jue(e){let t="precision "+e.precision+` float;
precision `+e.precision+" int;";return e.precision==="highp"?t+=`
#define HIGH_PRECISION`:e.precision==="mediump"?t+=`
#define MEDIUM_PRECISION`:e.precision==="lowp"&&(t+=`
#define LOW_PRECISION`),t}function fgr(e){let t="SHADOWMAP_TYPE_BASIC";return e.shadowMapType===Cht?t="SHADOWMAP_TYPE_PCF":e.shadowMapType===Uhe?t="SHADOWMAP_TYPE_PCF_SOFT":e.shadowMapType===F3&&(t="SHADOWMAP_TYPE_VSM"),t}function pgr(e){let t="ENVMAP_TYPE_CUBE";if(e.envMap)switch(e.envMapMode){case nx:case ix:t="ENVMAP_TYPE_CUBE";break;case xM:case z6:t="ENVMAP_TYPE_CUBE_UV";break}return t}function dgr(e){let t="ENVMAP_MODE_REFLECTION";if(e.envMap)switch(e.envMapMode){case ix:case z6:t="ENVMAP_MODE_REFRACTION";break}return t}function mgr(e){let t="ENVMAP_BLENDING_NONE";if(e.envMap)switch(e.combine){case O6:t="ENVMAP_BLENDING_MULTIPLY";break;case lfe:t="ENVMAP_BLENDING_MIX";break;case cfe:t="ENVMAP_BLENDING_ADD";break}return t}function ggr(e,t,r,n){let i=e.getContext(),o=r.defines,a=r.vertexShader,s=r.fragmentShader,l=fgr(r),c=pgr(r),u=dgr(r),h=mgr(r),f=r.isWebGL2?"":igr(r),p=ogr(o),d=i.createProgram(),g,_,y=r.glslVersion?"#version "+r.glslVersion+`
`:"";r.isRawShaderMaterial?(g=[p].filter(HP).join(`
`),g.length>0&&(g+=`
`),_=[f,p].filter(HP).join(`
`),_.length>0&&(_+=`
`)):(g=[jue(r),"#define SHADER_NAME "+r.shaderName,p,r.instancing?"#define USE_INSTANCING":"",r.instancingColor?"#define USE_INSTANCING_COLOR":"",r.supportsVertexTextures?"#define VERTEX_TEXTURES":"","#define MAX_BONES "+r.maxBones,r.useFog&&r.fog?"#define USE_FOG":"",r.useFog&&r.fogExp2?"#define FOG_EXP2":"",r.map?"#define USE_MAP":"",r.envMap?"#define USE_ENVMAP":"",r.envMap?"#define "+u:"",r.lightMap?"#define USE_LIGHTMAP":"",r.aoMap?"#define USE_AOMAP":"",r.emissiveMap?"#define USE_EMISSIVEMAP":"",r.bumpMap?"#define USE_BUMPMAP":"",r.normalMap?"#define USE_NORMALMAP":"",r.normalMap&&r.objectSpaceNormalMap?"#define OBJECTSPACE_NORMALMAP":"",r.normalMap&&r.tangentSpaceNormalMap?"#define TANGENTSPACE_NORMALMAP":"",r.clearcoatMap?"#define USE_CLEARCOATMAP":"",r.clearcoatRoughnessMap?"#define USE_CLEARCOAT_ROUGHNESSMAP":"",r.clearcoatNormalMap?"#define USE_CLEARCOAT_NORMALMAP":"",r.displacementMap&&r.supportsVertexTextures?"#define USE_DISPLACEMENTMAP":"",r.specularMap?"#define USE_SPECULARMAP":"",r.specularIntensityMap?"#define USE_SPECULARINTENSITYMAP":"",r.specularColorMap?"#define USE_SPECULARCOLORMAP":"",r.roughnessMap?"#define USE_ROUGHNESSMAP":"",r.metalnessMap?"#define USE_METALNESSMAP":"",r.alphaMap?"#define USE_ALPHAMAP":"",r.transmission?"#define USE_TRANSMISSION":"",r.transmissionMap?"#define USE_TRANSMISSIONMAP":"",r.thicknessMap?"#define USE_THICKNESSMAP":"",r.sheenColorMap?"#define USE_SHEENCOLORMAP":"",r.sheenRoughnessMap?"#define USE_SHEENROUGHNESSMAP":"",r.vertexTangents?"#define USE_TANGENT":"",r.vertexColors?"#define USE_COLOR":"",r.vertexAlphas?"#define USE_COLOR_ALPHA":"",r.vertexUvs?"#define USE_UV":"",r.uvsVertexOnly?"#define UVS_VERTEX_ONLY":"",r.flatShading?"#define FLAT_SHADED":"",r.skinning?"#define USE_SKINNING":"",r.useVertexTexture?"#define BONE_TEXTURE":"",r.morphTargets?"#define USE_MORPHTARGETS":"",r.morphNormals&&r.flatShading===!1?"#define USE_MORPHNORMALS":"",r.morphTargets&&r.isWebGL2?"#define MORPHTARGETS_TEXTURE":"",r.morphTargets&&r.isWebGL2?"#define MORPHTARGETS_COUNT "+r.morphTargetsCount:"",r.doubleSided?"#define DOUBLE_SIDED":"",r.flipSided?"#define FLIP_SIDED":"",r.shadowMapEnabled?"#define USE_SHADOWMAP":"",r.shadowMapEnabled?"#define "+l:"",r.sizeAttenuation?"#define USE_SIZEATTENUATION":"",r.logarithmicDepthBuffer?"#define USE_LOGDEPTHBUF":"",r.logarithmicDepthBuffer&&r.rendererExtensionFragDepth?"#define USE_LOGDEPTHBUF_EXT":"","uniform mat4 modelMatrix;","uniform mat4 modelViewMatrix;","uniform mat4 projectionMatrix;","uniform mat4 viewMatrix;","uniform mat3 normalMatrix;","uniform vec3 cameraPosition;","uniform bool isOrthographic;","#ifdef USE_INSTANCING","	attribute mat4 instanceMatrix;","#endif","#ifdef USE_INSTANCING_COLOR","	attribute vec3 instanceColor;","#endif","attribute vec3 position;","attribute vec3 normal;","attribute vec2 uv;","#ifdef USE_TANGENT","	attribute vec4 tangent;","#endif","#if defined( USE_COLOR_ALPHA )","	attribute vec4 color;","#elif defined( USE_COLOR )","	attribute vec3 color;","#endif","#if ( defined( USE_MORPHTARGETS ) && ! defined( MORPHTARGETS_TEXTURE ) )","	attribute vec3 morphTarget0;","	attribute vec3 morphTarget1;","	attribute vec3 morphTarget2;","	attribute vec3 morphTarget3;","	#ifdef USE_MORPHNORMALS","		attribute vec3 morphNormal0;","		attribute vec3 morphNormal1;","		attribute vec3 morphNormal2;","		attribute vec3 morphNormal3;","	#else","		attribute vec3 morphTarget4;","		attribute vec3 morphTarget5;","		attribute vec3 morphTarget6;","		attribute vec3 morphTarget7;","	#endif","#endif","#ifdef USE_SKINNING","	attribute vec4 skinIndex;","	attribute vec4 skinWeight;","#endif",`
`].filter(HP).join(`
`),_=[f,jue(r),"#define SHADER_NAME "+r.shaderName,p,r.useFog&&r.fog?"#define USE_FOG":"",r.useFog&&r.fogExp2?"#define FOG_EXP2":"",r.map?"#define USE_MAP":"",r.matcap?"#define USE_MATCAP":"",r.envMap?"#define USE_ENVMAP":"",r.envMap?"#define "+c:"",r.envMap?"#define "+u:"",r.envMap?"#define "+h:"",r.lightMap?"#define USE_LIGHTMAP":"",r.aoMap?"#define USE_AOMAP":"",r.emissiveMap?"#define USE_EMISSIVEMAP":"",r.bumpMap?"#define USE_BUMPMAP":"",r.normalMap?"#define USE_NORMALMAP":"",r.normalMap&&r.objectSpaceNormalMap?"#define OBJECTSPACE_NORMALMAP":"",r.normalMap&&r.tangentSpaceNormalMap?"#define TANGENTSPACE_NORMALMAP":"",r.clearcoat?"#define USE_CLEARCOAT":"",r.clearcoatMap?"#define USE_CLEARCOATMAP":"",r.clearcoatRoughnessMap?"#define USE_CLEARCOAT_ROUGHNESSMAP":"",r.clearcoatNormalMap?"#define USE_CLEARCOAT_NORMALMAP":"",r.specularMap?"#define USE_SPECULARMAP":"",r.specularIntensityMap?"#define USE_SPECULARINTENSITYMAP":"",r.specularColorMap?"#define USE_SPECULARCOLORMAP":"",r.roughnessMap?"#define USE_ROUGHNESSMAP":"",r.metalnessMap?"#define USE_METALNESSMAP":"",r.alphaMap?"#define USE_ALPHAMAP":"",r.alphaTest?"#define USE_ALPHATEST":"",r.sheen?"#define USE_SHEEN":"",r.sheenColorMap?"#define USE_SHEENCOLORMAP":"",r.sheenRoughnessMap?"#define USE_SHEENROUGHNESSMAP":"",r.transmission?"#define USE_TRANSMISSION":"",r.transmissionMap?"#define USE_TRANSMISSIONMAP":"",r.thicknessMap?"#define USE_THICKNESSMAP":"",r.decodeVideoTexture?"#define DECODE_VIDEO_TEXTURE":"",r.vertexTangents?"#define USE_TANGENT":"",r.vertexColors||r.instancingColor?"#define USE_COLOR":"",r.vertexAlphas?"#define USE_COLOR_ALPHA":"",r.vertexUvs?"#define USE_UV":"",r.uvsVertexOnly?"#define UVS_VERTEX_ONLY":"",r.gradientMap?"#define USE_GRADIENTMAP":"",r.flatShading?"#define FLAT_SHADED":"",r.doubleSided?"#define DOUBLE_SIDED":"",r.flipSided?"#define FLIP_SIDED":"",r.shadowMapEnabled?"#define USE_SHADOWMAP":"",r.shadowMapEnabled?"#define "+l:"",r.premultipliedAlpha?"#define PREMULTIPLIED_ALPHA":"",r.physicallyCorrectLights?"#define PHYSICALLY_CORRECT_LIGHTS":"",r.logarithmicDepthBuffer?"#define USE_LOGDEPTHBUF":"",r.logarithmicDepthBuffer&&r.rendererExtensionFragDepth?"#define USE_LOGDEPTHBUF_EXT":"",(r.extensionShaderTextureLOD||r.envMap)&&r.rendererExtensionShaderTextureLod?"#define TEXTURE_LOD_EXT":"","uniform mat4 viewMatrix;","uniform vec3 cameraPosition;","uniform bool isOrthographic;",r.toneMapping!==Kd?"#define TONE_MAPPING":"",r.toneMapping!==Kd?hr.tonemapping_pars_fragment:"",r.toneMapping!==Kd?ngr("toneMapping",r.toneMapping):"",r.dithering?"#define DITHERING":"",r.alphaWrite?"":"#define OPAQUE",hr.encodings_pars_fragment,rgr("linearToOutputTexel",r.outputEncoding),r.depthPacking?"#define DEPTH_PACKING "+r.depthPacking:"",`
`].filter(HP).join(`
`)),a=Jut(a),a=Gue(a,r),a=Wue(a,r),s=Jut(s),s=Gue(s,r),s=Wue(s,r),a=Yue(a),s=Yue(s),r.isWebGL2&&r.isRawShaderMaterial!==!0&&(y=`#version 300 es
`,g=["precision mediump sampler2DArray;","#define attribute in","#define varying out","#define texture2D texture"].join(`
`)+`
`+g,_=["#define varying in",r.glslVersion===Kut?"":"layout(location = 0) out highp vec4 pc_fragColor;",r.glslVersion===Kut?"":"#define gl_FragColor pc_fragColor","#define gl_FragDepthEXT gl_FragDepth","#define texture2D texture","#define textureCube texture","#define texture2DProj textureProj","#define texture2DLodEXT textureLod","#define texture2DProjLodEXT textureProjLod","#define textureCubeLodEXT textureLod","#define texture2DGradEXT textureGrad","#define texture2DProjGradEXT textureProjGrad","#define textureCubeGradEXT textureGrad"].join(`
`)+`
`+_);let x=y+g+a,b=y+_+s,S=Uue(i,35633,x),C=Uue(i,35632,b);if(i.attachShader(d,S),i.attachShader(d,C),r.index0AttributeName!==void 0?i.bindAttribLocation(d,0,r.index0AttributeName):r.morphTargets===!0&&i.bindAttribLocation(d,0,"position"),i.linkProgram(d),e.debug.checkShaderErrors){let O=i.getProgramInfoLog(d).trim(),D=i.getShaderInfoLog(S).trim(),B=i.getShaderInfoLog(C).trim(),I=!0,L=!0;if(i.getProgramParameter(d,35714)===!1){I=!1;let R=que(i,S,"vertex"),F=que(i,C,"fragment");console.error("THREE.WebGLProgram: Shader Error "+i.getError()+" - VALIDATE_STATUS "+i.getProgramParameter(d,35715)+`

Program Info Log: `+O+`
`+R+`
`+F)}else O!==""?console.warn("THREE.WebGLProgram: Program Info Log:",O):(D===""||B==="")&&(L=!1);L&&(this.diagnostics={runnable:I,programLog:O,vertexShader:{log:D,prefix:g},fragmentShader:{log:B,prefix:_}})}i.deleteShader(S),i.deleteShader(C);let P;this.getUniforms=function(){return P===void 0&&(P=new B0(i,d)),P};let k;return this.getAttributes=function(){return k===void 0&&(k=agr(i,d)),k},this.destroy=function(){n.releaseStatesOfProgram(this),i.deleteProgram(d),this.program=void 0},this.name=r.shaderName,this.id=Qmr++,this.cacheKey=t,this.usedTimes=1,this.program=d,this.vertexShader=S,this.fragmentShader=C,this}var _gr=0,Qut=class{constructor(){this.shaderCache=new Map,this.materialCache=new Map}update(t){let r=t.vertexShader,n=t.fragmentShader,i=this._getShaderStage(r),o=this._getShaderStage(n),a=this._getShaderCacheForMaterial(t);return a.has(i)===!1&&(a.add(i),i.usedTimes++),a.has(o)===!1&&(a.add(o),o.usedTimes++),this}remove(t){let r=this.materialCache.get(t);for(let n of r)n.usedTimes--,n.usedTimes===0&&this.shaderCache.delete(n);return this.materialCache.delete(t),this}getVertexShaderID(t){return this._getShaderStage(t.vertexShader).id}getFragmentShaderID(t){return this._getShaderStage(t.fragmentShader).id}dispose(){this.shaderCache.clear(),this.materialCache.clear()}_getShaderCacheForMaterial(t){let r=this.materialCache;return r.has(t)===!1&&r.set(t,new Set),r.get(t)}_getShaderStage(t){let r=this.shaderCache;if(r.has(t)===!1){let n=new tht;r.set(t,n)}return r.get(t)}},tht=class{constructor(){this.id=_gr++,this.usedTimes=0}};function ygr(e,t,r,n,i,o,a){let s=new X3,l=new Qut,c=[],u=i.isWebGL2,h=i.logarithmicDepthBuffer,f=i.floatVertexTextures,p=i.maxVertexUniforms,d=i.vertexTextures,g=i.precision,_={MeshDepthMaterial:"depth",MeshDistanceMaterial:"distanceRGBA",MeshNormalMaterial:"normal",MeshBasicMaterial:"basic",MeshLambertMaterial:"lambert",MeshPhongMaterial:"phong",MeshToonMaterial:"toon",MeshStandardMaterial:"physical",MeshPhysicalMaterial:"physical",MeshMatcapMaterial:"matcap",LineBasicMaterial:"basic",LineDashedMaterial:"dashed",PointsMaterial:"points",ShadowMaterial:"shadow",SpriteMaterial:"sprite"};function y(I){let R=I.skeleton.bones;if(f)return 1024;{let z=Math.floor((p-20)/4),U=Math.min(z,R.length);return U<R.length?(console.warn("THREE.WebGLRenderer: Skeleton has "+R.length+" bones. This GPU supports "+U+"."),0):U}}function x(I,L,R,F,z){let U=F.fog,W=I.isMeshStandardMaterial?F.environment:null,Z=(I.isMeshStandardMaterial?r:t).get(I.envMap||W),rt=_[I.type],ot=z.isSkinnedMesh?y(z):0;I.precision!==null&&(g=i.getMaxPrecision(I.precision),g!==I.precision&&console.warn("THREE.WebGLProgram.getParameters:",I.precision,"not supported, using",g,"instead."));let st,St,bt,Mt;if(rt){let X=ah[rt];st=X.vertexShader,St=X.fragmentShader}else st=I.vertexShader,St=I.fragmentShader,l.update(I),bt=l.getVertexShaderID(I),Mt=l.getFragmentShaderID(I);let lt=e.getRenderTarget(),Kt=I.alphaTest>0,_t=I.clearcoat>0;return{isWebGL2:u,shaderID:rt,shaderName:I.type,vertexShader:st,fragmentShader:St,defines:I.defines,customVertexShaderID:bt,customFragmentShaderID:Mt,isRawShaderMaterial:I.isRawShaderMaterial===!0,glslVersion:I.glslVersion,precision:g,instancing:z.isInstancedMesh===!0,instancingColor:z.isInstancedMesh===!0&&z.instanceColor!==null,supportsVertexTextures:d,outputEncoding:lt===null?e.outputEncoding:lt.isXRRenderTarget===!0?lt.texture.encoding:Qd,map:!!I.map,matcap:!!I.matcap,envMap:!!Z,envMapMode:Z&&Z.mapping,envMapCubeUV:!!Z&&(Z.mapping===xM||Z.mapping===z6),lightMap:!!I.lightMap,aoMap:!!I.aoMap,emissiveMap:!!I.emissiveMap,bumpMap:!!I.bumpMap,normalMap:!!I.normalMap,objectSpaceNormalMap:I.normalMapType===Dfe,tangentSpaceNormalMap:I.normalMapType===ax,decodeVideoTexture:!!I.map&&I.map.isVideoTexture===!0&&I.map.encoding===Wn,clearcoat:_t,clearcoatMap:_t&&!!I.clearcoatMap,clearcoatRoughnessMap:_t&&!!I.clearcoatRoughnessMap,clearcoatNormalMap:_t&&!!I.clearcoatNormalMap,displacementMap:!!I.displacementMap,roughnessMap:!!I.roughnessMap,metalnessMap:!!I.metalnessMap,specularMap:!!I.specularMap,specularIntensityMap:!!I.specularIntensityMap,specularColorMap:!!I.specularColorMap,alphaMap:!!I.alphaMap,alphaTest:Kt,alphaWrite:I.alphaWrite||I.transparent,gradientMap:!!I.gradientMap,sheen:I.sheen>0,sheenColorMap:!!I.sheenColorMap,sheenRoughnessMap:!!I.sheenRoughnessMap,transmission:I.transmission>0,transmissionMap:!!I.transmissionMap,thicknessMap:!!I.thicknessMap,combine:I.combine,vertexTangents:!!I.normalMap&&!!z.geometry&&!!z.geometry.attributes.tangent,vertexColors:I.vertexColors,vertexAlphas:I.vertexColors===!0&&!!z.geometry&&!!z.geometry.attributes.color&&z.geometry.attributes.color.itemSize===4,vertexUvs:!!I.map||!!I.bumpMap||!!I.normalMap||!!I.specularMap||!!I.alphaMap||!!I.emissiveMap||!!I.roughnessMap||!!I.metalnessMap||!!I.clearcoatMap||!!I.clearcoatRoughnessMap||!!I.clearcoatNormalMap||!!I.displacementMap||!!I.transmissionMap||!!I.thicknessMap||!!I.specularIntensityMap||!!I.specularColorMap||!!I.sheenColorMap||!!I.sheenRoughnessMap,uvsVertexOnly:!(!!I.map||!!I.bumpMap||!!I.normalMap||!!I.specularMap||!!I.alphaMap||!!I.emissiveMap||!!I.roughnessMap||!!I.metalnessMap||!!I.clearcoatNormalMap||I.transmission>0||!!I.transmissionMap||!!I.thicknessMap||!!I.specularIntensityMap||!!I.specularColorMap||I.sheen>0||!!I.sheenColorMap||!!I.sheenRoughnessMap)&&!!I.displacementMap,fog:!!U,useFog:I.fog,fogExp2:U&&U.isFogExp2,flatShading:!!I.flatShading,sizeAttenuation:I.sizeAttenuation,logarithmicDepthBuffer:h,skinning:z.isSkinnedMesh===!0&&ot>0,maxBones:ot,useVertexTexture:f,morphTargets:!!z.geometry&&!!z.geometry.morphAttributes.position,morphNormals:!!z.geometry&&!!z.geometry.morphAttributes.normal,morphTargetsCount:!!z.geometry&&!!z.geometry.morphAttributes.position?z.geometry.morphAttributes.position.length:0,numDirLights:L.directional.length,numPointLights:L.point.length,numSpotLights:L.spot.length,numRectAreaLights:L.rectArea.length,numHemiLights:L.hemi.length,numDirLightShadows:L.directionalShadowMap.length,numPointLightShadows:L.pointShadowMap.length,numSpotLightShadows:L.spotShadowMap.length,numClippingPlanes:a.numPlanes,numClipIntersection:a.numIntersection,dithering:I.dithering,shadowMapEnabled:e.shadowMap.enabled&&R.length>0,shadowMapType:e.shadowMap.type,toneMapping:I.toneMapped?e.toneMapping:Kd,physicallyCorrectLights:e.physicallyCorrectLights,premultipliedAlpha:I.premultipliedAlpha,doubleSided:I.side===L1,flipSided:I.side===Ii,depthPacking:I.depthPacking!==void 0?I.depthPacking:!1,index0AttributeName:I.index0AttributeName,extensionDerivatives:I.extensions&&I.extensions.derivatives,extensionFragDepth:I.extensions&&I.extensions.fragDepth,extensionDrawBuffers:I.extensions&&I.extensions.drawBuffers,extensionShaderTextureLOD:I.extensions&&I.extensions.shaderTextureLOD,rendererExtensionFragDepth:u||n.has("EXT_frag_depth"),rendererExtensionDrawBuffers:u||n.has("WEBGL_draw_buffers"),rendererExtensionShaderTextureLod:u||n.has("EXT_shader_texture_lod"),customProgramCacheKey:I.customProgramCacheKey()}}function b(I){let L=[];if(I.shaderID?L.push(I.shaderID):(L.push(I.customVertexShaderID),L.push(I.customFragmentShaderID)),I.defines!==void 0)for(let R in I.defines)L.push(R),L.push(I.defines[R]);return I.isRawShaderMaterial===!1&&(S(L,I),C(L,I),L.push(e.outputEncoding)),L.push(I.customProgramCacheKey),L.join()}function S(I,L){I.push(L.precision),I.push(L.outputEncoding),I.push(L.envMapMode),I.push(L.combine),I.push(L.vertexUvs),I.push(L.fogExp2),I.push(L.sizeAttenuation),I.push(L.maxBones),I.push(L.morphTargetsCount),I.push(L.numDirLights),I.push(L.numPointLights),I.push(L.numSpotLights),I.push(L.numHemiLights),I.push(L.numRectAreaLights),I.push(L.numDirLightShadows),I.push(L.numPointLightShadows),I.push(L.numSpotLightShadows),I.push(L.shadowMapType),I.push(L.toneMapping),I.push(L.numClippingPlanes),I.push(L.numClipIntersection),I.push(L.alphaWrite)}function C(I,L){s.disableAll(),L.isWebGL2&&s.enable(0),L.supportsVertexTextures&&s.enable(1),L.instancing&&s.enable(2),L.instancingColor&&s.enable(3),L.map&&s.enable(4),L.matcap&&s.enable(5),L.envMap&&s.enable(6),L.envMapCubeUV&&s.enable(7),L.lightMap&&s.enable(8),L.aoMap&&s.enable(9),L.emissiveMap&&s.enable(10),L.bumpMap&&s.enable(11),L.normalMap&&s.enable(12),L.objectSpaceNormalMap&&s.enable(13),L.tangentSpaceNormalMap&&s.enable(14),L.clearcoat&&s.enable(15),L.clearcoatMap&&s.enable(16),L.clearcoatRoughnessMap&&s.enable(17),L.clearcoatNormalMap&&s.enable(18),L.displacementMap&&s.enable(19),L.specularMap&&s.enable(20),L.roughnessMap&&s.enable(21),L.metalnessMap&&s.enable(22),L.gradientMap&&s.enable(23),L.alphaMap&&s.enable(24),L.alphaTest&&s.enable(25),L.vertexColors&&s.enable(26),L.vertexAlphas&&s.enable(27),L.vertexUvs&&s.enable(28),L.vertexTangents&&s.enable(29),L.uvsVertexOnly&&s.enable(30),L.fog&&s.enable(31),I.push(s.mask),s.disableAll(),L.useFog&&s.enable(0),L.flatShading&&s.enable(1),L.logarithmicDepthBuffer&&s.enable(2),L.skinning&&s.enable(3),L.useVertexTexture&&s.enable(4),L.morphTargets&&s.enable(5),L.morphNormals&&s.enable(6),L.premultipliedAlpha&&s.enable(7),L.shadowMapEnabled&&s.enable(8),L.physicallyCorrectLights&&s.enable(9),L.doubleSided&&s.enable(10),L.flipSided&&s.enable(11),L.depthPacking&&s.enable(12),L.dithering&&s.enable(13),L.specularIntensityMap&&s.enable(14),L.specularColorMap&&s.enable(15),L.transmission&&s.enable(16),L.transmissionMap&&s.enable(17),L.thicknessMap&&s.enable(18),L.sheen&&s.enable(19),L.sheenColorMap&&s.enable(20),L.sheenRoughnessMap&&s.enable(21),L.decodeVideoTexture&&s.enable(22),I.push(s.mask)}function P(I){let L=_[I.type],R;if(L){let F=ah[L];R=Vfe.clone(F.uniforms)}else R=I.uniforms;return R}function k(I,L){let R;for(let F=0,z=c.length;F<z;F++){let U=c[F];if(U.cacheKey===L){R=U,++R.usedTimes;break}}return R===void 0&&(R=new ggr(e,L,I,o),c.push(R)),R}function O(I){if(--I.usedTimes===0){let L=c.indexOf(I);c[L]=c[c.length-1],c.pop(),I.destroy()}}function D(I){l.remove(I)}function B(){l.dispose()}return{getParameters:x,getProgramCacheKey:b,getUniforms:P,acquireProgram:k,releaseProgram:O,releaseShaderCache:D,programs:c,dispose:B}}function vgr(){let e=new WeakMap;function t(o){let a=e.get(o);return a===void 0&&(a={},e.set(o,a)),a}function r(o){e.delete(o)}function n(o,a,s){e.get(o)[a]=s}function i(){e=new WeakMap}return{get:t,remove:r,update:n,dispose:i}}function xgr(e,t){return e.groupOrder!==t.groupOrder?e.groupOrder-t.groupOrder:e.renderOrder!==t.renderOrder?e.renderOrder-t.renderOrder:e.material.id!==t.material.id?e.material.id-t.material.id:e.z!==t.z?e.z-t.z:e.id-t.id}function Xue(e,t){return e.groupOrder!==t.groupOrder?e.groupOrder-t.groupOrder:e.renderOrder!==t.renderOrder?e.renderOrder-t.renderOrder:e.z!==t.z?t.z-e.z:e.id-t.id}function $ue(){let e=[],t=0,r=[],n=[],i=[];function o(){t=0,r.length=0,n.length=0,i.length=0}function a(h,f,p,d,g,_){let y=e[t];return y===void 0?(y={id:h.id,object:h,geometry:f,material:p,groupOrder:d,renderOrder:h.renderOrder,z:g,group:_},e[t]=y):(y.id=h.id,y.object=h,y.geometry=f,y.material=p,y.groupOrder=d,y.renderOrder=h.renderOrder,y.z=g,y.group=_),t++,y}function s(h,f,p,d,g,_){let y=a(h,f,p,d,g,_);p.transmission>0?n.push(y):p.transparent===!0?i.push(y):r.push(y)}function l(h,f,p,d,g,_){let y=a(h,f,p,d,g,_);p.transmission>0?n.unshift(y):p.transparent===!0?i.unshift(y):r.unshift(y)}function c(h,f){r.length>1&&r.sort(h||xgr),n.length>1&&n.sort(f||Xue),i.length>1&&i.sort(f||Xue)}function u(){for(let h=t,f=e.length;h<f;h++){let p=e[h];if(p.id===null)break;p.id=null,p.object=null,p.geometry=null,p.material=null,p.group=null}}return{opaque:r,transmissive:n,transparent:i,init:o,push:s,unshift:l,finish:u,sort:c}}function bgr(){let e=new WeakMap;function t(n,i){let o;return e.has(n)===!1?(o=new $ue,e.set(n,[o])):i>=e.get(n).length?(o=new $ue,e.get(n).push(o)):o=e.get(n)[i],o}function r(){e=new WeakMap}return{get:t,dispose:r}}function wgr(){let e={};return{get:function(t){if(e[t.id]!==void 0)return e[t.id];let r;switch(t.type){case"DirectionalLight":r={direction:new j,color:new ne};break;case"SpotLight":r={position:new j,direction:new j,color:new ne,distance:0,coneCos:0,penumbraCos:0,decay:0};break;case"PointLight":r={position:new j,color:new ne,distance:0,decay:0};break;case"HemisphereLight":r={direction:new j,skyColor:new ne,groundColor:new ne};break;case"RectAreaLight":r={color:new ne,position:new j,halfWidth:new j,halfHeight:new j};break}return e[t.id]=r,r}}}function Sgr(){let e={};return{get:function(t){if(e[t.id]!==void 0)return e[t.id];let r;switch(t.type){case"DirectionalLight":r={shadowBias:0,shadowNormalBias:0,shadowRadius:1,shadowMapSize:new Lt};break;case"SpotLight":r={shadowBias:0,shadowNormalBias:0,shadowRadius:1,shadowMapSize:new Lt};break;case"PointLight":r={shadowBias:0,shadowNormalBias:0,shadowRadius:1,shadowMapSize:new Lt,shadowCameraNear:1,shadowCameraFar:1e3};break}return e[t.id]=r,r}}}var Mgr=0;function Egr(e,t){return(t.castShadow?1:0)-(e.castShadow?1:0)}function Tgr(e,t){let r=new wgr,n=Sgr(),i={version:0,hash:{directionalLength:-1,pointLength:-1,spotLength:-1,rectAreaLength:-1,hemiLength:-1,numDirectionalShadows:-1,numPointShadows:-1,numSpotShadows:-1},ambient:[0,0,0],probe:[],directional:[],directionalShadow:[],directionalShadowMap:[],directionalShadowMatrix:[],spot:[],spotShadow:[],spotShadowMap:[],spotShadowMatrix:[],rectArea:[],rectAreaLTC1:null,rectAreaLTC2:null,point:[],pointShadow:[],pointShadowMap:[],pointShadowMatrix:[],hemi:[]};for(let u=0;u<9;u++)i.probe.push(new j);let o=new j,a=new Me,s=new Me;function l(u,h){let f=0,p=0,d=0;for(let D=0;D<9;D++)i.probe[D].set(0,0,0);let g=0,_=0,y=0,x=0,b=0,S=0,C=0,P=0;u.sort(Egr);let k=h!==!0?Math.PI:1;for(let D=0,B=u.length;D<B;D++){let I=u[D],L=I.color,R=I.intensity,F=I.distance,z=I.shadow&&I.shadow.map?I.shadow.map.texture:null;if(I.isAmbientLight)f+=L.r*R*k,p+=L.g*R*k,d+=L.b*R*k;else if(I.isLightProbe)for(let U=0;U<9;U++)i.probe[U].addScaledVector(I.sh.coefficients[U],R);else if(I.isDirectionalLight){let U=r.get(I);if(U.color.copy(I.color).multiplyScalar(I.intensity*k),I.castShadow){let W=I.shadow,Z=n.get(I);Z.shadowBias=W.bias,Z.shadowNormalBias=W.normalBias,Z.shadowRadius=W.radius,Z.shadowMapSize=W.mapSize,i.directionalShadow[g]=Z,i.directionalShadowMap[g]=z,i.directionalShadowMatrix[g]=I.shadow.matrix,S++}i.directional[g]=U,g++}else if(I.isSpotLight){let U=r.get(I);if(U.position.setFromMatrixPosition(I.matrixWorld),U.color.copy(L).multiplyScalar(R*k),U.distance=F,U.coneCos=Math.cos(I.angle),U.penumbraCos=Math.cos(I.angle*(1-I.penumbra)),U.decay=I.decay,I.castShadow){let W=I.shadow,Z=n.get(I);Z.shadowBias=W.bias,Z.shadowNormalBias=W.normalBias,Z.shadowRadius=W.radius,Z.shadowMapSize=W.mapSize,i.spotShadow[y]=Z,i.spotShadowMap[y]=z,i.spotShadowMatrix[y]=I.shadow.matrix,P++}i.spot[y]=U,y++}else if(I.isRectAreaLight){let U=r.get(I);U.color.copy(L).multiplyScalar(R),U.halfWidth.set(I.width*.5,0,0),U.halfHeight.set(0,I.height*.5,0),i.rectArea[x]=U,x++}else if(I.isPointLight){let U=r.get(I);if(U.color.copy(I.color).multiplyScalar(I.intensity*k),U.distance=I.distance,U.decay=I.decay,I.castShadow){let W=I.shadow,Z=n.get(I);Z.shadowBias=W.bias,Z.shadowNormalBias=W.normalBias,Z.shadowRadius=W.radius,Z.shadowMapSize=W.mapSize,Z.shadowCameraNear=W.camera.near,Z.shadowCameraFar=W.camera.far,i.pointShadow[_]=Z,i.pointShadowMap[_]=z,i.pointShadowMatrix[_]=I.shadow.matrix,C++}i.point[_]=U,_++}else if(I.isHemisphereLight){let U=r.get(I);U.skyColor.copy(I.color).multiplyScalar(R*k),U.groundColor.copy(I.groundColor).multiplyScalar(R*k),i.hemi[b]=U,b++}}x>0&&(t.isWebGL2||e.has("OES_texture_float_linear")===!0?(i.rectAreaLTC1=re.LTC_FLOAT_1,i.rectAreaLTC2=re.LTC_FLOAT_2):e.has("OES_texture_half_float_linear")===!0?(i.rectAreaLTC1=re.LTC_HALF_1,i.rectAreaLTC2=re.LTC_HALF_2):console.error("THREE.WebGLRenderer: Unable to use RectAreaLight. Missing WebGL extensions.")),i.ambient[0]=f,i.ambient[1]=p,i.ambient[2]=d;let O=i.hash;(O.directionalLength!==g||O.pointLength!==_||O.spotLength!==y||O.rectAreaLength!==x||O.hemiLength!==b||O.numDirectionalShadows!==S||O.numPointShadows!==C||O.numSpotShadows!==P)&&(i.directional.length=g,i.spot.length=y,i.rectArea.length=x,i.point.length=_,i.hemi.length=b,i.directionalShadow.length=S,i.directionalShadowMap.length=S,i.pointShadow.length=C,i.pointShadowMap.length=C,i.spotShadow.length=P,i.spotShadowMap.length=P,i.directionalShadowMatrix.length=S,i.pointShadowMatrix.length=C,i.spotShadowMatrix.length=P,O.directionalLength=g,O.pointLength=_,O.spotLength=y,O.rectAreaLength=x,O.hemiLength=b,O.numDirectionalShadows=S,O.numPointShadows=C,O.numSpotShadows=P,i.version=Mgr++)}function c(u,h){let f=0,p=0,d=0,g=0,_=0,y=h.matrixWorldInverse;for(let x=0,b=u.length;x<b;x++){let S=u[x];if(S.isDirectionalLight){let C=i.directional[f];C.direction.setFromMatrixPosition(S.matrixWorld),o.setFromMatrixPosition(S.target.matrixWorld),C.direction.sub(o),C.direction.transformDirection(y),f++}else if(S.isSpotLight){let C=i.spot[d];C.position.setFromMatrixPosition(S.matrixWorld),C.position.applyMatrix4(y),C.direction.setFromMatrixPosition(S.matrixWorld),o.setFromMatrixPosition(S.target.matrixWorld),C.direction.sub(o),C.direction.transformDirection(y),d++}else if(S.isRectAreaLight){let C=i.rectArea[g];C.position.setFromMatrixPosition(S.matrixWorld),C.position.applyMatrix4(y),s.identity(),a.copy(S.matrixWorld),a.premultiply(y),s.extractRotation(a),C.halfWidth.set(S.width*.5,0,0),C.halfHeight.set(0,S.height*.5,0),C.halfWidth.applyMatrix4(s),C.halfHeight.applyMatrix4(s),g++}else if(S.isPointLight){let C=i.point[p];C.position.setFromMatrixPosition(S.matrixWorld),C.position.applyMatrix4(y),p++}else if(S.isHemisphereLight){let C=i.hemi[_];C.direction.setFromMatrixPosition(S.matrixWorld),C.direction.transformDirection(y),C.direction.normalize(),_++}}}return{setup:l,setupView:c,state:i}}function Kue(e,t){let r=new Tgr(e,t),n=[],i=[];function o(){n.length=0,i.length=0}function a(h){n.push(h)}function s(h){i.push(h)}function l(h){r.setup(n,h)}function c(h){r.setupView(n,h)}return{init:o,state:{lightsArray:n,shadowsArray:i,lights:r},setupLights:l,setupLightsView:c,pushLight:a,pushShadow:s}}function Cgr(e,t){let r=new WeakMap;function n(o,a=0){let s;return r.has(o)===!1?(s=new Kue(e,t),r.set(o,[s])):a>=r.get(o).length?(s=new Kue(e,t),r.get(o).push(s)):s=r.get(o)[a],s}function i(){r=new WeakMap}return{get:n,dispose:i}}var eM=class extends qi{constructor(t){super(),this.type="MeshDepthMaterial",this.depthPacking=Rfe,this.map=null,this.alphaMap=null,this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.wireframe=!1,this.wireframeLinewidth=1,this.fog=!1,this.setValues(t)}copy(t){return super.copy(t),this.depthPacking=t.depthPacking,this.map=t.map,this.alphaMap=t.alphaMap,this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this}};eM.prototype.isMeshDepthMaterial=!0;var rM=class extends qi{constructor(t){super(),this.type="MeshDistanceMaterial",this.referencePosition=new j,this.nearDistance=1,this.farDistance=1e3,this.map=null,this.alphaMap=null,this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.fog=!1,this.setValues(t)}copy(t){return super.copy(t),this.referencePosition.copy(t.referencePosition),this.nearDistance=t.nearDistance,this.farDistance=t.farDistance,this.map=t.map,this.alphaMap=t.alphaMap,this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this}};rM.prototype.isMeshDistanceMaterial=!0;var Agr=`void main() {
	gl_Position = vec4( position, 1.0 );
}`,Pgr=`uniform sampler2D shadow_pass;
uniform vec2 resolution;
uniform float radius;
#include <packing>
void main() {
	const float samples = float( VSM_SAMPLES );
	float mean = 0.0;
	float squared_mean = 0.0;
	float uvStride = samples <= 1.0 ? 0.0 : 2.0 / ( samples - 1.0 );
	float uvStart = samples <= 1.0 ? 0.0 : - 1.0;
	for ( float i = 0.0; i < samples; i ++ ) {
		float uvOffset = uvStart + i * uvStride;
		#ifdef HORIZONTAL_PASS
			vec2 distribution = unpackRGBATo2Half( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( uvOffset, 0.0 ) * radius ) / resolution ) );
			mean += distribution.x;
			squared_mean += distribution.y * distribution.y + distribution.x * distribution.x;
		#else
			float depth = unpackRGBAToDepth( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( 0.0, uvOffset ) * radius ) / resolution ) );
			mean += depth;
			squared_mean += depth * depth;
		#endif
	}
	mean = mean / samples;
	squared_mean = squared_mean / samples;
	float std_dev = sqrt( squared_mean - mean * mean );
	gl_FragColor = pack2HalfToRGBA( vec2( mean, std_dev ) );
}`;function Jfe(e,t,r){let n=new N1,i=new Lt,o=new Lt,a=new en,s=new eM({depthPacking:Nfe}),l=new rM,c={},u=r.maxTextureSize,h={0:Ii,1:I1,2:L1},f=new lh({defines:{VSM_SAMPLES:8},uniforms:{shadow_pass:{value:null},resolution:{value:new Lt},radius:{value:4}},vertexShader:Agr,fragmentShader:Pgr}),p=f.clone();p.defines.HORIZONTAL_PASS=1;let d=new Pe;d.setAttribute("position",new Je(new Float32Array([-1,-1,.5,3,-1,.5,-1,3,.5]),3));let g=new ti(d,f),_=this;this.enabled=!1,this.autoUpdate=!0,this.needsUpdate=!1,this.type=Cht,this.render=function(S,C,P){if(_.enabled===!1||_.autoUpdate===!1&&_.needsUpdate===!1||S.length===0)return;let k=e.getRenderTarget(),O=e.getActiveCubeFace(),D=e.getActiveMipmapLevel(),B=e.state;B.setBlending($d),B.buffers.color.setClear(1,1,1,1),B.buffers.depth.setTest(!0),B.setScissorTest(!1);for(let I=0,L=S.length;I<L;I++){let R=S[I],F=R.shadow;if(F===void 0){console.warn("THREE.WebGLShadowMap:",R,"has no shadow.");continue}if(F.autoUpdate===!1&&F.needsUpdate===!1)continue;i.copy(F.mapSize);let z=F.getFrameExtents();if(i.multiply(z),o.copy(F.mapSize),(i.x>u||i.y>u)&&(i.x>u&&(o.x=Math.floor(u/z.x),i.x=o.x*z.x,F.mapSize.x=o.x),i.y>u&&(o.y=Math.floor(u/z.y),i.y=o.y*z.y,F.mapSize.y=o.y)),F.map===null&&!F.isPointLightShadow&&this.type===F3){let W={minFilter:ii,magFilter:ii,format:Qo};F.map=new us(i.x,i.y,W),F.map.texture.name=R.name+".shadowMap",F.mapPass=new us(i.x,i.y,W),F.camera.updateProjectionMatrix()}if(F.map===null){let W={minFilter:Li,magFilter:Li,format:Qo};F.map=new us(i.x,i.y,W),F.map.texture.name=R.name+".shadowMap",F.camera.updateProjectionMatrix()}e.setRenderTarget(F.map),e.clear();let U=F.getViewportCount();for(let W=0;W<U;W++){let Z=F.getViewport(W);a.set(o.x*Z.x,o.y*Z.y,o.x*Z.z,o.y*Z.w),B.viewport(a),F.updateMatrices(R,W),n=F.getFrustum(),b(C,P,F.camera,R,this.type)}!F.isPointLightShadow&&this.type===F3&&y(F,P),F.needsUpdate=!1}_.needsUpdate=!1,e.setRenderTarget(k,O,D)};function y(S,C){let P=t.update(g);f.defines.VSM_SAMPLES!==S.blurSamples&&(f.defines.VSM_SAMPLES=S.blurSamples,p.defines.VSM_SAMPLES=S.blurSamples,f.needsUpdate=!0,p.needsUpdate=!0),f.uniforms.shadow_pass.value=S.map.texture,f.uniforms.resolution.value=S.mapSize,f.uniforms.radius.value=S.radius,e.setRenderTarget(S.mapPass),e.clear(),e.renderBufferDirect(C,null,P,f,g,null),p.uniforms.shadow_pass.value=S.mapPass.texture,p.uniforms.resolution.value=S.mapSize,p.uniforms.radius.value=S.radius,e.setRenderTarget(S.map),e.clear(),e.renderBufferDirect(C,null,P,p,g,null)}function x(S,C,P,k,O,D,B){let I=null,L=k.isPointLight===!0?S.customDistanceMaterial:S.customDepthMaterial;if(L!==void 0?I=L:I=k.isPointLight===!0?l:s,e.localClippingEnabled&&P.clipShadows===!0&&P.clippingPlanes.length!==0||P.displacementMap&&P.displacementScale!==0||P.alphaMap&&P.alphaTest>0){let R=I.uuid,F=P.uuid,z=c[R];z===void 0&&(z={},c[R]=z);let U=z[F];U===void 0&&(U=I.clone(),z[F]=U),I=U}return I.visible=P.visible,I.wireframe=P.wireframe,B===F3?I.side=P.shadowSide!==null?P.shadowSide:P.side:I.side=P.shadowSide!==null?P.shadowSide:h[P.side],I.alphaMap=P.alphaMap,I.alphaTest=P.alphaTest,I.clipShadows=P.clipShadows,I.clippingPlanes=P.clippingPlanes,I.clipIntersection=P.clipIntersection,I.displacementMap=P.displacementMap,I.displacementScale=P.displacementScale,I.displacementBias=P.displacementBias,I.wireframeLinewidth=P.wireframeLinewidth,I.linewidth=P.linewidth,k.isPointLight===!0&&I.isMeshDistanceMaterial===!0&&(I.referencePosition.setFromMatrixPosition(k.matrixWorld),I.nearDistance=O,I.farDistance=D),I}function b(S,C,P,k,O){if(S.visible===!1)return;if(S.layers.test(C.layers)&&(S.isMesh||S.isLine||S.isPoints)&&(S.castShadow||S.receiveShadow&&O===F3)&&(!S.frustumCulled||n.intersectsObject(S))){S.modelViewMatrix.multiplyMatrices(P.matrixWorldInverse,S.matrixWorld);let I=t.update(S),L=S.material;if(Array.isArray(L)){let R=I.groups;for(let F=0,z=R.length;F<z;F++){let U=R[F],W=L[U.materialIndex];if(W&&W.visible){let Z=x(S,I,W,k,P.near,P.far,O);e.renderBufferDirect(P,null,I,Z,S,U)}}}else if(L.visible){let R=x(S,I,L,k,P.near,P.far,O);e.renderBufferDirect(P,null,I,R,S,null)}}let B=S.children;for(let I=0,L=B.length;I<L;I++)b(B[I],C,P,k,O)}}function Igr(e,t,r){let n=r.isWebGL2;function i(){let at=!1,se=new en,Qt=null,Ce=new en(0,0,0,0);return{setMask:function(Pt){Qt!==Pt&&!at&&(e.colorMask(Pt,Pt,Pt,Pt),Qt=Pt)},setLocked:function(Pt){at=Pt},setClear:function(Pt,Nt,ze,yn,Wi){Wi===!0&&(Pt*=yn,Nt*=yn,ze*=yn),se.set(Pt,Nt,ze,yn),Ce.equals(se)===!1&&(e.clearColor(Pt,Nt,ze,yn),Ce.copy(se))},reset:function(){at=!1,Qt=null,Ce.set(-1,0,0,0)}}}function o(){let at=!1,se=null,Qt=null,Ce=null;return{setTest:function(Pt){Pt?lt(2929):Kt(2929)},setMask:function(Pt){se!==Pt&&!at&&(e.depthMask(Pt),se=Pt)},setFunc:function(Pt){if(Qt!==Pt){if(Pt)switch(Pt){case efe:e.depthFunc(512);break;case rfe:e.depthFunc(519);break;case nfe:e.depthFunc(513);break;case iU:e.depthFunc(515);break;case ife:e.depthFunc(514);break;case ofe:e.depthFunc(518);break;case afe:e.depthFunc(516);break;case sfe:e.depthFunc(517);break;default:e.depthFunc(515)}else e.depthFunc(515);Qt=Pt}},setLocked:function(Pt){at=Pt},setClear:function(Pt){Ce!==Pt&&(e.clearDepth(Pt),Ce=Pt)},reset:function(){at=!1,se=null,Qt=null,Ce=null}}}function a(){let at=!1,se=null,Qt=null,Ce=null,Pt=null,Nt=null,ze=null,yn=null,Wi=null;return{setTest:function(Ar){at||(Ar?lt(2960):Kt(2960))},setMask:function(Ar){se!==Ar&&!at&&(e.stencilMask(Ar),se=Ar)},setFunc:function(Ar,Pa,ho){(Qt!==Ar||Ce!==Pa||Pt!==ho)&&(e.stencilFunc(Ar,Pa,ho),Qt=Ar,Ce=Pa,Pt=ho)},setOp:function(Ar,Pa,ho){(Nt!==Ar||ze!==Pa||yn!==ho)&&(e.stencilOp(Ar,Pa,ho),Nt=Ar,ze=Pa,yn=ho)},setLocked:function(Ar){at=Ar},setClear:function(Ar){Wi!==Ar&&(e.clearStencil(Ar),Wi=Ar)},reset:function(){at=!1,se=null,Qt=null,Ce=null,Pt=null,Nt=null,ze=null,yn=null,Wi=null}}}let s=new i,l=new o,c=new a,u={},h={},f=new WeakMap,p=[],d=null,g=!1,_=null,y=null,x=null,b=null,S=null,C=null,P=null,k=!1,O=null,D=null,B=null,I=null,L=null,R=e.getParameter(35661),F=!1,z=0,U=e.getParameter(7938);U.indexOf("WebGL")!==-1?(z=parseFloat(/^WebGL (\d)/.exec(U)[1]),F=z>=1):U.indexOf("OpenGL ES")!==-1&&(z=parseFloat(/^OpenGL ES (\d)/.exec(U)[1]),F=z>=2);let W=null,Z={},rt=e.getParameter(3088),ot=e.getParameter(2978),st=new en().fromArray(rt),St=new en().fromArray(ot);function bt(at,se,Qt){let Ce=new Uint8Array(4),Pt=e.createTexture();e.bindTexture(at,Pt),e.texParameteri(at,10241,9728),e.texParameteri(at,10240,9728);for(let Nt=0;Nt<Qt;Nt++)e.texImage2D(se+Nt,0,6408,1,1,0,6408,5121,Ce);return Pt}let Mt={};Mt[3553]=bt(3553,3553,1),Mt[34067]=bt(34067,34069,6),s.setClear(0,0,0,1),l.setClear(1),c.setClear(0),lt(2929),l.setFunc(iU),ht(!1),wt(Sut),lt(2884),q($d);function lt(at){u[at]!==!0&&(e.enable(at),u[at]=!0)}function Kt(at){u[at]!==!1&&(e.disable(at),u[at]=!1)}function _t(at,se){return h[at]!==se?(e.bindFramebuffer(at,se),h[at]=se,n&&(at===36009&&(h[36160]=se),at===36160&&(h[36009]=se)),!0):!1}function ct(at,se){let Qt=p,Ce=!1;if(at)if(Qt=f.get(se),Qt===void 0&&(Qt=[],f.set(se,Qt)),at.isWebGLMultipleRenderTargets){let Pt=at.texture;if(Qt.length!==Pt.length||Qt[0]!==36064){for(let Nt=0,ze=Pt.length;Nt<ze;Nt++)Qt[Nt]=36064+Nt;Qt.length=Pt.length,Ce=!0}}else Qt[0]!==36064&&(Qt[0]=36064,Ce=!0);else Qt[0]!==1029&&(Qt[0]=1029,Ce=!0);Ce&&(r.isWebGL2?e.drawBuffers(Qt):t.get("WEBGL_draw_buffers").drawBuffersWEBGL(Qt))}function X(at){return d!==at?(e.useProgram(at),d=at,!0):!1}let et={[M1]:32774,[Ghe]:32778,[Whe]:32779};if(n)et[Cut]=32775,et[Aut]=32776;else{let at=t.get("EXT_blend_minmax");at!==null&&(et[Cut]=at.MIN_EXT,et[Aut]=at.MAX_EXT)}let dt={[Yhe]:0,[jhe]:1,[Xhe]:768,[Pht]:770,[tfe]:776,[Jhe]:774,[Khe]:772,[$he]:769,[Iht]:771,[Qhe]:775,[Zhe]:773};function q(at,se,Qt,Ce,Pt,Nt,ze,yn){if(at===$d){g===!0&&(Kt(3042),g=!1);return}if(g===!1&&(lt(3042),g=!0),at!==qhe){if(at!==_||yn!==k){if((y!==M1||S!==M1)&&(e.blendEquation(32774),y=M1,S=M1),yn)switch(at){case V3:e.blendFuncSeparate(1,771,1,771);break;case Mut:e.blendFunc(1,1);break;case Eut:e.blendFuncSeparate(0,769,0,1);break;case Tut:e.blendFuncSeparate(0,768,0,770);break;default:console.error("THREE.WebGLState: Invalid blending: ",at);break}else switch(at){case V3:e.blendFuncSeparate(770,771,1,771);break;case Mut:e.blendFunc(770,1);break;case Eut:e.blendFuncSeparate(0,769,0,1);break;case Tut:e.blendFunc(0,768);break;default:console.error("THREE.WebGLState: Invalid blending: ",at);break}x=null,b=null,C=null,P=null,_=at,k=yn}return}Pt=Pt||se,Nt=Nt||Qt,ze=ze||Ce,(se!==y||Pt!==S)&&(e.blendEquationSeparate(et[se],et[Pt]),y=se,S=Pt),(Qt!==x||Ce!==b||Nt!==C||ze!==P)&&(e.blendFuncSeparate(dt[Qt],dt[Ce],dt[Nt],dt[ze]),x=Qt,b=Ce,C=Nt,P=ze),_=at,k=null}function pt(at,se){at.side===L1?Kt(2884):lt(2884);let Qt=at.side===Ii;se&&(Qt=!Qt),ht(Qt),at.blending===V3&&at.transparent===!1?q($d):q(at.blending,at.blendEquation,at.blendSrc,at.blendDst,at.blendEquationAlpha,at.blendSrcAlpha,at.blendDstAlpha,at.premultipliedAlpha),l.setFunc(at.depthFunc),l.setTest(at.depthTest),l.setMask(at.depthWrite),s.setMask(at.colorWrite);let Ce=at.stencilWrite;c.setTest(Ce),Ce&&(c.setMask(at.stencilWriteMask),c.setFunc(at.stencilFunc,at.stencilRef,at.stencilFuncMask),c.setOp(at.stencilFail,at.stencilZFail,at.stencilZPass)),ie(at.polygonOffset,at.polygonOffsetFactor,at.polygonOffsetUnits),at.alphaToCoverage===!0?lt(32926):Kt(32926)}function ht(at){O!==at&&(at?e.frontFace(2304):e.frontFace(2305),O=at)}function wt(at){at!==Hhe?(lt(2884),at!==D&&(at===Sut?e.cullFace(1029):at===Vhe?e.cullFace(1028):e.cullFace(1032))):Kt(2884),D=at}function kt(at){at!==B&&(F&&e.lineWidth(at),B=at)}function ie(at,se,Qt){at?(lt(32823),(I!==se||L!==Qt)&&(e.polygonOffset(se,Qt),I=se,L=Qt)):Kt(32823)}function ee(at){at?lt(3089):Kt(3089)}function Le(at){at===void 0&&(at=33984+R-1),W!==at&&(e.activeTexture(at),W=at)}function ar(at,se){W===null&&Le();let Qt=Z[W];Qt===void 0&&(Qt={type:void 0,texture:void 0},Z[W]=Qt),(Qt.type!==at||Qt.texture!==se)&&(e.bindTexture(at,se||Mt[at]),Qt.type=at,Qt.texture=se)}function fr(){let at=Z[W];at!==void 0&&at.type!==void 0&&(e.bindTexture(at.type,null),at.type=void 0,at.texture=void 0)}function tt(){try{e.compressedTexImage2D.apply(e,arguments)}catch(at){console.error("THREE.WebGLState:",at)}}function $(){try{e.texSubImage2D.apply(e,arguments)}catch(at){console.error("THREE.WebGLState:",at)}}function It(){try{e.texSubImage3D.apply(e,arguments)}catch(at){console.error("THREE.WebGLState:",at)}}function $t(){try{e.compressedTexSubImage2D.apply(e,arguments)}catch(at){console.error("THREE.WebGLState:",at)}}function he(){try{e.texStorage2D.apply(e,arguments)}catch(at){console.error("THREE.WebGLState:",at)}}function Tt(){try{e.texStorage3D.apply(e,arguments)}catch(at){console.error("THREE.WebGLState:",at)}}function be(){try{e.texImage2D.apply(e,arguments)}catch(at){console.error("THREE.WebGLState:",at)}}function nt(){try{e.texImage3D.apply(e,arguments)}catch(at){console.error("THREE.WebGLState:",at)}}function Ct(at){st.equals(at)===!1&&(e.scissor(at.x,at.y,at.z,at.w),st.copy(at))}function Wt(at){St.equals(at)===!1&&(e.viewport(at.x,at.y,at.z,at.w),St.copy(at))}function fe(){e.disable(3042),e.disable(2884),e.disable(2929),e.disable(32823),e.disable(3089),e.disable(2960),e.disable(32926),e.blendEquation(32774),e.blendFunc(1,0),e.blendFuncSeparate(1,0,1,0),e.colorMask(!0,!0,!0,!0),e.clearColor(0,0,0,0),e.depthMask(!0),e.depthFunc(513),e.clearDepth(1),e.stencilMask(4294967295),e.stencilFunc(519,0,4294967295),e.stencilOp(7680,7680,7680),e.clearStencil(0),e.cullFace(1029),e.frontFace(2305),e.polygonOffset(0,0),e.activeTexture(33984),e.bindFramebuffer(36160,null),n===!0&&(e.bindFramebuffer(36009,null),e.bindFramebuffer(36008,null)),e.useProgram(null),e.lineWidth(1),e.scissor(0,0,e.canvas.width,e.canvas.height),e.viewport(0,0,e.canvas.width,e.canvas.height),u={},W=null,Z={},h={},f=new WeakMap,p=[],d=null,g=!1,_=null,y=null,x=null,b=null,S=null,C=null,P=null,k=!1,O=null,D=null,B=null,I=null,L=null,st.set(0,0,e.canvas.width,e.canvas.height),St.set(0,0,e.canvas.width,e.canvas.height),s.reset(),l.reset(),c.reset()}return{buffers:{color:s,depth:l,stencil:c},enable:lt,disable:Kt,bindFramebuffer:_t,drawBuffers:ct,useProgram:X,setBlending:q,setMaterial:pt,setFlipSided:ht,setCullFace:wt,setLineWidth:kt,setPolygonOffset:ie,setScissorTest:ee,activeTexture:Le,bindTexture:ar,unbindTexture:fr,compressedTexImage2D:tt,texImage2D:be,texImage3D:nt,texStorage2D:he,texStorage3D:Tt,texSubImage2D:$,texSubImage3D:It,compressedTexSubImage2D:$t,scissor:Ct,viewport:Wt,reset:fe}}function Lgr(e,t,r,n,i,o,a){let s=i.isWebGL2,l=i.maxTextures,c=i.maxCubemapSize,u=i.maxTextureSize,h=i.maxSamples,p=t.has("WEBGL_multisampled_render_to_texture")?t.get("WEBGL_multisampled_render_to_texture"):void 0,d=new WeakMap,g,_=!1;try{_=typeof OffscreenCanvas!="undefined"&&new OffscreenCanvas(1,1).getContext("2d")!==null}catch(tt){}function y(tt,$){return _?new OffscreenCanvas(tt,$):t6("canvas")}function x(tt,$,It,$t){let he=1;if((tt.width>$t||tt.height>$t)&&(he=$t/Math.max(tt.width,tt.height)),he<1||$===!0)if(typeof HTMLImageElement!="undefined"&&tt instanceof HTMLImageElement||typeof HTMLCanvasElement!="undefined"&&tt instanceof HTMLCanvasElement||typeof ImageBitmap!="undefined"&&tt instanceof ImageBitmap){let Tt=$?Ffe:Math.floor,be=Tt(he*tt.width),nt=Tt(he*tt.height);g===void 0&&(g=y(be,nt));let Ct=It?y(be,nt):g;return Ct.width=be,Ct.height=nt,Ct.getContext("2d").drawImage(tt,0,0,be,nt),console.warn("THREE.WebGLRenderer: Texture has been resized from ("+tt.width+"x"+tt.height+") to ("+be+"x"+nt+")."),Ct}else return"data"in tt&&console.warn("THREE.WebGLRenderer: Image in DataTexture is too big ("+tt.width+"x"+tt.height+")."),tt;return tt}function b(tt){return Zut(tt.width)&&Zut(tt.height)}function S(tt){return s?!1:tt.wrapS!==Jo||tt.wrapT!==Jo||tt.minFilter!==Li&&tt.minFilter!==ii}function C(tt,$){return tt.generateMipmaps&&$&&tt.minFilter!==Li&&tt.minFilter!==ii}function P(tt){e.generateMipmap(tt)}function k(tt,$,It,$t,he=!1){if(s===!1)return $;if(tt!==null){if(e[tt]!==void 0)return e[tt];console.warn("THREE.WebGLRenderer: Attempt to use non-existing WebGL internal format '"+tt+"'")}let Tt=$;return $===6403&&(It===5126&&(Tt=33326),It===5131&&(Tt=33325),It===5121&&(Tt=33321)),$===33319&&(It===5126&&(Tt=33328),It===5131&&(Tt=33327),It===5121&&(Tt=33323)),$===6408&&(It===5126&&(Tt=34836),It===5131&&(Tt=34842),It===5121&&(Tt=$t===Wn&&he===!1?35907:32856),It===32819&&(Tt=32854),It===32820&&(Tt=32855)),(Tt===33325||Tt===33326||Tt===33327||Tt===33328||Tt===34842||Tt===34836)&&t.get("EXT_color_buffer_float"),Tt}function O(tt,$,It){return C(tt,It)===!0||tt.isFramebufferTexture&&tt.minFilter!==Li&&tt.minFilter!==ii?Math.log2(Math.max($.width,$.height))+1:tt.mipmaps!==void 0&&tt.mipmaps.length>0?tt.mipmaps.length:tt.isCompressedTexture&&Array.isArray(tt.image)?$.mipmaps.length:1}function D(tt){return tt===Li||tt===oU||tt===aU?9728:9729}function B(tt){let $=tt.target;$.removeEventListener("dispose",B),L($),$.isVideoTexture&&d.delete($),a.memory.textures--}function I(tt){let $=tt.target;$.removeEventListener("dispose",I),R($)}function L(tt){let $=n.get(tt);$.__webglInit!==void 0&&(e.deleteTexture($.__webglTexture),n.remove(tt))}function R(tt){let $=tt.texture,It=n.get(tt),$t=n.get($);if(!!tt){if($t.__webglTexture!==void 0&&(e.deleteTexture($t.__webglTexture),a.memory.textures--),tt.depthTexture&&tt.depthTexture.dispose(),tt.isWebGLCubeRenderTarget)for(let he=0;he<6;he++)e.deleteFramebuffer(It.__webglFramebuffer[he]),It.__webglDepthbuffer&&e.deleteRenderbuffer(It.__webglDepthbuffer[he]);else e.deleteFramebuffer(It.__webglFramebuffer),It.__webglDepthbuffer&&e.deleteRenderbuffer(It.__webglDepthbuffer),It.__webglMultisampledFramebuffer&&e.deleteFramebuffer(It.__webglMultisampledFramebuffer),It.__webglColorRenderbuffer&&e.deleteRenderbuffer(It.__webglColorRenderbuffer),It.__webglDepthRenderbuffer&&e.deleteRenderbuffer(It.__webglDepthRenderbuffer);if(tt.isWebGLMultipleRenderTargets)for(let he=0,Tt=$.length;he<Tt;he++){let be=n.get($[he]);be.__webglTexture&&(e.deleteTexture(be.__webglTexture),a.memory.textures--),n.remove($[he])}n.remove($),n.remove(tt)}}let F=0;function z(){F=0}function U(){let tt=F;return tt>=l&&console.warn("THREE.WebGLTextures: Trying to use "+tt+" texture units while this GPU supports only "+l),F+=1,tt}function W(tt,$){let It=n.get(tt);if(tt.isVideoTexture&&kt(tt),tt.version>0&&It.__version!==tt.version){let $t=tt.image;if($t===void 0)console.warn("THREE.WebGLRenderer: Texture marked for update but image is undefined");else if($t.complete===!1)console.warn("THREE.WebGLRenderer: Texture marked for update but image is incomplete");else{lt(It,tt,$);return}}r.activeTexture(33984+$),r.bindTexture(3553,It.__webglTexture)}function Z(tt,$){let It=n.get(tt);if(tt.version>0&&It.__version!==tt.version){lt(It,tt,$);return}r.activeTexture(33984+$),r.bindTexture(35866,It.__webglTexture)}function rt(tt,$){let It=n.get(tt);if(tt.version>0&&It.__version!==tt.version){lt(It,tt,$);return}r.activeTexture(33984+$),r.bindTexture(32879,It.__webglTexture)}function ot(tt,$){let It=n.get(tt);if(tt.version>0&&It.__version!==tt.version){Kt(It,tt,$);return}r.activeTexture(33984+$),r.bindTexture(34067,It.__webglTexture)}let st={[XP]:10497,[Jo]:33071,[$P]:33648},St={[Li]:9728,[oU]:9984,[aU]:9986,[ii]:9729,[Lht]:9985,[ox]:9987};function bt(tt,$,It){if(It?(e.texParameteri(tt,10242,st[$.wrapS]),e.texParameteri(tt,10243,st[$.wrapT]),(tt===32879||tt===35866)&&e.texParameteri(tt,32882,st[$.wrapR]),e.texParameteri(tt,10240,St[$.magFilter]),e.texParameteri(tt,10241,St[$.minFilter])):(e.texParameteri(tt,10242,33071),e.texParameteri(tt,10243,33071),(tt===32879||tt===35866)&&e.texParameteri(tt,32882,33071),($.wrapS!==Jo||$.wrapT!==Jo)&&console.warn("THREE.WebGLRenderer: Texture is not power of two. Texture.wrapS and Texture.wrapT should be set to THREE.ClampToEdgeWrapping."),e.texParameteri(tt,10240,D($.magFilter)),e.texParameteri(tt,10241,D($.minFilter)),$.minFilter!==Li&&$.minFilter!==ii&&console.warn("THREE.WebGLRenderer: Texture is not power of two. Texture.minFilter should be set to THREE.NearestFilter or THREE.LinearFilter.")),t.has("EXT_texture_filter_anisotropic")===!0){let $t=t.get("EXT_texture_filter_anisotropic");if($.type===jd&&t.has("OES_texture_float_linear")===!1||s===!1&&$.type===C1&&t.has("OES_texture_half_float_linear")===!1)return;($.anisotropy>1||n.get($).__currentAnisotropy)&&(e.texParameterf(tt,$t.TEXTURE_MAX_ANISOTROPY_EXT,Math.min($.anisotropy,i.getMaxAnisotropy())),n.get($).__currentAnisotropy=$.anisotropy)}}function Mt(tt,$){tt.__webglInit===void 0&&(tt.__webglInit=!0,$.addEventListener("dispose",B),tt.__webglTexture=e.createTexture(),a.memory.textures++)}function lt(tt,$,It){let $t=3553;$.isDataTexture2DArray&&($t=35866),$.isDataTexture3D&&($t=32879),Mt(tt,$),r.activeTexture(33984+It),r.bindTexture($t,tt.__webglTexture),e.pixelStorei(37440,$.flipY),e.pixelStorei(37441,$.premultiplyAlpha),e.pixelStorei(3317,$.unpackAlignment),e.pixelStorei(37443,0);let he=S($)&&b($.image)===!1,Tt=x($.image,he,!1,u);Tt=ie($,Tt);let be=b(Tt)||s,nt=o.convert($.format,$.encoding),Ct=o.convert($.type),Wt=k($.internalFormat,nt,Ct,$.encoding,$.isVideoTexture);bt($t,$,be);let fe,at=$.mipmaps,se=s&&$.isVideoTexture!==!0,Qt=tt.__version===void 0,Ce=O($,Tt,be);if($.isDepthTexture)Wt=6402,s?$.type===jd?Wt=36012:$.type===VP?Wt=33190:$.type===A1?Wt=35056:Wt=33189:$.type===jd&&console.error("WebGLRenderer: Floating point depth texture requires WebGL2."),$.format===z0&&Wt===6402&&$.type!==G3&&$.type!==VP&&(console.warn("THREE.WebGLRenderer: Use UnsignedShortType or UnsignedIntType for DepthFormat DepthTexture."),$.type=G3,Ct=o.convert($.type)),$.format===k1&&Wt===6402&&(Wt=34041,$.type!==A1&&(console.warn("THREE.WebGLRenderer: Use UnsignedInt248Type for DepthStencilFormat DepthTexture."),$.type=A1,Ct=o.convert($.type))),se&&Qt?r.texStorage2D(3553,1,Wt,Tt.width,Tt.height):r.texImage2D(3553,0,Wt,Tt.width,Tt.height,0,nt,Ct,null);else if($.isDataTexture)if(at.length>0&&be){se&&Qt&&r.texStorage2D(3553,Ce,Wt,at[0].width,at[0].height);for(let Pt=0,Nt=at.length;Pt<Nt;Pt++)fe=at[Pt],se?r.texSubImage2D(3553,0,0,0,fe.width,fe.height,nt,Ct,fe.data):r.texImage2D(3553,Pt,Wt,fe.width,fe.height,0,nt,Ct,fe.data);$.generateMipmaps=!1}else se?(Qt&&r.texStorage2D(3553,Ce,Wt,Tt.width,Tt.height),r.texSubImage2D(3553,0,0,0,Tt.width,Tt.height,nt,Ct,Tt.data)):r.texImage2D(3553,0,Wt,Tt.width,Tt.height,0,nt,Ct,Tt.data);else if($.isCompressedTexture){se&&Qt&&r.texStorage2D(3553,Ce,Wt,at[0].width,at[0].height);for(let Pt=0,Nt=at.length;Pt<Nt;Pt++)fe=at[Pt],$.format!==Qo?nt!==null?se?r.compressedTexSubImage2D(3553,Pt,0,0,fe.width,fe.height,nt,fe.data):r.compressedTexImage2D(3553,Pt,Wt,fe.width,fe.height,0,fe.data):console.warn("THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .uploadTexture()"):se?r.texSubImage2D(3553,Pt,0,0,fe.width,fe.height,nt,Ct,fe.data):r.texImage2D(3553,Pt,Wt,fe.width,fe.height,0,nt,Ct,fe.data)}else if($.isDataTexture2DArray)se?(Qt&&r.texStorage3D(35866,Ce,Wt,Tt.width,Tt.height,Tt.depth),r.texSubImage3D(35866,0,0,0,0,Tt.width,Tt.height,Tt.depth,nt,Ct,Tt.data)):r.texImage3D(35866,0,Wt,Tt.width,Tt.height,Tt.depth,0,nt,Ct,Tt.data);else if($.isDataTexture3D)se?(Qt&&r.texStorage3D(32879,Ce,Wt,Tt.width,Tt.height,Tt.depth),r.texSubImage3D(32879,0,0,0,0,Tt.width,Tt.height,Tt.depth,nt,Ct,Tt.data)):r.texImage3D(32879,0,Wt,Tt.width,Tt.height,Tt.depth,0,nt,Ct,Tt.data);else if($.isFramebufferTexture)se&&Qt?r.texStorage2D(3553,Ce,Wt,Tt.width,Tt.height):r.texImage2D(3553,0,Wt,Tt.width,Tt.height,0,nt,Ct,null);else if(at.length>0&&be){se&&Qt&&r.texStorage2D(3553,Ce,Wt,at[0].width,at[0].height);for(let Pt=0,Nt=at.length;Pt<Nt;Pt++)fe=at[Pt],se?r.texSubImage2D(3553,Pt,0,0,nt,Ct,fe):r.texImage2D(3553,Pt,Wt,nt,Ct,fe);$.generateMipmaps=!1}else se?(Qt&&r.texStorage2D(3553,Ce,Wt,Tt.width,Tt.height),r.texSubImage2D(3553,0,0,0,nt,Ct,Tt)):r.texImage2D(3553,0,Wt,nt,Ct,Tt);C($,be)&&P($t),tt.__version=$.version,$.onUpdate&&$.onUpdate($)}function Kt(tt,$,It){if($.image.length!==6)return;Mt(tt,$),r.activeTexture(33984+It),r.bindTexture(34067,tt.__webglTexture),e.pixelStorei(37440,$.flipY),e.pixelStorei(37441,$.premultiplyAlpha),e.pixelStorei(3317,$.unpackAlignment),e.pixelStorei(37443,0);let $t=$&&($.isCompressedTexture||$.image[0].isCompressedTexture),he=$.image[0]&&$.image[0].isDataTexture,Tt=[];for(let Pt=0;Pt<6;Pt++)!$t&&!he?Tt[Pt]=x($.image[Pt],!1,!0,c):Tt[Pt]=he?$.image[Pt].image:$.image[Pt],Tt[Pt]=ie($,Tt[Pt]);let be=Tt[0],nt=b(be)||s,Ct=o.convert($.format,$.encoding),Wt=o.convert($.type),fe=k($.internalFormat,Ct,Wt,$.encoding),at=s&&$.isVideoTexture!==!0,se=tt.__version===void 0,Qt=O($,be,nt);bt(34067,$,nt);let Ce;if($t){at&&se&&r.texStorage2D(34067,Qt,fe,be.width,be.height);for(let Pt=0;Pt<6;Pt++){Ce=Tt[Pt].mipmaps;for(let Nt=0;Nt<Ce.length;Nt++){let ze=Ce[Nt];$.format!==Qo?Ct!==null?at?r.compressedTexSubImage2D(34069+Pt,Nt,0,0,ze.width,ze.height,Ct,ze.data):r.compressedTexImage2D(34069+Pt,Nt,fe,ze.width,ze.height,0,ze.data):console.warn("THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .setTextureCube()"):at?r.texSubImage2D(34069+Pt,Nt,0,0,ze.width,ze.height,Ct,Wt,ze.data):r.texImage2D(34069+Pt,Nt,fe,ze.width,ze.height,0,Ct,Wt,ze.data)}}}else{Ce=$.mipmaps,at&&se&&(Ce.length>0&&Qt++,r.texStorage2D(34067,Qt,fe,Tt[0].width,Tt[0].height));for(let Pt=0;Pt<6;Pt++)if(he){at?r.texSubImage2D(34069+Pt,0,0,0,Tt[Pt].width,Tt[Pt].height,Ct,Wt,Tt[Pt].data):r.texImage2D(34069+Pt,0,fe,Tt[Pt].width,Tt[Pt].height,0,Ct,Wt,Tt[Pt].data);for(let Nt=0;Nt<Ce.length;Nt++){let yn=Ce[Nt].image[Pt].image;at?r.texSubImage2D(34069+Pt,Nt+1,0,0,yn.width,yn.height,Ct,Wt,yn.data):r.texImage2D(34069+Pt,Nt+1,fe,yn.width,yn.height,0,Ct,Wt,yn.data)}}else{at?r.texSubImage2D(34069+Pt,0,0,0,Ct,Wt,Tt[Pt]):r.texImage2D(34069+Pt,0,fe,Ct,Wt,Tt[Pt]);for(let Nt=0;Nt<Ce.length;Nt++){let ze=Ce[Nt];at?r.texSubImage2D(34069+Pt,Nt+1,0,0,Ct,Wt,ze.image[Pt]):r.texImage2D(34069+Pt,Nt+1,fe,Ct,Wt,ze.image[Pt])}}}C($,nt)&&P(34067),tt.__version=$.version,$.onUpdate&&$.onUpdate($)}function _t(tt,$,It,$t,he){let Tt=o.convert(It.format,It.encoding),be=o.convert(It.type),nt=k(It.internalFormat,Tt,be,It.encoding);n.get($).__hasExternalTextures||(he===32879||he===35866?r.texImage3D(he,0,nt,$.width,$.height,$.depth,0,Tt,be,null):r.texImage2D(he,0,nt,$.width,$.height,0,Tt,be,null)),r.bindFramebuffer(36160,tt),$.useRenderToTexture?p.framebufferTexture2DMultisampleEXT(36160,$t,he,n.get(It).__webglTexture,0,wt($)):e.framebufferTexture2D(36160,$t,he,n.get(It).__webglTexture,0),r.bindFramebuffer(36160,null)}function ct(tt,$,It){if(e.bindRenderbuffer(36161,tt),$.depthBuffer&&!$.stencilBuffer){let $t=33189;if(It||$.useRenderToTexture){let he=$.depthTexture;he&&he.isDepthTexture&&(he.type===jd?$t=36012:he.type===VP&&($t=33190));let Tt=wt($);$.useRenderToTexture?p.renderbufferStorageMultisampleEXT(36161,Tt,$t,$.width,$.height):e.renderbufferStorageMultisample(36161,Tt,$t,$.width,$.height)}else e.renderbufferStorage(36161,$t,$.width,$.height);e.framebufferRenderbuffer(36160,36096,36161,tt)}else if($.depthBuffer&&$.stencilBuffer){let $t=wt($);It&&$.useRenderbuffer?e.renderbufferStorageMultisample(36161,$t,35056,$.width,$.height):$.useRenderToTexture?p.renderbufferStorageMultisampleEXT(36161,$t,35056,$.width,$.height):e.renderbufferStorage(36161,34041,$.width,$.height),e.framebufferRenderbuffer(36160,33306,36161,tt)}else{let $t=$.isWebGLMultipleRenderTargets===!0?$.texture[0]:$.texture,he=o.convert($t.format,$t.encoding),Tt=o.convert($t.type),be=k($t.internalFormat,he,Tt,$t.encoding),nt=wt($);It&&$.useRenderbuffer?e.renderbufferStorageMultisample(36161,nt,be,$.width,$.height):$.useRenderToTexture?p.renderbufferStorageMultisampleEXT(36161,nt,be,$.width,$.height):e.renderbufferStorage(36161,be,$.width,$.height)}e.bindRenderbuffer(36161,null)}function X(tt,$){if($&&$.isWebGLCubeRenderTarget)throw new Error("Depth Texture with cube render targets is not supported");if(r.bindFramebuffer(36160,tt),!($.depthTexture&&$.depthTexture.isDepthTexture))throw new Error("renderTarget.depthTexture must be an instance of THREE.DepthTexture");(!n.get($.depthTexture).__webglTexture||$.depthTexture.image.width!==$.width||$.depthTexture.image.height!==$.height)&&($.depthTexture.image.width=$.width,$.depthTexture.image.height=$.height,$.depthTexture.needsUpdate=!0),W($.depthTexture,0);let $t=n.get($.depthTexture).__webglTexture,he=wt($);if($.depthTexture.format===z0)$.useRenderToTexture?p.framebufferTexture2DMultisampleEXT(36160,36096,3553,$t,0,he):e.framebufferTexture2D(36160,36096,3553,$t,0);else if($.depthTexture.format===k1)$.useRenderToTexture?p.framebufferTexture2DMultisampleEXT(36160,33306,3553,$t,0,he):e.framebufferTexture2D(36160,33306,3553,$t,0);else throw new Error("Unknown depthTexture format")}function et(tt){let $=n.get(tt),It=tt.isWebGLCubeRenderTarget===!0;if(tt.depthTexture&&!$.__autoAllocateDepthBuffer){if(It)throw new Error("target.depthTexture not supported in Cube render targets");X($.__webglFramebuffer,tt)}else if(It){$.__webglDepthbuffer=[];for(let $t=0;$t<6;$t++)r.bindFramebuffer(36160,$.__webglFramebuffer[$t]),$.__webglDepthbuffer[$t]=e.createRenderbuffer(),ct($.__webglDepthbuffer[$t],tt,!1)}else r.bindFramebuffer(36160,$.__webglFramebuffer),$.__webglDepthbuffer=e.createRenderbuffer(),ct($.__webglDepthbuffer,tt,!1);r.bindFramebuffer(36160,null)}function dt(tt,$,It){let $t=n.get(tt);$!==void 0&&_t($t.__webglFramebuffer,tt,tt.texture,36064,3553),It!==void 0&&et(tt)}function q(tt){let $=tt.texture,It=n.get(tt),$t=n.get($);tt.addEventListener("dispose",I),tt.isWebGLMultipleRenderTargets!==!0&&($t.__webglTexture===void 0&&($t.__webglTexture=e.createTexture()),$t.__version=$.version,a.memory.textures++);let he=tt.isWebGLCubeRenderTarget===!0,Tt=tt.isWebGLMultipleRenderTargets===!0,be=$.isDataTexture3D||$.isDataTexture2DArray,nt=b(tt)||s;if(he){It.__webglFramebuffer=[];for(let Ct=0;Ct<6;Ct++)It.__webglFramebuffer[Ct]=e.createFramebuffer()}else if(It.__webglFramebuffer=e.createFramebuffer(),Tt)if(i.drawBuffers){let Ct=tt.texture;for(let Wt=0,fe=Ct.length;Wt<fe;Wt++){let at=n.get(Ct[Wt]);at.__webglTexture===void 0&&(at.__webglTexture=e.createTexture(),a.memory.textures++)}}else console.warn("THREE.WebGLRenderer: WebGLMultipleRenderTargets can only be used with WebGL2 or WEBGL_draw_buffers extension.");else if(tt.useRenderbuffer)if(s){It.__webglMultisampledFramebuffer=e.createFramebuffer(),It.__webglColorRenderbuffer=e.createRenderbuffer(),e.bindRenderbuffer(36161,It.__webglColorRenderbuffer);let Ct=o.convert($.format,$.encoding),Wt=o.convert($.type),fe=k($.internalFormat,Ct,Wt,$.encoding),at=wt(tt);e.renderbufferStorageMultisample(36161,at,fe,tt.width,tt.height),r.bindFramebuffer(36160,It.__webglMultisampledFramebuffer),e.framebufferRenderbuffer(36160,36064,36161,It.__webglColorRenderbuffer),e.bindRenderbuffer(36161,null),tt.depthBuffer&&(It.__webglDepthRenderbuffer=e.createRenderbuffer(),ct(It.__webglDepthRenderbuffer,tt,!0)),r.bindFramebuffer(36160,null)}else console.warn("THREE.WebGLRenderer: WebGLMultisampleRenderTarget can only be used with WebGL2.");if(he){r.bindTexture(34067,$t.__webglTexture),bt(34067,$,nt);for(let Ct=0;Ct<6;Ct++)_t(It.__webglFramebuffer[Ct],tt,$,36064,34069+Ct);C($,nt)&&P(34067),r.unbindTexture()}else if(Tt){let Ct=tt.texture;for(let Wt=0,fe=Ct.length;Wt<fe;Wt++){let at=Ct[Wt],se=n.get(at);r.bindTexture(3553,se.__webglTexture),bt(3553,at,nt),_t(It.__webglFramebuffer,tt,at,36064+Wt,3553),C(at,nt)&&P(3553)}r.unbindTexture()}else{let Ct=3553;be&&(s?Ct=$.isDataTexture3D?32879:35866:console.warn("THREE.DataTexture3D and THREE.DataTexture2DArray only supported with WebGL2.")),r.bindTexture(Ct,$t.__webglTexture),bt(Ct,$,nt),_t(It.__webglFramebuffer,tt,$,36064,Ct),C($,nt)&&P(Ct),r.unbindTexture()}tt.depthBuffer&&et(tt)}function pt(tt){let $=b(tt)||s,It=tt.isWebGLMultipleRenderTargets===!0?tt.texture:[tt.texture];for(let $t=0,he=It.length;$t<he;$t++){let Tt=It[$t];if(C(Tt,$)){let be=tt.isWebGLCubeRenderTarget?34067:3553,nt=n.get(Tt).__webglTexture;r.bindTexture(be,nt),P(be),r.unbindTexture()}}}function ht(tt){if(tt.useRenderbuffer)if(s){let $=tt.width,It=tt.height,$t=16384,he=[36064],Tt=tt.stencilBuffer?33306:36096;tt.depthBuffer&&he.push(Tt),tt.ignoreDepthForMultisampleCopy||(tt.depthBuffer&&($t|=256),tt.stencilBuffer&&($t|=1024));let be=n.get(tt);r.bindFramebuffer(36008,be.__webglMultisampledFramebuffer),r.bindFramebuffer(36009,be.__webglFramebuffer),tt.ignoreDepthForMultisampleCopy&&(e.invalidateFramebuffer(36008,[Tt]),e.invalidateFramebuffer(36009,[Tt])),e.blitFramebuffer(0,0,$,It,0,0,$,It,$t,9728),e.invalidateFramebuffer(36008,he),r.bindFramebuffer(36008,null),r.bindFramebuffer(36009,be.__webglMultisampledFramebuffer)}else console.warn("THREE.WebGLRenderer: WebGLMultisampleRenderTarget can only be used with WebGL2.")}function wt(tt){return s&&(tt.useRenderbuffer||tt.useRenderToTexture)?Math.min(h,tt.samples):0}function kt(tt){let $=a.render.frame;d.get(tt)!==$&&(d.set(tt,$),tt.update())}function ie(tt,$){let It=tt.encoding,$t=tt.format,he=tt.type;return tt.isCompressedTexture===!0||tt.isVideoTexture===!0||tt.format===sU||It!==Qd&&(It===Wn?s===!1?t.has("EXT_sRGB")===!0&&$t===Qo?(tt.format=sU,tt.minFilter=ii,tt.generateMipmaps=!1):$=Kf.sRGBToLinear($):($t!==Qo||he!==Zd)&&console.warn("THREE.WebGLTextures: sRGB encoded textures have to use RGBAFormat and UnsignedByteType."):console.error("THREE.WebGLTextures: Unsupported texture encoding:",It)),$}let ee=!1,Le=!1;function ar(tt,$){tt&&tt.isWebGLRenderTarget&&(ee===!1&&(console.warn("THREE.WebGLTextures.safeSetTexture2D: don't use render targets as textures. Use their .texture property instead."),ee=!0),tt=tt.texture),W(tt,$)}function fr(tt,$){tt&&tt.isWebGLCubeRenderTarget&&(Le===!1&&(console.warn("THREE.WebGLTextures.safeSetTextureCube: don't use cube render targets as textures. Use their .texture property instead."),Le=!0),tt=tt.texture),ot(tt,$)}this.allocateTextureUnit=U,this.resetTextureUnits=z,this.setTexture2D=W,this.setTexture2DArray=Z,this.setTexture3D=rt,this.setTextureCube=ot,this.rebindTextures=dt,this.setupRenderTarget=q,this.updateRenderTargetMipmap=pt,this.updateMultisampleRenderTarget=ht,this.setupDepthRenderbuffer=et,this.setupFrameBufferTexture=_t,this.safeSetTexture2D=ar,this.safeSetTextureCube=fr}function Qfe(e,t,r){let n=r.isWebGL2;function i(o,a=null){let s;if(o===Zd)return 5121;if(o===yfe)return 32819;if(o===vfe)return 32820;if(o===mfe)return 5120;if(o===gfe)return 5122;if(o===G3)return 5123;if(o===_fe)return 5124;if(o===VP)return 5125;if(o===jd)return 5126;if(o===C1)return n?5131:(s=t.get("OES_texture_half_float"),s!==null?s.HALF_FLOAT_OES:null);if(o===xfe)return 6406;if(o===Qo)return 6408;if(o===bfe)return 6409;if(o===wfe)return 6410;if(o===z0)return 6402;if(o===k1)return 34041;if(o===Sfe)return 6403;if(o===sU)return s=t.get("EXT_sRGB"),s!==null?s.SRGB_ALPHA_EXT:null;if(o===Mfe)return 36244;if(o===Efe)return 33319;if(o===Tfe)return 33320;if(o===Cfe)return 36249;if(o===JV||o===QV||o===tU||o===eU)if(a===Wn)if(s=t.get("WEBGL_compressed_texture_s3tc_srgb"),s!==null){if(o===JV)return s.COMPRESSED_SRGB_S3TC_DXT1_EXT;if(o===QV)return s.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT;if(o===tU)return s.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT;if(o===eU)return s.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT}else return null;else if(s=t.get("WEBGL_compressed_texture_s3tc"),s!==null){if(o===JV)return s.COMPRESSED_RGB_S3TC_DXT1_EXT;if(o===QV)return s.COMPRESSED_RGBA_S3TC_DXT1_EXT;if(o===tU)return s.COMPRESSED_RGBA_S3TC_DXT3_EXT;if(o===eU)return s.COMPRESSED_RGBA_S3TC_DXT5_EXT}else return null;if(o===Put||o===Iut||o===Lut||o===kut)if(s=t.get("WEBGL_compressed_texture_pvrtc"),s!==null){if(o===Put)return s.COMPRESSED_RGB_PVRTC_4BPPV1_IMG;if(o===Iut)return s.COMPRESSED_RGB_PVRTC_2BPPV1_IMG;if(o===Lut)return s.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG;if(o===kut)return s.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG}else return null;if(o===Afe)return s=t.get("WEBGL_compressed_texture_etc1"),s!==null?s.COMPRESSED_RGB_ETC1_WEBGL:null;if(o===Rut||o===Nut)if(s=t.get("WEBGL_compressed_texture_etc"),s!==null){if(o===Rut)return a===Wn?s.COMPRESSED_SRGB8_ETC2:s.COMPRESSED_RGB8_ETC2;if(o===Nut)return a===Wn?s.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:s.COMPRESSED_RGBA8_ETC2_EAC}else return null;if(o===Dut||o===Out||o===zut||o===Fut||o===But||o===Hut||o===Vut||o===Uut||o===qut||o===Gut||o===Wut||o===Yut||o===jut||o===Xut)if(s=t.get("WEBGL_compressed_texture_astc"),s!==null){if(o===Dut)return a===Wn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR:s.COMPRESSED_RGBA_ASTC_4x4_KHR;if(o===Out)return a===Wn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR:s.COMPRESSED_RGBA_ASTC_5x4_KHR;if(o===zut)return a===Wn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR:s.COMPRESSED_RGBA_ASTC_5x5_KHR;if(o===Fut)return a===Wn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR:s.COMPRESSED_RGBA_ASTC_6x5_KHR;if(o===But)return a===Wn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR:s.COMPRESSED_RGBA_ASTC_6x6_KHR;if(o===Hut)return a===Wn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR:s.COMPRESSED_RGBA_ASTC_8x5_KHR;if(o===Vut)return a===Wn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR:s.COMPRESSED_RGBA_ASTC_8x6_KHR;if(o===Uut)return a===Wn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR:s.COMPRESSED_RGBA_ASTC_8x8_KHR;if(o===qut)return a===Wn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR:s.COMPRESSED_RGBA_ASTC_10x5_KHR;if(o===Gut)return a===Wn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR:s.COMPRESSED_RGBA_ASTC_10x6_KHR;if(o===Wut)return a===Wn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR:s.COMPRESSED_RGBA_ASTC_10x8_KHR;if(o===Yut)return a===Wn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR:s.COMPRESSED_RGBA_ASTC_10x10_KHR;if(o===jut)return a===Wn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR:s.COMPRESSED_RGBA_ASTC_12x10_KHR;if(o===Xut)return a===Wn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR:s.COMPRESSED_RGBA_ASTC_12x12_KHR}else return null;if(o===$ut)if(s=t.get("EXT_texture_compression_bptc"),s!==null){if(o===$ut)return a===Wn?s.COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT:s.COMPRESSED_RGBA_BPTC_UNORM_EXT}else return null;if(o===A1)return n?34042:(s=t.get("WEBGL_depth_texture"),s!==null?s.UNSIGNED_INT_24_8_WEBGL:null)}return{convert:i}}var n6=class extends Ui{constructor(t=[]){super(),this.cameras=t}};n6.prototype.isArrayCamera=!0;var Xd=class extends or{constructor(){super(),this.type="Group"}};Xd.prototype.isGroup=!0;var kgr={type:"move"},qP=class{constructor(){this._targetRay=null,this._grip=null,this._hand=null}getHandSpace(){return this._hand===null&&(this._hand=new Xd,this._hand.matrixAutoUpdate=!1,this._hand.visible=!1,this._hand.joints={},this._hand.inputState={pinching:!1}),this._hand}getTargetRaySpace(){return this._targetRay===null&&(this._targetRay=new Xd,this._targetRay.matrixAutoUpdate=!1,this._targetRay.visible=!1,this._targetRay.hasLinearVelocity=!1,this._targetRay.linearVelocity=new j,this._targetRay.hasAngularVelocity=!1,this._targetRay.angularVelocity=new j),this._targetRay}getGripSpace(){return this._grip===null&&(this._grip=new Xd,this._grip.matrixAutoUpdate=!1,this._grip.visible=!1,this._grip.hasLinearVelocity=!1,this._grip.linearVelocity=new j,this._grip.hasAngularVelocity=!1,this._grip.angularVelocity=new j),this._grip}dispatchEvent(t){return this._targetRay!==null&&this._targetRay.dispatchEvent(t),this._grip!==null&&this._grip.dispatchEvent(t),this._hand!==null&&this._hand.dispatchEvent(t),this}disconnect(t){return this.dispatchEvent({type:"disconnected",data:t}),this._targetRay!==null&&(this._targetRay.visible=!1),this._grip!==null&&(this._grip.visible=!1),this._hand!==null&&(this._hand.visible=!1),this}update(t,r,n){let i=null,o=null,a=null,s=this._targetRay,l=this._grip,c=this._hand;if(t&&r.session.visibilityState!=="visible-blurred")if(s!==null&&(i=r.getPose(t.targetRaySpace,n),i!==null&&(s.matrix.fromArray(i.transform.matrix),s.matrix.decompose(s.position,s.rotation,s.scale),i.linearVelocity?(s.hasLinearVelocity=!0,s.linearVelocity.copy(i.linearVelocity)):s.hasLinearVelocity=!1,i.angularVelocity?(s.hasAngularVelocity=!0,s.angularVelocity.copy(i.angularVelocity)):s.hasAngularVelocity=!1,this.dispatchEvent(kgr))),c&&t.hand){a=!0;for(let g of t.hand.values()){let _=r.getJointPose(g,n);if(c.joints[g.jointName]===void 0){let x=new Xd;x.matrixAutoUpdate=!1,x.visible=!1,c.joints[g.jointName]=x,c.add(x)}let y=c.joints[g.jointName];_!==null&&(y.matrix.fromArray(_.transform.matrix),y.matrix.decompose(y.position,y.rotation,y.scale),y.jointRadius=_.radius),y.visible=_!==null}let u=c.joints["index-finger-tip"],h=c.joints["thumb-tip"],f=u.position.distanceTo(h.position),p=.02,d=.005;c.inputState.pinching&&f>p+d?(c.inputState.pinching=!1,this.dispatchEvent({type:"pinchend",handedness:t.handedness,target:this})):!c.inputState.pinching&&f<=p-d&&(c.inputState.pinching=!0,this.dispatchEvent({type:"pinchstart",handedness:t.handedness,target:this}))}else l!==null&&t.gripSpace&&(o=r.getPose(t.gripSpace,n),o!==null&&(l.matrix.fromArray(o.transform.matrix),l.matrix.decompose(l.position,l.rotation,l.scale),o.linearVelocity?(l.hasLinearVelocity=!0,l.linearVelocity.copy(o.linearVelocity)):l.hasLinearVelocity=!1,o.angularVelocity?(l.hasAngularVelocity=!0,l.angularVelocity.copy(o.angularVelocity)):l.hasAngularVelocity=!1));return s!==null&&(s.visible=i!==null),l!==null&&(l.visible=o!==null),c!==null&&(c.visible=a!==null),this}},nM=class extends vi{constructor(t,r,n,i,o,a,s,l,c,u){if(u=u!==void 0?u:z0,u!==z0&&u!==k1)throw new Error("DepthTexture format must be either THREE.DepthFormat or THREE.DepthStencilFormat");n===void 0&&u===z0&&(n=G3),n===void 0&&u===k1&&(n=A1),super(null,i,o,a,s,l,u,n,c),this.image={width:t,height:r},this.magFilter=s!==void 0?s:Li,this.minFilter=l!==void 0?l:Li,this.flipY=!1,this.generateMipmaps=!1}};nM.prototype.isDepthTexture=!0;var eht=class extends Us{constructor(t,r){super();let n=this,i=null,o=1,a=null,s="local-floor",l=t.extensions.has("WEBGL_multisampled_render_to_texture"),c=null,u=null,h=null,f=null,p=!1,d=null,g=r.getContextAttributes(),_=null,y=null,x=[],b=new Map,S=new Ui;S.layers.enable(1),S.viewport=new en;let C=new Ui;C.layers.enable(2),C.viewport=new en;let P=[S,C],k=new n6;k.layers.enable(1),k.layers.enable(2);let O=null,D=null;this.cameraAutoUpdate=!0,this.enabled=!1,this.isPresenting=!1,this.getController=function(ot){let st=x[ot];return st===void 0&&(st=new qP,x[ot]=st),st.getTargetRaySpace()},this.getControllerGrip=function(ot){let st=x[ot];return st===void 0&&(st=new qP,x[ot]=st),st.getGripSpace()},this.getHand=function(ot){let st=x[ot];return st===void 0&&(st=new qP,x[ot]=st),st.getHandSpace()};function B(ot){let st=b.get(ot.inputSource);st&&st.dispatchEvent({type:ot.type,data:ot.inputSource})}function I(){b.forEach(function(ot,st){ot.disconnect(st)}),b.clear(),O=null,D=null,t.setRenderTarget(_),f=null,h=null,u=null,i=null,y=null,rt.stop(),n.isPresenting=!1,n.dispatchEvent({type:"sessionend"})}this.setFramebufferScaleFactor=function(ot){o=ot,n.isPresenting===!0&&console.warn("THREE.WebXRManager: Cannot change framebuffer scale while presenting.")},this.setReferenceSpaceType=function(ot){s=ot,n.isPresenting===!0&&console.warn("THREE.WebXRManager: Cannot change reference space type while presenting.")},this.getReferenceSpace=function(){return a},this.getBaseLayer=function(){return h!==null?h:f},this.getBinding=function(){return u},this.getFrame=function(){return d},this.getSession=function(){return i},this.setSession=function(ot){return Ri(this,null,function*(){if(i=ot,i!==null){if(_=t.getRenderTarget(),i.addEventListener("select",B),i.addEventListener("selectstart",B),i.addEventListener("selectend",B),i.addEventListener("squeeze",B),i.addEventListener("squeezestart",B),i.addEventListener("squeezeend",B),i.addEventListener("end",I),i.addEventListener("inputsourceschange",L),g.xrCompatible!==!0&&(yield r.makeXRCompatible()),i.renderState.layers===void 0||t.capabilities.isWebGL2===!1){let st={antialias:i.renderState.layers===void 0?g.antialias:!0,alpha:g.alpha,depth:g.depth,stencil:g.stencil,framebufferScaleFactor:o};f=new XRWebGLLayer(i,r,st),i.updateRenderState({baseLayer:f}),y=new us(f.framebufferWidth,f.framebufferHeight,{format:Qo,type:Zd,encoding:t.outputEncoding})}else{p=g.antialias;let st=null,St=null,bt=null;g.depth&&(bt=g.stencil?35056:33190,st=g.stencil?k1:z0,St=g.stencil?A1:G3);let Mt={colorFormat:t.outputEncoding===Wn?35907:32856,depthFormat:bt,scaleFactor:o};u=new XRWebGLBinding(i,r),h=u.createProjectionLayer(Mt),i.updateRenderState({layers:[h]}),p?y=new j3(h.textureWidth,h.textureHeight,{format:Qo,type:Zd,depthTexture:new nM(h.textureWidth,h.textureHeight,St,void 0,void 0,void 0,void 0,void 0,void 0,st),stencilBuffer:g.stencil,ignoreDepth:h.ignoreDepthValues,useRenderToTexture:l,encoding:t.outputEncoding}):y=new us(h.textureWidth,h.textureHeight,{format:Qo,type:Zd,depthTexture:new nM(h.textureWidth,h.textureHeight,St,void 0,void 0,void 0,void 0,void 0,void 0,st),stencilBuffer:g.stencil,ignoreDepth:h.ignoreDepthValues,encoding:t.outputEncoding})}y.isXRRenderTarget=!0,this.setFoveation(1),a=yield i.requestReferenceSpace(s),rt.setContext(i),rt.start(),n.isPresenting=!0,n.dispatchEvent({type:"sessionstart"})}})};function L(ot){let st=i.inputSources;for(let St=0;St<x.length;St++)b.set(st[St],x[St]);for(let St=0;St<ot.removed.length;St++){let bt=ot.removed[St],Mt=b.get(bt);Mt&&(Mt.dispatchEvent({type:"disconnected",data:bt}),b.delete(bt))}for(let St=0;St<ot.added.length;St++){let bt=ot.added[St],Mt=b.get(bt);Mt&&Mt.dispatchEvent({type:"connected",data:bt})}}let R=new j,F=new j;function z(ot,st,St){R.setFromMatrixPosition(st.matrixWorld),F.setFromMatrixPosition(St.matrixWorld);let bt=R.distanceTo(F),Mt=st.projectionMatrix.elements,lt=St.projectionMatrix.elements,Kt=Mt[14]/(Mt[10]-1),_t=Mt[14]/(Mt[10]+1),ct=(Mt[9]+1)/Mt[5],X=(Mt[9]-1)/Mt[5],et=(Mt[8]-1)/Mt[0],dt=(lt[8]+1)/lt[0],q=Kt*et,pt=Kt*dt,ht=bt/(-et+dt),wt=ht*-et;st.matrixWorld.decompose(ot.position,ot.quaternion,ot.scale),ot.translateX(wt),ot.translateZ(ht),ot.matrixWorld.compose(ot.position,ot.quaternion,ot.scale),ot.matrixWorldInverse.copy(ot.matrixWorld).invert();let kt=Kt+ht,ie=_t+ht,ee=q-wt,Le=pt+(bt-wt),ar=ct*_t/ie*kt,fr=X*_t/ie*kt;ot.projectionMatrix.makePerspective(ee,Le,ar,fr,kt,ie)}function U(ot,st){st===null?ot.matrixWorld.copy(ot.matrix):ot.matrixWorld.multiplyMatrices(st.matrixWorld,ot.matrix),ot.matrixWorldInverse.copy(ot.matrixWorld).invert()}this.updateCamera=function(ot){if(i===null)return;k.near=C.near=S.near=ot.near,k.far=C.far=S.far=ot.far,(O!==k.near||D!==k.far)&&(i.updateRenderState({depthNear:k.near,depthFar:k.far}),O=k.near,D=k.far);let st=ot.parent,St=k.cameras;U(k,st);for(let Mt=0;Mt<St.length;Mt++)U(St[Mt],st);k.matrixWorld.decompose(k.position,k.quaternion,k.scale),ot.position.copy(k.position),ot.quaternion.copy(k.quaternion),ot.scale.copy(k.scale),ot.matrix.copy(k.matrix),ot.matrixWorld.copy(k.matrixWorld);let bt=ot.children;for(let Mt=0,lt=bt.length;Mt<lt;Mt++)bt[Mt].updateMatrixWorld(!0);St.length===2?z(k,S,C):k.projectionMatrix.copy(S.projectionMatrix)},this.getCamera=function(){return k},this.getFoveation=function(){if(h!==null)return h.fixedFoveation;if(f!==null)return f.fixedFoveation},this.setFoveation=function(ot){h!==null&&(h.fixedFoveation=ot),f!==null&&f.fixedFoveation!==void 0&&(f.fixedFoveation=ot)};let W=null;function Z(ot,st){if(c=st.getViewerPose(a),d=st,c!==null){let bt=c.views;f!==null&&(t.setRenderTargetFramebuffer(y,f.framebuffer),t.setRenderTarget(y));let Mt=!1;bt.length!==k.cameras.length&&(k.cameras.length=0,Mt=!0);for(let lt=0;lt<bt.length;lt++){let Kt=bt[lt],_t=null;if(f!==null)_t=f.getViewport(Kt);else{let X=u.getViewSubImage(h,Kt);_t=X.viewport,lt===0&&(t.setRenderTargetTextures(y,X.colorTexture,h.ignoreDepthValues?void 0:X.depthStencilTexture),t.setRenderTarget(y))}let ct=P[lt];ct.matrix.fromArray(Kt.transform.matrix),ct.projectionMatrix.fromArray(Kt.projectionMatrix),ct.viewport.set(_t.x,_t.y,_t.width,_t.height),lt===0&&k.matrix.copy(ct.matrix),Mt===!0&&k.cameras.push(ct)}}let St=i.inputSources;for(let bt=0;bt<x.length;bt++){let Mt=x[bt],lt=St[bt];Mt.update(lt,st,a)}W&&W(ot,st),d=null}let rt=new Ufe;rt.setAnimationLoop(Z),this.setAnimationLoop=function(ot){W=ot},this.dispose=function(){}}};function Rgr(e){function t(y,x){y.fogColor.value.copy(x.color),x.isFog?(y.fogNear.value=x.near,y.fogFar.value=x.far):x.isFogExp2&&(y.fogDensity.value=x.density)}function r(y,x,b,S,C){x.isMeshBasicMaterial?n(y,x):x.isMeshLambertMaterial?(n(y,x),l(y,x)):x.isMeshToonMaterial?(n(y,x),u(y,x)):x.isMeshPhongMaterial?(n(y,x),c(y,x)):x.isMeshStandardMaterial?(n(y,x),x.isMeshPhysicalMaterial?f(y,x,C):h(y,x)):x.isMeshMatcapMaterial?(n(y,x),p(y,x)):x.isMeshDepthMaterial?(n(y,x),d(y,x)):x.isMeshDistanceMaterial?(n(y,x),g(y,x)):x.isMeshNormalMaterial?(n(y,x),_(y,x)):x.isLineBasicMaterial?(i(y,x),x.isLineDashedMaterial&&o(y,x)):x.isPointsMaterial?a(y,x,b,S):x.isSpriteMaterial?s(y,x):x.isShadowMaterial?(y.color.value.copy(x.color),y.opacity.value=x.opacity):x.isShaderMaterial&&(x.uniformsNeedUpdate=!1)}function n(y,x){y.opacity.value=x.opacity,x.color&&y.diffuse.value.copy(x.color),x.emissive&&y.emissive.value.copy(x.emissive).multiplyScalar(x.emissiveIntensity),x.map&&(y.map.value=x.map),x.alphaMap&&(y.alphaMap.value=x.alphaMap),x.specularMap&&(y.specularMap.value=x.specularMap),x.alphaTest>0&&(y.alphaTest.value=x.alphaTest);let b=e.get(x).envMap;b&&(y.envMap.value=b,y.flipEnvMap.value=b.isCubeTexture&&b.isRenderTargetTexture===!1?-1:1,y.reflectivity.value=x.reflectivity,y.ior.value=x.ior,y.refractionRatio.value=x.refractionRatio),x.lightMap&&(y.lightMap.value=x.lightMap,y.lightMapIntensity.value=x.lightMapIntensity),x.aoMap&&(y.aoMap.value=x.aoMap,y.aoMapIntensity.value=x.aoMapIntensity);let S;x.map?S=x.map:x.specularMap?S=x.specularMap:x.displacementMap?S=x.displacementMap:x.normalMap?S=x.normalMap:x.bumpMap?S=x.bumpMap:x.roughnessMap?S=x.roughnessMap:x.metalnessMap?S=x.metalnessMap:x.alphaMap?S=x.alphaMap:x.emissiveMap?S=x.emissiveMap:x.clearcoatMap?S=x.clearcoatMap:x.clearcoatNormalMap?S=x.clearcoatNormalMap:x.clearcoatRoughnessMap?S=x.clearcoatRoughnessMap:x.specularIntensityMap?S=x.specularIntensityMap:x.specularColorMap?S=x.specularColorMap:x.transmissionMap?S=x.transmissionMap:x.thicknessMap?S=x.thicknessMap:x.sheenColorMap?S=x.sheenColorMap:x.sheenRoughnessMap&&(S=x.sheenRoughnessMap),S!==void 0&&(S.isWebGLRenderTarget&&(S=S.texture),S.matrixAutoUpdate===!0&&S.updateMatrix(),y.uvTransform.value.copy(S.matrix));let C;x.aoMap?C=x.aoMap:x.lightMap&&(C=x.lightMap),C!==void 0&&(C.isWebGLRenderTarget&&(C=C.texture),C.matrixAutoUpdate===!0&&C.updateMatrix(),y.uv2Transform.value.copy(C.matrix))}function i(y,x){y.diffuse.value.copy(x.color),y.opacity.value=x.opacity}function o(y,x){y.dashSize.value=x.dashSize,y.totalSize.value=x.dashSize+x.gapSize,y.scale.value=x.scale}function a(y,x,b,S){y.diffuse.value.copy(x.color),y.opacity.value=x.opacity,y.size.value=x.size*b,y.scale.value=S*.5,x.map&&(y.map.value=x.map),x.alphaMap&&(y.alphaMap.value=x.alphaMap),x.alphaTest>0&&(y.alphaTest.value=x.alphaTest);let C;x.map?C=x.map:x.alphaMap&&(C=x.alphaMap),C!==void 0&&(C.matrixAutoUpdate===!0&&C.updateMatrix(),y.uvTransform.value.copy(C.matrix))}function s(y,x){y.diffuse.value.copy(x.color),y.opacity.value=x.opacity,y.rotation.value=x.rotation,x.map&&(y.map.value=x.map),x.alphaMap&&(y.alphaMap.value=x.alphaMap),x.alphaTest>0&&(y.alphaTest.value=x.alphaTest);let b;x.map?b=x.map:x.alphaMap&&(b=x.alphaMap),b!==void 0&&(b.matrixAutoUpdate===!0&&b.updateMatrix(),y.uvTransform.value.copy(b.matrix))}function l(y,x){x.emissiveMap&&(y.emissiveMap.value=x.emissiveMap)}function c(y,x){y.specular.value.copy(x.specular),y.shininess.value=Math.max(x.shininess,1e-4),x.emissiveMap&&(y.emissiveMap.value=x.emissiveMap),x.bumpMap&&(y.bumpMap.value=x.bumpMap,y.bumpScale.value=x.bumpScale,x.side===Ii&&(y.bumpScale.value*=-1)),x.normalMap&&(y.normalMap.value=x.normalMap,y.normalScale.value.copy(x.normalScale),x.side===Ii&&y.normalScale.value.negate()),x.displacementMap&&(y.displacementMap.value=x.displacementMap,y.displacementScale.value=x.displacementScale,y.displacementBias.value=x.displacementBias)}function u(y,x){x.gradientMap&&(y.gradientMap.value=x.gradientMap),x.emissiveMap&&(y.emissiveMap.value=x.emissiveMap),x.bumpMap&&(y.bumpMap.value=x.bumpMap,y.bumpScale.value=x.bumpScale,x.side===Ii&&(y.bumpScale.value*=-1)),x.normalMap&&(y.normalMap.value=x.normalMap,y.normalScale.value.copy(x.normalScale),x.side===Ii&&y.normalScale.value.negate()),x.displacementMap&&(y.displacementMap.value=x.displacementMap,y.displacementScale.value=x.displacementScale,y.displacementBias.value=x.displacementBias)}function h(y,x){y.roughness.value=x.roughness,y.metalness.value=x.metalness,x.roughnessMap&&(y.roughnessMap.value=x.roughnessMap),x.metalnessMap&&(y.metalnessMap.value=x.metalnessMap),x.emissiveMap&&(y.emissiveMap.value=x.emissiveMap),x.bumpMap&&(y.bumpMap.value=x.bumpMap,y.bumpScale.value=x.bumpScale,x.side===Ii&&(y.bumpScale.value*=-1)),x.normalMap&&(y.normalMap.value=x.normalMap,y.normalScale.value.copy(x.normalScale),x.side===Ii&&y.normalScale.value.negate()),x.displacementMap&&(y.displacementMap.value=x.displacementMap,y.displacementScale.value=x.displacementScale,y.displacementBias.value=x.displacementBias),e.get(x).envMap&&(y.envMapIntensity.value=x.envMapIntensity)}function f(y,x,b){h(y,x),y.ior.value=x.ior,x.sheen>0&&(y.sheenColor.value.copy(x.sheenColor).multiplyScalar(x.sheen),y.sheenRoughness.value=x.sheenRoughness,x.sheenColorMap&&(y.sheenColorMap.value=x.sheenColorMap),x.sheenRoughnessMap&&(y.sheenRoughnessMap.value=x.sheenRoughnessMap)),x.clearcoat>0&&(y.clearcoat.value=x.clearcoat,y.clearcoatRoughness.value=x.clearcoatRoughness,x.clearcoatMap&&(y.clearcoatMap.value=x.clearcoatMap),x.clearcoatRoughnessMap&&(y.clearcoatRoughnessMap.value=x.clearcoatRoughnessMap),x.clearcoatNormalMap&&(y.clearcoatNormalScale.value.copy(x.clearcoatNormalScale),y.clearcoatNormalMap.value=x.clearcoatNormalMap,x.side===Ii&&y.clearcoatNormalScale.value.negate())),x.transmission>0&&(y.transmission.value=x.transmission,y.transmissionSamplerMap.value=b.texture,y.transmissionSamplerSize.value.set(b.width,b.height),x.transmissionMap&&(y.transmissionMap.value=x.transmissionMap),y.thickness.value=x.thickness,x.thicknessMap&&(y.thicknessMap.value=x.thicknessMap),y.attenuationDistance.value=x.attenuationDistance,y.attenuationColor.value.copy(x.attenuationColor)),y.specularIntensity.value=x.specularIntensity,y.specularColor.value.copy(x.specularColor),x.specularIntensityMap&&(y.specularIntensityMap.value=x.specularIntensityMap),x.specularColorMap&&(y.specularColorMap.value=x.specularColorMap)}function p(y,x){x.matcap&&(y.matcap.value=x.matcap),x.bumpMap&&(y.bumpMap.value=x.bumpMap,y.bumpScale.value=x.bumpScale,x.side===Ii&&(y.bumpScale.value*=-1)),x.normalMap&&(y.normalMap.value=x.normalMap,y.normalScale.value.copy(x.normalScale),x.side===Ii&&y.normalScale.value.negate()),x.displacementMap&&(y.displacementMap.value=x.displacementMap,y.displacementScale.value=x.displacementScale,y.displacementBias.value=x.displacementBias)}function d(y,x){x.displacementMap&&(y.displacementMap.value=x.displacementMap,y.displacementScale.value=x.displacementScale,y.displacementBias.value=x.displacementBias)}function g(y,x){x.displacementMap&&(y.displacementMap.value=x.displacementMap,y.displacementScale.value=x.displacementScale,y.displacementBias.value=x.displacementBias),y.referencePosition.value.copy(x.referencePosition),y.nearDistance.value=x.nearDistance,y.farDistance.value=x.farDistance}function _(y,x){x.bumpMap&&(y.bumpMap.value=x.bumpMap,y.bumpScale.value=x.bumpScale,x.side===Ii&&(y.bumpScale.value*=-1)),x.normalMap&&(y.normalMap.value=x.normalMap,y.normalScale.value.copy(x.normalScale),x.side===Ii&&y.normalScale.value.negate()),x.displacementMap&&(y.displacementMap.value=x.displacementMap,y.displacementScale.value=x.displacementScale,y.displacementBias.value=x.displacementBias)}return{refreshFogUniforms:t,refreshMaterialUniforms:r}}function Ngr(){let e=t6("canvas");return e.style.display="block",e}function rn(e={}){let t=e.canvas!==void 0?e.canvas:Ngr(),r=e.context!==void 0?e.context:null,n=e.alpha!==void 0?e.alpha:!1,i=e.depth!==void 0?e.depth:!0,o=e.stencil!==void 0?e.stencil:!0,a=e.antialias!==void 0?e.antialias:!1,s=e.premultipliedAlpha!==void 0?e.premultipliedAlpha:!0,l=e.preserveDrawingBuffer!==void 0?e.preserveDrawingBuffer:!1,c=e.powerPreference!==void 0?e.powerPreference:"default",u=e.failIfMajorPerformanceCaveat!==void 0?e.failIfMajorPerformanceCaveat:!1,h=null,f=null,p=[],d=[];this.domElement=t,this.debug={checkShaderErrors:!0},this.autoClear=!0,this.autoClearColor=!0,this.autoClearDepth=!0,this.autoClearStencil=!0,this.sortObjects=!0,this.clippingPlanes=[],this.localClippingEnabled=!1,this.outputEncoding=Qd,this.physicallyCorrectLights=!1,this.toneMapping=Kd,this.toneMappingExposure=1;let g=this,_=!1,y=0,x=0,b=null,S=-1,C=null,P=new en,k=new en,O=null,D=t.width,B=t.height,I=1,L=null,R=null,F=new en(0,0,D,B),z=new en(0,0,D,B),U=!1,W=new N1,Z=!1,rt=!1,ot=null,st=new Me,St=new j,bt={background:null,fog:null,environment:null,overrideMaterial:null,isScene:!0};function Mt(){return b===null?I:1}let lt=r;function Kt(K,gt){for(let Et=0;Et<K.length;Et++){let xt=K[Et],Ft=t.getContext(xt,gt);if(Ft!==null)return Ft}return null}try{let K={alpha:!0,depth:i,stencil:o,antialias:a,premultipliedAlpha:s,preserveDrawingBuffer:l,powerPreference:c,failIfMajorPerformanceCaveat:u};if("setAttribute"in t&&t.setAttribute("data-engine",`three.js r${jU}`),t.addEventListener("webglcontextlost",fe,!1),t.addEventListener("webglcontextrestored",at,!1),lt===null){let gt=["webgl2","webgl","experimental-webgl"];if(g.isWebGL1Renderer===!0&&gt.shift(),lt=Kt(gt,K),lt===null)throw Kt(gt)?new Error("Error creating WebGL context with your selected attributes."):new Error("Error creating WebGL context.")}lt.getShaderPrecisionFormat===void 0&&(lt.getShaderPrecisionFormat=function(){return{rangeMin:1,rangeMax:1,precision:1}})}catch(K){throw console.error("THREE.WebGLRenderer: "+K.message),K}let _t,ct,X,et,dt,q,pt,ht,wt,kt,ie,ee,Le,ar,fr,tt,$,It,$t,he,Tt,be,nt;function Ct(){_t=new nmr(lt),ct=new Zdr(lt,_t,e),_t.init(ct),be=new Qfe(lt,_t,ct),X=new Igr(lt,_t,ct),et=new amr(lt),dt=new vgr,q=new Lgr(lt,_t,X,dt,ct,be,et),pt=new Qdr(g),ht=new rmr(g),wt=new bfr(lt,ct),nt=new $dr(lt,_t,wt,ct),kt=new imr(lt,wt,et,nt),ie=new umr(lt,kt,wt,et),$t=new cmr(lt,ct,q),tt=new Jdr(dt),ee=new ygr(g,pt,ht,_t,ct,nt,tt),Le=new Rgr(dt),ar=new bgr,fr=new Cgr(_t,ct),It=new Xdr(g,pt,X,ie,n,s),$=new Jfe(g,ie,ct),he=new Kdr(lt,_t,et,ct),Tt=new omr(lt,_t,et,ct),et.programs=ee.programs,g.capabilities=ct,g.extensions=_t,g.properties=dt,g.renderLists=ar,g.shadowMap=$,g.state=X,g.info=et}Ct();let Wt=new eht(g,lt);this.xr=Wt,this.getContext=function(){return lt},this.getContextAttributes=function(){return lt.getContextAttributes()},this.forceContextLoss=function(){let K=_t.get("WEBGL_lose_context");K&&K.loseContext()},this.forceContextRestore=function(){let K=_t.get("WEBGL_lose_context");K&&K.restoreContext()},this.getPixelRatio=function(){return I},this.setPixelRatio=function(K){K!==void 0&&(I=K,this.setSize(D,B,!1))},this.getSize=function(K){return K.set(D,B)},this.setSize=function(K,gt,Et){if(Wt.isPresenting){console.warn("THREE.WebGLRenderer: Can't change size while VR device is presenting.");return}D=K,B=gt,t.width=Math.floor(K*I),t.height=Math.floor(gt*I),Et!==!1&&(t.style.width=K+"px",t.style.height=gt+"px"),this.setViewport(0,0,K,gt)},this.getDrawingBufferSize=function(K){return K.set(D*I,B*I).floor()},this.setDrawingBufferSize=function(K,gt,Et){D=K,B=gt,I=Et,t.width=Math.floor(K*Et),t.height=Math.floor(gt*Et),this.setViewport(0,0,K,gt)},this.getCurrentViewport=function(K){return K.copy(P)},this.getViewport=function(K){return K.copy(F)},this.setViewport=function(K,gt,Et,xt){K.isVector4?F.set(K.x,K.y,K.z,K.w):F.set(K,gt,Et,xt),X.viewport(P.copy(F).multiplyScalar(I).floor())},this.getScissor=function(K){return K.copy(z)},this.setScissor=function(K,gt,Et,xt){K.isVector4?z.set(K.x,K.y,K.z,K.w):z.set(K,gt,Et,xt),X.scissor(k.copy(z).multiplyScalar(I).floor())},this.getScissorTest=function(){return U},this.setScissorTest=function(K){X.setScissorTest(U=K)},this.setOpaqueSort=function(K){L=K},this.setTransparentSort=function(K){R=K},this.getClearColor=function(K){return K.copy(It.getClearColor())},this.setClearColor=function(){It.setClearColor.apply(It,arguments)},this.getClearAlpha=function(){return It.getClearAlpha()},this.setClearAlpha=function(){It.setClearAlpha.apply(It,arguments)},this.clear=function(K,gt,Et){let xt=0;(K===void 0||K)&&(xt|=16384),(gt===void 0||gt)&&(xt|=256),(Et===void 0||Et)&&(xt|=1024),lt.clear(xt)},this.clearColor=function(){this.clear(!0,!1,!1)},this.clearDepth=function(){this.clear(!1,!0,!1)},this.clearStencil=function(){this.clear(!1,!1,!0)},this.dispose=function(){t.removeEventListener("webglcontextlost",fe,!1),t.removeEventListener("webglcontextrestored",at,!1),ar.dispose(),fr.dispose(),dt.dispose(),pt.dispose(),ht.dispose(),ie.dispose(),nt.dispose(),ee.dispose(),Wt.dispose(),Wt.removeEventListener("sessionstart",ze),Wt.removeEventListener("sessionend",yn),ot&&(ot.dispose(),ot=null),Wi.stop()};function fe(K){K.preventDefault(),console.log("THREE.WebGLRenderer: Context Lost."),_=!0}function at(){console.log("THREE.WebGLRenderer: Context Restored."),_=!1;let K=et.autoReset,gt=$.enabled,Et=$.autoUpdate,xt=$.needsUpdate,Ft=$.type;Ct(),et.autoReset=K,$.enabled=gt,$.autoUpdate=Et,$.needsUpdate=xt,$.type=Ft}function se(K){let gt=K.target;gt.removeEventListener("dispose",se),Qt(gt)}function Qt(K){Ce(K),dt.remove(K)}function Ce(K){let gt=dt.get(K).programs;gt!==void 0&&(gt.forEach(function(Et){ee.releaseProgram(Et)}),K.isShaderMaterial&&ee.releaseShaderCache(K))}this.renderBufferDirect=function(K,gt,Et,xt,Ft,Ve){gt===null&&(gt=bt);let Ue=Ft.isMesh&&Ft.matrixWorld.determinant()<0,tr=cn(K,gt,Et,xt,Ft);X.setMaterial(xt,Ue);let Ke=Et.index,Xr=Et.attributes.position;if(Ke===null){if(Xr===void 0||Xr.count===0)return}else if(Ke.count===0)return;let _r=1;xt.wireframe===!0&&(Ke=kt.getWireframeAttribute(Et),_r=2),nt.setup(Ft,xt,tr,Et,Ke);let Pr,jn=he;Ke!==null&&(Pr=wt.get(Ke),jn=Tt,jn.setIndex(Pr));let np=Ke!==null?Ke.count:Xr.count,um=Et.drawRange.start*_r,mr=Et.drawRange.count*_r,Fl=Ve!==null?Ve.start*_r:0,Xn=Ve!==null?Ve.count*_r:1/0,Bl=Math.max(um,Fl),ux=Math.min(np,um+mr,Fl+Xn)-1,Hl=Math.max(0,ux-Bl+1);if(Hl!==0){if(Ft.isMesh)xt.wireframe===!0?(X.setLineWidth(xt.wireframeLinewidth*Mt()),jn.setMode(1)):jn.setMode(4);else if(Ft.isLine){let Vl=xt.linewidth;Vl===void 0&&(Vl=1),X.setLineWidth(Vl*Mt()),Ft.isLineSegments?jn.setMode(1):Ft.isLineLoop?jn.setMode(2):jn.setMode(3)}else Ft.isPoints?jn.setMode(0):Ft.isSprite&&jn.setMode(4);if(Ft.isInstancedMesh)jn.renderInstances(Bl,Hl,Ft.count);else if(Et.isInstancedBufferGeometry){let Vl=Math.min(Et.instanceCount,Et._maxInstanceCount);jn.renderInstances(Bl,Hl,Vl)}else jn.render(Bl,Hl)}},this.compile=function(K,gt){f=fr.get(K),f.init(),d.push(f),K.traverseVisible(function(Et){Et.isLight&&Et.layers.test(gt.layers)&&(f.pushLight(Et),Et.castShadow&&f.pushShadow(Et))}),f.setupLights(g.physicallyCorrectLights),K.traverse(function(Et){let xt=Et.material;if(xt)if(Array.isArray(xt))for(let Ft=0;Ft<xt.length;Ft++){let Ve=xt[Ft];cm(Ve,K,Et)}else cm(xt,K,Et)}),d.pop(),f=null};let Pt=null;function Nt(K){Pt&&Pt(K)}function ze(){Wi.stop()}function yn(){Wi.start()}let Wi=new Ufe;Wi.setAnimationLoop(Nt),typeof window!="undefined"&&Wi.setContext(window),this.setAnimationLoop=function(K){Pt=K,Wt.setAnimationLoop(K),K===null?Wi.stop():Wi.start()},Wt.addEventListener("sessionstart",ze),Wt.addEventListener("sessionend",yn),this.render=function(K,gt){if(gt!==void 0&&gt.isCamera!==!0){console.error("THREE.WebGLRenderer.render: camera is not an instance of THREE.Camera.");return}if(_===!0)return;K.autoUpdate===!0&&K.updateMatrixWorld(),gt.parent===null&&gt.updateMatrixWorld(),Wt.enabled===!0&&Wt.isPresenting===!0&&(Wt.cameraAutoUpdate===!0&&Wt.updateCamera(gt),gt=Wt.getCamera()),K.isScene===!0&&K.onBeforeRender(g,K,gt,b),f=fr.get(K,d.length),f.init(),d.push(f),st.multiplyMatrices(gt.projectionMatrix,gt.matrixWorldInverse),W.setFromProjectionMatrix(st),rt=this.localClippingEnabled,Z=tt.init(this.clippingPlanes,rt,gt),h=ar.get(K,p.length),h.init(),p.push(h),Ar(K,gt,0,g.sortObjects),h.finish(),g.sortObjects===!0&&h.sort(L,R),Z===!0&&tt.beginShadows();let Et=f.state.shadowsArray;if($.render(Et,K,gt),Z===!0&&tt.endShadows(),this.info.autoReset===!0&&this.info.reset(),It.render(h,K),f.setupLights(g.physicallyCorrectLights),gt.isArrayCamera){let xt=gt.cameras;for(let Ft=0,Ve=xt.length;Ft<Ve;Ft++){let Ue=xt[Ft];Pa(h,K,Ue,Ue.viewport)}}else Pa(h,K,gt);b!==null&&(q.updateMultisampleRenderTarget(b),q.updateRenderTargetMipmap(b)),K.isScene===!0&&K.onAfterRender(g,K,gt),X.buffers.depth.setTest(!0),X.buffers.depth.setMask(!0),X.buffers.color.setMask(!0),X.setPolygonOffset(!1),nt.resetDefaultState(),S=-1,C=null,d.pop(),d.length>0?f=d[d.length-1]:f=null,p.pop(),p.length>0?h=p[p.length-1]:h=null};function Ar(K,gt,Et,xt){if(K.visible===!1)return;if(K.layers.test(gt.layers)){if(K.isGroup)Et=K.renderOrder;else if(K.isLOD)K.autoUpdate===!0&&K.update(gt);else if(K.isLight)f.pushLight(K),K.castShadow&&f.pushShadow(K);else if(K.isSprite){if(!K.frustumCulled||W.intersectsSprite(K)){xt&&St.setFromMatrixPosition(K.matrixWorld).applyMatrix4(st);let Ue=ie.update(K),tr=K.material;tr.visible&&h.push(K,Ue,tr,Et,St.z,null)}}else if((K.isMesh||K.isLine||K.isPoints)&&(K.isSkinnedMesh&&K.skeleton.frame!==et.render.frame&&(K.skeleton.update(),K.skeleton.frame=et.render.frame),!K.frustumCulled||W.intersectsObject(K))){xt&&St.setFromMatrixPosition(K.matrixWorld).applyMatrix4(st);let Ue=ie.update(K),tr=K.material;if(Array.isArray(tr)){let Ke=Ue.groups;for(let Xr=0,_r=Ke.length;Xr<_r;Xr++){let Pr=Ke[Xr],jn=tr[Pr.materialIndex];jn&&jn.visible&&h.push(K,Ue,jn,Et,St.z,Pr)}}else tr.visible&&h.push(K,Ue,tr,Et,St.z,null)}}let Ve=K.children;for(let Ue=0,tr=Ve.length;Ue<tr;Ue++)Ar(Ve[Ue],gt,Et,xt)}function Pa(K,gt,Et,xt){let Ft=K.opaque,Ve=K.transmissive,Ue=K.transparent;f.setupLightsView(Et),Ve.length>0&&ho(Ft,gt,Et),xt&&X.viewport(P.copy(xt)),Ft.length>0&&Ia(Ft,gt,Et),Ve.length>0&&Ia(Ve,gt,Et),Ue.length>0&&Ia(Ue,gt,Et)}function ho(K,gt,Et){if(ot===null){let Ue=a===!0&&ct.isWebGL2===!0?j3:us;ot=new Ue(1024,1024,{generateMipmaps:!0,type:be.convert(C1)!==null?C1:Zd,minFilter:ox,magFilter:Li,wrapS:Jo,wrapT:Jo,useRenderToTexture:_t.has("WEBGL_multisampled_render_to_texture")})}let xt=g.getRenderTarget();g.setRenderTarget(ot),g.clear();let Ft=g.toneMapping;g.toneMapping=Kd,Ia(K,gt,Et),g.toneMapping=Ft,q.updateMultisampleRenderTarget(ot),q.updateRenderTargetMipmap(ot),g.setRenderTarget(xt)}function Ia(K,gt,Et){let xt=gt.isScene===!0?gt.overrideMaterial:null;for(let Ft=0,Ve=K.length;Ft<Ve;Ft++){let Ue=K[Ft],tr=Ue.object,Ke=Ue.geometry,Xr=xt===null?Ue.material:xt,_r=Ue.group;tr.layers.test(Et.layers)&&lx(tr,gt,Et,Ke,Xr,_r)}}function lx(K,gt,Et,xt,Ft,Ve){K.onBeforeRender(g,gt,Et,xt,Ft,Ve),K.modelViewMatrix.multiplyMatrices(Et.matrixWorldInverse,K.matrixWorld),K.normalMatrix.getNormalMatrix(K.modelViewMatrix),Ft.onBeforeRender(g,gt,Et,xt,K,Ve),Ft.transparent===!0&&Ft.side===L1?(Ft.side=Ii,Ft.needsUpdate=!0,g.renderBufferDirect(Et,gt,xt,Ft,K,Ve),Ft.side=I1,Ft.needsUpdate=!0,g.renderBufferDirect(Et,gt,xt,Ft,K,Ve),Ft.side=L1):g.renderBufferDirect(Et,gt,xt,Ft,K,Ve),K.onAfterRender(g,gt,Et,xt,Ft,Ve)}function cm(K,gt,Et){gt.isScene!==!0&&(gt=bt);let xt=dt.get(K),Ft=f.state.lights,Ve=f.state.shadowsArray,Ue=Ft.state.version,tr=ee.getParameters(K,Ft.state,Ve,gt,Et),Ke=ee.getProgramCacheKey(tr),Xr=xt.programs;xt.environment=K.isMeshStandardMaterial?gt.environment:null,xt.fog=gt.fog,xt.envMap=(K.isMeshStandardMaterial?ht:pt).get(K.envMap||xt.environment),Xr===void 0&&(K.addEventListener("dispose",se),Xr=new Map,xt.programs=Xr);let _r=Xr.get(Ke);if(_r!==void 0){if(xt.currentProgram===_r&&xt.lightsStateVersion===Ue)return J0(K,tr),_r}else tr.uniforms=ee.getUniforms(K),K.onBuild(Et,tr,g),K.onBeforeCompile(tr,g),_r=ee.acquireProgram(tr,Ke),Xr.set(Ke,_r),xt.uniforms=tr.uniforms;let Pr=xt.uniforms;(!K.isShaderMaterial&&!K.isRawShaderMaterial||K.clipping===!0)&&(Pr.clippingPlanes=tt.uniform),J0(K,tr),xt.needsLights=rp(K),xt.lightsStateVersion=Ue,xt.needsLights&&(Pr.ambientLightColor.value=Ft.state.ambient,Pr.lightProbe.value=Ft.state.probe,Pr.directionalLights.value=Ft.state.directional,Pr.directionalLightShadows.value=Ft.state.directionalShadow,Pr.spotLights.value=Ft.state.spot,Pr.spotLightShadows.value=Ft.state.spotShadow,Pr.rectAreaLights.value=Ft.state.rectArea,Pr.ltc_1.value=Ft.state.rectAreaLTC1,Pr.ltc_2.value=Ft.state.rectAreaLTC2,Pr.pointLights.value=Ft.state.point,Pr.pointLightShadows.value=Ft.state.pointShadow,Pr.hemisphereLights.value=Ft.state.hemi,Pr.directionalShadowMap.value=Ft.state.directionalShadowMap,Pr.directionalShadowMatrix.value=Ft.state.directionalShadowMatrix,Pr.spotShadowMap.value=Ft.state.spotShadowMap,Pr.spotShadowMatrix.value=Ft.state.spotShadowMatrix,Pr.pointShadowMap.value=Ft.state.pointShadowMap,Pr.pointShadowMatrix.value=Ft.state.pointShadowMatrix);let jn=_r.getUniforms(),np=B0.seqWithValue(jn.seq,Pr);return xt.currentProgram=_r,xt.uniformsList=np,_r}function J0(K,gt){let Et=dt.get(K);Et.outputEncoding=gt.outputEncoding,Et.instancing=gt.instancing,Et.skinning=gt.skinning,Et.morphTargets=gt.morphTargets,Et.morphNormals=gt.morphNormals,Et.morphTargetsCount=gt.morphTargetsCount,Et.numClippingPlanes=gt.numClippingPlanes,Et.numIntersection=gt.numClipIntersection,Et.vertexAlphas=gt.vertexAlphas,Et.vertexTangents=gt.vertexTangents,Et.toneMapping=gt.toneMapping}function cn(K,gt,Et,xt,Ft){gt.isScene!==!0&&(gt=bt),q.resetTextureUnits();let Ve=gt.fog,Ue=xt.isMeshStandardMaterial?gt.environment:null,tr=b===null?g.outputEncoding:b.isXRRenderTarget===!0?b.texture.encoding:Qd,Ke=(xt.isMeshStandardMaterial?ht:pt).get(xt.envMap||Ue),Xr=xt.vertexColors===!0&&!!Et.attributes.color&&Et.attributes.color.itemSize===4,_r=!!xt.normalMap&&!!Et.attributes.tangent,Pr=!!Et.morphAttributes.position,jn=!!Et.morphAttributes.normal,np=Et.morphAttributes.position?Et.morphAttributes.position.length:0,um=xt.toneMapped?g.toneMapping:Kd,mr=dt.get(xt),Fl=f.state.lights;if(Z===!0&&(rt===!0||K!==C)){let qs=K===C&&xt.id===S;tt.setState(xt,K,qs)}let Xn=!1;xt.version===mr.__version?(mr.needsLights&&mr.lightsStateVersion!==Fl.state.version||mr.outputEncoding!==tr||Ft.isInstancedMesh&&mr.instancing===!1||!Ft.isInstancedMesh&&mr.instancing===!0||Ft.isSkinnedMesh&&mr.skinning===!1||!Ft.isSkinnedMesh&&mr.skinning===!0||mr.envMap!==Ke||xt.fog&&mr.fog!==Ve||mr.numClippingPlanes!==void 0&&(mr.numClippingPlanes!==tt.numPlanes||mr.numIntersection!==tt.numIntersection)||mr.vertexAlphas!==Xr||mr.vertexTangents!==_r||mr.morphTargets!==Pr||mr.morphNormals!==jn||mr.toneMapping!==um||ct.isWebGL2===!0&&mr.morphTargetsCount!==np)&&(Xn=!0):(Xn=!0,mr.__version=xt.version);let Bl=mr.currentProgram;Xn===!0&&(Bl=cm(xt,gt,Ft));let ux=!1,Hl=!1,Vl=!1,Yi=Bl.getUniforms(),hm=mr.uniforms;if(X.useProgram(Bl.program)&&(ux=!0,Hl=!0,Vl=!0),xt.id!==S&&(S=xt.id,Hl=!0),ux||C!==K){if(Yi.setValue(lt,"projectionMatrix",K.projectionMatrix),ct.logarithmicDepthBuffer&&Yi.setValue(lt,"logDepthBufFC",2/(Math.log(K.far+1)/Math.LN2)),C!==K&&(C=K,Hl=!0,Vl=!0),xt.isShaderMaterial||xt.isMeshPhongMaterial||xt.isMeshToonMaterial||xt.isMeshStandardMaterial||xt.envMap){let qs=Yi.map.cameraPosition;qs!==void 0&&qs.setValue(lt,St.setFromMatrixPosition(K.matrixWorld))}(xt.isMeshPhongMaterial||xt.isMeshToonMaterial||xt.isMeshLambertMaterial||xt.isMeshBasicMaterial||xt.isMeshStandardMaterial||xt.isShaderMaterial)&&Yi.setValue(lt,"isOrthographic",K.isOrthographicCamera===!0),(xt.isMeshPhongMaterial||xt.isMeshToonMaterial||xt.isMeshLambertMaterial||xt.isMeshBasicMaterial||xt.isMeshStandardMaterial||xt.isShaderMaterial||xt.isShadowMaterial||Ft.isSkinnedMesh)&&Yi.setValue(lt,"viewMatrix",K.matrixWorldInverse)}if(Ft.isSkinnedMesh){Yi.setOptional(lt,Ft,"bindMatrix"),Yi.setOptional(lt,Ft,"bindMatrixInverse");let qs=Ft.skeleton;qs&&(ct.floatVertexTextures?(qs.boneTexture===null&&qs.computeBoneTexture(),Yi.setValue(lt,"boneTexture",qs.boneTexture,q),Yi.setValue(lt,"boneTextureSize",qs.boneTextureSize)):Yi.setOptional(lt,qs,"boneMatrices"))}return!!Et&&(Et.morphAttributes.position!==void 0||Et.morphAttributes.normal!==void 0)&&$t.update(Ft,Et,xt,Bl),(Hl||mr.receiveShadow!==Ft.receiveShadow)&&(mr.receiveShadow=Ft.receiveShadow,Yi.setValue(lt,"receiveShadow",Ft.receiveShadow)),Hl&&(Yi.setValue(lt,"toneMappingExposure",g.toneMappingExposure),mr.needsLights&&cx(hm,Vl),Ve&&xt.fog&&Le.refreshFogUniforms(hm,Ve),Le.refreshMaterialUniforms(hm,xt,I,B,ot),B0.upload(lt,mr.uniformsList,hm,q)),xt.isShaderMaterial&&xt.uniformsNeedUpdate===!0&&(B0.upload(lt,mr.uniformsList,hm,q),xt.uniformsNeedUpdate=!1),xt.isSpriteMaterial&&Yi.setValue(lt,"center",Ft.center),Yi.setValue(lt,"modelViewMatrix",Ft.modelViewMatrix),Yi.setValue(lt,"normalMatrix",Ft.normalMatrix),Yi.setValue(lt,"modelMatrix",Ft.matrixWorld),Bl}function cx(K,gt){K.ambientLightColor.needsUpdate=gt,K.lightProbe.needsUpdate=gt,K.directionalLights.needsUpdate=gt,K.directionalLightShadows.needsUpdate=gt,K.pointLights.needsUpdate=gt,K.pointLightShadows.needsUpdate=gt,K.spotLights.needsUpdate=gt,K.spotLightShadows.needsUpdate=gt,K.rectAreaLights.needsUpdate=gt,K.hemisphereLights.needsUpdate=gt}function rp(K){return K.isMeshLambertMaterial||K.isMeshToonMaterial||K.isMeshPhongMaterial||K.isMeshStandardMaterial||K.isShadowMaterial||K.isShaderMaterial&&K.lights===!0}this.getActiveCubeFace=function(){return y},this.getActiveMipmapLevel=function(){return x},this.getRenderTarget=function(){return b},this.setRenderTargetTextures=function(K,gt,Et){dt.get(K.texture).__webglTexture=gt,dt.get(K.depthTexture).__webglTexture=Et;let xt=dt.get(K);xt.__hasExternalTextures=!0,xt.__hasExternalTextures&&(xt.__autoAllocateDepthBuffer=Et===void 0,xt.__autoAllocateDepthBuffer||K.useRenderToTexture&&(console.warn("render-to-texture extension was disabled because an external texture was provided"),K.useRenderToTexture=!1,K.useRenderbuffer=!0))},this.setRenderTargetFramebuffer=function(K,gt){let Et=dt.get(K);Et.__webglFramebuffer=gt,Et.__useDefaultFramebuffer=gt===void 0},this.setRenderTarget=function(K,gt=0,Et=0){b=K,y=gt,x=Et;let xt=!0;if(K){let Ke=dt.get(K);Ke.__useDefaultFramebuffer!==void 0?(X.bindFramebuffer(36160,null),xt=!1):Ke.__webglFramebuffer===void 0?q.setupRenderTarget(K):Ke.__hasExternalTextures&&q.rebindTextures(K,dt.get(K.texture).__webglTexture,dt.get(K.depthTexture).__webglTexture)}let Ft=null,Ve=!1,Ue=!1;if(K){let Ke=K.texture;(Ke.isDataTexture3D||Ke.isDataTexture2DArray)&&(Ue=!0);let Xr=dt.get(K).__webglFramebuffer;K.isWebGLCubeRenderTarget?(Ft=Xr[gt],Ve=!0):K.useRenderbuffer?Ft=dt.get(K).__webglMultisampledFramebuffer:Ft=Xr,P.copy(K.viewport),k.copy(K.scissor),O=K.scissorTest}else P.copy(F).multiplyScalar(I).floor(),k.copy(z).multiplyScalar(I).floor(),O=U;if(X.bindFramebuffer(36160,Ft)&&ct.drawBuffers&&xt&&X.drawBuffers(K,Ft),X.viewport(P),X.scissor(k),X.setScissorTest(O),Ve){let Ke=dt.get(K.texture);lt.framebufferTexture2D(36160,36064,34069+gt,Ke.__webglTexture,Et)}else if(Ue){let Ke=dt.get(K.texture),Xr=gt||0;lt.framebufferTextureLayer(36160,36064,Ke.__webglTexture,Et||0,Xr)}S=-1},this.readRenderTargetPixels=function(K,gt,Et,xt,Ft,Ve,Ue){if(!(K&&K.isWebGLRenderTarget)){console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not THREE.WebGLRenderTarget.");return}let tr=dt.get(K).__webglFramebuffer;if(K.isWebGLCubeRenderTarget&&Ue!==void 0&&(tr=tr[Ue]),tr){X.bindFramebuffer(36160,tr);try{let Ke=K.texture,Xr=Ke.format,_r=Ke.type;if(Xr!==Qo&&be.convert(Xr)!==lt.getParameter(35739)){console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in RGBA or implementation defined format.");return}let Pr=_r===C1&&(_t.has("EXT_color_buffer_half_float")||ct.isWebGL2&&_t.has("EXT_color_buffer_float"));if(_r!==Zd&&be.convert(_r)!==lt.getParameter(35738)&&!(_r===jd&&(ct.isWebGL2||_t.has("OES_texture_float")||_t.has("WEBGL_color_buffer_float")))&&!Pr){console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in UnsignedByteType or implementation defined type.");return}lt.checkFramebufferStatus(36160)===36053?gt>=0&&gt<=K.width-xt&&Et>=0&&Et<=K.height-Ft&&lt.readPixels(gt,Et,xt,Ft,be.convert(Xr),be.convert(_r),Ve):console.error("THREE.WebGLRenderer.readRenderTargetPixels: readPixels from renderTarget failed. Framebuffer not complete.")}finally{let Ke=b!==null?dt.get(b).__webglFramebuffer:null;X.bindFramebuffer(36160,Ke)}}},this.copyFramebufferToTexture=function(K,gt,Et=0){if(gt.isFramebufferTexture!==!0){console.error("THREE.WebGLRenderer: copyFramebufferToTexture() can only be used with FramebufferTexture.");return}let xt=Math.pow(2,-Et),Ft=Math.floor(gt.image.width*xt),Ve=Math.floor(gt.image.height*xt);q.setTexture2D(gt,0),lt.copyTexSubImage2D(3553,Et,0,0,K.x,K.y,Ft,Ve),X.unbindTexture()},this.copyTextureToTexture=function(K,gt,Et,xt=0){let Ft=gt.image.width,Ve=gt.image.height,Ue=be.convert(Et.format),tr=be.convert(Et.type);q.setTexture2D(Et,0),lt.pixelStorei(37440,Et.flipY),lt.pixelStorei(37441,Et.premultiplyAlpha),lt.pixelStorei(3317,Et.unpackAlignment),gt.isDataTexture?lt.texSubImage2D(3553,xt,K.x,K.y,Ft,Ve,Ue,tr,gt.image.data):gt.isCompressedTexture?lt.compressedTexSubImage2D(3553,xt,K.x,K.y,gt.mipmaps[0].width,gt.mipmaps[0].height,Ue,gt.mipmaps[0].data):lt.texSubImage2D(3553,xt,K.x,K.y,Ue,tr,gt.image),xt===0&&Et.generateMipmaps&&lt.generateMipmap(3553),X.unbindTexture()},this.copyTextureToTexture3D=function(K,gt,Et,xt,Ft=0){if(g.isWebGL1Renderer){console.warn("THREE.WebGLRenderer.copyTextureToTexture3D: can only be used with WebGL2.");return}let Ve=K.max.x-K.min.x+1,Ue=K.max.y-K.min.y+1,tr=K.max.z-K.min.z+1,Ke=be.convert(xt.format),Xr=be.convert(xt.type),_r;if(xt.isDataTexture3D)q.setTexture3D(xt,0),_r=32879;else if(xt.isDataTexture2DArray)q.setTexture2DArray(xt,0),_r=35866;else{console.warn("THREE.WebGLRenderer.copyTextureToTexture3D: only supports THREE.DataTexture3D and THREE.DataTexture2DArray.");return}lt.pixelStorei(37440,xt.flipY),lt.pixelStorei(37441,xt.premultiplyAlpha),lt.pixelStorei(3317,xt.unpackAlignment);let Pr=lt.getParameter(3314),jn=lt.getParameter(32878),np=lt.getParameter(3316),um=lt.getParameter(3315),mr=lt.getParameter(32877),Fl=Et.isCompressedTexture?Et.mipmaps[0]:Et.image;lt.pixelStorei(3314,Fl.width),lt.pixelStorei(32878,Fl.height),lt.pixelStorei(3316,K.min.x),lt.pixelStorei(3315,K.min.y),lt.pixelStorei(32877,K.min.z),Et.isDataTexture||Et.isDataTexture3D?lt.texSubImage3D(_r,Ft,gt.x,gt.y,gt.z,Ve,Ue,tr,Ke,Xr,Fl.data):Et.isCompressedTexture?(console.warn("THREE.WebGLRenderer.copyTextureToTexture3D: untested support for compressed srcTexture."),lt.compressedTexSubImage3D(_r,Ft,gt.x,gt.y,gt.z,Ve,Ue,tr,Ke,Fl.data)):lt.texSubImage3D(_r,Ft,gt.x,gt.y,gt.z,Ve,Ue,tr,Ke,Xr,Fl),lt.pixelStorei(3314,Pr),lt.pixelStorei(32878,jn),lt.pixelStorei(3316,np),lt.pixelStorei(3315,um),lt.pixelStorei(32877,mr),Ft===0&&xt.generateMipmaps&&lt.generateMipmap(_r),X.unbindTexture()},this.initTexture=function(K){q.setTexture2D(K,0),X.unbindTexture()},this.resetState=function(){y=0,x=0,b=null,X.reset(),nt.reset()},typeof __THREE_DEVTOOLS__!="undefined"&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("observe",{detail:this}))}rn.prototype.isWebGLRenderer=!0;var gU=class extends rn{};gU.prototype.isWebGL1Renderer=!0;var O1=class{constructor(t,r=25e-5){this.name="",this.color=new ne(t),this.density=r}clone(){return new O1(this.color,this.density)}toJSON(){return{type:"FogExp2",color:this.color.getHex(),density:this.density}}};O1.prototype.isFogExp2=!0;var z1=class{constructor(t,r=1,n=1e3){this.name="",this.color=new ne(t),this.near=r,this.far=n}clone(){return new z1(this.color,this.near,this.far)}toJSON(){return{type:"Fog",color:this.color.getHex(),near:this.near,far:this.far}}};z1.prototype.isFog=!0;var q0=class extends or{constructor(){super(),this.type="Scene",this.background=null,this.environment=null,this.fog=null,this.overrideMaterial=null,this.autoUpdate=!0,typeof __THREE_DEVTOOLS__!="undefined"&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("observe",{detail:this}))}copy(t,r){return super.copy(t,r),t.background!==null&&(this.background=t.background.clone()),t.environment!==null&&(this.environment=t.environment.clone()),t.fog!==null&&(this.fog=t.fog.clone()),t.overrideMaterial!==null&&(this.overrideMaterial=t.overrideMaterial.clone()),this.autoUpdate=t.autoUpdate,this.matrixAutoUpdate=t.matrixAutoUpdate,this}toJSON(t){let r=super.toJSON(t);return this.fog!==null&&(r.object.fog=this.fog.toJSON()),r}};q0.prototype.isScene=!0;var em=class{constructor(t,r){this.array=t,this.stride=r,this.count=t!==void 0?t.length/r:0,this.usage=W3,this.updateRange={offset:0,count:-1},this.version=0,this.uuid=Nl()}onUploadCallback(){}set needsUpdate(t){t===!0&&this.version++}setUsage(t){return this.usage=t,this}copy(t){return this.array=new t.array.constructor(t.array),this.count=t.count,this.stride=t.stride,this.usage=t.usage,this}copyAt(t,r,n){t*=this.stride,n*=r.stride;for(let i=0,o=this.stride;i<o;i++)this.array[t+i]=r.array[n+i];return this}set(t,r=0){return this.array.set(t,r),this}clone(t){t.arrayBuffers===void 0&&(t.arrayBuffers={}),this.array.buffer._uuid===void 0&&(this.array.buffer._uuid=Nl()),t.arrayBuffers[this.array.buffer._uuid]===void 0&&(t.arrayBuffers[this.array.buffer._uuid]=this.array.slice(0).buffer);let r=new this.array.constructor(t.arrayBuffers[this.array.buffer._uuid]),n=new this.constructor(r,this.stride);return n.setUsage(this.usage),n}onUpload(t){return this.onUploadCallback=t,this}toJSON(t){return t.arrayBuffers===void 0&&(t.arrayBuffers={}),this.array.buffer._uuid===void 0&&(this.array.buffer._uuid=Nl()),t.arrayBuffers[this.array.buffer._uuid]===void 0&&(t.arrayBuffers[this.array.buffer._uuid]=Array.prototype.slice.call(new Uint32Array(this.array.buffer))),{uuid:this.uuid,buffer:this.array.buffer._uuid,type:this.array.constructor.name,stride:this.stride}}};em.prototype.isInterleavedBuffer=!0;var Ai=new j,tp=class{constructor(t,r,n,i=!1){this.name="",this.data=t,this.itemSize=r,this.offset=n,this.normalized=i===!0}get count(){return this.data.count}get array(){return this.data.array}set needsUpdate(t){this.data.needsUpdate=t}applyMatrix4(t){for(let r=0,n=this.data.count;r<n;r++)Ai.x=this.getX(r),Ai.y=this.getY(r),Ai.z=this.getZ(r),Ai.applyMatrix4(t),this.setXYZ(r,Ai.x,Ai.y,Ai.z);return this}applyNormalMatrix(t){for(let r=0,n=this.count;r<n;r++)Ai.x=this.getX(r),Ai.y=this.getY(r),Ai.z=this.getZ(r),Ai.applyNormalMatrix(t),this.setXYZ(r,Ai.x,Ai.y,Ai.z);return this}transformDirection(t){for(let r=0,n=this.count;r<n;r++)Ai.x=this.getX(r),Ai.y=this.getY(r),Ai.z=this.getZ(r),Ai.transformDirection(t),this.setXYZ(r,Ai.x,Ai.y,Ai.z);return this}setX(t,r){return this.data.array[t*this.data.stride+this.offset]=r,this}setY(t,r){return this.data.array[t*this.data.stride+this.offset+1]=r,this}setZ(t,r){return this.data.array[t*this.data.stride+this.offset+2]=r,this}setW(t,r){return this.data.array[t*this.data.stride+this.offset+3]=r,this}getX(t){return this.data.array[t*this.data.stride+this.offset]}getY(t){return this.data.array[t*this.data.stride+this.offset+1]}getZ(t){return this.data.array[t*this.data.stride+this.offset+2]}getW(t){return this.data.array[t*this.data.stride+this.offset+3]}setXY(t,r,n){return t=t*this.data.stride+this.offset,this.data.array[t+0]=r,this.data.array[t+1]=n,this}setXYZ(t,r,n,i){return t=t*this.data.stride+this.offset,this.data.array[t+0]=r,this.data.array[t+1]=n,this.data.array[t+2]=i,this}setXYZW(t,r,n,i,o){return t=t*this.data.stride+this.offset,this.data.array[t+0]=r,this.data.array[t+1]=n,this.data.array[t+2]=i,this.data.array[t+3]=o,this}clone(t){if(t===void 0){console.log("THREE.InterleavedBufferAttribute.clone(): Cloning an interlaved buffer attribute will deinterleave buffer data.");let r=[];for(let n=0;n<this.count;n++){let i=n*this.data.stride+this.offset;for(let o=0;o<this.itemSize;o++)r.push(this.data.array[i+o])}return new Je(new this.array.constructor(r),this.itemSize,this.normalized)}else return t.interleavedBuffers===void 0&&(t.interleavedBuffers={}),t.interleavedBuffers[this.data.uuid]===void 0&&(t.interleavedBuffers[this.data.uuid]=this.data.clone(t)),new tp(t.interleavedBuffers[this.data.uuid],this.itemSize,this.offset,this.normalized)}toJSON(t){if(t===void 0){console.log("THREE.InterleavedBufferAttribute.toJSON(): Serializing an interlaved buffer attribute will deinterleave buffer data.");let r=[];for(let n=0;n<this.count;n++){let i=n*this.data.stride+this.offset;for(let o=0;o<this.itemSize;o++)r.push(this.data.array[i+o])}return{itemSize:this.itemSize,type:this.array.constructor.name,array:r,normalized:this.normalized}}else return t.interleavedBuffers===void 0&&(t.interleavedBuffers={}),t.interleavedBuffers[this.data.uuid]===void 0&&(t.interleavedBuffers[this.data.uuid]=this.data.toJSON(t)),{isInterleavedBufferAttribute:!0,itemSize:this.itemSize,data:this.data.uuid,offset:this.offset,normalized:this.normalized}}};tp.prototype.isInterleavedBufferAttribute=!0;var iM=class extends qi{constructor(t){super(),this.type="SpriteMaterial",this.color=new ne(16777215),this.map=null,this.alphaMap=null,this.rotation=0,this.sizeAttenuation=!0,this.transparent=!0,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.alphaMap=t.alphaMap,this.rotation=t.rotation,this.sizeAttenuation=t.sizeAttenuation,this}};iM.prototype.isSpriteMaterial=!0;var N3,DP=new j,D3=new j,O3=new j,z3=new Lt,OP=new Lt,tpe=new Me,LV=new j,zP=new j,kV=new j,Zue=new Lt,dut=new Lt,Jue=new Lt,oM=class extends or{constructor(t){if(super(),this.type="Sprite",N3===void 0){N3=new Pe;let r=new Float32Array([-.5,-.5,0,0,0,.5,-.5,0,1,0,.5,.5,0,1,1,-.5,.5,0,0,1]),n=new em(r,5);N3.setIndex([0,1,2,0,2,3]),N3.setAttribute("position",new tp(n,3,0,!1)),N3.setAttribute("uv",new tp(n,2,3,!1))}this.geometry=N3,this.material=t!==void 0?t:new iM,this.center=new Lt(.5,.5)}raycast(t,r){t.camera===null&&console.error('THREE.Sprite: "Raycaster.camera" needs to be set in order to raycast against sprites.'),D3.setFromMatrixScale(this.matrixWorld),tpe.copy(t.camera.matrixWorld),this.modelViewMatrix.multiplyMatrices(t.camera.matrixWorldInverse,this.matrixWorld),O3.setFromMatrixPosition(this.modelViewMatrix),t.camera.isPerspectiveCamera&&this.material.sizeAttenuation===!1&&D3.multiplyScalar(-O3.z);let n=this.material.rotation,i,o;n!==0&&(o=Math.cos(n),i=Math.sin(n));let a=this.center;RV(LV.set(-.5,-.5,0),O3,a,D3,i,o),RV(zP.set(.5,-.5,0),O3,a,D3,i,o),RV(kV.set(.5,.5,0),O3,a,D3,i,o),Zue.set(0,0),dut.set(1,0),Jue.set(1,1);let s=t.ray.intersectTriangle(LV,zP,kV,!1,DP);if(s===null&&(RV(zP.set(-.5,.5,0),O3,a,D3,i,o),dut.set(0,1),s=t.ray.intersectTriangle(LV,kV,zP,!1,DP),s===null))return;let l=t.ray.origin.distanceTo(DP);l<t.near||l>t.far||r.push({distance:l,point:DP.clone(),uv:oi.getUV(DP,LV,zP,kV,Zue,dut,Jue,new Lt),face:null,object:this})}copy(t){return super.copy(t),t.center!==void 0&&this.center.copy(t.center),this.material=t.material,this}};oM.prototype.isSprite=!0;function RV(e,t,r,n,i,o){z3.subVectors(e,r).addScalar(.5).multiply(n),i!==void 0?(OP.x=o*z3.x-i*z3.y,OP.y=i*z3.x+o*z3.y):OP.copy(z3),e.copy(t),e.x+=OP.x,e.y+=OP.y,e.applyMatrix4(tpe)}var NV=new j,Que=new j,_U=class extends or{constructor(){super(),this._currentLevel=0,this.type="LOD",Object.defineProperties(this,{levels:{enumerable:!0,value:[]},isLOD:{value:!0}}),this.autoUpdate=!0}copy(t){super.copy(t,!1);let r=t.levels;for(let n=0,i=r.length;n<i;n++){let o=r[n];this.addLevel(o.object.clone(),o.distance)}return this.autoUpdate=t.autoUpdate,this}addLevel(t,r=0){r=Math.abs(r);let n=this.levels,i;for(i=0;i<n.length&&!(r<n[i].distance);i++);return n.splice(i,0,{distance:r,object:t}),this.add(t),this}getCurrentLevel(){return this._currentLevel}getObjectForDistance(t){let r=this.levels;if(r.length>0){let n,i;for(n=1,i=r.length;n<i&&!(t<r[n].distance);n++);return r[n-1].object}return null}raycast(t,r){if(this.levels.length>0){NV.setFromMatrixPosition(this.matrixWorld);let i=t.ray.origin.distanceTo(NV);this.getObjectForDistance(i).raycast(t,r)}}update(t){let r=this.levels;if(r.length>1){NV.setFromMatrixPosition(t.matrixWorld),Que.setFromMatrixPosition(this.matrixWorld);let n=NV.distanceTo(Que)/t.zoom;r[0].object.visible=!0;let i,o;for(i=1,o=r.length;i<o&&n>=r[i].distance;i++)r[i-1].object.visible=!1,r[i].object.visible=!0;for(this._currentLevel=i-1;i<o;i++)r[i].object.visible=!1}}toJSON(t){let r=super.toJSON(t);this.autoUpdate===!1&&(r.object.autoUpdate=!1),r.object.levels=[];let n=this.levels;for(let i=0,o=n.length;i<o;i++){let a=n[i];r.object.levels.push({object:a.object.uuid,distance:a.distance})}return r}},the=new j,ehe=new en,rhe=new en,Dgr=new j,nhe=new Me,aM=class extends ti{constructor(t,r){super(t,r),this.type="SkinnedMesh",this.bindMode="attached",this.bindMatrix=new Me,this.bindMatrixInverse=new Me}copy(t){return super.copy(t),this.bindMode=t.bindMode,this.bindMatrix.copy(t.bindMatrix),this.bindMatrixInverse.copy(t.bindMatrixInverse),this.skeleton=t.skeleton,this}bind(t,r){this.skeleton=t,r===void 0&&(this.updateMatrixWorld(!0),this.skeleton.calculateInverses(),r=this.matrixWorld),this.bindMatrix.copy(r),this.bindMatrixInverse.copy(r).invert()}pose(){this.skeleton.pose()}normalizeSkinWeights(){let t=new en,r=this.geometry.attributes.skinWeight;for(let n=0,i=r.count;n<i;n++){t.x=r.getX(n),t.y=r.getY(n),t.z=r.getZ(n),t.w=r.getW(n);let o=1/t.manhattanLength();o!==1/0?t.multiplyScalar(o):t.set(1,0,0,0),r.setXYZW(n,t.x,t.y,t.z,t.w)}}updateMatrixWorld(t){super.updateMatrixWorld(t),this.bindMode==="attached"?this.bindMatrixInverse.copy(this.matrixWorld).invert():this.bindMode==="detached"?this.bindMatrixInverse.copy(this.bindMatrix).invert():console.warn("THREE.SkinnedMesh: Unrecognized bindMode: "+this.bindMode)}boneTransform(t,r){let n=this.skeleton,i=this.geometry;ehe.fromBufferAttribute(i.attributes.skinIndex,t),rhe.fromBufferAttribute(i.attributes.skinWeight,t),the.copy(r).applyMatrix4(this.bindMatrix),r.set(0,0,0);for(let o=0;o<4;o++){let a=rhe.getComponent(o);if(a!==0){let s=ehe.getComponent(o);nhe.multiplyMatrices(n.bones[s].matrixWorld,n.boneInverses[s]),r.addScaledVector(Dgr.copy(the).applyMatrix4(nhe),a)}}return r.applyMatrix4(this.bindMatrixInverse)}};aM.prototype.isSkinnedMesh=!0;var sM=class extends or{constructor(){super(),this.type="Bone"}};sM.prototype.isBone=!0;var Jd=class extends vi{constructor(t=null,r=1,n=1,i,o,a,s,l,c=Li,u=Li,h,f){super(null,a,s,l,c,u,i,o,h,f),this.image={data:t,width:r,height:n},this.magFilter=c,this.minFilter=u,this.generateMipmaps=!1,this.flipY=!1,this.unpackAlignment=1}};Jd.prototype.isDataTexture=!0;var ihe=new Me,Ogr=new Me,lM=class{constructor(t=[],r=[]){this.uuid=Nl(),this.bones=t.slice(0),this.boneInverses=r,this.boneMatrices=null,this.boneTexture=null,this.boneTextureSize=0,this.frame=-1,this.init()}init(){let t=this.bones,r=this.boneInverses;if(this.boneMatrices=new Float32Array(t.length*16),r.length===0)this.calculateInverses();else if(t.length!==r.length){console.warn("THREE.Skeleton: Number of inverse bone matrices does not match amount of bones."),this.boneInverses=[];for(let n=0,i=this.bones.length;n<i;n++)this.boneInverses.push(new Me)}}calculateInverses(){this.boneInverses.length=0;for(let t=0,r=this.bones.length;t<r;t++){let n=new Me;this.bones[t]&&n.copy(this.bones[t].matrixWorld).invert(),this.boneInverses.push(n)}}pose(){for(let t=0,r=this.bones.length;t<r;t++){let n=this.bones[t];n&&n.matrixWorld.copy(this.boneInverses[t]).invert()}for(let t=0,r=this.bones.length;t<r;t++){let n=this.bones[t];n&&(n.parent&&n.parent.isBone?(n.matrix.copy(n.parent.matrixWorld).invert(),n.matrix.multiply(n.matrixWorld)):n.matrix.copy(n.matrixWorld),n.matrix.decompose(n.position,n.quaternion,n.scale))}}update(){let t=this.bones,r=this.boneInverses,n=this.boneMatrices,i=this.boneTexture;for(let o=0,a=t.length;o<a;o++){let s=t[o]?t[o].matrixWorld:Ogr;ihe.multiplyMatrices(s,r[o]),ihe.toArray(n,o*16)}i!==null&&(i.needsUpdate=!0)}clone(){return new lM(this.bones,this.boneInverses)}computeBoneTexture(){let t=Math.sqrt(this.bones.length*4);t=zfe(t),t=Math.max(t,4);let r=new Float32Array(t*t*4);r.set(this.boneMatrices);let n=new Jd(r,t,t,Qo,jd);return n.needsUpdate=!0,this.boneMatrices=r,this.boneTexture=n,this.boneTextureSize=t,this}getBoneByName(t){for(let r=0,n=this.bones.length;r<n;r++){let i=this.bones[r];if(i.name===t)return i}}dispose(){this.boneTexture!==null&&(this.boneTexture.dispose(),this.boneTexture=null)}fromJSON(t,r){this.uuid=t.uuid;for(let n=0,i=t.bones.length;n<i;n++){let o=t.bones[n],a=r[o];a===void 0&&(console.warn("THREE.Skeleton: No bone found with UUID:",o),a=new sM),this.bones.push(a),this.boneInverses.push(new Me().fromArray(t.boneInverses[n]))}return this.init(),this}toJSON(){let t={metadata:{version:4.5,type:"Skeleton",generator:"Skeleton.toJSON"},bones:[],boneInverses:[]};t.uuid=this.uuid;let r=this.bones,n=this.boneInverses;for(let i=0,o=r.length;i<o;i++){let a=r[i];t.bones.push(a.uuid);let s=n[i];t.boneInverses.push(s.toArray())}return t}},rm=class extends Je{constructor(t,r,n,i=1){typeof n=="number"&&(i=n,n=!1,console.error("THREE.InstancedBufferAttribute: The constructor now expects normalized as the third argument.")),super(t,r,n),this.meshPerAttribute=i}copy(t){return super.copy(t),this.meshPerAttribute=t.meshPerAttribute,this}toJSON(){let t=super.toJSON();return t.meshPerAttribute=this.meshPerAttribute,t.isInstancedBufferAttribute=!0,t}};rm.prototype.isInstancedBufferAttribute=!0;var ohe=new Me,ahe=new Me,DV=[],FP=new ti,i6=class extends ti{constructor(t,r,n){super(t,r),this.instanceMatrix=new rm(new Float32Array(n*16),16),this.instanceColor=null,this.count=n,this.frustumCulled=!1}copy(t){return super.copy(t),this.instanceMatrix.copy(t.instanceMatrix),t.instanceColor!==null&&(this.instanceColor=t.instanceColor.clone()),this.count=t.count,this}getColorAt(t,r){r.fromArray(this.instanceColor.array,t*3)}getMatrixAt(t,r){r.fromArray(this.instanceMatrix.array,t*16)}raycast(t,r){let n=this.matrixWorld,i=this.count;if(FP.geometry=this.geometry,FP.material=this.material,FP.material!==void 0)for(let o=0;o<i;o++){this.getMatrixAt(o,ohe),ahe.multiplyMatrices(n,ohe),FP.matrixWorld=ahe,FP.raycast(t,DV);for(let a=0,s=DV.length;a<s;a++){let l=DV[a];l.instanceId=o,l.object=this,r.push(l)}DV.length=0}}setColorAt(t,r){this.instanceColor===null&&(this.instanceColor=new rm(new Float32Array(this.instanceMatrix.count*3),3)),r.toArray(this.instanceColor.array,t*3)}setMatrixAt(t,r){r.toArray(this.instanceMatrix.array,t*16)}updateMorphTargets(){}dispose(){this.dispatchEvent({type:"dispose"})}};i6.prototype.isInstancedMesh=!0;var Gi=class extends qi{constructor(t){super(),this.type="LineBasicMaterial",this.color=new ne(16777215),this.linewidth=1,this.linecap="round",this.linejoin="round",this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.linewidth=t.linewidth,this.linecap=t.linecap,this.linejoin=t.linejoin,this}};Gi.prototype.isLineBasicMaterial=!0;var she=new j,lhe=new j,che=new Me,mut=new Jf,OV=new Zf,ch=class extends or{constructor(t=new Pe,r=new Gi){super(),this.type="Line",this.geometry=t,this.material=r,this.updateMorphTargets()}copy(t){return super.copy(t),this.material=t.material,this.geometry=t.geometry,this}computeLineDistances(){let t=this.geometry;if(t.isBufferGeometry)if(t.index===null){let r=t.attributes.position,n=[0];for(let i=1,o=r.count;i<o;i++)she.fromBufferAttribute(r,i-1),lhe.fromBufferAttribute(r,i),n[i]=n[i-1],n[i]+=she.distanceTo(lhe);t.setAttribute("lineDistance",new xe(n,1))}else console.warn("THREE.Line.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.");else t.isGeometry&&console.error("THREE.Line.computeLineDistances() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.");return this}raycast(t,r){let n=this.geometry,i=this.matrixWorld,o=t.params.Line.threshold,a=n.drawRange;if(n.boundingSphere===null&&n.computeBoundingSphere(),OV.copy(n.boundingSphere),OV.applyMatrix4(i),OV.radius+=o,t.ray.intersectsSphere(OV)===!1)return;che.copy(i).invert(),mut.copy(t.ray).applyMatrix4(che);let s=o/((this.scale.x+this.scale.y+this.scale.z)/3),l=s*s,c=new j,u=new j,h=new j,f=new j,p=this.isLineSegments?2:1;if(n.isBufferGeometry){let d=n.index,_=n.attributes.position;if(d!==null){let y=Math.max(0,a.start),x=Math.min(d.count,a.start+a.count);for(let b=y,S=x-1;b<S;b+=p){let C=d.getX(b),P=d.getX(b+1);if(c.fromBufferAttribute(_,C),u.fromBufferAttribute(_,P),mut.distanceSqToSegment(c,u,f,h)>l)continue;f.applyMatrix4(this.matrixWorld);let O=t.ray.origin.distanceTo(f);O<t.near||O>t.far||r.push({distance:O,point:h.clone().applyMatrix4(this.matrixWorld),index:b,face:null,faceIndex:null,object:this})}}else{let y=Math.max(0,a.start),x=Math.min(_.count,a.start+a.count);for(let b=y,S=x-1;b<S;b+=p){if(c.fromBufferAttribute(_,b),u.fromBufferAttribute(_,b+1),mut.distanceSqToSegment(c,u,f,h)>l)continue;f.applyMatrix4(this.matrixWorld);let P=t.ray.origin.distanceTo(f);P<t.near||P>t.far||r.push({distance:P,point:h.clone().applyMatrix4(this.matrixWorld),index:b,face:null,faceIndex:null,object:this})}}}else n.isGeometry&&console.error("THREE.Line.raycast() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}updateMorphTargets(){let t=this.geometry;if(t.isBufferGeometry){let r=t.morphAttributes,n=Object.keys(r);if(n.length>0){let i=r[n[0]];if(i!==void 0){this.morphTargetInfluences=[],this.morphTargetDictionary={};for(let o=0,a=i.length;o<a;o++){let s=i[o].name||String(o);this.morphTargetInfluences.push(0),this.morphTargetDictionary[s]=o}}}}else{let r=t.morphTargets;r!==void 0&&r.length>0&&console.error("THREE.Line.updateMorphTargets() does not support THREE.Geometry. Use THREE.BufferGeometry instead.")}}};ch.prototype.isLine=!0;var uhe=new j,hhe=new j,Aa=class extends ch{constructor(t,r){super(t,r),this.type="LineSegments"}computeLineDistances(){let t=this.geometry;if(t.isBufferGeometry)if(t.index===null){let r=t.attributes.position,n=[];for(let i=0,o=r.count;i<o;i+=2)uhe.fromBufferAttribute(r,i),hhe.fromBufferAttribute(r,i+1),n[i]=i===0?0:n[i-1],n[i+1]=n[i]+uhe.distanceTo(hhe);t.setAttribute("lineDistance",new xe(n,1))}else console.warn("THREE.LineSegments.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.");else t.isGeometry&&console.error("THREE.LineSegments.computeLineDistances() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.");return this}};Aa.prototype.isLineSegments=!0;var o6=class extends ch{constructor(t,r){super(t,r),this.type="LineLoop"}};o6.prototype.isLineLoop=!0;var nm=class extends qi{constructor(t){super(),this.type="PointsMaterial",this.color=new ne(16777215),this.map=null,this.alphaMap=null,this.size=1,this.sizeAttenuation=!0,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.alphaMap=t.alphaMap,this.size=t.size,this.sizeAttenuation=t.sizeAttenuation,this}};nm.prototype.isPointsMaterial=!0;var fhe=new Me,rht=new Jf,zV=new Zf,FV=new j,im=class extends or{constructor(t=new Pe,r=new nm){super(),this.type="Points",this.geometry=t,this.material=r,this.updateMorphTargets()}copy(t){return super.copy(t),this.material=t.material,this.geometry=t.geometry,this}raycast(t,r){let n=this.geometry,i=this.matrixWorld,o=t.params.Points.threshold,a=n.drawRange;if(n.boundingSphere===null&&n.computeBoundingSphere(),zV.copy(n.boundingSphere),zV.applyMatrix4(i),zV.radius+=o,t.ray.intersectsSphere(zV)===!1)return;fhe.copy(i).invert(),rht.copy(t.ray).applyMatrix4(fhe);let s=o/((this.scale.x+this.scale.y+this.scale.z)/3),l=s*s;if(n.isBufferGeometry){let c=n.index,h=n.attributes.position;if(c!==null){let f=Math.max(0,a.start),p=Math.min(c.count,a.start+a.count);for(let d=f,g=p;d<g;d++){let _=c.getX(d);FV.fromBufferAttribute(h,_),phe(FV,_,l,i,t,r,this)}}else{let f=Math.max(0,a.start),p=Math.min(h.count,a.start+a.count);for(let d=f,g=p;d<g;d++)FV.fromBufferAttribute(h,d),phe(FV,d,l,i,t,r,this)}}else console.error("THREE.Points.raycast() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}updateMorphTargets(){let t=this.geometry;if(t.isBufferGeometry){let r=t.morphAttributes,n=Object.keys(r);if(n.length>0){let i=r[n[0]];if(i!==void 0){this.morphTargetInfluences=[],this.morphTargetDictionary={};for(let o=0,a=i.length;o<a;o++){let s=i[o].name||String(o);this.morphTargetInfluences.push(0),this.morphTargetDictionary[s]=o}}}}else{let r=t.morphTargets;r!==void 0&&r.length>0&&console.error("THREE.Points.updateMorphTargets() does not support THREE.Geometry. Use THREE.BufferGeometry instead.")}}};im.prototype.isPoints=!0;function phe(e,t,r,n,i,o,a){let s=rht.distanceSqToPoint(e);if(s<r){let l=new j;rht.closestPointToPoint(e,l),l.applyMatrix4(n);let c=i.ray.origin.distanceTo(l);if(c<i.near||c>i.far)return;o.push({distance:c,distanceToRay:Math.sqrt(s),point:l,index:t,face:null,object:a})}}var yU=class extends vi{constructor(t,r,n,i,o,a,s,l,c){super(t,r,n,i,o,a,s,l,c),this.minFilter=a!==void 0?a:ii,this.magFilter=o!==void 0?o:ii,this.generateMipmaps=!1;let u=this;function h(){u.needsUpdate=!0,t.requestVideoFrameCallback(h)}"requestVideoFrameCallback"in t&&t.requestVideoFrameCallback(h)}clone(){return new this.constructor(this.image).copy(this)}update(){let t=this.image;"requestVideoFrameCallback"in t===!1&&t.readyState>=t.HAVE_CURRENT_DATA&&(this.needsUpdate=!0)}};yU.prototype.isVideoTexture=!0;var vU=class extends vi{constructor(t,r,n){super({width:t,height:r}),this.format=n,this.magFilter=Li,this.minFilter=Li,this.generateMipmaps=!1,this.needsUpdate=!0}};vU.prototype.isFramebufferTexture=!0;var a6=class extends vi{constructor(t,r,n,i,o,a,s,l,c,u,h,f){super(null,a,s,l,c,u,i,o,h,f),this.image={width:r,height:n},this.mipmaps=t,this.flipY=!1,this.generateMipmaps=!1}};a6.prototype.isCompressedTexture=!0;var xU=class extends vi{constructor(t,r,n,i,o,a,s,l,c){super(t,r,n,i,o,a,s,l,c),this.needsUpdate=!0}};xU.prototype.isCanvasTexture=!0;var F1=class extends Pe{constructor(t=1,r=8,n=0,i=Math.PI*2){super(),this.type="CircleGeometry",this.parameters={radius:t,segments:r,thetaStart:n,thetaLength:i},r=Math.max(3,r);let o=[],a=[],s=[],l=[],c=new j,u=new Lt;a.push(0,0,0),s.push(0,0,1),l.push(.5,.5);for(let h=0,f=3;h<=r;h++,f+=3){let p=n+h/r*i;c.x=t*Math.cos(p),c.y=t*Math.sin(p),a.push(c.x,c.y,c.z),s.push(0,0,1),u.x=(a[f]/t+1)/2,u.y=(a[f+1]/t+1)/2,l.push(u.x,u.y)}for(let h=1;h<=r;h++)o.push(h,h+1,0);this.setIndex(o),this.setAttribute("position",new xe(a,3)),this.setAttribute("normal",new xe(s,3)),this.setAttribute("uv",new xe(l,2))}static fromJSON(t){return new F1(t.radius,t.segments,t.thetaStart,t.thetaLength)}},om=class extends Pe{constructor(t=1,r=1,n=1,i=8,o=1,a=!1,s=0,l=Math.PI*2){super(),this.type="CylinderGeometry",this.parameters={radiusTop:t,radiusBottom:r,height:n,radialSegments:i,heightSegments:o,openEnded:a,thetaStart:s,thetaLength:l};let c=this;i=Math.floor(i),o=Math.floor(o);let u=[],h=[],f=[],p=[],d=0,g=[],_=n/2,y=0;x(),a===!1&&(t>0&&b(!0),r>0&&b(!1)),this.setIndex(u),this.setAttribute("position",new xe(h,3)),this.setAttribute("normal",new xe(f,3)),this.setAttribute("uv",new xe(p,2));function x(){let S=new j,C=new j,P=0,k=(r-t)/n;for(let O=0;O<=o;O++){let D=[],B=O/o,I=B*(r-t)+t;for(let L=0;L<=i;L++){let R=L/i,F=R*l+s,z=Math.sin(F),U=Math.cos(F);C.x=I*z,C.y=-B*n+_,C.z=I*U,h.push(C.x,C.y,C.z),S.set(z,k,U).normalize(),f.push(S.x,S.y,S.z),p.push(R,1-B),D.push(d++)}g.push(D)}for(let O=0;O<i;O++)for(let D=0;D<o;D++){let B=g[D][O],I=g[D+1][O],L=g[D+1][O+1],R=g[D][O+1];u.push(B,I,R),u.push(I,L,R),P+=6}c.addGroup(y,P,0),y+=P}function b(S){let C=d,P=new Lt,k=new j,O=0,D=S===!0?t:r,B=S===!0?1:-1;for(let L=1;L<=i;L++)h.push(0,_*B,0),f.push(0,B,0),p.push(.5,.5),d++;let I=d;for(let L=0;L<=i;L++){let F=L/i*l+s,z=Math.cos(F),U=Math.sin(F);k.x=D*U,k.y=_*B,k.z=D*z,h.push(k.x,k.y,k.z),f.push(0,B,0),P.x=z*.5+.5,P.y=U*.5*B+.5,p.push(P.x,P.y),d++}for(let L=0;L<i;L++){let R=C+L,F=I+L;S===!0?u.push(F,F+1,R):u.push(F+1,F,R),O+=3}c.addGroup(y,O,S===!0?1:2),y+=O}}static fromJSON(t){return new om(t.radiusTop,t.radiusBottom,t.height,t.radialSegments,t.heightSegments,t.openEnded,t.thetaStart,t.thetaLength)}},B1=class extends om{constructor(t=1,r=1,n=8,i=1,o=!1,a=0,s=Math.PI*2){super(0,t,r,n,i,o,a,s),this.type="ConeGeometry",this.parameters={radius:t,height:r,radialSegments:n,heightSegments:i,openEnded:o,thetaStart:a,thetaLength:s}}static fromJSON(t){return new B1(t.radius,t.height,t.radialSegments,t.heightSegments,t.openEnded,t.thetaStart,t.thetaLength)}},uh=class extends Pe{constructor(t=[],r=[],n=1,i=0){super(),this.type="PolyhedronGeometry",this.parameters={vertices:t,indices:r,radius:n,detail:i};let o=[],a=[];s(i),c(n),u(),this.setAttribute("position",new xe(o,3)),this.setAttribute("normal",new xe(o.slice(),3)),this.setAttribute("uv",new xe(a,2)),i===0?this.computeVertexNormals():this.normalizeNormals();function s(x){let b=new j,S=new j,C=new j;for(let P=0;P<r.length;P+=3)p(r[P+0],b),p(r[P+1],S),p(r[P+2],C),l(b,S,C,x)}function l(x,b,S,C){let P=C+1,k=[];for(let O=0;O<=P;O++){k[O]=[];let D=x.clone().lerp(S,O/P),B=b.clone().lerp(S,O/P),I=P-O;for(let L=0;L<=I;L++)L===0&&O===P?k[O][L]=D:k[O][L]=D.clone().lerp(B,L/I)}for(let O=0;O<P;O++)for(let D=0;D<2*(P-O)-1;D++){let B=Math.floor(D/2);D%2===0?(f(k[O][B+1]),f(k[O+1][B]),f(k[O][B])):(f(k[O][B+1]),f(k[O+1][B+1]),f(k[O+1][B]))}}function c(x){let b=new j;for(let S=0;S<o.length;S+=3)b.x=o[S+0],b.y=o[S+1],b.z=o[S+2],b.normalize().multiplyScalar(x),o[S+0]=b.x,o[S+1]=b.y,o[S+2]=b.z}function u(){let x=new j;for(let b=0;b<o.length;b+=3){x.x=o[b+0],x.y=o[b+1],x.z=o[b+2];let S=_(x)/2/Math.PI+.5,C=y(x)/Math.PI+.5;a.push(S,1-C)}d(),h()}function h(){for(let x=0;x<a.length;x+=6){let b=a[x+0],S=a[x+2],C=a[x+4],P=Math.max(b,S,C),k=Math.min(b,S,C);P>.9&&k<.1&&(b<.2&&(a[x+0]+=1),S<.2&&(a[x+2]+=1),C<.2&&(a[x+4]+=1))}}function f(x){o.push(x.x,x.y,x.z)}function p(x,b){let S=x*3;b.x=t[S+0],b.y=t[S+1],b.z=t[S+2]}function d(){let x=new j,b=new j,S=new j,C=new j,P=new Lt,k=new Lt,O=new Lt;for(let D=0,B=0;D<o.length;D+=9,B+=6){x.set(o[D+0],o[D+1],o[D+2]),b.set(o[D+3],o[D+4],o[D+5]),S.set(o[D+6],o[D+7],o[D+8]),P.set(a[B+0],a[B+1]),k.set(a[B+2],a[B+3]),O.set(a[B+4],a[B+5]),C.copy(x).add(b).add(S).divideScalar(3);let I=_(C);g(P,B+0,x,I),g(k,B+2,b,I),g(O,B+4,S,I)}}function g(x,b,S,C){C<0&&x.x===1&&(a[b]=x.x-1),S.x===0&&S.z===0&&(a[b]=C/2/Math.PI+.5)}function _(x){return Math.atan2(x.z,-x.x)}function y(x){return Math.atan2(-x.y,Math.sqrt(x.x*x.x+x.z*x.z))}}static fromJSON(t){return new uh(t.vertices,t.indices,t.radius,t.details)}},H1=class extends uh{constructor(t=1,r=0){let n=(1+Math.sqrt(5))/2,i=1/n,o=[-1,-1,-1,-1,-1,1,-1,1,-1,-1,1,1,1,-1,-1,1,-1,1,1,1,-1,1,1,1,0,-i,-n,0,-i,n,0,i,-n,0,i,n,-i,-n,0,-i,n,0,i,-n,0,i,n,0,-n,0,-i,n,0,-i,-n,0,i,n,0,i],a=[3,11,7,3,7,15,3,15,13,7,19,17,7,17,6,7,6,15,17,4,8,17,8,10,17,10,6,8,0,16,8,16,2,8,2,10,0,12,1,0,1,18,0,18,16,6,10,2,6,2,13,6,13,15,2,16,18,2,18,3,2,3,13,18,1,9,18,9,11,18,11,3,4,14,12,4,12,0,4,0,8,11,9,5,11,5,19,11,19,7,19,5,14,19,14,4,19,4,17,1,12,14,1,14,5,1,5,9];super(o,a,t,r),this.type="DodecahedronGeometry",this.parameters={radius:t,detail:r}}static fromJSON(t){return new H1(t.radius,t.detail)}},BV=new j,HV=new j,gut=new j,VV=new oi,s6=class extends Pe{constructor(t=null,r=1){if(super(),this.type="EdgesGeometry",this.parameters={geometry:t,thresholdAngle:r},t!==null){let i=Math.pow(10,4),o=Math.cos(P1*r),a=t.getIndex(),s=t.getAttribute("position"),l=a?a.count:s.count,c=[0,0,0],u=["a","b","c"],h=new Array(3),f={},p=[];for(let d=0;d<l;d+=3){a?(c[0]=a.getX(d),c[1]=a.getX(d+1),c[2]=a.getX(d+2)):(c[0]=d,c[1]=d+1,c[2]=d+2);let{a:g,b:_,c:y}=VV;if(g.fromBufferAttribute(s,c[0]),_.fromBufferAttribute(s,c[1]),y.fromBufferAttribute(s,c[2]),VV.getNormal(gut),h[0]=`${Math.round(g.x*i)},${Math.round(g.y*i)},${Math.round(g.z*i)}`,h[1]=`${Math.round(_.x*i)},${Math.round(_.y*i)},${Math.round(_.z*i)}`,h[2]=`${Math.round(y.x*i)},${Math.round(y.y*i)},${Math.round(y.z*i)}`,!(h[0]===h[1]||h[1]===h[2]||h[2]===h[0]))for(let x=0;x<3;x++){let b=(x+1)%3,S=h[x],C=h[b],P=VV[u[x]],k=VV[u[b]],O=`${S}_${C}`,D=`${C}_${S}`;D in f&&f[D]?(gut.dot(f[D].normal)<=o&&(p.push(P.x,P.y,P.z),p.push(k.x,k.y,k.z)),f[D]=null):O in f||(f[O]={index0:c[x],index1:c[b],normal:gut.clone()})}}for(let d in f)if(f[d]){let{index0:g,index1:_}=f[d];BV.fromBufferAttribute(s,g),HV.fromBufferAttribute(s,_),p.push(BV.x,BV.y,BV.z),p.push(HV.x,HV.y,HV.z)}this.setAttribute("position",new xe(p,3))}}},fs=class{constructor(){this.type="Curve",this.arcLengthDivisions=200}getPoint(){return console.warn("THREE.Curve: .getPoint() not implemented."),null}getPointAt(t,r){let n=this.getUtoTmapping(t);return this.getPoint(n,r)}getPoints(t=5){let r=[];for(let n=0;n<=t;n++)r.push(this.getPoint(n/t));return r}getSpacedPoints(t=5){let r=[];for(let n=0;n<=t;n++)r.push(this.getPointAt(n/t));return r}getLength(){let t=this.getLengths();return t[t.length-1]}getLengths(t=this.arcLengthDivisions){if(this.cacheArcLengths&&this.cacheArcLengths.length===t+1&&!this.needsUpdate)return this.cacheArcLengths;this.needsUpdate=!1;let r=[],n,i=this.getPoint(0),o=0;r.push(0);for(let a=1;a<=t;a++)n=this.getPoint(a/t),o+=n.distanceTo(i),r.push(o),i=n;return this.cacheArcLengths=r,r}updateArcLengths(){this.needsUpdate=!0,this.getLengths()}getUtoTmapping(t,r){let n=this.getLengths(),i=0,o=n.length,a;r?a=r:a=t*n[o-1];let s=0,l=o-1,c;for(;s<=l;)if(i=Math.floor(s+(l-s)/2),c=n[i]-a,c<0)s=i+1;else if(c>0)l=i-1;else{l=i;break}if(i=l,n[i]===a)return i/(o-1);let u=n[i],f=n[i+1]-u,p=(a-u)/f;return(i+p)/(o-1)}getTangent(t,r){let i=t-1e-4,o=t+1e-4;i<0&&(i=0),o>1&&(o=1);let a=this.getPoint(i),s=this.getPoint(o),l=r||(a.isVector2?new Lt:new j);return l.copy(s).sub(a).normalize(),l}getTangentAt(t,r){let n=this.getUtoTmapping(t);return this.getTangent(n,r)}computeFrenetFrames(t,r){let n=new j,i=[],o=[],a=[],s=new j,l=new Me;for(let p=0;p<=t;p++){let d=p/t;i[p]=this.getTangentAt(d,new j)}o[0]=new j,a[0]=new j;let c=Number.MAX_VALUE,u=Math.abs(i[0].x),h=Math.abs(i[0].y),f=Math.abs(i[0].z);u<=c&&(c=u,n.set(1,0,0)),h<=c&&(c=h,n.set(0,1,0)),f<=c&&n.set(0,0,1),s.crossVectors(i[0],n).normalize(),o[0].crossVectors(i[0],s),a[0].crossVectors(i[0],o[0]);for(let p=1;p<=t;p++){if(o[p]=o[p-1].clone(),a[p]=a[p-1].clone(),s.crossVectors(i[p-1],i[p]),s.length()>Number.EPSILON){s.normalize();let d=Math.acos(Zo(i[p-1].dot(i[p]),-1,1));o[p].applyMatrix4(l.makeRotationAxis(s,d))}a[p].crossVectors(i[p],o[p])}if(r===!0){let p=Math.acos(Zo(o[0].dot(o[t]),-1,1));p/=t,i[0].dot(s.crossVectors(o[0],o[t]))>0&&(p=-p);for(let d=1;d<=t;d++)o[d].applyMatrix4(l.makeRotationAxis(i[d],p*d)),a[d].crossVectors(i[d],o[d])}return{tangents:i,normals:o,binormals:a}}clone(){return new this.constructor().copy(this)}copy(t){return this.arcLengthDivisions=t.arcLengthDivisions,this}toJSON(){let t={metadata:{version:4.5,type:"Curve",generator:"Curve.toJSON"}};return t.arcLengthDivisions=this.arcLengthDivisions,t.type=this.type,t}fromJSON(t){return this.arcLengthDivisions=t.arcLengthDivisions,this}},V1=class extends fs{constructor(t=0,r=0,n=1,i=1,o=0,a=Math.PI*2,s=!1,l=0){super(),this.type="EllipseCurve",this.aX=t,this.aY=r,this.xRadius=n,this.yRadius=i,this.aStartAngle=o,this.aEndAngle=a,this.aClockwise=s,this.aRotation=l}getPoint(t,r){let n=r||new Lt,i=Math.PI*2,o=this.aEndAngle-this.aStartAngle,a=Math.abs(o)<Number.EPSILON;for(;o<0;)o+=i;for(;o>i;)o-=i;o<Number.EPSILON&&(a?o=0:o=i),this.aClockwise===!0&&!a&&(o===i?o=-i:o=o-i);let s=this.aStartAngle+t*o,l=this.aX+this.xRadius*Math.cos(s),c=this.aY+this.yRadius*Math.sin(s);if(this.aRotation!==0){let u=Math.cos(this.aRotation),h=Math.sin(this.aRotation),f=l-this.aX,p=c-this.aY;l=f*u-p*h+this.aX,c=f*h+p*u+this.aY}return n.set(l,c)}copy(t){return super.copy(t),this.aX=t.aX,this.aY=t.aY,this.xRadius=t.xRadius,this.yRadius=t.yRadius,this.aStartAngle=t.aStartAngle,this.aEndAngle=t.aEndAngle,this.aClockwise=t.aClockwise,this.aRotation=t.aRotation,this}toJSON(){let t=super.toJSON();return t.aX=this.aX,t.aY=this.aY,t.xRadius=this.xRadius,t.yRadius=this.yRadius,t.aStartAngle=this.aStartAngle,t.aEndAngle=this.aEndAngle,t.aClockwise=this.aClockwise,t.aRotation=this.aRotation,t}fromJSON(t){return super.fromJSON(t),this.aX=t.aX,this.aY=t.aY,this.xRadius=t.xRadius,this.yRadius=t.yRadius,this.aStartAngle=t.aStartAngle,this.aEndAngle=t.aEndAngle,this.aClockwise=t.aClockwise,this.aRotation=t.aRotation,this}};V1.prototype.isEllipseCurve=!0;var l6=class extends V1{constructor(t,r,n,i,o,a){super(t,r,n,n,i,o,a),this.type="ArcCurve"}};l6.prototype.isArcCurve=!0;function Dht(){let e=0,t=0,r=0,n=0;function i(o,a,s,l){e=o,t=s,r=-3*o+3*a-2*s-l,n=2*o-2*a+s+l}return{initCatmullRom:function(o,a,s,l,c){i(a,s,c*(s-o),c*(l-a))},initNonuniformCatmullRom:function(o,a,s,l,c,u,h){let f=(a-o)/c-(s-o)/(c+u)+(s-a)/u,p=(s-a)/u-(l-a)/(u+h)+(l-s)/h;f*=u,p*=u,i(a,s,f,p)},calc:function(o){let a=o*o,s=a*o;return e+t*o+r*a+n*s}}}var UV=new j,_ut=new Dht,yut=new Dht,vut=new Dht,c6=class extends fs{constructor(t=[],r=!1,n="centripetal",i=.5){super(),this.type="CatmullRomCurve3",this.points=t,this.closed=r,this.curveType=n,this.tension=i}getPoint(t,r=new j){let n=r,i=this.points,o=i.length,a=(o-(this.closed?0:1))*t,s=Math.floor(a),l=a-s;this.closed?s+=s>0?0:(Math.floor(Math.abs(s)/o)+1)*o:l===0&&s===o-1&&(s=o-2,l=1);let c,u;this.closed||s>0?c=i[(s-1)%o]:(UV.subVectors(i[0],i[1]).add(i[0]),c=UV);let h=i[s%o],f=i[(s+1)%o];if(this.closed||s+2<o?u=i[(s+2)%o]:(UV.subVectors(i[o-1],i[o-2]).add(i[o-1]),u=UV),this.curveType==="centripetal"||this.curveType==="chordal"){let p=this.curveType==="chordal"?.5:.25,d=Math.pow(c.distanceToSquared(h),p),g=Math.pow(h.distanceToSquared(f),p),_=Math.pow(f.distanceToSquared(u),p);g<1e-4&&(g=1),d<1e-4&&(d=g),_<1e-4&&(_=g),_ut.initNonuniformCatmullRom(c.x,h.x,f.x,u.x,d,g,_),yut.initNonuniformCatmullRom(c.y,h.y,f.y,u.y,d,g,_),vut.initNonuniformCatmullRom(c.z,h.z,f.z,u.z,d,g,_)}else this.curveType==="catmullrom"&&(_ut.initCatmullRom(c.x,h.x,f.x,u.x,this.tension),yut.initCatmullRom(c.y,h.y,f.y,u.y,this.tension),vut.initCatmullRom(c.z,h.z,f.z,u.z,this.tension));return n.set(_ut.calc(l),yut.calc(l),vut.calc(l)),n}copy(t){super.copy(t),this.points=[];for(let r=0,n=t.points.length;r<n;r++){let i=t.points[r];this.points.push(i.clone())}return this.closed=t.closed,this.curveType=t.curveType,this.tension=t.tension,this}toJSON(){let t=super.toJSON();t.points=[];for(let r=0,n=this.points.length;r<n;r++){let i=this.points[r];t.points.push(i.toArray())}return t.closed=this.closed,t.curveType=this.curveType,t.tension=this.tension,t}fromJSON(t){super.fromJSON(t),this.points=[];for(let r=0,n=t.points.length;r<n;r++){let i=t.points[r];this.points.push(new j().fromArray(i))}return this.closed=t.closed,this.curveType=t.curveType,this.tension=t.tension,this}};c6.prototype.isCatmullRomCurve3=!0;function dhe(e,t,r,n,i){let o=(n-t)*.5,a=(i-r)*.5,s=e*e,l=e*s;return(2*r-2*n+o+a)*l+(-3*r+3*n-2*o-a)*s+o*e+r}function zgr(e,t){let r=1-e;return r*r*t}function Fgr(e,t){return 2*(1-e)*e*t}function Bgr(e,t){return e*e*t}function GP(e,t,r,n){return zgr(e,t)+Fgr(e,r)+Bgr(e,n)}function Hgr(e,t){let r=1-e;return r*r*r*t}function Vgr(e,t){let r=1-e;return 3*r*r*e*t}function Ugr(e,t){return 3*(1-e)*e*e*t}function qgr(e,t){return e*e*e*t}function WP(e,t,r,n,i){return Hgr(e,t)+Vgr(e,r)+Ugr(e,n)+qgr(e,i)}var cM=class extends fs{constructor(t=new Lt,r=new Lt,n=new Lt,i=new Lt){super(),this.type="CubicBezierCurve",this.v0=t,this.v1=r,this.v2=n,this.v3=i}getPoint(t,r=new Lt){let n=r,i=this.v0,o=this.v1,a=this.v2,s=this.v3;return n.set(WP(t,i.x,o.x,a.x,s.x),WP(t,i.y,o.y,a.y,s.y)),n}copy(t){return super.copy(t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this.v3.copy(t.v3),this}toJSON(){let t=super.toJSON();return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t.v3=this.v3.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this.v3.fromArray(t.v3),this}};cM.prototype.isCubicBezierCurve=!0;var u6=class extends fs{constructor(t=new j,r=new j,n=new j,i=new j){super(),this.type="CubicBezierCurve3",this.v0=t,this.v1=r,this.v2=n,this.v3=i}getPoint(t,r=new j){let n=r,i=this.v0,o=this.v1,a=this.v2,s=this.v3;return n.set(WP(t,i.x,o.x,a.x,s.x),WP(t,i.y,o.y,a.y,s.y),WP(t,i.z,o.z,a.z,s.z)),n}copy(t){return super.copy(t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this.v3.copy(t.v3),this}toJSON(){let t=super.toJSON();return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t.v3=this.v3.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this.v3.fromArray(t.v3),this}};u6.prototype.isCubicBezierCurve3=!0;var U1=class extends fs{constructor(t=new Lt,r=new Lt){super(),this.type="LineCurve",this.v1=t,this.v2=r}getPoint(t,r=new Lt){let n=r;return t===1?n.copy(this.v2):(n.copy(this.v2).sub(this.v1),n.multiplyScalar(t).add(this.v1)),n}getPointAt(t,r){return this.getPoint(t,r)}getTangent(t,r){let n=r||new Lt;return n.copy(this.v2).sub(this.v1).normalize(),n}copy(t){return super.copy(t),this.v1.copy(t.v1),this.v2.copy(t.v2),this}toJSON(){let t=super.toJSON();return t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this}};U1.prototype.isLineCurve=!0;var bU=class extends fs{constructor(t=new j,r=new j){super(),this.type="LineCurve3",this.isLineCurve3=!0,this.v1=t,this.v2=r}getPoint(t,r=new j){let n=r;return t===1?n.copy(this.v2):(n.copy(this.v2).sub(this.v1),n.multiplyScalar(t).add(this.v1)),n}getPointAt(t,r){return this.getPoint(t,r)}copy(t){return super.copy(t),this.v1.copy(t.v1),this.v2.copy(t.v2),this}toJSON(){let t=super.toJSON();return t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this}},uM=class extends fs{constructor(t=new Lt,r=new Lt,n=new Lt){super(),this.type="QuadraticBezierCurve",this.v0=t,this.v1=r,this.v2=n}getPoint(t,r=new Lt){let n=r,i=this.v0,o=this.v1,a=this.v2;return n.set(GP(t,i.x,o.x,a.x),GP(t,i.y,o.y,a.y)),n}copy(t){return super.copy(t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this}toJSON(){let t=super.toJSON();return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this}};uM.prototype.isQuadraticBezierCurve=!0;var hM=class extends fs{constructor(t=new j,r=new j,n=new j){super(),this.type="QuadraticBezierCurve3",this.v0=t,this.v1=r,this.v2=n}getPoint(t,r=new j){let n=r,i=this.v0,o=this.v1,a=this.v2;return n.set(GP(t,i.x,o.x,a.x),GP(t,i.y,o.y,a.y),GP(t,i.z,o.z,a.z)),n}copy(t){return super.copy(t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this}toJSON(){let t=super.toJSON();return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this}};hM.prototype.isQuadraticBezierCurve3=!0;var fM=class extends fs{constructor(t=[]){super(),this.type="SplineCurve",this.points=t}getPoint(t,r=new Lt){let n=r,i=this.points,o=(i.length-1)*t,a=Math.floor(o),s=o-a,l=i[a===0?a:a-1],c=i[a],u=i[a>i.length-2?i.length-1:a+1],h=i[a>i.length-3?i.length-1:a+2];return n.set(dhe(s,l.x,c.x,u.x,h.x),dhe(s,l.y,c.y,u.y,h.y)),n}copy(t){super.copy(t),this.points=[];for(let r=0,n=t.points.length;r<n;r++){let i=t.points[r];this.points.push(i.clone())}return this}toJSON(){let t=super.toJSON();t.points=[];for(let r=0,n=this.points.length;r<n;r++){let i=this.points[r];t.points.push(i.toArray())}return t}fromJSON(t){super.fromJSON(t),this.points=[];for(let r=0,n=t.points.length;r<n;r++){let i=t.points[r];this.points.push(new Lt().fromArray(i))}return this}};fM.prototype.isSplineCurve=!0;var Oht=Object.freeze({__proto__:null,ArcCurve:l6,CatmullRomCurve3:c6,CubicBezierCurve:cM,CubicBezierCurve3:u6,EllipseCurve:V1,LineCurve:U1,LineCurve3:bU,QuadraticBezierCurve:uM,QuadraticBezierCurve3:hM,SplineCurve:fM}),wU=class extends fs{constructor(){super(),this.type="CurvePath",this.curves=[],this.autoClose=!1}add(t){this.curves.push(t)}closePath(){let t=this.curves[0].getPoint(0),r=this.curves[this.curves.length-1].getPoint(1);t.equals(r)||this.curves.push(new U1(r,t))}getPoint(t,r){let n=t*this.getLength(),i=this.getCurveLengths(),o=0;for(;o<i.length;){if(i[o]>=n){let a=i[o]-n,s=this.curves[o],l=s.getLength(),c=l===0?0:1-a/l;return s.getPointAt(c,r)}o++}return null}getLength(){let t=this.getCurveLengths();return t[t.length-1]}updateArcLengths(){this.needsUpdate=!0,this.cacheLengths=null,this.getCurveLengths()}getCurveLengths(){if(this.cacheLengths&&this.cacheLengths.length===this.curves.length)return this.cacheLengths;let t=[],r=0;for(let n=0,i=this.curves.length;n<i;n++)r+=this.curves[n].getLength(),t.push(r);return this.cacheLengths=t,t}getSpacedPoints(t=40){let r=[];for(let n=0;n<=t;n++)r.push(this.getPoint(n/t));return this.autoClose&&r.push(r[0]),r}getPoints(t=12){let r=[],n;for(let i=0,o=this.curves;i<o.length;i++){let a=o[i],s=a&&a.isEllipseCurve?t*2:a&&(a.isLineCurve||a.isLineCurve3)?1:a&&a.isSplineCurve?t*a.points.length:t,l=a.getPoints(s);for(let c=0;c<l.length;c++){let u=l[c];n&&n.equals(u)||(r.push(u),n=u)}}return this.autoClose&&r.length>1&&!r[r.length-1].equals(r[0])&&r.push(r[0]),r}copy(t){super.copy(t),this.curves=[];for(let r=0,n=t.curves.length;r<n;r++){let i=t.curves[r];this.curves.push(i.clone())}return this.autoClose=t.autoClose,this}toJSON(){let t=super.toJSON();t.autoClose=this.autoClose,t.curves=[];for(let r=0,n=this.curves.length;r<n;r++){let i=this.curves[r];t.curves.push(i.toJSON())}return t}fromJSON(t){super.fromJSON(t),this.autoClose=t.autoClose,this.curves=[];for(let r=0,n=t.curves.length;r<n;r++){let i=t.curves[r];this.curves.push(new Oht[i.type]().fromJSON(i))}return this}},q1=class extends wU{constructor(t){super(),this.type="Path",this.currentPoint=new Lt,t&&this.setFromPoints(t)}setFromPoints(t){this.moveTo(t[0].x,t[0].y);for(let r=1,n=t.length;r<n;r++)this.lineTo(t[r].x,t[r].y);return this}moveTo(t,r){return this.currentPoint.set(t,r),this}lineTo(t,r){let n=new U1(this.currentPoint.clone(),new Lt(t,r));return this.curves.push(n),this.currentPoint.set(t,r),this}quadraticCurveTo(t,r,n,i){let o=new uM(this.currentPoint.clone(),new Lt(t,r),new Lt(n,i));return this.curves.push(o),this.currentPoint.set(n,i),this}bezierCurveTo(t,r,n,i,o,a){let s=new cM(this.currentPoint.clone(),new Lt(t,r),new Lt(n,i),new Lt(o,a));return this.curves.push(s),this.currentPoint.set(o,a),this}splineThru(t){let r=[this.currentPoint.clone()].concat(t),n=new fM(r);return this.curves.push(n),this.currentPoint.copy(t[t.length-1]),this}arc(t,r,n,i,o,a){let s=this.currentPoint.x,l=this.currentPoint.y;return this.absarc(t+s,r+l,n,i,o,a),this}absarc(t,r,n,i,o,a){return this.absellipse(t,r,n,n,i,o,a),this}ellipse(t,r,n,i,o,a,s,l){let c=this.currentPoint.x,u=this.currentPoint.y;return this.absellipse(t+c,r+u,n,i,o,a,s,l),this}absellipse(t,r,n,i,o,a,s,l){let c=new V1(t,r,n,i,o,a,s,l);if(this.curves.length>0){let h=c.getPoint(0);h.equals(this.currentPoint)||this.lineTo(h.x,h.y)}this.curves.push(c);let u=c.getPoint(1);return this.currentPoint.copy(u),this}copy(t){return super.copy(t),this.currentPoint.copy(t.currentPoint),this}toJSON(){let t=super.toJSON();return t.currentPoint=this.currentPoint.toArray(),t}fromJSON(t){return super.fromJSON(t),this.currentPoint.fromArray(t.currentPoint),this}},Kc=class extends q1{constructor(t){super(t),this.uuid=Nl(),this.type="Shape",this.holes=[]}getPointsHoles(t){let r=[];for(let n=0,i=this.holes.length;n<i;n++)r[n]=this.holes[n].getPoints(t);return r}extractPoints(t){return{shape:this.getPoints(t),holes:this.getPointsHoles(t)}}copy(t){super.copy(t),this.holes=[];for(let r=0,n=t.holes.length;r<n;r++){let i=t.holes[r];this.holes.push(i.clone())}return this}toJSON(){let t=super.toJSON();t.uuid=this.uuid,t.holes=[];for(let r=0,n=this.holes.length;r<n;r++){let i=this.holes[r];t.holes.push(i.toJSON())}return t}fromJSON(t){super.fromJSON(t),this.uuid=t.uuid,this.holes=[];for(let r=0,n=t.holes.length;r<n;r++){let i=t.holes[r];this.holes.push(new q1().fromJSON(i))}return this}},Ggr={triangulate:function(e,t,r=2){let n=t&&t.length,i=n?t[0]*r:e.length,o=epe(e,0,i,r,!0),a=[];if(!o||o.next===o.prev)return a;let s,l,c,u,h,f,p;if(n&&(o=$gr(e,t,o,r)),e.length>80*r){s=c=e[0],l=u=e[1];for(let d=r;d<i;d+=r)h=e[d],f=e[d+1],h<s&&(s=h),f<l&&(l=f),h>c&&(c=h),f>u&&(u=f);p=Math.max(c-s,u-l),p=p!==0?1/p:0}return h6(o,a,r,s,l,p),a}};function epe(e,t,r,n,i){let o,a;if(i===a0r(e,t,r,n)>0)for(o=t;o<r;o+=n)a=mhe(o,e[o],e[o+1],a);else for(o=r-n;o>=t;o-=n)a=mhe(o,e[o],e[o+1],a);return a&&ZU(a,a.next)&&(p6(a),a=a.next),a}function G0(e,t){if(!e)return e;t||(t=e);let r=e,n;do if(n=!1,!r.steiner&&(ZU(r,r.next)||ai(r.prev,r,r.next)===0)){if(p6(r),r=t=r.prev,r===r.next)break;n=!0}else r=r.next;while(n||r!==t);return t}function h6(e,t,r,n,i,o,a){if(!e)return;!a&&o&&t0r(e,n,i,o);let s=e,l,c;for(;e.prev!==e.next;){if(l=e.prev,c=e.next,o?Ygr(e,n,i,o):Wgr(e)){t.push(l.i/r),t.push(e.i/r),t.push(c.i/r),p6(e),e=c.next,s=c.next;continue}if(e=c,e===s){a?a===1?(e=jgr(G0(e),t,r),h6(e,t,r,n,i,o,2)):a===2&&Xgr(e,t,r,n,i,o):h6(G0(e),t,r,n,i,o,1);break}}}function Wgr(e){let t=e.prev,r=e,n=e.next;if(ai(t,r,n)>=0)return!1;let i=e.next.next;for(;i!==e.prev;){if(H3(t.x,t.y,r.x,r.y,n.x,n.y,i.x,i.y)&&ai(i.prev,i,i.next)>=0)return!1;i=i.next}return!0}function Ygr(e,t,r,n){let i=e.prev,o=e,a=e.next;if(ai(i,o,a)>=0)return!1;let s=i.x<o.x?i.x<a.x?i.x:a.x:o.x<a.x?o.x:a.x,l=i.y<o.y?i.y<a.y?i.y:a.y:o.y<a.y?o.y:a.y,c=i.x>o.x?i.x>a.x?i.x:a.x:o.x>a.x?o.x:a.x,u=i.y>o.y?i.y>a.y?i.y:a.y:o.y>a.y?o.y:a.y,h=nht(s,l,t,r,n),f=nht(c,u,t,r,n),p=e.prevZ,d=e.nextZ;for(;p&&p.z>=h&&d&&d.z<=f;){if(p!==e.prev&&p!==e.next&&H3(i.x,i.y,o.x,o.y,a.x,a.y,p.x,p.y)&&ai(p.prev,p,p.next)>=0||(p=p.prevZ,d!==e.prev&&d!==e.next&&H3(i.x,i.y,o.x,o.y,a.x,a.y,d.x,d.y)&&ai(d.prev,d,d.next)>=0))return!1;d=d.nextZ}for(;p&&p.z>=h;){if(p!==e.prev&&p!==e.next&&H3(i.x,i.y,o.x,o.y,a.x,a.y,p.x,p.y)&&ai(p.prev,p,p.next)>=0)return!1;p=p.prevZ}for(;d&&d.z<=f;){if(d!==e.prev&&d!==e.next&&H3(i.x,i.y,o.x,o.y,a.x,a.y,d.x,d.y)&&ai(d.prev,d,d.next)>=0)return!1;d=d.nextZ}return!0}function jgr(e,t,r){let n=e;do{let i=n.prev,o=n.next.next;!ZU(i,o)&&rpe(i,n,n.next,o)&&f6(i,o)&&f6(o,i)&&(t.push(i.i/r),t.push(n.i/r),t.push(o.i/r),p6(n),p6(n.next),n=e=o),n=n.next}while(n!==e);return G0(n)}function Xgr(e,t,r,n,i,o){let a=e;do{let s=a.next.next;for(;s!==a.prev;){if(a.i!==s.i&&n0r(a,s)){let l=npe(a,s);a=G0(a,a.next),l=G0(l,l.next),h6(a,t,r,n,i,o),h6(l,t,r,n,i,o);return}s=s.next}a=a.next}while(a!==e)}function $gr(e,t,r,n){let i=[],o,a,s,l,c;for(o=0,a=t.length;o<a;o++)s=t[o]*n,l=o<a-1?t[o+1]*n:e.length,c=epe(e,s,l,n,!1),c===c.next&&(c.steiner=!0),i.push(r0r(c));for(i.sort(Kgr),o=0;o<i.length;o++)Zgr(i[o],r),r=G0(r,r.next);return r}function Kgr(e,t){return e.x-t.x}function Zgr(e,t){if(t=Jgr(e,t),t){let r=npe(t,e);G0(t,t.next),G0(r,r.next)}}function Jgr(e,t){let r=t,n=e.x,i=e.y,o=-1/0,a;do{if(i<=r.y&&i>=r.next.y&&r.next.y!==r.y){let f=r.x+(i-r.y)*(r.next.x-r.x)/(r.next.y-r.y);if(f<=n&&f>o){if(o=f,f===n){if(i===r.y)return r;if(i===r.next.y)return r.next}a=r.x<r.next.x?r:r.next}}r=r.next}while(r!==t);if(!a)return null;if(n===o)return a;let s=a,l=a.x,c=a.y,u=1/0,h;r=a;do n>=r.x&&r.x>=l&&n!==r.x&&H3(i<c?n:o,i,l,c,i<c?o:n,i,r.x,r.y)&&(h=Math.abs(i-r.y)/(n-r.x),f6(r,e)&&(h<u||h===u&&(r.x>a.x||r.x===a.x&&Qgr(a,r)))&&(a=r,u=h)),r=r.next;while(r!==s);return a}function Qgr(e,t){return ai(e.prev,e,t.prev)<0&&ai(t.next,e,e.next)<0}function t0r(e,t,r,n){let i=e;do i.z===null&&(i.z=nht(i.x,i.y,t,r,n)),i.prevZ=i.prev,i.nextZ=i.next,i=i.next;while(i!==e);i.prevZ.nextZ=null,i.prevZ=null,e0r(i)}function e0r(e){let t,r,n,i,o,a,s,l,c=1;do{for(r=e,e=null,o=null,a=0;r;){for(a++,n=r,s=0,t=0;t<c&&(s++,n=n.nextZ,!!n);t++);for(l=c;s>0||l>0&&n;)s!==0&&(l===0||!n||r.z<=n.z)?(i=r,r=r.nextZ,s--):(i=n,n=n.nextZ,l--),o?o.nextZ=i:e=i,i.prevZ=o,o=i;r=n}o.nextZ=null,c*=2}while(a>1);return e}function nht(e,t,r,n,i){return e=32767*(e-r)*i,t=32767*(t-n)*i,e=(e|e<<8)&16711935,e=(e|e<<4)&252645135,e=(e|e<<2)&858993459,e=(e|e<<1)&1431655765,t=(t|t<<8)&16711935,t=(t|t<<4)&252645135,t=(t|t<<2)&858993459,t=(t|t<<1)&1431655765,e|t<<1}function r0r(e){let t=e,r=e;do(t.x<r.x||t.x===r.x&&t.y<r.y)&&(r=t),t=t.next;while(t!==e);return r}function H3(e,t,r,n,i,o,a,s){return(i-a)*(t-s)-(e-a)*(o-s)>=0&&(e-a)*(n-s)-(r-a)*(t-s)>=0&&(r-a)*(o-s)-(i-a)*(n-s)>=0}function n0r(e,t){return e.next.i!==t.i&&e.prev.i!==t.i&&!i0r(e,t)&&(f6(e,t)&&f6(t,e)&&o0r(e,t)&&(ai(e.prev,e,t.prev)||ai(e,t.prev,t))||ZU(e,t)&&ai(e.prev,e,e.next)>0&&ai(t.prev,t,t.next)>0)}function ai(e,t,r){return(t.y-e.y)*(r.x-t.x)-(t.x-e.x)*(r.y-t.y)}function ZU(e,t){return e.x===t.x&&e.y===t.y}function rpe(e,t,r,n){let i=GV(ai(e,t,r)),o=GV(ai(e,t,n)),a=GV(ai(r,n,e)),s=GV(ai(r,n,t));return!!(i!==o&&a!==s||i===0&&qV(e,r,t)||o===0&&qV(e,n,t)||a===0&&qV(r,e,n)||s===0&&qV(r,t,n))}function qV(e,t,r){return t.x<=Math.max(e.x,r.x)&&t.x>=Math.min(e.x,r.x)&&t.y<=Math.max(e.y,r.y)&&t.y>=Math.min(e.y,r.y)}function GV(e){return e>0?1:e<0?-1:0}function i0r(e,t){let r=e;do{if(r.i!==e.i&&r.next.i!==e.i&&r.i!==t.i&&r.next.i!==t.i&&rpe(r,r.next,e,t))return!0;r=r.next}while(r!==e);return!1}function f6(e,t){return ai(e.prev,e,e.next)<0?ai(e,t,e.next)>=0&&ai(e,e.prev,t)>=0:ai(e,t,e.prev)<0||ai(e,e.next,t)<0}function o0r(e,t){let r=e,n=!1,i=(e.x+t.x)/2,o=(e.y+t.y)/2;do r.y>o!=r.next.y>o&&r.next.y!==r.y&&i<(r.next.x-r.x)*(o-r.y)/(r.next.y-r.y)+r.x&&(n=!n),r=r.next;while(r!==e);return n}function npe(e,t){let r=new iht(e.i,e.x,e.y),n=new iht(t.i,t.x,t.y),i=e.next,o=t.prev;return e.next=t,t.prev=e,r.next=i,i.prev=r,n.next=r,r.prev=n,o.next=n,n.prev=o,n}function mhe(e,t,r,n){let i=new iht(e,t,r);return n?(i.next=n.next,i.prev=n,n.next.prev=i,n.next=i):(i.prev=i,i.next=i),i}function p6(e){e.next.prev=e.prev,e.prev.next=e.next,e.prevZ&&(e.prevZ.nextZ=e.nextZ),e.nextZ&&(e.nextZ.prevZ=e.prevZ)}function iht(e,t,r){this.i=e,this.x=t,this.y=r,this.prev=null,this.next=null,this.z=null,this.prevZ=null,this.nextZ=null,this.steiner=!1}function a0r(e,t,r,n){let i=0;for(let o=t,a=r-n;o<r;o+=n)i+=(e[a]-e[o])*(e[o+1]+e[a+1]),a=o;return i}var Zc=class{static area(t){let r=t.length,n=0;for(let i=r-1,o=0;o<r;i=o++)n+=t[i].x*t[o].y-t[o].x*t[i].y;return n*.5}static isClockWise(t){return Zc.area(t)<0}static triangulateShape(t,r){let n=[],i=[],o=[];ghe(t),_he(n,t);let a=t.length;r.forEach(ghe);for(let l=0;l<r.length;l++)i.push(a),a+=r[l].length,_he(n,r[l]);let s=Ggr.triangulate(n,i);for(let l=0;l<s.length;l+=3)o.push(s.slice(l,l+3));return o}};function ghe(e){let t=e.length;t>2&&e[t-1].equals(e[0])&&e.pop()}function _he(e,t){for(let r=0;r<t.length;r++)e.push(t[r].x),e.push(t[r].y)}var hh=class extends Pe{constructor(t=new Kc([new Lt(.5,.5),new Lt(-.5,.5),new Lt(-.5,-.5),new Lt(.5,-.5)]),r={}){super(),this.type="ExtrudeGeometry",this.parameters={shapes:t,options:r},t=Array.isArray(t)?t:[t];let n=this,i=[],o=[];for(let s=0,l=t.length;s<l;s++){let c=t[s];a(c)}this.setAttribute("position",new xe(i,3)),this.setAttribute("uv",new xe(o,2)),this.computeVertexNormals();function a(s){let l=[],c=r.curveSegments!==void 0?r.curveSegments:12,u=r.steps!==void 0?r.steps:1,h=r.depth!==void 0?r.depth:1,f=r.bevelEnabled!==void 0?r.bevelEnabled:!0,p=r.bevelThickness!==void 0?r.bevelThickness:.2,d=r.bevelSize!==void 0?r.bevelSize:p-.1,g=r.bevelOffset!==void 0?r.bevelOffset:0,_=r.bevelSegments!==void 0?r.bevelSegments:3,y=r.extrudePath,x=r.UVGenerator!==void 0?r.UVGenerator:s0r;r.amount!==void 0&&(console.warn("THREE.ExtrudeBufferGeometry: amount has been renamed to depth."),h=r.amount);let b,S=!1,C,P,k,O;y&&(b=y.getSpacedPoints(u),S=!0,f=!1,C=y.computeFrenetFrames(u,!1),P=new j,k=new j,O=new j),f||(_=0,p=0,d=0,g=0);let D=s.extractPoints(c),B=D.shape,I=D.holes;if(!Zc.isClockWise(B)){B=B.reverse();for(let q=0,pt=I.length;q<pt;q++){let ht=I[q];Zc.isClockWise(ht)&&(I[q]=ht.reverse())}}let R=Zc.triangulateShape(B,I),F=B;for(let q=0,pt=I.length;q<pt;q++){let ht=I[q];B=B.concat(ht)}function z(q,pt,ht){return pt||console.error("THREE.ExtrudeGeometry: vec does not exist"),pt.clone().multiplyScalar(ht).add(q)}let U=B.length,W=R.length;function Z(q,pt,ht){let wt,kt,ie,ee=q.x-pt.x,Le=q.y-pt.y,ar=ht.x-q.x,fr=ht.y-q.y,tt=ee*ee+Le*Le,$=ee*fr-Le*ar;if(Math.abs($)>Number.EPSILON){let It=Math.sqrt(tt),$t=Math.sqrt(ar*ar+fr*fr),he=pt.x-Le/It,Tt=pt.y+ee/It,be=ht.x-fr/$t,nt=ht.y+ar/$t,Ct=((be-he)*fr-(nt-Tt)*ar)/(ee*fr-Le*ar);wt=he+ee*Ct-q.x,kt=Tt+Le*Ct-q.y;let Wt=wt*wt+kt*kt;if(Wt<=2)return new Lt(wt,kt);ie=Math.sqrt(Wt/2)}else{let It=!1;ee>Number.EPSILON?ar>Number.EPSILON&&(It=!0):ee<-Number.EPSILON?ar<-Number.EPSILON&&(It=!0):Math.sign(Le)===Math.sign(fr)&&(It=!0),It?(wt=-Le,kt=ee,ie=Math.sqrt(tt)):(wt=ee,kt=Le,ie=Math.sqrt(tt/2))}return new Lt(wt/ie,kt/ie)}let rt=[];for(let q=0,pt=F.length,ht=pt-1,wt=q+1;q<pt;q++,ht++,wt++)ht===pt&&(ht=0),wt===pt&&(wt=0),rt[q]=Z(F[q],F[ht],F[wt]);let ot=[],st,St=rt.concat();for(let q=0,pt=I.length;q<pt;q++){let ht=I[q];st=[];for(let wt=0,kt=ht.length,ie=kt-1,ee=wt+1;wt<kt;wt++,ie++,ee++)ie===kt&&(ie=0),ee===kt&&(ee=0),st[wt]=Z(ht[wt],ht[ie],ht[ee]);ot.push(st),St=St.concat(st)}for(let q=0;q<_;q++){let pt=q/_,ht=p*Math.cos(pt*Math.PI/2),wt=d*Math.sin(pt*Math.PI/2)+g;for(let kt=0,ie=F.length;kt<ie;kt++){let ee=z(F[kt],rt[kt],wt);_t(ee.x,ee.y,-ht)}for(let kt=0,ie=I.length;kt<ie;kt++){let ee=I[kt];st=ot[kt];for(let Le=0,ar=ee.length;Le<ar;Le++){let fr=z(ee[Le],st[Le],wt);_t(fr.x,fr.y,-ht)}}}let bt=d+g;for(let q=0;q<U;q++){let pt=f?z(B[q],St[q],bt):B[q];S?(k.copy(C.normals[0]).multiplyScalar(pt.x),P.copy(C.binormals[0]).multiplyScalar(pt.y),O.copy(b[0]).add(k).add(P),_t(O.x,O.y,O.z)):_t(pt.x,pt.y,0)}for(let q=1;q<=u;q++)for(let pt=0;pt<U;pt++){let ht=f?z(B[pt],St[pt],bt):B[pt];S?(k.copy(C.normals[q]).multiplyScalar(ht.x),P.copy(C.binormals[q]).multiplyScalar(ht.y),O.copy(b[q]).add(k).add(P),_t(O.x,O.y,O.z)):_t(ht.x,ht.y,h/u*q)}for(let q=_-1;q>=0;q--){let pt=q/_,ht=p*Math.cos(pt*Math.PI/2),wt=d*Math.sin(pt*Math.PI/2)+g;for(let kt=0,ie=F.length;kt<ie;kt++){let ee=z(F[kt],rt[kt],wt);_t(ee.x,ee.y,h+ht)}for(let kt=0,ie=I.length;kt<ie;kt++){let ee=I[kt];st=ot[kt];for(let Le=0,ar=ee.length;Le<ar;Le++){let fr=z(ee[Le],st[Le],wt);S?_t(fr.x,fr.y+b[u-1].y,b[u-1].x+ht):_t(fr.x,fr.y,h+ht)}}}Mt(),lt();function Mt(){let q=i.length/3;if(f){let pt=0,ht=U*pt;for(let wt=0;wt<W;wt++){let kt=R[wt];ct(kt[2]+ht,kt[1]+ht,kt[0]+ht)}pt=u+_*2,ht=U*pt;for(let wt=0;wt<W;wt++){let kt=R[wt];ct(kt[0]+ht,kt[1]+ht,kt[2]+ht)}}else{for(let pt=0;pt<W;pt++){let ht=R[pt];ct(ht[2],ht[1],ht[0])}for(let pt=0;pt<W;pt++){let ht=R[pt];ct(ht[0]+U*u,ht[1]+U*u,ht[2]+U*u)}}n.addGroup(q,i.length/3-q,0)}function lt(){let q=i.length/3,pt=0;Kt(F,pt),pt+=F.length;for(let ht=0,wt=I.length;ht<wt;ht++){let kt=I[ht];Kt(kt,pt),pt+=kt.length}n.addGroup(q,i.length/3-q,1)}function Kt(q,pt){let ht=q.length;for(;--ht>=0;){let wt=ht,kt=ht-1;kt<0&&(kt=q.length-1);for(let ie=0,ee=u+_*2;ie<ee;ie++){let Le=U*ie,ar=U*(ie+1),fr=pt+wt+Le,tt=pt+kt+Le,$=pt+kt+ar,It=pt+wt+ar;X(fr,tt,$,It)}}}function _t(q,pt,ht){l.push(q),l.push(pt),l.push(ht)}function ct(q,pt,ht){et(q),et(pt),et(ht);let wt=i.length/3,kt=x.generateTopUV(n,i,wt-3,wt-2,wt-1);dt(kt[0]),dt(kt[1]),dt(kt[2])}function X(q,pt,ht,wt){et(q),et(pt),et(wt),et(pt),et(ht),et(wt);let kt=i.length/3,ie=x.generateSideWallUV(n,i,kt-6,kt-3,kt-2,kt-1);dt(ie[0]),dt(ie[1]),dt(ie[3]),dt(ie[1]),dt(ie[2]),dt(ie[3])}function et(q){i.push(l[q*3+0]),i.push(l[q*3+1]),i.push(l[q*3+2])}function dt(q){o.push(q.x),o.push(q.y)}}}toJSON(){let t=super.toJSON(),r=this.parameters.shapes,n=this.parameters.options;return l0r(r,n,t)}static fromJSON(t,r){let n=[];for(let o=0,a=t.shapes.length;o<a;o++){let s=r[t.shapes[o]];n.push(s)}let i=t.options.extrudePath;return i!==void 0&&(t.options.extrudePath=new Oht[i.type]().fromJSON(i)),new hh(n,t.options)}},s0r={generateTopUV:function(e,t,r,n,i){let o=t[r*3],a=t[r*3+1],s=t[n*3],l=t[n*3+1],c=t[i*3],u=t[i*3+1];return[new Lt(o,a),new Lt(s,l),new Lt(c,u)]},generateSideWallUV:function(e,t,r,n,i,o){let a=t[r*3],s=t[r*3+1],l=t[r*3+2],c=t[n*3],u=t[n*3+1],h=t[n*3+2],f=t[i*3],p=t[i*3+1],d=t[i*3+2],g=t[o*3],_=t[o*3+1],y=t[o*3+2];return Math.abs(s-u)<Math.abs(a-c)?[new Lt(a,1-l),new Lt(c,1-h),new Lt(f,1-d),new Lt(g,1-y)]:[new Lt(s,1-l),new Lt(u,1-h),new Lt(p,1-d),new Lt(_,1-y)]}};function l0r(e,t,r){if(r.shapes=[],Array.isArray(e))for(let n=0,i=e.length;n<i;n++){let o=e[n];r.shapes.push(o.uuid)}else r.shapes.push(e.uuid);return t.extrudePath!==void 0&&(r.options.extrudePath=t.extrudePath.toJSON()),r}var G1=class extends uh{constructor(t=1,r=0){let n=(1+Math.sqrt(5))/2,i=[-1,n,0,1,n,0,-1,-n,0,1,-n,0,0,-1,n,0,1,n,0,-1,-n,0,1,-n,n,0,-1,n,0,1,-n,0,-1,-n,0,1],o=[0,11,5,0,5,1,0,1,7,0,7,10,0,10,11,1,5,9,5,11,4,11,10,2,10,7,6,7,1,8,3,9,4,3,4,2,3,2,6,3,6,8,3,8,9,4,9,5,2,4,11,6,2,10,8,6,7,9,8,1];super(i,o,t,r),this.type="IcosahedronGeometry",this.parameters={radius:t,detail:r}}static fromJSON(t){return new G1(t.radius,t.detail)}},W1=class extends Pe{constructor(t=[new Lt(0,.5),new Lt(.5,0),new Lt(0,-.5)],r=12,n=0,i=Math.PI*2){super(),this.type="LatheGeometry",this.parameters={points:t,segments:r,phiStart:n,phiLength:i},r=Math.floor(r),i=Zo(i,0,Math.PI*2);let o=[],a=[],s=[],l=[],c=[],u=1/r,h=new j,f=new Lt,p=new j,d=new j,g=new j,_=0,y=0;for(let x=0;x<=t.length-1;x++)switch(x){case 0:_=t[x+1].x-t[x].x,y=t[x+1].y-t[x].y,p.x=y*1,p.y=-_,p.z=y*0,g.copy(p),p.normalize(),l.push(p.x,p.y,p.z);break;case t.length-1:l.push(g.x,g.y,g.z);break;default:_=t[x+1].x-t[x].x,y=t[x+1].y-t[x].y,p.x=y*1,p.y=-_,p.z=y*0,d.copy(p),p.x+=g.x,p.y+=g.y,p.z+=g.z,p.normalize(),l.push(p.x,p.y,p.z),g.copy(d)}for(let x=0;x<=r;x++){let b=n+x*u*i,S=Math.sin(b),C=Math.cos(b);for(let P=0;P<=t.length-1;P++){h.x=t[P].x*S,h.y=t[P].y,h.z=t[P].x*C,a.push(h.x,h.y,h.z),f.x=x/r,f.y=P/(t.length-1),s.push(f.x,f.y);let k=l[3*P+0]*S,O=l[3*P+1],D=l[3*P+0]*C;c.push(k,O,D)}}for(let x=0;x<r;x++)for(let b=0;b<t.length-1;b++){let S=b+x*t.length,C=S,P=S+t.length,k=S+t.length+1,O=S+1;o.push(C,P,O),o.push(k,O,P)}this.setIndex(o),this.setAttribute("position",new xe(a,3)),this.setAttribute("uv",new xe(s,2)),this.setAttribute("normal",new xe(c,3))}static fromJSON(t){return new W1(t.points,t.segments,t.phiStart,t.phiLength)}},W0=class extends uh{constructor(t=1,r=0){let n=[1,0,0,-1,0,0,0,1,0,0,-1,0,0,0,1,0,0,-1],i=[0,2,4,0,4,3,0,3,5,0,5,2,1,2,5,1,5,3,1,3,4,1,4,2];super(n,i,t,r),this.type="OctahedronGeometry",this.parameters={radius:t,detail:r}}static fromJSON(t){return new W0(t.radius,t.detail)}},Y1=class extends Pe{constructor(t=.5,r=1,n=8,i=1,o=0,a=Math.PI*2){super(),this.type="RingGeometry",this.parameters={innerRadius:t,outerRadius:r,thetaSegments:n,phiSegments:i,thetaStart:o,thetaLength:a},n=Math.max(3,n),i=Math.max(1,i);let s=[],l=[],c=[],u=[],h=t,f=(r-t)/i,p=new j,d=new Lt;for(let g=0;g<=i;g++){for(let _=0;_<=n;_++){let y=o+_/n*a;p.x=h*Math.cos(y),p.y=h*Math.sin(y),l.push(p.x,p.y,p.z),c.push(0,0,1),d.x=(p.x/r+1)/2,d.y=(p.y/r+1)/2,u.push(d.x,d.y)}h+=f}for(let g=0;g<i;g++){let _=g*(n+1);for(let y=0;y<n;y++){let x=y+_,b=x,S=x+n+1,C=x+n+2,P=x+1;s.push(b,S,P),s.push(S,C,P)}}this.setIndex(s),this.setAttribute("position",new xe(l,3)),this.setAttribute("normal",new xe(c,3)),this.setAttribute("uv",new xe(u,2))}static fromJSON(t){return new Y1(t.innerRadius,t.outerRadius,t.thetaSegments,t.phiSegments,t.thetaStart,t.thetaLength)}},Y0=class extends Pe{constructor(t=new Kc([new Lt(0,.5),new Lt(-.5,-.5),new Lt(.5,-.5)]),r=12){super(),this.type="ShapeGeometry",this.parameters={shapes:t,curveSegments:r};let n=[],i=[],o=[],a=[],s=0,l=0;if(Array.isArray(t)===!1)c(t);else for(let u=0;u<t.length;u++)c(t[u]),this.addGroup(s,l,u),s+=l,l=0;this.setIndex(n),this.setAttribute("position",new xe(i,3)),this.setAttribute("normal",new xe(o,3)),this.setAttribute("uv",new xe(a,2));function c(u){let h=i.length/3,f=u.extractPoints(r),p=f.shape,d=f.holes;Zc.isClockWise(p)===!1&&(p=p.reverse());for(let _=0,y=d.length;_<y;_++){let x=d[_];Zc.isClockWise(x)===!0&&(d[_]=x.reverse())}let g=Zc.triangulateShape(p,d);for(let _=0,y=d.length;_<y;_++){let x=d[_];p=p.concat(x)}for(let _=0,y=p.length;_<y;_++){let x=p[_];i.push(x.x,x.y,0),o.push(0,0,1),a.push(x.x,x.y)}for(let _=0,y=g.length;_<y;_++){let x=g[_],b=x[0]+h,S=x[1]+h,C=x[2]+h;n.push(b,S,C),l+=3}}}toJSON(){let t=super.toJSON(),r=this.parameters.shapes;return c0r(r,t)}static fromJSON(t,r){let n=[];for(let i=0,o=t.shapes.length;i<o;i++){let a=r[t.shapes[i]];n.push(a)}return new Y0(n,t.curveSegments)}};function c0r(e,t){if(t.shapes=[],Array.isArray(e))for(let r=0,n=e.length;r<n;r++){let i=e[r];t.shapes.push(i.uuid)}else t.shapes.push(e.uuid);return t}var j0=class extends Pe{constructor(t=1,r=32,n=16,i=0,o=Math.PI*2,a=0,s=Math.PI){super(),this.type="SphereGeometry",this.parameters={radius:t,widthSegments:r,heightSegments:n,phiStart:i,phiLength:o,thetaStart:a,thetaLength:s},r=Math.max(3,Math.floor(r)),n=Math.max(2,Math.floor(n));let l=Math.min(a+s,Math.PI),c=0,u=[],h=new j,f=new j,p=[],d=[],g=[],_=[];for(let y=0;y<=n;y++){let x=[],b=y/n,S=0;y==0&&a==0?S=.5/r:y==n&&l==Math.PI&&(S=-.5/r);for(let C=0;C<=r;C++){let P=C/r;h.x=-t*Math.cos(i+P*o)*Math.sin(a+b*s),h.y=t*Math.cos(a+b*s),h.z=t*Math.sin(i+P*o)*Math.sin(a+b*s),d.push(h.x,h.y,h.z),f.copy(h).normalize(),g.push(f.x,f.y,f.z),_.push(P+S,1-b),x.push(c++)}u.push(x)}for(let y=0;y<n;y++)for(let x=0;x<r;x++){let b=u[y][x+1],S=u[y][x],C=u[y+1][x],P=u[y+1][x+1];(y!==0||a>0)&&p.push(b,S,P),(y!==n-1||l<Math.PI)&&p.push(S,C,P)}this.setIndex(p),this.setAttribute("position",new xe(d,3)),this.setAttribute("normal",new xe(g,3)),this.setAttribute("uv",new xe(_,2))}static fromJSON(t){return new j0(t.radius,t.widthSegments,t.heightSegments,t.phiStart,t.phiLength,t.thetaStart,t.thetaLength)}},j1=class extends uh{constructor(t=1,r=0){let n=[1,1,1,-1,-1,1,-1,1,-1,1,-1,-1],i=[2,1,0,0,3,2,1,3,0,2,3,1];super(n,i,t,r),this.type="TetrahedronGeometry",this.parameters={radius:t,detail:r}}static fromJSON(t){return new j1(t.radius,t.detail)}},X1=class extends Pe{constructor(t=1,r=.4,n=8,i=6,o=Math.PI*2){super(),this.type="TorusGeometry",this.parameters={radius:t,tube:r,radialSegments:n,tubularSegments:i,arc:o},n=Math.floor(n),i=Math.floor(i);let a=[],s=[],l=[],c=[],u=new j,h=new j,f=new j;for(let p=0;p<=n;p++)for(let d=0;d<=i;d++){let g=d/i*o,_=p/n*Math.PI*2;h.x=(t+r*Math.cos(_))*Math.cos(g),h.y=(t+r*Math.cos(_))*Math.sin(g),h.z=r*Math.sin(_),s.push(h.x,h.y,h.z),u.x=t*Math.cos(g),u.y=t*Math.sin(g),f.subVectors(h,u).normalize(),l.push(f.x,f.y,f.z),c.push(d/i),c.push(p/n)}for(let p=1;p<=n;p++)for(let d=1;d<=i;d++){let g=(i+1)*p+d-1,_=(i+1)*(p-1)+d-1,y=(i+1)*(p-1)+d,x=(i+1)*p+d;a.push(g,_,x),a.push(_,y,x)}this.setIndex(a),this.setAttribute("position",new xe(s,3)),this.setAttribute("normal",new xe(l,3)),this.setAttribute("uv",new xe(c,2))}static fromJSON(t){return new X1(t.radius,t.tube,t.radialSegments,t.tubularSegments,t.arc)}},$1=class extends Pe{constructor(t=1,r=.4,n=64,i=8,o=2,a=3){super(),this.type="TorusKnotGeometry",this.parameters={radius:t,tube:r,tubularSegments:n,radialSegments:i,p:o,q:a},n=Math.floor(n),i=Math.floor(i);let s=[],l=[],c=[],u=[],h=new j,f=new j,p=new j,d=new j,g=new j,_=new j,y=new j;for(let b=0;b<=n;++b){let S=b/n*o*Math.PI*2;x(S,o,a,t,p),x(S+.01,o,a,t,d),_.subVectors(d,p),y.addVectors(d,p),g.crossVectors(_,y),y.crossVectors(g,_),g.normalize(),y.normalize();for(let C=0;C<=i;++C){let P=C/i*Math.PI*2,k=-r*Math.cos(P),O=r*Math.sin(P);h.x=p.x+(k*y.x+O*g.x),h.y=p.y+(k*y.y+O*g.y),h.z=p.z+(k*y.z+O*g.z),l.push(h.x,h.y,h.z),f.subVectors(h,p).normalize(),c.push(f.x,f.y,f.z),u.push(b/n),u.push(C/i)}}for(let b=1;b<=n;b++)for(let S=1;S<=i;S++){let C=(i+1)*(b-1)+(S-1),P=(i+1)*b+(S-1),k=(i+1)*b+S,O=(i+1)*(b-1)+S;s.push(C,P,O),s.push(P,k,O)}this.setIndex(s),this.setAttribute("position",new xe(l,3)),this.setAttribute("normal",new xe(c,3)),this.setAttribute("uv",new xe(u,2));function x(b,S,C,P,k){let O=Math.cos(b),D=Math.sin(b),B=C/S*b,I=Math.cos(B);k.x=P*(2+I)*.5*O,k.y=P*(2+I)*D*.5,k.z=P*Math.sin(B)*.5}}static fromJSON(t){return new $1(t.radius,t.tube,t.tubularSegments,t.radialSegments,t.p,t.q)}},K1=class extends Pe{constructor(t=new hM(new j(-1,-1,0),new j(-1,1,0),new j(1,1,0)),r=64,n=1,i=8,o=!1){super(),this.type="TubeGeometry",this.parameters={path:t,tubularSegments:r,radius:n,radialSegments:i,closed:o};let a=t.computeFrenetFrames(r,o);this.tangents=a.tangents,this.normals=a.normals,this.binormals=a.binormals;let s=new j,l=new j,c=new Lt,u=new j,h=[],f=[],p=[],d=[];g(),this.setIndex(d),this.setAttribute("position",new xe(h,3)),this.setAttribute("normal",new xe(f,3)),this.setAttribute("uv",new xe(p,2));function g(){for(let b=0;b<r;b++)_(b);_(o===!1?r:0),x(),y()}function _(b){u=t.getPointAt(b/r,u);let S=a.normals[b],C=a.binormals[b];for(let P=0;P<=i;P++){let k=P/i*Math.PI*2,O=Math.sin(k),D=-Math.cos(k);l.x=D*S.x+O*C.x,l.y=D*S.y+O*C.y,l.z=D*S.z+O*C.z,l.normalize(),f.push(l.x,l.y,l.z),s.x=u.x+n*l.x,s.y=u.y+n*l.y,s.z=u.z+n*l.z,h.push(s.x,s.y,s.z)}}function y(){for(let b=1;b<=r;b++)for(let S=1;S<=i;S++){let C=(i+1)*(b-1)+(S-1),P=(i+1)*b+(S-1),k=(i+1)*b+S,O=(i+1)*(b-1)+S;d.push(C,P,O),d.push(P,k,O)}}function x(){for(let b=0;b<=r;b++)for(let S=0;S<=i;S++)c.x=b/r,c.y=S/i,p.push(c.x,c.y)}}toJSON(){let t=super.toJSON();return t.path=this.parameters.path.toJSON(),t}static fromJSON(t){return new K1(new Oht[t.path.type]().fromJSON(t.path),t.tubularSegments,t.radius,t.radialSegments,t.closed)}},d6=class extends Pe{constructor(t=null){if(super(),this.type="WireframeGeometry",this.parameters={geometry:t},t!==null){let r=[],n=new Set,i=new j,o=new j;if(t.index!==null){let a=t.attributes.position,s=t.index,l=t.groups;l.length===0&&(l=[{start:0,count:s.count,materialIndex:0}]);for(let c=0,u=l.length;c<u;++c){let h=l[c],f=h.start,p=h.count;for(let d=f,g=f+p;d<g;d+=3)for(let _=0;_<3;_++){let y=s.getX(d+_),x=s.getX(d+(_+1)%3);i.fromBufferAttribute(a,y),o.fromBufferAttribute(a,x),yhe(i,o,n)===!0&&(r.push(i.x,i.y,i.z),r.push(o.x,o.y,o.z))}}}else{let a=t.attributes.position;for(let s=0,l=a.count/3;s<l;s++)for(let c=0;c<3;c++){let u=3*s+c,h=3*s+(c+1)%3;i.fromBufferAttribute(a,u),o.fromBufferAttribute(a,h),yhe(i,o,n)===!0&&(r.push(i.x,i.y,i.z),r.push(o.x,o.y,o.z))}}this.setAttribute("position",new xe(r,3))}}};function yhe(e,t,r){let n=`${e.x},${e.y},${e.z}-${t.x},${t.y},${t.z}`,i=`${t.x},${t.y},${t.z}-${e.x},${e.y},${e.z}`;return r.has(n)===!0||r.has(i)===!0?!1:(r.add(n,i),!0)}var vhe=Object.freeze({__proto__:null,BoxGeometry:Qf,BoxBufferGeometry:Qf,CircleGeometry:F1,CircleBufferGeometry:F1,ConeGeometry:B1,ConeBufferGeometry:B1,CylinderGeometry:om,CylinderBufferGeometry:om,DodecahedronGeometry:H1,DodecahedronBufferGeometry:H1,EdgesGeometry:s6,ExtrudeGeometry:hh,ExtrudeBufferGeometry:hh,IcosahedronGeometry:G1,IcosahedronBufferGeometry:G1,LatheGeometry:W1,LatheBufferGeometry:W1,OctahedronGeometry:W0,OctahedronBufferGeometry:W0,PlaneGeometry:V0,PlaneBufferGeometry:V0,PolyhedronGeometry:uh,PolyhedronBufferGeometry:uh,RingGeometry:Y1,RingBufferGeometry:Y1,ShapeGeometry:Y0,ShapeBufferGeometry:Y0,SphereGeometry:j0,SphereBufferGeometry:j0,TetrahedronGeometry:j1,TetrahedronBufferGeometry:j1,TorusGeometry:X1,TorusBufferGeometry:X1,TorusKnotGeometry:$1,TorusKnotBufferGeometry:$1,TubeGeometry:K1,TubeBufferGeometry:K1,WireframeGeometry:d6}),m6=class extends qi{constructor(t){super(),this.type="ShadowMaterial",this.color=new ne(0),this.transparent=!0,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this}};m6.prototype.isShadowMaterial=!0;var pM=class extends qi{constructor(t){super(),this.defines={STANDARD:""},this.type="MeshStandardMaterial",this.color=new ne(16777215),this.roughness=1,this.metalness=0,this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new ne(0),this.emissiveIntensity=1,this.emissiveMap=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=ax,this.normalScale=new Lt(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.roughnessMap=null,this.metalnessMap=null,this.alphaMap=null,this.envMap=null,this.envMapIntensity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.flatShading=!1,this.setValues(t)}copy(t){return super.copy(t),this.defines={STANDARD:""},this.color.copy(t.color),this.roughness=t.roughness,this.metalness=t.metalness,this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.roughnessMap=t.roughnessMap,this.metalnessMap=t.metalnessMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.envMapIntensity=t.envMapIntensity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this.flatShading=t.flatShading,this}};pM.prototype.isMeshStandardMaterial=!0;var g6=class extends pM{constructor(t){super(),this.defines={STANDARD:"",PHYSICAL:""},this.type="MeshPhysicalMaterial",this.clearcoatMap=null,this.clearcoatRoughness=0,this.clearcoatRoughnessMap=null,this.clearcoatNormalScale=new Lt(1,1),this.clearcoatNormalMap=null,this.ior=1.5,Object.defineProperty(this,"reflectivity",{get:function(){return Zo(2.5*(this.ior-1)/(this.ior+1),0,1)},set:function(r){this.ior=(1+.4*r)/(1-.4*r)}}),this.sheenColor=new ne(0),this.sheenColorMap=null,this.sheenRoughness=1,this.sheenRoughnessMap=null,this.transmissionMap=null,this.thickness=0,this.thicknessMap=null,this.attenuationDistance=0,this.attenuationColor=new ne(1,1,1),this.specularIntensity=1,this.specularIntensityMap=null,this.specularColor=new ne(1,1,1),this.specularColorMap=null,this._sheen=0,this._clearcoat=0,this._transmission=0,this.setValues(t)}get sheen(){return this._sheen}set sheen(t){this._sheen>0!=t>0&&this.version++,this._sheen=t}get clearcoat(){return this._clearcoat}set clearcoat(t){this._clearcoat>0!=t>0&&this.version++,this._clearcoat=t}get transmission(){return this._transmission}set transmission(t){this._transmission>0!=t>0&&this.version++,this._transmission=t}copy(t){return super.copy(t),this.defines={STANDARD:"",PHYSICAL:""},this.clearcoat=t.clearcoat,this.clearcoatMap=t.clearcoatMap,this.clearcoatRoughness=t.clearcoatRoughness,this.clearcoatRoughnessMap=t.clearcoatRoughnessMap,this.clearcoatNormalMap=t.clearcoatNormalMap,this.clearcoatNormalScale.copy(t.clearcoatNormalScale),this.ior=t.ior,this.sheen=t.sheen,this.sheenColor.copy(t.sheenColor),this.sheenColorMap=t.sheenColorMap,this.sheenRoughness=t.sheenRoughness,this.sheenRoughnessMap=t.sheenRoughnessMap,this.transmission=t.transmission,this.transmissionMap=t.transmissionMap,this.thickness=t.thickness,this.thicknessMap=t.thicknessMap,this.attenuationDistance=t.attenuationDistance,this.attenuationColor.copy(t.attenuationColor),this.specularIntensity=t.specularIntensity,this.specularIntensityMap=t.specularIntensityMap,this.specularColor.copy(t.specularColor),this.specularColorMap=t.specularColorMap,this}};g6.prototype.isMeshPhysicalMaterial=!0;var _6=class extends qi{constructor(t){super(),this.type="MeshPhongMaterial",this.color=new ne(16777215),this.specular=new ne(1118481),this.shininess=30,this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new ne(0),this.emissiveIntensity=1,this.emissiveMap=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=ax,this.normalScale=new Lt(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.specularMap=null,this.alphaMap=null,this.envMap=null,this.combine=O6,this.reflectivity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.flatShading=!1,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.specular.copy(t.specular),this.shininess=t.shininess,this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.specularMap=t.specularMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.combine=t.combine,this.reflectivity=t.reflectivity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this.flatShading=t.flatShading,this}};_6.prototype.isMeshPhongMaterial=!0;var y6=class extends qi{constructor(t){super(),this.defines={TOON:""},this.type="MeshToonMaterial",this.color=new ne(16777215),this.map=null,this.gradientMap=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new ne(0),this.emissiveIntensity=1,this.emissiveMap=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=ax,this.normalScale=new Lt(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.alphaMap=null,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.gradientMap=t.gradientMap,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.alphaMap=t.alphaMap,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this}};y6.prototype.isMeshToonMaterial=!0;var v6=class extends qi{constructor(t){super(),this.type="MeshNormalMaterial",this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=ax,this.normalScale=new Lt(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.wireframe=!1,this.wireframeLinewidth=1,this.fog=!1,this.flatShading=!1,this.setValues(t)}copy(t){return super.copy(t),this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.flatShading=t.flatShading,this}};v6.prototype.isMeshNormalMaterial=!0;var x6=class extends qi{constructor(t){super(),this.type="MeshLambertMaterial",this.color=new ne(16777215),this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new ne(0),this.emissiveIntensity=1,this.emissiveMap=null,this.specularMap=null,this.alphaMap=null,this.envMap=null,this.combine=O6,this.reflectivity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.specularMap=t.specularMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.combine=t.combine,this.reflectivity=t.reflectivity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this}};x6.prototype.isMeshLambertMaterial=!0;var b6=class extends qi{constructor(t){super(),this.defines={MATCAP:""},this.type="MeshMatcapMaterial",this.color=new ne(16777215),this.matcap=null,this.map=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=ax,this.normalScale=new Lt(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.alphaMap=null,this.flatShading=!1,this.setValues(t)}copy(t){return super.copy(t),this.defines={MATCAP:""},this.color.copy(t.color),this.matcap=t.matcap,this.map=t.map,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.alphaMap=t.alphaMap,this.flatShading=t.flatShading,this}};b6.prototype.isMeshMatcapMaterial=!0;var w6=class extends Gi{constructor(t){super(),this.type="LineDashedMaterial",this.scale=1,this.dashSize=3,this.gapSize=1,this.setValues(t)}copy(t){return super.copy(t),this.scale=t.scale,this.dashSize=t.dashSize,this.gapSize=t.gapSize,this}};w6.prototype.isLineDashedMaterial=!0;var u0r=Object.freeze({__proto__:null,ShadowMaterial:m6,SpriteMaterial:iM,RawShaderMaterial:U0,ShaderMaterial:lh,PointsMaterial:nm,MeshPhysicalMaterial:g6,MeshStandardMaterial:pM,MeshPhongMaterial:_6,MeshToonMaterial:y6,MeshNormalMaterial:v6,MeshLambertMaterial:x6,MeshDepthMaterial:eM,MeshDistanceMaterial:rM,MeshBasicMaterial:sh,MeshMatcapMaterial:b6,LineDashedMaterial:w6,LineBasicMaterial:Gi,Material:qi}),Yn={arraySlice:function(e,t,r){return Yn.isTypedArray(e)?new e.constructor(e.subarray(t,r!==void 0?r:e.length)):e.slice(t,r)},convertArray:function(e,t,r){return!e||!r&&e.constructor===t?e:typeof t.BYTES_PER_ELEMENT=="number"?new t(e):Array.prototype.slice.call(e)},isTypedArray:function(e){return ArrayBuffer.isView(e)&&!(e instanceof DataView)},getKeyframeOrder:function(e){function t(i,o){return e[i]-e[o]}let r=e.length,n=new Array(r);for(let i=0;i!==r;++i)n[i]=i;return n.sort(t),n},sortedArray:function(e,t,r){let n=e.length,i=new e.constructor(n);for(let o=0,a=0;a!==n;++o){let s=r[o]*t;for(let l=0;l!==t;++l)i[a++]=e[s+l]}return i},flattenJSON:function(e,t,r,n){let i=1,o=e[0];for(;o!==void 0&&o[n]===void 0;)o=e[i++];if(o===void 0)return;let a=o[n];if(a!==void 0)if(Array.isArray(a))do a=o[n],a!==void 0&&(t.push(o.time),r.push.apply(r,a)),o=e[i++];while(o!==void 0);else if(a.toArray!==void 0)do a=o[n],a!==void 0&&(t.push(o.time),a.toArray(r,r.length)),o=e[i++];while(o!==void 0);else do a=o[n],a!==void 0&&(t.push(o.time),r.push(a)),o=e[i++];while(o!==void 0)},subclip:function(e,t,r,n,i=30){let o=e.clone();o.name=t;let a=[];for(let l=0;l<o.tracks.length;++l){let c=o.tracks[l],u=c.getValueSize(),h=[],f=[];for(let p=0;p<c.times.length;++p){let d=c.times[p]*i;if(!(d<r||d>=n)){h.push(c.times[p]);for(let g=0;g<u;++g)f.push(c.values[p*u+g])}}h.length!==0&&(c.times=Yn.convertArray(h,c.times.constructor),c.values=Yn.convertArray(f,c.values.constructor),a.push(c))}o.tracks=a;let s=1/0;for(let l=0;l<o.tracks.length;++l)s>o.tracks[l].times[0]&&(s=o.tracks[l].times[0]);for(let l=0;l<o.tracks.length;++l)o.tracks[l].shift(-1*s);return o.resetDuration(),o},makeClipAdditive:function(e,t=0,r=e,n=30){n<=0&&(n=30);let i=r.tracks.length,o=t/n;for(let a=0;a<i;++a){let s=r.tracks[a],l=s.ValueTypeName;if(l==="bool"||l==="string")continue;let c=e.tracks.find(function(y){return y.name===s.name&&y.ValueTypeName===l});if(c===void 0)continue;let u=0,h=s.getValueSize();s.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline&&(u=h/3);let f=0,p=c.getValueSize();c.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline&&(f=p/3);let d=s.times.length-1,g;if(o<=s.times[0]){let y=u,x=h-u;g=Yn.arraySlice(s.values,y,x)}else if(o>=s.times[d]){let y=d*h+u,x=y+h-u;g=Yn.arraySlice(s.values,y,x)}else{let y=s.createInterpolant(),x=u,b=h-u;y.evaluate(o),g=Yn.arraySlice(y.resultBuffer,x,b)}l==="quaternion"&&new yi().fromArray(g).normalize().conjugate().toArray(g);let _=c.times.length;for(let y=0;y<_;++y){let x=y*p+f;if(l==="quaternion")yi.multiplyQuaternionsFlat(c.values,x,g,0,c.values,x);else{let b=p-f*2;for(let S=0;S<b;++S)c.values[x+S]-=g[S]}}}return e.blendMode=kht,e}},fh=class{constructor(t,r,n,i){this.parameterPositions=t,this._cachedIndex=0,this.resultBuffer=i!==void 0?i:new r.constructor(n),this.sampleValues=r,this.valueSize=n,this.settings=null,this.DefaultSettings_={}}evaluate(t){let r=this.parameterPositions,n=this._cachedIndex,i=r[n],o=r[n-1];t:{e:{let a;r:{n:if(!(t<i)){for(let s=n+2;;){if(i===void 0){if(t<o)break n;return n=r.length,this._cachedIndex=n,this.afterEnd_(n-1,t,o)}if(n===s)break;if(o=i,i=r[++n],t<i)break e}a=r.length;break r}if(!(t>=o)){let s=r[1];t<s&&(n=2,o=s);for(let l=n-2;;){if(o===void 0)return this._cachedIndex=0,this.beforeStart_(0,t,i);if(n===l)break;if(i=o,o=r[--n-1],t>=o)break e}a=n,n=0;break r}break t}for(;n<a;){let s=n+a>>>1;t<r[s]?a=s:n=s+1}if(i=r[n],o=r[n-1],o===void 0)return this._cachedIndex=0,this.beforeStart_(0,t,i);if(i===void 0)return n=r.length,this._cachedIndex=n,this.afterEnd_(n-1,o,t)}this._cachedIndex=n,this.intervalChanged_(n,o,i)}return this.interpolate_(n,o,t,i)}getSettings_(){return this.settings||this.DefaultSettings_}copySampleValue_(t){let r=this.resultBuffer,n=this.sampleValues,i=this.valueSize,o=t*i;for(let a=0;a!==i;++a)r[a]=n[o+a];return r}interpolate_(){throw new Error("call to abstract method")}intervalChanged_(){}};fh.prototype.beforeStart_=fh.prototype.copySampleValue_;fh.prototype.afterEnd_=fh.prototype.copySampleValue_;var SU=class extends fh{constructor(t,r,n,i){super(t,r,n,i),this._weightPrev=-0,this._offsetPrev=-0,this._weightNext=-0,this._offsetNext=-0,this.DefaultSettings_={endingStart:E1,endingEnd:E1}}intervalChanged_(t,r,n){let i=this.parameterPositions,o=t-2,a=t+1,s=i[o],l=i[a];if(s===void 0)switch(this.getSettings_().endingStart){case T1:o=t,s=2*r-n;break;case JP:o=i.length-2,s=r+i[o]-i[o+1];break;default:o=t,s=n}if(l===void 0)switch(this.getSettings_().endingEnd){case T1:a=t,l=2*n-r;break;case JP:a=1,l=n+i[1]-i[0];break;default:a=t-1,l=r}let c=(n-r)*.5,u=this.valueSize;this._weightPrev=c/(r-s),this._weightNext=c/(l-n),this._offsetPrev=o*u,this._offsetNext=a*u}interpolate_(t,r,n,i){let o=this.resultBuffer,a=this.sampleValues,s=this.valueSize,l=t*s,c=l-s,u=this._offsetPrev,h=this._offsetNext,f=this._weightPrev,p=this._weightNext,d=(n-r)/(i-r),g=d*d,_=g*d,y=-f*_+2*f*g-f*d,x=(1+f)*_+(-1.5-2*f)*g+(-.5+f)*d+1,b=(-1-p)*_+(1.5+p)*g+.5*d,S=p*_-p*g;for(let C=0;C!==s;++C)o[C]=y*a[u+C]+x*a[c+C]+b*a[l+C]+S*a[h+C];return o}},S6=class extends fh{constructor(t,r,n,i){super(t,r,n,i)}interpolate_(t,r,n,i){let o=this.resultBuffer,a=this.sampleValues,s=this.valueSize,l=t*s,c=l-s,u=(n-r)/(i-r),h=1-u;for(let f=0;f!==s;++f)o[f]=a[c+f]*h+a[l+f]*u;return o}},MU=class extends fh{constructor(t,r,n,i){super(t,r,n,i)}interpolate_(t){return this.copySampleValue_(t-1)}},Dl=class{constructor(t,r,n,i){if(t===void 0)throw new Error("THREE.KeyframeTrack: track name is undefined");if(r===void 0||r.length===0)throw new Error("THREE.KeyframeTrack: no keyframes in track named "+t);this.name=t,this.times=Yn.convertArray(r,this.TimeBufferType),this.values=Yn.convertArray(n,this.ValueBufferType),this.setInterpolation(i||this.DefaultInterpolation)}static toJSON(t){let r=t.constructor,n;if(r.toJSON!==this.toJSON)n=r.toJSON(t);else{n={name:t.name,times:Yn.convertArray(t.times,Array),values:Yn.convertArray(t.values,Array)};let i=t.getInterpolation();i!==t.DefaultInterpolation&&(n.interpolation=i)}return n.type=t.ValueTypeName,n}InterpolantFactoryMethodDiscrete(t){return new MU(this.times,this.values,this.getValueSize(),t)}InterpolantFactoryMethodLinear(t){return new S6(this.times,this.values,this.getValueSize(),t)}InterpolantFactoryMethodSmooth(t){return new SU(this.times,this.values,this.getValueSize(),t)}setInterpolation(t){let r;switch(t){case KP:r=this.InterpolantFactoryMethodDiscrete;break;case ZP:r=this.InterpolantFactoryMethodLinear;break;case rU:r=this.InterpolantFactoryMethodSmooth;break}if(r===void 0){let n="unsupported interpolation for "+this.ValueTypeName+" keyframe track named "+this.name;if(this.createInterpolant===void 0)if(t!==this.DefaultInterpolation)this.setInterpolation(this.DefaultInterpolation);else throw new Error(n);return console.warn("THREE.KeyframeTrack:",n),this}return this.createInterpolant=r,this}getInterpolation(){switch(this.createInterpolant){case this.InterpolantFactoryMethodDiscrete:return KP;case this.InterpolantFactoryMethodLinear:return ZP;case this.InterpolantFactoryMethodSmooth:return rU}}getValueSize(){return this.values.length/this.times.length}shift(t){if(t!==0){let r=this.times;for(let n=0,i=r.length;n!==i;++n)r[n]+=t}return this}scale(t){if(t!==1){let r=this.times;for(let n=0,i=r.length;n!==i;++n)r[n]*=t}return this}trim(t,r){let n=this.times,i=n.length,o=0,a=i-1;for(;o!==i&&n[o]<t;)++o;for(;a!==-1&&n[a]>r;)--a;if(++a,o!==0||a!==i){o>=a&&(a=Math.max(a,1),o=a-1);let s=this.getValueSize();this.times=Yn.arraySlice(n,o,a),this.values=Yn.arraySlice(this.values,o*s,a*s)}return this}validate(){let t=!0,r=this.getValueSize();r-Math.floor(r)!==0&&(console.error("THREE.KeyframeTrack: Invalid value size in track.",this),t=!1);let n=this.times,i=this.values,o=n.length;o===0&&(console.error("THREE.KeyframeTrack: Track is empty.",this),t=!1);let a=null;for(let s=0;s!==o;s++){let l=n[s];if(typeof l=="number"&&isNaN(l)){console.error("THREE.KeyframeTrack: Time is not a valid number.",this,s,l),t=!1;break}if(a!==null&&a>l){console.error("THREE.KeyframeTrack: Out of order keys.",this,s,l,a),t=!1;break}a=l}if(i!==void 0&&Yn.isTypedArray(i))for(let s=0,l=i.length;s!==l;++s){let c=i[s];if(isNaN(c)){console.error("THREE.KeyframeTrack: Value is not a valid number.",this,s,c),t=!1;break}}return t}optimize(){let t=Yn.arraySlice(this.times),r=Yn.arraySlice(this.values),n=this.getValueSize(),i=this.getInterpolation()===rU,o=t.length-1,a=1;for(let s=1;s<o;++s){let l=!1,c=t[s],u=t[s+1];if(c!==u&&(s!==1||c!==t[0]))if(i)l=!0;else{let h=s*n,f=h-n,p=h+n;for(let d=0;d!==n;++d){let g=r[h+d];if(g!==r[f+d]||g!==r[p+d]){l=!0;break}}}if(l){if(s!==a){t[a]=t[s];let h=s*n,f=a*n;for(let p=0;p!==n;++p)r[f+p]=r[h+p]}++a}}if(o>0){t[a]=t[o];for(let s=o*n,l=a*n,c=0;c!==n;++c)r[l+c]=r[s+c];++a}return a!==t.length?(this.times=Yn.arraySlice(t,0,a),this.values=Yn.arraySlice(r,0,a*n)):(this.times=t,this.values=r),this}clone(){let t=Yn.arraySlice(this.times,0),r=Yn.arraySlice(this.values,0),n=this.constructor,i=new n(this.name,t,r);return i.createInterpolant=this.createInterpolant,i}};Dl.prototype.TimeBufferType=Float32Array;Dl.prototype.ValueBufferType=Float32Array;Dl.prototype.DefaultInterpolation=ZP;var am=class extends Dl{};am.prototype.ValueTypeName="bool";am.prototype.ValueBufferType=Array;am.prototype.DefaultInterpolation=KP;am.prototype.InterpolantFactoryMethodLinear=void 0;am.prototype.InterpolantFactoryMethodSmooth=void 0;var M6=class extends Dl{};M6.prototype.ValueTypeName="color";var Z1=class extends Dl{};Z1.prototype.ValueTypeName="number";var EU=class extends fh{constructor(t,r,n,i){super(t,r,n,i)}interpolate_(t,r,n,i){let o=this.resultBuffer,a=this.sampleValues,s=this.valueSize,l=(n-r)/(i-r),c=t*s;for(let u=c+s;c!==u;c+=4)yi.slerpFlat(o,0,a,c-s,a,c,l);return o}},X0=class extends Dl{InterpolantFactoryMethodLinear(t){return new EU(this.times,this.values,this.getValueSize(),t)}};X0.prototype.ValueTypeName="quaternion";X0.prototype.DefaultInterpolation=ZP;X0.prototype.InterpolantFactoryMethodSmooth=void 0;var sm=class extends Dl{};sm.prototype.ValueTypeName="string";sm.prototype.ValueBufferType=Array;sm.prototype.DefaultInterpolation=KP;sm.prototype.InterpolantFactoryMethodLinear=void 0;sm.prototype.InterpolantFactoryMethodSmooth=void 0;var J1=class extends Dl{};J1.prototype.ValueTypeName="vector";var Q1=class{constructor(t,r=-1,n,i=$U){this.name=t,this.tracks=n,this.duration=r,this.blendMode=i,this.uuid=Nl(),this.duration<0&&this.resetDuration()}static parse(t){let r=[],n=t.tracks,i=1/(t.fps||1);for(let a=0,s=n.length;a!==s;++a)r.push(f0r(n[a]).scale(i));let o=new this(t.name,t.duration,r,t.blendMode);return o.uuid=t.uuid,o}static toJSON(t){let r=[],n=t.tracks,i={name:t.name,duration:t.duration,tracks:r,uuid:t.uuid,blendMode:t.blendMode};for(let o=0,a=n.length;o!==a;++o)r.push(Dl.toJSON(n[o]));return i}static CreateFromMorphTargetSequence(t,r,n,i){let o=r.length,a=[];for(let s=0;s<o;s++){let l=[],c=[];l.push((s+o-1)%o,s,(s+1)%o),c.push(0,1,0);let u=Yn.getKeyframeOrder(l);l=Yn.sortedArray(l,1,u),c=Yn.sortedArray(c,1,u),!i&&l[0]===0&&(l.push(o),c.push(c[0])),a.push(new Z1(".morphTargetInfluences["+r[s].name+"]",l,c).scale(1/n))}return new this(t,-1,a)}static findByName(t,r){let n=t;if(!Array.isArray(t)){let i=t;n=i.geometry&&i.geometry.animations||i.animations}for(let i=0;i<n.length;i++)if(n[i].name===r)return n[i];return null}static CreateClipsFromMorphTargetSequences(t,r,n){let i={},o=/^([\w-]*?)([\d]+)$/;for(let s=0,l=t.length;s<l;s++){let c=t[s],u=c.name.match(o);if(u&&u.length>1){let h=u[1],f=i[h];f||(i[h]=f=[]),f.push(c)}}let a=[];for(let s in i)a.push(this.CreateFromMorphTargetSequence(s,i[s],r,n));return a}static parseAnimation(t,r){if(!t)return console.error("THREE.AnimationClip: No animation in JSONLoader data."),null;let n=function(h,f,p,d,g){if(p.length!==0){let _=[],y=[];Yn.flattenJSON(p,_,y,d),_.length!==0&&g.push(new h(f,_,y))}},i=[],o=t.name||"default",a=t.fps||30,s=t.blendMode,l=t.length||-1,c=t.hierarchy||[];for(let h=0;h<c.length;h++){let f=c[h].keys;if(!(!f||f.length===0))if(f[0].morphTargets){let p={},d;for(d=0;d<f.length;d++)if(f[d].morphTargets)for(let g=0;g<f[d].morphTargets.length;g++)p[f[d].morphTargets[g]]=-1;for(let g in p){let _=[],y=[];for(let x=0;x!==f[d].morphTargets.length;++x){let b=f[d];_.push(b.time),y.push(b.morphTarget===g?1:0)}i.push(new Z1(".morphTargetInfluence["+g+"]",_,y))}l=p.length*(a||1)}else{let p=".bones["+r[h].name+"]";n(J1,p+".position",f,"pos",i),n(X0,p+".quaternion",f,"rot",i),n(J1,p+".scale",f,"scl",i)}}return i.length===0?null:new this(o,l,i,s)}resetDuration(){let t=this.tracks,r=0;for(let n=0,i=t.length;n!==i;++n){let o=this.tracks[n];r=Math.max(r,o.times[o.times.length-1])}return this.duration=r,this}trim(){for(let t=0;t<this.tracks.length;t++)this.tracks[t].trim(0,this.duration);return this}validate(){let t=!0;for(let r=0;r<this.tracks.length;r++)t=t&&this.tracks[r].validate();return t}optimize(){for(let t=0;t<this.tracks.length;t++)this.tracks[t].optimize();return this}clone(){let t=[];for(let r=0;r<this.tracks.length;r++)t.push(this.tracks[r].clone());return new this.constructor(this.name,this.duration,t,this.blendMode)}toJSON(){return this.constructor.toJSON(this)}};function h0r(e){switch(e.toLowerCase()){case"scalar":case"double":case"float":case"number":case"integer":return Z1;case"vector":case"vector2":case"vector3":case"vector4":return J1;case"color":return M6;case"quaternion":return X0;case"bool":case"boolean":return am;case"string":return sm}throw new Error("THREE.KeyframeTrack: Unsupported typeName: "+e)}function f0r(e){if(e.type===void 0)throw new Error("THREE.KeyframeTrack: track type undefined, can not parse");let t=h0r(e.type);if(e.times===void 0){let r=[],n=[];Yn.flattenJSON(e.keys,r,n,"value"),e.times=r,e.values=n}return t.parse!==void 0?t.parse(e):new t(e.name,e.times,e.values,e.interpolation)}var tx={enabled:!1,files:{},add:function(e,t){this.enabled!==!1&&(this.files[e]=t)},get:function(e){if(this.enabled!==!1)return this.files[e]},remove:function(e){delete this.files[e]},clear:function(){this.files={}}},E6=class{constructor(t,r,n){let i=this,o=!1,a=0,s=0,l,c=[];this.onStart=void 0,this.onLoad=t,this.onProgress=r,this.onError=n,this.itemStart=function(u){s++,o===!1&&i.onStart!==void 0&&i.onStart(u,a,s),o=!0},this.itemEnd=function(u){a++,i.onProgress!==void 0&&i.onProgress(u,a,s),a===s&&(o=!1,i.onLoad!==void 0&&i.onLoad())},this.itemError=function(u){i.onError!==void 0&&i.onError(u)},this.resolveURL=function(u){return l?l(u):u},this.setURLModifier=function(u){return l=u,this},this.addHandler=function(u,h){return c.push(u,h),this},this.removeHandler=function(u){let h=c.indexOf(u);return h!==-1&&c.splice(h,2),this},this.getHandler=function(u){for(let h=0,f=c.length;h<f;h+=2){let p=c[h],d=c[h+1];if(p.global&&(p.lastIndex=0),p.test(u))return d}return null}}},ipe=new E6,ea=class{constructor(t){this.manager=t!==void 0?t:ipe,this.crossOrigin="anonymous",this.withCredentials=!1,this.path="",this.resourcePath="",this.requestHeader={}}load(){}loadAsync(t,r){let n=this;return new Promise(function(i,o){n.load(t,i,r,o)})}parse(){}setCrossOrigin(t){return this.crossOrigin=t,this}setWithCredentials(t){return this.withCredentials=t,this}setPath(t){return this.path=t,this}setResourcePath(t){return this.resourcePath=t,this}setRequestHeader(t){return this.requestHeader=t,this}},Yd={},Jc=class extends ea{constructor(t){super(t)}load(t,r,n,i){t===void 0&&(t=""),this.path!==void 0&&(t=this.path+t),t=this.manager.resolveURL(t);let o=tx.get(t);if(o!==void 0)return this.manager.itemStart(t),setTimeout(()=>{r&&r(o),this.manager.itemEnd(t)},0),o;if(Yd[t]!==void 0){Yd[t].push({onLoad:r,onProgress:n,onError:i});return}Yd[t]=[],Yd[t].push({onLoad:r,onProgress:n,onError:i});let a=new Request(t,{headers:new Headers(this.requestHeader),credentials:this.withCredentials?"include":"same-origin"}),s=this.mimeType,l=this.responseType;fetch(a).then(c=>{if(c.status===200||c.status===0){if(c.status===0&&console.warn("THREE.FileLoader: HTTP Status 0 received."),typeof ReadableStream=="undefined"||c.body.getReader===void 0)return c;let u=Yd[t],h=c.body.getReader(),f=c.headers.get("Content-Length"),p=f?parseInt(f):0,d=p!==0,g=0,_=new ReadableStream({start(y){x();function x(){h.read().then(({done:b,value:S})=>{if(b)y.close();else{g+=S.byteLength;let C=new ProgressEvent("progress",{lengthComputable:d,loaded:g,total:p});for(let P=0,k=u.length;P<k;P++){let O=u[P];O.onProgress&&O.onProgress(C)}y.enqueue(S),x()}})}}});return new Response(_)}else throw Error(`fetch for "${c.url}" responded with ${c.status}: ${c.statusText}`)}).then(c=>{switch(l){case"arraybuffer":return c.arrayBuffer();case"blob":return c.blob();case"document":return c.text().then(u=>new DOMParser().parseFromString(u,s));case"json":return c.json();default:if(s===void 0)return c.text();{let h=/charset="?([^;"\s]*)"?/i.exec(s),f=h&&h[1]?h[1].toLowerCase():void 0,p=new TextDecoder(f);return c.arrayBuffer().then(d=>p.decode(d))}}}).then(c=>{tx.add(t,c);let u=Yd[t];delete Yd[t];for(let h=0,f=u.length;h<f;h++){let p=u[h];p.onLoad&&p.onLoad(c)}}).catch(c=>{let u=Yd[t];if(u===void 0)throw this.manager.itemError(t),c;delete Yd[t];for(let h=0,f=u.length;h<f;h++){let p=u[h];p.onError&&p.onError(c)}this.manager.itemError(t)}).finally(()=>{this.manager.itemEnd(t)}),this.manager.itemStart(t)}setResponseType(t){return this.responseType=t,this}setMimeType(t){return this.mimeType=t,this}},oht=class extends ea{constructor(t){super(t)}load(t,r,n,i){let o=this,a=new Jc(this.manager);a.setPath(this.path),a.setRequestHeader(this.requestHeader),a.setWithCredentials(this.withCredentials),a.load(t,function(s){try{r(o.parse(JSON.parse(s)))}catch(l){i?i(l):console.error(l),o.manager.itemError(t)}},n,i)}parse(t){let r=[];for(let n=0;n<t.length;n++){let i=Q1.parse(t[n]);r.push(i)}return r}},aht=class extends ea{constructor(t){super(t)}load(t,r,n,i){let o=this,a=[],s=new a6,l=new Jc(this.manager);l.setPath(this.path),l.setResponseType("arraybuffer"),l.setRequestHeader(this.requestHeader),l.setWithCredentials(o.withCredentials);let c=0;function u(h){l.load(t[h],function(f){let p=o.parse(f,!0);a[h]={width:p.width,height:p.height,format:p.format,mipmaps:p.mipmaps},c+=1,c===6&&(p.mipmapCount===1&&(s.minFilter=ii),s.image=a,s.format=p.format,s.needsUpdate=!0,r&&r(s))},n,i)}if(Array.isArray(t))for(let h=0,f=t.length;h<f;++h)u(h);else l.load(t,function(h){let f=o.parse(h,!0);if(f.isCubemap){let p=f.mipmaps.length/f.mipmapCount;for(let d=0;d<p;d++){a[d]={mipmaps:[]};for(let g=0;g<f.mipmapCount;g++)a[d].mipmaps.push(f.mipmaps[d*f.mipmapCount+g]),a[d].format=f.format,a[d].width=f.width,a[d].height=f.height}s.image=a}else s.image.width=f.width,s.image.height=f.height,s.mipmaps=f.mipmaps;f.mipmapCount===1&&(s.minFilter=ii),s.format=f.format,s.needsUpdate=!0,r&&r(s)},n,i);return s}},ex=class extends ea{constructor(t){super(t)}load(t,r,n,i){this.path!==void 0&&(t=this.path+t),t=this.manager.resolveURL(t);let o=this,a=tx.get(t);if(a!==void 0)return o.manager.itemStart(t),setTimeout(function(){r&&r(a),o.manager.itemEnd(t)},0),a;let s=t6("img");function l(){u(),tx.add(t,this),r&&r(this),o.manager.itemEnd(t)}function c(h){u(),i&&i(h),o.manager.itemError(t),o.manager.itemEnd(t)}function u(){s.removeEventListener("load",l,!1),s.removeEventListener("error",c,!1)}return s.addEventListener("load",l,!1),s.addEventListener("error",c,!1),t.substr(0,5)!=="data:"&&this.crossOrigin!==void 0&&(s.crossOrigin=this.crossOrigin),o.manager.itemStart(t),s.src=t,s}},TU=class extends ea{constructor(t){super(t)}load(t,r,n,i){let o=new H0,a=new ex(this.manager);a.setCrossOrigin(this.crossOrigin),a.setPath(this.path);let s=0;function l(c){a.load(t[c],function(u){o.images[c]=u,s++,s===6&&(o.needsUpdate=!0,r&&r(o))},void 0,i)}for(let c=0;c<t.length;++c)l(c);return o}},CU=class extends ea{constructor(t){super(t)}load(t,r,n,i){let o=this,a=new Jd,s=new Jc(this.manager);return s.setResponseType("arraybuffer"),s.setRequestHeader(this.requestHeader),s.setPath(this.path),s.setWithCredentials(o.withCredentials),s.load(t,function(l){let c=o.parse(l);!c||(c.image!==void 0?a.image=c.image:c.data!==void 0&&(a.image.width=c.width,a.image.height=c.height,a.image.data=c.data),a.wrapS=c.wrapS!==void 0?c.wrapS:Jo,a.wrapT=c.wrapT!==void 0?c.wrapT:Jo,a.magFilter=c.magFilter!==void 0?c.magFilter:ii,a.minFilter=c.minFilter!==void 0?c.minFilter:ii,a.anisotropy=c.anisotropy!==void 0?c.anisotropy:1,c.encoding!==void 0&&(a.encoding=c.encoding),c.flipY!==void 0&&(a.flipY=c.flipY),c.format!==void 0&&(a.format=c.format),c.type!==void 0&&(a.type=c.type),c.mipmaps!==void 0&&(a.mipmaps=c.mipmaps,a.minFilter=ox),c.mipmapCount===1&&(a.minFilter=ii),c.generateMipmaps!==void 0&&(a.generateMipmaps=c.generateMipmaps),a.needsUpdate=!0,r&&r(a,c))},n,i),a}},AU=class extends ea{constructor(t){super(t)}load(t,r,n,i){let o=new vi,a=new ex(this.manager);return a.setCrossOrigin(this.crossOrigin),a.setPath(this.path),a.load(t,function(s){o.image=s,o.needsUpdate=!0,r!==void 0&&r(o)},n,i),o}},Ol=class extends or{constructor(t,r=1){super(),this.type="Light",this.color=new ne(t),this.intensity=r}dispose(){}copy(t){return super.copy(t),this.color.copy(t.color),this.intensity=t.intensity,this}toJSON(t){let r=super.toJSON(t);return r.object.color=this.color.getHex(),r.object.intensity=this.intensity,this.groundColor!==void 0&&(r.object.groundColor=this.groundColor.getHex()),this.distance!==void 0&&(r.object.distance=this.distance),this.angle!==void 0&&(r.object.angle=this.angle),this.decay!==void 0&&(r.object.decay=this.decay),this.penumbra!==void 0&&(r.object.penumbra=this.penumbra),this.shadow!==void 0&&(r.object.shadow=this.shadow.toJSON()),r}};Ol.prototype.isLight=!0;var T6=class extends Ol{constructor(t,r,n){super(t,n),this.type="HemisphereLight",this.position.copy(or.DefaultUp),this.updateMatrix(),this.groundColor=new ne(r)}copy(t){return Ol.prototype.copy.call(this,t),this.groundColor.copy(t.groundColor),this}};T6.prototype.isHemisphereLight=!0;var xhe=new Me,bhe=new j,whe=new j,C6=class{constructor(t){this.camera=t,this.bias=0,this.normalBias=0,this.radius=1,this.blurSamples=8,this.mapSize=new Lt(512,512),this.map=null,this.mapPass=null,this.matrix=new Me,this.autoUpdate=!0,this.needsUpdate=!1,this._frustum=new N1,this._frameExtents=new Lt(1,1),this._viewportCount=1,this._viewports=[new en(0,0,1,1)]}getViewportCount(){return this._viewportCount}getFrustum(){return this._frustum}updateMatrices(t){let r=this.camera,n=this.matrix;bhe.setFromMatrixPosition(t.matrixWorld),r.position.copy(bhe),whe.setFromMatrixPosition(t.target.matrixWorld),r.lookAt(whe),r.updateMatrixWorld(),xhe.multiplyMatrices(r.projectionMatrix,r.matrixWorldInverse),this._frustum.setFromProjectionMatrix(xhe),n.set(.5,0,0,.5,0,.5,0,.5,0,0,.5,.5,0,0,0,1),n.multiply(r.projectionMatrix),n.multiply(r.matrixWorldInverse)}getViewport(t){return this._viewports[t]}getFrameExtents(){return this._frameExtents}dispose(){this.map&&this.map.dispose(),this.mapPass&&this.mapPass.dispose()}copy(t){return this.camera=t.camera.clone(),this.bias=t.bias,this.radius=t.radius,this.mapSize.copy(t.mapSize),this}clone(){return new this.constructor().copy(this)}toJSON(){let t={};return this.bias!==0&&(t.bias=this.bias),this.normalBias!==0&&(t.normalBias=this.normalBias),this.radius!==1&&(t.radius=this.radius),(this.mapSize.x!==512||this.mapSize.y!==512)&&(t.mapSize=this.mapSize.toArray()),t.camera=this.camera.toJSON(!1).object,delete t.camera.matrix,t}},PU=class extends C6{constructor(){super(new Ui(50,1,.5,500)),this.focus=1}updateMatrices(t){let r=this.camera,n=QP*2*t.angle*this.focus,i=this.mapSize.width/this.mapSize.height,o=t.distance||r.far;(n!==r.fov||i!==r.aspect||o!==r.far)&&(r.fov=n,r.aspect=i,r.far=o,r.updateProjectionMatrix()),super.updateMatrices(t)}copy(t){return super.copy(t),this.focus=t.focus,this}};PU.prototype.isSpotLightShadow=!0;var A6=class extends Ol{constructor(t,r,n=0,i=Math.PI/3,o=0,a=1){super(t,r),this.type="SpotLight",this.position.copy(or.DefaultUp),this.updateMatrix(),this.target=new or,this.distance=n,this.angle=i,this.penumbra=o,this.decay=a,this.shadow=new PU}get power(){return this.intensity*Math.PI}set power(t){this.intensity=t/Math.PI}dispose(){this.shadow.dispose()}copy(t){return super.copy(t),this.distance=t.distance,this.angle=t.angle,this.penumbra=t.penumbra,this.decay=t.decay,this.target=t.target.clone(),this.shadow=t.shadow.clone(),this}};A6.prototype.isSpotLight=!0;var She=new Me,BP=new j,xut=new j,IU=class extends C6{constructor(){super(new Ui(90,1,.5,500)),this._frameExtents=new Lt(4,2),this._viewportCount=6,this._viewports=[new en(2,1,1,1),new en(0,1,1,1),new en(3,1,1,1),new en(1,1,1,1),new en(3,0,1,1),new en(1,0,1,1)],this._cubeDirections=[new j(1,0,0),new j(-1,0,0),new j(0,0,1),new j(0,0,-1),new j(0,1,0),new j(0,-1,0)],this._cubeUps=[new j(0,1,0),new j(0,1,0),new j(0,1,0),new j(0,1,0),new j(0,0,1),new j(0,0,-1)]}updateMatrices(t,r=0){let n=this.camera,i=this.matrix,o=t.distance||n.far;o!==n.far&&(n.far=o,n.updateProjectionMatrix()),BP.setFromMatrixPosition(t.matrixWorld),n.position.copy(BP),xut.copy(n.position),xut.add(this._cubeDirections[r]),n.up.copy(this._cubeUps[r]),n.lookAt(xut),n.updateMatrixWorld(),i.makeTranslation(-BP.x,-BP.y,-BP.z),She.multiplyMatrices(n.projectionMatrix,n.matrixWorldInverse),this._frustum.setFromProjectionMatrix(She)}};IU.prototype.isPointLightShadow=!0;var P6=class extends Ol{constructor(t,r,n=0,i=1){super(t,r),this.type="PointLight",this.distance=n,this.decay=i,this.shadow=new IU}get power(){return this.intensity*4*Math.PI}set power(t){this.intensity=t/(4*Math.PI)}dispose(){this.shadow.dispose()}copy(t){return super.copy(t),this.distance=t.distance,this.decay=t.decay,this.shadow=t.shadow.clone(),this}};P6.prototype.isPointLight=!0;var LU=class extends C6{constructor(){super(new D1(-5,5,5,-5,.5,500))}};LU.prototype.isDirectionalLightShadow=!0;var I6=class extends Ol{constructor(t,r){super(t,r),this.type="DirectionalLight",this.position.copy(or.DefaultUp),this.updateMatrix(),this.target=new or,this.shadow=new LU}dispose(){this.shadow.dispose()}copy(t){return super.copy(t),this.target=t.target.clone(),this.shadow=t.shadow.clone(),this}};I6.prototype.isDirectionalLight=!0;var L6=class extends Ol{constructor(t,r){super(t,r),this.type="AmbientLight"}};L6.prototype.isAmbientLight=!0;var k6=class extends Ol{constructor(t,r,n=10,i=10){super(t,r),this.type="RectAreaLight",this.width=n,this.height=i}get power(){return this.intensity*this.width*this.height*Math.PI}set power(t){this.intensity=t/(this.width*this.height*Math.PI)}copy(t){return super.copy(t),this.width=t.width,this.height=t.height,this}toJSON(t){let r=super.toJSON(t);return r.object.width=this.width,r.object.height=this.height,r}};k6.prototype.isRectAreaLight=!0;var R6=class{constructor(){this.coefficients=[];for(let t=0;t<9;t++)this.coefficients.push(new j)}set(t){for(let r=0;r<9;r++)this.coefficients[r].copy(t[r]);return this}zero(){for(let t=0;t<9;t++)this.coefficients[t].set(0,0,0);return this}getAt(t,r){let n=t.x,i=t.y,o=t.z,a=this.coefficients;return r.copy(a[0]).multiplyScalar(.282095),r.addScaledVector(a[1],.488603*i),r.addScaledVector(a[2],.488603*o),r.addScaledVector(a[3],.488603*n),r.addScaledVector(a[4],1.092548*(n*i)),r.addScaledVector(a[5],1.092548*(i*o)),r.addScaledVector(a[6],.315392*(3*o*o-1)),r.addScaledVector(a[7],1.092548*(n*o)),r.addScaledVector(a[8],.546274*(n*n-i*i)),r}getIrradianceAt(t,r){let n=t.x,i=t.y,o=t.z,a=this.coefficients;return r.copy(a[0]).multiplyScalar(.886227),r.addScaledVector(a[1],2*.511664*i),r.addScaledVector(a[2],2*.511664*o),r.addScaledVector(a[3],2*.511664*n),r.addScaledVector(a[4],2*.429043*n*i),r.addScaledVector(a[5],2*.429043*i*o),r.addScaledVector(a[6],.743125*o*o-.247708),r.addScaledVector(a[7],2*.429043*n*o),r.addScaledVector(a[8],.429043*(n*n-i*i)),r}add(t){for(let r=0;r<9;r++)this.coefficients[r].add(t.coefficients[r]);return this}addScaledSH(t,r){for(let n=0;n<9;n++)this.coefficients[n].addScaledVector(t.coefficients[n],r);return this}scale(t){for(let r=0;r<9;r++)this.coefficients[r].multiplyScalar(t);return this}lerp(t,r){for(let n=0;n<9;n++)this.coefficients[n].lerp(t.coefficients[n],r);return this}equals(t){for(let r=0;r<9;r++)if(!this.coefficients[r].equals(t.coefficients[r]))return!1;return!0}copy(t){return this.set(t.coefficients)}clone(){return new this.constructor().copy(this)}fromArray(t,r=0){let n=this.coefficients;for(let i=0;i<9;i++)n[i].fromArray(t,r+i*3);return this}toArray(t=[],r=0){let n=this.coefficients;for(let i=0;i<9;i++)n[i].toArray(t,r+i*3);return t}static getBasisAt(t,r){let n=t.x,i=t.y,o=t.z;r[0]=.282095,r[1]=.488603*i,r[2]=.488603*o,r[3]=.488603*n,r[4]=1.092548*n*i,r[5]=1.092548*i*o,r[6]=.315392*(3*o*o-1),r[7]=1.092548*n*o,r[8]=.546274*(n*n-i*i)}};R6.prototype.isSphericalHarmonics3=!0;var rx=class extends Ol{constructor(t=new R6,r=1){super(void 0,r),this.sh=t}copy(t){return super.copy(t),this.sh.copy(t.sh),this}fromJSON(t){return this.intensity=t.intensity,this.sh.fromArray(t.sh),this}toJSON(t){let r=super.toJSON(t);return r.object.sh=this.sh.toArray(),r}};rx.prototype.isLightProbe=!0;var kU=class extends ea{constructor(t){super(t),this.textures={}}load(t,r,n,i){let o=this,a=new Jc(o.manager);a.setPath(o.path),a.setRequestHeader(o.requestHeader),a.setWithCredentials(o.withCredentials),a.load(t,function(s){try{r(o.parse(JSON.parse(s)))}catch(l){i?i(l):console.error(l),o.manager.itemError(t)}},n,i)}parse(t){let r=this.textures;function n(o){return r[o]===void 0&&console.warn("THREE.MaterialLoader: Undefined texture",o),r[o]}let i=new u0r[t.type];if(t.uuid!==void 0&&(i.uuid=t.uuid),t.name!==void 0&&(i.name=t.name),t.color!==void 0&&i.color!==void 0&&i.color.setHex(t.color),t.roughness!==void 0&&(i.roughness=t.roughness),t.metalness!==void 0&&(i.metalness=t.metalness),t.sheen!==void 0&&(i.sheen=t.sheen),t.sheenColor!==void 0&&(i.sheenColor=new ne().setHex(t.sheenColor)),t.sheenRoughness!==void 0&&(i.sheenRoughness=t.sheenRoughness),t.emissive!==void 0&&i.emissive!==void 0&&i.emissive.setHex(t.emissive),t.specular!==void 0&&i.specular!==void 0&&i.specular.setHex(t.specular),t.specularIntensity!==void 0&&(i.specularIntensity=t.specularIntensity),t.specularColor!==void 0&&i.specularColor!==void 0&&i.specularColor.setHex(t.specularColor),t.shininess!==void 0&&(i.shininess=t.shininess),t.clearcoat!==void 0&&(i.clearcoat=t.clearcoat),t.clearcoatRoughness!==void 0&&(i.clearcoatRoughness=t.clearcoatRoughness),t.transmission!==void 0&&(i.transmission=t.transmission),t.thickness!==void 0&&(i.thickness=t.thickness),t.attenuationDistance!==void 0&&(i.attenuationDistance=t.attenuationDistance),t.attenuationColor!==void 0&&i.attenuationColor!==void 0&&i.attenuationColor.setHex(t.attenuationColor),t.fog!==void 0&&(i.fog=t.fog),t.flatShading!==void 0&&(i.flatShading=t.flatShading),t.blending!==void 0&&(i.blending=t.blending),t.combine!==void 0&&(i.combine=t.combine),t.side!==void 0&&(i.side=t.side),t.shadowSide!==void 0&&(i.shadowSide=t.shadowSide),t.opacity!==void 0&&(i.opacity=t.opacity),t.transparent!==void 0&&(i.transparent=t.transparent),t.alphaTest!==void 0&&(i.alphaTest=t.alphaTest),t.depthTest!==void 0&&(i.depthTest=t.depthTest),t.depthWrite!==void 0&&(i.depthWrite=t.depthWrite),t.colorWrite!==void 0&&(i.colorWrite=t.colorWrite),t.alphaWrite!==void 0&&(i.alphaWrite=t.alphaWrite),t.stencilWrite!==void 0&&(i.stencilWrite=t.stencilWrite),t.stencilWriteMask!==void 0&&(i.stencilWriteMask=t.stencilWriteMask),t.stencilFunc!==void 0&&(i.stencilFunc=t.stencilFunc),t.stencilRef!==void 0&&(i.stencilRef=t.stencilRef),t.stencilFuncMask!==void 0&&(i.stencilFuncMask=t.stencilFuncMask),t.stencilFail!==void 0&&(i.stencilFail=t.stencilFail),t.stencilZFail!==void 0&&(i.stencilZFail=t.stencilZFail),t.stencilZPass!==void 0&&(i.stencilZPass=t.stencilZPass),t.wireframe!==void 0&&(i.wireframe=t.wireframe),t.wireframeLinewidth!==void 0&&(i.wireframeLinewidth=t.wireframeLinewidth),t.wireframeLinecap!==void 0&&(i.wireframeLinecap=t.wireframeLinecap),t.wireframeLinejoin!==void 0&&(i.wireframeLinejoin=t.wireframeLinejoin),t.rotation!==void 0&&(i.rotation=t.rotation),t.linewidth!==1&&(i.linewidth=t.linewidth),t.dashSize!==void 0&&(i.dashSize=t.dashSize),t.gapSize!==void 0&&(i.gapSize=t.gapSize),t.scale!==void 0&&(i.scale=t.scale),t.polygonOffset!==void 0&&(i.polygonOffset=t.polygonOffset),t.polygonOffsetFactor!==void 0&&(i.polygonOffsetFactor=t.polygonOffsetFactor),t.polygonOffsetUnits!==void 0&&(i.polygonOffsetUnits=t.polygonOffsetUnits),t.dithering!==void 0&&(i.dithering=t.dithering),t.alphaToCoverage!==void 0&&(i.alphaToCoverage=t.alphaToCoverage),t.premultipliedAlpha!==void 0&&(i.premultipliedAlpha=t.premultipliedAlpha),t.visible!==void 0&&(i.visible=t.visible),t.toneMapped!==void 0&&(i.toneMapped=t.toneMapped),t.userData!==void 0&&(i.userData=t.userData),t.vertexColors!==void 0&&(typeof t.vertexColors=="number"?i.vertexColors=t.vertexColors>0:i.vertexColors=t.vertexColors),t.uniforms!==void 0)for(let o in t.uniforms){let a=t.uniforms[o];switch(i.uniforms[o]={},a.type){case"t":i.uniforms[o].value=n(a.value);break;case"c":i.uniforms[o].value=new ne().setHex(a.value);break;case"v2":i.uniforms[o].value=new Lt().fromArray(a.value);break;case"v3":i.uniforms[o].value=new j().fromArray(a.value);break;case"v4":i.uniforms[o].value=new en().fromArray(a.value);break;case"m3":i.uniforms[o].value=new ki().fromArray(a.value);break;case"m4":i.uniforms[o].value=new Me().fromArray(a.value);break;default:i.uniforms[o].value=a.value}}if(t.defines!==void 0&&(i.defines=t.defines),t.vertexShader!==void 0&&(i.vertexShader=t.vertexShader),t.fragmentShader!==void 0&&(i.fragmentShader=t.fragmentShader),t.extensions!==void 0)for(let o in t.extensions)i.extensions[o]=t.extensions[o];if(t.shading!==void 0&&(i.flatShading=t.shading===1),t.size!==void 0&&(i.size=t.size),t.sizeAttenuation!==void 0&&(i.sizeAttenuation=t.sizeAttenuation),t.map!==void 0&&(i.map=n(t.map)),t.matcap!==void 0&&(i.matcap=n(t.matcap)),t.alphaMap!==void 0&&(i.alphaMap=n(t.alphaMap)),t.bumpMap!==void 0&&(i.bumpMap=n(t.bumpMap)),t.bumpScale!==void 0&&(i.bumpScale=t.bumpScale),t.normalMap!==void 0&&(i.normalMap=n(t.normalMap)),t.normalMapType!==void 0&&(i.normalMapType=t.normalMapType),t.normalScale!==void 0){let o=t.normalScale;Array.isArray(o)===!1&&(o=[o,o]),i.normalScale=new Lt().fromArray(o)}return t.displacementMap!==void 0&&(i.displacementMap=n(t.displacementMap)),t.displacementScale!==void 0&&(i.displacementScale=t.displacementScale),t.displacementBias!==void 0&&(i.displacementBias=t.displacementBias),t.roughnessMap!==void 0&&(i.roughnessMap=n(t.roughnessMap)),t.metalnessMap!==void 0&&(i.metalnessMap=n(t.metalnessMap)),t.emissiveMap!==void 0&&(i.emissiveMap=n(t.emissiveMap)),t.emissiveIntensity!==void 0&&(i.emissiveIntensity=t.emissiveIntensity),t.specularMap!==void 0&&(i.specularMap=n(t.specularMap)),t.specularIntensityMap!==void 0&&(i.specularIntensityMap=n(t.specularIntensityMap)),t.specularColorMap!==void 0&&(i.specularColorMap=n(t.specularColorMap)),t.envMap!==void 0&&(i.envMap=n(t.envMap)),t.envMapIntensity!==void 0&&(i.envMapIntensity=t.envMapIntensity),t.reflectivity!==void 0&&(i.reflectivity=t.reflectivity),t.refractionRatio!==void 0&&(i.refractionRatio=t.refractionRatio),t.lightMap!==void 0&&(i.lightMap=n(t.lightMap)),t.lightMapIntensity!==void 0&&(i.lightMapIntensity=t.lightMapIntensity),t.aoMap!==void 0&&(i.aoMap=n(t.aoMap)),t.aoMapIntensity!==void 0&&(i.aoMapIntensity=t.aoMapIntensity),t.gradientMap!==void 0&&(i.gradientMap=n(t.gradientMap)),t.clearcoatMap!==void 0&&(i.clearcoatMap=n(t.clearcoatMap)),t.clearcoatRoughnessMap!==void 0&&(i.clearcoatRoughnessMap=n(t.clearcoatRoughnessMap)),t.clearcoatNormalMap!==void 0&&(i.clearcoatNormalMap=n(t.clearcoatNormalMap)),t.clearcoatNormalScale!==void 0&&(i.clearcoatNormalScale=new Lt().fromArray(t.clearcoatNormalScale)),t.transmissionMap!==void 0&&(i.transmissionMap=n(t.transmissionMap)),t.thicknessMap!==void 0&&(i.thicknessMap=n(t.thicknessMap)),t.sheenColorMap!==void 0&&(i.sheenColorMap=n(t.sheenColorMap)),t.sheenRoughnessMap!==void 0&&(i.sheenRoughnessMap=n(t.sheenRoughnessMap)),i}setTextures(t){return this.textures=t,this}},dM=class{static decodeText(t){if(typeof TextDecoder!="undefined")return new TextDecoder().decode(t);let r="";for(let n=0,i=t.length;n<i;n++)r+=String.fromCharCode(t[n]);try{return decodeURIComponent(escape(r))}catch(n){return r}}static extractUrlBase(t){let r=t.lastIndexOf("/");return r===-1?"./":t.substr(0,r+1)}static resolveURL(t,r){return typeof t!="string"||t===""?"":(/^https?:\/\//i.test(r)&&/^\//.test(t)&&(r=r.replace(/(^https?:\/\/[^\/]+).*/i,"$1")),/^(https?:)?\/\//i.test(t)||/^data:.*,.*$/i.test(t)||/^blob:.*$/i.test(t)?t:r+t)}},N6=class extends Pe{constructor(){super(),this.type="InstancedBufferGeometry",this.instanceCount=1/0}copy(t){return super.copy(t),this.instanceCount=t.instanceCount,this}clone(){return new this.constructor().copy(this)}toJSON(){let t=super.toJSON(this);return t.instanceCount=this.instanceCount,t.isInstancedBufferGeometry=!0,t}};N6.prototype.isInstancedBufferGeometry=!0;var RU=class extends ea{constructor(t){super(t)}load(t,r,n,i){let o=this,a=new Jc(o.manager);a.setPath(o.path),a.setRequestHeader(o.requestHeader),a.setWithCredentials(o.withCredentials),a.load(t,function(s){try{r(o.parse(JSON.parse(s)))}catch(l){i?i(l):console.error(l),o.manager.itemError(t)}},n,i)}parse(t){let r={},n={};function i(p,d){if(r[d]!==void 0)return r[d];let _=p.interleavedBuffers[d],y=o(p,_.buffer),x=B3(_.type,y),b=new em(x,_.stride);return b.uuid=_.uuid,r[d]=b,b}function o(p,d){if(n[d]!==void 0)return n[d];let _=p.arrayBuffers[d],y=new Uint32Array(_).buffer;return n[d]=y,y}let a=t.isInstancedBufferGeometry?new N6:new Pe,s=t.data.index;if(s!==void 0){let p=B3(s.type,s.array);a.setIndex(new Je(p,1))}let l=t.data.attributes;for(let p in l){let d=l[p],g;if(d.isInterleavedBufferAttribute){let _=i(t.data,d.data);g=new tp(_,d.itemSize,d.offset,d.normalized)}else{let _=B3(d.type,d.array),y=d.isInstancedBufferAttribute?rm:Je;g=new y(_,d.itemSize,d.normalized)}d.name!==void 0&&(g.name=d.name),d.usage!==void 0&&g.setUsage(d.usage),d.updateRange!==void 0&&(g.updateRange.offset=d.updateRange.offset,g.updateRange.count=d.updateRange.count),a.setAttribute(p,g)}let c=t.data.morphAttributes;if(c)for(let p in c){let d=c[p],g=[];for(let _=0,y=d.length;_<y;_++){let x=d[_],b;if(x.isInterleavedBufferAttribute){let S=i(t.data,x.data);b=new tp(S,x.itemSize,x.offset,x.normalized)}else{let S=B3(x.type,x.array);b=new Je(S,x.itemSize,x.normalized)}x.name!==void 0&&(b.name=x.name),g.push(b)}a.morphAttributes[p]=g}t.data.morphTargetsRelative&&(a.morphTargetsRelative=!0);let h=t.data.groups||t.data.drawcalls||t.data.offsets;if(h!==void 0)for(let p=0,d=h.length;p!==d;++p){let g=h[p];a.addGroup(g.start,g.count,g.materialIndex)}let f=t.data.boundingSphere;if(f!==void 0){let p=new j;f.center!==void 0&&p.fromArray(f.center),a.boundingSphere=new Zf(p,f.radius)}return t.name&&(a.name=t.name),t.userData&&(a.userData=t.userData),a}},sht=class extends ea{constructor(t){super(t)}load(t,r,n,i){let o=this,a=this.path===""?dM.extractUrlBase(t):this.path;this.resourcePath=this.resourcePath||a;let s=new Jc(this.manager);s.setPath(this.path),s.setRequestHeader(this.requestHeader),s.setWithCredentials(this.withCredentials),s.load(t,function(l){let c=null;try{c=JSON.parse(l)}catch(h){i!==void 0&&i(h),console.error("THREE:ObjectLoader: Can't parse "+t+".",h.message);return}let u=c.metadata;if(u===void 0||u.type===void 0||u.type.toLowerCase()==="geometry"){console.error("THREE.ObjectLoader: Can't load "+t);return}o.parse(c,r)},n,i)}loadAsync(t,r){return Ri(this,null,function*(){let n=this,i=this.path===""?dM.extractUrlBase(t):this.path;this.resourcePath=this.resourcePath||i;let o=new Jc(this.manager);o.setPath(this.path),o.setRequestHeader(this.requestHeader),o.setWithCredentials(this.withCredentials);let a=yield o.loadAsync(t,r),s=JSON.parse(a),l=s.metadata;if(l===void 0||l.type===void 0||l.type.toLowerCase()==="geometry")throw new Error("THREE.ObjectLoader: Can't load "+t);return yield n.parseAsync(s)})}parse(t,r){let n=this.parseAnimations(t.animations),i=this.parseShapes(t.shapes),o=this.parseGeometries(t.geometries,i),a=this.parseImages(t.images,function(){r!==void 0&&r(c)}),s=this.parseTextures(t.textures,a),l=this.parseMaterials(t.materials,s),c=this.parseObject(t.object,o,l,s,n),u=this.parseSkeletons(t.skeletons,c);if(this.bindSkeletons(c,u),r!==void 0){let h=!1;for(let f in a)if(a[f]instanceof HTMLImageElement){h=!0;break}h===!1&&r(c)}return c}parseAsync(t){return Ri(this,null,function*(){let r=this.parseAnimations(t.animations),n=this.parseShapes(t.shapes),i=this.parseGeometries(t.geometries,n),o=yield this.parseImagesAsync(t.images),a=this.parseTextures(t.textures,o),s=this.parseMaterials(t.materials,a),l=this.parseObject(t.object,i,s,a,r),c=this.parseSkeletons(t.skeletons,l);return this.bindSkeletons(l,c),l})}parseShapes(t){let r={};if(t!==void 0)for(let n=0,i=t.length;n<i;n++){let o=new Kc().fromJSON(t[n]);r[o.uuid]=o}return r}parseSkeletons(t,r){let n={},i={};if(r.traverse(function(o){o.isBone&&(i[o.uuid]=o)}),t!==void 0)for(let o=0,a=t.length;o<a;o++){let s=new lM().fromJSON(t[o],i);n[s.uuid]=s}return n}parseGeometries(t,r){let n={};if(t!==void 0){let i=new RU;for(let o=0,a=t.length;o<a;o++){let s,l=t[o];switch(l.type){case"BufferGeometry":case"InstancedBufferGeometry":s=i.parse(l);break;case"Geometry":console.error("THREE.ObjectLoader: The legacy Geometry type is no longer supported.");break;default:l.type in vhe?s=vhe[l.type].fromJSON(l,r):console.warn(`THREE.ObjectLoader: Unsupported geometry type "${l.type}"`)}s.uuid=l.uuid,l.name!==void 0&&(s.name=l.name),s.isBufferGeometry===!0&&l.userData!==void 0&&(s.userData=l.userData),n[l.uuid]=s}}return n}parseMaterials(t,r){let n={},i={};if(t!==void 0){let o=new kU;o.setTextures(r);for(let a=0,s=t.length;a<s;a++){let l=t[a];if(l.type==="MultiMaterial"){let c=[];for(let u=0;u<l.materials.length;u++){let h=l.materials[u];n[h.uuid]===void 0&&(n[h.uuid]=o.parse(h)),c.push(n[h.uuid])}i[l.uuid]=c}else n[l.uuid]===void 0&&(n[l.uuid]=o.parse(l)),i[l.uuid]=n[l.uuid]}}return i}parseAnimations(t){let r={};if(t!==void 0)for(let n=0;n<t.length;n++){let i=t[n],o=Q1.parse(i);r[o.uuid]=o}return r}parseImages(t,r){let n=this,i={},o;function a(l){return n.manager.itemStart(l),o.load(l,function(){n.manager.itemEnd(l)},void 0,function(){n.manager.itemError(l),n.manager.itemEnd(l)})}function s(l){if(typeof l=="string"){let c=l,u=/^(\/\/)|([a-z]+:(\/\/)?)/i.test(c)?c:n.resourcePath+c;return a(u)}else return l.data?{data:B3(l.type,l.data),width:l.width,height:l.height}:null}if(t!==void 0&&t.length>0){let l=new E6(r);o=new ex(l),o.setCrossOrigin(this.crossOrigin);for(let c=0,u=t.length;c<u;c++){let h=t[c],f=h.url;if(Array.isArray(f)){i[h.uuid]=[];for(let p=0,d=f.length;p<d;p++){let g=f[p],_=s(g);_!==null&&(_ instanceof HTMLImageElement?i[h.uuid].push(_):i[h.uuid].push(new Jd(_.data,_.width,_.height)))}}else{let p=s(h.url);p!==null&&(i[h.uuid]=p)}}}return i}parseImagesAsync(t){return Ri(this,null,function*(){let r=this,n={},i;function o(a){return Ri(this,null,function*(){if(typeof a=="string"){let s=a,l=/^(\/\/)|([a-z]+:(\/\/)?)/i.test(s)?s:r.resourcePath+s;return yield i.loadAsync(l)}else return a.data?{data:B3(a.type,a.data),width:a.width,height:a.height}:null})}if(t!==void 0&&t.length>0){i=new ex(this.manager),i.setCrossOrigin(this.crossOrigin);for(let a=0,s=t.length;a<s;a++){let l=t[a],c=l.url;if(Array.isArray(c)){n[l.uuid]=[];for(let u=0,h=c.length;u<h;u++){let f=c[u],p=yield o(f);p!==null&&(p instanceof HTMLImageElement?n[l.uuid].push(p):n[l.uuid].push(new Jd(p.data,p.width,p.height)))}}else{let u=yield o(l.url);u!==null&&(n[l.uuid]=u)}}}return n})}parseTextures(t,r){function n(o,a){return typeof o=="number"?o:(console.warn("THREE.ObjectLoader.parseTexture: Constant should be in numeric form.",o),a[o])}let i={};if(t!==void 0)for(let o=0,a=t.length;o<a;o++){let s=t[o];s.image===void 0&&console.warn('THREE.ObjectLoader: No "image" specified for',s.uuid),r[s.image]===void 0&&console.warn("THREE.ObjectLoader: Undefined image",s.image);let l,c=r[s.image];Array.isArray(c)?(l=new H0(c),c.length===6&&(l.needsUpdate=!0)):(c&&c.data?l=new Jd(c.data,c.width,c.height):l=new vi(c),c&&(l.needsUpdate=!0)),l.uuid=s.uuid,s.name!==void 0&&(l.name=s.name),s.mapping!==void 0&&(l.mapping=n(s.mapping,p0r)),s.offset!==void 0&&l.offset.fromArray(s.offset),s.repeat!==void 0&&l.repeat.fromArray(s.repeat),s.center!==void 0&&l.center.fromArray(s.center),s.rotation!==void 0&&(l.rotation=s.rotation),s.wrap!==void 0&&(l.wrapS=n(s.wrap[0],Mhe),l.wrapT=n(s.wrap[1],Mhe)),s.format!==void 0&&(l.format=s.format),s.type!==void 0&&(l.type=s.type),s.encoding!==void 0&&(l.encoding=s.encoding),s.minFilter!==void 0&&(l.minFilter=n(s.minFilter,Ehe)),s.magFilter!==void 0&&(l.magFilter=n(s.magFilter,Ehe)),s.anisotropy!==void 0&&(l.anisotropy=s.anisotropy),s.flipY!==void 0&&(l.flipY=s.flipY),s.premultiplyAlpha!==void 0&&(l.premultiplyAlpha=s.premultiplyAlpha),s.unpackAlignment!==void 0&&(l.unpackAlignment=s.unpackAlignment),s.userData!==void 0&&(l.userData=s.userData),i[s.uuid]=l}return i}parseObject(t,r,n,i,o){let a;function s(f){return r[f]===void 0&&console.warn("THREE.ObjectLoader: Undefined geometry",f),r[f]}function l(f){if(f!==void 0){if(Array.isArray(f)){let p=[];for(let d=0,g=f.length;d<g;d++){let _=f[d];n[_]===void 0&&console.warn("THREE.ObjectLoader: Undefined material",_),p.push(n[_])}return p}return n[f]===void 0&&console.warn("THREE.ObjectLoader: Undefined material",f),n[f]}}function c(f){return i[f]===void 0&&console.warn("THREE.ObjectLoader: Undefined texture",f),i[f]}let u,h;switch(t.type){case"Scene":a=new q0,t.background!==void 0&&(Number.isInteger(t.background)?a.background=new ne(t.background):a.background=c(t.background)),t.environment!==void 0&&(a.environment=c(t.environment)),t.fog!==void 0&&(t.fog.type==="Fog"?a.fog=new z1(t.fog.color,t.fog.near,t.fog.far):t.fog.type==="FogExp2"&&(a.fog=new O1(t.fog.color,t.fog.density)));break;case"PerspectiveCamera":a=new Ui(t.fov,t.aspect,t.near,t.far),t.focus!==void 0&&(a.focus=t.focus),t.zoom!==void 0&&(a.zoom=t.zoom),t.filmGauge!==void 0&&(a.filmGauge=t.filmGauge),t.filmOffset!==void 0&&(a.filmOffset=t.filmOffset),t.view!==void 0&&(a.view=Object.assign({},t.view));break;case"OrthographicCamera":a=new D1(t.left,t.right,t.top,t.bottom,t.near,t.far),t.zoom!==void 0&&(a.zoom=t.zoom),t.view!==void 0&&(a.view=Object.assign({},t.view));break;case"AmbientLight":a=new L6(t.color,t.intensity);break;case"DirectionalLight":a=new I6(t.color,t.intensity);break;case"PointLight":a=new P6(t.color,t.intensity,t.distance,t.decay);break;case"RectAreaLight":a=new k6(t.color,t.intensity,t.width,t.height);break;case"SpotLight":a=new A6(t.color,t.intensity,t.distance,t.angle,t.penumbra,t.decay);break;case"HemisphereLight":a=new T6(t.color,t.groundColor,t.intensity);break;case"LightProbe":a=new rx().fromJSON(t);break;case"SkinnedMesh":u=s(t.geometry),h=l(t.material),a=new aM(u,h),t.bindMode!==void 0&&(a.bindMode=t.bindMode),t.bindMatrix!==void 0&&a.bindMatrix.fromArray(t.bindMatrix),t.skeleton!==void 0&&(a.skeleton=t.skeleton);break;case"Mesh":u=s(t.geometry),h=l(t.material),a=new ti(u,h);break;case"InstancedMesh":u=s(t.geometry),h=l(t.material);let f=t.count,p=t.instanceMatrix,d=t.instanceColor;a=new i6(u,h,f),a.instanceMatrix=new rm(new Float32Array(p.array),16),d!==void 0&&(a.instanceColor=new rm(new Float32Array(d.array),d.itemSize));break;case"LOD":a=new _U;break;case"Line":a=new ch(s(t.geometry),l(t.material));break;case"LineLoop":a=new o6(s(t.geometry),l(t.material));break;case"LineSegments":a=new Aa(s(t.geometry),l(t.material));break;case"PointCloud":case"Points":a=new im(s(t.geometry),l(t.material));break;case"Sprite":a=new oM(l(t.material));break;case"Group":a=new Xd;break;case"Bone":a=new sM;break;default:a=new or}if(a.uuid=t.uuid,t.name!==void 0&&(a.name=t.name),t.matrix!==void 0?(a.matrix.fromArray(t.matrix),t.matrixAutoUpdate!==void 0&&(a.matrixAutoUpdate=t.matrixAutoUpdate),a.matrixAutoUpdate&&a.matrix.decompose(a.position,a.quaternion,a.scale)):(t.position!==void 0&&a.position.fromArray(t.position),t.rotation!==void 0&&a.rotation.fromArray(t.rotation),t.quaternion!==void 0&&a.quaternion.fromArray(t.quaternion),t.scale!==void 0&&a.scale.fromArray(t.scale)),t.castShadow!==void 0&&(a.castShadow=t.castShadow),t.receiveShadow!==void 0&&(a.receiveShadow=t.receiveShadow),t.shadow&&(t.shadow.bias!==void 0&&(a.shadow.bias=t.shadow.bias),t.shadow.normalBias!==void 0&&(a.shadow.normalBias=t.shadow.normalBias),t.shadow.radius!==void 0&&(a.shadow.radius=t.shadow.radius),t.shadow.mapSize!==void 0&&a.shadow.mapSize.fromArray(t.shadow.mapSize),t.shadow.camera!==void 0&&(a.shadow.camera=this.parseObject(t.shadow.camera))),t.visible!==void 0&&(a.visible=t.visible),t.frustumCulled!==void 0&&(a.frustumCulled=t.frustumCulled),t.renderOrder!==void 0&&(a.renderOrder=t.renderOrder),t.userData!==void 0&&(a.userData=t.userData),t.layers!==void 0&&(a.layers.mask=t.layers),t.children!==void 0){let f=t.children;for(let p=0;p<f.length;p++)a.add(this.parseObject(f[p],r,n,i,o))}if(t.animations!==void 0){let f=t.animations;for(let p=0;p<f.length;p++){let d=f[p];a.animations.push(o[d])}}if(t.type==="LOD"){t.autoUpdate!==void 0&&(a.autoUpdate=t.autoUpdate);let f=t.levels;for(let p=0;p<f.length;p++){let d=f[p],g=a.getObjectByProperty("uuid",d.object);g!==void 0&&a.addLevel(g,d.distance)}}return a}bindSkeletons(t,r){Object.keys(r).length!==0&&t.traverse(function(n){if(n.isSkinnedMesh===!0&&n.skeleton!==void 0){let i=r[n.skeleton];i===void 0?console.warn("THREE.ObjectLoader: No skeleton found with UUID:",n.skeleton):n.bind(i,n.bindMatrix)}})}setTexturePath(t){return console.warn("THREE.ObjectLoader: .setTexturePath() has been renamed to .setResourcePath()."),this.setResourcePath(t)}},p0r={UVMapping:XU,CubeReflectionMapping:nx,CubeRefractionMapping:ix,EquirectangularReflectionMapping:YP,EquirectangularRefractionMapping:jP,CubeUVReflectionMapping:xM,CubeUVRefractionMapping:z6},Mhe={RepeatWrapping:XP,ClampToEdgeWrapping:Jo,MirroredRepeatWrapping:$P},Ehe={NearestFilter:Li,NearestMipmapNearestFilter:oU,NearestMipmapLinearFilter:aU,LinearFilter:ii,LinearMipmapNearestFilter:Lht,LinearMipmapLinearFilter:ox},NU=class extends ea{constructor(t){super(t),typeof createImageBitmap=="undefined"&&console.warn("THREE.ImageBitmapLoader: createImageBitmap() not supported."),typeof fetch=="undefined"&&console.warn("THREE.ImageBitmapLoader: fetch() not supported."),this.options={premultiplyAlpha:"none"}}setOptions(t){return this.options=t,this}load(t,r,n,i){t===void 0&&(t=""),this.path!==void 0&&(t=this.path+t),t=this.manager.resolveURL(t);let o=this,a=tx.get(t);if(a!==void 0)return o.manager.itemStart(t),setTimeout(function(){r&&r(a),o.manager.itemEnd(t)},0),a;let s={};s.credentials=this.crossOrigin==="anonymous"?"same-origin":"include",s.headers=this.requestHeader,fetch(t,s).then(function(l){return l.blob()}).then(function(l){return createImageBitmap(l,Object.assign(o.options,{colorSpaceConversion:"none"}))}).then(function(l){tx.add(t,l),r&&r(l),o.manager.itemEnd(t)}).catch(function(l){i&&i(l),o.manager.itemError(t),o.manager.itemEnd(t)}),o.manager.itemStart(t)}};NU.prototype.isImageBitmapLoader=!0;var WV,zht={getContext:function(){return WV===void 0&&(WV=new(window.AudioContext||window.webkitAudioContext)),WV},setContext:function(e){WV=e}},DU=class extends ea{constructor(t){super(t)}load(t,r,n,i){let o=this,a=new Jc(this.manager);a.setResponseType("arraybuffer"),a.setPath(this.path),a.setRequestHeader(this.requestHeader),a.setWithCredentials(this.withCredentials),a.load(t,function(s){try{let l=s.slice(0);zht.getContext().decodeAudioData(l,function(u){r(u)})}catch(l){i?i(l):console.error(l),o.manager.itemError(t)}},n,i)}},OU=class extends rx{constructor(t,r,n=1){super(void 0,n);let i=new ne().set(t),o=new ne().set(r),a=new j(i.r,i.g,i.b),s=new j(o.r,o.g,o.b),l=Math.sqrt(Math.PI),c=l*Math.sqrt(.75);this.sh.coefficients[0].copy(a).add(s).multiplyScalar(l),this.sh.coefficients[1].copy(a).sub(s).multiplyScalar(c)}};OU.prototype.isHemisphereLightProbe=!0;var zU=class extends rx{constructor(t,r=1){super(void 0,r);let n=new ne().set(t);this.sh.coefficients[0].set(n.r,n.g,n.b).multiplyScalar(2*Math.sqrt(Math.PI))}};zU.prototype.isAmbientLightProbe=!0;var The=new Me,Che=new Me,y1=new Me,lht=class{constructor(){this.type="StereoCamera",this.aspect=1,this.eyeSep=.064,this.cameraL=new Ui,this.cameraL.layers.enable(1),this.cameraL.matrixAutoUpdate=!1,this.cameraR=new Ui,this.cameraR.layers.enable(2),this.cameraR.matrixAutoUpdate=!1,this._cache={focus:null,fov:null,aspect:null,near:null,far:null,zoom:null,eyeSep:null}}update(t){let r=this._cache;if(r.focus!==t.focus||r.fov!==t.fov||r.aspect!==t.aspect*this.aspect||r.near!==t.near||r.far!==t.far||r.zoom!==t.zoom||r.eyeSep!==this.eyeSep){r.focus=t.focus,r.fov=t.fov,r.aspect=t.aspect*this.aspect,r.near=t.near,r.far=t.far,r.zoom=t.zoom,r.eyeSep=this.eyeSep,y1.copy(t.projectionMatrix);let i=r.eyeSep/2,o=i*r.near/r.focus,a=r.near*Math.tan(P1*r.fov*.5)/r.zoom,s,l;Che.elements[12]=-i,The.elements[12]=i,s=-a*r.aspect+o,l=a*r.aspect+o,y1.elements[0]=2*r.near/(l-s),y1.elements[8]=(l+s)/(l-s),this.cameraL.projectionMatrix.copy(y1),s=-a*r.aspect-o,l=a*r.aspect-o,y1.elements[0]=2*r.near/(l-s),y1.elements[8]=(l+s)/(l-s),this.cameraR.projectionMatrix.copy(y1)}this.cameraL.matrixWorld.copy(t.matrixWorld).multiply(Che),this.cameraR.matrixWorld.copy(t.matrixWorld).multiply(The)}},mM=class{constructor(t=!0){this.autoStart=t,this.startTime=0,this.oldTime=0,this.elapsedTime=0,this.running=!1}start(){this.startTime=Ahe(),this.oldTime=this.startTime,this.elapsedTime=0,this.running=!0}stop(){this.getElapsedTime(),this.running=!1,this.autoStart=!1}getElapsedTime(){return this.getDelta(),this.elapsedTime}getDelta(){let t=0;if(this.autoStart&&!this.running)return this.start(),0;if(this.running){let r=Ahe();t=(r-this.oldTime)/1e3,this.oldTime=r,this.elapsedTime+=t}return t}};function Ahe(){return(typeof performance=="undefined"?Date:performance).now()}var v1=new j,Phe=new yi,d0r=new j,x1=new j,cht=class extends or{constructor(){super(),this.type="AudioListener",this.context=zht.getContext(),this.gain=this.context.createGain(),this.gain.connect(this.context.destination),this.filter=null,this.timeDelta=0,this._clock=new mM}getInput(){return this.gain}removeFilter(){return this.filter!==null&&(this.gain.disconnect(this.filter),this.filter.disconnect(this.context.destination),this.gain.connect(this.context.destination),this.filter=null),this}getFilter(){return this.filter}setFilter(t){return this.filter!==null?(this.gain.disconnect(this.filter),this.filter.disconnect(this.context.destination)):this.gain.disconnect(this.context.destination),this.filter=t,this.gain.connect(this.filter),this.filter.connect(this.context.destination),this}getMasterVolume(){return this.gain.gain.value}setMasterVolume(t){return this.gain.gain.setTargetAtTime(t,this.context.currentTime,.01),this}updateMatrixWorld(t){super.updateMatrixWorld(t);let r=this.context.listener,n=this.up;if(this.timeDelta=this._clock.getDelta(),this.matrixWorld.decompose(v1,Phe,d0r),x1.set(0,0,-1).applyQuaternion(Phe),r.positionX){let i=this.context.currentTime+this.timeDelta;r.positionX.linearRampToValueAtTime(v1.x,i),r.positionY.linearRampToValueAtTime(v1.y,i),r.positionZ.linearRampToValueAtTime(v1.z,i),r.forwardX.linearRampToValueAtTime(x1.x,i),r.forwardY.linearRampToValueAtTime(x1.y,i),r.forwardZ.linearRampToValueAtTime(x1.z,i),r.upX.linearRampToValueAtTime(n.x,i),r.upY.linearRampToValueAtTime(n.y,i),r.upZ.linearRampToValueAtTime(n.z,i)}else r.setPosition(v1.x,v1.y,v1.z),r.setOrientation(x1.x,x1.y,x1.z,n.x,n.y,n.z)}},D6=class extends or{constructor(t){super(),this.type="Audio",this.listener=t,this.context=t.context,this.gain=this.context.createGain(),this.gain.connect(t.getInput()),this.autoplay=!1,this.buffer=null,this.detune=0,this.loop=!1,this.loopStart=0,this.loopEnd=0,this.offset=0,this.duration=void 0,this.playbackRate=1,this.isPlaying=!1,this.hasPlaybackControl=!0,this.source=null,this.sourceType="empty",this._startedAt=0,this._progress=0,this._connected=!1,this.filters=[]}getOutput(){return this.gain}setNodeSource(t){return this.hasPlaybackControl=!1,this.sourceType="audioNode",this.source=t,this.connect(),this}setMediaElementSource(t){return this.hasPlaybackControl=!1,this.sourceType="mediaNode",this.source=this.context.createMediaElementSource(t),this.connect(),this}setMediaStreamSource(t){return this.hasPlaybackControl=!1,this.sourceType="mediaStreamNode",this.source=this.context.createMediaStreamSource(t),this.connect(),this}setBuffer(t){return this.buffer=t,this.sourceType="buffer",this.autoplay&&this.play(),this}play(t=0){if(this.isPlaying===!0){console.warn("THREE.Audio: Audio is already playing.");return}if(this.hasPlaybackControl===!1){console.warn("THREE.Audio: this Audio has no playback control.");return}this._startedAt=this.context.currentTime+t;let r=this.context.createBufferSource();return r.buffer=this.buffer,r.loop=this.loop,r.loopStart=this.loopStart,r.loopEnd=this.loopEnd,r.onended=this.onEnded.bind(this),r.start(this._startedAt,this._progress+this.offset,this.duration),this.isPlaying=!0,this.source=r,this.setDetune(this.detune),this.setPlaybackRate(this.playbackRate),this.connect()}pause(){if(this.hasPlaybackControl===!1){console.warn("THREE.Audio: this Audio has no playback control.");return}return this.isPlaying===!0&&(this._progress+=Math.max(this.context.currentTime-this._startedAt,0)*this.playbackRate,this.loop===!0&&(this._progress=this._progress%(this.duration||this.buffer.duration)),this.source.stop(),this.source.onended=null,this.isPlaying=!1),this}stop(){if(this.hasPlaybackControl===!1){console.warn("THREE.Audio: this Audio has no playback control.");return}return this._progress=0,this.source.stop(),this.source.onended=null,this.isPlaying=!1,this}connect(){if(this.filters.length>0){this.source.connect(this.filters[0]);for(let t=1,r=this.filters.length;t<r;t++)this.filters[t-1].connect(this.filters[t]);this.filters[this.filters.length-1].connect(this.getOutput())}else this.source.connect(this.getOutput());return this._connected=!0,this}disconnect(){if(this.filters.length>0){this.source.disconnect(this.filters[0]);for(let t=1,r=this.filters.length;t<r;t++)this.filters[t-1].disconnect(this.filters[t]);this.filters[this.filters.length-1].disconnect(this.getOutput())}else this.source.disconnect(this.getOutput());return this._connected=!1,this}getFilters(){return this.filters}setFilters(t){return t||(t=[]),this._connected===!0?(this.disconnect(),this.filters=t.slice(),this.connect()):this.filters=t.slice(),this}setDetune(t){if(this.detune=t,this.source.detune!==void 0)return this.isPlaying===!0&&this.source.detune.setTargetAtTime(this.detune,this.context.currentTime,.01),this}getDetune(){return this.detune}getFilter(){return this.getFilters()[0]}setFilter(t){return this.setFilters(t?[t]:[])}setPlaybackRate(t){if(this.hasPlaybackControl===!1){console.warn("THREE.Audio: this Audio has no playback control.");return}return this.playbackRate=t,this.isPlaying===!0&&this.source.playbackRate.setTargetAtTime(this.playbackRate,this.context.currentTime,.01),this}getPlaybackRate(){return this.playbackRate}onEnded(){this.isPlaying=!1}getLoop(){return this.hasPlaybackControl===!1?(console.warn("THREE.Audio: this Audio has no playback control."),!1):this.loop}setLoop(t){if(this.hasPlaybackControl===!1){console.warn("THREE.Audio: this Audio has no playback control.");return}return this.loop=t,this.isPlaying===!0&&(this.source.loop=this.loop),this}setLoopStart(t){return this.loopStart=t,this}setLoopEnd(t){return this.loopEnd=t,this}getVolume(){return this.gain.gain.value}setVolume(t){return this.gain.gain.setTargetAtTime(t,this.context.currentTime,.01),this}},b1=new j,Ihe=new yi,m0r=new j,w1=new j,uht=class extends D6{constructor(t){super(t),this.panner=this.context.createPanner(),this.panner.panningModel="HRTF",this.panner.connect(this.gain)}getOutput(){return this.panner}getRefDistance(){return this.panner.refDistance}setRefDistance(t){return this.panner.refDistance=t,this}getRolloffFactor(){return this.panner.rolloffFactor}setRolloffFactor(t){return this.panner.rolloffFactor=t,this}getDistanceModel(){return this.panner.distanceModel}setDistanceModel(t){return this.panner.distanceModel=t,this}getMaxDistance(){return this.panner.maxDistance}setMaxDistance(t){return this.panner.maxDistance=t,this}setDirectionalCone(t,r,n){return this.panner.coneInnerAngle=t,this.panner.coneOuterAngle=r,this.panner.coneOuterGain=n,this}updateMatrixWorld(t){if(super.updateMatrixWorld(t),this.hasPlaybackControl===!0&&this.isPlaying===!1)return;this.matrixWorld.decompose(b1,Ihe,m0r),w1.set(0,0,1).applyQuaternion(Ihe);let r=this.panner;if(r.positionX){let n=this.context.currentTime+this.listener.timeDelta;r.positionX.linearRampToValueAtTime(b1.x,n),r.positionY.linearRampToValueAtTime(b1.y,n),r.positionZ.linearRampToValueAtTime(b1.z,n),r.orientationX.linearRampToValueAtTime(w1.x,n),r.orientationY.linearRampToValueAtTime(w1.y,n),r.orientationZ.linearRampToValueAtTime(w1.z,n)}else r.setPosition(b1.x,b1.y,b1.z),r.setOrientation(w1.x,w1.y,w1.z)}},FU=class{constructor(t,r=2048){this.analyser=t.context.createAnalyser(),this.analyser.fftSize=r,this.data=new Uint8Array(this.analyser.frequencyBinCount),t.getOutput().connect(this.analyser)}getFrequencyData(){return this.analyser.getByteFrequencyData(this.data),this.data}getAverageFrequency(){let t=0,r=this.getFrequencyData();for(let n=0;n<r.length;n++)t+=r[n];return t/r.length}},BU=class{constructor(t,r,n){this.binding=t,this.valueSize=n;let i,o,a;switch(r){case"quaternion":i=this._slerp,o=this._slerpAdditive,a=this._setAdditiveIdentityQuaternion,this.buffer=new Float64Array(n*6),this._workIndex=5;break;case"string":case"bool":i=this._select,o=this._select,a=this._setAdditiveIdentityOther,this.buffer=new Array(n*5);break;default:i=this._lerp,o=this._lerpAdditive,a=this._setAdditiveIdentityNumeric,this.buffer=new Float64Array(n*5)}this._mixBufferRegion=i,this._mixBufferRegionAdditive=o,this._setIdentity=a,this._origIndex=3,this._addIndex=4,this.cumulativeWeight=0,this.cumulativeWeightAdditive=0,this.useCount=0,this.referenceCount=0}accumulate(t,r){let n=this.buffer,i=this.valueSize,o=t*i+i,a=this.cumulativeWeight;if(a===0){for(let s=0;s!==i;++s)n[o+s]=n[s];a=r}else{a+=r;let s=r/a;this._mixBufferRegion(n,o,0,s,i)}this.cumulativeWeight=a}accumulateAdditive(t){let r=this.buffer,n=this.valueSize,i=n*this._addIndex;this.cumulativeWeightAdditive===0&&this._setIdentity(),this._mixBufferRegionAdditive(r,i,0,t,n),this.cumulativeWeightAdditive+=t}apply(t){let r=this.valueSize,n=this.buffer,i=t*r+r,o=this.cumulativeWeight,a=this.cumulativeWeightAdditive,s=this.binding;if(this.cumulativeWeight=0,this.cumulativeWeightAdditive=0,o<1){let l=r*this._origIndex;this._mixBufferRegion(n,i,l,1-o,r)}a>0&&this._mixBufferRegionAdditive(n,i,this._addIndex*r,1,r);for(let l=r,c=r+r;l!==c;++l)if(n[l]!==n[l+r]){s.setValue(n,i);break}}saveOriginalState(){let t=this.binding,r=this.buffer,n=this.valueSize,i=n*this._origIndex;t.getValue(r,i);for(let o=n,a=i;o!==a;++o)r[o]=r[i+o%n];this._setIdentity(),this.cumulativeWeight=0,this.cumulativeWeightAdditive=0}restoreOriginalState(){let t=this.valueSize*3;this.binding.setValue(this.buffer,t)}_setAdditiveIdentityNumeric(){let t=this._addIndex*this.valueSize,r=t+this.valueSize;for(let n=t;n<r;n++)this.buffer[n]=0}_setAdditiveIdentityQuaternion(){this._setAdditiveIdentityNumeric(),this.buffer[this._addIndex*this.valueSize+3]=1}_setAdditiveIdentityOther(){let t=this._origIndex*this.valueSize,r=this._addIndex*this.valueSize;for(let n=0;n<this.valueSize;n++)this.buffer[r+n]=this.buffer[t+n]}_select(t,r,n,i,o){if(i>=.5)for(let a=0;a!==o;++a)t[r+a]=t[n+a]}_slerp(t,r,n,i){yi.slerpFlat(t,r,t,r,t,n,i)}_slerpAdditive(t,r,n,i,o){let a=this._workIndex*o;yi.multiplyQuaternionsFlat(t,a,t,r,t,n),yi.slerpFlat(t,r,t,r,t,a,i)}_lerp(t,r,n,i,o){let a=1-i;for(let s=0;s!==o;++s){let l=r+s;t[l]=t[l]*a+t[n+s]*i}}_lerpAdditive(t,r,n,i,o){for(let a=0;a!==o;++a){let s=r+a;t[s]=t[s]+t[n+a]*i}}},Fht="\\[\\]\\.:\\/",g0r=new RegExp("["+Fht+"]","g"),Bht="[^"+Fht+"]",_0r="[^"+Fht.replace("\\.","")+"]",y0r=/((?:WC+[\/:])*)/.source.replace("WC",Bht),v0r=/(WCOD+)?/.source.replace("WCOD",_0r),x0r=/(?:\.(WC+)(?:\[(.+)\])?)?/.source.replace("WC",Bht),b0r=/\.(WC+)(?:\[(.+)\])?/.source.replace("WC",Bht),w0r=new RegExp("^"+y0r+v0r+x0r+b0r+"$"),S0r=["material","materials","bones"],hht=class{constructor(t,r,n){let i=n||Cr.parseTrackName(r);this._targetGroup=t,this._bindings=t.subscribe_(r,i)}getValue(t,r){this.bind();let n=this._targetGroup.nCachedObjects_,i=this._bindings[n];i!==void 0&&i.getValue(t,r)}setValue(t,r){let n=this._bindings;for(let i=this._targetGroup.nCachedObjects_,o=n.length;i!==o;++i)n[i].setValue(t,r)}bind(){let t=this._bindings;for(let r=this._targetGroup.nCachedObjects_,n=t.length;r!==n;++r)t[r].bind()}unbind(){let t=this._bindings;for(let r=this._targetGroup.nCachedObjects_,n=t.length;r!==n;++r)t[r].unbind()}},Cr=class{constructor(t,r,n){this.path=r,this.parsedPath=n||Cr.parseTrackName(r),this.node=Cr.findNode(t,this.parsedPath.nodeName)||t,this.rootNode=t,this.getValue=this._getValue_unbound,this.setValue=this._setValue_unbound}static create(t,r,n){return t&&t.isAnimationObjectGroup?new Cr.Composite(t,r,n):new Cr(t,r,n)}static sanitizeNodeName(t){return t.replace(/\s/g,"_").replace(g0r,"")}static parseTrackName(t){let r=w0r.exec(t);if(!r)throw new Error("PropertyBinding: Cannot parse trackName: "+t);let n={nodeName:r[2],objectName:r[3],objectIndex:r[4],propertyName:r[5],propertyIndex:r[6]},i=n.nodeName&&n.nodeName.lastIndexOf(".");if(i!==void 0&&i!==-1){let o=n.nodeName.substring(i+1);S0r.indexOf(o)!==-1&&(n.nodeName=n.nodeName.substring(0,i),n.objectName=o)}if(n.propertyName===null||n.propertyName.length===0)throw new Error("PropertyBinding: can not parse propertyName from trackName: "+t);return n}static findNode(t,r){if(!r||r===""||r==="."||r===-1||r===t.name||r===t.uuid)return t;if(t.skeleton){let n=t.skeleton.getBoneByName(r);if(n!==void 0)return n}if(t.children){let n=function(o){for(let a=0;a<o.length;a++){let s=o[a];if(s.name===r||s.uuid===r)return s;let l=n(s.children);if(l)return l}return null},i=n(t.children);if(i)return i}return null}_getValue_unavailable(){}_setValue_unavailable(){}_getValue_direct(t,r){t[r]=this.targetObject[this.propertyName]}_getValue_array(t,r){let n=this.resolvedProperty;for(let i=0,o=n.length;i!==o;++i)t[r++]=n[i]}_getValue_arrayElement(t,r){t[r]=this.resolvedProperty[this.propertyIndex]}_getValue_toArray(t,r){this.resolvedProperty.toArray(t,r)}_setValue_direct(t,r){this.targetObject[this.propertyName]=t[r]}_setValue_direct_setNeedsUpdate(t,r){this.targetObject[this.propertyName]=t[r],this.targetObject.needsUpdate=!0}_setValue_direct_setMatrixWorldNeedsUpdate(t,r){this.targetObject[this.propertyName]=t[r],this.targetObject.matrixWorldNeedsUpdate=!0}_setValue_array(t,r){let n=this.resolvedProperty;for(let i=0,o=n.length;i!==o;++i)n[i]=t[r++]}_setValue_array_setNeedsUpdate(t,r){let n=this.resolvedProperty;for(let i=0,o=n.length;i!==o;++i)n[i]=t[r++];this.targetObject.needsUpdate=!0}_setValue_array_setMatrixWorldNeedsUpdate(t,r){let n=this.resolvedProperty;for(let i=0,o=n.length;i!==o;++i)n[i]=t[r++];this.targetObject.matrixWorldNeedsUpdate=!0}_setValue_arrayElement(t,r){this.resolvedProperty[this.propertyIndex]=t[r]}_setValue_arrayElement_setNeedsUpdate(t,r){this.resolvedProperty[this.propertyIndex]=t[r],this.targetObject.needsUpdate=!0}_setValue_arrayElement_setMatrixWorldNeedsUpdate(t,r){this.resolvedProperty[this.propertyIndex]=t[r],this.targetObject.matrixWorldNeedsUpdate=!0}_setValue_fromArray(t,r){this.resolvedProperty.fromArray(t,r)}_setValue_fromArray_setNeedsUpdate(t,r){this.resolvedProperty.fromArray(t,r),this.targetObject.needsUpdate=!0}_setValue_fromArray_setMatrixWorldNeedsUpdate(t,r){this.resolvedProperty.fromArray(t,r),this.targetObject.matrixWorldNeedsUpdate=!0}_getValue_unbound(t,r){this.bind(),this.getValue(t,r)}_setValue_unbound(t,r){this.bind(),this.setValue(t,r)}bind(){let t=this.node,r=this.parsedPath,n=r.objectName,i=r.propertyName,o=r.propertyIndex;if(t||(t=Cr.findNode(this.rootNode,r.nodeName)||this.rootNode,this.node=t),this.getValue=this._getValue_unavailable,this.setValue=this._setValue_unavailable,!t){console.error("THREE.PropertyBinding: Trying to update node for track: "+this.path+" but it wasn't found.");return}if(n){let c=r.objectIndex;switch(n){case"materials":if(!t.material){console.error("THREE.PropertyBinding: Can not bind to material as node does not have a material.",this);return}if(!t.material.materials){console.error("THREE.PropertyBinding: Can not bind to material.materials as node.material does not have a materials array.",this);return}t=t.material.materials;break;case"bones":if(!t.skeleton){console.error("THREE.PropertyBinding: Can not bind to bones as node does not have a skeleton.",this);return}t=t.skeleton.bones;for(let u=0;u<t.length;u++)if(t[u].name===c){c=u;break}break;default:if(t[n]===void 0){console.error("THREE.PropertyBinding: Can not bind to objectName of node undefined.",this);return}t=t[n]}if(c!==void 0){if(t[c]===void 0){console.error("THREE.PropertyBinding: Trying to bind to objectIndex of objectName, but is undefined.",this,t);return}t=t[c]}}let a=t[i];if(a===void 0){let c=r.nodeName;console.error("THREE.PropertyBinding: Trying to update property for track: "+c+"."+i+" but it wasn't found.",t);return}let s=this.Versioning.None;this.targetObject=t,t.needsUpdate!==void 0?s=this.Versioning.NeedsUpdate:t.matrixWorldNeedsUpdate!==void 0&&(s=this.Versioning.MatrixWorldNeedsUpdate);let l=this.BindingType.Direct;if(o!==void 0){if(i==="morphTargetInfluences"){if(!t.geometry){console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.",this);return}if(t.geometry.isBufferGeometry){if(!t.geometry.morphAttributes){console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.morphAttributes.",this);return}t.morphTargetDictionary[o]!==void 0&&(o=t.morphTargetDictionary[o])}else{console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences on THREE.Geometry. Use THREE.BufferGeometry instead.",this);return}}l=this.BindingType.ArrayElement,this.resolvedProperty=a,this.propertyIndex=o}else a.fromArray!==void 0&&a.toArray!==void 0?(l=this.BindingType.HasFromToArray,this.resolvedProperty=a):Array.isArray(a)?(l=this.BindingType.EntireArray,this.resolvedProperty=a):this.propertyName=i;this.getValue=this.GetterByBindingType[l],this.setValue=this.SetterByBindingTypeAndVersioning[l][s]}unbind(){this.node=null,this.getValue=this._getValue_unbound,this.setValue=this._setValue_unbound}};Cr.Composite=hht;Cr.prototype.BindingType={Direct:0,EntireArray:1,ArrayElement:2,HasFromToArray:3};Cr.prototype.Versioning={None:0,NeedsUpdate:1,MatrixWorldNeedsUpdate:2};Cr.prototype.GetterByBindingType=[Cr.prototype._getValue_direct,Cr.prototype._getValue_array,Cr.prototype._getValue_arrayElement,Cr.prototype._getValue_toArray];Cr.prototype.SetterByBindingTypeAndVersioning=[[Cr.prototype._setValue_direct,Cr.prototype._setValue_direct_setNeedsUpdate,Cr.prototype._setValue_direct_setMatrixWorldNeedsUpdate],[Cr.prototype._setValue_array,Cr.prototype._setValue_array_setNeedsUpdate,Cr.prototype._setValue_array_setMatrixWorldNeedsUpdate],[Cr.prototype._setValue_arrayElement,Cr.prototype._setValue_arrayElement_setNeedsUpdate,Cr.prototype._setValue_arrayElement_setMatrixWorldNeedsUpdate],[Cr.prototype._setValue_fromArray,Cr.prototype._setValue_fromArray_setNeedsUpdate,Cr.prototype._setValue_fromArray_setMatrixWorldNeedsUpdate]];var HU=class{constructor(){this.uuid=Nl(),this._objects=Array.prototype.slice.call(arguments),this.nCachedObjects_=0;let t={};this._indicesByUUID=t;for(let n=0,i=arguments.length;n!==i;++n)t[arguments[n].uuid]=n;this._paths=[],this._parsedPaths=[],this._bindings=[],this._bindingsIndicesByPath={};let r=this;this.stats={objects:{get total(){return r._objects.length},get inUse(){return this.total-r.nCachedObjects_}},get bindingsPerObject(){return r._bindings.length}}}add(){let t=this._objects,r=this._indicesByUUID,n=this._paths,i=this._parsedPaths,o=this._bindings,a=o.length,s,l=t.length,c=this.nCachedObjects_;for(let u=0,h=arguments.length;u!==h;++u){let f=arguments[u],p=f.uuid,d=r[p];if(d===void 0){d=l++,r[p]=d,t.push(f);for(let g=0,_=a;g!==_;++g)o[g].push(new Cr(f,n[g],i[g]))}else if(d<c){s=t[d];let g=--c,_=t[g];r[_.uuid]=d,t[d]=_,r[p]=g,t[g]=f;for(let y=0,x=a;y!==x;++y){let b=o[y],S=b[g],C=b[d];b[d]=S,C===void 0&&(C=new Cr(f,n[y],i[y])),b[g]=C}}else t[d]!==s&&console.error("THREE.AnimationObjectGroup: Different objects with the same UUID detected. Clean the caches or recreate your infrastructure when reloading scenes.")}this.nCachedObjects_=c}remove(){let t=this._objects,r=this._indicesByUUID,n=this._bindings,i=n.length,o=this.nCachedObjects_;for(let a=0,s=arguments.length;a!==s;++a){let l=arguments[a],c=l.uuid,u=r[c];if(u!==void 0&&u>=o){let h=o++,f=t[h];r[f.uuid]=u,t[u]=f,r[c]=h,t[h]=l;for(let p=0,d=i;p!==d;++p){let g=n[p],_=g[h],y=g[u];g[u]=_,g[h]=y}}}this.nCachedObjects_=o}uncache(){let t=this._objects,r=this._indicesByUUID,n=this._bindings,i=n.length,o=this.nCachedObjects_,a=t.length;for(let s=0,l=arguments.length;s!==l;++s){let c=arguments[s],u=c.uuid,h=r[u];if(h!==void 0)if(delete r[u],h<o){let f=--o,p=t[f],d=--a,g=t[d];r[p.uuid]=h,t[h]=p,r[g.uuid]=f,t[f]=g,t.pop();for(let _=0,y=i;_!==y;++_){let x=n[_],b=x[f],S=x[d];x[h]=b,x[f]=S,x.pop()}}else{let f=--a,p=t[f];f>0&&(r[p.uuid]=h),t[h]=p,t.pop();for(let d=0,g=i;d!==g;++d){let _=n[d];_[h]=_[f],_.pop()}}}this.nCachedObjects_=o}subscribe_(t,r){let n=this._bindingsIndicesByPath,i=n[t],o=this._bindings;if(i!==void 0)return o[i];let a=this._paths,s=this._parsedPaths,l=this._objects,c=l.length,u=this.nCachedObjects_,h=new Array(c);i=o.length,n[t]=i,a.push(t),s.push(r),o.push(h);for(let f=u,p=l.length;f!==p;++f){let d=l[f];h[f]=new Cr(d,t,r)}return h}unsubscribe_(t){let r=this._bindingsIndicesByPath,n=r[t];if(n!==void 0){let i=this._paths,o=this._parsedPaths,a=this._bindings,s=a.length-1,l=a[s],c=t[s];r[c]=n,a[n]=l,a.pop(),o[n]=o[s],o.pop(),i[n]=i[s],i.pop()}}};HU.prototype.isAnimationObjectGroup=!0;var fht=class{constructor(t,r,n=null,i=r.blendMode){this._mixer=t,this._clip=r,this._localRoot=n,this.blendMode=i;let o=r.tracks,a=o.length,s=new Array(a),l={endingStart:E1,endingEnd:E1};for(let c=0;c!==a;++c){let u=o[c].createInterpolant(null);s[c]=u,u.settings=l}this._interpolantSettings=l,this._interpolants=s,this._propertyBindings=new Array(a),this._cacheIndex=null,this._byClipCacheIndex=null,this._timeScaleInterpolant=null,this._weightInterpolant=null,this.loop=Ife,this._loopCount=-1,this._startTime=null,this.time=0,this.timeScale=1,this._effectiveTimeScale=1,this.weight=1,this._effectiveWeight=1,this.repetitions=1/0,this.paused=!1,this.enabled=!0,this.clampWhenFinished=!1,this.zeroSlopeAtStart=!0,this.zeroSlopeAtEnd=!0}play(){return this._mixer._activateAction(this),this}stop(){return this._mixer._deactivateAction(this),this.reset()}reset(){return this.paused=!1,this.enabled=!0,this.time=0,this._loopCount=-1,this._startTime=null,this.stopFading().stopWarping()}isRunning(){return this.enabled&&!this.paused&&this.timeScale!==0&&this._startTime===null&&this._mixer._isActiveAction(this)}isScheduled(){return this._mixer._isActiveAction(this)}startAt(t){return this._startTime=t,this}setLoop(t,r){return this.loop=t,this.repetitions=r,this}setEffectiveWeight(t){return this.weight=t,this._effectiveWeight=this.enabled?t:0,this.stopFading()}getEffectiveWeight(){return this._effectiveWeight}fadeIn(t){return this._scheduleFading(t,0,1)}fadeOut(t){return this._scheduleFading(t,1,0)}crossFadeFrom(t,r,n){if(t.fadeOut(r),this.fadeIn(r),n){let i=this._clip.duration,o=t._clip.duration,a=o/i,s=i/o;t.warp(1,a,r),this.warp(s,1,r)}return this}crossFadeTo(t,r,n){return t.crossFadeFrom(this,r,n)}stopFading(){let t=this._weightInterpolant;return t!==null&&(this._weightInterpolant=null,this._mixer._takeBackControlInterpolant(t)),this}setEffectiveTimeScale(t){return this.timeScale=t,this._effectiveTimeScale=this.paused?0:t,this.stopWarping()}getEffectiveTimeScale(){return this._effectiveTimeScale}setDuration(t){return this.timeScale=this._clip.duration/t,this.stopWarping()}syncWith(t){return this.time=t.time,this.timeScale=t.timeScale,this.stopWarping()}halt(t){return this.warp(this._effectiveTimeScale,0,t)}warp(t,r,n){let i=this._mixer,o=i.time,a=this.timeScale,s=this._timeScaleInterpolant;s===null&&(s=i._lendControlInterpolant(),this._timeScaleInterpolant=s);let l=s.parameterPositions,c=s.sampleValues;return l[0]=o,l[1]=o+n,c[0]=t/a,c[1]=r/a,this}stopWarping(){let t=this._timeScaleInterpolant;return t!==null&&(this._timeScaleInterpolant=null,this._mixer._takeBackControlInterpolant(t)),this}getMixer(){return this._mixer}getClip(){return this._clip}getRoot(){return this._localRoot||this._mixer._root}_update(t,r,n,i){if(!this.enabled){this._updateWeight(t);return}let o=this._startTime;if(o!==null){let l=(t-o)*n;if(l<0||n===0)return;this._startTime=null,r=n*l}r*=this._updateTimeScale(t);let a=this._updateTime(r),s=this._updateWeight(t);if(s>0){let l=this._interpolants,c=this._propertyBindings;switch(this.blendMode){case kht:for(let u=0,h=l.length;u!==h;++u)l[u].evaluate(a),c[u].accumulateAdditive(s);break;case $U:default:for(let u=0,h=l.length;u!==h;++u)l[u].evaluate(a),c[u].accumulate(i,s)}}}_updateWeight(t){let r=0;if(this.enabled){r=this.weight;let n=this._weightInterpolant;if(n!==null){let i=n.evaluate(t)[0];r*=i,t>n.parameterPositions[1]&&(this.stopFading(),i===0&&(this.enabled=!1))}}return this._effectiveWeight=r,r}_updateTimeScale(t){let r=0;if(!this.paused){r=this.timeScale;let n=this._timeScaleInterpolant;n!==null&&(r*=n.evaluate(t)[0],t>n.parameterPositions[1]&&(this.stopWarping(),r===0?this.paused=!0:this.timeScale=r))}return this._effectiveTimeScale=r,r}_updateTime(t){let r=this._clip.duration,n=this.loop,i=this.time+t,o=this._loopCount,a=n===Lfe;if(t===0)return o===-1?i:a&&(o&1)===1?r-i:i;if(n===Pfe){o===-1&&(this._loopCount=0,this._setEndings(!0,!0,!1));t:{if(i>=r)i=r;else if(i<0)i=0;else{this.time=i;break t}this.clampWhenFinished?this.paused=!0:this.enabled=!1,this.time=i,this._mixer.dispatchEvent({type:"finished",action:this,direction:t<0?-1:1})}}else{if(o===-1&&(t>=0?(o=0,this._setEndings(!0,this.repetitions===0,a)):this._setEndings(this.repetitions===0,!0,a)),i>=r||i<0){let s=Math.floor(i/r);i-=r*s,o+=Math.abs(s);let l=this.repetitions-o;if(l<=0)this.clampWhenFinished?this.paused=!0:this.enabled=!1,i=t>0?r:0,this.time=i,this._mixer.dispatchEvent({type:"finished",action:this,direction:t>0?1:-1});else{if(l===1){let c=t<0;this._setEndings(c,!c,a)}else this._setEndings(!1,!1,a);this._loopCount=o,this.time=i,this._mixer.dispatchEvent({type:"loop",action:this,loopDelta:s})}}else this.time=i;if(a&&(o&1)===1)return r-i}return i}_setEndings(t,r,n){let i=this._interpolantSettings;n?(i.endingStart=T1,i.endingEnd=T1):(t?i.endingStart=this.zeroSlopeAtStart?T1:E1:i.endingStart=JP,r?i.endingEnd=this.zeroSlopeAtEnd?T1:E1:i.endingEnd=JP)}_scheduleFading(t,r,n){let i=this._mixer,o=i.time,a=this._weightInterpolant;a===null&&(a=i._lendControlInterpolant(),this._weightInterpolant=a);let s=a.parameterPositions,l=a.sampleValues;return s[0]=o,l[0]=r,s[1]=o+t,l[1]=n,this}},VU=class extends Us{constructor(t){super(),this._root=t,this._initMemoryManager(),this._accuIndex=0,this.time=0,this.timeScale=1}_bindAction(t,r){let n=t._localRoot||this._root,i=t._clip.tracks,o=i.length,a=t._propertyBindings,s=t._interpolants,l=n.uuid,c=this._bindingsByRootAndName,u=c[l];u===void 0&&(u={},c[l]=u);for(let h=0;h!==o;++h){let f=i[h],p=f.name,d=u[p];if(d!==void 0)++d.referenceCount,a[h]=d;else{if(d=a[h],d!==void 0){d._cacheIndex===null&&(++d.referenceCount,this._addInactiveBinding(d,l,p));continue}let g=r&&r._propertyBindings[h].binding.parsedPath;d=new BU(Cr.create(n,p,g),f.ValueTypeName,f.getValueSize()),++d.referenceCount,this._addInactiveBinding(d,l,p),a[h]=d}s[h].resultBuffer=d.buffer}}_activateAction(t){if(!this._isActiveAction(t)){if(t._cacheIndex===null){let n=(t._localRoot||this._root).uuid,i=t._clip.uuid,o=this._actionsByClip[i];this._bindAction(t,o&&o.knownActions[0]),this._addInactiveAction(t,i,n)}let r=t._propertyBindings;for(let n=0,i=r.length;n!==i;++n){let o=r[n];o.useCount++===0&&(this._lendBinding(o),o.saveOriginalState())}this._lendAction(t)}}_deactivateAction(t){if(this._isActiveAction(t)){let r=t._propertyBindings;for(let n=0,i=r.length;n!==i;++n){let o=r[n];--o.useCount===0&&(o.restoreOriginalState(),this._takeBackBinding(o))}this._takeBackAction(t)}}_initMemoryManager(){this._actions=[],this._nActiveActions=0,this._actionsByClip={},this._bindings=[],this._nActiveBindings=0,this._bindingsByRootAndName={},this._controlInterpolants=[],this._nActiveControlInterpolants=0;let t=this;this.stats={actions:{get total(){return t._actions.length},get inUse(){return t._nActiveActions}},bindings:{get total(){return t._bindings.length},get inUse(){return t._nActiveBindings}},controlInterpolants:{get total(){return t._controlInterpolants.length},get inUse(){return t._nActiveControlInterpolants}}}}_isActiveAction(t){let r=t._cacheIndex;return r!==null&&r<this._nActiveActions}_addInactiveAction(t,r,n){let i=this._actions,o=this._actionsByClip,a=o[r];if(a===void 0)a={knownActions:[t],actionByRoot:{}},t._byClipCacheIndex=0,o[r]=a;else{let s=a.knownActions;t._byClipCacheIndex=s.length,s.push(t)}t._cacheIndex=i.length,i.push(t),a.actionByRoot[n]=t}_removeInactiveAction(t){let r=this._actions,n=r[r.length-1],i=t._cacheIndex;n._cacheIndex=i,r[i]=n,r.pop(),t._cacheIndex=null;let o=t._clip.uuid,a=this._actionsByClip,s=a[o],l=s.knownActions,c=l[l.length-1],u=t._byClipCacheIndex;c._byClipCacheIndex=u,l[u]=c,l.pop(),t._byClipCacheIndex=null;let h=s.actionByRoot,f=(t._localRoot||this._root).uuid;delete h[f],l.length===0&&delete a[o],this._removeInactiveBindingsForAction(t)}_removeInactiveBindingsForAction(t){let r=t._propertyBindings;for(let n=0,i=r.length;n!==i;++n){let o=r[n];--o.referenceCount===0&&this._removeInactiveBinding(o)}}_lendAction(t){let r=this._actions,n=t._cacheIndex,i=this._nActiveActions++,o=r[i];t._cacheIndex=i,r[i]=t,o._cacheIndex=n,r[n]=o}_takeBackAction(t){let r=this._actions,n=t._cacheIndex,i=--this._nActiveActions,o=r[i];t._cacheIndex=i,r[i]=t,o._cacheIndex=n,r[n]=o}_addInactiveBinding(t,r,n){let i=this._bindingsByRootAndName,o=this._bindings,a=i[r];a===void 0&&(a={},i[r]=a),a[n]=t,t._cacheIndex=o.length,o.push(t)}_removeInactiveBinding(t){let r=this._bindings,n=t.binding,i=n.rootNode.uuid,o=n.path,a=this._bindingsByRootAndName,s=a[i],l=r[r.length-1],c=t._cacheIndex;l._cacheIndex=c,r[c]=l,r.pop(),delete s[o],Object.keys(s).length===0&&delete a[i]}_lendBinding(t){let r=this._bindings,n=t._cacheIndex,i=this._nActiveBindings++,o=r[i];t._cacheIndex=i,r[i]=t,o._cacheIndex=n,r[n]=o}_takeBackBinding(t){let r=this._bindings,n=t._cacheIndex,i=--this._nActiveBindings,o=r[i];t._cacheIndex=i,r[i]=t,o._cacheIndex=n,r[n]=o}_lendControlInterpolant(){let t=this._controlInterpolants,r=this._nActiveControlInterpolants++,n=t[r];return n===void 0&&(n=new S6(new Float32Array(2),new Float32Array(2),1,this._controlInterpolantsResultBuffer),n.__cacheIndex=r,t[r]=n),n}_takeBackControlInterpolant(t){let r=this._controlInterpolants,n=t.__cacheIndex,i=--this._nActiveControlInterpolants,o=r[i];t.__cacheIndex=i,r[i]=t,o.__cacheIndex=n,r[n]=o}clipAction(t,r,n){let i=r||this._root,o=i.uuid,a=typeof t=="string"?Q1.findByName(i,t):t,s=a!==null?a.uuid:t,l=this._actionsByClip[s],c=null;if(n===void 0&&(a!==null?n=a.blendMode:n=$U),l!==void 0){let h=l.actionByRoot[o];if(h!==void 0&&h.blendMode===n)return h;c=l.knownActions[0],a===null&&(a=c._clip)}if(a===null)return null;let u=new fht(this,a,r,n);return this._bindAction(u,c),this._addInactiveAction(u,s,o),u}existingAction(t,r){let n=r||this._root,i=n.uuid,o=typeof t=="string"?Q1.findByName(n,t):t,a=o?o.uuid:t,s=this._actionsByClip[a];return s!==void 0&&s.actionByRoot[i]||null}stopAllAction(){let t=this._actions,r=this._nActiveActions;for(let n=r-1;n>=0;--n)t[n].stop();return this}update(t){t*=this.timeScale;let r=this._actions,n=this._nActiveActions,i=this.time+=t,o=Math.sign(t),a=this._accuIndex^=1;for(let c=0;c!==n;++c)r[c]._update(i,t,o,a);let s=this._bindings,l=this._nActiveBindings;for(let c=0;c!==l;++c)s[c].apply(a);return this}setTime(t){this.time=0;for(let r=0;r<this._actions.length;r++)this._actions[r].time=0;return this.update(t)}getRoot(){return this._root}uncacheClip(t){let r=this._actions,n=t.uuid,i=this._actionsByClip,o=i[n];if(o!==void 0){let a=o.knownActions;for(let s=0,l=a.length;s!==l;++s){let c=a[s];this._deactivateAction(c);let u=c._cacheIndex,h=r[r.length-1];c._cacheIndex=null,c._byClipCacheIndex=null,h._cacheIndex=u,r[u]=h,r.pop(),this._removeInactiveBindingsForAction(c)}delete i[n]}}uncacheRoot(t){let r=t.uuid,n=this._actionsByClip;for(let a in n){let s=n[a].actionByRoot,l=s[r];l!==void 0&&(this._deactivateAction(l),this._removeInactiveAction(l))}let i=this._bindingsByRootAndName,o=i[r];if(o!==void 0)for(let a in o){let s=o[a];s.restoreOriginalState(),this._removeInactiveBinding(s)}}uncacheAction(t,r){let n=this.existingAction(t,r);n!==null&&(this._deactivateAction(n),this._removeInactiveAction(n))}};VU.prototype._controlInterpolantsResultBuffer=new Float32Array(1);var gM=class{constructor(t){typeof t=="string"&&(console.warn("THREE.Uniform: Type parameter is no longer needed."),t=arguments[1]),this.value=t}clone(){return new gM(this.value.clone===void 0?this.value:this.value.clone())}},UU=class extends em{constructor(t,r,n=1){super(t,r),this.meshPerAttribute=n}copy(t){return super.copy(t),this.meshPerAttribute=t.meshPerAttribute,this}clone(t){let r=super.clone(t);return r.meshPerAttribute=this.meshPerAttribute,r}toJSON(t){let r=super.toJSON(t);return r.isInstancedInterleavedBuffer=!0,r.meshPerAttribute=this.meshPerAttribute,r}};UU.prototype.isInstancedInterleavedBuffer=!0;var qU=class{constructor(t,r,n,i,o){this.buffer=t,this.type=r,this.itemSize=n,this.elementSize=i,this.count=o,this.version=0}set needsUpdate(t){t===!0&&this.version++}setBuffer(t){return this.buffer=t,this}setType(t,r){return this.type=t,this.elementSize=r,this}setItemSize(t){return this.itemSize=t,this}setCount(t){return this.count=t,this}};qU.prototype.isGLBufferAttribute=!0;var pht=class{constructor(t,r,n=0,i=1/0){this.ray=new Jf(t,r),this.near=n,this.far=i,this.camera=null,this.layers=new X3,this.params={Mesh:{},Line:{threshold:1},LOD:{},Points:{threshold:1},Sprite:{}}}set(t,r){this.ray.set(t,r)}setFromCamera(t,r){r&&r.isPerspectiveCamera?(this.ray.origin.setFromMatrixPosition(r.matrixWorld),this.ray.direction.set(t.x,t.y,.5).unproject(r).sub(this.ray.origin).normalize(),this.camera=r):r&&r.isOrthographicCamera?(this.ray.origin.set(t.x,t.y,(r.near+r.far)/(r.near-r.far)).unproject(r),this.ray.direction.set(0,0,-1).transformDirection(r.matrixWorld),this.camera=r):console.error("THREE.Raycaster: Unsupported camera type: "+r.type)}intersectObject(t,r=!0,n=[]){return dht(t,this,n,r),n.sort(Lhe),n}intersectObjects(t,r=!0,n=[]){for(let i=0,o=t.length;i<o;i++)dht(t[i],this,n,r);return n.sort(Lhe),n}};function Lhe(e,t){return e.distance-t.distance}function dht(e,t,r,n){if(e.layers.test(t.layers)&&e.raycast(t,r),n===!0){let i=e.children;for(let o=0,a=i.length;o<a;o++)dht(i[o],t,r,!0)}}var _M=class{constructor(t=1,r=0,n=0){return this.radius=t,this.phi=r,this.theta=n,this}set(t,r,n){return this.radius=t,this.phi=r,this.theta=n,this}copy(t){return this.radius=t.radius,this.phi=t.phi,this.theta=t.theta,this}makeSafe(){return this.phi=Math.max(1e-6,Math.min(Math.PI-1e-6,this.phi)),this}setFromVector3(t){return this.setFromCartesianCoords(t.x,t.y,t.z)}setFromCartesianCoords(t,r,n){return this.radius=Math.sqrt(t*t+r*r+n*n),this.radius===0?(this.theta=0,this.phi=0):(this.theta=Math.atan2(t,n),this.phi=Math.acos(Zo(r/this.radius,-1,1))),this}clone(){return new this.constructor().copy(this)}},mht=class{constructor(t=1,r=0,n=0){return this.radius=t,this.theta=r,this.y=n,this}set(t,r,n){return this.radius=t,this.theta=r,this.y=n,this}copy(t){return this.radius=t.radius,this.theta=t.theta,this.y=t.y,this}setFromVector3(t){return this.setFromCartesianCoords(t.x,t.y,t.z)}setFromCartesianCoords(t,r,n){return this.radius=Math.sqrt(t*t+n*n),this.theta=Math.atan2(t,n),this.y=r,this}clone(){return new this.constructor().copy(this)}},khe=new Lt,$0=class{constructor(t=new Lt(1/0,1/0),r=new Lt(-1/0,-1/0)){this.min=t,this.max=r}set(t,r){return this.min.copy(t),this.max.copy(r),this}setFromPoints(t){this.makeEmpty();for(let r=0,n=t.length;r<n;r++)this.expandByPoint(t[r]);return this}setFromCenterAndSize(t,r){let n=khe.copy(r).multiplyScalar(.5);return this.min.copy(t).sub(n),this.max.copy(t).add(n),this}clone(){return new this.constructor().copy(this)}copy(t){return this.min.copy(t.min),this.max.copy(t.max),this}makeEmpty(){return this.min.x=this.min.y=1/0,this.max.x=this.max.y=-1/0,this}isEmpty(){return this.max.x<this.min.x||this.max.y<this.min.y}getCenter(t){return this.isEmpty()?t.set(0,0):t.addVectors(this.min,this.max).multiplyScalar(.5)}getSize(t){return this.isEmpty()?t.set(0,0):t.subVectors(this.max,this.min)}expandByPoint(t){return this.min.min(t),this.max.max(t),this}expandByVector(t){return this.min.sub(t),this.max.add(t),this}expandByScalar(t){return this.min.addScalar(-t),this.max.addScalar(t),this}containsPoint(t){return!(t.x<this.min.x||t.x>this.max.x||t.y<this.min.y||t.y>this.max.y)}containsBox(t){return this.min.x<=t.min.x&&t.max.x<=this.max.x&&this.min.y<=t.min.y&&t.max.y<=this.max.y}getParameter(t,r){return r.set((t.x-this.min.x)/(this.max.x-this.min.x),(t.y-this.min.y)/(this.max.y-this.min.y))}intersectsBox(t){return!(t.max.x<this.min.x||t.min.x>this.max.x||t.max.y<this.min.y||t.min.y>this.max.y)}clampPoint(t,r){return r.copy(t).clamp(this.min,this.max)}distanceToPoint(t){return khe.copy(t).clamp(this.min,this.max).sub(t).length()}intersect(t){return this.min.max(t.min),this.max.min(t.max),this}union(t){return this.min.min(t.min),this.max.max(t.max),this}translate(t){return this.min.add(t),this.max.add(t),this}equals(t){return t.min.equals(this.min)&&t.max.equals(this.max)}};$0.prototype.isBox2=!0;var Rhe=new j,YV=new j,GU=class{constructor(t=new j,r=new j){this.start=t,this.end=r}set(t,r){return this.start.copy(t),this.end.copy(r),this}copy(t){return this.start.copy(t.start),this.end.copy(t.end),this}getCenter(t){return t.addVectors(this.start,this.end).multiplyScalar(.5)}delta(t){return t.subVectors(this.end,this.start)}distanceSq(){return this.start.distanceToSquared(this.end)}distance(){return this.start.distanceTo(this.end)}at(t,r){return this.delta(r).multiplyScalar(t).add(this.start)}closestPointToPointParameter(t,r){Rhe.subVectors(t,this.start),YV.subVectors(this.end,this.start);let n=YV.dot(YV),o=YV.dot(Rhe)/n;return r&&(o=Zo(o,0,1)),o}closestPointToPoint(t,r,n){let i=this.closestPointToPointParameter(t,r);return this.delta(n).multiplyScalar(i).add(this.start)}applyMatrix4(t){return this.start.applyMatrix4(t),this.end.applyMatrix4(t),this}equals(t){return t.start.equals(this.start)&&t.end.equals(this.end)}clone(){return new this.constructor().copy(this)}},Nhe=new j,ght=class extends or{constructor(t,r){super(),this.light=t,this.light.updateMatrixWorld(),this.matrix=t.matrixWorld,this.matrixAutoUpdate=!1,this.color=r;let n=new Pe,i=[0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,-1,0,1,0,0,0,0,1,1,0,0,0,0,-1,1];for(let a=0,s=1,l=32;a<l;a++,s++){let c=a/l*Math.PI*2,u=s/l*Math.PI*2;i.push(Math.cos(c),Math.sin(c),1,Math.cos(u),Math.sin(u),1)}n.setAttribute("position",new xe(i,3));let o=new Gi({fog:!1,toneMapped:!1});this.cone=new Aa(n,o),this.add(this.cone),this.update()}dispose(){this.cone.geometry.dispose(),this.cone.material.dispose()}update(){this.light.updateMatrixWorld();let t=this.light.distance?this.light.distance:1e3,r=t*Math.tan(this.light.angle);this.cone.scale.set(r,r,t),Nhe.setFromMatrixPosition(this.light.target.matrixWorld),this.cone.lookAt(Nhe),this.color!==void 0?this.cone.material.color.set(this.color):this.cone.material.color.copy(this.light.color)}},O0=new j,jV=new Me,but=new Me,WU=class extends Aa{constructor(t){let r=ope(t),n=new Pe,i=[],o=[],a=new ne(0,0,1),s=new ne(0,1,0);for(let c=0;c<r.length;c++){let u=r[c];u.parent&&u.parent.isBone&&(i.push(0,0,0),i.push(0,0,0),o.push(a.r,a.g,a.b),o.push(s.r,s.g,s.b))}n.setAttribute("position",new xe(i,3)),n.setAttribute("color",new xe(o,3));let l=new Gi({vertexColors:!0,depthTest:!1,depthWrite:!1,toneMapped:!1,transparent:!0});super(n,l),this.type="SkeletonHelper",this.isSkeletonHelper=!0,this.root=t,this.bones=r,this.matrix=t.matrixWorld,this.matrixAutoUpdate=!1}updateMatrixWorld(t){let r=this.bones,n=this.geometry,i=n.getAttribute("position");but.copy(this.root.matrixWorld).invert();for(let o=0,a=0;o<r.length;o++){let s=r[o];s.parent&&s.parent.isBone&&(jV.multiplyMatrices(but,s.matrixWorld),O0.setFromMatrixPosition(jV),i.setXYZ(a,O0.x,O0.y,O0.z),jV.multiplyMatrices(but,s.parent.matrixWorld),O0.setFromMatrixPosition(jV),i.setXYZ(a+1,O0.x,O0.y,O0.z),a+=2)}n.getAttribute("position").needsUpdate=!0,super.updateMatrixWorld(t)}};function ope(e){let t=[];e&&e.isBone&&t.push(e);for(let r=0;r<e.children.length;r++)t.push.apply(t,ope(e.children[r]));return t}var _ht=class extends ti{constructor(t,r,n){let i=new j0(r,4,2),o=new sh({wireframe:!0,fog:!1,toneMapped:!1});super(i,o),this.light=t,this.light.updateMatrixWorld(),this.color=n,this.type="PointLightHelper",this.matrix=this.light.matrixWorld,this.matrixAutoUpdate=!1,this.update()}dispose(){this.geometry.dispose(),this.material.dispose()}update(){this.color!==void 0?this.material.color.set(this.color):this.material.color.copy(this.light.color)}},M0r=new j,Dhe=new ne,Ohe=new ne,yht=class extends or{constructor(t,r,n){super(),this.light=t,this.light.updateMatrixWorld(),this.matrix=t.matrixWorld,this.matrixAutoUpdate=!1,this.color=n;let i=new W0(r);i.rotateY(Math.PI*.5),this.material=new sh({wireframe:!0,fog:!1,toneMapped:!1}),this.color===void 0&&(this.material.vertexColors=!0);let o=i.getAttribute("position"),a=new Float32Array(o.count*3);i.setAttribute("color",new Je(a,3)),this.add(new ti(i,this.material)),this.update()}dispose(){this.children[0].geometry.dispose(),this.children[0].material.dispose()}update(){let t=this.children[0];if(this.color!==void 0)this.material.color.set(this.color);else{let r=t.geometry.getAttribute("color");Dhe.copy(this.light.color),Ohe.copy(this.light.groundColor);for(let n=0,i=r.count;n<i;n++){let o=n<i/2?Dhe:Ohe;r.setXYZ(n,o.r,o.g,o.b)}r.needsUpdate=!0}t.lookAt(M0r.setFromMatrixPosition(this.light.matrixWorld).negate())}},YU=class extends Aa{constructor(t=10,r=10,n=4473924,i=8947848){n=new ne(n),i=new ne(i);let o=r/2,a=t/r,s=t/2,l=[],c=[];for(let f=0,p=0,d=-s;f<=r;f++,d+=a){l.push(-s,0,d,s,0,d),l.push(d,0,-s,d,0,s);let g=f===o?n:i;g.toArray(c,p),p+=3,g.toArray(c,p),p+=3,g.toArray(c,p),p+=3,g.toArray(c,p),p+=3}let u=new Pe;u.setAttribute("position",new xe(l,3)),u.setAttribute("color",new xe(c,3));let h=new Gi({vertexColors:!0,toneMapped:!1});super(u,h),this.type="GridHelper"}},vht=class extends Aa{constructor(t=10,r=16,n=8,i=64,o=4473924,a=8947848){o=new ne(o),a=new ne(a);let s=[],l=[];for(let h=0;h<=r;h++){let f=h/r*(Math.PI*2),p=Math.sin(f)*t,d=Math.cos(f)*t;s.push(0,0,0),s.push(p,0,d);let g=h&1?o:a;l.push(g.r,g.g,g.b),l.push(g.r,g.g,g.b)}for(let h=0;h<=n;h++){let f=h&1?o:a,p=t-t/n*h;for(let d=0;d<i;d++){let g=d/i*(Math.PI*2),_=Math.sin(g)*p,y=Math.cos(g)*p;s.push(_,0,y),l.push(f.r,f.g,f.b),g=(d+1)/i*(Math.PI*2),_=Math.sin(g)*p,y=Math.cos(g)*p,s.push(_,0,y),l.push(f.r,f.g,f.b)}}let c=new Pe;c.setAttribute("position",new xe(s,3)),c.setAttribute("color",new xe(l,3));let u=new Gi({vertexColors:!0,toneMapped:!1});super(c,u),this.type="PolarGridHelper"}},zhe=new j,XV=new j,Fhe=new j,xht=class extends or{constructor(t,r,n){super(),this.light=t,this.light.updateMatrixWorld(),this.matrix=t.matrixWorld,this.matrixAutoUpdate=!1,this.color=n,r===void 0&&(r=1);let i=new Pe;i.setAttribute("position",new xe([-r,r,0,r,r,0,r,-r,0,-r,-r,0,-r,r,0],3));let o=new Gi({fog:!1,toneMapped:!1});this.lightPlane=new ch(i,o),this.add(this.lightPlane),i=new Pe,i.setAttribute("position",new xe([0,0,0,0,0,1],3)),this.targetLine=new ch(i,o),this.add(this.targetLine),this.update()}dispose(){this.lightPlane.geometry.dispose(),this.lightPlane.material.dispose(),this.targetLine.geometry.dispose(),this.targetLine.material.dispose()}update(){zhe.setFromMatrixPosition(this.light.matrixWorld),XV.setFromMatrixPosition(this.light.target.matrixWorld),Fhe.subVectors(XV,zhe),this.lightPlane.lookAt(XV),this.color!==void 0?(this.lightPlane.material.color.set(this.color),this.targetLine.material.color.set(this.color)):(this.lightPlane.material.color.copy(this.light.color),this.targetLine.material.color.copy(this.light.color)),this.targetLine.lookAt(XV),this.targetLine.scale.z=Fhe.length()}},$V=new j,_i=new R1,bht=class extends Aa{constructor(t){let r=new Pe,n=new Gi({color:16777215,vertexColors:!0,toneMapped:!1}),i=[],o=[],a={},s=new ne(16755200),l=new ne(16711680),c=new ne(43775),u=new ne(16777215),h=new ne(3355443);f("n1","n2",s),f("n2","n4",s),f("n4","n3",s),f("n3","n1",s),f("f1","f2",s),f("f2","f4",s),f("f4","f3",s),f("f3","f1",s),f("n1","f1",s),f("n2","f2",s),f("n3","f3",s),f("n4","f4",s),f("p","n1",l),f("p","n2",l),f("p","n3",l),f("p","n4",l),f("u1","u2",c),f("u2","u3",c),f("u3","u1",c),f("c","t",u),f("p","c",h),f("cn1","cn2",h),f("cn3","cn4",h),f("cf1","cf2",h),f("cf3","cf4",h);function f(d,g,_){p(d,_),p(g,_)}function p(d,g){i.push(0,0,0),o.push(g.r,g.g,g.b),a[d]===void 0&&(a[d]=[]),a[d].push(i.length/3-1)}r.setAttribute("position",new xe(i,3)),r.setAttribute("color",new xe(o,3)),super(r,n),this.type="CameraHelper",this.camera=t,this.camera.updateProjectionMatrix&&this.camera.updateProjectionMatrix(),this.matrix=t.matrixWorld,this.matrixAutoUpdate=!1,this.pointMap=a,this.update()}update(){let t=this.geometry,r=this.pointMap,n=1,i=1;_i.projectionMatrixInverse.copy(this.camera.projectionMatrixInverse),Pi("c",r,t,_i,0,0,-1),Pi("t",r,t,_i,0,0,1),Pi("n1",r,t,_i,-n,-i,-1),Pi("n2",r,t,_i,n,-i,-1),Pi("n3",r,t,_i,-n,i,-1),Pi("n4",r,t,_i,n,i,-1),Pi("f1",r,t,_i,-n,-i,1),Pi("f2",r,t,_i,n,-i,1),Pi("f3",r,t,_i,-n,i,1),Pi("f4",r,t,_i,n,i,1),Pi("u1",r,t,_i,n*.7,i*1.1,-1),Pi("u2",r,t,_i,-n*.7,i*1.1,-1),Pi("u3",r,t,_i,0,i*2,-1),Pi("cf1",r,t,_i,-n,0,1),Pi("cf2",r,t,_i,n,0,1),Pi("cf3",r,t,_i,0,-i,1),Pi("cf4",r,t,_i,0,i,1),Pi("cn1",r,t,_i,-n,0,-1),Pi("cn2",r,t,_i,n,0,-1),Pi("cn3",r,t,_i,0,-i,-1),Pi("cn4",r,t,_i,0,i,-1),t.getAttribute("position").needsUpdate=!0}dispose(){this.geometry.dispose(),this.material.dispose()}};function Pi(e,t,r,n,i,o,a){$V.set(i,o,a).unproject(n);let s=t[e];if(s!==void 0){let l=r.getAttribute("position");for(let c=0,u=s.length;c<u;c++)l.setXYZ(s[c],$V.x,$V.y,$V.z)}}var KV=new ta,yM=class extends Aa{constructor(t,r=16776960){let n=new Uint16Array([0,1,1,2,2,3,3,0,4,5,5,6,6,7,7,4,0,4,1,5,2,6,3,7]),i=new Float32Array(8*3),o=new Pe;o.setIndex(new Je(n,1)),o.setAttribute("position",new Je(i,3)),super(o,new Gi({color:r,toneMapped:!1})),this.object=t,this.type="BoxHelper",this.matrixAutoUpdate=!1,this.update()}update(t){if(t!==void 0&&console.warn("THREE.BoxHelper: .update() has no longer arguments."),this.object!==void 0&&KV.setFromObject(this.object),KV.isEmpty())return;let r=KV.min,n=KV.max,i=this.geometry.attributes.position,o=i.array;o[0]=n.x,o[1]=n.y,o[2]=n.z,o[3]=r.x,o[4]=n.y,o[5]=n.z,o[6]=r.x,o[7]=r.y,o[8]=n.z,o[9]=n.x,o[10]=r.y,o[11]=n.z,o[12]=n.x,o[13]=n.y,o[14]=r.z,o[15]=r.x,o[16]=n.y,o[17]=r.z,o[18]=r.x,o[19]=r.y,o[20]=r.z,o[21]=n.x,o[22]=r.y,o[23]=r.z,i.needsUpdate=!0,this.geometry.computeBoundingSphere()}setFromObject(t){return this.object=t,this.update(),this}copy(t){return Aa.prototype.copy.call(this,t),this.object=t.object,this}},wht=class extends Aa{constructor(t,r=16776960){let n=new Uint16Array([0,1,1,2,2,3,3,0,4,5,5,6,6,7,7,4,0,4,1,5,2,6,3,7]),i=[1,1,1,-1,1,1,-1,-1,1,1,-1,1,1,1,-1,-1,1,-1,-1,-1,-1,1,-1,-1],o=new Pe;o.setIndex(new Je(n,1)),o.setAttribute("position",new xe(i,3)),super(o,new Gi({color:r,toneMapped:!1})),this.box=t,this.type="Box3Helper",this.geometry.computeBoundingSphere()}updateMatrixWorld(t){let r=this.box;r.isEmpty()||(r.getCenter(this.position),r.getSize(this.scale),this.scale.multiplyScalar(.5),super.updateMatrixWorld(t))}},Sht=class extends ch{constructor(t,r=1,n=16776960){let i=n,o=[1,-1,1,-1,1,1,-1,-1,1,1,1,1,-1,1,1,-1,-1,1,1,-1,1,1,1,1,0,0,1,0,0,0],a=new Pe;a.setAttribute("position",new xe(o,3)),a.computeBoundingSphere(),super(a,new Gi({color:i,toneMapped:!1})),this.type="PlaneHelper",this.plane=t,this.size=r;let s=[1,1,1,-1,1,1,-1,-1,1,1,1,1,-1,-1,1,1,-1,1],l=new Pe;l.setAttribute("position",new xe(s,3)),l.computeBoundingSphere(),this.add(new ti(l,new sh({color:i,opacity:.2,transparent:!0,depthWrite:!1,toneMapped:!1})))}updateMatrixWorld(t){let r=-this.plane.constant;Math.abs(r)<1e-8&&(r=1e-8),this.scale.set(.5*this.size,.5*this.size,r),this.children[0].material.side=r<0?Ii:I1,this.lookAt(this.plane.normal),super.updateMatrixWorld(t)}},Bhe=new j,ZV,wut,Mht=class extends or{constructor(t=new j(0,0,1),r=new j(0,0,0),n=1,i=16776960,o=n*.2,a=o*.2){super(),this.type="ArrowHelper",ZV===void 0&&(ZV=new Pe,ZV.setAttribute("position",new xe([0,0,0,0,1,0],3)),wut=new om(0,.5,1,5,1),wut.translate(0,-.5,0)),this.position.copy(r),this.line=new ch(ZV,new Gi({color:i,toneMapped:!1})),this.line.matrixAutoUpdate=!1,this.add(this.line),this.cone=new ti(wut,new sh({color:i,toneMapped:!1})),this.cone.matrixAutoUpdate=!1,this.add(this.cone),this.setDirection(t),this.setLength(n,o,a)}setDirection(t){if(t.y>.99999)this.quaternion.set(0,0,0,1);else if(t.y<-.99999)this.quaternion.set(1,0,0,0);else{Bhe.set(t.z,0,-t.x).normalize();let r=Math.acos(t.y);this.quaternion.setFromAxisAngle(Bhe,r)}}setLength(t,r=t*.2,n=r*.2){this.line.scale.set(1,Math.max(1e-4,t-r),1),this.line.updateMatrix(),this.cone.scale.set(n,r,n),this.cone.position.y=t,this.cone.updateMatrix()}setColor(t){this.line.material.color.set(t),this.cone.material.color.set(t)}copy(t){return super.copy(t,!1),this.line.copy(t.line),this.cone.copy(t.cone),this}},vM=class extends Aa{constructor(t=1){let r=[0,0,0,t,0,0,0,0,0,0,t,0,0,0,0,0,0,t],n=[1,0,0,1,.6,0,0,1,0,.6,1,0,0,0,1,0,.6,1],i=new Pe;i.setAttribute("position",new xe(r,3)),i.setAttribute("color",new xe(n,3));let o=new Gi({vertexColors:!0,toneMapped:!1});super(i,o),this.type="AxesHelper"}setColors(t,r,n){let i=new ne,o=this.geometry.attributes.color.array;return i.set(t),i.toArray(o,0),i.toArray(o,3),i.set(r),i.toArray(o,6),i.toArray(o,9),i.set(n),i.toArray(o,12),i.toArray(o,15),this.geometry.attributes.color.needsUpdate=!0,this}dispose(){this.geometry.dispose(),this.material.dispose()}},Eht=class{constructor(){this.type="ShapePath",this.color=new ne,this.subPaths=[],this.currentPath=null}moveTo(t,r){return this.currentPath=new q1,this.subPaths.push(this.currentPath),this.currentPath.moveTo(t,r),this}lineTo(t,r){return this.currentPath.lineTo(t,r),this}quadraticCurveTo(t,r,n,i){return this.currentPath.quadraticCurveTo(t,r,n,i),this}bezierCurveTo(t,r,n,i,o,a){return this.currentPath.bezierCurveTo(t,r,n,i,o,a),this}splineThru(t){return this.currentPath.splineThru(t),this}toShapes(t,r){function n(x){let b=[];for(let S=0,C=x.length;S<C;S++){let P=x[S],k=new Kc;k.curves=P.curves,b.push(k)}return b}function i(x,b){let S=b.length,C=!1;for(let P=S-1,k=0;k<S;P=k++){let O=b[P],D=b[k],B=D.x-O.x,I=D.y-O.y;if(Math.abs(I)>Number.EPSILON){if(I<0&&(O=b[k],B=-B,D=b[P],I=-I),x.y<O.y||x.y>D.y)continue;if(x.y===O.y){if(x.x===O.x)return!0}else{let L=I*(x.x-O.x)-B*(x.y-O.y);if(L===0)return!0;if(L<0)continue;C=!C}}else{if(x.y!==O.y)continue;if(D.x<=x.x&&x.x<=O.x||O.x<=x.x&&x.x<=D.x)return!0}}return C}let o=Zc.isClockWise,a=this.subPaths;if(a.length===0)return[];if(r===!0)return n(a);let s,l,c,u=[];if(a.length===1)return l=a[0],c=new Kc,c.curves=l.curves,u.push(c),u;let h=!o(a[0].getPoints());h=t?!h:h;let f=[],p=[],d=[],g=0,_;p[g]=void 0,d[g]=[];for(let x=0,b=a.length;x<b;x++)l=a[x],_=l.getPoints(),s=o(_),s=t?!s:s,s?(!h&&p[g]&&g++,p[g]={s:new Kc,p:_},p[g].s.curves=l.curves,h&&g++,d[g]=[]):d[g].push({h:l,p:_[0]});if(!p[0])return n(a);if(p.length>1){let x=!1,b=[];for(let S=0,C=p.length;S<C;S++)f[S]=[];for(let S=0,C=p.length;S<C;S++){let P=d[S];for(let k=0;k<P.length;k++){let O=P[k],D=!0;for(let B=0;B<p.length;B++)i(O.p,p[B].p)&&(S!==B&&b.push({froms:S,tos:B,hole:k}),D?(D=!1,f[B].push(O)):x=!0);D&&f[S].push(O)}}b.length>0&&(x||(d=f))}let y;for(let x=0,b=p.length;x<b;x++){c=p[x].s,u.push(c),y=d[x];for(let S=0,C=y.length;S<C;S++)c.holes.push(y[S].h)}return u}},ape=new Float32Array(1),E0r=new Int32Array(ape.buffer),Tht=class{static toHalfFloat(t){t>65504&&(console.warn("THREE.DataUtils.toHalfFloat(): value exceeds 65504."),t=65504),ape[0]=t;let r=E0r[0],n=r>>16&32768,i=r>>12&2047,o=r>>23&255;return o<103?n:o>142?(n|=31744,n|=(o==255?0:1)&&r&8388607,n):o<113?(i|=2048,n|=(i>>114-o)+(i>>113-o&1),n):(n|=o-112<<10|i>>1,n+=i&1,n)}},T0r=0,C0r=1,A0r=0,P0r=1,I0r=2;function L0r(e){return console.warn("THREE.MeshFaceMaterial has been removed. Use an Array instead."),e}function k0r(e=[]){return console.warn("THREE.MultiMaterial has been removed. Use an Array instead."),e.isMultiMaterial=!0,e.materials=e,e.clone=function(){return e.slice()},e}function R0r(e,t){return console.warn("THREE.PointCloud has been renamed to THREE.Points."),new im(e,t)}function N0r(e){return console.warn("THREE.Particle has been renamed to THREE.Sprite."),new oM(e)}function D0r(e,t){return console.warn("THREE.ParticleSystem has been renamed to THREE.Points."),new im(e,t)}function O0r(e){return console.warn("THREE.PointCloudMaterial has been renamed to THREE.PointsMaterial."),new nm(e)}function z0r(e){return console.warn("THREE.ParticleBasicMaterial has been renamed to THREE.PointsMaterial."),new nm(e)}function F0r(e){return console.warn("THREE.ParticleSystemMaterial has been renamed to THREE.PointsMaterial."),new nm(e)}function B0r(e,t,r){return console.warn("THREE.Vertex has been removed. Use THREE.Vector3 instead."),new j(e,t,r)}function H0r(e,t){return console.warn("THREE.DynamicBufferAttribute has been removed. Use new THREE.BufferAttribute().setUsage( THREE.DynamicDrawUsage ) instead."),new Je(e,t).setUsage(Y3)}function V0r(e,t){return console.warn("THREE.Int8Attribute has been removed. Use new THREE.Int8BufferAttribute() instead."),new cU(e,t)}function U0r(e,t){return console.warn("THREE.Uint8Attribute has been removed. Use new THREE.Uint8BufferAttribute() instead."),new uU(e,t)}function q0r(e,t){return console.warn("THREE.Uint8ClampedAttribute has been removed. Use new THREE.Uint8ClampedBufferAttribute() instead."),new hU(e,t)}function G0r(e,t){return console.warn("THREE.Int16Attribute has been removed. Use new THREE.Int16BufferAttribute() instead."),new fU(e,t)}function W0r(e,t){return console.warn("THREE.Uint16Attribute has been removed. Use new THREE.Uint16BufferAttribute() instead."),new $3(e,t)}function Y0r(e,t){return console.warn("THREE.Int32Attribute has been removed. Use new THREE.Int32BufferAttribute() instead."),new pU(e,t)}function j0r(e,t){return console.warn("THREE.Uint32Attribute has been removed. Use new THREE.Uint32BufferAttribute() instead."),new K3(e,t)}function X0r(e,t){return console.warn("THREE.Float32Attribute has been removed. Use new THREE.Float32BufferAttribute() instead."),new xe(e,t)}function $0r(e,t){return console.warn("THREE.Float64Attribute has been removed. Use new THREE.Float64BufferAttribute() instead."),new mU(e,t)}fs.create=function(e,t){return console.log("THREE.Curve.create() has been deprecated"),e.prototype=Object.create(fs.prototype),e.prototype.constructor=e,e.prototype.getPoint=t,e};q1.prototype.fromPoints=function(e){return console.warn("THREE.Path: .fromPoints() has been renamed to .setFromPoints()."),this.setFromPoints(e)};function K0r(e){return console.warn("THREE.AxisHelper has been renamed to THREE.AxesHelper."),new vM(e)}function Z0r(e,t){return console.warn("THREE.BoundingBoxHelper has been deprecated. Creating a THREE.BoxHelper instead."),new yM(e,t)}function J0r(e,t){return console.warn("THREE.EdgesHelper has been removed. Use THREE.EdgesGeometry instead."),new Aa(new s6(e.geometry),new Gi({color:t!==void 0?t:16777215}))}YU.prototype.setColors=function(){console.error("THREE.GridHelper: setColors() has been deprecated, pass them in the constructor instead.")};WU.prototype.update=function(){console.error("THREE.SkeletonHelper: update() no longer needs to be called.")};function Q0r(e,t){return console.warn("THREE.WireframeHelper has been removed. Use THREE.WireframeGeometry instead."),new Aa(new d6(e.geometry),new Gi({color:t!==void 0?t:16777215}))}ea.prototype.extractUrlBase=function(e){return console.warn("THREE.Loader: .extractUrlBase() has been deprecated. Use THREE.LoaderUtils.extractUrlBase() instead."),dM.extractUrlBase(e)};ea.Handlers={add:function(){console.error("THREE.Loader: Handlers.add() has been removed. Use LoadingManager.addHandler() instead.")},get:function(){console.error("THREE.Loader: Handlers.get() has been removed. Use LoadingManager.getHandler() instead.")}};function t_r(e){return console.warn("THREE.XHRLoader has been renamed to THREE.FileLoader."),new Jc(e)}function e_r(e){return console.warn("THREE.BinaryTextureLoader has been renamed to THREE.DataTextureLoader."),new CU(e)}$0.prototype.center=function(e){return console.warn("THREE.Box2: .center() has been renamed to .getCenter()."),this.getCenter(e)};$0.prototype.empty=function(){return console.warn("THREE.Box2: .empty() has been renamed to .isEmpty()."),this.isEmpty()};$0.prototype.isIntersectionBox=function(e){return console.warn("THREE.Box2: .isIntersectionBox() has been renamed to .intersectsBox()."),this.intersectsBox(e)};$0.prototype.size=function(e){return console.warn("THREE.Box2: .size() has been renamed to .getSize()."),this.getSize(e)};ta.prototype.center=function(e){return console.warn("THREE.Box3: .center() has been renamed to .getCenter()."),this.getCenter(e)};ta.prototype.empty=function(){return console.warn("THREE.Box3: .empty() has been renamed to .isEmpty()."),this.isEmpty()};ta.prototype.isIntersectionBox=function(e){return console.warn("THREE.Box3: .isIntersectionBox() has been renamed to .intersectsBox()."),this.intersectsBox(e)};ta.prototype.isIntersectionSphere=function(e){return console.warn("THREE.Box3: .isIntersectionSphere() has been renamed to .intersectsSphere()."),this.intersectsSphere(e)};ta.prototype.size=function(e){return console.warn("THREE.Box3: .size() has been renamed to .getSize()."),this.getSize(e)};Zf.prototype.empty=function(){return console.warn("THREE.Sphere: .empty() has been renamed to .isEmpty()."),this.isEmpty()};N1.prototype.setFromMatrix=function(e){return console.warn("THREE.Frustum: .setFromMatrix() has been renamed to .setFromProjectionMatrix()."),this.setFromProjectionMatrix(e)};GU.prototype.center=function(e){return console.warn("THREE.Line3: .center() has been renamed to .getCenter()."),this.getCenter(e)};ki.prototype.flattenToArrayOffset=function(e,t){return console.warn("THREE.Matrix3: .flattenToArrayOffset() has been deprecated. Use .toArray() instead."),this.toArray(e,t)};ki.prototype.multiplyVector3=function(e){return console.warn("THREE.Matrix3: .multiplyVector3() has been removed. Use vector.applyMatrix3( matrix ) instead."),e.applyMatrix3(this)};ki.prototype.multiplyVector3Array=function(){console.error("THREE.Matrix3: .multiplyVector3Array() has been removed.")};ki.prototype.applyToBufferAttribute=function(e){return console.warn("THREE.Matrix3: .applyToBufferAttribute() has been removed. Use attribute.applyMatrix3( matrix ) instead."),e.applyMatrix3(this)};ki.prototype.applyToVector3Array=function(){console.error("THREE.Matrix3: .applyToVector3Array() has been removed.")};ki.prototype.getInverse=function(e){return console.warn("THREE.Matrix3: .getInverse() has been removed. Use matrixInv.copy( matrix ).invert(); instead."),this.copy(e).invert()};Me.prototype.extractPosition=function(e){return console.warn("THREE.Matrix4: .extractPosition() has been renamed to .copyPosition()."),this.copyPosition(e)};Me.prototype.flattenToArrayOffset=function(e,t){return console.warn("THREE.Matrix4: .flattenToArrayOffset() has been deprecated. Use .toArray() instead."),this.toArray(e,t)};Me.prototype.getPosition=function(){return console.warn("THREE.Matrix4: .getPosition() has been removed. Use Vector3.setFromMatrixPosition( matrix ) instead."),new j().setFromMatrixColumn(this,3)};Me.prototype.setRotationFromQuaternion=function(e){return console.warn("THREE.Matrix4: .setRotationFromQuaternion() has been renamed to .makeRotationFromQuaternion()."),this.makeRotationFromQuaternion(e)};Me.prototype.multiplyToArray=function(){console.warn("THREE.Matrix4: .multiplyToArray() has been removed.")};Me.prototype.multiplyVector3=function(e){return console.warn("THREE.Matrix4: .multiplyVector3() has been removed. Use vector.applyMatrix4( matrix ) instead."),e.applyMatrix4(this)};Me.prototype.multiplyVector4=function(e){return console.warn("THREE.Matrix4: .multiplyVector4() has been removed. Use vector.applyMatrix4( matrix ) instead."),e.applyMatrix4(this)};Me.prototype.multiplyVector3Array=function(){console.error("THREE.Matrix4: .multiplyVector3Array() has been removed.")};Me.prototype.rotateAxis=function(e){console.warn("THREE.Matrix4: .rotateAxis() has been removed. Use Vector3.transformDirection( matrix ) instead."),e.transformDirection(this)};Me.prototype.crossVector=function(e){return console.warn("THREE.Matrix4: .crossVector() has been removed. Use vector.applyMatrix4( matrix ) instead."),e.applyMatrix4(this)};Me.prototype.translate=function(){console.error("THREE.Matrix4: .translate() has been removed.")};Me.prototype.rotateX=function(){console.error("THREE.Matrix4: .rotateX() has been removed.")};Me.prototype.rotateY=function(){console.error("THREE.Matrix4: .rotateY() has been removed.")};Me.prototype.rotateZ=function(){console.error("THREE.Matrix4: .rotateZ() has been removed.")};Me.prototype.rotateByAxis=function(){console.error("THREE.Matrix4: .rotateByAxis() has been removed.")};Me.prototype.applyToBufferAttribute=function(e){return console.warn("THREE.Matrix4: .applyToBufferAttribute() has been removed. Use attribute.applyMatrix4( matrix ) instead."),e.applyMatrix4(this)};Me.prototype.applyToVector3Array=function(){console.error("THREE.Matrix4: .applyToVector3Array() has been removed.")};Me.prototype.makeFrustum=function(e,t,r,n,i,o){return console.warn("THREE.Matrix4: .makeFrustum() has been removed. Use .makePerspective( left, right, top, bottom, near, far ) instead."),this.makePerspective(e,t,n,r,i,o)};Me.prototype.getInverse=function(e){return console.warn("THREE.Matrix4: .getInverse() has been removed. Use matrixInv.copy( matrix ).invert(); instead."),this.copy(e).invert()};$c.prototype.isIntersectionLine=function(e){return console.warn("THREE.Plane: .isIntersectionLine() has been renamed to .intersectsLine()."),this.intersectsLine(e)};yi.prototype.multiplyVector3=function(e){return console.warn("THREE.Quaternion: .multiplyVector3() has been removed. Use is now vector.applyQuaternion( quaternion ) instead."),e.applyQuaternion(this)};yi.prototype.inverse=function(){return console.warn("THREE.Quaternion: .inverse() has been renamed to invert()."),this.invert()};Jf.prototype.isIntersectionBox=function(e){return console.warn("THREE.Ray: .isIntersectionBox() has been renamed to .intersectsBox()."),this.intersectsBox(e)};Jf.prototype.isIntersectionPlane=function(e){return console.warn("THREE.Ray: .isIntersectionPlane() has been renamed to .intersectsPlane()."),this.intersectsPlane(e)};Jf.prototype.isIntersectionSphere=function(e){return console.warn("THREE.Ray: .isIntersectionSphere() has been renamed to .intersectsSphere()."),this.intersectsSphere(e)};oi.prototype.area=function(){return console.warn("THREE.Triangle: .area() has been renamed to .getArea()."),this.getArea()};oi.prototype.barycoordFromPoint=function(e,t){return console.warn("THREE.Triangle: .barycoordFromPoint() has been renamed to .getBarycoord()."),this.getBarycoord(e,t)};oi.prototype.midpoint=function(e){return console.warn("THREE.Triangle: .midpoint() has been renamed to .getMidpoint()."),this.getMidpoint(e)};oi.prototypenormal=function(e){return console.warn("THREE.Triangle: .normal() has been renamed to .getNormal()."),this.getNormal(e)};oi.prototype.plane=function(e){return console.warn("THREE.Triangle: .plane() has been renamed to .getPlane()."),this.getPlane(e)};oi.barycoordFromPoint=function(e,t,r,n,i){return console.warn("THREE.Triangle: .barycoordFromPoint() has been renamed to .getBarycoord()."),oi.getBarycoord(e,t,r,n,i)};oi.normal=function(e,t,r,n){return console.warn("THREE.Triangle: .normal() has been renamed to .getNormal()."),oi.getNormal(e,t,r,n)};Kc.prototype.extractAllPoints=function(e){return console.warn("THREE.Shape: .extractAllPoints() has been removed. Use .extractPoints() instead."),this.extractPoints(e)};Kc.prototype.extrude=function(e){return console.warn("THREE.Shape: .extrude() has been removed. Use ExtrudeGeometry() instead."),new hh(this,e)};Kc.prototype.makeGeometry=function(e){return console.warn("THREE.Shape: .makeGeometry() has been removed. Use ShapeGeometry() instead."),new Y0(this,e)};Lt.prototype.fromAttribute=function(e,t,r){return console.warn("THREE.Vector2: .fromAttribute() has been renamed to .fromBufferAttribute()."),this.fromBufferAttribute(e,t,r)};Lt.prototype.distanceToManhattan=function(e){return console.warn("THREE.Vector2: .distanceToManhattan() has been renamed to .manhattanDistanceTo()."),this.manhattanDistanceTo(e)};Lt.prototype.lengthManhattan=function(){return console.warn("THREE.Vector2: .lengthManhattan() has been renamed to .manhattanLength()."),this.manhattanLength()};j.prototype.setEulerFromRotationMatrix=function(){console.error("THREE.Vector3: .setEulerFromRotationMatrix() has been removed. Use Euler.setFromRotationMatrix() instead.")};j.prototype.setEulerFromQuaternion=function(){console.error("THREE.Vector3: .setEulerFromQuaternion() has been removed. Use Euler.setFromQuaternion() instead.")};j.prototype.getPositionFromMatrix=function(e){return console.warn("THREE.Vector3: .getPositionFromMatrix() has been renamed to .setFromMatrixPosition()."),this.setFromMatrixPosition(e)};j.prototype.getScaleFromMatrix=function(e){return console.warn("THREE.Vector3: .getScaleFromMatrix() has been renamed to .setFromMatrixScale()."),this.setFromMatrixScale(e)};j.prototype.getColumnFromMatrix=function(e,t){return console.warn("THREE.Vector3: .getColumnFromMatrix() has been renamed to .setFromMatrixColumn()."),this.setFromMatrixColumn(t,e)};j.prototype.applyProjection=function(e){return console.warn("THREE.Vector3: .applyProjection() has been removed. Use .applyMatrix4( m ) instead."),this.applyMatrix4(e)};j.prototype.fromAttribute=function(e,t,r){return console.warn("THREE.Vector3: .fromAttribute() has been renamed to .fromBufferAttribute()."),this.fromBufferAttribute(e,t,r)};j.prototype.distanceToManhattan=function(e){return console.warn("THREE.Vector3: .distanceToManhattan() has been renamed to .manhattanDistanceTo()."),this.manhattanDistanceTo(e)};j.prototype.lengthManhattan=function(){return console.warn("THREE.Vector3: .lengthManhattan() has been renamed to .manhattanLength()."),this.manhattanLength()};en.prototype.fromAttribute=function(e,t,r){return console.warn("THREE.Vector4: .fromAttribute() has been renamed to .fromBufferAttribute()."),this.fromBufferAttribute(e,t,r)};en.prototype.lengthManhattan=function(){return console.warn("THREE.Vector4: .lengthManhattan() has been renamed to .manhattanLength()."),this.manhattanLength()};or.prototype.getChildByName=function(e){return console.warn("THREE.Object3D: .getChildByName() has been renamed to .getObjectByName()."),this.getObjectByName(e)};or.prototype.renderDepth=function(){console.warn("THREE.Object3D: .renderDepth has been removed. Use .renderOrder, instead.")};or.prototype.translate=function(e,t){return console.warn("THREE.Object3D: .translate() has been removed. Use .translateOnAxis( axis, distance ) instead."),this.translateOnAxis(t,e)};or.prototype.getWorldRotation=function(){console.error("THREE.Object3D: .getWorldRotation() has been removed. Use THREE.Object3D.getWorldQuaternion( target ) instead.")};or.prototype.applyMatrix=function(e){return console.warn("THREE.Object3D: .applyMatrix() has been renamed to .applyMatrix4()."),this.applyMatrix4(e)};Object.defineProperties(or.prototype,{eulerOrder:{get:function(){return console.warn("THREE.Object3D: .eulerOrder is now .rotation.order."),this.rotation.order},set:function(e){console.warn("THREE.Object3D: .eulerOrder is now .rotation.order."),this.rotation.order=e}},useQuaternion:{get:function(){console.warn("THREE.Object3D: .useQuaternion has been removed. The library now uses quaternions by default.")},set:function(){console.warn("THREE.Object3D: .useQuaternion has been removed. The library now uses quaternions by default.")}}});ti.prototype.setDrawMode=function(){console.error("THREE.Mesh: .setDrawMode() has been removed. The renderer now always assumes THREE.TrianglesDrawMode. Transform your geometry via BufferGeometryUtils.toTrianglesDrawMode() if necessary.")};Object.defineProperties(ti.prototype,{drawMode:{get:function(){return console.error("THREE.Mesh: .drawMode has been removed. The renderer now always assumes THREE.TrianglesDrawMode."),kfe},set:function(){console.error("THREE.Mesh: .drawMode has been removed. The renderer now always assumes THREE.TrianglesDrawMode. Transform your geometry via BufferGeometryUtils.toTrianglesDrawMode() if necessary.")}}});aM.prototype.initBones=function(){console.error("THREE.SkinnedMesh: initBones() has been removed.")};Ui.prototype.setLens=function(e,t){console.warn("THREE.PerspectiveCamera.setLens is deprecated. Use .setFocalLength and .filmGauge for a photographic setup."),t!==void 0&&(this.filmGauge=t),this.setFocalLength(e)};Object.defineProperties(Ol.prototype,{onlyShadow:{set:function(){console.warn("THREE.Light: .onlyShadow has been removed.")}},shadowCameraFov:{set:function(e){console.warn("THREE.Light: .shadowCameraFov is now .shadow.camera.fov."),this.shadow.camera.fov=e}},shadowCameraLeft:{set:function(e){console.warn("THREE.Light: .shadowCameraLeft is now .shadow.camera.left."),this.shadow.camera.left=e}},shadowCameraRight:{set:function(e){console.warn("THREE.Light: .shadowCameraRight is now .shadow.camera.right."),this.shadow.camera.right=e}},shadowCameraTop:{set:function(e){console.warn("THREE.Light: .shadowCameraTop is now .shadow.camera.top."),this.shadow.camera.top=e}},shadowCameraBottom:{set:function(e){console.warn("THREE.Light: .shadowCameraBottom is now .shadow.camera.bottom."),this.shadow.camera.bottom=e}},shadowCameraNear:{set:function(e){console.warn("THREE.Light: .shadowCameraNear is now .shadow.camera.near."),this.shadow.camera.near=e}},shadowCameraFar:{set:function(e){console.warn("THREE.Light: .shadowCameraFar is now .shadow.camera.far."),this.shadow.camera.far=e}},shadowCameraVisible:{set:function(){console.warn("THREE.Light: .shadowCameraVisible has been removed. Use new THREE.CameraHelper( light.shadow.camera ) instead.")}},shadowBias:{set:function(e){console.warn("THREE.Light: .shadowBias is now .shadow.bias."),this.shadow.bias=e}},shadowDarkness:{set:function(){console.warn("THREE.Light: .shadowDarkness has been removed.")}},shadowMapWidth:{set:function(e){console.warn("THREE.Light: .shadowMapWidth is now .shadow.mapSize.width."),this.shadow.mapSize.width=e}},shadowMapHeight:{set:function(e){console.warn("THREE.Light: .shadowMapHeight is now .shadow.mapSize.height."),this.shadow.mapSize.height=e}}});Object.defineProperties(Je.prototype,{length:{get:function(){return console.warn("THREE.BufferAttribute: .length has been deprecated. Use .count instead."),this.array.length}},dynamic:{get:function(){return console.warn("THREE.BufferAttribute: .dynamic has been deprecated. Use .usage instead."),this.usage===Y3},set:function(){console.warn("THREE.BufferAttribute: .dynamic has been deprecated. Use .usage instead."),this.setUsage(Y3)}}});Je.prototype.setDynamic=function(e){return console.warn("THREE.BufferAttribute: .setDynamic() has been deprecated. Use .setUsage() instead."),this.setUsage(e===!0?Y3:W3),this};Je.prototype.copyIndicesArray=function(){console.error("THREE.BufferAttribute: .copyIndicesArray() has been removed.")},Je.prototype.setArray=function(){console.error("THREE.BufferAttribute: .setArray has been removed. Use BufferGeometry .setAttribute to replace/resize attribute buffers")};Pe.prototype.addIndex=function(e){console.warn("THREE.BufferGeometry: .addIndex() has been renamed to .setIndex()."),this.setIndex(e)};Pe.prototype.addAttribute=function(e,t){return console.warn("THREE.BufferGeometry: .addAttribute() has been renamed to .setAttribute()."),!(t&&t.isBufferAttribute)&&!(t&&t.isInterleavedBufferAttribute)?(console.warn("THREE.BufferGeometry: .addAttribute() now expects ( name, attribute )."),this.setAttribute(e,new Je(arguments[1],arguments[2]))):e==="index"?(console.warn("THREE.BufferGeometry.addAttribute: Use .setIndex() for index attribute."),this.setIndex(t),this):this.setAttribute(e,t)};Pe.prototype.addDrawCall=function(e,t,r){r!==void 0&&console.warn("THREE.BufferGeometry: .addDrawCall() no longer supports indexOffset."),console.warn("THREE.BufferGeometry: .addDrawCall() is now .addGroup()."),this.addGroup(e,t)};Pe.prototype.clearDrawCalls=function(){console.warn("THREE.BufferGeometry: .clearDrawCalls() is now .clearGroups()."),this.clearGroups()};Pe.prototype.computeOffsets=function(){console.warn("THREE.BufferGeometry: .computeOffsets() has been removed.")};Pe.prototype.removeAttribute=function(e){return console.warn("THREE.BufferGeometry: .removeAttribute() has been renamed to .deleteAttribute()."),this.deleteAttribute(e)};Pe.prototype.applyMatrix=function(e){return console.warn("THREE.BufferGeometry: .applyMatrix() has been renamed to .applyMatrix4()."),this.applyMatrix4(e)};Object.defineProperties(Pe.prototype,{drawcalls:{get:function(){return console.error("THREE.BufferGeometry: .drawcalls has been renamed to .groups."),this.groups}},offsets:{get:function(){return console.warn("THREE.BufferGeometry: .offsets has been renamed to .groups."),this.groups}}});em.prototype.setDynamic=function(e){return console.warn("THREE.InterleavedBuffer: .setDynamic() has been deprecated. Use .setUsage() instead."),this.setUsage(e===!0?Y3:W3),this};em.prototype.setArray=function(){console.error("THREE.InterleavedBuffer: .setArray has been removed. Use BufferGeometry .setAttribute to replace/resize attribute buffers")};hh.prototype.getArrays=function(){console.error("THREE.ExtrudeGeometry: .getArrays() has been removed.")};hh.prototype.addShapeList=function(){console.error("THREE.ExtrudeGeometry: .addShapeList() has been removed.")};hh.prototype.addShape=function(){console.error("THREE.ExtrudeGeometry: .addShape() has been removed.")};q0.prototype.dispose=function(){console.error("THREE.Scene: .dispose() has been removed.")};gM.prototype.onUpdate=function(){return console.warn("THREE.Uniform: .onUpdate() has been removed. Use object.onBeforeRender() instead."),this};Object.defineProperties(qi.prototype,{wrapAround:{get:function(){console.warn("THREE.Material: .wrapAround has been removed.")},set:function(){console.warn("THREE.Material: .wrapAround has been removed.")}},overdraw:{get:function(){console.warn("THREE.Material: .overdraw has been removed.")},set:function(){console.warn("THREE.Material: .overdraw has been removed.")}},wrapRGB:{get:function(){return console.warn("THREE.Material: .wrapRGB has been removed."),new ne}},shading:{get:function(){console.error("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead.")},set:function(e){console.warn("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead."),this.flatShading=e===Aht}},stencilMask:{get:function(){return console.warn("THREE."+this.type+": .stencilMask has been removed. Use .stencilFuncMask instead."),this.stencilFuncMask},set:function(e){console.warn("THREE."+this.type+": .stencilMask has been removed. Use .stencilFuncMask instead."),this.stencilFuncMask=e}},vertexTangents:{get:function(){console.warn("THREE."+this.type+": .vertexTangents has been removed.")},set:function(){console.warn("THREE."+this.type+": .vertexTangents has been removed.")}}});Object.defineProperties(lh.prototype,{derivatives:{get:function(){return console.warn("THREE.ShaderMaterial: .derivatives has been moved to .extensions.derivatives."),this.extensions.derivatives},set:function(e){console.warn("THREE. ShaderMaterial: .derivatives has been moved to .extensions.derivatives."),this.extensions.derivatives=e}}});rn.prototype.clearTarget=function(e,t,r,n){console.warn("THREE.WebGLRenderer: .clearTarget() has been deprecated. Use .setRenderTarget() and .clear() instead."),this.setRenderTarget(e),this.clear(t,r,n)};rn.prototype.animate=function(e){console.warn("THREE.WebGLRenderer: .animate() is now .setAnimationLoop()."),this.setAnimationLoop(e)};rn.prototype.getCurrentRenderTarget=function(){return console.warn("THREE.WebGLRenderer: .getCurrentRenderTarget() is now .getRenderTarget()."),this.getRenderTarget()};rn.prototype.getMaxAnisotropy=function(){return console.warn("THREE.WebGLRenderer: .getMaxAnisotropy() is now .capabilities.getMaxAnisotropy()."),this.capabilities.getMaxAnisotropy()};rn.prototype.getPrecision=function(){return console.warn("THREE.WebGLRenderer: .getPrecision() is now .capabilities.precision."),this.capabilities.precision};rn.prototype.resetGLState=function(){return console.warn("THREE.WebGLRenderer: .resetGLState() is now .state.reset()."),this.state.reset()};rn.prototype.supportsFloatTextures=function(){return console.warn("THREE.WebGLRenderer: .supportsFloatTextures() is now .extensions.get( 'OES_texture_float' )."),this.extensions.get("OES_texture_float")};rn.prototype.supportsHalfFloatTextures=function(){return console.warn("THREE.WebGLRenderer: .supportsHalfFloatTextures() is now .extensions.get( 'OES_texture_half_float' )."),this.extensions.get("OES_texture_half_float")};rn.prototype.supportsStandardDerivatives=function(){return console.warn("THREE.WebGLRenderer: .supportsStandardDerivatives() is now .extensions.get( 'OES_standard_derivatives' )."),this.extensions.get("OES_standard_derivatives")};rn.prototype.supportsCompressedTextureS3TC=function(){return console.warn("THREE.WebGLRenderer: .supportsCompressedTextureS3TC() is now .extensions.get( 'WEBGL_compressed_texture_s3tc' )."),this.extensions.get("WEBGL_compressed_texture_s3tc")};rn.prototype.supportsCompressedTexturePVRTC=function(){return console.warn("THREE.WebGLRenderer: .supportsCompressedTexturePVRTC() is now .extensions.get( 'WEBGL_compressed_texture_pvrtc' )."),this.extensions.get("WEBGL_compressed_texture_pvrtc")};rn.prototype.supportsBlendMinMax=function(){return console.warn("THREE.WebGLRenderer: .supportsBlendMinMax() is now .extensions.get( 'EXT_blend_minmax' )."),this.extensions.get("EXT_blend_minmax")};rn.prototype.supportsVertexTextures=function(){return console.warn("THREE.WebGLRenderer: .supportsVertexTextures() is now .capabilities.vertexTextures."),this.capabilities.vertexTextures};rn.prototype.supportsInstancedArrays=function(){return console.warn("THREE.WebGLRenderer: .supportsInstancedArrays() is now .extensions.get( 'ANGLE_instanced_arrays' )."),this.extensions.get("ANGLE_instanced_arrays")};rn.prototype.enableScissorTest=function(e){console.warn("THREE.WebGLRenderer: .enableScissorTest() is now .setScissorTest()."),this.setScissorTest(e)};rn.prototype.initMaterial=function(){console.warn("THREE.WebGLRenderer: .initMaterial() has been removed.")};rn.prototype.addPrePlugin=function(){console.warn("THREE.WebGLRenderer: .addPrePlugin() has been removed.")};rn.prototype.addPostPlugin=function(){console.warn("THREE.WebGLRenderer: .addPostPlugin() has been removed.")};rn.prototype.updateShadowMap=function(){console.warn("THREE.WebGLRenderer: .updateShadowMap() has been removed.")};rn.prototype.setFaceCulling=function(){console.warn("THREE.WebGLRenderer: .setFaceCulling() has been removed.")};rn.prototype.allocTextureUnit=function(){console.warn("THREE.WebGLRenderer: .allocTextureUnit() has been removed.")};rn.prototype.setTexture=function(){console.warn("THREE.WebGLRenderer: .setTexture() has been removed.")};rn.prototype.setTexture2D=function(){console.warn("THREE.WebGLRenderer: .setTexture2D() has been removed.")};rn.prototype.setTextureCube=function(){console.warn("THREE.WebGLRenderer: .setTextureCube() has been removed.")};rn.prototype.getActiveMipMapLevel=function(){return console.warn("THREE.WebGLRenderer: .getActiveMipMapLevel() is now .getActiveMipmapLevel()."),this.getActiveMipmapLevel()};Object.defineProperties(rn.prototype,{shadowMapEnabled:{get:function(){return this.shadowMap.enabled},set:function(e){console.warn("THREE.WebGLRenderer: .shadowMapEnabled is now .shadowMap.enabled."),this.shadowMap.enabled=e}},shadowMapType:{get:function(){return this.shadowMap.type},set:function(e){console.warn("THREE.WebGLRenderer: .shadowMapType is now .shadowMap.type."),this.shadowMap.type=e}},shadowMapCullFace:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMapCullFace has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMapCullFace has been removed. Set Material.shadowSide instead.")}},context:{get:function(){return console.warn("THREE.WebGLRenderer: .context has been removed. Use .getContext() instead."),this.getContext()}},vr:{get:function(){return console.warn("THREE.WebGLRenderer: .vr has been renamed to .xr"),this.xr}},gammaInput:{get:function(){return console.warn("THREE.WebGLRenderer: .gammaInput has been removed. Set the encoding for textures via Texture.encoding instead."),!1},set:function(){console.warn("THREE.WebGLRenderer: .gammaInput has been removed. Set the encoding for textures via Texture.encoding instead.")}},gammaOutput:{get:function(){return console.warn("THREE.WebGLRenderer: .gammaOutput has been removed. Set WebGLRenderer.outputEncoding instead."),!1},set:function(e){console.warn("THREE.WebGLRenderer: .gammaOutput has been removed. Set WebGLRenderer.outputEncoding instead."),this.outputEncoding=e===!0?Wn:Qd}},toneMappingWhitePoint:{get:function(){return console.warn("THREE.WebGLRenderer: .toneMappingWhitePoint has been removed."),1},set:function(){console.warn("THREE.WebGLRenderer: .toneMappingWhitePoint has been removed.")}},gammaFactor:{get:function(){return console.warn("THREE.WebGLRenderer: .gammaFactor has been removed."),2},set:function(){console.warn("THREE.WebGLRenderer: .gammaFactor has been removed.")}}});Object.defineProperties(Jfe.prototype,{cullFace:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMap.cullFace has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMap.cullFace has been removed. Set Material.shadowSide instead.")}},renderReverseSided:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderReverseSided has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderReverseSided has been removed. Set Material.shadowSide instead.")}},renderSingleSided:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderSingleSided has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderSingleSided has been removed. Set Material.shadowSide instead.")}}});function r_r(e,t,r){return console.warn("THREE.WebGLRenderTargetCube( width, height, options ) is now WebGLCubeRenderTarget( size, options )."),new Q3(e,r)}Object.defineProperties(us.prototype,{wrapS:{get:function(){return console.warn("THREE.WebGLRenderTarget: .wrapS is now .texture.wrapS."),this.texture.wrapS},set:function(e){console.warn("THREE.WebGLRenderTarget: .wrapS is now .texture.wrapS."),this.texture.wrapS=e}},wrapT:{get:function(){return console.warn("THREE.WebGLRenderTarget: .wrapT is now .texture.wrapT."),this.texture.wrapT},set:function(e){console.warn("THREE.WebGLRenderTarget: .wrapT is now .texture.wrapT."),this.texture.wrapT=e}},magFilter:{get:function(){return console.warn("THREE.WebGLRenderTarget: .magFilter is now .texture.magFilter."),this.texture.magFilter},set:function(e){console.warn("THREE.WebGLRenderTarget: .magFilter is now .texture.magFilter."),this.texture.magFilter=e}},minFilter:{get:function(){return console.warn("THREE.WebGLRenderTarget: .minFilter is now .texture.minFilter."),this.texture.minFilter},set:function(e){console.warn("THREE.WebGLRenderTarget: .minFilter is now .texture.minFilter."),this.texture.minFilter=e}},anisotropy:{get:function(){return console.warn("THREE.WebGLRenderTarget: .anisotropy is now .texture.anisotropy."),this.texture.anisotropy},set:function(e){console.warn("THREE.WebGLRenderTarget: .anisotropy is now .texture.anisotropy."),this.texture.anisotropy=e}},offset:{get:function(){return console.warn("THREE.WebGLRenderTarget: .offset is now .texture.offset."),this.texture.offset},set:function(e){console.warn("THREE.WebGLRenderTarget: .offset is now .texture.offset."),this.texture.offset=e}},repeat:{get:function(){return console.warn("THREE.WebGLRenderTarget: .repeat is now .texture.repeat."),this.texture.repeat},set:function(e){console.warn("THREE.WebGLRenderTarget: .repeat is now .texture.repeat."),this.texture.repeat=e}},format:{get:function(){return console.warn("THREE.WebGLRenderTarget: .format is now .texture.format."),this.texture.format},set:function(e){console.warn("THREE.WebGLRenderTarget: .format is now .texture.format."),this.texture.format=e}},type:{get:function(){return console.warn("THREE.WebGLRenderTarget: .type is now .texture.type."),this.texture.type},set:function(e){console.warn("THREE.WebGLRenderTarget: .type is now .texture.type."),this.texture.type=e}},generateMipmaps:{get:function(){return console.warn("THREE.WebGLRenderTarget: .generateMipmaps is now .texture.generateMipmaps."),this.texture.generateMipmaps},set:function(e){console.warn("THREE.WebGLRenderTarget: .generateMipmaps is now .texture.generateMipmaps."),this.texture.generateMipmaps=e}}});D6.prototype.load=function(e){console.warn("THREE.Audio: .load has been deprecated. Use THREE.AudioLoader instead.");let t=this;return new DU().load(e,function(n){t.setBuffer(n)}),this};FU.prototype.getData=function(){return console.warn("THREE.AudioAnalyser: .getData() is now .getFrequencyData()."),this.getFrequencyData()};J3.prototype.updateCubeMap=function(e,t){return console.warn("THREE.CubeCamera: .updateCubeMap() is now .update()."),this.update(e,t)};J3.prototype.clear=function(e,t,r,n){return console.warn("THREE.CubeCamera: .clear() is now .renderTarget.clear()."),this.renderTarget.clear(e,t,r,n)};Kf.crossOrigin=void 0;Kf.loadTexture=function(e,t,r,n){console.warn("THREE.ImageUtils.loadTexture has been deprecated. Use THREE.TextureLoader() instead.");let i=new AU;i.setCrossOrigin(this.crossOrigin);let o=i.load(e,r,void 0,n);return t&&(o.mapping=t),o};Kf.loadTextureCube=function(e,t,r,n){console.warn("THREE.ImageUtils.loadTextureCube has been deprecated. Use THREE.CubeTextureLoader() instead.");let i=new TU;i.setCrossOrigin(this.crossOrigin);let o=i.load(e,r,void 0,n);return t&&(o.mapping=t),o};Kf.loadCompressedTexture=function(){console.error("THREE.ImageUtils.loadCompressedTexture has been removed. Use THREE.DDSLoader instead.")};Kf.loadCompressedTextureCube=function(){console.error("THREE.ImageUtils.loadCompressedTextureCube has been removed. Use THREE.DDSLoader instead.")};function n_r(){console.error("THREE.CanvasRenderer has been removed")}function i_r(){console.error("THREE.JSONLoader has been removed.")}var o_r={createMultiMaterialObject:function(){console.error("THREE.SceneUtils has been moved to /examples/jsm/utils/SceneUtils.js")},detach:function(){console.error("THREE.SceneUtils has been moved to /examples/jsm/utils/SceneUtils.js")},attach:function(){console.error("THREE.SceneUtils has been moved to /examples/jsm/utils/SceneUtils.js")}};function a_r(){console.error("THREE.LensFlare has been moved to /examples/jsm/objects/Lensflare.js")}function s_r(){return console.error("THREE.ParametricGeometry has been moved to /examples/jsm/geometries/ParametricGeometry.js"),new Pe}function l_r(){return console.error("THREE.TextGeometry has been moved to /examples/jsm/geometries/TextGeometry.js"),new Pe}function c_r(){console.error("THREE.FontLoader has been moved to /examples/jsm/loaders/FontLoader.js")}function u_r(){console.error("THREE.Font has been moved to /examples/jsm/loaders/FontLoader.js")}function h_r(){console.error("THREE.ImmediateRenderObject has been removed.")}typeof __THREE_DEVTOOLS__!="undefined"&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("register",{detail:{revision:jU}}));typeof window!="undefined"&&(window.__THREE__?console.warn("WARNING: Multiple instances of Three.js being imported."):window.__THREE__=jU);var spe={type:"change"},Hht={type:"start"},lpe={type:"end"},JU=class extends Us{constructor(t,r){super(),r===void 0&&console.warn('THREE.OrbitControls: The second parameter "domElement" is now mandatory.'),r===document&&console.error('THREE.OrbitControls: "document" should not be used as the target "domElement". Please use "renderer.domElement" instead.'),this.object=t,this.domElement=r,this.domElement.style.touchAction="none",this.enabled=!0,this.target=new j,this.minDistance=0,this.maxDistance=1/0,this.minZoom=0,this.maxZoom=1/0,this.minPolarAngle=0,this.maxPolarAngle=Math.PI,this.minAzimuthAngle=-1/0,this.maxAzimuthAngle=1/0,this.enableDamping=!1,this.dampingFactor=.05,this.enableZoom=!0,this.zoomSpeed=1,this.enableRotate=!0,this.rotateSpeed=1,this.enablePan=!0,this.panSpeed=1,this.screenSpacePanning=!0,this.keyPanSpeed=7,this.autoRotate=!1,this.autoRotateSpeed=2,this.keys={LEFT:"ArrowLeft",UP:"ArrowUp",RIGHT:"ArrowRight",BOTTOM:"ArrowDown"},this.mouseButtons={LEFT:K0.ROTATE,MIDDLE:K0.DOLLY,RIGHT:K0.PAN},this.touches={ONE:Z0.ROTATE,TWO:Z0.DOLLY_PAN},this.target0=this.target.clone(),this.position0=this.object.position.clone(),this.zoom0=this.object.zoom,this._domElementKeyEvents=null,this.getPolarAngle=function(){return s.phi},this.getAzimuthalAngle=function(){return s.theta},this.getDistance=function(){return this.object.position.distanceTo(this.target)},this.listenToKeyEvents=function(nt){nt.addEventListener("keydown",fr),this._domElementKeyEvents=nt},this.saveState=function(){n.target0.copy(n.target),n.position0.copy(n.object.position),n.zoom0=n.object.zoom},this.reset=function(){n.target.copy(n.target0),n.object.position.copy(n.position0),n.object.zoom=n.zoom0,n.object.updateProjectionMatrix(),n.dispatchEvent(spe),n.update(),o=i.NONE},this.update=function(){let nt=new j,Ct=new yi().setFromUnitVectors(t.up,new j(0,1,0)),Wt=Ct.clone().invert(),fe=new j,at=new yi,se=2*Math.PI;return function(){let Ce=n.object.position;nt.copy(Ce).sub(n.target),nt.applyQuaternion(Ct),s.setFromVector3(nt),n.autoRotate&&o===i.NONE&&D(k()),n.enableDamping?(s.theta+=l.theta*n.dampingFactor,s.phi+=l.phi*n.dampingFactor):(s.theta+=l.theta,s.phi+=l.phi);let Pt=n.minAzimuthAngle,Nt=n.maxAzimuthAngle;return isFinite(Pt)&&isFinite(Nt)&&(Pt<-Math.PI?Pt+=se:Pt>Math.PI&&(Pt-=se),Nt<-Math.PI?Nt+=se:Nt>Math.PI&&(Nt-=se),Pt<=Nt?s.theta=Math.max(Pt,Math.min(Nt,s.theta)):s.theta=s.theta>(Pt+Nt)/2?Math.max(Pt,s.theta):Math.min(Nt,s.theta)),s.phi=Math.max(n.minPolarAngle,Math.min(n.maxPolarAngle,s.phi)),s.makeSafe(),s.radius*=c,s.radius=Math.max(n.minDistance,Math.min(n.maxDistance,s.radius)),n.enableDamping===!0?n.target.addScaledVector(u,n.dampingFactor):n.target.add(u),nt.setFromSpherical(s),nt.applyQuaternion(Wt),Ce.copy(n.target).add(nt),n.object.lookAt(n.target),n.enableDamping===!0?(l.theta*=1-n.dampingFactor,l.phi*=1-n.dampingFactor,u.multiplyScalar(1-n.dampingFactor)):(l.set(0,0,0),u.set(0,0,0)),c=1,h||fe.distanceToSquared(n.object.position)>a||8*(1-at.dot(n.object.quaternion))>a?(n.dispatchEvent(spe),fe.copy(n.object.position),at.copy(n.object.quaternion),h=!1,!0):!1}}(),this.dispose=function(){n.domElement.removeEventListener("contextmenu",It),n.domElement.removeEventListener("pointerdown",ht),n.domElement.removeEventListener("pointercancel",ie),n.domElement.removeEventListener("wheel",ar),n.domElement.removeEventListener("pointermove",wt),n.domElement.removeEventListener("pointerup",kt),n._domElementKeyEvents!==null&&n._domElementKeyEvents.removeEventListener("keydown",fr)};let n=this,i={NONE:-1,ROTATE:0,DOLLY:1,PAN:2,TOUCH_ROTATE:3,TOUCH_PAN:4,TOUCH_DOLLY_PAN:5,TOUCH_DOLLY_ROTATE:6},o=i.NONE,a=1e-6,s=new _M,l=new _M,c=1,u=new j,h=!1,f=new Lt,p=new Lt,d=new Lt,g=new Lt,_=new Lt,y=new Lt,x=new Lt,b=new Lt,S=new Lt,C=[],P={};function k(){return 2*Math.PI/60/60*n.autoRotateSpeed}function O(){return Math.pow(.95,n.zoomSpeed)}function D(nt){l.theta-=nt}function B(nt){l.phi-=nt}let I=function(){let nt=new j;return function(Wt,fe){nt.setFromMatrixColumn(fe,0),nt.multiplyScalar(-Wt),u.add(nt)}}(),L=function(){let nt=new j;return function(Wt,fe){n.screenSpacePanning===!0?nt.setFromMatrixColumn(fe,1):(nt.setFromMatrixColumn(fe,0),nt.crossVectors(n.object.up,nt)),nt.multiplyScalar(Wt),u.add(nt)}}(),R=function(){let nt=new j;return function(Wt,fe){let at=n.domElement;if(n.object.isPerspectiveCamera){let se=n.object.position;nt.copy(se).sub(n.target);let Qt=nt.length();Qt*=Math.tan(n.object.fov/2*Math.PI/180),I(2*Wt*Qt/at.clientHeight,n.object.matrix),L(2*fe*Qt/at.clientHeight,n.object.matrix)}else n.object.isOrthographicCamera?(I(Wt*(n.object.right-n.object.left)/n.object.zoom/at.clientWidth,n.object.matrix),L(fe*(n.object.top-n.object.bottom)/n.object.zoom/at.clientHeight,n.object.matrix)):(console.warn("WARNING: OrbitControls.js encountered an unknown camera type - pan disabled."),n.enablePan=!1)}}();function F(nt){n.object.isPerspectiveCamera?c/=nt:n.object.isOrthographicCamera?(n.object.zoom=Math.max(n.minZoom,Math.min(n.maxZoom,n.object.zoom*nt)),n.object.updateProjectionMatrix(),h=!0):(console.warn("WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled."),n.enableZoom=!1)}function z(nt){n.object.isPerspectiveCamera?c*=nt:n.object.isOrthographicCamera?(n.object.zoom=Math.max(n.minZoom,Math.min(n.maxZoom,n.object.zoom/nt)),n.object.updateProjectionMatrix(),h=!0):(console.warn("WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled."),n.enableZoom=!1)}function U(nt){f.set(nt.clientX,nt.clientY)}function W(nt){x.set(nt.clientX,nt.clientY)}function Z(nt){g.set(nt.clientX,nt.clientY)}function rt(nt){p.set(nt.clientX,nt.clientY),d.subVectors(p,f).multiplyScalar(n.rotateSpeed);let Ct=n.domElement;D(2*Math.PI*d.x/Ct.clientHeight),B(2*Math.PI*d.y/Ct.clientHeight),f.copy(p),n.update()}function ot(nt){b.set(nt.clientX,nt.clientY),S.subVectors(b,x),S.y>0?F(O()):S.y<0&&z(O()),x.copy(b),n.update()}function st(nt){_.set(nt.clientX,nt.clientY),y.subVectors(_,g).multiplyScalar(n.panSpeed),R(y.x,y.y),g.copy(_),n.update()}function St(nt){nt.deltaY<0?z(O()):nt.deltaY>0&&F(O()),n.update()}function bt(nt){let Ct=!1;switch(nt.code){case n.keys.UP:R(0,n.keyPanSpeed),Ct=!0;break;case n.keys.BOTTOM:R(0,-n.keyPanSpeed),Ct=!0;break;case n.keys.LEFT:R(n.keyPanSpeed,0),Ct=!0;break;case n.keys.RIGHT:R(-n.keyPanSpeed,0),Ct=!0;break}Ct&&(nt.preventDefault(),n.update())}function Mt(){if(C.length===1)f.set(C[0].pageX,C[0].pageY);else{let nt=.5*(C[0].pageX+C[1].pageX),Ct=.5*(C[0].pageY+C[1].pageY);f.set(nt,Ct)}}function lt(){if(C.length===1)g.set(C[0].pageX,C[0].pageY);else{let nt=.5*(C[0].pageX+C[1].pageX),Ct=.5*(C[0].pageY+C[1].pageY);g.set(nt,Ct)}}function Kt(){let nt=C[0].pageX-C[1].pageX,Ct=C[0].pageY-C[1].pageY,Wt=Math.sqrt(nt*nt+Ct*Ct);x.set(0,Wt)}function _t(){n.enableZoom&&Kt(),n.enablePan&&lt()}function ct(){n.enableZoom&&Kt(),n.enableRotate&&Mt()}function X(nt){if(C.length==1)p.set(nt.pageX,nt.pageY);else{let Wt=be(nt),fe=.5*(nt.pageX+Wt.x),at=.5*(nt.pageY+Wt.y);p.set(fe,at)}d.subVectors(p,f).multiplyScalar(n.rotateSpeed);let Ct=n.domElement;D(2*Math.PI*d.x/Ct.clientHeight),B(2*Math.PI*d.y/Ct.clientHeight),f.copy(p)}function et(nt){if(C.length===1)_.set(nt.pageX,nt.pageY);else{let Ct=be(nt),Wt=.5*(nt.pageX+Ct.x),fe=.5*(nt.pageY+Ct.y);_.set(Wt,fe)}y.subVectors(_,g).multiplyScalar(n.panSpeed),R(y.x,y.y),g.copy(_)}function dt(nt){let Ct=be(nt),Wt=nt.pageX-Ct.x,fe=nt.pageY-Ct.y,at=Math.sqrt(Wt*Wt+fe*fe);b.set(0,at),S.set(0,Math.pow(b.y/x.y,n.zoomSpeed)),F(S.y),x.copy(b)}function q(nt){n.enableZoom&&dt(nt),n.enablePan&&et(nt)}function pt(nt){n.enableZoom&&dt(nt),n.enableRotate&&X(nt)}function ht(nt){n.enabled!==!1&&(C.length===0&&(n.domElement.setPointerCapture(nt.pointerId),n.domElement.addEventListener("pointermove",wt),n.domElement.addEventListener("pointerup",kt)),$t(nt),nt.pointerType==="touch"?tt(nt):ee(nt))}function wt(nt){n.enabled!==!1&&(nt.pointerType==="touch"?$(nt):Le(nt))}function kt(nt){he(nt),C.length===0&&(n.domElement.releasePointerCapture(nt.pointerId),n.domElement.removeEventListener("pointermove",wt),n.domElement.removeEventListener("pointerup",kt)),n.dispatchEvent(lpe),o=i.NONE}function ie(nt){he(nt)}function ee(nt){let Ct;switch(nt.button){case 0:Ct=n.mouseButtons.LEFT;break;case 1:Ct=n.mouseButtons.MIDDLE;break;case 2:Ct=n.mouseButtons.RIGHT;break;default:Ct=-1}switch(Ct){case K0.DOLLY:if(n.enableZoom===!1)return;W(nt),o=i.DOLLY;break;case K0.ROTATE:if(nt.ctrlKey||nt.metaKey||nt.shiftKey){if(n.enablePan===!1)return;Z(nt),o=i.PAN}else{if(n.enableRotate===!1)return;U(nt),o=i.ROTATE}break;case K0.PAN:if(nt.ctrlKey||nt.metaKey||nt.shiftKey){if(n.enableRotate===!1)return;U(nt),o=i.ROTATE}else{if(n.enablePan===!1)return;Z(nt),o=i.PAN}break;default:o=i.NONE}o!==i.NONE&&n.dispatchEvent(Hht)}function Le(nt){if(n.enabled!==!1)switch(o){case i.ROTATE:if(n.enableRotate===!1)return;rt(nt);break;case i.DOLLY:if(n.enableZoom===!1)return;ot(nt);break;case i.PAN:if(n.enablePan===!1)return;st(nt);break}}function ar(nt){n.enabled===!1||n.enableZoom===!1||o!==i.NONE||(nt.preventDefault(),n.dispatchEvent(Hht),St(nt),n.dispatchEvent(lpe))}function fr(nt){n.enabled===!1||n.enablePan===!1||bt(nt)}function tt(nt){switch(Tt(nt),C.length){case 1:switch(n.touches.ONE){case Z0.ROTATE:if(n.enableRotate===!1)return;Mt(),o=i.TOUCH_ROTATE;break;case Z0.PAN:if(n.enablePan===!1)return;lt(),o=i.TOUCH_PAN;break;default:o=i.NONE}break;case 2:switch(n.touches.TWO){case Z0.DOLLY_PAN:if(n.enableZoom===!1&&n.enablePan===!1)return;_t(),o=i.TOUCH_DOLLY_PAN;break;case Z0.DOLLY_ROTATE:if(n.enableZoom===!1&&n.enableRotate===!1)return;ct(),o=i.TOUCH_DOLLY_ROTATE;break;default:o=i.NONE}break;default:o=i.NONE}o!==i.NONE&&n.dispatchEvent(Hht)}function $(nt){switch(Tt(nt),o){case i.TOUCH_ROTATE:if(n.enableRotate===!1)return;X(nt),n.update();break;case i.TOUCH_PAN:if(n.enablePan===!1)return;et(nt),n.update();break;case i.TOUCH_DOLLY_PAN:if(n.enableZoom===!1&&n.enablePan===!1)return;q(nt),n.update();break;case i.TOUCH_DOLLY_ROTATE:if(n.enableZoom===!1&&n.enableRotate===!1)return;pt(nt),n.update();break;default:o=i.NONE}}function It(nt){n.enabled!==!1&&nt.preventDefault()}function $t(nt){C.push(nt)}function he(nt){delete P[nt.pointerId];for(let Ct=0;Ct<C.length;Ct++)if(C[Ct].pointerId==nt.pointerId){C.splice(Ct,1);return}}function Tt(nt){let Ct=P[nt.pointerId];Ct===void 0&&(Ct=new Lt,P[nt.pointerId]=Ct),Ct.set(nt.pageX,nt.pageY)}function be(nt){let Ct=nt.pointerId===C[0].pointerId?C[1]:C[0];return P[Ct.pointerId]}n.domElement.addEventListener("contextmenu",It),n.domElement.addEventListener("pointerdown",ht),n.domElement.addEventListener("pointercancel",ie),n.domElement.addEventListener("wheel",ar,{passive:!1}),this.update()}};var F6=class extends Us{constructor(t){super(),this._lastMesh=null,this._clock=new mM,this._canvasSize=null,this._layersConfig=null,this._runColor=t}_isObject(t){var r=typeof t;return r=="object"&&t!=null&&!Array.isArray(t)}_applyDefaults(t,r){let n={},i=[t,r];for(let o=0;o<i.length;o++){let a=i[o];for(let s in a){let l=s in n;this._isObject(a[s])?n[s]=this._applyDefaults(n[s]||{},a[s]):l||(n[s]=a[s])}}return n}_createLayers(){if(!(!this._layersConfig||!this._scene||!this._lastMesh)){if(this._layersConfig.showBoundingBox){var t=new yM(this._lastMesh,new ne("rgb(0, 0, 255)"));this._scene.add(t)}if(this._layersConfig.showAxes){var r=new vM(5);this._scene.add(r)}}}setLayersConfig(t){this._layersConfig=this._applyDefaults(t,this._layersConfig||{})}_createWorld(t,r){var a,s,l,c;if(this.isReady())return;this._scene=new q0;var n=new wM[t.camera.cls](t.camera.fov,((a=this._canvasSize)==null?void 0:a.width)/((s=this._canvasSize)==null?void 0:s.height),t.camera.near,t.camera.far);this._camera=n,this.initCameraPosition=void 0,t.camera.position&&(this.initCameraPosition=new j().fromArray(t.camera.position)),this.initCameraLookAt=void 0,t.camera.lookAt&&(this.initCameraLookAt=new j().fromArray(t.camera.lookAt));var i=new JU(n,r);let o=i;o.lookSpeed=.4,o.movementSpeed=20,o.noFly=!0,o.lookVertical=!0,o.constrainVertical=!0,o.verticalMin=1,o.verticalMax=2,o.addEventListener("change",this._onCameraPositionChange.bind(this)),this._cameraControls=i,this._renderer=new rn({antialias:!0}),this._renderer.setPixelRatio(window.devicePixelRatio),this._renderer.setSize((l=this._canvasSize)==null?void 0:l.width,(c=this._canvasSize)==null?void 0:c.height),this._renderer.setClearColor(16777215,1)}_clearScene(){var t;if(this._scene)for(;this._scene.children.length>0;)this._scene.remove((t=this._scene)==null?void 0:t.children[0])}getRenderer(){return this._renderer}getCameraControls(){return this._cameraControls}isReady(){return!!this._camera&&!!this._cameraControls}getCameraPosition(){var t,r,n;return{far:(t=this._camera)==null?void 0:t.far,position:(r=this._camera)==null?void 0:r.position.clone(),target:(n=this._cameraControls)==null?void 0:n.target.clone()}}setCanvasSize(t){this._canvasSize=t}draw(){var r,n,i,o;this._animationFrameIndex&&cancelAnimationFrame(this._animationFrameIndex),this._camera&&(this._camera.aspect=((r=this._canvasSize)==null?void 0:r.width)/((n=this._canvasSize)==null?void 0:n.height),this._camera.updateProjectionMatrix()),this._renderer.setSize((i=this._canvasSize)==null?void 0:i.width,(o=this._canvasSize)==null?void 0:o.height);let t=function(){var a=this._clock.getDelta();this._cameraControls.update(a),this._animationFrameIndex=requestAnimationFrame(t),this._renderer.render(this._scene,this._camera)}.bind(this);t()}updateScene(t,r){let n={};"config"in t&&t.config&&(n=JSON.parse(t.config)),this.dispatchEvent({type:"beforeUpdateScene"});let i={camera:{cls:"PerspectiveCamera",fov:75,near:.1,far:1e3},lights:[{cls:"AmbientLight",color:"#ffffff",intensity:.75},{cls:"DirectionalLight",color:"#ffffff",intensity:.75,position:[0,-1,2]}]};n=this._applyDefaults(n,i),this._createWorld(n,r),this._clearScene(),this._createLights(this._scene,n),this._createGeometry(t,n),this._createLayers(),this.draw()}resetView(t){var n,i;if(!this.isReady())return;(n=this._cameraControls)==null||n.reset();let r;!t&&this._lastMesh&&(r=this._lastMesh),r&&(this._fitObjectToViewport(r),this._lastMesh=r),(i=this._cameraControls)==null||i.update()}_createGeometry(t,r){let n=t.mesh;n.vertices&&n.faces&&n.faces.length?this._createMesh(n,r):this._createPointCloud(n,r)}_createPointCloud(t,r){var h;let n=t.vertices,i=t.colors,o={material:{cls:"PointsMaterial",size:.005}};i&&i.length==n.length?o.material.vertexColors=!0:o.material.color=this._runColor;let a=this._applyDefaults(r,o),s=new Pe,l=new Float32Array(n.flat());if(s.setAttribute("position",new Je(l,3)),i&&i.length==n.length){let f=new Float32Array(i.flat());for(let p=0;p<f.length;p++)f[p]=f[p]/255;s.setAttribute("color",new Je(f,3))}var c=new wM[a.material.cls](a.material),u=new im(s,c);(h=this._scene)==null||h.add(u),this._lastMesh=u}setCameraViewpoint(t,r,n){this._silent=!0,this._camera&&(this._camera.far=r,this._camera.position.set(t.x,t.y,t.z),this._camera.lookAt(n.clone()),this._camera.updateProjectionMatrix()),this._cameraControls&&(this._cameraControls.target=n.clone(),this._cameraControls.update()),this._silent=!1}_onCameraPositionChange(t){this._silent||this.dispatchEvent({type:"cameraPositionChange",event:t})}_fitObjectToViewport(t){var p,d,g;let n=new ta,i=new j,o=new j;n.setFromObject(t),n.getCenter(i),n.getSize(o);let a=Math.max(o.x,o.y,o.z),s=((p=this._camera)==null?void 0:p.fov)*(Math.PI/180),l=Math.abs(a/(2*Math.tan(s/2)))*1.25,c=n.min.z,u=c<0?-c+l:l-c,h=(d=this.initCameraPosition)!=null?d:new j(i.x,i.y,l),f=(g=this.initCameraLookAt)!=null?g:i;this.setCameraViewpoint(h,u*3,f)}_createMesh(t,r){var f;let n=t.vertices,i=t.faces,o=t.colors,a=this._applyDefaults(r,{material:{cls:"MeshStandardMaterial",color:"#a0a0a0",roughness:1,metalness:0}}),s=new Pe,l=new Float32Array(n.flat());s.setAttribute("position",new Je(l,3));let c=new Uint16Array(i.flat());if(o&&o.length){let p=o.flat();for(let d=0;d<p.length;d++)p[d]=p[d]/255;s.setAttribute("color",new Je(new Float32Array(p),3)),a.material=a.material||{},a.material.vertexColors=!0}s.center(),s.computeBoundingSphere(),s.setIndex(new Je(c,1)),s.computeVertexNormals();let u=new wM[a.material.cls](a.material),h=new ti(s,u);h.castShadow=!0,h.receiveShadow=!0,(f=this._scene)==null||f.add(h),this._lastMesh=h}_createLights(t,r){for(let n=0;n<r.lights.length;n++){let i=r.lights[n],o=new wM[i.cls](i.color,i.intensity);i.position&&o.position.set(i.position[0],i.position[1],i.position[2]),t.add(o)}}};var Ln=class extends Gt(mt){constructor(){super(...arguments),this.selectedView="all",this.active=!1,this._colorScaleFunction=fn,this._steps=[],this._meshViewerAttached=!1,this._cameraPositionInitialized=!1,this._isMeshLoading=!1}get _runColor(){var t=this.run;return this._colorScaleFunction(t)}connectedCallback(){super.connectedCallback(),this._dataProvider=new IP(this.requestManager);let t=new F6(this._runColor);t.addEventListener("beforeUpdateScene",this._updateCanvasSize.bind(this)),t.addEventListener("cameraPositionChange",this._onCameraPositionChange.bind(this)),this._meshViewer=t}reload(){!this.active||!this._dataProvider||(this._isMeshLoading=!0,this._dataProvider.reload(this.run,this.tag,this.sample).then(t=>{!t||(this._steps=t,this._stepIndex=t.length-1)}).catch(t=>{if(!t||!t.code||t.code!=d1.CANCELLED)throw t=t||"Response processing failed.",new Error(t)}))}_updateScene(){var r;let t=this._currentStep;!t||!t.mesh||(this._meshViewer.updateScene(t,this),this._cameraPositionInitialized||(this._meshViewer.resetView(),this._cameraPositionInitialized=!0),this._meshViewerAttached||((r=this.shadowRoot)==null||r.appendChild(this._meshViewer.getRenderer().domElement),this._meshViewerAttached=!0))}_debouncedFetchMesh(){this.debounce("fetchMesh",()=>this._maybeFetchMesh(),100)}_maybeFetchMesh(){return Ri(this,null,function*(){let t=this._currentStep;if(!(!t||t.mesh||t.meshFetching)){t.meshFetching=!0,this._isMeshLoading=!0;try{let r=yield this._dataProvider.fetchData(t,this.run,this.tag,this.sample);t.mesh=r[0],this.notifyPath("_currentStep.mesh")}catch(r){if(!r||!r.code||r.code!=d1.CANCELLED)throw r=r||"Response processing failed.",new Error(r)}finally{this._isMeshLoading=!1,t.meshFetching=!1}}})}_onCameraPositionChange(){if(!this._meshViewer.isReady())return;let t=new CustomEvent("camera-position-change",{detail:this._meshViewer.getCameraPosition()});this.dispatchEvent(t)}setCameraViewpoint(t,r,n){this._meshViewer.setCameraViewpoint(t,r,n)}_updateCanvasSize(){let t=this.offsetWidth,r=t,n=this.$$(".tf-mesh-loader-header").offsetHeight,i={width:t,height:r-n};this._meshViewer.setCanvasSize(i)}redraw(){this._updateCanvasSize(),this.isConnected&&this._meshViewer.draw()}_hasAtLeastOneStep(t){return!!t&&t.length>0}_hasMultipleSteps(t){return!!t&&t.length>1}get _currentStep(){var t=this._steps,r=this._stepIndex;return t[r]||null}get _stepValue(){let t=this._currentStep;return t?t.step:0}get _currentWallTime(){let t=this._currentStep;return t?s2(t.wall_time):""}_getMaxStepIndex(t){return t.length-1}_getSampleText(t){return String(t+1)}_hasMultipleSamples(t){return t>1}_updateView(){var t=this.selectedView;this._meshViewer&&t=="all"&&this._meshViewer.resetView()}toLocaleString_(t){return t.toLocaleString()}};Ln.template=Q`
    <tf-card-heading color="[[_runColor]]" class="tf-mesh-loader-header">
      <template is="dom-if" if="[[_hasMultipleSamples(ofSamples)]]">
        <div>sample: [[_getSampleText(sample)]] of [[ofSamples]]</div>
      </template>
      <template is="dom-if" if="[[_hasAtLeastOneStep(_steps)]]">
        <div class="heading-row">
          <div class="heading-label">
            step
            <span style="font-weight: bold"
              >[[toLocaleString_(_stepValue)]]</span
            >
          </div>
          <div class="heading-label heading-right">
            <template is="dom-if" if="[[_currentWallTime]]">
              [[_currentWallTime]]
            </template>
          </div>
          <div class="label right">
            <paper-spinner-lite active hidden$="[[!_isMeshLoading]]">
            </paper-spinner-lite>
          </div>
        </div>
      </template>
      <template is="dom-if" if="[[_hasMultipleSteps(_steps)]]">
        <div>
          <paper-slider
            id="steps"
            immediate-value="{{_stepIndex}}"
            max="[[_getMaxStepIndex(_steps)]]"
            max-markers="[[_getMaxStepIndex(_steps)]]"
            snaps
            step="1"
            value="{{_stepIndex}}"
          ></paper-slider>
        </div>
      </template>
    </tf-card-heading>
    <style>
      paper-slider {
        width: 100%;
        margin-left: 1px;
        margin-right: 1px;
      }
      .tf-mesh-loader-header {
        display: block;
        height: 105px;
      }
      [hidden] {
        display: none;
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],Ln.prototype,"run",void 0);E([A({type:String}),w("design:type",String)],Ln.prototype,"tag",void 0);E([A({type:Number}),w("design:type",Number)],Ln.prototype,"sample",void 0);E([A({type:Number}),w("design:type",Number)],Ln.prototype,"ofSamples",void 0);E([A({type:String}),w("design:type",String)],Ln.prototype,"selectedView",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Ln.prototype,"active",void 0);E([A({type:Object}),w("design:type",Ae)],Ln.prototype,"requestManager",void 0);E([A({type:Object}),w("design:type",F6)],Ln.prototype,"_meshViewer",void 0);E([A({type:Object}),w("design:type",IP)],Ln.prototype,"_dataProvider",void 0);E([A({type:Object}),w("design:type",Object)],Ln.prototype,"_colorScaleFunction",void 0);E([A({type:Array,notify:!0}),w("design:type",Array)],Ln.prototype,"_steps",void 0);E([A({type:Number,notify:!0}),w("design:type",Number)],Ln.prototype,"_stepIndex",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Ln.prototype,"_meshViewerAttached",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Ln.prototype,"_cameraPositionInitialized",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Ln.prototype,"_isMeshLoading",void 0);E([Rt("run"),w("design:type",String),w("design:paramtypes",[])],Ln.prototype,"_runColor",null);E([Bt("run","tag","active","_dataProvider","_meshViewer"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Ln.prototype,"reload",null);E([Bt("_currentStep.*","_meshViewer"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Ln.prototype,"_updateScene",null);E([Bt("_currentStep"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Ln.prototype,"_debouncedFetchMesh",null);E([Rt("_steps","_stepIndex"),w("design:type",Object),w("design:paramtypes",[])],Ln.prototype,"_currentStep",null);E([Rt("_currentStep"),w("design:type",Number),w("design:paramtypes",[])],Ln.prototype,"_stepValue",null);E([Rt("_currentStep"),w("design:type",String),w("design:paramtypes",[])],Ln.prototype,"_currentWallTime",null);E([Bt("selectedView"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Ln.prototype,"_updateView",null);Ln=E([yt("tf-mesh-loader")],Ln);var ph=class extends mt{constructor(){super(),this.reloadOnReady=!0,this._tagFilter=".*",this._selectedView="all",this._requestManager=new Ae,window.addEventListener("resize",()=>{this._handleWindowResize()},!1),this.reloadOnReady&&this.reload()}_getAllChildren(){var t;return Array.from((t=this.shadowRoot)==null?void 0:t.querySelectorAll("tf-mesh-loader"))}_onCameraPositionChanged(t){this._selectedView=="share"&&this._getAllChildren().forEach(r=>{t.target!=r&&r.setCameraViewpoint(t.detail.position,t.detail.far,t.detail.target)})}_shouldOpen(t){return t<=2}reload(){this._fetchTags().then(this._reloadMeshes.bind(this))}_handleWindowResize(){this._getAllChildren().forEach(t=>{t.redraw()})}_fetchTags(){let t=_e().pluginRoute("mesh","/tags");return this._requestManager.request(t).then(r=>{if(sx.isEqual(r,this._runToTagInfo))return;let n=sx.mapValues(r,o=>Object.keys(o)),i=$i(n);this._dataNotFound=i.length===0,this._runToTagInfo=r})}_reloadMeshes(){this._getAllChildren().forEach(t=>{t.reload()})}get _categories(){var t=this._runToTagInfo,r=this._selectedRuns,n=this._tagFilter;let i=sx.mapValues(t,l=>Object.keys(l)),o=Ql(i,r,n);function a(l){let c=t[l.run][l.tag].samples;return sx.range(c).map(u=>Object.assign({},l,{sample:u,ofSamples:c}))}return o.map(l=>Object.assign({},l,{items:[].concat.apply([],l.items.map(a))}))}};ph.template=Q`
    <tf-dashboard-layout>
      <div slot="sidebar" class="all-controls">
        <div class="settings">
          <div class="sidebar-section view-control">
            <h3 class="title">Point of view</h3>
            <div>
              <paper-radio-group
                id="view-radio-group"
                selected="{{_selectedView}}"
              >
                <paper-radio-button id="all-radio-button" name="all">
                  Display all points
                </paper-radio-button>
                <paper-tooltip
                  animation-delay="0"
                  for="all-radio-button"
                  position="right"
                  offset="0"
                >
                  Zoom and center camera to display all points at once. Note,
                  that some points could be too far (i.e. too small) to be
                  visible.
                </paper-tooltip>
                <paper-radio-button id="user-radio-button" name="user">
                  Current view
                </paper-radio-button>
                <paper-tooltip
                  animation-delay="0"
                  for="user-radio-button"
                  position="right"
                  offset="0"
                >
                  Keep current camera position and zoom level.
                </paper-tooltip>
                <paper-radio-button id="share-radio-button" name="share">
                  Share viewpoint
                </paper-radio-button>
                <paper-tooltip
                  animation-delay="0"
                  for="share-radio-button"
                  position="right"
                  offset="0"
                >
                  Share viewpoint among all cameras.
                </paper-tooltip>
              </paper-radio-group>
            </div>
          </div>
        </div>
        <div class="sidebar-section runs-selector">
          <tf-runs-selector selected-runs="{{_selectedRuns}}">
          </tf-runs-selector>
        </div>
      </div>
      <div slot="center">
        <template is="dom-if" if="[[_dataNotFound]]">
          <div class="no-data-warning">
            <h3>No point cloud data was found.</h3>
            <p>Probable causes:</p>
            <ul>
              <li>
                You haven’t written any point cloud data to your event files.
              </li>
              <li>TensorBoard can’t find your event files.</li>
            </ul>

            <p>
              If you’re new to using TensorBoard, and want to find out how to
              add data and set up your event files, check out the
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
                >README</a
              >
              and perhaps the
              <a
                href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
                >TensorBoard tutorial</a
              >.
            </p>

            <p>
              If you think TensorBoard is configured properly, please see
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"
                >the section of the README devoted to missing data problems</a
              >
              and consider filing an issue on GitHub.
            </p>
          </div>
        </template>
        <template is="dom-if" if="[[!_dataNotFound]]">
          <tf-tag-filterer tag-filter="{{_tagFilter}}"></tf-tag-filterer>
          <template is="dom-repeat" items="[[_categories]]" as="category">
            <tf-category-paginated-view
              category="[[category]]"
              initial-opened="[[_shouldOpen(index)]]"
            >
              <template>
                <tf-mesh-loader
                  active="[[active]]"
                  selected-view="[[_selectedView]]"
                  run="[[item.run]]"
                  tag="[[item.tag]]"
                  sample="[[item.sample]]"
                  of-samples="[[item.ofSamples]]"
                  request-manager="[[_requestManager]]"
                  class="tf-mesh-loader-container"
                  on-camera-position-change="_onCameraPositionChanged"
                >
                </tf-mesh-loader>
              </template>
            </tf-category-paginated-view>
          </template>
        </template>
      </div>
    </tf-dashboard-layout>

    <style include="dashboard-style"></style>
    <style>
      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }
      paper-radio-button {
        display: block;
        padding: 5px;
      }
      .sidebar-section h3 {
        margin: 0;
        font-weight: normal;
        font-size: 14px;
        margin-bottom: 5px;
      }

      .runs-selector {
        flex-grow: 1;
      }

      tf-runs-selector {
        display: flex;
      }

      .view-control {
        display: block !important;
      }

      .view-control h3.title {
        padding-top: 16px;
        padding-bottom: 16px;
      }

      .allcontrols .view-control paper-radio-group {
        margin-top: 5px;
      }
      /* Layout must be horizontal, i.e. items arranged in a row. If items cannot fit in a row,
       * they should be moved to next line. All items must be square at all times. Minimum size of
       * the item is 480px. This means that maximum size of the item must be 480px + 479px = 959px.
       * */
      .horizontal {
        display: flex;
        flex-direction: row;
        flex-wrap: wrap;
      }
      tf-mesh-loader {
        width: 480px;
        flex-basis: 480px;
        flex-grow: 1;
        display: block;
      }
    </style>
  `;E([A({type:Boolean}),w("design:type",Boolean)],ph.prototype,"reloadOnReady",void 0);E([A({type:Array}),w("design:type",Array)],ph.prototype,"_selectedRuns",void 0);E([A({type:Object}),w("design:type",Object)],ph.prototype,"_runToTagInfo",void 0);E([A({type:Boolean}),w("design:type",Boolean)],ph.prototype,"_dataNotFound",void 0);E([A({type:String}),w("design:type",String)],ph.prototype,"_tagFilter",void 0);E([A({type:String,notify:!0}),w("design:type",String)],ph.prototype,"_selectedView",void 0);E([A({type:Object}),w("design:type",Object)],ph.prototype,"_requestManager",void 0);E([Rt("_runToTagInfo","_selectedRuns","_tagFilter"),w("design:type",Array),w("design:paramtypes",[])],ph.prototype,"_categories",null);ph=E([yt("mesh-dashboard"),w("design:paramtypes",[])],ph);var QU=class extends Gt(mt){constructor(){super(...arguments),this._installCommand="pip install -U tensorboard-plugin-profile"}_copyInstallCommand(){return Ri(this,null,function*(){let t=()=>Ri(this,null,function*(){this.$.commandTextarea.select();try{yield navigator.clipboard.writeText(this._installCommand)}catch(i){if(!document.execCommand("copy"))return Promise.reject()}}),r=this.$.copiedMessage;try{yield t(),r.innerText="Copied."}catch(n){r.innerText="Failed to copy to clipboard."}})}_removeCopiedMessage(){let t=this.$.copiedMessage;t.innerText=""}};QU.template=Q`
    <div class="message">
      <h3>The profile plugin has moved.</h3>
      <p>
        Please install the new version of the profile plugin from PyPI by
        running the following command from the machine running TensorBoard:
      </p>
      <textarea
        id="commandTextarea"
        readonly=""
        rows="1"
        on-blur="_removeCopiedMessage"
      >
[[_installCommand]]</textarea
      >
      <div id="copyContainer">
        <span id="copiedMessage"></span>
        <paper-button raised="" on-tap="_copyInstallCommand"
          >Copy to clipboard</paper-button
        >
      </div>
    </div>

    <style>
      :host {
        display: flex;
      }

      .message {
        margin: 80px auto 0 auto;
        max-width: 540px;
      }
      #commandTextarea {
        margin-top: 1ex;
        padding: 1ex 1em;
        resize: vertical;
        width: 100%;
      }
      #copyContainer {
        display: flex;
      }
      #copiedMessage {
        align-self: center;
        flex-grow: 1;
        font-style: italic;
        padding-right: 1em;
        text-align: right;
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],QU.prototype,"_installCommand",void 0);QU=E([yt("tf-profile-redirect-dashboard")],QU);var lm=Ee(Oe(),1);var zl=Ee(Oe(),1),tq=Ee(wl(),1);var nn=class extends mt{constructor(){super(...arguments),this._expanded=!1,this._runToPrCurveEntry={},this._previousRunToPrCurveEntry={},this._colorScaleFunction={scale:fn},this._canceller=new an,this._xComponentsCreationMethod=()=>{let t=new tq.Scales.Linear;return{scale:t,axis:new tq.Axes.Numeric(t,"bottom"),accessor:r=>r.recall}},this._yValueAccessor=t=>t.precision,this._tooltipColumns=(()=>{let t=Wu(e0),r=n=>isNaN(n)?"NaN":t(n);return[{title:"Run",evaluate:n=>n.dataset.metadata().name},{title:"Threshold",evaluate:n=>r(n.datum.thresholds)},{title:"Precision",evaluate:n=>r(n.datum.precision)},{title:"Recall",evaluate:n=>r(n.datum.recall)},{title:"TP",evaluate:n=>n.datum.true_positives},{title:"FP",evaluate:n=>n.datum.false_positives},{title:"TN",evaluate:n=>n.datum.true_negatives},{title:"FN",evaluate:n=>n.datum.false_negatives}]})(),this._seriesDataFields=["thresholds","precision","recall","true_positives","false_positives","true_negatives","false_negatives"],this._defaultXRange=[-.05,1.05],this._defaultYRange=[-.05,1.05],this._requestData=(t,r,n)=>{let o=_e().pluginRoute("pr_curves","/pr_curves");Promise.all(t.map(a=>{let s=a,l=this.tag,c=Mi(o,{tag:l,run:s});return this.requestManager.request(c).then(u=>void r({item:a,data:u}))})).finally(()=>void n())},this._smoothingEnabled=!1}_createProcessDataFunction(){return(t,r,n)=>{this.set("_runToDataOverTime",Object.assign({},this._runToDataOverTime,n))}}_computeRunColor(t){return fn(t)}connectedCallback(){super.connectedCallback(),this._attached=!0,this.reload()}_getChartDataLoader(){var t;return(t=this.shadowRoot)==null?void 0:t.querySelector("tf-line-chart-data-loader")}reload(){if(!!this._attached){if(this.runs.length===0){this.set("_runToDataOverTime",{});return}this._getChartDataLoader().reload()}}_setChartData(){var t=this._runToPrCurveEntry,r=this._previousRunToPrCurveEntry,n=this._setOfRelevantRuns;zl.forOwn(t,(i,o)=>{let a=r[o];if(!(a&&t[o].step===a.step)){if(!n[o]){this._clearSeriesData(o);return}this._updateSeriesDataForRun(o,i)}})}_updateSeriesDataForRun(t,r){let n=zl.reduce(this._seriesDataFields,(a,s)=>(a[s]=r[s].slice().reverse(),a),{}),i=new Array(n[this._seriesDataFields[0]].length);for(let a=0;a<i.length;a++)i[a]=zl.mapValues(n,s=>s[a]);let o=this._getChartDataLoader();o.setSeriesData(t,i),o.commitChanges()}_clearSeriesData(t){let r=this._getChartDataLoader();r.setSeriesData(t,[]),r.commitChanges()}_updateRunToPrCurveEntry(){var t=this._runToDataOverTime,r=this.runToStepCap;let n={};zl.forOwn(t,(i,o)=>{!i||!i.length||(n[o]=this._computeEntryClosestOrEqualToStepCap(r[o],i))}),this.set("_previousRunToPrCurveEntry",this._runToPrCurveEntry),this.set("_runToPrCurveEntry",n)}_notifyDataChange(){var t=this._runToDataOverTime;this.onDataChange&&this.onDataChange(t)}_computeEntryClosestOrEqualToStepCap(t,r){let n=Math.min(zl.sortedIndex(r.map(i=>i.step),t),r.length-1);return r[n]}get _runsWithStepAvailable(){var t=this.runs,r=this._runToPrCurveEntry;return zl.filter(t,n=>r[n]).sort()}get _setOfRelevantRuns(){var t=this._runsWithStepAvailable;let r={};return zl.forEach(t,n=>{r[n]=!0}),r}_computeCurrentStepForRun(t,r){let n=t[r];return n?n.step:null}_computeCurrentWallTimeForRun(t,r){let n=t[r];return n?new Date(n.wall_time*1e3).toString():null}_toggleExpanded(t){this.set("_expanded",!this._expanded),this.redraw()}_resetDomain(){this._getChartDataLoader().resetDomain()}redraw(){this._getChartDataLoader().redraw()}};nn.template=Q`
    <tf-card-heading
      tag="[[tag]]"
      display-name="[[tagMetadata.displayName]]"
      description="[[tagMetadata.description]]"
    ></tf-card-heading>

    <tf-line-chart-data-loader
      x-components-creation-method="[[_xComponentsCreationMethod]]"
      y-value-accessor="[[_yValueAccessor]]"
      tooltip-columns="[[_tooltipColumns]]"
      color-scale="[[_colorScaleFunction]]"
      default-x-range="[[_defaultXRange]]"
      default-y-range="[[_defaultYRange]]"
      smoothing-enabled="[[_smoothingEnabled]]"
      request-manager="[[requestManager]]"
      data-to-load="[[runs]]"
      data-series="[[runs]]"
      load-key="[[tag]]"
      request-data="[[_requestData]]"
      load-data-callback="[[_createProcessDataFunction()]]"
      active="[[active]]"
    ></tf-line-chart-data-loader>

    <div id="buttons-row">
      <paper-icon-button
        selected$="[[_expanded]]"
        icon="fullscreen"
        on-tap="_toggleExpanded"
      ></paper-icon-button>
      <paper-icon-button
        icon="settings-overscan"
        on-tap="_resetDomain"
        title="Reset axes to [0, 1]."
      ></paper-icon-button>
    </div>

    <div id="step-legend">
      <template is="dom-repeat" items="[[_runsWithStepAvailable]]" as="run">
        <div class="legend-row">
          <div
            class="color-box"
            style="background: [[_computeRunColor(run)]];"
          ></div>
          [[run]] is at
          <span class="step-label-text">
            step [[_computeCurrentStepForRun(_runToPrCurveEntry, run)]] </span
          ><br />
          <span class="wall-time-label-text">
            ([[_computeCurrentWallTimeForRun(_runToPrCurveEntry, run)]])
          </span>
        </div>
      </template>
    </div>

    <style>
      :host {
        display: flex;
        flex-direction: column;
        width: 500px;
        margin-right: 10px;
        margin-bottom: 25px;
      }
      :host([_expanded]) {
        width: 100%;
      }
      tf-line-chart-data-loader {
        height: 300px;
        position: relative;
      }
      :host([_expanded]) tf-line-chart-data-loader {
        height: 600px;
      }
      #buttons-row {
        display: flex;
        flex-direction: row;
      }
      #buttons-row paper-icon-button {
        color: #2196f3;
        border-radius: 100%;
        width: 32px;
        height: 32px;
        padding: 4px;
      }
      #buttons-row paper-icon-button[selected] {
        background: var(--tb-ui-light-accent);
      }
      #step-legend {
        box-sizing: border-box;
        font-size: 0.8em;
        max-height: 200px;
        overflow-y: auto;
        padding: 0 0 0 10px;
        width: 100%;
      }
      .legend-row {
        margin: 5px 0 5px 0;
        width: 100%;
      }
      .color-box {
        display: inline-block;
        border-radius: 1px;
        width: 10px;
        height: 10px;
      }
      .step-label-text {
        font-weight: bold;
      }
      .wall-time-label-text {
        color: #888;
        font-size: 0.8em;
      }
    </style>
  `;E([A({type:Array}),w("design:type",Array)],nn.prototype,"runs",void 0);E([A({type:String}),w("design:type",String)],nn.prototype,"tag",void 0);E([A({type:Object}),w("design:type",Object)],nn.prototype,"tagMetadata",void 0);E([A({type:Object}),w("design:type",Object)],nn.prototype,"runToStepCap",void 0);E([A({type:Object}),w("design:type",Ae)],nn.prototype,"requestManager",void 0);E([A({type:Boolean}),w("design:type",Boolean)],nn.prototype,"active",void 0);E([A({type:Boolean,reflectToAttribute:!0}),w("design:type",Boolean)],nn.prototype,"_expanded",void 0);E([A({type:Object}),w("design:type",Object)],nn.prototype,"_runToPrCurveEntry",void 0);E([A({type:Object}),w("design:type",Object)],nn.prototype,"_previousRunToPrCurveEntry",void 0);E([A({type:Object}),w("design:type",Object)],nn.prototype,"_runToDataOverTime",void 0);E([A({type:Object}),w("design:type",Function)],nn.prototype,"onDataChange",void 0);E([A({type:Object}),w("design:type",Object)],nn.prototype,"_colorScaleFunction",void 0);E([A({type:Object}),w("design:type",an)],nn.prototype,"_canceller",void 0);E([A({type:Boolean}),w("design:type",Boolean)],nn.prototype,"_attached",void 0);E([A({type:Object}),w("design:type",Object)],nn.prototype,"_xComponentsCreationMethod",void 0);E([A({type:Object}),w("design:type",Object)],nn.prototype,"_yValueAccessor",void 0);E([A({type:Array}),w("design:type",Array)],nn.prototype,"_tooltipColumns",void 0);E([A({type:Array}),w("design:type",Array)],nn.prototype,"_seriesDataFields",void 0);E([A({type:Array}),w("design:type",Array)],nn.prototype,"_defaultXRange",void 0);E([A({type:Array}),w("design:type",Array)],nn.prototype,"_defaultYRange",void 0);E([A({type:Object}),w("design:type",Function)],nn.prototype,"_requestData",void 0);E([A({type:Boolean}),w("design:type",Boolean)],nn.prototype,"_smoothingEnabled",void 0);E([Bt("runs","tag"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],nn.prototype,"reload",null);E([Bt("_runToPrCurveEntry","_previousRunToPrCurveEntry","_setOfRelevantRuns"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],nn.prototype,"_setChartData",null);E([Bt("_runToDataOverTime","runToStepCap"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],nn.prototype,"_updateRunToPrCurveEntry",null);E([Bt("_runToDataOverTime"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],nn.prototype,"_notifyDataChange",null);E([Rt("runs","_runToPrCurveEntry"),w("design:type",Array),w("design:paramtypes",[])],nn.prototype,"_runsWithStepAvailable",null);E([Rt("_runsWithStepAvailable"),w("design:type",Object),w("design:paramtypes",[])],nn.prototype,"_setOfRelevantRuns",null);nn=E([yt("tf-pr-curve-card")],nn);var SM=Ee(Oe(),1);var ep=class extends mt{constructor(){super(...arguments),this._runToStepIndex={}}_computeColorForRun(t){return fn(t)}_computeTimeTextForRun(t,r,n,i){let o=r[n];if(!SM.isNumber(o))return"";let a=t[n];if(!a)return"";let s=a[o][i];if(i==="step")return`step ${s}`;if(i==="relative")return s<1?`${(s*1e3).toFixed(2)} ms`:`${s.toFixed(2)} s`;if(i==="wall_time")return new Date(s*1e3).toString();throw new Error(`The display type of ${i} is not recognized.`)}_sliderValueChanged(t){let r=t.target.dataset.run,n=t.target.immediateValue,i=Object.assign({},this._runToStepIndex);isNaN(n)?delete i[r]:i[r]=t.target.immediateValue,this._runToStepIndex=i}_computeMaxStepIndexForRun(t,r){let n=t[r];return n&&n.length?n.length-1:0}_updateStepsForNewRuns(){var t=this.runToAvailableTimeEntries;let r=Object.assign({},this._runToStepIndex);SM.forOwn(t,(n,i)=>{SM.isNumber(r[i])||(r[i]=n.length-1)}),this._runToStepIndex=r}_getStep(t,r){return this._runToStepIndex?this._runToStepIndex[r]:0}_computeRunToStep(t,r){let n={};return SM.forOwn(r,(i,o)=>{let a=t[o];!a||(n[o]=a[i].step)}),n}get _runsWithSliders(){var t=this.runs,r=this.runToAvailableTimeEntries;return t.filter(n=>r[n])}};ep.template=Q`
    <template is="dom-repeat" items="[[_runsWithSliders]]" as="run">
      <div class="run-widget">
        <div class="run-display-container">
          <div
            class="run-color-box"
            style="background:[[_computeColorForRun(run)]];"
          ></div>
          <div class="run-text">[[run]]</div>
        </div>
        <div class="step-display-container">
          [[_computeTimeTextForRun(runToAvailableTimeEntries, _runToStepIndex,
          run, timeDisplayType)]]
        </div>
        <paper-slider
          data-run$="[[run]]"
          step="1"
          type="number"
          min="0"
          max="[[_computeMaxStepIndexForRun(runToAvailableTimeEntries, run)]]"
          value="[[_getStep(_runToStepIndex, run)]]"
          on-immediate-value-changed="_sliderValueChanged"
        ></paper-slider>
      </div>
    </template>
    <style>
      .run-widget {
        margin: 10px 0 0 0;
      }
      paper-slider {
        margin: -8px 0 0 -15px;
        width: 100%;
      }
      .step-display-container {
        font-size: 0.9em;
        margin: 0 15px 0 0;
      }
      .run-text {
        display: inline-block;
      }
      .run-color-box {
        width: 12px;
        height: 12px;
        border-radius: 3px;
        display: inline-block;
      }
    </style>
  `;E([A({type:Array}),w("design:type",Array)],ep.prototype,"runs",void 0);E([A({type:Object}),w("design:type",Object)],ep.prototype,"runToAvailableTimeEntries",void 0);E([A({type:Object,notify:!0,computed:"_computeRunToStep(runToAvailableTimeEntries, _runToStepIndex)"}),w("design:type",Object)],ep.prototype,"runToStep",void 0);E([A({type:String}),w("design:type",String)],ep.prototype,"timeDisplayType",void 0);E([A({type:Object}),w("design:type",Object)],ep.prototype,"_runToStepIndex",void 0);E([Bt("runToAvailableTimeEntries"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],ep.prototype,"_updateStepsForNewRuns",null);E([Rt("runs","runToAvailableTimeEntries"),w("design:type",Array),w("design:paramtypes",[])],ep.prototype,"_runsWithSliders",null);ep=E([yt("tf-pr-curve-steps-selector")],ep);var ko=class extends Gt(mt){constructor(){super(...arguments),this.reloadOnReady=!0,this._timeDisplayType="step",this._selectedRuns=[],this._runToTagInfo={},this._tagToRunToData={},this._getCategoryItemKey=t=>t.tag,this._requestManager=new Ae,this._step=0}ready(){super.ready(),this.reloadOnReady&&this.reload()}reload(){Promise.all([this._fetchTags()]).then(()=>{this._reloadCards()})}_shouldOpen(t){return t<=2}_fetchTags(){let t=_e().pluginRoute("pr_curves","/tags");return this._requestManager.request(t).then(r=>{if(lm.isEqual(r,this._runToTagInfo))return;let n=lm.mapValues(r,o=>lm.keys(o)),i=$i(n);this.set("_dataNotFound",i.length===0),this.set("_runToTagInfo",r),this.async(()=>{this.set("_categoriesDomReady",!0)})})}_reloadCards(){var t;lm.forEach((t=this.root)==null?void 0:t.querySelectorAll("tf-pr-curve-card"),r=>{r.reload()})}get _categories(){var t=this._runToTagInfo,r=this._selectedRuns,n=this._tagFilter;let i=lm.mapValues(t,o=>Object.keys(o));return hE(i,r,n)}get _relevantSelectedRuns(){var t=this._selectedRuns,r=this._runToTagInfo;return t.filter(n=>r[n])}_tagMetadata(t,r,n){let i={};r.forEach(a=>{i[a]=t[a][n]});let o=n.replace(/\/pr_curves$/,"");return oR(i,o)}_createDataChangeCallback(t){return r=>{this.set("_tagToRunToData",Mx(Kl({},this._tagToRunToData),{[t]:r}))}}get _runToAvailableTimeEntries(){var t=this._tagToRunToData;let r={};for(let[i,o]of Object.entries(t))for(let[a]of Object.entries(o))(r[a]==null||i<r[a])&&(r[a]=i);let n={};for(let[i,o]of Object.entries(r)){let a=t[o][i];n[i]=a.map(s=>({step:s.step,wall_time:s.wall_time,relative:s.wall_time-a[0].wall_time}))}return n}};ko.template=Q`
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <div class="settings">
          <div class="sidebar-section">
            <tf-option-selector
              id="time-type-selector"
              name="Time Display Type"
              selected-id="{{_timeDisplayType}}"
            >
              <paper-button id="step">step</paper-button>
              <!--
            -->
              <paper-button id="relative">relative</paper-button>
              <!--
            -->
              <paper-button id="wall_time">wall</paper-button>
            </tf-option-selector>
          </div>
          <template is="dom-if" if="[[_runToAvailableTimeEntries]]">
            <div class="sidebar-section" id="steps-selector-container">
              <tf-pr-curve-steps-selector
                runs="[[_relevantSelectedRuns]]"
                run-to-step="{{_runToStep}}"
                run-to-available-time-entries="[[_runToAvailableTimeEntries]]"
                time-display-type="[[_timeDisplayType]]"
              >
              </tf-pr-curve-steps-selector>
            </div>
          </template>
        </div>
        <div class="sidebar-section runs-selector">
          <tf-runs-selector selected-runs="{{_selectedRuns}}">
          </tf-runs-selector>
        </div>
      </div>
      <div class="center" slot="center">
        <template is="dom-if" if="[[_dataNotFound]]">
          <div class="no-data-warning">
            <h3>No precision–recall curve data was found.</h3>
            <p>Probable causes:</p>
            <ul>
              <li>
                You haven’t written any precision–recall data to your event
                files.
              </li>
              <li>TensorBoard can’t find your event files.</li>
            </ul>
            <p>
              If you’re new to using TensorBoard, and want to find out how to
              add data and set up your event files, check out the
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
                >README</a
              >
              and perhaps the
              <a
                href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
                >TensorBoard tutorial</a
              >.
            </p>

            <p>
              If you think TensorBoard is configured properly, please see
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"
                >the section of the README devoted to missing data problems</a
              >
              and consider filing an issue on GitHub.
            </p>
          </div>
        </template>
        <template is="dom-if" if="[[!_dataNotFound]]">
          <tf-tag-filterer tag-filter="{{_tagFilter}}"></tf-tag-filterer>
          <template is="dom-repeat" items="[[_categories]]" as="category">
            <tf-category-paginated-view
              category="[[category]]"
              initial-opened="[[_shouldOpen(index)]]"
              get-category-item-key="[[_getCategoryItemKey]]"
            >
              <template>
                <tf-pr-curve-card
                  active="[[active]]"
                  runs="[[item.runs]]"
                  tag="[[item.tag]]"
                  tag-metadata="[[_tagMetadata(_runToTagInfo, item.runs, item.tag)]]"
                  request-manager="[[_requestManager]]"
                  run-to-step-cap="[[_runToStep]]"
                  on-data-change="[[_createDataChangeCallback(item.tag)]]"
                ></tf-pr-curve-card>
              </template>
            </tf-category-paginated-view>
          </template>
        </template>
      </div>
    </tf-dashboard-layout>

    <style include="dashboard-style"></style>
    <style>
      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }

      /** Do not let the steps selector occlude the run selector. */
      #steps-selector-container {
        max-height: 60%;
        overflow-y: auto;
      }
    </style>
  `;E([A({type:Boolean}),w("design:type",Boolean)],ko.prototype,"reloadOnReady",void 0);E([A({type:String}),w("design:type",String)],ko.prototype,"_timeDisplayType",void 0);E([A({type:Array}),w("design:type",Array)],ko.prototype,"_selectedRuns",void 0);E([A({type:Object}),w("design:type",Object)],ko.prototype,"_runToTagInfo",void 0);E([A({type:Object}),w("design:type",Object)],ko.prototype,"_tagToRunToData",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],ko.prototype,"_runToStep",void 0);E([A({type:Boolean}),w("design:type",Boolean)],ko.prototype,"_dataNotFound",void 0);E([A({type:String}),w("design:type",String)],ko.prototype,"_tagFilter",void 0);E([A({type:Boolean}),w("design:type",Boolean)],ko.prototype,"_categoriesDomReady",void 0);E([A({type:Object}),w("design:type",Object)],ko.prototype,"_getCategoryItemKey",void 0);E([A({type:Object}),w("design:type",Ae)],ko.prototype,"_requestManager",void 0);E([A({type:Number,notify:!0}),w("design:type",Number)],ko.prototype,"_step",void 0);E([Rt("_runToTagInfo","_selectedRuns","_tagFilter","_categoriesDomReady"),w("design:type",Array),w("design:paramtypes",[])],ko.prototype,"_categories",null);E([Rt("_selectedRuns","_runToTagInfo"),w("design:type",Array),w("design:paramtypes",[])],ko.prototype,"_relevantSelectedRuns",null);E([Rt("_tagToRunToData"),w("design:type",Object),w("design:paramtypes",[])],ko.prototype,"_runToAvailableTimeEntries",null);ko=E([yt("tf-pr-curve-dashboard")],ko);var B6=Ee(Oe(),1);var uo=class extends Gt(nb){constructor(){super(...arguments),this.reloadOnReady=!0,this._showDownloadLinks=vp("_showDownloadLinks",{defaultValue:!1,useLocalStorage:!0}).call(this),this._smoothingWeight=_E("_smoothingWeight",{defaultValue:.6}).call(this),this._ignoreYOutliers=vp("_ignoreYOutliers",{defaultValue:!0,useLocalStorage:!0}).call(this),this._xType=Ed.STEP,this._selectedRuns=[],this._tagFilter="",this._categories=[],this._getCategoryItemKey=t=>t.tag,this._requestManager=new Ae(50),this._showDownloadLinksObserver=xp("_showDownloadLinks",{defaultValue:!1,useLocalStorage:!0}),this._smoothingWeightObserver=yE("_smoothingWeight",{defaultValue:.6}),this._ignoreYOutliersObserver=xp("_ignoreYOutliers",{defaultValue:!0,useLocalStorage:!0})}get _smoothingEnabled(){var t=this._smoothingWeight;return t>0}_getCategoryKey(t){return t.metadata.type==Na.SEARCH_RESULTS?"":t.name}_shouldOpen(t){return t<=2}ready(){super.ready(),this.reloadOnReady&&this.reload()}reload(){this._fetchTags().then(()=>{this._reloadCharts()})}_fetchTags(){let t=_e().pluginRoute("scalars","/tags");return this._requestManager.request(t).then(r=>{if(B6.isEqual(r,this._runToTagInfo))return;let n=B6.mapValues(r,o=>Object.keys(o)),i=$i(n);this.set("_dataNotFound",i.length===0),this.set("_runToTagInfo",r),this.async(()=>{this.set("_categoriesDomReady",!0)})})}_reloadCharts(){var t;(t=this.root)==null||t.querySelectorAll("tf-scalar-card").forEach(r=>{r.reload()})}_updateCategories(){var t=this._runToTagInfo,r=this._selectedRuns,n=this._tagFilter;let i,o=n,a=B6.mapValues(t,s=>Object.keys(s));i=hE(a,r,o),i.forEach(s=>{s.items=s.items.map(l=>({tag:l.tag,series:l.runs.map(c=>({run:c,tag:l.tag}))}))}),this.updateArrayProp("_categories",i,this._getCategoryKey)}_tagMetadata(t,r,n){let i=t.name,o=n.tag,a={};n.series.forEach(({run:u})=>{a[u]=r[u][o]});let s=o.replace(/\/scalar_summary$/,""),{description:l,displayName:c}=oR(a,s);return t.metadata.type==Na.PREFIX_GROUP&&c.startsWith(i+"/")&&(c=c.slice(i.length+1)),{description:l,displayName:c}}};uo.template=Q`
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <div class="settings">
          <div class="sidebar-section">
            <div class="line-item">
              <paper-checkbox
                id="show-download-links"
                checked="{{_showDownloadLinks}}"
                >Show data download links</paper-checkbox
              >
            </div>
            <div class="line-item">
              <paper-checkbox
                id="ignore-y-outlier"
                checked="{{_ignoreYOutliers}}"
                >Ignore outliers in chart scaling</paper-checkbox
              >
            </div>
            <div id="tooltip-sorting">
              <div>Tooltip sorting method:</div>
              <paper-dropdown-menu
                no-label-float
                selected-item-label="{{_tooltipSortingMethod}}"
              >
                <paper-listbox
                  class="dropdown-content"
                  selected="0"
                  slot="dropdown-content"
                >
                  <paper-item>default</paper-item>
                  <paper-item>descending</paper-item>
                  <paper-item>ascending</paper-item>
                  <paper-item>nearest</paper-item>
                </paper-listbox>
              </paper-dropdown-menu>
            </div>
          </div>
          <div class="sidebar-section">
            <tf-smoothing-input
              weight="{{_smoothingWeight}}"
              step="0.001"
              min="0"
              max="0.999"
            ></tf-smoothing-input>
          </div>
          <div class="sidebar-section">
            <tf-option-selector
              id="x-type-selector"
              name="Horizontal Axis"
              selected-id="{{_xType}}"
            >
              <paper-button id="step">step</paper-button
              ><!--
            --><paper-button id="relative">relative</paper-button
              ><!--
            --><paper-button id="wall_time">wall</paper-button>
            </tf-option-selector>
          </div>
        </div>
        <div class="sidebar-section runs-selector">
          <tf-runs-selector selected-runs="{{_selectedRuns}}">
          </tf-runs-selector>
        </div>
      </div>
      <div class="center" slot="center">
        <template is="dom-if" if="[[_dataNotFound]]">
          <div class="no-data-warning">
            <h3>No scalar data was found.</h3>
            <p>Probable causes:</p>
            <ul>
              <li>You haven’t written any scalar data to your event files.</li>
              <li>TensorBoard can’t find your event files.</li>
            </ul>

            <p>
              If you’re new to using TensorBoard, and want to find out how to
              add data and set up your event files, check out the
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
                >README</a
              >
              and perhaps the
              <a
                href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
                >TensorBoard tutorial</a
              >.
            </p>

            <p>
              If you think TensorBoard is configured properly, please see
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"
                >the section of the README devoted to missing data problems</a
              >
              and consider filing an issue on GitHub.
            </p>
          </div>
        </template>
        <template is="dom-if" if="[[!_dataNotFound]]">
          <tf-tag-filterer tag-filter="{{_tagFilter}}"></tf-tag-filterer>
          <template is="dom-repeat" items="[[_categories]]" as="category">
            <tf-category-paginated-view
              category="[[category]]"
              initial-opened="[[_shouldOpen(index)]]"
              get-category-item-key="[[_getCategoryItemKey]]"
            >
              <template>
                <tf-scalar-card
                  active="[[active]]"
                  data-to-load="[[item.series]]"
                  ignore-y-outliers="[[_ignoreYOutliers]]"
                  multi-experiments="[[_getMultiExperiments(dataSelection)]]"
                  request-manager="[[_requestManager]]"
                  show-download-links="[[_showDownloadLinks]]"
                  smoothing-enabled="[[_smoothingEnabled]]"
                  smoothing-weight="[[_smoothingWeight]]"
                  tag-metadata="[[_tagMetadata(category, _runToTagInfo, item)]]"
                  tag="[[item.tag]]"
                  tooltip-sorting-method="[[_tooltipSortingMethod]]"
                  x-type="[[_xType]]"
                  batch-size="[[featureFlags.scalarsBatchSize]]"
                  in-colab="[[featureFlags.inColab]]"
                ></tf-scalar-card>
              </template>
            </tf-category-paginated-view>
          </template>
        </template>
      </div>
    </tf-dashboard-layout>

    <style include="dashboard-style"></style>
    <style>
      #tooltip-sorting {
        align-items: center;
        display: flex;
        font-size: 14px;
        margin-top: 15px;
      }

      #tooltip-sorting paper-dropdown-menu {
        margin-left: 10px;
        --paper-input-container-focus-color: var(--tb-orange-strong);
        width: 105px;
      }

      .line-item {
        display: block;
        padding-top: 5px;
      }
      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }
      .center {
        overflow-x: hidden;
      }
    </style>
  `;E([A({type:Boolean}),w("design:type",Boolean)],uo.prototype,"reloadOnReady",void 0);E([A({type:Object}),w("design:type",Object)],uo.prototype,"featureFlags",void 0);E([A({type:Boolean,notify:!0,observer:"_showDownloadLinksObserver"}),w("design:type",Boolean)],uo.prototype,"_showDownloadLinks",void 0);E([A({type:Number,notify:!0,observer:"_smoothingWeightObserver"}),w("design:type",Number)],uo.prototype,"_smoothingWeight",void 0);E([A({type:Boolean,observer:"_ignoreYOutliersObserver"}),w("design:type",Boolean)],uo.prototype,"_ignoreYOutliers",void 0);E([A({type:String}),w("design:type",String)],uo.prototype,"_xType",void 0);E([A({type:Array}),w("design:type",Array)],uo.prototype,"_selectedRuns",void 0);E([A({type:Object}),w("design:type",Object)],uo.prototype,"_runToTagInfo",void 0);E([A({type:Boolean}),w("design:type",Boolean)],uo.prototype,"_dataNotFound",void 0);E([A({type:String}),w("design:type",String)],uo.prototype,"_tagFilter",void 0);E([A({type:Boolean}),w("design:type",Boolean)],uo.prototype,"_categoriesDomReady",void 0);E([A({type:Array}),w("design:type",Array)],uo.prototype,"_categories",void 0);E([A({type:Object}),w("design:type",Object)],uo.prototype,"_getCategoryItemKey",void 0);E([A({type:Object}),w("design:type",Ae)],uo.prototype,"_requestManager",void 0);E([Rt("_smoothingWeight"),w("design:type",Boolean),w("design:paramtypes",[])],uo.prototype,"_smoothingEnabled",null);E([Bt("_runToTagInfo","_selectedRuns","_tagFilter","_categoriesDomReady"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],uo.prototype,"_updateCategories",null);uo=E([yt("tf-scalar-dashboard")],uo);var cpe=Ee(Oe(),1);var dh=class extends Gt(mt){constructor(){super(...arguments),this._texts=[],this._canceller=new an}get _runColor(){var t=this.run;return fn(t)}_changeRunColor(){var t=this._runColor;this.updateStyles({"--tb-text-loader-outline":t})}attached(){this.reload()}reload(){if(!this.isAttached)return;this._canceller.cancelAll();let t=_e(),r=Mi(t.pluginRoute("text","/text"),{tag:this.tag,run:this.run,markdown:this.markdownEnabled?"true":"false"}),n=this._canceller.cancellable(i=>{if(i.cancelled)return;let o=i.value.map(a=>({wall_time:new Date(a.wall_time*1e3),step:a.step,text:a.text}));this.set("_texts",o.slice().reverse())});this.requestManager.request(r).then(n)}_formatStep(t){return xn(",")(t)}};dh.template=Q`
    <tf-card-heading run="[[run]]" tag="[[tag]]" color="[[_runColor]]">
    </tf-card-heading>
    <paper-material
      elevation="1"
      id="steps-container"
      class="container scrollbar"
    >
      <template is="dom-repeat" items="[[_texts]]">
        <paper-material elevation="1" class="step-container">
          step <span class="step-value">[[_formatStep(item.step)]]</span>
        </paper-material>
        <paper-material elevation="1" class="text">
          <tf-markdown-view html="[[item.text]]"></tf-markdown-view>
        </paper-material>
      </template>
    </paper-material>
    <style include="scrollbar-style"></style>
    <style>
      :host {
        display: flex;
        flex-direction: column;
        width: 100%;
        height: auto;
        margin-right: 10px;
        margin-bottom: 15px;
      }
      .scrollbar {
        will-change: transform;
      }
      #steps-container {
        border-radius: 3px;
        border: 2px solid /* color computed and set as inline style */;
        display: block;
        max-height: 500px;
        overflow: auto;
        padding: 10px;
        border-color: var(--tb-text-loader-outline);
      }
      .text {
        background-color: inherit;
        border-radius: 0 3px 3px 3px;
        padding: 5px;
        word-break: break-word;
      }
      .step-container {
        background-color: var(--tb-ui-light-accent);
        border-bottom: none;
        border-radius: 3px 3px 0 0;
        border: 1px solid var(--tb-ui-border);
        display: inline-block;
        font-size: 12px;
        font-style: italic;
        margin-left: -1px; /* to correct for border */
        padding: 3px;
      }
      .step-container:not(:first-child) {
        margin-top: 15px;
      }

      tf-card-heading {
        margin-bottom: 10px;
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],dh.prototype,"run",void 0);E([A({type:String}),w("design:type",String)],dh.prototype,"tag",void 0);E([A({type:Boolean}),w("design:type",Boolean)],dh.prototype,"markdownEnabled",void 0);E([A({type:Array}),w("design:type",Array)],dh.prototype,"_texts",void 0);E([A({type:Object}),w("design:type",Ae)],dh.prototype,"requestManager",void 0);E([A({type:Object}),w("design:type",an)],dh.prototype,"_canceller",void 0);E([Rt("run"),w("design:type",String),w("design:paramtypes",[])],dh.prototype,"_runColor",null);E([Bt("_runColor"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],dh.prototype,"_changeRunColor",null);dh=E([yt("tf-text-loader")],dh);var Qc=class extends Gt(mt){constructor(){super(...arguments),this.reloadOnReady=!0,this._markdownEnabled=vp("_markdownEnabled",{defaultValue:!0,useLocalStorage:!0}).call(this),this._requestManager=new Ae,this._markdownEnabledStorageObserver=xp("_markdownEnabled",{defaultValue:!0,useLocalStorage:!0})}static get observers(){return["_markdownEnabledObserver(_markdownEnabled)"]}ready(){super.ready(),this.reloadOnReady&&this.reload()}reload(){this._fetchTags().then(()=>{this._reloadTexts()})}_shouldOpen(t){return t<=2}_fetchTags(){let t=_e().pluginRoute("text","/tags");return this._requestManager.request(t).then(r=>{if(cpe.isEqual(r,this._runToTag))return;let n=$i(r);this.set("_dataNotFound",n.length===0),this.set("_runToTag",r),this.async(()=>{this.set("_categoriesDomReady",!0)})})}_reloadTexts(){var t;(t=this.root)==null||t.querySelectorAll("tf-text-loader").forEach(r=>{r.reload()})}get _categories(){var t=this._runToTag,r=this._selectedRuns,n=this._tagFilter;return Ql(t,r,n)}_markdownEnabledObserver(){this._reloadTexts()}};Qc.template=Q`
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <div class="sidebar-section">
          <div class="line-item">
            <paper-checkbox checked="{{_markdownEnabled}}"
              >Enable Markdown</paper-checkbox
            >
          </div>
        </div>
        <div class="sidebar-section runs-selector">
          <tf-runs-selector selected-runs="{{_selectedRuns}}">
          </tf-runs-selector>
        </div>
      </div>
      <div class="center" slot="center">
        <template is="dom-if" if="[[_dataNotFound]]">
          <div class="no-data-warning">
            <h3>No text data was found.</h3>
            <p>Probable causes:</p>
            <ul>
              <li>You haven’t written any text data to your event files.</li>
              <li>TensorBoard can’t find your event files.</li>
            </ul>

            <p>
              If you’re new to using TensorBoard, and want to find out how to
              add data and set up your event files, check out the
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
                >README</a
              >
              and perhaps the
              <a
                href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
                >TensorBoard tutorial</a
              >.
            </p>

            <p>
              If you think TensorBoard is configured properly, please see
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"
                >the section of the README devoted to missing data problems</a
              >
              and consider filing an issue on GitHub.
            </p>
          </div>
        </template>
        <template is="dom-if" if="[[!_dataNotFound]]">
          <tf-tag-filterer tag-filter="{{_tagFilter}}"></tf-tag-filterer>
          <template is="dom-repeat" items="[[_categories]]" as="category">
            <tf-category-paginated-view
              category="[[category]]"
              initial-opened="[[_shouldOpen(index)]]"
            >
              <template>
                <tf-text-loader
                  active="[[active]]"
                  tag="[[item.tag]]"
                  run="[[item.run]]"
                  request-manager="[[_requestManager]]"
                  markdown-enabled="[[_markdownEnabled]]"
                ></tf-text-loader>
              </template>
            </tf-category-paginated-view>
          </template>
        </template>
      </div>
    </tf-dashboard-layout>
    <style include="dashboard-style"></style>
    <style>
      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }
    </style>
  `;E([A({type:Boolean}),w("design:type",Boolean)],Qc.prototype,"reloadOnReady",void 0);E([A({type:Boolean,notify:!0,observer:"_markdownEnabledStorageObserver"}),w("design:type",Boolean)],Qc.prototype,"_markdownEnabled",void 0);E([A({type:Array}),w("design:type",Array)],Qc.prototype,"_selectedRuns",void 0);E([A({type:Object}),w("design:type",Object)],Qc.prototype,"_runToTag",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Qc.prototype,"_dataNotFound",void 0);E([A({type:String}),w("design:type",String)],Qc.prototype,"_tagFilter",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Qc.prototype,"_categoriesDomReady",void 0);E([A({type:Object}),w("design:type",Object)],Qc.prototype,"_requestManager",void 0);E([Rt("_runToTag","_selectedRuns","_tagFilter","_categoriesDomReady"),w("design:type",Array),w("design:paramtypes",[])],Qc.prototype,"_categories",null);Qc=E([yt("tf-text-dashboard")],Qc);var Vht=class extends Gt(mt){};Vht.template=Q`
    <div class="message">
      <h3>The What-If Tool is no longer supported.</h3>
      <p>
        The
        <a href="https://pair-code.github.io/lit/"
          >Learning Interpretability Tool (LIT)</a
        >
        is an actively maintained alternative. Please follow the instructions
        <a href="https://pair-code.github.io/lit/setup/">here</a> to install and
        use this tool.
      </p>
      <style>
        :host {
          display: flex;
        }

        .message {
          margin: 80px auto 0 auto;
          max-width: 540px;
        }
        #commandTextarea {
          margin-top: 1ex;
          padding: 1ex 1em;
          resize: vertical;
          width: 100%;
        }
        #copyContainer {
          display: flex;
        }
        #copiedMessage {
          align-self: center;
          flex-grow: 1;
          font-style: italic;
          padding-right: 1em;
          text-align: right;
        }
      </style>
    </div>
  `;Vht=E([yt("tf-wit-redirect-dashboard")],Vht);var upe=class extends mt{constructor(){super(...arguments),this._template=null,this.tf_backend=RB}};upe=E([yt("tf-backend")],upe);var hpe=class extends mt{constructor(){super(...arguments),this._template=null,this.runsColorScale=fn}};hpe=E([yt("tf-color-scale")],hpe);var fpe=class extends mt{constructor(){super(...arguments),this._template=null,this.tf_feature_flags=tW}};fpe=E([yt("tf-feature-flags")],fpe);var ppe=class extends mt{constructor(){super(...arguments),this._template=null,this.tf_globals=kW}};ppe=E([yt("tf-globals")],ppe);var Uht={};Ks(Uht,{TfDomRepeat:()=>Oi,addLimitListener:()=>UW,getLimit:()=>GW,removeLimitListener:()=>qW,setLimit:()=>s2e});var dpe=class extends mt{constructor(){super(...arguments),this._template=null,this.tf_paginated_view=Uht}};dpe=E([yt("tf-paginated-view-store")],dpe);var mpe=class extends mt{constructor(){super(...arguments),this._template=null,this.tf_storage=OB}};mpe=E([yt("tf-storage")],mpe);})();
/*!
 * is-plain-object <https://github.com/jonschlinkert/is-plain-object>
 *
 * Copyright (c) 2014-2017, Jon Schlinkert.
 * Released under the MIT License.
 */
/*!
 * isobject <https://github.com/jonschlinkert/isobject>
 *
 * Copyright (c) 2014-2017, Jon Schlinkert.
 * Released under the MIT License.
 */
/*! *****************************************************************************
Copyright (c) Microsoft Corporation. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
this file except in compliance with the License. You may obtain a copy of the
License at http://www.apache.org/licenses/LICENSE-2.0

THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
MERCHANTABLITY OR NON-INFRINGEMENT.

See the Apache Version 2.0 License for specific language governing permissions
and limitations under the License.
***************************************************************************** */
/**
 * @fileoverview
 * @suppress {checkPrototypalTypes}
 * @license Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
 * This code may only be used under the BSD style license found at
 * http://polymer.github.io/LICENSE.txt The complete set of authors may be found
 * at http://polymer.github.io/AUTHORS.txt The complete set of contributors may
 * be found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by
 * Google as part of the polymer project is also subject to an additional IP
 * rights grant found at http://polymer.github.io/PATENTS.txt
 */
/**
 * @license
 * Copyright (c) 2016 The Polymer Project Authors. All rights reserved.
 * This code may only be used under the BSD style license found at
 * http://polymer.github.io/LICENSE.txt The complete set of authors may be found
 * at http://polymer.github.io/AUTHORS.txt The complete set of contributors may
 * be found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by
 * Google as part of the polymer project is also subject to an additional IP
 * rights grant found at http://polymer.github.io/PATENTS.txt
 */
/**
 * @license
 * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
 * This code may only be used under the BSD style license found at
 * http://polymer.github.io/LICENSE.txt
 * The complete set of authors may be found at
 * http://polymer.github.io/AUTHORS.txt
 * The complete set of contributors may be found at
 * http://polymer.github.io/CONTRIBUTORS.txt
 * Code distributed by Google as part of the polymer project is also
 * subject to an additional IP rights grant found at
 * http://polymer.github.io/PATENTS.txt
 */
/**
 * @license
 * Copyright (c) 2018 The Polymer Project Authors. All rights reserved.
 * This code may only be used under the BSD style license found at
 * http://polymer.github.io/LICENSE.txt
 * The complete set of authors may be found at
 * http://polymer.github.io/AUTHORS.txt
 * The complete set of contributors may be found at
 * http://polymer.github.io/CONTRIBUTORS.txt
 * Code distributed by Google as part of the polymer project is also
 * subject to an additional IP rights grant found at
 * http://polymer.github.io/PATENTS.txt
 */
/**
 * @license
 * Copyright (c) 2021 Vaadin Ltd.
 * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
 */
/**
 * @license
 * Copyright 2010-2022 Three.js Authors
 * SPDX-License-Identifier: MIT
 */
/**
 * @license
 * Lodash <https://lodash.com/>
 * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
 * Released under MIT license <https://lodash.com/license>
 * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
 * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
 */
/**
 * Copyright 2014-present Palantir Technologies
 * @license MIT
 *
 * @fileoverview manually add d3-selection-multi to d3 default bundle. Most of this code is
 * copied from d3-selection-multi@1.0.0.
 * See https://github.com/d3/d3-selection-multi/issues/11 for why we have to do this
 */
/**
 * Copyright 2014-present Palantir Technologies
 * @license MIT
 * @fileoverview Implements a convenient thunk function to handle the common case
 * of creating a memoized function that takes its inputs from mutable class properties.
 */
/**
 * Copyright 2014-present Palantir Technologies
 * @license MIT
 * @fileoverview Implements a function memoizer using the Signature API.
 */
/**
 * Copyright 2014-present Palantir Technologies
 * @license MIT
 * @fileoverview Implements the Signature API to help in comparing when two
 * Plottable objects have "changed".
 *
 * Memoization in Plottable is complicated by mutable scales and datasets. We cannot simply
 * reference compare two e.g. scales since it may have internally mutated. To resolve this,
 * we write a recursive Signature interface that holds an immutable snapshot of whatever
 * state the scale/data was in at the time. Then on memoized function invocation we sign the
 * new inputs and compare the signatures to decide if we should recompute.
 *
 * We must hand-write a signature for each custom class we wish to support.
 */
/**
 * Copyright 2014-present Palantir Technologies
 * @license MIT
 */
/**
 * Copyright 2017-present Palantir Technologies
 * @license MIT
 */
/**
@license
Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
This code may only be used under the BSD style license found at
http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
part of the polymer project is also subject to an additional IP rights grant
found at http://polymer.github.io/PATENTS.txt
*/
/**
@license
Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
This code may only be used under the BSD style license found at
http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
part of the polymer project is also subject to an additional IP rights grant
found at http://polymer.github.io/PATENTS.txt
*/
/**
@license
Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
Code distributed by Google as part of the polymer project is also
subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
*/
/**
@license
Copyright (c) 2016 The Polymer Project Authors. All rights reserved.
This code may only be used under the BSD style license found at
http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
part of the polymer project is also subject to an additional IP rights grant
found at http://polymer.github.io/PATENTS.txt
*/
/**
@license
Copyright (c) 2016 The Polymer Project Authors. All rights reserved.
This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
Code distributed by Google as part of the polymer project is also
subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
*/
/**
@license
Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
This code may only be used under the BSD style license found at
http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
part of the polymer project is also subject to an additional IP rights grant
found at http://polymer.github.io/PATENTS.txt
*/
/**
@license
Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
Code distributed by Google as part of the polymer project is also
subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
*/
/**
@license
Copyright (c) 2019 The Polymer Project Authors. All rights reserved.
This code may only be used under the BSD style license found at
http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
part of the polymer project is also subject to an additional IP rights grant
found at http://polymer.github.io/PATENTS.txt
*/
/**
@license
Copyright (c) 2019 The Polymer Project Authors. All rights reserved.
This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
Code distributed by Google as part of the polymer project is also
subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
*/

(()=>{var Xie=Object.create,HA=Object.defineProperty,Qie=Object.getOwnPropertyDescriptor,Zie=Object.getOwnPropertyNames,Kie=Object.getPrototypeOf,Jie=Object.prototype.hasOwnProperty,y4=(n,t)=>()=>(t||n((t={exports:{}}).exports,t),t.exports),zA=(n,t)=>{for(var e in t)HA(n,e,{get:t[e],enumerable:!0})},b4=(n,t,e)=>(e=null!=n?Xie(Kie(n)):{},((n,t,e,i)=>{if(t&&"object"==typeof t||"function"==typeof t)for(let r of Zie(t))!Jie.call(n,r)&&undefined!==r&&HA(n,r,{get:()=>t[r],enumerable:!(i=Qie(t,r))||i.enumerable});return n})(!t&&n&&n.__esModule?e:HA(e,"default",{value:n,enumerable:!0}),n)),iH=y4((cUe,CC)=>{var k4,P4,O4,F4,L4,N4,B4,V4,H4,z4,U4,j4,G4,vC,tR,W4,q4,Y4,jm,X4,Q4,Z4,K4,J4,$4,eH,tH,nH,xC;!function(n){var t="object"==typeof global?global:"object"==typeof self?self:"object"==typeof this?this:{};function e(i,r){return i!==t&&("function"==typeof Object.create?Object.defineProperty(i,"__esModule",{value:!0}):i.__esModule=!0),function(o,a){return i[o]=r?r(o,a):a}}"function"==typeof define&&define.amd?define("tslib",["exports"],function(i){n(e(t,e(i)))}):n("object"==typeof CC&&"object"==typeof CC.exports?e(t,e(CC.exports)):e(t))}(function(n){var t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(i,r){i.__proto__=r}||function(i,r){for(var o in r)Object.prototype.hasOwnProperty.call(r,o)&&(i[o]=r[o])};k4=function(i,r){if("function"!=typeof r&&null!==r)throw new TypeError("Class extends value "+String(r)+" is not a constructor or null");function o(){this.constructor=i}t(i,r),i.prototype=null===r?Object.create(r):(o.prototype=r.prototype,new o)},P4=Object.assign||function(i){for(var r,o=1,a=arguments.length;o<a;o++)for(var s in r=arguments[o])Object.prototype.hasOwnProperty.call(r,s)&&(i[s]=r[s]);return i},O4=function(i,r){var o={};for(var a in i)Object.prototype.hasOwnProperty.call(i,a)&&r.indexOf(a)<0&&(o[a]=i[a]);if(null!=i&&"function"==typeof Object.getOwnPropertySymbols){var s=0;for(a=Object.getOwnPropertySymbols(i);s<a.length;s++)r.indexOf(a[s])<0&&Object.prototype.propertyIsEnumerable.call(i,a[s])&&(o[a[s]]=i[a[s]])}return o},F4=function(i,r,o,a){var c,s=arguments.length,l=s<3?r:null===a?a=Object.getOwnPropertyDescriptor(r,o):a;if("object"==typeof Reflect&&"function"==typeof Reflect.decorate)l=Reflect.decorate(i,r,o,a);else for(var d=i.length-1;d>=0;d--)(c=i[d])&&(l=(s<3?c(l):s>3?c(r,o,l):c(r,o))||l);return s>3&&l&&Object.defineProperty(r,o,l),l},L4=function(i,r){return function(o,a){r(o,a,i)}},N4=function(i,r,o,a,s,l){function c(A){if(void 0!==A&&"function"!=typeof A)throw new TypeError("Function expected");return A}for(var m,d=a.kind,u="getter"===d?"get":"setter"===d?"set":"value",p=!r&&i?a.static?i:i.prototype:null,f=r||(p?Object.getOwnPropertyDescriptor(p,a.name):{}),y=!1,M=o.length-1;M>=0;M--){var v={};for(var x in a)v[x]="access"===x?{}:a[x];for(var x in a.access)v.access[x]=a.access[x];v.addInitializer=function(A){if(y)throw new TypeError("Cannot add initializers after decoration has completed");l.push(c(A||null))};var R=(0,o[M])("accessor"===d?{get:f.get,set:f.set}:f[u],v);if("accessor"===d){if(void 0===R)continue;if(null===R||"object"!=typeof R)throw new TypeError("Object expected");(m=c(R.get))&&(f.get=m),(m=c(R.set))&&(f.set=m),(m=c(R.init))&&s.push(m)}else(m=c(R))&&("field"===d?s.push(m):f[u]=m)}p&&Object.defineProperty(p,a.name,f),y=!0},B4=function(i,r,o){for(var a=arguments.length>2,s=0;s<r.length;s++)o=a?r[s].call(i,o):r[s].call(i);return a?o:void 0},V4=function(i){return"symbol"==typeof i?i:"".concat(i)},H4=function(i,r,o){return"symbol"==typeof r&&(r=r.description?"[".concat(r.description,"]"):""),Object.defineProperty(i,"name",{configurable:!0,value:o?"".concat(o," ",r):r})},z4=function(i,r){if("object"==typeof Reflect&&"function"==typeof Reflect.metadata)return Reflect.metadata(i,r)},U4=function(i,r,o,a){return new(o||(o=Promise))(function(l,c){function d(f){try{p(a.next(f))}catch(m){c(m)}}function u(f){try{p(a.throw(f))}catch(m){c(m)}}function p(f){f.done?l(f.value):function(l){return l instanceof o?l:new o(function(c){c(l)})}(f.value).then(d,u)}p((a=a.apply(i,r||[])).next())})},j4=function(i,r){var a,s,l,c,o={label:0,sent:function(){if(1&l[0])throw l[1];return l[1]},trys:[],ops:[]};return c={next:d(0),throw:d(1),return:d(2)},"function"==typeof Symbol&&(c[Symbol.iterator]=function(){return this}),c;function d(p){return function(f){return function(p){if(a)throw new TypeError("Generator is already executing.");for(;c&&(c=0,p[0]&&(o=0)),o;)try{if(a=1,s&&(l=2&p[0]?s.return:p[0]?s.throw||((l=s.return)&&l.call(s),0):s.next)&&!(l=l.call(s,p[1])).done)return l;switch(s=0,l&&(p=[2&p[0],l.value]),p[0]){case 0:case 1:l=p;break;case 4:return o.label++,{value:p[1],done:!1};case 5:o.label++,s=p[1],p=[0];continue;case 7:p=o.ops.pop(),o.trys.pop();continue;default:if(!(l=(l=o.trys).length>0&&l[l.length-1])&&(6===p[0]||2===p[0])){o=0;continue}if(3===p[0]&&(!l||p[1]>l[0]&&p[1]<l[3])){o.label=p[1];break}if(6===p[0]&&o.label<l[1]){o.label=l[1],l=p;break}if(l&&o.label<l[2]){o.label=l[2],o.ops.push(p);break}l[2]&&o.ops.pop(),o.trys.pop();continue}p=r.call(i,o)}catch(f){p=[6,f],s=0}finally{a=l=0}if(5&p[0])throw p[1];return{value:p[0]?p[1]:void 0,done:!0}}([p,f])}}},G4=function(i,r){for(var o in i)"default"!==o&&!Object.prototype.hasOwnProperty.call(r,o)&&xC(r,i,o)},xC=Object.create?function(i,r,o,a){void 0===a&&(a=o);var s=Object.getOwnPropertyDescriptor(r,o);(!s||("get"in s?!r.__esModule:s.writable||s.configurable))&&(s={enumerable:!0,get:function(){return r[o]}}),Object.defineProperty(i,a,s)}:function(i,r,o,a){void 0===a&&(a=o),i[a]=r[o]},vC=function(i){var r="function"==typeof Symbol&&Symbol.iterator,o=r&&i[r],a=0;if(o)return o.call(i);if(i&&"number"==typeof i.length)return{next:function(){return i&&a>=i.length&&(i=void 0),{value:i&&i[a++],done:!i}}};throw new TypeError(r?"Object is not iterable.":"Symbol.iterator is not defined.")},tR=function(i,r){var o="function"==typeof Symbol&&i[Symbol.iterator];if(!o)return i;var s,c,a=o.call(i),l=[];try{for(;(void 0===r||r-- >0)&&!(s=a.next()).done;)l.push(s.value)}catch(d){c={error:d}}finally{try{s&&!s.done&&(o=a.return)&&o.call(a)}finally{if(c)throw c.error}}return l},W4=function(){for(var i=[],r=0;r<arguments.length;r++)i=i.concat(tR(arguments[r]));return i},q4=function(){for(var i=0,r=0,o=arguments.length;r<o;r++)i+=arguments[r].length;var a=Array(i),s=0;for(r=0;r<o;r++)for(var l=arguments[r],c=0,d=l.length;c<d;c++,s++)a[s]=l[c];return a},Y4=function(i,r,o){if(o||2===arguments.length)for(var l,a=0,s=r.length;a<s;a++)(l||!(a in r))&&(l||(l=Array.prototype.slice.call(r,0,a)),l[a]=r[a]);return i.concat(l||Array.prototype.slice.call(r))},jm=function(i){return this instanceof jm?(this.v=i,this):new jm(i)},X4=function(i,r,o){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var s,a=o.apply(i,r||[]),l=[];return s={},c("next"),c("throw"),c("return"),s[Symbol.asyncIterator]=function(){return this},s;function c(y){a[y]&&(s[y]=function(M){return new Promise(function(v,x){l.push([y,M,v,x])>1||d(y,M)})})}function d(y,M){try{!function(y){y.value instanceof jm?Promise.resolve(y.value.v).then(p,f):m(l[0][2],y)}(a[y](M))}catch(v){m(l[0][3],v)}}function p(y){d("next",y)}function f(y){d("throw",y)}function m(y,M){y(M),l.shift(),l.length&&d(l[0][0],l[0][1])}},Q4=function(i){var r,o;return r={},a("next"),a("throw",function(s){throw s}),a("return"),r[Symbol.iterator]=function(){return this},r;function a(s,l){r[s]=i[s]?function(c){return(o=!o)?{value:jm(i[s](c)),done:!1}:l?l(c):c}:l}},Z4=function(i){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var o,r=i[Symbol.asyncIterator];return r?r.call(i):(i=vC(i),o={},a("next"),a("throw"),a("return"),o[Symbol.asyncIterator]=function(){return this},o);function a(l){o[l]=i[l]&&function(c){return new Promise(function(d,u){!function(l,c,d,u){Promise.resolve(u).then(function(p){l({value:p,done:d})},c)}(d,u,(c=i[l](c)).done,c.value)})}}},K4=function(i,r){return Object.defineProperty?Object.defineProperty(i,"raw",{value:r}):i.raw=r,i};var e=Object.create?function(i,r){Object.defineProperty(i,"default",{enumerable:!0,value:r})}:function(i,r){i.default=r};J4=function(i){if(i&&i.__esModule)return i;var r={};if(null!=i)for(var o in i)"default"!==o&&Object.prototype.hasOwnProperty.call(i,o)&&xC(r,i,o);return e(r,i),r},$4=function(i){return i&&i.__esModule?i:{default:i}},eH=function(i,r,o,a){if("a"===o&&!a)throw new TypeError("Private accessor was defined without a getter");if("function"==typeof r?i!==r||!a:!r.has(i))throw new TypeError("Cannot read private member from an object whose class did not declare it");return"m"===o?a:"a"===o?a.call(i):a?a.value:r.get(i)},tH=function(i,r,o,a,s){if("m"===a)throw new TypeError("Private method is not writable");if("a"===a&&!s)throw new TypeError("Private accessor was defined without a setter");if("function"==typeof r?i!==r||!s:!r.has(i))throw new TypeError("Cannot write private member to an object whose class did not declare it");return"a"===a?s.call(i,o):s?s.value=o:r.set(i,o),o},nH=function(i,r){if(null===r||"object"!=typeof r&&"function"!=typeof r)throw new TypeError("Cannot use 'in' operator on non-object");return"function"==typeof i?r===i:i.has(r)},n("__extends",k4),n("__assign",P4),n("__rest",O4),n("__decorate",F4),n("__param",L4),n("__esDecorate",N4),n("__runInitializers",B4),n("__propKey",V4),n("__setFunctionName",H4),n("__metadata",z4),n("__awaiter",U4),n("__generator",j4),n("__exportStar",G4),n("__createBinding",xC),n("__values",vC),n("__read",tR),n("__spread",W4),n("__spreadArrays",q4),n("__spreadArray",Y4),n("__await",jm),n("__asyncGenerator",X4),n("__asyncDelegator",Q4),n("__asyncValues",Z4),n("__makeTemplateObject",K4),n("__importStar",J4),n("__importDefault",$4),n("__classPrivateFieldGet",eH),n("__classPrivateFieldSet",tH),n("__classPrivateFieldIn",nH)})}),RG=y4(mO=>{"use strict";var n,hu=mO&&mO.__spreadArray||function(n,t,e){if(e||2===arguments.length)for(var o,i=0,r=t.length;i<r;i++)(o||!(i in t))&&(o||(o=Array.prototype.slice.call(t,0,i)),o[i]=t[i]);return n.concat(o||Array.prototype.slice.call(t))};n=function(){!function(j){var ee=j.performance;function le(gt){ee&&ee.mark&&ee.mark(gt)}function E(gt,me){ee&&ee.measure&&ee.measure(gt,me)}le("Zone");var z=j.__Zone_symbol_prefix||"__zone_symbol__";function Y(gt){return z+gt}var J=!0===j[Y("forceDuplicateZoneCheck")];if(j.Zone){if(J||"function"!=typeof j.Zone.__symbol__)throw new Error("Zone already loaded.");return j.Zone}var ae=function(){function gt(me,he){this._parent=me,this._name=he?he.name||"unnamed":"<root>",this._properties=he&&he.properties||{},this._zoneDelegate=new et(this,this._parent&&this._parent._zoneDelegate,he)}return gt.assertZonePatched=function(){if(j.Promise!==Ln.ZoneAwarePromise)throw new Error("Zone.js has detected that ZoneAwarePromise `(window|global).Promise` has been overwritten.\nMost likely cause is that a Promise polyfill has been loaded after Zone.js (Polyfilling Promise api is not necessary when zone.js is loaded. If you must load one, do so before loading zone.js.)")},Object.defineProperty(gt,"root",{get:function(){for(var me=gt.current;me.parent;)me=me.parent;return me},enumerable:!1,configurable:!0}),Object.defineProperty(gt,"current",{get:function(){return or.zone},enumerable:!1,configurable:!0}),Object.defineProperty(gt,"currentTask",{get:function(){return Ma},enumerable:!1,configurable:!0}),gt.__load_patch=function(me,he,Re){if(void 0===Re&&(Re=!1),Ln.hasOwnProperty(me)){if(!Re&&J)throw Error("Already loaded patch: "+me)}else if(!j["__Zone_disable_"+me]){var En="Zone:"+me;le(En),Ln[me]=he(j,gt,pr),E(En,En)}},Object.defineProperty(gt.prototype,"parent",{get:function(){return this._parent},enumerable:!1,configurable:!0}),Object.defineProperty(gt.prototype,"name",{get:function(){return this._name},enumerable:!1,configurable:!0}),gt.prototype.get=function(me){var he=this.getZoneWith(me);if(he)return he._properties[me]},gt.prototype.getZoneWith=function(me){for(var he=this;he;){if(he._properties.hasOwnProperty(me))return he;he=he._parent}return null},gt.prototype.fork=function(me){if(!me)throw new Error("ZoneSpec required!");return this._zoneDelegate.fork(this,me)},gt.prototype.wrap=function(me,he){if("function"!=typeof me)throw new Error("Expecting function got: "+me);var Re=this._zoneDelegate.intercept(this,me,he),En=this;return function(){return En.runGuarded(Re,this,arguments,he)}},gt.prototype.run=function(me,he,Re,En){or={parent:or,zone:this};try{return this._zoneDelegate.invoke(this,me,he,Re,En)}finally{or=or.parent}},gt.prototype.runGuarded=function(me,he,Re,En){void 0===he&&(he=null),or={parent:or,zone:this};try{try{return this._zoneDelegate.invoke(this,me,he,Re,En)}catch(mr){if(this._zoneDelegate.handleError(this,mr))throw mr}}finally{or=or.parent}},gt.prototype.runTask=function(me,he,Re){if(me.zone!=this)throw new Error("A task can only be run in the zone of creation! (Creation: "+(me.zone||It).name+"; Execution: "+this.name+")");if(me.state!==gi||me.type!==_i&&me.type!==On){var En=me.state!=Qn;En&&me._transitionTo(Qn,jn),me.runCount++;var mr=Ma;Ma=me,or={parent:or,zone:this};try{me.type==On&&me.data&&!me.data.isPeriodic&&(me.cancelFn=void 0);try{return this._zoneDelegate.invokeTask(this,me,he,Re)}catch(ol){if(this._zoneDelegate.handleError(this,ol))throw ol}}finally{me.state!==gi&&me.state!==Bi&&(me.type==_i||me.data&&me.data.isPeriodic?En&&me._transitionTo(jn,Qn):(me.runCount=0,this._updateTaskCount(me,-1),En&&me._transitionTo(gi,Qn,gi))),or=or.parent,Ma=mr}}},gt.prototype.scheduleTask=function(me){if(me.zone&&me.zone!==this)for(var he=this;he;){if(he===me.zone)throw Error("can not reschedule task to ".concat(this.name," which is descendants of the original zone ").concat(me.zone.name));he=he.parent}me._transitionTo(ei,gi);var Re=[];me._zoneDelegates=Re,me._zone=this;try{me=this._zoneDelegate.scheduleTask(this,me)}catch(En){throw me._transitionTo(Bi,ei,gi),this._zoneDelegate.handleError(this,En),En}return me._zoneDelegates===Re&&this._updateTaskCount(me,1),me.state==ei&&me._transitionTo(jn,ei),me},gt.prototype.scheduleMicroTask=function(me,he,Re,En){return this.scheduleTask(new qe(xn,me,he,Re,En,void 0))},gt.prototype.scheduleMacroTask=function(me,he,Re,En,mr){return this.scheduleTask(new qe(On,me,he,Re,En,mr))},gt.prototype.scheduleEventTask=function(me,he,Re,En,mr){return this.scheduleTask(new qe(_i,me,he,Re,En,mr))},gt.prototype.cancelTask=function(me){if(me.zone!=this)throw new Error("A task can only be cancelled in the zone of creation! (Creation: "+(me.zone||It).name+"; Execution: "+this.name+")");if(me.state===jn||me.state===Qn){me._transitionTo(jt,jn,Qn);try{this._zoneDelegate.cancelTask(this,me)}catch(he){throw me._transitionTo(Bi,jt),this._zoneDelegate.handleError(this,he),he}return this._updateTaskCount(me,-1),me._transitionTo(gi,jt),me.runCount=0,me}},gt.prototype._updateTaskCount=function(me,he){var Re=me._zoneDelegates;-1==he&&(me._zoneDelegates=null);for(var En=0;En<Re.length;En++)Re[En]._updateTaskCount(me.type,he)},gt}();ae.__symbol__=Y;var Yi,Ue={name:"",onHasTask:function(gt,me,he,Re){return gt.hasTask(he,Re)},onScheduleTask:function(gt,me,he,Re){return gt.scheduleTask(he,Re)},onInvokeTask:function(gt,me,he,Re,En,mr){return gt.invokeTask(he,Re,En,mr)},onCancelTask:function(gt,me,he,Re){return gt.cancelTask(he,Re)}},et=function(){function gt(me,he,Re){this._taskCounts={microTask:0,macroTask:0,eventTask:0},this.zone=me,this._parentDelegate=he,this._forkZS=Re&&(Re&&Re.onFork?Re:he._forkZS),this._forkDlgt=Re&&(Re.onFork?he:he._forkDlgt),this._forkCurrZone=Re&&(Re.onFork?this.zone:he._forkCurrZone),this._interceptZS=Re&&(Re.onIntercept?Re:he._interceptZS),this._interceptDlgt=Re&&(Re.onIntercept?he:he._interceptDlgt),this._interceptCurrZone=Re&&(Re.onIntercept?this.zone:he._interceptCurrZone),this._invokeZS=Re&&(Re.onInvoke?Re:he._invokeZS),this._invokeDlgt=Re&&(Re.onInvoke?he:he._invokeDlgt),this._invokeCurrZone=Re&&(Re.onInvoke?this.zone:he._invokeCurrZone),this._handleErrorZS=Re&&(Re.onHandleError?Re:he._handleErrorZS),this._handleErrorDlgt=Re&&(Re.onHandleError?he:he._handleErrorDlgt),this._handleErrorCurrZone=Re&&(Re.onHandleError?this.zone:he._handleErrorCurrZone),this._scheduleTaskZS=Re&&(Re.onScheduleTask?Re:he._scheduleTaskZS),this._scheduleTaskDlgt=Re&&(Re.onScheduleTask?he:he._scheduleTaskDlgt),this._scheduleTaskCurrZone=Re&&(Re.onScheduleTask?this.zone:he._scheduleTaskCurrZone),this._invokeTaskZS=Re&&(Re.onInvokeTask?Re:he._invokeTaskZS),this._invokeTaskDlgt=Re&&(Re.onInvokeTask?he:he._invokeTaskDlgt),this._invokeTaskCurrZone=Re&&(Re.onInvokeTask?this.zone:he._invokeTaskCurrZone),this._cancelTaskZS=Re&&(Re.onCancelTask?Re:he._cancelTaskZS),this._cancelTaskDlgt=Re&&(Re.onCancelTask?he:he._cancelTaskDlgt),this._cancelTaskCurrZone=Re&&(Re.onCancelTask?this.zone:he._cancelTaskCurrZone),this._hasTaskZS=null,this._hasTaskDlgt=null,this._hasTaskDlgtOwner=null,this._hasTaskCurrZone=null;var En=Re&&Re.onHasTask;(En||he&&he._hasTaskZS)&&(this._hasTaskZS=En?Re:Ue,this._hasTaskDlgt=he,this._hasTaskDlgtOwner=this,this._hasTaskCurrZone=me,Re.onScheduleTask||(this._scheduleTaskZS=Ue,this._scheduleTaskDlgt=he,this._scheduleTaskCurrZone=this.zone),Re.onInvokeTask||(this._invokeTaskZS=Ue,this._invokeTaskDlgt=he,this._invokeTaskCurrZone=this.zone),Re.onCancelTask||(this._cancelTaskZS=Ue,this._cancelTaskDlgt=he,this._cancelTaskCurrZone=this.zone))}return gt.prototype.fork=function(me,he){return this._forkZS?this._forkZS.onFork(this._forkDlgt,this.zone,me,he):new ae(me,he)},gt.prototype.intercept=function(me,he,Re){return this._interceptZS?this._interceptZS.onIntercept(this._interceptDlgt,this._interceptCurrZone,me,he,Re):he},gt.prototype.invoke=function(me,he,Re,En,mr){return this._invokeZS?this._invokeZS.onInvoke(this._invokeDlgt,this._invokeCurrZone,me,he,Re,En,mr):he.apply(Re,En)},gt.prototype.handleError=function(me,he){return!this._handleErrorZS||this._handleErrorZS.onHandleError(this._handleErrorDlgt,this._handleErrorCurrZone,me,he)},gt.prototype.scheduleTask=function(me,he){var Re=he;if(this._scheduleTaskZS)this._hasTaskZS&&Re._zoneDelegates.push(this._hasTaskDlgtOwner),(Re=this._scheduleTaskZS.onScheduleTask(this._scheduleTaskDlgt,this._scheduleTaskCurrZone,me,he))||(Re=he);else if(he.scheduleFn)he.scheduleFn(he);else{if(he.type!=xn)throw new Error("Task is missing scheduleFn.");fn(he)}return Re},gt.prototype.invokeTask=function(me,he,Re,En){return this._invokeTaskZS?this._invokeTaskZS.onInvokeTask(this._invokeTaskDlgt,this._invokeTaskCurrZone,me,he,Re,En):he.callback.apply(Re,En)},gt.prototype.cancelTask=function(me,he){var Re;if(this._cancelTaskZS)Re=this._cancelTaskZS.onCancelTask(this._cancelTaskDlgt,this._cancelTaskCurrZone,me,he);else{if(!he.cancelFn)throw Error("Task is not cancelable");Re=he.cancelFn(he)}return Re},gt.prototype.hasTask=function(me,he){try{this._hasTaskZS&&this._hasTaskZS.onHasTask(this._hasTaskDlgt,this._hasTaskCurrZone,me,he)}catch(Re){this.handleError(me,Re)}},gt.prototype._updateTaskCount=function(me,he){var Re=this._taskCounts,En=Re[me],mr=Re[me]=En+he;if(mr<0)throw new Error("More tasks executed then were scheduled.");0!=En&&0!=mr||this.hasTask(this.zone,{microTask:Re.microTask>0,macroTask:Re.macroTask>0,eventTask:Re.eventTask>0,change:me})},gt}(),qe=function(){function gt(me,he,Re,En,mr,ol){if(this._zone=null,this.runCount=0,this._zoneDelegates=null,this._state="notScheduled",this.type=me,this.source=he,this.data=En,this.scheduleFn=mr,this.cancelFn=ol,!Re)throw new Error("callback is not defined");this.callback=Re;var nt=this;this.invoke=me===_i&&En&&En.useG?gt.invokeTask:function(){return gt.invokeTask.call(j,nt,this,arguments)}}return gt.invokeTask=function(me,he,Re){me||(me=this),xr++;try{return me.runCount++,me.zone.runTask(me,he,Re)}finally{1==xr&&Pn(),xr--}},Object.defineProperty(gt.prototype,"zone",{get:function(){return this._zone},enumerable:!1,configurable:!0}),Object.defineProperty(gt.prototype,"state",{get:function(){return this._state},enumerable:!1,configurable:!0}),gt.prototype.cancelScheduleRequest=function(){this._transitionTo(gi,ei)},gt.prototype._transitionTo=function(me,he,Re){if(this._state!==he&&this._state!==Re)throw new Error("".concat(this.type," '").concat(this.source,"': can not transition to '").concat(me,"', expecting state '").concat(he,"'").concat(Re?" or '"+Re+"'":"",", was '").concat(this._state,"'."));this._state=me,me==gi&&(this._zoneDelegates=null)},gt.prototype.toString=function(){return this.data&&typeof this.data.handleId<"u"?this.data.handleId.toString():Object.prototype.toString.call(this)},gt.prototype.toJSON=function(){return{type:this.type,state:this.state,source:this.source,zone:this.zone.name,runCount:this.runCount}},gt}(),rt=Y("setTimeout"),dt=Y("Promise"),Et=Y("then"),At=[],ln=!1;function xi(gt){if(Yi||j[dt]&&(Yi=j[dt].resolve(0)),Yi){var me=Yi[Et];me||(me=Yi.then),me.call(Yi,gt)}else j[rt](gt,0)}function fn(gt){0===xr&&0===At.length&&xi(Pn),gt&&At.push(gt)}function Pn(){if(!ln){for(ln=!0;At.length;){var gt=At;At=[];for(var me=0;me<gt.length;me++){var he=gt[me];try{he.zone.runTask(he,null,null)}catch(Re){pr.onUnhandledError(Re)}}}pr.microtaskDrainDone(),ln=!1}}var It={name:"NO ZONE"},gi="notScheduled",ei="scheduling",jn="scheduled",Qn="running",jt="canceling",Bi="unknown",xn="microTask",On="macroTask",_i="eventTask",Ln={},pr={symbol:Y,currentZoneFrame:function(){return or},onUnhandledError:fr,microtaskDrainDone:fr,scheduleMicroTask:fn,showUncaughtError:function(){return!ae[Y("ignoreConsoleErrorUncaughtError")]},patchEventTarget:function(){return[]},patchOnProperties:fr,patchMethod:function(){return fr},bindArguments:function(){return[]},patchThen:function(){return fr},patchMacroTask:function(){return fr},patchEventPrototype:function(){return fr},isIEOrEdge:function(){return!1},getGlobalObjects:function(){},ObjectDefineProperty:function(){return fr},ObjectGetOwnPropertyDescriptor:function(){},ObjectCreate:function(){},ArraySlice:function(){return[]},patchClass:function(){return fr},wrapWithCurrentZone:function(){return fr},filterProperties:function(){return[]},attachOriginToPatched:function(){return fr},_redefineProperty:function(){return fr},patchCallbacks:function(){return fr},nativeScheduleMicroTask:xi},or={parent:null,zone:new ae(null,null)},Ma=null,xr=0;function fr(){}E("Zone","Zone"),j.Zone=ae}(typeof window<"u"&&window||typeof self<"u"&&self||global);var n=Object.getOwnPropertyDescriptor,t=Object.defineProperty,e=Object.getPrototypeOf,i=Object.create,r=Array.prototype.slice,o="addEventListener",a="removeEventListener",s=Zone.__symbol__(o),l=Zone.__symbol__(a),c="true",d="false",u=Zone.__symbol__("");function p(j,ee){return Zone.current.wrap(j,ee)}function f(j,ee,le,E,z){return Zone.current.scheduleMacroTask(j,ee,le,E,z)}var m=Zone.__symbol__,y=typeof window<"u",M=y?window:void 0,v=y&&M||"object"==typeof self&&self||global,x="removeAttribute";function R(j,ee){for(var le=j.length-1;le>=0;le--)"function"==typeof j[le]&&(j[le]=p(j[le],ee+"_"+le));return j}function H(j){return!j||!1!==j.writable&&!("function"==typeof j.get&&typeof j.set>"u")}var te=typeof WorkerGlobalScope<"u"&&self instanceof WorkerGlobalScope,K=!("nw"in v)&&typeof v.process<"u"&&"[object process]"==={}.toString.call(v.process),Ce=!K&&!te&&!(!y||!M.HTMLElement),Ze=typeof v.process<"u"&&"[object process]"==={}.toString.call(v.process)&&!te&&!(!y||!M.HTMLElement),Ie={},I=function(j){if(j=j||v.event){var ee=Ie[j.type];ee||(ee=Ie[j.type]=m("ON_PROPERTY"+j.type));var z,le=this||j.target||v,E=le[ee];return Ce&&le===M&&"error"===j.type?!0===(z=E&&E.call(this,j.message,j.filename,j.lineno,j.colno,j.error))&&j.preventDefault():null!=(z=E&&E.apply(this,arguments))&&!z&&j.preventDefault(),z}};function re(j,ee,le){var E=n(j,ee);if(!E&&le&&n(le,ee)&&(E={enumerable:!0,configurable:!0}),E&&E.configurable){var Y=m("on"+ee+"patched");if(!j.hasOwnProperty(Y)||!j[Y]){delete E.writable,delete E.value;var J=E.get,ae=E.set,Ue=ee.slice(2),et=Ie[Ue];et||(et=Ie[Ue]=m("ON_PROPERTY"+Ue)),E.set=function(qe){var rt=this;!rt&&j===v&&(rt=v),rt&&("function"==typeof rt[et]&&rt.removeEventListener(Ue,I),ae&&ae.call(rt,null),rt[et]=qe,"function"==typeof qe&&rt.addEventListener(Ue,I,!1))},E.get=function(){var qe=this;if(!qe&&j===v&&(qe=v),!qe)return null;var rt=qe[et];if(rt)return rt;if(J){var dt=J.call(this);if(dt)return E.set.call(this,dt),"function"==typeof qe[x]&&qe.removeAttribute(ee),dt}return null},t(j,ee,E),j[Y]=!0}}}function ce(j,ee,le){if(ee)for(var E=0;E<ee.length;E++)re(j,"on"+ee[E],le);else{var z=[];for(var Y in j)"on"==Y.slice(0,2)&&z.push(Y);for(var J=0;J<z.length;J++)re(j,z[J],le)}}var fe=m("originalInstance");function _e(j){var ee=v[j];if(ee){v[m(j)]=ee,v[j]=function(){var z=R(arguments,j);switch(z.length){case 0:this[fe]=new ee;break;case 1:this[fe]=new ee(z[0]);break;case 2:this[fe]=new ee(z[0],z[1]);break;case 3:this[fe]=new ee(z[0],z[1],z[2]);break;case 4:this[fe]=new ee(z[0],z[1],z[2],z[3]);break;default:throw new Error("Arg list too long.")}},ue(v[j],ee);var E,le=new ee(function(){});for(E in le)"XMLHttpRequest"===j&&"responseBlob"===E||function(z){"function"==typeof le[z]?v[j].prototype[z]=function(){return this[fe][z].apply(this[fe],arguments)}:t(v[j].prototype,z,{set:function(Y){"function"==typeof Y?(this[fe][z]=p(Y,j+"."+z),ue(this[fe][z],Y)):this[fe][z]=Y},get:function(){return this[fe][z]}})}(E);for(E in ee)"prototype"!==E&&ee.hasOwnProperty(E)&&(v[j][E]=ee[E])}}function ne(j,ee,le){for(var E=j;E&&!E.hasOwnProperty(ee);)E=e(E);!E&&j[ee]&&(E=j);var z=m(ee),Y=null;if(E&&(!(Y=E[z])||!E.hasOwnProperty(z))&&(Y=E[z]=E[ee],H(E&&n(E,ee)))){var ae=le(Y,z,ee);E[ee]=function(){return ae(this,arguments)},ue(E[ee],Y)}return Y}function de(j,ee,le){var E=null;function z(Y){var J=Y.data;return J.args[J.cbIdx]=function(){Y.invoke.apply(this,arguments)},E.apply(J.target,J.args),Y}E=ne(j,ee,function(Y){return function(J,ae){var Ue=le(J,ae);return Ue.cbIdx>=0&&"function"==typeof ae[Ue.cbIdx]?f(Ue.name,ae[Ue.cbIdx],Ue,z):Y.apply(J,ae)}})}function ue(j,ee){j[m("OriginalDelegate")]=ee}var Ge=!1,Me=!1;function ct(){if(Ge)return Me;Ge=!0;try{var j=M.navigator.userAgent;(-1!==j.indexOf("MSIE ")||-1!==j.indexOf("Trident/")||-1!==j.indexOf("Edge/"))&&(Me=!0)}catch{}return Me}Zone.__load_patch("ZoneAwarePromise",function(j,ee,le){var E=Object.getOwnPropertyDescriptor,z=Object.defineProperty,J=le.symbol,ae=[],Ue=!0===j[J("DISABLE_WRAPPING_UNCAUGHT_PROMISE_REJECTION")],et=J("Promise"),qe=J("then"),rt="__creationTrace__";le.onUnhandledError=function(nt){if(le.showUncaughtError()){var Ot=nt&&nt.rejection;Ot?console.error("Unhandled Promise rejection:",Ot instanceof Error?Ot.message:Ot,"; Zone:",nt.zone.name,"; Task:",nt.task&&nt.task.source,"; Value:",Ot,Ot instanceof Error?Ot.stack:void 0):console.error(nt)}},le.microtaskDrainDone=function(){for(var nt=function(){var Ot=ae.shift();try{Ot.zone.runGuarded(function(){throw Ot.throwOriginal?Ot.rejection:Ot})}catch(xt){!function(nt){le.onUnhandledError(nt);try{var Ot=ee[dt];"function"==typeof Ot&&Ot.call(this,nt)}catch{}}(xt)}};ae.length;)nt()};var dt=J("unhandledPromiseRejectionHandler");function At(nt){return nt&&nt.then}function ln(nt){return nt}function Yi(nt){return he.reject(nt)}var xi=J("state"),fn=J("value"),Pn=J("finally"),It=J("parentPromiseValue"),gi=J("parentPromiseState"),ei="Promise.then",jn=null,Qn=!0,jt=!1,Bi=0;function xn(nt,Ot){return function(xt){try{pr(nt,Ot,xt)}catch(Je){pr(nt,!1,Je)}}}var On=function(){var nt=!1;return function(xt){return function(){nt||(nt=!0,xt.apply(null,arguments))}}},_i="Promise resolved with itself",Ln=J("currentTaskTrace");function pr(nt,Ot,xt){var Je=On();if(nt===xt)throw new TypeError(_i);if(nt[xi]===jn){var $t=null;try{("object"==typeof xt||"function"==typeof xt)&&($t=xt&&xt.then)}catch(ri){return Je(function(){pr(nt,!1,ri)})(),nt}if(Ot!==jt&&xt instanceof he&&xt.hasOwnProperty(xi)&&xt.hasOwnProperty(fn)&&xt[xi]!==jn)Ma(xt),pr(nt,xt[xi],xt[fn]);else if(Ot!==jt&&"function"==typeof $t)try{$t.call(xt,Je(xn(nt,Ot)),Je(xn(nt,!1)))}catch(ri){Je(function(){pr(nt,!1,ri)})()}else{nt[xi]=Ot;var zn=nt[fn];if(nt[fn]=xt,nt[Pn]===Pn&&Ot===Qn&&(nt[xi]=nt[gi],nt[fn]=nt[It]),Ot===jt&&xt instanceof Error){var Rn=ee.currentTask&&ee.currentTask.data&&ee.currentTask.data[rt];Rn&&z(xt,Ln,{configurable:!0,enumerable:!1,writable:!0,value:Rn})}for(var ti=0;ti<zn.length;)xr(nt,zn[ti++],zn[ti++],zn[ti++],zn[ti++]);if(0==zn.length&&Ot==jt){nt[xi]=Bi;var ni=xt;try{throw new Error("Uncaught (in promise): "+function(nt){return nt&&nt.toString===Object.prototype.toString?(nt.constructor&&nt.constructor.name||"")+": "+JSON.stringify(nt):nt?nt.toString():Object.prototype.toString.call(nt)}(xt)+(xt&&xt.stack?"\n"+xt.stack:""))}catch(ri){ni=ri}Ue&&(ni.throwOriginal=!0),ni.rejection=xt,ni.promise=nt,ni.zone=ee.current,ni.task=ee.currentTask,ae.push(ni),le.scheduleMicroTask()}}}return nt}var or=J("rejectionHandledHandler");function Ma(nt){if(nt[xi]===Bi){try{var Ot=ee[or];Ot&&"function"==typeof Ot&&Ot.call(this,{rejection:nt[fn],promise:nt})}catch{}nt[xi]=jt;for(var xt=0;xt<ae.length;xt++)nt===ae[xt].promise&&ae.splice(xt,1)}}function xr(nt,Ot,xt,Je,$t){Ma(nt);var zn=nt[xi],Rn=zn?"function"==typeof Je?Je:ln:"function"==typeof $t?$t:Yi;Ot.scheduleMicroTask(ei,function(){try{var ti=nt[fn],ni=!!xt&&Pn===xt[Pn];ni&&(xt[It]=ti,xt[gi]=zn);var ri=Ot.run(Rn,void 0,ni&&Rn!==Yi&&Rn!==ln?[]:[ti]);pr(xt,!0,ri)}catch(Ci){pr(xt,!1,Ci)}},xt)}var gt=function(){},me=j.AggregateError,he=function(){function nt(Ot){var xt=this;if(!(xt instanceof nt))throw new Error("Must be an instanceof Promise.");xt[xi]=jn,xt[fn]=[];try{var Je=On();Ot&&Ot(Je(xn(xt,Qn)),Je(xn(xt,jt)))}catch($t){pr(xt,!1,$t)}}return nt.toString=function(){return"function ZoneAwarePromise() { [native code] }"},nt.resolve=function(Ot){return pr(new this(null),Qn,Ot)},nt.reject=function(Ot){return pr(new this(null),jt,Ot)},nt.any=function(Ot){if(!Ot||"function"!=typeof Ot[Symbol.iterator])return Promise.reject(new me([],"All promises were rejected"));var xt=[],Je=0;try{for(var $t=0,zn=Ot;$t<zn.length;$t++)Je++,xt.push(nt.resolve(zn[$t]))}catch{return Promise.reject(new me([],"All promises were rejected"))}if(0===Je)return Promise.reject(new me([],"All promises were rejected"));var ti=!1,ni=[];return new nt(function(ri,Ci){for(var hr=0;hr<xt.length;hr++)xt[hr].then(function(ko){ti||(ti=!0,ri(ko))},function(ko){ni.push(ko),0==--Je&&(ti=!0,Ci(new me(ni,"All promises were rejected")))})})},nt.race=function(Ot){var xt,Je,$t=new this(function(Ci,hr){xt=Ci,Je=hr});function zn(Ci){xt(Ci)}function Rn(Ci){Je(Ci)}for(var ti=0,ni=Ot;ti<ni.length;ti++){var ri=ni[ti];At(ri)||(ri=this.resolve(ri)),ri.then(zn,Rn)}return $t},nt.all=function(Ot){return nt.allWithCallback(Ot)},nt.allSettled=function(Ot){return(this&&this.prototype instanceof nt?this:nt).allWithCallback(Ot,{thenCallback:function(Je){return{status:"fulfilled",value:Je}},errorCallback:function(Je){return{status:"rejected",reason:Je}}})},nt.allWithCallback=function(Ot,xt){for(var Je,$t,zn=new this(function(eo,xo){Je=eo,$t=xo}),Rn=2,ti=0,ni=[],ri=function(eo){At(eo)||(eo=Ci.resolve(eo));var xo=ti;try{eo.then(function(Gr){ni[xo]=xt?xt.thenCallback(Gr):Gr,0==--Rn&&Je(ni)},function(Gr){xt?(ni[xo]=xt.errorCallback(Gr),0==--Rn&&Je(ni)):$t(Gr)})}catch(Gr){$t(Gr)}Rn++,ti++},Ci=this,hr=0,ko=Ot;hr<ko.length;hr++)ri(ko[hr]);return 0==(Rn-=2)&&Je(ni),zn},Object.defineProperty(nt.prototype,Symbol.toStringTag,{get:function(){return"Promise"},enumerable:!1,configurable:!0}),Object.defineProperty(nt.prototype,Symbol.species,{get:function(){return nt},enumerable:!1,configurable:!0}),nt.prototype.then=function(Ot,xt){var Je,$t=null===(Je=this.constructor)||void 0===Je?void 0:Je[Symbol.species];(!$t||"function"!=typeof $t)&&($t=this.constructor||nt);var zn=new $t(gt),Rn=ee.current;return this[xi]==jn?this[fn].push(Rn,zn,Ot,xt):xr(this,Rn,zn,Ot,xt),zn},nt.prototype.catch=function(Ot){return this.then(null,Ot)},nt.prototype.finally=function(Ot){var xt,Je=null===(xt=this.constructor)||void 0===xt?void 0:xt[Symbol.species];(!Je||"function"!=typeof Je)&&(Je=nt);var $t=new Je(gt);$t[Pn]=Pn;var zn=ee.current;return this[xi]==jn?this[fn].push(zn,$t,Ot,Ot):xr(this,zn,$t,Ot,Ot),$t},nt}();he.resolve=he.resolve,he.reject=he.reject,he.race=he.race,he.all=he.all;var Re=j[et]=j.Promise;j.Promise=he;var En=J("thenPatched");function mr(nt){var Ot=nt.prototype,xt=E(Ot,"then");if(!xt||!1!==xt.writable&&xt.configurable){var Je=Ot.then;Ot[qe]=Je,nt.prototype.then=function($t,zn){var Rn=this;return new he(function(ni,ri){Je.call(Rn,ni,ri)}).then($t,zn)},nt[En]=!0}}return le.patchThen=mr,Re&&(mr(Re),ne(j,"fetch",function(nt){return function(nt){return function(Ot,xt){var Je=nt.apply(Ot,xt);if(Je instanceof he)return Je;var $t=Je.constructor;return $t[En]||mr($t),Je}}(nt)})),Promise[ee.__symbol__("uncaughtPromiseErrors")]=ae,he}),Zone.__load_patch("toString",function(j){var ee=Function.prototype.toString,le=m("OriginalDelegate"),E=m("Promise"),z=m("Error"),Y=function(){if("function"==typeof this){var et=this[le];if(et)return"function"==typeof et?ee.call(et):Object.prototype.toString.call(et);if(this===Promise){var qe=j[E];if(qe)return ee.call(qe)}if(this===Error){var rt=j[z];if(rt)return ee.call(rt)}}return ee.call(this)};Y[le]=ee,Function.prototype.toString=Y;var J=Object.prototype.toString;Object.prototype.toString=function(){return"function"==typeof Promise&&this instanceof Promise?"[object Promise]":J.call(this)}});var wt=!1;if(typeof window<"u")try{var ft=Object.defineProperty({},"passive",{get:function(){wt=!0}});window.addEventListener("test",ft,ft),window.removeEventListener("test",ft,ft)}catch{wt=!1}var ii,Li,Ni,Z,N,Oe={useG:!0},An={},St={},rn=new RegExp("^"+u+"(\\w+)(true|false)$"),ve=m("propagationStopped");function ht(j,ee){var le=(ee?ee(j):j)+d,E=(ee?ee(j):j)+c,z=u+le,Y=u+E;An[j]={},An[j][d]=z,An[j][c]=Y}function mt(j,ee,le,E){var z=E&&E.add||o,Y=E&&E.rm||a,J=E&&E.listeners||"eventListeners",ae=E&&E.rmAll||"removeAllListeners",Ue=m(z),et="."+z+":",qe="prependListener",rt="."+qe+":",dt=function(Pn,It,gi){if(!Pn.isRemoved){var jn,ei=Pn.callback;"object"==typeof ei&&ei.handleEvent&&(Pn.callback=function(Bi){return ei.handleEvent(Bi)},Pn.originalDelegate=ei);try{Pn.invoke(Pn,It,[gi])}catch(Bi){jn=Bi}var Qn=Pn.options;return Qn&&"object"==typeof Qn&&Qn.once&&It[Y].call(It,gi.type,Pn.originalDelegate?Pn.originalDelegate:Pn.callback,Qn),jn}};function Et(Pn,It,gi){if(It=It||j.event){var ei=Pn||It.target||j,jn=ei[An[It.type][gi?c:d]];if(jn){var Qn=[];if(1===jn.length)(jt=dt(jn[0],ei,It))&&Qn.push(jt);else for(var Bi=jn.slice(),xn=0;xn<Bi.length&&(!It||!0!==It[ve]);xn++){var jt;(jt=dt(Bi[xn],ei,It))&&Qn.push(jt)}if(1===Qn.length)throw Qn[0];var On=function(_i){var Ln=Qn[_i];ee.nativeScheduleMicroTask(function(){throw Ln})};for(xn=0;xn<Qn.length;xn++)On(xn)}}}var At=function(Pn){return Et(this,Pn,!1)},ln=function(Pn){return Et(this,Pn,!0)};function Yi(Pn,It){if(!Pn)return!1;var gi=!0;It&&void 0!==It.useG&&(gi=It.useG);var ei=It&&It.vh,jn=!0;It&&void 0!==It.chkDup&&(jn=It.chkDup);var Qn=!1;It&&void 0!==It.rt&&(Qn=It.rt);for(var jt=Pn;jt&&!jt.hasOwnProperty(z);)jt=e(jt);if(!jt&&Pn[z]&&(jt=Pn),!jt||jt[Ue])return!1;var or,Bi=It&&It.eventNameToString,xn={},On=jt[Ue]=jt[z],_i=jt[m(Y)]=jt[Y],Ln=jt[m(J)]=jt[J],pr=jt[m(ae)]=jt[ae];It&&It.prepend&&(or=jt[m(It.prepend)]=jt[It.prepend]);var Re=gi?function(Je){if(!xn.isExisting)return On.call(xn.target,xn.eventName,xn.capture?ln:At,xn.options)}:function(Je){return On.call(xn.target,xn.eventName,Je.invoke,xn.options)},En=gi?function(Je){if(!Je.isRemoved){var $t=An[Je.eventName],zn=void 0;$t&&(zn=$t[Je.capture?c:d]);var Rn=zn&&Je.target[zn];if(Rn)for(var ti=0;ti<Rn.length;ti++)if(Rn[ti]===Je){Rn.splice(ti,1),Je.isRemoved=!0,0===Rn.length&&(Je.allRemoved=!0,Je.target[zn]=null);break}}if(Je.allRemoved)return _i.call(Je.target,Je.eventName,Je.capture?ln:At,Je.options)}:function(Je){return _i.call(Je.target,Je.eventName,Je.invoke,Je.options)},ol=It&&It.diff?It.diff:function(Je,$t){var zn=typeof $t;return"function"===zn&&Je.callback===$t||"object"===zn&&Je.originalDelegate===$t},nt=Zone[m("UNPATCHED_EVENTS")],Ot=j[m("PASSIVE_EVENTS")],xt=function(Je,$t,zn,Rn,ti,ni){return void 0===ti&&(ti=!1),void 0===ni&&(ni=!1),function(){var ri=this||j,Ci=arguments[0];It&&It.transferEventName&&(Ci=It.transferEventName(Ci));var hr=arguments[1];if(!hr)return Je.apply(this,arguments);if(K&&"uncaughtException"===Ci)return Je.apply(this,arguments);var ko=!1;if("function"!=typeof hr){if(!hr.handleEvent)return Je.apply(this,arguments);ko=!0}if(!ei||ei(Je,hr,ri,arguments)){var Xc=wt&&!!Ot&&-1!==Ot.indexOf(Ci),eo=function(Je,$t){return!wt&&"object"==typeof Je&&Je?!!Je.capture:wt&&$t?"boolean"==typeof Je?{capture:Je,passive:!0}:Je?"object"==typeof Je&&!1!==Je.passive?Object.assign(Object.assign({},Je),{passive:!0}):Je:{passive:!0}:Je}(arguments[2],Xc);if(nt)for(var xo=0;xo<nt.length;xo++)if(Ci===nt[xo])return Xc?Je.call(ri,Ci,hr,eo):Je.apply(this,arguments);var Gr=!!eo&&("boolean"==typeof eo||eo.capture),Fm=!(!eo||"object"!=typeof eo)&&eo.once,Yie=Zone.current,VA=An[Ci];VA||(ht(Ci,Bi),VA=An[Ci]);var m4=VA[Gr?c:d],Lm=ri[m4],h4=!1;if(Lm){if(h4=!0,jn)for(xo=0;xo<Lm.length;xo++)if(ol(Lm[xo],hr))return}else Lm=ri[m4]=[];var aC,g4=ri.constructor.name,_4=St[g4];_4&&(aC=_4[Ci]),aC||(aC=g4+$t+(Bi?Bi(Ci):Ci)),xn.options=eo,Fm&&(xn.options.once=!1),xn.target=ri,xn.capture=Gr,xn.eventName=Ci,xn.isExisting=h4;var O_=gi?Oe:void 0;O_&&(O_.taskData=xn);var Zd=Yie.scheduleEventTask(aC,hr,O_,zn,Rn);if(xn.target=null,O_&&(O_.taskData=null),Fm&&(eo.once=!0),!wt&&"boolean"==typeof Zd.options||(Zd.options=eo),Zd.target=ri,Zd.capture=Gr,Zd.eventName=Ci,ko&&(Zd.originalDelegate=hr),ni?Lm.unshift(Zd):Lm.push(Zd),ti)return ri}}};return jt[z]=xt(On,et,Re,En,Qn),or&&(jt[qe]=xt(or,rt,function(Je){return or.call(xn.target,xn.eventName,Je.invoke,xn.options)},En,Qn,!0)),jt[Y]=function(){var Je=this||j,$t=arguments[0];It&&It.transferEventName&&($t=It.transferEventName($t));var zn=arguments[2],Rn=!!zn&&("boolean"==typeof zn||zn.capture),ti=arguments[1];if(!ti)return _i.apply(this,arguments);if(!ei||ei(_i,ti,Je,arguments)){var ri,ni=An[$t];ni&&(ri=ni[Rn?c:d]);var Ci=ri&&Je[ri];if(Ci)for(var hr=0;hr<Ci.length;hr++){var ko=Ci[hr];if(ol(ko,ti))return Ci.splice(hr,1),ko.isRemoved=!0,0===Ci.length&&(ko.allRemoved=!0,Je[ri]=null,"string"==typeof $t)&&(Je[u+"ON_PROPERTY"+$t]=null),ko.zone.cancelTask(ko),Qn?Je:void 0}return _i.apply(this,arguments)}},jt[J]=function(){var Je=this||j,$t=arguments[0];It&&It.transferEventName&&($t=It.transferEventName($t));for(var zn=[],Rn=oe(Je,Bi?Bi($t):$t),ti=0;ti<Rn.length;ti++){var ni=Rn[ti];zn.push(ni.originalDelegate?ni.originalDelegate:ni.callback)}return zn},jt[ae]=function(){var Je=this||j,$t=arguments[0];if($t){It&&It.transferEventName&&($t=It.transferEventName($t));var Ci=An[$t];if(Ci){var Xc=Je[Ci[d]],eo=Je[Ci[c]];if(Xc)for(var xo=Xc.slice(),Rn=0;Rn<xo.length;Rn++)this[Y].call(this,$t,(Gr=xo[Rn]).originalDelegate?Gr.originalDelegate:Gr.callback,Gr.options);if(eo)for(xo=eo.slice(),Rn=0;Rn<xo.length;Rn++){var Gr;this[Y].call(this,$t,(Gr=xo[Rn]).originalDelegate?Gr.originalDelegate:Gr.callback,Gr.options)}}}else{var zn=Object.keys(Je);for(Rn=0;Rn<zn.length;Rn++){var ni=rn.exec(zn[Rn]),ri=ni&&ni[1];ri&&"removeListener"!==ri&&this[ae].call(this,ri)}this[ae].call(this,"removeListener")}if(Qn)return this},ue(jt[z],On),ue(jt[Y],_i),pr&&ue(jt[ae],pr),Ln&&ue(jt[J],Ln),!0}for(var xi=[],fn=0;fn<le.length;fn++)xi[fn]=Yi(le[fn],E);return xi}function oe(j,ee){if(!ee){var le=[];for(var E in j){var z=rn.exec(E),Y=z&&z[1];if(Y&&(!ee||Y===ee)){var J=j[E];if(J)for(var ae=0;ae<J.length;ae++)le.push(J[ae])}}return le}var Ue=An[ee];Ue||(ht(ee),Ue=An[ee]);var et=j[Ue[d]],qe=j[Ue[c]];return et?qe?et.concat(qe):et.slice():qe?qe.slice():[]}function st(j,ee){var le=j.Event;le&&le.prototype&&ee.patchMethod(le.prototype,"stopImmediatePropagation",function(E){return function(z,Y){z[ve]=!0,E&&E.apply(z,Y)}})}function Xe(j,ee,le,E,z){var Y=Zone.__symbol__(E);if(!ee[Y]){var J=ee[Y]=ee[E];ee[E]=function(ae,Ue,et){return Ue&&Ue.prototype&&z.forEach(function(qe){var rt="".concat(le,".").concat(E,"::")+qe,dt=Ue.prototype;try{if(dt.hasOwnProperty(qe)){var Et=j.ObjectGetOwnPropertyDescriptor(dt,qe);Et&&Et.value?(Et.value=j.wrapWithCurrentZone(Et.value,rt),j._redefineProperty(Ue.prototype,qe,Et)):dt[qe]&&(dt[qe]=j.wrapWithCurrentZone(dt[qe],rt))}else dt[qe]&&(dt[qe]=j.wrapWithCurrentZone(dt[qe],rt))}catch{}}),J.call(ee,ae,Ue,et)},j.attachOriginToPatched(ee[E],J)}}function _t(j,ee,le){if(!le||0===le.length)return ee;var E=le.filter(function(Y){return Y.target===j});if(!E||0===E.length)return ee;var z=E[0].ignoreProperties;return ee.filter(function(Y){return-1===z.indexOf(Y)})}function pt(j,ee,le,E){j&&ce(j,_t(j,ee,le),E)}function on(j){return Object.getOwnPropertyNames(j).filter(function(ee){return ee.startsWith("on")&&ee.length>2}).map(function(ee){return ee.substring(2)})}function yt(j,ee,le){var E=le.configurable;return mn(j,ee,le=Be(j,ee,le),E)}function nn(j,ee){return j&&j[N]&&j[N][ee]}function Be(j,ee,le){return Object.isFrozen(le)||(le.configurable=!0),le.configurable||(!j[N]&&!Object.isFrozen(j)&&Li(j,N,{writable:!0,value:{}}),j[N]&&(j[N][ee]=!0)),le}function mn(j,ee,le,E){try{return Li(j,ee,le)}catch(J){if(!le.configurable)throw J;typeof E>"u"?delete le.configurable:le.configurable=E;try{return Li(j,ee,le)}catch(ae){var z=!1;if(("createdCallback"===ee||"attachedCallback"===ee||"detachedCallback"===ee||"attributeChangedCallback"===ee)&&(z=!0),!z)throw ae;var Y=null;try{Y=JSON.stringify(le)}catch{Y=le.toString()}console.log("Attempting to configure '".concat(ee,"' with descriptor '").concat(Y,"' on object '").concat(j,"' and got error, giving up: ").concat(ae))}}}Zone.__load_patch("util",function(j,ee,le){var E=on(j);le.patchOnProperties=ce,le.patchMethod=ne,le.bindArguments=R,le.patchMacroTask=de;var z=ee.__symbol__("BLACK_LISTED_EVENTS"),Y=ee.__symbol__("UNPATCHED_EVENTS");j[Y]&&(j[z]=j[Y]),j[z]&&(ee[z]=ee[Y]=j[z]),le.patchEventPrototype=st,le.patchEventTarget=mt,le.isIEOrEdge=ct,le.ObjectDefineProperty=t,le.ObjectGetOwnPropertyDescriptor=n,le.ObjectCreate=i,le.ArraySlice=r,le.patchClass=_e,le.wrapWithCurrentZone=p,le.filterProperties=_t,le.attachOriginToPatched=ue,le._redefineProperty=Object.defineProperty,le.patchCallbacks=Xe,le.getGlobalObjects=function(){return{globalSources:St,zoneSymbolEventNames:An,eventNames:E,isBrowser:Ce,isMix:Ze,isNode:K,TRUE_STR:c,FALSE_STR:d,ZONE_SYMBOL_PREFIX:u,ADD_EVENT_LISTENER_STR:o,REMOVE_EVENT_LISTENER_STR:a}}});var j,Uo=hu(hu(hu(hu(hu(hu(hu(hu([],["abort","animationcancel","animationend","animationiteration","auxclick","beforeinput","blur","cancel","canplay","canplaythrough","change","compositionstart","compositionupdate","compositionend","cuechange","click","close","contextmenu","curechange","dblclick","drag","dragend","dragenter","dragexit","dragleave","dragover","drop","durationchange","emptied","ended","error","focus","focusin","focusout","gotpointercapture","input","invalid","keydown","keypress","keyup","load","loadstart","loadeddata","loadedmetadata","lostpointercapture","mousedown","mouseenter","mouseleave","mousemove","mouseout","mouseover","mouseup","mousewheel","orientationchange","pause","play","playing","pointercancel","pointerdown","pointerenter","pointerleave","pointerlockchange","mozpointerlockchange","webkitpointerlockerchange","pointerlockerror","mozpointerlockerror","webkitpointerlockerror","pointermove","pointout","pointerover","pointerup","progress","ratechange","reset","resize","scroll","seeked","seeking","select","selectionchange","selectstart","show","sort","stalled","submit","suspend","timeupdate","volumechange","touchcancel","touchmove","touchstart","touchend","transitioncancel","transitionend","waiting","wheel"],!0),["webglcontextrestored","webglcontextlost","webglcontextcreationerror"],!0),["autocomplete","autocompleteerror"],!0),["toggle"],!0),["afterscriptexecute","beforescriptexecute","DOMContentLoaded","freeze","fullscreenchange","mozfullscreenchange","webkitfullscreenchange","msfullscreenchange","fullscreenerror","mozfullscreenerror","webkitfullscreenerror","msfullscreenerror","readystatechange","visibilitychange","resume"],!0),["absolutedeviceorientation","afterinput","afterprint","appinstalled","beforeinstallprompt","beforeprint","beforeunload","devicelight","devicemotion","deviceorientation","deviceorientationabsolute","deviceproximity","hashchange","languagechange","message","mozbeforepaint","offline","online","paint","pageshow","pagehide","popstate","rejectionhandled","storage","unhandledrejection","unload","userproximity","vrdisplayconnected","vrdisplaydisconnected","vrdisplaypresentchange"],!0),["beforecopy","beforecut","beforepaste","copy","cut","paste","dragstart","loadend","animationstart","search","transitionrun","transitionstart","webkitanimationend","webkitanimationiteration","webkitanimationstart","webkittransitionend"],!0),["activate","afterupdate","ariarequest","beforeactivate","beforedeactivate","beforeeditfocus","beforeupdate","cellchange","controlselect","dataavailable","datasetchanged","datasetcomplete","errorupdate","filterchange","layoutcomplete","losecapture","move","moveend","movestart","propertychange","resizeend","resizestart","rowenter","rowexit","rowsdelete","rowsinserted","command","compassneedscalibration","deactivate","help","mscontentzoom","msmanipulationstatechanged","msgesturechange","msgesturedoubletap","msgestureend","msgesturehold","msgesturestart","msgesturetap","msgotpointercapture","msinertiastart","mslostpointercapture","mspointercancel","mspointerdown","mspointerenter","mspointerhover","mspointerleave","mspointermove","mspointerout","mspointerover","mspointerup","pointerout","mssitemodejumplistitemremoved","msthumbnailclick","stop","storagecommit"],!0);(j=typeof window<"u"?window:typeof global<"u"?global:typeof self<"u"?self:{})[("legacyPatch",(j.__Zone_symbol_prefix||"__zone_symbol__")+"legacyPatch")]=function(){var E=j.Zone;E.__load_patch("defineProperty",function(z,Y,J){J._redefineProperty=yt,ii=Zone.__symbol__,Li=Object[ii("defineProperty")]=Object.defineProperty,Ni=Object[ii("getOwnPropertyDescriptor")]=Object.getOwnPropertyDescriptor,Z=Object.create,N=ii("unconfigurables"),Object.defineProperty=function(j,ee,le){if(nn(j,ee))throw new TypeError("Cannot assign to read only property '"+ee+"' of "+j);var E=le.configurable;return"prototype"!==ee&&(le=Be(j,ee,le)),mn(j,ee,le,E)},Object.defineProperties=function(j,ee){Object.keys(ee).forEach(function(J){Object.defineProperty(j,J,ee[J])});for(var le=0,E=Object.getOwnPropertySymbols(ee);le<E.length;le++){var z=E[le];Object.getOwnPropertyDescriptor(ee,z)?.enumerable&&Object.defineProperty(j,z,ee[z])}return j},Object.create=function(j,ee){return"object"==typeof ee&&!Object.isFrozen(ee)&&Object.keys(ee).forEach(function(le){ee[le]=Be(j,le,ee[le])}),Z(j,ee)},Object.getOwnPropertyDescriptor=function(j,ee){var le=Ni(j,ee);return le&&nn(j,ee)&&(le.configurable=!1),le}}),E.__load_patch("registerElement",function(z,Y,J){!function(j,ee){var le=ee.getGlobalObjects();(le.isBrowser||le.isMix)&&"registerElement"in j.document&&ee.patchCallbacks(ee,document,"Document","registerElement",["createdCallback","attachedCallback","detachedCallback","attributeChangedCallback"])}(z,J)}),E.__load_patch("EventTargetLegacy",function(z,Y,J){(function(j,ee){var le=ee.getGlobalObjects(),E=le.eventNames,z=le.globalSources,Y=le.zoneSymbolEventNames,J=le.TRUE_STR,ae=le.FALSE_STR,Ue=le.ZONE_SYMBOL_PREFIX,qe="ApplicationCache,EventSource,FileReader,InputMethodContext,MediaController,MessagePort,Node,Performance,SVGElementInstance,SharedWorker,TextTrack,TextTrackCue,TextTrackList,WebKitNamedFlow,Window,Worker,WorkerGlobalScope,XMLHttpRequest,XMLHttpRequestEventTarget,XMLHttpRequestUpload,IDBRequest,IDBOpenDBRequest,IDBDatabase,IDBTransaction,IDBCursor,DBIndex,WebSocket".split(","),rt="EventTarget",dt=[],Et=j.wtf,At="Anchor,Area,Audio,BR,Base,BaseFont,Body,Button,Canvas,Content,DList,Directory,Div,Embed,FieldSet,Font,Form,Frame,FrameSet,HR,Head,Heading,Html,IFrame,Image,Input,Keygen,LI,Label,Legend,Link,Map,Marquee,Media,Menu,Meta,Meter,Mod,OList,Object,OptGroup,Option,Output,Paragraph,Pre,Progress,Quote,Script,Select,Source,Span,Style,TableCaption,TableCell,TableCol,Table,TableRow,TableSection,TextArea,Title,Track,UList,Unknown,Video".split(",");Et?dt=At.map(function(xr){return"HTML"+xr+"Element"}).concat(qe):j[rt]?dt.push(rt):dt=qe;for(var ln=j.__Zone_disable_IE_check||!1,Yi=j.__Zone_enable_cross_context_check||!1,xi=ee.isIEOrEdge(),Pn="[object FunctionWrapper]",It="function __BROWSERTOOLS_CONSOLE_SAFEFUNC() { [native code] }",gi={MSPointerCancel:"pointercancel",MSPointerDown:"pointerdown",MSPointerEnter:"pointerenter",MSPointerHover:"pointerhover",MSPointerLeave:"pointerleave",MSPointerMove:"pointermove",MSPointerOut:"pointerout",MSPointerOver:"pointerover",MSPointerUp:"pointerup"},ei=0;ei<E.length;ei++){var Bi=Ue+((jn=E[ei])+ae),xn=Ue+(jn+J);Y[jn]={},Y[jn][ae]=Bi,Y[jn][J]=xn}for(ei=0;ei<At.length;ei++)for(var On=At[ei],_i=z[On]={},Ln=0;Ln<E.length;Ln++){var jn;_i[jn=E[Ln]]=On+".addEventListener:"+jn}var or=[];for(ei=0;ei<dt.length;ei++){var Ma=j[dt[ei]];or.push(Ma&&Ma.prototype)}ee.patchEventTarget(j,ee,or,{vh:function(xr,fr,gt,me){if(!ln&&xi)if(Yi)try{if((he=fr.toString())===Pn||he==It)return xr.apply(gt,me),!1}catch{return xr.apply(gt,me),!1}else{var he;if((he=fr.toString())===Pn||he==It)return xr.apply(gt,me),!1}else if(Yi)try{fr.toString()}catch{return xr.apply(gt,me),!1}return!0},transferEventName:function(xr){return gi[xr]||xr}}),Zone[ee.symbol("patchEventTarget")]=!!j[rt]})(z,J),function(j,ee){var le=j.getGlobalObjects();if((!le.isNode||le.isMix)&&!function(j,ee){var le=j.getGlobalObjects();if((le.isBrowser||le.isMix)&&!j.ObjectGetOwnPropertyDescriptor(HTMLElement.prototype,"onclick")&&typeof Element<"u"){var Y=j.ObjectGetOwnPropertyDescriptor(Element.prototype,"onclick");if(Y&&!Y.configurable)return!1;if(Y){j.ObjectDefineProperty(Element.prototype,"onclick",{enumerable:!0,configurable:!0,get:function(){return!0}});var ae=!!document.createElement("div").onclick;return j.ObjectDefineProperty(Element.prototype,"onclick",Y),ae}}var Ue=ee.XMLHttpRequest;if(!Ue)return!1;var et="onreadystatechange",qe=Ue.prototype,rt=j.ObjectGetOwnPropertyDescriptor(qe,et);if(rt)return j.ObjectDefineProperty(qe,et,{enumerable:!0,configurable:!0,get:function(){return!0}}),ae=!!(dt=new Ue).onreadystatechange,j.ObjectDefineProperty(qe,et,rt||{}),ae;var Et=j.symbol("fake");j.ObjectDefineProperty(qe,et,{enumerable:!0,configurable:!0,get:function(){return this[Et]},set:function(xi){this[Et]=xi}});var dt,At=function(){};return(dt=new Ue).onreadystatechange=At,ae=dt[Et]===At,dt.onreadystatechange=null,ae}(j,ee)){var Y=typeof WebSocket<"u";(function(j){for(var ee=j.symbol("unbound"),le=function(z){var Y=Uo[z],J="on"+Y;self.addEventListener(Y,function(ae){var et,qe,Ue=ae.target;for(qe=Ue?Ue.constructor.name+"."+J:"unknown."+J;Ue;)Ue[J]&&!Ue[J][ee]&&((et=j.wrapWithCurrentZone(Ue[J],qe))[ee]=Ue[J],Ue[J]=et),Ue=Ue.parentElement},!0)},E=0;E<Uo.length;E++)le(E)})(j),j.patchClass("XMLHttpRequest"),Y&&function(j,ee){var le=j.getGlobalObjects(),E=le.ADD_EVENT_LISTENER_STR,z=le.REMOVE_EVENT_LISTENER_STR,Y=ee.WebSocket;ee.EventTarget||j.patchEventTarget(ee,j,[Y.prototype]),ee.WebSocket=function(Ue,et){var rt,dt,qe=arguments.length>1?new Y(Ue,et):new Y(Ue),Et=j.ObjectGetOwnPropertyDescriptor(qe,"onmessage");return Et&&!1===Et.configurable?(rt=j.ObjectCreate(qe),dt=qe,[E,z,"send","close"].forEach(function(At){rt[At]=function(){var ln=j.ArraySlice.call(arguments);if(At===E||At===z){var Yi=ln.length>0?ln[0]:void 0;if(Yi){var xi=Zone.__symbol__("ON_PROPERTY"+Yi);qe[xi]=rt[xi]}}return qe[At].apply(qe,ln)}})):rt=qe,j.patchOnProperties(rt,["close","error","message","open"],dt),rt};var J=ee.WebSocket;for(var ae in Y)J[ae]=Y[ae]}(j,ee),Zone[j.symbol("patchEvents")]=!0}}(J,z)})};var Ca=m("zoneTask");function rl(j,ee,le,E){var z=null,Y=null;le+=E;var J={};function ae(et){var qe=et.data;return qe.args[0]=function(){return et.invoke.apply(this,arguments)},qe.handleId=z.apply(j,qe.args),et}function Ue(et){return Y.call(j,et.data.handleId)}z=ne(j,ee+=E,function(et){return function(qe,rt){if("function"==typeof rt[0]){var dt={isPeriodic:"Interval"===E,delay:"Timeout"===E||"Interval"===E?rt[1]||0:void 0,args:rt},Et=rt[0];rt[0]=function(){try{return Et.apply(this,arguments)}finally{dt.isPeriodic||("number"==typeof dt.handleId?delete J[dt.handleId]:dt.handleId&&(dt.handleId[Ca]=null))}};var At=f(ee,rt[0],dt,ae,Ue);if(!At)return At;var ln=At.data.handleId;return"number"==typeof ln?J[ln]=At:ln&&(ln[Ca]=At),ln&&ln.ref&&ln.unref&&"function"==typeof ln.ref&&"function"==typeof ln.unref&&(At.ref=ln.ref.bind(ln),At.unref=ln.unref.bind(ln)),"number"==typeof ln||ln?ln:At}return et.apply(j,rt)}}),Y=ne(j,le,function(et){return function(qe,rt){var Et,dt=rt[0];"number"==typeof dt?Et=J[dt]:(Et=dt&&dt[Ca])||(Et=dt),Et&&"string"==typeof Et.type?"notScheduled"!==Et.state&&(Et.cancelFn&&Et.data.isPeriodic||0===Et.runCount)&&("number"==typeof dt?delete J[dt]:dt&&(dt[Ca]=null),Et.zone.cancelTask(Et)):et.apply(j,rt)}})}Zone.__load_patch("legacy",function(j){var ee=j[Zone.__symbol__("legacyPatch")];ee&&ee()}),Zone.__load_patch("queueMicrotask",function(j,ee,le){le.patchMethod(j,"queueMicrotask",function(E){return function(z,Y){ee.current.scheduleMicroTask("queueMicrotask",Y[0])}})}),Zone.__load_patch("timers",function(j){var le="clear";rl(j,"set",le,"Timeout"),rl(j,"set",le,"Interval"),rl(j,"set",le,"Immediate")}),Zone.__load_patch("requestAnimationFrame",function(j){rl(j,"request","cancel","AnimationFrame"),rl(j,"mozRequest","mozCancel","AnimationFrame"),rl(j,"webkitRequest","webkitCancel","AnimationFrame")}),Zone.__load_patch("blocking",function(j,ee){for(var le=["alert","prompt","confirm"],E=0;E<le.length;E++)ne(j,le[E],function(Y,J,ae){return function(Ue,et){return ee.current.run(Y,j,et,ae)}})}),Zone.__load_patch("EventTarget",function(j,ee,le){(function(j,ee){ee.patchEventPrototype(j,ee)})(j,le),function(j,ee){if(!Zone[ee.symbol("patchEventTarget")]){for(var le=ee.getGlobalObjects(),E=le.eventNames,z=le.zoneSymbolEventNames,Y=le.TRUE_STR,J=le.FALSE_STR,ae=le.ZONE_SYMBOL_PREFIX,Ue=0;Ue<E.length;Ue++){var et=E[Ue],dt=ae+(et+J),Et=ae+(et+Y);z[et]={},z[et][J]=dt,z[et][Y]=Et}var At=j.EventTarget;At&&At.prototype&&ee.patchEventTarget(j,ee,[At&&At.prototype])}}(j,le);var E=j.XMLHttpRequestEventTarget;E&&E.prototype&&le.patchEventTarget(j,le,[E.prototype])}),Zone.__load_patch("MutationObserver",function(j,ee,le){_e("MutationObserver"),_e("WebKitMutationObserver")}),Zone.__load_patch("IntersectionObserver",function(j,ee,le){_e("IntersectionObserver")}),Zone.__load_patch("FileReader",function(j,ee,le){_e("FileReader")}),Zone.__load_patch("on_property",function(j,ee,le){!function(j,ee){if((!K||Ze)&&!Zone[j.symbol("patchEvents")]){var le=ee.__Zone_ignore_on_properties,E=[];if(Ce){var z=window;E=E.concat(["Document","SVGElement","Element","HTMLElement","HTMLBodyElement","HTMLMediaElement","HTMLFrameSetElement","HTMLFrameElement","HTMLIFrameElement","HTMLMarqueeElement","Worker"]);var Y=function(){try{var j=M.navigator.userAgent;if(-1!==j.indexOf("MSIE ")||-1!==j.indexOf("Trident/"))return!0}catch{}return!1}()?[{target:z,ignoreProperties:["error"]}]:[];pt(z,on(z),le&&le.concat(Y),e(z))}E=E.concat(["XMLHttpRequest","XMLHttpRequestEventTarget","IDBIndex","IDBRequest","IDBOpenDBRequest","IDBDatabase","IDBTransaction","IDBCursor","WebSocket"]);for(var J=0;J<E.length;J++){var ae=ee[E[J]];ae&&ae.prototype&&pt(ae.prototype,on(ae.prototype),le)}}}(le,j)}),Zone.__load_patch("customElements",function(j,ee,le){!function(j,ee){var le=ee.getGlobalObjects();(le.isBrowser||le.isMix)&&j.customElements&&"customElements"in j&&ee.patchCallbacks(ee,j.customElements,"customElements","define",["connectedCallback","disconnectedCallback","adoptedCallback","attributeChangedCallback"])}(j,le)}),Zone.__load_patch("XHR",function(j,ee){!function(et){var qe=et.XMLHttpRequest;if(qe){var rt=qe.prototype,Et=rt[s],At=rt[l];if(!Et){var ln=et.XMLHttpRequestEventTarget;if(ln){var Yi=ln.prototype;Et=Yi[s],At=Yi[l]}}var xi="readystatechange",fn="scheduled",ei=ne(rt,"open",function(){return function(On,_i){return On[E]=0==_i[2],On[J]=_i[1],ei.apply(On,_i)}}),Qn=m("fetchTaskAborting"),jt=m("fetchTaskScheduling"),Bi=ne(rt,"send",function(){return function(On,_i){if(!0===ee.current[jt]||On[E])return Bi.apply(On,_i);var Ln={target:On,url:On[J],isPeriodic:!1,args:_i,aborted:!1},pr=f("XMLHttpRequest.send",It,Ln,Pn,gi);On&&!0===On[ae]&&!Ln.aborted&&pr.state===fn&&pr.invoke()}}),xn=ne(rt,"abort",function(){return function(On,_i){var Ln=function(On){return On[le]}(On);if(Ln&&"string"==typeof Ln.type){if(null==Ln.cancelFn||Ln.data&&Ln.data.aborted)return;Ln.zone.cancelTask(Ln)}else if(!0===ee.current[Qn])return xn.apply(On,_i)}})}function Pn(On){var _i=On.data,Ln=_i.target;Ln[Y]=!1,Ln[ae]=!1;var pr=Ln[z];Et||(Et=Ln[s],At=Ln[l]),pr&&At.call(Ln,xi,pr);var or=Ln[z]=function(){if(Ln.readyState===Ln.DONE)if(!_i.aborted&&Ln[Y]&&On.state===fn){var xr=Ln[ee.__symbol__("loadfalse")];if(0!==Ln.status&&xr&&xr.length>0){var fr=On.invoke;On.invoke=function(){for(var gt=Ln[ee.__symbol__("loadfalse")],me=0;me<gt.length;me++)gt[me]===On&&gt.splice(me,1);!_i.aborted&&On.state===fn&&fr.call(On)},xr.push(On)}else On.invoke()}else!_i.aborted&&!1===Ln[Y]&&(Ln[ae]=!0)};return Et.call(Ln,xi,or),Ln[le]||(Ln[le]=On),Bi.apply(Ln,_i.args),Ln[Y]=!0,On}function It(){}function gi(On){var _i=On.data;return _i.aborted=!0,xn.apply(_i.target,_i.args)}}(j);var le=m("xhrTask"),E=m("xhrSync"),z=m("xhrListener"),Y=m("xhrScheduled"),J=m("xhrURL"),ae=m("xhrErrorBeforeScheduled")}),Zone.__load_patch("geolocation",function(j){j.navigator&&j.navigator.geolocation&&function(j,ee){for(var le=j.constructor.name,E=function(Y){var et,qe,J=ee[Y],ae=j[J];if(ae){if(!H(n(j,J)))return"continue";j[J]=(qe=function(){return et.apply(this,R(arguments,le+"."+J))},ue(qe,et=ae),qe)}},z=0;z<ee.length;z++)E(z)}(j.navigator.geolocation,["getCurrentPosition","watchPosition"])}),Zone.__load_patch("PromiseRejectionEvent",function(j,ee){function le(E){return function(z){oe(j,E).forEach(function(J){var ae=j.PromiseRejectionEvent;if(ae){var Ue=new ae(E,{promise:z.promise,reason:z.rejection});J.invoke(Ue)}})}}j.PromiseRejectionEvent&&(ee[m("unhandledPromiseRejectionHandler")]=le("unhandledrejection"),ee[m("rejectionHandledHandler")]=le("rejectionhandled"))})},"function"==typeof define&&define.amd?define(n):n()});function _n(n){return"function"==typeof n}function Nm(n){let e=n(i=>{Error.call(i),i.stack=(new Error).stack});return e.prototype=Object.create(Error.prototype),e.prototype.constructor=e,e}var sC=Nm(n=>function(e){n(this),this.message=e?`${e.length} errors occurred during unsubscription:\n${e.map((i,r)=>`${r+1}) ${i.toString()}`).join("\n  ")}`:"",this.name="UnsubscriptionError",this.errors=e});function kp(n,t){if(n){let e=n.indexOf(t);0<=e&&n.splice(e,1)}}var yn=class{constructor(t){this.initialTeardown=t,this.closed=!1,this._parentage=null,this._finalizers=null}unsubscribe(){let t;if(!this.closed){this.closed=!0;let{_parentage:e}=this;if(e)if(this._parentage=null,Array.isArray(e))for(let o of e)o.remove(this);else e.remove(this);let{initialTeardown:i}=this;if(_n(i))try{i()}catch(o){t=o instanceof sC?o.errors:[o]}let{_finalizers:r}=this;if(r){this._finalizers=null;for(let o of r)try{v4(o)}catch(a){t=t??[],a instanceof sC?t=[...t,...a.errors]:t.push(a)}}if(t)throw new sC(t)}}add(t){var e;if(t&&t!==this)if(this.closed)v4(t);else{if(t instanceof yn){if(t.closed||t._hasParent(this))return;t._addParent(this)}(this._finalizers=null!==(e=this._finalizers)&&void 0!==e?e:[]).push(t)}}_hasParent(t){let{_parentage:e}=this;return e===t||Array.isArray(e)&&e.includes(t)}_addParent(t){let{_parentage:e}=this;this._parentage=Array.isArray(e)?(e.push(t),e):e?[e,t]:t}_removeParent(t){let{_parentage:e}=this;e===t?this._parentage=null:Array.isArray(e)&&kp(e,t)}remove(t){let{_finalizers:e}=this;e&&kp(e,t),t instanceof yn&&t._removeParent(this)}};yn.EMPTY=(()=>{let n=new yn;return n.closed=!0,n})();var UA=yn.EMPTY;function lC(n){return n instanceof yn||n&&"closed"in n&&_n(n.remove)&&_n(n.add)&&_n(n.unsubscribe)}function v4(n){_n(n)?n():n.unsubscribe()}var al={onUnhandledError:null,onStoppedNotification:null,Promise:void 0,useDeprecatedSynchronousErrorHandling:!1,useDeprecatedNextContext:!1},Bm={setTimeout(n,t,...e){let{delegate:i}=Bm;return i?.setTimeout?i.setTimeout(n,t,...e):setTimeout(n,t,...e)},clearTimeout(n){let{delegate:t}=Bm;return(t?.clearTimeout||clearTimeout)(n)},delegate:void 0};function cC(n){Bm.setTimeout(()=>{let{onUnhandledError:t}=al;if(!t)throw n;t(n)})}function sl(){}var x4=jA("C",void 0,void 0);function jA(n,t,e){return{kind:n,value:t,error:e}}var Pp=null;function Vm(n){if(al.useDeprecatedSynchronousErrorHandling){let t=!Pp;if(t&&(Pp={errorThrown:!1,error:null}),n(),t){let{errorThrown:e,error:i}=Pp;if(Pp=null,e)throw i}}else n()}var Op=class extends yn{constructor(t){super(),this.isStopped=!1,t?(this.destination=t,lC(t)&&t.add(this)):this.destination=nre}static create(t,e,i){return new ll(t,e,i)}next(t){this.isStopped?WA(jA("N",t,void 0),this):this._next(t)}error(t){this.isStopped?WA(jA("E",void 0,t),this):(this.isStopped=!0,this._error(t))}complete(){this.isStopped?WA(x4,this):(this.isStopped=!0,this._complete())}unsubscribe(){this.closed||(this.isStopped=!0,super.unsubscribe(),this.destination=null)}_next(t){this.destination.next(t)}_error(t){try{this.destination.error(t)}finally{this.unsubscribe()}}_complete(){try{this.destination.complete()}finally{this.unsubscribe()}}},ere=Function.prototype.bind;function GA(n,t){return ere.call(n,t)}var ll=class extends Op{constructor(t,e,i){let r;if(super(),_n(t)||!t)r={next:t??void 0,error:e??void 0,complete:i??void 0};else{let o;this&&al.useDeprecatedNextContext?(o=Object.create(t),o.unsubscribe=()=>this.unsubscribe(),r={next:t.next&&GA(t.next,o),error:t.error&&GA(t.error,o),complete:t.complete&&GA(t.complete,o)}):r=t}this.destination=new class{constructor(t){this.partialObserver=t}next(t){let{partialObserver:e}=this;if(e.next)try{e.next(t)}catch(i){dC(i)}}error(t){let{partialObserver:e}=this;if(e.error)try{e.error(t)}catch(i){dC(i)}else dC(t)}complete(){let{partialObserver:t}=this;if(t.complete)try{t.complete()}catch(e){dC(e)}}}(r)}};function dC(n){al.useDeprecatedSynchronousErrorHandling?function(n){al.useDeprecatedSynchronousErrorHandling&&Pp&&(Pp.errorThrown=!0,Pp.error=n)}(n):cC(n)}function WA(n,t){let{onStoppedNotification:e}=al;e&&Bm.setTimeout(()=>e(n,t))}var nre={closed:!0,next:sl,error:function(n){throw n},complete:sl},Hm="function"==typeof Symbol&&Symbol.observable||"@@observable";function la(n){return n}function XA(n){return 0===n.length?la:1===n.length?n[0]:function(e){return n.reduce((i,r)=>r(i),e)}}var en=(()=>{class n{constructor(e){e&&(this._subscribe=e)}lift(e){let i=new n;return i.source=this,i.operator=e,i}subscribe(e,i,r){let o=function(n){return n&&n instanceof Op||function(n){return n&&_n(n.next)&&_n(n.error)&&_n(n.complete)}(n)&&lC(n)}(e)?e:new ll(e,i,r);return Vm(()=>{let{operator:a,source:s}=this;o.add(a?a.call(o,s):s?this._subscribe(o):this._trySubscribe(o))}),o}_trySubscribe(e){try{return this._subscribe(e)}catch(i){e.error(i)}}forEach(e,i){return new(i=S4(i))((r,o)=>{let a=new ll({next:s=>{try{e(s)}catch(l){o(l),a.unsubscribe()}},error:o,complete:r});this.subscribe(a)})}_subscribe(e){var i;return null===(i=this.source)||void 0===i?void 0:i.subscribe(e)}[Hm](){return this}pipe(...e){return XA(e)(this)}toPromise(e){return new(e=S4(e))((i,r)=>{let o;this.subscribe(a=>o=a,a=>r(a),()=>i(o))})}}return n.create=t=>new n(t),n})();function S4(n){var t;return null!==(t=n??al.Promise)&&void 0!==t?t:Promise}function QA(n){return _n(n?.lift)}function Kt(n){return t=>{if(QA(t))return t.lift(function(e){try{return n(e,this)}catch(i){this.error(i)}});throw new TypeError("Unable to lift unknown Observable type")}}function Ht(n,t,e,i,r){return new F_(n,t,e,i,r)}var ZA,F_=class extends Op{constructor(t,e,i,r,o,a){super(t),this.onFinalize=o,this.shouldUnsubscribe=a,this._next=e?function(s){try{e(s)}catch(l){t.error(l)}}:super._next,this._error=r?function(s){try{r(s)}catch(l){t.error(l)}finally{this.unsubscribe()}}:super._error,this._complete=i?function(){try{i()}catch(s){t.error(s)}finally{this.unsubscribe()}}:super._complete}unsubscribe(){var t;if(!this.shouldUnsubscribe||this.shouldUnsubscribe()){let{closed:e}=this;super.unsubscribe(),!e&&(null===(t=this.onFinalize)||void 0===t||t.call(this))}}},L_=class extends en{constructor(t,e){super(),this.source=t,this.subjectFactory=e,this._subject=null,this._refCount=0,this._connection=null,QA(t)&&(this.lift=t.lift)}_subscribe(t){return this.getSubject().subscribe(t)}getSubject(){let t=this._subject;return(!t||t.isStopped)&&(this._subject=this.subjectFactory()),this._subject}_teardown(){this._refCount=0;let{_connection:t}=this;this._subject=this._connection=null,t?.unsubscribe()}connect(){let t=this._connection;if(!t){t=this._connection=new yn;let e=this.getSubject();t.add(this.source.subscribe(Ht(e,void 0,()=>{this._teardown(),e.complete()},i=>{this._teardown(),e.error(i)},()=>this._teardown()))),t.closed&&(this._connection=null,t=yn.EMPTY)}return t}refCount(){return Kt((n,t)=>{let e=null;n._refCount++;let i=Ht(t,void 0,void 0,void 0,()=>{if(!n||n._refCount<=0||0<--n._refCount)return void(e=null);let r=n._connection,o=e;e=null,r&&(!o||r===o)&&r.unsubscribe(),t.unsubscribe()});n.subscribe(i),i.closed||(e=n.connect())})(this)}},zm={schedule(n){let t=requestAnimationFrame,e=cancelAnimationFrame,{delegate:i}=zm;i&&(t=i.requestAnimationFrame,e=i.cancelAnimationFrame);let r=t(o=>{e=void 0,n(o)});return new yn(()=>e?.(r))},requestAnimationFrame(...n){let{delegate:t}=zm;return(t?.requestAnimationFrame||requestAnimationFrame)(...n)},cancelAnimationFrame(...n){let{delegate:t}=zm;return(t?.cancelAnimationFrame||cancelAnimationFrame)(...n)},delegate:void 0},T4=Nm(n=>function(){n(this),this.name="ObjectUnsubscribedError",this.message="object unsubscribed"}),Ae=(()=>{class n extends en{constructor(){super(),this.closed=!1,this.currentObservers=null,this.observers=[],this.isStopped=!1,this.hasError=!1,this.thrownError=null}lift(e){let i=new uC(this,this);return i.operator=e,i}_throwIfClosed(){if(this.closed)throw new T4}next(e){Vm(()=>{if(this._throwIfClosed(),!this.isStopped){this.currentObservers||(this.currentObservers=Array.from(this.observers));for(let i of this.currentObservers)i.next(e)}})}error(e){Vm(()=>{if(this._throwIfClosed(),!this.isStopped){this.hasError=this.isStopped=!0,this.thrownError=e;let{observers:i}=this;for(;i.length;)i.shift().error(e)}})}complete(){Vm(()=>{if(this._throwIfClosed(),!this.isStopped){this.isStopped=!0;let{observers:e}=this;for(;e.length;)e.shift().complete()}})}unsubscribe(){this.isStopped=this.closed=!0,this.observers=this.currentObservers=null}get observed(){var e;return(null===(e=this.observers)||void 0===e?void 0:e.length)>0}_trySubscribe(e){return this._throwIfClosed(),super._trySubscribe(e)}_subscribe(e){return this._throwIfClosed(),this._checkFinalizedStatuses(e),this._innerSubscribe(e)}_innerSubscribe(e){let{hasError:i,isStopped:r,observers:o}=this;return i||r?UA:(this.currentObservers=null,o.push(e),new yn(()=>{this.currentObservers=null,kp(o,e)}))}_checkFinalizedStatuses(e){let{hasError:i,thrownError:r,isStopped:o}=this;i?e.error(r):o&&e.complete()}asObservable(){let e=new en;return e.source=this,e}}return n.create=(t,e)=>new uC(t,e),n})(),uC=class extends Ae{constructor(t,e){super(),this.destination=t,this.source=e}next(t){var e,i;null===(i=null===(e=this.destination)||void 0===e?void 0:e.next)||void 0===i||i.call(e,t)}error(t){var e,i;null===(i=null===(e=this.destination)||void 0===e?void 0:e.error)||void 0===i||i.call(e,t)}complete(){var t,e;null===(e=null===(t=this.destination)||void 0===t?void 0:t.complete)||void 0===e||e.call(t)}_subscribe(t){var e,i;return null!==(i=null===(e=this.source)||void 0===e?void 0:e.subscribe(t))&&void 0!==i?i:UA}},Ri=class extends Ae{constructor(t){super(),this._value=t}get value(){return this.getValue()}_subscribe(t){let e=super._subscribe(t);return!e.closed&&t.next(this._value),e}getValue(){let{hasError:t,thrownError:e,_value:i}=this;if(t)throw e;return this._throwIfClosed(),i}next(t){super.next(this._value=t)}},N_={now:()=>(N_.delegate||Date).now(),delegate:void 0},Fp=class extends Ae{constructor(t=1/0,e=1/0,i=N_){super(),this._bufferSize=t,this._windowTime=e,this._timestampProvider=i,this._buffer=[],this._infiniteTimeWindow=!0,this._infiniteTimeWindow=e===1/0,this._bufferSize=Math.max(1,t),this._windowTime=Math.max(1,e)}next(t){let{isStopped:e,_buffer:i,_infiniteTimeWindow:r,_timestampProvider:o,_windowTime:a}=this;e||(i.push(t),!r&&i.push(o.now()+a)),this._trimBuffer(),super.next(t)}_subscribe(t){this._throwIfClosed(),this._trimBuffer();let e=this._innerSubscribe(t),{_infiniteTimeWindow:i,_buffer:r}=this,o=r.slice();for(let a=0;a<o.length&&!t.closed;a+=i?1:2)t.next(o[a]);return this._checkFinalizedStatuses(t),e}_trimBuffer(){let{_bufferSize:t,_timestampProvider:e,_buffer:i,_infiniteTimeWindow:r}=this,o=(r?1:2)*t;if(t<1/0&&o<i.length&&i.splice(0,i.length-o),!r){let a=e.now(),s=0;for(let l=1;l<i.length&&i[l]<=a;l+=2)s=l;s&&i.splice(0,s+1)}}},pC=class extends yn{constructor(t,e){super()}schedule(t,e=0){return this}},B_={setInterval(n,t,...e){let{delegate:i}=B_;return i?.setInterval?i.setInterval(n,t,...e):setInterval(n,t,...e)},clearInterval(n){let{delegate:t}=B_;return(t?.clearInterval||clearInterval)(n)},delegate:void 0},$l=class extends pC{constructor(t,e){super(t,e),this.scheduler=t,this.work=e,this.pending=!1}schedule(t,e=0){var i;if(this.closed)return this;this.state=t;let r=this.id,o=this.scheduler;return null!=r&&(this.id=this.recycleAsyncId(o,r,e)),this.pending=!0,this.delay=e,this.id=null!==(i=this.id)&&void 0!==i?i:this.requestAsyncId(o,this.id,e),this}requestAsyncId(t,e,i=0){return B_.setInterval(t.flush.bind(t,this),i)}recycleAsyncId(t,e,i=0){if(null!=i&&this.delay===i&&!1===this.pending)return e;null!=e&&B_.clearInterval(e)}execute(t,e){if(this.closed)return new Error("executing a cancelled action");this.pending=!1;let i=this._execute(t,e);if(i)return i;!1===this.pending&&null!=this.id&&(this.id=this.recycleAsyncId(this.scheduler,this.id,null))}_execute(t,e){let r,i=!1;try{this.work(t)}catch(o){i=!0,r=o||new Error("Scheduled action threw falsy error")}if(i)return this.unsubscribe(),r}unsubscribe(){if(!this.closed){let{id:t,scheduler:e}=this,{actions:i}=e;this.work=this.state=this.scheduler=null,this.pending=!1,kp(i,this),null!=t&&(this.id=this.recycleAsyncId(e,t,null)),this.delay=null,super.unsubscribe()}}},ore=1,KA={};function D4(n){return n in KA&&(delete KA[n],!0)}var I4={setImmediate(n){let t=ore++;return KA[t]=!0,ZA||(ZA=Promise.resolve()),ZA.then(()=>D4(t)&&n()),t},clearImmediate(n){D4(n)}},{setImmediate:are,clearImmediate:sre}=I4,V_={setImmediate(...n){let{delegate:t}=V_;return(t?.setImmediate||are)(...n)},clearImmediate(n){let{delegate:t}=V_;return(t?.clearImmediate||sre)(n)},delegate:void 0},Kd=class{constructor(t,e=Kd.now){this.schedulerActionCtor=t,this.now=e}schedule(t,e=0,i){return new this.schedulerActionCtor(this,t).schedule(i,e)}};Kd.now=N_.now;var ec=class extends Kd{constructor(t,e=Kd.now){super(t,e),this.actions=[],this._active=!1}flush(t){let i,{actions:e}=this;if(this._active)e.push(t);else{this._active=!0;do{if(i=t.execute(t.state,t.delay))break}while(t=e.shift());if(this._active=!1,i){for(;t=e.shift();)t.unsubscribe();throw i}}}},Um=new class extends ec{flush(t){this._active=!0;let e=this._scheduled;this._scheduled=void 0;let r,{actions:i}=this;t=t||i.shift();do{if(r=t.execute(t.state,t.delay))break}while((t=i[0])&&t.id===e&&i.shift());if(this._active=!1,r){for(;(t=i[0])&&t.id===e&&i.shift();)t.unsubscribe();throw r}}}(class extends $l{constructor(t,e){super(t,e),this.scheduler=t,this.work=e}requestAsyncId(t,e,i=0){return null!==i&&i>0?super.requestAsyncId(t,e,i):(t.actions.push(this),t._scheduled||(t._scheduled=V_.setImmediate(t.flush.bind(t,void 0))))}recycleAsyncId(t,e,i=0){var r;if(null!=i?i>0:this.delay>0)return super.recycleAsyncId(t,e,i);let{actions:o}=t;null!=e&&(null===(r=o[o.length-1])||void 0===r?void 0:r.id)!==e&&(V_.clearImmediate(e),t._scheduled=void 0)}}),Qc=new ec($l),A4=Qc,JA=new class extends ec{}(class extends $l{constructor(t,e){super(t,e),this.scheduler=t,this.work=e}schedule(t,e=0){return e>0?super.schedule(t,e):(this.delay=e,this.state=t,this.scheduler.flush(this),this)}execute(t,e){return e>0||this.closed?super.execute(t,e):this._execute(t,e)}requestAsyncId(t,e,i=0){return null!=i&&i>0||null==i&&this.delay>0?super.requestAsyncId(t,e,i):(t.flush(this),0)}}),$A=new class extends ec{flush(t){this._active=!0;let e=this._scheduled;this._scheduled=void 0;let r,{actions:i}=this;t=t||i.shift();do{if(r=t.execute(t.state,t.delay))break}while((t=i[0])&&t.id===e&&i.shift());if(this._active=!1,r){for(;(t=i[0])&&t.id===e&&i.shift();)t.unsubscribe();throw r}}}(class extends $l{constructor(t,e){super(t,e),this.scheduler=t,this.work=e}requestAsyncId(t,e,i=0){return null!==i&&i>0?super.requestAsyncId(t,e,i):(t.actions.push(this),t._scheduled||(t._scheduled=zm.requestAnimationFrame(()=>t.flush(void 0))))}recycleAsyncId(t,e,i=0){var r;if(null!=i?i>0:this.delay>0)return super.recycleAsyncId(t,e,i);let{actions:o}=t;null!=e&&(null===(r=o[o.length-1])||void 0===r?void 0:r.id)!==e&&(zm.cancelAnimationFrame(e),t._scheduled=void 0)}}),to=new en(n=>n.complete());function bC(n){return n&&_n(n.schedule)}function eR(n){return n[n.length-1]}function tc(n){return _n(eR(n))?n.pop():void 0}function nc(n){return bC(eR(n))?n.pop():void 0}var rH=b4(iH(),1),{__decorate:oH,__awaiter:aH,__await:MC,__asyncGenerator:sH,__asyncValues:lH}=rH.default,Gm=n=>n&&"number"==typeof n.length&&"function"!=typeof n;function wC(n){return _n(n?.then)}function SC(n){return _n(n[Hm])}function EC(n){return Symbol.asyncIterator&&_n(n?.[Symbol.asyncIterator])}function TC(n){return new TypeError(`You provided ${null!==n&&"object"==typeof n?"an invalid object":`'${n}'`} where a stream was expected. You can provide an Observable, Promise, ReadableStream, Array, AsyncIterable, or Iterable.`)}var DC="function"==typeof Symbol&&Symbol.iterator?Symbol.iterator:"@@iterator";function IC(n){return _n(n?.[DC])}function AC(n){return sH(this,arguments,function*(){let e=n.getReader();try{for(;;){let{value:i,done:r}=yield MC(e.read());if(r)return yield MC(void 0);yield yield MC(i)}}finally{e.releaseLock()}})}function RC(n){return _n(n?.getReader)}function oi(n){if(n instanceof en)return n;if(null!=n){if(SC(n))return function(n){return new en(t=>{let e=n[Hm]();if(_n(e.subscribe))return e.subscribe(t);throw new TypeError("Provided object does not correctly implement Symbol.observable")})}(n);if(Gm(n))return function(n){return new en(t=>{for(let e=0;e<n.length&&!t.closed;e++)t.next(n[e]);t.complete()})}(n);if(wC(n))return function(n){return new en(t=>{n.then(e=>{t.closed||(t.next(e),t.complete())},e=>t.error(e)).then(null,cC)})}(n);if(EC(n))return cH(n);if(IC(n))return function(n){return new en(t=>{for(let e of n)if(t.next(e),t.closed)return;t.complete()})}(n);if(RC(n))return function(n){return cH(AC(n))}(n)}throw TC(n)}function cH(n){return new en(t=>{(function(n,t){var e,i,r,o;return aH(this,void 0,void 0,function*(){try{for(e=lH(n);!(i=yield e.next()).done;)if(t.next(i.value),t.closed)return}catch(a){r={error:a}}finally{try{i&&!i.done&&(o=e.return)&&(yield o.call(e))}finally{if(r)throw r.error}}t.complete()})})(n,t).catch(e=>t.error(e))})}function wa(n,t,e,i=0,r=!1){let o=t.schedule(function(){e(),r?n.add(this.schedule(null,i)):this.unsubscribe()},i);if(n.add(o),!r)return o}function Lp(n,t=0){return Kt((e,i)=>{e.subscribe(Ht(i,r=>wa(i,n,()=>i.next(r),t),()=>wa(i,n,()=>i.complete(),t),r=>wa(i,n,()=>i.error(r),t)))})}function kC(n,t=0){return Kt((e,i)=>{i.add(n.schedule(()=>e.subscribe(i),t))})}function PC(n,t){if(!n)throw new Error("Iterable cannot be null");return new en(e=>{wa(e,t,()=>{let i=n[Symbol.asyncIterator]();wa(e,t,()=>{i.next().then(r=>{r.done?e.complete():e.next(r.value)})},0,!0)})})}function no(n,t){return t?function(n,t){if(null!=n){if(SC(n))return function(n,t){return oi(n).pipe(kC(t),Lp(t))}(n,t);if(Gm(n))return function(n,t){return new en(e=>{let i=0;return t.schedule(function(){i===n.length?e.complete():(e.next(n[i++]),e.closed||this.schedule())})})}(n,t);if(wC(n))return function(n,t){return oi(n).pipe(kC(t),Lp(t))}(n,t);if(EC(n))return PC(n,t);if(IC(n))return function(n,t){return new en(e=>{let i;return wa(e,t,()=>{i=n[DC](),wa(e,t,()=>{let r,o;try{({value:r,done:o}=i.next())}catch(a){return void e.error(a)}o?e.complete():e.next(r)},0,!0)}),()=>_n(i?.return)&&i.return()})}(n,t);if(RC(n))return function(n,t){return PC(AC(n),t)}(n,t)}throw TC(n)}(n,t):oi(n)}function qt(...n){return no(n,nc(n))}function cl(n,t){let e=_n(n)?n:()=>n,i=r=>r.error(e());return new en(t?r=>t.schedule(i,0,r):i)}var vs=class{constructor(t,e,i){this.kind=t,this.value=e,this.error=i,this.hasValue="N"===t}observe(t){return nR(this,t)}do(t,e,i){let{kind:r,value:o,error:a}=this;return"N"===r?t?.(o):"E"===r?e?.(a):i?.()}accept(t,e,i){var r;return _n(null===(r=t)||void 0===r?void 0:r.next)?this.observe(t):this.do(t,e,i)}toObservable(){let{kind:t,value:e,error:i}=this,r="N"===t?qt(e):"E"===t?cl(()=>i):"C"===t?to:0;if(!r)throw new TypeError(`Unexpected notification kind ${t}`);return r}static createNext(t){return new vs("N",t)}static createError(t){return new vs("E",void 0,t)}static createComplete(){return vs.completeNotification}};function nR(n,t){var e,i,r;let{kind:o,value:a,error:s}=n;if("string"!=typeof o)throw new TypeError('Invalid notification, missing "kind"');"N"===o?null===(e=t.next)||void 0===e||e.call(t,a):"E"===o?null===(i=t.error)||void 0===i||i.call(t,s):null===(r=t.complete)||void 0===r||r.call(t)}function H_(n){return!!n&&(n instanceof en||_n(n.lift)&&_n(n.subscribe))}vs.completeNotification=new vs("C");var Wm=Nm(n=>function(){n(this),this.name="EmptyError",this.message="no elements in sequence"});function OC(n,t){let e="object"==typeof t;return new Promise((i,r)=>{let o=new ll({next:a=>{i(a),o.unsubscribe()},error:r,complete:()=>{e?i(t.defaultValue):r(new Wm)}});n.subscribe(o)})}function U(n,t){return Kt((e,i)=>{let r=0;e.subscribe(Ht(i,o=>{i.next(n.call(t,o,r++))}))})}var{isArray:hre}=Array;function Jd(n){return U(t=>function(n,t){return hre(t)?n(...t):n(t)}(n,t))}var{isArray:_re}=Array,{getPrototypeOf:yre,prototype:bre,keys:vre}=Object;function FC(n){if(1===n.length){let t=n[0];if(_re(t))return{args:t,keys:null};if(function(n){return n&&"object"==typeof n&&yre(n)===bre}(t)){let e=vre(t);return{args:e.map(i=>t[i]),keys:e}}}return{args:n,keys:null}}function LC(n,t){return n.reduce((e,i,r)=>(e[i]=t[r],e),{})}function un(...n){let t=nc(n),e=tc(n),{args:i,keys:r}=FC(n);if(0===i.length)return no([],t);let o=new en(iR(i,t,r?a=>LC(r,a):la));return e?o.pipe(Jd(e)):o}function iR(n,t,e=la){return i=>{_H(t,()=>{let{length:r}=n,o=new Array(r),a=r,s=r;for(let l=0;l<r;l++)_H(t,()=>{let c=no(n[l],t),d=!1;c.subscribe(Ht(i,u=>{o[l]=u,d||(d=!0,s--),s||i.next(e(o.slice()))},()=>{--a||i.complete()}))},i)},i)}}function _H(n,t,e){n?wa(e,n,t):t()}function hn(n,t,e=1/0){return _n(t)?hn((i,r)=>U((o,a)=>t(i,o,r,a))(oi(n(i,r))),e):("number"==typeof t&&(e=t),Kt((i,r)=>function(n,t,e,i,r,o,a,s){let l=[],c=0,d=0,u=!1,p=()=>{u&&!l.length&&!c&&t.complete()},f=y=>c<i?m(y):l.push(y),m=y=>{c++;let M=!1;oi(e(y,d++)).subscribe(Ht(t,v=>{t.next(v)},()=>{M=!0},void 0,()=>{if(M)try{for(c--;l.length&&c<i;){let v=l.shift();m(v)}p()}catch(v){t.error(v)}}))};return n.subscribe(Ht(t,f,()=>{u=!0,p()})),()=>{}}(i,r,n,e)))}function NC(n=1/0){return hn(la,n)}function $d(...n){return NC(1)(no(n,nc(n)))}function Ka(n){return new en(t=>{oi(n()).subscribe(t)})}function po(...n){let t=tc(n),{args:e,keys:i}=FC(n),r=new en(o=>{let{length:a}=e;if(!a)return void o.complete();let s=new Array(a),l=a,c=a;for(let d=0;d<a;d++){let u=!1;oi(e[d]).subscribe(Ht(o,p=>{u||(u=!0,c--),s[d]=p},()=>l--,void 0,()=>{(!l||!u)&&(c||o.next(i?LC(i,s):s),o.complete())}))}});return t?r.pipe(Jd(t)):r}var Cre=["addListener","removeListener"],Mre=["addEventListener","removeEventListener"],wre=["on","off"];function ai(n,t,e,i){if(_n(e)&&(i=e,e=void 0),i)return ai(n,t,e).pipe(Jd(i));let[r,o]=function(n){return _n(n.addEventListener)&&_n(n.removeEventListener)}(n)?Mre.map(a=>s=>n[a](t,s,e)):function(n){return _n(n.addListener)&&_n(n.removeListener)}(n)?Cre.map(vH(n,t)):function(n){return _n(n.on)&&_n(n.off)}(n)?wre.map(vH(n,t)):[];if(!r&&Gm(n))return hn(a=>ai(a,t,e))(oi(n));if(!r)throw new TypeError("Invalid event target");return new en(a=>{let s=(...l)=>a.next(1<l.length?l:l[0]);return r(s),()=>o(s)})}function vH(n,t){return e=>i=>n[e](t,i)}function Ja(n=0,t,e=A4){let i=-1;return null!=t&&(bC(t)?e=t:i=t),new en(r=>{let o=function(n){return n instanceof Date&&!isNaN(n)}(n)?+n-e.now():n;o<0&&(o=0);let a=0;return e.schedule(function(){r.closed||(r.next(a++),0<=i?this.schedule(void 0,i):r.complete())},o)})}function cn(...n){let t=nc(n),e=function(n,t){return"number"==typeof eR(n)?n.pop():1/0}(n),i=n;return i.length?1===i.length?oi(i[0]):NC(e)(no(i,t)):to}var{isArray:Dre}=Array;function BC(n){return 1===n.length&&Dre(n[0])?n[0]:n}function Ve(n,t){return Kt((e,i)=>{let r=0;e.subscribe(Ht(i,o=>n.call(t,o,r++)&&i.next(o)))})}function ic(n,t=Qc){return function(n){return Kt((t,e)=>{let i=!1,r=null,o=null,a=!1,s=()=>{if(o?.unsubscribe(),o=null,i){i=!1;let c=r;r=null,e.next(c)}a&&e.complete()},l=()=>{o=null,a&&e.complete()};t.subscribe(Ht(e,c=>{i=!0,r=c,o||oi(n()).subscribe(o=Ht(e,s,l))},()=>{a=!0,(!i||!o||o.closed)&&e.complete()}))})}(()=>Ja(n,t))}function fo(n){return Kt((t,e)=>{let o,i=null,r=!1;i=t.subscribe(Ht(e,void 0,void 0,a=>{o=oi(n(a,fo(n)(t))),i?(i.unsubscribe(),i=null,o.subscribe(e)):r=!0})),r&&(i.unsubscribe(),i=null,o.subscribe(e))})}function aR(...n){let t=tc(n);return t?function(...n){return XA(n)}(aR(...n),Jd(t)):Kt((e,i)=>{iR([e,...BC(n)])(i)})}function Vi(...n){return aR(...n)}function Cr(n,t=Qc){return Kt((e,i)=>{let r=null,o=null,a=null,s=()=>{if(r){r.unsubscribe(),r=null;let c=o;o=null,i.next(c)}};function l(){let c=a+n,d=t.now();if(d<c)return r=this.schedule(void 0,c-d),void i.add(r);s()}e.subscribe(Ht(i,c=>{o=c,a=t.now(),r||(r=t.schedule(l,n),i.add(r))},()=>{s(),i.complete()},void 0,()=>{o=r=null}))})}function zt(n){return n<=0?()=>to:Kt((t,e)=>{let i=0;t.subscribe(Ht(e,r=>{++i<=n&&(e.next(r),n<=i&&e.complete())}))})}function z_(){return Kt((n,t)=>{n.subscribe(Ht(t,sl))})}function qm(n,t){return t?e=>$d(t.pipe(zt(1),z_()),e.pipe(qm(n))):hn((e,i)=>n(e,i).pipe(zt(1),function(n){return U(()=>n)}(e)))}function xs(n,t=Qc){let e=Ja(n,t);return qm(()=>e)}function ui(n,t=la){return n=n??Ire,Kt((e,i)=>{let r,o=!0;e.subscribe(Ht(i,a=>{let s=t(a);(o||!n(r,s))&&(o=!1,r=s,i.next(a))}))})}function Ire(n,t){return n===t}function SH(n=Are){return Kt((t,e)=>{let i=!1;t.subscribe(Ht(e,r=>{i=!0,e.next(r)},()=>i?e.complete():e.error(n())))})}function Are(){return new Wm}function HC(n,t){return t?e=>e.pipe(HC((i,r)=>oi(n(i,r)).pipe(U((o,a)=>t(i,o,r,a))))):Kt((e,i)=>{let r=0,o=null,a=!1;e.subscribe(Ht(i,s=>{o||(o=Ht(i,void 0,()=>{o=null,a&&i.complete()}),oi(n(s,r++)).subscribe(o))},()=>{a=!0,!o&&i.complete()}))})}function UC(n,t,e,i){return Kt((r,o)=>{let a;t&&"function"!=typeof t?({duration:e,element:a,connector:i}=t):a=t;let s=new Map,l=m=>{s.forEach(m),m(o)},c=m=>l(y=>y.error(m)),d=0,u=!1,p=new F_(o,m=>{try{let y=n(m),M=s.get(y);if(!M){s.set(y,M=i?i():new Ae);let v=function(m,y){let M=new en(v=>{d++;let x=y.subscribe(v);return()=>{x.unsubscribe(),0==--d&&u&&p.unsubscribe()}});return M.key=m,M}(y,M);if(o.next(v),e){let x=Ht(M,()=>{M.complete(),x?.unsubscribe()},void 0,void 0,()=>s.delete(y));p.add(oi(e(v)).subscribe(x))}}M.next(a?a(m):m)}catch(y){c(y)}},()=>l(m=>m.complete()),c,()=>s.clear(),()=>(u=!0,0===d));r.subscribe(p)})}function Ym(){return Kt((n,t)=>{let e,i=!1;n.subscribe(Ht(t,r=>{let o=e;e=r,i&&t.next([o,r]),i=!0}))})}function Sa(n={}){let{connector:t=(()=>new Ae),resetOnError:e=!0,resetOnComplete:i=!0,resetOnRefCountZero:r=!0}=n;return o=>{let a,s,l,c=0,d=!1,u=!1,p=()=>{s?.unsubscribe(),s=void 0},f=()=>{p(),a=l=void 0,d=u=!1},m=()=>{let y=a;f(),y?.unsubscribe()};return Kt((y,M)=>{c++,!u&&!d&&p();let v=l=l??t();M.add(()=>{c--,0===c&&!u&&!d&&(s=fR(m,r))}),v.subscribe(M),!a&&c>0&&(a=new ll({next:x=>v.next(x),error:x=>{u=!0,p(),s=fR(f,e,x),v.error(x)},complete:()=>{d=!0,p(),s=fR(f,i),v.complete()}}),oi(y).subscribe(a))})(o)}}function fR(n,t,...e){if(!0===t)return void n();if(!1===t)return;let i=new ll({next:()=>{i.unsubscribe(),n()}});return t(...e).subscribe(i)}function Ea(n,t,e){let i,r=!1;return n&&"object"==typeof n?({bufferSize:i=1/0,windowTime:t=1/0,refCount:r=!1,scheduler:e}=n):i=n??1/0,Sa({connector:()=>new Fp(i,t,e),resetOnError:!0,resetOnComplete:!1,resetOnRefCountZero:r})}function $a(n){return Ve((t,e)=>n<=e)}function Nn(...n){let t=nc(n);return Kt((e,i)=>{(t?$d(n,e,t):$d(n,e)).subscribe(i)})}function yi(n,t){return Kt((e,i)=>{let r=null,o=0,a=!1,s=()=>a&&!r&&i.complete();e.subscribe(Ht(i,l=>{r?.unsubscribe();let c=0,d=o++;oi(n(l,d)).subscribe(r=Ht(i,u=>i.next(t?t(l,u,d,c++):u),()=>{r=null,s()}))},()=>{a=!0,s()}))})}function ot(n){return Kt((t,e)=>{oi(n).subscribe(Ht(e,()=>e.complete(),sl)),!e.closed&&t.subscribe(e)})}function U_(n,t=!1){return Kt((e,i)=>{let r=0;e.subscribe(Ht(i,o=>{let a=n(o,r++);(a||t)&&i.next(o),!a&&i.complete()}))})}function Vt(n,t,e){let i=_n(n)||t||e?{next:n,error:t,complete:e}:n;return i?Kt((r,o)=>{var a;null===(a=i.subscribe)||void 0===a||a.call(i);let s=!0;r.subscribe(Ht(o,l=>{var c;null===(c=i.next)||void 0===c||c.call(i,l),o.next(l)},()=>{var l;s=!1,null===(l=i.complete)||void 0===l||l.call(i),o.complete()},l=>{var c;s=!1,null===(c=i.error)||void 0===c||c.call(i,l),o.error(l)},()=>{var l,c;s&&(null===(l=i.unsubscribe)||void 0===l||l.call(i)),null===(c=i.finalize)||void 0===c||c.call(i)}))}):la}var mR={leading:!0,trailing:!1};function eu(n,t=Qc,e=mR){let i=Ja(n,t);return function(n,t=mR){return Kt((e,i)=>{let{leading:r,trailing:o}=t,a=!1,s=null,l=null,c=!1,d=()=>{l?.unsubscribe(),l=null,o&&(f(),c&&i.complete())},u=()=>{l=null,c&&i.complete()},p=m=>l=oi(n(m)).subscribe(Ht(i,d,u)),f=()=>{if(a){a=!1;let m=s;s=null,i.next(m),!c&&p(m)}};e.subscribe(Ht(i,m=>{a=!0,s=m,(!l||l.closed)&&(r?f():p(m))},()=>{c=!0,(!(o&&a&&l)||l.closed)&&i.complete()}))})}(()=>i,e)}function Yt(...n){let t=tc(n);return Kt((e,i)=>{let r=n.length,o=new Array(r),a=n.map(()=>!1),s=!1;for(let l=0;l<r;l++)oi(n[l]).subscribe(Ht(i,c=>{o[l]=c,!s&&!a[l]&&(a[l]=!0,(s=a.every(la))&&(a=null))},sl));e.subscribe(Ht(i,l=>{if(s){let c=[l,...o];i.next(t?t(...c):c)}}))})}function nr(n){for(let t in n)if(n[t]===nr)return t;throw Error("Could not find renamed property on target object.")}function hR(n,t){for(let e in t)t.hasOwnProperty(e)&&!n.hasOwnProperty(e)&&(n[e]=t[e])}function ho(n){if("string"==typeof n)return n;if(Array.isArray(n))return"["+n.map(ho).join(", ")+"]";if(null==n)return""+n;if(n.overriddenName)return`${n.overriddenName}`;if(n.name)return`${n.name}`;let t=n.toString();if(null==t)return""+t;let e=t.indexOf("\n");return-1===e?t:t.substring(0,e)}function LR(n,t){return null==n||""===n?null===t?"":t:null==t||""===t?n:n+" "+t}var Rre=nr({__forward_ref__:nr});function Vn(n){return n.__forward_ref__=Vn,n.toString=function(){return ho(this())},n}function ki(n){return x5(n)?n():n}function x5(n){return"function"==typeof n&&n.hasOwnProperty(Rre)&&n.__forward_ref__===Vn}function C5(n){return n&&!!n.\u0275providers}var fy="https://g.co/ng/security#xss",bt=class extends Error{constructor(t,e){super(function(n,t){return`NG0${Math.abs(n)}${t?": "+t.trim():""}`}(t,e)),this.code=t}};function Yn(n){return"string"==typeof n?n:null==n?"":String(n)}function jk(n){return"function"==typeof n?n.name||n.toString():"object"==typeof n&&null!=n&&"function"==typeof n.type?n.type.name||n.type.toString():Yn(n)}function Gk(n,t){throw new bt(-201,!1)}function M5(n,t,e,i){throw new Error(`ASSERTION ERROR: ${n}`+(null==i?"":` [Expected=> ${e} ${i} ${t} <=Actual]`))}function pe(n){return{token:n.token,providedIn:n.providedIn||null,factory:n.factory,value:void 0}}function B(n){return{providers:n.providers||[],imports:n.imports||[]}}function Wk(n){return TH(n,iM)||TH(n,w5)}function TH(n,t){return n.hasOwnProperty(t)?n[t]:null}function DH(n){return n&&(n.hasOwnProperty(NR)||n.hasOwnProperty(Lre))?n[NR]:null}var BR,iM=nr({"\u0275prov":nr}),NR=nr({"\u0275inj":nr}),w5=nr({ngInjectableDef:nr}),Lre=nr({ngInjectorDef:nr}),Mi=(()=>{return(n=Mi||(Mi={}))[n.Default=0]="Default",n[n.Host=1]="Host",n[n.Self=2]="Self",n[n.SkipSelf=4]="SkipSelf",n[n.Optional=8]="Optional",Mi;var n})();function Cs(n){let t=BR;return BR=n,t}function S5(n,t,e){let i=Wk(n);return i&&"root"==i.providedIn?void 0===i.value?i.value=i.factory():i.value:e&Mi.Optional?null:void 0!==t?t:void Gk(ho(n))}var W_,Wr=(()=>typeof globalThis<"u"&&globalThis||typeof global<"u"&&global||typeof window<"u"&&window||typeof self<"u"&&typeof WorkerGlobalScope<"u"&&self instanceof WorkerGlobalScope&&self)(),ty={},VR="__NG_DI_FLAG__",rM="ngTempTokenPath",Vre="ngTokenPath",Hre=/\n/gm,zre="\u0275",IH="__source";function Xm(n){let t=W_;return W_=n,t}function Ure(n,t=Mi.Default){if(void 0===W_)throw new bt(-203,!1);return null===W_?S5(n,void 0,t):W_.get(n,t&Mi.Optional?null:void 0,t)}function O(n,t=Mi.Default){return(BR||Ure)(ki(n),t)}function E5(n){throw new bt(202,!1)}function pi(n,t=Mi.Default){return O(n,IM(t))}function IM(n){return typeof n>"u"||"number"==typeof n?n:0|(n.optional&&8)|(n.host&&1)|(n.self&&2)|(n.skipSelf&&4)}function HR(n){let t=[];for(let e=0;e<n.length;e++){let i=ki(n[e]);if(Array.isArray(i)){if(0===i.length)throw new bt(900,!1);let r,o=Mi.Default;for(let a=0;a<i.length;a++){let s=i[a],l=jre(s);"number"==typeof l?-1===l?r=s.token:o|=l:r=s}t.push(O(r,o))}else t.push(O(i))}return t}function my(n,t){return n[VR]=t,n.prototype[VR]=t,n}function jre(n){return n[VR]}function su(n){return{toString:n}.toString()}var q_=(()=>{return(n=q_||(q_={}))[n.OnPush=0]="OnPush",n[n.Default=1]="Default",q_;var n})(),es=(()=>{return(n=es||(es={}))[n.Emulated=0]="Emulated",n[n.None=2]="None",n[n.ShadowDom=3]="ShadowDom",es;var n})(),Zc={},Ui=[],AM=nr({"\u0275cmp":nr}),qk=nr({"\u0275dir":nr}),Yk=nr({"\u0275pipe":nr}),T5=nr({"\u0275mod":nr}),Kc=nr({"\u0275fac":nr}),Y_=nr({__NG_ELEMENT_ID__:nr}),qre=0;function k(n){return su(()=>{let t=I5(n),e={...t,decls:n.decls,vars:n.vars,template:n.template,consts:n.consts||null,ngContentSelectors:n.ngContentSelectors,onPush:n.changeDetection===q_.OnPush,directiveDefs:null,pipeDefs:null,dependencies:t.standalone&&n.dependencies||null,getStandaloneInjector:null,data:n.data||{},encapsulation:n.encapsulation||es.Emulated,id:"c"+qre++,styles:n.styles||Ui,_:null,schemas:n.schemas||null,tView:null};A5(e);let i=n.dependencies;return e.directiveDefs=oM(i,!1),e.pipeDefs=oM(i,!0),e})}function hy(n,t,e){let i=n.\u0275cmp;i.directiveDefs=oM(t,!1),i.pipeDefs=oM(e,!0)}function Yre(n){return ws(n)||iu(n)}function Xre(n){return null!==n}function V(n){return su(()=>({type:n.type,bootstrap:n.bootstrap||Ui,declarations:n.declarations||Ui,imports:n.imports||Ui,exports:n.exports||Ui,transitiveCompileScopes:null,schemas:n.schemas||null,id:n.id||null}))}function AH(n,t){if(null==n)return Zc;let e={};for(let i in n)if(n.hasOwnProperty(i)){let r=n[i],o=r;Array.isArray(r)&&(o=r[1],r=r[0]),e[r]=i,t&&(t[r]=o)}return e}function xe(n){return su(()=>{let t=I5(n);return A5(t),t})}function ch(n){return{type:n.type,name:n.name,factory:null,pure:!1!==n.pure,standalone:!0===n.standalone,onDestroy:n.type.prototype.ngOnDestroy||null}}function ws(n){return n[AM]||null}function iu(n){return n[qk]||null}function ru(n){return n[Yk]||null}function D5(n){let t=ws(n)||iu(n)||ru(n);return null!==t&&t.standalone}function nh(n,t){let e=n[T5]||null;if(!e&&!0===t)throw new Error(`Type ${ho(n)} does not have '\u0275mod' property.`);return e}function I5(n){let t={};return{type:n.type,providersResolver:null,factory:null,hostBindings:n.hostBindings||null,hostVars:n.hostVars||0,hostAttrs:n.hostAttrs||null,contentQueries:n.contentQueries||null,declaredInputs:t,exportAs:n.exportAs||null,standalone:!0===n.standalone,selectors:n.selectors||Ui,viewQuery:n.viewQuery||null,features:n.features||null,setInput:null,findHostDirectiveDefs:null,hostDirectives:null,inputs:AH(n.inputs,t),outputs:AH(n.outputs)}}function A5(n){n.features?.forEach(t=>t(n))}function oM(n,t){if(!n)return null;let e=t?ru:Yre;return()=>("function"==typeof n?n():n).map(i=>e(i)).filter(Xre)}var lu=0,Bn=1,si=2,Yr=3,pl=4,Vp=5,Da=6,ny=7,Ia=8,aM=9,sM=10,li=11,zR=12,iy=13,RH=14,dh=15,fl=16,gy=17,Qm=18,oc=19,RM=20,R5=21,Xr=22,Xk=1,k5=2,Qk=7,lM=8,ih=9,Ta=10;function Hp(n){return Array.isArray(n)&&"object"==typeof n[Xk]}function $c(n){return Array.isArray(n)&&!0===n[Xk]}function Zk(n){return 0!=(4&n.flags)}function kM(n){return n.componentOffset>-1}function PM(n){return 1==(1&n.flags)}function ml(n){return!!n.template}function Qre(n){return 0!=(256&n[si])}function Up(n,t){return n.hasOwnProperty(Kc)?n[Kc]:null}var UR=class{constructor(t,e,i){this.previousValue=t,this.currentValue=e,this.firstChange=i}isFirstChange(){return this.firstChange}};function Gt(){return P5}function P5(n){return n.type.prototype.ngOnChanges&&(n.setInput=Kre),Zre}function Zre(){let n=F5(this),t=n?.current;if(t){let e=n.previous;if(e===Zc)n.previous=t;else for(let i in t)e[i]=t[i];n.current=null,this.ngOnChanges(t)}}function Kre(n,t,e,i){let r=this.declaredInputs[e],o=F5(n)||function(n,t){return n[O5]=t}(n,{previous:Zc,current:null}),a=o.current||(o.current={}),s=o.previous,l=s[r];a[r]=new UR(l&&l.currentValue,t,s===Zc),n[i]=t}Gt.ngInherit=!0;var O5="__ngSimpleChanges__";function F5(n){return n[O5]||null}var Ms=function(n,t,e){},L5="svg",N5="math";function Ts(n){for(;Array.isArray(n);)n=n[lu];return n}function OM(n,t){return Ts(t[n])}function ts(n,t){return Ts(t[n.index])}function B5(n,t){return n.data[t]}function uh(n,t){return n[t]}function ed(n,t){let e=t[n];return Hp(e)?e:e[lu]}function cM(n){return 64==(64&n[si])}function ou(n,t){return null==t?null:n[t]}function V5(n){n[Qm]=0}function Kk(n,t){n[Vp]+=t;let e=n,i=n[Yr];for(;null!==i&&(1===t&&1===e[Vp]||-1===t&&0===e[Vp]);)i[Vp]+=t,e=i,i=i[Yr]}var Xn={lFrame:Y5(null),bindingsEnabled:!0};function H5(){return Xn.bindingsEnabled}function Ke(){return Xn.lFrame.lView}function Ei(){return Xn.lFrame.tView}function X(n){return Xn.lFrame.contextLView=n,n[Ia]}function Q(n){return Xn.lFrame.contextLView=null,n}function Po(){let n=z5();for(;null!==n&&64===n.type;)n=n.parent;return n}function z5(){return Xn.lFrame.currentTNode}function ry(){let n=Xn.lFrame,t=n.currentTNode;return n.isParent?t:t.parent}function ac(n,t){let e=Xn.lFrame;e.currentTNode=n,e.isParent=t}function Jk(){return Xn.lFrame.isParent}function $k(){Xn.lFrame.isParent=!1}function da(){let n=Xn.lFrame,t=n.bindingRootIndex;return-1===t&&(t=n.bindingRootIndex=n.tView.bindingStartIndex),t}function td(){return Xn.lFrame.bindingIndex}function U5(n){return Xn.lFrame.bindingIndex=n}function ph(){return Xn.lFrame.bindingIndex++}function nd(n){let t=Xn.lFrame,e=t.bindingIndex;return t.bindingIndex=t.bindingIndex+n,e}function j5(n){Xn.lFrame.inI18n=n}function coe(n,t){let e=Xn.lFrame;e.bindingIndex=e.bindingRootIndex=n,jR(t)}function jR(n){Xn.lFrame.currentDirectiveIndex=n}function eP(n){let t=Xn.lFrame.currentDirectiveIndex;return-1===t?null:n[t]}function G5(){return Xn.lFrame.currentQueryIndex}function tP(n){Xn.lFrame.currentQueryIndex=n}function uoe(n){let t=n[Bn];return 2===t.type?t.declTNode:1===t.type?n[Da]:null}function W5(n,t,e){if(e&Mi.SkipSelf){let r=t,o=n;for(;!(r=r.parent,null!==r||e&Mi.Host||(r=uoe(o),null===r||(o=o[dh],10&r.type))););if(null===r)return!1;t=r,n=o}let i=Xn.lFrame=q5();return i.currentTNode=t,i.lView=n,!0}function nP(n){let t=q5(),e=n[Bn];Xn.lFrame=t,t.currentTNode=e.firstChild,t.lView=n,t.tView=e,t.contextLView=n,t.bindingIndex=e.bindingStartIndex,t.inI18n=!1}function q5(){let n=Xn.lFrame,t=null===n?null:n.child;return null===t?Y5(n):t}function Y5(n){let t={currentTNode:null,isParent:!0,lView:null,tView:null,selectedIndex:-1,contextLView:null,elementDepthCount:0,currentNamespace:null,currentDirectiveIndex:-1,bindingRootIndex:-1,bindingIndex:-1,currentQueryIndex:0,parent:n,child:null,inI18n:!1};return null!==n&&(n.child=t),t}function X5(){let n=Xn.lFrame;return Xn.lFrame=n.parent,n.currentTNode=null,n.lView=null,n}var Q5=X5;function iP(){let n=X5();n.isParent=!0,n.tView=null,n.selectedIndex=-1,n.contextLView=null,n.elementDepthCount=0,n.currentDirectiveIndex=-1,n.currentNamespace=null,n.bindingRootIndex=-1,n.bindingIndex=-1,n.currentQueryIndex=0}function ua(){return Xn.lFrame.selectedIndex}function jp(n){Xn.lFrame.selectedIndex=n}function kr(){let n=Xn.lFrame;return B5(n.tView,n.selectedIndex)}function Tn(){Xn.lFrame.currentNamespace=L5}function Oo(){Xn.lFrame.currentNamespace=null}function FM(n,t){for(let e=t.directiveStart,i=t.directiveEnd;e<i;e++){let o=n.data[e].type.prototype,{ngAfterContentInit:a,ngAfterContentChecked:s,ngAfterViewInit:l,ngAfterViewChecked:c,ngOnDestroy:d}=o;a&&(n.contentHooks??(n.contentHooks=[])).push(-e,a),s&&((n.contentHooks??(n.contentHooks=[])).push(e,s),(n.contentCheckHooks??(n.contentCheckHooks=[])).push(e,s)),l&&(n.viewHooks??(n.viewHooks=[])).push(-e,l),c&&((n.viewHooks??(n.viewHooks=[])).push(e,c),(n.viewCheckHooks??(n.viewCheckHooks=[])).push(e,c)),null!=d&&(n.destroyHooks??(n.destroyHooks=[])).push(e,d)}}function XC(n,t,e){Z5(n,t,3,e)}function QC(n,t,e,i){(3&n[si])===e&&Z5(n,t,e,i)}function gR(n,t){let e=n[si];(3&e)===t&&(e&=2047,e+=1,n[si]=e)}function Z5(n,t,e,i){let o=i??-1,a=t.length-1,s=0;for(let l=void 0!==i?65535&n[Qm]:0;l<a;l++)if("number"==typeof t[l+1]){if(s=t[l],null!=i&&s>=i)break}else t[l]<0&&(n[Qm]+=65536),(s<o||-1==o)&&(yoe(n,e,t,l),n[Qm]=(4294901760&n[Qm])+l+2),l++}function yoe(n,t,e,i){let r=e[i]<0,o=e[i+1],s=n[r?-e[i]:e[i]];if(r){if(n[si]>>11<n[Qm]>>16&&(3&n[si])===t){n[si]+=2048,Ms(4,s,o);try{o.call(s)}finally{Ms(5,s,o)}}}else{Ms(4,s,o);try{o.call(s)}finally{Ms(5,s,o)}}}var th=-1,Gp=class{constructor(t,e,i){this.factory=t,this.resolving=!1,this.canSeeViewProviders=e,this.injectImpl=i}};function GR(n,t,e){let i=0;for(;i<e.length;){let r=e[i];if("number"==typeof r){if(0!==r)break;i++;let o=e[i++],a=e[i++],s=e[i++];n.setAttribute(t,a,s,o)}else{let o=r,a=e[++i];Coe(o)?n.setProperty(t,o,a):n.setAttribute(t,o,a),i++}}return i}function K5(n){return 3===n||4===n||6===n}function Coe(n){return 64===n.charCodeAt(0)}function oy(n,t){if(null!==t&&0!==t.length)if(null===n||0===n.length)n=t.slice();else{let e=-1;for(let i=0;i<t.length;i++){let r=t[i];"number"==typeof r?e=r:0===e||PH(n,e,r,null,-1===e||2===e?t[++i]:null)}}return n}function PH(n,t,e,i,r){let o=0,a=n.length;if(-1===t)a=-1;else for(;o<n.length;){let s=n[o++];if("number"==typeof s){if(s===t){a=-1;break}if(s>t){a=o-1;break}}}for(;o<n.length;){let s=n[o];if("number"==typeof s)break;if(s===e){if(null===i)return void(null!==r&&(n[o+1]=r));if(i===n[o+1])return void(n[o+2]=r)}o++,null!==i&&o++,null!==r&&o++}-1!==a&&(n.splice(a,0,t),o=a+1),n.splice(o++,0,e),null!==i&&n.splice(o++,0,i),null!==r&&n.splice(o++,0,r)}function J5(n){return n!==th}function dM(n){return 32767&n}function uM(n,t){let e=function(n){return n>>16}(n),i=t;for(;e>0;)i=i[dh],e--;return i}var WR=!0;function pM(n){let t=WR;return WR=n,t}var $5=255,ez=5,Soe=0,rc={};function fM(n,t){let e=tz(n,t);if(-1!==e)return e;let i=t[Bn];i.firstCreatePass&&(n.injectorIndex=t.length,_R(i.data,n),_R(t,null),_R(i.blueprint,null));let r=rP(n,t),o=n.injectorIndex;if(J5(r)){let a=dM(r),s=uM(r,t),l=s[Bn].data;for(let c=0;c<8;c++)t[o+c]=s[a+c]|l[a+c]}return t[o+8]=r,o}function _R(n,t){n.push(0,0,0,0,0,0,0,0,t)}function tz(n,t){return-1===n.injectorIndex||n.parent&&n.parent.injectorIndex===n.injectorIndex||null===t[n.injectorIndex+8]?-1:n.injectorIndex}function rP(n,t){if(n.parent&&-1!==n.parent.injectorIndex)return n.parent.injectorIndex;let e=0,i=null,r=t;for(;null!==r;){if(i=az(r),null===i)return th;if(e++,r=r[dh],-1!==i.injectorIndex)return i.injectorIndex|e<<16}return th}function qR(n,t,e){!function(n,t,e){let i;"string"==typeof e?i=e.charCodeAt(0)||0:e.hasOwnProperty(Y_)&&(i=e[Y_]),null==i&&(i=e[Y_]=Soe++);let r=i&$5;t.data[n+(r>>ez)]|=1<<r}(n,t,e)}function nz(n,t,e){if(e&Mi.Optional||void 0!==n)return n;Gk()}function iz(n,t,e,i){if(e&Mi.Optional&&void 0===i&&(i=null),0==(e&(Mi.Self|Mi.Host))){let r=n[aM],o=Cs(void 0);try{return r?r.get(t,i,e&Mi.Optional):S5(t,i,e&Mi.Optional)}finally{Cs(o)}}return nz(i,0,e)}function rz(n,t,e,i=Mi.Default,r){if(null!==n){if(1024&t[si]){let a=function(n,t,e,i,r){let o=n,a=t;for(;null!==o&&null!==a&&1024&a[si]&&!(256&a[si]);){let s=oz(o,a,e,i|Mi.Self,rc);if(s!==rc)return s;let l=o.parent;if(!l){let c=a[R5];if(c){let d=c.get(e,rc,i);if(d!==rc)return d}l=az(a),a=a[dh]}o=l}return r}(n,t,e,i,rc);if(a!==rc)return a}let o=oz(n,t,e,i,rc);if(o!==rc)return o}return iz(t,e,i,r)}function oz(n,t,e,i,r){let o=function(n){if("string"==typeof n)return n.charCodeAt(0)||0;let t=n.hasOwnProperty(Y_)?n[Y_]:void 0;return"number"==typeof t?t>=0?t&$5:Aoe:t}(e);if("function"==typeof o){if(!W5(t,n,i))return i&Mi.Host?nz(r,0,i):iz(t,e,i,r);try{let a=o(i);if(null!=a||i&Mi.Optional)return a;Gk()}finally{Q5()}}else if("number"==typeof o){let a=null,s=tz(n,t),l=th,c=i&Mi.Host?t[fl][Da]:null;for((-1===s||i&Mi.SkipSelf)&&(l=-1===s?rP(n,t):t[s+8],l!==th&&FH(i,!1)?(a=t[Bn],s=dM(l),t=uM(l,t)):s=-1);-1!==s;){let d=t[Bn];if(OH(o,s,d.data)){let u=Doe(s,t,e,a,i,c);if(u!==rc)return u}l=t[s+8],l!==th&&FH(i,t[Bn].data[s+8]===c)&&OH(o,s,t)?(a=d,s=dM(l),t=uM(l,t)):s=-1}}return r}function Doe(n,t,e,i,r,o){let a=t[Bn],s=a.data[n+8],d=ZC(s,a,e,null==i?kM(s)&&WR:i!=a&&0!=(3&s.type),r&Mi.Host&&o===s);return null!==d?Wp(t,a,d,s):rc}function ZC(n,t,e,i,r){let o=n.providerIndexes,a=t.data,s=1048575&o,l=n.directiveStart,d=o>>20,p=r?s+d:n.directiveEnd;for(let f=i?s:s+d;f<p;f++){let m=a[f];if(f<l&&e===m||f>=l&&m.type===e)return f}if(r){let f=a[l];if(f&&ml(f)&&f.type===e)return l}return null}function Wp(n,t,e,i){let r=n[e],o=t.data;if(function(n){return n instanceof Gp}(r)){let a=r;a.resolving&&function(n,t){throw new bt(-200,`Circular dependency in DI detected for ${n}`)}(jk(o[e]));let s=pM(a.canSeeViewProviders);a.resolving=!0;let l=a.injectImpl?Cs(a.injectImpl):null;W5(n,i,Mi.Default);try{r=n[e]=a.factory(void 0,o,n,i),t.firstCreatePass&&e>=i.directiveStart&&function(n,t,e){let{ngOnChanges:i,ngOnInit:r,ngDoCheck:o}=t.type.prototype;if(i){let a=P5(t);(e.preOrderHooks??(e.preOrderHooks=[])).push(n,a),(e.preOrderCheckHooks??(e.preOrderCheckHooks=[])).push(n,a)}r&&(e.preOrderHooks??(e.preOrderHooks=[])).push(0-n,r),o&&((e.preOrderHooks??(e.preOrderHooks=[])).push(n,o),(e.preOrderCheckHooks??(e.preOrderCheckHooks=[])).push(n,o))}(e,o[e],t)}finally{null!==l&&Cs(l),pM(s),a.resolving=!1,Q5()}}return r}function OH(n,t,e){return!!(e[t+(n>>ez)]&1<<n)}function FH(n,t){return!(n&Mi.Self||n&Mi.Host&&t)}var zp=class{constructor(t,e){this._tNode=t,this._lView=e}get(t,e,i){return rz(this._tNode,this._lView,t,IM(i),e)}};function Aoe(){return new zp(Po(),Ke())}function Cn(n){return su(()=>{let t=n.prototype.constructor,e=t[Kc]||YR(t),i=Object.prototype,r=Object.getPrototypeOf(n.prototype).constructor;for(;r&&r!==i;){let o=r[Kc]||YR(r);if(o&&o!==e)return o;r=Object.getPrototypeOf(r)}return o=>new o})}function YR(n){return x5(n)?()=>{let t=YR(ki(n));return t&&t()}:Up(n)}function az(n){let t=n[Bn],e=t.type;return 2===e?t.declTNode:1===e?n[Da]:null}function Vr(n){return function(n,t){if("class"===t)return n.classes;if("style"===t)return n.styles;let e=n.attrs;if(e){let i=e.length,r=0;for(;r<i;){let o=e[r];if(K5(o))break;if(0===o)r+=2;else if("number"==typeof o)for(r++;r<i&&"string"==typeof e[r];)r++;else{if(o===t)return e[r+1];r+=2}}}return null}(Po(),n)}var Zm="__annotations__",Km="__parameters__",Jm="__prop__metadata__";function _y(n,t,e,i,r){return su(()=>{let o=oP(t);function a(...s){if(this instanceof a)return o.call(this,...s),this;let l=new a(...s);return function(d){return r&&r(d,...s),(d.hasOwnProperty(Zm)?d[Zm]:Object.defineProperty(d,Zm,{value:[]})[Zm]).push(l),i&&i(d),d}}return e&&(a.prototype=Object.create(e.prototype)),a.prototype.ngMetadataName=n,a.annotationCls=a,a})}function oP(n){return function(...e){if(n){let i=n(...e);for(let r in i)this[r]=i[r]}}}function fh(n,t,e){return su(()=>{let i=oP(t);function r(...o){if(this instanceof r)return i.apply(this,o),this;let a=new r(...o);return s.annotation=a,s;function s(l,c,d){let u=l.hasOwnProperty(Km)?l[Km]:Object.defineProperty(l,Km,{value:[]})[Km];for(;u.length<=d;)u.push(null);return(u[d]=u[d]||[]).push(a),l}}return e&&(r.prototype=Object.create(e.prototype)),r.prototype.ngMetadataName=n,r.annotationCls=r,r})}function cu(n,t,e,i){return su(()=>{let r=oP(t);function o(...a){if(this instanceof o)return r.apply(this,a),this;let s=new o(...a);return function(c,d){let u=c.constructor,p=u.hasOwnProperty(Jm)?u[Jm]:Object.defineProperty(u,Jm,{value:{}})[Jm];p[d]=p.hasOwnProperty(d)&&p[d]||[],p[d].unshift(s),i&&i(c,d,...a)}}return e&&(o.prototype=Object.create(e.prototype)),o.prototype.ngMetadataName=n,o.annotationCls=o,o})}var koe=fh("Attribute",n=>({attributeName:n,__NG_ELEMENT_ID__:()=>Vr(n)})),ie=class{constructor(t,e){this._desc=t,this.ngMetadataName="InjectionToken",this.\u0275prov=void 0,"number"==typeof e?this.__NG_ELEMENT_ID__=e:void 0!==e&&(this.\u0275prov=pe({token:this,providedIn:e.providedIn||"root",factory:e.factory}))}get multi(){return this}toString(){return`InjectionToken ${this._desc}`}},rh=(new ie("AnalyzeForEntryComponents"),class{});function Ss(n){let t=Wr.ng;if(t&&t.\u0275compilerFacade)return t.\u0275compilerFacade;throw new Error("JIT compiler unavailable")}cu("ContentChildren",(n,t={})=>({selector:n,first:!1,isViewQuery:!1,descendants:!1,emitDistinctChangesOnly:!0,...t}),rh),cu("ContentChild",(n,t={})=>({selector:n,first:!0,isViewQuery:!1,descendants:!0,...t}),rh),cu("ViewChildren",(n,t={})=>({selector:n,first:!1,isViewQuery:!0,descendants:!0,emitDistinctChangesOnly:!0,...t}),rh),cu("ViewChild",(n,t)=>({selector:n,first:!0,isViewQuery:!0,descendants:!0,...t}),rh);var Poe=Function;function j_(n){return"function"==typeof n}function tu(n){return n.flat(Number.POSITIVE_INFINITY)}function aP(n,t){n.forEach(e=>Array.isArray(e)?aP(e,t):t(e))}function lz(n,t,e){t>=n.length?n.push(e):n.splice(t,0,e)}function mM(n,t){return t>=n.length-1?n.pop():n.splice(t,1)[0]}function X_(n,t){let e=[];for(let i=0;i<n;i++)e.push(t);return e}function ns(n,t,e){let i=yy(n,t);return i>=0?n[1|i]=e:(i=~i,function(n,t,e,i){let r=n.length;if(r==t)n.push(e,i);else if(1===r)n.push(i,n[0]),n[0]=e;else{for(r--,n.push(n[r-1],n[r]);r>t;)n[r]=n[r-2],r--;n[t]=e,n[t+1]=i}}(n,i,t,e)),i}function yR(n,t){let e=yy(n,t);if(e>=0)return n[1|e]}function yy(n,t){return function(n,t,e){let i=0,r=n.length>>1;for(;r!==i;){let o=i+(r-i>>1),a=n[o<<1];if(t===a)return o<<1;a>t?r=o:i=o+1}return~(r<<1)}(n,t)}var Noe=/^function\s+\S+\(\)\s*{[\s\S]+\.apply\(this,\s*(arguments|(?:[^()]+\(\[\],)?[^()]+\(arguments\).*)\)/,Boe=/^class\s+[A-Za-z\d$_]*\s*extends\s+[^{]+{/,Voe=/^class\s+[A-Za-z\d$_]*\s*extends\s+[^{]+{[\s\S]*constructor\s*\(/,Hoe=/^class\s+[A-Za-z\d$_]*\s*extends\s+[^{]+{[\s\S]*constructor\s*\(\)\s*{[^}]*super\(\.\.\.arguments\)/,XR=class{constructor(t){this._reflect=t||Wr.Reflect}factory(t){return(...e)=>new t(...e)}_zipTypesAndAnnotations(t,e){let i;i=X_(typeof t>"u"?e.length:t.length);for(let r=0;r<i.length;r++)i[r]=typeof t>"u"?[]:t[r]&&t[r]!=Object?[t[r]]:[],e&&null!=e[r]&&(i[r]=i[r].concat(e[r]));return i}_ownParameters(t,e){let i=t.toString();if(Noe.test(n=i)||Hoe.test(n)||Boe.test(n)&&!Voe.test(n))return null;var n;if(t.parameters&&t.parameters!==e.parameters)return t.parameters;let r=t.ctorParameters;if(r&&r!==e.ctorParameters){let s="function"==typeof r?r():r,l=s.map(d=>d&&d.type),c=s.map(d=>d&&bR(d.decorators));return this._zipTypesAndAnnotations(l,c)}let o=t.hasOwnProperty(Km)&&t[Km],a=this._reflect&&this._reflect.getOwnMetadata&&this._reflect.getOwnMetadata("design:paramtypes",t);return a||o?this._zipTypesAndAnnotations(a,o):X_(t.length)}parameters(t){if(!j_(t))return[];let e=jC(t),i=this._ownParameters(t,e);return!i&&e!==Object&&(i=this.parameters(e)),i||[]}_ownAnnotations(t,e){if(t.annotations&&t.annotations!==e.annotations){let i=t.annotations;return"function"==typeof i&&i.annotations&&(i=i.annotations),i}return t.decorators&&t.decorators!==e.decorators?bR(t.decorators):t.hasOwnProperty(Zm)?t[Zm]:null}annotations(t){if(!j_(t))return[];let e=jC(t),i=this._ownAnnotations(t,e)||[];return(e!==Object?this.annotations(e):[]).concat(i)}_ownPropMetadata(t,e){if(t.propMetadata&&t.propMetadata!==e.propMetadata){let i=t.propMetadata;return"function"==typeof i&&i.propMetadata&&(i=i.propMetadata),i}if(t.propDecorators&&t.propDecorators!==e.propDecorators){let i=t.propDecorators,r={};return Object.keys(i).forEach(o=>{r[o]=bR(i[o])}),r}return t.hasOwnProperty(Jm)?t[Jm]:null}propMetadata(t){if(!j_(t))return{};let e=jC(t),i={};if(e!==Object){let o=this.propMetadata(e);Object.keys(o).forEach(a=>{i[a]=o[a]})}let r=this._ownPropMetadata(t,e);return r&&Object.keys(r).forEach(o=>{let a=[];i.hasOwnProperty(o)&&a.push(...i[o]),a.push(...r[o]),i[o]=a}),i}ownPropMetadata(t){return j_(t)&&this._ownPropMetadata(t,jC(t))||{}}hasLifecycleHook(t,e){return t instanceof Poe&&e in t.prototype}};function bR(n){return n?n.map(t=>new(0,t.type.annotationCls)(...t.args?t.args:[])):[]}function jC(n){let t=n.prototype?Object.getPrototypeOf(n.prototype):null;return(t?t.constructor:null)||Object}var mh=my(fh("Inject",n=>({token:n})),-1),Aa=my(fh("Optional"),8),Uoe=my(fh("Self"),2),id=my(fh("SkipSelf"),4),joe=my(fh("Host"),1),LH=null;function sP(){return LH=LH||new XR}function LM(n){return cz(sP().parameters(n))}function cz(n){return n.map(t=>function(n){let t={token:null,attribute:null,host:!1,optional:!1,self:!1,skipSelf:!1};if(Array.isArray(n)&&n.length>0)for(let e=0;e<n.length;e++){let i=n[e];if(void 0===i)continue;let r=Object.getPrototypeOf(i);if(i instanceof Aa||"Optional"===r.ngMetadataName)t.optional=!0;else if(i instanceof id||"SkipSelf"===r.ngMetadataName)t.skipSelf=!0;else if(i instanceof Uoe||"Self"===r.ngMetadataName)t.self=!0;else if(i instanceof joe||"Host"===r.ngMetadataName)t.host=!0;else if(i instanceof mh)t.token=i.token;else if(i instanceof koe){if(void 0===i.attributeName)throw new bt(204,!1);t.attribute=i.attributeName}else t.token=i}else t.token=void 0===n||Array.isArray(n)&&0===n.length?null:n;return t}(t))}var ay=new Map,dz=new Set;function uz(n){return!!(n.templateUrl&&!n.hasOwnProperty("template")||n.styleUrls&&n.styleUrls.length)}var NH=new Map,Koe=!0;function pz(n,t){(function(n,t,e){if(t&&t!==e&&Koe)throw new Error(`Duplicate module registered for ${n} - ${ho(t)} vs ${ho(t.name)}`)})(t,NH.get(t)||null,n),NH.set(t,n)}var QR,Es=(()=>{return(n=Es||(Es={}))[n.Important=1]="Important",n[n.DashCase=2]="DashCase",Es;var n})(),$oe=/^>|^->|<!--|-->|--!>|<!-$/g,eae=/(<|>)/,tae="\u200b$1\u200b",fz=new Map,iae=0,BH="__ngContext__";function sc(n,t){Hp(t)?(n[BH]=t[RM],function(n){fz.set(n[RM],n)}(t)):n[BH]=t}function lP(n,t){return QR(n,t)}function cP(n){let t=n[Yr];return $c(t)?t[Yr]:t}function dP(n){return mz(n[iy])}function uP(n){return mz(n[pl])}function mz(n){for(;null!==n&&!$c(n);)n=n[pl];return n}function $m(n,t,e,i,r){if(null!=i){let o,a=!1;$c(i)?o=i:Hp(i)&&(a=!0,i=i[lu]);let s=Ts(i);0===n&&null!==e?null==r?vz(t,e,s):qp(t,e,s,r||null,!0):1===n&&null!==e?qp(t,e,s,r||null,!0):2===n?mP(t,s,a):3===n&&t.destroyNode(s),null!=o&&function(n,t,e,i,r){let o=e[Qk];o!==Ts(e)&&$m(t,n,i,o,r);for(let s=Ta;s<e.length;s++){let l=e[s];by(l[Bn],l,n,t,i,o)}}(t,n,o,e,r)}}function pP(n,t){return n.createText(t)}function hz(n,t,e){n.setValue(t,e)}function lae(n,t){return n.createComment(function(n){return n.replace($oe,t=>t.replace(eae,tae))}(t))}function fP(n,t,e){return n.createElement(t,e)}function gz(n,t){let e=n[ih],i=e.indexOf(t),r=t[Yr];512&t[si]&&(t[si]&=-513,Kk(r,-1)),e.splice(i,1)}function ZR(n,t){if(n.length<=Ta)return;let e=Ta+t,i=n[e];if(i){let r=i[gy];null!==r&&r!==n&&gz(r,i),t>0&&(n[e-1][pl]=i[pl]);let o=mM(n,Ta+t);!function(n,t){by(n,t,t[li],2,null,null),t[lu]=null,t[Da]=null}(i[Bn],i);let a=o[oc];null!==a&&a.detachView(o[Bn]),i[Yr]=null,i[pl]=null,i[si]&=-65}return i}function _z(n,t){if(!(128&t[si])){let e=t[li];e.destroyNode&&by(n,t,e,3,null,null),function(n){let t=n[iy];if(!t)return vR(n[Bn],n);for(;t;){let e=null;if(Hp(t))e=t[iy];else{let i=t[Ta];i&&(e=i)}if(!e){for(;t&&!t[pl]&&t!==n;)Hp(t)&&vR(t[Bn],t),t=t[Yr];null===t&&(t=n),Hp(t)&&vR(t[Bn],t),e=t&&t[pl]}t=e}}(t)}}function vR(n,t){if(!(128&t[si])){t[si]&=-65,t[si]|=128,function(n,t){let e;if(null!=n&&null!=(e=n.destroyHooks))for(let i=0;i<e.length;i+=2){let r=t[e[i]];if(!(r instanceof Gp)){let o=e[i+1];if(Array.isArray(o))for(let a=0;a<o.length;a+=2){let s=r[o[a]],l=o[a+1];Ms(4,s,l);try{l.call(s)}finally{Ms(5,s,l)}}else{Ms(4,r,o);try{o.call(r)}finally{Ms(5,r,o)}}}}}(n,t),function(n,t){let e=n.cleanup,i=t[ny],r=-1;if(null!==e)for(let o=0;o<e.length-1;o+=2)if("string"==typeof e[o]){let a=e[o+3];a>=0?i[r=a]():i[r=-a].unsubscribe(),o+=2}else{let a=i[r=e[o+1]];e[o].call(a)}if(null!==i){for(let o=r+1;o<i.length;o++)(0,i[o])();t[ny]=null}}(n,t),1===t[Bn].type&&t[li].destroy();let e=t[gy];if(null!==e&&$c(t[Yr])){e!==t[Yr]&&gz(e,t);let i=t[oc];null!==i&&i.detachView(n)}!function(n){fz.delete(n[RM])}(t)}}function yz(n,t,e){return bz(n,t.parent,e)}function bz(n,t,e){let i=t;for(;null!==i&&40&i.type;)i=(t=i).parent;if(null===i)return e[lu];{let{componentOffset:r}=i;if(r>-1){let{encapsulation:o}=n.data[i.directiveStart+r];if(o===es.None||o===es.Emulated)return null}return ts(i,e)}}function qp(n,t,e,i,r){n.insertBefore(t,e,i,r)}function vz(n,t,e){n.appendChild(t,e)}function VH(n,t,e,i,r){null!==i?qp(n,t,e,i,r):vz(n,t,e)}function NM(n,t){return n.parentNode(t)}function xz(n,t,e){return Mz(n,t,e)}function Cz(n,t,e){return 40&n.type?ts(n,e):null}var KR,GC,$R,WC,Mz=Cz;function wz(n,t){Mz=n,KR=t}function BM(n,t,e,i){let r=yz(n,i,t),o=t[li],s=xz(i.parent||t[Da],i,t);if(null!=r)if(Array.isArray(e))for(let l=0;l<e.length;l++)VH(o,r,e[l],s,!1);else VH(o,r,e,s,!1);void 0!==KR&&KR(o,i,t,e,r)}function KC(n,t){if(null!==t){let e=t.type;if(3&e)return ts(t,n);if(4&e)return JR(-1,n[t.index]);if(8&e){let i=t.child;if(null!==i)return KC(n,i);{let r=n[t.index];return $c(r)?JR(-1,r):Ts(r)}}if(32&e)return lP(t,n)()||Ts(n[t.index]);{let i=Sz(n,t);return null!==i?Array.isArray(i)?i[0]:KC(cP(n[fl]),i):KC(n,t.next)}}return null}function Sz(n,t){return null!==t?n[fl][Da].projection[t.projection]:null}function JR(n,t){let e=Ta+n+1;if(e<t.length){let i=t[e],r=i[Bn].firstChild;if(null!==r)return KC(i,r)}return t[Qk]}function mP(n,t,e){let i=NM(n,t);i&&function(n,t,e,i){n.removeChild(t,e,i)}(n,i,t,e)}function hP(n,t,e,i,r,o,a){for(;null!=e;){let s=i[e.index],l=e.type;if(a&&0===t&&(s&&sc(Ts(s),i),e.flags|=2),32!=(32&e.flags))if(8&l)hP(n,t,e.child,i,r,o,!1),$m(t,n,r,s,o);else if(32&l){let d,c=lP(e,i);for(;d=c();)$m(t,n,r,d,o);$m(t,n,r,s,o)}else 16&l?Ez(n,t,i,e,r,o):$m(t,n,r,s,o);e=a?e.projectionNext:e.next}}function by(n,t,e,i,r,o){hP(e,i,n.firstChild,t,r,o,!1)}function Ez(n,t,e,i,r,o){let a=e[fl],l=a[Da].projection[i.projection];if(Array.isArray(l))for(let c=0;c<l.length;c++)$m(t,n,r,l[c],o);else hP(n,t,l,a[Yr],r,o,!0)}function Tz(n,t,e){""===e?n.removeAttribute(t,"class"):n.setAttribute(t,"class",e)}function Dz(n,t,e){let{mergedAttrs:i,classes:r,styles:o}=e;null!==i&&GR(n,t,i),null!==r&&Tz(n,t,r),null!==o&&function(n,t,e){n.setAttribute(t,"style",e)}(n,t,o)}function Iz(){if(void 0===GC&&(GC=null,Wr.trustedTypes))try{GC=Wr.trustedTypes.createPolicy("angular",{createHTML:n=>n,createScript:n=>n,createScriptURL:n=>n})}catch{}return GC}function hh(n){return Iz()?.createHTML(n)||n}function Rz(){return void 0!==$R?$R:typeof document<"u"?document:void 0}function gP(){if(void 0===WC&&(WC=null,Wr.trustedTypes))try{WC=Wr.trustedTypes.createPolicy("angular#unsafe-bypass",{createHTML:n=>n,createScript:n=>n,createScriptURL:n=>n})}catch{}return WC}function HH(n){return gP()?.createHTML(n)||n}function zH(n){return gP()?.createScript(n)||n}function UH(n){return gP()?.createScriptURL(n)||n}var Jc=class{constructor(t){this.changingThisBreaksApplicationSecurity=t}toString(){return`SafeValue must use [property]=binding: ${this.changingThisBreaksApplicationSecurity} (see ${fy})`}},ek=class extends Jc{getTypeName(){return"HTML"}},tk=class extends Jc{getTypeName(){return"Style"}},nk=class extends Jc{getTypeName(){return"Script"}},ik=class extends Jc{getTypeName(){return"URL"}},rk=class extends Jc{getTypeName(){return"ResourceURL"}};function Ra(n){return n instanceof Jc?n.changingThisBreaksApplicationSecurity:n}function gl(n,t){let e=function(n){return n instanceof Jc&&n.getTypeName()||null}(n);if(null!=e&&e!==t){if("ResourceURL"===e&&"URL"===t)return!0;throw new Error(`Required a safe ${t}, got a ${e} (see ${fy})`)}return e===t}function Nz(n){let t=new ak(n);return function(){try{return!!(new window.DOMParser).parseFromString(hh(""),"text/html")}catch{return!1}}()?new ok(t):t}var ok=class{constructor(t){this.inertDocumentHelper=t}getInertBodyElement(t){t="<body><remove></remove>"+t;try{let e=(new window.DOMParser).parseFromString(hh(t),"text/html").body;return null===e?this.inertDocumentHelper.getInertBodyElement(t):(e.removeChild(e.firstChild),e)}catch{return null}}},ak=class{constructor(t){this.defaultDoc=t,this.inertDocument=this.defaultDoc.implementation.createHTMLDocument("sanitization-inert")}getInertBodyElement(t){let e=this.inertDocument.createElement("template");return e.innerHTML=hh(t),e}},Tae=/^(?!javascript:)(?:[a-z0-9+.-]+:|[^&:\/?#]*(?:[\/?#]|$))/i;function vy(n){return(n=String(n)).match(Tae)?n:"unsafe:"+n}function rd(n){let t={};for(let e of n.split(","))t[e]=!0;return t}function xy(...n){let t={};for(let e of n)for(let i in e)e.hasOwnProperty(i)&&(t[i]=!0);return t}var qC,Bz=rd("area,br,col,hr,img,wbr"),Vz=rd("colgroup,dd,dt,li,p,tbody,td,tfoot,th,thead,tr"),Hz=rd("rp,rt"),Dae=xy(Hz,Vz),Iae=xy(Vz,rd("address,article,aside,blockquote,caption,center,del,details,dialog,dir,div,dl,figure,figcaption,footer,h1,h2,h3,h4,h5,h6,header,hgroup,hr,ins,main,map,menu,nav,ol,pre,section,summary,table,ul")),Aae=xy(Hz,rd("a,abbr,acronym,audio,b,bdi,bdo,big,br,cite,code,del,dfn,em,font,i,img,ins,kbd,label,map,mark,picture,q,ruby,rp,rt,s,samp,small,source,span,strike,strong,sub,sup,time,track,tt,u,var,video")),sk=xy(Bz,Iae,Aae,Dae),_P=rd("background,cite,href,itemtype,longdesc,poster,src,xlink:href"),Rae=rd("abbr,accesskey,align,alt,autoplay,axis,bgcolor,border,cellpadding,cellspacing,class,clear,color,cols,colspan,compact,controls,coords,datetime,default,dir,download,face,headers,height,hidden,hreflang,hspace,ismap,itemscope,itemprop,kind,label,lang,language,loop,media,muted,nohref,nowrap,open,preload,rel,rev,role,rows,rowspan,rules,scope,scrolling,shape,size,sizes,span,srclang,srcset,start,summary,tabindex,target,title,translate,type,usemap,valign,value,vspace,width"),kae=rd("aria-activedescendant,aria-atomic,aria-autocomplete,aria-busy,aria-checked,aria-colcount,aria-colindex,aria-colspan,aria-controls,aria-current,aria-describedby,aria-details,aria-disabled,aria-dropeffect,aria-errormessage,aria-expanded,aria-flowto,aria-grabbed,aria-haspopup,aria-hidden,aria-invalid,aria-keyshortcuts,aria-label,aria-labelledby,aria-level,aria-live,aria-modal,aria-multiline,aria-multiselectable,aria-orientation,aria-owns,aria-placeholder,aria-posinset,aria-pressed,aria-readonly,aria-relevant,aria-required,aria-roledescription,aria-rowcount,aria-rowindex,aria-rowspan,aria-selected,aria-setsize,aria-sort,aria-valuemax,aria-valuemin,aria-valuenow,aria-valuetext"),zz=xy(_P,Rae,kae),Pae=rd("script,style,template"),lk=class{constructor(){this.sanitizedSomething=!1,this.buf=[]}sanitizeChildren(t){let e=t.firstChild,i=!0;for(;e;)if(e.nodeType===Node.ELEMENT_NODE?i=this.startElement(e):e.nodeType===Node.TEXT_NODE?this.chars(e.nodeValue):this.sanitizedSomething=!0,i&&e.firstChild)e=e.firstChild;else for(;e;){e.nodeType===Node.ELEMENT_NODE&&this.endElement(e);let r=this.checkClobberedElement(e,e.nextSibling);if(r){e=r;break}e=this.checkClobberedElement(e,e.parentNode)}return this.buf.join("")}startElement(t){let e=t.nodeName.toLowerCase();if(!sk.hasOwnProperty(e))return this.sanitizedSomething=!0,!Pae.hasOwnProperty(e);this.buf.push("<"),this.buf.push(e);let i=t.attributes;for(let r=0;r<i.length;r++){let o=i.item(r),a=o.name,s=a.toLowerCase();if(!zz.hasOwnProperty(s)){this.sanitizedSomething=!0;continue}let l=o.value;_P[s]&&(l=vy(l)),this.buf.push(" ",a,'="',jH(l),'"')}return this.buf.push(">"),!0}endElement(t){let e=t.nodeName.toLowerCase();sk.hasOwnProperty(e)&&!Bz.hasOwnProperty(e)&&(this.buf.push("</"),this.buf.push(e),this.buf.push(">"))}chars(t){this.buf.push(jH(t))}checkClobberedElement(t,e){if(e&&(t.compareDocumentPosition(e)&Node.DOCUMENT_POSITION_CONTAINED_BY)===Node.DOCUMENT_POSITION_CONTAINED_BY)throw new Error(`Failed to sanitize html because the element is clobbered: ${t.outerHTML}`);return e}},Oae=/[\uD800-\uDBFF][\uDC00-\uDFFF]/g,Fae=/([^\#-~ |!])/g;function jH(n){return n.replace(/&/g,"&amp;").replace(Oae,function(t){return"&#"+(1024*(t.charCodeAt(0)-55296)+(t.charCodeAt(1)-56320)+65536)+";"}).replace(Fae,function(t){return"&#"+t.charCodeAt(0)+";"}).replace(/</g,"&lt;").replace(/>/g,"&gt;")}function yP(n,t){let e=null;try{qC=qC||Nz(n);let i=t?String(t):"";e=qC.getInertBodyElement(i);let r=5,o=i;do{if(0===r)throw new Error("Failed to sanitize html because the input is unstable");r--,i=o,o=e.innerHTML,e=qC.getInertBodyElement(i)}while(i!==o);return hh((new lk).sanitizeChildren(ck(e)||e))}finally{if(e){let i=ck(e)||e;for(;i.firstChild;)i.removeChild(i.firstChild)}}}function ck(n){return"content"in n&&function(n){return n.nodeType===Node.ELEMENT_NODE&&"TEMPLATE"===n.nodeName}(n)?n.content:null}var qr=(()=>{return(n=qr||(qr={}))[n.NONE=0]="NONE",n[n.HTML=1]="HTML",n[n.STYLE=2]="STYLE",n[n.SCRIPT=3]="SCRIPT",n[n.URL=4]="URL",n[n.RESOURCE_URL=5]="RESOURCE_URL",qr;var n})();function bP(n){let t=Cy();return t?HH(t.sanitize(qr.HTML,n)||""):gl(n,"HTML")?HH(Ra(n)):yP(Rz(),Yn(n))}function As(n){let t=Cy();return t?t.sanitize(qr.URL,n)||"":gl(n,"URL")?Ra(n):vy(Yn(n))}function Uz(n){let t=Cy();if(t)return UH(t.sanitize(qr.RESOURCE_URL,n)||"");if(gl(n,"ResourceURL"))return UH(Ra(n));throw new bt(904,!1)}function Cy(){let n=Ke();return n&&n[zR]}var VM=new ie("ENVIRONMENT_INITIALIZER"),jz=new ie("INJECTOR",-1),Gz=new ie("INJECTOR_DEF_TYPES"),hM=class{get(t,e=ty){if(e===ty){let i=new Error(`NullInjectorError: No provider for ${ho(t)}!`);throw i.name="NullInjectorError",i}return e}};function jae(...n){return{"\u0275providers":Wz(0,n),"\u0275fromNgModule":!0}}function Wz(n,...t){let r,e=[],i=new Set;return aP(t,o=>{let a=o;dk(a,e,[],i)&&(r||(r=[]),r.push(a))}),void 0!==r&&qz(r,e),e}function qz(n,t){for(let e=0;e<n.length;e++){let{providers:r}=n[e];vP(r,o=>{t.push(o)})}}function dk(n,t,e,i){if(!(n=ki(n)))return!1;let r=null,o=DH(n),a=!o&&ws(n);if(o||a){if(a&&!a.standalone)return!1;r=n}else{let l=n.ngModule;if(o=DH(l),!o)return!1;r=l}let s=i.has(r);if(a){if(s)return!1;if(i.add(r),a.dependencies){let l="function"==typeof a.dependencies?a.dependencies():a.dependencies;for(let c of l)dk(c,t,e,i)}}else{if(!o)return!1;{if(null!=o.imports&&!s){let c;i.add(r);try{aP(o.imports,d=>{dk(d,t,e,i)&&(c||(c=[]),c.push(d))})}finally{}void 0!==c&&qz(c,t)}if(!s){let c=Up(r)||(()=>new r);t.push({provide:r,useFactory:c,deps:Ui},{provide:Gz,useValue:r,multi:!0},{provide:VM,useValue:()=>O(r),multi:!0})}let l=o.providers;null==l||s||vP(l,d=>{t.push(d)})}}return r!==n&&void 0!==n.providers}function vP(n,t){for(let e of n)C5(e)&&(e=e.\u0275providers),Array.isArray(e)?vP(e,t):t(e)}var Gae=nr({provide:String,useValue:nr});function Yz(n){return null!==n&&"object"==typeof n&&Gae in n}function oh(n){return"function"==typeof n}var xR,zM=new ie("Set Injector scope."),JC={},Xae={};function xP(){return void 0===xR&&(xR=new hM),xR}var lc=class{},gM=class extends lc{get destroyed(){return this._destroyed}constructor(t,e,i,r){super(),this.parent=e,this.source=i,this.scopes=r,this.records=new Map,this._ngOnDestroyHooks=new Set,this._onDestroyHooks=[],this._destroyed=!1,pk(t,a=>this.processProvider(a)),this.records.set(jz,eh(void 0,this)),r.has("environment")&&this.records.set(lc,eh(void 0,this));let o=this.records.get(zM);null!=o&&"string"==typeof o.value&&this.scopes.add(o.value),this.injectorDefTypes=new Set(this.get(Gz.multi,Ui,Mi.Self))}destroy(){this.assertNotDestroyed(),this._destroyed=!0;try{for(let t of this._ngOnDestroyHooks)t.ngOnDestroy();for(let t of this._onDestroyHooks)t()}finally{this.records.clear(),this._ngOnDestroyHooks.clear(),this.injectorDefTypes.clear(),this._onDestroyHooks.length=0}}onDestroy(t){this._onDestroyHooks.push(t)}runInContext(t){this.assertNotDestroyed();let e=Xm(this),i=Cs(void 0);try{return t()}finally{Xm(e),Cs(i)}}get(t,e=ty,i=Mi.Default){this.assertNotDestroyed(),i=IM(i);let r=Xm(this),o=Cs(void 0);try{if(!(i&Mi.SkipSelf)){let s=this.records.get(t);if(void 0===s){let l=("function"==typeof(n=t)||"object"==typeof n&&n instanceof ie)&&Wk(t);s=l&&this.injectableDefInScope(l)?eh(uk(t),JC):null,this.records.set(t,s)}if(null!=s)return this.hydrate(t,s)}return(i&Mi.Self?xP():this.parent).get(t,e=i&Mi.Optional&&e===ty?null:e)}catch(a){if("NullInjectorError"===a.name){if((a[rM]=a[rM]||[]).unshift(ho(t)),r)throw a;return function(n,t,e,i){let r=n[rM];throw t[IH]&&r.unshift(t[IH]),n.message=function(n,t,e,i=null){n=n&&"\n"===n.charAt(0)&&n.charAt(1)==zre?n.slice(2):n;let r=ho(t);if(Array.isArray(t))r=t.map(ho).join(" -> ");else if("object"==typeof t){let o=[];for(let a in t)if(t.hasOwnProperty(a)){let s=t[a];o.push(a+":"+("string"==typeof s?JSON.stringify(s):ho(s)))}r=`{${o.join(", ")}}`}return`${e}${i?"("+i+")":""}[${r}]: ${n.replace(Hre,"\n  ")}`}("\n"+n.message,r,e,i),n[Vre]=r,n[rM]=null,n}(a,t,"R3InjectorError",this.source)}throw a}finally{Cs(o),Xm(r)}var n}resolveInjectorInitializers(){let t=Xm(this),e=Cs(void 0);try{let i=this.get(VM.multi,Ui,Mi.Self);for(let r of i)r()}finally{Xm(t),Cs(e)}}toString(){let t=[],e=this.records;for(let i of e.keys())t.push(ho(i));return`R3Injector[${t.join(", ")}]`}assertNotDestroyed(){if(this._destroyed)throw new bt(205,!1)}processProvider(t){let e=oh(t=ki(t))?t:ki(t&&t.provide),i=function(n){return Yz(n)?eh(void 0,n.useValue):eh(Xz(n),JC)}(t);if(oh(t)||!0!==t.multi)this.records.get(e);else{let r=this.records.get(e);r||(r=eh(void 0,JC,!0),r.factory=()=>HR(r.multi),this.records.set(e,r)),e=t,r.multi.push(t)}this.records.set(e,i)}hydrate(t,e){return e.value===JC&&(e.value=Xae,e.value=e.factory()),"object"==typeof e.value&&e.value&&null!==(n=e.value)&&"object"==typeof n&&"function"==typeof n.ngOnDestroy&&this._ngOnDestroyHooks.add(e.value),e.value;var n}injectableDefInScope(t){if(!t.providedIn)return!1;let e=ki(t.providedIn);return"string"==typeof e?"any"===e||this.scopes.has(e):this.injectorDefTypes.has(e)}};function uk(n){let t=Wk(n),e=null!==t?t.factory:Up(n);if(null!==e)return e;if(n instanceof ie)throw new bt(204,!1);if(n instanceof Function)return function(n){let t=n.length;if(t>0)throw X_(t,"?"),new bt(204,!1);let e=function(n){return n&&(n[iM]||n[w5])||null}(n);return null!==e?()=>e.factory(n):()=>new n}(n);throw new bt(204,!1)}function Xz(n,t,e){let i;if(oh(n)){let r=ki(n);return Up(r)||uk(r)}if(Yz(n))i=()=>ki(n.useValue);else if(function(n){return!(!n||!n.useFactory)}(n))i=()=>n.useFactory(...HR(n.deps||[]));else if(function(n){return!(!n||!n.useExisting)}(n))i=()=>O(ki(n.useExisting));else{let r=ki(n&&(n.useClass||n.provide));if(!function(n){return!!n.deps}(n))return Up(r)||uk(r);i=()=>new r(...HR(n.deps))}return i}function eh(n,t,e=!1){return{factory:n,value:t,multi:e?[]:void 0}}function pk(n,t){for(let e of n)Array.isArray(e)?pk(e,t):e&&C5(e)?pk(e.\u0275providers,t):t(e)}var fk=class{},_M=class{},mk=class{resolveComponentFactory(t){throw function(n){let t=Error(`No component factory found for ${ho(n)}. Did you add it to @NgModule.entryComponents?`);return t.ngComponent=n,t}(t)}},Qr=(()=>{class n{}return n.NULL=new mk,n})();function nse(){return gh(Po(),Ke())}function gh(n,t){return new be(ts(n,t))}var be=(()=>{class n{constructor(e){this.nativeElement=e}}return n.__NG_ELEMENT_ID__=nse,n})();function ise(n){return n instanceof be?n.nativeElement:n}var cc=class{},dc=(()=>{class n{}return n.__NG_ELEMENT_ID__=()=>function(){let n=Ke(),e=ed(Po().index,n);return(Hp(e)?e:n)[li]}(),n})(),ose=(()=>{class n{}return n.\u0275prov=pe({token:n,providedIn:"root",factory:()=>null}),n})(),hl=class{constructor(t){this.full=t,this.major=t.split(".")[0],this.minor=t.split(".")[1],this.patch=t.split(".").slice(2).join(".")}},ase=new hl("15.2.9"),CR={},sse="ngOriginalError";function MR(n){return n[sse]}var ca=class{constructor(){this._console=console}handleError(t){let e=this._findOriginalError(t);this._console.error("ERROR",t),e&&this._console.error("ORIGINAL ERROR",e)}_findOriginalError(t){let e=t&&MR(t);for(;e&&MR(e);)e=MR(e);return e||null}};function uc(n){return n.ownerDocument}function $C(n){return n instanceof Function?n():n}function Qz(n,t,e){let i=n.length;for(;;){let r=n.indexOf(t,e);if(-1===r)return r;if(0===r||n.charCodeAt(r-1)<=32){let o=t.length;if(r+o===i||n.charCodeAt(r+o)<=32)return r}e=r+1}}var Zz="ng-template";function dse(n,t,e){let i=0,r=!0;for(;i<n.length;){let o=n[i++];if("string"==typeof o&&r){let a=n[i++];if(e&&"class"===o&&-1!==Qz(a.toLowerCase(),t,0))return!0}else{if(1===o){for(;i<n.length&&"string"==typeof(o=n[i++]);)if(o.toLowerCase()===t)return!0;return!1}"number"==typeof o&&(r=!1)}}return!1}function Kz(n){return 4===n.type&&n.value!==Zz}function use(n,t,e){return t===(4!==n.type||e?n.value:Zz)}function pse(n,t,e){let i=4,r=n.attrs||[],o=function(n){for(let t=0;t<n.length;t++)if(K5(n[t]))return t;return n.length}(r),a=!1;for(let s=0;s<t.length;s++){let l=t[s];if("number"!=typeof l){if(!a)if(4&i){if(i=2|1&i,""!==l&&!use(n,l,e)||""===l&&1===t.length){if(dl(i))return!1;a=!0}}else{let c=8&i?l:t[++s];if(8&i&&null!==n.attrs){if(!dse(n.attrs,c,e)){if(dl(i))return!1;a=!0}continue}let u=fse(8&i?"class":l,r,Kz(n),e);if(-1===u){if(dl(i))return!1;a=!0;continue}if(""!==c){let p;p=u>o?"":r[u+1].toLowerCase();let f=8&i?p:null;if(f&&-1!==Qz(f,c,0)||2&i&&c!==p){if(dl(i))return!1;a=!0}}}}else{if(!a&&!dl(i)&&!dl(l))return!1;if(a&&dl(l))continue;a=!1,i=l|1&i}}return dl(i)||a}function dl(n){return 0==(1&n)}function fse(n,t,e,i){if(null===t)return-1;let r=0;if(i||!e){let o=!1;for(;r<t.length;){let a=t[r];if(a===n)return r;if(3===a||6===a)o=!0;else{if(1===a||2===a){let s=t[++r];for(;"string"==typeof s;)s=t[++r];continue}if(4===a)break;if(0===a){r+=4;continue}}r+=o?1:2}return-1}return function(n,t){let e=n.indexOf(4);if(e>-1)for(e++;e<n.length;){let i=n[e];if("number"==typeof i)return-1;if(i===t)return e;e++}return-1}(t,n)}function Jz(n,t,e=!1){for(let i=0;i<t.length;i++)if(pse(n,t[i],e))return!0;return!1}function _se(n,t){e:for(let e=0;e<t.length;e++){let i=t[e];if(n.length===i.length){for(let r=0;r<n.length;r++)if(n[r]!==i[r])continue e;return!0}}return!1}function GH(n,t){return n?":not("+t.trim()+")":t}function yse(n){let t=n[0],e=1,i=2,r="",o=!1;for(;e<n.length;){let a=n[e];if("string"==typeof a)if(2&i){let s=n[++e];r+="["+a+(s.length>0?'="'+s+'"':"")+"]"}else 8&i?r+="."+a:4&i&&(r+=" "+a);else""!==r&&!dl(a)&&(t+=GH(o,r),r=""),i=a,o=o||!dl(i);e++}return""!==r&&(t+=GH(o,r)),t}var Gn={};function b(n){$z(Ei(),Ke(),ua()+n,!1)}function $z(n,t,e,i){if(!i)if(3==(3&t[si])){let o=n.preOrderCheckHooks;null!==o&&XC(t,o,e)}else{let o=n.preOrderHooks;null!==o&&QC(t,o,0,e)}jp(e)}var WH={"\u0275\u0275defineInjectable":pe,"\u0275\u0275defineInjector":B,"\u0275\u0275inject":O,"\u0275\u0275invalidFactoryDep":E5,resolveForwardRef:ki};var Cse=nr({provide:String,useValue:nr});function qH(n){return void 0!==n.useClass}function YH(n){return void 0!==n.useFactory}var eU=_y("Injectable",void 0,void 0,void 0,(n,t)=>function(n,t){let e=null,i=null;n.hasOwnProperty(iM)||Object.defineProperty(n,iM,{get:()=>(null===e&&(e=Ss().compileInjectable(WH,`ng:///${n.name}/\u0275prov.js`,function(n,t){let e=t||{providedIn:null},i={name:n.name,type:n,typeArgumentCount:0,providedIn:e.providedIn};return(qH(e)||YH(e))&&void 0!==e.deps&&(i.deps=cz(e.deps)),qH(e)?i.useClass=e.useClass:function(n){return Cse in n}(e)?i.useValue=e.useValue:YH(e)?i.useFactory=e.useFactory:function(n){return void 0!==n.useExisting}(e)&&(i.useExisting=e.useExisting),i}(n,t))),e)}),n.hasOwnProperty(Kc)||Object.defineProperty(n,Kc,{get:()=>{if(null===i){let r=Ss();i=r.compileFactory(WH,`ng:///${n.name}/\u0275fac.js`,{name:n.name,type:n,typeArgumentCount:0,deps:LM(n),target:r.FactoryTarget.Injectable})}return i},configurable:!0})}(n,t));function XH(n,t=null,e=null,i){let r=tU(n,t,e,i);return r.resolveInjectorInitializers(),r}function tU(n,t=null,e=null,i,r=new Set){let o=[e||Ui,jae(n)];return i=i||("object"==typeof n?void 0:ho(n)),new gM(o,t||xP(),i||null,r)}var bi=(()=>{class n{static create(e,i){if(Array.isArray(e))return XH({name:""},i,e,"");{let r=e.name??"";return XH({name:r},e.parent,e.providers,r)}}}return n.THROW_IF_NOT_FOUND=ty,n.NULL=new hM,n.\u0275prov=pe({token:n,providedIn:"any",factory:()=>O(jz)}),n.__NG_ELEMENT_ID__=-1,n})(),Q_=class{constructor(t,e){if(this.token=t,this.id=e,!t)throw new bt(208,!1);this.displayName=ho(this.token)}static get(t){return QH.get(ki(t))}static get numberOfKeys(){return QH.numberOfKeys}},QH=new class{constructor(){this._allKeys=new Map}get(t){if(t instanceof Q_)return t;if(this._allKeys.has(t))return this._allKeys.get(t);let e=new Q_(t,Q_.numberOfKeys);return this._allKeys.set(t,e),e}get numberOfKeys(){return this._allKeys.size}};function C(n,t=Mi.Default){let e=Ke();return null===e?O(n,t):rz(Po(),e,ki(n),t)}function _l(){throw new Error("invalid")}function nU(n,t){let e=n.contentQueries;if(null!==e)for(let i=0;i<e.length;i+=2){let o=e[i+1];if(-1!==o){let a=n.data[o];tP(e[i]),a.contentQueries(2,t[o],o)}}}function UM(n,t,e,i,r,o,a,s,l,c,d){let u=t.blueprint.slice();return u[lu]=r,u[si]=76|i,(null!==d||n&&1024&n[si])&&(u[si]|=1024),V5(u),u[Yr]=u[dh]=n,u[Ia]=e,u[sM]=a||n&&n[sM],u[li]=s||n&&n[li],u[zR]=l||n&&n[zR]||null,u[aM]=c||n&&n[aM]||null,u[Da]=o,u[RM]=iae++,u[R5]=d,u[fl]=2==t.type?n[fl]:u,u}function _h(n,t,e,i,r){let o=n.data[t];if(null===o)o=CP(n,t,e,i,r),Xn.lFrame.inI18n&&(o.flags|=32);else if(64&o.type){o.type=e,o.value=i,o.attrs=r;let a=ry();o.injectorIndex=null===a?-1:a.injectorIndex}return ac(o,!0),o}function CP(n,t,e,i,r){let o=z5(),a=Jk(),l=n.data[t]=function(n,t,e,i,r,o){return{type:e,index:i,insertBeforeIndex:null,injectorIndex:t?t.injectorIndex:-1,directiveStart:-1,directiveEnd:-1,directiveStylingLast:-1,componentOffset:-1,propertyBindings:null,flags:0,providerIndexes:0,value:r,attrs:o,mergedAttrs:null,localNames:null,initialInputs:void 0,inputs:null,outputs:null,tView:null,next:null,prev:null,projectionNext:null,child:null,parent:t,projection:null,styles:null,stylesWithoutHost:null,residualStyles:void 0,classes:null,classesWithoutHost:null,residualClasses:void 0,classBindings:0,styleBindings:0}}(0,a?o:o&&o.parent,e,t,i,r);return null===n.firstChild&&(n.firstChild=l),null!==o&&(a?null==o.child&&null!==l.parent&&(o.child=l):null===o.next&&(o.next=l,l.prev=o)),l}function My(n,t,e,i){if(0===e)return-1;let r=t.length;for(let o=0;o<e;o++)t.push(i),n.blueprint.push(i),n.data.push(null);return r}function MP(n,t,e){nP(t);try{let i=n.viewQuery;null!==i&&yk(1,i,e);let r=n.template;null!==r&&iU(n,t,r,1,e),n.firstCreatePass&&(n.firstCreatePass=!1),n.staticContentQueries&&nU(n,t),n.staticViewQueries&&yk(2,n.viewQuery,e);let o=n.components;null!==o&&function(n,t){for(let e=0;e<t.length;e++)Zse(n,t[e])}(t,o)}catch(i){throw n.firstCreatePass&&(n.incompleteFirstPass=!0,n.firstCreatePass=!1),i}finally{t[si]&=-5,iP()}}function jM(n,t,e,i){let r=t[si];if(128!=(128&r)){nP(t);try{V5(t),U5(n.bindingStartIndex),null!==e&&iU(n,t,e,2,i);let a=3==(3&r);if(a){let c=n.preOrderCheckHooks;null!==c&&XC(t,c,null)}else{let c=n.preOrderHooks;null!==c&&QC(t,c,0,null),gR(t,0)}if(function(n){for(let t=dP(n);null!==t;t=uP(t)){if(!t[k5])continue;let e=t[ih];for(let i=0;i<e.length;i++){let r=e[i];0==(512&r[si])&&Kk(r[Yr],1),r[si]|=512}}}(t),function(n){for(let t=dP(n);null!==t;t=uP(t))for(let e=Ta;e<t.length;e++){let i=t[e],r=i[Bn];cM(i)&&jM(r,i,r.template,i[Ia])}}(t),null!==n.contentQueries&&nU(n,t),a){let c=n.contentCheckHooks;null!==c&&XC(t,c)}else{let c=n.contentHooks;null!==c&&QC(t,c,1),gR(t,1)}!function(n,t){let e=n.hostBindingOpCodes;if(null!==e)try{for(let i=0;i<e.length;i++){let r=e[i];if(r<0)jp(~r);else{let o=r,a=e[++i],s=e[++i];coe(a,o),s(2,t[o])}}}finally{jp(-1)}}(n,t);let s=n.components;null!==s&&function(n,t){for(let e=0;e<t.length;e++)Qse(n,t[e])}(t,s);let l=n.viewQuery;if(null!==l&&yk(2,l,i),a){let c=n.viewCheckHooks;null!==c&&XC(t,c)}else{let c=n.viewHooks;null!==c&&QC(t,c,2),gR(t,2)}!0===n.firstUpdatePass&&(n.firstUpdatePass=!1),t[si]&=-41,512&t[si]&&(t[si]&=-513,Kk(t[Yr],-1))}finally{iP()}}}function iU(n,t,e,i,r){let o=ua(),a=2&i;try{jp(-1),a&&t.length>Xr&&$z(n,t,Xr,!1),Ms(a?2:0,r),e(i,r)}finally{jp(o),Ms(a?3:1,r)}}function wP(n,t,e){if(Zk(t)){let r=t.directiveEnd;for(let o=t.directiveStart;o<r;o++){let a=n.data[o];a.contentQueries&&a.contentQueries(1,e[o],o)}}}function SP(n,t,e){!H5()||(function(n,t,e,i){let r=e.directiveStart,o=e.directiveEnd;kM(e)&&function(n,t,e){let i=ts(t,n),r=rU(e),o=n[sM],a=GM(n,UM(n,r,null,e.onPush?32:16,i,t,o,o.createRenderer(i,e),null,null,null));n[t.index]=a}(t,e,n.data[r+e.componentOffset]),n.firstCreatePass||fM(e,t),sc(i,t);let a=e.initialInputs;for(let s=r;s<o;s++){let l=n.data[s],c=Wp(t,n,s,e);sc(c,t),null!==a&&Wse(0,s-r,c,l,0,a),ml(l)&&(ed(e.index,t)[Ia]=Wp(t,n,s,e))}}(n,t,e,ts(e,t)),64==(64&e.flags)&&sU(n,t,e))}function EP(n,t,e=ts){let i=t.localNames;if(null!==i){let r=t.index+1;for(let o=0;o<i.length;o+=2){let a=i[o+1],s=-1===a?e(t,n):n[a];n[r++]=s}}}function rU(n){let t=n.tView;return null===t||t.incompleteFirstPass?n.tView=TP(1,null,n.template,n.decls,n.vars,n.directiveDefs,n.pipeDefs,n.viewQuery,n.schemas,n.consts):t}function TP(n,t,e,i,r,o,a,s,l,c){let d=Xr+i,u=d+r,p=function(n,t){let e=[];for(let i=0;i<t;i++)e.push(i<n?null:Gn);return e}(d,u),f="function"==typeof c?c():c;return p[Bn]={type:n,blueprint:p,template:e,queries:null,viewQuery:s,declTNode:t,data:p.slice().fill(null,d),bindingStartIndex:d,expandoStartIndex:u,hostBindingOpCodes:null,firstCreatePass:!0,firstUpdatePass:!0,staticViewQueries:!1,staticContentQueries:!1,preOrderHooks:null,preOrderCheckHooks:null,contentHooks:null,contentCheckHooks:null,viewHooks:null,viewCheckHooks:null,destroyHooks:null,cleanup:null,contentQueries:null,components:null,directiveRegistry:"function"==typeof o?o():o,pipeRegistry:"function"==typeof a?a():a,firstChild:null,schemas:l,consts:f,incompleteFirstPass:!1}}function oU(n,t,e,i){let r=dU(t);null===e?r.push(i):(r.push(e),n.firstCreatePass&&uU(n).push(i,r.length-1))}function ZH(n,t,e,i){for(let r in n)if(n.hasOwnProperty(r)){e=null===e?{}:e;let o=n[r];null===i?KH(e,t,r,o):i.hasOwnProperty(r)&&KH(e,t,i[r],o)}return e}function KH(n,t,e,i){n.hasOwnProperty(e)?n[e].push(t,i):n[e]=[t,i]}function is(n,t,e,i,r,o,a,s){let d,l=ts(t,e),c=t.inputs;!s&&null!=c&&(d=c[i])?(RP(n,e,d,i,r),kM(t)&&function(n,t){let e=ed(t,n);16&e[si]||(e[si]|=32)}(e,t.index)):3&t.type&&(i=function(n){return"class"===n?"className":"for"===n?"htmlFor":"formaction"===n?"formAction":"innerHtml"===n?"innerHTML":"readonly"===n?"readOnly":"tabindex"===n?"tabIndex":n}(i),r=null!=a?a(r,t.value||"",i):r,o.setProperty(l,i,r))}function DP(n,t,e,i){if(H5()){let a,s,r=null===i?null:{"":-1},o=function(n,t){let e=n.directiveRegistry,i=null,r=null;if(e)for(let o=0;o<e.length;o++){let a=e[o];if(Jz(t,a.selectors,!1))if(i||(i=[]),ml(a))if(null!==a.findHostDirectiveDefs){let s=[];r=r||new Map,a.findHostDirectiveDefs(a,s,r),i.unshift(...s,a),gk(n,t,s.length)}else i.unshift(a),gk(n,t,0);else r=r||new Map,a.findHostDirectiveDefs?.(a,i,r),i.push(a)}return null===i?null:[i,r]}(n,e);null===o?a=s=null:[a,s]=o,null!==a&&aU(n,t,e,a,r,s),r&&function(n,t,e){if(t){let i=n.localNames=[];for(let r=0;r<t.length;r+=2){let o=e[t[r+1]];if(null==o)throw new bt(-301,!1);i.push(t[r],o)}}}(e,i,r)}e.mergedAttrs=oy(e.mergedAttrs,e.attrs)}function aU(n,t,e,i,r,o){for(let c=0;c<i.length;c++)qR(fM(e,t),n,i[c].type);!function(n,t,e){n.flags|=1,n.directiveStart=t,n.directiveEnd=t+e,n.providerIndexes=t}(e,n.data.length,i.length);for(let c=0;c<i.length;c++){let d=i[c];d.providersResolver&&d.providersResolver(d)}let a=!1,s=!1,l=My(n,t,i.length,null);for(let c=0;c<i.length;c++){let d=i[c];e.mergedAttrs=oy(e.mergedAttrs,d.hostAttrs),jse(n,e,t,l,d),zse(l,d,r),null!==d.contentQueries&&(e.flags|=4),(null!==d.hostBindings||null!==d.hostAttrs||0!==d.hostVars)&&(e.flags|=64);let u=d.type.prototype;!a&&(u.ngOnChanges||u.ngOnInit||u.ngDoCheck)&&((n.preOrderHooks??(n.preOrderHooks=[])).push(e.index),a=!0),!s&&(u.ngOnChanges||u.ngDoCheck)&&((n.preOrderCheckHooks??(n.preOrderCheckHooks=[])).push(e.index),s=!0),l++}!function(n,t,e){let r=t.directiveEnd,o=n.data,a=t.attrs,s=[],l=null,c=null;for(let d=t.directiveStart;d<r;d++){let u=o[d],p=e?e.get(u):null,m=p?p.outputs:null;l=ZH(u.inputs,d,l,p?p.inputs:null),c=ZH(u.outputs,d,c,m);let y=null===l||null===a||Kz(t)?null:qse(l,d,a);s.push(y)}null!==l&&(l.hasOwnProperty("class")&&(t.flags|=8),l.hasOwnProperty("style")&&(t.flags|=16)),t.initialInputs=s,t.inputs=l,t.outputs=c}(n,e,o)}function sU(n,t,e){let i=e.directiveStart,r=e.directiveEnd,o=e.index,a=Xn.lFrame.currentDirectiveIndex;try{jp(o);for(let s=i;s<r;s++){let l=n.data[s],c=t[s];jR(s),(null!==l.hostBindings||0!==l.hostVars||null!==l.hostAttrs)&&Bse(l,c)}}finally{jp(-1),jR(a)}}function Bse(n,t){null!==n.hostBindings&&n.hostBindings(1,t)}function gk(n,t,e){t.componentOffset=e,(n.components??(n.components=[])).push(t.index)}function zse(n,t,e){if(e){if(t.exportAs)for(let i=0;i<t.exportAs.length;i++)e[t.exportAs[i]]=n;ml(t)&&(e[""]=n)}}function jse(n,t,e,i,r){n.data[i]=r;let o=r.factory||(r.factory=Up(r.type)),a=new Gp(o,ml(r),C);n.blueprint[i]=a,e[i]=a,function(n,t,e,i,r){let o=r.hostBindings;if(o){let a=n.hostBindingOpCodes;null===a&&(a=n.hostBindingOpCodes=[]);let s=~t.index;(function(n){let t=n.length;for(;t>0;){let e=n[--t];if("number"==typeof e&&e<0)return e}return 0})(a)!=s&&a.push(s),a.push(e,i,o)}}(n,t,i,My(n,e,r.hostVars,Gn),r)}function pc(n,t,e,i,r,o){let a=ts(n,t);IP(t[li],a,o,n.value,e,i,r)}function IP(n,t,e,i,r,o,a){if(null==o)n.removeAttribute(t,r,e);else{let s=null==a?Yn(o):a(o,i||"",r);n.setAttribute(t,r,s,e)}}function Wse(n,t,e,i,r,o){let a=o[t];if(null!==a){let s=i.setInput;for(let l=0;l<a.length;){let c=a[l++],d=a[l++],u=a[l++];null!==s?i.setInput(e,u,c,d):e[d]=u}}}function qse(n,t,e){let i=null,r=0;for(;r<e.length;){let o=e[r];if(0!==o)if(5!==o){if("number"==typeof o)break;if(n.hasOwnProperty(o)){null===i&&(i=[]);let a=n[o];for(let s=0;s<a.length;s+=2)if(a[s]===t){i.push(o,a[s+1],e[r+1]);break}}r+=2}else r+=2;else r+=4}return i}function lU(n,t,e,i){return[n,!0,!1,t,null,0,i,e,null,null]}function Qse(n,t){let e=ed(t,n);if(cM(e)){let i=e[Bn];48&e[si]?jM(i,e,i.template,e[Ia]):e[Vp]>0&&_k(e)}}function _k(n){for(let i=dP(n);null!==i;i=uP(i))for(let r=Ta;r<i.length;r++){let o=i[r];if(cM(o))if(512&o[si]){let a=o[Bn];jM(a,o,a.template,o[Ia])}else o[Vp]>0&&_k(o)}let e=n[Bn].components;if(null!==e)for(let i=0;i<e.length;i++){let r=ed(e[i],n);cM(r)&&r[Vp]>0&&_k(r)}}function Zse(n,t){let e=ed(t,n),i=e[Bn];(function(n,t){for(let e=t.length;e<n.blueprint.length;e++)t.push(n.blueprint[e])})(i,e),MP(i,e,e[Ia])}function GM(n,t){return n[iy]?n[RH][pl]=t:n[iy]=t,n[RH]=t,t}function AP(n){for(;n;){n[si]|=32;let t=cP(n);if(Qre(n)&&!t)return n;n=t}return null}function cU(n,t,e,i=!0){let r=t[sM];r.begin&&r.begin();try{jM(n,t,n.template,e)}catch(a){throw i&&fU(t,a),a}finally{r.end&&r.end()}}function yk(n,t,e){tP(0),t(n,e)}function dU(n){return n[ny]||(n[ny]=[])}function uU(n){return n.cleanup||(n.cleanup=[])}function pU(n,t,e){return(null===n||ml(n))&&(e=function(n){for(;Array.isArray(n);){if("object"==typeof n[Xk])return n;n=n[lu]}return null}(e[t.index])),e[li]}function fU(n,t){let e=n[aM],i=e?e.get(ca,null):null;i&&i.handleError(t)}function RP(n,t,e,i,r){for(let o=0;o<e.length;){let a=e[o++],s=e[o++],l=t[a],c=n.data[a];null!==c.setInput?c.setInput(l,r,i,s):l[s]=r}}function od(n,t,e){let i=OM(t,n);hz(n[li],i,e)}function yM(n,t,e){let i=e?n.styles:null,r=e?n.classes:null,o=0;if(null!==t)for(let a=0;a<t.length;a++){let s=t[a];"number"==typeof s?o=s:1==o?r=LR(r,s):2==o&&(i=LR(i,s+": "+t[++a]+";"))}e?n.styles=i:n.stylesWithoutHost=i,e?n.classes=r:n.classesWithoutHost=r}function eM(n,t,e,i,r=!1){for(;null!==e;){let o=t[e.index];if(null!==o&&i.push(Ts(o)),$c(o))for(let s=Ta;s<o.length;s++){let l=o[s],c=l[Bn].firstChild;null!==c&&eM(l[Bn],l,c,i)}let a=e.type;if(8&a)eM(n,t,e.child,i);else if(32&a){let l,s=lP(e,t);for(;l=s();)i.push(l)}else if(16&a){let s=Sz(t,e);if(Array.isArray(s))i.push(...s);else{let l=cP(t[fl]);eM(l[Bn],l,s,i,!0)}}e=r?e.projectionNext:e.next}return i}var Yp=class{get rootNodes(){let t=this._lView,e=t[Bn];return eM(e,t,e.firstChild,[])}constructor(t,e){this._lView=t,this._cdRefInjectingView=e,this._appRef=null,this._attachedToViewContainer=!1}get context(){return this._lView[Ia]}set context(t){this._lView[Ia]=t}get destroyed(){return 128==(128&this._lView[si])}destroy(){if(this._appRef)this._appRef.detachView(this);else if(this._attachedToViewContainer){let t=this._lView[Yr];if($c(t)){let e=t[lM],i=e?e.indexOf(this):-1;i>-1&&(ZR(t,i),mM(e,i))}this._attachedToViewContainer=!1}_z(this._lView[Bn],this._lView)}onDestroy(t){oU(this._lView[Bn],this._lView,null,t)}markForCheck(){AP(this._cdRefInjectingView||this._lView)}detach(){this._lView[si]&=-65}reattach(){this._lView[si]|=64}detectChanges(){cU(this._lView[Bn],this._lView,this.context)}checkNoChanges(){}attachToViewContainerRef(){if(this._appRef)throw new bt(902,!1);this._attachedToViewContainer=!0}detachFromAppRef(){var t;this._appRef=null,by(this._lView[Bn],t=this._lView,t[li],2,null,null)}attachToAppRef(t){if(this._attachedToViewContainer)throw new bt(902,!1);this._appRef=t}},bk=class extends Yp{constructor(t){super(t),this._view=t}detectChanges(){let t=this._view;cU(t[Bn],t,t[Ia],!1)}checkNoChanges(){}get context(){return null}},bM=class extends Qr{constructor(t){super(),this.ngModule=t}resolveComponentFactory(t){let e=ws(t);return new vM(e,this.ngModule)}};function JH(n){let t=[];for(let e in n)n.hasOwnProperty(e)&&t.push({propName:n[e],templateName:e});return t}var vM=class extends _M{get inputs(){return JH(this.componentDef.inputs)}get outputs(){return JH(this.componentDef.outputs)}constructor(t,e){super(),this.componentDef=t,this.ngModule=e,this.componentType=t.type,this.selector=t.selectors.map(yse).join(","),this.ngContentSelectors=t.ngContentSelectors?t.ngContentSelectors:[],this.isBoundToModule=!!e}create(t,e,i,r){let o=(r=r||this.ngModule)instanceof lc?r:r?.injector;o&&null!==this.componentDef.getStandaloneInjector&&(o=this.componentDef.getStandaloneInjector(o)||o);let a=o?new class{constructor(t,e){this.injector=t,this.parentInjector=e}get(t,e,i){i=IM(i);let r=this.injector.get(t,CR,i);return r!==CR||e===CR?r:this.parentInjector.get(t,e,i)}}(t,o):t,s=a.get(cc,null);if(null===s)throw new bt(407,!1);let y,M,l=a.get(ose,null),c=s.createRenderer(null,this.componentDef),d=this.componentDef.selectors[0][0]||"div",u=i?function(n,t,e){return n.selectRootElement(t,e===es.ShadowDom)}(c,i,this.componentDef.encapsulation):fP(c,d,function(n){let t=n.toLowerCase();return"svg"===t?L5:"math"===t?N5:null}(d)),p=this.componentDef.onPush?288:272,f=TP(0,null,null,1,0,null,null,null,null,null),m=UM(null,f,null,p,null,null,s,c,l,a,null);nP(m);try{let x,v=this.componentDef,R=null;v.findHostDirectiveDefs?(x=[],R=new Map,v.findHostDirectiveDefs(v,x,R),x.push(v)):x=[v];let A=function(n,t){let e=n[Bn],i=Xr;return n[i]=t,_h(e,i,2,"#host",null)}(m,u),H=function(n,t,e,i,r,o,a,s){let l=r[Bn];!function(n,t,e,i){for(let r of n)t.mergedAttrs=oy(t.mergedAttrs,r.hostAttrs);null!==t.mergedAttrs&&(yM(t,t.mergedAttrs,!0),null!==e&&Dz(i,e,t))}(i,n,t,a);let c=o.createRenderer(t,e),d=UM(r,rU(e),null,e.onPush?32:16,r[n.index],n,o,c,null,null,null);return l.firstCreatePass&&gk(l,n,i.length-1),GM(r,d),r[n.index]=d}(A,u,v,x,m,s,c);M=B5(f,Xr),u&&function(n,t,e,i){if(i)GR(n,e,["ng-version",ase.full]);else{let{attrs:r,classes:o}=function(n){let t=[],e=[],i=1,r=2;for(;i<n.length;){let o=n[i];if("string"==typeof o)2===r?""!==o&&t.push(o,n[++i]):8===r&&e.push(o);else{if(!dl(r))break;r=o}i++}return{attrs:t,classes:e}}(t.selectors[0]);r&&GR(n,e,r),o&&o.length>0&&Tz(n,e,o.join(" "))}}(c,v,u,i),void 0!==e&&function(n,t,e){let i=n.projection=[];for(let r=0;r<t.length;r++){let o=e[r];i.push(null!=o?Array.from(o):null)}}(M,this.ngContentSelectors,e),y=function(n,t,e,i,r,o){let a=Po(),s=r[Bn],l=ts(a,r);aU(s,r,a,e,null,i);for(let d=0;d<e.length;d++)sc(Wp(r,s,a.directiveStart+d,a),r);sU(s,r,a),l&&sc(l,r);let c=Wp(r,s,a.directiveStart+a.componentOffset,a);if(n[Ia]=r[Ia]=c,null!==o)for(let d of o)d(c,t);return wP(s,a,n),c}(H,v,x,R,m,[ole]),MP(f,m,null)}finally{iP()}return new xk(this.componentType,y,gh(M,m),m,M)}},xk=class extends fk{constructor(t,e,i,r,o){super(),this.location=i,this._rootLView=r,this._tNode=o,this.instance=e,this.hostView=this.changeDetectorRef=new bk(r),this.componentType=t}setInput(t,e){let r,i=this._tNode.inputs;if(null!==i&&(r=i[t])){let o=this._rootLView;RP(o[Bn],o,r,t,e),AP(ed(this._tNode.index,o))}}get injector(){return new zp(this._tNode,this._rootLView)}destroy(){this.hostView.destroy()}onDestroy(t){this.hostView.onDestroy(t)}};function ole(){let n=Po();FM(Ke()[Bn],n)}function mU(n){return Object.getPrototypeOf(n.prototype).constructor}function Le(n){let t=mU(n.type),e=!0,i=[n];for(;t;){let r;if(ml(n))r=t.\u0275cmp||t.\u0275dir;else{if(t.\u0275cmp)throw new bt(903,!1);r=t.\u0275dir}if(r){if(e){i.push(r);let a=n;a.inputs=wR(n.inputs),a.declaredInputs=wR(n.declaredInputs),a.outputs=wR(n.outputs);let s=r.hostBindings;s&&cle(n,s);let l=r.viewQuery,c=r.contentQueries;if(l&&sle(n,l),c&&lle(n,c),hR(n.inputs,r.inputs),hR(n.declaredInputs,r.declaredInputs),hR(n.outputs,r.outputs),ml(r)&&r.data.animation){let d=n.data;d.animation=(d.animation||[]).concat(r.data.animation)}}let o=r.features;if(o)for(let a=0;a<o.length;a++){let s=o[a];s&&s.ngInherit&&s(n),s===Le&&(e=!1)}}t=Object.getPrototypeOf(t)}!function(n){let t=0,e=null;for(let i=n.length-1;i>=0;i--){let r=n[i];r.hostVars=t+=r.hostVars,r.hostAttrs=oy(r.hostAttrs,e=oy(e,r.hostAttrs))}}(i)}function wR(n){return n===Zc?{}:n===Ui?[]:n}function sle(n,t){let e=n.viewQuery;n.viewQuery=e?(i,r)=>{t(i,r),e(i,r)}:t}function lle(n,t){let e=n.contentQueries;n.contentQueries=e?(i,r,o)=>{t(i,r,o),e(i,r,o)}:t}function cle(n,t){let e=n.hostBindings;n.hostBindings=e?(i,r)=>{t(i,r),e(i,r)}:t}var dle=["providersResolver"],ule=["template","decls","consts","vars","onPush","ngContentSelectors","styles","encapsulation","schemas"];function hU(n,t,e){if(null!==n.hostDirectives)for(let i of n.hostDirectives){let r=iu(i.directive);mle(r.declaredInputs,i.inputs),hU(r,t,e),e.set(r,i),t.push(r)}}function $H(n){if(void 0===n||0===n.length)return Zc;let t={};for(let e=0;e<n.length;e+=2)t[n[e]]=n[e+1];return t}function mle(n,t){for(let e in t)t.hasOwnProperty(e)&&(n[t[e]]=n[e])}function gU(n){return!!kP(n)&&(Array.isArray(n)||!(n instanceof Map)&&Symbol.iterator in n)}function kP(n){return null!==n&&("function"==typeof n||"object"==typeof n)}function fc(n,t,e){return n[t]=e}function wy(n,t){return n[t]}function jo(n,t,e){return!Object.is(n[t],e)&&(n[t]=e,!0)}function Xp(n,t,e,i){let r=jo(n,t,e);return jo(n,t+1,i)||r}function WM(n,t,e,i,r){let o=Xp(n,t,e,i);return jo(n,t+2,r)||o}function Ds(n,t,e,i,r,o){let a=Xp(n,t,e,i);return Xp(n,t+2,r,o)||a}function Pe(n,t,e,i){let r=Ke();return jo(r,ph(),t)&&(Ei(),pc(kr(),r,n,t,e,i)),Pe}function yh(n,t){let e=!1,i=td();for(let o=1;o<t.length;o+=2)e=jo(n,i++,t[o])||e;if(U5(i),!e)return Gn;let r=t[0];for(let o=1;o<t.length;o+=2)r+=Yn(t[o])+t[o+1];return r}function bh(n,t,e,i){return jo(n,ph(),e)?t+Yn(e)+i:Gn}function vh(n,t,e,i,r,o){let s=Xp(n,td(),e,r);return nd(2),s?t+Yn(e)+i+Yn(r)+o:Gn}function xh(n,t,e,i,r,o,a,s){let c=WM(n,td(),e,r,a);return nd(3),c?t+Yn(e)+i+Yn(r)+o+Yn(a)+s:Gn}function Ch(n,t,e,i,r,o,a,s,l,c){let u=Ds(n,td(),e,r,a,l);return nd(4),u?t+Yn(e)+i+Yn(r)+o+Yn(a)+s+Yn(l)+c:Gn}function Mh(n,t,e,i,r,o,a,s,l,c,d,u){let p=td(),f=Ds(n,p,e,r,a,l);return f=jo(n,p+4,d)||f,nd(5),f?t+Yn(e)+i+Yn(r)+o+Yn(a)+s+Yn(l)+c+Yn(d)+u:Gn}function wh(n,t,e,i,r,o,a,s,l,c,d,u,p,f){let m=td(),y=Ds(n,m,e,r,a,l);return y=Xp(n,m+4,d,p)||y,nd(6),y?t+Yn(e)+i+Yn(r)+o+Yn(a)+s+Yn(l)+c+Yn(d)+u+Yn(p)+f:Gn}function Sh(n,t,e,i,r,o,a,s,l,c,d,u,p,f,m,y){let M=td(),v=Ds(n,M,e,r,a,l);return v=WM(n,M+4,d,p,m)||v,nd(7),v?t+Yn(e)+i+Yn(r)+o+Yn(a)+s+Yn(l)+c+Yn(d)+u+Yn(p)+f+Yn(m)+y:Gn}function Eh(n,t,e,i,r,o,a,s,l,c,d,u,p,f,m,y,M,v){let x=td(),R=Ds(n,x,e,r,a,l);return R=Ds(n,x+4,d,p,m,M)||R,nd(8),R?t+Yn(e)+i+Yn(r)+o+Yn(a)+s+Yn(l)+c+Yn(d)+u+Yn(p)+f+Yn(m)+y+Yn(M)+v:Gn}function S(n,t,e,i,r,o,a,s){let l=Ke(),c=Ei(),d=n+Xr,u=c.firstCreatePass?function(n,t,e,i,r,o,a,s,l){let c=t.consts,d=_h(t,n,4,a||null,ou(c,s));DP(t,e,d,ou(c,l)),FM(t,d);let u=d.tView=TP(2,d,i,r,o,t.directiveRegistry,t.pipeRegistry,null,t.schemas,c);return null!==t.queries&&(t.queries.template(t,d),u.queries=t.queries.embeddedTView(d)),d}(d,c,l,t,e,i,r,o,a):c.data[d];ac(u,!1);let p=l[li].createComment("");BM(c,l,p,u),sc(p,l),GM(l,l[d]=lU(p,l,p,u)),PM(u)&&SP(c,l,u),null!=a&&EP(l,u,s)}function tt(n){return uh(Xn.lFrame.contextLView,Xr+n)}function _(n,t,e){let i=Ke();return jo(i,ph(),t)&&is(Ei(),kr(),i,n,t,i[li],e,!1),_}function Ck(n,t,e,i,r){let a=r?"class":"style";RP(n,e,t.inputs[a],a,i)}function h(n,t,e,i){let r=Ke(),o=Ei(),a=Xr+n,s=r[li],l=o.firstCreatePass?function(n,t,e,i,r,o){let a=t.consts,l=_h(t,n,2,i,ou(a,r));return DP(t,e,l,ou(a,o)),null!==l.attrs&&yM(l,l.attrs,!1),null!==l.mergedAttrs&&yM(l,l.mergedAttrs,!0),null!==t.queries&&t.queries.elementStart(t,l),l}(a,o,r,t,e,i):o.data[a],c=r[a]=fP(s,t,Xn.lFrame.currentNamespace),d=PM(l);return ac(l,!0),Dz(s,c,l),32!=(32&l.flags)&&BM(o,r,c,l),0===Xn.lFrame.elementDepthCount&&sc(c,r),Xn.lFrame.elementDepthCount++,d&&(SP(o,r,l),wP(o,l,r)),null!==i&&EP(r,l),h}function g(){let n=Po();Jk()?$k():(n=n.parent,ac(n,!1));let t=n;Xn.lFrame.elementDepthCount--;let e=Ei();return e.firstCreatePass&&(FM(e,n),Zk(n)&&e.queries.elementEnd(n)),null!=t.classesWithoutHost&&function(n){return 0!=(8&n.flags)}(t)&&Ck(e,t,Ke(),t.classesWithoutHost,!0),null!=t.stylesWithoutHost&&function(n){return 0!=(16&n.flags)}(t)&&Ck(e,t,Ke(),t.stylesWithoutHost,!1),g}function P(n,t,e,i){return h(n,t,e,i),g(),P}function Tt(n,t,e){let i=Ke(),r=Ei(),o=n+Xr,a=r.firstCreatePass?function(n,t,e,i,r){let o=t.consts,a=ou(o,i),s=_h(t,n,8,"ng-container",a);return null!==a&&yM(s,a,!0),DP(t,e,s,ou(o,r)),null!==t.queries&&t.queries.elementStart(t,s),s}(o,r,i,t,e):r.data[o];ac(a,!0);let s=i[o]=i[li].createComment("");return BM(r,i,s,a),sc(s,i),PM(a)&&(SP(r,i,a),wP(r,a,i)),null!=e&&EP(i,a),Tt}function Dt(){let n=Po(),t=Ei();return Jk()?$k():(n=n.parent,ac(n,!1)),t.firstCreatePass&&(FM(t,n),Zk(n)&&t.queries.elementEnd(n)),Dt}function Ti(n,t,e){return Tt(n,t,e),Dt(),Ti}function ge(){return Ke()}function Th(n){return!!n&&"function"==typeof n.then}function PP(n){return!!n&&"function"==typeof n.subscribe}var OP=PP;function D(n,t,e,i){let r=Ke(),o=Ei(),a=Po();return EU(o,r,r[li],a,n,t,i),D}function Zp(n,t){let e=Po(),i=Ke(),r=Ei();return EU(r,i,pU(eP(r.data),e,i),e,n,t),Zp}function EU(n,t,e,i,r,o,a){let s=PM(i),c=n.firstCreatePass&&uU(n),d=t[Ia],u=dU(t),p=!0;if(3&i.type||a){let y=ts(i,t),M=a?a(y):y,v=u.length,x=a?A=>a(Ts(A[i.index])):i.index,R=null;if(!a&&s&&(R=function(n,t,e,i){let r=n.cleanup;if(null!=r)for(let o=0;o<r.length-1;o+=2){let a=r[o];if(a===e&&r[o+1]===i){let s=t[ny],l=r[o+2];return s.length>l?s[l]:null}"string"==typeof a&&(o+=2)}return null}(n,t,r,i.index)),null!==R)(R.__ngLastListenerFn__||R).__ngNextListenerFn__=o,R.__ngLastListenerFn__=o,p=!1;else{o=t5(i,t,d,o,!1);let A=e.listen(M,r,o);u.push(o,A),c&&c.push(r,x,v,v+1)}}else o=t5(i,t,d,o,!1);let m,f=i.outputs;if(p&&null!==f&&(m=f[r])){let y=m.length;if(y)for(let M=0;M<y;M+=2){let H=t[m[M]][m[M+1]].subscribe(o),te=u.length;u.push(o,H),c&&c.push(r,i.index,te,-(te+1))}}}function e5(n,t,e,i){try{return Ms(6,t,e),!1!==e(i)}catch(r){return fU(n,r),!1}finally{Ms(7,t,e)}}function t5(n,t,e,i,r){return function o(a){if(a===Function)return i;AP(n.componentOffset>-1?ed(n.index,t):t);let l=e5(t,e,i,a),c=o.__ngNextListenerFn__;for(;c;)l=e5(t,e,c,a)&&l,c=c.__ngNextListenerFn__;return r&&!1===l&&(a.preventDefault(),a.returnValue=!1),l}}function w(n=1){return function(n){return(Xn.lFrame.contextLView=function(n,t){for(;n>0;)t=t[dh],n--;return t}(n,Xn.lFrame.contextLView))[Ia]}(n)}function xle(n,t){let e=null,i=function(n){let t=n.attrs;if(null!=t){let e=t.indexOf(5);if(0==(1&e))return t[e+1]}return null}(n);for(let r=0;r<t.length;r++){let o=t[r];if("*"!==o){if(null===i?Jz(n,o,!0):_se(i,o))return r}else e=r}return e}function gn(n){let t=Ke()[fl][Da];if(!t.projection){let i=t.projection=X_(n?n.length:1,null),r=i.slice(),o=t.child;for(;null!==o;){let a=n?xle(o,n):0;null!==a&&(r[a]?r[a].projectionNext=o:i[a]=o,r[a]=o),o=o.next}}}function Xt(n,t=0,e){let i=Ke(),r=Ei(),o=_h(r,Xr+n,16,null,e||null);null===o.projection&&(o.projection=t),$k(),32!=(32&o.flags)&&function(n,t,e){Ez(t[li],0,t,e,yz(n,e,t),xz(e.parent||t[Da],e,t))}(r,i,o)}function Ji(n,t,e){return Sy(n,"",t,"",e),Ji}function Sy(n,t,e,i,r){let o=Ke(),a=bh(o,t,e,i);return a!==Gn&&is(Ei(),kr(),o,n,a,o[li],r,!1),Sy}function qM(n,t,e,i,r,o,a){let s=Ke(),l=vh(s,t,e,i,r,o);return l!==Gn&&is(Ei(),kr(),s,n,l,s[li],a,!1),qM}function YC(n,t){return n<<17|t<<2}function Qp(n){return n>>17&32767}function Mk(n){return 2|n}function ah(n){return(131068&n)>>2}function SR(n,t){return-131069&n|t<<2}function wk(n){return 1|n}function n5(n,t,e,i,r){let o=n[e+1],a=null===t,s=i?Qp(o):ah(o),l=!1;for(;0!==s&&(!1===l||a);){let d=n[s+1];Tle(n[s],t)&&(l=!0,n[s+1]=i?wk(d):Mk(d)),s=i?Qp(d):ah(d)}l&&(n[e+1]=i?Mk(o):wk(o))}function Tle(n,t){return null===n||null==t||(Array.isArray(n)?n[1]:n)===t||!(!Array.isArray(n)||"string"!=typeof t)&&yy(n,t)>=0}var mo={textEnd:0,key:0,keyEnd:0,value:0,valueEnd:0};function OU(n){return n.substring(mo.key,mo.keyEnd)}function Dle(n){return n.substring(mo.value,mo.valueEnd)}function FU(n,t){let e=mo.textEnd;return e===t?-1:(t=mo.keyEnd=function(n,t,e){for(;t<e&&n.charCodeAt(t)>32;)t++;return t}(n,mo.key=t,e),sh(n,t,e))}function LU(n,t){let e=mo.textEnd,i=mo.key=sh(n,t,e);return e===i?-1:(i=mo.keyEnd=function(n,t,e){let i;for(;t<e&&(45===(i=n.charCodeAt(t))||95===i||(-33&i)>=65&&(-33&i)<=90||i>=48&&i<=57);)t++;return t}(n,i,e),i=i5(n,i,e),i=mo.value=sh(n,i,e),i=mo.valueEnd=function(n,t,e){let i=-1,r=-1,o=-1,a=t,s=a;for(;a<e;){let l=n.charCodeAt(a++);if(59===l)return s;34===l||39===l?s=a=r5(n,l,a,e):t===a-4&&85===o&&82===r&&76===i&&40===l?s=a=r5(n,41,a,e):l>32&&(s=a),o=r,r=i,i=-33&l}return s}(n,i,e),i5(n,i,e))}function NU(n){mo.key=0,mo.keyEnd=0,mo.value=0,mo.valueEnd=0,mo.textEnd=n.length}function sh(n,t,e){for(;t<e&&n.charCodeAt(t)<=32;)t++;return t}function i5(n,t,e,i){return(t=sh(n,t,e))<e&&t++,t}function r5(n,t,e,i){let r=-1,o=e;for(;o<i;){let a=n.charCodeAt(o++);if(a==t&&92!==r)return o;r=92==a&&92===r?0:a}throw new Error}function Mt(n,t,e){return yl(n,t,e,!1),Mt}function Qe(n,t){return yl(n,t,null,!0),Qe}function Rs(n){bl(HU,Ole,n,!1)}function Ole(n,t){for(let e=function(n){return NU(n),LU(n,sh(n,0,mo.textEnd))}(t);e>=0;e=LU(t,e))HU(n,OU(t),Dle(t))}function ka(n){bl(Hle,mc,n,!0)}function mc(n,t){for(let e=function(n){return NU(n),FU(n,sh(n,0,mo.textEnd))}(t);e>=0;e=FU(t,e))ns(n,OU(t),!0)}function yl(n,t,e,i){let r=Ke(),o=Ei(),a=nd(2);o.firstUpdatePass&&VU(o,n,a,i),t!==Gn&&jo(r,a,t)&&zU(o,o.data[ua()],r,r[li],n,r[a+1]=function(n,t){return null==n||""===n||("string"==typeof t?n+=t:"object"==typeof n&&(n=ho(Ra(n)))),n}(t,e),i,a)}function bl(n,t,e,i){let r=Ei(),o=nd(2);r.firstUpdatePass&&VU(r,null,o,i);let a=Ke();if(e!==Gn&&jo(a,o,e)){let s=r.data[ua()];if(UU(s,i)&&!BU(r,o)){let l=i?s.classesWithoutHost:s.stylesWithoutHost;null!==l&&(e=LR(l,e||"")),Ck(r,s,a,e,i)}else!function(n,t,e,i,r,o,a,s){r===Gn&&(r=Ui);let l=0,c=0,d=0<r.length?r[0]:null,u=0<o.length?o[0]:null;for(;null!==d||null!==u;){let y,p=l<r.length?r[l+1]:void 0,f=c<o.length?o[c+1]:void 0,m=null;d===u?(l+=2,c+=2,p!==f&&(m=u,y=f)):null===u||null!==d&&d<u?(l+=2,m=d):(c+=2,m=u,y=f),null!==m&&zU(n,t,e,i,m,y,a,s),d=l<r.length?r[l]:null,u=c<o.length?o[c]:null}}(r,s,a,a[li],a[o+1],a[o+1]=function(n,t,e){if(null==e||""===e)return Ui;let i=[],r=Ra(e);if(Array.isArray(r))for(let o=0;o<r.length;o++)n(i,r[o],!0);else if("object"==typeof r)for(let o in r)r.hasOwnProperty(o)&&n(i,o,r[o]);else"string"==typeof r&&t(i,r);return i}(n,t,e),i,o)}}function BU(n,t){return t>=n.expandoStartIndex}function VU(n,t,e,i){let r=n.data;if(null===r[e+1]){let o=r[ua()],a=BU(n,e);UU(o,i)&&null===t&&!a&&(t=!1),t=function(n,t,e,i){let r=eP(n),o=i?t.residualClasses:t.residualStyles;if(null===r)0===(i?t.classBindings:t.styleBindings)&&(e=sy(e=ER(null,n,t,e,i),t.attrs,i),o=null);else{let a=t.directiveStylingLast;if(-1===a||n[a]!==r)if(e=ER(r,n,t,e,i),null===o){let l=function(n,t,e){let i=e?t.classBindings:t.styleBindings;if(0!==ah(i))return n[Qp(i)]}(n,t,i);void 0!==l&&Array.isArray(l)&&(l=ER(null,n,t,l[1],i),l=sy(l,t.attrs,i),function(n,t,e,i){n[Qp(e?t.classBindings:t.styleBindings)]=i}(n,t,i,l))}else o=function(n,t,e){let i,r=t.directiveEnd;for(let o=1+t.directiveStylingLast;o<r;o++)i=sy(i,n[o].hostAttrs,e);return sy(i,t.attrs,e)}(n,t,i)}return void 0!==o&&(i?t.residualClasses=o:t.residualStyles=o),e}(r,o,t,i),function(n,t,e,i,r,o){let a=o?t.classBindings:t.styleBindings,s=Qp(a),l=ah(a);n[i]=e;let d,c=!1;if(Array.isArray(e)?(d=e[1],(null===d||yy(e,d)>0)&&(c=!0)):d=e,r)if(0!==l){let p=Qp(n[s+1]);n[i+1]=YC(p,s),0!==p&&(n[p+1]=SR(n[p+1],i)),n[s+1]=function(n,t){return 131071&n|t<<17}(n[s+1],i)}else n[i+1]=YC(s,0),0!==s&&(n[s+1]=SR(n[s+1],i)),s=i;else n[i+1]=YC(l,0),0===s?s=i:n[l+1]=SR(n[l+1],i),l=i;c&&(n[i+1]=Mk(n[i+1])),n5(n,d,i,!0),n5(n,d,i,!1),function(n,t,e,i,r){let o=r?n.residualClasses:n.residualStyles;null!=o&&"string"==typeof t&&yy(o,t)>=0&&(e[i+1]=wk(e[i+1]))}(t,d,n,i,o),a=YC(s,l),o?t.classBindings=a:t.styleBindings=a}(r,o,t,e,a,i)}}function ER(n,t,e,i,r){let o=null,a=e.directiveEnd,s=e.directiveStylingLast;for(-1===s?s=e.directiveStart:s++;s<a&&(o=t[s],i=sy(i,o.hostAttrs,r),o!==n);)s++;return null!==n&&(e.directiveStylingLast=s),i}function sy(n,t,e){let i=e?1:2,r=-1;if(null!==t)for(let o=0;o<t.length;o++){let a=t[o];"number"==typeof a?r=a:r===i&&(Array.isArray(n)||(n=void 0===n?[]:["",n]),ns(n,a,!!e||t[++o]))}return void 0===n?null:n}function HU(n,t,e){ns(n,t,Ra(e))}function Hle(n,t,e){let i=String(t);""!==i&&!i.includes(" ")&&ns(n,i,e)}function zU(n,t,e,i,r,o,a,s){if(!(3&t.type))return;let l=n.data,c=l[s+1],d=function(n){return 1==(1&n)}(c)?o5(l,t,e,r,ah(c),a):void 0;xM(d)||(xM(o)||function(n){return 2==(2&n)}(c)&&(o=o5(l,null,e,r,s,a)),function(n,t,e,i,r){if(t)r?n.addClass(e,i):n.removeClass(e,i);else{let o=-1===i.indexOf("-")?void 0:Es.DashCase;null==r?n.removeStyle(e,i,o):("string"==typeof r&&r.endsWith("!important")&&(r=r.slice(0,-10),o|=Es.Important),n.setStyle(e,i,r,o))}}(i,a,OM(ua(),e),r,o))}function o5(n,t,e,i,r,o){let s,a=null===t;for(;r>0;){let l=n[r],c=Array.isArray(l),d=c?l[1]:l,u=null===d,p=e[r+1];p===Gn&&(p=u?Ui:void 0);let f=u?yR(p,i):d===i?p:void 0;if(c&&!xM(f)&&(f=yR(l,i)),xM(f)&&(s=f,a))return s;let m=n[r+1];r=a?Qp(m):ah(m)}if(null!==t){let l=o?t.residualClasses:t.residualStyles;null!=l&&(s=yR(l,i))}return s}function xM(n){return void 0!==n}function UU(n,t){return 0!=(n.flags&(t?8:16))}function T(n,t=""){let e=Ke(),i=Ei(),r=n+Xr,o=i.firstCreatePass?_h(i,r,1,t,null):i.data[r],a=e[r]=pP(e[li],t);BM(i,e,a,o),ac(o,!1)}function ut(n){return ze("",n,""),ut}function ze(n,t,e){let i=Ke(),r=bh(i,n,t,e);return r!==Gn&&od(i,ua(),r),ze}function du(n,t,e,i,r){let o=Ke(),a=vh(o,n,t,e,i,r);return a!==Gn&&od(o,ua(),a),du}function YM(n,t,e,i,r,o,a){let s=Ke(),l=xh(s,n,t,e,i,r,o,a);return l!==Gn&&od(s,ua(),l),YM}function Dh(n,t,e){bl(ns,mc,bh(Ke(),n,t,e),!0)}function Co(n,t,e){let i=Ke();return jo(i,ph(),t)&&is(Ei(),kr(),i,n,t,i[li],e,!0),Co}function Kp(n,t,e){let i=Ke();if(jo(i,ph(),t)){let o=Ei(),a=kr();is(o,a,i,n,t,pU(eP(o.data),a,i),e,!0)}return Kp}var Np=void 0,sce=["en",[["a","p"],["AM","PM"],Np],[["AM","PM"],Np,Np],[["S","M","T","W","T","F","S"],["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],["Su","Mo","Tu","We","Th","Fr","Sa"]],Np,[["J","F","M","A","M","J","J","A","S","O","N","D"],["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"],["January","February","March","April","May","June","July","August","September","October","November","December"]],Np,[["B","A"],["BC","AD"],["Before Christ","Anno Domini"]],0,[6,0],["M/d/yy","MMM d, y","MMMM d, y","EEEE, MMMM d, y"],["h:mm a","h:mm:ss a","h:mm:ss a z","h:mm:ss a zzzz"],["{1}, {0}",Np,"{1} 'at' {0}",Np],[".",",",";","%","+","-","E","\xd7","\u2030","\u221e","NaN",":"],["#,##0.###","#,##0%","\xa4#,##0.00","#E0"],"USD","$","US Dollar",{},"ltr",function(n){let e=Math.floor(Math.abs(n)),i=n.toString().replace(/^[^.]*\.?/,"").length;return 1===e&&0===i?1:5}],TR={};function Pa(n){let t=function(n){return n.toLowerCase().replace(/_/g,"-")}(n),e=a5(t);if(e)return e;let i=t.split("-")[0];if(e=a5(i),e)return e;if("en"===i)return sce;throw new bt(701,!1)}function a5(n){return n in TR||(TR[n]=Wr.ng&&Wr.ng.common&&Wr.ng.common.locales&&Wr.ng.common.locales[n]),TR[n]}var gr=(()=>{return(n=gr||(gr={}))[n.LocaleId=0]="LocaleId",n[n.DayPeriodsFormat=1]="DayPeriodsFormat",n[n.DayPeriodsStandalone=2]="DayPeriodsStandalone",n[n.DaysFormat=3]="DaysFormat",n[n.DaysStandalone=4]="DaysStandalone",n[n.MonthsFormat=5]="MonthsFormat",n[n.MonthsStandalone=6]="MonthsStandalone",n[n.Eras=7]="Eras",n[n.FirstDayOfWeek=8]="FirstDayOfWeek",n[n.WeekendRange=9]="WeekendRange",n[n.DateFormat=10]="DateFormat",n[n.TimeFormat=11]="TimeFormat",n[n.DateTimeFormat=12]="DateTimeFormat",n[n.NumberSymbols=13]="NumberSymbols",n[n.NumberFormats=14]="NumberFormats",n[n.CurrencyCode=15]="CurrencyCode",n[n.CurrencySymbol=16]="CurrencySymbol",n[n.CurrencyName=17]="CurrencyName",n[n.Currencies=18]="Currencies",n[n.Directionality=19]="Directionality",n[n.PluralCase=20]="PluralCase",n[n.ExtraData=21]="ExtraData",gr;var n})(),cce=["zero","one","two","few","many"];var CM="en-US",oj={marker:"element"},aj={marker:"ICU"},ul=(()=>{return(n=ul||(ul={}))[n.SHIFT=2]="SHIFT",n[n.APPEND_EAGERLY=1]="APPEND_EAGERLY",n[n.COMMENT=2]="COMMENT",ul;var n})(),sj=CM;function lj(n,t,e){let i=t.insertBeforeIndex,r=Array.isArray(i)?i[0]:i;return null===r?Cz(n,0,e):Ts(e[r])}function cj(n,t,e,i,r){let o=t.insertBeforeIndex;if(Array.isArray(o)){let a=i,s=null;if(3&t.type||(s=a,a=r),null!==a&&-1===t.componentOffset)for(let l=1;l<o.length;l++)qp(n,a,e[o[l]],s,!1)}}function dj(n,t){if(n.push(t),n.length>1)for(let e=n.length-2;e>=0;e--){let i=n[e];uj(i)||mce(i,t)&&null===hce(i)&&gce(i,t.index)}}function uj(n){return!(64&n.type)}function mce(n,t){return uj(t)||n.index>t.index}function hce(n){let t=n.insertBeforeIndex;return Array.isArray(t)?t[0]:t}function gce(n,t){let e=n.insertBeforeIndex;Array.isArray(e)?e[0]=t:(wz(lj,cj),n.insertBeforeIndex=t)}function Z_(n,t){let e=n.data[t];return null===e||"string"==typeof e?null:e.hasOwnProperty("currentCaseLViewIndex")?e:e.value}function bce(n,t,e){let i=CP(n,e,64,null,null);return dj(t,i),i}function XM(n,t){let e=t[n.currentCaseLViewIndex];return null===e?e:e<0?~e:e}function vce(n){return n>>>17}function xce(n){return(131070&n)>>>1}var ly=0,K_=0;function pj(n,t,e,i){let a,r=e[li],o=null;for(let s=0;s<t.length;s++){let l=t[s];if("string"==typeof l){let c=t[++s];null===e[c]&&(e[c]=pP(r,l))}else if("number"==typeof l)switch(1&l){case 0:let d,u,c=vce(l);if(null===o&&(o=c,a=NM(r,i)),c===o?(d=i,u=a):(d=null,u=Ts(e[c])),null!==u){let y=xce(l);qp(r,u,e[y],d,!1);let v=Z_(n,y);if(null!==v&&"object"==typeof v){let x=XM(v,e);null!==x&&pj(n,v.create[x],e,e[v.anchorIdx])}}break;case 1:let f=t[++s],m=t[++s];IP(r,OM(l>>>1,e),null,null,f,m,null)}else switch(l){case aj:let c=t[++s],d=t[++s];null===e[d]&&sc(e[d]=lae(r,c),e);break;case oj:let u=t[++s],p=t[++s];null===e[p]&&sc(e[p]=fP(r,u,null),e)}}}function fj(n,t,e,i,r){for(let o=0;o<e.length;o++){let a=e[o],s=e[++o];if(a&r){let l="";for(let c=o+1;c<=o+s;c++){let d=e[c];if("string"==typeof d)l+=d;else if("number"==typeof d)if(d<0)l+=Yn(t[i-d]);else{let u=d>>>2;switch(3&d){case 1:let p=e[++c],f=e[++c],m=n.data[u];"string"==typeof m?IP(t[li],t[u],null,m,p,l,f):is(n,m,t,p,l,t[li],f,!1);break;case 0:let y=t[u];null!==y&&hz(t[li],y,l);break;case 2:Ece(n,Z_(n,u),t,l);break;case 3:s5(n,Z_(n,u),i,t)}}}}else{let l=e[o+1];if(l>0&&3==(3&l)){let d=Z_(n,l>>>2);t[d.currentCaseLViewIndex]<0&&s5(n,d,i,t)}}o+=s}}function s5(n,t,e,i){let r=i[t.currentCaseLViewIndex];if(null!==r){let o=ly;r<0&&(r=i[t.currentCaseLViewIndex]=~r,o=-1),fj(n,i,t.update[r],e,o)}}function Ece(n,t,e,i){let r=function(n,t){let e=n.cases.indexOf(t);if(-1===e)switch(n.type){case 1:{let i=function(n,t){let e=function(n){return Pa(n)[gr.PluralCase]}(t)(parseInt(n,10)),i=cce[e];return void 0!==i?i:"other"}(t,sj);e=n.cases.indexOf(i),-1===e&&"other"!==i&&(e=n.cases.indexOf("other"));break}case 0:e=n.cases.indexOf("other")}return-1===e?null:e}(t,i);if(XM(t,e)!==r&&(mj(n,t,e),e[t.currentCaseLViewIndex]=null===r?null:~r,null!==r)){let a=e[t.anchorIdx];a&&pj(n,t.create[r],e,a)}}function mj(n,t,e){let i=XM(t,e);if(null!==i){let r=t.remove[i];for(let o=0;o<r.length;o++){let a=r[o];if(a>0){let s=OM(a,e);null!==s&&mP(e[li],s)}else mj(n,Z_(n,~a),e)}}}function Dce(){let e,i,n=[],t=-1;function o(s,l){t=0;let c=XM(s,l);i=null!==c?s.remove[c]:Ui}function a(){if(t<i.length){let s=i[t++];return s>0?e[s]:(n.push(t,i),o(e[Bn].data[~s],e),a())}return 0===n.length?null:(i=n.pop(),t=n.pop(),a())}return function(s,l){for(e=l;n.length;)n.pop();return o(s.value,l),a}}var MM=/\ufffd(\d+):?\d*\ufffd/gi,Ice=/({\s*\ufffd\d+:?\d*\ufffd\s*,\s*\S{6}\s*,[\s\S]*})/gi,Ace=/\ufffd(\d+)\ufffd/,hj=/^\s*(\ufffd\d+:?\d*\ufffd)\s*,\s*(select|plural)\s*,/,J_="\ufffd",Rce=/\ufffd\/?\*(\d+:\d+)\ufffd/gi,kce=/\ufffd(\/?[#*]\d+):?\d*\ufffd/gi,Pce=/\uE500/g;function gj(n,t,e,i,r,o,a){let s=My(n,i,1,null),l=s<<ul.SHIFT,c=ry();t===c&&(c=null),null===c&&(l|=ul.APPEND_EAGERLY),a&&(l|=ul.COMMENT,function(n){void 0===QR&&(QR=n())}(Dce)),r.push(l,null===o?"":o);let d=CP(n,s,a?32:1,null===o?"":o,null);dj(e,d);let u=d.index;return ac(d,!1),null!==c&&t!==c&&function(n,t){let e=n.insertBeforeIndex;null===e?(wz(lj,cj),e=n.insertBeforeIndex=[null,t]):(function(n,t,e){1!=n&&M5("Expecting array here",n,!0,"==")}(Array.isArray(e)),e.push(t))}(c,u),d}function Lce(n,t,e,i,r,o,a){let s=a.match(MM),l=gj(n,t,e,o,i,s?null:a,!1);s&&$_(r,a,l.index,null,0,null)}function $_(n,t,e,i,r,o){let a=n.length,s=a+1;n.push(null,null);let l=a+2,c=t.split(MM),d=0;for(let u=0;u<c.length;u++){let p=c[u];if(1&u){let f=r+parseInt(p,10);n.push(-1-f),d|=_j(f)}else""!==p&&n.push(p)}return n.push(e<<2|(i?1:0)),i&&n.push(i,o),n[a]=d,n[s]=n.length-l,d}function Bce(n){let t=0;for(let e=0;e<n.length;e++){let i=n[e];"number"==typeof i&&i<0&&t++}return t}function _j(n){return 1<<Math.min(n,31)}function l5(n){let t,o,e="",i=0,r=!1;for(;null!==(t=Rce.exec(n));)r?t[0]===`${J_}/*${o}${J_}`&&(i=t.index,r=!1):(e+=n.substring(i,t.index+t[0].length),o=t[1],r=!0);return e+=n.slice(i),e}function yj(n,t,e,i,r,o){let a=0,s={type:r.type,currentCaseLViewIndex:My(n,t,1,null),anchorIdx:o,cases:[],create:[],remove:[],update:[]};(function(n,t,e){n.push(_j(t.mainBinding),2,-1-t.mainBinding,e<<2|2)})(e,r,o),function(n,t,e){let i=n.data[t];null===i?n.data[t]=e:i.value=e}(n,o,s);let l=r.values;for(let c=0;c<l.length;c++){let d=l[c],u=[];for(let p=0;p<d.length;p++){let f=d[p];if("string"!=typeof f){let m=u.push(f)-1;d[p]=`\x3c!--\ufffd${m}\ufffd--\x3e`}}a=Uce(n,s,t,e,i,r.cases[c],d.join(""),u)|a}a&&function(n,t,e){n.push(t,1,e<<2|3)}(e,a,o)}function zce(n){let t=[],e=[],i=1,r=0,o=Sk(n=n.replace(hj,function(a,s,l){return i="select"===l?0:1,r=parseInt(s.slice(1),10),""}));for(let a=0;a<o.length;){let s=o[a++].trim();1===i&&(s=s.replace(/\s*(?:=)?(\w+)\s*/,"$1")),s.length&&t.push(s);let l=Sk(o[a++]);t.length>e.length&&e.push(l)}return{type:i,mainBinding:r,cases:t,values:e}}function Sk(n){if(!n)return[];let o,t=0,e=[],i=[],r=/[{}]/g;for(r.lastIndex=0;o=r.exec(n);){let s=o.index;if("}"==o[0]){if(e.pop(),0==e.length){let l=n.substring(t,s);hj.test(l)?i.push(zce(l)):i.push(l),t=s+1}}else{if(0==e.length){let l=n.substring(t,s);i.push(l),t=s+1}e.push("{")}}let a=n.substring(t);return i.push(a),i}function Uce(n,t,e,i,r,o,a,s){let l=[],c=[],d=[];t.cases.push(o),t.create.push(l),t.remove.push(c),t.update.push(d);let p=Nz(Rz()).getInertBodyElement(a),f=ck(p)||p;return f?bj(n,t,e,i,l,c,d,f,r,s,0):0}function bj(n,t,e,i,r,o,a,s,l,c,d){let u=0,p=s.firstChild;for(;p;){let f=My(n,e,1,null);switch(p.nodeType){case Node.ELEMENT_NODE:let m=p,y=m.tagName.toLowerCase();if(sk.hasOwnProperty(y)){DR(r,oj,y,l,f),n.data[f]=y;let R=m.attributes;for(let A=0;A<R.length;A++){let H=R.item(A),te=H.name.toLowerCase();H.value.match(MM)?zz.hasOwnProperty(te)&&$_(a,H.value,f,H.name,0,_P[te]?vy:null):qce(r,f,H)}u=bj(n,t,e,i,r,o,a,p,f,c,d+1)|u,c5(o,f,d)}break;case Node.TEXT_NODE:let M=p.textContent||"",v=M.match(MM);DR(r,null,v?"":M,l,f),c5(o,f,d),v&&(u=$_(a,M,f,null,0,null)|u);break;case Node.COMMENT_NODE:let x=Ace.exec(p.textContent||"");if(x){let A=c[parseInt(x[1],10)];DR(r,aj,"",l,f),yj(n,e,i,l,A,f),jce(o,f,d)}}p=p.nextSibling}return u}function c5(n,t,e){0===e&&n.push(t)}function jce(n,t,e){0===e&&(n.push(~t),n.push(t))}function DR(n,t,e,i,r){null!==t&&n.push(t),n.push(e,r,function(n,t,e){return 0|t<<17|e<<1}(0,i,r))}function qce(n,t,e){n.push(t<<1|1,e.name,e.value)}var d5=0,Yce=/\[(\ufffd.+?\ufffd?)\]/,Xce=/\[(\ufffd.+?\ufffd?)\]|(\ufffd\/?\*\d+:\d+\ufffd)/g,Qce=/({\s*)(VAR_(PLURAL|SELECT)(_\d+)?)(\s*,)/g,Zce=/{([A-Z0-9_]+)}/g,Kce=/\ufffdI18N_EXP_(ICU(_\d+)?)\ufffd/g,Jce=/\/\*/,$ce=/\d+\:(\d+)/;function vj(n,t,e=-1){let i=Ei(),r=Ke(),o=Xr+n,a=ou(i.consts,t),s=ry();i.firstCreatePass&&function(n,t,e,i,r,o){let a=ry(),s=[],l=[],c=[[]];r=function(n,t){if(function(n){return-1===n}(t))return l5(n);{let e=n.indexOf(`:${t}${J_}`)+2+t.toString().length,i=n.search(new RegExp(`${J_}\\/\\*\\d+:${t}${J_}`));return l5(n.substring(e,i))}}(r,o);let d=function(n){return n.replace(Pce," ")}(r).split(kce);for(let u=0;u<d.length;u++){let p=d[u];if(0==(1&u)){let f=Sk(p);for(let m=0;m<f.length;m++){let y=f[m];if(0==(1&m))""!==y&&Lce(n,a,c[0],s,l,e,y);else{let M=y;if("object"!=typeof M)throw new Error(`Unable to parse ICU expression in "${r}" message.`);yj(n,e,l,t,M,gj(n,a,c[0],e,s,"",!0).index)}}}else{let f=47===p.charCodeAt(0),y=(p.charCodeAt(f?1:0),Xr+Number.parseInt(p.substring(f?2:1)));if(f)c.shift(),ac(ry(),!1);else{let M=bce(n,c[0],y);c.unshift([]),ac(M,!0)}}}n.data[i]={create:s,update:l}}(i,null===s?0:s.index,r,o,a,e);let l=i.data[o],d=bz(i,s===r[Da]?null:s,r);(function(n,t,e,i){let r=n[li];for(let o=0;o<t.length;o++){let a=t[o++],s=t[o],c=(a&ul.APPEND_EAGERLY)===ul.APPEND_EAGERLY,d=a>>>ul.SHIFT,u=n[d];null===u&&(u=n[d]=(a&ul.COMMENT)===ul.COMMENT?r.createComment(s):pP(r,s)),c&&null!==e&&qp(r,e,u,i,!1)}})(r,l.create,d,s&&8&s.type?r[s.index]:null),j5(!0)}function xj(){j5(!1)}function QM(n,t,e){vj(n,t,e),xj()}function Ey(n){return function(n){n&&(ly|=1<<Math.min(K_,31)),K_++}(jo(Ke(),ph(),n)),Ey}function ZM(n){!function(n,t,e){if(K_>0){let i=n.data[e];fj(n,t,Array.isArray(i)?i:i.update,td()-K_-1,ly)}ly=0,K_=0}(Ei(),Ke(),n+Xr)}function KM(n,t={}){return function(n,t={}){let e=n;if(Yce.test(n)){let i={},r=[d5];e=e.replace(Xce,(o,a,s)=>{let l=a||s,c=i[l]||[];if(c.length||(l.split("|").forEach(y=>{let M=y.match($ce),v=M?parseInt(M[1],10):d5,x=Jce.test(y);c.push([v,x,y])}),i[l]=c),!c.length)throw new Error(`i18n postprocess: unmatched placeholder - ${l}`);let d=r[r.length-1],u=0;for(let y=0;y<c.length;y++)if(c[y][0]===d){u=y;break}let[p,f,m]=c[u];return f?r.pop():d!==p&&r.push(p),c.splice(u,1),m})}return Object.keys(t).length&&(e=e.replace(Qce,(i,r,o,a,s,l)=>t.hasOwnProperty(o)?`${r}${t[o]}${l}`:i),e=e.replace(Zce,(i,r)=>t.hasOwnProperty(r)?t[r]:i),e=e.replace(Kce,(i,r)=>{if(t.hasOwnProperty(r)){let o=t[r];if(!o.length)throw new Error(`i18n postprocess: unmatched ICU - ${i} with key: ${r}`);return o.shift()}return i})),e}(n,t)}function Ek(n,t,e,i,r){if(n=ki(n),Array.isArray(n))for(let o=0;o<n.length;o++)Ek(n[o],t,e,i,r);else{let o=Ei(),a=Ke(),s=oh(n)?n:ki(n.provide),l=Xz(n),c=Po(),d=1048575&c.providerIndexes,u=c.directiveStart,p=c.providerIndexes>>20;if(oh(n)||!n.multi){let f=new Gp(l,r,C),m=AR(s,t,r?d:d+p,u);-1===m?(qR(fM(c,a),o,s),IR(o,n,t.length),t.push(s),c.directiveStart++,c.directiveEnd++,r&&(c.providerIndexes+=1048576),e.push(f),a.push(f)):(e[m]=f,a[m]=f)}else{let f=AR(s,t,d+p,u),m=AR(s,t,d,d+p),M=m>=0&&e[m];if(r&&!M||!r&&!(f>=0&&e[f])){qR(fM(c,a),o,s);let v=function(n,t,e,i,r){let o=new Gp(n,e,C);return o.multi=[],o.index=t,o.componentProviders=0,Cj(o,r,i&&!e),o}(r?rde:ide,e.length,r,i,l);!r&&M&&(e[m].providerFactory=v),IR(o,n,t.length,0),t.push(s),c.directiveStart++,c.directiveEnd++,r&&(c.providerIndexes+=1048576),e.push(v),a.push(v)}else IR(o,n,f>-1?f:m,Cj(e[r?m:f],l,!r&&i));!r&&i&&M&&e[m].componentProviders++}}}function IR(n,t,e,i){let r=oh(t),o=function(n){return!!n.useClass}(t);if(r||o){let l=(o?ki(t.useClass):t).prototype.ngOnDestroy;if(l){let c=n.destroyHooks||(n.destroyHooks=[]);if(!r&&t.multi){let d=c.indexOf(e);-1===d?c.push(e,[i,l]):c[d+1].push(i,l)}else c.push(e,l)}}}function Cj(n,t,e){return e&&n.componentProviders++,n.multi.push(t)-1}function AR(n,t,e,i){for(let r=e;r<i;r++)if(t[r]===n)return r;return-1}function ide(n,t,e,i){return Tk(this.multi,[])}function rde(n,t,e,i){let o,r=this.multi;if(this.providerFactory){let a=this.providerFactory.componentProviders,s=Wp(e,e[Bn],this.providerFactory.index,i);o=s.slice(0,a),Tk(r,o);for(let l=a;l<s.length;l++)o.push(s[l])}else o=[],Tk(r,o);return o}function Tk(n,t){for(let e=0;e<n.length;e++)t.push((0,n[e])());return t}function Rt(n,t=[]){return e=>{e.providersResolver=(i,r)=>function(n,t,e){let i=Ei();if(i.firstCreatePass){let r=ml(n);Ek(e,i.data,i.blueprint,r,!0),Ek(t,i.data,i.blueprint,r,!1)}}(i,r?r(n):n,t)}}var au=class{},Dk=class{},Ik=class extends au{constructor(t,e){super(),this._parent=e,this._bootstrapComponents=[],this.destroyCbs=[],this.componentFactoryResolver=new bM(this);let i=nh(t);this._bootstrapComponents=$C(i.bootstrap),this._r3Injector=tU(t,e,[{provide:au,useValue:this},{provide:Qr,useValue:this.componentFactoryResolver}],ho(t),new Set(["environment"])),this._r3Injector.resolveInjectorInitializers(),this.instance=this._r3Injector.get(t)}get injector(){return this._r3Injector}destroy(){let t=this._r3Injector;!t.destroyed&&t.destroy(),this.destroyCbs.forEach(e=>e()),this.destroyCbs=null}onDestroy(t){this.destroyCbs.push(t)}},Ak=class extends Dk{constructor(t){super(),this.moduleType=t}create(t){return new Ik(this.moduleType,t)}},Rk=class extends au{constructor(t,e,i){super(),this.componentFactoryResolver=new bM(this),this.instance=null;let r=new gM([...t,{provide:au,useValue:this},{provide:Qr,useValue:this.componentFactoryResolver}],e||xP(),i,new Set(["environment"]));this.injector=r,r.resolveInjectorInitializers()}destroy(){this.injector.destroy()}onDestroy(t){this.injector.onDestroy(t)}},sde=(()=>{class n{constructor(e){this._injector=e,this.cachedInjectors=new Map}getOrCreateStandaloneInjector(e){if(!e.standalone)return null;if(!this.cachedInjectors.has(e.id)){let i=Wz(0,e.type),r=i.length>0?function(n,t,e=null){return new Rk(n,t,e).injector}([i],this._injector,`Standalone[${e.type.name}]`):null;this.cachedInjectors.set(e.id,r)}return this.cachedInjectors.get(e.id)}ngOnDestroy(){try{for(let e of this.cachedInjectors.values())null!==e&&e.destroy()}finally{this.cachedInjectors.clear()}}}return n.\u0275prov=pe({token:n,providedIn:"environment",factory:()=>new n(O(lc))}),n})();function FP(n){n.getStandaloneInjector=t=>t.get(sde).getOrCreateStandaloneInjector(n)}function uu(n,t,e){let i=da()+n,r=Ke();return r[i]===Gn?fc(r,i,e?t.call(e):t()):wy(r,i)}function Sn(n,t,e,i){return Mj(Ke(),da(),n,t,e,i)}function Pr(n,t,e,i,r){return wj(Ke(),da(),n,t,e,i,r)}function Ty(n,t,e,i,r,o){return Sj(Ke(),da(),n,t,e,i,r,o)}function LP(n,t,e,i,r,o,a){return Ej(Ke(),da(),n,t,e,i,r,o,a)}function NP(n,t,e,i,r,o,a,s){let l=da()+n,c=Ke(),d=Ds(c,l,e,i,r,o);return jo(c,l+4,a)||d?fc(c,l+5,s?t.call(s,e,i,r,o,a):t(e,i,r,o,a)):wy(c,l+5)}function Dy(n,t){let e=n[t];return e===Gn?void 0:e}function Mj(n,t,e,i,r,o){let a=t+e;return jo(n,a,r)?fc(n,a+1,o?i.call(o,r):i(r)):Dy(n,a+1)}function wj(n,t,e,i,r,o,a){let s=t+e;return Xp(n,s,r,o)?fc(n,s+2,a?i.call(a,r,o):i(r,o)):Dy(n,s+2)}function Sj(n,t,e,i,r,o,a,s){let l=t+e;return WM(n,l,r,o,a)?fc(n,l+3,s?i.call(s,r,o,a):i(r,o,a)):Dy(n,l+3)}function Ej(n,t,e,i,r,o,a,s,l){let c=t+e;return Ds(n,c,r,o,a,s)?fc(n,c+4,l?i.call(l,r,o,a,s):i(r,o,a,s)):Dy(n,c+4)}function Tj(n,t,e,i,r,o){let a=t+e,s=!1;for(let l=0;l<r.length;l++)jo(n,a++,r[l])&&(s=!0);return s?fc(n,a,i.apply(o,r)):Dy(n,a)}function G(n,t){let i,e=Ei(),r=n+Xr;e.firstCreatePass?(i=function(n,t){if(t)for(let e=t.length-1;e>=0;e--){let i=t[e];if(n===i.name)return i}}(t,e.pipeRegistry),e.data[r]=i,i.onDestroy&&(e.destroyHooks??(e.destroyHooks=[])).push(r,i.onDestroy)):i=e.data[r];let o=i.factory||(i.factory=Up(i.type)),a=Cs(C);try{let s=pM(!1),l=o();return pM(s),function(n,t,e,i){e>=n.data.length&&(n.data[e]=null,n.blueprint[e]=null),t[e]=i}(e,Ke(),r,l),l}finally{Cs(a)}}function W(n,t,e){let i=n+Xr,r=Ke(),o=uh(r,i);return Iy(r,i)?Mj(r,da(),t,o.transform,e,o):o.transform(e)}function Jp(n,t,e,i){let r=n+Xr,o=Ke(),a=uh(o,r);return Iy(o,r)?wj(o,da(),t,a.transform,e,i,a):a.transform(e,i)}function BP(n,t,e,i,r){let o=n+Xr,a=Ke(),s=uh(a,o);return Iy(a,o)?Sj(a,da(),t,s.transform,e,i,r,s):s.transform(e,i,r)}function Iy(n,t){return n[Bn].data[t].pure}function RR(n){return t=>{setTimeout(n,void 0,t)}}var L=class extends Ae{constructor(t=!1){super(),this.__isAsync=t}emit(t){super.next(t)}subscribe(t,e,i){let r=t,o=e||(()=>null),a=i;if(t&&"object"==typeof t){let l=t;r=l.next?.bind(l),o=l.error?.bind(l),a=l.complete?.bind(l)}this.__isAsync&&(o=RR(o),r&&(r=RR(r)),a&&(a=RR(a)));let s=super.subscribe({next:r,error:o,complete:a});return t instanceof yn&&t.add(s),s}};function hde(){return this._results[Symbol.iterator]()}var Is=class{get changes(){return this._changes||(this._changes=new L)}constructor(t=!1){this._emitDistinctChangesOnly=t,this.dirty=!0,this._results=[],this._changesDetected=!1,this._changes=null,this.length=0,this.first=void 0,this.last=void 0;let e=Is.prototype;e[Symbol.iterator]||(e[Symbol.iterator]=hde)}get(t){return this._results[t]}map(t){return this._results.map(t)}filter(t){return this._results.filter(t)}find(t){return this._results.find(t)}reduce(t,e){return this._results.reduce(t,e)}forEach(t){this._results.forEach(t)}some(t){return this._results.some(t)}toArray(){return this._results.slice()}toString(){return this._results.toString()}reset(t,e){let i=this;i.dirty=!1;let r=tu(t);(this._changesDetected=!function(n,t,e){if(n.length!==t.length)return!1;for(let i=0;i<n.length;i++){let r=n[i],o=t[i];if(e&&(r=e(r),o=e(o)),o!==r)return!1}return!0}(i._results,r,e))&&(i._results=r,i.length=r.length,i.last=r[this.length-1],i.first=r[0])}notifyOnChanges(){this._changes&&(this._changesDetected||!this._emitDistinctChangesOnly)&&this._changes.emit(this)}setDirty(){this.dirty=!0}destroy(){this.changes.complete(),this.changes.unsubscribe()}},Si=(()=>{class n{}return n.__NG_ELEMENT_ID__=yde,n})(),gde=Si,_de=class extends gde{constructor(t,e,i){super(),this._declarationLView=t,this._declarationTContainer=e,this.elementRef=i}createEmbeddedView(t,e){let i=this._declarationTContainer.tView,r=UM(this._declarationLView,i,t,16,null,i.declTNode,null,null,null,null,e||null);r[gy]=this._declarationLView[this._declarationTContainer.index];let a=this._declarationLView[oc];return null!==a&&(r[oc]=a.createEmbeddedView(i)),MP(i,r,t),new Yp(r)}};function yde(){return JM(Po(),Ke())}function JM(n,t){return 4&n.type?new _de(t,n,gh(n,t)):null}var Zn=(()=>{class n{}return n.__NG_ELEMENT_ID__=bde,n})();function bde(){return Ij(Po(),Ke())}var vde=Zn,Dj=class extends vde{constructor(t,e,i){super(),this._lContainer=t,this._hostTNode=e,this._hostLView=i}get element(){return gh(this._hostTNode,this._hostLView)}get injector(){return new zp(this._hostTNode,this._hostLView)}get parentInjector(){let t=rP(this._hostTNode,this._hostLView);if(J5(t)){let e=uM(t,this._hostLView),i=dM(t);return new zp(e[Bn].data[i+8],e)}return new zp(null,this._hostLView)}clear(){for(;this.length>0;)this.remove(this.length-1)}get(t){let e=u5(this._lContainer);return null!==e&&e[t]||null}get length(){return this._lContainer.length-Ta}createEmbeddedView(t,e,i){let r,o;"number"==typeof i?r=i:null!=i&&(r=i.index,o=i.injector);let a=t.createEmbeddedView(e||{},o);return this.insert(a,r),a}createComponent(t,e,i,r,o){let s,a=t&&!j_(t);if(a)s=e;else{let u=e||{};s=u.index,i=u.injector,r=u.projectableNodes,o=u.environmentInjector||u.ngModuleRef}let l=a?t:new vM(ws(t)),c=i||this.parentInjector;if(!o&&null==l.ngModule){let p=(a?c:this.parentInjector).get(lc,null);p&&(o=p)}let d=l.create(c,r,void 0,o);return this.insert(d.hostView,s),d}insert(t,e){let i=t._lView,r=i[Bn];if($c(i[Yr])){let d=this.indexOf(t);if(-1!==d)this.detach(d);else{let u=i[Yr],p=new Dj(u,u[Da],u[Yr]);p.detach(p.indexOf(t))}}let o=this._adjustIndex(e),a=this._lContainer;!function(n,t,e,i){let r=Ta+i,o=e.length;i>0&&(e[r-1][pl]=t),i<o-Ta?(t[pl]=e[r],lz(e,Ta+i,t)):(e.push(t),t[pl]=null),t[Yr]=e;let a=t[gy];null!==a&&e!==a&&function(n,t){let e=n[ih];t[fl]!==t[Yr][Yr][fl]&&(n[k5]=!0),null===e?n[ih]=[t]:e.push(t)}(a,t);let s=t[oc];null!==s&&s.insertView(n),t[si]|=64}(r,i,a,o);let s=JR(o,a),l=i[li],c=NM(l,a[Qk]);return null!==c&&function(n,t,e,i,r,o){i[lu]=r,i[Da]=t,by(n,i,e,1,r,o)}(r,a[Da],l,i,c,s),t.attachToViewContainerRef(),lz(kR(a),o,t),t}move(t,e){return this.insert(t,e)}indexOf(t){let e=u5(this._lContainer);return null!==e?e.indexOf(t):-1}remove(t){let e=this._adjustIndex(t,-1),i=ZR(this._lContainer,e);i&&(mM(kR(this._lContainer),e),_z(i[Bn],i))}detach(t){let e=this._adjustIndex(t,-1),i=ZR(this._lContainer,e);return i&&null!=mM(kR(this._lContainer),e)?new Yp(i):null}_adjustIndex(t,e=0){return t??this.length+e}};function u5(n){return n[lM]}function kR(n){return n[lM]||(n[lM]=[])}function Ij(n,t){let e,i=t[n.index];if($c(i))e=i;else{let r;if(8&n.type)r=Ts(i);else{let o=t[li];r=o.createComment("");let a=ts(n,t);qp(o,NM(o,a),r,function(n,t){return n.nextSibling(t)}(o,a),!1)}t[n.index]=e=lU(i,t,r,n),GM(t,e)}return new Dj(e,n,t)}var cy=class{constructor(t){this.queryList=t,this.matches=null}clone(){return new cy(this.queryList)}setDirty(){this.queryList.setDirty()}},dy=class{constructor(t=[]){this.queries=t}createEmbeddedView(t){let e=t.queries;if(null!==e){let i=null!==t.contentQueries?t.contentQueries[0]:e.length,r=[];for(let o=0;o<i;o++){let a=e.getByIndex(o);r.push(this.queries[a.indexInDeclarationView].clone())}return new dy(r)}return null}insertView(t){this.dirtyQueriesWithMatches(t)}detachView(t){this.dirtyQueriesWithMatches(t)}dirtyQueriesWithMatches(t){for(let e=0;e<this.queries.length;e++)null!==Pj(t,e).matches&&this.queries[e].setDirty()}},wM=class{constructor(t,e,i=null){this.predicate=t,this.flags=e,this.read=i}},uy=class{constructor(t=[]){this.queries=t}elementStart(t,e){for(let i=0;i<this.queries.length;i++)this.queries[i].elementStart(t,e)}elementEnd(t){for(let e=0;e<this.queries.length;e++)this.queries[e].elementEnd(t)}embeddedTView(t){let e=null;for(let i=0;i<this.length;i++){let r=null!==e?e.length:0,o=this.getByIndex(i).embeddedTView(t,r);o&&(o.indexInDeclarationView=i,null!==e?e.push(o):e=[o])}return null!==e?new uy(e):null}template(t,e){for(let i=0;i<this.queries.length;i++)this.queries[i].template(t,e)}getByIndex(t){return this.queries[t]}get length(){return this.queries.length}track(t){this.queries.push(t)}},py=class{constructor(t,e=-1){this.metadata=t,this.matches=null,this.indexInDeclarationView=-1,this.crossesNgTemplate=!1,this._appliesToNextNode=!0,this._declarationNodeIndex=e}elementStart(t,e){this.isApplyingToNode(e)&&this.matchTNode(t,e)}elementEnd(t){this._declarationNodeIndex===t.index&&(this._appliesToNextNode=!1)}template(t,e){this.elementStart(t,e)}embeddedTView(t,e){return this.isApplyingToNode(t)?(this.crossesNgTemplate=!0,this.addMatch(-t.index,e),new py(this.metadata)):null}isApplyingToNode(t){if(this._appliesToNextNode&&1!=(1&this.metadata.flags)){let e=this._declarationNodeIndex,i=t.parent;for(;null!==i&&8&i.type&&i.index!==e;)i=i.parent;return e===(null!==i?i.index:-1)}return this._appliesToNextNode}matchTNode(t,e){let i=this.metadata.predicate;if(Array.isArray(i))for(let r=0;r<i.length;r++){let o=i[r];this.matchTNodeWithReadOption(t,e,xde(e,o)),this.matchTNodeWithReadOption(t,e,ZC(e,t,o,!1,!1))}else i===Si?4&e.type&&this.matchTNodeWithReadOption(t,e,-1):this.matchTNodeWithReadOption(t,e,ZC(e,t,i,!1,!1))}matchTNodeWithReadOption(t,e,i){if(null!==i){let r=this.metadata.read;if(null!==r)if(r===be||r===Zn||r===Si&&4&e.type)this.addMatch(e.index,-2);else{let o=ZC(e,t,r,!1,!1);null!==o&&this.addMatch(e.index,o)}else this.addMatch(e.index,i)}}addMatch(t,e){null===this.matches?this.matches=[t,e]:this.matches.push(t,e)}};function xde(n,t){let e=n.localNames;if(null!==e)for(let i=0;i<e.length;i+=2)if(e[i]===t)return e[i+1];return null}function Mde(n,t,e,i){return-1===e?function(n,t){return 11&n.type?gh(n,t):4&n.type?JM(n,t):null}(t,n):-2===e?function(n,t,e){return e===be?gh(t,n):e===Si?JM(t,n):e===Zn?Ij(t,n):void 0}(n,t,i):Wp(n,n[Bn],e,t)}function Aj(n,t,e,i){let r=t[oc].queries[i];if(null===r.matches){let o=n.data,a=e.matches,s=[];for(let l=0;l<a.length;l+=2){let c=a[l];s.push(c<0?null:Mde(t,o[c],a[l+1],e.metadata.read))}r.matches=s}return r.matches}function Pk(n,t,e,i){let r=n.queries.getByIndex(e),o=r.matches;if(null!==o){let a=Aj(n,t,r,e);for(let s=0;s<o.length;s+=2){let l=o[s];if(l>0)i.push(a[s/2]);else{let c=o[s+1],d=t[-l];for(let u=Ta;u<d.length;u++){let p=d[u];p[gy]===p[Yr]&&Pk(p[Bn],p,c,i)}if(null!==d[ih]){let u=d[ih];for(let p=0;p<u.length;p++){let f=u[p];Pk(f[Bn],f,c,i)}}}}}return i}function we(n){let t=Ke(),e=Ei(),i=G5();tP(i+1);let r=Pj(e,i);if(n.dirty&&function(n){return 4==(4&n[si])}(t)===(2==(2&r.metadata.flags))){if(null===r.matches)n.reset([]);else{let o=r.crossesNgTemplate?Pk(e,t,i,[]):Aj(e,t,r,i);n.reset(o,ise),n.notifyOnChanges()}return!0}return!1}function Ye(n,t,e){let i=Ei();i.firstCreatePass&&(kj(i,new wM(n,t,e),-1),2==(2&t)&&(i.staticViewQueries=!0)),Rj(i,Ke(),t)}function ci(n,t,e,i){let r=Ei();if(r.firstCreatePass){let o=Po();kj(r,new wM(t,e,i),o.index),function(n,t){let e=n.contentQueries||(n.contentQueries=[]);t!==(e.length?e[e.length-1]:-1)&&e.push(n.queries.length-1,t)}(r,n),2==(2&e)&&(r.staticContentQueries=!0)}Rj(r,Ke(),e)}function Se(){return n=Ke(),t=G5(),n[oc].queries[t].queryList;var n,t}function Rj(n,t,e){let i=new Is(4==(4&e));oU(n,t,i,i.destroy),null===t[oc]&&(t[oc]=new dy),t[oc].queries.push(new cy(i))}function kj(n,t,e){null===n.queries&&(n.queries=new uy),n.queries.track(new py(t,e))}function Pj(n,t){return n.queries.getByIndex(t)}function Zt(n,t){return JM(n,t)}var nu={"\u0275\u0275attribute":Pe,"\u0275\u0275attributeInterpolate1":function _U(n,t,e,i,r,o){let a=Ke(),s=bh(a,t,e,i);return s!==Gn&&pc(kr(),a,n,s,r,o),_U},"\u0275\u0275attributeInterpolate2":function yU(n,t,e,i,r,o,a,s){let l=Ke(),c=vh(l,t,e,i,r,o);return c!==Gn&&pc(kr(),l,n,c,a,s),yU},"\u0275\u0275attributeInterpolate3":function bU(n,t,e,i,r,o,a,s,l,c){let d=Ke(),u=xh(d,t,e,i,r,o,a,s);return u!==Gn&&pc(kr(),d,n,u,l,c),bU},"\u0275\u0275attributeInterpolate4":function vU(n,t,e,i,r,o,a,s,l,c,d,u){let p=Ke(),f=Ch(p,t,e,i,r,o,a,s,l,c);return f!==Gn&&pc(kr(),p,n,f,d,u),vU},"\u0275\u0275attributeInterpolate5":function xU(n,t,e,i,r,o,a,s,l,c,d,u,p,f){let m=Ke(),y=Mh(m,t,e,i,r,o,a,s,l,c,d,u);return y!==Gn&&pc(kr(),m,n,y,p,f),xU},"\u0275\u0275attributeInterpolate6":function CU(n,t,e,i,r,o,a,s,l,c,d,u,p,f,m,y){let M=Ke(),v=wh(M,t,e,i,r,o,a,s,l,c,d,u,p,f);return v!==Gn&&pc(kr(),M,n,v,m,y),CU},"\u0275\u0275attributeInterpolate7":function MU(n,t,e,i,r,o,a,s,l,c,d,u,p,f,m,y,M,v){let x=Ke(),R=Sh(x,t,e,i,r,o,a,s,l,c,d,u,p,f,m,y);return R!==Gn&&pc(kr(),x,n,R,M,v),MU},"\u0275\u0275attributeInterpolate8":function wU(n,t,e,i,r,o,a,s,l,c,d,u,p,f,m,y,M,v,x,R){let A=Ke(),H=Eh(A,t,e,i,r,o,a,s,l,c,d,u,p,f,m,y,M,v);return H!==Gn&&pc(kr(),A,n,H,x,R),wU},"\u0275\u0275attributeInterpolateV":function SU(n,t,e,i){let r=Ke(),o=yh(r,t);return o!==Gn&&pc(kr(),r,n,o,e,i),SU},"\u0275\u0275defineComponent":k,"\u0275\u0275defineDirective":xe,"\u0275\u0275defineInjectable":pe,"\u0275\u0275defineInjector":B,"\u0275\u0275defineNgModule":V,"\u0275\u0275definePipe":ch,"\u0275\u0275directiveInject":C,"\u0275\u0275getInheritedFactory":Cn,"\u0275\u0275inject":O,"\u0275\u0275injectAttribute":Vr,"\u0275\u0275invalidFactory":_l,"\u0275\u0275invalidFactoryDep":E5,"\u0275\u0275templateRefExtractor":Zt,"\u0275\u0275resetView":Q,"\u0275\u0275HostDirectivesFeature":function(n){return t=>{t.findHostDirectiveDefs=hU,t.hostDirectives=(Array.isArray(n)?n:n()).map(e=>"function"==typeof e?{directive:ki(e),inputs:Zc,outputs:Zc}:{directive:ki(e.directive),inputs:$H(e.inputs),outputs:$H(e.outputs)})}},"\u0275\u0275NgOnChangesFeature":Gt,"\u0275\u0275ProvidersFeature":Rt,"\u0275\u0275CopyDefinitionFeature":function(n){let e,t=mU(n.type);e=ml(n)?t.\u0275cmp:t.\u0275dir;let i=n;for(let r of dle)i[r]=e[r];if(ml(e))for(let r of ule)i[r]=e[r]},"\u0275\u0275InheritDefinitionFeature":Le,"\u0275\u0275StandaloneFeature":FP,"\u0275\u0275nextContext":w,"\u0275\u0275namespaceHTML":Oo,"\u0275\u0275namespaceMathML":function(){Xn.lFrame.currentNamespace=N5},"\u0275\u0275namespaceSVG":Tn,"\u0275\u0275enableBindings":function(){Xn.bindingsEnabled=!0},"\u0275\u0275disableBindings":function(){Xn.bindingsEnabled=!1},"\u0275\u0275elementStart":h,"\u0275\u0275elementEnd":g,"\u0275\u0275element":P,"\u0275\u0275elementContainerStart":Tt,"\u0275\u0275elementContainerEnd":Dt,"\u0275\u0275elementContainer":Ti,"\u0275\u0275pureFunction0":uu,"\u0275\u0275pureFunction1":Sn,"\u0275\u0275pureFunction2":Pr,"\u0275\u0275pureFunction3":Ty,"\u0275\u0275pureFunction4":LP,"\u0275\u0275pureFunction5":NP,"\u0275\u0275pureFunction6":function(n,t,e,i,r,o,a,s,l){let c=da()+n,d=Ke(),u=Ds(d,c,e,i,r,o);return Xp(d,c+4,a,s)||u?fc(d,c+6,l?t.call(l,e,i,r,o,a,s):t(e,i,r,o,a,s)):wy(d,c+6)},"\u0275\u0275pureFunction7":function(n,t,e,i,r,o,a,s,l,c){let d=da()+n,u=Ke(),p=Ds(u,d,e,i,r,o);return WM(u,d+4,a,s,l)||p?fc(u,d+7,c?t.call(c,e,i,r,o,a,s,l):t(e,i,r,o,a,s,l)):wy(u,d+7)},"\u0275\u0275pureFunction8":function(n,t,e,i,r,o,a,s,l,c,d){let u=da()+n,p=Ke(),f=Ds(p,u,e,i,r,o);return Ds(p,u+4,a,s,l,c)||f?fc(p,u+8,d?t.call(d,e,i,r,o,a,s,l,c):t(e,i,r,o,a,s,l,c)):wy(p,u+8)},"\u0275\u0275pureFunctionV":function(n,t,e,i){return Tj(Ke(),da(),n,t,e,i)},"\u0275\u0275getCurrentView":ge,"\u0275\u0275restoreView":X,"\u0275\u0275listener":D,"\u0275\u0275projection":Xt,"\u0275\u0275syntheticHostProperty":Kp,"\u0275\u0275syntheticHostListener":Zp,"\u0275\u0275pipeBind1":W,"\u0275\u0275pipeBind2":Jp,"\u0275\u0275pipeBind3":BP,"\u0275\u0275pipeBind4":function(n,t,e,i,r,o){let a=n+Xr,s=Ke(),l=uh(s,a);return Iy(s,a)?Ej(s,da(),t,l.transform,e,i,r,o,l):l.transform(e,i,r,o)},"\u0275\u0275pipeBindV":function(n,t,e){let i=n+Xr,r=Ke(),o=uh(r,i);return Iy(r,i)?Tj(r,da(),t,o.transform,e,o):o.transform.apply(o,e)},"\u0275\u0275projectionDef":gn,"\u0275\u0275hostProperty":Co,"\u0275\u0275property":_,"\u0275\u0275propertyInterpolate":Ji,"\u0275\u0275propertyInterpolate1":Sy,"\u0275\u0275propertyInterpolate2":qM,"\u0275\u0275propertyInterpolate3":function TU(n,t,e,i,r,o,a,s,l){let c=Ke(),d=xh(c,t,e,i,r,o,a,s);return d!==Gn&&is(Ei(),kr(),c,n,d,c[li],l,!1),TU},"\u0275\u0275propertyInterpolate4":function DU(n,t,e,i,r,o,a,s,l,c,d){let u=Ke(),p=Ch(u,t,e,i,r,o,a,s,l,c);return p!==Gn&&is(Ei(),kr(),u,n,p,u[li],d,!1),DU},"\u0275\u0275propertyInterpolate5":function IU(n,t,e,i,r,o,a,s,l,c,d,u,p){let f=Ke(),m=Mh(f,t,e,i,r,o,a,s,l,c,d,u);return m!==Gn&&is(Ei(),kr(),f,n,m,f[li],p,!1),IU},"\u0275\u0275propertyInterpolate6":function AU(n,t,e,i,r,o,a,s,l,c,d,u,p,f,m){let y=Ke(),M=wh(y,t,e,i,r,o,a,s,l,c,d,u,p,f);return M!==Gn&&is(Ei(),kr(),y,n,M,y[li],m,!1),AU},"\u0275\u0275propertyInterpolate7":function RU(n,t,e,i,r,o,a,s,l,c,d,u,p,f,m,y,M){let v=Ke(),x=Sh(v,t,e,i,r,o,a,s,l,c,d,u,p,f,m,y);return x!==Gn&&is(Ei(),kr(),v,n,x,v[li],M,!1),RU},"\u0275\u0275propertyInterpolate8":function kU(n,t,e,i,r,o,a,s,l,c,d,u,p,f,m,y,M,v,x){let R=Ke(),A=Eh(R,t,e,i,r,o,a,s,l,c,d,u,p,f,m,y,M,v);return A!==Gn&&is(Ei(),kr(),R,n,A,R[li],x,!1),kU},"\u0275\u0275propertyInterpolateV":function PU(n,t,e){let i=Ke(),r=yh(i,t);return r!==Gn&&is(Ei(),kr(),i,n,r,i[li],e,!1),PU},"\u0275\u0275pipe":G,"\u0275\u0275queryRefresh":we,"\u0275\u0275viewQuery":Ye,"\u0275\u0275loadQuery":Se,"\u0275\u0275contentQuery":ci,"\u0275\u0275reference":tt,"\u0275\u0275classMap":ka,"\u0275\u0275classMapInterpolate1":Dh,"\u0275\u0275classMapInterpolate2":function(n,t,e,i,r){bl(ns,mc,vh(Ke(),n,t,e,i,r),!0)},"\u0275\u0275classMapInterpolate3":function(n,t,e,i,r,o,a){bl(ns,mc,xh(Ke(),n,t,e,i,r,o,a),!0)},"\u0275\u0275classMapInterpolate4":function(n,t,e,i,r,o,a,s,l){bl(ns,mc,Ch(Ke(),n,t,e,i,r,o,a,s,l),!0)},"\u0275\u0275classMapInterpolate5":function(n,t,e,i,r,o,a,s,l,c,d){bl(ns,mc,Mh(Ke(),n,t,e,i,r,o,a,s,l,c,d),!0)},"\u0275\u0275classMapInterpolate6":function(n,t,e,i,r,o,a,s,l,c,d,u,p){bl(ns,mc,wh(Ke(),n,t,e,i,r,o,a,s,l,c,d,u,p),!0)},"\u0275\u0275classMapInterpolate7":function(n,t,e,i,r,o,a,s,l,c,d,u,p,f,m){bl(ns,mc,Sh(Ke(),n,t,e,i,r,o,a,s,l,c,d,u,p,f,m),!0)},"\u0275\u0275classMapInterpolate8":function(n,t,e,i,r,o,a,s,l,c,d,u,p,f,m,y,M){bl(ns,mc,Eh(Ke(),n,t,e,i,r,o,a,s,l,c,d,u,p,f,m,y,M),!0)},"\u0275\u0275classMapInterpolateV":function(n){bl(ns,mc,yh(Ke(),n),!0)},"\u0275\u0275styleMap":Rs,"\u0275\u0275styleMapInterpolate1":function(n,t,e){Rs(bh(Ke(),n,t,e))},"\u0275\u0275styleMapInterpolate2":function(n,t,e,i,r){Rs(vh(Ke(),n,t,e,i,r))},"\u0275\u0275styleMapInterpolate3":function(n,t,e,i,r,o,a){Rs(xh(Ke(),n,t,e,i,r,o,a))},"\u0275\u0275styleMapInterpolate4":function(n,t,e,i,r,o,a,s,l){Rs(Ch(Ke(),n,t,e,i,r,o,a,s,l))},"\u0275\u0275styleMapInterpolate5":function(n,t,e,i,r,o,a,s,l,c,d){Rs(Mh(Ke(),n,t,e,i,r,o,a,s,l,c,d))},"\u0275\u0275styleMapInterpolate6":function(n,t,e,i,r,o,a,s,l,c,d,u,p){Rs(wh(Ke(),n,t,e,i,r,o,a,s,l,c,d,u,p))},"\u0275\u0275styleMapInterpolate7":function(n,t,e,i,r,o,a,s,l,c,d,u,p,f,m){Rs(Sh(Ke(),n,t,e,i,r,o,a,s,l,c,d,u,p,f,m))},"\u0275\u0275styleMapInterpolate8":function(n,t,e,i,r,o,a,s,l,c,d,u,p,f,m,y,M){Rs(Eh(Ke(),n,t,e,i,r,o,a,s,l,c,d,u,p,f,m,y,M))},"\u0275\u0275styleMapInterpolateV":function(n){Rs(yh(Ke(),n))},"\u0275\u0275styleProp":Mt,"\u0275\u0275stylePropInterpolate1":function QU(n,t,e,i,r){return yl(n,bh(Ke(),t,e,i),r,!1),QU},"\u0275\u0275stylePropInterpolate2":function ZU(n,t,e,i,r,o,a){return yl(n,vh(Ke(),t,e,i,r,o),a,!1),ZU},"\u0275\u0275stylePropInterpolate3":function KU(n,t,e,i,r,o,a,s,l){return yl(n,xh(Ke(),t,e,i,r,o,a,s),l,!1),KU},"\u0275\u0275stylePropInterpolate4":function JU(n,t,e,i,r,o,a,s,l,c,d){return yl(n,Ch(Ke(),t,e,i,r,o,a,s,l,c),d,!1),JU},"\u0275\u0275stylePropInterpolate5":function $U(n,t,e,i,r,o,a,s,l,c,d,u,p){return yl(n,Mh(Ke(),t,e,i,r,o,a,s,l,c,d,u),p,!1),$U},"\u0275\u0275stylePropInterpolate6":function ej(n,t,e,i,r,o,a,s,l,c,d,u,p,f,m){return yl(n,wh(Ke(),t,e,i,r,o,a,s,l,c,d,u,p,f),m,!1),ej},"\u0275\u0275stylePropInterpolate7":function tj(n,t,e,i,r,o,a,s,l,c,d,u,p,f,m,y,M){return yl(n,Sh(Ke(),t,e,i,r,o,a,s,l,c,d,u,p,f,m,y),M,!1),tj},"\u0275\u0275stylePropInterpolate8":function nj(n,t,e,i,r,o,a,s,l,c,d,u,p,f,m,y,M,v,x){return yl(n,Eh(Ke(),t,e,i,r,o,a,s,l,c,d,u,p,f,m,y,M,v),x,!1),nj},"\u0275\u0275stylePropInterpolateV":function ij(n,t,e){return yl(n,yh(Ke(),t),e,!1),ij},"\u0275\u0275classProp":Qe,"\u0275\u0275advance":b,"\u0275\u0275template":S,"\u0275\u0275text":T,"\u0275\u0275textInterpolate":ut,"\u0275\u0275textInterpolate1":ze,"\u0275\u0275textInterpolate2":du,"\u0275\u0275textInterpolate3":YM,"\u0275\u0275textInterpolate4":function jU(n,t,e,i,r,o,a,s,l){let c=Ke(),d=Ch(c,n,t,e,i,r,o,a,s,l);return d!==Gn&&od(c,ua(),d),jU},"\u0275\u0275textInterpolate5":function GU(n,t,e,i,r,o,a,s,l,c,d){let u=Ke(),p=Mh(u,n,t,e,i,r,o,a,s,l,c,d);return p!==Gn&&od(u,ua(),p),GU},"\u0275\u0275textInterpolate6":function WU(n,t,e,i,r,o,a,s,l,c,d,u,p){let f=Ke(),m=wh(f,n,t,e,i,r,o,a,s,l,c,d,u,p);return m!==Gn&&od(f,ua(),m),WU},"\u0275\u0275textInterpolate7":function qU(n,t,e,i,r,o,a,s,l,c,d,u,p,f,m){let y=Ke(),M=Sh(y,n,t,e,i,r,o,a,s,l,c,d,u,p,f,m);return M!==Gn&&od(y,ua(),M),qU},"\u0275\u0275textInterpolate8":function YU(n,t,e,i,r,o,a,s,l,c,d,u,p,f,m,y,M){let v=Ke(),x=Eh(v,n,t,e,i,r,o,a,s,l,c,d,u,p,f,m,y,M);return x!==Gn&&od(v,ua(),x),YU},"\u0275\u0275textInterpolateV":function XU(n){let t=Ke(),e=yh(t,n);return e!==Gn&&od(t,ua(),e),XU},"\u0275\u0275i18n":QM,"\u0275\u0275i18nAttributes":function(n,t){let e=Ei(),i=ou(e.consts,t);!function(n,t,e){let r=Po().index,o=[];if(n.firstCreatePass&&null===n.data[t]){for(let a=0;a<e.length;a+=2){let s=e[a],l=e[a+1];if(""!==l){if(Ice.test(l))throw new Error(`ICU expressions are not supported in attributes. Message: "${l}".`);$_(o,l,r,s,Bce(o),null)}}n.data[t]=o}}(e,n+Xr,i)},"\u0275\u0275i18nExp":Ey,"\u0275\u0275i18nStart":vj,"\u0275\u0275i18nEnd":xj,"\u0275\u0275i18nApply":ZM,"\u0275\u0275i18nPostprocess":KM,"\u0275\u0275resolveWindow":function(n){return n.ownerDocument.defaultView},"\u0275\u0275resolveDocument":uc,"\u0275\u0275resolveBody":function(n){return n.ownerDocument.body},"\u0275\u0275setComponentScope":hy,"\u0275\u0275setNgModuleScope":function(n,t){return su(()=>{let e=nh(n,!0);e.declarations=t.declarations||Ui,e.imports=t.imports||Ui,e.exports=t.exports||Ui})},"\u0275\u0275registerNgModuleType":pz,"\u0275\u0275sanitizeHtml":bP,"\u0275\u0275sanitizeStyle":function(n){let t=Cy();return t?t.sanitize(qr.STYLE,n)||"":gl(n,"Style")?Ra(n):Yn(n)},"\u0275\u0275sanitizeResourceUrl":Uz,"\u0275\u0275sanitizeScript":function(n){let t=Cy();if(t)return zH(t.sanitize(qr.SCRIPT,n)||"");if(gl(n,"Script"))return zH(Ra(n));throw new bt(905,!1)},"\u0275\u0275sanitizeUrl":As,"\u0275\u0275sanitizeUrlOrResourceUrl":function(n,t,e){return function(n,t){return"src"===t&&("embed"===n||"frame"===n||"iframe"===n||"media"===n||"script"===n)||"href"===t&&("base"===n||"link"===n)?Uz:As}(t,e)(n)},"\u0275\u0275trustConstantHtml":function(n){return hh(n[0])},"\u0275\u0275trustConstantResourceUrl":function(n){return function(n){return Iz()?.createScriptURL(n)||n}(n[0])},"\u0275\u0275validateIframeAttribute":function(n,t,e){let i=Ke(),r=kr(),o=ts(r,i);if(2===r.type&&"iframe"===t.toLowerCase()){let a=o;throw a.src="",a.srcdoc=hh(""),mP(i[li],a),new bt(-910,!1)}return n},forwardRef:Vn,resolveForwardRef:ki},G_=null;function Oj(n){return!!nh(n)}var tM=[],PR=!1;function Fj(n){return Array.isArray(n)?n.every(Fj):!!ki(n)}function Ode(n,t){let e=tu(t.declarations||Ui),i=lh(n);e.forEach(r=>{(r=ki(r)).hasOwnProperty(AM)?Lj(ws(r),i):!r.hasOwnProperty(qk)&&!r.hasOwnProperty(Yk)&&(r.ngSelectorScope=n)})}function Lj(n,t){n.directiveDefs=()=>Array.from(t.compilation.directives).map(e=>e.hasOwnProperty(AM)?ws(e):iu(e)).filter(e=>!!e),n.pipeDefs=()=>Array.from(t.compilation.pipes).map(e=>ru(e)),n.schemas=t.schemas,n.tView=null}function lh(n){if(Oj(n))return function(n){let t=nh(n,!0);if(null!==t.transitiveCompileScopes)return t.transitiveCompileScopes;let e={schemas:t.schemas||null,compilation:{directives:new Set,pipes:new Set},exported:{directives:new Set,pipes:new Set}};return $C(t.imports).forEach(i=>{let r=lh(i);r.exported.directives.forEach(o=>e.compilation.directives.add(o)),r.exported.pipes.forEach(o=>e.compilation.pipes.add(o))}),$C(t.declarations).forEach(i=>{ru(i)?e.compilation.pipes.add(i):e.compilation.directives.add(i)}),$C(t.exports).forEach(i=>{let r=i;if(Oj(r)){let o=lh(r);o.exported.directives.forEach(a=>{e.compilation.directives.add(a),e.exported.directives.add(a)}),o.exported.pipes.forEach(a=>{e.compilation.pipes.add(a),e.exported.pipes.add(a)})}else ru(r)?e.exported.pipes.add(r):e.exported.directives.add(r)}),t.transitiveCompileScopes=e,e}(n);if(D5(n)){if(null!==(ws(n)||iu(n)))return{schemas:null,compilation:{directives:new Set,pipes:new Set},exported:{directives:new Set([n]),pipes:new Set}};if(null!==ru(n))return{schemas:null,compilation:{directives:new Set,pipes:new Set},exported:{directives:new Set,pipes:new Set([n])}}}throw new Error(`${n.name} does not have a module def (\u0275mod property)`)}function p5(n){return function(n){return void 0!==n.ngModule}(n)?n.ngModule:n}var OR=0;function Nj(n,t){let e=null;Vj(n,t||{}),Object.defineProperty(n,qk,{get:()=>{if(null===e){let i=Bj(n,t||{});e=Ss().compileDirective(nu,i.sourceMapUrl,i.metadata)}return e},configurable:!1})}function Bj(n,t){let e=n&&n.name,i=`ng:///${e}/\u0275dir.js`,r=Ss(),o=Hj(n,t);return o.typeSourceSpan=r.createParseSourceSpan("Directive",e,i),o.usesInheritance&&zj(n),{metadata:o,sourceMapUrl:i}}function Vj(n,t){let e=null;Object.defineProperty(n,Kc,{get:()=>{if(null===e){let i=Bj(n,t),r=Ss();e=r.compileFactory(nu,`ng:///${n.name}/\u0275fac.js`,{name:i.metadata.name,type:i.metadata.type,typeArgumentCount:0,deps:LM(n),target:r.FactoryTarget.Directive})}return e},configurable:!1})}function Vde(n){return Object.getPrototypeOf(n.prototype)===Object.prototype}function Hj(n,t){let e=sP(),i=e.ownPropMetadata(n);return{name:n.name,type:n,selector:void 0!==t.selector?t.selector:null,host:t.host||Zc,propMetadata:i,inputs:t.inputs||Ui,outputs:t.outputs||Ui,queries:f5(n,i,Uj),lifecycle:{usesOnChanges:e.hasLifecycleHook(n,"ngOnChanges")},typeSourceSpan:null,usesInheritance:!Vde(n),exportAs:Ude(t.exportAs),providers:t.providers||null,viewQueries:f5(n,i,jj),isStandalone:!!t.standalone,hostDirectives:t.hostDirectives?.map(r=>"function"==typeof r?{directive:r}:r)||null}}function zj(n){let t=Object.prototype,e=Object.getPrototypeOf(n.prototype).constructor;for(;e&&e!==t;)!iu(e)&&!ws(e)&&Gde(e)&&Nj(e,null),e=Object.getPrototypeOf(e)}function Hde(n){return"string"==typeof n?Wj(n):ki(n)}function zde(n,t){return{propertyName:n,predicate:Hde(t.selector),descendants:t.descendants,first:t.first,read:t.read?t.read:null,static:!!t.static,emitDistinctChangesOnly:!!t.emitDistinctChangesOnly}}function f5(n,t,e){let i=[];for(let r in t)if(t.hasOwnProperty(r)){let o=t[r];o.forEach(a=>{if(e(a)){if(!a.selector)throw new Error(`Can't construct a query for the property "${r}" of "${jk(n)}" since the query selector wasn't defined.`);if(o.some(Gj))throw new Error("Cannot combine @Input decorators with query decorators");i.push(zde(r,a))}})}return i}function Ude(n){return void 0===n?null:Wj(n)}function Uj(n){let t=n.ngMetadataName;return"ContentChild"===t||"ContentChildren"===t}function jj(n){let t=n.ngMetadataName;return"ViewChild"===t||"ViewChildren"===t}function Gj(n){return"Input"===n.ngMetadataName}function Wj(n){return n.split(",").map(t=>t.trim())}var jde=["ngOnChanges","ngOnInit","ngOnDestroy","ngDoCheck","ngAfterViewInit","ngAfterViewChecked","ngAfterContentInit","ngAfterContentChecked"];function Gde(n){let t=sP();if(jde.some(i=>t.hasLifecycleHook(n,i)))return!0;let e=t.propMetadata(n);for(let i in e){let r=e[i];for(let o=0;o<r.length;o++){let a=r[o],s=a.ngMetadataName;if(Gj(a)||Uj(a)||jj(a)||"Output"===s||"HostBinding"===s||"HostListener"===s)return!0}}return!1}function m5(n,t){return{type:n,name:n.name,pipeName:t.name,pure:void 0===t.pure||t.pure,isStandalone:!!t.standalone}}var qde=_y("Directive",(n={})=>n,void 0,void 0,(n,t)=>Nj(n,t));function SM(...n){}_y("Component",(n={})=>({changeDetection:q_.Default,...n}),qde,void 0,(n,t)=>function(n,t){let e=null;(function(n,t){uz(t)&&(ay.set(n,t),dz.add(n))})(n,t),Vj(n,t),Object.defineProperty(n,AM,{get:()=>{if(null===e){let i=Ss();if(uz(t)){let c=[`Component '${n.name}' is not resolved:`];throw t.templateUrl&&c.push(` - templateUrl: ${t.templateUrl}`),t.styleUrls&&t.styleUrls.length&&c.push(` - styleUrls: ${JSON.stringify(t.styleUrls)}`),c.push("Did you run and wait for 'resolveComponentResources()'?"),new Error(c.join("\n"))}let o=t.preserveWhitespaces;void 0===o&&(o=null!==G_&&void 0!==G_.preserveWhitespaces&&G_.preserveWhitespaces);let a=t.encapsulation;void 0===a&&(a=null!==G_&&void 0!==G_.defaultEncapsulation?G_.defaultEncapsulation:es.Emulated);let s=t.templateUrl||`ng:///${n.name}/template.html`,l={...Hj(n,t),typeSourceSpan:i.createParseSourceSpan("Component",n.name,s),template:t.template||"",preserveWhitespaces:o,styles:t.styles||Ui,animations:t.animations,declarations:[],changeDetection:t.changeDetection,encapsulation:a,interpolation:t.interpolation,viewProviders:t.viewProviders||null};OR++;try{if(l.usesInheritance&&zj(n),e=i.compileComponent(nu,s,l),t.standalone){let c=tu(t.imports||Ui),{directiveDefs:d,pipeDefs:u}=function(n,t){let e=null,i=null;return{directiveDefs:()=>{if(null===e){e=[ws(n)];let a=new Set;for(let s of t){let l=ki(s);if(!a.has(l))if(a.add(l),nh(l)){let c=lh(l);for(let d of c.exported.directives){let u=ws(d)||iu(d);u&&!a.has(d)&&(a.add(d),e.push(u))}}else{let c=ws(l)||iu(l);c&&e.push(c)}}}return e},pipeDefs:()=>{if(null===i){i=[];let a=new Set;for(let s of t){let l=ki(s);if(!a.has(l))if(a.add(l),nh(l)){let c=lh(l);for(let d of c.exported.pipes){let u=ru(d);u&&!a.has(d)&&(a.add(d),i.push(u))}}else{let c=ru(l);c&&i.push(c)}}}return i}}}(n,c);e.directiveDefs=d,e.pipeDefs=u,e.dependencies=()=>c.map(ki)}}finally{OR--}if(0===OR&&function(){if(!PR){PR=!0;try{for(let n=tM.length-1;n>=0;n--){let{moduleType:t,ngModule:e}=tM[n];e.declarations&&e.declarations.every(Fj)&&(tM.splice(n,1),Ode(t,e))}}finally{PR=!1}}}(),function(n){return void 0!==n.ngSelectorScope}(n)){let c=lh(n.ngSelectorScope);Lj(e,c)}if(t.schemas){if(!t.standalone)throw new Error(`The 'schemas' was specified for the ${jk(n)} but is only valid on a component that is standalone.`);e.schemas=t.schemas}else t.standalone&&(e.schemas=[])}return e},configurable:!1})}(n,t)),_y("Pipe",n=>({pure:!0,...n}),void 0,void 0,(n,t)=>function(n,t){let e=null,i=null;Object.defineProperty(n,Kc,{get:()=>{if(null===i){let r=m5(n,t),o=Ss();i=o.compileFactory(nu,`ng:///${r.name}/\u0275fac.js`,{name:r.name,type:r.type,typeArgumentCount:0,deps:LM(n),target:o.FactoryTarget.Pipe})}return i},configurable:!1}),Object.defineProperty(n,Yk,{get:()=>{if(null===e){let r=m5(n,t);e=Ss().compilePipe(nu,`ng:///${r.name}/\u0275pipe.js`,r)}return e},configurable:!1})}(n,t)),cu("Input",n=>({bindingPropertyName:n})),cu("Output",n=>({bindingPropertyName:n})),cu("HostBinding",n=>({hostPropertyName:n})),cu("HostListener",(n,t)=>({eventName:n,args:t})),_y("NgModule",n=>n,void 0,void 0,(n,t)=>function(n,t={}){(function(n,t,e=!1){let i=tu(t.declarations||Ui),r=null;Object.defineProperty(n,T5,{configurable:!0,get:()=>(null===r&&(r=Ss().compileNgModule(nu,`ng:///${n.name}/\u0275mod.js`,{type:n,bootstrap:tu(t.bootstrap||Ui).map(ki),declarations:i.map(ki),imports:tu(t.imports||Ui).map(ki).map(p5),exports:tu(t.exports||Ui).map(ki).map(p5),schemas:t.schemas?tu(t.schemas):null,id:t.id||null}),r.schemas||(r.schemas=[])),r)});let o=null;Object.defineProperty(n,Kc,{get:()=>{if(null===o){let s=Ss();o=s.compileFactory(nu,`ng:///${n.name}/\u0275fac.js`,{name:n.name,type:n,deps:LM(n),target:s.FactoryTarget.NgModule,typeArgumentCount:0})}return o},configurable:!1});let a=null;Object.defineProperty(n,NR,{get:()=>{if(null===a){let s={name:n.name,type:n,providers:t.providers||Ui,imports:[(t.imports||Ui).map(ki),(t.exports||Ui).map(ki)]};a=Ss().compileInjector(nu,`ng:///${n.name}/\u0275inj.js`,s)}return a},configurable:!1})})(n,t),void 0!==t.id&&pz(n,t.id),function(n,t){tM.push({moduleType:n,ngModule:t})}(n,t)}(n,t));var VP=new ie("Application Initializer"),$M=(()=>{class n{constructor(e){this.appInits=e,this.resolve=SM,this.reject=SM,this.initialized=!1,this.done=!1,this.donePromise=new Promise((i,r)=>{this.resolve=i,this.reject=r})}runInitializers(){if(this.initialized)return;let e=[],i=()=>{this.done=!0,this.resolve()};if(this.appInits)for(let r=0;r<this.appInits.length;r++){let o=this.appInits[r]();if(Th(o))e.push(o);else if(OP(o)){let a=new Promise((s,l)=>{o.subscribe({complete:s,error:l})});e.push(a)}}Promise.all(e).then(()=>{i()}).catch(r=>{this.reject(r)}),0===e.length&&i(),this.initialized=!0}}return n.\u0275fac=function(e){return new(e||n)(O(VP,8))},n.\u0275prov=pe({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),$p=new ie("AppId",{providedIn:"root",factory:function(){return`${FR()}${FR()}${FR()}`}});function FR(){return String.fromCharCode(97+Math.floor(25*Math.random()))}var HP=new ie("Platform Initializer"),hc=new ie("Platform ID",{providedIn:"platform",factory:()=>"unknown"}),di=(new ie("Application Packages Root URL"),new ie("AnimationModuleType")),ad=new ie("LocaleId",{providedIn:"root",factory:()=>pi(ad,Mi.Optional|Mi.SkipSelf)||typeof $localize<"u"&&$localize.locale||CM}),Kde=(new ie("DefaultCurrencyCode",{providedIn:"root",factory:()=>"USD"}),new ie("Translations"),new ie("TranslationsFormat"),new ie("compilerOptions"),Promise.resolve(0));function Ok(n){typeof Zone>"u"?Kde.then(()=>{n&&n.apply(null,null)}):Zone.current.scheduleMicroTask("scheduleMicrotask",n)}var at=class{constructor({enableLongStackTrace:t=!1,shouldCoalesceEventChangeDetection:e=!1,shouldCoalesceRunChangeDetection:i=!1}){if(this.hasPendingMacrotasks=!1,this.hasPendingMicrotasks=!1,this.isStable=!0,this.onUnstable=new L(!1),this.onMicrotaskEmpty=new L(!1),this.onStable=new L(!1),this.onError=new L(!1),typeof Zone>"u")throw new bt(908,!1);Zone.assertZonePatched();let r=this;r._nesting=0,r._outer=r._inner=Zone.current,Zone.TaskTrackingZoneSpec&&(r._inner=r._inner.fork(new Zone.TaskTrackingZoneSpec)),t&&Zone.longStackTraceZoneSpec&&(r._inner=r._inner.fork(Zone.longStackTraceZoneSpec)),r.shouldCoalesceEventChangeDetection=!i&&e,r.shouldCoalesceRunChangeDetection=i,r.lastRequestAnimationFrameId=-1,r.nativeRequestAnimationFrame=function(){let n=Wr.requestAnimationFrame,t=Wr.cancelAnimationFrame;if(typeof Zone<"u"&&n&&t){let e=n[Zone.__symbol__("OriginalDelegate")];e&&(n=e);let i=t[Zone.__symbol__("OriginalDelegate")];i&&(t=i)}return{nativeRequestAnimationFrame:n,nativeCancelAnimationFrame:t}}().nativeRequestAnimationFrame,function(n){let t=()=>{!function(n){n.isCheckStableRunning||-1!==n.lastRequestAnimationFrameId||(n.lastRequestAnimationFrameId=n.nativeRequestAnimationFrame.call(Wr,()=>{n.fakeTopEventTask||(n.fakeTopEventTask=Zone.root.scheduleEventTask("fakeTopEventTask",()=>{n.lastRequestAnimationFrameId=-1,Fk(n),n.isCheckStableRunning=!0,zP(n),n.isCheckStableRunning=!1},void 0,()=>{},()=>{})),n.fakeTopEventTask.invoke()}),Fk(n))}(n)};n._inner=n._inner.fork({name:"angular",properties:{isAngularZone:!0},onInvokeTask:(e,i,r,o,a,s)=>{try{return h5(n),e.invokeTask(r,o,a,s)}finally{(n.shouldCoalesceEventChangeDetection&&"eventTask"===o.type||n.shouldCoalesceRunChangeDetection)&&t(),g5(n)}},onInvoke:(e,i,r,o,a,s,l)=>{try{return h5(n),e.invoke(r,o,a,s,l)}finally{n.shouldCoalesceRunChangeDetection&&t(),g5(n)}},onHasTask:(e,i,r,o)=>{e.hasTask(r,o),i===r&&("microTask"==o.change?(n._hasPendingMicrotasks=o.microTask,Fk(n),zP(n)):"macroTask"==o.change&&(n.hasPendingMacrotasks=o.macroTask))},onHandleError:(e,i,r,o)=>(e.handleError(r,o),n.runOutsideAngular(()=>n.onError.emit(o)),!1)})}(r)}static isInAngularZone(){return typeof Zone<"u"&&!0===Zone.current.get("isAngularZone")}static assertInAngularZone(){if(!at.isInAngularZone())throw new bt(909,!1)}static assertNotInAngularZone(){if(at.isInAngularZone())throw new bt(909,!1)}run(t,e,i){return this._inner.run(t,e,i)}runTask(t,e,i,r){let o=this._inner,a=o.scheduleEventTask("NgZoneEvent: "+r,t,$de,SM,SM);try{return o.runTask(a,e,i)}finally{o.cancelTask(a)}}runGuarded(t,e,i){return this._inner.runGuarded(t,e,i)}runOutsideAngular(t){return this._outer.run(t)}},$de={};function zP(n){if(0==n._nesting&&!n.hasPendingMicrotasks&&!n.isStable)try{n._nesting++,n.onMicrotaskEmpty.emit(null)}finally{if(n._nesting--,!n.hasPendingMicrotasks)try{n.runOutsideAngular(()=>n.onStable.emit(null))}finally{n.isStable=!0}}}function Fk(n){n.hasPendingMicrotasks=!!(n._hasPendingMicrotasks||(n.shouldCoalesceEventChangeDetection||n.shouldCoalesceRunChangeDetection)&&-1!==n.lastRequestAnimationFrameId)}function h5(n){n._nesting++,n.isStable&&(n.isStable=!1,n.onUnstable.emit(null))}function g5(n){n._nesting--,zP(n)}var jP,UP=new ie(""),Ay=new ie(""),ew=(()=>{class n{constructor(e,i,r){this._ngZone=e,this.registry=i,this._pendingCount=0,this._isZoneStable=!0,this._didWork=!1,this._callbacks=[],this.taskTrackingZone=null,jP||(function(n){jP=n}(r),r.addToWindow(i)),this._watchAngularEvents(),e.run(()=>{this.taskTrackingZone=typeof Zone>"u"?null:Zone.current.get("TaskTrackingZone")})}_watchAngularEvents(){this._ngZone.onUnstable.subscribe({next:()=>{this._didWork=!0,this._isZoneStable=!1}}),this._ngZone.runOutsideAngular(()=>{this._ngZone.onStable.subscribe({next:()=>{at.assertNotInAngularZone(),Ok(()=>{this._isZoneStable=!0,this._runCallbacksIfReady()})}})})}increasePendingRequestCount(){return this._pendingCount+=1,this._didWork=!0,this._pendingCount}decreasePendingRequestCount(){if(this._pendingCount-=1,this._pendingCount<0)throw new Error("pending async requests below zero");return this._runCallbacksIfReady(),this._pendingCount}isStable(){return this._isZoneStable&&0===this._pendingCount&&!this._ngZone.hasPendingMacrotasks}_runCallbacksIfReady(){if(this.isStable())Ok(()=>{for(;0!==this._callbacks.length;){let e=this._callbacks.pop();clearTimeout(e.timeoutId),e.doneCb(this._didWork)}this._didWork=!1});else{let e=this.getPendingTasks();this._callbacks=this._callbacks.filter(i=>!i.updateCb||!i.updateCb(e)||(clearTimeout(i.timeoutId),!1)),this._didWork=!0}}getPendingTasks(){return this.taskTrackingZone?this.taskTrackingZone.macroTasks.map(e=>({source:e.source,creationLocation:e.creationLocation,data:e.data})):[]}addCallback(e,i,r){let o=-1;i&&i>0&&(o=setTimeout(()=>{this._callbacks=this._callbacks.filter(a=>a.timeoutId!==o),e(this._didWork,this.getPendingTasks())},i)),this._callbacks.push({doneCb:e,timeoutId:o,updateCb:r})}whenStable(e,i,r){if(r&&!this.taskTrackingZone)throw new Error('Task tracking zone is required when passing an update callback to whenStable(). Is "zone.js/plugins/task-tracking" loaded?');this.addCallback(e,i,r),this._runCallbacksIfReady()}getPendingRequestCount(){return this._pendingCount}registerApplication(e){this.registry.registerApplication(e,this)}unregisterApplication(e){this.registry.unregisterApplication(e)}findProviders(e,i,r){return[]}}return n.\u0275fac=function(e){return new(e||n)(O(at),O(tw),O(Ay))},n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})(),tw=(()=>{class n{constructor(){this._applications=new Map}registerApplication(e,i){this._applications.set(e,i)}unregisterApplication(e){this._applications.delete(e)}unregisterAllApplications(){this._applications.clear()}getTestability(e){return this._applications.get(e)||null}getAllTestabilities(){return Array.from(this._applications.values())}getAllRootElements(){return Array.from(this._applications.keys())}findTestabilityInTree(e,i=!0){return jP?.findTestabilityInTree(this,e,i)??null}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=pe({token:n,factory:n.\u0275fac,providedIn:"platform"}),n})(),ey=null,qj=new ie("AllowMultipleToken"),Yj=new ie("PlatformDestroyListeners"),iue=new ie("appBootstrapListener");function GP(n,t,e=[]){let i=`Platform: ${t}`,r=new ie(i);return(o=[])=>{let a=Xj();if(!a||a.injector.get(qj,!1)){let s=[...e,...o,{provide:r,useValue:!0}];n?n(s):function(n){if(ey&&!ey.get(qj,!1))throw new bt(400,!1);ey=n;let t=n.get(Qj);(function(n){let t=n.get(HP,null);t&&t.forEach(e=>e())})(n)}(function(n=[],t){return bi.create({name:t,providers:[{provide:zM,useValue:"platform"},{provide:Yj,useValue:new Set([()=>ey=null])},...n]})}(s,i))}return function(n){let t=Xj();if(!t)throw new bt(401,!1);return t}()}}function Xj(){return ey?.get(Qj)??null}var Qj=(()=>{class n{constructor(e){this._injector=e,this._modules=[],this._destroyListeners=[],this._destroyed=!1}bootstrapModuleFactory(e,i){let r=function(n,t){let e;return e="noop"===n?new class{constructor(){this.hasPendingMicrotasks=!1,this.hasPendingMacrotasks=!1,this.isStable=!0,this.onUnstable=new L,this.onMicrotaskEmpty=new L,this.onStable=new L,this.onError=new L}run(t,e,i){return t.apply(e,i)}runGuarded(t,e,i){return t.apply(e,i)}runOutsideAngular(t){return t()}runTask(t,e,i,r){return t.apply(e,i)}}:("zone.js"===n?void 0:n)||new at(t),e}(i?.ngZone,function(n){return{enableLongStackTrace:!1,shouldCoalesceEventChangeDetection:!(!n||!n.ngZoneEventCoalescing)||!1,shouldCoalesceRunChangeDetection:!(!n||!n.ngZoneRunCoalescing)||!1}}(i)),o=[{provide:at,useValue:r}];return r.run(()=>{let a=bi.create({providers:o,parent:this.injector,name:e.moduleType.name}),s=e.create(a),l=s.injector.get(ca,null);if(!l)throw new bt(402,!1);return r.runOutsideAngular(()=>{let c=r.onError.subscribe({next:d=>{l.handleError(d)}});s.onDestroy(()=>{nM(this._modules,s),c.unsubscribe()})}),function(n,t,e){try{let i=e();return Th(i)?i.catch(r=>{throw t.runOutsideAngular(()=>n.handleError(r)),r}):i}catch(i){throw t.runOutsideAngular(()=>n.handleError(i)),i}}(l,r,()=>{let c=s.injector.get($M);return c.runInitializers(),c.donePromise.then(()=>(function(n){(function(n,t){null==n&&M5("Expected localeId to be defined",n,null,"!=")})(n),"string"==typeof n&&(sj=n.toLowerCase().replace(/_/g,"-"))}(s.injector.get(ad,CM)||CM),this._moduleDoBootstrap(s),s))})})}bootstrapModule(e,i=[]){let r=Zj({},i);return function(n,t,e){let i=new Ak(e);return Promise.resolve(i)}(0,0,e).then(o=>this.bootstrapModuleFactory(o,r))}_moduleDoBootstrap(e){let i=e.injector.get(gc);if(e._bootstrapComponents.length>0)e._bootstrapComponents.forEach(r=>i.bootstrap(r));else{if(!e.instance.ngDoBootstrap)throw new bt(-403,!1);e.instance.ngDoBootstrap(i)}this._modules.push(e)}onDestroy(e){this._destroyListeners.push(e)}get injector(){return this._injector}destroy(){if(this._destroyed)throw new bt(404,!1);this._modules.slice().forEach(i=>i.destroy()),this._destroyListeners.forEach(i=>i());let e=this._injector.get(Yj,null);e&&(e.forEach(i=>i()),e.clear()),this._destroyed=!0}get destroyed(){return this._destroyed}}return n.\u0275fac=function(e){return new(e||n)(O(bi))},n.\u0275prov=pe({token:n,factory:n.\u0275fac,providedIn:"platform"}),n})();function Zj(n,t){return Array.isArray(t)?t.reduce(Zj,n):{...n,...t}}var gc=(()=>{class n{get destroyed(){return this._destroyed}get injector(){return this._injector}constructor(e,i,r){this._zone=e,this._injector=i,this._exceptionHandler=r,this._bootstrapListeners=[],this._views=[],this._runningTick=!1,this._stable=!0,this._destroyed=!1,this._destroyListeners=[],this.componentTypes=[],this.components=[],this._onMicrotaskEmptySubscription=this._zone.onMicrotaskEmpty.subscribe({next:()=>{this._zone.run(()=>{this.tick()})}});let o=new en(s=>{this._stable=this._zone.isStable&&!this._zone.hasPendingMacrotasks&&!this._zone.hasPendingMicrotasks,this._zone.runOutsideAngular(()=>{s.next(this._stable),s.complete()})}),a=new en(s=>{let l;this._zone.runOutsideAngular(()=>{l=this._zone.onStable.subscribe(()=>{at.assertNotInAngularZone(),Ok(()=>{!this._stable&&!this._zone.hasPendingMacrotasks&&!this._zone.hasPendingMicrotasks&&(this._stable=!0,s.next(!0))})})});let c=this._zone.onUnstable.subscribe(()=>{at.assertInAngularZone(),this._stable&&(this._stable=!1,this._zone.runOutsideAngular(()=>{s.next(!1)}))});return()=>{l.unsubscribe(),c.unsubscribe()}});this.isStable=cn(o,a.pipe(Sa()))}bootstrap(e,i){let a,r=e instanceof _M;if(!this._injector.get($M).done)throw!r&&D5(e),new bt(405,false);a=r?e:this._injector.get(Qr).resolveComponentFactory(e),this.componentTypes.push(a.componentType);let s=function(n){return n.isBoundToModule}(a)?void 0:this._injector.get(au),c=a.create(bi.NULL,[],i||a.selector,s),d=c.location.nativeElement,u=c.injector.get(UP,null);return u?.registerApplication(d),c.onDestroy(()=>{this.detachView(c.hostView),nM(this.components,c),u?.unregisterApplication(d)}),this._loadComponent(c),c}tick(){if(this._runningTick)throw new bt(101,!1);try{this._runningTick=!0;for(let e of this._views)e.detectChanges()}catch(e){this._zone.runOutsideAngular(()=>this._exceptionHandler.handleError(e))}finally{this._runningTick=!1}}attachView(e){let i=e;this._views.push(i),i.attachToAppRef(this)}detachView(e){let i=e;nM(this._views,i),i.detachFromAppRef()}_loadComponent(e){this.attachView(e.hostView),this.tick(),this.components.push(e);let i=this._injector.get(iue,[]);i.push(...this._bootstrapListeners),i.forEach(r=>r(e))}ngOnDestroy(){if(!this._destroyed)try{this._destroyListeners.forEach(e=>e()),this._views.slice().forEach(e=>e.destroy()),this._onMicrotaskEmptySubscription.unsubscribe()}finally{this._destroyed=!0,this._views=[],this._bootstrapListeners=[],this._destroyListeners=[]}}onDestroy(e){return this._destroyListeners.push(e),()=>nM(this._destroyListeners,e)}destroy(){if(this._destroyed)throw new bt(406,!1);let e=this._injector;e.destroy&&!e.destroyed&&e.destroy()}get viewCount(){return this._views.length}warnIfDestroyed(){}}return n.\u0275fac=function(e){return new(e||n)(O(at),O(lc),O(ca))},n.\u0275prov=pe({token:n,factory:n.\u0275fac,providedIn:"root"}),n})();function nM(n,t){let e=n.indexOf(t);e>-1&&n.splice(e,1)}var Ft=(()=>{class n{}return n.__NG_ELEMENT_ID__=mue,n})();function mue(n){return function(n,t,e){if(kM(n)&&!e){let i=ed(n.index,t);return new Yp(i,i)}return 47&n.type?new Yp(t[fl],t):null}(Po(),Ke(),16==(16&n))}var EM=class{constructor(){}supports(t){return gU(t)}create(t){return new Nk(t)}},gue=(n,t)=>t,Nk=class{constructor(t){this.length=0,this._linkedRecords=null,this._unlinkedRecords=null,this._previousItHead=null,this._itHead=null,this._itTail=null,this._additionsHead=null,this._additionsTail=null,this._movesHead=null,this._movesTail=null,this._removalsHead=null,this._removalsTail=null,this._identityChangesHead=null,this._identityChangesTail=null,this._trackByFn=t||gue}forEachItem(t){let e;for(e=this._itHead;null!==e;e=e._next)t(e)}forEachOperation(t){let e=this._itHead,i=this._removalsHead,r=0,o=null;for(;e||i;){let a=!i||e&&e.currentIndex<y5(i,r,o)?e:i,s=y5(a,r,o),l=a.currentIndex;if(a===i)r--,i=i._nextRemoved;else if(e=e._next,null==a.previousIndex)r++;else{o||(o=[]);let c=s-r,d=l-r;if(c!=d){for(let p=0;p<c;p++){let f=p<o.length?o[p]:o[p]=0,m=f+p;d<=m&&m<c&&(o[p]=f+1)}o[a.previousIndex]=d-c}}s!==l&&t(a,s,l)}}forEachPreviousItem(t){let e;for(e=this._previousItHead;null!==e;e=e._nextPrevious)t(e)}forEachAddedItem(t){let e;for(e=this._additionsHead;null!==e;e=e._nextAdded)t(e)}forEachMovedItem(t){let e;for(e=this._movesHead;null!==e;e=e._nextMoved)t(e)}forEachRemovedItem(t){let e;for(e=this._removalsHead;null!==e;e=e._nextRemoved)t(e)}forEachIdentityChange(t){let e;for(e=this._identityChangesHead;null!==e;e=e._nextIdentityChange)t(e)}diff(t){if(null==t&&(t=[]),!gU(t))throw new bt(900,!1);return this.check(t)?this:null}onDestroy(){}check(t){this._reset();let r,o,a,e=this._itHead,i=!1;if(Array.isArray(t)){this.length=t.length;for(let s=0;s<this.length;s++)o=t[s],a=this._trackByFn(s,o),null!==e&&Object.is(e.trackById,a)?(i&&(e=this._verifyReinsertion(e,o,a,s)),Object.is(e.item,o)||this._addIdentityChange(e,o)):(e=this._mismatch(e,o,a,s),i=!0),e=e._next}else r=0,function(n,t){if(Array.isArray(n))for(let e=0;e<n.length;e++)t(n[e]);else{let i,e=n[Symbol.iterator]();for(;!(i=e.next()).done;)t(i.value)}}(t,s=>{a=this._trackByFn(r,s),null!==e&&Object.is(e.trackById,a)?(i&&(e=this._verifyReinsertion(e,s,a,r)),Object.is(e.item,s)||this._addIdentityChange(e,s)):(e=this._mismatch(e,s,a,r),i=!0),e=e._next,r++}),this.length=r;return this._truncate(e),this.collection=t,this.isDirty}get isDirty(){return null!==this._additionsHead||null!==this._movesHead||null!==this._removalsHead||null!==this._identityChangesHead}_reset(){if(this.isDirty){let t;for(t=this._previousItHead=this._itHead;null!==t;t=t._next)t._nextPrevious=t._next;for(t=this._additionsHead;null!==t;t=t._nextAdded)t.previousIndex=t.currentIndex;for(this._additionsHead=this._additionsTail=null,t=this._movesHead;null!==t;t=t._nextMoved)t.previousIndex=t.currentIndex;this._movesHead=this._movesTail=null,this._removalsHead=this._removalsTail=null,this._identityChangesHead=this._identityChangesTail=null}}_mismatch(t,e,i,r){let o;return null===t?o=this._itTail:(o=t._prev,this._remove(t)),null!==(t=null===this._unlinkedRecords?null:this._unlinkedRecords.get(i,null))?(Object.is(t.item,e)||this._addIdentityChange(t,e),this._reinsertAfter(t,o,r)):null!==(t=null===this._linkedRecords?null:this._linkedRecords.get(i,r))?(Object.is(t.item,e)||this._addIdentityChange(t,e),this._moveAfter(t,o,r)):t=this._addAfter(new Bk(e,i),o,r),t}_verifyReinsertion(t,e,i,r){let o=null===this._unlinkedRecords?null:this._unlinkedRecords.get(i,null);return null!==o?t=this._reinsertAfter(o,t._prev,r):t.currentIndex!=r&&(t.currentIndex=r,this._addToMoves(t,r)),t}_truncate(t){for(;null!==t;){let e=t._next;this._addToRemovals(this._unlink(t)),t=e}null!==this._unlinkedRecords&&this._unlinkedRecords.clear(),null!==this._additionsTail&&(this._additionsTail._nextAdded=null),null!==this._movesTail&&(this._movesTail._nextMoved=null),null!==this._itTail&&(this._itTail._next=null),null!==this._removalsTail&&(this._removalsTail._nextRemoved=null),null!==this._identityChangesTail&&(this._identityChangesTail._nextIdentityChange=null)}_reinsertAfter(t,e,i){null!==this._unlinkedRecords&&this._unlinkedRecords.remove(t);let r=t._prevRemoved,o=t._nextRemoved;return null===r?this._removalsHead=o:r._nextRemoved=o,null===o?this._removalsTail=r:o._prevRemoved=r,this._insertAfter(t,e,i),this._addToMoves(t,i),t}_moveAfter(t,e,i){return this._unlink(t),this._insertAfter(t,e,i),this._addToMoves(t,i),t}_addAfter(t,e,i){return this._insertAfter(t,e,i),this._additionsTail=null===this._additionsTail?this._additionsHead=t:this._additionsTail._nextAdded=t,t}_insertAfter(t,e,i){let r=null===e?this._itHead:e._next;return t._next=r,t._prev=e,null===r?this._itTail=t:r._prev=t,null===e?this._itHead=t:e._next=t,null===this._linkedRecords&&(this._linkedRecords=new TM),this._linkedRecords.put(t),t.currentIndex=i,t}_remove(t){return this._addToRemovals(this._unlink(t))}_unlink(t){null!==this._linkedRecords&&this._linkedRecords.remove(t);let e=t._prev,i=t._next;return null===e?this._itHead=i:e._next=i,null===i?this._itTail=e:i._prev=e,t}_addToMoves(t,e){return t.previousIndex===e||(this._movesTail=null===this._movesTail?this._movesHead=t:this._movesTail._nextMoved=t),t}_addToRemovals(t){return null===this._unlinkedRecords&&(this._unlinkedRecords=new TM),this._unlinkedRecords.put(t),t.currentIndex=null,t._nextRemoved=null,null===this._removalsTail?(this._removalsTail=this._removalsHead=t,t._prevRemoved=null):(t._prevRemoved=this._removalsTail,this._removalsTail=this._removalsTail._nextRemoved=t),t}_addIdentityChange(t,e){return t.item=e,this._identityChangesTail=null===this._identityChangesTail?this._identityChangesHead=t:this._identityChangesTail._nextIdentityChange=t,t}},Bk=class{constructor(t,e){this.item=t,this.trackById=e,this.currentIndex=null,this.previousIndex=null,this._nextPrevious=null,this._prev=null,this._next=null,this._prevDup=null,this._nextDup=null,this._prevRemoved=null,this._nextRemoved=null,this._nextAdded=null,this._nextMoved=null,this._nextIdentityChange=null}},TM=class{constructor(){this.map=new Map}put(t){let e=t.trackById,i=this.map.get(e);i||(i=new class{constructor(){this._head=null,this._tail=null}add(t){null===this._head?(this._head=this._tail=t,t._nextDup=null,t._prevDup=null):(this._tail._nextDup=t,t._prevDup=this._tail,t._nextDup=null,this._tail=t)}get(t,e){let i;for(i=this._head;null!==i;i=i._nextDup)if((null===e||e<=i.currentIndex)&&Object.is(i.trackById,t))return i;return null}remove(t){let e=t._prevDup,i=t._nextDup;return null===e?this._head=i:e._nextDup=i,null===i?this._tail=e:i._prevDup=e,null===this._head}},this.map.set(e,i)),i.add(t)}get(t,e){let r=this.map.get(t);return r?r.get(t,e):null}remove(t){let e=t.trackById;return this.map.get(e).remove(t)&&this.map.delete(e),t}get isEmpty(){return 0===this.map.size}clear(){this.map.clear()}};function y5(n,t,e){let i=n.previousIndex;if(null===i)return i;let r=0;return e&&i<e.length&&(r=e[i]),i+t+r}var DM=class{constructor(){}supports(t){return t instanceof Map||kP(t)}create(){return new Hk}},Hk=class{constructor(){this._records=new Map,this._mapHead=null,this._appendAfter=null,this._previousMapHead=null,this._changesHead=null,this._changesTail=null,this._additionsHead=null,this._additionsTail=null,this._removalsHead=null,this._removalsTail=null}get isDirty(){return null!==this._additionsHead||null!==this._changesHead||null!==this._removalsHead}forEachItem(t){let e;for(e=this._mapHead;null!==e;e=e._next)t(e)}forEachPreviousItem(t){let e;for(e=this._previousMapHead;null!==e;e=e._nextPrevious)t(e)}forEachChangedItem(t){let e;for(e=this._changesHead;null!==e;e=e._nextChanged)t(e)}forEachAddedItem(t){let e;for(e=this._additionsHead;null!==e;e=e._nextAdded)t(e)}forEachRemovedItem(t){let e;for(e=this._removalsHead;null!==e;e=e._nextRemoved)t(e)}diff(t){if(t){if(!(t instanceof Map||kP(t)))throw new bt(900,!1)}else t=new Map;return this.check(t)?this:null}onDestroy(){}check(t){this._reset();let e=this._mapHead;if(this._appendAfter=null,this._forEach(t,(i,r)=>{if(e&&e.key===r)this._maybeAddToChanges(e,i),this._appendAfter=e,e=e._next;else{let o=this._getOrCreateRecordForKey(r,i);e=this._insertBeforeOrAppend(e,o)}}),e){e._prev&&(e._prev._next=null),this._removalsHead=e;for(let i=e;null!==i;i=i._nextRemoved)i===this._mapHead&&(this._mapHead=null),this._records.delete(i.key),i._nextRemoved=i._next,i.previousValue=i.currentValue,i.currentValue=null,i._prev=null,i._next=null}return this._changesTail&&(this._changesTail._nextChanged=null),this._additionsTail&&(this._additionsTail._nextAdded=null),this.isDirty}_insertBeforeOrAppend(t,e){if(t){let i=t._prev;return e._next=t,e._prev=i,t._prev=e,i&&(i._next=e),t===this._mapHead&&(this._mapHead=e),this._appendAfter=t,t}return this._appendAfter?(this._appendAfter._next=e,e._prev=this._appendAfter):this._mapHead=e,this._appendAfter=e,null}_getOrCreateRecordForKey(t,e){if(this._records.has(t)){let r=this._records.get(t);this._maybeAddToChanges(r,e);let o=r._prev,a=r._next;return o&&(o._next=a),a&&(a._prev=o),r._next=null,r._prev=null,r}let i=new zk(t);return this._records.set(t,i),i.currentValue=e,this._addToAdditions(i),i}_reset(){if(this.isDirty){let t;for(this._previousMapHead=this._mapHead,t=this._previousMapHead;null!==t;t=t._next)t._nextPrevious=t._next;for(t=this._changesHead;null!==t;t=t._nextChanged)t.previousValue=t.currentValue;for(t=this._additionsHead;null!=t;t=t._nextAdded)t.previousValue=t.currentValue;this._changesHead=this._changesTail=null,this._additionsHead=this._additionsTail=null,this._removalsHead=null}}_maybeAddToChanges(t,e){Object.is(e,t.currentValue)||(t.previousValue=t.currentValue,t.currentValue=e,this._addToChanges(t))}_addToAdditions(t){null===this._additionsHead?this._additionsHead=this._additionsTail=t:(this._additionsTail._nextAdded=t,this._additionsTail=t)}_addToChanges(t){null===this._changesHead?this._changesHead=this._changesTail=t:(this._changesTail._nextChanged=t,this._changesTail=t)}_forEach(t,e){t instanceof Map?t.forEach(e):Object.keys(t).forEach(i=>e(t[i],i))}},zk=class{constructor(t){this.key=t,this.previousValue=null,this.currentValue=null,this._nextPrevious=null,this._next=null,this._prev=null,this._nextAdded=null,this._nextRemoved=null,this._nextChanged=null}};function b5(){return new vl([new EM])}var vl=(()=>{class n{constructor(e){this.factories=e}static create(e,i){if(null!=i){let r=i.factories.slice();e=e.concat(r)}return new n(e)}static extend(e){return{provide:n,useFactory:i=>n.create(e,i||b5()),deps:[[n,new id,new Aa]]}}find(e){let i=this.factories.find(r=>r.supports(e));if(null!=i)return i;throw new bt(901,!1)}}return n.\u0275prov=pe({token:n,providedIn:"root",factory:b5}),n})();function v5(){return new ky([new DM])}var ky=(()=>{class n{constructor(e){this.factories=e}static create(e,i){if(i){let r=i.factories.slice();e=e.concat(r)}return new n(e)}static extend(e){return{provide:n,useFactory:i=>n.create(e,i||v5()),deps:[[n,new id,new Aa]]}}find(e){let i=this.factories.find(r=>r.supports(e));if(i)return i;throw new bt(901,!1)}}return n.\u0275prov=pe({token:n,providedIn:"root",factory:v5}),n})(),_ue=[new DM],yue=[new EM],Kj=(new vl(yue),new ky(_ue),GP(null,"core",[])),Jj=(()=>{class n{constructor(e){}}return n.\u0275fac=function(e){return new(e||n)(O(gc))},n.\u0275mod=V({type:n}),n.\u0275inj=B({}),n})();function nw(n){return"boolean"==typeof n?n:null!=n&&"false"!==n}var bue=":",pu=class{static zero(){return new pu([0])}static one(){return new pu([1])}constructor(t){this.digits=t}clone(){return new pu(this.digits.slice())}add(t){let e=this.clone();return e.addToSelf(t),e}addToSelf(t){let e=Math.max(this.digits.length,t.digits.length),i=0;for(let r=0;r<e;r++){let o=i;r<this.digits.length&&(o+=this.digits[r]),r<t.digits.length&&(o+=t.digits[r]),o>=10?(this.digits[r]=o-10,i=1):(this.digits[r]=o,i=0)}i>0&&(this.digits[e]=1)}toString(){let t="";for(let e=this.digits.length-1;e>=0;e--)t+=this.digits[e];return t}},iw=class{constructor(t){this.powerOfTwos=[t]}getValue(){return this.powerOfTwos[0]}multiplyBy(t){let e=pu.zero();return this.multiplyByAndAddTo(t,e),e}multiplyByAndAddTo(t,e){for(let i=0;0!==t;t>>>=1,i++)if(1&t){let r=this.getMultipliedByPowerOfTwo(i);e.addToSelf(r)}}getMultipliedByPowerOfTwo(t){for(let e=this.powerOfTwos.length;e<=t;e++){let i=this.powerOfTwos[e-1];this.powerOfTwos[e]=i.add(i)}return this.powerOfTwos[t]}};new class{visitText(t,e){return t.value}visitContainer(t,e){return`[${t.children.map(i=>i.visit(this)).join(", ")}]`}visitIcu(t,e){let i=Object.keys(t.cases).map(r=>`${r} {${t.cases[r].visit(this)}}`);return`{${t.expression}, ${t.type}, ${i.join(", ")}}`}visitTagPlaceholder(t,e){return t.isVoid?`<ph tag name="${t.startName}"/>`:`<ph tag name="${t.startName}">${t.children.map(i=>i.visit(this)).join(", ")}</ph name="${t.closeName}">`}visitPlaceholder(t,e){return t.value?`<ph name="${t.name}">${t.value}</ph>`:`<ph name="${t.name}"/>`}visitIcuPlaceholder(t,e){return`<ph icu name="${t.name}">${t.value.visit(this)}</ph>`}},new class{constructor(t){this.base=t,this.exponents=[new iw(pu.one())]}toThePowerOf(t){for(let e=this.exponents.length;e<=t;e++){let i=this.exponents[e-1].multiplyBy(this.base);this.exponents[e]=new iw(i)}return this.exponents[t]}}(256);var rw=function(n,...t){if(rw.translate){let i=rw.translate(n,t);n=i[0],t=i[1]}let e=$j(n[0],n.raw[0]);for(let i=1;i<n.length;i++)e+=t[i-1]+$j(n[i],n.raw[i]);return e},xue=":";function $j(n,t){return t.charAt(0)===xue?n.substring(function(n,t){for(let e=1,i=1;e<n.length;e++,i++)if("\\"===t[i])i++;else if(n[e]===bue)return e;throw new Error(`Unterminated $localize metadata block in "${t}".`)}(n,t)+1):n}(()=>typeof globalThis<"u"&&globalThis||typeof global<"u"&&global||typeof window<"u"&&window||typeof self<"u"&&typeof WorkerGlobalScope<"u"&&self instanceof WorkerGlobalScope&&self)().$localize=rw;var $P=null;function Ml(){return $P}var fw=class{},kt=new ie("DocumentToken"),uG=(()=>{class n{historyGo(e){throw new Error("Not implemented")}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=pe({token:n,factory:function(){return O(pG)},providedIn:"platform"}),n})();new ie("Location Initialized");var pG=(()=>{class n extends uG{constructor(e){super(),this._doc=e,this._location=window.location,this._history=window.history}getBaseHrefFromDOM(){return Ml().getBaseHref(this._doc)}onPopState(e){let i=Ml().getGlobalEventTarget(this._doc,"window");return i.addEventListener("popstate",e,!1),()=>i.removeEventListener("popstate",e)}onHashChange(e){let i=Ml().getGlobalEventTarget(this._doc,"window");return i.addEventListener("hashchange",e,!1),()=>i.removeEventListener("hashchange",e)}get href(){return this._location.href}get protocol(){return this._location.protocol}get hostname(){return this._location.hostname}get port(){return this._location.port}get pathname(){return this._location.pathname}get search(){return this._location.search}get hash(){return this._location.hash}set pathname(e){this._location.pathname=e}pushState(e,i,r){tG()?this._history.pushState(e,i,r):this._location.hash=r}replaceState(e,i,r){tG()?this._history.replaceState(e,i,r):this._location.hash=r}forward(){this._history.forward()}back(){this._history.back()}historyGo(e=0){this._history.go(e)}getState(){return this._history.state}}return n.\u0275fac=function(e){return new(e||n)(O(kt))},n.\u0275prov=pe({token:n,factory:function(){return new pG(O(kt))},providedIn:"platform"}),n})();function tG(){return!!window.history.pushState}function fG(n,t){if(0==n.length)return t;if(0==t.length)return n;let e=0;return n.endsWith("/")&&e++,t.startsWith("/")&&e++,2==e?n+t.substring(1):1==e?n+t:n+"/"+t}function nG(n){let t=n.match(/#|\?|$/),e=t&&t.index||n.length;return n.slice(0,e-("/"===n[e-1]?1:0))+n.slice(e)}function ef(n){return n&&"?"!==n[0]?"?"+n:n}var rO=(()=>{class n{historyGo(e){throw new Error("Not implemented")}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=pe({token:n,factory:function(){return pi(Sue)},providedIn:"root"}),n})(),wue=new ie("appBaseHref"),Sue=(()=>{class n extends rO{constructor(e,i){super(),this._platformLocation=e,this._removeListenerFns=[],this._baseHref=i??this._platformLocation.getBaseHrefFromDOM()??pi(kt).location?.origin??""}ngOnDestroy(){for(;this._removeListenerFns.length;)this._removeListenerFns.pop()()}onPopState(e){this._removeListenerFns.push(this._platformLocation.onPopState(e),this._platformLocation.onHashChange(e))}getBaseHref(){return this._baseHref}prepareExternalUrl(e){return fG(this._baseHref,e)}path(e=!1){let i=this._platformLocation.pathname+ef(this._platformLocation.search),r=this._platformLocation.hash;return r&&e?`${i}${r}`:i}pushState(e,i,r,o){let a=this.prepareExternalUrl(r+ef(o));this._platformLocation.pushState(e,i,a)}replaceState(e,i,r,o){let a=this.prepareExternalUrl(r+ef(o));this._platformLocation.replaceState(e,i,a)}forward(){this._platformLocation.forward()}back(){this._platformLocation.back()}getState(){return this._platformLocation.getState()}historyGo(e=0){this._platformLocation.historyGo?.(e)}}return n.\u0275fac=function(e){return new(e||n)(O(uG),O(wue,8))},n.\u0275prov=pe({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),Fy=(()=>{class n{constructor(e){this._subject=new L,this._urlChangeListeners=[],this._urlChangeSubscription=null,this._locationStrategy=e;let i=this._locationStrategy.getBaseHref();this._basePath=function(n){if(new RegExp("^(https?:)?//").test(n)){let[,e]=n.split(/\/\/[^\/]+/);return e}return n}(nG(iG(i))),this._locationStrategy.onPopState(r=>{this._subject.emit({url:this.path(!0),pop:!0,state:r.state,type:r.type})})}ngOnDestroy(){this._urlChangeSubscription?.unsubscribe(),this._urlChangeListeners=[]}path(e=!1){return this.normalize(this._locationStrategy.path(e))}getState(){return this._locationStrategy.getState()}isCurrentPathEqualTo(e,i=""){return this.path()==this.normalize(e+ef(i))}normalize(e){return n.stripTrailingSlash(function(n,t){if(!n||!t.startsWith(n))return t;let e=t.substring(n.length);return""===e||["/",";","?","#"].includes(e[0])?e:t}(this._basePath,iG(e)))}prepareExternalUrl(e){return e&&"/"!==e[0]&&(e="/"+e),this._locationStrategy.prepareExternalUrl(e)}go(e,i="",r=null){this._locationStrategy.pushState(r,"",e,i),this._notifyUrlChangeListeners(this.prepareExternalUrl(e+ef(i)),r)}replaceState(e,i="",r=null){this._locationStrategy.replaceState(r,"",e,i),this._notifyUrlChangeListeners(this.prepareExternalUrl(e+ef(i)),r)}forward(){this._locationStrategy.forward()}back(){this._locationStrategy.back()}historyGo(e=0){this._locationStrategy.historyGo?.(e)}onUrlChange(e){return this._urlChangeListeners.push(e),this._urlChangeSubscription||(this._urlChangeSubscription=this.subscribe(i=>{this._notifyUrlChangeListeners(i.url,i.state)})),()=>{let i=this._urlChangeListeners.indexOf(e);this._urlChangeListeners.splice(i,1),0===this._urlChangeListeners.length&&(this._urlChangeSubscription?.unsubscribe(),this._urlChangeSubscription=null)}}_notifyUrlChangeListeners(e="",i){this._urlChangeListeners.forEach(r=>r(e,i))}subscribe(e,i,r){return this._subject.subscribe({next:e,error:i,complete:r})}}return n.normalizeQueryParams=ef,n.joinWithSlash=fG,n.stripTrailingSlash=nG,n.\u0275fac=function(e){return new(e||n)(O(rO))},n.\u0275prov=pe({token:n,factory:function(){return new Fy(O(rO))},providedIn:"root"}),n})();function iG(n){return n.replace(/\/index.html$/,"")}var uw=(()=>{return(n=uw||(uw={}))[n.Decimal=0]="Decimal",n[n.Percent=1]="Percent",n[n.Currency=2]="Currency",n[n.Scientific=3]="Scientific",uw;var n})(),Fo=(()=>{return(n=Fo||(Fo={}))[n.Format=0]="Format",n[n.Standalone=1]="Standalone",Fo;var n})(),Xi=(()=>{return(n=Xi||(Xi={}))[n.Narrow=0]="Narrow",n[n.Abbreviated=1]="Abbreviated",n[n.Wide=2]="Wide",n[n.Short=3]="Short",Xi;var n})(),pa=(()=>{return(n=pa||(pa={}))[n.Short=0]="Short",n[n.Medium=1]="Medium",n[n.Long=2]="Long",n[n.Full=3]="Full",pa;var n})(),Go=(()=>{return(n=Go||(Go={}))[n.Decimal=0]="Decimal",n[n.Group=1]="Group",n[n.List=2]="List",n[n.PercentSign=3]="PercentSign",n[n.PlusSign=4]="PlusSign",n[n.MinusSign=5]="MinusSign",n[n.Exponential=6]="Exponential",n[n.SuperscriptingExponent=7]="SuperscriptingExponent",n[n.PerMille=8]="PerMille",n[n.Infinity=9]="Infinity",n[n.NaN=10]="NaN",n[n.TimeSeparator=11]="TimeSeparator",n[n.CurrencyDecimal=12]="CurrencyDecimal",n[n.CurrencyGroup=13]="CurrencyGroup",Go;var n})();function ow(n,t){return ks(Pa(n)[gr.DateFormat],t)}function aw(n,t){return ks(Pa(n)[gr.TimeFormat],t)}function sw(n,t){return ks(Pa(n)[gr.DateTimeFormat],t)}function ld(n,t){let e=Pa(n),i=e[gr.NumberSymbols][t];if(typeof i>"u"){if(t===Go.CurrencyDecimal)return e[gr.NumberSymbols][Go.Decimal];if(t===Go.CurrencyGroup)return e[gr.NumberSymbols][Go.Group]}return i}function mG(n){if(!n[gr.ExtraData])throw new Error(`Missing extra locale data for the locale "${n[gr.LocaleId]}". Use "registerLocaleData" to load new data. See the "I18n guide" on angular.io to know more.`)}function ks(n,t){for(let e=t;e>-1;e--)if(typeof n[e]<"u")return n[e];throw new Error("Locale data API: locale data undefined")}function YP(n){let[t,e]=n.split(":");return{hours:+t,minutes:+e}}var Nue=/^(\d{4,})-?(\d\d)-?(\d\d)(?:T(\d\d)(?::?(\d\d)(?::?(\d\d)(?:\.(\d+))?)?)?(Z|([+-])(\d\d):?(\d\d))?)?$/,Py={},Bue=/((?:[^BEGHLMOSWYZabcdhmswyz']+)|(?:'(?:[^']|'')*')|(?:G{1,5}|y{1,4}|Y{1,4}|M{1,5}|L{1,5}|w{1,2}|W{1}|d{1,2}|E{1,6}|c{1,6}|a{1,5}|b{1,5}|B{1,5}|h{1,2}|H{1,2}|m{1,2}|s{1,2}|S{1,3}|z{1,4}|Z{1,5}|O{1,4}))([\s\S]*)/,Cl=(()=>{return(n=Cl||(Cl={}))[n.Short=0]="Short",n[n.ShortGMT=1]="ShortGMT",n[n.Long=2]="Long",n[n.Extended=3]="Extended",Cl;var n})(),Ai=(()=>{return(n=Ai||(Ai={}))[n.FullYear=0]="FullYear",n[n.Month=1]="Month",n[n.Date=2]="Date",n[n.Hours=3]="Hours",n[n.Minutes=4]="Minutes",n[n.Seconds=5]="Seconds",n[n.FractionalSeconds=6]="FractionalSeconds",n[n.Day=7]="Day",Ai;var n})(),Ii=(()=>{return(n=Ii||(Ii={}))[n.DayPeriods=0]="DayPeriods",n[n.Days=1]="Days",n[n.Months=2]="Months",n[n.Eras=3]="Eras",Ii;var n})();function Vue(n,t,e,i){let r=function(n){if(rG(n))return n;if("number"==typeof n&&!isNaN(n))return new Date(n);if("string"==typeof n){if(n=n.trim(),/^(\d{4}(-\d{1,2}(-\d{1,2})?)?)$/.test(n)){let[r,o=1,a=1]=n.split("-").map(s=>+s);return mw(r,o-1,a)}let i,e=parseFloat(n);if(!isNaN(n-e))return new Date(e);if(i=n.match(Nue))return function(n){let t=new Date(0),e=0,i=0,r=n[8]?t.setUTCFullYear:t.setFullYear,o=n[8]?t.setUTCHours:t.setHours;n[9]&&(e=Number(n[9]+n[10]),i=Number(n[9]+n[11])),r.call(t,Number(n[1]),Number(n[2])-1,Number(n[3]));let a=Number(n[4]||0)-e,s=Number(n[5]||0)-i,l=Number(n[6]||0),c=Math.floor(1e3*parseFloat("0."+(n[7]||0)));return o.call(t,a,s,l,c),t}(i)}let t=new Date(n);if(!rG(t))throw new Error(`Unable to convert "${n}" into a date`);return t}(n);t=sd(e,t)||t;let s,a=[];for(;t;){if(s=Bue.exec(t),!s){a.push(t);break}{a=a.concat(s.slice(1));let d=a.pop();if(!d)break;t=d}}let l=r.getTimezoneOffset();i&&(l=gG(i,l),r=function(n,t,e){let r=n.getTimezoneOffset();return function(n,t){return(n=new Date(n.getTime())).setMinutes(n.getMinutes()+t),n}(n,-1*(gG(t,r)-r))}(r,i));let c="";return a.forEach(d=>{let u=function(n){if(QP[n])return QP[n];let t;switch(n){case"G":case"GG":case"GGG":t=ar(Ii.Eras,Xi.Abbreviated);break;case"GGGG":t=ar(Ii.Eras,Xi.Wide);break;case"GGGGG":t=ar(Ii.Eras,Xi.Narrow);break;case"y":t=io(Ai.FullYear,1,0,!1,!0);break;case"yy":t=io(Ai.FullYear,2,0,!0,!0);break;case"yyy":t=io(Ai.FullYear,3,0,!1,!0);break;case"yyyy":t=io(Ai.FullYear,4,0,!1,!0);break;case"Y":t=dw(1);break;case"YY":t=dw(2,!0);break;case"YYY":t=dw(3);break;case"YYYY":t=dw(4);break;case"M":case"L":t=io(Ai.Month,1,1);break;case"MM":case"LL":t=io(Ai.Month,2,1);break;case"MMM":t=ar(Ii.Months,Xi.Abbreviated);break;case"MMMM":t=ar(Ii.Months,Xi.Wide);break;case"MMMMM":t=ar(Ii.Months,Xi.Narrow);break;case"LLL":t=ar(Ii.Months,Xi.Abbreviated,Fo.Standalone);break;case"LLLL":t=ar(Ii.Months,Xi.Wide,Fo.Standalone);break;case"LLLLL":t=ar(Ii.Months,Xi.Narrow,Fo.Standalone);break;case"w":t=XP(1);break;case"ww":t=XP(2);break;case"W":t=XP(1,!0);break;case"d":t=io(Ai.Date,1);break;case"dd":t=io(Ai.Date,2);break;case"c":case"cc":t=io(Ai.Day,1);break;case"ccc":t=ar(Ii.Days,Xi.Abbreviated,Fo.Standalone);break;case"cccc":t=ar(Ii.Days,Xi.Wide,Fo.Standalone);break;case"ccccc":t=ar(Ii.Days,Xi.Narrow,Fo.Standalone);break;case"cccccc":t=ar(Ii.Days,Xi.Short,Fo.Standalone);break;case"E":case"EE":case"EEE":t=ar(Ii.Days,Xi.Abbreviated);break;case"EEEE":t=ar(Ii.Days,Xi.Wide);break;case"EEEEE":t=ar(Ii.Days,Xi.Narrow);break;case"EEEEEE":t=ar(Ii.Days,Xi.Short);break;case"a":case"aa":case"aaa":t=ar(Ii.DayPeriods,Xi.Abbreviated);break;case"aaaa":t=ar(Ii.DayPeriods,Xi.Wide);break;case"aaaaa":t=ar(Ii.DayPeriods,Xi.Narrow);break;case"b":case"bb":case"bbb":t=ar(Ii.DayPeriods,Xi.Abbreviated,Fo.Standalone,!0);break;case"bbbb":t=ar(Ii.DayPeriods,Xi.Wide,Fo.Standalone,!0);break;case"bbbbb":t=ar(Ii.DayPeriods,Xi.Narrow,Fo.Standalone,!0);break;case"B":case"BB":case"BBB":t=ar(Ii.DayPeriods,Xi.Abbreviated,Fo.Format,!0);break;case"BBBB":t=ar(Ii.DayPeriods,Xi.Wide,Fo.Format,!0);break;case"BBBBB":t=ar(Ii.DayPeriods,Xi.Narrow,Fo.Format,!0);break;case"h":t=io(Ai.Hours,1,-12);break;case"hh":t=io(Ai.Hours,2,-12);break;case"H":t=io(Ai.Hours,1);break;case"HH":t=io(Ai.Hours,2);break;case"m":t=io(Ai.Minutes,1);break;case"mm":t=io(Ai.Minutes,2);break;case"s":t=io(Ai.Seconds,1);break;case"ss":t=io(Ai.Seconds,2);break;case"S":t=io(Ai.FractionalSeconds,1);break;case"SS":t=io(Ai.FractionalSeconds,2);break;case"SSS":t=io(Ai.FractionalSeconds,3);break;case"Z":case"ZZ":case"ZZZ":t=cw(Cl.Short);break;case"ZZZZZ":t=cw(Cl.Extended);break;case"O":case"OO":case"OOO":case"z":case"zz":case"zzz":t=cw(Cl.ShortGMT);break;case"OOOO":case"ZZZZ":case"zzzz":t=cw(Cl.Long);break;default:return null}return QP[n]=t,t}(d);c+=u?u(r,e,l):"''"===d?"'":d.replace(/(^'|'$)/g,"").replace(/''/g,"'")}),c}function mw(n,t,e){let i=new Date(0);return i.setFullYear(n,t,e),i.setHours(0,0,0),i}function sd(n,t){let e=function(n){return Pa(n)[gr.LocaleId]}(n);if(Py[e]=Py[e]||{},Py[e][t])return Py[e][t];let i="";switch(t){case"shortDate":i=ow(n,pa.Short);break;case"mediumDate":i=ow(n,pa.Medium);break;case"longDate":i=ow(n,pa.Long);break;case"fullDate":i=ow(n,pa.Full);break;case"shortTime":i=aw(n,pa.Short);break;case"mediumTime":i=aw(n,pa.Medium);break;case"longTime":i=aw(n,pa.Long);break;case"fullTime":i=aw(n,pa.Full);break;case"short":let r=sd(n,"shortTime"),o=sd(n,"shortDate");i=lw(sw(n,pa.Short),[r,o]);break;case"medium":let a=sd(n,"mediumTime"),s=sd(n,"mediumDate");i=lw(sw(n,pa.Medium),[a,s]);break;case"long":let l=sd(n,"longTime"),c=sd(n,"longDate");i=lw(sw(n,pa.Long),[l,c]);break;case"full":let d=sd(n,"fullTime"),u=sd(n,"fullDate");i=lw(sw(n,pa.Full),[d,u])}return i&&(Py[e][t]=i),i}function lw(n,t){return t&&(n=n.replace(/\{([^}]+)}/g,function(e,i){return null!=t&&i in t?t[i]:e})),n}function xl(n,t,e="-",i,r){let o="";(n<0||r&&n<=0)&&(r?n=1-n:(n=-n,o=e));let a=String(n);for(;a.length<t;)a="0"+a;return i&&(a=a.slice(a.length-t)),o+a}function io(n,t,e=0,i=!1,r=!1){return function(o,a){let s=function(n,t){switch(n){case Ai.FullYear:return t.getFullYear();case Ai.Month:return t.getMonth();case Ai.Date:return t.getDate();case Ai.Hours:return t.getHours();case Ai.Minutes:return t.getMinutes();case Ai.Seconds:return t.getSeconds();case Ai.FractionalSeconds:return t.getMilliseconds();case Ai.Day:return t.getDay();default:throw new Error(`Unknown DateType value "${n}".`)}}(n,o);if((e>0||s>-e)&&(s+=e),n===Ai.Hours)0===s&&-12===e&&(s=12);else if(n===Ai.FractionalSeconds)return function(n,t){return xl(n,3).substring(0,t)}(s,t);let l=ld(a,Go.MinusSign);return xl(s,t,l,i,r)}}function ar(n,t,e=Fo.Format,i=!1){return function(r,o){return function(n,t,e,i,r,o){switch(e){case Ii.Months:return function(n,t,e){let i=Pa(n),o=ks([i[gr.MonthsFormat],i[gr.MonthsStandalone]],t);return ks(o,e)}(t,r,i)[n.getMonth()];case Ii.Days:return function(n,t,e){let i=Pa(n),o=ks([i[gr.DaysFormat],i[gr.DaysStandalone]],t);return ks(o,e)}(t,r,i)[n.getDay()];case Ii.DayPeriods:let a=n.getHours(),s=n.getMinutes();if(o){let c=function(n){let t=Pa(n);return mG(t),(t[gr.ExtraData][2]||[]).map(i=>"string"==typeof i?YP(i):[YP(i[0]),YP(i[1])])}(t),d=function(n,t,e){let i=Pa(n);mG(i);let o=ks([i[gr.ExtraData][0],i[gr.ExtraData][1]],t)||[];return ks(o,e)||[]}(t,r,i),u=c.findIndex(p=>{if(Array.isArray(p)){let[f,m]=p,y=a>=f.hours&&s>=f.minutes,M=a<m.hours||a===m.hours&&s<m.minutes;if(f.hours<m.hours){if(y&&M)return!0}else if(y||M)return!0}else if(p.hours===a&&p.minutes===s)return!0;return!1});if(-1!==u)return d[u]}return function(n,t,e){let i=Pa(n),o=ks([i[gr.DayPeriodsFormat],i[gr.DayPeriodsStandalone]],t);return ks(o,e)}(t,r,i)[a<12?0:1];case Ii.Eras:return function(n,t){return ks(Pa(n)[gr.Eras],t)}(t,i)[n.getFullYear()<=0?0:1];default:throw new Error(`unexpected translation type ${e}`)}}(r,o,n,t,e,i)}}function cw(n){return function(t,e,i){let r=-1*i,o=ld(e,Go.MinusSign),a=r>0?Math.floor(r/60):Math.ceil(r/60);switch(n){case Cl.Short:return(r>=0?"+":"")+xl(a,2,o)+xl(Math.abs(r%60),2,o);case Cl.ShortGMT:return"GMT"+(r>=0?"+":"")+xl(a,1,o);case Cl.Long:return"GMT"+(r>=0?"+":"")+xl(a,2,o)+":"+xl(Math.abs(r%60),2,o);case Cl.Extended:return 0===i?"Z":(r>=0?"+":"")+xl(a,2,o)+":"+xl(Math.abs(r%60),2,o);default:throw new Error(`Unknown zone width "${n}"`)}}}var jue=0,pw=4;function hG(n){return mw(n.getFullYear(),n.getMonth(),n.getDate()+(pw-n.getDay()))}function XP(n,t=!1){return function(e,i){let r;if(t){let o=new Date(e.getFullYear(),e.getMonth(),1).getDay()-1,a=e.getDate();r=1+Math.floor((a+o)/7)}else{let o=hG(e),a=function(n){let t=mw(n,jue,1).getDay();return mw(n,0,1+(t<=pw?pw:pw+7)-t)}(o.getFullYear()),s=o.getTime()-a.getTime();r=1+Math.round(s/6048e5)}return xl(r,n,ld(i,Go.MinusSign))}}function dw(n,t=!1){return function(e,i){return xl(hG(e).getFullYear(),n,ld(i,Go.MinusSign),t)}}var QP={};function gG(n,t){n=n.replace(/:/g,"");let e=Date.parse("Jan 01, 1970 00:00:00 "+n)/6e4;return isNaN(e)?t:e}function rG(n){return n instanceof Date&&!isNaN(n.valueOf())}var Zue=/^(\d+)?\.((\d+)(-(\d+))?)?$/,oG=22,hw=".",Oy="0",Kue=";",Jue=",",ZP="#";function oO(n,t,e){let i=function(n,t){return Pa(n)[gr.NumberFormats][t]}(t,uw.Decimal),r=function(n,t="-"){let e={minInt:1,minFrac:0,maxFrac:0,posPre:"",posSuf:"",negPre:"",negSuf:"",gSize:0,lgSize:0},i=n.split(Kue),r=i[0],o=i[1],a=-1!==r.indexOf(hw)?r.split(hw):[r.substring(0,r.lastIndexOf(Oy)+1),r.substring(r.lastIndexOf(Oy)+1)],s=a[0],l=a[1]||"";e.posPre=s.substring(0,s.indexOf(ZP));for(let d=0;d<l.length;d++){let u=l.charAt(d);u===Oy?e.minFrac=e.maxFrac=d+1:u===ZP?e.maxFrac=d+1:e.posSuf+=u}let c=s.split(Jue);if(e.gSize=c[1]?c[1].length:0,e.lgSize=c[2]||c[1]?(c[2]||c[1]).length:0,o){let d=r.length-e.posPre.length-e.posSuf.length,u=o.indexOf(ZP);e.negPre=o.substring(0,u).replace(/'/g,""),e.negSuf=o.slice(u+d).replace(/'/g,"")}else e.negPre=t+e.posPre,e.negSuf=e.posSuf;return e}(i,ld(t,Go.MinusSign));return function(n,t,e,i,r,o,a=!1){let s="",l=!1;if(isFinite(n)){let c=function(n){let i,r,o,a,s,t=Math.abs(n)+"",e=0;for((r=t.indexOf(hw))>-1&&(t=t.replace(hw,"")),(o=t.search(/e/i))>0?(r<0&&(r=o),r+=+t.slice(o+1),t=t.substring(0,o)):r<0&&(r=t.length),o=0;t.charAt(o)===Oy;o++);if(o===(s=t.length))i=[0],r=1;else{for(s--;t.charAt(s)===Oy;)s--;for(r-=o,i=[],a=0;o<=s;o++,a++)i[a]=Number(t.charAt(o))}return r>oG&&(i=i.splice(0,oG-1),e=r-1,r=1),{digits:i,exponent:e,integerLen:r}}(n);a&&(c=function(n){if(0===n.digits[0])return n;let t=n.digits.length-n.integerLen;return n.exponent?n.exponent+=2:(0===t?n.digits.push(0,0):1===t&&n.digits.push(0),n.integerLen+=2),n}(c));let d=t.minInt,u=t.minFrac,p=t.maxFrac;if(o){let x=o.match(Zue);if(null===x)throw new Error(`${o} is not a valid digit info`);let R=x[1],A=x[3],H=x[5];null!=R&&(d=KP(R)),null!=A&&(u=KP(A)),null!=H?p=KP(H):null!=A&&u>p&&(p=u)}!function(n,t,e){if(t>e)throw new Error(`The minimum number of digits after fraction (${t}) is higher than the maximum (${e}).`);let i=n.digits,r=i.length-n.integerLen,o=Math.min(Math.max(t,r),e),a=o+n.integerLen,s=i[a];if(a>0){i.splice(Math.max(n.integerLen,a));for(let u=a;u<i.length;u++)i[u]=0}else{r=Math.max(0,r),n.integerLen=1,i.length=Math.max(1,a=o+1),i[0]=0;for(let u=1;u<a;u++)i[u]=0}if(s>=5)if(a-1<0){for(let u=0;u>a;u--)i.unshift(0),n.integerLen++;i.unshift(1),n.integerLen++}else i[a-1]++;for(;r<Math.max(0,o);r++)i.push(0);let l=0!==o,c=t+n.integerLen,d=i.reduceRight(function(u,p,f,m){return m[f]=(p+=u)<10?p:p-10,l&&(0===m[f]&&f>=c?m.pop():l=!1),p>=10?1:0},0);d&&(i.unshift(d),n.integerLen++)}(c,u,p);let f=c.digits,m=c.integerLen,y=c.exponent,M=[];for(l=f.every(x=>!x);m<d;m++)f.unshift(0);for(;m<0;m++)f.unshift(0);m>0?M=f.splice(m,f.length):(M=f,f=[0]);let v=[];for(f.length>=t.lgSize&&v.unshift(f.splice(-t.lgSize,f.length).join(""));f.length>t.gSize;)v.unshift(f.splice(-t.gSize,f.length).join(""));f.length&&v.unshift(f.join("")),s=v.join(ld(e,i)),M.length&&(s+=ld(e,r)+M.join("")),y&&(s+=ld(e,Go.Exponential)+"+"+y)}else s=ld(e,Go.Infinity);return s=n<0&&!l?t.negPre+s+t.negSuf:t.posPre+s+t.posSuf,s}(n,r,t,Go.Group,Go.Decimal,e)}function KP(n){let t=parseInt(n);if(isNaN(t))throw new Error("Invalid integer literal when parsing "+n);return t}function _w(n,t){t=encodeURIComponent(t);for(let e of n.split(";")){let i=e.indexOf("="),[r,o]=-1==i?[e,""]:[e.slice(0,i),e.slice(i+1)];if(r.trim()===t)return decodeURIComponent(o)}return null}var JP=/\s+/,aG=[],bn=(()=>{class n{constructor(e,i,r,o){this._iterableDiffers=e,this._keyValueDiffers=i,this._ngEl=r,this._renderer=o,this.initialClasses=aG,this.stateMap=new Map}set klass(e){this.initialClasses=null!=e?e.trim().split(JP):aG}set ngClass(e){this.rawClass="string"==typeof e?e.trim().split(JP):e}ngDoCheck(){for(let i of this.initialClasses)this._updateState(i,!0);let e=this.rawClass;if(Array.isArray(e)||e instanceof Set)for(let i of e)this._updateState(i,!0);else if(null!=e)for(let i of Object.keys(e))this._updateState(i,Boolean(e[i]));this._applyStateDiff()}_updateState(e,i){let r=this.stateMap.get(e);void 0!==r?(r.enabled!==i&&(r.changed=!0,r.enabled=i),r.touched=!0):this.stateMap.set(e,{enabled:i,changed:!0,touched:!0})}_applyStateDiff(){for(let e of this.stateMap){let i=e[0],r=e[1];r.changed?(this._toggleClass(i,r.enabled),r.changed=!1):r.touched||(r.enabled&&this._toggleClass(i,!1),this.stateMap.delete(i)),r.touched=!1}}_toggleClass(e,i){(e=e.trim()).length>0&&e.split(JP).forEach(r=>{i?this._renderer.addClass(this._ngEl.nativeElement,r):this._renderer.removeClass(this._ngEl.nativeElement,r)})}}return n.\u0275fac=function(e){return new(e||n)(C(vl),C(ky),C(be),C(dc))},n.\u0275dir=xe({type:n,selectors:[["","ngClass",""]],inputs:{klass:["class","klass"],ngClass:"ngClass"},standalone:!0}),n})(),dn=(()=>{class n{set ngForOf(e){this._ngForOf=e,this._ngForOfDirty=!0}set ngForTrackBy(e){this._trackByFn=e}get ngForTrackBy(){return this._trackByFn}constructor(e,i,r){this._viewContainer=e,this._template=i,this._differs=r,this._ngForOf=null,this._ngForOfDirty=!0,this._differ=null}set ngForTemplate(e){e&&(this._template=e)}ngDoCheck(){if(this._ngForOfDirty){this._ngForOfDirty=!1;let e=this._ngForOf;!this._differ&&e&&(this._differ=this._differs.find(e).create(this.ngForTrackBy))}if(this._differ){let e=this._differ.diff(this._ngForOf);e&&this._applyChanges(e)}}_applyChanges(e){let i=this._viewContainer;e.forEachOperation((r,o,a)=>{if(null==r.previousIndex)i.createEmbeddedView(this._template,new class{constructor(t,e,i,r){this.$implicit=t,this.ngForOf=e,this.index=i,this.count=r}get first(){return 0===this.index}get last(){return this.index===this.count-1}get even(){return this.index%2==0}get odd(){return!this.even}}(r.item,this._ngForOf,-1,-1),null===a?void 0:a);else if(null==a)i.remove(null===o?void 0:o);else if(null!==o){let s=i.get(o);i.move(s,a),lG(s,r)}});for(let r=0,o=i.length;r<o;r++){let s=i.get(r).context;s.index=r,s.count=o,s.ngForOf=this._ngForOf}e.forEachIdentityChange(r=>{lG(i.get(r.currentIndex),r)})}static ngTemplateContextGuard(e,i){return!0}}return n.\u0275fac=function(e){return new(e||n)(C(Zn),C(Si),C(vl))},n.\u0275dir=xe({type:n,selectors:[["","ngFor","","ngForOf",""]],inputs:{ngForOf:"ngForOf",ngForTrackBy:"ngForTrackBy",ngForTemplate:"ngForTemplate"},standalone:!0}),n})();function lG(n,t){n.context.$implicit=t.item}var Fe=(()=>{class n{constructor(e,i){this._viewContainer=e,this._context=new tO,this._thenTemplateRef=null,this._elseTemplateRef=null,this._thenViewRef=null,this._elseViewRef=null,this._thenTemplateRef=i}set ngIf(e){this._context.$implicit=this._context.ngIf=e,this._updateView()}set ngIfThen(e){cG("ngIfThen",e),this._thenTemplateRef=e,this._thenViewRef=null,this._updateView()}set ngIfElse(e){cG("ngIfElse",e),this._elseTemplateRef=e,this._elseViewRef=null,this._updateView()}_updateView(){this._context.$implicit?this._thenViewRef||(this._viewContainer.clear(),this._elseViewRef=null,this._thenTemplateRef&&(this._thenViewRef=this._viewContainer.createEmbeddedView(this._thenTemplateRef,this._context))):this._elseViewRef||(this._viewContainer.clear(),this._thenViewRef=null,this._elseTemplateRef&&(this._elseViewRef=this._viewContainer.createEmbeddedView(this._elseTemplateRef,this._context)))}static ngTemplateContextGuard(e,i){return!0}}return n.\u0275fac=function(e){return new(e||n)(C(Zn),C(Si))},n.\u0275dir=xe({type:n,selectors:[["","ngIf",""]],inputs:{ngIf:"ngIf",ngIfThen:"ngIfThen",ngIfElse:"ngIfElse"},standalone:!0}),n})(),tO=class{constructor(){this.$implicit=null,this.ngIf=null}};function cG(n,t){if(t&&!t.createEmbeddedView)throw new Error(`${n} must be a TemplateRef, but received '${ho(t)}'.`)}var gw=class{constructor(t,e){this._viewContainerRef=t,this._templateRef=e,this._created=!1}create(){this._created=!0,this._viewContainerRef.createEmbeddedView(this._templateRef)}destroy(){this._created=!1,this._viewContainerRef.clear()}enforceState(t){t&&!this._created?this.create():!t&&this._created&&this.destroy()}},$i=(()=>{class n{constructor(){this._defaultViews=[],this._defaultUsed=!1,this._caseCount=0,this._lastCaseCheckIndex=0,this._lastCasesMatched=!1}set ngSwitch(e){this._ngSwitch=e,0===this._caseCount&&this._updateDefaultCases(!0)}_addCase(){return this._caseCount++}_addDefault(e){this._defaultViews.push(e)}_matchCase(e){let i=e==this._ngSwitch;return this._lastCasesMatched=this._lastCasesMatched||i,this._lastCaseCheckIndex++,this._lastCaseCheckIndex===this._caseCount&&(this._updateDefaultCases(!this._lastCasesMatched),this._lastCaseCheckIndex=0,this._lastCasesMatched=!1),i}_updateDefaultCases(e){if(this._defaultViews.length>0&&e!==this._defaultUsed){this._defaultUsed=e;for(let i of this._defaultViews)i.enforceState(e)}}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275dir=xe({type:n,selectors:[["","ngSwitch",""]],inputs:{ngSwitch:"ngSwitch"},standalone:!0}),n})(),sr=(()=>{class n{constructor(e,i,r){this.ngSwitch=r,r._addCase(),this._view=new gw(e,i)}ngDoCheck(){this._view.enforceState(this.ngSwitch._matchCase(this.ngSwitchCase))}}return n.\u0275fac=function(e){return new(e||n)(C(Zn),C(Si),C($i,9))},n.\u0275dir=xe({type:n,selectors:[["","ngSwitchCase",""]],inputs:{ngSwitchCase:"ngSwitchCase"},standalone:!0}),n})(),fu=(()=>{class n{constructor(e,i,r){r._addDefault(new gw(e,i))}}return n.\u0275fac=function(e){return new(e||n)(C(Zn),C(Si),C($i,9))},n.\u0275dir=xe({type:n,selectors:[["","ngSwitchDefault",""]],standalone:!0}),n})(),mu=(()=>{class n{constructor(e,i,r){this._ngEl=e,this._differs=i,this._renderer=r,this._ngStyle=null,this._differ=null}set ngStyle(e){this._ngStyle=e,!this._differ&&e&&(this._differ=this._differs.find(e).create())}ngDoCheck(){if(this._differ){let e=this._differ.diff(this._ngStyle);e&&this._applyChanges(e)}}_setStyle(e,i){let[r,o]=e.split("."),a=-1===r.indexOf("-")?void 0:Es.DashCase;null!=i?this._renderer.setStyle(this._ngEl.nativeElement,r,o?`${i}${o}`:i,a):this._renderer.removeStyle(this._ngEl.nativeElement,r,a)}_applyChanges(e){e.forEachRemovedItem(i=>this._setStyle(i.key,null)),e.forEachAddedItem(i=>this._setStyle(i.key,i.currentValue)),e.forEachChangedItem(i=>this._setStyle(i.key,i.currentValue))}}return n.\u0275fac=function(e){return new(e||n)(C(be),C(ky),C(dc))},n.\u0275dir=xe({type:n,selectors:[["","ngStyle",""]],inputs:{ngStyle:"ngStyle"},standalone:!0}),n})(),Mo=(()=>{class n{constructor(e){this._viewContainerRef=e,this._viewRef=null,this.ngTemplateOutletContext=null,this.ngTemplateOutlet=null,this.ngTemplateOutletInjector=null}ngOnChanges(e){if(e.ngTemplateOutlet||e.ngTemplateOutletInjector){let i=this._viewContainerRef;if(this._viewRef&&i.remove(i.indexOf(this._viewRef)),this.ngTemplateOutlet){let{ngTemplateOutlet:r,ngTemplateOutletContext:o,ngTemplateOutletInjector:a}=this;this._viewRef=i.createEmbeddedView(r,o,a?{injector:a}:void 0)}else this._viewRef=null}else this._viewRef&&e.ngTemplateOutletContext&&this.ngTemplateOutletContext&&(this._viewRef.context=this.ngTemplateOutletContext)}}return n.\u0275fac=function(e){return new(e||n)(C(Zn))},n.\u0275dir=xe({type:n,selectors:[["","ngTemplateOutlet",""]],inputs:{ngTemplateOutletContext:"ngTemplateOutletContext",ngTemplateOutlet:"ngTemplateOutlet",ngTemplateOutletInjector:"ngTemplateOutletInjector"},standalone:!0,features:[Gt]}),n})();function yw(n,t){return new bt(2100,!1)}var ope=new class{createSubscription(t,e){return t.then(e,i=>{throw i})}dispose(t){}},ape=new class{createSubscription(t,e){return t.subscribe({next:e,error:i=>{throw i}})}dispose(t){t.unsubscribe()}},lt=(()=>{class n{constructor(e){this._latestValue=null,this._subscription=null,this._obj=null,this._strategy=null,this._ref=e}ngOnDestroy(){this._subscription&&this._dispose(),this._ref=null}transform(e){return this._obj?e!==this._obj?(this._dispose(),this.transform(e)):this._latestValue:(e&&this._subscribe(e),this._latestValue)}_subscribe(e){this._obj=e,this._strategy=this._selectStrategy(e),this._subscription=this._strategy.createSubscription(e,i=>this._updateLatestValue(e,i))}_selectStrategy(e){if(Th(e))return ope;if(PP(e))return ape;throw yw()}_dispose(){this._strategy.dispose(this._subscription),this._latestValue=null,this._subscription=null,this._obj=null}_updateLatestValue(e,i){e===this._obj&&(this._latestValue=i,this._ref.markForCheck())}}return n.\u0275fac=function(e){return new(e||n)(C(Ft,16))},n.\u0275pipe=ch({name:"async",type:n,pure:!1,standalone:!0}),n})(),lpe=new ie("DATE_PIPE_DEFAULT_TIMEZONE"),cpe=new ie("DATE_PIPE_DEFAULT_OPTIONS"),Ih=(()=>{class n{constructor(e,i,r){this.locale=e,this.defaultTimezone=i,this.defaultOptions=r}transform(e,i,r,o){if(null==e||""===e||e!=e)return null;try{return Vue(e,i??this.defaultOptions?.dateFormat??"mediumDate",o||this.locale,r??this.defaultOptions?.timezone??this.defaultTimezone??void 0)}catch(a){throw yw()}}}return n.\u0275fac=function(e){return new(e||n)(C(ad,16),C(lpe,24),C(cpe,24))},n.\u0275pipe=ch({name:"date",type:n,pure:!0,standalone:!0}),n})(),Ps=(()=>{class n{constructor(e){this._locale=e}transform(e,i,r){if(!function(n){return!(null==n||""===n||n!=n)}(e))return null;r=r||this._locale;try{let o=function(n){if("string"==typeof n&&!isNaN(Number(n)-parseFloat(n)))return Number(n);if("number"!=typeof n)throw new Error(`${n} is not a number`);return n}(e);return oO(o,r,i)}catch(o){throw yw()}}}return n.\u0275fac=function(e){return new(e||n)(C(ad,16))},n.\u0275pipe=ch({name:"number",type:n,pure:!0,standalone:!0}),n})(),_G=(()=>{class n{transform(e,i,r){if(null==e)return null;if(!this.supports(e))throw yw();return e.slice(i,r)}supports(e){return"string"==typeof e||Array.isArray(e)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275pipe=ch({name:"slice",type:n,pure:!1,standalone:!0}),n})(),Te=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({}),n})(),aO="browser";function bw(n){return n===aO}new hl("15.2.9");var tf=class{};function hpe(n){return n.startsWith("/")?n.slice(1):n}var gpe=n=>n.src,_pe=new ie("ImageLoader",{providedIn:"root",factory:()=>gpe});function vw(n,t){return function(i){return function(n){if("string"!=typeof n||""===n.trim())return!1;try{return new URL(n),!0}catch{return!1}}(i)||function(n,t){throw new bt(2959,!1)}(),i=function(n){return n.endsWith("/")?n.slice(0,-1):n}(i),[{provide:_pe,useValue:a=>(function(n){return/^https?:\/\//.test(n)}(a.src)&&function(n,t){throw new bt(2959,!1)}(),n(i,{...a,src:hpe(a.src)}))}]}}vw(function(n,t){let e="format=auto";return t.width&&(e+=`,width=${t.width}`),`${n}/cdn-cgi/image/${e}/${t.src}`}),vw(function(n,t){let e="f_auto,q_auto";return t.width&&(e+=`,w_${t.width}`),`${n}/image/upload/${e}/${t.src}`}),vw(function(n,t){let r,{src:e,width:i}=t;return r=i?[n,`tr:w-${i}`,e]:[n,e],r.join("/")}),vw(function(n,t){let e=new URL(`${n}/${t.src}`);return e.searchParams.set("auto","format"),t.width&&e.searchParams.set("w",t.width.toString()),e.href}),new ie("PRECONNECT_CHECK_BLOCKLIST"),new ie("NG_OPTIMIZED_PRELOADED_IMAGES",{providedIn:"root",factory:()=>new Set});var xw,wpe={breakpoints:[16,32,48,64,96,128,256,384,640,750,828,1080,1200,1920,2048,3840]},lO=(new ie("ImageConfig",{providedIn:"root",factory:()=>wpe}),class extends fw{constructor(){super(...arguments),this.supportsDOMEvents=!0}}),Vy=class extends lO{static makeCurrent(){var n;n=new Vy,$P||($P=n)}onAndCancel(t,e,i){return t.addEventListener(e,i,!1),()=>{t.removeEventListener(e,i,!1)}}dispatchEvent(t,e){t.dispatchEvent(e)}remove(t){t.parentNode&&t.parentNode.removeChild(t)}createElement(t,e){return(e=e||this.getDefaultDocument()).createElement(t)}createHtmlDocument(){return document.implementation.createHTMLDocument("fakeTitle")}getDefaultDocument(){return document}isElementNode(t){return t.nodeType===Node.ELEMENT_NODE}isShadowRoot(t){return t instanceof DocumentFragment}getGlobalEventTarget(t,e){return"window"===e?window:"document"===e?t:"body"===e?t.body:null}getBaseHref(t){let e=(Ly=Ly||document.querySelector("base"))?Ly.getAttribute("href"):null;return null==e?null:function(n){(xw=xw||document.createElement("a")).setAttribute("href",n);let t=xw.pathname;return"/"===t.charAt(0)?t:`/${t}`}(e)}resetBaseElement(){Ly=null}getUserAgent(){return window.navigator.userAgent}getCookie(t){return _w(document.cookie,t)}},Ly=null,MG=new ie("TRANSITION_ID"),Ipe=[{provide:VP,useFactory:function(n,t,e){return()=>{e.get($M).donePromise.then(()=>{let i=Ml(),r=t.querySelectorAll(`style[ng-transition="${n}"]`);for(let o=0;o<r.length;o++)i.remove(r[o])})}},deps:[MG,kt,bi],multi:!0}],Ape=(()=>{class n{build(){return new XMLHttpRequest}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})(),Cw=new ie("EventManagerPlugins"),Mw=(()=>{class n{constructor(e,i){this._zone=i,this._eventNameToPlugin=new Map,e.forEach(r=>{r.manager=this}),this._plugins=e.slice().reverse()}addEventListener(e,i,r){return this._findPluginFor(i).addEventListener(e,i,r)}addGlobalEventListener(e,i,r){return this._findPluginFor(i).addGlobalEventListener(e,i,r)}getZone(){return this._zone}_findPluginFor(e){let i=this._eventNameToPlugin.get(e);if(i)return i;let r=this._plugins;for(let o=0;o<r.length;o++){let a=r[o];if(a.supports(e))return this._eventNameToPlugin.set(e,a),a}throw new Error(`No event manager plugin found for event ${e}`)}}return n.\u0275fac=function(e){return new(e||n)(O(Cw),O(at))},n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})(),ww=class{constructor(t){this._doc=t}addGlobalEventListener(t,e,i){let r=Ml().getGlobalEventTarget(this._doc,t);if(!r)throw new Error(`Unsupported event target ${r} for event ${e}`);return this.addEventListener(r,e,i)}},wG=(()=>{class n{constructor(){this.usageCount=new Map}addStyles(e){for(let i of e)1===this.changeUsageCount(i,1)&&this.onStyleAdded(i)}removeStyles(e){for(let i of e)0===this.changeUsageCount(i,-1)&&this.onStyleRemoved(i)}onStyleRemoved(e){}onStyleAdded(e){}getAllStyles(){return this.usageCount.keys()}changeUsageCount(e,i){let r=this.usageCount,o=r.get(e)??0;return o+=i,o>0?r.set(e,o):r.delete(e),o}ngOnDestroy(){for(let e of this.getAllStyles())this.onStyleRemoved(e);this.usageCount.clear()}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})(),Ny=(()=>{class n extends wG{constructor(e){super(),this.doc=e,this.styleRef=new Map,this.hostNodes=new Set,this.resetHostNodes()}onStyleAdded(e){for(let i of this.hostNodes)this.addStyleToHost(i,e)}onStyleRemoved(e){let i=this.styleRef;i.get(e)?.forEach(o=>o.remove()),i.delete(e)}ngOnDestroy(){super.ngOnDestroy(),this.styleRef.clear(),this.resetHostNodes()}addHost(e){this.hostNodes.add(e);for(let i of this.getAllStyles())this.addStyleToHost(e,i)}removeHost(e){this.hostNodes.delete(e)}addStyleToHost(e,i){let r=this.doc.createElement("style");r.textContent=i,e.appendChild(r);let o=this.styleRef.get(i);o?o.push(r):this.styleRef.set(i,[r])}resetHostNodes(){let e=this.hostNodes;e.clear(),e.add(this.doc.head)}}return n.\u0275fac=function(e){return new(e||n)(O(kt))},n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})(),sO={svg:"http://www.w3.org/2000/svg",xhtml:"http://www.w3.org/1999/xhtml",xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/",math:"http://www.w3.org/1998/MathML/"},uO=/%COMP%/g,EG=new ie("RemoveStylesOnCompDestory",{providedIn:"root",factory:()=>!1});function TG(n,t){return t.flat(100).map(e=>e.replace(uO,n))}function bG(n){return t=>{if("__ngUnwrap__"===t)return n;!1===n(t)&&(t.preventDefault(),t.returnValue=!1)}}var By=(()=>{class n{constructor(e,i,r,o){this.eventManager=e,this.sharedStylesHost=i,this.appId=r,this.removeStylesOnCompDestory=o,this.rendererByCompId=new Map,this.defaultRenderer=new Hy(e)}createRenderer(e,i){if(!e||!i)return this.defaultRenderer;let r=this.getOrCreateRenderer(e,i);return r instanceof Sw?r.applyToHost(e):r instanceof zy&&r.applyStyles(),r}getOrCreateRenderer(e,i){let r=this.rendererByCompId,o=r.get(i.id);if(!o){let a=this.eventManager,s=this.sharedStylesHost,l=this.removeStylesOnCompDestory;switch(i.encapsulation){case es.Emulated:o=new Sw(a,s,i,this.appId,l);break;case es.ShadowDom:return new dO(a,s,e,i);default:o=new zy(a,s,i,l)}o.onDestroy=()=>r.delete(i.id),r.set(i.id,o)}return o}ngOnDestroy(){this.rendererByCompId.clear()}begin(){}end(){}}return n.\u0275fac=function(e){return new(e||n)(O(Mw),O(Ny),O($p),O(EG))},n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})(),Hy=class{constructor(t){this.eventManager=t,this.data=Object.create(null),this.destroyNode=null}destroy(){}createElement(t,e){return e?document.createElementNS(sO[e]||e,t):document.createElement(t)}createComment(t){return document.createComment(t)}createText(t){return document.createTextNode(t)}appendChild(t,e){(xG(t)?t.content:t).appendChild(e)}insertBefore(t,e,i){t&&(xG(t)?t.content:t).insertBefore(e,i)}removeChild(t,e){t&&t.removeChild(e)}selectRootElement(t,e){let i="string"==typeof t?document.querySelector(t):t;if(!i)throw new Error(`The selector "${t}" did not match any elements`);return e||(i.textContent=""),i}parentNode(t){return t.parentNode}nextSibling(t){return t.nextSibling}setAttribute(t,e,i,r){if(r){e=r+":"+e;let o=sO[r];o?t.setAttributeNS(o,e,i):t.setAttribute(e,i)}else t.setAttribute(e,i)}removeAttribute(t,e,i){if(i){let r=sO[i];r?t.removeAttributeNS(r,e):t.removeAttribute(`${i}:${e}`)}else t.removeAttribute(e)}addClass(t,e){t.classList.add(e)}removeClass(t,e){t.classList.remove(e)}setStyle(t,e,i,r){r&(Es.DashCase|Es.Important)?t.style.setProperty(e,i,r&Es.Important?"important":""):t.style[e]=i}removeStyle(t,e,i){i&Es.DashCase?t.style.removeProperty(e):t.style[e]=""}setProperty(t,e,i){t[e]=i}setValue(t,e){t.nodeValue=e}listen(t,e,i){return"string"==typeof t?this.eventManager.addGlobalEventListener(t,e,bG(i)):this.eventManager.addEventListener(t,e,bG(i))}};function xG(n){return"TEMPLATE"===n.tagName&&void 0!==n.content}"@".charCodeAt(0);var dO=class extends Hy{constructor(t,e,i,r){super(t),this.sharedStylesHost=e,this.hostEl=i,this.shadowRoot=i.attachShadow({mode:"open"}),this.sharedStylesHost.addHost(this.shadowRoot);let o=TG(r.id,r.styles);for(let a of o){let s=document.createElement("style");s.textContent=a,this.shadowRoot.appendChild(s)}}nodeOrShadowRoot(t){return t===this.hostEl?this.shadowRoot:t}appendChild(t,e){return super.appendChild(this.nodeOrShadowRoot(t),e)}insertBefore(t,e,i){return super.insertBefore(this.nodeOrShadowRoot(t),e,i)}removeChild(t,e){return super.removeChild(this.nodeOrShadowRoot(t),e)}parentNode(t){return this.nodeOrShadowRoot(super.parentNode(this.nodeOrShadowRoot(t)))}destroy(){this.sharedStylesHost.removeHost(this.shadowRoot)}},zy=class extends Hy{constructor(t,e,i,r,o=i.id){super(t),this.sharedStylesHost=e,this.removeStylesOnCompDestory=r,this.rendererUsageCount=0,this.styles=TG(o,i.styles)}applyStyles(){this.sharedStylesHost.addStyles(this.styles),this.rendererUsageCount++}destroy(){!this.removeStylesOnCompDestory||(this.sharedStylesHost.removeStyles(this.styles),this.rendererUsageCount--,0===this.rendererUsageCount&&this.onDestroy?.())}},Sw=class extends zy{constructor(t,e,i,r,o){let a=r+"-"+i.id;super(t,e,i,o,a),this.contentAttr="_ngcontent-%COMP%".replace(uO,a),this.hostAttr=function(n){return"_nghost-%COMP%".replace(uO,n)}(a)}applyToHost(t){this.applyStyles(),this.setAttribute(t,this.hostAttr,"")}createElement(t,e){let i=super.createElement(t,e);return super.setAttribute(i,this.contentAttr,""),i}},Npe=(()=>{class n extends ww{constructor(e){super(e)}supports(e){return!0}addEventListener(e,i,r){return e.addEventListener(i,r,!1),()=>this.removeEventListener(e,i,r)}removeEventListener(e,i,r){return e.removeEventListener(i,r)}}return n.\u0275fac=function(e){return new(e||n)(O(kt))},n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})(),CG=["alt","control","meta","shift"],Bpe={"\b":"Backspace","\t":"Tab","\x7f":"Delete","\x1b":"Escape",Del:"Delete",Esc:"Escape",Left:"ArrowLeft",Right:"ArrowRight",Up:"ArrowUp",Down:"ArrowDown",Menu:"ContextMenu",Scroll:"ScrollLock",Win:"OS"},Vpe={alt:n=>n.altKey,control:n=>n.ctrlKey,meta:n=>n.metaKey,shift:n=>n.shiftKey},Hpe=(()=>{class n extends ww{constructor(e){super(e)}supports(e){return null!=n.parseEventName(e)}addEventListener(e,i,r){let o=n.parseEventName(i),a=n.eventCallback(o.fullKey,r,this.manager.getZone());return this.manager.getZone().runOutsideAngular(()=>Ml().onAndCancel(e,o.domEventName,a))}static parseEventName(e){let i=e.toLowerCase().split("."),r=i.shift();if(0===i.length||"keydown"!==r&&"keyup"!==r)return null;let o=n._normalizeKey(i.pop()),a="",s=i.indexOf("code");if(s>-1&&(i.splice(s,1),a="code."),CG.forEach(c=>{let d=i.indexOf(c);d>-1&&(i.splice(d,1),a+=c+".")}),a+=o,0!=i.length||0===o.length)return null;let l={};return l.domEventName=r,l.fullKey=a,l}static matchEventFullKeyCode(e,i){let r=Bpe[e.key]||e.key,o="";return i.indexOf("code.")>-1&&(r=e.code,o="code."),!(null==r||!r)&&(r=r.toLowerCase()," "===r?r="space":"."===r&&(r="dot"),CG.forEach(a=>{a!==r&&(0,Vpe[a])(e)&&(o+=a+".")}),o+=r,o===i)}static eventCallback(e,i,r){return o=>{n.matchEventFullKeyCode(o,e)&&r.runGuarded(()=>i(o))}}static _normalizeKey(e){return"esc"===e?"escape":e}}return n.\u0275fac=function(e){return new(e||n)(O(kt))},n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})(),Gpe=[{provide:hc,useValue:aO},{provide:HP,useValue:function(){Vy.makeCurrent()},multi:!0},{provide:kt,useFactory:function(){return n=document,$R=n,document;var n},deps:[]}],fO=GP(Kj,"browser",Gpe),DG=new ie(""),Wpe=[{provide:Ay,useClass:class{addToWindow(t){Wr.getAngularTestability=(i,r=!0)=>{let o=t.findTestabilityInTree(i,r);if(null==o)throw new Error("Could not find testability for element.");return o},Wr.getAllAngularTestabilities=()=>t.getAllTestabilities(),Wr.getAllAngularRootElements=()=>t.getAllRootElements(),Wr.frameworkStabilizers||(Wr.frameworkStabilizers=[]),Wr.frameworkStabilizers.push(i=>{let r=Wr.getAllAngularTestabilities(),o=r.length,a=!1,s=function(l){a=a||l,o--,0==o&&i(a)};r.forEach(function(l){l.whenStable(s)})})}findTestabilityInTree(t,e,i){return null==e?null:t.getTestability(e)??(i?Ml().isShadowRoot(e)?this.findTestabilityInTree(t,e.host,!0):this.findTestabilityInTree(t,e.parentElement,!0):null)}},deps:[]},{provide:UP,useClass:ew,deps:[at,tw,Ay]},{provide:ew,useClass:ew,deps:[at,tw,Ay]}],qpe=[{provide:zM,useValue:"root"},{provide:ca,useFactory:function(){return new ca},deps:[]},{provide:Cw,useClass:Npe,multi:!0,deps:[kt,at,hc]},{provide:Cw,useClass:Hpe,multi:!0,deps:[kt]},{provide:By,useClass:By,deps:[Mw,Ny,$p,EG]},{provide:cc,useExisting:By},{provide:wG,useExisting:Ny},{provide:Ny,useClass:Ny,deps:[kt]},{provide:Mw,useClass:Mw,deps:[Cw,at]},{provide:tf,useClass:Ape,deps:[]},[]],Ew=(()=>{class n{constructor(e){}static withServerTransition(e){return{ngModule:n,providers:[{provide:$p,useValue:e.appId},{provide:MG,useExisting:$p},Ipe]}}}return n.\u0275fac=function(e){return new(e||n)(O(DG,12))},n.\u0275mod=V({type:n}),n.\u0275inj=B({providers:[...qpe,...Wpe],imports:[Te,Jj]}),n})(),nf=(new ie("HammerGestureConfig"),new ie("HammerLoader"),(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=pe({token:n,factory:function(e){let i=null;return i=e?new(e||n):O(IG),i},providedIn:"root"}),n})()),IG=(()=>{class n extends nf{constructor(e){super(),this._doc=e}sanitize(e,i){if(null==i)return null;switch(e){case qr.NONE:return i;case qr.HTML:return gl(i,"HTML")?Ra(i):yP(this._doc,String(i)).toString();case qr.STYLE:return gl(i,"Style")?Ra(i):i;case qr.SCRIPT:if(gl(i,"Script"))return Ra(i);throw new Error("unsafe value used in a script context");case qr.URL:return gl(i,"URL")?Ra(i):vy(String(i));case qr.RESOURCE_URL:if(gl(i,"ResourceURL"))return Ra(i);throw new Error(`unsafe value used in a resource URL context (see ${fy})`);default:throw new Error(`Unexpected SecurityContext ${e} (see ${fy})`)}}bypassSecurityTrustHtml(e){return function(n){return new ek(n)}(e)}bypassSecurityTrustStyle(e){return function(n){return new tk(n)}(e)}bypassSecurityTrustScript(e){return function(n){return new nk(n)}(e)}bypassSecurityTrustUrl(e){return function(n){return new ik(n)}(e)}bypassSecurityTrustResourceUrl(e){return function(n){return new rk(n)}(e)}}return n.\u0275fac=function(e){return new(e||n)(O(kt))},n.\u0275prov=pe({token:n,factory:function(e){let i=null;return i=e?new e:function(n){return new IG(n.get(kt))}(O(bi)),i},providedIn:"root"}),n})(),Uy=(new hl("15.2.9"),b4(RG(),1),class{}),Tw=class{},_c="*";function ji(n,t){return{type:7,name:n,definitions:t,options:{}}}function Kn(n,t=null){return{type:4,styles:t,timings:n}}function Gy(n,t=null){return{type:3,steps:n,options:t}}function Dw(n,t=null){return{type:2,steps:n,options:t}}function Bt(n){return{type:6,styles:n,offset:null}}function Jn(n,t,e){return{type:0,name:n,styles:t,options:e}}function rf(n){return{type:5,steps:n}}function Wn(n,t,e=null){return{type:1,expr:n,animation:t,options:e}}function cd(n=null){return{type:9,options:n}}function dd(n,t,e=null){return{type:11,selector:n,animation:t,options:e}}function kG(n){Promise.resolve().then(n)}var gu=class{constructor(t=0,e=0){this._onDoneFns=[],this._onStartFns=[],this._onDestroyFns=[],this._originalOnDoneFns=[],this._originalOnStartFns=[],this._started=!1,this._destroyed=!1,this._finished=!1,this._position=0,this.parentPlayer=null,this.totalTime=t+e}_onFinish(){this._finished||(this._finished=!0,this._onDoneFns.forEach(t=>t()),this._onDoneFns=[])}onStart(t){this._originalOnStartFns.push(t),this._onStartFns.push(t)}onDone(t){this._originalOnDoneFns.push(t),this._onDoneFns.push(t)}onDestroy(t){this._onDestroyFns.push(t)}hasStarted(){return this._started}init(){}play(){this.hasStarted()||(this._onStart(),this.triggerMicrotask()),this._started=!0}triggerMicrotask(){kG(()=>this._onFinish())}_onStart(){this._onStartFns.forEach(t=>t()),this._onStartFns=[]}pause(){}restart(){}finish(){this._onFinish()}destroy(){this._destroyed||(this._destroyed=!0,this.hasStarted()||this._onStart(),this.finish(),this._onDestroyFns.forEach(t=>t()),this._onDestroyFns=[])}reset(){this._started=!1,this._finished=!1,this._onStartFns=this._originalOnStartFns,this._onDoneFns=this._originalOnDoneFns}setPosition(t){this._position=this.totalTime?t*this.totalTime:1}getPosition(){return this.totalTime?this._position/this.totalTime:1}triggerCallback(t){let e="start"==t?this._onStartFns:this._onDoneFns;e.forEach(i=>i()),e.length=0}},jy=class{constructor(t){this._onDoneFns=[],this._onStartFns=[],this._finished=!1,this._started=!1,this._destroyed=!1,this._onDestroyFns=[],this.parentPlayer=null,this.totalTime=0,this.players=t;let e=0,i=0,r=0,o=this.players.length;0==o?kG(()=>this._onFinish()):this.players.forEach(a=>{a.onDone(()=>{++e==o&&this._onFinish()}),a.onDestroy(()=>{++i==o&&this._onDestroy()}),a.onStart(()=>{++r==o&&this._onStart()})}),this.totalTime=this.players.reduce((a,s)=>Math.max(a,s.totalTime),0)}_onFinish(){this._finished||(this._finished=!0,this._onDoneFns.forEach(t=>t()),this._onDoneFns=[])}init(){this.players.forEach(t=>t.init())}onStart(t){this._onStartFns.push(t)}_onStart(){this.hasStarted()||(this._started=!0,this._onStartFns.forEach(t=>t()),this._onStartFns=[])}onDone(t){this._onDoneFns.push(t)}onDestroy(t){this._onDestroyFns.push(t)}hasStarted(){return this._started}play(){this.parentPlayer||this.init(),this._onStart(),this.players.forEach(t=>t.play())}pause(){this.players.forEach(t=>t.pause())}restart(){this.players.forEach(t=>t.restart())}finish(){this._onFinish(),this.players.forEach(t=>t.finish())}destroy(){this._onDestroy()}_onDestroy(){this._destroyed||(this._destroyed=!0,this._onFinish(),this.players.forEach(t=>t.destroy()),this._onDestroyFns.forEach(t=>t()),this._onDestroyFns=[])}reset(){this.players.forEach(t=>t.reset()),this._destroyed=!1,this._finished=!1,this._started=!1}setPosition(t){let e=t*this.totalTime;this.players.forEach(i=>{let r=i.totalTime?Math.min(1,e/i.totalTime):1;i.setPosition(r)})}getPosition(){let t=this.players.reduce((e,i)=>null===e||i.totalTime>e.totalTime?i:e,null);return null!=t?t.getPosition():0}beforeDestroy(){this.players.forEach(t=>{t.beforeDestroy&&t.beforeDestroy()})}triggerCallback(t){let e="start"==t?this._onStartFns:this._onDoneFns;e.forEach(i=>i()),e.length=0}},Iw="!";function PG(n){return new bt(3e3,!1)}function FO(){return typeof process<"u"&&"[object process]"==={}.toString.call(process)}function _u(n){switch(n.length){case 0:return new gu;case 1:return n[0];default:return new jy(n)}}function XG(n,t,e,i,r=new Map,o=new Map){let a=[],s=[],l=-1,c=null;if(i.forEach(d=>{let u=d.get("offset"),p=u==l,f=p&&c||new Map;d.forEach((m,y)=>{let M=y,v=m;if("offset"!==y)switch(M=t.normalizePropertyName(M,a),v){case Iw:v=r.get(y);break;case _c:v=o.get(y);break;default:v=t.normalizeStyleValue(y,M,v,a)}f.set(M,v)}),p||s.push(f),c=f,l=u}),a.length)throw new bt(3502,!1);return s}function LO(n,t,e,i){switch(t){case"start":n.onStart(()=>i(e&&hO(e,"start",n)));break;case"done":n.onDone(()=>i(e&&hO(e,"done",n)));break;case"destroy":n.onDestroy(()=>i(e&&hO(e,"destroy",n)))}}function hO(n,t,e){let o=NO(n.element,n.triggerName,n.fromState,n.toState,t||n.phaseName,e.totalTime??n.totalTime,!!e.disabled),a=n._data;return null!=a&&(o._data=a),o}function NO(n,t,e,i,r="",o=0,a){return{element:n,triggerName:t,fromState:e,toState:i,phaseName:r,totalTime:o,disabled:!!a}}function os(n,t,e){let i=n.get(t);return i||n.set(t,i=e),i}function OG(n){let t=n.indexOf(":");return[n.substring(1,t),n.slice(t+1)]}var xO=(n,t)=>!1,QG=(n,t,e)=>[],ZG=null;function BO(n){let t=n.parentNode||n.host;return t===ZG?null:t}(FO()||typeof Element<"u")&&(typeof window<"u"&&typeof window.document<"u"?(ZG=(()=>document.documentElement)(),xO=(n,t)=>{for(;t;){if(t===n)return!0;t=BO(t)}return!1}):xO=(n,t)=>n.contains(t),QG=(n,t,e)=>{if(e)return Array.from(n.querySelectorAll(t));let i=n.querySelector(t);return i?[i]:[]});var of=null,FG=!1;var KG=xO,JG=QG,VO=(()=>{class n{validateStyleProperty(e){return function(n){of||(of=(typeof document<"u"?document.body:null)||{},FG=!!of.style&&"WebkitAppearance"in of.style);let t=!0;return of.style&&!function(n){return"ebkit"==n.substring(1,6)}(n)&&(t=n in of.style,!t&&FG&&(t="Webkit"+n.charAt(0).toUpperCase()+n.slice(1)in of.style)),t}(e)}matchesElement(e,i){return!1}containsElement(e,i){return KG(e,i)}getParentElement(e){return BO(e)}query(e,i,r){return JG(e,i,r)}computeStyle(e,i,r){return r||""}animate(e,i,r,o,a,s=[],l){return new gu(r,o)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})(),Jy=(()=>{class n{}return n.NOOP=new VO,n})(),Afe=1e3,e8="ng-enter",CO="ng-leave",Aw="ng-trigger",Ow=".ng-trigger",LG="ng-animating",MO=".ng-animating";function ud(n){if("number"==typeof n)return n;let t=n.match(/^(-?[\.\d]+)(m?s)/);return!t||t.length<2?0:wO(parseFloat(t[1]),t[2])}function wO(n,t){return"s"===t?n*Afe:n}function Fw(n,t,e){return n.hasOwnProperty("duration")?n:function(n,t,e){let r,o=0,a="";if("string"==typeof n){let s=n.match(/^(-?[\.\d]+)(m?s)(?:\s+(-?[\.\d]+)(m?s))?(?:\s+([-a-z]+(?:\(.+?\))?))?$/i);if(null===s)return t.push(PG()),{duration:0,delay:0,easing:""};r=wO(parseFloat(s[1]),s[2]);let l=s[3];null!=l&&(o=wO(parseFloat(l),s[4]));let c=s[5];c&&(a=c)}else r=n;if(!e){let s=!1,l=t.length;r<0&&(t.push(new bt(3100,!1)),s=!0),o<0&&(t.push(new bt(3101,!1)),s=!0),s&&t.splice(l,0,PG())}return{duration:r,delay:o,easing:a}}(n,t,e)}function $y(n,t={}){return Object.keys(n).forEach(e=>{t[e]=n[e]}),t}function t8(n){let t=new Map;return Object.keys(n).forEach(e=>{t.set(e,n[e])}),t}function Rh(n,t=new Map,e){if(e)for(let[i,r]of e)t.set(i,r);for(let[i,r]of n)t.set(i,r);return t}function NG(n,t,e){return e?t+":"+e+";":""}function n8(n){let t="";for(let e=0;e<n.style.length;e++){let i=n.style.item(e);t+=NG(0,i,n.style.getPropertyValue(i))}for(let e in n.style)n.style.hasOwnProperty(e)&&!e.startsWith("_")&&(t+=NG(0,Lfe(e),n.style[e]));n.setAttribute("style",t)}function yc(n,t,e){n.style&&(t.forEach((i,r)=>{let o=HO(r);e&&!e.has(r)&&e.set(r,n.style[o]),n.style[o]=i}),FO()&&n8(n))}function sf(n,t){n.style&&(t.forEach((e,i)=>{let r=HO(i);n.style[r]=""}),FO()&&n8(n))}function Wy(n){return Array.isArray(n)?1==n.length?n[0]:Dw(n):n}var SO=new RegExp("{{\\s*(.+?)\\s*}}","g");function i8(n){let t=[];if("string"==typeof n){let e;for(;e=SO.exec(n);)t.push(e[1]);SO.lastIndex=0}return t}function Yy(n,t,e){let i=n.toString(),r=i.replace(SO,(o,a)=>{let s=t[a];return null==s&&(e.push(new bt(3003,!1)),s=""),s.toString()});return r==i?n:r}function Lw(n){let t=[],e=n.next();for(;!e.done;)t.push(e.value),e=n.next();return t}var Ffe=/-+([a-z0-9])/g;function HO(n){return n.replace(Ffe,(...t)=>t[1].toUpperCase())}function Lfe(n){return n.replace(/([a-z])([A-Z])/g,"$1-$2").toLowerCase()}function rs(n,t,e){switch(t.type){case 7:return n.visitTrigger(t,e);case 0:return n.visitState(t,e);case 1:return n.visitTransition(t,e);case 2:return n.visitSequence(t,e);case 3:return n.visitGroup(t,e);case 4:return n.visitAnimate(t,e);case 5:return n.visitKeyframes(t,e);case 6:return n.visitStyle(t,e);case 8:return n.visitReference(t,e);case 9:return n.visitAnimateChild(t,e);case 10:return n.visitAnimateRef(t,e);case 11:return n.visitQuery(t,e);case 12:return n.visitStagger(t,e);default:throw new bt(3004,!1)}}function r8(n,t){return window.getComputedStyle(n)[t]}var Nw="*";function zfe(n,t){let e=[];return"string"==typeof n?n.split(/\s*,\s*/).forEach(i=>function(n,t,e){if(":"==n[0]){let l=function(n,t){switch(n){case":enter":return"void => *";case":leave":return"* => void";case":increment":return(e,i)=>parseFloat(i)>parseFloat(e);case":decrement":return(e,i)=>parseFloat(i)<parseFloat(e);default:return t.push(new bt(3016,!1)),"* => *"}}(n,e);if("function"==typeof l)return void t.push(l);n=l}let i=n.match(/^(\*|[-\w]+)\s*(<?[=-]>)\s*(\*|[-\w]+)$/);if(null==i||i.length<4)return e.push(new bt(3015,!1)),t;let r=i[1],o=i[2],a=i[3];t.push(BG(r,a)),"<"==o[0]&&!(r==Nw&&a==Nw)&&t.push(BG(a,r))}(i,e,t)):e.push(n),e}var Rw=new Set(["true","1"]),kw=new Set(["false","0"]);function BG(n,t){let e=Rw.has(n)||kw.has(n),i=Rw.has(t)||kw.has(t);return(r,o)=>{let a=n==Nw||n==r,s=t==Nw||t==o;return!a&&e&&"boolean"==typeof r&&(a=r?Rw.has(n):kw.has(n)),!s&&i&&"boolean"==typeof o&&(s=o?Rw.has(t):kw.has(t)),a&&s}}var Gfe=new RegExp("s*:selfs*,?","g");function l8(n,t,e,i){return new EO(n).build(t,e,i)}var EO=class{constructor(t){this._driver=t}build(t,e,i){let r=new TO(e);return this._resetContextStyleTimingState(r),rs(this,Wy(t),r)}_resetContextStyleTimingState(t){t.currentQuerySelector="",t.collectedStyles=new Map,t.collectedStyles.set("",new Map),t.currentTime=0}visitTrigger(t,e){let i=e.queryCount=0,r=e.depCount=0,o=[],a=[];return"@"==t.name.charAt(0)&&e.errors.push(new bt(3006,!1)),t.definitions.forEach(s=>{if(this._resetContextStyleTimingState(e),0==s.type){let l=s,c=l.name;c.toString().split(/\s*,\s*/).forEach(d=>{l.name=d,o.push(this.visitState(l,e))}),l.name=c}else if(1==s.type){let l=this.visitTransition(s,e);i+=l.queryCount,r+=l.depCount,a.push(l)}else e.errors.push(new bt(3007,!1))}),{type:7,name:t.name,states:o,transitions:a,queryCount:i,depCount:r,options:null}}visitState(t,e){let i=this.visitStyle(t.styles,e),r=t.options&&t.options.params||null;if(i.containsDynamicStyles){let o=new Set,a=r||{};i.styles.forEach(s=>{s instanceof Map&&s.forEach(l=>{i8(l).forEach(c=>{a.hasOwnProperty(c)||o.add(c)})})}),o.size&&(Lw(o.values()),e.errors.push(new bt(3008,!1)))}return{type:0,name:t.name,style:i,options:r?{params:r}:null}}visitTransition(t,e){e.queryCount=0,e.depCount=0;let i=rs(this,Wy(t.animation),e);return{type:1,matchers:zfe(t.expr,e.errors),animation:i,queryCount:e.queryCount,depCount:e.depCount,options:af(t.options)}}visitSequence(t,e){return{type:2,steps:t.steps.map(i=>rs(this,i,e)),options:af(t.options)}}visitGroup(t,e){let i=e.currentTime,r=0,o=t.steps.map(a=>{e.currentTime=i;let s=rs(this,a,e);return r=Math.max(r,e.currentTime),s});return e.currentTime=r,{type:3,steps:o,options:af(t.options)}}visitAnimate(t,e){let i=function(n,t){if(n.hasOwnProperty("duration"))return n;if("number"==typeof n)return gO(Fw(n,t).duration,0,"");let e=n;if(e.split(/\s+/).some(o=>"{"==o.charAt(0)&&"{"==o.charAt(1))){let o=gO(0,0,"");return o.dynamic=!0,o.strValue=e,o}let r=Fw(e,t);return gO(r.duration,r.delay,r.easing)}(t.timings,e.errors);e.currentAnimateTimings=i;let r,o=t.styles?t.styles:Bt({});if(5==o.type)r=this.visitKeyframes(o,e);else{let a=t.styles,s=!1;if(!a){s=!0;let c={};i.easing&&(c.easing=i.easing),a=Bt(c)}e.currentTime+=i.duration+i.delay;let l=this.visitStyle(a,e);l.isEmptyStep=s,r=l}return e.currentAnimateTimings=null,{type:4,timings:i,style:r,options:null}}visitStyle(t,e){let i=this._makeStyleAst(t,e);return this._validateStyleAst(i,e),i}_makeStyleAst(t,e){let i=[],r=Array.isArray(t.styles)?t.styles:[t.styles];for(let s of r)"string"==typeof s?s===_c?i.push(s):e.errors.push(new bt(3002,!1)):i.push(t8(s));let o=!1,a=null;return i.forEach(s=>{if(s instanceof Map&&(s.has("easing")&&(a=s.get("easing"),s.delete("easing")),!o))for(let l of s.values())if(l.toString().indexOf("{{")>=0){o=!0;break}}),{type:6,styles:i,easing:a,offset:t.offset,containsDynamicStyles:o,options:null}}_validateStyleAst(t,e){let i=e.currentAnimateTimings,r=e.currentTime,o=e.currentTime;i&&o>0&&(o-=i.duration+i.delay),t.styles.forEach(a=>{"string"!=typeof a&&a.forEach((s,l)=>{let c=e.collectedStyles.get(e.currentQuerySelector),d=c.get(l),u=!0;d&&(o!=r&&o>=d.startTime&&r<=d.endTime&&(e.errors.push(new bt(3010,!1)),u=!1),o=d.startTime),u&&c.set(l,{startTime:o,endTime:r}),e.options&&function(n,t,e){let i=t.params||{},r=i8(n);r.length&&r.forEach(o=>{i.hasOwnProperty(o)||e.push(new bt(3001,!1))})}(s,e.options,e.errors)})})}visitKeyframes(t,e){let i={type:5,styles:[],options:null};if(!e.currentAnimateTimings)return e.errors.push(new bt(3011,!1)),i;let o=0,a=[],s=!1,l=!1,c=0,d=t.steps.map(v=>{let x=this._makeStyleAst(v,e),R=null!=x.offset?x.offset:function(n){if("string"==typeof n)return null;let t=null;if(Array.isArray(n))n.forEach(e=>{if(e instanceof Map&&e.has("offset")){let i=e;t=parseFloat(i.get("offset")),i.delete("offset")}});else if(n instanceof Map&&n.has("offset")){let e=n;t=parseFloat(e.get("offset")),e.delete("offset")}return t}(x.styles),A=0;return null!=R&&(o++,A=x.offset=R),l=l||A<0||A>1,s=s||A<c,c=A,a.push(A),x});l&&e.errors.push(new bt(3012,!1)),s&&e.errors.push(new bt(3200,!1));let u=t.steps.length,p=0;o>0&&o<u?e.errors.push(new bt(3202,!1)):0==o&&(p=1/(u-1));let f=u-1,m=e.currentTime,y=e.currentAnimateTimings,M=y.duration;return d.forEach((v,x)=>{let R=p>0?x==f?1:p*x:a[x],A=R*M;e.currentTime=m+y.delay+A,y.duration=A,this._validateStyleAst(v,e),v.offset=R,i.styles.push(v)}),i}visitReference(t,e){return{type:8,animation:rs(this,Wy(t.animation),e),options:af(t.options)}}visitAnimateChild(t,e){return e.depCount++,{type:9,options:af(t.options)}}visitAnimateRef(t,e){return{type:10,animation:this.visitReference(t.animation,e),options:af(t.options)}}visitQuery(t,e){let i=e.currentQuerySelector,r=t.options||{};e.queryCount++,e.currentQuery=t;let[o,a]=function(n){let t=!!n.split(/\s*,\s*/).find(e=>":self"==e);return t&&(n=n.replace(Gfe,"")),n=n.replace(/@\*/g,Ow).replace(/@\w+/g,e=>Ow+"-"+e.slice(1)).replace(/:animating/g,MO),[n,t]}(t.selector);e.currentQuerySelector=i.length?i+" "+o:o,os(e.collectedStyles,e.currentQuerySelector,new Map);let s=rs(this,Wy(t.animation),e);return e.currentQuery=null,e.currentQuerySelector=i,{type:11,selector:o,limit:r.limit||0,optional:!!r.optional,includeSelf:a,animation:s,originalSelector:t.selector,options:af(t.options)}}visitStagger(t,e){e.currentQuery||e.errors.push(new bt(3013,!1));let i="full"===t.timings?{duration:0,delay:0,easing:"full"}:Fw(t.timings,e.errors,!0);return{type:12,animation:rs(this,Wy(t.animation),e),timings:i,options:null}}},TO=class{constructor(t){this.errors=t,this.queryCount=0,this.depCount=0,this.currentTransition=null,this.currentQuery=null,this.currentQuerySelector=null,this.currentAnimateTimings=null,this.currentTime=0,this.collectedStyles=new Map,this.options=null,this.unsupportedCSSPropertiesFound=new Set}};function af(n){return n?(n=$y(n)).params&&(n.params=function(n){return n?$y(n):null}(n.params)):n={},n}function gO(n,t,e){return{duration:n,delay:t,easing:e}}function zO(n,t,e,i,r,o,a=null,s=!1){return{type:1,element:n,keyframes:t,preStyleProps:e,postStyleProps:i,duration:r,delay:o,totalTime:r+o,easing:a,subTimeline:s}}var Xy=class{constructor(){this._map=new Map}get(t){return this._map.get(t)||[]}append(t,e){let i=this._map.get(t);i||this._map.set(t,i=[]),i.push(...e)}has(t){return this._map.has(t)}clear(){this._map.clear()}},Kfe=new RegExp(":enter","g"),$fe=new RegExp(":leave","g");function c8(n,t,e,i,r,o=new Map,a=new Map,s,l,c=[]){return(new DO).buildKeyframes(n,t,e,i,r,o,a,s,l,c)}var DO=class{buildKeyframes(t,e,i,r,o,a,s,l,c,d=[]){c=c||new Xy;let u=new Qy(t,e,c,r,o,d,[]);u.options=l;let p=l.delay?ud(l.delay):0;u.currentTimeline.delayNextStep(p),u.currentTimeline.setStyles([a],null,u.errors,l),rs(this,i,u);let f=u.timelines.filter(m=>m.containsAnimation());if(f.length&&s.size){let m;for(let y=f.length-1;y>=0;y--){let M=f[y];if(M.element===e){m=M;break}}m&&!m.allowOnlyTimelineStyles()&&m.setStyles([s],null,u.errors,l)}return f.length?f.map(m=>m.buildKeyframes()):[zO(e,[],[],[],0,p,"",!1)]}visitTrigger(t,e){}visitState(t,e){}visitTransition(t,e){}visitAnimateChild(t,e){let i=e.subInstructions.get(e.element);if(i){let r=e.createSubContext(t.options),o=e.currentTimeline.currentTime,a=this._visitSubInstructions(i,r,r.options);o!=a&&e.transformIntoNewTimeline(a)}e.previousNode=t}visitAnimateRef(t,e){let i=e.createSubContext(t.options);i.transformIntoNewTimeline(),this._applyAnimationRefDelays([t.options,t.animation.options],e,i),this.visitReference(t.animation,i),e.transformIntoNewTimeline(i.currentTimeline.currentTime),e.previousNode=t}_applyAnimationRefDelays(t,e,i){for(let r of t){let o=r?.delay;if(o){let a="number"==typeof o?o:ud(Yy(o,r?.params??{},e.errors));i.delayNextStep(a)}}}_visitSubInstructions(t,e,i){let o=e.currentTimeline.currentTime,a=null!=i.duration?ud(i.duration):null,s=null!=i.delay?ud(i.delay):null;return 0!==a&&t.forEach(l=>{let c=e.appendInstructionToTimeline(l,a,s);o=Math.max(o,c.duration+c.delay)}),o}visitReference(t,e){e.updateOptions(t.options,!0),rs(this,t.animation,e),e.previousNode=t}visitSequence(t,e){let i=e.subContextCount,r=e,o=t.options;if(o&&(o.params||o.delay)&&(r=e.createSubContext(o),r.transformIntoNewTimeline(),null!=o.delay)){6==r.previousNode.type&&(r.currentTimeline.snapshotCurrentStyles(),r.previousNode=Bw);let a=ud(o.delay);r.delayNextStep(a)}t.steps.length&&(t.steps.forEach(a=>rs(this,a,r)),r.currentTimeline.applyStylesToKeyframe(),r.subContextCount>i&&r.transformIntoNewTimeline()),e.previousNode=t}visitGroup(t,e){let i=[],r=e.currentTimeline.currentTime,o=t.options&&t.options.delay?ud(t.options.delay):0;t.steps.forEach(a=>{let s=e.createSubContext(t.options);o&&s.delayNextStep(o),rs(this,a,s),r=Math.max(r,s.currentTimeline.currentTime),i.push(s.currentTimeline)}),i.forEach(a=>e.currentTimeline.mergeTimelineCollectedStyles(a)),e.transformIntoNewTimeline(r),e.previousNode=t}_visitTiming(t,e){if(t.dynamic){let i=t.strValue;return Fw(e.params?Yy(i,e.params,e.errors):i,e.errors)}return{duration:t.duration,delay:t.delay,easing:t.easing}}visitAnimate(t,e){let i=e.currentAnimateTimings=this._visitTiming(t.timings,e),r=e.currentTimeline;i.delay&&(e.incrementTime(i.delay),r.snapshotCurrentStyles());let o=t.style;5==o.type?this.visitKeyframes(o,e):(e.incrementTime(i.duration),this.visitStyle(o,e),r.applyStylesToKeyframe()),e.currentAnimateTimings=null,e.previousNode=t}visitStyle(t,e){let i=e.currentTimeline,r=e.currentAnimateTimings;!r&&i.hasCurrentStyleProperties()&&i.forwardFrame();let o=r&&r.easing||t.easing;t.isEmptyStep?i.applyEmptyStep(o):i.setStyles(t.styles,o,e.errors,e.options),e.previousNode=t}visitKeyframes(t,e){let i=e.currentAnimateTimings,r=e.currentTimeline.duration,o=i.duration,s=e.createSubContext().currentTimeline;s.easing=i.easing,t.styles.forEach(l=>{s.forwardTime((l.offset||0)*o),s.setStyles(l.styles,l.easing,e.errors,e.options),s.applyStylesToKeyframe()}),e.currentTimeline.mergeTimelineCollectedStyles(s),e.transformIntoNewTimeline(r+o),e.previousNode=t}visitQuery(t,e){let i=e.currentTimeline.currentTime,r=t.options||{},o=r.delay?ud(r.delay):0;o&&(6===e.previousNode.type||0==i&&e.currentTimeline.hasCurrentStyleProperties())&&(e.currentTimeline.snapshotCurrentStyles(),e.previousNode=Bw);let a=i,s=e.invokeQuery(t.selector,t.originalSelector,t.limit,t.includeSelf,!!r.optional,e.errors);e.currentQueryTotal=s.length;let l=null;s.forEach((c,d)=>{e.currentQueryIndex=d;let u=e.createSubContext(t.options,c);o&&u.delayNextStep(o),c===e.element&&(l=u.currentTimeline),rs(this,t.animation,u),u.currentTimeline.applyStylesToKeyframe(),a=Math.max(a,u.currentTimeline.currentTime)}),e.currentQueryIndex=0,e.currentQueryTotal=0,e.transformIntoNewTimeline(a),l&&(e.currentTimeline.mergeTimelineCollectedStyles(l),e.currentTimeline.snapshotCurrentStyles()),e.previousNode=t}visitStagger(t,e){let i=e.parentContext,r=e.currentTimeline,o=t.timings,a=Math.abs(o.duration),s=a*(e.currentQueryTotal-1),l=a*e.currentQueryIndex;switch(o.duration<0?"reverse":o.easing){case"reverse":l=s-l;break;case"full":l=i.currentStaggerTime}let d=e.currentTimeline;l&&d.delayNextStep(l);let u=d.currentTime;rs(this,t.animation,e),e.previousNode=t,i.currentStaggerTime=r.currentTime-u+(r.startTime-i.currentTimeline.startTime)}},Bw={},Qy=class{constructor(t,e,i,r,o,a,s,l){this._driver=t,this.element=e,this.subInstructions=i,this._enterClassName=r,this._leaveClassName=o,this.errors=a,this.timelines=s,this.parentContext=null,this.currentAnimateTimings=null,this.previousNode=Bw,this.subContextCount=0,this.options={},this.currentQueryIndex=0,this.currentQueryTotal=0,this.currentStaggerTime=0,this.currentTimeline=l||new kh(this._driver,e,0),s.push(this.currentTimeline)}get params(){return this.options.params}updateOptions(t,e){if(!t)return;let i=t,r=this.options;null!=i.duration&&(r.duration=ud(i.duration)),null!=i.delay&&(r.delay=ud(i.delay));let o=i.params;if(o){let a=r.params;a||(a=this.options.params={}),Object.keys(o).forEach(s=>{(!e||!a.hasOwnProperty(s))&&(a[s]=Yy(o[s],a,this.errors))})}}_copyOptions(){let t={};if(this.options){let e=this.options.params;if(e){let i=t.params={};Object.keys(e).forEach(r=>{i[r]=e[r]})}}return t}createSubContext(t=null,e,i){let r=e||this.element,o=new Qy(this._driver,r,this.subInstructions,this._enterClassName,this._leaveClassName,this.errors,this.timelines,this.currentTimeline.fork(r,i||0));return o.previousNode=this.previousNode,o.currentAnimateTimings=this.currentAnimateTimings,o.options=this._copyOptions(),o.updateOptions(t),o.currentQueryIndex=this.currentQueryIndex,o.currentQueryTotal=this.currentQueryTotal,o.parentContext=this,this.subContextCount++,o}transformIntoNewTimeline(t){return this.previousNode=Bw,this.currentTimeline=this.currentTimeline.fork(this.element,t),this.timelines.push(this.currentTimeline),this.currentTimeline}appendInstructionToTimeline(t,e,i){let r={duration:e??t.duration,delay:this.currentTimeline.currentTime+(i??0)+t.delay,easing:""},o=new IO(this._driver,t.element,t.keyframes,t.preStyleProps,t.postStyleProps,r,t.stretchStartingKeyframe);return this.timelines.push(o),r}incrementTime(t){this.currentTimeline.forwardTime(this.currentTimeline.duration+t)}delayNextStep(t){t>0&&this.currentTimeline.delayNextStep(t)}invokeQuery(t,e,i,r,o,a){let s=[];if(r&&s.push(this.element),t.length>0){t=(t=t.replace(Kfe,"."+this._enterClassName)).replace($fe,"."+this._leaveClassName);let c=this._driver.query(this.element,t,1!=i);0!==i&&(c=i<0?c.slice(c.length+i,c.length):c.slice(0,i)),s.push(...c)}return!o&&0==s.length&&a.push(new bt(3014,!1)),s}},kh=class{constructor(t,e,i,r){this._driver=t,this.element=e,this.startTime=i,this._elementTimelineStylesLookup=r,this.duration=0,this.easing=null,this._previousKeyframe=new Map,this._currentKeyframe=new Map,this._keyframes=new Map,this._styleSummary=new Map,this._localTimelineStyles=new Map,this._pendingStyles=new Map,this._backFill=new Map,this._currentEmptyStepKeyframe=null,this._elementTimelineStylesLookup||(this._elementTimelineStylesLookup=new Map),this._globalTimelineStyles=this._elementTimelineStylesLookup.get(e),this._globalTimelineStyles||(this._globalTimelineStyles=this._localTimelineStyles,this._elementTimelineStylesLookup.set(e,this._localTimelineStyles)),this._loadKeyframe()}containsAnimation(){switch(this._keyframes.size){case 0:return!1;case 1:return this.hasCurrentStyleProperties();default:return!0}}hasCurrentStyleProperties(){return this._currentKeyframe.size>0}get currentTime(){return this.startTime+this.duration}delayNextStep(t){let e=1===this._keyframes.size&&this._pendingStyles.size;this.duration||e?(this.forwardTime(this.currentTime+t),e&&this.snapshotCurrentStyles()):this.startTime+=t}fork(t,e){return this.applyStylesToKeyframe(),new kh(this._driver,t,e||this.currentTime,this._elementTimelineStylesLookup)}_loadKeyframe(){this._currentKeyframe&&(this._previousKeyframe=this._currentKeyframe),this._currentKeyframe=this._keyframes.get(this.duration),this._currentKeyframe||(this._currentKeyframe=new Map,this._keyframes.set(this.duration,this._currentKeyframe))}forwardFrame(){this.duration+=1,this._loadKeyframe()}forwardTime(t){this.applyStylesToKeyframe(),this.duration=t,this._loadKeyframe()}_updateStyle(t,e){this._localTimelineStyles.set(t,e),this._globalTimelineStyles.set(t,e),this._styleSummary.set(t,{time:this.currentTime,value:e})}allowOnlyTimelineStyles(){return this._currentEmptyStepKeyframe!==this._currentKeyframe}applyEmptyStep(t){t&&this._previousKeyframe.set("easing",t);for(let[e,i]of this._globalTimelineStyles)this._backFill.set(e,i||_c),this._currentKeyframe.set(e,_c);this._currentEmptyStepKeyframe=this._currentKeyframe}setStyles(t,e,i,r){e&&this._previousKeyframe.set("easing",e);let o=r&&r.params||{},a=function(n,t){let i,e=new Map;return n.forEach(r=>{if("*"===r){i=i||t.keys();for(let o of i)e.set(o,_c)}else Rh(r,e)}),e}(t,this._globalTimelineStyles);for(let[s,l]of a){let c=Yy(l,o,i);this._pendingStyles.set(s,c),this._localTimelineStyles.has(s)||this._backFill.set(s,this._globalTimelineStyles.get(s)??_c),this._updateStyle(s,c)}}applyStylesToKeyframe(){0!=this._pendingStyles.size&&(this._pendingStyles.forEach((t,e)=>{this._currentKeyframe.set(e,t)}),this._pendingStyles.clear(),this._localTimelineStyles.forEach((t,e)=>{this._currentKeyframe.has(e)||this._currentKeyframe.set(e,t)}))}snapshotCurrentStyles(){for(let[t,e]of this._localTimelineStyles)this._pendingStyles.set(t,e),this._updateStyle(t,e)}getFinalKeyframe(){return this._keyframes.get(this.duration)}get properties(){let t=[];for(let e in this._currentKeyframe)t.push(e);return t}mergeTimelineCollectedStyles(t){t._styleSummary.forEach((e,i)=>{let r=this._styleSummary.get(i);(!r||e.time>r.time)&&this._updateStyle(i,e.value)})}buildKeyframes(){this.applyStylesToKeyframe();let t=new Set,e=new Set,i=1===this._keyframes.size&&0===this.duration,r=[];this._keyframes.forEach((s,l)=>{let c=Rh(s,new Map,this._backFill);c.forEach((d,u)=>{d===Iw?t.add(u):d===_c&&e.add(u)}),i||c.set("offset",l/this.duration),r.push(c)});let o=t.size?Lw(t.values()):[],a=e.size?Lw(e.values()):[];if(i){let s=r[0],l=new Map(s);s.set("offset",0),l.set("offset",1),r=[s,l]}return zO(this.element,r,o,a,this.duration,this.startTime,this.easing,!1)}},IO=class extends kh{constructor(t,e,i,r,o,a,s=!1){super(t,e,a.delay),this.keyframes=i,this.preStyleProps=r,this.postStyleProps=o,this._stretchStartingKeyframe=s,this.timings={duration:a.duration,delay:a.delay,easing:a.easing}}containsAnimation(){return this.keyframes.length>1}buildKeyframes(){let t=this.keyframes,{delay:e,duration:i,easing:r}=this.timings;if(this._stretchStartingKeyframe&&e){let o=[],a=i+e,s=e/a,l=Rh(t[0]);l.set("offset",0),o.push(l);let c=Rh(t[0]);c.set("offset",HG(s)),o.push(c);let d=t.length-1;for(let u=1;u<=d;u++){let p=Rh(t[u]),f=p.get("offset");p.set("offset",HG((e+f*i)/a)),o.push(p)}i=a,e=0,r="",t=o}return zO(this.element,t,this.preStyleProps,this.postStyleProps,i,e,r,!0)}};function HG(n,t=3){let e=Math.pow(10,t-1);return Math.round(n*e)/e}var lf=class{},tme=new Set(["width","height","minWidth","minHeight","maxWidth","maxHeight","left","top","bottom","right","fontSize","outlineWidth","outlineOffset","paddingTop","paddingLeft","paddingBottom","paddingRight","marginTop","marginLeft","marginBottom","marginRight","borderRadius","borderWidth","borderTopWidth","borderLeftWidth","borderRightWidth","borderBottomWidth","textIndent","perspective"]),Vw=class extends lf{normalizePropertyName(t,e){return HO(t)}normalizeStyleValue(t,e,i,r){let o="",a=i.toString().trim();if(tme.has(e)&&0!==i&&"0"!==i)if("number"==typeof i)o="px";else{let s=i.match(/^[+-]?[\d\.]+([a-z]*)$/);s&&0==s[1].length&&r.push(new bt(3005,!1))}return a+o}};function zG(n,t,e,i,r,o,a,s,l,c,d,u,p){return{type:0,element:n,triggerName:t,isRemovalTransition:r,fromState:e,fromStyles:o,toState:i,toStyles:a,timelines:s,queriedElements:l,preStyleProps:c,postStyleProps:d,totalTime:u,errors:p}}var _O={},Hw=class{constructor(t,e,i){this._triggerName=t,this.ast=e,this._stateStyles=i}match(t,e,i,r){return function(n,t,e,i,r){return n.some(o=>o(t,e,i,r))}(this.ast.matchers,t,e,i,r)}buildStyles(t,e,i){let r=this._stateStyles.get("*");return void 0!==t&&(r=this._stateStyles.get(t?.toString())||r),r?r.buildStyles(e,i):new Map}build(t,e,i,r,o,a,s,l,c,d){let u=[],p=this.ast.options&&this.ast.options.params||_O,m=this.buildStyles(i,s&&s.params||_O,u),y=l&&l.params||_O,M=this.buildStyles(r,y,u),v=new Set,x=new Map,R=new Map,A="void"===r,H={params:ime(y,p),delay:this.ast.options?.delay},te=d?[]:c8(t,e,this.ast.animation,o,a,m,M,H,c,u),K=0;if(te.forEach(Ze=>{K=Math.max(Ze.duration+Ze.delay,K)}),u.length)return zG(e,this._triggerName,i,r,A,m,M,[],[],x,R,K,u);te.forEach(Ze=>{let Ie=Ze.element,I=os(x,Ie,new Set);Ze.preStyleProps.forEach(ce=>I.add(ce));let re=os(R,Ie,new Set);Ze.postStyleProps.forEach(ce=>re.add(ce)),Ie!==e&&v.add(Ie)});let Ce=Lw(v.values());return zG(e,this._triggerName,i,r,A,m,M,te,Ce,x,R,K)}};function ime(n,t){let e=$y(t);for(let i in n)n.hasOwnProperty(i)&&null!=n[i]&&(e[i]=n[i]);return e}function UG(n,t,e){n.has(t)?n.has(e)||n.set(e,n.get(t)):n.has(e)&&n.set(t,n.get(e))}var ame=new Xy,jG="ng-animate-queued",yO="ng-animate-disabled",ume=[],d8={namespaceId:"",setForRemoval:!1,setForMove:!1,hasAnimation:!1,removedBeforeQueried:!1},pme={namespaceId:"",setForMove:!1,setForRemoval:!1,hasAnimation:!1,removedBeforeQueried:!0},Os="__ng_removed",Zy=class{get params(){return this.options.params}constructor(t,e=""){this.namespaceId=e;let i=t&&t.hasOwnProperty("value");if(this.value=(i?t.value:t)??null,i){let o=$y(t);delete o.value,this.options=o}else this.options={};this.options.params||(this.options.params={})}absorbOptions(t){let e=t.params;if(e){let i=this.options.params;Object.keys(e).forEach(r=>{null==i[r]&&(i[r]=e[r])})}}},qy="void",bO=new Zy(qy),Ky=class{constructor(t,e,i){this.namespaceId=t,this.triggerName=e,this.element=i,this._player=new gu,this._containsRealPlayer=!1,this._queuedCallbacks=new Map,this.destroyed=!1,this.parentPlayer=null,this.markedForDestroy=!1,this.disabled=!1,this.queued=!0,this.totalTime=0}setRealPlayer(t){this._containsRealPlayer||(this._player=t,this._queuedCallbacks.forEach((e,i)=>{e.forEach(r=>LO(t,i,void 0,r))}),this._queuedCallbacks.clear(),this._containsRealPlayer=!0,this.overrideTotalTime(t.totalTime),this.queued=!1)}getRealPlayer(){return this._player}overrideTotalTime(t){this.totalTime=t}syncPlayerEvents(t){let e=this._player;e.triggerCallback&&t.onStart(()=>e.triggerCallback("start")),t.onDone(()=>this.finish()),t.onDestroy(()=>this.destroy())}_queueEvent(t,e){os(this._queuedCallbacks,t,[]).push(e)}onDone(t){this.queued&&this._queueEvent("done",t),this._player.onDone(t)}onStart(t){this.queued&&this._queueEvent("start",t),this._player.onStart(t)}onDestroy(t){this.queued&&this._queueEvent("destroy",t),this._player.onDestroy(t)}init(){this._player.init()}hasStarted(){return!this.queued&&this._player.hasStarted()}play(){!this.queued&&this._player.play()}pause(){!this.queued&&this._player.pause()}restart(){!this.queued&&this._player.restart()}finish(){this._player.finish()}destroy(){this.destroyed=!0,this._player.destroy()}reset(){!this.queued&&this._player.reset()}setPosition(t){this.queued||this._player.setPosition(t)}getPosition(){return this.queued?0:this._player.getPosition()}triggerCallback(t){let e=this._player;e.triggerCallback&&e.triggerCallback(t)}};function Pw(n){return n&&1===n.nodeType}function GG(n,t){let e=n.style.display;return n.style.display=t??"none",e}function WG(n,t,e,i,r){let o=[];e.forEach(l=>o.push(GG(l)));let a=[];i.forEach((l,c)=>{let d=new Map;l.forEach(u=>{let p=t.computeStyle(c,u,r);d.set(u,p),(!p||0==p.length)&&(c[Os]=pme,a.push(c))}),n.set(c,d)});let s=0;return e.forEach(l=>GG(l,o[s++])),a}function qG(n,t){let e=new Map;if(n.forEach(s=>e.set(s,[])),0==t.length)return e;let i=1,r=new Set(t),o=new Map;function a(s){if(!s)return i;let l=o.get(s);if(l)return l;let c=s.parentNode;return l=e.has(c)?c:r.has(c)?i:a(c),o.set(s,l),l}return t.forEach(s=>{let l=a(s);l!==i&&e.get(l).push(s)}),e}function Fs(n,t){n.classList?.add(t)}function Ah(n,t){n.classList?.remove(t)}function gme(n,t,e){_u(e).onDone(()=>n.processLeaveNode(t))}function u8(n,t){for(let e=0;e<n.length;e++){let i=n[e];i instanceof jy?u8(i.players,t):t.push(i)}}function YG(n,t,e){let i=e.get(n);if(!i)return!1;let r=t.get(n);return r?i.forEach(o=>r.add(o)):t.set(n,i),e.delete(n),!0}var yu=class{constructor(t,e,i){this.bodyNode=t,this._driver=e,this._normalizer=i,this._triggerCache={},this.onRemovalComplete=(r,o)=>{},this._transitionEngine=new class{_onRemovalComplete(t,e){this.onRemovalComplete(t,e)}constructor(t,e,i){this.bodyNode=t,this.driver=e,this._normalizer=i,this.players=[],this.newHostElements=new Map,this.playersByElement=new Map,this.playersByQueriedElement=new Map,this.statesByElement=new Map,this.disabledNodes=new Set,this.totalAnimations=0,this.totalQueuedPlayers=0,this._namespaceLookup={},this._namespaceList=[],this._flushFns=[],this._whenQuietFns=[],this.namespacesByHostElement=new Map,this.collectedEnterElements=[],this.collectedLeaveElements=[],this.onRemovalComplete=(r,o)=>{}}get queuedPlayers(){let t=[];return this._namespaceList.forEach(e=>{e.players.forEach(i=>{i.queued&&t.push(i)})}),t}createNamespace(t,e){let i=new class{constructor(t,e,i){this.id=t,this.hostElement=e,this._engine=i,this.players=[],this._triggers=new Map,this._queue=[],this._elementListeners=new Map,this._hostClassName="ng-tns-"+t,Fs(e,this._hostClassName)}listen(t,e,i,r){if(!this._triggers.has(e))throw new bt(3302,!1);if(null==i||0==i.length)throw new bt(3303,!1);if("start"!=(n=i)&&"done"!=n)throw new bt(3400,!1);var n;let o=os(this._elementListeners,t,[]),a={name:e,phase:i,callback:r};o.push(a);let s=os(this._engine.statesByElement,t,new Map);return s.has(e)||(Fs(t,Aw),Fs(t,Aw+"-"+e),s.set(e,bO)),()=>{this._engine.afterFlush(()=>{let l=o.indexOf(a);l>=0&&o.splice(l,1),this._triggers.has(e)||s.delete(e)})}}register(t,e){return!this._triggers.has(t)&&(this._triggers.set(t,e),!0)}_getTrigger(t){let e=this._triggers.get(t);if(!e)throw new bt(3401,!1);return e}trigger(t,e,i,r=!0){let o=this._getTrigger(e),a=new Ky(this.id,e,t),s=this._engine.statesByElement.get(t);s||(Fs(t,Aw),Fs(t,Aw+"-"+e),this._engine.statesByElement.set(t,s=new Map));let l=s.get(e),c=new Zy(i,this.id);if(!(i&&i.hasOwnProperty("value"))&&l&&c.absorbOptions(l.options),s.set(e,c),l||(l=bO),c.value!==qy&&l.value===c.value){if(!function(n,t){let e=Object.keys(n),i=Object.keys(t);if(e.length!=i.length)return!1;for(let r=0;r<e.length;r++){let o=e[r];if(!t.hasOwnProperty(o)||n[o]!==t[o])return!1}return!0}(l.params,c.params)){let y=[],M=o.matchStyles(l.value,l.params,y),v=o.matchStyles(c.value,c.params,y);y.length?this._engine.reportError(y):this._engine.afterFlush(()=>{sf(t,M),yc(t,v)})}return}let p=os(this._engine.playersByElement,t,[]);p.forEach(y=>{y.namespaceId==this.id&&y.triggerName==e&&y.queued&&y.destroy()});let f=o.matchTransition(l.value,c.value,t,c.params),m=!1;if(!f){if(!r)return;f=o.fallbackTransition,m=!0}return this._engine.totalQueuedPlayers++,this._queue.push({element:t,triggerName:e,transition:f,fromState:l,toState:c,player:a,isFallbackTransition:m}),m||(Fs(t,jG),a.onStart(()=>{Ah(t,jG)})),a.onDone(()=>{let y=this.players.indexOf(a);y>=0&&this.players.splice(y,1);let M=this._engine.playersByElement.get(t);if(M){let v=M.indexOf(a);v>=0&&M.splice(v,1)}}),this.players.push(a),p.push(a),a}deregister(t){this._triggers.delete(t),this._engine.statesByElement.forEach(e=>e.delete(t)),this._elementListeners.forEach((e,i)=>{this._elementListeners.set(i,e.filter(r=>r.name!=t))})}clearElementCache(t){this._engine.statesByElement.delete(t),this._elementListeners.delete(t);let e=this._engine.playersByElement.get(t);e&&(e.forEach(i=>i.destroy()),this._engine.playersByElement.delete(t))}_signalRemovalForInnerTriggers(t,e){let i=this._engine.driver.query(t,Ow,!0);i.forEach(r=>{if(r[Os])return;let o=this._engine.fetchNamespacesByElement(r);o.size?o.forEach(a=>a.triggerLeaveAnimation(r,e,!1,!0)):this.clearElementCache(r)}),this._engine.afterFlushAnimationsDone(()=>i.forEach(r=>this.clearElementCache(r)))}triggerLeaveAnimation(t,e,i,r){let o=this._engine.statesByElement.get(t),a=new Map;if(o){let s=[];if(o.forEach((l,c)=>{if(a.set(c,l.value),this._triggers.has(c)){let d=this.trigger(t,c,qy,r);d&&s.push(d)}}),s.length)return this._engine.markElementAsRemoved(this.id,t,!0,e,a),i&&_u(s).onDone(()=>this._engine.processLeaveNode(t)),!0}return!1}prepareLeaveAnimationListeners(t){let e=this._elementListeners.get(t),i=this._engine.statesByElement.get(t);if(e&&i){let r=new Set;e.forEach(o=>{let a=o.name;if(r.has(a))return;r.add(a);let l=this._triggers.get(a).fallbackTransition,c=i.get(a)||bO,d=new Zy(qy),u=new Ky(this.id,a,t);this._engine.totalQueuedPlayers++,this._queue.push({element:t,triggerName:a,transition:l,fromState:c,toState:d,player:u,isFallbackTransition:!0})})}}removeNode(t,e){let i=this._engine;if(t.childElementCount&&this._signalRemovalForInnerTriggers(t,e),this.triggerLeaveAnimation(t,e,!0))return;let r=!1;if(i.totalAnimations){let o=i.players.length?i.playersByQueriedElement.get(t):[];if(o&&o.length)r=!0;else{let a=t;for(;a=a.parentNode;)if(i.statesByElement.get(a)){r=!0;break}}}if(this.prepareLeaveAnimationListeners(t),r)i.markElementAsRemoved(this.id,t,!1,e);else{let o=t[Os];(!o||o===d8)&&(i.afterFlush(()=>this.clearElementCache(t)),i.destroyInnerAnimations(t),i._onRemovalComplete(t,e))}}insertNode(t,e){Fs(t,this._hostClassName)}drainQueuedTransitions(t){let e=[];return this._queue.forEach(i=>{let r=i.player;if(r.destroyed)return;let o=i.element,a=this._elementListeners.get(o);a&&a.forEach(s=>{if(s.name==i.triggerName){let l=NO(o,i.triggerName,i.fromState.value,i.toState.value);l._data=t,LO(i.player,s.phase,l,s.callback)}}),r.markedForDestroy?this._engine.afterFlush(()=>{r.destroy()}):e.push(i)}),this._queue=[],e.sort((i,r)=>{let o=i.transition.ast.depCount,a=r.transition.ast.depCount;return 0==o||0==a?o-a:this._engine.driver.containsElement(i.element,r.element)?1:-1})}destroy(t){this.players.forEach(e=>e.destroy()),this._signalRemovalForInnerTriggers(this.hostElement,t)}elementContainsData(t){let e=!1;return this._elementListeners.has(t)&&(e=!0),e=!!this._queue.find(i=>i.element===t)||e,e}}(t,e,this);return this.bodyNode&&this.driver.containsElement(this.bodyNode,e)?this._balanceNamespaceList(i,e):(this.newHostElements.set(e,i),this.collectEnterElement(e)),this._namespaceLookup[t]=i}_balanceNamespaceList(t,e){let i=this._namespaceList,r=this.namespacesByHostElement;if(i.length-1>=0){let a=!1,s=this.driver.getParentElement(e);for(;s;){let l=r.get(s);if(l){let c=i.indexOf(l);i.splice(c+1,0,t),a=!0;break}s=this.driver.getParentElement(s)}a||i.unshift(t)}else i.push(t);return r.set(e,t),t}register(t,e){let i=this._namespaceLookup[t];return i||(i=this.createNamespace(t,e)),i}registerTrigger(t,e,i){let r=this._namespaceLookup[t];r&&r.register(e,i)&&this.totalAnimations++}destroy(t,e){if(!t)return;let i=this._fetchNamespace(t);this.afterFlush(()=>{this.namespacesByHostElement.delete(i.hostElement),delete this._namespaceLookup[t];let r=this._namespaceList.indexOf(i);r>=0&&this._namespaceList.splice(r,1)}),this.afterFlushAnimationsDone(()=>i.destroy(e))}_fetchNamespace(t){return this._namespaceLookup[t]}fetchNamespacesByElement(t){let e=new Set,i=this.statesByElement.get(t);if(i)for(let r of i.values())if(r.namespaceId){let o=this._fetchNamespace(r.namespaceId);o&&e.add(o)}return e}trigger(t,e,i,r){if(Pw(e)){let o=this._fetchNamespace(t);if(o)return o.trigger(e,i,r),!0}return!1}insertNode(t,e,i,r){if(!Pw(e))return;let o=e[Os];if(o&&o.setForRemoval){o.setForRemoval=!1,o.setForMove=!0;let a=this.collectedLeaveElements.indexOf(e);a>=0&&this.collectedLeaveElements.splice(a,1)}if(t){let a=this._fetchNamespace(t);a&&a.insertNode(e,i)}r&&this.collectEnterElement(e)}collectEnterElement(t){this.collectedEnterElements.push(t)}markElementAsDisabled(t,e){e?this.disabledNodes.has(t)||(this.disabledNodes.add(t),Fs(t,yO)):this.disabledNodes.has(t)&&(this.disabledNodes.delete(t),Ah(t,yO))}removeNode(t,e,i,r){if(Pw(e)){let o=t?this._fetchNamespace(t):null;if(o?o.removeNode(e,r):this.markElementAsRemoved(t,e,!1,r),i){let a=this.namespacesByHostElement.get(e);a&&a.id!==t&&a.removeNode(e,r)}}else this._onRemovalComplete(e,r)}markElementAsRemoved(t,e,i,r,o){this.collectedLeaveElements.push(e),e[Os]={namespaceId:t,setForRemoval:r,hasAnimation:i,removedBeforeQueried:!1,previousTriggersValues:o}}listen(t,e,i,r,o){return Pw(e)?this._fetchNamespace(t).listen(e,i,r,o):()=>{}}_buildInstruction(t,e,i,r,o){return t.transition.build(this.driver,t.element,t.fromState.value,t.toState.value,i,r,t.fromState.options,t.toState.options,e,o)}destroyInnerAnimations(t){let e=this.driver.query(t,Ow,!0);e.forEach(i=>this.destroyActiveAnimationsForElement(i)),0!=this.playersByQueriedElement.size&&(e=this.driver.query(t,MO,!0),e.forEach(i=>this.finishActiveQueriedAnimationOnElement(i)))}destroyActiveAnimationsForElement(t){let e=this.playersByElement.get(t);e&&e.forEach(i=>{i.queued?i.markedForDestroy=!0:i.destroy()})}finishActiveQueriedAnimationOnElement(t){let e=this.playersByQueriedElement.get(t);e&&e.forEach(i=>i.finish())}whenRenderingDone(){return new Promise(t=>{if(this.players.length)return _u(this.players).onDone(()=>t());t()})}processLeaveNode(t){let e=t[Os];if(e&&e.setForRemoval){if(t[Os]=d8,e.namespaceId){this.destroyInnerAnimations(t);let i=this._fetchNamespace(e.namespaceId);i&&i.clearElementCache(t)}this._onRemovalComplete(t,e.setForRemoval)}t.classList?.contains(yO)&&this.markElementAsDisabled(t,!1),this.driver.query(t,".ng-animate-disabled",!0).forEach(i=>{this.markElementAsDisabled(i,!1)})}flush(t=-1){let e=[];if(this.newHostElements.size&&(this.newHostElements.forEach((i,r)=>this._balanceNamespaceList(i,r)),this.newHostElements.clear()),this.totalAnimations&&this.collectedEnterElements.length)for(let i=0;i<this.collectedEnterElements.length;i++)Fs(this.collectedEnterElements[i],"ng-star-inserted");if(this._namespaceList.length&&(this.totalQueuedPlayers||this.collectedLeaveElements.length)){let i=[];try{e=this._flushAnimations(i,t)}finally{for(let r=0;r<i.length;r++)i[r]()}}else for(let i=0;i<this.collectedLeaveElements.length;i++)this.processLeaveNode(this.collectedLeaveElements[i]);if(this.totalQueuedPlayers=0,this.collectedEnterElements.length=0,this.collectedLeaveElements.length=0,this._flushFns.forEach(i=>i()),this._flushFns=[],this._whenQuietFns.length){let i=this._whenQuietFns;this._whenQuietFns=[],e.length?_u(e).onDone(()=>{i.forEach(r=>r())}):i.forEach(r=>r())}}reportError(t){throw new bt(3402,!1)}_flushAnimations(t,e){let i=new Xy,r=[],o=new Map,a=[],s=new Map,l=new Map,c=new Map,d=new Set;this.disabledNodes.forEach(ne=>{d.add(ne);let de=this.driver.query(ne,".ng-animate-queued",!0);for(let ue=0;ue<de.length;ue++)d.add(de[ue])});let u=this.bodyNode,p=Array.from(this.statesByElement.keys()),f=qG(p,this.collectedEnterElements),m=new Map,y=0;f.forEach((ne,de)=>{let ue=e8+y++;m.set(de,ue),ne.forEach(Ge=>Fs(Ge,ue))});let M=[],v=new Set,x=new Set;for(let ne=0;ne<this.collectedLeaveElements.length;ne++){let de=this.collectedLeaveElements[ne],ue=de[Os];ue&&ue.setForRemoval&&(M.push(de),v.add(de),ue.hasAnimation?this.driver.query(de,".ng-star-inserted",!0).forEach(Ge=>v.add(Ge)):x.add(de))}let R=new Map,A=qG(p,Array.from(v));A.forEach((ne,de)=>{let ue=CO+y++;R.set(de,ue),ne.forEach(Ge=>Fs(Ge,ue))}),t.push(()=>{f.forEach((ne,de)=>{let ue=m.get(de);ne.forEach(Ge=>Ah(Ge,ue))}),A.forEach((ne,de)=>{let ue=R.get(de);ne.forEach(Ge=>Ah(Ge,ue))}),M.forEach(ne=>{this.processLeaveNode(ne)})});let H=[],te=[];for(let ne=this._namespaceList.length-1;ne>=0;ne--)this._namespaceList[ne].drainQueuedTransitions(e).forEach(ue=>{let Ge=ue.player,Me=ue.element;if(H.push(Ge),this.collectedEnterElements.length){let St=Me[Os];if(St&&St.setForMove){if(St.previousTriggersValues&&St.previousTriggersValues.has(ue.triggerName)){let rn=St.previousTriggersValues.get(ue.triggerName),ve=this.statesByElement.get(ue.element);if(ve&&ve.has(ue.triggerName)){let ht=ve.get(ue.triggerName);ht.value=rn,ve.set(ue.triggerName,ht)}}return void Ge.destroy()}}let Ne=!u||!this.driver.containsElement(u,Me),ct=R.get(Me),wt=m.get(Me),ft=this._buildInstruction(ue,i,wt,ct,Ne);if(ft.errors&&ft.errors.length)return void te.push(ft);if(Ne)return Ge.onStart(()=>sf(Me,ft.fromStyles)),Ge.onDestroy(()=>yc(Me,ft.toStyles)),void r.push(Ge);if(ue.isFallbackTransition)return Ge.onStart(()=>sf(Me,ft.fromStyles)),Ge.onDestroy(()=>yc(Me,ft.toStyles)),void r.push(Ge);let Oe=[];ft.timelines.forEach(St=>{St.stretchStartingKeyframe=!0,this.disabledNodes.has(St.element)||Oe.push(St)}),ft.timelines=Oe,i.append(Me,ft.timelines),a.push({instruction:ft,player:Ge,element:Me}),ft.queriedElements.forEach(St=>os(s,St,[]).push(Ge)),ft.preStyleProps.forEach((St,rn)=>{if(St.size){let ve=l.get(rn);ve||l.set(rn,ve=new Set),St.forEach((ht,mt)=>ve.add(mt))}}),ft.postStyleProps.forEach((St,rn)=>{let ve=c.get(rn);ve||c.set(rn,ve=new Set),St.forEach((ht,mt)=>ve.add(mt))})});if(te.length){let ne=[];te.forEach(de=>{ne.push(new bt(3505,!1))}),H.forEach(de=>de.destroy()),this.reportError(ne)}let K=new Map,Ce=new Map;a.forEach(ne=>{let de=ne.element;i.has(de)&&(Ce.set(de,de),this._beforeAnimationBuild(ne.player.namespaceId,ne.instruction,K))}),r.forEach(ne=>{let de=ne.element;this._getPreviousPlayers(de,!1,ne.namespaceId,ne.triggerName,null).forEach(Ge=>{os(K,de,[]).push(Ge),Ge.destroy()})});let Ze=M.filter(ne=>YG(ne,l,c)),Ie=new Map;WG(Ie,this.driver,x,c,_c).forEach(ne=>{YG(ne,l,c)&&Ze.push(ne)});let re=new Map;f.forEach((ne,de)=>{WG(re,this.driver,new Set(ne),l,Iw)}),Ze.forEach(ne=>{let de=Ie.get(ne),ue=re.get(ne);Ie.set(ne,new Map([...Array.from(de?.entries()??[]),...Array.from(ue?.entries()??[])]))});let ce=[],fe=[],_e={};a.forEach(ne=>{let{element:de,player:ue,instruction:Ge}=ne;if(i.has(de)){if(d.has(de))return ue.onDestroy(()=>yc(de,Ge.toStyles)),ue.disabled=!0,ue.overrideTotalTime(Ge.totalTime),void r.push(ue);let Me=_e;if(Ce.size>1){let ct=de,wt=[];for(;ct=ct.parentNode;){let ft=Ce.get(ct);if(ft){Me=ft;break}wt.push(ct)}wt.forEach(ft=>Ce.set(ft,Me))}let Ne=this._buildAnimation(ue.namespaceId,Ge,K,o,re,Ie);if(ue.setRealPlayer(Ne),Me===_e)ce.push(ue);else{let ct=this.playersByElement.get(Me);ct&&ct.length&&(ue.parentPlayer=_u(ct)),r.push(ue)}}else sf(de,Ge.fromStyles),ue.onDestroy(()=>yc(de,Ge.toStyles)),fe.push(ue),d.has(de)&&r.push(ue)}),fe.forEach(ne=>{let de=o.get(ne.element);if(de&&de.length){let ue=_u(de);ne.setRealPlayer(ue)}}),r.forEach(ne=>{ne.parentPlayer?ne.syncPlayerEvents(ne.parentPlayer):ne.destroy()});for(let ne=0;ne<M.length;ne++){let de=M[ne],ue=de[Os];if(Ah(de,CO),ue&&ue.hasAnimation)continue;let Ge=[];if(s.size){let Ne=s.get(de);Ne&&Ne.length&&Ge.push(...Ne);let ct=this.driver.query(de,MO,!0);for(let wt=0;wt<ct.length;wt++){let ft=s.get(ct[wt]);ft&&ft.length&&Ge.push(...ft)}}let Me=Ge.filter(Ne=>!Ne.destroyed);Me.length?gme(this,de,Me):this.processLeaveNode(de)}return M.length=0,ce.forEach(ne=>{this.players.push(ne),ne.onDone(()=>{ne.destroy();let de=this.players.indexOf(ne);this.players.splice(de,1)}),ne.play()}),ce}elementContainsData(t,e){let i=!1,r=e[Os];return r&&r.setForRemoval&&(i=!0),this.playersByElement.has(e)&&(i=!0),this.playersByQueriedElement.has(e)&&(i=!0),this.statesByElement.has(e)&&(i=!0),this._fetchNamespace(t).elementContainsData(e)||i}afterFlush(t){this._flushFns.push(t)}afterFlushAnimationsDone(t){this._whenQuietFns.push(t)}_getPreviousPlayers(t,e,i,r,o){let a=[];if(e){let s=this.playersByQueriedElement.get(t);s&&(a=s)}else{let s=this.playersByElement.get(t);if(s){let l=!o||o==qy;s.forEach(c=>{c.queued||!l&&c.triggerName!=r||a.push(c)})}}return(i||r)&&(a=a.filter(s=>!(i&&i!=s.namespaceId||r&&r!=s.triggerName))),a}_beforeAnimationBuild(t,e,i){let o=e.element,a=e.isRemovalTransition?void 0:t,s=e.isRemovalTransition?void 0:e.triggerName;for(let l of e.timelines){let c=l.element,d=c!==o,u=os(i,c,[]);this._getPreviousPlayers(c,d,a,s,e.toState).forEach(f=>{let m=f.getRealPlayer();m.beforeDestroy&&m.beforeDestroy(),f.destroy(),u.push(f)})}sf(o,e.fromStyles)}_buildAnimation(t,e,i,r,o,a){let s=e.triggerName,l=e.element,c=[],d=new Set,u=new Set,p=e.timelines.map(m=>{let y=m.element;d.add(y);let M=y[Os];if(M&&M.removedBeforeQueried)return new gu(m.duration,m.delay);let v=y!==l,x=function(n){let t=[];return u8(n,t),t}((i.get(y)||ume).map(K=>K.getRealPlayer())).filter(K=>!!K.element&&K.element===y),R=o.get(y),A=a.get(y),H=XG(0,this._normalizer,0,m.keyframes,R,A),te=this._buildPlayer(m,H,x);if(m.subTimeline&&r&&u.add(y),v){let K=new Ky(t,s,y);K.setRealPlayer(te),c.push(K)}return te});c.forEach(m=>{os(this.playersByQueriedElement,m.element,[]).push(m),m.onDone(()=>function(n,t,e){let i=n.get(t);if(i){if(i.length){let r=i.indexOf(e);i.splice(r,1)}0==i.length&&n.delete(t)}return i}(this.playersByQueriedElement,m.element,m))}),d.forEach(m=>Fs(m,LG));let f=_u(p);return f.onDestroy(()=>{d.forEach(m=>Ah(m,LG)),yc(l,e.toStyles)}),u.forEach(m=>{os(r,m,[]).push(f)}),f}_buildPlayer(t,e,i){return e.length>0?this.driver.animate(t.element,e,t.duration,t.delay,t.easing,i):new gu(t.duration,t.delay)}}(t,e,i),this._timelineEngine=new class{constructor(t,e,i){this.bodyNode=t,this._driver=e,this._normalizer=i,this._animations=new Map,this._playersById=new Map,this.players=[]}register(t,e){let i=[],r=[],o=l8(this._driver,e,i,r);if(i.length)throw new bt(3503,!1);this._animations.set(t,o)}_buildPlayer(t,e,i){let r=t.element,o=XG(0,this._normalizer,0,t.keyframes,e,i);return this._driver.animate(r,o,t.duration,t.delay,t.easing,[],!0)}create(t,e,i={}){let a,r=[],o=this._animations.get(t),s=new Map;if(o?(a=c8(this._driver,e,o,e8,CO,new Map,new Map,i,ame,r),a.forEach(d=>{let u=os(s,d.element,new Map);d.postStyleProps.forEach(p=>u.set(p,null))})):(r.push(new bt(3300,!1)),a=[]),r.length)throw new bt(3504,!1);s.forEach((d,u)=>{d.forEach((p,f)=>{d.set(f,this._driver.computeStyle(u,f,_c))})});let c=_u(a.map(d=>{let u=s.get(d.element);return this._buildPlayer(d,new Map,u)}));return this._playersById.set(t,c),c.onDestroy(()=>this.destroy(t)),this.players.push(c),c}destroy(t){let e=this._getPlayer(t);e.destroy(),this._playersById.delete(t);let i=this.players.indexOf(e);i>=0&&this.players.splice(i,1)}_getPlayer(t){let e=this._playersById.get(t);if(!e)throw new bt(3301,!1);return e}listen(t,e,i,r){let o=NO(e,"","","");return LO(this._getPlayer(t),i,o,r),()=>{}}command(t,e,i,r){if("register"==i)return void this.register(t,r[0]);if("create"==i)return void this.create(t,e,r[0]||{});let o=this._getPlayer(t);switch(i){case"play":o.play();break;case"pause":o.pause();break;case"reset":o.reset();break;case"restart":o.restart();break;case"finish":o.finish();break;case"init":o.init();break;case"setPosition":o.setPosition(parseFloat(r[0]));break;case"destroy":this.destroy(t)}}}(t,e,i),this._transitionEngine.onRemovalComplete=(r,o)=>this.onRemovalComplete(r,o)}registerTrigger(t,e,i,r,o){let a=t+"-"+r,s=this._triggerCache[a];if(!s){let l=[],c=[],d=l8(this._driver,o,l,c);if(l.length)throw new bt(3404,!1);s=function(n,t,e){return new class{constructor(t,e,i){this.name=t,this.ast=e,this._normalizer=i,this.transitionFactories=[],this.states=new Map,e.states.forEach(r=>{let o=r.options&&r.options.params||{};this.states.set(r.name,new class{constructor(t,e,i){this.styles=t,this.defaultParams=e,this.normalizer=i}buildStyles(t,e){let i=new Map,r=$y(this.defaultParams);return Object.keys(t).forEach(o=>{let a=t[o];null!==a&&(r[o]=a)}),this.styles.styles.forEach(o=>{"string"!=typeof o&&o.forEach((a,s)=>{a&&(a=Yy(a,r,e));let l=this.normalizer.normalizePropertyName(s,e);a=this.normalizer.normalizeStyleValue(s,l,a,e),i.set(s,a)})}),i}}(r.style,o,i))}),UG(this.states,"true","1"),UG(this.states,"false","0"),e.transitions.forEach(r=>{this.transitionFactories.push(new Hw(t,r,this.states))}),this.fallbackTransition=function(n,t,e){return new Hw(n,{type:1,animation:{type:2,steps:[],options:null},matchers:[(a,s)=>!0],options:null,queryCount:0,depCount:0},t)}(t,this.states)}get containsQueries(){return this.ast.queryCount>0}matchTransition(t,e,i,r){return this.transitionFactories.find(a=>a.match(t,e,i,r))||null}matchStyles(t,e,i){return this.fallbackTransition.buildStyles(t,e,i)}}(n,t,e)}(r,d,this._normalizer),this._triggerCache[a]=s}this._transitionEngine.registerTrigger(e,r,s)}register(t,e){this._transitionEngine.register(t,e)}destroy(t,e){this._transitionEngine.destroy(t,e)}onInsert(t,e,i,r){this._transitionEngine.insertNode(t,e,i,r)}onRemove(t,e,i,r){this._transitionEngine.removeNode(t,e,r||!1,i)}disableAnimations(t,e){this._transitionEngine.markElementAsDisabled(t,e)}process(t,e,i,r){if("@"==i.charAt(0)){let[o,a]=OG(i);this._timelineEngine.command(o,e,a,r)}else this._transitionEngine.trigger(t,e,i,r)}listen(t,e,i,r,o){if("@"==i.charAt(0)){let[a,s]=OG(i);return this._timelineEngine.listen(a,e,s,o)}return this._transitionEngine.listen(t,e,i,r,o)}flush(t=-1){this._transitionEngine.flush(t)}get players(){return this._transitionEngine.players.concat(this._timelineEngine.players)}whenRenderingDone(){return this._transitionEngine.whenRenderingDone()}},vme=(()=>{class n{constructor(e,i,r){this._element=e,this._startStyles=i,this._endStyles=r,this._state=0;let o=n.initialStylesByElement.get(e);o||n.initialStylesByElement.set(e,o=new Map),this._initialStyles=o}start(){this._state<1&&(this._startStyles&&yc(this._element,this._startStyles,this._initialStyles),this._state=1)}finish(){this.start(),this._state<2&&(yc(this._element,this._initialStyles),this._endStyles&&(yc(this._element,this._endStyles),this._endStyles=null),this._state=1)}destroy(){this.finish(),this._state<3&&(n.initialStylesByElement.delete(this._element),this._startStyles&&(sf(this._element,this._startStyles),this._endStyles=null),this._endStyles&&(sf(this._element,this._endStyles),this._endStyles=null),yc(this._element,this._initialStyles),this._state=3)}}return n.initialStylesByElement=new WeakMap,n})();function vO(n){let t=null;return n.forEach((e,i)=>{(function(n){return"display"===n||"position"===n})(i)&&(t=t||new Map,t.set(i,e))}),t}var zw=class{constructor(t,e,i,r){this.element=t,this.keyframes=e,this.options=i,this._specialStyles=r,this._onDoneFns=[],this._onStartFns=[],this._onDestroyFns=[],this._initialized=!1,this._finished=!1,this._started=!1,this._destroyed=!1,this._originalOnDoneFns=[],this._originalOnStartFns=[],this.time=0,this.parentPlayer=null,this.currentSnapshot=new Map,this._duration=i.duration,this._delay=i.delay||0,this.time=this._duration+this._delay}_onFinish(){this._finished||(this._finished=!0,this._onDoneFns.forEach(t=>t()),this._onDoneFns=[])}init(){this._buildPlayer(),this._preparePlayerBeforeStart()}_buildPlayer(){if(this._initialized)return;this._initialized=!0;let t=this.keyframes;this.domPlayer=this._triggerWebAnimation(this.element,t,this.options),this._finalKeyframe=t.length?t[t.length-1]:new Map,this.domPlayer.addEventListener("finish",()=>this._onFinish())}_preparePlayerBeforeStart(){this._delay?this._resetDomPlayerState():this.domPlayer.pause()}_convertKeyframesToObject(t){let e=[];return t.forEach(i=>{e.push(Object.fromEntries(i))}),e}_triggerWebAnimation(t,e,i){return t.animate(this._convertKeyframesToObject(e),i)}onStart(t){this._originalOnStartFns.push(t),this._onStartFns.push(t)}onDone(t){this._originalOnDoneFns.push(t),this._onDoneFns.push(t)}onDestroy(t){this._onDestroyFns.push(t)}play(){this._buildPlayer(),this.hasStarted()||(this._onStartFns.forEach(t=>t()),this._onStartFns=[],this._started=!0,this._specialStyles&&this._specialStyles.start()),this.domPlayer.play()}pause(){this.init(),this.domPlayer.pause()}finish(){this.init(),this._specialStyles&&this._specialStyles.finish(),this._onFinish(),this.domPlayer.finish()}reset(){this._resetDomPlayerState(),this._destroyed=!1,this._finished=!1,this._started=!1,this._onStartFns=this._originalOnStartFns,this._onDoneFns=this._originalOnDoneFns}_resetDomPlayerState(){this.domPlayer&&this.domPlayer.cancel()}restart(){this.reset(),this.play()}hasStarted(){return this._started}destroy(){this._destroyed||(this._destroyed=!0,this._resetDomPlayerState(),this._onFinish(),this._specialStyles&&this._specialStyles.destroy(),this._onDestroyFns.forEach(t=>t()),this._onDestroyFns=[])}setPosition(t){void 0===this.domPlayer&&this.init(),this.domPlayer.currentTime=t*this.time}getPosition(){return this.domPlayer.currentTime/this.time}get totalTime(){return this._delay+this._duration}beforeDestroy(){let t=new Map;this.hasStarted()&&this._finalKeyframe.forEach((i,r)=>{"offset"!==r&&t.set(r,this._finished?i:r8(this.element,r))}),this.currentSnapshot=t}triggerCallback(t){let e="start"===t?this._onStartFns:this._onDoneFns;e.forEach(i=>i()),e.length=0}},Mme=(()=>{class n extends Uy{constructor(e,i){super(),this._nextAnimationId=0,this._renderer=e.createRenderer(i.body,{id:"0",encapsulation:es.None,styles:[],data:{animation:[]}})}build(e){let i=this._nextAnimationId.toString();this._nextAnimationId++;let r=Array.isArray(e)?Dw(e):e;return f8(this._renderer,null,i,"register",[r]),new UO(i,this._renderer)}}return n.\u0275fac=function(e){return new(e||n)(O(cc),O(kt))},n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})(),UO=class extends Tw{constructor(t,e){super(),this._id=t,this._renderer=e}create(t,e){return new jO(this._id,t,e||{},this._renderer)}},jO=class{constructor(t,e,i,r){this.id=t,this.element=e,this._renderer=r,this.parentPlayer=null,this._started=!1,this.totalTime=0,this._command("create",i)}_listen(t,e){return this._renderer.listen(this.element,`@@${this.id}:${t}`,e)}_command(t,...e){return f8(this._renderer,this.element,this.id,t,e)}onDone(t){this._listen("done",t)}onStart(t){this._listen("start",t)}onDestroy(t){this._listen("destroy",t)}init(){this._command("init")}hasStarted(){return this._started}play(){this._command("play"),this._started=!0}pause(){this._command("pause")}restart(){this._command("restart")}finish(){this._command("finish")}destroy(){this._command("destroy")}reset(){this._command("reset"),this._started=!1}setPosition(t){this._command("setPosition",t)}getPosition(){return this._renderer.engine.players[+this.id]?.getPosition()??0}};function f8(n,t,e,i,r){return n.setProperty(t,`@@${e}:${i}`,r)}var m8="@.disabled",wme=(()=>{class n{constructor(e,i,r){this.delegate=e,this.engine=i,this._zone=r,this._currentId=0,this._microtaskId=1,this._animationCallbacksBuffer=[],this._rendererCache=new Map,this._cdRecurDepth=0,this.promise=Promise.resolve(0),i.onRemovalComplete=(o,a)=>{let s=a?.parentNode(o);s&&a.removeChild(s,o)}}createRenderer(e,i){let o=this.delegate.createRenderer(e,i);if(!(e&&i&&i.data&&i.data.animation)){let d=this._rendererCache.get(o);return d||(d=new Gw("",o,this.engine,()=>this._rendererCache.delete(o)),this._rendererCache.set(o,d)),d}let a=i.id,s=i.id+"-"+this._currentId;this._currentId++,this.engine.register(s,e);let l=d=>{Array.isArray(d)?d.forEach(l):this.engine.registerTrigger(a,s,e,d.name,d)};return i.data.animation.forEach(l),new GO(this,s,o,this.engine)}begin(){this._cdRecurDepth++,this.delegate.begin&&this.delegate.begin()}_scheduleCountTask(){this.promise.then(()=>{this._microtaskId++})}scheduleListenerCallback(e,i,r){e>=0&&e<this._microtaskId?this._zone.run(()=>i(r)):(0==this._animationCallbacksBuffer.length&&Promise.resolve(null).then(()=>{this._zone.run(()=>{this._animationCallbacksBuffer.forEach(o=>{let[a,s]=o;a(s)}),this._animationCallbacksBuffer=[]})}),this._animationCallbacksBuffer.push([i,r]))}end(){this._cdRecurDepth--,0==this._cdRecurDepth&&this._zone.runOutsideAngular(()=>{this._scheduleCountTask(),this.engine.flush(this._microtaskId)}),this.delegate.end&&this.delegate.end()}whenRenderingDone(){return this.engine.whenRenderingDone()}}return n.\u0275fac=function(e){return new(e||n)(O(cc),O(yu),O(at))},n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})(),Gw=class{constructor(t,e,i,r){this.namespaceId=t,this.delegate=e,this.engine=i,this._onDestroy=r,this.destroyNode=this.delegate.destroyNode?o=>e.destroyNode(o):null}get data(){return this.delegate.data}destroy(){this.engine.destroy(this.namespaceId,this.delegate),this.delegate.destroy(),this._onDestroy?.()}createElement(t,e){return this.delegate.createElement(t,e)}createComment(t){return this.delegate.createComment(t)}createText(t){return this.delegate.createText(t)}appendChild(t,e){this.delegate.appendChild(t,e),this.engine.onInsert(this.namespaceId,e,t,!1)}insertBefore(t,e,i,r=!0){this.delegate.insertBefore(t,e,i),this.engine.onInsert(this.namespaceId,e,t,r)}removeChild(t,e,i){this.engine.onRemove(this.namespaceId,e,this.delegate,i)}selectRootElement(t,e){return this.delegate.selectRootElement(t,e)}parentNode(t){return this.delegate.parentNode(t)}nextSibling(t){return this.delegate.nextSibling(t)}setAttribute(t,e,i,r){this.delegate.setAttribute(t,e,i,r)}removeAttribute(t,e,i){this.delegate.removeAttribute(t,e,i)}addClass(t,e){this.delegate.addClass(t,e)}removeClass(t,e){this.delegate.removeClass(t,e)}setStyle(t,e,i,r){this.delegate.setStyle(t,e,i,r)}removeStyle(t,e,i){this.delegate.removeStyle(t,e,i)}setProperty(t,e,i){"@"==e.charAt(0)&&e==m8?this.disableAnimations(t,!!i):this.delegate.setProperty(t,e,i)}setValue(t,e){this.delegate.setValue(t,e)}listen(t,e,i){return this.delegate.listen(t,e,i)}disableAnimations(t,e){this.engine.disableAnimations(t,e)}},GO=class extends Gw{constructor(t,e,i,r,o){super(e,i,r,o),this.factory=t,this.namespaceId=e}setProperty(t,e,i){"@"==e.charAt(0)?"."==e.charAt(1)&&e==m8?this.disableAnimations(t,i=void 0===i||!!i):this.engine.process(this.namespaceId,t,e.slice(1),i):this.delegate.setProperty(t,e,i)}listen(t,e,i){if("@"==e.charAt(0)){let r=function(n){switch(n){case"body":return document.body;case"document":return document;case"window":return window;default:return n}}(t),o=e.slice(1),a="";return"@"!=o.charAt(0)&&([o,a]=function(n){let t=n.indexOf(".");return[n.substring(0,t),n.slice(t+1)]}(o)),this.engine.listen(this.namespaceId,r,o,a,s=>{this.factory.scheduleListenerCallback(s._data||-1,i,s)})}return this.delegate.listen(t,e,i)}},Tme=(()=>{class n extends yu{constructor(e,i,r,o){super(e.body,i,r)}ngOnDestroy(){this.flush()}}return n.\u0275fac=function(e){return new(e||n)(O(kt),O(Jy),O(lf),O(gc))},n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})(),h8=[{provide:Uy,useClass:Mme},{provide:lf,useFactory:function(){return new Vw}},{provide:yu,useClass:Tme},{provide:cc,useFactory:function(n,t,e){return new wme(n,t,e)},deps:[By,yu,at]}],p8=[{provide:Jy,useFactory:()=>new class{validateStyleProperty(t){return!0}validateAnimatableStyleProperty(t){return!0}matchesElement(t,e){return!1}containsElement(t,e){return KG(t,e)}getParentElement(t){return BO(t)}query(t,e,i){return JG(t,e,i)}computeStyle(t,e,i){return window.getComputedStyle(t)[e]}animate(t,e,i,r,o,a=[]){let l={duration:i,delay:r,fill:0==r?"both":"forwards"};o&&(l.easing=o);let c=new Map,d=a.filter(f=>f instanceof zw);(function(n,t){return 0===n||0===t})(i,r)&&d.forEach(f=>{f.currentSnapshot.forEach((m,y)=>c.set(y,m))});let u=(n=e,n.length?n[0]instanceof Map?n:n.map(t=>t8(t)):[]).map(f=>Rh(f));var n;u=function(n,t,e){if(e.size&&t.length){let i=t[0],r=[];if(e.forEach((o,a)=>{i.has(a)||r.push(a),i.set(a,o)}),r.length)for(let o=1;o<t.length;o++){let a=t[o];r.forEach(s=>a.set(s,r8(n,s)))}}return t}(t,u,c);let p=function(n,t){let e=null,i=null;return Array.isArray(t)&&t.length?(e=vO(t[0]),t.length>1&&(i=vO(t[t.length-1]))):t instanceof Map&&(e=vO(t)),e||i?new vme(n,e,i):null}(t,u);return new zw(t,u,l,p)}}},{provide:di,useValue:"BrowserAnimations"},...h8],Ame=[{provide:Jy,useClass:VO},{provide:di,useValue:"NoopAnimations"},...h8],g8=(()=>{class n{static withConfig(e){return{ngModule:n,providers:e.disableAnimations?Ame:p8}}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({providers:p8,imports:[Ew]}),n})(),XO={};function ye(n,t){if(XO[n]=(XO[n]||0)+1,"function"==typeof t)return WO(n,(...i)=>({...t(...i),type:n}));switch(t?t._as:"empty"){case"empty":return WO(n,()=>({type:n}));case"props":return WO(n,i=>({...i,type:n}));default:throw new Error("Unexpected config.")}}function WO(n,t){return Object.defineProperty(t,"type",{value:n,writable:!1})}var k8="@ngrx/store/init",Oh=(()=>{class n extends Ri{constructor(){super({type:k8})}next(e){if("function"==typeof e)throw new TypeError("\n        Dispatch expected an object, instead it received a function.\n        If you're using the createAction function, make sure to invoke the function\n        before dispatching the action. For example, someAction should be someAction().");if(typeof e>"u")throw new TypeError("Actions must be objects");if(typeof e.type>"u")throw new TypeError("Actions must have a type property");super.next(e)}complete(){}ngOnDestroy(){super.complete()}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})(),Rme=[Oh],P8=new ie("@ngrx/store Internal Root Guard"),_8=new ie("@ngrx/store Internal Initial State"),JO=new ie("@ngrx/store Initial State"),O8=new ie("@ngrx/store Reducer Factory"),y8=new ie("@ngrx/store Internal Reducer Factory Provider"),F8=new ie("@ngrx/store Initial Reducers"),qO=new ie("@ngrx/store Internal Initial Reducers"),b8=new ie("@ngrx/store Store Features"),v8=new ie("@ngrx/store Internal Store Reducers"),YO=new ie("@ngrx/store Internal Feature Reducers"),x8=new ie("@ngrx/store Internal Feature Configs"),L8=new ie("@ngrx/store Internal Store Features"),C8=new ie("@ngrx/store Internal Feature Reducers Token"),N8=new ie("@ngrx/store Feature Reducers"),M8=new ie("@ngrx/store User Provided Meta Reducers"),Ph=new ie("@ngrx/store Meta Reducers"),w8=new ie("@ngrx/store Internal Resolved Meta Reducers"),S8=new ie("@ngrx/store User Runtime Checks Config"),E8=new ie("@ngrx/store Internal User Runtime Checks Config"),eb=new ie("@ngrx/store Internal Runtime Checks"),$O=new ie("@ngrx/store Check if Action types are unique");function cf(n,t={}){let e=Object.keys(n),i={};for(let o=0;o<e.length;o++){let a=e[o];"function"==typeof n[a]&&(i[a]=n[a])}let r=Object.keys(i);return function(a,s){a=void 0===a?t:a;let l=!1,c={};for(let d=0;d<r.length;d++){let u=r[d],f=a[u],m=(0,i[u])(f,s);c[u]=m,l=l||m!==f}return l?c:a}}function B8(...n){return function(t){if(0===n.length)return t;let e=n[n.length-1];return n.slice(0,-1).reduceRight((r,o)=>o(r),e(t))}}function V8(n,t){return Array.isArray(t)&&t.length>0&&(n=B8.apply(null,[...t,n])),(e,i)=>{let r=n(e);return(o,a)=>r(o=void 0===o?i:o,a)}}new ie("@ngrx/store Root Store Provider"),new ie("@ngrx/store Feature State Provider");var tb=class extends en{},Ww=class extends Oh{},qw=(()=>{class n extends Ri{constructor(e,i,r,o){super(o(r,i)),this.dispatcher=e,this.initialState=i,this.reducers=r,this.reducerFactory=o}get currentReducers(){return this.reducers}addFeature(e){this.addFeatures([e])}addFeatures(e){let i=e.reduce((r,{reducers:o,reducerFactory:a,metaReducers:s,initialState:l,key:c})=>{let d="function"==typeof o?function(n){let t=Array.isArray(n)&&n.length>0?B8(...n):e=>e;return(e,i)=>(e=t(e),(r,o)=>e(r=void 0===r?i:r,o))}(s)(o,l):V8(a,s)(o,l);return r[c]=d,r},{});this.addReducers(i)}removeFeature(e){this.removeFeatures([e])}removeFeatures(e){this.removeReducers(e.map(i=>i.key))}addReducer(e,i){this.addReducers({[e]:i})}addReducers(e){this.reducers={...this.reducers,...e},this.updateReducers(Object.keys(e))}removeReducer(e){this.removeReducers([e])}removeReducers(e){e.forEach(i=>{this.reducers=function(n,t){return Object.keys(n).filter(e=>e!==t).reduce((e,i)=>Object.assign(e,{[i]:n[i]}),{})}(this.reducers,i)}),this.updateReducers(e)}updateReducers(e){this.next(this.reducerFactory(this.reducers,this.initialState)),this.dispatcher.next({type:"@ngrx/store/update-reducers",features:e})}ngOnDestroy(){this.complete()}}return n.\u0275fac=function(e){return new(e||n)(O(Ww),O(JO),O(F8),O(O8))},n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})(),Nme=[qw,{provide:tb,useExisting:qw},{provide:Ww,useExisting:Oh}],nb=(()=>{class n extends Ae{ngOnDestroy(){this.complete()}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Cn(n)))(i||n)}}(),n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})(),Bme=[nb],Yw=class extends en{},T8=(()=>{class n extends Ri{constructor(e,i,r,o){super(o);let c=e.pipe(Lp(JA)).pipe(Yt(i)).pipe(function(n,t){return Kt(function(n,t,e,i,r){return(o,a)=>{let s=e,l=t,c=0;o.subscribe(Ht(a,d=>{let u=c++;l=s?n(l,d,u):(s=!0,d),a.next(l)},void 0))}}(n,t,arguments.length>=2))}(Vme,{state:o}));this.stateSubscription=c.subscribe(({state:d,action:u})=>{this.next(d),r.next(u)})}ngOnDestroy(){this.stateSubscription.unsubscribe(),this.complete()}}return n.INIT=k8,n.\u0275fac=function(e){return new(e||n)(O(Oh),O(tb),O(nb),O(JO))},n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})();function Vme(n={state:void 0},[t,e]){let{state:i}=n;return{state:e(i,t),action:t}}var Hme=[T8,{provide:Yw,useExisting:T8}],ke=(()=>{class n extends en{constructor(e,i,r){super(),this.actionsObserver=i,this.reducerManager=r,this.source=e}select(e,...i){return pn.call(null,e,...i)(this)}lift(e){let i=new n(this,this.actionsObserver,this.reducerManager);return i.operator=e,i}dispatch(e){this.actionsObserver.next(e)}next(e){this.actionsObserver.next(e)}error(e){this.actionsObserver.error(e)}complete(){this.actionsObserver.complete()}addReducer(e,i){this.reducerManager.addReducer(e,i)}removeReducer(e){this.reducerManager.removeReducer(e)}}return n.\u0275fac=function(e){return new(e||n)(O(Yw),O(Oh),O(qw))},n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})(),zme=[ke];function pn(n,t,...e){return function(r){let o;if("string"==typeof n){let a=[t,...e].filter(Boolean);o=r.pipe(function(...n){let t=n.length;if(0===t)throw new Error("list of properties cannot be empty.");return U(e=>{let i=e;for(let r=0;r<t;r++){let o=i?.[n[r]];if(!(typeof o<"u"))return;i=o}return i})}(n,...a))}else{if("function"!=typeof n)throw new TypeError(`Unexpected type '${typeof n}' in select operator, expected 'string' or 'function'`);o=r.pipe(U(a=>n(a,t)))}return o.pipe(ui())}}var eF="https://ngrx.io/guide/store/configuration/runtime-checks";function D8(n){return void 0===n}function I8(n){return null===n}function H8(n){return Array.isArray(n)}function z8(n){return"object"==typeof n&&null!==n}function QO(n){return"function"==typeof n}function A8(n,t){return n===t}function U8(n,t=A8,e=A8){let o,i=null,r=null;return{memoized:function(){if(void 0!==o)return o.result;if(!i)return r=n.apply(null,arguments),i=arguments,r;if(!function(n,t,e){for(let i=0;i<n.length;i++)if(!e(n[i],t[i]))return!0;return!1}(arguments,i,t))return r;let d=n.apply(null,arguments);return i=arguments,e(r,d)?r:(r=d,d)},reset:function(){i=null,r=null},setResult:function(d){o={result:d}},clearResult:function(){o=void 0}}}function q(...n){return function(n,t={stateFn:Jme}){return function(...e){let i=e;if(Array.isArray(i[0])){let[d,...u]=i;i=[...d,...u]}else 1===i.length&&function(n){return!!n&&"object"==typeof n&&Object.values(n).every(t=>"function"==typeof t)}(i[0])&&(i=function(n){let t=Object.values(n),e=Object.keys(n);return[...t,(...r)=>e.reduce((o,a,s)=>({...o,[a]:r[s]}),{})]}(i[0]));let r=i.slice(0,i.length-1),o=i[i.length-1],a=r.filter(d=>d.release&&"function"==typeof d.release),s=n(function(...d){return o.apply(null,d)}),l=U8(function(d,u){return t.stateFn.apply(null,[d,r,u,s])});return Object.assign(l.memoized,{release:function(){l.reset(),s.reset(),a.forEach(d=>d.release())},projector:s.memoized,setResult:l.setResult,clearResult:l.clearResult})}}(U8)(...n)}function Jme(n,t,e,i){if(void 0===e){let o=t.map(a=>a(n));return i.memoized.apply(null,o)}let r=t.map(o=>o(n,e));return i.memoized.apply(null,[...r,e])}function Mr(n){return q(t=>t[n],t=>t)}function nhe(n){return n instanceof ie?pi(n):n}function ihe(n,t){return t.map((e,i)=>{if(n[i]instanceof ie){let r=pi(n[i]);return{key:e.key,reducerFactory:r.reducerFactory?r.reducerFactory:cf,metaReducers:r.metaReducers?r.metaReducers:[],initialState:r.initialState}}return e})}function rhe(n){return n.map(t=>t instanceof ie?pi(t):t)}function j8(n){return"function"==typeof n?n():n}function ohe(n,t){return n.concat(t)}function ahe(){if(pi(ke,{optional:!0,skipSelf:!0}))throw new TypeError("The root Store has been provided more than once. Feature modules should provide feature states instead.");return"guarded"}function ZO(n){Object.freeze(n);let t=QO(n);return Object.getOwnPropertyNames(n).forEach(e=>{if(!e.startsWith("\u0275")&&function(n,t){return Object.prototype.hasOwnProperty.call(n,t)}(n,e)&&(!t||"caller"!==e&&"callee"!==e&&"arguments"!==e)){let i=n[e];(z8(i)||QO(i))&&!Object.isFrozen(i)&&ZO(i)}}),n}function KO(n,t=[]){return(D8(n)||I8(n))&&0===t.length?{path:["root"],value:n}:Object.keys(n).reduce((i,r)=>{if(i)return i;let o=n[r];return function(n){return QO(n)&&n.hasOwnProperty("\u0275cmp")}(o)?i:!(D8(o)||I8(o)||function(n){return"number"==typeof n}(o)||function(n){return"boolean"==typeof n}(o)||function(n){return"string"==typeof n}(o)||H8(o))&&(function(n){if(!function(n){return z8(n)&&!H8(n)}(n))return!1;let t=Object.getPrototypeOf(n);return t===Object.prototype||null===t}(o)?KO(o,[...t,r]):{path:[...t,r],value:o})},!1)}function R8(n,t){if(!1===n)return;let e=n.path.join("."),i=new Error(`Detected unserializable ${t} at "${e}". ${eF}#strict${t}serializability`);throw i.value=n.value,i.unserializablePath=e,i}function dhe(n){return{strictStateSerializability:!1,strictActionSerializability:!1,strictStateImmutability:!1,strictActionImmutability:!1,strictActionWithinNgZone:!1,strictActionTypeUniqueness:!1}}function uhe({strictActionSerializability:n,strictStateSerializability:t}){return e=>n||t?function(n,t){return function(e,i){t.action(i)&&R8(KO(i),"action");let r=n(e,i);return t.state()&&R8(KO(r),"state"),r}}(e,{action:i=>n&&!tF(i),state:()=>t}):e}function phe({strictActionImmutability:n,strictStateImmutability:t}){return e=>n||t?function(n,t){return function(e,i){let r=t.action(i)?ZO(i):i,o=n(e,r);return t.state()?ZO(o):o}}(e,{action:i=>n&&!tF(i),state:()=>t}):e}function tF(n){return n.type.startsWith("@ngrx")}function fhe({strictActionWithinNgZone:n}){return t=>n?function(n,t){return function(e,i){if(t.action(i)&&!at.isInAngularZone())throw new Error(`Action '${i.type}' running outside NgZone. ${eF}#strictactionwithinngzone`);return n(e,i)}}(t,{action:e=>n&&!tF(e)}):t}function mhe(n){return[{provide:E8,useValue:n},{provide:S8,useFactory:hhe,deps:[E8]},{provide:eb,deps:[S8],useFactory:dhe},{provide:Ph,multi:!0,deps:[eb],useFactory:phe},{provide:Ph,multi:!0,deps:[eb],useFactory:uhe},{provide:Ph,multi:!0,deps:[eb],useFactory:fhe}]}function G8(){return[{provide:$O,multi:!0,deps:[eb],useFactory:ghe}]}function hhe(n){return n}function ghe(n){if(!n.strictActionTypeUniqueness)return;let t=Object.entries(XO).filter(([,e])=>e>1).map(([e])=>e);if(t.length)throw new Error(`Action types are registered more than once, ${t.map(e=>`"${e}"`).join(", ")}. ${eF}#strictactiontypeuniqueness`)}function _he(n={},t={}){return[{provide:P8,useFactory:ahe},{provide:_8,useValue:t.initialState},{provide:JO,useFactory:j8,deps:[_8]},{provide:qO,useValue:n},{provide:v8,useExisting:n instanceof ie?n:qO},{provide:F8,deps:[qO,[new mh(v8)]],useFactory:nhe},{provide:M8,useValue:t.metaReducers?t.metaReducers:[]},{provide:w8,deps:[Ph,M8],useFactory:ohe},{provide:y8,useValue:t.reducerFactory?t.reducerFactory:cf},{provide:O8,deps:[y8,w8],useFactory:V8},Rme,Nme,Bme,Hme,zme,mhe(t.runtimeChecks),G8()]}function yhe(n,t,e={}){return[{provide:x8,multi:!0,useValue:n instanceof Object?{}:e},{provide:b8,multi:!0,useValue:{key:n instanceof Object?n.name:n,reducerFactory:e instanceof ie||!e.reducerFactory?cf:e.reducerFactory,metaReducers:e instanceof ie||!e.metaReducers?[]:e.metaReducers,initialState:e instanceof ie||!e.initialState?void 0:e.initialState}},{provide:L8,deps:[x8,b8],useFactory:ihe},{provide:YO,multi:!0,useValue:n instanceof Object?n.reducer:t},{provide:C8,multi:!0,useExisting:t instanceof ie?t:YO},{provide:N8,multi:!0,deps:[YO,[new mh(C8)]],useFactory:rhe},G8()]}var ib=(()=>{class n{constructor(e,i,r,o,a,s){}}return n.\u0275fac=function(e){return new(e||n)(O(Oh),O(tb),O(nb),O(ke),O(P8,8),O($O,8))},n.\u0275mod=V({type:n}),n.\u0275inj=B({}),n})(),Xw=(()=>{class n{constructor(e,i,r,o,a){this.features=e,this.featureReducers=i,this.reducerManager=r;let s=e.map((l,c)=>{let u=i.shift()[c];return{...l,reducers:u,initialState:j8(l.initialState)}});r.addFeatures(s)}ngOnDestroy(){this.reducerManager.removeFeatures(this.features)}}return n.\u0275fac=function(e){return new(e||n)(O(L8),O(N8),O(qw),O(ib),O($O,8))},n.\u0275mod=V({type:n}),n.\u0275inj=B({}),n})(),wr=(()=>{class n{static forRoot(e,i){return{ngModule:ib,providers:[..._he(e,i)]}}static forFeature(e,i,r={}){return{ngModule:Xw,providers:[...yhe(e,i,r)]}}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({}),n})();function Ee(...n){return{reducer:n.pop(),types:n.map(i=>i.type)}}function _r(n,...t){let e=new Map;for(let i of t)for(let r of i.types){let o=e.get(r);e.set(r,o?(s,l)=>i.reducer(o(s,l),l):i.reducer)}return function(i=n,r){let o=e.get(r.type);return o?o(i,r):i}}var bhe={dispatch:!0,functional:!1,useEffectsErrorHandler:!0},Zw="__@ngrx/effects_create__";function Or(n,t={}){let e=t.functional?n:n(),i={...bhe,...t};return Object.defineProperty(e,Zw,{value:i}),e}function X8(n){return Object.getPrototypeOf(n)}function Q8(n){return"function"==typeof n}function W8(n){return n.filter(Q8)}function Mhe(n,t,e){let i=X8(n).constructor.name,r=function(n){return function(n){return Object.getOwnPropertyNames(n).filter(i=>!(!n[i]||!n[i].hasOwnProperty(Zw))&&n[i][Zw].hasOwnProperty("dispatch")).map(i=>({propertyName:i,...n[i][Zw]}))}(n)}(n).map(({propertyName:o,dispatch:a,useEffectsErrorHandler:s})=>{let l="function"==typeof n[o]?n[o]():n[o],c=s?e(l,t):l;return!1===a?c.pipe(z_()):c.pipe(Kt((n,t)=>{n.subscribe(Ht(t,e=>{t.next(vs.createNext(e))},()=>{t.next(vs.createComplete()),t.complete()},e=>{t.next(vs.createError(e)),t.complete()}))})).pipe(U(u=>({effect:n[o],notification:u,propertyName:o,sourceName:i,sourceInstance:n})))});return cn(...r)}var whe=10;function Z8(n,t,e=whe){return n.pipe(fo(i=>(t&&t.handleError(i),e<=1?n:Z8(n,t,e-1))))}var Wo=(()=>{class n extends en{constructor(e){super(),e&&(this.source=e)}lift(e){let i=new n;return i.source=this,i.operator=e,i}}return n.\u0275fac=function(e){return new(e||n)(O(nb))},n.\u0275prov=pe({token:n,factory:n.\u0275fac,providedIn:"root"}),n})();function wi(...n){return Ve(t=>n.some(e=>"string"==typeof e?e===t.type:e.type===t.type))}var K8=new ie("@ngrx/effects Internal Root Guard"),Qw=new ie("@ngrx/effects User Provided Effects"),nF=new ie("@ngrx/effects Internal Root Effects"),J8=new ie("@ngrx/effects Internal Root Effects Instances"),q8=new ie("@ngrx/effects Internal Feature Effects"),$8=new ie("@ngrx/effects Internal Feature Effects Instance Groups"),She=new ie("@ngrx/effects Effects Error Handler",{providedIn:"root",factory:()=>Z8}),e6="@ngrx/effects/init";ye(e6);var Ahe="ngrxOnIdentifyEffects",Ohe="ngrxOnInitEffects";function Fhe(n){return iF(n,Ohe)}function iF(n,t){return n&&t in n&&"function"==typeof n[t]}var t6=(()=>{class n extends Ae{constructor(e,i){super(),this.errorHandler=e,this.effectsErrorHandler=i}addEffects(e){this.next(e)}toActions(){return this.pipe(UC(e=>function(n){return"Object"!==n.constructor.name&&"Function"!==n.constructor.name}(e)?X8(e):e),hn(e=>e.pipe(UC(Lhe))),hn(e=>{let i=e.pipe(HC(o=>function(n,t){return e=>{let i=Mhe(e,n,t);return function(n){return iF(n,"ngrxOnRunEffects")}(e)?e.ngrxOnRunEffects(i):i}}(this.errorHandler,this.effectsErrorHandler)(o)),U(o=>(function(n,t){if("N"===n.notification.kind){let e=n.notification.value;!function(n){return"function"!=typeof n&&n&&n.type&&"string"==typeof n.type}(e)&&t.handleError(new Error(`Effect ${function({propertyName:n,sourceInstance:t,sourceName:e}){let i="function"==typeof t[n];return`"${e}.${String(n)}${i?"()":""}"`}(n)} dispatched an invalid action: ${function(n){try{return JSON.stringify(n)}catch{return n}}(e)}`))}}(o,this.errorHandler),o.notification)),Ve(o=>"N"===o.kind&&null!=o.value),Kt((n,t)=>{n.subscribe(Ht(t,e=>nR(e,t)))}));return cn(i,e.pipe(zt(1),Ve(Fhe),U(o=>o.ngrxOnInitEffects())))}))}}return n.\u0275fac=function(e){return new(e||n)(O(ca),O(She))},n.\u0275prov=pe({token:n,factory:n.\u0275fac,providedIn:"root"}),n})();function Lhe(n){return function(n){return iF(n,Ahe)}(n)?n.ngrxOnIdentifyEffects():""}var n6=(()=>{class n{constructor(e,i){this.effectSources=e,this.store=i,this.effectsSubscription=null}get isStarted(){return!!this.effectsSubscription}start(){this.effectsSubscription||(this.effectsSubscription=this.effectSources.toActions().subscribe(this.store))}ngOnDestroy(){this.effectsSubscription&&(this.effectsSubscription.unsubscribe(),this.effectsSubscription=null)}}return n.\u0275fac=function(e){return new(e||n)(O(t6),O(ke))},n.\u0275prov=pe({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),i6=(()=>{class n{constructor(e,i,r,o,a,s,l){this.sources=e,i.start();for(let c of o)e.addEffects(c);r.dispatch({type:e6})}addEffects(e){this.sources.addEffects(e)}}return n.\u0275fac=function(e){return new(e||n)(O(t6),O(n6),O(ke),O(J8),O(ib,8),O(Xw,8),O(K8,8))},n.\u0275mod=V({type:n}),n.\u0275inj=B({}),n})(),Bhe=(()=>{class n{constructor(e,i,r,o){let a=i.flat();for(let s of a)e.addEffects(s)}}return n.\u0275fac=function(e){return new(e||n)(O(i6),O($8),O(ib,8),O(Xw,8))},n.\u0275mod=V({type:n}),n.\u0275inj=B({}),n})(),wo=(()=>{class n{static forFeature(...e){let i=e.flat(),r=W8(i);return{ngModule:Bhe,providers:[r,{provide:q8,multi:!0,useValue:i},{provide:Qw,multi:!0,useValue:[]},{provide:$8,multi:!0,useFactory:Y8,deps:[q8,Qw]}]}}static forRoot(...e){let i=e.flat(),r=W8(i);return{ngModule:i6,providers:[r,{provide:nF,useValue:[i]},{provide:K8,useFactory:Vhe},{provide:Qw,multi:!0,useValue:[]},{provide:J8,useFactory:Y8,deps:[nF,Qw]}]}}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({}),n})();function Y8(n,t){let e=[];for(let i of n)e.push(...i);for(let i of t)e.push(...i);return e.map(i=>Q8(i)?pi(i):i)}function Vhe(){let n=pi(n6,{optional:!0,skipSelf:!0}),t=pi(nF,{self:!0});if((1!==t.length||0!==t[0].length)&&n)throw new TypeError("EffectsModule.forRoot() called twice. Feature modules should use EffectsModule.forFeature() instead.");return"guarded"}var kn=(()=>{return(n=kn||(kn={}))[n.UNKNOWN=0]="UNKNOWN",n[n.EXPERIMENTS=1]="EXPERIMENTS",n[n.EXPERIMENT=2]="EXPERIMENT",n[n.COMPARE_EXPERIMENT=3]="COMPARE_EXPERIMENT",n[n.CARD=4]="CARD",n[n.NOT_SET=5]="NOT_SET",kn;var n})(),Kw="defaultExperimentId",Fh=(()=>{return(n=Fh||(Fh={}))[n.EXPERIMENTS=0]="EXPERIMENTS",n[n.DASHBOARD=1]="DASHBOARD",Fh;var n})();function Lh(n){return n.split(",").map(t=>{let e=t.indexOf(":");if(e<0)throw new Error(`Expect colon delimiting name and ID: ${t}`);let i=t.slice(0,e),r=t.slice(e+1);if(!r)throw new Error(`Expect id to be non-falsy: ${t}`);return{name:i,id:r}})}function r6(n){return n.map(({alias:t,id:e})=>`${t}:${e}`).join(",")}function rb(n,t){switch(n){case kn.EXPERIMENT:return Object.prototype.hasOwnProperty.call(t,"experimentId")?[t.experimentId]:[Kw];case kn.CARD:{let e=t.experimentIds;return e.indexOf(",")<0?[e]:Lh(e).map(({id:i})=>i)}case kn.COMPARE_EXPERIMENT:return Lh(t.experimentIds).map(({id:i})=>i);default:return null}}function Lo(n,t){if(!n||!t)return n===t;if(n.routeKind!==t.routeKind)return!1;let e=rb(n.routeKind,n.params),i=rb(t.routeKind,t.params);if(null===e||null===i)return e===i;if(e.length!==i.length)return!1;let r=i.sort();return e.sort().every((o,a)=>r[a]===o)}function rF(n){switch(n){case kn.EXPERIMENTS:return Fh.EXPERIMENTS;case kn.EXPERIMENT:case kn.CARD:case kn.COMPARE_EXPERIMENT:return Fh.DASHBOARD;case kn.UNKNOWN:case kn.NOT_SET:return null}}function Jw(n,t,e){let i=rF(n);return null!==i&&!e.some(r=>r.deepLinkGroup===i&&r.namespaceId===t)}var l6_getHref=()=>window.location.href,df=(()=>{class n{getHref(){return l6_getHref()}getSearch(){let e=new URLSearchParams(window.location.search),i=[];return e.forEach((r,o)=>{i.push({key:o,value:r})}),i}getHash(){return window.location.hash}getPath(){return window.location.pathname}getHistoryState(){return window.history.state}replaceStateUrl(e){window.history.replaceState(window.history.state,"",e)}pushStateUrl(e){window.history.pushState(null,"",e)}replaceStateData(e){window.history.replaceState(e,"")}onPopState(){return ai(window,"popstate").pipe(U(e=>({pathname:this.getPath(),state:e.state})))}getResolvedPath(e){return new URL(e,l6_getHref()).pathname}getFullPath(e,i,r){let o=this.getResolvedPath(e),a="";return i.length&&(a="?"+function(n){let t=new URLSearchParams;for(let{key:e,value:i}of n)t.append(e,i);return t}(i).toString()),`${o}${a}${r?this.getHash():""}`}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})(),uf=(()=>{class n{constructor(e){this.appRoot=this.getAppRootFromMetaElement(e)}getAppRootFromMetaElement(e){let i=document.querySelector('head meta[name="tb-relative-root"]');if(!i)return"/";let{pathname:r}=new URL(i.content,e.getHref());return r.replace(/\/*$/,"/")}getAbsPathnameWithAppRoot(e){return this.appRoot.slice(0,-1)+e}getAppRootlessPathname(e){return e.startsWith(this.appRoot)?"/"+e.slice(this.appRoot.length):e}}return n.\u0275fac=function(e){return new(e||n)(O(df))},n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})(),Nh=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({providers:[df]}),n})(),Bh=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({providers:[uf],imports:[Nh]}),n})(),sF=new ie("[App Routing] Dirty Updates"),$w=(()=>{class n{constructor(e){this.dirtyUpdatesSelectorFactories=e}getDirtyUpdatesSelectors(){return this.dirtyUpdatesSelectorFactories??[]}static registerDirtyUpdates(e){return{ngModule:n,providers:[{provide:sF,multi:!0,useFactory:e}]}}}return n.\u0275fac=function(e){return new(e||n)(O(sF,8))},n.\u0275mod=V({type:n}),n.\u0275inj=B({}),n})(),c6=ye("[App Routing] Discarding Unsaved Updates"),Vh=ye("[App Routing] State Rehydrated From Url",{_as:"props",_p:void 0}),eS=ye("[App Routing] Route Config Loaded",{_as:"props",_p:void 0}),lF=ye("[App Routing] In App Navigation Requested",{_as:"props",_p:void 0}),Hh=ye("[App Routing] In App Navigating",{_as:"props",_p:void 0}),Ls=ye("[App Routing] In App Navigated",{_as:"props",_p:void 0}),dF=new ie("[App Routing] Programmatical Navigation Provider"),tS=(()=>{class n{constructor(e){this.providers=new Map;for(let i of e||[]){if(this.providers.has(i.actionCreator.type))throw new RangeError(`"${i.actionCreator.type}" is already registered for nav. Multiple navigations on same kick is not allowed.`);this.providers.set(i.actionCreator.type,i.lambda)}}getNavigation(e){let i=this.providers.get(e.type);return i?i(e):null}static registerProgrammaticalNavigation(e){return{ngModule:n,providers:[{provide:dF,multi:!0,useFactory:e}]}}}return n.\u0275fac=function(e){return new(e||n)(O(dF,8))},n.\u0275mod=V({type:n}),n.\u0275inj=B({}),n})();function ob(n){return null!=n.routeKind}function fF(n){return p6(n).map(e=>{let i=e.startsWith(":");return i?{pathPart:e,isParam:!0,paramName:e.slice(1)}:{pathPart:e,isParam:i}})}var zh=class{static getMatcher(t){return ob(t)?new ab(t):void 0!==t.redirectionPath?new uF(t):new pF(t)}constructor(t){this.validateConfig(t),this.pathFragments=fF(t.path),this.pathMatchers=this.getPathMatchers(this.pathFragments)}validateConfig({path:t}){if(!t.startsWith("/"))throw new RangeError(`config.path should start with '/'. ${t}`);let e=0;for(;(e=t.indexOf(":",e+1))>=0;){if("/"!==t[e-1])throw new RangeError(`config.path parameter should come after '/'. ${t}`);if(void 0===t[e+1]||"/"===t[e+1])throw new RangeError(`config.path parameter should have non-empty name. ${t}`)}}getPathMatchers(t){return t.map(e=>{let{pathPart:i}=e;return e.isParam?r=>({isParamPathPart:!0,partMatched:!0,paramName:e.paramName,paramValue:r}):r=>({isParamPathPart:!1,partMatched:r===i})})}match(t){let e={};if(this.pathMatchers.length!==t.length)return{result:!1};let i=0;for(let r of this.pathMatchers){let a=r(t[i++]);if(!a.partMatched)return{result:!1};a.isParamPathPart&&(e={...e,[a.paramName]:a.paramValue})}return{result:!0,params:e,pathParts:t,isRedirection:!1,redirectionQueryParams:void 0}}matchByParams(t){return{result:!0,params:t,pathParts:this.reprojectPathByParams(this.pathFragments,t),isRedirection:!1,redirectionQueryParams:void 0}}reprojectPathByParams(t,e){let i=[];for(let r of t)if(r.isParam){let{paramName:o}=r;if(!e.hasOwnProperty(o))throw new RangeError(`Failed to reproject parameter. "${o}" parameter should be present.`);i.push(e[o])}else i.push(r.pathPart);return i}},ab=class extends zh{constructor(t){super(t),this.definition=t}},uF=class extends zh{constructor(t){super(t),this.definition=t,this.redirectionFragments=fF(t.redirectionPath)}match(t){let e=super.match(t);if(!e.result)return e;let i=this.reprojectPathByParams(this.redirectionFragments,e.params);return{result:!0,params:e.params,pathParts:i,isRedirection:!0,redirectionQueryParams:void 0}}},pF=class extends zh{constructor(t){super(t),this.definition=t}match(t){let e=super.match(t);if(!e.result)return e;let{pathParts:i,queryParams:r}=this.definition.redirector(t);return{result:!0,params:e.params,pathParts:i,isRedirection:!0,redirectionQueryParams:r}}},sb=class{constructor(t,e=3){if(this.maxRedirection=e,e<0)throw new RangeError("maxRedirection has to be non-negative number");this.validateRouteConfigs(t),this.defaultRouteConfig=null,this.routeKindToConcreteConfigMatchers=new Map,this.configMatchers=[];for(let i of t){let r=zh.getMatcher(i);this.configMatchers.push(r),r instanceof ab&&(this.routeKindToConcreteConfigMatchers.set(r.definition.routeKind,r),r.definition.defaultRoute&&(this.defaultRouteConfig=r))}}validateRouteConfigs(t){let e=t.filter(ob),i=e.filter(o=>o.defaultRoute);if(i.length>1){let o=i.map(({path:a})=>a).join(", ");throw new RangeError(`There are more than one defaultRoutes. ${o}`)}if(1===i.length){let{path:o}=i[0];if(Boolean(fF(o).find(({isParam:s})=>s)))throw new RangeError(`A defaultRoute cannot have any params. ${o}`)}let r=new Set;for(let{routeKind:o}of e){if(r.has(o))throw new RangeError(`Multiple route configuration for kind: ${o}. Configurations should have unique routeKinds`);r.add(o)}}generateAction(t,e){return t.actionGenerator?t.actionGenerator(e):null}match(t){if(!t.pathname.startsWith("/"))throw new RangeError('Navigation has to made with pathname that starts with "/"');let o,e=p6(t.pathname),i=0,r=!1;for(;;){let a=!1;for(let s of this.configMatchers){let l=s.match(e);if(l.result){a=!0;let{params:c,pathParts:d,isRedirection:u}=l;if(u){e=d,r=!0,o=l.redirectionQueryParams;break}if(!(s instanceof ab))throw new RangeError("No concrete route definition `match` return redirection");let{definition:p}=s,f={routeKind:p.routeKind,params:c,pathname:u6(d),deepLinkProvider:p.deepLinkProvider||null,action:this.generateAction(p,d)};return r?{...f,originateFromRedirection:!0,redirectionOnlyQueryParams:o}:{...f,originateFromRedirection:!1}}}if(r&&i++,!a||i>this.maxRedirection)break}if(i>this.maxRedirection)throw new Error(`Potential redirection loop (redirecting more than ${this.maxRedirection} times. Please do not have cycles in the routes.`);if(this.defaultRouteConfig){let{definition:a}=this.defaultRouteConfig;return{routeKind:a.routeKind,deepLinkProvider:a.deepLinkProvider??null,pathname:a.path,params:{},originateFromRedirection:!0,redirectionOnlyQueryParams:void 0,action:this.generateAction(a,e)}}return null}matchByRouteKind(t,e){let i=this.routeKindToConcreteConfigMatchers.get(t);if(!i)throw new RangeError(`Requires configuration for routeKind: ${t}`);let r=i.matchByParams(e);return{routeKind:t,params:e,pathname:u6(r.pathParts),deepLinkProvider:i.definition.deepLinkProvider||null,originateFromRedirection:!1,action:this.generateAction(i.definition,r.pathParts)}}};function p6(n){return n.split("/").slice(1)}function u6(n){return"/"+n.join("/")}var mF=new ie("[App Routing] Route Config"),wl=(()=>{class n{constructor(e){if(this.routeKindToNgComponent=new Map,!e)return void(this.routeConfigs=new sb([]));let i=[];for(let r of e)for(let o of r)i.push(o);this.routeConfigs=new sb(i),i.forEach(r=>{ob(r)&&this.routeKindToNgComponent.set(r.routeKind,r.ngComponent)})}getRegisteredRouteKinds(){return this.routeKindToNgComponent.keys()}getRouteConfigs(){return this.routeConfigs}getNgComponentByRouteKind(e){return this.routeKindToNgComponent.get(e)||null}static registerRoutes(e){return{ngModule:n,providers:[{provide:mF,multi:!0,useFactory:e}]}}}return n.\u0275fac=function(e){return new(e||n)(O(mF,8))},n.\u0275mod=V({type:n}),n.\u0275inj=B({}),n})(),nS="app_routing",lb=Mr(nS),fa=q(lb,n=>n.activeRoute),h6=q(lb,n=>n.nextRoute),g6=q(lb,n=>n.activeNamespaceId),_6=q(lb,n=>n.rehydratedDeepLinks),y6=q(lb,n=>n.registeredRouteKeys),Ns=q(fa,n=>n?n.routeKind:kn.NOT_SET),gF=q(fa,n=>n?n.params:{}),ro=q(Ns,gF,(n,t)=>rb(n,t)),Bs=(q(Ns,gF,(n,t)=>{if(n!==kn.COMPARE_EXPERIMENT)return{};let i=function(n){let t=new Map,e=Lh(n.experimentIds);for(let{id:i,name:r}of e)r&&t.set(i,r);return t}(t);return Object.fromEntries(i.entries())}),q(Ns,gF,(n,t)=>{let e=t;if(n!==kn.COMPARE_EXPERIMENT&&(n!==kn.CARD||-1===e.experimentIds.indexOf(",")))return{};let i=function(n){let t=new Map,e=Lh(n.experimentIds),i=0;for(let{id:r,name:o}of e)i++,!t.has(r)&&t.set(r,{aliasText:o,aliasNumber:i});return t}(e);return Object.fromEntries(i.entries())})),_F=ye("[App Routing] Effects Init"),ma=(()=>{return(n=ma||(ma={}))[n.UNCHANGED=0]="UNCHANGED",n[n.NEW=1]="NEW",n[n.FROM_HISTORY=2]="FROM_HISTORY",ma;var n})(),b6=(()=>{class n{constructor(e,i,r,o,a,s,l){this.actions$=e,this.store=i,this.location=r,this.dirtyUpdatesRegistry=o,this.registry=a,this.programmaticalNavModule=s,this.appRootProvider=l,this.onNavigationRequested$=this.actions$.pipe(wi(lF),U(c=>({pathname:c.pathname.startsWith("/")?this.appRootProvider.getAbsPathnameWithAppRoot(c.pathname):this.location.getResolvedPath(c.pathname),options:{browserInitiated:!1,replaceState:c.replaceState??!1,namespaceUpdate:{option:c.resetNamespacedState?ma.NEW:ma.UNCHANGED}}}))),this.bootstrapReducers$=Or(()=>this.actions$.pipe(wi(_F),U(()=>eS({routeKinds:new Set(this.registry.getRegisteredRouteKinds())})))),this.onInit$=this.actions$.pipe(wi(_F)).pipe(xs(0),U(()=>{let c=this.location.getHistoryState()?.namespaceId,d=void 0===c?{option:ma.NEW}:{option:ma.FROM_HISTORY,namespaceId:c};return{pathname:this.location.getPath(),options:{browserInitiated:!0,replaceState:!0,namespaceUpdate:d}}})),this.onPopState$=this.location.onPopState().pipe(U(c=>({pathname:c.pathname,options:{browserInitiated:!0,replaceState:!0,namespaceUpdate:void 0===c.state?.namespaceId?{option:ma.UNCHANGED}:{option:ma.FROM_HISTORY,namespaceId:c.state.namespaceId}}}))),this.userInitNavRoute$=cn(this.onNavigationRequested$,this.onInit$,this.onPopState$).pipe(U(c=>{if(!c.pathname.startsWith("/"))throw new Error(`[App routing] pathname must start with '/'. Got: ${c.pathname}`);return{...c,pathname:this.appRootProvider.getAppRootlessPathname(c.pathname)}}),U(c=>({routeMatch:this.routeConfigs.match(c),options:c.options}))),this.programmaticalNavRoute$=this.actions$.pipe(U(c=>this.programmaticalNavModule.getNavigation(c)),Ve(c=>null!==c),U(c=>{let m,d=c,{replaceState:u=!1,resetNamespacedState:p,routeKind:f}=d;return m=d.routeKind===kn.COMPARE_EXPERIMENT?{experimentIds:r6(d.routeParams.aliasAndExperimentIds)}:d.routeParams,{replaceState:u,routeKind:f,routeParams:m,resetNamespacedState:p}}),U(({replaceState:c,routeKind:d,routeParams:u,resetNamespacedState:p})=>({routeMatch:this.routeConfigs?this.routeConfigs.matchByRouteKind(d,u):null,options:{replaceState:c,browserInitiated:!1,namespaceUpdate:{option:p?ma.NEW:ma.UNCHANGED}}}))),this.validatedRouteMatch$=cn(this.userInitNavRoute$,this.programmaticalNavRoute$).pipe(Ve(({routeMatch:c})=>Boolean(c)),U(({routeMatch:c,options:d})=>({routeMatch:c,options:d}))),this.navigate$=Or(()=>this.validatedRouteMatch$.pipe(Yt(this.store.select(fa)),hn(([u,p])=>{let f=null!==p&&Lo(p,u.routeMatch),m=this.dirtyUpdatesRegistry.getDirtyUpdatesSelectors();return f||!m.length?qt(u):po(this.dirtyUpdatesRegistry.getDirtyUpdatesSelectors().map(y=>this.store.select(y).pipe(zt(1)))).pipe(U(y=>void 0!==y[0].experimentIds&&y[0].experimentIds.length>0),Ve(y=>{if(y){let M=window.confirm("You have unsaved edits, are you sure you want to discard them?");return M&&this.store.dispatch(c6()),M}return!0}),U(()=>u))}),Yt(this.store.select(_6)),Vt(([{routeMatch:u,options:p},f])=>{if(!p.browserInitiated||!u.deepLinkProvider||p.namespaceUpdate.option===ma.FROM_HISTORY&&!Jw(u.routeKind,p.namespaceUpdate.namespaceId,f))return;let m=u.originateFromRedirection&&u.redirectionOnlyQueryParams?u.redirectionOnlyQueryParams:this.location.getSearch(),y=u.deepLinkProvider.deserializeQueryParams(m);this.store.dispatch(Vh({routeKind:u.routeKind,partialState:y}))}),Vt(([{routeMatch:u}])=>{u.action&&this.store.dispatch(u.action)}),yi(([{routeMatch:u,options:p}])=>null===u.deepLinkProvider?qt({route:{routeKind:u.routeKind,params:u.params},pathname:u.pathname,queryParams:[],options:p}):u.deepLinkProvider.serializeStateToQueryParams(this.store).pipe(U((f,m)=>({route:{routeKind:u.routeKind,params:u.params},pathname:u.pathname,queryParams:f,options:0===m?p:{...p,namespaceUpdate:{option:ma.UNCHANGED},replaceState:!0}})))),Vt(({route:u})=>{this.store.dispatch(Hh({after:u}))}),Cr(0)).pipe(Yt(this.store.select(fa)),U(([u,p])=>{let f=null===p||null===u.route||Lo(p,u.route);return{...u,preserveHash:f}}),Vt(({preserveHash:u,pathname:p,queryParams:f,options:m})=>{(function(n,t){return n.pathname===t.pathname&&n.queryParams.length===t.queryParams.length&&n.queryParams.every((e,i)=>{let r=t.queryParams[i];return e.key===r.key&&e.value===r.value})})({pathname:p,queryParams:f},{pathname:this.appRootProvider.getAppRootlessPathname(this.location.getPath()),queryParams:this.location.getSearch()})||(m.replaceState?this.location.replaceStateUrl(this.appRootProvider.getAbsPathnameWithAppRoot(this.location.getFullPath(p,f,u))):this.location.pushStateUrl(this.appRootProvider.getAbsPathnameWithAppRoot(this.location.getFullPath(p,f,u))))})).pipe(Yt(this.store.select(fa),this.store.select(g6)),U(([{route:u,options:p},f,m])=>{let y=function(n,t,e){return t.namespaceUpdate.option===ma.FROM_HISTORY?t.namespaceUpdate.namespaceId:null==e||t.namespaceUpdate.option===ma.NEW?`${Date.now().toString()}:${function(){let n=new Uint8Array(32);crypto.getRandomValues(n);let t="";for(let e of n)t+=(e>>4).toString(16);return t}()}`:e}(0,p,m);return this.location.replaceStateData({...this.location.getHistoryState(),namespaceId:y}),Ls({before:f,after:u,beforeNamespaceId:m,afterNamespaceId:y})}))),this.routeConfigs=a.getRouteConfigs()}ngrxOnInitEffects(){return _F()}}return n.\u0275fac=function(e){return new(e||n)(O(Wo),O(ke),O(df),O($w),O(wl),O(tS),O(uf))},n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})(),Ghe=_r({activeRoute:null,nextRoute:null,activeNamespaceId:null,rehydratedDeepLinks:[],registeredRouteKeys:new Set},Ee(Hh,(n,{after:t})=>({...n,nextRoute:t})),Ee(Ls,(n,{after:t,afterNamespaceId:e})=>{let i=n.rehydratedDeepLinks;return Jw(t.routeKind,e,i)&&(i=[...i],i.push({deepLinkGroup:rF(t.routeKind),namespaceId:e})),{...n,activeRoute:t,nextRoute:null,activeNamespaceId:e,rehydratedDeepLinks:i}}),Ee(eS,(n,{routeKinds:t})=>({...n,registeredRouteKeys:t})));function v6(n,t){return Ghe(n,t)}var Uh=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({providers:[$w,tS],imports:[wl,wr.forFeature(nS,v6),wo.forFeature([b6]),Bh,Nh]}),n})(),x6="__tab__",C6=(()=>{class n{constructor(){this.tfStorage=document.createElement("tf-storage"),document.createElement("tf-globals").tf_globals.setUseHash(!0),this.tfStorage.tf_storage.migrateLegacyURLScheme()}getString(e){return this.tfStorage.tf_storage.getString(e)}setString(e,i,r){this.tfStorage.tf_storage.setString(e,i,r)}getPluginId(){return this.getString(x6)}setPluginId(e,i){this.setString(x6,e,i)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})(),vu=class{},Oa=(()=>{return(n=Oa||(Oa={})).BROWSER_DEFAULT="browser_default",n.LIGHT="light",n.DARK="dark",Oa;var n})(),Sl=ye("[Persistent Settings] Global Settings Loaded",{_as:"props",_p:void 0}),yF=new ie("[Persistent Settings] Global Settings"),er=(()=>{class n{constructor(e){this.globalSettingSelectors=[],e&&(this.globalSettingSelectors=e.map(i=>i()))}getGlobalSettingSelectors(){return this.globalSettingSelectors??[]}static defineGlobalSetting(e){return{ngModule:n,providers:[{provide:yF,multi:!0,useValue:e}]}}}return n.\u0275fac=function(e){return new(e||n)(O(yF,8))},n.\u0275mod=V({type:n}),n.\u0275inj=B({}),n})(),M6="_tb_global_settings.timeseries",w6="_tb_global_settings",S6="notificationLastReadTimestamp",iS=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})(),rS=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})(),bF=(()=>{class n extends rS{uiToBackend(e){let i={};return void 0!==e.ignoreOutliers&&(i.ignoreOutliers=e.ignoreOutliers),void 0!==e.scalarSmoothing&&(i.scalarSmoothing=e.scalarSmoothing),void 0!==e.tooltipSort&&(i.tooltipSort=e.tooltipSort),void 0!==e.autoReload&&(i.autoReload=e.autoReload),void 0!==e.autoReloadPeriodInMs&&(i.autoReloadPeriodInMs=e.autoReloadPeriodInMs),void 0!==e.pageSize&&(i.paginationSize=e.pageSize),void 0!==e.themeOverride&&(i.theme=e.themeOverride),void 0!==e.notificationLastReadTimeInMs&&(i.notificationLastReadTimeInMs=e.notificationLastReadTimeInMs),void 0!==e.sideBarWidthInPercent&&(i.sideBarWidthInPercent=e.sideBarWidthInPercent),void 0!==e.timeSeriesSettingsPaneOpened&&(i.timeSeriesSettingsPaneOpened=e.timeSeriesSettingsPaneOpened),void 0!==e.timeSeriesCardMinWidth&&(i.timeSeriesCardMinWidth=e.timeSeriesCardMinWidth),void 0!==e.stepSelectorEnabled&&(i.stepSelectorEnabled=e.stepSelectorEnabled),void 0!==e.rangeSelectionEnabled&&(i.rangeSelectionEnabled=e.rangeSelectionEnabled),void 0!==e.linkedTimeEnabled&&(i.linkedTimeEnabled=e.linkedTimeEnabled),void 0!==e.singleSelectionHeaders&&(i.singleSelectionHeaders=e.singleSelectionHeaders),void 0!==e.rangeSelectionHeaders&&(i.rangeSelectionHeaders=e.rangeSelectionHeaders),i}backendToUi(e){let i={};return e.hasOwnProperty("scalarSmoothing")&&"number"==typeof e.scalarSmoothing&&(i.scalarSmoothing=e.scalarSmoothing),e.hasOwnProperty("ignoreOutliers")&&"boolean"==typeof e.ignoreOutliers&&(i.ignoreOutliers=e.ignoreOutliers),e.hasOwnProperty("tooltipSort")&&"string"==typeof e.tooltipSort&&(i.tooltipSort=e.tooltipSort),e.hasOwnProperty("autoReload")&&"boolean"==typeof e.autoReload&&(i.autoReload=e.autoReload),e.hasOwnProperty("autoReloadPeriodInMs")&&"number"==typeof e.autoReloadPeriodInMs&&(i.autoReloadPeriodInMs=e.autoReloadPeriodInMs),e.hasOwnProperty("paginationSize")&&"number"==typeof e.paginationSize&&(i.pageSize=e.paginationSize),e.hasOwnProperty("theme")&&"string"==typeof e.theme&&new Set(Object.values(Oa)).has(e.theme)&&(i.themeOverride=e.theme),e.hasOwnProperty("notificationLastReadTimeInMs")&&"number"==typeof e.notificationLastReadTimeInMs&&(i.notificationLastReadTimeInMs=e.notificationLastReadTimeInMs),e.hasOwnProperty("sideBarWidthInPercent")&&"number"==typeof e.sideBarWidthInPercent&&(i.sideBarWidthInPercent=e.sideBarWidthInPercent),e.hasOwnProperty("timeSeriesSettingsPaneOpened")&&"boolean"==typeof e.timeSeriesSettingsPaneOpened&&(i.timeSeriesSettingsPaneOpened=e.timeSeriesSettingsPaneOpened),e.hasOwnProperty("timeSeriesCardMinWidth")&&"number"==typeof e.timeSeriesCardMinWidth&&(i.timeSeriesCardMinWidth=e.timeSeriesCardMinWidth),e.hasOwnProperty("stepSelectorEnabled")&&"boolean"==typeof e.stepSelectorEnabled&&(i.stepSelectorEnabled=e.stepSelectorEnabled),e.hasOwnProperty("rangeSelectionEnabled")&&"boolean"==typeof e.rangeSelectionEnabled&&(i.rangeSelectionEnabled=e.rangeSelectionEnabled),e.hasOwnProperty("linkedTimeEnabled")&&"boolean"==typeof e.linkedTimeEnabled&&(i.linkedTimeEnabled=e.linkedTimeEnabled),Array.isArray(e.singleSelectionHeaders)&&void 0!==e.singleSelectionHeaders[0].name&&(e.singleSelectionHeaders.forEach(r=>{r.movable=r.movable??!0,r.sortable=r.sortable??!0,r.removable=r.removable??!0}),i.singleSelectionHeaders=e.singleSelectionHeaders),Array.isArray(e.rangeSelectionHeaders)&&void 0!==e.rangeSelectionHeaders[0].name&&(e.rangeSelectionHeaders.forEach(r=>{r.movable=r.movable??!0,r.sortable=r.sortable??!0,r.removable=r.removable??!0}),i.rangeSelectionHeaders=e.rangeSelectionHeaders),i}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Cn(n)))(i||n)}}(),n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})(),E6=(()=>{class n{constructor(e){this.converter=e}setSettings(e){return Object.keys(e)?this.getSettings().pipe(Vt(i=>{window.localStorage.setItem(w6,JSON.stringify(this.converter.uiToBackend({...i,...e}))),window.localStorage.removeItem(M6),window.localStorage.removeItem(S6)}),U(()=>{})):to}deserialize(e){try{return JSON.parse(e)}catch{return{}}}getSettings(){let e=window.localStorage.getItem(S6);return qt({...this.converter.backendToUi(this.deserialize(e?JSON.stringify({notificationLastReadTimeInMs:Number(e)}):"{}")),...this.converter.backendToUi(this.deserialize(window.localStorage.getItem(M6)??"{}")),...this.converter.backendToUi(this.deserialize(window.localStorage.getItem(w6)??"{}"))})}}return n.\u0275fac=function(e){return new(e||n)(O(rS))},n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})(),T6=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({providers:[{provide:iS,useClass:E6},bF,{provide:rS,useExisting:bF}]}),n})(),oS="persistent_settings",D6=q(Mr(oS),n=>n.shouldPersistSettings),I6=(()=>{class n{constructor(e,i,r,o){this.actions$=e,this.store=i,this.configModule=r,this.dataSource=o,this.initializeAndUpdateSettings$=Or(()=>{let a=this.actions$.pipe(wi(Hh),zt(1),Yt(this.store.select(D6)),Ve(([,s])=>s),hn(()=>this.dataSource.getSettings()),Vt(s=>{this.store.dispatch(Sl({partialSettings:s}))}),xs(0),hn(()=>cn(...this.configModule.getGlobalSettingSelectors().map(l=>this.store.select(l).pipe(ui((c,d)=>{let u=Object.values(c),p=Object.values(d);return u.length===p.length&&u.every((f,m)=>f===p[m])}),$a(1))))),Sa());return a.pipe(function(n){return Kt((t,e)=>{let i=[];return t.subscribe(Ht(e,r=>i.push(r),()=>{e.next(i),e.complete()})),n.subscribe(Ht(e,()=>{let r=i;i=[],e.next(r)},sl)),()=>{i=null}})}(a.pipe(Cr(500))),hn(s=>{if(0===s.length)return to;let l={};for(let c of s)Object.assign(l,c);return this.dataSource.setSettings(l)}))},{dispatch:!1})}}return n.\u0275fac=function(e){return new(e||n)(O(Wo),O(ke),O(er),O(iS))},n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})(),Zhe=_r({shouldPersistSettings:!0});function A6(n,t){return Zhe(n,t)}var vF=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({providers:[er],imports:[wr.forFeature(oS,A6),wo.forFeature([I6]),T6]}),n})(),db=class{},lS=class{},as=class{constructor(t){this.normalizedNames=new Map,this.lazyUpdate=null,t?this.lazyInit="string"==typeof t?()=>{this.headers=new Map,t.split("\n").forEach(e=>{let i=e.indexOf(":");if(i>0){let r=e.slice(0,i),o=r.toLowerCase(),a=e.slice(i+1).trim();this.maybeSetNormalizedName(r,o),this.headers.has(o)?this.headers.get(o).push(a):this.headers.set(o,[a])}})}:()=>{this.headers=new Map,Object.entries(t).forEach(([e,i])=>{let r;if(r="string"==typeof i?[i]:"number"==typeof i?[i.toString()]:i.map(o=>o.toString()),r.length>0){let o=e.toLowerCase();this.headers.set(o,r),this.maybeSetNormalizedName(e,o)}})}:this.headers=new Map}has(t){return this.init(),this.headers.has(t.toLowerCase())}get(t){this.init();let e=this.headers.get(t.toLowerCase());return e&&e.length>0?e[0]:null}keys(){return this.init(),Array.from(this.normalizedNames.values())}getAll(t){return this.init(),this.headers.get(t.toLowerCase())||null}append(t,e){return this.clone({name:t,value:e,op:"a"})}set(t,e){return this.clone({name:t,value:e,op:"s"})}delete(t,e){return this.clone({name:t,value:e,op:"d"})}maybeSetNormalizedName(t,e){this.normalizedNames.has(e)||this.normalizedNames.set(e,t)}init(){this.lazyInit&&(this.lazyInit instanceof as?this.copyFrom(this.lazyInit):this.lazyInit(),this.lazyInit=null,this.lazyUpdate&&(this.lazyUpdate.forEach(t=>this.applyUpdate(t)),this.lazyUpdate=null))}copyFrom(t){t.init(),Array.from(t.headers.keys()).forEach(e=>{this.headers.set(e,t.headers.get(e)),this.normalizedNames.set(e,t.normalizedNames.get(e))})}clone(t){let e=new as;return e.lazyInit=this.lazyInit&&this.lazyInit instanceof as?this.lazyInit:this,e.lazyUpdate=(this.lazyUpdate||[]).concat([t]),e}applyUpdate(t){let e=t.name.toLowerCase();switch(t.op){case"a":case"s":let i=t.value;if("string"==typeof i&&(i=[i]),0===i.length)return;this.maybeSetNormalizedName(t.name,e);let r=("a"===t.op?this.headers.get(e):void 0)||[];r.push(...i),this.headers.set(e,r);break;case"d":let o=t.value;if(o){let a=this.headers.get(e);if(!a)return;a=a.filter(s=>-1===o.indexOf(s)),0===a.length?(this.headers.delete(e),this.normalizedNames.delete(e)):this.headers.set(e,a)}else this.headers.delete(e),this.normalizedNames.delete(e)}}forEach(t){this.init(),Array.from(this.normalizedNames.keys()).forEach(e=>t(this.normalizedNames.get(e),this.headers.get(e)))}},Jhe=/%(\d[a-f0-9])/gi,$he={40:"@","3A":":",24:"$","2C":",","3B":";","3D":"=","3F":"?","2F":"/"};function R6(n){return encodeURIComponent(n).replace(Jhe,(t,e)=>$he[e]??t)}function aS(n){return`${n}`}var bc=class{constructor(t={}){if(this.updates=null,this.cloneFrom=null,this.encoder=t.encoder||new class{encodeKey(t){return R6(t)}encodeValue(t){return R6(t)}decodeKey(t){return decodeURIComponent(t)}decodeValue(t){return decodeURIComponent(t)}},t.fromString){if(t.fromObject)throw new Error("Cannot specify both fromString and fromObject.");this.map=function(n,t){let e=new Map;return n.length>0&&n.replace(/^\?/,"").split("&").forEach(r=>{let o=r.indexOf("="),[a,s]=-1==o?[t.decodeKey(r),""]:[t.decodeKey(r.slice(0,o)),t.decodeValue(r.slice(o+1))],l=e.get(a)||[];l.push(s),e.set(a,l)}),e}(t.fromString,this.encoder)}else t.fromObject?(this.map=new Map,Object.keys(t.fromObject).forEach(e=>{let i=t.fromObject[e],r=Array.isArray(i)?i.map(aS):[aS(i)];this.map.set(e,r)})):this.map=null}has(t){return this.init(),this.map.has(t)}get(t){this.init();let e=this.map.get(t);return e?e[0]:null}getAll(t){return this.init(),this.map.get(t)||null}keys(){return this.init(),Array.from(this.map.keys())}append(t,e){return this.clone({param:t,value:e,op:"a"})}appendAll(t){let e=[];return Object.keys(t).forEach(i=>{let r=t[i];Array.isArray(r)?r.forEach(o=>{e.push({param:i,value:o,op:"a"})}):e.push({param:i,value:r,op:"a"})}),this.clone(e)}set(t,e){return this.clone({param:t,value:e,op:"s"})}delete(t,e){return this.clone({param:t,value:e,op:"d"})}toString(){return this.init(),this.keys().map(t=>{let e=this.encoder.encodeKey(t);return this.map.get(t).map(i=>e+"="+this.encoder.encodeValue(i)).join("&")}).filter(t=>""!==t).join("&")}clone(t){let e=new bc({encoder:this.encoder});return e.cloneFrom=this.cloneFrom||this,e.updates=(this.updates||[]).concat(t),e}init(){null===this.map&&(this.map=new Map),null!==this.cloneFrom&&(this.cloneFrom.init(),this.cloneFrom.keys().forEach(t=>this.map.set(t,this.cloneFrom.map.get(t))),this.updates.forEach(t=>{switch(t.op){case"a":case"s":let e=("a"===t.op?this.map.get(t.param):void 0)||[];e.push(aS(t.value)),this.map.set(t.param,e);break;case"d":if(void 0===t.value){this.map.delete(t.param);break}{let i=this.map.get(t.param)||[],r=i.indexOf(aS(t.value));-1!==r&&i.splice(r,1),i.length>0?this.map.set(t.param,i):this.map.delete(t.param)}}}),this.cloneFrom=this.updates=null)}};function k6(n){return typeof ArrayBuffer<"u"&&n instanceof ArrayBuffer}function P6(n){return typeof Blob<"u"&&n instanceof Blob}function O6(n){return typeof FormData<"u"&&n instanceof FormData}var pf=class{constructor(t,e,i,r){let o;if(this.url=e,this.body=null,this.reportProgress=!1,this.withCredentials=!1,this.responseType="json",this.method=t.toUpperCase(),function(n){switch(n){case"DELETE":case"GET":case"HEAD":case"OPTIONS":case"JSONP":return!1;default:return!0}}(this.method)||r?(this.body=void 0!==i?i:null,o=r):o=i,o&&(this.reportProgress=!!o.reportProgress,this.withCredentials=!!o.withCredentials,o.responseType&&(this.responseType=o.responseType),o.headers&&(this.headers=o.headers),o.context&&(this.context=o.context),o.params&&(this.params=o.params)),this.headers||(this.headers=new as),this.context||(this.context=new class{constructor(){this.map=new Map}set(t,e){return this.map.set(t,e),this}get(t){return this.map.has(t)||this.map.set(t,t.defaultValue()),this.map.get(t)}delete(t){return this.map.delete(t),this}has(t){return this.map.has(t)}keys(){return this.map.keys()}}),this.params){let a=this.params.toString();if(0===a.length)this.urlWithParams=e;else{let s=e.indexOf("?");this.urlWithParams=e+(-1===s?"?":s<e.length-1?"&":"")+a}}else this.params=new bc,this.urlWithParams=e}serializeBody(){return null===this.body?null:k6(this.body)||P6(this.body)||O6(this.body)||typeof URLSearchParams<"u"&&this.body instanceof URLSearchParams||"string"==typeof this.body?this.body:this.body instanceof bc?this.body.toString():"object"==typeof this.body||"boolean"==typeof this.body||Array.isArray(this.body)?JSON.stringify(this.body):this.body.toString()}detectContentTypeHeader(){return null===this.body||O6(this.body)?null:P6(this.body)?this.body.type||null:k6(this.body)?null:"string"==typeof this.body?"text/plain":this.body instanceof bc?"application/x-www-form-urlencoded;charset=UTF-8":"object"==typeof this.body||"number"==typeof this.body||"boolean"==typeof this.body?"application/json":null}clone(t={}){let e=t.method||this.method,i=t.url||this.url,r=t.responseType||this.responseType,o=void 0!==t.body?t.body:this.body,a=void 0!==t.withCredentials?t.withCredentials:this.withCredentials,s=void 0!==t.reportProgress?t.reportProgress:this.reportProgress,l=t.headers||this.headers,c=t.params||this.params,d=t.context??this.context;return void 0!==t.setHeaders&&(l=Object.keys(t.setHeaders).reduce((u,p)=>u.set(p,t.setHeaders[p]),l)),t.setParams&&(c=Object.keys(t.setParams).reduce((u,p)=>u.set(p,t.setParams[p]),c)),new pf(e,i,o,{params:c,headers:l,context:d,reportProgress:s,responseType:r,withCredentials:a})}},xu=(()=>{return(n=xu||(xu={}))[n.Sent=0]="Sent",n[n.UploadProgress=1]="UploadProgress",n[n.ResponseHeader=2]="ResponseHeader",n[n.DownloadProgress=3]="DownloadProgress",n[n.Response=4]="Response",n[n.User=5]="User",xu;var n})(),ub=class{constructor(t,e=200,i="OK"){this.headers=t.headers||new as,this.status=void 0!==t.status?t.status:e,this.statusText=t.statusText||i,this.url=t.url||null,this.ok=this.status>=200&&this.status<300}},pb=class extends ub{constructor(t={}){super(t),this.type=xu.ResponseHeader}clone(t={}){return new pb({headers:t.headers||this.headers,status:void 0!==t.status?t.status:this.status,statusText:t.statusText||this.statusText,url:t.url||this.url||void 0})}},jh=class extends ub{constructor(t={}){super(t),this.type=xu.Response,this.body=void 0!==t.body?t.body:null}clone(t={}){return new jh({body:void 0!==t.body?t.body:this.body,headers:t.headers||this.headers,status:void 0!==t.status?t.status:this.status,statusText:t.statusText||this.statusText,url:t.url||this.url||void 0})}},pd=class extends ub{constructor(t){super(t,0,"Unknown Error"),this.name="HttpErrorResponse",this.ok=!1,this.message=this.status>=200&&this.status<300?`Http failure during parsing for ${t.url||"(unknown url)"}`:`Http failure response for ${t.url||"(unknown url)"}: ${t.status} ${t.statusText}`,this.error=t.error||null}};function xF(n,t){return{body:t,headers:n.headers,context:n.context,observe:n.observe,params:n.params,reportProgress:n.reportProgress,responseType:n.responseType,withCredentials:n.withCredentials}}var ff=(()=>{class n{constructor(e){this.handler=e}request(e,i,r={}){let o;if(e instanceof pf)o=e;else{let l,c;l=r.headers instanceof as?r.headers:new as(r.headers),r.params&&(c=r.params instanceof bc?r.params:new bc({fromObject:r.params})),o=new pf(e,i,void 0!==r.body?r.body:null,{headers:l,context:r.context,params:c,reportProgress:r.reportProgress,responseType:r.responseType||"json",withCredentials:r.withCredentials})}let a=qt(o).pipe(function(n,t){return _n(t)?hn(n,t,1):hn(n,1)}(l=>this.handler.handle(l)));if(e instanceof pf||"events"===r.observe)return a;let s=a.pipe(Ve(l=>l instanceof jh));switch(r.observe||"body"){case"body":switch(o.responseType){case"arraybuffer":return s.pipe(U(l=>{if(null!==l.body&&!(l.body instanceof ArrayBuffer))throw new Error("Response is not an ArrayBuffer.");return l.body}));case"blob":return s.pipe(U(l=>{if(null!==l.body&&!(l.body instanceof Blob))throw new Error("Response is not a Blob.");return l.body}));case"text":return s.pipe(U(l=>{if(null!==l.body&&"string"!=typeof l.body)throw new Error("Response is not a string.");return l.body}));default:return s.pipe(U(l=>l.body))}case"response":return s;default:throw new Error(`Unreachable: unhandled observe type ${r.observe}}`)}}delete(e,i={}){return this.request("DELETE",e,i)}get(e,i={}){return this.request("GET",e,i)}head(e,i={}){return this.request("HEAD",e,i)}jsonp(e,i){return this.request("JSONP",e,{params:(new bc).append(i,"JSONP_CALLBACK"),observe:"body",responseType:"json"})}options(e,i={}){return this.request("OPTIONS",e,i)}patch(e,i,r={}){return this.request("PATCH",e,xF(r,i))}post(e,i,r={}){return this.request("POST",e,xF(r,i))}put(e,i,r={}){return this.request("PUT",e,xF(r,i))}}return n.\u0275fac=function(e){return new(e||n)(O(db))},n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})();function B6(n,t){return t(n)}function nge(n,t){return(e,i)=>t.intercept(e,{handle:r=>n(r,i)})}var wF=new ie("HTTP_INTERCEPTORS"),SF=new ie("HTTP_INTERCEPTOR_FNS");function rge(){let n=null;return(t,e)=>(null===n&&(n=(pi(wF,{optional:!0})??[]).reduceRight(nge,B6)),n(t,e))}var F6=(()=>{class n extends db{constructor(e,i){super(),this.backend=e,this.injector=i,this.chain=null}handle(e){if(null===this.chain){let i=Array.from(new Set(this.injector.get(SF)));this.chain=i.reduceRight((r,o)=>function(n,t,e){return(i,r)=>e.runInContext(()=>t(i,o=>n(o,r)))}(r,o,this.injector),B6)}return this.chain(e,i=>this.backend.handle(i))}}return n.\u0275fac=function(e){return new(e||n)(O(lS),O(lc))},n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})(),oge=/^\)\]\}',?\n/,L6=(()=>{class n{constructor(e){this.xhrFactory=e}handle(e){if("JSONP"===e.method)throw new Error("Attempted to construct Jsonp request without HttpClientJsonpModule installed.");return new en(i=>{let r=this.xhrFactory.build();if(r.open(e.method,e.urlWithParams),e.withCredentials&&(r.withCredentials=!0),e.headers.forEach((f,m)=>r.setRequestHeader(f,m.join(","))),e.headers.has("Accept")||r.setRequestHeader("Accept","application/json, text/plain, */*"),!e.headers.has("Content-Type")){let f=e.detectContentTypeHeader();null!==f&&r.setRequestHeader("Content-Type",f)}if(e.responseType){let f=e.responseType.toLowerCase();r.responseType="json"!==f?f:"text"}let o=e.serializeBody(),a=null,s=()=>{if(null!==a)return a;let f=r.statusText||"OK",m=new as(r.getAllResponseHeaders()),y=function(n){return"responseURL"in n&&n.responseURL?n.responseURL:/^X-Request-URL:/m.test(n.getAllResponseHeaders())?n.getResponseHeader("X-Request-URL"):null}(r)||e.url;return a=new pb({headers:m,status:r.status,statusText:f,url:y}),a},l=()=>{let{headers:f,status:m,statusText:y,url:M}=s(),v=null;204!==m&&(v=typeof r.response>"u"?r.responseText:r.response),0===m&&(m=v?200:0);let x=m>=200&&m<300;if("json"===e.responseType&&"string"==typeof v){let R=v;v=v.replace(oge,"");try{v=""!==v?JSON.parse(v):null}catch(A){v=R,x&&(x=!1,v={error:A,text:v})}}x?(i.next(new jh({body:v,headers:f,status:m,statusText:y,url:M||void 0})),i.complete()):i.error(new pd({error:v,headers:f,status:m,statusText:y,url:M||void 0}))},c=f=>{let{url:m}=s(),y=new pd({error:f,status:r.status||0,statusText:r.statusText||"Unknown Error",url:m||void 0});i.error(y)},d=!1,u=f=>{d||(i.next(s()),d=!0);let m={type:xu.DownloadProgress,loaded:f.loaded};f.lengthComputable&&(m.total=f.total),"text"===e.responseType&&!!r.responseText&&(m.partialText=r.responseText),i.next(m)},p=f=>{let m={type:xu.UploadProgress,loaded:f.loaded};f.lengthComputable&&(m.total=f.total),i.next(m)};return r.addEventListener("load",l),r.addEventListener("error",c),r.addEventListener("timeout",c),r.addEventListener("abort",c),e.reportProgress&&(r.addEventListener("progress",u),null!==o&&r.upload&&r.upload.addEventListener("progress",p)),r.send(o),i.next({type:xu.Sent}),()=>{r.removeEventListener("error",c),r.removeEventListener("abort",c),r.removeEventListener("load",l),r.removeEventListener("timeout",c),e.reportProgress&&(r.removeEventListener("progress",u),null!==o&&r.upload&&r.upload.removeEventListener("progress",p)),r.readyState!==r.DONE&&r.abort()}})}}return n.\u0275fac=function(e){return new(e||n)(O(tf))},n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})(),V6=new ie("XSRF_ENABLED"),lge=new ie("XSRF_COOKIE_NAME",{providedIn:"root",factory:()=>"XSRF-TOKEN"}),dge=new ie("XSRF_HEADER_NAME",{providedIn:"root",factory:()=>"X-XSRF-TOKEN"}),cS=class{},uge=(()=>{class n{constructor(e,i,r){this.doc=e,this.platform=i,this.cookieName=r,this.lastCookieString="",this.lastToken=null,this.parseCount=0}getToken(){if("server"===this.platform)return null;let e=this.doc.cookie||"";return e!==this.lastCookieString&&(this.parseCount++,this.lastToken=_w(e,this.cookieName),this.lastCookieString=e),this.lastToken}}return n.\u0275fac=function(e){return new(e||n)(O(kt),O(hc),O(lge))},n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})();function pge(n,t){let e=n.url.toLowerCase();if(!pi(V6)||"GET"===n.method||"HEAD"===n.method||e.startsWith("http://")||e.startsWith("https://"))return t(n);let i=pi(cS).getToken(),r=pi(dge);return null!=i&&!n.headers.has(r)&&(n=n.clone({headers:n.headers.set(r,i)})),t(n)}var sS=(()=>{return(n=sS||(sS={}))[n.Interceptors=0]="Interceptors",n[n.LegacyInterceptors=1]="LegacyInterceptors",n[n.CustomXsrfConfiguration=2]="CustomXsrfConfiguration",n[n.NoXsrfProtection=3]="NoXsrfProtection",n[n.JsonpSupport=4]="JsonpSupport",n[n.RequestsMadeViaParent=5]="RequestsMadeViaParent",sS;var n})();function mge(...n){let t=[ff,L6,F6,{provide:db,useExisting:F6},{provide:lS,useExisting:L6},{provide:SF,useValue:pge,multi:!0},{provide:V6,useValue:!0},{provide:cS,useClass:uge}];for(let e of n)t.push(...e.\u0275providers);return function(n){return{"\u0275providers":n}}(t)}var N6=new ie("LEGACY_INTERCEPTOR_FN"),H6=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({providers:[mge({"\u0275kind":sS.LegacyInterceptors,"\u0275providers":[{provide:N6,useFactory:rge},{provide:SF,useExisting:N6,multi:!0}]})]}),n})(),dS="feature",Gh=Mr(dS),Cu=q(Gh,n=>n.isFeatureFlagsLoaded),Fa=q(Gh,n=>({...n.defaultFlags,...n.flagOverrides})),U6=q(Gh,n=>n.defaultFlags),fb=q(Gh,n=>n.flagOverrides||{}),mf=q(Gh,n=>n.metadata),Wh=q(Gh,n=>{let t={};for(let e in n.flagOverrides){let i=n.metadata[e];i&&i.queryParamOverride&&i.sendToServerWhenOverridden&&(t[e]=n.flagOverrides[e])}return t}),j6=q(Fa,n=>n.isAutoDarkModeAllowed),El=q(Fa,n=>null!==n.enableDarkModeOverride?n.enableDarkModeOverride:n.defaultEnableDarkMode),uS=q(Fa,n=>n.enableDarkModeOverride),G6=q(Fa,n=>n.enabledExperimentalPlugins),W6=q(Fa,n=>n.inColab),pS=q(Fa,n=>n.metricsImageSupportEnabled),EF=q(Fa,n=>n.forceSvg),q6=q(Fa,n=>void 0!==n.showFlags),fS=q(Fa,n=>n.enableScalarColumnCustomization),hf=q(Fa,n=>n.enableHparamsInTimeSeries);function _ge(n,t){if(!n)return;let e=n instanceof FormData?function(n){let t={};for(let[e,i]of n.entries())t[e]=i;return t}(n):n;return t?{[t]:JSON.stringify(e)}:e}var yge="X-XSRF-Protected";function TF(n){let t=n.headers||new as;return t=t.append(yge,"1"),{...n,headers:t}}var vc=(()=>{class n{constructor(e,i,r){this.appRootProvider=e,this.http=i,this.store=r}resolveAppRoot(e){return e.startsWith("/")?this.appRootProvider.getAbsPathnameWithAppRoot(e):e}get(e,i={}){return this.http.get(this.resolveAppRoot(e),i)}post(e,i,r={},o){return r=TF(r),this.store.select(Cu).pipe(Ve(a=>Boolean(a)),zt(1),Yt(this.store.select(W6)),hn(([,a])=>{let s=this.resolveAppRoot(e);return a?this.http.get(s,{headers:r.headers??{},params:_ge(i,o)}):this.http.post(s,i,r)}))}put(e,i,r={}){return this.http.put(this.resolveAppRoot(e),i,TF(r))}delete(e,i={}){return this.http.delete(this.resolveAppRoot(e),TF(i))}}return n.\u0275fac=function(e){return new(e||n)(O(uf),O(ff),O(ke))},n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})(),qh=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({providers:[vc],imports:[H6,Bh]}),n})(),Vs=(()=>{return(n=Vs||(Vs={})).UNKNOWN="UNKNOWN",n.NOT_FOUND="NOT_FOUND",n.PERMISSION_DENIED="PERMISSION_DENIED",Vs;var n})(),Y6=new ie("TensorBoard brand name"),oo=(()=>{return(n=oo||(oo={})).STEP="step",n.WALL_TIME="wall_time",n.RELATIVE="relative",oo;var n})(),Sr=(()=>{return(n=Sr||(Sr={})).OFFSET="offset",n.OVERLAY="overlay",Sr;var n})();function X6(n){let t=Vs.UNKNOWN;return n instanceof pd&&(404===n.status&&(t=Vs.NOT_FOUND),403===n.status&&(t=Vs.PERMISSION_DENIED)),cl(new mb(t))}var mb=class{constructor(t){this.failureCode=t}},hS=(()=>{class n{constructor(e){this.http=e,this.tfBackend=document.createElement("tf-backend").tf_backend}fetchPluginsListing(e){let i=function(n){if(!n.length)return null;let t=new URLSearchParams;for(let e of n)t.append("experimentalPlugin",e);return t}(e),r=i?`data/plugins_listing?${i.toString()}`:"data/plugins_listing";return this.http.get(r).pipe(fo(X6))}fetchEnvironment(){return po([this.http.get("data/environment"),no(this.tfBackend.environmentStore.refresh())]).pipe(U(([r])=>r),fo(X6))}}return n.\u0275fac=function(e){return new(e||n)(O(vc))},n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})(),Q6=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({providers:[hS],imports:[qh]}),n})(),De=(()=>{return(n=De||(De={}))[n.NOT_LOADED=0]="NOT_LOADED",n[n.LOADED=1]="LOADED",n[n.LOADING=2]="LOADING",n[n.FAILED=3]="FAILED",De;var n})(),xc=ye("[Core] Plugin Changed",{_as:"props",_p:void 0}),gS=ye("[Core] Plugin Url Hash Changed",{_as:"props",_p:void 0}),Z6=ye("[Core] Loaded"),Hs=ye("[Core] User Triggered Reload"),ss=ye("[Core] Auto Reload"),_S=ye("[Core] PluginListing Fetch Requested"),gf=ye("[Core] PluginListing Fetch Successful",{_as:"props",_p:void 0}),hb=ye("[Core] PluginListing Fetch Failed",{_as:"props",_p:void 0}),yS=ye("[Core] Polymer Component Runs Fetch Requested"),bS=ye("[Core] Polymer Component Runs Fetch Successful"),vS=ye("[Core] Polymer Component Runs Fetch Failed"),xS=ye("[Core] Environment Fetch Successful",{_as:"props",_p:void 0}),K6=ye("[Core] Run Selection Changed",{_as:"props",_p:void 0}),J6=ye("[Core] Run Fetch Successful",{_as:"props",_p:void 0}),Yh=ye("[Core] Side Bar Width Changed",{_as:"props",_p:void 0}),CS=ye("[Core] Runs Table Full Screen Toggled");function _f(n,t,e){let i=Object.keys(n),r={...n,...t,privateNamespacedState:{}};return{initialState:r,reducers:_r(r,Ee(Ls,(s,{before:l,after:c,beforeNamespaceId:d,afterNamespaceId:u})=>{let p=s;return d!==u&&(p=function(s,l,c){let d={...s.privateNamespacedState};if(l){let p={};for(let f of i)p[f]=s[f];d={...d,[l]:p}}let u={};return s.privateNamespacedState?.[c]?u=s.privateNamespacedState[c]:l&&(u=n),{...s,...u,privateNamespacedState:d}}(s,d,u)),e&&(p=e(p,l,c)),p}))}}function yf(...n){return(t,e)=>{let i=t;for(let r of n)i=r(i,e);return i}}var gb={activePlugin:null,plugins:{},coreDataLoadState:{state:De.NOT_LOADED,lastLoadedTimeInMs:null},pluginsListLoaded:{state:De.NOT_LOADED,lastLoadedTimeInMs:null,failureCode:null},environment:{data_location:"",window_title:""},polymerRunsLoadState:{state:De.NOT_LOADED,lastLoadedTimeInMs:null},polymerInteropRuns:[],polymerInteropRunSelection:new Set,sideBarWidthInPercent:20,runsTableFullScreen:!1},xge=_r(gb,Ee(xc,gS,(n,{plugin:t})=>({...n,activePlugin:t})),Ee(_S,n=>({...n,coreDataLoadState:{...n.coreDataLoadState,state:De.LOADING},pluginsListLoaded:{...n.pluginsListLoaded,state:De.LOADING}})),Ee(hb,(n,{failureCode:t})=>({...n,coreDataLoadState:{...n.coreDataLoadState,state:De.FAILED},pluginsListLoaded:{...n.pluginsListLoaded,state:De.FAILED,failureCode:t}})),Ee(gf,(n,{plugins:t})=>{let e=Object.keys(t).find(a=>t[a].enabled)||null,i=n.activePlugin||e,r=Date.now(),o=n.coreDataLoadState;return n.polymerRunsLoadState.state===De.LOADED&&(o={state:De.LOADED,lastLoadedTimeInMs:r}),{...n,activePlugin:i,coreDataLoadState:o,plugins:t,pluginsListLoaded:{state:De.LOADED,lastLoadedTimeInMs:r,failureCode:null}}}),Ee(yS,n=>({...n,coreDataLoadState:{...n.coreDataLoadState,state:De.LOADING},polymerRunsLoadState:{...n.polymerRunsLoadState,state:De.LOADING}})),Ee(bS,n=>{let t=Date.now(),e=n.coreDataLoadState;return n.pluginsListLoaded.state===De.LOADED&&(e={state:De.LOADED,lastLoadedTimeInMs:t}),{...n,coreDataLoadState:e,polymerRunsLoadState:{...n.polymerRunsLoadState,state:De.LOADED,lastLoadedTimeInMs:t}}}),Ee(vS,n=>({...n,coreDataLoadState:{...n.coreDataLoadState,state:De.FAILED},polymerRunsLoadState:{...n.polymerRunsLoadState,state:De.FAILED}})),Ee(xS,(n,{environment:t})=>({...n,environment:t})),Ee(J6,(n,{runs:t})=>({...n,polymerInteropRuns:t})),Ee(K6,(n,{nextSelection:t})=>({...n,polymerInteropRunSelection:new Set(t)})),Ee(Yh,(n,{widthInPercent:t})=>({...n,sideBarWidthInPercent:Math.min(Math.max(0,t),100)})),Ee(Sl,(n,{partialSettings:t})=>{let e={...n},i=t.sideBarWidthInPercent;return"number"==typeof i&&i>=0&&i<=100&&(e.sideBarWidthInPercent=i),e}),Ee(CS,n=>({...n,runsTableFullScreen:!n.runsTableFullScreen}))),{reducers:Cge}=_f(gb,{});function $6(n,t){return yf(xge,Cge)(n,t)}var fd=Mr("core"),SS=q(fd,n=>n.pluginsListLoaded),eW=q(fd,n=>n.polymerRunsLoadState),tW=q(fd,n=>n.coreDataLoadState.state),Xh=q(fd,n=>n.coreDataLoadState.lastLoadedTimeInMs),qo=q(fd,n=>n.activePlugin),Qh=q(fd,n=>n.plugins),ES=q(fd,n=>n.environment),TS=q(fd,n=>n.sideBarWidthInPercent),Zh=q(fd,n=>n.runsTableFullScreen),nW=new Set([kn.COMPARE_EXPERIMENT,kn.EXPERIMENT,kn.NOT_SET]),iW=(()=>{class n{refreshPolymerRuns(){return no(this.tfBackend.ref.runsStore.refresh())}fetchEnvironment(){return this.webappDataSource.fetchEnvironment().pipe(Vt(e=>{this.store.dispatch(xS({environment:e}))}))}constructor(e,i,r){this.actions$=e,this.store=i,this.webappDataSource=r,this.tfBackend={ref:document.createElement("tf-backend").tf_backend},this.onDashboardLoad$=cn(this.actions$.pipe(wi(Z6,Ls),Yt(this.store.select(fa)),ui(([,o],[,a])=>Lo(o,a))),this.actions$.pipe(wi(ss,Hs))).pipe(Yt(this.store.select(Ns)),Ve(([,o])=>nW.has(o)),eu(1,void 0,{leading:!0})),this.fetchWebAppData$=Or(()=>{let o=this.onDashboardLoad$.pipe(Yt(this.store.select(SS),this.store.select(G6)),Ve(([,{state:s}])=>s!==De.LOADING),Vt(()=>this.store.dispatch(_S())),hn(([,,s])=>function(...n){let t=tc(n),e=BC(n);return e.length?new en(i=>{let r=e.map(()=>[]),o=e.map(()=>!1);i.add(()=>{r=o=null});for(let a=0;!i.closed&&a<e.length;a++)oi(e[a]).subscribe(Ht(i,s=>{if(r[a].push(s),r.every(l=>l.length)){let l=r.map(c=>c.shift());i.next(t?t(...l):l),r.some((c,d)=>!c.length&&o[d])&&i.complete()}},()=>{o[a]=!0,!r[a].length&&i.complete()}));return()=>{r=o=null}}):to}(this.webappDataSource.fetchPluginsListing(s),this.fetchEnvironment()).pipe(U(([l])=>{this.store.dispatch(gf({plugins:l}))}),fo(l=>(this.store.dispatch(hb(l instanceof mb?{failureCode:l.failureCode}:{failureCode:Vs.UNKNOWN})),to)))));return cn(o,this.onDashboardLoad$.pipe(U(([,s])=>s),yi(s=>s!==kn.COMPARE_EXPERIMENT?qt([]):this.store.select(Bs).pipe(ui((l,c)=>{let d=Object.entries(l),u=new Map(Object.entries(c));if(d.length!==u.size)return!1;for(let[p,f]of d)if(!u.get(p)||u.get(p).aliasText!==f.aliasText||u.get(p).aliasNumber!==f.aliasNumber)return!1;return!0}),xs(0),eu(500,void 0,{leading:!0,trailing:!0}))),Yt(this.store.select(Ns),this.store.select(eW)),Ve(([,s,l])=>nW.has(s)&&l.state!==De.LOADING),Vt(()=>{this.store.dispatch(yS())}),yi(()=>this.refreshPolymerRuns()),Vt(()=>{this.store.dispatch(bS())}),fo(()=>(this.store.dispatch(vS()),to))))},{dispatch:!1}),this.dispatchChangePlugin$=Or(()=>cn(this.onDashboardLoad$,this.actions$.pipe(wi(gf))).pipe(Yt(this.store.select(qo)),U(([,o])=>o),ui(),Ve(o=>null!==o),zt(1),Vt(o=>{this.store.dispatch(xc({plugin:o}))})),{dispatch:!1})}}return n.\u0275fac=function(e){return new(e||n)(O(Wo),O(ke),O(hS))},n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})(),DF=new ie("Core Feature Config");function rW(n){return{initialState:{...gb,activePlugin:n.getPluginId()||null}}}function Sge(){return q(TS,n=>({sideBarWidthInPercent:n}))}var zs=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({providers:[{provide:DF,deps:[vu],useFactory:rW}],imports:[wo.forFeature([iW]),wr.forFeature("core",$6,DF),Q6,er.defineGlobalSetting(Sge)]}),n})(),oW=new ie("[Alert] Action-To-Alert Provider"),Cc=(()=>{class n{constructor(e){this.providers=new Map;for(let i of e||[])for(let r of i){if(this.providers.has(r.actionCreator.type))throw new RangeError(`"${r.actionCreator.type}" is already registered for alerts. Multiple alerts for the same action is not allowed.`);this.providers.set(r.actionCreator.type,r.alertFromAction)}}getAlertFromAction(e){let i=this.providers.get(e.type);return i?i(e):null}static registerAlertActions(e){return{ngModule:n,providers:[{provide:oW,multi:!0,useFactory:e}]}}}return n.\u0275fac=function(e){return new(e||n)(O(oW,8))},n.\u0275mod=V({type:n}),n.\u0275inj=B({}),n})(),DS=ye("[Runs] Fetch Runs Requested",{_as:"props",_p:void 0}),Mu=ye("[Runs] Fetch Runs Succeeded",{_as:"props",_p:void 0}),Kh=ye("[Runs] Fetch Runs Failed",{_as:"props",_p:void 0}),_b=ye("[Runs] Run Selection Toggled",{_as:"props",_p:void 0}),IS=ye("[Runs] Single Run Selected",{_as:"props",_p:void 0}),yb=ye("[Runs] Run Page Selection Toggled",{_as:"props",_p:void 0}),AS=ye("[Runs] Run Selector Pagination Option Changed",{_as:"props",_p:void 0}),RS=ye("[Runs] Run Selector Sort Changed",{_as:"props",_p:void 0}),bb=ye("[Runs] Run Selector Regex Filter Changed",{_as:"props",_p:void 0}),kS=ye("[Runs] Run Color Changed",{_as:"props",_p:void 0}),PS=ye("[Runs] Run Table Shown",{_as:"props",_p:void 0}),Jh=ye("[Runs] Run Group By Changed",{_as:"props",_p:void 0}),OS=ye("[Runs] Runs Table Header Added",{_as:"props",_p:void 0}),FS=ye("[Runs] Runs Table Header Removed",{_as:"props",_p:void 0}),LS=ye("[Runs] Runs Table Header Order Changed",{_as:"props",_p:void 0}),NS=ye("[Runs] Runs Table Sorting Info Changed",{_as:"props",_p:void 0}),wu=(()=>{return(n=wu||(wu={})).STATUS_UNKNOWN="STATUS_UNKNOWN",n.STATUS_SUCCESS="STATUS_SUCCESS",n.STATUS_FAILURE="STATUS_FAILURE",n.STATUS_RUNNING="STATUS_RUNNING",wu;var n})(),Un=(()=>{return(n=Un||(Un={}))[n.DISCRETE=0]="DISCRETE",n[n.INTERVAL=1]="INTERVAL",Un;var n})(),BS=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=pe({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),bf={};zA(bf,{hparamsDiscreteHparamFilterChanged:()=>RF,hparamsIntervalHparamFilterChanged:()=>kF,hparamsMetricFilterChanged:()=>PF});var RF=ye("[Hparams] Hparams Discrete Hparam Filter Changed",{_as:"props",_p:void 0}),kF=ye("[Hparams] Hparams Interval Hparam Filter Changed",{_as:"props",_p:void 0}),PF=ye("[Hparams] Hparams Metric Filter Changed",{_as:"props",_p:void 0});function vf(n){return JSON.stringify([...n].sort())}function vb(n){let t=new Map,e=new Map,i=new Map;for(let r of n)for(let[o,a]of r)if(a.type===Un.DISCRETE){let{possibleValues:s,values:l}=e.get(o)||{possibleValues:new Set,values:new Set};for(let c of a.filterValues)l.add(c);for(let c of a.possibleValues)s.add(c);e.set(o,{possibleValues:s,values:l})}else{let s=i.get(o);i.set(o,{filterLowerValue:Math.min(a.filterLowerValue,s?.filterLowerValue??1/0),filterUpperValue:Math.max(a.filterUpperValue,s?.filterUpperValue??-1/0),minValue:Math.min(a.minValue,s?.minValue??1/0),maxValue:Math.max(a.maxValue,s?.maxValue??-1/0)})}for(let[r,{values:o,possibleValues:a}]of e)t.set(r,{type:Un.DISCRETE,includeUndefined:!0,possibleValues:[...a],filterValues:[...o]});for(let[r,{minValue:o,maxValue:a,filterLowerValue:s,filterUpperValue:l}]of i){if(t.has(r)){let c=t.get(r);if(c.type===Un.DISCRETE&&c.possibleValues.some(d=>d))throw new RangeError(`Cannot combine hparam, ${r}, as it is of mixed types.`)}t.set(r,{type:Un.INTERVAL,includeUndefined:!0,minValue:o,maxValue:a,filterLowerValue:s,filterUpperValue:l})}return t}function VS(n){let t=new Map;for(let e of n)for(let[i,r]of e){let o=t.get(i);t.set(i,{type:Un.INTERVAL,includeUndefined:!0,...o,minValue:Math.min(r.minValue,o?.minValue??1/0),maxValue:Math.max(r.maxValue,o?.maxValue??-1/0),filterLowerValue:Math.min(r.filterLowerValue,o?.filterLowerValue??1/0),filterUpperValue:Math.max(r.filterUpperValue,o?.filterUpperValue??-1/0)})}return t}var Rge=_r({specs:{},filters:{}},Ee(RF,(n,t)=>{let{experimentIds:e,hparamName:i,filterValues:r,includeUndefined:o}=t,a=vf(e),s=n.filters[a]??{hparams:new Map},l=s.hparams.get(i);if(l&&l.type!==Un.DISCRETE)throw new RangeError(`New discrete filter of ${i} conflicts existing filter of `+Un[l.type]);let c=vb(e.filter(f=>Boolean(n.specs[f])).map(f=>n.specs[f].hparam.defaultFilters)).get(i);if(!c)throw new Error(`Cannot set hparam, ${i}, when it is not known for experimentIds: ${e.join(", ")}`);if(c.type!==Un.DISCRETE)throw new Error(`Cannot set ${i} when default filter is not of discrete type.`);let d=new Set(c.possibleValues),u=[...r].filter(f=>!d.has(f));if(u.length)throw new Error(`New filter for ${i} has more than one value that is not present in the spec. Bad values: ${u.join(", ")}`);let p=new Map(s.hparams);return p.set(i,{...l,type:Un.DISCRETE,includeUndefined:o,possibleValues:[...d],filterValues:r}),{...n,filters:{...n.filters,[a]:{...s,hparams:p}}}}),Ee(kF,(n,t)=>{let{experimentIds:e,hparamName:i,filterLowerValue:r,filterUpperValue:o,includeUndefined:a}=t,s=vf(e),l=n.filters[s]??{metrics:new Map,hparams:new Map},c=l.hparams.get(i);if(c&&c.type!==Un.INTERVAL)throw new RangeError(`New interval filter of ${i} conflicts existing filter of `+Un[c.type]);let d=vb(e.filter(p=>Boolean(n.specs[p])).map(p=>n.specs[p].hparam.defaultFilters)).get(i);if(!d)throw new Error(`Cannot set hpara, ${i}, when it is not known for experimentIds: ${e.join(", ")}`);if(d.type!==Un.INTERVAL)throw new Error(`Cannot set ${i} when default filter is not of interval type.`);let u=new Map(l.hparams);return u.set(i,{...c,type:Un.INTERVAL,includeUndefined:a,minValue:d.minValue,maxValue:d.maxValue,filterLowerValue:r,filterUpperValue:o}),{...n,filters:{...n.filters,[s]:{...l,hparams:u}}}}),Ee(PF,(n,t)=>{let{experimentIds:e,metricTag:i,filterLowerValue:r,filterUpperValue:o,includeUndefined:a}=t,s=vf(e),l=n.filters[s]??{metrics:new Map,hparams:new Map},c=VS(e.filter(p=>Boolean(n.specs[p])).map(p=>n.specs[p].metric.defaultFilters)).get(i);if(!c)throw new Error(`Cannot set metric, ${i}, when it is not known for experimentIds: ${e.join(", ")}`);let d=l.metrics.get(i),u=new Map(l.metrics);return u.set(i,{...d,type:Un.INTERVAL,includeUndefined:a,minValue:c.minValue,maxValue:c.maxValue,filterLowerValue:r,filterUpperValue:o}),{...n,filters:{...n.filters,[s]:{...l,metrics:u}}}}),Ee(Mu,(n,t)=>{if(0===Object.keys(t.newRunsAndMetadata).length)return n;let e={...n.specs},i=new Map,r=new Set;for(let o of Object.keys(t.newRunsAndMetadata)){let a=new Map,s=new Map,l=new Map,c=new Map,{runs:d,metadata:u}=t.newRunsAndMetadata[o];for(let p of d){let f=u.runToHparamsAndMetrics[p.id];if(f)for(let m of f.metrics){let y=i.get(m.tag);i.set(m.tag,{min:y?Math.min(y.min,m.value):m.value,max:y?Math.max(y.max,m.value):m.value})}}for(let{name:p,domain:f}of u.hparamSpecs)if(f.type===Un.DISCRETE){let m=l.get(p)||new Set;for(let y of f.values)m.add(y);l.set(p,m)}else{let m=c.get(p);c.set(p,{minValue:m?Math.min(f.minValue,m.minValue):f.minValue,maxValue:m?Math.max(f.maxValue,m.maxValue):f.maxValue})}for(let p of u.metricSpecs)r.add(p.tag);for(let[p,f]of l)a.set(p,{type:Un.DISCRETE,includeUndefined:!0,possibleValues:[...f],filterValues:[...f]});for(let[p,{minValue:f,maxValue:m}]of c)a.set(p,{type:Un.INTERVAL,includeUndefined:!0,minValue:f,maxValue:m,filterLowerValue:f,filterUpperValue:m});for(let p of r){let f=i.get(p),m=f?.min??0,y=f?.max??0;s.set(p,{type:Un.INTERVAL,includeUndefined:!0,minValue:m,maxValue:y,filterLowerValue:m,filterUpperValue:y})}e[o]={hparam:{...e[o]?.hparam,specs:u.hparamSpecs,defaultFilters:a},metric:{...e[o]?.metric,specs:u.metricSpecs,defaultFilters:s}}}return{...n,specs:e}}));function lW(n,t){return Rge(n,t)}var HS="hparams",cW=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[wr.forFeature(HS,lW)]}),n})(),zS=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[cW]}),n})(),dW="data/plugin/hparams";function kge(n,t){return`${t}/${n}`}function Pge(n){let t;return t=function(n){return n.hasOwnProperty("domainDiscrete")}(n)?{type:Un.DISCRETE,values:n.domainDiscrete}:function(n){return n.hasOwnProperty("domainInterval")}(n)?{...n.domainInterval,type:Un.INTERVAL}:{type:Un.INTERVAL,minValue:-1/0,maxValue:1/0},{description:n.description,displayName:n.displayName,name:n.name,type:n.type,domain:t}}function Oge(n){let{name:t,...e}=n;return{...e,tag:t.tag}}var uW=(()=>{class n{constructor(e){this.http=e}fetchRuns(e){return this.http.get(`/experiment/${e}/data/runs`).pipe(U(i=>i.map(r=>({id:kge(r,e),name:r,startTime:0}))))}fetchHparamsMetadata(e){return this.http.post(`/experiment/${e}/${dW}/experiment`,{experimentName:e},{},"request").pipe(U(r=>{let o=[];for(let s of r.hparamInfos)o.push({hparam:s.name});for(let s of r.metricInfos)o.push({metric:s.name});return{experimentHparamsInfo:r,listSessionRequestParams:{experimentName:e,allowedStatuses:[wu.STATUS_FAILURE,wu.STATUS_RUNNING,wu.STATUS_SUCCESS,wu.STATUS_UNKNOWN],colParams:o,startIndex:0,sliceSize:1e6}}}),hn(({experimentHparamsInfo:r,listSessionRequestParams:o})=>this.http.post(`/experiment/${e}/${dW}/session_groups`,o,{},"request").pipe(U(a=>({experimentHparamsInfo:r,sessionGroupsList:a})))),U(({experimentHparamsInfo:r,sessionGroupsList:o})=>{let a={};for(let s of o.sessionGroups){let l=Object.entries(s.hparams).map(c=>{let[d,u]=c;return{name:d,value:u}});for(let c of s.sessions)for(let d of c.metricValues){let p=`${e}/${d.name.group?`${c.name}/${d.name.group}`:c.name}`,f=a[p]||{metrics:[],hparams:l};f.metrics.push({tag:d.name.tag,trainingStep:d.trainingStep,value:d.value}),a[p]=f}}return{hparamSpecs:r.hparamInfos.map(Pge),metricSpecs:r.metricInfos.map(Oge),runToHparamsAndMetrics:a}}),fo(r=>r instanceof pd&&400===r.status?qt({hparamSpecs:[],metricSpecs:[],runToHparamsAndMetrics:{}}):cl(r)))}}return n.\u0275fac=function(e){return new(e||n)(O(vc))},n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})(),pW=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({providers:[{provide:BS,useClass:uW}]}),n})(),fW=q(Mr("alerts"),n=>n.latestAlert),jS="experiments",mW=q(Mr(jS),n=>n.data),GS=q(mW,(n,t)=>{let{experimentId:e}=t;return n.experimentMap[e]||null});function WS(n,t,e){return n<t?t:n>e?e:n}function $h(n,t,e){let i=WS(n.start.step,t,e),r=n.end?WS(n.end.step,t,e):null;return{startStep:i,endStep:r,clipped:i!==n.start.step||r!==(n.end?.step??null)}}function qS(n,t){let e=t[n.id];return e&&e.visible&&!Boolean(e.aux)}function OF(n,t){return t?n:{start:n.start,end:null}}function FF(n,t,e){return OF(function(n,{minStep:t,maxStep:e}){return{start:{step:WS(n.start.step,t,e)},end:n.end?{step:WS(n.end.step,t,e)}:null}}(n,t),e)}var qn=(()=>{return(n=qn||(qn={})).SCALARS="scalars",n.HISTOGRAMS="histograms",n.IMAGES="images",qn;var n})(),Pi=(()=>{return(n=Pi||(Pi={})).STEP="step",n.RELATIVE="relative",n.WALL_TIME="walltime",Pi;var n})(),xb="timeseries";function vW(n){return n===qn.SCALARS||n===qn.HISTOGRAMS||n===qn.IMAGES}var Vge=[qn.IMAGES];function ls(n){return Vge.includes(n)}var Hge=[qn.HISTOGRAMS,qn.IMAGES];function cs(n){return Hge.includes(n)}function LF(n){return cs(n.plugin)}var Mc=class{};function XS(n){return n.hasOwnProperty("error")}var NF="data/plugin/timeseries";function xW(n){let t=n.indexOf("/");return{run:n.substring(t+1),experimentId:n.substring(0,t)}}function MW(n,t){return`${t}/${n}`}function CW(n,t){let{runToSeries:e,run:i,...r}=n,o={...r};return e&&(o.runToSeries=BF(e,t)),i&&(o.runId=MW(i,t)),o}function BF(n,t){let e={};for(let i in n)n.hasOwnProperty(i)&&(e[MW(i,t)]=n[i]);return e}var wW=(()=>{class n{constructor(e,i){this.http=e,this.store=i}fetchTagMetadata(e){let i=e.map(o=>this.http.get(`/experiment/${o}/${NF}/tags`).pipe(U(s=>function(n,t){let e={};for(let i of Object.keys(n)){let r=i;if(ls(r)){let{tagRunSampledInfo:o,...a}=n[r],s={};for(let l in o)o.hasOwnProperty(l)&&(s[l]=BF(o[l],t));e[r]={...a,tagRunSampledInfo:s}}else{let{runTagInfo:o,...a}=n[r];e[r]={...a,runTagInfo:BF(o,t)}}}return e}(s,o)))),r=this.store.select(Cu).pipe(Ve(Boolean),zt(1),Yt(this.store.select(pS)),U(([,o])=>o));return po(i).pipe(Yt(r),U(([o,a])=>{let s=function(n){let t={};for(let e of n)for(let i of Object.values(qn))if(ls(i)){t[i]=t[i]||{tagDescriptions:{},tagRunSampledInfo:{}};let{tagDescriptions:r,tagRunSampledInfo:o}=e[i];t[i].tagDescriptions={...t[i].tagDescriptions,...r};let a=t[i].tagRunSampledInfo;for(let s of Object.keys(o)){a[s]=a[s]||{};for(let l of Object.keys(o[s]))a[s][l]=o[s][l]}}else{t[i]=t[i]||{tagDescriptions:{},runTagInfo:{}};let{tagDescriptions:r,runTagInfo:o}=e[i];t[i].tagDescriptions={...t[i].tagDescriptions,...r},t[i].runTagInfo={...t[i].runTagInfo,...o}}return t}(o);return a||(s[qn.IMAGES]={tagDescriptions:{},tagRunSampledInfo:{}}),s}))}fetchTimeSeries(e){let i=e.map(r=>{if(cs(r.plugin)){let{runId:l,...c}=r,{run:d,experimentId:u}=xW(l),p={...c,run:d};return this.fetchTimeSeriesBackendRequest(p,u).pipe(U(({response:f,experimentId:m})=>CW(f,m)))}let{experimentIds:o,...a}=r;return po(o.map(l=>this.fetchTimeSeriesBackendRequest(a,l))).pipe(U(l=>{let{runToSeries:c,error:d,...u}=l[0].response,p=u;for(let{response:f,experimentId:m}of l){let y=CW(f,m);if(p.error)continue;let{runToSeries:M,error:v}=y;if(v)p.error=v,p.runToSeries=void 0;else{p.runToSeries=p.runToSeries||{};for(let x of Object.keys(M))p.runToSeries[x]=M[x]}}return p}))});return po(i)}fetchTimeSeriesBackendRequest(e,i){let r=new FormData;return r.append("requests",JSON.stringify([e])),this.http.post(`/experiment/${i}/${NF}/timeSeries`,r).pipe(U(o=>({response:o[0],experimentId:i})))}imageUrl(e){return`${NF}/imageData?imageId=${e}`}downloadUrl(e,i,r,o){let l,{run:a,experimentId:s}=xW(r);if(e!==qn.SCALARS)throw new Error(`Not implemented: downloadUrl for ${e} is not implemented yet`);if(l="scalars/scalars",!s)throw new Error("experimentId is empty; it is required to form downloadUrl.");return`/experiment/${s}/data/plugin/scalars/scalars?${new URLSearchParams({tag:i,run:a,format:o})}`}}return n.\u0275fac=function(e){return new(e||n)(O(vc),O(ke))},n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})(),Gge=new URLSearchParams(window.location.search),QS=(()=>{class n{getParams(){return Gge}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})(),Cb="tb_feature_flag_storage_key",VF=(()=>{class n{constructor(e){this.queryParams=e}getFeatures(e,i){let r=e?this.getPartialFeaturesFromMediaQuery():{},o=function(n,t){return Object.entries(n).reduce((e,[i,r])=>{let o=function(n,t){let e=n.queryParamOverride;if(!e||!t.has(e))return null;let i=t.get(e);return null==i?null:n.parseValue(i)}(r,t);return null!==o&&(e[i]=o),e},{})}(i,this.queryParams.getParams());return{...r,...Object.fromEntries(Object.entries(this.getPersistentFeatureFlags()).filter(([s])=>i[s])),...o}}persistFeatureFlags(e){let r={...this.getPersistentFeatureFlags(),...e};window.localStorage.setItem(Cb,JSON.stringify(r))}resetPersistedFeatureFlag(e){let i=this.getPersistentFeatureFlags();if(null!=i[e]){if(delete i[e],0===Object.keys(i).length)return void window.localStorage.removeItem(Cb);window.localStorage.setItem(Cb,JSON.stringify(i))}}resetAllPersistedFeatureFlags(){window.localStorage.removeItem(Cb)}getPersistentFeatureFlags(){let e=window.localStorage.getItem(Cb);return null==e?{}:JSON.parse(e)}getPartialFeaturesFromMediaQuery(){let e={};return window.matchMedia("(prefers-color-scheme: dark)").matches&&(e.defaultEnableDarkMode=!0),e}}return n.\u0275fac=function(e){return new(e||n)(O(QS))},n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})(),ZS=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})(),TW=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({providers:[VF,QS,{provide:ZS,useClass:VF}]}),n})(),Mb=ye("[FEATURE FLAG] Partial Feature Flags Loaded",{_as:"props",_p:void 0}),KS=ye("[FEATURE FLAG] Enable Dark Mode Override Changed",{_as:"props",_p:void 0}),xf=ye("[FEATURE FLAG] Store the feature flags in persistent localStorage",{_as:"props",_p:void 0}),Su=ye("[FEATURE FLAG] Reset feature flag overrides",{_as:"props",_p:void 0}),eg=ye("[FEATURE FLAG] Reset all feature flag overrides"),DW=ye("[FEATURE FLAG] Effects Init"),IW=(()=>{class n{constructor(e,i,r){this.actions$=e,this.store=i,this.dataSource=r,this.tfFeatureFlags={ref:document.createElement("tf-feature-flags").tf_feature_flags},this.getFeatureFlags$=Or(()=>this.actions$.pipe(wi(DW),Vi(this.store.select(j6),this.store.select(mf)),U(([,o,a])=>{let s=this.dataSource.getFeatures(o,a);return Mb({features:s})}))),this.updatePolymerFeatureFlags$=Or(()=>this.actions$.pipe(wi(Mb),Yt(this.store.select(Fa),this.store.select(Wh)),Vt(([,o,a])=>{this.tfFeatureFlags.ref.setFeatureFlags(o,a)})),{dispatch:!1}),this.storeFeatureFlag$=Or(()=>this.actions$.pipe(wi(xf),Vt(({flags:o})=>{this.dataSource.persistFeatureFlags(o)})),{dispatch:!1}),this.resetFeatureFlagOverrides$=Or(()=>this.actions$.pipe(wi(Su),Vt(({flags:o})=>{o.forEach(a=>{this.dataSource.resetPersistedFeatureFlag(a)})})),{dispatch:!1}),this.resetAllFeatureFlagOverrides$=Or(()=>this.actions$.pipe(wi(eg),Vt(()=>{this.dataSource.resetAllPersistedFeatureFlags()})),{dispatch:!1})}ngrxOnInitEffects(){return DW()}}return n.\u0275fac=function(e){return new(e||n)(O(Wo),O(ke),O(ZS))},n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})(),kW=(()=>{class n{constructor(e){this.store=e}intercept(e,i){return this.store.pipe(pn(Wh),function(n,t){let e=arguments.length>=2;return i=>i.pipe(n?Ve((r,o)=>n(r,o,i)):la,zt(1),e?function(n){return Kt((t,e)=>{let i=!1;t.subscribe(Ht(e,r=>{i=!0,e.next(r)},()=>{i||e.next(n),e.complete()}))})}(t):SH(()=>new Wm))}(),yi(r=>(e=e.clone({headers:e.headers.set("X-TensorBoard-Feature-Flags",JSON.stringify(r))}),i.handle(e))))}}return n.\u0275fac=function(e){return new(e||n)(O(ke))},n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})();function tg(n){return"false"!==n}var n,HF={scalarsBatchSize:{defaultValue:void 0,queryParamOverride:"scalarsBatchSize",parseValue:parseInt},enabledExperimentalPlugins:{defaultValue:[],queryParamOverride:"experimentalPlugin",parseValue:function(n){return n?n.split(","):[]}},forceSvg:{defaultValue:!1,queryParamOverride:"forceSVG",parseValue:tg},enableDarkModeOverride:{defaultValue:null,queryParamOverride:null},defaultEnableDarkMode:{defaultValue:!1,queryParamOverride:"darkMode",parseValue:tg},isAutoDarkModeAllowed:{defaultValue:!0,queryParamOverride:null},inColab:{defaultValue:!1,queryParamOverride:"tensorboardColab",parseValue:tg},metricsImageSupportEnabled:{defaultValue:!0,queryParamOverride:null},showFlags:{defaultValue:void 0,queryParamOverride:"showFlags",parseValue:n=>n},enableScalarColumnCustomization:{defaultValue:!1,queryParamOverride:"enableScalarColumnCustomization",parseValue:tg},enableHparamsInTimeSeries:{defaultValue:!1,queryParamOverride:"enableHparamsInTimeSeries",parseValue:tg},enableSuggestedCards:{defaultValue:!1,queryParamOverride:"enableSuggestedCards",parseValue:tg}},zF={isFeatureFlagsLoaded:!1,defaultFlags:(n=HF,Object.entries(n).reduce((t,[e,i])=>(t[e]=i.defaultValue,t),{})),metadata:HF,flagOverrides:{}},UF=new ie("[Feature Flag] Store Config");function OW(){return{initialState:zF}}var Kge=_r(zF,Ee(Mb,(n,{features:t})=>({...n,isFeatureFlagsLoaded:!0,flagOverrides:{...n.flagOverrides,...t}})),Ee(KS,(n,{enableDarkMode:t})=>({...n,flagOverrides:{...n.flagOverrides,enableDarkModeOverride:t}})),Ee(xf,(n,t)=>({...n,flagOverrides:{...n.flagOverrides,...t.flags}})),Ee(Su,(n,t)=>{if(!t||!t.flags||!t.flags.length)return n;let e={...n.flagOverrides};return t.flags.forEach(i=>{delete e[i]}),{...n,flagOverrides:e}}),Ee(eg,n=>({...n,flagOverrides:{}})),Ee(Sl,(n,{partialSettings:t})=>{if(!t.themeOverride)return n;let e;switch(t.themeOverride){case Oa.BROWSER_DEFAULT:e=null;break;case Oa.DARK:e=!0;break;case Oa.LIGHT:e=!1}return{...n,flagOverrides:{...n.flagOverrides,enableDarkModeOverride:e}}}));function FW(n,t){return Kge(n,t)}function Jge(){return q(uS,n=>null===n?{themeOverride:Oa.BROWSER_DEFAULT}:{themeOverride:n?Oa.DARK:Oa.LIGHT})}var ng=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({providers:[{provide:UF,useFactory:OW},{provide:wF,useClass:kW,multi:!0}],imports:[TW,wr.forFeature(dS,FW,UF),wo.forFeature([IW]),er.defineGlobalSetting(Jge)]}),n})(),JS=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({providers:[{provide:Mc,useClass:wW}],imports:[ng,qh]}),n})(),ao=(()=>(function(n){n.DEFAULT="default",n.ALPHABETICAL="alphabetical",n.ASCENDING="ascending",n.DESCENDING="descending",n.NEAREST="nearest",n.NEAREST_Y="nearest_Y"}(ao||(ao={})),ao))(),$S="metrics",La=(()=>(function(n){n[n.NONE=0]="NONE",n[n.OVERRIDE_AS_ENABLED=1]="OVERRIDE_AS_ENABLED",n[n.OVERRIDE_AS_DISABLED=2]="OVERRIDE_AS_DISABLED"}(La||(La={})),La))(),e1={cardMinWidth:null,tooltipSort:ao.ALPHABETICAL,ignoreOutliers:!0,xAxisType:Pi.STEP,hideEmptyCards:!0,scalarSmoothing:.6,scalarPartitionNonMonotonicX:!1,imageBrightnessInMilli:1e3,imageContrastInMilli:1e3,imageShowActualSize:!1,histogramMode:Sr.OFFSET},$ge=.1;function md(n,t,e,i){return n[t].hasOwnProperty(e)?ls(t)?n[t][e].hasOwnProperty(i)?n[t][e][i]:null:n[t][e]:null}function t1(n,t,e,i){if(ls(t)){let a={...n[t]},s=function(n,t,e){let r=n.hasOwnProperty(t)?{...n[t]}:{},o=r.hasOwnProperty(e);return r[e]=o?{...r[e]}:{runToSeries:{},runToLoadState:{}},r}(a,e,i);return a[e]=s,a}let r={...n[t]},o=r.hasOwnProperty(e);return r[e]=o?{...r[e]}:{runToSeries:{},runToLoadState:{}},r}function jF(n){return JSON.stringify(n)}function n1(n,t,e){let i={...e};for(let r of t)i[r]=n;return i}function ig(n,t,e,i){if(ls(t)){let o=n[t].tagRunSampledInfo;return o.hasOwnProperty(e)?Object.keys(o[e]).filter(s=>i<o[e][s].maxSamplesPerStep):[]}let r=n[t].tagToRuns;return r.hasOwnProperty(e)?r[e]:[]}function n0e(n,t){return n.plugin===t.plugin&&n.tag===t.tag&&n.sample===t.sample&&(n.runId===t.runId||!n.runId&&!t.runId)}function GF(n,t,e,i,r,o,a,s){let l=new Set(n),c=[];for(let u of n)for(let p of t)if(n0e(e[p],u)){c.push(p),l.delete(u);break}if(!c.length)return{unresolvedImportedPinnedCards:n,cardMetadataMap:e,cardToPinnedCopy:i,cardToPinnedCopyCache:r,pinnedCardToOriginal:o,cardStepIndex:a,cardStateMap:s};let d={cardToPinnedCopy:i,cardToPinnedCopyCache:r,pinnedCardToOriginal:o,cardStepIndex:a,cardMetadataMap:e,cardStateMap:s};for(let u of c)d=WF(u,d.cardToPinnedCopy,d.cardToPinnedCopyCache,d.pinnedCardToOriginal,d.cardStepIndex,d.cardMetadataMap,s);return{...d,unresolvedImportedPinnedCards:[...l]}}function WF(n,t,e,i,r,o,a){if(t.has(n))return{cardToPinnedCopy:t,cardToPinnedCopyCache:e,pinnedCardToOriginal:i,cardStepIndex:r,cardMetadataMap:o,cardStateMap:a};let s=new Map(t),l=new Map(e),c=new Map(i),d={...r},u={...o},p={...a},f=function(n){return JSON.stringify({baseCardId:n})}(n);s.set(n,f),l.set(n,f),c.set(f,n),r.hasOwnProperty(n)&&(d[f]=r[n]);let m=o[n];if(!m)throw new Error("Cannot pin a card without metadata");return u[f]=m,p[n]&&(p[f]=p[n]),{cardToPinnedCopy:s,cardToPinnedCopyCache:l,pinnedCardToOriginal:c,cardStepIndex:d,cardMetadataMap:u,cardStateMap:p}}var i0e={MAX_PIN_COUNT:10};function i1(n){return n.pinnedCardToOriginal.size+n.unresolvedImportedPinnedCards.length<i0e.MAX_PIN_COUNT}function qF(n,t,e,i){let r={...n};return Object.keys(n).forEach(o=>{if(!o.includes('"plugin":"images"'))return;let a=YF(o,t,e),s=null;if(null===i.end)s=function(n,t){let e=t.indexOf(n);if(-1!==e)return{index:e,isClosest:!1};for(let i=0;i<t.length-1;i++){let r=t[i],o=t[i+1],a=(o-r)*$ge;if(n<r)return null;if(!(n>o)){if(n-r<=a)return{index:i,isClosest:!0};if(o-n<=a)return{index:i+1,isClosest:!0}}}return null}(i.start.step,a);else{let c=a[n[o].index],d=function(n,t){if(!n)return[];if(null===n.end)return-1!==t.indexOf(n.start.step)?[n.start.step]:[];let e=[];for(let i of t)i>=n.start.step&&i<=n.end.step&&e.push(i);return e}(i,a);s=function(n,t,e){if(0===n.length)return null;let i=n[0],r=n[n.length-1];return e>r?{index:t.indexOf(r),isClosest:!1}:e<i?{index:t.indexOf(i),isClosest:!1}:null}(d,a,c)}null!==s&&(r[o]=s)}),r}function YF(n,t,e){if(!t.hasOwnProperty(n))return[];let{plugin:i,tag:r,sample:o,runId:a}=t[n];if(null===a)return[];let s=md(e,i,r,o);return null!==s&&s.runToSeries.hasOwnProperty(a)?s.runToSeries[a].map(l=>l.step):[]}function XF(n){let{dataMinMax:t,userViewBox:e}=n,i=e?.x;if(!i)return t;let r=i[0]<i[1]?i[0]:i[1],o=r===i[0]?i[1]:i[0];return{minStep:Math.ceil(r),maxStep:Math.floor(o)}}function r1(n,t){switch(n){case La.OVERRIDE_AS_ENABLED:return!0;case La.OVERRIDE_AS_DISABLED:return!1;default:return t}}function o1(n,t,e,i){return e?t:r1(n[i]?.rangeSelectionOverride,t)}function Cf(n){let t=new Map;return(...e)=>{let i=JSON.stringify(e);if(t.has(i))return t.get(i);{let r=n(...e);return t.set(i,r),r}}}var Gi=Mr($S),wb=q(Gi,n=>n.tagMetadataLoadState),zW=q(Gi,n=>n.tagMetadata),l0e=q(Gi,n=>n.cardList),hd=q(Gi,(n,t)=>{if(!n.cardMetadataMap.hasOwnProperty(t))return De.NOT_LOADED;let{plugin:e,tag:i,runId:r,sample:o}=n.cardMetadataMap[t],a=md(n.timeSeriesData,e,i,o);if(!a)return De.NOT_LOADED;let s=a.runToLoadState;if(r)return s.hasOwnProperty(r)?s[r]:De.NOT_LOADED;let l=ig(n.tagMetadata,e,i,o);if(!l.length)throw new Error("Cannot load a card whose tag has no runs");return l.every(c=>s[c]===De.LOADED)?De.LOADED:l.some(c=>s[c]===De.LOADING)?De.LOADING:De.NOT_LOADED}),c0e=Cf(n=>q(t=>t,t=>{let{plugin:e,tag:i,sample:r}=n,o=md(t.timeSeriesData,e,i,r);return o?o.runToSeries:null})),Eu=q(Gi,(n,t)=>n.cardMetadataMap.hasOwnProperty(t)?c0e(n.cardMetadataMap[t])(n):null),QF=q(Gi,n=>n.cardMetadataMap),Us=q(QF,(n,t)=>n.hasOwnProperty(t)?n[t]:null),js=q(Gi,n=>n.cardStateMap),d0e=q(Gi,n=>n.visibleCardMap),UW=q(d0e,n=>new Set(n.values())),a1=q(l0e,QF,(n,t)=>n.filter(e=>t.hasOwnProperty(e)).map(e=>({cardId:e,...t[e]}))),ZF=q(Gi,(n,t)=>n.cardStepIndex.hasOwnProperty(t)?n.cardStepIndex[t]:null),jW=q(Gi,(n,t)=>YF(t,n.cardMetadataMap,n.timeSeriesData)),GW=q(Gi,n=>n.cardToPinnedCopy),u0e=q(Gi,n=>n.pinnedCardToOriginal),Sb=q(GW,QF,(n,t)=>[...n.values()].filter(e=>t.hasOwnProperty(e)).map(e=>({cardId:e,...t[e]}))),Tu=q(GW,u0e,(n,t,e)=>n.has(e)||t.has(e)),WW=q(Gi,n=>n.unresolvedImportedPinnedCards),qW=q(Gi,n=>i1(n)),Tl=q(Gi,n=>({...n.settings,...n.settingOverrides})),YW=q(Gi,n=>n.settingOverrides),rg=q(Tl,n=>n.cardMinWidth),Mf=q(Tl,n=>n.tooltipSort),wf=q(Tl,n=>n.ignoreOutliers),Dl=q(Tl,n=>n.xAxisType),s1=q(Tl,n=>n.histogramMode),XW=q(Tl,n=>n.hideEmptyCards),gd=q(Tl,n=>n.scalarSmoothing),l1=q(Tl,n=>n.scalarPartitionNonMonotonicX),c1=q(Tl,n=>n.imageBrightnessInMilli),d1=q(Tl,n=>n.imageContrastInMilli),u1=q(Tl,n=>n.imageShowActualSize),Il=q(Gi,n=>n.tagFilter),p1=q(Gi,(n,t)=>Boolean(n.tagGroupExpanded.get(t))),Du=q(Gi,n=>n.linkedTimeEnabled),Eb=q(Gi,n=>n.stepSelectorEnabled),Iu=q(Gi,n=>n.rangeSelectionEnabled),KF=q(Gi,n=>{let{min:t,max:e}=n.stepMinMax;return{min:t===1/0?0:t,max:e===-1/0?1e3:e}}),JF=q(Gi,KF,(n,t)=>n.linkedTimeSelection?n.linkedTimeSelection:{start:{step:t.max},end:null}),Au=q(Gi,JF,(n,t)=>n.linkedTimeEnabled?t:null),wc=q(Gi,n=>n.filteredPluginTypes),f1=q(Gi,n=>n.isSettingsPaneOpen),m1=q(Gi,n=>n.isSlideoutMenuOpen),QW=q(Gi,n=>n.tableEditorSelectedTab),h1=q(js,Iu,Du,(n,t,e,i)=>o1(n,t,e,i)),ZW=q(js,(n,t)=>{if(n[t])return XF(n[t])}),KW=q(js,(n,t)=>n[t]?.dataMinMax),$F=q(js,(n,t)=>n[t]?.userViewBox??null),JW=q(js,Eb,Iu,Du,Au,(n,t,e,i,r,o)=>{let a=n[o];if(!a)return;let s=XF(a);if(!s)return;if(i&&r)return FF(r,s,e);if(!r1(a.stepSelectionOverride,t))return;let l=r1(a.rangeSelectionOverride,e),c=a.timeSelection;return c||(c={start:{step:s.minStep},end:{step:s.maxStep}}),l?c.end||(c={start:{step:s.minStep},end:c.start}):c={start:c.end??c.start,end:null},FF(c,s,l)}),Tb=q(Gi,n=>n.singleSelectionHeaders),Db=q(Gi,n=>n.rangeSelectionHeaders),g1=Cf(n=>q(t=>t,Tb,Db,(t,e,i)=>h1(t,n)?i:e)),e7=Mr("notification"),Sc=(q(e7,n=>n.notifications),q(e7,n=>n.lastReadTimestampInMs??-1),(()=>(function(n){n[n.EXPERIMENT_NAME=0]="EXPERIMENT_NAME",n[n.HPARAM=1]="HPARAM",n[n.METRIC=2]="METRIC",n[n.RUN_NAME=3]="RUN_NAME"}(Sc||(Sc={})),Sc))()),Qi=(()=>(function(n){n[n.RUN=0]="RUN",n[n.EXPERIMENT=1]="EXPERIMENT",n[n.REGEX=2]="REGEX"}(Qi||(Qi={})),Qi))();function Ab(n,t,e){let i={},r=[],o={matches:i,nonMatches:r};switch(n.key){case Qi.RUN:for(let s of t)i[s.id]=[s];break;case Qi.EXPERIMENT:for(let s of t){let l=e[s.id],c=i[l]||[];c.push(s),i[l]=c}break;case Qi.REGEX:if(!n.regexString)break;let a;try{a=new RegExp(n.regexString)}catch{break}for(let s of t){let l=s.name.match(a);if(l){let d=l.length>1?JSON.stringify(l.slice(1)):"pseudo_group",u=i[d]||[];u.push(s),i[d]=u}else r.push(s)}}return o}function y1(n,t){return n===Qi.REGEX?{key:n,regexString:t??""}:{key:n}}var t7=Mr("runs"),Na=q(t7,n=>n.data),n7=q(Na,n=>n.runIdToExpId),b1=q(Na,(n,t)=>n.runIdToExpId[t.runId]??null),v1=q(Na,(n,t)=>n.runMetadata[t.runId]??null),Ec=q(Na,(n,t)=>(n.runIds[t.experimentId]||[]).filter(i=>Boolean(n.runMetadata[i])).map(i=>n.runMetadata[i])),r7=q(Na,(n,t)=>n.runIds[t.experimentId]??[]),o7=q(Na,n=>new Map(Object.entries(n.runMetadata))),Rb=q(Na,(n,t)=>n.runsLoadState[t.experimentId]||{lastLoadedTimeInMs:null,state:De.NOT_LOADED}),e2=q(Na,n=>null!==n.userSetGroupByKey?y1(n.userSetGroupByKey,n.colorGroupRegexString):null),a7=q(e2,Na,(n,t)=>n??t.initialGroupBy),_d=q(Na,n=>n.regexFilter),kb=q(t7,n=>n.ui),t2=q(kb,n=>n.paginationOption),n2=q(kb,n=>n.sort),s7=q(kb,n=>n.selectionState),l7=q(Na,n=>n.runColorOverrideForGroupBy),c7=q(Na,n=>n.defaultRunColorIdForGroupBy),x1=q(Na,n=>n.colorGroupRegexString),d7=q(kb,n=>n.runsTableHeaders),u7=q(kb,n=>n.sortingInfo),C1=ye("[Settings] Reload Enable Toggled"),M1=ye("[Settings] Reload Period Change",{_as:"props",_p:void 0}),w1=ye("[Settings] Page Size Change",{_as:"props",_p:void 0}),Ba={};zA(Ba,{getColorPalette:()=>p0e,getPageSize:()=>Sf,getReloadEnabled:()=>Ob,getReloadPeriodInMs:()=>Fb,getSettingsLoadState:()=>i2});var S1="settings",m7={state:De.LOADED,lastLoadedTimeInMs:Date.now(),settings:{reloadPeriodInMs:3e4,reloadEnabled:!1,pageSize:12,colorPalette:{id:"default",name:"Defalt",colors:[{name:"Slate",lightHex:"#425066",darkHex:"#8e98a3"},{name:"Cyan",lightHex:"#12b5cb",darkHex:"#12b5cb"},{name:"Pink",lightHex:"#e52592",darkHex:"#e52592"},{name:"Yellow",lightHex:"#f9ab00",darkHex:"#f9ab00"},{name:"Purple",lightHex:"#9334e6",darkHex:"#9334e6"},{name:"Light Green",lightHex:"#7cb342",darkHex:"#7cb342"},{name:"Orange",lightHex:"#e8710a",darkHex:"#e8710a"}],inactive:{name:"Gray",lightHex:"#e0e0e0",darkHex:"#3b3b3b"}}}},Pb=Mr(S1),i2=q(Pb,n=>n.state),Ob=q(Pb,n=>n.settings.reloadEnabled),Fb=q(Pb,n=>n.settings.reloadPeriodInMs),Sf=q(Pb,n=>n.settings.pageSize),p0e=q(Pb,n=>n.settings.colorPalette);function og(n,t,e){if(!t)return!0;let i;try{i=new RegExp(t,"i")}catch{return!1}let r=[n.runName];return e&&r.push(n.experimentAlias.aliasText,`${n.experimentAlias.aliasText}/${n.runName}`),r.some(o=>i.test(o))}var f0e=q(ro,s7,n7,(n,t,e)=>{if(!n)return new Map;let i=new Map;for(let[r,o]of t.entries()){let a=e[r];a&&n.indexOf(a)>=0&&i.set(r,o)}return i}),Ru=q(ro,f0e,_d,n=>{let t=ro(n)??[],e=Bs(n),i=new Map;for(let r of t){let o=Ec(n,{experimentId:r});for(let a of o)i.set(a.id,{runName:a.name,experimentAlias:e[r]})}return i},Ns,(n,t,e,i,r)=>{if(!n)return null;let o=r===kn.COMPARE_EXPERIMENT,a=new Map;for(let[s,l]of t.entries()){let c=i.get(s);a.set(s,og(c,e,o)&&l)}return a}),ku=q(Ba.getColorPalette,c7,l7,El,(n,t,e,i)=>{let r={};return t.forEach((o,a)=>{let s=i?n.inactive.darkHex:n.inactive.lightHex;if(e.has(a))s=e.get(a);else if(o>=0){let l=n.colors[o%n.colors.length];s=i?l.darkHex:l.lightHex}r[a]=s}),r}),h7=(()=>{class n{constructor(e,i,r){this.actions$=e,this.store=i,this.runsDataSource=r,this.loadRunsOnRunTableShown$=Or(()=>this.actions$.pipe(wi(PS),hn(({experimentIds:o})=>this.getExperimentsWithLoadState(o,s=>s===De.FAILED||s===De.NOT_LOADED).pipe(Ve(s=>!!s.length),hn(s=>this.fetchAllRunsList(o,s))))),{dispatch:!1}),this.experimentsWithStaleRunsOnRouteChange$=this.actions$.pipe(wi(Ls),Yt(this.store.select(fa)),ui(([,o],[,a])=>Lo(o,a)),Yt(this.store.select(ro)),Ve(([,o])=>!!o),U(([,o])=>o),hn(o=>this.getExperimentsWithLoadState(o,a=>a===De.FAILED||a===De.NOT_LOADED).pipe(U(a=>({experimentIds:o,experimentIdsToBeFetched:a}))))),this.experimentsWithStaleRunsOnReload$=this.actions$.pipe(wi(ss,Hs),Yt(this.store.select(ro)),Ve(([,o])=>!!o),U(([,o])=>o),hn(o=>this.getExperimentsWithLoadState(o,a=>a!==De.LOADING).pipe(U(a=>({experimentIds:o,experimentIdsToBeFetched:a}))))),this.loadRunsOnNavigationOrReload$=Or(()=>cn(this.experimentsWithStaleRunsOnRouteChange$,this.experimentsWithStaleRunsOnReload$).pipe(Yt(this.store.select(fa)),Ve(([,o])=>null!==o&&o.routeKind!==kn.CARD),hn(([{experimentIds:o,experimentIdsToBeFetched:a}])=>this.fetchAllRunsList(o,a))),{dispatch:!1})}getRunsListLoadState(e){return this.store.select(Rb,{experimentId:e}).pipe(zt(1))}getExperimentsWithLoadState(e,i){return po(e.map(r=>this.getRunsListLoadState(r))).pipe(U(r=>e.filter((o,a)=>i(r[a].state))))}fetchAllRunsList(e,i){return qt({experimentIds:e,experimentIdsToBeFetched:i}).pipe(Vt(()=>{this.store.dispatch(DS({experimentIds:e,requestedExperimentIds:i}))}),hn(()=>{let r=new Set(i);return po(e.map(a=>r.has(a)?this.fetchRunsForExperiment(a):this.maybeWaitForRunsAndGetRuns(a)))}),U(r=>{let o={},a=[];for(let s of r)a.push(...s.runs),s.fromRemote&&(o[s.experimentId]={runs:s.runs,metadata:s.metadata});return{newRunsAndMetadata:o,runsForAllExperiments:a}}),Vt(({newRunsAndMetadata:r,runsForAllExperiments:o})=>{this.store.dispatch(Mu({experimentIds:e,newRunsAndMetadata:r,runsForAllExperiments:o}))}),fo(r=>(this.store.dispatch(Kh({experimentIds:e,requestedExperimentIds:i})),qt(null))),U(()=>null))}maybeWaitForRunsAndGetRuns(e){return this.store.select(Rb,{experimentId:e}).pipe(Ve(i=>i.state!==De.LOADING),zt(1),hn(i=>i.state===De.FAILED?cl(new Error("Pending request failed")):qt(i)),Yt(this.store.select(Ec,{experimentId:e})),U(([,i])=>({fromRemote:!1,experimentId:e,runs:i})))}fetchRunsForExperiment(e){return po([this.runsDataSource.fetchRuns(e),this.runsDataSource.fetchHparamsMetadata(e)]).pipe(U(([i,r])=>({fromRemote:!0,experimentId:e,runs:i,metadata:r})))}}return n.\u0275fac=function(e){return new(e||n)(O(Wo),O(ke),O(BS))},n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})(),Gs=(()=>(function(n){n.ASC="asc",n.DESC="desc",n.UNSET=""}(Gs||(Gs={})),Gs))(),vt=(()=>(function(n){n.COLOR="COLOR",n.RELATIVE_TIME="RELATIVE_TIME",n.RUN="RUN",n.STEP="STEP",n.TIME="TIME",n.VALUE="VALUE",n.SMOOTHED="SMOOTHED",n.VALUE_CHANGE="VALUE_CHANGE",n.START_STEP="START_STEP",n.END_STEP="END_STEP",n.START_VALUE="START_VALUE",n.END_VALUE="END_VALUE",n.MIN_VALUE="MIN_VALUE",n.MAX_VALUE="MAX_VALUE",n.PERCENTAGE_CHANGE="PERCENTAGE_CHANGE",n.STEP_AT_MAX="STEP_AT_MAX",n.STEP_AT_MIN="STEP_AT_MIN",n.MEAN="MEAN",n.RAW_CHANGE="RAW_CHANGE",n.HPARAM="HPARAM",n.CUSTOM="CUSTOM"}(vt||(vt={})),vt))(),so=(()=>(function(n){n[n.ASCENDING=0]="ASCENDING",n[n.DESCENDING=1]="DESCENDING"}(so||(so={})),so))(),lo=(()=>(function(n){n[n.SINGLE=0]="SINGLE",n[n.RANGE=1]="RANGE"}(lo||(lo={})),lo))(),{initialState:m0e,reducers:h0e}=_f({runColorOverrideForGroupBy:new Map,defaultRunColorIdForGroupBy:new Map,groupKeyToColorId:new Map,initialGroupBy:{key:Qi.RUN},userSetGroupByKey:null,colorGroupRegexString:"",regexFilter:""},{runIds:{},runIdToExpId:{},runMetadata:{},runsLoadState:{}},(n,t,e)=>Lo(t,e)?n:{...n,initialGroupBy:{key:e.routeKind===kn.COMPARE_EXPERIMENT?Qi.EXPERIMENT:Qi.RUN}}),g0e=_r(m0e,Ee(Vh,(n,{routeKind:t,partialState:e})=>{if(t!==kn.COMPARE_EXPERIMENT&&t!==kn.EXPERIMENT)return n;let r=e.runs.groupBy,o=e.runs.regexFilter??"";if(!r&&!o)return n;let{colorGroupRegexString:a,userSetGroupByKey:s}=n;return r&&(a=r.key===Qi.REGEX?r.regexString:n.colorGroupRegexString,s=r.key??null),{...n,colorGroupRegexString:a,regexFilter:o,userSetGroupByKey:s}}),Ee(DS,(n,t)=>{let e={...n.runsLoadState};for(let i of t.requestedExperimentIds)e[i]=e[i]?{...e[i],state:De.LOADING}:{lastLoadedTimeInMs:null,state:De.LOADING};return{...n,runsLoadState:e}}),Ee(Mu,(n,t)=>{let e={...n.runIds},i={...n.runMetadata},r={...n.runIdToExpId},o={...n.runsLoadState};for(let a of Object.keys(t.newRunsAndMetadata)){let{runs:s,metadata:l}=t.newRunsAndMetadata[a];e[a]=s.map(({id:c})=>c),o[a]={...o[a],lastLoadedTimeInMs:Date.now(),state:De.LOADED};for(let c of s){let d=l.runToHparamsAndMetrics[c.id];i[c.id]={...c,hparams:d?d.hparams:null,metrics:d?d.metrics:null},r[c.id]=a}}return{...n,runIds:e,runIdToExpId:r,runMetadata:i,runsLoadState:o}}),Ee(Kh,(n,t)=>{let e={...n.runsLoadState};for(let i of t.requestedExperimentIds)e[i]=e[i]?{...e[i],state:De.FAILED}:{lastLoadedTimeInMs:null,state:De.FAILED};return{...n,runsLoadState:e}}),Ee(Mu,(n,{runsForAllExperiments:t})=>{let e=new Map(n.groupKeyToColorId),i=new Map(n.defaultRunColorIdForGroupBy),r=n.initialGroupBy;null!==n.userSetGroupByKey&&(r=y1(n.userSetGroupByKey,n.colorGroupRegexString));let o=Ab(r,t,n.runIdToExpId);Object.entries(o.matches).forEach(([a,s])=>{let l=e.get(a)??e.size;e.set(a,l);for(let c of s)i.set(c.id,l)});for(let a of o.nonMatches)i.set(a.id,-1);return{...n,defaultRunColorIdForGroupBy:i,groupKeyToColorId:e}}),Ee(Jh,(n,{experimentIds:t,groupBy:e})=>{let i=new Map,r=new Map(n.defaultRunColorIdForGroupBy),a=Ab(e,t.flatMap(l=>n.runIds[l]).map(l=>n.runMetadata[l]),n.runIdToExpId);Object.entries(a.matches).forEach(([l,c])=>{let d=i.get(l)??i.size;i.set(l,d);for(let u of c)r.set(u.id,d)});for(let l of a.nonMatches)r.set(l.id,-1);let s=e.key===Qi.REGEX?e.regexString:n.colorGroupRegexString;return{...n,colorGroupRegexString:s,userSetGroupByKey:e.key,defaultRunColorIdForGroupBy:r,groupKeyToColorId:i,runColorOverrideForGroupBy:new Map}}),Ee(kS,(n,{runId:t,newColor:e})=>{let i=new Map(n.runColorOverrideForGroupBy);return i.set(t,e),{...n,runColorOverrideForGroupBy:i}}),Ee(bb,(n,t)=>({...n,regexFilter:t.regexString}))),_0e=yf(g0e,h0e),y0e={key:null,direction:Gs.UNSET},{initialState:b0e,reducers:v0e}=_f({paginationOption:{pageIndex:0,pageSize:10},sort:y0e,selectionState:new Map,runsTableHeaders:[{type:vt.RUN,name:"run",displayName:"Run",enabled:!0,sortable:!0,movable:!0}],sortingInfo:{name:"run",order:so.DESCENDING}},{},(n,t,e)=>{if(!Lo(t,e)){if(e.routeKind===kn.COMPARE_EXPERIMENT&&!n.runsTableHeaders.find(i=>"experimentAlias"===i.name)){let i=[...n.runsTableHeaders,{type:vt.CUSTOM,name:"experimentAlias",displayName:"Experiment",enabled:!0,movable:!0,sortable:!0}];return{...n,runsTableHeaders:i}}if(t?.routeKind===kn.COMPARE_EXPERIMENT&&e.routeKind!==kn.COMPARE_EXPERIMENT){let i=n.runsTableHeaders.filter(r=>"experimentAlias"!==r.name);return{...n,runsTableHeaders:i}}}return n}),x0e=_r(b0e,Ee(AS,(n,{pageSize:t,pageIndex:e})=>({...n,paginationOption:{pageSize:t,pageIndex:e}})),Ee(bb,(n,t)=>({...n,paginationOption:{...n.paginationOption,pageIndex:0}})),Ee(RS,(n,t)=>({...n,sort:{key:t.key,direction:t.direction}})),Ee(Mu,(n,t)=>{let e=new Map(n.selectionState),i=t.runsForAllExperiments.length<=500;for(let r of t.runsForAllExperiments)e.has(r.id)||e.set(r.id,i);return{...n,selectionState:e}}),Ee(_b,(n,{runId:t})=>{let e=new Map(n.selectionState);return e.set(t,!Boolean(e.get(t))),{...n,selectionState:e}}),Ee(IS,(n,{runId:t})=>{let e=new Map;for(let i of n.selectionState.keys())e.set(i,t===i);return{...n,selectionState:e}}),Ee(yb,(n,{runIds:t})=>{let e=new Map(n.selectionState),i=!t.every(r=>Boolean(e.get(r)));for(let r of t)e.set(r,i);return{...n,selectionState:e}}),Ee(OS,(n,{header:t,index:e})=>{let i=[...n.runsTableHeaders];return void 0===e?i.push(t):i.splice(e,0,t),{...n,runsTableHeaders:i}}),Ee(FS,(n,{header:t})=>{let e=n.runsTableHeaders.filter(({name:i})=>i!==t.name);return{...n,runsTableHeaders:e}}),Ee(LS,(n,{newHeaderOrder:t})=>({...n,runsTableHeaders:t})),Ee(NS,(n,{sortingInfo:t})=>({...n,sortingInfo:t}))),C0e=yf(x0e,v0e);function g7(n,t){return cf({data:_0e,ui:C0e})(n,t)}function M0e(){return[{actionCreator:Kh,alertFromAction:()=>({localizedMessage:"Failed to fetch runs"})}]}var E1=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[wr.forFeature("runs",g7),wo.forFeature([h7]),pW,Cc.registerAlertActions(M0e),zS]}),n})(),yd=(()=>(function(n){n.RUNS_CHANGED="experimental.RunsChanged",n.GET_RUNS="experimental.GetRuns",n.GET_URL_DATA="experimental.GetURLPluginData",n.DATA_RELOADED="experimental.DataReloaded"}(yd||(yd={})),yd))(),y7=new WeakMap,ag=new Set,r2=new Map,D1=new Map;function b7(n,t){return e=>{let i=D1.get(t),r=y7.get(i)||null;return n(r,e)}}window.addEventListener("message",n=>{if("experimental.bootstrap"!==n.data)return;let t=n.ports[0];if(!t)return;let e=n.source?n.source.frameElement:null;!e||function(n,t){let e=new class{constructor(t){this.port=t,this.id=0,this.responseWaits=new Map,this.listeners=new Map,this.port.addEventListener("message",e=>this.onMessage(e))}listen(t,e){this.listeners.set(t,e)}unlisten(t){this.listeners.delete(t)}async onMessage(t){let e=JSON.parse(t.data),i=e.type,r=e.id,o=e.payload,a=e.error;if(e.isReply){if(!this.responseWaits.has(r))return;let{resolve:u,reject:p}=this.responseWaits.get(r);return this.responseWaits.delete(r),void(a?p(new Error(a)):u(o))}let l=null,c=null;if(this.listeners.has(i)){let u=this.listeners.get(i);try{l=await u(o)}catch(p){c=p}}this.postMessage({type:i,id:r,payload:l,error:c,isReply:!0})}postMessage(t){this.port.postMessage(JSON.stringify(t))}sendMessage(t,e){let i=this.id++;return this.postMessage({type:t,id:i,payload:e,error:null,isReply:!1}),new Promise((o,a)=>{this.responseWaits.set(i,{resolve:o,reject:a})})}}(n);ag.add(e),D1.set(e,t),n.start();for(let[i,r]of r2){let o=b7(r,e);e.listen(i,o)}}(t,e)});var a2,sg=(()=>{class n{broadcast(e,i){return function(n,t){for(let i of ag)D1.get(i).isConnected||(ag.delete(i),D1.delete(i));let e=[...ag].map(i=>i.sendMessage(n,t));return Promise.all(e)}(e,i)}listen(e,i){!function(n,t){r2.set(n,t);for(let e of ag){let i=b7(t,e);e.listen(n,i)}}(e,i)}unlisten(e){!function(n){r2.delete(n);for(let t of ag)t.unlisten(n)}(e)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})(),I1=(()=>{class n{constructor(e,i){this.ipc=e,this.store=i}init(){let e=document.createElement("tf-storage");this.ipc.listen(yd.GET_URL_DATA,i=>{if(!i)return;let r=`p.${i.pluginName}.`,o={},a=e.tf_storage.getUrlHashDict();for(let s in a)s.startsWith(r)&&(o[s.substring(r.length)]=a[s]);return o}),this.store.select(Xh).pipe(Ve(i=>null!==i),ui()).subscribe(()=>{this.ipc.broadcast(yd.DATA_RELOADED,void 0)})}}return n.\u0275fac=function(e){return new(e||n)(O(sg),O(ke))},n.\u0275prov=pe({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),A1=(()=>{class n{constructor(e,i){this.ipc=e,this.store=i}init(){let e=this.store.select(ro).pipe(hn(i=>i?un(i.map(o=>this.store.select(Ec,{experimentId:o}))).pipe(U(o=>o.flat()),ui((o,a)=>o.length===a.length&&o.every((s,l)=>a[l].id===s.id)),U(o=>o.map(({name:a})=>a))):qt([])));e.subscribe(i=>{this.ipc.broadcast(yd.RUNS_CHANGED,i)}),this.ipc.listen(yd.GET_RUNS,()=>e.pipe(zt(1)).toPromise())}}return n.\u0275fac=function(e){return new(e||n)(O(sg),O(ke))},n.\u0275prov=pe({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),R1=(()=>{class n{constructor(e,i){i.init(),e.init()}registerPluginIframe(e,i){!function(n,t){y7.set(n,{pluginName:t})}(e,i)}}return n.\u0275fac=function(e){return new(e||n)(O(A1),O(I1))},n.\u0275mod=V({type:n}),n.\u0275inj=B({providers:[sg,I1,A1],imports:[Uh,zs,E1]}),n})(),lg=ye("[Alert] Alert Reported",{_as:"props",_p:void 0}),C7=(()=>{class n{constructor(e,i,r){this.actions$=e,this.store=i,this.alertActionModule=r,this.reportRegisteredActionAlerts$=Or(()=>this.actions$.pipe(Vt(o=>{let a=this.alertActionModule.getAlertFromAction(o);a&&this.store.dispatch(lg(a))})),{dispatch:!1})}}return n.\u0275fac=function(e){return new(e||n)(O(Wo),O(ke),O(Cc))},n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})(),P0e=_r({latestAlert:null},Ee(lg,(n,{localizedMessage:t,followupAction:e})=>{let i={localizedMessage:t,created:Date.now()};return e&&(i.followupAction=e),{...n,latestAlert:i}}));function M7(n,t){return P0e(n,t)}try{a2=typeof Intl<"u"&&Intl.v8BreakIterator}catch{a2=!1}var cg,Nb,k1,Ef,o2,$n=(()=>{class n{constructor(e){this._platformId=e,this.isBrowser=this._platformId?bw(this._platformId):"object"==typeof document&&!!document,this.EDGE=this.isBrowser&&/(edge)/i.test(navigator.userAgent),this.TRIDENT=this.isBrowser&&/(msie|trident)/i.test(navigator.userAgent),this.BLINK=this.isBrowser&&!(!window.chrome&&!a2)&&typeof CSS<"u"&&!this.EDGE&&!this.TRIDENT,this.WEBKIT=this.isBrowser&&/AppleWebKit/i.test(navigator.userAgent)&&!this.BLINK&&!this.EDGE&&!this.TRIDENT,this.IOS=this.isBrowser&&/iPad|iPhone|iPod/.test(navigator.userAgent)&&!("MSStream"in window),this.FIREFOX=this.isBrowser&&/(firefox|minefield)/i.test(navigator.userAgent),this.ANDROID=this.isBrowser&&/android/i.test(navigator.userAgent)&&!this.TRIDENT,this.SAFARI=this.isBrowser&&/safari/i.test(navigator.userAgent)&&this.WEBKIT}}return n.\u0275fac=function(e){return new(e||n)(O(hc))},n.\u0275prov=pe({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),w7=["color","button","checkbox","date","datetime-local","email","file","hidden","image","month","number","password","radio","range","reset","search","submit","tel","text","time","url","week"];function s2(){if(cg)return cg;if("object"!=typeof document||!document)return cg=new Set(w7);let n=document.createElement("input");return cg=new Set(w7.filter(t=>(n.setAttribute("type",t),n.type===t)))}function Yo(n){return function(){if(null==Nb&&typeof window<"u")try{window.addEventListener("test",null,Object.defineProperty({},"passive",{get:()=>Nb=!0}))}finally{Nb=Nb||!1}return Nb}()?n:!!n.capture}function P1(){if(null==Ef){if("object"!=typeof document||!document||"function"!=typeof Element||!Element)return Ef=!1;if("scrollBehavior"in document.documentElement.style)Ef=!0;else{let n=Element.prototype.scrollTo;Ef=!!n&&!/\{\s*\[native code\]\s*\}/.test(n.toString())}}return Ef}function dg(){if("object"!=typeof document||!document)return 0;if(null==k1){let n=document.createElement("div"),t=n.style;n.dir="rtl",t.width="1px",t.overflow="auto",t.visibility="hidden",t.pointerEvents="none",t.position="absolute";let e=document.createElement("div"),i=e.style;i.width="2px",i.height="1px",n.appendChild(e),document.body.appendChild(n),k1=0,0===n.scrollLeft&&(n.scrollLeft=1,k1=0===n.scrollLeft?1:2),n.remove()}return k1}function O1(n){if(function(){if(null==o2){let n=typeof document<"u"?document.head:null;o2=!(!n||!n.createShadowRoot&&!n.attachShadow)}return o2}()){let t=n.getRootNode?n.getRootNode():null;if(typeof ShadowRoot<"u"&&ShadowRoot&&t instanceof ShadowRoot)return t}return null}function Bb(){let n=typeof document<"u"&&document?document.activeElement:null;for(;n&&n.shadowRoot;){let t=n.shadowRoot.activeElement;if(t===n)break;n=t}return n}function ds(n){return n.composedPath?n.composedPath()[0]:n.target}function Vb(){return typeof __karma__<"u"&&!!__karma__||typeof jasmine<"u"&&!!jasmine||typeof jest<"u"&&!!jest||typeof Mocha<"u"&&!!Mocha}function yr(n,...t){return t.length?t.some(e=>n[e]):n.altKey||n.shiftKey||n.ctrlKey||n.metaKey}function Ut(n){return null!=n&&"false"!=`${n}`}function Di(n,t=0){return l2(n)?Number(n):t}function l2(n){return!isNaN(parseFloat(n))&&!isNaN(Number(n))}function ug(n){return Array.isArray(n)?n:[n]}function Zr(n){return null==n?"":"string"==typeof n?n:`${n}px`}function Va(n){return n instanceof be?n.nativeElement:n}var fg,E7=(()=>{class n{create(e){return typeof MutationObserver>"u"?null:new MutationObserver(e)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=pe({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),L0e=(()=>{class n{constructor(e){this._mutationObserverFactory=e,this._observedElements=new Map}ngOnDestroy(){this._observedElements.forEach((e,i)=>this._cleanupObserver(i))}observe(e){let i=Va(e);return new en(r=>{let a=this._observeElement(i).subscribe(r);return()=>{a.unsubscribe(),this._unobserveElement(i)}})}_observeElement(e){if(this._observedElements.has(e))this._observedElements.get(e).count++;else{let i=new Ae,r=this._mutationObserverFactory.create(o=>i.next(o));r&&r.observe(e,{characterData:!0,childList:!0,subtree:!0}),this._observedElements.set(e,{observer:r,stream:i,count:1})}return this._observedElements.get(e).stream}_unobserveElement(e){this._observedElements.has(e)&&(this._observedElements.get(e).count--,this._observedElements.get(e).count||this._cleanupObserver(e))}_cleanupObserver(e){if(this._observedElements.has(e)){let{observer:i,stream:r}=this._observedElements.get(e);i&&i.disconnect(),r.complete(),this._observedElements.delete(e)}}}return n.\u0275fac=function(e){return new(e||n)(O(E7))},n.\u0275prov=pe({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),pg=(()=>{class n{get disabled(){return this._disabled}set disabled(e){this._disabled=Ut(e),this._disabled?this._unsubscribe():this._subscribe()}get debounce(){return this._debounce}set debounce(e){this._debounce=Di(e),this._subscribe()}constructor(e,i,r){this._contentObserver=e,this._elementRef=i,this._ngZone=r,this.event=new L,this._disabled=!1,this._currentSubscription=null}ngAfterContentInit(){!this._currentSubscription&&!this.disabled&&this._subscribe()}ngOnDestroy(){this._unsubscribe()}_subscribe(){this._unsubscribe();let e=this._contentObserver.observe(this._elementRef);this._ngZone.runOutsideAngular(()=>{this._currentSubscription=(this.debounce?e.pipe(Cr(this.debounce)):e).subscribe(this.event)})}_unsubscribe(){this._currentSubscription?.unsubscribe()}}return n.\u0275fac=function(e){return new(e||n)(C(L0e),C(be),C(at))},n.\u0275dir=xe({type:n,selectors:[["","cdkObserveContent",""]],inputs:{disabled:["cdkObserveContentDisabled","disabled"],debounce:"debounce"},outputs:{event:"cdkObserveContent"},exportAs:["cdkObserveContent"]}),n})(),Pu=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({providers:[E7]}),n})(),T7=new Set,N0e=(()=>{class n{constructor(e){this._platform=e,this._matchMedia=this._platform.isBrowser&&window.matchMedia?window.matchMedia.bind(window):V0e}matchMedia(e){return(this._platform.WEBKIT||this._platform.BLINK)&&function(n){if(!T7.has(n))try{fg||((fg=document.createElement("style")).setAttribute("type","text/css"),document.head.appendChild(fg)),fg.sheet&&(fg.sheet.insertRule(`@media ${n} {body{ }}`,0),T7.add(n))}catch(t){console.error(t)}}(e),this._matchMedia(e)}}return n.\u0275fac=function(e){return new(e||n)(O($n))},n.\u0275prov=pe({token:n,factory:n.\u0275fac,providedIn:"root"}),n})();function V0e(n){return{matches:"all"===n||""===n,media:n,addListener:()=>{},removeListener:()=>{}}}var Ou=(()=>{class n{constructor(e,i){this._mediaMatcher=e,this._zone=i,this._queries=new Map,this._destroySubject=new Ae}ngOnDestroy(){this._destroySubject.next(),this._destroySubject.complete()}isMatched(e){return D7(ug(e)).some(r=>this._registerQuery(r).mql.matches)}observe(e){let o=un(D7(ug(e)).map(a=>this._registerQuery(a).observable));return o=$d(o.pipe(zt(1)),o.pipe($a(1),Cr(0))),o.pipe(U(a=>{let s={matches:!1,breakpoints:{}};return a.forEach(({matches:l,query:c})=>{s.matches=s.matches||l,s.breakpoints[c]=l}),s}))}_registerQuery(e){if(this._queries.has(e))return this._queries.get(e);let i=this._mediaMatcher.matchMedia(e),o={observable:new en(a=>{let s=l=>this._zone.run(()=>a.next(l));return i.addListener(s),()=>{i.removeListener(s)}}).pipe(Nn(i),U(({matches:a})=>({query:e,matches:a})),ot(this._destroySubject)),mql:i};return this._queries.set(e,o),o}}return n.\u0275fac=function(e){return new(e||n)(O(N0e),O(at))},n.\u0275prov=pe({token:n,factory:n.\u0275fac,providedIn:"root"}),n})();function D7(n){return n.map(t=>t.split(",")).reduce((t,e)=>t.concat(e)).map(t=>t.trim())}function B1(n,t){return(n.getAttribute(t)||"").match(/\S+/g)||[]}var O7="cdk-describedby-message",L1="cdk-describedby-host",f2=0,H1=(()=>{class n{constructor(e,i){this._platform=i,this._messageRegistry=new Map,this._messagesContainer=null,this._id=""+f2++,this._document=e,this._id=pi($p)+"-"+f2++}describe(e,i,r){if(!this._canBeDescribed(e,i))return;let o=u2(i,r);"string"!=typeof i?(I7(i,this._id),this._messageRegistry.set(o,{messageElement:i,referenceCount:0})):this._messageRegistry.has(o)||this._createMessageElement(i,r),this._isElementDescribedByMessage(e,o)||this._addMessageReference(e,o)}removeDescription(e,i,r){if(!i||!this._isElementNode(e))return;let o=u2(i,r);if(this._isElementDescribedByMessage(e,o)&&this._removeMessageReference(e,o),"string"==typeof i){let a=this._messageRegistry.get(o);a&&0===a.referenceCount&&this._deleteMessageElement(o)}0===this._messagesContainer?.childNodes.length&&(this._messagesContainer.remove(),this._messagesContainer=null)}ngOnDestroy(){let e=this._document.querySelectorAll(`[${L1}="${this._id}"]`);for(let i=0;i<e.length;i++)this._removeCdkDescribedByReferenceIds(e[i]),e[i].removeAttribute(L1);this._messagesContainer?.remove(),this._messagesContainer=null,this._messageRegistry.clear()}_createMessageElement(e,i){let r=this._document.createElement("div");I7(r,this._id),r.textContent=e,i&&r.setAttribute("role",i),this._createMessagesContainer(),this._messagesContainer.appendChild(r),this._messageRegistry.set(u2(e,i),{messageElement:r,referenceCount:0})}_deleteMessageElement(e){this._messageRegistry.get(e)?.messageElement?.remove(),this._messageRegistry.delete(e)}_createMessagesContainer(){if(this._messagesContainer)return;let e="cdk-describedby-message-container",i=this._document.querySelectorAll(`.${e}[platform="server"]`);for(let o=0;o<i.length;o++)i[o].remove();let r=this._document.createElement("div");r.style.visibility="hidden",r.classList.add(e),r.classList.add("cdk-visually-hidden"),this._platform&&!this._platform.isBrowser&&r.setAttribute("platform","server"),this._document.body.appendChild(r),this._messagesContainer=r}_removeCdkDescribedByReferenceIds(e){let i=B1(e,"aria-describedby").filter(r=>0!=r.indexOf(O7));e.setAttribute("aria-describedby",i.join(" "))}_addMessageReference(e,i){let r=this._messageRegistry.get(i);(function(n,t,e){let i=B1(n,t);i.some(r=>r.trim()==e.trim())||(i.push(e.trim()),n.setAttribute(t,i.join(" ")))})(e,"aria-describedby",r.messageElement.id),e.setAttribute(L1,this._id),r.referenceCount++}_removeMessageReference(e,i){let r=this._messageRegistry.get(i);r.referenceCount--,function(n,t,e){let r=B1(n,t).filter(o=>o!=e.trim());r.length?n.setAttribute(t,r.join(" ")):n.removeAttribute(t)}(e,"aria-describedby",r.messageElement.id),e.removeAttribute(L1)}_isElementDescribedByMessage(e,i){let r=B1(e,"aria-describedby"),o=this._messageRegistry.get(i),a=o&&o.messageElement.id;return!!a&&-1!=r.indexOf(a)}_canBeDescribed(e,i){if(!this._isElementNode(e))return!1;if(i&&"object"==typeof i)return!0;let r=null==i?"":`${i}`.trim(),o=e.getAttribute("aria-label");return!(!r||o&&o.trim()===r)}_isElementNode(e){return e.nodeType===this._document.ELEMENT_NODE}}return n.\u0275fac=function(e){return new(e||n)(O(kt),O($n))},n.\u0275prov=pe({token:n,factory:n.\u0275fac,providedIn:"root"}),n})();function u2(n,t){return"string"==typeof n?`${t||""}/${n}`:n}function I7(n,t){n.id||(n.id=`${O7}-${t}-${f2++}`)}var V1=class{constructor(t){this._items=t,this._activeItemIndex=-1,this._activeItem=null,this._wrap=!1,this._letterKeyStream=new Ae,this._typeaheadSubscription=yn.EMPTY,this._vertical=!0,this._allowedModifierKeys=[],this._homeAndEnd=!1,this._pageUpAndDown={enabled:!1,delta:10},this._skipPredicateFn=e=>e.disabled,this._pressedLetters=[],this.tabOut=new Ae,this.change=new Ae,t instanceof Is&&(this._itemChangesSubscription=t.changes.subscribe(e=>{if(this._activeItem){let r=e.toArray().indexOf(this._activeItem);r>-1&&r!==this._activeItemIndex&&(this._activeItemIndex=r)}}))}skipPredicate(t){return this._skipPredicateFn=t,this}withWrap(t=!0){return this._wrap=t,this}withVerticalOrientation(t=!0){return this._vertical=t,this}withHorizontalOrientation(t){return this._horizontal=t,this}withAllowedModifierKeys(t){return this._allowedModifierKeys=t,this}withTypeAhead(t=200){return this._typeaheadSubscription.unsubscribe(),this._typeaheadSubscription=this._letterKeyStream.pipe(Vt(e=>this._pressedLetters.push(e)),Cr(t),Ve(()=>this._pressedLetters.length>0),U(()=>this._pressedLetters.join(""))).subscribe(e=>{let i=this._getItemsArray();for(let r=1;r<i.length+1;r++){let o=(this._activeItemIndex+r)%i.length,a=i[o];if(!this._skipPredicateFn(a)&&0===a.getLabel().toUpperCase().trim().indexOf(e)){this.setActiveItem(o);break}}this._pressedLetters=[]}),this}cancelTypeahead(){return this._pressedLetters=[],this}withHomeAndEnd(t=!0){return this._homeAndEnd=t,this}withPageUpDown(t=!0,e=10){return this._pageUpAndDown={enabled:t,delta:e},this}setActiveItem(t){let e=this._activeItem;this.updateActiveItem(t),this._activeItem!==e&&this.change.next(this._activeItemIndex)}onKeydown(t){let e=t.keyCode,r=["altKey","ctrlKey","metaKey","shiftKey"].every(o=>!t[o]||this._allowedModifierKeys.indexOf(o)>-1);switch(e){case 9:return void this.tabOut.next();case 40:if(this._vertical&&r){this.setNextItemActive();break}return;case 38:if(this._vertical&&r){this.setPreviousItemActive();break}return;case 39:if(this._horizontal&&r){"rtl"===this._horizontal?this.setPreviousItemActive():this.setNextItemActive();break}return;case 37:if(this._horizontal&&r){"rtl"===this._horizontal?this.setNextItemActive():this.setPreviousItemActive();break}return;case 36:if(this._homeAndEnd&&r){this.setFirstItemActive();break}return;case 35:if(this._homeAndEnd&&r){this.setLastItemActive();break}return;case 33:if(this._pageUpAndDown.enabled&&r){let o=this._activeItemIndex-this._pageUpAndDown.delta;this._setActiveItemByIndex(o>0?o:0,1);break}return;case 34:if(this._pageUpAndDown.enabled&&r){let o=this._activeItemIndex+this._pageUpAndDown.delta,a=this._getItemsArray().length;this._setActiveItemByIndex(o<a?o:a-1,-1);break}return;default:return void((r||yr(t,"shiftKey"))&&(t.key&&1===t.key.length?this._letterKeyStream.next(t.key.toLocaleUpperCase()):(e>=65&&e<=90||e>=48&&e<=57)&&this._letterKeyStream.next(String.fromCharCode(e))))}this._pressedLetters=[],t.preventDefault()}get activeItemIndex(){return this._activeItemIndex}get activeItem(){return this._activeItem}isTyping(){return this._pressedLetters.length>0}setFirstItemActive(){this._setActiveItemByIndex(0,1)}setLastItemActive(){this._setActiveItemByIndex(this._items.length-1,-1)}setNextItemActive(){this._activeItemIndex<0?this.setFirstItemActive():this._setActiveItemByDelta(1)}setPreviousItemActive(){this._activeItemIndex<0&&this._wrap?this.setLastItemActive():this._setActiveItemByDelta(-1)}updateActiveItem(t){let e=this._getItemsArray(),i="number"==typeof t?t:e.indexOf(t);this._activeItem=e[i]??null,this._activeItemIndex=i}destroy(){this._typeaheadSubscription.unsubscribe(),this._itemChangesSubscription?.unsubscribe(),this._letterKeyStream.complete(),this.tabOut.complete(),this.change.complete(),this._pressedLetters=[]}_setActiveItemByDelta(t){this._wrap?this._setActiveInWrapMode(t):this._setActiveInDefaultMode(t)}_setActiveInWrapMode(t){let e=this._getItemsArray();for(let i=1;i<=e.length;i++){let r=(this._activeItemIndex+t*i+e.length)%e.length;if(!this._skipPredicateFn(e[r]))return void this.setActiveItem(r)}}_setActiveInDefaultMode(t){this._setActiveItemByIndex(this._activeItemIndex+t,t)}_setActiveItemByIndex(t,e){let i=this._getItemsArray();if(i[t]){for(;this._skipPredicateFn(i[t]);)if(!i[t+=e])return;this.setActiveItem(t)}}_getItemsArray(){return this._items instanceof Is?this._items.toArray():this._items}},hg=class extends V1{setActiveItem(t){this.activeItem&&this.activeItem.setInactiveStyles(),super.setActiveItem(t),this.activeItem&&this.activeItem.setActiveStyles()}},gg=class extends V1{constructor(){super(...arguments),this._origin="program"}setFocusOrigin(t){return this._origin=t,this}setActiveItem(t){super.setActiveItem(t),this.activeItem&&this.activeItem.focus(this._origin)}},Tf=(()=>{class n{constructor(e){this._platform=e}isDisabled(e){return e.hasAttribute("disabled")}isVisible(e){return function(n){return!!(n.offsetWidth||n.offsetHeight||"function"==typeof n.getClientRects&&n.getClientRects().length)}(e)&&"visible"===getComputedStyle(e).visibility}isTabbable(e){if(!this._platform.isBrowser)return!1;let i=function(n){try{return n.frameElement}catch{return null}}(function(n){return n.ownerDocument&&n.ownerDocument.defaultView||window}(e));if(i&&(-1===A7(i)||!this.isVisible(i)))return!1;let r=e.nodeName.toLowerCase(),o=A7(e);return e.hasAttribute("contenteditable")?-1!==o:!("iframe"===r||"object"===r||this._platform.WEBKIT&&this._platform.IOS&&!function(n){let t=n.nodeName.toLowerCase(),e="input"===t&&n.type;return"text"===e||"password"===e||"select"===t||"textarea"===t}(e))&&("audio"===r?!!e.hasAttribute("controls")&&-1!==o:"video"===r?-1!==o&&(null!==o||this._platform.FIREFOX||e.hasAttribute("controls")):e.tabIndex>=0)}isFocusable(e,i){return function(n){return!function(n){return function(n){return"input"==n.nodeName.toLowerCase()}(n)&&"hidden"==n.type}(n)&&(function(n){let t=n.nodeName.toLowerCase();return"input"===t||"select"===t||"button"===t||"textarea"===t}(n)||function(n){return function(n){return"a"==n.nodeName.toLowerCase()}(n)&&n.hasAttribute("href")}(n)||n.hasAttribute("contenteditable")||F7(n))}(e)&&!this.isDisabled(e)&&(i?.ignoreVisibility||this.isVisible(e))}}return n.\u0275fac=function(e){return new(e||n)(O($n))},n.\u0275prov=pe({token:n,factory:n.\u0275fac,providedIn:"root"}),n})();function F7(n){if(!n.hasAttribute("tabindex")||void 0===n.tabIndex)return!1;let t=n.getAttribute("tabindex");return!(!t||isNaN(parseInt(t,10)))}function A7(n){if(!F7(n))return null;let t=parseInt(n.getAttribute("tabindex")||"",10);return isNaN(t)?-1:t}var _g=(()=>{class n{constructor(e,i,r){this._checker=e,this._ngZone=i,this._document=r}create(e,i=!1){return new class{get enabled(){return this._enabled}set enabled(t){this._enabled=t,this._startAnchor&&this._endAnchor&&(this._toggleAnchorTabIndex(t,this._startAnchor),this._toggleAnchorTabIndex(t,this._endAnchor))}constructor(t,e,i,r,o=!1){this._element=t,this._checker=e,this._ngZone=i,this._document=r,this._hasAttached=!1,this.startAnchorListener=()=>this.focusLastTabbableElement(),this.endAnchorListener=()=>this.focusFirstTabbableElement(),this._enabled=!0,o||this.attachAnchors()}destroy(){let t=this._startAnchor,e=this._endAnchor;t&&(t.removeEventListener("focus",this.startAnchorListener),t.remove()),e&&(e.removeEventListener("focus",this.endAnchorListener),e.remove()),this._startAnchor=this._endAnchor=null,this._hasAttached=!1}attachAnchors(){return!!this._hasAttached||(this._ngZone.runOutsideAngular(()=>{this._startAnchor||(this._startAnchor=this._createAnchor(),this._startAnchor.addEventListener("focus",this.startAnchorListener)),this._endAnchor||(this._endAnchor=this._createAnchor(),this._endAnchor.addEventListener("focus",this.endAnchorListener))}),this._element.parentNode&&(this._element.parentNode.insertBefore(this._startAnchor,this._element),this._element.parentNode.insertBefore(this._endAnchor,this._element.nextSibling),this._hasAttached=!0),this._hasAttached)}focusInitialElementWhenReady(t){return new Promise(e=>{this._executeOnStable(()=>e(this.focusInitialElement(t)))})}focusFirstTabbableElementWhenReady(t){return new Promise(e=>{this._executeOnStable(()=>e(this.focusFirstTabbableElement(t)))})}focusLastTabbableElementWhenReady(t){return new Promise(e=>{this._executeOnStable(()=>e(this.focusLastTabbableElement(t)))})}_getRegionBoundary(t){let e=this._element.querySelectorAll(`[cdk-focus-region-${t}], [cdkFocusRegion${t}], [cdk-focus-${t}]`);return"start"==t?e.length?e[0]:this._getFirstTabbableElement(this._element):e.length?e[e.length-1]:this._getLastTabbableElement(this._element)}focusInitialElement(t){let e=this._element.querySelector("[cdk-focus-initial], [cdkFocusInitial]");if(e){if(!this._checker.isFocusable(e)){let i=this._getFirstTabbableElement(e);return i?.focus(t),!!i}return e.focus(t),!0}return this.focusFirstTabbableElement(t)}focusFirstTabbableElement(t){let e=this._getRegionBoundary("start");return e&&e.focus(t),!!e}focusLastTabbableElement(t){let e=this._getRegionBoundary("end");return e&&e.focus(t),!!e}hasAttached(){return this._hasAttached}_getFirstTabbableElement(t){if(this._checker.isFocusable(t)&&this._checker.isTabbable(t))return t;let e=t.children;for(let i=0;i<e.length;i++){let r=e[i].nodeType===this._document.ELEMENT_NODE?this._getFirstTabbableElement(e[i]):null;if(r)return r}return null}_getLastTabbableElement(t){if(this._checker.isFocusable(t)&&this._checker.isTabbable(t))return t;let e=t.children;for(let i=e.length-1;i>=0;i--){let r=e[i].nodeType===this._document.ELEMENT_NODE?this._getLastTabbableElement(e[i]):null;if(r)return r}return null}_createAnchor(){let t=this._document.createElement("div");return this._toggleAnchorTabIndex(this._enabled,t),t.classList.add("cdk-visually-hidden"),t.classList.add("cdk-focus-trap-anchor"),t.setAttribute("aria-hidden","true"),t}_toggleAnchorTabIndex(t,e){t?e.setAttribute("tabindex","0"):e.removeAttribute("tabindex")}toggleAnchors(t){this._startAnchor&&this._endAnchor&&(this._toggleAnchorTabIndex(t,this._startAnchor),this._toggleAnchorTabIndex(t,this._endAnchor))}_executeOnStable(t){this._ngZone.isStable?t():this._ngZone.onStable.pipe(zt(1)).subscribe(t)}}(e,this._checker,this._ngZone,this._document,i)}}return n.\u0275fac=function(e){return new(e||n)(O(Tf),O(at),O(kt))},n.\u0275prov=pe({token:n,factory:n.\u0275fac,providedIn:"root"}),n})();function Hb(n){return 0===n.buttons||0===n.offsetX&&0===n.offsetY}function zb(n){let t=n.touches&&n.touches[0]||n.changedTouches&&n.changedTouches[0];return!(!t||-1!==t.identifier||null!=t.radiusX&&1!==t.radiusX||null!=t.radiusY&&1!==t.radiusY)}new ie("FOCUS_TRAP_INERT_STRATEGY");var a_e=new ie("cdk-input-modality-detector-options"),s_e={ignoreKeys:[18,17,224,91,16]},mg=Yo({passive:!0,capture:!0}),l_e=(()=>{class n{get mostRecentModality(){return this._modality.value}constructor(e,i,r,o){this._platform=e,this._mostRecentTarget=null,this._modality=new Ri(null),this._lastTouchMs=0,this._onKeydown=a=>{this._options?.ignoreKeys?.some(s=>s===a.keyCode)||(this._modality.next("keyboard"),this._mostRecentTarget=ds(a))},this._onMousedown=a=>{Date.now()-this._lastTouchMs<650||(this._modality.next(Hb(a)?"keyboard":"mouse"),this._mostRecentTarget=ds(a))},this._onTouchstart=a=>{zb(a)?this._modality.next("keyboard"):(this._lastTouchMs=Date.now(),this._modality.next("touch"),this._mostRecentTarget=ds(a))},this._options={...s_e,...o},this.modalityDetected=this._modality.pipe($a(1)),this.modalityChanged=this.modalityDetected.pipe(ui()),e.isBrowser&&i.runOutsideAngular(()=>{r.addEventListener("keydown",this._onKeydown,mg),r.addEventListener("mousedown",this._onMousedown,mg),r.addEventListener("touchstart",this._onTouchstart,mg)})}ngOnDestroy(){this._modality.complete(),this._platform.isBrowser&&(document.removeEventListener("keydown",this._onKeydown,mg),document.removeEventListener("mousedown",this._onMousedown,mg),document.removeEventListener("touchstart",this._onTouchstart,mg))}}return n.\u0275fac=function(e){return new(e||n)(O($n),O(at),O(kt),O(a_e,8))},n.\u0275prov=pe({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),c_e=new ie("liveAnnouncerElement",{providedIn:"root",factory:function(){return null}}),u_e=new ie("LIVE_ANNOUNCER_DEFAULT_OPTIONS"),p_e=0,yg=(()=>{class n{constructor(e,i,r,o){this._ngZone=i,this._defaultOptions=o,this._document=r,this._liveElement=e||this._createLiveElement()}announce(e,...i){let o,a,r=this._defaultOptions;return 1===i.length&&"number"==typeof i[0]?a=i[0]:[o,a]=i,this.clear(),clearTimeout(this._previousTimeout),o||(o=r&&r.politeness?r.politeness:"polite"),null==a&&r&&(a=r.duration),this._liveElement.setAttribute("aria-live",o),this._liveElement.id&&this._exposeAnnouncerToModals(this._liveElement.id),this._ngZone.runOutsideAngular(()=>(this._currentPromise||(this._currentPromise=new Promise(s=>this._currentResolve=s)),clearTimeout(this._previousTimeout),this._previousTimeout=setTimeout(()=>{this._liveElement.textContent=e,"number"==typeof a&&(this._previousTimeout=setTimeout(()=>this.clear(),a)),this._currentResolve(),this._currentPromise=this._currentResolve=void 0},100),this._currentPromise))}clear(){this._liveElement&&(this._liveElement.textContent="")}ngOnDestroy(){clearTimeout(this._previousTimeout),this._liveElement?.remove(),this._liveElement=null,this._currentResolve?.(),this._currentPromise=this._currentResolve=void 0}_createLiveElement(){let e="cdk-live-announcer-element",i=this._document.getElementsByClassName(e),r=this._document.createElement("div");for(let o=0;o<i.length;o++)i[o].remove();return r.classList.add(e),r.classList.add("cdk-visually-hidden"),r.setAttribute("aria-atomic","true"),r.setAttribute("aria-live","polite"),r.id="cdk-live-announcer-"+p_e++,this._document.body.appendChild(r),r}_exposeAnnouncerToModals(e){let i=this._document.querySelectorAll('body > .cdk-overlay-container [aria-modal="true"]');for(let r=0;r<i.length;r++){let o=i[r],a=o.getAttribute("aria-owns");a?-1===a.indexOf(e)&&o.setAttribute("aria-owns",a+" "+e):o.setAttribute("aria-owns",e)}}}return n.\u0275fac=function(e){return new(e||n)(O(c_e,8),O(at),O(kt),O(u_e,8))},n.\u0275prov=pe({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),f_e=new ie("cdk-focus-monitor-default-options"),N1=Yo({passive:!0,capture:!0}),lr=(()=>{class n{constructor(e,i,r,o,a){this._ngZone=e,this._platform=i,this._inputModalityDetector=r,this._origin=null,this._windowFocused=!1,this._originFromTouchInteraction=!1,this._elementInfo=new Map,this._monitoredElementCount=0,this._rootNodeFocusListenerCount=new Map,this._windowFocusListener=()=>{this._windowFocused=!0,this._windowFocusTimeoutId=window.setTimeout(()=>this._windowFocused=!1)},this._stopInputModalityDetector=new Ae,this._rootNodeFocusAndBlurListener=s=>{for(let c=ds(s);c;c=c.parentElement)"focus"===s.type?this._onFocus(s,c):this._onBlur(s,c)},this._document=o,this._detectionMode=a?.detectionMode||0}monitor(e,i=!1){let r=Va(e);if(!this._platform.isBrowser||1!==r.nodeType)return qt(null);let o=O1(r)||this._getDocument(),a=this._elementInfo.get(r);if(a)return i&&(a.checkChildren=!0),a.subject;let s={checkChildren:i,subject:new Ae,rootNode:o};return this._elementInfo.set(r,s),this._registerGlobalListeners(s),s.subject}stopMonitoring(e){let i=Va(e),r=this._elementInfo.get(i);r&&(r.subject.complete(),this._setClasses(i),this._elementInfo.delete(i),this._removeGlobalListeners(r))}focusVia(e,i,r){let o=Va(e);o===this._getDocument().activeElement?this._getClosestElementsInfo(o).forEach(([s,l])=>this._originChanged(s,i,l)):(this._setOrigin(i),"function"==typeof o.focus&&o.focus(r))}ngOnDestroy(){this._elementInfo.forEach((e,i)=>this.stopMonitoring(i))}_getDocument(){return this._document||document}_getWindow(){return this._getDocument().defaultView||window}_getFocusOrigin(e){return this._origin?this._originFromTouchInteraction?this._shouldBeAttributedToTouch(e)?"touch":"program":this._origin:this._windowFocused&&this._lastFocusOrigin?this._lastFocusOrigin:e&&this._isLastInteractionFromInputLabel(e)?"mouse":"program"}_shouldBeAttributedToTouch(e){return 1===this._detectionMode||!!e?.contains(this._inputModalityDetector._mostRecentTarget)}_setClasses(e,i){e.classList.toggle("cdk-focused",!!i),e.classList.toggle("cdk-touch-focused","touch"===i),e.classList.toggle("cdk-keyboard-focused","keyboard"===i),e.classList.toggle("cdk-mouse-focused","mouse"===i),e.classList.toggle("cdk-program-focused","program"===i)}_setOrigin(e,i=!1){this._ngZone.runOutsideAngular(()=>{this._origin=e,this._originFromTouchInteraction="touch"===e&&i,0===this._detectionMode&&(clearTimeout(this._originTimeoutId),this._originTimeoutId=setTimeout(()=>this._origin=null,this._originFromTouchInteraction?650:1))})}_onFocus(e,i){let r=this._elementInfo.get(i),o=ds(e);!r||!r.checkChildren&&i!==o||this._originChanged(i,this._getFocusOrigin(o),r)}_onBlur(e,i){let r=this._elementInfo.get(i);!r||r.checkChildren&&e.relatedTarget instanceof Node&&i.contains(e.relatedTarget)||(this._setClasses(i),this._emitOrigin(r,null))}_emitOrigin(e,i){e.subject.observers.length&&this._ngZone.run(()=>e.subject.next(i))}_registerGlobalListeners(e){if(!this._platform.isBrowser)return;let i=e.rootNode,r=this._rootNodeFocusListenerCount.get(i)||0;r||this._ngZone.runOutsideAngular(()=>{i.addEventListener("focus",this._rootNodeFocusAndBlurListener,N1),i.addEventListener("blur",this._rootNodeFocusAndBlurListener,N1)}),this._rootNodeFocusListenerCount.set(i,r+1),1==++this._monitoredElementCount&&(this._ngZone.runOutsideAngular(()=>{this._getWindow().addEventListener("focus",this._windowFocusListener)}),this._inputModalityDetector.modalityDetected.pipe(ot(this._stopInputModalityDetector)).subscribe(o=>{this._setOrigin(o,!0)}))}_removeGlobalListeners(e){let i=e.rootNode;if(this._rootNodeFocusListenerCount.has(i)){let r=this._rootNodeFocusListenerCount.get(i);r>1?this._rootNodeFocusListenerCount.set(i,r-1):(i.removeEventListener("focus",this._rootNodeFocusAndBlurListener,N1),i.removeEventListener("blur",this._rootNodeFocusAndBlurListener,N1),this._rootNodeFocusListenerCount.delete(i))}--this._monitoredElementCount||(this._getWindow().removeEventListener("focus",this._windowFocusListener),this._stopInputModalityDetector.next(),clearTimeout(this._windowFocusTimeoutId),clearTimeout(this._originTimeoutId))}_originChanged(e,i,r){this._setClasses(e,i),this._emitOrigin(r,i),this._lastFocusOrigin=i}_getClosestElementsInfo(e){let i=[];return this._elementInfo.forEach((r,o)=>{(o===e||r.checkChildren&&o.contains(e))&&i.push([o,r])}),i}_isLastInteractionFromInputLabel(e){let{_mostRecentTarget:i,mostRecentModality:r}=this._inputModalityDetector;if("mouse"!==r||!i||i===e||"INPUT"!==e.nodeName&&"TEXTAREA"!==e.nodeName||e.disabled)return!1;let o=e.labels;if(o)for(let a=0;a<o.length;a++)if(o[a].contains(i))return!0;return!1}}return n.\u0275fac=function(e){return new(e||n)(O(at),O($n),O(l_e),O(kt,8),O(f_e,8))},n.\u0275prov=pe({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),x2=(()=>{class n{constructor(e,i){this._elementRef=e,this._focusMonitor=i,this._focusOrigin=null,this.cdkFocusChange=new L}get focusOrigin(){return this._focusOrigin}ngAfterViewInit(){let e=this._elementRef.nativeElement;this._monitorSubscription=this._focusMonitor.monitor(e,1===e.nodeType&&e.hasAttribute("cdkMonitorSubtreeFocus")).subscribe(i=>{this._focusOrigin=i,this.cdkFocusChange.emit(i)})}ngOnDestroy(){this._focusMonitor.stopMonitoring(this._elementRef),this._monitorSubscription&&this._monitorSubscription.unsubscribe()}}return n.\u0275fac=function(e){return new(e||n)(C(be),C(lr))},n.\u0275dir=xe({type:n,selectors:[["","cdkMonitorElementFocus",""],["","cdkMonitorSubtreeFocus",""]],outputs:{cdkFocusChange:"cdkFocusChange"},exportAs:["cdkMonitorFocus"]}),n})(),R7="cdk-high-contrast-black-on-white",k7="cdk-high-contrast-white-on-black",p2="cdk-high-contrast-active",C2=(()=>{class n{constructor(e,i){this._platform=e,this._document=i,this._breakpointSubscription=pi(Ou).observe("(forced-colors: active)").subscribe(()=>{this._hasCheckedHighContrastMode&&(this._hasCheckedHighContrastMode=!1,this._applyBodyHighContrastModeCssClasses())})}getHighContrastMode(){if(!this._platform.isBrowser)return 0;let e=this._document.createElement("div");e.style.backgroundColor="rgb(1,2,3)",e.style.position="absolute",this._document.body.appendChild(e);let i=this._document.defaultView||window,r=i&&i.getComputedStyle?i.getComputedStyle(e):null,o=(r&&r.backgroundColor||"").replace(/ /g,"");switch(e.remove(),o){case"rgb(0,0,0)":case"rgb(45,50,54)":case"rgb(32,32,32)":return 2;case"rgb(255,255,255)":case"rgb(255,250,239)":return 1}return 0}ngOnDestroy(){this._breakpointSubscription.unsubscribe()}_applyBodyHighContrastModeCssClasses(){if(!this._hasCheckedHighContrastMode&&this._platform.isBrowser&&this._document.body){let e=this._document.body.classList;e.remove(p2,R7,k7),this._hasCheckedHighContrastMode=!0;let i=this.getHighContrastMode();1===i?e.add(p2,R7):2===i&&e.add(p2,k7)}}}return n.\u0275fac=function(e){return new(e||n)(O($n),O(kt))},n.\u0275prov=pe({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),Df=(()=>{class n{constructor(e){e._applyBodyHighContrastModeCssClasses()}}return n.\u0275fac=function(e){return new(e||n)(O(C2))},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Pu]}),n})(),m_e=new ie("cdk-dir-doc",{providedIn:"root",factory:function(){return pi(kt)}}),g_e=/^(ar|ckb|dv|he|iw|fa|nqo|ps|sd|ug|ur|yi|.*[-_](Adlm|Arab|Hebr|Nkoo|Rohg|Thaa))(?!.*[-_](Latn|Cyrl)($|-|_))($|-|_)/i,Hi=(()=>{class n{constructor(e){this.value="ltr",this.change=new L,e&&(this.value=function(n){let t=n?.toLowerCase()||"";return"auto"===t&&typeof navigator<"u"&&navigator?.language?g_e.test(navigator.language)?"rtl":"ltr":"rtl"===t?"rtl":"ltr"}((e.body?e.body.dir:null)||(e.documentElement?e.documentElement.dir:null)||"ltr"))}ngOnDestroy(){this.change.complete()}}return n.\u0275fac=function(e){return new(e||n)(O(m_e,8))},n.\u0275prov=pe({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),Nu=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({}),n})(),y_e=["text"],S2=(new hl("15.2.9"),(()=>{class n{}return n.STANDARD_CURVE="cubic-bezier(0.4,0.0,0.2,1)",n.DECELERATION_CURVE="cubic-bezier(0.0,0.0,0.2,1)",n.ACCELERATION_CURVE="cubic-bezier(0.4,0.0,1,1)",n.SHARP_CURVE="cubic-bezier(0.4,0.0,0.6,1)",n})()),E2=(()=>{class n{}return n.COMPLEX="375ms",n.ENTERING="225ms",n.EXITING="195ms",n})(),z7=new ie("mat-sanity-checks",{providedIn:"root",factory:function(){return!0}}),Qt=(()=>{class n{constructor(e,i,r){this._sanityChecks=i,this._document=r,this._hasDoneGlobalChecks=!1,e._applyBodyHighContrastModeCssClasses(),this._hasDoneGlobalChecks||(this._hasDoneGlobalChecks=!0)}_checkIsEnabled(e){return!Vb()&&("boolean"==typeof this._sanityChecks?this._sanityChecks:!!this._sanityChecks[e])}}return n.\u0275fac=function(e){return new(e||n)(O(C2),O(z7,8),O(kt))},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Nu,Nu]}),n})();function Kr(n){return class extends n{get disabled(){return this._disabled}set disabled(t){this._disabled=Ut(t)}constructor(...t){super(...t),this._disabled=!1}}}function go(n,t){return class extends n{get color(){return this._color}set color(e){let i=e||this.defaultColor;i!==this._color&&(this._color&&this._elementRef.nativeElement.classList.remove(`mat-${this._color}`),i&&this._elementRef.nativeElement.classList.add(`mat-${i}`),this._color=i)}constructor(...e){super(...e),this.defaultColor=t,this.color=t}}}function Qo(n){return class extends n{get disableRipple(){return this._disableRipple}set disableRipple(t){this._disableRipple=Ut(t)}constructor(...t){super(...t),this._disableRipple=!1}}}function vd(n,t=0){return class extends n{get tabIndex(){return this.disabled?-1:this._tabIndex}set tabIndex(e){this._tabIndex=null!=e?Di(e):this.defaultTabIndex}constructor(...e){super(...e),this._tabIndex=t,this.defaultTabIndex=t}}}function Ub(n){return class extends n{updateErrorState(){let t=this.errorState,o=(this.errorStateMatcher||this._defaultErrorStateMatcher).isErrorState(this.ngControl?this.ngControl.control:null,this._parentFormGroup||this._parentForm);o!==t&&(this.errorState=o,this.stateChanges.next())}constructor(...t){super(...t),this.errorState=!1}}}function jb(n){return class extends n{constructor(...t){super(...t),this._isInitialized=!1,this._pendingSubscribers=[],this.initialized=new en(e=>{this._isInitialized?this._notifySubscriber(e):this._pendingSubscribers.push(e)})}_markInitialized(){this._isInitialized=!0,this._pendingSubscribers.forEach(this._notifySubscriber),this._pendingSubscribers=null}_notifySubscriber(t){t.next(),t.complete()}}}new ie("MAT_DATE_LOCALE",{providedIn:"root",factory:function(){return pi(ad)}}),new ie("mat-date-formats");var If=(()=>{class n{isErrorState(e,i){return!!(e&&e.invalid&&(e.touched||i&&i.submitted))}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=pe({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),N7=Yo({passive:!0,capture:!0}),w2={enterDuration:225,exitDuration:150},B7=Yo({passive:!0,capture:!0}),V7=["mousedown","touchstart"],H7=["mouseup","mouseleave","touchend","touchcancel"],bd=class{constructor(t,e,i,r){this._target=t,this._ngZone=e,this._platform=r,this._isPointerDown=!1,this._activeRipples=new Map,this._pointerUpEventsRegistered=!1,r.isBrowser&&(this._containerElement=Va(i))}fadeInRipple(t,e,i={}){let r=this._containerRect=this._containerRect||this._containerElement.getBoundingClientRect(),o={...w2,...i.animation};i.centered&&(t=r.left+r.width/2,e=r.top+r.height/2);let a=i.radius||function(n,t,e){let i=Math.max(Math.abs(n-e.left),Math.abs(n-e.right)),r=Math.max(Math.abs(t-e.top),Math.abs(t-e.bottom));return Math.sqrt(i*i+r*r)}(t,e,r),s=t-r.left,l=e-r.top,c=o.enterDuration,d=document.createElement("div");d.classList.add("mat-ripple-element"),d.style.left=s-a+"px",d.style.top=l-a+"px",d.style.height=2*a+"px",d.style.width=2*a+"px",null!=i.color&&(d.style.backgroundColor=i.color),d.style.transitionDuration=`${c}ms`,this._containerElement.appendChild(d);let u=window.getComputedStyle(d),f=u.transitionDuration,m="none"===u.transitionProperty||"0s"===f||"0s, 0s"===f||0===r.width&&0===r.height,y=new class{constructor(t,e,i,r=!1){this._renderer=t,this.element=e,this.config=i,this._animationForciblyDisabledThroughCss=r,this.state=3}fadeOut(){this._renderer.fadeOutRipple(this)}}(this,d,i,m);d.style.transform="scale3d(1, 1, 1)",y.state=0,i.persistent||(this._mostRecentTransientRipple=y);let M=null;return!m&&(c||o.exitDuration)&&this._ngZone.runOutsideAngular(()=>{let v=()=>this._finishRippleTransition(y),x=()=>this._destroyRipple(y);d.addEventListener("transitionend",v),d.addEventListener("transitioncancel",x),M={onTransitionEnd:v,onTransitionCancel:x}}),this._activeRipples.set(y,M),(m||!c)&&this._finishRippleTransition(y),y}fadeOutRipple(t){if(2===t.state||3===t.state)return;let e=t.element,i={...w2,...t.config.animation};e.style.transitionDuration=`${i.exitDuration}ms`,e.style.opacity="0",t.state=2,(t._animationForciblyDisabledThroughCss||!i.exitDuration)&&this._finishRippleTransition(t)}fadeOutAll(){this._getActiveRipples().forEach(t=>t.fadeOut())}fadeOutAllNonPersistent(){this._getActiveRipples().forEach(t=>{t.config.persistent||t.fadeOut()})}setupTriggerEvents(t){let e=Va(t);!this._platform.isBrowser||!e||e===this._triggerElement||(this._removeTriggerEvents(),this._triggerElement=e,V7.forEach(i=>{bd._eventManager.addHandler(this._ngZone,i,e,this)}))}handleEvent(t){"mousedown"===t.type?this._onMousedown(t):"touchstart"===t.type?this._onTouchStart(t):this._onPointerUp(),this._pointerUpEventsRegistered||(this._ngZone.runOutsideAngular(()=>{H7.forEach(e=>{this._triggerElement.addEventListener(e,this,B7)})}),this._pointerUpEventsRegistered=!0)}_finishRippleTransition(t){0===t.state?this._startFadeOutTransition(t):2===t.state&&this._destroyRipple(t)}_startFadeOutTransition(t){let e=t===this._mostRecentTransientRipple,{persistent:i}=t.config;t.state=1,!i&&(!e||!this._isPointerDown)&&t.fadeOut()}_destroyRipple(t){let e=this._activeRipples.get(t)??null;this._activeRipples.delete(t),this._activeRipples.size||(this._containerRect=null),t===this._mostRecentTransientRipple&&(this._mostRecentTransientRipple=null),t.state=3,null!==e&&(t.element.removeEventListener("transitionend",e.onTransitionEnd),t.element.removeEventListener("transitioncancel",e.onTransitionCancel)),t.element.remove()}_onMousedown(t){let e=Hb(t),i=this._lastTouchStartEvent&&Date.now()<this._lastTouchStartEvent+800;!this._target.rippleDisabled&&!e&&!i&&(this._isPointerDown=!0,this.fadeInRipple(t.clientX,t.clientY,this._target.rippleConfig))}_onTouchStart(t){if(!this._target.rippleDisabled&&!zb(t)){this._lastTouchStartEvent=Date.now(),this._isPointerDown=!0;let e=t.changedTouches;for(let i=0;i<e.length;i++)this.fadeInRipple(e[i].clientX,e[i].clientY,this._target.rippleConfig)}}_onPointerUp(){!this._isPointerDown||(this._isPointerDown=!1,this._getActiveRipples().forEach(t=>{!t.config.persistent&&(1===t.state||t.config.terminateOnPointerUp&&0===t.state)&&t.fadeOut()}))}_getActiveRipples(){return Array.from(this._activeRipples.keys())}_removeTriggerEvents(){let t=this._triggerElement;t&&(V7.forEach(e=>bd._eventManager.removeHandler(e,t,this)),this._pointerUpEventsRegistered&&H7.forEach(e=>t.removeEventListener(e,this,B7)))}};bd._eventManager=new class{constructor(){this._events=new Map,this._delegateEventHandler=t=>{let e=ds(t);e&&this._events.get(t.type)?.forEach((i,r)=>{(r===e||r.contains(e))&&i.forEach(o=>o.handleEvent(t))})}}addHandler(t,e,i,r){let o=this._events.get(e);if(o){let a=o.get(i);a?a.add(r):o.set(i,new Set([r]))}else this._events.set(e,new Map([[i,new Set([r])]])),t.runOutsideAngular(()=>{document.addEventListener(e,this._delegateEventHandler,N7)})}removeHandler(t,e,i){let r=this._events.get(t);if(!r)return;let o=r.get(e);!o||(o.delete(i),0===o.size&&r.delete(e),0===r.size&&(this._events.delete(t),document.removeEventListener(t,this._delegateEventHandler,N7)))}};var Gb=new ie("mat-ripple-global-options"),Fr=(()=>{class n{get disabled(){return this._disabled}set disabled(e){e&&this.fadeOutAllNonPersistent(),this._disabled=e,this._setupTriggerEventsIfEnabled()}get trigger(){return this._trigger||this._elementRef.nativeElement}set trigger(e){this._trigger=e,this._setupTriggerEventsIfEnabled()}constructor(e,i,r,o,a){this._elementRef=e,this._animationMode=a,this.radius=0,this._disabled=!1,this._isInitialized=!1,this._globalOptions=o||{},this._rippleRenderer=new bd(this,i,e,r)}ngOnInit(){this._isInitialized=!0,this._setupTriggerEventsIfEnabled()}ngOnDestroy(){this._rippleRenderer._removeTriggerEvents()}fadeOutAll(){this._rippleRenderer.fadeOutAll()}fadeOutAllNonPersistent(){this._rippleRenderer.fadeOutAllNonPersistent()}get rippleConfig(){return{centered:this.centered,radius:this.radius,color:this.color,animation:{...this._globalOptions.animation,..."NoopAnimations"===this._animationMode?{enterDuration:0,exitDuration:0}:{},...this.animation},terminateOnPointerUp:this._globalOptions.terminateOnPointerUp}}get rippleDisabled(){return this.disabled||!!this._globalOptions.disabled}_setupTriggerEventsIfEnabled(){!this.disabled&&this._isInitialized&&this._rippleRenderer.setupTriggerEvents(this.trigger)}launch(e,i=0,r){return"number"==typeof e?this._rippleRenderer.fadeInRipple(e,i,{...this.rippleConfig,...r}):this._rippleRenderer.fadeInRipple(0,0,{...this.rippleConfig,...e})}}return n.\u0275fac=function(e){return new(e||n)(C(be),C(at),C($n),C(Gb,8),C(di,8))},n.\u0275dir=xe({type:n,selectors:[["","mat-ripple",""],["","matRipple",""]],hostAttrs:[1,"mat-ripple"],hostVars:2,hostBindings:function(e,i){2&e&&Qe("mat-ripple-unbounded",i.unbounded)},inputs:{color:["matRippleColor","color"],unbounded:["matRippleUnbounded","unbounded"],centered:["matRippleCentered","centered"],radius:["matRippleRadius","radius"],animation:["matRippleAnimation","animation"],disabled:["matRippleDisabled","disabled"],trigger:["matRippleTrigger","trigger"]},exportAs:["matRipple"]}),n})(),Zo=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Qt,Qt]}),n})(),T2=(()=>{class n{constructor(e){this._animationMode=e,this.state="unchecked",this.disabled=!1,this.appearance="full"}}return n.\u0275fac=function(e){return new(e||n)(C(di,8))},n.\u0275cmp=k({type:n,selectors:[["mat-pseudo-checkbox"]],hostAttrs:[1,"mat-pseudo-checkbox"],hostVars:12,hostBindings:function(e,i){2&e&&Qe("mat-pseudo-checkbox-indeterminate","indeterminate"===i.state)("mat-pseudo-checkbox-checked","checked"===i.state)("mat-pseudo-checkbox-disabled",i.disabled)("mat-pseudo-checkbox-minimal","minimal"===i.appearance)("mat-pseudo-checkbox-full","full"===i.appearance)("_mat-animation-noopable","NoopAnimations"===i._animationMode)},inputs:{state:"state",disabled:"disabled",appearance:"appearance"},decls:0,vars:0,template:function(e,i){},styles:['.mat-pseudo-checkbox{border-radius:2px;cursor:pointer;display:inline-block;vertical-align:middle;box-sizing:border-box;position:relative;flex-shrink:0;transition:border-color 90ms cubic-bezier(0, 0, 0.2, 0.1),background-color 90ms cubic-bezier(0, 0, 0.2, 0.1)}.mat-pseudo-checkbox::after{position:absolute;opacity:0;content:"";border-bottom:2px solid currentColor;transition:opacity 90ms cubic-bezier(0, 0, 0.2, 0.1)}.mat-pseudo-checkbox._mat-animation-noopable{transition:none !important;animation:none !important}.mat-pseudo-checkbox._mat-animation-noopable::after{transition:none}.mat-pseudo-checkbox-disabled{cursor:default}.mat-pseudo-checkbox-indeterminate::after{left:1px;opacity:1;border-radius:2px}.mat-pseudo-checkbox-checked::after{left:1px;border-left:2px solid currentColor;transform:rotate(-45deg);opacity:1;box-sizing:content-box}.mat-pseudo-checkbox-full{border:2px solid}.mat-pseudo-checkbox-full.mat-pseudo-checkbox-checked,.mat-pseudo-checkbox-full.mat-pseudo-checkbox-indeterminate{border-color:rgba(0,0,0,0)}.mat-pseudo-checkbox{width:18px;height:18px}.mat-pseudo-checkbox-minimal.mat-pseudo-checkbox-checked::after{width:14px;height:6px;transform-origin:center;top:-4.2426406871px;left:0;bottom:0;right:0;margin:auto}.mat-pseudo-checkbox-minimal.mat-pseudo-checkbox-indeterminate::after{top:8px;width:16px}.mat-pseudo-checkbox-full.mat-pseudo-checkbox-checked::after{width:10px;height:4px;transform-origin:center;top:-2.8284271247px;left:0;bottom:0;right:0;margin:auto}.mat-pseudo-checkbox-full.mat-pseudo-checkbox-indeterminate::after{top:6px;width:12px}'],encapsulation:2,changeDetection:0}),n})(),D2=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Qt]}),n})(),xd=new ie("MAT_OPTION_PARENT_COMPONENT"),Cd=(Kr(class{}),new ie("MatOptgroup")),S_e=0,bg=class{constructor(t,e=!1){this.source=t,this.isUserInput=e}},I2=(()=>{class n{get multiple(){return this._parent&&this._parent.multiple}get selected(){return this._selected}get disabled(){return this.group&&this.group.disabled||this._disabled}set disabled(e){this._disabled=Ut(e)}get disableRipple(){return!(!this._parent||!this._parent.disableRipple)}get hideSingleSelectionIndicator(){return!(!this._parent||!this._parent.hideSingleSelectionIndicator)}constructor(e,i,r,o){this._element=e,this._changeDetectorRef=i,this._parent=r,this.group=o,this._selected=!1,this._active=!1,this._disabled=!1,this._mostRecentViewValue="",this.id="mat-option-"+S_e++,this.onSelectionChange=new L,this._stateChanges=new Ae}get active(){return this._active}get viewValue(){return(this._text?.nativeElement.textContent||"").trim()}select(){this._selected||(this._selected=!0,this._changeDetectorRef.markForCheck(),this._emitSelectionChangeEvent())}deselect(){this._selected&&(this._selected=!1,this._changeDetectorRef.markForCheck(),this._emitSelectionChangeEvent())}focus(e,i){let r=this._getHostElement();"function"==typeof r.focus&&r.focus(i)}setActiveStyles(){this._active||(this._active=!0,this._changeDetectorRef.markForCheck())}setInactiveStyles(){this._active&&(this._active=!1,this._changeDetectorRef.markForCheck())}getLabel(){return this.viewValue}_handleKeydown(e){(13===e.keyCode||32===e.keyCode)&&!yr(e)&&(this._selectViaInteraction(),e.preventDefault())}_selectViaInteraction(){this.disabled||(this._selected=!this.multiple||!this._selected,this._changeDetectorRef.markForCheck(),this._emitSelectionChangeEvent(!0))}_getTabIndex(){return this.disabled?"-1":"0"}_getHostElement(){return this._element.nativeElement}ngAfterViewChecked(){if(this._selected){let e=this.viewValue;e!==this._mostRecentViewValue&&(this._mostRecentViewValue&&this._stateChanges.next(),this._mostRecentViewValue=e)}}ngOnDestroy(){this._stateChanges.complete()}_emitSelectionChangeEvent(e=!1){this.onSelectionChange.emit(new bg(this,e))}}return n.\u0275fac=function(e){_l()},n.\u0275dir=xe({type:n,viewQuery:function(e,i){if(1&e&&Ye(y_e,7),2&e){let r;we(r=Se())&&(i._text=r.first)}},inputs:{value:"value",id:"id",disabled:"disabled"},outputs:{onSelectionChange:"onSelectionChange"}}),n})();function Af(n,t,e){if(e.length){let i=t.toArray(),r=e.toArray(),o=0;for(let a=0;a<n+1;a++)i[a].group&&i[a].group===r[o]&&o++;return o}return 0}function vg(n,t,e,i){return n<e?n:n+t>e+i?Math.max(0,n-i+t):e}var j7=["mat-button",""],G7=["*"],D_e=["mat-button","mat-flat-button","mat-icon-button","mat-raised-button","mat-stroked-button","mat-mini-fab","mat-fab"],I_e=go(Kr(Qo(class{constructor(n){this._elementRef=n}}))),Fn=(()=>{class n extends I_e{constructor(e,i,r){super(e),this._focusMonitor=i,this._animationMode=r,this.isRoundButton=this._hasHostAttributes("mat-fab","mat-mini-fab"),this.isIconButton=this._hasHostAttributes("mat-icon-button");for(let o of D_e)this._hasHostAttributes(o)&&this._getHostElement().classList.add(o);e.nativeElement.classList.add("mat-button-base"),this.isRoundButton&&(this.color="accent")}ngAfterViewInit(){this._focusMonitor.monitor(this._elementRef,!0)}ngOnDestroy(){this._focusMonitor.stopMonitoring(this._elementRef)}focus(e,i){e?this._focusMonitor.focusVia(this._getHostElement(),e,i):this._getHostElement().focus(i)}_getHostElement(){return this._elementRef.nativeElement}_isRippleDisabled(){return this.disableRipple||this.disabled}_hasHostAttributes(...e){return e.some(i=>this._getHostElement().hasAttribute(i))}}return n.\u0275fac=function(e){return new(e||n)(C(be),C(lr),C(di,8))},n.\u0275cmp=k({type:n,selectors:[["button","mat-button",""],["button","mat-raised-button",""],["button","mat-icon-button",""],["button","mat-fab",""],["button","mat-mini-fab",""],["button","mat-stroked-button",""],["button","mat-flat-button",""]],viewQuery:function(e,i){if(1&e&&Ye(Fr,5),2&e){let r;we(r=Se())&&(i.ripple=r.first)}},hostAttrs:[1,"mat-focus-indicator"],hostVars:5,hostBindings:function(e,i){2&e&&(Pe("disabled",i.disabled||null),Qe("_mat-animation-noopable","NoopAnimations"===i._animationMode)("mat-button-disabled",i.disabled))},inputs:{disabled:"disabled",disableRipple:"disableRipple",color:"color"},exportAs:["matButton"],features:[Le],attrs:j7,ngContentSelectors:G7,decls:4,vars:5,consts:[[1,"mat-button-wrapper"],["matRipple","",1,"mat-button-ripple",3,"matRippleDisabled","matRippleCentered","matRippleTrigger"],[1,"mat-button-focus-overlay"]],template:function(e,i){1&e&&(gn(),h(0,"span",0),Xt(1),g(),P(2,"span",1)(3,"span",2)),2&e&&(b(2),Qe("mat-button-ripple-round",i.isRoundButton||i.isIconButton),_("matRippleDisabled",i._isRippleDisabled())("matRippleCentered",i.isIconButton)("matRippleTrigger",i._getHostElement()))},dependencies:[Fr],styles:[".mat-button .mat-button-focus-overlay,.mat-icon-button .mat-button-focus-overlay{opacity:0}.mat-button:hover:not(.mat-button-disabled) .mat-button-focus-overlay,.mat-stroked-button:hover:not(.mat-button-disabled) .mat-button-focus-overlay{opacity:.04}@media(hover: none){.mat-button:hover:not(.mat-button-disabled) .mat-button-focus-overlay,.mat-stroked-button:hover:not(.mat-button-disabled) .mat-button-focus-overlay{opacity:0}}.mat-button,.mat-icon-button,.mat-stroked-button,.mat-flat-button{box-sizing:border-box;position:relative;-webkit-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:rgba(0,0,0,0);display:inline-block;white-space:nowrap;text-decoration:none;vertical-align:baseline;text-align:center;margin:0;min-width:64px;line-height:36px;padding:0 16px;border-radius:4px;overflow:visible}.mat-button::-moz-focus-inner,.mat-icon-button::-moz-focus-inner,.mat-stroked-button::-moz-focus-inner,.mat-flat-button::-moz-focus-inner{border:0}.mat-button.mat-button-disabled,.mat-icon-button.mat-button-disabled,.mat-stroked-button.mat-button-disabled,.mat-flat-button.mat-button-disabled{cursor:default}.mat-button.cdk-keyboard-focused .mat-button-focus-overlay,.mat-button.cdk-program-focused .mat-button-focus-overlay,.mat-icon-button.cdk-keyboard-focused .mat-button-focus-overlay,.mat-icon-button.cdk-program-focused .mat-button-focus-overlay,.mat-stroked-button.cdk-keyboard-focused .mat-button-focus-overlay,.mat-stroked-button.cdk-program-focused .mat-button-focus-overlay,.mat-flat-button.cdk-keyboard-focused .mat-button-focus-overlay,.mat-flat-button.cdk-program-focused .mat-button-focus-overlay{opacity:.12}.mat-button::-moz-focus-inner,.mat-icon-button::-moz-focus-inner,.mat-stroked-button::-moz-focus-inner,.mat-flat-button::-moz-focus-inner{border:0}.mat-raised-button{box-sizing:border-box;position:relative;-webkit-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:rgba(0,0,0,0);display:inline-block;white-space:nowrap;text-decoration:none;vertical-align:baseline;text-align:center;margin:0;min-width:64px;line-height:36px;padding:0 16px;border-radius:4px;overflow:visible;transform:translate3d(0, 0, 0);transition:background 400ms cubic-bezier(0.25, 0.8, 0.25, 1),box-shadow 280ms cubic-bezier(0.4, 0, 0.2, 1)}.mat-raised-button::-moz-focus-inner{border:0}.mat-raised-button.mat-button-disabled{cursor:default}.mat-raised-button.cdk-keyboard-focused .mat-button-focus-overlay,.mat-raised-button.cdk-program-focused .mat-button-focus-overlay{opacity:.12}.mat-raised-button::-moz-focus-inner{border:0}.mat-raised-button._mat-animation-noopable{transition:none !important;animation:none !important}.mat-stroked-button{border:1px solid currentColor;padding:0 15px;line-height:34px}.mat-stroked-button .mat-button-ripple.mat-ripple,.mat-stroked-button .mat-button-focus-overlay{top:-1px;left:-1px;right:-1px;bottom:-1px}.mat-fab{box-sizing:border-box;position:relative;-webkit-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:rgba(0,0,0,0);display:inline-block;white-space:nowrap;text-decoration:none;vertical-align:baseline;text-align:center;margin:0;min-width:64px;line-height:36px;padding:0 16px;border-radius:4px;overflow:visible;transform:translate3d(0, 0, 0);transition:background 400ms cubic-bezier(0.25, 0.8, 0.25, 1),box-shadow 280ms cubic-bezier(0.4, 0, 0.2, 1);min-width:0;border-radius:50%;width:56px;height:56px;padding:0;flex-shrink:0}.mat-fab::-moz-focus-inner{border:0}.mat-fab.mat-button-disabled{cursor:default}.mat-fab.cdk-keyboard-focused .mat-button-focus-overlay,.mat-fab.cdk-program-focused .mat-button-focus-overlay{opacity:.12}.mat-fab::-moz-focus-inner{border:0}.mat-fab._mat-animation-noopable{transition:none !important;animation:none !important}.mat-fab .mat-button-wrapper{padding:16px 0;display:inline-block;line-height:24px}.mat-mini-fab{box-sizing:border-box;position:relative;-webkit-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:rgba(0,0,0,0);display:inline-block;white-space:nowrap;text-decoration:none;vertical-align:baseline;text-align:center;margin:0;min-width:64px;line-height:36px;padding:0 16px;border-radius:4px;overflow:visible;transform:translate3d(0, 0, 0);transition:background 400ms cubic-bezier(0.25, 0.8, 0.25, 1),box-shadow 280ms cubic-bezier(0.4, 0, 0.2, 1);min-width:0;border-radius:50%;width:40px;height:40px;padding:0;flex-shrink:0}.mat-mini-fab::-moz-focus-inner{border:0}.mat-mini-fab.mat-button-disabled{cursor:default}.mat-mini-fab.cdk-keyboard-focused .mat-button-focus-overlay,.mat-mini-fab.cdk-program-focused .mat-button-focus-overlay{opacity:.12}.mat-mini-fab::-moz-focus-inner{border:0}.mat-mini-fab._mat-animation-noopable{transition:none !important;animation:none !important}.mat-mini-fab .mat-button-wrapper{padding:8px 0;display:inline-block;line-height:24px}.mat-icon-button{padding:0;min-width:0;width:40px;height:40px;flex-shrink:0;line-height:40px;border-radius:50%}.mat-icon-button i,.mat-icon-button .mat-icon{line-height:24px}.mat-button-ripple.mat-ripple,.mat-button-focus-overlay{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none;border-radius:inherit}.mat-button-ripple.mat-ripple:not(:empty){transform:translateZ(0)}.mat-button-focus-overlay{opacity:0;transition:opacity 200ms cubic-bezier(0.35, 0, 0.25, 1),background-color 200ms cubic-bezier(0.35, 0, 0.25, 1)}._mat-animation-noopable .mat-button-focus-overlay{transition:none}.mat-button-ripple-round{border-radius:50%;z-index:1}.mat-button .mat-button-wrapper>*,.mat-flat-button .mat-button-wrapper>*,.mat-stroked-button .mat-button-wrapper>*,.mat-raised-button .mat-button-wrapper>*,.mat-icon-button .mat-button-wrapper>*,.mat-fab .mat-button-wrapper>*,.mat-mini-fab .mat-button-wrapper>*{vertical-align:middle}.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-prefix .mat-icon-button,.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-suffix .mat-icon-button{display:inline-flex;justify-content:center;align-items:center;font-size:inherit;width:2.5em;height:2.5em}.mat-flat-button::before,.mat-raised-button::before,.mat-fab::before,.mat-mini-fab::before{margin:calc(calc(var(--mat-focus-indicator-border-width, 3px) + 2px) * -1)}.mat-stroked-button::before{margin:calc(calc(var(--mat-focus-indicator-border-width, 3px) + 3px) * -1)}.cdk-high-contrast-active .mat-button,.cdk-high-contrast-active .mat-flat-button,.cdk-high-contrast-active .mat-raised-button,.cdk-high-contrast-active .mat-icon-button,.cdk-high-contrast-active .mat-fab,.cdk-high-contrast-active .mat-mini-fab{outline:solid 1px}.mat-datepicker-toggle .mat-mdc-button-base{width:40px;height:40px;padding:8px 0}.mat-datepicker-actions .mat-button-base+.mat-button-base{margin-left:8px}[dir=rtl] .mat-datepicker-actions .mat-button-base+.mat-button-base{margin-left:0;margin-right:8px}"],encapsulation:2,changeDetection:0}),n})(),U1=(()=>{class n extends Fn{constructor(e,i,r,o){super(i,e,r),this._ngZone=o,this._haltDisabledEvents=a=>{this.disabled&&(a.preventDefault(),a.stopImmediatePropagation())}}ngAfterViewInit(){super.ngAfterViewInit(),this._ngZone?this._ngZone.runOutsideAngular(()=>{this._elementRef.nativeElement.addEventListener("click",this._haltDisabledEvents)}):this._elementRef.nativeElement.addEventListener("click",this._haltDisabledEvents)}ngOnDestroy(){super.ngOnDestroy(),this._elementRef.nativeElement.removeEventListener("click",this._haltDisabledEvents)}}return n.\u0275fac=function(e){return new(e||n)(C(lr),C(be),C(di,8),C(at,8))},n.\u0275cmp=k({type:n,selectors:[["a","mat-button",""],["a","mat-raised-button",""],["a","mat-icon-button",""],["a","mat-fab",""],["a","mat-mini-fab",""],["a","mat-stroked-button",""],["a","mat-flat-button",""]],hostAttrs:[1,"mat-focus-indicator"],hostVars:7,hostBindings:function(e,i){2&e&&(Pe("tabindex",i.disabled?-1:i.tabIndex)("disabled",i.disabled||null)("aria-disabled",i.disabled.toString()),Qe("_mat-animation-noopable","NoopAnimations"===i._animationMode)("mat-button-disabled",i.disabled))},inputs:{disabled:"disabled",disableRipple:"disableRipple",color:"color",tabIndex:"tabIndex"},exportAs:["matButton","matAnchor"],features:[Le],attrs:j7,ngContentSelectors:G7,decls:4,vars:5,consts:[[1,"mat-button-wrapper"],["matRipple","",1,"mat-button-ripple",3,"matRippleDisabled","matRippleCentered","matRippleTrigger"],[1,"mat-button-focus-overlay"]],template:function(e,i){1&e&&(gn(),h(0,"span",0),Xt(1),g(),P(2,"span",1)(3,"span",2)),2&e&&(b(2),Qe("mat-button-ripple-round",i.isRoundButton||i.isIconButton),_("matRippleDisabled",i._isRippleDisabled())("matRippleCentered",i.isIconButton)("matRippleTrigger",i._getHostElement()))},dependencies:[Fr],styles:[".mat-button .mat-button-focus-overlay,.mat-icon-button .mat-button-focus-overlay{opacity:0}.mat-button:hover:not(.mat-button-disabled) .mat-button-focus-overlay,.mat-stroked-button:hover:not(.mat-button-disabled) .mat-button-focus-overlay{opacity:.04}@media(hover: none){.mat-button:hover:not(.mat-button-disabled) .mat-button-focus-overlay,.mat-stroked-button:hover:not(.mat-button-disabled) .mat-button-focus-overlay{opacity:0}}.mat-button,.mat-icon-button,.mat-stroked-button,.mat-flat-button{box-sizing:border-box;position:relative;-webkit-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:rgba(0,0,0,0);display:inline-block;white-space:nowrap;text-decoration:none;vertical-align:baseline;text-align:center;margin:0;min-width:64px;line-height:36px;padding:0 16px;border-radius:4px;overflow:visible}.mat-button::-moz-focus-inner,.mat-icon-button::-moz-focus-inner,.mat-stroked-button::-moz-focus-inner,.mat-flat-button::-moz-focus-inner{border:0}.mat-button.mat-button-disabled,.mat-icon-button.mat-button-disabled,.mat-stroked-button.mat-button-disabled,.mat-flat-button.mat-button-disabled{cursor:default}.mat-button.cdk-keyboard-focused .mat-button-focus-overlay,.mat-button.cdk-program-focused .mat-button-focus-overlay,.mat-icon-button.cdk-keyboard-focused .mat-button-focus-overlay,.mat-icon-button.cdk-program-focused .mat-button-focus-overlay,.mat-stroked-button.cdk-keyboard-focused .mat-button-focus-overlay,.mat-stroked-button.cdk-program-focused .mat-button-focus-overlay,.mat-flat-button.cdk-keyboard-focused .mat-button-focus-overlay,.mat-flat-button.cdk-program-focused .mat-button-focus-overlay{opacity:.12}.mat-button::-moz-focus-inner,.mat-icon-button::-moz-focus-inner,.mat-stroked-button::-moz-focus-inner,.mat-flat-button::-moz-focus-inner{border:0}.mat-raised-button{box-sizing:border-box;position:relative;-webkit-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:rgba(0,0,0,0);display:inline-block;white-space:nowrap;text-decoration:none;vertical-align:baseline;text-align:center;margin:0;min-width:64px;line-height:36px;padding:0 16px;border-radius:4px;overflow:visible;transform:translate3d(0, 0, 0);transition:background 400ms cubic-bezier(0.25, 0.8, 0.25, 1),box-shadow 280ms cubic-bezier(0.4, 0, 0.2, 1)}.mat-raised-button::-moz-focus-inner{border:0}.mat-raised-button.mat-button-disabled{cursor:default}.mat-raised-button.cdk-keyboard-focused .mat-button-focus-overlay,.mat-raised-button.cdk-program-focused .mat-button-focus-overlay{opacity:.12}.mat-raised-button::-moz-focus-inner{border:0}.mat-raised-button._mat-animation-noopable{transition:none !important;animation:none !important}.mat-stroked-button{border:1px solid currentColor;padding:0 15px;line-height:34px}.mat-stroked-button .mat-button-ripple.mat-ripple,.mat-stroked-button .mat-button-focus-overlay{top:-1px;left:-1px;right:-1px;bottom:-1px}.mat-fab{box-sizing:border-box;position:relative;-webkit-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:rgba(0,0,0,0);display:inline-block;white-space:nowrap;text-decoration:none;vertical-align:baseline;text-align:center;margin:0;min-width:64px;line-height:36px;padding:0 16px;border-radius:4px;overflow:visible;transform:translate3d(0, 0, 0);transition:background 400ms cubic-bezier(0.25, 0.8, 0.25, 1),box-shadow 280ms cubic-bezier(0.4, 0, 0.2, 1);min-width:0;border-radius:50%;width:56px;height:56px;padding:0;flex-shrink:0}.mat-fab::-moz-focus-inner{border:0}.mat-fab.mat-button-disabled{cursor:default}.mat-fab.cdk-keyboard-focused .mat-button-focus-overlay,.mat-fab.cdk-program-focused .mat-button-focus-overlay{opacity:.12}.mat-fab::-moz-focus-inner{border:0}.mat-fab._mat-animation-noopable{transition:none !important;animation:none !important}.mat-fab .mat-button-wrapper{padding:16px 0;display:inline-block;line-height:24px}.mat-mini-fab{box-sizing:border-box;position:relative;-webkit-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:rgba(0,0,0,0);display:inline-block;white-space:nowrap;text-decoration:none;vertical-align:baseline;text-align:center;margin:0;min-width:64px;line-height:36px;padding:0 16px;border-radius:4px;overflow:visible;transform:translate3d(0, 0, 0);transition:background 400ms cubic-bezier(0.25, 0.8, 0.25, 1),box-shadow 280ms cubic-bezier(0.4, 0, 0.2, 1);min-width:0;border-radius:50%;width:40px;height:40px;padding:0;flex-shrink:0}.mat-mini-fab::-moz-focus-inner{border:0}.mat-mini-fab.mat-button-disabled{cursor:default}.mat-mini-fab.cdk-keyboard-focused .mat-button-focus-overlay,.mat-mini-fab.cdk-program-focused .mat-button-focus-overlay{opacity:.12}.mat-mini-fab::-moz-focus-inner{border:0}.mat-mini-fab._mat-animation-noopable{transition:none !important;animation:none !important}.mat-mini-fab .mat-button-wrapper{padding:8px 0;display:inline-block;line-height:24px}.mat-icon-button{padding:0;min-width:0;width:40px;height:40px;flex-shrink:0;line-height:40px;border-radius:50%}.mat-icon-button i,.mat-icon-button .mat-icon{line-height:24px}.mat-button-ripple.mat-ripple,.mat-button-focus-overlay{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none;border-radius:inherit}.mat-button-ripple.mat-ripple:not(:empty){transform:translateZ(0)}.mat-button-focus-overlay{opacity:0;transition:opacity 200ms cubic-bezier(0.35, 0, 0.25, 1),background-color 200ms cubic-bezier(0.35, 0, 0.25, 1)}._mat-animation-noopable .mat-button-focus-overlay{transition:none}.mat-button-ripple-round{border-radius:50%;z-index:1}.mat-button .mat-button-wrapper>*,.mat-flat-button .mat-button-wrapper>*,.mat-stroked-button .mat-button-wrapper>*,.mat-raised-button .mat-button-wrapper>*,.mat-icon-button .mat-button-wrapper>*,.mat-fab .mat-button-wrapper>*,.mat-mini-fab .mat-button-wrapper>*{vertical-align:middle}.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-prefix .mat-icon-button,.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-suffix .mat-icon-button{display:inline-flex;justify-content:center;align-items:center;font-size:inherit;width:2.5em;height:2.5em}.mat-flat-button::before,.mat-raised-button::before,.mat-fab::before,.mat-mini-fab::before{margin:calc(calc(var(--mat-focus-indicator-border-width, 3px) + 2px) * -1)}.mat-stroked-button::before{margin:calc(calc(var(--mat-focus-indicator-border-width, 3px) + 3px) * -1)}.cdk-high-contrast-active .mat-button,.cdk-high-contrast-active .mat-flat-button,.cdk-high-contrast-active .mat-raised-button,.cdk-high-contrast-active .mat-icon-button,.cdk-high-contrast-active .mat-fab,.cdk-high-contrast-active .mat-mini-fab{outline:solid 1px}.mat-datepicker-toggle .mat-mdc-button-base{width:40px;height:40px;padding:8px 0}.mat-datepicker-actions .mat-button-base+.mat-button-base{margin-left:8px}[dir=rtl] .mat-datepicker-actions .mat-button-base+.mat-button-base{margin-left:0;margin-right:8px}"],encapsulation:2,changeDetection:0}),n})(),fi=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Zo,Qt,Qt]}),n})(),Wb=class{},j1=class extends Wb{constructor(t){super(),this._data=t}connect(){return H_(this._data)?this._data:qt(this._data)}disconnect(){}},qb=class{constructor(){this.viewCacheSize=20,this._viewCache=[]}applyChanges(t,e,i,r,o){t.forEachOperation((a,s,l)=>{let c,d;null==a.previousIndex?(c=this._insertView(()=>i(a,s,l),l,e,r(a)),d=c?1:0):null==l?(this._detachAndCacheView(s,e),d=3):(c=this._moveView(s,l,e,r(a)),d=2),o&&o({context:c?.context,operation:d,record:a})})}detach(){for(let t of this._viewCache)t.destroy();this._viewCache=[]}_insertView(t,e,i,r){let o=this._insertViewFromCache(e,i);if(o)return void(o.context.$implicit=r);let a=t();return i.createEmbeddedView(a.templateRef,a.context,a.index)}_detachAndCacheView(t,e){let i=e.detach(t);this._maybeCacheView(i,e)}_moveView(t,e,i,r){let o=i.get(t);return i.move(o,e),o.context.$implicit=r,o}_maybeCacheView(t,e){if(this._viewCache.length<this.viewCacheSize)this._viewCache.push(t);else{let i=e.indexOf(t);-1===i?t.destroy():e.remove(i)}}_insertViewFromCache(t,e){let i=this._viewCache.pop();return i&&e.insert(i,t),i||null}},xg=class{get selected(){return this._selected||(this._selected=Array.from(this._selection.values())),this._selected}constructor(t=!1,e,i=!0,r){this._multiple=t,this._emitChanges=i,this.compareWith=r,this._selection=new Set,this._deselectedToEmit=[],this._selectedToEmit=[],this.changed=new Ae,e&&e.length&&(t?e.forEach(o=>this._markSelected(o)):this._markSelected(e[0]),this._selectedToEmit.length=0)}select(...t){this._verifyValueAssignment(t),t.forEach(i=>this._markSelected(i));let e=this._hasQueuedChanges();return this._emitChangeEvent(),e}deselect(...t){this._verifyValueAssignment(t),t.forEach(i=>this._unmarkSelected(i));let e=this._hasQueuedChanges();return this._emitChangeEvent(),e}setSelection(...t){this._verifyValueAssignment(t);let e=this.selected,i=new Set(t);t.forEach(o=>this._markSelected(o)),e.filter(o=>!i.has(o)).forEach(o=>this._unmarkSelected(o));let r=this._hasQueuedChanges();return this._emitChangeEvent(),r}toggle(t){return this.isSelected(t)?this.deselect(t):this.select(t)}clear(t=!0){this._unmarkAll();let e=this._hasQueuedChanges();return t&&this._emitChangeEvent(),e}isSelected(t){return this._selection.has(this._getConcreteValue(t))}isEmpty(){return 0===this._selection.size}hasValue(){return!this.isEmpty()}sort(t){this._multiple&&this.selected&&this._selected.sort(t)}isMultipleSelection(){return this._multiple}_emitChangeEvent(){this._selected=null,(this._selectedToEmit.length||this._deselectedToEmit.length)&&(this.changed.next({source:this,added:this._selectedToEmit,removed:this._deselectedToEmit}),this._deselectedToEmit=[],this._selectedToEmit=[])}_markSelected(t){t=this._getConcreteValue(t),this.isSelected(t)||(this._multiple||this._unmarkAll(),this.isSelected(t)||this._selection.add(t),this._emitChanges&&this._selectedToEmit.push(t))}_unmarkSelected(t){t=this._getConcreteValue(t),this.isSelected(t)&&(this._selection.delete(t),this._emitChanges&&this._deselectedToEmit.push(t))}_unmarkAll(){this.isEmpty()||this._selection.forEach(t=>this._unmarkSelected(t))}_verifyValueAssignment(t){}_hasQueuedChanges(){return!(!this._deselectedToEmit.length&&!this._selectedToEmit.length)}_getConcreteValue(t){if(this.compareWith){for(let e of this._selection)if(this.compareWith(t,e))return e;return t}return t}},G1=new ie("_ViewRepeater"),A_e=["contentWrapper"],R_e=["*"],X7=new ie("VIRTUAL_SCROLL_STRATEGY");function k_e(n){return n._scrollStrategy}var Q7=(()=>{class n{constructor(){this._itemSize=20,this._minBufferPx=100,this._maxBufferPx=200,this._scrollStrategy=new class{constructor(t,e,i){this._scrolledIndexChange=new Ae,this.scrolledIndexChange=this._scrolledIndexChange.pipe(ui()),this._viewport=null,this._itemSize=t,this._minBufferPx=e,this._maxBufferPx=i}attach(t){this._viewport=t,this._updateTotalContentSize(),this._updateRenderedRange()}detach(){this._scrolledIndexChange.complete(),this._viewport=null}updateItemAndBufferSize(t,e,i){this._itemSize=t,this._minBufferPx=e,this._maxBufferPx=i,this._updateTotalContentSize(),this._updateRenderedRange()}onContentScrolled(){this._updateRenderedRange()}onDataLengthChanged(){this._updateTotalContentSize(),this._updateRenderedRange()}onContentRendered(){}onRenderedOffsetChanged(){}scrollToIndex(t,e){this._viewport&&this._viewport.scrollToOffset(t*this._itemSize,e)}_updateTotalContentSize(){!this._viewport||this._viewport.setTotalContentSize(this._viewport.getDataLength()*this._itemSize)}_updateRenderedRange(){if(!this._viewport)return;let t=this._viewport.getRenderedRange(),e={start:t.start,end:t.end},i=this._viewport.getViewportSize(),r=this._viewport.getDataLength(),o=this._viewport.measureScrollOffset(),a=this._itemSize>0?o/this._itemSize:0;if(e.end>r){let l=Math.ceil(i/this._itemSize),c=Math.max(0,Math.min(a,r-l));a!=c&&(a=c,o=c*this._itemSize,e.start=Math.floor(a)),e.end=Math.max(0,Math.min(r,e.start+l))}let s=o-e.start*this._itemSize;if(s<this._minBufferPx&&0!=e.start){let l=Math.ceil((this._maxBufferPx-s)/this._itemSize);e.start=Math.max(0,e.start-l),e.end=Math.min(r,Math.ceil(a+(i+this._minBufferPx)/this._itemSize))}else{let l=e.end*this._itemSize-(o+i);if(l<this._minBufferPx&&e.end!=r){let c=Math.ceil((this._maxBufferPx-l)/this._itemSize);c>0&&(e.end=Math.min(r,e.end+c),e.start=Math.max(0,Math.floor(a-this._minBufferPx/this._itemSize)))}}this._viewport.setRenderedRange(e),this._viewport.setRenderedContentOffset(this._itemSize*e.start),this._scrolledIndexChange.next(Math.floor(a))}}(this.itemSize,this.minBufferPx,this.maxBufferPx)}get itemSize(){return this._itemSize}set itemSize(e){this._itemSize=Di(e)}get minBufferPx(){return this._minBufferPx}set minBufferPx(e){this._minBufferPx=Di(e)}get maxBufferPx(){return this._maxBufferPx}set maxBufferPx(e){this._maxBufferPx=Di(e)}ngOnChanges(){this._scrollStrategy.updateItemAndBufferSize(this.itemSize,this.minBufferPx,this.maxBufferPx)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275dir=xe({type:n,selectors:[["cdk-virtual-scroll-viewport","itemSize",""]],inputs:{itemSize:"itemSize",minBufferPx:"minBufferPx",maxBufferPx:"maxBufferPx"},standalone:!0,features:[Rt([{provide:X7,useFactory:k_e,deps:[Vn(()=>n)]}]),Gt]}),n})(),Rf=(()=>{class n{constructor(e,i,r){this._ngZone=e,this._platform=i,this._scrolled=new Ae,this._globalSubscription=null,this._scrolledCount=0,this.scrollContainers=new Map,this._document=r}register(e){this.scrollContainers.has(e)||this.scrollContainers.set(e,e.elementScrolled().subscribe(()=>this._scrolled.next(e)))}deregister(e){let i=this.scrollContainers.get(e);i&&(i.unsubscribe(),this.scrollContainers.delete(e))}scrolled(e=20){return this._platform.isBrowser?new en(i=>{this._globalSubscription||this._addGlobalListener();let r=e>0?this._scrolled.pipe(ic(e)).subscribe(i):this._scrolled.subscribe(i);return this._scrolledCount++,()=>{r.unsubscribe(),this._scrolledCount--,this._scrolledCount||this._removeGlobalListener()}}):qt()}ngOnDestroy(){this._removeGlobalListener(),this.scrollContainers.forEach((e,i)=>this.deregister(i)),this._scrolled.complete()}ancestorScrolled(e,i){let r=this.getAncestorScrollContainers(e);return this.scrolled(i).pipe(Ve(o=>!o||r.indexOf(o)>-1))}getAncestorScrollContainers(e){let i=[];return this.scrollContainers.forEach((r,o)=>{this._scrollableContainsElement(o,e)&&i.push(o)}),i}_getWindow(){return this._document.defaultView||window}_scrollableContainsElement(e,i){let r=Va(i),o=e.getElementRef().nativeElement;do{if(r==o)return!0}while(r=r.parentElement);return!1}_addGlobalListener(){this._globalSubscription=this._ngZone.runOutsideAngular(()=>ai(this._getWindow().document,"scroll").subscribe(()=>this._scrolled.next()))}_removeGlobalListener(){this._globalSubscription&&(this._globalSubscription.unsubscribe(),this._globalSubscription=null)}}return n.\u0275fac=function(e){return new(e||n)(O(at),O($n),O(kt,8))},n.\u0275prov=pe({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),Bu=(()=>{class n{constructor(e,i,r,o){this.elementRef=e,this.scrollDispatcher=i,this.ngZone=r,this.dir=o,this._destroyed=new Ae,this._elementScrolled=new en(a=>this.ngZone.runOutsideAngular(()=>ai(this.elementRef.nativeElement,"scroll").pipe(ot(this._destroyed)).subscribe(a)))}ngOnInit(){this.scrollDispatcher.register(this)}ngOnDestroy(){this.scrollDispatcher.deregister(this),this._destroyed.next(),this._destroyed.complete()}elementScrolled(){return this._elementScrolled}getElementRef(){return this.elementRef}scrollTo(e){let i=this.elementRef.nativeElement,r=this.dir&&"rtl"==this.dir.value;null==e.left&&(e.left=r?e.end:e.start),null==e.right&&(e.right=r?e.start:e.end),null!=e.bottom&&(e.top=i.scrollHeight-i.clientHeight-e.bottom),r&&0!=dg()?(null!=e.left&&(e.right=i.scrollWidth-i.clientWidth-e.left),2==dg()?e.left=e.right:1==dg()&&(e.left=e.right?-e.right:e.right)):null!=e.right&&(e.left=i.scrollWidth-i.clientWidth-e.right),this._applyScrollToOptions(e)}_applyScrollToOptions(e){let i=this.elementRef.nativeElement;P1()?i.scrollTo(e):(null!=e.top&&(i.scrollTop=e.top),null!=e.left&&(i.scrollLeft=e.left))}measureScrollOffset(e){let i="left",r="right",o=this.elementRef.nativeElement;if("top"==e)return o.scrollTop;if("bottom"==e)return o.scrollHeight-o.clientHeight-o.scrollTop;let a=this.dir&&"rtl"==this.dir.value;return"start"==e?e=a?r:i:"end"==e&&(e=a?i:r),a&&2==dg()?e==i?o.scrollWidth-o.clientWidth-o.scrollLeft:o.scrollLeft:a&&1==dg()?e==i?o.scrollLeft+o.scrollWidth-o.clientWidth:-o.scrollLeft:e==i?o.scrollLeft:o.scrollWidth-o.clientWidth-o.scrollLeft}}return n.\u0275fac=function(e){return new(e||n)(C(be),C(Rf),C(at),C(Hi,8))},n.\u0275dir=xe({type:n,selectors:[["","cdk-scrollable",""],["","cdkScrollable",""]],standalone:!0}),n})(),Ko=(()=>{class n{constructor(e,i,r){this._platform=e,this._change=new Ae,this._changeListener=o=>{this._change.next(o)},this._document=r,i.runOutsideAngular(()=>{if(e.isBrowser){let o=this._getWindow();o.addEventListener("resize",this._changeListener),o.addEventListener("orientationchange",this._changeListener)}this.change().subscribe(()=>this._viewportSize=null)})}ngOnDestroy(){if(this._platform.isBrowser){let e=this._getWindow();e.removeEventListener("resize",this._changeListener),e.removeEventListener("orientationchange",this._changeListener)}this._change.complete()}getViewportSize(){this._viewportSize||this._updateViewportSize();let e={width:this._viewportSize.width,height:this._viewportSize.height};return this._platform.isBrowser||(this._viewportSize=null),e}getViewportRect(){let e=this.getViewportScrollPosition(),{width:i,height:r}=this.getViewportSize();return{top:e.top,left:e.left,bottom:e.top+r,right:e.left+i,height:r,width:i}}getViewportScrollPosition(){if(!this._platform.isBrowser)return{top:0,left:0};let e=this._document,i=this._getWindow(),r=e.documentElement,o=r.getBoundingClientRect();return{top:-o.top||e.body.scrollTop||i.scrollY||r.scrollTop||0,left:-o.left||e.body.scrollLeft||i.scrollX||r.scrollLeft||0}}change(e=20){return e>0?this._change.pipe(ic(e)):this._change}_getWindow(){return this._document.defaultView||window}_updateViewportSize(){let e=this._getWindow();this._viewportSize=this._platform.isBrowser?{width:e.innerWidth,height:e.innerHeight}:{width:0,height:0}}}return n.\u0275fac=function(e){return new(e||n)(O($n),O(at),O(kt,8))},n.\u0275prov=pe({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),q7=new ie("VIRTUAL_SCROLLABLE"),F_e=(()=>{class n extends Bu{constructor(e,i,r,o){super(e,i,r,o)}measureViewportSize(e){let i=this.elementRef.nativeElement;return"horizontal"===e?i.clientWidth:i.clientHeight}}return n.\u0275fac=function(e){return new(e||n)(C(be),C(Rf),C(at),C(Hi,8))},n.\u0275dir=xe({type:n,features:[Le]}),n})(),N_e=typeof requestAnimationFrame<"u"?$A:Um,Cg=(()=>{class n extends F_e{get orientation(){return this._orientation}set orientation(e){this._orientation!==e&&(this._orientation=e,this._calculateSpacerSize())}get appendOnly(){return this._appendOnly}set appendOnly(e){this._appendOnly=Ut(e)}constructor(e,i,r,o,a,s,l,c){super(e,s,r,a),this.elementRef=e,this._changeDetectorRef=i,this._scrollStrategy=o,this.scrollable=c,this._platform=pi($n),this._detachedSubject=new Ae,this._renderedRangeSubject=new Ae,this._orientation="vertical",this._appendOnly=!1,this.scrolledIndexChange=new en(d=>this._scrollStrategy.scrolledIndexChange.subscribe(u=>Promise.resolve().then(()=>this.ngZone.run(()=>d.next(u))))),this.renderedRangeStream=this._renderedRangeSubject,this._totalContentSize=0,this._totalContentWidth="",this._totalContentHeight="",this._renderedRange={start:0,end:0},this._dataLength=0,this._viewportSize=0,this._renderedContentOffset=0,this._renderedContentOffsetNeedsRewrite=!1,this._isChangeDetectionPending=!1,this._runAfterChangeDetection=[],this._viewportChanges=yn.EMPTY,this._viewportChanges=l.change().subscribe(()=>{this.checkViewportSize()}),this.scrollable||(this.elementRef.nativeElement.classList.add("cdk-virtual-scrollable"),this.scrollable=this)}ngOnInit(){!this._platform.isBrowser||(this.scrollable===this&&super.ngOnInit(),this.ngZone.runOutsideAngular(()=>Promise.resolve().then(()=>{this._measureViewportSize(),this._scrollStrategy.attach(this),this.scrollable.elementScrolled().pipe(Nn(null),ic(0,N_e)).subscribe(()=>this._scrollStrategy.onContentScrolled()),this._markChangeDetectionNeeded()})))}ngOnDestroy(){this.detach(),this._scrollStrategy.detach(),this._renderedRangeSubject.complete(),this._detachedSubject.complete(),this._viewportChanges.unsubscribe(),super.ngOnDestroy()}attach(e){this.ngZone.runOutsideAngular(()=>{this._forOf=e,this._forOf.dataStream.pipe(ot(this._detachedSubject)).subscribe(i=>{let r=i.length;r!==this._dataLength&&(this._dataLength=r,this._scrollStrategy.onDataLengthChanged()),this._doChangeDetection()})})}detach(){this._forOf=null,this._detachedSubject.next()}getDataLength(){return this._dataLength}getViewportSize(){return this._viewportSize}getRenderedRange(){return this._renderedRange}measureBoundingClientRectWithScrollOffset(e){return this.getElementRef().nativeElement.getBoundingClientRect()[e]}setTotalContentSize(e){this._totalContentSize!==e&&(this._totalContentSize=e,this._calculateSpacerSize(),this._markChangeDetectionNeeded())}setRenderedRange(e){(function(n,t){return n.start==t.start&&n.end==t.end})(this._renderedRange,e)||(this.appendOnly&&(e={start:0,end:Math.max(this._renderedRange.end,e.end)}),this._renderedRangeSubject.next(this._renderedRange=e),this._markChangeDetectionNeeded(()=>this._scrollStrategy.onContentRendered()))}getOffsetToRenderedContentStart(){return this._renderedContentOffsetNeedsRewrite?null:this._renderedContentOffset}setRenderedContentOffset(e,i="to-start"){e=this.appendOnly&&"to-start"===i?0:e;let o="horizontal"==this.orientation,a=o?"X":"Y",l=`translate${a}(${Number((o&&this.dir&&"rtl"==this.dir.value?-1:1)*e)}px)`;this._renderedContentOffset=e,"to-end"===i&&(l+=` translate${a}(-100%)`,this._renderedContentOffsetNeedsRewrite=!0),this._renderedContentTransform!=l&&(this._renderedContentTransform=l,this._markChangeDetectionNeeded(()=>{this._renderedContentOffsetNeedsRewrite?(this._renderedContentOffset-=this.measureRenderedContentSize(),this._renderedContentOffsetNeedsRewrite=!1,this.setRenderedContentOffset(this._renderedContentOffset)):this._scrollStrategy.onRenderedOffsetChanged()}))}scrollToOffset(e,i="auto"){let r={behavior:i};"horizontal"===this.orientation?r.start=e:r.top=e,this.scrollable.scrollTo(r)}scrollToIndex(e,i="auto"){this._scrollStrategy.scrollToIndex(e,i)}measureScrollOffset(e){let i;return i=this.scrollable==this?r=>super.measureScrollOffset(r):r=>this.scrollable.measureScrollOffset(r),Math.max(0,i(e??("horizontal"===this.orientation?"start":"top"))-this.measureViewportOffset())}measureViewportOffset(e){let i,r="left",o="right",a="rtl"==this.dir?.value;i="start"==e?a?o:r:"end"==e?a?r:o:e||("horizontal"===this.orientation?"left":"top");let s=this.scrollable.measureBoundingClientRectWithScrollOffset(i);return this.elementRef.nativeElement.getBoundingClientRect()[i]-s}measureRenderedContentSize(){let e=this._contentWrapper.nativeElement;return"horizontal"===this.orientation?e.offsetWidth:e.offsetHeight}measureRangeSize(e){return this._forOf?this._forOf.measureRangeSize(e,this.orientation):0}checkViewportSize(){this._measureViewportSize(),this._scrollStrategy.onDataLengthChanged()}_measureViewportSize(){this._viewportSize=this.scrollable.measureViewportSize(this.orientation)}_markChangeDetectionNeeded(e){e&&this._runAfterChangeDetection.push(e),this._isChangeDetectionPending||(this._isChangeDetectionPending=!0,this.ngZone.runOutsideAngular(()=>Promise.resolve().then(()=>{this._doChangeDetection()})))}_doChangeDetection(){this._isChangeDetectionPending=!1,this._contentWrapper.nativeElement.style.transform=this._renderedContentTransform,this.ngZone.run(()=>this._changeDetectorRef.markForCheck());let e=this._runAfterChangeDetection;this._runAfterChangeDetection=[];for(let i of e)i()}_calculateSpacerSize(){this._totalContentHeight="horizontal"===this.orientation?"":`${this._totalContentSize}px`,this._totalContentWidth="horizontal"===this.orientation?`${this._totalContentSize}px`:""}}return n.\u0275fac=function(e){return new(e||n)(C(be),C(Ft),C(at),C(X7,8),C(Hi,8),C(Rf),C(Ko),C(q7,8))},n.\u0275cmp=k({type:n,selectors:[["cdk-virtual-scroll-viewport"]],viewQuery:function(e,i){if(1&e&&Ye(A_e,7),2&e){let r;we(r=Se())&&(i._contentWrapper=r.first)}},hostAttrs:[1,"cdk-virtual-scroll-viewport"],hostVars:4,hostBindings:function(e,i){2&e&&Qe("cdk-virtual-scroll-orientation-horizontal","horizontal"===i.orientation)("cdk-virtual-scroll-orientation-vertical","horizontal"!==i.orientation)},inputs:{orientation:"orientation",appendOnly:"appendOnly"},outputs:{scrolledIndexChange:"scrolledIndexChange"},standalone:!0,features:[Rt([{provide:Bu,useFactory:(t,e)=>t||e,deps:[[new Aa,new mh(q7)],n]}]),Le,FP],ngContentSelectors:R_e,decls:4,vars:4,consts:[[1,"cdk-virtual-scroll-content-wrapper"],["contentWrapper",""],[1,"cdk-virtual-scroll-spacer"]],template:function(e,i){1&e&&(gn(),h(0,"div",0,1),Xt(2),g(),P(3,"div",2)),2&e&&(b(3),Mt("width",i._totalContentWidth)("height",i._totalContentHeight))},styles:["cdk-virtual-scroll-viewport{display:block;position:relative;transform:translateZ(0)}.cdk-virtual-scrollable{overflow:auto;will-change:scroll-position;contain:strict;-webkit-overflow-scrolling:touch}.cdk-virtual-scroll-content-wrapper{position:absolute;top:0;left:0;contain:content}[dir=rtl] .cdk-virtual-scroll-content-wrapper{right:0;left:auto}.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper{min-height:100%}.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>dl:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>ol:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>table:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>ul:not([cdkVirtualFor]){padding-left:0;padding-right:0;margin-left:0;margin-right:0;border-left-width:0;border-right-width:0;outline:none}.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper{min-width:100%}.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>dl:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>ol:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>table:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>ul:not([cdkVirtualFor]){padding-top:0;padding-bottom:0;margin-top:0;margin-bottom:0;border-top-width:0;border-bottom-width:0;outline:none}.cdk-virtual-scroll-spacer{height:1px;transform-origin:0 0;flex:0 0 auto}[dir=rtl] .cdk-virtual-scroll-spacer{transform-origin:100% 0}"],encapsulation:2,changeDetection:0}),n})();function Y7(n,t,e){if(!e.getBoundingClientRect)return 0;let r=e.getBoundingClientRect();return"horizontal"===n?"start"===t?r.left:r.right:"start"===t?r.top:r.bottom}var Z7=(()=>{class n{get cdkVirtualForOf(){return this._cdkVirtualForOf}set cdkVirtualForOf(e){this._cdkVirtualForOf=e,function(n){return n&&"function"==typeof n.connect&&!(n instanceof L_)}(e)?this._dataSourceChanges.next(e):this._dataSourceChanges.next(new j1(H_(e)?e:Array.from(e||[])))}get cdkVirtualForTrackBy(){return this._cdkVirtualForTrackBy}set cdkVirtualForTrackBy(e){this._needsUpdate=!0,this._cdkVirtualForTrackBy=e?(i,r)=>e(i+(this._renderedRange?this._renderedRange.start:0),r):void 0}set cdkVirtualForTemplate(e){e&&(this._needsUpdate=!0,this._template=e)}get cdkVirtualForTemplateCacheSize(){return this._viewRepeater.viewCacheSize}set cdkVirtualForTemplateCacheSize(e){this._viewRepeater.viewCacheSize=Di(e)}constructor(e,i,r,o,a,s){this._viewContainerRef=e,this._template=i,this._differs=r,this._viewRepeater=o,this._viewport=a,this.viewChange=new Ae,this._dataSourceChanges=new Ae,this.dataStream=this._dataSourceChanges.pipe(Nn(null),Ym(),yi(([l,c])=>this._changeDataSource(l,c)),Ea(1)),this._differ=null,this._needsUpdate=!1,this._destroyed=new Ae,this.dataStream.subscribe(l=>{this._data=l,this._onRenderedDataChange()}),this._viewport.renderedRangeStream.pipe(ot(this._destroyed)).subscribe(l=>{this._renderedRange=l,this.viewChange.observers.length&&s.run(()=>this.viewChange.next(this._renderedRange)),this._onRenderedDataChange()}),this._viewport.attach(this)}measureRangeSize(e,i){if(e.start>=e.end)return 0;let a,s,r=e.start-this._renderedRange.start,o=e.end-e.start;for(let l=0;l<o;l++){let c=this._viewContainerRef.get(l+r);if(c&&c.rootNodes.length){a=s=c.rootNodes[0];break}}for(let l=o-1;l>-1;l--){let c=this._viewContainerRef.get(l+r);if(c&&c.rootNodes.length){s=c.rootNodes[c.rootNodes.length-1];break}}return a&&s?Y7(i,"end",s)-Y7(i,"start",a):0}ngDoCheck(){if(this._differ&&this._needsUpdate){let e=this._differ.diff(this._renderedItems);e?this._applyChanges(e):this._updateContext(),this._needsUpdate=!1}}ngOnDestroy(){this._viewport.detach(),this._dataSourceChanges.next(void 0),this._dataSourceChanges.complete(),this.viewChange.complete(),this._destroyed.next(),this._destroyed.complete(),this._viewRepeater.detach()}_onRenderedDataChange(){!this._renderedRange||(this._renderedItems=this._data.slice(this._renderedRange.start,this._renderedRange.end),this._differ||(this._differ=this._differs.find(this._renderedItems).create((e,i)=>this.cdkVirtualForTrackBy?this.cdkVirtualForTrackBy(e,i):i)),this._needsUpdate=!0)}_changeDataSource(e,i){return e&&e.disconnect(this),this._needsUpdate=!0,i?i.connect(this):qt()}_updateContext(){let e=this._data.length,i=this._viewContainerRef.length;for(;i--;){let r=this._viewContainerRef.get(i);r.context.index=this._renderedRange.start+i,r.context.count=e,this._updateComputedContextProperties(r.context),r.detectChanges()}}_applyChanges(e){this._viewRepeater.applyChanges(e,this._viewContainerRef,(o,a,s)=>this._getEmbeddedViewArgs(o,s),o=>o.item),e.forEachIdentityChange(o=>{this._viewContainerRef.get(o.currentIndex).context.$implicit=o.item});let i=this._data.length,r=this._viewContainerRef.length;for(;r--;){let o=this._viewContainerRef.get(r);o.context.index=this._renderedRange.start+r,o.context.count=i,this._updateComputedContextProperties(o.context)}}_updateComputedContextProperties(e){e.first=0===e.index,e.last=e.index===e.count-1,e.even=e.index%2==0,e.odd=!e.even}_getEmbeddedViewArgs(e,i){return{templateRef:this._template,context:{$implicit:e.item,cdkVirtualForOf:this._cdkVirtualForOf,index:-1,count:-1,first:!1,last:!1,odd:!1,even:!1},index:i}}}return n.\u0275fac=function(e){return new(e||n)(C(Zn),C(Si),C(vl),C(G1),C(Cg,4),C(at))},n.\u0275dir=xe({type:n,selectors:[["","cdkVirtualFor","","cdkVirtualForOf",""]],inputs:{cdkVirtualForOf:"cdkVirtualForOf",cdkVirtualForTrackBy:"cdkVirtualForTrackBy",cdkVirtualForTemplate:"cdkVirtualForTemplate",cdkVirtualForTemplateCacheSize:"cdkVirtualForTemplateCacheSize"},standalone:!0,features:[Rt([{provide:G1,useClass:qb}])]}),n})(),Rc=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({}),n})(),Md=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Nu,Rc,Cg,Nu,Rc]}),n})(),Yb=class{attach(t){return this._attachedHost=t,t.attach(this)}detach(){let t=this._attachedHost;null!=t&&(this._attachedHost=null,t.detach())}get isAttached(){return null!=this._attachedHost}setAttachedHost(t){this._attachedHost=t}},Pl=class extends Yb{constructor(t,e,i,r,o){super(),this.component=t,this.viewContainerRef=e,this.injector=i,this.componentFactoryResolver=r,this.projectableNodes=o}},Jo=class extends Yb{constructor(t,e,i,r){super(),this.templateRef=t,this.viewContainerRef=e,this.context=i,this.injector=r}get origin(){return this.templateRef.elementRef}attach(t,e=this.context){return this.context=e,super.attach(t)}detach(){return this.context=void 0,super.detach()}},R2=class extends Yb{constructor(t){super(),this.element=t instanceof be?t.nativeElement:t}},Vu=class{constructor(){this._isDisposed=!1,this.attachDomPortal=null}hasAttached(){return!!this._attachedPortal}attach(t){return t instanceof Pl?(this._attachedPortal=t,this.attachComponentPortal(t)):t instanceof Jo?(this._attachedPortal=t,this.attachTemplatePortal(t)):this.attachDomPortal&&t instanceof R2?(this._attachedPortal=t,this.attachDomPortal(t)):void 0}detach(){this._attachedPortal&&(this._attachedPortal.setAttachedHost(null),this._attachedPortal=null),this._invokeDisposeFn()}dispose(){this.hasAttached()&&this.detach(),this._invokeDisposeFn(),this._isDisposed=!0}setDisposeFn(t){this._disposeFn=t}_invokeDisposeFn(){this._disposeFn&&(this._disposeFn(),this._disposeFn=null)}},Xb=class extends Vu{constructor(t,e,i,r,o){super(),this.outletElement=t,this._componentFactoryResolver=e,this._appRef=i,this._defaultInjector=r,this.attachDomPortal=a=>{let s=a.element,l=this._document.createComment("dom-portal");s.parentNode.insertBefore(l,s),this.outletElement.appendChild(s),this._attachedPortal=a,super.setDisposeFn(()=>{l.parentNode&&l.parentNode.replaceChild(s,l)})},this._document=o}attachComponentPortal(t){let r,i=(t.componentFactoryResolver||this._componentFactoryResolver).resolveComponentFactory(t.component);return t.viewContainerRef?(r=t.viewContainerRef.createComponent(i,t.viewContainerRef.length,t.injector||t.viewContainerRef.injector,t.projectableNodes||void 0),this.setDisposeFn(()=>r.destroy())):(r=i.create(t.injector||this._defaultInjector||bi.NULL),this._appRef.attachView(r.hostView),this.setDisposeFn(()=>{this._appRef.viewCount>0&&this._appRef.detachView(r.hostView),r.destroy()})),this.outletElement.appendChild(this._getComponentRootNode(r)),this._attachedPortal=t,r}attachTemplatePortal(t){let e=t.viewContainerRef,i=e.createEmbeddedView(t.templateRef,t.context,{injector:t.injector});return i.rootNodes.forEach(r=>this.outletElement.appendChild(r)),i.detectChanges(),this.setDisposeFn(()=>{let r=e.indexOf(i);-1!==r&&e.remove(r)}),this._attachedPortal=t,i}dispose(){super.dispose(),this.outletElement.remove()}_getComponentRootNode(t){return t.hostView.rootNodes[0]}},K7=(()=>{class n extends Jo{constructor(e,i){super(e,i)}}return n.\u0275fac=function(e){return new(e||n)(C(Si),C(Zn))},n.\u0275dir=xe({type:n,selectors:[["","cdkPortal",""]],exportAs:["cdkPortal"],features:[Le]}),n})(),No=(()=>{class n extends Vu{constructor(e,i,r){super(),this._componentFactoryResolver=e,this._viewContainerRef=i,this._isInitialized=!1,this.attached=new L,this.attachDomPortal=o=>{let a=o.element,s=this._document.createComment("dom-portal");o.setAttachedHost(this),a.parentNode.insertBefore(s,a),this._getRootNode().appendChild(a),this._attachedPortal=o,super.setDisposeFn(()=>{s.parentNode&&s.parentNode.replaceChild(a,s)})},this._document=r}get portal(){return this._attachedPortal}set portal(e){this.hasAttached()&&!e&&!this._isInitialized||(this.hasAttached()&&super.detach(),e&&super.attach(e),this._attachedPortal=e||null)}get attachedRef(){return this._attachedRef}ngOnInit(){this._isInitialized=!0}ngOnDestroy(){super.dispose(),this._attachedRef=this._attachedPortal=null}attachComponentPortal(e){e.setAttachedHost(this);let i=null!=e.viewContainerRef?e.viewContainerRef:this._viewContainerRef,o=(e.componentFactoryResolver||this._componentFactoryResolver).resolveComponentFactory(e.component),a=i.createComponent(o,i.length,e.injector||i.injector,e.projectableNodes||void 0);return i!==this._viewContainerRef&&this._getRootNode().appendChild(a.hostView.rootNodes[0]),super.setDisposeFn(()=>a.destroy()),this._attachedPortal=e,this._attachedRef=a,this.attached.emit(a),a}attachTemplatePortal(e){e.setAttachedHost(this);let i=this._viewContainerRef.createEmbeddedView(e.templateRef,e.context,{injector:e.injector});return super.setDisposeFn(()=>this._viewContainerRef.clear()),this._attachedPortal=e,this._attachedRef=i,this.attached.emit(i),i}_getRootNode(){let e=this._viewContainerRef.element.nativeElement;return e.nodeType===e.ELEMENT_NODE?e:e.parentNode}}return n.\u0275fac=function(e){return new(e||n)(C(Qr),C(Zn),C(kt))},n.\u0275dir=xe({type:n,selectors:[["","cdkPortalOutlet",""]],inputs:{portal:["cdkPortalOutlet","portal"]},outputs:{attached:"attached"},exportAs:["cdkPortalOutlet"],features:[Le]}),n})(),us=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({}),n})(),J7=P1(),q1=class{enable(){}disable(){}attach(){}};function O2(n,t){return t.some(e=>n.bottom<e.top||n.top>e.bottom||n.right<e.left||n.left>e.right)}function $7(n,t){return t.some(e=>n.top<e.top||n.bottom>e.bottom||n.left<e.left||n.right>e.right)}var Pf=class{constructor(t,e,i,r){this._scrollDispatcher=t,this._viewportRuler=e,this._ngZone=i,this._config=r,this._scrollSubscription=null}attach(t){this._overlayRef=t}enable(){this._scrollSubscription||(this._scrollSubscription=this._scrollDispatcher.scrolled(this._config?this._config.scrollThrottle:0).subscribe(()=>{if(this._overlayRef.updatePosition(),this._config&&this._config.autoClose){let e=this._overlayRef.overlayElement.getBoundingClientRect(),{width:i,height:r}=this._viewportRuler.getViewportSize();O2(e,[{width:i,height:r,bottom:r,right:i,top:0,left:0}])&&(this.disable(),this._ngZone.run(()=>this._overlayRef.detach()))}}))}disable(){this._scrollSubscription&&(this._scrollSubscription.unsubscribe(),this._scrollSubscription=null)}detach(){this.disable(),this._overlayRef=null}},B_e=(()=>{class n{constructor(e,i,r,o){this._scrollDispatcher=e,this._viewportRuler=i,this._ngZone=r,this.noop=()=>new q1,this.close=a=>new class{constructor(t,e,i,r){this._scrollDispatcher=t,this._ngZone=e,this._viewportRuler=i,this._config=r,this._scrollSubscription=null,this._detach=()=>{this.disable(),this._overlayRef.hasAttached()&&this._ngZone.run(()=>this._overlayRef.detach())}}attach(t){this._overlayRef=t}enable(){if(this._scrollSubscription)return;let t=this._scrollDispatcher.scrolled(0).pipe(Ve(e=>!e||!this._overlayRef.overlayElement.contains(e.getElementRef().nativeElement)));this._config&&this._config.threshold&&this._config.threshold>1?(this._initialScrollPosition=this._viewportRuler.getViewportScrollPosition().top,this._scrollSubscription=t.subscribe(()=>{let e=this._viewportRuler.getViewportScrollPosition().top;Math.abs(e-this._initialScrollPosition)>this._config.threshold?this._detach():this._overlayRef.updatePosition()})):this._scrollSubscription=t.subscribe(this._detach)}disable(){this._scrollSubscription&&(this._scrollSubscription.unsubscribe(),this._scrollSubscription=null)}detach(){this.disable(),this._overlayRef=null}}(this._scrollDispatcher,this._ngZone,this._viewportRuler,a),this.block=()=>new class{constructor(t,e){this._viewportRuler=t,this._previousHTMLStyles={top:"",left:""},this._isEnabled=!1,this._document=e}attach(){}enable(){if(this._canBeEnabled()){let t=this._document.documentElement;this._previousScrollPosition=this._viewportRuler.getViewportScrollPosition(),this._previousHTMLStyles.left=t.style.left||"",this._previousHTMLStyles.top=t.style.top||"",t.style.left=Zr(-this._previousScrollPosition.left),t.style.top=Zr(-this._previousScrollPosition.top),t.classList.add("cdk-global-scrollblock"),this._isEnabled=!0}}disable(){if(this._isEnabled){let t=this._document.documentElement,i=t.style,r=this._document.body.style,o=i.scrollBehavior||"",a=r.scrollBehavior||"";this._isEnabled=!1,i.left=this._previousHTMLStyles.left,i.top=this._previousHTMLStyles.top,t.classList.remove("cdk-global-scrollblock"),J7&&(i.scrollBehavior=r.scrollBehavior="auto"),window.scroll(this._previousScrollPosition.left,this._previousScrollPosition.top),J7&&(i.scrollBehavior=o,r.scrollBehavior=a)}}_canBeEnabled(){if(this._document.documentElement.classList.contains("cdk-global-scrollblock")||this._isEnabled)return!1;let e=this._document.body,i=this._viewportRuler.getViewportSize();return e.scrollHeight>i.height||e.scrollWidth>i.width}}(this._viewportRuler,this._document),this.reposition=a=>new Pf(this._scrollDispatcher,this._viewportRuler,this._ngZone,a),this._document=o}}return n.\u0275fac=function(e){return new(e||n)(O(Rf),O(Ko),O(at),O(kt))},n.\u0275prov=pe({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),Ws=class{constructor(t){if(this.scrollStrategy=new q1,this.panelClass="",this.hasBackdrop=!1,this.backdropClass="cdk-overlay-dark-backdrop",this.disposeOnNavigation=!1,t){let e=Object.keys(t);for(let i of e)void 0!==t[i]&&(this[i]=t[i])}}},r9=(()=>{class n{constructor(e){this._attachedOverlays=[],this._document=e}ngOnDestroy(){this.detach()}add(e){this.remove(e),this._attachedOverlays.push(e)}remove(e){let i=this._attachedOverlays.indexOf(e);i>-1&&this._attachedOverlays.splice(i,1),0===this._attachedOverlays.length&&this.detach()}}return n.\u0275fac=function(e){return new(e||n)(O(kt))},n.\u0275prov=pe({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),V_e=(()=>{class n extends r9{constructor(e,i){super(e),this._ngZone=i,this._keydownListener=r=>{let o=this._attachedOverlays;for(let a=o.length-1;a>-1;a--)if(o[a]._keydownEvents.observers.length>0){let s=o[a]._keydownEvents;this._ngZone?this._ngZone.run(()=>s.next(r)):s.next(r);break}}}add(e){super.add(e),this._isAttached||(this._ngZone?this._ngZone.runOutsideAngular(()=>this._document.body.addEventListener("keydown",this._keydownListener)):this._document.body.addEventListener("keydown",this._keydownListener),this._isAttached=!0)}detach(){this._isAttached&&(this._document.body.removeEventListener("keydown",this._keydownListener),this._isAttached=!1)}}return n.\u0275fac=function(e){return new(e||n)(O(kt),O(at,8))},n.\u0275prov=pe({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),H_e=(()=>{class n extends r9{constructor(e,i,r){super(e),this._platform=i,this._ngZone=r,this._cursorStyleIsSet=!1,this._pointerDownListener=o=>{this._pointerDownEventTarget=ds(o)},this._clickListener=o=>{let a=ds(o),s="click"===o.type&&this._pointerDownEventTarget?this._pointerDownEventTarget:a;this._pointerDownEventTarget=null;let l=this._attachedOverlays.slice();for(let c=l.length-1;c>-1;c--){let d=l[c];if(d._outsidePointerEvents.observers.length<1||!d.hasAttached())continue;if(d.overlayElement.contains(a)||d.overlayElement.contains(s))break;let u=d._outsidePointerEvents;this._ngZone?this._ngZone.run(()=>u.next(o)):u.next(o)}}}add(e){if(super.add(e),!this._isAttached){let i=this._document.body;this._ngZone?this._ngZone.runOutsideAngular(()=>this._addEventListeners(i)):this._addEventListeners(i),this._platform.IOS&&!this._cursorStyleIsSet&&(this._cursorOriginalValue=i.style.cursor,i.style.cursor="pointer",this._cursorStyleIsSet=!0),this._isAttached=!0}}detach(){if(this._isAttached){let e=this._document.body;e.removeEventListener("pointerdown",this._pointerDownListener,!0),e.removeEventListener("click",this._clickListener,!0),e.removeEventListener("auxclick",this._clickListener,!0),e.removeEventListener("contextmenu",this._clickListener,!0),this._platform.IOS&&this._cursorStyleIsSet&&(e.style.cursor=this._cursorOriginalValue,this._cursorStyleIsSet=!1),this._isAttached=!1}}_addEventListeners(e){e.addEventListener("pointerdown",this._pointerDownListener,!0),e.addEventListener("click",this._clickListener,!0),e.addEventListener("auxclick",this._clickListener,!0),e.addEventListener("contextmenu",this._clickListener,!0)}}return n.\u0275fac=function(e){return new(e||n)(O(kt),O($n),O(at,8))},n.\u0275prov=pe({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),Of=(()=>{class n{constructor(e,i){this._platform=i,this._document=e}ngOnDestroy(){this._containerElement?.remove()}getContainerElement(){return this._containerElement||this._createContainer(),this._containerElement}_createContainer(){let e="cdk-overlay-container";if(this._platform.isBrowser||Vb()){let r=this._document.querySelectorAll(`.${e}[platform="server"], .${e}[platform="test"]`);for(let o=0;o<r.length;o++)r[o].remove()}let i=this._document.createElement("div");i.classList.add(e),Vb()?i.setAttribute("platform","test"):this._platform.isBrowser||i.setAttribute("platform","server"),this._document.body.appendChild(i),this._containerElement=i}}return n.\u0275fac=function(e){return new(e||n)(O(kt),O($n))},n.\u0275prov=pe({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),Ol=class{constructor(t,e,i,r,o,a,s,l,c,d=!1){this._portalOutlet=t,this._host=e,this._pane=i,this._config=r,this._ngZone=o,this._keyboardDispatcher=a,this._document=s,this._location=l,this._outsideClickDispatcher=c,this._animationsDisabled=d,this._backdropElement=null,this._backdropClick=new Ae,this._attachments=new Ae,this._detachments=new Ae,this._locationChanges=yn.EMPTY,this._backdropClickHandler=u=>this._backdropClick.next(u),this._backdropTransitionendHandler=u=>{this._disposeBackdrop(u.target)},this._keydownEvents=new Ae,this._outsidePointerEvents=new Ae,r.scrollStrategy&&(this._scrollStrategy=r.scrollStrategy,this._scrollStrategy.attach(this)),this._positionStrategy=r.positionStrategy}get overlayElement(){return this._pane}get backdropElement(){return this._backdropElement}get hostElement(){return this._host}attach(t){!this._host.parentElement&&this._previousHostParent&&this._previousHostParent.appendChild(this._host);let e=this._portalOutlet.attach(t);return this._positionStrategy&&this._positionStrategy.attach(this),this._updateStackingOrder(),this._updateElementSize(),this._updateElementDirection(),this._scrollStrategy&&this._scrollStrategy.enable(),this._ngZone.onStable.pipe(zt(1)).subscribe(()=>{this.hasAttached()&&this.updatePosition()}),this._togglePointerEvents(!0),this._config.hasBackdrop&&this._attachBackdrop(),this._config.panelClass&&this._toggleClasses(this._pane,this._config.panelClass,!0),this._attachments.next(),this._keyboardDispatcher.add(this),this._config.disposeOnNavigation&&(this._locationChanges=this._location.subscribe(()=>this.dispose())),this._outsideClickDispatcher.add(this),"function"==typeof e?.onDestroy&&e.onDestroy(()=>{this.hasAttached()&&this._ngZone.runOutsideAngular(()=>Promise.resolve().then(()=>this.detach()))}),e}detach(){if(!this.hasAttached())return;this.detachBackdrop(),this._togglePointerEvents(!1),this._positionStrategy&&this._positionStrategy.detach&&this._positionStrategy.detach(),this._scrollStrategy&&this._scrollStrategy.disable();let t=this._portalOutlet.detach();return this._detachments.next(),this._keyboardDispatcher.remove(this),this._detachContentWhenStable(),this._locationChanges.unsubscribe(),this._outsideClickDispatcher.remove(this),t}dispose(){let t=this.hasAttached();this._positionStrategy&&this._positionStrategy.dispose(),this._disposeScrollStrategy(),this._disposeBackdrop(this._backdropElement),this._locationChanges.unsubscribe(),this._keyboardDispatcher.remove(this),this._portalOutlet.dispose(),this._attachments.complete(),this._backdropClick.complete(),this._keydownEvents.complete(),this._outsidePointerEvents.complete(),this._outsideClickDispatcher.remove(this),this._host?.remove(),this._previousHostParent=this._pane=this._host=null,t&&this._detachments.next(),this._detachments.complete()}hasAttached(){return this._portalOutlet.hasAttached()}backdropClick(){return this._backdropClick}attachments(){return this._attachments}detachments(){return this._detachments}keydownEvents(){return this._keydownEvents}outsidePointerEvents(){return this._outsidePointerEvents}getConfig(){return this._config}updatePosition(){this._positionStrategy&&this._positionStrategy.apply()}updatePositionStrategy(t){t!==this._positionStrategy&&(this._positionStrategy&&this._positionStrategy.dispose(),this._positionStrategy=t,this.hasAttached()&&(t.attach(this),this.updatePosition()))}updateSize(t){this._config={...this._config,...t},this._updateElementSize()}setDirection(t){this._config={...this._config,direction:t},this._updateElementDirection()}addPanelClass(t){this._pane&&this._toggleClasses(this._pane,t,!0)}removePanelClass(t){this._pane&&this._toggleClasses(this._pane,t,!1)}getDirection(){let t=this._config.direction;return t?"string"==typeof t?t:t.value:"ltr"}updateScrollStrategy(t){t!==this._scrollStrategy&&(this._disposeScrollStrategy(),this._scrollStrategy=t,this.hasAttached()&&(t.attach(this),t.enable()))}_updateElementDirection(){this._host.setAttribute("dir",this.getDirection())}_updateElementSize(){if(!this._pane)return;let t=this._pane.style;t.width=Zr(this._config.width),t.height=Zr(this._config.height),t.minWidth=Zr(this._config.minWidth),t.minHeight=Zr(this._config.minHeight),t.maxWidth=Zr(this._config.maxWidth),t.maxHeight=Zr(this._config.maxHeight)}_togglePointerEvents(t){this._pane.style.pointerEvents=t?"":"none"}_attachBackdrop(){let t="cdk-overlay-backdrop-showing";this._backdropElement=this._document.createElement("div"),this._backdropElement.classList.add("cdk-overlay-backdrop"),this._animationsDisabled&&this._backdropElement.classList.add("cdk-overlay-backdrop-noop-animation"),this._config.backdropClass&&this._toggleClasses(this._backdropElement,this._config.backdropClass,!0),this._host.parentElement.insertBefore(this._backdropElement,this._host),this._backdropElement.addEventListener("click",this._backdropClickHandler),!this._animationsDisabled&&typeof requestAnimationFrame<"u"?this._ngZone.runOutsideAngular(()=>{requestAnimationFrame(()=>{this._backdropElement&&this._backdropElement.classList.add(t)})}):this._backdropElement.classList.add(t)}_updateStackingOrder(){this._host.nextSibling&&this._host.parentNode.appendChild(this._host)}detachBackdrop(){let t=this._backdropElement;if(t){if(this._animationsDisabled)return void this._disposeBackdrop(t);t.classList.remove("cdk-overlay-backdrop-showing"),this._ngZone.runOutsideAngular(()=>{t.addEventListener("transitionend",this._backdropTransitionendHandler)}),t.style.pointerEvents="none",this._backdropTimeout=this._ngZone.runOutsideAngular(()=>setTimeout(()=>{this._disposeBackdrop(t)},500))}}_toggleClasses(t,e,i){let r=ug(e||[]).filter(o=>!!o);r.length&&(i?t.classList.add(...r):t.classList.remove(...r))}_detachContentWhenStable(){this._ngZone.runOutsideAngular(()=>{let t=this._ngZone.onStable.pipe(ot(cn(this._attachments,this._detachments))).subscribe(()=>{(!this._pane||!this._host||0===this._pane.children.length)&&(this._pane&&this._config.panelClass&&this._toggleClasses(this._pane,this._config.panelClass,!1),this._host&&this._host.parentElement&&(this._previousHostParent=this._host.parentElement,this._host.remove()),t.unsubscribe())})})}_disposeScrollStrategy(){let t=this._scrollStrategy;t&&(t.disable(),t.detach&&t.detach())}_disposeBackdrop(t){t&&(t.removeEventListener("click",this._backdropClickHandler),t.removeEventListener("transitionend",this._backdropTransitionendHandler),t.remove(),this._backdropElement===t&&(this._backdropElement=null)),this._backdropTimeout&&(clearTimeout(this._backdropTimeout),this._backdropTimeout=void 0)}},e9="cdk-overlay-connected-position-bounding-box",z_e=/([A-Za-z%]+)$/;function kf(n,t){for(let e in t)t.hasOwnProperty(e)&&(n[e]=t[e]);return n}function t9(n){if("number"!=typeof n&&null!=n){let[t,e]=n.split(z_e);return e&&"px"!==e?null:parseFloat(t)}return n||null}function n9(n){return{top:Math.floor(n.top),right:Math.floor(n.right),bottom:Math.floor(n.bottom),left:Math.floor(n.left),width:Math.floor(n.width),height:Math.floor(n.height)}}var i9="cdk-global-overlay-wrapper",U_e=(()=>{class n{constructor(e,i,r,o){this._viewportRuler=e,this._document=i,this._platform=r,this._overlayContainer=o}global(){return new class{constructor(){this._cssPosition="static",this._topOffset="",this._bottomOffset="",this._alignItems="",this._xPosition="",this._xOffset="",this._width="",this._height="",this._isDisposed=!1}attach(t){let e=t.getConfig();this._overlayRef=t,this._width&&!e.width&&t.updateSize({width:this._width}),this._height&&!e.height&&t.updateSize({height:this._height}),t.hostElement.classList.add(i9),this._isDisposed=!1}top(t=""){return this._bottomOffset="",this._topOffset=t,this._alignItems="flex-start",this}left(t=""){return this._xOffset=t,this._xPosition="left",this}bottom(t=""){return this._topOffset="",this._bottomOffset=t,this._alignItems="flex-end",this}right(t=""){return this._xOffset=t,this._xPosition="right",this}start(t=""){return this._xOffset=t,this._xPosition="start",this}end(t=""){return this._xOffset=t,this._xPosition="end",this}width(t=""){return this._overlayRef?this._overlayRef.updateSize({width:t}):this._width=t,this}height(t=""){return this._overlayRef?this._overlayRef.updateSize({height:t}):this._height=t,this}centerHorizontally(t=""){return this.left(t),this._xPosition="center",this}centerVertically(t=""){return this.top(t),this._alignItems="center",this}apply(){if(!this._overlayRef||!this._overlayRef.hasAttached())return;let t=this._overlayRef.overlayElement.style,e=this._overlayRef.hostElement.style,i=this._overlayRef.getConfig(),{width:r,height:o,maxWidth:a,maxHeight:s}=i,l=!("100%"!==r&&"100vw"!==r||a&&"100%"!==a&&"100vw"!==a),c=!("100%"!==o&&"100vh"!==o||s&&"100%"!==s&&"100vh"!==s),d=this._xPosition,u=this._xOffset,p="rtl"===this._overlayRef.getConfig().direction,f="",m="",y="";l?y="flex-start":"center"===d?(y="center",p?m=u:f=u):p?"left"===d||"end"===d?(y="flex-end",f=u):("right"===d||"start"===d)&&(y="flex-start",m=u):"left"===d||"start"===d?(y="flex-start",f=u):("right"===d||"end"===d)&&(y="flex-end",m=u),t.position=this._cssPosition,t.marginLeft=l?"0":f,t.marginTop=c?"0":this._topOffset,t.marginBottom=this._bottomOffset,t.marginRight=l?"0":m,e.justifyContent=y,e.alignItems=c?"flex-start":this._alignItems}dispose(){if(this._isDisposed||!this._overlayRef)return;let t=this._overlayRef.overlayElement.style,e=this._overlayRef.hostElement,i=e.style;e.classList.remove(i9),i.justifyContent=i.alignItems=t.marginTop=t.marginBottom=t.marginLeft=t.marginRight=t.position="",this._overlayRef=null,this._isDisposed=!0}}}flexibleConnectedTo(e){return new class{get positions(){return this._preferredPositions}constructor(t,e,i,r,o){this._viewportRuler=e,this._document=i,this._platform=r,this._overlayContainer=o,this._lastBoundingBoxSize={width:0,height:0},this._isPushed=!1,this._canPush=!0,this._growAfterOpen=!1,this._hasFlexibleDimensions=!0,this._positionLocked=!1,this._viewportMargin=0,this._scrollables=[],this._preferredPositions=[],this._positionChanges=new Ae,this._resizeSubscription=yn.EMPTY,this._offsetX=0,this._offsetY=0,this._appliedPanelClasses=[],this.positionChanges=this._positionChanges,this.setOrigin(t)}attach(t){this._validatePositions(),t.hostElement.classList.add(e9),this._overlayRef=t,this._boundingBox=t.hostElement,this._pane=t.overlayElement,this._isDisposed=!1,this._isInitialRender=!0,this._lastPosition=null,this._resizeSubscription.unsubscribe(),this._resizeSubscription=this._viewportRuler.change().subscribe(()=>{this._isInitialRender=!0,this.apply()})}apply(){if(this._isDisposed||!this._platform.isBrowser)return;if(!this._isInitialRender&&this._positionLocked&&this._lastPosition)return void this.reapplyLastPosition();this._clearPanelClasses(),this._resetOverlayElementStyles(),this._resetBoundingBoxStyles(),this._viewportRect=this._getNarrowedViewportRect(),this._originRect=this._getOriginRect(),this._overlayRect=this._pane.getBoundingClientRect(),this._containerRect=this._overlayContainer.getContainerElement().getBoundingClientRect();let a,t=this._originRect,e=this._overlayRect,i=this._viewportRect,r=this._containerRect,o=[];for(let s of this._preferredPositions){let l=this._getOriginPoint(t,r,s),c=this._getOverlayPoint(l,e,s),d=this._getOverlayFit(c,e,i,s);if(d.isCompletelyWithinViewport)return this._isPushed=!1,void this._applyPosition(s,l);this._canFitWithFlexibleDimensions(d,c,i)?o.push({position:s,origin:l,overlayRect:e,boundingBoxRect:this._calculateBoundingBoxRect(l,s)}):(!a||a.overlayFit.visibleArea<d.visibleArea)&&(a={overlayFit:d,overlayPoint:c,originPoint:l,position:s,overlayRect:e})}if(o.length){let s=null,l=-1;for(let c of o){let d=c.boundingBoxRect.width*c.boundingBoxRect.height*(c.position.weight||1);d>l&&(l=d,s=c)}return this._isPushed=!1,void this._applyPosition(s.position,s.origin)}if(this._canPush)return this._isPushed=!0,void this._applyPosition(a.position,a.originPoint);this._applyPosition(a.position,a.originPoint)}detach(){this._clearPanelClasses(),this._lastPosition=null,this._previousPushAmount=null,this._resizeSubscription.unsubscribe()}dispose(){this._isDisposed||(this._boundingBox&&kf(this._boundingBox.style,{top:"",left:"",right:"",bottom:"",height:"",width:"",alignItems:"",justifyContent:""}),this._pane&&this._resetOverlayElementStyles(),this._overlayRef&&this._overlayRef.hostElement.classList.remove(e9),this.detach(),this._positionChanges.complete(),this._overlayRef=this._boundingBox=null,this._isDisposed=!0)}reapplyLastPosition(){if(this._isDisposed||!this._platform.isBrowser)return;let t=this._lastPosition;if(t){this._originRect=this._getOriginRect(),this._overlayRect=this._pane.getBoundingClientRect(),this._viewportRect=this._getNarrowedViewportRect(),this._containerRect=this._overlayContainer.getContainerElement().getBoundingClientRect();let e=this._getOriginPoint(this._originRect,this._containerRect,t);this._applyPosition(t,e)}else this.apply()}withScrollableContainers(t){return this._scrollables=t,this}withPositions(t){return this._preferredPositions=t,-1===t.indexOf(this._lastPosition)&&(this._lastPosition=null),this._validatePositions(),this}withViewportMargin(t){return this._viewportMargin=t,this}withFlexibleDimensions(t=!0){return this._hasFlexibleDimensions=t,this}withGrowAfterOpen(t=!0){return this._growAfterOpen=t,this}withPush(t=!0){return this._canPush=t,this}withLockedPosition(t=!0){return this._positionLocked=t,this}setOrigin(t){return this._origin=t,this}withDefaultOffsetX(t){return this._offsetX=t,this}withDefaultOffsetY(t){return this._offsetY=t,this}withTransformOriginOn(t){return this._transformOriginSelector=t,this}_getOriginPoint(t,e,i){let r,o;if("center"==i.originX)r=t.left+t.width/2;else{let a=this._isRtl()?t.right:t.left,s=this._isRtl()?t.left:t.right;r="start"==i.originX?a:s}return e.left<0&&(r-=e.left),o="center"==i.originY?t.top+t.height/2:"top"==i.originY?t.top:t.bottom,e.top<0&&(o-=e.top),{x:r,y:o}}_getOverlayPoint(t,e,i){let r,o;return r="center"==i.overlayX?-e.width/2:"start"===i.overlayX?this._isRtl()?-e.width:0:this._isRtl()?0:-e.width,o="center"==i.overlayY?-e.height/2:"top"==i.overlayY?0:-e.height,{x:t.x+r,y:t.y+o}}_getOverlayFit(t,e,i,r){let o=n9(e),{x:a,y:s}=t,l=this._getOffset(r,"x"),c=this._getOffset(r,"y");l&&(a+=l),c&&(s+=c);let p=0-s,f=s+o.height-i.height,m=this._subtractOverflows(o.width,0-a,a+o.width-i.width),y=this._subtractOverflows(o.height,p,f),M=m*y;return{visibleArea:M,isCompletelyWithinViewport:o.width*o.height===M,fitsInViewportVertically:y===o.height,fitsInViewportHorizontally:m==o.width}}_canFitWithFlexibleDimensions(t,e,i){if(this._hasFlexibleDimensions){let r=i.bottom-e.y,o=i.right-e.x,a=t9(this._overlayRef.getConfig().minHeight),s=t9(this._overlayRef.getConfig().minWidth);return(t.fitsInViewportVertically||null!=a&&a<=r)&&(t.fitsInViewportHorizontally||null!=s&&s<=o)}return!1}_pushOverlayOnScreen(t,e,i){if(this._previousPushAmount&&this._positionLocked)return{x:t.x+this._previousPushAmount.x,y:t.y+this._previousPushAmount.y};let r=n9(e),o=this._viewportRect,a=Math.max(t.x+r.width-o.width,0),s=Math.max(t.y+r.height-o.height,0),l=Math.max(o.top-i.top-t.y,0),c=Math.max(o.left-i.left-t.x,0),d=0,u=0;return d=r.width<=o.width?c||-a:t.x<this._viewportMargin?o.left-i.left-t.x:0,u=r.height<=o.height?l||-s:t.y<this._viewportMargin?o.top-i.top-t.y:0,this._previousPushAmount={x:d,y:u},{x:t.x+d,y:t.y+u}}_applyPosition(t,e){if(this._setTransformOrigin(t),this._setOverlayElementStyles(e,t),this._setBoundingBoxStyles(e,t),t.panelClass&&this._addPanelClasses(t.panelClass),this._lastPosition=t,this._positionChanges.observers.length){let i=this._getScrollVisibility(),r=new class{constructor(t,e){this.connectionPair=t,this.scrollableViewProperties=e}}(t,i);this._positionChanges.next(r)}this._isInitialRender=!1}_setTransformOrigin(t){if(!this._transformOriginSelector)return;let i,e=this._boundingBox.querySelectorAll(this._transformOriginSelector),r=t.overlayY;i="center"===t.overlayX?"center":this._isRtl()?"start"===t.overlayX?"right":"left":"start"===t.overlayX?"left":"right";for(let o=0;o<e.length;o++)e[o].style.transformOrigin=`${i} ${r}`}_calculateBoundingBoxRect(t,e){let o,a,s,d,u,p,i=this._viewportRect,r=this._isRtl();if("top"===e.overlayY)a=t.y,o=i.height-a+this._viewportMargin;else if("bottom"===e.overlayY)s=i.height-t.y+2*this._viewportMargin,o=i.height-s+this._viewportMargin;else{let f=Math.min(i.bottom-t.y+i.top,t.y),m=this._lastBoundingBoxSize.height;o=2*f,a=t.y-f,o>m&&!this._isInitialRender&&!this._growAfterOpen&&(a=t.y-m/2)}if("end"===e.overlayX&&!r||"start"===e.overlayX&&r)p=i.width-t.x+this._viewportMargin,d=t.x-this._viewportMargin;else if("start"===e.overlayX&&!r||"end"===e.overlayX&&r)u=t.x,d=i.right-t.x;else{let f=Math.min(i.right-t.x+i.left,t.x),m=this._lastBoundingBoxSize.width;d=2*f,u=t.x-f,d>m&&!this._isInitialRender&&!this._growAfterOpen&&(u=t.x-m/2)}return{top:a,left:u,bottom:s,right:p,width:d,height:o}}_setBoundingBoxStyles(t,e){let i=this._calculateBoundingBoxRect(t,e);!this._isInitialRender&&!this._growAfterOpen&&(i.height=Math.min(i.height,this._lastBoundingBoxSize.height),i.width=Math.min(i.width,this._lastBoundingBoxSize.width));let r={};if(this._hasExactPosition())r.top=r.left="0",r.bottom=r.right=r.maxHeight=r.maxWidth="",r.width=r.height="100%";else{let o=this._overlayRef.getConfig().maxHeight,a=this._overlayRef.getConfig().maxWidth;r.height=Zr(i.height),r.top=Zr(i.top),r.bottom=Zr(i.bottom),r.width=Zr(i.width),r.left=Zr(i.left),r.right=Zr(i.right),r.alignItems="center"===e.overlayX?"center":"end"===e.overlayX?"flex-end":"flex-start",r.justifyContent="center"===e.overlayY?"center":"bottom"===e.overlayY?"flex-end":"flex-start",o&&(r.maxHeight=Zr(o)),a&&(r.maxWidth=Zr(a))}this._lastBoundingBoxSize=i,kf(this._boundingBox.style,r)}_resetBoundingBoxStyles(){kf(this._boundingBox.style,{top:"0",left:"0",right:"0",bottom:"0",height:"",width:"",alignItems:"",justifyContent:""})}_resetOverlayElementStyles(){kf(this._pane.style,{top:"",left:"",bottom:"",right:"",position:"",transform:""})}_setOverlayElementStyles(t,e){let i={},r=this._hasExactPosition(),o=this._hasFlexibleDimensions,a=this._overlayRef.getConfig();if(r){let d=this._viewportRuler.getViewportScrollPosition();kf(i,this._getExactOverlayY(e,t,d)),kf(i,this._getExactOverlayX(e,t,d))}else i.position="static";let s="",l=this._getOffset(e,"x"),c=this._getOffset(e,"y");l&&(s+=`translateX(${l}px) `),c&&(s+=`translateY(${c}px)`),i.transform=s.trim(),a.maxHeight&&(r?i.maxHeight=Zr(a.maxHeight):o&&(i.maxHeight="")),a.maxWidth&&(r?i.maxWidth=Zr(a.maxWidth):o&&(i.maxWidth="")),kf(this._pane.style,i)}_getExactOverlayY(t,e,i){let r={top:"",bottom:""},o=this._getOverlayPoint(e,this._overlayRect,t);return this._isPushed&&(o=this._pushOverlayOnScreen(o,this._overlayRect,i)),"bottom"===t.overlayY?r.bottom=this._document.documentElement.clientHeight-(o.y+this._overlayRect.height)+"px":r.top=Zr(o.y),r}_getExactOverlayX(t,e,i){let a,r={left:"",right:""},o=this._getOverlayPoint(e,this._overlayRect,t);return this._isPushed&&(o=this._pushOverlayOnScreen(o,this._overlayRect,i)),a=this._isRtl()?"end"===t.overlayX?"left":"right":"end"===t.overlayX?"right":"left","right"===a?r.right=this._document.documentElement.clientWidth-(o.x+this._overlayRect.width)+"px":r.left=Zr(o.x),r}_getScrollVisibility(){let t=this._getOriginRect(),e=this._pane.getBoundingClientRect(),i=this._scrollables.map(r=>r.getElementRef().nativeElement.getBoundingClientRect());return{isOriginClipped:$7(t,i),isOriginOutsideView:O2(t,i),isOverlayClipped:$7(e,i),isOverlayOutsideView:O2(e,i)}}_subtractOverflows(t,...e){return e.reduce((i,r)=>i-Math.max(r,0),t)}_getNarrowedViewportRect(){let t=this._document.documentElement.clientWidth,e=this._document.documentElement.clientHeight,i=this._viewportRuler.getViewportScrollPosition();return{top:i.top+this._viewportMargin,left:i.left+this._viewportMargin,right:i.left+t-this._viewportMargin,bottom:i.top+e-this._viewportMargin,width:t-2*this._viewportMargin,height:e-2*this._viewportMargin}}_isRtl(){return"rtl"===this._overlayRef.getDirection()}_hasExactPosition(){return!this._hasFlexibleDimensions||this._isPushed}_getOffset(t,e){return"x"===e?null==t.offsetX?this._offsetX:t.offsetX:null==t.offsetY?this._offsetY:t.offsetY}_validatePositions(){}_addPanelClasses(t){this._pane&&ug(t).forEach(e=>{""!==e&&-1===this._appliedPanelClasses.indexOf(e)&&(this._appliedPanelClasses.push(e),this._pane.classList.add(e))})}_clearPanelClasses(){this._pane&&(this._appliedPanelClasses.forEach(t=>{this._pane.classList.remove(t)}),this._appliedPanelClasses=[])}_getOriginRect(){let t=this._origin;if(t instanceof be)return t.nativeElement.getBoundingClientRect();if(t instanceof Element)return t.getBoundingClientRect();let e=t.width||0,i=t.height||0;return{top:t.y,bottom:t.y+i,left:t.x,right:t.x+e,height:i,width:e}}}(e,this._viewportRuler,this._document,this._platform,this._overlayContainer)}}return n.\u0275fac=function(e){return new(e||n)(O(Ko),O(kt),O($n),O(Of))},n.\u0275prov=pe({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),j_e=0,Oi=(()=>{class n{constructor(e,i,r,o,a,s,l,c,d,u,p,f){this.scrollStrategies=e,this._overlayContainer=i,this._componentFactoryResolver=r,this._positionBuilder=o,this._keyboardDispatcher=a,this._injector=s,this._ngZone=l,this._document=c,this._directionality=d,this._location=u,this._outsideClickDispatcher=p,this._animationsModuleType=f}create(e){let i=this._createHostElement(),r=this._createPaneElement(i),o=this._createPortalOutlet(r),a=new Ws(e);return a.direction=a.direction||this._directionality.value,new Ol(o,i,r,a,this._ngZone,this._keyboardDispatcher,this._document,this._location,this._outsideClickDispatcher,"NoopAnimations"===this._animationsModuleType)}position(){return this._positionBuilder}_createPaneElement(e){let i=this._document.createElement("div");return i.id="cdk-overlay-"+j_e++,i.classList.add("cdk-overlay-pane"),e.appendChild(i),i}_createHostElement(){let e=this._document.createElement("div");return this._overlayContainer.getContainerElement().appendChild(e),e}_createPortalOutlet(e){return this._appRef||(this._appRef=this._injector.get(gc)),new Xb(e,this._componentFactoryResolver,this._appRef,this._injector,this._document)}}return n.\u0275fac=function(e){return new(e||n)(O(B_e),O(Of),O(Qr),O(U_e),O(V_e),O(bi),O(at),O(kt),O(Hi),O(Fy),O(H_e),O(di,8))},n.\u0275prov=pe({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),G_e=[{originX:"start",originY:"bottom",overlayX:"start",overlayY:"top"},{originX:"start",originY:"top",overlayX:"start",overlayY:"bottom"},{originX:"end",originY:"top",overlayX:"end",overlayY:"bottom"},{originX:"end",originY:"bottom",overlayX:"end",overlayY:"top"}],o9=new ie("cdk-connected-overlay-scroll-strategy"),Hu=(()=>{class n{constructor(e){this.elementRef=e}}return n.\u0275fac=function(e){return new(e||n)(C(be))},n.\u0275dir=xe({type:n,selectors:[["","cdk-overlay-origin",""],["","overlay-origin",""],["","cdkOverlayOrigin",""]],exportAs:["cdkOverlayOrigin"],standalone:!0}),n})(),zu=(()=>{class n{get offsetX(){return this._offsetX}set offsetX(e){this._offsetX=e,this._position&&this._updatePositionStrategy(this._position)}get offsetY(){return this._offsetY}set offsetY(e){this._offsetY=e,this._position&&this._updatePositionStrategy(this._position)}get hasBackdrop(){return this._hasBackdrop}set hasBackdrop(e){this._hasBackdrop=Ut(e)}get lockPosition(){return this._lockPosition}set lockPosition(e){this._lockPosition=Ut(e)}get flexibleDimensions(){return this._flexibleDimensions}set flexibleDimensions(e){this._flexibleDimensions=Ut(e)}get growAfterOpen(){return this._growAfterOpen}set growAfterOpen(e){this._growAfterOpen=Ut(e)}get push(){return this._push}set push(e){this._push=Ut(e)}constructor(e,i,r,o,a){this._overlay=e,this._dir=a,this._hasBackdrop=!1,this._lockPosition=!1,this._growAfterOpen=!1,this._flexibleDimensions=!1,this._push=!1,this._backdropSubscription=yn.EMPTY,this._attachSubscription=yn.EMPTY,this._detachSubscription=yn.EMPTY,this._positionSubscription=yn.EMPTY,this.viewportMargin=0,this.open=!1,this.disableClose=!1,this.backdropClick=new L,this.positionChange=new L,this.attach=new L,this.detach=new L,this.overlayKeydown=new L,this.overlayOutsideClick=new L,this._templatePortal=new Jo(i,r),this._scrollStrategyFactory=o,this.scrollStrategy=this._scrollStrategyFactory()}get overlayRef(){return this._overlayRef}get dir(){return this._dir?this._dir.value:"ltr"}ngOnDestroy(){this._attachSubscription.unsubscribe(),this._detachSubscription.unsubscribe(),this._backdropSubscription.unsubscribe(),this._positionSubscription.unsubscribe(),this._overlayRef&&this._overlayRef.dispose()}ngOnChanges(e){this._position&&(this._updatePositionStrategy(this._position),this._overlayRef.updateSize({width:this.width,minWidth:this.minWidth,height:this.height,minHeight:this.minHeight}),e.origin&&this.open&&this._position.apply()),e.open&&(this.open?this._attachOverlay():this._detachOverlay())}_createOverlay(){(!this.positions||!this.positions.length)&&(this.positions=G_e);let e=this._overlayRef=this._overlay.create(this._buildConfig());this._attachSubscription=e.attachments().subscribe(()=>this.attach.emit()),this._detachSubscription=e.detachments().subscribe(()=>this.detach.emit()),e.keydownEvents().subscribe(i=>{this.overlayKeydown.next(i),27===i.keyCode&&!this.disableClose&&!yr(i)&&(i.preventDefault(),this._detachOverlay())}),this._overlayRef.outsidePointerEvents().subscribe(i=>{this.overlayOutsideClick.next(i)})}_buildConfig(){let e=this._position=this.positionStrategy||this._createPositionStrategy(),i=new Ws({direction:this._dir,positionStrategy:e,scrollStrategy:this.scrollStrategy,hasBackdrop:this.hasBackdrop});return(this.width||0===this.width)&&(i.width=this.width),(this.height||0===this.height)&&(i.height=this.height),(this.minWidth||0===this.minWidth)&&(i.minWidth=this.minWidth),(this.minHeight||0===this.minHeight)&&(i.minHeight=this.minHeight),this.backdropClass&&(i.backdropClass=this.backdropClass),this.panelClass&&(i.panelClass=this.panelClass),i}_updatePositionStrategy(e){let i=this.positions.map(r=>({originX:r.originX,originY:r.originY,overlayX:r.overlayX,overlayY:r.overlayY,offsetX:r.offsetX||this.offsetX,offsetY:r.offsetY||this.offsetY,panelClass:r.panelClass||void 0}));return e.setOrigin(this._getFlexibleConnectedPositionStrategyOrigin()).withPositions(i).withFlexibleDimensions(this.flexibleDimensions).withPush(this.push).withGrowAfterOpen(this.growAfterOpen).withViewportMargin(this.viewportMargin).withLockedPosition(this.lockPosition).withTransformOriginOn(this.transformOriginSelector)}_createPositionStrategy(){let e=this._overlay.position().flexibleConnectedTo(this._getFlexibleConnectedPositionStrategyOrigin());return this._updatePositionStrategy(e),e}_getFlexibleConnectedPositionStrategyOrigin(){return this.origin instanceof Hu?this.origin.elementRef:this.origin}_attachOverlay(){this._overlayRef?this._overlayRef.getConfig().hasBackdrop=this.hasBackdrop:this._createOverlay(),this._overlayRef.hasAttached()||this._overlayRef.attach(this._templatePortal),this.hasBackdrop?this._backdropSubscription=this._overlayRef.backdropClick().subscribe(e=>{this.backdropClick.emit(e)}):this._backdropSubscription.unsubscribe(),this._positionSubscription.unsubscribe(),this.positionChange.observers.length>0&&(this._positionSubscription=this._position.positionChanges.pipe(U_(()=>this.positionChange.observers.length>0)).subscribe(e=>{this.positionChange.emit(e),0===this.positionChange.observers.length&&this._positionSubscription.unsubscribe()}))}_detachOverlay(){this._overlayRef&&this._overlayRef.detach(),this._backdropSubscription.unsubscribe(),this._positionSubscription.unsubscribe()}}return n.\u0275fac=function(e){return new(e||n)(C(Oi),C(Si),C(Zn),C(o9),C(Hi,8))},n.\u0275dir=xe({type:n,selectors:[["","cdk-connected-overlay",""],["","connected-overlay",""],["","cdkConnectedOverlay",""]],inputs:{origin:["cdkConnectedOverlayOrigin","origin"],positions:["cdkConnectedOverlayPositions","positions"],positionStrategy:["cdkConnectedOverlayPositionStrategy","positionStrategy"],offsetX:["cdkConnectedOverlayOffsetX","offsetX"],offsetY:["cdkConnectedOverlayOffsetY","offsetY"],width:["cdkConnectedOverlayWidth","width"],height:["cdkConnectedOverlayHeight","height"],minWidth:["cdkConnectedOverlayMinWidth","minWidth"],minHeight:["cdkConnectedOverlayMinHeight","minHeight"],backdropClass:["cdkConnectedOverlayBackdropClass","backdropClass"],panelClass:["cdkConnectedOverlayPanelClass","panelClass"],viewportMargin:["cdkConnectedOverlayViewportMargin","viewportMargin"],scrollStrategy:["cdkConnectedOverlayScrollStrategy","scrollStrategy"],open:["cdkConnectedOverlayOpen","open"],disableClose:["cdkConnectedOverlayDisableClose","disableClose"],transformOriginSelector:["cdkConnectedOverlayTransformOriginOn","transformOriginSelector"],hasBackdrop:["cdkConnectedOverlayHasBackdrop","hasBackdrop"],lockPosition:["cdkConnectedOverlayLockPosition","lockPosition"],flexibleDimensions:["cdkConnectedOverlayFlexibleDimensions","flexibleDimensions"],growAfterOpen:["cdkConnectedOverlayGrowAfterOpen","growAfterOpen"],push:["cdkConnectedOverlayPush","push"]},outputs:{backdropClick:"backdropClick",positionChange:"positionChange",attach:"attach",detach:"detach",overlayKeydown:"overlayKeydown",overlayOutsideClick:"overlayOutsideClick"},exportAs:["cdkConnectedOverlay"],standalone:!0,features:[Gt]}),n})(),q_e={provide:o9,deps:[Oi],useFactory:function(n){return()=>n.scrollStrategies.reposition()}},Lr=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({providers:[Oi,q_e],imports:[Nu,us,Md,Md]}),n})(),Y_e=Math.pow(2,31)-1,wd=class{constructor(t,e){this._overlayRef=e,this._afterDismissed=new Ae,this._afterOpened=new Ae,this._onAction=new Ae,this._dismissedByAction=!1,this.containerInstance=t,t._onExit.subscribe(()=>this._finishDismiss())}dismiss(){this._afterDismissed.closed||this.containerInstance.exit(),clearTimeout(this._durationTimeoutId)}dismissWithAction(){this._onAction.closed||(this._dismissedByAction=!0,this._onAction.next(),this._onAction.complete(),this.dismiss()),clearTimeout(this._durationTimeoutId)}closeWithAction(){this.dismissWithAction()}_dismissAfter(t){this._durationTimeoutId=setTimeout(()=>this.dismiss(),Math.min(t,Y_e))}_open(){this._afterOpened.closed||(this._afterOpened.next(),this._afterOpened.complete())}_finishDismiss(){this._overlayRef.dispose(),this._onAction.closed||this._onAction.complete(),this._afterDismissed.next({dismissedByAction:this._dismissedByAction}),this._afterDismissed.complete(),this._dismissedByAction=!1}afterDismissed(){return this._afterDismissed}afterOpened(){return this.containerInstance._onEnter}onAction(){return this._onAction}},Mg=new ie("MatSnackBarData"),Ff=class{constructor(){this.politeness="assertive",this.announcementMessage="",this.duration=0,this.data=null,this.horizontalPosition="center",this.verticalPosition="bottom"}},B2={snackBarState:ji("state",[Jn("void, hidden",Bt({transform:"scale(0.8)",opacity:0})),Jn("visible",Bt({transform:"scale(1)",opacity:1})),Wn("* => visible",Kn("150ms cubic-bezier(0, 0, 0.2, 1)")),Wn("* => void, * => hidden",Kn("75ms cubic-bezier(0.4, 0.0, 1, 1)",Bt({opacity:0})))])},X_e=0,V2=(()=>{class n extends Vu{constructor(e,i,r,o,a){super(),this._ngZone=e,this._elementRef=i,this._changeDetectorRef=r,this._platform=o,this.snackBarConfig=a,this._document=pi(kt),this._trackedModals=new Set,this._announceDelay=150,this._destroyed=!1,this._onAnnounce=new Ae,this._onExit=new Ae,this._onEnter=new Ae,this._animationState="void",this._liveElementId="mat-snack-bar-container-live-"+X_e++,this.attachDomPortal=s=>{this._assertNotAttached();let l=this._portalOutlet.attachDomPortal(s);return this._afterPortalAttached(),l},this._live="assertive"!==a.politeness||a.announcementMessage?"off"===a.politeness?"off":"polite":"assertive",this._platform.FIREFOX&&("polite"===this._live&&(this._role="status"),"assertive"===this._live&&(this._role="alert"))}attachComponentPortal(e){this._assertNotAttached();let i=this._portalOutlet.attachComponentPortal(e);return this._afterPortalAttached(),i}attachTemplatePortal(e){this._assertNotAttached();let i=this._portalOutlet.attachTemplatePortal(e);return this._afterPortalAttached(),i}onAnimationEnd(e){let{fromState:i,toState:r}=e;if(("void"===r&&"void"!==i||"hidden"===r)&&this._completeExit(),"visible"===r){let o=this._onEnter;this._ngZone.run(()=>{o.next(),o.complete()})}}enter(){this._destroyed||(this._animationState="visible",this._changeDetectorRef.detectChanges(),this._screenReaderAnnounce())}exit(){return this._ngZone.run(()=>{this._animationState="hidden",this._elementRef.nativeElement.setAttribute("mat-exit",""),clearTimeout(this._announceTimeoutId)}),this._onExit}ngOnDestroy(){this._destroyed=!0,this._clearFromModals(),this._completeExit()}_completeExit(){this._ngZone.onMicrotaskEmpty.pipe(zt(1)).subscribe(()=>{this._ngZone.run(()=>{this._onExit.next(),this._onExit.complete()})})}_afterPortalAttached(){let e=this._elementRef.nativeElement,i=this.snackBarConfig.panelClass;i&&(Array.isArray(i)?i.forEach(r=>e.classList.add(r)):e.classList.add(i)),this._exposeToModals()}_exposeToModals(){let e=this._liveElementId,i=this._document.querySelectorAll('body > .cdk-overlay-container [aria-modal="true"]');for(let r=0;r<i.length;r++){let o=i[r],a=o.getAttribute("aria-owns");this._trackedModals.add(o),a?-1===a.indexOf(e)&&o.setAttribute("aria-owns",a+" "+e):o.setAttribute("aria-owns",e)}}_clearFromModals(){this._trackedModals.forEach(e=>{let i=e.getAttribute("aria-owns");if(i){let r=i.replace(this._liveElementId,"").trim();r.length>0?e.setAttribute("aria-owns",r):e.removeAttribute("aria-owns")}}),this._trackedModals.clear()}_assertNotAttached(){this._portalOutlet.hasAttached()}_screenReaderAnnounce(){this._announceTimeoutId||this._ngZone.runOutsideAngular(()=>{this._announceTimeoutId=setTimeout(()=>{let e=this._elementRef.nativeElement.querySelector("[aria-hidden]"),i=this._elementRef.nativeElement.querySelector("[aria-live]");if(e&&i){let r=null;this._platform.isBrowser&&document.activeElement instanceof HTMLElement&&e.contains(document.activeElement)&&(r=document.activeElement),e.removeAttribute("aria-hidden"),i.appendChild(e),r?.focus(),this._onAnnounce.next(),this._onAnnounce.complete()}},this._announceDelay)})}}return n.\u0275fac=function(e){return new(e||n)(C(at),C(be),C(Ft),C($n),C(Ff))},n.\u0275dir=xe({type:n,viewQuery:function(e,i){if(1&e&&Ye(No,7),2&e){let r;we(r=Se())&&(i._portalOutlet=r.first)}},features:[Le]}),n})(),Y1=new ie("mat-snack-bar-default-options",{providedIn:"root",factory:function(){return new Ff}}),H2=(()=>{class n{get _openedSnackBarRef(){let e=this._parentSnackBar;return e?e._openedSnackBarRef:this._snackBarRefAtThisLevel}set _openedSnackBarRef(e){this._parentSnackBar?this._parentSnackBar._openedSnackBarRef=e:this._snackBarRefAtThisLevel=e}constructor(e,i,r,o,a,s){this._overlay=e,this._live=i,this._injector=r,this._breakpointObserver=o,this._parentSnackBar=a,this._defaultConfig=s,this._snackBarRefAtThisLevel=null}openFromComponent(e,i){return this._attach(e,i)}openFromTemplate(e,i){return this._attach(e,i)}open(e,i="",r){let o={...this._defaultConfig,...r};return o.data={message:e,action:i},o.announcementMessage===e&&(o.announcementMessage=void 0),this.openFromComponent(this.simpleSnackBarComponent,o)}dismiss(){this._openedSnackBarRef&&this._openedSnackBarRef.dismiss()}ngOnDestroy(){this._snackBarRefAtThisLevel&&this._snackBarRefAtThisLevel.dismiss()}_attachSnackBarContainer(e,i){let o=bi.create({parent:i&&i.viewContainerRef&&i.viewContainerRef.injector||this._injector,providers:[{provide:Ff,useValue:i}]}),a=new Pl(this.snackBarContainerComponent,i.viewContainerRef,o),s=e.attach(a);return s.instance.snackBarConfig=i,s.instance}_attach(e,i){let r={...new Ff,...this._defaultConfig,...i},o=this._createOverlay(r),a=this._attachSnackBarContainer(o,r),s=new wd(a,o);if(e instanceof Si){let l=new Jo(e,null,{$implicit:r.data,snackBarRef:s});s.instance=a.attachTemplatePortal(l)}else{let l=this._createInjector(r,s),c=new Pl(e,void 0,l),d=a.attachComponentPortal(c);s.instance=d.instance}return this._breakpointObserver.observe("(max-width: 599.98px) and (orientation: portrait)").pipe(ot(o.detachments())).subscribe(l=>{o.overlayElement.classList.toggle(this.handsetCssClass,l.matches)}),r.announcementMessage&&a._onAnnounce.subscribe(()=>{this._live.announce(r.announcementMessage,r.politeness)}),this._animateSnackBar(s,r),this._openedSnackBarRef=s,this._openedSnackBarRef}_animateSnackBar(e,i){e.afterDismissed().subscribe(()=>{this._openedSnackBarRef==e&&(this._openedSnackBarRef=null),i.announcementMessage&&this._live.clear()}),this._openedSnackBarRef?(this._openedSnackBarRef.afterDismissed().subscribe(()=>{e.containerInstance.enter()}),this._openedSnackBarRef.dismiss()):e.containerInstance.enter(),i.duration&&i.duration>0&&e.afterOpened().subscribe(()=>e._dismissAfter(i.duration))}_createOverlay(e){let i=new Ws;i.direction=e.direction;let r=this._overlay.position().global(),o="rtl"===e.direction,a="left"===e.horizontalPosition||"start"===e.horizontalPosition&&!o||"end"===e.horizontalPosition&&o,s=!a&&"center"!==e.horizontalPosition;return a?r.left("0"):s?r.right("0"):r.centerHorizontally(),"top"===e.verticalPosition?r.top("0"):r.bottom("0"),i.positionStrategy=r,this._overlay.create(i)}_createInjector(e,i){return bi.create({parent:e&&e.viewContainerRef&&e.viewContainerRef.injector||this._injector,providers:[{provide:wd,useValue:i},{provide:Mg,useValue:e.data}]})}}return n.\u0275fac=function(e){return new(e||n)(O(Oi),O(yg),O(bi),O(Ou),O(n,12),O(Y1))},n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})();function Z_e(n,t){if(1&n){let e=ge();h(0,"div",2)(1,"button",3),D("click",function(){return X(e),Q(w().action())}),T(2),g()()}if(2&n){let e=w();b(2),ut(e.data.action)}}function K_e(n,t){}var J_e=(()=>{class n{constructor(e,i){this.snackBarRef=e,this.data=i}action(){this.snackBarRef.dismissWithAction()}get hasAction(){return!!this.data.action}}return n.\u0275fac=function(e){return new(e||n)(C(wd),C(Mg))},n.\u0275cmp=k({type:n,selectors:[["simple-snack-bar"]],hostAttrs:[1,"mat-simple-snackbar"],decls:3,vars:2,consts:[[1,"mat-simple-snack-bar-content"],["class","mat-simple-snackbar-action",4,"ngIf"],[1,"mat-simple-snackbar-action"],["mat-button","",3,"click"]],template:function(e,i){1&e&&(h(0,"span",0),T(1),g(),S(2,Z_e,3,1,"div",1)),2&e&&(b(1),ut(i.data.message),b(1),_("ngIf",i.hasAction))},dependencies:[Fe,Fn],styles:[".mat-simple-snackbar{display:flex;justify-content:space-between;align-items:center;line-height:20px;opacity:1}.mat-simple-snackbar-action{flex-shrink:0;margin:-8px -8px -8px 8px}.mat-simple-snackbar-action button{max-height:36px;min-width:0}[dir=rtl] .mat-simple-snackbar-action{margin-left:-8px;margin-right:8px}.mat-simple-snack-bar-content{overflow:hidden;text-overflow:ellipsis}"],encapsulation:2,changeDetection:0}),n})(),$_e=(()=>{class n extends V2{_afterPortalAttached(){super._afterPortalAttached(),"center"===this.snackBarConfig.horizontalPosition&&this._elementRef.nativeElement.classList.add("mat-snack-bar-center"),"top"===this.snackBarConfig.verticalPosition&&this._elementRef.nativeElement.classList.add("mat-snack-bar-top")}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Cn(n)))(i||n)}}(),n.\u0275cmp=k({type:n,selectors:[["snack-bar-container"]],hostAttrs:[1,"mat-snack-bar-container"],hostVars:1,hostBindings:function(e,i){1&e&&Zp("@state.done",function(o){return i.onAnimationEnd(o)}),2&e&&Kp("@state",i._animationState)},features:[Le],decls:3,vars:3,consts:[["aria-hidden","true"],["cdkPortalOutlet",""]],template:function(e,i){1&e&&(h(0,"div",0),S(1,K_e,0,0,"ng-template",1),g(),P(2,"div")),2&e&&(b(2),Pe("aria-live",i._live)("role",i._role)("id",i._liveElementId))},dependencies:[No],styles:[".mat-snack-bar-container{border-radius:4px;box-sizing:border-box;display:block;margin:24px;max-width:33vw;min-width:344px;padding:14px 16px;min-height:48px;transform-origin:center}.cdk-high-contrast-active .mat-snack-bar-container{border:solid 1px}.mat-snack-bar-handset{width:100%}.mat-snack-bar-handset .mat-snack-bar-container{margin:8px;max-width:100%;min-width:0;width:100%}"],encapsulation:2,data:{animation:[B2.snackBarState]}}),n})(),z2=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Lr,us,Te,fi,Qt,Qt]}),n})(),s9=(()=>{class n extends H2{constructor(e,i,r,o,a,s){super(e,i,r,o,a,s),this.simpleSnackBarComponent=J_e,this.snackBarContainerComponent=$_e,this.handsetCssClass="mat-snack-bar-handset"}}return n.\u0275fac=function(e){return new(e||n)(O(Oi),O(yg),O(bi),O(Ou),O(n,12),O(Y1))},n.\u0275prov=pe({token:n,factory:n.\u0275fac,providedIn:z2}),n})(),eye=/[\\^$.*+?()[\]{}|]/g,c9="\\u0000-\\u0020\\u007f-\\u009f",nye=new RegExp("(?:[a-zA-Z][a-zA-Z0-9+.-]{2,}:\\/\\/|data:|www\\.)[^\\s"+c9+'"]{2,}[^\\s'+c9+"\"')}\\],:;.!?]","gu");function u9(n){return function(n,t){t.flags.includes("g")||(t=new RegExp(t,t.flags+"g"));let e=[],i=0;for(let r of n.matchAll(t)){let o=r.index,a=r[0];o>i&&e.push({index:i,text:n.substring(i,o),matchesRegex:!1}),e.push({index:o,text:a,matchesRegex:!0}),i=o+a.length}return n.length>i&&e.push({index:i,text:n.substring(i,n.length),matchesRegex:!1}),e}(n,nye).map(({matchesRegex:t,text:e})=>({isURL:t,text:e}))}function iye(n,t){if(1&n&&(Tt(0),T(1),Dt()),2&n){let e=w().$implicit;b(1),ze(" ",e.text," ")}}function rye(n,t){if(1&n&&(h(0,"a",7),T(1),g()),2&n){let e=w().$implicit;Ji("href",e.text,As),b(1),ut(e.text)}}function oye(n,t){if(1&n&&(Tt(0),S(1,iye,2,1,"ng-container",5),S(2,rye,2,2,"ng-template",null,6,Zt),Dt()),2&n){let e=t.$implicit,i=tt(3);b(1),_("ngIf",!e.isURL)("ngIfElse",i)}}function aye(n,t){if(1&n){let e=ge();h(0,"button",8),D("click",function(){return X(e),Q(w().onActionButtonClicked())}),T(1),g()}if(2&n){let e=w();b(1),ze(" ",e.alert.followupAction.localizedLabel," ")}}var p9=(()=>{class n{constructor(e,i,r){this.snackBarRef=e,this.unknownData=i,this.store=r,this.splitByURL=u9,this.alert=i}async onActionButtonClicked(){this.snackBarRef.dismiss();let e=await this.alert.followupAction.getFollowupAction(this.store);this.store.dispatch(e)}onCloseButtonClicked(){this.snackBarRef.dismiss()}}return n.\u0275fac=function(e){return new(e||n)(C(wd),C(Mg),C(ke))},n.\u0275cmp=k({type:n,selectors:[["alert-display-snackbar"]],decls:6,vars:2,consts:function(){let t;return t=$localize`:A button to close the snackbar message␟ea4d9fe61420a3fce81cf54c4c615e3c19c646a6␟1536087519743707362:Dismiss`,[[1,"message"],[4,"ngFor","ngForOf"],[1,"controls"],["mat-button","","class","followup-button",3,"click",4,"ngIf"],["mat-button","","aria-label",t,1,"dismiss-button",3,"click"],[4,"ngIf","ngIfElse"],["linkPiece",""],["rel","noreferrer noopener","target","_blank",3,"href"],["mat-button","",1,"followup-button",3,"click"]]},template:function(e,i){1&e&&(h(0,"div",0),S(1,oye,4,2,"ng-container",1),g(),h(2,"div",2),S(3,aye,2,1,"button",3),h(4,"button",4),D("click",function(){return i.onCloseButtonClicked()}),T(5," Dismiss "),g()()),2&e&&(b(1),_("ngForOf",i.splitByURL(i.alert.localizedMessage)),b(2),_("ngIf",i.alert.followupAction))},dependencies:[dn,Fe,Fn],styles:["[_nghost-%COMP%]{display:flex;flex-wrap:wrap}.message[_ngcontent-%COMP%]{font-size:14px;align-self:center;margin:5px 0;word-break:break-word}.message[_ngcontent-%COMP%]   a[_ngcontent-%COMP%]{color:inherit}.controls[_ngcontent-%COMP%]{white-space:nowrap;margin-left:auto}button[_ngcontent-%COMP%]{text-transform:uppercase}"],changeDetection:0}),n})(),f9=(()=>{class n{constructor(e,i){this.store=e,this.snackBar=i,this.ngUnsubscribe=new Ae}ngOnInit(){this.store.select(fW).pipe(ot(this.ngUnsubscribe),Ve(e=>Boolean(e))).subscribe(e=>{this.showAlert(e)})}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}showAlert(e){this.snackBar.openFromComponent(p9,{duration:5e3,horizontalPosition:"start",verticalPosition:"bottom",data:e})}}return n.\u0275fac=function(e){return new(e||n)(C(ke),C(s9))},n.\u0275cmp=k({type:n,selectors:[["alert-snackbar"]],decls:0,vars:0,template:function(e,i){},encapsulation:2,changeDetection:0}),n})(),X1=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Te,fi,z2]}),n})(),Q1=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Cc,X1,wr.forFeature("alerts",M7),wo.forFeature([C7])]}),n})();function lye(n,t){}var Lf=class{constructor(){this.role="dialog",this.panelClass="",this.hasBackdrop=!0,this.backdropClass="",this.disableClose=!1,this.width="",this.height="",this.data=null,this.ariaDescribedBy=null,this.ariaLabelledBy=null,this.ariaLabel=null,this.ariaModal=!0,this.autoFocus="first-tabbable",this.restoreFocus=!0,this.closeOnNavigation=!0,this.closeOnDestroy=!0,this.closeOnOverlayDetachments=!0}},j2=(()=>{class n extends Vu{constructor(e,i,r,o,a,s,l,c){super(),this._elementRef=e,this._focusTrapFactory=i,this._config=o,this._interactivityChecker=a,this._ngZone=s,this._overlayRef=l,this._focusMonitor=c,this._elementFocusedBeforeDialogWasOpened=null,this._closeInteractionType=null,this.attachDomPortal=d=>{this._portalOutlet.hasAttached();let u=this._portalOutlet.attachDomPortal(d);return this._contentAttached(),u},this._ariaLabelledBy=this._config.ariaLabelledBy||null,this._document=r}_contentAttached(){this._initializeFocusTrap(),this._handleBackdropClicks(),this._captureInitialFocus()}_captureInitialFocus(){this._trapFocus()}ngOnDestroy(){this._restoreFocus()}attachComponentPortal(e){this._portalOutlet.hasAttached();let i=this._portalOutlet.attachComponentPortal(e);return this._contentAttached(),i}attachTemplatePortal(e){this._portalOutlet.hasAttached();let i=this._portalOutlet.attachTemplatePortal(e);return this._contentAttached(),i}_recaptureFocus(){this._containsFocus()||this._trapFocus()}_forceFocus(e,i){this._interactivityChecker.isFocusable(e)||(e.tabIndex=-1,this._ngZone.runOutsideAngular(()=>{let r=()=>{e.removeEventListener("blur",r),e.removeEventListener("mousedown",r),e.removeAttribute("tabindex")};e.addEventListener("blur",r),e.addEventListener("mousedown",r)})),e.focus(i)}_focusByCssSelector(e,i){let r=this._elementRef.nativeElement.querySelector(e);r&&this._forceFocus(r,i)}_trapFocus(){let e=this._elementRef.nativeElement;switch(this._config.autoFocus){case!1:case"dialog":this._containsFocus()||e.focus();break;case!0:case"first-tabbable":this._focusTrap.focusInitialElementWhenReady().then(i=>{i||this._focusDialogContainer()});break;case"first-heading":this._focusByCssSelector('h1, h2, h3, h4, h5, h6, [role="heading"]');break;default:this._focusByCssSelector(this._config.autoFocus)}}_restoreFocus(){let e=this._config.restoreFocus,i=null;if("string"==typeof e?i=this._document.querySelector(e):"boolean"==typeof e?i=e?this._elementFocusedBeforeDialogWasOpened:null:e&&(i=e),this._config.restoreFocus&&i&&"function"==typeof i.focus){let r=Bb(),o=this._elementRef.nativeElement;(!r||r===this._document.body||r===o||o.contains(r))&&(this._focusMonitor?(this._focusMonitor.focusVia(i,this._closeInteractionType),this._closeInteractionType=null):i.focus())}this._focusTrap&&this._focusTrap.destroy()}_focusDialogContainer(){this._elementRef.nativeElement.focus&&this._elementRef.nativeElement.focus()}_containsFocus(){let e=this._elementRef.nativeElement,i=Bb();return e===i||e.contains(i)}_initializeFocusTrap(){this._focusTrap=this._focusTrapFactory.create(this._elementRef.nativeElement),this._document&&(this._elementFocusedBeforeDialogWasOpened=Bb())}_handleBackdropClicks(){this._overlayRef.backdropClick().subscribe(()=>{this._config.disableClose&&this._recaptureFocus()})}}return n.\u0275fac=function(e){return new(e||n)(C(be),C(_g),C(kt,8),C(Lf),C(Tf),C(at),C(Ol),C(lr))},n.\u0275cmp=k({type:n,selectors:[["cdk-dialog-container"]],viewQuery:function(e,i){if(1&e&&Ye(No,7),2&e){let r;we(r=Se())&&(i._portalOutlet=r.first)}},hostAttrs:["tabindex","-1",1,"cdk-dialog-container"],hostVars:6,hostBindings:function(e,i){2&e&&Pe("id",i._config.id||null)("role",i._config.role)("aria-modal",i._config.ariaModal)("aria-labelledby",i._config.ariaLabel?null:i._ariaLabelledBy)("aria-label",i._config.ariaLabel)("aria-describedby",i._config.ariaDescribedBy||null)},features:[Le],decls:1,vars:0,consts:[["cdkPortalOutlet",""]],template:function(e,i){1&e&&S(0,lye,0,0,"ng-template",0)},dependencies:[No],styles:[".cdk-dialog-container{display:block;width:100%;height:100%;min-height:inherit;max-height:inherit}"],encapsulation:2}),n})(),Qb=class{constructor(t,e){this.overlayRef=t,this.config=e,this.closed=new Ae,this.disableClose=e.disableClose,this.backdropClick=t.backdropClick(),this.keydownEvents=t.keydownEvents(),this.outsidePointerEvents=t.outsidePointerEvents(),this.id=e.id,this.keydownEvents.subscribe(i=>{27===i.keyCode&&!this.disableClose&&!yr(i)&&(i.preventDefault(),this.close(void 0,{focusOrigin:"keyboard"}))}),this.backdropClick.subscribe(()=>{this.disableClose||this.close(void 0,{focusOrigin:"mouse"})}),this._detachSubscription=t.detachments().subscribe(()=>{!1!==e.closeOnOverlayDetachments&&this.close()})}close(t,e){if(this.containerInstance){let i=this.closed;this.containerInstance._closeInteractionType=e?.focusOrigin||"program",this._detachSubscription.unsubscribe(),this.overlayRef.dispose(),i.next(t),i.complete(),this.componentInstance=this.containerInstance=null}}updatePosition(){return this.overlayRef.updatePosition(),this}updateSize(t="",e=""){return this.overlayRef.updateSize({width:t,height:e}),this}addPanelClass(t){return this.overlayRef.addPanelClass(t),this}removePanelClass(t){return this.overlayRef.removePanelClass(t),this}},m9=new ie("DialogScrollStrategy"),cye=new ie("DialogData"),dye=new ie("DefaultDialogConfig"),pye={provide:m9,deps:[Oi],useFactory:function(n){return()=>n.scrollStrategies.block()}},fye=0,G2=(()=>{class n{get openDialogs(){return this._parentDialog?this._parentDialog.openDialogs:this._openDialogsAtThisLevel}get afterOpened(){return this._parentDialog?this._parentDialog.afterOpened:this._afterOpenedAtThisLevel}constructor(e,i,r,o,a,s){this._overlay=e,this._injector=i,this._defaultOptions=r,this._parentDialog=o,this._overlayContainer=a,this._openDialogsAtThisLevel=[],this._afterAllClosedAtThisLevel=new Ae,this._afterOpenedAtThisLevel=new Ae,this._ariaHiddenElements=new Map,this.afterAllClosed=Ka(()=>this.openDialogs.length?this._getAfterAllClosed():this._getAfterAllClosed().pipe(Nn(void 0))),this._scrollStrategy=s}open(e,i){(i={...this._defaultOptions||new Lf,...i}).id=i.id||"cdk-dialog-"+fye++,i.id&&this.getDialogById(i.id);let o=this._getOverlayConfig(i),a=this._overlay.create(o),s=new Qb(a,i),l=this._attachContainer(a,s,i);return s.containerInstance=l,this._attachDialogContent(e,s,l,i),this.openDialogs.length||this._hideNonDialogContentFromAssistiveTechnology(),this.openDialogs.push(s),s.closed.subscribe(()=>this._removeOpenDialog(s,!0)),this.afterOpened.next(s),s}closeAll(){U2(this.openDialogs,e=>e.close())}getDialogById(e){return this.openDialogs.find(i=>i.id===e)}ngOnDestroy(){U2(this._openDialogsAtThisLevel,e=>{!1===e.config.closeOnDestroy&&this._removeOpenDialog(e,!1)}),U2(this._openDialogsAtThisLevel,e=>e.close()),this._afterAllClosedAtThisLevel.complete(),this._afterOpenedAtThisLevel.complete(),this._openDialogsAtThisLevel=[]}_getOverlayConfig(e){let i=new Ws({positionStrategy:e.positionStrategy||this._overlay.position().global().centerHorizontally().centerVertically(),scrollStrategy:e.scrollStrategy||this._scrollStrategy(),panelClass:e.panelClass,hasBackdrop:e.hasBackdrop,direction:e.direction,minWidth:e.minWidth,minHeight:e.minHeight,maxWidth:e.maxWidth,maxHeight:e.maxHeight,width:e.width,height:e.height,disposeOnNavigation:e.closeOnNavigation});return e.backdropClass&&(i.backdropClass=e.backdropClass),i}_attachContainer(e,i,r){let s,o=r.injector||r.viewContainerRef?.injector,a=[{provide:Lf,useValue:r},{provide:Qb,useValue:i},{provide:Ol,useValue:e}];r.container?"function"==typeof r.container?s=r.container:(s=r.container.type,a.push(...r.container.providers(r))):s=j2;let l=new Pl(s,r.viewContainerRef,bi.create({parent:o||this._injector,providers:a}),r.componentFactoryResolver);return e.attach(l).instance}_attachDialogContent(e,i,r,o){if(e instanceof Si){let a=this._createInjector(o,i,r,void 0),s={$implicit:o.data,dialogRef:i};o.templateContext&&(s={...s,..."function"==typeof o.templateContext?o.templateContext():o.templateContext}),r.attachTemplatePortal(new Jo(e,null,s,a))}else{let a=this._createInjector(o,i,r,this._injector),s=r.attachComponentPortal(new Pl(e,o.viewContainerRef,a,o.componentFactoryResolver));i.componentInstance=s.instance}}_createInjector(e,i,r,o){let a=e.injector||e.viewContainerRef?.injector,s=[{provide:cye,useValue:e.data},{provide:Qb,useValue:i}];return e.providers&&("function"==typeof e.providers?s.push(...e.providers(i,e,r)):s.push(...e.providers)),e.direction&&(!a||!a.get(Hi,null,{optional:!0}))&&s.push({provide:Hi,useValue:{value:e.direction,change:qt()}}),bi.create({parent:a||o,providers:s})}_removeOpenDialog(e,i){let r=this.openDialogs.indexOf(e);r>-1&&(this.openDialogs.splice(r,1),this.openDialogs.length||(this._ariaHiddenElements.forEach((o,a)=>{o?a.setAttribute("aria-hidden",o):a.removeAttribute("aria-hidden")}),this._ariaHiddenElements.clear(),i&&this._getAfterAllClosed().next()))}_hideNonDialogContentFromAssistiveTechnology(){let e=this._overlayContainer.getContainerElement();if(e.parentElement){let i=e.parentElement.children;for(let r=i.length-1;r>-1;r--){let o=i[r];o!==e&&"SCRIPT"!==o.nodeName&&"STYLE"!==o.nodeName&&!o.hasAttribute("aria-live")&&(this._ariaHiddenElements.set(o,o.getAttribute("aria-hidden")),o.setAttribute("aria-hidden","true"))}}}_getAfterAllClosed(){let e=this._parentDialog;return e?e._getAfterAllClosed():this._afterAllClosedAtThisLevel}}return n.\u0275fac=function(e){return new(e||n)(O(Oi),O(bi),O(dye,8),O(n,12),O(Of),O(m9))},n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})();function U2(n,t){let e=n.length;for(;e--;)t(n[e])}var W2=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({providers:[G2,pye],imports:[Lr,us,Df,us]}),n})(),Nf=class{constructor(){this.role="dialog",this.panelClass="",this.hasBackdrop=!0,this.backdropClass="",this.disableClose=!1,this.width="",this.height="",this.maxWidth="80vw",this.data=null,this.ariaDescribedBy=null,this.ariaLabelledBy=null,this.ariaLabel=null,this.ariaModal=!0,this.autoFocus="first-tabbable",this.restoreFocus=!0,this.delayFocusTrap=!0,this.closeOnNavigation=!0}},h9=(()=>{class n extends j2{constructor(e,i,r,o,a,s,l,c){super(e,i,r,o,a,s,l,c),this._animationStateChanged=new L}_captureInitialFocus(){this._config.delayFocusTrap||this._trapFocus()}_openAnimationDone(e){this._config.delayFocusTrap&&this._trapFocus(),this._animationStateChanged.next({state:"opened",totalTime:e})}}return n.\u0275fac=function(e){return new(e||n)(C(be),C(_g),C(kt,8),C(Nf),C(Tf),C(at),C(Ol),C(lr))},n.\u0275cmp=k({type:n,selectors:[["ng-component"]],features:[Le],decls:0,vars:0,template:function(e,i){},encapsulation:2}),n})(),Z1=class{constructor(t,e,i){this._ref=t,this._containerInstance=i,this._afterOpened=new Ae,this._beforeClosed=new Ae,this._state=0,this.disableClose=e.disableClose,this.id=t.id,i._animationStateChanged.pipe(Ve(r=>"opened"===r.state),zt(1)).subscribe(()=>{this._afterOpened.next(),this._afterOpened.complete()}),i._animationStateChanged.pipe(Ve(r=>"closed"===r.state),zt(1)).subscribe(()=>{clearTimeout(this._closeFallbackTimeout),this._finishDialogClose()}),t.overlayRef.detachments().subscribe(()=>{this._beforeClosed.next(this._result),this._beforeClosed.complete(),this._finishDialogClose()}),cn(this.backdropClick(),this.keydownEvents().pipe(Ve(r=>27===r.keyCode&&!this.disableClose&&!yr(r)))).subscribe(r=>{this.disableClose||(r.preventDefault(),q2(this,"keydown"===r.type?"keyboard":"mouse"))})}close(t){this._result=t,this._containerInstance._animationStateChanged.pipe(Ve(e=>"closing"===e.state),zt(1)).subscribe(e=>{this._beforeClosed.next(t),this._beforeClosed.complete(),this._ref.overlayRef.detachBackdrop(),this._closeFallbackTimeout=setTimeout(()=>this._finishDialogClose(),e.totalTime+100)}),this._state=1,this._containerInstance._startExitAnimation()}afterOpened(){return this._afterOpened}afterClosed(){return this._ref.closed}beforeClosed(){return this._beforeClosed}backdropClick(){return this._ref.backdropClick}keydownEvents(){return this._ref.keydownEvents}updatePosition(t){let e=this._ref.config.positionStrategy;return t&&(t.left||t.right)?t.left?e.left(t.left):e.right(t.right):e.centerHorizontally(),t&&(t.top||t.bottom)?t.top?e.top(t.top):e.bottom(t.bottom):e.centerVertically(),this._ref.updatePosition(),this}updateSize(t="",e=""){return this._ref.updateSize(t,e),this}addPanelClass(t){return this._ref.addPanelClass(t),this}removePanelClass(t){return this._ref.removePanelClass(t),this}getState(){return this._state}_finishDialogClose(){this._state=2,this._ref.close(this._result,{focusOrigin:this._closeInteractionType}),this.componentInstance=null}};function q2(n,t,e){return n._closeInteractionType=t,n.close(e)}new ie("MatMdcDialogData"),new ie("mat-mdc-dialog-default-options"),new ie("mat-mdc-dialog-scroll-strategy");var mye=0,g9=(()=>{class n{get openDialogs(){return this._parentDialog?this._parentDialog.openDialogs:this._openDialogsAtThisLevel}get afterOpened(){return this._parentDialog?this._parentDialog.afterOpened:this._afterOpenedAtThisLevel}_getAfterAllClosed(){let e=this._parentDialog;return e?e._getAfterAllClosed():this._afterAllClosedAtThisLevel}constructor(e,i,r,o,a,s,l,c,d,u){this._overlay=e,this._defaultOptions=r,this._parentDialog=o,this._dialogRefConstructor=l,this._dialogContainerType=c,this._dialogDataToken=d,this._openDialogsAtThisLevel=[],this._afterAllClosedAtThisLevel=new Ae,this._afterOpenedAtThisLevel=new Ae,this._idPrefix="mat-dialog-",this.dialogConfigClass=Nf,this.afterAllClosed=Ka(()=>this.openDialogs.length?this._getAfterAllClosed():this._getAfterAllClosed().pipe(Nn(void 0))),this._scrollStrategy=s,this._dialog=i.get(G2)}open(e,i){let r;(i={...this._defaultOptions||new Nf,...i}).id=i.id||`${this._idPrefix}${mye++}`,i.scrollStrategy=i.scrollStrategy||this._scrollStrategy();let o=this._dialog.open(e,{...i,positionStrategy:this._overlay.position().global().centerHorizontally().centerVertically(),disableClose:!0,closeOnDestroy:!1,closeOnOverlayDetachments:!1,container:{type:this._dialogContainerType,providers:()=>[{provide:this.dialogConfigClass,useValue:i},{provide:Lf,useValue:i}]},templateContext:()=>({dialogRef:r}),providers:(a,s,l)=>(r=new this._dialogRefConstructor(a,i,l),r.updatePosition(i?.position),[{provide:this._dialogContainerType,useValue:l},{provide:this._dialogDataToken,useValue:s.data},{provide:this._dialogRefConstructor,useValue:r}])});return r.componentInstance=o.componentInstance,this.openDialogs.push(r),this.afterOpened.next(r),r.afterClosed().subscribe(()=>{let a=this.openDialogs.indexOf(r);a>-1&&(this.openDialogs.splice(a,1),this.openDialogs.length||this._getAfterAllClosed().next())}),r}closeAll(){this._closeDialogs(this.openDialogs)}getDialogById(e){return this.openDialogs.find(i=>i.id===e)}ngOnDestroy(){this._closeDialogs(this._openDialogsAtThisLevel),this._afterAllClosedAtThisLevel.complete(),this._afterOpenedAtThisLevel.complete()}_closeDialogs(e){let i=e.length;for(;i--;)e[i].close()}}return n.\u0275fac=function(e){_l()},n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})(),Zb={params:{enterAnimationDuration:"150ms",exitAnimationDuration:"75ms"}},_9={dialogContainer:ji("dialogContainer",[Jn("void, exit",Bt({opacity:0,transform:"scale(0.7)"})),Jn("enter",Bt({transform:"none"})),Wn("* => enter",Gy([Kn("{{enterAnimationDuration}} cubic-bezier(0, 0, 0.2, 1)",Bt({transform:"none",opacity:1})),dd("@*",cd(),{optional:!0})]),Zb),Wn("* => void, * => exit",Gy([Kn("{{exitAnimationDuration}} cubic-bezier(0.4, 0.0, 0.2, 1)",Bt({opacity:0})),dd("@*",cd(),{optional:!0})]),Zb)])};function hye(n,t){}var y9_params_enterAnimationDuration="150ms",y9_params_exitAnimationDuration="75ms",K1=class extends Nf{constructor(){super(...arguments),this.enterAnimationDuration=Zb.params.enterAnimationDuration,this.exitAnimationDuration=Zb.params.exitAnimationDuration}},gye=(()=>{class n extends h9{_onAnimationDone({toState:e,totalTime:i}){"enter"===e?this._openAnimationDone(i):"exit"===e&&this._animationStateChanged.next({state:"closed",totalTime:i})}_onAnimationStart({toState:e,totalTime:i}){"enter"===e?this._animationStateChanged.next({state:"opening",totalTime:i}):("exit"===e||"void"===e)&&this._animationStateChanged.next({state:"closing",totalTime:i})}_startExitAnimation(){this._state="exit",this._changeDetectorRef.markForCheck()}constructor(e,i,r,o,a,s,l,c,d){super(e,i,r,o,a,s,l,d),this._changeDetectorRef=c,this._state="enter"}_getAnimationState(){return{value:this._state,params:{enterAnimationDuration:this._config.enterAnimationDuration||y9_params_enterAnimationDuration,exitAnimationDuration:this._config.exitAnimationDuration||y9_params_exitAnimationDuration}}}}return n.\u0275fac=function(e){return new(e||n)(C(be),C(_g),C(kt,8),C(K1),C(Tf),C(at),C(Ol),C(Ft),C(lr))},n.\u0275cmp=k({type:n,selectors:[["mat-dialog-container"]],hostAttrs:["tabindex","-1",1,"mat-dialog-container"],hostVars:7,hostBindings:function(e,i){1&e&&Zp("@dialogContainer.start",function(o){return i._onAnimationStart(o)})("@dialogContainer.done",function(o){return i._onAnimationDone(o)}),2&e&&(Co("id",i._config.id),Pe("aria-modal",i._config.ariaModal)("role",i._config.role)("aria-labelledby",i._config.ariaLabel?null:i._ariaLabelledBy)("aria-label",i._config.ariaLabel)("aria-describedby",i._config.ariaDescribedBy||null),Kp("@dialogContainer",i._getAnimationState()))},features:[Le],decls:1,vars:0,consts:[["cdkPortalOutlet",""]],template:function(e,i){1&e&&S(0,hye,0,0,"ng-template",0)},dependencies:[No],styles:[".mat-dialog-container{display:block;padding:24px;border-radius:4px;box-sizing:border-box;overflow:auto;outline:0;width:100%;height:100%;min-height:inherit;max-height:inherit}.cdk-high-contrast-active .mat-dialog-container{outline:solid 1px}.mat-dialog-content{display:block;margin:0 -24px;padding:0 24px;max-height:65vh;overflow:auto;-webkit-overflow-scrolling:touch}.mat-dialog-title{margin:0 0 20px;display:block}.mat-dialog-actions{padding:8px 0;display:flex;flex-wrap:wrap;min-height:52px;align-items:center;box-sizing:content-box;margin-bottom:-24px}.mat-dialog-actions.mat-dialog-actions-align-center,.mat-dialog-actions[align=center]{justify-content:center}.mat-dialog-actions.mat-dialog-actions-align-end,.mat-dialog-actions[align=end]{justify-content:flex-end}.mat-dialog-actions .mat-button-base+.mat-button-base,.mat-dialog-actions .mat-mdc-button-base+.mat-mdc-button-base{margin-left:8px}[dir=rtl] .mat-dialog-actions .mat-button-base+.mat-button-base,[dir=rtl] .mat-dialog-actions .mat-mdc-button-base+.mat-mdc-button-base{margin-left:0;margin-right:8px}"],encapsulation:2,data:{animation:[_9.dialogContainer]}}),n})(),Sd=class extends Z1{},Kb=new ie("MatDialogData"),_ye=new ie("mat-dialog-default-options"),b9=new ie("mat-dialog-scroll-strategy"),bye={provide:b9,deps:[Oi],useFactory:function(n){return()=>n.scrollStrategies.block()}},Ll=(()=>{class n extends g9{constructor(e,i,r,o,a,s,l,c){super(e,i,o,s,l,a,Sd,gye,Kb,c),this.dialogConfigClass=K1}}return n.\u0275fac=function(e){return new(e||n)(O(Oi),O(bi),O(Fy,8),O(_ye,8),O(b9),O(n,12),O(Of),O(di,8))},n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})(),vye=0,J1=(()=>{class n{constructor(e,i,r){this.dialogRef=e,this._elementRef=i,this._dialog=r,this.type="button"}ngOnInit(){this.dialogRef||(this.dialogRef=x9(this._elementRef,this._dialog.openDialogs))}ngOnChanges(e){let i=e._matDialogClose||e._matDialogCloseResult;i&&(this.dialogResult=i.currentValue)}_onButtonClick(e){q2(this.dialogRef,0===e.screenX&&0===e.screenY?"keyboard":"mouse",this.dialogResult)}}return n.\u0275fac=function(e){return new(e||n)(C(Sd,8),C(be),C(Ll))},n.\u0275dir=xe({type:n,selectors:[["","mat-dialog-close",""],["","matDialogClose",""]],hostVars:2,hostBindings:function(e,i){1&e&&D("click",function(o){return i._onButtonClick(o)}),2&e&&Pe("aria-label",i.ariaLabel||null)("type",i.type)},inputs:{ariaLabel:["aria-label","ariaLabel"],type:"type",dialogResult:["mat-dialog-close","dialogResult"],_matDialogClose:["matDialogClose","_matDialogClose"]},exportAs:["matDialogClose"],features:[Gt]}),n})(),v9=(()=>{class n{constructor(e,i,r){this._dialogRef=e,this._elementRef=i,this._dialog=r,this.id="mat-dialog-title-"+vye++}ngOnInit(){this._dialogRef||(this._dialogRef=x9(this._elementRef,this._dialog.openDialogs)),this._dialogRef&&Promise.resolve().then(()=>{let e=this._dialogRef._containerInstance;e&&!e._ariaLabelledBy&&(e._ariaLabelledBy=this.id)})}}return n.\u0275fac=function(e){return new(e||n)(C(Sd,8),C(be),C(Ll))},n.\u0275dir=xe({type:n,selectors:[["","mat-dialog-title",""],["","matDialogTitle",""]],hostAttrs:[1,"mat-dialog-title"],hostVars:1,hostBindings:function(e,i){2&e&&Co("id",i.id)},inputs:{id:"id"},exportAs:["matDialogTitle"]}),n})(),$1=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275dir=xe({type:n,selectors:[["","mat-dialog-content",""],["mat-dialog-content"],["","matDialogContent",""]],hostAttrs:[1,"mat-dialog-content"]}),n})(),eE=(()=>{class n{constructor(){this.align="start"}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275dir=xe({type:n,selectors:[["","mat-dialog-actions",""],["mat-dialog-actions"],["","matDialogActions",""]],hostAttrs:[1,"mat-dialog-actions"],hostVars:4,hostBindings:function(e,i){2&e&&Qe("mat-dialog-actions-align-center","center"===i.align)("mat-dialog-actions-align-end","end"===i.align)},inputs:{align:"align"}}),n})();function x9(n,t){let e=n.nativeElement.parentElement;for(;e&&!e.classList.contains("mat-dialog-container");)e=e.parentElement;return e?t.find(i=>i.id===e.id):null}var wg=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({providers:[Ll,bye],imports:[W2,Lr,us,Qt,Qt]}),n})();function Cye(n,t){if(1&n&&P(0,"mat-pseudo-checkbox",5),2&n){let e=w();_("state",e.selected?"checked":"unchecked")("disabled",e.disabled)}}function Mye(n,t){if(1&n&&(h(0,"span",6),T(1),g()),2&n){let e=w();b(1),ze("(",e.group.label,")")}}var wye=["*"],Ha=(()=>{class n extends I2{constructor(e,i,r,o){super(e,i,r,o)}}return n.\u0275fac=function(e){return new(e||n)(C(be),C(Ft),C(xd,8),C(Cd,8))},n.\u0275cmp=k({type:n,selectors:[["mat-option"]],hostAttrs:["role","option",1,"mat-option","mat-focus-indicator"],hostVars:12,hostBindings:function(e,i){1&e&&D("click",function(){return i._selectViaInteraction()})("keydown",function(o){return i._handleKeydown(o)}),2&e&&(Co("id",i.id),Pe("tabindex",i._getTabIndex())("aria-selected",i.selected)("aria-disabled",i.disabled.toString()),Qe("mat-selected",i.selected)("mat-option-multiple",i.multiple)("mat-active",i.active)("mat-option-disabled",i.disabled))},exportAs:["matOption"],features:[Le],ngContentSelectors:wye,decls:6,vars:4,consts:[["class","mat-option-pseudo-checkbox",3,"state","disabled",4,"ngIf"],[1,"mat-option-text"],["text",""],["class","cdk-visually-hidden",4,"ngIf"],["mat-ripple","",1,"mat-option-ripple",3,"matRippleTrigger","matRippleDisabled"],[1,"mat-option-pseudo-checkbox",3,"state","disabled"],[1,"cdk-visually-hidden"]],template:function(e,i){1&e&&(gn(),S(0,Cye,1,2,"mat-pseudo-checkbox",0),h(1,"span",1,2),Xt(3),g(),S(4,Mye,2,1,"span",3),P(5,"div",4)),2&e&&(_("ngIf",i.multiple),b(4),_("ngIf",i.group&&i.group._inert),b(1),_("matRippleTrigger",i._getHostElement())("matRippleDisabled",i.disabled||i.disableRipple))},dependencies:[Fr,Fe,T2],styles:['.mat-option{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;line-height:48px;height:48px;padding:0 16px;text-align:left;text-decoration:none;max-width:100%;position:relative;cursor:pointer;outline:none;display:flex;flex-direction:row;max-width:100%;box-sizing:border-box;align-items:center;-webkit-tap-highlight-color:rgba(0,0,0,0)}.mat-option[disabled]{cursor:default}[dir=rtl] .mat-option{text-align:right}.mat-option .mat-icon{margin-right:16px;vertical-align:middle}.mat-option .mat-icon svg{vertical-align:top}[dir=rtl] .mat-option .mat-icon{margin-left:16px;margin-right:0}.mat-option[aria-disabled=true]{-webkit-user-select:none;user-select:none;cursor:default}.mat-optgroup .mat-option:not(.mat-option-multiple){padding-left:32px}[dir=rtl] .mat-optgroup .mat-option:not(.mat-option-multiple){padding-left:16px;padding-right:32px}.mat-option.mat-active::before{content:""}.cdk-high-contrast-active .mat-option[aria-disabled=true]{opacity:.5}.cdk-high-contrast-active .mat-option.mat-selected:not(.mat-option-multiple)::after{content:"";position:absolute;top:50%;right:16px;transform:translateY(-50%);width:10px;height:0;border-bottom:solid 10px;border-radius:10px}[dir=rtl] .cdk-high-contrast-active .mat-option.mat-selected:not(.mat-option-multiple)::after{right:auto;left:16px}.mat-option-text{display:inline-block;flex-grow:1;overflow:hidden;text-overflow:ellipsis}.mat-option .mat-option-ripple{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none}.mat-option-pseudo-checkbox{margin-right:8px}[dir=rtl] .mat-option-pseudo-checkbox{margin-left:8px;margin-right:0}'],encapsulation:2,changeDetection:0}),n})(),Sg=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Zo,Te,Qt,D2]}),n})(),tE=new ie("MatError"),nE=new ie("MatPrefix"),Y2=new ie("MatSuffix"),X2={transitionMessages:ji("transitionMessages",[Jn("enter",Bt({opacity:1,transform:"translateY(0%)"})),Wn("void => enter",[Bt({opacity:0,transform:"translateY(-5px)"}),Kn("300ms cubic-bezier(0.55, 0, 0.55, 0.2)")])])},Nl=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275dir=xe({type:n}),n})(),Bl=new ie("MatFormField"),Sye=(new ie("MAT_FORM_FIELD_DEFAULT_OPTIONS"),["connectionContainer"]),Eye=["inputContainer"],Tye=["label"];function Dye(n,t){1&n&&(Tt(0),h(1,"div",14),P(2,"div",15)(3,"div",16)(4,"div",17),g(),h(5,"div",18),P(6,"div",15)(7,"div",16)(8,"div",17),g(),Dt())}function Iye(n,t){if(1&n){let e=ge();h(0,"div",19),D("cdkObserveContent",function(){return X(e),Q(w().updateOutlineGap())}),Xt(1,1),g()}2&n&&_("cdkObserveContentDisabled","outline"!=w().appearance)}function Aye(n,t){if(1&n&&(Tt(0),Xt(1,2),h(2,"span"),T(3),g(),Dt()),2&n){let e=w(2);b(3),ut(e._control.placeholder)}}function Rye(n,t){1&n&&Xt(0,3,["*ngSwitchCase","true"])}function kye(n,t){1&n&&(h(0,"span",23),T(1," *"),g())}function Pye(n,t){if(1&n){let e=ge();h(0,"label",20,21),D("cdkObserveContent",function(){return X(e),Q(w().updateOutlineGap())}),S(2,Aye,4,1,"ng-container",12),S(3,Rye,1,0,"ng-content",12),S(4,kye,2,0,"span",22),g()}if(2&n){let e=w();Qe("mat-empty",e._control.empty&&!e._shouldAlwaysFloat())("mat-form-field-empty",e._control.empty&&!e._shouldAlwaysFloat())("mat-accent","accent"==e.color)("mat-warn","warn"==e.color),_("cdkObserveContentDisabled","outline"!=e.appearance)("id",e._labelId)("ngSwitch",e._hasLabel()),Pe("for",e._control.id)("aria-owns",e._control.id),b(2),_("ngSwitchCase",!1),b(1),_("ngSwitchCase",!0),b(1),_("ngIf",!e.hideRequiredMarker&&e._control.required&&!e._control.disabled)}}function Oye(n,t){1&n&&(h(0,"div",24),Xt(1,4),g())}function Fye(n,t){if(1&n&&(h(0,"div",25),P(1,"span",26),g()),2&n){let e=w();b(1),Qe("mat-accent","accent"==e.color)("mat-warn","warn"==e.color)}}function Lye(n,t){1&n&&(h(0,"div"),Xt(1,5),g()),2&n&&_("@transitionMessages",w()._subscriptAnimationState)}function Nye(n,t){if(1&n&&(h(0,"div",30),T(1),g()),2&n){let e=w(2);_("id",e._hintLabelId),b(1),ut(e.hintLabel)}}function Bye(n,t){if(1&n&&(h(0,"div",27),S(1,Nye,2,2,"div",28),Xt(2,6),P(3,"div",29),Xt(4,7),g()),2&n){let e=w();_("@transitionMessages",e._subscriptAnimationState),b(1),_("ngIf",e.hintLabel)}}var Vye=["*",[["","matPrefix",""]],[["mat-placeholder"]],[["mat-label"]],[["","matSuffix",""]],[["mat-error"]],[["mat-hint",3,"align","end"]],[["mat-hint","align","end"]]],Hye=["*","[matPrefix]","mat-placeholder","mat-label","[matSuffix]","mat-error","mat-hint:not([align='end'])","mat-hint[align='end']"],zye=0,w9=(()=>{class n{constructor(e,i){this.id="mat-error-"+zye++,e||i.nativeElement.setAttribute("aria-live","polite")}}return n.\u0275fac=function(e){return new(e||n)(Vr("aria-live"),C(be))},n.\u0275dir=xe({type:n,selectors:[["mat-error"]],hostAttrs:["aria-atomic","true",1,"mat-error"],hostVars:1,hostBindings:function(e,i){2&e&&Pe("id",i.id)},inputs:{id:"id"},features:[Rt([{provide:tE,useExisting:n}])]}),n})(),Uye=new ie("MatHint"),Eg=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275dir=xe({type:n,selectors:[["mat-label"]]}),n})(),jye=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275dir=xe({type:n,selectors:[["mat-placeholder"]]}),n})(),C9=0,Wye=go(class{constructor(n){this._elementRef=n}},"primary"),qye=new ie("MAT_FORM_FIELD_DEFAULT_OPTIONS"),Ys=(()=>{class n extends Wye{get appearance(){return this._appearance}set appearance(e){let i=this._appearance;this._appearance=e||this._defaults?.appearance||"legacy","outline"===this._appearance&&i!==e&&(this._outlineGapCalculationNeededOnStable=!0)}get hideRequiredMarker(){return this._hideRequiredMarker}set hideRequiredMarker(e){this._hideRequiredMarker=Ut(e)}_shouldAlwaysFloat(){return"always"===this.floatLabel&&!this._showAlwaysAnimate}_canLabelFloat(){return"never"!==this.floatLabel}get hintLabel(){return this._hintLabel}set hintLabel(e){this._hintLabel=e,this._processHints()}get floatLabel(){return"legacy"!==this.appearance&&"never"===this._floatLabel?"auto":this._floatLabel}set floatLabel(e){e!==this._floatLabel&&(this._floatLabel=e||this._getDefaultFloatLabelState(),this._changeDetectorRef.markForCheck())}get _control(){return this._explicitFormFieldControl||this._controlNonStatic||this._controlStatic}set _control(e){this._explicitFormFieldControl=e}constructor(e,i,r,o,a,s,l){super(e),this._changeDetectorRef=i,this._dir=r,this._defaults=o,this._platform=a,this._ngZone=s,this._outlineGapCalculationNeededImmediately=!1,this._outlineGapCalculationNeededOnStable=!1,this._destroyed=new Ae,this._hideRequiredMarker=!1,this._showAlwaysAnimate=!1,this._subscriptAnimationState="",this._hintLabel="",this._hintLabelId="mat-hint-"+C9++,this._labelId="mat-form-field-label-"+C9++,this.floatLabel=this._getDefaultFloatLabelState(),this._animationsEnabled="NoopAnimations"!==l,this.appearance=o?.appearance||"legacy",o&&(this._hideRequiredMarker=Boolean(o.hideRequiredMarker),o.color&&(this.color=this.defaultColor=o.color))}getLabelId(){return this._hasFloatingLabel()?this._labelId:null}getConnectedOverlayOrigin(){return this._connectionContainerRef||this._elementRef}ngAfterContentInit(){this._validateControlChild();let e=this._control;e.controlType&&this._elementRef.nativeElement.classList.add(`mat-form-field-type-${e.controlType}`),e.stateChanges.pipe(Nn(null)).subscribe(()=>{this._validatePlaceholders(),this._syncDescribedByIds(),this._changeDetectorRef.markForCheck()}),e.ngControl&&e.ngControl.valueChanges&&e.ngControl.valueChanges.pipe(ot(this._destroyed)).subscribe(()=>this._changeDetectorRef.markForCheck()),this._ngZone.runOutsideAngular(()=>{this._ngZone.onStable.pipe(ot(this._destroyed)).subscribe(()=>{this._outlineGapCalculationNeededOnStable&&this.updateOutlineGap()})}),cn(this._prefixChildren.changes,this._suffixChildren.changes).subscribe(()=>{this._outlineGapCalculationNeededOnStable=!0,this._changeDetectorRef.markForCheck()}),this._hintChildren.changes.pipe(Nn(null)).subscribe(()=>{this._processHints(),this._changeDetectorRef.markForCheck()}),this._errorChildren.changes.pipe(Nn(null)).subscribe(()=>{this._syncDescribedByIds(),this._changeDetectorRef.markForCheck()}),this._dir&&this._dir.change.pipe(ot(this._destroyed)).subscribe(()=>{"function"==typeof requestAnimationFrame?this._ngZone.runOutsideAngular(()=>{requestAnimationFrame(()=>this.updateOutlineGap())}):this.updateOutlineGap()})}ngAfterContentChecked(){this._validateControlChild(),this._outlineGapCalculationNeededImmediately&&this.updateOutlineGap()}ngAfterViewInit(){this._subscriptAnimationState="enter",this._changeDetectorRef.detectChanges()}ngOnDestroy(){this._destroyed.next(),this._destroyed.complete()}_shouldForward(e){let i=this._control?this._control.ngControl:null;return i&&i[e]}_hasPlaceholder(){return!!(this._control&&this._control.placeholder||this._placeholderChild)}_hasLabel(){return!(!this._labelChildNonStatic&&!this._labelChildStatic)}_shouldLabelFloat(){return this._canLabelFloat()&&(this._control&&this._control.shouldLabelFloat||this._shouldAlwaysFloat())}_hideControlPlaceholder(){return"legacy"===this.appearance&&!this._hasLabel()||this._hasLabel()&&!this._shouldLabelFloat()}_hasFloatingLabel(){return this._hasLabel()||"legacy"===this.appearance&&this._hasPlaceholder()}_getDisplayedMessages(){return this._errorChildren&&this._errorChildren.length>0&&this._control.errorState?"error":"hint"}_animateAndLockLabel(){this._hasFloatingLabel()&&this._canLabelFloat()&&(this._animationsEnabled&&this._label&&(this._showAlwaysAnimate=!0,ai(this._label.nativeElement,"transitionend").pipe(zt(1)).subscribe(()=>{this._showAlwaysAnimate=!1})),this.floatLabel="always",this._changeDetectorRef.markForCheck())}_validatePlaceholders(){}_processHints(){this._validateHints(),this._syncDescribedByIds()}_validateHints(){}_getDefaultFloatLabelState(){return this._defaults&&this._defaults.floatLabel||"auto"}_syncDescribedByIds(){if(this._control){let e=[];if(this._control.userAriaDescribedBy&&"string"==typeof this._control.userAriaDescribedBy&&e.push(...this._control.userAriaDescribedBy.split(" ")),"hint"===this._getDisplayedMessages()){let i=this._hintChildren?this._hintChildren.find(o=>"start"===o.align):null,r=this._hintChildren?this._hintChildren.find(o=>"end"===o.align):null;i?e.push(i.id):this._hintLabel&&e.push(this._hintLabelId),r&&e.push(r.id)}else this._errorChildren&&e.push(...this._errorChildren.map(i=>i.id));this._control.setDescribedByIds(e)}}_validateControlChild(){}updateOutlineGap(){let e=this._label?this._label.nativeElement:null,i=this._connectionContainerRef.nativeElement,r=".mat-form-field-outline-start",o=".mat-form-field-outline-gap";if("outline"!==this.appearance||!this._platform.isBrowser)return;if(!e||!e.children.length||!e.textContent.trim()){let d=i.querySelectorAll(`${r}, ${o}`);for(let u=0;u<d.length;u++)d[u].style.width="0";return}if(!this._isAttachedToDOM())return void(this._outlineGapCalculationNeededImmediately=!0);let a=0,s=0,l=i.querySelectorAll(r),c=i.querySelectorAll(o);if(this._label&&this._label.nativeElement.children.length){let d=i.getBoundingClientRect();if(0===d.width&&0===d.height)return this._outlineGapCalculationNeededOnStable=!0,void(this._outlineGapCalculationNeededImmediately=!1);let u=this._getStartEnd(d),p=e.children,f=this._getStartEnd(p[0].getBoundingClientRect()),m=0;for(let y=0;y<p.length;y++)m+=p[y].offsetWidth;a=Math.abs(f-u)-5,s=m>0?.75*m+10:0}for(let d=0;d<l.length;d++)l[d].style.width=`${a}px`;for(let d=0;d<c.length;d++)c[d].style.width=`${s}px`;this._outlineGapCalculationNeededOnStable=this._outlineGapCalculationNeededImmediately=!1}_getStartEnd(e){return this._dir&&"rtl"===this._dir.value?e.right:e.left}_isAttachedToDOM(){let e=this._elementRef.nativeElement;if(e.getRootNode){let i=e.getRootNode();return i&&i!==e}return document.documentElement.contains(e)}}return n.\u0275fac=function(e){return new(e||n)(C(be),C(Ft),C(Hi,8),C(qye,8),C($n),C(at),C(di,8))},n.\u0275cmp=k({type:n,selectors:[["mat-form-field"]],contentQueries:function(e,i,r){if(1&e&&(ci(r,Nl,5),ci(r,Nl,7),ci(r,Eg,5),ci(r,Eg,7),ci(r,jye,5),ci(r,tE,5),ci(r,Uye,5),ci(r,nE,5),ci(r,Y2,5)),2&e){let o;we(o=Se())&&(i._controlNonStatic=o.first),we(o=Se())&&(i._controlStatic=o.first),we(o=Se())&&(i._labelChildNonStatic=o.first),we(o=Se())&&(i._labelChildStatic=o.first),we(o=Se())&&(i._placeholderChild=o.first),we(o=Se())&&(i._errorChildren=o),we(o=Se())&&(i._hintChildren=o),we(o=Se())&&(i._prefixChildren=o),we(o=Se())&&(i._suffixChildren=o)}},viewQuery:function(e,i){if(1&e&&(Ye(Sye,7),Ye(Eye,5),Ye(Tye,5)),2&e){let r;we(r=Se())&&(i._connectionContainerRef=r.first),we(r=Se())&&(i._inputContainerRef=r.first),we(r=Se())&&(i._label=r.first)}},hostAttrs:[1,"mat-form-field"],hostVars:40,hostBindings:function(e,i){2&e&&Qe("mat-form-field-appearance-standard","standard"==i.appearance)("mat-form-field-appearance-fill","fill"==i.appearance)("mat-form-field-appearance-outline","outline"==i.appearance)("mat-form-field-appearance-legacy","legacy"==i.appearance)("mat-form-field-invalid",i._control.errorState)("mat-form-field-can-float",i._canLabelFloat())("mat-form-field-should-float",i._shouldLabelFloat())("mat-form-field-has-label",i._hasFloatingLabel())("mat-form-field-hide-placeholder",i._hideControlPlaceholder())("mat-form-field-disabled",i._control.disabled)("mat-form-field-autofilled",i._control.autofilled)("mat-focused",i._control.focused)("ng-untouched",i._shouldForward("untouched"))("ng-touched",i._shouldForward("touched"))("ng-pristine",i._shouldForward("pristine"))("ng-dirty",i._shouldForward("dirty"))("ng-valid",i._shouldForward("valid"))("ng-invalid",i._shouldForward("invalid"))("ng-pending",i._shouldForward("pending"))("_mat-animation-noopable",!i._animationsEnabled)},inputs:{color:"color",appearance:"appearance",hideRequiredMarker:"hideRequiredMarker",hintLabel:"hintLabel",floatLabel:"floatLabel"},exportAs:["matFormField"],features:[Rt([{provide:Bl,useExisting:n}]),Le],ngContentSelectors:Hye,decls:15,vars:8,consts:[[1,"mat-form-field-wrapper"],[1,"mat-form-field-flex",3,"click"],["connectionContainer",""],[4,"ngIf"],["class","mat-form-field-prefix",3,"cdkObserveContentDisabled","cdkObserveContent",4,"ngIf"],[1,"mat-form-field-infix"],["inputContainer",""],[1,"mat-form-field-label-wrapper"],["class","mat-form-field-label",3,"cdkObserveContentDisabled","id","mat-empty","mat-form-field-empty","mat-accent","mat-warn","ngSwitch","cdkObserveContent",4,"ngIf"],["class","mat-form-field-suffix",4,"ngIf"],["class","mat-form-field-underline",4,"ngIf"],[1,"mat-form-field-subscript-wrapper",3,"ngSwitch"],[4,"ngSwitchCase"],["class","mat-form-field-hint-wrapper",4,"ngSwitchCase"],[1,"mat-form-field-outline"],[1,"mat-form-field-outline-start"],[1,"mat-form-field-outline-gap"],[1,"mat-form-field-outline-end"],[1,"mat-form-field-outline","mat-form-field-outline-thick"],[1,"mat-form-field-prefix",3,"cdkObserveContentDisabled","cdkObserveContent"],[1,"mat-form-field-label",3,"cdkObserveContentDisabled","id","ngSwitch","cdkObserveContent"],["label",""],["class","mat-placeholder-required mat-form-field-required-marker","aria-hidden","true",4,"ngIf"],["aria-hidden","true",1,"mat-placeholder-required","mat-form-field-required-marker"],[1,"mat-form-field-suffix"],[1,"mat-form-field-underline"],[1,"mat-form-field-ripple"],[1,"mat-form-field-hint-wrapper"],["class","mat-hint",3,"id",4,"ngIf"],[1,"mat-form-field-hint-spacer"],[1,"mat-hint",3,"id"]],template:function(e,i){1&e&&(gn(Vye),h(0,"div",0)(1,"div",1,2),D("click",function(o){return i._control.onContainerClick&&i._control.onContainerClick(o)}),S(3,Dye,9,0,"ng-container",3),S(4,Iye,2,1,"div",4),h(5,"div",5,6),Xt(7),h(8,"span",7),S(9,Pye,5,16,"label",8),g()(),S(10,Oye,2,0,"div",9),g(),S(11,Fye,2,4,"div",10),h(12,"div",11),S(13,Lye,2,1,"div",12),S(14,Bye,5,2,"div",13),g()()),2&e&&(b(3),_("ngIf","outline"==i.appearance),b(1),_("ngIf",i._prefixChildren.length),b(5),_("ngIf",i._hasFloatingLabel()),b(1),_("ngIf",i._suffixChildren.length),b(1),_("ngIf","outline"!=i.appearance),b(1),_("ngSwitch",i._getDisplayedMessages()),b(1),_("ngSwitchCase","error"),b(1),_("ngSwitchCase","hint"))},dependencies:[Fe,$i,sr,pg],styles:[".mat-form-field{display:inline-block;position:relative;text-align:left}[dir=rtl] .mat-form-field{text-align:right}.mat-form-field-wrapper{position:relative}.mat-form-field-flex{display:inline-flex;align-items:baseline;box-sizing:border-box;width:100%}.mat-form-field-prefix,.mat-form-field-suffix{white-space:nowrap;flex:none;position:relative}.mat-form-field-infix{display:block;position:relative;flex:auto;min-width:0;width:180px}.cdk-high-contrast-active .mat-form-field-infix{border-image:linear-gradient(transparent, transparent)}.mat-form-field-label-wrapper{position:absolute;left:0;box-sizing:content-box;width:100%;height:100%;overflow:hidden;pointer-events:none}[dir=rtl] .mat-form-field-label-wrapper{left:auto;right:0}.mat-form-field-label{position:absolute;left:0;font:inherit;pointer-events:none;width:100%;white-space:nowrap;text-overflow:ellipsis;overflow:hidden;transform-origin:0 0;transition:transform 400ms cubic-bezier(0.25, 0.8, 0.25, 1),color 400ms cubic-bezier(0.25, 0.8, 0.25, 1),width 400ms cubic-bezier(0.25, 0.8, 0.25, 1);display:none}[dir=rtl] .mat-form-field-label{transform-origin:100% 0;left:auto;right:0}.cdk-high-contrast-active .mat-form-field-disabled .mat-form-field-label{color:GrayText}.mat-form-field-empty.mat-form-field-label,.mat-form-field-can-float.mat-form-field-should-float .mat-form-field-label{display:block}.mat-form-field-autofill-control:-webkit-autofill+.mat-form-field-label-wrapper .mat-form-field-label{display:none}.mat-form-field-can-float .mat-form-field-autofill-control:-webkit-autofill+.mat-form-field-label-wrapper .mat-form-field-label{display:block;transition:none}.mat-input-server:focus+.mat-form-field-label-wrapper .mat-form-field-label,.mat-input-server[placeholder]:not(:placeholder-shown)+.mat-form-field-label-wrapper .mat-form-field-label{display:none}.mat-form-field-can-float .mat-input-server:focus+.mat-form-field-label-wrapper .mat-form-field-label,.mat-form-field-can-float .mat-input-server[placeholder]:not(:placeholder-shown)+.mat-form-field-label-wrapper .mat-form-field-label{display:block}.mat-form-field-label:not(.mat-form-field-empty){transition:none}.mat-form-field-underline{position:absolute;width:100%;pointer-events:none;transform:scale3d(1, 1.0001, 1)}.mat-form-field-ripple{position:absolute;left:0;width:100%;transform-origin:50%;transform:scaleX(0.5);opacity:0;transition:background-color 300ms cubic-bezier(0.55, 0, 0.55, 0.2)}.mat-form-field.mat-focused .mat-form-field-ripple,.mat-form-field.mat-form-field-invalid .mat-form-field-ripple{opacity:1;transform:none;transition:transform 300ms cubic-bezier(0.25, 0.8, 0.25, 1),opacity 100ms cubic-bezier(0.25, 0.8, 0.25, 1),background-color 300ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-form-field-subscript-wrapper{position:absolute;box-sizing:border-box;width:100%;overflow:hidden}.mat-form-field-subscript-wrapper .mat-icon,.mat-form-field-label-wrapper .mat-icon{width:1em;height:1em;font-size:inherit;vertical-align:baseline}.mat-form-field-hint-wrapper{display:flex}.mat-form-field-hint-spacer{flex:1 0 1em}.mat-error{display:block}.mat-form-field-control-wrapper{position:relative}.mat-form-field-hint-end{order:1}.mat-form-field._mat-animation-noopable .mat-form-field-label,.mat-form-field._mat-animation-noopable .mat-form-field-ripple{transition:none}.mat-form-field .mat-form-field-prefix .mat-datepicker-toggle .mat-mdc-button-base,.mat-form-field .mat-form-field-suffix .mat-datepicker-toggle .mat-mdc-button-base{width:40px;height:40px;padding:8px 0}.mat-form-field .mat-datepicker-toggle .mat-mdc-icon-button .mat-icon{font-size:1em;display:inline-block;margin:-2px 0 1px}.mat-form-field-type-mat-date-range-input .mat-form-field-infix{width:200px}.mat-form-field-appearance-legacy .mat-form-field-prefix .mat-datepicker-toggle .mat-mdc-icon-button,.mat-form-field-appearance-legacy .mat-form-field-suffix .mat-datepicker-toggle .mat-mdc-icon-button{font-size:inherit;width:1.5em;height:1.5em;padding:0}.mat-form-field-appearance-legacy .mat-form-field-prefix .mat-datepicker-toggle-default-icon,.mat-form-field-appearance-legacy .mat-form-field-suffix .mat-datepicker-toggle-default-icon{width:1em}.mat-form-field-appearance-legacy .mat-form-field-prefix .mat-datepicker-toggle .mat-mdc-icon-button .mat-icon,.mat-form-field-appearance-legacy .mat-form-field-suffix .mat-datepicker-toggle .mat-mdc-icon-button .mat-icon{line-height:1.5em;margin:0}.mat-form-field .mat-datepicker-toggle .mat-mdc-button-base{vertical-align:middle}.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-datepicker-toggle .mat-mdc-button-base{vertical-align:baseline}",'.mat-form-field-appearance-fill .mat-form-field-flex{border-radius:4px 4px 0 0;padding:.75em .75em 0 .75em}.cdk-high-contrast-active .mat-form-field-appearance-fill .mat-form-field-flex{outline:solid 1px}.cdk-high-contrast-active .mat-form-field-appearance-fill.mat-form-field-disabled .mat-form-field-flex{outline-color:GrayText}.cdk-high-contrast-active .mat-form-field-appearance-fill.mat-focused .mat-form-field-flex{outline:dashed 3px}.mat-form-field-appearance-fill .mat-form-field-underline::before{content:"";display:block;position:absolute;bottom:0;height:1px;width:100%}.mat-form-field-appearance-fill .mat-form-field-ripple{bottom:0;height:2px}.cdk-high-contrast-active .mat-form-field-appearance-fill .mat-form-field-ripple{height:0}.mat-form-field-appearance-fill:not(.mat-form-field-disabled) .mat-form-field-flex:hover~.mat-form-field-underline .mat-form-field-ripple{opacity:1;transform:none;transition:opacity 600ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-form-field-appearance-fill._mat-animation-noopable:not(.mat-form-field-disabled) .mat-form-field-flex:hover~.mat-form-field-underline .mat-form-field-ripple{transition:none}.mat-form-field-appearance-fill .mat-form-field-subscript-wrapper{padding:0 1em}','.mat-input-element{font:inherit;background:rgba(0,0,0,0);color:currentColor;border:none;outline:none;padding:0;margin:0;width:100%;max-width:100%;vertical-align:bottom;text-align:inherit;box-sizing:content-box}.mat-input-element:-moz-ui-invalid{box-shadow:none}.mat-input-element,.mat-input-element::-webkit-search-cancel-button,.mat-input-element::-webkit-search-decoration,.mat-input-element::-webkit-search-results-button,.mat-input-element::-webkit-search-results-decoration{-webkit-appearance:none}.mat-input-element::-webkit-contacts-auto-fill-button,.mat-input-element::-webkit-caps-lock-indicator,.mat-input-element:not([type=password])::-webkit-credentials-auto-fill-button{visibility:hidden}.mat-input-element[type=date],.mat-input-element[type=datetime],.mat-input-element[type=datetime-local],.mat-input-element[type=month],.mat-input-element[type=week],.mat-input-element[type=time]{line-height:1}.mat-input-element[type=date]::after,.mat-input-element[type=datetime]::after,.mat-input-element[type=datetime-local]::after,.mat-input-element[type=month]::after,.mat-input-element[type=week]::after,.mat-input-element[type=time]::after{content:" ";white-space:pre;width:1px}.mat-input-element::-webkit-inner-spin-button,.mat-input-element::-webkit-calendar-picker-indicator,.mat-input-element::-webkit-clear-button{font-size:.75em}.mat-input-element::placeholder{-webkit-user-select:none;user-select:none;transition:color 400ms 133.3333333333ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-input-element::-moz-placeholder{-webkit-user-select:none;user-select:none;transition:color 400ms 133.3333333333ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-input-element::-webkit-input-placeholder{-webkit-user-select:none;user-select:none;transition:color 400ms 133.3333333333ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-input-element:-ms-input-placeholder{-webkit-user-select:none;user-select:none;transition:color 400ms 133.3333333333ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-form-field-hide-placeholder .mat-input-element::placeholder{color:rgba(0,0,0,0) !important;-webkit-text-fill-color:rgba(0,0,0,0);transition:none}.cdk-high-contrast-active .mat-form-field-hide-placeholder .mat-input-element::placeholder{opacity:0}.mat-form-field-hide-placeholder .mat-input-element::-moz-placeholder{color:rgba(0,0,0,0) !important;-webkit-text-fill-color:rgba(0,0,0,0);transition:none}.cdk-high-contrast-active .mat-form-field-hide-placeholder .mat-input-element::-moz-placeholder{opacity:0}.mat-form-field-hide-placeholder .mat-input-element::-webkit-input-placeholder{color:rgba(0,0,0,0) !important;-webkit-text-fill-color:rgba(0,0,0,0);transition:none}.cdk-high-contrast-active .mat-form-field-hide-placeholder .mat-input-element::-webkit-input-placeholder{opacity:0}.mat-form-field-hide-placeholder .mat-input-element:-ms-input-placeholder{color:rgba(0,0,0,0) !important;-webkit-text-fill-color:rgba(0,0,0,0);transition:none}.cdk-high-contrast-active .mat-form-field-hide-placeholder .mat-input-element:-ms-input-placeholder{opacity:0}._mat-animation-noopable .mat-input-element::placeholder{transition:none}._mat-animation-noopable .mat-input-element::-moz-placeholder{transition:none}._mat-animation-noopable .mat-input-element::-webkit-input-placeholder{transition:none}._mat-animation-noopable .mat-input-element:-ms-input-placeholder{transition:none}textarea.mat-input-element{resize:vertical;overflow:auto}textarea.mat-input-element.cdk-textarea-autosize{resize:none}textarea.mat-input-element{padding:2px 0;margin:-2px 0}select.mat-input-element{-moz-appearance:none;-webkit-appearance:none;position:relative;background-color:rgba(0,0,0,0);display:inline-flex;box-sizing:border-box;padding-top:1em;top:-1em;margin-bottom:-1em}select.mat-input-element::-moz-focus-inner{border:0}select.mat-input-element:not(:disabled){cursor:pointer}.mat-form-field-type-mat-native-select .mat-form-field-infix::after{content:"";width:0;height:0;border-left:5px solid rgba(0,0,0,0);border-right:5px solid rgba(0,0,0,0);border-top:5px solid;position:absolute;top:50%;right:0;margin-top:-2.5px;pointer-events:none}[dir=rtl] .mat-form-field-type-mat-native-select .mat-form-field-infix::after{right:auto;left:0}.mat-form-field-type-mat-native-select .mat-input-element{padding-right:15px}[dir=rtl] .mat-form-field-type-mat-native-select .mat-input-element{padding-right:0;padding-left:15px}.mat-form-field-type-mat-native-select .mat-form-field-label-wrapper{max-width:calc(100% - 10px)}.mat-form-field-type-mat-native-select.mat-form-field-appearance-outline .mat-form-field-infix::after{margin-top:-5px}.mat-form-field-type-mat-native-select.mat-form-field-appearance-fill .mat-form-field-infix::after{margin-top:-10px}',".mat-form-field-appearance-legacy .mat-form-field-label{transform:perspective(100px)}.mat-form-field-appearance-legacy .mat-form-field-prefix .mat-icon,.mat-form-field-appearance-legacy .mat-form-field-suffix .mat-icon{width:1em}.mat-form-field-appearance-legacy .mat-form-field-prefix .mat-icon-button,.mat-form-field-appearance-legacy .mat-form-field-suffix .mat-icon-button{font:inherit;vertical-align:baseline}.mat-form-field-appearance-legacy .mat-form-field-prefix .mat-icon-button .mat-icon,.mat-form-field-appearance-legacy .mat-form-field-suffix .mat-icon-button .mat-icon{font-size:inherit}.mat-form-field-appearance-legacy .mat-form-field-underline{height:1px}.cdk-high-contrast-active .mat-form-field-appearance-legacy .mat-form-field-underline{height:0;border-top:solid 1px}.mat-form-field-appearance-legacy .mat-form-field-ripple{top:0;height:2px;overflow:hidden}.cdk-high-contrast-active .mat-form-field-appearance-legacy .mat-form-field-ripple{height:0;border-top:solid 2px}.mat-form-field-appearance-legacy.mat-form-field-disabled .mat-form-field-underline{background-position:0;background-color:rgba(0,0,0,0)}.cdk-high-contrast-active .mat-form-field-appearance-legacy.mat-form-field-disabled .mat-form-field-underline{border-top-style:dotted;border-top-width:2px;border-top-color:GrayText}.mat-form-field-appearance-legacy.mat-form-field-invalid:not(.mat-focused) .mat-form-field-ripple{height:1px}",".mat-form-field-appearance-outline .mat-form-field-wrapper{margin:.25em 0}.mat-form-field-appearance-outline .mat-form-field-flex{padding:0 .75em 0 .75em;margin-top:-0.25em;position:relative}.mat-form-field-appearance-outline .mat-form-field-prefix,.mat-form-field-appearance-outline .mat-form-field-suffix{top:.25em}.mat-form-field-appearance-outline .mat-form-field-outline{display:flex;position:absolute;top:.25em;left:0;right:0;bottom:0;pointer-events:none}.mat-form-field-appearance-outline .mat-form-field-outline-start,.mat-form-field-appearance-outline .mat-form-field-outline-end{border:1px solid currentColor;min-width:5px}.mat-form-field-appearance-outline .mat-form-field-outline-start{border-radius:5px 0 0 5px;border-right-style:none}[dir=rtl] .mat-form-field-appearance-outline .mat-form-field-outline-start{border-right-style:solid;border-left-style:none;border-radius:0 5px 5px 0}.mat-form-field-appearance-outline .mat-form-field-outline-end{border-radius:0 5px 5px 0;border-left-style:none;flex-grow:1}[dir=rtl] .mat-form-field-appearance-outline .mat-form-field-outline-end{border-left-style:solid;border-right-style:none;border-radius:5px 0 0 5px}.mat-form-field-appearance-outline .mat-form-field-outline-gap{border-radius:.000001px;border:1px solid currentColor;border-left-style:none;border-right-style:none}.mat-form-field-appearance-outline.mat-form-field-can-float.mat-form-field-should-float .mat-form-field-outline-gap{border-top-color:rgba(0,0,0,0)}.mat-form-field-appearance-outline .mat-form-field-outline-thick{opacity:0}.mat-form-field-appearance-outline .mat-form-field-outline-thick .mat-form-field-outline-start,.mat-form-field-appearance-outline .mat-form-field-outline-thick .mat-form-field-outline-end,.mat-form-field-appearance-outline .mat-form-field-outline-thick .mat-form-field-outline-gap{border-width:2px}.mat-form-field-appearance-outline.mat-focused .mat-form-field-outline,.mat-form-field-appearance-outline.mat-form-field-invalid .mat-form-field-outline{opacity:0;transition:opacity 100ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-form-field-appearance-outline.mat-focused .mat-form-field-outline-thick,.mat-form-field-appearance-outline.mat-form-field-invalid .mat-form-field-outline-thick{opacity:1}.cdk-high-contrast-active .mat-form-field-appearance-outline.mat-focused .mat-form-field-outline-thick{border:3px dashed}.mat-form-field-appearance-outline:not(.mat-form-field-disabled) .mat-form-field-flex:hover .mat-form-field-outline{opacity:0;transition:opacity 600ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-form-field-appearance-outline:not(.mat-form-field-disabled) .mat-form-field-flex:hover .mat-form-field-outline-thick{opacity:1}.mat-form-field-appearance-outline .mat-form-field-subscript-wrapper{padding:0 1em}.cdk-high-contrast-active .mat-form-field-appearance-outline.mat-form-field-disabled .mat-form-field-outline{color:GrayText}.mat-form-field-appearance-outline._mat-animation-noopable:not(.mat-form-field-disabled) .mat-form-field-flex:hover~.mat-form-field-outline,.mat-form-field-appearance-outline._mat-animation-noopable .mat-form-field-outline,.mat-form-field-appearance-outline._mat-animation-noopable .mat-form-field-outline-start,.mat-form-field-appearance-outline._mat-animation-noopable .mat-form-field-outline-end,.mat-form-field-appearance-outline._mat-animation-noopable .mat-form-field-outline-gap{transition:none}",".mat-form-field-appearance-standard .mat-form-field-flex{padding-top:.75em}.mat-form-field-appearance-standard .mat-form-field-underline{height:1px}.cdk-high-contrast-active .mat-form-field-appearance-standard .mat-form-field-underline{height:0;border-top:solid 1px}.mat-form-field-appearance-standard .mat-form-field-ripple{bottom:0;height:2px}.cdk-high-contrast-active .mat-form-field-appearance-standard .mat-form-field-ripple{height:0;border-top:solid 2px}.mat-form-field-appearance-standard.mat-form-field-disabled .mat-form-field-underline{background-position:0;background-color:rgba(0,0,0,0)}.cdk-high-contrast-active .mat-form-field-appearance-standard.mat-form-field-disabled .mat-form-field-underline{border-top-style:dotted;border-top-width:2px}.mat-form-field-appearance-standard:not(.mat-form-field-disabled) .mat-form-field-flex:hover~.mat-form-field-underline .mat-form-field-ripple{opacity:1;transform:none;transition:opacity 600ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-form-field-appearance-standard._mat-animation-noopable:not(.mat-form-field-disabled) .mat-form-field-flex:hover~.mat-form-field-underline .mat-form-field-ripple{transition:none}"],encapsulation:2,data:{animation:[X2.transitionMessages]},changeDetection:0}),n})(),S9=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275dir=xe({type:n,selectors:[["","matPrefix",""]],features:[Rt([{provide:nE,useExisting:n}])]}),n})(),Vf=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Te,Qt,Pu,Qt]}),n})(),P9=(()=>{class n{constructor(e,i){this._renderer=e,this._elementRef=i,this.onChange=r=>{},this.onTouched=()=>{}}setProperty(e,i){this._renderer.setProperty(this._elementRef.nativeElement,e,i)}registerOnTouched(e){this.onTouched=e}registerOnChange(e){this.onChange=e}setDisabledState(e){this.setProperty("disabled",e)}}return n.\u0275fac=function(e){return new(e||n)(C(dc),C(be))},n.\u0275dir=xe({type:n}),n})(),Hf=(()=>{class n extends P9{}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Cn(n)))(i||n)}}(),n.\u0275dir=xe({type:n,features:[Le]}),n})(),Hr=new ie("NgValueAccessor"),Yye={provide:Hr,useExisting:Vn(()=>Xye),multi:!0},Xye=(()=>{class n extends Hf{writeValue(e){this.setProperty("checked",e)}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Cn(n)))(i||n)}}(),n.\u0275dir=xe({type:n,selectors:[["input","type","checkbox","formControlName",""],["input","type","checkbox","formControl",""],["input","type","checkbox","ngModel",""]],hostBindings:function(e,i){1&e&&D("change",function(o){return i.onChange(o.target.checked)})("blur",function(){return i.onTouched()})},features:[Rt([Yye]),Le]}),n})(),Qye={provide:Hr,useExisting:Vn(()=>Ig),multi:!0},Kye=new ie("CompositionEventMode"),Ig=(()=>{class n extends P9{constructor(e,i,r){super(e,i),this._compositionMode=r,this._composing=!1,null==this._compositionMode&&(this._compositionMode=!function(){let n=Ml()?Ml().getUserAgent():"";return/android (\d+)/.test(n.toLowerCase())}())}writeValue(e){this.setProperty("value",e??"")}_handleInput(e){(!this._compositionMode||this._compositionMode&&!this._composing)&&this.onChange(e)}_compositionStart(){this._composing=!0}_compositionEnd(e){this._composing=!1,this._compositionMode&&this.onChange(e)}}return n.\u0275fac=function(e){return new(e||n)(C(dc),C(be),C(Kye,8))},n.\u0275dir=xe({type:n,selectors:[["input","formControlName","",3,"type","checkbox"],["textarea","formControlName",""],["input","formControl","",3,"type","checkbox"],["textarea","formControl",""],["input","ngModel","",3,"type","checkbox"],["textarea","ngModel",""],["","ngDefaultControl",""]],hostBindings:function(e,i){1&e&&D("input",function(o){return i._handleInput(o.target.value)})("blur",function(){return i.onTouched()})("compositionstart",function(){return i._compositionStart()})("compositionend",function(o){return i._compositionEnd(o.target.value)})},features:[Rt([Qye]),Le]}),n})(),Jye=!1;function Uu(n){return null==n||("string"==typeof n||Array.isArray(n))&&0===n.length}function O9(n){return null!=n&&"number"==typeof n.length}var So=new ie("NgValidators"),ju=new ie("NgAsyncValidators"),$ye=/^(?=.{1,254}$)(?=.{1,64}@)[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)*@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/,Vl=class{static min(t){return F9(t)}static max(t){return L9(t)}static required(t){return N9(t)}static requiredTrue(t){return B9(t)}static email(t){return V9(t)}static minLength(t){return H9(t)}static maxLength(t){return z9(t)}static pattern(t){return U9(t)}static nullValidator(t){return null}static compose(t){return X9(t)}static composeAsync(t){return Q9(t)}};function F9(n){return t=>{if(Uu(t.value)||Uu(n))return null;let e=parseFloat(t.value);return!isNaN(e)&&e<n?{min:{min:n,actual:t.value}}:null}}function L9(n){return t=>{if(Uu(t.value)||Uu(n))return null;let e=parseFloat(t.value);return!isNaN(e)&&e>n?{max:{max:n,actual:t.value}}:null}}function N9(n){return Uu(n.value)?{required:!0}:null}function B9(n){return!0===n.value?null:{required:!0}}function V9(n){return Uu(n.value)||$ye.test(n.value)?null:{email:!0}}function H9(n){return t=>Uu(t.value)||!O9(t.value)?null:t.value.length<n?{minlength:{requiredLength:n,actualLength:t.value.length}}:null}function z9(n){return t=>O9(t.value)&&t.value.length>n?{maxlength:{requiredLength:n,actualLength:t.value.length}}:null}function U9(n){if(!n)return rE;let t,e;return"string"==typeof n?(e="","^"!==n.charAt(0)&&(e+="^"),e+=n,"$"!==n.charAt(n.length-1)&&(e+="$"),t=new RegExp(e)):(e=n.toString(),t=n),i=>{if(Uu(i.value))return null;let r=i.value;return t.test(r)?null:{pattern:{requiredPattern:e,actualValue:r}}}}function rE(n){return null}function j9(n){return null!=n}function G9(n){let t=Th(n)?no(n):n;if(Jye&&!OP(t)){let e="Expected async validator to return Promise or Observable.";throw"object"==typeof n&&(e+=" Are you using a synchronous validator where an async validator is expected?"),new bt(-1101,e)}return t}function W9(n){let t={};return n.forEach(e=>{t=null!=e?{...t,...e}:t}),0===Object.keys(t).length?null:t}function q9(n,t){return t.map(e=>e(n))}function Y9(n){return n.map(t=>function(n){return!n.validate}(t)?t:e=>t.validate(e))}function X9(n){if(!n)return null;let t=n.filter(j9);return 0==t.length?null:function(e){return W9(q9(e,t))}}function J2(n){return null!=n?X9(Y9(n)):null}function Q9(n){if(!n)return null;let t=n.filter(j9);return 0==t.length?null:function(e){return po(q9(e,t).map(G9)).pipe(U(W9))}}function $2(n){return null!=n?Q9(Y9(n)):null}function E9(n,t){return null===n?[t]:Array.isArray(n)?[...n,t]:[n,t]}function Z9(n){return n._rawValidators}function K9(n){return n._rawAsyncValidators}function Q2(n){return n?Array.isArray(n)?n:[n]:[]}function oE(n,t){return Array.isArray(n)?n.includes(t):n===t}function T9(n,t){let e=Q2(t);return Q2(n).forEach(r=>{oE(e,r)||e.push(r)}),e}function D9(n,t){return Q2(t).filter(e=>!oE(n,e))}var aE=class{constructor(){this._rawValidators=[],this._rawAsyncValidators=[],this._onDestroyCallbacks=[]}get value(){return this.control?this.control.value:null}get valid(){return this.control?this.control.valid:null}get invalid(){return this.control?this.control.invalid:null}get pending(){return this.control?this.control.pending:null}get disabled(){return this.control?this.control.disabled:null}get enabled(){return this.control?this.control.enabled:null}get errors(){return this.control?this.control.errors:null}get pristine(){return this.control?this.control.pristine:null}get dirty(){return this.control?this.control.dirty:null}get touched(){return this.control?this.control.touched:null}get status(){return this.control?this.control.status:null}get untouched(){return this.control?this.control.untouched:null}get statusChanges(){return this.control?this.control.statusChanges:null}get valueChanges(){return this.control?this.control.valueChanges:null}get path(){return null}_setValidators(t){this._rawValidators=t||[],this._composedValidatorFn=J2(this._rawValidators)}_setAsyncValidators(t){this._rawAsyncValidators=t||[],this._composedAsyncValidatorFn=$2(this._rawAsyncValidators)}get validator(){return this._composedValidatorFn||null}get asyncValidator(){return this._composedAsyncValidatorFn||null}_registerOnDestroy(t){this._onDestroyCallbacks.push(t)}_invokeOnDestroyCallbacks(){this._onDestroyCallbacks.forEach(t=>t()),this._onDestroyCallbacks=[]}reset(t){this.control&&this.control.reset(t)}hasError(t,e){return!!this.control&&this.control.hasError(t,e)}getError(t,e){return this.control?this.control.getError(t,e):null}},$o=class extends aE{get formDirective(){return null}get path(){return null}},za=class extends aE{constructor(){super(...arguments),this._parent=null,this.name=null,this.valueAccessor=null}},Z2=class{constructor(t){this._cd=t}get isTouched(){return!!this._cd?.control?.touched}get isUntouched(){return!!this._cd?.control?.untouched}get isPristine(){return!!this._cd?.control?.pristine}get isDirty(){return!!this._cd?.control?.dirty}get isValid(){return!!this._cd?.control?.valid}get isInvalid(){return!!this._cd?.control?.invalid}get isPending(){return!!this._cd?.control?.pending}get isSubmitted(){return!!this._cd?.submitted}},pE=(()=>{class n extends Z2{constructor(e){super(e)}}return n.\u0275fac=function(e){return new(e||n)(C(za,2))},n.\u0275dir=xe({type:n,selectors:[["","formControlName",""],["","ngModel",""],["","formControl",""]],hostVars:14,hostBindings:function(e,i){2&e&&Qe("ng-untouched",i.isUntouched)("ng-touched",i.isTouched)("ng-pristine",i.isPristine)("ng-dirty",i.isDirty)("ng-valid",i.isValid)("ng-invalid",i.isInvalid)("ng-pending",i.isPending)},features:[Le]}),n})();function J9(n,t){return n?`with name: '${t}'`:`at index: ${t}`}var K2=!1,$b="VALID",iE="INVALID",Dg="PENDING",ev="DISABLED";function $9(n){return(fE(n)?n.validators:n)||null}function eq(n,t){return(fE(t)?t.asyncValidators:n)||null}function fE(n){return null!=n&&!Array.isArray(n)&&"object"==typeof n}var sE=class{constructor(t,e){this._pendingDirty=!1,this._hasOwnPendingAsyncValidator=!1,this._pendingTouched=!1,this._onCollectionChange=()=>{},this._parent=null,this.pristine=!0,this.touched=!1,this._onDisabledChange=[],this._assignValidators(t),this._assignAsyncValidators(e)}get validator(){return this._composedValidatorFn}set validator(t){this._rawValidators=this._composedValidatorFn=t}get asyncValidator(){return this._composedAsyncValidatorFn}set asyncValidator(t){this._rawAsyncValidators=this._composedAsyncValidatorFn=t}get parent(){return this._parent}get valid(){return this.status===$b}get invalid(){return this.status===iE}get pending(){return this.status==Dg}get disabled(){return this.status===ev}get enabled(){return this.status!==ev}get dirty(){return!this.pristine}get untouched(){return!this.touched}get updateOn(){return this._updateOn?this._updateOn:this.parent?this.parent.updateOn:"change"}setValidators(t){this._assignValidators(t)}setAsyncValidators(t){this._assignAsyncValidators(t)}addValidators(t){this.setValidators(T9(t,this._rawValidators))}addAsyncValidators(t){this.setAsyncValidators(T9(t,this._rawAsyncValidators))}removeValidators(t){this.setValidators(D9(t,this._rawValidators))}removeAsyncValidators(t){this.setAsyncValidators(D9(t,this._rawAsyncValidators))}hasValidator(t){return oE(this._rawValidators,t)}hasAsyncValidator(t){return oE(this._rawAsyncValidators,t)}clearValidators(){this.validator=null}clearAsyncValidators(){this.asyncValidator=null}markAsTouched(t={}){this.touched=!0,this._parent&&!t.onlySelf&&this._parent.markAsTouched(t)}markAllAsTouched(){this.markAsTouched({onlySelf:!0}),this._forEachChild(t=>t.markAllAsTouched())}markAsUntouched(t={}){this.touched=!1,this._pendingTouched=!1,this._forEachChild(e=>{e.markAsUntouched({onlySelf:!0})}),this._parent&&!t.onlySelf&&this._parent._updateTouched(t)}markAsDirty(t={}){this.pristine=!1,this._parent&&!t.onlySelf&&this._parent.markAsDirty(t)}markAsPristine(t={}){this.pristine=!0,this._pendingDirty=!1,this._forEachChild(e=>{e.markAsPristine({onlySelf:!0})}),this._parent&&!t.onlySelf&&this._parent._updatePristine(t)}markAsPending(t={}){this.status=Dg,!1!==t.emitEvent&&this.statusChanges.emit(this.status),this._parent&&!t.onlySelf&&this._parent.markAsPending(t)}disable(t={}){let e=this._parentMarkedDirty(t.onlySelf);this.status=ev,this.errors=null,this._forEachChild(i=>{i.disable({...t,onlySelf:!0})}),this._updateValue(),!1!==t.emitEvent&&(this.valueChanges.emit(this.value),this.statusChanges.emit(this.status)),this._updateAncestors({...t,skipPristineCheck:e}),this._onDisabledChange.forEach(i=>i(!0))}enable(t={}){let e=this._parentMarkedDirty(t.onlySelf);this.status=$b,this._forEachChild(i=>{i.enable({...t,onlySelf:!0})}),this.updateValueAndValidity({onlySelf:!0,emitEvent:t.emitEvent}),this._updateAncestors({...t,skipPristineCheck:e}),this._onDisabledChange.forEach(i=>i(!1))}_updateAncestors(t){this._parent&&!t.onlySelf&&(this._parent.updateValueAndValidity(t),t.skipPristineCheck||this._parent._updatePristine(),this._parent._updateTouched())}setParent(t){this._parent=t}getRawValue(){return this.value}updateValueAndValidity(t={}){this._setInitialStatus(),this._updateValue(),this.enabled&&(this._cancelExistingSubscription(),this.errors=this._runValidator(),this.status=this._calculateStatus(),(this.status===$b||this.status===Dg)&&this._runAsyncValidator(t.emitEvent)),!1!==t.emitEvent&&(this.valueChanges.emit(this.value),this.statusChanges.emit(this.status)),this._parent&&!t.onlySelf&&this._parent.updateValueAndValidity(t)}_updateTreeValidity(t={emitEvent:!0}){this._forEachChild(e=>e._updateTreeValidity(t)),this.updateValueAndValidity({onlySelf:!0,emitEvent:t.emitEvent})}_setInitialStatus(){this.status=this._allControlsDisabled()?ev:$b}_runValidator(){return this.validator?this.validator(this):null}_runAsyncValidator(t){if(this.asyncValidator){this.status=Dg,this._hasOwnPendingAsyncValidator=!0;let e=G9(this.asyncValidator(this));this._asyncValidationSubscription=e.subscribe(i=>{this._hasOwnPendingAsyncValidator=!1,this.setErrors(i,{emitEvent:t})})}}_cancelExistingSubscription(){this._asyncValidationSubscription&&(this._asyncValidationSubscription.unsubscribe(),this._hasOwnPendingAsyncValidator=!1)}setErrors(t,e={}){this.errors=t,this._updateControlsErrors(!1!==e.emitEvent)}get(t){let e=t;return null==e||(Array.isArray(e)||(e=e.split(".")),0===e.length)?null:e.reduce((i,r)=>i&&i._find(r),this)}getError(t,e){let i=e?this.get(e):this;return i&&i.errors?i.errors[t]:null}hasError(t,e){return!!this.getError(t,e)}get root(){let t=this;for(;t._parent;)t=t._parent;return t}_updateControlsErrors(t){this.status=this._calculateStatus(),t&&this.statusChanges.emit(this.status),this._parent&&this._parent._updateControlsErrors(t)}_initObservables(){this.valueChanges=new L,this.statusChanges=new L}_calculateStatus(){return this._allControlsDisabled()?ev:this.errors?iE:this._hasOwnPendingAsyncValidator||this._anyControlsHaveStatus(Dg)?Dg:this._anyControlsHaveStatus(iE)?iE:$b}_anyControlsHaveStatus(t){return this._anyControls(e=>e.status===t)}_anyControlsDirty(){return this._anyControls(t=>t.dirty)}_anyControlsTouched(){return this._anyControls(t=>t.touched)}_updatePristine(t={}){this.pristine=!this._anyControlsDirty(),this._parent&&!t.onlySelf&&this._parent._updatePristine(t)}_updateTouched(t={}){this.touched=this._anyControlsTouched(),this._parent&&!t.onlySelf&&this._parent._updateTouched(t)}_registerOnCollectionChange(t){this._onCollectionChange=t}_setUpdateStrategy(t){fE(t)&&null!=t.updateOn&&(this._updateOn=t.updateOn)}_parentMarkedDirty(t){return!t&&!(!this._parent||!this._parent.dirty)&&!this._parent._anyControlsDirty()}_find(t){return null}_assignValidators(t){this._rawValidators=Array.isArray(t)?t.slice():t,this._composedValidatorFn=function(n){return Array.isArray(n)?J2(n):n||null}(this._rawValidators)}_assignAsyncValidators(t){this._rawAsyncValidators=Array.isArray(t)?t.slice():t,this._composedAsyncValidatorFn=function(n){return Array.isArray(n)?$2(n):n||null}(this._rawAsyncValidators)}},lE=class extends sE{constructor(t,e,i){super($9(e),eq(i,e)),this.controls=t,this._initObservables(),this._setUpdateStrategy(e),this._setUpControls(),this.updateValueAndValidity({onlySelf:!0,emitEvent:!!this.asyncValidator})}registerControl(t,e){return this.controls[t]?this.controls[t]:(this.controls[t]=e,e.setParent(this),e._registerOnCollectionChange(this._onCollectionChange),e)}addControl(t,e,i={}){this.registerControl(t,e),this.updateValueAndValidity({emitEvent:i.emitEvent}),this._onCollectionChange()}removeControl(t,e={}){this.controls[t]&&this.controls[t]._registerOnCollectionChange(()=>{}),delete this.controls[t],this.updateValueAndValidity({emitEvent:e.emitEvent}),this._onCollectionChange()}setControl(t,e,i={}){this.controls[t]&&this.controls[t]._registerOnCollectionChange(()=>{}),delete this.controls[t],e&&this.registerControl(t,e),this.updateValueAndValidity({emitEvent:i.emitEvent}),this._onCollectionChange()}contains(t){return this.controls.hasOwnProperty(t)&&this.controls[t].enabled}setValue(t,e={}){(function(n,t,e){n._forEachChild((i,r)=>{if(void 0===e[r])throw new bt(1002,K2?function(n,t){return`Must supply a value for form control ${J9(n,t)}`}(t,r):"")})})(this,!0,t),Object.keys(t).forEach(i=>{(function(n,t,e){let i=n.controls;if(!(t?Object.keys(i):i).length)throw new bt(1e3,K2?function(n){return`\n    There are no form controls registered with this ${n?"group":"array"} yet. If you're using ngModel,\n    you may want to check next tick (e.g. use setTimeout).\n  `}(t):"");if(!i[e])throw new bt(1001,K2?function(n,t){return`Cannot find form control ${J9(n,t)}`}(t,e):"")})(this,!0,i),this.controls[i].setValue(t[i],{onlySelf:!0,emitEvent:e.emitEvent})}),this.updateValueAndValidity(e)}patchValue(t,e={}){null!=t&&(Object.keys(t).forEach(i=>{let r=this.controls[i];r&&r.patchValue(t[i],{onlySelf:!0,emitEvent:e.emitEvent})}),this.updateValueAndValidity(e))}reset(t={},e={}){this._forEachChild((i,r)=>{i.reset(t[r],{onlySelf:!0,emitEvent:e.emitEvent})}),this._updatePristine(e),this._updateTouched(e),this.updateValueAndValidity(e)}getRawValue(){return this._reduceChildren({},(t,e,i)=>(t[i]=e.getRawValue(),t))}_syncPendingControls(){let t=this._reduceChildren(!1,(e,i)=>!!i._syncPendingControls()||e);return t&&this.updateValueAndValidity({onlySelf:!0}),t}_forEachChild(t){Object.keys(this.controls).forEach(e=>{let i=this.controls[e];i&&t(i,e)})}_setUpControls(){this._forEachChild(t=>{t.setParent(this),t._registerOnCollectionChange(this._onCollectionChange)})}_updateValue(){this.value=this._reduceValue()}_anyControls(t){for(let[e,i]of Object.entries(this.controls))if(this.contains(e)&&t(i))return!0;return!1}_reduceValue(){return this._reduceChildren({},(e,i,r)=>((i.enabled||this.disabled)&&(e[r]=i.value),e))}_reduceChildren(t,e){let i=t;return this._forEachChild((r,o)=>{i=e(i,r,o)}),i}_allControlsDisabled(){for(let t of Object.keys(this.controls))if(this.controls[t].enabled)return!1;return Object.keys(this.controls).length>0||this.disabled}_find(t){return this.controls.hasOwnProperty(t)?this.controls[t]:null}},zf=new ie("CallSetDisabledState",{providedIn:"root",factory:()=>iv}),iv="always";function mE(n,t){return[...t.path,n]}function nv(n,t,e=iv){eL(n,t),t.valueAccessor.writeValue(n.value),(n.disabled||"always"===e)&&t.valueAccessor.setDisabledState?.(n.disabled),function(n,t){t.valueAccessor.registerOnChange(e=>{n._pendingValue=e,n._pendingChange=!0,n._pendingDirty=!0,"change"===n.updateOn&&tq(n,t)})}(n,t),function(n,t){let e=(i,r)=>{t.valueAccessor.writeValue(i),r&&t.viewToModelUpdate(i)};n.registerOnChange(e),t._registerOnDestroy(()=>{n._unregisterOnChange(e)})}(n,t),function(n,t){t.valueAccessor.registerOnTouched(()=>{n._pendingTouched=!0,"blur"===n.updateOn&&n._pendingChange&&tq(n,t),"submit"!==n.updateOn&&n.markAsTouched()})}(n,t),function(n,t){if(t.valueAccessor.setDisabledState){let e=i=>{t.valueAccessor.setDisabledState(i)};n.registerOnDisabledChange(e),t._registerOnDestroy(()=>{n._unregisterOnDisabledChange(e)})}}(n,t)}function cE(n,t,e=!0){let i=()=>{};t.valueAccessor&&(t.valueAccessor.registerOnChange(i),t.valueAccessor.registerOnTouched(i)),uE(n,t),n&&(t._invokeOnDestroyCallbacks(),n._registerOnCollectionChange(()=>{}))}function dE(n,t){n.forEach(e=>{e.registerOnValidatorChange&&e.registerOnValidatorChange(t)})}function eL(n,t){let e=Z9(n);null!==t.validator?n.setValidators(E9(e,t.validator)):"function"==typeof e&&n.setValidators([e]);let i=K9(n);null!==t.asyncValidator?n.setAsyncValidators(E9(i,t.asyncValidator)):"function"==typeof i&&n.setAsyncValidators([i]);let r=()=>n.updateValueAndValidity();dE(t._rawValidators,r),dE(t._rawAsyncValidators,r)}function uE(n,t){let e=!1;if(null!==n){if(null!==t.validator){let r=Z9(n);if(Array.isArray(r)&&r.length>0){let o=r.filter(a=>a!==t.validator);o.length!==r.length&&(e=!0,n.setValidators(o))}}if(null!==t.asyncValidator){let r=K9(n);if(Array.isArray(r)&&r.length>0){let o=r.filter(a=>a!==t.asyncValidator);o.length!==r.length&&(e=!0,n.setAsyncValidators(o))}}}let i=()=>{};return dE(t._rawValidators,i),dE(t._rawAsyncValidators,i),e}function tq(n,t){n._pendingDirty&&n.markAsDirty(),n.setValue(n._pendingValue,{emitModelToViewChange:!1}),t.viewToModelUpdate(n._pendingValue),n._pendingChange=!1}function nq(n,t){eL(n,t)}function tL(n,t){if(!n.hasOwnProperty("model"))return!1;let e=n.model;return!!e.isFirstChange()||!Object.is(t,e.currentValue)}function iq(n,t){n._syncPendingControls(),t.forEach(e=>{let i=e.control;"submit"===i.updateOn&&i._pendingChange&&(e.viewToModelUpdate(i._pendingValue),i._pendingChange=!1)})}function nL(n,t){if(!t)return null;let e,i,r;return Array.isArray(t),t.forEach(o=>{o.constructor===Ig?e=o:function(n){return Object.getPrototypeOf(n.constructor)===Hf}(o)?i=o:r=o}),r||i||e||null}var gbe={provide:$o,useExisting:Vn(()=>Ag)},tv=Promise.resolve(),Ag=(()=>{class n extends $o{constructor(e,i,r){super(),this.callSetDisabledState=r,this.submitted=!1,this._directives=new Set,this.ngSubmit=new L,this.form=new lE({},J2(e),$2(i))}ngAfterViewInit(){this._setUpdateStrategy()}get formDirective(){return this}get control(){return this.form}get path(){return[]}get controls(){return this.form.controls}addControl(e){tv.then(()=>{let i=this._findContainer(e.path);e.control=i.registerControl(e.name,e.control),nv(e.control,e,this.callSetDisabledState),e.control.updateValueAndValidity({emitEvent:!1}),this._directives.add(e)})}getControl(e){return this.form.get(e.path)}removeControl(e){tv.then(()=>{let i=this._findContainer(e.path);i&&i.removeControl(e.name),this._directives.delete(e)})}addFormGroup(e){tv.then(()=>{let i=this._findContainer(e.path),r=new lE({});nq(r,e),i.registerControl(e.name,r),r.updateValueAndValidity({emitEvent:!1})})}removeFormGroup(e){tv.then(()=>{let i=this._findContainer(e.path);i&&i.removeControl(e.name)})}getFormGroup(e){return this.form.get(e.path)}updateModel(e,i){tv.then(()=>{this.form.get(e.path).setValue(i)})}setValue(e){this.control.setValue(e)}onSubmit(e){return this.submitted=!0,iq(this.form,this._directives),this.ngSubmit.emit(e),"dialog"===e?.target?.method}onReset(){this.resetForm()}resetForm(e){this.form.reset(e),this.submitted=!1}_setUpdateStrategy(){this.options&&null!=this.options.updateOn&&(this.form._updateOn=this.options.updateOn)}_findContainer(e){return e.pop(),e.length?this.form.get(e):this.form}}return n.\u0275fac=function(e){return new(e||n)(C(So,10),C(ju,10),C(zf,8))},n.\u0275dir=xe({type:n,selectors:[["form",3,"ngNoForm","",3,"formGroup",""],["ng-form"],["","ngForm",""]],hostBindings:function(e,i){1&e&&D("submit",function(o){return i.onSubmit(o)})("reset",function(){return i.onReset()})},inputs:{options:["ngFormOptions","options"]},outputs:{ngSubmit:"ngSubmit"},exportAs:["ngForm"],features:[Rt([gbe]),Le]}),n})();function I9(n,t){let e=n.indexOf(t);e>-1&&n.splice(e,1)}function A9(n){return"object"==typeof n&&null!==n&&2===Object.keys(n).length&&"value"in n&&"disabled"in n}var rv=class extends sE{constructor(t=null,e,i){super($9(e),eq(i,e)),this.defaultValue=null,this._onChange=[],this._pendingChange=!1,this._applyFormState(t),this._setUpdateStrategy(e),this._initObservables(),this.updateValueAndValidity({onlySelf:!0,emitEvent:!!this.asyncValidator}),fE(e)&&(e.nonNullable||e.initialValueIsDefault)&&(this.defaultValue=A9(t)?t.value:t)}setValue(t,e={}){this.value=this._pendingValue=t,this._onChange.length&&!1!==e.emitModelToViewChange&&this._onChange.forEach(i=>i(this.value,!1!==e.emitViewToModelChange)),this.updateValueAndValidity(e)}patchValue(t,e={}){this.setValue(t,e)}reset(t=this.defaultValue,e={}){this._applyFormState(t),this.markAsPristine(e),this.markAsUntouched(e),this.setValue(this.value,e),this._pendingChange=!1}_updateValue(){}_anyControls(t){return!1}_allControlsDisabled(){return this.disabled}registerOnChange(t){this._onChange.push(t)}_unregisterOnChange(t){I9(this._onChange,t)}registerOnDisabledChange(t){this._onDisabledChange.push(t)}_unregisterOnDisabledChange(t){I9(this._onDisabledChange,t)}_forEachChild(t){}_syncPendingControls(){return!("submit"!==this.updateOn||(this._pendingDirty&&this.markAsDirty(),this._pendingTouched&&this.markAsTouched(),!this._pendingChange)||(this.setValue(this._pendingValue,{onlySelf:!0,emitModelToViewChange:!1}),0))}_applyFormState(t){A9(t)?(this.value=this._pendingValue=t.value,t.disabled?this.disable({onlySelf:!0,emitEvent:!1}):this.enable({onlySelf:!0,emitEvent:!1})):this.value=this._pendingValue=t}},rq=(()=>{class n extends $o{ngOnInit(){this._checkParentType(),this.formDirective.addFormGroup(this)}ngOnDestroy(){this.formDirective&&this.formDirective.removeFormGroup(this)}get control(){return this.formDirective.getFormGroup(this)}get path(){return mE(null==this.name?this.name:this.name.toString(),this._parent)}get formDirective(){return this._parent?this._parent.formDirective:null}_checkParentType(){}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Cn(n)))(i||n)}}(),n.\u0275dir=xe({type:n,features:[Le]}),n})(),ybe={provide:$o,useExisting:Vn(()=>bbe)},bbe=(()=>{class n extends rq{constructor(e,i,r){super(),this._parent=e,this._setValidators(i),this._setAsyncValidators(r)}_checkParentType(){}}return n.\u0275fac=function(e){return new(e||n)(C($o,5),C(So,10),C(ju,10))},n.\u0275dir=xe({type:n,selectors:[["","ngModelGroup",""]],inputs:{name:["ngModelGroup","name"]},exportAs:["ngModelGroup"],features:[Rt([ybe]),Le]}),n})(),vbe={provide:za,useExisting:Vn(()=>iL)},R9=Promise.resolve(),iL=(()=>{class n extends za{constructor(e,i,r,o,a,s){super(),this._changeDetectorRef=a,this.callSetDisabledState=s,this.control=new rv,this._registered=!1,this.update=new L,this._parent=e,this._setValidators(i),this._setAsyncValidators(r),this.valueAccessor=nL(0,o)}ngOnChanges(e){if(this._checkForErrors(),!this._registered||"name"in e){if(this._registered&&(this._checkName(),this.formDirective)){let i=e.name.previousValue;this.formDirective.removeControl({name:i,path:this._getPath(i)})}this._setUpControl()}"isDisabled"in e&&this._updateDisabled(e),tL(e,this.viewModel)&&(this._updateValue(this.model),this.viewModel=this.model)}ngOnDestroy(){this.formDirective&&this.formDirective.removeControl(this)}get path(){return this._getPath(this.name)}get formDirective(){return this._parent?this._parent.formDirective:null}viewToModelUpdate(e){this.viewModel=e,this.update.emit(e)}_setUpControl(){this._setUpdateStrategy(),this._isStandalone()?this._setUpStandalone():this.formDirective.addControl(this),this._registered=!0}_setUpdateStrategy(){this.options&&null!=this.options.updateOn&&(this.control._updateOn=this.options.updateOn)}_isStandalone(){return!this._parent||!(!this.options||!this.options.standalone)}_setUpStandalone(){nv(this.control,this,this.callSetDisabledState),this.control.updateValueAndValidity({emitEvent:!1})}_checkForErrors(){this._isStandalone()||this._checkParentType(),this._checkName()}_checkParentType(){}_checkName(){this.options&&this.options.name&&(this.name=this.options.name),this._isStandalone()}_updateValue(e){R9.then(()=>{this.control.setValue(e,{emitViewToModelChange:!1}),this._changeDetectorRef?.markForCheck()})}_updateDisabled(e){let i=e.isDisabled.currentValue,r=0!==i&&nw(i);R9.then(()=>{r&&!this.control.disabled?this.control.disable():!r&&this.control.disabled&&this.control.enable(),this._changeDetectorRef?.markForCheck()})}_getPath(e){return this._parent?mE(e,this._parent):[e]}}return n.\u0275fac=function(e){return new(e||n)(C($o,9),C(So,10),C(ju,10),C(Hr,10),C(Ft,8),C(zf,8))},n.\u0275dir=xe({type:n,selectors:[["","ngModel","",3,"formControlName","",3,"formControl",""]],inputs:{name:"name",isDisabled:["disabled","isDisabled"],model:["ngModel","model"],options:["ngModelOptions","options"]},outputs:{update:"ngModelChange"},exportAs:["ngModel"],features:[Rt([vbe]),Le,Gt]}),n})(),xbe={provide:Hr,useExisting:Vn(()=>rL),multi:!0},rL=(()=>{class n extends Hf{writeValue(e){this.setProperty("value",e??"")}registerOnChange(e){this.onChange=i=>{e(""==i?null:parseFloat(i))}}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Cn(n)))(i||n)}}(),n.\u0275dir=xe({type:n,selectors:[["input","type","number","formControlName",""],["input","type","number","formControl",""],["input","type","number","ngModel",""]],hostBindings:function(e,i){1&e&&D("input",function(o){return i.onChange(o.target.value)})("blur",function(){return i.onTouched()})},features:[Rt([xbe]),Le]}),n})(),Cbe={provide:Hr,useExisting:Vn(()=>wbe),multi:!0},oq=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({}),n})(),Mbe=(()=>{class n{constructor(){this._accessors=[]}add(e,i){this._accessors.push([e,i])}remove(e){for(let i=this._accessors.length-1;i>=0;--i)if(this._accessors[i][1]===e)return void this._accessors.splice(i,1)}select(e){this._accessors.forEach(i=>{this._isSameGroup(i,e)&&i[1]!==e&&i[1].fireUncheck(e.value)})}_isSameGroup(e,i){return!!e[0].control&&e[0]._parent===i._control._parent&&e[1].name===i.name}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=pe({token:n,factory:n.\u0275fac,providedIn:oq}),n})(),wbe=(()=>{class n extends Hf{constructor(e,i,r,o){super(e,i),this._registry=r,this._injector=o,this.setDisabledStateFired=!1,this.onChange=()=>{},this.callSetDisabledState=pi(zf,{optional:!0})??iv}ngOnInit(){this._control=this._injector.get(za),this._checkName(),this._registry.add(this._control,this)}ngOnDestroy(){this._registry.remove(this)}writeValue(e){this._state=e===this.value,this.setProperty("checked",this._state)}registerOnChange(e){this._fn=e,this.onChange=()=>{e(this.value),this._registry.select(this)}}setDisabledState(e){(this.setDisabledStateFired||e||"whenDisabledForLegacyCode"===this.callSetDisabledState)&&this.setProperty("disabled",e),this.setDisabledStateFired=!0}fireUncheck(e){this.writeValue(e)}_checkName(){!this.name&&this.formControlName&&(this.name=this.formControlName)}}return n.\u0275fac=function(e){return new(e||n)(C(dc),C(be),C(Mbe),C(bi))},n.\u0275dir=xe({type:n,selectors:[["input","type","radio","formControlName",""],["input","type","radio","formControl",""],["input","type","radio","ngModel",""]],hostBindings:function(e,i){1&e&&D("change",function(){return i.onChange()})("blur",function(){return i.onTouched()})},inputs:{name:"name",formControlName:"formControlName",value:"value"},features:[Rt([Cbe]),Le]}),n})(),Sbe={provide:Hr,useExisting:Vn(()=>Ebe),multi:!0},Ebe=(()=>{class n extends Hf{writeValue(e){this.setProperty("value",parseFloat(e))}registerOnChange(e){this.onChange=i=>{e(""==i?null:parseFloat(i))}}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Cn(n)))(i||n)}}(),n.\u0275dir=xe({type:n,selectors:[["input","type","range","formControlName",""],["input","type","range","formControl",""],["input","type","range","ngModel",""]],hostBindings:function(e,i){1&e&&D("change",function(o){return i.onChange(o.target.value)})("input",function(o){return i.onChange(o.target.value)})("blur",function(){return i.onTouched()})},features:[Rt([Sbe]),Le]}),n})(),oL=new ie("NgModelWithFormControlWarning"),Tbe={provide:za,useExisting:Vn(()=>aL)},aL=(()=>{class n extends za{set isDisabled(e){}constructor(e,i,r,o,a){super(),this._ngModelWarningConfig=o,this.callSetDisabledState=a,this.update=new L,this._ngModelWarningSent=!1,this._setValidators(e),this._setAsyncValidators(i),this.valueAccessor=nL(0,r)}ngOnChanges(e){if(this._isControlChanged(e)){let i=e.form.previousValue;i&&cE(i,this,!1),nv(this.form,this,this.callSetDisabledState),this.form.updateValueAndValidity({emitEvent:!1})}tL(e,this.viewModel)&&(this.form.setValue(this.model),this.viewModel=this.model)}ngOnDestroy(){this.form&&cE(this.form,this,!1)}get path(){return[]}get control(){return this.form}viewToModelUpdate(e){this.viewModel=e,this.update.emit(e)}_isControlChanged(e){return e.hasOwnProperty("form")}}return n._ngModelWarningSentOnce=!1,n.\u0275fac=function(e){return new(e||n)(C(So,10),C(ju,10),C(Hr,10),C(oL,8),C(zf,8))},n.\u0275dir=xe({type:n,selectors:[["","formControl",""]],inputs:{form:["formControl","form"],isDisabled:["disabled","isDisabled"],model:["ngModel","model"]},outputs:{update:"ngModelChange"},exportAs:["ngForm"],features:[Rt([Tbe]),Le,Gt]}),n})(),Dbe={provide:$o,useExisting:Vn(()=>Rg)},Rg=(()=>{class n extends $o{constructor(e,i,r){super(),this.callSetDisabledState=r,this.submitted=!1,this._onCollectionChange=()=>this._updateDomValue(),this.directives=[],this.form=null,this.ngSubmit=new L,this._setValidators(e),this._setAsyncValidators(i)}ngOnChanges(e){this._checkFormPresent(),e.hasOwnProperty("form")&&(this._updateValidators(),this._updateDomValue(),this._updateRegistrations(),this._oldForm=this.form)}ngOnDestroy(){this.form&&(uE(this.form,this),this.form._onCollectionChange===this._onCollectionChange&&this.form._registerOnCollectionChange(()=>{}))}get formDirective(){return this}get control(){return this.form}get path(){return[]}addControl(e){let i=this.form.get(e.path);return nv(i,e,this.callSetDisabledState),i.updateValueAndValidity({emitEvent:!1}),this.directives.push(e),i}getControl(e){return this.form.get(e.path)}removeControl(e){cE(e.control||null,e,!1),function(n,t){let e=n.indexOf(t);e>-1&&n.splice(e,1)}(this.directives,e)}addFormGroup(e){this._setUpFormContainer(e)}removeFormGroup(e){this._cleanUpFormContainer(e)}getFormGroup(e){return this.form.get(e.path)}addFormArray(e){this._setUpFormContainer(e)}removeFormArray(e){this._cleanUpFormContainer(e)}getFormArray(e){return this.form.get(e.path)}updateModel(e,i){this.form.get(e.path).setValue(i)}onSubmit(e){return this.submitted=!0,iq(this.form,this.directives),this.ngSubmit.emit(e),"dialog"===e?.target?.method}onReset(){this.resetForm()}resetForm(e){this.form.reset(e),this.submitted=!1}_updateDomValue(){this.directives.forEach(e=>{let i=e.control,r=this.form.get(e.path);i!==r&&(cE(i||null,e),(n=>n instanceof rv)(r)&&(nv(r,e,this.callSetDisabledState),e.control=r))}),this.form._updateTreeValidity({emitEvent:!1})}_setUpFormContainer(e){let i=this.form.get(e.path);nq(i,e),i.updateValueAndValidity({emitEvent:!1})}_cleanUpFormContainer(e){if(this.form){let i=this.form.get(e.path);i&&function(n,t){return uE(n,t)}(i,e)&&i.updateValueAndValidity({emitEvent:!1})}}_updateRegistrations(){this.form._registerOnCollectionChange(this._onCollectionChange),this._oldForm&&this._oldForm._registerOnCollectionChange(()=>{})}_updateValidators(){eL(this.form,this),this._oldForm&&uE(this._oldForm,this)}_checkFormPresent(){}}return n.\u0275fac=function(e){return new(e||n)(C(So,10),C(ju,10),C(zf,8))},n.\u0275dir=xe({type:n,selectors:[["","formGroup",""]],hostBindings:function(e,i){1&e&&D("submit",function(o){return i.onSubmit(o)})("reset",function(){return i.onReset()})},inputs:{form:["formGroup","form"]},outputs:{ngSubmit:"ngSubmit"},exportAs:["ngForm"],features:[Rt([Dbe]),Le,Gt]}),n})(),Ibe={provide:$o,useExisting:Vn(()=>aq)},aq=(()=>{class n extends rq{constructor(e,i,r){super(),this._parent=e,this._setValidators(i),this._setAsyncValidators(r)}_checkParentType(){lq(this._parent)}}return n.\u0275fac=function(e){return new(e||n)(C($o,13),C(So,10),C(ju,10))},n.\u0275dir=xe({type:n,selectors:[["","formGroupName",""]],inputs:{name:["formGroupName","name"]},features:[Rt([Ibe]),Le]}),n})(),Abe={provide:$o,useExisting:Vn(()=>sq)},sq=(()=>{class n extends $o{constructor(e,i,r){super(),this._parent=e,this._setValidators(i),this._setAsyncValidators(r)}ngOnInit(){this._checkParentType(),this.formDirective.addFormArray(this)}ngOnDestroy(){this.formDirective&&this.formDirective.removeFormArray(this)}get control(){return this.formDirective.getFormArray(this)}get formDirective(){return this._parent?this._parent.formDirective:null}get path(){return mE(null==this.name?this.name:this.name.toString(),this._parent)}_checkParentType(){lq(this._parent)}}return n.\u0275fac=function(e){return new(e||n)(C($o,13),C(So,10),C(ju,10))},n.\u0275dir=xe({type:n,selectors:[["","formArrayName",""]],inputs:{name:["formArrayName","name"]},features:[Rt([Abe]),Le]}),n})();function lq(n){return!(n instanceof aq||n instanceof Rg||n instanceof sq)}var Rbe={provide:za,useExisting:Vn(()=>kbe)},kbe=(()=>{class n extends za{set isDisabled(e){}constructor(e,i,r,o,a){super(),this._ngModelWarningConfig=a,this._added=!1,this.update=new L,this._ngModelWarningSent=!1,this._parent=e,this._setValidators(i),this._setAsyncValidators(r),this.valueAccessor=nL(0,o)}ngOnChanges(e){this._added||this._setUpControl(),tL(e,this.viewModel)&&(this.viewModel=this.model,this.formDirective.updateModel(this,this.model))}ngOnDestroy(){this.formDirective&&this.formDirective.removeControl(this)}viewToModelUpdate(e){this.viewModel=e,this.update.emit(e)}get path(){return mE(null==this.name?this.name:this.name.toString(),this._parent)}get formDirective(){return this._parent?this._parent.formDirective:null}_checkParentType(){}_setUpControl(){this._checkParentType(),this.control=this.formDirective.addControl(this),this._added=!0}}return n._ngModelWarningSentOnce=!1,n.\u0275fac=function(e){return new(e||n)(C($o,13),C(So,10),C(ju,10),C(Hr,10),C(oL,8))},n.\u0275dir=xe({type:n,selectors:[["","formControlName",""]],inputs:{name:["formControlName","name"],isDisabled:["disabled","isDisabled"],model:["ngModel","model"]},outputs:{update:"ngModelChange"},features:[Rt([Rbe]),Le,Gt]}),n})(),Pbe={provide:Hr,useExisting:Vn(()=>dq),multi:!0};function cq(n,t){return null==n?`${t}`:(t&&"object"==typeof t&&(t="Object"),`${n}: ${t}`.slice(0,50))}var dq=(()=>{class n extends Hf{constructor(){super(...arguments),this._optionMap=new Map,this._idCounter=0,this._compareWith=Object.is}set compareWith(e){this._compareWith=e}writeValue(e){this.value=e;let r=cq(this._getOptionId(e),e);this.setProperty("value",r)}registerOnChange(e){this.onChange=i=>{this.value=this._getOptionValue(i),e(this.value)}}_registerOption(){return(this._idCounter++).toString()}_getOptionId(e){for(let i of Array.from(this._optionMap.keys()))if(this._compareWith(this._optionMap.get(i),e))return i;return null}_getOptionValue(e){let i=function(n){return n.split(":")[0]}(e);return this._optionMap.has(i)?this._optionMap.get(i):e}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Cn(n)))(i||n)}}(),n.\u0275dir=xe({type:n,selectors:[["select","formControlName","",3,"multiple",""],["select","formControl","",3,"multiple",""],["select","ngModel","",3,"multiple",""]],hostBindings:function(e,i){1&e&&D("change",function(o){return i.onChange(o.target.value)})("blur",function(){return i.onTouched()})},inputs:{compareWith:"compareWith"},features:[Rt([Pbe]),Le]}),n})(),uq=(()=>{class n{constructor(e,i,r){this._element=e,this._renderer=i,this._select=r,this._select&&(this.id=this._select._registerOption())}set ngValue(e){null!=this._select&&(this._select._optionMap.set(this.id,e),this._setElementValue(cq(this.id,e)),this._select.writeValue(this._select.value))}set value(e){this._setElementValue(e),this._select&&this._select.writeValue(this._select.value)}_setElementValue(e){this._renderer.setProperty(this._element.nativeElement,"value",e)}ngOnDestroy(){this._select&&(this._select._optionMap.delete(this.id),this._select.writeValue(this._select.value))}}return n.\u0275fac=function(e){return new(e||n)(C(be),C(dc),C(dq,9))},n.\u0275dir=xe({type:n,selectors:[["option"]],inputs:{ngValue:"ngValue",value:"value"}}),n})(),Fbe={provide:Hr,useExisting:Vn(()=>pq),multi:!0};function k9(n,t){return null==n?`${t}`:("string"==typeof t&&(t=`'${t}'`),t&&"object"==typeof t&&(t="Object"),`${n}: ${t}`.slice(0,50))}var pq=(()=>{class n extends Hf{constructor(){super(...arguments),this._optionMap=new Map,this._idCounter=0,this._compareWith=Object.is}set compareWith(e){this._compareWith=e}writeValue(e){let i;if(this.value=e,Array.isArray(e)){let r=e.map(o=>this._getOptionId(o));i=(o,a)=>{o._setSelected(r.indexOf(a.toString())>-1)}}else i=(r,o)=>{r._setSelected(!1)};this._optionMap.forEach(i)}registerOnChange(e){this.onChange=i=>{let r=[],o=i.selectedOptions;if(void 0!==o){let a=o;for(let s=0;s<a.length;s++){let c=this._getOptionValue(a[s].value);r.push(c)}}else{let a=i.options;for(let s=0;s<a.length;s++){let l=a[s];if(l.selected){let c=this._getOptionValue(l.value);r.push(c)}}}this.value=r,e(r)}}_registerOption(e){let i=(this._idCounter++).toString();return this._optionMap.set(i,e),i}_getOptionId(e){for(let i of Array.from(this._optionMap.keys()))if(this._compareWith(this._optionMap.get(i)._value,e))return i;return null}_getOptionValue(e){let i=function(n){return n.split(":")[0]}(e);return this._optionMap.has(i)?this._optionMap.get(i)._value:e}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Cn(n)))(i||n)}}(),n.\u0275dir=xe({type:n,selectors:[["select","multiple","","formControlName",""],["select","multiple","","formControl",""],["select","multiple","","ngModel",""]],hostBindings:function(e,i){1&e&&D("change",function(o){return i.onChange(o.target)})("blur",function(){return i.onTouched()})},inputs:{compareWith:"compareWith"},features:[Rt([Fbe]),Le]}),n})(),fq=(()=>{class n{constructor(e,i,r){this._element=e,this._renderer=i,this._select=r,this._select&&(this.id=this._select._registerOption(this))}set ngValue(e){null!=this._select&&(this._value=e,this._setElementValue(k9(this.id,e)),this._select.writeValue(this._select.value))}set value(e){this._select?(this._value=e,this._setElementValue(k9(this.id,e)),this._select.writeValue(this._select.value)):this._setElementValue(e)}_setElementValue(e){this._renderer.setProperty(this._element.nativeElement,"value",e)}_setSelected(e){this._renderer.setProperty(this._element.nativeElement,"selected",e)}ngOnDestroy(){this._select&&(this._select._optionMap.delete(this.id),this._select.writeValue(this._select.value))}}return n.\u0275fac=function(e){return new(e||n)(C(be),C(dc),C(pq,9))},n.\u0275dir=xe({type:n,selectors:[["option"]],inputs:{ngValue:"ngValue",value:"value"}}),n})();function mq(n){return"number"==typeof n?n:parseInt(n,10)}function hq(n){return"number"==typeof n?n:parseFloat(n)}var Uf=(()=>{class n{constructor(){this._validator=rE}ngOnChanges(e){if(this.inputName in e){let i=this.normalizeInput(e[this.inputName].currentValue);this._enabled=this.enabled(i),this._validator=this._enabled?this.createValidator(i):rE,this._onChange&&this._onChange()}}validate(e){return this._validator(e)}registerOnValidatorChange(e){this._onChange=e}enabled(e){return null!=e}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275dir=xe({type:n,features:[Gt]}),n})(),Nbe={provide:So,useExisting:Vn(()=>Bbe),multi:!0},Bbe=(()=>{class n extends Uf{constructor(){super(...arguments),this.inputName="max",this.normalizeInput=e=>hq(e),this.createValidator=e=>L9(e)}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Cn(n)))(i||n)}}(),n.\u0275dir=xe({type:n,selectors:[["input","type","number","max","","formControlName",""],["input","type","number","max","","formControl",""],["input","type","number","max","","ngModel",""]],hostVars:1,hostBindings:function(e,i){2&e&&Pe("max",i._enabled?i.max:null)},inputs:{max:"max"},features:[Rt([Nbe]),Le]}),n})(),Vbe={provide:So,useExisting:Vn(()=>Hbe),multi:!0},Hbe=(()=>{class n extends Uf{constructor(){super(...arguments),this.inputName="min",this.normalizeInput=e=>hq(e),this.createValidator=e=>F9(e)}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Cn(n)))(i||n)}}(),n.\u0275dir=xe({type:n,selectors:[["input","type","number","min","","formControlName",""],["input","type","number","min","","formControl",""],["input","type","number","min","","ngModel",""]],hostVars:1,hostBindings:function(e,i){2&e&&Pe("min",i._enabled?i.min:null)},inputs:{min:"min"},features:[Rt([Vbe]),Le]}),n})(),zbe={provide:So,useExisting:Vn(()=>gq),multi:!0},Ube={provide:So,useExisting:Vn(()=>sL),multi:!0},gq=(()=>{class n extends Uf{constructor(){super(...arguments),this.inputName="required",this.normalizeInput=nw,this.createValidator=e=>N9}enabled(e){return e}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Cn(n)))(i||n)}}(),n.\u0275dir=xe({type:n,selectors:[["","required","","formControlName","",3,"type","checkbox"],["","required","","formControl","",3,"type","checkbox"],["","required","","ngModel","",3,"type","checkbox"]],hostVars:1,hostBindings:function(e,i){2&e&&Pe("required",i._enabled?"":null)},inputs:{required:"required"},features:[Rt([zbe]),Le]}),n})(),sL=(()=>{class n extends gq{constructor(){super(...arguments),this.createValidator=e=>B9}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Cn(n)))(i||n)}}(),n.\u0275dir=xe({type:n,selectors:[["input","type","checkbox","required","","formControlName",""],["input","type","checkbox","required","","formControl",""],["input","type","checkbox","required","","ngModel",""]],hostVars:1,hostBindings:function(e,i){2&e&&Pe("required",i._enabled?"":null)},features:[Rt([Ube]),Le]}),n})(),jbe={provide:So,useExisting:Vn(()=>Gbe),multi:!0},Gbe=(()=>{class n extends Uf{constructor(){super(...arguments),this.inputName="email",this.normalizeInput=nw,this.createValidator=e=>V9}enabled(e){return e}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Cn(n)))(i||n)}}(),n.\u0275dir=xe({type:n,selectors:[["","email","","formControlName",""],["","email","","formControl",""],["","email","","ngModel",""]],inputs:{email:"email"},features:[Rt([jbe]),Le]}),n})(),Wbe={provide:So,useExisting:Vn(()=>qbe),multi:!0},qbe=(()=>{class n extends Uf{constructor(){super(...arguments),this.inputName="minlength",this.normalizeInput=e=>mq(e),this.createValidator=e=>H9(e)}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Cn(n)))(i||n)}}(),n.\u0275dir=xe({type:n,selectors:[["","minlength","","formControlName",""],["","minlength","","formControl",""],["","minlength","","ngModel",""]],hostVars:1,hostBindings:function(e,i){2&e&&Pe("minlength",i._enabled?i.minlength:null)},inputs:{minlength:"minlength"},features:[Rt([Wbe]),Le]}),n})(),Ybe={provide:So,useExisting:Vn(()=>Xbe),multi:!0},Xbe=(()=>{class n extends Uf{constructor(){super(...arguments),this.inputName="maxlength",this.normalizeInput=e=>mq(e),this.createValidator=e=>z9(e)}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Cn(n)))(i||n)}}(),n.\u0275dir=xe({type:n,selectors:[["","maxlength","","formControlName",""],["","maxlength","","formControl",""],["","maxlength","","ngModel",""]],hostVars:1,hostBindings:function(e,i){2&e&&Pe("maxlength",i._enabled?i.maxlength:null)},inputs:{maxlength:"maxlength"},features:[Rt([Ybe]),Le]}),n})(),Qbe={provide:So,useExisting:Vn(()=>Zbe),multi:!0},Zbe=(()=>{class n extends Uf{constructor(){super(...arguments),this.inputName="pattern",this.normalizeInput=e=>e,this.createValidator=e=>U9(e)}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Cn(n)))(i||n)}}(),n.\u0275dir=xe({type:n,selectors:[["","pattern","","formControlName",""],["","pattern","","formControl",""],["","pattern","","ngModel",""]],hostVars:1,hostBindings:function(e,i){2&e&&Pe("pattern",i._enabled?i.pattern:null)},inputs:{pattern:"pattern"},features:[Rt([Qbe]),Le]}),n})(),_q=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[oq]}),n})(),kg=(new hl("15.2.9"),(()=>{class n{static withConfig(e){return{ngModule:n,providers:[{provide:zf,useValue:e.callSetDisabledState??iv}]}}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[_q]}),n})()),yq=(()=>{class n{static withConfig(e){return{ngModule:n,providers:[{provide:oL,useValue:e.warnOnNgModelWithFormControl??"always"},{provide:zf,useValue:e.callSetDisabledState??iv}]}}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[_q]}),n})(),eve=["trigger"],tve=["panel"],bq=(ji("transformPanelWrap",[Wn("* => void",dd("@transformPanel",[cd()],{optional:!0}))]),ji("transformPanel",[Jn("void",Bt({opacity:0,transform:"scale(1, 0.8)"})),Wn("void => showing",Kn("120ms cubic-bezier(0, 0, 0.2, 1)",Bt({opacity:1,transform:"scale(1, 1)"}))),Wn("* => void",Kn("100ms linear",Bt({opacity:0})))]),0),vq=new ie("mat-select-scroll-strategy"),ive=new ie("MAT_SELECT_CONFIG"),xq={provide:vq,deps:[Oi],useFactory:function(n){return()=>n.scrollStrategies.reposition()}},Cq=new ie("MatSelectTrigger"),rve=Qo(vd(Kr(Ub(class{constructor(n,t,e,i,r){this._elementRef=n,this._defaultErrorStateMatcher=t,this._parentForm=e,this._parentFormGroup=i,this.ngControl=r,this.stateChanges=new Ae}})))),Mq=(()=>{class n extends rve{get focused(){return this._focused||this._panelOpen}get placeholder(){return this._placeholder}set placeholder(e){this._placeholder=e,this.stateChanges.next()}get required(){return this._required??this.ngControl?.control?.hasValidator(Vl.required)??!1}set required(e){this._required=Ut(e),this.stateChanges.next()}get multiple(){return this._multiple}set multiple(e){this._multiple=Ut(e)}get disableOptionCentering(){return this._disableOptionCentering}set disableOptionCentering(e){this._disableOptionCentering=Ut(e)}get compareWith(){return this._compareWith}set compareWith(e){this._compareWith=e,this._selectionModel&&this._initializeSelection()}get value(){return this._value}set value(e){this._assignValue(e)&&this._onChange(e)}get typeaheadDebounceInterval(){return this._typeaheadDebounceInterval}set typeaheadDebounceInterval(e){this._typeaheadDebounceInterval=Di(e)}get id(){return this._id}set id(e){this._id=e||this._uid,this.stateChanges.next()}constructor(e,i,r,o,a,s,l,c,d,u,p,f,m,y){super(a,o,l,c,u),this._viewportRuler=e,this._changeDetectorRef=i,this._ngZone=r,this._dir=s,this._parentFormField=d,this._liveAnnouncer=m,this._defaultOptions=y,this._panelOpen=!1,this._compareWith=(M,v)=>M===v,this._uid="mat-select-"+bq++,this._triggerAriaLabelledBy=null,this._destroy=new Ae,this._onChange=()=>{},this._onTouched=()=>{},this._valueId="mat-select-value-"+bq++,this._panelDoneAnimatingStream=new Ae,this._overlayPanelClass=this._defaultOptions?.overlayPanelClass||"",this._focused=!1,this.controlType="mat-select",this._multiple=!1,this._disableOptionCentering=this._defaultOptions?.disableOptionCentering??!1,this.ariaLabel="",this.optionSelectionChanges=Ka(()=>{let M=this.options;return M?M.changes.pipe(Nn(M),yi(()=>cn(...M.map(v=>v.onSelectionChange)))):this._ngZone.onStable.pipe(zt(1),yi(()=>this.optionSelectionChanges))}),this.openedChange=new L,this._openedStream=this.openedChange.pipe(Ve(M=>M),U(()=>{})),this._closedStream=this.openedChange.pipe(Ve(M=>!M),U(()=>{})),this.selectionChange=new L,this.valueChange=new L,this.ngControl&&(this.ngControl.valueAccessor=this),null!=y?.typeaheadDebounceInterval&&(this._typeaheadDebounceInterval=y.typeaheadDebounceInterval),this._scrollStrategyFactory=f,this._scrollStrategy=this._scrollStrategyFactory(),this.tabIndex=parseInt(p)||0,this.id=this.id}ngOnInit(){this._selectionModel=new xg(this.multiple),this.stateChanges.next(),this._panelDoneAnimatingStream.pipe(ui(),ot(this._destroy)).subscribe(()=>this._panelDoneAnimating(this.panelOpen))}ngAfterContentInit(){this._initKeyManager(),this._selectionModel.changed.pipe(ot(this._destroy)).subscribe(e=>{e.added.forEach(i=>i.select()),e.removed.forEach(i=>i.deselect())}),this.options.changes.pipe(Nn(null),ot(this._destroy)).subscribe(()=>{this._resetOptions(),this._initializeSelection()})}ngDoCheck(){let e=this._getTriggerAriaLabelledby(),i=this.ngControl;if(e!==this._triggerAriaLabelledBy){let r=this._elementRef.nativeElement;this._triggerAriaLabelledBy=e,e?r.setAttribute("aria-labelledby",e):r.removeAttribute("aria-labelledby")}i&&(this._previousControl!==i.control&&(void 0!==this._previousControl&&null!==i.disabled&&i.disabled!==this.disabled&&(this.disabled=i.disabled),this._previousControl=i.control),this.updateErrorState())}ngOnChanges(e){(e.disabled||e.userAriaDescribedBy)&&this.stateChanges.next(),e.typeaheadDebounceInterval&&this._keyManager&&this._keyManager.withTypeAhead(this._typeaheadDebounceInterval)}ngOnDestroy(){this._keyManager?.destroy(),this._destroy.next(),this._destroy.complete(),this.stateChanges.complete()}toggle(){this.panelOpen?this.close():this.open()}open(){this._canOpen()&&(this._panelOpen=!0,this._keyManager.withHorizontalOrientation(null),this._highlightCorrectOption(),this._changeDetectorRef.markForCheck())}close(){this._panelOpen&&(this._panelOpen=!1,this._keyManager.withHorizontalOrientation(this._isRtl()?"rtl":"ltr"),this._changeDetectorRef.markForCheck(),this._onTouched())}writeValue(e){this._assignValue(e)}registerOnChange(e){this._onChange=e}registerOnTouched(e){this._onTouched=e}setDisabledState(e){this.disabled=e,this._changeDetectorRef.markForCheck(),this.stateChanges.next()}get panelOpen(){return this._panelOpen}get selected(){return this.multiple?this._selectionModel?.selected||[]:this._selectionModel?.selected[0]}get triggerValue(){if(this.empty)return"";if(this._multiple){let e=this._selectionModel.selected.map(i=>i.viewValue);return this._isRtl()&&e.reverse(),e.join(", ")}return this._selectionModel.selected[0].viewValue}_isRtl(){return!!this._dir&&"rtl"===this._dir.value}_handleKeydown(e){this.disabled||(this.panelOpen?this._handleOpenKeydown(e):this._handleClosedKeydown(e))}_handleClosedKeydown(e){let i=e.keyCode,r=40===i||38===i||37===i||39===i,o=13===i||32===i,a=this._keyManager;if(!a.isTyping()&&o&&!yr(e)||(this.multiple||e.altKey)&&r)e.preventDefault(),this.open();else if(!this.multiple){let s=this.selected;a.onKeydown(e);let l=this.selected;l&&s!==l&&this._liveAnnouncer.announce(l.viewValue,1e4)}}_handleOpenKeydown(e){let i=this._keyManager,r=e.keyCode,o=40===r||38===r,a=i.isTyping();if(o&&e.altKey)e.preventDefault(),this.close();else if(a||13!==r&&32!==r||!i.activeItem||yr(e))if(!a&&this._multiple&&65===r&&e.ctrlKey){e.preventDefault();let s=this.options.some(l=>!l.disabled&&!l.selected);this.options.forEach(l=>{l.disabled||(s?l.select():l.deselect())})}else{let s=i.activeItemIndex;i.onKeydown(e),this._multiple&&o&&e.shiftKey&&i.activeItem&&i.activeItemIndex!==s&&i.activeItem._selectViaInteraction()}else e.preventDefault(),i.activeItem._selectViaInteraction()}_onFocus(){this.disabled||(this._focused=!0,this.stateChanges.next())}_onBlur(){this._focused=!1,this._keyManager?.cancelTypeahead(),!this.disabled&&!this.panelOpen&&(this._onTouched(),this._changeDetectorRef.markForCheck(),this.stateChanges.next())}_onAttached(){this._overlayDir.positionChange.pipe(zt(1)).subscribe(()=>{this._changeDetectorRef.detectChanges(),this._positioningSettled()})}_getPanelTheme(){return this._parentFormField?`mat-${this._parentFormField.color}`:""}get empty(){return!this._selectionModel||this._selectionModel.isEmpty()}_initializeSelection(){Promise.resolve().then(()=>{this.ngControl&&(this._value=this.ngControl.value),this._setSelectionByValue(this._value),this.stateChanges.next()})}_setSelectionByValue(e){if(this.options.forEach(i=>i.setInactiveStyles()),this._selectionModel.clear(),this.multiple&&e)Array.isArray(e),e.forEach(i=>this._selectOptionByValue(i)),this._sortValues();else{let i=this._selectOptionByValue(e);i?this._keyManager.updateActiveItem(i):this.panelOpen||this._keyManager.updateActiveItem(-1)}this._changeDetectorRef.markForCheck()}_selectOptionByValue(e){let i=this.options.find(r=>{if(this._selectionModel.isSelected(r))return!1;try{return null!=r.value&&this._compareWith(r.value,e)}catch{return!1}});return i&&this._selectionModel.select(i),i}_assignValue(e){return!!(e!==this._value||this._multiple&&Array.isArray(e))&&(this.options&&this._setSelectionByValue(e),this._value=e,!0)}_initKeyManager(){this._keyManager=new hg(this.options).withTypeAhead(this._typeaheadDebounceInterval).withVerticalOrientation().withHorizontalOrientation(this._isRtl()?"rtl":"ltr").withHomeAndEnd().withPageUpDown().withAllowedModifierKeys(["shiftKey"]),this._keyManager.tabOut.subscribe(()=>{this.panelOpen&&(!this.multiple&&this._keyManager.activeItem&&this._keyManager.activeItem._selectViaInteraction(),this.focus(),this.close())}),this._keyManager.change.subscribe(()=>{this._panelOpen&&this.panel?this._scrollOptionIntoView(this._keyManager.activeItemIndex||0):!this._panelOpen&&!this.multiple&&this._keyManager.activeItem&&this._keyManager.activeItem._selectViaInteraction()})}_resetOptions(){let e=cn(this.options.changes,this._destroy);this.optionSelectionChanges.pipe(ot(e)).subscribe(i=>{this._onSelect(i.source,i.isUserInput),i.isUserInput&&!this.multiple&&this._panelOpen&&(this.close(),this.focus())}),cn(...this.options.map(i=>i._stateChanges)).pipe(ot(e)).subscribe(()=>{this._changeDetectorRef.detectChanges(),this.stateChanges.next()})}_onSelect(e,i){let r=this._selectionModel.isSelected(e);null!=e.value||this._multiple?(r!==e.selected&&(e.selected?this._selectionModel.select(e):this._selectionModel.deselect(e)),i&&this._keyManager.setActiveItem(e),this.multiple&&(this._sortValues(),i&&this.focus())):(e.deselect(),this._selectionModel.clear(),null!=this.value&&this._propagateChanges(e.value)),r!==this._selectionModel.isSelected(e)&&this._propagateChanges(),this.stateChanges.next()}_sortValues(){if(this.multiple){let e=this.options.toArray();this._selectionModel.sort((i,r)=>this.sortComparator?this.sortComparator(i,r,e):e.indexOf(i)-e.indexOf(r)),this.stateChanges.next()}}_propagateChanges(e){let i=null;i=this.multiple?this.selected.map(r=>r.value):this.selected?this.selected.value:e,this._value=i,this.valueChange.emit(i),this._onChange(i),this.selectionChange.emit(this._getChangeEvent(i)),this._changeDetectorRef.markForCheck()}_highlightCorrectOption(){this._keyManager&&(this.empty?this._keyManager.setFirstItemActive():this._keyManager.setActiveItem(this._selectionModel.selected[0]))}_canOpen(){return!this._panelOpen&&!this.disabled&&this.options?.length>0}focus(e){this._elementRef.nativeElement.focus(e)}_getPanelAriaLabelledby(){if(this.ariaLabel)return null;let e=this._parentFormField?.getLabelId();return this.ariaLabelledby?(e?e+" ":"")+this.ariaLabelledby:e}_getAriaActiveDescendant(){return this.panelOpen&&this._keyManager&&this._keyManager.activeItem?this._keyManager.activeItem.id:null}_getTriggerAriaLabelledby(){if(this.ariaLabel)return null;let e=this._parentFormField?.getLabelId(),i=(e?e+" ":"")+this._valueId;return this.ariaLabelledby&&(i+=" "+this.ariaLabelledby),i}_panelDoneAnimating(e){this.openedChange.emit(e)}setDescribedByIds(e){e.length?this._elementRef.nativeElement.setAttribute("aria-describedby",e.join(" ")):this._elementRef.nativeElement.removeAttribute("aria-describedby")}onContainerClick(){this.focus(),this.open()}get shouldLabelFloat(){return this._panelOpen||!this.empty||this._focused&&!!this._placeholder}}return n.\u0275fac=function(e){return new(e||n)(C(Ko),C(Ft),C(at),C(If),C(be),C(Hi,8),C(Ag,8),C(Rg,8),C(Bl,8),C(za,10),Vr("tabindex"),C(vq),C(yg),C(ive,8))},n.\u0275dir=xe({type:n,viewQuery:function(e,i){if(1&e&&(Ye(eve,5),Ye(tve,5),Ye(zu,5)),2&e){let r;we(r=Se())&&(i.trigger=r.first),we(r=Se())&&(i.panel=r.first),we(r=Se())&&(i._overlayDir=r.first)}},inputs:{userAriaDescribedBy:["aria-describedby","userAriaDescribedBy"],panelClass:"panelClass",placeholder:"placeholder",required:"required",multiple:"multiple",disableOptionCentering:"disableOptionCentering",compareWith:"compareWith",value:"value",ariaLabel:["aria-label","ariaLabel"],ariaLabelledby:["aria-labelledby","ariaLabelledby"],errorStateMatcher:"errorStateMatcher",typeaheadDebounceInterval:"typeaheadDebounceInterval",sortComparator:"sortComparator",id:"id"},outputs:{openedChange:"openedChange",_openedStream:"opened",_closedStream:"closed",selectionChange:"selectionChange",valueChange:"valueChange"},features:[Le,Gt]}),n})();function ove(n,t){if(1&n&&(h(0,"span",8),T(1),g()),2&n){let e=w();b(1),ut(e.placeholder)}}function ave(n,t){if(1&n&&(h(0,"span",12),T(1),g()),2&n){let e=w(2);b(1),ut(e.triggerValue)}}function sve(n,t){1&n&&Xt(0,0,["*ngSwitchCase","true"])}function lve(n,t){1&n&&(h(0,"span",9),S(1,ave,2,1,"span",10),S(2,sve,1,0,"ng-content",11),g()),2&n&&(_("ngSwitch",!!w().customTrigger),b(2),_("ngSwitchCase",!0))}function cve(n,t){if(1&n){let e=ge();h(0,"div",13)(1,"div",14,15),D("@transformPanel.done",function(r){return X(e),Q(w()._panelDoneAnimatingStream.next(r.toState))})("keydown",function(r){return X(e),Q(w()._handleKeydown(r))}),Xt(3,1),g()()}if(2&n){let e=w();_("@transformPanelWrap",void 0),b(1),Dh("mat-select-panel ",e._getPanelTheme(),""),Mt("transform-origin",e._transformOrigin)("font-size",e._triggerFontSize,"px"),_("ngClass",e.panelClass)("@transformPanel",e.multiple?"showing-multiple":"showing"),Pe("id",e.id+"-panel")("aria-multiselectable",e.multiple)("aria-label",e.ariaLabel||null)("aria-labelledby",e._getPanelAriaLabelledby())}}var dve=[[["mat-select-trigger"]],"*"],uve=["mat-select-trigger","*"],wq={transformPanelWrap:ji("transformPanelWrap",[Wn("* => void",dd("@transformPanel",[cd()],{optional:!0}))]),transformPanel:ji("transformPanel",[Jn("void",Bt({transform:"scaleY(0.8)",minWidth:"100%",opacity:0})),Jn("showing",Bt({opacity:1,minWidth:"calc(100% + 32px)",transform:"scaleY(1)"})),Jn("showing-multiple",Bt({opacity:1,minWidth:"calc(100% + 64px)",transform:"scaleY(1)"})),Wn("void => *",Kn("120ms cubic-bezier(0, 0, 0.2, 1)")),Wn("* => void",Kn("100ms 25ms linear",Bt({opacity:0})))])},Gu=(()=>{class n extends Mq{constructor(){super(...arguments),this._scrollTop=0,this._triggerFontSize=0,this._transformOrigin="top",this._offsetY=0,this._positions=[{originX:"start",originY:"top",overlayX:"start",overlayY:"top"},{originX:"start",originY:"bottom",overlayX:"start",overlayY:"bottom"}]}_calculateOverlayScroll(e,i,r){let o=this._getItemHeight();return Math.min(Math.max(0,o*e-i+o/2),r)}ngOnInit(){super.ngOnInit(),this._viewportRuler.change().pipe(ot(this._destroy)).subscribe(()=>{this.panelOpen&&(this._triggerRect=this.trigger.nativeElement.getBoundingClientRect(),this._changeDetectorRef.markForCheck())})}open(){super._canOpen()&&(super.open(),this._triggerRect=this.trigger.nativeElement.getBoundingClientRect(),this._triggerFontSize=parseInt(getComputedStyle(this.trigger.nativeElement).fontSize||"0"),this._calculateOverlayPosition(),this._ngZone.onStable.pipe(zt(1)).subscribe(()=>{this._triggerFontSize&&this._overlayDir.overlayRef&&this._overlayDir.overlayRef.overlayElement&&(this._overlayDir.overlayRef.overlayElement.style.fontSize=`${this._triggerFontSize}px`)}))}_scrollOptionIntoView(e){let i=Af(e,this.options,this.optionGroups),r=this._getItemHeight();this.panel.nativeElement.scrollTop=0===e&&1===i?0:vg((e+i)*r,r,this.panel.nativeElement.scrollTop,256)}_positioningSettled(){this._calculateOverlayOffsetX(),this.panel.nativeElement.scrollTop=this._scrollTop}_panelDoneAnimating(e){this.panelOpen?this._scrollTop=0:(this._overlayDir.offsetX=0,this._changeDetectorRef.markForCheck()),super._panelDoneAnimating(e)}_getChangeEvent(e){return new class{constructor(t,e){this.source=t,this.value=e}}(this,e)}_getOverlayMinWidth(){return this._triggerRect?.width}_calculateOverlayOffsetX(){let a,e=this._overlayDir.overlayRef.overlayElement.getBoundingClientRect(),i=this._viewportRuler.getViewportSize(),r=this._isRtl(),o=this.multiple?56:32;if(this.multiple)a=40;else if(this.disableOptionCentering)a=16;else{let c=this._selectionModel.selected[0]||this.options.first;a=c&&c.group?32:16}r||(a*=-1);let s=0-(e.left+a-(r?o:0)),l=e.right+a-i.width+(r?0:o);s>0?a+=s+8:l>0&&(a-=l+8),this._overlayDir.offsetX=Math.round(a),this._overlayDir.overlayRef.updatePosition()}_calculateOverlayOffsetY(e,i,r){let l,o=this._getItemHeight(),a=(o-this._triggerRect.height)/2,s=Math.floor(256/o);return this.disableOptionCentering?0:(l=0===this._scrollTop?e*o:this._scrollTop===r?(e-(this._getItemCount()-s))*o+(o-(this._getItemCount()*o-256)%o):i-o/2,Math.round(-1*l-a))}_checkOverlayWithinViewport(e){let i=this._getItemHeight(),r=this._viewportRuler.getViewportSize(),o=this._triggerRect.top-8,a=r.height-this._triggerRect.bottom-8,s=Math.abs(this._offsetY),c=Math.min(this._getItemCount()*i,256)-s-this._triggerRect.height;c>a?this._adjustPanelUp(c,a):s>o?this._adjustPanelDown(s,o,e):this._transformOrigin=this._getOriginBasedOnOption()}_adjustPanelUp(e,i){let r=Math.round(e-i);this._scrollTop-=r,this._offsetY-=r,this._transformOrigin=this._getOriginBasedOnOption(),this._scrollTop<=0&&(this._scrollTop=0,this._offsetY=0,this._transformOrigin="50% bottom 0px")}_adjustPanelDown(e,i,r){let o=Math.round(e-i);if(this._scrollTop+=o,this._offsetY+=o,this._transformOrigin=this._getOriginBasedOnOption(),this._scrollTop>=r)return this._scrollTop=r,this._offsetY=0,void(this._transformOrigin="50% top 0px")}_calculateOverlayPosition(){let s,e=this._getItemHeight(),i=this._getItemCount(),r=Math.min(i*e,256),a=i*e-r;s=this.empty?0:Math.max(this.options.toArray().indexOf(this._selectionModel.selected[0]),0),s+=Af(s,this.options,this.optionGroups);let l=r/2;this._scrollTop=this._calculateOverlayScroll(s,l,a),this._offsetY=this._calculateOverlayOffsetY(s,l,a),this._checkOverlayWithinViewport(a)}_getOriginBasedOnOption(){let e=this._getItemHeight(),i=(e-this._triggerRect.height)/2;return`50% ${Math.abs(this._offsetY)-i+e/2}px 0px`}_getItemHeight(){return 3*this._triggerFontSize}_getItemCount(){return this.options.length+this.optionGroups.length}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Cn(n)))(i||n)}}(),n.\u0275cmp=k({type:n,selectors:[["mat-select"]],contentQueries:function(e,i,r){if(1&e&&(ci(r,Cq,5),ci(r,Ha,5),ci(r,Cd,5)),2&e){let o;we(o=Se())&&(i.customTrigger=o.first),we(o=Se())&&(i.options=o),we(o=Se())&&(i.optionGroups=o)}},hostAttrs:["role","combobox","aria-autocomplete","none","aria-haspopup","true",1,"mat-select"],hostVars:19,hostBindings:function(e,i){1&e&&D("keydown",function(o){return i._handleKeydown(o)})("focus",function(){return i._onFocus()})("blur",function(){return i._onBlur()}),2&e&&(Pe("id",i.id)("tabindex",i.tabIndex)("aria-controls",i.panelOpen?i.id+"-panel":null)("aria-expanded",i.panelOpen)("aria-label",i.ariaLabel||null)("aria-required",i.required.toString())("aria-disabled",i.disabled.toString())("aria-invalid",i.errorState)("aria-activedescendant",i._getAriaActiveDescendant()),Qe("mat-select-disabled",i.disabled)("mat-select-invalid",i.errorState)("mat-select-required",i.required)("mat-select-empty",i.empty)("mat-select-multiple",i.multiple))},inputs:{disabled:"disabled",disableRipple:"disableRipple",tabIndex:"tabIndex"},exportAs:["matSelect"],features:[Rt([{provide:Nl,useExisting:n},{provide:xd,useExisting:n}]),Le],ngContentSelectors:uve,decls:9,vars:12,consts:[["cdk-overlay-origin","",1,"mat-select-trigger",3,"click"],["origin","cdkOverlayOrigin","trigger",""],[1,"mat-select-value",3,"ngSwitch"],["class","mat-select-placeholder mat-select-min-line",4,"ngSwitchCase"],["class","mat-select-value-text",3,"ngSwitch",4,"ngSwitchCase"],[1,"mat-select-arrow-wrapper"],[1,"mat-select-arrow"],["cdk-connected-overlay","","cdkConnectedOverlayLockPosition","","cdkConnectedOverlayHasBackdrop","","cdkConnectedOverlayBackdropClass","cdk-overlay-transparent-backdrop",3,"cdkConnectedOverlayPanelClass","cdkConnectedOverlayScrollStrategy","cdkConnectedOverlayOrigin","cdkConnectedOverlayOpen","cdkConnectedOverlayPositions","cdkConnectedOverlayMinWidth","cdkConnectedOverlayOffsetY","backdropClick","attach","detach"],[1,"mat-select-placeholder","mat-select-min-line"],[1,"mat-select-value-text",3,"ngSwitch"],["class","mat-select-min-line",4,"ngSwitchDefault"],[4,"ngSwitchCase"],[1,"mat-select-min-line"],[1,"mat-select-panel-wrap"],["role","listbox","tabindex","-1",3,"ngClass","keydown"],["panel",""]],template:function(e,i){if(1&e&&(gn(dve),h(0,"div",0,1),D("click",function(){return i.toggle()}),h(3,"div",2),S(4,ove,2,1,"span",3),S(5,lve,3,2,"span",4),g(),h(6,"div",5),P(7,"div",6),g()(),S(8,cve,4,14,"ng-template",7),D("backdropClick",function(){return i.close()})("attach",function(){return i._onAttached()})("detach",function(){return i.close()})),2&e){let r=tt(1);Pe("aria-owns",i.panelOpen?i.id+"-panel":null),b(3),_("ngSwitch",i.empty),Pe("id",i._valueId),b(1),_("ngSwitchCase",!0),b(1),_("ngSwitchCase",!1),b(3),_("cdkConnectedOverlayPanelClass",i._overlayPanelClass)("cdkConnectedOverlayScrollStrategy",i._scrollStrategy)("cdkConnectedOverlayOrigin",r)("cdkConnectedOverlayOpen",i.panelOpen)("cdkConnectedOverlayPositions",i._positions)("cdkConnectedOverlayMinWidth",i._getOverlayMinWidth())("cdkConnectedOverlayOffsetY",i._offsetY)}},dependencies:[bn,$i,sr,fu,zu,Hu],styles:['.mat-select{display:inline-block;width:100%;outline:none}.mat-select-trigger{display:inline-flex;align-items:center;cursor:pointer;position:relative;box-sizing:border-box;width:100%}.mat-select-disabled .mat-select-trigger{-webkit-user-select:none;user-select:none;cursor:default}.mat-select-value{width:100%;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.mat-select-value-text{white-space:nowrap;overflow:hidden;text-overflow:ellipsis}.mat-select-arrow-wrapper{height:16px;flex-shrink:0;display:inline-flex;align-items:center}.mat-form-field-appearance-fill .mat-select-arrow-wrapper{transform:translateY(-50%)}.mat-form-field-appearance-outline .mat-select-arrow-wrapper{transform:translateY(-25%)}.mat-form-field-appearance-standard.mat-form-field-has-label .mat-select:not(.mat-select-empty) .mat-select-arrow-wrapper{transform:translateY(-50%)}.mat-form-field-appearance-standard .mat-select.mat-select-empty .mat-select-arrow-wrapper{transition:transform 400ms cubic-bezier(0.25, 0.8, 0.25, 1)}._mat-animation-noopable.mat-form-field-appearance-standard .mat-select.mat-select-empty .mat-select-arrow-wrapper{transition:none}.mat-select-arrow{width:0;height:0;border-left:5px solid rgba(0,0,0,0);border-right:5px solid rgba(0,0,0,0);border-top:5px solid;margin:0 4px}.mat-form-field.mat-focused .mat-select-arrow{transform:translateX(0)}.mat-select-panel-wrap{flex-basis:100%}.mat-select-panel{min-width:112px;max-width:280px;overflow:auto;-webkit-overflow-scrolling:touch;padding-top:0;padding-bottom:0;max-height:256px;min-width:100%;border-radius:4px;outline:0}.cdk-high-contrast-active .mat-select-panel{outline:solid 1px}.mat-select-panel .mat-optgroup-label,.mat-select-panel .mat-option{font-size:inherit;line-height:3em;height:3em}.mat-form-field-type-mat-select:not(.mat-form-field-disabled) .mat-form-field-flex{cursor:pointer}.mat-form-field-type-mat-select .mat-form-field-label{width:calc(100% - 18px)}.mat-select-placeholder{transition:color 400ms 133.3333333333ms cubic-bezier(0.25, 0.8, 0.25, 1)}._mat-animation-noopable .mat-select-placeholder{transition:none}.mat-form-field-hide-placeholder .mat-select-placeholder{color:rgba(0,0,0,0);-webkit-text-fill-color:rgba(0,0,0,0);transition:none;display:block}.mat-select-min-line:empty::before{content:" ";white-space:pre;width:1px;display:inline-block;visibility:hidden}'],encapsulation:2,data:{animation:[wq.transformPanelWrap,wq.transformPanel]},changeDetection:0}),n})(),Xs=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({providers:[xq],imports:[Te,Lr,Sg,Qt,Rc,Vf,Sg,Qt]}),n})();function mve(n,t){1&n&&(Tt(0),h(1,"div",1),T(2," There is a difference between Default - (Enabled/Disabled) and (Enabled/Disabled) "),g(),h(3,"div",1),T(4," Only flags with non default values are sent to the backend. "),g(),Dt())}function hve(n,t){if(1&n&&(Tt(0),h(1,"div",1),T(2),g(),Dt()),2&n){let e=w();b(2),ze(' Feature Flags are filtered to only show features containing "',e.showFlagsFilter,'" ')}}function gve(n,t){1&n&&(h(0,"sup",11),T(1,"1"),g())}function _ve(n,t){1&n&&Ti(0)}function yve(n,t){if(1&n){let e=ge();h(0,"mat-select",12),D("selectionChange",function(r){X(e);let o=w().$implicit;return Q(w().flagChanged.emit({flag:o.flag,status:r.value}))}),h(1,"mat-option",13),T(2),g(),h(3,"mat-option",14),T(4,"Enabled"),g(),h(5,"mat-option",15),T(6,"Disabled"),g()()}if(2&n){let e=w().$implicit,i=w();_("value",e.status),b(2),ze(" Default ",i.formatFlagValue(e.defaultValue)," ")}}function bve(n,t){if(1&n&&(h(0,"td"),T(1),g()),2&n){let e=w().$implicit,i=w();b(1),ze("Unsupported By UI ",i.formatFlagValue(e.value),"")}}function vve(n,t){if(1&n&&(Tt(0),h(1,"tr")(2,"td")(3,"div"),T(4),S(5,gve,2,0,"sup",7),g()(),S(6,_ve,1,0,"ng-container",8),S(7,yve,7,2,"ng-template",null,9,Zt),S(9,bve,2,1,"ng-template",null,10,Zt),g(),Dt()),2&n){let e=t.$implicit,i=tt(8),r=tt(10),o=w();b(4),ze(" ",e.flag," "),b(1),_("ngIf",e.sendToServerWhenOverridden),b(1),_("ngIf",o.isEditable(e))("ngIfThen",i)("ngIfElse",r)}}function xve(n,t){1&n&&(h(0,"div",11),T(1," 1. Sent to server when overridden "),g())}var _E,Eq=(()=>{class n{constructor(){this.hasFlagsSentToServer=!1,this.flagChanged=new L,this.allFlagsReset=new L}serializeFlagValue(e){return!0===e?"Enabled":!1===e?"Disabled":null==e?"null":Array.isArray(e)?JSON.stringify(e):e.toString()}isEditable(e){return"boolean"==typeof e.defaultValue}formatFlagValue(e){let i=this.serializeFlagValue(e);return 0===i.length?"":`- ${i}`}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["feature-flag-dialog-component"]],inputs:{featureFlagStatuses:"featureFlagStatuses",hasFlagsSentToServer:"hasFlagsSentToServer",showFlagsFilter:"showFlagsFilter"},outputs:{flagChanged:"flagChanged",allFlagsReset:"allFlagsReset"},decls:12,vars:4,consts:[[1,"scrolling-page"],[1,"message"],[1,"warning"],[4,"ngIf"],[1,"feature-flag-table"],[4,"ngFor","ngForOf"],["mat-button","",3,"click"],["class","note-1",4,"ngIf"],[4,"ngIf","ngIfThen","ngIfElse"],["selectBlock",""],["unsupportedBlock",""],[1,"note-1"],[3,"value","selectionChange"],["value","default"],["value","enabled"],["value","disabled"]],template:function(e,i){1&e&&(h(0,"div",0)(1,"div",1)(2,"h2",2),T(3,"WARNING: EXPERIMENTAL FEATURES AHEAD!"),g(),T(4," By enabling these features, you could put the application in an unusable state or expose yourself to untested features or potential bugs. "),g(),S(5,mve,5,0,"ng-container",3),S(6,hve,3,1,"ng-container",3),h(7,"table",4),S(8,vve,11,5,"ng-container",5),g(),h(9,"button",6),D("click",function(){return i.allFlagsReset.emit()}),T(10,"Reset All"),g(),S(11,xve,2,0,"div",7),g()),2&e&&(b(5),_("ngIf",i.hasFlagsSentToServer),b(1),_("ngIf",i.showFlagsFilter),b(2),_("ngForOf",i.featureFlagStatuses),b(3),_("ngIf",i.hasFlagsSentToServer))},dependencies:[dn,Fe,Fn,Gu,Ha],styles:[".message[_ngcontent-%COMP%]{margin-bottom:16px}.message[_ngcontent-%COMP%]   .warning[_ngcontent-%COMP%]{color:#f44336}.note-1[_ngcontent-%COMP%]{color:#ff9800}.scrolling-page[_ngcontent-%COMP%]{max-height:90vh}.feature-flag-table[_ngcontent-%COMP%]{width:100%}"]}),n})(),Tq=(()=>{class n{constructor(e){this.store=e,this.showFlagsFilter$=this.store.select(fb).pipe(U(i=>i.showFlags?.toLowerCase())),this.hasFlagsSentToServer$=this.store.select(mf).pipe(U(i=>Object.values(i).some(r=>r.sendToServerWhenOverridden))),this.featureFlags$=this.store.select(fb).pipe(Yt(this.store.select(U6),this.store.select(mf),this.showFlagsFilter$),U(([i,r,o,a])=>Object.entries(r).filter(([s])=>!a||s.toLowerCase().includes(a)).map(([s,l])=>{let c=function(n,t){return void 0===t[n]?"default":t[n]?"enabled":"disabled"}(s,i);return{flag:s,defaultValue:l,status:c,sendToServerWhenOverridden:o[s].sendToServerWhenOverridden}})))}onFlagChanged({flag:e,status:i}){switch(i){case"default":this.store.dispatch(Su({flags:[e]}));break;case"enabled":this.store.dispatch(xf({flags:{[e]:!0}}));break;case"disabled":this.store.dispatch(xf({flags:{[e]:!1}}));break;default:throw new Error("Flag changed to invalid status")}}onAllFlagsReset(){this.store.dispatch(eg())}}return n.\u0275fac=function(e){return new(e||n)(C(ke))},n.\u0275cmp=k({type:n,selectors:[["feature-flag-dialog"]],decls:4,vars:9,consts:[[3,"featureFlagStatuses","hasFlagsSentToServer","showFlagsFilter","flagChanged","allFlagsReset"]],template:function(e,i){1&e&&(h(0,"feature-flag-dialog-component",0),D("flagChanged",function(o){return i.onFlagChanged(o)})("allFlagsReset",function(){return i.onAllFlagsReset()}),G(1,"async"),G(2,"async"),G(3,"async"),g()),2&e&&_("featureFlagStatuses",W(1,3,i.featureFlags$))("hasFlagsSentToServer",W(2,5,i.hasFlagsSentToServer$))("showFlagsFilter",W(3,7,i.showFlagsFilter$))},dependencies:[Eq,lt],encapsulation:2}),n})(),Dq=(()=>{class n{constructor(e,i){this.store=e,this.dialog=i,this.featureFlagDialogType=Tq,this.showFeatureFlags$=this.store.select(q6),this.ngUnsubscribe=new Ae}ngOnInit(){this.showFeatureFlags$.pipe(ot(this.ngUnsubscribe)).subscribe(e=>{if(e)return this.featureFlagsDialog=this.dialog.open(this.featureFlagDialogType),void this.featureFlagsDialog.afterClosed().pipe(ot(this.ngUnsubscribe)).subscribe(()=>{this.store.dispatch(Su({flags:["showFlags"]})),setTimeout(()=>{window.location.reload()},1)})})}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}}return n.\u0275fac=function(e){return new(e||n)(C(ke),C(Ll))},n.\u0275cmp=k({type:n,selectors:[["feature-flag-modal-trigger"]],decls:0,vars:0,template:function(e,i){},encapsulation:2}),n})(),Eve=["routeContainer"],Iq=(()=>{class n{constructor(e){this.componentFactoryResolver=e}ngOnChanges(e){let i=e.activeNgComponent;if(i&&(this.routeContainer.clear(),i.currentValue)){let r=this.componentFactoryResolver.resolveComponentFactory(i.currentValue);this.routeContainer.createComponent(r)}}}return n.\u0275fac=function(e){return new(e||n)(C(Qr))},n.\u0275cmp=k({type:n,selectors:[["router-outlet-component"]],viewQuery:function(e,i){if(1&e&&Ye(Eve,7,Zn),2&e){let r;we(r=Se())&&(i.routeContainer=r.first)}},inputs:{activeNgComponent:"activeNgComponent"},features:[Gt],decls:2,vars:0,consts:[["routeContainer",""]],template:function(e,i){1&e&&Ti(0,null,0)},encapsulation:2,changeDetection:0}),n})(),Aq=(()=>{class n{constructor(e,i){this.store=e,this.registry=i,this.activeNgComponent$=un([this.store.select(fa),this.store.select(h6)]).pipe(U(([r,o])=>r&&(null===o||Lo(r,o))?this.registry.getNgComponentByRouteKind(r.routeKind):null))}}return n.\u0275fac=function(e){return new(e||n)(C(ke),C(wl))},n.\u0275cmp=k({type:n,selectors:[["router-outlet"]],decls:2,vars:3,consts:[[3,"activeNgComponent"]],template:function(e,i){1&e&&(P(0,"router-outlet-component",0),G(1,"async")),2&e&&_("activeNgComponent",W(1,1,i.activeNgComponent$))},dependencies:[Iq,lt],encapsulation:2,changeDetection:0}),n})(),Rq=(()=>{class n{constructor(e){e.select(El).subscribe(i=>{document.body.classList.toggle("dark-mode",i)})}}return n.\u0275fac=function(e){return new(e||n)(C(ke))},n.\u0275cmp=k({type:n,selectors:[["dark-mode-supporter"]],decls:0,vars:0,template:function(e,i){},styles:["[_nghost-%COMP%] {\n        display: none;\n      }"],changeDetection:0}),n})(),Og=(()=>(function(n){n[n.ACTIVE_PLUGIN=0]="ACTIVE_PLUGIN"}(Og||(Og={})),Og))(),kq=(()=>{class n{constructor(e){this.deepLinker=e,this.onValueChange=new L,this.ngUnsubscribe=new Ae,this.onHashChange=ai(window,"popstate",{passive:!0}).pipe(ot(this.ngUnsubscribe))}ngOnInit(){this.onHashChange.subscribe(()=>{let e=this.deepLinker.getPluginId();e!==this.activePluginId&&this.onValueChange.emit({prop:Og.ACTIVE_PLUGIN,value:e})})}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}ngOnChanges(e){if(e.activePluginId){let i=e.activePluginId;this.deepLinker.setPluginId(null===i.currentValue?"":i.currentValue,{defaultValue:"",useLocationReplace:null===i.previousValue||i.firstChange})}}}return n.\u0275fac=function(e){return new(e||n)(C(vu))},n.\u0275cmp=k({type:n,selectors:[["hash-storage-component"]],inputs:{activePluginId:"activePluginId"},outputs:{onValueChange:"onValueChange"},features:[Gt],decls:0,vars:0,template:function(e,i){},encapsulation:2,changeDetection:0}),n})(),Pq=(()=>{class n{constructor(e){this.store=e,this.activePluginId$=this.store.pipe(pn(qo))}onValueChanged(e){e.prop===Og.ACTIVE_PLUGIN&&this.store.dispatch(gS({plugin:e.value}))}}return n.\u0275fac=function(e){return new(e||n)(C(ke))},n.\u0275cmp=k({type:n,selectors:[["hash-storage"]],decls:2,vars:3,consts:[[3,"activePluginId","onValueChange"]],template:function(e,i){1&e&&(h(0,"hash-storage-component",0),D("onValueChange",function(o){return i.onValueChanged(o)}),G(1,"async"),g()),2&e&&_("activePluginId",W(1,1,i.activePluginId$))},dependencies:[kq,lt],styles:["[_nghost-%COMP%] {\n        display: none;\n      }"],changeDetection:0}),n})(),kve=["*"];function sv(n){return function(){if(void 0===_E&&(_E=null,typeof window<"u")){let n=window;void 0!==n.trustedTypes&&(_E=n.trustedTypes.createPolicy("angular#components",{createHTML:t=>t}))}return _E}()?.createHTML(n)||n}function Oq(n){return Error(`Unable to find icon with the name "${n}"`)}function Fq(n){return Error(`The URL provided to MatIconRegistry was not trusted as a resource URL via Angular's DomSanitizer. Attempted URL was "${n}".`)}function Lq(n){return Error(`The literal provided to MatIconRegistry was not trusted as safe HTML by Angular's DomSanitizer. Attempted literal was "${n}".`)}var Ed=class{constructor(t,e,i){this.url=t,this.svgText=e,this.options=i}},Fg=(()=>{class n{constructor(e,i,r,o){this._httpClient=e,this._sanitizer=i,this._errorHandler=o,this._svgIconConfigs=new Map,this._iconSetConfigs=new Map,this._cachedIconsByUrl=new Map,this._inProgressUrlFetches=new Map,this._fontCssClassesByAlias=new Map,this._resolvers=[],this._defaultFontSetClass=["material-icons","mat-ligature-font"],this._document=r}addSvgIcon(e,i,r){return this.addSvgIconInNamespace("",e,i,r)}addSvgIconLiteral(e,i,r){return this.addSvgIconLiteralInNamespace("",e,i,r)}addSvgIconInNamespace(e,i,r,o){return this._addSvgIconConfig(e,i,new Ed(r,null,o))}addSvgIconResolver(e){return this._resolvers.push(e),this}addSvgIconLiteralInNamespace(e,i,r,o){let a=this._sanitizer.sanitize(qr.HTML,r);if(!a)throw Lq(r);let s=sv(a);return this._addSvgIconConfig(e,i,new Ed("",s,o))}addSvgIconSet(e,i){return this.addSvgIconSetInNamespace("",e,i)}addSvgIconSetLiteral(e,i){return this.addSvgIconSetLiteralInNamespace("",e,i)}addSvgIconSetInNamespace(e,i,r){return this._addSvgIconSetConfig(e,new Ed(i,null,r))}addSvgIconSetLiteralInNamespace(e,i,r){let o=this._sanitizer.sanitize(qr.HTML,i);if(!o)throw Lq(i);let a=sv(o);return this._addSvgIconSetConfig(e,new Ed("",a,r))}registerFontClassAlias(e,i=e){return this._fontCssClassesByAlias.set(e,i),this}classNameForFontAlias(e){return this._fontCssClassesByAlias.get(e)||e}setDefaultFontSetClass(...e){return this._defaultFontSetClass=e,this}getDefaultFontSetClass(){return this._defaultFontSetClass}getSvgIconFromUrl(e){let i=this._sanitizer.sanitize(qr.RESOURCE_URL,e);if(!i)throw Fq(e);let r=this._cachedIconsByUrl.get(i);return r?qt(yE(r)):this._loadSvgIconFromConfig(new Ed(e,null)).pipe(Vt(o=>this._cachedIconsByUrl.set(i,o)),U(o=>yE(o)))}getNamedSvgIcon(e,i=""){let r=Nq(i,e),o=this._svgIconConfigs.get(r);if(o)return this._getSvgFromConfig(o);if(o=this._getIconConfigFromResolvers(i,e),o)return this._svgIconConfigs.set(r,o),this._getSvgFromConfig(o);let a=this._iconSetConfigs.get(i);return a?this._getSvgFromIconSetConfigs(e,a):cl(Oq(r))}ngOnDestroy(){this._resolvers=[],this._svgIconConfigs.clear(),this._iconSetConfigs.clear(),this._cachedIconsByUrl.clear()}_getSvgFromConfig(e){return e.svgText?qt(yE(this._svgElementFromConfig(e))):this._loadSvgIconFromConfig(e).pipe(U(i=>yE(i)))}_getSvgFromIconSetConfigs(e,i){let r=this._extractIconWithNameFromAnySet(e,i);return r?qt(r):po(i.filter(a=>!a.svgText).map(a=>this._loadSvgIconSetFromConfig(a).pipe(fo(s=>{let c=`Loading icon set URL: ${this._sanitizer.sanitize(qr.RESOURCE_URL,a.url)} failed: ${s.message}`;return this._errorHandler.handleError(new Error(c)),qt(null)})))).pipe(U(()=>{let a=this._extractIconWithNameFromAnySet(e,i);if(!a)throw Oq(e);return a}))}_extractIconWithNameFromAnySet(e,i){for(let r=i.length-1;r>=0;r--){let o=i[r];if(o.svgText&&o.svgText.toString().indexOf(e)>-1){let a=this._svgElementFromConfig(o),s=this._extractSvgIconFromSet(a,e,o.options);if(s)return s}}return null}_loadSvgIconFromConfig(e){return this._fetchIcon(e).pipe(Vt(i=>e.svgText=i),U(()=>this._svgElementFromConfig(e)))}_loadSvgIconSetFromConfig(e){return e.svgText?qt(null):this._fetchIcon(e).pipe(Vt(i=>e.svgText=i))}_extractSvgIconFromSet(e,i,r){let o=e.querySelector(`[id="${i}"]`);if(!o)return null;let a=o.cloneNode(!0);if(a.removeAttribute("id"),"svg"===a.nodeName.toLowerCase())return this._setSvgAttributes(a,r);if("symbol"===a.nodeName.toLowerCase())return this._setSvgAttributes(this._toSvgElement(a),r);let s=this._svgElementFromString(sv("<svg></svg>"));return s.appendChild(a),this._setSvgAttributes(s,r)}_svgElementFromString(e){let i=this._document.createElement("DIV");i.innerHTML=e;let r=i.querySelector("svg");if(!r)throw Error("<svg> tag not found");return r}_toSvgElement(e){let i=this._svgElementFromString(sv("<svg></svg>")),r=e.attributes;for(let o=0;o<r.length;o++){let{name:a,value:s}=r[o];"id"!==a&&i.setAttribute(a,s)}for(let o=0;o<e.childNodes.length;o++)e.childNodes[o].nodeType===this._document.ELEMENT_NODE&&i.appendChild(e.childNodes[o].cloneNode(!0));return i}_setSvgAttributes(e,i){return e.setAttribute("fit",""),e.setAttribute("height","100%"),e.setAttribute("width","100%"),e.setAttribute("preserveAspectRatio","xMidYMid meet"),e.setAttribute("focusable","false"),i&&i.viewBox&&e.setAttribute("viewBox",i.viewBox),e}_fetchIcon(e){let{url:i,options:r}=e,o=r?.withCredentials??!1;if(!this._httpClient)throw Error("Could not find HttpClient provider for use with Angular Material icons. Please include the HttpClientModule from @angular/common/http in your app imports.");if(null==i)throw Error(`Cannot fetch icon from URL "${i}".`);let a=this._sanitizer.sanitize(qr.RESOURCE_URL,i);if(!a)throw Fq(i);let s=this._inProgressUrlFetches.get(a);if(s)return s;let l=this._httpClient.get(a,{responseType:"text",withCredentials:o}).pipe(U(c=>sv(c)),function(n){return Kt((t,e)=>{try{t.subscribe(e)}finally{e.add(n)}})}(()=>this._inProgressUrlFetches.delete(a)),Sa());return this._inProgressUrlFetches.set(a,l),l}_addSvgIconConfig(e,i,r){return this._svgIconConfigs.set(Nq(e,i),r),this}_addSvgIconSetConfig(e,i){let r=this._iconSetConfigs.get(e);return r?r.push(i):this._iconSetConfigs.set(e,[i]),this}_svgElementFromConfig(e){if(!e.svgElement){let i=this._svgElementFromString(e.svgText);this._setSvgAttributes(i,e.options),e.svgElement=i}return e.svgElement}_getIconConfigFromResolvers(e,i){for(let r=0;r<this._resolvers.length;r++){let o=this._resolvers[r](i,e);if(o)return Lve(o)?new Ed(o.url,null,o.options):new Ed(o,null)}}}return n.\u0275fac=function(e){return new(e||n)(O(ff,8),O(nf),O(kt,8),O(ca))},n.\u0275prov=pe({token:n,factory:n.\u0275fac,providedIn:"root"}),n})();function yE(n){return n.cloneNode(!0)}function Nq(n,t){return n+":"+t}function Lve(n){return!(!n.url||!n.options)}new Aa,new id,new Aa,new Aa;var Nve=go(class{constructor(n){this._elementRef=n}}),Bve=new ie("MAT_ICON_DEFAULT_OPTIONS"),Vve=new ie("mat-icon-location",{providedIn:"root",factory:function(){let n=pi(kt),t=n?n.location:null;return{getPathname:()=>t?t.pathname+t.search:""}}}),Bq=["clip-path","color-profile","src","cursor","fill","filter","marker","marker-start","marker-mid","marker-end","mask","stroke"],zve=Bq.map(n=>`[${n}]`).join(", "),Uve=/^url\(['"]?#(.*?)['"]?\)$/,Dn=(()=>{class n extends Nve{get inline(){return this._inline}set inline(e){this._inline=Ut(e)}get svgIcon(){return this._svgIcon}set svgIcon(e){e!==this._svgIcon&&(e?this._updateSvgIcon(e):this._svgIcon&&this._clearSvgElement(),this._svgIcon=e)}get fontSet(){return this._fontSet}set fontSet(e){let i=this._cleanupFontValue(e);i!==this._fontSet&&(this._fontSet=i,this._updateFontIconClasses())}get fontIcon(){return this._fontIcon}set fontIcon(e){let i=this._cleanupFontValue(e);i!==this._fontIcon&&(this._fontIcon=i,this._updateFontIconClasses())}constructor(e,i,r,o,a,s){super(e),this._iconRegistry=i,this._location=o,this._errorHandler=a,this._inline=!1,this._previousFontSetClass=[],this._currentIconFetch=yn.EMPTY,s&&(s.color&&(this.color=this.defaultColor=s.color),s.fontSet&&(this.fontSet=s.fontSet)),r||e.nativeElement.setAttribute("aria-hidden","true")}_splitIconName(e){if(!e)return["",""];let i=e.split(":");switch(i.length){case 1:return["",i[0]];case 2:return i;default:throw Error(`Invalid icon name: "${e}"`)}}ngOnInit(){this._updateFontIconClasses()}ngAfterViewChecked(){let e=this._elementsWithExternalReferences;if(e&&e.size){let i=this._location.getPathname();i!==this._previousPath&&(this._previousPath=i,this._prependPathToReferences(i))}}ngOnDestroy(){this._currentIconFetch.unsubscribe(),this._elementsWithExternalReferences&&this._elementsWithExternalReferences.clear()}_usingFontIcon(){return!this.svgIcon}_setSvgElement(e){this._clearSvgElement();let i=this._location.getPathname();this._previousPath=i,this._cacheChildrenWithExternalReferences(e),this._prependPathToReferences(i),this._elementRef.nativeElement.appendChild(e)}_clearSvgElement(){let e=this._elementRef.nativeElement,i=e.childNodes.length;for(this._elementsWithExternalReferences&&this._elementsWithExternalReferences.clear();i--;){let r=e.childNodes[i];(1!==r.nodeType||"svg"===r.nodeName.toLowerCase())&&r.remove()}}_updateFontIconClasses(){if(!this._usingFontIcon())return;let e=this._elementRef.nativeElement,i=(this.fontSet?this._iconRegistry.classNameForFontAlias(this.fontSet).split(/ +/):this._iconRegistry.getDefaultFontSetClass()).filter(r=>r.length>0);this._previousFontSetClass.forEach(r=>e.classList.remove(r)),i.forEach(r=>e.classList.add(r)),this._previousFontSetClass=i,this.fontIcon!==this._previousFontIconClass&&!i.includes("mat-ligature-font")&&(this._previousFontIconClass&&e.classList.remove(this._previousFontIconClass),this.fontIcon&&e.classList.add(this.fontIcon),this._previousFontIconClass=this.fontIcon)}_cleanupFontValue(e){return"string"==typeof e?e.trim().split(" ")[0]:e}_prependPathToReferences(e){let i=this._elementsWithExternalReferences;i&&i.forEach((r,o)=>{r.forEach(a=>{o.setAttribute(a.name,`url('${e}#${a.value}')`)})})}_cacheChildrenWithExternalReferences(e){let i=e.querySelectorAll(zve),r=this._elementsWithExternalReferences=this._elementsWithExternalReferences||new Map;for(let o=0;o<i.length;o++)Bq.forEach(a=>{let s=i[o],l=s.getAttribute(a),c=l?l.match(Uve):null;if(c){let d=r.get(s);d||(d=[],r.set(s,d)),d.push({name:a,value:c[1]})}})}_updateSvgIcon(e){if(this._svgNamespace=null,this._svgName=null,this._currentIconFetch.unsubscribe(),e){let[i,r]=this._splitIconName(e);i&&(this._svgNamespace=i),r&&(this._svgName=r),this._currentIconFetch=this._iconRegistry.getNamedSvgIcon(r,i).pipe(zt(1)).subscribe(o=>this._setSvgElement(o),o=>{this._errorHandler.handleError(new Error(`Error retrieving icon ${i}:${r}! ${o.message}`))})}}}return n.\u0275fac=function(e){return new(e||n)(C(be),C(Fg),Vr("aria-hidden"),C(Vve),C(ca),C(Bve,8))},n.\u0275cmp=k({type:n,selectors:[["mat-icon"]],hostAttrs:["role","img",1,"mat-icon","notranslate"],hostVars:8,hostBindings:function(e,i){2&e&&(Pe("data-mat-icon-type",i._usingFontIcon()?"font":"svg")("data-mat-icon-name",i._svgName||i.fontIcon)("data-mat-icon-namespace",i._svgNamespace||i.fontSet)("fontIcon",i._usingFontIcon()?i.fontIcon:null),Qe("mat-icon-inline",i.inline)("mat-icon-no-color","primary"!==i.color&&"accent"!==i.color&&"warn"!==i.color))},inputs:{color:"color",inline:"inline",svgIcon:"svgIcon",fontSet:"fontSet",fontIcon:"fontIcon"},exportAs:["matIcon"],features:[Le],ngContentSelectors:kve,decls:1,vars:0,template:function(e,i){1&e&&(gn(),Xt(0))},styles:[".mat-icon{-webkit-user-select:none;user-select:none;background-repeat:no-repeat;display:inline-block;fill:currentColor;height:24px;width:24px;overflow:hidden}.mat-icon.mat-icon-inline{font-size:inherit;height:inherit;line-height:inherit;width:inherit}.mat-icon.mat-ligature-font[fontIcon]::before{content:attr(fontIcon)}[dir=rtl] .mat-icon-rtl-mirror{transform:scale(-1, 1)}.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-prefix .mat-icon,.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-suffix .mat-icon{display:block}.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-prefix .mat-icon-button .mat-icon,.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-suffix .mat-icon-button .mat-icon{margin:auto}"],encapsulation:2,changeDetection:0}),n})(),mi=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Qt,Qt]}),n})(),jve=["*",[["mat-toolbar-row"]]],Gve=["*","mat-toolbar-row"],Wve=go(class{constructor(n){this._elementRef=n}}),qve=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275dir=xe({type:n,selectors:[["mat-toolbar-row"]],hostAttrs:[1,"mat-toolbar-row"],exportAs:["matToolbarRow"]}),n})(),Vq=(()=>{class n extends Wve{constructor(e,i,r){super(e),this._platform=i,this._document=r}ngAfterViewInit(){this._platform.isBrowser&&(this._checkToolbarMixedModes(),this._toolbarRows.changes.subscribe(()=>this._checkToolbarMixedModes()))}_checkToolbarMixedModes(){}}return n.\u0275fac=function(e){return new(e||n)(C(be),C($n),C(kt))},n.\u0275cmp=k({type:n,selectors:[["mat-toolbar"]],contentQueries:function(e,i,r){if(1&e&&ci(r,qve,5),2&e){let o;we(o=Se())&&(i._toolbarRows=o)}},hostAttrs:[1,"mat-toolbar"],hostVars:4,hostBindings:function(e,i){2&e&&Qe("mat-toolbar-multiple-rows",i._toolbarRows.length>0)("mat-toolbar-single-row",0===i._toolbarRows.length)},inputs:{color:"color"},exportAs:["matToolbar"],features:[Le],ngContentSelectors:Gve,decls:2,vars:0,template:function(e,i){1&e&&(gn(jve),Xt(0),Xt(1,1))},styles:[".cdk-high-contrast-active .mat-toolbar{outline:solid 1px}.mat-toolbar .mat-mdc-button-base.mat-unthemed{--mdc-text-button-label-text-color: inherit;--mdc-outlined-button-label-text-color: inherit}.mat-toolbar-row,.mat-toolbar-single-row{display:flex;box-sizing:border-box;padding:0 16px;width:100%;flex-direction:row;align-items:center;white-space:nowrap}.mat-toolbar-multiple-rows{display:flex;box-sizing:border-box;flex-direction:column;width:100%}"],encapsulation:2,changeDetection:0}),n})(),Hq=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Qt,Qt]}),n})();function cL(n){return n.state!==De.NOT_LOADED&&n.state!==De.LOADING}var Xve=_r(m7,Ee(C1,n=>cL(n)?{...n,settings:{...n.settings,reloadEnabled:!n.settings.reloadEnabled}}:n),Ee(M1,(n,{periodInMs:t})=>{if(!cL(n))return n;let e=t>=3e4?t:n.settings.reloadPeriodInMs;return{...n,settings:{...n.settings,reloadPeriodInMs:e}}}),Ee(w1,(n,{size:t})=>{if(!cL(n))return n;let e=t>0?t:n.settings.pageSize;return{...n,settings:{...n.settings,pageSize:e}}}),Ee(Sl,(n,{partialSettings:t})=>{let e={};return Number.isFinite(t.pageSize)&&t.pageSize>0&&(e.pageSize=Number(t.pageSize)),"boolean"==typeof t.autoReload&&(e.reloadEnabled=t.autoReload),Number.isFinite(t.autoReloadPeriodInMs)&&t.autoReloadPeriodInMs>3e4&&(e.reloadPeriodInMs=Number(t.autoReloadPeriodInMs)),{...n,settings:{...n.settings,...e}}}));function zq(n,t){return Xve(n,t)}var Qve=["input"],Zve=["label"],Kve=["*"],uL=new ie("mat-checkbox-default-options",{providedIn:"root",factory:function(){return{color:"accent",clickAction:"check-indeterminate"}}});var Jve={provide:Hr,useExisting:Vn(()=>txe),multi:!0},$ve=0,Uq={color:"accent",clickAction:"check-indeterminate"},exe=vd(go(Qo(Kr(class{constructor(n){this._elementRef=n}})))),pL=(()=>{class n extends exe{get inputId(){return`${this.id||this._uniqueId}-input`}get required(){return this._required}set required(e){this._required=Ut(e)}constructor(e,i,r,o,a,s,l){super(i),this._changeDetectorRef=r,this._ngZone=o,this._animationMode=s,this._options=l,this.ariaLabel="",this.ariaLabelledby=null,this.labelPosition="after",this.name=null,this.change=new L,this.indeterminateChange=new L,this._onTouched=()=>{},this._currentAnimationClass="",this._currentCheckState=0,this._controlValueAccessorChangeFn=()=>{},this._checked=!1,this._disabled=!1,this._indeterminate=!1,this._options=this._options||Uq,this.color=this.defaultColor=this._options.color||Uq.color,this.tabIndex=parseInt(a)||0,this.id=this._uniqueId=`${e}${++$ve}`}ngAfterViewInit(){this._syncIndeterminate(this._indeterminate)}get checked(){return this._checked}set checked(e){let i=Ut(e);i!=this.checked&&(this._checked=i,this._changeDetectorRef.markForCheck())}get disabled(){return this._disabled}set disabled(e){let i=Ut(e);i!==this.disabled&&(this._disabled=i,this._changeDetectorRef.markForCheck())}get indeterminate(){return this._indeterminate}set indeterminate(e){let i=e!=this._indeterminate;this._indeterminate=Ut(e),i&&(this._transitionCheckState(this._indeterminate?3:this.checked?1:2),this.indeterminateChange.emit(this._indeterminate)),this._syncIndeterminate(this._indeterminate)}_isRippleDisabled(){return this.disableRipple||this.disabled}_onLabelTextChange(){this._changeDetectorRef.detectChanges()}writeValue(e){this.checked=!!e}registerOnChange(e){this._controlValueAccessorChangeFn=e}registerOnTouched(e){this._onTouched=e}setDisabledState(e){this.disabled=e}_transitionCheckState(e){let i=this._currentCheckState,r=this._getAnimationTargetElement();if(i!==e&&r&&(this._currentAnimationClass&&r.classList.remove(this._currentAnimationClass),this._currentAnimationClass=this._getAnimationClassForCheckStateTransition(i,e),this._currentCheckState=e,this._currentAnimationClass.length>0)){r.classList.add(this._currentAnimationClass);let o=this._currentAnimationClass;this._ngZone.runOutsideAngular(()=>{setTimeout(()=>{r.classList.remove(o)},1e3)})}}_emitChangeEvent(){this._controlValueAccessorChangeFn(this.checked),this.change.emit(this._createChangeEvent(this.checked)),this._inputElement&&(this._inputElement.nativeElement.checked=this.checked)}toggle(){this.checked=!this.checked,this._controlValueAccessorChangeFn(this.checked)}_handleInputClick(){let e=this._options?.clickAction;this.disabled||"noop"===e?!this.disabled&&"noop"===e&&(this._inputElement.nativeElement.checked=this.checked,this._inputElement.nativeElement.indeterminate=this.indeterminate):(this.indeterminate&&"check"!==e&&Promise.resolve().then(()=>{this._indeterminate=!1,this.indeterminateChange.emit(this._indeterminate)}),this._checked=!this._checked,this._transitionCheckState(this._checked?1:2),this._emitChangeEvent())}_onInteractionEvent(e){e.stopPropagation()}_onBlur(){Promise.resolve().then(()=>{this._onTouched(),this._changeDetectorRef.markForCheck()})}_getAnimationClassForCheckStateTransition(e,i){if("NoopAnimations"===this._animationMode)return"";switch(e){case 0:if(1===i)return this._animationClasses.uncheckedToChecked;if(3==i)return this._checked?this._animationClasses.checkedToIndeterminate:this._animationClasses.uncheckedToIndeterminate;break;case 2:return 1===i?this._animationClasses.uncheckedToChecked:this._animationClasses.uncheckedToIndeterminate;case 1:return 2===i?this._animationClasses.checkedToUnchecked:this._animationClasses.checkedToIndeterminate;case 3:return 1===i?this._animationClasses.indeterminateToChecked:this._animationClasses.indeterminateToUnchecked}return""}_syncIndeterminate(e){let i=this._inputElement;i&&(i.nativeElement.indeterminate=e)}}return n.\u0275fac=function(e){_l()},n.\u0275dir=xe({type:n,viewQuery:function(e,i){if(1&e&&(Ye(Qve,5),Ye(Zve,5),Ye(Fr,5)),2&e){let r;we(r=Se())&&(i._inputElement=r.first),we(r=Se())&&(i._labelElement=r.first),we(r=Se())&&(i.ripple=r.first)}},inputs:{ariaLabel:["aria-label","ariaLabel"],ariaLabelledby:["aria-labelledby","ariaLabelledby"],ariaDescribedby:["aria-describedby","ariaDescribedby"],id:"id",required:"required",labelPosition:"labelPosition",name:"name",value:"value",checked:"checked",disabled:"disabled",indeterminate:"indeterminate"},outputs:{change:"change",indeterminateChange:"indeterminateChange"},features:[Le]}),n})(),txe=(()=>{class n extends pL{constructor(e,i,r,o,a,s){super("mat-mdc-checkbox-",e,i,r,o,a,s),this._animationClasses={uncheckedToChecked:"mdc-checkbox--anim-unchecked-checked",uncheckedToIndeterminate:"mdc-checkbox--anim-unchecked-indeterminate",checkedToUnchecked:"mdc-checkbox--anim-checked-unchecked",checkedToIndeterminate:"mdc-checkbox--anim-checked-indeterminate",indeterminateToChecked:"mdc-checkbox--anim-indeterminate-checked",indeterminateToUnchecked:"mdc-checkbox--anim-indeterminate-unchecked"}}focus(){this._inputElement.nativeElement.focus()}_createChangeEvent(e){let i=new class{};return i.source=this,i.checked=e,i}_getAnimationTargetElement(){return this._inputElement?.nativeElement}_onInputClick(){super._handleInputClick()}_onTouchTargetClick(){super._handleInputClick(),this.disabled||this._inputElement.nativeElement.focus()}_preventBubblingFromLabel(e){e.target&&this._labelElement.nativeElement.contains(e.target)&&e.stopPropagation()}}return n.\u0275fac=function(e){return new(e||n)(C(be),C(Ft),C(at),Vr("tabindex"),C(di,8),C(uL,8))},n.\u0275cmp=k({type:n,selectors:[["mat-checkbox"]],hostAttrs:[1,"mat-mdc-checkbox"],hostVars:12,hostBindings:function(e,i){2&e&&(Co("id",i.id),Pe("tabindex",null)("aria-label",null)("aria-labelledby",null),Qe("_mat-animation-noopable","NoopAnimations"===i._animationMode)("mdc-checkbox--disabled",i.disabled)("mat-mdc-checkbox-disabled",i.disabled)("mat-mdc-checkbox-checked",i.checked))},inputs:{disableRipple:"disableRipple",color:"color",tabIndex:"tabIndex"},exportAs:["matCheckbox"],features:[Rt([Jve]),Le],ngContentSelectors:Kve,decls:15,vars:19,consts:[[1,"mdc-form-field",3,"click"],[1,"mdc-checkbox"],["checkbox",""],[1,"mat-mdc-checkbox-touch-target",3,"click"],["type","checkbox",1,"mdc-checkbox__native-control",3,"checked","indeterminate","disabled","id","required","tabIndex","blur","click","change"],["input",""],[1,"mdc-checkbox__ripple"],[1,"mdc-checkbox__background"],["focusable","false","viewBox","0 0 24 24","aria-hidden","true",1,"mdc-checkbox__checkmark"],["fill","none","d","M1.73,12.91 8.1,19.28 22.79,4.59",1,"mdc-checkbox__checkmark-path"],[1,"mdc-checkbox__mixedmark"],["mat-ripple","",1,"mat-mdc-checkbox-ripple","mat-mdc-focus-indicator",3,"matRippleTrigger","matRippleDisabled","matRippleCentered"],[3,"for"],["label",""]],template:function(e,i){if(1&e&&(gn(),h(0,"div",0),D("click",function(o){return i._preventBubblingFromLabel(o)}),h(1,"div",1,2)(3,"div",3),D("click",function(){return i._onTouchTargetClick()}),g(),h(4,"input",4,5),D("blur",function(){return i._onBlur()})("click",function(){return i._onInputClick()})("change",function(o){return i._onInteractionEvent(o)}),g(),P(6,"div",6),h(7,"div",7),Tn(),h(8,"svg",8),P(9,"path",9),g(),Oo(),P(10,"div",10),g(),P(11,"div",11),g(),h(12,"label",12,13),Xt(14),g()()),2&e){let r=tt(2);Qe("mdc-form-field--align-end","before"==i.labelPosition),b(4),Qe("mdc-checkbox--selected",i.checked),_("checked",i.checked)("indeterminate",i.indeterminate)("disabled",i.disabled)("id",i.inputId)("required",i.required)("tabIndex",i.tabIndex),Pe("aria-label",i.ariaLabel||null)("aria-labelledby",i.ariaLabelledby)("aria-describedby",i.ariaDescribedby)("name",i.name)("value",i.value),b(7),_("matRippleTrigger",r)("matRippleDisabled",i.disableRipple||i.disabled)("matRippleCentered",!0),b(1),_("for",i.inputId)}},dependencies:[Fr],styles:['.mdc-touch-target-wrapper{display:inline}@keyframes mdc-checkbox-unchecked-checked-checkmark-path{0%,50%{stroke-dashoffset:29.7833385}50%{animation-timing-function:cubic-bezier(0, 0, 0.2, 1)}100%{stroke-dashoffset:0}}@keyframes mdc-checkbox-unchecked-indeterminate-mixedmark{0%,68.2%{transform:scaleX(0)}68.2%{animation-timing-function:cubic-bezier(0, 0, 0, 1)}100%{transform:scaleX(1)}}@keyframes mdc-checkbox-checked-unchecked-checkmark-path{from{animation-timing-function:cubic-bezier(0.4, 0, 1, 1);opacity:1;stroke-dashoffset:0}to{opacity:0;stroke-dashoffset:-29.7833385}}@keyframes mdc-checkbox-checked-indeterminate-checkmark{from{animation-timing-function:cubic-bezier(0, 0, 0.2, 1);transform:rotate(0deg);opacity:1}to{transform:rotate(45deg);opacity:0}}@keyframes mdc-checkbox-indeterminate-checked-checkmark{from{animation-timing-function:cubic-bezier(0.14, 0, 0, 1);transform:rotate(45deg);opacity:0}to{transform:rotate(360deg);opacity:1}}@keyframes mdc-checkbox-checked-indeterminate-mixedmark{from{animation-timing-function:mdc-animation-deceleration-curve-timing-function;transform:rotate(-45deg);opacity:0}to{transform:rotate(0deg);opacity:1}}@keyframes mdc-checkbox-indeterminate-checked-mixedmark{from{animation-timing-function:cubic-bezier(0.14, 0, 0, 1);transform:rotate(0deg);opacity:1}to{transform:rotate(315deg);opacity:0}}@keyframes mdc-checkbox-indeterminate-unchecked-mixedmark{0%{animation-timing-function:linear;transform:scaleX(1);opacity:1}32.8%,100%{transform:scaleX(0);opacity:0}}.mdc-checkbox{display:inline-block;position:relative;flex:0 0 18px;box-sizing:content-box;width:18px;height:18px;line-height:0;white-space:nowrap;cursor:pointer;vertical-align:bottom}.mdc-checkbox[hidden]{display:none}.mdc-checkbox.mdc-ripple-upgraded--background-focused .mdc-checkbox__focus-ring,.mdc-checkbox:not(.mdc-ripple-upgraded):focus .mdc-checkbox__focus-ring{pointer-events:none;border:2px solid rgba(0,0,0,0);border-radius:6px;box-sizing:content-box;position:absolute;top:50%;left:50%;transform:translate(-50%, -50%);height:100%;width:100%}@media screen and (forced-colors: active){.mdc-checkbox.mdc-ripple-upgraded--background-focused .mdc-checkbox__focus-ring,.mdc-checkbox:not(.mdc-ripple-upgraded):focus .mdc-checkbox__focus-ring{border-color:CanvasText}}.mdc-checkbox.mdc-ripple-upgraded--background-focused .mdc-checkbox__focus-ring::after,.mdc-checkbox:not(.mdc-ripple-upgraded):focus .mdc-checkbox__focus-ring::after{content:"";border:2px solid rgba(0,0,0,0);border-radius:8px;display:block;position:absolute;top:50%;left:50%;transform:translate(-50%, -50%);height:calc(100% + 4px);width:calc(100% + 4px)}@media screen and (forced-colors: active){.mdc-checkbox.mdc-ripple-upgraded--background-focused .mdc-checkbox__focus-ring::after,.mdc-checkbox:not(.mdc-ripple-upgraded):focus .mdc-checkbox__focus-ring::after{border-color:CanvasText}}@media all and (-ms-high-contrast: none){.mdc-checkbox .mdc-checkbox__focus-ring{display:none}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mdc-checkbox__mixedmark{margin:0 1px}}.mdc-checkbox--disabled{cursor:default;pointer-events:none}.mdc-checkbox__background{display:inline-flex;position:absolute;align-items:center;justify-content:center;box-sizing:border-box;width:18px;height:18px;border:2px solid currentColor;border-radius:2px;background-color:rgba(0,0,0,0);pointer-events:none;will-change:background-color,border-color;transition:background-color 90ms 0ms cubic-bezier(0.4, 0, 0.6, 1),border-color 90ms 0ms cubic-bezier(0.4, 0, 0.6, 1)}.mdc-checkbox__checkmark{position:absolute;top:0;right:0;bottom:0;left:0;width:100%;opacity:0;transition:opacity 180ms 0ms cubic-bezier(0.4, 0, 0.6, 1)}.mdc-checkbox--upgraded .mdc-checkbox__checkmark{opacity:1}.mdc-checkbox__checkmark-path{transition:stroke-dashoffset 180ms 0ms cubic-bezier(0.4, 0, 0.6, 1);stroke:currentColor;stroke-width:3.12px;stroke-dashoffset:29.7833385;stroke-dasharray:29.7833385}.mdc-checkbox__mixedmark{width:100%;height:0;transform:scaleX(0) rotate(0deg);border-width:1px;border-style:solid;opacity:0;transition:opacity 90ms 0ms cubic-bezier(0.4, 0, 0.6, 1),transform 90ms 0ms cubic-bezier(0.4, 0, 0.6, 1)}.mdc-checkbox--anim-unchecked-checked .mdc-checkbox__background,.mdc-checkbox--anim-unchecked-indeterminate .mdc-checkbox__background,.mdc-checkbox--anim-checked-unchecked .mdc-checkbox__background,.mdc-checkbox--anim-indeterminate-unchecked .mdc-checkbox__background{animation-duration:180ms;animation-timing-function:linear}.mdc-checkbox--anim-unchecked-checked .mdc-checkbox__checkmark-path{animation:mdc-checkbox-unchecked-checked-checkmark-path 180ms linear 0s;transition:none}.mdc-checkbox--anim-unchecked-indeterminate .mdc-checkbox__mixedmark{animation:mdc-checkbox-unchecked-indeterminate-mixedmark 90ms linear 0s;transition:none}.mdc-checkbox--anim-checked-unchecked .mdc-checkbox__checkmark-path{animation:mdc-checkbox-checked-unchecked-checkmark-path 90ms linear 0s;transition:none}.mdc-checkbox--anim-checked-indeterminate .mdc-checkbox__checkmark{animation:mdc-checkbox-checked-indeterminate-checkmark 90ms linear 0s;transition:none}.mdc-checkbox--anim-checked-indeterminate .mdc-checkbox__mixedmark{animation:mdc-checkbox-checked-indeterminate-mixedmark 90ms linear 0s;transition:none}.mdc-checkbox--anim-indeterminate-checked .mdc-checkbox__checkmark{animation:mdc-checkbox-indeterminate-checked-checkmark 500ms linear 0s;transition:none}.mdc-checkbox--anim-indeterminate-checked .mdc-checkbox__mixedmark{animation:mdc-checkbox-indeterminate-checked-mixedmark 500ms linear 0s;transition:none}.mdc-checkbox--anim-indeterminate-unchecked .mdc-checkbox__mixedmark{animation:mdc-checkbox-indeterminate-unchecked-mixedmark 300ms linear 0s;transition:none}.mdc-checkbox__native-control:checked~.mdc-checkbox__background,.mdc-checkbox__native-control:indeterminate~.mdc-checkbox__background,.mdc-checkbox__native-control[data-indeterminate=true]~.mdc-checkbox__background{transition:border-color 90ms 0ms cubic-bezier(0, 0, 0.2, 1),background-color 90ms 0ms cubic-bezier(0, 0, 0.2, 1)}.mdc-checkbox__native-control:checked~.mdc-checkbox__background .mdc-checkbox__checkmark-path,.mdc-checkbox__native-control:indeterminate~.mdc-checkbox__background .mdc-checkbox__checkmark-path,.mdc-checkbox__native-control[data-indeterminate=true]~.mdc-checkbox__background .mdc-checkbox__checkmark-path{stroke-dashoffset:0}.mdc-checkbox__native-control{position:absolute;margin:0;padding:0;opacity:0;cursor:inherit}.mdc-checkbox__native-control:disabled{cursor:default;pointer-events:none}.mdc-checkbox--touch{margin:calc((var(--mdc-checkbox-state-layer-size, 48px) - var(--mdc-checkbox-state-layer-size, 40px)) / 2)}.mdc-checkbox--touch .mdc-checkbox__native-control{top:calc((var(--mdc-checkbox-state-layer-size, 40px) - var(--mdc-checkbox-state-layer-size, 48px)) / 2);right:calc((var(--mdc-checkbox-state-layer-size, 40px) - var(--mdc-checkbox-state-layer-size, 48px)) / 2);left:calc((var(--mdc-checkbox-state-layer-size, 40px) - var(--mdc-checkbox-state-layer-size, 48px)) / 2);width:var(--mdc-checkbox-state-layer-size, 48px);height:var(--mdc-checkbox-state-layer-size, 48px)}.mdc-checkbox__native-control:checked~.mdc-checkbox__background .mdc-checkbox__checkmark{transition:opacity 180ms 0ms cubic-bezier(0, 0, 0.2, 1),transform 180ms 0ms cubic-bezier(0, 0, 0.2, 1);opacity:1}.mdc-checkbox__native-control:checked~.mdc-checkbox__background .mdc-checkbox__mixedmark{transform:scaleX(1) rotate(-45deg)}.mdc-checkbox__native-control:indeterminate~.mdc-checkbox__background .mdc-checkbox__checkmark,.mdc-checkbox__native-control[data-indeterminate=true]~.mdc-checkbox__background .mdc-checkbox__checkmark{transform:rotate(45deg);opacity:0;transition:opacity 90ms 0ms cubic-bezier(0.4, 0, 0.6, 1),transform 90ms 0ms cubic-bezier(0.4, 0, 0.6, 1)}.mdc-checkbox__native-control:indeterminate~.mdc-checkbox__background .mdc-checkbox__mixedmark,.mdc-checkbox__native-control[data-indeterminate=true]~.mdc-checkbox__background .mdc-checkbox__mixedmark{transform:scaleX(1) rotate(0deg);opacity:1}.mdc-checkbox.mdc-checkbox--upgraded .mdc-checkbox__background,.mdc-checkbox.mdc-checkbox--upgraded .mdc-checkbox__checkmark,.mdc-checkbox.mdc-checkbox--upgraded .mdc-checkbox__checkmark-path,.mdc-checkbox.mdc-checkbox--upgraded .mdc-checkbox__mixedmark{transition:none}.mdc-form-field{display:inline-flex;align-items:center;vertical-align:middle}.mdc-form-field[hidden]{display:none}.mdc-form-field>label{margin-left:0;margin-right:auto;padding-left:4px;padding-right:0;order:0}[dir=rtl] .mdc-form-field>label,.mdc-form-field>label[dir=rtl]{margin-left:auto;margin-right:0}[dir=rtl] .mdc-form-field>label,.mdc-form-field>label[dir=rtl]{padding-left:0;padding-right:4px}.mdc-form-field--nowrap>label{text-overflow:ellipsis;overflow:hidden;white-space:nowrap}.mdc-form-field--align-end>label{margin-left:auto;margin-right:0;padding-left:0;padding-right:4px;order:-1}[dir=rtl] .mdc-form-field--align-end>label,.mdc-form-field--align-end>label[dir=rtl]{margin-left:0;margin-right:auto}[dir=rtl] .mdc-form-field--align-end>label,.mdc-form-field--align-end>label[dir=rtl]{padding-left:4px;padding-right:0}.mdc-form-field--space-between{justify-content:space-between}.mdc-form-field--space-between>label{margin:0}[dir=rtl] .mdc-form-field--space-between>label,.mdc-form-field--space-between>label[dir=rtl]{margin:0}.mat-mdc-checkbox{display:inline-block;position:relative;-webkit-tap-highlight-color:rgba(0,0,0,0)}.mat-mdc-checkbox .mdc-checkbox{padding:calc((var(--mdc-checkbox-state-layer-size, 40px) - 18px) / 2);margin:calc((var(--mdc-checkbox-state-layer-size, 40px) - var(--mdc-checkbox-state-layer-size, 40px)) / 2)}.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__native-control[disabled]:not(:checked):not(:indeterminate):not([data-indeterminate=true])~.mdc-checkbox__background{border-color:var(--mdc-checkbox-disabled-unselected-icon-color, rgba(0, 0, 0, 0.38));background-color:transparent}.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__native-control[disabled]:checked~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__native-control[disabled]:indeterminate~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__native-control[data-indeterminate=true][disabled]~.mdc-checkbox__background{border-color:transparent;background-color:var(--mdc-checkbox-disabled-selected-icon-color, rgba(0, 0, 0, 0.38))}.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__native-control:enabled~.mdc-checkbox__background .mdc-checkbox__checkmark{color:var(--mdc-checkbox-selected-checkmark-color, #fff)}.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__native-control:enabled~.mdc-checkbox__background .mdc-checkbox__mixedmark{border-color:var(--mdc-checkbox-selected-checkmark-color, #fff)}.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__native-control:disabled~.mdc-checkbox__background .mdc-checkbox__checkmark{color:var(--mdc-checkbox-disabled-selected-checkmark-color, #fff)}.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__native-control:disabled~.mdc-checkbox__background .mdc-checkbox__mixedmark{border-color:var(--mdc-checkbox-disabled-selected-checkmark-color, #fff)}.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__native-control:enabled:not(:checked):not(:indeterminate):not([data-indeterminate=true])~.mdc-checkbox__background{border-color:var(--mdc-checkbox-unselected-icon-color, rgba(0, 0, 0, 0.54));background-color:transparent}.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__native-control:enabled:checked~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__native-control:enabled:indeterminate~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__native-control[data-indeterminate=true]:enabled~.mdc-checkbox__background{border-color:var(--mdc-checkbox-selected-icon-color, var(--mdc-theme-secondary, #018786));background-color:var(--mdc-checkbox-selected-icon-color, var(--mdc-theme-secondary, #018786))}@keyframes mdc-checkbox-fade-in-background-8A000000FF01878600000000FF018786{0%{border-color:var(--mdc-checkbox-unselected-icon-color, rgba(0, 0, 0, 0.54));background-color:transparent}50%{border-color:var(--mdc-checkbox-selected-icon-color, var(--mdc-theme-secondary, #018786));background-color:var(--mdc-checkbox-selected-icon-color, var(--mdc-theme-secondary, #018786))}}@keyframes mdc-checkbox-fade-out-background-8A000000FF01878600000000FF018786{0%,80%{border-color:var(--mdc-checkbox-selected-icon-color, var(--mdc-theme-secondary, #018786));background-color:var(--mdc-checkbox-selected-icon-color, var(--mdc-theme-secondary, #018786))}100%{border-color:var(--mdc-checkbox-unselected-icon-color, rgba(0, 0, 0, 0.54));background-color:transparent}}.mat-mdc-checkbox .mdc-checkbox.mdc-checkbox--anim-unchecked-checked .mdc-checkbox__native-control:enabled~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox.mdc-checkbox--anim-unchecked-indeterminate .mdc-checkbox__native-control:enabled~.mdc-checkbox__background{animation-name:mdc-checkbox-fade-in-background-8A000000FF01878600000000FF018786}.mat-mdc-checkbox .mdc-checkbox.mdc-checkbox--anim-checked-unchecked .mdc-checkbox__native-control:enabled~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox.mdc-checkbox--anim-indeterminate-unchecked .mdc-checkbox__native-control:enabled~.mdc-checkbox__background{animation-name:mdc-checkbox-fade-out-background-8A000000FF01878600000000FF018786}.mat-mdc-checkbox .mdc-checkbox:hover .mdc-checkbox__native-control:enabled:not(:checked):not(:indeterminate):not([data-indeterminate=true])~.mdc-checkbox__background{border-color:var(--mdc-checkbox-unselected-hover-icon-color, var(--mdc-theme-secondary, #018786));background-color:transparent}.mat-mdc-checkbox .mdc-checkbox:hover .mdc-checkbox__native-control:enabled:checked~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox:hover .mdc-checkbox__native-control:enabled:indeterminate~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox:hover .mdc-checkbox__native-control[data-indeterminate=true]:enabled~.mdc-checkbox__background{border-color:var(--mdc-checkbox-selected-hover-icon-color, var(--mdc-theme-secondary, #018786));background-color:var(--mdc-checkbox-selected-hover-icon-color, var(--mdc-theme-secondary, #018786))}@keyframes mdc-checkbox-fade-in-background-FF018786FF01878600000000FF018786{0%{border-color:var(--mdc-checkbox-unselected-hover-icon-color, var(--mdc-theme-secondary, #018786));background-color:transparent}50%{border-color:var(--mdc-checkbox-selected-hover-icon-color, var(--mdc-theme-secondary, #018786));background-color:var(--mdc-checkbox-selected-hover-icon-color, var(--mdc-theme-secondary, #018786))}}@keyframes mdc-checkbox-fade-out-background-FF018786FF01878600000000FF018786{0%,80%{border-color:var(--mdc-checkbox-selected-hover-icon-color, var(--mdc-theme-secondary, #018786));background-color:var(--mdc-checkbox-selected-hover-icon-color, var(--mdc-theme-secondary, #018786))}100%{border-color:var(--mdc-checkbox-unselected-hover-icon-color, var(--mdc-theme-secondary, #018786));background-color:transparent}}.mat-mdc-checkbox .mdc-checkbox:hover.mdc-checkbox--anim-unchecked-checked .mdc-checkbox__native-control:enabled~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox:hover.mdc-checkbox--anim-unchecked-indeterminate .mdc-checkbox__native-control:enabled~.mdc-checkbox__background{animation-name:mdc-checkbox-fade-in-background-FF018786FF01878600000000FF018786}.mat-mdc-checkbox .mdc-checkbox:hover.mdc-checkbox--anim-checked-unchecked .mdc-checkbox__native-control:enabled~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox:hover.mdc-checkbox--anim-indeterminate-unchecked .mdc-checkbox__native-control:enabled~.mdc-checkbox__background{animation-name:mdc-checkbox-fade-out-background-FF018786FF01878600000000FF018786}.mat-mdc-checkbox .mdc-checkbox.mdc-ripple-upgraded--background-focused .mdc-checkbox__native-control:enabled:not(:checked):not(:indeterminate):not([data-indeterminate=true])~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox:not(.mdc-ripple-upgraded):focus .mdc-checkbox__native-control:enabled:not(:checked):not(:indeterminate):not([data-indeterminate=true])~.mdc-checkbox__background{border-color:var(--mdc-checkbox-unselected-focus-icon-color, var(--mdc-theme-secondary, #018786));background-color:transparent}.mat-mdc-checkbox .mdc-checkbox.mdc-ripple-upgraded--background-focused .mdc-checkbox__native-control:enabled:checked~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox.mdc-ripple-upgraded--background-focused .mdc-checkbox__native-control:enabled:indeterminate~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox.mdc-ripple-upgraded--background-focused .mdc-checkbox__native-control[data-indeterminate=true]:enabled~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox:not(.mdc-ripple-upgraded):focus .mdc-checkbox__native-control:enabled:checked~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox:not(.mdc-ripple-upgraded):focus .mdc-checkbox__native-control:enabled:indeterminate~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox:not(.mdc-ripple-upgraded):focus .mdc-checkbox__native-control[data-indeterminate=true]:enabled~.mdc-checkbox__background{border-color:var(--mdc-checkbox-selected-focus-icon-color, var(--mdc-theme-secondary, #018786));background-color:var(--mdc-checkbox-selected-focus-icon-color, var(--mdc-theme-secondary, #018786))}@keyframes mdc-checkbox-fade-in-background-FF018786FF01878600000000FF018786{0%{border-color:var(--mdc-checkbox-unselected-focus-icon-color, var(--mdc-theme-secondary, #018786));background-color:transparent}50%{border-color:var(--mdc-checkbox-selected-focus-icon-color, var(--mdc-theme-secondary, #018786));background-color:var(--mdc-checkbox-selected-focus-icon-color, var(--mdc-theme-secondary, #018786))}}@keyframes mdc-checkbox-fade-out-background-FF018786FF01878600000000FF018786{0%,80%{border-color:var(--mdc-checkbox-selected-focus-icon-color, var(--mdc-theme-secondary, #018786));background-color:var(--mdc-checkbox-selected-focus-icon-color, var(--mdc-theme-secondary, #018786))}100%{border-color:var(--mdc-checkbox-unselected-focus-icon-color, var(--mdc-theme-secondary, #018786));background-color:transparent}}.mat-mdc-checkbox .mdc-checkbox.mdc-ripple-upgraded--background-focused.mdc-checkbox--anim-unchecked-checked .mdc-checkbox__native-control:enabled~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox.mdc-ripple-upgraded--background-focused.mdc-checkbox--anim-unchecked-indeterminate .mdc-checkbox__native-control:enabled~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox:not(.mdc-ripple-upgraded):focus.mdc-checkbox--anim-unchecked-checked .mdc-checkbox__native-control:enabled~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox:not(.mdc-ripple-upgraded):focus.mdc-checkbox--anim-unchecked-indeterminate .mdc-checkbox__native-control:enabled~.mdc-checkbox__background{animation-name:mdc-checkbox-fade-in-background-FF018786FF01878600000000FF018786}.mat-mdc-checkbox .mdc-checkbox.mdc-ripple-upgraded--background-focused.mdc-checkbox--anim-checked-unchecked .mdc-checkbox__native-control:enabled~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox.mdc-ripple-upgraded--background-focused.mdc-checkbox--anim-indeterminate-unchecked .mdc-checkbox__native-control:enabled~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox:not(.mdc-ripple-upgraded):focus.mdc-checkbox--anim-checked-unchecked .mdc-checkbox__native-control:enabled~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox:not(.mdc-ripple-upgraded):focus.mdc-checkbox--anim-indeterminate-unchecked .mdc-checkbox__native-control:enabled~.mdc-checkbox__background{animation-name:mdc-checkbox-fade-out-background-FF018786FF01878600000000FF018786}.mat-mdc-checkbox .mdc-checkbox:not(:disabled):active .mdc-checkbox__native-control:enabled:not(:checked):not(:indeterminate):not([data-indeterminate=true])~.mdc-checkbox__background{border-color:var(--mdc-checkbox-unselected-pressed-icon-color, rgba(0, 0, 0, 0.54));background-color:transparent}.mat-mdc-checkbox .mdc-checkbox:not(:disabled):active .mdc-checkbox__native-control:enabled:checked~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox:not(:disabled):active .mdc-checkbox__native-control:enabled:indeterminate~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox:not(:disabled):active .mdc-checkbox__native-control[data-indeterminate=true]:enabled~.mdc-checkbox__background{border-color:var(--mdc-checkbox-selected-pressed-icon-color, var(--mdc-theme-secondary, #018786));background-color:var(--mdc-checkbox-selected-pressed-icon-color, var(--mdc-theme-secondary, #018786))}@keyframes mdc-checkbox-fade-in-background-8A000000FF01878600000000FF018786{0%{border-color:var(--mdc-checkbox-unselected-pressed-icon-color, rgba(0, 0, 0, 0.54));background-color:transparent}50%{border-color:var(--mdc-checkbox-selected-pressed-icon-color, var(--mdc-theme-secondary, #018786));background-color:var(--mdc-checkbox-selected-pressed-icon-color, var(--mdc-theme-secondary, #018786))}}@keyframes mdc-checkbox-fade-out-background-8A000000FF01878600000000FF018786{0%,80%{border-color:var(--mdc-checkbox-selected-pressed-icon-color, var(--mdc-theme-secondary, #018786));background-color:var(--mdc-checkbox-selected-pressed-icon-color, var(--mdc-theme-secondary, #018786))}100%{border-color:var(--mdc-checkbox-unselected-pressed-icon-color, rgba(0, 0, 0, 0.54));background-color:transparent}}.mat-mdc-checkbox .mdc-checkbox:not(:disabled):active.mdc-checkbox--anim-unchecked-checked .mdc-checkbox__native-control:enabled~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox:not(:disabled):active.mdc-checkbox--anim-unchecked-indeterminate .mdc-checkbox__native-control:enabled~.mdc-checkbox__background{animation-name:mdc-checkbox-fade-in-background-8A000000FF01878600000000FF018786}.mat-mdc-checkbox .mdc-checkbox:not(:disabled):active.mdc-checkbox--anim-checked-unchecked .mdc-checkbox__native-control:enabled~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox:not(:disabled):active.mdc-checkbox--anim-indeterminate-unchecked .mdc-checkbox__native-control:enabled~.mdc-checkbox__background{animation-name:mdc-checkbox-fade-out-background-8A000000FF01878600000000FF018786}.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__background{top:calc((var(--mdc-checkbox-state-layer-size, 40px) - 18px) / 2);left:calc((var(--mdc-checkbox-state-layer-size, 40px) - 18px) / 2)}.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__native-control{top:calc((var(--mdc-checkbox-state-layer-size, 40px) - var(--mdc-checkbox-state-layer-size, 40px)) / 2);right:calc((var(--mdc-checkbox-state-layer-size, 40px) - var(--mdc-checkbox-state-layer-size, 40px)) / 2);left:calc((var(--mdc-checkbox-state-layer-size, 40px) - var(--mdc-checkbox-state-layer-size, 40px)) / 2);width:var(--mdc-checkbox-state-layer-size, 40px);height:var(--mdc-checkbox-state-layer-size, 40px)}.mat-mdc-checkbox .mdc-checkbox:hover .mdc-checkbox__native-control:not([disabled])~.mdc-checkbox__ripple{opacity:.04;transform:scale(1);transition:opacity 80ms 0 cubic-bezier(0, 0, 0.2, 1),transform 80ms 0 cubic-bezier(0, 0, 0.2, 1)}.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__native-control:not([disabled]):focus~.mdc-checkbox__ripple{opacity:.16}.mat-mdc-checkbox .mdc-checkbox__background{-webkit-print-color-adjust:exact;color-adjust:exact}.mat-mdc-checkbox._mat-animation-noopable *,.mat-mdc-checkbox._mat-animation-noopable *::before{transition:none !important;animation:none !important}.mat-mdc-checkbox label{cursor:pointer}.mat-mdc-checkbox.mat-mdc-checkbox-disabled label{cursor:default}.mat-mdc-checkbox label:empty{display:none}.mat-mdc-checkbox .mdc-checkbox__native-control:focus:enabled:not(:checked):not(:indeterminate):not([data-indeterminate=true])~.mdc-checkbox__background{border-color:var(--mdc-checkbox-unselected-focus-icon-color, black)}.cdk-high-contrast-active .mat-mdc-checkbox.mat-mdc-checkbox-disabled{opacity:.5}.cdk-high-contrast-active .mat-mdc-checkbox .mdc-checkbox__checkmark{--mdc-checkbox-selected-checkmark-color: CanvasText;--mdc-checkbox-disabled-selected-checkmark-color: CanvasText}.mat-mdc-checkbox .mdc-checkbox__ripple{opacity:0}.mat-mdc-checkbox-ripple,.mdc-checkbox__ripple{top:0;left:0;right:0;bottom:0;position:absolute;border-radius:50%;pointer-events:none}.mat-mdc-checkbox-ripple:not(:empty),.mdc-checkbox__ripple:not(:empty){transform:translateZ(0)}.mat-mdc-checkbox-touch-target{position:absolute;top:50%;height:48px;left:50%;width:48px;transform:translate(-50%, -50%)}.mat-mdc-checkbox-ripple::before{border-radius:50%}.mdc-checkbox__native-control:focus~.mat-mdc-focus-indicator::before{content:""}'],encapsulation:2,changeDetection:0}),n})(),nxe={provide:So,useExisting:Vn(()=>ixe),multi:!0},ixe=(()=>{class n extends sL{}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Cn(n)))(i||n)}}(),n.\u0275dir=xe({type:n,selectors:[["mat-checkbox","required","","formControlName",""],["mat-checkbox","required","","formControl",""],["mat-checkbox","required","","ngModel",""]],features:[Rt([nxe]),Le]}),n})(),fL=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({}),n})(),rxe=function(n){return{enterDuration:n}},oxe=["*"],axe={provide:Hr,useExisting:Vn(()=>Hl),multi:!0},Hl=(()=>{class n extends pL{constructor(e,i,r,o,a,s,l){super("mat-checkbox-",e,i,o,a,s,l),this._focusMonitor=r,this._animationClasses={uncheckedToChecked:"mat-checkbox-anim-unchecked-checked",uncheckedToIndeterminate:"mat-checkbox-anim-unchecked-indeterminate",checkedToUnchecked:"mat-checkbox-anim-checked-unchecked",checkedToIndeterminate:"mat-checkbox-anim-checked-indeterminate",indeterminateToChecked:"mat-checkbox-anim-indeterminate-checked",indeterminateToUnchecked:"mat-checkbox-anim-indeterminate-unchecked"}}_createChangeEvent(e){let i=new class{};return i.source=this,i.checked=e,i}_getAnimationTargetElement(){return this._elementRef.nativeElement}ngAfterViewInit(){super.ngAfterViewInit(),this._focusMonitor.monitor(this._elementRef,!0).subscribe(e=>{e||this._onBlur()})}ngOnDestroy(){this._focusMonitor.stopMonitoring(this._elementRef)}_onInputClick(e){e.stopPropagation(),super._handleInputClick()}focus(e,i){e?this._focusMonitor.focusVia(this._inputElement,e,i):this._inputElement.nativeElement.focus(i)}}return n.\u0275fac=function(e){return new(e||n)(C(be),C(Ft),C(lr),C(at),Vr("tabindex"),C(di,8),C(uL,8))},n.\u0275cmp=k({type:n,selectors:[["mat-checkbox"]],hostAttrs:[1,"mat-checkbox"],hostVars:14,hostBindings:function(e,i){2&e&&(Co("id",i.id),Pe("tabindex",null)("aria-label",null)("aria-labelledby",null),Qe("mat-checkbox-indeterminate",i.indeterminate)("mat-checkbox-checked",i.checked)("mat-checkbox-disabled",i.disabled)("mat-checkbox-label-before","before"==i.labelPosition)("_mat-animation-noopable","NoopAnimations"===i._animationMode))},inputs:{disableRipple:"disableRipple",color:"color",tabIndex:"tabIndex"},exportAs:["matCheckbox"],features:[Rt([axe]),Le],ngContentSelectors:oxe,decls:17,vars:20,consts:[[1,"mat-checkbox-layout"],["label",""],[1,"mat-checkbox-inner-container"],["type","checkbox",1,"mat-checkbox-input","cdk-visually-hidden",3,"id","required","checked","disabled","tabIndex","change","click"],["input",""],["matRipple","",1,"mat-checkbox-ripple","mat-focus-indicator",3,"matRippleTrigger","matRippleDisabled","matRippleRadius","matRippleCentered","matRippleAnimation"],[1,"mat-ripple-element","mat-checkbox-persistent-ripple"],[1,"mat-checkbox-frame"],[1,"mat-checkbox-background"],["version","1.1","focusable","false","viewBox","0 0 24 24","aria-hidden","true",1,"mat-checkbox-checkmark"],["fill","none","stroke","white","d","M4.1,12.7 9,17.6 20.3,6.3",1,"mat-checkbox-checkmark-path"],[1,"mat-checkbox-mixedmark"],[1,"mat-checkbox-label",3,"cdkObserveContent"],["checkboxLabel",""],[2,"display","none"]],template:function(e,i){if(1&e&&(gn(),h(0,"label",0,1)(2,"span",2)(3,"input",3,4),D("change",function(o){return i._onInteractionEvent(o)})("click",function(o){return i._onInputClick(o)}),g(),h(5,"span",5),P(6,"span",6),g(),P(7,"span",7),h(8,"span",8),Tn(),h(9,"svg",9),P(10,"path",10),g(),Oo(),P(11,"span",11),g()(),h(12,"span",12,13),D("cdkObserveContent",function(){return i._onLabelTextChange()}),h(14,"span",14),T(15,"\xa0"),g(),Xt(16),g()()),2&e){let r=tt(1),o=tt(13);Pe("for",i.inputId),b(2),Qe("mat-checkbox-inner-container-no-side-margin",!o.textContent||!o.textContent.trim()),b(1),_("id",i.inputId)("required",i.required)("checked",i.checked)("disabled",i.disabled)("tabIndex",i.tabIndex),Pe("value",i.value)("name",i.name)("aria-label",i.ariaLabel||null)("aria-labelledby",i.ariaLabelledby)("aria-describedby",i.ariaDescribedby),b(2),_("matRippleTrigger",r)("matRippleDisabled",i._isRippleDisabled())("matRippleRadius",20)("matRippleCentered",!0)("matRippleAnimation",Sn(18,rxe,"NoopAnimations"===i._animationMode?0:150))}},dependencies:[Fr,pg],styles:['@keyframes mat-checkbox-fade-in-background{0%{opacity:0}50%{opacity:1}}@keyframes mat-checkbox-fade-out-background{0%,50%{opacity:1}100%{opacity:0}}@keyframes mat-checkbox-unchecked-checked-checkmark-path{0%,50%{stroke-dashoffset:22.910259}50%{animation-timing-function:cubic-bezier(0, 0, 0.2, 0.1)}100%{stroke-dashoffset:0}}@keyframes mat-checkbox-unchecked-indeterminate-mixedmark{0%,68.2%{transform:scaleX(0)}68.2%{animation-timing-function:cubic-bezier(0, 0, 0, 1)}100%{transform:scaleX(1)}}@keyframes mat-checkbox-checked-unchecked-checkmark-path{from{animation-timing-function:cubic-bezier(0.4, 0, 1, 1);stroke-dashoffset:0}to{stroke-dashoffset:-22.910259}}@keyframes mat-checkbox-checked-indeterminate-checkmark{from{animation-timing-function:cubic-bezier(0, 0, 0.2, 0.1);opacity:1;transform:rotate(0deg)}to{opacity:0;transform:rotate(45deg)}}@keyframes mat-checkbox-indeterminate-checked-checkmark{from{animation-timing-function:cubic-bezier(0.14, 0, 0, 1);opacity:0;transform:rotate(45deg)}to{opacity:1;transform:rotate(360deg)}}@keyframes mat-checkbox-checked-indeterminate-mixedmark{from{animation-timing-function:cubic-bezier(0, 0, 0.2, 0.1);opacity:0;transform:rotate(-45deg)}to{opacity:1;transform:rotate(0deg)}}@keyframes mat-checkbox-indeterminate-checked-mixedmark{from{animation-timing-function:cubic-bezier(0.14, 0, 0, 1);opacity:1;transform:rotate(0deg)}to{opacity:0;transform:rotate(315deg)}}@keyframes mat-checkbox-indeterminate-unchecked-mixedmark{0%{animation-timing-function:linear;opacity:1;transform:scaleX(1)}32.8%,100%{opacity:0;transform:scaleX(0)}}.mat-checkbox-background,.mat-checkbox-frame{top:0;left:0;right:0;bottom:0;position:absolute;border-radius:2px;box-sizing:border-box;pointer-events:none}.mat-checkbox{display:inline-block;transition:background 400ms cubic-bezier(0.25, 0.8, 0.25, 1),box-shadow 280ms cubic-bezier(0.4, 0, 0.2, 1);cursor:pointer;-webkit-tap-highlight-color:rgba(0,0,0,0);position:relative}.mat-checkbox._mat-animation-noopable{transition:none !important;animation:none !important}.mat-checkbox .mat-ripple-element:not(.mat-checkbox-persistent-ripple){opacity:.16}.mat-checkbox .mat-checkbox-ripple{position:absolute;left:calc(50% - 20px);top:calc(50% - 20px);height:40px;width:40px;z-index:1;pointer-events:none}.mat-checkbox-layout{-webkit-user-select:none;user-select:none;cursor:inherit;align-items:baseline;vertical-align:middle;display:inline-flex;white-space:nowrap}.mat-checkbox-label{-webkit-user-select:auto;user-select:auto}.mat-checkbox-inner-container{display:inline-block;height:16px;line-height:0;margin:auto;margin-right:8px;order:0;position:relative;vertical-align:middle;white-space:nowrap;width:16px;flex-shrink:0}[dir=rtl] .mat-checkbox-inner-container{margin-left:8px;margin-right:auto}.mat-checkbox-inner-container-no-side-margin{margin-left:0;margin-right:0}.mat-checkbox-frame{background-color:rgba(0,0,0,0);transition:border-color 90ms cubic-bezier(0, 0, 0.2, 0.1);border-width:2px;border-style:solid}._mat-animation-noopable .mat-checkbox-frame{transition:none}.mat-checkbox-background{align-items:center;display:inline-flex;justify-content:center;transition:background-color 90ms cubic-bezier(0, 0, 0.2, 0.1),opacity 90ms cubic-bezier(0, 0, 0.2, 0.1);-webkit-print-color-adjust:exact;color-adjust:exact}._mat-animation-noopable .mat-checkbox-background{transition:none}.cdk-high-contrast-active .mat-checkbox .mat-checkbox-background{background:none}.mat-checkbox-persistent-ripple{display:block;width:100%;height:100%;transform:none}.mat-checkbox-inner-container:hover .mat-checkbox-persistent-ripple{opacity:.04}.mat-checkbox.cdk-keyboard-focused .mat-checkbox-persistent-ripple{opacity:.12}.mat-checkbox-persistent-ripple,.mat-checkbox.mat-checkbox-disabled .mat-checkbox-inner-container:hover .mat-checkbox-persistent-ripple{opacity:0}@media(hover: none){.mat-checkbox-inner-container:hover .mat-checkbox-persistent-ripple{display:none}}.mat-checkbox-checkmark{top:0;left:0;right:0;bottom:0;position:absolute;width:100%}.mat-checkbox-checkmark-path{stroke-dashoffset:22.910259;stroke-dasharray:22.910259;stroke-width:2.1333333333px}.cdk-high-contrast-black-on-white .mat-checkbox-checkmark-path{stroke:#000 !important}.mat-checkbox-mixedmark{width:calc(100% - 6px);height:2px;opacity:0;transform:scaleX(0) rotate(0deg);border-radius:2px}.cdk-high-contrast-active .mat-checkbox-mixedmark{height:0;border-top:solid 2px;margin-top:2px}.mat-checkbox-label-before .mat-checkbox-inner-container{order:1;margin-left:8px;margin-right:auto}[dir=rtl] .mat-checkbox-label-before .mat-checkbox-inner-container{margin-left:auto;margin-right:8px}.mat-checkbox-checked .mat-checkbox-checkmark{opacity:1}.mat-checkbox-checked .mat-checkbox-checkmark-path{stroke-dashoffset:0}.mat-checkbox-checked .mat-checkbox-mixedmark{transform:scaleX(1) rotate(-45deg)}.mat-checkbox-indeterminate .mat-checkbox-checkmark{opacity:0;transform:rotate(45deg)}.mat-checkbox-indeterminate .mat-checkbox-checkmark-path{stroke-dashoffset:0}.mat-checkbox-indeterminate .mat-checkbox-mixedmark{opacity:1;transform:scaleX(1) rotate(0deg)}.mat-checkbox-unchecked .mat-checkbox-background{background-color:rgba(0,0,0,0)}.mat-checkbox-disabled{cursor:default}.cdk-high-contrast-active .mat-checkbox-disabled{opacity:.5}.mat-checkbox-anim-unchecked-checked .mat-checkbox-background{animation:180ms linear 0ms mat-checkbox-fade-in-background}.mat-checkbox-anim-unchecked-checked .mat-checkbox-checkmark-path{animation:180ms linear 0ms mat-checkbox-unchecked-checked-checkmark-path}.mat-checkbox-anim-unchecked-indeterminate .mat-checkbox-background{animation:180ms linear 0ms mat-checkbox-fade-in-background}.mat-checkbox-anim-unchecked-indeterminate .mat-checkbox-mixedmark{animation:90ms linear 0ms mat-checkbox-unchecked-indeterminate-mixedmark}.mat-checkbox-anim-checked-unchecked .mat-checkbox-background{animation:180ms linear 0ms mat-checkbox-fade-out-background}.mat-checkbox-anim-checked-unchecked .mat-checkbox-checkmark-path{animation:90ms linear 0ms mat-checkbox-checked-unchecked-checkmark-path}.mat-checkbox-anim-checked-indeterminate .mat-checkbox-checkmark{animation:90ms linear 0ms mat-checkbox-checked-indeterminate-checkmark}.mat-checkbox-anim-checked-indeterminate .mat-checkbox-mixedmark{animation:90ms linear 0ms mat-checkbox-checked-indeterminate-mixedmark}.mat-checkbox-anim-indeterminate-checked .mat-checkbox-checkmark{animation:500ms linear 0ms mat-checkbox-indeterminate-checked-checkmark}.mat-checkbox-anim-indeterminate-checked .mat-checkbox-mixedmark{animation:500ms linear 0ms mat-checkbox-indeterminate-checked-mixedmark}.mat-checkbox-anim-indeterminate-unchecked .mat-checkbox-background{animation:180ms linear 0ms mat-checkbox-fade-out-background}.mat-checkbox-anim-indeterminate-unchecked .mat-checkbox-mixedmark{animation:300ms linear 0ms mat-checkbox-indeterminate-unchecked-mixedmark}.mat-checkbox-input{bottom:0;left:50%}.mat-checkbox-input:focus~.mat-focus-indicator::before{content:""}'],encapsulation:2,changeDetection:0}),n})(),Wu=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Zo,Qt,Pu,fL,Qt,fL]}),n})(),Gq=Yo({passive:!0}),Wq=(()=>{class n{constructor(e,i){this._platform=e,this._ngZone=i,this._monitoredElements=new Map}monitor(e){if(!this._platform.isBrowser)return to;let i=Va(e),r=this._monitoredElements.get(i);if(r)return r.subject;let o=new Ae,a="cdk-text-field-autofilled",s=l=>{"cdk-text-field-autofill-start"!==l.animationName||i.classList.contains(a)?"cdk-text-field-autofill-end"===l.animationName&&i.classList.contains(a)&&(i.classList.remove(a),this._ngZone.run(()=>o.next({target:l.target,isAutofilled:!1}))):(i.classList.add(a),this._ngZone.run(()=>o.next({target:l.target,isAutofilled:!0})))};return this._ngZone.runOutsideAngular(()=>{i.addEventListener("animationstart",s,Gq),i.classList.add("cdk-text-field-autofill-monitored")}),this._monitoredElements.set(i,{subject:o,unlisten:()=>{i.removeEventListener("animationstart",s,Gq)}}),o}stopMonitoring(e){let i=Va(e),r=this._monitoredElements.get(i);r&&(r.unlisten(),r.subject.complete(),i.classList.remove("cdk-text-field-autofill-monitored"),i.classList.remove("cdk-text-field-autofilled"),this._monitoredElements.delete(i))}ngOnDestroy(){this._monitoredElements.forEach((e,i)=>this.stopMonitoring(i))}}return n.\u0275fac=function(e){return new(e||n)(O($n),O(at))},n.\u0275prov=pe({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),hL=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({}),n})(),lxe=new ie("MAT_INPUT_VALUE_ACCESSOR"),cxe=["button","checkbox","file","hidden","image","radio","range","reset","submit"],dxe=0,uxe=Ub(class{constructor(n,t,e,i){this._defaultErrorStateMatcher=n,this._parentForm=t,this._parentFormGroup=e,this.ngControl=i,this.stateChanges=new Ae}}),qq=(()=>{class n extends uxe{get disabled(){return this._disabled}set disabled(e){this._disabled=Ut(e),this.focused&&(this.focused=!1,this.stateChanges.next())}get id(){return this._id}set id(e){this._id=e||this._uid}get required(){return this._required??this.ngControl?.control?.hasValidator(Vl.required)??!1}set required(e){this._required=Ut(e)}get type(){return this._type}set type(e){this._type=e||"text",this._validateType(),!this._isTextarea&&s2().has(this._type)&&(this._elementRef.nativeElement.type=this._type)}get value(){return this._inputValueAccessor.value}set value(e){e!==this.value&&(this._inputValueAccessor.value=e,this.stateChanges.next())}get readonly(){return this._readonly}set readonly(e){this._readonly=Ut(e)}constructor(e,i,r,o,a,s,l,c,d,u){super(s,o,a,r),this._elementRef=e,this._platform=i,this._autofillMonitor=c,this._formField=u,this._uid="mat-input-"+dxe++,this.focused=!1,this.stateChanges=new Ae,this.controlType="mat-input",this.autofilled=!1,this._disabled=!1,this._type="text",this._readonly=!1,this._neverEmptyInputTypes=["date","datetime","datetime-local","month","time","week"].filter(m=>s2().has(m)),this._iOSKeyupListener=m=>{let y=m.target;!y.value&&0===y.selectionStart&&0===y.selectionEnd&&(y.setSelectionRange(1,1),y.setSelectionRange(0,0))};let p=this._elementRef.nativeElement,f=p.nodeName.toLowerCase();this._inputValueAccessor=l||p,this._previousNativeValue=this.value,this.id=this.id,i.IOS&&d.runOutsideAngular(()=>{e.nativeElement.addEventListener("keyup",this._iOSKeyupListener)}),this._isServer=!this._platform.isBrowser,this._isNativeSelect="select"===f,this._isTextarea="textarea"===f,this._isInFormField=!!u,this._isNativeSelect&&(this.controlType=p.multiple?"mat-native-select-multiple":"mat-native-select")}ngAfterViewInit(){this._platform.isBrowser&&this._autofillMonitor.monitor(this._elementRef.nativeElement).subscribe(e=>{this.autofilled=e.isAutofilled,this.stateChanges.next()})}ngOnChanges(){this.stateChanges.next()}ngOnDestroy(){this.stateChanges.complete(),this._platform.isBrowser&&this._autofillMonitor.stopMonitoring(this._elementRef.nativeElement),this._platform.IOS&&this._elementRef.nativeElement.removeEventListener("keyup",this._iOSKeyupListener)}ngDoCheck(){this.ngControl&&(this.updateErrorState(),null!==this.ngControl.disabled&&this.ngControl.disabled!==this.disabled&&(this.disabled=this.ngControl.disabled,this.stateChanges.next())),this._dirtyCheckNativeValue(),this._dirtyCheckPlaceholder()}focus(e){this._elementRef.nativeElement.focus(e)}_focusChanged(e){e!==this.focused&&(this.focused=e,this.stateChanges.next())}_onInput(){}_dirtyCheckNativeValue(){let e=this._elementRef.nativeElement.value;this._previousNativeValue!==e&&(this._previousNativeValue=e,this.stateChanges.next())}_dirtyCheckPlaceholder(){let e=this._getPlaceholder();if(e!==this._previousPlaceholder){let i=this._elementRef.nativeElement;this._previousPlaceholder=e,e?i.setAttribute("placeholder",e):i.removeAttribute("placeholder")}}_getPlaceholder(){return this.placeholder||null}_validateType(){cxe.indexOf(this._type)}_isNeverEmpty(){return this._neverEmptyInputTypes.indexOf(this._type)>-1}_isBadInput(){let e=this._elementRef.nativeElement.validity;return e&&e.badInput}get empty(){return!(this._isNeverEmpty()||this._elementRef.nativeElement.value||this._isBadInput()||this.autofilled)}get shouldLabelFloat(){if(this._isNativeSelect){let e=this._elementRef.nativeElement,i=e.options[0];return this.focused||e.multiple||!this.empty||!!(e.selectedIndex>-1&&i&&i.label)}return this.focused||!this.empty}setDescribedByIds(e){e.length?this._elementRef.nativeElement.setAttribute("aria-describedby",e.join(" ")):this._elementRef.nativeElement.removeAttribute("aria-describedby")}onContainerClick(){this.focused||this.focus()}_isInlineSelect(){let e=this._elementRef.nativeElement;return this._isNativeSelect&&(e.multiple||e.size>1)}}return n.\u0275fac=function(e){return new(e||n)(C(be),C($n),C(za,10),C(Ag,8),C(Rg,8),C(If),C(lxe,10),C(Wq),C(at),C(Bl,8))},n.\u0275dir=xe({type:n,selectors:[["input","matInput",""],["textarea","matInput",""],["select","matNativeControl",""],["input","matNativeControl",""],["textarea","matNativeControl",""]],hostAttrs:[1,"mat-mdc-input-element"],hostVars:18,hostBindings:function(e,i){1&e&&D("focus",function(){return i._focusChanged(!0)})("blur",function(){return i._focusChanged(!1)})("input",function(){return i._onInput()}),2&e&&(Co("id",i.id)("disabled",i.disabled)("required",i.required),Pe("name",i.name||null)("readonly",i.readonly&&!i._isNativeSelect||null)("aria-invalid",i.empty&&i.required?null:i.errorState)("aria-required",i.required)("id",i.id),Qe("mat-input-server",i._isServer)("mat-mdc-form-field-textarea-control",i._isInFormField&&i._isTextarea)("mat-mdc-form-field-input-control",i._isInFormField)("mdc-text-field__input",i._isInFormField)("mat-mdc-native-select-inline",i._isInlineSelect()))},inputs:{disabled:"disabled",id:"id",placeholder:"placeholder",name:"name",required:"required",type:"type",errorStateMatcher:"errorStateMatcher",userAriaDescribedBy:["aria-describedby","userAriaDescribedBy"],value:"value",readonly:"readonly"},exportAs:["matInput"],features:[Rt([{provide:Nl,useExisting:n}]),Le,Gt]}),n})(),qu=(()=>{class n extends qq{constructor(){super(...arguments),this._legacyFormField=pi(Bl,{optional:!0})}_getPlaceholder(){let e=this._legacyFormField;return e&&"legacy"===e.appearance&&!e._hasLabel?.()?null:this.placeholder}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Cn(n)))(i||n)}}(),n.\u0275dir=xe({type:n,selectors:[["input","matInput",""],["textarea","matInput",""],["select","matNativeControl",""],["input","matNativeControl",""],["textarea","matNativeControl",""]],hostAttrs:[1,"mat-input-element","mat-form-field-autofill-control"],hostVars:15,hostBindings:function(e,i){2&e&&(Pe("data-placeholder",i.placeholder),Qe("mat-input-server",i._isServer)("mat-mdc-input-element",!1)("mat-mdc-form-field-textarea-control",!1)("mat-mdc-form-field-input-control",!1)("mdc-text-field__input",!1)("mat-mdc-native-select-inline",!1)("mat-native-select-inline",i._isInlineSelect()))},exportAs:["matInput"],features:[Rt([{provide:Nl,useExisting:n}]),Le]}),n})(),Qs=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({providers:[If],imports:[hL,Vf,Qt,hL,Vf]}),n})();function pxe(n,t){if(1&n&&(h(0,"mat-error"),T(1),g()),2&n){let e=w();b(1),ze(" Reload period has to be minimum of ",e.MIN_RELOAD_PERIOD_IN_S," seconds. ")}}function fxe(n,t){1&n&&(h(0,"mat-error"),T(1," Page size has to be a positive integer. "),g())}var Yq=(()=>{class n{constructor(){this.reloadToggled=new L,this.reloadPeriodInMsChanged=new L,this.pageSizeChanged=new L,this.MIN_RELOAD_PERIOD_IN_S=30,this.reloadPeriodControl=new rv(this.MIN_RELOAD_PERIOD_IN_S,[Vl.required,Vl.min(this.MIN_RELOAD_PERIOD_IN_S)]),this.paginationControl=new rv(1,[Vl.required,Vl.min(1),n=>{let t=Number(n.value);return Math.round(t)===n.value?null:{integer:{value:n.value}}}]),this.ngUnsubscribe=new Ae}ngOnInit(){this.reloadPeriodControl.valueChanges.pipe(ot(this.ngUnsubscribe),Cr(500),Ve(()=>this.reloadPeriodControl.valid)).subscribe(()=>{this.reloadPeriodControl.valid&&this.reloadPeriodInMsChanged.emit(1e3*this.reloadPeriodControl.value)}),this.paginationControl.valueChanges.pipe(ot(this.ngUnsubscribe),Cr(500),Ve(()=>this.paginationControl.valid)).subscribe(()=>{this.pageSizeChanged.emit(this.paginationControl.value)})}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}ngOnChanges(e){if(e.reloadPeriodInMs){let i=e.reloadPeriodInMs;i.previousValue!==i.currentValue&&this.reloadPeriodControl.setValue(i.currentValue/1e3)}if(e.reloadEnabled&&(e.reloadEnabled.currentValue?this.reloadPeriodControl.enable():this.reloadPeriodControl.disable()),e.pageSize){let i=e.pageSize;i.previousValue!==i.currentValue&&this.paginationControl.setValue(i.currentValue)}}onReloadToggle(){this.reloadToggled.emit()}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["settings-dialog-component"]],inputs:{reloadEnabled:"reloadEnabled",reloadPeriodInMs:"reloadPeriodInMs",pageSize:"pageSize"},outputs:{reloadToggled:"reloadToggled",reloadPeriodInMsChanged:"reloadPeriodInMsChanged",pageSizeChanged:"pageSizeChanged"},features:[Gt],decls:14,vars:5,consts:[[1,"reload-toggle"],[3,"checked","change"],["matInput","","type","number","placeholder","Reload Period (seconds)",1,"reload-period",3,"formControl"],[4,"ngIf"],["matInput","","type","number","placeholder","Pagination Limit",1,"page-size",3,"formControl"]],template:function(e,i){1&e&&(h(0,"h3"),T(1,"Settings"),g(),h(2,"div")(3,"div",0)(4,"mat-checkbox",1),D("change",function(){return i.onReloadToggle()}),T(5,"Reload data"),g()(),h(6,"div")(7,"mat-form-field"),P(8,"input",2),g(),S(9,pxe,2,1,"mat-error",3),g()(),h(10,"div")(11,"mat-form-field"),P(12,"input",4),g(),S(13,fxe,2,0,"mat-error",3),g()),2&e&&(b(4),_("checked",i.reloadEnabled),b(4),_("formControl",i.reloadPeriodControl),b(1),_("ngIf",i.reloadPeriodControl.hasError("min")||i.reloadPeriodControl.hasError("required")),b(3),_("formControl",i.paginationControl),b(1),_("ngIf",i.paginationControl.invalid))},dependencies:[Fe,Ig,rL,pE,aL,Hl,w9,Ys,qu],styles:["[_nghost-%COMP%] {\n  font-size: 15px;\n}\n\n[_nghost-%COMP%]    > div[_ngcontent-%COMP%] {\n  margin: 10px 0;\n}\n\n[_nghost-%COMP%]    > [_ngcontent-%COMP%]:first-child {\n  margin-top: 0;\n}\n\n[_nghost-%COMP%]    > [_ngcontent-%COMP%]:last-child {\n  margin-bottom: 0;\n}\n\nh3[_ngcontent-%COMP%] {\n  font-size: 20px;\n}\n\n.reload-toggle[_ngcontent-%COMP%] {\n  margin-bottom: 10px;\n}"]}),n})(),Xq=(()=>{class n{constructor(e){this.store=e,this.reloadEnabled$=this.store.select(Ob),this.reloadPeriodInMs$=this.store.select(Fb),this.pageSize$=this.store.select(Sf)}onReloadToggled(){this.store.dispatch(C1())}onReloadPeriodInMsChanged(e){this.store.dispatch(M1({periodInMs:e}))}onPageSizeChanged(e){this.store.dispatch(w1({size:e}))}}return n.\u0275fac=function(e){return new(e||n)(C(ke))},n.\u0275cmp=k({type:n,selectors:[["settings-dialog"]],decls:4,vars:9,consts:[[3,"reloadEnabled","reloadPeriodInMs","pageSize","reloadToggled","reloadPeriodInMsChanged","pageSizeChanged"]],template:function(e,i){1&e&&(h(0,"settings-dialog-component",0),D("reloadToggled",function(){return i.onReloadToggled()})("reloadPeriodInMsChanged",function(o){return i.onReloadPeriodInMsChanged(o)})("pageSizeChanged",function(o){return i.onPageSizeChanged(o)}),G(1,"async"),G(2,"async"),G(3,"async"),g()),2&e&&_("reloadEnabled",W(1,3,i.reloadEnabled$))("reloadPeriodInMs",W(2,5,i.reloadPeriodInMs$))("pageSize",W(3,7,i.pageSize$))},dependencies:[Yq,lt],encapsulation:2}),n})(),Qq=(()=>{class n{constructor(e){this.dialog=e}isButtonDisabled(){return this.settingsLoadState===De.NOT_LOADED||this.settingsLoadState===De.LOADING}openDialog(){this.dialog.open(Xq,{width:"400px"})}}return n.\u0275fac=function(e){return new(e||n)(C(Ll))},n.\u0275cmp=k({type:n,selectors:[["settings-button-component"]],inputs:{settingsLoadState:"settingsLoadState"},decls:2,vars:1,consts:[["mat-icon-button","",3,"disabled","click"],["svgIcon","settings_24px"]],template:function(e,i){1&e&&(h(0,"button",0),D("click",function(){return i.openDialog()}),P(1,"mat-icon",1),g()),2&e&&_("disabled",i.isButtonDisabled())},dependencies:[Fn,Dn],encapsulation:2}),n})(),Zq=(()=>{class n{constructor(e){this.store=e,this.settingsLoadState$=this.store.select(i2)}}return n.\u0275fac=function(e){return new(e||n)(C(ke))},n.\u0275cmp=k({type:n,selectors:[["settings-button"]],decls:2,vars:3,consts:[[3,"settingsLoadState"]],template:function(e,i){1&e&&(P(0,"settings-button-component",0),G(1,"async")),2&e&&_("settingsLoadState",W(1,1,i.settingsLoadState$))},dependencies:[Qq,lt],encapsulation:2}),n})(),yxe=["mat-menu-item",""];function bxe(n,t){1&n&&(Tn(),h(0,"svg",3),P(1,"polygon",4),g())}var vxe=[[["mat-icon"],["","matMenuItemIcon",""]],"*"],xxe=["mat-icon, [matMenuItemIcon]","*"],xE=new ie("MAT_MENU_PANEL"),Cxe=Qo(Kr(class{})),Ng=(()=>{class n extends Cxe{constructor(e,i,r,o,a){super(),this._elementRef=e,this._document=i,this._focusMonitor=r,this._parentMenu=o,this._changeDetectorRef=a,this.role="menuitem",this._hovered=new Ae,this._focused=new Ae,this._highlighted=!1,this._triggersSubmenu=!1,o?.addItem?.(this)}focus(e,i){this._focusMonitor&&e?this._focusMonitor.focusVia(this._getHostElement(),e,i):this._getHostElement().focus(i),this._focused.next(this)}ngAfterViewInit(){this._focusMonitor&&this._focusMonitor.monitor(this._elementRef,!1)}ngOnDestroy(){this._focusMonitor&&this._focusMonitor.stopMonitoring(this._elementRef),this._parentMenu&&this._parentMenu.removeItem&&this._parentMenu.removeItem(this),this._hovered.complete(),this._focused.complete()}_getTabIndex(){return this.disabled?"-1":"0"}_getHostElement(){return this._elementRef.nativeElement}_checkDisabled(e){this.disabled&&(e.preventDefault(),e.stopPropagation())}_handleMouseEnter(){this._hovered.next(this)}getLabel(){let e=this._elementRef.nativeElement.cloneNode(!0),i=e.querySelectorAll("mat-icon, .material-icons");for(let r=0;r<i.length;r++)i[r].remove();return e.textContent?.trim()||""}_setHighlighted(e){this._highlighted=e,this._changeDetectorRef?.markForCheck()}_setTriggersSubmenu(e){this._triggersSubmenu=e,this._changeDetectorRef?.markForCheck()}_hasFocus(){return this._document&&this._document.activeElement===this._getHostElement()}}return n.\u0275fac=function(e){return new(e||n)(C(be),C(kt),C(lr),C(xE,8),C(Ft))},n.\u0275cmp=k({type:n,selectors:[["","mat-menu-item",""]],hostAttrs:[1,"mat-mdc-menu-item","mat-mdc-focus-indicator","mdc-list-item"],hostVars:8,hostBindings:function(e,i){1&e&&D("click",function(o){return i._checkDisabled(o)})("mouseenter",function(){return i._handleMouseEnter()}),2&e&&(Pe("role",i.role)("tabindex",i._getTabIndex())("aria-disabled",i.disabled)("disabled",i.disabled||null),Qe("mat-mdc-menu-item-highlighted",i._highlighted)("mat-mdc-menu-item-submenu-trigger",i._triggersSubmenu))},inputs:{disabled:"disabled",disableRipple:"disableRipple",role:"role"},exportAs:["matMenuItem"],features:[Le],attrs:yxe,ngContentSelectors:xxe,decls:5,vars:3,consts:[[1,"mdc-list-item__primary-text"],["matRipple","",1,"mat-mdc-menu-ripple",3,"matRippleDisabled","matRippleTrigger"],["class","mat-mdc-menu-submenu-icon","viewBox","0 0 5 10","focusable","false",4,"ngIf"],["viewBox","0 0 5 10","focusable","false",1,"mat-mdc-menu-submenu-icon"],["points","0,0 5,5 0,10"]],template:function(e,i){1&e&&(gn(vxe),Xt(0),h(1,"span",0),Xt(2,1),g(),P(3,"div",1),S(4,bxe,2,0,"svg",2)),2&e&&(b(3),_("matRippleDisabled",i.disableRipple||i.disabled)("matRippleTrigger",i._getHostElement()),b(1),_("ngIf",i._triggersSubmenu))},dependencies:[Fe,Fr],encapsulation:2,changeDetection:0}),n})(),Jq=new ie("MatMenuContent"),cv={transformMenu:ji("transformMenu",[Jn("void",Bt({opacity:0,transform:"scale(0.8)"})),Wn("void => enter",Kn("120ms cubic-bezier(0, 0, 0.2, 1)",Bt({opacity:1,transform:"scale(1)"}))),Wn("* => void",Kn("100ms 25ms linear",Bt({opacity:0})))]),fadeInItems:ji("fadeInItems",[Jn("showing",Bt({opacity:1})),Wn("void => *",[Bt({opacity:0}),Kn("400ms 100ms cubic-bezier(0.55, 0, 0.55, 0.2)")])])},Mxe=0,gL=new ie("mat-menu-default-options",{providedIn:"root",factory:function(){return{overlapTrigger:!1,xPosition:"after",yPosition:"below",backdropClass:"cdk-overlay-transparent-backdrop"}}}),Lg=(()=>{class n{get xPosition(){return this._xPosition}set xPosition(e){this._xPosition=e,this.setPositionClasses()}get yPosition(){return this._yPosition}set yPosition(e){this._yPosition=e,this.setPositionClasses()}get overlapTrigger(){return this._overlapTrigger}set overlapTrigger(e){this._overlapTrigger=Ut(e)}get hasBackdrop(){return this._hasBackdrop}set hasBackdrop(e){this._hasBackdrop=Ut(e)}set panelClass(e){let i=this._previousPanelClass;i&&i.length&&i.split(" ").forEach(r=>{this._classList[r]=!1}),this._previousPanelClass=e,e&&e.length&&(e.split(" ").forEach(r=>{this._classList[r]=!0}),this._elementRef.nativeElement.className="")}get classList(){return this.panelClass}set classList(e){this.panelClass=e}constructor(e,i,r,o){this._elementRef=e,this._ngZone=i,this._defaultOptions=r,this._changeDetectorRef=o,this._xPosition=this._defaultOptions.xPosition,this._yPosition=this._defaultOptions.yPosition,this._directDescendantItems=new Is,this._classList={},this._panelAnimationState="void",this._animationDone=new Ae,this.overlayPanelClass=this._defaultOptions.overlayPanelClass||"",this.backdropClass=this._defaultOptions.backdropClass,this._overlapTrigger=this._defaultOptions.overlapTrigger,this._hasBackdrop=this._defaultOptions.hasBackdrop,this.closed=new L,this.close=this.closed,this.panelId="mat-menu-panel-"+Mxe++}ngOnInit(){this.setPositionClasses()}ngAfterContentInit(){this._updateDirectDescendants(),this._keyManager=new gg(this._directDescendantItems).withWrap().withTypeAhead().withHomeAndEnd(),this._keyManager.tabOut.subscribe(()=>this.closed.emit("tab")),this._directDescendantItems.changes.pipe(Nn(this._directDescendantItems),yi(e=>cn(...e.map(i=>i._focused)))).subscribe(e=>this._keyManager.updateActiveItem(e)),this._directDescendantItems.changes.subscribe(e=>{let i=this._keyManager;if("enter"===this._panelAnimationState&&i.activeItem?._hasFocus()){let r=e.toArray(),o=Math.max(0,Math.min(r.length-1,i.activeItemIndex||0));r[o]&&!r[o].disabled?i.setActiveItem(o):i.setNextItemActive()}})}ngOnDestroy(){this._keyManager?.destroy(),this._directDescendantItems.destroy(),this.closed.complete(),this._firstItemFocusSubscription?.unsubscribe()}_hovered(){return this._directDescendantItems.changes.pipe(Nn(this._directDescendantItems),yi(i=>cn(...i.map(r=>r._hovered))))}addItem(e){}removeItem(e){}_handleKeydown(e){let i=e.keyCode,r=this._keyManager;switch(i){case 27:yr(e)||(e.preventDefault(),this.closed.emit("keydown"));break;case 37:this.parentMenu&&"ltr"===this.direction&&this.closed.emit("keydown");break;case 39:this.parentMenu&&"rtl"===this.direction&&this.closed.emit("keydown");break;default:return(38===i||40===i)&&r.setFocusOrigin("keyboard"),void r.onKeydown(e)}e.stopPropagation()}focusFirstItem(e="program"){this._firstItemFocusSubscription?.unsubscribe(),this._firstItemFocusSubscription=this._ngZone.onStable.pipe(zt(1)).subscribe(()=>{let i=null;if(this._directDescendantItems.length&&(i=this._directDescendantItems.first._getHostElement().closest('[role="menu"]')),!i||!i.contains(document.activeElement)){let r=this._keyManager;r.setFocusOrigin(e).setFirstItemActive(),!r.activeItem&&i&&i.focus()}})}resetActiveItem(){this._keyManager.setActiveItem(-1)}setElevation(e){let i=Math.min(this._baseElevation+e,24),r=`${this._elevationPrefix}${i}`,o=Object.keys(this._classList).find(a=>a.startsWith(this._elevationPrefix));(!o||o===this._previousElevation)&&(this._previousElevation&&(this._classList[this._previousElevation]=!1),this._classList[r]=!0,this._previousElevation=r)}setPositionClasses(e=this.xPosition,i=this.yPosition){let r=this._classList;r["mat-menu-before"]="before"===e,r["mat-menu-after"]="after"===e,r["mat-menu-above"]="above"===i,r["mat-menu-below"]="below"===i,this._changeDetectorRef?.markForCheck()}_startAnimation(){this._panelAnimationState="enter"}_resetAnimation(){this._panelAnimationState="void"}_onAnimationDone(e){this._animationDone.next(e),this._isAnimating=!1}_onAnimationStart(e){this._isAnimating=!0,"enter"===e.toState&&0===this._keyManager.activeItemIndex&&(e.element.scrollTop=0)}_updateDirectDescendants(){this._allItems.changes.pipe(Nn(this._allItems)).subscribe(e=>{this._directDescendantItems.reset(e.filter(i=>i._parentMenu===this)),this._directDescendantItems.notifyOnChanges()})}}return n.\u0275fac=function(e){return new(e||n)(C(be),C(at),C(gL),C(Ft))},n.\u0275dir=xe({type:n,contentQueries:function(e,i,r){if(1&e&&(ci(r,Jq,5),ci(r,Ng,5),ci(r,Ng,4)),2&e){let o;we(o=Se())&&(i.lazyContent=o.first),we(o=Se())&&(i._allItems=o),we(o=Se())&&(i.items=o)}},viewQuery:function(e,i){if(1&e&&Ye(Si,5),2&e){let r;we(r=Se())&&(i.templateRef=r.first)}},inputs:{backdropClass:"backdropClass",ariaLabel:["aria-label","ariaLabel"],ariaLabelledby:["aria-labelledby","ariaLabelledby"],ariaDescribedby:["aria-describedby","ariaDescribedby"],xPosition:"xPosition",yPosition:"yPosition",overlapTrigger:"overlapTrigger",hasBackdrop:"hasBackdrop",panelClass:["class","panelClass"],classList:"classList"},outputs:{closed:"closed",close:"close"}}),n})(),$q=new ie("mat-menu-scroll-strategy"),eY={provide:$q,deps:[Oi],useFactory:function(n){return()=>n.scrollStrategies.reposition()}},Kq=Yo({passive:!0}),tY=(()=>{class n{get _deprecatedMatMenuTriggerFor(){return this.menu}set _deprecatedMatMenuTriggerFor(e){this.menu=e}get menu(){return this._menu}set menu(e){e!==this._menu&&(this._menu=e,this._menuCloseSubscription.unsubscribe(),e&&(this._menuCloseSubscription=e.close.subscribe(i=>{this._destroyMenu(i),("click"===i||"tab"===i)&&this._parentMaterialMenu&&this._parentMaterialMenu.closed.emit(i)})),this._menuItemInstance?._setTriggersSubmenu(this.triggersSubmenu()))}constructor(e,i,r,o,a,s,l,c,d){this._overlay=e,this._element=i,this._viewContainerRef=r,this._menuItemInstance=s,this._dir=l,this._focusMonitor=c,this._ngZone=d,this._overlayRef=null,this._menuOpen=!1,this._closingActionsSubscription=yn.EMPTY,this._hoverSubscription=yn.EMPTY,this._menuCloseSubscription=yn.EMPTY,this._changeDetectorRef=pi(Ft),this._handleTouchStart=u=>{zb(u)||(this._openedBy="touch")},this._openedBy=void 0,this.restoreFocus=!0,this.menuOpened=new L,this.onMenuOpen=this.menuOpened,this.menuClosed=new L,this.onMenuClose=this.menuClosed,this._scrollStrategy=o,this._parentMaterialMenu=a instanceof Lg?a:void 0,i.nativeElement.addEventListener("touchstart",this._handleTouchStart,Kq)}ngAfterContentInit(){this._handleHover()}ngOnDestroy(){this._overlayRef&&(this._overlayRef.dispose(),this._overlayRef=null),this._element.nativeElement.removeEventListener("touchstart",this._handleTouchStart,Kq),this._menuCloseSubscription.unsubscribe(),this._closingActionsSubscription.unsubscribe(),this._hoverSubscription.unsubscribe()}get menuOpen(){return this._menuOpen}get dir(){return this._dir&&"rtl"===this._dir.value?"rtl":"ltr"}triggersSubmenu(){return!!(this._menuItemInstance&&this._parentMaterialMenu&&this.menu)}toggleMenu(){return this._menuOpen?this.closeMenu():this.openMenu()}openMenu(){let e=this.menu;if(this._menuOpen||!e)return;let i=this._createOverlay(e),r=i.getConfig(),o=r.positionStrategy;this._setPosition(e,o),r.hasBackdrop=null==e.hasBackdrop?!this.triggersSubmenu():e.hasBackdrop,i.attach(this._getPortal(e)),e.lazyContent&&e.lazyContent.attach(this.menuData),this._closingActionsSubscription=this._menuClosingActions().subscribe(()=>this.closeMenu()),this._initMenu(e),e instanceof Lg&&(e._startAnimation(),e._directDescendantItems.changes.pipe(ot(e.close)).subscribe(()=>{o.withLockedPosition(!1).reapplyLastPosition(),o.withLockedPosition(!0)}))}closeMenu(){this.menu?.close.emit()}focus(e,i){this._focusMonitor&&e?this._focusMonitor.focusVia(this._element,e,i):this._element.nativeElement.focus(i)}updatePosition(){this._overlayRef?.updatePosition()}_destroyMenu(e){if(!this._overlayRef||!this.menuOpen)return;let i=this.menu;this._closingActionsSubscription.unsubscribe(),this._overlayRef.detach(),this.restoreFocus&&("keydown"===e||!this._openedBy||!this.triggersSubmenu())&&this.focus(this._openedBy),this._openedBy=void 0,i instanceof Lg?(i._resetAnimation(),i.lazyContent?i._animationDone.pipe(Ve(r=>"void"===r.toState),zt(1),ot(i.lazyContent._attached)).subscribe({next:()=>i.lazyContent.detach(),complete:()=>this._setIsMenuOpen(!1)}):this._setIsMenuOpen(!1)):(this._setIsMenuOpen(!1),i?.lazyContent?.detach())}_initMenu(e){e.parentMenu=this.triggersSubmenu()?this._parentMaterialMenu:void 0,e.direction=this.dir,this._setMenuElevation(e),e.focusFirstItem(this._openedBy||"program"),this._setIsMenuOpen(!0)}_setMenuElevation(e){if(e.setElevation){let i=0,r=e.parentMenu;for(;r;)i++,r=r.parentMenu;e.setElevation(i)}}_setIsMenuOpen(e){e!==this._menuOpen&&(this._menuOpen=e,this._menuOpen?this.menuOpened.emit():this.menuClosed.emit(),this.triggersSubmenu()&&this._menuItemInstance._setHighlighted(e),this._changeDetectorRef.markForCheck())}_createOverlay(e){if(!this._overlayRef){let i=this._getOverlayConfig(e);this._subscribeToPositions(e,i.positionStrategy),this._overlayRef=this._overlay.create(i),this._overlayRef.keydownEvents().subscribe()}return this._overlayRef}_getOverlayConfig(e){return new Ws({positionStrategy:this._overlay.position().flexibleConnectedTo(this._element).withLockedPosition().withGrowAfterOpen().withTransformOriginOn(".mat-menu-panel, .mat-mdc-menu-panel"),backdropClass:e.backdropClass||"cdk-overlay-transparent-backdrop",panelClass:e.overlayPanelClass,scrollStrategy:this._scrollStrategy(),direction:this._dir})}_subscribeToPositions(e,i){e.setPositionClasses&&i.positionChanges.subscribe(r=>{let o="start"===r.connectionPair.overlayX?"after":"before",a="top"===r.connectionPair.overlayY?"below":"above";this._ngZone?this._ngZone.run(()=>e.setPositionClasses(o,a)):e.setPositionClasses(o,a)})}_setPosition(e,i){let[r,o]="before"===e.xPosition?["end","start"]:["start","end"],[a,s]="above"===e.yPosition?["bottom","top"]:["top","bottom"],[l,c]=[a,s],[d,u]=[r,o],p=0;if(this.triggersSubmenu()){if(u=r="before"===e.xPosition?"start":"end",o=d="end"===r?"start":"end",this._parentMaterialMenu){if(null==this._parentInnerPadding){let f=this._parentMaterialMenu.items.first;this._parentInnerPadding=f?f._getHostElement().offsetTop:0}p="bottom"===a?this._parentInnerPadding:-this._parentInnerPadding}}else e.overlapTrigger||(l="top"===a?"bottom":"top",c="top"===s?"bottom":"top");i.withPositions([{originX:r,originY:l,overlayX:d,overlayY:a,offsetY:p},{originX:o,originY:l,overlayX:u,overlayY:a,offsetY:p},{originX:r,originY:c,overlayX:d,overlayY:s,offsetY:-p},{originX:o,originY:c,overlayX:u,overlayY:s,offsetY:-p}])}_menuClosingActions(){let e=this._overlayRef.backdropClick(),i=this._overlayRef.detachments();return cn(e,this._parentMaterialMenu?this._parentMaterialMenu.closed:qt(),this._parentMaterialMenu?this._parentMaterialMenu._hovered().pipe(Ve(a=>a!==this._menuItemInstance),Ve(()=>this._menuOpen)):qt(),i)}_handleMousedown(e){Hb(e)||(this._openedBy=0===e.button?"mouse":void 0,this.triggersSubmenu()&&e.preventDefault())}_handleKeydown(e){let i=e.keyCode;(13===i||32===i)&&(this._openedBy="keyboard"),this.triggersSubmenu()&&(39===i&&"ltr"===this.dir||37===i&&"rtl"===this.dir)&&(this._openedBy="keyboard",this.openMenu())}_handleClick(e){this.triggersSubmenu()?(e.stopPropagation(),this.openMenu()):this.toggleMenu()}_handleHover(){!this.triggersSubmenu()||!this._parentMaterialMenu||(this._hoverSubscription=this._parentMaterialMenu._hovered().pipe(Ve(e=>e===this._menuItemInstance&&!e.disabled),xs(0,Um)).subscribe(()=>{this._openedBy="mouse",this.menu instanceof Lg&&this.menu._isAnimating?this.menu._animationDone.pipe(zt(1),xs(0,Um),ot(this._parentMaterialMenu._hovered())).subscribe(()=>this.openMenu()):this.openMenu()}))}_getPortal(e){return(!this._portal||this._portal.templateRef!==e.templateRef)&&(this._portal=new Jo(e.templateRef,this._viewContainerRef)),this._portal}}return n.\u0275fac=function(e){return new(e||n)(C(Oi),C(be),C(Zn),C($q),C(xE,8),C(Ng,10),C(Hi,8),C(lr),C(at))},n.\u0275dir=xe({type:n,hostVars:3,hostBindings:function(e,i){1&e&&D("click",function(o){return i._handleClick(o)})("mousedown",function(o){return i._handleMousedown(o)})("keydown",function(o){return i._handleKeydown(o)}),2&e&&Pe("aria-haspopup",i.menu?"menu":null)("aria-expanded",i.menuOpen)("aria-controls",i.menuOpen?i.menu.panelId:null)},inputs:{_deprecatedMatMenuTriggerFor:["mat-menu-trigger-for","_deprecatedMatMenuTriggerFor"],menu:["matMenuTriggerFor","menu"],menuData:["matMenuTriggerData","menuData"],restoreFocus:["matMenuTriggerRestoreFocus","restoreFocus"]},outputs:{menuOpened:"menuOpened",onMenuOpen:"onMenuOpen",menuClosed:"menuClosed",onMenuClose:"onMenuClose"}}),n})();function Exe(n,t){if(1&n){let e=ge();h(0,"div",0),D("keydown",function(r){return X(e),Q(w()._handleKeydown(r))})("click",function(){return X(e),Q(w().closed.emit("click"))})("@transformMenu.start",function(r){return X(e),Q(w()._onAnimationStart(r))})("@transformMenu.done",function(r){return X(e),Q(w()._onAnimationDone(r))}),h(1,"div",1),Xt(2),g()()}if(2&n){let e=w();_("id",e.panelId)("ngClass",e._classList)("@transformMenu",e._panelAnimationState),Pe("aria-label",e.ariaLabel||null)("aria-labelledby",e.ariaLabelledby||null)("aria-describedby",e.ariaDescribedby||null)}}var nY=["*"],Txe=["mat-menu-item",""];function Dxe(n,t){1&n&&(Tn(),h(0,"svg",2),P(1,"polygon",3),g())}var kc=(()=>{class n extends Lg{constructor(e,i,r,o){super(e,i,r,o),this._elevationPrefix="mat-elevation-z",this._baseElevation=4}}return n.\u0275fac=function(e){return new(e||n)(C(be),C(at),C(gL),C(Ft))},n.\u0275cmp=k({type:n,selectors:[["mat-menu"]],hostVars:3,hostBindings:function(e,i){2&e&&Pe("aria-label",null)("aria-labelledby",null)("aria-describedby",null)},exportAs:["matMenu"],features:[Rt([{provide:xE,useExisting:n}]),Le],ngContentSelectors:nY,decls:1,vars:0,consts:[["tabindex","-1","role","menu",1,"mat-menu-panel",3,"id","ngClass","keydown","click"],[1,"mat-menu-content"]],template:function(e,i){1&e&&(gn(),S(0,Exe,3,6,"ng-template"))},dependencies:[bn],styles:['mat-menu{display:none}.mat-menu-panel{min-width:112px;max-width:280px;overflow:auto;-webkit-overflow-scrolling:touch;max-height:calc(100vh - 48px);border-radius:4px;outline:0;min-height:64px;position:relative}.mat-menu-panel.ng-animating{pointer-events:none}.cdk-high-contrast-active .mat-menu-panel{outline:solid 1px}.mat-menu-content:not(:empty){padding-top:8px;padding-bottom:8px}.mat-menu-item{-webkit-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:rgba(0,0,0,0);white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;line-height:48px;height:48px;padding:0 16px;text-align:left;text-decoration:none;max-width:100%;position:relative}.mat-menu-item::-moz-focus-inner{border:0}.mat-menu-item[disabled]{cursor:default}[dir=rtl] .mat-menu-item{text-align:right}.mat-menu-item .mat-icon{margin-right:16px;vertical-align:middle}.mat-menu-item .mat-icon svg{vertical-align:top}[dir=rtl] .mat-menu-item .mat-icon{margin-left:16px;margin-right:0}.mat-menu-item[disabled]::after{display:block;position:absolute;content:"";top:0;left:0;bottom:0;right:0}.cdk-high-contrast-active .mat-menu-item{margin-top:1px}.mat-menu-item-submenu-trigger{padding-right:32px}[dir=rtl] .mat-menu-item-submenu-trigger{padding-right:16px;padding-left:32px}.mat-menu-submenu-icon{position:absolute;top:50%;right:16px;transform:translateY(-50%);width:5px;height:10px;fill:currentColor}[dir=rtl] .mat-menu-submenu-icon{right:auto;left:16px;transform:translateY(-50%) scaleX(-1)}.cdk-high-contrast-active .mat-menu-submenu-icon{fill:CanvasText}button.mat-menu-item{width:100%}.mat-menu-item .mat-menu-ripple{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none}'],encapsulation:2,data:{animation:[cv.transformMenu,cv.fadeInItems]},changeDetection:0}),n})(),Yu=(()=>{class n extends Ng{}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Cn(n)))(i||n)}}(),n.\u0275cmp=k({type:n,selectors:[["","mat-menu-item",""]],hostAttrs:[1,"mat-focus-indicator"],hostVars:20,hostBindings:function(e,i){2&e&&(Pe("role",i.role)("tabindex",i._getTabIndex())("aria-disabled",i.disabled.toString())("disabled",i.disabled||null),Qe("mat-menu-item",!0)("mat-menu-item-highlighted",i._highlighted)("mat-menu-item-submenu-trigger",i._triggersSubmenu)("mat-mdc-menu-item",!1)("mat-mdc-focus-indicator",!1)("mdc-list-item",!1)("mat-mdc-menu-item-highlighted",!1)("mat-mdc-menu-item-submenu-trigger",!1))},inputs:{disabled:"disabled",disableRipple:"disableRipple"},exportAs:["matMenuItem"],features:[Rt([{provide:Ng,useExisting:n}]),Le],attrs:Txe,ngContentSelectors:nY,decls:3,vars:3,consts:[["matRipple","",1,"mat-menu-ripple",3,"matRippleDisabled","matRippleTrigger"],["class","mat-menu-submenu-icon","viewBox","0 0 5 10","focusable","false",4,"ngIf"],["viewBox","0 0 5 10","focusable","false",1,"mat-menu-submenu-icon"],["points","0,0 5,5 0,10"]],template:function(e,i){1&e&&(gn(),Xt(0),P(1,"div",0),S(2,Dxe,2,0,"svg",1)),2&e&&(b(1),_("matRippleDisabled",i.disableRipple||i.disabled)("matRippleTrigger",i._getHostElement()),b(1),_("ngIf",i._triggersSubmenu))},dependencies:[Fe,Fr],encapsulation:2,changeDetection:0}),n})(),Pc=(()=>{class n extends tY{}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Cn(n)))(i||n)}}(),n.\u0275dir=xe({type:n,selectors:[["","mat-menu-trigger-for",""],["","matMenuTriggerFor",""]],hostAttrs:[1,"mat-menu-trigger"],exportAs:["matMenuTrigger"],features:[Le]}),n})(),Xu=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({providers:[eY],imports:[Te,Qt,Zo,Lr,Rc,Qt]}),n})();function Ixe(n,t){1&n&&P(0,"mat-icon",8)}function Axe(n,t){1&n&&P(0,"mat-icon",9)}function Rxe(n,t){1&n&&P(0,"mat-icon",10)}var Ua=(()=>(function(n){n[n.DEFAULT=0]="DEFAULT",n[n.DARK_MODE_ON=1]="DARK_MODE_ON",n[n.DARK_MODE_OFF=2]="DARK_MODE_OFF"}(Ua||(Ua={})),Ua))(),iY=(()=>{class n{constructor(){this.DarkModeOverride=Ua,this.onOverrideChanged=new L}getButtonTitle(){let e;switch(this.darkModeOverride){case Ua.DEFAULT:e="Browser default";break;case Ua.DARK_MODE_ON:e="Dark mode";break;case Ua.DARK_MODE_OFF:e="Light mode"}return`Current mode: [${e}]. Switch between browser default, light, or dark theme.`}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["app-header-dark-mode-toggle-component"]],inputs:{darkModeOverride:"darkModeOverride"},outputs:{onOverrideChanged:"onOverrideChanged"},decls:15,vars:6,consts:[["mat-icon-button","","aria-label","Menu for changing light or dark theme",3,"matMenuTriggerFor","ngSwitch","title"],["svgIcon","brightness_6_24px",4,"ngSwitchCase"],["svgIcon","light_mode_24px",4,"ngSwitchCase"],["svgIcon","dark_mode_24px",4,"ngSwitchCase"],["menu","matMenu"],["mat-menu-item","","title","Set the theme to match the default mode in the browser.",3,"click"],["mat-menu-item","","title","Force light TensorBoard theme.",3,"click"],["mat-menu-item","","title","Force dark TensorBoard theme.",3,"click"],["svgIcon","brightness_6_24px"],["svgIcon","light_mode_24px"],["svgIcon","dark_mode_24px"]],template:function(e,i){1&e&&(h(0,"button",0),S(1,Ixe,1,0,"mat-icon",1),S(2,Axe,1,0,"mat-icon",2),S(3,Rxe,1,0,"mat-icon",3),g(),h(4,"mat-menu",null,4)(6,"button",5),D("click",function(){return i.onOverrideChanged.emit(i.DarkModeOverride.DEFAULT)}),h(7,"label"),T(8,"Browser default"),g()(),h(9,"button",6),D("click",function(){return i.onOverrideChanged.emit(i.DarkModeOverride.DARK_MODE_OFF)}),h(10,"label"),T(11,"Light"),g()(),h(12,"button",7),D("click",function(){return i.onOverrideChanged.emit(i.DarkModeOverride.DARK_MODE_ON)}),h(13,"label"),T(14,"Dark"),g()()()),2&e&&(_("matMenuTriggerFor",tt(5))("ngSwitch",i.darkModeOverride)("title",i.getButtonTitle()),b(1),_("ngSwitchCase",i.DarkModeOverride.DEFAULT),b(1),_("ngSwitchCase",i.DarkModeOverride.DARK_MODE_OFF),b(1),_("ngSwitchCase",i.DarkModeOverride.DARK_MODE_ON))},dependencies:[Fn,Dn,kc,Yu,Pc,$i,sr],encapsulation:2}),n})(),rY=(()=>{class n{constructor(e){this.store=e,this.darkModeOverride$=this.store.select(uS).pipe(U(i=>null===i?Ua.DEFAULT:i?Ua.DARK_MODE_ON:Ua.DARK_MODE_OFF))}changeDarkMode(e){let i=null;switch(e){case Ua.DEFAULT:i=null;break;case Ua.DARK_MODE_OFF:i=!1;break;case Ua.DARK_MODE_ON:i=!0}this.store.dispatch(KS({enableDarkMode:i}))}}return n.\u0275fac=function(e){return new(e||n)(C(ke))},n.\u0275cmp=k({type:n,selectors:[["app-header-dark-mode-toggle"]],decls:2,vars:3,consts:[[3,"darkModeOverride","onOverrideChanged"]],template:function(e,i){1&e&&(h(0,"app-header-dark-mode-toggle-component",0),D("onOverrideChanged",function(o){return i.changeDarkMode(o)}),G(1,"async"),g()),2&e&&_("darkModeOverride",W(1,1,i.darkModeOverride$))},dependencies:[iY,lt],encapsulation:2}),n})();function Oxe(n,t){}var Fxe=function(n){return{animationDuration:n}},Lxe=function(n,t){return{value:n,params:t}},bL={translateTab:ji("translateTab",[Jn("center, void, left-origin-center, right-origin-center",Bt({transform:"none"})),Jn("left",Bt({transform:"translate3d(-100%, 0, 0)",minHeight:"1px",visibility:"hidden"})),Jn("right",Bt({transform:"translate3d(100%, 0, 0)",minHeight:"1px",visibility:"hidden"})),Wn("* => left, * => right, left => center, right => center",Kn("{{animationDuration}} cubic-bezier(0.35, 0, 0.25, 1)")),Wn("void => left-origin-center",[Bt({transform:"translate3d(-100%, 0, 0)",visibility:"hidden"}),Kn("{{animationDuration}} cubic-bezier(0.35, 0, 0.25, 1)")]),Wn("void => right-origin-center",[Bt({transform:"translate3d(100%, 0, 0)",visibility:"hidden"}),Kn("{{animationDuration}} cubic-bezier(0.35, 0, 0.25, 1)")])])},vL=(()=>{class n extends No{constructor(e,i,r,o){super(e,i,o),this._host=r,this._centeringSub=yn.EMPTY,this._leavingSub=yn.EMPTY}ngOnInit(){super.ngOnInit(),this._centeringSub=this._host._beforeCentering.pipe(Nn(this._host._isCenterPosition(this._host._position))).subscribe(e=>{e&&!this.hasAttached()&&this.attach(this._host._content)}),this._leavingSub=this._host._afterLeavingCenter.subscribe(()=>{this._host.preserveContent||this.detach()})}ngOnDestroy(){super.ngOnDestroy(),this._centeringSub.unsubscribe(),this._leavingSub.unsubscribe()}}return n.\u0275fac=function(e){return new(e||n)(C(Qr),C(Zn),C(Vn(()=>Nxe)),C(kt))},n.\u0275dir=xe({type:n,selectors:[["","matTabBodyHost",""]],features:[Le]}),n})(),xL=(()=>{class n{set position(e){this._positionIndex=e,this._computePositionAnimationState()}constructor(e,i,r){this._elementRef=e,this._dir=i,this._dirChangeSubscription=yn.EMPTY,this._translateTabComplete=new Ae,this._onCentering=new L,this._beforeCentering=new L,this._afterLeavingCenter=new L,this._onCentered=new L(!0),this.animationDuration="500ms",this.preserveContent=!1,i&&(this._dirChangeSubscription=i.change.subscribe(o=>{this._computePositionAnimationState(o),r.markForCheck()})),this._translateTabComplete.pipe(ui((o,a)=>o.fromState===a.fromState&&o.toState===a.toState)).subscribe(o=>{this._isCenterPosition(o.toState)&&this._isCenterPosition(this._position)&&this._onCentered.emit(),this._isCenterPosition(o.fromState)&&!this._isCenterPosition(this._position)&&this._afterLeavingCenter.emit()})}ngOnInit(){"center"==this._position&&null!=this.origin&&(this._position=this._computePositionFromOrigin(this.origin))}ngOnDestroy(){this._dirChangeSubscription.unsubscribe(),this._translateTabComplete.complete()}_onTranslateTabStarted(e){let i=this._isCenterPosition(e.toState);this._beforeCentering.emit(i),i&&this._onCentering.emit(this._elementRef.nativeElement.clientHeight)}_getLayoutDirection(){return this._dir&&"rtl"===this._dir.value?"rtl":"ltr"}_isCenterPosition(e){return"center"==e||"left-origin-center"==e||"right-origin-center"==e}_computePositionAnimationState(e=this._getLayoutDirection()){this._position=this._positionIndex<0?"ltr"==e?"left":"right":this._positionIndex>0?"ltr"==e?"right":"left":"center"}_computePositionFromOrigin(e){let i=this._getLayoutDirection();return"ltr"==i&&e<=0||"rtl"==i&&e>0?"left-origin-center":"right-origin-center"}}return n.\u0275fac=function(e){return new(e||n)(C(be),C(Hi,8),C(Ft))},n.\u0275dir=xe({type:n,inputs:{_content:["content","_content"],origin:"origin",animationDuration:"animationDuration",preserveContent:"preserveContent",position:"position"},outputs:{_onCentering:"_onCentering",_beforeCentering:"_beforeCentering",_afterLeavingCenter:"_afterLeavingCenter",_onCentered:"_onCentered"}}),n})(),Nxe=(()=>{class n extends xL{constructor(e,i,r){super(e,i,r)}}return n.\u0275fac=function(e){return new(e||n)(C(be),C(Hi,8),C(Ft))},n.\u0275cmp=k({type:n,selectors:[["mat-tab-body"]],viewQuery:function(e,i){if(1&e&&Ye(No,5),2&e){let r;we(r=Se())&&(i._portalHost=r.first)}},hostAttrs:[1,"mat-mdc-tab-body"],features:[Le],decls:3,vars:6,consts:[["cdkScrollable","",1,"mat-mdc-tab-body-content"],["content",""],["matTabBodyHost",""]],template:function(e,i){1&e&&(h(0,"div",0,1),D("@translateTab.start",function(o){return i._onTranslateTabStarted(o)})("@translateTab.done",function(o){return i._translateTabComplete.next(o)}),S(2,Oxe,0,0,"ng-template",2),g()),2&e&&_("@translateTab",Pr(3,Lxe,i._position,Sn(1,Fxe,i.animationDuration)))},dependencies:[vL],styles:['.mat-mdc-tab-body{top:0;left:0;right:0;bottom:0;position:absolute;display:block;overflow:hidden;outline:0;flex-basis:100%}.mat-mdc-tab-body.mat-mdc-tab-body-active{position:relative;overflow-x:hidden;overflow-y:auto;z-index:1;flex-grow:1}.mat-mdc-tab-group.mat-mdc-tab-group-dynamic-height .mat-mdc-tab-body.mat-mdc-tab-body-active{overflow-y:hidden}.mat-mdc-tab-body-content{height:100%;overflow:auto}.mat-mdc-tab-group-dynamic-height .mat-mdc-tab-body-content{overflow:hidden}.mat-mdc-tab-body-content[style*="visibility: hidden"]{display:none}'],encapsulation:2,data:{animation:[bL.translateTab]}}),n})(),sY=new ie("MatTabContent"),CE=new ie("MatTabLabel"),CL=new ie("MAT_TAB"),lY=(()=>{class n extends K7{constructor(e,i,r){super(e,i),this._closestTab=r}}return n.\u0275fac=function(e){return new(e||n)(C(Si),C(Zn),C(CL,8))},n.\u0275dir=xe({type:n,selectors:[["","mat-tab-label",""],["","matTabLabel",""]],features:[Rt([{provide:CE,useExisting:n}]),Le]}),n})(),_L="mdc-tab-indicator--active",oY="mdc-tab-indicator--no-transition";function cY(n){return class extends n{constructor(...t){super(...t),this._fitToContent=!1}get fitInkBarToContent(){return this._fitToContent}set fitInkBarToContent(t){let e=Ut(t);this._fitToContent!==e&&(this._fitToContent=e,this._inkBarElement&&this._appendInkBarElement())}activateInkBar(t){let e=this.elementRef.nativeElement;if(!t||!e.getBoundingClientRect||!this._inkBarContentElement)return void e.classList.add(_L);let i=e.getBoundingClientRect(),r=t.width/i.width,o=t.left-i.left;e.classList.add(oY),this._inkBarContentElement.style.setProperty("transform",`translateX(${o}px) scaleX(${r})`),e.getBoundingClientRect(),e.classList.remove(oY),e.classList.add(_L),this._inkBarContentElement.style.setProperty("transform","")}deactivateInkBar(){this.elementRef.nativeElement.classList.remove(_L)}ngOnInit(){this._createInkBarElement()}ngOnDestroy(){this._inkBarElement?.remove(),this._inkBarElement=this._inkBarContentElement=null}_createInkBarElement(){let t=this.elementRef.nativeElement.ownerDocument||document;this._inkBarElement=t.createElement("span"),this._inkBarContentElement=t.createElement("span"),this._inkBarElement.className="mdc-tab-indicator",this._inkBarContentElement.className="mdc-tab-indicator__content mdc-tab-indicator__content--underline",this._inkBarElement.appendChild(this._inkBarContentElement),this._appendInkBarElement()}_appendInkBarElement(){(this._fitToContent?this.elementRef.nativeElement.querySelector(".mdc-tab__content"):this.elementRef.nativeElement).appendChild(this._inkBarElement)}}}var dY=new ie("MatInkBarPositioner",{providedIn:"root",factory:function(){return t=>({left:t?(t.offsetLeft||0)+"px":"0",width:t?(t.offsetWidth||0)+"px":"0"})}}),Vxe=Kr(class{}),ML=(()=>{class n extends Vxe{constructor(e){super(),this.elementRef=e}focus(){this.elementRef.nativeElement.focus()}getOffsetLeft(){return this.elementRef.nativeElement.offsetLeft}getOffsetWidth(){return this.elementRef.nativeElement.offsetWidth}}return n.\u0275fac=function(e){return new(e||n)(C(be))},n.\u0275dir=xe({type:n,features:[Le]}),n})(),Hxe=(cY(ML),Kr(class{})),wL=new ie("MAT_TAB_GROUP"),uY=(()=>{class n extends Hxe{get content(){return this._contentPortal}constructor(e,i){super(),this._viewContainerRef=e,this._closestTabGroup=i,this.textLabel="",this._contentPortal=null,this._stateChanges=new Ae,this.position=null,this.origin=null,this.isActive=!1}ngOnChanges(e){(e.hasOwnProperty("textLabel")||e.hasOwnProperty("disabled"))&&this._stateChanges.next()}ngOnDestroy(){this._stateChanges.complete()}ngOnInit(){this._contentPortal=new Jo(this._explicitContent||this._implicitContent,this._viewContainerRef)}_setTemplateLabelInput(e){e&&e._closestTab===this&&(this._templateLabel=e)}}return n.\u0275fac=function(e){return new(e||n)(C(Zn),C(wL,8))},n.\u0275dir=xe({type:n,viewQuery:function(e,i){if(1&e&&Ye(Si,7),2&e){let r;we(r=Se())&&(i._implicitContent=r.first)}},inputs:{textLabel:["label","textLabel"],ariaLabel:["aria-label","ariaLabel"],ariaLabelledby:["aria-labelledby","ariaLabelledby"],labelClass:"labelClass",bodyClass:"bodyClass"},features:[Le,Gt]}),n})(),aY=Yo({passive:!0}),pY=(()=>{class n{get disablePagination(){return this._disablePagination}set disablePagination(e){this._disablePagination=Ut(e)}get selectedIndex(){return this._selectedIndex}set selectedIndex(e){e=Di(e),this._selectedIndex!=e&&(this._selectedIndexChanged=!0,this._selectedIndex=e,this._keyManager&&this._keyManager.updateActiveItem(e))}constructor(e,i,r,o,a,s,l){this._elementRef=e,this._changeDetectorRef=i,this._viewportRuler=r,this._dir=o,this._ngZone=a,this._platform=s,this._animationMode=l,this._scrollDistance=0,this._selectedIndexChanged=!1,this._destroyed=new Ae,this._showPaginationControls=!1,this._disableScrollAfter=!0,this._disableScrollBefore=!0,this._stopScrolling=new Ae,this._disablePagination=!1,this._selectedIndex=0,this.selectFocusedIndex=new L,this.indexFocused=new L,a.runOutsideAngular(()=>{ai(e.nativeElement,"mouseleave").pipe(ot(this._destroyed)).subscribe(()=>{this._stopInterval()})})}ngAfterViewInit(){ai(this._previousPaginator.nativeElement,"touchstart",aY).pipe(ot(this._destroyed)).subscribe(()=>{this._handlePaginatorPress("before")}),ai(this._nextPaginator.nativeElement,"touchstart",aY).pipe(ot(this._destroyed)).subscribe(()=>{this._handlePaginatorPress("after")})}ngAfterContentInit(){let e=this._dir?this._dir.change:qt("ltr"),i=this._viewportRuler.change(150),r=()=>{this.updatePagination(),this._alignInkBarToSelectedTab()};this._keyManager=new gg(this._items).withHorizontalOrientation(this._getLayoutDirection()).withHomeAndEnd().withWrap().skipPredicate(()=>!1),this._keyManager.updateActiveItem(this._selectedIndex),this._ngZone.onStable.pipe(zt(1)).subscribe(r),cn(e,i,this._items.changes,this._itemsResized()).pipe(ot(this._destroyed)).subscribe(()=>{this._ngZone.run(()=>{Promise.resolve().then(()=>{this._scrollDistance=Math.max(0,Math.min(this._getMaxScrollDistance(),this._scrollDistance)),r()})}),this._keyManager.withHorizontalOrientation(this._getLayoutDirection())}),this._keyManager.change.subscribe(o=>{this.indexFocused.emit(o),this._setTabFocus(o)})}_itemsResized(){return"function"!=typeof ResizeObserver?to:this._items.changes.pipe(Nn(this._items),yi(e=>new en(i=>this._ngZone.runOutsideAngular(()=>{let r=new ResizeObserver(o=>i.next(o));return e.forEach(o=>r.observe(o.elementRef.nativeElement)),()=>{r.disconnect()}}))),$a(1),Ve(e=>e.some(i=>i.contentRect.width>0&&i.contentRect.height>0)))}ngAfterContentChecked(){this._tabLabelCount!=this._items.length&&(this.updatePagination(),this._tabLabelCount=this._items.length,this._changeDetectorRef.markForCheck()),this._selectedIndexChanged&&(this._scrollToLabel(this._selectedIndex),this._checkScrollingControls(),this._alignInkBarToSelectedTab(),this._selectedIndexChanged=!1,this._changeDetectorRef.markForCheck()),this._scrollDistanceChanged&&(this._updateTabScrollPosition(),this._scrollDistanceChanged=!1,this._changeDetectorRef.markForCheck())}ngOnDestroy(){this._keyManager?.destroy(),this._destroyed.next(),this._destroyed.complete(),this._stopScrolling.complete()}_handleKeydown(e){if(!yr(e))switch(e.keyCode){case 13:case 32:if(this.focusIndex!==this.selectedIndex){let i=this._items.get(this.focusIndex);i&&!i.disabled&&(this.selectFocusedIndex.emit(this.focusIndex),this._itemSelected(e))}break;default:this._keyManager.onKeydown(e)}}_onContentChanges(){let e=this._elementRef.nativeElement.textContent;e!==this._currentTextContent&&(this._currentTextContent=e||"",this._ngZone.run(()=>{this.updatePagination(),this._alignInkBarToSelectedTab(),this._changeDetectorRef.markForCheck()}))}updatePagination(){this._checkPaginationEnabled(),this._checkScrollingControls(),this._updateTabScrollPosition()}get focusIndex(){return this._keyManager?this._keyManager.activeItemIndex:0}set focusIndex(e){!this._isValidIndex(e)||this.focusIndex===e||!this._keyManager||this._keyManager.setActiveItem(e)}_isValidIndex(e){return!this._items||!!this._items.toArray()[e]}_setTabFocus(e){if(this._showPaginationControls&&this._scrollToLabel(e),this._items&&this._items.length){this._items.toArray()[e].focus();let i=this._tabListContainer.nativeElement;i.scrollLeft="ltr"==this._getLayoutDirection()?0:i.scrollWidth-i.offsetWidth}}_getLayoutDirection(){return this._dir&&"rtl"===this._dir.value?"rtl":"ltr"}_updateTabScrollPosition(){if(this.disablePagination)return;let e=this.scrollDistance,i="ltr"===this._getLayoutDirection()?-e:e;this._tabList.nativeElement.style.transform=`translateX(${Math.round(i)}px)`,(this._platform.TRIDENT||this._platform.EDGE)&&(this._tabListContainer.nativeElement.scrollLeft=0)}get scrollDistance(){return this._scrollDistance}set scrollDistance(e){this._scrollTo(e)}_scrollHeader(e){return this._scrollTo(this._scrollDistance+("before"==e?-1:1)*this._tabListContainer.nativeElement.offsetWidth/3)}_handlePaginatorClick(e){this._stopInterval(),this._scrollHeader(e)}_scrollToLabel(e){if(this.disablePagination)return;let i=this._items?this._items.toArray()[e]:null;if(!i)return;let s,l,r=this._tabListContainer.nativeElement.offsetWidth,{offsetLeft:o,offsetWidth:a}=i.elementRef.nativeElement;"ltr"==this._getLayoutDirection()?(s=o,l=s+a):(l=this._tabListInner.nativeElement.offsetWidth-o,s=l-a);let c=this.scrollDistance,d=this.scrollDistance+r;s<c?this.scrollDistance-=c-s:l>d&&(this.scrollDistance+=Math.min(l-d,s-c))}_checkPaginationEnabled(){if(this.disablePagination)this._showPaginationControls=!1;else{let e=this._tabListInner.nativeElement.scrollWidth>this._elementRef.nativeElement.offsetWidth;e||(this.scrollDistance=0),e!==this._showPaginationControls&&this._changeDetectorRef.markForCheck(),this._showPaginationControls=e}}_checkScrollingControls(){this.disablePagination?this._disableScrollAfter=this._disableScrollBefore=!0:(this._disableScrollBefore=0==this.scrollDistance,this._disableScrollAfter=this.scrollDistance==this._getMaxScrollDistance(),this._changeDetectorRef.markForCheck())}_getMaxScrollDistance(){return this._tabListInner.nativeElement.scrollWidth-this._tabListContainer.nativeElement.offsetWidth||0}_alignInkBarToSelectedTab(){let e=this._items&&this._items.length?this._items.toArray()[this.selectedIndex]:null,i=e?e.elementRef.nativeElement:null;i?this._inkBar.alignToElement(i):this._inkBar.hide()}_stopInterval(){this._stopScrolling.next()}_handlePaginatorPress(e,i){i&&null!=i.button&&0!==i.button||(this._stopInterval(),Ja(650,100).pipe(ot(cn(this._stopScrolling,this._destroyed))).subscribe(()=>{let{maxScrollDistance:r,distance:o}=this._scrollHeader(e);(0===o||o>=r)&&this._stopInterval()}))}_scrollTo(e){if(this.disablePagination)return{maxScrollDistance:0,distance:0};let i=this._getMaxScrollDistance();return this._scrollDistance=Math.max(0,Math.min(i,e)),this._scrollDistanceChanged=!0,this._checkScrollingControls(),{maxScrollDistance:i,distance:this._scrollDistance}}}return n.\u0275fac=function(e){return new(e||n)(C(be),C(Ft),C(Ko),C(Hi,8),C(at),C($n),C(di,8))},n.\u0275dir=xe({type:n,inputs:{disablePagination:"disablePagination"}}),n})(),fY=(()=>{class n extends pY{get disableRipple(){return this._disableRipple}set disableRipple(e){this._disableRipple=Ut(e)}constructor(e,i,r,o,a,s,l){super(e,i,r,o,a,s,l),this._disableRipple=!1}_itemSelected(e){e.preventDefault()}}return n.\u0275fac=function(e){return new(e||n)(C(be),C(Ft),C(Ko),C(Hi,8),C(at),C($n),C(di,8))},n.\u0275dir=xe({type:n,inputs:{disableRipple:"disableRipple"},features:[Le]}),n})(),SL=new ie("MAT_TABS_CONFIG"),jxe=0,Gxe=go(Qo(class{constructor(n){this._elementRef=n}}),"primary"),mY=(()=>{class n extends Gxe{get dynamicHeight(){return this._dynamicHeight}set dynamicHeight(e){this._dynamicHeight=Ut(e)}get selectedIndex(){return this._selectedIndex}set selectedIndex(e){this._indexToSelect=Di(e,null)}get animationDuration(){return this._animationDuration}set animationDuration(e){this._animationDuration=/^\d+$/.test(e+"")?e+"ms":e}get contentTabIndex(){return this._contentTabIndex}set contentTabIndex(e){this._contentTabIndex=Di(e,null)}get disablePagination(){return this._disablePagination}set disablePagination(e){this._disablePagination=Ut(e)}get preserveContent(){return this._preserveContent}set preserveContent(e){this._preserveContent=Ut(e)}get backgroundColor(){return this._backgroundColor}set backgroundColor(e){let i=this._elementRef.nativeElement.classList;i.remove("mat-tabs-with-background",`mat-background-${this.backgroundColor}`),e&&i.add("mat-tabs-with-background",`mat-background-${e}`),this._backgroundColor=e}constructor(e,i,r,o){super(e),this._changeDetectorRef=i,this._animationMode=o,this._tabs=new Is,this._indexToSelect=0,this._lastFocusedTabIndex=null,this._tabBodyWrapperHeight=0,this._tabsSubscription=yn.EMPTY,this._tabLabelSubscription=yn.EMPTY,this._dynamicHeight=!1,this._selectedIndex=null,this.headerPosition="above",this._disablePagination=!1,this._preserveContent=!1,this.selectedIndexChange=new L,this.focusChange=new L,this.animationDone=new L,this.selectedTabChange=new L(!0),this._groupId=jxe++,this.animationDuration=r&&r.animationDuration?r.animationDuration:"500ms",this.disablePagination=!(!r||null==r.disablePagination)&&r.disablePagination,this.dynamicHeight=!(!r||null==r.dynamicHeight)&&r.dynamicHeight,this.contentTabIndex=r?.contentTabIndex??null,this.preserveContent=!!r?.preserveContent}ngAfterContentChecked(){let e=this._indexToSelect=this._clampTabIndex(this._indexToSelect);if(this._selectedIndex!=e){let i=null==this._selectedIndex;if(!i){this.selectedTabChange.emit(this._createChangeEvent(e));let r=this._tabBodyWrapper.nativeElement;r.style.minHeight=r.clientHeight+"px"}Promise.resolve().then(()=>{this._tabs.forEach((r,o)=>r.isActive=o===e),i||(this.selectedIndexChange.emit(e),this._tabBodyWrapper.nativeElement.style.minHeight="")})}this._tabs.forEach((i,r)=>{i.position=r-e,null!=this._selectedIndex&&0==i.position&&!i.origin&&(i.origin=e-this._selectedIndex)}),this._selectedIndex!==e&&(this._selectedIndex=e,this._lastFocusedTabIndex=null,this._changeDetectorRef.markForCheck())}ngAfterContentInit(){this._subscribeToAllTabChanges(),this._subscribeToTabLabels(),this._tabsSubscription=this._tabs.changes.subscribe(()=>{let e=this._clampTabIndex(this._indexToSelect);if(e===this._selectedIndex){let r,i=this._tabs.toArray();for(let o=0;o<i.length;o++)if(i[o].isActive){this._indexToSelect=this._selectedIndex=o,this._lastFocusedTabIndex=null,r=i[o];break}!r&&i[e]&&Promise.resolve().then(()=>{i[e].isActive=!0,this.selectedTabChange.emit(this._createChangeEvent(e))})}this._changeDetectorRef.markForCheck()})}_subscribeToAllTabChanges(){this._allTabs.changes.pipe(Nn(this._allTabs)).subscribe(e=>{this._tabs.reset(e.filter(i=>i._closestTabGroup===this||!i._closestTabGroup)),this._tabs.notifyOnChanges()})}ngOnDestroy(){this._tabs.destroy(),this._tabsSubscription.unsubscribe(),this._tabLabelSubscription.unsubscribe()}realignInkBar(){this._tabHeader&&this._tabHeader._alignInkBarToSelectedTab()}updatePagination(){this._tabHeader&&this._tabHeader.updatePagination()}focusTab(e){let i=this._tabHeader;i&&(i.focusIndex=e)}_focusChanged(e){this._lastFocusedTabIndex=e,this.focusChange.emit(this._createChangeEvent(e))}_createChangeEvent(e){let i=new yL;return i.index=e,this._tabs&&this._tabs.length&&(i.tab=this._tabs.toArray()[e]),i}_subscribeToTabLabels(){this._tabLabelSubscription&&this._tabLabelSubscription.unsubscribe(),this._tabLabelSubscription=cn(...this._tabs.map(e=>e._stateChanges)).subscribe(()=>this._changeDetectorRef.markForCheck())}_clampTabIndex(e){return Math.min(this._tabs.length-1,Math.max(e||0,0))}_getTabLabelId(e){return`mat-tab-label-${this._groupId}-${e}`}_getTabContentId(e){return`mat-tab-content-${this._groupId}-${e}`}_setTabBodyWrapperHeight(e){if(!this._dynamicHeight||!this._tabBodyWrapperHeight)return;let i=this._tabBodyWrapper.nativeElement;i.style.height=this._tabBodyWrapperHeight+"px",this._tabBodyWrapper.nativeElement.offsetHeight&&(i.style.height=e+"px")}_removeTabBodyWrapperHeight(){let e=this._tabBodyWrapper.nativeElement;this._tabBodyWrapperHeight=e.clientHeight,e.style.height="",this.animationDone.emit()}_handleClick(e,i,r){i.focusIndex=r,e.disabled||(this.selectedIndex=r)}_getTabIndex(e){return e===(this._lastFocusedTabIndex??this.selectedIndex)?0:-1}_tabFocusChanged(e,i){e&&"mouse"!==e&&"touch"!==e&&(this._tabHeader.focusIndex=i)}}return n.\u0275fac=function(e){return new(e||n)(C(be),C(Ft),C(SL,8),C(di,8))},n.\u0275dir=xe({type:n,inputs:{dynamicHeight:"dynamicHeight",selectedIndex:"selectedIndex",headerPosition:"headerPosition",animationDuration:"animationDuration",contentTabIndex:"contentTabIndex",disablePagination:"disablePagination",preserveContent:"preserveContent",backgroundColor:"backgroundColor"},outputs:{selectedIndexChange:"selectedIndexChange",focusChange:"focusChange",animationDone:"animationDone",selectedTabChange:"selectedTabChange"},features:[Le]}),n})(),yL=class{},Wxe=0,hY=(()=>{class n extends pY{get backgroundColor(){return this._backgroundColor}set backgroundColor(e){let i=this._elementRef.nativeElement.classList;i.remove("mat-tabs-with-background",`mat-background-${this.backgroundColor}`),e&&i.add("mat-tabs-with-background",`mat-background-${e}`),this._backgroundColor=e}get disableRipple(){return this._disableRipple}set disableRipple(e){this._disableRipple=Ut(e)}constructor(e,i,r,o,a,s,l){super(e,o,a,i,r,s,l),this._disableRipple=!1,this.color="primary"}_itemSelected(){}ngAfterContentInit(){this._items.changes.pipe(Nn(null),ot(this._destroyed)).subscribe(()=>{this.updateActiveLink()}),super.ngAfterContentInit()}updateActiveLink(){if(!this._items)return;let e=this._items.toArray();for(let i=0;i<e.length;i++)if(e[i].active)return this.selectedIndex=i,this._changeDetectorRef.markForCheck(),void(this.tabPanel&&(this.tabPanel._activeTabId=e[i].id));this.selectedIndex=-1,this._inkBar.hide()}_getRole(){return this.tabPanel?"tablist":this._elementRef.nativeElement.getAttribute("role")}}return n.\u0275fac=function(e){return new(e||n)(C(be),C(Hi,8),C(at),C(Ft),C(Ko),C($n),C(di,8))},n.\u0275dir=xe({type:n,inputs:{backgroundColor:"backgroundColor",disableRipple:"disableRipple",color:"color",tabPanel:"tabPanel"},features:[Le]}),n})(),qxe=vd(Qo(Kr(class{}))),gY=(()=>{class n extends qxe{get active(){return this._isActive}set active(e){let i=Ut(e);i!==this._isActive&&(this._isActive=i,this._tabNavBar.updateActiveLink())}get rippleDisabled(){return this.disabled||this.disableRipple||this._tabNavBar.disableRipple||!!this.rippleConfig.disabled}constructor(e,i,r,o,a,s){super(),this._tabNavBar=e,this.elementRef=i,this._focusMonitor=a,this._isActive=!1,this.id="mat-tab-link-"+Wxe++,this.rippleConfig=r||{},this.tabIndex=parseInt(o)||0,"NoopAnimations"===s&&(this.rippleConfig.animation={enterDuration:0,exitDuration:0})}focus(){this.elementRef.nativeElement.focus()}ngAfterViewInit(){this._focusMonitor.monitor(this.elementRef)}ngOnDestroy(){this._focusMonitor.stopMonitoring(this.elementRef)}_handleFocus(){this._tabNavBar.focusIndex=this._tabNavBar._items.toArray().indexOf(this)}_handleKeydown(e){this._tabNavBar.tabPanel&&32===e.keyCode&&this.elementRef.nativeElement.click()}_getAriaControls(){return this._tabNavBar.tabPanel?this._tabNavBar.tabPanel?.id:this.elementRef.nativeElement.getAttribute("aria-controls")}_getAriaSelected(){return this._tabNavBar.tabPanel?this.active?"true":"false":this.elementRef.nativeElement.getAttribute("aria-selected")}_getAriaCurrent(){return this.active&&!this._tabNavBar.tabPanel?"page":null}_getRole(){return this._tabNavBar.tabPanel?"tab":this.elementRef.nativeElement.getAttribute("role")}_getTabIndex(){return this._tabNavBar.tabPanel?this._isActive&&!this.disabled?0:-1:this.tabIndex}}return n.\u0275fac=function(e){return new(e||n)(C(hY),C(be),C(Gb,8),Vr("tabindex"),C(lr),C(di,8))},n.\u0275dir=xe({type:n,inputs:{active:"active",id:"id"},features:[Le]}),n})();function Yxe(n,t){1&n&&Xt(0)}cY(gY);var yY=["*"];function Xxe(n,t){}var Qxe=function(n){return{animationDuration:n}},Zxe=function(n,t){return{value:n,params:t}},Kxe=["tabListContainer"],Jxe=["tabList"],$xe=["tabListInner"],eCe=["nextPaginator"],tCe=["previousPaginator"],nCe=["tabBodyWrapper"],iCe=["tabHeader"];function rCe(n,t){}function oCe(n,t){1&n&&S(0,rCe,0,0,"ng-template",10),2&n&&_("cdkPortalOutlet",w().$implicit.templateLabel)}function aCe(n,t){1&n&&T(0),2&n&&ut(w().$implicit.textLabel)}function sCe(n,t){if(1&n){let e=ge();h(0,"div",6),D("click",function(){let r=X(e),o=r.$implicit,a=r.index,s=w(),l=tt(1);return Q(s._handleClick(o,l,a))})("cdkFocusChange",function(r){let a=X(e).index;return Q(w()._tabFocusChanged(r,a))}),h(1,"div",7),S(2,oCe,1,1,"ng-template",8),S(3,aCe,1,1,"ng-template",null,9,Zt),g()()}if(2&n){let e=t.$implicit,i=t.index,r=tt(4),o=w();Qe("mat-tab-label-active",o.selectedIndex===i),_("id",o._getTabLabelId(i))("ngClass",e.labelClass)("disabled",e.disabled)("matRippleDisabled",e.disabled||o.disableRipple),Pe("tabIndex",o._getTabIndex(i))("aria-posinset",i+1)("aria-setsize",o._tabs.length)("aria-controls",o._getTabContentId(i))("aria-selected",o.selectedIndex===i)("aria-label",e.ariaLabel||null)("aria-labelledby",!e.ariaLabel&&e.ariaLabelledby?e.ariaLabelledby:null),b(2),_("ngIf",e.templateLabel)("ngIfElse",r)}}function lCe(n,t){if(1&n){let e=ge();h(0,"mat-tab-body",11),D("_onCentered",function(){return X(e),Q(w()._removeTabBodyWrapperHeight())})("_onCentering",function(r){return X(e),Q(w()._setTabBodyWrapperHeight(r))}),g()}if(2&n){let e=t.$implicit,i=t.index,r=w();Qe("mat-tab-body-active",r.selectedIndex===i),_("id",r._getTabContentId(i))("ngClass",e.bodyClass)("content",e.content)("position",e.position)("origin",e.origin)("animationDuration",r.animationDuration)("preserveContent",r.preserveContent),Pe("tabindex",null!=r.contentTabIndex&&r.selectedIndex===i?r.contentTabIndex:null)("aria-labelledby",r._getTabLabelId(i))}}var _Y=(()=>{class n{constructor(e,i,r,o){this._elementRef=e,this._ngZone=i,this._inkBarPositioner=r,this._animationMode=o}alignToElement(e){this.show(),this._ngZone.run(()=>{this._ngZone.onStable.pipe(zt(1)).subscribe(()=>{let i=this._inkBarPositioner(e),r=this._elementRef.nativeElement;r.style.left=i.left,r.style.width=i.width})})}show(){this._elementRef.nativeElement.style.visibility="visible"}hide(){this._elementRef.nativeElement.style.visibility="hidden"}}return n.\u0275fac=function(e){return new(e||n)(C(be),C(at),C(dY),C(di,8))},n.\u0275dir=xe({type:n,selectors:[["mat-ink-bar"]],hostAttrs:[1,"mat-ink-bar"],hostVars:2,hostBindings:function(e,i){2&e&&Qe("_mat-animation-noopable","NoopAnimations"===i._animationMode)}}),n})(),uv=(()=>{class n extends uY{get templateLabel(){return this._templateLabel}set templateLabel(e){this._setTemplateLabelInput(e)}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Cn(n)))(i||n)}}(),n.\u0275cmp=k({type:n,selectors:[["mat-tab"]],contentQueries:function(e,i,r){if(1&e&&(ci(r,CE,5),ci(r,sY,7,Si)),2&e){let o;we(o=Se())&&(i.templateLabel=o.first),we(o=Se())&&(i._explicitContent=o.first)}},inputs:{disabled:"disabled"},exportAs:["matTab"],features:[Rt([{provide:CL,useExisting:n}]),Le],ngContentSelectors:yY,decls:1,vars:0,template:function(e,i){1&e&&(gn(),S(0,Yxe,1,0,"ng-template"))},encapsulation:2}),n})(),cCe=(()=>{class n extends vL{constructor(e,i,r,o){super(e,i,r,o)}}return n.\u0275fac=function(e){return new(e||n)(C(Qr),C(Zn),C(Vn(()=>bY)),C(kt))},n.\u0275dir=xe({type:n,selectors:[["","matTabBodyHost",""]],features:[Le]}),n})(),bY=(()=>{class n extends xL{constructor(e,i,r){super(e,i,r)}}return n.\u0275fac=function(e){return new(e||n)(C(be),C(Hi,8),C(Ft))},n.\u0275cmp=k({type:n,selectors:[["mat-tab-body"]],viewQuery:function(e,i){if(1&e&&Ye(No,5),2&e){let r;we(r=Se())&&(i._portalHost=r.first)}},hostAttrs:[1,"mat-tab-body"],features:[Le],decls:3,vars:6,consts:[["cdkScrollable","",1,"mat-tab-body-content"],["content",""],["matTabBodyHost",""]],template:function(e,i){1&e&&(h(0,"div",0,1),D("@translateTab.start",function(o){return i._onTranslateTabStarted(o)})("@translateTab.done",function(o){return i._translateTabComplete.next(o)}),S(2,Xxe,0,0,"ng-template",2),g()),2&e&&_("@translateTab",Pr(3,Zxe,i._position,Sn(1,Qxe,i.animationDuration)))},dependencies:[cCe],styles:['.mat-tab-body-content{height:100%;overflow:auto}.mat-tab-group-dynamic-height .mat-tab-body-content{overflow:hidden}.mat-tab-body-content[style*="visibility: hidden"]{display:none}'],encapsulation:2,data:{animation:[bL.translateTab]}}),n})(),vY=(()=>{class n extends ML{}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Cn(n)))(i||n)}}(),n.\u0275dir=xe({type:n,selectors:[["","matTabLabelWrapper",""]],hostVars:3,hostBindings:function(e,i){2&e&&(Pe("aria-disabled",!!i.disabled),Qe("mat-tab-disabled",i.disabled))},inputs:{disabled:"disabled"},features:[Le]}),n})(),dCe=(()=>{class n extends fY{constructor(e,i,r,o,a,s,l){super(e,i,r,o,a,s,l)}}return n.\u0275fac=function(e){return new(e||n)(C(be),C(Ft),C(Ko),C(Hi,8),C(at),C($n),C(di,8))},n.\u0275cmp=k({type:n,selectors:[["mat-tab-header"]],contentQueries:function(e,i,r){if(1&e&&ci(r,vY,4),2&e){let o;we(o=Se())&&(i._items=o)}},viewQuery:function(e,i){if(1&e&&(Ye(_Y,7),Ye(Kxe,7),Ye(Jxe,7),Ye($xe,7),Ye(eCe,5),Ye(tCe,5)),2&e){let r;we(r=Se())&&(i._inkBar=r.first),we(r=Se())&&(i._tabListContainer=r.first),we(r=Se())&&(i._tabList=r.first),we(r=Se())&&(i._tabListInner=r.first),we(r=Se())&&(i._nextPaginator=r.first),we(r=Se())&&(i._previousPaginator=r.first)}},hostAttrs:[1,"mat-tab-header"],hostVars:4,hostBindings:function(e,i){2&e&&Qe("mat-tab-header-pagination-controls-enabled",i._showPaginationControls)("mat-tab-header-rtl","rtl"==i._getLayoutDirection())},inputs:{selectedIndex:"selectedIndex"},outputs:{selectFocusedIndex:"selectFocusedIndex",indexFocused:"indexFocused"},features:[Le],ngContentSelectors:yY,decls:14,vars:10,consts:[["aria-hidden","true","type","button","mat-ripple","","tabindex","-1",1,"mat-tab-header-pagination","mat-tab-header-pagination-before","mat-elevation-z4",3,"matRippleDisabled","disabled","click","mousedown","touchend"],["previousPaginator",""],[1,"mat-tab-header-pagination-chevron"],[1,"mat-tab-label-container",3,"keydown"],["tabListContainer",""],["role","tablist",1,"mat-tab-list",3,"cdkObserveContent"],["tabList",""],[1,"mat-tab-labels"],["tabListInner",""],["aria-hidden","true","type","button","mat-ripple","","tabindex","-1",1,"mat-tab-header-pagination","mat-tab-header-pagination-after","mat-elevation-z4",3,"matRippleDisabled","disabled","mousedown","click","touchend"],["nextPaginator",""]],template:function(e,i){1&e&&(gn(),h(0,"button",0,1),D("click",function(){return i._handlePaginatorClick("before")})("mousedown",function(o){return i._handlePaginatorPress("before",o)})("touchend",function(){return i._stopInterval()}),P(2,"div",2),g(),h(3,"div",3,4),D("keydown",function(o){return i._handleKeydown(o)}),h(5,"div",5,6),D("cdkObserveContent",function(){return i._onContentChanges()}),h(7,"div",7,8),Xt(9),g(),P(10,"mat-ink-bar"),g()(),h(11,"button",9,10),D("mousedown",function(o){return i._handlePaginatorPress("after",o)})("click",function(){return i._handlePaginatorClick("after")})("touchend",function(){return i._stopInterval()}),P(13,"div",2),g()),2&e&&(Qe("mat-tab-header-pagination-disabled",i._disableScrollBefore),_("matRippleDisabled",i._disableScrollBefore||i.disableRipple)("disabled",i._disableScrollBefore||null),b(5),Qe("_mat-animation-noopable","NoopAnimations"===i._animationMode),b(6),Qe("mat-tab-header-pagination-disabled",i._disableScrollAfter),_("matRippleDisabled",i._disableScrollAfter||i.disableRipple)("disabled",i._disableScrollAfter||null))},dependencies:[Fr,pg,_Y],styles:[".mat-tab-header{display:flex;overflow:hidden;position:relative;flex-shrink:0}.mat-tab-header-pagination{-webkit-user-select:none;user-select:none;position:relative;display:none;justify-content:center;align-items:center;min-width:32px;cursor:pointer;z-index:2;-webkit-tap-highlight-color:rgba(0,0,0,0);touch-action:none;box-sizing:content-box;background:none;border:none;outline:0;padding:0}.mat-tab-header-pagination::-moz-focus-inner{border:0}.mat-tab-header-pagination-controls-enabled .mat-tab-header-pagination{display:flex}.mat-tab-header-pagination-before,.mat-tab-header-rtl .mat-tab-header-pagination-after{padding-left:4px}.mat-tab-header-pagination-before .mat-tab-header-pagination-chevron,.mat-tab-header-rtl .mat-tab-header-pagination-after .mat-tab-header-pagination-chevron{transform:rotate(-135deg)}.mat-tab-header-rtl .mat-tab-header-pagination-before,.mat-tab-header-pagination-after{padding-right:4px}.mat-tab-header-rtl .mat-tab-header-pagination-before .mat-tab-header-pagination-chevron,.mat-tab-header-pagination-after .mat-tab-header-pagination-chevron{transform:rotate(45deg)}.mat-tab-header-pagination-chevron{border-style:solid;border-width:2px 2px 0 0;height:8px;width:8px}.mat-tab-header-pagination-disabled{box-shadow:none;cursor:default}.mat-tab-list{flex-grow:1;position:relative;transition:transform 500ms cubic-bezier(0.35, 0, 0.25, 1)}.mat-ink-bar{position:absolute;bottom:0;height:2px;transition:500ms cubic-bezier(0.35, 0, 0.25, 1)}.mat-ink-bar._mat-animation-noopable{transition:none !important;animation:none !important}.mat-tab-group-inverted-header .mat-ink-bar{bottom:auto;top:0}.cdk-high-contrast-active .mat-ink-bar{outline:solid 2px;height:0}.mat-tab-labels{display:flex}[mat-align-tabs=center]>.mat-tab-header .mat-tab-labels{justify-content:center}[mat-align-tabs=end]>.mat-tab-header .mat-tab-labels{justify-content:flex-end}.mat-tab-label-container{display:flex;flex-grow:1;overflow:hidden;z-index:1}.mat-tab-list._mat-animation-noopable{transition:none !important;animation:none !important}.mat-tab-label{height:48px;padding:0 24px;cursor:pointer;box-sizing:border-box;opacity:.6;min-width:160px;text-align:center;display:inline-flex;justify-content:center;align-items:center;white-space:nowrap;position:relative}.mat-tab-label:focus{outline:none}.mat-tab-label:focus:not(.mat-tab-disabled){opacity:1}.mat-tab-label.mat-tab-disabled{cursor:default}.cdk-high-contrast-active .mat-tab-label.mat-tab-disabled{opacity:.5}.mat-tab-label .mat-tab-label-content{display:inline-flex;justify-content:center;align-items:center;white-space:nowrap}.cdk-high-contrast-active .mat-tab-label{opacity:1}.mat-tab-label::before{margin:5px}@media(max-width: 599px){.mat-tab-label{min-width:72px}}"],encapsulation:2}),n})(),ME=(()=>{class n extends mY{constructor(e,i,r,o){super(e,i,r,o)}}return n.\u0275fac=function(e){return new(e||n)(C(be),C(Ft),C(SL,8),C(di,8))},n.\u0275cmp=k({type:n,selectors:[["mat-tab-group"]],contentQueries:function(e,i,r){if(1&e&&ci(r,uv,5),2&e){let o;we(o=Se())&&(i._allTabs=o)}},viewQuery:function(e,i){if(1&e&&(Ye(nCe,5),Ye(iCe,5)),2&e){let r;we(r=Se())&&(i._tabBodyWrapper=r.first),we(r=Se())&&(i._tabHeader=r.first)}},hostAttrs:[1,"mat-tab-group"],hostVars:4,hostBindings:function(e,i){2&e&&Qe("mat-tab-group-dynamic-height",i.dynamicHeight)("mat-tab-group-inverted-header","below"===i.headerPosition)},inputs:{color:"color",disableRipple:"disableRipple"},exportAs:["matTabGroup"],features:[Rt([{provide:wL,useExisting:n}]),Le],decls:6,vars:7,consts:[[3,"selectedIndex","disableRipple","disablePagination","indexFocused","selectFocusedIndex"],["tabHeader",""],["class","mat-tab-label mat-focus-indicator","role","tab","matTabLabelWrapper","","mat-ripple","","cdkMonitorElementFocus","",3,"id","mat-tab-label-active","ngClass","disabled","matRippleDisabled","click","cdkFocusChange",4,"ngFor","ngForOf"],[1,"mat-tab-body-wrapper"],["tabBodyWrapper",""],["role","tabpanel",3,"id","mat-tab-body-active","ngClass","content","position","origin","animationDuration","preserveContent","_onCentered","_onCentering",4,"ngFor","ngForOf"],["role","tab","matTabLabelWrapper","","mat-ripple","","cdkMonitorElementFocus","",1,"mat-tab-label","mat-focus-indicator",3,"id","ngClass","disabled","matRippleDisabled","click","cdkFocusChange"],[1,"mat-tab-label-content"],[3,"ngIf","ngIfElse"],["tabTextLabel",""],[3,"cdkPortalOutlet"],["role","tabpanel",3,"id","ngClass","content","position","origin","animationDuration","preserveContent","_onCentered","_onCentering"]],template:function(e,i){1&e&&(h(0,"mat-tab-header",0,1),D("indexFocused",function(o){return i._focusChanged(o)})("selectFocusedIndex",function(o){return i.selectedIndex=o}),S(2,sCe,5,15,"div",2),g(),h(3,"div",3,4),S(5,lCe,1,11,"mat-tab-body",5),g()),2&e&&(_("selectedIndex",i.selectedIndex||0)("disableRipple",i.disableRipple)("disablePagination",i.disablePagination),b(2),_("ngForOf",i._tabs),b(1),Qe("_mat-animation-noopable","NoopAnimations"===i._animationMode),b(2),_("ngForOf",i._tabs))},dependencies:[bn,dn,Fe,No,Fr,x2,vY,bY,dCe],styles:[".mat-tab-group{display:flex;flex-direction:column;max-width:100%}.mat-tab-group.mat-tab-group-inverted-header{flex-direction:column-reverse}.mat-tab-label{height:48px;padding:0 24px;cursor:pointer;box-sizing:border-box;opacity:.6;min-width:160px;text-align:center;display:inline-flex;justify-content:center;align-items:center;white-space:nowrap;position:relative}.mat-tab-label:focus{outline:none}.mat-tab-label:focus:not(.mat-tab-disabled){opacity:1}.mat-tab-label.mat-tab-disabled{cursor:default}.cdk-high-contrast-active .mat-tab-label.mat-tab-disabled{opacity:.5}.mat-tab-label .mat-tab-label-content{display:inline-flex;justify-content:center;align-items:center;white-space:nowrap}.cdk-high-contrast-active .mat-tab-label{opacity:1}@media(max-width: 599px){.mat-tab-label{padding:0 12px}}@media(max-width: 959px){.mat-tab-label{padding:0 12px}}.mat-tab-group[mat-stretch-tabs]>.mat-tab-header .mat-tab-label{flex-basis:0;flex-grow:1}.mat-tab-body-wrapper{position:relative;overflow:hidden;display:flex;transition:height 500ms cubic-bezier(0.35, 0, 0.25, 1)}.mat-tab-body-wrapper._mat-animation-noopable{transition:none !important;animation:none !important}.mat-tab-body{top:0;left:0;right:0;bottom:0;position:absolute;display:block;overflow:hidden;outline:0;flex-basis:100%}.mat-tab-body.mat-tab-body-active{position:relative;overflow-x:hidden;overflow-y:auto;z-index:1;flex-grow:1}.mat-tab-group.mat-tab-group-dynamic-height .mat-tab-body.mat-tab-body-active{overflow-y:hidden}"],encapsulation:2}),n})(),xY=(()=>{class n extends lY{}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Cn(n)))(i||n)}}(),n.\u0275dir=xe({type:n,selectors:[["","mat-tab-label",""],["","matTabLabel",""]],features:[Rt([{provide:CE,useExisting:n}]),Le]}),n})(),wE=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Te,Qt,us,Zo,Pu,Df,Qt]}),n})();function uCe(n,t){if(1&n){let e=ge();h(0,"span",5),D("click",function(r){X(e);let o=w().$implicit;return Q(w().onActivePluginSelection(r,o.id))}),T(1),g()}if(2&n){let e=w().$implicit;Pe("data-plugin-id",e.id),b(1),ze(" ",e.tab_name," ")}}function pCe(n,t){1&n&&(h(0,"mat-tab",3),S(1,uCe,2,2,"ng-template",4),g()),2&n&&_("disabled",!t.$implicit.enabled)}function fCe(n,t){if(1&n&&(h(0,"mat-option",9),T(1),g()),2&n){let e=t.$implicit;_("value",e.id),Pe("data-plugin-id",e.id),b(1),ze(" ",e.tab_name," ")}}function mCe(n,t){if(1&n){let e=ge();h(0,"mat-form-field",6)(1,"mat-label"),T(2,"Inactive"),g(),h(3,"mat-select",7),D("selectionChange",function(r){return X(e),Q(w().onDisabledPluginSelectionChanged(r))}),S(4,fCe,2,3,"mat-option",8),g()()}if(2&n){let e=w();b(3),_("value",e.selectedPlugin),b(1),_("ngForOf",e.disabledPlugins)}}var MY=(()=>{class n{constructor(){this.onPluginSelectionChanged=new L}getActivePluginIndex(){return this.activePlugins.findIndex(({id:e})=>e===this.selectedPlugin)}onActivePluginSelection(e,i){e.stopPropagation(),this.onPluginSelectionChanged.emit(i)}onDisabledPluginSelectionChanged(e){this.onPluginSelectionChanged.emit(e.value)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["plugin-selector-component"]],inputs:{activePlugins:"activePlugins",disabledPlugins:"disabledPlugins",selectedPlugin:"selectedPlugin"},outputs:{onPluginSelectionChanged:"onPluginSelectionChanged"},decls:3,vars:3,consts:[["animationDuration","100ms",1,"active-plugin-list",3,"selectedIndex"],[3,"disabled",4,"ngFor","ngForOf"],["floatLabel","never",4,"ngIf"],[3,"disabled"],["mat-tab-label",""],[1,"plugin-name",3,"click"],["floatLabel","never"],[3,"value","selectionChange"],[3,"value",4,"ngFor","ngForOf"],[3,"value"]],template:function(e,i){1&e&&(h(0,"mat-tab-group",0),S(1,pCe,2,1,"mat-tab",1),g(),S(2,mCe,5,2,"mat-form-field",2)),2&e&&(_("selectedIndex",i.getActivePluginIndex()),b(1),_("ngForOf",i.activePlugins),b(1),_("ngIf",i.disabledPlugins.length>0))},dependencies:[ME,xY,uv,Ys,Eg,Gu,Ha,dn,Fe],styles:["[_nghost-%COMP%]{align-items:center;display:flex;flex:1 1 auto;font-size:14px;height:100%;overflow:hidden}mat-form-field[_ngcontent-%COMP%]{flex:0 0;margin-top:5px;width:130px}mat-label[_ngcontent-%COMP%], mat-select[_ngcontent-%COMP%], mat-option[_ngcontent-%COMP%]{font-weight:500;text-transform:uppercase}.active-plugin-list[_ngcontent-%COMP%]{align-self:stretch;flex:1 1 auto;overflow:hidden}.plugin-name[_ngcontent-%COMP%]{align-items:center;display:inline-flex;height:100%;justify-content:center;padding:0 12px;width:100%}[_nghost-%COMP%]     .mat-form-field.mat-form-field.mat-form-field .mat-form-field-underline, [_nghost-%COMP%]     .mat-form-field.mat-form-field.mat-form-field .mat-form-field-ripple, [_nghost-%COMP%]     .mat-form-field.mat-form-field.mat-form-field.mat-focused .mat-form-field-ripple{background-color:currentColor}[_nghost-%COMP%]     .mat-form-field.mat-form-field.mat-form-field .mat-select-value, [_nghost-%COMP%]     .mat-form-field.mat-form-field.mat-form-field .mat-select-arrow, [_nghost-%COMP%]     .mat-form-field.mat-form-field.mat-form-field.mat-focused .mat-form-field-label, [_nghost-%COMP%]     .mat-form-field.mat-form-field.mat-form-field.mat-focused .mat-select-arrow{color:inherit}[_nghost-%COMP%]     .active-plugin-list.mat-primary .mat-tab-list .mat-ink-bar{background-color:currentColor}[_nghost-%COMP%]     .active-plugin-list .mat-tab-label, [_nghost-%COMP%]     .active-plugin-list .mat-tab-link{color:inherit;opacity:.7}[_nghost-%COMP%]     .active-plugin-list .mat-tab-label.mat-tab-label-active, [_nghost-%COMP%]     .active-plugin-list .mat-tab-link.mat-tab-label-active{opacity:1}[_nghost-%COMP%]     .active-plugin-list .mat-tab-header-pagination-chevron{border-color:currentColor}[_nghost-%COMP%]     .active-plugin-list .mat-tab-header-pagination-disabled{visibility:hidden}[_nghost-%COMP%]     .active-plugin-list .mat-tab-disabled{display:none}[_nghost-%COMP%]     .active-plugin-list mat-tab-list, [_nghost-%COMP%]     .active-plugin-list .mat-tab-header, [_nghost-%COMP%]     .active-plugin-list .mat-tab-labels, [_nghost-%COMP%]     .active-plugin-list .mat-tab-label{height:100%}[_nghost-%COMP%]     .active-plugin-list .mat-tab-label{min-width:48px;padding:0;text-transform:uppercase}[_nghost-%COMP%]     .active-plugin-list .mat-tab-label-content{height:100%}[_nghost-%COMP%]     .active-plugin-list mat-tab-header .mat-tab-list{padding:0 36px}[_nghost-%COMP%]     .active-plugin-list mat-tab-header>:first-child, [_nghost-%COMP%]     .active-plugin-list mat-tab-header>.mat-tab-label-container, [_nghost-%COMP%]     .active-plugin-list mat-tab-header>:last-child{bottom:0;position:absolute;top:0}[_nghost-%COMP%]     .active-plugin-list mat-tab-header>:first-child, [_nghost-%COMP%]     .active-plugin-list mat-tab-header>.mat-tab-label-container{left:0}[_nghost-%COMP%]     .active-plugin-list mat-tab-header>:last-child, [_nghost-%COMP%]     .active-plugin-list mat-tab-header>.mat-tab-label-container{right:0}[_nghost-%COMP%]     .active-plugin-list mat-tab-header>.mat-tab-header-pagination{background-color:#f57c00}body.dark-mode   [_nghost-%COMP%]     .active-plugin-list mat-tab-header>.mat-tab-header-pagination{background-color:#ef6c00}"]}),n})(),wY=q(Qh,n=>Object.keys(n).map(t=>Object.assign({},{id:t},n[t]))),gCe=q(wY,n=>n.filter(t=>!t.enabled)),SY=(()=>{class n{constructor(e){this.store=e,this.activePlugin$=this.store.pipe(pn(qo)),this.plugins$=this.store.pipe(pn(wY)),this.disabledPlugins$=this.store.pipe(pn(gCe))}onPluginSelectionChange(e){this.store.dispatch(xc({plugin:e}))}}return n.\u0275fac=function(e){return new(e||n)(C(ke))},n.\u0275cmp=k({type:n,selectors:[["plugin-selector"]],decls:4,vars:9,consts:[[3,"activePlugins","disabledPlugins","selectedPlugin","onPluginSelectionChanged"]],template:function(e,i){1&e&&(h(0,"plugin-selector-component",0),D("onPluginSelectionChanged",function(o){return i.onPluginSelectionChange(o)}),G(1,"async"),G(2,"async"),G(3,"async"),g()),2&e&&_("activePlugins",W(1,3,i.plugins$))("disabledPlugins",W(2,5,i.disabledPlugins$))("selectedPlugin",W(3,7,i.activePlugin$))},dependencies:[MY,lt],encapsulation:2}),n})(),yCe=q(Qh,qo,(n,t)=>!(!t||!n[t])&&n[t].disable_reload),EY=(()=>{class n{constructor(e){this.store=e,this.reloadDisabled$=this.store.select(yCe),this.isReloading$=this.store.select(tW).pipe(Vi(this.reloadDisabled$),U(([i,r])=>!r&&i===De.LOADING)),this.lastLoadedTimeInMs$=this.store.select(Xh)}triggerReload(){this.store.dispatch(Hs())}getReloadTitle(e){return e?`Last Updated: ${e}`:"Loading..."}}return n.\u0275fac=function(e){return new(e||n)(C(ke))},n.\u0275cmp=k({type:n,selectors:[["app-header-reload"]],decls:6,vars:13,consts:[["mat-icon-button","",1,"reload-button",3,"title","disabled","click"],["svgIcon","refresh_24px",1,"refresh-icon"]],template:function(e,i){1&e&&(h(0,"button",0),D("click",function(){return i.triggerReload()}),G(1,"async"),G(2,"date"),G(3,"async"),G(4,"async"),P(5,"mat-icon",1),g()),2&e&&(Qe("loading",W(1,4,i.isReloading$)),_("title",i.getReloadTitle(Jp(2,6,W(3,9,i.lastLoadedTimeInMs$),"medium")))("disabled",W(4,11,i.reloadDisabled$)))},dependencies:[Fn,Dn,lt,Ih],styles:[".reload-button[_ngcontent-%COMP%], .refresh-icon[_ngcontent-%COMP%] {\n        align-items: center;\n        display: flex;\n        justify-content: center;\n      }\n\n      .reload-button.loading[_ngcontent-%COMP%] {\n        animation: _ngcontent-%COMP%_rotate 2s linear infinite;\n      }\n\n      @keyframes _ngcontent-%COMP%_rotate {\n        0% {\n          transform: rotate(0deg);\n        }\n        50% {\n          transform: rotate(180deg);\n        }\n        100% {\n          transform: rotate(360deg);\n        }\n      }"]}),n})(),TY=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["app-header"]],decls:9,vars:0,consts:[[1,"brand"],[1,"plugins"],["mat-icon-button","","href","https://github.com/tensorflow/tensorboard/blob/master/README.md","rel","noopener noreferrer","target","_blank","aria-label","Help",1,"readme"],["svgIcon","help_outline_24px"]],template:function(e,i){1&e&&(h(0,"mat-toolbar")(1,"span",0),T(2,"TensorBoard"),g(),P(3,"plugin-selector",1)(4,"app-header-dark-mode-toggle")(5,"app-header-reload")(6,"settings-button"),h(7,"a",2),P(8,"mat-icon",3),g()())},dependencies:[U1,Dn,Vq,Zq,rY,SY,EY],styles:["mat-toolbar[_ngcontent-%COMP%]{align-items:center;color:#fff;display:flex;height:64px;overflow:hidden;width:100%}.brand[_ngcontent-%COMP%], .readme[_ngcontent-%COMP%], app-header-reload[_ngcontent-%COMP%], settings-button[_ngcontent-%COMP%]{flex:0 0 auto}.brand[_ngcontent-%COMP%]{letter-spacing:-0.025em;margin-left:10px;text-rendering:optimizeLegibility}.plugins[_ngcontent-%COMP%]{align-items:center;display:flex;flex:1 1 auto;font-size:14px;height:100%;overflow:hidden}"]}),n})(),CCe_setDocumentTitle=function(n){document.title=n},DY=(()=>{class n{ngOnChanges(e){e.title&&CCe_setDocumentTitle(e.title.currentValue)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["page-title-component"]],inputs:{title:"title"},features:[Gt],decls:0,vars:0,template:function(e,i){},encapsulation:2,changeDetection:0}),n})(),IY="TensorBoard",AY=(()=>{class n{constructor(e,i){this.store=e,this.customBrandName=i,this.getExperimentId$=this.store.select(ro).pipe(U(r=>r?.[0])),this.experimentName$=this.getExperimentId$.pipe(Ve(Boolean),hn(r=>this.store.select(GS,{experimentId:r})),U(r=>r?r.name:null)),this.title$=this.store.select(ES).pipe(Vi(this.store.select(Ns),this.experimentName$),U(([r,o,a])=>{let s=this.customBrandName||IY;return r.window_title?r.window_title:o===kn.EXPERIMENT&&a?`${a} - ${s}`:s}),Nn(this.customBrandName||IY),ui())}}return n.\u0275fac=function(e){return new(e||n)(C(ke),C(Y6,8))},n.\u0275cmp=k({type:n,selectors:[["page-title"]],decls:2,vars:3,consts:[[3,"title"]],template:function(e,i){1&e&&(P(0,"page-title-component",0),G(1,"async")),2&e&&_("title",W(1,1,i.title$))},dependencies:[DY,lt],styles:["[_nghost-%COMP%] {\n        display: none;\n      }"],changeDetection:0}),n})(),RY=(()=>{class n{constructor(e){this.store=e,this.ngUnsubscribe=new Ae,this.getPageSize$=this.store.pipe(pn(Sf)),this.paginatedViewStore=document.createElement("tf-paginated-view-store").tf_paginated_view}ngOnInit(){this.getPageSize$.pipe(ot(this.ngUnsubscribe),ui()).subscribe(e=>{this.paginatedViewStore.setLimit(e)})}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}}return n.\u0275fac=function(e){return new(e||n)(C(ke))},n.\u0275cmp=k({type:n,selectors:[["settings-polymer-interop"]],decls:0,vars:0,template:function(e,i){},encapsulation:2,changeDetection:0}),n})(),kY=(()=>{class n{constructor(e){this.vcRef=e}}return n.\u0275fac=function(e){return new(e||n)(C(Zn))},n.\u0275cmp=k({type:n,selectors:[["tb-webapp"]],decls:9,vars:0,template:function(e,i){1&e&&(P(0,"app-header"),h(1,"main"),P(2,"router-outlet"),g(),P(3,"alert-snackbar")(4,"hash-storage")(5,"page-title")(6,"settings-polymer-interop")(7,"dark-mode-supporter")(8,"feature-flag-modal-trigger"))},dependencies:[Dq,Aq,f9,Rq,Pq,TY,AY,RY],styles:["html[_ngcontent-%COMP%], body[_ngcontent-%COMP%]{font-family:Roboto,sans-serif;height:100%;margin:0;padding:0}[_nghost-%COMP%]{background:#f5f5f5;display:flex;flex-direction:column;height:100%}app-header[_ngcontent-%COMP%]{box-shadow:0 1px 3px 3px rgba(0,0,0,.25);flex:0 0;z-index:1}body.dark-mode[_nghost-%COMP%]   app-header[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   app-header[_ngcontent-%COMP%]{box-shadow:0 1px 3px 3px rgba(255,255,255,.1)}main[_ngcontent-%COMP%]{flex-grow:1;overflow:auto}"]}),n})(),PY=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Te,Bh,Nh,wl]}),n})(),OY=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({}),n})(),FY=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({providers:[{provide:vu,useClass:C6}]}),n})(),LY=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Te,FY]}),n})(),NY=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Te]}),n})(),BY={id:Kw,name:"",start_time:0},TCe=_r({experimentMap:{[BY.id]:BY}});function VY(n,t){return cf({data:TCe})(n,t)}var HY=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[wr.forFeature(jS,VY)]}),n})(),zY=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Te,fi,Xs]}),n})(),UY=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Te,zY]}),n})(),jY=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Te,kg,yq,fi,Wu,wg,mi,Qs]}),n})();function DCe(){return q(Ob,n=>({autoReload:n}))}function ICe(){return q(Fb,n=>({autoReloadPeriodInMs:n}))}function ACe(){return q(Sf,n=>({pageSize:n}))}var SE=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[wr.forFeature(S1,zq),er.defineGlobalSetting(DCe),er.defineGlobalSetting(ICe),er.defineGlobalSetting(ACe),jY]}),n})(),GY=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[fi,mi,wE,Hq,Xs,Xu,Te,zs,SE]}),n})(),WY=(()=>{class n{constructor(e,i){let r=e.bypassSecurityTrustResourceUrl("./icon_bundle.svg");i.addSvgIconSet(r)}}return n.\u0275fac=function(e){return new(e||n)(O(nf),O(Fg))},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[mi]}),n})(),EL=new ie("[plugins] Plugin registry config"),qY=new Map,Oc=(()=>{class n{constructor(e){if(!e)return;let i=new Set(e.map(r=>r.pluginName));console.assert(i.size===e.length,"Cannot register the same plugin multiple times.");for(let r of e){let{pluginName:o,componentClass:a}=r;qY.set(o,a)}}static forPlugin(e,i){return{ngModule:n,providers:[{provide:EL,multi:!0,useValue:{pluginName:e,componentClass:i}}]}}getComponent(e){return qY.get(e)||null}}return n.\u0275fac=function(e){return new(e||n)(O(EL,8))},n.\u0275mod=V({type:n}),n.\u0275inj=B({}),n})(),EE=(()=>{class n{constructor(e){this.http=e,this.httpPathPrefix="data/plugin/debugger-v2"}fetchRuns(){return this.http.get(this.httpPathPrefix+"/runs")}fetchExecutionDigests(e,i,r){return this.http.get(this.httpPathPrefix+"/execution/digests",{params:{run:e,begin:String(i),end:String(r)}})}fetchExecutionData(e,i,r){return this.http.get(this.httpPathPrefix+"/execution/data",{params:{run:e,begin:String(i),end:String(r)}})}fetchGraphExecutionDigests(e,i,r,o){if(void 0!==o)throw new Error("trace_id is not implemented for fetchGraphExecutionDigests() yet");return this.http.get(this.httpPathPrefix+"/graph_execution/digests",{params:{run:e,begin:String(i),end:String(r)}})}fetchGraphExecutionData(e,i,r,o){if(void 0!==o)throw new Error("trace_id is not implemented for fetchGraphExecutionData() yet");return this.http.get(this.httpPathPrefix+"/graph_execution/data",{params:{run:e,begin:String(i),end:String(r)}})}fetchGraphOpInfo(e,i,r){return this.http.get(this.httpPathPrefix+"/graphs/op_info",{params:{run:e,graph_id:i,op_name:r}})}fetchSourceFileList(e){return this.http.get(this.httpPathPrefix+"/source_files/list",{params:{run:e}})}fetchSourceFile(e,i){return this.http.get(this.httpPathPrefix+"/source_files/file",{params:{run:e,index:String(i)}})}fetchStackFrames(e,i){return this.http.get(this.httpPathPrefix+"/stack_frames/stack_frames",{params:{run:e,stack_frame_ids:i.join(",")}}).pipe(U(r=>({stack_frames:r.stack_frames.map(o=>function(n){return{host_name:n[0],file_path:n[1],lineno:n[2],function_name:n[3]}}(o))})))}fetchAlerts(e,i,r,o){let a={run:e,begin:String(i),end:String(r)};return void 0!==o&&(a.alert_type=o),this.http.get(this.httpPathPrefix+"/alerts",{params:a})}}return n.\u0275fac=function(e){return new(e||n)(O(vc))},n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})(),YY=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({providers:[EE],imports:[qh]}),n})(),TE=ye("[Debugger] Debugger Loaded"),DE=ye("[Debugger] Debugger Unloaded"),pv=ye("[Debugger] A New Debugger Data Polling Event Begins"),IE=ye("[Debugger] Debugger Runs Requested"),AE=ye("[Debugger] Debugger Runs Loaded",{_as:"props",_p:void 0}),XY=ye("[Debugger] Debugger Runs Request Failed"),fv=ye("[Debugger] Number and Breakdown of Alerts Requested"),RE=ye("[Debugger] Number and Breakdown of Alerts Loaded",{_as:"props",_p:void 0}),kE=ye("[Debugger] Alerts Data of an AlertType Is Loaded",{_as:"props",_p:void 0}),Bg=ye("[Debugger] Alert Type Focus Toggled",{_as:"props",_p:void 0}),PE=ye("[Debugger] Number of Top-Level Executions Requested"),OE=ye("[Debugger] Number of Top-Level Executions Loaded",{_as:"props",_p:void 0}),FE=ye("[Debugger] ExecutionDigests Requested",{_as:"props",_p:void 0}),LE=ye("[Debugger] ExecutionDigests Loaded",{_as:"props",_p:void 0}),Vg=ye("[Debugger] Scroll Leftward on the Execution Timeline"),Hg=ye("[Debugger] Scroll Rightward on the Execution Timeline"),zg=ye("[Debugger] Scroll the Execution Timeline to Given Index",{_as:"props",_p:void 0}),Ug=ye("[Debugger] Execution Data Objects Being Focused On",{_as:"props",_p:void 0}),NE=ye("[Debugger] Execution Data Objects Loaded",{_as:"props",_p:void 0}),BE=ye("[Debugger] Number of Intra-Graph Executions Requested"),VE=ye("[Debugger] Number of Intra-Graph Executions Loaded",{_as:"props",_p:void 0}),HE=ye("[Debugger] Intra-Graph Execution Data Requested",{_as:"props",_p:void 0}),zE=ye("[Debugger] Intra-Graph Execution Data Loaded",{_as:"props",_p:void 0}),jg=ye("[Debugger] Scroll Intra-Graph Execution List to Given Index",{_as:"props",_p:void 0}),Gg=ye("[Debugger] Graph Execution is Focused On",{_as:"props",_p:void 0}),Wg=ye("[Debugger] Graph Op Is Focused On",{_as:"props",_p:void 0}),UE=ye("[Debugger] Graph Op Info Requested",{_as:"props",_p:void 0}),jE=ye("[Debugger] Graph Op Info Loaded",{_as:"props",_p:void 0}),GE=ye("[Debugger] Source File List Requested."),WE=ye("[Debugger] Source File List Loaded",{_as:"props",_p:void 0}),qg=ye("[Debugger] Source File Line Is Focused on",{_as:"props",_p:void 0}),qE=ye("[Debugger] Source File Requested",{_as:"props",_p:void 0}),YE=ye("[Debugger] Source File Loaded",{_as:"props",_p:void 0}),mv=ye("[Debugger] A Set of Stack Frames Have Been Loaded",{_as:"props",_p:void 0}),hv="debugger",Eo=(()=>(function(n){n[n.UNSPECIFIED=0]="UNSPECIFIED",n[n.NO_TENSOR=1]="NO_TENSOR",n[n.CURT_HEALTH=2]="CURT_HEALTH",n[n.CONCISE_HEALTH=3]="CONCISE_HEALTH",n[n.FULL_HEALTH=4]="FULL_HEALTH",n[n.SHAPE=5]="SHAPE",n[n.FULL_NUMERICS=6]="FULL_NUMERICS",n[n.FULL_TENSOR=7]="FULL_TENSOR",n[n.REDUCE_INF_NAN_THREE_SLOTS=8]="REDUCE_INF_NAN_THREE_SLOTS"}(Eo||(Eo={})),Eo))(),Fc=(()=>(function(n){n.FUNCTION_RECOMPILE_ALERT="FunctionRecompilesAlert",n.INF_NAN_ALERT="InfNanAlert",n.TENSOR_SHAPE_ALERT="TensorShapeAlert"}(Fc||(Fc={})),Fc))(),Bo=(()=>(function(n){n[n.EXECUTION=0]="EXECUTION",n[n.GRAPH_OP_CREATION=1]="GRAPH_OP_CREATION"}(Bo||(Bo={})),Bo))();function Yg(n){if(null===n.codeLocationFocusType)return null;let t=[];if(n.codeLocationFocusType===Bo.EXECUTION){let{focusIndex:i,executionData:r}=n.executions;if(null===i||void 0===r[i])return null;t=r[i].stack_frame_ids}else{if(null===n.graphs.focusedOp)return null;let{graphId:i,opName:r}=n.graphs.focusedOp;if(void 0===n.graphs.ops[i]||!n.graphs.ops[i].has(r))return null;t=n.graphs.ops[i].get(r).stack_frame_ids}let e=[];for(let i of t){if(null==n.stackFrames[i])return null;e.push(n.stackFrames[i])}return e}function gv(n,t){return n.findIndex(e=>e.host_name===t.host_name&&e.file_path===t.file_path)}function DL(n,t,e){if(t>=e)throw new Error(`Expected begin to be less than end, but got begin=${t}, end=${e}`);return n.findIndex(i=>i.begin===t&&i.end===e)}function XE(n){let t=n.sourceCode.focusLineSpec;if(!n.stickToBottommostFrameInFocusedFile)return t;let e=Yg(n);if(null===e)return t;let i=function(n,t){if(null===t)return null;for(let e=n.length-1;e>=0;--e){let i=n[e],{host_name:r,file_path:o}=i;if(r===t.host_name&&o===t.file_path)return i}return null}(e,t);return null===i?t:i}var UCe=_r({runs:{},runsLoaded:{state:De.NOT_LOADED,lastLoadedTimeInMs:null},activeRunId:null,lastDataPollOnsetTimeMs:-1,lastNonEmptyPollDataTimeMs:1,alerts:{alertsLoaded:{state:De.NOT_LOADED,lastLoadedTimeInMs:null},numAlerts:0,alertsBreakdown:{},alerts:{},executionIndices:{},graphExecutionIndices:{},focusType:null},executions:{numExecutionsLoaded:{state:De.NOT_LOADED,lastLoadedTimeInMs:null},executionDigestsLoaded:{loadingRanges:[],numExecutions:0,pageLoadedSizes:{}},displayCount:50,pageSize:100,scrollBeginIndex:0,focusIndex:null,executionDigests:{},executionData:{}},graphExecutions:{numExecutionsLoaded:{state:De.NOT_LOADED,lastLoadedTimeInMs:null},executionDigestsLoaded:{loadingRanges:[],numExecutions:0,pageLoadedSizes:{}},displayCount:100,pageSize:200,scrollBeginIndex:0,focusIndex:null,graphExecutionDigests:{},graphExecutionDataLoadingPages:[],graphExecutionDataPageLoadedSizes:{},graphExecutionData:{}},graphs:{ops:{},loadingOps:{},focusedOp:null},stackFrames:{},codeLocationFocusType:null,stickToBottommostFrameInFocusedFile:!1,sourceCode:{sourceFileListLoaded:{state:De.NOT_LOADED,lastLoadedTimeInMs:null},sourceFileList:[],fileContents:[],focusLineSpec:null}},Ee(IE,n=>({...n,runsLoaded:{...n.runsLoaded,state:De.LOADING}})),Ee(XY,n=>({...n,runsLoaded:{...n.runsLoaded,state:De.FAILED}})),Ee(AE,(n,{runs:t})=>{let e=Object.keys(t),i=e.length>0&&null===n.activeRunId;return{...n,lastNonEmptyPollDataTimeMs:i?Date.now():n.lastNonEmptyPollDataTimeMs,runs:t,runsLoaded:{state:De.LOADED,lastLoadedTimeInMs:Date.now()},activeRunId:e.length>0?e[0]:null}}),Ee(pv,n=>({...n,lastDataPollOnsetTimeMs:Date.now()})),Ee(fv,n=>null===n.activeRunId?n:{...n,alerts:{...n.alerts,alertsLoaded:{...n.alerts.alertsLoaded,state:De.LOADING}}}),Ee(RE,(n,{numAlerts:t,alertsBreakdown:e})=>{if(null===n.activeRunId)return n;let r=t>n.alerts.numAlerts;return{...n,lastNonEmptyPollDataTimeMs:r?Date.now():n.lastNonEmptyPollDataTimeMs,alerts:{...n.alerts,alertsLoaded:{...n.alerts.alertsLoaded,state:De.LOADED,lastLoadedTimeInMs:Date.now()},numAlerts:t,alertsBreakdown:e}}}),Ee(kE,(n,{numAlerts:t,alertsBreakdown:e,alertType:i,begin:r,alerts:o})=>{if(null===n.activeRunId)return n;let s={},l=n.alerts.executionIndices[i]?n.alerts.executionIndices[i].slice():[],c=n.alerts.graphExecutionIndices[i]?n.alerts.graphExecutionIndices[i].slice():[];for(let p=0;p<o.length;++p){let f=r+p,m=o[p];if(s[f]=m,m.alert_type===Fc.INF_NAN_ALERT){let y=m;l[f]=y.execution_index,null!==y.graph_execution_trace_index&&(c[f]=y.graph_execution_trace_index)}}void 0!==n.alerts.alerts[i]&&Object.assign(s,n.alerts.alerts[i]);let d=n.executions.scrollBeginIndex,u=n.graphExecutions.focusIndex;if(i===Fc.INF_NAN_ALERT&&0===r){let p=o[0];d=Math.max(0,p.execution_index-Math.floor(n.executions.displayCount/2)),null!==p.graph_execution_trace_index&&(u=p.graph_execution_trace_index)}return{...n,executions:{...n.executions,scrollBeginIndex:d},graphExecutions:{...n.graphExecutions,focusIndex:u},alerts:{...n.alerts,alertsLoaded:{...n.alerts.alertsLoaded,state:De.LOADED,lastLoadedTimeInMs:Date.now()},numAlerts:t,alertsBreakdown:e,alerts:{...n.alerts.alerts,[i]:s},executionIndices:{...n.alerts.executionIndices,[i]:l},graphExecutionIndices:{...n.alerts.graphExecutionIndices,[i]:c}}}}),Ee(Bg,(n,{alertType:t})=>{let e={...n,alerts:{...n.alerts,focusType:n.alerts.focusType===t?null:t}},i=e.alerts.focusType;if(null!==i){let r=e.alerts.executionIndices[i]||[];void 0!==r[0]&&(e.executions={...e.executions,scrollBeginIndex:Math.max(0,Number(r[0])-Math.floor(e.executions.displayCount/2))})}return e}),Ee(PE,n=>null===n.activeRunId?n:{...n,executions:{...n.executions,numExecutionsLoaded:{...n.executions.numExecutionsLoaded,state:De.LOADING}}}),Ee(OE,(n,{numExecutions:t})=>{if(null===n.activeRunId)return n;let i=t>n.executions.executionDigestsLoaded.numExecutions,r={...n,lastNonEmptyPollDataTimeMs:i?Date.now():n.lastNonEmptyPollDataTimeMs,executions:{...n.executions,numExecutionsLoaded:{...n.executions.numExecutionsLoaded,state:De.LOADED,lastLoadedTimeInMs:Date.now()},executionDigestsLoaded:{...n.executions.executionDigestsLoaded,numExecutions:t}}};return t>0&&null===n.executions.focusIndex&&(r.executions.focusIndex=0),r}),Ee(FE,(n,t)=>{if(null===n.activeRunId)return n;let i=[...n.executions.executionDigestsLoaded.loadingRanges];return-1===DL(i,t.begin,t.end)&&i.push({begin:t.begin,end:t.end}),{...n,executions:{...n.executions,executionDigestsLoaded:{...n.executions.executionDigestsLoaded,loadingRanges:i}}}}),Ee(LE,(n,t)=>{if(null===n.activeRunId)return n;let i=[...n.executions.executionDigestsLoaded.loadingRanges],r=DL(i,t.begin,t.end);-1!==r&&i.splice(r,1);let o={...n,executions:{...n.executions,executionDigestsLoaded:{...n.executions.executionDigestsLoaded,numExecutions:t.num_digests,loadingRanges:i},executionDigests:{...n.executions.executionDigests}}};for(let a=t.begin;a<t.end;++a)o.executions.executionDigests[a]=t.execution_digests[a-t.begin];return t.end>t.begin&&(o.executions.executionDigestsLoaded.pageLoadedSizes={...o.executions.executionDigestsLoaded.pageLoadedSizes,[t.begin/n.executions.pageSize]:t.end-t.begin}),o}),Ee(Vg,n=>{if(null===n.activeRunId)return n;let e=n.executions.scrollBeginIndex;return e>0&&e--,{...n,executions:{...n.executions,scrollBeginIndex:e}}}),Ee(Hg,n=>{if(null===n.activeRunId)return n;let e=n.executions.scrollBeginIndex;return e+n.executions.displayCount+1<=n.executions.executionDigestsLoaded.numExecutions&&e++,{...n,executions:{...n.executions,scrollBeginIndex:e}}}),Ee(zg,(n,t)=>{if(t.index<0||!Number.isInteger(t.index))throw new Error(`Attempt to scroll to negative or non-integer execution index (${t.index})`);let{displayCount:e}=n.executions,{numExecutions:i}=n.executions.executionDigestsLoaded;if(t.index>Math.max(0,i-e))throw new Error(`Attempt to scroll to execution index (${t.index}), which exceeds maximum allowed index (numExecutions=${i}; displayCount=${e})`);return{...n,executions:{...n.executions,scrollBeginIndex:t.index}}}),Ee(Ug,(n,t)=>{let e={...n,executions:{...n.executions,focusIndex:n.executions.scrollBeginIndex+t.displayIndex},codeLocationFocusType:Bo.EXECUTION,sourceCode:{...n.sourceCode}};return e.sourceCode.focusLineSpec=XE(e),e}),Ee(NE,(n,t)=>{if(null===n.activeRunId)return n;let i={...n,executions:{...n.executions,executionData:{...n.executions.executionData}}};for(let r=t.begin;r<t.end;++r)i.executions.executionData[r]=t.executions[r-t.begin];return i}),Ee(BE,n=>null===n.activeRunId?n:{...n,graphExecutions:{...n.graphExecutions,numExecutionsLoaded:{...n.graphExecutions.numExecutionsLoaded,state:De.LOADING}}}),Ee(VE,(n,{numGraphExecutions:t})=>{if(null===n.activeRunId)return n;let e=t>n.graphExecutions.executionDigestsLoaded.numExecutions,i={...n,lastNonEmptyPollDataTimeMs:e?Date.now():n.lastNonEmptyPollDataTimeMs,graphExecutions:{...n.graphExecutions,numExecutionsLoaded:{...n.graphExecutions.numExecutionsLoaded,state:De.LOADED,lastLoadedTimeInMs:Date.now()},executionDigestsLoaded:{...n.graphExecutions.executionDigestsLoaded,numExecutions:t}}};return t>0&&null===n.graphExecutions.focusIndex&&(i.graphExecutions.focusIndex=0),i}),Ee(HE,(n,{pageIndex:t})=>{if(null===n.activeRunId)return n;let e=n.graphExecutions.graphExecutionDataLoadingPages.slice();return-1===e.indexOf(t)&&e.push(t),{...n,graphExecutions:{...n.graphExecutions,graphExecutionDataLoadingPages:e}}}),Ee(zE,(n,t)=>{if(null===n.activeRunId)return n;let{pageSize:e}=n.graphExecutions,i=n.graphExecutions.graphExecutionDataLoadingPages.slice(),r={...n.graphExecutions.graphExecutionDataPageLoadedSizes},o={...n.graphExecutions.graphExecutionData};for(let a=t.begin;a<t.end;++a){let s=Math.floor(a/e);-1!==i.indexOf(s)&&i.splice(i.indexOf(s),1),void 0===r[s]&&(r[s]=0),void 0===o[a]&&r[s]++,o[a]=t.graph_executions[a-t.begin]}return{...n,graphExecutions:{...n.graphExecutions,graphExecutionDataLoadingPages:i,graphExecutionDataPageLoadedSizes:r,graphExecutionData:o}}}),Ee(jg,(n,t)=>{if(t.index<0||!Number.isInteger(t.index))throw new Error(`Attempt to scroll to negative or non-integer graph-execution index (${t.index})`);return{...n,graphExecutions:{...n.graphExecutions,scrollBeginIndex:t.index}}}),Ee(Gg,(n,t)=>KY(n,t.graph_id,t.op_name,t.index)),Ee(Wg,(n,t)=>KY(n,t.graph_id,t.op_name)),Ee(UE,(n,t)=>{let{graph_id:e,op_name:i}=t,r={...n,graphs:{...n.graphs,loadingOps:{...n.graphs.loadingOps}}};return void 0===r.graphs.loadingOps[e]&&(r.graphs.loadingOps[e]=new Map),r.graphs.loadingOps[e].has(i)||r.graphs.loadingOps[e].set(i,De.LOADING),r}),Ee(jE,(n,t)=>{let{graphOpInfoResponse:e}=t,{graph_ids:i}=e,r=i[i.length-1],o={...n,graphs:{...n.graphs,ops:{...n.graphs.ops,[r]:new Map(n.graphs.ops[r])},loadingOps:{...n.graphs.loadingOps,[r]:new Map(n.graphs.loadingOps[r])}}};for(let a of e.inputs)!a.data||o.graphs.ops[r].set(a.op_name,a.data);for(let a=0;a<e.consumers.length;++a)for(let s of e.consumers[a])!s.data||o.graphs.ops[r].set(s.op_name,s.data);return o.graphs.ops[r].set(e.op_name,{...e,inputs:e.inputs.map(a=>({op_name:a.op_name,output_slot:a.output_slot})),consumers:e.consumers.map(a=>a.map(s=>({op_name:s.op_name,input_slot:s.input_slot})))}),o.graphs.loadingOps[r].set(e.op_name,De.LOADED),o}),Ee(GE,n=>({...n,sourceCode:{...n.sourceCode,sourceFileListLoaded:{...n.sourceCode.sourceFileListLoaded,state:De.LOADING}}})),Ee(WE,(n,t)=>{let e={...n,sourceCode:{...n.sourceCode,sourceFileListLoaded:{...n.sourceCode.sourceFileListLoaded,state:De.LOADED,lastLoadedTimeInMs:Date.now()},sourceFileList:t.sourceFiles,fileContents:n.sourceCode.fileContents.slice()}},i=t.sourceFiles.length,{fileContents:r}=e.sourceCode;for(let o=0;o<i;++o)r[o]=n.sourceCode.fileContents[o]??{loadState:De.NOT_LOADED,lines:null};return e}),Ee(qg,(n,t)=>{let e=Yg(n),i={...n,sourceCode:{...n.sourceCode,focusLineSpec:t.stackFrame}};return null!==e&&(i.stickToBottommostFrameInFocusedFile=function(n,t){let e=-1,i=-1;if(n.forEach(({file_path:r,lineno:o},a)=>{r===t.file_path&&(i=a,o===t.lineno&&(e=a))}),-1===e)throw new Error(`Stack frame ${JSON.stringify(t)} is not found.`);return e===i}(e,t.stackFrame)),i}),Ee(qE,(n,t)=>{let e={...n,sourceCode:{...n.sourceCode,fileContents:n.sourceCode.fileContents.slice()}},i=gv(e.sourceCode.sourceFileList,t);if(!(i>=0))throw new Error(`Cannot find the following file in file list: host_name="${t.host_name}", file_path="${t.file_path}"`);return e.sourceCode.fileContents.splice(i,1,{...e.sourceCode.fileContents[i],loadState:De.LOADING}),e}),Ee(YE,(n,t)=>{let e={...n,sourceCode:{...n.sourceCode,fileContents:n.sourceCode.fileContents.slice()}},i=gv(e.sourceCode.sourceFileList,t);if(!(i>=0))throw new Error(`Cannot find the following file in file list: host_name="${t.host_name}", file_path="${t.file_path}"`);return e.sourceCode.fileContents.splice(i,1,{loadState:De.LOADED,lines:t.lines}),e}),Ee(mv,(n,t)=>{if(null===n.activeRunId)return n;let i={...n,stackFrames:{...n.stackFrames,...t.stackFrames},sourceCode:{...n.sourceCode}};return i.sourceCode.focusLineSpec=XE(i),i}));function KY(n,t,e,i){let r={...n,graphs:{...n.graphs,focusedOp:{graphId:t,opName:e}},codeLocationFocusType:Bo.GRAPH_OP_CREATION,sourceCode:{...n.sourceCode}};return r.sourceCode.focusLineSpec=XE(r),void 0!==i&&(r.graphExecutions={...n.graphExecutions,focusIndex:i}),r}function JY(n,t){return UCe(n,t)}var To=Mr(hv),jf=q(To,n=>n.runs),IL=q(To,n=>n.runsLoaded),ea=q(To,n=>n.activeRunId),$Y=q(To,n=>n.lastDataPollOnsetTimeMs-n.lastNonEmptyPollDataTimeMs),Xg=q(To,n=>n.alerts),AL=q(Xg,n=>n.alertsLoaded),eX=q(Xg,n=>n.numAlerts),QE=q(Xg,n=>n.focusType),tX=q(Xg,n=>null===n.focusType?0:n.alertsBreakdown[n.focusType]||0),nX=q(Xg,n=>null===n.focusType||void 0===n.alerts[n.focusType]?null:n.alerts[n.focusType]),iX=q(Xg,n=>n.alertsBreakdown),Gf=q(To,n=>n.executions),ZE=q(Gf,n=>n.numExecutionsLoaded),_v=q(Gf,n=>n.executionDigestsLoaded),Qu=q(Gf,n=>n.executionDigestsLoaded.numExecutions),yv=q(Gf,n=>n.scrollBeginIndex),Qg=q(Gf,n=>n.pageSize),Zg=q(Gf,n=>n.displayCount),rX=q(Gf,n=>{let t=[];for(let e=n.scrollBeginIndex;e<n.scrollBeginIndex+n.displayCount;++e)t.push(e in n.executionDigests?n.executionDigests[e]:null);return t}),Zu=q(To,n=>n.graphExecutions),oX=q(Zu,n=>n.numExecutionsLoaded),bv=q(To,n=>n.graphExecutions.executionDigestsLoaded.numExecutions),aX=q(Zu,n=>n.scrollBeginIndex),sX=q(Zu,n=>n.displayCount),lX=q(Zu,n=>n.pageSize),cX=q(Zu,n=>n.graphExecutionDataLoadingPages),dX=q(Zu,n=>n.graphExecutionDataPageLoadedSizes),RL=q(Zu,n=>n.graphExecutionData),kL=q(Zu,n=>n.focusIndex),PL=q(To,n=>n.graphs),OL=q(PL,n=>{let{focusedOp:t,ops:e}=n;return null===t||void 0===e[t.graphId]?null:e[t.graphId].get(t.opName)||null}),FL=q(PL,n=>{let{focusedOp:t,ops:e}=n;if(null===t||void 0===e[t.graphId]||!e[t.graphId].has(t.opName))return null;{let i=e[t.graphId],{inputs:r}=i.get(t.opName);return r.map(o=>{let a={...o};return i.has(o.op_name)&&(a.data=i.get(o.op_name)),a})}}),uX=q(kL,RL,FL,(n,t,e)=>{if(null===n||null===e)return null;let i=e.map(s=>!1),r=[];if(0===e.length)return r;let o=t[n].graph_id,a=Math.max(0,n-200);for(let s=n-1;s>=a;--s)if(void 0!==t[s])for(let l=0;l<e.length&&(i[l]||t[s].graph_id!==o||t[s].op_name!==e[l].op_name||t[s].output_slot!==e[l].output_slot||(r.push(s),i[l]=!0,r.length!==e.length));++l);return r}),pX=q(PL,n=>{let{focusedOp:t,ops:e}=n;if(null===t||void 0===e[t.graphId]||!e[t.graphId].has(t.opName))return null;{let i=e[t.graphId],{consumers:r}=i.get(t.opName);return r.map(o=>o.map(a=>{let s={...a};return i.has(a.op_name)&&(s.data=i.get(a.op_name)),s}))}}),fX=q(To,n=>{let t=n.executions.scrollBeginIndex,e=n.executions.scrollBeginIndex+n.executions.displayCount,i=new Array(e-t).fill(null),r=n.alerts.focusType;if(null===r)return i;let o=n.alerts.executionIndices[r];if(void 0===o)return i;for(let a=t;a<e;++a)o.includes(a)&&(i[a-t]=n.alerts.focusType);return i}),KE=q(To,n=>n.executions),LL=q(KE,n=>n.focusIndex),mX=q(KE,n=>{if(null===n.focusIndex)return null;let{focusIndex:t,scrollBeginIndex:e,displayCount:i}=n;return t<e||t>=e+i?null:t-e}),NL=q(KE,n=>n.executionData),hX=q(To,n=>n.graphs.loadingOps),BL=q(To,n=>n.stackFrames),Wf=q(KE,n=>{let{focusIndex:t,executionData:e}=n;return null===t||void 0===e[t]?null:e[t]}),vv=q(To,LL,Wf,OL,(n,t,e,i)=>{let{codeLocationFocusType:r}=n;return null===r?null:r===Bo.EXECUTION?null===t||null===e?null:{codeLocationType:Bo.EXECUTION,opType:e.op_type,executionIndex:t}:null===i?null:{codeLocationType:Bo.GRAPH_OP_CREATION,opType:i.op_type,opName:i.op_name}}),gX=q(To,Yg),JE=q(To,n=>n.sourceCode),_X=q(JE,n=>n.sourceFileListLoaded),VL=(q(JE,n=>n.sourceFileList),q(JE,n=>{let{sourceFileList:t,focusLineSpec:e}=n;return null===e?-1:gv(t,e)})),$E=q(JE,VL,(n,t)=>-1===t?null:n.fileContents[t]||null),eT=q(To,n=>n.sourceCode.focusLineSpec),yX=q(To,n=>n.stickToBottommostFrameInFocusedFile),bX=function(n){return[n]};function GCe(n,t){if(1&n){let e=ge();h(0,"div",7),D("click",function(){let o=X(e).$implicit;return Q(w().onToggleFocusType.emit(o.type))}),h(1,"div",8),T(2),g(),h(3,"div",9),T(4),g(),P(5,"div"),g()}if(2&n){let e=t.$implicit,i=w();_("ngClass",Sn(4,bX,e.type===i.focusType?"focus":"")),b(2),ut(e.displayName),b(2),du(" ",e.displaySymbol,": ",e.count," ")}}var vX=(()=>{class n{constructor(){this.numAlerts=0,this.alertsBreakdown=[],this.focusType=null,this.onToggleFocusType=new L}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["alerts-component"]],inputs:{numAlerts:"numAlerts",alertsBreakdown:"alertsBreakdown",focusType:"focusType"},outputs:{onToggleFocusType:"onToggleFocusType"},decls:10,vars:5,consts:[[1,"alerts-container"],[1,"debugging-title"],[1,"num-alerts-container"],[1,"num-alerts-label"],[1,"num-alerts-value",3,"ngClass"],[1,"alerts-breakdown-container"],["class","alerts-breakdown-type",3,"ngClass","click",4,"ngFor","ngForOf"],[1,"alerts-breakdown-type",3,"ngClass","click"],[1,"alert-type-name"],[1,"alert-type-count"]],template:function(e,i){1&e&&(h(0,"div",0)(1,"div",1),T(2,"Debugging"),g(),h(3,"div",2)(4,"div",3),T(5,"Alerts"),g(),h(6,"div",4),T(7),g()(),h(8,"div",5),S(9,GCe,6,6,"div",6),g()()),2&e&&(b(6),_("ngClass",Sn(3,bX,i.numAlerts>0?"non-zero":"")),b(1),ze(" ",i.numAlerts," "),b(2),_("ngForOf",i.alertsBreakdown))},dependencies:[bn,dn],styles:[".alerts-breakdown-container[_ngcontent-%COMP%] {\n  font-size: 13px;\n  padding: 10px 10px 10px;\n  position: relative;\n}\n\n.alerts-breakdown-type[_ngcontent-%COMP%] {\n  border-radius: 0 10px 10px 0;\n  cursor: pointer;\n  display: flex;\n  padding: 6px 0 6px 50px;\n  vertical-align: middle;\n}\n\n.alerts-breakdown-type.focus[_ngcontent-%COMP%] {\n  background-color: #ffeee0;\n}\n\n.alerts-container[_ngcontent-%COMP%] {\n  font-family: 'Roboto', Arial, Helvetica, sans-serif;\n}\n\n.alert-type-count[_ngcontent-%COMP%] {\n  \n  background-color: #e52592;\n  border-radius: 3px;\n  color: #fff;\n  display: inline-block;\n  padding: 3px;\n  position: absolute;\n  right: 20px;\n  vertical-align: middle;\n}\n\n.alert-type-name[_ngcontent-%COMP%] {\n  display: inline-block;\n  padding: 3px;\n  vertical-align: middle;\n}\n\n.debugging-title[_ngcontent-%COMP%] {\n  font-size: 18px;\n}\n\n.num-alerts-container[_ngcontent-%COMP%] {\n  font-weight: bold;\n  padding: 10px 10px 10px 30px;\n  position: relative;\n}\n\n.num-alerts-label[_ngcontent-%COMP%] {\n  display: inline-block;\n  font-size: 13px;\n}\n\n.num-alerts-value[_ngcontent-%COMP%] {\n  border-radius: 12px;\n  display: inline-block;\n  font-size: 13px;\n  font-weight: normal;\n  line-height: 24px;\n  position: absolute;\n  right: 20px;\n  text-align: center;\n  vertical-align: middle;\n  width: 24px;\n}\n\n.num-alerts-value.non-zero[_ngcontent-%COMP%] {\n  background-color: #ffb780;\n  font-weight: bold;\n}"]}),n})(),qCe={[Fc.FUNCTION_RECOMPILE_ALERT]:{displayName:"Function recompiles",displaySymbol:"C"},[Fc.INF_NAN_ALERT]:{displayName:"NaN/\u221e",displaySymbol:"\u221e"},[Fc.TENSOR_SHAPE_ALERT]:{displayName:"Tensor shape",displaySymbol:"\u25a0"}},xX=(()=>{class n{constructor(e){this.store=e,this.numAlerts$=this.store.pipe(pn(eX)),this.alertsBreakdown$=this.store.pipe(pn(q(iX,i=>{let r=Object.keys(i);return r.sort(),r.map(o=>({type:o,...qCe[o],count:i[o]}))}))),this.focusType$=this.store.pipe(pn(QE))}onToggleFocusType(e){this.store.dispatch(Bg({alertType:e}))}}return n.\u0275fac=function(e){return new(e||n)(C(ke))},n.\u0275cmp=k({type:n,selectors:[["tf-debugger-v2-alerts"]],decls:4,vars:9,consts:[[3,"numAlerts","alertsBreakdown","focusType","onToggleFocusType"]],template:function(e,i){1&e&&(h(0,"alerts-component",0),D("onToggleFocusType",function(o){return i.onToggleFocusType(o)}),G(1,"async"),G(2,"async"),G(3,"async"),g()),2&e&&_("numAlerts",W(1,3,i.numAlerts$))("alertsBreakdown",W(2,5,i.alertsBreakdown$))("focusType",W(3,7,i.focusType$))},dependencies:[vX,lt],encapsulation:2,changeDetection:0}),n})(),xv={19:"float16",1:"float32",2:"float64",3:"int32",4:"uint8",17:"uint16",22:"uint32",23:"uint64",5:"int16",6:"int8",7:"string",8:"complex64",18:"complex128",9:"int64",10:"bool",11:"qint8",12:"quint8",15:"qint16",16:"quint16",13:"qint32",14:"bfloat16",20:"resource",21:"variant",119:"float16_ref",101:"float32_ref",102:"float64_ref",103:"int32_ref",122:"uint32_ref",104:"uint8_ref",117:"uint16_ref",105:"int16_ref",106:"int8_ref",107:"string_ref",108:"complex64_ref",118:"complex128_ref",109:"int64_ref",123:"uint64_ref",110:"bool_ref",111:"qint8_ref",112:"quint8_ref",115:"qint16_ref",116:"quint16_ref",113:"qint32_ref",114:"bfloat16_ref",120:"resource_ref",121:"variant_ref"};function tT(n){let{tensorDebugMode:t,array:e}=n;switch(t){case Eo.NO_TENSOR:if(null!==e)throw new Error("Unexpectedly received non-null debug-tensor-value array under NO_TENSOR mode");return{};case Eo.CURT_HEALTH:if(null===e||2!==e.length)throw new Error(`Under CURT_HEALTH mode, expected debug-tensor-value array to have length 2, but got ${JSON.stringify(e)}`);return{hasInfOrNaN:Boolean(e[1])};case Eo.CONCISE_HEALTH:{if(null===e||5!==e.length)throw new Error(`Under CONCISE_HEALTH mode, expected debug-tensor-value array to have length 5, but got ${JSON.stringify(e)}`);let i={size:e[1]};return e[2]>0&&(i.numNegativeInfs=e[2]),e[3]>0&&(i.numPositiveInfs=e[3]),e[4]>0&&(i.numNaNs=e[4]),i}case Eo.SHAPE:{if(null===e||10!==e.length)throw new Error(`Under SHAPE mode, expected debug-tensor-value array to have length 10, but got ${JSON.stringify(e)}`);let i=e[2],r=e.slice(4,Math.min(4+i,e.length));return r.length<i&&(r=new Array(i-r.length).concat(r)),{dtype:xv[e[1]],rank:i,size:e[3],shape:r}}case Eo.FULL_HEALTH:{if(null===e||11!==e.length)throw new Error(`Under FULL_HEALTH mode, expected debug-tensor-value array to have length 11, but got ${JSON.stringify(e)}`);let r={dtype:xv[e[2]],rank:e[3],size:e[4]};return e[5]>0&&(r.numNegativeInfs=e[5]),e[6]>0&&(r.numPositiveInfs=e[6]),e[7]>0&&(r.numNaNs=e[7]),e[8]>0&&(r.numNegativeFinites=e[8]),e[9]>0&&(r.numZeros=e[9]),e[10]>0&&(r.numPositiveFinites=e[10]),r}case Eo.FULL_TENSOR:if(null!==e)throw new Error("Unexpectedly received non-null debug-tensor-value array under FULL_TENSOR mode");return{};default:throw new Error(`Unrecognized tensorDebugMode: ${t}`)}}var HL="[_nghost-%COMP%] {\n    background-color: #e3e5e8;\n    border: 1px solid #c0c0c0;\n    border-radius: 4px;\n    font-family: 'Roboto Mono', monospace;\n    height: 14px;\n    line-height: 14px;\n    margin: 0 2px;\n    padding: 1px 3px;\n    width: max-content;\n  }";function XCe(n,t){1&n&&P(0,"div",4)}function QCe(n,t){if(1&n&&(h(0,"div",7)(1,"span",8),T(2,"NaN"),g(),h(3,"span",9),T(4),g()()),2&n){let e=w(2);b(4),ze("\xd7",e.numNaNs,"")}}function ZCe(n,t){if(1&n&&(h(0,"div",7)(1,"span",8),T(2,"-\u221e"),g(),h(3,"span",9),T(4),g()()),2&n){let e=w(2);b(4),ze("\xd7",e.numNegativeInfs,"")}}function KCe(n,t){if(1&n&&(h(0,"div",7)(1,"span",8),T(2,"+\u221e"),g(),h(3,"span",9),T(4),g()()),2&n){let e=w(2);b(4),ze("\xd7",e.numPositiveInfs,"")}}function JCe(n,t){if(1&n&&(h(0,"div",7)(1,"span",10),T(2,"-"),g(),h(3,"span",9),T(4),g()()),2&n){let e=w(2);b(4),ze("\xd7",e.numNegativeFinites,"")}}function $Ce(n,t){if(1&n&&(h(0,"div",7)(1,"span",10),T(2,"0"),g(),h(3,"span",9),T(4),g()()),2&n){let e=w(2);b(4),ze("\xd7",e.numZeros,"")}}function eMe(n,t){if(1&n&&(h(0,"div",7)(1,"span",10),T(2,"+"),g(),h(3,"span",9),T(4),g()()),2&n){let e=w(2);b(4),ze("\xd7",e.numPositiveFinites,"")}}function tMe(n,t){if(1&n&&(h(0,"div",5),S(1,QCe,5,1,"div",6),S(2,ZCe,5,1,"div",6),S(3,KCe,5,1,"div",6),S(4,JCe,5,1,"div",6),S(5,$Ce,5,1,"div",6),S(6,eMe,5,1,"div",6),g()),2&n){let e=w();b(1),_("ngIf",void 0!==e.numNaNs&&e.numNaNs>0),b(1),_("ngIf",void 0!==e.numNegativeInfs&&e.numNegativeInfs>0),b(1),_("ngIf",void 0!==e.numPositiveInfs&&e.numPositiveInfs>0),b(1),_("ngIf",void 0!==e.numNegativeFinites&&e.numNegativeFinites>0),b(1),_("ngIf",void 0!==e.numZeros&&e.numZeros>0),b(1),_("ngIf",void 0!==e.numPositiveFinites&&e.numPositiveFinites>0)}}var nMe=function(n){return["container",n]};function iMe(n,t){1&n&&P(0,"debug-tensor-dtype",5),2&n&&_("dtype",w().debugTensorValue.dtype)}function rMe(n,t){1&n&&P(0,"debug-tensor-rank",6),2&n&&_("rank",w().debugTensorValue.rank)}function oMe(n,t){1&n&&P(0,"debug-tensor-shape",7),2&n&&_("shape",w().debugTensorValue.shape)}function aMe(n,t){1&n&&P(0,"debug-tensor-has-inf-or-nan",8),2&n&&_("hasInfOrNaN",w().debugTensorValue.hasInfOrNaN)}function sMe(n,t){if(1&n&&P(0,"debug-tensor-numeric-breakdown",9),2&n){let e=w();Ji("size",e.debugTensorValue.size),_("numNegativeInfs",e.debugTensorValue.numNegativeInfs)("numPositiveInfs",e.debugTensorValue.numPositiveInfs)("numNaNs",e.debugTensorValue.numNaNs)("numNegativeFinites",e.debugTensorValue.numNegativeFinites)("numZeros",e.debugTensorValue.numZeros)("numPositiveFinites",e.debugTensorValue.numPositiveFinites)}}var lMe=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["debug-tensor-dtype"]],inputs:{dtype:"dtype"},decls:1,vars:1,template:function(e,i){1&e&&T(0),2&e&&ze(" ",i.dtype," ")},styles:[HL]}),n})(),cMe=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["debug-tensor-rank"]],inputs:{rank:"rank"},decls:1,vars:1,template:function(e,i){1&e&&T(0),2&e&&ze(" ",i.rank,"D ")},styles:[HL]}),n})(),dMe=(()=>{class n{get shapeString(){return"["+this.shape.map(e=>void 0===e?"?":String(e)).join(",")+"]"}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["debug-tensor-shape"]],inputs:{shape:"shape"},decls:1,vars:1,template:function(e,i){1&e&&T(0),2&e&&ze(" shape:",i.shapeString," ")},styles:[HL]}),n})(),uMe=(()=>{class n{get breakdownExists(){return void 0!==this.numNaNs||void 0!==this.numNegativeInfs||void 0!==this.numPositiveInfs||void 0!==this.numNegativeFinites||void 0!==this.numZeros||void 0!==this.numPositiveFinites}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["debug-tensor-numeric-breakdown"]],inputs:{size:"size",numNaNs:"numNaNs",numNegativeInfs:"numNegativeInfs",numPositiveInfs:"numPositiveInfs",numNegativeFinites:"numNegativeFinites",numZeros:"numZeros",numPositiveFinites:"numPositiveFinites"},decls:7,vars:3,consts:[[1,"size"],[1,"size-value"],["class","break",4,"ngIf"],["class","breakdown",4,"ngIf"],[1,"break"],[1,"breakdown"],["class","category",4,"ngIf"],[1,"category"],[1,"category-tag","infinite"],[1,"category-count"],[1,"category-tag","finite"]],template:function(e,i){1&e&&(h(0,"div",0)(1,"span"),T(2,"size:"),g(),h(3,"span",1),T(4),g()(),S(5,XCe,1,0,"div",2),S(6,tMe,7,6,"div",3)),2&e&&(b(4),ut(i.size),b(1),_("ngIf",i.breakdownExists),b(1),_("ngIf",i.breakdownExists))},dependencies:[Fe],styles:["[_nghost-%COMP%] {\n        background-color: #e3e5e8;\n        border: 1px solid #c0c0c0;\n        border-radius: 4px;\n        font-family: 'Roboto Mono', monospace;\n        font-size: 10px;\n        margin: 0 2px;\n        padding: 1px;\n      }\n      .break[_ngcontent-%COMP%] {\n        flex-basis: 100%;\n        width: 0;\n      }\n      .size[_ngcontent-%COMP%] {\n        display: block;\n        height: 11px;\n        line-height: 11px;\n        margin: 0 3px;\n        vertical-align: middle;\n      }\n      .breakdown[_ngcontent-%COMP%] {\n        border-top: 1px solid rgba(0, 0, 0, 0.12);\n        display: flex;\n        height: 11px;\n        line-height: 11px;\n        padding: 2px;\n        vertical-align: middle;\n      }\n      .category[_ngcontent-%COMP%] {\n        margin-bottom: 2px;\n        margin-left: 4px;\n        margin-top: 2px;\n        heigth: 100%;\n        width: max-content;\n      }\n      .category-tag[_ngcontent-%COMP%] {\n        border-radius: 2px;\n        padding: 0 2px;\n      }\n      .finite[_ngcontent-%COMP%] {\n        background-color: #aaa;\n        color: #fefefe;\n      }\n      .infinite[_ngcontent-%COMP%] {\n        background-color: #e52592;\n        color: #fff;\n      }"]}),n})(),pMe=(()=>{class n{get infoString(){return this.hasInfOrNaN?"Has \u221e/NaN":"No \u221e/NaN"}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["debug-tensor-has-inf-or-nan"]],inputs:{hasInfOrNaN:"hasInfOrNaN"},decls:2,vars:4,consts:[[3,"ngClass"]],template:function(e,i){1&e&&(h(0,"div",0),T(1),g()),2&e&&(_("ngClass",Sn(2,nMe,i.hasInfOrNaN?"has-inf-or-nan":"")),b(1),ze(" ",i.infoString," "))},dependencies:[bn],styles:[".container[_ngcontent-%COMP%] {\n        background-color: #e3e5e8;\n        border: 1px solid #c0c0c0;\n        border-radius: 4px;\n        color: #666666;\n        font-family: 'Roboto Mono', monospace;\n        height: 14px;\n        line-height: 14px;\n        margin: 0 2px;\n        padding: 1px 3px;\n        width: max-content;\n      }\n      .has-inf-or-nan[_ngcontent-%COMP%] {\n        background-color: #e52592;\n        color: #fff;\n      }"]}),n})(),nT=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["debug-tensor-value"]],inputs:{debugTensorValue:"debugTensorValue"},decls:5,vars:5,consts:[[3,"dtype",4,"ngIf"],[3,"rank",4,"ngIf"],[3,"shape",4,"ngIf"],[3,"hasInfOrNaN",4,"ngIf"],[3,"size","numNegativeInfs","numPositiveInfs","numNaNs","numNegativeFinites","numZeros","numPositiveFinites",4,"ngIf"],[3,"dtype"],[3,"rank"],[3,"shape"],[3,"hasInfOrNaN"],[3,"size","numNegativeInfs","numPositiveInfs","numNaNs","numNegativeFinites","numZeros","numPositiveFinites"]],template:function(e,i){1&e&&(S(0,iMe,1,1,"debug-tensor-dtype",0),S(1,rMe,1,1,"debug-tensor-rank",1),S(2,oMe,1,1,"debug-tensor-shape",2),S(3,aMe,1,1,"debug-tensor-has-inf-or-nan",3),S(4,sMe,1,7,"debug-tensor-numeric-breakdown",4)),2&e&&(_("ngIf",void 0!==i.debugTensorValue.dtype),b(1),_("ngIf",void 0!==i.debugTensorValue.rank),b(1),_("ngIf",void 0!==i.debugTensorValue.shape),b(1),_("ngIf",void 0!==i.debugTensorValue.hasInfOrNaN),b(1),_("ngIf",void 0!==i.debugTensorValue.size))},dependencies:[Fe,lMe,pMe,uMe,cMe,dMe],styles:["[_nghost-%COMP%] {\n        align-items: flex-start;\n        display: flex;\n        flex-wrap: nowrap;\n        overflow: hidden;\n        vertical-align: top;\n      }\n      debug-tensor-numeric-breakdown[_ngcontent-%COMP%] {\n        display: inline-block;\n      }"]}),n})();function fMe(n,t){1&n&&(h(0,"div",12),T(1,"\u25b6"),g())}var mMe=function(n,t){return{tensorDebugMode:n,array:t}};function hMe(n,t){if(1&n&&P(0,"debug-tensor-value",17),2&n){let e=w(2).$implicit,i=w(2);_("debugTensorValue",i.parseDebugTensorValue(Pr(1,mMe,i.graphExecutionData[e].tensor_debug_mode,i.graphExecutionData[e].debug_tensor_value)))}}function gMe(n,t){if(1&n){let e=ge();h(0,"div")(1,"div",13)(2,"button",14),D("click",function(){X(e);let r=w().$implicit,o=w(2);return Q(o.onTensorNameClick.emit({index:r,graph_id:o.graphExecutionData[r].graph_id,op_name:o.graphExecutionData[r].op_name}))}),T(3),g(),h(4,"div",15),T(5),g()(),S(6,hMe,1,4,"debug-tensor-value",16),g()}if(2&n){let e=w().$implicit,i=w(2);b(2),Ji("title",i.getTensorName(e)),b(1),ze(" ",i.getTensorName(e)," "),b(2),ut(i.graphExecutionData[e].op_type),b(1),_("ngIf",null!==i.graphExecutionData[e].debug_tensor_value)}}function _Me(n,t){1&n&&(h(0,"div",18),T(1," Loading... "),g())}var yMe=function(n){return{"input-of-focus":n}};function bMe(n,t){if(1&n&&(h(0,"div",5)(1,"div",6)(2,"div",7),S(3,fMe,2,0,"div",8),T(4),g(),S(5,gMe,7,4,"div",9),S(6,_Me,2,0,"ng-template",10,11,Zt),g()()),2&n){let e=t.$implicit,i=tt(7),r=w(2);b(1),_("ngClass",Sn(5,yMe,r.isInputOfFocus(e))),b(2),_("ngIf",e===r.focusIndex),b(1),ze(" ",e," "),b(1),_("ngIf",r.graphExecutionData[e])("ngIfElse",i)}}function vMe(n,t){if(1&n){let e=ge();h(0,"cdk-virtual-scroll-viewport",3),D("scrolledIndexChange",function(r){return X(e),Q(w().onScrolledIndexChange.emit(r))}),S(1,bMe,8,7,"div",4),g()}if(2&n){let e=w();b(1),_("cdkVirtualForOf",e.graphExecutionIndices)}}var MX=(()=>{class n{constructor(){this.onScrolledIndexChange=new L,this.onTensorNameClick=new L,this.parseDebugTensorValue=tT,this.TEST_ONLY={getViewPort:()=>this.viewPort}}ngOnChanges(e){if(this.viewPort&&e.focusIndex&&null!==e.focusIndex.currentValue){let i=this.viewPort.getRenderedRange(),r=e.focusIndex.currentValue,o=Math.round((i.end-i.start)/3),a=Math.max(r-o,0);this.viewPort.scrollToIndex(a,r>=i.start&&r<i.end?"smooth":void 0)}}getTensorName(e){return`${this.graphExecutionData[e].op_name}:${this.graphExecutionData[e].output_slot}`}isInputOfFocus(e){return null!==this.focusInputIndices&&this.focusInputIndices.includes(e)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["graph-executions-component"]],viewQuery:function(e,i){if(1&e&&Ye(Cg,5),2&e){let r;we(r=Se())&&(i.viewPort=r.first)}},inputs:{numGraphExecutions:"numGraphExecutions",graphExecutionData:"graphExecutionData",graphExecutionIndices:"graphExecutionIndices",focusIndex:"focusIndex",focusInputIndices:"focusInputIndices"},outputs:{onScrolledIndexChange:"onScrolledIndexChange",onTensorNameClick:"onTensorNameClick"},features:[Gt],decls:4,vars:2,consts:[[1,"graph-executions-container"],[1,"graph-executions-title"],["itemSize","38","class","graph-executions-viewport",3,"scrolledIndexChange",4,"ngIf"],["itemSize","38",1,"graph-executions-viewport",3,"scrolledIndexChange"],["class","tensor-container",4,"cdkVirtualFor","cdkVirtualForOf"],[1,"tensor-container"],[1,"tensor-item",3,"ngClass"],[1,"graph-execution-index"],["class","graph-execution-focus",4,"ngIf"],[4,"ngIf","ngIfElse"],["class","tensor-item"],["dataLoading",""],[1,"graph-execution-focus"],[1,"tensor-name-and-op-type"],[1,"tensor-name",3,"title","click"],[1,"op-type"],[3,"debugTensorValue",4,"ngIf"],[3,"debugTensorValue"],[1,"loading-spinner"]],template:function(e,i){1&e&&(h(0,"div",0)(1,"div",1),T(2),g(),S(3,vMe,2,1,"cdk-virtual-scroll-viewport",2),g()),2&e&&(b(2),ze(" Graph Executions (",i.numGraphExecutions,") "),b(1),_("ngIf",null!==i.numGraphExecutions&&i.numGraphExecutions>0))},dependencies:[bn,Fe,nT,Q7,Z7,Cg],styles:['.graph-executions-container[_ngcontent-%COMP%]{border-left:1px solid #ebebeb;display:flex;flex-direction:column;height:100%;margin-left:8px;padding-left:10px}body.dark-mode[_nghost-%COMP%]   .graph-executions-container[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .graph-executions-container[_ngcontent-%COMP%]{border-left:1px solid #555}.graph-execution-focus[_ngcontent-%COMP%]{display:inline-block}.graph-execution-index[_ngcontent-%COMP%]{color:#616161;display:inline-block;padding-right:4px;text-align:right;width:40px}body.dark-mode[_nghost-%COMP%]   .graph-execution-index[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .graph-execution-index[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}.graph-executions-title[_ngcontent-%COMP%]{box-shadow:0 5px 3px -3px #ccc;padding-bottom:5px}.graph-executions-viewport[_ngcontent-%COMP%]{flex-grow:1;font-size:12px;width:100%;overflow-x:hidden}.input-of-focus[_ngcontent-%COMP%]{background-color:#fff099}body.dark-mode[_nghost-%COMP%]   .input-of-focus[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .input-of-focus[_ngcontent-%COMP%]{background-color:#e65100}.loading-spinner[_ngcontent-%COMP%]{display:inline-block}.op-type[_ngcontent-%COMP%]{background-color:#eceff1;border:1px solid #ebebeb;border-radius:4px;font-family:"Roboto Mono",monospace;font-size:10px;height:14px;line-height:14px;padding:1px 3px;width:max-content;direction:rtl;display:block}body.dark-mode[_nghost-%COMP%]   .op-type[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .op-type[_ngcontent-%COMP%]{border:1px solid #555}body.dark-mode[_nghost-%COMP%]   .op-type[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .op-type[_ngcontent-%COMP%]{background-color:#455a64}.tensor-container[_ngcontent-%COMP%]{width:100%}.tensor-item[_ngcontent-%COMP%]{border-bottom:1px solid #ebebeb;display:flex;flex-wrap:nowrap;height:38px;line-height:38px;text-align:left;vertical-align:middle;white-space:nowrap;width:100%}body.dark-mode[_nghost-%COMP%]   .tensor-item[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .tensor-item[_ngcontent-%COMP%]{border-bottom:1px solid #555}.tensor-name[_ngcontent-%COMP%]{background-color:rgba(0,0,0,0);border:none;box-sizing:border-box;color:inherit;cursor:pointer;direction:rtl;display:block;height:16px;line-height:16px;margin:2px 0 1px;max-width:calc(100% - 2px);overflow:hidden;padding:0 2px;text-align:right;text-decoration:underline;text-overflow:ellipsis;white-space:nowrap}.tensor-name[_ngcontent-%COMP%]:focus{outline:1px solid #c6cad1}.tensor-name-and-op-type[_ngcontent-%COMP%]{direction:rtl;display:inline-block;overflow:hidden;padding-right:8px;text-align:right;width:240px}debug-tensor-value[_ngcontent-%COMP%]{display:inline-block;margin:2px 0}'],changeDetection:0}),n})(),wX=(()=>{class n{onScrolledIndexChange(e){this.store.dispatch(jg({index:e}))}onTensorNameClick(e){this.store.dispatch(Gg(e))}constructor(e){this.store=e,this.numGraphExecutions$=this.store.pipe(pn(bv)),this.graphExecutionData$=this.store.pipe(pn(RL)),this.graphExecutionIndices$=this.store.pipe(pn(q(bv,i=>0===i?null:Array.from({length:i}).map((r,o)=>o)))),this.focusIndex$=this.store.pipe(pn(kL)),this.focusInputIndices$=this.store.pipe(pn(uX))}}return n.\u0275fac=function(e){return new(e||n)(C(ke))},n.\u0275cmp=k({type:n,selectors:[["tf-debugger-v2-graph-executions"]],decls:6,vars:15,consts:[[3,"numGraphExecutions","graphExecutionData","graphExecutionIndices","focusIndex","focusInputIndices","onScrolledIndexChange","onTensorNameClick"]],template:function(e,i){1&e&&(h(0,"graph-executions-component",0),D("onScrolledIndexChange",function(o){return i.onScrolledIndexChange(o)})("onTensorNameClick",function(o){return i.onTensorNameClick(o)}),G(1,"async"),G(2,"async"),G(3,"async"),G(4,"async"),G(5,"async"),g()),2&e&&_("numGraphExecutions",W(1,5,i.numGraphExecutions$))("graphExecutionData",W(2,7,i.graphExecutionData$))("graphExecutionIndices",W(3,9,i.graphExecutionIndices$))("focusIndex",W(4,11,i.focusIndex$))("focusInputIndices",W(5,13,i.focusInputIndices$))},dependencies:[MX,lt],encapsulation:2}),n})();function MMe(n,t){1&n&&(h(0,"span"),T(1," Output "),g())}function wMe(n,t){1&n&&(h(0,"span"),T(1," Input "),g())}function SMe(n,t){if(1&n&&(h(0,"div",6)(1,"span",7),S(2,MMe,2,0,"span",8),S(3,wMe,2,0,"span",8),g(),T(4),g()),2&n){let e=w();b(1),_("ngSwitch",e.kind),b(1),_("ngSwitchCase","input"),b(1),_("ngSwitchCase","consumer"),b(1),ze(" slot: ",e.slot," ")}}function EMe(n,t){if(1&n&&(h(0,"div",9),T(1),g()),2&n){let e=w();b(1),ze(" ",e.opData.op_type," ")}}function TMe(n,t){1&n&&(h(0,"span",10),T(1," (Op info unavailable.) "),g())}var DMe=function(n){return[n]},SX=(()=>{class n{constructor(){this.onOpNameClick=new L}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["graph-op"]],inputs:{kind:"kind",opName:"opName",slot:"slot",opData:"opData"},outputs:{onOpNameClick:"onOpNameClick"},decls:9,vars:7,consts:[[1,"op-container"],[1,"input-tensor-name"],[1,"op-name",3,"ngClass","click"],["class","slot",4,"ngIf"],["class","op-type",4,"ngIf","ngIfElse"],["opInfoMissing",""],[1,"slot"],[3,"ngSwitch"],[4,"ngSwitchCase"],[1,"op-type"],[1,"op-info-missing"]],template:function(e,i){if(1&e&&(h(0,"button",0)(1,"div",1)(2,"button",2),D("click",function(){return i.onOpNameClick.emit({op_name:i.opName})}),h(3,"span"),T(4),g()(),S(5,SMe,5,4,"div",3),g(),S(6,EMe,2,1,"div",4),S(7,TMe,2,0,"ng-template",null,5,Zt),g()),2&e){let r=tt(8);b(2),_("ngClass",Sn(5,DMe,"self"===i.kind?"self-op-name":"")),b(2),ut(i.opName),b(1),_("ngIf","self"!==i.kind),b(1),_("ngIf",void 0!==i.opData)("ngIfElse",r)}},dependencies:[bn,Fe,$i,sr],styles:['.op-container[_ngcontent-%COMP%], .op-name[_ngcontent-%COMP%]{color:inherit;background-color:inherit}.op-container[_ngcontent-%COMP%]{border:2px solid #ebebeb;border-radius:4px;box-shadow:1px 3px #eee;cursor:pointer;margin:0 5px 0 0;padding:2px 6px;text-align:right;width:200px}body.dark-mode[_nghost-%COMP%]   .op-container[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .op-container[_ngcontent-%COMP%]{border:2px solid #555}body.dark-mode[_nghost-%COMP%]   .op-container[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .op-container[_ngcontent-%COMP%]{box-shadow:1px 3px #757575}.op-container[_ngcontent-%COMP%]:focus{outline:0}.op-container[_ngcontent-%COMP%]:hover{border:2px solid #ffd3b2}.op-info-missing[_ngcontent-%COMP%]{color:gray}.op-name[_ngcontent-%COMP%]{border:none;cursor:pointer;display:inline-block;overflow-wrap:anywhere;padding:0;text-align:right;text-decoration:underline;white-space:pre-wrap}.op-name[_ngcontent-%COMP%]:focus{outline:0}.op-type[_ngcontent-%COMP%]{background-color:#eceff1;border:1px solid #ebebeb;border-radius:4px;font-family:"Roboto Mono",monospace;font-size:10px;height:14px;line-height:14px;padding:1px 3px;width:max-content;display:inline-block;margin-top:3px}body.dark-mode[_nghost-%COMP%]   .op-type[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .op-type[_ngcontent-%COMP%]{border:1px solid #555}body.dark-mode[_nghost-%COMP%]   .op-type[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .op-type[_ngcontent-%COMP%]{background-color:#455a64}.self-op-name[_ngcontent-%COMP%]{font-weight:bold;text-decoration:none}.slot[_ngcontent-%COMP%]{color:#616161}body.dark-mode[_nghost-%COMP%]   .slot[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .slot[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}']}),n})();function AMe(n,t){if(1&n){let e=ge();h(0,"div",13)(1,"div",14),T(2),g(),h(3,"graph-op",15),D("onOpNameClick",function(r){X(e);let o=w(3);return Q(o.onGraphOpNavigate.emit({op_name:r.op_name,graph_id:o.graphId}))}),g()()}if(2&n){let e=t.$implicit,i=t.index;b(2),ze("Input slot ",i,":"),b(1),_("kind","input")("opName",e.op_name)("slot",e.output_slot)("opData",e.data)}}function RMe(n,t){if(1&n&&(h(0,"div",11)(1,"div"),S(2,AMe,4,5,"div",12),g()()),2&n){let e=w(2);b(2),_("ngForOf",e.inputOps)}}function kMe(n,t){1&n&&(h(0,"div",16),T(1," (This op has no input tensor.) "),g())}function PMe(n,t){if(1&n){let e=ge();h(0,"div",23)(1,"graph-op",15),D("onOpNameClick",function(r){X(e);let o=w(4);return Q(o.onGraphOpNavigate.emit({op_name:r.op_name,graph_id:o.graphId}))}),g()()}if(2&n){let e=t.$implicit;b(1),_("kind","consumer")("opName",e.op_name)("slot",e.input_slot)("opData",e.data)}}function OMe(n,t){if(1&n&&(h(0,"div",19)(1,"div",20),T(2),h(3,"span"),QM(4,21),g(),T(5,") "),g(),S(6,PMe,2,4,"div",22),g()),2&n){let e=t.$implicit,i=t.index;b(2),du(" Output slot ",i,": (",e.length," "),b(2),Ey(e.length),ZM(4),b(2),_("ngForOf",e)}}function FMe(n,t){if(1&n&&(h(0,"div",17)(1,"div"),S(2,OMe,7,4,"div",18),g()()),2&n){let e=w(2);b(2),_("ngForOf",e.consumerOps)}}function LMe(n,t){if(1&n&&(h(0,"div",24),T(1),h(2,"span"),QM(3,25),g(),T(4," and no consumer.) "),g()),2&n){let e=w(2);b(1),ze(" (This op has ",e.opInfo.consumers.length," output "),b(2),Ey(e.opInfo.consumers.length),ZM(3)}}function NMe(n,t){if(1&n){let e=ge();h(0,"div"),S(1,RMe,3,1,"div",4),S(2,kMe,2,0,"ng-template",null,5,Zt),h(4,"div",6)(5,"div",7),T(6,"Op:"),g(),h(7,"graph-op",8),D("onOpNameClick",function(r){X(e);let o=w();return Q(o.onGraphOpNavigate.emit({op_name:r.op_name,graph_id:o.graphId}))}),g()(),S(8,FMe,3,1,"div",9),S(9,LMe,5,2,"ng-template",null,10,Zt),g()}if(2&n){let e=tt(3),i=tt(10),r=w();b(1),_("ngIf",r.inputOps.length>0)("ngIfElse",e),b(6),_("kind","self")("opName",r.opInfo.op_name)("opData",r.opInfo),b(1),_("ngIf",r.totalNumConsumers>0)("ngIfElse",i)}}function BMe(n,t){1&n&&(h(0,"span",26),T(1," (Op info unavailable.) "),g())}function VMe(n,t){1&n&&(h(0,"div",27),T(1," No graph op selected. Click a tensor name in the Graph Executions table to view the neighborhood of the tensor's op in its graph. "),g())}var EX=(()=>{class n{constructor(){this.onGraphOpNavigate=new L}get graphId(){return this.opInfo.graph_ids[this.opInfo.graph_ids.length-1]}get totalNumConsumers(){return this.consumerOps.reduce((e,i)=>e+i.length,0)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["graph-component"]],inputs:{opInfo:"opInfo",inputOps:"inputOps",consumerOps:"consumerOps"},outputs:{onGraphOpNavigate:"onGraphOpNavigate"},decls:9,vars:2,consts:function(){let t,e,i,r;return t=$localize`:␟fe55f9b193ea20aae5b5635e68d9386503847746␟4955133740841299851:{VAR_PLURAL, plural, =0 {consumer} =1 {consumer} other {consumers}}`,t=KM(t,{VAR_PLURAL:"\ufffd0\ufffd"}),e=$localize`:␟baa460e2f2b857e26292b246fc18ae0ea9b5e537␟5556340343850165516: ${t}:ICU:`,i=$localize`:␟6aa75f627e0dc16150ef448464e0c857aaa0dc18␟5156712935150586878:{VAR_PLURAL, plural, =0 {tensor} =1 {tensor} other {tensors}}`,i=KM(i,{VAR_PLURAL:"\ufffd0\ufffd"}),r=$localize`:␟893476c2c421cee47663c9732fa41a750d3a73df␟246067053735162634: ${i}:ICU:`,[[1,"graph-structure-container"],[4,"ngIf","ngIfElse"],["opInfoMissing",""],["noOpFocused",""],["class","inputs-container",4,"ngIf","ngIfElse"],["noInputs",""],[1,"self-op-container"],[1,"self-op-header"],[3,"kind","opName","opData","onOpNameClick"],["class","consumers-container",4,"ngIf","ngIfElse"],["noConsumers",""],[1,"inputs-container"],["class","input-op-section",4,"ngFor","ngForOf"],[1,"input-op-section"],[1,"input-slot-header"],[3,"kind","opName","slot","opData","onOpNameClick"],[1,"inputs-container","no-inputs-indicator"],[1,"consumers-container"],["class","slot-consumers-container",4,"ngFor","ngForOf"],[1,"slot-consumers-container"],[1,"slot-consumers-header"],e,["class","consumer-section",4,"ngFor","ngForOf"],[1,"consumer-section"],[1,"op-consumers-container"],r,[1,"op-info-missing"],[1,"no-op-focused"]]},template:function(e,i){if(1&e&&(h(0,"div")(1,"div"),T(2,"Graph Structure"),g(),h(3,"div",0),S(4,NMe,11,7,"div",1),g(),S(5,BMe,2,0,"ng-template",null,2,Zt),S(7,VMe,2,0,"ng-template",null,3,Zt),g()),2&e){let r=tt(8);b(4),_("ngIf",null!=i.opInfo)("ngIfElse",r)}},dependencies:[dn,Fe,SX],styles:['[_nghost-%COMP%]{overflow-y:auto}.consumers-container[_ngcontent-%COMP%]{padding-bottom:5px;overflow-x:auto;white-space:nowrap}.consumer-section[_ngcontent-%COMP%]{display:block;margin:5px 0}.graph-structure-container[_ngcontent-%COMP%]{font-size:12px;overflow-y:auto;white-space:nowrap}.inputs-container[_ngcontent-%COMP%]{border-bottom:1px solid rgba(0,0,0,.12);margin-top:5px;overflow-x:auto;padding-bottom:0;white-space:nowrap}.input-op-section[_ngcontent-%COMP%]{border-right:1px solid rgba(0,0,0,.12);display:inline-block;margin-right:5px;padding-bottom:5px}.input-slot-header[_ngcontent-%COMP%]{background-color:#fff099;margin-bottom:5px}body.dark-mode[_nghost-%COMP%]   .input-slot-header[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .input-slot-header[_ngcontent-%COMP%]{background-color:#e65100}.input-tensor-name[_ngcontent-%COMP%]{display:block;white-space:nowrap}.no-op-focused[_ngcontent-%COMP%]{color:gray;font-family:"Roboto",Arial,Helvetica,sans-serif;font-size:13px;white-space:normal}.self-op-header[_ngcontent-%COMP%]{font-weight:bold;margin-bottom:5px}.self-op-container[_ngcontent-%COMP%]{border-bottom:1px solid rgba(0,0,0,.12);padding-bottom:5px}.slot-consumers-container[_ngcontent-%COMP%]{border-right:1px solid rgba(0,0,0,.12);display:inline-block;margin-right:5px;padding-top:5px;vertical-align:top}.slot-consumers-header[_ngcontent-%COMP%]{white-space:nowrap}'],changeDetection:0}),n})(),TX=(()=>{class n{onGraphOpNavigate(e){this.store.dispatch(Wg(e))}constructor(e){this.store=e,this.opInfo$=this.store.pipe(pn(OL)),this.inputOps$=this.store.pipe(pn(FL)),this.consumerOps$=this.store.pipe(pn(pX))}}return n.\u0275fac=function(e){return new(e||n)(C(ke))},n.\u0275cmp=k({type:n,selectors:[["tf-debugger-v2-graph"]],decls:4,vars:9,consts:[[3,"opInfo","inputOps","consumerOps","onGraphOpNavigate"]],template:function(e,i){1&e&&(h(0,"graph-component",0),D("onGraphOpNavigate",function(o){return i.onGraphOpNavigate(o)}),G(1,"async"),G(2,"async"),G(3,"async"),g()),2&e&&_("opInfo",W(1,3,i.opInfo$))("inputOps",W(2,5,i.inputOps$))("consumerOps",W(3,7,i.consumerOps$))},dependencies:[EX,lt],encapsulation:2}),n})(),DX=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["inactive-component"]],decls:54,vars:0,consts:[[1,"container"],[1,"title"],[1,"code"],[1,"arg"],[1,"exhibits-container"],[1,"exhibit"],[1,"screenshot"],["src","data:image/png;base64,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"],[1,"description"],["src","data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAATYAAAE2CAYAAADrvL6pAABMC3pUWHRSYXcgcHJvZmlsZSB0eXBlIGV4aWYAAHjarf1ZtiW5lWUL/ksrogkiqARoDioZ4/Ugm59z4iiNRtI9IvxlmlIL3nuuFMAu1toVrv3/+X++63/9r//1vKmkK+W3llbKzX+ppRY6/6j37792/nzudP48/8Xy51/Pv379+usbgb+jn/x94+2/v5/O1/M/f+Af93jGv379qn++E+qfC/35Bhf+PYF39t/r7w/J18Pv60/6c6G2f/8orb5/f9Tx50LzzwfPo/z5nf56rN9f/v/rX77wskorc6MYwo5PvM+f6fcE8fe78/s9fwY+9/C1HmMsF3898f1zMRbkX17vH3/f998X6F8W+R//uv599f/6178tfuh/vh7/bS3LnzW6y3/9jSf/29fjX7cJ/yIOfz1R+Ndv3CHF/3idP7+/b9Xv27+360hhS+WPRJ3Ffv5xGT44WPJ4fqzw6+V35t/v+dX4Ve9+T7Z83fMe/JpPewK78l1PetbTn+/Z5+/5TB4xhR1e/g5hhni+VuMbWpjRfUr+er7wxhZXrOzbDPti61IMfz3Lc+7bzv3mU7nzevhoeLiYW/3f/rr+d9/8n/y6vm+6RM9d/1orniso1zyGO+effIoNeb4/+5bPAv/j15/tv/8mP4gqO5jPMldesN/jd4mRn3/KVjz7HPlc5u+fCj3Xu/5cgCXi3pmHeSI7cJcn5qc89xvC+zysY2WDOk8eYgqDHXhyDouHRF5iCdcbavDe/Mz7nM+GHErwy9gmNiLHgm5VdqizWSll5OdNFRnqOeaUcy75zfXKLfcSSyq5lPIWjVx/45ve/Jb3fevb3l5jTTXXUt9aa6u9hRaxgbmV9rbaWus9XJ0bda7V+XznKyOMONLIo4x31NFGn4jPTDPPMt9ZZ5t9hRUXZmKV9a662ur7uTaWYqedd9nvrrvt/iFrX/zSl7/yvV/92tf/2rU/u/ofv/4Hu/b82bVwdsrPvX/tGl+93vcfl3g0J9k9Y8dCetjx1x1AoIN7dtcnpeDOuWd3CyhFDjxkdm+u9bhjbGHaT8jf89fe/XPn/q/27cr1/2rfwv9p5y637v8fO3exdf+5b//Fri393Dw79tNC1/SOaB+f6aFe/L5v/vjrbx6p7p7L6Hn1kWdeqaMi977fF4fycNmZYn93v1NYO6UvhpTeK9bQa8ZO5a+Nsd57bNc8sDZv+upT8FrPdqnizpU1rn2+bY/61L7jO8vHh3duV4m4yBEwZYVlr2FzE4xf/7hoSyzByO/qfc303jPw1nwXbxvY0dxa/Yo+Oo77YsO/OnmZ+L5fqWzD2hmfHsYIveyMRwQIPLxlnaOttNNYLfOcuYXMpn7IEwJUr4ERXpXnCqn1PV/eueb1fm8r9eu1jPY+X0EoIq+5W18dO9Mz+/HuZ3ChN208wXs97B4uovYv548v1Pyl8d1nT/Hgdce62U/2rqeEoI5USwhrtvfFw1RWZB3duco7nl14zVlHijzNYAk/1AIdwH49pakMn1L57fzl+ZXJo8Vnt7z2qu+eH1tcUJF5f33twd5+MdY79zBSutmd95l1zaUXWt/decb8Dl5vfUhPWONb+/lmryu9+7t4iqx47Pcp73dvfMHLz8xR2mxYyPd94savzpBv9gudD3fJdaPrG6f27InEPStcI01ekj8it+o+9hfnjZcb3rOlXdkydi6u+9sjoVo98Yg7sIMYlzJCrSGx/RORaCn0vVWnuT7WlluP+b0o3U4FuYj37rPidXdgC9C5wc69Lh1Xw/YgF/nCPoTkxSpqFnfx/dtuwb/XN8//f3phs56nZTS73TE2fXgYb3i/2HdeI61rLF4m3PVLrGFiDzsOKbcRe/tQcOBuW2NgmCbbwf8wVmxTb/EboWCpkKnU3twvfNNCMwc7HVJBqgeGB7AAspvIFzZubYTjrevLA2UZe/KYNy/lDSJr2+Zmt6+NTj1zFUxbQ1b7ylvdf7FI9+BREKG1QIxz8rE3HD0sWI+exhz+bqv09aC02ibc545eLczGM92rprKRr4atibx1f7nLg0zsjqlaq7QWMFApldrvvLgOyL9ixPYcDyYZRNXBVxGbIi5e6dtP/lhWVgvJSbkiMa3xkbXqLOl7ENQXFU1xQiE+3jRrTBHV+mIwsAX+L8TB5s4+Z8QfoLx3Thgl9Bgl39w9LpT3ewF6oQ9sdrvdYvQT+MXb8++Y+12wzbH3t95jYhfi3do3K4vCU925YU14hTlB/rEslvvCzMXNjsxcnpR7TRjq8KQ3IIMdLqCHuwuLgyfIg40aheccuwFWxuxllYSHAETUmPJ4ckTUJ2pXsO8T3LrbfN+uMLH3rOPDsiDsvPluGA3W0V3Ep7Ek/UYvLpa5pMDLD21L4sVQIC52f/54XixfwgENRGW/2N+MSqL0fK42bo6wh80F9tW4Y4t5rrcO1BznsHByuDKEDu/V0ffY551KKM/Hv2v5UF9MOT8xP9xF3DvjxaFZG5uXE5/AAKY+sE68buUvTD5eAuF8e6qj3BOFBmUDNjFxeXwFbUYiMz7jwWWvhRtpXh9nm97aemZV0QhWFvHH6mKGfefBMyNhr5LxfIMna/V43vW1Wa9HCyKw5xnRFsx5LwFBwI66/A8+GyeRtIjNVeTbBbDPW7DS7FhT0l4ZpFuMUQNKYHkjtpRXy1hRVia/6D+CWVrGkCM++GF0rQqnv7lbSYDRkjvOZVzSgw9G8IYRZsUAyVXC9uIdmUJlkJ5UPkDKhiv0gYgjH0XP9WHMcYhLa309qOURpXXjz9aH2rdv+YH7QxKhEAUQkGCmLCbyxY8hA7miNB8rzR839vYt11snF0cJVwe87beyIwrdMxYu81besN5TwIAvjBq2r2c82Ax4xw9R+fb+8CK8K+gA4IIRwohj8YBlj26d7Wv7gx0NEM9CKEFBKC6C8G0WP7J6H74Bx9ARhuvGCoR3DFz0DDzj3WNRFVksSAKP2pCD2YocWBPzYcABODwS98aVYkjw7RHjv3jZjdFJwCVYITdaeO1j9MeGZP39JxrKzbp/75GfkAu7gYZXDPeF7eUiDSgxpETlRVtBFG99XNVbxedGPCu7ESaeT0cLavxajgpOxg1i0F8AOyYUBXufUPAKeA+0lgsAy9BZxHh/gxXLGKDenney+qk8D5gngTh5IlZQg3a9E/PLOpZPU+lK7acCH0Zl63srebT0FqAW0oifHjjy+QDYpjGCqrii3TwXQGvP9uEAFewF6sGlcGHUFCePiRM5gt2wT0/HFUj9UDpsVPtutvEDfMONnnI1nAYqg3HZBbDF5oAfsVqZjX3AOM1352YVg84/8X2QXcwl/jGOwibjaRHAdCHtSFlcQUMOmn/TgiECVsQ4oUAqcoBKlIxjuJVtdAiZP8gDNAEuL2Hgla5bmINoKZMQx3GWHhdXgaYo9YOvBgK+GGN+PJSWlnyS1wsZgcX/IcZ3nemaFTO1Ve8mwcdDx/uN0FXWTcSR0UzEHS/OVoNXcphzAwrxiYHL3Cw7NqiVK7IHWLgG/AM7I71oOSv1vK7yg56Hhg/D+AYwNgQPuPsheeKtmrk5qpUgTPvq6BQwIRecWAIzIAgoPq8FOYYaJYgHd0HyJ2CVHZ/IFZj1w3NvvAHfOVx+XVimx8jJCyX5x9ePvy51PTKG9fsAFuTvH5nHpv3tJ6//9z/6rz95nR/do+S7Ygx7atieCJqcY2JOYSmI6IPRhZaC9LDfCGnLEICXHSqikd/bXvNIK9bhxe2/8+AAdLT+YyV+34BF+C2V90AZTNDNzaKazy3nThcCOPFyoL+AHmFtXiAr6oO6HuTHPkJk8gsd2F2HkzHu7KC4HUBX/fPDM1+L7UG73xUEdg/MAMUOMs8cvTWkZeDmcW94uw+vJE6LgMQ3djj0DRAfRjoucHDBGWOBsZsNgcGAhxe4CKZmKbgndm0AcgGbPGpMcWgTEqh1pLuBahNy3ON1by4FqcGPbRZnoC2sBOaPjwTJIK4+RFwYVolHGbAjrLDRT4hjb3uPvdao32XoCuAqoFLP0SzUDZ4cWBAYNZtbEmavs/0NGZ04ppmfMMSn7DPUG2N0f/mqcGuAJdCgvkpJihn3BPv4Kp45D5x+rtxzdhFYSVKMhCGa+m7s0oI2L659TTQSSljfITpijXCWcTzpG9D/Plg1eP6HzMCSx1fxdjsHHBZi1WSRD26+rPFg2LjzB+wAjeBDIAjvm598KAR+AlSGCPXCYt0i/TdM9L69AV5QRSJw6wRkXxeqHfRUBbuBtH1f+4PHAO9xY5jaEVhgIdYswng/XNP88DvoiByxAtTZzytj/RqwH6z+pMBt5eLnh1GKG/zA4+XI3mN7eC3en31nlZ8MFopA8Y4FDe0FsbEfQE2eA1oB2UKqNoRipwR5YUeCzAuU8oCcMJ6YxAg9wtmhuCzXDeSSolzFXcfDAXR1nBmmJbo3pigwLegfsAGUzu40OIAsmp/lHbYuacJ9MWPhuX78rOLtoJa7v2wTopB5d5T1ZlVuTDu21TAGDB6zCZiLOMChn028Xkqo7rw6IBtEhk4UbS+OCHjTWUz8CY5BzoToYejhMx1ECBOFTki22M4HaAXkfDRsCT3o7x4sPRsy8KqGH9CWDPDDc2EnBMM3kOcb2ABsTxAnej0eL2DMWb3yXmUje9scAzCs3+xSye9Bh2/Gv7FEONZVWRLjbs8LTOkbG7LwdLOAjhrEmnW/QNZYiiBZKvnBiRo1AabA2O+WH3XzhMLEvDjYwrO3FcMqAFx4CejvZQ3vcq3qHmSlcHTMRoXiJL4IBI2SYvANsG3hjYaSAtyIigWi9OoH1Qnwz42KHCYPmMJU8SBrvSB6lB/h4L6bVcKJYc4CCi0ZG5WNBcHNW7W93wEhhG7sC4IL9kHUwdf5/Mudg+OzYpCqgI1GYPkSWNeQ4twvOBebnsEuhiRQXAS8X4CYgF/AC5aNPOCKtVtTmMDyueyoTl8GCmKobw4qcpe2sm4LEQyVFwP6sTgYDUQMtURcuTeyERqMHMwGahClVGw8Hkqviz1lzZCMzTbmgTHRhOPbr5M6AaAvsRWwBmz5HSgdcCDf23HurCG6/AEOcJOf4fYXHKkCAX42cuK/TUJpEMbxZ4NbIfpYfoBWQL5qyO+ELXW8Dl4IK42dl+kBGPk8JAKWiVK9z5Vg+Tjatu7dq6rANqIDrGLIIjjMbrmBKwNet9nHJP2Gof7jSf7xINefJ0EP+rGKBn0E1XyK3UFIv7xOfJe1hg0XSDPYC8VideJdNJ63Dv3KMFdMrs5AEt1QbX6g1IJAY7Zhc4jAg6bffclZvvLn1njx9P3z9tff7x8/wK1oAyLKAp0F7Svj0gG6BlmkQc3omNE/BbPH52uYtNwvTFqSihbIfxNAg8FbdDFlsC8MDPn+jOgm6aCxIJgjtpUtNcR9Fn20cCU8UOCxfDfMNqAV/waiDs+IQOIAj1Rmcab5OSLzYsWhVMOc4N/CGpdxjdYbngHfcoRgHJAlsP0Dt/5tf/7r7bn+2h8t/wCB4Czyg/+F3+BZF6QHGwbsyLVgOlI4UcUbpLDn0U8j6SjLtbCQa+bKC0zDBgHlYdMb2sc2brxUlFscoL6miAt+NnB76AAPxxaDTFhYLOS+HyD90zovKM3LE3s40EyMbNDHw0l56geK617iY9/zqo/x8r37T1muu5Q77qrFExgvvPtEGyG1kq4TE4OXyRrYuxOdTnuAOz5szF5V5o8ClHpNHCHKXTLwpwCTEIQ3wnNBqBAUKHdfT3BtB16N6/O9VQWufCLyTOwrurk0I4jyPWDAKBRmmLXpESKMm0wRUIHluCVasmDeHyuE1QUlSYCeVeHKG3f0jAuENwwaGN1HZhdqJNV8x2d8GBQMbOnQwhhiUdkNWA/j8K9BlKXxb6uEdSHNMGmDnDwjkg1dgKaOb2Yc7aNZ6BWygKxlKMqe0qGysZPGpkPSniJVI11GzlpnlX57WxtOQAgHqmhQd7OrrCE/zZekpxhhQ+niusDFcZTgK/jKVRsW2DT3/apLorxvF0XYTARMsqOCOIqV2sbwszNA065S3FBlvDrPinwYQKh4inrjbirUqOnkhiQKRI+3iRMUA7P7MsuCgY3zB7wgeRGokmYA8EMo6hVEQhDulcFP+2A14Ov3biQaUiwI3zni8yFnH1qw8bnvB5ThJh+WHJNT8JhTxJbBH+rsPOq4jS0XVg28OSe0c+AjjAFDQnGvYGN4xsdFceGYzFZridDQC178Lpdd0a04DfgRq2iAk4VPOGWeFw+wYh9r52WAw41POrOGEJioxt5f4Jxt3CE0brhkL3lU0E0yAYATO+IXPnwsWniXb6PaKTzoftXnzTdWgNKaV924b1DYl2tCscDMCO8N8X1gNitxu7qBOxDu/D7gH5MncDUw2M1tAAtD3WnxMjQ0ZccQ6oCtwDwltRiSgGD+I3RfsU1Phti+0Eh0bjXERweQVosgjSdfAS1yYTdeeEim96t125iCDDK+O7gUfwrvi0a0QLIbC3hXczGFJfp+0P7kRZBgo/OPIe0nJaAzAsU+Bh0y0g3O3dKCRzdl4n7M9QBJcVO/nBJLnK8hGDLkgRFpiBvabjDxRI+BJVJYEFYvEpkQUSHeD5HFtcMztLpQX6SqXxiUkRAEVgF/NvPhr1tnALiIQrWFHGJ3sRcL88brw9ISuAifeZs4eBaUaF+6SzwH2wSHhoa2p0YAPCJyg0/yEXbIL6zw44FfSCAfQGK5b0buQf5gRRzZBXpcbyqDb40J/x78RjW5hKHnAqoERxj/uLGzwMcnL+H4/VvipxqgWyw4+Kiat9eciXMNv2h0qkbJbwBxntug2911yYal0H5Y2m5xPXlGJQHluMSMYKKN0URWOhBqpi+EbnXN1p1rt+aSGgyJAPiUZcNhcS+McYjBjEoGRFSwZP8P4RPn/23dMAh8MGOrI/AhooWZ/97XePadJ0+K8W8mpdCxJdmyxCebJGWfDTFhFfcG60MPBCb/fjsE8scD46U4xn/e/cFTYCnrMI2kSJtrSycqAj+BdMSThGLXa8+xR/N+rYfxXp+FLbVjP1HR29g1ROMF/Jf+z9udu02DAFt4OuuBEDwQ3nPhuwBPF8JfE3gf4IQ5x8sUAwJ4D3wqftN0X6yYh1+uD7MZks8wN/KBQgBVxtDWXPzbT6YvYii3AfzvZAl917Mgfy0H+JgHiTdwPOCCsW241lZx1XDk+2KHxz3hurjzraiBNbWvko1+th48hdlr/4ebXP+4Sz4SAUjm3YEGaLULD8ZD4TCYuLsOT8nn8V/A/Mt2AA7myfLhfC7gbRzY54xvej4UGovsms6Tjf3XB/jbtv/Le8YaQP4sDRwDIwFiwoVkTfGJ6WAyG9uCDUHZQZdGkbqk5e+7h/XC+vSxL0g6WolUytANOOKXI2YVMZbsjCdC5NFF7DG8532Bv+A5JKdX5C/qvkzxKZD4bzYAIiSMzlWaNquGzjiCFBFYBroqX9EGhZnxRDjw9y9QWiaQ8SrCufEHmqOVE4qLP8UlQ5Ab2gQVKC+WbUv/bpOFz1GCZmJkP9hRdHc+15BcGMqBwtzxXujmMM8K1oTNmhzBhJZ3c9G8zwaART4ztZAhP31jPLAolz5vmOmY+IN9IhDcj2XGx6f64W4xlSbJwCaNZwQ5rcLysuKsnQVlGaTR92XAcn0mbkrvXAVnhIiMemdZFTuC6Z9o0K/KZfLq21gYPjazQdU8vkYSur4TxiPwXibRX+Od4PRpTdkTPjNU8oresZXbIBv832jZSQUa6CrraewPqLYB8h80fxg9j/0BELGzcn1cSGdjJqZkjCPSVUIhiDASzcrvYOY4hq8HvEg79Ylwu0MlPrjlhLsVTGQGpUWr6fgZZC0rKVPJR6Zwa9z+S5gSrv2YzlA4TTVHlp1VgSxbhvCLaYH7u5Uj3DsNgB572LDyL8xRPwhgBtUCLZ59ReAlZCGDxOR4ot23IXlJZIhvLSvDq1qY6QSn2EyAC+yDNTS+XvPJ5D2m6Rt0LBXTGcao8S1cTEtuvYN0VSys+cPHrEOVYINgjvQkBJ37422xkdfzmHSokx3AWIxjW8PP+8KjuOMb4IMLhICIAHBRaMTrtWgmfgAzAAnvHPcFRvBbqJNqw+shjLN3JB8oBl+teLZvQeGWgY78GLJS//+647mfyUz90xDioyTodcTx4LAg/jHhbsVhiV2DGCBH+HSTgPnFU6MBj98Pxku+fjX8NN5nAnXa+5j6BCWC8XA2QqBQjALxLlCWuFGklvBXJ9ldAQ+gyZGKMOriUYBwA4uDDt5YU8gCNGqDASrYO+X4YLaQ/2cN9q0cHgbKQYnB4P65EJiJPfpbjkHcD0BKt4noX8bvxxUjypzL4YqYGfjRB/QB5JgkS+8DwS/X1wcYKi1eCSkCIgLSp7bzOYkHxdm6oBujmw0ygzkxj3ljJw2r8PwY+ronhi3koZ5uMW0yV7tMu3fLOUCCSGQUtLel7RRnLwP33SDhSUzGX8r+0vFHjOUHuM3lpDR+bP7Bue4HBMb3v6aR+r2M0oxwvLoBMTReA/qO0laUHN+bISnWvSCkBi7xiTx/RyyytUygF/BBrgChuk4BNUCLr4Dh4a5JNNJMekRUJPVXTzeNzgFaU49vwiIigYYheSuUvcRkrA5vPYBI0bDcYxYRQnxF85PsTrBKRcqKjVYNxhi+h7RBrxKLsVWcSMXZYmCxLji7cq9fDKCUCwsCrTgLFko+P4QRgOgB/jC/rA+AA5uBaOwF8AcCAqEmGjawJpgS7htGXSB/fKJJANlNRRRWx6EZN+DdbjlCN4jBbqHXVopxzwS+Em6Mv734BU+HGFmOtwYw4sFOfMHaFTgjMm4ljwgJm+3Wm9EAqyQgGO4YuChehK3d20rfuAAFtR5B4PdSH7H4H+gPAG7qq8PlA+xrjM4ilcz6WDti6VG0XMD82gcuhGw+xgA/9uXBqPPKrGRsQ0WCkqNgwLJyFq2e9QPQmzqf3IRrYRLq1aAPkIMbjW8w9nLSox9WEXOH8+L3xp4MjH99TfnvCmflfgKc20TW8b4jXtEQ1XmX8P6WMBsVwHZB3W5j7oAtkCMoBESUghlBSBGcW5/yGvZ+kJ58IZa3F0LeYDwsULobj9jR7nbCEjmftBa0IqB7VixiktkLsajJUvPFONez2JXL5HdDi4elAYcVQSBAEawKyG5uEIqAQbLAXmALcB5IsMVSZRo9mZeRQZZs+d7o1RrscDQytAye6Tm2mQc4o6V/oo/7M0sxAat80Yojr/ddMIWereESModacIo31s2yhwSA2PGYiRtnAxPclv4BCnvdDU8CWM0IGERttgsLbERGeJh7NQ+FPqLnGLZ6Sm0AytWENI+XYsZ6A/BAhVCj9VhScGPuMAiACJ8H6GDWLZrbRwbqQhbBT+U+JdkZsj1w2hbIY7ANwAD8dUYbFy3gyeOaWIeNB/8smQJU12rAQb2M3CIXgzHfIRGstel61jdXo/imwZDqVJG4Ni+zf5t7f4DK9vZi6Gs+IDuXGA6AINzBMOX9jfGr3L93HJYVCsnNv7JqL08U77RPrSEgh0etprcM2QwlPOCdMKUGi3AcibV9mqUMxgi3VegAsX5qQy+sMpTKzE0yCmlpOlDASgYxiLcHYmREz+oB63bAQR0Ejs17E3I1unUXD7tWUT0MMDfM2zIzXu3Rjn28PjChWSdocA2v0LRdYL3BTsOVlcNVeXbAN7q2t6UVJoYAY7/kPMSea/o+0LdDA5BkNBc/hHDLBLJ572JQNoYTuV2skfgIeQYnvBVQPjJEJBjDfDAgwLM+h6WTFejG6kIF+4uAFxYZEzb7AyDub7n2CxRFbgA2ZrRa3NM0mpUvgB3jId+0wHEacDv50RPbT355LGQxHwT2oGtTJ41O7oxt4XdSrjV8eKYEe8CW3MgiWxWMVtYpSeaKAl3Q67QcNgfrIQ3M5XI/kBZWhEvi+pNOaofOvrAXt4Wl77DKw2zulDuecHs3jJheEOFlNeSfrEPV1kbrRfjiL1eL0TSCzJeg5cmyaatW1AR5i6We+0MJcDwg/wcEBS/O2Yv1tnGMOM/3Ra+n4RKTZDwQWAAD2wzjr2gxgLVjSiVMjAW80vrvHvbfn1VTbTDzVyMRbhZC7wwQZz/DZZhLaTx1mKg9GKCnkKB+0DQ0KWCZpgyl51O+0GRBVjJNXAdmBkIFA4/pCmwCgAhQ9eiqzBAa1eanvv/qqf48/l/JjT8vMPJl0fw63wIpHBuFmBRc6YkChcOtczsx3mCUEoqbmoF1HOD3EzLjwfl61Xd0PIrHkTEAydx8SsgKlHt1012sgry97MMN11qv+BWoB/MGB7MosKOq2YP8T4vqBCjVNHIC/mJu8slgJ+SvYesAQBavJPPqkNMMGJlY+G4cB3dkO0D66Ub4fkpQflVsuk6AnRU1r7saTzXb8azb6kE4LF+YDSdZ8gUBYN9gRewYzmHjAnlzXHECyGPZ50wgnhMRWsaeH2s5gR1AVZbmw7+xavlb10kPQFxuqHTbJtOMhUAssH+PxZLhG2J8nq78Ixn116Md0jROU8mFhEtuT2z9s0JlGQlo/riP0Ho0v6I1HvhMszm5ziAVUvj5s0484uqXFujGwTawuuWk1YLlVXhNiAt2Bc6EHwZSlpwNCckOAi4iW/Bz3hHOBAa+DA7Mf+TJXOXxy6D9c5X/82V+UObFoYlsokb5QY4O28DEA6BSMMzyzvHLVom/hCmwhpFZxVBuu8QC681anCRCAwFjPtE1yx4EIVCb+1evLudFswLMBicfsRwwCAAlQBP6AvcMmlaWh1dD9LFasoMrKXQ4nAdEiIgiijCA/P5afV5DEc1A8ndaZrCS2twhfYbyB1CpTPwGF15GOINO04QFaN5mk//pqo0Op/1LONP3WzYYbI52JyTQ/YijbLNkJpfStJQBS2MdvuWyeRodKm1j8VzsmG5gWMNCskDuPWaS2xsPA30XiGrG/XIR/AOYogPN+uEW1oVD7ELgBa9n9OenYctWjGKcg/UVrU049rOa/nvHO1cvO0UP+DacL5QXsHn/9HOfpHg/JFNjmuIv4G2J2HG1/TUzKTV3DfCMZpPY5bbuCee01HxuCCO6FqrdVcbOcUC2JJg3e1mwZYkMoB1EjguwjBmkigBaYGY05zHrfURTv3EpOXHW31583BUePO2CYT1+X7PkhFdAhI8XxUjiQnh3NgLziEO2/mFeFr7xqhXkr749uM0OoQQvsV7LNEnZA9qCFbEacz1mHixmfMy+VePt7OoDOY460PEfqwMqv3+yhGFwEbX8+QCW+Avawajv34LZOHBN2zURu3tLaRAvZBbMhKmwzcsaI8jDjjgRC197fWf8QI/sKyxCXvvlYmz7+ljxai2LzSRZPpvx0bftLi/OAe/19vsEVX2uB3KN22tYm12tAUHF0TswMJ62ww3RRV58Wc9kjuZTpmIpkC4BSYTgPniaidmL2CjQK1biBGamxd5ALxN12iz8eQmgJMNKplTvam0AULsAY4VYthxZmwJI+7R+4KzvT5Llt7sXLtQ0mZ4nvPBPlhmbz2ZI+AMrKV6DZrHhFv1I0oHKmPQnVwtj7tfi/z2uzDfbNoAc5g+TvUaxOkhZJAATCLYlxXxyWfiW+kzIrEVQAfrbjB5aoH8tgAUgISBd1eR9YXdnLTwFGPS258sVWJYJgjKLJYo4Xw0VVhXA/hpVg3dcr90XcgJ0qhiRh8E+WipTLjOCSNeodxsNidgbW8lqv8Zio40VpWNSxoPsXtk6BHzd+2ByglHB+SvAQbaBG4/13UjT9AXZd5MIsBmrdNkHbHhkb8Cbz9XMVG1oxym3hss+VmjDCkB7oHMwGrTifnnBt53/i+w8wIfC45b7y8+o2JQJYpt2PUBqjovEfiEq7CnINvCDvAb8i31/CgwMemv50wOhgysAvnJG0AOYLd6Xj2zjj7lMkNjHm1dbQllLkV0xDn4bdhknmo+ktmbeFIl5PosWRC6PDvJTEc42cmfwD47NqsMtR9SsxZPXt0ULFNjEfbNaUMIL59Mj8uwKo7uyrXQDy1/yCCgS5izfKQ1fB0bAQ2bc92Ms0toRM1Rvz6e1CdM5gFLRyqr7mihNAqwHiSD2NOOa0i83amrf6ko059lNymRefpZfdVcCc30LWwkl+uUgsUU/a1Os9UknPWn9ZYT93yc6FN//vNjf7nnueEwtyBZIacEvloVdeLHRoT/4+Rf8BaKGtRgNBMvICbsB99foiImRb06UNV/t//KO/7wh+AYTvixDrSa87c5Faa3wSRHPgDB2uGcHfeyo87rxAyca9VohganUuoSTPZAgnSICEYNeCQZZQHl9Na6P/7T7g0c23RlhsRDfoVtKEdxxej8wUbNYJIWhRycBeBlkbREtvh9Yx7Xc/IB1Q23RV9QOmdP6Nt8D0p+R/2U7Fp+HpE145EJb8ZJcG8ZxwSWTKdhfK9QGXqHpFv1mSGDhSssMMpSYx0Bhh2nbUXDLBXMwZh4GcQURzzBncWBLsXCnmTp/0UU8cLawD3iC8D3RctbbLPRtn2NPaLihSjQRqlWQ7FQb79vSnZGzd1lzcov3Oh9fFUKatvV5CRNnMMxkqsEG69gCXsUOTvvPrrsgHba+nxwP/y4z7O3DAWXQQn0pW4bc/OqRpU54l9PRCr8wAwenuNsV0AtruNKjJ74PTn4VobEMAUEt8f4bRJOfJ70WL5rAwyhAKuvdrZm5bXi5LMMx7Wr49HPbrHuZ3S5liLitoWYdz//k837BUhakIDZAVlt8+EEqL70kzgGijVNDHn+UZZ2YCs9Xsl01tsW82U6wb98L64783gaQRomoVNixA9gnbgmigxevvByGNdvLtaz7e5C9O7YKlF6GTSfS1K1uZGthMuimVXO3zZGXwAAtOG043S44WIi14AaAy+hJTmijdbUNVFzHfo7GSxa8GgaCS/EykJpqYUe0TtgQNWsHeOkd3wqBw43V9rJJA3E0hHoHbPm8xQsZtrpvOSzvk2a6UKMxujKAY0EiYJBWBkPjzK2cepKVLKBB8K1rQMpCMdU/bB/b/uBnw9YFv3hatJnFsokAxc3BeRf3r9buRnftdsaiPnbdBQtRco88KLx2QpMttOERrlowXJaL5fIr4ltW4Cf4KysQBFbTwvVx+m4NP0AfZhJ3RB/JfontF65pECyCPAM7yQ6dvIUJIduOrdhWuG8bXo4+dojHiZ0lbDI06ZUTACcaiC3bCYUkA9cACvMGl/JcGKbHQkT+FyHZE2CLbzsXhuGhSJ91pskcBuQeMPq9y46BvZeFETxw06HjvLB+E7eQwpkfg3JGaxXSxD86ocMnqVCc+7HLOd0XTHPqR5LJKvYHDxP10yCGYYHzKoag5A+1YQUep8dgTB3+YevGN7XI73dftjlA6cqJM0FU67BKp35r1ew61c8Mvsh4/YCBqMlsACDlEWAAwu4081V9m2w7n970s/e1/BrX5m6GlRqLgK2p5owe+M3aUlNJFLSa1YDeG+wG+VvGY77H3mA0kKd5gFVfivYMTsuEOyK1oy3hFQOadfjW2e3bJB6odwPJrmJVSmODb6XRvcBnrbCbnZXw3W7VkBGK7NwI67QFotE1K9AdIOLHNhV8/zTijE18bPJHyHl+8DOSZvkb3qTZ+XBqtYBGpw/8NZ7P0xkH2Xk/L1h3Xw6jENN+057JNnQkxYg6GBnQAY43a2fa+b11xUF2DXYAUNp53pLV93df1tWedt1hW4DxY74NOsMNIIwfbnnWhBWPBgQQeAPoFdZRmpjzTSkOnSlU1NgsP5AA61gtK8bHNElrVpel/zBhRndr0h58ANpnWXl/9/ZKXHjYeKoVrxWtIQi1sBegY6g7ooAOgTdfdNOuNiz9acQ9lB1UbTvLBzEAh2C5XyvV577a+BWZDmsPdbtmxgPmtqAZ7Z8Bj19V8mt1CAogo9sF2rbma6Q5P14I0bjz04CcvG+ypvgBtX8FDWT5gL41oGGPr/uYqbqtS77NeedWOg7IfPn1/qrxh4Nc8DlPHIYDpoHoz3QDKsJqutRgjMeInVWtppQNkthinnn5+Vw4BTuRWAucrCJqtBN1+U5hEm4cB2APLN6m3KgCqL4qU7cF4SiIUUBznle26v7rjrVwptOvIjtuyfg7sXjgeDAGuG3h67CjuORiNQO0YusZ0377hjdcWCKM1MQs7Ra4K/cFaCGbgqKTGLTUYbFI9QbFfkiV7PCJoCNEr/FJfMKKF5adl0IJ2UtcoDNLOm+Kai5z6acFHXsN9bebxXjMtOMC8cL57dHt9WQ3woUTscpjWesIW2PvQOoL07VMctpmjpG0fAT+D7RfWeUwiYAXehxK0FKHJtcLkNmqeSqw9v1AlF47yRquxkhNN4xgebwsOeiX+NfDUq5TpetbPjZj3eWylektP6lFgsHHxhLi9xO2BUn/JrLPAwwj+roKqB5uGRdmnhR0hH3o94Vf/LajvngA1te5Nm9JeiJMt/lIa/VQ/fbWdTuMBvCV9OWgMEQub9tg+8bTssvRxgQw9On/KFzDfH02wjzstukns5qsXxBk8X77APoNwZ4ig41Dv9Afq4riZltfEHJI3Dj5imZjWDSgxZNPB8k7eUwb6N5k83EC9J7YJtbiTlc1xLbjEcTXCobyLHN2mzV5OuTOMlJ9X5z2GJQT24hAAWMkCbLCDoAZtioCJm024QFvl2NqDIaFU4sMjgcowmZV93UyNLxUsDSjn/A9gNEeRz5x/R8+MjV4jhVwBE229Ql6HITPuQgTmvSg7TEuluOEkuonAD5YHP/QrV5zhAvCbDw+ATxZ7i7EwjwCcDAeel5nNfQOl72WNVvLHnW23jjj55QSSDDmNpiKrKe66gR0bLlB+OEqBgh5JJN6E9MA6dawLWMxWFcgBsY83Fa+N1w+ZAbbNLuW6bNCLC58VbZQqjqJB5cHAgK2hw1gtyYkugv5sZqkT8EMOj06SAyi4JgNi9bgQxnlAknANBCLG1Av9ujIGRDxuwLi/qHzx+Y1aR0Pj+0zPlUn2w6kQOoTpvPDJJtY0X1tyxfgncXCOEztgIsAK9H3fqrRC7ohcR/V+n58bMaBQL+eIFnYp28raws6AGoLq48VAodfWlr9EtLHS1h6+J1F5gbvv4iDdDDbAS9zSHYysk7oABAHrAAVxc9z9RHNK4MVywtwGMEUB24fK3SfyUh/XVN6bzD2x5XGL0LAClxn2JJVa5has0rrV3Rz6l3/7cvG0HL9by55/fOa/79d8vqvHvP/zSWv//2bs7yoIiQ0YG5va+KE0if6kH4LeTccn3FIJz8sg+z3+I/L/CyHcxB+tsMspe2+MPegnvff4IBTu3z9+9cNHv0XL2udJOYFNd6Io51Uuf1o17LM9AuXQ1ugZJgifCdW0MLnPj+wIhwph2o8hHWwZO9TFG1m1CToh0QTuDWrNsvV3m0PKfbwXN++KBzxrK4ZoGZVsDUeD7uwwpwOvUGZ4JHLknj0Rkhs6Ob6bOb7rHUGW5SBZdhWgzV79DseaxsU/OIx3VZybIthb9uBHP0RsDmfI5Qsq37t+fqwzRlsiENExZJ9av15LIQADfM1TMoChmrP7CfAAn6GmdjE6bSD1C8saIfDtFQCjO0WjjtD7xjON7zLrjHL/YJxNScg7QDgdvrM52w1507ACZpgFOWHCsOuog2reOzP8H851ZrRBupkmfVndaLf1CdDO5FKyI3J0u/kti4WC4MJ7tqwSCiCpsdwdLF0ydi5fvfOPpwzYZBA8QkIyC4l2yACHiGYp51n9lq3lX7cEkMpxbQqxgd7TqOFJXquz0kfmdGEAdz1cMrHmDwsHN6PiuTu9p9CWMTxw2VD7SPGZjyuZRUGFyip2aw18AMBp1KBR1BExfCbViA460MOtUwahVOfG5zfxg4nozaW4S4n7SQLGuxUj+AsbPNtRQq+rD3w4yvcgoqSwQa8TcTx5z8Vo3ssidZtYMOxpH/9zfO6G9XJfABrKOd6+2k6ZYsFKjf7BvC0VuizMsQaVYA8kEai1E+v/yfa3WBOmOSLTzy7CE/8eDUTdIojqMnm844ogc5ibaBB5yXsaf8FPgXQB5JuxrTgCpK75LyOjh9a+8rYownKf/Kp1EgWPycuER1jgxqnWEyzBOdCDWvYcU7g9Twh3RU+LFV2TNaFlCc268uHqYIddF+DHZ2+H8AGjJYcummFDR58dhOifhVD4rgZNImdXJdRIhMQoJiNXH2vpDnezr564X4qV08jA6adWcW+rFScFKgDDY5Xm848Ktmo39dOI9d2Lg+yDL8Qm22MU1b9T22tg5zA3NzlDmXP0+A2sJmQKGu89rp0q9AjOOZGJey7GMAgeJDBMrG3RoDXWc6F3fOkuk9x2NrPmTlkrRFY5nLShfktLrDhf1giUKw9ro4calhG7M8wCgQYSh+6D21h/exbCfYJYtc/cyAXaBL/0E9S1pCVLsFatWLOz5RDwVacUYf9OfWdIg6zQQsAr7krgIQSx3VinLFYCdrvVco9fG3cuHME6sMXigGtZAVAfD6Qrz0s67SPaKjGr9QzXTarZXYBO8JtRsC2d2fg2a18Q1bteUgdCWdJ4VCAbX8Y2xkmrqZN2PY0T2S/yBm7BuF7Dx56N4skQ86iVMSu2KjFn/doLLJxNiNnp6Mpn5SMc0CQbJhqsLbvkN7qaKT1a80F9ZnYPJM5WjVdmiHhnZ9vMePnwlMbiMbZcn2PywQe74kvNnQ52sn+O53QcVtYAscEap4scj2zw6xzcziF0xjOaw/RKdAP9J6jypNY52U31QjlQcSxTrEky3pu72+F6PPsWjD8Trl7LSZrtxN2HrjtdafjD8w/rz2jtVHdyHJ2hl9uzncKRULfT5k9hnjx2fuxbPiZhg6c6wVd//nXeiqbHcVh4edn/wX6obIH++bLY5Pxd4vpHXh1higaHrVc00LCni9XJmELM/tubLLbO3R3jI8inZ6+knOy7uxkpFh4G2AJBio4d+pGq86OL9mRPdY2CZcPUApsxrIj7NDKYEkGPhdbbVHrNIr9vpFrpvYacsClYAZRZBzeZYkQJpdfxtjw6ggXpDSbcIxAGkGWyQMcE0bWGUdLiet2LyK/qZrDR/ivHt9jd4WDeVvCshyydhenFjqWYtsD8CC2GaY77aeP0bGMFifaAYxwwHn29STFyjI2QzSvRaZWtFnZCWM4CVUbHxzXN/MNI32zNXxs1T4zG/jBbunmlc4wP7uTLaFw7hlL557j3nSMfAtDYeUsiz8/y5959OeMT0TRq2lATEm4Fo6nI1yhO2/qPUmJ9Swsmz2GTkeC7UwsNs4jWryaLUaSz8CF7DGcJrXLd7GpAdEcfBicBSbAe7Cr92mBgJDgzszkDMzYslrDMkzYCiJulGwYYajWKF7R8ZNvShNYZDL/Nxcysqn6KA0lpFudnfZ8ngGgb3ROSvugaxjjMHrAFkJF4Wu30/vMigKgH6jqZ0sM2mwr8GOszC71YVL2sfYr5I7W25Xi4FoMfJ/9so/HoW7Q+fKcWAK2HngFFHo6cmrLS3RiDAbvUDU88IvBssDTEGeVQu/2Xv9+16c5jLKOv/c8fYbmY/yXj/76sv768Hut99dW/19+2oo2m2Ycs2E20Xm8uM99O9RgRIxLexzXYnEFFg8nsj4hpyXb+1ENYAsZfyBBfMdUuvljOkutmjUByiKmxcFfr9WaVeL33dVqJdCQPPqHjeKfRMFpdBHCG7dazahsMqAENEh/mim64chpEgodxuU1h8o4tgtbaxcMLmVbxBrARsvedWcUmVd01IdwzElsgFfnWXwvbJg1ShZxOnoDVcdvO5nF2uQHY5f4F5Q4dIe12gznFIW7Cg2RHT6zbKi3cve7Om6kxtjdVEwFNlahtoRxVkyiqffdH5NhwBUwy0QHTvB42C2Bp8r2Z2KPBtuGGRyOtILyx9MyPH/VM/uzEFKJF9CeNvP3hy/tMMgsO8saupPa/ozk+X3iz/efvy7X/345nEL917v57b/udf1u9u8X+3OzYZv7+4A5wVo4GIC5ftYJeuu0AJnQQcDbntefBWnlv7jd/+3LOXXpMmgJKmGlLTHFBmlfIUafUoVXhhXCX97z9daHxctDahlP/NFRDTgt0/Sng+Y3XXSV+09lJk9wiskQ01OyjHM3Dv4CcEc6UT4H55n3huFaHxFQ2pFO2WhzuFJCmUB3TlvqjrLU4RzAP7s5qZMMgP0+/TPbZrevdRw38Dpeu6XtuBHs2D6r0+dZfNtK/zzs71Ft1XPSb9RlOi8Qd/RaZffYfF2uUuuYZ3zUvE+zTNoCMj02S/Hsrk57yANoBPy5naWKAYdARN1W/cfcE5D/fz4JpNshKdEZ+dBua3uLIdoc0XVnYBQ0JFn3ZJ3KZ095u8BLvqweIr4iHi9om8nEbyZTJ3zMNiV8W0Ng7EZXdEaMzZz3wNoKjK5obMFJmNb+P+ASp5c0p03MFIUWk/foj6211XG4IQGQMTHxVGng24e9fWVcj8PEBtplFBioaOU8fj9hknMFa4rNy+hyhd12cZzSFBkkEB7otI6Yug20l61V3SYCPn1M1Y0neuxm44kivifwonD13cNrtPgdCbrjqt4OcVb6MEtfvYzznq6zxypHUKj1necgCexKkH/b0dQBGdZJYe14TI+XeDB3D84XR84SLVTEdAAOyEjlx4IDca3sc9zFsn+TJcM3dSHCVga0z8uSQG7sSIR/zCfHHTmkCcC5CjzewYfgF4UkGvA3beHIjfA6whh8UR1uBr20QLI1gKUzX+1rtu3M+l7Ao51rxr2X4RCbo1aRkbXxq6Rwtx3fhC1ZjrbsNt06mrTZJh0uxx+EhH8FIIICb8e6GMk4JYoxOxkHMHUb4rRracvGrBh6PWjDgn0TDEj8hYYX6bMJWrMYC3L18GJpDIcBYbd/M6DOfI/bQVpOYgNQSHYV7weZ321dda+TRnekKpwjO/d1OEYkvo4Ddhj+GcE0nruyuGc2FoDSsrE79ZqlWOWcwvDunOY4Myuzg/GBawri49zmM4hklF/hnobUmIUsHwPgzCzTShiCBdG/0EhQHNTVuTZCnLaPVev6uXQ7Zv6MeV+2zfISohdrYVt3IIKlarBKQOjF7jdse/JJH/kx9+njcdzctoKF1TeSbwGUlsiAFAr8mCObpoY7tAcoEC6P4nA6huUMp1RSZAu1/ZVMvGcy7enrd9aVOenl+Q/QQh7tpHs63hY5Ydfs3Oe/ZbMiUmSgWC4D/MvRmjiHX6D334kr6VJMXrZSLFgK1isis7kDj407OkwhOBiuQHvCyeM5oULsanHaYgudFvBt3QJ7KkVvTtiS+Fl2s65dm001wRjP5HmdvMul3pMbg0A53W7AODqIY9oLEgzWLHvcsjK6MzAA8bo8rWGiXsVhPgkEbl0wGIGfeu39A+tH521iDr5p82MpghEbpO1SbbaPagIuPpHnNKXcnP/+AvdZUZOQ2Q59FHah3Eu37byQVLcQ0K4JGNxfY6sQyPc4xX8bXSU7NgB5B8dQ2BzCl19X3cwoPtECB18+QU23SZb3Ql8w+sWuJ29nHawTmCs+oTkY396Zan+ekRhdq139axgyfS3yP2VMd7ov0VZl2526ZgsNEq8Yv6fdaTk3xvOFwq/BHqYE7F/RmhSnO99GffcJn1xo9weN+DyyBWzs3MtzpsiXnmiRqZ0k2RdytN6/JINt4Pnn9KrrH+OrTKDCGTNcZ7G5Dic0/GXztOc1FCv1+M62JgZPwQZ8TtRxIjQOMbWrBAs6YMPfV/K0YQ7SZ9Q1sz0Q4rU13pbOIk/wXSEQK2prEtuKympE0azLmcemim6MqHPQUSxW88XrYau1NdGOu54zMoB2s8AsVrHbGGxg//hI4wM2X/zEbgWKdubzWnIL/ww4rXLGL7/AsAaYFZpho8atMNYDZXG2RlEQPlBLuxy1ZW8yZHpbXVxQ/SBcypa/s/+sii0sE+VzqInisk9SzWBxc2g4Oj430K8ty+ntGJyW7z7OuLTzFlKCJPdjdrGY8j0EFkp4W8gW7S0vdjVa7vaOK5Zsl5/lluZbLVpHsOpvsuFtdGHgYvCdGvcZnZdTnIyQ63I9TwJNYAin/ZO6Oxld0UNUMR0a4ukVRtqGEwahqogbzgQD5KDw4Wwx4JKjVDwm5DK0/1itCTM1huf8V4wGrATqYD7E6gN+2qkgHn6w9m5NP2DGHnVPIzjLOV9GcwVaxc4sXujMViyCYXSWl1/Om61OlwzmMT3IY2Jtbq4MjipYaRs7W7ySJcwWe3gST7ddxq6ZzwJB57872Delz2KU7qBoW5R9wAYQ8ZAJjbrzvL7L7p7HMj9r/e1Yzc5tBkLwAjdwxG5e4KTdcffnDBR727Ns1+kkgKllFtSoH5LodHeYPU40Oer6Xo7d4oGqI5QM6zlVxlZOAFWQhj9vqg6jAsKMAZ5BCK8cq1Wjx8rZLfItp/KiAOOMdDzanfp60jTgmAqQozjUyqbFKDco44Tjr7gdNZRAjsah8CGaNRv37PW30vacKuAEyRK5Pe8eHgvPDXO/4bR4nnkWF0iMa+Nby4B0z12trNm2nzskJZj+B3I5u96hP9iMdiYuA8GrU0OAATrqWfBr4cnG+fc6RX+afFblzAFwhDl65USo8foszalc1enHj52cE/vnRvCCkJrPSaLdCb22w/MGwegh7BdW/syFFYqZJWvl1rw6tN7DESAaqKb9pI+TtuO4TkljPiNteXUHERS7ks4G8Mr9zIXUTO9Ty+GEt2K3+PK4BYBIevFv0IPLepd56tispkAFsxl2G3iT4cV0yp1ByKc1rhebGB9r2EG+iAYwrt5ncP3Fatg6csTZeq0j0FbMmidqv/TJg5f/jZ0+EYpdBybC3pu/6cAFNMhOrnAoO98Y9UFp56+t++3hsx383y553MW//BT7fv1TqJ73DhWc8ZtfYrFr//dL5p9X/tvP8PQOx57rOm2T+0adsRtSatDFuj1mAScd2+nzX8tJ1rFgXu/8pjPO4HZGnbOj2jhveP1zXX7vKEP9Pe//7Pmuf33AfzxfBAy1VRym+8AT+2tabjvIymrhQ1yzhWT3hHgHe+8vJ/al90+b19EWDGhoWH/ke+UzgjwAdoKRGnb9HIjzrC+fSjqLaCNQ9JkXZqZFB/suo9VnMvj44EexvtnofLUksZ0OigeNxFnDRDy2B366fKL6FuN/OMhzRoUz1VyaNNg7QO/eTp5j9e1XrLainwppiEUDnj8NWjr0fc14Ccv3XavVX5v091tICa7zUDIwdwtOQAgTkQd/YWqDXZvYk9cRBmU7R/gI6c0amWt5DEzv4TSzwCqistYbBtN/NoENcUXVvwWnrGEfv347FNQRcJ408a5wdY86+uxf8AXOmFvLVnfw+J3t6z6OvHM2cXV2JZYEYLuaCneOH9inFiVflqPaTHxOfLN1INjCbwIEPbf0fvx65+B2mCsskoXRxepQ4+1Gw9KRK/v7v9uhIyfbys9ZBWjfoqMZrC2wWT2fUyaH1XVO//8zauWcJZZxpe0t8bIYxkk53Qm5NiTozV4jM7gA8e9X86/yoQAqMq+DewL0JPsEuANc+nGw98UKeJlt7QE3P4Oxszd+k4esxN4hmCF3Yzrdosj8cZvxWFzuXIbjx5D0qzvGcz8niKHvrTbmZLPibMwZMmqzTgdaonQBRuno3f46XdJumnDnCcVtTqt+zVDJHeMahjyBdfamOEjQGC8KgVm+27bcalqCOU5eEDfa8RPGwhco+Kr1zIaYQqTmCIO2xuNJKfIKm5QxIu1dHtjlqVFG0Iy/A/KcMxVCdgyEsRGWYY1iAytK48QA542bC7YLYNtJ6ImYzdPWKjimC10diresK3De3knIwWnZmNdYzatBxsFBGB19ZQe3jXzOFsWFhXPgmAHWRzDklOpq/45TBV7ISgce4zlXOxryZ/Sup2vAdxOAEN4IbuFC/OccDQdcPL2mauNpHpZQYQXqPnX+sNgz6We9DjTBvL4OEJlQ/WWB97ZHPDnu1QmmA9KP6QACdtYDacJprQepgEJg9AKIJTsXZM8HN7lgJU9e6DY4y5Y+bLTHUDRPWzKGHHjGx3JpQfZ2wBikJjtEbn3OzbbH7A7b4JPRFdTW7rllzZqJw5FstDvb98DZPBOw5Wjy39NV2DU73Lenxlhw4iGsOznzFvAyEB3nzNgDc3ucXC//MgvbwqYy/vTTrr+Zs5z//q1//c4Zmmna0IHYw+F4S9SQznlsFjJVqDkgy549J34j1/Ec1VNtQRunrgYhTsnx0JbcIAjb3rLVFp7f8ezDacT1gj0D8nJ0IMYpbbJL5T0ZiPkjduCk/+7rG3QKCas9NocpsJo5QJ6qc2ZasME6z3N40WtINWG7nj4d63pmTNs0dQpImxX/AG8e+YkXFsyw8TY1flsN9j98pmKffBwDmrWOq0q1Sq8fEJeeFxKAZQ6vhYyfB9vBAZb71oKVAl8zcOtJTXZ5PE4ZxoRX6yKA0m1D0W0yd6bSiSLXX2TYs24MUni4nmMh45lYgpN0rvCJu+VwrYV7mVboO9oR8Ziv4YPqqBcwN9t4nj//6a//DQa3mesc92Um6MhLvI64HGFh1f4pSPHfvi593bqqfBD/a0GDVYtWmsAEeryK3SgA8wq73sXI2FqeBwByHA7/dCYzbM05dnYkxNqCniOY+RedP5KhCIW4NdrsWLIYf8k1k3Nj2V/DicMmvA/W0I2KnKmrwVrn4rFcFlI4IeWk1a//Nq/umXb2Yeu4UYczkAoG4lQUyPP0EKUBWhSM48PyJfC+nUxgBbfRQKegren8S6OZg813qLeVLvs9c6st09JaaE/Dm9F9QwYXMKMDTCQQcLJuIHKhhPmuTlV/nCNuB2H9nL/Ez0hL0jnAzkHoA/59g4bgImwhO3XnAupo5n0/R16BNZwUNk0GdSne67wLRJA13AZrsEiGrz3iYIAsc4cc83OmL/s9SmG3pmcunBpm2LVIBavlqZiIPI6SHfHcSKg+TsymrVGHuYjnwoABcYzdLNSgTUw8rg/o+S4L8Z7Htuni3NxsO+3noBgb7ywZbnfBTBejp/B+TKanAVTrhLN1E/Gc3gOgvHfFcH9GHEBiWFWLWIYD47dDMLn167lNsE7eBF2zvB+HetcKBnG0eP88xI7nNGcTn2dYZ/fnyCuPwoHS/s7Iargow+XhHJyEq7H/+3MMtuewNme04C7RYKRofRUbwSWdU+QYzHJyLa9hyAzBBe14EkOul3PHW7WXwnltrO8HtkaenYkllPtzGiOgEQ7x07xPLO3QhnedzjlY50T7b4PmOx6lgf/9b37UoHY98YTqJJXiaWfBTndW1MC4U+6snJbme9Adgv78ANWNtJngG8lMCVzdmwHtHAEzzlGRq6DYoDGnDDf70xMwqYKQnDX7HCLtyNK7fdXTOz059cx3QfrrcDyDdrLALID7DlD5KrumxJyIiZTHs188ZQ/k7aG4w+H+wSFL8T7BlpodvgeKV55PdvBrTqqzW0xo4PS64cRFD0etQKK6PCPS8Sxdsuyr8k9AhVU/z30aATyf07p4bEnv7TqJF9Clg2aVieih5ZC9R+ovB7DBAodQ7HAo/VQa20Jl1Q8m0HGJSN1bAKNrnzMnoGBB/ZuO/BovbBsDak2dZ53YloviPAGi1P3BdebVojOew4bJa5fp/jrK40QKXMzzLD3dEgkJ2u3aT/YzdrPlYGgwFJ/Jf513Wr+T+2+XdYH3OdrHBK5RTMu1qoniYDtLYV2ANpDII2J/BAxkzFYbcwdl2iCYEchTsW898fAowHlKZl6nHjhQE2Vzip59yRCdfWutv2jF7j6NnNOBdZCvjoXsv4khy9EP6V+Vwog/MBbz26oHmoJaWcEDnW15lX0X5zx7CoMTb06x2YuuByUVM2w0xVNuYrAFrVrp46ktkAfrGf/2ikeHjgZd9zlCptWD6IsTKoKZivvbxTkYcXhgAYTUHuvX8de5eA4ZhtUU+txWiGDB38uWBCdw2Wt76v/zL0bC4tZQf2Xp35/3zviP+DpkOGIbYrnlZf10Hq/Lg2XQVCfQTH4YxFqsT42/nhYc1frfXfrkrYKD068l+LZtARiMOFrdhjmYx4952NA56Q6/FfRX5outzEPzDVxCAYPtOibAL32CgSeDjY6bDx4PgGLCcs7ZwI7AfDzpGLV501h2uKfbwfbv8a3gW6hWHFc97WamdOXyRVxczS3of7cVEcOhwCa1C47Kk5A9ZmMbgBqeVXsLukywOHIXLCn7i6bcPqctGtMsQUp0TilqJ6d5o32mIx8nV5aD5hH+aINzmPP6pSoFasH0tNOf02D9lqN3ndEb4zrTmc2stTOYzUDf44mozh7pJy3zomvjNt1jqWJxiqOlM/yY81MqK/UApR2mWW+PuwRHFDtcABktgfde5yK3P/NqeUiY8MnQzNSdC2Se+H4wALueSPGMu8bkMb7ZDBeOunqeFMzQMt14CmG+CwdWH+cCvmU1sA942n5bz351vMA6Y1w80exxLk/+dVM8f87VwsBtT64BdF1WTNuQ7/GArLOT/fc5HOZ8tB63PJonoJwITsC7r4ori556+p1Rqx7MmOD9VrFAQJ0XjbeyiL/8TS09//uFBMfmaQpOdTQEZqODSfuTETxDUC9MjGbZeQfIyG0FnQOmHHa0Tzqt5N85PtZdFaes20H4n/p/6UKdo/CdvP3fK83fZvAWRHLaBT3l7U34xVodTFA83vJzOPn74g+3Z/nwo9pKeIhd3k6UCw59y0iQ2438VKMr02NVsH8nTvSe07WhCj1YDconrnhqTZDkU3nTnZ54syLowLzPIQOj2W6JEE8nKNp8b3GyIbbyODkZhgDoSJcNLtaPWTm2hvPhksfkgaEfh8MHJ5a/ngr62gzdnO2pL3L6qRWYnrWBvEHX39fjw8Txj/N8+RmnO+CIdaZW7K7osM9u/Q4O+wZ2O3r8OcVyeAB2aDpM4DohFAC5+GU62gFg5bAgg9PRU8KDxxE5/MzDT6ythOx78t3yaDlIhAKS8P0/0oKcN1NigGZD12E6rcaJ2q+NDin88tH2bifU8PWcKSutceXJQudQ7stcdQwZ1m+edziuYt3CQjvRDeubK5IxzxOTw32WOTAlox8k0euIKDOo1rMSkWXdTIFI2KlRDJn+Ciw1TM6e3tFDfK3x7RaEbuML2GHkdTv0sTnZ689k07nPIXMe0pDFaGxrGyfVhKkf29lmEmjPS0ymf8zj/847Aur9ZrK8C1OBeS2e+PxrgbQmpJ4hnkXG6QGN1VniFiZh4q1mfmx1xKfbjHQ6WKZnvzzbwVO4jTeefB2v3e9wsuaOnrRozBSVw5z5TA7Ahvr1g9bvDyXDtXm2WJaYptkSAozmOtHfE6lN4QGlzpFGNpQA8ywLHR613h2i3J5qs4H9WM6rlWA85t3Ryxh2QGMMnj2mDx3QUB2cWyyeluZtLHgzceEuO5DWJCOstl1nwiw22/O/y+e5gvaNTJdltGM5kcPn9I06COJ2BoODYhTNZFvrOQslLY9yaif5x24aXbHxqWneTvrOZJwzRtXY7WnAVkxgEuH1/tjdjVLjA6tDFJMBbq9/h2MhDpHSXEHeltn9mM5RWx7AxL7ZG8u72rihqzYcubH2l9UerznzczS9DGenM7apWfNwCldW5zXf93R8Y5FwmdnGG6OAnvsTz7HfF+TNgjVLS5r8IuO57zw8dCJj6RZbYCVFEh06+Q03jX3TIXgv+ZBdp9awvx7eig2wEMaKJrw6T2X0dFp3+mXrYT8uCMHCuZfloR3Yx9INZT3ugMnTy01YZ9794Mnu5ZEYCIBzRoSkFm+JoLfF3Gdm1hlo7RCwus8B31a7lPZdAS/Z7M0KTtwd9znsOVnTtDzBQjV9zCubEnS4PPaeb2eHwlb717OnFfe+L9ujHT+F3mVP3+rOBvDcP/tXwnMOVPLQGA9xqibg2F/JZvfIeg+twazpf65zLCrI5fr/ApYTqA8aJerYAAABg2lDQ1BJQ0MgcHJvZmlsZQAAeJx9kT1Iw0AcxV9TpaIVBTuIOGSoThZERRy1CkWoEGqFVh1MLv2CJg1Jiouj4Fpw8GOx6uDirKuDqyAIfoA4OTopukiJ/0sKLWI8OO7Hu3uPu3eAUC8zzeoYBzTdNlOJuJjJroqhV4QgoB89CMjMMuYkKQnf8XWPAF/vYjzL/9yfo1fNWQwIiMSzzDBt4g3i6U3b4LxPHGFFWSU+Jx4z6YLEj1xXPH7jXHBZ4JkRM52aJ44Qi4U2VtqYFU2NeIo4qmo65QsZj1XOW5y1cpU178lfGM7pK8tcpzmMBBaxBAkiFFRRQhk2YrTqpFhI0X7cxz/k+iVyKeQqgZFjARVokF0/+B/87tbKT054SeE40PniOB8jQGgXaNQc5/vYcRonQPAZuNJb/kodmPkkvdbSokdA3zZwcd3SlD3gcgcYfDJkU3alIE0hnwfez+ibssDALdC95vXW3MfpA5CmrpI3wMEhMFqg7HWfd3e19/bvmWZ/P8a7cmLw0XxvAAAABmJLR0QA/wD/AP+gvaeTAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAB3RJTUUH5AcCECQSR1/UMQAAIABJREFUeNrsXWd4FFXbvs/M1nTSEwJJqEKoSq+CSFEsKKJ+ooCgiIrSuwgvvSgdQSkWRH1FRIoFC/KCgCCCQiC0kJC2u8luyvadcr4fOzNsGoYSiuxzXXNtsju7M3PmnHueej+EUoq7Vf7880+MGDECf//9N8LDw9GzZ0/Exsbiq6++wtmzZwEAGzduxOzZs5Gbm4tHH30ULMsiJCQEa9asAQDs3bsXI0eOxOnTp5GYmIhGjRrht99+w9ixY2Gz2bB582YUFhbi0UcfhdvthsPhwNGjR2EymQAAoaGhSE5OhiiK4HkegiAor4IgQBRF37+JKIrw3Sil8iuhlELeAJCyrwBAKSXS5SuvZd4j586di4mIiIjTarUxLMvGMAwTxTBMBCEkHEANACGEkBAAgQACAOgBaKSNBcBIvycCEAB4pM0JwAHATiktAVBCKS2ilFoopWZBEAo4jjO6XC5TXl5eXvPmzU3S71Cfrdz/hJCyn8nvAQAlhJR79dkowzAghIBhmLIbZVkWLMuCYRjIf6tUKuVV3tRqNdRqNTQaDTQaDbRaLbRaLfR6PfR6PQIDAxEUFITg4GCEhYWhRo0aiIyMRHR0NOLj43H48GHUrX8P/HJjhNzNwHY94vF4kJubC4PBgIKCAlgsFhQVFaGkpAQ2mw12ux0OhwMulwsulwtutxsejwcejwccx4HjOPA8X2qTAcx3E0WRyABXBsxKAZn8fxkAKwVYvv9v27atgV6vr8eybF2GYeoASCKEJAJIBKC7TYbZBeASpTSTUpohiuJFjuPSrVbrhQEDBpyXwc0H2CoDvHIASAih0nhREHJ5YAgpBXy+IOcLemXBzhf0fMFOp9dDp9UiNDQUMTExCsCFhIQgLCwM4eHhiIyMREZGBtq27wS1Wu1fXH5gu3YZOXIkVq5ceVudU3R0tFfNqQDMZK1MBjb53smami94+f6/b//B6JjY2KZqtbopwzAphJAUAI0AaO/wW+gGcFoUxVOCIJxyuZyp6RfSUx/p26dA0hR9QU0sA4CglCr/X0Gjo4RhwBAGDEPAMDKYMZRh2ApBjVWxUKnUUKtUUKnV0KjVEhgSqDUa1EpIQEBAAAIDAxEcHIyQkBDUqFEDOTk5aNqsJQRBQExMjB+Z/MB288RoNCI3NxcmkwkFBQUoLCxEcXExrFYrbDYbHA4HnE6noqWV1dD+QUsjstlZBtB8NbNS2lhZUHu47yPs4neWtNbpdK0YhrmPEHIvgAZ32W06J4rin7k5Wcc0GvWfY8eM+XPv3r2iD9iJlQCeZMYSSggoQEBIZSDHgGEZsAwDhmFpKYBTsVCxl7U2lWyiqtUQRRHBwUGIiIiAXq9HQECAYp4ajUbUb3APakgaXGxMLCKjovyLzg9s1SfFxcXIycmBwWBAfn5+hWan0+mE0+mE2+1WzE6O4+DxeMDzfClQ8/GjEV8/WgWaGanAX6ZoZmPHjmUfe+zxTuGRUe2DgoI7EELaAwjy3zHAbrfBWlKMVvfda6OUHuJ5/pDVaj386quvHvriiy94QkhZoBMrMm3LaHG0lF+OUcANLMuAYb0gp2JZsL7gJgEcwzBgiFczL+t/M5vNqFU7CaGhoV4TNSIC0dHRiIuLQ3BwiP+G+oHtxgnHccjKyiqlpRUVFSlaWlX8aGW1NFk78w0OyJqZbGb6aGS+vjJCKWUsFkvjoKCg+1mW7QKQrkeOHAmNT6jtv1kVSG7OJbRp3brcc+rQ74f3RUXH7i8oyN/fvm3rNAnUKtLqxEpA7rImxzCUIT4aHMuClbW4ctqbCqIgIjIyQgkw6HQ66HQ6FBUVIS6uJgKDAhEcHILQ0FBFe4uJiUVwUBCyszJht9sqvd7AwCAkJddFSGjoLRvzkuJiZFy8cMvPU3W3TXZKKQwGA0wmE3hBgM1qrXA/i8UCk8lUSjuz2+2KduYLZP8AYhVGNWWHv2T/gPj4x8qCmcPh6KbRaHowDNMDQFPf83Q6HX4Eq0ScjgrHJtTtcvbVarV9a9ZMwKXsvJM8z/9is9l+bZrSaD8hEHyBjlJaTqOT/HMAIZSIIkRCwIgMBMJQhhHAsgxhGBYsz1Ke5aFSSRocp4Ig8LDZtNBoNIp273K5UFJSAq1OD6fLq/k7HN65ZrNaUVJSgiJLAQIDAxEWFnZFLTXj4gU0a3HvLRvzi+nn4XDY/1Gbru7zVN1toHbs2DGAMAgMCkZgYBBiYkvv43A4kJOTDbeHB8eL4AQRgkghUiivFKT0RlFmo6AUECmFKFIiKpFL71bWxKSUEiqZmcQbrmOcTmcfjUbThxDSB0DNa73mH3f/gI0b1sNkMiI+Ph4fb/oM586dxdAhg5R9Jk2Zhoceevhuxb8mKpWqSVhY2BtZOXk5giD8YLfbf0pp1OAnyVwVKgU5SikFod4AKwUhIkSRQBB8AI5lwfMsWBVPVbwKoijA4XCA4zio1WrFXWG326EpLlaATnZtOBx22Ow2FJiMCA0Nhc1mQ2RkJHQ6XaWgcSvln0DtZp3nXQVsBoMBIAyiY+IqNl1yc5GXmwtTvglmsxlFhYWKH83hsMMpm51uNzxuNzycB5xH0tZ4Hx8aL0AQeMncFCGKsslJCaUiKAUBKLlscnr//+23A90TE2s/Gh8f3/d6wMz3ehbMn4uZs+agdes2KCkpAQDUq1cfP/78KwDgpaGDq228N6xfh8ce74eIiIhy57VsyTs4ceJvaDQa9HiwF0a8+hpYlgUAZGdnY8WyJThx8gS0Wi169uyFl4ePUD6vDpGOWfPEyRMvarXaF6dMnZYzdNjL39nt9u+aNWm0XwI4oYzZWlaLk4IPIkSRgSgSyggCBIYFKzBEYHmIokidTmc5YHM4HFCrNV5XhjS/3G43nE4XHA4nCi0FEtA5YLfbERERgcjISL9a7gc2wGTKR2BQcLn3bTYbsrOzvDlp+fmwFFpQXCT70S5HO90uF9weNzxujxfUOA48x4FTAI0HLwcEFFATJTCTE2i9ICabmadOn20SEBjYj2GYx+12W+P8/HzEx8ffkOs9k3YakZGR6NixEwAoC4EQAq1Wq/xdXfLhxvXo3KVLOWCb8fY0NGnSFP+ZPRfFRUUYM/pN1EyoiX79noQoipg0YRy6dX8As+bMg8loxLixoxAVFY3+Tw2olvOs5Jg1o6Kih/V/asCwrBzD6c4d2+34z+y5374w8P9OARAk7U0gxKuYX9bkKKWUUEIESikhoihSQkQIAkNZ1uuOcLlcUKlUVA4qqdVquFwuqNR2yaXh9dO6PR7JXHWhuKhQ0eZcLhccDgccDgeioqKg1+uv6bq/2vIl3lu9Ej/9shcA8MrLw2CxWEq5YyZNnoIeD/YEAJw+fQq7du5A8+Yt8GDPXtW+XhfMn4tvd+1U5ujrI99E/6cGID09HUveXYyS4iIEh4Ri4qTJqFXL62c+eOA3rFmz+u4CNl7gERgYVEZ7yEFuTi6MRiPMZm8Kh1dLs172p8nRTo/kU/PI/jQvqAk8D573DQgIvmkapHRAAMxHH3+i69yl61Msy/YnhPTydaraSoqu+zqPHz+GGdOnKZrA4496zcx+T/THoMFDqvQbhw4ewMoVy2Ew5CExMQljxo5HSpMmyud7f92DDRvWId9kQkxsLIYPH4F27TsAAEa+/iqyLmUCAEa/+QZUKhYJCbWwcvUaiKKIrl274eG+faHVahEdE4NWrVvj7JkzymKqER6O5wYOhEajQUKtWujYqTPS0k5X27yowjEbEUIaxcbGTriUnbfb6XRsnzH9rR2ffbbZCYCXNDcZ7BSQk31xhFBQ6jVTKaXU7XaD53kiBRUoz/Nwu91gWRV4NQ+Ov+yz5aRglLWkRAlMeTyeUgAXGRlZofYmiiIYhin3NwDk5eXh2107S+2/5v11yt9ulwtDBr+Ajp06AwBWr1qJ9PQLcNjtqFev/tXZ+k2aKInsVzrHsv9bzGa8t+YDNE5JKfWdWf95G6NGjUHzFi2xa+cOLF+2FIsWvwuXy4mFC+Zh5eq1YO4mYPMNFDidTpw5cwZnz57FxYvpyM7OQl5eHvLzTQrAFRcXwyqZoja7HQ67A06H0ydXzQ23203cbg/xBhE84HmOSDlpRBRFRhRFhlLKUkrZ1NNnm2dcyp7drfsDJ1Qq1Qe+oOarPV6vtGjREtu278Kbo8agZs0EbNu+C9u276oyqF04fx5vTZuCEa+9jl3f7cZTA57GmNFvwGQ0AgAyMzMwe9ZMTJw4BTu//QGPPPIYpk6dDIfkrF+xcjW2bd8FAFiybDm2bd+Flau9JWgMw+C5gc8jLKyG19l8MR0HfvsNbdu2U7TKFStXQ6fTKxP9+LFjaNasebXNi6s5JiGkZ0BA4MoFi97ZX79Bgylr31/XjFKqhTfhWQNADVAVpVQl33d5HkhzgnAcRzySNuZyuYjL5SIyWDmdTjgdTjjsDtjsdthsNlilwJXNZkNxcTEKCwthNpthMpmQl5eHrKwsXLp0CW63WznPI0cOY+rkieA4DhaLBS8NHVJKG1u0cD5GvvFmpWPy3XffolPnLoo2OOyll7H4nSWoU7fuVY9vSEgINBpNhZ+tX/c+Nn+6CQBw4sTfePON18s9cMr6yR997HE0b9ESAHDPPY1glgAzLy8PYWE1ULNmzbsvKuo1SY3IzsqWniL5KCy04MKFC9j9w/fo1u0BuFxOOF2uy6anpKVlZmYgrEYNEEIg8Dzhea+G5vG4IQgCYVUq8BxHZJHNzd69+/RZ+8H6Z/f9b+9TH27cAI7jULdePUyaPEVZTLeT7Ny5HV3v76aYsL37PITvvtuF3bt/wMDnX0BERCQ2bPwYtWp71f9HHn0MS5e8g6ysS2jYsGr1jqknT2L0qJFwuVy4v1t3dOl6f4X7rXlvFfQBAXjo4b437fqrckxCSK2I8IhRQcHBozKzcreWlBR/1TSl0S8A4aXIqiBpbYKvBgeA8jxPGYaR8xeplNdIGIYBL6goL/gmcXv9t06Ho1Q+pKzReRRz1WumRklJva1atcave37BzBnTkZOTjSeffArhEkhs/2Yb6tath0aNUyo1zbd+9SUWLn5Xea8yYLpeefb/BmL0qDdgNhdg3//+h1lz5iqfmS1mTJ82BWaLGW3atMXoMeOg1WrRr9+Tyj5ffP4ZevbuDQCIjY2DxWJGenr63aWxiaKI9PQLOHPmjKSlXUJeXh5MJhPOpKWB53lcyrqkVBLIeWpOhxNOlxOUUnjcHuJxu0tpaFLaBqGiyBBCGEop0++JJ1UXLl4aPG78hB+7dL1/q9lsfmrF8mV4d+kyfPLpZ1Cr1Nj61Ve3bZAlLq60n6927SQYDHkAgKCgIBw9+geGvzwUzz37NAa/MFAZ36pKSpMm2P3THnzx5Vbk5eVhw/p15fb5+KMP8fvvhzB37nyoVDfnGVzVY1JKYSm0ICgwCAzDPBEWVuPTS9l5W9LOnn+2efMWekqpDpeJAXw1OIZSygiCwPA8T3ieJxzHEZ7n5cABcbvcxOVyeVM/HE4lV1IOHvA8r1QshIaGQq/Xw2QyITc3F1lZWUhPvwBKKYYPH4E/j/4BrUargLTRaMCO7d9g2LCXKr223/bvQ1JyHcTGxl3XWPbu3Rv9+/dHfHw8OnTogP79+6Nx48al9gkKCsIrr7yKL//7Bbp1717qwTh+/ES88+5SbPr0c5jNZny9dUup72758r8oMBfgqaeeBgDo9XpMnjIN8+fNvns0tqKiIpw/fx6sSgtTvhEWszc/zWr1mppZWZcQGxeH3NwcxMTEKE9CQ14eOI4DIQSUUsJxHgAEHMcRQeCB0jWaZPNnXwQvWjh/8JKlywcRQpoePHgA8+YvBBVFvDFqtGKCNbznHuTl5d6WYxUTEwNDXl6p93JystGypTfvaN//9uLTTZ9gydLlSKhVCwDQpVP7irSacmDndrnw3Xffok+fh6DV6RAXF4cePR7E/v37yk3aH3f/gGUrVt20hNOrOeaRI4ehUavRoGFD3+vtGBgY2HH7zm9fdrvdn3399Vf/nTBubAkhRJB8cbIWp/jiBEGglFIqiiI4joMgiJRlRQiiQARBoIJKgCB4Qc83J9Jut0Oj0UCn0ynlWbL/7fy58yjIL8CaNasw8PlBOHsmDQvmz8WkyVOxc8cOWG1WvDL8JYB4yRyGDHoea9Z+AK2UQvLF55/h5VdGXPd4fv/99wCADh06ICMjA7m55ef7hQsXMH/eHPxn1hxs3LAOtROT8PDDfSEIAlq0vFcxhXv27IXDv/+ufO/XPb/gxx9/wLtLlpeKlrdr3wHt2ne4OzS27OxsnDx5EllZWcjKuoS83DyYTJeDBUaDAYIgIigwCEWFhYofrSA/H4IgICQklGi1OkIphSAIhBd4Igg8YSQBwDz5ZP/wi5nZYzt17nIoJjZ2cdrpU02zsi4BAJKSkhEVHY3Onbsoi3vHjm/Qo8eDty6QIpk6AEAlyiQZhB7u+wj27t2Dw4d/B8/z+OWXn5F68gR69vK6BM1mMwgBGJZFcXGR4iOhYukqlrj4eBw6eBAcxyFfomnSaLX45OOP8Pnnm8FxHIqKCrFv3//QrFmzy6bwju3Y9vVWLF2+UjGfqt38ruIx3W43fj90EPPnzcHwV15FYGBgRYDeRKfTzXn22ee+P38hY8Tq99ZGSRqcllKqoZSqfTU4yQ/LeMkPeMLxHPEGDdzE7XYTl8sNH59cKe3NbrfDKiXxyr63rKxLOHToAOrUqYtu3R/AtOkzoNFoYbFYMHTYS/j8iy3Y+NEnWLN2HTQaDTZ+9IkCaqdPnYLb46lWn6avHP3jCCZNnor7u3XHu0tX4FTqSVBKUVxcjBcG/p+SonT8+DEkJScrf3/04UbMX7CowvEH/uXpHpRSnD17FpmZmQrFEKtSo6S4BFabFQ67HQ6nE9k52QgI0EvOV4Li4mIQhsDlchO1WgUP54EoCgBAfOiBGADkhx9/Cbl0KXPYgf37hjEMUxcAOnbsjIMHDyIwMBCdO3ctZw7PmTMLDzzQo1IfR3VL2QTdBfPnYsH8uXiwZy+8NX0G6tdvgLdnzsJ7q1fCkJeH2omJWLj4XcRI2cx9HnoYJ0+ewNAhL4BlVXjs8X6oX78BLIWWUscZM2YcFi9a6H0S166NdRs+gkajwYKFi7FyxTJ88flnUKvV6Hp/Nwwa/CIAQBAELFroNQOffbp/aTNx0+brNo8qkqoec+Rrr4IQIDExCWPHTVB8kFeQulqdbkbfRx59oceDPT/+ZtvXn40bO7pY1t4k/5uixXlTQ4hIKAX1VqhQQRQhigLheR4sy1K5cqUiiiv5YWUw5KFGjXA0aNAQZ8+egcPhwJix46qU2vP5Z5/iqRucVnPgwIFKPxvw9DPK3xERERg/YRIAIDw8HC8OG4bXXx0OSoHkOnXQ7wmvb23+vDlwu90Y5RNomPrW22jQoCEKCy14edjQf2+tqNVqxfnz53Hp0mU/2l9//QWGVcFus8Huk5uWlnb6svZCKdRqNdHpdLBarTLvFpGIIAnDMIRSyiQlJbF79u5/mWXZl3/66cfG+/+3FzP+MxsAkJ6ejnlzZyMoMBCDXxyK5s1bKOe1bOm74DgO48ZPrDgieS4NXbt2rfJ17t27109QWIlUNpa3cMxOp544/tHy5cs3f/fddx4J4BQTFd7aVPmVysX2DMNQQRAU/jeVSkVZloVarYZKpVLILWXTNCm5jsT3JpFZxsSgZs0EJCcnlUt3utFy8Lf/VXnf9h27VNt5/Cs1NqPRiAsXLiAry5vC4UsEybAqrzPW6YTL7YLdbgfP84iOiQHPcXC6XMRht4NhWRBCiCAIci6aEuU8feb8My8M/L8RRqOxbXx8PPLK+A7q1KkDu82GgoJ8NG162cTa/OkmmM1mzJg564Zdq14f4EewqxybWzhmjWrUCJ+/c+fOJ0pKSj4MCwvbQQjhfAFO0uKIV4sDpVSgolSrJ/njIIoiUalU1JcVRtbaAIKioiLwHK8k+7rdbrhdLrhcTiQlJlUrHVJAQGCVyqoCAgKrdaD/dcCWkZGB9PR0ZGdnK0mBctKt1WoFw7BKKofH44HFbIFKpYLb5SY8z4NKBeretA2GiCJPBEEgAJg2bdp2f2fJ0lcDAwP7TpoyFVMnT0SN8HCoVCwCyiyWjp06o6S4SEk2NBoNWPPeKiQk1MKQQd4oIsOw2PjRJ9d1vSzLwm63VfuT+E4Tu81aaQkWc4vGzG6zglWpQAhpExoa2kYQhL4mk+nDuLi4A4QQjlLKE0JkgBNBIIJChCgqBJmi6M0akamtRFFUzFMA0On0sJaUeFNCeDklhLtcyeByw+lyoZYU9LnRklyn3j8WwgcEBCK5Tr1qHet/jSlKKcWZM2eQnp6OnJwcGI1GhWZIrvfMyckBYRgvK0epsiieeNk4eF/6IFlLY06kpjUIDg5+jRDyyq0ynyoH8kyYLRbExMb70cxXazfkIjIyAom1y1M6ZWRmwmy++WNmNOQiIiICSYmlz4njuHWpqakft2zZ8gIADgAvRVIVH5zMH+fLCedDcEnLmqUyJZIcMZVTQ8LDwxEVFYW4uDjUrl27WkvqbqX8KzQ2uYogIyNDATWz2Yzi4mKfInYH3G43REp9y6IIz/PgBR6iQitECQUloJT0f2oAu3DROyNZln0DQMLNuJag4OCr2j8xsTby800wGnIRFBxy12tudpsVNpsVAs9XCGoAkJSYCJPp5o2ZfE6iIJQDNQBQq9XDWrRo0cdut6/t3Lnzx8eOHfPIAAdvkMq3AF/hhpNBjmEYIvnfqExR7ttcRgY4X9ZeuedCw4YNr7nW9HaWO15jKywsxNmzZ5U8GV8OtbJkkIWFhfBWC/DgKtfSGADk3IWMnhqNZhSAB27monS7nWjWtOlVa6sXMzJhsZgh8CJcrruTo02vDwDDsoiMiERiYq1/1EYyMy8hv6AAAi9U25jp9QFgVaoKNbWKRBTFPSaTaV1cXNw+QohvgIGXNDdBAjRRDi6wLEt9wIyq1epSJJa+PRbkBjJyd6ykpCQ0aNAANWrU8APbbWNuGI2l0jlk2u6KGG7dbjfsdjtcLhcRKYUgEUEqWhqlBKDMkaPHYqOiokcRQkbf7OsxGfMQFxuDuLg4+OXuFo/Hs+qXX37Z2KdPH4MUYJA1OMEnciqDG5W1NVlTU6vVVG4BWBbcfE3S+Ph4JCYmokGDBv+qJjJ3rCmalZWFc+fOITMzU0nn8G2uItO6+DLdCoJAPB6uIvYNBgBz4eKl/iqVajSA+27mtTjsNtisJQCoH9T8AgDQaDSv9erVq4PZbF4bERHxHSGElcCN88l/I14lTxR9Gv5QH6p5WlmuW2V1p9UVVPADWxXkwoULOH/+vAJqcjpH2eYqZei7CcdxAKh80+UuT8y2bdtqhYSEjMm8eP7Vm30twcHBUKlUiI+PQ2xsrH9F++WyOUVIy/Dw8DUej+eD3377bUO3bt2yCSGMbJpSSnlcZl4WvV4J6hspJb5R07LpITJ9vS+1vcfjQd1rYPDwA9t1SlpampJ4K3eNKizFdOsoC2rEpxeB4kuDVDngdrufUKvVYwG08i8lv9yOolarX+ratet9+fn5a6KionZLvjdGAjVZe5NTQcpqb+XSQspWLvh2TpMB7p577uykb5KRkXFHnKhcHiUHCXz9aWW1NJ9OUcRbWOztDCWncFBKyc8//xyWmJg4jmGYCf6l45c7yPe2bOvWresnTZpUCMDjk+AryP43uWpBSgnx9b1R3woFufVfUFBQOb+bHFS4U9NBVImJibf9SXIch9TUVMV3VlGHqAq6Qvl2U/cFNcZut3fRarXjCSE9/UvFL3eYvDl+/PiUZ555Zm1SUtIRACwAOXpKUJrJF6IoghAil2QRmf+trIbmW2TvcDhgtVpRVFSElJQUqNVqvyl6o8XlciE1NVUpkZKrCXxb4ik9CSTCPVlTk01PCdgYSinj8XiGsyw7EYA/o9Uvd6QwDNMjMTGxcUlJycqQkJAvADCSeSonlZcKLMgWD/UKkasXfPrY4krF9SkpKZV2xbptTdHbOd3DbreXArWy1QRlGxbL/jTJ/JTrPBlRFElubm58dHT0BELIq/6l4Zfb1d1iMBhgNJogCAJsNus/fofn+XVHjhxZN3ny5FxJc5MrF5Tiep+8N0ipIXISr5LzJnemL1ulEB0djZo1ayI5Ofm2ALfg4BCwLIPo6OgrZhDcthqb1WqtFNRkhlu596JvkEAGNZ/IJ2O32ztrtdqJhJAH/cvHL7crqB07dgwURKmGqGJW2bD6DRvX6drtgfc6tGvzBwAG3sipTIDqpUXy/kOlvrdejY1SL0OS1AdX3uQeuoJIwQsUHC/C7RGQmJyAoKBbX9lit9uQm2dAbl4e7rv33jsH2IqLixVQk4vZzWZzhZpaJZFPxZ/mdrsHqlSqyQDq+ZePX25XMRgMoCDXVL/KMEz3WrVqJ55MTVvRJOWeHaCUoYBv3w1BogsRvbEACskCBbzrhComqRxRlcxUUaQQqRRNpSIaNmiI4JCQWzpWgYFBCAwMgsmYB4PBUGGa1G3FoPvDDz+gffv2iImJQdeuXTFhwgTs2bNHYeioKALqVvoPeH1q0saIoqiaP3/+lPT09LXff//9bQNqPM9j1KhRiI6ORmhoKIYPH650d/LL3SsmUz6Cgq8LMOqGhoUtPnf+4vCG9zQKAKCTumfJPRdYSsFSKnfLEgjPc/BwnJep1+WWeix4u2NZrVYUFxXBYjHDZDQhJycHGRcvIu1MGkqKi2+LMQsMCoZR6pxWVtgZM2bcFie5d+9e9OzZEykpKXjggQeQlJSEoqIiHD58WI7sKIBW1vyUtTQvtbLApKSk1Pr888/ndu3adcyAAQOYkJAQdOnS5ba4zokTJ2Lbtm349NNP8eyzz2Lp0qU4deoUHnvsMf/qvoslNzcXNcIjrvp7p0+lYt5U7MeHAAAgAElEQVSc2ejVuw8AMCq1uuOz//dcSKvWbS58vfUrB+BV3SozfylAcLmRt2SO0subpKkVFOTj0MGDKCwsREREBIKCgqHT6fD1119h/tzZ2LZtKwothWgpmYb5+fl4a9oUbN68CT//9BOaNG2K0NAwAMBffx3HtCmTsHXrFhw/9idat2l7TV2wNBoNrNZixFfga7ttTNG1a9eiadOmeOaZZ5CVlQVCCFq2bImCggKcOXMGKSkplSXelgoSPPjgg60aNWo0pVu3bn3lm3e7iN1ux6pVq7Bp0yaFmuj9999Hz549sWDBggqb3vrl7hCrtQTR12CGNrynEd6e+Z9S76nV6kFdunSJ/uXX/63pfn+XE5RSRkI3xTSVsU0UBJGXfG2A99ULeBKwgeJC+gVwHAeWYREREYGMjAxQAIGBgdi6ZQvWfrAeGo0GY8e8iSNHDqN16zZYvWoFund/AH0feRR//HEEC+bNxar31oLnecybMwvzFy5GUlIy1n3g7Sv60svDr2ncfHsF33amaFFREex2O3JycnDhwoVSPrXExEQkJiYqKR12ux35+fmksLAQNpuNuFwuIggCI4oik5SU1PvHH39csnz58r6EEHTp0gVHjx7FW2+9hXbtvA1527Vrh9mzZ6N79+4ICAhAvXr18P3332PZsmVISEhAaGgohg0bphD3UUoxb9481K9fHxqNBhERERg0aBDsdjs8Hg+aNm2KBx+8HJPYtGkTtFotjh8/DgDo378/WrXyFjUcO3YMTqezFN9a587eTtsHDx70r26/lBOz2YyxY0Zh0PP/h8GDBuL3Q955kp2djQH9n8CT/R7FqDdGlvrO5InjMWTQ831m/2fG1JSUlC4AdKDUt5EMK4oiK68bpYkMx6GkpJgYDHleQkqnt3FzZGQkGjZoCI1Wg5KSEuTm5iAzIwO7f/gBKU2aICDAS7JaI6wG/pLm/V9/HUeXLt55HhoairS00/B4PDDk5UGn1yMpyduYJTw8HH8dP3bDx+2Wa2xyoKBdu3b49ttvMXfuXMTFxSEkJAR6vR4y17uc0mE2mwkAqFQqQimVu64zVqv1WY1GM7Vv3771GzZsiEWLFoFhGLRv3x6PPPIIpkyZohxz/vz52LFjBzp16oRXXnkF/fr1w+OPP47Tp0/j1KlT6NatGx566CE88cQTWLVqFRYuXIjNmzejcePGOH78OAYOHIjmzZtjzJgx+PDDD9GuXTt88skn6N69O0aOHImZM2eiRYsWCrAVFhYCAHJychRw9Hm6IiIiAtnZ2f5V7Jdy8sXnm9GsWTMMGvwi0tPTsXrVCrRt1x4JCQn475atOHfuLObOLk01P2/BImltFbUZ/tLQ8A8/+mTF4EHPfyspMkSyTjkKCN4HOBGlfF4QQqhKpSJut9urxAGgoCCEgdvlgs1mQ74pHwBBZmYGAgICcPFiOlYsWwpBFBAs+QmLi4uh1emwY/s3+Omn3dBoNLDZbCgpKYFWq4XH48HKFcuQm5uLoqKiGz5ut1Rj803pEEURAwcORN26dWEymXDq1CkcPXoUqampKCkpgdvtRklJCZHAQIn4MAzDBAcHv/Lll18u0mg09eWGFzqdDhqNBoQQhVlUln79+qFbt25Qq9V44okn4HK5MHfuXAQHB6Nt27Zo0qQJUlNTAQBJSUlYv349+vTpg8TERDz22GPo2rWr8vl9992HSZMmYfz48RgyZAiaNGmCCRMuV2k988wzGDHC26PR4XBUmAuk1WqlDll+8Utpad2mLX7+6Ud89OFGuF0uLH5nSZW+J4oiZs54Gw/3fbTeAz0enHYq7dwAADpp01BK1aBUBYAFKKOkRwGEZVXgOA/xuD0+rf7scHs8cDgcsBRakJ9vQlFREU78/RfGjxuD555/Ad26laYunDdnFjIyLmLxO0uh1WpLKTNjRr+Jxo1TMPKNN6tl3G4ZsPkm38opHS6XC3Xq1EGrVq3QuHFjREREQBAEGI1G4na7JXYO7xNHzlHjOG58SkrKgtTU1Cp3qPAtI5MHPCEhoZRTUgaavn37onbt2pg5cyaee+45tGjRAt99953UOMMr06dPR0REBPbs2YOPP/5Y6XNQVvR6PTweT7n33W53pf0R/XKXA1vrNli5ag1qJiTg44824u23plbpe+vXvQ+dToeBz78AAFHBwcFvff3N9sEA9BK4aQkhakKIilLKAmB8AnCE43h4OA9RIqZOJziPF+hKiothsVjgcbtRXFKCxx9/AgQEJdYShIaFKeZnh46dMPKNUVCr1fB4PApzb0lxMUaPGYfefR6Cy+VCmPSdOx7YfMuksrOzkZOTgy1btuDixYtKnhrHcdDr9QgJCSGAl/7bF9RWr16t5jhuOsMws0VR1JXtOH5F+1tV3gKvrNh3yZIl6NChAzIzM9GhQwesXbsWvXv3LrWP0WhETk4OKKX49ddfKz1uQkICXC5XKdWb4ziYzWbUrFnTv4r9Uk7mzZ2Nw0cOo0ePBzF5yjQcOnQQ/zTX9+/fh72//oopU9/ynde6Jk2aTrn33nuHN2vWPBBSOgilVA0pHQQAS0WR8DxHBIEnPFc6HYTnebjdbsWkVGs0cDgcKCjIx8WL6dj9w/do1LgxAKBFi5bKef559CiSkpKh0WgQGxeH0LAwaCULav++fWjeosWd72OTC9p9az+LioqQn58Ph8OB5ORk3+RbIms4cvs7AGTnzp1BPXv2nMowzLiioiKcOnUKQ4cOrfB418tOsGTJEkyePBkzZ85U3svIyCgVwXzppZfQokUL9OvXD6NHj0bPnj0rBKqWLVtCr9dj3759eOSRR6RJuB8MwyjBDb/4xVcGDnwBixcvwOebP4UoihgzdjwYhkF2djbGjHoDHOdBcXExBvR/Avfedx8mTZ6KlcuXwuVy4bURLyu/s3L1WgQHB2PBondGv7NooaagIH9dbm6u/ISVo6W8tNYEb2Mswetik/bheYF6OK85CgIEBwUjLi4en27ydpK/9977EBwcDJ7n8eprIzF/3hx8+d8voNfrMXHyFEWpmDL1LcyaNQOch0OtWrUwYdKUOxvYKKXlyqTk6GdycjLOnz+P1NRUBAQEQBAEuN3epwQhRCbTIykpKTVmz549NSIi4k21Wo0pU6YgJCQEAwZU3L06KCgIBw8exKFDh64JPMLDw3HgwAHk5uZCEAQsXLgQp06dQlOpL8H69euxZ88e/P3336hXrx42bdqEl156Cd9++y0A4PPPP0dhYSFGjBiBwMBADB06FK+//jqCg4Oh0WgwfPhwDBkyBOHh4f5V7JdyUqt2bSxbvqpC7f+/W7ZW+J3P//tVpb93zz2N8MH6ja+53W7V5k83rZv+1lSztLZ8lAEGlIqCKDKlwC0oKAgarUa2nkBAUCMsDElJSYiIiEBMTCwyMzLAsiwaN06p1B/YtGkzrH1/fbWO2001Ra9U0B4UFITY2FiIoiibo0QGNZZlCaWUXLhwIeL7779/Ky4u7s0HHngAXbp0gVarxf79+yu101977TUcOHAAgwcPvqZz3rBhA0pKSlC3bl20a9cONpsNkyZNwp9//omsrCyMGTMGU6dORYMGDcAwDD744AP8+OOP2LBhAwBgy5YtWL/+8k1cvHgxHnroITz++OPo27cv7r//fixbtsy/gv1yU0Wr1Q5/buDAl+ctWBQFQCtVKai9yo5SpUBE0Zt54G3A7A0ouN3eKgWHw+E1SyWfm8lkQm5uLjIyMnD2zJlben03jd0jLS0NaWlpSos8uZuUXCbly3xbJvmWUErJmTNnatSpU+ctQshI/7QsLaIoIiPzEiwWCwRBgMt5d5Zo6fR6sCyL8BoRSEqqXWkQR7YevGNmBs9X35jp9HqoVCpEhEcgKaly7sO9e/eibv2bz1rrcbs/2LTpk/ffnj7NAsBFCHFDaRxDBEIgEMIoDWPUahXUGg3VaqS+pQEBCAoMRLDUzi8iIhKxsbGoXbs26tarj3r1qreasbI+vDfFFJV7FJTlU5M7SR0/fty3QoD42v3SFlSvXr2pAP7VoGYwGK66U5Db7cFff/0FVqVCcEiov6+o3YbCokIUHM1Hi+YtoNGoKwS1P/44CoZlERRc/WNmt9tgtliQX5CP1q2uzECfc/PzGV/q1q27eHHIi2s/3LhBWYde09RbYgWIgihSUG8xPBUEkQi8QJVu8z4klU6HA3a7DVZrCYoKi2AuKCiVcXAjpeYVfrfagS0rK6tUj4Ky3dkdDgdq166taGoej6dU7efq1avVw4YNm8owzJvwSznJM+SBVan8neAlkZkfjIZc5OblIqkChuiLGZlgWPamjZnvOWVmXkLiFfqL1kxIuBXDNnzqtOl8RkbG2l/3/FKZhitcBjuRUioSSsv3UeAlZl6Ph4PL482BI4Qg/iZH/asV2IxGo9Iir2zjlQo6SZGKuNQkUBvnX7IVi7nAjKCQUP9AlJGg4BAUFJgrBDaLxYLgWzBmQcEhKDAXXBHYbpkZr9O99v4H6z0N6iWvl7VaOaBAvdEFKpbKMyEUIAQgcld6EELAeMkswTAsWJaFilVB5TVfERUVdecDm9yhXW6Rl5+fXymdd1mfmm/yLcMwU/3LtDI/ESAIwl1vflamJRUXWSr87FaNWWBgEIoLLdf03ZLiYmRcvAC73XbF309KrouQ0GsDbb1ePzrt7AXXPQ3qbpLwTJlqPmMnXm7fx1GO8xAJ+EAYAsIwErAxYFkGKpXC1guNRoPQ0NA7F9icTmcpUCvLp1YJSaTcfIVIvQleYRhm2pUX9tVTKd9uUlWq44qEEMDp9HO5VToPK+G5u5XBlWu9XxfTz8PhsF9xH7vdhoyLF9Csxb3XAb6Bo0+eOuNo0rjhVh9Qo2U0OBEAFUWR8DxPnU4HYVmWMoSAEAYMQyCXNno3FVRqNTRqDRo1bnxTKMZvOLBRSnHmzBmlTZ4c/SyrqZWJfsqNJRiJ9fZZlmWnwVv6UelxrpFK+baTqlAdX6v8uPsHbNywHiaTEfHx8fh402c4d+4shg4ZpOwzaco0PPTQw34kvI3ln0DNdy5dr1UaGhr6xrG/TtpbNm/yva+2VgbcAECklHp9apyHeHsrXAY2hmXBMhKwyVqbVoPGjVOqva3fDQc2X1Ar28zYbrdXSOft61dzOp29VCrVVABXNMivh0r5djSb/onq+FokNzcXC+bPxcxZc9C6dRuUlJQAAOrVq48ff/4VAPDS0MHVdl0b1q/DY4/3K8VmIp/XsiXv4MSJv6HRaNDjwV4Y8eprYFkWgJeSZ8WyJThx8gS0Wi169uyFl4ePUD6vDvmnY3bp1B5qtRqEMEhKSsKQocPQsWOnfyuORkVERLy6cuXKktdff/1AGc2NEkKo9D+Rm2DxHOflImcIJQwBQyQ/m6S5KcCm1kCr0aJe/frVegE3NEE3IyMD6enpleapydRDUos8+LLfUkoZq9XaSqPRTAXwj1d9A6iUbz+AuwLV8TU9ZNJOIzIyEh07doJGo1HKwAghSmei6nxyfrhxPSwWc7n3Z7w9DTUTEvD1Nzvx/gcbcOjgAWzfvg2ANydv0oRxaNDwHmz7ZidWrFiNvb/uwddbv6q286zqMVeuXoMdu77DkKHDsHjhfGz9asstmSeEENx7773o2bMnevTogfj4q3u4C4KA337bj8kTxyM7K6uyY9SLiooavmDBgsaS5STTjKuVulJK5W70hOd58Jw39cNTKvXDjsKiQvz0426sXfMe5s+fg/379yFLOm7WpUsY+fqrePaZpzBm1BsoKipUzuGjDzfiuWefxjNP98eunTtujcZmNBoVUDMajQqoyblqvl3afTq0K6BmMBhq6fX6KQDaVvXm/Nuc5oGBQbBZr59P/vjxY5gxfRo8Es3M4496zcx+T/THoMFDqvQbhw4ewMoVy2Ew5CExMQljxo5HSpMmyud7f92DDRvWId9kQkxsLIYPH4F27TsAAEa+/iqyLmUCAEa/+QZUKhYJCbWwcvUaiKKIrl274eG+faHVahEdE4NWrVsrmeoWiwU1wsPx3MCB0Gg0SKhVCx07dUZa2ulqG/erOaZer0fHjp2gnjINb0+fhl69+9x0Zpbk5GSwLIvdu3dDq9Wie/fuyM/Ph8R+Uwqw5SRl37/ffON11KxZE6dPn4IgClcC0NaJiYnDxo4du+idd97JkbU2H5+bHGAQBUEEIby37pEwlDAMCEPAsAxyc3NBCMEDPXoAlGLD+nWoV78+9Dodli55B4893g89ejyILz7/DO+tXoXJU6bhxIm/vXNs40dwu90YPnwYWt57X5VB/IZobFarVWHq8K3/lDu3Xymtg1JKXnzxRTYiImIyIaRv1Y9ZckMni9lsxuRJE/Dcs09j3tzZtwzcKqM6vhpp0aIltm3fhTdHjUHNmgnYtn0Xtm3fVWVQu3D+PN6aNgUjXnsdu77bjacGPI0xo9+ASdImMzMzMHvWTEycOAU7v/0BjzzyGKZOnaw0pVmxcjW2bd8FAFiybDm2bd+FlavXeCccw+C5gc8jLKyG1yl+MR0HfvsNbdt663gjIyOxYuVq6HR6ZUEeP3YMzZo1r7Yxv5Zjtm7TFh6OuyWlQ5GRkcjNzVV8XaIookaNGqX2OXLkMKZOngiO42CxWPDS0CGwWLwR2XeXLMPkKdOqpBgwDNP7vvvuGxwTE6OXtDaf0iuwABhvRziRuFwu4nK5wHEeYjGbkZebC5fTheLiIgQGBqKkpAQqtRqCICD15AlkZGYgLe20cu8fergvDv9+CABw/txZtGjZElqdDiGhoWjfvgP+OHL45pmilNJyVQW+mppvBNS3Q7tvBHTNmjWTCCHDbsRN/2rLl3ju2afx7DNPYf68OXC7XFX63vtr38M99zTCp599gbHjLhNFmoxG7Nyx/a5yVO/cuR1d7++Gjh07QavVonefh3BPo0bYvfsHAEBERCQ2bPwYjVNSwDAMHnn0MXAeD7KyLlX5GKknT6Jnj24Y9PxzuKdRI3Tpen+F+615bxX0AQF46OG+N+36q3JMQgjCa4TDdv3O+qsWjUYDQRAQERGBTp06QRTFUkSOANCqVWuER0Rg5ozpGDvmTfR74kmFaOFqG6eoVKrnFy1aNBBeLjdfk1QlYQgjUkoYhoHH4yE2mw0ul4sEBgbC7XZDpVLBYMiD1WpFdnY2CgstyM3NRW5ODiIjoyAnBR86eABWq3c869Sth6N/HFEoklJTT8Jms908YDt79iwuXbqkpHVUpfdnmQjowBuVq3bixN/YsuW/WPvBeny6+QswDIP169dV6bvnz51Dh44dy934/Px87NjxzV0FbAaDAXFxpVX+2rWTYDDkAfCyPBw9+geGvzwUzz37NAa/MFDRdKoqKU2aYPdPe/DFl1uRl5eHDRXcp48/+hC//34Ic+fOr5BDrzqkqseklMJSaEHQLXKHJCcno1GjRvjtt9+UoFBZ4B0+fAT+PPoHtBrtdT0Y9Ho9Bg4c+KbBYOhZgb/Nq7l5/W0MIQSCIECt1kAQBOLxuBEUFAxeEHD490M4fSoVDMPA4XDAZDKhV6/e+OabrzFk8PNITT2JwEBv/4TmzVugZ68+GPn6CEyfNgUB+gDoA/Q3x8eWnZ1dLlfNt1TKB9RQUQTUbrd3lpoZ35BZa7NaERQUjICAADAMgxeHvoSLF9OlxZqHRQsXIN9kRGhYDYwbPwGJiUn4+eef8N8vPkNmZibmzpkFjUaD5557Hl263o+lS97BsT+PwmAwYPjLXr63te+vx4b16/Dnn0dhNBiQ0qQJLqZfQGRUNN55dykopVi9aiX++OMwOA+H9h064rXXR4JSinFjRuH+bt3xyKOP4cSJvzFn9n+wbv2Ht0V3bV+JiYmBIS+v1Hs5Odlo2dKbirLvf3vx6aZPsGTpciTUqgXAGzWsaHGVBTu3y4XvvvsWffo8BK1Oh7i4OPTo8SD2799Xar8tX/4XP+7+ActWrLrmhNOrlas55pEjh6FRq9GgYcObfn+kskP8+eefAACWZctRy9tsNowfPwYDnx+Es2fSsGD+XEyaPPWagkVOpxNbtmxRAXjlr7/+MjRv3vxPydcmSv42JWJKKSUMw8LjcVOn09uUnjAMoqKiEBAQAJ1Oh7//+guiIMJiMUMbF4/nXxiMBg0a4mJ6Oi5lZirHfW7g83hu4PMAgJeGvYi6dateUH/NGltRUVGFuWqVgBop06Wdyc3NjddqtRNxAzu0t27TFjVr1sTLw17E11u3QKfToXXrNgCAObNnoWfPXvh402d4/oVBmC5RLD/wQA+sfX89ataMx7S3ZmDt++sVs2jU6LGYMHEKkpKTsfb99aU4pNq2bYcZM2chMzMDH32yGZcyM2GxWGA0GhAYGIANGz/Gx5s2I/XkCRw/fgyEEEyZNh2fbvoYaWmnMXfOLEx76+1bBmrS/fBqH6KoaNIA8HDfR7B37x4cPvw7eJ7HL7/8jNSTJ9CzVy/FH0kIwLAsiouLsPnTTdLvlGaKiYuPx6GDB8FxHPJNJq82rNXik48/wuefbwbHcSgqKsS+ff9Ds2bNLpvCO7Zj29dbsXT5ypvGU1fVY7rdbvx+6CDmz5uD4a+8ekso3fPz8xWA0mg0CAsLK9cQ5cKF8+jatRv+77mBmDZ9BjQareJjuw6pW79+/RdHjRoVW5G/jVLKMAzDyFRjHo8HHM8RzsPB43bDYXfgzJkziIqKgt1hR1FREQoKCmA0GPDHH0ewfNkSPPlUaV5FjuOw6ZOPQYiXx61aNTZBEJCenq4EC3wjoBWkdZAyaR2EUspER0dPIIQ8eCNvuEqlwoyZs3D6VCq+/fZbDH5hIGbNnos6devi7Jk09FzhJexr06Yt3nW5YDIaER1zbWm9Wq0WOr1eMVsDAvTgOQ6xsXGIjIzCxAljwTIsDEav39Hrm4rA6DHj8Pqrr+D5FwajSZOmtwTUyiboLpg/Fwvmz8WDPXvhrekzUL9+A7w9cxbeW70Shrw81E5MxMLF7yImxptf1+ehh3Hy5AkMHfICWFaFxx7vh/r1G8BSplxozJhxWLxoITZuWIfatWtj3YaPoNFosGDhYqxcsQxffP4Z1Go1ut7fDYMGv6jMrUULvWbgs0/3L20mbtqM2Ni4Gz4eVT3myNdeBSFAYmISxo6bcEPz2IKDg6u8b0ZGBsLCwtCjRw8AwPHjx8v10mjevAWaN2+hrIux48bfIP/rzm6tW7fOALDCR2sTAVBCiDdGSkUq14vyPE8ZwpASawnlOQ6hoWGIjomF3W6HWqWGWq3Grl07wDIsnnr6abSXIuuAl+J8+dJ30bx5S8xfsLhCbbOycbsmYPONgFbGqVYG1GQGALlcajgh5NUbPUFPnz4FnU6HRo1T0KhxCr79tjE++GAt5s1boJhGipnEMKC48Vx0f/11HLt27sDSZSug1ekwY3rpqjCHwwG1Wg2Xy1ntANardx+5Q3gpqV+/Af63/8p9TDt27FTpwtVqtZj21tul3quo4W2btu0qZHmtV78+li5fWeFvsyyLvfsO3FSgr8ox/2m8bsQ52O22KkUq5aqb65VPP/vimr6nVquHbNiwIePFF1/cBi/FrkgBKrWSp/CmgYiiKFKBF8ATDoEBAUSr1VGdXge32wWnw1uNoFKr0K1bd8TGxqFWrdrIyLiIOnXqAgA6deqMTp06V3oedpu1Uj/oVZuieXl5CgWRb1pHBRFQ+ICaoq3Z7fYuLMtOrI7JkXXpEhbOnwe73Vt+Yi4oQGhoKLQ6Heo3aIgfpajeH38cgVqlQnT0P2troaGhKMgvqLC7VEViNpuh1+uh1miQn5/vzYWSiokNhjy8t3ol3v9gAw7//juOXEX4unLHbgD8cnVjcyvHrLJjR0dHw3GFWueAgKqZvFXd73p/Kygo6JV33323hRJMkJrCyCapnAIiigLheQEcz4PjPPB4ZAZeFxwOB+w2G0qKS7wMvPlGKbm/aknqdpsV0dHR1w9sDoejFFvHPwQLyiXhpqWlhWm12vEAqqUOqmev3ujcpSteHvYinn3mKaSePIHXR3pp3KZOm45vd+3E4EEDsXH9Osz4z5wqOVITatVC23bt8PSAJ/HCwGdhNBquuH+nTp2h0+vx1JP9MH3aFNStVx92ux08z2Pm29Px0suvoFbt2pj61ttYvHD+dfs95Ce9X8pP+spKsJhbNGZ2mxVsJRpGXFwcKBWRb8yr8NyS69T7R9AKCAhEcp0bx1j7D8eMi4+PH/TCC4NqyOBGy4MbQykloigQgefBcbzkb/PA7XLB5XTC7nDAarOiuLgIFrMFJqMR2VnZSl+FysbRZMgFCCotP7wqavDU1FSkpaUhMzNTqQX1NUV9KgyIrLVJvjVGoiGaxTDMhBsx6LeKSrm6pTKq48r9LZkwWyx+oskyYjTkIjIyAom1y3OfZWRmwmy++WNmNOQiIiICSVfgYzOZTDAYDOB5Hlbr7c9W43K5VvXu3Xs9AIe0uQB4CCEcAJ4QIhJCRIlaXKYvolqtl1o8ICAAgYGBCA4ORo0aNRAREYG4uDjUrl0bycnJ5TXF4GCoVSrExsZWqq1dlY8tKysL2dnZMJlMMJvNFQYLPB5PudQOOVjgcrmeuFGgdrXO1jtJrva6EhNrIz/fBKMhV2E5uds1NZvNCoHnKwQ1AEhKTITJdPPGTD4nURCuCGqySXqlBXsbymtZWVlna9WqtVf2txFClIACAHhZPwhkcFOpVNBoNNBqtdDr9QqwhYaGIjw8HFFRUYiLi0OdOnVQS0onulqpErBZrValsqAsqPnWgPqmdviaoEajsZZarR57q5ytd9KivNpEVEIIWrVqhYsZmbBYzCiyWOBy3Z0cbXp9ABiWRWREJBITr7wg2rRujczMS8gvKKjWMdPrA8CqVP+oqd3JUrNmzcFffvnl2aeeeiobl6OkMrBROZLgJafkKcMwhGVZyrIsXC5XKSJKGewCAgIQHJtg0NwAACAASURBVByMsLCwa1JiqrSKZNPTNwm3gsoCX1CTqwsIpZSJiIgYA6DVjRzM6OhoGAzGfx2wxcdffToDIQR1kpNQJznJb4Nepbab+C8Fm5sphJCWffv2HQBgFQBB6o/gjZZKpJTwElNSCdzAcZwCbiqVqkJwCwwMREhICJr4kC9UVf4xeJCVlYWcnBzFn1YZqF3BBO1fHakdirPVZIDjDneeO+w2rzMU9IZxsfnFLzdTdDrdkOzs7M6Qyq0opRpIybu+gQRBEIgEbApuyB2uHBLNUUmJN0qan5+PnJwcheLohmlsdru9wnw1X8JIGdh4ni9ngmZnZ8eq1erR1TWY9957L4xGI4wmE6wlxXckNbjsDE1IqHmn+Vb84pdSEh8fP2jjxo2pQ4YMESR/m+BrlpY1SaXqBOpLRGm32xWtTQ4shISEIDw8/KqqPK4IbGXz1cpEPn3z1SoyQUlMTMwoAPdV52DGxMRcdS9Ov/jFL9VikrYYMGBA/yFDhnwAgPcxSQXJJBXhZd1VTFKGYYhKpaIyC4hvYKGoqKiUr61Ro0ZVB7ZMn6JTX8nPz8eZM2dKMXeU9a+VDRz4cqylpaX1zMrKGu2/3X7xy10lL+/Zs+dot27dDsvgBilSKhfLS01g5Kp5hVPucvery6ZqWTO1qi38VIlhP5R7k+MF5F/MAnEaQNxmEE8xCGcDI9hBBBcguADB491EjlBRACgl8jb4/9qw9aP3jPLfY7/45e6ThGbi/9VLrvH3+YuFPACBAAJAZbOUgRfNACqCijyF6CYQXBSCAxCsIIIOjGAB4fJBPLkg7kwQ5znAlor45FpQq/6590WFwYOsbAsMpmKYLTYUFTths7ngcLrhdHJwuzl4PDw8HA+OF8DzIgSBQhQpREoJBZj3lw0eCeAB/y32i1+uTSi9c8+dZZmuh/dMfwRyIMEbRJADCSyViClFkUIQKHheBMcL8HA8PB4ebjcHp5ODw+mGzeZCUbETZosNBlMxLmVVrVKnnI+tuMSJ3LwiFBRYUVjkgNXqhN3hBTWXm4Pbw8PjEcBxAnheJLxAIQiUiJQSUBDLxXcbsCzzhn9q+sUvVyciBQyWSJgKwyCILGx3djrioAULFhyZOHHiRa9J6g0meE1SiJIFSkRKwAuEcgJDPDxL3ZwKTo8aNpcaJU4tCm06FFj1MBYFItscBENxCPJK4lAngUNceAEqq4osB2w5uYUw5ZfAUmhHidUJm90Nh9MDl8sjgRoPjuPB+2prFKAUhAJMSIj+NQAJ/mnqF79cHagdO1cfYMMQFHJn98mVpGZC7eTHJ06cuBoAD2+EVH4VQQgFvG38CCEgUrNlItEdsSo1VCo1VGoN1BotNFodtLoAiCQQxTY18ooSkGcOw731z1cIbqVMUWN+CQzGYhRYbCgqdsBqc8Hh8MDp4uByy6AmyCYo4b0mKKEiJZSCOPJWdCeEvPJvmnDjpm3B/X3fuWG/x/MCRk3+AtH1xiG09psYPmoTHA6Pf2Xf5WIojATYMMTExv9rks61Wu2gPb/ua47LVOIaSuFDJe7NnhBFkQiCAF7gCc95Awec5//ZO+/wKKo2iv9mtmVTIE16CUhHaVJE0AAfUkRBBCslIAgqLYLSld6D9N5EpSgIiiBKEZAelCIIUgUEEtJ7smVmvj9md5JNIyBN2fM8+0B2Znbu3p155233HCsWqwWLQ8ZP1T5IJD4ujuSUFHQ6A+gKczPeL9dzuxi2GxEJRMcmk5CgGrXUNAvpGdbMvJrDsNntsmC3O0JQGUEBARCNRsP77ks0fwwbs5FNP/zOus96sWl1H3bu+ZN+g9e6J+YRR1R8of+cTi5AufLlO2QxbAZQDGSqW4nO1jBJlgXJLmG32wWb3ZZZFbVmVkVTUlJITEwkLjaWyJuRePv43tqw/X09Tg1B41JJTEojJdVCepqVjAwbFoujWJDprSFJMrKsOAscYkbUvDcEgRfdl2jeSE21MG/pbsLGdyC4cSWCG1di8azOrFxzkJhYN/XQowpFAUnS35Gndub0HwwMvfcp7TNnThM2bYrGaejExo3fENLlLUK6dnIR5ImOjmbgBwN4u3vXli1atmpMFipxRVHUIoKiiA7mHxRHq4ck2bV2DyfFUYaj5SM1NZXk5CSNUjwxMQm7rM+10CICWG12NQSNTSEhKY3kFAtpaRbSnUbNWTCwS9jtkmCXZCQZx7IpxI8/aq0z6HXvPegL5Onmkwkd9hXBbcIIqjGcJxqO4futJ7TtdZtMZPjYjVStP4rilT/i7PlILBYbYyZvpnzNEXgU7UO9phPZsdtVKNdmk+gd+iXeJftTvPJHfDpve+YPGJPMK50X4lf2A7xL9ueFV+dw4VKUtr1j10XUbTIRgGO//016uo3gRpW07c82VEXvD4ZfdN/hjygEAVLShDs6tnKVqowaM/aejm/+vLksW7qESxcvaiSuAFevXmHD+vUsWLSUZctXcuLEMY08df68OTRr9j9Wfr6Kd997/1UPD7OHMxzFUSEVBEEHOI2bytsmSUiOVUw2mw2rLYuyfHo6qSmpJCaqIWl0VBQJiVKuOTY9wI0bCUTHJBOfkEpSkloFTXO0dlisdqyapybhqII6vDU1DP148Eu9KKCC+73GgmW/sHV9P5o9V4XNP/7OK10WcnjnUGrXUBc7z5i/k5ULumEy6qlUoSg9+33Bjzv/YOGnb1GpQlGWfr6PF16dw/G9I6lWReXrOnD4IuXKBnB0zwiOnrhKj36fU8jHTM+ujQkd9jUWq43wn4cC0G/wV4S89xn7f1IZmjq2q0N8glreuh6RgNGoJ8A/88lsMOgI8Pfi2o0E9x3uRg7ExsYyccI4YqKjEESR997rQ4OnG3Lt2jUGhvbHZrPi6+vHipVfZKY7hnzEjRvXAVV0ydPLizVr1wEqrf+cWTNITErE38+fwUOHaVoWAOu+/ooNG9Zr+wP0fKcXRqORsGlTXMb2+4kTPFW3Lp6entjtdvx8/Thx/Dj16tXnxInjfPCBSujj6+tbr0SJ4i0uXbq0GbA5XlohQVEU2RGSOlYkSOh0dux2GzabHqvN0aibnk6aSQ1JExISiImNwWTIvadNn55u1XrWEpOyVEE1o+bIqzlya44Q1OmtCSf2fVxIpxN7PSwXwlsd69HsOZWA8sVWNWjepCoLl//Copmq9mWbFk/yWnuVaCQuPpXPVh9g1ZIevNRaVf2eNq4jh379iymzfmLlAlU5vVjRQiyb0xWTyUClCkX57fgV5izeRc+ujbl8NZbSJf0oWdwPT08jy+d25dqNeG08b3Sop/0/Ld2Kh4c+lySrHovV7r6L3ciBr9aupkaNGoR0e5tLly4xf94cGjzdkFKlSvH1+g2cP3+OiePHuRwzaco0ABITE+j9Tg8+GPghoMr2TRw/lvETJ1O8eHF++nErC+bPY/SYzONr1qqVg3k4L4HlxMREPDw8iI6OZtKEcUiyhI8jT5iYmIjJw4PvN33Hjh3b8PT0fLVHz3f2LFu6xOo0bI5VCZIj36bIiiIIakiq2CW7YLPrFL0zJDWoIWl6ejqpqSlqSBofj0Evkp4uYza7jlG8EamGoPGJmT1rGemZBQObzdmzltVbA9nhrVWtXLwnUO1huRDq1HSloalepTinztzQ/q74eOZC8zNnI5BlhYb1yrsc0/jpCvxxJlNXs27tIEwmg/Z3/afK8ee5SGRZZsiAlnz/4+8EPj6QNq/N4bsfTlC9Su7MrGYPA1arlON9i8WOl6fRfRe7kQP16jdg547trPxsBZaMDMKmzyjQcbIsM2b0KNq82Jb69dVg6q+/LnHt2t8MHzqY7iFdWL36S6JuuuoLVKpUmVc6dCzw+E6f/oORI4byTu93adrUtSd/0oRxXL78F2HTZ2Iymap0697jeVwKCY4KqZoSE1C9NmRZQrJLSHa7QytBrZJaLRYyLBmkp6VrhYTExERuRCbm9NjUnrUUkhzeWrrTW7M4QlBnz5okC5Jd9daczbhnwsf46XRiz4fpQpCzaVtmWOzodJnF36wGJLuVz/oZWYV+jdncXb1eRK8XEUWRti/U5PqZKXy/9Xd+3PkHw8d+y/xluzm8Yxie2YxVqRJ+ZGTYSEhMw7ewp5a/i41LpWRxX/dd7EZOw1avPnPnLST8SDifr1yB0WhkzLgJtzxu2dLFeHh40LlL1yy5YhvFihVzCVv/CQoXLkxGRgZh02dSqFAhTpw4TmFfX23bM40a06JlK81bLF68+Ku9er27c/HihdYs4aidLLxtLl6bXRJ0drviUiW1WEjPSCc1NY3k5GT0OoGoaJliRQvh5WnK9NhiYpNJSExXe9bSrVrBwKZVQeVMb01WvTVnbu3xco+9DTz+MF0I4Ucvu/x96MglatfInU21Yvki6PUiB49ccnn/QPhFqlTKzDucveD6VDt+8m+qVVYJIYeM2sD5i1F0eeNpVi3pwf6fPuLU6RscP5mTQ6p2jdKYzQb2Hjivvbfv0AVEUeDpbF6jG24ATJo4nvAj4TRv/jzDho/k0KGDLg/d3LBv31727N7N8BEfuwgWVahQgaSkJH7Zs1vLt32/6TuXY8+fP8fGjd8UaGxP1qiB1WrFZDIhSRIHD+ynZi1Vy7RWrdraOI/+9htBQeUwmUzl+/Tt15xsRYTsXpvs9NrUQkJmldSmCi9bMjJIT1dzbSkpKcTEJhN509Vr08cnqCsMUh3emsViU9dsOUNQm8Nbk1y9td/2DPfR6cS3H7qcxIZfeab+4zzftCorVh3g5OnrrFrSI9d9fXw86NerGYNGrsfby0SlCkVZ/uV+DoZfYurWD7X9/jhzg4XL9/Du28Ec/vUv5izaxdI5XRxGL5I+H65hXtibBPh7sWLVAby9TZphXPvNEeIT0nivRzBeXiZ6dGlM38Fr8fHxwGjQ0zv0S7p3egZ/Py/3XexGDnTu3JWwsCmsXb0KWZYZOOgjRFF0KR4kJibyWsdXqPPUUwwdNoK5s2eSkZFBn/cyU99z5y/Cx8eHSVOmMfPT6SxauABPT08GZhNSPnb0KBs2rKd9+w63HFvZskG0b9+Bd3v1REHh2WeDqVevPgDv9+nH5EkTWPf1V5jNZoYMGw6An79/h/avdNi+ccM3NsDqMG52VGUrlW1Xbdp15NpUry1rldRitWq9bToR4hMkoqKTKV7UV4uShFmTX+VGRDxRMcnEx6eSmKwuek9Ns2pLqTIskmC1StjtiiDJiqgoiNbo+f10OjHsYboInm4+mSeqluDCX9EcOnKJGtVLMX18R559Rm2pqNtkIi+3qcnIj9pox1itdkaO/44vvjpEQmI6tZ4szfiRbflfsMr99OHI9Zw5F4Gfryc//3IWnU5kaGgr+rzTBFDbPQYM/Yrtu86QnJJBnZplmDa2A42eVmXQOnZdxOWrsfy6e7gjn2YjdNjXrPnmCKIg0LFdHWZPeQMPD4P7Ln6Esed45f+k6lpuiI+Pn1jjiarfAylAKpAmCIIFVd3K7lC1knU6nWIwGjEZTYqHhwkPsxlPsyde3l74+BTCt7AvoggNa0mUD3qMalVKUD5IpTUSxo98yXUZlcN7S02zkp5hJSPDJlisEjabIkiSLMgyYufX6+k/W9DjMPDkw2bYWjWvzuihLz2yN4iigCC4v/vDMmcF/exHybApivJHo4YN3v/776spDuOWJghCOmBBleyTRFGURVFUDAaDohJPeigeHh6YPc14enrh7e1N4UKFEQSFek/KlCnlT6UKxaj5RGk8PAzoUxy5tYwMG1ZL1tUFWRa5Z+tbWzqnW5eHzahlh+Db+1/3g0eem0bRIre/rEZS9FyOqkx8kh5JFslIfzRVqjzMZnSign8hO0FFziIKebfQyApcialMbIIJSdbdszlTxyQTWNhC2cfO3tLIXb927VH4qaovWLj42RfbtNrpyLXZFEWxgWAXBLWQIMuyACg2my3TIOJY6SSrKxU8TCa1uTlFIjEpk9ooqEwg+tQ0i4O5I1tuTZKRJFmQJMWxykB9oSDq9bouD/1TIWHRI3Ezp9v9+P1CKfQGD3wKu3VFU1NTiE9OIiahKjUfv4pJn5irUfv13BPo9Ob7MmepqSnEJicRFf8E9Sqdyte4lSz1aBDjFC9Rog3wi8OwWQG9IKDH0deGqmwlqMvQBQUEQRQERRTVbgRRp8NitSKgkJomkZycQXxCGjExyZQq4YeYnm5TvTWrSyMudruEJMlqJdRBnqSAkHZzbmug8cM4WYd2DH3kwtDIuCLoDR7/KVaIfwIvL2+KFiuBTu9BRFzuil+Xo6uh05vv25xljsnMlZjKuAGiKDbcs/dALTJJKA2KouhQK6SqNVMUFEVWK6SyM4rMupZUlSRIT7eRkppBYlIasfGpREYlIaZrPGtqz5rNLmGXHEbNGYJmMngIRoPuTffP8vAgNtH0n2SF+Kfw9ilETKIp121xifoHMmfePoWISTC5fxwHSpcunb31w8n8oXOyfjhojZAltf3D7lgkb7fZsDpaQNIzrKSmWUlOySAhIY2Y2GT0FksmeaTWs6bm1gS1b01xWE6EhCsznxQE4dXbCgkf4WT2vZ4fSdYhyTq3p5aHl5QYH4ssgyi6zveDmjN1THF39JsnJSZy+a+LpOajoevl5U1QuccpVLjwXRnvvT6nwWBou/ar9V+98XrHC2RSh+sFQbA7wlFZlexTBEmSFUmSBMkuKU6vzW6zAQoWi0x6upXUVAuJyenExaWiV3NrWZdNyQ5vTVaLBgo4+da8vEyvF2TA/zGK43v7FPcEnU6iiG9CvlTHuUEnSo9soaAgSE9PdzFqoBqUBzln6elpd/Qg++vSBdLSUvPdJzU1hct/XaRGrTp3Zaz345y169R+DriaJddmdXhtkqKouTZFkRVVxUpypTay2xFQsFglMiw21WtLziA+MQ19Fv0CNa9mzywayA5XEAVh81d9PERReL0gRu0/RnF8z5GamkJEgl++VMd3iu3bfmLF8mVERd2kRIkSfP7lGs6fP0eP7iHaPkOHj+SFF9q4f4iHGLcyMFmvpX/TOT09vdq0e7n9+u++3WjJzLVhEwREUBy5NkFQFBlJkhVJlgS7ukgeu92GAFitMhkWG+npVlJSM0hKSkefnUDSniW3lnX5VPOm1V4FSt9qoFkpjt0oeIji5eXNzUiZm/F+FPOPvyufe+PGDaZMnsiYcROoV68+SUlJAFSoUJHtO3cD8E6Pbvfsey1ftpR2L7cnICAgx7hmzZjOyZO/YzQaaf58S957v4/GKnHt2jXmzJrByVMnMZlMtGjRkl6938vBOnE3catzPte4IQaDAUEQCQoKonuPnjRq1Nh98f5zlBr58agG3327cRfaEitFD0KmPoJKIa5kzbWpi+QlQMFqk7FY7GRYbKSlq7k20RmCSpKc2eIhZ7Z44Gzx0OkKtOT/v0pxfF/C0nyoju8EZ/88Q2BgII0aNcZoNBIYGOgIxwRMJhMmk8llLeHdxmcrlhEXF5vj/dGjRlKyVCk2freZxUuWc+jgATZt+lb1+GWZoYM/pFLlKnz73WbmzJnPnt272Ljhm3s2zoKec+78hXy/ZSvde/QkbOpkNnyz/oFcJ4IgUKdOHVq0aEHz5s0pUeL2nAhJkti/fx/DhnzEtb//vi8pgbFjRvHWG6/RvVsXzpw+rW37++pVxo8b04ws1VEc60edDLuSJAmSJAmKIguSatwEp7CyJKkRp9Vqd/HaNMPm0t4hOSm/1RaP+KsznhAEWt7qC/wTimM3VM8tL6rj28Hx48d4uW0bpk2dTGRkJC+3bcPLbduw8rMVBf6MQwcP0PmtN2jeLJge3UP449Qpl+17du8ipGsnXmj1PN27deHQwQPatn593+fltmpo+8GA/rzctg19339XMyLBwU3pGtINk8lEkaJFqVuvHufOngUgLi4OP39/OnXujNFopFTp0jRq/Cx//nnmns377ZzTbDbTqFFjhg0fyZLFC10YZe8XypUrh06nY9u2bezdu5eaNWtiMBhyNdi5/X9A/778smc3Z86cRpKl2zp348aN0ev1eT4gcvt73ddf4enpyeq1XzN48FDGjxuD4rjIZ86YzsvtX2m2Zu260mTTHwV0giAIoig6144iazUASXs5qdWsFjsZGTbS0qyIzoKBXSsYOLUMtKKB4O3l0b5gT5I7pzh2Q0VKqvCPc2y1atXm201bGBA6kJIlS/Htpi18u2kLId26F+j4ixcu8PHI4bzXpy9btm7j1ddeZ+AH/TXuritXLjN+3BiGDBnO5h9+4qWX2jFixDDS0tSk/Jy58/l20xYAZsyazbebtjB3/kIARFGkU+cu+Pqqnulff13iwP79NGjwNACBgYHMmTsfDw+zdnMcP3aMGjVq3rM5v5Nz1qvfAKvNphnk+4nAwEBu3LjhcCZUii0/P1dP/8iRcEYMG4LNZiMuLo53enQnLk4VG/50xiyGDR95Rw5IQEBAnl7+hwNDOX7sqGbMFsyf57iezmu/b9Vq1TEajVy7pnqK58+fo0GDp6lVu1aDXLw2ERAVBUEQBLXtQ8laRHC0gNizem120jOsiHZJ1sRZnGGorGSyeKAogigKL/+TH2LQwFBe69iekC5v0bXzm2zZ/L2W13it4yu0b/ci3UPu7WKG7iFduHjx9nQFtv30I691fIUXWrdg9qy8Cf527NjO6E9G/meM6+bNmwhu0pRGjRpjMplo1foFqlStyjaHkEdAQCDLV3xOterVEUWRl9q2w2a18vffVwt8jj9OnaJF86aEdOlElapVeS64Sa77LVwwD7OnJy+0uX86QQU5pyAI+Pv5k5J6/0V4jEYjkiQREBBA48aNkWUZk8m1P65u3Xr4BwQwZvQnDBo4gPavdMDf3187/l6gT9/+TJwwnrlzZrP1hy106aoWqB6vUIFf9uxBlmUuXbrEzZuRpCSr8/b44xXYs3sXXl7ezbMZNX2mccvsaVNkRzjq1EeQVMdMVZKXsFhtpGfYELMYNa1gICuAo2iQGjG3GXeBIfejIcNY+cVq5sxbwOcrV3Dp0iWN3nhq2KcP5Q3eomUrvl6/gW7d3uZRQmRkJMWLu+ZtypQJIjJSZRX29vbmt99+pXevHnR683W6de2cayiSH6o/8QTbduziq3UbiIiIcFE4cuLzlZ9x+PAhJk6cnGf4c7dR0HMqikJcfBzeDyjtUq5cOapWrcr+/fu1olB2w9u793sc/e1XTEbTP3owmM1mOnbsSMeOHTEYDLRr146OHTvy2GOPuez3eIUK6j3z1Rp69X6XQoXUXPurr72BTq+je7cufPH5Z3h7e2P2VL3jQR8O5uefd/J2965VuoaEVHEYs6x5Np2iKCpXm3M1giwjOUNTWdY6OlSvTcJisaGXsqwycDTkOsNQAMFk0re9mz9I4cK+PPFkDS5eOE/58nmTKyYmJjB54gSioqKw22106txVY+M8c+Y0M2dMJz0tjSJFizF02AgtMb5718+sXv0llowMqj/xJB8M/FDLP+z6eSdjR39MenoGffv117yEb9avU5PXikLTZv+jW/cet/weR46E8+n0aYiCSMlSJfE0e2rb8htD82bB9B/wAUuXLEJR4PstWx86w1a0aFEiIyJc3rt+/Rq1a6u9Snt/2cOqL79gxszZlCqtFsqfa9ww15sru7GzZGSwdesPtG79AiYPD4oXL07z5s+zb99el/3Wr/ua7dt+YtaceXet4fRWuJ1zHjkSjtFgoFLl+79Eymq1YrfbOXpUDft0Oh0Wi8U1pZGSwkcfDaRzlxDOnf2TKZMnMnTYiDsqFqWnp7N+vVooadeuHT/88ANZF6dnjXB27/qZ8RMmMT1sGhMmTaZSpcqYzWaGDhsBQFJSEm+81oESJUoCUKp0aT6dMctx3+xq+PnKlX9kNWyCIDjCUUXIGnqrKTMJRRGQJAW7XfXabDY7FotdDUVVb00WHEUDTahFURRREIS7GgNER0Vx6uTvVKlSNd/9zp07x/+aP8+yFSuZM3cBs2bOwOpYGzbq4xGEhg7k8y/X8MwzjViyaIGWr1m/fh1z5sxn5RerAfhhy2btM318fFj5xWpGjxnH/PlzAZVYb/PmTSxctJQlyz7jt99+Y9fPO/Mdm8ViYcK4MYwaPZYvV6+lTOmy2rZbjcFutxMVFcW6b75l/TcbH5jxcnZvAyiyjN1u14xQmxdfYs+eXYSHH8Zut/Pzzzv549RJWrRU60exsbEIAog6HYmJCaxe9aXjc1yrHsVLlODQwYPYbDaio1RJQqPJxBefr2Tt2tXYbDYSEuLZu/cXatSokRkKf7+JbzduYObsuVr4dM/D7wKe02KxcPjQQSZPmkDvd9/Hy+v+E4RGR0drBspoNOLr60tCgqvK2cWLFwgObspbnToz8pPRGI0mLcd2r3Dy5Ek+nTGL54KbMOLjT/jt1yMu25OSkpg2dTIvvtQ2Rzj8999XWbZ0cbMsIahWRHB4bKIgCC7LrFQaNdlRI3DNtenVSqiseWuyymEpAEJ65LzWQMm78aWnh03F7GHGaDLSp29/Spcpk+/+NWvWYvmyJWzb9iM6nR6LJYPk5GQS4uPx9vaharXqALzUth1NmzUD4PDhQ1z7+yrv9n5He7J5e/tk5h0c7J5Vq1XTEuHh4Yd4/vmWmM2qa/ziiy8RHn6Yps3+l+fYrl69wmOPFdGMc5Vq1dj3y54CjQGga0i3e5bnKAiyN+hOmTyRKZMn8nyLlnz8yWgqVqzEqDHjWDB/LpEREZQpW5apYZ9qMm2tX2jDqVMn6dG9KzqdnnYvt6dixUrExbveOAMHfkjYtKmsWL6UMmXKsHT5SoxGI1OmhjF3ziy+WrsGg8FAcJOmhDjCfUmSmDZVDQPffN21w+jzL1dTrFjxuz4fBT1nvz7vIwgqc+ygDwfftT42RQFvz4KXwi9fvoyvry/NmzcH4Pjx41it1hz3w62AuQAAIABJREFUT82aKk23Xq9nUDam3DvFd999l3cuPcs5atWqTa1atbW/Fy9awO5du/hf8+dzFLH693uflOQUQrq/XWL02PFPNnmu0a/Z8mw2QbXkznBUUYsIMoKgemySo1bgzLXpJafylHP5lJpbAxCMRl3ru3XxDPpwsEYbXBCsXbMKu83OlKnTEQRBax9whjhOGAwG/PzUJ6zNaiO4SVNNbiy/xG/WECmrdy4IglaKzi+/klezaEHGIGZf53OP0LJVa1q2yvkTVqxYiV/2Hcz32EaNGud545pMJkZ+PMrlvXd65eS/q9/gab5evyHH+xUqVmTm7Lm5frZOp2PP3gP31dAX5Jy3mq9/AkEAvc5OampKgSqViqJw7Nixf3zeVWu+um9z3Kv3e/Tqnbum+uw587OmKuoBx7OFo7ps4aigyLIiSXZEQUSSBMfigkyvTZSdYaijGqqSuWlhaGseEKKjY/D28UYQBI4fP0ZSUhKKolC6TBmSk5M5f/4cAD/9uFUTcq1Xvz4/79zJ9euqWOzOnTs4efL3fM9Tt259tm/bRnp6OjabjR+2bKa+ozSdF8qWDSI6OloruUfcyJT3u5Mx/JMnvTlLbs+N7Elvzxw9gQ96znIbE0AR3wRSk/MWzfb0LFjIW9D97uZn3c1zmjw8mmTz1pw9baLj5SDlUARJkhAEuyA7o84sXpteC0MVBSVLGJoWMbfp3QpD80J+ghSvvfY6Y8eM4octW6hcpQoVKlYkMSGBwMBAxowbz6dh07BYLAQ+FsiQoWpiskqVqvTrP4Chgz/EZrdRLqgcg4cOy3cMT9WtS8tWrXm3l1owePa5JjRt2kxLhi5dspiU1BRkSWLf3r106RrCS23bMXT4CEYMG4Kfvz96vU4rHtzJGP7Jk14U5QI/6R8lpKYkI4pyjp5Adc6kBzJnqSnJ6EQp1z7FYv5x3Ij1JypSwcvHL8fYypWvcMtF6Z6eXpQrX+GujfdBnBMosX3HrsrPN296giw0Rk6jpho2BFmWHe4bSLKgdXY4K6RCkUAzFqtdsFpl7JIiyKpYi84Ws2CSKAof3O6oHiXu9nuBi+f/JLhWwZs+L0dVJja5kHttbjbcjLxBQKEkgh7LOZeXoysTm3T/5yy/MTm9yaj4QkTGB2CTjKQ+osQt6enpS1u3br0KVQ8hGVXwJd0h+GITBCRRFGSDXlCMRhGTUa+YPQyYzQY8zSa8vEzonWGokoXJQ1EUURSF5vc6CepGTnh7KrfF11Um8DxR8dW5GXkDbx83NXhqSjIpKcnYbRmUCTiXeyoh8CxRcU/etzlzjkmyp1M28Gy+HnhR/ySK+ic94qI8SkPgqyzhqM7B9qFWRxEcC+NBlhVFVpt2FUlS1AqpXUKfrSkXBYS4yzOqcQdiLbebBHUj5w2g19lv64IWRZm6lc5wOboycYlWEuLiyMh4NB/1ZrMnoigTUNhG2cfOIQpKntdpvUonuRJTmZgEyz2dM7PZE50oEeBroWzg2QL/to8yOasgCNW3ru9bvHXHuX9pxk1Bh+DIsYEgKKrNkmXUbg5HZdT50qvU39nWhnp7NLnTQRXxTSAiIcFt2O4AKSmJlPS7fcoiUbBTvsgflC/ilt+7HcMR9NhZgh57OOT33HDFU7WCqgF/Ow2bAjohawFBzbUpiqNNTXKsRnD0tyE6vDUBbW0ogk4Un7vTARXzj0OREoi6eY20B7CO7t+ItNQUoiKugpRIUb9/xsX2aD/pH745cxu1O4Ovr2ct1KKBnswCgir0otGpKYKsIDi8NkGWlSwem5OeyOGxDerXTCcIBP+TH/KpSpe4Ge/DzfgAkhONpKS6f6i84O0FBp2VUoFxFPFNck+IG24ABr2uYc3qxQwn/ojUZwlHRQREBUUAQVAUxxIrxbG4wEG7JskygpdZJ9jsiiCp1VAx+frspp5m44/uqXXDDTceJI6euNLnqeCJp8hSHRUE0gGrIAg2QUDWadVRHR4mveLhYcBsNqK3S1kWviuKcDMqseH96ox3ww033MjTazPoKgN/Zg1FFQVREFA7OBCQZQW7BIJNRhDsasgogODh4SHa7XZBURRRURSd3W7fJAjC8+5pdcMNNx4k7Hb7boPBMDGLx5YiCEIqYBEEwSoIgiQIgqzX6xWj0ag46O4Vs9mM6FwXqSiK8Oqrr+oEQWjonlI33HDjQUOv19ctW7Zs1sKBVkBwOGKuVEZZXoLRaBQlSRIVRdElJiY29Pb23uWeUjfcuP9QFIXIyEhu3oxCkiRSUpIf+Tk5depU7759+551emyOV7ogCFbA7vTadDqdotfrMRgMislkQp+VycLDw6Ou+/Jyw40HY9SOHTuGgqCthnDr8YKv/2PlgQtkaftwkE9qjTSCICAIAqKoQ6/Xo9cbMheWAoJOp3vq3/jlQ0NDadWqVYH2TUlJQRAEdu/efcfnq1WrFpMnT77TvAGhoaEUKVKEwoUL07t3b00ExY1HF5GRkSgIFC1Wwt3cngU+Pj6Vs4WhopN4MqvtUhmJZLWfTZHVHJtznaggCHXcU3lvMWzYMDZt2sS6devYtGkTO3fupF+/fu6JecQRFRXt1uPNBQaD4Qly5tiyGTUFlW5NQVFkFFnWduD8+fNFgEruqbx3SE1NZd68eYSFhREcHExwcDCLFy9m5cqVxMTEuCfoEYYkSXfkqZ05/QcDQ/vf8/GdOXOasGlT2O5QKnNi48ZvCOnyFiFdO7kI8kRHRzPwgwGEdO1E3z7vcfXqFW3biRPH6fl2N7qFdGb0JyPz1WYVBKHCyI9Heedj3AAEHAsNnM26zqqoUKJEiSf/KxfJd999R/369TGbzXh5edG8eXPOnXNlevjll1+oVq0aHh4eNGvWjL/++kvbJssyY8eOpXTp0nh7e9OoUSP279+f67mio6N55ZVX8PPzw9vbmxdeeIELFy5o2wMDA/nwQ5VN99ixY6SnpxMcnLmw49lnnwXg4MGD7rv7EUZy8p2tOqlcpSqjxoy9p2ObP28uy5Yu4dLFiy5G6OrVK2xYv54Fi5aybPlKTpw4xpEj4Y5j5tCs2f9Y+fkqunV/mymTJmqpmEkTxjHyk1F8tvJLSpUuo2lm5IVnnwsu4TBkLoSTjrBUW4GgKlipXpvm0hkMhv+EYfv999955ZVX6Ny5M2fOnGHHjh3cvHlTMy5OzJo1i0mTJnH8+HG8vb1p1qyZprwzceJElixZwpIlSzh58iQdOnSgefPmnM1FHDc0NBSLxUJ4eDjHjh1DlmVCQjL1BAYNGqRx01+/fh2j0UhAQEBWV5uAgACuXbvmvrvdyIHY2FgGDQwlpMtbdAvpzOFD6gPQqcnboX1bQvu7pjKGDflI9aK6vEW7l17gzTde1bZdvHiR0P596d6tC4M+GMDNm5Eux677+iuX/QF6vtOLsOkzKP/446732okTPFW3Lp6eKsmqn68fJ44f17yy555TH+CFCxfmzz/PYLVaiYyIwMNsJiioHAD+/v6cOJ4/zXnxYsXKZDFqjjxb1nBUyQxJ1TwbelB72HQ6XfX/woWgKAqffvop/fur7nlQUBAhISEsWLDAZb9PPvmEdu3aAbBixQpKlSrF5s2beemll5g8eTLLly/XChIDBw5k165dzJw5M8fnXL58mdKlS1OyZEk8PT1Zvny5i5EaNiyTPTctLQ0PD48cYzaZTDnk09xwA+CrtaupUaMGId3e5tKlS8yfN4cGTzfUNHnPnz/HxPHjXI6ZNGUaoEpY9n6nh6a/YbVamTh+LOMnTqZ48eL89ONWFsyfx+gxmcfXrFUrh55HXsJDiYmJeHh4EB0dzaQJ45BkCR9HnjAxMRGThwffb/qOHTu2YTQaSUlJISkpCZPJhNVqZe6cWdy4cSOHwlZ2eHl7l8ti1BwGThEdFAOOXjactQJFURRB72xyEwThP2HYatasSUBAANOnT+fMmTOcPXuWX3/9laJFXYvnjRtnCpUEBARQvnx5/vjjD5588klSU1Pp1q0bb7+dKZRstVpdjnFiyJAhvPnmmwQGBtK0aVNefPFFunbtmuvYzGZzDjUhUCXdHoSMmxsPP+rVb8CcWTMAgfr1GxA2fUaBjpNlmTGjR9HmxbbUr98AUKUhr137m+FDB6v7KDJe2fQKKlWqTKVKBddKPX36D46NGEroB4M4++efXMyShpk0YRwBgYGETZ/Jqx1edjGIAz8YwIsvvkSHjq8yYtjQfM9hMBgqZMut5cyxoaCAVkDQZ26g6n/hQjh48CDNmjWjSZMmNG3alNdee43w8HCWLl2a71NIr9djNBo1rc01a9ZQvbqrrc/N22rbti3Xr1/n+++/58cff2T48OHMnz+fw4cPay66E6VKlSIjI4OEhAR8fX0BsNlsxMbGUrJkSfdd7EZOw1avPnPnLST8SDifr1yB0WhkzLgJtzxu2dLFeHh40LlL5kPWZrNRrFgxVqz84q6MrXDhwmRkZBA2fSaFChXixInjFHZc14ULF+aZRo01kXNVhtKbQoUKkZSYyISJU3j88cc5e/ZP7V7IC4IgVM6SW8uaZ8teQFCcBQQREKKioioBpv/ChbBgwQLq16/P1q1bGTx4MC1atODGjRs5JPWy5suSk5O5ePEi1atXp3z58phMJi5cuECFChW016JFi9iyZUuuHtv58+fp0qULq1atYv/+/Zw6dYrjjlxDVtSuXRuz2czevZmq5/v27UMURZ5++mn3XexGDkyaOJ7wI+E0b/48w4aP5NChgy7Skblh37697Nm9m+EjPnaRqqxQoQJJSUn8sme3lm/7fpOrTuj58+fYuPGbAo3tyRo1sFqtmEwmJEni4IH91KylapnWqlVbG+fR334jKKgcRqORYsWLU9jXF5PDsdi3d692TD4wLV66PDAXg6b1sAFZPDZHjs3b27vCf+VC8Pf3Z+fOnZw8eZKSJUuybt06li1bhp+fn8t+48ePp3Hjxvj6+hIaGkrFihVp3bo1oigycOBAxo4dS7FixWjYsCHr169nxowZbN++Pcf5zp49S58+fZg3bx4BAQGsWLECb29vqlRRBW0mTZpE7dq1adWqFV5eXvTo0YO+ffvi4+OD0Wikd+/edO/e/b4pnrvx70Lnzl0JC5vC2tWrkGWZgYM+QhTFfBXe5s6eSUZGBn3e66V9ztz5i/Dx8WHSlGnM/HQ6ixYuwNPTk4HZhJSPHT3Khg3rad++wy3HVrZsEO3bd+DdXj1RUHj22WBNO/j9Pv2YPGkC677+CrPZzJBhw7XIaPiIjxk3bjQ2q43SpUszeOjwW56rQoWKjwHXc/fYHDohGrekgiCKoofFYhmg1+sn/1t//NDQUP78809+/PFHYmNj6dmzJzt37sRgMPDUU0/xxhtv0LNnT65evYqvry8+Pj5MnTqVlStX8vfff9OoUSMWLlxIGYc6vc1mY8yYMXz22WfExMRQuXJlPvnkEzp06OB4GtXijTfeYOjQoURHRzNgwAC2b99OcnIyderUYdq0aTRq1AhQ2z26detGWFiYlk8LDQ1lzZo1iKJIx44dmT17dq5hrhuPDvbs2eNWd8sHcbGxYTVrVN+OumbU+UoTBCEDVSleEkVRXTNqMCiCIAhmu90+UxTFXu7pc8MNt2F7GJGRnr66YoVyX2QzbKlZDJtdEERZpxMVvcGg6B3JuaB/6xeeN28effv2/U/8eJGRkTmqtwWBLMtcvnKVuLg4JEkiI/3RXHvqYTaj0+nw9wsgKKgM+RGmKorimLNY7PZ7N2ceZjN6vZ4A/wCCgsrecv/r7n7GXCFJUnEcTblZX4qiphHV7g4ZWQbJLiEIguApy/JRoLJ7+v59sFisnDhxAp1e79YVBVJTU0hJTkKS7NSqWQuj0ZCrUfv1198Qdbr7oyvqGJMsS9SrW9ftsd0BFEU5X6ZU8Q/IJJ10Ek86qcLtjnBU0ev1irO6UNY9df9ORERGoNPr3awQDnh5eVO0WAl0Oj03Im7kus9fl68g6nT3bc6cYxJFHVeuXHVftHcAQRBKZ/PYsv/fpVlXPH/+fFHAnbn+lyI2JtbNCpELvH0KERMTm+u2uLi4BzJn3j6FiIl1kx3caVT/yegx3uTZ8uHUbQFQ0AcEBBR3z9m/1T2/c1aIR8FzS0yIy3Xbg5ozLy9vEuPj7ujYpMRELv91kdR8tHq9vLwJKvc4hQoXfmDzfi/HWbVKtUJATC7emvOOwNn6oTeZTEXv/g3npjguKHx8CqHTiRQpUoTixW/vGSMIkJ7uJqnMC+l5EHg+yOLKnf5ef126QFpa/gK9qakpXP7rIjVqPThaxXs5zseKFCmU3VtzFA8E13BUUfQ6ne6uGjY3xfHtIzU1hRsRkdyIiOCpOnf3oty+7SdWLF9GVNRNSpQowedfruH8+XP06J7JQDJ0+EheeKGN+4d4iHErY5H1WvqvjrNQoUKFshgwZ3Ou4FgMnzWSEfSiKD52N79YVopjNwoeonh5eRN1M4LIyEiKFSt2Vz73xo0bTJk8kTHjJlCvXn2SklTOrwoVKrJ9524A3unR7Z59r+XLltLu5fYuNE3Occ2aMZ2TJ3/HaDTS/PmWvPd+H41V4tq1a8yZNYOTp05iMplo0aIlvXq/l4N14m7iVud8rnFDDAYDgiASFBRE9x49adSosfvivY8wmz0KuRq1HC/H0kkFURTFgLt5cjfF8T8wcN4+3Lx586593tk/zxAYGEijRo0xGo0EBgY6QlgBhwajy1rCu43PViwjLi5nAn/0qJGULFWKjd9tZvGS5Rw6eIBNm74F1J68oYM/pFLlKnz73WbmzJnPnt272Ljhm3s2zoKec+78hXy/ZSvde/QkbOpkNnyz/oFcJ4IgUKdOHVq0aEHz5s0pUeL2nIiDB/YT0rUTr7/6CjM+DdPWdNpsNsKmTSGky1t0D+nCvn2Za5rzY8S9d5FMKpu++5ahg1XaJYPBmN1jE3EUDrJGjFarFVEQhLu6SNGdzP5nnptdkv7x5xw/foyX27Zh2tTJREZG8nLbNrzctg0rP1tR4M84dPAAnd96g+bNgunRPYQ/Tp1y2b5n9y5CunbihVbP071bFw4dPKBt69f3fV5uq4a2Hwzoz8tt29D3/Xc1IxIc3JSuId0wmUwUKVqUuvXqcc5BShAXF4efvz+dOnfGaDRSqnRpGjV+lj//PHPP5v12zmk2m2nUqDHDho9kyeKF+dJa3yuUK1cOnU7Htm3b2Lt3LzVr1sRgMORqsLP/PyMjnalTJjFx0lRWr11HTEwM2376EYCtP2whIyODlV+sZvqMWcye+anm5efFiFsQPPHEE9pDNb8xZv07JiaGd3p058KF89rvoNfrC+XhqWkvWZbR6/WIgN/dnPQ7pTh2Q0VK8j8vtNSqVZtvN21hQOhASpYsxbebtvDtpi2EdOteoOMvXrjAxyOH816fvmzZuo1XX3udgR/0J8rhTV65cpnx48YwZMhwNv/wEy+91I4RI4Zpaltz5s7n200qE8qMWbP5dtMW5s5fCIAoinTq3AVfX/Wy++uvSxzYv58GDVR2k8DAQObMnY+Hh1m70I8fO0aNGjXv2ZzfyTnr1W+A1WbTDPL9RGBgIDdu3NA8FFmWc5A8HDkSzohhQ7DZbMTFxfFOj+7ExcURERGBr68fJUuWRKfT0apVaw4fPgSorLfPPvuc43cSMBiMnDt3VtuWGyNuAXNjeZJVLlu6WKMGP3nydwb0V1cR+fr68sWqNYR0y+RE1Ol0uYWiuIahqkcrAvc8bhw0MJTXOrYnpMtbdO38Jls2f6/lNV7r+Art271I95Au93QM3UO6cPHixds6ZttPP/Jax1d4oXULZs/Km+Bvx47tjP5k5H/GuG7evIngJk1p1KgxJpOJVq1foErVqmxzCHkEBASyfMXnVKteHVEUealtO2xWK3//XfDm0z9OnaJF86aEdOlElapVeS64Sa77LVwwD7OnJy+0efG+ff+CnFMQBPz9/El5AMl6o9GIJEkEBATQuHFjZFnGZHJlHatbtx7+AQGMGf0JgwYOoP0rHfD396dYseLExcVy6dIl7HY74eHhpKSo38HJiHvq1EmGDP4Qo8lIYmKits3JiDt3ziyNEfef4s23OrNr18/MmT2TcWNG07dff6d3liOnKgiCdz65NRcjpxcE4b4kxD4aMox69eqTmJhAr55vU7Wayn2WF73xw4AWLVvRomUrvv5qLZGREY+M1xgZGUmFChVd3itTJkibA29vb3Zs38b48WNISU7JM6zID9WfeIJtO3YRERHBJx+PYPmypfR8x5WH4fOVn3H48CHmzJmPXq+/L9+9oOdUFIW4+Di8H1DaxRmO7t+/n1q58JkJgkDv3u/xxusdKVOmrGakzWYzw4aPZPKk8Y7ftSyeZrN23PffbyI9PZ1Jk6cxe+anLp+ZFyNuXmjVqhXe3ur8OPOAp0+f5vTp09o+3t7evPvu+3wQ2o833+pE5cp5LysTRdE7nzBUM2o2mw09cF85qQsX9uWJJ2tw8cJ5ypcvn+d+iYkJTJ44gaioKOx2G506d9XYOM+cOc3MGdNJT0ujSNFiDB02Qovhd+/6mdWrv8SSkUH1J57kg4EfavmHXT/vZOzoj0lPz6Bvv/6al/DN+nVq8lpRaNrsf3Tr3uOW3+PIkXA+nT4NURApWaoknuZMttz8xtC8WTD9B3zA0iWLUBT4fsvWh86wFS1alMgIV0N+/fo1atdWW1H2/rKHVV9+wYyZsylVujSgVg1zu7myGztLRgZbt/5A69YvYPLwoHjx4jRv/rxLohpg/bqv2b7tJ2bNmXffGk5v55xHjoRjNBioVPn+L7G2Wq3Y7XaOHj3qDNFyaGakpKTw0UcD6dwlhHNn/2TK5IkMHTYCQRB4uuEzPN3wGUfubK5GS1+4cGHMZjNjx01AFEUsFguFHfOQFyNufvjxRzV398wzz3D58mUtfHZJe1y8yORJExg7bgIrli+lTNkg2uTtKXtlM2JZjJqQNWRFBDzv548SHRXFqZO/U6VK/kzk586d43/Nn2fZipXMmbuAWTNnYLVasVqtjPp4BKGhA/n8yzU880wjlixaoOVr1q9fx5w581n5xWoAftiyWftMHx8fVn6xmtFjxjF//lxAJdbbvHkTCxctZcmyz/jtt9/Y9fPOfMdmsViYMG4Mo0aP5cvVaylTOnOp7a3GYLfbiYqKYt0337L+m40PzHjZ7XaNBl2RZex2u2aE2rz4Env27CI8/DB2u52ff97JH6dO0qJlS0BVThIEEHU6EhMTtByJIruyFBcvUYJDBw9is9mIjopSwyiTiS8+X8nataux2WwkJMSzd+8v1KhRIzMU/n4T327cwMzZc+8bAWdBz2mxWDh86CCTJ02g97vvPxCtiujoaK2abTQa8fX1zSGIcvHiBYKDm/JWp86M/GQ0RqOJuDjXVQ+HDx1kx45tWg9jrVq1sdvtiKJIQkI8Fy9epFLFStq23Bhx/yl++/UIQ4eNoEnTZnw6cw6n/ziVg+06y4PSnM2oZX2GupT39YD5fvwY08OmYvYwYzQZ6dO3P6UdpI55oWbNWixftoRt235Ep9NjsWSQnJxMQnw83t4+VK2m6hG81LYdTZs1U3+ow4e49vdV3u39Tpanik9m3sHB7lm1WjUtER4efojnn2+J2eGOv/jiS4SHH6Zps//lObarV6/w2GNFNONcpVo19v2yp0BjAOga0u2uXBR3iuwNulMmT2TK5Ik836IlH38ymooVKzFqzDgWzJ9LZEQEZcqWZWrYpxQtqvbXtX6hDadOnaRH967odHravdyeihUrEZdtudDAgR8SNm2q+iQuU4aly1diNBqZMjWMuXNm8dXaNRgMBoKbNNWSxJIkMW3qZPR6PW++3tE1TPxyNcWK3f0VgAU9Z78+7yMIKnPsoA8H39U+Nh8fnwLve/nyZXx9fTVZx+PHj+dI5NesWYuaNWtp+apBWZhy4+Pj6NWzB6VLl2bipCk8VqSI9rueO3dOy3f3GxCqea55MeIWBAcOHMhz22uvv6H9PyAggI8G5yvs4pFPGOqwcCKSJKEH7ssdNujDwRptcEGwds0q7DY7U6ZORxAErX3AaZ6dMBgM+PmpT1ib1UZwk6aa3Fh+id+sIVLWVi5BEPJ8YmTNr+TVLFqQMeTHE3Y30bJVa1q2ap3j/YoVK/HLvvwFmhs1apznjWsymRj58SiX997p1TvHfvUbPM3X6zfkeL9CxYrMnD0318/W6XTs2Xvgvhr6gpzzVvN1N8aQmppSoFYp5+qeO4Wfnz/rcokWshvArAgMDCywQtbdREBAgFZhz8VWCdntgSCATqe2ezw41yFfdzsGbx9vBEHg+PFjJCUloSgKpcuUITk5mfPnVWX3n37cSti0KQDUq1+fn3fu5Pr16wDs3LmDkyd/z/c8devWZ/u2baSnp2Oz2fhhy2bqN8hfWKVs2SCio6O1nEFEltzBnYzhn8Bs9sSN25ubBzlneZ27SJEipOWzptrTs2Ahb0H3u1e4x+M05uKpCUo2r80Ziuoe1CTkJ0jx2muvM3bMKH7YsoXKVapQoWJFEhMSCAwMZMy48XwaNg2LxULgY4EMGTpCDQmrVKVf/wEMHfwhNruNckHlGDx0WL5jeKpuXVq2as27vdSCwbPPNaFpUzW03fbTjyxdspiU1BRkSWLf3r106RrCS23bMXT4CEYMG4Kfvz96vU4rHtzJGO7Xk/5RQmpKcp5etfiA5iw1JRldHpXW4sWLExERQfTNCDy9fXKMrVz5CrdcYO7p6UW58g9Wl+kej1OXm8eWW95NUG4Vd90mjh49SpFibo3MO0VU5HXq3MZC+MuXrxAbF+dem5sNNyNvEBgYQNlccrmXr1whNvb+z9nNyBsEBAQQVDbv/HJUVBSRkZHY7XaSk92sONnRpEmT9kAaKoNuEpmiLhY07QNBvuvNQW4P4p890W+3X6ts2TJER0cjntqPAAAgAElEQVRxM/KGmxrcMYcpKclIdnuuRg0gqGxZoqLu35w5xyRLUr5GzRmSFnEk893IFdnDTsGZYxMEQV11IIqCoCiKhLpE4a4gIiKCyMibPFbUzV95+97aDUqUKH7b7B6KovDX5SvExcUi2WUyMh5Njjaz2RNRpyMwIJCyZUvfcoH/lStXiY6JQbJL92zOzGZPdHr9LT01NwoEWRCEjkBqFo8tRRCEVMAiCIJNEAS7KIqKoCiKFTDc7XBUEHV4eXnj6fbcbok0h9gHKLcVhrrhxiMGmyAIr2cxbMlAsiAIaUBGVsOmB+66YatTpw43b97kZlQUyUmJbgbdfODt44NBr6dUqZLuEMQNN/KHtaA7Og3bXa8RFy1a9I40Mt1www03CmjYlGz/ahCBdPd8ueGGG/8CZBTYY7ty5YpbDcQNN9x46KEoSnou3pmiOBRdnJ1riqIo+rJly6a6p8wNN9x42CHLcmqW0FMzcNnbPQRBQFQUxU1564YbbvwbPLbszJZKtv9rf+tRe0HccMONB3/juvV484Hdbk/JYsCULKGokjUUlWUZvaIoCfdSqcgNN9womFFz6/HmD4vFkpybx+ZqvzJD0bhHbYJKlSpFtWrVchWj8Pb25rPPPruXTx1CQ0MpUqQIhQsXpnfv3poIihuPLrLq8bqXI+Z57yRl89gUcmn1ANWwxT6Kk3TmzBkmTZp03887bNgwNm3axLp169i0aRM7d+6kX79+7qv2EYdbj/fWsFqtSVk8tVzya4LKrSiAKElSzKM4SeXKlWPixImcOXPmvp0zNTWVefPmERYWRnBwMMHBwSxevJiVK1cSExPjvnIfYdypHu+Z038wMLT/fXAEThM2bQrbHUplTmzc+A0hXd4ipGsnli9bqr2fn8DyiRPH6fl2N7qFdGb0JyMLrM2anp6WjGtTbrbqqNNfA9Fms918FC+k3r17U716dd555518GXPXr1/Pk08+idlspnr16ixdutRl+88//0ydOnUwm83Uq1ePsLAwF3HYwMBAPvxQZdM9duwY6enpBAcHa9ufffZZAA4ePOi+ux9h3Kkeb+UqVRk1Zuw9Hdv8eXNZtnQJly5edDFCV69eYcP69SxYtJRly1dy4sQxjhwJdxyTu8Cy3W5n0oRxjPxkFJ+t/JJSpctomhm3QlJiUl6haI4VCPqMjIyoW6nN/Beh0+lYsmQJDRo0YNGiRbz77rs59tm7dy+dOnVi9uzZtGrViqNHj9K7d290Oh3du3fn4sWLtGnThr59+7JmzRp++eUX+vfv7yLwMWjQIGrXrg3A9evXMRqNBAQEaNsNBgMBAQFcu3bNfXe7kQOxsbFMnDCOmOgoBFHkvff60ODphi4krb6+fqxY+UVmumPIR9y4oTI4JyQk4OnlxZq16wBVFWrOrBkkJiXi7+fP4KHDNC0LgHVff8WGDeu1/QF6vtMLo9GoMVU78fuJEzxVty6enp7Y7Xb8fP04cfw49erV58SJ43zwwSDAVWA56uZNPMxmgoLKAeDv78/PO3cUaC5uRt1MLoBRUwD0EREREXnJz//X8dRTTxEaGsqQIUNo27atpn3oxIQJE+jRowe9e6t8/mXLluXSpUtMnTqV7t27s3DhQqpUqcK0adPUp2flypw8eZLVq1e75NScSEtLw8PDI8c4TCZTDvk0N9wA+GrtamrUqEFIt7e5dOkS8+fNocHTDSlVqlSemryTpqjXY2JiAr3f6aHpb1itViaOH8v4iZMpXrw4P/24lQXz5zF6TObxNWvVysE8nJfwkFNgOTo6mkkTxiHJEj6OPGFWgeUdO7ZpAstJSUmYTCasVitz58zixo0bORS28g67TzvbPeS8PDVnMCrWrFkzittYg/Vfw9ixYwkICKBv3745tp06dYply5bh7e2tvUaOHMmFCxeQJInjx49Tv76rQE2jRo3yPJfZbM61EmuxWB6IjJsbDz/q1W/Azh3bWfnZCiwZGQUWVJFlmTGjR9HmxbbUr98AUKUhr137m+FDB9M9pAurV3+pqbU5UalSZV7p0LHA4zt9+g9GjhjKO73fpWlTV2W3SRPGcfnyX4RNn+miVJ+YmMjADwZQrVp1+vUfUNBTZUwYPzYtn1BUM3SCoDboAlwFKj2KF46npycLFy6kZcuWbNzoqtxjt9sZNGgQb7/9do7jRFFEr9fnEATOL19XqlQpMjIySEhIwNfXF1BVq2NjYylZ0k2n7kYuhq1efebOW0j4kXA+X7kCo9HImHETbnncsqWL8fDwoHOXrtp7NpuNYsWKuYSt/wSFCxcmIyODsOkzKVSoECdOHKew47rOS2C5UKFCJCUmMmHiFB5//HHOnv1Tuxfyg6Iof2czYHIWzy3n/akeo1x5lC+eFi1a0LlzZ/r27auJCANUq1aNkydPUqFCBe114MABZs2ahSAIPPnkkxw5csTls7L/nRW1a9fGbDazd2+m6vm+ffsQRZGnn37afRe7kQOTJo4n/Eg4zZs/z7DhIzl06GCOh2l27Nu3lz27dzN8xMcuzasVKlQgKSmJX/bs1vJt32/6zuXY8+fPsXHjNwUa25M1amC1WjGZTEiSxMED+6lZS9UyzUtguVjx4hT29cXkCG/37d2rHZMfJEm6ns2o5eGtqf0eekCRZflyXoo+jwpmzJhB1apVXXJdQ4YMoVWrVowePZpOnTpx+vRp+vfvz8CBAwHo27cvs2fPZujQobz99tscOnSIBQsWuISVkyZNonbt2rRq1QovLy969OhB37598fHxwWg00rt3b7p3737fFM/d+Hehc+euhIVNYe3qVciyzMBBHyGKYr4Kb3NnzyQjI4M+7/XSPmfu/EX4+Pgwaco0Zn46nUULF+Dp6cnAbDqix44eZcOG9bRv3+GWYytbNoj27Tvwbq+eKCg8+2ywph2cl8CyXq9n+IiPGTduNDarjdKlSzN46K3Fl202W0QuHpuiqu+5em2CgCIIguCdkZHRz2g0TnxULpZSpUoRGhqqtWE48cUXX9C1a1dWrFhBt27dAFi1ahUTJ07kwoULFCtWjJ49ezJy5EjtSfjTTz8xcOBALly4QO3atWnQoAHr16/XdEUDAwPp1q0bYWFhWj4tNDSUNWvWIIoiHTt2ZPbs2bkWFdx4dLBnzx4er1jFPRF5ICYm5tPaNZ/4BVda8BQnLTgqbbgkiqKs0+lVw5aUlNTG29t7rXv6bg8nT54kLS2NBg0aaO+NHj2aH374gfDw8Ps2DlmWuXzlKnFxcUiSREb6o7lEy8NsRqfT4e8XQFBQGURRzC9n45izWOz2ezdnHmYzer2eAP8AgoLKug3bHeLsn38Oa/6/JqfJKeSSDjik90RJFEVZr9cpekCJj4+/+Cj0skmSdNvydvndGBcuXKBLly6sWrWKWrVqcfLkSebNm8fw4cPJjPcLjsjIyNumU7dYrJw4cQKdXo9PocJu+b3UFOIT4on5LZpaNWthNBpy/e1+/fU3RJ0Ob597P2epqSnExsURHRNNvbp18933urufMVccOngglsyCgVY4cDB7OEJRBQUFWZYRBEHwBIz/Z++745uo//+fd5dcdvempYW2DFGgSAE/FBF/bBzgF0UFRCxYkCEgIhQUFGQrQgsiU5ClIGJZArJkyipYhmyQ0qbpbtORcXe/P240SdNSoGXm9XhEadZd3nf3vNd8PlmW1QNQuJbw7mzq1KlYvHgx0tLSEBwcjLi4OIwePbpSb6E67WGJ/z7qxosTeyEstLyXdO36DeTm5j4UwWQfb2+EOpHhc3lsld+/Q2oF9AEvY2B0CEVLAJgFoWSGJElOJpNxJMqScRdc63f3Fh8fj+vXr8NkMuHq1asYM2bMAwM1AMjOynYNTzsxrc4NWVnO+R1ycnIeypppdW7IynbNBN9DquUi7Fs8bFs97IsHIoOu6J2zLHvetYSPl3HcvQ9PP+mm0WjBskyFKYmHsWYajRaMlXEdnLs0i8VyFeX71xz72Hh2DwHcZARBcBzHcVar9XxFoxMuezSNIICSEheXW0VWUgHP3cMsrtzr8SrIz8eN61dRVGSsFDjD6oTDzd39of2+mthPo7HwphNAK+exEUSZ7oFMfKGkpOScC9gq84542maDwQArw8BYWD20zVqtDjK5DH6+vggMDKz2/d61cweWL1sKgyEDQUFBWLlqLS5fvoTY/v2k94yNn4CuXbu5DvIjbNevXUFxceX0PkVFRty4fhWNmzZ7ovbz9u202w6AxgBghaJBuYcIbADAXbp06Vx0dLTrDKoA1JKTkwGChEar42mbA6rv+4uKjEjXZyA9PR3NmlXfSZmWloYZ06fiy8lfIzq6BQoKeGqciIhI7Nq9DwAwMPb9Glu3ZUuX4PXuPezYTMT9mjvnG6Sk/AOaptG+QycM/miINHydmpqKhLlzkHI2BQqFAh07dsKHcYNRk03kd9rmizEvQC6XgyBIhIWFoX/sALRuHfPAzsE7gYXtufQwrSb2c/++vRkCaDEiqNl7bbyXBluVKhHlWrZsmQXgsgvGypterwcIEn7+gTWSm9FotPDzDwRAID09vdq+9+K/F+Dj44PWrWNA07TEE0cQBBQKBRQKBWpS7+LH5UuRk1M+gT9p4gTUCg7Gb79vwaLFy3D0yGEkJW0CwPfkjR0zGvXqN8Cm37cgIWEB9u/bi982/lpj+1nVbSYuWIjNW7ejf+wAzJ45HRt/3eC6OGreqbgyc8a0ksrCUIIQQlHYh6IQ3sCyLHuKJMlI13Lam8GQCY1WV+Pb0ejcYDAY7jskPX06GZO+mACz2Yzi4mJ0f40PM3u80RP93u9fpe84euQwEhPmQa9PR2hoGEZ98ikaPfus7V0Uy5YtQabBAP+AAMTFDUarF/4HABg29CPcEhhTR348HDIZheDgECQuWAiWZdG2bTt0e+UVKBQK+Pn7o3l0NC5dvAiAr1h6enmhd58+oGkawSEhaB3TBv/+W3NF+7vZpkqlQuvWMZDHT8DELyagU+cujx0zC8MwOHr0CLYk/Y4hQ4cjOCQEAD8kP/e7b5HyzxmQJIXYgR8iJoYnQs3MzMS0qVOQnZ0Fnc4NYz4bi9q1QyvdDkEQiIqKgo+PD1iWxfnz55GWllbl/Vzx43L8sX3bOWdhKACW4zi2LL9GcCAIvkG9oEAqHgAAZ7FYkhUKRS8XlNmblbE+kCqaRqOFsSDvvr+nadMobEraih1/bMfKFT9i9dqf7+rzV69cwecT4jHpqylo3jwae/fsxqiRw/HTqrXw8/fHzZs3MGXyl5g7bz4aNGyITb9txPjx47B5y3ao1WokJC6Qwrc5c+chMrKMOIYkSfTu07csJ3P9Gg4fOoSPhvC0UT4+PtLnRW/qdHIyXu/eo8bW/V62Gd2iJcwWCy5dvIioZs0eyfOWZVmp9cj23x8PH4patWrhwoXzYGwqx9u3bUVpaSlW/LQGOTk5GPRhLBo3bgI3NzeJEfeVV1/DiRPHMWPaVMz//odKt1+nTh1QFIWdO3dCoVDg5ZdfRmZmJiwWi9N9tP07JeUf7N+3F7Nmf3vlhVbRjmGobY4NIoARAjhrtVq+3UNMwhUUFJxywVh5q65CQZW2ZTQ+9N+7ZUsS2r7UDq1bx0ChUKBzl65o0LAhdgp8997ePli2fCWeadQIJEni1ddeh8Vsxq1b/1V5G+fOnkXH9u3Qr29vNGjYEC+2fcnp+xZ+Px8qtRpdu73ywH5/VbZJEAS8PL1gLDI+kufs8ePHMH7cZ7BYLMjJycHA2P7IyeEF6b6dMxfj4ieUu1mfOXMabdq8KNyACMjlNC5duii99uKLPKW9LSPunW4YoofGcfxEgKenp917li5ZJFGDp6T8g4+H8ze4K5cvoWlUFG7xrr+tt8Y4CUfBcZwEcHI5bdegy7311lunwHf2uqwSO3PmNDp1eBl5ebmSh9Ov77tPVE4xMNC+K7927TDo9Xz+T6vV4uTJE4j7MBa93+mF99/rI91tq2qNnn0WO//ci5/Xb0R6erqdEIhoK1f8iL//PoqpU6dX2yjcnayq2+Q4Djm5OdA+oj2EzZtHw8vbG19O+gKfjPoYPd74P4lB5k6MuGfPpuCzMaNBK2jk5+dLr4mMuIkJcyVG3MqMpmkwDANvb2/ExMSAZVk7wkkAeOfdPti7dw8S5n2HyV9OwtBhvDBN3fAInDxx3Dh0yEcZDiGoHbAJYFZO1IUUksccAHb//v0sx3FHXdB1ZyspKcGa1aufyN/m7+8PvUMR4/btVIkb/8Bf+7F61U/4/PNJWL325wpDXYIgyoGdqbQUm37bCFMpT9ocGBiI9u074MyZ03bv27D+F+zauQNzvkt4YH1Zd7PN48ePgZbLUa9+/YdyfDp27Cg9HFmcxbWPixuMUydPQEErquzxbt6chOXLlmLa9FkIdcihVcSIe6dwtGHDhjh06JBUlbc1rVaLQYM+wvpffka7l19G/fr8WFmTJk3RvkOnkwZDRmWgxpbNiYrBKK/zQMKeN5y1Wq0uYKviAdu7Z7fk3tvavr178OHAD9Cv77uYOWOalFNIS0vDoA8HoPc7vTBr5nQpqf9Q8oZWq0SqybEsrFarBELdXnkV+/fvxbFjf8NqtWLPnt04dzYFHTt1AsALjBAEQFIU8vPzpFCCY+3JTAODgnD0yBFYLBZkGgz8XVyhwE8rV2DdujWwWCzIy8vFgQN/oXHjxmWh8OYkbPptI76bl/jAeOqquk2TyYS/jx7B9GlfI27QRw+lcJCRkYGdO3dKD2dMMkajEZ9+Ogp9+vZDQEAAZkyfWim7sxhienh4YNbsb+Hl5QWTyQR3AeBFRtxhw0dALpdLjLiVmdlshslkwsGDB2EymUBRVDltj6tXr2L6tK/x1eSvcfTIYWzdukV67dVXXzvrJAxlbHNsomNGEISUq3Nzd4dMKI9yoltXWFh4zEV6eGdTqzXo2KkLVq9aiS5dygDq+vVr2LBhPRISFkChVGLmjGnYtnULXu/eA3PnfIP2HTqi55tv4djfR3Ho4IGHsu+ODbozpk/FjOlT0aFjJ3z+xSRERtbDxC8n4/sFidCnp6N2aChmzv5W8ti6dO2Gs2dTENv/PVCUDK9374HIyHrIybUH+VGjRmP2rJlYvmwJateujSXLVoCmacyYORuJCXPx87q1kMvlaPtSO/R7n6dfZxgGs2byYeA7vey591euWoOAgOpvYq7qNocN+QgEwRMsfjJ6zAPtY7tbu3r1Ctq2bYd3e/eB1WrF3O/mICcnp1xPoa01bRqFc+fOgiRJ5OXl4urVq6gnFH4qYsStzDIzM+3CXw8Pj3LCLSdPHMfYcePxfPPmeK5xEyxbuhhdu3YDQRC4dv3atYpADQ5TByRJQSajYDYDFEmVTR6IHttHH310dN26dfkA3F3wVbm98X890a9vb4k1FAD+/vsoUm/9h0FxA6W7llZoFUlJ+QcTBUWg8Iia76rp1LkLOnXuUu75yMh6+Otg5TqmrVvHVHjhKhQKTPh8ot1zAz+MK/e+Fi1b4ZcNG8s9HxEZie/mJTr9boqisP/A4Qd6HKuyzTut1/2aTle97URNmjRFkyY85bZMJsMnDky5zqxL1264dOkS+vfjq9bDPh4hheQVMeJWZjdu3ICHhwfat28PADh9+nS5gsNbvd6W/u3t7Y1Px4yVUn5xA2NTnYIaQbDgOJYTjCRJjiQJjiBIaLVaLjc3h/fYbHOiv/zyi3XNmjUHSJJ8xQVdFRtBEFCpVHijZ0+sWlUmjmExW9D2pXaS5JljwrkmG2Jd9vgaRVEoKjI+0OF8x9xoZQDo4+NTZYUs2/M9OTn5nvbNYrH8rdfrbcNQqwhuBA9unDRlQJIgCBIkSYBWKODu7sEXDxxmrliLxXLQdardGdgAoEf3N3A79Zb0fHSLFtize7dEDb57959ISflHcue3b9vKh4NCGf1+TaVSuw7GXa7Nw1yzirbt5+eHYmNhpamPqqZIHnaKpjrel5ub+08lYahDKCqMUpEkSIIESZJSVRRCIo4FwGVkZLiArYqmUCrRp29ZvqpBg4YYNvxjjB0zGm/36ok/d+5AcHAwAGD4iFHYueMP9H6nF7Zt2wqyGmYfxTu9y+ytyFhY4Wwp+ZDWrMhYCKqCFpLAwEBwHIvMjHSn+1anbsQdwUCt1qBO3YiHuu7VtZ+nTp646gTUxEeZmAtB8IUskigDNZIEoVKpCKvVSrAsS3IcR3EcJwegYFl2H4BnXZcIcPLUKfgH3L/u54UL51GrVjDc3NywZ89ubN+2FbNmf2v3ngz9bTx/F53sN27cRHaOi0HX0TL0afDx8UZo7fJstQ+LdZhn9fVGmBMGXdEMBgP0ej2sVisKH2Bj+KNkHMedb9eu3STwIi224i1FAIoJghA0DgiGIAiWJEmOoijQNM3RNA2FQgEZH59KeR8pHLVarXtkMpkL2ADIqin/UVpSijGjR/HK71otPhs7rtwdXS6X39V3hobWRmamARn6NGh1bi7NA2MhjMZCMFarU1ADgLDQUBgMD27NxH1iGaZSUBNDUj8/v6f6GBYWFv4NJ7k1AIwYVYqtHhRFQS6Xg6ZpKJVKKJVKqFQqEFqtlrBYLATDMATLshTHcRQAOisr62UvL6+NLlgD0tPTka7PEBg4as4MGekIDPC/6yF4juNw/cZN5ORkg7GyKC19OsknVSo1SIqCj7cPQkND7liouXnzP2RmZYGxMjW2ZiqVGpRMdkdPzWVlduLEiU+jo6OvAihGmcaBkSCIIsGLMwv6BgxFUZxcLucUCgWUSiWnVCqhVqtBuLm5EWazWQQ223BUybJsMoBarqUGTp1KBkEQ0Gh1UFfzHb64yAhjYQEArlr52FzmsscwDE0jSXKkTRhqC2wlAEoJgrDREKU4mqYlYFOpVFCr1XwoSpIkxzCMbSjKAWAYhtlBUdQHruUGmjWLQnp6OgyGTBQW5FXbsLpOp4NMJkNQUCACAgJcC+2yp9pKSkr+gn011C4UdcAooYeNxzCSJEFRFCiKKsuxiW0fwlApC4AtLCz808PDwwVsggUGBtYIfbfLXOYy3q5cuXLGAdSsAKwEQdi1ehAOfWwioIn/JsXyqDhnZdPTxnp5ef0J4LZruV3mMpc9iDC0SZMm1wXwsjo8GFtQAwBb7LIFN4qiIGNZluM4roxt0sZjA8Beu3ZtO0VRA1zL7jKXuayGw9B9jp6aA6iJzLmcGF0KPG8cwzBgGAZWqxUWiwUyhUIhkrRJ0/8C2LEAGHd39+3e3t4uYHOZy1xWo3b8+PHkSsJQidFD9NBkMhnkcjmEwgHEwoFWqwVpG5vacLNJ4aivr+9BuFTiXeYyl9VsGHqxRYsW/zmAmgUVMHo45takEFQm4x82FQWCJEmOZVlCiGFFsQTGbDZvpmm6oWv5XeayGr24odfrkZFhAMMwMBqfnsmDwsLCfbBvypUeHMeJjbkiwSRYluUsFgtsdA/AcZwUjspsPTbBa+OIMoUXFgCTlpa2LSwsbIzr1HOZy2oO1JKTk8GBkKYh/J+i379zxx9nnHhrVvDTBnbEkiRJcpRMBlpOQ6GgoVAqoVKqoFKroFFroNPpykJRW3BzDEfr1q17nmXZnU/aYiYmJkKpVD7QbVqtVowYMQJ+fn5wd3dHXFwciouLXVf2U256vR4cCPgHBD11Y3FWq3Vv7AfvZ9sAm8XBaysfhooD77ZhKCWDTC6HXC4HKZPJRFDjbDw2zobtgwXAFBcXJ7lOv/u3cePGISkpCevXr0dSUhJ2796NYcOGuRbmKTeDIRNandtT+dvT09MOOQlBLai4f01oxiU5ihSATcbn1+QyGeQ0XRaKOhYRCIKwa/1ISEjYPG7cuM8AhLhOw3uzoqIizJ8/H6tWrULbtryU2aJFi9CxY0fMmDFDUmp32dNnDMPck6d24fw5LF70A779bl6N7t+FC+exdctmNGnSFB06dpKe/+23X7Fp468AQaBt23b4IJZvoKhMYPnMmdNImPsdrIwVYaFhqdeuX7/g4K1JYaiIP44NuSRFgiQdvDWhSkrTdJnHZhuKiuGojdfGjB8/vsRisfz6tJ1wa9euRZMmTaBSqVC3bl3Mm2d/Au3ZswfNmjWDSqVCdHQ0Zs+ebQdQPXv2RPPmzQEAycnJKCkpkUANANq04ZW2jxw54rq6n2IrLCy4p8/Vb9AQE7/8qkb3bcH8RCxdshjXrl5FUVGR9Px//93Exg0b8P0PS7B02QqcOZOM48ePCZ/hBZZXrFyN9/t/gBnTpkqpmGlfT8aELybixxWr4OPrt2Pvnt0WZ94aQNhXREVwI0lQtuNTAqjJ5HLIRdoisTwqvImjKIpgGIYjSRIMw0h5NgDWW7dubapbt+6Ip+Vk++mnnxAbG4tvvvkGnTt3xl9//YXhw4dDrVZjwIABuHr1Krp164ahQ4di7dq10uu2ykU9e/ZEbi6vP3r79m3QNG0nqCGXy+Ht7Y3U1FTX1e2ycpadnY2pX09GVqYBBEli8OAhaNnqBaSmpmLUiOGwWMzw8PDE8hVl9PTjPvsUaWn8wFBeXh7UGg3WrlsPgFeFSpg7B/kF+fDy9MKYseMkkR4AWP/Lz9i4cYP0fgAYMPBD0DSN2bNm2O3bP2fO4PnmzaFWq2G1WuHp4Ykzp08jOroFzpw5jZEjPwFgL7BsyMiAUqVCWFgd0bM7VYG3ZiUIMb9GcADBEQBHkCRHkSRIkuKkSFMMQwVvTaFQlgGbTa7NNhy1mx2NiIi4YLVaN5Ik+cbTcFJ98803+OCDD6QcWGRkJG7cuIHJkydjwIABWLhwIRo0aIBZs2bxd8/69ZGSkoI1a9ZI3/H222ViFcXFxU6LFQqFopwsmctcBgA/r1uDxo0bo9/7H+DatWtYMD8BLVu9gODgYPyyYSMuX76EqVMm231m2gz+fMzPz0PcwFhJf8NsNmPqlK8wZep0BAYGYscf2/H9gvmY9PjO7rQAACAASURBVGXZ55s0bVqOefhOAsuZmZmY9vVkMCwDnZAntBVY/vPPnZLAckFBARQKBcxmM+Z+9+2WZUsXZzl4arbgJoSh4PiHWDSwSZ/Jyrw1WmjWVamUIOVyORy8NjgOxgu9IgwAJi8v76kJR8+fP48XXnjB7rmYmBj8999/MBqNOH36dDmx2tatW1f4fSqVqpxKD8BrVT4MfUqXPfoW3aIldv+5Cyt+XA5TaWmVBVVYlsWXkyai2yuvoUWLlgB4acjU1FuIHzsG/fv1xZo1q2DIyLD7XL169fHG//W8i2vkHCaMH4uBcYPQrt3/swfYCgSW8/PzMWrkx/Bw9zjkxFuzLRpIbB62uTWKsglDZRRkMrmNt6aASqWGTAQ2sWtXDEcpiuIEHUHb2VHGx8dnD8MwhwiCaP2kn1QqlcrpCSP+XyaTlVM6r0yUNjg4GKWlpcjLy4OHhwcAwGKxIDs7G7VquWjvXOYE2KJbIHH+Qhw7fgwrVywHTdP4cvLXd/zc0iWLoFQq0afve9JzFosFAQEBdmHr/Zi7uztKS0sx+5vv4ObmhjNnTsNdOK9FgeWOnTpL3qJWq4WbmxsK8vMxecq0oy+/1OZ6Jd6a2LvGlnVpCGEoj1GSQyaXyUDL5aAVCiiVKqg1apA0TUMu9H5UEJLaFREAWIuKin5+Gk6qhg0blkvqHz58GIGBgXBzc8Nzzz2H48eP273u+LetRUVFQaVS4cCBMqHkgwcPgiRJtGrVynUVu6ycTZs6BceOH0P79h0wLn4Cjh49Uu5m6mgHDx7A/n37ED/+czsW4YiICBQUFOCv/fukfNvmpN/tPnv58iX89lvVgrLnGjeG2WyGQqEAwzA4cvgQmjTltUwrElgOCAyEu4cH8nJzd1fkrQGEHZsHQNh4bGV5NcrOW1NAqVBCrVZBq9FCJgJbRUUEm7YPaRKhffv2vx45cuRDgiAee00ElmXxxx9/lHu+bdu2iI+PR8+ePfHss8+ic+fOOHjwIObMmYOJE3mx4KFDh2LevHkYO3YsPvjgAxw9ehTff/+9XVi5bt065ObmYvDgwdBoNIiNjcXQoUOh0+lA0zTi4uLQv39/STHbZS6ztT593sPs2TOwbs1qsCyLUZ98CpIk7YoH+fn5eKvnG2j2/PMYO248Eud9h9LSUgwZ/KH0PYkLfoBOp8O0GbPw3bff4IeF30OtVmOUg45o8qlT2LhxA3r0+L877ltoaBh69Pg/DPpwADhwaNOmrSQeXpHAskwmw7j4Cedfe6Xr2Qq8NQtBiKAmFA0I8N4aRYIiKU4mVULlUt8araChVCmhFiYPiJ49eyI/Px+FhYUoKipCcXExSkpKYDKZCJPJBBs9BJLjOBkAOQBlUVHRAJVK9fXjfNIkJiZW2Bx7/fp1hIWFYdmyZZgxYwZu3LiBsLAwDB8+HEOGDJHet2PHDowaNQpXrlxBVFQUWrZsiQ0bNki6oj179sSNGzdw4sQJKZ82YsQIrF27FiRJomfPnpg3b94Dn4Bw2aNl+/fvR3hkg6fitxoMhm+fj2p8BDz9t6hrYARPBV5CEEQpD3CElVehojiZTCYqUHG2TB4arRY6nQ6enp7w8fFFUFAQwsLCQPTu3Rt5eXkoKChAUVERioqKUFJSgtLSUphMJsJsNsNqtZIsyxI2egj04sWLvWJjY/8AEP60nowpKSkoLi5Gy5YtpecmTZqEbdu24dixYw/U67xx8z/k5OSAYRiUljydI1pKlQoURcHL0xthYbUl8lRnxnGcsGbZsFprbs2UKhVkMhm8vbwRFhb61AMbx3HXPhszeuLaNauLAJSgTNfACF5arwSAWQA2RpDWY4Vwk1MoFfxcqEoFtUYDnVYLN3d3eHl5w9/fD8HBIQiPiIBMpVKhpKQENE3DbDZDLpfDYrE4VkhtQ1IGADNw4MCC3r17/6RUKic9jgs8bNgwJCYm3s8BwpUrV9C3b1+sXr0aTZs2RUpKCubPn4/4eN7tvpNKkqPp9Xr4+9/d6LPJZMaZM2dAyWTQubm75PeKjMjNy0XWyUw0bdIUNC13euxOnDgJkqKg1dX8mhUVGZGdk4PMrExEC83aFdntJ7yfMTc3d/PaNatNNiGoWQQyABYOYAgHbQPxPxzHgWM5sCwLlmV5Jg+BzcNqtcBiscBiNsNsMvPAplQqUVJSYpdrk8lksFqtoCgKDMOA4ziJNpzjOAYAs3nz5p/ffPPN9wDUfdwWOCEhAQkJCff1HT169EB8fDxGjBiBtLQ0BAcH49NPP8XHH38sXUA1ben6dFAymUswWTCNRguNRosMfRrS0tMQFlreS7p+4yZIinpga2a7Tzdv/ofQSmT4agUHP8ne2vWlS5ecdAA1m9xaWYtHGaEkBblM1A3lq56it6bVauHu7g5PTy/4+fkhODgYdcPD0ajRsyA1Gg2USiUUCgVomoZtMUEoIoCiKM6mn01s/bD26tUrt6SkZOXTfCHFx8fj+vXrMJlMuHr1KsaMGVNpCFTdlp2V/dQOT1dmWp0bsrKynb6Wk5PzUNZMq3NDVnbWU3tMsrOzkxYvWlgK+4KBCG4Sk4dtiwcfipKgZBRHUQ7NuMKUgVqtkkDO28sbMpkMpFarhVqthlKpxL20fqxbt24tx3Euht2Hcge89+Hpp8FzY1nG6WsPa800Gi0YK/OUnqvcxW9mzzrhBNTEfFo5wRZe6Z10mAflR6fkAqipVEpoNBq4ubnBw9MTvn6+AACZTqeTKqJCwcAu1yaTyTir1UowDOO0YTc2Njb/rbfeWqHRaKY/4QcGer0eBoMBVoaBsbB62E21Wh1kchn8fH3vWtqPIICSEheXW0VWUgHP3cMsrtzr8SKSM0HMTwau5N3bhiM8wA2JAhflWy2/oyA/HzeuX0VRkbFSIA+rEw43d3dkZGQkrfppRYW5NThpyCVJkuP71mScTEbxoCaTg6bLdA54jQMd7615+0Ch4LsLZB4eHigoKIDRaJSqoWazWQI3q9UKmUwGhmHEpJ3U0ybk2qxvvfXWmi1btrxBEESLJxXUkpOTAYKERqvj2U2rUdu4qMiIdH0G0tPTq10JftfOHVi+bCkMhgwEBQVh5aq1uHz5EmL795PeMzZ+Arp27eZCwkfZEpOBq3n3/vkreSDmJ4Nb0rFaduf6tSsoLi6643l94/pVPNu46Yl3er2Z7ATUnHprkJhybYfc5ZDL5JDTfDOuQqGAUqWCRsNPM3h68Xk20WSenp7Iy8tDYWGhbQ8baJrmqwwOXpsN64ek1rx9+3ZzQUHBj+7u7k8ksOn1eoAg4edfM2LJYnLZoE9Denp6tYkyp6WlYcb0qfhy8teIjm6BggKeGiciIhK7du8DAAyMfb/G1m3Z0iV4vXsPOzYTcb/mzvkGKSn/gKZptO/QCYM/GiINX6empiJh7hyknE2BQqFAx46d8GHc4HLD2dVpd9rmizEvQC6XgyBIhIWFoX/sALRuHfPAzkHifkDNBtyqy+4Earbg9t/Nm1uvXLlsvYO3xpTPrVGQURQnjU7J5TwdOE2XeWs6Ldw9PODt7WM3Akn6+PjAw8MDOp0OarUaKpUKCoVCyrU5y7c5y7V5eHhsZll225MIbAZDJjRaXc3nYHRuMBgM1fZ9F/+9AB8fH7RuHQOapiWeOIIgoFDwd727bUm5G/tx+VLk5JRP4E+aOAG1goPx2+9bsGjxMhw9chhJSZsA8D15Y8eMRr36DbDp9y1ISFiA/fv24reNNce9UNVtJi5YiM1bt6N/7ADMnjkdG3/d4PIk72BWq3VXm5gXLjjx1Cr01kg7b60M1OTCPKhCqYRKxcvsubu5w8vTC/423hoAkH5+fvDy8oKbmxu0Wi3E9g+xSmoDbJwNhbjdiBX4aXyLwWD48Yk8OIz1gSSbNRotrFbrfX/P6dPJ6P5aN8yaOR16vR7dX+uG7q91w4ofl1f5O44eOYw+776N9i+3RWz/fjh39qzd6/v37UW/93qja+cO6P9+Xxw9clh6bdjQj9D9NT60HfnxcHR/rRuGfjRIApG2bdvhvX7vQ6FQwM/fH82jo3Hp4kUAfMXS08sLvfv0AU3TCA4JQeuYNvj335qrT93NNlUqFVq3jsG4+AlYvGihHfHik2BFRUVI+n0Txo4ZXT0h6/XrO2E/E2oHbBzHWTmOYziOY1mW5QhA8tZKSoq5TIMBqbduoaCgoIy9Q6mCRqOGQqHAgvmJOHjwL6jUantgCwoKgo+PDzw9PaHT6eDY/lFJlbSc1xYYGHjYYrEsedKArboKBVXaltF439/RtGkUNiVtxccjRqFWrWBsStqKTUlb0e/9/lX6/NUrV/D5hHgMHjIUW7fvxJtv9cKokcMlipubN29gyuQv8dln8diybQdeffV1jB8/ThKlSUhcgE1JWwEAc+bOw6akrUhcsJA/4UgSvfv0hYeHp3DiX8PhQ4fQsiVPAuDj44OExAVQKlUSEJ5OTkbjxk1qbM3vZZvRLVrCbLFIgPw4meMQvfh3VlYWBsb2x5Url6vlRlJaWrpm/PjxtxxAzeTorfFjUzyeMAwDkqTAsgwsFgs/SRAejsysTLAcB6VCCZXQ3nHs2FEolUq4ubmX2zapUqkQEBAAb29vuLu7w7b9ozKvzVlfG0EQlnPnzq0EcNvlhD++tmVLEtq+1A6tW8dAoVCgc5euaNCwIXbu3AEA8Pb2wbLlK/FMo0YgSRKvvvY6LGYzbt36r8rbOHf2LDq2b4d+fXujQcOGeLHtS07ft/D7+VCp1eja7ZUH9vursk2CIODl6QVjkfHROXAEoP0gCm6j/wdCKYPqtfpwG9cGhJvC7m2jR43A6eRTAHjG3O8XzAcAeHh44KfVa9Hv/Q+qY29uHzt27K8KPDXb3jUW4HNrFEVxHMdxFEWBZVlOoVAIw+0qeHt5wWgshEooGOTl5cFsMuHFF1+EXF5+uoQEgKCgIPj6+sLT0xNubm7QaDRQq9VSHsYZA0hFubaoqKirxcXFPzzpF3/Xzh1QWPhkCtrq9XoEBtp35deuHQa9Ph0AoNVqcfLkCcR9GIve7/TC++/1ceoJVGaNnn0WO//ci5/Xb0R6ejqWLS3v6K9c8SP+/vsopk6dDplM9kB+e1W3yXEccnJzoH2EegiVHSNAqORgc0rgvfQ1qN9oiNI/r8L9U3vqxCFDh2Pq11OQmDAP27dtRd/3+Aq5eG1Xh+Xl5f2SmJiY6+CpmZzn1jiuTMoYkMkoKJRKmM1mUCSPNcXFxSAIQnC6FDh86BAGDIiDzs15o7UM4Kl/AwICkJOTU2Hrh8ViEWayrJzA9sGxLAuCIFiO4wjbXFubNm1WHj9+vB1Jku1c/s/jZ/7+/tCnp9vffm+nIiqKb0U58Nd+rF71E+Z8Nw/BIbxo2YsxLzj1ahzBzlRaiu3bt6FLl65QKJUIDAxE+/YdcPDgAbv3bVj/C3bt3IG5CfPh5u7+QH733Wzz+PFjoOVy1Ktf/4EfH0XrELjHvyj9bfk3E7mf7IS8njdKtl2G9XoudMNbInfkDpiPp0H7gX0LUXhEBDp26oyVK5Zj5qxv4OZ271MYcrkc7drZX+Y7duw4MHr06ONV8NYYAT9Yq9XKCZEgKJmMUyqUIAkCN25cl4YHeDYPDU6fTsZL7V5GvQYN8O/FCxUDGwCEhIQgKyvLaeuHCGwiuDEMIz2EGVIWACH2tSUnJ5sNBsOSgICApxLYft2wnq/ycRzavfz/8H7/WAB8m8NXk75AYWEhmkZF4dDBA1Iu6kGbbZGCY1lYrVZpwqTbK69iyOA4dOjUCc2aPY+//tqPc2dT8NnYcQB4gRGCAEiKQn5+HrZu2SJ8j/1sbGBQEI4eOYK6dcORl5sLXz8/0AoFflq5Avn5eXi3d18UFRlx4MBfaNKkLJ+1ZXMSNv22EXMT5j8wnrqqbtNkMuF08inMmDENcYM+eiiU7qZDt2Dotrr8Mb2eC7qJP+TP+cF6Mw+qV+vBcjkbcDguO3f8gX1792DK19PwzexZ+HradNSrd28AbbFYsHOnvZb6tWvXthYUFDhOF4geWzmGXIqiQFIUwHFS36xcLkdAYCA0Gg10Wh3++ecM/P0DQNMKXL1yBYUFhbj47wXk5GSDJEnI5XL0evud8sAmhqS5ubnIz8+H0WhEcXExTCaTHbjZem0Mw3Acx0F4SNMIACyBgYEHTCbTfJqmhzxNoJZ86hS2bEnCwh+WgKIofDJqBEJDw9Du5f+HuXO+QfsOHdHzzbdw7O+jOOTgpTwoc2zQnTF9KmZMn4oOHTvh8y8mITKyHiZ+ORnfL0iEPj0dtUNDMXP2t5KaUZeu3XD2bApi+78HipLh9e49EBlZDzm5OXbbGTVqNGbPmonly5agdu3aWLJsBWiaxoyZs5GYMBc/r1sLuVyOti+1k/I6DMNg1kw+DHynlz33/spVaxAQUP29hFXd5rAhH4EgeILFT0aPeaB9bFWxku2X4fbJ/0D5qJHVeyM0bz4D989ikD/joN37UlJS8O2cufDz94ebuztOnjh+z8BWbh9KSn4cN27cDQG8zI4FA1QwZQCAs1gs0Gi1nNxGw0Aup5GWngaZTIY6derCz88P02fORoP6DeDj64uF38+HVquzA7VywObv74/s7Gzk5eVJwCaOWYkem43X5hiS2k0jEARh3rNnz/JOnTr9jyCIqKcF2I4dO4oOHTpJzYKvvPIqjh37G+1e/n9ISfkHEwVFoPCIyBrfl06du6BT5y7lno+MrIe/DlauY9q6dUyFF65CocCEzyfaPTfww7hy72vRshV+2bCx3PMRkZH4bp5zyiiKorD/wOEHesyqss07rdf9mk5XDX2SDIeCmYekP43LTwPLT5d72yc2rLlNm0ahadPquTw5jjvzxx9/OBYMbHNrZim3RhCsQPnNWa1WDgCUSiWn0+mkWdCiomJcungR/v4B6NCxE8/kIUwY+PhWPhpWLjtaq1atcrk20WNz8NqkcJRlWVvVeIbjOBKAtUuXLvrs7OwfvLy8Fj5NXpttz6vAYyclnGuyIdZlj69RFIWiIuMjQWjg7e19TymStLS0jWvXrjU6ATWTHajxnGssQYAjSZKn9pbzPWri2JSCpuHt5YX69esLtES+8PDwgI+Pj91kzqDBzgPCcvw67u7ucNbbVkHjLifSG1XUtOvt7b3dYrEsflpO0ObNW2DXzp0oKSmBxWLBtq1b0ELo0WraNArbt/EnzOVL1dP/pFKpXahwl2vzMNesom37+fmh2FhxlZ0L97h/j6oavkM0tdo+t1haWrp65MiRF21CUJODt2ZXMCAIgiOEZn8ZrzjFyeUyYRaUlmZB+SF3gSXX2xv+/gGSduldeWwAX0gQvTZbqnBHr822iCB6bSxfBmOESilJEAR16NChZW3btn2eIIhmT9KFM+CDfiAE7jVfXz8kJC7A882bo1PnLhj0IV8waPPiS2jX7mUAwPARo/DlxM/x64b1CI+I4BOmT9Cd/lGyImNhha0L5ENasyJjIagKWkgCAwORnp6OzIx0qAWiBTsbGgUuMfmeZ0a5cA9gaPVlhOrUjZAG4TmOO71nz569TvJqtu0djkUDfnRKHJuSyyCXC54bLY5NlQ25e3l6wc/Xr8oylU5XWS6XIzg42K6IYEtpJIaiju0fTgoJVgCWdu3apWZmZi708fFZ9DheJFon+Y9tf+yq8P293n6nXDITAPLycjFz9rdwc3PDnj27UVJSUqVt3SlsyM7JcQGbgxmNhfDx9XH6mo+PN7KzH/yaGY2F5QgBbK1Zs2YwGAzQ6/UoKsy375PUAhhbG0Dt+9iDbOBydvVdF1oNtFoNbt68ufHHH38sqCgEhYOyO5+VEZTvOA4cy3Icy4JlGTCMlX9YLbBazLCYS2Exl8JUWgxTaRFuXr9y78AGAAEBAcjNzbXz2pzl2mw9NodCgui1WQiCIH19fXeWlpbOVSgUHz9uF4msmu7wpSWlGDN6FK/8rtVK7RO2d3RnXdSVWWhobWRmGpChT4NW5+bSPDAWwmgsBGO1IrS2cxAICw2FwfDg1kzcJ5ZhEBZaOTD5+fnZ0e886pafn7/kpZdeulSRt0YQhAhsDEEQjMjcIapO0TQNlUoleGdldN9eXl7w9S1TnWrQoAEaNmxY9Wu2shdr165dYV+bo9fGsizhUEgoVyVdtWrV0v79+zciSbL943Sx+Pn5IV2fcd8XQFSzZli4qOJR2qIiIwID7k7MhSAING/eHNdv3EROTjbycnJQWvp0kk+qVGqQFAUfbx+EhoZU+t4W0dG4efM/ZGZl1eiaqVRqUDIZvL297whqj5tZrdZ9EydOPOAAaqUisAmgZp9XE7QMRCV3uVzOyeVlxJG2AOfh4QFvb28EBASgdu27WzviToIjt27dwvnz53Ht2jWkpqbCYDAgJydHAjxHLVIB9AiWZQmWZSmO4yjwWqQ0x3HKGzdutAoNDZ0L4LFSHzl1KhkEQUCj1UFdzXf44iIjjIUFALhqJ5p0mctqyNIPHTo0OyYm5pYAZCXgNUKLYK8Paiulx9h6awqFgpP0QTW80LGHhwe8vGzEWerWxTPPPIOQkJC7i7Lu9IaQkBBJUNkx1+bY+iHKYnG82U4kWHnngiDDwsKOFxQUJOp0uqmP01Fs1iwK6enpMBgyUViQVy0sHADfvySTyRAUFIiAgADX5eKyx8Ju3769KiYmJlUIM8XQs9RJCGoVvDVp0F0ijRRCUVuab1G/QAxFa9WqddegViVg4/M4oU5zbU562sRCgmNvmzhuZSEIgnJzc/vZZDLVpWl6wON0MAMDA6uN3dZlLntczWg0rg4ODj4F+9YOxxDUYhOCss5C0IpAjVd190FQUBBCQ0PvaR+rpBOn0+kQEhJiR29ky7grDqkK/W12vW2C1yb1tokLsWvXriUsy+5xnSYuc9ljlVfbv3Dhwj1wXgGVPDY4zIMK5JGcLajRAsW3GI7qdKIoC59XCwkJueeJDNnNmzerjoI8VZHT7nnxOfF14SEm8FihA58Qwe2VV15JO3DgwPchISGhAMJdp4zLXPZoG8dx106cOJH06aefFjoJQcuBmiCAbCenZ4sfFeEIL+RCgmVZ3A0+2QHb3bh6vr6+TicRbASWYUMfTphMJhAEAUG6T2oBIfhfRLZp0+ZETk5Ogqen5+yqhsUuc5nLHo6zdu3atTVvvvlmqoO35iwEtdq2dojhp8DvKBUMtFqtXegpVj8jIyPRuHFjqNX3PiFyV2CiVqsRGhpaboa0gvlRjmVZQiwkcBzHCgUF26kE0svLa3NxcXGQSqUa4zp3XOayR9Oys7MXh4eHn7Xx1EptHwRBmGxBzTEEFSQGyuXVbMHNV9DWDQ0NvS9Qu2tgA/gEekV8bc7GrMTGXQHcOGEqQcy3kQDIVq1aLTlx4oS/XC7v5zqFXPYUh3rQ6/XIyDCAYRgYjY8GQ3NpaenP7777rm2/WrkQlOM4CdQ4jmMFRlyOZVmOYRg7vj8xshMfYpVUoVBArVZDLpfj0qVLDxbYACA8PNzpqJWTaQRO6GcTR63EWVLbFhDin3/+Iffs2bO4ffv2fhRFdXGd4i57GkEtOTkZHAhpGsL/Edgvi8Xy508rV+zKycmxOAE12wkDfmyKIFgCYPl0FK/eLjB3cEolL8Si0Wj5njV3D3h5e8HfPwC1goMRXjdc0tG4X7unb6AoCnXr1kVwcDD8/f3h5eVlVylVKpW2+TdOZAKxVbYS3FUr+BYQc+fOnVMvXbq0kOO4Y4/zCbpp0yYolcqKExVWK0aMGAE/Pz+4u7sjLi5OUndy2dNrer0eHAj4BwQ9MmNxLMuePHTwYNLELyYUOOTUSoRHqR2oSXREJFe+Clp+ukDnpoOHh6dERVQ7NLRaQO2egQ3gFW3CwsIQFBQER21SJypXopqzXQuIA7iZnnnmmZS0tLQFHMddeVJP4HHjxiEpKQnr169HUlISdu/ejWHDhrmu7KfcDIZMaHVuj8z+cBx39dy5c+v79nknwwHUbCugJjtQE3rWSFKaB4VcJufktCh0rIBKZT9l4OPjA/+AAISE1L4v7YVqAzYACA4ORmhoKAIDAyX+tkrADbb9bQJ/m0QlLjxMwcHBB3JychIAZD5pJ29RURHmz5+P2bNno23btmjbti0WLVqEFStWICsry3V1P8XGMMw9eWoXzp/DqBHDq3t3sm7evLm6a+cO12E/2G4HbARBWDiOs4iCxxzHCRxrFEeQJIqKjMjNzUGmwQACvNi0Rq2G2WTCgb/+wpYtm/Hnrp3w9vau9sb3+/b76tWrh9q1a0vg5uHhYSfhZwNuYkgq9sOxzkJSACYfH59t+fn53wkLWKPWqlUrTJkyBS+//DLUajUiIiLwxx9/YO7cuQgODoa7uzsGDBggqS2NGDECnTt3tvuO7t27Y9CgQU6/v2fPnmjevDkAIDk5GSUlJWjbtq30eps2bQAAR44ccV3dT7EVFhbc0+fqN2iIiV9+VZ27UqrXpy9v07rVeZS1dZTahJ68t2bX2kEyJEmxHMex4DjIZBTMJhNUKjUXElIb/gEBSE9Ph1qtgVqjQUrKP3jl1VcxevQYRERE4vChQ9W+nvfdO0YQBCIiIpwqWjmrjootIAAIAE6LCRzHkR4eHuuNRqNGo9HE1/RJNX36dGzevBkxMTEYNGgQevToge7du+PChQs4f/482rVrh65du+KNN9646+/u2bMncnNzAQC3b98GTdN2nFxyuRze3t5ITU11Xd0uK2fZ2dmY+vVkZGUaQJAkBg8egpatXkBqaipGjRgOi8UMDw9PLF/xU1m647NPkZbGa5bn5eVBrdFg7br1AICrV68iYe4c5Bfkw8vTC2PGjpNEegBg+bKli7/4fPwpB1ArtQE3vlgAWIRrliUIsARJcARHgOM4TiaTgWVZzt3DHQqFAgRBQJ+eDrVKDYqioFarUb9BQwTVqoWiIiMOHTz4MrnEwAAAIABJREFU6AEbwI9chYeHlyOjFMu8TgbkbfvbIISk4mSCCG6EVqtdWVxcrFKpVCNr8uTp0aOHpI34xhtvYNmyZZg6dSp0Oh1atmyJZ599FufOnbsnYHv77belfxcXFzstLCgUCphMJtdV7LJy9vO6NWjcuDH6vf8Brl27hgXzE9Cy1QsIDg7GLxs24vLlS5g6ZbLdZ6bNmAUAyM/PQ9zAWIwcNRoAYDabMXXKV5gydToCAwOx44/t+H7BfEwSBIby8/N++OLz8YedhJ4ld8ircSzDiFRlkMtpUZwFRUVFMApsxkoVH71ptFr4+vpi+7atyM/PR15e3qMJbACvcGVLIW7btGvjsdn2tUngxpap6jIC0Eng9tZbby1Zv349rVQqa0zGz3b6QqFQSPlD0WiarhbgUalUMJvN5Z43mUwPRZ/SZY++RbdoiYS5cwAQaNGiJWZ/M6dKn2NZFl9Omohur7yGFi1aAgCuX7+G1NRbiB/L98KzHAuNoF1QWFi47J1eb+1H+akC+xDURkJPFDtmGIaTy+Uc75yAo2meLDXTYIBGo0V0dAv8/fdRuLt7QKVUgmVZrPhxOXr1ehsNn3kG48eNfXSBDQDCwsLstBEcpxFsiChh461xAviJkwkQmv1AEASxZcsWYtq0aUvi4+NlCoUiriZOHpkTHvqK1KScPW+xWKq0neDgYJSWliIvLw8eHh7SZ7Ozs6vM5e6ypwzYolsgcf5CHDt+DCtXLAdN0/hy8td3/NzSJYugVCrRp+97dudpQECAXdgKAEajccWE+HF7U1L+cexTcwQ1OzZcodmeoxUKjpbLYbZYQJEkaIUCFEXB19cXderUhbu7BwiCQGBQIHRaHRirFRM+n4jw8HBcvPivdC08ssAGAPXr1y+nReoYjjp4bSK9EWxyboyQgyMIgiC++uqrPF9f3yUDBw4kFQrFwId5otE0Xc51vnTpUpU4o6KioqBSqXDgwAG8+uqrAICDBw+CJEm0atXKdRW7rJxNmzoF0S1aon37DmgR3QJv9uwBlmUr7fc6ePAA9u/bh4WLltjdiCMiIlBQUIC/9u/Di21fwtWrV3Hq5Imfzp49u2fjxg0lNp5aicPDRBCEWcip2bHhMizLySgZZDI5SkpKOHcvbyiVSuh0blAo+P+Xmkr5JtxawQgLDUNAYCAUNM3v64EDaNK06aMPbARBoH79+hKwOXpsDMPYemy24AZhFANCvs3uO4cNG5ZN0/SSfv364WGCW8uWLTF79mwsW7YMzZs3x6JFi5Cenl7h+9etW4fc3FwMHjwYGo0GsbGxGDp0KHQ6HWiaRlxcHPr37w8vLy/XVeyyctanz3uYPXsG1q1ZDZZlMeqTT0GSpF3xID8/H2/1fAPNnn8eY8eNR+K871BaWoohgz+UvidxwQ/Q6XSYNmMWvvv2G/yw8HvQNP2Th6fnnxvW/1IE+0KBbQOuyXEOVOpXoygQDIOSkmKUlpZwarUanl5eUKlUqFe/Pm7euIGjRw9Dp9Oh19vvIiQ4BPXq10f8+M8xefIkWMwWhISEYMzY+Ecf2MRcUr169ewqpLa5NiGvVq6YAPtKqS24EQRBEHFxcZkmk2nRwIEDWaVSGfcwTrTXX38dI0eOxOjRo8GyLPr164cBAwagtNR5Z8qGDRtw48YNDB48GAAwe/ZsWK1WdO/eHSRJomfPnpg7d67rCnaZUwupXRtz5813mtb4ZcNG5zfTX36t8PsaNGiIhYuWwGg0rpg1c8aeZUsXVwRqkqcmghpJkgxQRhopoyhOrlSCphUc33wriLKoNXBzd0dkZCT8/PwQFFQLYXXqoG54OJRKJZ57rjF+WLS0RtftjpoH92MZGRk4d+4crly5gtTUVOj1emRnZ5fTSxBCV0IAQEJg4SU4jiNtNBPkHMcpACgnTJjgHh8fH6tSqYa4Tn0+UXzj5n/IyckBwzAoLXk6R7SUKhUoioKXpzfCwmpXGq5xHCesWTas1ppbM6VKBZlMBm8vb4SFVUwRtn//foRHNngg61RYWLhsQvy4vTbhpzNQs2XssIiMHWJzPUXJOIHemwc1pb24sadnmcpUaFgY6tdvAF9f3wd2LtQoB5q/v3+54XgnFVLY5NmkSqlwwdr2uImFBUyZMgUnT578YcOGDWa1Wn3PrSAdOnTAn3/++chcmHq9Hv7+dzf6bDKZcebMGVAyGXRu7i75vSIjcvNykXUyE02bNIVYoXMEtRMnToKkKGh1Nb9mRUVGZOfkIDMrE9FCs3ZFdruG+xkLCgp+GDpk8P5Lly6aKwM1lFVAJT1QgThWUJoiIIxOSawdJCVQf1MU5DIZxPlQtVIFs8lU47/tgQEbwIvBiOBWWXVUrJAKvWyc1WoVwY2xDUtFcNu+fTs0Gs3SwsLCUq1WOxKA8m73bdeuXY/9hZyuTwclk8E/IAguAzQaLTQaLTL0aUhLT0OYEyLV6zdugqSoB7Zmtvt08+Z/CK1Ehq+WTZtRNVtpdnb24lYtmx9Gefbbijw1KwiCIQCGEDw1GUVxMpngqYlD7Wo1tBoNdHakkYGoXTsUkZGRCA0Le+DnwQNhrQ0PD69IYFkCOJu7qZRrs1qt4mtOwQ0AdDrdqtzc3GIPD4/hAHyftgs5OysbWjd3F6I5mFbnhqysbKfAlpOTA91DWDOtzg1Z2VmVAlsNWZZen748+vmoU7Cf/XT00uxBDQKoESRHEiRHkQJbB21DGCnMf2oFvQI+BPVDrVp8Xu1hgNoDAzY+adnAKbA5em2i5yaCG8APCFcCbpynp+fGjIyMIl9f348Igoh4Wi5ejrv34emnwXPLz8tx+trDWjONRov83Jx7+iyRnAlifjJw5e669DlwV2+asla3/m/y+Tt4aqZyoEYIoEYSAguuDHI5zSlokalDADWJBdcLbjodLOZS5OVmIzNDg8yMNKfrEFYnHG7u7o8/sAFAo0aNyoFbBcAmgZuYcKsI3MS//f39/7h+/XpB7dq140iSjK5+EOHZTQ0GA6wMA2Nh9bCbarU6yOQy+Am0yHd1shNASYmLy60iK6mA5+5hFlfu+XglJgNX7w7UWHAnz5XcWt85dfZ1lJ/9tG/psMuplQc1mQBqtIL31ByLBaLIsdVigoeHR6XK7UVFRty4fhWNmzZ7MoCNIAg0atSoQq/NGZjYeHBOwU34Xo7jOK5OnTqHk5OT85577rkBFEV1rk5QS05OBggSGq2OZzetRm3joiIj0vUZSE9Pr3Yl+F07d2D5sqUwGDIQFBSElavW4vLlS4jtX8bCPjZ+Arp27eZCwkfYiLsENQvH/Hmw8GJSn4yFGTbhp+PsZ4kAauZyOTU7UJODFgSOlQpBLk/jWAH1Q2BQEIwFeZWCmu05/0SEoqLJ5XIJ3O7gsdnm2yoCN3HwlhND06ioqHMbN26c1a1bt0yapvtWxz7r9XqAIOHnXzNiyWJy2aBPQ3p6erVxU6WlpWHG9Kn4cvLXiI5ugYICnhonIiISu3bvAwAMjH2/xo71sqVL8Hr3HnZsJuJ+zZ3zDVJS/gFN02jfoRMGfzQEFEUBAFJTU5Ewdw5SzqZAoVCgY8dO+DBusPR6TdidtvlizAuQy+UgCBJhYWHoHzsArVvHPJqeKmv+eU32oV1f5P1WUAmolfPUBALYCkCN71VTqkQRFl0ZqPnxbR1hoWHIz8uu0eNUVSMfxkaVSiUaNWqE8PBwBAcHS0LMtlxuYrOfQqGQxFVlMhlnI8TM2HK5CTmCUgAlb7zxxu0mTZp8azQavxFevy8zGDKh0epqfF00OjcYDIZq+76L/16Aj48PWreOAU3T8PHxkTxnQQqtwpnY6rAfly9FTk52uecnTZyAWsHB+O33LVi0eBmOHjmMpKRNfPjEshg7ZjTq1W+ATb9vQULCAuzftxe/bfy1xvazqttMXLAQm7duR//YAZg9czo2/rrhoVy03j92h9vo/0l/eyV0hbJTBABYc61F37e+NvH3L/J+y3fIpRULj7Lqpy2ogWBgU/2kKFk5UAMHZGZmori4WMqp+fr6IigwCKGhYahXvz5oYVRKPM+aNWuGjh07on379ggKursq9Iofl6P3O73wdq+e2Lplc5k3arFg9qwZ6Nf3XfTv1xcHDx54+B5bmZeiQaNGjZwNxZcLS0WxVdhUS4UT0nFCgRPD0n///ZfV6XQrMzIy9L6+voMIgrhnUWYrY30gyWaNRgtjwf1TuJw+nYxJX0yA2WxGcXExur/Gh5k93uiJfu/3r9J3HD1yGIkJ86DXpyM0NAyjPvkUjZ59Vnp9/769WLZsCTINBvgHBCAubjBavcBfbMOGfoRb//FCtyM/Hg6ZjEJwcAgSFywEy7Jo27Ydur3yChQKBfz8/dE8OhqXLl4EwFcsPb280LtPH9A0jeCQELSOaYN//71QY+t+N9tUqVRo3ToG8vgJmPjFBHTq3OWhMLNo+jSGcVky2JwSIZzhrv1nzlrzws2vzsJeTcoZn5oQfhJWgBNBjeUdBtKmUCDnaKFQkJ+fD0ZQmqJpGl5eZZ5aaBgPao6SeXXq1AFFUdi5cycUCgVefvllZGZm2pFGOM69in+npPzDn2PLV8BkMiEubgCimj2PoKAgbN+2FaWlpVjx0xrk5ORg0IexaNy4iUQtnp6e/nA8NtF0Op1Tz83T0xM6nc4ZxbidMIyon+DguZkFz60UQLG/v/8f//777ySGYfbe635WV6GgStsy3n/uoWnTKGxK2oqPR4xCrVrB2JS0FZuStlYZ1K5euYLPJ8Rj8JCh2Lp9J958qxdGjRwOQ0YGAODmzRuYMvlLfPZZPLZs24FXX30d48ePk0RpEhIXYFPSVgDAnLnzsClpKxIXLORDBJJE7z594eHhCYCn0jl86BBatuRJAHx8fJCQuABKpUo60U8nJ6Nx4yY1tub3ss3oFi1htlgkQH7QZjlrgPbD5/kbL2vd//ftc/NfuPlVCuwZb4sdHqUE/zADhAUEykCNz+xwVquFk8l5Cv+8vHzI5DKoVCrUCauDqGbPw8vbG1qtFr6+frynFhaG+vXqQ6vVOl3XtLQ0yVlhWRaenp5271m6ZBHWrF4FAEhJ+QcfDx8KALhy+RKaRkVBoVTCzd0dL7zwP5w4zus8nTlzGm3avCicTwTkchqXLpUdh1kzpz9cYAMAd3d3CdxCQkLswO0OFOO2YSkrhKbinUoEtxIAxc8888ypn3/+eUppaelyVxr6zrZlSxLavtQOrVvHQKFQoHOXrmjQsCF27tzBh0LePli2fKUklfbqa6/DYjbj1q3/qryNc2fPomP7dujXtzcaNGyIF9u+5PR9C7+fD5Vaja7dXnlgv78q2yQIAl6eXjDWcBK8whvgyjNQdY5AiSe1OuHX5Su7/TbmlgOoOQJbCQGUAoSZf8BKCKpSJMCRIDiapjmSJFFSXMwVFBTA3cMdOq2On/10c4O7uztUKhXc3Nz4nJoAaroKRFhomgbDMPD29kZMTAxYlpX4DkV7590+2Lt3DxLmfYfJX07C0GG8fkPd8AicPHEcRqMRBQUFOHfurHTTz8/Ph1KpxNmzKfhszGjQChr5+fkAgKTfNyE8POLhhaK25uHhgUaNGlV6Eon/Fx4cQRCExWLhbOsMLMtytv1tYlgKgOvdu3cagITs7OwbXl5egwDcc4b+woXziBsYi2XLVyIiMhJLlyzG5qRNkpdSkX035xscPnQIOTk5mDjpS7R5se0jCWx6vR4REZF2z9WuHQa9nmcx0Wq1+HPXTkyZ8iWMhUa7MKKq1ujZZ7Hzz71IT0/HF5+Px7KlSzBg4Id271m54kf8/fdRJCQscMqZVxNW1W1yHIec3BxoH1IPIVdkSb88f/eqhseGnMIxifxRBDZTBaGnBeBEpXaGAMEJwAYKBCeXy6FUqri8vFxQlAwB/gFC9VMHNzc3eHl5Qa/XwNPLSwg/G9yxF00MRw8dOoSmTuiJtFotBg36CCNHDMM77/ZG/fr8vGyTJk3RsVMXDBs6GO5u7lCr1FCpVdLnNm9OQklJCaZNn4V5330LAMjI0GNz0u9InP/9owFsAODp6WkHbjYgVg7YxGOLsiZewmauVAQ6aa4NACuS4nl7e286f/78jXr16vWjKOrle91fuVyOv/7aj4jISBw+VDXO9hEjP8GIkZ9gnMBg+qiav78/9A5UTLdvpyIqim9FOfDXfqxe9RPmfDcPwQIP3YsxLzi9ITmCnam0FNu3b0OXLl2hUCoRGBiI9u07lEsAb1j/C3bt3IG5CfNrtJHzXrd5/Pgx0HI56tWv/8CPj5Wx7vtbf35ztx/jU1GJOrt9gYCQetQAgiUJgiVAcCTHggLJyUBCJpNz+fl5cHN3B2O1wmDIwLPPNS6bKPDzhVvqLfj6+qF+/f/f3pnHR1Xe+//znGX2yb4MyYSEkIRctuClwrViXS4uVFspuK+Xqq0//fW6Ila9rbV1BZcqyq16Rau1euUVbdUf9d66wr0golGJCYQkJCQkISGQZSaZmbM8vz/OeU6eOZlJQAFJzPN6HeZkMpMZzpx5n893L0fqKMeINZv97LPPABjziO2dqBsaGvDA/ffint/ei7XPPYvJhUU421TKl152OS69zEhsuObqn2Lq1BLLynO73bjnt/dCEAREo1GkpqbirTffRH+oH9f+/Jpv3xS1w23mzJkoKSlBQUFB3Fi/1NRUy+fmdruZaUrZ3FKbWcr8borNNB1gpumqVavuHhgYePLrvtd/mD4DH3+8CXV1OxDg0jM+3rwJK5bfYv386COrvrXo2YhfDrO7MQBQXbfaSgHA2ef8CB9++D62bPkYqqrivffexVfV23DGmWcCMAaMEAIIooje3h7LR0L1+KDPpLw8bN60CYqioMuM9jqcTrz4xxfwyisvQ1EU9PQcwIYNH2H27NlDpvCbf8Ubr1fiscdXH7U+dQf7mtFoFB9v3oQH7r8XP7/2uqMeOOjTBp+9/fHfrT37b3eMZnoOAIiY06RiABRCzIHGFLogiVQkApUgUBkCHESkhAB+fwry84OYVv4PcLnccLvcyMjIRE5ODvLz8pGelo68vLxRoQYYEVQmRBwOB9LS0oY1af106ye4/Zd34pRTT8Mjjz2Bmq+q44KHiqLgpRf/CEKAWbNmWz5k1Qxk9PQcQENDA8pKy3DV1dfglVfXYe0LLx47io03S2fOnDlMsY2wUWIsEEKsNuOmkqNcgq/OerQD0G+//Xb99ttv/4+Wlpa6/Pz8fyGEHHco79Mhy/B6PHjxjy9gwUkn4avqbWPGh2ZP0H3wgfvw4AP34fQzzsS//epulJaW4de/+S3WPLUaHe3tmFxYiIdWPWJNM1r0w7NRXb0NVy27AqIo4dzFP0FpaRn228qFbr75Vqxa+ZBxJZ48Gc8+9wIcDgcefGgVVj/xe7z6yp8hyzJOPuVUXPkvPwVg5CmufOgBSJKEiy88L95MfOllBAKHP5fwYF/zF9dfB0KAwsIi3HLrbUc1j00H/bwhsrfylJb76tA4lOJkU2rWLcFQHzUARiUBiA5QKgBUpIRKggBRA2QiUickONPSh2o/fT4UFBQM5amZgYIdO7YPi34mW01NTUhLS8PChQsBAJ9//vmwmR8XXDg07CgzMxPLbxuaf7Bx4wY8/tgjqKg4Dg88uMqC5KIfno26ujosu9JQc7+44cZhCls6Fr94qampmDVrltUOhRBi3fL73H0W3ABQrqpB53xwiUxTraCg4MPXXnut7pxzzrnA5XItO9j3qKgqTvvnhfj9Y4/ghhtvxh/WPHXMHcczz1qEM89aNOz+0tIyfLRx5DmmJ564IOkX1+l04q5/+3Xcfdf8bHjfz3nz/ylhM8SS0lI89vjqhH9bFEV8uOF/j+pxOpjXHO14fdPl9yfPkxwIh//02r4P37/rQGUfZ3rGEgHN9KcpADWgRg2gEQqdgFICQkUQKioaJAAykQyoQYbb4zGSb/1DPrXs7BwjpcPMU/ve9w6+WtGq2Pmaa8GCk7BgwUnD7pckCbfcunzE5x6TYGMfNA83+5YAcBbcFEWhZoUCH1SgXKUCU28aAO38889vBfBka2vrl3l5eVcSQkZtwq5rGr5/4gI0NTXFRXoEUYR+BJt3TqzxuURRRDgcisuX1HX9i127dlWe8oMTd4BLZxoBajEypNJYdw6dAGaQgEAEoRIEyBAsqLkgw+X0wOPzwefzWT61nByjTKqoMHGeWqLl8XgxMBA+qMcdySUdyx+21+vF7NmzIYqitY0COmoqOBYxtQcVmG2q201TAFowGPxg7dq1X11wwQXneTyen432/jIyMvB/f/Gv6Ofy3PLzg9jd3IRYLAaq66itrUFhYdERO0Zut2eCCod4bL7NY5bstXNyctDRsdcCWyjU//wfX3j+o/vvuzdkU2l85JPfeKiZZid0E2jUiHwKVAKBTETqgAgHZLiIDLfDA09JDnxmSgeDGt/91p6mkWxNKS7Brsb6EeHm8Xgxpbjkuws2wCi/ssPNDrkEJipTb/YqBcr53phpqpumqQZAXbZsmbZs2bJn6urqPi0uLr5EFMVDysnIy8vDqaf9My6/9CKkpKRaZUxAfLrHV9Xb8MTjv8f9DzyEqSVf/0NOdKWfWEDYHNKbaAnf0jELh/ohJkkhmTRpEtrb29HR1rphd0vr20uXLG5KotJ4nxoLjMWGVJoxRcq4cBs1n4IgUkkSIUlmhw6HDAdrEmnOKGD91CzzMz/fyFObVn5IqTYpqamoOG7ut/75H9GZB4dzUUqt+QktLS3o6OhAV1cXenp60Nvbi3A4jHA4jEgkwo//I9zgZqLrOpulQACweQqiCXiZUuoA4ADgBOAsKSlxbdmy5UeNu3ZdmRs4OoM/93bswdxD6PDR1NSM7v37JzroDjuObcjKykRhgk4TTc3N6O4++sdsb0cbMjMzUZSg0SSldE9nZ+d/zpkz55OOjg7FBrVoIoUGK9pJVBiNITTTEqFsMyt0IEkSJMmaUwAnBzaPxwO/34+0tDRkZGQgNzcX+fn5mDJlyhGtJf5OKzaLwIRg5syZ7AMaptzst+Y2LGJKCKEm3MArN2aawphGrwFQ6+vr1YyMjMonn3zykwU/OGVxRkbmlUf6ii7L8iE9p7BwMrq6OrG3ow0+f8rEzINQP0KhfmiqmhBqAFBUWIjOzqN3zNh70jUtIdTC4fDLb7zxxkeXXXbZgVFUWpRTaNZEdlOlaSbMdA5mRsdb2dbK2831UjPbeWdnZyMQCGDy5MkoKSlBeXn5mD4Pxoxi41dDQwPq6+vR3NyM9vZ27Nu3D/v370dfXx9CoRDC4TAGBwct5WbOXCDcGEBevQmmehNM0EsAJE69WQru/Q82VEwpLl4qiuKZR+L/1bm3HZMCuYfctohSil1Nzdi/vxuaqiMS+W42n3S7PRBEEVmZWSgsLBhVbTQ370bXvn3QVO2IHTO32wNRkhIqNUVR/ruqquq/5s+f38IBLRnUEpmd6pDZaQHNmE1gAs0oZI9XaF6v14JaRkYGsrKyMGnSJBQWFqKkpARTp04d8+fCmAQbALS0tGDnzp0W3Do7O3HgwAH09vaiv78fAwMD/Gi/YXDTNI2Yw5vZmD8GN2aespF/Mg83AM5PPq1akJOTe/7h6tQ7EA4h1N8HgB72RpMT69hbuq5vbWxsfLu0tLTWVFx2lRZLoNKUBCpN5zZqWjBJoeYx0zn81nyCdCPyaUKttLQUBWYlyVhf0lh94wUFBTCrDmAWxVu3icxV00SlgiAQQRCgKAolhLCGl/bAghUpJYQw09Q6AY+fe9z7JSUlmx5++OEzUlJSzieEfG3d7vf7IUkS8vImIRAITHzrx/GilO5ob2//68KFC6tqa2sZzOy+tJjNh8ZDzRYcsIYXU1EUqSiK1vdBlmXKeu4xqHm9XgtqRpDAbDtUWIiysrJDHv04AbYjtHJzc8GaUPKASwQ1zvfGZiESRVFACGEJvZQODTXVbWkhGgDVnG+qmP435dxzz33rjjvu+PDWW289PS0t7XxCSPHE13diJQDarq6urr/efffdW9esWRPlTMlYAtOT3Sp2s5Odi8yXxiay21WaLMsW0OxQYwECls5RVFSEsrKyYe2Exrwp2tTUNOb/E5FIBI2NjVa0dN++fVa0NBQKYWBgAIODg4hGo5ZZahboElYzycxSLmpKbKapSCmVmInK+d8cAJy33HJLyhVXXLEwJSVl6TdpajmxxhXQGvfv3//mmjVrPn322WcjHKCUJECLcbCzRzuZUrOincz85KwUq9s0U2t8oCA1NRVpaWnm3M8ACgoKUFxcDJfLNe6O/Zj1sSU4ibBjxw40NjZiz5492Lt3rwU4FlRggOP9bsz3xgGOmF19CfO/IT41RIQRXEgEOMfy5cv9K1asODUjI+NcQsiMia/3d9KHVtPZ2fm3X/3qV1XPPPNMdASg2TfFNDtVDmYab3baVZqp1OKAlijyyYDGUjmKi4sxbdq0MZvO8Z0BG1tNTU1obGxEa2urpd4OHDiAvr6+pEGFBIGFuMgpU28MchjKfUsKuOLiYsfGjRtPys3NPVsQhBMmvu7jf2matrmlpeXdk046qbq1tZXBiQeachBAY8+zAgMAKB/xZCqNDxAkCxKkxE1nDyAYDKK4uBhF39Ig4wkf29dcRUVFfFujOB/cKAEGdiVk6o1qmmblvcHMdTPVW1xwweZ/iwFwNDY2OvLy8t4F8FFdXd2coqKihbIs/3ji6z/+VjQafWv79u3/M2fOnF0czHiVFksANSUJ0PjgQFySLa/SeLPT4XAM86cx05NP5ygoKMDUqVPHVZDgOwM2wAgq8H3bXC4X+JPADrdIJGIBLhaLWZFTBjcuuED4kX+sQwiMfCIVgGIqOAtwABxlZWVbAHz+7rvvvjpv3rwf+Hy+swEEJ5Awpl0frf39/e+8//77ny1evHhfEqAlgpoykkIzL5h8lB4spsWtkJTyAAATTklEQVTmBui6TnVdh6ZpVl8yRVGsBHWm6BwOB8LhMNxuN/r7+9Hb24vt27dj+/bth+UY+P0pEEXBShmZMEWPot+trq4Ozc3NaGtrw969e7F///4R/W5mKVbC4AKX1AvTNGWlWXFBBpuJypuqMgDHJZdc4lq5cuX8nJyc0yRJOm0CE2Nnqar6fktLy//cdNNNtX/5y1+UgwSakgBo9qAAg5lOiACjxlOggihCEkWIrCRKkiE7ZDhkB4yp7KZSc7vh8Xrh9/mRkmqMxsvKykJuIIBg0AgSHAl/WpjLwZx7DOVgjiuwXXTRRXj11Vdx/fXXY/XqoX5fra2taGpqwg033IDPPvsM5557LgoKCpL63biEXph+t5GCC2QUwElJACcDkBctWlSwdu3a+Tk5OQu/ST7cxDqiF8gdPT09H3z00UdfLF68uJuDUiKgKUmApiYDmtkjkDJfGhEEiKYvTRQNoEmyWRolOyA7HHCaUHO7XHDH5agZ6RxZ2dmm+Tn5qKipzr3tyJsUOGZyMcedKSrLMt544w088cQT1hUqGAxCEARUV1cDMDp1BgKBYT44ey5cLBaDKIpQFIVldZNE5qnNB8c6hQimiSpxJqpknvAW2NavX18fCASaAby+bdu28qlTp57gdrtPAzBR1f7twqxtYGDgg5qamqp58+btZj7VgwAav6mmQtMSmZwMaIIgUEqpmV9pJNqKkghJZLWeEmTZYSg1FiRwGpFPtxn59PuNyGdGZgZysnORl5eHyYWF1qzNI728Pj/27t07AbYjtRYsWIANGzZgy5YtmD9/vnX/xo0bMWfOHGzdutUq9jUnzccBLhwOW0GGSCRiAc5Ub9QeXNB1nQ8wJAoyaABE84otUUoZ2OxKTp41a9bnAL4C8Pz27dtnFRYWHu9yuU6ZgNzRg9ng4OBH9fX1X1RUVOzi1VUSoKkHCbOEQOMDA7quU1mWMUylxZmeTrj4dA6vF7FoFFs/+QQXX3IJMjOzkGOmcxQVTYkbRPxNV21tDd5+601UVMzB6WcML5X2en0I9fceM5/luANbRkYGTj31VFRWVsaBbd26dbjgggvw6aefIhgMorS0FB6PBzU1NaisrERPTw/cbjfKy8uRn5+PwcFBSJKEnTt3Yt++fdagE0mSaGZmJkRRJKFQCJFIhIqiCNaxFwARRdECnK7rgml2iGbkVDRPfGamSglAJ5WXl28F8DmAtV9++eW04uLiOR6P54SJ3LjDu3RdrwmHwx/v2LGj5vjjj+eVmc6BaSSgqRzQ7OYmi5zTZEBj6RuqqsLhcEBkHTkk04JgKs3hhNM13PT0p6RgznHHIRicbKRzFASRk3N4o55PPbkajY0NGAiHh41l5NfRHCz+nQMbACxduhQPP/wwHnzwQQDA4OAg1q9fj5UrV2LFihVIT0/H7NmzUVdXh+effx6XXHIJCgoKUFtbizfffBOyLCMYDGL37t3o6upCaWkpZFlGT08P9uzZg4GBAaSmptJYLIZIJEJ0XYfX66WapiESiUDXdSpJEuGiqMS8Wgs2M5WvaOA3HnTS7NmzvzCV3Kvr16+fNHfu3OlpaWlzZFk+AUDqBJ4OafUqivJxd3f3l5s2bWpYsmRJN4YikcnUWSKo8R02VNtzdU6hUb4/GkuwFSwfmhHBFASBOp0uPj8NssMBgRDs3r0bmqpClCTMnjUb+cEgKAX+39tvQRAEpKdn4JHHHreskF+uWI62tj0AgJ6eHni8Xvz5ldcAGJ1xnvj9o+jt60VGegZuu/2X1pAeAHjtP19FZeU66/EAcPU1P4PD4cCqlQ+OmQ95XIJt8eLFuO6661BdXY2ZM2di/fr1mD59OgoLC63HeDwevPzyy7j44otx7bXXoq2tDcFgEKFQCJs2bUJFRQVyc3Ph9/uRlZWFSCQCn8+Hffv2QdM0uN1uRCIRAKDp6ekQBMEyUVVVhSiKbNYCi6IS0zQVzPsY4ETziyKZqk60QY4HnbRo0aJdAFoA/L2iokJ+7rnniouLi6f5fL7ZkiR9D8BEK12bkFBV9dO+vr7qurq6xquuuqq1pqZGtykzzWY6JgMaDzP+ObrN3LQUmrkhGdBYzzRCCFwu1zCVtqdtD3KyczB9xgyoqorttbWY/08nID09Hd///omIxaJ49ZU/Yxo33/T+B1caBO/twc+vuQo33XwrAGPO532/uwe/u+8BTJo0Ce/8bT3WPPUk7v7Nb63nVsyZM6zzsMPhGHMf+rjNY1uwYAFef/11zJw5E+vWrcN555037HHV1dXo6upCZWUluMlW0HUd2dnZcLlcaGxsxM6dO600EUVRkJKSAq/Xi4EBo4eX3++HpmlUVVUMDg4SVVUhy7KVa2RGUVk+EjXHaQ1TcKaZalU2cJBLBDvpiy++kObOnVsNYDuAtwoLC8WXX355cmlpaXFqauo0WZZnEkJKvksUo5TWx2Kxrw4cOFC/ffv25ssvv3xva2urblNlidRZMpVm/Y4lY9v+Bu83izM3eaBxCeBxQGMKjRACt8c9lMZhmp7BYAF21u1AW1sbSkpKcMlllyEj3Yh6BgIBRKNRuN3uRCY2fnP3r3H2OT/GvHmGS2bXrka0trbgDnNgt051eG1DVcrKpqGsbNqYPw+k8XqCL126FGvXrsVtt92Gt99+G/fee++wx6iqiltuuQU//akx07K9vd1qOS6KIt544w288847KC4uxuTJkzFjxgxUVVVBkiT4fD5riIvX67VSQ2RZptFoFE6nk5jRU2qLoDKwWVPsKaW6eR+DnAAjRYAvwBdtgBu239zcLJ544ok7ANQDeBeAuGrVKt/pp5+el5+fP9nn802RZblEEIRpMHrLjeUV1XV9RywWa+jv72/evXv3nnfeeWfvnXfeOQguJ2wEmCWDWtw+p8zizEybOqM2oFG+kwzfYcYONLYBgNfjjQ8QeDzIy8vHjOnTcaCnBzvrdqC9rQ033nQLJuXlIS8vDzt31iU8OP/x7NNwuVy47PIrrPsURUEgEMDaF14c9xe4cQu2JUuW4MYbb8TTTz+NsrIyTJkyZdhjpk+fjm3btqHEHKZSUlKCZ555Bhs3bsRVV12FTZs2YeHChViwYIGV87Z582a43W74/X5rqrXX67Uipw6Hg5kVlG9oqWkaBEGgqqqCUgpRFCmllJhBB8KpOFZ4TzjICSbkhASQG3H/1ltvHQTQDaCGM32FysrKrPLy8uysrKxcn8+XJ8vyJFEUg4SQAgDHSruHCKW0RdO0PbFYrD0UCrV3dnZ21dTUdF944YUHMJSdr48Cs2QKLeE+BzPdDjMMDQCiydRZIqDZitatjUXjAcDn98eVRvl8Pmzd+gmmTSvHqaeeBrfbjXt/dw+mlZfD50vucdi4cQM+/OAD/PvTz8Yl5ZaUlKCvrw8fffgBfnDyKWhoaEDNV9X40Y/PtR6zc2cdqqu34Sc/WToBtmNxBYNBzJs3D3fddRfuvPPOhI9ZsWIFzjrrLNx999249NJLUVNTg+XLl+Pmm2/GjBkzkJWVhY6ODvj9fiiKgvfeew+RSASyLCM9PR379xuTz30+n1WxwE5St9sNVVWxf/9+qigKfD4fJEkig4OD0DSNMj8GSxcRBIEV24MBbgTIWYCydR0ZaeOTh4UlS5YMANjD/V32GuTRRx/1zZo1KyUQCKSkpqameDyeFIfDkSJJUoooiimCIPgIIT5CiJcQ4jZByBoAsNcCBwZrbByldJBSGqaUhnRdD2ma1q+qal80Gu0bGBjo7+np6Wtvb+//8ssvQ8uXLx/g4EVtIKMjwEy3KSxttI110UgAsjiY8SADS6g1p6Tx5iaDma2tUBzQWN80p9MJSilSU1NtrbtTcdZZP8S77/43Ghvq4XQ6ceddv4LP50NraytuvvFfoSgx9Pb24oLzluAf587F7b+8E6sffwyRSATX/5+hCZKrn/oD/H4/7n9wJR575GH84d/XwOPx4Gbb4OGqzz5DZeW6MQ+2cVd5oKoq1q1bBwBYuXIlbrvtNjQ0NKC42OgBKUkSXnrpJVx00UUAgD/96U+47777UF9fj0AggKuvvhp33XUXCCHYsmULrr76atTW1sLj8aC83JivWFVVhWXLlqG2thZ///vfsXjxYqtqYdeuXWhubkZFRQUURcHOnTuhqiqCwSCbloXu7m6m1CAIAjuxCeeLsyDH9hNALg52nJoTEoEswT5/m2jjX2ekDQlu7ftxbrAE+/ztSJsdZPYtmUobts8G9ySC2GgwY/u2xqUHBTRepfHNIHt6ejBpUj68Pi/8fnO+p1nAnpsbQH5+/iGNwfs2VsPO7Tj55JMnwDZWVm9vL/bs2WP53+z1pmx4jL2ZJVdzCm4MoFW8zMxUPsjAyrW4si3+cyI20MVBjlIQgA6D3SH+nAhsPOCEBFAbCXAjwc0ONCSA2EgKTU+i1uyO/VEhZns93m/GYGbdcqanfXA3tXdtZjBzudxISfEPawLJFFp3dzcKJhdZzSAzMjOt4nK/P2VMfE+OJbCNG1P0hBNOwObNm8dcEI+/yKSmpjLzlHJdHAjX3YEQQuJUHIxxgcTw00EACEkEJUoh2KBHRgHaSHA7FOV2KGA7FLMzGeCoDWgjAUy3AwwglBBQgIAQC2QGzAQBAjEhJgoQ+RIothmlUENqTZYhCAQCIVA1DdmpqcMaQfr9fhBCEAwGoWkafD4/UlNS4fV40dfbh77evmP+RM4PHlvNasYN2DZt2nTUXosf2Nzd3R3XyDIcDo/UqddSboqiWMrNVG98DSrhFBzllBy7pTZTlcFE59Udr7IIAUkEPQ6So4FMGAVoyaBGEkB8NLVGkyi3ZKBjcNJHeg5z9rOZspzzP5Eqs8GMQBDY7FqBCsLwmRqSJBlgk2TIJtQcZqKt0+GAruuQJBmZmZlW5QBrBCmKIoqLpyLbnEUwsSbAdtRXQUEBcnNz0dbWZnXpTWSeso4hIwGO3xjYRoMcBzhomkYJkxhDQIuDjU3hxUGPSz0ZBjDTtB0JZEfSx2b7mSmppMCjiZ7Pdc7AsH2D9gbQCAEBAREIFQhBnDozFBoVBQGCKEK0Q02SIEnMp2ZATXY44JBlOEyz06gqECGKAgKBgNWumzWClGUZ02fMOOSB2RNrAmyHdTkcDhQVFVmA6+zstNqQ9/T0oL+/f0T/WzLAcf43q4MIDzkuidiCnGmeIn64Pa/cCExAYQh2IOw7ngxYNpU3qj+Nsn06imIj1s3BQG4U4PE/G+Yj/3dsTn8AoLpOIQgCDJ4RavY/A7GUmcAFBkTT7DRveYUmMoXGAc1UaPHBATc8HsOXpioKJk+ebLXrZtOiotHoiFAjVV0gT1YB9T2H/2QuSQO9/jjQ47InwDYeF6UUHR0d6OzshKpph1TUG4lE0N/fb5mjbEvWyJJtlAI6pZAkCU6ncyTAQdM0vprBgpwgiKBUp7pOTcDpoBSgoKz9KgBCTPCZ33eYIBwOKi6gREa5jdu3eHVw/QzpISq5+Def4HdczhZl+c+iKFrPYealpmkQRWkYzAifg2b4zyyojeZHk02z0+FwwuF0xAHN4xmavD4Q7kdpaSlycnIQCATg9XoP7gRbXQU09ByZE7++B+TJKtBnz5gA23iEWlVVFUAEeH1+eL0+5H6N1lKDg4Po7OxEd/c+9JiT6fv6+xAOhRAOD2BwcACRwQgi0QhipnobGBxEJDIIVVGMq3pi8zRuY4pNVVVIkgRdp0SnOqiuwwCcMRqVRWVNABDZ4YBumrqMRyy6N8QnAk7NIYl5yYMSB2GCjgI2AkKSAi4OWPGP434mhJeaoJRadZjs/0gIMSpEHA7mO6MMahbMDD/acLNzRKCxtkIuuNwuuN0eeL0eeH0+pJjpG2np6Qj396KiogIej+eQzitypKDGwW3CFB2Hq6OjAyACcnK/WbdRt9uNwsJCBAK56OrsQvd+M7jQ22uZpwMDYQwMGDCLRqNwezyIxWLo7+uFJElwu90jmqhMtWmaBkVRIEnyUJBhCG5EVY2/4XQ6zceY/jhRhK4b1ls0GjWUiihiyJZFHNgSpAQxfmAodkETXiyStaNmbaDi1ZT1PGr/vZnQzIPNAlgCpz8IIdA0DQ6HwwIaMy8BwOlwxqdqiIL1GVFK4TLrNF1uF0RRwhefV1l/1+PxoKS0FHmZmXHpG3aF5vf7kZKaivT0dGRmZCI7Jxutu5sOGWoTawJsX3t1dnbB6/Mftr/ndLoQLChAYNIkM/et21Jw/f39CIVDGDAV3OBgBNFoBA5ZxuDgAHw+34g+OH6LxWKQZUdcAb8JOKqGFBBC4Pf7TRVHCaU6dMpMVmoMryECZEni/XScv27IFcYBz/qHDO0Ngx8bNGKDG1VV1YIVpYCmqSCEQhCMagxFUUAEAZJovCdVVaDrlBrF4kMqzXL62zaBGCampqnU5XINyzdj4OKhFgqFEAqFUFw8FS63G3s7OtDWtgezZs0GU33fO34e0tLS0NfXh+ptX8LpcGLGzFlwmwrN4/XA5/WZLboNhZaRkYns7OzDmlyb+fxiKNWd6Fv1vwCAjCd+iIG36hB5pz7pc/zXHQ/nKUXYd4HRjsh7+WxIU9LRe8+HB/26ozWbPJbW/wcaLtbwuOLTqwAAAABJRU5ErkJggg=="],["src","data:image/png;base64,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"],[1,"details-container"],[1,"details"],["href","https://www.tensorflow.org/api_docs/python/tf/debugging/experimental/enable_dump_debug_info","target","blank","rel","noreferrer noopener"],["href","https://www.tensorflow.org/api_docs/python/tf/debugging","target","blank","rel","noreferrer noopener"]],template:function(e,i){1&e&&(h(0,"div",0)(1,"div",1),T(2,"Debugger V2 is inactive because no data is available."),g(),h(3,"div"),T(4,"To use the debugger,"),g(),h(5,"div")(6,"ol")(7,"li"),T(8," Add the following line to the beginning of your program: "),h(9,"div",2)(10,"span"),T(11,"tf.debugging.experimental.enable_dump_debug_info("),g(),h(12,"span",3),T(13,"logdir"),g(),T(14,", "),h(15,"span",3),T(16,'tensor_debug_mode="FULL_HEALTH"'),g(),T(17,", "),h(18,"span",3),T(19,"circular_buffer_size=-1"),g(),h(20,"span"),T(21,")"),g()()(),h(22,"li"),T(23,"Re-run the program."),g()()(),h(24,"div",4)(25,"div",5)(26,"div",6),P(27,"img",7),g(),h(28,"div",8),T(29,"Auto-alerts for problems found"),g()(),h(30,"div",5)(31,"div",6),P(32,"img",9),g(),h(33,"div",8),T(34," Integrated debugging to trace problems to their causes "),g()(),h(35,"div",5)(36,"div",6),P(37,"img",10),g(),h(38,"div",8),T(39,"Link log to code"),g()()(),h(40,"div",11)(41,"div",12),T(42," The log directory must contain TensorFlow Debugger (V2) data. tf.debugging.experimental.enable_dump_debug_info() will collect tensor data, graph structures, the associated stack traces, and source code to the specificed directory logdir as the instrumented TensorFlow program executes. "),g(),h(43,"div",12)(44,"div"),T(45," See "),h(46,"a",13),T(47," documentation "),g(),T(48," of the Python API of Debugger V2. "),g(),h(49,"div"),T(50," See "),h(51,"a",14),T(52," here "),g(),T(53," for other TensorFlow debugging APIs. "),g()()()())},styles:[".arg[_ngcontent-%COMP%] {\n  color: lightblue;\n  font-style: italic;\n  margin: 2px;\n}\n\n.code[_ngcontent-%COMP%] {\n  font-family: 'Roboto Mono', monospace;\n  margin: 10px;\n}\n\n.container[_ngcontent-%COMP%] {\n  height: 100%;\n  font-family: Roboto;\n  font-size: 15px;\n  overflow-y: auto;\n  padding: 50px;\n}\n\n.details-container[_ngcontent-%COMP%] {\n  display: inline-flex;\n  vertical-align: middle;\n  width: 100%;\n}\n\n.details[_ngcontent-%COMP%] {\n  display: inline-block;\n  margin: 10px 60px;\n  width: 50%;\n}\n\n.exhibit-container[_ngcontent-%COMP%] {\n  white-space: nowrap;\n  width: 100%;\n}\n\n.exhibit[_ngcontent-%COMP%] {\n  align-content: center;\n  display: inline-block;\n  margin: 10px 60px;\n  vertical-align: top;\n  width: 310px;\n}\n\n.exhibit[_ngcontent-%COMP%]   .description[_ngcontent-%COMP%] {\n  font-weight: bold;\n  text-align: center;\n  width: 310px;\n}\n\n.exhibit[_ngcontent-%COMP%]   .screenshot[_ngcontent-%COMP%]   canvas[_ngcontent-%COMP%] {\n  height: 200px;\n  width: 100%;\n}\n\n.title[_ngcontent-%COMP%] {\n  font-size: 135%;\n  font-weight: bold;\n  margin-bottom: 25px;\n}"]}),n})(),IX=(()=>{class n{constructor(e){this.store=e}}return n.\u0275fac=function(e){return new(e||n)(C(ke))},n.\u0275cmp=k({type:n,selectors:[["tf-debugger-v2-inactive"]],decls:1,vars:0,template:function(e,i){1&e&&P(0,"inactive-component")},dependencies:[DX],encapsulation:2}),n})(),RX={getWindow:function(){return window}};function AX(n){let t=RX.getWindow().require;return new Promise(e=>{t(n,e)})}var UL_loadMonaco=async function(){let n=RX.getWindow();if(void 0===n.monaco){if(!n.require)throw new Error("loadMonaco() failed because function require() is unavailable");n.require.config({paths:{vs:"/tf-imports/vs"}}),await AX(["vs/editor/editor.main"]),await AX(["vs/python/python.contribution"])}};function iT(n){return n?"vs-dark":"vs"}var qf=(()=>{class n{constructor(e){this.resizeEventDebouncePeriodInMs=100,this.onResize=new L,this.ngUnsubscribe$=new Ae,this.onResize$=new Ae;let i=new ResizeObserver(()=>{this.onResize$.next()});i.observe(e.nativeElement),this.ngUnsubscribe$.subscribe(()=>{i.unobserve(e.nativeElement)})}ngOnInit(){this.onResize$.pipe($a(1),Cr(this.resizeEventDebouncePeriodInMs),ot(this.ngUnsubscribe$)).subscribe(()=>{this.onResize.emit()})}ngOnDestroy(){this.ngUnsubscribe$.next(),this.ngUnsubscribe$.complete()}}return n.\u0275fac=function(e){return new(e||n)(C(be))},n.\u0275dir=xe({type:n,selectors:[["","detectResize",""]],inputs:{resizeEventDebouncePeriodInMs:"resizeEventDebouncePeriodInMs"},outputs:{onResize:"onResize"}}),n})(),YMe=["codeViewerContainer"],FX=(()=>{class n{constructor(){this.lines=null,this.focusedLineno=null,this.monaco=null,this.editor=null,this.decorations=[],this.RESIZE_DEBOUNCE_INTERVAL_MS=50}onResize(){this.editor&&this.editor.layout()}ngOnChanges(e){if(null===this.monaco)return;let i=e.monaco&&null===this.editor;null===this.editor&&(this.editor=this.monaco.editor.create(this.codeViewerContainer.nativeElement,{value:(this.lines??[]).join("\n"),language:"python",readOnly:!0,fontSize:10,minimap:{enabled:!0},theme:iT(this.useDarkMode)})),e.lines&&this.lines&&this.editor.setValue(this.lines.join("\n"));let r=i||e.focusedLineno?this.focusedLineno:null;if(r&&this.lines){this.editor.revealLineInCenter(r,this.monaco.editor.ScrollType.Smooth);let o=this.lines[r-1].length;this.decorations=this.editor.deltaDecorations(this.decorations,[{range:new this.monaco.Range(r,1,r,1),options:{isWholeLine:!0,linesDecorationsClassName:"highlight-gutter"}},{range:new this.monaco.Range(r,1,r,o+1),options:{inlineClassName:"highlight-line"}}])}e.useDarkMode&&this.monaco.editor.setTheme(iT(this.useDarkMode))}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["source-code-component"]],viewQuery:function(e,i){if(1&e&&Ye(YMe,7,be),2&e){let r;we(r=Se())&&(i.codeViewerContainer=r.first)}},inputs:{lines:"lines",focusedLineno:"focusedLineno",monaco:"monaco",useDarkMode:"useDarkMode"},features:[Gt],decls:2,vars:1,consts:[["detectResize","",1,"code-viewer-container",3,"resizeEventDebouncePeriodInMs","onResize"],["codeViewerContainer",""]],template:function(e,i){1&e&&(h(0,"div",0,1),D("onResize",function(){return i.onResize()}),g()),2&e&&_("resizeEventDebouncePeriodInMs",i.RESIZE_DEBOUNCE_INTERVAL_MS)},dependencies:[qf],styles:[".code-viewer-container[_ngcontent-%COMP%] {\n  height: 100%;\n}\n\n[_nghost-%COMP%]     .highlight-gutter {\n  background: rgba(255, 111, 0, 0.7);\n  width: 5px !important;\n}\n\n[_nghost-%COMP%]     .highlight-line {\n  background: rgba(255, 111, 0, 0.3);\n}"],changeDetection:0}),n})(),LX=(()=>{class n{ngOnInit(){this.monaco$=no(UL_loadMonaco()).pipe(U(()=>window.monaco))}constructor(){this.lines=null,this.focusedLineno=null,this.useDarkMode=!1,this.monaco$=null}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["source-code"]],inputs:{lines:"lines",focusedLineno:"focusedLineno",useDarkMode:"useDarkMode"},decls:2,vars:6,consts:[[3,"lines","focusedLineno","monaco","useDarkMode"]],template:function(e,i){1&e&&(P(0,"source-code-component",0),G(1,"async")),2&e&&_("lines",i.lines)("focusedLineno",i.focusedLineno)("monaco",W(1,4,i.monaco$))("useDarkMode",i.useDarkMode)},dependencies:[FX,lt],encapsulation:2}),n})();function ZMe(n,t){if(1&n&&(h(0,"div",6),T(1),g()),2&n){let e=w();b(1),ze(" ",e.focusedSourceLineSpec.file_path," ")}}function KMe(n,t){1&n&&(h(0,"div",7),T(1," No file selected. Click a line number in the Stack Trace section to show the source code. "),g())}function JMe(n,t){if(1&n&&P(0,"source-code",8),2&n){let e=w();_("lines",e.focusedSourceFileContent.lines)("focusedLineno",e.focusedSourceLineSpec.lineno)("useDarkMode",e.useDarkMode)}}var NX=(()=>{class n{constructor(){this.focusedSourceFileContent=null,this.focusedSourceLineSpec=null}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["source-files-component"]],inputs:{focusedSourceFileContent:"focusedSourceFileContent",focusedSourceLineSpec:"focusedSourceLineSpec",useDarkMode:"useDarkMode"},decls:8,vars:3,consts:[[1,"source-files-container"],[1,"header-section"],[1,"title-tag"],["class","file-label",4,"ngIf","ngIfElse"],["noFileSelected",""],[3,"lines","focusedLineno","useDarkMode",4,"ngIf"],[1,"file-label"],[1,"no-file-selected"],[3,"lines","focusedLineno","useDarkMode"]],template:function(e,i){if(1&e&&(h(0,"div",0)(1,"div",1)(2,"div",2),T(3,"Source Code"),g(),S(4,ZMe,2,1,"div",3),S(5,KMe,2,0,"ng-template",null,4,Zt),g(),S(7,JMe,1,3,"source-code",5),g()),2&e){let r=tt(6);b(4),_("ngIf",null!==i.focusedSourceLineSpec)("ngIfElse",r),b(3),_("ngIf",null!==i.focusedSourceFileContent&&null!==i.focusedSourceLineSpec&&null!==i.focusedSourceFileContent.lines)}},dependencies:[Fe,LX],styles:['.header-section[_ngcontent-%COMP%]{border-bottom:1px solid #ebebeb;display:flex;height:24px;padding-bottom:6px;vertical-align:middle;white-space:nowrap;width:100%}body.dark-mode[_nghost-%COMP%]   .header-section[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .header-section[_ngcontent-%COMP%]{border-bottom:1px solid #555}.file-label[_ngcontent-%COMP%]{display:inline-block;font-weight:normal;white-space:normal;overflow-wrap:anywhere;overflow-y:auto;padding:0 20px}.no-file-selected[_ngcontent-%COMP%]{display:inline-block;color:#666;padding:0 20px;white-space:normal}.source-files-container[_ngcontent-%COMP%]{display:flex;flex-direction:column;font-family:"Roboto Mono",monospace;font-size:10px;height:100%}.title-tag[_ngcontent-%COMP%]{display:inline-block;font-weight:bold;height:100%;padding-left:6px;vertical-align:top}source-code[_ngcontent-%COMP%]{flex-grow:1;width:100%}']}),n})(),BX=(()=>{class n{constructor(e){this.store=e,this.focusedSourceFileContent$=this.store.select($E),this.focusedSourceLineSpec$=this.store.select(eT),this.useDarkMode$=this.store.select(El)}}return n.\u0275fac=function(e){return new(e||n)(C(ke))},n.\u0275cmp=k({type:n,selectors:[["tf-debugger-v2-source-files"]],decls:4,vars:9,consts:[[3,"focusedSourceFileContent","focusedSourceLineSpec","useDarkMode"]],template:function(e,i){1&e&&(P(0,"source-files-component",0),G(1,"async"),G(2,"async"),G(3,"async")),2&e&&_("focusedSourceFileContent",W(1,3,i.focusedSourceFileContent$))("focusedSourceLineSpec",W(2,5,i.focusedSourceLineSpec$))("useDarkMode",W(3,7,i.useDarkMode$))},dependencies:[NX,lt],encapsulation:2}),n})(),twe=["stackFrameArray"];function nwe(n,t){if(1&n&&(h(0,"span",13),T(1),g()),2&n){let e=w(3);b(1),ze(" #",e.executionIndex,": ")}}function iwe(n,t){if(1&n&&(h(0,"span",14),T(1),g()),2&n){let e=w(3);b(1),ze(" ",e.opType," ")}}function rwe(n,t){if(1&n&&(h(0,"div"),T(1," Eager execution "),S(2,nwe,2,1,"span",11),S(3,iwe,2,1,"span",12),g()),2&n){let e=w(2);b(2),_("ngIf",null!==e.opType),b(1),_("ngIf",null!==e.opType)}}function owe(n,t){if(1&n&&(h(0,"span",16),T(1),g()),2&n){let e=w(3);b(1),ze(' "',e.opName,'" ')}}function awe(n,t){if(1&n&&(h(0,"span",14),T(1),g()),2&n){let e=w(3);b(1),ze(" ",e.opType," ")}}function swe(n,t){if(1&n&&(h(0,"div"),T(1," Creation of graph op "),S(2,owe,2,1,"span",15),S(3,awe,2,1,"span",12),g()),2&n){let e=w(2);b(2),_("ngIf",null!==e.opName),b(1),_("ngIf",null!==e.opType)}}function lwe(n,t){if(1&n&&(h(0,"span",17),T(1),g()),2&n){let e=w(2);b(1),ze(" (Host name: ",e.stackFramesForDisplay[0].host_name,") ")}}function cwe(n,t){if(1&n&&(h(0,"div",7)(1,"span")(2,"span",8),S(3,rwe,4,2,"div",9),S(4,swe,4,2,"div",9),g()(),h(5,"div"),S(6,lwe,2,1,"span",10),g()()),2&n){let e=w();b(2),_("ngSwitch",e.codeLocationType),b(1),_("ngSwitchCase",e.CodeLocationType.EXECUTION),b(1),_("ngSwitchCase",e.CodeLocationType.GRAPH_OP_CREATION),b(2),_("ngIf",null!==e.stackFramesForDisplay&&e.stackFramesForDisplay.length>0)}}function dwe(n,t){1&n&&(h(0,"div",18),T(1," Click an eager execution or graph op to show its original stack trace. "),g())}function uwe(n,t){1&n&&(h(0,"div",28),T(1," \u2913 "),g())}var pwe=function(n,t){return[n,t]};function fwe(n,t){if(1&n){let e=ge();h(0,"div",22)(1,"div",23),T(2),g(),h(3,"div",24),S(4,uwe,2,0,"div",25),h(5,"div",26),D("click",function(){let o=X(e).$implicit;return Q(w(2).onSourceLineClicked.emit(o))}),T(6),g(),h(7,"div",27),T(8),g()()()}if(2&n){let e=t.$implicit,i=w(2);_("ngClass",Pr(6,pwe,e.belongsToFocusedFile?"focused-file":"",e.focused?"focused-stack-frame":"")),b(1),Ji("title",e.file_path),b(1),ze(" ",e.concise_file_path," "),b(2),_("ngIf",i.stickToBottommostFrameInFocusedFile&&e.focused),b(2),ze(" Line ",e.lineno," "),b(2),ze(" ",e.function_name," ")}}function mwe(n,t){if(1&n&&(h(0,"div",19,20),S(2,fwe,9,9,"div",21),g()),2&n){let e=w();b(2),_("ngForOf",e.stackFramesForDisplay)}}function hwe(n,t){}var VX=(()=>{class n{constructor(){this.stackFramesForDisplay=null,this.onSourceLineClicked=new L,this.CodeLocationType=Bo}ngAfterViewChecked(){if(void 0===this.stackFrameArray)return;let e=this.stackFrameArray.nativeElement,i=e.querySelector(".focused-stack-frame");if(null!==i)return void this.scrollToElement(e,i);let r=e.querySelector(".stack-frame-container:last-child");null!==r&&this.scrollToElement(e,r)}scrollToElement(e,i){e.scrollTop=i.offsetTop}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["stack-trace-component"]],viewQuery:function(e,i){if(1&e&&Ye(twe,5),2&e){let r;we(r=Se())&&(i.stackFrameArray=r.first)}},inputs:{codeLocationType:"codeLocationType",opType:"opType",opName:"opName",executionIndex:"executionIndex",stickToBottommostFrameInFocusedFile:"stickToBottommostFrameInFocusedFile",stackFramesForDisplay:"stackFramesForDisplay"},outputs:{onSourceLineClicked:"onSourceLineClicked"},decls:10,vars:4,consts:[[1,"stack-trace-container"],[1,"stack-trace-header"],[1,"stack-trace-title"],["class","stack-trace-aux-info",4,"ngIf","ngIfElse"],["noStackTrace",""],["class","stack-frame-array",4,"ngIf","ngIfElse"],["loadingSection",""],[1,"stack-trace-aux-info"],[1,"code-location-origin",3,"ngSwitch"],[4,"ngSwitchCase"],["class","stack-trace-host-name",4,"ngIf"],["class","eager-execution-index",4,"ngIf"],["class","op-type",4,"ngIf"],[1,"eager-execution-index"],[1,"op-type"],["class","op-name",4,"ngIf"],[1,"op-name"],[1,"stack-trace-host-name"],[1,"stack-trace-aux-info","no-stack-trace"],[1,"stack-frame-array"],["stackFrameArray",""],["class","stack-frame-container",3,"ngClass",4,"ngFor","ngForOf"],[1,"stack-frame-container",3,"ngClass"],[1,"stack-frame-file-path",3,"title"],[1,"stack-frame-lineno-function"],["class","stick-to-bottommost-indicator","title","Sticking to the bottommost frame in the current source file when navigating executions and graph ops. To remove this sticking, click any non-bottommost stack frame.",4,"ngIf"],[1,"stack-frame-lineno",3,"click"],[1,"stack-frame-function"],["title","Sticking to the bottommost frame in the current source file when navigating executions and graph ops. To remove this sticking, click any non-bottommost stack frame.",1,"stick-to-bottommost-indicator"]],template:function(e,i){if(1&e&&(h(0,"div",0)(1,"div",1)(2,"span",2),T(3," Stack Trace "),g(),S(4,cwe,7,4,"div",3),S(5,dwe,2,0,"ng-template",null,4,Zt),g(),S(7,mwe,3,1,"div",5),S(8,hwe,0,0,"ng-template",null,6,Zt),g()),2&e){let r=tt(6),o=tt(9);b(4),_("ngIf",null!==i.codeLocationType)("ngIfElse",r),b(3),_("ngIf",null!==i.stackFramesForDisplay)("ngIfElse",o)}},dependencies:[bn,dn,Fe,$i,sr],styles:['.focused-file[_ngcontent-%COMP%]{font-weight:bold}.focused-stack-frame[_ngcontent-%COMP%]{background-color:rgba(255,111,0,.3)}.no-stack-trace[_ngcontent-%COMP%]{color:gray}.op-name[_ngcontent-%COMP%]{word-wrap:anywhere}.op-type[_ngcontent-%COMP%]{background-color:#eceff1;border:1px solid #ebebeb;border-radius:4px;font-family:"Roboto Mono",monospace;font-size:10px;height:14px;line-height:14px;padding:1px 3px;width:max-content}body.dark-mode[_nghost-%COMP%]   .op-type[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .op-type[_ngcontent-%COMP%]{border:1px solid #555}body.dark-mode[_nghost-%COMP%]   .op-type[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .op-type[_ngcontent-%COMP%]{background-color:#455a64}.stack-frame-array[_ngcontent-%COMP%]{overflow-x:hidden;overflow-y:auto;width:calc(100% - 8px)}.stack-frame-container[_ngcontent-%COMP%]{border-bottom:1px solid #a0a0a0}.stack-frame-file-path[_ngcontent-%COMP%]{max-width:180px;width:180px}.stack-frame-lineno-function[_ngcontent-%COMP%]{text-align:right;white-space:nowrap}.stack-frame-function[_ngcontent-%COMP%]{display:inline-block;max-width:200px;padding-left:10px;text-align:left;white-space:normal;width:200px;word-wrap:anywhere}.stack-frame-lineno[_ngcontent-%COMP%]{cursor:pointer;display:inline-block;max-width:80px;text-align:left;text-decoration:underline;width:80px}.stack-trace-aux-info[_ngcontent-%COMP%]{margin-top:15px;padding-left:24px}.stack-trace-container[_ngcontent-%COMP%]{border-left:1px solid #ebebeb;box-sizing:border-box;display:flex;flex-flow:column;font-size:10px;font-family:"Roboto Mono",monospace;height:100%;margin-left:8px;max-height:360px;overflow-x:hidden;overflow-y:hidden;padding-left:8px;width:100%}body.dark-mode[_nghost-%COMP%]   .stack-trace-container[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .stack-trace-container[_ngcontent-%COMP%]{border-left:1px solid #555}.stack-trace-header[_ngcontent-%COMP%]{box-shadow:0 5px 3px -3px #ccc;padding-bottom:3px}.stack-trace-host-name[_ngcontent-%COMP%]{color:gray}.stack-trace-title[_ngcontent-%COMP%]{font-weight:bold}.stick-to-bottommost-indicator[_ngcontent-%COMP%]{display:inline-block;font-weight:bold;font-size:12px;padding-right:3px}']}),n})(),HX=(()=>{class n{constructor(e){this.store=e,this.codeLocationType$=this.store.pipe(pn(q(vv,i=>null===i?null:i.codeLocationType))),this.opType$=this.store.pipe(pn(q(vv,i=>null===i?null:i.opType))),this.opName$=this.store.pipe(pn(q(vv,i=>null===i||i.codeLocationType!==Bo.GRAPH_OP_CREATION?null:i.opName))),this.executionIndex$=this.store.pipe(pn(q(vv,i=>null===i||i.codeLocationType!==Bo.EXECUTION?null:i.executionIndex))),this.stickToBottommostFrameInFocusedFile$=this.store.pipe(pn(yX)),this.stackFramesForDisplay$=this.store.pipe(pn(q(gX,eT,(i,r)=>{if(null===i)return null;let o=[];for(let a of i){let{host_name:s,file_path:l,lineno:c,function_name:d}=a,u=l.split("/"),f=null!==r&&s===r.host_name&&l===r.file_path;o.push({host_name:s,file_path:l,concise_file_path:u[u.length-1],lineno:c,function_name:d,belongsToFocusedFile:f,focused:f&&c===r.lineno})}return o})))}onSourceLineClicked(e){let{host_name:i,file_path:r,lineno:o,function_name:a}=e;this.store.dispatch(qg({stackFrame:{host_name:i,file_path:r,lineno:o,function_name:a}}))}}return n.\u0275fac=function(e){return new(e||n)(C(ke))},n.\u0275cmp=k({type:n,selectors:[["tf-debugger-v2-stack-trace"]],decls:7,vars:18,consts:[[3,"codeLocationType","opType","opName","executionIndex","stickToBottommostFrameInFocusedFile","stackFramesForDisplay","onSourceLineClicked"]],template:function(e,i){1&e&&(h(0,"stack-trace-component",0),D("onSourceLineClicked",function(o){return i.onSourceLineClicked(o)}),G(1,"async"),G(2,"async"),G(3,"async"),G(4,"async"),G(5,"async"),G(6,"async"),g()),2&e&&_("codeLocationType",W(1,6,i.codeLocationType$))("opType",W(2,8,i.opType$))("opName",W(3,10,i.opName$))("executionIndex",W(4,12,i.executionIndex$))("stickToBottommostFrameInFocusedFile",W(5,14,i.stickToBottommostFrameInFocusedFile$))("stackFramesForDisplay",W(6,16,i.stackFramesForDisplay$))},dependencies:[VX,lt],encapsulation:2}),n})(),ywe=function(n,t){return{tensorDebugMode:n,array:t}};function bwe(n,t){if(1&n&&(h(0,"div",12)(1,"div",13),T(2),g(),h(3,"div",14),P(4,"debug-tensor-value",15),g()()),2&n){let e=t.$implicit,i=t.index,r=w(3);b(2),ze("Output slot ",i,":"),b(2),_("debugTensorValue",r.parseDebugTensorValue(Pr(2,ywe,r.tensorDebugMode,e)))}}function vwe(n,t){if(1&n&&(h(0,"div",10),S(1,bwe,5,5,"div",11),g()),2&n){let e=w(2);b(1),_("ngForOf",e.debugTensorValues)}}function xwe(n,t){if(1&n&&(h(0,"div")(1,"div")(2,"div",3)(3,"span",4),T(4," Op: "),g(),h(5,"span",5),T(6),g()(),h(7,"div",3)(8,"span",4),T(9," # of input tensors: "),g(),h(10,"span",6),T(11),g()(),h(12,"div",3)(13,"span",4),T(14," # of output tensors: "),g(),h(15,"span",7),T(16),g(),h(17,"span",8),T(18),g()(),S(19,vwe,2,1,"div",9),g()()),2&n){let e=w();b(6),ze(" ",e.focusedExecutionData.op_type," "),b(5),ze(" ",null==e.focusedExecutionData.input_tensor_ids?0:e.focusedExecutionData.input_tensor_ids.length," "),b(5),ze(" ",null==e.focusedExecutionData.output_tensor_ids?0:e.focusedExecutionData.output_tensor_ids.length," "),b(2),ze(" (debug mode: ",e.TensorDebugMode[e.tensorDebugMode],") "),b(1),_("ngIf",e.hasDebugTensorValues)}}function Cwe(n,t){}var zX=(()=>{class n{constructor(){this.tensorDebugMode=Eo.UNSPECIFIED,this.hasDebugTensorValues=!1,this.debugTensorValues=null,this.debugTensorDtypes=null,this.TensorDebugMode=Eo,this.parseDebugTensorValue=tT}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["execution-data-component"]],inputs:{focusedExecutionIndex:"focusedExecutionIndex",focusedExecutionData:"focusedExecutionData",tensorDebugMode:"tensorDebugMode",hasDebugTensorValues:"hasDebugTensorValues",debugTensorValues:"debugTensorValues",debugTensorDtypes:"debugTensorDtypes"},decls:7,vars:3,consts:[[1,"focus-execution-container"],[4,"ngIf","ngIfElse"],["loading_section",""],[1,"execution-data-field"],[1,"execution-data-key"],[1,"execution-data-value","op-type"],[1,"execution-data-value","input-tensors"],[1,"execution-data-value","output-tensors"],[1,"execution-data-value"],["class","output-slots",4,"ngIf"],[1,"output-slots"],["class","output-slot-container",4,"ngFor","ngForOf"],[1,"output-slot-container"],[1,"output-slot-number"],[1,"output-slot-debug-tensor-value"],[3,"debugTensorValue"]],template:function(e,i){if(1&e&&(h(0,"div",0)(1,"div")(2,"span"),T(3),g()(),S(4,xwe,20,5,"div",1),S(5,Cwe,0,0,"ng-template",null,2,Zt),g()),2&e){let r=tt(6);b(3),ze(" Python Execution #",i.focusedExecutionIndex," "),b(1),_("ngIf",null!==i.focusedExecutionData)("ngIfElse",r)}},dependencies:[dn,Fe,nT],styles:['.debug-tensor-values-table[_ngcontent-%COMP%]{width:100%}.debug-tensor-values-table[_ngcontent-%COMP%]   td[_ngcontent-%COMP%]{border-top:1px solid #000;text-align:left}.debug-tensor-values-table[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]{text-align:left}.execution-data-field[_ngcontent-%COMP%]{white-space:nowrap}.execution-data-key[_ngcontent-%COMP%]{display:inline-block;max-width:120px;text-align:right;width:120px}.execution-data-value[_ngcontent-%COMP%]{display:inline-block;margin-left:10px}.focus-execution-container[_ngcontent-%COMP%]{background-color:#ffcc80;border-radius:4px;font-size:12px;height:120px;padding:5px;width:360px}body.dark-mode[_nghost-%COMP%]   .focus-execution-container[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .focus-execution-container[_ngcontent-%COMP%]{background-color:#e65100}.output-slots[_ngcontent-%COMP%]{height:60px;overflow-x:auto;overflow-y:auto}.output-slot-container[_ngcontent-%COMP%]{border-top:1px solid #ebebeb;margin-top:5px;padding:2px 0;vertical-align:top}body.dark-mode[_nghost-%COMP%]   .output-slot-container[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .output-slot-container[_ngcontent-%COMP%]{border-top:1px solid #555}.output-slot-number[_ngcontent-%COMP%]{display:block;font-family:"Roboto Mono",monospace}.output-slot-debug-tensor-value[_ngcontent-%COMP%]{display:block;margin:3px 0 3px 30px}.output-tensors[_ngcontent-%COMP%]{margin-top:5px}']}),n})(),UX="Unknown dtype",jX=(()=>{class n{constructor(e){this.store=e,this.focusedExecutionData$=this.store.pipe(pn(Wf)),this.tensorDebugMode$=this.store.pipe(pn(q(Wf,i=>null===i?Eo.UNSPECIFIED:i.tensor_debug_mode))),this.hasDebugTensorValues$=this.store.pipe(pn(q(Wf,i=>{if(null===i||null===i.debug_tensor_values)return!1;for(let r of i.debug_tensor_values)if(null!==r&&r.length>0)return!0;return!1}))),this.debugTensorValues$=this.store.pipe(pn(q(Wf,i=>null===i?null:i.debug_tensor_values))),this.debugTensorDtypes$=this.store.pipe(pn(q(Wf,i=>{if(null===i||null===i.debug_tensor_values||i.tensor_debug_mode!==Eo.FULL_HEALTH&&i.tensor_debug_mode!==Eo.SHAPE)return null;let r=[];for(let o of i.debug_tensor_values)if(null===o)r.push(UX);else{let a=String(i.tensor_debug_mode===Eo.FULL_HEALTH?o[2]:o[1]);r.push(xv[a]||UX)}return r})))}}return n.\u0275fac=function(e){return new(e||n)(C(ke))},n.\u0275cmp=k({type:n,selectors:[["tf-debugger-v2-execution-data"]],inputs:{focusedExecutionIndex:"focusedExecutionIndex"},decls:6,vars:16,consts:[[3,"focusedExecutionIndex","focusedExecutionData","tensorDebugMode","hasDebugTensorValues","debugTensorValues","debugTensorDtypes"]],template:function(e,i){1&e&&(P(0,"execution-data-component",0),G(1,"async"),G(2,"async"),G(3,"async"),G(4,"async"),G(5,"async")),2&e&&_("focusedExecutionIndex",i.focusedExecutionIndex)("focusedExecutionData",W(1,6,i.focusedExecutionData$))("tensorDebugMode",W(2,8,i.tensorDebugMode$))("hasDebugTensorValues",W(3,10,i.hasDebugTensorValues$))("debugTensorValues",W(4,12,i.debugTensorValues$))("debugTensorDtypes",W(5,14,i.debugTensorDtypes$))},dependencies:[zX,lt],encapsulation:2}),n})(),Swe=["sliderWrapper"],Zs=Yo({passive:!1}),Awe={provide:Hr,useExisting:Vn(()=>Td),multi:!0},Rwe=vd(go(Kr(class{constructor(n){this._elementRef=n}}),"accent")),Td=(()=>{class n extends Rwe{get invert(){return this._invert}set invert(e){this._invert=Ut(e)}get max(){return this._max}set max(e){this._max=Di(e,this._max),this._percent=this._calculatePercentage(this._value),this._changeDetectorRef.markForCheck()}get min(){return this._min}set min(e){this._min=Di(e,this._min),this._percent=this._calculatePercentage(this._value),this._changeDetectorRef.markForCheck()}get step(){return this._step}set step(e){this._step=Di(e,this._step),this._step%1!=0&&(this._roundToDecimal=this._step.toString().split(".").pop().length),this._changeDetectorRef.markForCheck()}get thumbLabel(){return this._thumbLabel}set thumbLabel(e){this._thumbLabel=Ut(e)}get tickInterval(){return this._tickInterval}set tickInterval(e){this._tickInterval="auto"===e?"auto":"number"==typeof e||"string"==typeof e?Di(e,this._tickInterval):0}get value(){return null===this._value&&(this.value=this._min),this._value}set value(e){if(e!==this._value){let i=Di(e,0);this._roundToDecimal&&i!==this.min&&i!==this.max&&(i=parseFloat(i.toFixed(this._roundToDecimal))),this._value=i,this._percent=this._calculatePercentage(this._value),this._changeDetectorRef.markForCheck()}}get vertical(){return this._vertical}set vertical(e){this._vertical=Ut(e)}get displayValue(){return this.displayWith?this.displayWith(this.value):this._roundToDecimal&&this.value&&this.value%1!=0?this.value.toFixed(this._roundToDecimal):this.value||0}focus(e){this._focusHostElement(e)}blur(){this._blurHostElement()}get percent(){return this._clamp(this._percent)}_shouldInvertAxis(){return this.vertical?!this.invert:this.invert}_isMinValue(){return 0===this.percent}_getThumbGap(){return this.disabled?7:this._isMinValue()&&!this.thumbLabel?this._isActive?10:7:0}_getTrackBackgroundStyles(){let i=this.vertical?`1, ${1-this.percent}, 1`:1-this.percent+", 1, 1";return{transform:`translate${this.vertical?"Y":"X"}(${this._shouldInvertMouseCoords()?"-":""}${this._getThumbGap()}px) scale3d(${i})`}}_getTrackFillStyles(){let e=this.percent,r=this.vertical?`1, ${e}, 1`:`${e}, 1, 1`;return{transform:`translate${this.vertical?"Y":"X"}(${this._shouldInvertMouseCoords()?"":"-"}${this._getThumbGap()}px) scale3d(${r})`,display:0===e?"none":""}}_getTicksContainerStyles(){return{transform:`translate${this.vertical?"Y":"X"}(${this.vertical||"rtl"!=this._getDirection()?"-":""}${this._tickIntervalPercent/2*100}%)`}}_getTicksStyles(){let e=100*this._tickIntervalPercent,s={backgroundSize:this.vertical?`2px ${e}%`:`${e}% 2px`,transform:`translateZ(0) translate${this.vertical?"Y":"X"}(${this.vertical||"rtl"!=this._getDirection()?"":"-"}${e/2}%)${this.vertical||"rtl"!=this._getDirection()?"":" rotate(180deg)"}`};if(this._isMinValue()&&this._getThumbGap()){let c,l=this._shouldInvertAxis();c=this.vertical?l?"Bottom":"Top":l?"Right":"Left",s[`padding${c}`]=`${this._getThumbGap()}px`}return s}_getThumbContainerStyles(){let e=this._shouldInvertAxis();return{transform:`translate${this.vertical?"Y":"X"}(-${100*(("rtl"!=this._getDirection()||this.vertical?e:!e)?this.percent:1-this.percent)}%)`}}_shouldInvertMouseCoords(){let e=this._shouldInvertAxis();return"rtl"!=this._getDirection()||this.vertical?e:!e}_getDirection(){return this._dir&&"rtl"==this._dir.value?"rtl":"ltr"}constructor(e,i,r,o,a,s,l,c){super(e),this._focusMonitor=i,this._changeDetectorRef=r,this._dir=o,this._ngZone=s,this._animationMode=c,this._invert=!1,this._max=100,this._min=0,this._step=1,this._thumbLabel=!1,this._tickInterval=0,this._value=null,this._vertical=!1,this.change=new L,this.input=new L,this.valueChange=new L,this.onTouched=()=>{},this._percent=0,this._isSliding=null,this._isActive=!1,this._tickIntervalPercent=0,this._sliderDimensions=null,this._controlValueAccessorChangeFn=()=>{},this._dirChangeSubscription=yn.EMPTY,this._pointerDown=d=>{this.disabled||this._isSliding||!Cv(d)&&0!==d.button||this._ngZone.run(()=>{this._touchId=Cv(d)?function(n,t){for(let e=0;e<n.touches.length;e++){let i=n.touches[e].target;if(t===i||t.contains(i))return n.touches[e].identifier}}(d,this._elementRef.nativeElement):void 0;let u=WX(d,this._touchId);if(u){let p=this.value;this._isSliding="pointer",this._lastPointerEvent=d,this._focusHostElement(),this._onMouseenter(),this._bindGlobalEvents(d),this._focusHostElement(),this._updateValueFromPosition(u),this._valueOnSlideStart=p,d.cancelable&&d.preventDefault(),p!=this.value&&this._emitInputEvent()}})},this._pointerMove=d=>{if("pointer"===this._isSliding){let u=WX(d,this._touchId);if(u){d.cancelable&&d.preventDefault();let p=this.value;this._lastPointerEvent=d,this._updateValueFromPosition(u),p!=this.value&&this._emitInputEvent()}}},this._pointerUp=d=>{"pointer"===this._isSliding&&(!Cv(d)||"number"!=typeof this._touchId||GL(d.changedTouches,this._touchId))&&(d.cancelable&&d.preventDefault(),this._removeGlobalEvents(),this._isSliding=null,this._touchId=void 0,this._valueOnSlideStart!=this.value&&!this.disabled&&this._emitChangeEvent(),this._valueOnSlideStart=this._lastPointerEvent=null)},this._windowBlur=()=>{this._lastPointerEvent&&this._pointerUp(this._lastPointerEvent)},this._document=l,this.tabIndex=parseInt(a)||0,s.runOutsideAngular(()=>{let d=e.nativeElement;d.addEventListener("mousedown",this._pointerDown,Zs),d.addEventListener("touchstart",this._pointerDown,Zs)})}ngAfterViewInit(){this._focusMonitor.monitor(this._elementRef,!0).subscribe(e=>{this._isActive=!!e&&"keyboard"!==e,this._changeDetectorRef.detectChanges()}),this._dir&&(this._dirChangeSubscription=this._dir.change.subscribe(()=>{this._changeDetectorRef.markForCheck()}))}ngOnDestroy(){let e=this._elementRef.nativeElement;e.removeEventListener("mousedown",this._pointerDown,Zs),e.removeEventListener("touchstart",this._pointerDown,Zs),this._lastPointerEvent=null,this._removeGlobalEvents(),this._focusMonitor.stopMonitoring(this._elementRef),this._dirChangeSubscription.unsubscribe()}_onMouseenter(){this.disabled||(this._sliderDimensions=this._getSliderDimensions(),this._updateTickIntervalPercent())}_onFocus(){this._sliderDimensions=this._getSliderDimensions(),this._updateTickIntervalPercent()}_onBlur(){this.onTouched()}_onKeydown(e){if(this.disabled||yr(e)||this._isSliding&&"keyboard"!==this._isSliding)return;let i=this.value;switch(e.keyCode){case 33:this._increment(10);break;case 34:this._increment(-10);break;case 35:this.value=this.max;break;case 36:this.value=this.min;break;case 37:this._increment("rtl"==this._getDirection()?1:-1);break;case 38:this._increment(1);break;case 39:this._increment("rtl"==this._getDirection()?-1:1);break;case 40:this._increment(-1);break;default:return}i!=this.value&&(this._emitInputEvent(),this._emitChangeEvent()),this._isSliding="keyboard",e.preventDefault()}_onKeyup(){"keyboard"===this._isSliding&&(this._isSliding=null)}_getWindow(){return this._document.defaultView||window}_bindGlobalEvents(e){let i=this._document,r=Cv(e),a=r?"touchend":"mouseup";i.addEventListener(r?"touchmove":"mousemove",this._pointerMove,Zs),i.addEventListener(a,this._pointerUp,Zs),r&&i.addEventListener("touchcancel",this._pointerUp,Zs);let s=this._getWindow();typeof s<"u"&&s&&s.addEventListener("blur",this._windowBlur)}_removeGlobalEvents(){let e=this._document;e.removeEventListener("mousemove",this._pointerMove,Zs),e.removeEventListener("mouseup",this._pointerUp,Zs),e.removeEventListener("touchmove",this._pointerMove,Zs),e.removeEventListener("touchend",this._pointerUp,Zs),e.removeEventListener("touchcancel",this._pointerUp,Zs);let i=this._getWindow();typeof i<"u"&&i&&i.removeEventListener("blur",this._windowBlur)}_increment(e){let i=this._clamp(this.value||0,this.min,this.max);this.value=this._clamp(i+this.step*e,this.min,this.max)}_updateValueFromPosition(e){if(!this._sliderDimensions)return;let a=this._clamp(((this.vertical?e.y:e.x)-(this.vertical?this._sliderDimensions.top:this._sliderDimensions.left))/(this.vertical?this._sliderDimensions.height:this._sliderDimensions.width));if(this._shouldInvertMouseCoords()&&(a=1-a),0===a)this.value=this.min;else if(1===a)this.value=this.max;else{let s=this._calculateValue(a),l=Math.round((s-this.min)/this.step)*this.step+this.min;this.value=this._clamp(l,this.min,this.max)}}_emitChangeEvent(){this._controlValueAccessorChangeFn(this.value),this.valueChange.emit(this.value),this.change.emit(this._createChangeEvent())}_emitInputEvent(){this.input.emit(this._createChangeEvent())}_updateTickIntervalPercent(){if(!this.tickInterval||!this._sliderDimensions)return;let e;if("auto"==this.tickInterval){let i=this.vertical?this._sliderDimensions.height:this._sliderDimensions.width;e=Math.ceil(30/(i*this.step/(this.max-this.min)))*this.step/i}else e=this.tickInterval*this.step/(this.max-this.min);this._tickIntervalPercent=GX(e)?e:0}_createChangeEvent(e=this.value){let i=new class{};return i.source=this,i.value=e,i}_calculatePercentage(e){let i=((e||0)-this.min)/(this.max-this.min);return GX(i)?i:0}_calculateValue(e){return this.min+e*(this.max-this.min)}_clamp(e,i=0,r=1){return Math.max(i,Math.min(e,r))}_getSliderDimensions(){return this._sliderWrapper?this._sliderWrapper.nativeElement.getBoundingClientRect():null}_focusHostElement(e){this._elementRef.nativeElement.focus(e)}_blurHostElement(){this._elementRef.nativeElement.blur()}writeValue(e){this.value=e}registerOnChange(e){this._controlValueAccessorChangeFn=e}registerOnTouched(e){this.onTouched=e}setDisabledState(e){this.disabled=e}}return n.\u0275fac=function(e){return new(e||n)(C(be),C(lr),C(Ft),C(Hi,8),Vr("tabindex"),C(at),C(kt),C(di,8))},n.\u0275cmp=k({type:n,selectors:[["mat-slider"]],viewQuery:function(e,i){if(1&e&&Ye(Swe,5),2&e){let r;we(r=Se())&&(i._sliderWrapper=r.first)}},hostAttrs:["role","slider",1,"mat-slider","mat-focus-indicator"],hostVars:29,hostBindings:function(e,i){1&e&&D("focus",function(){return i._onFocus()})("blur",function(){return i._onBlur()})("keydown",function(o){return i._onKeydown(o)})("keyup",function(){return i._onKeyup()})("mouseenter",function(){return i._onMouseenter()})("selectstart",function(o){return o.preventDefault()}),2&e&&(Co("tabIndex",i.tabIndex),Pe("aria-disabled",i.disabled)("aria-valuemax",i.max)("aria-valuemin",i.min)("aria-valuenow",i.value)("aria-valuetext",null==i.valueText?i.displayValue:i.valueText)("aria-orientation",i.vertical?"vertical":"horizontal"),Qe("mat-slider-disabled",i.disabled)("mat-slider-has-ticks",i.tickInterval)("mat-slider-horizontal",!i.vertical)("mat-slider-axis-inverted",i._shouldInvertAxis())("mat-slider-invert-mouse-coords",i._shouldInvertMouseCoords())("mat-slider-sliding",i._isSliding)("mat-slider-thumb-label-showing",i.thumbLabel)("mat-slider-vertical",i.vertical)("mat-slider-min-value",i._isMinValue())("mat-slider-hide-last-tick",i.disabled||i._isMinValue()&&i._getThumbGap()&&i._shouldInvertAxis())("_mat-animation-noopable","NoopAnimations"===i._animationMode))},inputs:{disabled:"disabled",color:"color",tabIndex:"tabIndex",invert:"invert",max:"max",min:"min",step:"step",thumbLabel:"thumbLabel",tickInterval:"tickInterval",value:"value",displayWith:"displayWith",valueText:"valueText",vertical:"vertical"},outputs:{change:"change",input:"input",valueChange:"valueChange"},exportAs:["matSlider"],features:[Rt([Awe]),Le],decls:13,vars:6,consts:[[1,"mat-slider-wrapper"],["sliderWrapper",""],[1,"mat-slider-track-wrapper"],[1,"mat-slider-track-background",3,"ngStyle"],[1,"mat-slider-track-fill",3,"ngStyle"],[1,"mat-slider-ticks-container",3,"ngStyle"],[1,"mat-slider-ticks",3,"ngStyle"],[1,"mat-slider-thumb-container",3,"ngStyle"],[1,"mat-slider-focus-ring"],[1,"mat-slider-thumb"],[1,"mat-slider-thumb-label"],[1,"mat-slider-thumb-label-text"]],template:function(e,i){1&e&&(h(0,"div",0,1)(2,"div",2),P(3,"div",3)(4,"div",4),g(),h(5,"div",5),P(6,"div",6),g(),h(7,"div",7),P(8,"div",8)(9,"div",9),h(10,"div",10)(11,"span",11),T(12),g()()()()),2&e&&(b(3),_("ngStyle",i._getTrackBackgroundStyles()),b(1),_("ngStyle",i._getTrackFillStyles()),b(1),_("ngStyle",i._getTicksContainerStyles()),b(1),_("ngStyle",i._getTicksStyles()),b(1),_("ngStyle",i._getThumbContainerStyles()),b(5),ut(i.displayValue))},dependencies:[mu],styles:['.mat-slider{display:inline-block;position:relative;box-sizing:border-box;padding:8px;outline:none;vertical-align:middle}.mat-slider:not(.mat-slider-disabled):active,.mat-slider.mat-slider-sliding:not(.mat-slider-disabled){cursor:grabbing}.mat-slider-wrapper{-webkit-print-color-adjust:exact;color-adjust:exact;position:absolute}.mat-slider-track-wrapper{position:absolute;top:0;left:0;overflow:hidden}.mat-slider-track-fill{position:absolute;transform-origin:0 0;transition:transform 400ms cubic-bezier(0.25, 0.8, 0.25, 1),background-color 400ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-slider-track-background{position:absolute;transform-origin:100% 100%;transition:transform 400ms cubic-bezier(0.25, 0.8, 0.25, 1),background-color 400ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-slider-ticks-container{position:absolute;left:0;top:0;overflow:hidden}.mat-slider-ticks{-webkit-background-clip:content-box;background-clip:content-box;background-repeat:repeat;box-sizing:border-box;opacity:0;transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-slider-thumb-container{position:absolute;z-index:1;transition:transform 400ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-slider-focus-ring{position:absolute;width:30px;height:30px;border-radius:50%;transform:scale(0);opacity:0;transition:transform 400ms cubic-bezier(0.25, 0.8, 0.25, 1),background-color 400ms cubic-bezier(0.25, 0.8, 0.25, 1),opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-slider.cdk-keyboard-focused .mat-slider-focus-ring,.mat-slider.cdk-program-focused .mat-slider-focus-ring{transform:scale(1);opacity:1}.mat-slider:not(.mat-slider-disabled):not(.mat-slider-sliding) .mat-slider-thumb-label,.mat-slider:not(.mat-slider-disabled):not(.mat-slider-sliding) .mat-slider-thumb{cursor:grab}.mat-slider-thumb{position:absolute;right:-10px;bottom:-10px;box-sizing:border-box;width:20px;height:20px;border:3px solid rgba(0,0,0,0);border-radius:50%;transform:scale(0.7);transition:transform 400ms cubic-bezier(0.25, 0.8, 0.25, 1),background-color 400ms cubic-bezier(0.25, 0.8, 0.25, 1),border-color 400ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-slider-thumb-label{display:none;align-items:center;justify-content:center;position:absolute;width:28px;height:28px;border-radius:50%;transition:transform 400ms cubic-bezier(0.25, 0.8, 0.25, 1),border-radius 400ms cubic-bezier(0.25, 0.8, 0.25, 1),background-color 400ms cubic-bezier(0.25, 0.8, 0.25, 1)}.cdk-high-contrast-active .mat-slider-thumb-label{outline:solid 1px}.mat-slider-thumb-label-text{z-index:1;opacity:0;transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-slider-sliding .mat-slider-track-fill,.mat-slider-sliding .mat-slider-track-background,.mat-slider-sliding .mat-slider-thumb-container{transition-duration:0ms}.mat-slider-has-ticks .mat-slider-wrapper::after{content:"";position:absolute;border-width:0;border-style:solid;opacity:0;transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-slider-has-ticks.cdk-focused:not(.mat-slider-hide-last-tick) .mat-slider-wrapper::after,.mat-slider-has-ticks:hover:not(.mat-slider-hide-last-tick) .mat-slider-wrapper::after{opacity:1}.mat-slider-has-ticks.cdk-focused:not(.mat-slider-disabled) .mat-slider-ticks,.mat-slider-has-ticks:hover:not(.mat-slider-disabled) .mat-slider-ticks{opacity:1}.mat-slider-thumb-label-showing .mat-slider-focus-ring{display:none}.mat-slider-thumb-label-showing .mat-slider-thumb-label{display:flex}.mat-slider-axis-inverted .mat-slider-track-fill{transform-origin:100% 100%}.mat-slider-axis-inverted .mat-slider-track-background{transform-origin:0 0}.mat-slider:not(.mat-slider-disabled).cdk-focused.mat-slider-thumb-label-showing .mat-slider-thumb{transform:scale(0)}.mat-slider:not(.mat-slider-disabled).cdk-focused .mat-slider-thumb-label{border-radius:50% 50% 0}.mat-slider:not(.mat-slider-disabled).cdk-focused .mat-slider-thumb-label-text{opacity:1}.mat-slider:not(.mat-slider-disabled).cdk-mouse-focused .mat-slider-thumb,.mat-slider:not(.mat-slider-disabled).cdk-touch-focused .mat-slider-thumb,.mat-slider:not(.mat-slider-disabled).cdk-program-focused .mat-slider-thumb{border-width:2px;transform:scale(1)}.mat-slider-disabled .mat-slider-focus-ring{transform:scale(0);opacity:0}.mat-slider-disabled .mat-slider-thumb{border-width:4px;transform:scale(0.5)}.mat-slider-disabled .mat-slider-thumb-label{display:none}.mat-slider-horizontal{height:48px;min-width:128px}.mat-slider-horizontal .mat-slider-wrapper{height:2px;top:23px;left:8px;right:8px}.mat-slider-horizontal .mat-slider-wrapper::after{height:2px;border-left-width:2px;right:0;top:0}.mat-slider-horizontal .mat-slider-track-wrapper{height:2px;width:100%}.mat-slider-horizontal .mat-slider-track-fill{height:2px;width:100%;transform:scaleX(0)}.mat-slider-horizontal .mat-slider-track-background{height:2px;width:100%;transform:scaleX(1)}.mat-slider-horizontal .mat-slider-ticks-container{height:2px;width:100%}.cdk-high-contrast-active .mat-slider-horizontal .mat-slider-ticks-container{height:0;outline:solid 2px;top:1px}.mat-slider-horizontal .mat-slider-ticks{height:2px;width:100%}.mat-slider-horizontal .mat-slider-thumb-container{width:100%;height:0;top:50%}.mat-slider-horizontal .mat-slider-focus-ring{top:-15px;right:-15px}.mat-slider-horizontal .mat-slider-thumb-label{right:-14px;top:-40px;transform:translateY(26px) scale(0.01) rotate(45deg)}.mat-slider-horizontal .mat-slider-thumb-label-text{transform:rotate(-45deg)}.mat-slider-horizontal.cdk-focused .mat-slider-thumb-label{transform:rotate(45deg)}.cdk-high-contrast-active .mat-slider-horizontal.cdk-focused .mat-slider-thumb-label,.cdk-high-contrast-active .mat-slider-horizontal.cdk-focused .mat-slider-thumb-label-text{transform:none}.mat-slider-vertical{width:48px;min-height:128px}.mat-slider-vertical .mat-slider-wrapper{width:2px;top:8px;bottom:8px;left:23px}.mat-slider-vertical .mat-slider-wrapper::after{width:2px;border-top-width:2px;bottom:0;left:0}.mat-slider-vertical .mat-slider-track-wrapper{height:100%;width:2px}.mat-slider-vertical .mat-slider-track-fill{height:100%;width:2px;transform:scaleY(0)}.mat-slider-vertical .mat-slider-track-background{height:100%;width:2px;transform:scaleY(1)}.mat-slider-vertical .mat-slider-ticks-container{width:2px;height:100%}.cdk-high-contrast-active .mat-slider-vertical .mat-slider-ticks-container{width:0;outline:solid 2px;left:1px}.mat-slider-vertical .mat-slider-focus-ring{bottom:-15px;left:-15px}.mat-slider-vertical .mat-slider-ticks{width:2px;height:100%}.mat-slider-vertical .mat-slider-thumb-container{height:100%;width:0;left:50%}.mat-slider-vertical .mat-slider-thumb{-webkit-backface-visibility:hidden;backface-visibility:hidden}.mat-slider-vertical .mat-slider-thumb-label{bottom:-14px;left:-40px;transform:translateX(26px) scale(0.01) rotate(-45deg)}.mat-slider-vertical .mat-slider-thumb-label-text{transform:rotate(45deg)}.mat-slider-vertical.cdk-focused .mat-slider-thumb-label{transform:rotate(-45deg)}[dir=rtl] .mat-slider-wrapper::after{left:0;right:auto}[dir=rtl] .mat-slider-horizontal .mat-slider-track-fill{transform-origin:100% 100%}[dir=rtl] .mat-slider-horizontal .mat-slider-track-background{transform-origin:0 0}[dir=rtl] .mat-slider-horizontal.mat-slider-axis-inverted .mat-slider-track-fill{transform-origin:0 0}[dir=rtl] .mat-slider-horizontal.mat-slider-axis-inverted .mat-slider-track-background{transform-origin:100% 100%}.mat-slider._mat-animation-noopable .mat-slider-track-fill,.mat-slider._mat-animation-noopable .mat-slider-track-background,.mat-slider._mat-animation-noopable .mat-slider-ticks,.mat-slider._mat-animation-noopable .mat-slider-thumb-container,.mat-slider._mat-animation-noopable .mat-slider-focus-ring,.mat-slider._mat-animation-noopable .mat-slider-thumb,.mat-slider._mat-animation-noopable .mat-slider-thumb-label,.mat-slider._mat-animation-noopable .mat-slider-thumb-label-text,.mat-slider._mat-animation-noopable .mat-slider-has-ticks .mat-slider-wrapper::after{transition:none}'],encapsulation:2,changeDetection:0}),n})();function GX(n){return!isNaN(n)&&isFinite(n)}function Cv(n){return"t"===n.type[0]}function WX(n,t){let e;return e=Cv(n)?"number"==typeof t?GL(n.touches,t)||GL(n.changedTouches,t):n.touches[0]||n.changedTouches[0]:n,e?{x:e.clientX,y:e.clientY}:void 0}function GL(n,t){for(let e=0;e<n.length;e++)if(n[e].identifier===t)return n[e]}var Ku=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Te,Qt,Qt]}),n})();function Pwe(n,t){if(1&n){let e=ge();h(0,"mat-slider",11),D("input",function(r){return X(e),Q(w(2).onSliderChange.emit(r.value))}),g()}if(2&n){let e=w(2);_("min",0)("max",e.scrollBeginIndexUpperLimit)("value",e.scrollBeginIndex)}}function Owe(n,t){if(1&n){let e=ge();h(0,"div",6)(1,"button",7),D("click",function(){return X(e),Q(w().onNavigateLeft.emit())}),T(2," < "),g(),h(3,"div",8),T(4),g(),h(5,"button",9),D("click",function(){return X(e),Q(w().onNavigateRight.emit())}),T(6," > "),g(),S(7,Pwe,1,3,"mat-slider",10),g()}if(2&n){let e=w();b(4),YM(" ",e.scrollBeginIndex," ~ ",e.scrollBeginIndex+e.displayCount-1," of ",e.numExecutions," "),b(3),_("ngIf",e.scrollBeginIndexUpperLimit>0)}}var Fwe=function(n,t,e){return[n,t,e]};function Lwe(n,t){if(1&n){let e=ge();h(0,"div",14),D("click",function(){let o=X(e).index;return Q(w(2).onExecutionDigestClicked.emit(o))}),h(1,"div",15),T(2),g()()}if(2&n){let e=t.$implicit,i=t.index,r=w(2);b(1),Ji("title",e.op_type),_("ngClass",Ty(3,Fwe,e.is_graph?"func-graph-execution":"",i===r.focusedExecutionDisplayIndex?"focused":"",r.displayFocusedAlertTypes[i]||"")),b(1),ze(" ",e.short_op_type," ")}}function Nwe(n,t){if(1&n&&(h(0,"div",12),S(1,Lwe,3,7,"div",13),g()),2&n){let e=w();b(1),_("ngForOf",e.displayExecutionDigests)}}function Bwe(n,t){if(1&n&&(Tt(0),P(1,"tf-debugger-v2-execution-data",16),Dt()),2&n){let e=w();b(1),_("focusedExecutionIndex",e.focusedExecutionIndex)}}var qX=(()=>{class n{constructor(){this.activeRunId=null,this.loadingNumExecutions=!1,this.numExecutions=0,this.scrollBeginIndex=0,this.scrollBeginIndexUpperLimit=0,this.pageSize=0,this.displayCount=0,this.displayExecutionDigests=[],this.displayFocusedAlertTypes=[],this.focusedExecutionIndex=null,this.focusedExecutionDisplayIndex=null,this.focusedExecutionData=null,this.onNavigateLeft=new L,this.onNavigateRight=new L,this.onExecutionDigestClicked=new L,this.onSliderChange=new L}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["timeline-component"]],inputs:{activeRunId:"activeRunId",loadingNumExecutions:"loadingNumExecutions",numExecutions:"numExecutions",scrollBeginIndex:"scrollBeginIndex",scrollBeginIndexUpperLimit:"scrollBeginIndexUpperLimit",pageSize:"pageSize",displayCount:"displayCount",displayExecutionDigests:"displayExecutionDigests",displayFocusedAlertTypes:"displayFocusedAlertTypes",focusedExecutionIndex:"focusedExecutionIndex",focusedExecutionDisplayIndex:"focusedExecutionDisplayIndex",focusedExecutionData:"focusedExecutionData"},outputs:{onNavigateLeft:"onNavigateLeft",onNavigateRight:"onNavigateRight",onExecutionDigestClicked:"onExecutionDigestClicked",onSliderChange:"onSliderChange"},decls:9,vars:4,consts:[[1,"timeline-title"],[1,"execution-count"],[1,"top-level-executions"],["class","navigation-section",4,"ngIf"],["class","execution-timeline",4,"ngIf"],[4,"ngIf"],[1,"navigation-section"],["mat-button","",1,"navigation-button-left",3,"click"],[1,"navigation-position-info"],["mat-button","",1,"navigation-button-right",3,"click"],["class","timeline-slider","step","1",3,"min","max","value","input",4,"ngIf"],["step","1",1,"timeline-slider",3,"min","max","value","input"],[1,"execution-timeline"],[3,"click",4,"ngFor","ngForOf"],[3,"click"],[1,"execution-digest",3,"ngClass","title"],[3,"focusedExecutionIndex"]],template:function(e,i){1&e&&(h(0,"div")(1,"div",0),T(2," Python Execution Timeline "),h(3,"span",1),T(4),g()(),h(5,"div",2),S(6,Owe,8,4,"div",3),S(7,Nwe,2,1,"div",4),S(8,Bwe,2,1,"ng-container",5),g()()),2&e&&(b(4),ze(" (",i.numExecutions,") "),b(2),_("ngIf",i.numExecutions),b(1),_("ngIf",i.numExecutions),b(1),_("ngIf",null!==i.activeRunId&&null!==i.focusedExecutionIndex))},dependencies:[bn,dn,Fe,jX,Fn,Td],styles:[".execution-digest[_ngcontent-%COMP%] {\n  background-color: #e3e5e8;\n  border: 1px solid #c0c0c0;\n  color: #425066;\n  display: inline-block;\n  font-size: 10px;\n  height: 15px;\n  padding: 1px;\n  text-align: center;\n  vertical-align: middle;\n  width: 12px;\n}\n\n.execution-digest.func-graph-execution[_ngcontent-%COMP%] {\n  background-color: #c7dbf5;\n  color: #4e5664;\n  text-decoration: underline;\n}\n\n.execution-digest.focused[_ngcontent-%COMP%] {\n  background-color: #ffd4b3;\n  border: 1px solid #000;\n  font-weight: bold;\n}\n\n.execution-digest.InfNanAlert[_ngcontent-%COMP%] {\n  background-color: #e52592;\n  color: #fff;\n}\n\n\n.execution-digest[_ngcontent-%COMP%]:hover {\n  border: 1px solid #000;\n  font-weight: bold;\n}\n\n.execution-timeline[_ngcontent-%COMP%] {\n  display: flex;\n  overflow-x: hidden;\n  white-space: nowrap;\n  width: 100%;\n  margin-top: 5px;\n  margin-bottom: 5px;\n}\n\n.timeline-slider[_ngcontent-%COMP%] {\n  display: inline-block;\n  height: 48px;\n  left: 340px; \n  padding: 0;\n  position: absolute;\n  right: 40px;\n}\n\n  .timeline-slider .mat-slider-thumb {\n  border-radius: 5px;\n  right: -40px;\n  width: 80px;\n}\n\n\n.navigation-position-info[_ngcontent-%COMP%] {\n  display: inline-flex;\n  font-size: 14px;\n  line-height: normal;\n  max-width: 200px;\n  padding-left: 10px;\n  padding-right: 10px;\n  text-align: center;\n  vertical-align: middle;\n}\n\n.navigation-section[_ngcontent-%COMP%] {\n  height: 48px;\n  line-height: 48px;\n  position: relative;\n  vertical-align: middle;\n  width: 100%;\n}"],changeDetection:0}),n})(),Hwe=["__forward_","__backward_","__inference_"],YX=(()=>{class n{constructor(e){this.store=e,this.activeRunId$=this.store.pipe(pn(ea)),this.loadingNumExecutions$=this.store.pipe(pn(q(ZE,i=>i.state==De.LOADING))),this.scrollBeginIndex$=this.store.pipe(pn(yv)),this.scrollBeginIndexUpperLimit$=this.store.pipe(pn(q(Qu,Zg,(i,r)=>Math.max(0,i-r)))),this.pageSize$=this.store.pipe(pn(Qg)),this.displayCount$=this.store.pipe(pn(Zg)),this.displayExecutionDigests$=this.store.pipe(pn(q(rX,i=>i.map(r=>function(n,t=1){if(!n)return{op_type:"(N/A)",short_op_type:"..",is_graph:!1};let e=Hwe.filter(i=>n.op_type.startsWith(i));if(e.length){let i=n.op_type.slice(e[0].length);return{op_type:n.op_type,short_op_type:i.slice(0,t),is_graph:!0}}return{op_type:n.op_type,short_op_type:n.op_type.slice(0,t),is_graph:!1}}(r))))),this.displayFocusedAlertTypes$=this.store.pipe(pn(fX)),this.focusedExecutionIndex$=this.store.pipe(pn(LL)),this.focusedExecutionDisplayIndex$=this.store.pipe(pn(mX)),this.numExecutions$=this.store.pipe(pn(Qu))}onNavigateLeft(){this.store.dispatch(Vg())}onNavigateRight(){this.store.dispatch(Hg())}onExecutionDigestClicked(e){this.store.dispatch(Ug({displayIndex:e}))}onSliderChange(e){this.store.dispatch(zg({index:e}))}}return n.\u0275fac=function(e){return new(e||n)(C(ke))},n.\u0275cmp=k({type:n,selectors:[["tf-debugger-v2-timeline"]],decls:12,vars:33,consts:[[3,"activeRunId","loadingNumExecutions","numExecutions","scrollBeginIndex","scrollBeginIndexUpperLimit","pageSize","displayCount","displayExecutionDigests","displayFocusedAlertTypes","focusedExecutionIndex","focusedExecutionDisplayIndex","onNavigateLeft","onNavigateRight","onExecutionDigestClicked","onSliderChange"]],template:function(e,i){1&e&&(h(0,"timeline-component",0),D("onNavigateLeft",function(){return i.onNavigateLeft()})("onNavigateRight",function(){return i.onNavigateRight()})("onExecutionDigestClicked",function(o){return i.onExecutionDigestClicked(o)})("onSliderChange",function(o){return i.onSliderChange(o)}),G(1,"async"),G(2,"async"),G(3,"async"),G(4,"async"),G(5,"async"),G(6,"async"),G(7,"async"),G(8,"async"),G(9,"async"),G(10,"async"),G(11,"async"),g()),2&e&&_("activeRunId",W(1,11,i.activeRunId$))("loadingNumExecutions",W(2,13,i.loadingNumExecutions$))("numExecutions",W(3,15,i.numExecutions$))("scrollBeginIndex",W(4,17,i.scrollBeginIndex$))("scrollBeginIndexUpperLimit",W(5,19,i.scrollBeginIndexUpperLimit$))("pageSize",W(6,21,i.pageSize$))("displayCount",W(7,23,i.displayCount$))("displayExecutionDigests",W(8,25,i.displayExecutionDigests$))("displayFocusedAlertTypes",W(9,27,i.displayFocusedAlertTypes$))("focusedExecutionIndex",W(10,29,i.focusedExecutionIndex$))("focusedExecutionDisplayIndex",W(11,31,i.focusedExecutionDisplayIndex$))},dependencies:[qX,lt],encapsulation:2,changeDetection:0}),n})();function jwe(n,t){1&n&&P(0,"tf-debugger-v2-inactive")}function Gwe(n,t){1&n&&(h(0,"div",3),P(1,"tf-debugger-v2-alerts"),h(2,"div",4),P(3,"tf-debugger-v2-timeline")(4,"tf-debugger-v2-graph"),g(),P(5,"tf-debugger-v2-graph-executions"),g(),h(6,"div",5),P(7,"tf-debugger-v2-source-files")(8,"tf-debugger-v2-stack-trace"),g())}var XX=(()=>{class n{constructor(){this.runs={},this.runIds=[],this.activeRunId=null}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["debugger-component"]],inputs:{runs:"runs",runIds:"runIds",activeRunId:"activeRunId"},decls:4,vars:2,consts:[[1,"debugger-container"],[4,"ngIf","ngIfElse"],["dataAvailable",""],[1,"top-section"],[1,"top-center-section"],[1,"bottom-section"]],template:function(e,i){if(1&e&&(h(0,"div",0),S(1,jwe,1,0,"tf-debugger-v2-inactive",1),S(2,Gwe,9,0,"ng-template",null,2,Zt),g()),2&e){let r=tt(3);b(1),_("ngIf",0===i.runIds.length)("ngIfElse",r)}},dependencies:[xX,Fe,wX,TX,IX,BX,HX,YX],styles:[".bottom-section[_ngcontent-%COMP%]{box-sizing:border-box;border-top:1px solid #ebebeb;display:flex;flex-grow:1;height:34%;padding-top:6px}body.dark-mode[_nghost-%COMP%]   .bottom-section[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .bottom-section[_ngcontent-%COMP%]{border-top:1px solid #555}.debugger-container[_ngcontent-%COMP%]{box-sizing:border-box;height:100%;overflow:hidden}.top-section[_ngcontent-%COMP%]{box-sizing:border-box;display:flex;flex-grow:1;height:66%;padding:6px 0}tf-debugger-v2-alerts[_ngcontent-%COMP%]{border-right:1px solid #ebebeb;display:inline-block;margin-right:10px;min-width:160px;width:calc(15% - 11px)}body.dark-mode[_nghost-%COMP%]   tf-debugger-v2-alerts[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   tf-debugger-v2-alerts[_ngcontent-%COMP%]{border-right:1px solid #555}tf-debugger-v2-graph-executions[_ngcontent-%COMP%]{display:inline-block;flex-grow:1;min-width:540px;width:540px}tf-debugger-v2-source-files[_ngcontent-%COMP%]{display:inline-block;height:100%;width:70%}tf-debugger-v2-stack-trace[_ngcontent-%COMP%]{display:inline-block;flex-grow:1;height:100%;min-width:540px;width:540px}.top-center-section[_ngcontent-%COMP%]{display:inline-block;overflow:auto;width:55%}tf-debugger-v2-timeline[_ngcontent-%COMP%]{display:block}tf-debugger-v2-graph[_ngcontent-%COMP%]{border-top:1px solid #ebebeb;display:block;margin-top:5px}body.dark-mode[_nghost-%COMP%]   tf-debugger-v2-graph[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   tf-debugger-v2-graph[_ngcontent-%COMP%]{border-top:1px solid #555}"],changeDetection:0}),n})(),QX=(()=>{class n{constructor(e){this.store=e,this.runs$=this.store.pipe(pn(jf)),this.runsIds$=this.store.pipe(pn(q(jf,i=>Object.keys(i)))),this.activeRunId$=this.store.pipe(pn(ea))}ngOnInit(){this.store.dispatch(TE())}ngOnDestroy(){this.store.dispatch(DE())}}return n.\u0275fac=function(e){return new(e||n)(C(ke))},n.\u0275cmp=k({type:n,selectors:[["tf-debugger-v2"]],decls:4,vars:9,consts:[[3,"runs","runIds","activeRunId"]],template:function(e,i){1&e&&(P(0,"debugger-component",0),G(1,"async"),G(2,"async"),G(3,"async")),2&e&&_("runs",W(1,3,i.runs$))("runIds",W(2,5,i.runsIds$))("activeRunId",W(3,7,i.activeRunId$))},dependencies:[XX,lt],styles:["[_nghost-%COMP%] {\n        display: block;\n        height: 100%;\n      }"]}),n})(),aT="debugger-v2";function WL(n,t,e,i,r){if(e<=0||!Number.isInteger(e))throw new Error(`Invalid pageSize: ${e}`);if(t>i)throw new Error(`end index (${t}) exceeds total number of items (${i})`);if(t-n>e)throw new Error("begin-end span exceeds page size, which is not allowed");let o=[],a=Math.floor(n/e);(!(a in r)||r[a]<e&&a*e+r[a]<i)&&o.push(a);let s=Math.floor((t-1)/e);return s!==a&&(!(s in r)||s*e+r[s]<t&&t<i)&&o.push(s),o}var JX=(()=>{class n{onDebuggerDataPoll(){return this.actions$.pipe(wi(TE),yi(e=>function(n,t,e){return n.pipe(function(n){return Kt((t,e)=>{let i,o,r=!1,a=!1,s=!1,l=()=>s&&a&&(e.complete(),!0),d=()=>{s=!1,i=t.subscribe(Ht(e,void 0,()=>{s=!0,!l()&&(o||(o=new Ae,n(o).subscribe(Ht(e,()=>{i?d():r=!0},()=>{a=!0,l()}))),o).next()})),r&&(i.unsubscribe(),i=null,r=!1,d())};d()})}(i=>i.pipe(Yt(t),qm(([,r])=>Ja(r)))),ot(e),U(()=>{}))}(qt(e),this.store.select($Y).pipe(U(i=>function(n){return n>6e4?6e4:n>4e3?n:2e3}(i))),this.actions$.pipe(wi(DE)))),Vt(()=>this.store.dispatch(pv())),U(()=>{}))}onCoreReload(){return cn(this.actions$.pipe(wi(Hs,ss)),this.actions$.pipe(wi(xc)).pipe(Yt(this.store.select(IL)),Ve(([,e])=>e.state===De.NOT_LOADED||e.state===De.FAILED&&null===e.lastLoadedTimeInMs))).pipe(Yt(this.store.select(qo)),Ve(([,e])=>e===aT),Vt(()=>this.store.dispatch(pv())),U(()=>{}))}loadDebuggerRuns(e){return e.pipe(Yt(this.store.select(IL)),Ve(([,{state:i}])=>i!==De.LOADING),Vt(()=>this.store.dispatch(IE())),hn(()=>this.dataSource.fetchRuns().pipe(Vt(i=>{this.store.dispatch(AE({runs:i}))}),U(()=>{}))))}createNumExecutionLoader(e){return e.pipe(Yt(this.store.select(jf),this.store.select(ZE)),Ve(([,i,r])=>Object.keys(i).length>0&&r.state!==De.LOADING),Vt(()=>this.store.dispatch(PE())),hn(([,i])=>{let r=Object.keys(i)[0];return this.dataSource.fetchExecutionDigests(r,0,0).pipe(Vt(s=>{this.store.dispatch(OE({numExecutions:s.num_digests}))}),U(()=>{}))}))}createNumGraphExecutionLoader(e){return e.pipe(Yt(this.store.select(jf),this.store.select(oX)),Ve(([,i,r])=>Object.keys(i).length>0&&r.state!==De.LOADING),Vt(()=>this.store.dispatch(BE())),hn(([,i])=>{let r=Object.keys(i)[0];return this.dataSource.fetchGraphExecutionDigests(r,0,0).pipe(Vt(s=>{this.store.dispatch(VE({numGraphExecutions:s.num_digests}))}),U(()=>{}))}))}createNumAlertsAndBreakdownLoader(e){return e.pipe(Yt(this.store.select(jf),this.store.select(AL)),Ve(([,i,r])=>Object.keys(i).length>0&&r.state!==De.LOADING),Vt(()=>this.store.dispatch(fv())),hn(([,i])=>{let r=Object.keys(i)[0];return this.dataSource.fetchAlerts(r,0,0).pipe(Vt(s=>{this.store.dispatch(RE({numAlerts:s.num_alerts,alertsBreakdown:s.alerts_breakdown}))}),U(()=>{}))}))}createInitialExecutionDetector(e){return e.pipe(Yt(this.store.select(Qu),this.store.select(_v)),Ve(([,i,r])=>i>0&&0===Object.keys(r.pageLoadedSizes).length),U(()=>{}))}createInitialExecutionDigest(e){return e.pipe(Yt(this.store.select(Qu),this.store.select(ea),this.store.select(Qg)),Ve(([,,i])=>null!==i),U(([,i,r,o])=>({begin:0,end:Math.min(i,o),runId:r})))}onExecutionScroll(){return this.actions$.pipe(wi(Vg,Hg,zg),Yt(this.store.select(ea),this.store.select(yv),this.store.select(Qu),this.store.select(Zg),this.store.select(Qg)),Ve(([e])=>null!==e),U(([,e,i,r,o,a])=>({runId:e,begin:i,end:Math.min(r,i+o),pageSize:a})),Yt(this.store.select(_v)),U(([e,i])=>({props:e,loaded:i,missingPages:WL(e.begin,e.end,e.pageSize,i.numExecutions,i.pageLoadedSizes)})),Ve(({missingPages:e})=>e.length>0),U(({props:e,loaded:i,missingPages:r})=>{let{runId:o,pageSize:a}=e;return{begin:r[0]*a,end:Math.min(i.numExecutions,(r[r.length-1]+1)*a),runId:o}}))}createExecutionDigestLoader(e){return e.pipe(Yt(this.store.select(_v)),Ve(([{begin:i,end:r},o])=>r>i&&!function(n,t,e){if(t>=e)throw new Error(`Expected begin to be less than end, but got begin=${t}, end=${e}`);return-1!==n.findIndex(i=>i.begin>=t&&i.end<=e)}(o.loadingRanges,i,r)),Vt(([{begin:i,end:r}])=>{this.store.dispatch(FE({begin:i,end:r}))}),hn(([{runId:i,begin:r,end:o}])=>this.dataSource.fetchExecutionDigests(i,r,o).pipe(Vt(a=>{this.store.dispatch(LE(a))}),U(()=>{}))))}onExecutionDigestFocused(){return this.actions$.pipe(wi(Ug),Yt(this.store.select(ea),this.store.select(NL),this.store.select(yv)),U(([e,i,r,o])=>({activeRunId:i,loadedExecutionData:r,focusIndex:o+e.displayIndex})))}createExecutionDataAndStackFramesLoader(e){return e.pipe(Ve(({activeRunId:i,loadedExecutionData:r,focusIndex:o})=>null!==i&&null!==o&&void 0===r[o]),hn(({activeRunId:i,focusIndex:r})=>{let o=r,a=o+1;return this.dataSource.fetchExecutionData(i,o,a).pipe(Vt(s=>{this.store.dispatch(NE(s))}),U(s=>({executionData:s,begin:o,end:a})))}),U(({executionData:i})=>i.executions[0]),Yt(this.store.select(ea),this.store.select(BL)),Ve(([i,r,o])=>{if(null===r)return!1;for(let a of i.stack_frame_ids)if(void 0===o[a])return!0;return!1}),hn(([i,r])=>{let o=i.stack_frame_ids;return this.dataSource.fetchStackFrames(r,o).pipe(Vt(a=>{let s={};for(let l=0;l<o.length;++l)s[o[l]]=a.stack_frames[l];this.store.dispatch(mv({stackFrames:s}))}),U(()=>{}))}))}onGraphExecutionScroll(){return this.actions$.pipe(wi(jg),Cr(100),Yt(this.store.select(ea),this.store.select(bv),this.store.select(aX)),Ve(([,e,i])=>null!==e&&i>0),U(([,e,i,r])=>({runId:e,numGraphExecutions:i,scrollBeginIndex:r})),Yt(this.store.select(lX),this.store.select(sX),this.store.select(cX),this.store.select(dX)),U(([{runId:e,numGraphExecutions:i,scrollBeginIndex:r},o,a,s,l])=>{let c=WL(r,Math.min(r+a,i),o,i,l);return c=c.filter(d=>-1===s.indexOf(d)),{runId:e,missingPages:c,pageSize:o,numGraphExecutions:i}}))}loadGraphExecutionPages(e){return e.pipe(Ve(({missingPages:i})=>i.length>0),Vt(({missingPages:i})=>{i.forEach(r=>{this.store.dispatch(HE({pageIndex:r}))})}),hn(({runId:i,missingPages:r,pageSize:o,numGraphExecutions:a})=>{let s=r[0]*o,l=Math.min((r[r.length-1]+1)*o,a);return this.dataSource.fetchGraphExecutionData(i,s,l).pipe(Vt(c=>{this.store.dispatch(zE(c))}),U(()=>{}))}))}loadGraphOpInfo(){return this.actions$.pipe(wi(Wg,Gg),Yt(this.store.select(ea),this.store.select(hX)),Ve(([e,i,r])=>{let{graph_id:o,op_name:a}=e;return!(null===i||void 0!==r[o]&&r[o].has(a)&&(r[o].get(a)===De.LOADING||r[o].get(a)===De.LOADED))}),Vt(([{graph_id:e,op_name:i}])=>this.store.dispatch(UE({graph_id:e,op_name:i}))),hn(([e,i])=>{let{graph_id:r,op_name:o}=e;return this.dataSource.fetchGraphOpInfo(i,r,o).pipe(Vt(a=>this.store.dispatch(jE({graphOpInfoResponse:a}))),U(a=>({runId:i,stackFrameIds:a.stack_frame_ids})))}))}loadGraphOpStackFrames(e){return e.pipe(Yt(this.store.select(BL)),U(([{runId:i,stackFrameIds:r},o])=>({runId:i,missingStackFrameIds:r.filter(s=>void 0===o[s])})),Ve(({runId:i,missingStackFrameIds:r})=>null!==i&&r.length>0),hn(({runId:i,missingStackFrameIds:r})=>this.dataSource.fetchStackFrames(i,r).pipe(Vt(o=>{let a={};for(let s=0;s<r.length;++s)a[r[s]]=o.stack_frames[s];this.store.dispatch(mv({stackFrames:a}))}),U(()=>{}))))}onAlertTypeFocused(){return this.actions$.pipe(wi(Bg),Yt(this.store.select(ea),this.store.select(QE),this.store.select(tX),this.store.select(nX),this.store.select(AL)),Ve(([,e,i,r,o,a])=>null!==e&&null!==i&&r>0&&(null===o||Object.keys(o).length<r)&&a.state!==De.LOADING),Vt(()=>this.store.dispatch(fv())),hn(([,e,i])=>this.dataSource.fetchAlerts(e,0,-1,i)),Vt(({num_alerts:e,alerts_breakdown:i,alert_type:r,begin:o,end:a,alerts:s})=>{this.store.dispatch(kE({numAlerts:e,alertsBreakdown:i,alertType:r,begin:o,end:a,alerts:s}))}))}fetchExecutionDigestsForAlertTypeFocus(e){return e.pipe(Yt(this.store.select(Qg),this.store.select(Zg),this.store.select(Qu),this.store.select(_v),this.store.select(ea)),U(([i,r,o,a,s,l])=>{let d=i.alerts[0].execution_index,u=WL(Math.max(0,d-Math.floor(o/2)),Math.min(d+Math.floor(o/2),a),r,a,s.pageLoadedSizes);return 0===u.length?{runId:l,begin:0,end:0}:{runId:l,begin:u[0]*r,end:Math.min(s.numExecutions,(u[u.length-1]+1)*r)}}))}loadSourceFileList(e){return e.pipe(Yt(this.store.select(ea),this.store.select(_X)),Ve(([,i,r])=>null!==i&&r.state!==De.LOADING),Vt(()=>this.store.dispatch(GE())),hn(([,i])=>this.dataSource.fetchSourceFileList(i).pipe(Vt(r=>{let o=[];r.forEach(([a,s])=>{o.push({host_name:a,file_path:s})}),this.store.dispatch(WE({sourceFiles:o}))}),U(()=>{}))))}onSourceFileFocused(){return this.actions$.pipe(wi(qg),Yt(this.store.select(ea),this.store.select(VL),this.store.select($E)),U(([e,i,r,o])=>({runId:i,stackFrame:e.stackFrame,fileIndex:r,fileContent:o})),Ve(({runId:e,fileContent:i})=>null!==e&&null!==i&&i.loadState===De.NOT_LOADED),Vt(({stackFrame:e})=>this.store.dispatch(qE({host_name:e.host_name,file_path:e.file_path}))),hn(({fileIndex:e,runId:i})=>this.dataSource.fetchSourceFile(i,e).pipe(Vt(r=>{this.store.dispatch(YE(r))}),U(()=>{}))))}constructor(e,i,r){this.actions$=e,this.store=i,this.dataSource=r,this.loadData$=Or(()=>{let o=this.loadDebuggerRuns(cn(this.onDebuggerDataPoll(),this.onCoreReload())).pipe(Sa()),a=this.loadSourceFileList(o),s=this.createNumExecutionLoader(o),l=this.createNumAlertsAndBreakdownLoader(o),c=this.onAlertTypeFocused(),d=this.fetchExecutionDigestsForAlertTypeFocus(c),u=this.createInitialExecutionDetector(s).pipe(Sa()),p=this.createExecutionDigestLoader(cn(this.onExecutionScroll(),this.createInitialExecutionDigest(u),d)),f=this.createExecutionDataAndStackFramesLoader(cn(this.onExecutionDigestFocused(),u.pipe(Yt(this.store.select(ea),this.store.select(NL)),U(([,x,R])=>({activeRunId:x,loadedExecutionData:R,focusIndex:0})))));return cn(l,p,f,this.createNumGraphExecutionLoader(o),a,this.onSourceFileFocused(),this.loadGraphExecutionPages(this.onGraphExecutionScroll()),this.loadGraphOpStackFrames(this.loadGraphOpInfo())).pipe(U(()=>({})))},{dispatch:!1})}}return n.\u0275fac=function(e){return new(e||n)(O(Wo),O(ke),O(EE))},n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})(),$X=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Te]}),n})(),eQ=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Te]}),n})(),sT=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Te]}),n})(),tQ=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Te,sT,Md]}),n})(),nQ=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({}),n})(),Ju=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({}),n})(),lT=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Te,Ju]}),n})(),iQ=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Te,lT]}),n})(),rQ=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Te,lT]}),n})(),oQ=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Te,sT]}),n})(),aQ=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Te,oQ,fi,Ku]}),n})(),sQ=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[$X,Te,zs,tQ,eQ,nQ,iQ,rQ,YY,aQ,wr.forFeature(hv,JY),wo.forFeature([JX]),Oc.forPlugin(aT,QX)]}),n})(),cT=ye("[Metrics] Metrics Settings Pane Closed"),dT=ye("[Metrics] Metrics Settings Pane Toggled"),uT=ye("[Metrics] Slide out settings menu toggled"),pT=ye("[Metrics] User requested to open the slide out menu",{_as:"props",_p:void 0}),fT=ye("[Metrics] User changed the tab in the table editor",{_as:"props",_p:void 0}),mT=ye("[Metrics] Slide out settings menu closed"),hT=ye("[Metrics] Metrics Tag Metadata Requested"),gT=ye("[Metrics] Metrics Tag Metadata Loaded",{_as:"props",_p:void 0}),_T=ye("[Metrics] Metrics Tag Metadata Failed"),yT=ye("[Metrics] Metrics Card State Updated",{_as:"props",_p:void 0}),Kg=ye("[Metrics] Metrics Card Full Size Toggled",{_as:"props",_p:void 0}),bT=ye("[Metrics] Metrics Settings Change Tooltip",{_as:"props",_p:void 0}),vT=(ye("[Metrics] Metrics Settings Toggle Show Data Download"),ye("[Metrics] Metrics Setting Toggle Ignore Outlier")),xT=ye("[Metrics] Metrics Setting Change X Axis Type",{_as:"props",_p:void 0}),CT=ye("[Metrics] Metrics Setting Change Card Width",{_as:"props",_p:void 0}),MT=ye("[Metrics] Metrics Setting Reset Card Width"),wT=ye("[Metrics] Metrics Setting Change Scalar Smoothing",{_as:"props",_p:void 0}),ST=ye("[Metrics] Metrics Setting Partition Non Monotonic X Toggled"),ET=ye("[Metrics] Metrics Setting Change Image Brightness",{_as:"props",_p:void 0}),TT=ye("[Metrics] Metrics Setting Change Image Contrast",{_as:"props",_p:void 0}),DT=ye("[Metrics] Image Brightness Setting Reset"),IT=ye("[Metrics] Image Contrast Setting Reset"),AT=ye("[Metrics] Metrics Setting Toggle Image Show Actual Size"),RT=ye("[Metrics] Metrics Setting Change Histogram Mode",{_as:"props",_p:void 0}),kT=ye("[Metrics] Multiple Time Series Requested",{_as:"props",_p:void 0}),PT=ye("[Metrics] Fetch Time Series Request Failed",{_as:"props",_p:void 0}),OT=ye("[Metrics] Fetch Time Series Response Loaded",{_as:"props",_p:void 0}),Jg=ye("[Metrics] Card Visibility Changed",{_as:"props",_p:void 0}),FT=ye("[Metrics] Card Step Slider Changed",{_as:"props",_p:void 0}),LT=ye("[Metrics] Tag Filter Changed",{_as:"props",_p:void 0}),NT=ye("[Metrics] Metrics Tag Group Expansion Changed",{_as:"props",_p:void 0}),$g=ye("[Metrics] Card Pin State Toggled",{_as:"props",_p:void 0}),BT=ye("[Metrics] Toggle Visible Plugin",{_as:"props",_p:void 0}),VT=ye("[Metrics] Toggle Show All Plugins"),Yf=ye("[Metrics] Time Selection Changed",{_as:"props",_p:void 0}),Mv=ye("[Metrics] Card User View Box Changed",{_as:"props",_p:void 0}),HT=ye("[Metrics] Linked Time Enable Toggle",{_as:"props",_p:void 0}),lQ=ye("[Metrics] Sorting Data Table By Header",{_as:"props",_p:void 0}),e0=ye("[Metrics] Data table columns edited in edit menu",{_as:"props",_p:void 0}),t0=ye("[Metrics] Data table column toggled in edit menu or delete button clicked",{_as:"props",_p:void 0}),Dd=ye("[Metrics] Time Selector Enable Toggle",{_as:"props",_p:void 0}),zT=ye("[Metrics] Range Selection Toggled",{_as:"props",_p:void 0}),cQ=ye("[Metrics] Hide Empty Cards Changed");function wv(n,t){let e={};for(let i of Object.keys(n))e[i]=t(n[i],i);return e}var ja=(()=>(function(n){n.NONE="no affordance",n.EXTENDED_LINE="extendedLine",n.FOB="fob",n.FOB_REMOVED="fobRemoved",n.FOB_TEXT="fobText",n.HISTOGRAM_CLICK_TO_RANGE="histogramClickToRange",n.FOB_ADDED="fobAdded"}(ja||(ja={})),ja))(),Ga=(()=>(function(n){n.NONE="no toggle affordance",n.FOB_DESELECT="fobDeselect",n.CHECK_BOX="checkBox"}(Ga||(Ga={})),Ga))(),ga=(()=>(function(n){n[n.HORIZONTAL=0]="HORIZONTAL",n[n.VERTICAL=1]="VERTICAL"}(ga||(ga={})),ga))();function UT(n){let t=new Map,e=n.slice().sort((i,r)=>Sv(i.tag,r.tag));for(let i of e){let r=Zwe(i.tag);t.has(r)||t.set(r,{groupName:r,items:[]}),t.get(r).items.push(i)}return[...t.values()]}function Zwe(n){return n.split("/",1)[0]}function Sv(n,t){let e=0,i=0;for(;;){if(e===n.length)return i===t.length?0:-1;if(i===t.length)return 1;if(Xf(n[e])&&Xf(t[i])){let r=e,o=i;e=dQ(n,e+1),i=dQ(t,i+1);let a=Number(n.slice(r,e)),s=Number(t.slice(o,i));if(a<s)return-1;if(a>s)return 1}else{if(qL(n[e])){if(!qL(t[i]))return-1}else{if(qL(t[i]))return 1;if(n[e]<t[i])return-1;if(n[e]>t[i])return 1}e++,i++}}}function dQ(n,t){let e;var o;(o=e||(e={}))[o.NATURAL=0]="NATURAL",o[o.REAL=1]="REAL",o[o.EXPONENT_SIGN=2]="EXPONENT_SIGN",o[o.EXPONENT=3]="EXPONENT";let i=e.NATURAL,r=t;for(;r<n.length;r++)if(i===e.NATURAL){if("."===n[r])i=e.REAL;else if("e"===n[r]||"E"===n[r])i=e.EXPONENT_SIGN;else if(!Xf(n[r]))break}else if(i===e.REAL){if("e"===n[r]||"E"===n[r])i=e.EXPONENT_SIGN;else if(!Xf(n[r]))break}else if(i===e.EXPONENT_SIGN){if(!Xf(n[r])&&"+"!==n[r]&&"-"!==n[r])break;i=e.EXPONENT}else if(i===e.EXPONENT&&!Xf(n[r]))break;return r}function Xf(n){return"0"<=n&&n<="9"}function qL(n){return"/"===n||Xf(n)}function YL(n,t,e){let{plugin:i,tag:r,runId:o,sample:a}=t[n],s=md(e,i,r,a);if(s){if(null!==o&&s.runToSeries.hasOwnProperty(o)){let c=s.runToSeries[o].length;return c>0?c-1:null}let l=Object.values(s.runToSeries).map(c=>c.length);if(l.length)return Math.max(...l)-1}return null}function Jwe(n,t,e,i){let r={...t};for(let o in n){if(!n.hasOwnProperty(o))continue;let a=YL(o,n,e);if(null===a)continue;let s=t.hasOwnProperty(o)?t[o].index:null,l=YL(o,n,i);(null!==s&&s>a||null===s||null!==s&&s===l)&&(r[o]={index:a,isClosest:!1})}return r}function uQ(n){let t=wv(n.runToLoadState,e=>e===De.LOADING?De.LOADING:De.NOT_LOADED);return{...n,runToLoadState:t}}function pQ(n,t,e,i){return JSON.stringify([n,t,e||"",i])}var{initialState:mQ,reducers:$we}=_f({tagMetadataLoadState:{state:De.NOT_LOADED,lastLoadedTimeInMs:null},tagMetadata:{scalars:{tagDescriptions:{},tagToRuns:{}},histograms:{tagDescriptions:{},tagToRuns:{}},images:{tagDescriptions:{},tagRunSampledInfo:{}}},cardList:[],cardToPinnedCopy:new Map,cardToPinnedCopyCache:new Map,pinnedCardToOriginal:new Map,unresolvedImportedPinnedCards:[],cardMetadataMap:{},cardStateMap:{},cardStepIndex:{},tagFilter:"",tagGroupExpanded:new Map,linkedTimeSelection:null,linkedTimeEnabled:!1,stepSelectorEnabled:!1,rangeSelectionEnabled:!1,singleSelectionHeaders:[{type:vt.RUN,name:"run",displayName:"Run",enabled:!0,removable:!0,sortable:!0,movable:!0},{type:vt.SMOOTHED,name:"smoothed",displayName:"Smoothed",enabled:!0,removable:!0,sortable:!0,movable:!0},{type:vt.VALUE,name:"value",displayName:"Value",enabled:!0,removable:!0,sortable:!0,movable:!0},{type:vt.STEP,name:"step",displayName:"Step",enabled:!0,removable:!0,sortable:!0,movable:!0},{type:vt.RELATIVE_TIME,name:"relative",displayName:"Relative",enabled:!0,removable:!0,sortable:!0,movable:!0}],rangeSelectionHeaders:[{type:vt.RUN,name:"run",displayName:"Run",enabled:!0,removable:!0,sortable:!0,movable:!0},{type:vt.MIN_VALUE,name:"min",displayName:"Min",enabled:!0,removable:!0,sortable:!0,movable:!0},{type:vt.MAX_VALUE,name:"max",displayName:"Max",enabled:!0,removable:!0,sortable:!0,movable:!0},{type:vt.START_VALUE,name:"start",displayName:"Start Value",enabled:!0,removable:!0,sortable:!0,movable:!0},{type:vt.END_VALUE,name:"end",displayName:"End Value",enabled:!0,removable:!0,sortable:!0,movable:!0},{type:vt.VALUE_CHANGE,name:"valueChange",displayName:"Value",enabled:!0,removable:!0,sortable:!0,movable:!0},{type:vt.PERCENTAGE_CHANGE,name:"percentageChange",displayName:"%",enabled:!0,removable:!0,sortable:!0,movable:!0},{type:vt.START_STEP,name:"startStep",displayName:"Start Step",enabled:!0,removable:!0,sortable:!0,movable:!0},{type:vt.END_STEP,name:"endStep",displayName:"End Step",enabled:!0,removable:!0,sortable:!0,movable:!0},{type:vt.STEP_AT_MAX,name:"stepAtMax",displayName:"Step At Max",enabled:!1,removable:!0,sortable:!0,movable:!0},{type:vt.STEP_AT_MIN,name:"stepAtMin",displayName:"Step At Min",enabled:!1,removable:!0,sortable:!0,movable:!0},{type:vt.MEAN,name:"mean",displayName:"Mean",enabled:!1,removable:!0,sortable:!0,movable:!0},{type:vt.RAW_CHANGE,name:"rawChange",displayName:"Raw",enabled:!1,removable:!0,sortable:!0,movable:!0}],filteredPluginTypes:new Set,stepMinMax:{min:1/0,max:-1/0}},{isSettingsPaneOpen:!0,isSlideoutMenuOpen:!1,tableEditorSelectedTab:lo.SINGLE,timeSeriesData:{scalars:{},histograms:{},images:{}},settings:e1,settingOverrides:{},visibleCardMap:new Map},(n,t,e)=>Lo(t,e)?n:{...n,tagMetadataLoadState:{state:De.NOT_LOADED,lastLoadedTimeInMs:null},tagMetadata:{scalars:{tagDescriptions:{},tagToRuns:{}},histograms:{tagDescriptions:{},tagToRuns:{}},images:{tagDescriptions:{},tagRunSampledInfo:{}}},cardList:[],cardMetadataMap:{},visibleCardMap:new Map}),XL=mQ,eSe=_r(mQ,Ee(Vh,(n,{routeKind:t,partialState:e})=>{if(t!==kn.EXPERIMENT&&t!==kn.COMPARE_EXPERIMENT)return n;let i=new Set;for(let d of n.pinnedCardToOriginal.keys()){let{plugin:u,tag:p,runId:f,sample:m}=n.cardMetadataMap[d];i.add(pQ(u,p,f,m))}let r=e,o=[];for(let d of[...n.unresolvedImportedPinnedCards,...r.metrics.pinnedCards]){let u=pQ(d.plugin,d.tag,d.runId,d.sample);i.has(u)||(i.add(u),o.push(d))}let a=GF(o,n.cardList,n.cardMetadataMap,n.cardToPinnedCopy,n.cardToPinnedCopyCache,n.pinnedCardToOriginal,n.cardStepIndex,n.cardStateMap),s=r.metrics.smoothing,l=n.settingOverrides;if(Number.isFinite(s)&&null!==s){let d=Math.max(0,Math.min(.999,Number(s.toPrecision(3))));l={...n.settingOverrides,scalarSmoothing:d}}let c={...n,...a,settingOverrides:l};return null!==r.metrics.tagFilter&&(c.tagFilter=r.metrics.tagFilter),c}),Ee(Sl,(n,{partialSettings:t})=>{let e={};t.tooltipSort&&Object.values(ao).includes(t.tooltipSort)&&(e.tooltipSort=t.tooltipSort),"number"==typeof t.timeSeriesCardMinWidth&&(e.cardMinWidth=t.timeSeriesCardMinWidth),"boolean"==typeof t.ignoreOutliers&&(e.ignoreOutliers=t.ignoreOutliers),"number"==typeof t.scalarSmoothing&&(e.scalarSmoothing=t.scalarSmoothing);let i=t.timeSeriesSettingsPaneOpened??n.isSettingsPaneOpen,r=t.stepSelectorEnabled??n.stepSelectorEnabled,o=t.rangeSelectionEnabled??n.rangeSelectionEnabled,a=t.linkedTimeEnabled??n.linkedTimeEnabled,s=t.singleSelectionHeaders??n.singleSelectionHeaders,l=t.rangeSelectionHeaders??n.rangeSelectionHeaders;return{...n,isSettingsPaneOpen:i,stepSelectorEnabled:r,rangeSelectionEnabled:o,linkedTimeEnabled:a,singleSelectionHeaders:s,rangeSelectionHeaders:l,settings:{...n.settings,...e}}}),Ee(ss,Hs,n=>{let t=n.tagMetadataLoadState.state===De.LOADING?De.LOADING:De.NOT_LOADED,e=wv(n.timeSeriesData,(i,r)=>wv(i,o=>ls(r)?wv(o,a=>uQ(a)):uQ(o)));return{...n,tagMetadataLoadState:{...n.tagMetadataLoadState,state:t},timeSeriesData:e}}),Ee(hT,n=>({...n,tagMetadataLoadState:{...n.tagMetadataLoadState,state:De.LOADING}})),Ee(_T,n=>({...n,tagMetadataLoadState:{...n.tagMetadataLoadState,state:De.FAILED}})),Ee(gT,(n,{tagMetadata:t})=>{let e={scalars:fQ(t,qn.SCALARS),histograms:fQ(t,qn.HISTOGRAMS),images:t[qn.IMAGES]},i={},r=function(n){let t=[];for(let e of Object.keys(n)){let r,i=e;if(ls(i)){if(!cs(i))throw new Error("Multi-run, sampled plugin support not yet implemented");{let o=n[i].tagRunSampledInfo;for(let a of Object.keys(o))for(let s of Object.keys(o[a])){let{maxSamplesPerStep:l}=o[a][s];for(let c=0;c<l;c++)t.push({plugin:i,tag:a,runId:s,sample:c,numSample:l})}}}else if(cs(i)){r=n[i].tagToRuns;for(let o of Object.keys(r))for(let a of r[o])t.push({plugin:i,tag:o,runId:a})}else{r=n[i].tagToRuns;for(let o of Object.keys(r))t.push({plugin:i,tag:o,runId:null})}}return t}(e),o=[];for(let f of r){let m=jF(f);i[m]=f,o.push(m)}let a=n.tagGroupExpanded;if(0===n.tagGroupExpanded.size){let m=UT(o.map(y=>({...i[y],cardId:y})).filter(Boolean));a=new Map(n.tagGroupExpanded);for(let y of m.slice(0,2))a.set(y.groupName,!0)}let{nextCardToPinnedCopy:s,nextPinnedCardToOriginal:l,pinnedCardMetadataMap:c}=function(n,t,e){let i=new Map,r=new Map,o={};return n.forEach((a,s)=>{-1!==e.indexOf(s)&&(i.set(s,a),r.set(a,s),o[a]=t[s])}),{nextCardToPinnedCopy:i,nextPinnedCardToOriginal:r,pinnedCardMetadataMap:o}}(n.cardToPinnedCopyCache,i,o),d={...i,...c},u=function(n,t){let e={};return Object.entries(n).forEach(([i,r])=>{t[i]&&(e[i]=r)}),e}(n.cardStepIndex,d),p=GF(n.unresolvedImportedPinnedCards,o,d,s,n.cardToPinnedCopyCache,l,u,n.cardStateMap);return{...n,...p,tagGroupExpanded:a,tagMetadataLoadState:{state:De.LOADED,lastLoadedTimeInMs:Date.now()},tagMetadata:e,cardList:o}}),Ee(yT,(n,{cardId:t,settings:e})=>{let i={...n.cardStateMap};return i[t]={...i[t],...e},{...n,cardStateMap:i}}),Ee(Kg,(n,{cardId:t})=>{let e={...n.cardStateMap};return e[t]={...e[t],fullWidth:!e[t]?.fullWidth,tableExpanded:!e[t]?.fullWidth},{...n,cardStateMap:e}}),Ee(LT,(n,{tagFilter:t})=>({...n,tagFilter:t})),Ee(bT,(n,{sort:t})=>({...n,settingOverrides:{...n.settingOverrides,tooltipSort:t}})),Ee(vT,n=>{let t=!(n.settingOverrides.ignoreOutliers??n.settings.ignoreOutliers);return{...n,settingOverrides:{...n.settingOverrides,ignoreOutliers:t}}}),Ee(xT,(n,{xAxisType:t})=>({...n,settingOverrides:{...n.settingOverrides,xAxisType:t}})),Ee(wT,(n,{smoothing:t})=>({...n,settingOverrides:{...n.settingOverrides,scalarSmoothing:t}})),Ee(ST,n=>{let t=!(n.settingOverrides.scalarPartitionNonMonotonicX??n.settings.scalarPartitionNonMonotonicX);return{...n,settingOverrides:{...n.settingOverrides,scalarPartitionNonMonotonicX:t}}}),Ee(ET,(n,{brightnessInMilli:t})=>({...n,settingOverrides:{...n.settingOverrides,imageBrightnessInMilli:t}})),Ee(TT,(n,{contrastInMilli:t})=>({...n,settingOverrides:{...n.settingOverrides,imageContrastInMilli:t}})),Ee(DT,n=>{let{imageBrightnessInMilli:t,...e}=n.settingOverrides;return{...n,settingOverrides:e}}),Ee(IT,n=>{let{imageContrastInMilli:t,...e}=n.settingOverrides;return{...n,settingOverrides:e}}),Ee(AT,n=>{let t=!(n.settingOverrides.imageShowActualSize??n.settings.imageShowActualSize);return{...n,settingOverrides:{...n.settingOverrides,imageShowActualSize:t}}}),Ee(RT,(n,{histogramMode:t})=>({...n,settingOverrides:{...n.settingOverrides,histogramMode:t}})),Ee(CT,(n,{cardMinWidth:t})=>({...n,settingOverrides:{...n.settingOverrides,cardMinWidth:t}})),Ee(MT,n=>({...n,settingOverrides:{...n.settingOverrides,cardMinWidth:null}})),Ee(cQ,n=>({...n,settingOverrides:{...n.settingOverrides,hideEmptyCards:!n.settingOverrides.hideEmptyCards}})),Ee(kT,(n,{requests:t})=>{if(!t.length)return n;let e={...n.timeSeriesData};for(let i of t){let{plugin:r,tag:o,sample:a}=i;e[r]=t1(e,r,o,a);let s=md(e,r,o,a),l=LF(i)?[i.runId]:ig(n.tagMetadata,r,o,a);s.runToLoadState=n1(De.LOADING,l,s.runToLoadState)}return{...n,timeSeriesData:e}}),Ee(PT,(n,{request:t})=>{let e={...n.timeSeriesData},{plugin:i,tag:r,sample:o}=t;e[i]=t1(e,i,r,o);let a=md(e,i,r,o),s=LF(t)?[t.runId]:ig(n.tagMetadata,i,r,o);return a.runToLoadState=n1(De.FAILED,s,a.runToLoadState),{...n,timeSeriesData:e}}),Ee(OT,(n,{response:t})=>{let e={...n.stepMinMax},i={...n.cardStateMap},r={...n.timeSeriesData},{plugin:o,tag:a,runId:s,sample:l}=t;r[o]=t1(r,o,a,l);let c=md(r,o,a,l);if(XS(t)){let u=s?[s]:ig(n.tagMetadata,o,a,l);c.runToLoadState=n1(De.FAILED,u,c.runToLoadState)}else{let u=t.runToSeries;c.runToSeries={...c.runToSeries},c.runToLoadState={...c.runToLoadState};for(let p in u)if(u.hasOwnProperty(p)){c.runToSeries[p]=u[p],c.runToLoadState[p]=De.LOADED;for(let f of u[p])e.min=Math.min(e.min,f.step),e.max=Math.max(e.max,f.step)}}if(t.runToSeries&&t.plugin===qn.SCALARS){let u=jF({plugin:o,tag:a,runId:null}),p=function(n){let t=1/0,e=-1/0;return Object.values(n).flat().forEach(i=>{t=Math.min(t,i.step),e=Math.max(e,i.step)}),{minStep:t,maxStep:e}}(c.runToSeries);i[u]={...i[u],dataMinMax:p};let f=n.cardToPinnedCopy.get(u);f&&(i[f]={...i[f],dataMinMax:p})}return{...n,timeSeriesData:r,cardStepIndex:Jwe(n.cardMetadataMap,n.cardStepIndex,r,n.timeSeriesData),stepMinMax:e,cardStateMap:i}}),Ee(FT,(n,{cardId:t,stepIndex:e})=>{let i=YL(t,n.cardMetadataMap,n.timeSeriesData),r=e;return null===i?r=null:e>i&&(r=i),{...n,cardStepIndex:{...n.cardStepIndex,[t]:{index:r,isClosest:!1}}}}),Ee(NT,(n,{tagGroup:t})=>{let e=new Map(n.tagGroupExpanded);return e.set(t,!e.get(t)),{...n,tagGroupExpanded:e}}),Ee(Jg,(n,{enteredCards:t,exitedCards:e})=>{if(!t.length&&!e.length)return n;let i=new Map(n.visibleCardMap);return t.forEach(({elementId:r,cardId:o})=>{let a=i.get(r)??null;if(null!==a&&a!==o)throw new Error("A DOM element cannot be reused for more than 1 unique card metadata");i.set(r,o)}),e.forEach(({elementId:r})=>{i.delete(r)}),{...n,visibleCardMap:i}}),Ee($g,(n,{cardId:t})=>{let e=n.pinnedCardToOriginal.has(t),i=!e&&!n.cardToPinnedCopy.has(t);if(i&&!i1(n))return n;let r=new Map(n.cardToPinnedCopy),o=new Map(n.cardToPinnedCopyCache),a=new Map(n.pinnedCardToOriginal),s={...n.cardMetadataMap},l={...n.cardStepIndex},c={...n.cardStateMap};if(e){let d=n.pinnedCardToOriginal.get(t);r.delete(d),o.delete(d),a.delete(t),delete s[t],delete l[t],delete c[t]}else if(i){let d=WF(t,r,o,a,l,s,c);r=d.cardToPinnedCopy,o=d.cardToPinnedCopyCache,a=d.pinnedCardToOriginal,s=d.cardMetadataMap,l=d.cardStepIndex,c=d.cardStateMap}else{let d=n.cardToPinnedCopy.get(t);r.delete(t),o.delete(t),a.delete(d),delete s[d],delete l[d],delete c[t]}return{...n,cardMetadataMap:s,cardStateMap:c,cardStepIndex:l,cardToPinnedCopy:r,cardToPinnedCopyCache:o,pinnedCardToOriginal:a}}),Ee(HT,n=>{let t=!n.linkedTimeEnabled,e={...n.cardStepIndex},i=n.linkedTimeSelection,r=n.stepSelectorEnabled,o=n.rangeSelectionEnabled;if(t){let{max:a}=n.stepMinMax;i=n.linkedTimeSelection??{start:{step:a===-1/0?0:a},end:null},e=qF(n.cardStepIndex,n.cardMetadataMap,n.timeSeriesData,i),r=t,o=Boolean(i.end)}return{...n,cardStepIndex:e,linkedTimeEnabled:t,linkedTimeSelection:i,stepSelectorEnabled:r,rangeSelectionEnabled:o}}),Ee(zT,n=>{let t=!n.rangeSelectionEnabled,e=n.stepSelectorEnabled,i=n.linkedTimeSelection,r=Object.entries(n.cardStateMap).reduce((o,[a,s])=>(o[a]={...s,stepSelectionOverride:La.NONE,rangeSelectionOverride:La.NONE},o),{});return t?(e=t,i||(i={start:{step:n.stepMinMax.min},end:{step:n.stepMinMax.max}}),i.end||(i={start:{step:n.stepMinMax.min},end:i.start})):i&&(i={start:i.end??i.start,end:null}),{...n,stepSelectorEnabled:e,rangeSelectionEnabled:t,linkedTimeSelection:i,cardStateMap:r}}),Ee(Yf,(n,t)=>{let{cardId:e,timeSelection:i}=t,r=i.start.step,o=i.end?.step,s=n.rangeSelectionEnabled;n.linkedTimeEnabled&&(s=void 0!==o);let l={start:{step:r},end:void 0===o?null:{step:r>o?r:o}},c=qF(n.cardStepIndex,n.cardMetadataMap,n.timeSeriesData,l),d={...n.cardStateMap};return e&&(d[e]={...d[e],timeSelection:l,stepSelectionOverride:La.OVERRIDE_AS_ENABLED,rangeSelectionOverride:void 0===l.end?.step?La.OVERRIDE_AS_DISABLED:La.OVERRIDE_AS_ENABLED}),{...n,linkedTimeSelection:l,cardStepIndex:c,cardStateMap:d,rangeSelectionEnabled:s}}),Ee(Mv,(n,{cardId:t,userViewBox:e})=>{let i={...n.cardStateMap};return i[t]={...i[t],userViewBox:e},{...n,cardStateMap:i}}),Ee(Dd,(n,{affordance:t,cardId:e})=>{let i={...n.cardStateMap};if(e){let{timeSelection:s,...l}=i[e]||{};i[e]={...l,stepSelectionOverride:La.OVERRIDE_AS_DISABLED}}else Object.keys(i).forEach(s=>{i[s]={...i[s],stepSelectionOverride:La.NONE}});if(!n.linkedTimeEnabled&&t!==Ga.CHECK_BOX)return{...n,cardStateMap:i};let r=!n.stepSelectorEnabled,o=r&&n.linkedTimeEnabled,a=r&&n.rangeSelectionEnabled;return{...n,linkedTimeEnabled:o,stepSelectorEnabled:r,rangeSelectionEnabled:a,cardStateMap:i}}),Ee(fT,(n,{tab:t})=>({...n,tableEditorSelectedTab:t})),Ee(e0,(n,{dataTableMode:t,headers:e})=>{let i=[],r=[];return e.forEach(o=>{o.enabled?i.push(o):r.push(o)}),t===lo.RANGE?{...n,rangeSelectionHeaders:i.concat(r)}:{...n,singleSelectionHeaders:i.concat(r)}}),Ee(t0,(n,{dataTableMode:t,header:e,cardId:i})=>{let{cardStateMap:r,rangeSelectionEnabled:o,linkedTimeEnabled:a}=n,s=i?o1(r,o,a,i):t===lo.RANGE,l=s?n.rangeSelectionHeaders:n.singleSelectionHeaders,c=l.findIndex(p=>p.name===e.name),d=function(n){let t=0;return n.forEach(e=>{e.enabled&&t++}),t}(l);l[c].enabled&&d--;let u=function(n,t,e){let i=[...e];return i.splice(n,1),i.splice(t,0,e[n]),i}(c,d,l);return u[d]={...u[d],enabled:!u[d].enabled},s?{...n,rangeSelectionHeaders:u}:{...n,singleSelectionHeaders:u}}),Ee(BT,(n,{plugin:t})=>{let e=new Set(n.filteredPluginTypes);return e.has(t)?e.delete(t):e.add(t),Object.values(qn).every(i=>e.has(i))&&(e=new Set),{...n,filteredPluginTypes:e}}),Ee(VT,n=>({...n,filteredPluginTypes:new Set})),Ee(dT,n=>({...n,isSettingsPaneOpen:!n.isSettingsPaneOpen})),Ee(cT,n=>({...n,isSettingsPaneOpen:!1})),Ee(uT,n=>({...n,isSlideoutMenuOpen:!n.isSlideoutMenuOpen})),Ee(pT,(n,{mode:t})=>({...n,isSlideoutMenuOpen:!0,isSettingsPaneOpen:!0,tableEditorSelectedTab:t})),Ee(mT,n=>({...n,isSlideoutMenuOpen:!1})));function hQ(n,t){return yf(eSe,$we)(n,t)}function fQ(n,t){return{tagDescriptions:n[t].tagDescriptions,tagToRuns:tSe(n[t].runTagInfo)}}function tSe(n){let t={};for(let e in n)for(let i of n[e])t[i]=[...t[i]||[],e];return t}var rSe=q(hd,Us,(n,t,e)=>t?{...t,loadState:n,id:e}:null),gQ=ye("[Metrics Effects] Init"),_Q=(()=>{class n{constructor(e,i,r){this.actions$=e,this.store=i,this.dataSource=r,this.dashboardShownWithoutData$=this.actions$.pipe(wi(gQ,xc,gf,Ls),Yt(this.store.select(qo),this.store.select(wb)),Ve(([,o,a])=>o===xb&&a.state===De.NOT_LOADED)),this.reloadRequestedWhileShown$=this.actions$.pipe(wi(ss,Hs),Yt(this.store.select(qo)),Ve(([,o])=>o===xb)),this.loadTagMetadata$=cn(this.dashboardShownWithoutData$,this.reloadRequestedWhileShown$).pipe(Yt(this.store.select(wb),this.store.select(ro)),Ve(([,o,a])=>o.state!==De.LOADING&&null!==a),eu(10),Vt(()=>{this.store.dispatch(hT())}),yi(([,,o])=>this.dataSource.fetchTagMetadata(o).pipe(Vt(a=>{this.store.dispatch(gT({tagMetadata:a}))}),fo(()=>(this.store.dispatch(_T()),qt(null)))))),this.visibleCardsWithoutDataChanged$=this.actions$.pipe(wi(Jg),Yt(this.getVisibleCardFetchInfos()),U(([,o])=>o.filter(a=>a.loadState===De.NOT_LOADED))),this.visibleCardsReloaded$=this.reloadRequestedWhileShown$.pipe(Yt(this.getVisibleCardFetchInfos()),U(([,o])=>o.filter(a=>a.loadState!==De.LOADING))),this.loadTimeSeries$=cn(this.visibleCardsWithoutDataChanged$,this.visibleCardsReloaded$).pipe(Ve(o=>o.length>0),Yt(this.store.select(ro).pipe(Ve(o=>null!==o))),hn(([o,a])=>this.fetchTimeSeriesForCards(o,a))),this.dataEffects$=Or(()=>cn(this.loadTagMetadata$,this.loadTimeSeries$),{dispatch:!1})}ngrxOnInitEffects(){return gQ()}getVisibleCardFetchInfos(){return this.store.select(UW).pipe(yi(i=>i.size?po([...i].map(o=>this.store.select(rSe,o).pipe(zt(1)))):qt([])),U(i=>i.filter(Boolean)))}fetchTimeSeries(e){return this.dataSource.fetchTimeSeries([e]).pipe(Vt(i=>{let r=i.filter(XS);r.length&&console.error("Time series response contained errors:",r),this.store.dispatch(OT({response:i[0]}))}),fo(()=>(this.store.dispatch(PT({request:e})),qt(null))))}fetchTimeSeriesForCards(e,i){return qt(e.map(o=>{let{plugin:a,tag:s,runId:l,sample:c}=o,d=cs(a)?{plugin:a,tag:s,runId:l}:{plugin:a,tag:s,experimentIds:i};return void 0!==c&&(d.sample=c),d})).pipe(Vt(o=>{this.store.dispatch(kT({requests:o}))}),hn(o=>cn(...o.map(s=>this.fetchTimeSeries(s)))))}}return n.\u0275fac=function(e){return new(e||n)(O(Wo),O(ke),O(Mc))},n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})(),QL=new ie("Metrics Store Config"),ZL=new ie("Metrics Initial Settings Config");function yQ(n){return n?{initialState:{...XL,settings:n}}:{initialState:XL}}var ps=(()=>(function(n){n[n.LEFT=1]="LEFT",n[n.RIGHT=2]="RIGHT",n[n.MIDDLE=4]="MIDDLE",n[n.FOURTH=8]="FOURTH",n[n.FIFTH=32]="FIFTH"}(ps||(ps={})),ps))(),bQ=0;function oSe(n,t){if(1&n){let e=ge();h(0,"button",3),D("click",function(){return X(e),Q(w().expandSidebar())}),P(1,"mat-icon",4),g()}}function aSe(n,t){if(1&n&&(h(0,"nav",5),G(1,"async"),G(2,"async"),Xt(3,1),g()),2&n){let e=w();Mt("width",W(1,6,e.width$),"%")("min-width",e.MINIMUM_SIDEBAR_WIDTH_IN_PX,"px")("max-width",W(2,8,e.runsTableFullScreen$)?100:"","%")}}function sSe(n,t){if(1&n){let e=ge();h(0,"div",6),D("mousedown",function(){return X(e),Q(w().resizeGrabbed())}),g()}}var lSe=[[["","main",""]],[["","sidebar",""]]],cSe=["[main]","[sidebar]"],xQ=(()=>{class n{constructor(e,i){this.store=e,this.runsTableFullScreen$=this.store.select(Zh),this.width$=this.store.select(TS).pipe(Vi(this.runsTableFullScreen$),U(([r,o])=>o?100:r)),this.ngUnsubscribe=new Ae,this.resizing=!1,this.MINIMUM_SIDEBAR_WIDTH_IN_PX=75,ai(i.nativeElement,"mousemove").pipe(ot(this.ngUnsubscribe),Ve(()=>this.resizing)).subscribe(r=>{if((r.buttons&ps.LEFT)!==ps.LEFT)return void(this.resizing=!1);r.preventDefault();let{width:o}=i.nativeElement.getBoundingClientRect();this.store.dispatch(Yh({widthInPercent:r.clientX<=this.MINIMUM_SIDEBAR_WIDTH_IN_PX?0:r.clientX/o*100}))}),ai(i.nativeElement,"mouseup",{passive:!0}).pipe(ot(this.ngUnsubscribe)).subscribe(()=>{this.resizing=!1})}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}resizeGrabbed(){this.resizing=!0}expandSidebar(){this.store.dispatch(Yh({widthInPercent:20}))}}return n.\u0275fac=function(e){return new(e||n)(C(ke),C(be))},n.\u0275cmp=k({type:n,selectors:[["tb-dashboard-layout"]],ngContentSelectors:cSe,decls:7,vars:9,consts:[["class","expand",3,"click",4,"ngIf"],["class","sidebar",3,"width","minWidth","maxWidth",4,"ngIf"],["class","resizer",3,"mousedown",4,"ngIf"],[1,"expand",3,"click"],["svgIcon","expand_more_24px"],[1,"sidebar"],[1,"resizer",3,"mousedown"]],template:function(e,i){1&e&&(gn(lSe),S(0,oSe,2,0,"button",0),G(1,"async"),S(2,aSe,4,10,"nav",1),G(3,"async"),S(4,sSe,1,0,"div",2),G(5,"async"),Xt(6)),2&e&&(_("ngIf",0===W(1,3,i.width$)),b(2),_("ngIf",W(3,5,i.width$)>0),b(2),_("ngIf",W(5,7,i.width$)>0))},dependencies:[Fe,Dn,lt],styles:["[_nghost-%COMP%]{display:flex;flex-direction:row;height:100%;width:100%;position:relative}.sidebar[_ngcontent-%COMP%]{max-width:80vw}.resizer[_ngcontent-%COMP%], .expand[_ngcontent-%COMP%]{border-color:#ebebeb;box-sizing:border-box;flex:0 0;justify-self:stretch}body.dark-mode[_nghost-%COMP%]   .resizer[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .resizer[_ngcontent-%COMP%]{border-color:#555}body.dark-mode[_nghost-%COMP%]   .expand[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .expand[_ngcontent-%COMP%]{border-color:#555}.expand[_ngcontent-%COMP%]{width:20px}.resizer[_ngcontent-%COMP%]{align-items:center;border-style:solid;border-width:0 2px;cursor:ew-resize;contain:strict;display:flex;justify-self:stretch}.resizer[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{width:100%}.resizer[_ngcontent-%COMP%]:hover{border-color:#ccc;outline:3px solid #ccc;z-index:1}body.dark-mode[_nghost-%COMP%]   .resizer[_ngcontent-%COMP%]:hover, body.dark-mode   [_nghost-%COMP%]   .resizer[_ngcontent-%COMP%]:hover{outline-color:#777;border-color:#777}.expand[_ngcontent-%COMP%]{align-items:center;background:rgba(0,0,0,0);border-style:solid;border-width:0 1px 0 0;color:inherit;contain:content;cursor:pointer;display:flex;justify-self:stretch;padding:0}.expand[_ngcontent-%COMP%]   mat-icon[_ngcontent-%COMP%]{transform:rotate(-90deg);transform-origin:center}"],changeDetection:0}),n})(),KL=new WeakMap,Ev=class{constructor(t,e){this.root=t,this.buffer=e,this.destroyedTargets=new WeakSet}initialize(t){if(this.intersectionObserver)return;this.intersectionCallback=t;let e={threshold:0,root:this.root??null};this.buffer&&(e.rootMargin=this.buffer),this.intersectionObserver=new IntersectionObserver(this.onCardIntersection.bind(this),e)}add(t){this.ensureInitialized()&&this.intersectionObserver.observe(t)}willDestroy(t){this.ensureInitialized()&&this.destroyedTargets.add(t)}ensureInitialized(){if(!this.intersectionObserver)throw new Error("CardObserver must be initialized before use");return!0}onCardIntersection(t){t.sort((r,o)=>r.time-o.time);let e=new Set,i=new Set;for(let{isIntersecting:r,target:o}of t)r?(e.add(o),i.delete(o)):(e.delete(o),i.add(o)),this.destroyedTargets.has(o)&&!r&&(this.destroyedTargets.delete(o),this.intersectionObserver.unobserve(o));this.intersectionCallback(e,i)}onCardIntersectionForTest(t){this.onCardIntersection(t)}},CQ=(()=>{class n{constructor(e,i){this.host=e,this.store=i}onCardIntersection(e,i){let r=[...e].map(a=>{let s=KL.get(a);if(!s)throw new Error("A CardObserver element must have an associated element id and card id.");return{elementId:s.elementId,cardId:s.cardId}}),o=[...i].map(a=>{let s=KL.get(a);if(!s)throw new Error("A CardObserver element must have an associated element id and card id.");return{elementId:s.elementId,cardId:s.cardId}});this.store.dispatch(Jg({enteredCards:r,exitedCards:o}))}ngOnInit(){let e=this.host.nativeElement;KL.set(e,{elementId:(bQ++,Symbol(bQ)),cardId:this.cardId}),this.cardObserver||(this.cardObserver=new Ev),this.cardObserver.initialize(this.onCardIntersection.bind(this)),this.cardObserver.add(e)}ngOnDestroy(){this.cardObserver&&this.cardObserver.willDestroy(this.host.nativeElement)}hostForTest(){return this.host}}return n.\u0275fac=function(e){return new(e||n)(C(be),C(ke))},n.\u0275dir=xe({type:n,selectors:[["","cardLazyLoader",""]],inputs:{cardId:["cardLazyLoader","cardId"],cardObserver:"cardObserver"}}),n})();function pSe(n,t){1&n&&(Tt(0),Xt(1),Dt())}var fSe=["*"],MQ=(()=>{class n{constructor(e,i){this.viewContainerRef=e,this.componentFactoryResolver=i}ngOnInit(){if(this.customizableComponent){let e=this.componentFactoryResolver.resolveComponentFactory(this.customizableComponent.constructor);this.viewContainerRef.createComponent(e)}}}return n.\u0275fac=function(e){return new(e||n)(C(Zn),C(Qr))},n.\u0275cmp=k({type:n,selectors:[["tb-customization"]],inputs:{customizableComponent:"customizableComponent"},ngContentSelectors:fSe,decls:1,vars:1,consts:[[4,"ngIf"]],template:function(e,i){1&e&&(gn(),S(0,pSe,2,0,"ng-container",0)),2&e&&_("ngIf",!i.customizableComponent)},dependencies:[Fe],encapsulation:2}),n})(),hSe=["button"],gSe=["*"],wQ=new ie("MAT_BUTTON_TOGGLE_DEFAULT_OPTIONS"),SQ=new ie("MatButtonToggleGroup"),_Se={provide:Hr,useExisting:Vn(()=>JL),multi:!0},EQ=0,jT=class{constructor(t,e){this.source=t,this.value=e}},JL=(()=>{class n{get name(){return this._name}set name(e){this._name=e,this._markButtonsForCheck()}get vertical(){return this._vertical}set vertical(e){this._vertical=Ut(e)}get value(){let e=this._selectionModel?this._selectionModel.selected:[];return this.multiple?e.map(i=>i.value):e[0]?e[0].value:void 0}set value(e){this._setSelectionByValue(e),this.valueChange.emit(this.value)}get selected(){let e=this._selectionModel?this._selectionModel.selected:[];return this.multiple?e:e[0]||null}get multiple(){return this._multiple}set multiple(e){this._multiple=Ut(e),this._markButtonsForCheck()}get disabled(){return this._disabled}set disabled(e){this._disabled=Ut(e),this._markButtonsForCheck()}constructor(e,i){this._changeDetector=e,this._vertical=!1,this._multiple=!1,this._disabled=!1,this._controlValueAccessorChangeFn=()=>{},this._onTouched=()=>{},this._name="mat-button-toggle-group-"+EQ++,this.valueChange=new L,this.change=new L,this.appearance=i&&i.appearance?i.appearance:"standard"}ngOnInit(){this._selectionModel=new xg(this.multiple,void 0,!1)}ngAfterContentInit(){this._selectionModel.select(...this._buttonToggles.filter(e=>e.checked))}writeValue(e){this.value=e,this._changeDetector.markForCheck()}registerOnChange(e){this._controlValueAccessorChangeFn=e}registerOnTouched(e){this._onTouched=e}setDisabledState(e){this.disabled=e}_emitChangeEvent(e){let i=new jT(e,this.value);this._controlValueAccessorChangeFn(i.value),this.change.emit(i)}_syncButtonToggle(e,i,r=!1,o=!1){!this.multiple&&this.selected&&!e.checked&&(this.selected.checked=!1),this._selectionModel?i?this._selectionModel.select(e):this._selectionModel.deselect(e):o=!0,o?Promise.resolve().then(()=>this._updateModelValue(e,r)):this._updateModelValue(e,r)}_isSelected(e){return this._selectionModel&&this._selectionModel.isSelected(e)}_isPrechecked(e){return!(typeof this._rawValue>"u")&&(this.multiple&&Array.isArray(this._rawValue)?this._rawValue.some(i=>null!=e.value&&i===e.value):e.value===this._rawValue)}_setSelectionByValue(e){this._rawValue=e,this._buttonToggles&&(this.multiple&&e?(Array.isArray(e),this._clearSelection(),e.forEach(i=>this._selectValue(i))):(this._clearSelection(),this._selectValue(e)))}_clearSelection(){this._selectionModel.clear(),this._buttonToggles.forEach(e=>e.checked=!1)}_selectValue(e){let i=this._buttonToggles.find(r=>null!=r.value&&r.value===e);i&&(i.checked=!0,this._selectionModel.select(i))}_updateModelValue(e,i){i&&this._emitChangeEvent(e),this.valueChange.emit(this.value)}_markButtonsForCheck(){this._buttonToggles?.forEach(e=>e._markForCheck())}}return n.\u0275fac=function(e){return new(e||n)(C(Ft),C(wQ,8))},n.\u0275dir=xe({type:n,selectors:[["mat-button-toggle-group"]],contentQueries:function(e,i,r){if(1&e&&ci(r,bSe,5),2&e){let o;we(o=Se())&&(i._buttonToggles=o)}},hostAttrs:["role","group",1,"mat-button-toggle-group"],hostVars:5,hostBindings:function(e,i){2&e&&(Pe("aria-disabled",i.disabled),Qe("mat-button-toggle-vertical",i.vertical)("mat-button-toggle-group-appearance-standard","standard"===i.appearance))},inputs:{appearance:"appearance",name:"name",vertical:"vertical",value:"value",multiple:"multiple",disabled:"disabled"},outputs:{valueChange:"valueChange",change:"change"},exportAs:["matButtonToggleGroup"],features:[Rt([_Se,{provide:SQ,useExisting:n}])]}),n})(),ySe=Qo(class{}),bSe=(()=>{class n extends ySe{get buttonId(){return`${this.id}-button`}get appearance(){return this.buttonToggleGroup?this.buttonToggleGroup.appearance:this._appearance}set appearance(e){this._appearance=e}get checked(){return this.buttonToggleGroup?this.buttonToggleGroup._isSelected(this):this._checked}set checked(e){let i=Ut(e);i!==this._checked&&(this._checked=i,this.buttonToggleGroup&&this.buttonToggleGroup._syncButtonToggle(this,this._checked),this._changeDetectorRef.markForCheck())}get disabled(){return this._disabled||this.buttonToggleGroup&&this.buttonToggleGroup.disabled}set disabled(e){this._disabled=Ut(e)}constructor(e,i,r,o,a,s){super(),this._changeDetectorRef=i,this._elementRef=r,this._focusMonitor=o,this._checked=!1,this.ariaLabelledby=null,this._disabled=!1,this.change=new L;let l=Number(a);this.tabIndex=l||0===l?l:null,this.buttonToggleGroup=e,this.appearance=s&&s.appearance?s.appearance:"standard"}ngOnInit(){let e=this.buttonToggleGroup;this.id=this.id||"mat-button-toggle-"+EQ++,e&&(e._isPrechecked(this)?this.checked=!0:e._isSelected(this)!==this._checked&&e._syncButtonToggle(this,this._checked))}ngAfterViewInit(){this._focusMonitor.monitor(this._elementRef,!0)}ngOnDestroy(){let e=this.buttonToggleGroup;this._focusMonitor.stopMonitoring(this._elementRef),e&&e._isSelected(this)&&e._syncButtonToggle(this,!1,!1,!0)}focus(e){this._buttonElement.nativeElement.focus(e)}_onButtonClick(){let e=!!this._isSingleSelector()||!this._checked;e!==this._checked&&(this._checked=e,this.buttonToggleGroup&&(this.buttonToggleGroup._syncButtonToggle(this,this._checked,!0),this.buttonToggleGroup._onTouched())),this.change.emit(new jT(this,this.value))}_markForCheck(){this._changeDetectorRef.markForCheck()}_getButtonName(){return this._isSingleSelector()?this.buttonToggleGroup.name:this.name||null}_isSingleSelector(){return this.buttonToggleGroup&&!this.buttonToggleGroup.multiple}}return n.\u0275fac=function(e){return new(e||n)(C(SQ,8),C(Ft),C(be),C(lr),Vr("tabindex"),C(wQ,8))},n.\u0275cmp=k({type:n,selectors:[["mat-button-toggle"]],viewQuery:function(e,i){if(1&e&&Ye(hSe,5),2&e){let r;we(r=Se())&&(i._buttonElement=r.first)}},hostAttrs:["role","presentation",1,"mat-button-toggle"],hostVars:12,hostBindings:function(e,i){1&e&&D("focus",function(){return i.focus()}),2&e&&(Pe("aria-label",null)("aria-labelledby",null)("id",i.id)("name",null),Qe("mat-button-toggle-standalone",!i.buttonToggleGroup)("mat-button-toggle-checked",i.checked)("mat-button-toggle-disabled",i.disabled)("mat-button-toggle-appearance-standard","standard"===i.appearance))},inputs:{disableRipple:"disableRipple",ariaLabel:["aria-label","ariaLabel"],ariaLabelledby:["aria-labelledby","ariaLabelledby"],id:"id",name:"name",value:"value",tabIndex:"tabIndex",appearance:"appearance",checked:"checked",disabled:"disabled"},outputs:{change:"change"},exportAs:["matButtonToggle"],features:[Le],ngContentSelectors:gSe,decls:6,vars:9,consts:[["type","button",1,"mat-button-toggle-button","mat-focus-indicator",3,"id","disabled","click"],["button",""],[1,"mat-button-toggle-label-content"],[1,"mat-button-toggle-focus-overlay"],["matRipple","",1,"mat-button-toggle-ripple",3,"matRippleTrigger","matRippleDisabled"]],template:function(e,i){if(1&e&&(gn(),h(0,"button",0,1),D("click",function(){return i._onButtonClick()}),h(2,"span",2),Xt(3),g()(),P(4,"span",3)(5,"span",4)),2&e){let r=tt(1);_("id",i.buttonId)("disabled",i.disabled||null),Pe("tabindex",i.disabled?-1:i.tabIndex)("aria-pressed",i.checked)("name",i._getButtonName())("aria-label",i.ariaLabel)("aria-labelledby",i.ariaLabelledby),b(5),_("matRippleTrigger",r)("matRippleDisabled",i.disableRipple||i.disabled)}},dependencies:[Fr],styles:[".mat-button-toggle-standalone,.mat-button-toggle-group{position:relative;display:inline-flex;flex-direction:row;white-space:nowrap;overflow:hidden;border-radius:2px;-webkit-tap-highlight-color:rgba(0,0,0,0);transform:translateZ(0)}.cdk-high-contrast-active .mat-button-toggle-standalone,.cdk-high-contrast-active .mat-button-toggle-group{outline:solid 1px}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard,.mat-button-toggle-group-appearance-standard{border-radius:4px}.cdk-high-contrast-active .mat-button-toggle-standalone.mat-button-toggle-appearance-standard,.cdk-high-contrast-active .mat-button-toggle-group-appearance-standard{outline:0}.mat-button-toggle-vertical{flex-direction:column}.mat-button-toggle-vertical .mat-button-toggle-label-content{display:block}.mat-button-toggle{white-space:nowrap;position:relative}.mat-button-toggle .mat-icon svg{vertical-align:top}.mat-button-toggle.cdk-keyboard-focused .mat-button-toggle-focus-overlay{opacity:1}.mat-button-toggle-appearance-standard:not(.mat-button-toggle-disabled):hover .mat-button-toggle-focus-overlay{opacity:.04}.mat-button-toggle-appearance-standard.cdk-keyboard-focused:not(.mat-button-toggle-disabled) .mat-button-toggle-focus-overlay{opacity:.12}@media(hover: none){.mat-button-toggle-appearance-standard:not(.mat-button-toggle-disabled):hover .mat-button-toggle-focus-overlay{display:none}}.mat-button-toggle-label-content{-webkit-user-select:none;user-select:none;display:inline-block;line-height:36px;padding:0 16px;position:relative}.mat-button-toggle-appearance-standard .mat-button-toggle-label-content{padding:0 12px}.mat-button-toggle-label-content>*{vertical-align:middle}.mat-button-toggle-focus-overlay{top:0;left:0;right:0;bottom:0;position:absolute;border-radius:inherit;pointer-events:none;opacity:0}.cdk-high-contrast-active .mat-button-toggle-checked .mat-button-toggle-focus-overlay{border-bottom:solid 36px;opacity:.5;height:0}.cdk-high-contrast-active .mat-button-toggle-checked:hover .mat-button-toggle-focus-overlay{opacity:.6}.cdk-high-contrast-active .mat-button-toggle-checked.mat-button-toggle-appearance-standard .mat-button-toggle-focus-overlay{border-bottom:solid 500px}.mat-button-toggle .mat-button-toggle-ripple{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none}.mat-button-toggle-button{border:0;background:none;color:inherit;padding:0;margin:0;font:inherit;outline:none;width:100%;cursor:pointer}.mat-button-toggle-disabled .mat-button-toggle-button{cursor:default}.mat-button-toggle-button::-moz-focus-inner{border:0}"],encapsulation:2,changeDetection:0}),n})(),GT=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Qt,Zo,Qt]}),n})(),TQ=(go(class{constructor(n){this._elementRef=n}},"primary"),new ie("mat-progress-spinner-default-options",{providedIn:"root",factory:function(){return{diameter:CSe}}})),CSe=100;function MSe(n,t){if(1&n&&(Tn(),P(0,"circle",4)),2&n){let e=w(),i=tt(1);Mt("animation-name","mat-progress-spinner-stroke-rotate-"+e._spinnerAnimationLabel)("stroke-dashoffset",e._getStrokeDashOffset(),"px")("stroke-dasharray",e._getStrokeCircumference(),"px")("stroke-width",e._getCircleStrokeWidth(),"%")("transform-origin",e._getCircleTransformOrigin(i)),Pe("r",e._getCircleRadius())}}function wSe(n,t){if(1&n&&(Tn(),P(0,"circle",4)),2&n){let e=w(),i=tt(1);Mt("stroke-dashoffset",e._getStrokeDashOffset(),"px")("stroke-dasharray",e._getStrokeCircumference(),"px")("stroke-width",e._getCircleStrokeWidth(),"%")("transform-origin",e._getCircleTransformOrigin(i)),Pe("r",e._getCircleRadius())}}var ESe=go(class{constructor(n){this._elementRef=n}},"primary"),zr=class extends ESe{get diameter(){return this._diameter}set diameter(t){this._diameter=Di(t),this._spinnerAnimationLabel=this._getSpinnerAnimationLabel(),this._styleRoot&&this._attachStyleNode()}get strokeWidth(){return this._strokeWidth||this.diameter/10}set strokeWidth(t){this._strokeWidth=Di(t)}get value(){return"determinate"===this.mode?this._value:0}set value(t){this._value=Math.max(0,Math.min(100,Di(t)))}constructor(t,e,i,r,o,a,s,l){super(t),this._document=i,this._diameter=100,this._value=0,this._resizeSubscription=yn.EMPTY,this.mode="determinate";let c=zr._diameters;this._spinnerAnimationLabel=this._getSpinnerAnimationLabel(),c.has(i.head)||c.set(i.head,new Set([100])),this._noopAnimations="NoopAnimations"===r&&!!o&&!o._forceAnimations,"mat-spinner"===t.nativeElement.nodeName.toLowerCase()&&(this.mode="indeterminate"),o&&(o.color&&(this.color=this.defaultColor=o.color),o.diameter&&(this.diameter=o.diameter),o.strokeWidth&&(this.strokeWidth=o.strokeWidth)),e.isBrowser&&e.SAFARI&&s&&a&&l&&(this._resizeSubscription=s.change(150).subscribe(()=>{"indeterminate"===this.mode&&l.run(()=>a.markForCheck())}))}ngOnInit(){let t=this._elementRef.nativeElement;this._styleRoot=O1(t)||this._document.head,this._attachStyleNode(),t.classList.add("mat-progress-spinner-indeterminate-animation")}ngOnDestroy(){this._resizeSubscription.unsubscribe()}_getCircleRadius(){return(this.diameter-10)/2}_getViewBox(){let t=2*this._getCircleRadius()+this.strokeWidth;return`0 0 ${t} ${t}`}_getStrokeCircumference(){return 2*Math.PI*this._getCircleRadius()}_getStrokeDashOffset(){return"determinate"===this.mode?this._getStrokeCircumference()*(100-this._value)/100:null}_getCircleStrokeWidth(){return this.strokeWidth/this.diameter*100}_getCircleTransformOrigin(t){let e=50*(t.currentScale??1);return`${e}% ${e}%`}_attachStyleNode(){let t=this._styleRoot,e=this._diameter,i=zr._diameters,r=i.get(t);if(!r||!r.has(e)){let o=this._document.createElement("style");o.setAttribute("mat-spinner-animation",this._spinnerAnimationLabel),o.textContent=this._getAnimationText(),t.appendChild(o),r||(r=new Set,i.set(t,r)),r.add(e)}}_getAnimationText(){let t=this._getStrokeCircumference();return"\n @keyframes mat-progress-spinner-stroke-rotate-DIAMETER {\n    0%      { stroke-dashoffset: START_VALUE;  transform: rotate(0); }\n    12.5%   { stroke-dashoffset: END_VALUE;    transform: rotate(0); }\n    12.5001%  { stroke-dashoffset: END_VALUE;    transform: rotateX(180deg) rotate(72.5deg); }\n    25%     { stroke-dashoffset: START_VALUE;  transform: rotateX(180deg) rotate(72.5deg); }\n\n    25.0001%   { stroke-dashoffset: START_VALUE;  transform: rotate(270deg); }\n    37.5%   { stroke-dashoffset: END_VALUE;    transform: rotate(270deg); }\n    37.5001%  { stroke-dashoffset: END_VALUE;    transform: rotateX(180deg) rotate(161.5deg); }\n    50%     { stroke-dashoffset: START_VALUE;  transform: rotateX(180deg) rotate(161.5deg); }\n\n    50.0001%  { stroke-dashoffset: START_VALUE;  transform: rotate(180deg); }\n    62.5%   { stroke-dashoffset: END_VALUE;    transform: rotate(180deg); }\n    62.5001%  { stroke-dashoffset: END_VALUE;    transform: rotateX(180deg) rotate(251.5deg); }\n    75%     { stroke-dashoffset: START_VALUE;  transform: rotateX(180deg) rotate(251.5deg); }\n\n    75.0001%  { stroke-dashoffset: START_VALUE;  transform: rotate(90deg); }\n    87.5%   { stroke-dashoffset: END_VALUE;    transform: rotate(90deg); }\n    87.5001%  { stroke-dashoffset: END_VALUE;    transform: rotateX(180deg) rotate(341.5deg); }\n    100%    { stroke-dashoffset: START_VALUE;  transform: rotateX(180deg) rotate(341.5deg); }\n  }\n".replace(/START_VALUE/g,""+.95*t).replace(/END_VALUE/g,""+.2*t).replace(/DIAMETER/g,`${this._spinnerAnimationLabel}`)}_getSpinnerAnimationLabel(){return this.diameter.toString().replace(".","_")}};zr._diameters=new WeakMap,zr.\u0275fac=function(t){return new(t||zr)(C(be),C($n),C(kt,8),C(di,8),C(TQ),C(Ft),C(Ko),C(at))},zr.\u0275cmp=k({type:zr,selectors:[["mat-progress-spinner"],["mat-spinner"]],hostAttrs:["role","progressbar","tabindex","-1",1,"mat-progress-spinner","mat-spinner"],hostVars:10,hostBindings:function(t,e){2&t&&(Pe("aria-valuemin","determinate"===e.mode?0:null)("aria-valuemax","determinate"===e.mode?100:null)("aria-valuenow","determinate"===e.mode?e.value:null)("mode",e.mode),Mt("width",e.diameter,"px")("height",e.diameter,"px"),Qe("_mat-animation-noopable",e._noopAnimations))},inputs:{color:"color",diameter:"diameter",strokeWidth:"strokeWidth",mode:"mode",value:"value"},exportAs:["matProgressSpinner"],features:[Le],decls:4,vars:8,consts:[["preserveAspectRatio","xMidYMid meet","focusable","false","aria-hidden","true",3,"ngSwitch"],["svg",""],["cx","50%","cy","50%",3,"animation-name","stroke-dashoffset","stroke-dasharray","stroke-width","transform-origin",4,"ngSwitchCase"],["cx","50%","cy","50%",3,"stroke-dashoffset","stroke-dasharray","stroke-width","transform-origin",4,"ngSwitchCase"],["cx","50%","cy","50%"]],template:function(t,e){1&t&&(Tn(),h(0,"svg",0,1),S(2,MSe,1,11,"circle",2),S(3,wSe,1,9,"circle",3),g()),2&t&&(Mt("width",e.diameter,"px")("height",e.diameter,"px"),_("ngSwitch","indeterminate"===e.mode),Pe("viewBox",e._getViewBox()),b(2),_("ngSwitchCase",!0),b(1),_("ngSwitchCase",!1))},dependencies:[$i,sr],styles:[".mat-progress-spinner{display:block;position:relative;overflow:hidden}.mat-progress-spinner svg{position:absolute;transform:rotate(-90deg);top:0;left:0;transform-origin:center;overflow:visible}.mat-progress-spinner circle{fill:rgba(0,0,0,0);transition:stroke-dashoffset 225ms linear}.cdk-high-contrast-active .mat-progress-spinner circle{stroke:CanvasText}.mat-progress-spinner[mode=indeterminate] svg{animation:mat-progress-spinner-linear-rotate 2000ms linear infinite}.mat-progress-spinner[mode=indeterminate] circle{transition-property:stroke;animation-duration:4000ms;animation-timing-function:cubic-bezier(0.35, 0, 0.25, 1);animation-iteration-count:infinite}.mat-progress-spinner._mat-animation-noopable svg,.mat-progress-spinner._mat-animation-noopable circle{animation:none;transition:none}@keyframes mat-progress-spinner-linear-rotate{0%{transform:rotate(0deg)}100%{transform:rotate(360deg)}}@keyframes mat-progress-spinner-stroke-rotate-100{0%{stroke-dashoffset:268.606171575px;transform:rotate(0)}12.5%{stroke-dashoffset:56.5486677px;transform:rotate(0)}12.5001%{stroke-dashoffset:56.5486677px;transform:rotateX(180deg) rotate(72.5deg)}25%{stroke-dashoffset:268.606171575px;transform:rotateX(180deg) rotate(72.5deg)}25.0001%{stroke-dashoffset:268.606171575px;transform:rotate(270deg)}37.5%{stroke-dashoffset:56.5486677px;transform:rotate(270deg)}37.5001%{stroke-dashoffset:56.5486677px;transform:rotateX(180deg) rotate(161.5deg)}50%{stroke-dashoffset:268.606171575px;transform:rotateX(180deg) rotate(161.5deg)}50.0001%{stroke-dashoffset:268.606171575px;transform:rotate(180deg)}62.5%{stroke-dashoffset:56.5486677px;transform:rotate(180deg)}62.5001%{stroke-dashoffset:56.5486677px;transform:rotateX(180deg) rotate(251.5deg)}75%{stroke-dashoffset:268.606171575px;transform:rotateX(180deg) rotate(251.5deg)}75.0001%{stroke-dashoffset:268.606171575px;transform:rotate(90deg)}87.5%{stroke-dashoffset:56.5486677px;transform:rotate(90deg)}87.5001%{stroke-dashoffset:56.5486677px;transform:rotateX(180deg) rotate(341.5deg)}100%{stroke-dashoffset:268.606171575px;transform:rotateX(180deg) rotate(341.5deg)}}"],encapsulation:2,changeDetection:0});var Lc=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Qt,Te,Qt]}),n})();function DSe(n,t){if(1&n&&(h(0,"b"),T(1),g()),2&n){let e=w().$implicit;b(1),ze("",e.displayAlias,":")}}function ISe(n,t){if(1&n&&(h(0,"mat-option",2)(1,"span",3),S(2,DSe,2,1,"b",4),T(3),g()()),2&n){let e=t.$implicit;_("value",e.value)("disabled",e.disabled),b(1),qM("title","",e.displayAlias,": ",e.displayText,""),b(1),_("ngIf",e.displayAlias),b(1),ze(" ",e.displayText," ")}}var IQ=(()=>{class n{constructor(){this.value="",this.options=[],this.selectionChange=new L}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["tb-dropdown"]],inputs:{value:"value",options:"options"},outputs:{selectionChange:"selectionChange"},decls:2,vars:2,consts:[[3,"value","selectionChange"],[3,"value","disabled",4,"ngFor","ngForOf"],[3,"value","disabled"],[1,"option-content",3,"title"],[4,"ngIf"]],template:function(e,i){1&e&&(h(0,"mat-select",0),D("selectionChange",function(o){return i.selectionChange.emit(o.value)}),S(1,ISe,4,6,"mat-option",1),g()),2&e&&(_("value",i.value),b(1),_("ngForOf",i.options))},dependencies:[dn,Fe,Gu,Ha],styles:["mat-select[_ngcontent-%COMP%]{border:1px solid #8e98a3;border-radius:3px;box-sizing:border-box;padding:6px}mat-select[_ngcontent-%COMP%]:focus{outline-color:-webkit-focus-ring-color;outline-style:auto}  .mat-select-panel{max-width:70vw}  mat-option.mat-option{height:auto}  .mat-option-text{white-space:normal;word-break:break-all}.option-content[_ngcontent-%COMP%]{white-space:nowrap}"]}),n})(),RSe=function(n){return{"column-edit-menu-toggle":!0,"toggle-opened":n}};function kSe(n,t){if(1&n){let e=ge();h(0,"button",31),D("click",function(){return X(e),Q(w().onSlideOutToggled.emit())}),P(1,"mat-icon",32),T(2," Edit Table Columns "),g()}if(2&n){let e=w();_("ngClass",Sn(1,RSe,e.isSlideOutMenuOpen))}}function PSe(n,t){if(1&n){let e=ge();h(0,"section",33)(1,"h3",1),T(2,"Images"),g(),h(3,"div",34)(4,"div",35),T(5,"Brightness"),g(),h(6,"div",13)(7,"mat-slider",36),D("input",function(r){return X(e),Q(w().imageBrightnessSliderChanged$.emit(r.value))}),g(),h(8,"button",37),D("click",function(){return X(e),Q(w().imageBrightnessReset.emit())}),P(9,"mat-icon",16),g()()(),h(10,"div",38)(11,"div",39),T(12,"Contrast"),g(),h(13,"div",13)(14,"mat-slider",40),D("input",function(r){return X(e),Q(w().imageContrastSliderChanged$.emit(r.value))}),g(),h(15,"button",41),D("click",function(){return X(e),Q(w().imageContrastReset.emit())}),P(16,"mat-icon",16),g()()(),h(17,"div",42)(18,"mat-checkbox",25),D("change",function(r){return X(e),Q(w().imageShowActualSizeChanged.emit(r.checked))}),T(19,"Show actual image size"),g()()()}if(2&n){let e=w();b(7),_("max",2e3)("min",0)("step",10)("value",e.imageBrightnessInMilli)("thumbLabel",!0)("displayWith",e.formatMilliToZeroth),b(7),_("max",5e3)("min",0)("step",10)("value",e.imageContrastInMilli)("thumbLabel",!0)("displayWith",e.formatMilliToZeroth),b(4),_("checked",e.imageShowActualSize)}}var RQ=(()=>{class n{constructor(e){this.locale=e,this.linkedTimeToggled=new L,this.stepSelectorToggled=new L,this.rangeSelectionToggled=new L,this.onSlideOutToggled=new L,this.TooltipSortDropdownOptions=[{value:ao.ALPHABETICAL,displayText:"Alphabetical"},{value:ao.ASCENDING,displayText:"Ascending"},{value:ao.DESCENDING,displayText:"Descending"},{value:ao.NEAREST,displayText:"Nearest Pixel"},{value:ao.NEAREST_Y,displayText:"Nearest Y"}],this.tooltipSortChanged=new L,this.ignoreOutliersChanged=new L,this.XAxisType=Pi,this.XAxisTypeDropdownOptions=[{value:Pi.STEP,displayText:"Step"},{value:Pi.RELATIVE,displayText:"Relative"},{value:Pi.WALL_TIME,displayText:"Wall"}],this.xAxisTypeChanged=new L,this.MAX_CARD_WIDTH_SLIDER_VALUE=735,this.MIN_CARD_WIDTH_SLIDER_VALUE=335,this.cardWidthSliderChanged$=new L,this.cardWidthChanged=this.cardWidthSliderChanged$.pipe(ic(250)),this.cardWidthReset=new L,this.HistogramModeDropdownOptions=[{value:Sr.OFFSET,displayText:"Offset"},{value:Sr.OVERLAY,displayText:"Overlay"}],this.histogramModeChanged=new L,this.MAX_SMOOTHING_VALUE=.999,this.MAX_SMOOTHING_SLIDER_VALUE=.99,this.scalarSmoothingControlChanged$=new L,this.scalarSmoothingChanged=this.scalarSmoothingControlChanged$.pipe(ic(250)),this.scalarPartitionXToggled=new L,this.imageBrightnessSliderChanged$=new L,this.imageBrightnessInMilliChanged=this.imageBrightnessSliderChanged$.pipe(ic(250)),this.imageBrightnessReset=new L,this.imageContrastSliderChanged$=new L,this.imageContrastInMilliChanged=this.imageContrastSliderChanged$.pipe(ic(250)),this.imageContrastReset=new L,this.imageShowActualSizeChanged=new L}onScalarSmoothingInput(e){let i=e.target;if(!i.value)return;let r=Math.min(Math.max(0,parseFloat(i.value)),.999);r!==parseFloat(i.value)&&(i.value=String(r)),this.scalarSmoothingControlChanged$.emit(r)}formatMilliToZeroth(e){return oO(e/1e3,this.locale||"en-US","1.0-2")}getLinkedTimeSelectionStartStep(){return this.isLinkedTimeEnabled||null===this.linkedTimeSelection||null!==this.linkedTimeSelection.end?"":this.linkedTimeSelection.start.step}isAxisTypeStep(){return this.xAxisType===Pi.STEP}}return n.\u0275fac=function(e){return new(e||n)(C(ad))},n.\u0275cmp=k({type:n,selectors:[["metrics-dashboard-settings-component"]],inputs:{isLinkedTimeEnabled:"isLinkedTimeEnabled",isScalarStepSelectorEnabled:"isScalarStepSelectorEnabled",isScalarStepSelectorRangeEnabled:"isScalarStepSelectorRangeEnabled",isScalarColumnCustomizationEnabled:"isScalarColumnCustomizationEnabled",linkedTimeSelection:"linkedTimeSelection",stepMinMax:"stepMinMax",isSlideOutMenuOpen:"isSlideOutMenuOpen",isImageSupportEnabled:"isImageSupportEnabled",tooltipSort:"tooltipSort",ignoreOutliers:"ignoreOutliers",xAxisType:"xAxisType",cardMinWidth:"cardMinWidth",histogramMode:"histogramMode",scalarSmoothing:"scalarSmoothing",scalarPartitionX:"scalarPartitionX",imageBrightnessInMilli:"imageBrightnessInMilli",imageContrastInMilli:"imageContrastInMilli",imageShowActualSize:"imageShowActualSize"},outputs:{linkedTimeToggled:"linkedTimeToggled",stepSelectorToggled:"stepSelectorToggled",rangeSelectionToggled:"rangeSelectionToggled",onSlideOutToggled:"onSlideOutToggled",tooltipSortChanged:"tooltipSortChanged",ignoreOutliersChanged:"ignoreOutliersChanged",xAxisTypeChanged:"xAxisTypeChanged",cardWidthChanged:"cardWidthChanged",cardWidthReset:"cardWidthReset",histogramModeChanged:"histogramModeChanged",scalarSmoothingChanged:"scalarSmoothingChanged",scalarPartitionXToggled:"scalarPartitionXToggled",imageBrightnessInMilliChanged:"imageBrightnessInMilliChanged",imageBrightnessReset:"imageBrightnessReset",imageContrastInMilliChanged:"imageContrastInMilliChanged",imageContrastReset:"imageContrastReset",imageShowActualSizeChanged:"imageShowActualSizeChanged"},decls:54,vars:30,consts:function(){let t,e,i;return t=$localize`:A button to reset the card width setting␟ccdc96b003fbba90db7a6959b5b26e3cc58f7d80␟5223111047968102466:Reset card width`,e=$localize`:A button to reset the image brightness setting␟c482b3a47ea0975fa8be01afb3fbec9b76628bd7␟1189161857240378395:Reset brightness`,i=$localize`:A button to reset the image contrast setting␟ed712a8b927041be15252b29eb521ebb1374bad8␟5370703342923611955:Reset contrast`,[[1,"general"],[1,"section-title"],[1,"control-row","x-axis-type"],["id","x-axis-type-label",1,"control-name"],[3,"value","options","selectionChange"],[1,"control-row","scalars-step-selector",3,"title"],[3,"checked","disabled","change"],[1,"indent"],[1,"indent","range-selection"],[1,"control-row","linked-time","indent"],["mat-button","",3,"ngClass","click",4,"ngIf"],[1,"control-row","card-width"],["id","card-width-label",1,"control-name"],[1,"slider-row"],["aria-labelledby","card-width-label","color","primary",3,"max","min","step","value","thumbLabel","input"],["mat-icon-button","","aria-label",t,"title","Reset card width",1,"reset-button",3,"click"],["svgIcon","settings_backup_restore_24px"],[1,"scalars"],[1,"control-row","scalars-smoothing"],["id","scalars-smoothing-label",1,"control-name"],["aria-labelledby","scalars-smoothing-label","color","primary",3,"max","min","step","value","thumbLabel","input"],["aria-labelledby","scalars-smoothing-label","type","number","min","0","step","0.001",1,"slider-input",3,"max","value","input"],[1,"control-row","tooltip-sort"],[1,"control-name"],[1,"control-row","scalars-ignore-outliers"],[3,"checked","change"],[1,"control-row","scalars-partition-x"],["svgIcon","help_outline_24px","title","Non-monotonic steps can occur when reusing a logdir with multiple summary writers and overlapping steps. Line charts, without this option enabled, can appear zig zagged. This is common when restarting from a checkpoint.\n\nWhen enabled, a non-monotonic time series composed of N monotonic pieces will be shown as N monotonic lines.",1,"info"],[1,"Histograms"],[1,"control-row","histogram-mode"],["class","image",4,"ngIf"],["mat-button","",3,"ngClass","click"],["svgIcon","edit_24px"],[1,"image"],[1,"control-row","image-brightness"],["id","image-brightness-label",1,"control-name"],["aria-labelledby","image-brightness-label","color","primary",3,"max","min","step","value","thumbLabel","displayWith","input"],["mat-icon-button","","aria-label",e,"title","Reset brightness",1,"reset-button",3,"click"],[1,"control-row","image-contrast"],["id","image-constrast-label",1,"control-name"],["aria-labelledby","image-constrast-label","color","primary",3,"max","min","step","value","thumbLabel","displayWith","input"],["mat-icon-button","","aria-label",i,"title","Reset contrast",1,"reset-button",3,"click"],[1,"control-row","image-show-actual-size"]]},template:function(e,i){1&e&&(h(0,"section",0)(1,"h3",1),T(2,"General"),g(),h(3,"div",2)(4,"div",3),T(5,"Horizontal Axis"),g(),h(6,"tb-dropdown",4),D("selectionChange",function(o){return i.xAxisTypeChanged.emit(o)}),g()(),h(7,"div",5)(8,"mat-checkbox",6),D("change",function(){return i.stepSelectorToggled.emit()}),T(9,"Enable step selection and data table "),g(),h(10,"span",7),T(11,"(Scalars only)"),g(),h(12,"div",8)(13,"mat-checkbox",6),D("change",function(){return i.rangeSelectionToggled.emit()}),T(14,"Enable Range Selection "),g()(),h(15,"div",9)(16,"mat-checkbox",6),D("change",function(){return i.linkedTimeToggled.emit()}),T(17),g()(),S(18,kSe,3,3,"button",10),g(),h(19,"div",11)(20,"div",12),T(21,"Card Width"),g(),h(22,"div",13)(23,"mat-slider",14),D("input",function(o){return i.cardWidthSliderChanged$.emit(o.value)}),g(),h(24,"button",15),D("click",function(){return i.cardWidthReset.emit()}),P(25,"mat-icon",16),g()()()(),h(26,"section",17)(27,"h3",1),T(28,"Scalars"),g(),h(29,"div",18)(30,"div",19),T(31,"Smoothing"),g(),h(32,"div",13)(33,"mat-slider",20),D("input",function(o){return i.scalarSmoothingControlChanged$.emit(o.value)}),g(),h(34,"input",21),D("input",function(o){return i.onScalarSmoothingInput(o)}),g()()(),h(35,"div",22)(36,"div",23),T(37,"Tooltip sorting method"),g(),h(38,"tb-dropdown",4),D("selectionChange",function(o){return i.tooltipSortChanged.emit(o)}),g()(),h(39,"div",24)(40,"mat-checkbox",25),D("change",function(o){return i.ignoreOutliersChanged.emit(o.checked)}),T(41,"Ignore outliers in chart scaling"),g()(),h(42,"div",26)(43,"mat-checkbox",25),D("change",function(){return i.scalarPartitionXToggled.emit()}),T(44,"Partition non-monotonic X axis"),g(),P(45,"mat-icon",27),g()(),h(46,"section",28)(47,"h3",1),T(48,"Histograms"),g(),h(49,"div",29)(50,"div",23),T(51,"Mode"),g(),h(52,"tb-dropdown",4),D("selectionChange",function(o){return i.histogramModeChanged.emit(o)}),g()()(),S(53,PSe,20,13,"section",30)),2&e&&(b(6),_("value",i.xAxisType)("options",i.XAxisTypeDropdownOptions),b(1),_("title",i.isAxisTypeStep()?"":"Only available when Horizontal Axis is set to step"),b(1),_("checked",i.isScalarStepSelectorEnabled)("disabled",!i.isAxisTypeStep()),b(5),_("checked",i.isScalarStepSelectorRangeEnabled)("disabled",!i.isAxisTypeStep()),b(3),_("checked",i.isLinkedTimeEnabled)("disabled",!i.isAxisTypeStep()),b(1),ze("Link by step ",i.getLinkedTimeSelectionStartStep()," "),b(1),_("ngIf",i.isScalarColumnCustomizationEnabled),b(5),_("max",i.MAX_CARD_WIDTH_SLIDER_VALUE)("min",i.MIN_CARD_WIDTH_SLIDER_VALUE)("step",50)("value",i.cardMinWidth)("thumbLabel",!1),b(10),_("max",i.MAX_SMOOTHING_SLIDER_VALUE)("min",0)("step",.01)("value",i.scalarSmoothing)("thumbLabel",!0),b(1),_("max",i.MAX_SMOOTHING_VALUE)("value",i.scalarSmoothing),b(4),_("value",i.tooltipSort)("options",i.TooltipSortDropdownOptions),b(2),_("checked",i.ignoreOutliers),b(3),_("checked",i.scalarPartitionX),b(9),_("value",i.histogramMode)("options",i.HistogramModeDropdownOptions),b(1),_("ngIf",i.isImageSupportEnabled))},dependencies:[bn,Fe,IQ,Fn,Hl,Dn,Td],styles:["[_nghost-%COMP%]{color:#616161;font-size:12px}body.dark-mode   [_nghost-%COMP%]{color:rgba(255,255,255,.7)}section[_ngcontent-%COMP%]{border-bottom:1px solid #ebebeb;padding:16px}body.dark-mode[_nghost-%COMP%]   section[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   section[_ngcontent-%COMP%]{border-bottom:1px solid #555}.section-title[_ngcontent-%COMP%]{color:#212121;text-transform:uppercase;font-weight:500;font-size:13px;line-height:normal;margin:0 0 12px 0}body.dark-mode[_nghost-%COMP%]   .section-title[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .section-title[_ngcontent-%COMP%]{color:#fff}section[_ngcontent-%COMP%]   .control-row[_ngcontent-%COMP%]:not(:last-child){margin-bottom:12px}.control-name[_ngcontent-%COMP%]{margin-bottom:8px}.slider-row[_ngcontent-%COMP%]{display:flex;align-items:center;height:28px}.slider-row[_ngcontent-%COMP%]   .reset-button[_ngcontent-%COMP%]{margin-left:6px}.slider-row[_ngcontent-%COMP%]   .slider-input[_ngcontent-%COMP%]{background-color:inherit;border:1px solid #8e98a3;border-radius:2px;box-sizing:border-box;color:inherit;height:100%;margin-left:12px;padding:0 4px}body.dark-mode[_nghost-%COMP%]   .slider-row[_ngcontent-%COMP%]   .slider-input[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .slider-row[_ngcontent-%COMP%]   .slider-input[_ngcontent-%COMP%]{border-color:#425066}.scalars-smoothing[_ngcontent-%COMP%]   .slider-input[_ngcontent-%COMP%]{flex:none;width:5em}.scalars-partition-x[_ngcontent-%COMP%]{align-items:center;display:flex}.scalars-partition-x[_ngcontent-%COMP%]   .info[_ngcontent-%COMP%]{height:15px;margin-left:5px;width:15px;min-width:15px}mat-slider[_ngcontent-%COMP%]{flex:1;margin-left:-8px;margin-right:-8px}.column-edit-menu-toggle[_ngcontent-%COMP%]{align-items:center;display:flex;cursor:pointer;font-size:inherit;height:28px;padding-left:5px;padding-right:12px}.column-edit-menu-toggle.mat-button-wrapper[_ngcontent-%COMP%]{display:inline-flex;align-items:center}.column-edit-menu-toggle.toggle-opened[_ngcontent-%COMP%]{background-color:#eee}body.dark-mode[_nghost-%COMP%]   .column-edit-menu-toggle.toggle-opened[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .column-edit-menu-toggle.toggle-opened[_ngcontent-%COMP%]{background-color:#424242}.column-edit-menu-toggle[_ngcontent-%COMP%]   mat-icon[_ngcontent-%COMP%]{width:15px;margin-right:6px}tb-dropdown[_ngcontent-%COMP%]{display:block}.linked-time[_ngcontent-%COMP%]{padding:5px 0}.control-row[_ngcontent-%COMP%]   .indent[_ngcontent-%COMP%]{margin-left:25px}"],changeDetection:0}),n})(),kQ=(()=>{class n{constructor(e){this.store=e,this.isScalarStepSelectorEnabled$=this.store.select(Eb),this.isScalarStepSelectorRangeEnabled$=this.store.select(Iu),this.isLinkedTimeEnabled$=this.store.select(Du),this.isScalarColumnCustomizationEnabled$=this.store.select(fS),this.linkedTimeSelection$=this.store.select(JF),this.stepMinMax$=this.store.select(KF),this.isSlideOutMenuOpen$=this.store.select(m1),this.isImageSupportEnabled$=this.store.select(Cu).pipe(Ve(Boolean),zt(1),Yt(this.store.select(pS)),U(([,i])=>i)),this.tooltipSort$=this.store.select(Mf),this.ignoreOutliers$=this.store.select(wf),this.xAxisType$=this.store.select(Dl),this.cardMinWidth$=this.store.select(rg),this.histogramMode$=this.store.select(s1),this.scalarSmoothing$=this.store.select(gd),this.scalarPartitionX$=this.store.select(l1),this.imageBrightnessInMilli$=this.store.select(c1),this.imageContrastInMilli$=this.store.select(d1),this.imageShowActualSize$=this.store.select(u1)}onTooltipSortChanged(e){this.store.dispatch(bT({sort:e}))}onIgnoreOutliersChanged(){this.store.dispatch(vT())}onXAxisTypeChanged(e){this.store.dispatch(xT({xAxisType:e}))}onCardWidthChanged(e){this.store.dispatch(CT({cardMinWidth:e}))}onCardWidthReset(){this.store.dispatch(MT())}onHistogramModeChanged(e){this.store.dispatch(RT({histogramMode:e}))}onScalarSmoothingChanged(e){this.store.dispatch(wT({smoothing:e}))}onScalarPartitionXToggled(){this.store.dispatch(ST())}onImageBrightnessInMilliChanged(e){this.store.dispatch(ET({brightnessInMilli:e}))}onImageBrightnessReset(){this.store.dispatch(DT())}onImageContrastReset(){this.store.dispatch(IT())}onImageContrastInMilliChanged(e){this.store.dispatch(TT({contrastInMilli:e}))}onImageShowActualSizeChanged(){this.store.dispatch(AT())}onLinkedTimeToggled(){this.store.dispatch(HT({affordance:Ga.CHECK_BOX}))}onStepSelectorToggled(){this.store.dispatch(Dd({affordance:Ga.CHECK_BOX}))}onRangeSelectionToggled(){this.store.dispatch(zT({affordance:Ga.CHECK_BOX}))}onSlideOutToggled(){this.store.dispatch(uT())}}return n.\u0275fac=function(e){return new(e||n)(C(ke))},n.\u0275cmp=k({type:n,selectors:[["metrics-dashboard-settings"]],decls:19,vars:54,consts:[[3,"isImageSupportEnabled","tooltipSort","ignoreOutliers","xAxisType","cardMinWidth","histogramMode","scalarSmoothing","scalarPartitionX","imageBrightnessInMilli","imageContrastInMilli","imageShowActualSize","isScalarStepSelectorEnabled","isScalarStepSelectorRangeEnabled","isLinkedTimeEnabled","isScalarColumnCustomizationEnabled","linkedTimeSelection","stepMinMax","isSlideOutMenuOpen","tooltipSortChanged","ignoreOutliersChanged","xAxisTypeChanged","cardWidthChanged","cardWidthReset","histogramModeChanged","scalarSmoothingChanged","scalarPartitionXToggled","imageBrightnessInMilliChanged","imageBrightnessReset","imageContrastInMilliChanged","imageContrastReset","imageShowActualSizeChanged","linkedTimeToggled","stepSelectorToggled","rangeSelectionToggled","onSlideOutToggled"]],template:function(e,i){1&e&&(h(0,"metrics-dashboard-settings-component",0),D("tooltipSortChanged",function(o){return i.onTooltipSortChanged(o)})("ignoreOutliersChanged",function(){return i.onIgnoreOutliersChanged()})("xAxisTypeChanged",function(o){return i.onXAxisTypeChanged(o)})("cardWidthChanged",function(o){return i.onCardWidthChanged(o)})("cardWidthReset",function(){return i.onCardWidthReset()})("histogramModeChanged",function(o){return i.onHistogramModeChanged(o)})("scalarSmoothingChanged",function(o){return i.onScalarSmoothingChanged(o)})("scalarPartitionXToggled",function(){return i.onScalarPartitionXToggled()})("imageBrightnessInMilliChanged",function(o){return i.onImageBrightnessInMilliChanged(o)})("imageBrightnessReset",function(){return i.onImageBrightnessReset()})("imageContrastInMilliChanged",function(o){return i.onImageContrastInMilliChanged(o)})("imageContrastReset",function(){return i.onImageContrastReset()})("imageShowActualSizeChanged",function(){return i.onImageShowActualSizeChanged()})("linkedTimeToggled",function(){return i.onLinkedTimeToggled()})("stepSelectorToggled",function(){return i.onStepSelectorToggled()})("rangeSelectionToggled",function(){return i.onRangeSelectionToggled()})("onSlideOutToggled",function(){return i.onSlideOutToggled()}),G(1,"async"),G(2,"async"),G(3,"async"),G(4,"async"),G(5,"async"),G(6,"async"),G(7,"async"),G(8,"async"),G(9,"async"),G(10,"async"),G(11,"async"),G(12,"async"),G(13,"async"),G(14,"async"),G(15,"async"),G(16,"async"),G(17,"async"),G(18,"async"),g()),2&e&&_("isImageSupportEnabled",W(1,18,i.isImageSupportEnabled$))("tooltipSort",W(2,20,i.tooltipSort$))("ignoreOutliers",W(3,22,i.ignoreOutliers$))("xAxisType",W(4,24,i.xAxisType$))("cardMinWidth",W(5,26,i.cardMinWidth$))("histogramMode",W(6,28,i.histogramMode$))("scalarSmoothing",W(7,30,i.scalarSmoothing$))("scalarPartitionX",W(8,32,i.scalarPartitionX$))("imageBrightnessInMilli",W(9,34,i.imageBrightnessInMilli$))("imageContrastInMilli",W(10,36,i.imageContrastInMilli$))("imageShowActualSize",W(11,38,i.imageShowActualSize$))("isScalarStepSelectorEnabled",W(12,40,i.isScalarStepSelectorEnabled$))("isScalarStepSelectorRangeEnabled",W(13,42,i.isScalarStepSelectorRangeEnabled$))("isLinkedTimeEnabled",W(14,44,i.isLinkedTimeEnabled$))("isScalarColumnCustomizationEnabled",W(15,46,i.isScalarColumnCustomizationEnabled$))("linkedTimeSelection",W(16,48,i.linkedTimeSelection$))("stepMinMax",W(17,50,i.stepMinMax$))("isSlideOutMenuOpen",W(18,52,i.isSlideOutMenuOpen$))},dependencies:[RQ,lt],encapsulation:2,changeDetection:0}),n})(),PQ=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["metrics-dashboard-right-pane"]],decls:1,vars:0,template:function(e,i){1&e&&P(0,"metrics-dashboard-settings")},dependencies:[kQ],encapsulation:2,changeDetection:0}),n})();function HSe(n,t){1&n&&P(0,"mat-icon",4)}function zSe(n,t){1&n&&P(0,"mat-icon",4)}function USe(n,t){1&n&&P(0,"mat-icon",4)}function jSe(n,t){1&n&&P(0,"div",5)}var qT=(()=>{class n{constructor(){this.ColumnHeaderType=vt}getSpecialTypeClasses(e){switch(e){case vt.STEP_AT_MIN:return"step-at-min";case vt.STEP_AT_MAX:return"step-at-max";default:return""}}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["tb-data-table-header"]],inputs:{header:"header"},decls:7,vars:6,consts:[[1,"header-container",3,"ngSwitch"],["svgIcon","change_history_24px",4,"ngSwitchCase"],["class","extra-right-padding",4,"ngSwitchDefault"],[3,"ngClass"],["svgIcon","change_history_24px"],[1,"extra-right-padding"]],template:function(e,i){1&e&&(h(0,"div",0),S(1,HSe,1,0,"mat-icon",1),S(2,zSe,1,0,"mat-icon",1),S(3,USe,1,0,"mat-icon",1),S(4,jSe,1,0,"div",2),h(5,"span",3),T(6),g()()),2&e&&(_("ngSwitch",i.header.type),b(1),_("ngSwitchCase",i.ColumnHeaderType.VALUE_CHANGE),b(1),_("ngSwitchCase",i.ColumnHeaderType.PERCENTAGE_CHANGE),b(1),_("ngSwitchCase",i.ColumnHeaderType.RAW_CHANGE),b(2),_("ngClass",i.getSpecialTypeClasses(i.header.type)),b(1),ut(i.header.displayName))},dependencies:[bn,$i,sr,fu,Dn],styles:[".header-container[_ngcontent-%COMP%]{align-items:center;display:flex}.extra-right-padding[_ngcontent-%COMP%]{padding-right:1px}mat-icon[_ngcontent-%COMP%]{height:12px;width:12px;min-width:12px;line-height:12px}.step-at-min[_ngcontent-%COMP%]{min-width:37px}.step-at-max[_ngcontent-%COMP%]{min-width:40px}"],changeDetection:0}),n})();function GSe(n,t){if(1&n){let e=ge();h(0,"div",9),D("dragstart",function(){let o=X(e).$implicit;return Q(w(2).dragStart(o))})("dragend",function(){X(e);let r=w().dataTableMode;return Q(w().dragEnd(r))})("dragenter",function(){let o=X(e).$implicit,a=w().dataTableMode;return Q(w().dragEnter(o,a))}),h(1,"mat-checkbox",10),D("change",function(){let o=X(e).$implicit,a=w().dataTableMode;return Q(w().toggleHeader(o,a))}),P(2,"tb-data-table-header",11),g()()}if(2&n){let e=t.$implicit;_("ngClass",w(2).getHighlightClasses(e)),b(1),_("checked",e.enabled),b(1),_("header",e)}}function WSe(n,t){if(1&n&&(h(0,"div",7),S(1,GSe,3,3,"div",8),g()),2&n){let e=t.headers;b(1),_("ngForOf",e)}}var FQ=function(n,t){return{headers:n,dataTableMode:t}},$L=n=>{n.preventDefault()},qSe=(n,t,e)=>{let i=[...e];return i.splice(n,1),i.splice(t,0,e[n]),i},YT=(n,t)=>t.findIndex(e=>e.name===n.name),$u=(()=>(function(n){n[n.TOP=0]="TOP",n[n.BOTTOM=1]="BOTTOM"}($u||($u={})),$u))(),LQ=(()=>{class n{constructor(e){this.hostElement=e,this.DataTableMode=lo,this.highlightEdge=$u.TOP,this.onScalarTableColumnEdit=new L,this.onScalarTableColumnToggled=new L,this.onScalarTableColumnEditorClosed=new L,this.onTabChange=new L}ngOnDestroy(){this.hostElement.nativeElement.removeEventListener("dragover",$L)}tabChange(e){this.onTabChange.emit(0===e.index?lo.SINGLE:lo.RANGE)}dragStart(e){this.draggingHeader=e,this.hostElement.nativeElement.addEventListener("dragover",$L)}dragEnd(e){if(!this.draggingHeader||!this.highlightedHeader)return;let i=this.getHeadersForMode(e);this.onScalarTableColumnEdit.emit({dataTableMode:e,headers:qSe(YT(this.draggingHeader,i),YT(this.highlightedHeader,i),i)}),this.draggingHeader=void 0,this.highlightedHeader=void 0,this.hostElement.nativeElement.removeEventListener("dragover",$L)}dragEnter(e,i){if(!this.draggingHeader)return;let r=this.getHeadersForMode(i);this.highlightEdge=YT(e,r)<YT(this.draggingHeader,r)?$u.TOP:$u.BOTTOM,this.highlightedHeader=e}toggleHeader(e,i){this.onScalarTableColumnToggled.emit({dataTableMode:i,header:e})}getHighlightClasses(e){return e.name!==this.highlightedHeader?.name?{}:{highlighted:!0,"highlight-top":this.highlightEdge===$u.TOP,"highlight-bottom":this.highlightEdge===$u.BOTTOM}}getSelectedTabIndex(){return this.selectedTab===lo.SINGLE?0:1}getHeadersForMode(e){return e===lo.SINGLE?this.singleHeaders:this.rangeHeaders}}return n.\u0275fac=function(e){return new(e||n)(C(be))},n.\u0275cmp=k({type:n,selectors:[["metrics-scalar-column-editor-component"]],inputs:{rangeHeaders:"rangeHeaders",singleHeaders:"singleHeaders",selectedTab:"selectedTab"},outputs:{onScalarTableColumnEdit:"onScalarTableColumnEdit",onScalarTableColumnToggled:"onScalarTableColumnToggled",onScalarTableColumnEditorClosed:"onScalarTableColumnEditorClosed",onTabChange:"onTabChange"},decls:11,vars:13,consts:function(){let t;return t=$localize`:Label on a button to close the column editor.␟cb616ce9b4327b41e6bdb9344669ba7c72e2c70e␟7205635764713034842:Close column editor`,[[1,"editor-controls"],[1,"tab-group",3,"selectedIndex","selectedTabChange"],[3,"label"],[3,"ngTemplateOutlet","ngTemplateOutletContext"],[1,"footer"],["mat-button","","aria-label",t,1,"close-button",3,"click"],["headerList",""],[1,"header-list"],["class","header-list-item","draggable","true",3,"ngClass","dragstart","dragend","dragenter",4,"ngFor","ngForOf"],["draggable","true",1,"header-list-item",3,"ngClass","dragstart","dragend","dragenter"],[3,"checked","change"],[3,"header"]]},template:function(e,i){if(1&e&&(h(0,"div",0)(1,"mat-tab-group",1),D("selectedTabChange",function(o){return i.tabChange(o)}),h(2,"mat-tab",2),P(3,"ngContext",3),g(),h(4,"mat-tab",2),P(5,"ngContext",3),g()()(),h(6,"div",4)(7,"button",5),D("click",function(){return i.onScalarTableColumnEditorClosed.emit()}),T(8," Close "),g()(),S(9,WSe,2,1,"ng-template",null,6,Zt)),2&e){let r=tt(10);b(1),_("selectedIndex",i.getSelectedTabIndex()),b(1),_("label","Single"),b(1),_("ngTemplateOutlet",r)("ngTemplateOutletContext",Pr(7,FQ,i.singleHeaders,i.DataTableMode.SINGLE)),b(1),_("label","Range"),b(1),_("ngTemplateOutlet",r)("ngTemplateOutletContext",Pr(10,FQ,i.rangeHeaders,i.DataTableMode.RANGE))}},dependencies:[bn,dn,Mo,qT,Hl,ME,uv,Fn],styles:["[_nghost-%COMP%]     .mat-tab-label{min-width:0;padding:0 30px}.editor-controls[_ngcontent-%COMP%]{height:calc(100% - 45px)}.tab-group[_ngcontent-%COMP%]{position:relative;z-index:0;height:100%}.header-list[_ngcontent-%COMP%]{margin-top:5%;margin-left:5%}.header-list-item[_ngcontent-%COMP%]{padding:3px}.highlighted[_ngcontent-%COMP%]{background-color:#eee}.highlight-bottom[_ngcontent-%COMP%]{border-bottom:2px solid #ff9800}.highlight-top[_ngcontent-%COMP%]{border-top:2px solid #ff9800}.footer[_ngcontent-%COMP%]{display:flex;position:absolute;left:0;bottom:0;box-sizing:border-box;width:100%;align-items:center;justify-content:flex-end;padding:4px;border-top:1px solid #ebebeb}body.dark-mode[_nghost-%COMP%]   .footer[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .footer[_ngcontent-%COMP%]{border-color:#555}.close-button[_ngcontent-%COMP%]{color:#616161;width:84px}body.dark-mode[_nghost-%COMP%]   .close-button[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .close-button[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}  .mat-tab-body-wrapper{flex:1}"],changeDetection:0}),n})(),NQ=(()=>{class n{constructor(e){this.store=e,this.singleHeaders$=this.store.select(Tb),this.rangeHeaders$=this.store.select(Db),this.selectedTab$=this.store.select(QW)}onScalarTableColumnToggled(e){this.store.dispatch(t0(e))}onScalarTableColumnEdit(e){this.store.dispatch(e0(e))}onScalarTableColumnEditorClosed(){this.store.dispatch(mT())}onTabChange(e){this.store.dispatch(fT({tab:e}))}}return n.\u0275fac=function(e){return new(e||n)(C(ke))},n.\u0275cmp=k({type:n,selectors:[["metrics-scalar-column-editor"]],decls:4,vars:9,consts:[[3,"singleHeaders","rangeHeaders","selectedTab","onScalarTableColumnToggled","onScalarTableColumnEdit","onScalarTableColumnEditorClosed","onTabChange"]],template:function(e,i){1&e&&(h(0,"metrics-scalar-column-editor-component",0),D("onScalarTableColumnToggled",function(o){return i.onScalarTableColumnToggled(o)})("onScalarTableColumnEdit",function(o){return i.onScalarTableColumnEdit(o)})("onScalarTableColumnEditorClosed",function(){return i.onScalarTableColumnEditorClosed()})("onTabChange",function(o){return i.onTabChange(o)}),G(1,"async"),G(2,"async"),G(3,"async"),g()),2&e&&_("singleHeaders",W(1,3,i.singleHeaders$))("rangeHeaders",W(2,5,i.rangeHeaders$))("selectedTab",W(3,7,i.selectedTab$))},dependencies:[LQ,lt],encapsulation:2,changeDetection:0}),n})(),ep={};zA(ep,{getExperimentsHparamsAndMetricsSpecs:()=>nN,getHparamFilterMap:()=>KSe,getHparamFilterMapFromExperimentIds:()=>eN,getMetricFilterMap:()=>e1e,getMetricFilterMapFromExperimentIds:()=>tN});var Id=Mr(HS);function VQ(n,t){let e=[];for(let i of t)!n.specs[i]||e.push(n.specs[i].hparam.defaultFilters);return vb(e)}var QSe=q(Id,VQ);function HQ(n,t,e){let i=vf(e);return new Map([...t,...n.filters[i]?.hparams??[]])}var KSe=q(Id,QSe,HQ);function eN(n,t){return q(Id,function(n){return q(Id,t=>VQ(t,n))}(n),(e,i)=>HQ(e,t?i:new Map,n))}function zQ(n,t){let e=[];for(let i of t)!n.specs[i]||e.push(n.specs[i].metric.defaultFilters);return VS(e)}var JSe=q(Id,zQ);function UQ(n,t,e){let i=vf(e);return new Map([...t,...n.filters[i]?.metrics??[]])}var e1e=q(Id,JSe,UQ);function tN(n,t){return q(Id,function(n){return q(Id,t=>zQ(t,n))}(n),(e,i)=>UQ(e,t?i:new Map,n))}var nN=q(Id,(n,t)=>function(...n){let t=new Map,e=new Map,i=new Map,r=new Map,o=[];for(let a of n){for(let s of a.hparams)if(e.has(s.name)||e.set(s.name,new Set),e.get(s.name).add(s.displayName),t.has(s.name)){let l=t.get(s.name),c=s;if(l.type!==c.type&&o.push(`Hparam, ${c.name}, types have to match. Got: ${l.type} vs. ${c.type}`),l.domain.type===Un.INTERVAL&&c.domain.type===Un.INTERVAL)(l.domain.minValue!==c.domain.minValue||l.domain.maxValue!==c.domain.maxValue)&&o.push(`Hparam, ${c.name}, domains have to match. Got: ${l.domain} vs. ${c.domain}`);else if(l.domain.type===Un.DISCRETE&&c.domain.type===Un.DISCRETE){let d=new Set([...l.domain.values,...c.domain.values]);(l.domain.values.length!==c.domain.values.length||l.domain.values.length!==d.size)&&o.push(`Hparam, ${c.name}, domains have to match. Got: ${l.domain} vs. ${c.domain}`)}else o.push(`Hparam, ${c.name}, domains have to match. Got: ${l.domain} vs. ${c.domain}`)}else t.set(s.name,{...s});for(let s of a.metrics)if(r.has(s.tag)||r.set(s.tag,new Set),r.get(s.tag).add(s.displayName),i.has(s.tag)){let l=i.get(s.tag);l.datasetType!==s.datasetType&&o.push(`Metric, ${s.tag}, datasetTypes have to match. Got: ${l.datasetType} vs. ${s.datasetType}`)}else i.set(s.tag,{...s})}if(o.length)throw new Error(`Validation error:\n${o.join("\n")}`);return{hparams:[...t].map(([a,s])=>({...s,displayName:[...e.get(a)].join(" or ")})),metrics:[...i].map(([a,s])=>({...s,displayName:[...r.get(a)].join(" or ")}))}}(...t.experimentIds.map(e=>{let i=n.specs[e];return i?{hparams:i.hparam.specs,metrics:i.metric.specs}:null}).filter(Boolean))),r0=(()=>(function(n){n[n.ORIGINAL=0]="ORIGINAL",n[n.DERIVED=1]="DERIVED"}(r0||(r0={})),r0))(),t1e=q(zW,Ru,(n,t)=>new Set(Object.entries(n.scalars.tagToRuns).filter(([,e])=>!t||!t.size||e.some(i=>t?.get(i))).map(([e])=>e))),n1e=q(a1,Ru,XW,t1e,(n,t,e,i)=>{let r=Array.from(t?.values()||[]).some(Boolean);return n.filter(o=>cs(o.plugin)?Boolean(t&&t.get(o.runId)):!e||!r||o.plugin!==qn.SCALARS||i.has(o.tag))}),Qf=q(n1e,n=>n.sort((t,e)=>Sv(t.tag,e.tag))),XT={filterRunItemsByRegex:(n,t,e)=>t?n.filter(i=>og({runName:i.run.name,experimentAlias:i.experimentAlias},t,e)):n,matchFilter:(n,t)=>void 0===t?n.includeUndefined:n.type===Un.DISCRETE?n.filterValues.includes(t):n.type===Un.INTERVAL&&"number"==typeof t&&n.filterLowerValue<=t&&t<=n.filterUpperValue,filterRunItemsByHparamAndMetricFilter:(n,t,e)=>n.filter(({hparams:i,metrics:r})=>{let o=[...t.entries()].every(([s,l])=>{let c=i.get(s);return XT.matchFilter(l,c)}),a=[...e.entries()].every(([s,l])=>{let c=r.get(s);return XT.matchFilter(l,c)});return o&&a})},i1e=Cf(n=>q((n=>q(Na,t=>n.reduce((e,i)=>((t.runIds[i]||[]).filter(r=>Boolean(t.runMetadata[r])).forEach(r=>{e.push({...t.runMetadata[r],experimentId:i})}),e),[])))(n),(n=>q(mW,t=>n.map(e=>t.experimentMap[e]).filter(Boolean).reduce((e,i)=>(e[i.id]=i.name,e),{})))(n),Ru,ku,Bs,(t,e,i,r,o)=>t.map(a=>{let s=new Map;(a.hparams||[]).forEach(c=>{s.set(c.name,c.value)});let l=new Map;return(a.metrics||[]).forEach(c=>{l.set(c.tag,c.value)}),{run:a,experimentName:e[a.experimentId]||"",experimentAlias:o[a.experimentId],selected:Boolean(i&&i.get(a.id)),runColor:r[a.id],hparams:s,metrics:l}}))),r1e=Cf(n=>q(_d,i1e(n),eN(n),tN(n),Ns,(t,e,i,r,o)=>{let a=XT.filterRunItemsByRegex(e,t,o===kn.COMPARE_EXPERIMENT);return XT.filterRunItemsByHparamAndMetricFilter(a,i,r)})),iN=q(n=>n,ro,(n,t)=>r1e(t||[])(n)),jQ=q(iN,n=>new Set(n.map(({run:{id:t}})=>t))),rN=q(n=>n,ro,(n,t)=>{if(!t)return[];let{hparams:e}=nN(n,{experimentIds:t});return e.map(i=>({type:vt.HPARAM,name:i.name,displayName:i.displayName||i.name,enabled:!1,removable:!0,sortable:!0,movable:!0}))}),o0=(Cf(n=>q(g1(n),rN,(t,e)=>[...t,...e])),(()=>{class n{constructor(e,i){this.ref=e,this.cdkScrollable=i,this.onVisibilityChange=new L,this.ngUnsubscribe$=new Ae,this.onEvent$=new Ae}ngOnInit(){let e={root:this.cdkScrollable?this.cdkScrollable.getElementRef().nativeElement:null};this.intersectionObserverMargin&&(e.rootMargin=this.intersectionObserverMargin);let i=new IntersectionObserver(r=>{this.onEvent$.next(r)},e);i.observe(this.ref.nativeElement),this.ngUnsubscribe$.subscribe(()=>{i.unobserve(this.ref.nativeElement)}),this.onEvent$.pipe(ot(this.ngUnsubscribe$)).subscribe(r=>{let o=r.slice(-1)[0];this.onVisibilityChange.emit({visible:o.isIntersecting})})}ngOnDestroy(){this.ngUnsubscribe$.next(),this.ngUnsubscribe$.complete()}waitForEventForTestOnly(){return new Promise(e=>this.onEvent$.pipe(zt(1)).subscribe(()=>{e()}))}}return n.\u0275fac=function(e){return new(e||n)(C(be),C(Bu,8))},n.\u0275dir=xe({type:n,selectors:[["","observeIntersection",""]],inputs:{intersectionObserverMargin:"intersectionObserverMargin"},outputs:{onVisibilityChange:"onVisibilityChange"}}),n})()),GQ="/scalar_summary";function a0(n,t){let e=n;return t&&n.startsWith(t+"/")&&(e=n.slice(t.length+1)),e.endsWith(GQ)&&(e=e.slice(0,-GQ.length)),e||n}var QT=(()=>{class n{constructor(e,i){this.store=e,this.changeDetectorRef=i,this.hrefAttr=void 0,this.srcAttr=void 0,this.includeFeatureFlags=!0}getUrlWithFeatureFlags(e){return this.store.select(Wh).pipe(U(i=>{if(Object.keys(i).length>0){let r=new URLSearchParams([["tensorBoardFeatureFlags",JSON.stringify(i)]]),o=e.includes("?")?"&":"?";return e+o+String(r)}return e}))}set href(e){e&&OC(this.getUrlWithFeatureFlags(e)).then(i=>{this.hrefAttr=i,this.changeDetectorRef.detectChanges()})}set src(e){e&&OC(this.getUrlWithFeatureFlags(e)).then(i=>{this.srcAttr=i,this.changeDetectorRef.detectChanges()})}}return n.\u0275fac=function(e){return new(e||n)(C(ke),C(Ft))},n.\u0275dir=xe({type:n,selectors:[["a","includeFeatureFlags",""],["img","includeFeatureFlags",""]],hostVars:2,hostBindings:function(e,i){2&e&&Pe("href",i.hrefAttr,As)("src",i.srcAttr,As)},inputs:{includeFeatureFlags:"includeFeatureFlags",href:"href",src:"src"}}),n})(),o1e=["measurer"],a1e=["input"],qQ=(()=>{class n{constructor(e){this.changeDetector=e,this.placeholder="",this.style="default",this.patternRegex=new RegExp(".*"),this.isValid=!0,this.onValueChange=new L,this.blur=new L,this.focus=new L,this.keydown=new L,this.keyup=new L,this.internalValue="",this.fontChangeListener=this.updateInputWidth.bind(this)}ngOnInit(){document.fonts&&document.fonts.addEventListener("loadingdone",this.fontChangeListener)}ngOnDestroy(){document.fonts&&document.fonts.removeEventListener("loadingdone",this.fontChangeListener)}ngOnChanges(e){e.pattern&&(this.patternRegex=new RegExp(this.pattern??"")),e.value&&(this.internalValue=this.value),this.isValid=this.patternRegex.test(this.internalValue)}ngAfterViewChecked(){this.updateInputWidth()}onInput(e){let i=this.internalValue;this.internalValue=this.inputElRef.nativeElement.value,this.internalValue!==i&&(this.isValid=this.patternRegex.test(this.internalValue),this.changeDetector.markForCheck()),this.onValueChange.emit({value:this.internalValue})}updateInputWidth(){let{width:e}=this.measurerElRef.nativeElement.getBoundingClientRect();this.inputElRef.nativeElement.style.width=`${e}px`}}return n.\u0275fac=function(e){return new(e||n)(C(Ft))},n.\u0275cmp=k({type:n,selectors:[["content-wrapping-input"]],viewQuery:function(e,i){if(1&e&&(Ye(o1e,7,be),Ye(a1e,7,be)),2&e){let r;we(r=Se())&&(i.measurerElRef=r.first),we(r=Se())&&(i.inputElRef=r.first)}},hostVars:2,hostBindings:function(e,i){2&e&&ka(i.style)},inputs:{value:"value",placeholder:"placeholder",style:"style",pattern:"pattern"},outputs:{onValueChange:"onValueChange",blur:"blur",focus:"focus",keydown:"keydown",keyup:"keyup"},features:[Gt],decls:6,vars:7,consts:[["aria-hidden","true",1,"measurer"],["measurer",""],["autocomplete","off","spellcheck","false","type","text",3,"value","placeholder","blur","focus","input","keydown","keyup"],["input",""]],template:function(e,i){1&e&&(h(0,"span")(1,"span",0,1),T(3),g(),h(4,"input",2,3),D("blur",function(o){return i.blur.emit(o)})("focus",function(o){return i.focus.emit(o)})("input",function(o){return i.onInput(o)})("keydown",function(o){return i.keydown.emit(o)})("keyup",function(o){return i.keyup.emit(o)}),g()()),2&e&&(Qe("container",!0)("is-valid",i.isValid),b(3),ut(i.internalValue||i.placeholder),b(1),_("value",i.value)("placeholder",i.placeholder))},styles:["[_nghost-%COMP%]{display:inline-flex;width:max-content}[_nghost-%COMP%]:focus-within   .container[_ngcontent-%COMP%]{border-color:#f57c00}.default[_nghost-%COMP%]:hover   .container[_ngcontent-%COMP%]{border-color:#ebebeb}.error[_nghost-%COMP%]   .container[_ngcontent-%COMP%], [_nghost-%COMP%]   .container[_ngcontent-%COMP%]:not(.is-valid){border-color:#ef9a9a}.error[_nghost-%COMP%]   .container[_ngcontent-%COMP%]:hover, .error[_nghost-%COMP%]   .container[_ngcontent-%COMP%]:focus-within, [_nghost-%COMP%]   .container[_ngcontent-%COMP%]:not(.is-valid):hover, [_nghost-%COMP%]   .container[_ngcontent-%COMP%]:not(.is-valid):focus-within{border-color:#ef9a9a}.high-contrast[_nghost-%COMP%]   .container[_ngcontent-%COMP%]{border-color:#bdbdbd}.high-contrast[_nghost-%COMP%]   .container[_ngcontent-%COMP%]:hover{border-color:#757575}.container[_ngcontent-%COMP%]{border-radius:4px;border:2px solid rgba(0,0,0,0);padding:1px 2px;position:relative}.measurer[_ngcontent-%COMP%]{pointer-events:none;position:absolute;visibility:hidden}.measurer[_ngcontent-%COMP%], input[_ngcontent-%COMP%]{font-family:inherit;font-size:inherit;line-height:1.4;padding:0;white-space:pre}.measurer[_ngcontent-%COMP%]:empty, input[_ngcontent-%COMP%]:empty{width:2ch}input[_ngcontent-%COMP%]{appearance:none;background-color:inherit;border:0;color:inherit;display:inline-block;font-family:inherit;outline:0}input[_ngcontent-%COMP%]:focus{padding-right:1ch}"],changeDetection:0}),n})();function l1e(n,t){if(1&n){let e=ge();h(0,"content-wrapping-input",3),D("onValueChange",function(r){return X(e),Q(w().aliasChanged.emit(r))}),g()}if(2&n){let e=w();Rs(e.isAliasNameLegal?"high-contrast":"error"),_("value",e.alias.aliasText)}}function c1e(n,t){if(1&n&&(h(0,"span",4),T(1),g()),2&n){let e=w();Qe("illegal",!e.isAliasNameLegal),_("title",e.title),b(1),ut(e.alias.aliasText)}}var tp=(()=>{class n{constructor(){this.isAliasNameLegal=!0,this.aliasChanged=new L}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["tb-experiment-alias"]],inputs:{alias:"alias",aliasEditable:"aliasEditable",title:"title",isAliasNameLegal:"isAliasNameLegal"},outputs:{aliasChanged:"aliasChanged"},decls:5,vars:3,consts:[[1,"alias-number"],["placeholder","Alias for experiment",3,"style","value","onValueChange",4,"ngIf","ngIfElse"],["noEditAliasName",""],["placeholder","Alias for experiment",3,"value","onValueChange"],[3,"title"]],template:function(e,i){if(1&e&&(h(0,"span",0),T(1),g(),S(2,l1e,1,3,"content-wrapping-input",1),S(3,c1e,2,4,"ng-template",null,2,Zt)),2&e){let r=tt(4);b(1),ut(i.alias.aliasNumber),b(1),_("ngIf",i.aliasEditable)("ngIfElse",r)}},dependencies:[Fe,qQ],styles:[".alias-number[_ngcontent-%COMP%]{background-color:#e0e0e0;border:1px solid #ebebeb;color:#212121;border-radius:2px;margin-right:2px;padding:0 2px}body.dark-mode[_nghost-%COMP%]   .alias-number[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .alias-number[_ngcontent-%COMP%]{background-color:#616161}body.dark-mode[_nghost-%COMP%]   .alias-number[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .alias-number[_ngcontent-%COMP%]{border:1px solid #555}body.dark-mode[_nghost-%COMP%]   .alias-number[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .alias-number[_ngcontent-%COMP%]{color:#fff}[_nghost-%COMP%]{display:inline-flex;align-items:baseline}"]}),n})();function d1e(n,t){1&n&&P(0,"tb-experiment-alias",2),2&n&&_("alias",w().experimentAlias)}function u1e(n,t){1&n&&(h(0,"span"),T(1,"/"),g())}var YQ=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["card-run-name-component"]],inputs:{name:"name",experimentAlias:"experimentAlias"},decls:4,vars:3,consts:[[3,"alias",4,"ngIf"],[4,"ngIf"],[3,"alias"]],template:function(e,i){1&e&&(S(0,d1e,1,1,"tb-experiment-alias",0),S(1,u1e,2,0,"span",1),h(2,"span"),T(3),g()),2&e&&(_("ngIf",null!=i.experimentAlias),b(1),_("ngIf",null!=i.experimentAlias),b(2),ut(i.name))},dependencies:[Fe,tp],styles:["[_nghost-%COMP%]{color:#616161}body.dark-mode   [_nghost-%COMP%]{color:rgba(255,255,255,.7)}"],changeDetection:0}),n})(),KT=(()=>{class n{constructor(e){this.store=e}ngOnInit(){this.name$=un([this.store.select(v1,{runId:this.runId})]).pipe(U(([e])=>function(n,t,e){if(!t)return n;let i=t?.name??"...";return i}(this.runId,e))),this.experimentAlias$=un([this.store.select(b1,{runId:this.runId}),this.store.select(Bs)]).pipe(U(([e,i])=>e?i[e]:null))}}return n.\u0275fac=function(e){return new(e||n)(C(ke))},n.\u0275cmp=k({type:n,selectors:[["card-run-name"]],inputs:{runId:"runId"},decls:4,vars:9,consts:[[3,"name","experimentAlias"]],template:function(e,i){1&e&&(P(0,"card-run-name-component",0),G(1,"async"),G(2,"async"),G(3,"async")),2&e&&(_("name",W(1,3,i.name$))("experimentAlias",W(3,7,i.experimentAlias$)),Pe("title",W(2,5,i.name$)))},dependencies:[YQ,lt],encapsulation:2,changeDetection:0}),n})();function f1e(n,t){if(1&n&&(h(0,"span",2),T(1),g()),2&n){let e=w();b(1),ut(e.firstTextPart())}}var s0=(()=>{class n{parseValue(){let e=this.value.lastIndexOf("/");return-1===e?{first:"",second:this.value}:{first:this.value.slice(0,e),second:this.value.slice(e)}}firstTextPart(){return this.parseValue().first}secondTextPart(){return this.parseValue().second}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["tb-truncated-path"]],inputs:{value:"value"},decls:3,vars:2,consts:[["class","first-text-part",4,"ngIf"],[1,"second-text-part"],[1,"first-text-part"]],template:function(e,i){1&e&&(S(0,f1e,2,1,"span",0),h(1,"span",1),T(2),g()),2&e&&(_("ngIf",i.firstTextPart().length>0),b(2),ut(i.secondTextPart()))},dependencies:[Fe],styles:["[_nghost-%COMP%]{display:inline-flex;white-space:nowrap}.first-text-part[_ngcontent-%COMP%]{flex:1 1 4ch;max-width:max-content}.first-text-part[_ngcontent-%COMP%], .second-text-part[_ngcontent-%COMP%]{overflow:hidden;text-overflow:ellipsis}"]}),n})();function m1e(n,t){1&n&&P(0,"mat-icon",2)}function h1e(n,t){1&n&&P(0,"mat-icon",3)}var l0=(()=>{class n{constructor(){this.isClipped=!1,this.isClosestStepHighlighted=!1}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["vis-linked-time-selection-warning"]],inputs:{isClipped:"isClipped",isClosestStepHighlighted:"isClosestStepHighlighted"},decls:2,vars:2,consts:[["data-value","clipped","svgIcon","info_outline_24px","title","Linked step is not found in this visualization. We highlighted the closest step for you.",4,"ngIf"],["data-value","closestStepHighlighted","svgIcon","info_outline_24px","title","Data is not found on selected step. We highlighted the closest step for you.",4,"ngIf"],["data-value","clipped","svgIcon","info_outline_24px","title","Linked step is not found in this visualization. We highlighted the closest step for you."],["data-value","closestStepHighlighted","svgIcon","info_outline_24px","title","Data is not found on selected step. We highlighted the closest step for you."]],template:function(e,i){1&e&&(S(0,m1e,1,0,"mat-icon",0),S(1,h1e,1,0,"mat-icon",1)),2&e&&(_("ngIf",i.isClipped),b(1),_("ngIf",i.isClosestStepHighlighted))},dependencies:[Fe,Dn],styles:["[_nghost-%COMP%]{color:#d32f2f;height:1em;line-height:0;display:inline-flex}body.dark-mode   [_nghost-%COMP%]{color:#d32f2f}[_nghost-%COMP%]   mat-icon[_ngcontent-%COMP%]{height:100%;width:100%}"],changeDetection:0}),n})();function g1e(n,t){if(1&n&&(h(0,"span",19),T(1),G(2,"number"),g()),2&n){let e=w();b(1),ze("Step ",W(2,1,e.steps[e.stepIndex]),"")}}function _1e(n,t){if(1&n&&(h(0,"span",20),T(1),G(2,"number"),G(3,"number"),g()),2&n){let e=w();b(1),du("Sample ",W(2,2,e.sample+1),"/",W(3,4,e.numSample),"")}}function y1e(n,t){1&n&&P(0,"mat-spinner",21)}function b1e(n,t){if(1&n&&(h(0,"span"),P(1,"span",30)(2,"span",31),g()),2&n){let e=w(3);b(2),Mt("left",e.sliderStartPosition)("width",e.sliderTrackWidth)}}function v1e(n,t){if(1&n&&P(0,"div",32),2&n){let e=t.$implicit,i=w(3);Mt("left",i.getLinkedTimeTickLeftStyle(e))("margin-left",i.getLinkedTimeTickMarginLeftStyle(e))}}function x1e(n,t){if(1&n&&(h(0,"div",27),S(1,b1e,3,4,"span",28),S(2,v1e,1,4,"div",29),g()),2&n){let e=w(2);b(1),_("ngIf",null!==e.linkedTimeSelection.endStep),b(1),_("ngForOf",e.selectedSteps)}}var C1e=function(n){return[n]},M1e=function(n){return{filter:n}};function w1e(n,t){if(1&n){let e=ge();Tt(0),h(1,"div",22)(2,"mat-slider",23),D("input",function(r){return X(e),Q(w().onSliderInput(r))}),g(),S(3,x1e,3,2,"div",24),g(),h(4,"div",25),P(5,"img",26),g(),Dt()}if(2&n){let e=w();b(2),_("ngClass",Sn(11,C1e,e.linkedTimeSelection&&null!==e.linkedTimeSelection.endStep?"hide-slider":""))("disabled",e.steps.length<=1)("min",0)("max",e.steps.length-1)("step",1)("tickInterval",1)("value",e.stepIndex),b(1),_("ngIf",e.linkedTimeSelection),b(2),Sy("alt","Image at step ",e.steps[e.stepIndex],""),Ji("src",e.imageUrl,As),_("ngStyle",Sn(13,M1e,e.cssFilter()))}}function S1e(n,t){1&n&&(h(0,"div",34),T(1," Data failed to load. "),g())}function E1e(n,t){if(1&n&&S(0,S1e,2,0,"div",33),2&n){let e=w();_("ngIf",e.loadState===e.DataLoadState.FAILED)}}var T1e=function(n){return{backgroundColor:n}},QQ=(()=>{class n{constructor(){this.DataLoadState=De,this.sliderStartPosition="",this.sliderTrackWidth="",this.linkedTimeSelection=null,this.isClosestStepHighlighted=!1,this.onActualSizeToggle=new L,this.stepIndexChange=new L,this.onPinClicked=new L}cssFilter(){return`contrast(${this.contrastInMilli/10}%) brightness(${this.brightnessInMilli/1e3})`}onSliderInput(e){this.stepIndexChange.emit(e.value)}changeDistinct(e){return e.currentValue!==e.previousValue}ngOnChanges(e){(e.selectedSteps&&this.changeDistinct(e.selectedSteps)||e.linkedTimeSelection&&this.changeDistinct(e.linkedTimeSelection))&&this.renderRangeSlider()}renderRangeSlider(){if(!this.linkedTimeSelection||!this.linkedTimeSelection.endStep)return;let e=this.steps.length-1,i=this.linkedTimeSelection.startStep<this.steps[0]?this.steps[0]:this.linkedTimeSelection.startStep,r=this.linkedTimeSelection.endStep>this.steps[e]?this.steps[e]:this.linkedTimeSelection.endStep,{startPosition:o,width:a}=this.getTrackStartPositionAndWidth(i,r,e);this.sliderStartPosition=100*o+"%",this.sliderTrackWidth=100*a+"%"}getTrackStartPositionAndWidth(e,i,r){let o=1/r,a=0,s=0,l=0;for(;l<this.steps.length-1;l++){let c=this.steps[l],d=this.steps[l+1];if(c<=e&&e<=d){a+=(e-c)/(d-c);break}}for(a=(a+l)*o;l<this.steps.length-1;l++){let c=this.steps[l],d=this.steps[l+1];if(e>=c&&i<=d){s=(i-e)/(d-c);break}if(e>=c&&i>=d)s+=(d-e)/(d-c);else{if(!(i>=d)){s+=(i-c)/(d-c);break}s+=1}}return s*=o,(a>1||a<0)&&(a=0),{startPosition:a,width:s}}getLinkedTimeTickLeftStyle(e){if(-1==this.steps.indexOf(e))throw new Error("Invalid stepIndex: stepIndex value is not included in steps");return this.steps.indexOf(e)/(this.steps.length-1)*100+"%"}getLinkedTimeTickMarginLeftStyle(e){if(-1==this.steps.indexOf(e))throw new Error("Invalid stepIndex: stepIndex value is not included in steps");return`-${this.steps.indexOf(e)/(this.steps.length-1)*14}px`}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["image-card-component"]],hostVars:2,hostBindings:function(e,i){2&e&&Qe("actual-size",i.showActualSize)},inputs:{loadState:"loadState",title:"title",tag:"tag",runId:"runId",sample:"sample",numSample:"numSample",imageUrl:"imageUrl",stepIndex:"stepIndex",steps:"steps",brightnessInMilli:"brightnessInMilli",contrastInMilli:"contrastInMilli",showActualSize:"showActualSize",runColorScale:"runColorScale",allowToggleActualSize:"allowToggleActualSize",isPinned:"isPinned",selectedSteps:"selectedSteps",linkedTimeSelection:"linkedTimeSelection",isClosestStepHighlighted:"isClosestStepHighlighted"},outputs:{onActualSizeToggle:"onActualSizeToggle",stepIndexChange:"stepIndexChange",onPinClicked:"onPinClicked"},features:[Gt],decls:21,vars:16,consts:function(){let t,e;return t=$localize`:A button to pin a card.␟e665dc712bd5f18d4dfa3a29e125d565cc51e2f6␟7284606426234375344:Pin card`,e=$localize`:A button on an image card that toggles actual image size.␟3ca05ef3a6e3a37065f5e0f69c5d5a2178d90791␟7635101936664789140:Toggle actual image size`,[[1,"heading"],[1,"line"],[1,"tag"],[1,"tag-path",3,"title","value"],[3,"isClipped","isClosestStepHighlighted"],[1,"controls"],["mat-icon-button","","aria-label",t,1,"pin-button",3,"click"],[3,"svgIcon"],["mat-icon-button","","aria-label",e,"title","Toggle actual image size",3,"disabled","click"],["svgIcon","image_search_24px"],[1,"run"],[1,"dot",3,"ngStyle"],[1,"run-text",3,"runId"],[1,"metadata"],["class","step",4,"ngIf"],["class","sample",4,"ngIf"],["class","loading","diameter","18",4,"ngIf"],[4,"ngIf","ngIfElse"],["noImageData",""],[1,"step"],[1,"sample"],["diameter","18",1,"loading"],[1,"slider-row"],["color","primary",1,"step-slider",3,"ngClass","disabled","min","max","step","tickInterval","value","input"],["class","linked-time-wrapper",4,"ngIf"],[1,"img-container"],[3,"alt","src","ngStyle","includeFeatureFlags"],[1,"linked-time-wrapper"],[4,"ngIf"],["class","linked-time-tick",3,"left","margin-left",4,"ngFor","ngForOf"],[1,"slider-track"],[1,"slider-track-fill"],[1,"linked-time-tick"],["class","empty-message",4,"ngIf"],[1,"empty-message"]]},template:function(e,i){if(1&e&&(h(0,"div",0)(1,"div",1)(2,"span",2),P(3,"tb-truncated-path",3)(4,"vis-linked-time-selection-warning",4),g(),h(5,"span",5)(6,"button",6),D("click",function(){return i.onPinClicked.emit(!i.isPinned)}),P(7,"mat-icon",7),g(),h(8,"button",8),D("click",function(){return i.onActualSizeToggle.emit()}),P(9,"mat-icon",9),g()()(),h(10,"div",1)(11,"span",10),P(12,"span",11)(13,"card-run-name",12),g(),h(14,"div",13),S(15,g1e,3,3,"span",14),S(16,_1e,4,6,"span",15),S(17,y1e,1,0,"mat-spinner",16),g()()(),S(18,w1e,6,15,"ng-container",17),S(19,E1e,1,1,"ng-template",null,18,Zt)),2&e){let r=tt(20);b(3),Ji("title",i.tag),Ji("value",i.title),b(1),_("isClipped",i.linkedTimeSelection&&i.linkedTimeSelection.clipped)("isClosestStepHighlighted",i.isClosestStepHighlighted),b(2),Pe("title",i.isPinned?"Unpin card":"Pin card"),b(1),_("svgIcon",i.isPinned?"keep_24px":"keep_outline_24px"),b(1),_("disabled",!i.allowToggleActualSize),b(4),_("ngStyle",Sn(14,T1e,i.runColorScale(i.runId))),b(1),_("runId",i.runId),b(2),_("ngIf",null!==i.stepIndex&&i.stepIndex<i.steps.length),b(1),_("ngIf",i.numSample>1),b(1),_("ngIf",i.loadState===i.DataLoadState.LOADING),b(1),_("ngIf",null!==i.stepIndex&&i.stepIndex<i.steps.length)("ngIfElse",r)}},dependencies:[bn,dn,Fe,mu,QT,Fn,Dn,zr,Td,KT,s0,l0,Ps],styles:["[_nghost-%COMP%]{box-sizing:border-box;display:flex;flex-basis:318px;flex-direction:column;flex-grow:1;height:100%;overflow:auto;padding:16px;padding-top:4px}.actual-size[_nghost-%COMP%]{height:auto}.heading[_ngcontent-%COMP%]{align-items:center;font-size:14px;margin-bottom:4px;position:relative}.line[_ngcontent-%COMP%]{align-items:center;display:grid;grid-template-columns:1fr max-content}.tag[_ngcontent-%COMP%]{align-items:center;display:flex;gap:5px}.metadata[_ngcontent-%COMP%]{display:flex;flex-wrap:wrap;gap:5px;justify-content:flex-end;max-width:175px;text-align:end}.tag-path[_ngcontent-%COMP%]{overflow:hidden}.pin-button[_ngcontent-%COMP%]   mat-icon[_ngcontent-%COMP%]{height:18px}.run[_ngcontent-%COMP%]{align-self:baseline;display:flex;overflow:hidden;white-space:nowrap}.run[_ngcontent-%COMP%]   .dot[_ngcontent-%COMP%]{flex:none;display:inline-block;width:13px;height:13px;border-radius:50%;margin-right:4px}.run[_ngcontent-%COMP%]   .run-text[_ngcontent-%COMP%]{overflow:hidden;text-overflow:ellipsis;max-width:120px}.run[_ngcontent-%COMP%], .sample[_ngcontent-%COMP%], .step[_ngcontent-%COMP%]{color:#616161;font-size:13px}body.dark-mode[_nghost-%COMP%]   .run[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .run[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}body.dark-mode[_nghost-%COMP%]   .sample[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .sample[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}body.dark-mode[_nghost-%COMP%]   .step[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .step[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}.controls[_ngcontent-%COMP%]{color:#616161;white-space:nowrap;justify-self:flex-end;flex-shrink:0;margin-right:-12px}body.dark-mode[_nghost-%COMP%]   .controls[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .controls[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}.img-container[_ngcontent-%COMP%]{flex-grow:1;overflow-y:auto;position:relative}.img-container[_ngcontent-%COMP%]   img[_ngcontent-%COMP%]{image-rendering:-moz-crisp-edges;image-rendering:pixelated}.actual-size[_nghost-%COMP%]   .img-container[_ngcontent-%COMP%]{overflow:auto;flex:none}[_nghost-%COMP%]:not(.actual-size)   img[_ngcontent-%COMP%]{position:absolute;max-height:100%;max-width:100%;width:auto;height:100%;object-fit:contain}.slider-row[_ngcontent-%COMP%]{display:flex;align-items:center;height:24px;position:relative}.step-slider[_ngcontent-%COMP%]{flex:1}[_nghost-%COMP%]     .mat-slider-min-value .mat-slider-thumb{background-color:#f57c00}[_nghost-%COMP%]     .hide-slider.mat-slider-horizontal .mat-slider-track-wrapper{height:0}.empty-message[_ngcontent-%COMP%]{margin-top:1em;font-size:13px}.linked-time-wrapper[_ngcontent-%COMP%]{position:absolute;top:5px;width:100%}.linked-time-tick[_ngcontent-%COMP%]{background-color:#e0e0e0;border-radius:50%;height:14px;position:absolute;width:14px}body.dark-mode[_nghost-%COMP%]   .linked-time-tick[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .linked-time-tick[_ngcontent-%COMP%]{background-color:#212121}.slider-track[_ngcontent-%COMP%], .slider-track-fill[_ngcontent-%COMP%]{height:2px;top:6px;position:absolute}.slider-track[_ngcontent-%COMP%]{background:rgba(0,0,0,.26);left:7px;width:calc(100% - 14px)}body.dark-mode[_nghost-%COMP%]   .slider-track[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .slider-track[_ngcontent-%COMP%]{background:rgba(255,255,255,.3)}.slider-track-fill[_ngcontent-%COMP%]{background:#f57c00}body.dark-mode[_nghost-%COMP%]   .slider-track-fill[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .slider-track-fill[_ngcontent-%COMP%]{background:#ef6c00}"],changeDetection:0}),n})(),ZQ=(()=>{class n{constructor(e,i){this.store=e,this.dataSource=i,this.fullWidthChanged=new L,this.pinStateChanged=new L,this.brightnessInMilli$=this.store.select(c1),this.contrastInMilli$=this.store.select(d1),this.actualSizeGlobalSetting$=this.store.select(u1),this.showActualSize=!1,this.actualSizeUiToggled=!1,this.actualSizeUiToggleSubject=new Ri(this.actualSizeUiToggled),this.ngUnsubscribe=new Ae}onStepIndexChanged(e){this.store.dispatch(FT({cardId:this.cardId,stepIndex:e}))}isImageCardMetadata(e){let{plugin:i}=e;return i===qn.IMAGES}onActualSizeToggle(){this.actualSizeUiToggled=!this.actualSizeUiToggled,this.actualSizeUiToggleSubject.next(this.actualSizeUiToggled)}ngOnInit(){un([this.actualSizeGlobalSetting$,this.actualSizeUiToggleSubject]).pipe(ot(this.ngUnsubscribe),Vt(([l,c])=>{this.showActualSize=l||c,this.fullWidthChanged.emit(this.showActualSize)})).subscribe(()=>{});let i=this.store.select(Us,this.cardId).pipe(ot(this.ngUnsubscribe),Ve(l=>!!l&&this.isImageCardMetadata(l)),U(l=>l),Ea(1)),o=un([i,this.store.select(Eu,this.cardId)]).pipe(ot(this.ngUnsubscribe),U(([l,c])=>{let d=l.runId;return c&&c.hasOwnProperty(d)?c[d]:[]}),ui((l,c)=>l.length===c.length&&0===l.length||l===c),Ea(1));this.stepIndex$=this.store.select(ZF,this.cardId).pipe(U(l=>l?l.index:null)),this.isClosestStepHighlighted$=this.store.select(ZF,this.cardId).pipe(U(l=>!!l&&l.isClosest)),this.loadState$=this.store.select(hd,this.cardId),this.tag$=i.pipe(U(l=>l.tag)),this.title$=this.tag$.pipe(U(l=>a0(l,this.groupName))),this.runId$=i.pipe(U(l=>l.runId)),this.sample$=i.pipe(U(l=>l.sample)),this.numSample$=i.pipe(U(l=>l.numSample)),this.steps$=this.store.select(jW,this.cardId),this.isPinned$=this.store.select(Tu,this.cardId),this.linkedTimeSelection$=this.store.select(Au).pipe(Vi(this.steps$),U(([l,c])=>l?$h(l,Math.min(...c),Math.max(...c)):null)),this.selectedSteps$=this.linkedTimeSelection$.pipe(Vi(this.steps$),U(([l,c])=>l?null===l.endStep?-1!==c.indexOf(l.startStep)?[l.startStep]:[]:c.filter(d=>d>=l.startStep&&d<=l.endStep):[]));let s=un([o,this.stepIndex$]).pipe(U(([l,c])=>null!==c&&l[c]?l[c]:null));this.imageUrl$=s.pipe(U(l=>l?this.dataSource.imageUrl(l.imageId):null))}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}}return n.\u0275fac=function(e){return new(e||n)(C(ke),C(Mc))},n.\u0275cmp=k({type:n,selectors:[["image-card"]],inputs:{cardId:"cardId",groupName:"groupName",runColorScale:"runColorScale"},outputs:{fullWidthChanged:"fullWidthChanged",pinStateChanged:"pinStateChanged"},decls:17,vars:50,consts:[[3,"loadState","title","tag","runId","sample","numSample","imageUrl","stepIndex","steps","isClosestStepHighlighted","brightnessInMilli","contrastInMilli","runColorScale","showActualSize","allowToggleActualSize","isPinned","linkedTimeSelection","selectedSteps","stepIndexChange","onActualSizeToggle","onPinClicked"]],template:function(e,i){1&e&&(h(0,"image-card-component",0),D("stepIndexChange",function(o){return i.onStepIndexChanged(o)})("onActualSizeToggle",function(){return i.onActualSizeToggle()})("onPinClicked",function(o){return i.pinStateChanged.emit(o)}),G(1,"async"),G(2,"async"),G(3,"async"),G(4,"async"),G(5,"async"),G(6,"async"),G(7,"async"),G(8,"async"),G(9,"async"),G(10,"async"),G(11,"async"),G(12,"async"),G(13,"async"),G(14,"async"),G(15,"async"),G(16,"async"),g()),2&e&&_("loadState",W(1,18,i.loadState$))("title",W(2,20,i.title$))("tag",W(3,22,i.tag$))("runId",W(4,24,i.runId$))("sample",W(5,26,i.sample$))("numSample",W(6,28,i.numSample$))("imageUrl",W(7,30,i.imageUrl$))("stepIndex",W(8,32,i.stepIndex$))("steps",W(9,34,i.steps$))("isClosestStepHighlighted",W(10,36,i.isClosestStepHighlighted$))("brightnessInMilli",W(11,38,i.brightnessInMilli$))("contrastInMilli",W(12,40,i.contrastInMilli$))("runColorScale",i.runColorScale)("showActualSize",i.showActualSize)("allowToggleActualSize",!1===W(13,42,i.actualSizeGlobalSetting$))("isPinned",W(14,44,i.isPinned$))("linkedTimeSelection",W(15,46,i.linkedTimeSelection$))("selectedSteps",W(16,48,i.selectedSteps$))},dependencies:[QQ,lt],styles:["[_nghost-%COMP%] {\n        display: flex;\n        flex-direction: column;\n        height: 100%;\n      }"],changeDetection:0}),n})(),Zi=(()=>(function(n){n[n.SVG=0]="SVG",n[n.WEBGL=1]="WEBGL"}(Zi||(Zi={})),Zi))(),ir=(()=>(function(n){n[n.LINEAR=0]="LINEAR",n[n.LOG10=1]="LOG10",n[n.TIME=2]="TIME"}(ir||(ir={})),ir))(),Tr=(()=>(function(n){n.NONE="NONE",n.DRAG_ZOOMING="DRAG_ZOOMING",n.SCROLL_ZOOMING="SCROLL_ZOOMING",n.PANNING="PANNING"}(Tr||(Tr={})),Tr))();function R1e(n,t){1&n&&(h(0,"span"),T(1,"scalar"),g())}function k1e(n,t){1&n&&(h(0,"span"),T(1,"histogram"),g())}function P1e(n,t){1&n&&(h(0,"span"),T(1,"unknown"),g())}function O1e(n,t){if(1&n&&(Tt(0,13),S(1,R1e,2,0,"span",14),S(2,k1e,2,0,"span",14),S(3,P1e,2,0,"span",15),Dt()),2&n){let e=w(2);_("ngSwitch",e.cardMetadata.plugin),b(1),_("ngSwitchCase",e.PluginType.SCALARS),b(1),_("ngSwitchCase",e.PluginType.HISTOGRAMS)}}function F1e(n,t){1&n&&Ti(0)}function L1e(n,t){if(1&n&&(h(0,"option",16),T(1),g()),2&n){let e=t.$implicit;_("value",e.id),b(1),ut(e.name)}}function N1e(n,t){if(1&n){let e=ge();Tt(0),h(1,"h2"),S(2,O1e,4,3,"ng-template",null,2,Zt),h(4,"span"),T(5,"Download\xa0"),g(),S(6,F1e,1,0,"ng-container",3),h(7,"span"),T(8,"\xa0data for\xa0"),g(),h(9,"code",4),T(10),g()(),h(11,"mat-dialog-content")(12,"mat-form-field",5)(13,"mat-label"),T(14,"Select a run to download a data for a series"),g(),h(15,"select",6),D("change",function(r){return X(e),Q(w().runSelected.emit(r.target.value))}),h(16,"option",7),T(17,"-"),g(),S(18,L1e,2,2,"option",8),g()(),h(19,"div",9)(20,"span"),T(21,"Download as\u2026"),g(),T(22,"\xa0"),h(23,"a",10),T(24,"JSON"),g(),h(25,"a",10),T(26,"CSV"),g()()(),h(27,"mat-dialog-actions",11)(28,"button",12),T(29,"Close"),g()(),Dt()}if(2&n){let e=tt(3),i=w();b(6),_("ngTemplateOutlet",e),b(3),_("title",i.cardMetadata.tag),b(1),ut(i.cardMetadata.tag),b(5),_("value",i.selectedRunId||""),b(1),_("value",""),b(2),_("ngForOf",i.runs),b(5),_("disabled",!i.downloadUrlJson)("download",i.getDownloadName("json"))("href",i.downloadUrlJson,As),b(2),_("disabled",!i.downloadUrlCsv)("download",i.getDownloadName("csv"))("href",i.downloadUrlCsv,As)}}function B1e(n,t){1&n&&T(0,"Loading...")}var JQ=(()=>{class n{constructor(){this.runSelected=new L,this.PluginType=qn}getDownloadName(e){let i=this.runs.find(r=>r.id===this.selectedRunId);return i?`${i.name}.${e}`:""}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["data_download_dialog_component"]],inputs:{cardMetadata:"cardMetadata",runs:"runs",selectedRunId:"selectedRunId",downloadUrlCsv:"downloadUrlCsv",downloadUrlJson:"downloadUrlJson"},outputs:{runSelected:"runSelected"},decls:3,vars:2,consts:[[4,"ngIf","ngIfElse"],["noCardMetadata",""],["dataName",""],[4,"ngTemplateOutlet"],[1,"tag-name",3,"title"],["appearance","fill",1,"run-selector"],["matNativeControl","","name","run","cdkFocusInitial","","required","",3,"value","change"],["selected","",3,"value"],[3,"value",4,"ngFor","ngForOf"],[1,"download-controls"],["mat-stroked-button","",3,"disabled","download","href","includeFeatureFlags"],["align","end"],["mat-button","","mat-dialog-close",""],[3,"ngSwitch"],[4,"ngSwitchCase"],[4,"NgSwitchDefault"],[3,"value"]],template:function(e,i){if(1&e&&(S(0,N1e,30,12,"ng-container",0),S(1,B1e,1,0,"ng-template",null,1,Zt)),2&e){let r=tt(2);_("ngIf",i.cardMetadata)("ngIfElse",r)}},dependencies:[dn,Fe,Mo,$i,sr,QT,uq,fq,Fn,U1,J1,$1,eE,Ys,Eg,qu],styles:["h2[_ngcontent-%COMP%]{font-size:1.25em;overflow-wrap:break-word}.run-selector[_ngcontent-%COMP%]{font-size:.9em;width:100%}.download-controls[_ngcontent-%COMP%]{font-size:.9em}.download-controls[_ngcontent-%COMP%]   a[_ngcontent-%COMP%]{margin:3px 10px 3px 0}"],changeDetection:0}),n})(),$Q=(()=>{class n{constructor(e,i,r){this.selectedRunId$=new Ri(null),this.cardMetadata$=e.select(Us,r.cardId).pipe(Ve(o=>Boolean(o))),this.downloadUrlCsv$=un([e.select(Us,r.cardId),this.selectedRunId$]).pipe(U(([o,a])=>o&&a?i.downloadUrl(o.plugin,o.tag,a,"csv"):null),Nn(null)),this.downloadUrlJson$=un([e.select(Us,r.cardId),this.selectedRunId$]).pipe(U(([o,a])=>o&&a?i.downloadUrl(o.plugin,o.tag,a,"json"):null),Nn(null)),this.runs$=un([e.select(o7),e.select(Eu,r.cardId)]).pipe(U(([o,a])=>a?Object.keys(a).map(s=>o.get(s)).filter(Boolean):[]))}}return n.\u0275fac=function(e){return new(e||n)(C(ke),C(Mc),C(Kb))},n.\u0275cmp=k({type:n,selectors:[["data_download_dialog"]],decls:6,vars:15,consts:[[3,"cardMetadata","runs","selectedRunId","downloadUrlCsv","downloadUrlJson","runSelected"]],template:function(e,i){1&e&&(h(0,"data_download_dialog_component",0),D("runSelected",function(o){return i.selectedRunId$.next(o)}),G(1,"async"),G(2,"async"),G(3,"async"),G(4,"async"),G(5,"async"),g()),2&e&&_("cardMetadata",W(1,5,i.cardMetadata$))("runs",W(2,7,i.runs$))("selectedRunId",W(3,9,i.selectedRunId$))("downloadUrlCsv",W(4,11,i.downloadUrlCsv$))("downloadUrlJson",W(5,13,i.downloadUrlJson$))},dependencies:[JQ,lt],encapsulation:2,changeDetection:0}),n})();function Ks(n,t){return n<t?-1:n>t?1:n>=t?0:NaN}function Tv(n){return 1===n.length&&(n=function(n){return function(t,e){return Ks(n(t),e)}}(n)),{left:function(t,e,i,r){for(null==i&&(i=0),null==r&&(r=t.length);i<r;){var o=i+r>>>1;n(t[o],e)<0?i=o+1:r=o}return i},right:function(t,e,i,r){for(null==i&&(i=0),null==r&&(r=t.length);i<r;){var o=i+r>>>1;n(t[o],e)>0?r=o:i=o+1}return i}}}var Nc=Tv(Ks).right,lN=Math.sqrt(50),cN=Math.sqrt(10),dN=Math.sqrt(2);function Dv(n,t,e){var i,o,a,s,r=-1;if(e=+e,(n=+n)==(t=+t)&&e>0)return[n];if((i=t<n)&&(o=n,n=t,t=o),0===(s=c0(n,t,e))||!isFinite(s))return[];if(s>0)for(n=Math.ceil(n/s),t=Math.floor(t/s),a=new Array(o=Math.ceil(t-n+1));++r<o;)a[r]=(n+r)*s;else for(n=Math.floor(n*s),t=Math.ceil(t*s),a=new Array(o=Math.ceil(n-t+1));++r<o;)a[r]=(n-r)/s;return i&&a.reverse(),a}function c0(n,t,e){var i=(t-n)/Math.max(0,e),r=Math.floor(Math.log(i)/Math.LN10),o=i/Math.pow(10,r);return r>=0?(o>=lN?10:o>=cN?5:o>=dN?2:1)*Math.pow(10,r):-Math.pow(10,-r)/(o>=lN?10:o>=cN?5:o>=dN?2:1)}function Ad(n,t,e){var i=Math.abs(t-n)/Math.max(0,e),r=Math.pow(10,Math.floor(Math.log(i)/Math.LN10)),o=i/r;return o>=lN?r*=10:o>=cN?r*=5:o>=dN&&(r*=2),t<n?-r:r}var $T=Array.prototype.slice;function oZ(n){return n}var pN=1,tD=2,fN=3,eD=4,aZ=1e-6;function Q1e(n){return"translate("+(n+.5)+",0)"}function Z1e(n){return"translate(0,"+(n+.5)+")"}function K1e(n){return function(t){return+n(t)}}function J1e(n){var t=Math.max(0,n.bandwidth()-1)/2;return n.round()&&(t=Math.round(t)),function(e){return+n(e)+t}}function $1e(){return!this.__axis}function sZ(n,t){var e=[],i=null,r=null,o=6,a=6,s=3,l=n===pN||n===eD?-1:1,c=n===eD||n===tD?"x":"y",d=n===pN||n===fN?Q1e:Z1e;function u(p){var f=i??(t.ticks?t.ticks.apply(t,e):t.domain()),m=r??(t.tickFormat?t.tickFormat.apply(t,e):oZ),y=Math.max(o,0)+s,M=t.range(),v=+M[0]+.5,x=+M[M.length-1]+.5,R=(t.bandwidth?J1e:K1e)(t.copy()),A=p.selection?p.selection():p,H=A.selectAll(".domain").data([null]),te=A.selectAll(".tick").data(f,t).order(),K=te.exit(),Ce=te.enter().append("g").attr("class","tick"),Ze=te.select("line"),Ie=te.select("text");H=H.merge(H.enter().insert("path",".tick").attr("class","domain").attr("stroke","currentColor")),te=te.merge(Ce),Ze=Ze.merge(Ce.append("line").attr("stroke","currentColor").attr(c+"2",l*o)),Ie=Ie.merge(Ce.append("text").attr("fill","currentColor").attr(c,l*y).attr("dy",n===pN?"0em":n===fN?"0.71em":"0.32em")),p!==A&&(H=H.transition(p),te=te.transition(p),Ze=Ze.transition(p),Ie=Ie.transition(p),K=K.transition(p).attr("opacity",aZ).attr("transform",function(I){return isFinite(I=R(I))?d(I):this.getAttribute("transform")}),Ce.attr("opacity",aZ).attr("transform",function(I){var re=this.parentNode.__axis;return d(re&&isFinite(re=re(I))?re:R(I))})),K.remove(),H.attr("d",n===eD||n==tD?a?"M"+l*a+","+v+"H0.5V"+x+"H"+l*a:"M0.5,"+v+"V"+x:a?"M"+v+","+l*a+"V0.5H"+x+"V"+l*a:"M"+v+",0.5H"+x),te.attr("opacity",1).attr("transform",function(I){return d(R(I))}),Ze.attr(c+"2",l*o),Ie.attr(c,l*y).text(m),A.filter($1e).attr("fill","none").attr("font-size",10).attr("font-family","sans-serif").attr("text-anchor",n===tD?"start":n===eD?"end":"middle"),A.each(function(){this.__axis=R})}return u.scale=function(p){return arguments.length?(t=p,u):t},u.ticks=function(){return e=$T.call(arguments),u},u.tickArguments=function(p){return arguments.length?(e=null==p?[]:$T.call(p),u):e.slice()},u.tickValues=function(p){return arguments.length?(i=null==p?null:$T.call(p),u):i&&i.slice()},u.tickFormat=function(p){return arguments.length?(r=p,u):r},u.tickSize=function(p){return arguments.length?(o=a=+p,u):o},u.tickSizeInner=function(p){return arguments.length?(o=+p,u):o},u.tickSizeOuter=function(p){return arguments.length?(a=+p,u):a},u.tickPadding=function(p){return arguments.length?(s=+p,u):s},u}var eEe={value:function(){}};function cZ(){for(var i,n=0,t=arguments.length,e={};n<t;++n){if(!(i=arguments[n]+"")||i in e||/[\s.]/.test(i))throw new Error("illegal type: "+i);e[i]=[]}return new nD(e)}function nD(n){this._=n}function nEe(n,t){for(var r,e=0,i=n.length;e<i;++e)if((r=n[e]).name===t)return r.value}function lZ(n,t,e){for(var i=0,r=n.length;i<r;++i)if(n[i].name===t){n[i]=eEe,n=n.slice(0,i).concat(n.slice(i+1));break}return null!=e&&n.push({name:t,value:e}),n}nD.prototype=cZ.prototype={constructor:nD,on:function(n,t){var r,e=this._,i=function(n,t){return n.trim().split(/^|\s+/).map(function(e){var i="",r=e.indexOf(".");if(r>=0&&(i=e.slice(r+1),e=e.slice(0,r)),e&&!t.hasOwnProperty(e))throw new Error("unknown type: "+e);return{type:e,name:i}})}(n+"",e),o=-1,a=i.length;if(!(arguments.length<2)){if(null!=t&&"function"!=typeof t)throw new Error("invalid callback: "+t);for(;++o<a;)if(r=(n=i[o]).type)e[r]=lZ(e[r],n.name,t);else if(null==t)for(r in e)e[r]=lZ(e[r],n.name,null);return this}for(;++o<a;)if((r=(n=i[o]).type)&&(r=nEe(e[r],n.name)))return r},copy:function(){var n={},t=this._;for(var e in t)n[e]=t[e].slice();return new nD(n)},call:function(n,t){if((r=arguments.length-2)>0)for(var r,o,e=new Array(r),i=0;i<r;++i)e[i]=arguments[i+2];if(!this._.hasOwnProperty(n))throw new Error("unknown type: "+n);for(i=0,r=(o=this._[n]).length;i<r;++i)o[i].value.apply(t,e)},apply:function(n,t,e){if(!this._.hasOwnProperty(n))throw new Error("unknown type: "+n);for(var i=this._[n],r=0,o=i.length;r<o;++r)i[r].value.apply(t,e)}};var gN=cZ,iD="http://www.w3.org/1999/xhtml",_N={svg:"http://www.w3.org/2000/svg",xhtml:iD,xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/"};function Rd(n){var t=n+="",e=t.indexOf(":");return e>=0&&"xmlns"!==(t=n.slice(0,e))&&(n=n.slice(e+1)),_N.hasOwnProperty(t)?{space:_N[t],local:n}:n}function iEe(n){return function(){var t=this.ownerDocument,e=this.namespaceURI;return e===iD&&t.documentElement.namespaceURI===iD?t.createElement(n):t.createElementNS(e,n)}}function rEe(n){return function(){return this.ownerDocument.createElementNS(n.space,n.local)}}function rD(n){var t=Rd(n);return(t.local?rEe:iEe)(t)}function oEe(){}function Zf(n){return null==n?oEe:function(){return this.querySelector(n)}}function aEe(){return[]}function Av(n){return null==n?aEe:function(){return this.querySelectorAll(n)}}function Rv(n){return function(){return this.matches(n)}}function oD(n){return new Array(n.length)}function kv(n,t){this.ownerDocument=n.ownerDocument,this.namespaceURI=n.namespaceURI,this._next=null,this._parent=n,this.__data__=t}kv.prototype={constructor:kv,appendChild:function(n){return this._parent.insertBefore(n,this._next)},insertBefore:function(n,t){return this._parent.insertBefore(n,t)},querySelector:function(n){return this._parent.querySelector(n)},querySelectorAll:function(n){return this._parent.querySelectorAll(n)}};var hZ="$";function sEe(n,t,e,i,r,o){for(var s,a=0,l=t.length,c=o.length;a<c;++a)(s=t[a])?(s.__data__=o[a],i[a]=s):e[a]=new kv(n,o[a]);for(;a<l;++a)(s=t[a])&&(r[a]=s)}function lEe(n,t,e,i,r,o,a){var s,l,f,c={},d=t.length,u=o.length,p=new Array(d);for(s=0;s<d;++s)(l=t[s])&&(p[s]=f=hZ+a.call(l,l.__data__,s,t),f in c?r[s]=l:c[f]=l);for(s=0;s<u;++s)(l=c[f=hZ+a.call(n,o[s],s,o)])?(i[s]=l,l.__data__=o[s],c[f]=null):e[s]=new kv(n,o[s]);for(s=0;s<d;++s)(l=t[s])&&c[p[s]]===l&&(r[s]=l)}function cEe(n,t){return n<t?-1:n>t?1:n>=t?0:NaN}function dEe(n){return function(){this.removeAttribute(n)}}function uEe(n){return function(){this.removeAttributeNS(n.space,n.local)}}function pEe(n,t){return function(){this.setAttribute(n,t)}}function fEe(n,t){return function(){this.setAttributeNS(n.space,n.local,t)}}function mEe(n,t){return function(){var e=t.apply(this,arguments);null==e?this.removeAttribute(n):this.setAttribute(n,e)}}function hEe(n,t){return function(){var e=t.apply(this,arguments);null==e?this.removeAttributeNS(n.space,n.local):this.setAttributeNS(n.space,n.local,e)}}function aD(n){return n.ownerDocument&&n.ownerDocument.defaultView||n.document&&n||n.defaultView}function gEe(n){return function(){this.style.removeProperty(n)}}function _Ee(n,t,e){return function(){this.style.setProperty(n,t,e)}}function yEe(n,t,e){return function(){var i=t.apply(this,arguments);null==i?this.style.removeProperty(n):this.style.setProperty(n,i,e)}}function np(n,t){return n.style.getPropertyValue(t)||aD(n).getComputedStyle(n,null).getPropertyValue(t)}function bEe(n){return function(){delete this[n]}}function vEe(n,t){return function(){this[n]=t}}function xEe(n,t){return function(){var e=t.apply(this,arguments);null==e?delete this[n]:this[n]=e}}function RZ(n){return n.trim().split(/^|\s+/)}function yN(n){return n.classList||new kZ(n)}function kZ(n){this._node=n,this._names=RZ(n.getAttribute("class")||"")}function PZ(n,t){for(var e=yN(n),i=-1,r=t.length;++i<r;)e.add(t[i])}function OZ(n,t){for(var e=yN(n),i=-1,r=t.length;++i<r;)e.remove(t[i])}function CEe(n){return function(){PZ(this,n)}}function MEe(n){return function(){OZ(this,n)}}function wEe(n,t){return function(){(t.apply(this,arguments)?PZ:OZ)(this,n)}}function SEe(){this.textContent=""}function EEe(n){return function(){this.textContent=n}}function TEe(n){return function(){var t=n.apply(this,arguments);this.textContent=t??""}}function DEe(){this.innerHTML=""}function IEe(n){return function(){this.innerHTML=n}}function AEe(n){return function(){var t=n.apply(this,arguments);this.innerHTML=t??""}}function REe(){this.nextSibling&&this.parentNode.appendChild(this)}function kEe(){this.previousSibling&&this.parentNode.insertBefore(this,this.parentNode.firstChild)}function PEe(){return null}function OEe(){var n=this.parentNode;n&&n.removeChild(this)}function FEe(){var n=this.cloneNode(!1),t=this.parentNode;return t?t.insertBefore(n,this.nextSibling):n}function LEe(){var n=this.cloneNode(!0),t=this.parentNode;return t?t.insertBefore(n,this.nextSibling):n}kZ.prototype={add:function(n){this._names.indexOf(n)<0&&(this._names.push(n),this._node.setAttribute("class",this._names.join(" ")))},remove:function(n){var t=this._names.indexOf(n);t>=0&&(this._names.splice(t,1),this._node.setAttribute("class",this._names.join(" ")))},contains:function(n){return this._names.indexOf(n)>=0}};var qZ={},bN=null;function NEe(n,t,e){return n=YZ(n,t,e),function(i){var r=i.relatedTarget;(!r||r!==this&&!(8&r.compareDocumentPosition(this)))&&n.call(this,i)}}function YZ(n,t,e){return function(i){var r=bN;bN=i;try{n.call(this,this.__data__,t,e)}finally{bN=r}}}function VEe(n){return function(){var t=this.__on;if(t){for(var o,e=0,i=-1,r=t.length;e<r;++e)o=t[e],n.type&&o.type!==n.type||o.name!==n.name?t[++i]=o:this.removeEventListener(o.type,o.listener,o.capture);++i?t.length=i:delete this.__on}}}function HEe(n,t,e){var i=qZ.hasOwnProperty(n.type)?NEe:YZ;return function(r,o,a){var l,s=this.__on,c=i(t,o,a);if(s)for(var d=0,u=s.length;d<u;++d)if((l=s[d]).type===n.type&&l.name===n.name)return this.removeEventListener(l.type,l.listener,l.capture),this.addEventListener(l.type,l.listener=c,l.capture=e),void(l.value=t);this.addEventListener(n.type,c,e),l={type:n.type,name:n.name,value:t,listener:c,capture:e},s?s.push(l):this.__on=[l]}}function QZ(n,t,e){var i=aD(n),r=i.CustomEvent;"function"==typeof r?r=new r(t,e):(r=i.document.createEvent("Event"),e?(r.initEvent(t,e.bubbles,e.cancelable),r.detail=e.detail):r.initEvent(t,!1,!1)),n.dispatchEvent(r)}function zEe(n,t){return function(){return QZ(this,n,t)}}function UEe(n,t){return function(){return QZ(this,n,t.apply(this,arguments))}}typeof document<"u"&&("onmouseenter"in document.documentElement||(qZ={mouseenter:"mouseover",mouseleave:"mouseout"}));var vN=[null];function Ur(n,t){this._groups=n,this._parents=t}function KZ(){return new Ur([[document.documentElement]],vN)}Ur.prototype=KZ.prototype={constructor:Ur,select:function(n){"function"!=typeof n&&(n=Zf(n));for(var t=this._groups,e=t.length,i=new Array(e),r=0;r<e;++r)for(var l,c,o=t[r],a=o.length,s=i[r]=new Array(a),d=0;d<a;++d)(l=o[d])&&(c=n.call(l,l.__data__,d,o))&&("__data__"in l&&(c.__data__=l.__data__),s[d]=c);return new Ur(i,this._parents)},selectAll:function(n){"function"!=typeof n&&(n=Av(n));for(var t=this._groups,e=t.length,i=[],r=[],o=0;o<e;++o)for(var l,a=t[o],s=a.length,c=0;c<s;++c)(l=a[c])&&(i.push(n.call(l,l.__data__,c,a)),r.push(l));return new Ur(i,r)},filter:function(n){"function"!=typeof n&&(n=Rv(n));for(var t=this._groups,e=t.length,i=new Array(e),r=0;r<e;++r)for(var l,o=t[r],a=o.length,s=i[r]=[],c=0;c<a;++c)(l=o[c])&&n.call(l,l.__data__,c,o)&&s.push(l);return new Ur(i,this._parents)},data:function(n,t){if(!n)return f=new Array(this.size()),c=-1,this.each(function(te){f[++c]=te}),f;var e=t?lEe:sEe,i=this._parents,r=this._groups;"function"!=typeof n&&(n=function(n){return function(){return n}}(n));for(var o=r.length,a=new Array(o),s=new Array(o),l=new Array(o),c=0;c<o;++c){var d=i[c],u=r[c],p=u.length,f=n.call(d,d&&d.__data__,c,i),m=f.length,y=s[c]=new Array(m),M=a[c]=new Array(m);e(d,u,y,M,l[c]=new Array(p),f,t);for(var A,H,x=0,R=0;x<m;++x)if(A=y[x]){for(x>=R&&(R=x+1);!(H=M[R])&&++R<m;);A._next=H||null}}return(a=new Ur(a,i))._enter=s,a._exit=l,a},enter:function(){return new Ur(this._enter||this._groups.map(oD),this._parents)},exit:function(){return new Ur(this._exit||this._groups.map(oD),this._parents)},join:function(n,t,e){var i=this.enter(),r=this,o=this.exit();return i="function"==typeof n?n(i):i.append(n+""),null!=t&&(r=t(r)),null==e?o.remove():e(o),i&&r?i.merge(r).order():r},merge:function(n){for(var t=this._groups,e=n._groups,i=t.length,o=Math.min(i,e.length),a=new Array(i),s=0;s<o;++s)for(var p,l=t[s],c=e[s],d=l.length,u=a[s]=new Array(d),f=0;f<d;++f)(p=l[f]||c[f])&&(u[f]=p);for(;s<i;++s)a[s]=t[s];return new Ur(a,this._parents)},order:function(){for(var n=this._groups,t=-1,e=n.length;++t<e;)for(var a,i=n[t],r=i.length-1,o=i[r];--r>=0;)(a=i[r])&&(o&&4^a.compareDocumentPosition(o)&&o.parentNode.insertBefore(a,o),o=a);return this},sort:function(n){function t(u,p){return u&&p?n(u.__data__,p.__data__):!u-!p}n||(n=cEe);for(var e=this._groups,i=e.length,r=new Array(i),o=0;o<i;++o){for(var c,a=e[o],s=a.length,l=r[o]=new Array(s),d=0;d<s;++d)(c=a[d])&&(l[d]=c);l.sort(t)}return new Ur(r,this._parents).order()},call:function(){var n=arguments[0];return arguments[0]=this,n.apply(null,arguments),this},nodes:function(){var n=new Array(this.size()),t=-1;return this.each(function(){n[++t]=this}),n},node:function(){for(var n=this._groups,t=0,e=n.length;t<e;++t)for(var i=n[t],r=0,o=i.length;r<o;++r){var a=i[r];if(a)return a}return null},size:function(){var n=0;return this.each(function(){++n}),n},empty:function(){return!this.node()},each:function(n){for(var t=this._groups,e=0,i=t.length;e<i;++e)for(var s,r=t[e],o=0,a=r.length;o<a;++o)(s=r[o])&&n.call(s,s.__data__,o,r);return this},attr:function(n,t){var e=Rd(n);if(arguments.length<2){var i=this.node();return e.local?i.getAttributeNS(e.space,e.local):i.getAttribute(e)}return this.each((null==t?e.local?uEe:dEe:"function"==typeof t?e.local?hEe:mEe:e.local?fEe:pEe)(e,t))},style:function(n,t,e){return arguments.length>1?this.each((null==t?gEe:"function"==typeof t?yEe:_Ee)(n,t,e??"")):np(this.node(),n)},property:function(n,t){return arguments.length>1?this.each((null==t?bEe:"function"==typeof t?xEe:vEe)(n,t)):this.node()[n]},classed:function(n,t){var e=RZ(n+"");if(arguments.length<2){for(var i=yN(this.node()),r=-1,o=e.length;++r<o;)if(!i.contains(e[r]))return!1;return!0}return this.each(("function"==typeof t?wEe:t?CEe:MEe)(e,t))},text:function(n){return arguments.length?this.each(null==n?SEe:("function"==typeof n?TEe:EEe)(n)):this.node().textContent},html:function(n){return arguments.length?this.each(null==n?DEe:("function"==typeof n?AEe:IEe)(n)):this.node().innerHTML},raise:function(){return this.each(REe)},lower:function(){return this.each(kEe)},append:function(n){var t="function"==typeof n?n:rD(n);return this.select(function(){return this.appendChild(t.apply(this,arguments))})},insert:function(n,t){var e="function"==typeof n?n:rD(n),i=null==t?PEe:"function"==typeof t?t:Zf(t);return this.select(function(){return this.insertBefore(e.apply(this,arguments),i.apply(this,arguments)||null)})},remove:function(){return this.each(OEe)},clone:function(n){return this.select(n?LEe:FEe)},datum:function(n){return arguments.length?this.property("__data__",n):this.node().__data__},on:function(n,t,e){var r,a,i=function(n){return n.trim().split(/^|\s+/).map(function(t){var e="",i=t.indexOf(".");return i>=0&&(e=t.slice(i+1),t=t.slice(0,i)),{type:t,name:e}})}(n+""),o=i.length;if(!(arguments.length<2)){for(s=t?HEe:VEe,null==e&&(e=!1),r=0;r<o;++r)this.each(s(i[r],t,e));return this}var s=this.node().__on;if(s)for(var d,l=0,c=s.length;l<c;++l)for(r=0,d=s[l];r<o;++r)if((a=i[r]).type===d.type&&a.name===d.name)return d.value},dispatch:function(n,t){return this.each(("function"==typeof t?UEe:zEe)(n,t))}};var kd=KZ;function sD(n){return"string"==typeof n?new Ur([[document.querySelector(n)]],[document.documentElement]):new Ur([[n]],vN)}function Kf(n,t,e){n.prototype=t.prototype=e,e.constructor=n}function d0(n,t){var e=Object.create(n.prototype);for(var i in t)e[i]=t[i];return e}function ip(){}var cD=1/.7,u0="\\s*([+-]?\\d+)\\s*",Ov="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",Vc="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",jEe=/^#([0-9a-f]{3,8})$/,GEe=new RegExp("^rgb\\("+[u0,u0,u0]+"\\)$"),WEe=new RegExp("^rgb\\("+[Vc,Vc,Vc]+"\\)$"),qEe=new RegExp("^rgba\\("+[u0,u0,u0,Ov]+"\\)$"),YEe=new RegExp("^rgba\\("+[Vc,Vc,Vc,Ov]+"\\)$"),XEe=new RegExp("^hsl\\("+[Ov,Vc,Vc]+"\\)$"),QEe=new RegExp("^hsla\\("+[Ov,Vc,Vc,Ov]+"\\)$"),JZ={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};function $Z(){return this.rgb().formatHex()}function eK(){return this.rgb().formatRgb()}function zl(n){var t,e;return n=(n+"").trim().toLowerCase(),(t=jEe.exec(n))?(e=t[1].length,t=parseInt(t[1],16),6===e?tK(t):3===e?new ta(t>>8&15|t>>4&240,t>>4&15|240&t,(15&t)<<4|15&t,1):8===e?lD(t>>24&255,t>>16&255,t>>8&255,(255&t)/255):4===e?lD(t>>12&15|t>>8&240,t>>8&15|t>>4&240,t>>4&15|240&t,((15&t)<<4|15&t)/255):null):(t=GEe.exec(n))?new ta(t[1],t[2],t[3],1):(t=WEe.exec(n))?new ta(255*t[1]/100,255*t[2]/100,255*t[3]/100,1):(t=qEe.exec(n))?lD(t[1],t[2],t[3],t[4]):(t=YEe.exec(n))?lD(255*t[1]/100,255*t[2]/100,255*t[3]/100,t[4]):(t=XEe.exec(n))?rK(t[1],t[2]/100,t[3]/100,1):(t=QEe.exec(n))?rK(t[1],t[2]/100,t[3]/100,t[4]):JZ.hasOwnProperty(n)?tK(JZ[n]):"transparent"===n?new ta(NaN,NaN,NaN,0):null}function tK(n){return new ta(n>>16&255,n>>8&255,255&n,1)}function lD(n,t,e,i){return i<=0&&(n=t=e=NaN),new ta(n,t,e,i)}function MN(n){return n instanceof ip||(n=zl(n)),n?new ta((n=n.rgb()).r,n.g,n.b,n.opacity):new ta}function p0(n,t,e,i){return 1===arguments.length?MN(n):new ta(n,t,e,i??1)}function ta(n,t,e,i){this.r=+n,this.g=+t,this.b=+e,this.opacity=+i}function nK(){return"#"+xN(this.r)+xN(this.g)+xN(this.b)}function iK(){var n=this.opacity;return(1===(n=isNaN(n)?1:Math.max(0,Math.min(1,n)))?"rgb(":"rgba(")+Math.max(0,Math.min(255,Math.round(this.r)||0))+", "+Math.max(0,Math.min(255,Math.round(this.g)||0))+", "+Math.max(0,Math.min(255,Math.round(this.b)||0))+(1===n?")":", "+n+")")}function xN(n){return((n=Math.max(0,Math.min(255,Math.round(n)||0)))<16?"0":"")+n.toString(16)}function rK(n,t,e,i){return i<=0?n=t=e=NaN:e<=0||e>=1?n=t=NaN:t<=0&&(n=NaN),new Bc(n,t,e,i)}function oK(n){if(n instanceof Bc)return new Bc(n.h,n.s,n.l,n.opacity);if(n instanceof ip||(n=zl(n)),!n)return new Bc;if(n instanceof Bc)return n;var t=(n=n.rgb()).r/255,e=n.g/255,i=n.b/255,r=Math.min(t,e,i),o=Math.max(t,e,i),a=NaN,s=o-r,l=(o+r)/2;return s?(a=t===o?(e-i)/s+6*(e<i):e===o?(i-t)/s+2:(t-e)/s+4,s/=l<.5?o+r:2-o-r,a*=60):s=l>0&&l<1?0:a,new Bc(a,s,l,n.opacity)}function Jf(n,t,e,i){return 1===arguments.length?oK(n):new Bc(n,t,e,i??1)}function Bc(n,t,e,i){this.h=+n,this.s=+t,this.l=+e,this.opacity=+i}function CN(n,t,e){return 255*(n<60?t+(e-t)*n/60:n<180?e:n<240?t+(e-t)*(240-n)/60:t)}Kf(ip,zl,{copy:function(n){return Object.assign(new this.constructor,this,n)},displayable:function(){return this.rgb().displayable()},hex:$Z,formatHex:$Z,formatHsl:function(){return oK(this).formatHsl()},formatRgb:eK,toString:eK}),Kf(ta,p0,d0(ip,{brighter:function(n){return n=null==n?cD:Math.pow(cD,n),new ta(this.r*n,this.g*n,this.b*n,this.opacity)},darker:function(n){return n=null==n?.7:Math.pow(.7,n),new ta(this.r*n,this.g*n,this.b*n,this.opacity)},rgb:function(){return this},displayable:function(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:nK,formatHex:nK,formatRgb:iK,toString:iK})),Kf(Bc,Jf,d0(ip,{brighter:function(n){return n=null==n?cD:Math.pow(cD,n),new Bc(this.h,this.s,this.l*n,this.opacity)},darker:function(n){return n=null==n?.7:Math.pow(.7,n),new Bc(this.h,this.s,this.l*n,this.opacity)},rgb:function(){var n=this.h%360+360*(this.h<0),t=isNaN(n)||isNaN(this.s)?0:this.s,e=this.l,i=e+(e<.5?e:1-e)*t,r=2*e-i;return new ta(CN(n>=240?n-240:n+120,r,i),CN(n,r,i),CN(n<120?n+240:n-120,r,i),this.opacity)},displayable:function(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl:function(){var n=this.opacity;return(1===(n=isNaN(n)?1:Math.max(0,Math.min(1,n)))?"hsl(":"hsla(")+(this.h||0)+", "+100*(this.s||0)+"%, "+100*(this.l||0)+"%"+(1===n?")":", "+n+")")}}));var aK=Math.PI/180,sK=180/Math.PI,lK=.96422,cK=1,dK=.82521,uK=4/29,f0=6/29,pK=3*f0*f0,KEe=f0*f0*f0;function fK(n){if(n instanceof Hc)return new Hc(n.l,n.a,n.b,n.opacity);if(n instanceof Pd)return mK(n);n instanceof ta||(n=MN(n));var o,a,t=TN(n.r),e=TN(n.g),i=TN(n.b),r=wN((.2225045*t+.7168786*e+.0606169*i)/cK);return t===e&&e===i?o=a=r:(o=wN((.4360747*t+.3850649*e+.1430804*i)/lK),a=wN((.0139322*t+.0971045*e+.7141733*i)/dK)),new Hc(116*r-16,500*(o-r),200*(r-a),n.opacity)}function Hc(n,t,e,i){this.l=+n,this.a=+t,this.b=+e,this.opacity=+i}function wN(n){return n>KEe?Math.pow(n,1/3):n/pK+uK}function SN(n){return n>f0?n*n*n:pK*(n-uK)}function EN(n){return 255*(n<=.0031308?12.92*n:1.055*Math.pow(n,1/2.4)-.055)}function TN(n){return(n/=255)<=.04045?n/12.92:Math.pow((n+.055)/1.055,2.4)}function $f(n,t,e,i){return 1===arguments.length?function(n){if(n instanceof Pd)return new Pd(n.h,n.c,n.l,n.opacity);if(n instanceof Hc||(n=fK(n)),0===n.a&&0===n.b)return new Pd(NaN,0<n.l&&n.l<100?0:NaN,n.l,n.opacity);var t=Math.atan2(n.b,n.a)*sK;return new Pd(t<0?t+360:t,Math.sqrt(n.a*n.a+n.b*n.b),n.l,n.opacity)}(n):new Pd(n,t,e,i??1)}function Pd(n,t,e,i){this.h=+n,this.c=+t,this.l=+e,this.opacity=+i}function mK(n){if(isNaN(n.h))return new Hc(n.l,0,0,n.opacity);var t=n.h*aK;return new Hc(n.l,Math.cos(t)*n.c,Math.sin(t)*n.c,n.opacity)}function IN(n,t,e,i,r){var o=n*n,a=o*n;return((1-3*n+3*o-a)*t+(4-6*o+3*a)*e+(1+3*n+3*o-3*a)*i+a*r)/6}function m0(n){return function(){return n}}function _K(n,t){return function(e){return n+e*t}}function uD(n,t){var e=t-n;return e?_K(n,e>180||e<-180?e-360*Math.round(e/360):e):m0(isNaN(n)?t:n)}function Wa(n,t){var e=t-n;return e?_K(n,e):m0(isNaN(n)?t:n)}Kf(Hc,function(n,t,e,i){return 1===arguments.length?fK(n):new Hc(n,t,e,i??1)},d0(ip,{brighter:function(n){return new Hc(this.l+18*(n??1),this.a,this.b,this.opacity)},darker:function(n){return new Hc(this.l-18*(n??1),this.a,this.b,this.opacity)},rgb:function(){var n=(this.l+16)/116,t=isNaN(this.a)?n:n+this.a/500,e=isNaN(this.b)?n:n-this.b/200;return new ta(EN(3.1338561*(t=lK*SN(t))-1.6168667*(n=cK*SN(n))-.4906146*(e=dK*SN(e))),EN(-.9787684*t+1.9161415*n+.033454*e),EN(.0719453*t-.2289914*n+1.4052427*e),this.opacity)}})),Kf(Pd,$f,d0(ip,{brighter:function(n){return new Pd(this.h,this.c,this.l+18*(n??1),this.opacity)},darker:function(n){return new Pd(this.h,this.c,this.l-18*(n??1),this.opacity)},rgb:function(){return mK(this).rgb()}}));var em=function n(t){var e=function(n){return 1==(n=+n)?Wa:function(t,e){return e-t?function(n,t,e){return n=Math.pow(n,e),t=Math.pow(t,e)-n,e=1/e,function(i){return Math.pow(n+i*t,e)}}(t,e,n):m0(isNaN(t)?e:t)}}(t);function i(r,o){var a=e((r=p0(r)).r,(o=p0(o)).r),s=e(r.g,o.g),l=e(r.b,o.b),c=Wa(r.opacity,o.opacity);return function(d){return r.r=a(d),r.g=s(d),r.b=l(d),r.opacity=c(d),r+""}}return i.gamma=n,i}(1);function bK(n){return function(t){var a,s,e=t.length,i=new Array(e),r=new Array(e),o=new Array(e);for(a=0;a<e;++a)s=p0(t[a]),i[a]=s.r||0,r[a]=s.g||0,o[a]=s.b||0;return i=n(i),r=n(r),o=n(o),s.opacity=1,function(l){return s.r=i(l),s.g=r(l),s.b=o(l),s+""}}}function vK(n,t){t||(t=[]);var r,e=n?Math.min(t.length,n.length):0,i=t.slice();return function(o){for(r=0;r<e;++r)i[r]=n[r]*(1-o)+t[r]*o;return i}}function CK(n,t){var a,e=t?t.length:0,i=n?Math.min(e,n.length):0,r=new Array(i),o=new Array(e);for(a=0;a<i;++a)r[a]=tm(n[a],t[a]);for(;a<e;++a)o[a]=t[a];return function(s){for(a=0;a<i;++a)o[a]=r[a](s);return o}}function MK(n,t){var e=new Date;return n=+n,t=+t,function(i){return e.setTime(n*(1-i)+t*i),e}}function Vo(n,t){return n=+n,t=+t,function(e){return n*(1-e)+t*e}}function wK(n,t){var r,e={},i={};for(r in(null===n||"object"!=typeof n)&&(n={}),(null===t||"object"!=typeof t)&&(t={}),t)r in n?e[r]=tm(n[r],t[r]):i[r]=t[r];return function(o){for(r in e)i[r]=e[r](o);return i}}bK(function(n){var t=n.length-1;return function(e){var i=e<=0?e=0:e>=1?(e=1,t-1):Math.floor(e*t),r=n[i],o=n[i+1];return IN((e-i/t)*t,i>0?n[i-1]:2*r-o,r,o,i<t-1?n[i+2]:2*o-r)}}),bK(function(n){var t=n.length;return function(e){var i=Math.floor(((e%=1)<0?++e:e)*t);return IN((e-i/t)*t,n[(i+t-1)%t],n[i%t],n[(i+1)%t],n[(i+2)%t])}});var RN=/[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,AN=new RegExp(RN.source,"g");function Fv(n,t){var i,r,o,e=RN.lastIndex=AN.lastIndex=0,a=-1,s=[],l=[];for(n+="",t+="";(i=RN.exec(n))&&(r=AN.exec(t));)(o=r.index)>e&&(o=t.slice(e,o),s[a]?s[a]+=o:s[++a]=o),(i=i[0])===(r=r[0])?s[a]?s[a]+=r:s[++a]=r:(s[++a]=null,l.push({i:a,x:Vo(i,r)})),e=AN.lastIndex;return e<t.length&&(o=t.slice(e),s[a]?s[a]+=o:s[++a]=o),s.length<2?l[0]?function(n){return function(t){return n(t)+""}}(l[0].x):function(n){return function(){return n}}(t):(t=l.length,function(c){for(var u,d=0;d<t;++d)s[(u=l[d]).i]=u.x(c);return s.join("")})}function tm(n,t){var i,e=typeof t;return null==t||"boolean"===e?m0(t):("number"===e?Vo:"string"===e?(i=zl(t))?(t=i,em):Fv:t instanceof zl?em:t instanceof Date?MK:function(n){return ArrayBuffer.isView(n)&&!(n instanceof DataView)}(t)?vK:Array.isArray(t)?CK:"function"!=typeof t.valueOf&&"function"!=typeof t.toString||isNaN(t)?wK:Vo)(n,t)}function kN(n,t){return n=+n,t=+t,function(e){return Math.round(n*(1-e)+t*e)}}var Lv,ON,EK,fD,SK=180/Math.PI,pD={translateX:0,translateY:0,rotate:0,skewX:0,scaleX:1,scaleY:1};function PN(n,t,e,i,r,o){var a,s,l;return(a=Math.sqrt(n*n+t*t))&&(n/=a,t/=a),(l=n*e+t*i)&&(e-=n*l,i-=t*l),(s=Math.sqrt(e*e+i*i))&&(e/=s,i/=s,l/=s),n*i<t*e&&(n=-n,t=-t,l=-l,a=-a),{translateX:r,translateY:o,rotate:Math.atan2(t,n)*SK,skewX:Math.atan(l)*SK,scaleX:a,scaleY:s}}function IK(n,t,e,i){function r(c){return c.length?c.pop()+" ":""}return function(c,d){var u=[],p=[];return c=n(c),d=n(d),function(c,d,u,p,f,m){if(c!==u||d!==p){var y=f.push("translate(",null,t,null,e);m.push({i:y-4,x:Vo(c,u)},{i:y-2,x:Vo(d,p)})}else(u||p)&&f.push("translate("+u+t+p+e)}(c.translateX,c.translateY,d.translateX,d.translateY,u,p),function(c,d,u,p){c!==d?(c-d>180?d+=360:d-c>180&&(c+=360),p.push({i:u.push(r(u)+"rotate(",null,i)-2,x:Vo(c,d)})):d&&u.push(r(u)+"rotate("+d+i)}(c.rotate,d.rotate,u,p),function(c,d,u,p){c!==d?p.push({i:u.push(r(u)+"skewX(",null,i)-2,x:Vo(c,d)}):d&&u.push(r(u)+"skewX("+d+i)}(c.skewX,d.skewX,u,p),function(c,d,u,p,f,m){if(c!==u||d!==p){var y=f.push(r(f)+"scale(",null,",",null,")");m.push({i:y-4,x:Vo(c,u)},{i:y-2,x:Vo(d,p)})}else(1!==u||1!==p)&&f.push(r(f)+"scale("+u+","+p+")")}(c.scaleX,c.scaleY,d.scaleX,d.scaleY,u,p),c=d=null,function(f){for(var M,m=-1,y=p.length;++m<y;)u[(M=p[m]).i]=M.x(f);return u.join("")}}}var FN=IK(function(n){return"none"===n?pD:(Lv||(Lv=document.createElement("DIV"),ON=document.documentElement,EK=document.defaultView),Lv.style.transform=n,n=EK.getComputedStyle(ON.appendChild(Lv),null).getPropertyValue("transform"),ON.removeChild(Lv),PN(+(n=n.slice(7,-1).split(","))[0],+n[1],+n[2],+n[3],+n[4],+n[5]))},"px, ","px)","deg)"),LN=IK(function(n){return null==n?pD:(fD||(fD=document.createElementNS("http://www.w3.org/2000/svg","g")),fD.setAttribute("transform",n),(n=fD.transform.baseVal.consolidate())?PN((n=n.matrix).a,n.b,n.c,n.d,n.e,n.f):pD)},", ",")",")");function AK(n){return function(t,e){var i=n((t=Jf(t)).h,(e=Jf(e)).h),r=Wa(t.s,e.s),o=Wa(t.l,e.l),a=Wa(t.opacity,e.opacity);return function(s){return t.h=i(s),t.s=r(s),t.l=o(s),t.opacity=a(s),t+""}}}var NN=AK(uD);function RK(n){return function(t,e){var i=n((t=$f(t)).h,(e=$f(e)).h),r=Wa(t.c,e.c),o=Wa(t.l,e.l),a=Wa(t.opacity,e.opacity);return function(s){return t.h=i(s),t.c=r(s),t.l=o(s),t.opacity=a(s),t+""}}}AK(Wa);var mD,Vv,BN=RK(uD),h0=(RK(Wa),0),Bv=0,Nv=0,PK=1e3,hD=0,nm=0,gD=0,Hv="object"==typeof performance&&performance.now?performance:Date,OK="object"==typeof window&&window.requestAnimationFrame?window.requestAnimationFrame.bind(window):function(n){setTimeout(n,17)};function g0(){return nm||(OK(aTe),nm=Hv.now()+gD)}function aTe(){nm=0}function zv(){this._call=this._time=this._next=null}function _D(n,t,e){var i=new zv;return i.restart(n,t,e),i}function kK(){nm=(hD=Hv.now())+gD,h0=Bv=0;try{!function(){g0(),++h0;for(var t,n=mD;n;)(t=nm-n._time)>=0&&n._call.call(null,t),n=n._next;--h0}()}finally{h0=0,function(){for(var n,e,t=mD,i=1/0;t;)t._call?(i>t._time&&(i=t._time),n=t,t=t._next):(e=t._next,t._next=null,t=n?n._next=e:mD=e);Vv=n,VN(i)}(),nm=0}}function sTe(){var n=Hv.now(),t=n-hD;t>PK&&(gD-=t,hD=n)}function VN(n){h0||(Bv&&(Bv=clearTimeout(Bv)),n-nm>24?(n<1/0&&(Bv=setTimeout(kK,n-Hv.now()-gD)),Nv&&(Nv=clearInterval(Nv))):(Nv||(hD=Hv.now(),Nv=setInterval(sTe,PK)),h0=1,OK(kK)))}function yD(n,t,e){var i=new zv;return i.restart(function(r){i.stop(),n(r+t)},t=null==t?0:+t,e),i}zv.prototype=_D.prototype={constructor:zv,restart:function(n,t,e){if("function"!=typeof n)throw new TypeError("callback is not a function");e=(null==e?g0():+e)+(null==t?0:+t),!this._next&&Vv!==this&&(Vv?Vv._next=this:mD=this,Vv=this),this._call=n,this._time=e,VN()},stop:function(){this._call&&(this._call=null,this._time=1/0,VN())}};var cTe=gN("start","end","cancel","interrupt"),dTe=[],NK=0,HN=1,vD=2,bD=3,LK=4,xD=5,Uv=6;function rp(n,t,e,i,r,o){var a=n.__transition;if(a){if(e in a)return}else n.__transition={};!function(n,t,e){var r,i=n.__transition;function a(c){var d,u,p,f;if(e.state!==HN)return l();for(d in i)if((f=i[d]).name===e.name){if(f.state===bD)return yD(a);f.state===LK?(f.state=Uv,f.timer.stop(),f.on.call("interrupt",n,n.__data__,f.index,f.group),delete i[d]):+d<t&&(f.state=Uv,f.timer.stop(),f.on.call("cancel",n,n.__data__,f.index,f.group),delete i[d])}if(yD(function(){e.state===bD&&(e.state=LK,e.timer.restart(s,e.delay,e.time),s(c))}),e.state=vD,e.on.call("start",n,n.__data__,e.index,e.group),e.state===vD){for(e.state=bD,r=new Array(p=e.tween.length),d=0,u=-1;d<p;++d)(f=e.tween[d].value.call(n,n.__data__,e.index,e.group))&&(r[++u]=f);r.length=u+1}}function s(c){for(var d=c<e.duration?e.ease.call(null,c/e.duration):(e.timer.restart(l),e.state=xD,1),u=-1,p=r.length;++u<p;)r[u].call(n,d);e.state===xD&&(e.on.call("end",n,n.__data__,e.index,e.group),l())}function l(){for(var c in e.state=Uv,e.timer.stop(),delete i[t],i)return;delete n.__transition}i[t]=e,e.timer=_D(function(c){e.state=HN,e.timer.restart(a,e.delay,e.time),e.delay<=c&&a(c-e.delay)},0,e.time)}(n,e,{name:t,index:i,group:r,on:cTe,tween:dTe,time:o.time,delay:o.delay,duration:o.duration,ease:o.ease,timer:null,state:NK})}function jv(n,t){var e=_o(n,t);if(e.state>NK)throw new Error("too late; already scheduled");return e}function _a(n,t){var e=_o(n,t);if(e.state>bD)throw new Error("too late; already running");return e}function _o(n,t){var e=n.__transition;if(!e||!(e=e[t]))throw new Error("transition not found");return e}function pTe(n,t){var e,i;return function(){var r=_a(this,n),o=r.tween;if(o!==e)for(var a=0,s=(i=e=o).length;a<s;++a)if(i[a].name===t){(i=i.slice()).splice(a,1);break}r.tween=i}}function fTe(n,t,e){var i,r;if("function"!=typeof e)throw new Error;return function(){var o=_a(this,n),a=o.tween;if(a!==i){r=(i=a).slice();for(var s={name:t,value:e},l=0,c=r.length;l<c;++l)if(r[l].name===t){r[l]=s;break}l===c&&r.push(s)}o.tween=r}}function _0(n,t,e){var i=n._id;return n.each(function(){var r=_a(this,i);(r.value||(r.value={}))[t]=e.apply(this,arguments)}),function(r){return _o(r,i).value[t]}}function CD(n,t){var e;return("number"==typeof t?Vo:t instanceof zl?em:(e=zl(t))?(t=e,em):Fv)(n,t)}function mTe(n){return function(){this.removeAttribute(n)}}function hTe(n){return function(){this.removeAttributeNS(n.space,n.local)}}function gTe(n,t,e){var i,o,r=e+"";return function(){var a=this.getAttribute(n);return a===r?null:a===i?o:o=t(i=a,e)}}function _Te(n,t,e){var i,o,r=e+"";return function(){var a=this.getAttributeNS(n.space,n.local);return a===r?null:a===i?o:o=t(i=a,e)}}function yTe(n,t,e){var i,r,o;return function(){var a,l,s=e(this);return null==s?void this.removeAttribute(n):(a=this.getAttribute(n))===(l=s+"")?null:a===i&&l===r?o:(r=l,o=t(i=a,s))}}function bTe(n,t,e){var i,r,o;return function(){var a,l,s=e(this);return null==s?void this.removeAttributeNS(n.space,n.local):(a=this.getAttributeNS(n.space,n.local))===(l=s+"")?null:a===i&&l===r?o:(r=l,o=t(i=a,s))}}function CTe(n,t){var e,i;function r(){var o=t.apply(this,arguments);return o!==i&&(e=(i=o)&&function(n,t){return function(e){this.setAttributeNS(n.space,n.local,t.call(this,e))}}(n,o)),e}return r._value=t,r}function MTe(n,t){var e,i;function r(){var o=t.apply(this,arguments);return o!==i&&(e=(i=o)&&function(n,t){return function(e){this.setAttribute(n,t.call(this,e))}}(n,o)),e}return r._value=t,r}function wTe(n,t){return function(){jv(this,n).delay=+t.apply(this,arguments)}}function STe(n,t){return t=+t,function(){jv(this,n).delay=t}}function ETe(n,t){return function(){_a(this,n).duration=+t.apply(this,arguments)}}function TTe(n,t){return t=+t,function(){_a(this,n).duration=t}}var kTe=kd.prototype.constructor;function JK(n){return function(){this.style.removeProperty(n)}}var jTe=0;function na(n,t,e,i){this._groups=n,this._parents=t,this._name=e,this._id=i}function MD(){return++jTe}var y0=kd.prototype;na.prototype=function(n){return kd().transition(n)}.prototype={constructor:na,select:function(n){var t=this._name,e=this._id;"function"!=typeof n&&(n=Zf(n));for(var i=this._groups,r=i.length,o=new Array(r),a=0;a<r;++a)for(var d,u,s=i[a],l=s.length,c=o[a]=new Array(l),p=0;p<l;++p)(d=s[p])&&(u=n.call(d,d.__data__,p,s))&&("__data__"in d&&(u.__data__=d.__data__),c[p]=u,rp(c[p],t,e,p,c,_o(d,e)));return new na(o,this._parents,t,e)},selectAll:function(n){var t=this._name,e=this._id;"function"!=typeof n&&(n=Av(n));for(var i=this._groups,r=i.length,o=[],a=[],s=0;s<r;++s)for(var d,l=i[s],c=l.length,u=0;u<c;++u)if(d=l[u]){for(var f,p=n.call(d,d.__data__,u,l),m=_o(d,e),y=0,M=p.length;y<M;++y)(f=p[y])&&rp(f,t,e,y,p,m);o.push(p),a.push(d)}return new na(o,a,t,e)},filter:function(n){"function"!=typeof n&&(n=Rv(n));for(var t=this._groups,e=t.length,i=new Array(e),r=0;r<e;++r)for(var l,o=t[r],a=o.length,s=i[r]=[],c=0;c<a;++c)(l=o[c])&&n.call(l,l.__data__,c,o)&&s.push(l);return new na(i,this._parents,this._name,this._id)},merge:function(n){if(n._id!==this._id)throw new Error;for(var t=this._groups,e=n._groups,i=t.length,o=Math.min(i,e.length),a=new Array(i),s=0;s<o;++s)for(var p,l=t[s],c=e[s],d=l.length,u=a[s]=new Array(d),f=0;f<d;++f)(p=l[f]||c[f])&&(u[f]=p);for(;s<i;++s)a[s]=t[s];return new na(a,this._parents,this._name,this._id)},selection:function(){return new kTe(this._groups,this._parents)},transition:function(){for(var n=this._name,t=this._id,e=MD(),i=this._groups,r=i.length,o=0;o<r;++o)for(var l,a=i[o],s=a.length,c=0;c<s;++c)if(l=a[c]){var d=_o(l,t);rp(l,n,e,c,a,{time:d.time+d.delay+d.duration,delay:0,duration:d.duration,ease:d.ease})}return new na(i,this._parents,n,e)},call:y0.call,nodes:y0.nodes,node:y0.node,size:y0.size,empty:y0.empty,each:y0.each,on:function(n,t){var e=this._id;return arguments.length<2?_o(this.node(),e).on.on(n):this.each(function(n,t,e){var i,r,o=function(n){return(n+"").trim().split(/^|\s+/).every(function(t){var e=t.indexOf(".");return e>=0&&(t=t.slice(0,e)),!t||"start"===t})}(t)?jv:_a;return function(){var a=o(this,n),s=a.on;s!==i&&(r=(i=s).copy()).on(t,e),a.on=r}}(e,n,t))},attr:function(n,t){var e=Rd(n),i="transform"===e?LN:CD;return this.attrTween(n,"function"==typeof t?(e.local?bTe:yTe)(e,i,_0(this,"attr."+n,t)):null==t?(e.local?hTe:mTe)(e):(e.local?_Te:gTe)(e,i,t))},attrTween:function(n,t){var e="attr."+n;if(arguments.length<2)return(e=this.tween(e))&&e._value;if(null==t)return this.tween(e,null);if("function"!=typeof t)throw new Error;var i=Rd(n);return this.tween(e,(i.local?CTe:MTe)(i,t))},style:function(n,t,e){var i="transform"==(n+="")?FN:CD;return null==t?this.styleTween(n,function(n,t){var e,i,r;return function(){var o=np(this,n),a=(this.style.removeProperty(n),np(this,n));return o===a?null:o===e&&a===i?r:r=t(e=o,i=a)}}(n,i)).on("end.style."+n,JK(n)):"function"==typeof t?this.styleTween(n,function(n,t,e){var i,r,o;return function(){var a=np(this,n),s=e(this),l=s+"";return null==s&&(this.style.removeProperty(n),l=s=np(this,n)),a===l?null:a===i&&l===r?o:(r=l,o=t(i=a,s))}}(n,i,_0(this,"style."+n,t))).each(function(n,t){var e,i,r,s,o="style."+t,a="end."+o;return function(){var l=_a(this,n),c=l.on,d=null==l.value[o]?s||(s=JK(t)):void 0;(c!==e||r!==d)&&(i=(e=c).copy()).on(a,r=d),l.on=i}}(this._id,n)):this.styleTween(n,function(n,t,e){var i,o,r=e+"";return function(){var a=np(this,n);return a===r?null:a===i?o:o=t(i=a,e)}}(n,i,t),e).on("end.style."+n,null)},styleTween:function(n,t,e){var i="style."+(n+="");if(arguments.length<2)return(i=this.tween(i))&&i._value;if(null==t)return this.tween(i,null);if("function"!=typeof t)throw new Error;return this.tween(i,function(n,t,e){var i,r;function o(){var a=t.apply(this,arguments);return a!==r&&(i=(r=a)&&function(n,t,e){return function(i){this.style.setProperty(n,t.call(this,i),e)}}(n,a,e)),i}return o._value=t,o}(n,t,e??""))},text:function(n){return this.tween("text","function"==typeof n?function(n){return function(){var t=n(this);this.textContent=t??""}}(_0(this,"text",n)):function(n){return function(){this.textContent=n}}(null==n?"":n+""))},textTween:function(n){var t="text";if(arguments.length<1)return(t=this.tween(t))&&t._value;if(null==n)return this.tween(t,null);if("function"!=typeof n)throw new Error;return this.tween(t,function(n){var t,e;function i(){var r=n.apply(this,arguments);return r!==e&&(t=(e=r)&&function(n){return function(t){this.textContent=n.call(this,t)}}(r)),t}return i._value=n,i}(n))},remove:function(){return this.on("end.remove",function(n){return function(){var t=this.parentNode;for(var e in this.__transition)if(+e!==n)return;t&&t.removeChild(this)}}(this._id))},tween:function(n,t){var e=this._id;if(n+="",arguments.length<2){for(var a,i=_o(this.node(),e).tween,r=0,o=i.length;r<o;++r)if((a=i[r]).name===n)return a.value;return null}return this.each((null==t?pTe:fTe)(e,n,t))},delay:function(n){var t=this._id;return arguments.length?this.each(("function"==typeof n?wTe:STe)(t,n)):_o(this.node(),t).delay},duration:function(n){var t=this._id;return arguments.length?this.each(("function"==typeof n?ETe:TTe)(t,n)):_o(this.node(),t).duration},ease:function(n){var t=this._id;return arguments.length?this.each(function(n,t){if("function"!=typeof t)throw new Error;return function(){_a(this,n).ease=t}}(t,n)):_o(this.node(),t).ease},end:function(){var n,t,e=this,i=e._id,r=e.size();return new Promise(function(o,a){var s={value:a},l={value:function(){0==--r&&o()}};e.each(function(){var c=_a(this,i),d=c.on;d!==n&&((t=(n=d).copy())._.cancel.push(s),t._.interrupt.push(s),t._.end.push(l)),c.on=t})})}};var UN={time:null,delay:0,duration:250,ease:function(n){return((n*=2)<=1?n*n*n:(n-=2)*n*n+2)/2}};function GTe(n,t){for(var e;!(e=n.__transition)||!(e=e[t]);)if(!(n=n.parentNode))return UN.time=g0(),UN;return e}function jN(n){return{type:n}}kd.prototype.interrupt=function(n){return this.each(function(){!function(n,t){var i,r,a,e=n.__transition,o=!0;if(e){for(a in t=null==t?null:t+"",e)(i=e[a]).name===t?(r=i.state>vD&&i.state<xD,i.state=Uv,i.timer.stop(),i.on.call(r?"interrupt":"cancel",n,n.__data__,i.index,i.group),delete e[a]):o=!1;o&&delete n.__transition}}(this,n)})},kd.prototype.transition=function(n){var t,e;n instanceof na?(t=n._id,n=n._name):(t=MD(),(e=UN).time=g0(),n=null==n?null:n+"");for(var i=this._groups,r=i.length,o=0;o<r;++o)for(var l,a=i[o],s=a.length,c=0;c<s;++c)(l=a[c])&&rp(l,n,t,c,a,e||GTe(l,t));return new na(i,this._parents,n,t)},["w","e"].map(jN),["n","s"].map(jN),["n","w","e","s","nw","ne","sw","se"].map(jN),Math;var fs="$";function SD(){}function lJ(n,t){var e=new SD;if(n instanceof SD)n.each(function(s,l){e.set(l,s)});else if(Array.isArray(n)){var o,i=-1,r=n.length;if(null==t)for(;++i<r;)e.set(i,n[i]);else for(;++i<r;)e.set(t(o=n[i],i,n),o)}else if(n)for(var a in n)e.set(a,n[a]);return e}function ED(){}SD.prototype=lJ.prototype={constructor:SD,has:function(n){return fs+n in this},get:function(n){return this[fs+n]},set:function(n,t){return this[fs+n]=t,this},remove:function(n){var t=fs+n;return t in this&&delete this[t]},clear:function(){for(var n in this)n[0]===fs&&delete this[n]},keys:function(){var n=[];for(var t in this)t[0]===fs&&n.push(t.slice(1));return n},values:function(){var n=[];for(var t in this)t[0]===fs&&n.push(this[t]);return n},entries:function(){var n=[];for(var t in this)t[0]===fs&&n.push({key:t.slice(1),value:this[t]});return n},size:function(){var n=0;for(var t in this)t[0]===fs&&++n;return n},empty:function(){for(var n in this)if(n[0]===fs)return!1;return!0},each:function(n){for(var t in this)t[0]===fs&&n(this[t],t.slice(1),this)}};var rm=lJ.prototype;function om(n,t){if((e=(n=t?n.toExponential(t-1):n.toExponential()).indexOf("e"))<0)return null;var e,i=n.slice(0,e);return[i.length>1?i[0]+i.slice(2):i,+n.slice(e+1)]}function zc(n){return(n=om(Math.abs(n)))?n[1]:NaN}ED.prototype=function(n,t){var e=new ED;if(n instanceof ED)n.each(function(o){e.add(o)});else if(n){var i=-1,r=n.length;if(null==t)for(;++i<r;)e.add(n[i]);else for(;++i<r;)e.add(t(n[i],i,n))}return e}.prototype={constructor:ED,has:rm.has,add:function(n){return this[fs+(n+="")]=n,this},remove:rm.remove,clear:rm.clear,values:rm.keys,size:rm.size,empty:rm.empty,each:rm.each},Math,Math.sqrt(5);var GN,$Te=/^(?:(.)?([<>=^]))?([+\-( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?(~)?([a-z%])?$/i;function op(n){if(!(t=$Te.exec(n)))throw new Error("invalid format: "+n);var t;return new TD({fill:t[1],align:t[2],sign:t[3],symbol:t[4],zero:t[5],width:t[6],comma:t[7],precision:t[8]&&t[8].slice(1),trim:t[9],type:t[10]})}function TD(n){this.fill=void 0===n.fill?" ":n.fill+"",this.align=void 0===n.align?">":n.align+"",this.sign=void 0===n.sign?"-":n.sign+"",this.symbol=void 0===n.symbol?"":n.symbol+"",this.zero=!!n.zero,this.width=void 0===n.width?void 0:+n.width,this.comma=!!n.comma,this.precision=void 0===n.precision?void 0:+n.precision,this.trim=!!n.trim,this.type=void 0===n.type?"":n.type+""}function WN(n,t){var e=om(n,t);if(!e)return n+"";var i=e[0],r=e[1];return r<0?"0."+new Array(-r).join("0")+i:i.length>r+1?i.slice(0,r+1)+"."+i.slice(r+1):i+new Array(r-i.length+2).join("0")}op.prototype=TD.prototype,TD.prototype.toString=function(){return this.fill+this.align+this.sign+this.symbol+(this.zero?"0":"")+(void 0===this.width?"":Math.max(1,0|this.width))+(this.comma?",":"")+(void 0===this.precision?"":"."+Math.max(0,0|this.precision))+(this.trim?"~":"")+this.type};var qN={"%":function(n,t){return(100*n).toFixed(t)},b:function(n){return Math.round(n).toString(2)},c:function(n){return n+""},d:function(n){return Math.abs(n=Math.round(n))>=1e21?n.toLocaleString("en").replace(/,/g,""):n.toString(10)},e:function(n,t){return n.toExponential(t)},f:function(n,t){return n.toFixed(t)},g:function(n,t){return n.toPrecision(t)},o:function(n){return Math.round(n).toString(8)},p:function(n,t){return WN(100*n,t)},r:WN,s:function(n,t){var e=om(n,t);if(!e)return n+"";var i=e[0],r=e[1],o=r-(GN=3*Math.max(-8,Math.min(8,Math.floor(r/3))))+1,a=i.length;return o===a?i:o>a?i+new Array(o-a+1).join("0"):o>0?i.slice(0,o)+"."+i.slice(o):"0."+new Array(1-o).join("0")+om(n,Math.max(0,t+o-1))[0]},X:function(n){return Math.round(n).toString(16).toUpperCase()},x:function(n){return Math.round(n).toString(16)}};function YN(n){return n}var DD,Jr,ID,gJ=Array.prototype.map,_J=["y","z","a","f","p","n","\xb5","m","","k","M","G","T","P","E","Z","Y"];function Js(){return Math.random()}DD=function(n){var t=void 0===n.grouping||void 0===n.thousands?YN:function(n,t){return function(e,i){for(var r=e.length,o=[],a=0,s=n[0],l=0;r>0&&s>0&&(l+s+1>i&&(s=Math.max(1,i-l)),o.push(e.substring(r-=s,r+s)),!((l+=s+1)>i));)s=n[a=(a+1)%n.length];return o.reverse().join(t)}}(gJ.call(n.grouping,Number),n.thousands+""),e=void 0===n.currency?"":n.currency[0]+"",i=void 0===n.currency?"":n.currency[1]+"",r=void 0===n.decimal?".":n.decimal+"",o=void 0===n.numerals?YN:function(n){return function(t){return t.replace(/[0-9]/g,function(e){return n[+e]})}}(gJ.call(n.numerals,String)),a=void 0===n.percent?"%":n.percent+"",s=void 0===n.minus?"-":n.minus+"",l=void 0===n.nan?"NaN":n.nan+"";function c(u){var p=(u=op(u)).fill,f=u.align,m=u.sign,y=u.symbol,M=u.zero,v=u.width,x=u.comma,R=u.precision,A=u.trim,H=u.type;"n"===H?(x=!0,H="g"):qN[H]||(void 0===R&&(R=12),A=!0,H="g"),(M||"0"===p&&"="===f)&&(M=!0,p="0",f="=");var te="$"===y?e:"#"===y&&/[boxX]/.test(H)?"0"+H.toLowerCase():"",K="$"===y?i:/[%p]/.test(H)?a:"",Ce=qN[H],Ze=/[defgprs%]/.test(H);function Ie(I){var fe,_e,ne,re=te,ce=K;if("c"===H)ce=Ce(I)+ce,I="";else{var de=(I=+I)<0||1/I<0;if(I=isNaN(I)?l:Ce(Math.abs(I),R),A&&(I=function(n){e:for(var r,t=n.length,e=1,i=-1;e<t;++e)switch(n[e]){case".":i=r=e;break;case"0":0===i&&(i=e),r=e;break;default:if(!+n[e])break e;i>0&&(i=0)}return i>0?n.slice(0,i)+n.slice(r+1):n}(I)),de&&0==+I&&"+"!==m&&(de=!1),re=(de?"("===m?m:s:"-"===m||"("===m?"":m)+re,ce=("s"===H?_J[8+GN/3]:"")+ce+(de&&"("===m?")":""),Ze)for(fe=-1,_e=I.length;++fe<_e;)if(48>(ne=I.charCodeAt(fe))||ne>57){ce=(46===ne?r+I.slice(fe+1):I.slice(fe))+ce,I=I.slice(0,fe);break}}x&&!M&&(I=t(I,1/0));var ue=re.length+I.length+ce.length,Ge=ue<v?new Array(v-ue+1).join(p):"";switch(x&&M&&(I=t(Ge+I,Ge.length?v-ce.length:1/0),Ge=""),f){case"<":I=re+I+ce+Ge;break;case"=":I=re+Ge+I+ce;break;case"^":I=Ge.slice(0,ue=Ge.length>>1)+re+I+ce+Ge.slice(ue);break;default:I=Ge+re+I+ce}return o(I)}return R=void 0===R?6:/[gprs]/.test(H)?Math.max(1,Math.min(21,R)):Math.max(0,Math.min(20,R)),Ie.toString=function(){return u+""},Ie}return{format:c,formatPrefix:function(u,p){var f=c(((u=op(u)).type="f",u)),m=3*Math.max(-8,Math.min(8,Math.floor(zc(p)/3))),y=Math.pow(10,-m),M=_J[8+m/3];return function(v){return f(y*v)+M}}}}({decimal:".",thousands:",",grouping:[3],currency:["$",""],minus:"-"}),Jr=DD.format,ID=DD.formatPrefix,function n(t){function e(i,r){return i=null==i?0:+i,r=null==r?1:+r,1===arguments.length?(r=i,i=0):r-=i,function(){return t()*r+i}}return e.source=n,e}(Js);var JN=function n(t){function e(i,r){var o,a;return i=null==i?0:+i,r=null==r?1:+r,function(){var s;if(null!=o)s=o,o=null;else do{o=2*t()-1,s=2*t()-1,a=o*o+s*s}while(!a||a>1);return i+r*s*Math.sqrt(-2*Math.log(a)/a)}}return e.source=n,e}(Js),$N=(function n(t){function e(){var i=JN.source(t).apply(this,arguments);return function(){return Math.exp(i())}}return e.source=n,e}(Js),function n(t){function e(i){return function(){for(var r=0,o=0;o<i;++o)r+=t();return r}}return e.source=n,e}(Js));function qa(n,t){switch(arguments.length){case 0:break;case 1:this.range(n);break;default:this.range(t).domain(n)}return this}(function n(t){function e(i){var r=$N.source(t)(i);return function(){return r()/i}}return e.source=n,e})(Js),function n(t){function e(i){return function(){return-Math.log(1-t())/i}}return e.source=n,e}(Js);var bJ=Array.prototype,qv=bJ.map,am=bJ.slice;function e3(n){return+n}var xJ=[0,1];function Ya(n){return n}function t3(n,t){return(t-=n=+n)?function(e){return(e-n)/t}:function(n){return function(){return n}}(isNaN(t)?NaN:.5)}function CJ(n){var i,t=n[0],e=n[n.length-1];return t>e&&(i=t,t=e,e=i),function(r){return Math.max(t,Math.min(e,r))}}function oDe(n,t,e){var i=n[0],r=n[1],o=t[0],a=t[1];return r<i?(i=t3(r,i),o=e(a,o)):(i=t3(i,r),o=e(o,a)),function(s){return o(i(s))}}function aDe(n,t,e){var i=Math.min(n.length,t.length)-1,r=new Array(i),o=new Array(i),a=-1;for(n[i]<n[0]&&(n=n.slice().reverse(),t=t.slice().reverse());++a<i;)r[a]=t3(n[a],n[a+1]),o[a]=e(t[a],t[a+1]);return function(s){var l=Nc(n,s,1,i)-1;return o[l](r[l](s))}}function ap(n,t){return t.domain(n.domain()).range(n.range()).interpolate(n.interpolate()).clamp(n.clamp()).unknown(n.unknown())}function Yv(){var i,r,o,s,l,c,n=xJ,t=xJ,e=tm,a=Ya;function d(){return s=Math.min(n.length,t.length)>2?aDe:oDe,l=c=null,u}function u(p){return isNaN(p=+p)?o:(l||(l=s(n.map(i),t,e)))(i(a(p)))}return u.invert=function(p){return a(r((c||(c=s(t,n.map(i),Vo)))(p)))},u.domain=function(p){return arguments.length?(n=qv.call(p,e3),a===Ya||(a=CJ(n)),d()):n.slice()},u.range=function(p){return arguments.length?(t=am.call(p),d()):t.slice()},u.rangeRound=function(p){return t=am.call(p),e=kN,d()},u.clamp=function(p){return arguments.length?(a=p?CJ(n):Ya,u):a!==Ya},u.interpolate=function(p){return arguments.length?(e=p,d()):e},u.unknown=function(p){return arguments.length?(o=p,u):o},function(p,f){return i=p,r=f,d()}}function Xv(n,t){return Yv()(n,t)}function Ul(){var n=Xv(Ya,Ya);return n.copy=function(){return ap(n,Ul())},qa.apply(n,arguments),function(n){var t=n.domain;return n.ticks=function(e){var i=t();return Dv(i[0],i[i.length-1],e??10)},n.tickFormat=function(e,i){var r=t();return function(n,t,e,i){var o,r=Ad(n,t,e);switch((i=op(i??",f")).type){case"s":var a=Math.max(Math.abs(n),Math.abs(t));return null==i.precision&&!isNaN(o=function(n,t){return Math.max(0,3*Math.max(-8,Math.min(8,Math.floor(zc(t)/3)))-zc(Math.abs(n)))}(r,a))&&(i.precision=o),ID(i,a);case"":case"e":case"g":case"p":case"r":null==i.precision&&!isNaN(o=function(n,t){return n=Math.abs(n),t=Math.abs(t)-n,Math.max(0,zc(t)-zc(n))+1}(r,Math.max(Math.abs(n),Math.abs(t))))&&(i.precision=o-("e"===i.type));break;case"f":case"%":null==i.precision&&!isNaN(o=function(n){return Math.max(0,-zc(Math.abs(n)))}(r))&&(i.precision=o-2*("%"===i.type))}return Jr(i)}(r[0],r[r.length-1],e??10,i)},n.nice=function(e){null==e&&(e=10);var l,i=t(),r=0,o=i.length-1,a=i[r],s=i[o];return s<a&&(l=a,a=s,s=l,l=r,r=o,o=l),(l=c0(a,s,e))>0?l=c0(a=Math.floor(a/l)*l,s=Math.ceil(s/l)*l,e):l<0&&(l=c0(a=Math.ceil(a*l)/l,s=Math.floor(s*l)/l,e)),l>0?(i[r]=Math.floor(a/l)*l,i[o]=Math.ceil(s/l)*l,t(i)):l<0&&(i[r]=Math.ceil(a*l)/l,i[o]=Math.floor(s*l)/l,t(i)),n},n}(n)}function AD(n,t){var a,e=0,i=(n=n.slice()).length-1,r=n[e],o=n[i];return o<r&&(a=e,e=i,i=a,a=r,r=o,o=a),n[e]=t.floor(r),n[i]=t.ceil(o),n}function MJ(n){return Math.log(n)}function wJ(n){return Math.exp(n)}function sDe(n){return-Math.log(-n)}function lDe(n){return-Math.exp(-n)}function cDe(n){return isFinite(n)?+("1e"+n):n<0?0:n}function SJ(n){return function(t){return-n(-t)}}function Qv(){var n=function(n){var r,o,t=n(MJ,wJ),e=t.domain,i=10;function a(){return r=function(n){return n===Math.E?Math.log:10===n&&Math.log10||2===n&&Math.log2||(n=Math.log(n),function(t){return Math.log(t)/n})}(i),o=function(n){return 10===n?cDe:n===Math.E?Math.exp:function(t){return Math.pow(n,t)}}(i),e()[0]<0?(r=SJ(r),o=SJ(o),n(sDe,lDe)):n(MJ,wJ),t}return t.base=function(s){return arguments.length?(i=+s,a()):i},t.domain=function(s){return arguments.length?(e(s),a()):e()},t.ticks=function(s){var u,l=e(),c=l[0],d=l[l.length-1];(u=d<c)&&(p=c,c=d,d=p);var m,y,M,p=r(c),f=r(d),v=null==s?10:+s,x=[];if(!(i%1)&&f-p<v){if(p=Math.round(p)-1,f=Math.round(f)+1,c>0){for(;p<f;++p)for(y=1,m=o(p);y<i;++y)if(!((M=m*y)<c)){if(M>d)break;x.push(M)}}else for(;p<f;++p)for(y=i-1,m=o(p);y>=1;--y)if(!((M=m*y)<c)){if(M>d)break;x.push(M)}}else x=Dv(p,f,Math.min(f-p,v)).map(o);return u?x.reverse():x},t.tickFormat=function(s,l){if(null==l&&(l=10===i?".0e":","),"function"!=typeof l&&(l=Jr(l)),s===1/0)return l;null==s&&(s=10);var c=Math.max(1,i*s/t.ticks().length);return function(d){var u=d/o(Math.round(r(d)));return u*i<i-.5&&(u*=i),u<=c?l(d):""}},t.nice=function(){return e(AD(e(),{floor:function(s){return o(Math.floor(r(s)))},ceil:function(s){return o(Math.ceil(r(s)))}}))},t}(Yv()).domain([1,10]);return n.copy=function(){return ap(n,Qv()).base(n.base())},qa.apply(n,arguments),n}var r3=new Date,o3=new Date;function rr(n,t,e,i){function r(o){return n(o=0===arguments.length?new Date:new Date(+o)),o}return r.floor=function(o){return n(o=new Date(+o)),o},r.ceil=function(o){return n(o=new Date(o-1)),t(o,1),n(o),o},r.round=function(o){var a=r(o),s=r.ceil(o);return o-a<s-o?a:s},r.offset=function(o,a){return t(o=new Date(+o),null==a?1:Math.floor(a)),o},r.range=function(o,a,s){var c,l=[];if(o=r.ceil(o),s=null==s?1:Math.floor(s),!(o<a&&s>0))return l;do{l.push(c=new Date(+o)),t(o,s),n(o)}while(c<o&&o<a);return l},r.filter=function(o){return rr(function(a){if(a>=a)for(;n(a),!o(a);)a.setTime(a-1)},function(a,s){if(a>=a)if(s<0)for(;++s<=0;)for(;t(a,-1),!o(a););else for(;--s>=0;)for(;t(a,1),!o(a););})},e&&(r.count=function(o,a){return r3.setTime(+o),o3.setTime(+a),n(r3),n(o3),Math.floor(e(r3,o3))},r.every=function(o){return o=Math.floor(o),isFinite(o)&&o>0?o>1?r.filter(i?function(a){return i(a)%o==0}:function(a){return r.count(0,a)%o==0}):r:null}),r}var RD=rr(function(){},function(n,t){n.setTime(+n+t)},function(n,t){return t-n});RD.every=function(n){return n=Math.floor(n),isFinite(n)&&n>0?n>1?rr(function(t){t.setTime(Math.floor(t/n)*n)},function(t,e){t.setTime(+t+e*n)},function(t,e){return(e-t)/n}):RD:null};var kD=RD,Od=6e4,OD=6048e5,TJ=rr(function(n){n.setTime(n-n.getMilliseconds())},function(n,t){n.setTime(+n+1e3*t)},function(n,t){return(t-n)/1e3},function(n){return n.getUTCSeconds()}),FD=TJ,IJ=rr(function(n){n.setTime(n-n.getMilliseconds()-1e3*n.getSeconds())},function(n,t){n.setTime(+n+t*Od)},function(n,t){return(t-n)/Od},function(n){return n.getMinutes()}),s3=IJ,AJ=rr(function(n){n.setTime(n-n.getMilliseconds()-1e3*n.getSeconds()-n.getMinutes()*Od)},function(n,t){n.setTime(+n+36e5*t)},function(n,t){return(t-n)/36e5},function(n){return n.getHours()}),l3=AJ,RJ=rr(function(n){n.setHours(0,0,0,0)},function(n,t){n.setDate(n.getDate()+t)},function(n,t){return(t-n-(t.getTimezoneOffset()-n.getTimezoneOffset())*Od)/864e5},function(n){return n.getDate()-1}),b0=RJ;function cm(n){return rr(function(t){t.setDate(t.getDate()-(t.getDay()+7-n)%7),t.setHours(0,0,0,0)},function(t,e){t.setDate(t.getDate()+7*e)},function(t,e){return(e-t-(e.getTimezoneOffset()-t.getTimezoneOffset())*Od)/OD})}var dm=cm(0),v0=cm(1),sp=(cm(2),cm(3),cm(4)),NJ=(cm(5),cm(6),rr(function(n){n.setDate(1),n.setHours(0,0,0,0)},function(n,t){n.setMonth(n.getMonth()+t)},function(n,t){return t.getMonth()-n.getMonth()+12*(t.getFullYear()-n.getFullYear())},function(n){return n.getMonth()})),c3=NJ,d3=rr(function(n){n.setMonth(0,1),n.setHours(0,0,0,0)},function(n,t){n.setFullYear(n.getFullYear()+t)},function(n,t){return t.getFullYear()-n.getFullYear()},function(n){return n.getFullYear()});d3.every=function(n){return isFinite(n=Math.floor(n))&&n>0?rr(function(t){t.setFullYear(Math.floor(t.getFullYear()/n)*n),t.setMonth(0,1),t.setHours(0,0,0,0)},function(t,e){t.setFullYear(t.getFullYear()+e*n)}):null};var Fd=d3,BJ=rr(function(n){n.setUTCHours(0,0,0,0)},function(n,t){n.setUTCDate(n.getUTCDate()+t)},function(n,t){return(t-n)/864e5},function(n){return n.getUTCDate()-1}),LD=BJ;function um(n){return rr(function(t){t.setUTCDate(t.getUTCDate()-(t.getUTCDay()+7-n)%7),t.setUTCHours(0,0,0,0)},function(t,e){t.setUTCDate(t.getUTCDate()+7*e)},function(t,e){return(e-t)/OD})}var Zv=um(0),x0=um(1),lp=(um(2),um(3),um(4)),u3=(um(5),um(6),rr(function(n){n.setUTCMonth(0,1),n.setUTCHours(0,0,0,0)},function(n,t){n.setUTCFullYear(n.getUTCFullYear()+t)},function(n,t){return t.getUTCFullYear()-n.getUTCFullYear()},function(n){return n.getUTCFullYear()}));u3.every=function(n){return isFinite(n=Math.floor(n))&&n>0?rr(function(t){t.setUTCFullYear(Math.floor(t.getUTCFullYear()/n)*n),t.setUTCMonth(0,1),t.setUTCHours(0,0,0,0)},function(t,e){t.setUTCFullYear(t.getUTCFullYear()+e*n)}):null};var pm=u3;function p3(n){if(0<=n.y&&n.y<100){var t=new Date(-1,n.m,n.d,n.H,n.M,n.S,n.L);return t.setFullYear(n.y),t}return new Date(n.y,n.m,n.d,n.H,n.M,n.S,n.L)}function f3(n){if(0<=n.y&&n.y<100){var t=new Date(Date.UTC(-1,n.m,n.d,n.H,n.M,n.S,n.L));return t.setUTCFullYear(n.y),t}return new Date(Date.UTC(n.y,n.m,n.d,n.H,n.M,n.S,n.L))}function Kv(n,t,e){return{y:n,m:t,d:e,H:0,M:0,S:0,L:0}}var C0,M0,GJ={"-":"",_:" ",0:"0"},Do=/^\s*\d+/,RDe=/^%/,kDe=/[\\^$*+?|[\]().{}]/g;function Fi(n,t,e){var i=n<0?"-":"",r=(i?-n:n)+"",o=r.length;return i+(o<e?new Array(e-o+1).join(t)+r:r)}function PDe(n){return n.replace(kDe,"\\$&")}function Jv(n){return new RegExp("^(?:"+n.map(PDe).join("|")+")","i")}function $v(n){for(var t={},e=-1,i=n.length;++e<i;)t[n[e].toLowerCase()]=e;return t}function ODe(n,t,e){var i=Do.exec(t.slice(e,e+1));return i?(n.w=+i[0],e+i[0].length):-1}function FDe(n,t,e){var i=Do.exec(t.slice(e,e+1));return i?(n.u=+i[0],e+i[0].length):-1}function LDe(n,t,e){var i=Do.exec(t.slice(e,e+2));return i?(n.U=+i[0],e+i[0].length):-1}function NDe(n,t,e){var i=Do.exec(t.slice(e,e+2));return i?(n.V=+i[0],e+i[0].length):-1}function BDe(n,t,e){var i=Do.exec(t.slice(e,e+2));return i?(n.W=+i[0],e+i[0].length):-1}function WJ(n,t,e){var i=Do.exec(t.slice(e,e+4));return i?(n.y=+i[0],e+i[0].length):-1}function qJ(n,t,e){var i=Do.exec(t.slice(e,e+2));return i?(n.y=+i[0]+(+i[0]>68?1900:2e3),e+i[0].length):-1}function VDe(n,t,e){var i=/^(Z)|([+-]\d\d)(?::?(\d\d))?/.exec(t.slice(e,e+6));return i?(n.Z=i[1]?0:-(i[2]+(i[3]||"00")),e+i[0].length):-1}function HDe(n,t,e){var i=Do.exec(t.slice(e,e+1));return i?(n.q=3*i[0]-3,e+i[0].length):-1}function zDe(n,t,e){var i=Do.exec(t.slice(e,e+2));return i?(n.m=i[0]-1,e+i[0].length):-1}function YJ(n,t,e){var i=Do.exec(t.slice(e,e+2));return i?(n.d=+i[0],e+i[0].length):-1}function UDe(n,t,e){var i=Do.exec(t.slice(e,e+3));return i?(n.m=0,n.d=+i[0],e+i[0].length):-1}function XJ(n,t,e){var i=Do.exec(t.slice(e,e+2));return i?(n.H=+i[0],e+i[0].length):-1}function jDe(n,t,e){var i=Do.exec(t.slice(e,e+2));return i?(n.M=+i[0],e+i[0].length):-1}function GDe(n,t,e){var i=Do.exec(t.slice(e,e+2));return i?(n.S=+i[0],e+i[0].length):-1}function WDe(n,t,e){var i=Do.exec(t.slice(e,e+3));return i?(n.L=+i[0],e+i[0].length):-1}function qDe(n,t,e){var i=Do.exec(t.slice(e,e+6));return i?(n.L=Math.floor(i[0]/1e3),e+i[0].length):-1}function YDe(n,t,e){var i=RDe.exec(t.slice(e,e+1));return i?e+i[0].length:-1}function XDe(n,t,e){var i=Do.exec(t.slice(e));return i?(n.Q=+i[0],e+i[0].length):-1}function QDe(n,t,e){var i=Do.exec(t.slice(e));return i?(n.s=+i[0],e+i[0].length):-1}function QJ(n,t){return Fi(n.getDate(),t,2)}function ZDe(n,t){return Fi(n.getHours(),t,2)}function KDe(n,t){return Fi(n.getHours()%12||12,t,2)}function JDe(n,t){return Fi(1+b0.count(Fd(n),n),t,3)}function e$(n,t){return Fi(n.getMilliseconds(),t,3)}function $De(n,t){return e$(n,t)+"000"}function eIe(n,t){return Fi(n.getMonth()+1,t,2)}function tIe(n,t){return Fi(n.getMinutes(),t,2)}function nIe(n,t){return Fi(n.getSeconds(),t,2)}function iIe(n){var t=n.getDay();return 0===t?7:t}function rIe(n,t){return Fi(dm.count(Fd(n)-1,n),t,2)}function t$(n){var t=n.getDay();return t>=4||0===t?sp(n):sp.ceil(n)}function oIe(n,t){return n=t$(n),Fi(sp.count(Fd(n),n)+(4===Fd(n).getDay()),t,2)}function aIe(n){return n.getDay()}function sIe(n,t){return Fi(v0.count(Fd(n)-1,n),t,2)}function lIe(n,t){return Fi(n.getFullYear()%100,t,2)}function cIe(n,t){return Fi((n=t$(n)).getFullYear()%100,t,2)}function dIe(n,t){return Fi(n.getFullYear()%1e4,t,4)}function uIe(n,t){var e=n.getDay();return Fi((n=e>=4||0===e?sp(n):sp.ceil(n)).getFullYear()%1e4,t,4)}function pIe(n){var t=n.getTimezoneOffset();return(t>0?"-":(t*=-1,"+"))+Fi(t/60|0,"0",2)+Fi(t%60,"0",2)}function ZJ(n,t){return Fi(n.getUTCDate(),t,2)}function fIe(n,t){return Fi(n.getUTCHours(),t,2)}function mIe(n,t){return Fi(n.getUTCHours()%12||12,t,2)}function hIe(n,t){return Fi(1+LD.count(pm(n),n),t,3)}function n$(n,t){return Fi(n.getUTCMilliseconds(),t,3)}function gIe(n,t){return n$(n,t)+"000"}function _Ie(n,t){return Fi(n.getUTCMonth()+1,t,2)}function yIe(n,t){return Fi(n.getUTCMinutes(),t,2)}function bIe(n,t){return Fi(n.getUTCSeconds(),t,2)}function vIe(n){var t=n.getUTCDay();return 0===t?7:t}function xIe(n,t){return Fi(Zv.count(pm(n)-1,n),t,2)}function i$(n){var t=n.getUTCDay();return t>=4||0===t?lp(n):lp.ceil(n)}function CIe(n,t){return n=i$(n),Fi(lp.count(pm(n),n)+(4===pm(n).getUTCDay()),t,2)}function MIe(n){return n.getUTCDay()}function wIe(n,t){return Fi(x0.count(pm(n)-1,n),t,2)}function SIe(n,t){return Fi(n.getUTCFullYear()%100,t,2)}function EIe(n,t){return Fi((n=i$(n)).getUTCFullYear()%100,t,2)}function TIe(n,t){return Fi(n.getUTCFullYear()%1e4,t,4)}function DIe(n,t){var e=n.getUTCDay();return Fi((n=e>=4||0===e?lp(n):lp.ceil(n)).getUTCFullYear()%1e4,t,4)}function IIe(){return"+0000"}function KJ(){return"%"}function JJ(n){return+n}function $J(n){return Math.floor(+n/1e3)}C0=function(n){var t=n.dateTime,e=n.date,i=n.time,r=n.periods,o=n.days,a=n.shortDays,s=n.months,l=n.shortMonths,c=Jv(r),d=$v(r),u=Jv(o),p=$v(o),f=Jv(a),m=$v(a),y=Jv(s),M=$v(s),v=Jv(l),x=$v(l),R={a:function(ve){return a[ve.getDay()]},A:function(ve){return o[ve.getDay()]},b:function(ve){return l[ve.getMonth()]},B:function(ve){return s[ve.getMonth()]},c:null,d:QJ,e:QJ,f:$De,g:cIe,G:uIe,H:ZDe,I:KDe,j:JDe,L:e$,m:eIe,M:tIe,p:function(ve){return r[+(ve.getHours()>=12)]},q:function(ve){return 1+~~(ve.getMonth()/3)},Q:JJ,s:$J,S:nIe,u:iIe,U:rIe,V:oIe,w:aIe,W:sIe,x:null,X:null,y:lIe,Y:dIe,Z:pIe,"%":KJ},A={a:function(ve){return a[ve.getUTCDay()]},A:function(ve){return o[ve.getUTCDay()]},b:function(ve){return l[ve.getUTCMonth()]},B:function(ve){return s[ve.getUTCMonth()]},c:null,d:ZJ,e:ZJ,f:gIe,g:EIe,G:DIe,H:fIe,I:mIe,j:hIe,L:n$,m:_Ie,M:yIe,p:function(ve){return r[+(ve.getUTCHours()>=12)]},q:function(ve){return 1+~~(ve.getUTCMonth()/3)},Q:JJ,s:$J,S:bIe,u:vIe,U:xIe,V:CIe,w:MIe,W:wIe,x:null,X:null,y:SIe,Y:TIe,Z:IIe,"%":KJ},H={a:function(ve,ht,mt){var oe=f.exec(ht.slice(mt));return oe?(ve.w=m[oe[0].toLowerCase()],mt+oe[0].length):-1},A:function(ve,ht,mt){var oe=u.exec(ht.slice(mt));return oe?(ve.w=p[oe[0].toLowerCase()],mt+oe[0].length):-1},b:function(ve,ht,mt){var oe=v.exec(ht.slice(mt));return oe?(ve.m=x[oe[0].toLowerCase()],mt+oe[0].length):-1},B:function(ve,ht,mt){var oe=y.exec(ht.slice(mt));return oe?(ve.m=M[oe[0].toLowerCase()],mt+oe[0].length):-1},c:function(ve,ht,mt){return Ce(ve,t,ht,mt)},d:YJ,e:YJ,f:qDe,g:qJ,G:WJ,H:XJ,I:XJ,j:UDe,L:WDe,m:zDe,M:jDe,p:function(ve,ht,mt){var oe=c.exec(ht.slice(mt));return oe?(ve.p=d[oe[0].toLowerCase()],mt+oe[0].length):-1},q:HDe,Q:XDe,s:QDe,S:GDe,u:FDe,U:LDe,V:NDe,w:ODe,W:BDe,x:function(ve,ht,mt){return Ce(ve,e,ht,mt)},X:function(ve,ht,mt){return Ce(ve,i,ht,mt)},y:qJ,Y:WJ,Z:VDe,"%":YDe};function te(ve,ht){return function(mt){var pt,on,wn,oe=[],st=-1,Xe=0,_t=ve.length;for(mt instanceof Date||(mt=new Date(+mt));++st<_t;)37===ve.charCodeAt(st)&&(oe.push(ve.slice(Xe,st)),null!=(on=GJ[pt=ve.charAt(++st)])?pt=ve.charAt(++st):on="e"===pt?" ":"0",(wn=ht[pt])&&(pt=wn(mt,on)),oe.push(pt),Xe=st+1);return oe.push(ve.slice(Xe,st)),oe.join("")}}function K(ve,ht){return function(mt){var Xe,_t,oe=Kv(1900,void 0,1);if(Ce(oe,ve,mt+="",0)!=mt.length)return null;if("Q"in oe)return new Date(oe.Q);if("s"in oe)return new Date(1e3*oe.s+("L"in oe?oe.L:0));if(ht&&!("Z"in oe)&&(oe.Z=0),"p"in oe&&(oe.H=oe.H%12+12*oe.p),void 0===oe.m&&(oe.m="q"in oe?oe.q:0),"V"in oe){if(oe.V<1||oe.V>53)return null;"w"in oe||(oe.w=1),"Z"in oe?(_t=(Xe=f3(Kv(oe.y,0,1))).getUTCDay(),Xe=_t>4||0===_t?x0.ceil(Xe):x0(Xe),Xe=LD.offset(Xe,7*(oe.V-1)),oe.y=Xe.getUTCFullYear(),oe.m=Xe.getUTCMonth(),oe.d=Xe.getUTCDate()+(oe.w+6)%7):(_t=(Xe=p3(Kv(oe.y,0,1))).getDay(),Xe=_t>4||0===_t?v0.ceil(Xe):v0(Xe),Xe=b0.offset(Xe,7*(oe.V-1)),oe.y=Xe.getFullYear(),oe.m=Xe.getMonth(),oe.d=Xe.getDate()+(oe.w+6)%7)}else("W"in oe||"U"in oe)&&("w"in oe||(oe.w="u"in oe?oe.u%7:"W"in oe?1:0),_t="Z"in oe?f3(Kv(oe.y,0,1)).getUTCDay():p3(Kv(oe.y,0,1)).getDay(),oe.m=0,oe.d="W"in oe?(oe.w+6)%7+7*oe.W-(_t+5)%7:oe.w+7*oe.U-(_t+6)%7);return"Z"in oe?(oe.H+=oe.Z/100|0,oe.M+=oe.Z%100,f3(oe)):p3(oe)}}function Ce(ve,ht,mt,oe){for(var pt,on,st=0,Xe=ht.length,_t=mt.length;st<Xe;){if(oe>=_t)return-1;if(37===(pt=ht.charCodeAt(st++))){if(pt=ht.charAt(st++),!(on=H[pt in GJ?ht.charAt(st++):pt])||(oe=on(ve,mt,oe))<0)return-1}else if(pt!=mt.charCodeAt(oe++))return-1}return oe}return R.x=te(e,R),R.X=te(i,R),R.c=te(t,R),A.x=te(e,A),A.X=te(i,A),A.c=te(t,A),{format:function(ve){var ht=te(ve+="",R);return ht.toString=function(){return ve},ht},parse:function(ve){var ht=K(ve+="",!1);return ht.toString=function(){return ve},ht},utcFormat:function(ve){var ht=te(ve+="",A);return ht.toString=function(){return ve},ht},utcParse:function(ve){var ht=K(ve+="",!0);return ht.toString=function(){return ve},ht}}}({dateTime:"%x, %X",date:"%-m/%-d/%Y",time:"%-I:%M:%S %p",periods:["AM","PM"],days:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],shortDays:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],months:["January","February","March","April","May","June","July","August","September","October","November","December"],shortMonths:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]}),M0=C0.format;var ex=1e3,tx=60*ex,nx=60*tx,ix=24*nx,AIe=7*ix,s$=30*ix,g3=365*ix;function RIe(n){return new Date(n)}function kIe(n){return n instanceof Date?+n:+new Date(+n)}function _3(n,t,e,i,r,o,a,s,l){var c=Xv(Ya,Ya),d=c.invert,u=c.domain,p=l(".%L"),f=l(":%S"),m=l("%I:%M"),y=l("%I %p"),M=l("%a %d"),v=l("%b %d"),x=l("%B"),R=l("%Y"),A=[[a,1,ex],[a,5,5*ex],[a,15,15*ex],[a,30,30*ex],[o,1,tx],[o,5,5*tx],[o,15,15*tx],[o,30,30*tx],[r,1,nx],[r,3,3*nx],[r,6,6*nx],[r,12,12*nx],[i,1,ix],[i,2,2*ix],[e,1,AIe],[t,1,s$],[t,3,3*s$],[n,1,g3]];function H(K){return(a(K)<K?p:o(K)<K?f:r(K)<K?m:i(K)<K?y:t(K)<K?e(K)<K?M:v:n(K)<K?x:R)(K)}function te(K,Ce,Ze,Ie){if(null==K&&(K=10),"number"==typeof K){var I=Math.abs(Ze-Ce)/K,re=Tv(function(ce){return ce[2]}).right(A,I);re===A.length?(Ie=Ad(Ce/g3,Ze/g3,K),K=n):re?(Ie=(re=A[I/A[re-1][2]<A[re][2]/I?re-1:re])[1],K=re[0]):(Ie=Math.max(Ad(Ce,Ze,K),1),K=s)}return null==Ie?K:K.every(Ie)}return c.invert=function(K){return new Date(d(K))},c.domain=function(K){return arguments.length?u(qv.call(K,kIe)):u().map(RIe)},c.ticks=function(K,Ce){var ce,Ze=u(),Ie=Ze[0],I=Ze[Ze.length-1],re=I<Ie;return re&&(ce=Ie,Ie=I,I=ce),ce=(ce=te(K,Ie,I,Ce))?ce.range(Ie,I+1):[],re?ce.reverse():ce},c.tickFormat=function(K,Ce){return null==Ce?H:l(Ce)},c.nice=function(K,Ce){var Ze=u();return(K=te(K,Ze[0],Ze[Ze.length-1],Ce))?u(AD(Ze,K)):c},c.copy=function(){return ap(c,_3(n,t,e,i,r,o,a,s,l))},c}function fm(){return qa.apply(_3(Fd,c3,dm,b0,l3,s3,FD,kD,M0).domain([new Date(2e3,0,1),new Date(2e3,0,2)]),arguments)}function y3(){this._=null}function w0(n){n.U=n.C=n.L=n.R=n.P=n.N=null}function rx(n,t){var e=t,i=t.R,r=e.U;r?r.L===e?r.L=i:r.R=i:n._=i,i.U=r,e.U=i,e.R=i.L,e.R&&(e.R.U=e),i.L=e}function ox(n,t){var e=t,i=t.L,r=e.U;r?r.L===e?r.L=i:r.R=i:n._=i,i.U=r,e.U=i,e.L=i.R,e.L&&(e.L.U=e),i.R=e}function c$(n){for(;n.L;)n=n.L;return n}y3.prototype={constructor:y3,insert:function(n,t){var e,i,r;if(n){if(t.P=n,t.N=n.N,n.N&&(n.N.P=t),n.N=t,n.R){for(n=n.R;n.L;)n=n.L;n.L=t}else n.R=t;e=n}else this._?(n=c$(this._),t.P=null,t.N=n,n.P=n.L=t,e=n):(t.P=t.N=null,this._=t,e=null);for(t.L=t.R=null,t.U=e,t.C=!0,n=t;e&&e.C;)e===(i=e.U).L?(r=i.R)&&r.C?(e.C=r.C=!1,i.C=!0,n=i):(n===e.R&&(rx(this,e),e=(n=e).U),e.C=!1,i.C=!0,ox(this,i)):(r=i.L)&&r.C?(e.C=r.C=!1,i.C=!0,n=i):(n===e.L&&(ox(this,e),e=(n=e).U),e.C=!1,i.C=!0,rx(this,i)),e=n.U;this._.C=!1},remove:function(n){n.N&&(n.N.P=n.P),n.P&&(n.P.N=n.N),n.N=n.P=null;var e,o,a,t=n.U,i=n.L,r=n.R;if(o=i?r?c$(r):i:r,t?t.L===n?t.L=o:t.R=o:this._=o,i&&r?(a=o.C,o.C=n.C,o.L=i,i.U=o,o!==r?(t=o.U,o.U=n.U,t.L=n=o.R,o.R=r,r.U=o):(o.U=t,t=o,n=o.R)):(a=n.C,n=o),n&&(n.U=t),!a){if(n&&n.C)return void(n.C=!1);do{if(n===this._)break;if(n===t.L){if((e=t.R).C&&(e.C=!1,t.C=!0,rx(this,t),e=t.R),e.L&&e.L.C||e.R&&e.R.C){(!e.R||!e.R.C)&&(e.L.C=!1,e.C=!0,ox(this,e),e=t.R),e.C=t.C,t.C=e.R.C=!1,rx(this,t),n=this._;break}}else if((e=t.L).C&&(e.C=!1,t.C=!0,ox(this,t),e=t.L),e.L&&e.L.C||e.R&&e.R.C){(!e.L||!e.L.C)&&(e.R.C=!1,e.C=!0,rx(this,e),e=t.L),e.C=t.C,t.C=e.L.C=!1,ox(this,t),n=this._;break}e.C=!0,n=t,t=t.U}while(!n.C);n&&(n.C=!1)}}};var b3=y3;function S0(n,t,e,i){var r=[null,null],o=Io.push(r)-1;return r.left=n,r.right=t,e&&ax(r,n,t,e),i&&ax(r,t,n,i),ya[n.index].halfedges.push(o),ya[t.index].halfedges.push(o),r}function E0(n,t,e){var i=[t,e];return i.left=n,i}function ax(n,t,e,i){n[0]||n[1]?n.left===e?n[1]=i:n[0]=i:(n[0]=i,n.left=t,n.right=e)}function FIe(n,t,e,i,r){var y,o=n[0],a=n[1],s=o[0],l=o[1],u=0,p=1,f=a[0]-s,m=a[1]-l;if(y=t-s,f||!(y>0)){if(y/=f,f<0){if(y<u)return;y<p&&(p=y)}else if(f>0){if(y>p)return;y>u&&(u=y)}if(y=i-s,f||!(y<0)){if(y/=f,f<0){if(y>p)return;y>u&&(u=y)}else if(f>0){if(y<u)return;y<p&&(p=y)}if(y=e-l,m||!(y>0)){if(y/=m,m<0){if(y<u)return;y<p&&(p=y)}else if(m>0){if(y>p)return;y>u&&(u=y)}if(y=r-l,m||!(y<0)){if(y/=m,m<0){if(y>p)return;y>u&&(u=y)}else if(m>0){if(y<u)return;y<p&&(p=y)}return!(u>0)&&!(p<1)||(u>0&&(n[0]=[s+u*f,l+u*m]),p<1&&(n[1]=[s+p*f,l+p*m])),!0}}}}}function LIe(n,t,e,i,r){var o=n[1];if(o)return!0;var y,M,a=n[0],s=n.left,l=n.right,c=s[0],d=s[1],u=l[0],p=l[1],f=(c+u)/2;if(p===d){if(f<t||f>=i)return;if(c>u){if(a){if(a[1]>=r)return}else a=[f,e];o=[f,r]}else{if(a){if(a[1]<e)return}else a=[f,r];o=[f,e]}}else if(M=(d+p)/2-(y=(c-u)/(p-d))*f,y<-1||y>1)if(c>u){if(a){if(a[1]>=r)return}else a=[(e-M)/y,e];o=[(r-M)/y,r]}else{if(a){if(a[1]<e)return}else a=[(r-M)/y,r];o=[(e-M)/y,e]}else if(d<p){if(a){if(a[0]>=i)return}else a=[t,y*t+M];o=[i,y*i+M]}else{if(a){if(a[0]<t)return}else a=[i,y*i+M];o=[t,y*t+M]}return n[0]=a,n[1]=o,!0}function NIe(n,t){var e=n.site,i=t.left,r=t.right;return e===r&&(r=i,i=e),r?Math.atan2(r[1]-i[1],r[0]-i[0]):(e===i?(i=t[1],r=t[0]):(i=t[0],r=t[1]),Math.atan2(i[0]-r[0],r[1]-i[1]))}function v3(n,t){return t[+(t.left!==n.site)]}function BIe(n,t){return t[+(t.left===n.site)]}var ND,m$=[];function VIe(){w0(this),this.x=this.y=this.arc=this.site=this.cy=null}function mm(n){var t=n.P,e=n.N;if(t&&e){var i=t.site,r=n.site,o=e.site;if(i!==o){var a=r[0],s=r[1],l=i[0]-a,c=i[1]-s,d=o[0]-a,u=o[1]-s,p=2*(l*u-c*d);if(!(p>=-h$)){var f=l*l+c*c,m=d*d+u*u,y=(u*f-c*m)/p,M=(l*m-d*f)/p,v=m$.pop()||new VIe;v.arc=n,v.site=r,v.x=y+a,v.y=(v.cy=M+s)+Math.sqrt(y*y+M*M),n.circle=v;for(var x=null,R=T0._;R;)if(v.y<R.y||v.y===R.y&&v.x<=R.x){if(!R.L){x=R.P;break}R=R.L}else{if(!R.R){x=R;break}R=R.R}T0.insert(x,v),x||(ND=v)}}}}function hm(n){var t=n.circle;t&&(t.P||(ND=t.N),T0.remove(t),m$.push(t),w0(t),n.circle=null)}var _$=[];function HIe(){w0(this),this.edge=this.site=this.circle=null}function g$(n){var t=_$.pop()||new HIe;return t.site=n,t}function x3(n){hm(n),gm.remove(n),_$.push(n),w0(n)}function y$(n){var t=n.circle,e=t.x,i=t.cy,r=[e,i],o=n.P,a=n.N,s=[n];x3(n);for(var l=o;l.circle&&Math.abs(e-l.circle.x)<tr&&Math.abs(i-l.circle.cy)<tr;)o=l.P,s.unshift(l),x3(l),l=o;s.unshift(l),hm(l);for(var c=a;c.circle&&Math.abs(e-c.circle.x)<tr&&Math.abs(i-c.circle.cy)<tr;)a=c.N,s.push(c),x3(c),c=a;s.push(c),hm(c);var u,d=s.length;for(u=1;u<d;++u)ax((c=s[u]).edge,(l=s[u-1]).site,c.site,r);(c=s[d-1]).edge=S0((l=s[0]).site,c.site,null,r),mm(l),mm(c)}function b$(n){for(var i,r,o,a,t=n[0],e=n[1],s=gm._;s;)if((o=v$(s,e)-t)>tr)s=s.L;else{if(!((a=t-zIe(s,e))>tr)){o>-tr?(i=s.P,r=s):a>-tr?(i=s,r=s.N):i=r=s;break}if(!s.R){i=s;break}s=s.R}!function(n){ya[n.index]={site:n,halfedges:[]}}(n);var l=g$(n);if(gm.insert(i,l),i||r){if(i===r)return hm(i),r=g$(i.site),gm.insert(l,r),l.edge=r.edge=S0(i.site,l.site),mm(i),void mm(r);if(!r)return void(l.edge=S0(i.site,l.site));hm(i),hm(r);var c=i.site,d=c[0],u=c[1],p=n[0]-d,f=n[1]-u,m=r.site,y=m[0]-d,M=m[1]-u,v=2*(p*M-f*y),x=p*p+f*f,R=y*y+M*M,A=[(M*x-f*R)/v+d,(p*R-y*x)/v+u];ax(r.edge,c,m,A),l.edge=S0(c,n,null,A),r.edge=S0(n,m,null,A),mm(i),mm(r)}}function v$(n,t){var e=n.site,i=e[0],r=e[1],o=r-t;if(!o)return i;var a=n.P;if(!a)return-1/0;var s=(e=a.site)[0],l=e[1],c=l-t;if(!c)return s;var d=s-i,u=1/o-1/c,p=d/c;return u?(-p+Math.sqrt(p*p-2*u*(d*d/(-2*c)-l+c/2+r-o/2)))/u+i:(i+s)/2}function zIe(n,t){var e=n.N;if(e)return v$(e,t);var i=n.site;return i[1]===t?i[0]:1/0}var gm,ya,T0,Io,tr=1e-6,h$=1e-12;function UIe(n,t,e){return(n[0]-e[0])*(t[1]-n[1])-(n[0]-t[0])*(e[1]-n[1])}function jIe(n,t){return t[1]-n[1]||t[0]-n[0]}function BD(n,t){var i,r,o,e=n.sort(jIe).pop();for(Io=[],ya=new Array(n.length),gm=new b3,T0=new b3;;)if(o=ND,e&&(!o||e[1]<o.y||e[1]===o.y&&e[0]<o.x))(e[0]!==i||e[1]!==r)&&(b$(e),i=e[0],r=e[1]),e=n.pop();else{if(!o)break;y$(o.arc)}if(function(){for(var e,i,r,o,n=0,t=ya.length;n<t;++n)if((e=ya[n])&&(o=(i=e.halfedges).length)){var a=new Array(o),s=new Array(o);for(r=0;r<o;++r)a[r]=r,s[r]=NIe(e,Io[i[r]]);for(a.sort(function(l,c){return s[c]-s[l]}),r=0;r<o;++r)s[r]=i[a[r]];for(r=0;r<o;++r)i[r]=s[r]}}(),t){var a=+t[0][0],s=+t[0][1],l=+t[1][0],c=+t[1][1];(function(n,t,e,i){for(var o,r=Io.length;r--;)LIe(o=Io[r],n,t,e,i)&&FIe(o,n,t,e,i)&&(Math.abs(o[0][0]-o[1][0])>tr||Math.abs(o[0][1]-o[1][1])>tr)||delete Io[r]})(a,s,l,c),function(n,t,e,i){var o,a,s,l,c,d,u,p,f,m,y,M,r=ya.length,v=!0;for(o=0;o<r;++o)if(a=ya[o]){for(s=a.site,l=(c=a.halfedges).length;l--;)Io[c[l]]||c.splice(l,1);for(l=0,d=c.length;l<d;)y=(m=BIe(a,Io[c[l]]))[0],M=m[1],p=(u=v3(a,Io[c[++l%d]]))[0],f=u[1],(Math.abs(y-p)>tr||Math.abs(M-f)>tr)&&(c.splice(l,0,Io.push(E0(s,m,Math.abs(y-n)<tr&&i-M>tr?[n,Math.abs(p-n)<tr?f:i]:Math.abs(M-i)<tr&&e-y>tr?[Math.abs(f-i)<tr?p:e,i]:Math.abs(y-e)<tr&&M-t>tr?[e,Math.abs(p-e)<tr?f:t]:Math.abs(M-t)<tr&&y-n>tr?[Math.abs(f-t)<tr?p:n,t]:null))-1),++d);d&&(v=!1)}if(v){var x,R,A,H=1/0;for(o=0,v=null;o<r;++o)(a=ya[o])&&(A=(x=(s=a.site)[0]-n)*x+(R=s[1]-t)*R)<H&&(H=A,v=a);if(v){var te=[n,t],K=[n,i],Ce=[e,i],Ze=[e,t];v.halfedges.push(Io.push(E0(s=v.site,te,K))-1,Io.push(E0(s,K,Ce))-1,Io.push(E0(s,Ce,Ze))-1,Io.push(E0(s,Ze,te))-1)}}for(o=0;o<r;++o)(a=ya[o])&&(a.halfedges.length||delete ya[o])}(a,s,l,c)}this.edges=Io,this.cells=ya,gm=T0=Io=ya=null}function _m(n,t,e){this.k=n,this.x=t,this.y=e}BD.prototype={constructor:BD,polygons:function(){var n=this.edges;return this.cells.map(function(t){var e=t.halfedges.map(function(i){return v3(t,n[i])});return e.data=t.site.data,e})},triangles:function(){var n=[],t=this.edges;return this.cells.forEach(function(e,i){if(s=(o=e.halfedges).length)for(var o,s,l,r=e.site,a=-1,c=t[o[s-1]],d=c.left===r?c.right:c.left;++a<s;)l=d,d=(c=t[o[a]]).left===r?c.right:c.left,l&&d&&i<l.index&&i<d.index&&UIe(r,l,d)<0&&n.push([r.data,l.data,d.data])}),n},links:function(){return this.edges.filter(function(n){return n.right}).map(function(n){return{source:n.left.data,target:n.right.data}})},find:function(n,t,e){for(var r,s,i=this,o=i._found||0,a=i.cells.length;!(s=i.cells[o]);)if(++o>=a)return null;var l=n-s.site[0],c=t-s.site[1],d=l*l+c*c;do{s=i.cells[r=o],o=null,s.halfedges.forEach(function(u){var p=i.edges[u],f=p.left;if(f!==s.site&&f||(f=p.right)){var m=n-f[0],y=t-f[1],M=m*m+y*y;M<d&&(d=M,o=f.index)}})}while(null!==o);return i._found=r,null==e||d<=e*e?s.site:null}},_m.prototype={constructor:_m,scale:function(n){return 1===n?this:new _m(this.k*n,this.x,this.y)},translate:function(n,t){return 0===n&0===t?this:new _m(this.k,this.x+this.k*n,this.y+this.k*t)},apply:function(n){return[n[0]*this.k+this.x,n[1]*this.k+this.y]},applyX:function(n){return n*this.k+this.x},applyY:function(n){return n*this.k+this.y},invert:function(n){return[(n[0]-this.x)/this.k,(n[1]-this.y)/this.k]},invertX:function(n){return(n-this.x)/this.k},invertY:function(n){return(n-this.y)/this.k},rescaleX:function(n){return n.copy().domain(n.range().map(this.invertX,this).map(n.invert,n))},rescaleY:function(n){return n.copy().domain(n.range().map(this.invertY,this).map(n.invert,n))},toString:function(){return"translate("+this.x+","+this.y+") scale("+this.k+")"}},new _m(1,0,0);var A3=1e4,R3=.001,w$=Jr(".2~e"),GIe=Jr(".4~r"),x$=Jr(",~");function C$(n){if(0===n)return"0";let t=Math.abs(n);return t>=A3||t<R3?w$(n):GIe(n)}var cp={formatTick:C$,formatShort:C$,formatReadable(n){let t=Math.abs(n);return t>=A3||t<R3?w$(n):x$(n)},formatLong:x$},WIe=new Intl.NumberFormat(void 0,{maximumFractionDigits:4});function VD(n){return WIe.format(n)}var I0={formatTick:VD,formatShort:VD,formatReadable:VD,formatLong:VD},qIe=Jr("0.3~s"),YIe=Jr(",.3~f");function HD(n){let t=Math.abs(n);return t>=A3||t<R3?qIe(n):YIe(n)}var k3={formatTick:HD,formatShort:HD,formatReadable:HD,formatLong:HD},E3=1e3,T3=60*E3,D3=60*T3,I3=24*D3,M$=365*I3,D0=Jr(".4~");function zD(n){if(0===n)return"0";let t=Math.sign(n)>0?"":"-",e=Math.abs(n);return t+=e<E3?`${D0(e)} ms`:e<T3?`${D0(e/E3)} sec`:e<D3?`${D0(e/T3)} min`:e<I3?`${D0(e/D3)} hr`:e<M$?`${D0(e/I3)} day`:`${D0(e/M$)} yr`,t}var S3,A0={formatTick:zD,formatShort:zD,formatReadable:zD,formatLong:zD},XIe=fm().tickFormat(),S$={formatTick:n=>XIe(new Date(n)),formatShort:n=>new Date(n).toLocaleString(S3,{year:"numeric",month:"short",day:"numeric",hour:"numeric",minute:"numeric",second:"numeric"}),formatReadable:n=>new Date(n).toLocaleString(S3,{year:"numeric",month:"short",day:"numeric",hour:"numeric",minute:"numeric",second:"numeric",timeZoneName:"short"}),formatLong:n=>new Date(n).toLocaleString(S3,{year:"numeric",month:"long",day:"numeric",hour:"numeric",minute:"numeric",second:"numeric",timeZoneName:"short",fractionalSecondDigits:3})};function jl(n){switch(n){case ir.LINEAR:return new sx;case ir.LOG10:return new P3;case ir.TIME:return new lx;default:throw new RangeError(`ScaleType ${n} not supported.`)}}var sx=class{constructor(){this.defaultFormatter=cp}transform(t,e,i){let[r,o]=t,a=o-r,[s,l]=e;return 0===a?s:(l-s)/a*(i-r)+s}forward(t,e,i){return this.transform(t,e,i)}reverse(t,e,i){return this.transform(e,t,i)}niceDomain(t){let[e,i]=t;if(i<e)throw new Error("Unexpected input: min is larger than max");if(i===e)return 0===e?[-1,1]:e<0?[2*e,0]:[0,2*e];let r=Ul(),o=.05*(i-e+Number.EPSILON),[a,s]=r.domain([e-o,i+o]).nice().domain();return[a,s]}ticks(t,e){return Ul().domain(t).ticks(e)}isSafeNumber(t){return Number.isFinite(t)}},P3=class{constructor(){this.defaultFormatter=cp}transform(t){return Math.log10(t>0?t:Number.MIN_VALUE)}untransform(t){return Math.exp(t/Math.LOG10E)}forward(t,e,i){if(i<=0)return e[0];let[r,o]=t,[a,s]=e,l=this.transform(r),d=this.transform(o)-l,u=s-a;return i=this.transform(i),u/(d+Number.EPSILON)*(i-l)+a}reverse(t,e,i){let[r,o]=t,[a,s]=e,l=this.transform(r),d=this.transform(o)-l;return this.untransform(d/(s-a+Number.EPSILON)*(i-a)+l)}niceDomain(t){let[e,i]=t;if(e>i)throw new Error("Unexpected input: min is larger than max");let r=Math.max(e,Number.MIN_VALUE),o=Math.max(i,Number.MIN_VALUE);return i<=0?[Number.MIN_VALUE,1]:[Math.max(Number.MIN_VALUE,.5*r),2*o]}ticks(t,e){let i=t[0]<=0?Number.MIN_VALUE:t[0],r=t[1]<=0?Number.MIN_VALUE:t[1],o=Qv().domain([i,r]).ticks(e);return o.length?o:t}isSafeNumber(t){return Number.isFinite(t)&&t>0}},lx=class{constructor(){this.scale=fm(),this.defaultFormatter=S$}forward(t,e,i){return this.scale.domain(t).range(e)(i)}reverse(t,e,i){return this.scale.domain(t).range(e).invert(i).getTime()}niceDomain(t){let[e,i]=this.scale.domain(t).nice().domain();return[e.getTime(),i.getTime()]}ticks(t,e){return this.scale.domain(t).ticks(e).map(i=>i.getTime())}isSafeNumber(t){return Number.isFinite(t)}},O3=!1;if(self.hasOwnProperty("WebGL2RenderingContext")&&self.hasOwnProperty("document")){let n=document.createElement("canvas");n.addEventListener("webglcontextcreationerror",()=>{O3=!1});let t=n.getContext("webgl2");O3=Boolean(t)}var Gl_convertRectToExtent=function(n){return{x:[n.x,n.x+n.width],y:[n.y,n.y+n.height]}},Gl_isWebGl2Supported=function(){return O3},Gl_isWebGl2OffscreenCanvasSupported=function(){if(!self.hasOwnProperty("OffscreenCanvas"))return!1;let n=new OffscreenCanvas(0,0).getContext("webgl2");return Boolean(n)},Gl_arePolylinesEqual=function(n,t){if(n.length!==t.length)return!1;for(let e=0;e<n.length;e++)if(n[e]!==t[e])return!1;return!0},R0=class{constructor(){this.xScale=jl(ir.LINEAR),this.yScale=jl(ir.LINEAR),this.domContainerRect={x:0,width:1,y:0,height:1},this.lastUpdated=0,this.currentViewBoxRect={x:0,width:1,y:0,height:1}}getUpdateIdentifier(){return this.lastUpdated}updateIdentifier(){this.lastUpdated++}isYAxisPointedDown(){return!0}setXScale(t){this.xScale=t,this.updateIdentifier()}setYScale(t){this.yScale=t,this.updateIdentifier()}getCurrentViewBoxRect(){return this.currentViewBoxRect}setViewBoxRect(t){this.currentViewBoxRect=t,this.updateIdentifier()}setDomContainerRect(t){this.domContainerRect=t,this.updateIdentifier()}transformDataToUiCoord(t,e){let i=t,r=Gl_convertRectToExtent(this.currentViewBoxRect);return[this.xScale.forward(r.x,[i.x,i.x+i.width],e[0]),this.yScale.forward(r.y,this.isYAxisPointedDown()?[i.y+i.height,i.y]:[i.y,i.y+i.height],e[1])]}};function UD(n,t,e,i){let{color:r,visible:o,opacity:a}=i,s=n;return s||o?(s=s??t(),s=e(s),s.style.display=o?"":"none",s.style.stroke=r,s.style.opacity=String(a??1),s):null}var OV="137",tAe=0,E$=1,nAe=2,lte=1,iAe=2,bx=3,Sx=0,yo=1,o_=2,yp=0,xx=1,T$=2,D$=3,I$=4,rAe=5,K0=100,oAe=101,aAe=102,A$=103,R$=104,sAe=200,lAe=201,cAe=202,dAe=203,dte=204,ute=205,uAe=206,pAe=207,fAe=208,mAe=209,hAe=210,gAe=0,_Ae=1,yAe=2,vB=3,bAe=4,vAe=5,xAe=6,CAe=7,JI=0,MAe=1,wAe=2,bp=0,SAe=1,EAe=2,TAe=3,DAe=4,IAe=5,Zx=301,Kx=302,xB=303,CB=304,$I=306,FV=307,MB=1e3,gs=1001,wB=1002,bo=1003,k$=1004,P$=1005,ra=1006,AAe=1007,eA=1008,vp=1009,RAe=1010,kAe=1011,Ex=1012,PAe=1013,CI=1014,Cm=1015,t_=1016,OAe=1017,FAe=1018,n_=1020,LAe=1021,ba=1023,NAe=1024,BAe=1025,wm=1026,a_=1027,VAe=1028,HAe=1029,zAe=1030,UAe=1031,jAe=1033,F3=33776,L3=33777,N3=33778,B3=33779,O$=35840,F$=35841,L$=35842,N$=35843,GAe=36196,B$=37492,V$=37496,H$=37808,z$=37809,U$=37810,j$=37811,G$=37812,W$=37813,q$=37814,Y$=37815,X$=37816,Q$=37817,Z$=37818,K$=37819,J$=37820,$$=37821,eee=36492,J0=2400,$0=2401,Mp=3e3,Dr=3001,ZAe=3201,y_=0,KAe=1,Tx=35044,EI=35048,tee="300 es",SB=1035,Ud=class{addEventListener(t,e){void 0===this._listeners&&(this._listeners={});let i=this._listeners;void 0===i[t]&&(i[t]=[]),-1===i[t].indexOf(e)&&i[t].push(e)}hasEventListener(t,e){if(void 0===this._listeners)return!1;let i=this._listeners;return void 0!==i[t]&&-1!==i[t].indexOf(e)}removeEventListener(t,e){if(void 0===this._listeners)return;let r=this._listeners[t];if(void 0!==r){let o=r.indexOf(e);-1!==o&&r.splice(o,1)}}dispatchEvent(t){if(void 0===this._listeners)return;let i=this._listeners[t.type];if(void 0!==i){t.target=this;let r=i.slice(0);for(let o=0,a=r.length;o<a;o++)r[o].call(this,t);t.target=null}}},Ho=[];for(let n=0;n<256;n++)Ho[n]=(n<16?"0":"")+n.toString(16);var z3=Math.PI/180,EB=180/Math.PI;function Ql(){let n=4294967295*Math.random()|0,t=4294967295*Math.random()|0,e=4294967295*Math.random()|0,i=4294967295*Math.random()|0;return(Ho[255&n]+Ho[n>>8&255]+Ho[n>>16&255]+Ho[n>>24&255]+"-"+Ho[255&t]+Ho[t>>8&255]+"-"+Ho[t>>16&15|64]+Ho[t>>24&255]+"-"+Ho[63&e|128]+Ho[e>>8&255]+"-"+Ho[e>>16&255]+Ho[e>>24&255]+Ho[255&i]+Ho[i>>8&255]+Ho[i>>16&255]+Ho[i>>24&255]).toUpperCase()}function Xa(n,t,e){return Math.max(t,Math.min(e,n))}function U3(n,t,e){return(1-e)*n+e*t}function nee(n){return 0==(n&n-1)&&0!==n}function eRe(n){return Math.pow(2,Math.floor(Math.log(n)/Math.LN2))}var $e=class{constructor(t=0,e=0){this.x=t,this.y=e}get width(){return this.x}set width(t){this.x=t}get height(){return this.y}set height(t){this.y=t}set(t,e){return this.x=t,this.y=e,this}setScalar(t){return this.x=t,this.y=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setComponent(t,e){switch(t){case 0:this.x=e;break;case 1:this.y=e;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y)}copy(t){return this.x=t.x,this.y=t.y,this}add(t,e){return void 0!==e?(console.warn("THREE.Vector2: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(t,e)):(this.x+=t.x,this.y+=t.y,this)}addScalar(t){return this.x+=t,this.y+=t,this}addVectors(t,e){return this.x=t.x+e.x,this.y=t.y+e.y,this}addScaledVector(t,e){return this.x+=t.x*e,this.y+=t.y*e,this}sub(t,e){return void 0!==e?(console.warn("THREE.Vector2: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),this.subVectors(t,e)):(this.x-=t.x,this.y-=t.y,this)}subScalar(t){return this.x-=t,this.y-=t,this}subVectors(t,e){return this.x=t.x-e.x,this.y=t.y-e.y,this}multiply(t){return this.x*=t.x,this.y*=t.y,this}multiplyScalar(t){return this.x*=t,this.y*=t,this}divide(t){return this.x/=t.x,this.y/=t.y,this}divideScalar(t){return this.multiplyScalar(1/t)}applyMatrix3(t){let e=this.x,i=this.y,r=t.elements;return this.x=r[0]*e+r[3]*i+r[6],this.y=r[1]*e+r[4]*i+r[7],this}min(t){return this.x=Math.min(this.x,t.x),this.y=Math.min(this.y,t.y),this}max(t){return this.x=Math.max(this.x,t.x),this.y=Math.max(this.y,t.y),this}clamp(t,e){return this.x=Math.max(t.x,Math.min(e.x,this.x)),this.y=Math.max(t.y,Math.min(e.y,this.y)),this}clampScalar(t,e){return this.x=Math.max(t,Math.min(e,this.x)),this.y=Math.max(t,Math.min(e,this.y)),this}clampLength(t,e){let i=this.length();return this.divideScalar(i||1).multiplyScalar(Math.max(t,Math.min(e,i)))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this}roundToZero(){return this.x=this.x<0?Math.ceil(this.x):Math.floor(this.x),this.y=this.y<0?Math.ceil(this.y):Math.floor(this.y),this}negate(){return this.x=-this.x,this.y=-this.y,this}dot(t){return this.x*t.x+this.y*t.y}cross(t){return this.x*t.y-this.y*t.x}lengthSq(){return this.x*this.x+this.y*this.y}length(){return Math.sqrt(this.x*this.x+this.y*this.y)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)}normalize(){return this.divideScalar(this.length()||1)}angle(){return Math.atan2(-this.y,-this.x)+Math.PI}distanceTo(t){return Math.sqrt(this.distanceToSquared(t))}distanceToSquared(t){let e=this.x-t.x,i=this.y-t.y;return e*e+i*i}manhattanDistanceTo(t){return Math.abs(this.x-t.x)+Math.abs(this.y-t.y)}setLength(t){return this.normalize().multiplyScalar(t)}lerp(t,e){return this.x+=(t.x-this.x)*e,this.y+=(t.y-this.y)*e,this}lerpVectors(t,e,i){return this.x=t.x+(e.x-t.x)*i,this.y=t.y+(e.y-t.y)*i,this}equals(t){return t.x===this.x&&t.y===this.y}fromArray(t,e=0){return this.x=t[e],this.y=t[e+1],this}toArray(t=[],e=0){return t[e]=this.x,t[e+1]=this.y,t}fromBufferAttribute(t,e,i){return void 0!==i&&console.warn("THREE.Vector2: offset has been removed from .fromBufferAttribute()."),this.x=t.getX(e),this.y=t.getY(e),this}rotateAround(t,e){let i=Math.cos(e),r=Math.sin(e),o=this.x-t.x,a=this.y-t.y;return this.x=o*i-a*r+t.x,this.y=o*r+a*i+t.y,this}random(){return this.x=Math.random(),this.y=Math.random(),this}*[Symbol.iterator](){yield this.x,yield this.y}};$e.prototype.isVector2=!0;var vo=class{constructor(){this.elements=[1,0,0,0,1,0,0,0,1],arguments.length>0&&console.error("THREE.Matrix3: the constructor no longer reads arguments. use .set() instead.")}set(t,e,i,r,o,a,s,l,c){let d=this.elements;return d[0]=t,d[1]=r,d[2]=s,d[3]=e,d[4]=o,d[5]=l,d[6]=i,d[7]=a,d[8]=c,this}identity(){return this.set(1,0,0,0,1,0,0,0,1),this}copy(t){let e=this.elements,i=t.elements;return e[0]=i[0],e[1]=i[1],e[2]=i[2],e[3]=i[3],e[4]=i[4],e[5]=i[5],e[6]=i[6],e[7]=i[7],e[8]=i[8],this}extractBasis(t,e,i){return t.setFromMatrix3Column(this,0),e.setFromMatrix3Column(this,1),i.setFromMatrix3Column(this,2),this}setFromMatrix4(t){let e=t.elements;return this.set(e[0],e[4],e[8],e[1],e[5],e[9],e[2],e[6],e[10]),this}multiply(t){return this.multiplyMatrices(this,t)}premultiply(t){return this.multiplyMatrices(t,this)}multiplyMatrices(t,e){let i=t.elements,r=e.elements,o=this.elements,a=i[0],s=i[3],l=i[6],c=i[1],d=i[4],u=i[7],p=i[2],f=i[5],m=i[8],y=r[0],M=r[3],v=r[6],x=r[1],R=r[4],A=r[7],H=r[2],te=r[5],K=r[8];return o[0]=a*y+s*x+l*H,o[3]=a*M+s*R+l*te,o[6]=a*v+s*A+l*K,o[1]=c*y+d*x+u*H,o[4]=c*M+d*R+u*te,o[7]=c*v+d*A+u*K,o[2]=p*y+f*x+m*H,o[5]=p*M+f*R+m*te,o[8]=p*v+f*A+m*K,this}multiplyScalar(t){let e=this.elements;return e[0]*=t,e[3]*=t,e[6]*=t,e[1]*=t,e[4]*=t,e[7]*=t,e[2]*=t,e[5]*=t,e[8]*=t,this}determinant(){let t=this.elements,e=t[0],i=t[1],r=t[2],o=t[3],a=t[4],s=t[5],l=t[6],c=t[7],d=t[8];return e*a*d-e*s*c-i*o*d+i*s*l+r*o*c-r*a*l}invert(){let t=this.elements,e=t[0],i=t[1],r=t[2],o=t[3],a=t[4],s=t[5],l=t[6],c=t[7],d=t[8],u=d*a-s*c,p=s*l-d*o,f=c*o-a*l,m=e*u+i*p+r*f;if(0===m)return this.set(0,0,0,0,0,0,0,0,0);let y=1/m;return t[0]=u*y,t[1]=(r*c-d*i)*y,t[2]=(s*i-r*a)*y,t[3]=p*y,t[4]=(d*e-r*l)*y,t[5]=(r*o-s*e)*y,t[6]=f*y,t[7]=(i*l-c*e)*y,t[8]=(a*e-i*o)*y,this}transpose(){let t,e=this.elements;return t=e[1],e[1]=e[3],e[3]=t,t=e[2],e[2]=e[6],e[6]=t,t=e[5],e[5]=e[7],e[7]=t,this}getNormalMatrix(t){return this.setFromMatrix4(t).invert().transpose()}transposeIntoArray(t){let e=this.elements;return t[0]=e[0],t[1]=e[3],t[2]=e[6],t[3]=e[1],t[4]=e[4],t[5]=e[7],t[6]=e[2],t[7]=e[5],t[8]=e[8],this}setUvTransform(t,e,i,r,o,a,s){let l=Math.cos(o),c=Math.sin(o);return this.set(i*l,i*c,-i*(l*a+c*s)+a+t,-r*c,r*l,-r*(-c*a+l*s)+s+e,0,0,1),this}scale(t,e){let i=this.elements;return i[0]*=t,i[3]*=t,i[6]*=t,i[1]*=e,i[4]*=e,i[7]*=e,this}rotate(t){let e=Math.cos(t),i=Math.sin(t),r=this.elements,o=r[0],a=r[3],s=r[6],l=r[1],c=r[4],d=r[7];return r[0]=e*o+i*l,r[3]=e*a+i*c,r[6]=e*s+i*d,r[1]=-i*o+e*l,r[4]=-i*a+e*c,r[7]=-i*s+e*d,this}translate(t,e){let i=this.elements;return i[0]+=t*i[2],i[3]+=t*i[5],i[6]+=t*i[8],i[1]+=e*i[2],i[4]+=e*i[5],i[7]+=e*i[8],this}equals(t){let e=this.elements,i=t.elements;for(let r=0;r<9;r++)if(e[r]!==i[r])return!1;return!0}fromArray(t,e=0){for(let i=0;i<9;i++)this.elements[i]=t[i+e];return this}toArray(t=[],e=0){let i=this.elements;return t[e]=i[0],t[e+1]=i[1],t[e+2]=i[2],t[e+3]=i[3],t[e+4]=i[4],t[e+5]=i[5],t[e+6]=i[6],t[e+7]=i[7],t[e+8]=i[8],t}clone(){return(new this.constructor).fromArray(this.elements)}};function mte(n){for(let t=n.length-1;t>=0;--t)if(n[t]>65535)return!0;return!1}function Dx(n){return document.createElementNS("http://www.w3.org/1999/xhtml",n)}vo.prototype.isMatrix3=!0;var iee={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074},Wl={h:0,s:0,l:0},jD={h:0,s:0,l:0};function j3(n,t,e){return e<0&&(e+=1),e>1&&(e-=1),e<1/6?n+6*(t-n)*e:e<.5?t:e<2/3?n+6*(t-n)*(2/3-e):n}function i_(n){return n<.04045?.0773993808*n:Math.pow(.9478672986*n+.0521327014,2.4)}function G3(n){return n<.0031308?12.92*n:1.055*Math.pow(n,.41666)-.055}var an=(()=>{class n{constructor(e,i,r){return void 0===i&&void 0===r?this.set(e):this.setRGB(e,i,r)}set(e){return e&&e.isColor?this.copy(e):"number"==typeof e?this.setHex(e):"string"==typeof e&&this.setStyle(e),this}setScalar(e){return this.r=e,this.g=e,this.b=e,this}setHex(e){return e=Math.floor(e),this.r=(e>>16&255)/255,this.g=(e>>8&255)/255,this.b=(255&e)/255,this}setRGB(e,i,r){return this.r=e,this.g=i,this.b=r,this}setHSL(e,i,r){if(e=function(n,t){return(n%1+1)%1}(e),i=Xa(i,0,1),r=Xa(r,0,1),0===i)this.r=this.g=this.b=r;else{let o=r<=.5?r*(1+i):r+i-r*i,a=2*r-o;this.r=j3(a,o,e+1/3),this.g=j3(a,o,e),this.b=j3(a,o,e-1/3)}return this}setStyle(e){function i(o){void 0!==o&&parseFloat(o)<1&&console.warn("THREE.Color: Alpha component of "+e+" will be ignored.")}let r;if(r=/^((?:rgb|hsl)a?)\(([^\)]*)\)/.exec(e)){let o,s=r[2];switch(r[1]){case"rgb":case"rgba":if(o=/^\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(s))return this.r=Math.min(255,parseInt(o[1],10))/255,this.g=Math.min(255,parseInt(o[2],10))/255,this.b=Math.min(255,parseInt(o[3],10))/255,i(o[4]),this;if(o=/^\s*(\d+)\%\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(s))return this.r=Math.min(100,parseInt(o[1],10))/100,this.g=Math.min(100,parseInt(o[2],10))/100,this.b=Math.min(100,parseInt(o[3],10))/100,i(o[4]),this;break;case"hsl":case"hsla":if(o=/^\s*(\d*\.?\d+)\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(s)){let l=parseFloat(o[1])/360,c=parseInt(o[2],10)/100,d=parseInt(o[3],10)/100;return i(o[4]),this.setHSL(l,c,d)}}}else if(r=/^\#([A-Fa-f\d]+)$/.exec(e)){let o=r[1],a=o.length;if(3===a)return this.r=parseInt(o.charAt(0)+o.charAt(0),16)/255,this.g=parseInt(o.charAt(1)+o.charAt(1),16)/255,this.b=parseInt(o.charAt(2)+o.charAt(2),16)/255,this;if(6===a)return this.r=parseInt(o.charAt(0)+o.charAt(1),16)/255,this.g=parseInt(o.charAt(2)+o.charAt(3),16)/255,this.b=parseInt(o.charAt(4)+o.charAt(5),16)/255,this}return e&&e.length>0?this.setColorName(e):this}setColorName(e){let i=iee[e.toLowerCase()];return void 0!==i?this.setHex(i):console.warn("THREE.Color: Unknown color "+e),this}clone(){return new this.constructor(this.r,this.g,this.b)}copy(e){return this.r=e.r,this.g=e.g,this.b=e.b,this}copySRGBToLinear(e){return this.r=i_(e.r),this.g=i_(e.g),this.b=i_(e.b),this}copyLinearToSRGB(e){return this.r=G3(e.r),this.g=G3(e.g),this.b=G3(e.b),this}convertSRGBToLinear(){return this.copySRGBToLinear(this),this}convertLinearToSRGB(){return this.copyLinearToSRGB(this),this}getHex(){return 255*this.r<<16^255*this.g<<8^255*this.b<<0}getHexString(){return("000000"+this.getHex().toString(16)).slice(-6)}getHSL(e){let l,c,i=this.r,r=this.g,o=this.b,a=Math.max(i,r,o),s=Math.min(i,r,o),d=(s+a)/2;if(s===a)l=0,c=0;else{let u=a-s;switch(c=d<=.5?u/(a+s):u/(2-a-s),a){case i:l=(r-o)/u+(r<o?6:0);break;case r:l=(o-i)/u+2;break;case o:l=(i-r)/u+4}l/=6}return e.h=l,e.s=c,e.l=d,e}getStyle(){return"rgb("+(255*this.r|0)+","+(255*this.g|0)+","+(255*this.b|0)+")"}offsetHSL(e,i,r){return this.getHSL(Wl),Wl.h+=e,Wl.s+=i,Wl.l+=r,this.setHSL(Wl.h,Wl.s,Wl.l),this}add(e){return this.r+=e.r,this.g+=e.g,this.b+=e.b,this}addColors(e,i){return this.r=e.r+i.r,this.g=e.g+i.g,this.b=e.b+i.b,this}addScalar(e){return this.r+=e,this.g+=e,this.b+=e,this}sub(e){return this.r=Math.max(0,this.r-e.r),this.g=Math.max(0,this.g-e.g),this.b=Math.max(0,this.b-e.b),this}multiply(e){return this.r*=e.r,this.g*=e.g,this.b*=e.b,this}multiplyScalar(e){return this.r*=e,this.g*=e,this.b*=e,this}lerp(e,i){return this.r+=(e.r-this.r)*i,this.g+=(e.g-this.g)*i,this.b+=(e.b-this.b)*i,this}lerpColors(e,i,r){return this.r=e.r+(i.r-e.r)*r,this.g=e.g+(i.g-e.g)*r,this.b=e.b+(i.b-e.b)*r,this}lerpHSL(e,i){this.getHSL(Wl),e.getHSL(jD);let r=U3(Wl.h,jD.h,i),o=U3(Wl.s,jD.s,i),a=U3(Wl.l,jD.l,i);return this.setHSL(r,o,a),this}equals(e){return e.r===this.r&&e.g===this.g&&e.b===this.b}fromArray(e,i=0){return this.r=e[i],this.g=e[i+1],this.b=e[i+2],this}toArray(e=[],i=0){return e[i]=this.r,e[i+1]=this.g,e[i+2]=this.b,e}fromBufferAttribute(e,i){return this.r=e.getX(i),this.g=e.getY(i),this.b=e.getZ(i),!0===e.normalized&&(this.r/=255,this.g/=255,this.b/=255),this}toJSON(){return this.getHex()}}return n.NAMES=iee,n})();an.prototype.isColor=!0,an.prototype.r=1,an.prototype.g=1,an.prototype.b=1;var k0,jd=class{static getDataURL(t){if(/^data:/i.test(t.src)||typeof HTMLCanvasElement>"u")return t.src;let e;if(t instanceof HTMLCanvasElement)e=t;else{void 0===k0&&(k0=Dx("canvas")),k0.width=t.width,k0.height=t.height;let i=k0.getContext("2d");t instanceof ImageData?i.putImageData(t,0,0):i.drawImage(t,0,0,t.width,t.height),e=k0}return e.width>2048||e.height>2048?(console.warn("THREE.ImageUtils.getDataURL: Image converted to jpg for performance reasons",t),e.toDataURL("image/jpeg",.6)):e.toDataURL("image/png")}static sRGBToLinear(t){if(typeof HTMLImageElement<"u"&&t instanceof HTMLImageElement||typeof HTMLCanvasElement<"u"&&t instanceof HTMLCanvasElement||typeof ImageBitmap<"u"&&t instanceof ImageBitmap){let e=Dx("canvas");e.width=t.width,e.height=t.height;let i=e.getContext("2d");i.drawImage(t,0,0,t.width,t.height);let r=i.getImageData(0,0,t.width,t.height),o=r.data;for(let a=0;a<o.length;a++)o[a]=255*i_(o[a]/255);return i.putImageData(r,0,0),e}if(t.data){let e=t.data.slice(0);for(let i=0;i<e.length;i++)e[i]=e instanceof Uint8Array||e instanceof Uint8ClampedArray?Math.floor(255*i_(e[i]/255)):i_(e[i]);return{data:e,width:t.width,height:t.height}}return console.warn("THREE.ImageUtils.sRGBToLinear(): Unsupported image type. No color space conversion applied."),t}},tRe=0,uo=class extends Ud{constructor(t=uo.DEFAULT_IMAGE,e=uo.DEFAULT_MAPPING,i=gs,r=gs,o=ra,a=eA,s=ba,l=vp,c=1,d=Mp){super(),Object.defineProperty(this,"id",{value:tRe++}),this.uuid=Ql(),this.name="",this.image=t,this.mipmaps=[],this.mapping=e,this.wrapS=i,this.wrapT=r,this.magFilter=o,this.minFilter=a,this.anisotropy=c,this.format=s,this.internalFormat=null,this.type=l,this.offset=new $e(0,0),this.repeat=new $e(1,1),this.center=new $e(0,0),this.rotation=0,this.matrixAutoUpdate=!0,this.matrix=new vo,this.generateMipmaps=!0,this.premultiplyAlpha=!1,this.flipY=!0,this.unpackAlignment=4,this.encoding=d,this.userData={},this.version=0,this.onUpdate=null,this.isRenderTargetTexture=!1,this.needsPMREMUpdate=!1}updateMatrix(){this.matrix.setUvTransform(this.offset.x,this.offset.y,this.repeat.x,this.repeat.y,this.rotation,this.center.x,this.center.y)}clone(){return(new this.constructor).copy(this)}copy(t){return this.name=t.name,this.image=t.image,this.mipmaps=t.mipmaps.slice(0),this.mapping=t.mapping,this.wrapS=t.wrapS,this.wrapT=t.wrapT,this.magFilter=t.magFilter,this.minFilter=t.minFilter,this.anisotropy=t.anisotropy,this.format=t.format,this.internalFormat=t.internalFormat,this.type=t.type,this.offset.copy(t.offset),this.repeat.copy(t.repeat),this.center.copy(t.center),this.rotation=t.rotation,this.matrixAutoUpdate=t.matrixAutoUpdate,this.matrix.copy(t.matrix),this.generateMipmaps=t.generateMipmaps,this.premultiplyAlpha=t.premultiplyAlpha,this.flipY=t.flipY,this.unpackAlignment=t.unpackAlignment,this.encoding=t.encoding,this.userData=JSON.parse(JSON.stringify(t.userData)),this}toJSON(t){let e=void 0===t||"string"==typeof t;if(!e&&void 0!==t.textures[this.uuid])return t.textures[this.uuid];let i={metadata:{version:4.5,type:"Texture",generator:"Texture.toJSON"},uuid:this.uuid,name:this.name,mapping:this.mapping,repeat:[this.repeat.x,this.repeat.y],offset:[this.offset.x,this.offset.y],center:[this.center.x,this.center.y],rotation:this.rotation,wrap:[this.wrapS,this.wrapT],format:this.format,type:this.type,encoding:this.encoding,minFilter:this.minFilter,magFilter:this.magFilter,anisotropy:this.anisotropy,flipY:this.flipY,premultiplyAlpha:this.premultiplyAlpha,unpackAlignment:this.unpackAlignment};if(void 0!==this.image){let r=this.image;if(void 0===r.uuid&&(r.uuid=Ql()),!e&&void 0===t.images[r.uuid]){let o;if(Array.isArray(r)){o=[];for(let a=0,s=r.length;a<s;a++)o.push(W3(r[a].isDataTexture?r[a].image:r[a]))}else o=W3(r);t.images[r.uuid]={uuid:r.uuid,url:o}}i.image=r.uuid}return"{}"!==JSON.stringify(this.userData)&&(i.userData=this.userData),e||(t.textures[this.uuid]=i),i}dispose(){this.dispatchEvent({type:"dispose"})}transformUv(t){if(300!==this.mapping)return t;if(t.applyMatrix3(this.matrix),t.x<0||t.x>1)switch(this.wrapS){case MB:t.x=t.x-Math.floor(t.x);break;case gs:t.x=t.x<0?0:1;break;case wB:t.x=1===Math.abs(Math.floor(t.x)%2)?Math.ceil(t.x)-t.x:t.x-Math.floor(t.x)}if(t.y<0||t.y>1)switch(this.wrapT){case MB:t.y=t.y-Math.floor(t.y);break;case gs:t.y=t.y<0?0:1;break;case wB:t.y=1===Math.abs(Math.floor(t.y)%2)?Math.ceil(t.y)-t.y:t.y-Math.floor(t.y)}return this.flipY&&(t.y=1-t.y),t}set needsUpdate(t){!0===t&&this.version++}};function W3(n){return typeof HTMLImageElement<"u"&&n instanceof HTMLImageElement||typeof HTMLCanvasElement<"u"&&n instanceof HTMLCanvasElement||typeof ImageBitmap<"u"&&n instanceof ImageBitmap?jd.getDataURL(n):n.data?{data:Array.prototype.slice.call(n.data),width:n.width,height:n.height,type:n.data.constructor.name}:(console.warn("THREE.Texture: Unable to serialize Texture."),{})}uo.DEFAULT_IMAGE=void 0,uo.DEFAULT_MAPPING=300,uo.prototype.isTexture=!0;var Ki=class{constructor(t=0,e=0,i=0,r=1){this.x=t,this.y=e,this.z=i,this.w=r}get width(){return this.z}set width(t){this.z=t}get height(){return this.w}set height(t){this.w=t}set(t,e,i,r){return this.x=t,this.y=e,this.z=i,this.w=r,this}setScalar(t){return this.x=t,this.y=t,this.z=t,this.w=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setZ(t){return this.z=t,this}setW(t){return this.w=t,this}setComponent(t,e){switch(t){case 0:this.x=e;break;case 1:this.y=e;break;case 2:this.z=e;break;case 3:this.w=e;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;case 2:return this.z;case 3:return this.w;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y,this.z,this.w)}copy(t){return this.x=t.x,this.y=t.y,this.z=t.z,this.w=void 0!==t.w?t.w:1,this}add(t,e){return void 0!==e?(console.warn("THREE.Vector4: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(t,e)):(this.x+=t.x,this.y+=t.y,this.z+=t.z,this.w+=t.w,this)}addScalar(t){return this.x+=t,this.y+=t,this.z+=t,this.w+=t,this}addVectors(t,e){return this.x=t.x+e.x,this.y=t.y+e.y,this.z=t.z+e.z,this.w=t.w+e.w,this}addScaledVector(t,e){return this.x+=t.x*e,this.y+=t.y*e,this.z+=t.z*e,this.w+=t.w*e,this}sub(t,e){return void 0!==e?(console.warn("THREE.Vector4: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),this.subVectors(t,e)):(this.x-=t.x,this.y-=t.y,this.z-=t.z,this.w-=t.w,this)}subScalar(t){return this.x-=t,this.y-=t,this.z-=t,this.w-=t,this}subVectors(t,e){return this.x=t.x-e.x,this.y=t.y-e.y,this.z=t.z-e.z,this.w=t.w-e.w,this}multiply(t){return this.x*=t.x,this.y*=t.y,this.z*=t.z,this.w*=t.w,this}multiplyScalar(t){return this.x*=t,this.y*=t,this.z*=t,this.w*=t,this}applyMatrix4(t){let e=this.x,i=this.y,r=this.z,o=this.w,a=t.elements;return this.x=a[0]*e+a[4]*i+a[8]*r+a[12]*o,this.y=a[1]*e+a[5]*i+a[9]*r+a[13]*o,this.z=a[2]*e+a[6]*i+a[10]*r+a[14]*o,this.w=a[3]*e+a[7]*i+a[11]*r+a[15]*o,this}divideScalar(t){return this.multiplyScalar(1/t)}setAxisAngleFromQuaternion(t){this.w=2*Math.acos(t.w);let e=Math.sqrt(1-t.w*t.w);return e<1e-4?(this.x=1,this.y=0,this.z=0):(this.x=t.x/e,this.y=t.y/e,this.z=t.z/e),this}setAxisAngleFromRotationMatrix(t){let e,i,r,o,l=t.elements,c=l[0],d=l[4],u=l[8],p=l[1],f=l[5],m=l[9],y=l[2],M=l[6],v=l[10];if(Math.abs(d-p)<.01&&Math.abs(u-y)<.01&&Math.abs(m-M)<.01){if(Math.abs(d+p)<.1&&Math.abs(u+y)<.1&&Math.abs(m+M)<.1&&Math.abs(c+f+v-3)<.1)return this.set(1,0,0,0),this;e=Math.PI;let R=(c+1)/2,A=(f+1)/2,H=(v+1)/2,te=(d+p)/4,K=(u+y)/4,Ce=(m+M)/4;return R>A&&R>H?R<.01?(i=0,r=.707106781,o=.707106781):(i=Math.sqrt(R),r=te/i,o=K/i):A>H?A<.01?(i=.707106781,r=0,o=.707106781):(r=Math.sqrt(A),i=te/r,o=Ce/r):H<.01?(i=.707106781,r=.707106781,o=0):(o=Math.sqrt(H),i=K/o,r=Ce/o),this.set(i,r,o,e),this}let x=Math.sqrt((M-m)*(M-m)+(u-y)*(u-y)+(p-d)*(p-d));return Math.abs(x)<.001&&(x=1),this.x=(M-m)/x,this.y=(u-y)/x,this.z=(p-d)/x,this.w=Math.acos((c+f+v-1)/2),this}min(t){return this.x=Math.min(this.x,t.x),this.y=Math.min(this.y,t.y),this.z=Math.min(this.z,t.z),this.w=Math.min(this.w,t.w),this}max(t){return this.x=Math.max(this.x,t.x),this.y=Math.max(this.y,t.y),this.z=Math.max(this.z,t.z),this.w=Math.max(this.w,t.w),this}clamp(t,e){return this.x=Math.max(t.x,Math.min(e.x,this.x)),this.y=Math.max(t.y,Math.min(e.y,this.y)),this.z=Math.max(t.z,Math.min(e.z,this.z)),this.w=Math.max(t.w,Math.min(e.w,this.w)),this}clampScalar(t,e){return this.x=Math.max(t,Math.min(e,this.x)),this.y=Math.max(t,Math.min(e,this.y)),this.z=Math.max(t,Math.min(e,this.z)),this.w=Math.max(t,Math.min(e,this.w)),this}clampLength(t,e){let i=this.length();return this.divideScalar(i||1).multiplyScalar(Math.max(t,Math.min(e,i)))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this.z=Math.floor(this.z),this.w=Math.floor(this.w),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this.z=Math.ceil(this.z),this.w=Math.ceil(this.w),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this.z=Math.round(this.z),this.w=Math.round(this.w),this}roundToZero(){return this.x=this.x<0?Math.ceil(this.x):Math.floor(this.x),this.y=this.y<0?Math.ceil(this.y):Math.floor(this.y),this.z=this.z<0?Math.ceil(this.z):Math.floor(this.z),this.w=this.w<0?Math.ceil(this.w):Math.floor(this.w),this}negate(){return this.x=-this.x,this.y=-this.y,this.z=-this.z,this.w=-this.w,this}dot(t){return this.x*t.x+this.y*t.y+this.z*t.z+this.w*t.w}lengthSq(){return this.x*this.x+this.y*this.y+this.z*this.z+this.w*this.w}length(){return Math.sqrt(this.x*this.x+this.y*this.y+this.z*this.z+this.w*this.w)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)+Math.abs(this.z)+Math.abs(this.w)}normalize(){return this.divideScalar(this.length()||1)}setLength(t){return this.normalize().multiplyScalar(t)}lerp(t,e){return this.x+=(t.x-this.x)*e,this.y+=(t.y-this.y)*e,this.z+=(t.z-this.z)*e,this.w+=(t.w-this.w)*e,this}lerpVectors(t,e,i){return this.x=t.x+(e.x-t.x)*i,this.y=t.y+(e.y-t.y)*i,this.z=t.z+(e.z-t.z)*i,this.w=t.w+(e.w-t.w)*i,this}equals(t){return t.x===this.x&&t.y===this.y&&t.z===this.z&&t.w===this.w}fromArray(t,e=0){return this.x=t[e],this.y=t[e+1],this.z=t[e+2],this.w=t[e+3],this}toArray(t=[],e=0){return t[e]=this.x,t[e+1]=this.y,t[e+2]=this.z,t[e+3]=this.w,t}fromBufferAttribute(t,e,i){return void 0!==i&&console.warn("THREE.Vector4: offset has been removed from .fromBufferAttribute()."),this.x=t.getX(e),this.y=t.getY(e),this.z=t.getZ(e),this.w=t.getW(e),this}random(){return this.x=Math.random(),this.y=Math.random(),this.z=Math.random(),this.w=Math.random(),this}*[Symbol.iterator](){yield this.x,yield this.y,yield this.z,yield this.w}};Ki.prototype.isVector4=!0;var Qa=class extends Ud{constructor(t,e,i={}){super(),this.width=t,this.height=e,this.depth=1,this.scissor=new Ki(0,0,t,e),this.scissorTest=!1,this.viewport=new Ki(0,0,t,e),this.texture=new uo(void 0,i.mapping,i.wrapS,i.wrapT,i.magFilter,i.minFilter,i.format,i.type,i.anisotropy,i.encoding),this.texture.isRenderTargetTexture=!0,this.texture.image={width:t,height:e,depth:1},this.texture.generateMipmaps=void 0!==i.generateMipmaps&&i.generateMipmaps,this.texture.internalFormat=void 0!==i.internalFormat?i.internalFormat:null,this.texture.minFilter=void 0!==i.minFilter?i.minFilter:ra,this.depthBuffer=void 0===i.depthBuffer||i.depthBuffer,this.stencilBuffer=void 0!==i.stencilBuffer&&i.stencilBuffer,this.depthTexture=void 0!==i.depthTexture?i.depthTexture:null}setTexture(t){t.image={width:this.width,height:this.height,depth:this.depth},this.texture=t}setSize(t,e,i=1){(this.width!==t||this.height!==e||this.depth!==i)&&(this.width=t,this.height=e,this.depth=i,this.texture.image.width=t,this.texture.image.height=e,this.texture.image.depth=i,this.dispose()),this.viewport.set(0,0,t,e),this.scissor.set(0,0,t,e)}clone(){return(new this.constructor).copy(this)}copy(t){return this.width=t.width,this.height=t.height,this.depth=t.depth,this.viewport.copy(t.viewport),this.texture=t.texture.clone(),this.texture.image=Object.assign({},t.texture.image),this.depthBuffer=t.depthBuffer,this.stencilBuffer=t.stencilBuffer,this.depthTexture=t.depthTexture,this}dispose(){this.dispatchEvent({type:"dispose"})}};Qa.prototype.isWebGLRenderTarget=!0,class extends Qa{constructor(t,e,i){super(t,e);let r=this.texture;this.texture=[];for(let o=0;o<i;o++)this.texture[o]=r.clone()}setSize(t,e,i=1){if(this.width!==t||this.height!==e||this.depth!==i){this.width=t,this.height=e,this.depth=i;for(let r=0,o=this.texture.length;r<o;r++)this.texture[r].image.width=t,this.texture[r].image.height=e,this.texture[r].image.depth=i;this.dispose()}return this.viewport.set(0,0,t,e),this.scissor.set(0,0,t,e),this}copy(t){this.dispose(),this.width=t.width,this.height=t.height,this.depth=t.depth,this.viewport.set(0,0,this.width,this.height),this.scissor.set(0,0,this.width,this.height),this.depthBuffer=t.depthBuffer,this.stencilBuffer=t.stencilBuffer,this.depthTexture=t.depthTexture,this.texture.length=0;for(let e=0,i=t.texture.length;e<i;e++)this.texture[e]=t.texture[e].clone();return this}}.prototype.isWebGLMultipleRenderTargets=!0;var Ix=class extends Qa{constructor(t,e,i={}){super(t,e,i),this.samples=4,this.ignoreDepthForMultisampleCopy=void 0===i.ignoreDepth||i.ignoreDepth,this.useRenderToTexture=void 0!==i.useRenderToTexture&&i.useRenderToTexture,this.useRenderbuffer=!1===this.useRenderToTexture}copy(t){return super.copy.call(this,t),this.samples=t.samples,this.useRenderToTexture=t.useRenderToTexture,this.useRenderbuffer=t.useRenderbuffer,this}};Ix.prototype.isWebGLMultisampleRenderTarget=!0;var aa=class{constructor(t=0,e=0,i=0,r=1){this._x=t,this._y=e,this._z=i,this._w=r}static slerp(t,e,i,r){return console.warn("THREE.Quaternion: Static .slerp() has been deprecated. Use qm.slerpQuaternions( qa, qb, t ) instead."),i.slerpQuaternions(t,e,r)}static slerpFlat(t,e,i,r,o,a,s){let l=i[r+0],c=i[r+1],d=i[r+2],u=i[r+3],p=o[a+0],f=o[a+1],m=o[a+2],y=o[a+3];if(0===s)return t[e+0]=l,t[e+1]=c,t[e+2]=d,void(t[e+3]=u);if(1===s)return t[e+0]=p,t[e+1]=f,t[e+2]=m,void(t[e+3]=y);if(u!==y||l!==p||c!==f||d!==m){let M=1-s,v=l*p+c*f+d*m+u*y,x=v>=0?1:-1,R=1-v*v;if(R>Number.EPSILON){let H=Math.sqrt(R),te=Math.atan2(H,v*x);M=Math.sin(M*te)/H,s=Math.sin(s*te)/H}let A=s*x;if(l=l*M+p*A,c=c*M+f*A,d=d*M+m*A,u=u*M+y*A,M===1-s){let H=1/Math.sqrt(l*l+c*c+d*d+u*u);l*=H,c*=H,d*=H,u*=H}}t[e]=l,t[e+1]=c,t[e+2]=d,t[e+3]=u}static multiplyQuaternionsFlat(t,e,i,r,o,a){let s=i[r],l=i[r+1],c=i[r+2],d=i[r+3],u=o[a],p=o[a+1],f=o[a+2],m=o[a+3];return t[e]=s*m+d*u+l*f-c*p,t[e+1]=l*m+d*p+c*u-s*f,t[e+2]=c*m+d*f+s*p-l*u,t[e+3]=d*m-s*u-l*p-c*f,t}get x(){return this._x}set x(t){this._x=t,this._onChangeCallback()}get y(){return this._y}set y(t){this._y=t,this._onChangeCallback()}get z(){return this._z}set z(t){this._z=t,this._onChangeCallback()}get w(){return this._w}set w(t){this._w=t,this._onChangeCallback()}set(t,e,i,r){return this._x=t,this._y=e,this._z=i,this._w=r,this._onChangeCallback(),this}clone(){return new this.constructor(this._x,this._y,this._z,this._w)}copy(t){return this._x=t.x,this._y=t.y,this._z=t.z,this._w=t.w,this._onChangeCallback(),this}setFromEuler(t,e){if(!t||!t.isEuler)throw new Error("THREE.Quaternion: .setFromEuler() now expects an Euler rotation rather than a Vector3 and order.");let i=t._x,r=t._y,o=t._z,a=t._order,s=Math.cos,l=Math.sin,c=s(i/2),d=s(r/2),u=s(o/2),p=l(i/2),f=l(r/2),m=l(o/2);switch(a){case"XYZ":this._x=p*d*u+c*f*m,this._y=c*f*u-p*d*m,this._z=c*d*m+p*f*u,this._w=c*d*u-p*f*m;break;case"YXZ":this._x=p*d*u+c*f*m,this._y=c*f*u-p*d*m,this._z=c*d*m-p*f*u,this._w=c*d*u+p*f*m;break;case"ZXY":this._x=p*d*u-c*f*m,this._y=c*f*u+p*d*m,this._z=c*d*m+p*f*u,this._w=c*d*u-p*f*m;break;case"ZYX":this._x=p*d*u-c*f*m,this._y=c*f*u+p*d*m,this._z=c*d*m-p*f*u,this._w=c*d*u+p*f*m;break;case"YZX":this._x=p*d*u+c*f*m,this._y=c*f*u+p*d*m,this._z=c*d*m-p*f*u,this._w=c*d*u-p*f*m;break;case"XZY":this._x=p*d*u-c*f*m,this._y=c*f*u-p*d*m,this._z=c*d*m+p*f*u,this._w=c*d*u+p*f*m;break;default:console.warn("THREE.Quaternion: .setFromEuler() encountered an unknown order: "+a)}return!1!==e&&this._onChangeCallback(),this}setFromAxisAngle(t,e){let i=e/2,r=Math.sin(i);return this._x=t.x*r,this._y=t.y*r,this._z=t.z*r,this._w=Math.cos(i),this._onChangeCallback(),this}setFromRotationMatrix(t){let e=t.elements,i=e[0],r=e[4],o=e[8],a=e[1],s=e[5],l=e[9],c=e[2],d=e[6],u=e[10],p=i+s+u;if(p>0){let f=.5/Math.sqrt(p+1);this._w=.25/f,this._x=(d-l)*f,this._y=(o-c)*f,this._z=(a-r)*f}else if(i>s&&i>u){let f=2*Math.sqrt(1+i-s-u);this._w=(d-l)/f,this._x=.25*f,this._y=(r+a)/f,this._z=(o+c)/f}else if(s>u){let f=2*Math.sqrt(1+s-i-u);this._w=(o-c)/f,this._x=(r+a)/f,this._y=.25*f,this._z=(l+d)/f}else{let f=2*Math.sqrt(1+u-i-s);this._w=(a-r)/f,this._x=(o+c)/f,this._y=(l+d)/f,this._z=.25*f}return this._onChangeCallback(),this}setFromUnitVectors(t,e){let i=t.dot(e)+1;return i<Number.EPSILON?(i=0,Math.abs(t.x)>Math.abs(t.z)?(this._x=-t.y,this._y=t.x,this._z=0,this._w=i):(this._x=0,this._y=-t.z,this._z=t.y,this._w=i)):(this._x=t.y*e.z-t.z*e.y,this._y=t.z*e.x-t.x*e.z,this._z=t.x*e.y-t.y*e.x,this._w=i),this.normalize()}angleTo(t){return 2*Math.acos(Math.abs(Xa(this.dot(t),-1,1)))}rotateTowards(t,e){let i=this.angleTo(t);if(0===i)return this;let r=Math.min(1,e/i);return this.slerp(t,r),this}identity(){return this.set(0,0,0,1)}invert(){return this.conjugate()}conjugate(){return this._x*=-1,this._y*=-1,this._z*=-1,this._onChangeCallback(),this}dot(t){return this._x*t._x+this._y*t._y+this._z*t._z+this._w*t._w}lengthSq(){return this._x*this._x+this._y*this._y+this._z*this._z+this._w*this._w}length(){return Math.sqrt(this._x*this._x+this._y*this._y+this._z*this._z+this._w*this._w)}normalize(){let t=this.length();return 0===t?(this._x=0,this._y=0,this._z=0,this._w=1):(t=1/t,this._x=this._x*t,this._y=this._y*t,this._z=this._z*t,this._w=this._w*t),this._onChangeCallback(),this}multiply(t,e){return void 0!==e?(console.warn("THREE.Quaternion: .multiply() now only accepts one argument. Use .multiplyQuaternions( a, b ) instead."),this.multiplyQuaternions(t,e)):this.multiplyQuaternions(this,t)}premultiply(t){return this.multiplyQuaternions(t,this)}multiplyQuaternions(t,e){let i=t._x,r=t._y,o=t._z,a=t._w,s=e._x,l=e._y,c=e._z,d=e._w;return this._x=i*d+a*s+r*c-o*l,this._y=r*d+a*l+o*s-i*c,this._z=o*d+a*c+i*l-r*s,this._w=a*d-i*s-r*l-o*c,this._onChangeCallback(),this}slerp(t,e){if(0===e)return this;if(1===e)return this.copy(t);let i=this._x,r=this._y,o=this._z,a=this._w,s=a*t._w+i*t._x+r*t._y+o*t._z;if(s<0?(this._w=-t._w,this._x=-t._x,this._y=-t._y,this._z=-t._z,s=-s):this.copy(t),s>=1)return this._w=a,this._x=i,this._y=r,this._z=o,this;let l=1-s*s;if(l<=Number.EPSILON){let f=1-e;return this._w=f*a+e*this._w,this._x=f*i+e*this._x,this._y=f*r+e*this._y,this._z=f*o+e*this._z,this.normalize(),this._onChangeCallback(),this}let c=Math.sqrt(l),d=Math.atan2(c,s),u=Math.sin((1-e)*d)/c,p=Math.sin(e*d)/c;return this._w=a*u+this._w*p,this._x=i*u+this._x*p,this._y=r*u+this._y*p,this._z=o*u+this._z*p,this._onChangeCallback(),this}slerpQuaternions(t,e,i){return this.copy(t).slerp(e,i)}random(){let t=Math.random(),e=Math.sqrt(1-t),i=Math.sqrt(t),r=2*Math.PI*Math.random(),o=2*Math.PI*Math.random();return this.set(e*Math.cos(r),i*Math.sin(o),i*Math.cos(o),e*Math.sin(r))}equals(t){return t._x===this._x&&t._y===this._y&&t._z===this._z&&t._w===this._w}fromArray(t,e=0){return this._x=t[e],this._y=t[e+1],this._z=t[e+2],this._w=t[e+3],this._onChangeCallback(),this}toArray(t=[],e=0){return t[e]=this._x,t[e+1]=this._y,t[e+2]=this._z,t[e+3]=this._w,t}fromBufferAttribute(t,e){return this._x=t.getX(e),this._y=t.getY(e),this._z=t.getZ(e),this._w=t.getW(e),this}_onChange(t){return this._onChangeCallback=t,this}_onChangeCallback(){}};aa.prototype.isQuaternion=!0;var $=class{constructor(t=0,e=0,i=0){this.x=t,this.y=e,this.z=i}set(t,e,i){return void 0===i&&(i=this.z),this.x=t,this.y=e,this.z=i,this}setScalar(t){return this.x=t,this.y=t,this.z=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setZ(t){return this.z=t,this}setComponent(t,e){switch(t){case 0:this.x=e;break;case 1:this.y=e;break;case 2:this.z=e;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;case 2:return this.z;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y,this.z)}copy(t){return this.x=t.x,this.y=t.y,this.z=t.z,this}add(t,e){return void 0!==e?(console.warn("THREE.Vector3: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(t,e)):(this.x+=t.x,this.y+=t.y,this.z+=t.z,this)}addScalar(t){return this.x+=t,this.y+=t,this.z+=t,this}addVectors(t,e){return this.x=t.x+e.x,this.y=t.y+e.y,this.z=t.z+e.z,this}addScaledVector(t,e){return this.x+=t.x*e,this.y+=t.y*e,this.z+=t.z*e,this}sub(t,e){return void 0!==e?(console.warn("THREE.Vector3: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),this.subVectors(t,e)):(this.x-=t.x,this.y-=t.y,this.z-=t.z,this)}subScalar(t){return this.x-=t,this.y-=t,this.z-=t,this}subVectors(t,e){return this.x=t.x-e.x,this.y=t.y-e.y,this.z=t.z-e.z,this}multiply(t,e){return void 0!==e?(console.warn("THREE.Vector3: .multiply() now only accepts one argument. Use .multiplyVectors( a, b ) instead."),this.multiplyVectors(t,e)):(this.x*=t.x,this.y*=t.y,this.z*=t.z,this)}multiplyScalar(t){return this.x*=t,this.y*=t,this.z*=t,this}multiplyVectors(t,e){return this.x=t.x*e.x,this.y=t.y*e.y,this.z=t.z*e.z,this}applyEuler(t){return t&&t.isEuler||console.error("THREE.Vector3: .applyEuler() now expects an Euler rotation rather than a Vector3 and order."),this.applyQuaternion(ree.setFromEuler(t))}applyAxisAngle(t,e){return this.applyQuaternion(ree.setFromAxisAngle(t,e))}applyMatrix3(t){let e=this.x,i=this.y,r=this.z,o=t.elements;return this.x=o[0]*e+o[3]*i+o[6]*r,this.y=o[1]*e+o[4]*i+o[7]*r,this.z=o[2]*e+o[5]*i+o[8]*r,this}applyNormalMatrix(t){return this.applyMatrix3(t).normalize()}applyMatrix4(t){let e=this.x,i=this.y,r=this.z,o=t.elements,a=1/(o[3]*e+o[7]*i+o[11]*r+o[15]);return this.x=(o[0]*e+o[4]*i+o[8]*r+o[12])*a,this.y=(o[1]*e+o[5]*i+o[9]*r+o[13])*a,this.z=(o[2]*e+o[6]*i+o[10]*r+o[14])*a,this}applyQuaternion(t){let e=this.x,i=this.y,r=this.z,o=t.x,a=t.y,s=t.z,l=t.w,c=l*e+a*r-s*i,d=l*i+s*e-o*r,u=l*r+o*i-a*e,p=-o*e-a*i-s*r;return this.x=c*l+p*-o+d*-s-u*-a,this.y=d*l+p*-a+u*-o-c*-s,this.z=u*l+p*-s+c*-a-d*-o,this}project(t){return this.applyMatrix4(t.matrixWorldInverse).applyMatrix4(t.projectionMatrix)}unproject(t){return this.applyMatrix4(t.projectionMatrixInverse).applyMatrix4(t.matrixWorld)}transformDirection(t){let e=this.x,i=this.y,r=this.z,o=t.elements;return this.x=o[0]*e+o[4]*i+o[8]*r,this.y=o[1]*e+o[5]*i+o[9]*r,this.z=o[2]*e+o[6]*i+o[10]*r,this.normalize()}divide(t){return this.x/=t.x,this.y/=t.y,this.z/=t.z,this}divideScalar(t){return this.multiplyScalar(1/t)}min(t){return this.x=Math.min(this.x,t.x),this.y=Math.min(this.y,t.y),this.z=Math.min(this.z,t.z),this}max(t){return this.x=Math.max(this.x,t.x),this.y=Math.max(this.y,t.y),this.z=Math.max(this.z,t.z),this}clamp(t,e){return this.x=Math.max(t.x,Math.min(e.x,this.x)),this.y=Math.max(t.y,Math.min(e.y,this.y)),this.z=Math.max(t.z,Math.min(e.z,this.z)),this}clampScalar(t,e){return this.x=Math.max(t,Math.min(e,this.x)),this.y=Math.max(t,Math.min(e,this.y)),this.z=Math.max(t,Math.min(e,this.z)),this}clampLength(t,e){let i=this.length();return this.divideScalar(i||1).multiplyScalar(Math.max(t,Math.min(e,i)))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this.z=Math.floor(this.z),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this.z=Math.ceil(this.z),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this.z=Math.round(this.z),this}roundToZero(){return this.x=this.x<0?Math.ceil(this.x):Math.floor(this.x),this.y=this.y<0?Math.ceil(this.y):Math.floor(this.y),this.z=this.z<0?Math.ceil(this.z):Math.floor(this.z),this}negate(){return this.x=-this.x,this.y=-this.y,this.z=-this.z,this}dot(t){return this.x*t.x+this.y*t.y+this.z*t.z}lengthSq(){return this.x*this.x+this.y*this.y+this.z*this.z}length(){return Math.sqrt(this.x*this.x+this.y*this.y+this.z*this.z)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)+Math.abs(this.z)}normalize(){return this.divideScalar(this.length()||1)}setLength(t){return this.normalize().multiplyScalar(t)}lerp(t,e){return this.x+=(t.x-this.x)*e,this.y+=(t.y-this.y)*e,this.z+=(t.z-this.z)*e,this}lerpVectors(t,e,i){return this.x=t.x+(e.x-t.x)*i,this.y=t.y+(e.y-t.y)*i,this.z=t.z+(e.z-t.z)*i,this}cross(t,e){return void 0!==e?(console.warn("THREE.Vector3: .cross() now only accepts one argument. Use .crossVectors( a, b ) instead."),this.crossVectors(t,e)):this.crossVectors(this,t)}crossVectors(t,e){let i=t.x,r=t.y,o=t.z,a=e.x,s=e.y,l=e.z;return this.x=r*l-o*s,this.y=o*a-i*l,this.z=i*s-r*a,this}projectOnVector(t){let e=t.lengthSq();if(0===e)return this.set(0,0,0);let i=t.dot(this)/e;return this.copy(t).multiplyScalar(i)}projectOnPlane(t){return q3.copy(this).projectOnVector(t),this.sub(q3)}reflect(t){return this.sub(q3.copy(t).multiplyScalar(2*this.dot(t)))}angleTo(t){let e=Math.sqrt(this.lengthSq()*t.lengthSq());if(0===e)return Math.PI/2;let i=this.dot(t)/e;return Math.acos(Xa(i,-1,1))}distanceTo(t){return Math.sqrt(this.distanceToSquared(t))}distanceToSquared(t){let e=this.x-t.x,i=this.y-t.y,r=this.z-t.z;return e*e+i*i+r*r}manhattanDistanceTo(t){return Math.abs(this.x-t.x)+Math.abs(this.y-t.y)+Math.abs(this.z-t.z)}setFromSpherical(t){return this.setFromSphericalCoords(t.radius,t.phi,t.theta)}setFromSphericalCoords(t,e,i){let r=Math.sin(e)*t;return this.x=r*Math.sin(i),this.y=Math.cos(e)*t,this.z=r*Math.cos(i),this}setFromCylindrical(t){return this.setFromCylindricalCoords(t.radius,t.theta,t.y)}setFromCylindricalCoords(t,e,i){return this.x=t*Math.sin(e),this.y=i,this.z=t*Math.cos(e),this}setFromMatrixPosition(t){let e=t.elements;return this.x=e[12],this.y=e[13],this.z=e[14],this}setFromMatrixScale(t){let e=this.setFromMatrixColumn(t,0).length(),i=this.setFromMatrixColumn(t,1).length(),r=this.setFromMatrixColumn(t,2).length();return this.x=e,this.y=i,this.z=r,this}setFromMatrixColumn(t,e){return this.fromArray(t.elements,4*e)}setFromMatrix3Column(t,e){return this.fromArray(t.elements,3*e)}equals(t){return t.x===this.x&&t.y===this.y&&t.z===this.z}fromArray(t,e=0){return this.x=t[e],this.y=t[e+1],this.z=t[e+2],this}toArray(t=[],e=0){return t[e]=this.x,t[e+1]=this.y,t[e+2]=this.z,t}fromBufferAttribute(t,e,i){return void 0!==i&&console.warn("THREE.Vector3: offset has been removed from .fromBufferAttribute()."),this.x=t.getX(e),this.y=t.getY(e),this.z=t.getZ(e),this}random(){return this.x=Math.random(),this.y=Math.random(),this.z=Math.random(),this}randomDirection(){let t=2*(Math.random()-.5),e=Math.random()*Math.PI*2,i=Math.sqrt(1-t**2);return this.x=i*Math.cos(e),this.y=i*Math.sin(e),this.z=t,this}*[Symbol.iterator](){yield this.x,yield this.y,yield this.z}};$.prototype.isVector3=!0;var q3=new $,ree=new aa,_s=class{constructor(t=new $(1/0,1/0,1/0),e=new $(-1/0,-1/0,-1/0)){this.min=t,this.max=e}set(t,e){return this.min.copy(t),this.max.copy(e),this}setFromArray(t){let e=1/0,i=1/0,r=1/0,o=-1/0,a=-1/0,s=-1/0;for(let l=0,c=t.length;l<c;l+=3){let d=t[l],u=t[l+1],p=t[l+2];d<e&&(e=d),u<i&&(i=u),p<r&&(r=p),d>o&&(o=d),u>a&&(a=u),p>s&&(s=p)}return this.min.set(e,i,r),this.max.set(o,a,s),this}setFromBufferAttribute(t){let e=1/0,i=1/0,r=1/0,o=-1/0,a=-1/0,s=-1/0;for(let l=0,c=t.count;l<c;l++){let d=t.getX(l),u=t.getY(l),p=t.getZ(l);d<e&&(e=d),u<i&&(i=u),p<r&&(r=p),d>o&&(o=d),u>a&&(a=u),p>s&&(s=p)}return this.min.set(e,i,r),this.max.set(o,a,s),this}setFromPoints(t){this.makeEmpty();for(let e=0,i=t.length;e<i;e++)this.expandByPoint(t[e]);return this}setFromCenterAndSize(t,e){let i=ym.copy(e).multiplyScalar(.5);return this.min.copy(t).sub(i),this.max.copy(t).add(i),this}setFromObject(t,e=!1){return this.makeEmpty(),this.expandByObject(t,e)}clone(){return(new this.constructor).copy(this)}copy(t){return this.min.copy(t.min),this.max.copy(t.max),this}makeEmpty(){return this.min.x=this.min.y=this.min.z=1/0,this.max.x=this.max.y=this.max.z=-1/0,this}isEmpty(){return this.max.x<this.min.x||this.max.y<this.min.y||this.max.z<this.min.z}getCenter(t){return this.isEmpty()?t.set(0,0,0):t.addVectors(this.min,this.max).multiplyScalar(.5)}getSize(t){return this.isEmpty()?t.set(0,0,0):t.subVectors(this.max,this.min)}expandByPoint(t){return this.min.min(t),this.max.max(t),this}expandByVector(t){return this.min.sub(t),this.max.add(t),this}expandByScalar(t){return this.min.addScalar(-t),this.max.addScalar(t),this}expandByObject(t,e=!1){t.updateWorldMatrix(!1,!1);let i=t.geometry;if(void 0!==i)if(e&&null!=i.attributes&&void 0!==i.attributes.position){let o=i.attributes.position;for(let a=0,s=o.count;a<s;a++)ym.fromBufferAttribute(o,a).applyMatrix4(t.matrixWorld),this.expandByPoint(ym)}else null===i.boundingBox&&i.computeBoundingBox(),Y3.copy(i.boundingBox),Y3.applyMatrix4(t.matrixWorld),this.union(Y3);let r=t.children;for(let o=0,a=r.length;o<a;o++)this.expandByObject(r[o],e);return this}containsPoint(t){return!(t.x<this.min.x||t.x>this.max.x||t.y<this.min.y||t.y>this.max.y||t.z<this.min.z||t.z>this.max.z)}containsBox(t){return this.min.x<=t.min.x&&t.max.x<=this.max.x&&this.min.y<=t.min.y&&t.max.y<=this.max.y&&this.min.z<=t.min.z&&t.max.z<=this.max.z}getParameter(t,e){return e.set((t.x-this.min.x)/(this.max.x-this.min.x),(t.y-this.min.y)/(this.max.y-this.min.y),(t.z-this.min.z)/(this.max.z-this.min.z))}intersectsBox(t){return!(t.max.x<this.min.x||t.min.x>this.max.x||t.max.y<this.min.y||t.min.y>this.max.y||t.max.z<this.min.z||t.min.z>this.max.z)}intersectsSphere(t){return this.clampPoint(t.center,ym),ym.distanceToSquared(t.center)<=t.radius*t.radius}intersectsPlane(t){let e,i;return t.normal.x>0?(e=t.normal.x*this.min.x,i=t.normal.x*this.max.x):(e=t.normal.x*this.max.x,i=t.normal.x*this.min.x),t.normal.y>0?(e+=t.normal.y*this.min.y,i+=t.normal.y*this.max.y):(e+=t.normal.y*this.max.y,i+=t.normal.y*this.min.y),t.normal.z>0?(e+=t.normal.z*this.min.z,i+=t.normal.z*this.max.z):(e+=t.normal.z*this.max.z,i+=t.normal.z*this.min.z),e<=-t.constant&&i>=-t.constant}intersectsTriangle(t){if(this.isEmpty())return!1;this.getCenter(dx),GD.subVectors(this.max,dx),P0.subVectors(t.a,dx),O0.subVectors(t.b,dx),F0.subVectors(t.c,dx),dp.subVectors(O0,P0),up.subVectors(F0,O0),bm.subVectors(P0,F0);let e=[0,-dp.z,dp.y,0,-up.z,up.y,0,-bm.z,bm.y,dp.z,0,-dp.x,up.z,0,-up.x,bm.z,0,-bm.x,-dp.y,dp.x,0,-up.y,up.x,0,-bm.y,bm.x,0];return!(!X3(e,P0,O0,F0,GD)||(e=[1,0,0,0,1,0,0,0,1],!X3(e,P0,O0,F0,GD)))&&(WD.crossVectors(dp,up),e=[WD.x,WD.y,WD.z],X3(e,P0,O0,F0,GD))}clampPoint(t,e){return e.copy(t).clamp(this.min,this.max)}distanceToPoint(t){return ym.copy(t).clamp(this.min,this.max).sub(t).length()}getBoundingSphere(t){return this.getCenter(t.center),t.radius=.5*this.getSize(ym).length(),t}intersect(t){return this.min.max(t.min),this.max.min(t.max),this.isEmpty()&&this.makeEmpty(),this}union(t){return this.min.min(t.min),this.max.max(t.max),this}applyMatrix4(t){return this.isEmpty()||(Ld[0].set(this.min.x,this.min.y,this.min.z).applyMatrix4(t),Ld[1].set(this.min.x,this.min.y,this.max.z).applyMatrix4(t),Ld[2].set(this.min.x,this.max.y,this.min.z).applyMatrix4(t),Ld[3].set(this.min.x,this.max.y,this.max.z).applyMatrix4(t),Ld[4].set(this.max.x,this.min.y,this.min.z).applyMatrix4(t),Ld[5].set(this.max.x,this.min.y,this.max.z).applyMatrix4(t),Ld[6].set(this.max.x,this.max.y,this.min.z).applyMatrix4(t),Ld[7].set(this.max.x,this.max.y,this.max.z).applyMatrix4(t),this.setFromPoints(Ld)),this}translate(t){return this.min.add(t),this.max.add(t),this}equals(t){return t.min.equals(this.min)&&t.max.equals(this.max)}};_s.prototype.isBox3=!0;var Ld=[new $,new $,new $,new $,new $,new $,new $,new $],ym=new $,Y3=new _s,P0=new $,O0=new $,F0=new $,dp=new $,up=new $,bm=new $,dx=new $,GD=new $,WD=new $,vm=new $;function X3(n,t,e,i,r){for(let o=0,a=n.length-3;o<=a;o+=3){vm.fromArray(n,o);let s=r.x*Math.abs(vm.x)+r.y*Math.abs(vm.y)+r.z*Math.abs(vm.z),l=t.dot(vm),c=e.dot(vm),d=i.dot(vm);if(Math.max(-Math.max(l,c,d),Math.min(l,c,d))>s)return!1}return!0}var nRe=new _s,oee=new $,qD=new $,Q3=new $,wp=class{constructor(t=new $,e=-1){this.center=t,this.radius=e}set(t,e){return this.center.copy(t),this.radius=e,this}setFromPoints(t,e){let i=this.center;void 0!==e?i.copy(e):nRe.setFromPoints(t).getCenter(i);let r=0;for(let o=0,a=t.length;o<a;o++)r=Math.max(r,i.distanceToSquared(t[o]));return this.radius=Math.sqrt(r),this}copy(t){return this.center.copy(t.center),this.radius=t.radius,this}isEmpty(){return this.radius<0}makeEmpty(){return this.center.set(0,0,0),this.radius=-1,this}containsPoint(t){return t.distanceToSquared(this.center)<=this.radius*this.radius}distanceToPoint(t){return t.distanceTo(this.center)-this.radius}intersectsSphere(t){let e=this.radius+t.radius;return t.center.distanceToSquared(this.center)<=e*e}intersectsBox(t){return t.intersectsSphere(this)}intersectsPlane(t){return Math.abs(t.distanceToPoint(this.center))<=this.radius}clampPoint(t,e){let i=this.center.distanceToSquared(t);return e.copy(t),i>this.radius*this.radius&&(e.sub(this.center).normalize(),e.multiplyScalar(this.radius).add(this.center)),e}getBoundingBox(t){return this.isEmpty()?(t.makeEmpty(),t):(t.set(this.center,this.center),t.expandByScalar(this.radius),t)}applyMatrix4(t){return this.center.applyMatrix4(t),this.radius=this.radius*t.getMaxScaleOnAxis(),this}translate(t){return this.center.add(t),this}expandByPoint(t){Q3.subVectors(t,this.center);let e=Q3.lengthSq();if(e>this.radius*this.radius){let i=Math.sqrt(e),r=.5*(i-this.radius);this.center.add(Q3.multiplyScalar(r/i)),this.radius+=r}return this}union(t){return!0===this.center.equals(t.center)?qD.set(0,0,1).multiplyScalar(t.radius):qD.subVectors(t.center,this.center).normalize().multiplyScalar(t.radius),this.expandByPoint(oee.copy(t.center).add(qD)),this.expandByPoint(oee.copy(t.center).sub(qD)),this}equals(t){return t.center.equals(this.center)&&t.radius===this.radius}clone(){return(new this.constructor).copy(this)}},Nd=new $,Z3=new $,YD=new $,pp=new $,K3=new $,XD=new $,J3=new $,Sp=class{constructor(t=new $,e=new $(0,0,-1)){this.origin=t,this.direction=e}set(t,e){return this.origin.copy(t),this.direction.copy(e),this}copy(t){return this.origin.copy(t.origin),this.direction.copy(t.direction),this}at(t,e){return e.copy(this.direction).multiplyScalar(t).add(this.origin)}lookAt(t){return this.direction.copy(t).sub(this.origin).normalize(),this}recast(t){return this.origin.copy(this.at(t,Nd)),this}closestPointToPoint(t,e){e.subVectors(t,this.origin);let i=e.dot(this.direction);return i<0?e.copy(this.origin):e.copy(this.direction).multiplyScalar(i).add(this.origin)}distanceToPoint(t){return Math.sqrt(this.distanceSqToPoint(t))}distanceSqToPoint(t){let e=Nd.subVectors(t,this.origin).dot(this.direction);return e<0?this.origin.distanceToSquared(t):(Nd.copy(this.direction).multiplyScalar(e).add(this.origin),Nd.distanceToSquared(t))}distanceSqToSegment(t,e,i,r){Z3.copy(t).add(e).multiplyScalar(.5),YD.copy(e).sub(t).normalize(),pp.copy(this.origin).sub(Z3);let u,p,f,m,o=.5*t.distanceTo(e),a=-this.direction.dot(YD),s=pp.dot(this.direction),l=-pp.dot(YD),c=pp.lengthSq(),d=Math.abs(1-a*a);if(d>0)if(u=a*l-s,p=a*s-l,m=o*d,u>=0)if(p>=-m)if(p<=m){let y=1/d;u*=y,p*=y,f=u*(u+a*p+2*s)+p*(a*u+p+2*l)+c}else p=o,u=Math.max(0,-(a*p+s)),f=-u*u+p*(p+2*l)+c;else p=-o,u=Math.max(0,-(a*p+s)),f=-u*u+p*(p+2*l)+c;else p<=-m?(u=Math.max(0,-(-a*o+s)),p=u>0?-o:Math.min(Math.max(-o,-l),o),f=-u*u+p*(p+2*l)+c):p<=m?(u=0,p=Math.min(Math.max(-o,-l),o),f=p*(p+2*l)+c):(u=Math.max(0,-(a*o+s)),p=u>0?o:Math.min(Math.max(-o,-l),o),f=-u*u+p*(p+2*l)+c);else p=a>0?-o:o,u=Math.max(0,-(a*p+s)),f=-u*u+p*(p+2*l)+c;return i&&i.copy(this.direction).multiplyScalar(u).add(this.origin),r&&r.copy(YD).multiplyScalar(p).add(Z3),f}intersectSphere(t,e){Nd.subVectors(t.center,this.origin);let i=Nd.dot(this.direction),r=Nd.dot(Nd)-i*i,o=t.radius*t.radius;if(r>o)return null;let a=Math.sqrt(o-r),s=i-a,l=i+a;return s<0&&l<0?null:this.at(s<0?l:s,e)}intersectsSphere(t){return this.distanceSqToPoint(t.center)<=t.radius*t.radius}distanceToPlane(t){let e=t.normal.dot(this.direction);if(0===e)return 0===t.distanceToPoint(this.origin)?0:null;let i=-(this.origin.dot(t.normal)+t.constant)/e;return i>=0?i:null}intersectPlane(t,e){let i=this.distanceToPlane(t);return null===i?null:this.at(i,e)}intersectsPlane(t){let e=t.distanceToPoint(this.origin);return 0===e||t.normal.dot(this.direction)*e<0}intersectBox(t,e){let i,r,o,a,s,l,c=1/this.direction.x,d=1/this.direction.y,u=1/this.direction.z,p=this.origin;return c>=0?(i=(t.min.x-p.x)*c,r=(t.max.x-p.x)*c):(i=(t.max.x-p.x)*c,r=(t.min.x-p.x)*c),d>=0?(o=(t.min.y-p.y)*d,a=(t.max.y-p.y)*d):(o=(t.max.y-p.y)*d,a=(t.min.y-p.y)*d),i>a||o>r||((o>i||i!=i)&&(i=o),(a<r||r!=r)&&(r=a),u>=0?(s=(t.min.z-p.z)*u,l=(t.max.z-p.z)*u):(s=(t.max.z-p.z)*u,l=(t.min.z-p.z)*u),i>l||s>r)||((s>i||i!=i)&&(i=s),(l<r||r!=r)&&(r=l),r<0)?null:this.at(i>=0?i:r,e)}intersectsBox(t){return null!==this.intersectBox(t,Nd)}intersectTriangle(t,e,i,r,o){K3.subVectors(e,t),XD.subVectors(i,t),J3.crossVectors(K3,XD);let s,a=this.direction.dot(J3);if(a>0){if(r)return null;s=1}else{if(!(a<0))return null;s=-1,a=-a}pp.subVectors(this.origin,t);let l=s*this.direction.dot(XD.crossVectors(pp,XD));if(l<0)return null;let c=s*this.direction.dot(K3.cross(pp));if(c<0||l+c>a)return null;let d=-s*pp.dot(J3);return d<0?null:this.at(d/a,o)}applyMatrix4(t){return this.origin.applyMatrix4(t),this.direction.transformDirection(t),this}equals(t){return t.origin.equals(this.origin)&&t.direction.equals(this.direction)}clone(){return(new this.constructor).copy(this)}},Mn=class{constructor(){this.elements=[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1],arguments.length>0&&console.error("THREE.Matrix4: the constructor no longer reads arguments. use .set() instead.")}set(t,e,i,r,o,a,s,l,c,d,u,p,f,m,y,M){let v=this.elements;return v[0]=t,v[4]=e,v[8]=i,v[12]=r,v[1]=o,v[5]=a,v[9]=s,v[13]=l,v[2]=c,v[6]=d,v[10]=u,v[14]=p,v[3]=f,v[7]=m,v[11]=y,v[15]=M,this}identity(){return this.set(1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1),this}clone(){return(new Mn).fromArray(this.elements)}copy(t){let e=this.elements,i=t.elements;return e[0]=i[0],e[1]=i[1],e[2]=i[2],e[3]=i[3],e[4]=i[4],e[5]=i[5],e[6]=i[6],e[7]=i[7],e[8]=i[8],e[9]=i[9],e[10]=i[10],e[11]=i[11],e[12]=i[12],e[13]=i[13],e[14]=i[14],e[15]=i[15],this}copyPosition(t){let e=this.elements,i=t.elements;return e[12]=i[12],e[13]=i[13],e[14]=i[14],this}setFromMatrix3(t){let e=t.elements;return this.set(e[0],e[3],e[6],0,e[1],e[4],e[7],0,e[2],e[5],e[8],0,0,0,0,1),this}extractBasis(t,e,i){return t.setFromMatrixColumn(this,0),e.setFromMatrixColumn(this,1),i.setFromMatrixColumn(this,2),this}makeBasis(t,e,i){return this.set(t.x,e.x,i.x,0,t.y,e.y,i.y,0,t.z,e.z,i.z,0,0,0,0,1),this}extractRotation(t){let e=this.elements,i=t.elements,r=1/L0.setFromMatrixColumn(t,0).length(),o=1/L0.setFromMatrixColumn(t,1).length(),a=1/L0.setFromMatrixColumn(t,2).length();return e[0]=i[0]*r,e[1]=i[1]*r,e[2]=i[2]*r,e[3]=0,e[4]=i[4]*o,e[5]=i[5]*o,e[6]=i[6]*o,e[7]=0,e[8]=i[8]*a,e[9]=i[9]*a,e[10]=i[10]*a,e[11]=0,e[12]=0,e[13]=0,e[14]=0,e[15]=1,this}makeRotationFromEuler(t){t&&t.isEuler||console.error("THREE.Matrix4: .makeRotationFromEuler() now expects a Euler rotation rather than a Vector3 and order.");let e=this.elements,i=t.x,r=t.y,o=t.z,a=Math.cos(i),s=Math.sin(i),l=Math.cos(r),c=Math.sin(r),d=Math.cos(o),u=Math.sin(o);if("XYZ"===t.order){let p=a*d,f=a*u,m=s*d,y=s*u;e[0]=l*d,e[4]=-l*u,e[8]=c,e[1]=f+m*c,e[5]=p-y*c,e[9]=-s*l,e[2]=y-p*c,e[6]=m+f*c,e[10]=a*l}else if("YXZ"===t.order){let p=l*d,f=l*u,m=c*d,y=c*u;e[0]=p+y*s,e[4]=m*s-f,e[8]=a*c,e[1]=a*u,e[5]=a*d,e[9]=-s,e[2]=f*s-m,e[6]=y+p*s,e[10]=a*l}else if("ZXY"===t.order){let p=l*d,f=l*u,m=c*d,y=c*u;e[0]=p-y*s,e[4]=-a*u,e[8]=m+f*s,e[1]=f+m*s,e[5]=a*d,e[9]=y-p*s,e[2]=-a*c,e[6]=s,e[10]=a*l}else if("ZYX"===t.order){let p=a*d,f=a*u,m=s*d,y=s*u;e[0]=l*d,e[4]=m*c-f,e[8]=p*c+y,e[1]=l*u,e[5]=y*c+p,e[9]=f*c-m,e[2]=-c,e[6]=s*l,e[10]=a*l}else if("YZX"===t.order){let p=a*l,f=a*c,m=s*l,y=s*c;e[0]=l*d,e[4]=y-p*u,e[8]=m*u+f,e[1]=u,e[5]=a*d,e[9]=-s*d,e[2]=-c*d,e[6]=f*u+m,e[10]=p-y*u}else if("XZY"===t.order){let p=a*l,f=a*c,m=s*l,y=s*c;e[0]=l*d,e[4]=-u,e[8]=c*d,e[1]=p*u+y,e[5]=a*d,e[9]=f*u-m,e[2]=m*u-f,e[6]=s*d,e[10]=y*u+p}return e[3]=0,e[7]=0,e[11]=0,e[12]=0,e[13]=0,e[14]=0,e[15]=1,this}makeRotationFromQuaternion(t){return this.compose(iRe,t,rRe)}lookAt(t,e,i){let r=this.elements;return ms.subVectors(t,e),0===ms.lengthSq()&&(ms.z=1),ms.normalize(),fp.crossVectors(i,ms),0===fp.lengthSq()&&(1===Math.abs(i.z)?ms.x+=1e-4:ms.z+=1e-4,ms.normalize(),fp.crossVectors(i,ms)),fp.normalize(),QD.crossVectors(ms,fp),r[0]=fp.x,r[4]=QD.x,r[8]=ms.x,r[1]=fp.y,r[5]=QD.y,r[9]=ms.y,r[2]=fp.z,r[6]=QD.z,r[10]=ms.z,this}multiply(t,e){return void 0!==e?(console.warn("THREE.Matrix4: .multiply() now only accepts one argument. Use .multiplyMatrices( a, b ) instead."),this.multiplyMatrices(t,e)):this.multiplyMatrices(this,t)}premultiply(t){return this.multiplyMatrices(t,this)}multiplyMatrices(t,e){let i=t.elements,r=e.elements,o=this.elements,a=i[0],s=i[4],l=i[8],c=i[12],d=i[1],u=i[5],p=i[9],f=i[13],m=i[2],y=i[6],M=i[10],v=i[14],x=i[3],R=i[7],A=i[11],H=i[15],te=r[0],K=r[4],Ce=r[8],Ze=r[12],Ie=r[1],I=r[5],re=r[9],ce=r[13],fe=r[2],_e=r[6],ne=r[10],de=r[14],ue=r[3],Ge=r[7],Me=r[11],Ne=r[15];return o[0]=a*te+s*Ie+l*fe+c*ue,o[4]=a*K+s*I+l*_e+c*Ge,o[8]=a*Ce+s*re+l*ne+c*Me,o[12]=a*Ze+s*ce+l*de+c*Ne,o[1]=d*te+u*Ie+p*fe+f*ue,o[5]=d*K+u*I+p*_e+f*Ge,o[9]=d*Ce+u*re+p*ne+f*Me,o[13]=d*Ze+u*ce+p*de+f*Ne,o[2]=m*te+y*Ie+M*fe+v*ue,o[6]=m*K+y*I+M*_e+v*Ge,o[10]=m*Ce+y*re+M*ne+v*Me,o[14]=m*Ze+y*ce+M*de+v*Ne,o[3]=x*te+R*Ie+A*fe+H*ue,o[7]=x*K+R*I+A*_e+H*Ge,o[11]=x*Ce+R*re+A*ne+H*Me,o[15]=x*Ze+R*ce+A*de+H*Ne,this}multiplyScalar(t){let e=this.elements;return e[0]*=t,e[4]*=t,e[8]*=t,e[12]*=t,e[1]*=t,e[5]*=t,e[9]*=t,e[13]*=t,e[2]*=t,e[6]*=t,e[10]*=t,e[14]*=t,e[3]*=t,e[7]*=t,e[11]*=t,e[15]*=t,this}determinant(){let t=this.elements,e=t[0],i=t[4],r=t[8],o=t[12],a=t[1],s=t[5],l=t[9],c=t[13],d=t[2],u=t[6],p=t[10],f=t[14];return t[3]*(+o*l*u-r*c*u-o*s*p+i*c*p+r*s*f-i*l*f)+t[7]*(+e*l*f-e*c*p+o*a*p-r*a*f+r*c*d-o*l*d)+t[11]*(+e*c*u-e*s*f-o*a*u+i*a*f+o*s*d-i*c*d)+t[15]*(-r*s*d-e*l*u+e*s*p+r*a*u-i*a*p+i*l*d)}transpose(){let e,t=this.elements;return e=t[1],t[1]=t[4],t[4]=e,e=t[2],t[2]=t[8],t[8]=e,e=t[6],t[6]=t[9],t[9]=e,e=t[3],t[3]=t[12],t[12]=e,e=t[7],t[7]=t[13],t[13]=e,e=t[11],t[11]=t[14],t[14]=e,this}setPosition(t,e,i){let r=this.elements;return t.isVector3?(r[12]=t.x,r[13]=t.y,r[14]=t.z):(r[12]=t,r[13]=e,r[14]=i),this}invert(){let t=this.elements,e=t[0],i=t[1],r=t[2],o=t[3],a=t[4],s=t[5],l=t[6],c=t[7],d=t[8],u=t[9],p=t[10],f=t[11],m=t[12],y=t[13],M=t[14],v=t[15],x=u*M*c-y*p*c+y*l*f-s*M*f-u*l*v+s*p*v,R=m*p*c-d*M*c-m*l*f+a*M*f+d*l*v-a*p*v,A=d*y*c-m*u*c+m*s*f-a*y*f-d*s*v+a*u*v,H=m*u*l-d*y*l-m*s*p+a*y*p+d*s*M-a*u*M,te=e*x+i*R+r*A+o*H;if(0===te)return this.set(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0);let K=1/te;return t[0]=x*K,t[1]=(y*p*o-u*M*o-y*r*f+i*M*f+u*r*v-i*p*v)*K,t[2]=(s*M*o-y*l*o+y*r*c-i*M*c-s*r*v+i*l*v)*K,t[3]=(u*l*o-s*p*o-u*r*c+i*p*c+s*r*f-i*l*f)*K,t[4]=R*K,t[5]=(d*M*o-m*p*o+m*r*f-e*M*f-d*r*v+e*p*v)*K,t[6]=(m*l*o-a*M*o-m*r*c+e*M*c+a*r*v-e*l*v)*K,t[7]=(a*p*o-d*l*o+d*r*c-e*p*c-a*r*f+e*l*f)*K,t[8]=A*K,t[9]=(m*u*o-d*y*o-m*i*f+e*y*f+d*i*v-e*u*v)*K,t[10]=(a*y*o-m*s*o+m*i*c-e*y*c-a*i*v+e*s*v)*K,t[11]=(d*s*o-a*u*o-d*i*c+e*u*c+a*i*f-e*s*f)*K,t[12]=H*K,t[13]=(d*y*r-m*u*r+m*i*p-e*y*p-d*i*M+e*u*M)*K,t[14]=(m*s*r-a*y*r-m*i*l+e*y*l+a*i*M-e*s*M)*K,t[15]=(a*u*r-d*s*r+d*i*l-e*u*l-a*i*p+e*s*p)*K,this}scale(t){let e=this.elements,i=t.x,r=t.y,o=t.z;return e[0]*=i,e[4]*=r,e[8]*=o,e[1]*=i,e[5]*=r,e[9]*=o,e[2]*=i,e[6]*=r,e[10]*=o,e[3]*=i,e[7]*=r,e[11]*=o,this}getMaxScaleOnAxis(){let t=this.elements;return Math.sqrt(Math.max(t[0]*t[0]+t[1]*t[1]+t[2]*t[2],t[4]*t[4]+t[5]*t[5]+t[6]*t[6],t[8]*t[8]+t[9]*t[9]+t[10]*t[10]))}makeTranslation(t,e,i){return this.set(1,0,0,t,0,1,0,e,0,0,1,i,0,0,0,1),this}makeRotationX(t){let e=Math.cos(t),i=Math.sin(t);return this.set(1,0,0,0,0,e,-i,0,0,i,e,0,0,0,0,1),this}makeRotationY(t){let e=Math.cos(t),i=Math.sin(t);return this.set(e,0,i,0,0,1,0,0,-i,0,e,0,0,0,0,1),this}makeRotationZ(t){let e=Math.cos(t),i=Math.sin(t);return this.set(e,-i,0,0,i,e,0,0,0,0,1,0,0,0,0,1),this}makeRotationAxis(t,e){let i=Math.cos(e),r=Math.sin(e),o=1-i,a=t.x,s=t.y,l=t.z,c=o*a,d=o*s;return this.set(c*a+i,c*s-r*l,c*l+r*s,0,c*s+r*l,d*s+i,d*l-r*a,0,c*l-r*s,d*l+r*a,o*l*l+i,0,0,0,0,1),this}makeScale(t,e,i){return this.set(t,0,0,0,0,e,0,0,0,0,i,0,0,0,0,1),this}makeShear(t,e,i,r,o,a){return this.set(1,i,o,0,t,1,a,0,e,r,1,0,0,0,0,1),this}compose(t,e,i){let r=this.elements,o=e._x,a=e._y,s=e._z,l=e._w,c=o+o,d=a+a,u=s+s,p=o*c,f=o*d,m=o*u,y=a*d,M=a*u,v=s*u,x=l*c,R=l*d,A=l*u,H=i.x,te=i.y,K=i.z;return r[0]=(1-(y+v))*H,r[1]=(f+A)*H,r[2]=(m-R)*H,r[3]=0,r[4]=(f-A)*te,r[5]=(1-(p+v))*te,r[6]=(M+x)*te,r[7]=0,r[8]=(m+R)*K,r[9]=(M-x)*K,r[10]=(1-(p+y))*K,r[11]=0,r[12]=t.x,r[13]=t.y,r[14]=t.z,r[15]=1,this}decompose(t,e,i){let r=this.elements,o=L0.set(r[0],r[1],r[2]).length(),a=L0.set(r[4],r[5],r[6]).length(),s=L0.set(r[8],r[9],r[10]).length();this.determinant()<0&&(o=-o),t.x=r[12],t.y=r[13],t.z=r[14],ql.copy(this);let c=1/o,d=1/a,u=1/s;return ql.elements[0]*=c,ql.elements[1]*=c,ql.elements[2]*=c,ql.elements[4]*=d,ql.elements[5]*=d,ql.elements[6]*=d,ql.elements[8]*=u,ql.elements[9]*=u,ql.elements[10]*=u,e.setFromRotationMatrix(ql),i.x=o,i.y=a,i.z=s,this}makePerspective(t,e,i,r,o,a){void 0===a&&console.warn("THREE.Matrix4: .makePerspective() has been redefined and has a new signature. Please check the docs.");let s=this.elements,c=2*o/(i-r),d=(e+t)/(e-t),u=(i+r)/(i-r),p=-(a+o)/(a-o),f=-2*a*o/(a-o);return s[0]=2*o/(e-t),s[4]=0,s[8]=d,s[12]=0,s[1]=0,s[5]=c,s[9]=u,s[13]=0,s[2]=0,s[6]=0,s[10]=p,s[14]=f,s[3]=0,s[7]=0,s[11]=-1,s[15]=0,this}makeOrthographic(t,e,i,r,o,a){let s=this.elements,l=1/(e-t),c=1/(i-r),d=1/(a-o),u=(e+t)*l,p=(i+r)*c,f=(a+o)*d;return s[0]=2*l,s[4]=0,s[8]=0,s[12]=-u,s[1]=0,s[5]=2*c,s[9]=0,s[13]=-p,s[2]=0,s[6]=0,s[10]=-2*d,s[14]=-f,s[3]=0,s[7]=0,s[11]=0,s[15]=1,this}equals(t){let e=this.elements,i=t.elements;for(let r=0;r<16;r++)if(e[r]!==i[r])return!1;return!0}fromArray(t,e=0){for(let i=0;i<16;i++)this.elements[i]=t[i+e];return this}toArray(t=[],e=0){let i=this.elements;return t[e]=i[0],t[e+1]=i[1],t[e+2]=i[2],t[e+3]=i[3],t[e+4]=i[4],t[e+5]=i[5],t[e+6]=i[6],t[e+7]=i[7],t[e+8]=i[8],t[e+9]=i[9],t[e+10]=i[10],t[e+11]=i[11],t[e+12]=i[12],t[e+13]=i[13],t[e+14]=i[14],t[e+15]=i[15],t}};Mn.prototype.isMatrix4=!0;var L0=new $,ql=new Mn,iRe=new $(0,0,0),rRe=new $(1,1,1),fp=new $,QD=new $,ms=new $,aee=new Mn,see=new aa,Ep=class{constructor(t=0,e=0,i=0,r=Ep.DefaultOrder){this._x=t,this._y=e,this._z=i,this._order=r}get x(){return this._x}set x(t){this._x=t,this._onChangeCallback()}get y(){return this._y}set y(t){this._y=t,this._onChangeCallback()}get z(){return this._z}set z(t){this._z=t,this._onChangeCallback()}get order(){return this._order}set order(t){this._order=t,this._onChangeCallback()}set(t,e,i,r=this._order){return this._x=t,this._y=e,this._z=i,this._order=r,this._onChangeCallback(),this}clone(){return new this.constructor(this._x,this._y,this._z,this._order)}copy(t){return this._x=t._x,this._y=t._y,this._z=t._z,this._order=t._order,this._onChangeCallback(),this}setFromRotationMatrix(t,e=this._order,i=!0){let r=t.elements,o=r[0],a=r[4],s=r[8],l=r[1],c=r[5],d=r[9],u=r[2],p=r[6],f=r[10];switch(e){case"XYZ":this._y=Math.asin(Xa(s,-1,1)),Math.abs(s)<.9999999?(this._x=Math.atan2(-d,f),this._z=Math.atan2(-a,o)):(this._x=Math.atan2(p,c),this._z=0);break;case"YXZ":this._x=Math.asin(-Xa(d,-1,1)),Math.abs(d)<.9999999?(this._y=Math.atan2(s,f),this._z=Math.atan2(l,c)):(this._y=Math.atan2(-u,o),this._z=0);break;case"ZXY":this._x=Math.asin(Xa(p,-1,1)),Math.abs(p)<.9999999?(this._y=Math.atan2(-u,f),this._z=Math.atan2(-a,c)):(this._y=0,this._z=Math.atan2(l,o));break;case"ZYX":this._y=Math.asin(-Xa(u,-1,1)),Math.abs(u)<.9999999?(this._x=Math.atan2(p,f),this._z=Math.atan2(l,o)):(this._x=0,this._z=Math.atan2(-a,c));break;case"YZX":this._z=Math.asin(Xa(l,-1,1)),Math.abs(l)<.9999999?(this._x=Math.atan2(-d,c),this._y=Math.atan2(-u,o)):(this._x=0,this._y=Math.atan2(s,f));break;case"XZY":this._z=Math.asin(-Xa(a,-1,1)),Math.abs(a)<.9999999?(this._x=Math.atan2(p,c),this._y=Math.atan2(s,o)):(this._x=Math.atan2(-d,f),this._y=0);break;default:console.warn("THREE.Euler: .setFromRotationMatrix() encountered an unknown order: "+e)}return this._order=e,!0===i&&this._onChangeCallback(),this}setFromQuaternion(t,e,i){return aee.makeRotationFromQuaternion(t),this.setFromRotationMatrix(aee,e,i)}setFromVector3(t,e=this._order){return this.set(t.x,t.y,t.z,e)}reorder(t){return see.setFromEuler(this),this.setFromQuaternion(see,t)}equals(t){return t._x===this._x&&t._y===this._y&&t._z===this._z&&t._order===this._order}fromArray(t){return this._x=t[0],this._y=t[1],this._z=t[2],void 0!==t[3]&&(this._order=t[3]),this._onChangeCallback(),this}toArray(t=[],e=0){return t[e]=this._x,t[e+1]=this._y,t[e+2]=this._z,t[e+3]=this._order,t}toVector3(t){return t?t.set(this._x,this._y,this._z):new $(this._x,this._y,this._z)}_onChange(t){return this._onChangeCallback=t,this}_onChangeCallback(){}};Ep.prototype.isEuler=!0,Ep.DefaultOrder="XYZ",Ep.RotationOrders=["XYZ","YZX","ZXY","XZY","YXZ","ZYX"];var TI=class{constructor(){this.mask=1}set(t){this.mask=(1<<t|0)>>>0}enable(t){this.mask|=1<<t|0}enableAll(){this.mask=-1}toggle(t){this.mask^=1<<t|0}disable(t){this.mask&=~(1<<t|0)}disableAll(){this.mask=0}test(t){return 0!=(this.mask&t.mask)}isEnabled(t){return 0!=(this.mask&(1<<t|0))}},oRe=0,lee=new $,N0=new aa,Bd=new Mn,ZD=new $,ux=new $,aRe=new $,sRe=new aa,cee=new $(1,0,0),dee=new $(0,1,0),uee=new $(0,0,1),lRe={type:"added"},pee={type:"removed"},zi=class extends Ud{constructor(){super(),Object.defineProperty(this,"id",{value:oRe++}),this.uuid=Ql(),this.name="",this.type="Object3D",this.parent=null,this.children=[],this.up=zi.DefaultUp.clone();let t=new $,e=new Ep,i=new aa,r=new $(1,1,1);e._onChange(function(){i.setFromEuler(e,!1)}),i._onChange(function(){e.setFromQuaternion(i,void 0,!1)}),Object.defineProperties(this,{position:{configurable:!0,enumerable:!0,value:t},rotation:{configurable:!0,enumerable:!0,value:e},quaternion:{configurable:!0,enumerable:!0,value:i},scale:{configurable:!0,enumerable:!0,value:r},modelViewMatrix:{value:new Mn},normalMatrix:{value:new vo}}),this.matrix=new Mn,this.matrixWorld=new Mn,this.matrixAutoUpdate=zi.DefaultMatrixAutoUpdate,this.matrixWorldNeedsUpdate=!1,this.layers=new TI,this.visible=!0,this.castShadow=!1,this.receiveShadow=!1,this.frustumCulled=!0,this.renderOrder=0,this.animations=[],this.userData={}}onBeforeRender(){}onAfterRender(){}applyMatrix4(t){this.matrixAutoUpdate&&this.updateMatrix(),this.matrix.premultiply(t),this.matrix.decompose(this.position,this.quaternion,this.scale)}applyQuaternion(t){return this.quaternion.premultiply(t),this}setRotationFromAxisAngle(t,e){this.quaternion.setFromAxisAngle(t,e)}setRotationFromEuler(t){this.quaternion.setFromEuler(t,!0)}setRotationFromMatrix(t){this.quaternion.setFromRotationMatrix(t)}setRotationFromQuaternion(t){this.quaternion.copy(t)}rotateOnAxis(t,e){return N0.setFromAxisAngle(t,e),this.quaternion.multiply(N0),this}rotateOnWorldAxis(t,e){return N0.setFromAxisAngle(t,e),this.quaternion.premultiply(N0),this}rotateX(t){return this.rotateOnAxis(cee,t)}rotateY(t){return this.rotateOnAxis(dee,t)}rotateZ(t){return this.rotateOnAxis(uee,t)}translateOnAxis(t,e){return lee.copy(t).applyQuaternion(this.quaternion),this.position.add(lee.multiplyScalar(e)),this}translateX(t){return this.translateOnAxis(cee,t)}translateY(t){return this.translateOnAxis(dee,t)}translateZ(t){return this.translateOnAxis(uee,t)}localToWorld(t){return t.applyMatrix4(this.matrixWorld)}worldToLocal(t){return t.applyMatrix4(Bd.copy(this.matrixWorld).invert())}lookAt(t,e,i){t.isVector3?ZD.copy(t):ZD.set(t,e,i);let r=this.parent;this.updateWorldMatrix(!0,!1),ux.setFromMatrixPosition(this.matrixWorld),this.isCamera||this.isLight?Bd.lookAt(ux,ZD,this.up):Bd.lookAt(ZD,ux,this.up),this.quaternion.setFromRotationMatrix(Bd),r&&(Bd.extractRotation(r.matrixWorld),N0.setFromRotationMatrix(Bd),this.quaternion.premultiply(N0.invert()))}add(t){if(arguments.length>1){for(let e=0;e<arguments.length;e++)this.add(arguments[e]);return this}return t===this?(console.error("THREE.Object3D.add: object can't be added as a child of itself.",t),this):(t&&t.isObject3D?(null!==t.parent&&t.parent.remove(t),t.parent=this,this.children.push(t),t.dispatchEvent(lRe)):console.error("THREE.Object3D.add: object not an instance of THREE.Object3D.",t),this)}remove(t){if(arguments.length>1){for(let i=0;i<arguments.length;i++)this.remove(arguments[i]);return this}let e=this.children.indexOf(t);return-1!==e&&(t.parent=null,this.children.splice(e,1),t.dispatchEvent(pee)),this}removeFromParent(){let t=this.parent;return null!==t&&t.remove(this),this}clear(){for(let t=0;t<this.children.length;t++){let e=this.children[t];e.parent=null,e.dispatchEvent(pee)}return this.children.length=0,this}attach(t){return this.updateWorldMatrix(!0,!1),Bd.copy(this.matrixWorld).invert(),null!==t.parent&&(t.parent.updateWorldMatrix(!0,!1),Bd.multiply(t.parent.matrixWorld)),t.applyMatrix4(Bd),this.add(t),t.updateWorldMatrix(!1,!0),this}getObjectById(t){return this.getObjectByProperty("id",t)}getObjectByName(t){return this.getObjectByProperty("name",t)}getObjectByProperty(t,e){if(this[t]===e)return this;for(let i=0,r=this.children.length;i<r;i++){let a=this.children[i].getObjectByProperty(t,e);if(void 0!==a)return a}}getWorldPosition(t){return this.updateWorldMatrix(!0,!1),t.setFromMatrixPosition(this.matrixWorld)}getWorldQuaternion(t){return this.updateWorldMatrix(!0,!1),this.matrixWorld.decompose(ux,t,aRe),t}getWorldScale(t){return this.updateWorldMatrix(!0,!1),this.matrixWorld.decompose(ux,sRe,t),t}getWorldDirection(t){this.updateWorldMatrix(!0,!1);let e=this.matrixWorld.elements;return t.set(e[8],e[9],e[10]).normalize()}raycast(){}traverse(t){t(this);let e=this.children;for(let i=0,r=e.length;i<r;i++)e[i].traverse(t)}traverseVisible(t){if(!1===this.visible)return;t(this);let e=this.children;for(let i=0,r=e.length;i<r;i++)e[i].traverseVisible(t)}traverseAncestors(t){let e=this.parent;null!==e&&(t(e),e.traverseAncestors(t))}updateMatrix(){this.matrix.compose(this.position,this.quaternion,this.scale),this.matrixWorldNeedsUpdate=!0}updateMatrixWorld(t){this.matrixAutoUpdate&&this.updateMatrix(),(this.matrixWorldNeedsUpdate||t)&&(null===this.parent?this.matrixWorld.copy(this.matrix):this.matrixWorld.multiplyMatrices(this.parent.matrixWorld,this.matrix),this.matrixWorldNeedsUpdate=!1,t=!0);let e=this.children;for(let i=0,r=e.length;i<r;i++)e[i].updateMatrixWorld(t)}updateWorldMatrix(t,e){let i=this.parent;if(!0===t&&null!==i&&i.updateWorldMatrix(!0,!1),this.matrixAutoUpdate&&this.updateMatrix(),null===this.parent?this.matrixWorld.copy(this.matrix):this.matrixWorld.multiplyMatrices(this.parent.matrixWorld,this.matrix),!0===e){let r=this.children;for(let o=0,a=r.length;o<a;o++)r[o].updateWorldMatrix(!1,!0)}}toJSON(t){let e=void 0===t||"string"==typeof t,i={};e&&(t={geometries:{},materials:{},textures:{},images:{},shapes:{},skeletons:{},animations:{}},i.metadata={version:4.5,type:"Object",generator:"Object3D.toJSON"});let r={};function o(s,l){return void 0===s[l.uuid]&&(s[l.uuid]=l.toJSON(t)),l.uuid}if(r.uuid=this.uuid,r.type=this.type,""!==this.name&&(r.name=this.name),!0===this.castShadow&&(r.castShadow=!0),!0===this.receiveShadow&&(r.receiveShadow=!0),!1===this.visible&&(r.visible=!1),!1===this.frustumCulled&&(r.frustumCulled=!1),0!==this.renderOrder&&(r.renderOrder=this.renderOrder),"{}"!==JSON.stringify(this.userData)&&(r.userData=this.userData),r.layers=this.layers.mask,r.matrix=this.matrix.toArray(),!1===this.matrixAutoUpdate&&(r.matrixAutoUpdate=!1),this.isInstancedMesh&&(r.type="InstancedMesh",r.count=this.count,r.instanceMatrix=this.instanceMatrix.toJSON(),null!==this.instanceColor&&(r.instanceColor=this.instanceColor.toJSON())),this.isScene)this.background&&(this.background.isColor?r.background=this.background.toJSON():this.background.isTexture&&(r.background=this.background.toJSON(t).uuid)),this.environment&&this.environment.isTexture&&(r.environment=this.environment.toJSON(t).uuid);else if(this.isMesh||this.isLine||this.isPoints){r.geometry=o(t.geometries,this.geometry);let s=this.geometry.parameters;if(void 0!==s&&void 0!==s.shapes){let l=s.shapes;if(Array.isArray(l))for(let c=0,d=l.length;c<d;c++)o(t.shapes,l[c]);else o(t.shapes,l)}}if(this.isSkinnedMesh&&(r.bindMode=this.bindMode,r.bindMatrix=this.bindMatrix.toArray(),void 0!==this.skeleton&&(o(t.skeletons,this.skeleton),r.skeleton=this.skeleton.uuid)),void 0!==this.material)if(Array.isArray(this.material)){let s=[];for(let l=0,c=this.material.length;l<c;l++)s.push(o(t.materials,this.material[l]));r.material=s}else r.material=o(t.materials,this.material);if(this.children.length>0){r.children=[];for(let s=0;s<this.children.length;s++)r.children.push(this.children[s].toJSON(t).object)}if(this.animations.length>0){r.animations=[];for(let s=0;s<this.animations.length;s++)r.animations.push(o(t.animations,this.animations[s]))}if(e){let s=a(t.geometries),l=a(t.materials),c=a(t.textures),d=a(t.images),u=a(t.shapes),p=a(t.skeletons),f=a(t.animations);s.length>0&&(i.geometries=s),l.length>0&&(i.materials=l),c.length>0&&(i.textures=c),d.length>0&&(i.images=d),u.length>0&&(i.shapes=u),p.length>0&&(i.skeletons=p),f.length>0&&(i.animations=f)}return i.object=r,i;function a(s){let l=[];for(let c in s){let d=s[c];delete d.metadata,l.push(d)}return l}}clone(t){return(new this.constructor).copy(this,t)}copy(t,e=!0){if(this.name=t.name,this.up.copy(t.up),this.position.copy(t.position),this.rotation.order=t.rotation.order,this.quaternion.copy(t.quaternion),this.scale.copy(t.scale),this.matrix.copy(t.matrix),this.matrixWorld.copy(t.matrixWorld),this.matrixAutoUpdate=t.matrixAutoUpdate,this.matrixWorldNeedsUpdate=t.matrixWorldNeedsUpdate,this.layers.mask=t.layers.mask,this.visible=t.visible,this.castShadow=t.castShadow,this.receiveShadow=t.receiveShadow,this.frustumCulled=t.frustumCulled,this.renderOrder=t.renderOrder,this.userData=JSON.parse(JSON.stringify(t.userData)),!0===e)for(let i=0;i<t.children.length;i++)this.add(t.children[i].clone());return this}};zi.DefaultUp=new $(0,1,0),zi.DefaultMatrixAutoUpdate=!0,zi.prototype.isObject3D=!0;var Yl=new $,Vd=new $,$3=new $,Hd=new $,B0=new $,V0=new $,fee=new $,eB=new $,tB=new $,nB=new $,jr=class{constructor(t=new $,e=new $,i=new $){this.a=t,this.b=e,this.c=i}static getNormal(t,e,i,r){r.subVectors(i,e),Yl.subVectors(t,e),r.cross(Yl);let o=r.lengthSq();return o>0?r.multiplyScalar(1/Math.sqrt(o)):r.set(0,0,0)}static getBarycoord(t,e,i,r,o){Yl.subVectors(r,e),Vd.subVectors(i,e),$3.subVectors(t,e);let a=Yl.dot(Yl),s=Yl.dot(Vd),l=Yl.dot($3),c=Vd.dot(Vd),d=Vd.dot($3),u=a*c-s*s;if(0===u)return o.set(-2,-1,-1);let p=1/u,f=(c*l-s*d)*p,m=(a*d-s*l)*p;return o.set(1-f-m,m,f)}static containsPoint(t,e,i,r){return this.getBarycoord(t,e,i,r,Hd),Hd.x>=0&&Hd.y>=0&&Hd.x+Hd.y<=1}static getUV(t,e,i,r,o,a,s,l){return this.getBarycoord(t,e,i,r,Hd),l.set(0,0),l.addScaledVector(o,Hd.x),l.addScaledVector(a,Hd.y),l.addScaledVector(s,Hd.z),l}static isFrontFacing(t,e,i,r){return Yl.subVectors(i,e),Vd.subVectors(t,e),Yl.cross(Vd).dot(r)<0}set(t,e,i){return this.a.copy(t),this.b.copy(e),this.c.copy(i),this}setFromPointsAndIndices(t,e,i,r){return this.a.copy(t[e]),this.b.copy(t[i]),this.c.copy(t[r]),this}setFromAttributeAndIndices(t,e,i,r){return this.a.fromBufferAttribute(t,e),this.b.fromBufferAttribute(t,i),this.c.fromBufferAttribute(t,r),this}clone(){return(new this.constructor).copy(this)}copy(t){return this.a.copy(t.a),this.b.copy(t.b),this.c.copy(t.c),this}getArea(){return Yl.subVectors(this.c,this.b),Vd.subVectors(this.a,this.b),.5*Yl.cross(Vd).length()}getMidpoint(t){return t.addVectors(this.a,this.b).add(this.c).multiplyScalar(1/3)}getNormal(t){return jr.getNormal(this.a,this.b,this.c,t)}getPlane(t){return t.setFromCoplanarPoints(this.a,this.b,this.c)}getBarycoord(t,e){return jr.getBarycoord(t,this.a,this.b,this.c,e)}getUV(t,e,i,r,o){return jr.getUV(t,this.a,this.b,this.c,e,i,r,o)}containsPoint(t){return jr.containsPoint(t,this.a,this.b,this.c)}isFrontFacing(t){return jr.isFrontFacing(this.a,this.b,this.c,t)}intersectsBox(t){return t.intersectsTriangle(this)}closestPointToPoint(t,e){let a,s,i=this.a,r=this.b,o=this.c;B0.subVectors(r,i),V0.subVectors(o,i),eB.subVectors(t,i);let l=B0.dot(eB),c=V0.dot(eB);if(l<=0&&c<=0)return e.copy(i);tB.subVectors(t,r);let d=B0.dot(tB),u=V0.dot(tB);if(d>=0&&u<=d)return e.copy(r);let p=l*u-d*c;if(p<=0&&l>=0&&d<=0)return a=l/(l-d),e.copy(i).addScaledVector(B0,a);nB.subVectors(t,o);let f=B0.dot(nB),m=V0.dot(nB);if(m>=0&&f<=m)return e.copy(o);let y=f*c-l*m;if(y<=0&&c>=0&&m<=0)return s=c/(c-m),e.copy(i).addScaledVector(V0,s);let M=d*m-f*u;if(M<=0&&u-d>=0&&f-m>=0)return fee.subVectors(o,r),s=(u-d)/(u-d+(f-m)),e.copy(r).addScaledVector(fee,s);let v=1/(M+y+p);return a=y*v,s=p*v,e.copy(i).addScaledVector(B0,a).addScaledVector(V0,s)}equals(t){return t.a.equals(this.a)&&t.b.equals(this.b)&&t.c.equals(this.c)}},cRe=0,Ro=class extends Ud{constructor(){super(),Object.defineProperty(this,"id",{value:cRe++}),this.uuid=Ql(),this.name="",this.type="Material",this.fog=!0,this.blending=xx,this.side=Sx,this.vertexColors=!1,this.opacity=1,this.transparent=!1,this.blendSrc=dte,this.blendDst=ute,this.blendEquation=K0,this.blendSrcAlpha=null,this.blendDstAlpha=null,this.blendEquationAlpha=null,this.depthFunc=vB,this.depthTest=!0,this.depthWrite=!0,this.stencilWriteMask=255,this.stencilFunc=519,this.stencilRef=0,this.stencilFuncMask=255,this.stencilFail=7680,this.stencilZFail=7680,this.stencilZPass=7680,this.stencilWrite=!1,this.clippingPlanes=null,this.clipIntersection=!1,this.clipShadows=!1,this.shadowSide=null,this.colorWrite=!0,this.alphaWrite=!0,this.precision=null,this.polygonOffset=!1,this.polygonOffsetFactor=0,this.polygonOffsetUnits=0,this.dithering=!1,this.alphaToCoverage=!1,this.premultipliedAlpha=!1,this.visible=!0,this.toneMapped=!0,this.userData={},this.version=0,this._alphaTest=0}get alphaTest(){return this._alphaTest}set alphaTest(t){this._alphaTest>0!=t>0&&this.version++,this._alphaTest=t}onBuild(){}onBeforeRender(){}onBeforeCompile(){}customProgramCacheKey(){return this.onBeforeCompile.toString()}setValues(t){if(void 0!==t)for(let e in t){let i=t[e];if(void 0===i){console.warn("THREE.Material: '"+e+"' parameter is undefined.");continue}if("shading"===e){console.warn("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead."),this.flatShading=1===i;continue}let r=this[e];void 0!==r?r&&r.isColor?r.set(i):r&&r.isVector3&&i&&i.isVector3?r.copy(i):this[e]=i:console.warn("THREE."+this.type+": '"+e+"' is not a property of this material.")}}toJSON(t){let e=void 0===t||"string"==typeof t;e&&(t={textures:{},images:{}});let i={metadata:{version:4.5,type:"Material",generator:"Material.toJSON"}};function r(o){let a=[];for(let s in o){let l=o[s];delete l.metadata,a.push(l)}return a}if(i.uuid=this.uuid,i.type=this.type,""!==this.name&&(i.name=this.name),this.color&&this.color.isColor&&(i.color=this.color.getHex()),void 0!==this.roughness&&(i.roughness=this.roughness),void 0!==this.metalness&&(i.metalness=this.metalness),void 0!==this.sheen&&(i.sheen=this.sheen),this.sheenColor&&this.sheenColor.isColor&&(i.sheenColor=this.sheenColor.getHex()),void 0!==this.sheenRoughness&&(i.sheenRoughness=this.sheenRoughness),this.emissive&&this.emissive.isColor&&(i.emissive=this.emissive.getHex()),this.emissiveIntensity&&1!==this.emissiveIntensity&&(i.emissiveIntensity=this.emissiveIntensity),this.specular&&this.specular.isColor&&(i.specular=this.specular.getHex()),void 0!==this.specularIntensity&&(i.specularIntensity=this.specularIntensity),this.specularColor&&this.specularColor.isColor&&(i.specularColor=this.specularColor.getHex()),void 0!==this.shininess&&(i.shininess=this.shininess),void 0!==this.clearcoat&&(i.clearcoat=this.clearcoat),void 0!==this.clearcoatRoughness&&(i.clearcoatRoughness=this.clearcoatRoughness),this.clearcoatMap&&this.clearcoatMap.isTexture&&(i.clearcoatMap=this.clearcoatMap.toJSON(t).uuid),this.clearcoatRoughnessMap&&this.clearcoatRoughnessMap.isTexture&&(i.clearcoatRoughnessMap=this.clearcoatRoughnessMap.toJSON(t).uuid),this.clearcoatNormalMap&&this.clearcoatNormalMap.isTexture&&(i.clearcoatNormalMap=this.clearcoatNormalMap.toJSON(t).uuid,i.clearcoatNormalScale=this.clearcoatNormalScale.toArray()),this.map&&this.map.isTexture&&(i.map=this.map.toJSON(t).uuid),this.matcap&&this.matcap.isTexture&&(i.matcap=this.matcap.toJSON(t).uuid),this.alphaMap&&this.alphaMap.isTexture&&(i.alphaMap=this.alphaMap.toJSON(t).uuid),this.lightMap&&this.lightMap.isTexture&&(i.lightMap=this.lightMap.toJSON(t).uuid,i.lightMapIntensity=this.lightMapIntensity),this.aoMap&&this.aoMap.isTexture&&(i.aoMap=this.aoMap.toJSON(t).uuid,i.aoMapIntensity=this.aoMapIntensity),this.bumpMap&&this.bumpMap.isTexture&&(i.bumpMap=this.bumpMap.toJSON(t).uuid,i.bumpScale=this.bumpScale),this.normalMap&&this.normalMap.isTexture&&(i.normalMap=this.normalMap.toJSON(t).uuid,i.normalMapType=this.normalMapType,i.normalScale=this.normalScale.toArray()),this.displacementMap&&this.displacementMap.isTexture&&(i.displacementMap=this.displacementMap.toJSON(t).uuid,i.displacementScale=this.displacementScale,i.displacementBias=this.displacementBias),this.roughnessMap&&this.roughnessMap.isTexture&&(i.roughnessMap=this.roughnessMap.toJSON(t).uuid),this.metalnessMap&&this.metalnessMap.isTexture&&(i.metalnessMap=this.metalnessMap.toJSON(t).uuid),this.emissiveMap&&this.emissiveMap.isTexture&&(i.emissiveMap=this.emissiveMap.toJSON(t).uuid),this.specularMap&&this.specularMap.isTexture&&(i.specularMap=this.specularMap.toJSON(t).uuid),this.specularIntensityMap&&this.specularIntensityMap.isTexture&&(i.specularIntensityMap=this.specularIntensityMap.toJSON(t).uuid),this.specularColorMap&&this.specularColorMap.isTexture&&(i.specularColorMap=this.specularColorMap.toJSON(t).uuid),this.envMap&&this.envMap.isTexture&&(i.envMap=this.envMap.toJSON(t).uuid,void 0!==this.combine&&(i.combine=this.combine)),void 0!==this.envMapIntensity&&(i.envMapIntensity=this.envMapIntensity),void 0!==this.reflectivity&&(i.reflectivity=this.reflectivity),void 0!==this.refractionRatio&&(i.refractionRatio=this.refractionRatio),this.gradientMap&&this.gradientMap.isTexture&&(i.gradientMap=this.gradientMap.toJSON(t).uuid),void 0!==this.transmission&&(i.transmission=this.transmission),this.transmissionMap&&this.transmissionMap.isTexture&&(i.transmissionMap=this.transmissionMap.toJSON(t).uuid),void 0!==this.thickness&&(i.thickness=this.thickness),this.thicknessMap&&this.thicknessMap.isTexture&&(i.thicknessMap=this.thicknessMap.toJSON(t).uuid),void 0!==this.attenuationDistance&&(i.attenuationDistance=this.attenuationDistance),void 0!==this.attenuationColor&&(i.attenuationColor=this.attenuationColor.getHex()),void 0!==this.size&&(i.size=this.size),null!==this.shadowSide&&(i.shadowSide=this.shadowSide),void 0!==this.sizeAttenuation&&(i.sizeAttenuation=this.sizeAttenuation),this.blending!==xx&&(i.blending=this.blending),this.side!==Sx&&(i.side=this.side),this.vertexColors&&(i.vertexColors=!0),this.opacity<1&&(i.opacity=this.opacity),!0===this.transparent&&(i.transparent=this.transparent),i.depthFunc=this.depthFunc,i.depthTest=this.depthTest,i.depthWrite=this.depthWrite,i.colorWrite=this.colorWrite,i.alphaWrite=this.alphaWrite,i.stencilWrite=this.stencilWrite,i.stencilWriteMask=this.stencilWriteMask,i.stencilFunc=this.stencilFunc,i.stencilRef=this.stencilRef,i.stencilFuncMask=this.stencilFuncMask,i.stencilFail=this.stencilFail,i.stencilZFail=this.stencilZFail,i.stencilZPass=this.stencilZPass,this.rotation&&0!==this.rotation&&(i.rotation=this.rotation),!0===this.polygonOffset&&(i.polygonOffset=!0),0!==this.polygonOffsetFactor&&(i.polygonOffsetFactor=this.polygonOffsetFactor),0!==this.polygonOffsetUnits&&(i.polygonOffsetUnits=this.polygonOffsetUnits),this.linewidth&&1!==this.linewidth&&(i.linewidth=this.linewidth),void 0!==this.dashSize&&(i.dashSize=this.dashSize),void 0!==this.gapSize&&(i.gapSize=this.gapSize),void 0!==this.scale&&(i.scale=this.scale),!0===this.dithering&&(i.dithering=!0),this.alphaTest>0&&(i.alphaTest=this.alphaTest),!0===this.alphaToCoverage&&(i.alphaToCoverage=this.alphaToCoverage),!0===this.premultipliedAlpha&&(i.premultipliedAlpha=this.premultipliedAlpha),!0===this.wireframe&&(i.wireframe=this.wireframe),this.wireframeLinewidth>1&&(i.wireframeLinewidth=this.wireframeLinewidth),"round"!==this.wireframeLinecap&&(i.wireframeLinecap=this.wireframeLinecap),"round"!==this.wireframeLinejoin&&(i.wireframeLinejoin=this.wireframeLinejoin),!0===this.flatShading&&(i.flatShading=this.flatShading),!1===this.visible&&(i.visible=!1),!1===this.toneMapped&&(i.toneMapped=!1),"{}"!==JSON.stringify(this.userData)&&(i.userData=this.userData),e){let o=r(t.textures),a=r(t.images);o.length>0&&(i.textures=o),a.length>0&&(i.images=a)}return i}clone(){return(new this.constructor).copy(this)}copy(t){this.name=t.name,this.fog=t.fog,this.blending=t.blending,this.side=t.side,this.vertexColors=t.vertexColors,this.opacity=t.opacity,this.transparent=t.transparent,this.blendSrc=t.blendSrc,this.blendDst=t.blendDst,this.blendEquation=t.blendEquation,this.blendSrcAlpha=t.blendSrcAlpha,this.blendDstAlpha=t.blendDstAlpha,this.blendEquationAlpha=t.blendEquationAlpha,this.depthFunc=t.depthFunc,this.depthTest=t.depthTest,this.depthWrite=t.depthWrite,this.stencilWriteMask=t.stencilWriteMask,this.stencilFunc=t.stencilFunc,this.stencilRef=t.stencilRef,this.stencilFuncMask=t.stencilFuncMask,this.stencilFail=t.stencilFail,this.stencilZFail=t.stencilZFail,this.stencilZPass=t.stencilZPass,this.stencilWrite=t.stencilWrite;let e=t.clippingPlanes,i=null;if(null!==e){let r=e.length;i=new Array(r);for(let o=0;o!==r;++o)i[o]=e[o].clone()}return this.clippingPlanes=i,this.clipIntersection=t.clipIntersection,this.clipShadows=t.clipShadows,this.shadowSide=t.shadowSide,this.colorWrite=t.colorWrite,this.alphaWrite=t.alphaWrite,this.precision=t.precision,this.polygonOffset=t.polygonOffset,this.polygonOffsetFactor=t.polygonOffsetFactor,this.polygonOffsetUnits=t.polygonOffsetUnits,this.dithering=t.dithering,this.alphaTest=t.alphaTest,this.alphaToCoverage=t.alphaToCoverage,this.premultipliedAlpha=t.premultipliedAlpha,this.visible=t.visible,this.toneMapped=t.toneMapped,this.userData=JSON.parse(JSON.stringify(t.userData)),this}dispose(){this.dispatchEvent({type:"dispose"})}set needsUpdate(t){!0===t&&this.version++}};Ro.prototype.isMaterial=!0;var Sm=class extends Ro{constructor(t){super(),this.type="MeshBasicMaterial",this.color=new an(16777215),this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.specularMap=null,this.alphaMap=null,this.envMap=null,this.combine=JI,this.reflectivity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.specularMap=t.specularMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.combine=t.combine,this.reflectivity=t.reflectivity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this}};Sm.prototype.isMeshBasicMaterial=!0;var dr=new $,KD=new $e,Ar=class{constructor(t,e,i){if(Array.isArray(t))throw new TypeError("THREE.BufferAttribute: array should be a Typed Array.");this.name="",this.array=t,this.itemSize=e,this.count=void 0!==t?t.length/e:0,this.normalized=!0===i,this.usage=Tx,this.updateRange={offset:0,count:-1},this.version=0}onUploadCallback(){}set needsUpdate(t){!0===t&&this.version++}setUsage(t){return this.usage=t,this}copy(t){return this.name=t.name,this.array=new t.array.constructor(t.array),this.itemSize=t.itemSize,this.count=t.count,this.normalized=t.normalized,this.usage=t.usage,this}copyAt(t,e,i){t*=this.itemSize,i*=e.itemSize;for(let r=0,o=this.itemSize;r<o;r++)this.array[t+r]=e.array[i+r];return this}copyArray(t){return this.array.set(t),this}copyColorsArray(t){let e=this.array,i=0;for(let r=0,o=t.length;r<o;r++){let a=t[r];void 0===a&&(console.warn("THREE.BufferAttribute.copyColorsArray(): color is undefined",r),a=new an),e[i++]=a.r,e[i++]=a.g,e[i++]=a.b}return this}copyVector2sArray(t){let e=this.array,i=0;for(let r=0,o=t.length;r<o;r++){let a=t[r];void 0===a&&(console.warn("THREE.BufferAttribute.copyVector2sArray(): vector is undefined",r),a=new $e),e[i++]=a.x,e[i++]=a.y}return this}copyVector3sArray(t){let e=this.array,i=0;for(let r=0,o=t.length;r<o;r++){let a=t[r];void 0===a&&(console.warn("THREE.BufferAttribute.copyVector3sArray(): vector is undefined",r),a=new $),e[i++]=a.x,e[i++]=a.y,e[i++]=a.z}return this}copyVector4sArray(t){let e=this.array,i=0;for(let r=0,o=t.length;r<o;r++){let a=t[r];void 0===a&&(console.warn("THREE.BufferAttribute.copyVector4sArray(): vector is undefined",r),a=new Ki),e[i++]=a.x,e[i++]=a.y,e[i++]=a.z,e[i++]=a.w}return this}applyMatrix3(t){if(2===this.itemSize)for(let e=0,i=this.count;e<i;e++)KD.fromBufferAttribute(this,e),KD.applyMatrix3(t),this.setXY(e,KD.x,KD.y);else if(3===this.itemSize)for(let e=0,i=this.count;e<i;e++)dr.fromBufferAttribute(this,e),dr.applyMatrix3(t),this.setXYZ(e,dr.x,dr.y,dr.z);return this}applyMatrix4(t){for(let e=0,i=this.count;e<i;e++)dr.x=this.getX(e),dr.y=this.getY(e),dr.z=this.getZ(e),dr.applyMatrix4(t),this.setXYZ(e,dr.x,dr.y,dr.z);return this}applyNormalMatrix(t){for(let e=0,i=this.count;e<i;e++)dr.x=this.getX(e),dr.y=this.getY(e),dr.z=this.getZ(e),dr.applyNormalMatrix(t),this.setXYZ(e,dr.x,dr.y,dr.z);return this}transformDirection(t){for(let e=0,i=this.count;e<i;e++)dr.x=this.getX(e),dr.y=this.getY(e),dr.z=this.getZ(e),dr.transformDirection(t),this.setXYZ(e,dr.x,dr.y,dr.z);return this}set(t,e=0){return this.array.set(t,e),this}getX(t){return this.array[t*this.itemSize]}setX(t,e){return this.array[t*this.itemSize]=e,this}getY(t){return this.array[t*this.itemSize+1]}setY(t,e){return this.array[t*this.itemSize+1]=e,this}getZ(t){return this.array[t*this.itemSize+2]}setZ(t,e){return this.array[t*this.itemSize+2]=e,this}getW(t){return this.array[t*this.itemSize+3]}setW(t,e){return this.array[t*this.itemSize+3]=e,this}setXY(t,e,i){return this.array[0+(t*=this.itemSize)]=e,this.array[t+1]=i,this}setXYZ(t,e,i,r){return this.array[0+(t*=this.itemSize)]=e,this.array[t+1]=i,this.array[t+2]=r,this}setXYZW(t,e,i,r,o){return this.array[0+(t*=this.itemSize)]=e,this.array[t+1]=i,this.array[t+2]=r,this.array[t+3]=o,this}onUpload(t){return this.onUploadCallback=t,this}clone(){return new this.constructor(this.array,this.itemSize).copy(this)}toJSON(){let t={itemSize:this.itemSize,type:this.array.constructor.name,array:Array.prototype.slice.call(this.array),normalized:this.normalized};return""!==this.name&&(t.name=this.name),this.usage!==Tx&&(t.usage=this.usage),(0!==this.updateRange.offset||-1!==this.updateRange.count)&&(t.updateRange=this.updateRange),t}};Ar.prototype.isBufferAttribute=!0;var DI=class extends Ar{constructor(t,e,i){super(new Uint16Array(t),e,i)}},II=class extends Ar{constructor(t,e,i){super(new Uint32Array(t),e,i)}};(class extends Ar{constructor(t,e,i){super(new Uint16Array(t),e,i)}}).prototype.isFloat16BufferAttribute=!0;var Br=class extends Ar{constructor(t,e,i){super(new Float32Array(t),e,i)}},dRe=0,$s=new Mn,iB=new zi,H0=new $,hs=new _s,px=new _s,Ao=new $,Wi=class extends Ud{constructor(){super(),Object.defineProperty(this,"id",{value:dRe++}),this.uuid=Ql(),this.name="",this.type="BufferGeometry",this.index=null,this.attributes={},this.morphAttributes={},this.morphTargetsRelative=!1,this.groups=[],this.boundingBox=null,this.boundingSphere=null,this.drawRange={start:0,count:1/0},this.userData={}}getIndex(){return this.index}setIndex(t){return this.index=Array.isArray(t)?new(mte(t)?II:DI)(t,1):t,this}getAttribute(t){return this.attributes[t]}setAttribute(t,e){return this.attributes[t]=e,this}deleteAttribute(t){return delete this.attributes[t],this}hasAttribute(t){return void 0!==this.attributes[t]}addGroup(t,e,i=0){this.groups.push({start:t,count:e,materialIndex:i})}clearGroups(){this.groups=[]}setDrawRange(t,e){this.drawRange.start=t,this.drawRange.count=e}applyMatrix4(t){let e=this.attributes.position;void 0!==e&&(e.applyMatrix4(t),e.needsUpdate=!0);let i=this.attributes.normal;if(void 0!==i){let o=(new vo).getNormalMatrix(t);i.applyNormalMatrix(o),i.needsUpdate=!0}let r=this.attributes.tangent;return void 0!==r&&(r.transformDirection(t),r.needsUpdate=!0),null!==this.boundingBox&&this.computeBoundingBox(),null!==this.boundingSphere&&this.computeBoundingSphere(),this}applyQuaternion(t){return $s.makeRotationFromQuaternion(t),this.applyMatrix4($s),this}rotateX(t){return $s.makeRotationX(t),this.applyMatrix4($s),this}rotateY(t){return $s.makeRotationY(t),this.applyMatrix4($s),this}rotateZ(t){return $s.makeRotationZ(t),this.applyMatrix4($s),this}translate(t,e,i){return $s.makeTranslation(t,e,i),this.applyMatrix4($s),this}scale(t,e,i){return $s.makeScale(t,e,i),this.applyMatrix4($s),this}lookAt(t){return iB.lookAt(t),iB.updateMatrix(),this.applyMatrix4(iB.matrix),this}center(){return this.computeBoundingBox(),this.boundingBox.getCenter(H0).negate(),this.translate(H0.x,H0.y,H0.z),this}setFromPoints(t){let e=[];for(let i=0,r=t.length;i<r;i++){let o=t[i];e.push(o.x,o.y,o.z||0)}return this.setAttribute("position",new Br(e,3)),this}computeBoundingBox(){null===this.boundingBox&&(this.boundingBox=new _s);let t=this.attributes.position,e=this.morphAttributes.position;if(t&&t.isGLBufferAttribute)return console.error('THREE.BufferGeometry.computeBoundingBox(): GLBufferAttribute requires a manual bounding box. Alternatively set "mesh.frustumCulled" to "false".',this),void this.boundingBox.set(new $(-1/0,-1/0,-1/0),new $(1/0,1/0,1/0));if(void 0!==t){if(this.boundingBox.setFromBufferAttribute(t),e)for(let i=0,r=e.length;i<r;i++)hs.setFromBufferAttribute(e[i]),this.morphTargetsRelative?(Ao.addVectors(this.boundingBox.min,hs.min),this.boundingBox.expandByPoint(Ao),Ao.addVectors(this.boundingBox.max,hs.max),this.boundingBox.expandByPoint(Ao)):(this.boundingBox.expandByPoint(hs.min),this.boundingBox.expandByPoint(hs.max))}else this.boundingBox.makeEmpty();(isNaN(this.boundingBox.min.x)||isNaN(this.boundingBox.min.y)||isNaN(this.boundingBox.min.z))&&console.error('THREE.BufferGeometry.computeBoundingBox(): Computed min/max have NaN values. The "position" attribute is likely to have NaN values.',this)}computeBoundingSphere(){null===this.boundingSphere&&(this.boundingSphere=new wp);let t=this.attributes.position,e=this.morphAttributes.position;if(t&&t.isGLBufferAttribute)return console.error('THREE.BufferGeometry.computeBoundingSphere(): GLBufferAttribute requires a manual bounding sphere. Alternatively set "mesh.frustumCulled" to "false".',this),void this.boundingSphere.set(new $,1/0);if(t){let i=this.boundingSphere.center;if(hs.setFromBufferAttribute(t),e)for(let o=0,a=e.length;o<a;o++)px.setFromBufferAttribute(e[o]),this.morphTargetsRelative?(Ao.addVectors(hs.min,px.min),hs.expandByPoint(Ao),Ao.addVectors(hs.max,px.max),hs.expandByPoint(Ao)):(hs.expandByPoint(px.min),hs.expandByPoint(px.max));hs.getCenter(i);let r=0;for(let o=0,a=t.count;o<a;o++)Ao.fromBufferAttribute(t,o),r=Math.max(r,i.distanceToSquared(Ao));if(e)for(let o=0,a=e.length;o<a;o++){let s=e[o],l=this.morphTargetsRelative;for(let c=0,d=s.count;c<d;c++)Ao.fromBufferAttribute(s,c),l&&(H0.fromBufferAttribute(t,c),Ao.add(H0)),r=Math.max(r,i.distanceToSquared(Ao))}this.boundingSphere.radius=Math.sqrt(r),isNaN(this.boundingSphere.radius)&&console.error('THREE.BufferGeometry.computeBoundingSphere(): Computed radius is NaN. The "position" attribute is likely to have NaN values.',this)}}computeTangents(){let t=this.index,e=this.attributes;if(null===t||void 0===e.position||void 0===e.normal||void 0===e.uv)return void console.error("THREE.BufferGeometry: .computeTangents() failed. Missing required attributes (index, position, normal or uv)");let i=t.array,r=e.position.array,o=e.normal.array,a=e.uv.array,s=r.length/3;void 0===e.tangent&&this.setAttribute("tangent",new Ar(new Float32Array(4*s),4));let l=e.tangent.array,c=[],d=[];for(let Ie=0;Ie<s;Ie++)c[Ie]=new $,d[Ie]=new $;let u=new $,p=new $,f=new $,m=new $e,y=new $e,M=new $e,v=new $,x=new $;function R(Ie,I,re){u.fromArray(r,3*Ie),p.fromArray(r,3*I),f.fromArray(r,3*re),m.fromArray(a,2*Ie),y.fromArray(a,2*I),M.fromArray(a,2*re),p.sub(u),f.sub(u),y.sub(m),M.sub(m);let ce=1/(y.x*M.y-M.x*y.y);!isFinite(ce)||(v.copy(p).multiplyScalar(M.y).addScaledVector(f,-y.y).multiplyScalar(ce),x.copy(f).multiplyScalar(y.x).addScaledVector(p,-M.x).multiplyScalar(ce),c[Ie].add(v),c[I].add(v),c[re].add(v),d[Ie].add(x),d[I].add(x),d[re].add(x))}let A=this.groups;0===A.length&&(A=[{start:0,count:i.length}]);for(let Ie=0,I=A.length;Ie<I;++Ie){let re=A[Ie],ce=re.start;for(let _e=ce,ne=ce+re.count;_e<ne;_e+=3)R(i[_e+0],i[_e+1],i[_e+2])}let H=new $,te=new $,K=new $,Ce=new $;function Ze(Ie){K.fromArray(o,3*Ie),Ce.copy(K);let I=c[Ie];H.copy(I),H.sub(K.multiplyScalar(K.dot(I))).normalize(),te.crossVectors(Ce,I);let ce=te.dot(d[Ie])<0?-1:1;l[4*Ie]=H.x,l[4*Ie+1]=H.y,l[4*Ie+2]=H.z,l[4*Ie+3]=ce}for(let Ie=0,I=A.length;Ie<I;++Ie){let re=A[Ie],ce=re.start;for(let _e=ce,ne=ce+re.count;_e<ne;_e+=3)Ze(i[_e+0]),Ze(i[_e+1]),Ze(i[_e+2])}}computeVertexNormals(){let t=this.index,e=this.getAttribute("position");if(void 0!==e){let i=this.getAttribute("normal");if(void 0===i)i=new Ar(new Float32Array(3*e.count),3),this.setAttribute("normal",i);else for(let p=0,f=i.count;p<f;p++)i.setXYZ(p,0,0,0);let r=new $,o=new $,a=new $,s=new $,l=new $,c=new $,d=new $,u=new $;if(t)for(let p=0,f=t.count;p<f;p+=3){let m=t.getX(p+0),y=t.getX(p+1),M=t.getX(p+2);r.fromBufferAttribute(e,m),o.fromBufferAttribute(e,y),a.fromBufferAttribute(e,M),d.subVectors(a,o),u.subVectors(r,o),d.cross(u),s.fromBufferAttribute(i,m),l.fromBufferAttribute(i,y),c.fromBufferAttribute(i,M),s.add(d),l.add(d),c.add(d),i.setXYZ(m,s.x,s.y,s.z),i.setXYZ(y,l.x,l.y,l.z),i.setXYZ(M,c.x,c.y,c.z)}else for(let p=0,f=e.count;p<f;p+=3)r.fromBufferAttribute(e,p+0),o.fromBufferAttribute(e,p+1),a.fromBufferAttribute(e,p+2),d.subVectors(a,o),u.subVectors(r,o),d.cross(u),i.setXYZ(p+0,d.x,d.y,d.z),i.setXYZ(p+1,d.x,d.y,d.z),i.setXYZ(p+2,d.x,d.y,d.z);this.normalizeNormals(),i.needsUpdate=!0}}merge(t,e){if(!t||!t.isBufferGeometry)return void console.error("THREE.BufferGeometry.merge(): geometry not an instance of THREE.BufferGeometry.",t);void 0===e&&(e=0,console.warn("THREE.BufferGeometry.merge(): Overwriting original geometry, starting at offset=0. Use BufferGeometryUtils.mergeBufferGeometries() for lossless merge."));let i=this.attributes;for(let r in i){if(void 0===t.attributes[r])continue;let a=i[r].array,s=t.attributes[r],l=s.array,c=s.itemSize*e,d=Math.min(l.length,a.length-c);for(let u=0,p=c;u<d;u++,p++)a[p]=l[u]}return this}normalizeNormals(){let t=this.attributes.normal;for(let e=0,i=t.count;e<i;e++)Ao.fromBufferAttribute(t,e),Ao.normalize(),t.setXYZ(e,Ao.x,Ao.y,Ao.z)}toNonIndexed(){function t(s,l){let c=s.array,d=s.itemSize,u=s.normalized,p=new c.constructor(l.length*d),f=0,m=0;for(let y=0,M=l.length;y<M;y++){f=s.isInterleavedBufferAttribute?l[y]*s.data.stride+s.offset:l[y]*d;for(let v=0;v<d;v++)p[m++]=c[f++]}return new Ar(p,d,u)}if(null===this.index)return console.warn("THREE.BufferGeometry.toNonIndexed(): BufferGeometry is already non-indexed."),this;let e=new Wi,i=this.index.array,r=this.attributes;for(let s in r){let c=t(r[s],i);e.setAttribute(s,c)}let o=this.morphAttributes;for(let s in o){let l=[],c=o[s];for(let d=0,u=c.length;d<u;d++){let f=t(c[d],i);l.push(f)}e.morphAttributes[s]=l}e.morphTargetsRelative=this.morphTargetsRelative;let a=this.groups;for(let s=0,l=a.length;s<l;s++){let c=a[s];e.addGroup(c.start,c.count,c.materialIndex)}return e}toJSON(){let t={metadata:{version:4.5,type:"BufferGeometry",generator:"BufferGeometry.toJSON"}};if(t.uuid=this.uuid,t.type=this.type,""!==this.name&&(t.name=this.name),Object.keys(this.userData).length>0&&(t.userData=this.userData),void 0!==this.parameters){let l=this.parameters;for(let c in l)void 0!==l[c]&&(t[c]=l[c]);return t}t.data={attributes:{}};let e=this.index;null!==e&&(t.data.index={type:e.array.constructor.name,array:Array.prototype.slice.call(e.array)});let i=this.attributes;for(let l in i)t.data.attributes[l]=i[l].toJSON(t.data);let r={},o=!1;for(let l in this.morphAttributes){let c=this.morphAttributes[l],d=[];for(let u=0,p=c.length;u<p;u++)d.push(c[u].toJSON(t.data));d.length>0&&(r[l]=d,o=!0)}o&&(t.data.morphAttributes=r,t.data.morphTargetsRelative=this.morphTargetsRelative);let a=this.groups;a.length>0&&(t.data.groups=JSON.parse(JSON.stringify(a)));let s=this.boundingSphere;return null!==s&&(t.data.boundingSphere={center:s.center.toArray(),radius:s.radius}),t}clone(){return(new this.constructor).copy(this)}copy(t){this.index=null,this.attributes={},this.morphAttributes={},this.groups=[],this.boundingBox=null,this.boundingSphere=null;let e={};this.name=t.name;let i=t.index;null!==i&&this.setIndex(i.clone(e));let r=t.attributes;for(let c in r)this.setAttribute(c,r[c].clone(e));let o=t.morphAttributes;for(let c in o){let d=[],u=o[c];for(let p=0,f=u.length;p<f;p++)d.push(u[p].clone(e));this.morphAttributes[c]=d}this.morphTargetsRelative=t.morphTargetsRelative;let a=t.groups;for(let c=0,d=a.length;c<d;c++){let u=a[c];this.addGroup(u.start,u.count,u.materialIndex)}let s=t.boundingBox;null!==s&&(this.boundingBox=s.clone());let l=t.boundingSphere;return null!==l&&(this.boundingSphere=l.clone()),this.drawRange.start=t.drawRange.start,this.drawRange.count=t.drawRange.count,this.userData=t.userData,void 0!==t.parameters&&(this.parameters=Object.assign({},t.parameters)),this}dispose(){this.dispatchEvent({type:"dispose"})}};Wi.prototype.isBufferGeometry=!0;var mee=new Mn,z0=new Sp,rB=new wp,mp=new $,hp=new $,gp=new $,oB=new $,aB=new $,sB=new $,JD=new $,$D=new $,eI=new $,tI=new $e,nI=new $e,iI=new $e,lB=new $,rI=new $,co=class extends zi{constructor(t=new Wi,e=new Sm){super(),this.type="Mesh",this.geometry=t,this.material=e,this.updateMorphTargets()}copy(t){return super.copy(t),void 0!==t.morphTargetInfluences&&(this.morphTargetInfluences=t.morphTargetInfluences.slice()),void 0!==t.morphTargetDictionary&&(this.morphTargetDictionary=Object.assign({},t.morphTargetDictionary)),this.material=t.material,this.geometry=t.geometry,this}updateMorphTargets(){let t=this.geometry;if(t.isBufferGeometry){let e=t.morphAttributes,i=Object.keys(e);if(i.length>0){let r=e[i[0]];if(void 0!==r){this.morphTargetInfluences=[],this.morphTargetDictionary={};for(let o=0,a=r.length;o<a;o++){let s=r[o].name||String(o);this.morphTargetInfluences.push(0),this.morphTargetDictionary[s]=o}}}}else{let e=t.morphTargets;void 0!==e&&e.length>0&&console.error("THREE.Mesh.updateMorphTargets() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}}raycast(t,e){let a,i=this.geometry,r=this.material,o=this.matrixWorld;if(void 0!==r&&(null===i.boundingSphere&&i.computeBoundingSphere(),rB.copy(i.boundingSphere),rB.applyMatrix4(o),!1!==t.ray.intersectsSphere(rB))&&(mee.copy(o).invert(),z0.copy(t.ray).applyMatrix4(mee),null===i.boundingBox||!1!==z0.intersectsBox(i.boundingBox)))if(i.isBufferGeometry){let s=i.index,l=i.attributes.position,c=i.morphAttributes.position,d=i.morphTargetsRelative,u=i.attributes.uv,p=i.attributes.uv2,f=i.groups,m=i.drawRange;if(null!==s)if(Array.isArray(r))for(let y=0,M=f.length;y<M;y++){let v=f[y],x=r[v.materialIndex];for(let H=Math.max(v.start,m.start),te=Math.min(s.count,Math.min(v.start+v.count,m.start+m.count));H<te;H+=3){let K=s.getX(H),Ce=s.getX(H+1),Ze=s.getX(H+2);a=oI(this,x,t,z0,l,c,d,u,p,K,Ce,Ze),a&&(a.faceIndex=Math.floor(H/3),a.face.materialIndex=v.materialIndex,e.push(a))}}else for(let v=Math.max(0,m.start),x=Math.min(s.count,m.start+m.count);v<x;v+=3){let R=s.getX(v),A=s.getX(v+1),H=s.getX(v+2);a=oI(this,r,t,z0,l,c,d,u,p,R,A,H),a&&(a.faceIndex=Math.floor(v/3),e.push(a))}else if(void 0!==l)if(Array.isArray(r))for(let y=0,M=f.length;y<M;y++){let v=f[y],x=r[v.materialIndex];for(let H=Math.max(v.start,m.start),te=Math.min(l.count,Math.min(v.start+v.count,m.start+m.count));H<te;H+=3)a=oI(this,x,t,z0,l,c,d,u,p,H,H+1,H+2),a&&(a.faceIndex=Math.floor(H/3),a.face.materialIndex=v.materialIndex,e.push(a))}else for(let v=Math.max(0,m.start),x=Math.min(l.count,m.start+m.count);v<x;v+=3)a=oI(this,r,t,z0,l,c,d,u,p,v,v+1,v+2),a&&(a.faceIndex=Math.floor(v/3),e.push(a))}else i.isGeometry&&console.error("THREE.Mesh.raycast() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}};function oI(n,t,e,i,r,o,a,s,l,c,d,u){mp.fromBufferAttribute(r,c),hp.fromBufferAttribute(r,d),gp.fromBufferAttribute(r,u);let p=n.morphTargetInfluences;if(o&&p){JD.set(0,0,0),$D.set(0,0,0),eI.set(0,0,0);for(let m=0,y=o.length;m<y;m++){let M=p[m],v=o[m];0!==M&&(oB.fromBufferAttribute(v,c),aB.fromBufferAttribute(v,d),sB.fromBufferAttribute(v,u),a?(JD.addScaledVector(oB,M),$D.addScaledVector(aB,M),eI.addScaledVector(sB,M)):(JD.addScaledVector(oB.sub(mp),M),$D.addScaledVector(aB.sub(hp),M),eI.addScaledVector(sB.sub(gp),M)))}mp.add(JD),hp.add($D),gp.add(eI)}n.isSkinnedMesh&&(n.boneTransform(c,mp),n.boneTransform(d,hp),n.boneTransform(u,gp));let f=function(n,t,e,i,r,o,a,s){let l;if(l=t.side===yo?i.intersectTriangle(a,o,r,!0,s):i.intersectTriangle(r,o,a,t.side!==o_,s),null===l)return null;rI.copy(s),rI.applyMatrix4(n.matrixWorld);let c=e.ray.origin.distanceTo(rI);return c<e.near||c>e.far?null:{distance:c,point:rI.clone(),object:n}}(n,t,e,i,mp,hp,gp,lB);if(f){s&&(tI.fromBufferAttribute(s,c),nI.fromBufferAttribute(s,d),iI.fromBufferAttribute(s,u),f.uv=jr.getUV(lB,mp,hp,gp,tI,nI,iI,new $e)),l&&(tI.fromBufferAttribute(l,c),nI.fromBufferAttribute(l,d),iI.fromBufferAttribute(l,u),f.uv2=jr.getUV(lB,mp,hp,gp,tI,nI,iI,new $e));let m={a:c,b:d,c:u,normal:new $,materialIndex:0};jr.getNormal(mp,hp,gp,m.normal),f.face=m}return f}co.prototype.isMesh=!0;var Em=class extends Wi{constructor(t=1,e=1,i=1,r=1,o=1,a=1){super(),this.type="BoxGeometry",this.parameters={width:t,height:e,depth:i,widthSegments:r,heightSegments:o,depthSegments:a};let s=this;r=Math.floor(r),o=Math.floor(o),a=Math.floor(a);let l=[],c=[],d=[],u=[],p=0,f=0;function m(y,M,v,x,R,A,H,te,K,Ce,Ze){let Ie=A/K,I=H/Ce,re=A/2,ce=H/2,fe=te/2,_e=K+1,ne=Ce+1,de=0,ue=0,Ge=new $;for(let Me=0;Me<ne;Me++){let Ne=Me*I-ce;for(let ct=0;ct<_e;ct++)Ge[y]=(ct*Ie-re)*x,Ge[M]=Ne*R,Ge[v]=fe,c.push(Ge.x,Ge.y,Ge.z),Ge[y]=0,Ge[M]=0,Ge[v]=te>0?1:-1,d.push(Ge.x,Ge.y,Ge.z),u.push(ct/K),u.push(1-Me/Ce),de+=1}for(let Me=0;Me<Ce;Me++)for(let Ne=0;Ne<K;Ne++){let wt=p+Ne+_e*(Me+1),ft=p+(Ne+1)+_e*(Me+1),Oe=p+(Ne+1)+_e*Me;l.push(p+Ne+_e*Me,wt,Oe),l.push(wt,ft,Oe),ue+=6}s.addGroup(f,ue,Ze),f+=ue,p+=de}m("z","y","x",-1,-1,i,e,t,a,o,0),m("z","y","x",1,-1,i,e,-t,a,o,1),m("x","z","y",1,1,t,i,e,r,a,2),m("x","z","y",1,-1,t,i,-e,r,a,3),m("x","y","z",1,-1,t,e,i,r,o,4),m("x","y","z",-1,-1,t,e,-i,r,o,5),this.setIndex(l),this.setAttribute("position",new Br(c,3)),this.setAttribute("normal",new Br(d,3)),this.setAttribute("uv",new Br(u,2))}static fromJSON(t){return new Em(t.width,t.height,t.depth,t.widthSegments,t.heightSegments,t.depthSegments)}};function s_(n){let t={};for(let e in n){t[e]={};for(let i in n[e]){let r=n[e][i];t[e][i]=r&&(r.isColor||r.isMatrix3||r.isMatrix4||r.isVector2||r.isVector3||r.isVector4||r.isTexture||r.isQuaternion)?r.clone():Array.isArray(r)?r.slice():r}}return t}function ia(n){let t={};for(let e=0;e<n.length;e++){let i=s_(n[e]);for(let r in i)t[r]=i[r]}return t}var pRe={clone:s_,merge:ia},Gd=class extends Ro{constructor(t){super(),this.type="ShaderMaterial",this.defines={},this.uniforms={},this.vertexShader="void main() {\n\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n}",this.fragmentShader="void main() {\n\tgl_FragColor = vec4( 1.0, 0.0, 0.0, 1.0 );\n}",this.linewidth=1,this.wireframe=!1,this.wireframeLinewidth=1,this.fog=!1,this.lights=!1,this.clipping=!1,this.extensions={derivatives:!1,fragDepth:!1,drawBuffers:!1,shaderTextureLOD:!1},this.defaultAttributeValues={color:[1,1,1],uv:[0,0],uv2:[0,0]},this.index0AttributeName=void 0,this.uniformsNeedUpdate=!1,this.glslVersion=null,void 0!==t&&(void 0!==t.attributes&&console.error("THREE.ShaderMaterial: attributes should now be defined in THREE.BufferGeometry instead."),this.setValues(t))}copy(t){return super.copy(t),this.fragmentShader=t.fragmentShader,this.vertexShader=t.vertexShader,this.uniforms=s_(t.uniforms),this.defines=Object.assign({},t.defines),this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.lights=t.lights,this.clipping=t.clipping,this.extensions=Object.assign({},t.extensions),this.glslVersion=t.glslVersion,this}toJSON(t){let e=super.toJSON(t);e.glslVersion=this.glslVersion,e.uniforms={};for(let r in this.uniforms){let a=this.uniforms[r].value;e.uniforms[r]=a&&a.isTexture?{type:"t",value:a.toJSON(t).uuid}:a&&a.isColor?{type:"c",value:a.getHex()}:a&&a.isVector2?{type:"v2",value:a.toArray()}:a&&a.isVector3?{type:"v3",value:a.toArray()}:a&&a.isVector4?{type:"v4",value:a.toArray()}:a&&a.isMatrix3?{type:"m3",value:a.toArray()}:a&&a.isMatrix4?{type:"m4",value:a.toArray()}:{value:a}}Object.keys(this.defines).length>0&&(e.defines=this.defines),e.vertexShader=this.vertexShader,e.fragmentShader=this.fragmentShader;let i={};for(let r in this.extensions)!0===this.extensions[r]&&(i[r]=!0);return Object.keys(i).length>0&&(e.extensions=i),e}};Gd.prototype.isShaderMaterial=!0;var Ax=class extends zi{constructor(){super(),this.type="Camera",this.matrixWorldInverse=new Mn,this.projectionMatrix=new Mn,this.projectionMatrixInverse=new Mn}copy(t,e){return super.copy(t,e),this.matrixWorldInverse.copy(t.matrixWorldInverse),this.projectionMatrix.copy(t.projectionMatrix),this.projectionMatrixInverse.copy(t.projectionMatrixInverse),this}getWorldDirection(t){this.updateWorldMatrix(!0,!1);let e=this.matrixWorld.elements;return t.set(-e[8],-e[9],-e[10]).normalize()}updateMatrixWorld(t){super.updateMatrixWorld(t),this.matrixWorldInverse.copy(this.matrixWorld).invert()}updateWorldMatrix(t,e){super.updateWorldMatrix(t,e),this.matrixWorldInverse.copy(this.matrixWorld).invert()}clone(){return(new this.constructor).copy(this)}};Ax.prototype.isCamera=!0;var oa=class extends Ax{constructor(t=50,e=1,i=.1,r=2e3){super(),this.type="PerspectiveCamera",this.fov=t,this.zoom=1,this.near=i,this.far=r,this.focus=10,this.aspect=e,this.view=null,this.filmGauge=35,this.filmOffset=0,this.updateProjectionMatrix()}copy(t,e){return super.copy(t,e),this.fov=t.fov,this.zoom=t.zoom,this.near=t.near,this.far=t.far,this.focus=t.focus,this.aspect=t.aspect,this.view=null===t.view?null:Object.assign({},t.view),this.filmGauge=t.filmGauge,this.filmOffset=t.filmOffset,this}setFocalLength(t){let e=.5*this.getFilmHeight()/t;this.fov=2*EB*Math.atan(e),this.updateProjectionMatrix()}getFocalLength(){let t=Math.tan(.5*z3*this.fov);return.5*this.getFilmHeight()/t}getEffectiveFOV(){return 2*EB*Math.atan(Math.tan(.5*z3*this.fov)/this.zoom)}getFilmWidth(){return this.filmGauge*Math.min(this.aspect,1)}getFilmHeight(){return this.filmGauge/Math.max(this.aspect,1)}setViewOffset(t,e,i,r,o,a){this.aspect=t/e,null===this.view&&(this.view={enabled:!0,fullWidth:1,fullHeight:1,offsetX:0,offsetY:0,width:1,height:1}),this.view.enabled=!0,this.view.fullWidth=t,this.view.fullHeight=e,this.view.offsetX=i,this.view.offsetY=r,this.view.width=o,this.view.height=a,this.updateProjectionMatrix()}clearViewOffset(){null!==this.view&&(this.view.enabled=!1),this.updateProjectionMatrix()}updateProjectionMatrix(){let t=this.near,e=t*Math.tan(.5*z3*this.fov)/this.zoom,i=2*e,r=this.aspect*i,o=-.5*r,a=this.view;if(null!==this.view&&this.view.enabled){let l=a.fullWidth,c=a.fullHeight;o+=a.offsetX*r/l,e-=a.offsetY*i/c,r*=a.width/l,i*=a.height/c}let s=this.filmOffset;0!==s&&(o+=t*s/this.getFilmWidth()),this.projectionMatrix.makePerspective(o,o+r,e,e-i,t,this.far),this.projectionMatrixInverse.copy(this.projectionMatrix).invert()}toJSON(t){let e=super.toJSON(t);return e.object.fov=this.fov,e.object.zoom=this.zoom,e.object.near=this.near,e.object.far=this.far,e.object.focus=this.focus,e.object.aspect=this.aspect,null!==this.view&&(e.object.view=Object.assign({},this.view)),e.object.filmGauge=this.filmGauge,e.object.filmOffset=this.filmOffset,e}};oa.prototype.isPerspectiveCamera=!0;var Rx=class extends zi{constructor(t,e,i){if(super(),this.type="CubeCamera",!0!==i.isWebGLCubeRenderTarget)return void console.error("THREE.CubeCamera: The constructor now expects an instance of WebGLCubeRenderTarget as third parameter.");this.renderTarget=i;let r=new oa(90,1,t,e);r.layers=this.layers,r.up.set(0,-1,0),r.lookAt(new $(1,0,0)),this.add(r);let o=new oa(90,1,t,e);o.layers=this.layers,o.up.set(0,-1,0),o.lookAt(new $(-1,0,0)),this.add(o);let a=new oa(90,1,t,e);a.layers=this.layers,a.up.set(0,0,1),a.lookAt(new $(0,1,0)),this.add(a);let s=new oa(90,1,t,e);s.layers=this.layers,s.up.set(0,0,-1),s.lookAt(new $(0,-1,0)),this.add(s);let l=new oa(90,1,t,e);l.layers=this.layers,l.up.set(0,-1,0),l.lookAt(new $(0,0,1)),this.add(l);let c=new oa(90,1,t,e);c.layers=this.layers,c.up.set(0,-1,0),c.lookAt(new $(0,0,-1)),this.add(c)}update(t,e){null===this.parent&&this.updateMatrixWorld();let i=this.renderTarget,[r,o,a,s,l,c]=this.children,d=t.xr.enabled,u=t.getRenderTarget();t.xr.enabled=!1;let p=i.texture.generateMipmaps;i.texture.generateMipmaps=!1,t.setRenderTarget(i,0),t.render(e,r),t.setRenderTarget(i,1),t.render(e,o),t.setRenderTarget(i,2),t.render(e,a),t.setRenderTarget(i,3),t.render(e,s),t.setRenderTarget(i,4),t.render(e,l),i.texture.generateMipmaps=p,t.setRenderTarget(i,5),t.render(e,c),t.setRenderTarget(u),t.xr.enabled=d,i.texture.needsPMREMUpdate=!0}},l_=class extends uo{constructor(t,e,i,r,o,a,s,l,c,d){super(t=void 0!==t?t:[],e=void 0!==e?e:Zx,i,r,o,a,s,l,c,d),this.flipY=!1}get images(){return this.image}set images(t){this.image=t}};l_.prototype.isCubeTexture=!0;var AI=class extends Qa{constructor(t,e,i){Number.isInteger(e)&&(console.warn("THREE.WebGLCubeRenderTarget: constructor signature is now WebGLCubeRenderTarget( size, options )"),e=i),super(t,t,e),this.texture=new l_(void 0,(e=e||{}).mapping,e.wrapS,e.wrapT,e.magFilter,e.minFilter,e.format,e.type,e.anisotropy,e.encoding),this.texture.isRenderTargetTexture=!0,this.texture.generateMipmaps=void 0!==e.generateMipmaps&&e.generateMipmaps,this.texture.minFilter=void 0!==e.minFilter?e.minFilter:ra}fromEquirectangularTexture(t,e){this.texture.type=e.type,this.texture.format=ba,this.texture.encoding=e.encoding,this.texture.generateMipmaps=e.generateMipmaps,this.texture.minFilter=e.minFilter,this.texture.magFilter=e.magFilter;let i_uniforms={tEquirect:{value:null}},i_vertexShader="\n\n\t\t\t\tvarying vec3 vWorldDirection;\n\n\t\t\t\tvec3 transformDirection( in vec3 dir, in mat4 matrix ) {\n\n\t\t\t\t\treturn normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );\n\n\t\t\t\t}\n\n\t\t\t\tvoid main() {\n\n\t\t\t\t\tvWorldDirection = transformDirection( position, modelMatrix );\n\n\t\t\t\t\t#include <begin_vertex>\n\t\t\t\t\t#include <project_vertex>\n\n\t\t\t\t}\n\t\t\t",i_fragmentShader="\n\n\t\t\t\tuniform sampler2D tEquirect;\n\n\t\t\t\tvarying vec3 vWorldDirection;\n\n\t\t\t\t#include <common>\n\n\t\t\t\tvoid main() {\n\n\t\t\t\t\tvec3 direction = normalize( vWorldDirection );\n\n\t\t\t\t\tvec2 sampleUV = equirectUv( direction );\n\n\t\t\t\t\tgl_FragColor = texture2D( tEquirect, sampleUV );\n\n\t\t\t\t}\n\t\t\t",r=new Em(5,5,5),o=new Gd({name:"CubemapFromEquirect",uniforms:s_(i_uniforms),vertexShader:i_vertexShader,fragmentShader:i_fragmentShader,side:yo,blending:yp});o.uniforms.tEquirect.value=e;let a=new co(r,o),s=e.minFilter;return e.minFilter===eA&&(e.minFilter=ra),new Rx(1,10,this).update(t,a),e.minFilter=s,a.geometry.dispose(),a.material.dispose(),this}clear(t,e,i,r){let o=t.getRenderTarget();for(let a=0;a<6;a++)t.setRenderTarget(this,a),t.clear(e,i,r);t.setRenderTarget(o)}};AI.prototype.isWebGLCubeRenderTarget=!0;var cB=new $,hRe=new $,gRe=new vo,Xl=class{constructor(t=new $(1,0,0),e=0){this.normal=t,this.constant=e}set(t,e){return this.normal.copy(t),this.constant=e,this}setComponents(t,e,i,r){return this.normal.set(t,e,i),this.constant=r,this}setFromNormalAndCoplanarPoint(t,e){return this.normal.copy(t),this.constant=-e.dot(this.normal),this}setFromCoplanarPoints(t,e,i){let r=cB.subVectors(i,e).cross(hRe.subVectors(t,e)).normalize();return this.setFromNormalAndCoplanarPoint(r,t),this}copy(t){return this.normal.copy(t.normal),this.constant=t.constant,this}normalize(){let t=1/this.normal.length();return this.normal.multiplyScalar(t),this.constant*=t,this}negate(){return this.constant*=-1,this.normal.negate(),this}distanceToPoint(t){return this.normal.dot(t)+this.constant}distanceToSphere(t){return this.distanceToPoint(t.center)-t.radius}projectPoint(t,e){return e.copy(this.normal).multiplyScalar(-this.distanceToPoint(t)).add(t)}intersectLine(t,e){let i=t.delta(cB),r=this.normal.dot(i);if(0===r)return 0===this.distanceToPoint(t.start)?e.copy(t.start):null;let o=-(t.start.dot(this.normal)+this.constant)/r;return o<0||o>1?null:e.copy(i).multiplyScalar(o).add(t.start)}intersectsLine(t){let e=this.distanceToPoint(t.start),i=this.distanceToPoint(t.end);return e<0&&i>0||i<0&&e>0}intersectsBox(t){return t.intersectsPlane(this)}intersectsSphere(t){return t.intersectsPlane(this)}coplanarPoint(t){return t.copy(this.normal).multiplyScalar(-this.constant)}applyMatrix4(t,e){let i=e||gRe.getNormalMatrix(t),r=this.coplanarPoint(cB).applyMatrix4(t),o=this.normal.applyMatrix3(i).normalize();return this.constant=-r.dot(o),this}translate(t){return this.constant-=t.dot(this.normal),this}equals(t){return t.normal.equals(this.normal)&&t.constant===this.constant}clone(){return(new this.constructor).copy(this)}};Xl.prototype.isPlane=!0;var G0=new wp,aI=new $,c_=class{constructor(t=new Xl,e=new Xl,i=new Xl,r=new Xl,o=new Xl,a=new Xl){this.planes=[t,e,i,r,o,a]}set(t,e,i,r,o,a){let s=this.planes;return s[0].copy(t),s[1].copy(e),s[2].copy(i),s[3].copy(r),s[4].copy(o),s[5].copy(a),this}copy(t){let e=this.planes;for(let i=0;i<6;i++)e[i].copy(t.planes[i]);return this}setFromProjectionMatrix(t){let e=this.planes,i=t.elements,r=i[0],o=i[1],a=i[2],s=i[3],l=i[4],c=i[5],d=i[6],u=i[7],p=i[8],f=i[9],m=i[10],y=i[11],M=i[12],v=i[13],x=i[14],R=i[15];return e[0].setComponents(s-r,u-l,y-p,R-M).normalize(),e[1].setComponents(s+r,u+l,y+p,R+M).normalize(),e[2].setComponents(s+o,u+c,y+f,R+v).normalize(),e[3].setComponents(s-o,u-c,y-f,R-v).normalize(),e[4].setComponents(s-a,u-d,y-m,R-x).normalize(),e[5].setComponents(s+a,u+d,y+m,R+x).normalize(),this}intersectsObject(t){let e=t.geometry;return null===e.boundingSphere&&e.computeBoundingSphere(),G0.copy(e.boundingSphere).applyMatrix4(t.matrixWorld),this.intersectsSphere(G0)}intersectsSprite(t){return G0.center.set(0,0,0),G0.radius=.7071067811865476,G0.applyMatrix4(t.matrixWorld),this.intersectsSphere(G0)}intersectsSphere(t){let e=this.planes,i=t.center,r=-t.radius;for(let o=0;o<6;o++)if(e[o].distanceToPoint(i)<r)return!1;return!0}intersectsBox(t){let e=this.planes;for(let i=0;i<6;i++){let r=e[i];if(aI.x=r.normal.x>0?t.max.x:t.min.x,aI.y=r.normal.y>0?t.max.y:t.min.y,aI.z=r.normal.z>0?t.max.z:t.min.z,r.distanceToPoint(aI)<0)return!1}return!0}containsPoint(t){let e=this.planes;for(let i=0;i<6;i++)if(e[i].distanceToPoint(t)<0)return!1;return!0}clone(){return(new this.constructor).copy(this)}};function hte(){let n=null,t=!1,e=null,i=null;function r(o,a){e(o,a),i=n.requestAnimationFrame(r)}return{start:function(){!0!==t&&null!==e&&(i=n.requestAnimationFrame(r),t=!0)},stop:function(){n.cancelAnimationFrame(i),t=!1},setAnimationLoop:function(o){e=o},setContext:function(o){n=o}}}function _Re(n,t){let e=t.isWebGL2,i=new WeakMap;return{get:function(c){return c.isInterleavedBufferAttribute&&(c=c.data),i.get(c)},remove:function(c){c.isInterleavedBufferAttribute&&(c=c.data);let d=i.get(c);d&&(n.deleteBuffer(d.buffer),i.delete(c))},update:function(c,d){if(c.isGLBufferAttribute){let p=i.get(c);return void((!p||p.version<c.version)&&i.set(c,{buffer:c.buffer,type:c.type,bytesPerElement:c.elementSize,version:c.version}))}c.isInterleavedBufferAttribute&&(c=c.data);let u=i.get(c);void 0===u?i.set(c,function(c,d){let u=c.array,p=c.usage,f=n.createBuffer();n.bindBuffer(d,f),n.bufferData(d,u,p),c.onUploadCallback();let m=5126;return u instanceof Float32Array?m=5126:u instanceof Float64Array?console.warn("THREE.WebGLAttributes: Unsupported data buffer format: Float64Array."):u instanceof Uint16Array?c.isFloat16BufferAttribute?e?m=5131:console.warn("THREE.WebGLAttributes: Usage of Float16BufferAttribute requires WebGL2."):m=5123:u instanceof Int16Array?m=5122:u instanceof Uint32Array?m=5125:u instanceof Int32Array?m=5124:u instanceof Int8Array?m=5120:(u instanceof Uint8Array||u instanceof Uint8ClampedArray)&&(m=5121),{buffer:f,type:m,bytesPerElement:u.BYTES_PER_ELEMENT,version:c.version}}(c,d)):u.version<c.version&&(function(c,d,u){let p=d.array,f=d.updateRange;n.bindBuffer(u,c),-1===f.count?n.bufferSubData(u,0,p):(e?n.bufferSubData(u,f.offset*p.BYTES_PER_ELEMENT,p,f.offset,f.count):n.bufferSubData(u,f.offset*p.BYTES_PER_ELEMENT,p.subarray(f.offset,f.offset+f.count)),f.count=-1)}(u.buffer,c,d),u.version=c.version)}}}var kx=class extends Wi{constructor(t=1,e=1,i=1,r=1){super(),this.type="PlaneGeometry",this.parameters={width:t,height:e,widthSegments:i,heightSegments:r};let o=t/2,a=e/2,s=Math.floor(i),l=Math.floor(r),c=s+1,d=l+1,u=t/s,p=e/l,f=[],m=[],y=[],M=[];for(let v=0;v<d;v++){let x=v*p-a;for(let R=0;R<c;R++)m.push(R*u-o,-x,0),y.push(0,0,1),M.push(R/s),M.push(1-v/l)}for(let v=0;v<l;v++)for(let x=0;x<s;x++){let A=x+c*(v+1),H=x+1+c*(v+1),te=x+1+c*v;f.push(x+c*v,A,te),f.push(A,H,te)}this.setIndex(f),this.setAttribute("position",new Br(m,3)),this.setAttribute("normal",new Br(y,3)),this.setAttribute("uv",new Br(M,2))}static fromJSON(t){return new kx(t.width,t.height,t.widthSegments,t.heightSegments)}},vi={alphamap_fragment:"#ifdef USE_ALPHAMAP\n\tdiffuseColor.a *= texture2D( alphaMap, vUv ).g;\n#endif",alphamap_pars_fragment:"#ifdef USE_ALPHAMAP\n\tuniform sampler2D alphaMap;\n#endif",alphatest_fragment:"#ifdef USE_ALPHATEST\n\tif ( diffuseColor.a < alphaTest ) discard;\n#endif",alphatest_pars_fragment:"#ifdef USE_ALPHATEST\n\tuniform float alphaTest;\n#endif",aomap_fragment:"#ifdef USE_AOMAP\n\tfloat ambientOcclusion = ( texture2D( aoMap, vUv2 ).r - 1.0 ) * aoMapIntensity + 1.0;\n\treflectedLight.indirectDiffuse *= ambientOcclusion;\n\t#if defined( USE_ENVMAP ) && defined( STANDARD )\n\t\tfloat dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );\n\t\treflectedLight.indirectSpecular *= computeSpecularOcclusion( dotNV, ambientOcclusion, material.roughness );\n\t#endif\n#endif",aomap_pars_fragment:"#ifdef USE_AOMAP\n\tuniform sampler2D aoMap;\n\tuniform float aoMapIntensity;\n#endif",begin_vertex:"vec3 transformed = vec3( position );",beginnormal_vertex:"vec3 objectNormal = vec3( normal );\n#ifdef USE_TANGENT\n\tvec3 objectTangent = vec3( tangent.xyz );\n#endif",bsdfs:"vec3 BRDF_Lambert( const in vec3 diffuseColor ) {\n\treturn RECIPROCAL_PI * diffuseColor;\n}\nvec3 F_Schlick( const in vec3 f0, const in float f90, const in float dotVH ) {\n\tfloat fresnel = exp2( ( - 5.55473 * dotVH - 6.98316 ) * dotVH );\n\treturn f0 * ( 1.0 - fresnel ) + ( f90 * fresnel );\n}\nfloat V_GGX_SmithCorrelated( const in float alpha, const in float dotNL, const in float dotNV ) {\n\tfloat a2 = pow2( alpha );\n\tfloat gv = dotNL * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );\n\tfloat gl = dotNV * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );\n\treturn 0.5 / max( gv + gl, EPSILON );\n}\nfloat D_GGX( const in float alpha, const in float dotNH ) {\n\tfloat a2 = pow2( alpha );\n\tfloat denom = pow2( dotNH ) * ( a2 - 1.0 ) + 1.0;\n\treturn RECIPROCAL_PI * a2 / pow2( denom );\n}\nvec3 BRDF_GGX( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in vec3 f0, const in float f90, const in float roughness ) {\n\tfloat alpha = pow2( roughness );\n\tvec3 halfDir = normalize( lightDir + viewDir );\n\tfloat dotNL = saturate( dot( normal, lightDir ) );\n\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\tfloat dotNH = saturate( dot( normal, halfDir ) );\n\tfloat dotVH = saturate( dot( viewDir, halfDir ) );\n\tvec3 F = F_Schlick( f0, f90, dotVH );\n\tfloat V = V_GGX_SmithCorrelated( alpha, dotNL, dotNV );\n\tfloat D = D_GGX( alpha, dotNH );\n\treturn F * ( V * D );\n}\nvec2 LTC_Uv( const in vec3 N, const in vec3 V, const in float roughness ) {\n\tconst float LUT_SIZE = 64.0;\n\tconst float LUT_SCALE = ( LUT_SIZE - 1.0 ) / LUT_SIZE;\n\tconst float LUT_BIAS = 0.5 / LUT_SIZE;\n\tfloat dotNV = saturate( dot( N, V ) );\n\tvec2 uv = vec2( roughness, sqrt( 1.0 - dotNV ) );\n\tuv = uv * LUT_SCALE + LUT_BIAS;\n\treturn uv;\n}\nfloat LTC_ClippedSphereFormFactor( const in vec3 f ) {\n\tfloat l = length( f );\n\treturn max( ( l * l + f.z ) / ( l + 1.0 ), 0.0 );\n}\nvec3 LTC_EdgeVectorFormFactor( const in vec3 v1, const in vec3 v2 ) {\n\tfloat x = dot( v1, v2 );\n\tfloat y = abs( x );\n\tfloat a = 0.8543985 + ( 0.4965155 + 0.0145206 * y ) * y;\n\tfloat b = 3.4175940 + ( 4.1616724 + y ) * y;\n\tfloat v = a / b;\n\tfloat theta_sintheta = ( x > 0.0 ) ? v : 0.5 * inversesqrt( max( 1.0 - x * x, 1e-7 ) ) - v;\n\treturn cross( v1, v2 ) * theta_sintheta;\n}\nvec3 LTC_Evaluate( const in vec3 N, const in vec3 V, const in vec3 P, const in mat3 mInv, const in vec3 rectCoords[ 4 ] ) {\n\tvec3 v1 = rectCoords[ 1 ] - rectCoords[ 0 ];\n\tvec3 v2 = rectCoords[ 3 ] - rectCoords[ 0 ];\n\tvec3 lightNormal = cross( v1, v2 );\n\tif( dot( lightNormal, P - rectCoords[ 0 ] ) < 0.0 ) return vec3( 0.0 );\n\tvec3 T1, T2;\n\tT1 = normalize( V - N * dot( V, N ) );\n\tT2 = - cross( N, T1 );\n\tmat3 mat = mInv * transposeMat3( mat3( T1, T2, N ) );\n\tvec3 coords[ 4 ];\n\tcoords[ 0 ] = mat * ( rectCoords[ 0 ] - P );\n\tcoords[ 1 ] = mat * ( rectCoords[ 1 ] - P );\n\tcoords[ 2 ] = mat * ( rectCoords[ 2 ] - P );\n\tcoords[ 3 ] = mat * ( rectCoords[ 3 ] - P );\n\tcoords[ 0 ] = normalize( coords[ 0 ] );\n\tcoords[ 1 ] = normalize( coords[ 1 ] );\n\tcoords[ 2 ] = normalize( coords[ 2 ] );\n\tcoords[ 3 ] = normalize( coords[ 3 ] );\n\tvec3 vectorFormFactor = vec3( 0.0 );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 0 ], coords[ 1 ] );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 1 ], coords[ 2 ] );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 2 ], coords[ 3 ] );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 3 ], coords[ 0 ] );\n\tfloat result = LTC_ClippedSphereFormFactor( vectorFormFactor );\n\treturn vec3( result );\n}\nfloat G_BlinnPhong_Implicit( ) {\n\treturn 0.25;\n}\nfloat D_BlinnPhong( const in float shininess, const in float dotNH ) {\n\treturn RECIPROCAL_PI * ( shininess * 0.5 + 1.0 ) * pow( dotNH, shininess );\n}\nvec3 BRDF_BlinnPhong( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in vec3 specularColor, const in float shininess ) {\n\tvec3 halfDir = normalize( lightDir + viewDir );\n\tfloat dotNH = saturate( dot( normal, halfDir ) );\n\tfloat dotVH = saturate( dot( viewDir, halfDir ) );\n\tvec3 F = F_Schlick( specularColor, 1.0, dotVH );\n\tfloat G = G_BlinnPhong_Implicit( );\n\tfloat D = D_BlinnPhong( shininess, dotNH );\n\treturn F * ( G * D );\n}\n#if defined( USE_SHEEN )\nfloat D_Charlie( float roughness, float dotNH ) {\n\tfloat alpha = pow2( roughness );\n\tfloat invAlpha = 1.0 / alpha;\n\tfloat cos2h = dotNH * dotNH;\n\tfloat sin2h = max( 1.0 - cos2h, 0.0078125 );\n\treturn ( 2.0 + invAlpha ) * pow( sin2h, invAlpha * 0.5 ) / ( 2.0 * PI );\n}\nfloat V_Neubelt( float dotNV, float dotNL ) {\n\treturn saturate( 1.0 / ( 4.0 * ( dotNL + dotNV - dotNL * dotNV ) ) );\n}\nvec3 BRDF_Sheen( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, vec3 sheenColor, const in float sheenRoughness ) {\n\tvec3 halfDir = normalize( lightDir + viewDir );\n\tfloat dotNL = saturate( dot( normal, lightDir ) );\n\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\tfloat dotNH = saturate( dot( normal, halfDir ) );\n\tfloat D = D_Charlie( sheenRoughness, dotNH );\n\tfloat V = V_Neubelt( dotNV, dotNL );\n\treturn sheenColor * ( D * V );\n}\n#endif",bumpmap_pars_fragment:"#ifdef USE_BUMPMAP\n\tuniform sampler2D bumpMap;\n\tuniform float bumpScale;\n\tvec2 dHdxy_fwd() {\n\t\tvec2 dSTdx = dFdx( vUv );\n\t\tvec2 dSTdy = dFdy( vUv );\n\t\tfloat Hll = bumpScale * texture2D( bumpMap, vUv ).x;\n\t\tfloat dBx = bumpScale * texture2D( bumpMap, vUv + dSTdx ).x - Hll;\n\t\tfloat dBy = bumpScale * texture2D( bumpMap, vUv + dSTdy ).x - Hll;\n\t\treturn vec2( dBx, dBy );\n\t}\n\tvec3 perturbNormalArb( vec3 surf_pos, vec3 surf_norm, vec2 dHdxy, float faceDirection ) {\n\t\tvec3 vSigmaX = vec3( dFdx( surf_pos.x ), dFdx( surf_pos.y ), dFdx( surf_pos.z ) );\n\t\tvec3 vSigmaY = vec3( dFdy( surf_pos.x ), dFdy( surf_pos.y ), dFdy( surf_pos.z ) );\n\t\tvec3 vN = surf_norm;\n\t\tvec3 R1 = cross( vSigmaY, vN );\n\t\tvec3 R2 = cross( vN, vSigmaX );\n\t\tfloat fDet = dot( vSigmaX, R1 ) * faceDirection;\n\t\tvec3 vGrad = sign( fDet ) * ( dHdxy.x * R1 + dHdxy.y * R2 );\n\t\treturn normalize( abs( fDet ) * surf_norm - vGrad );\n\t}\n#endif",clipping_planes_fragment:"#if NUM_CLIPPING_PLANES > 0\n\tvec4 plane;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < UNION_CLIPPING_PLANES; i ++ ) {\n\t\tplane = clippingPlanes[ i ];\n\t\tif ( dot( vClipPosition, plane.xyz ) > plane.w ) discard;\n\t}\n\t#pragma unroll_loop_end\n\t#if UNION_CLIPPING_PLANES < NUM_CLIPPING_PLANES\n\t\tbool clipped = true;\n\t\t#pragma unroll_loop_start\n\t\tfor ( int i = UNION_CLIPPING_PLANES; i < NUM_CLIPPING_PLANES; i ++ ) {\n\t\t\tplane = clippingPlanes[ i ];\n\t\t\tclipped = ( dot( vClipPosition, plane.xyz ) > plane.w ) && clipped;\n\t\t}\n\t\t#pragma unroll_loop_end\n\t\tif ( clipped ) discard;\n\t#endif\n#endif",clipping_planes_pars_fragment:"#if NUM_CLIPPING_PLANES > 0\n\tvarying vec3 vClipPosition;\n\tuniform vec4 clippingPlanes[ NUM_CLIPPING_PLANES ];\n#endif",clipping_planes_pars_vertex:"#if NUM_CLIPPING_PLANES > 0\n\tvarying vec3 vClipPosition;\n#endif",clipping_planes_vertex:"#if NUM_CLIPPING_PLANES > 0\n\tvClipPosition = - mvPosition.xyz;\n#endif",color_fragment:"#if defined( USE_COLOR_ALPHA )\n\tdiffuseColor *= vColor;\n#elif defined( USE_COLOR )\n\tdiffuseColor.rgb *= vColor;\n#endif",color_pars_fragment:"#if defined( USE_COLOR_ALPHA )\n\tvarying vec4 vColor;\n#elif defined( USE_COLOR )\n\tvarying vec3 vColor;\n#endif",color_pars_vertex:"#if defined( USE_COLOR_ALPHA )\n\tvarying vec4 vColor;\n#elif defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR )\n\tvarying vec3 vColor;\n#endif",color_vertex:"#if defined( USE_COLOR_ALPHA )\n\tvColor = vec4( 1.0 );\n#elif defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR )\n\tvColor = vec3( 1.0 );\n#endif\n#ifdef USE_COLOR\n\tvColor *= color;\n#endif\n#ifdef USE_INSTANCING_COLOR\n\tvColor.xyz *= instanceColor.xyz;\n#endif",common:"#define PI 3.141592653589793\n#define PI2 6.283185307179586\n#define PI_HALF 1.5707963267948966\n#define RECIPROCAL_PI 0.3183098861837907\n#define RECIPROCAL_PI2 0.15915494309189535\n#define EPSILON 1e-6\n#ifndef saturate\n#define saturate( a ) clamp( a, 0.0, 1.0 )\n#endif\n#define whiteComplement( a ) ( 1.0 - saturate( a ) )\nfloat pow2( const in float x ) { return x*x; }\nfloat pow3( const in float x ) { return x*x*x; }\nfloat pow4( const in float x ) { float x2 = x*x; return x2*x2; }\nfloat max3( const in vec3 v ) { return max( max( v.x, v.y ), v.z ); }\nfloat average( const in vec3 color ) { return dot( color, vec3( 0.3333 ) ); }\nhighp float rand( const in vec2 uv ) {\n\tconst highp float a = 12.9898, b = 78.233, c = 43758.5453;\n\thighp float dt = dot( uv.xy, vec2( a,b ) ), sn = mod( dt, PI );\n\treturn fract( sin( sn ) * c );\n}\n#ifdef HIGH_PRECISION\n\tfloat precisionSafeLength( vec3 v ) { return length( v ); }\n#else\n\tfloat precisionSafeLength( vec3 v ) {\n\t\tfloat maxComponent = max3( abs( v ) );\n\t\treturn length( v / maxComponent ) * maxComponent;\n\t}\n#endif\nstruct IncidentLight {\n\tvec3 color;\n\tvec3 direction;\n\tbool visible;\n};\nstruct ReflectedLight {\n\tvec3 directDiffuse;\n\tvec3 directSpecular;\n\tvec3 indirectDiffuse;\n\tvec3 indirectSpecular;\n};\nstruct GeometricContext {\n\tvec3 position;\n\tvec3 normal;\n\tvec3 viewDir;\n#ifdef USE_CLEARCOAT\n\tvec3 clearcoatNormal;\n#endif\n};\nvec3 transformDirection( in vec3 dir, in mat4 matrix ) {\n\treturn normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );\n}\nvec3 inverseTransformDirection( in vec3 dir, in mat4 matrix ) {\n\treturn normalize( ( vec4( dir, 0.0 ) * matrix ).xyz );\n}\nmat3 transposeMat3( const in mat3 m ) {\n\tmat3 tmp;\n\ttmp[ 0 ] = vec3( m[ 0 ].x, m[ 1 ].x, m[ 2 ].x );\n\ttmp[ 1 ] = vec3( m[ 0 ].y, m[ 1 ].y, m[ 2 ].y );\n\ttmp[ 2 ] = vec3( m[ 0 ].z, m[ 1 ].z, m[ 2 ].z );\n\treturn tmp;\n}\nfloat linearToRelativeLuminance( const in vec3 color ) {\n\tvec3 weights = vec3( 0.2126, 0.7152, 0.0722 );\n\treturn dot( weights, color.rgb );\n}\nbool isPerspectiveMatrix( mat4 m ) {\n\treturn m[ 2 ][ 3 ] == - 1.0;\n}\nvec2 equirectUv( in vec3 dir ) {\n\tfloat u = atan( dir.z, dir.x ) * RECIPROCAL_PI2 + 0.5;\n\tfloat v = asin( clamp( dir.y, - 1.0, 1.0 ) ) * RECIPROCAL_PI + 0.5;\n\treturn vec2( u, v );\n}",cube_uv_reflection_fragment:"#ifdef ENVMAP_TYPE_CUBE_UV\n\t#define cubeUV_maxMipLevel 8.0\n\t#define cubeUV_minMipLevel 4.0\n\t#define cubeUV_maxTileSize 256.0\n\t#define cubeUV_minTileSize 16.0\n\tfloat getFace( vec3 direction ) {\n\t\tvec3 absDirection = abs( direction );\n\t\tfloat face = - 1.0;\n\t\tif ( absDirection.x > absDirection.z ) {\n\t\t\tif ( absDirection.x > absDirection.y )\n\t\t\t\tface = direction.x > 0.0 ? 0.0 : 3.0;\n\t\t\telse\n\t\t\t\tface = direction.y > 0.0 ? 1.0 : 4.0;\n\t\t} else {\n\t\t\tif ( absDirection.z > absDirection.y )\n\t\t\t\tface = direction.z > 0.0 ? 2.0 : 5.0;\n\t\t\telse\n\t\t\t\tface = direction.y > 0.0 ? 1.0 : 4.0;\n\t\t}\n\t\treturn face;\n\t}\n\tvec2 getUV( vec3 direction, float face ) {\n\t\tvec2 uv;\n\t\tif ( face == 0.0 ) {\n\t\t\tuv = vec2( direction.z, direction.y ) / abs( direction.x );\n\t\t} else if ( face == 1.0 ) {\n\t\t\tuv = vec2( - direction.x, - direction.z ) / abs( direction.y );\n\t\t} else if ( face == 2.0 ) {\n\t\t\tuv = vec2( - direction.x, direction.y ) / abs( direction.z );\n\t\t} else if ( face == 3.0 ) {\n\t\t\tuv = vec2( - direction.z, direction.y ) / abs( direction.x );\n\t\t} else if ( face == 4.0 ) {\n\t\t\tuv = vec2( - direction.x, direction.z ) / abs( direction.y );\n\t\t} else {\n\t\t\tuv = vec2( direction.x, direction.y ) / abs( direction.z );\n\t\t}\n\t\treturn 0.5 * ( uv + 1.0 );\n\t}\n\tvec3 bilinearCubeUV( sampler2D envMap, vec3 direction, float mipInt ) {\n\t\tfloat face = getFace( direction );\n\t\tfloat filterInt = max( cubeUV_minMipLevel - mipInt, 0.0 );\n\t\tmipInt = max( mipInt, cubeUV_minMipLevel );\n\t\tfloat faceSize = exp2( mipInt );\n\t\tfloat texelSize = 1.0 / ( 3.0 * cubeUV_maxTileSize );\n\t\tvec2 uv = getUV( direction, face ) * ( faceSize - 1.0 ) + 0.5;\n\t\tif ( face > 2.0 ) {\n\t\t\tuv.y += faceSize;\n\t\t\tface -= 3.0;\n\t\t}\n\t\tuv.x += face * faceSize;\n\t\tif ( mipInt < cubeUV_maxMipLevel ) {\n\t\t\tuv.y += 2.0 * cubeUV_maxTileSize;\n\t\t}\n\t\tuv.y += filterInt * 2.0 * cubeUV_minTileSize;\n\t\tuv.x += 3.0 * max( 0.0, cubeUV_maxTileSize - 2.0 * faceSize );\n\t\tuv *= texelSize;\n\t\treturn texture2D( envMap, uv ).rgb;\n\t}\n\t#define r0 1.0\n\t#define v0 0.339\n\t#define m0 - 2.0\n\t#define r1 0.8\n\t#define v1 0.276\n\t#define m1 - 1.0\n\t#define r4 0.4\n\t#define v4 0.046\n\t#define m4 2.0\n\t#define r5 0.305\n\t#define v5 0.016\n\t#define m5 3.0\n\t#define r6 0.21\n\t#define v6 0.0038\n\t#define m6 4.0\n\tfloat roughnessToMip( float roughness ) {\n\t\tfloat mip = 0.0;\n\t\tif ( roughness >= r1 ) {\n\t\t\tmip = ( r0 - roughness ) * ( m1 - m0 ) / ( r0 - r1 ) + m0;\n\t\t} else if ( roughness >= r4 ) {\n\t\t\tmip = ( r1 - roughness ) * ( m4 - m1 ) / ( r1 - r4 ) + m1;\n\t\t} else if ( roughness >= r5 ) {\n\t\t\tmip = ( r4 - roughness ) * ( m5 - m4 ) / ( r4 - r5 ) + m4;\n\t\t} else if ( roughness >= r6 ) {\n\t\t\tmip = ( r5 - roughness ) * ( m6 - m5 ) / ( r5 - r6 ) + m5;\n\t\t} else {\n\t\t\tmip = - 2.0 * log2( 1.16 * roughness );\t\t}\n\t\treturn mip;\n\t}\n\tvec4 textureCubeUV( sampler2D envMap, vec3 sampleDir, float roughness ) {\n\t\tfloat mip = clamp( roughnessToMip( roughness ), m0, cubeUV_maxMipLevel );\n\t\tfloat mipF = fract( mip );\n\t\tfloat mipInt = floor( mip );\n\t\tvec3 color0 = bilinearCubeUV( envMap, sampleDir, mipInt );\n\t\tif ( mipF == 0.0 ) {\n\t\t\treturn vec4( color0, 1.0 );\n\t\t} else {\n\t\t\tvec3 color1 = bilinearCubeUV( envMap, sampleDir, mipInt + 1.0 );\n\t\t\treturn vec4( mix( color0, color1, mipF ), 1.0 );\n\t\t}\n\t}\n#endif",defaultnormal_vertex:"vec3 transformedNormal = objectNormal;\n#ifdef USE_INSTANCING\n\tmat3 m = mat3( instanceMatrix );\n\ttransformedNormal /= vec3( dot( m[ 0 ], m[ 0 ] ), dot( m[ 1 ], m[ 1 ] ), dot( m[ 2 ], m[ 2 ] ) );\n\ttransformedNormal = m * transformedNormal;\n#endif\ntransformedNormal = normalMatrix * transformedNormal;\n#ifdef FLIP_SIDED\n\ttransformedNormal = - transformedNormal;\n#endif\n#ifdef USE_TANGENT\n\tvec3 transformedTangent = ( modelViewMatrix * vec4( objectTangent, 0.0 ) ).xyz;\n\t#ifdef FLIP_SIDED\n\t\ttransformedTangent = - transformedTangent;\n\t#endif\n#endif",displacementmap_pars_vertex:"#ifdef USE_DISPLACEMENTMAP\n\tuniform sampler2D displacementMap;\n\tuniform float displacementScale;\n\tuniform float displacementBias;\n#endif",displacementmap_vertex:"#ifdef USE_DISPLACEMENTMAP\n\ttransformed += normalize( objectNormal ) * ( texture2D( displacementMap, vUv ).x * displacementScale + displacementBias );\n#endif",emissivemap_fragment:"#ifdef USE_EMISSIVEMAP\n\tvec4 emissiveColor = texture2D( emissiveMap, vUv );\n\ttotalEmissiveRadiance *= emissiveColor.rgb;\n#endif",emissivemap_pars_fragment:"#ifdef USE_EMISSIVEMAP\n\tuniform sampler2D emissiveMap;\n#endif",encodings_fragment:"gl_FragColor = linearToOutputTexel( gl_FragColor );",encodings_pars_fragment:"vec4 LinearToLinear( in vec4 value ) {\n\treturn value;\n}\nvec4 LinearTosRGB( in vec4 value ) {\n\treturn vec4( mix( pow( value.rgb, vec3( 0.41666 ) ) * 1.055 - vec3( 0.055 ), value.rgb * 12.92, vec3( lessThanEqual( value.rgb, vec3( 0.0031308 ) ) ) ), value.a );\n}",envmap_fragment:"#ifdef USE_ENVMAP\n\t#ifdef ENV_WORLDPOS\n\t\tvec3 cameraToFrag;\n\t\tif ( isOrthographic ) {\n\t\t\tcameraToFrag = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );\n\t\t} else {\n\t\t\tcameraToFrag = normalize( vWorldPosition - cameraPosition );\n\t\t}\n\t\tvec3 worldNormal = inverseTransformDirection( normal, viewMatrix );\n\t\t#ifdef ENVMAP_MODE_REFLECTION\n\t\t\tvec3 reflectVec = reflect( cameraToFrag, worldNormal );\n\t\t#else\n\t\t\tvec3 reflectVec = refract( cameraToFrag, worldNormal, refractionRatio );\n\t\t#endif\n\t#else\n\t\tvec3 reflectVec = vReflect;\n\t#endif\n\t#ifdef ENVMAP_TYPE_CUBE\n\t\tvec4 envColor = textureCube( envMap, vec3( flipEnvMap * reflectVec.x, reflectVec.yz ) );\n\t#elif defined( ENVMAP_TYPE_CUBE_UV )\n\t\tvec4 envColor = textureCubeUV( envMap, reflectVec, 0.0 );\n\t#else\n\t\tvec4 envColor = vec4( 0.0 );\n\t#endif\n\t#ifdef ENVMAP_BLENDING_MULTIPLY\n\t\toutgoingLight = mix( outgoingLight, outgoingLight * envColor.xyz, specularStrength * reflectivity );\n\t#elif defined( ENVMAP_BLENDING_MIX )\n\t\toutgoingLight = mix( outgoingLight, envColor.xyz, specularStrength * reflectivity );\n\t#elif defined( ENVMAP_BLENDING_ADD )\n\t\toutgoingLight += envColor.xyz * specularStrength * reflectivity;\n\t#endif\n#endif",envmap_common_pars_fragment:"#ifdef USE_ENVMAP\n\tuniform float envMapIntensity;\n\tuniform float flipEnvMap;\n\t#ifdef ENVMAP_TYPE_CUBE\n\t\tuniform samplerCube envMap;\n\t#else\n\t\tuniform sampler2D envMap;\n\t#endif\n\t\n#endif",envmap_pars_fragment:"#ifdef USE_ENVMAP\n\tuniform float reflectivity;\n\t#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG )\n\t\t#define ENV_WORLDPOS\n\t#endif\n\t#ifdef ENV_WORLDPOS\n\t\tvarying vec3 vWorldPosition;\n\t\tuniform float refractionRatio;\n\t#else\n\t\tvarying vec3 vReflect;\n\t#endif\n#endif",envmap_pars_vertex:"#ifdef USE_ENVMAP\n\t#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) ||defined( PHONG )\n\t\t#define ENV_WORLDPOS\n\t#endif\n\t#ifdef ENV_WORLDPOS\n\t\t\n\t\tvarying vec3 vWorldPosition;\n\t#else\n\t\tvarying vec3 vReflect;\n\t\tuniform float refractionRatio;\n\t#endif\n#endif",envmap_physical_pars_fragment:"#if defined( USE_ENVMAP )\n\t#ifdef ENVMAP_MODE_REFRACTION\n\t\tuniform float refractionRatio;\n\t#endif\n\tvec3 getIBLIrradiance( const in vec3 normal ) {\n\t\t#if defined( ENVMAP_TYPE_CUBE_UV )\n\t\t\tvec3 worldNormal = inverseTransformDirection( normal, viewMatrix );\n\t\t\tvec4 envMapColor = textureCubeUV( envMap, worldNormal, 1.0 );\n\t\t\treturn PI * envMapColor.rgb * envMapIntensity;\n\t\t#else\n\t\t\treturn vec3( 0.0 );\n\t\t#endif\n\t}\n\tvec3 getIBLRadiance( const in vec3 viewDir, const in vec3 normal, const in float roughness ) {\n\t\t#if defined( ENVMAP_TYPE_CUBE_UV )\n\t\t\tvec3 reflectVec;\n\t\t\t#ifdef ENVMAP_MODE_REFLECTION\n\t\t\t\treflectVec = reflect( - viewDir, normal );\n\t\t\t\treflectVec = normalize( mix( reflectVec, normal, roughness * roughness) );\n\t\t\t#else\n\t\t\t\treflectVec = refract( - viewDir, normal, refractionRatio );\n\t\t\t#endif\n\t\t\treflectVec = inverseTransformDirection( reflectVec, viewMatrix );\n\t\t\tvec4 envMapColor = textureCubeUV( envMap, reflectVec, roughness );\n\t\t\treturn envMapColor.rgb * envMapIntensity;\n\t\t#else\n\t\t\treturn vec3( 0.0 );\n\t\t#endif\n\t}\n#endif",envmap_vertex:"#ifdef USE_ENVMAP\n\t#ifdef ENV_WORLDPOS\n\t\tvWorldPosition = worldPosition.xyz;\n\t#else\n\t\tvec3 cameraToVertex;\n\t\tif ( isOrthographic ) {\n\t\t\tcameraToVertex = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );\n\t\t} else {\n\t\t\tcameraToVertex = normalize( worldPosition.xyz - cameraPosition );\n\t\t}\n\t\tvec3 worldNormal = inverseTransformDirection( transformedNormal, viewMatrix );\n\t\t#ifdef ENVMAP_MODE_REFLECTION\n\t\t\tvReflect = reflect( cameraToVertex, worldNormal );\n\t\t#else\n\t\t\tvReflect = refract( cameraToVertex, worldNormal, refractionRatio );\n\t\t#endif\n\t#endif\n#endif",fog_vertex:"#ifdef USE_FOG\n\tvFogDepth = - mvPosition.z;\n#endif",fog_pars_vertex:"#ifdef USE_FOG\n\tvarying float vFogDepth;\n#endif",fog_fragment:"#ifdef USE_FOG\n\t#ifdef FOG_EXP2\n\t\tfloat fogFactor = 1.0 - exp( - fogDensity * fogDensity * vFogDepth * vFogDepth );\n\t#else\n\t\tfloat fogFactor = smoothstep( fogNear, fogFar, vFogDepth );\n\t#endif\n\tgl_FragColor.rgb = mix( gl_FragColor.rgb, fogColor, fogFactor );\n#endif",fog_pars_fragment:"#ifdef USE_FOG\n\tuniform vec3 fogColor;\n\tvarying float vFogDepth;\n\t#ifdef FOG_EXP2\n\t\tuniform float fogDensity;\n\t#else\n\t\tuniform float fogNear;\n\t\tuniform float fogFar;\n\t#endif\n#endif",gradientmap_pars_fragment:"#ifdef USE_GRADIENTMAP\n\tuniform sampler2D gradientMap;\n#endif\nvec3 getGradientIrradiance( vec3 normal, vec3 lightDirection ) {\n\tfloat dotNL = dot( normal, lightDirection );\n\tvec2 coord = vec2( dotNL * 0.5 + 0.5, 0.0 );\n\t#ifdef USE_GRADIENTMAP\n\t\treturn vec3( texture2D( gradientMap, coord ).r );\n\t#else\n\t\treturn ( coord.x < 0.7 ) ? vec3( 0.7 ) : vec3( 1.0 );\n\t#endif\n}",lightmap_fragment:"#ifdef USE_LIGHTMAP\n\tvec4 lightMapTexel = texture2D( lightMap, vUv2 );\n\tvec3 lightMapIrradiance = lightMapTexel.rgb * lightMapIntensity;\n\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\tlightMapIrradiance *= PI;\n\t#endif\n\treflectedLight.indirectDiffuse += lightMapIrradiance;\n#endif",lightmap_pars_fragment:"#ifdef USE_LIGHTMAP\n\tuniform sampler2D lightMap;\n\tuniform float lightMapIntensity;\n#endif",lights_lambert_vertex:"vec3 diffuse = vec3( 1.0 );\nGeometricContext geometry;\ngeometry.position = mvPosition.xyz;\ngeometry.normal = normalize( transformedNormal );\ngeometry.viewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( -mvPosition.xyz );\nGeometricContext backGeometry;\nbackGeometry.position = geometry.position;\nbackGeometry.normal = -geometry.normal;\nbackGeometry.viewDir = geometry.viewDir;\nvLightFront = vec3( 0.0 );\nvIndirectFront = vec3( 0.0 );\n#ifdef DOUBLE_SIDED\n\tvLightBack = vec3( 0.0 );\n\tvIndirectBack = vec3( 0.0 );\n#endif\nIncidentLight directLight;\nfloat dotNL;\nvec3 directLightColor_Diffuse;\nvIndirectFront += getAmbientLightIrradiance( ambientLightColor );\nvIndirectFront += getLightProbeIrradiance( lightProbe, geometry.normal );\n#ifdef DOUBLE_SIDED\n\tvIndirectBack += getAmbientLightIrradiance( ambientLightColor );\n\tvIndirectBack += getLightProbeIrradiance( lightProbe, backGeometry.normal );\n#endif\n#if NUM_POINT_LIGHTS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\n\t\tgetPointLightInfo( pointLights[ i ], geometry, directLight );\n\t\tdotNL = dot( geometry.normal, directLight.direction );\n\t\tdirectLightColor_Diffuse = directLight.color;\n\t\tvLightFront += saturate( dotNL ) * directLightColor_Diffuse;\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvLightBack += saturate( - dotNL ) * directLightColor_Diffuse;\n\t\t#endif\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if NUM_SPOT_LIGHTS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\n\t\tgetSpotLightInfo( spotLights[ i ], geometry, directLight );\n\t\tdotNL = dot( geometry.normal, directLight.direction );\n\t\tdirectLightColor_Diffuse = directLight.color;\n\t\tvLightFront += saturate( dotNL ) * directLightColor_Diffuse;\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvLightBack += saturate( - dotNL ) * directLightColor_Diffuse;\n\t\t#endif\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if NUM_DIR_LIGHTS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n\t\tgetDirectionalLightInfo( directionalLights[ i ], geometry, directLight );\n\t\tdotNL = dot( geometry.normal, directLight.direction );\n\t\tdirectLightColor_Diffuse = directLight.color;\n\t\tvLightFront += saturate( dotNL ) * directLightColor_Diffuse;\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvLightBack += saturate( - dotNL ) * directLightColor_Diffuse;\n\t\t#endif\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if NUM_HEMI_LIGHTS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {\n\t\tvIndirectFront += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry.normal );\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvIndirectBack += getHemisphereLightIrradiance( hemisphereLights[ i ], backGeometry.normal );\n\t\t#endif\n\t}\n\t#pragma unroll_loop_end\n#endif",lights_pars_begin:"uniform bool receiveShadow;\nuniform vec3 ambientLightColor;\nuniform vec3 lightProbe[ 9 ];\nvec3 shGetIrradianceAt( in vec3 normal, in vec3 shCoefficients[ 9 ] ) {\n\tfloat x = normal.x, y = normal.y, z = normal.z;\n\tvec3 result = shCoefficients[ 0 ] * 0.886227;\n\tresult += shCoefficients[ 1 ] * 2.0 * 0.511664 * y;\n\tresult += shCoefficients[ 2 ] * 2.0 * 0.511664 * z;\n\tresult += shCoefficients[ 3 ] * 2.0 * 0.511664 * x;\n\tresult += shCoefficients[ 4 ] * 2.0 * 0.429043 * x * y;\n\tresult += shCoefficients[ 5 ] * 2.0 * 0.429043 * y * z;\n\tresult += shCoefficients[ 6 ] * ( 0.743125 * z * z - 0.247708 );\n\tresult += shCoefficients[ 7 ] * 2.0 * 0.429043 * x * z;\n\tresult += shCoefficients[ 8 ] * 0.429043 * ( x * x - y * y );\n\treturn result;\n}\nvec3 getLightProbeIrradiance( const in vec3 lightProbe[ 9 ], const in vec3 normal ) {\n\tvec3 worldNormal = inverseTransformDirection( normal, viewMatrix );\n\tvec3 irradiance = shGetIrradianceAt( worldNormal, lightProbe );\n\treturn irradiance;\n}\nvec3 getAmbientLightIrradiance( const in vec3 ambientLightColor ) {\n\tvec3 irradiance = ambientLightColor;\n\treturn irradiance;\n}\nfloat getDistanceAttenuation( const in float lightDistance, const in float cutoffDistance, const in float decayExponent ) {\n\t#if defined ( PHYSICALLY_CORRECT_LIGHTS )\n\t\tfloat distanceFalloff = 1.0 / max( pow( lightDistance, decayExponent ), 0.01 );\n\t\tif ( cutoffDistance > 0.0 ) {\n\t\t\tdistanceFalloff *= pow2( saturate( 1.0 - pow4( lightDistance / cutoffDistance ) ) );\n\t\t}\n\t\treturn distanceFalloff;\n\t#else\n\t\tif ( cutoffDistance > 0.0 && decayExponent > 0.0 ) {\n\t\t\treturn pow( saturate( - lightDistance / cutoffDistance + 1.0 ), decayExponent );\n\t\t}\n\t\treturn 1.0;\n\t#endif\n}\nfloat getSpotAttenuation( const in float coneCosine, const in float penumbraCosine, const in float angleCosine ) {\n\treturn smoothstep( coneCosine, penumbraCosine, angleCosine );\n}\n#if NUM_DIR_LIGHTS > 0\n\tstruct DirectionalLight {\n\t\tvec3 direction;\n\t\tvec3 color;\n\t};\n\tuniform DirectionalLight directionalLights[ NUM_DIR_LIGHTS ];\n\tvoid getDirectionalLightInfo( const in DirectionalLight directionalLight, const in GeometricContext geometry, out IncidentLight light ) {\n\t\tlight.color = directionalLight.color;\n\t\tlight.direction = directionalLight.direction;\n\t\tlight.visible = true;\n\t}\n#endif\n#if NUM_POINT_LIGHTS > 0\n\tstruct PointLight {\n\t\tvec3 position;\n\t\tvec3 color;\n\t\tfloat distance;\n\t\tfloat decay;\n\t};\n\tuniform PointLight pointLights[ NUM_POINT_LIGHTS ];\n\tvoid getPointLightInfo( const in PointLight pointLight, const in GeometricContext geometry, out IncidentLight light ) {\n\t\tvec3 lVector = pointLight.position - geometry.position;\n\t\tlight.direction = normalize( lVector );\n\t\tfloat lightDistance = length( lVector );\n\t\tlight.color = pointLight.color;\n\t\tlight.color *= getDistanceAttenuation( lightDistance, pointLight.distance, pointLight.decay );\n\t\tlight.visible = ( light.color != vec3( 0.0 ) );\n\t}\n#endif\n#if NUM_SPOT_LIGHTS > 0\n\tstruct SpotLight {\n\t\tvec3 position;\n\t\tvec3 direction;\n\t\tvec3 color;\n\t\tfloat distance;\n\t\tfloat decay;\n\t\tfloat coneCos;\n\t\tfloat penumbraCos;\n\t};\n\tuniform SpotLight spotLights[ NUM_SPOT_LIGHTS ];\n\tvoid getSpotLightInfo( const in SpotLight spotLight, const in GeometricContext geometry, out IncidentLight light ) {\n\t\tvec3 lVector = spotLight.position - geometry.position;\n\t\tlight.direction = normalize( lVector );\n\t\tfloat angleCos = dot( light.direction, spotLight.direction );\n\t\tfloat spotAttenuation = getSpotAttenuation( spotLight.coneCos, spotLight.penumbraCos, angleCos );\n\t\tif ( spotAttenuation > 0.0 ) {\n\t\t\tfloat lightDistance = length( lVector );\n\t\t\tlight.color = spotLight.color * spotAttenuation;\n\t\t\tlight.color *= getDistanceAttenuation( lightDistance, spotLight.distance, spotLight.decay );\n\t\t\tlight.visible = ( light.color != vec3( 0.0 ) );\n\t\t} else {\n\t\t\tlight.color = vec3( 0.0 );\n\t\t\tlight.visible = false;\n\t\t}\n\t}\n#endif\n#if NUM_RECT_AREA_LIGHTS > 0\n\tstruct RectAreaLight {\n\t\tvec3 color;\n\t\tvec3 position;\n\t\tvec3 halfWidth;\n\t\tvec3 halfHeight;\n\t};\n\tuniform sampler2D ltc_1;\tuniform sampler2D ltc_2;\n\tuniform RectAreaLight rectAreaLights[ NUM_RECT_AREA_LIGHTS ];\n#endif\n#if NUM_HEMI_LIGHTS > 0\n\tstruct HemisphereLight {\n\t\tvec3 direction;\n\t\tvec3 skyColor;\n\t\tvec3 groundColor;\n\t};\n\tuniform HemisphereLight hemisphereLights[ NUM_HEMI_LIGHTS ];\n\tvec3 getHemisphereLightIrradiance( const in HemisphereLight hemiLight, const in vec3 normal ) {\n\t\tfloat dotNL = dot( normal, hemiLight.direction );\n\t\tfloat hemiDiffuseWeight = 0.5 * dotNL + 0.5;\n\t\tvec3 irradiance = mix( hemiLight.groundColor, hemiLight.skyColor, hemiDiffuseWeight );\n\t\treturn irradiance;\n\t}\n#endif",lights_toon_fragment:"ToonMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb;",lights_toon_pars_fragment:"varying vec3 vViewPosition;\nstruct ToonMaterial {\n\tvec3 diffuseColor;\n};\nvoid RE_Direct_Toon( const in IncidentLight directLight, const in GeometricContext geometry, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {\n\tvec3 irradiance = getGradientIrradiance( geometry.normal, directLight.direction ) * directLight.color;\n\treflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectDiffuse_Toon( const in vec3 irradiance, const in GeometricContext geometry, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {\n\treflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\n#define RE_Direct\t\t\t\tRE_Direct_Toon\n#define RE_IndirectDiffuse\t\tRE_IndirectDiffuse_Toon\n#define Material_LightProbeLOD( material )\t(0)",lights_phong_fragment:"BlinnPhongMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb;\nmaterial.specularColor = specular;\nmaterial.specularShininess = shininess;\nmaterial.specularStrength = specularStrength;",lights_phong_pars_fragment:"varying vec3 vViewPosition;\nstruct BlinnPhongMaterial {\n\tvec3 diffuseColor;\n\tvec3 specularColor;\n\tfloat specularShininess;\n\tfloat specularStrength;\n};\nvoid RE_Direct_BlinnPhong( const in IncidentLight directLight, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {\n\tfloat dotNL = saturate( dot( geometry.normal, directLight.direction ) );\n\tvec3 irradiance = dotNL * directLight.color;\n\treflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n\treflectedLight.directSpecular += irradiance * BRDF_BlinnPhong( directLight.direction, geometry.viewDir, geometry.normal, material.specularColor, material.specularShininess ) * material.specularStrength;\n}\nvoid RE_IndirectDiffuse_BlinnPhong( const in vec3 irradiance, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {\n\treflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\n#define RE_Direct\t\t\t\tRE_Direct_BlinnPhong\n#define RE_IndirectDiffuse\t\tRE_IndirectDiffuse_BlinnPhong\n#define Material_LightProbeLOD( material )\t(0)",lights_physical_fragment:"PhysicalMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb * ( 1.0 - metalnessFactor );\nvec3 dxy = max( abs( dFdx( geometryNormal ) ), abs( dFdy( geometryNormal ) ) );\nfloat geometryRoughness = max( max( dxy.x, dxy.y ), dxy.z );\nmaterial.roughness = max( roughnessFactor, 0.0525 );material.roughness += geometryRoughness;\nmaterial.roughness = min( material.roughness, 1.0 );\n#ifdef IOR\n\t#ifdef SPECULAR\n\t\tfloat specularIntensityFactor = specularIntensity;\n\t\tvec3 specularColorFactor = specularColor;\n\t\t#ifdef USE_SPECULARINTENSITYMAP\n\t\t\tspecularIntensityFactor *= texture2D( specularIntensityMap, vUv ).a;\n\t\t#endif\n\t\t#ifdef USE_SPECULARCOLORMAP\n\t\t\tspecularColorFactor *= texture2D( specularColorMap, vUv ).rgb;\n\t\t#endif\n\t\tmaterial.specularF90 = mix( specularIntensityFactor, 1.0, metalnessFactor );\n\t#else\n\t\tfloat specularIntensityFactor = 1.0;\n\t\tvec3 specularColorFactor = vec3( 1.0 );\n\t\tmaterial.specularF90 = 1.0;\n\t#endif\n\tmaterial.specularColor = mix( min( pow2( ( ior - 1.0 ) / ( ior + 1.0 ) ) * specularColorFactor, vec3( 1.0 ) ) * specularIntensityFactor, diffuseColor.rgb, metalnessFactor );\n#else\n\tmaterial.specularColor = mix( vec3( 0.04 ), diffuseColor.rgb, metalnessFactor );\n\tmaterial.specularF90 = 1.0;\n#endif\n#ifdef USE_CLEARCOAT\n\tmaterial.clearcoat = clearcoat;\n\tmaterial.clearcoatRoughness = clearcoatRoughness;\n\tmaterial.clearcoatF0 = vec3( 0.04 );\n\tmaterial.clearcoatF90 = 1.0;\n\t#ifdef USE_CLEARCOATMAP\n\t\tmaterial.clearcoat *= texture2D( clearcoatMap, vUv ).x;\n\t#endif\n\t#ifdef USE_CLEARCOAT_ROUGHNESSMAP\n\t\tmaterial.clearcoatRoughness *= texture2D( clearcoatRoughnessMap, vUv ).y;\n\t#endif\n\tmaterial.clearcoat = saturate( material.clearcoat );\tmaterial.clearcoatRoughness = max( material.clearcoatRoughness, 0.0525 );\n\tmaterial.clearcoatRoughness += geometryRoughness;\n\tmaterial.clearcoatRoughness = min( material.clearcoatRoughness, 1.0 );\n#endif\n#ifdef USE_SHEEN\n\tmaterial.sheenColor = sheenColor;\n\t#ifdef USE_SHEENCOLORMAP\n\t\tmaterial.sheenColor *= texture2D( sheenColorMap, vUv ).rgb;\n\t#endif\n\tmaterial.sheenRoughness = clamp( sheenRoughness, 0.07, 1.0 );\n\t#ifdef USE_SHEENROUGHNESSMAP\n\t\tmaterial.sheenRoughness *= texture2D( sheenRoughnessMap, vUv ).a;\n\t#endif\n#endif",lights_physical_pars_fragment:"struct PhysicalMaterial {\n\tvec3 diffuseColor;\n\tfloat roughness;\n\tvec3 specularColor;\n\tfloat specularF90;\n\t#ifdef USE_CLEARCOAT\n\t\tfloat clearcoat;\n\t\tfloat clearcoatRoughness;\n\t\tvec3 clearcoatF0;\n\t\tfloat clearcoatF90;\n\t#endif\n\t#ifdef USE_SHEEN\n\t\tvec3 sheenColor;\n\t\tfloat sheenRoughness;\n\t#endif\n};\nvec3 clearcoatSpecular = vec3( 0.0 );\nvec3 sheenSpecular = vec3( 0.0 );\nfloat IBLSheenBRDF( const in vec3 normal, const in vec3 viewDir, const in float roughness) {\n\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\tfloat r2 = roughness * roughness;\n\tfloat a = roughness < 0.25 ? -339.2 * r2 + 161.4 * roughness - 25.9 : -8.48 * r2 + 14.3 * roughness - 9.95;\n\tfloat b = roughness < 0.25 ? 44.0 * r2 - 23.7 * roughness + 3.26 : 1.97 * r2 - 3.27 * roughness + 0.72;\n\tfloat DG = exp( a * dotNV + b ) + ( roughness < 0.25 ? 0.0 : 0.1 * ( roughness - 0.25 ) );\n\treturn saturate( DG * RECIPROCAL_PI );\n}\nvec2 DFGApprox( const in vec3 normal, const in vec3 viewDir, const in float roughness ) {\n\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\tconst vec4 c0 = vec4( - 1, - 0.0275, - 0.572, 0.022 );\n\tconst vec4 c1 = vec4( 1, 0.0425, 1.04, - 0.04 );\n\tvec4 r = roughness * c0 + c1;\n\tfloat a004 = min( r.x * r.x, exp2( - 9.28 * dotNV ) ) * r.x + r.y;\n\tvec2 fab = vec2( - 1.04, 1.04 ) * a004 + r.zw;\n\treturn fab;\n}\nvec3 EnvironmentBRDF( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float roughness ) {\n\tvec2 fab = DFGApprox( normal, viewDir, roughness );\n\treturn specularColor * fab.x + specularF90 * fab.y;\n}\nvoid computeMultiscattering( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float roughness, inout vec3 singleScatter, inout vec3 multiScatter ) {\n\tvec2 fab = DFGApprox( normal, viewDir, roughness );\n\tvec3 FssEss = specularColor * fab.x + specularF90 * fab.y;\n\tfloat Ess = fab.x + fab.y;\n\tfloat Ems = 1.0 - Ess;\n\tvec3 Favg = specularColor + ( 1.0 - specularColor ) * 0.047619;\tvec3 Fms = FssEss * Favg / ( 1.0 - Ems * Favg );\n\tsingleScatter += FssEss;\n\tmultiScatter += Fms * Ems;\n}\n#if NUM_RECT_AREA_LIGHTS > 0\n\tvoid RE_Direct_RectArea_Physical( const in RectAreaLight rectAreaLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n\t\tvec3 normal = geometry.normal;\n\t\tvec3 viewDir = geometry.viewDir;\n\t\tvec3 position = geometry.position;\n\t\tvec3 lightPos = rectAreaLight.position;\n\t\tvec3 halfWidth = rectAreaLight.halfWidth;\n\t\tvec3 halfHeight = rectAreaLight.halfHeight;\n\t\tvec3 lightColor = rectAreaLight.color;\n\t\tfloat roughness = material.roughness;\n\t\tvec3 rectCoords[ 4 ];\n\t\trectCoords[ 0 ] = lightPos + halfWidth - halfHeight;\t\trectCoords[ 1 ] = lightPos - halfWidth - halfHeight;\n\t\trectCoords[ 2 ] = lightPos - halfWidth + halfHeight;\n\t\trectCoords[ 3 ] = lightPos + halfWidth + halfHeight;\n\t\tvec2 uv = LTC_Uv( normal, viewDir, roughness );\n\t\tvec4 t1 = texture2D( ltc_1, uv );\n\t\tvec4 t2 = texture2D( ltc_2, uv );\n\t\tmat3 mInv = mat3(\n\t\t\tvec3( t1.x, 0, t1.y ),\n\t\t\tvec3(    0, 1,    0 ),\n\t\t\tvec3( t1.z, 0, t1.w )\n\t\t);\n\t\tvec3 fresnel = ( material.specularColor * t2.x + ( vec3( 1.0 ) - material.specularColor ) * t2.y );\n\t\treflectedLight.directSpecular += lightColor * fresnel * LTC_Evaluate( normal, viewDir, position, mInv, rectCoords );\n\t\treflectedLight.directDiffuse += lightColor * material.diffuseColor * LTC_Evaluate( normal, viewDir, position, mat3( 1.0 ), rectCoords );\n\t}\n#endif\nvoid RE_Direct_Physical( const in IncidentLight directLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n\tfloat dotNL = saturate( dot( geometry.normal, directLight.direction ) );\n\tvec3 irradiance = dotNL * directLight.color;\n\t#ifdef USE_CLEARCOAT\n\t\tfloat dotNLcc = saturate( dot( geometry.clearcoatNormal, directLight.direction ) );\n\t\tvec3 ccIrradiance = dotNLcc * directLight.color;\n\t\tclearcoatSpecular += ccIrradiance * BRDF_GGX( directLight.direction, geometry.viewDir, geometry.clearcoatNormal, material.clearcoatF0, material.clearcoatF90, material.clearcoatRoughness );\n\t#endif\n\t#ifdef USE_SHEEN\n\t\tsheenSpecular += irradiance * BRDF_Sheen( directLight.direction, geometry.viewDir, geometry.normal, material.sheenColor, material.sheenRoughness );\n\t#endif\n\treflectedLight.directSpecular += irradiance * BRDF_GGX( directLight.direction, geometry.viewDir, geometry.normal, material.specularColor, material.specularF90, material.roughness );\n\treflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectDiffuse_Physical( const in vec3 irradiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n\treflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectSpecular_Physical( const in vec3 radiance, const in vec3 irradiance, const in vec3 clearcoatRadiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight) {\n\t#ifdef USE_CLEARCOAT\n\t\tclearcoatSpecular += clearcoatRadiance * EnvironmentBRDF( geometry.clearcoatNormal, geometry.viewDir, material.clearcoatF0, material.clearcoatF90, material.clearcoatRoughness );\n\t#endif\n\t#ifdef USE_SHEEN\n\t\tsheenSpecular += irradiance * material.sheenColor * IBLSheenBRDF( geometry.normal, geometry.viewDir, material.sheenRoughness );\n\t#endif\n\tvec3 singleScattering = vec3( 0.0 );\n\tvec3 multiScattering = vec3( 0.0 );\n\tvec3 cosineWeightedIrradiance = irradiance * RECIPROCAL_PI;\n\tcomputeMultiscattering( geometry.normal, geometry.viewDir, material.specularColor, material.specularF90, material.roughness, singleScattering, multiScattering );\n\tvec3 diffuse = material.diffuseColor * ( 1.0 - ( singleScattering + multiScattering ) );\n\treflectedLight.indirectSpecular += radiance * singleScattering;\n\treflectedLight.indirectSpecular += multiScattering * cosineWeightedIrradiance;\n\treflectedLight.indirectDiffuse += diffuse * cosineWeightedIrradiance;\n}\n#define RE_Direct\t\t\t\tRE_Direct_Physical\n#define RE_Direct_RectArea\t\tRE_Direct_RectArea_Physical\n#define RE_IndirectDiffuse\t\tRE_IndirectDiffuse_Physical\n#define RE_IndirectSpecular\t\tRE_IndirectSpecular_Physical\nfloat computeSpecularOcclusion( const in float dotNV, const in float ambientOcclusion, const in float roughness ) {\n\treturn saturate( pow( dotNV + ambientOcclusion, exp2( - 16.0 * roughness - 1.0 ) ) - 1.0 + ambientOcclusion );\n}",lights_fragment_begin:"\nGeometricContext geometry;\ngeometry.position = - vViewPosition;\ngeometry.normal = normal;\ngeometry.viewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( vViewPosition );\n#ifdef USE_CLEARCOAT\n\tgeometry.clearcoatNormal = clearcoatNormal;\n#endif\nIncidentLight directLight;\n#if ( NUM_POINT_LIGHTS > 0 ) && defined( RE_Direct )\n\tPointLight pointLight;\n\t#if defined( USE_SHADOWMAP ) && NUM_POINT_LIGHT_SHADOWS > 0\n\tPointLightShadow pointLightShadow;\n\t#endif\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\n\t\tpointLight = pointLights[ i ];\n\t\tgetPointLightInfo( pointLight, geometry, directLight );\n\t\t#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_POINT_LIGHT_SHADOWS )\n\t\tpointLightShadow = pointLightShadows[ i ];\n\t\tdirectLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getPointShadow( pointShadowMap[ i ], pointLightShadow.shadowMapSize, pointLightShadow.shadowBias, pointLightShadow.shadowRadius, vPointShadowCoord[ i ], pointLightShadow.shadowCameraNear, pointLightShadow.shadowCameraFar ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometry, material, reflectedLight );\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if ( NUM_SPOT_LIGHTS > 0 ) && defined( RE_Direct )\n\tSpotLight spotLight;\n\t#if defined( USE_SHADOWMAP ) && NUM_SPOT_LIGHT_SHADOWS > 0\n\tSpotLightShadow spotLightShadow;\n\t#endif\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\n\t\tspotLight = spotLights[ i ];\n\t\tgetSpotLightInfo( spotLight, geometry, directLight );\n\t\t#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )\n\t\tspotLightShadow = spotLightShadows[ i ];\n\t\tdirectLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getShadow( spotShadowMap[ i ], spotLightShadow.shadowMapSize, spotLightShadow.shadowBias, spotLightShadow.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometry, material, reflectedLight );\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if ( NUM_DIR_LIGHTS > 0 ) && defined( RE_Direct )\n\tDirectionalLight directionalLight;\n\t#if defined( USE_SHADOWMAP ) && NUM_DIR_LIGHT_SHADOWS > 0\n\tDirectionalLightShadow directionalLightShadow;\n\t#endif\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n\t\tdirectionalLight = directionalLights[ i ];\n\t\tgetDirectionalLightInfo( directionalLight, geometry, directLight );\n\t\t#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS )\n\t\tdirectionalLightShadow = directionalLightShadows[ i ];\n\t\tdirectLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getShadow( directionalShadowMap[ i ], directionalLightShadow.shadowMapSize, directionalLightShadow.shadowBias, directionalLightShadow.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometry, material, reflectedLight );\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if ( NUM_RECT_AREA_LIGHTS > 0 ) && defined( RE_Direct_RectArea )\n\tRectAreaLight rectAreaLight;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_RECT_AREA_LIGHTS; i ++ ) {\n\t\trectAreaLight = rectAreaLights[ i ];\n\t\tRE_Direct_RectArea( rectAreaLight, geometry, material, reflectedLight );\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if defined( RE_IndirectDiffuse )\n\tvec3 iblIrradiance = vec3( 0.0 );\n\tvec3 irradiance = getAmbientLightIrradiance( ambientLightColor );\n\tirradiance += getLightProbeIrradiance( lightProbe, geometry.normal );\n\t#if ( NUM_HEMI_LIGHTS > 0 )\n\t\t#pragma unroll_loop_start\n\t\tfor ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {\n\t\t\tirradiance += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry.normal );\n\t\t}\n\t\t#pragma unroll_loop_end\n\t#endif\n#endif\n#if defined( RE_IndirectSpecular )\n\tvec3 radiance = vec3( 0.0 );\n\tvec3 clearcoatRadiance = vec3( 0.0 );\n#endif",lights_fragment_maps:"#if defined( RE_IndirectDiffuse )\n\t#ifdef USE_LIGHTMAP\n\t\tvec4 lightMapTexel = texture2D( lightMap, vUv2 );\n\t\tvec3 lightMapIrradiance = lightMapTexel.rgb * lightMapIntensity;\n\t\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\t\tlightMapIrradiance *= PI;\n\t\t#endif\n\t\tirradiance += lightMapIrradiance;\n\t#endif\n\t#if defined( USE_ENVMAP ) && defined( STANDARD ) && defined( ENVMAP_TYPE_CUBE_UV )\n\t\tiblIrradiance += getIBLIrradiance( geometry.normal );\n\t#endif\n#endif\n#if defined( USE_ENVMAP ) && defined( RE_IndirectSpecular )\n\tradiance += getIBLRadiance( geometry.viewDir, geometry.normal, material.roughness );\n\t#ifdef USE_CLEARCOAT\n\t\tclearcoatRadiance += getIBLRadiance( geometry.viewDir, geometry.clearcoatNormal, material.clearcoatRoughness );\n\t#endif\n#endif",lights_fragment_end:"#if defined( RE_IndirectDiffuse )\n\tRE_IndirectDiffuse( irradiance, geometry, material, reflectedLight );\n#endif\n#if defined( RE_IndirectSpecular )\n\tRE_IndirectSpecular( radiance, iblIrradiance, clearcoatRadiance, geometry, material, reflectedLight );\n#endif",logdepthbuf_fragment:"#if defined( USE_LOGDEPTHBUF ) && defined( USE_LOGDEPTHBUF_EXT )\n\tgl_FragDepthEXT = vIsPerspective == 0.0 ? gl_FragCoord.z : log2( vFragDepth ) * logDepthBufFC * 0.5;\n#endif",logdepthbuf_pars_fragment:"#if defined( USE_LOGDEPTHBUF ) && defined( USE_LOGDEPTHBUF_EXT )\n\tuniform float logDepthBufFC;\n\tvarying float vFragDepth;\n\tvarying float vIsPerspective;\n#endif",logdepthbuf_pars_vertex:"#ifdef USE_LOGDEPTHBUF\n\t#ifdef USE_LOGDEPTHBUF_EXT\n\t\tvarying float vFragDepth;\n\t\tvarying float vIsPerspective;\n\t#else\n\t\tuniform float logDepthBufFC;\n\t#endif\n#endif",logdepthbuf_vertex:"#ifdef USE_LOGDEPTHBUF\n\t#ifdef USE_LOGDEPTHBUF_EXT\n\t\tvFragDepth = 1.0 + gl_Position.w;\n\t\tvIsPerspective = float( isPerspectiveMatrix( projectionMatrix ) );\n\t#else\n\t\tif ( isPerspectiveMatrix( projectionMatrix ) ) {\n\t\t\tgl_Position.z = log2( max( EPSILON, gl_Position.w + 1.0 ) ) * logDepthBufFC - 1.0;\n\t\t\tgl_Position.z *= gl_Position.w;\n\t\t}\n\t#endif\n#endif",map_fragment:"#ifdef USE_MAP\n\tvec4 sampledDiffuseColor = texture2D( map, vUv );\n\t#ifdef DECODE_VIDEO_TEXTURE\n\t\tsampledDiffuseColor = vec4( mix( pow( sampledDiffuseColor.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), sampledDiffuseColor.rgb * 0.0773993808, vec3( lessThanEqual( sampledDiffuseColor.rgb, vec3( 0.04045 ) ) ) ), sampledDiffuseColor.w );\n\t#endif\n\tdiffuseColor *= sampledDiffuseColor;\n#endif",map_pars_fragment:"#ifdef USE_MAP\n\tuniform sampler2D map;\n#endif",map_particle_fragment:"#if defined( USE_MAP ) || defined( USE_ALPHAMAP )\n\tvec2 uv = ( uvTransform * vec3( gl_PointCoord.x, 1.0 - gl_PointCoord.y, 1 ) ).xy;\n#endif\n#ifdef USE_MAP\n\tdiffuseColor *= texture2D( map, uv );\n#endif\n#ifdef USE_ALPHAMAP\n\tdiffuseColor.a *= texture2D( alphaMap, uv ).g;\n#endif",map_particle_pars_fragment:"#if defined( USE_MAP ) || defined( USE_ALPHAMAP )\n\tuniform mat3 uvTransform;\n#endif\n#ifdef USE_MAP\n\tuniform sampler2D map;\n#endif\n#ifdef USE_ALPHAMAP\n\tuniform sampler2D alphaMap;\n#endif",metalnessmap_fragment:"float metalnessFactor = metalness;\n#ifdef USE_METALNESSMAP\n\tvec4 texelMetalness = texture2D( metalnessMap, vUv );\n\tmetalnessFactor *= texelMetalness.b;\n#endif",metalnessmap_pars_fragment:"#ifdef USE_METALNESSMAP\n\tuniform sampler2D metalnessMap;\n#endif",morphnormal_vertex:"#ifdef USE_MORPHNORMALS\n\tobjectNormal *= morphTargetBaseInfluence;\n\t#ifdef MORPHTARGETS_TEXTURE\n\t\tfor ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {\n\t\t\tif ( morphTargetInfluences[ i ] != 0.0 ) objectNormal += getMorph( gl_VertexID, i, 1, 2 ) * morphTargetInfluences[ i ];\n\t\t}\n\t#else\n\t\tobjectNormal += morphNormal0 * morphTargetInfluences[ 0 ];\n\t\tobjectNormal += morphNormal1 * morphTargetInfluences[ 1 ];\n\t\tobjectNormal += morphNormal2 * morphTargetInfluences[ 2 ];\n\t\tobjectNormal += morphNormal3 * morphTargetInfluences[ 3 ];\n\t#endif\n#endif",morphtarget_pars_vertex:"#ifdef USE_MORPHTARGETS\n\tuniform float morphTargetBaseInfluence;\n\t#ifdef MORPHTARGETS_TEXTURE\n\t\tuniform float morphTargetInfluences[ MORPHTARGETS_COUNT ];\n\t\tuniform sampler2DArray morphTargetsTexture;\n\t\tuniform vec2 morphTargetsTextureSize;\n\t\tvec3 getMorph( const in int vertexIndex, const in int morphTargetIndex, const in int offset, const in int stride ) {\n\t\t\tfloat texelIndex = float( vertexIndex * stride + offset );\n\t\t\tfloat y = floor( texelIndex / morphTargetsTextureSize.x );\n\t\t\tfloat x = texelIndex - y * morphTargetsTextureSize.x;\n\t\t\tvec3 morphUV = vec3( ( x + 0.5 ) / morphTargetsTextureSize.x, y / morphTargetsTextureSize.y, morphTargetIndex );\n\t\t\treturn texture( morphTargetsTexture, morphUV ).xyz;\n\t\t}\n\t#else\n\t\t#ifndef USE_MORPHNORMALS\n\t\t\tuniform float morphTargetInfluences[ 8 ];\n\t\t#else\n\t\t\tuniform float morphTargetInfluences[ 4 ];\n\t\t#endif\n\t#endif\n#endif",morphtarget_vertex:"#ifdef USE_MORPHTARGETS\n\ttransformed *= morphTargetBaseInfluence;\n\t#ifdef MORPHTARGETS_TEXTURE\n\t\tfor ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {\n\t\t\t#ifndef USE_MORPHNORMALS\n\t\t\t\tif ( morphTargetInfluences[ i ] != 0.0 ) transformed += getMorph( gl_VertexID, i, 0, 1 ) * morphTargetInfluences[ i ];\n\t\t\t#else\n\t\t\t\tif ( morphTargetInfluences[ i ] != 0.0 ) transformed += getMorph( gl_VertexID, i, 0, 2 ) * morphTargetInfluences[ i ];\n\t\t\t#endif\n\t\t}\n\t#else\n\t\ttransformed += morphTarget0 * morphTargetInfluences[ 0 ];\n\t\ttransformed += morphTarget1 * morphTargetInfluences[ 1 ];\n\t\ttransformed += morphTarget2 * morphTargetInfluences[ 2 ];\n\t\ttransformed += morphTarget3 * morphTargetInfluences[ 3 ];\n\t\t#ifndef USE_MORPHNORMALS\n\t\t\ttransformed += morphTarget4 * morphTargetInfluences[ 4 ];\n\t\t\ttransformed += morphTarget5 * morphTargetInfluences[ 5 ];\n\t\t\ttransformed += morphTarget6 * morphTargetInfluences[ 6 ];\n\t\t\ttransformed += morphTarget7 * morphTargetInfluences[ 7 ];\n\t\t#endif\n\t#endif\n#endif",normal_fragment_begin:"float faceDirection = gl_FrontFacing ? 1.0 : - 1.0;\n#ifdef FLAT_SHADED\n\tvec3 fdx = vec3( dFdx( vViewPosition.x ), dFdx( vViewPosition.y ), dFdx( vViewPosition.z ) );\n\tvec3 fdy = vec3( dFdy( vViewPosition.x ), dFdy( vViewPosition.y ), dFdy( vViewPosition.z ) );\n\tvec3 normal = normalize( cross( fdx, fdy ) );\n#else\n\tvec3 normal = normalize( vNormal );\n\t#ifdef DOUBLE_SIDED\n\t\tnormal = normal * faceDirection;\n\t#endif\n\t#ifdef USE_TANGENT\n\t\tvec3 tangent = normalize( vTangent );\n\t\tvec3 bitangent = normalize( vBitangent );\n\t\t#ifdef DOUBLE_SIDED\n\t\t\ttangent = tangent * faceDirection;\n\t\t\tbitangent = bitangent * faceDirection;\n\t\t#endif\n\t\t#if defined( TANGENTSPACE_NORMALMAP ) || defined( USE_CLEARCOAT_NORMALMAP )\n\t\t\tmat3 vTBN = mat3( tangent, bitangent, normal );\n\t\t#endif\n\t#endif\n#endif\nvec3 geometryNormal = normal;",normal_fragment_maps:"#ifdef OBJECTSPACE_NORMALMAP\n\tnormal = texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;\n\t#ifdef FLIP_SIDED\n\t\tnormal = - normal;\n\t#endif\n\t#ifdef DOUBLE_SIDED\n\t\tnormal = normal * faceDirection;\n\t#endif\n\tnormal = normalize( normalMatrix * normal );\n#elif defined( TANGENTSPACE_NORMALMAP )\n\tvec3 mapN = texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;\n\tmapN.xy *= normalScale;\n\t#ifdef USE_TANGENT\n\t\tnormal = normalize( vTBN * mapN );\n\t#else\n\t\tnormal = perturbNormal2Arb( - vViewPosition, normal, mapN, faceDirection );\n\t#endif\n#elif defined( USE_BUMPMAP )\n\tnormal = perturbNormalArb( - vViewPosition, normal, dHdxy_fwd(), faceDirection );\n#endif",normal_pars_fragment:"#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n\t#ifdef USE_TANGENT\n\t\tvarying vec3 vTangent;\n\t\tvarying vec3 vBitangent;\n\t#endif\n#endif",normal_pars_vertex:"#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n\t#ifdef USE_TANGENT\n\t\tvarying vec3 vTangent;\n\t\tvarying vec3 vBitangent;\n\t#endif\n#endif",normal_vertex:"#ifndef FLAT_SHADED\n\tvNormal = normalize( transformedNormal );\n\t#ifdef USE_TANGENT\n\t\tvTangent = normalize( transformedTangent );\n\t\tvBitangent = normalize( cross( vNormal, vTangent ) * tangent.w );\n\t#endif\n#endif",normalmap_pars_fragment:"#ifdef USE_NORMALMAP\n\tuniform sampler2D normalMap;\n\tuniform vec2 normalScale;\n#endif\n#ifdef OBJECTSPACE_NORMALMAP\n\tuniform mat3 normalMatrix;\n#endif\n#if ! defined ( USE_TANGENT ) && ( defined ( TANGENTSPACE_NORMALMAP ) || defined ( USE_CLEARCOAT_NORMALMAP ) )\n\tvec3 perturbNormal2Arb( vec3 eye_pos, vec3 surf_norm, vec3 mapN, float faceDirection ) {\n\t\tvec3 q0 = vec3( dFdx( eye_pos.x ), dFdx( eye_pos.y ), dFdx( eye_pos.z ) );\n\t\tvec3 q1 = vec3( dFdy( eye_pos.x ), dFdy( eye_pos.y ), dFdy( eye_pos.z ) );\n\t\tvec2 st0 = dFdx( vUv.st );\n\t\tvec2 st1 = dFdy( vUv.st );\n\t\tvec3 N = surf_norm;\n\t\tvec3 q1perp = cross( q1, N );\n\t\tvec3 q0perp = cross( N, q0 );\n\t\tvec3 T = q1perp * st0.x + q0perp * st1.x;\n\t\tvec3 B = q1perp * st0.y + q0perp * st1.y;\n\t\tfloat det = max( dot( T, T ), dot( B, B ) );\n\t\tfloat scale = ( det == 0.0 ) ? 0.0 : faceDirection * inversesqrt( det );\n\t\treturn normalize( T * ( mapN.x * scale ) + B * ( mapN.y * scale ) + N * mapN.z );\n\t}\n#endif",clearcoat_normal_fragment_begin:"#ifdef USE_CLEARCOAT\n\tvec3 clearcoatNormal = geometryNormal;\n#endif",clearcoat_normal_fragment_maps:"#ifdef USE_CLEARCOAT_NORMALMAP\n\tvec3 clearcoatMapN = texture2D( clearcoatNormalMap, vUv ).xyz * 2.0 - 1.0;\n\tclearcoatMapN.xy *= clearcoatNormalScale;\n\t#ifdef USE_TANGENT\n\t\tclearcoatNormal = normalize( vTBN * clearcoatMapN );\n\t#else\n\t\tclearcoatNormal = perturbNormal2Arb( - vViewPosition, clearcoatNormal, clearcoatMapN, faceDirection );\n\t#endif\n#endif",clearcoat_pars_fragment:"#ifdef USE_CLEARCOATMAP\n\tuniform sampler2D clearcoatMap;\n#endif\n#ifdef USE_CLEARCOAT_ROUGHNESSMAP\n\tuniform sampler2D clearcoatRoughnessMap;\n#endif\n#ifdef USE_CLEARCOAT_NORMALMAP\n\tuniform sampler2D clearcoatNormalMap;\n\tuniform vec2 clearcoatNormalScale;\n#endif",output_fragment:"#ifdef OPAQUE\ndiffuseColor.a = 1.0;\n#endif\n#ifdef USE_TRANSMISSION\ndiffuseColor.a *= transmissionAlpha + 0.1;\n#endif\ngl_FragColor = vec4( outgoingLight, diffuseColor.a );",packing:"vec3 packNormalToRGB( const in vec3 normal ) {\n\treturn normalize( normal ) * 0.5 + 0.5;\n}\nvec3 unpackRGBToNormal( const in vec3 rgb ) {\n\treturn 2.0 * rgb.xyz - 1.0;\n}\nconst float PackUpscale = 256. / 255.;const float UnpackDownscale = 255. / 256.;\nconst vec3 PackFactors = vec3( 256. * 256. * 256., 256. * 256., 256. );\nconst vec4 UnpackFactors = UnpackDownscale / vec4( PackFactors, 1. );\nconst float ShiftRight8 = 1. / 256.;\nvec4 packDepthToRGBA( const in float v ) {\n\tvec4 r = vec4( fract( v * PackFactors ), v );\n\tr.yzw -= r.xyz * ShiftRight8;\treturn r * PackUpscale;\n}\nfloat unpackRGBAToDepth( const in vec4 v ) {\n\treturn dot( v, UnpackFactors );\n}\nvec4 pack2HalfToRGBA( vec2 v ) {\n\tvec4 r = vec4( v.x, fract( v.x * 255.0 ), v.y, fract( v.y * 255.0 ) );\n\treturn vec4( r.x - r.y / 255.0, r.y, r.z - r.w / 255.0, r.w );\n}\nvec2 unpackRGBATo2Half( vec4 v ) {\n\treturn vec2( v.x + ( v.y / 255.0 ), v.z + ( v.w / 255.0 ) );\n}\nfloat viewZToOrthographicDepth( const in float viewZ, const in float near, const in float far ) {\n\treturn ( viewZ + near ) / ( near - far );\n}\nfloat orthographicDepthToViewZ( const in float linearClipZ, const in float near, const in float far ) {\n\treturn linearClipZ * ( near - far ) - near;\n}\nfloat viewZToPerspectiveDepth( const in float viewZ, const in float near, const in float far ) {\n\treturn ( ( near + viewZ ) * far ) / ( ( far - near ) * viewZ );\n}\nfloat perspectiveDepthToViewZ( const in float invClipZ, const in float near, const in float far ) {\n\treturn ( near * far ) / ( ( far - near ) * invClipZ - far );\n}",premultiplied_alpha_fragment:"#ifdef PREMULTIPLIED_ALPHA\n\tgl_FragColor.rgb *= gl_FragColor.a;\n#endif",project_vertex:"vec4 mvPosition = vec4( transformed, 1.0 );\n#ifdef USE_INSTANCING\n\tmvPosition = instanceMatrix * mvPosition;\n#endif\nmvPosition = modelViewMatrix * mvPosition;\ngl_Position = projectionMatrix * mvPosition;",dithering_fragment:"#ifdef DITHERING\n\tgl_FragColor.rgb = dithering( gl_FragColor.rgb );\n#endif",dithering_pars_fragment:"#ifdef DITHERING\n\tvec3 dithering( vec3 color ) {\n\t\tfloat grid_position = rand( gl_FragCoord.xy );\n\t\tvec3 dither_shift_RGB = vec3( 0.25 / 255.0, -0.25 / 255.0, 0.25 / 255.0 );\n\t\tdither_shift_RGB = mix( 2.0 * dither_shift_RGB, -2.0 * dither_shift_RGB, grid_position );\n\t\treturn color + dither_shift_RGB;\n\t}\n#endif",roughnessmap_fragment:"float roughnessFactor = roughness;\n#ifdef USE_ROUGHNESSMAP\n\tvec4 texelRoughness = texture2D( roughnessMap, vUv );\n\troughnessFactor *= texelRoughness.g;\n#endif",roughnessmap_pars_fragment:"#ifdef USE_ROUGHNESSMAP\n\tuniform sampler2D roughnessMap;\n#endif",shadowmap_pars_fragment:"#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\t\tuniform sampler2D directionalShadowMap[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tvarying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tstruct DirectionalLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t};\n\t\tuniform DirectionalLightShadow directionalLightShadows[ NUM_DIR_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS > 0\n\t\tuniform sampler2D spotShadowMap[ NUM_SPOT_LIGHT_SHADOWS ];\n\t\tvarying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHT_SHADOWS ];\n\t\tstruct SpotLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t};\n\t\tuniform SpotLightShadow spotLightShadows[ NUM_SPOT_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\t\tuniform sampler2D pointShadowMap[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tvarying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tstruct PointLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t\tfloat shadowCameraNear;\n\t\t\tfloat shadowCameraFar;\n\t\t};\n\t\tuniform PointLightShadow pointLightShadows[ NUM_POINT_LIGHT_SHADOWS ];\n\t#endif\n\tfloat texture2DCompare( sampler2D depths, vec2 uv, float compare ) {\n\t\treturn step( compare, unpackRGBAToDepth( texture2D( depths, uv ) ) );\n\t}\n\tvec2 texture2DDistribution( sampler2D shadow, vec2 uv ) {\n\t\treturn unpackRGBATo2Half( texture2D( shadow, uv ) );\n\t}\n\tfloat VSMShadow (sampler2D shadow, vec2 uv, float compare ){\n\t\tfloat occlusion = 1.0;\n\t\tvec2 distribution = texture2DDistribution( shadow, uv );\n\t\tfloat hard_shadow = step( compare , distribution.x );\n\t\tif (hard_shadow != 1.0 ) {\n\t\t\tfloat distance = compare - distribution.x ;\n\t\t\tfloat variance = max( 0.00000, distribution.y * distribution.y );\n\t\t\tfloat softness_probability = variance / (variance + distance * distance );\t\t\tsoftness_probability = clamp( ( softness_probability - 0.3 ) / ( 0.95 - 0.3 ), 0.0, 1.0 );\t\t\tocclusion = clamp( max( hard_shadow, softness_probability ), 0.0, 1.0 );\n\t\t}\n\t\treturn occlusion;\n\t}\n\tfloat getShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord ) {\n\t\tfloat shadow = 1.0;\n\t\tshadowCoord.xyz /= shadowCoord.w;\n\t\tshadowCoord.z += shadowBias;\n\t\tbvec4 inFrustumVec = bvec4 ( shadowCoord.x >= 0.0, shadowCoord.x <= 1.0, shadowCoord.y >= 0.0, shadowCoord.y <= 1.0 );\n\t\tbool inFrustum = all( inFrustumVec );\n\t\tbvec2 frustumTestVec = bvec2( inFrustum, shadowCoord.z <= 1.0 );\n\t\tbool frustumTest = all( frustumTestVec );\n\t\tif ( frustumTest ) {\n\t\t#if defined( SHADOWMAP_TYPE_PCF )\n\t\t\tvec2 texelSize = vec2( 1.0 ) / shadowMapSize;\n\t\t\tfloat dx0 = - texelSize.x * shadowRadius;\n\t\t\tfloat dy0 = - texelSize.y * shadowRadius;\n\t\t\tfloat dx1 = + texelSize.x * shadowRadius;\n\t\t\tfloat dy1 = + texelSize.y * shadowRadius;\n\t\t\tfloat dx2 = dx0 / 2.0;\n\t\t\tfloat dy2 = dy0 / 2.0;\n\t\t\tfloat dx3 = dx1 / 2.0;\n\t\t\tfloat dy3 = dy1 / 2.0;\n\t\t\tshadow = (\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, dy2 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy2 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, dy2 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, dy3 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy3 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, dy3 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy1 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy1 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy1 ), shadowCoord.z )\n\t\t\t) * ( 1.0 / 17.0 );\n\t\t#elif defined( SHADOWMAP_TYPE_PCF_SOFT )\n\t\t\tvec2 texelSize = vec2( 1.0 ) / shadowMapSize;\n\t\t\tfloat dx = texelSize.x;\n\t\t\tfloat dy = texelSize.y;\n\t\t\tvec2 uv = shadowCoord.xy;\n\t\t\tvec2 f = fract( uv * shadowMapSize + 0.5 );\n\t\t\tuv -= f * texelSize;\n\t\t\tshadow = (\n\t\t\t\ttexture2DCompare( shadowMap, uv, shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, uv + vec2( dx, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, uv + vec2( 0.0, dy ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, uv + texelSize, shadowCoord.z ) +\n\t\t\t\tmix( texture2DCompare( shadowMap, uv + vec2( -dx, 0.0 ), shadowCoord.z ), \n\t\t\t\t\t texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, 0.0 ), shadowCoord.z ),\n\t\t\t\t\t f.x ) +\n\t\t\t\tmix( texture2DCompare( shadowMap, uv + vec2( -dx, dy ), shadowCoord.z ), \n\t\t\t\t\t texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, dy ), shadowCoord.z ),\n\t\t\t\t\t f.x ) +\n\t\t\t\tmix( texture2DCompare( shadowMap, uv + vec2( 0.0, -dy ), shadowCoord.z ), \n\t\t\t\t\t texture2DCompare( shadowMap, uv + vec2( 0.0, 2.0 * dy ), shadowCoord.z ),\n\t\t\t\t\t f.y ) +\n\t\t\t\tmix( texture2DCompare( shadowMap, uv + vec2( dx, -dy ), shadowCoord.z ), \n\t\t\t\t\t texture2DCompare( shadowMap, uv + vec2( dx, 2.0 * dy ), shadowCoord.z ),\n\t\t\t\t\t f.y ) +\n\t\t\t\tmix( mix( texture2DCompare( shadowMap, uv + vec2( -dx, -dy ), shadowCoord.z ), \n\t\t\t\t\t\t  texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, -dy ), shadowCoord.z ),\n\t\t\t\t\t\t  f.x ),\n\t\t\t\t\t mix( texture2DCompare( shadowMap, uv + vec2( -dx, 2.0 * dy ), shadowCoord.z ), \n\t\t\t\t\t\t  texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, 2.0 * dy ), shadowCoord.z ),\n\t\t\t\t\t\t  f.x ),\n\t\t\t\t\t f.y )\n\t\t\t) * ( 1.0 / 9.0 );\n\t\t#elif defined( SHADOWMAP_TYPE_VSM )\n\t\t\tshadow = VSMShadow( shadowMap, shadowCoord.xy, shadowCoord.z );\n\t\t#else\n\t\t\tshadow = texture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z );\n\t\t#endif\n\t\t}\n\t\treturn shadow;\n\t}\n\tvec2 cubeToUV( vec3 v, float texelSizeY ) {\n\t\tvec3 absV = abs( v );\n\t\tfloat scaleToCube = 1.0 / max( absV.x, max( absV.y, absV.z ) );\n\t\tabsV *= scaleToCube;\n\t\tv *= scaleToCube * ( 1.0 - 2.0 * texelSizeY );\n\t\tvec2 planar = v.xy;\n\t\tfloat almostATexel = 1.5 * texelSizeY;\n\t\tfloat almostOne = 1.0 - almostATexel;\n\t\tif ( absV.z >= almostOne ) {\n\t\t\tif ( v.z > 0.0 )\n\t\t\t\tplanar.x = 4.0 - v.x;\n\t\t} else if ( absV.x >= almostOne ) {\n\t\t\tfloat signX = sign( v.x );\n\t\t\tplanar.x = v.z * signX + 2.0 * signX;\n\t\t} else if ( absV.y >= almostOne ) {\n\t\t\tfloat signY = sign( v.y );\n\t\t\tplanar.x = v.x + 2.0 * signY + 2.0;\n\t\t\tplanar.y = v.z * signY - 2.0;\n\t\t}\n\t\treturn vec2( 0.125, 0.25 ) * planar + vec2( 0.375, 0.75 );\n\t}\n\tfloat getPointShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord, float shadowCameraNear, float shadowCameraFar ) {\n\t\tvec2 texelSize = vec2( 1.0 ) / ( shadowMapSize * vec2( 4.0, 2.0 ) );\n\t\tvec3 lightToPosition = shadowCoord.xyz;\n\t\tfloat dp = ( length( lightToPosition ) - shadowCameraNear ) / ( shadowCameraFar - shadowCameraNear );\t\tdp += shadowBias;\n\t\tvec3 bd3D = normalize( lightToPosition );\n\t\t#if defined( SHADOWMAP_TYPE_PCF ) || defined( SHADOWMAP_TYPE_PCF_SOFT ) || defined( SHADOWMAP_TYPE_VSM )\n\t\t\tvec2 offset = vec2( - 1, 1 ) * shadowRadius * texelSize.y;\n\t\t\treturn (\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyy, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyy, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyx, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyx, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxy, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxy, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxx, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxx, texelSize.y ), dp )\n\t\t\t) * ( 1.0 / 9.0 );\n\t\t#else\n\t\t\treturn texture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp );\n\t\t#endif\n\t}\n#endif",shadowmap_pars_vertex:"#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\t\tuniform mat4 directionalShadowMatrix[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tvarying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tstruct DirectionalLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t};\n\t\tuniform DirectionalLightShadow directionalLightShadows[ NUM_DIR_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS > 0\n\t\tuniform mat4 spotShadowMatrix[ NUM_SPOT_LIGHT_SHADOWS ];\n\t\tvarying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHT_SHADOWS ];\n\t\tstruct SpotLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t};\n\t\tuniform SpotLightShadow spotLightShadows[ NUM_SPOT_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\t\tuniform mat4 pointShadowMatrix[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tvarying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tstruct PointLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t\tfloat shadowCameraNear;\n\t\t\tfloat shadowCameraFar;\n\t\t};\n\t\tuniform PointLightShadow pointLightShadows[ NUM_POINT_LIGHT_SHADOWS ];\n\t#endif\n#endif",shadowmap_vertex:"#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS > 0 || NUM_SPOT_LIGHT_SHADOWS > 0 || NUM_POINT_LIGHT_SHADOWS > 0\n\t\tvec3 shadowWorldNormal = inverseTransformDirection( transformedNormal, viewMatrix );\n\t\tvec4 shadowWorldPosition;\n\t#endif\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {\n\t\tshadowWorldPosition = worldPosition + vec4( shadowWorldNormal * directionalLightShadows[ i ].shadowNormalBias, 0 );\n\t\tvDirectionalShadowCoord[ i ] = directionalShadowMatrix[ i ] * shadowWorldPosition;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_SPOT_LIGHT_SHADOWS; i ++ ) {\n\t\tshadowWorldPosition = worldPosition + vec4( shadowWorldNormal * spotLightShadows[ i ].shadowNormalBias, 0 );\n\t\tvSpotShadowCoord[ i ] = spotShadowMatrix[ i ] * shadowWorldPosition;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {\n\t\tshadowWorldPosition = worldPosition + vec4( shadowWorldNormal * pointLightShadows[ i ].shadowNormalBias, 0 );\n\t\tvPointShadowCoord[ i ] = pointShadowMatrix[ i ] * shadowWorldPosition;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n#endif",shadowmask_pars_fragment:"float getShadowMask() {\n\tfloat shadow = 1.0;\n\t#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\tDirectionalLightShadow directionalLight;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {\n\t\tdirectionalLight = directionalLightShadows[ i ];\n\t\tshadow *= receiveShadow ? getShadow( directionalShadowMap[ i ], directionalLight.shadowMapSize, directionalLight.shadowBias, directionalLight.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS > 0\n\tSpotLightShadow spotLight;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_SPOT_LIGHT_SHADOWS; i ++ ) {\n\t\tspotLight = spotLightShadows[ i ];\n\t\tshadow *= receiveShadow ? getShadow( spotShadowMap[ i ], spotLight.shadowMapSize, spotLight.shadowBias, spotLight.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\tPointLightShadow pointLight;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {\n\t\tpointLight = pointLightShadows[ i ];\n\t\tshadow *= receiveShadow ? getPointShadow( pointShadowMap[ i ], pointLight.shadowMapSize, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ i ], pointLight.shadowCameraNear, pointLight.shadowCameraFar ) : 1.0;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#endif\n\treturn shadow;\n}",skinbase_vertex:"#ifdef USE_SKINNING\n\tmat4 boneMatX = getBoneMatrix( skinIndex.x );\n\tmat4 boneMatY = getBoneMatrix( skinIndex.y );\n\tmat4 boneMatZ = getBoneMatrix( skinIndex.z );\n\tmat4 boneMatW = getBoneMatrix( skinIndex.w );\n#endif",skinning_pars_vertex:"#ifdef USE_SKINNING\n\tuniform mat4 bindMatrix;\n\tuniform mat4 bindMatrixInverse;\n\t#ifdef BONE_TEXTURE\n\t\tuniform highp sampler2D boneTexture;\n\t\tuniform int boneTextureSize;\n\t\tmat4 getBoneMatrix( const in float i ) {\n\t\t\tfloat j = i * 4.0;\n\t\t\tfloat x = mod( j, float( boneTextureSize ) );\n\t\t\tfloat y = floor( j / float( boneTextureSize ) );\n\t\t\tfloat dx = 1.0 / float( boneTextureSize );\n\t\t\tfloat dy = 1.0 / float( boneTextureSize );\n\t\t\ty = dy * ( y + 0.5 );\n\t\t\tvec4 v1 = texture2D( boneTexture, vec2( dx * ( x + 0.5 ), y ) );\n\t\t\tvec4 v2 = texture2D( boneTexture, vec2( dx * ( x + 1.5 ), y ) );\n\t\t\tvec4 v3 = texture2D( boneTexture, vec2( dx * ( x + 2.5 ), y ) );\n\t\t\tvec4 v4 = texture2D( boneTexture, vec2( dx * ( x + 3.5 ), y ) );\n\t\t\tmat4 bone = mat4( v1, v2, v3, v4 );\n\t\t\treturn bone;\n\t\t}\n\t#else\n\t\tuniform mat4 boneMatrices[ MAX_BONES ];\n\t\tmat4 getBoneMatrix( const in float i ) {\n\t\t\tmat4 bone = boneMatrices[ int(i) ];\n\t\t\treturn bone;\n\t\t}\n\t#endif\n#endif",skinning_vertex:"#ifdef USE_SKINNING\n\tvec4 skinVertex = bindMatrix * vec4( transformed, 1.0 );\n\tvec4 skinned = vec4( 0.0 );\n\tskinned += boneMatX * skinVertex * skinWeight.x;\n\tskinned += boneMatY * skinVertex * skinWeight.y;\n\tskinned += boneMatZ * skinVertex * skinWeight.z;\n\tskinned += boneMatW * skinVertex * skinWeight.w;\n\ttransformed = ( bindMatrixInverse * skinned ).xyz;\n#endif",skinnormal_vertex:"#ifdef USE_SKINNING\n\tmat4 skinMatrix = mat4( 0.0 );\n\tskinMatrix += skinWeight.x * boneMatX;\n\tskinMatrix += skinWeight.y * boneMatY;\n\tskinMatrix += skinWeight.z * boneMatZ;\n\tskinMatrix += skinWeight.w * boneMatW;\n\tskinMatrix = bindMatrixInverse * skinMatrix * bindMatrix;\n\tobjectNormal = vec4( skinMatrix * vec4( objectNormal, 0.0 ) ).xyz;\n\t#ifdef USE_TANGENT\n\t\tobjectTangent = vec4( skinMatrix * vec4( objectTangent, 0.0 ) ).xyz;\n\t#endif\n#endif",specularmap_fragment:"float specularStrength;\n#ifdef USE_SPECULARMAP\n\tvec4 texelSpecular = texture2D( specularMap, vUv );\n\tspecularStrength = texelSpecular.r;\n#else\n\tspecularStrength = 1.0;\n#endif",specularmap_pars_fragment:"#ifdef USE_SPECULARMAP\n\tuniform sampler2D specularMap;\n#endif",tonemapping_fragment:"#if defined( TONE_MAPPING )\n\tgl_FragColor.rgb = toneMapping( gl_FragColor.rgb );\n#endif",tonemapping_pars_fragment:"#ifndef saturate\n#define saturate( a ) clamp( a, 0.0, 1.0 )\n#endif\nuniform float toneMappingExposure;\nvec3 LinearToneMapping( vec3 color ) {\n\treturn toneMappingExposure * color;\n}\nvec3 ReinhardToneMapping( vec3 color ) {\n\tcolor *= toneMappingExposure;\n\treturn saturate( color / ( vec3( 1.0 ) + color ) );\n}\nvec3 OptimizedCineonToneMapping( vec3 color ) {\n\tcolor *= toneMappingExposure;\n\tcolor = max( vec3( 0.0 ), color - 0.004 );\n\treturn pow( ( color * ( 6.2 * color + 0.5 ) ) / ( color * ( 6.2 * color + 1.7 ) + 0.06 ), vec3( 2.2 ) );\n}\nvec3 RRTAndODTFit( vec3 v ) {\n\tvec3 a = v * ( v + 0.0245786 ) - 0.000090537;\n\tvec3 b = v * ( 0.983729 * v + 0.4329510 ) + 0.238081;\n\treturn a / b;\n}\nvec3 ACESFilmicToneMapping( vec3 color ) {\n\tconst mat3 ACESInputMat = mat3(\n\t\tvec3( 0.59719, 0.07600, 0.02840 ),\t\tvec3( 0.35458, 0.90834, 0.13383 ),\n\t\tvec3( 0.04823, 0.01566, 0.83777 )\n\t);\n\tconst mat3 ACESOutputMat = mat3(\n\t\tvec3(  1.60475, -0.10208, -0.00327 ),\t\tvec3( -0.53108,  1.10813, -0.07276 ),\n\t\tvec3( -0.07367, -0.00605,  1.07602 )\n\t);\n\tcolor *= toneMappingExposure / 0.6;\n\tcolor = ACESInputMat * color;\n\tcolor = RRTAndODTFit( color );\n\tcolor = ACESOutputMat * color;\n\treturn saturate( color );\n}\nvec3 CustomToneMapping( vec3 color ) { return color; }",transmission_fragment:"#ifdef USE_TRANSMISSION\n\tfloat transmissionAlpha = 1.0;\n\tfloat transmissionFactor = transmission;\n\tfloat thicknessFactor = thickness;\n\t#ifdef USE_TRANSMISSIONMAP\n\t\ttransmissionFactor *= texture2D( transmissionMap, vUv ).r;\n\t#endif\n\t#ifdef USE_THICKNESSMAP\n\t\tthicknessFactor *= texture2D( thicknessMap, vUv ).g;\n\t#endif\n\tvec3 pos = vWorldPosition;\n\tvec3 v = normalize( cameraPosition - pos );\n\tvec3 n = inverseTransformDirection( normal, viewMatrix );\n\tvec4 transmission = getIBLVolumeRefraction(\n\t\tn, v, roughnessFactor, material.diffuseColor, material.specularColor, material.specularF90,\n\t\tpos, modelMatrix, viewMatrix, projectionMatrix, ior, thicknessFactor,\n\t\tattenuationColor, attenuationDistance );\n\ttotalDiffuse = mix( totalDiffuse, transmission.rgb, transmissionFactor );\n\ttransmissionAlpha = mix( transmissionAlpha, transmission.a, transmissionFactor );\n#endif",transmission_pars_fragment:"#ifdef USE_TRANSMISSION\n\tuniform float transmission;\n\tuniform float thickness;\n\tuniform float attenuationDistance;\n\tuniform vec3 attenuationColor;\n\t#ifdef USE_TRANSMISSIONMAP\n\t\tuniform sampler2D transmissionMap;\n\t#endif\n\t#ifdef USE_THICKNESSMAP\n\t\tuniform sampler2D thicknessMap;\n\t#endif\n\tuniform vec2 transmissionSamplerSize;\n\tuniform sampler2D transmissionSamplerMap;\n\tuniform mat4 modelMatrix;\n\tuniform mat4 projectionMatrix;\n\tvarying vec3 vWorldPosition;\n\tvec3 getVolumeTransmissionRay( const in vec3 n, const in vec3 v, const in float thickness, const in float ior, const in mat4 modelMatrix ) {\n\t\tvec3 refractionVector = refract( - v, normalize( n ), 1.0 / ior );\n\t\tvec3 modelScale;\n\t\tmodelScale.x = length( vec3( modelMatrix[ 0 ].xyz ) );\n\t\tmodelScale.y = length( vec3( modelMatrix[ 1 ].xyz ) );\n\t\tmodelScale.z = length( vec3( modelMatrix[ 2 ].xyz ) );\n\t\treturn normalize( refractionVector ) * thickness * modelScale;\n\t}\n\tfloat applyIorToRoughness( const in float roughness, const in float ior ) {\n\t\treturn roughness * clamp( ior * 2.0 - 2.0, 0.0, 1.0 );\n\t}\n\tvec4 getTransmissionSample( const in vec2 fragCoord, const in float roughness, const in float ior ) {\n\t\tfloat framebufferLod = log2( transmissionSamplerSize.x ) * applyIorToRoughness( roughness, ior );\n\t\t#ifdef TEXTURE_LOD_EXT\n\t\t\treturn texture2DLodEXT( transmissionSamplerMap, fragCoord.xy, framebufferLod );\n\t\t#else\n\t\t\treturn texture2D( transmissionSamplerMap, fragCoord.xy, framebufferLod );\n\t\t#endif\n\t}\n\tvec3 applyVolumeAttenuation( const in vec3 radiance, const in float transmissionDistance, const in vec3 attenuationColor, const in float attenuationDistance ) {\n\t\tif ( attenuationDistance == 0.0 ) {\n\t\t\treturn radiance;\n\t\t} else {\n\t\t\tvec3 attenuationCoefficient = -log( attenuationColor ) / attenuationDistance;\n\t\t\tvec3 transmittance = exp( - attenuationCoefficient * transmissionDistance );\t\t\treturn transmittance * radiance;\n\t\t}\n\t}\n\tvec4 getIBLVolumeRefraction( const in vec3 n, const in vec3 v, const in float roughness, const in vec3 diffuseColor,\n\t\tconst in vec3 specularColor, const in float specularF90, const in vec3 position, const in mat4 modelMatrix,\n\t\tconst in mat4 viewMatrix, const in mat4 projMatrix, const in float ior, const in float thickness,\n\t\tconst in vec3 attenuationColor, const in float attenuationDistance ) {\n\t\tvec3 transmissionRay = getVolumeTransmissionRay( n, v, thickness, ior, modelMatrix );\n\t\tvec3 refractedRayExit = position + transmissionRay;\n\t\tvec4 ndcPos = projMatrix * viewMatrix * vec4( refractedRayExit, 1.0 );\n\t\tvec2 refractionCoords = ndcPos.xy / ndcPos.w;\n\t\trefractionCoords += 1.0;\n\t\trefractionCoords /= 2.0;\n\t\tvec4 transmittedLight = getTransmissionSample( refractionCoords, roughness, ior );\n\t\tvec3 attenuatedColor = applyVolumeAttenuation( transmittedLight.rgb, length( transmissionRay ), attenuationColor, attenuationDistance );\n\t\tvec3 F = EnvironmentBRDF( n, v, specularColor, specularF90, roughness );\n\t\treturn vec4( ( 1.0 - F ) * attenuatedColor * diffuseColor, transmittedLight.a );\n\t}\n#endif",uv_pars_fragment:"#if ( defined( USE_UV ) && ! defined( UVS_VERTEX_ONLY ) )\n\tvarying vec2 vUv;\n#endif",uv_pars_vertex:"#ifdef USE_UV\n\t#ifdef UVS_VERTEX_ONLY\n\t\tvec2 vUv;\n\t#else\n\t\tvarying vec2 vUv;\n\t#endif\n\tuniform mat3 uvTransform;\n#endif",uv_vertex:"#ifdef USE_UV\n\tvUv = ( uvTransform * vec3( uv, 1 ) ).xy;\n#endif",uv2_pars_fragment:"#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\n\tvarying vec2 vUv2;\n#endif",uv2_pars_vertex:"#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\n\tattribute vec2 uv2;\n\tvarying vec2 vUv2;\n\tuniform mat3 uv2Transform;\n#endif",uv2_vertex:"#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\n\tvUv2 = ( uv2Transform * vec3( uv2, 1 ) ).xy;\n#endif",worldpos_vertex:"#if defined( USE_ENVMAP ) || defined( DISTANCE ) || defined ( USE_SHADOWMAP ) || defined ( USE_TRANSMISSION )\n\tvec4 worldPosition = vec4( transformed, 1.0 );\n\t#ifdef USE_INSTANCING\n\t\tworldPosition = instanceMatrix * worldPosition;\n\t#endif\n\tworldPosition = modelMatrix * worldPosition;\n#endif",background_vert:"varying vec2 vUv;\nuniform mat3 uvTransform;\nvoid main() {\n\tvUv = ( uvTransform * vec3( uv, 1 ) ).xy;\n\tgl_Position = vec4( position.xy, 1.0, 1.0 );\n}",background_frag:"uniform sampler2D t2D;\nvarying vec2 vUv;\nvoid main() {\n\tgl_FragColor = texture2D( t2D, vUv );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n}",cube_vert:"varying vec3 vWorldDirection;\n#include <common>\nvoid main() {\n\tvWorldDirection = transformDirection( position, modelMatrix );\n\t#include <begin_vertex>\n\t#include <project_vertex>\n\tgl_Position.z = gl_Position.w;\n}",cube_frag:"#include <envmap_common_pars_fragment>\nuniform float opacity;\nvarying vec3 vWorldDirection;\n#include <cube_uv_reflection_fragment>\nvoid main() {\n\tvec3 vReflect = vWorldDirection;\n\t#include <envmap_fragment>\n\tgl_FragColor = envColor;\n\tgl_FragColor.a *= opacity;\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n}",depth_vert:"#include <common>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvarying vec2 vHighPrecisionZW;\nvoid main() {\n\t#include <uv_vertex>\n\t#include <skinbase_vertex>\n\t#ifdef USE_DISPLACEMENTMAP\n\t\t#include <beginnormal_vertex>\n\t\t#include <morphnormal_vertex>\n\t\t#include <skinnormal_vertex>\n\t#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvHighPrecisionZW = gl_Position.zw;\n}",depth_frag:"#if DEPTH_PACKING == 3200\n\tuniform float opacity;\n#endif\n#include <common>\n#include <packing>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvarying vec2 vHighPrecisionZW;\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( 1.0 );\n\t#if DEPTH_PACKING == 3200\n\t\tdiffuseColor.a = opacity;\n\t#endif\n\t#include <map_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <logdepthbuf_fragment>\n\tfloat fragCoordZ = 0.5 * vHighPrecisionZW[0] / vHighPrecisionZW[1] + 0.5;\n\t#if DEPTH_PACKING == 3200\n\t\tgl_FragColor = vec4( vec3( 1.0 - fragCoordZ ), opacity );\n\t#elif DEPTH_PACKING == 3201\n\t\tgl_FragColor = packDepthToRGBA( fragCoordZ );\n\t#endif\n}",distanceRGBA_vert:"#define DISTANCE\nvarying vec3 vWorldPosition;\n#include <common>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <skinbase_vertex>\n\t#ifdef USE_DISPLACEMENTMAP\n\t\t#include <beginnormal_vertex>\n\t\t#include <morphnormal_vertex>\n\t\t#include <skinnormal_vertex>\n\t#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <worldpos_vertex>\n\t#include <clipping_planes_vertex>\n\tvWorldPosition = worldPosition.xyz;\n}",distanceRGBA_frag:"#define DISTANCE\nuniform vec3 referencePosition;\nuniform float nearDistance;\nuniform float farDistance;\nvarying vec3 vWorldPosition;\n#include <common>\n#include <packing>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main () {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( 1.0 );\n\t#include <map_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\tfloat dist = length( vWorldPosition - referencePosition );\n\tdist = ( dist - nearDistance ) / ( farDistance - nearDistance );\n\tdist = saturate( dist );\n\tgl_FragColor = packDepthToRGBA( dist );\n}",equirect_vert:"varying vec3 vWorldDirection;\n#include <common>\nvoid main() {\n\tvWorldDirection = transformDirection( position, modelMatrix );\n\t#include <begin_vertex>\n\t#include <project_vertex>\n}",equirect_frag:"uniform sampler2D tEquirect;\nvarying vec3 vWorldDirection;\n#include <common>\nvoid main() {\n\tvec3 direction = normalize( vWorldDirection );\n\tvec2 sampleUV = equirectUv( direction );\n\tgl_FragColor = texture2D( tEquirect, sampleUV );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n}",linedashed_vert:"uniform float scale;\nattribute float lineDistance;\nvarying float vLineDistance;\n#include <common>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\tvLineDistance = scale * lineDistance;\n\t#include <color_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <fog_vertex>\n}",linedashed_frag:"uniform vec3 diffuse;\nuniform float opacity;\nuniform float dashSize;\nuniform float totalSize;\nvarying float vLineDistance;\n#include <common>\n#include <color_pars_fragment>\n#include <fog_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tif ( mod( vLineDistance, totalSize ) > dashSize ) {\n\t\tdiscard;\n\t}\n\tvec3 outgoingLight = vec3( 0.0 );\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <color_fragment>\n\toutgoingLight = diffuseColor.rgb;\n\t#include <output_fragment>\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n}",meshbasic_vert:"#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <envmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#if defined ( USE_ENVMAP ) || defined ( USE_SKINNING )\n\t\t#include <beginnormal_vertex>\n\t\t#include <morphnormal_vertex>\n\t\t#include <skinbase_vertex>\n\t\t#include <skinnormal_vertex>\n\t\t#include <defaultnormal_vertex>\n\t#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <worldpos_vertex>\n\t#include <envmap_vertex>\n\t#include <fog_vertex>\n}",meshbasic_frag:"uniform vec3 diffuse;\nuniform float opacity;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include <common>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <envmap_common_pars_fragment>\n#include <envmap_pars_fragment>\n#include <cube_uv_reflection_fragment>\n#include <fog_pars_fragment>\n#include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <specularmap_fragment>\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\t#ifdef USE_LIGHTMAP\n\t\tvec4 lightMapTexel= texture2D( lightMap, vUv2 );\n\t\treflectedLight.indirectDiffuse += lightMapTexel.rgb * lightMapIntensity;\n\t#else\n\t\treflectedLight.indirectDiffuse += vec3( 1.0 );\n\t#endif\n\t#include <aomap_fragment>\n\treflectedLight.indirectDiffuse *= diffuseColor.rgb;\n\tvec3 outgoingLight = reflectedLight.indirectDiffuse;\n\t#include <envmap_fragment>\n\t#include <output_fragment>\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}",meshlambert_vert:"#define LAMBERT\nvarying vec3 vLightFront;\nvarying vec3 vIndirectFront;\n#ifdef DOUBLE_SIDED\n\tvarying vec3 vLightBack;\n\tvarying vec3 vIndirectBack;\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <envmap_pars_vertex>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <worldpos_vertex>\n\t#include <envmap_vertex>\n\t#include <lights_lambert_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}",meshlambert_frag:"uniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float opacity;\nvarying vec3 vLightFront;\nvarying vec3 vIndirectFront;\n#ifdef DOUBLE_SIDED\n\tvarying vec3 vLightBack;\n\tvarying vec3 vIndirectBack;\n#endif\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <envmap_common_pars_fragment>\n#include <envmap_pars_fragment>\n#include <cube_uv_reflection_fragment>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <fog_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <shadowmask_pars_fragment>\n#include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <specularmap_fragment>\n\t#include <emissivemap_fragment>\n\t#ifdef DOUBLE_SIDED\n\t\treflectedLight.indirectDiffuse += ( gl_FrontFacing ) ? vIndirectFront : vIndirectBack;\n\t#else\n\t\treflectedLight.indirectDiffuse += vIndirectFront;\n\t#endif\n\t#include <lightmap_fragment>\n\treflectedLight.indirectDiffuse *= BRDF_Lambert( diffuseColor.rgb );\n\t#ifdef DOUBLE_SIDED\n\t\treflectedLight.directDiffuse = ( gl_FrontFacing ) ? vLightFront : vLightBack;\n\t#else\n\t\treflectedLight.directDiffuse = vLightFront;\n\t#endif\n\treflectedLight.directDiffuse *= BRDF_Lambert( diffuseColor.rgb ) * getShadowMask();\n\t#include <aomap_fragment>\n\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;\n\t#include <envmap_fragment>\n\t#include <output_fragment>\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}",meshmatcap_vert:"#define MATCAP\nvarying vec3 vViewPosition;\n#include <common>\n#include <uv_pars_vertex>\n#include <color_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <fog_pars_vertex>\n#include <normal_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <color_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <normal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <fog_vertex>\n\tvViewPosition = - mvPosition.xyz;\n}",meshmatcap_frag:"#define MATCAP\nuniform vec3 diffuse;\nuniform float opacity;\nuniform sampler2D matcap;\nvarying vec3 vViewPosition;\n#include <common>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <fog_pars_fragment>\n#include <normal_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\tvec3 viewDir = normalize( vViewPosition );\n\tvec3 x = normalize( vec3( viewDir.z, 0.0, - viewDir.x ) );\n\tvec3 y = cross( viewDir, x );\n\tvec2 uv = vec2( dot( x, normal ), dot( y, normal ) ) * 0.495 + 0.5;\n\t#ifdef USE_MATCAP\n\t\tvec4 matcapColor = texture2D( matcap, uv );\n\t#else\n\t\tvec4 matcapColor = vec4( vec3( mix( 0.2, 0.8, uv.y ) ), 1.0 );\n\t#endif\n\tvec3 outgoingLight = diffuseColor.rgb * matcapColor.rgb;\n\t#include <output_fragment>\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}",meshnormal_vert:"#define NORMAL\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )\n\tvarying vec3 vViewPosition;\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <normal_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <normal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )\n\tvViewPosition = - mvPosition.xyz;\n#endif\n}",meshnormal_frag:"#define NORMAL\nuniform float opacity;\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )\n\tvarying vec3 vViewPosition;\n#endif\n#include <packing>\n#include <uv_pars_fragment>\n#include <normal_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\t#include <logdepthbuf_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\tgl_FragColor = vec4( packNormalToRGB( normal ), opacity );\n}",meshphong_vert:"#define PHONG\nvarying vec3 vViewPosition;\n#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <envmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <normal_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <normal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvViewPosition = - mvPosition.xyz;\n\t#include <worldpos_vertex>\n\t#include <envmap_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}",meshphong_frag:"#define PHONG\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform vec3 specular;\nuniform float shininess;\nuniform float opacity;\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <envmap_common_pars_fragment>\n#include <envmap_pars_fragment>\n#include <cube_uv_reflection_fragment>\n#include <fog_pars_fragment>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <normal_pars_fragment>\n#include <lights_phong_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <specularmap_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\t#include <emissivemap_fragment>\n\t#include <lights_phong_fragment>\n\t#include <lights_fragment_begin>\n\t#include <lights_fragment_maps>\n\t#include <lights_fragment_end>\n\t#include <aomap_fragment>\n\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance;\n\t#include <envmap_fragment>\n\t#include <output_fragment>\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}",meshphysical_vert:"#define STANDARD\nvarying vec3 vViewPosition;\n#ifdef USE_TRANSMISSION\n\tvarying vec3 vWorldPosition;\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <normal_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <normal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvViewPosition = - mvPosition.xyz;\n\t#include <worldpos_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n#ifdef USE_TRANSMISSION\n\tvWorldPosition = worldPosition.xyz;\n#endif\n}",meshphysical_frag:"#define STANDARD\n#ifdef PHYSICAL\n\t#define IOR\n\t#define SPECULAR\n#endif\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float roughness;\nuniform float metalness;\nuniform float opacity;\n#ifdef IOR\n\tuniform float ior;\n#endif\n#ifdef SPECULAR\n\tuniform float specularIntensity;\n\tuniform vec3 specularColor;\n\t#ifdef USE_SPECULARINTENSITYMAP\n\t\tuniform sampler2D specularIntensityMap;\n\t#endif\n\t#ifdef USE_SPECULARCOLORMAP\n\t\tuniform sampler2D specularColorMap;\n\t#endif\n#endif\n#ifdef USE_CLEARCOAT\n\tuniform float clearcoat;\n\tuniform float clearcoatRoughness;\n#endif\n#ifdef USE_SHEEN\n\tuniform vec3 sheenColor;\n\tuniform float sheenRoughness;\n\t#ifdef USE_SHEENCOLORMAP\n\t\tuniform sampler2D sheenColorMap;\n\t#endif\n\t#ifdef USE_SHEENROUGHNESSMAP\n\t\tuniform sampler2D sheenRoughnessMap;\n\t#endif\n#endif\nvarying vec3 vViewPosition;\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <bsdfs>\n#include <cube_uv_reflection_fragment>\n#include <envmap_common_pars_fragment>\n#include <envmap_physical_pars_fragment>\n#include <fog_pars_fragment>\n#include <lights_pars_begin>\n#include <normal_pars_fragment>\n#include <lights_physical_pars_fragment>\n#include <transmission_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <clearcoat_pars_fragment>\n#include <roughnessmap_pars_fragment>\n#include <metalnessmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <roughnessmap_fragment>\n\t#include <metalnessmap_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\t#include <clearcoat_normal_fragment_begin>\n\t#include <clearcoat_normal_fragment_maps>\n\t#include <emissivemap_fragment>\n\t#include <lights_physical_fragment>\n\t#include <lights_fragment_begin>\n\t#include <lights_fragment_maps>\n\t#include <lights_fragment_end>\n\t#include <aomap_fragment>\n\tvec3 totalDiffuse = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse;\n\tvec3 totalSpecular = reflectedLight.directSpecular + reflectedLight.indirectSpecular;\n\t#include <transmission_fragment>\n\tvec3 outgoingLight = totalDiffuse + totalSpecular + totalEmissiveRadiance;\n\t#ifdef USE_SHEEN\n\t\tfloat sheenEnergyComp = 1.0 - 0.157 * max3( material.sheenColor );\n\t\toutgoingLight = outgoingLight * sheenEnergyComp + sheenSpecular;\n\t#endif\n\t#ifdef USE_CLEARCOAT\n\t\tfloat dotNVcc = saturate( dot( geometry.clearcoatNormal, geometry.viewDir ) );\n\t\tvec3 Fcc = F_Schlick( material.clearcoatF0, material.clearcoatF90, dotNVcc );\n\t\toutgoingLight = outgoingLight * ( 1.0 - material.clearcoat * Fcc ) + clearcoatSpecular * material.clearcoat;\n\t#endif\n\t#include <output_fragment>\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}",meshtoon_vert:"#define TOON\nvarying vec3 vViewPosition;\n#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <normal_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <normal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvViewPosition = - mvPosition.xyz;\n\t#include <worldpos_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}",meshtoon_frag:"#define TOON\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float opacity;\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <gradientmap_pars_fragment>\n#include <fog_pars_fragment>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <normal_pars_fragment>\n#include <lights_toon_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\t#include <emissivemap_fragment>\n\t#include <lights_toon_fragment>\n\t#include <lights_fragment_begin>\n\t#include <lights_fragment_maps>\n\t#include <lights_fragment_end>\n\t#include <aomap_fragment>\n\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;\n\t#include <output_fragment>\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}",points_vert:"uniform float size;\nuniform float scale;\n#include <common>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <color_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <project_vertex>\n\tgl_PointSize = size;\n\t#ifdef USE_SIZEATTENUATION\n\t\tbool isPerspective = isPerspectiveMatrix( projectionMatrix );\n\t\tif ( isPerspective ) gl_PointSize *= ( scale / - mvPosition.z );\n\t#endif\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <worldpos_vertex>\n\t#include <fog_vertex>\n}",points_frag:"uniform vec3 diffuse;\nuniform float opacity;\n#include <common>\n#include <color_pars_fragment>\n#include <map_particle_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <fog_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec3 outgoingLight = vec3( 0.0 );\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <map_particle_fragment>\n\t#include <color_fragment>\n\t#include <alphatest_fragment>\n\toutgoingLight = diffuseColor.rgb;\n\t#include <output_fragment>\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n}",shadow_vert:"#include <common>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\nvoid main() {\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <project_vertex>\n\t#include <worldpos_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}",shadow_frag:"uniform vec3 color;\nuniform float opacity;\n#include <common>\n#include <packing>\n#include <fog_pars_fragment>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <shadowmap_pars_fragment>\n#include <shadowmask_pars_fragment>\nvoid main() {\n\tgl_FragColor = vec4( color, opacity * ( 1.0 - getShadowMask() ) );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n}",sprite_vert:"uniform float rotation;\nuniform vec2 center;\n#include <common>\n#include <uv_pars_vertex>\n#include <fog_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\tvec4 mvPosition = modelViewMatrix * vec4( 0.0, 0.0, 0.0, 1.0 );\n\tvec2 scale;\n\tscale.x = length( vec3( modelMatrix[ 0 ].x, modelMatrix[ 0 ].y, modelMatrix[ 0 ].z ) );\n\tscale.y = length( vec3( modelMatrix[ 1 ].x, modelMatrix[ 1 ].y, modelMatrix[ 1 ].z ) );\n\t#ifndef USE_SIZEATTENUATION\n\t\tbool isPerspective = isPerspectiveMatrix( projectionMatrix );\n\t\tif ( isPerspective ) scale *= - mvPosition.z;\n\t#endif\n\tvec2 alignedPosition = ( position.xy - ( center - vec2( 0.5 ) ) ) * scale;\n\tvec2 rotatedPosition;\n\trotatedPosition.x = cos( rotation ) * alignedPosition.x - sin( rotation ) * alignedPosition.y;\n\trotatedPosition.y = sin( rotation ) * alignedPosition.x + cos( rotation ) * alignedPosition.y;\n\tmvPosition.xy += rotatedPosition;\n\tgl_Position = projectionMatrix * mvPosition;\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <fog_vertex>\n}",sprite_frag:"uniform vec3 diffuse;\nuniform float opacity;\n#include <common>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <fog_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec3 outgoingLight = vec3( 0.0 );\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\toutgoingLight = diffuseColor.rgb;\n\t#include <output_fragment>\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n}"},Pt={common:{diffuse:{value:new an(16777215)},opacity:{value:1},map:{value:null},uvTransform:{value:new vo},uv2Transform:{value:new vo},alphaMap:{value:null},alphaTest:{value:0}},specularmap:{specularMap:{value:null}},envmap:{envMap:{value:null},flipEnvMap:{value:-1},reflectivity:{value:1},ior:{value:1.5},refractionRatio:{value:.98}},aomap:{aoMap:{value:null},aoMapIntensity:{value:1}},lightmap:{lightMap:{value:null},lightMapIntensity:{value:1}},emissivemap:{emissiveMap:{value:null}},bumpmap:{bumpMap:{value:null},bumpScale:{value:1}},normalmap:{normalMap:{value:null},normalScale:{value:new $e(1,1)}},displacementmap:{displacementMap:{value:null},displacementScale:{value:1},displacementBias:{value:0}},roughnessmap:{roughnessMap:{value:null}},metalnessmap:{metalnessMap:{value:null}},gradientmap:{gradientMap:{value:null}},fog:{fogDensity:{value:25e-5},fogNear:{value:1},fogFar:{value:2e3},fogColor:{value:new an(16777215)}},lights:{ambientLightColor:{value:[]},lightProbe:{value:[]},directionalLights:{value:[],properties:{direction:{},color:{}}},directionalLightShadows:{value:[],properties:{shadowBias:{},shadowNormalBias:{},shadowRadius:{},shadowMapSize:{}}},directionalShadowMap:{value:[]},directionalShadowMatrix:{value:[]},spotLights:{value:[],properties:{color:{},position:{},direction:{},distance:{},coneCos:{},penumbraCos:{},decay:{}}},spotLightShadows:{value:[],properties:{shadowBias:{},shadowNormalBias:{},shadowRadius:{},shadowMapSize:{}}},spotShadowMap:{value:[]},spotShadowMatrix:{value:[]},pointLights:{value:[],properties:{color:{},position:{},decay:{},distance:{}}},pointLightShadows:{value:[],properties:{shadowBias:{},shadowNormalBias:{},shadowRadius:{},shadowMapSize:{},shadowCameraNear:{},shadowCameraFar:{}}},pointShadowMap:{value:[]},pointShadowMatrix:{value:[]},hemisphereLights:{value:[],properties:{direction:{},skyColor:{},groundColor:{}}},rectAreaLights:{value:[],properties:{color:{},position:{},width:{},height:{}}},ltc_1:{value:null},ltc_2:{value:null}},points:{diffuse:{value:new an(16777215)},opacity:{value:1},size:{value:1},scale:{value:1},map:{value:null},alphaMap:{value:null},alphaTest:{value:0},uvTransform:{value:new vo}},sprite:{diffuse:{value:new an(16777215)},opacity:{value:1},center:{value:new $e(.5,.5)},rotation:{value:0},map:{value:null},alphaMap:{value:null},alphaTest:{value:0},uvTransform:{value:new vo}}},jc={basic:{uniforms:ia([Pt.common,Pt.specularmap,Pt.envmap,Pt.aomap,Pt.lightmap,Pt.fog]),vertexShader:vi.meshbasic_vert,fragmentShader:vi.meshbasic_frag},lambert:{uniforms:ia([Pt.common,Pt.specularmap,Pt.envmap,Pt.aomap,Pt.lightmap,Pt.emissivemap,Pt.fog,Pt.lights,{emissive:{value:new an(0)}}]),vertexShader:vi.meshlambert_vert,fragmentShader:vi.meshlambert_frag},phong:{uniforms:ia([Pt.common,Pt.specularmap,Pt.envmap,Pt.aomap,Pt.lightmap,Pt.emissivemap,Pt.bumpmap,Pt.normalmap,Pt.displacementmap,Pt.fog,Pt.lights,{emissive:{value:new an(0)},specular:{value:new an(1118481)},shininess:{value:30}}]),vertexShader:vi.meshphong_vert,fragmentShader:vi.meshphong_frag},standard:{uniforms:ia([Pt.common,Pt.envmap,Pt.aomap,Pt.lightmap,Pt.emissivemap,Pt.bumpmap,Pt.normalmap,Pt.displacementmap,Pt.roughnessmap,Pt.metalnessmap,Pt.fog,Pt.lights,{emissive:{value:new an(0)},roughness:{value:1},metalness:{value:0},envMapIntensity:{value:1}}]),vertexShader:vi.meshphysical_vert,fragmentShader:vi.meshphysical_frag},toon:{uniforms:ia([Pt.common,Pt.aomap,Pt.lightmap,Pt.emissivemap,Pt.bumpmap,Pt.normalmap,Pt.displacementmap,Pt.gradientmap,Pt.fog,Pt.lights,{emissive:{value:new an(0)}}]),vertexShader:vi.meshtoon_vert,fragmentShader:vi.meshtoon_frag},matcap:{uniforms:ia([Pt.common,Pt.bumpmap,Pt.normalmap,Pt.displacementmap,Pt.fog,{matcap:{value:null}}]),vertexShader:vi.meshmatcap_vert,fragmentShader:vi.meshmatcap_frag},points:{uniforms:ia([Pt.points,Pt.fog]),vertexShader:vi.points_vert,fragmentShader:vi.points_frag},dashed:{uniforms:ia([Pt.common,Pt.fog,{scale:{value:1},dashSize:{value:1},totalSize:{value:2}}]),vertexShader:vi.linedashed_vert,fragmentShader:vi.linedashed_frag},depth:{uniforms:ia([Pt.common,Pt.displacementmap]),vertexShader:vi.depth_vert,fragmentShader:vi.depth_frag},normal:{uniforms:ia([Pt.common,Pt.bumpmap,Pt.normalmap,Pt.displacementmap,{opacity:{value:1}}]),vertexShader:vi.meshnormal_vert,fragmentShader:vi.meshnormal_frag},sprite:{uniforms:ia([Pt.sprite,Pt.fog]),vertexShader:vi.sprite_vert,fragmentShader:vi.sprite_frag},background:{uniforms:{uvTransform:{value:new vo},t2D:{value:null}},vertexShader:vi.background_vert,fragmentShader:vi.background_frag},cube:{uniforms:ia([Pt.envmap,{opacity:{value:1}}]),vertexShader:vi.cube_vert,fragmentShader:vi.cube_frag},equirect:{uniforms:{tEquirect:{value:null}},vertexShader:vi.equirect_vert,fragmentShader:vi.equirect_frag},distanceRGBA:{uniforms:ia([Pt.common,Pt.displacementmap,{referencePosition:{value:new $},nearDistance:{value:1},farDistance:{value:1e3}}]),vertexShader:vi.distanceRGBA_vert,fragmentShader:vi.distanceRGBA_frag},shadow:{uniforms:ia([Pt.lights,Pt.fog,{color:{value:new an(0)},opacity:{value:1}}]),vertexShader:vi.shadow_vert,fragmentShader:vi.shadow_frag}};function GPe(n,t,e,i,r,o){let l,c,a=new an(0),s=!0===r?0:1,d=null,u=0,p=null;function m(y,M){e.buffers.color.setClear(y.r,y.g,y.b,M,o)}return{getClearColor:function(){return a},setClearColor:function(y,M=1){a.set(y),s=M,m(a,s)},getClearAlpha:function(){return s},setClearAlpha:function(y){s=y,m(a,s)},render:function(y,M){let v=!1,x=!0===M.isScene?M.background:null;x&&x.isTexture&&(x=t.get(x));let R=n.xr,A=R.getSession&&R.getSession();A&&"additive"===A.environmentBlendMode&&(x=null),null===x?m(a,s):x&&x.isColor&&(m(x,1),v=!0),(n.autoClear||v)&&n.clear(n.autoClearColor,n.autoClearDepth,n.autoClearStencil),x&&(x.isCubeTexture||x.mapping===$I)?(void 0===c&&(c=new co(new Em(1,1,1),new Gd({name:"BackgroundCubeMaterial",uniforms:s_(jc.cube.uniforms),vertexShader:jc.cube.vertexShader,fragmentShader:jc.cube.fragmentShader,side:yo,depthTest:!1,depthWrite:!1,fog:!1})),c.geometry.deleteAttribute("normal"),c.geometry.deleteAttribute("uv"),c.onBeforeRender=function(H,te,K){this.matrixWorld.copyPosition(K.matrixWorld)},Object.defineProperty(c.material,"envMap",{get:function(){return this.uniforms.envMap.value}}),i.update(c)),c.material.uniforms.envMap.value=x,c.material.uniforms.flipEnvMap.value=x.isCubeTexture&&!1===x.isRenderTargetTexture?-1:1,(d!==x||u!==x.version||p!==n.toneMapping)&&(c.material.needsUpdate=!0,d=x,u=x.version,p=n.toneMapping),y.unshift(c,c.geometry,c.material,0,0,null)):x&&x.isTexture&&(void 0===l&&(l=new co(new kx(2,2),new Gd({name:"BackgroundMaterial",uniforms:s_(jc.background.uniforms),vertexShader:jc.background.vertexShader,fragmentShader:jc.background.fragmentShader,side:Sx,depthTest:!1,depthWrite:!1,fog:!1})),l.geometry.deleteAttribute("normal"),Object.defineProperty(l.material,"map",{get:function(){return this.uniforms.t2D.value}}),i.update(l)),l.material.uniforms.t2D.value=x,!0===x.matrixAutoUpdate&&x.updateMatrix(),l.material.uniforms.uvTransform.value.copy(x.matrix),(d!==x||u!==x.version||p!==n.toneMapping)&&(l.material.needsUpdate=!0,d=x,u=x.version,p=n.toneMapping),y.unshift(l,l.geometry,l.material,0,0,null))}}}function WPe(n,t,e,i){let r=n.getParameter(34921),o=i.isWebGL2?null:t.get("OES_vertex_array_object"),a=i.isWebGL2||null!==o,s={},l=y(null),c=l;function p(ce){return i.isWebGL2?n.bindVertexArray(ce):o.bindVertexArrayOES(ce)}function f(ce){return i.isWebGL2?n.deleteVertexArray(ce):o.deleteVertexArrayOES(ce)}function y(ce){let fe=[],_e=[],ne=[];for(let de=0;de<r;de++)fe[de]=0,_e[de]=0,ne[de]=0;return{geometry:null,program:null,wireframe:!1,newAttributes:fe,enabledAttributes:_e,attributeDivisors:ne,object:ce,attributes:{},index:null}}function x(){let ce=c.newAttributes;for(let fe=0,_e=ce.length;fe<_e;fe++)ce[fe]=0}function R(ce){A(ce,0)}function A(ce,fe){let ne=c.enabledAttributes,de=c.attributeDivisors;c.newAttributes[ce]=1,0===ne[ce]&&(n.enableVertexAttribArray(ce),ne[ce]=1),de[ce]!==fe&&((i.isWebGL2?n:t.get("ANGLE_instanced_arrays"))[i.isWebGL2?"vertexAttribDivisor":"vertexAttribDivisorANGLE"](ce,fe),de[ce]=fe)}function H(){let ce=c.newAttributes,fe=c.enabledAttributes;for(let _e=0,ne=fe.length;_e<ne;_e++)fe[_e]!==ce[_e]&&(n.disableVertexAttribArray(_e),fe[_e]=0)}function te(ce,fe,_e,ne,de,ue){!0!==i.isWebGL2||5124!==_e&&5125!==_e?n.vertexAttribPointer(ce,fe,_e,ne,de,ue):n.vertexAttribIPointer(ce,fe,_e,de,ue)}function I(){re(),c!==l&&(c=l,p(c.object))}function re(){l.geometry=null,l.program=null,l.wireframe=!1}return{setup:function(ce,fe,_e,ne,de){let ue=!1;if(a){let Ge=function(ce,fe,_e){let ne=!0===_e.wireframe,de=s[ce.id];void 0===de&&(de={},s[ce.id]=de);let ue=de[fe.id];void 0===ue&&(ue={},de[fe.id]=ue);let Ge=ue[ne];return void 0===Ge&&(Ge=y(i.isWebGL2?n.createVertexArray():o.createVertexArrayOES()),ue[ne]=Ge),Ge}(ne,_e,fe);c!==Ge&&(c=Ge,p(c.object)),ue=function(ce,fe){let _e=c.attributes,ne=ce.attributes,de=0;for(let ue in ne){let Ge=_e[ue],Me=ne[ue];if(void 0===Ge||Ge.attribute!==Me||Ge.data!==Me.data)return!0;de++}return c.attributesNum!==de||c.index!==fe}(ne,de),ue&&function(ce,fe){let _e={},ne=ce.attributes,de=0;for(let ue in ne){let Ge=ne[ue],Me={};Me.attribute=Ge,Ge.data&&(Me.data=Ge.data),_e[ue]=Me,de++}c.attributes=_e,c.attributesNum=de,c.index=fe}(ne,de)}else{let Ge=!0===fe.wireframe;(c.geometry!==ne.id||c.program!==_e.id||c.wireframe!==Ge)&&(c.geometry=ne.id,c.program=_e.id,c.wireframe=Ge,ue=!0)}!0===ce.isInstancedMesh&&(ue=!0),null!==de&&e.update(de,34963),ue&&(function(ce,fe,_e,ne){if(!1===i.isWebGL2&&(ce.isInstancedMesh||ne.isInstancedBufferGeometry)&&null===t.get("ANGLE_instanced_arrays"))return;x();let de=ne.attributes,ue=_e.getAttributes(),Ge=fe.defaultAttributeValues;for(let Me in ue){let Ne=ue[Me];if(Ne.location>=0){let ct=de[Me];if(void 0===ct&&("instanceMatrix"===Me&&ce.instanceMatrix&&(ct=ce.instanceMatrix),"instanceColor"===Me&&ce.instanceColor&&(ct=ce.instanceColor)),void 0!==ct){let wt=ct.normalized,ft=ct.itemSize,Oe=e.get(ct);if(void 0===Oe)continue;let An=Oe.buffer,St=Oe.type,rn=Oe.bytesPerElement;if(ct.isInterleavedBufferAttribute){let ve=ct.data,ht=ve.stride,mt=ct.offset;if(ve&&ve.isInstancedInterleavedBuffer){for(let oe=0;oe<Ne.locationSize;oe++)A(Ne.location+oe,ve.meshPerAttribute);!0!==ce.isInstancedMesh&&void 0===ne._maxInstanceCount&&(ne._maxInstanceCount=ve.meshPerAttribute*ve.count)}else for(let oe=0;oe<Ne.locationSize;oe++)R(Ne.location+oe);n.bindBuffer(34962,An);for(let oe=0;oe<Ne.locationSize;oe++)te(Ne.location+oe,ft/Ne.locationSize,St,wt,ht*rn,(mt+ft/Ne.locationSize*oe)*rn)}else{if(ct.isInstancedBufferAttribute){for(let ve=0;ve<Ne.locationSize;ve++)A(Ne.location+ve,ct.meshPerAttribute);!0!==ce.isInstancedMesh&&void 0===ne._maxInstanceCount&&(ne._maxInstanceCount=ct.meshPerAttribute*ct.count)}else for(let ve=0;ve<Ne.locationSize;ve++)R(Ne.location+ve);n.bindBuffer(34962,An);for(let ve=0;ve<Ne.locationSize;ve++)te(Ne.location+ve,ft/Ne.locationSize,St,wt,ft*rn,ft/Ne.locationSize*ve*rn)}}else if(void 0!==Ge){let wt=Ge[Me];if(void 0!==wt)switch(wt.length){case 2:n.vertexAttrib2fv(Ne.location,wt);break;case 3:n.vertexAttrib3fv(Ne.location,wt);break;case 4:n.vertexAttrib4fv(Ne.location,wt);break;default:n.vertexAttrib1fv(Ne.location,wt)}}}}H()}(ce,fe,_e,ne),null!==de&&n.bindBuffer(34963,e.get(de).buffer))},reset:I,resetDefaultState:re,dispose:function(){I();for(let ce in s){let fe=s[ce];for(let _e in fe){let ne=fe[_e];for(let de in ne)f(ne[de].object),delete ne[de];delete fe[_e]}delete s[ce]}},releaseStatesOfGeometry:function(ce){if(void 0===s[ce.id])return;let fe=s[ce.id];for(let _e in fe){let ne=fe[_e];for(let de in ne)f(ne[de].object),delete ne[de];delete fe[_e]}delete s[ce.id]},releaseStatesOfProgram:function(ce){for(let fe in s){let _e=s[fe];if(void 0===_e[ce.id])continue;let ne=_e[ce.id];for(let de in ne)f(ne[de].object),delete ne[de];delete _e[ce.id]}},initAttributes:x,enableAttribute:R,disableUnusedAttributes:H}}function qPe(n,t,e,i){let o,r=i.isWebGL2;this.setMode=function(c){o=c},this.render=function(c,d){n.drawArrays(o,c,d),e.update(d,o,1)},this.renderInstances=function(c,d,u){if(0===u)return;let p,f;if(r)p=n,f="drawArraysInstanced";else if(p=t.get("ANGLE_instanced_arrays"),f="drawArraysInstancedANGLE",null===p)return void console.error("THREE.WebGLBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.");p[f](o,c,d,u),e.update(d,o,u)}}function YPe(n,t,e){let i;function o(K){if("highp"===K){if(n.getShaderPrecisionFormat(35633,36338).precision>0&&n.getShaderPrecisionFormat(35632,36338).precision>0)return"highp";K="mediump"}return"mediump"===K&&n.getShaderPrecisionFormat(35633,36337).precision>0&&n.getShaderPrecisionFormat(35632,36337).precision>0?"mediump":"lowp"}let a=typeof WebGL2RenderingContext<"u"&&n instanceof WebGL2RenderingContext||typeof WebGL2ComputeRenderingContext<"u"&&n instanceof WebGL2ComputeRenderingContext,s=void 0!==e.precision?e.precision:"highp",l=o(s);l!==s&&(console.warn("THREE.WebGLRenderer:",s,"not supported, using",l,"instead."),s=l);let c=a||t.has("WEBGL_draw_buffers"),d=!0===e.logarithmicDepthBuffer,u=n.getParameter(34930),p=n.getParameter(35660),f=n.getParameter(3379),m=n.getParameter(34076),y=n.getParameter(34921),M=n.getParameter(36347),v=n.getParameter(36348),x=n.getParameter(36349),R=p>0,A=a||t.has("OES_texture_float");return{isWebGL2:a,drawBuffers:c,getMaxAnisotropy:function(){if(void 0!==i)return i;if(!0===t.has("EXT_texture_filter_anisotropic")){let K=t.get("EXT_texture_filter_anisotropic");i=n.getParameter(K.MAX_TEXTURE_MAX_ANISOTROPY_EXT)}else i=0;return i},getMaxPrecision:o,precision:s,logarithmicDepthBuffer:d,maxTextures:u,maxVertexTextures:p,maxTextureSize:f,maxCubemapSize:m,maxAttributes:y,maxVertexUniforms:M,maxVaryings:v,maxFragmentUniforms:x,vertexTextures:R,floatFragmentTextures:A,floatVertexTextures:R&&A,maxSamples:a?n.getParameter(36183):0}}function XPe(n){let t=this,e=null,i=0,r=!1,o=!1,a=new Xl,s=new vo,l={value:null,needsUpdate:!1};function c(){l.value!==e&&(l.value=e,l.needsUpdate=i>0),t.numPlanes=i,t.numIntersection=0}function d(u,p,f,m){let y=null!==u?u.length:0,M=null;if(0!==y){if(M=l.value,!0!==m||null===M){let v=f+4*y,x=p.matrixWorldInverse;s.getNormalMatrix(x),(null===M||M.length<v)&&(M=new Float32Array(v));for(let R=0,A=f;R!==y;++R,A+=4)a.copy(u[R]).applyMatrix4(x,s),a.normal.toArray(M,A),M[A+3]=a.constant}l.value=M,l.needsUpdate=!0}return t.numPlanes=y,t.numIntersection=0,M}this.uniform=l,this.numPlanes=0,this.numIntersection=0,this.init=function(u,p,f){let m=0!==u.length||p||0!==i||r;return r=p,e=d(u,f,0),i=u.length,m},this.beginShadows=function(){o=!0,d(null)},this.endShadows=function(){o=!1,c()},this.setState=function(u,p,f){let m=u.clippingPlanes,y=u.clipIntersection,M=u.clipShadows,v=n.get(u);if(!r||null===m||0===m.length||o&&!M)o?d(null):c();else{let x=o?0:i,R=4*x,A=v.clippingState||null;l.value=A,A=d(m,p,R,f);for(let H=0;H!==R;++H)A[H]=e[H];v.clippingState=A,this.numIntersection=y?this.numPlanes:0,this.numPlanes+=x}}}function QPe(n){let t=new WeakMap;function e(a,s){return s===xB?a.mapping=Zx:s===CB&&(a.mapping=Kx),a}function r(a){let s=a.target;s.removeEventListener("dispose",r);let l=t.get(s);void 0!==l&&(t.delete(s),l.dispose())}return{get:function(a){if(a&&a.isTexture&&!1===a.isRenderTargetTexture){let s=a.mapping;if(s===xB||s===CB){if(t.has(a))return e(t.get(a).texture,a.mapping);{let l=a.image;if(l&&l.height>0){let c=new AI(l.height/2);return c.fromEquirectangularTexture(n,a),t.set(a,c),a.addEventListener("dispose",r),e(c.texture,a.mapping)}return null}}}return a},dispose:function(){t=new WeakMap}}}jc.physical={uniforms:ia([jc.standard.uniforms,{clearcoat:{value:0},clearcoatMap:{value:null},clearcoatRoughness:{value:0},clearcoatRoughnessMap:{value:null},clearcoatNormalScale:{value:new $e(1,1)},clearcoatNormalMap:{value:null},sheen:{value:0},sheenColor:{value:new an(0)},sheenColorMap:{value:null},sheenRoughness:{value:1},sheenRoughnessMap:{value:null},transmission:{value:0},transmissionMap:{value:null},transmissionSamplerSize:{value:new $e},transmissionSamplerMap:{value:null},thickness:{value:0},thicknessMap:{value:null},attenuationDistance:{value:0},attenuationColor:{value:new an(0)},specularIntensity:{value:1},specularIntensityMap:{value:null},specularColor:{value:new an(1,1,1)},specularColorMap:{value:null}}]),vertexShader:vi.meshphysical_vert,fragmentShader:vi.meshphysical_frag};var Tm=class extends Ax{constructor(t=-1,e=1,i=1,r=-1,o=.1,a=2e3){super(),this.type="OrthographicCamera",this.zoom=1,this.view=null,this.left=t,this.right=e,this.top=i,this.bottom=r,this.near=o,this.far=a,this.updateProjectionMatrix()}copy(t,e){return super.copy(t,e),this.left=t.left,this.right=t.right,this.top=t.top,this.bottom=t.bottom,this.near=t.near,this.far=t.far,this.zoom=t.zoom,this.view=null===t.view?null:Object.assign({},t.view),this}setViewOffset(t,e,i,r,o,a){null===this.view&&(this.view={enabled:!0,fullWidth:1,fullHeight:1,offsetX:0,offsetY:0,width:1,height:1}),this.view.enabled=!0,this.view.fullWidth=t,this.view.fullHeight=e,this.view.offsetX=i,this.view.offsetY=r,this.view.width=o,this.view.height=a,this.updateProjectionMatrix()}clearViewOffset(){null!==this.view&&(this.view.enabled=!1),this.updateProjectionMatrix()}updateProjectionMatrix(){let t=(this.right-this.left)/(2*this.zoom),e=(this.top-this.bottom)/(2*this.zoom),i=(this.right+this.left)/2,r=(this.top+this.bottom)/2,o=i-t,a=i+t,s=r+e,l=r-e;if(null!==this.view&&this.view.enabled){let c=(this.right-this.left)/this.view.fullWidth/this.zoom,d=(this.top-this.bottom)/this.view.fullHeight/this.zoom;o+=c*this.view.offsetX,a=o+c*this.view.width,s-=d*this.view.offsetY,l=s-d*this.view.height}this.projectionMatrix.makeOrthographic(o,a,s,l,this.near,this.far),this.projectionMatrixInverse.copy(this.projectionMatrix).invert()}toJSON(t){let e=super.toJSON(t);return e.object.zoom=this.zoom,e.object.left=this.left,e.object.right=this.right,e.object.top=this.top,e.object.bottom=this.bottom,e.object.near=this.near,e.object.far=this.far,null!==this.view&&(e.object.view=Object.assign({},this.view)),e}};Tm.prototype.isOrthographicCamera=!0;var d_=class extends Gd{constructor(t){super(t),this.type="RawShaderMaterial"}};d_.prototype.isRawShaderMaterial=!0;var r_=4,xp=8,Uc=Math.pow(2,xp),gte=[.125,.215,.35,.446,.526,.582],_te=xp-r_+1+gte.length,dB=new Tm,{_lodPlanes:fx,_sizeLods:hee,_sigmas:sI}=ZPe(),gee=new an,uB=null,xm=(1+Math.sqrt(5))/2,q0=1/xm,_ee=[new $(1,1,1),new $(-1,1,1),new $(1,1,-1),new $(-1,1,-1),new $(0,xm,q0),new $(0,xm,-q0),new $(q0,0,xm),new $(-q0,0,xm),new $(xm,q0,0),new $(-xm,q0,0)],RI=class{constructor(t){this._renderer=t,this._pingPongRenderTarget=null,this._blurMaterial=function(n){let t=new Float32Array(20),e=new $(0,1,0);return new d_({name:"SphericalGaussianBlur",defines:{n:20},uniforms:{envMap:{value:null},samples:{value:1},weights:{value:t},latitudinal:{value:!1},dTheta:{value:0},mipInt:{value:0},poleAxis:{value:e}},vertexShader:"\n\n\t\tprecision mediump float;\n\t\tprecision mediump int;\n\n\t\tattribute vec3 position;\n\t\tattribute vec2 uv;\n\t\tattribute float faceIndex;\n\n\t\tvarying vec3 vOutputDirection;\n\n\t\t// RH coordinate system; PMREM face-indexing convention\n\t\tvec3 getDirection( vec2 uv, float face ) {\n\n\t\t\tuv = 2.0 * uv - 1.0;\n\n\t\t\tvec3 direction = vec3( uv, 1.0 );\n\n\t\t\tif ( face == 0.0 ) {\n\n\t\t\t\tdirection = direction.zyx; // ( 1, v, u ) pos x\n\n\t\t\t} else if ( face == 1.0 ) {\n\n\t\t\t\tdirection = direction.xzy;\n\t\t\t\tdirection.xz *= -1.0; // ( -u, 1, -v ) pos y\n\n\t\t\t} else if ( face == 2.0 ) {\n\n\t\t\t\tdirection.x *= -1.0; // ( -u, v, 1 ) pos z\n\n\t\t\t} else if ( face == 3.0 ) {\n\n\t\t\t\tdirection = direction.zyx;\n\t\t\t\tdirection.xz *= -1.0; // ( -1, v, -u ) neg x\n\n\t\t\t} else if ( face == 4.0 ) {\n\n\t\t\t\tdirection = direction.xzy;\n\t\t\t\tdirection.xy *= -1.0; // ( -u, -1, v ) neg y\n\n\t\t\t} else if ( face == 5.0 ) {\n\n\t\t\t\tdirection.z *= -1.0; // ( u, v, -1 ) neg z\n\n\t\t\t}\n\n\t\t\treturn direction;\n\n\t\t}\n\n\t\tvoid main() {\n\n\t\t\tvOutputDirection = getDirection( uv, faceIndex );\n\t\t\tgl_Position = vec4( position, 1.0 );\n\n\t\t}\n\t",fragmentShader:"\n\n\t\t\tprecision mediump float;\n\t\t\tprecision mediump int;\n\n\t\t\tvarying vec3 vOutputDirection;\n\n\t\t\tuniform sampler2D envMap;\n\t\t\tuniform int samples;\n\t\t\tuniform float weights[ n ];\n\t\t\tuniform bool latitudinal;\n\t\t\tuniform float dTheta;\n\t\t\tuniform float mipInt;\n\t\t\tuniform vec3 poleAxis;\n\n\t\t\t#define ENVMAP_TYPE_CUBE_UV\n\t\t\t#include <cube_uv_reflection_fragment>\n\n\t\t\tvec3 getSample( float theta, vec3 axis ) {\n\n\t\t\t\tfloat cosTheta = cos( theta );\n\t\t\t\t// Rodrigues' axis-angle rotation\n\t\t\t\tvec3 sampleDirection = vOutputDirection * cosTheta\n\t\t\t\t\t+ cross( axis, vOutputDirection ) * sin( theta )\n\t\t\t\t\t+ axis * dot( axis, vOutputDirection ) * ( 1.0 - cosTheta );\n\n\t\t\t\treturn bilinearCubeUV( envMap, sampleDirection, mipInt );\n\n\t\t\t}\n\n\t\t\tvoid main() {\n\n\t\t\t\tvec3 axis = latitudinal ? poleAxis : cross( poleAxis, vOutputDirection );\n\n\t\t\t\tif ( all( equal( axis, vec3( 0.0 ) ) ) ) {\n\n\t\t\t\t\taxis = vec3( vOutputDirection.z, 0.0, - vOutputDirection.x );\n\n\t\t\t\t}\n\n\t\t\t\taxis = normalize( axis );\n\n\t\t\t\tgl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 );\n\t\t\t\tgl_FragColor.rgb += weights[ 0 ] * getSample( 0.0, axis );\n\n\t\t\t\tfor ( int i = 1; i < n; i++ ) {\n\n\t\t\t\t\tif ( i >= samples ) {\n\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t}\n\n\t\t\t\t\tfloat theta = dTheta * float( i );\n\t\t\t\t\tgl_FragColor.rgb += weights[ i ] * getSample( -1.0 * theta, axis );\n\t\t\t\t\tgl_FragColor.rgb += weights[ i ] * getSample( theta, axis );\n\n\t\t\t\t}\n\n\t\t\t}\n\t\t",blending:yp,depthTest:!1,depthWrite:!1})}(),this._equirectShader=null,this._cubemapShader=null,this._compileMaterial(this._blurMaterial)}fromScene(t,e=0,i=.1,r=100){uB=this._renderer.getRenderTarget();let o=this._allocateTargets();return this._sceneToCubeUV(t,i,r,o),e>0&&this._blur(o,0,0,e),this._applyPMREM(o),this._cleanup(o),o}fromEquirectangular(t,e=null){return this._fromTexture(t,e)}fromCubemap(t,e=null){return this._fromTexture(t,e)}compileCubemapShader(){null===this._cubemapShader&&(this._cubemapShader=vee(),this._compileMaterial(this._cubemapShader))}compileEquirectangularShader(){null===this._equirectShader&&(this._equirectShader=bee(),this._compileMaterial(this._equirectShader))}dispose(){this._blurMaterial.dispose(),null!==this._pingPongRenderTarget&&this._pingPongRenderTarget.dispose(),null!==this._cubemapShader&&this._cubemapShader.dispose(),null!==this._equirectShader&&this._equirectShader.dispose();for(let t=0;t<fx.length;t++)fx[t].dispose()}_cleanup(t){this._renderer.setRenderTarget(uB),t.scissorTest=!1,lI(t,0,0,t.width,t.height)}_fromTexture(t,e){uB=this._renderer.getRenderTarget();let i=e||this._allocateTargets(t);return this._textureToCubeUV(t,i),this._applyPMREM(i),this._cleanup(i),i}_allocateTargets(t){let e={magFilter:ra,minFilter:ra,generateMipmaps:!1,type:t_,format:ba,encoding:Mp,depthBuffer:!1},i=yee(e);return i.depthBuffer=!t,null===this._pingPongRenderTarget&&(this._pingPongRenderTarget=yee(e)),i}_compileMaterial(t){let e=new co(fx[0],t);this._renderer.compile(e,dB)}_sceneToCubeUV(t,e,i,r){let s=new oa(90,1,e,i),l=[1,-1,1,1,1,1],c=[1,1,1,-1,-1,-1],d=this._renderer,u=d.autoClear,p=d.toneMapping;d.getClearColor(gee),d.toneMapping=bp,d.autoClear=!1;let f=new Sm({name:"PMREM.Background",side:yo,depthWrite:!1,depthTest:!1}),m=new co(new Em,f),y=!1,M=t.background;M?M.isColor&&(f.color.copy(M),t.background=null,y=!0):(f.color.copy(gee),y=!0);for(let v=0;v<6;v++){let x=v%3;0===x?(s.up.set(0,l[v],0),s.lookAt(c[v],0,0)):1===x?(s.up.set(0,0,l[v]),s.lookAt(0,c[v],0)):(s.up.set(0,l[v],0),s.lookAt(0,0,c[v])),lI(r,x*Uc,v>2?Uc:0,Uc,Uc),d.setRenderTarget(r),y&&d.render(m,s),d.render(t,s)}m.geometry.dispose(),m.material.dispose(),d.toneMapping=p,d.autoClear=u,t.background=M}_textureToCubeUV(t,e){let i=this._renderer,r=t.mapping===Zx||t.mapping===Kx;r?(null===this._cubemapShader&&(this._cubemapShader=vee()),this._cubemapShader.uniforms.flipEnvMap.value=!1===t.isRenderTargetTexture?-1:1):null===this._equirectShader&&(this._equirectShader=bee());let o=r?this._cubemapShader:this._equirectShader,a=new co(fx[0],o),s=o.uniforms;s.envMap.value=t,r||s.texelSize.value.set(1/t.image.width,1/t.image.height),lI(e,0,0,3*Uc,2*Uc),i.setRenderTarget(e),i.render(a,dB)}_applyPMREM(t){let e=this._renderer,i=e.autoClear;e.autoClear=!1;for(let r=1;r<_te;r++){let o=Math.sqrt(sI[r]*sI[r]-sI[r-1]*sI[r-1]);this._blur(t,r-1,r,o,_ee[(r-1)%_ee.length])}e.autoClear=i}_blur(t,e,i,r,o){let a=this._pingPongRenderTarget;this._halfBlur(t,a,e,i,r,"latitudinal",o),this._halfBlur(a,t,i,i,r,"longitudinal",o)}_halfBlur(t,e,i,r,o,a,s){let l=this._renderer,c=this._blurMaterial;"latitudinal"!==a&&"longitudinal"!==a&&console.error("blur direction must be either latitudinal or longitudinal!");let u=new co(fx[r],c),p=c.uniforms,f=hee[i]-1,m=isFinite(o)?Math.PI/(2*f):2*Math.PI/39,y=o/m,M=isFinite(o)?1+Math.floor(3*y):20;M>20&&console.warn(`sigmaRadians, ${o}, is too large and will clip, as it requested ${M} samples when the maximum is set to 20`);let v=[],x=0;for(let te=0;te<20;++te){let K=te/y,Ce=Math.exp(-K*K/2);v.push(Ce),0===te?x+=Ce:te<M&&(x+=2*Ce)}for(let te=0;te<v.length;te++)v[te]=v[te]/x;p.envMap.value=t.texture,p.samples.value=M,p.weights.value=v,p.latitudinal.value="latitudinal"===a,s&&(p.poleAxis.value=s),p.dTheta.value=m,p.mipInt.value=xp-i;let R=hee[r];lI(e,3*Math.max(0,Uc-2*R),(0===r?0:2*Uc)+2*R*(r>xp-r_?r-xp+r_:0),3*R,2*R),l.setRenderTarget(e),l.render(u,dB)}};function ZPe(){let n=[],t=[],e=[],i=xp;for(let r=0;r<_te;r++){let o=Math.pow(2,i);t.push(o);let a=1/o;r>xp-r_?a=gte[r-xp+r_-1]:0===r&&(a=0),e.push(a);let s=1/(o-1),l=-s/2,c=1+s/2,d=[l,l,c,l,c,c,l,l,c,c,l,c],u=6,p=6,f=3,m=2,y=1,M=new Float32Array(f*p*u),v=new Float32Array(m*p*u),x=new Float32Array(y*p*u);for(let A=0;A<u;A++){let H=A%3*2/3-1,te=A>2?0:-1;M.set([H,te,0,H+2/3,te,0,H+2/3,te+1,0,H,te,0,H+2/3,te+1,0,H,te+1,0],f*p*A),v.set(d,m*p*A),x.set([A,A,A,A,A,A],y*p*A)}let R=new Wi;R.setAttribute("position",new Ar(M,f)),R.setAttribute("uv",new Ar(v,m)),R.setAttribute("faceIndex",new Ar(x,y)),n.push(R),i>r_&&i--}return{_lodPlanes:n,_sizeLods:t,_sigmas:e}}function yee(n){let t=new Qa(3*Uc,3*Uc,n);return t.texture.mapping=$I,t.texture.name="PMREM.cubeUv",t.scissorTest=!0,t}function lI(n,t,e,i,r){n.viewport.set(t,e,i,r),n.scissor.set(t,e,i,r)}function bee(){let n=new $e(1,1);return new d_({name:"EquirectangularToCubeUV",uniforms:{envMap:{value:null},texelSize:{value:n}},vertexShader:"\n\n\t\tprecision mediump float;\n\t\tprecision mediump int;\n\n\t\tattribute vec3 position;\n\t\tattribute vec2 uv;\n\t\tattribute float faceIndex;\n\n\t\tvarying vec3 vOutputDirection;\n\n\t\t// RH coordinate system; PMREM face-indexing convention\n\t\tvec3 getDirection( vec2 uv, float face ) {\n\n\t\t\tuv = 2.0 * uv - 1.0;\n\n\t\t\tvec3 direction = vec3( uv, 1.0 );\n\n\t\t\tif ( face == 0.0 ) {\n\n\t\t\t\tdirection = direction.zyx; // ( 1, v, u ) pos x\n\n\t\t\t} else if ( face == 1.0 ) {\n\n\t\t\t\tdirection = direction.xzy;\n\t\t\t\tdirection.xz *= -1.0; // ( -u, 1, -v ) pos y\n\n\t\t\t} else if ( face == 2.0 ) {\n\n\t\t\t\tdirection.x *= -1.0; // ( -u, v, 1 ) pos z\n\n\t\t\t} else if ( face == 3.0 ) {\n\n\t\t\t\tdirection = direction.zyx;\n\t\t\t\tdirection.xz *= -1.0; // ( -1, v, -u ) neg x\n\n\t\t\t} else if ( face == 4.0 ) {\n\n\t\t\t\tdirection = direction.xzy;\n\t\t\t\tdirection.xy *= -1.0; // ( -u, -1, v ) neg y\n\n\t\t\t} else if ( face == 5.0 ) {\n\n\t\t\t\tdirection.z *= -1.0; // ( u, v, -1 ) neg z\n\n\t\t\t}\n\n\t\t\treturn direction;\n\n\t\t}\n\n\t\tvoid main() {\n\n\t\t\tvOutputDirection = getDirection( uv, faceIndex );\n\t\t\tgl_Position = vec4( position, 1.0 );\n\n\t\t}\n\t",fragmentShader:"\n\n\t\t\tprecision mediump float;\n\t\t\tprecision mediump int;\n\n\t\t\tvarying vec3 vOutputDirection;\n\n\t\t\tuniform sampler2D envMap;\n\t\t\tuniform vec2 texelSize;\n\n\t\t\t#include <common>\n\n\t\t\tvoid main() {\n\n\t\t\t\tgl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 );\n\n\t\t\t\tvec3 outputDirection = normalize( vOutputDirection );\n\t\t\t\tvec2 uv = equirectUv( outputDirection );\n\n\t\t\t\tvec2 f = fract( uv / texelSize - 0.5 );\n\t\t\t\tuv -= f * texelSize;\n\t\t\t\tvec3 tl = texture2D ( envMap, uv ).rgb;\n\t\t\t\tuv.x += texelSize.x;\n\t\t\t\tvec3 tr = texture2D ( envMap, uv ).rgb;\n\t\t\t\tuv.y += texelSize.y;\n\t\t\t\tvec3 br = texture2D ( envMap, uv ).rgb;\n\t\t\t\tuv.x -= texelSize.x;\n\t\t\t\tvec3 bl = texture2D ( envMap, uv ).rgb;\n\n\t\t\t\tvec3 tm = mix( tl, tr, f.x );\n\t\t\t\tvec3 bm = mix( bl, br, f.x );\n\t\t\t\tgl_FragColor.rgb = mix( tm, bm, f.y );\n\n\t\t\t}\n\t\t",blending:yp,depthTest:!1,depthWrite:!1})}function vee(){return new d_({name:"CubemapToCubeUV",uniforms:{envMap:{value:null},flipEnvMap:{value:-1}},vertexShader:"\n\n\t\tprecision mediump float;\n\t\tprecision mediump int;\n\n\t\tattribute vec3 position;\n\t\tattribute vec2 uv;\n\t\tattribute float faceIndex;\n\n\t\tvarying vec3 vOutputDirection;\n\n\t\t// RH coordinate system; PMREM face-indexing convention\n\t\tvec3 getDirection( vec2 uv, float face ) {\n\n\t\t\tuv = 2.0 * uv - 1.0;\n\n\t\t\tvec3 direction = vec3( uv, 1.0 );\n\n\t\t\tif ( face == 0.0 ) {\n\n\t\t\t\tdirection = direction.zyx; // ( 1, v, u ) pos x\n\n\t\t\t} else if ( face == 1.0 ) {\n\n\t\t\t\tdirection = direction.xzy;\n\t\t\t\tdirection.xz *= -1.0; // ( -u, 1, -v ) pos y\n\n\t\t\t} else if ( face == 2.0 ) {\n\n\t\t\t\tdirection.x *= -1.0; // ( -u, v, 1 ) pos z\n\n\t\t\t} else if ( face == 3.0 ) {\n\n\t\t\t\tdirection = direction.zyx;\n\t\t\t\tdirection.xz *= -1.0; // ( -1, v, -u ) neg x\n\n\t\t\t} else if ( face == 4.0 ) {\n\n\t\t\t\tdirection = direction.xzy;\n\t\t\t\tdirection.xy *= -1.0; // ( -u, -1, v ) neg y\n\n\t\t\t} else if ( face == 5.0 ) {\n\n\t\t\t\tdirection.z *= -1.0; // ( u, v, -1 ) neg z\n\n\t\t\t}\n\n\t\t\treturn direction;\n\n\t\t}\n\n\t\tvoid main() {\n\n\t\t\tvOutputDirection = getDirection( uv, faceIndex );\n\t\t\tgl_Position = vec4( position, 1.0 );\n\n\t\t}\n\t",fragmentShader:"\n\n\t\t\tprecision mediump float;\n\t\t\tprecision mediump int;\n\n\t\t\tuniform float flipEnvMap;\n\n\t\t\tvarying vec3 vOutputDirection;\n\n\t\t\tuniform samplerCube envMap;\n\n\t\t\tvoid main() {\n\n\t\t\t\tgl_FragColor = textureCube( envMap, vec3( flipEnvMap * vOutputDirection.x, vOutputDirection.yz ) );\n\n\t\t\t}\n\t\t",blending:yp,depthTest:!1,depthWrite:!1})}function JPe(n){let t=new WeakMap,e=null;function o(s){let l=s.target;l.removeEventListener("dispose",o);let c=t.get(l);void 0!==c&&(t.delete(l),c.dispose())}return{get:function(s){if(s&&s.isTexture){let l=s.mapping,c=l===xB||l===CB,d=l===Zx||l===Kx;if(c||d){if(s.isRenderTargetTexture&&!0===s.needsPMREMUpdate){s.needsPMREMUpdate=!1;let u=t.get(s);return null===e&&(e=new RI(n)),u=c?e.fromEquirectangular(s,u):e.fromCubemap(s,u),t.set(s,u),u.texture}if(t.has(s))return t.get(s).texture;{let u=s.image;if(c&&u&&u.height>0||d&&u&&function(s){let l=0;for(let d=0;d<6;d++)void 0!==s[d]&&l++;return 6===l}(u)){null===e&&(e=new RI(n));let p=c?e.fromEquirectangular(s):e.fromCubemap(s);return t.set(s,p),s.addEventListener("dispose",o),p.texture}return null}}}return s},dispose:function(){t=new WeakMap,null!==e&&(e.dispose(),e=null)}}}function $Pe(n){let t={};function e(i){if(void 0!==t[i])return t[i];let r;switch(i){case"WEBGL_depth_texture":r=n.getExtension("WEBGL_depth_texture")||n.getExtension("MOZ_WEBGL_depth_texture")||n.getExtension("WEBKIT_WEBGL_depth_texture");break;case"EXT_texture_filter_anisotropic":r=n.getExtension("EXT_texture_filter_anisotropic")||n.getExtension("MOZ_EXT_texture_filter_anisotropic")||n.getExtension("WEBKIT_EXT_texture_filter_anisotropic");break;case"WEBGL_compressed_texture_s3tc":r=n.getExtension("WEBGL_compressed_texture_s3tc")||n.getExtension("MOZ_WEBGL_compressed_texture_s3tc")||n.getExtension("WEBKIT_WEBGL_compressed_texture_s3tc");break;case"WEBGL_compressed_texture_pvrtc":r=n.getExtension("WEBGL_compressed_texture_pvrtc")||n.getExtension("WEBKIT_WEBGL_compressed_texture_pvrtc");break;default:r=n.getExtension(i)}return t[i]=r,r}return{has:function(i){return null!==e(i)},init:function(i){i.isWebGL2?e("EXT_color_buffer_float"):(e("WEBGL_depth_texture"),e("OES_texture_float"),e("OES_texture_half_float"),e("OES_texture_half_float_linear"),e("OES_standard_derivatives"),e("OES_element_index_uint"),e("OES_vertex_array_object"),e("ANGLE_instanced_arrays")),e("OES_texture_float_linear"),e("EXT_color_buffer_half_float"),e("WEBGL_multisampled_render_to_texture")},get:function(i){let r=e(i);return null===r&&console.warn("THREE.WebGLRenderer: "+i+" extension not supported."),r}}}function eOe(n,t,e,i){let r={},o=new WeakMap;function a(u){let p=u.target;null!==p.index&&t.remove(p.index);for(let m in p.attributes)t.remove(p.attributes[m]);p.removeEventListener("dispose",a),delete r[p.id];let f=o.get(p);f&&(t.remove(f),o.delete(p)),i.releaseStatesOfGeometry(p),!0===p.isInstancedBufferGeometry&&delete p._maxInstanceCount,e.memory.geometries--}function c(u){let p=[],f=u.index,m=u.attributes.position,y=0;if(null!==f){let x=f.array;y=f.version;for(let R=0,A=x.length;R<A;R+=3){let H=x[R+0],te=x[R+1],K=x[R+2];p.push(H,te,te,K,K,H)}}else{y=m.version;for(let R=0,A=m.array.length/3-1;R<A;R+=3){let H=R+0,te=R+1,K=R+2;p.push(H,te,te,K,K,H)}}let M=new(mte(p)?II:DI)(p,1);M.version=y;let v=o.get(u);v&&t.remove(v),o.set(u,M)}return{get:function(u,p){return!0===r[p.id]||(p.addEventListener("dispose",a),r[p.id]=!0,e.memory.geometries++),p},update:function(u){let p=u.attributes;for(let m in p)t.update(p[m],34962);let f=u.morphAttributes;for(let m in f){let y=f[m];for(let M=0,v=y.length;M<v;M++)t.update(y[M],34962)}},getWireframeAttribute:function(u){let p=o.get(u);if(p){let f=u.index;null!==f&&p.version<f.version&&c(u)}else c(u);return o.get(u)}}}function tOe(n,t,e,i){let o,s,l,r=i.isWebGL2;this.setMode=function(p){o=p},this.setIndex=function(p){s=p.type,l=p.bytesPerElement},this.render=function(p,f){n.drawElements(o,f,s,p*l),e.update(f,o,1)},this.renderInstances=function(p,f,m){if(0===m)return;let y,M;if(r)y=n,M="drawElementsInstanced";else if(y=t.get("ANGLE_instanced_arrays"),M="drawElementsInstancedANGLE",null===y)return void console.error("THREE.WebGLIndexedBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.");y[M](o,f,s,p*l,m),e.update(f,o,m)}}function nOe(n){let e={frame:0,calls:0,triangles:0,points:0,lines:0};return{memory:{geometries:0,textures:0},render:e,programs:null,autoReset:!0,reset:function(){e.frame++,e.calls=0,e.triangles=0,e.points=0,e.lines=0},update:function(o,a,s){switch(e.calls++,a){case 4:e.triangles+=s*(o/3);break;case 1:e.lines+=s*(o/2);break;case 3:e.lines+=s*(o-1);break;case 2:e.lines+=s*o;break;case 0:e.points+=s*o;break;default:console.error("THREE.WebGLInfo: Unknown draw mode:",a)}}}}var Px=class extends uo{constructor(t=null,e=1,i=1,r=1){super(null),this.image={data:t,width:e,height:i,depth:r},this.magFilter=bo,this.minFilter=bo,this.wrapR=gs,this.generateMipmaps=!1,this.flipY=!1,this.unpackAlignment=1}};function iOe(n,t){return n[0]-t[0]}function rOe(n,t){return Math.abs(t[1])-Math.abs(n[1])}function xee(n,t){let e=1,i=t.isInterleavedBufferAttribute?t.data.array:t.array;i instanceof Int8Array?e=127:i instanceof Int16Array?e=32767:i instanceof Int32Array?e=2147483647:console.error("THREE.WebGLMorphtargets: Unsupported morph attribute data type: ",i),n.divideScalar(e)}function oOe(n,t,e){let i={},r=new Float32Array(8),o=new WeakMap,a=new $,s=[];for(let c=0;c<8;c++)s[c]=[c,0];return{update:function(c,d,u,p){let f=c.morphTargetInfluences;if(!0===t.isWebGL2){let m=d.morphAttributes.position.length,y=o.get(d);if(void 0===y||y.count!==m){let re=function(){Ie.dispose(),o.delete(d),d.removeEventListener("dispose",re)};void 0!==y&&y.texture.dispose();let x=void 0!==d.morphAttributes.normal,R=d.morphAttributes.position,A=d.morphAttributes.normal||[],te=!0===x?2:1,K=d.attributes.position.count*te,Ce=1;K>t.maxTextureSize&&(Ce=Math.ceil(K/t.maxTextureSize),K=t.maxTextureSize);let Ze=new Float32Array(K*Ce*4*m),Ie=new Px(Ze,K,Ce,m);Ie.format=ba,Ie.type=Cm,Ie.needsUpdate=!0;let I=4*te;for(let ce=0;ce<m;ce++){let fe=R[ce],_e=A[ce],ne=K*Ce*4*ce;for(let de=0;de<fe.count;de++){a.fromBufferAttribute(fe,de),!0===fe.normalized&&xee(a,fe);let ue=de*I;Ze[ne+ue+0]=a.x,Ze[ne+ue+1]=a.y,Ze[ne+ue+2]=a.z,Ze[ne+ue+3]=0,!0===x&&(a.fromBufferAttribute(_e,de),!0===_e.normalized&&xee(a,_e),Ze[ne+ue+4]=a.x,Ze[ne+ue+5]=a.y,Ze[ne+ue+6]=a.z,Ze[ne+ue+7]=0)}}y={count:m,texture:Ie,size:new $e(K,Ce)},o.set(d,y),d.addEventListener("dispose",re)}let M=0;for(let x=0;x<f.length;x++)M+=f[x];let v=d.morphTargetsRelative?1:1-M;p.getUniforms().setValue(n,"morphTargetBaseInfluence",v),p.getUniforms().setValue(n,"morphTargetInfluences",f),p.getUniforms().setValue(n,"morphTargetsTexture",y.texture,e),p.getUniforms().setValue(n,"morphTargetsTextureSize",y.size)}else{let m=void 0===f?0:f.length,y=i[d.id];if(void 0===y||y.length!==m){y=[];for(let A=0;A<m;A++)y[A]=[A,0];i[d.id]=y}for(let A=0;A<m;A++){let H=y[A];H[0]=A,H[1]=f[A]}y.sort(rOe);for(let A=0;A<8;A++)A<m&&y[A][1]?(s[A][0]=y[A][0],s[A][1]=y[A][1]):(s[A][0]=Number.MAX_SAFE_INTEGER,s[A][1]=0);s.sort(iOe);let M=d.morphAttributes.position,v=d.morphAttributes.normal,x=0;for(let A=0;A<8;A++){let H=s[A],te=H[0],K=H[1];te!==Number.MAX_SAFE_INTEGER&&K?(M&&d.getAttribute("morphTarget"+A)!==M[te]&&d.setAttribute("morphTarget"+A,M[te]),v&&d.getAttribute("morphNormal"+A)!==v[te]&&d.setAttribute("morphNormal"+A,v[te]),r[A]=K,x+=K):(M&&!0===d.hasAttribute("morphTarget"+A)&&d.deleteAttribute("morphTarget"+A),v&&!0===d.hasAttribute("morphNormal"+A)&&d.deleteAttribute("morphNormal"+A),r[A]=0)}let R=d.morphTargetsRelative?1:1-x;p.getUniforms().setValue(n,"morphTargetBaseInfluence",R),p.getUniforms().setValue(n,"morphTargetInfluences",r)}}}}function aOe(n,t,e,i){let r=new WeakMap;function s(l){let c=l.target;c.removeEventListener("dispose",s),e.remove(c.instanceMatrix),null!==c.instanceColor&&e.remove(c.instanceColor)}return{update:function(l){let c=i.render.frame,u=t.get(l,l.geometry);return r.get(u)!==c&&(t.update(u),r.set(u,c)),l.isInstancedMesh&&(!1===l.hasEventListener("dispose",s)&&l.addEventListener("dispose",s),e.update(l.instanceMatrix,34962),null!==l.instanceColor&&e.update(l.instanceColor,34962)),u},dispose:function(){r=new WeakMap}}}Px.prototype.isDataTexture2DArray=!0;var kI=class extends uo{constructor(t=null,e=1,i=1,r=1){super(null),this.image={data:t,width:e,height:i,depth:r},this.magFilter=bo,this.minFilter=bo,this.wrapR=gs,this.generateMipmaps=!1,this.flipY=!1,this.unpackAlignment=1}};kI.prototype.isDataTexture3D=!0;var yte=new uo,bte=new Px,vte=new kI,xte=new l_,Cee=[],Mee=[],wee=new Float32Array(16),See=new Float32Array(9),Eee=new Float32Array(4);function b_(n,t,e){let i=n[0];if(i<=0||i>0)return n;let r=t*e,o=Cee[r];if(void 0===o&&(o=new Float32Array(r),Cee[r]=o),0!==t){i.toArray(o,0);for(let a=1,s=0;a!==t;++a)s+=e,n[a].toArray(o,s)}return o}function va(n,t){if(n.length!==t.length)return!1;for(let e=0,i=n.length;e<i;e++)if(n[e]!==t[e])return!1;return!0}function sa(n,t){for(let e=0,i=t.length;e<i;e++)n[e]=t[e]}function tA(n,t){let e=Mee[t];void 0===e&&(e=new Int32Array(t),Mee[t]=e);for(let i=0;i!==t;++i)e[i]=n.allocateTextureUnit();return e}function sOe(n,t){let e=this.cache;e[0]!==t&&(n.uniform1f(this.addr,t),e[0]=t)}function lOe(n,t){let e=this.cache;if(void 0!==t.x)(e[0]!==t.x||e[1]!==t.y)&&(n.uniform2f(this.addr,t.x,t.y),e[0]=t.x,e[1]=t.y);else{if(va(e,t))return;n.uniform2fv(this.addr,t),sa(e,t)}}function cOe(n,t){let e=this.cache;if(void 0!==t.x)(e[0]!==t.x||e[1]!==t.y||e[2]!==t.z)&&(n.uniform3f(this.addr,t.x,t.y,t.z),e[0]=t.x,e[1]=t.y,e[2]=t.z);else if(void 0!==t.r)(e[0]!==t.r||e[1]!==t.g||e[2]!==t.b)&&(n.uniform3f(this.addr,t.r,t.g,t.b),e[0]=t.r,e[1]=t.g,e[2]=t.b);else{if(va(e,t))return;n.uniform3fv(this.addr,t),sa(e,t)}}function dOe(n,t){let e=this.cache;if(void 0!==t.x)(e[0]!==t.x||e[1]!==t.y||e[2]!==t.z||e[3]!==t.w)&&(n.uniform4f(this.addr,t.x,t.y,t.z,t.w),e[0]=t.x,e[1]=t.y,e[2]=t.z,e[3]=t.w);else{if(va(e,t))return;n.uniform4fv(this.addr,t),sa(e,t)}}function uOe(n,t){let e=this.cache,i=t.elements;if(void 0===i){if(va(e,t))return;n.uniformMatrix2fv(this.addr,!1,t),sa(e,t)}else{if(va(e,i))return;Eee.set(i),n.uniformMatrix2fv(this.addr,!1,Eee),sa(e,i)}}function pOe(n,t){let e=this.cache,i=t.elements;if(void 0===i){if(va(e,t))return;n.uniformMatrix3fv(this.addr,!1,t),sa(e,t)}else{if(va(e,i))return;See.set(i),n.uniformMatrix3fv(this.addr,!1,See),sa(e,i)}}function fOe(n,t){let e=this.cache,i=t.elements;if(void 0===i){if(va(e,t))return;n.uniformMatrix4fv(this.addr,!1,t),sa(e,t)}else{if(va(e,i))return;wee.set(i),n.uniformMatrix4fv(this.addr,!1,wee),sa(e,i)}}function mOe(n,t){let e=this.cache;e[0]!==t&&(n.uniform1i(this.addr,t),e[0]=t)}function hOe(n,t){let e=this.cache;va(e,t)||(n.uniform2iv(this.addr,t),sa(e,t))}function gOe(n,t){let e=this.cache;va(e,t)||(n.uniform3iv(this.addr,t),sa(e,t))}function _Oe(n,t){let e=this.cache;va(e,t)||(n.uniform4iv(this.addr,t),sa(e,t))}function yOe(n,t){let e=this.cache;e[0]!==t&&(n.uniform1ui(this.addr,t),e[0]=t)}function bOe(n,t){let e=this.cache;va(e,t)||(n.uniform2uiv(this.addr,t),sa(e,t))}function vOe(n,t){let e=this.cache;va(e,t)||(n.uniform3uiv(this.addr,t),sa(e,t))}function xOe(n,t){let e=this.cache;va(e,t)||(n.uniform4uiv(this.addr,t),sa(e,t))}function COe(n,t,e){let i=this.cache,r=e.allocateTextureUnit();i[0]!==r&&(n.uniform1i(this.addr,r),i[0]=r),e.safeSetTexture2D(t||yte,r)}function MOe(n,t,e){let i=this.cache,r=e.allocateTextureUnit();i[0]!==r&&(n.uniform1i(this.addr,r),i[0]=r),e.setTexture3D(t||vte,r)}function wOe(n,t,e){let i=this.cache,r=e.allocateTextureUnit();i[0]!==r&&(n.uniform1i(this.addr,r),i[0]=r),e.safeSetTextureCube(t||xte,r)}function SOe(n,t,e){let i=this.cache,r=e.allocateTextureUnit();i[0]!==r&&(n.uniform1i(this.addr,r),i[0]=r),e.setTexture2DArray(t||bte,r)}function TOe(n,t){n.uniform1fv(this.addr,t)}function DOe(n,t){let e=b_(t,this.size,2);n.uniform2fv(this.addr,e)}function IOe(n,t){let e=b_(t,this.size,3);n.uniform3fv(this.addr,e)}function AOe(n,t){let e=b_(t,this.size,4);n.uniform4fv(this.addr,e)}function ROe(n,t){let e=b_(t,this.size,4);n.uniformMatrix2fv(this.addr,!1,e)}function kOe(n,t){let e=b_(t,this.size,9);n.uniformMatrix3fv(this.addr,!1,e)}function POe(n,t){let e=b_(t,this.size,16);n.uniformMatrix4fv(this.addr,!1,e)}function OOe(n,t){n.uniform1iv(this.addr,t)}function FOe(n,t){n.uniform2iv(this.addr,t)}function LOe(n,t){n.uniform3iv(this.addr,t)}function NOe(n,t){n.uniform4iv(this.addr,t)}function BOe(n,t){n.uniform1uiv(this.addr,t)}function VOe(n,t){n.uniform2uiv(this.addr,t)}function HOe(n,t){n.uniform3uiv(this.addr,t)}function zOe(n,t){n.uniform4uiv(this.addr,t)}function UOe(n,t,e){let i=t.length,r=tA(e,i);n.uniform1iv(this.addr,r);for(let o=0;o!==i;++o)e.safeSetTexture2D(t[o]||yte,r[o])}function jOe(n,t,e){let i=t.length,r=tA(e,i);n.uniform1iv(this.addr,r);for(let o=0;o!==i;++o)e.setTexture3D(t[o]||vte,r[o])}function GOe(n,t,e){let i=t.length,r=tA(e,i);n.uniform1iv(this.addr,r);for(let o=0;o!==i;++o)e.safeSetTextureCube(t[o]||xte,r[o])}function WOe(n,t,e){let i=t.length,r=tA(e,i);n.uniform1iv(this.addr,r);for(let o=0;o!==i;++o)e.setTexture2DArray(t[o]||bte,r[o])}function YOe(n,t,e){this.id=n,this.addr=e,this.cache=[],this.setValue=function(n){switch(n){case 5126:return sOe;case 35664:return lOe;case 35665:return cOe;case 35666:return dOe;case 35674:return uOe;case 35675:return pOe;case 35676:return fOe;case 5124:case 35670:return mOe;case 35667:case 35671:return hOe;case 35668:case 35672:return gOe;case 35669:case 35673:return _Oe;case 5125:return yOe;case 36294:return bOe;case 36295:return vOe;case 36296:return xOe;case 35678:case 36198:case 36298:case 36306:case 35682:return COe;case 35679:case 36299:case 36307:return MOe;case 35680:case 36300:case 36308:case 36293:return wOe;case 36289:case 36303:case 36311:case 36292:return SOe}}(t.type)}function Cte(n,t,e){this.id=n,this.addr=e,this.cache=[],this.size=t.size,this.setValue=function(n){switch(n){case 5126:return TOe;case 35664:return DOe;case 35665:return IOe;case 35666:return AOe;case 35674:return ROe;case 35675:return kOe;case 35676:return POe;case 5124:case 35670:return OOe;case 35667:case 35671:return FOe;case 35668:case 35672:return LOe;case 35669:case 35673:return NOe;case 5125:return BOe;case 36294:return VOe;case 36295:return HOe;case 36296:return zOe;case 35678:case 36198:case 36298:case 36306:case 35682:return UOe;case 35679:case 36299:case 36307:return jOe;case 35680:case 36300:case 36308:case 36293:return GOe;case 36289:case 36303:case 36311:case 36292:return WOe}}(t.type)}function Mte(n){this.id=n,this.seq=[],this.map={}}Cte.prototype.updateCache=function(n){let t=this.cache;n instanceof Float32Array&&t.length!==n.length&&(this.cache=new Float32Array(n.length)),sa(t,n)},Mte.prototype.setValue=function(n,t,e){let i=this.seq;for(let r=0,o=i.length;r!==o;++r){let a=i[r];a.setValue(n,t[a.id],e)}};var pB=/(\w+)(\])?(\[|\.)?/g;function Tee(n,t){n.seq.push(t),n.map[t.id]=t}function XOe(n,t,e){let i=n.name,r=i.length;for(pB.lastIndex=0;;){let o=pB.exec(i),s=o[1],c=o[3];if("]"===o[2]&&(s|=0),void 0===c||"["===c&&pB.lastIndex+2===r){Tee(e,void 0===c?new YOe(s,n,t):new Cte(s,n,t));break}{let u=e.map[s];void 0===u&&(u=new Mte(s),Tee(e,u)),e=u}}}function Cp(n,t){this.seq=[],this.map={};let e=n.getProgramParameter(t,35718);for(let i=0;i<e;++i){let r=n.getActiveUniform(t,i);XOe(r,n.getUniformLocation(t,r.name),this)}}function Dee(n,t,e){let i=n.createShader(t);return n.shaderSource(i,e),n.compileShader(i),i}Cp.prototype.setValue=function(n,t,e,i){let r=this.map[t];void 0!==r&&r.setValue(n,e,i)},Cp.prototype.setOptional=function(n,t,e){let i=t[e];void 0!==i&&this.setValue(n,e,i)},Cp.upload=function(n,t,e,i){for(let r=0,o=t.length;r!==o;++r){let a=t[r],s=e[a.id];!1!==s.needsUpdate&&a.setValue(n,s.value,i)}},Cp.seqWithValue=function(n,t){let e=[];for(let i=0,r=n.length;i!==r;++i){let o=n[i];o.id in t&&e.push(o)}return e};var QOe=0;function Iee(n,t,e){let i=n.getShaderParameter(t,35713),r=n.getShaderInfoLog(t).trim();return i&&""===r?"":e.toUpperCase()+"\n\n"+r+"\n\n"+function(n){let t=n.split("\n");for(let e=0;e<t.length;e++)t[e]=e+1+": "+t[e];return t.join("\n")}(n.getShaderSource(t))}function JOe(n,t){let e=function(n){switch(n){case Mp:return["Linear","( value )"];case Dr:return["sRGB","( value )"];default:return console.warn("THREE.WebGLProgram: Unsupported encoding:",n),["Linear","( value )"]}}(t);return"vec4 "+n+"( vec4 value ) { return LinearTo"+e[0]+e[1]+"; }"}function $Oe(n,t){let e;switch(t){case SAe:e="Linear";break;case EAe:e="Reinhard";break;case TAe:e="OptimizedCineon";break;case DAe:e="ACESFilmic";break;case IAe:e="Custom";break;default:console.warn("THREE.WebGLProgram: Unsupported toneMapping:",t),e="Linear"}return"vec3 "+n+"( vec3 color ) { return "+e+"ToneMapping( color ); }"}function vx(n){return""!==n}function Aee(n,t){return n.replace(/NUM_DIR_LIGHTS/g,t.numDirLights).replace(/NUM_SPOT_LIGHTS/g,t.numSpotLights).replace(/NUM_RECT_AREA_LIGHTS/g,t.numRectAreaLights).replace(/NUM_POINT_LIGHTS/g,t.numPointLights).replace(/NUM_HEMI_LIGHTS/g,t.numHemiLights).replace(/NUM_DIR_LIGHT_SHADOWS/g,t.numDirLightShadows).replace(/NUM_SPOT_LIGHT_SHADOWS/g,t.numSpotLightShadows).replace(/NUM_POINT_LIGHT_SHADOWS/g,t.numPointLightShadows)}function Ree(n,t){return n.replace(/NUM_CLIPPING_PLANES/g,t.numClippingPlanes).replace(/UNION_CLIPPING_PLANES/g,t.numClippingPlanes-t.numClipIntersection)}var iFe=/^[ \t]*#include +<([\w\d./]+)>/gm;function IB(n){return n.replace(iFe,rFe)}function rFe(n,t){let e=vi[t];if(void 0===e)throw new Error("Can not resolve #include <"+t+">");return IB(e)}var oFe=/#pragma unroll_loop[\s]+?for \( int i \= (\d+)\; i < (\d+)\; i \+\+ \) \{([\s\S]+?)(?=\})\}/g,aFe=/#pragma unroll_loop_start\s+for\s*\(\s*int\s+i\s*=\s*(\d+)\s*;\s*i\s*<\s*(\d+)\s*;\s*i\s*\+\+\s*\)\s*{([\s\S]+?)}\s+#pragma unroll_loop_end/g;function kee(n){return n.replace(aFe,wte).replace(oFe,sFe)}function sFe(n,t,e,i){return console.warn("WebGLProgram: #pragma unroll_loop shader syntax is deprecated. Please use #pragma unroll_loop_start syntax instead."),wte(0,t,e,i)}function wte(n,t,e,i){let r="";for(let o=parseInt(t);o<parseInt(e);o++)r+=i.replace(/\[\s*i\s*\]/g,"[ "+o+" ]").replace(/UNROLLED_LOOP_INDEX/g,o);return r}function Pee(n){let t="precision "+n.precision+" float;\nprecision "+n.precision+" int;";return"highp"===n.precision?t+="\n#define HIGH_PRECISION":"mediump"===n.precision?t+="\n#define MEDIUM_PRECISION":"lowp"===n.precision&&(t+="\n#define LOW_PRECISION"),t}function pFe(n,t,e,i){let y,M,r=n.getContext(),o=e.defines,a=e.vertexShader,s=e.fragmentShader,l=function(n){let t="SHADOWMAP_TYPE_BASIC";return n.shadowMapType===lte?t="SHADOWMAP_TYPE_PCF":n.shadowMapType===iAe?t="SHADOWMAP_TYPE_PCF_SOFT":n.shadowMapType===bx&&(t="SHADOWMAP_TYPE_VSM"),t}(e),c=function(n){let t="ENVMAP_TYPE_CUBE";if(n.envMap)switch(n.envMapMode){case Zx:case Kx:t="ENVMAP_TYPE_CUBE";break;case $I:case FV:t="ENVMAP_TYPE_CUBE_UV"}return t}(e),d=function(n){let t="ENVMAP_MODE_REFLECTION";if(n.envMap)switch(n.envMapMode){case Kx:case FV:t="ENVMAP_MODE_REFRACTION"}return t}(e),u=function(n){let t="ENVMAP_BLENDING_NONE";if(n.envMap)switch(n.combine){case JI:t="ENVMAP_BLENDING_MULTIPLY";break;case MAe:t="ENVMAP_BLENDING_MIX";break;case wAe:t="ENVMAP_BLENDING_ADD"}return t}(e),p=e.isWebGL2?"":function(n){return[n.extensionDerivatives||n.envMapCubeUV||n.bumpMap||n.tangentSpaceNormalMap||n.clearcoatNormalMap||n.flatShading||"physical"===n.shaderID?"#extension GL_OES_standard_derivatives : enable":"",(n.extensionFragDepth||n.logarithmicDepthBuffer)&&n.rendererExtensionFragDepth?"#extension GL_EXT_frag_depth : enable":"",n.extensionDrawBuffers&&n.rendererExtensionDrawBuffers?"#extension GL_EXT_draw_buffers : require":"",(n.extensionShaderTextureLOD||n.envMap||n.transmission)&&n.rendererExtensionShaderTextureLod?"#extension GL_EXT_shader_texture_lod : enable":""].filter(vx).join("\n")}(e),f=function(n){let t=[];for(let e in n){let i=n[e];!1!==i&&t.push("#define "+e+" "+i)}return t.join("\n")}(o),m=r.createProgram(),v=e.glslVersion?"#version "+e.glslVersion+"\n":"";e.isRawShaderMaterial?(y=[f].filter(vx).join("\n"),y.length>0&&(y+="\n"),M=[p,f].filter(vx).join("\n"),M.length>0&&(M+="\n")):(y=[Pee(e),"#define SHADER_NAME "+e.shaderName,f,e.instancing?"#define USE_INSTANCING":"",e.instancingColor?"#define USE_INSTANCING_COLOR":"",e.supportsVertexTextures?"#define VERTEX_TEXTURES":"","#define MAX_BONES "+e.maxBones,e.useFog&&e.fog?"#define USE_FOG":"",e.useFog&&e.fogExp2?"#define FOG_EXP2":"",e.map?"#define USE_MAP":"",e.envMap?"#define USE_ENVMAP":"",e.envMap?"#define "+d:"",e.lightMap?"#define USE_LIGHTMAP":"",e.aoMap?"#define USE_AOMAP":"",e.emissiveMap?"#define USE_EMISSIVEMAP":"",e.bumpMap?"#define USE_BUMPMAP":"",e.normalMap?"#define USE_NORMALMAP":"",e.normalMap&&e.objectSpaceNormalMap?"#define OBJECTSPACE_NORMALMAP":"",e.normalMap&&e.tangentSpaceNormalMap?"#define TANGENTSPACE_NORMALMAP":"",e.clearcoatMap?"#define USE_CLEARCOATMAP":"",e.clearcoatRoughnessMap?"#define USE_CLEARCOAT_ROUGHNESSMAP":"",e.clearcoatNormalMap?"#define USE_CLEARCOAT_NORMALMAP":"",e.displacementMap&&e.supportsVertexTextures?"#define USE_DISPLACEMENTMAP":"",e.specularMap?"#define USE_SPECULARMAP":"",e.specularIntensityMap?"#define USE_SPECULARINTENSITYMAP":"",e.specularColorMap?"#define USE_SPECULARCOLORMAP":"",e.roughnessMap?"#define USE_ROUGHNESSMAP":"",e.metalnessMap?"#define USE_METALNESSMAP":"",e.alphaMap?"#define USE_ALPHAMAP":"",e.transmission?"#define USE_TRANSMISSION":"",e.transmissionMap?"#define USE_TRANSMISSIONMAP":"",e.thicknessMap?"#define USE_THICKNESSMAP":"",e.sheenColorMap?"#define USE_SHEENCOLORMAP":"",e.sheenRoughnessMap?"#define USE_SHEENROUGHNESSMAP":"",e.vertexTangents?"#define USE_TANGENT":"",e.vertexColors?"#define USE_COLOR":"",e.vertexAlphas?"#define USE_COLOR_ALPHA":"",e.vertexUvs?"#define USE_UV":"",e.uvsVertexOnly?"#define UVS_VERTEX_ONLY":"",e.flatShading?"#define FLAT_SHADED":"",e.skinning?"#define USE_SKINNING":"",e.useVertexTexture?"#define BONE_TEXTURE":"",e.morphTargets?"#define USE_MORPHTARGETS":"",e.morphNormals&&!1===e.flatShading?"#define USE_MORPHNORMALS":"",e.morphTargets&&e.isWebGL2?"#define MORPHTARGETS_TEXTURE":"",e.morphTargets&&e.isWebGL2?"#define MORPHTARGETS_COUNT "+e.morphTargetsCount:"",e.doubleSided?"#define DOUBLE_SIDED":"",e.flipSided?"#define FLIP_SIDED":"",e.shadowMapEnabled?"#define USE_SHADOWMAP":"",e.shadowMapEnabled?"#define "+l:"",e.sizeAttenuation?"#define USE_SIZEATTENUATION":"",e.logarithmicDepthBuffer?"#define USE_LOGDEPTHBUF":"",e.logarithmicDepthBuffer&&e.rendererExtensionFragDepth?"#define USE_LOGDEPTHBUF_EXT":"","uniform mat4 modelMatrix;","uniform mat4 modelViewMatrix;","uniform mat4 projectionMatrix;","uniform mat4 viewMatrix;","uniform mat3 normalMatrix;","uniform vec3 cameraPosition;","uniform bool isOrthographic;","#ifdef USE_INSTANCING","\tattribute mat4 instanceMatrix;","#endif","#ifdef USE_INSTANCING_COLOR","\tattribute vec3 instanceColor;","#endif","attribute vec3 position;","attribute vec3 normal;","attribute vec2 uv;","#ifdef USE_TANGENT","\tattribute vec4 tangent;","#endif","#if defined( USE_COLOR_ALPHA )","\tattribute vec4 color;","#elif defined( USE_COLOR )","\tattribute vec3 color;","#endif","#if ( defined( USE_MORPHTARGETS ) && ! defined( MORPHTARGETS_TEXTURE ) )","\tattribute vec3 morphTarget0;","\tattribute vec3 morphTarget1;","\tattribute vec3 morphTarget2;","\tattribute vec3 morphTarget3;","\t#ifdef USE_MORPHNORMALS","\t\tattribute vec3 morphNormal0;","\t\tattribute vec3 morphNormal1;","\t\tattribute vec3 morphNormal2;","\t\tattribute vec3 morphNormal3;","\t#else","\t\tattribute vec3 morphTarget4;","\t\tattribute vec3 morphTarget5;","\t\tattribute vec3 morphTarget6;","\t\tattribute vec3 morphTarget7;","\t#endif","#endif","#ifdef USE_SKINNING","\tattribute vec4 skinIndex;","\tattribute vec4 skinWeight;","#endif","\n"].filter(vx).join("\n"),M=[p,Pee(e),"#define SHADER_NAME "+e.shaderName,f,e.useFog&&e.fog?"#define USE_FOG":"",e.useFog&&e.fogExp2?"#define FOG_EXP2":"",e.map?"#define USE_MAP":"",e.matcap?"#define USE_MATCAP":"",e.envMap?"#define USE_ENVMAP":"",e.envMap?"#define "+c:"",e.envMap?"#define "+d:"",e.envMap?"#define "+u:"",e.lightMap?"#define USE_LIGHTMAP":"",e.aoMap?"#define USE_AOMAP":"",e.emissiveMap?"#define USE_EMISSIVEMAP":"",e.bumpMap?"#define USE_BUMPMAP":"",e.normalMap?"#define USE_NORMALMAP":"",e.normalMap&&e.objectSpaceNormalMap?"#define OBJECTSPACE_NORMALMAP":"",e.normalMap&&e.tangentSpaceNormalMap?"#define TANGENTSPACE_NORMALMAP":"",e.clearcoat?"#define USE_CLEARCOAT":"",e.clearcoatMap?"#define USE_CLEARCOATMAP":"",e.clearcoatRoughnessMap?"#define USE_CLEARCOAT_ROUGHNESSMAP":"",e.clearcoatNormalMap?"#define USE_CLEARCOAT_NORMALMAP":"",e.specularMap?"#define USE_SPECULARMAP":"",e.specularIntensityMap?"#define USE_SPECULARINTENSITYMAP":"",e.specularColorMap?"#define USE_SPECULARCOLORMAP":"",e.roughnessMap?"#define USE_ROUGHNESSMAP":"",e.metalnessMap?"#define USE_METALNESSMAP":"",e.alphaMap?"#define USE_ALPHAMAP":"",e.alphaTest?"#define USE_ALPHATEST":"",e.sheen?"#define USE_SHEEN":"",e.sheenColorMap?"#define USE_SHEENCOLORMAP":"",e.sheenRoughnessMap?"#define USE_SHEENROUGHNESSMAP":"",e.transmission?"#define USE_TRANSMISSION":"",e.transmissionMap?"#define USE_TRANSMISSIONMAP":"",e.thicknessMap?"#define USE_THICKNESSMAP":"",e.decodeVideoTexture?"#define DECODE_VIDEO_TEXTURE":"",e.vertexTangents?"#define USE_TANGENT":"",e.vertexColors||e.instancingColor?"#define USE_COLOR":"",e.vertexAlphas?"#define USE_COLOR_ALPHA":"",e.vertexUvs?"#define USE_UV":"",e.uvsVertexOnly?"#define UVS_VERTEX_ONLY":"",e.gradientMap?"#define USE_GRADIENTMAP":"",e.flatShading?"#define FLAT_SHADED":"",e.doubleSided?"#define DOUBLE_SIDED":"",e.flipSided?"#define FLIP_SIDED":"",e.shadowMapEnabled?"#define USE_SHADOWMAP":"",e.shadowMapEnabled?"#define "+l:"",e.premultipliedAlpha?"#define PREMULTIPLIED_ALPHA":"",e.physicallyCorrectLights?"#define PHYSICALLY_CORRECT_LIGHTS":"",e.logarithmicDepthBuffer?"#define USE_LOGDEPTHBUF":"",e.logarithmicDepthBuffer&&e.rendererExtensionFragDepth?"#define USE_LOGDEPTHBUF_EXT":"",(e.extensionShaderTextureLOD||e.envMap)&&e.rendererExtensionShaderTextureLod?"#define TEXTURE_LOD_EXT":"","uniform mat4 viewMatrix;","uniform vec3 cameraPosition;","uniform bool isOrthographic;",e.toneMapping!==bp?"#define TONE_MAPPING":"",e.toneMapping!==bp?vi.tonemapping_pars_fragment:"",e.toneMapping!==bp?$Oe("toneMapping",e.toneMapping):"",e.dithering?"#define DITHERING":"",e.alphaWrite?"":"#define OPAQUE",vi.encodings_pars_fragment,JOe("linearToOutputTexel",e.outputEncoding),e.depthPacking?"#define DEPTH_PACKING "+e.depthPacking:"","\n"].filter(vx).join("\n")),a=IB(a),a=Aee(a,e),a=Ree(a,e),s=IB(s),s=Aee(s,e),s=Ree(s,e),a=kee(a),s=kee(s),e.isWebGL2&&!0!==e.isRawShaderMaterial&&(v="#version 300 es\n",y=["precision mediump sampler2DArray;","#define attribute in","#define varying out","#define texture2D texture"].join("\n")+"\n"+y,M=["#define varying in",e.glslVersion===tee?"":"layout(location = 0) out highp vec4 pc_fragColor;",e.glslVersion===tee?"":"#define gl_FragColor pc_fragColor","#define gl_FragDepthEXT gl_FragDepth","#define texture2D texture","#define textureCube texture","#define texture2DProj textureProj","#define texture2DLodEXT textureLod","#define texture2DProjLodEXT textureProjLod","#define textureCubeLodEXT textureLod","#define texture2DGradEXT textureGrad","#define texture2DProjGradEXT textureProjGrad","#define textureCubeGradEXT textureGrad"].join("\n")+"\n"+M);let te,K,R=v+M+s,A=Dee(r,35633,v+y+a),H=Dee(r,35632,R);if(r.attachShader(m,A),r.attachShader(m,H),void 0!==e.index0AttributeName?r.bindAttribLocation(m,0,e.index0AttributeName):!0===e.morphTargets&&r.bindAttribLocation(m,0,"position"),r.linkProgram(m),n.debug.checkShaderErrors){let Ce=r.getProgramInfoLog(m).trim(),Ze=r.getShaderInfoLog(A).trim(),Ie=r.getShaderInfoLog(H).trim(),I=!0,re=!0;if(!1===r.getProgramParameter(m,35714)){I=!1;let ce=Iee(r,A,"vertex"),fe=Iee(r,H,"fragment");console.error("THREE.WebGLProgram: Shader Error "+r.getError()+" - VALIDATE_STATUS "+r.getProgramParameter(m,35715)+"\n\nProgram Info Log: "+Ce+"\n"+ce+"\n"+fe)}else""!==Ce?console.warn("THREE.WebGLProgram: Program Info Log:",Ce):(""===Ze||""===Ie)&&(re=!1);re&&(this.diagnostics={runnable:I,programLog:Ce,vertexShader:{log:Ze,prefix:y},fragmentShader:{log:Ie,prefix:M}})}return r.deleteShader(A),r.deleteShader(H),this.getUniforms=function(){return void 0===te&&(te=new Cp(r,m)),te},this.getAttributes=function(){return void 0===K&&(K=function(n,t){let e={},i=n.getProgramParameter(t,35721);for(let r=0;r<i;r++){let o=n.getActiveAttrib(t,r),a=o.name,s=1;35674===o.type&&(s=2),35675===o.type&&(s=3),35676===o.type&&(s=4),e[a]={type:o.type,location:n.getAttribLocation(t,a),locationSize:s}}return e}(r,m)),K},this.destroy=function(){i.releaseStatesOfProgram(this),r.deleteProgram(m),this.program=void 0},this.name=e.shaderName,this.id=QOe++,this.cacheKey=t,this.usedTimes=1,this.program=m,this.vertexShader=A,this.fragmentShader=H,this}var fFe=0,AB=class{constructor(){this.shaderCache=new Map,this.materialCache=new Map}update(t){let i=t.fragmentShader,r=this._getShaderStage(t.vertexShader),o=this._getShaderStage(i),a=this._getShaderCacheForMaterial(t);return!1===a.has(r)&&(a.add(r),r.usedTimes++),!1===a.has(o)&&(a.add(o),o.usedTimes++),this}remove(t){let e=this.materialCache.get(t);for(let i of e)i.usedTimes--,0===i.usedTimes&&this.shaderCache.delete(i);return this.materialCache.delete(t),this}getVertexShaderID(t){return this._getShaderStage(t.vertexShader).id}getFragmentShaderID(t){return this._getShaderStage(t.fragmentShader).id}dispose(){this.shaderCache.clear(),this.materialCache.clear()}_getShaderCacheForMaterial(t){let e=this.materialCache;return!1===e.has(t)&&e.set(t,new Set),e.get(t)}_getShaderStage(t){let e=this.shaderCache;if(!1===e.has(t)){let i=new RB;e.set(t,i)}return e.get(t)}},RB=class{constructor(){this.id=fFe++,this.usedTimes=0}};function mFe(n,t,e,i,r,o,a){let s=new TI,l=new AB,c=[],d=r.isWebGL2,u=r.logarithmicDepthBuffer,p=r.floatVertexTextures,f=r.maxVertexUniforms,m=r.vertexTextures,y=r.precision,M={MeshDepthMaterial:"depth",MeshDistanceMaterial:"distanceRGBA",MeshNormalMaterial:"normal",MeshBasicMaterial:"basic",MeshLambertMaterial:"lambert",MeshPhongMaterial:"phong",MeshToonMaterial:"toon",MeshStandardMaterial:"physical",MeshPhysicalMaterial:"physical",MeshMatcapMaterial:"matcap",LineBasicMaterial:"basic",LineDashedMaterial:"dashed",PointsMaterial:"points",ShadowMaterial:"shadow",SpriteMaterial:"sprite"};return{getParameters:function(I,re,ce,fe,_e){let Ne,ct,wt,ft,ne=fe.fog,ue=(I.isMeshStandardMaterial?e:t).get(I.envMap||(I.isMeshStandardMaterial?fe.environment:null)),Ge=M[I.type],Me=_e.isSkinnedMesh?function(I){let ce=I.skeleton.bones;if(p)return 1024;{let _e=Math.floor((f-20)/4),ne=Math.min(_e,ce.length);return ne<ce.length?(console.warn("THREE.WebGLRenderer: Skeleton has "+ce.length+" bones. This GPU supports "+ne+"."),0):ne}}(_e):0;if(null!==I.precision&&(y=r.getMaxPrecision(I.precision),y!==I.precision&&console.warn("THREE.WebGLProgram.getParameters:",I.precision,"not supported, using",y,"instead.")),Ge){let ve=jc[Ge];Ne=ve.vertexShader,ct=ve.fragmentShader}else Ne=I.vertexShader,ct=I.fragmentShader,l.update(I),wt=l.getVertexShaderID(I),ft=l.getFragmentShaderID(I);let Oe=n.getRenderTarget(),St=I.clearcoat>0;return{isWebGL2:d,shaderID:Ge,shaderName:I.type,vertexShader:Ne,fragmentShader:ct,defines:I.defines,customVertexShaderID:wt,customFragmentShaderID:ft,isRawShaderMaterial:!0===I.isRawShaderMaterial,glslVersion:I.glslVersion,precision:y,instancing:!0===_e.isInstancedMesh,instancingColor:!0===_e.isInstancedMesh&&null!==_e.instanceColor,supportsVertexTextures:m,outputEncoding:null===Oe?n.outputEncoding:!0===Oe.isXRRenderTarget?Oe.texture.encoding:Mp,map:!!I.map,matcap:!!I.matcap,envMap:!!ue,envMapMode:ue&&ue.mapping,envMapCubeUV:!!ue&&(ue.mapping===$I||ue.mapping===FV),lightMap:!!I.lightMap,aoMap:!!I.aoMap,emissiveMap:!!I.emissiveMap,bumpMap:!!I.bumpMap,normalMap:!!I.normalMap,objectSpaceNormalMap:I.normalMapType===KAe,tangentSpaceNormalMap:I.normalMapType===y_,decodeVideoTexture:!!I.map&&!0===I.map.isVideoTexture&&I.map.encoding===Dr,clearcoat:St,clearcoatMap:St&&!!I.clearcoatMap,clearcoatRoughnessMap:St&&!!I.clearcoatRoughnessMap,clearcoatNormalMap:St&&!!I.clearcoatNormalMap,displacementMap:!!I.displacementMap,roughnessMap:!!I.roughnessMap,metalnessMap:!!I.metalnessMap,specularMap:!!I.specularMap,specularIntensityMap:!!I.specularIntensityMap,specularColorMap:!!I.specularColorMap,alphaMap:!!I.alphaMap,alphaTest:I.alphaTest>0,alphaWrite:I.alphaWrite||I.transparent,gradientMap:!!I.gradientMap,sheen:I.sheen>0,sheenColorMap:!!I.sheenColorMap,sheenRoughnessMap:!!I.sheenRoughnessMap,transmission:I.transmission>0,transmissionMap:!!I.transmissionMap,thicknessMap:!!I.thicknessMap,combine:I.combine,vertexTangents:!!I.normalMap&&!!_e.geometry&&!!_e.geometry.attributes.tangent,vertexColors:I.vertexColors,vertexAlphas:!0===I.vertexColors&&!!_e.geometry&&!!_e.geometry.attributes.color&&4===_e.geometry.attributes.color.itemSize,vertexUvs:!!(I.map||I.bumpMap||I.normalMap||I.specularMap||I.alphaMap||I.emissiveMap||I.roughnessMap||I.metalnessMap||I.clearcoatMap||I.clearcoatRoughnessMap||I.clearcoatNormalMap||I.displacementMap||I.transmissionMap||I.thicknessMap||I.specularIntensityMap||I.specularColorMap||I.sheenColorMap||I.sheenRoughnessMap),uvsVertexOnly:!(I.map||I.bumpMap||I.normalMap||I.specularMap||I.alphaMap||I.emissiveMap||I.roughnessMap||I.metalnessMap||I.clearcoatNormalMap||I.transmission>0||I.transmissionMap||I.thicknessMap||I.specularIntensityMap||I.specularColorMap||I.sheen>0||I.sheenColorMap||I.sheenRoughnessMap||!I.displacementMap),fog:!!ne,useFog:I.fog,fogExp2:ne&&ne.isFogExp2,flatShading:!!I.flatShading,sizeAttenuation:I.sizeAttenuation,logarithmicDepthBuffer:u,skinning:!0===_e.isSkinnedMesh&&Me>0,maxBones:Me,useVertexTexture:p,morphTargets:!!_e.geometry&&!!_e.geometry.morphAttributes.position,morphNormals:!!_e.geometry&&!!_e.geometry.morphAttributes.normal,morphTargetsCount:_e.geometry&&_e.geometry.morphAttributes.position?_e.geometry.morphAttributes.position.length:0,numDirLights:re.directional.length,numPointLights:re.point.length,numSpotLights:re.spot.length,numRectAreaLights:re.rectArea.length,numHemiLights:re.hemi.length,numDirLightShadows:re.directionalShadowMap.length,numPointLightShadows:re.pointShadowMap.length,numSpotLightShadows:re.spotShadowMap.length,numClippingPlanes:a.numPlanes,numClipIntersection:a.numIntersection,dithering:I.dithering,shadowMapEnabled:n.shadowMap.enabled&&ce.length>0,shadowMapType:n.shadowMap.type,toneMapping:I.toneMapped?n.toneMapping:bp,physicallyCorrectLights:n.physicallyCorrectLights,premultipliedAlpha:I.premultipliedAlpha,doubleSided:I.side===o_,flipSided:I.side===yo,depthPacking:void 0!==I.depthPacking&&I.depthPacking,index0AttributeName:I.index0AttributeName,extensionDerivatives:I.extensions&&I.extensions.derivatives,extensionFragDepth:I.extensions&&I.extensions.fragDepth,extensionDrawBuffers:I.extensions&&I.extensions.drawBuffers,extensionShaderTextureLOD:I.extensions&&I.extensions.shaderTextureLOD,rendererExtensionFragDepth:d||i.has("EXT_frag_depth"),rendererExtensionDrawBuffers:d||i.has("WEBGL_draw_buffers"),rendererExtensionShaderTextureLod:d||i.has("EXT_shader_texture_lod"),customProgramCacheKey:I.customProgramCacheKey()}},getProgramCacheKey:function(I){let re=[];if(I.shaderID?re.push(I.shaderID):(re.push(I.customVertexShaderID),re.push(I.customFragmentShaderID)),void 0!==I.defines)for(let ce in I.defines)re.push(ce),re.push(I.defines[ce]);return!1===I.isRawShaderMaterial&&(function(I,re){I.push(re.precision),I.push(re.outputEncoding),I.push(re.envMapMode),I.push(re.combine),I.push(re.vertexUvs),I.push(re.fogExp2),I.push(re.sizeAttenuation),I.push(re.maxBones),I.push(re.morphTargetsCount),I.push(re.numDirLights),I.push(re.numPointLights),I.push(re.numSpotLights),I.push(re.numHemiLights),I.push(re.numRectAreaLights),I.push(re.numDirLightShadows),I.push(re.numPointLightShadows),I.push(re.numSpotLightShadows),I.push(re.shadowMapType),I.push(re.toneMapping),I.push(re.numClippingPlanes),I.push(re.numClipIntersection),I.push(re.alphaWrite)}(re,I),function(I,re){s.disableAll(),re.isWebGL2&&s.enable(0),re.supportsVertexTextures&&s.enable(1),re.instancing&&s.enable(2),re.instancingColor&&s.enable(3),re.map&&s.enable(4),re.matcap&&s.enable(5),re.envMap&&s.enable(6),re.envMapCubeUV&&s.enable(7),re.lightMap&&s.enable(8),re.aoMap&&s.enable(9),re.emissiveMap&&s.enable(10),re.bumpMap&&s.enable(11),re.normalMap&&s.enable(12),re.objectSpaceNormalMap&&s.enable(13),re.tangentSpaceNormalMap&&s.enable(14),re.clearcoat&&s.enable(15),re.clearcoatMap&&s.enable(16),re.clearcoatRoughnessMap&&s.enable(17),re.clearcoatNormalMap&&s.enable(18),re.displacementMap&&s.enable(19),re.specularMap&&s.enable(20),re.roughnessMap&&s.enable(21),re.metalnessMap&&s.enable(22),re.gradientMap&&s.enable(23),re.alphaMap&&s.enable(24),re.alphaTest&&s.enable(25),re.vertexColors&&s.enable(26),re.vertexAlphas&&s.enable(27),re.vertexUvs&&s.enable(28),re.vertexTangents&&s.enable(29),re.uvsVertexOnly&&s.enable(30),re.fog&&s.enable(31),I.push(s.mask),s.disableAll(),re.useFog&&s.enable(0),re.flatShading&&s.enable(1),re.logarithmicDepthBuffer&&s.enable(2),re.skinning&&s.enable(3),re.useVertexTexture&&s.enable(4),re.morphTargets&&s.enable(5),re.morphNormals&&s.enable(6),re.premultipliedAlpha&&s.enable(7),re.shadowMapEnabled&&s.enable(8),re.physicallyCorrectLights&&s.enable(9),re.doubleSided&&s.enable(10),re.flipSided&&s.enable(11),re.depthPacking&&s.enable(12),re.dithering&&s.enable(13),re.specularIntensityMap&&s.enable(14),re.specularColorMap&&s.enable(15),re.transmission&&s.enable(16),re.transmissionMap&&s.enable(17),re.thicknessMap&&s.enable(18),re.sheen&&s.enable(19),re.sheenColorMap&&s.enable(20),re.sheenRoughnessMap&&s.enable(21),re.decodeVideoTexture&&s.enable(22),I.push(s.mask)}(re,I),re.push(n.outputEncoding)),re.push(I.customProgramCacheKey),re.join()},getUniforms:function(I){let ce,re=M[I.type];return ce=re?pRe.clone(jc[re].uniforms):I.uniforms,ce},acquireProgram:function(I,re){let ce;for(let fe=0,_e=c.length;fe<_e;fe++){let ne=c[fe];if(ne.cacheKey===re){ce=ne,++ce.usedTimes;break}}return void 0===ce&&(ce=new pFe(n,re,I,o),c.push(ce)),ce},releaseProgram:function(I){if(0==--I.usedTimes){let re=c.indexOf(I);c[re]=c[c.length-1],c.pop(),I.destroy()}},releaseShaderCache:function(I){l.remove(I)},programs:c,dispose:function(){l.dispose()}}}function hFe(){let n=new WeakMap;return{get:function(o){let a=n.get(o);return void 0===a&&(a={},n.set(o,a)),a},remove:function(o){n.delete(o)},update:function(o,a,s){n.get(o)[a]=s},dispose:function(){n=new WeakMap}}}function gFe(n,t){return n.groupOrder!==t.groupOrder?n.groupOrder-t.groupOrder:n.renderOrder!==t.renderOrder?n.renderOrder-t.renderOrder:n.material.id!==t.material.id?n.material.id-t.material.id:n.z!==t.z?n.z-t.z:n.id-t.id}function Oee(n,t){return n.groupOrder!==t.groupOrder?n.groupOrder-t.groupOrder:n.renderOrder!==t.renderOrder?n.renderOrder-t.renderOrder:n.z!==t.z?t.z-n.z:n.id-t.id}function Fee(){let n=[],t=0,e=[],i=[],r=[];function a(u,p,f,m,y,M){let v=n[t];return void 0===v?(v={id:u.id,object:u,geometry:p,material:f,groupOrder:m,renderOrder:u.renderOrder,z:y,group:M},n[t]=v):(v.id=u.id,v.object=u,v.geometry=p,v.material=f,v.groupOrder=m,v.renderOrder=u.renderOrder,v.z=y,v.group=M),t++,v}return{opaque:e,transmissive:i,transparent:r,init:function(){t=0,e.length=0,i.length=0,r.length=0},push:function(u,p,f,m,y,M){let v=a(u,p,f,m,y,M);f.transmission>0?i.push(v):!0===f.transparent?r.push(v):e.push(v)},unshift:function(u,p,f,m,y,M){let v=a(u,p,f,m,y,M);f.transmission>0?i.unshift(v):!0===f.transparent?r.unshift(v):e.unshift(v)},finish:function(){for(let u=t,p=n.length;u<p;u++){let f=n[u];if(null===f.id)break;f.id=null,f.object=null,f.geometry=null,f.material=null,f.group=null}},sort:function(u,p){e.length>1&&e.sort(u||gFe),i.length>1&&i.sort(p||Oee),r.length>1&&r.sort(p||Oee)}}}function _Fe(){let n=new WeakMap;return{get:function(i,r){let o;return!1===n.has(i)?(o=new Fee,n.set(i,[o])):r>=n.get(i).length?(o=new Fee,n.get(i).push(o)):o=n.get(i)[r],o},dispose:function(){n=new WeakMap}}}function yFe(){let n={};return{get:function(t){if(void 0!==n[t.id])return n[t.id];let e;switch(t.type){case"DirectionalLight":e={direction:new $,color:new an};break;case"SpotLight":e={position:new $,direction:new $,color:new an,distance:0,coneCos:0,penumbraCos:0,decay:0};break;case"PointLight":e={position:new $,color:new an,distance:0,decay:0};break;case"HemisphereLight":e={direction:new $,skyColor:new an,groundColor:new an};break;case"RectAreaLight":e={color:new an,position:new $,halfWidth:new $,halfHeight:new $}}return n[t.id]=e,e}}}var vFe=0;function xFe(n,t){return(t.castShadow?1:0)-(n.castShadow?1:0)}function CFe(n,t){let e=new yFe,i=function(){let n={};return{get:function(t){if(void 0!==n[t.id])return n[t.id];let e;switch(t.type){case"DirectionalLight":case"SpotLight":e={shadowBias:0,shadowNormalBias:0,shadowRadius:1,shadowMapSize:new $e};break;case"PointLight":e={shadowBias:0,shadowNormalBias:0,shadowRadius:1,shadowMapSize:new $e,shadowCameraNear:1,shadowCameraFar:1e3}}return n[t.id]=e,e}}}(),r={version:0,hash:{directionalLength:-1,pointLength:-1,spotLength:-1,rectAreaLength:-1,hemiLength:-1,numDirectionalShadows:-1,numPointShadows:-1,numSpotShadows:-1},ambient:[0,0,0],probe:[],directional:[],directionalShadow:[],directionalShadowMap:[],directionalShadowMatrix:[],spot:[],spotShadow:[],spotShadowMap:[],spotShadowMatrix:[],rectArea:[],rectAreaLTC1:null,rectAreaLTC2:null,point:[],pointShadow:[],pointShadowMap:[],pointShadowMatrix:[],hemi:[]};for(let d=0;d<9;d++)r.probe.push(new $);let o=new $,a=new Mn,s=new Mn;return{setup:function(d,u){let p=0,f=0,m=0;for(let Ze=0;Ze<9;Ze++)r.probe[Ze].set(0,0,0);let y=0,M=0,v=0,x=0,R=0,A=0,H=0,te=0;d.sort(xFe);let K=!0!==u?Math.PI:1;for(let Ze=0,Ie=d.length;Ze<Ie;Ze++){let I=d[Ze],re=I.color,ce=I.intensity,fe=I.distance,_e=I.shadow&&I.shadow.map?I.shadow.map.texture:null;if(I.isAmbientLight)p+=re.r*ce*K,f+=re.g*ce*K,m+=re.b*ce*K;else if(I.isLightProbe)for(let ne=0;ne<9;ne++)r.probe[ne].addScaledVector(I.sh.coefficients[ne],ce);else if(I.isDirectionalLight){let ne=e.get(I);if(ne.color.copy(I.color).multiplyScalar(I.intensity*K),I.castShadow){let de=I.shadow,ue=i.get(I);ue.shadowBias=de.bias,ue.shadowNormalBias=de.normalBias,ue.shadowRadius=de.radius,ue.shadowMapSize=de.mapSize,r.directionalShadow[y]=ue,r.directionalShadowMap[y]=_e,r.directionalShadowMatrix[y]=I.shadow.matrix,A++}r.directional[y]=ne,y++}else if(I.isSpotLight){let ne=e.get(I);if(ne.position.setFromMatrixPosition(I.matrixWorld),ne.color.copy(re).multiplyScalar(ce*K),ne.distance=fe,ne.coneCos=Math.cos(I.angle),ne.penumbraCos=Math.cos(I.angle*(1-I.penumbra)),ne.decay=I.decay,I.castShadow){let de=I.shadow,ue=i.get(I);ue.shadowBias=de.bias,ue.shadowNormalBias=de.normalBias,ue.shadowRadius=de.radius,ue.shadowMapSize=de.mapSize,r.spotShadow[v]=ue,r.spotShadowMap[v]=_e,r.spotShadowMatrix[v]=I.shadow.matrix,te++}r.spot[v]=ne,v++}else if(I.isRectAreaLight){let ne=e.get(I);ne.color.copy(re).multiplyScalar(ce),ne.halfWidth.set(.5*I.width,0,0),ne.halfHeight.set(0,.5*I.height,0),r.rectArea[x]=ne,x++}else if(I.isPointLight){let ne=e.get(I);if(ne.color.copy(I.color).multiplyScalar(I.intensity*K),ne.distance=I.distance,ne.decay=I.decay,I.castShadow){let de=I.shadow,ue=i.get(I);ue.shadowBias=de.bias,ue.shadowNormalBias=de.normalBias,ue.shadowRadius=de.radius,ue.shadowMapSize=de.mapSize,ue.shadowCameraNear=de.camera.near,ue.shadowCameraFar=de.camera.far,r.pointShadow[M]=ue,r.pointShadowMap[M]=_e,r.pointShadowMatrix[M]=I.shadow.matrix,H++}r.point[M]=ne,M++}else if(I.isHemisphereLight){let ne=e.get(I);ne.skyColor.copy(I.color).multiplyScalar(ce*K),ne.groundColor.copy(I.groundColor).multiplyScalar(ce*K),r.hemi[R]=ne,R++}}x>0&&(t.isWebGL2||!0===n.has("OES_texture_float_linear")?(r.rectAreaLTC1=Pt.LTC_FLOAT_1,r.rectAreaLTC2=Pt.LTC_FLOAT_2):!0===n.has("OES_texture_half_float_linear")?(r.rectAreaLTC1=Pt.LTC_HALF_1,r.rectAreaLTC2=Pt.LTC_HALF_2):console.error("THREE.WebGLRenderer: Unable to use RectAreaLight. Missing WebGL extensions.")),r.ambient[0]=p,r.ambient[1]=f,r.ambient[2]=m;let Ce=r.hash;(Ce.directionalLength!==y||Ce.pointLength!==M||Ce.spotLength!==v||Ce.rectAreaLength!==x||Ce.hemiLength!==R||Ce.numDirectionalShadows!==A||Ce.numPointShadows!==H||Ce.numSpotShadows!==te)&&(r.directional.length=y,r.spot.length=v,r.rectArea.length=x,r.point.length=M,r.hemi.length=R,r.directionalShadow.length=A,r.directionalShadowMap.length=A,r.pointShadow.length=H,r.pointShadowMap.length=H,r.spotShadow.length=te,r.spotShadowMap.length=te,r.directionalShadowMatrix.length=A,r.pointShadowMatrix.length=H,r.spotShadowMatrix.length=te,Ce.directionalLength=y,Ce.pointLength=M,Ce.spotLength=v,Ce.rectAreaLength=x,Ce.hemiLength=R,Ce.numDirectionalShadows=A,Ce.numPointShadows=H,Ce.numSpotShadows=te,r.version=vFe++)},setupView:function(d,u){let p=0,f=0,m=0,y=0,M=0,v=u.matrixWorldInverse;for(let x=0,R=d.length;x<R;x++){let A=d[x];if(A.isDirectionalLight){let H=r.directional[p];H.direction.setFromMatrixPosition(A.matrixWorld),o.setFromMatrixPosition(A.target.matrixWorld),H.direction.sub(o),H.direction.transformDirection(v),p++}else if(A.isSpotLight){let H=r.spot[m];H.position.setFromMatrixPosition(A.matrixWorld),H.position.applyMatrix4(v),H.direction.setFromMatrixPosition(A.matrixWorld),o.setFromMatrixPosition(A.target.matrixWorld),H.direction.sub(o),H.direction.transformDirection(v),m++}else if(A.isRectAreaLight){let H=r.rectArea[y];H.position.setFromMatrixPosition(A.matrixWorld),H.position.applyMatrix4(v),s.identity(),a.copy(A.matrixWorld),a.premultiply(v),s.extractRotation(a),H.halfWidth.set(.5*A.width,0,0),H.halfHeight.set(0,.5*A.height,0),H.halfWidth.applyMatrix4(s),H.halfHeight.applyMatrix4(s),y++}else if(A.isPointLight){let H=r.point[f];H.position.setFromMatrixPosition(A.matrixWorld),H.position.applyMatrix4(v),f++}else if(A.isHemisphereLight){let H=r.hemi[M];H.direction.setFromMatrixPosition(A.matrixWorld),H.direction.transformDirection(v),H.direction.normalize(),M++}}},state:r}}function Lee(n,t){let e=new CFe(n,t),i=[],r=[];return{init:function(){i.length=0,r.length=0},state:{lightsArray:i,shadowsArray:r,lights:e},setupLights:function(u){e.setup(i,u)},setupLightsView:function(u){e.setupView(i,u)},pushLight:function(u){i.push(u)},pushShadow:function(u){r.push(u)}}}function MFe(n,t){let e=new WeakMap;return{get:function(o,a=0){let s;return!1===e.has(o)?(s=new Lee(n,t),e.set(o,[s])):a>=e.get(o).length?(s=new Lee(n,t),e.get(o).push(s)):s=e.get(o)[a],s},dispose:function(){e=new WeakMap}}}var PI=class extends Ro{constructor(t){super(),this.type="MeshDepthMaterial",this.depthPacking=3200,this.map=null,this.alphaMap=null,this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.wireframe=!1,this.wireframeLinewidth=1,this.fog=!1,this.setValues(t)}copy(t){return super.copy(t),this.depthPacking=t.depthPacking,this.map=t.map,this.alphaMap=t.alphaMap,this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this}};PI.prototype.isMeshDepthMaterial=!0;var OI=class extends Ro{constructor(t){super(),this.type="MeshDistanceMaterial",this.referencePosition=new $,this.nearDistance=1,this.farDistance=1e3,this.map=null,this.alphaMap=null,this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.fog=!1,this.setValues(t)}copy(t){return super.copy(t),this.referencePosition.copy(t.referencePosition),this.nearDistance=t.nearDistance,this.farDistance=t.farDistance,this.map=t.map,this.alphaMap=t.alphaMap,this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this}};OI.prototype.isMeshDistanceMaterial=!0;var wFe="void main() {\n\tgl_Position = vec4( position, 1.0 );\n}",SFe="uniform sampler2D shadow_pass;\nuniform vec2 resolution;\nuniform float radius;\n#include <packing>\nvoid main() {\n\tconst float samples = float( VSM_SAMPLES );\n\tfloat mean = 0.0;\n\tfloat squared_mean = 0.0;\n\tfloat uvStride = samples <= 1.0 ? 0.0 : 2.0 / ( samples - 1.0 );\n\tfloat uvStart = samples <= 1.0 ? 0.0 : - 1.0;\n\tfor ( float i = 0.0; i < samples; i ++ ) {\n\t\tfloat uvOffset = uvStart + i * uvStride;\n\t\t#ifdef HORIZONTAL_PASS\n\t\t\tvec2 distribution = unpackRGBATo2Half( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( uvOffset, 0.0 ) * radius ) / resolution ) );\n\t\t\tmean += distribution.x;\n\t\t\tsquared_mean += distribution.y * distribution.y + distribution.x * distribution.x;\n\t\t#else\n\t\t\tfloat depth = unpackRGBAToDepth( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( 0.0, uvOffset ) * radius ) / resolution ) );\n\t\t\tmean += depth;\n\t\t\tsquared_mean += depth * depth;\n\t\t#endif\n\t}\n\tmean = mean / samples;\n\tsquared_mean = squared_mean / samples;\n\tfloat std_dev = sqrt( squared_mean - mean * mean );\n\tgl_FragColor = pack2HalfToRGBA( vec2( mean, std_dev ) );\n}";function Ste(n,t,e){let i=new c_,r=new $e,o=new $e,a=new Ki,s=new PI({depthPacking:ZAe}),l=new OI,c={},d=e.maxTextureSize,u={0:yo,1:Sx,2:o_},p=new Gd({defines:{VSM_SAMPLES:8},uniforms:{shadow_pass:{value:null},resolution:{value:new $e},radius:{value:4}},vertexShader:wFe,fragmentShader:SFe}),f=p.clone();f.defines.HORIZONTAL_PASS=1;let m=new Wi;m.setAttribute("position",new Ar(new Float32Array([-1,-1,.5,3,-1,.5,-1,3,.5]),3));let y=new co(m,p),M=this;function v(A,H){let te=t.update(y);p.defines.VSM_SAMPLES!==A.blurSamples&&(p.defines.VSM_SAMPLES=A.blurSamples,f.defines.VSM_SAMPLES=A.blurSamples,p.needsUpdate=!0,f.needsUpdate=!0),p.uniforms.shadow_pass.value=A.map.texture,p.uniforms.resolution.value=A.mapSize,p.uniforms.radius.value=A.radius,n.setRenderTarget(A.mapPass),n.clear(),n.renderBufferDirect(H,null,te,p,y,null),f.uniforms.shadow_pass.value=A.mapPass.texture,f.uniforms.resolution.value=A.mapSize,f.uniforms.radius.value=A.radius,n.setRenderTarget(A.map),n.clear(),n.renderBufferDirect(H,null,te,f,y,null)}function x(A,H,te,K,Ce,Ze,Ie){let I=null,re=!0===K.isPointLight?A.customDistanceMaterial:A.customDepthMaterial;if(I=void 0!==re?re:!0===K.isPointLight?l:s,n.localClippingEnabled&&!0===te.clipShadows&&0!==te.clippingPlanes.length||te.displacementMap&&0!==te.displacementScale||te.alphaMap&&te.alphaTest>0){let ce=I.uuid,fe=te.uuid,_e=c[ce];void 0===_e&&(_e={},c[ce]=_e);let ne=_e[fe];void 0===ne&&(ne=I.clone(),_e[fe]=ne),I=ne}return I.visible=te.visible,I.wireframe=te.wireframe,I.side=Ie===bx?null!==te.shadowSide?te.shadowSide:te.side:null!==te.shadowSide?te.shadowSide:u[te.side],I.alphaMap=te.alphaMap,I.alphaTest=te.alphaTest,I.clipShadows=te.clipShadows,I.clippingPlanes=te.clippingPlanes,I.clipIntersection=te.clipIntersection,I.displacementMap=te.displacementMap,I.displacementScale=te.displacementScale,I.displacementBias=te.displacementBias,I.wireframeLinewidth=te.wireframeLinewidth,I.linewidth=te.linewidth,!0===K.isPointLight&&!0===I.isMeshDistanceMaterial&&(I.referencePosition.setFromMatrixPosition(K.matrixWorld),I.nearDistance=Ce,I.farDistance=Ze),I}function R(A,H,te,K,Ce){if(!1===A.visible)return;if(A.layers.test(H.layers)&&(A.isMesh||A.isLine||A.isPoints)&&(A.castShadow||A.receiveShadow&&Ce===bx)&&(!A.frustumCulled||i.intersectsObject(A))){A.modelViewMatrix.multiplyMatrices(te.matrixWorldInverse,A.matrixWorld);let I=t.update(A),re=A.material;if(Array.isArray(re)){let ce=I.groups;for(let fe=0,_e=ce.length;fe<_e;fe++){let ne=ce[fe],de=re[ne.materialIndex];if(de&&de.visible){let ue=x(A,0,de,K,te.near,te.far,Ce);n.renderBufferDirect(te,null,I,ue,A,ne)}}}else if(re.visible){let ce=x(A,0,re,K,te.near,te.far,Ce);n.renderBufferDirect(te,null,I,ce,A,null)}}let Ie=A.children;for(let I=0,re=Ie.length;I<re;I++)R(Ie[I],H,te,K,Ce)}this.enabled=!1,this.autoUpdate=!0,this.needsUpdate=!1,this.type=lte,this.render=function(A,H,te){if(!1===M.enabled||!1===M.autoUpdate&&!1===M.needsUpdate||0===A.length)return;let K=n.getRenderTarget(),Ce=n.getActiveCubeFace(),Ze=n.getActiveMipmapLevel(),Ie=n.state;Ie.setBlending(yp),Ie.buffers.color.setClear(1,1,1,1),Ie.buffers.depth.setTest(!0),Ie.setScissorTest(!1);for(let I=0,re=A.length;I<re;I++){let ce=A[I],fe=ce.shadow;if(void 0===fe){console.warn("THREE.WebGLShadowMap:",ce,"has no shadow.");continue}if(!1===fe.autoUpdate&&!1===fe.needsUpdate)continue;r.copy(fe.mapSize);let _e=fe.getFrameExtents();if(r.multiply(_e),o.copy(fe.mapSize),(r.x>d||r.y>d)&&(r.x>d&&(o.x=Math.floor(d/_e.x),r.x=o.x*_e.x,fe.mapSize.x=o.x),r.y>d&&(o.y=Math.floor(d/_e.y),r.y=o.y*_e.y,fe.mapSize.y=o.y)),null===fe.map&&!fe.isPointLightShadow&&this.type===bx){let de={minFilter:ra,magFilter:ra,format:ba};fe.map=new Qa(r.x,r.y,de),fe.map.texture.name=ce.name+".shadowMap",fe.mapPass=new Qa(r.x,r.y,de),fe.camera.updateProjectionMatrix()}null===fe.map&&(fe.map=new Qa(r.x,r.y,{minFilter:bo,magFilter:bo,format:ba}),fe.map.texture.name=ce.name+".shadowMap",fe.camera.updateProjectionMatrix()),n.setRenderTarget(fe.map),n.clear();let ne=fe.getViewportCount();for(let de=0;de<ne;de++){let ue=fe.getViewport(de);a.set(o.x*ue.x,o.y*ue.y,o.x*ue.z,o.y*ue.w),Ie.viewport(a),fe.updateMatrices(ce,de),i=fe.getFrustum(),R(H,te,fe.camera,ce,this.type)}!fe.isPointLightShadow&&this.type===bx&&v(fe,te),fe.needsUpdate=!1}M.needsUpdate=!1,n.setRenderTarget(K,Ce,Ze)}}function EFe(n,t,e){let i=e.isWebGL2,s=new function(){let se=!1,tn=new Ki,Wt=null,In=new Ki(0,0,0,0);return{setMask:function(We){Wt!==We&&!se&&(n.colorMask(We,We,We,We),Wt=We)},setLocked:function(We){se=We},setClear:function(We,vn,hi,ur,Uo){!0===Uo&&(We*=ur,vn*=ur,hi*=ur),tn.set(We,vn,hi,ur),!1===In.equals(tn)&&(n.clearColor(We,vn,hi,ur),In.copy(tn))},reset:function(){se=!1,Wt=null,In.set(-1,0,0,0)}}},l=new function(){let se=!1,tn=null,Wt=null,In=null;return{setTest:function(We){We?Oe(2929):An(2929)},setMask:function(We){tn!==We&&!se&&(n.depthMask(We),tn=We)},setFunc:function(We){if(Wt!==We){if(We)switch(We){case gAe:n.depthFunc(512);break;case _Ae:n.depthFunc(519);break;case yAe:n.depthFunc(513);break;case vB:n.depthFunc(515);break;case bAe:n.depthFunc(514);break;case vAe:n.depthFunc(518);break;case xAe:n.depthFunc(516);break;case CAe:n.depthFunc(517);break;default:n.depthFunc(515)}else n.depthFunc(515);Wt=We}},setLocked:function(We){se=We},setClear:function(We){In!==We&&(n.clearDepth(We),In=We)},reset:function(){se=!1,tn=null,Wt=null,In=null}}},c=new function(){let se=!1,tn=null,Wt=null,In=null,We=null,vn=null,hi=null,ur=null,Uo=null;return{setTest:function(vr){se||(vr?Oe(2960):An(2960))},setMask:function(vr){tn!==vr&&!se&&(n.stencilMask(vr),tn=vr)},setFunc:function(vr,bs,Ca){(Wt!==vr||In!==bs||We!==Ca)&&(n.stencilFunc(vr,bs,Ca),Wt=vr,In=bs,We=Ca)},setOp:function(vr,bs,Ca){(vn!==vr||hi!==bs||ur!==Ca)&&(n.stencilOp(vr,bs,Ca),vn=vr,hi=bs,ur=Ca)},setLocked:function(vr){se=vr},setClear:function(vr){Uo!==vr&&(n.clearStencil(vr),Uo=vr)},reset:function(){se=!1,tn=null,Wt=null,In=null,We=null,vn=null,hi=null,ur=null,Uo=null}}},d={},u={},p=new WeakMap,f=[],m=null,y=!1,M=null,v=null,x=null,R=null,A=null,H=null,te=null,K=!1,Ce=null,Ze=null,Ie=null,I=null,re=null,ce=n.getParameter(35661),fe=!1,_e=0,ne=n.getParameter(7938);-1!==ne.indexOf("WebGL")?(_e=parseFloat(/^WebGL (\d)/.exec(ne)[1]),fe=_e>=1):-1!==ne.indexOf("OpenGL ES")&&(_e=parseFloat(/^OpenGL ES (\d)/.exec(ne)[1]),fe=_e>=2);let de=null,ue={},Ge=n.getParameter(3088),Me=n.getParameter(2978),Ne=(new Ki).fromArray(Ge),ct=(new Ki).fromArray(Me);function wt(se,tn,Wt){let In=new Uint8Array(4),We=n.createTexture();n.bindTexture(se,We),n.texParameteri(se,10241,9728),n.texParameteri(se,10240,9728);for(let vn=0;vn<Wt;vn++)n.texImage2D(tn+vn,0,6408,1,1,0,6408,5121,In);return We}let ft={};function Oe(se){!0!==d[se]&&(n.enable(se),d[se]=!0)}function An(se){!1!==d[se]&&(n.disable(se),d[se]=!1)}ft[3553]=wt(3553,3553,1),ft[34067]=wt(34067,34069,6),s.setClear(0,0,0,1),l.setClear(1),c.setClear(0),Oe(2929),l.setFunc(vB),Xe(!1),_t(E$),Oe(2884),oe(yp);let ht={[K0]:32774,[oAe]:32778,[aAe]:32779};if(i)ht[A$]=32775,ht[R$]=32776;else{let se=t.get("EXT_blend_minmax");null!==se&&(ht[A$]=se.MIN_EXT,ht[R$]=se.MAX_EXT)}let mt={[sAe]:0,[lAe]:1,[cAe]:768,[dte]:770,[hAe]:776,[fAe]:774,[uAe]:772,[dAe]:769,[ute]:771,[mAe]:775,[pAe]:773};function oe(se,tn,Wt,In,We,vn,hi,ur){if(se!==yp){if(!1===y&&(Oe(3042),y=!0),se===rAe)We=We||tn,vn=vn||Wt,hi=hi||In,(tn!==v||We!==A)&&(n.blendEquationSeparate(ht[tn],ht[We]),v=tn,A=We),(Wt!==x||In!==R||vn!==H||hi!==te)&&(n.blendFuncSeparate(mt[Wt],mt[In],mt[vn],mt[hi]),x=Wt,R=In,H=vn,te=hi),M=se,K=null;else if(se!==M||ur!==K){if((v!==K0||A!==K0)&&(n.blendEquation(32774),v=K0,A=K0),ur)switch(se){case xx:n.blendFuncSeparate(1,771,1,771);break;case T$:n.blendFunc(1,1);break;case D$:n.blendFuncSeparate(0,769,0,1);break;case I$:n.blendFuncSeparate(0,768,0,770);break;default:console.error("THREE.WebGLState: Invalid blending: ",se)}else switch(se){case xx:n.blendFuncSeparate(770,771,1,771);break;case T$:n.blendFunc(770,1);break;case D$:n.blendFuncSeparate(0,769,0,1);break;case I$:n.blendFunc(0,768);break;default:console.error("THREE.WebGLState: Invalid blending: ",se)}x=null,R=null,H=null,te=null,M=se,K=ur}}else!0===y&&(An(3042),y=!1)}function Xe(se){Ce!==se&&(n.frontFace(se?2304:2305),Ce=se)}function _t(se){se!==tAe?(Oe(2884),se!==Ze&&n.cullFace(se===E$?1029:se===nAe?1028:1032)):An(2884),Ze=se}function on(se,tn,Wt){se?(Oe(32823),(I!==tn||re!==Wt)&&(n.polygonOffset(tn,Wt),I=tn,re=Wt)):An(32823)}function ii(se){void 0===se&&(se=33984+ce-1),de!==se&&(n.activeTexture(se),de=se)}return{buffers:{color:s,depth:l,stencil:c},enable:Oe,disable:An,bindFramebuffer:function(se,tn){return u[se]!==tn&&(n.bindFramebuffer(se,tn),u[se]=tn,i&&(36009===se&&(u[36160]=tn),36160===se&&(u[36009]=tn)),!0)},drawBuffers:function(se,tn){let Wt=f,In=!1;if(se)if(Wt=p.get(tn),void 0===Wt&&(Wt=[],p.set(tn,Wt)),se.isWebGLMultipleRenderTargets){let We=se.texture;if(Wt.length!==We.length||36064!==Wt[0]){for(let vn=0,hi=We.length;vn<hi;vn++)Wt[vn]=36064+vn;Wt.length=We.length,In=!0}}else 36064!==Wt[0]&&(Wt[0]=36064,In=!0);else 1029!==Wt[0]&&(Wt[0]=1029,In=!0);In&&(e.isWebGL2?n.drawBuffers(Wt):t.get("WEBGL_draw_buffers").drawBuffersWEBGL(Wt))},useProgram:function(se){return m!==se&&(n.useProgram(se),m=se,!0)},setBlending:oe,setMaterial:function(se,tn){se.side===o_?An(2884):Oe(2884);let Wt=se.side===yo;tn&&(Wt=!Wt),Xe(Wt),se.blending===xx&&!1===se.transparent?oe(yp):oe(se.blending,se.blendEquation,se.blendSrc,se.blendDst,se.blendEquationAlpha,se.blendSrcAlpha,se.blendDstAlpha,se.premultipliedAlpha),l.setFunc(se.depthFunc),l.setTest(se.depthTest),l.setMask(se.depthWrite),s.setMask(se.colorWrite);let In=se.stencilWrite;c.setTest(In),In&&(c.setMask(se.stencilWriteMask),c.setFunc(se.stencilFunc,se.stencilRef,se.stencilFuncMask),c.setOp(se.stencilFail,se.stencilZFail,se.stencilZPass)),on(se.polygonOffset,se.polygonOffsetFactor,se.polygonOffsetUnits),!0===se.alphaToCoverage?Oe(32926):An(32926)},setFlipSided:Xe,setCullFace:_t,setLineWidth:function(se){se!==Ie&&(fe&&n.lineWidth(se),Ie=se)},setPolygonOffset:on,setScissorTest:function(se){se?Oe(3089):An(3089)},activeTexture:ii,bindTexture:function(se,tn){null===de&&ii();let Wt=ue[de];void 0===Wt&&(Wt={type:void 0,texture:void 0},ue[de]=Wt),(Wt.type!==se||Wt.texture!==tn)&&(n.bindTexture(se,tn||ft[se]),Wt.type=se,Wt.texture=tn)},unbindTexture:function(){let se=ue[de];void 0!==se&&void 0!==se.type&&(n.bindTexture(se.type,null),se.type=void 0,se.texture=void 0)},compressedTexImage2D:function(){try{n.compressedTexImage2D.apply(n,arguments)}catch(se){console.error("THREE.WebGLState:",se)}},texImage2D:function(){try{n.texImage2D.apply(n,arguments)}catch(se){console.error("THREE.WebGLState:",se)}},texImage3D:function(){try{n.texImage3D.apply(n,arguments)}catch(se){console.error("THREE.WebGLState:",se)}},texStorage2D:function(){try{n.texStorage2D.apply(n,arguments)}catch(se){console.error("THREE.WebGLState:",se)}},texStorage3D:function(){try{n.texStorage3D.apply(n,arguments)}catch(se){console.error("THREE.WebGLState:",se)}},texSubImage2D:function(){try{n.texSubImage2D.apply(n,arguments)}catch(se){console.error("THREE.WebGLState:",se)}},texSubImage3D:function(){try{n.texSubImage3D.apply(n,arguments)}catch(se){console.error("THREE.WebGLState:",se)}},compressedTexSubImage2D:function(){try{n.compressedTexSubImage2D.apply(n,arguments)}catch(se){console.error("THREE.WebGLState:",se)}},scissor:function(se){!1===Ne.equals(se)&&(n.scissor(se.x,se.y,se.z,se.w),Ne.copy(se))},viewport:function(se){!1===ct.equals(se)&&(n.viewport(se.x,se.y,se.z,se.w),ct.copy(se))},reset:function(){n.disable(3042),n.disable(2884),n.disable(2929),n.disable(32823),n.disable(3089),n.disable(2960),n.disable(32926),n.blendEquation(32774),n.blendFunc(1,0),n.blendFuncSeparate(1,0,1,0),n.colorMask(!0,!0,!0,!0),n.clearColor(0,0,0,0),n.depthMask(!0),n.depthFunc(513),n.clearDepth(1),n.stencilMask(4294967295),n.stencilFunc(519,0,4294967295),n.stencilOp(7680,7680,7680),n.clearStencil(0),n.cullFace(1029),n.frontFace(2305),n.polygonOffset(0,0),n.activeTexture(33984),n.bindFramebuffer(36160,null),!0===i&&(n.bindFramebuffer(36009,null),n.bindFramebuffer(36008,null)),n.useProgram(null),n.lineWidth(1),n.scissor(0,0,n.canvas.width,n.canvas.height),n.viewport(0,0,n.canvas.width,n.canvas.height),d={},de=null,ue={},u={},p=new WeakMap,f=[],m=null,y=!1,M=null,v=null,x=null,R=null,A=null,H=null,te=null,K=!1,Ce=null,Ze=null,Ie=null,I=null,re=null,Ne.set(0,0,n.canvas.width,n.canvas.height),ct.set(0,0,n.canvas.width,n.canvas.height),s.reset(),l.reset(),c.reset()}}}function TFe(n,t,e,i,r,o,a){let y,s=r.isWebGL2,l=r.maxTextures,c=r.maxCubemapSize,d=r.maxTextureSize,u=r.maxSamples,f=t.has("WEBGL_multisampled_render_to_texture")?t.get("WEBGL_multisampled_render_to_texture"):void 0,m=new WeakMap,M=!1;try{M=typeof OffscreenCanvas<"u"&&null!==new OffscreenCanvas(1,1).getContext("2d")}catch{}function v(Z,N){return M?new OffscreenCanvas(Z,N):Dx("canvas")}function x(Z,N,He,yt){let nn=1;if((Z.width>yt||Z.height>yt)&&(nn=yt/Math.max(Z.width,Z.height)),nn<1||!0===N){if(typeof HTMLImageElement<"u"&&Z instanceof HTMLImageElement||typeof HTMLCanvasElement<"u"&&Z instanceof HTMLCanvasElement||typeof ImageBitmap<"u"&&Z instanceof ImageBitmap){let Be=N?eRe:Math.floor,mn=Be(nn*Z.width),sn=Be(nn*Z.height);void 0===y&&(y=v(mn,sn));let Nt=He?v(mn,sn):y;return Nt.width=mn,Nt.height=sn,Nt.getContext("2d").drawImage(Z,0,0,mn,sn),console.warn("THREE.WebGLRenderer: Texture has been resized from ("+Z.width+"x"+Z.height+") to ("+mn+"x"+sn+")."),Nt}return"data"in Z&&console.warn("THREE.WebGLRenderer: Image in DataTexture is too big ("+Z.width+"x"+Z.height+")."),Z}return Z}function R(Z){return nee(Z.width)&&nee(Z.height)}function H(Z,N){return Z.generateMipmaps&&N&&Z.minFilter!==bo&&Z.minFilter!==ra}function te(Z){n.generateMipmap(Z)}function K(Z,N,He,yt,nn=!1){if(!1===s)return N;if(null!==Z){if(void 0!==n[Z])return n[Z];console.warn("THREE.WebGLRenderer: Attempt to use non-existing WebGL internal format '"+Z+"'")}let Be=N;return 6403===N&&(5126===He&&(Be=33326),5131===He&&(Be=33325),5121===He&&(Be=33321)),33319===N&&(5126===He&&(Be=33328),5131===He&&(Be=33327),5121===He&&(Be=33323)),6408===N&&(5126===He&&(Be=34836),5131===He&&(Be=34842),5121===He&&(Be=yt===Dr&&!1===nn?35907:32856),32819===He&&(Be=32854),32820===He&&(Be=32855)),(33325===Be||33326===Be||33327===Be||33328===Be||34842===Be||34836===Be)&&t.get("EXT_color_buffer_float"),Be}function Ce(Z,N,He){return!0===H(Z,He)||Z.isFramebufferTexture&&Z.minFilter!==bo&&Z.minFilter!==ra?Math.log2(Math.max(N.width,N.height))+1:void 0!==Z.mipmaps&&Z.mipmaps.length>0?Z.mipmaps.length:Z.isCompressedTexture&&Array.isArray(Z.image)?N.mipmaps.length:1}function Ze(Z){return Z===bo||Z===k$||Z===P$?9728:9729}function Ie(Z){let N=Z.target;N.removeEventListener("dispose",Ie),function(Z){let N=i.get(Z);void 0!==N.__webglInit&&(n.deleteTexture(N.__webglTexture),i.remove(Z))}(N),N.isVideoTexture&&m.delete(N),a.memory.textures--}function I(Z){let N=Z.target;N.removeEventListener("dispose",I),function(Z){let N=Z.texture,He=i.get(Z),yt=i.get(N);if(Z){if(void 0!==yt.__webglTexture&&(n.deleteTexture(yt.__webglTexture),a.memory.textures--),Z.depthTexture&&Z.depthTexture.dispose(),Z.isWebGLCubeRenderTarget)for(let nn=0;nn<6;nn++)n.deleteFramebuffer(He.__webglFramebuffer[nn]),He.__webglDepthbuffer&&n.deleteRenderbuffer(He.__webglDepthbuffer[nn]);else n.deleteFramebuffer(He.__webglFramebuffer),He.__webglDepthbuffer&&n.deleteRenderbuffer(He.__webglDepthbuffer),He.__webglMultisampledFramebuffer&&n.deleteFramebuffer(He.__webglMultisampledFramebuffer),He.__webglColorRenderbuffer&&n.deleteRenderbuffer(He.__webglColorRenderbuffer),He.__webglDepthRenderbuffer&&n.deleteRenderbuffer(He.__webglDepthRenderbuffer);if(Z.isWebGLMultipleRenderTargets)for(let nn=0,Be=N.length;nn<Be;nn++){let mn=i.get(N[nn]);mn.__webglTexture&&(n.deleteTexture(mn.__webglTexture),a.memory.textures--),i.remove(N[nn])}i.remove(N),i.remove(Z)}}(N)}let fe=0;function de(Z,N){let He=i.get(Z);if(Z.isVideoTexture&&function(Z){let N=a.render.frame;m.get(Z)!==N&&(m.set(Z,N),Z.update())}(Z),Z.version>0&&He.__version!==Z.version){let yt=Z.image;if(void 0===yt)console.warn("THREE.WebGLRenderer: Texture marked for update but image is undefined");else{if(!1!==yt.complete)return void Oe(He,Z,N);console.warn("THREE.WebGLRenderer: Texture marked for update but image is incomplete")}}e.activeTexture(33984+N),e.bindTexture(3553,He.__webglTexture)}function Me(Z,N){let He=i.get(Z);Z.version>0&&He.__version!==Z.version?function(Z,N,He){if(6!==N.image.length)return;ft(Z,N),e.activeTexture(33984+He),e.bindTexture(34067,Z.__webglTexture),n.pixelStorei(37440,N.flipY),n.pixelStorei(37441,N.premultiplyAlpha),n.pixelStorei(3317,N.unpackAlignment),n.pixelStorei(37443,0);let yt=N&&(N.isCompressedTexture||N.image[0].isCompressedTexture),nn=N.image[0]&&N.image[0].isDataTexture,Be=[];for(let We=0;We<6;We++)Be[We]=yt||nn?nn?N.image[We].image:N.image[We]:x(N.image[We],!1,!0,c),Be[We]=on(N,Be[We]);let In,mn=Be[0],sn=R(mn)||s,Nt=o.convert(N.format,N.encoding),Lt=o.convert(N.type),Hn=K(N.internalFormat,Nt,Lt,N.encoding),se=s&&!0!==N.isVideoTexture,tn=void 0===Z.__version,Wt=Ce(N,mn,sn);if(wt(34067,N,sn),yt){se&&tn&&e.texStorage2D(34067,Wt,Hn,mn.width,mn.height);for(let We=0;We<6;We++){In=Be[We].mipmaps;for(let vn=0;vn<In.length;vn++){let hi=In[vn];N.format!==ba?null!==Nt?se?e.compressedTexSubImage2D(34069+We,vn,0,0,hi.width,hi.height,Nt,hi.data):e.compressedTexImage2D(34069+We,vn,Hn,hi.width,hi.height,0,hi.data):console.warn("THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .setTextureCube()"):se?e.texSubImage2D(34069+We,vn,0,0,hi.width,hi.height,Nt,Lt,hi.data):e.texImage2D(34069+We,vn,Hn,hi.width,hi.height,0,Nt,Lt,hi.data)}}}else{In=N.mipmaps,se&&tn&&(In.length>0&&Wt++,e.texStorage2D(34067,Wt,Hn,Be[0].width,Be[0].height));for(let We=0;We<6;We++)if(nn){se?e.texSubImage2D(34069+We,0,0,0,Be[We].width,Be[We].height,Nt,Lt,Be[We].data):e.texImage2D(34069+We,0,Hn,Be[We].width,Be[We].height,0,Nt,Lt,Be[We].data);for(let vn=0;vn<In.length;vn++){let ur=In[vn].image[We].image;se?e.texSubImage2D(34069+We,vn+1,0,0,ur.width,ur.height,Nt,Lt,ur.data):e.texImage2D(34069+We,vn+1,Hn,ur.width,ur.height,0,Nt,Lt,ur.data)}}else{se?e.texSubImage2D(34069+We,0,0,0,Nt,Lt,Be[We]):e.texImage2D(34069+We,0,Hn,Nt,Lt,Be[We]);for(let vn=0;vn<In.length;vn++){let hi=In[vn];se?e.texSubImage2D(34069+We,vn+1,0,0,Nt,Lt,hi.image[We]):e.texImage2D(34069+We,vn+1,Hn,Nt,Lt,hi.image[We])}}}H(N,sn)&&te(34067),Z.__version=N.version,N.onUpdate&&N.onUpdate(N)}(He,Z,N):(e.activeTexture(33984+N),e.bindTexture(34067,He.__webglTexture))}let Ne={[MB]:10497,[gs]:33071,[wB]:33648},ct={[bo]:9728,[k$]:9984,[P$]:9986,[ra]:9729,[AAe]:9985,[eA]:9987};function wt(Z,N,He){if(He?(n.texParameteri(Z,10242,Ne[N.wrapS]),n.texParameteri(Z,10243,Ne[N.wrapT]),(32879===Z||35866===Z)&&n.texParameteri(Z,32882,Ne[N.wrapR]),n.texParameteri(Z,10240,ct[N.magFilter]),n.texParameteri(Z,10241,ct[N.minFilter])):(n.texParameteri(Z,10242,33071),n.texParameteri(Z,10243,33071),(32879===Z||35866===Z)&&n.texParameteri(Z,32882,33071),(N.wrapS!==gs||N.wrapT!==gs)&&console.warn("THREE.WebGLRenderer: Texture is not power of two. Texture.wrapS and Texture.wrapT should be set to THREE.ClampToEdgeWrapping."),n.texParameteri(Z,10240,Ze(N.magFilter)),n.texParameteri(Z,10241,Ze(N.minFilter)),N.minFilter!==bo&&N.minFilter!==ra&&console.warn("THREE.WebGLRenderer: Texture is not power of two. Texture.minFilter should be set to THREE.NearestFilter or THREE.LinearFilter.")),!0===t.has("EXT_texture_filter_anisotropic")){let yt=t.get("EXT_texture_filter_anisotropic");if(N.type===Cm&&!1===t.has("OES_texture_float_linear")||!1===s&&N.type===t_&&!1===t.has("OES_texture_half_float_linear"))return;(N.anisotropy>1||i.get(N).__currentAnisotropy)&&(n.texParameterf(Z,yt.TEXTURE_MAX_ANISOTROPY_EXT,Math.min(N.anisotropy,r.getMaxAnisotropy())),i.get(N).__currentAnisotropy=N.anisotropy)}}function ft(Z,N){void 0===Z.__webglInit&&(Z.__webglInit=!0,N.addEventListener("dispose",Ie),Z.__webglTexture=n.createTexture(),a.memory.textures++)}function Oe(Z,N,He){let yt=3553;N.isDataTexture2DArray&&(yt=35866),N.isDataTexture3D&&(yt=32879),ft(Z,N),e.activeTexture(33984+He),e.bindTexture(yt,Z.__webglTexture),n.pixelStorei(37440,N.flipY),n.pixelStorei(37441,N.premultiplyAlpha),n.pixelStorei(3317,N.unpackAlignment),n.pixelStorei(37443,0);let nn=function(Z){return!s&&(Z.wrapS!==gs||Z.wrapT!==gs||Z.minFilter!==bo&&Z.minFilter!==ra)}(N)&&!1===R(N.image),Be=x(N.image,nn,!1,d);Be=on(N,Be);let mn=R(Be)||s,sn=o.convert(N.format,N.encoding),Nt=o.convert(N.type),Lt=K(N.internalFormat,sn,Nt,N.encoding,N.isVideoTexture);wt(yt,N,mn);let Hn,se=N.mipmaps,tn=s&&!0!==N.isVideoTexture,Wt=void 0===Z.__version,In=Ce(N,Be,mn);if(N.isDepthTexture)Lt=6402,s?Lt=N.type===Cm?36012:N.type===CI?33190:N.type===n_?35056:33189:N.type===Cm&&console.error("WebGLRenderer: Floating point depth texture requires WebGL2."),N.format===wm&&6402===Lt&&N.type!==Ex&&N.type!==CI&&(console.warn("THREE.WebGLRenderer: Use UnsignedShortType or UnsignedIntType for DepthFormat DepthTexture."),N.type=Ex,Nt=o.convert(N.type)),N.format===a_&&6402===Lt&&(Lt=34041,N.type!==n_&&(console.warn("THREE.WebGLRenderer: Use UnsignedInt248Type for DepthStencilFormat DepthTexture."),N.type=n_,Nt=o.convert(N.type))),tn&&Wt?e.texStorage2D(3553,1,Lt,Be.width,Be.height):e.texImage2D(3553,0,Lt,Be.width,Be.height,0,sn,Nt,null);else if(N.isDataTexture)if(se.length>0&&mn){tn&&Wt&&e.texStorage2D(3553,In,Lt,se[0].width,se[0].height);for(let We=0,vn=se.length;We<vn;We++)Hn=se[We],tn?e.texSubImage2D(3553,0,0,0,Hn.width,Hn.height,sn,Nt,Hn.data):e.texImage2D(3553,We,Lt,Hn.width,Hn.height,0,sn,Nt,Hn.data);N.generateMipmaps=!1}else tn?(Wt&&e.texStorage2D(3553,In,Lt,Be.width,Be.height),e.texSubImage2D(3553,0,0,0,Be.width,Be.height,sn,Nt,Be.data)):e.texImage2D(3553,0,Lt,Be.width,Be.height,0,sn,Nt,Be.data);else if(N.isCompressedTexture){tn&&Wt&&e.texStorage2D(3553,In,Lt,se[0].width,se[0].height);for(let We=0,vn=se.length;We<vn;We++)Hn=se[We],N.format!==ba?null!==sn?tn?e.compressedTexSubImage2D(3553,We,0,0,Hn.width,Hn.height,sn,Hn.data):e.compressedTexImage2D(3553,We,Lt,Hn.width,Hn.height,0,Hn.data):console.warn("THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .uploadTexture()"):tn?e.texSubImage2D(3553,We,0,0,Hn.width,Hn.height,sn,Nt,Hn.data):e.texImage2D(3553,We,Lt,Hn.width,Hn.height,0,sn,Nt,Hn.data)}else if(N.isDataTexture2DArray)tn?(Wt&&e.texStorage3D(35866,In,Lt,Be.width,Be.height,Be.depth),e.texSubImage3D(35866,0,0,0,0,Be.width,Be.height,Be.depth,sn,Nt,Be.data)):e.texImage3D(35866,0,Lt,Be.width,Be.height,Be.depth,0,sn,Nt,Be.data);else if(N.isDataTexture3D)tn?(Wt&&e.texStorage3D(32879,In,Lt,Be.width,Be.height,Be.depth),e.texSubImage3D(32879,0,0,0,0,Be.width,Be.height,Be.depth,sn,Nt,Be.data)):e.texImage3D(32879,0,Lt,Be.width,Be.height,Be.depth,0,sn,Nt,Be.data);else if(N.isFramebufferTexture)tn&&Wt?e.texStorage2D(3553,In,Lt,Be.width,Be.height):e.texImage2D(3553,0,Lt,Be.width,Be.height,0,sn,Nt,null);else if(se.length>0&&mn){tn&&Wt&&e.texStorage2D(3553,In,Lt,se[0].width,se[0].height);for(let We=0,vn=se.length;We<vn;We++)Hn=se[We],tn?e.texSubImage2D(3553,We,0,0,sn,Nt,Hn):e.texImage2D(3553,We,Lt,sn,Nt,Hn);N.generateMipmaps=!1}else tn?(Wt&&e.texStorage2D(3553,In,Lt,Be.width,Be.height),e.texSubImage2D(3553,0,0,0,sn,Nt,Be)):e.texImage2D(3553,0,Lt,sn,Nt,Be);H(N,mn)&&te(yt),Z.__version=N.version,N.onUpdate&&N.onUpdate(N)}function St(Z,N,He,yt,nn){let Be=o.convert(He.format,He.encoding),mn=o.convert(He.type),sn=K(He.internalFormat,Be,mn,He.encoding);i.get(N).__hasExternalTextures||(32879===nn||35866===nn?e.texImage3D(nn,0,sn,N.width,N.height,N.depth,0,Be,mn,null):e.texImage2D(nn,0,sn,N.width,N.height,0,Be,mn,null)),e.bindFramebuffer(36160,Z),N.useRenderToTexture?f.framebufferTexture2DMultisampleEXT(36160,yt,nn,i.get(He).__webglTexture,0,_t(N)):n.framebufferTexture2D(36160,yt,nn,i.get(He).__webglTexture,0),e.bindFramebuffer(36160,null)}function rn(Z,N,He){if(n.bindRenderbuffer(36161,Z),N.depthBuffer&&!N.stencilBuffer){let yt=33189;if(He||N.useRenderToTexture){let nn=N.depthTexture;nn&&nn.isDepthTexture&&(nn.type===Cm?yt=36012:nn.type===CI&&(yt=33190));let Be=_t(N);N.useRenderToTexture?f.renderbufferStorageMultisampleEXT(36161,Be,yt,N.width,N.height):n.renderbufferStorageMultisample(36161,Be,yt,N.width,N.height)}else n.renderbufferStorage(36161,yt,N.width,N.height);n.framebufferRenderbuffer(36160,36096,36161,Z)}else if(N.depthBuffer&&N.stencilBuffer){let yt=_t(N);He&&N.useRenderbuffer?n.renderbufferStorageMultisample(36161,yt,35056,N.width,N.height):N.useRenderToTexture?f.renderbufferStorageMultisampleEXT(36161,yt,35056,N.width,N.height):n.renderbufferStorage(36161,34041,N.width,N.height),n.framebufferRenderbuffer(36160,33306,36161,Z)}else{let yt=!0===N.isWebGLMultipleRenderTargets?N.texture[0]:N.texture,nn=o.convert(yt.format,yt.encoding),Be=o.convert(yt.type),mn=K(yt.internalFormat,nn,Be,yt.encoding),sn=_t(N);He&&N.useRenderbuffer?n.renderbufferStorageMultisample(36161,sn,mn,N.width,N.height):N.useRenderToTexture?f.renderbufferStorageMultisampleEXT(36161,sn,mn,N.width,N.height):n.renderbufferStorage(36161,mn,N.width,N.height)}n.bindRenderbuffer(36161,null)}function ht(Z){let N=i.get(Z),He=!0===Z.isWebGLCubeRenderTarget;if(Z.depthTexture&&!N.__autoAllocateDepthBuffer){if(He)throw new Error("target.depthTexture not supported in Cube render targets");!function(Z,N){if(N&&N.isWebGLCubeRenderTarget)throw new Error("Depth Texture with cube render targets is not supported");if(e.bindFramebuffer(36160,Z),!N.depthTexture||!N.depthTexture.isDepthTexture)throw new Error("renderTarget.depthTexture must be an instance of THREE.DepthTexture");(!i.get(N.depthTexture).__webglTexture||N.depthTexture.image.width!==N.width||N.depthTexture.image.height!==N.height)&&(N.depthTexture.image.width=N.width,N.depthTexture.image.height=N.height,N.depthTexture.needsUpdate=!0),de(N.depthTexture,0);let yt=i.get(N.depthTexture).__webglTexture,nn=_t(N);if(N.depthTexture.format===wm)N.useRenderToTexture?f.framebufferTexture2DMultisampleEXT(36160,36096,3553,yt,0,nn):n.framebufferTexture2D(36160,36096,3553,yt,0);else{if(N.depthTexture.format!==a_)throw new Error("Unknown depthTexture format");N.useRenderToTexture?f.framebufferTexture2DMultisampleEXT(36160,33306,3553,yt,0,nn):n.framebufferTexture2D(36160,33306,3553,yt,0)}}(N.__webglFramebuffer,Z)}else if(He){N.__webglDepthbuffer=[];for(let yt=0;yt<6;yt++)e.bindFramebuffer(36160,N.__webglFramebuffer[yt]),N.__webglDepthbuffer[yt]=n.createRenderbuffer(),rn(N.__webglDepthbuffer[yt],Z,!1)}else e.bindFramebuffer(36160,N.__webglFramebuffer),N.__webglDepthbuffer=n.createRenderbuffer(),rn(N.__webglDepthbuffer,Z,!1);e.bindFramebuffer(36160,null)}function _t(Z){return s&&(Z.useRenderbuffer||Z.useRenderToTexture)?Math.min(u,Z.samples):0}function on(Z,N){let He=Z.encoding,yt=Z.format,nn=Z.type;return!0===Z.isCompressedTexture||!0===Z.isVideoTexture||Z.format===SB||He!==Mp&&(He===Dr?!1===s?!0===t.has("EXT_sRGB")&&yt===ba?(Z.format=SB,Z.minFilter=ra,Z.generateMipmaps=!1):N=jd.sRGBToLinear(N):(yt!==ba||nn!==vp)&&console.warn("THREE.WebGLTextures: sRGB encoded textures have to use RGBAFormat and UnsignedByteType."):console.error("THREE.WebGLTextures: Unsupported texture encoding:",He)),N}let wn=!1,ii=!1;this.allocateTextureUnit=function(){let Z=fe;return Z>=l&&console.warn("THREE.WebGLTextures: Trying to use "+Z+" texture units while this GPU supports only "+l),fe+=1,Z},this.resetTextureUnits=function(){fe=0},this.setTexture2D=de,this.setTexture2DArray=function(Z,N){let He=i.get(Z);Z.version>0&&He.__version!==Z.version?Oe(He,Z,N):(e.activeTexture(33984+N),e.bindTexture(35866,He.__webglTexture))},this.setTexture3D=function(Z,N){let He=i.get(Z);Z.version>0&&He.__version!==Z.version?Oe(He,Z,N):(e.activeTexture(33984+N),e.bindTexture(32879,He.__webglTexture))},this.setTextureCube=Me,this.rebindTextures=function(Z,N,He){let yt=i.get(Z);void 0!==N&&St(yt.__webglFramebuffer,Z,Z.texture,36064,3553),void 0!==He&&ht(Z)},this.setupRenderTarget=function(Z){let N=Z.texture,He=i.get(Z),yt=i.get(N);Z.addEventListener("dispose",I),!0!==Z.isWebGLMultipleRenderTargets&&(void 0===yt.__webglTexture&&(yt.__webglTexture=n.createTexture()),yt.__version=N.version,a.memory.textures++);let nn=!0===Z.isWebGLCubeRenderTarget,Be=!0===Z.isWebGLMultipleRenderTargets,mn=N.isDataTexture3D||N.isDataTexture2DArray,sn=R(Z)||s;if(nn){He.__webglFramebuffer=[];for(let Nt=0;Nt<6;Nt++)He.__webglFramebuffer[Nt]=n.createFramebuffer()}else if(He.__webglFramebuffer=n.createFramebuffer(),Be)if(r.drawBuffers){let Nt=Z.texture;for(let Lt=0,Hn=Nt.length;Lt<Hn;Lt++){let se=i.get(Nt[Lt]);void 0===se.__webglTexture&&(se.__webglTexture=n.createTexture(),a.memory.textures++)}}else console.warn("THREE.WebGLRenderer: WebGLMultipleRenderTargets can only be used with WebGL2 or WEBGL_draw_buffers extension.");else if(Z.useRenderbuffer)if(s){He.__webglMultisampledFramebuffer=n.createFramebuffer(),He.__webglColorRenderbuffer=n.createRenderbuffer(),n.bindRenderbuffer(36161,He.__webglColorRenderbuffer);let Nt=o.convert(N.format,N.encoding),Lt=o.convert(N.type),Hn=K(N.internalFormat,Nt,Lt,N.encoding),se=_t(Z);n.renderbufferStorageMultisample(36161,se,Hn,Z.width,Z.height),e.bindFramebuffer(36160,He.__webglMultisampledFramebuffer),n.framebufferRenderbuffer(36160,36064,36161,He.__webglColorRenderbuffer),n.bindRenderbuffer(36161,null),Z.depthBuffer&&(He.__webglDepthRenderbuffer=n.createRenderbuffer(),rn(He.__webglDepthRenderbuffer,Z,!0)),e.bindFramebuffer(36160,null)}else console.warn("THREE.WebGLRenderer: WebGLMultisampleRenderTarget can only be used with WebGL2.");if(nn){e.bindTexture(34067,yt.__webglTexture),wt(34067,N,sn);for(let Nt=0;Nt<6;Nt++)St(He.__webglFramebuffer[Nt],Z,N,36064,34069+Nt);H(N,sn)&&te(34067),e.unbindTexture()}else if(Be){let Nt=Z.texture;for(let Lt=0,Hn=Nt.length;Lt<Hn;Lt++){let se=Nt[Lt],tn=i.get(se);e.bindTexture(3553,tn.__webglTexture),wt(3553,se,sn),St(He.__webglFramebuffer,Z,se,36064+Lt,3553),H(se,sn)&&te(3553)}e.unbindTexture()}else{let Nt=3553;mn&&(s?Nt=N.isDataTexture3D?32879:35866:console.warn("THREE.DataTexture3D and THREE.DataTexture2DArray only supported with WebGL2.")),e.bindTexture(Nt,yt.__webglTexture),wt(Nt,N,sn),St(He.__webglFramebuffer,Z,N,36064,Nt),H(N,sn)&&te(Nt),e.unbindTexture()}Z.depthBuffer&&ht(Z)},this.updateRenderTargetMipmap=function(Z){let N=R(Z)||s,He=!0===Z.isWebGLMultipleRenderTargets?Z.texture:[Z.texture];for(let yt=0,nn=He.length;yt<nn;yt++){let Be=He[yt];if(H(Be,N)){let mn=Z.isWebGLCubeRenderTarget?34067:3553,sn=i.get(Be).__webglTexture;e.bindTexture(mn,sn),te(mn),e.unbindTexture()}}},this.updateMultisampleRenderTarget=function(Z){if(Z.useRenderbuffer)if(s){let N=Z.width,He=Z.height,yt=16384,nn=[36064],Be=Z.stencilBuffer?33306:36096;Z.depthBuffer&&nn.push(Be),Z.ignoreDepthForMultisampleCopy||(Z.depthBuffer&&(yt|=256),Z.stencilBuffer&&(yt|=1024));let mn=i.get(Z);e.bindFramebuffer(36008,mn.__webglMultisampledFramebuffer),e.bindFramebuffer(36009,mn.__webglFramebuffer),Z.ignoreDepthForMultisampleCopy&&(n.invalidateFramebuffer(36008,[Be]),n.invalidateFramebuffer(36009,[Be])),n.blitFramebuffer(0,0,N,He,0,0,N,He,yt,9728),n.invalidateFramebuffer(36008,nn),e.bindFramebuffer(36008,null),e.bindFramebuffer(36009,mn.__webglMultisampledFramebuffer)}else console.warn("THREE.WebGLRenderer: WebGLMultisampleRenderTarget can only be used with WebGL2.")},this.setupDepthRenderbuffer=ht,this.setupFrameBufferTexture=St,this.safeSetTexture2D=function(Z,N){Z&&Z.isWebGLRenderTarget&&(!1===wn&&(console.warn("THREE.WebGLTextures.safeSetTexture2D: don't use render targets as textures. Use their .texture property instead."),wn=!0),Z=Z.texture),de(Z,N)},this.safeSetTextureCube=function(Z,N){Z&&Z.isWebGLCubeRenderTarget&&(!1===ii&&(console.warn("THREE.WebGLTextures.safeSetTextureCube: don't use cube render targets as textures. Use their .texture property instead."),ii=!0),Z=Z.texture),Me(Z,N)}}function DFe(n,t,e){let i=e.isWebGL2;return{convert:function(o,a=null){let s;if(o===vp)return 5121;if(o===OAe)return 32819;if(o===FAe)return 32820;if(o===RAe)return 5120;if(o===kAe)return 5122;if(o===Ex)return 5123;if(o===PAe)return 5124;if(o===CI)return 5125;if(o===Cm)return 5126;if(o===t_)return i?5131:(s=t.get("OES_texture_half_float"),null!==s?s.HALF_FLOAT_OES:null);if(o===LAe)return 6406;if(o===ba)return 6408;if(o===NAe)return 6409;if(o===BAe)return 6410;if(o===wm)return 6402;if(o===a_)return 34041;if(o===VAe)return 6403;if(o===SB)return s=t.get("EXT_sRGB"),null!==s?s.SRGB_ALPHA_EXT:null;if(o===HAe)return 36244;if(o===zAe)return 33319;if(o===UAe)return 33320;if(o===jAe)return 36249;if(o===F3||o===L3||o===N3||o===B3)if(a===Dr){if(s=t.get("WEBGL_compressed_texture_s3tc_srgb"),null===s)return null;if(o===F3)return s.COMPRESSED_SRGB_S3TC_DXT1_EXT;if(o===L3)return s.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT;if(o===N3)return s.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT;if(o===B3)return s.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT}else{if(s=t.get("WEBGL_compressed_texture_s3tc"),null===s)return null;if(o===F3)return s.COMPRESSED_RGB_S3TC_DXT1_EXT;if(o===L3)return s.COMPRESSED_RGBA_S3TC_DXT1_EXT;if(o===N3)return s.COMPRESSED_RGBA_S3TC_DXT3_EXT;if(o===B3)return s.COMPRESSED_RGBA_S3TC_DXT5_EXT}if(o===O$||o===F$||o===L$||o===N$){if(s=t.get("WEBGL_compressed_texture_pvrtc"),null===s)return null;if(o===O$)return s.COMPRESSED_RGB_PVRTC_4BPPV1_IMG;if(o===F$)return s.COMPRESSED_RGB_PVRTC_2BPPV1_IMG;if(o===L$)return s.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG;if(o===N$)return s.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG}if(o===GAe)return s=t.get("WEBGL_compressed_texture_etc1"),null!==s?s.COMPRESSED_RGB_ETC1_WEBGL:null;if(o===B$||o===V$){if(s=t.get("WEBGL_compressed_texture_etc"),null===s)return null;if(o===B$)return a===Dr?s.COMPRESSED_SRGB8_ETC2:s.COMPRESSED_RGB8_ETC2;if(o===V$)return a===Dr?s.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:s.COMPRESSED_RGBA8_ETC2_EAC}if(o===H$||o===z$||o===U$||o===j$||o===G$||o===W$||o===q$||o===Y$||o===X$||o===Q$||o===Z$||o===K$||o===J$||o===$$){if(s=t.get("WEBGL_compressed_texture_astc"),null===s)return null;if(o===H$)return a===Dr?s.COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR:s.COMPRESSED_RGBA_ASTC_4x4_KHR;if(o===z$)return a===Dr?s.COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR:s.COMPRESSED_RGBA_ASTC_5x4_KHR;if(o===U$)return a===Dr?s.COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR:s.COMPRESSED_RGBA_ASTC_5x5_KHR;if(o===j$)return a===Dr?s.COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR:s.COMPRESSED_RGBA_ASTC_6x5_KHR;if(o===G$)return a===Dr?s.COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR:s.COMPRESSED_RGBA_ASTC_6x6_KHR;if(o===W$)return a===Dr?s.COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR:s.COMPRESSED_RGBA_ASTC_8x5_KHR;if(o===q$)return a===Dr?s.COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR:s.COMPRESSED_RGBA_ASTC_8x6_KHR;if(o===Y$)return a===Dr?s.COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR:s.COMPRESSED_RGBA_ASTC_8x8_KHR;if(o===X$)return a===Dr?s.COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR:s.COMPRESSED_RGBA_ASTC_10x5_KHR;if(o===Q$)return a===Dr?s.COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR:s.COMPRESSED_RGBA_ASTC_10x6_KHR;if(o===Z$)return a===Dr?s.COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR:s.COMPRESSED_RGBA_ASTC_10x8_KHR;if(o===K$)return a===Dr?s.COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR:s.COMPRESSED_RGBA_ASTC_10x10_KHR;if(o===J$)return a===Dr?s.COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR:s.COMPRESSED_RGBA_ASTC_12x10_KHR;if(o===$$)return a===Dr?s.COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR:s.COMPRESSED_RGBA_ASTC_12x12_KHR}if(o===eee){if(s=t.get("EXT_texture_compression_bptc"),null===s)return null;if(o===eee)return a===Dr?s.COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT:s.COMPRESSED_RGBA_BPTC_UNORM_EXT}return o===n_?i?34042:(s=t.get("WEBGL_depth_texture"),null!==s?s.UNSIGNED_INT_24_8_WEBGL:null):void 0}}}var FI=class extends oa{constructor(t=[]){super(),this.cameras=t}};FI.prototype.isArrayCamera=!0;var Mm=class extends zi{constructor(){super(),this.type="Group"}};Mm.prototype.isGroup=!0;var IFe={type:"move"},Cx=class{constructor(){this._targetRay=null,this._grip=null,this._hand=null}getHandSpace(){return null===this._hand&&(this._hand=new Mm,this._hand.matrixAutoUpdate=!1,this._hand.visible=!1,this._hand.joints={},this._hand.inputState={pinching:!1}),this._hand}getTargetRaySpace(){return null===this._targetRay&&(this._targetRay=new Mm,this._targetRay.matrixAutoUpdate=!1,this._targetRay.visible=!1,this._targetRay.hasLinearVelocity=!1,this._targetRay.linearVelocity=new $,this._targetRay.hasAngularVelocity=!1,this._targetRay.angularVelocity=new $),this._targetRay}getGripSpace(){return null===this._grip&&(this._grip=new Mm,this._grip.matrixAutoUpdate=!1,this._grip.visible=!1,this._grip.hasLinearVelocity=!1,this._grip.linearVelocity=new $,this._grip.hasAngularVelocity=!1,this._grip.angularVelocity=new $),this._grip}dispatchEvent(t){return null!==this._targetRay&&this._targetRay.dispatchEvent(t),null!==this._grip&&this._grip.dispatchEvent(t),null!==this._hand&&this._hand.dispatchEvent(t),this}disconnect(t){return this.dispatchEvent({type:"disconnected",data:t}),null!==this._targetRay&&(this._targetRay.visible=!1),null!==this._grip&&(this._grip.visible=!1),null!==this._hand&&(this._hand.visible=!1),this}update(t,e,i){let r=null,o=null,a=null,s=this._targetRay,l=this._grip,c=this._hand;if(t&&"visible-blurred"!==e.session.visibilityState)if(null!==s&&(r=e.getPose(t.targetRaySpace,i),null!==r&&(s.matrix.fromArray(r.transform.matrix),s.matrix.decompose(s.position,s.rotation,s.scale),r.linearVelocity?(s.hasLinearVelocity=!0,s.linearVelocity.copy(r.linearVelocity)):s.hasLinearVelocity=!1,r.angularVelocity?(s.hasAngularVelocity=!0,s.angularVelocity.copy(r.angularVelocity)):s.hasAngularVelocity=!1,this.dispatchEvent(IFe))),c&&t.hand){a=!0;for(let y of t.hand.values()){let M=e.getJointPose(y,i);if(void 0===c.joints[y.jointName]){let x=new Mm;x.matrixAutoUpdate=!1,x.visible=!1,c.joints[y.jointName]=x,c.add(x)}let v=c.joints[y.jointName];null!==M&&(v.matrix.fromArray(M.transform.matrix),v.matrix.decompose(v.position,v.rotation,v.scale),v.jointRadius=M.radius),v.visible=null!==M}let p=c.joints["index-finger-tip"].position.distanceTo(c.joints["thumb-tip"].position),f=.02,m=.005;c.inputState.pinching&&p>f+m?(c.inputState.pinching=!1,this.dispatchEvent({type:"pinchend",handedness:t.handedness,target:this})):!c.inputState.pinching&&p<=f-m&&(c.inputState.pinching=!0,this.dispatchEvent({type:"pinchstart",handedness:t.handedness,target:this}))}else null!==l&&t.gripSpace&&(o=e.getPose(t.gripSpace,i),null!==o&&(l.matrix.fromArray(o.transform.matrix),l.matrix.decompose(l.position,l.rotation,l.scale),o.linearVelocity?(l.hasLinearVelocity=!0,l.linearVelocity.copy(o.linearVelocity)):l.hasLinearVelocity=!1,o.angularVelocity?(l.hasAngularVelocity=!0,l.angularVelocity.copy(o.angularVelocity)):l.hasAngularVelocity=!1));return null!==s&&(s.visible=null!==r),null!==l&&(l.visible=null!==o),null!==c&&(c.visible=null!==a),this}},Ox=class extends uo{constructor(t,e,i,r,o,a,s,l,c,d){if((d=void 0!==d?d:wm)!==wm&&d!==a_)throw new Error("DepthTexture format must be either THREE.DepthFormat or THREE.DepthStencilFormat");void 0===i&&d===wm&&(i=Ex),void 0===i&&d===a_&&(i=n_),super(null,r,o,a,s,l,d,i,c),this.image={width:t,height:e},this.magFilter=void 0!==s?s:bo,this.minFilter=void 0!==l?l:bo,this.flipY=!1,this.generateMipmaps=!1}};Ox.prototype.isDepthTexture=!0;var kB=class extends Ud{constructor(t,e){super();let i=this,r=null,o=1,a=null,s="local-floor",l=t.extensions.has("WEBGL_multisampled_render_to_texture"),c=null,d=null,u=null,p=null,f=!1,m=null,y=e.getContextAttributes(),M=null,v=null,x=[],R=new Map,A=new oa;A.layers.enable(1),A.viewport=new Ki;let H=new oa;H.layers.enable(2),H.viewport=new Ki;let te=[A,H],K=new FI;K.layers.enable(1),K.layers.enable(2);let Ce=null,Ze=null;function Ie(Me){let Ne=R.get(Me.inputSource);Ne&&Ne.dispatchEvent({type:Me.type,data:Me.inputSource})}function I(){R.forEach(function(Me,Ne){Me.disconnect(Ne)}),R.clear(),Ce=null,Ze=null,t.setRenderTarget(M),p=null,u=null,d=null,r=null,v=null,Ge.stop(),i.isPresenting=!1,i.dispatchEvent({type:"sessionend"})}function re(Me){let Ne=r.inputSources;for(let ct=0;ct<x.length;ct++)R.set(Ne[ct],x[ct]);for(let ct=0;ct<Me.removed.length;ct++){let wt=Me.removed[ct],ft=R.get(wt);ft&&(ft.dispatchEvent({type:"disconnected",data:wt}),R.delete(wt))}for(let ct=0;ct<Me.added.length;ct++){let wt=Me.added[ct],ft=R.get(wt);ft&&ft.dispatchEvent({type:"connected",data:wt})}}this.cameraAutoUpdate=!0,this.enabled=!1,this.isPresenting=!1,this.getController=function(Me){let Ne=x[Me];return void 0===Ne&&(Ne=new Cx,x[Me]=Ne),Ne.getTargetRaySpace()},this.getControllerGrip=function(Me){let Ne=x[Me];return void 0===Ne&&(Ne=new Cx,x[Me]=Ne),Ne.getGripSpace()},this.getHand=function(Me){let Ne=x[Me];return void 0===Ne&&(Ne=new Cx,x[Me]=Ne),Ne.getHandSpace()},this.setFramebufferScaleFactor=function(Me){o=Me,!0===i.isPresenting&&console.warn("THREE.WebXRManager: Cannot change framebuffer scale while presenting.")},this.setReferenceSpaceType=function(Me){s=Me,!0===i.isPresenting&&console.warn("THREE.WebXRManager: Cannot change reference space type while presenting.")},this.getReferenceSpace=function(){return a},this.getBaseLayer=function(){return null!==u?u:p},this.getBinding=function(){return d},this.getFrame=function(){return m},this.getSession=function(){return r},this.setSession=async function(Me){if(r=Me,null!==r){if(M=t.getRenderTarget(),r.addEventListener("select",Ie),r.addEventListener("selectstart",Ie),r.addEventListener("selectend",Ie),r.addEventListener("squeeze",Ie),r.addEventListener("squeezestart",Ie),r.addEventListener("squeezeend",Ie),r.addEventListener("end",I),r.addEventListener("inputsourceschange",re),!0!==y.xrCompatible&&await e.makeXRCompatible(),void 0===r.renderState.layers||!1===t.capabilities.isWebGL2)p=new XRWebGLLayer(r,e,{antialias:void 0!==r.renderState.layers||y.antialias,alpha:y.alpha,depth:y.depth,stencil:y.stencil,framebufferScaleFactor:o}),r.updateRenderState({baseLayer:p}),v=new Qa(p.framebufferWidth,p.framebufferHeight,{format:ba,type:vp,encoding:t.outputEncoding});else{f=y.antialias;let Ne=null,ct=null,wt=null;y.depth&&(wt=y.stencil?35056:33190,Ne=y.stencil?a_:wm,ct=y.stencil?n_:Ex);let ft={colorFormat:t.outputEncoding===Dr?35907:32856,depthFormat:wt,scaleFactor:o};d=new XRWebGLBinding(r,e),u=d.createProjectionLayer(ft),r.updateRenderState({layers:[u]}),v=f?new Ix(u.textureWidth,u.textureHeight,{format:ba,type:vp,depthTexture:new Ox(u.textureWidth,u.textureHeight,ct,void 0,void 0,void 0,void 0,void 0,void 0,Ne),stencilBuffer:y.stencil,ignoreDepth:u.ignoreDepthValues,useRenderToTexture:l,encoding:t.outputEncoding}):new Qa(u.textureWidth,u.textureHeight,{format:ba,type:vp,depthTexture:new Ox(u.textureWidth,u.textureHeight,ct,void 0,void 0,void 0,void 0,void 0,void 0,Ne),stencilBuffer:y.stencil,ignoreDepth:u.ignoreDepthValues,encoding:t.outputEncoding})}v.isXRRenderTarget=!0,this.setFoveation(1),a=await r.requestReferenceSpace(s),Ge.setContext(r),Ge.start(),i.isPresenting=!0,i.dispatchEvent({type:"sessionstart"})}};let ce=new $,fe=new $;function ne(Me,Ne){null===Ne?Me.matrixWorld.copy(Me.matrix):Me.matrixWorld.multiplyMatrices(Ne.matrixWorld,Me.matrix),Me.matrixWorldInverse.copy(Me.matrixWorld).invert()}this.updateCamera=function(Me){if(null===r)return;K.near=H.near=A.near=Me.near,K.far=H.far=A.far=Me.far,(Ce!==K.near||Ze!==K.far)&&(r.updateRenderState({depthNear:K.near,depthFar:K.far}),Ce=K.near,Ze=K.far);let Ne=Me.parent,ct=K.cameras;ne(K,Ne);for(let ft=0;ft<ct.length;ft++)ne(ct[ft],Ne);K.matrixWorld.decompose(K.position,K.quaternion,K.scale),Me.position.copy(K.position),Me.quaternion.copy(K.quaternion),Me.scale.copy(K.scale),Me.matrix.copy(K.matrix),Me.matrixWorld.copy(K.matrixWorld);let wt=Me.children;for(let ft=0,Oe=wt.length;ft<Oe;ft++)wt[ft].updateMatrixWorld(!0);2===ct.length?function(Me,Ne,ct){ce.setFromMatrixPosition(Ne.matrixWorld),fe.setFromMatrixPosition(ct.matrixWorld);let wt=ce.distanceTo(fe),ft=Ne.projectionMatrix.elements,Oe=ct.projectionMatrix.elements,An=ft[14]/(ft[10]-1),St=ft[14]/(ft[10]+1),rn=(ft[9]+1)/ft[5],ve=(ft[9]-1)/ft[5],ht=(ft[8]-1)/ft[0],mt=(Oe[8]+1)/Oe[0],oe=An*ht,st=An*mt,Xe=wt/(-ht+mt),_t=Xe*-ht;Ne.matrixWorld.decompose(Me.position,Me.quaternion,Me.scale),Me.translateX(_t),Me.translateZ(Xe),Me.matrixWorld.compose(Me.position,Me.quaternion,Me.scale),Me.matrixWorldInverse.copy(Me.matrixWorld).invert();let pt=An+Xe,on=St+Xe;Me.projectionMatrix.makePerspective(oe-_t,st+(wt-_t),rn*St/on*pt,ve*St/on*pt,pt,on)}(K,A,H):K.projectionMatrix.copy(A.projectionMatrix)},this.getCamera=function(){return K},this.getFoveation=function(){return null!==u?u.fixedFoveation:null!==p?p.fixedFoveation:void 0},this.setFoveation=function(Me){null!==u&&(u.fixedFoveation=Me),null!==p&&void 0!==p.fixedFoveation&&(p.fixedFoveation=Me)};let de=null,Ge=new hte;Ge.setAnimationLoop(function(Me,Ne){if(c=Ne.getViewerPose(a),m=Ne,null!==c){let wt=c.views;null!==p&&(t.setRenderTargetFramebuffer(v,p.framebuffer),t.setRenderTarget(v));let ft=!1;wt.length!==K.cameras.length&&(K.cameras.length=0,ft=!0);for(let Oe=0;Oe<wt.length;Oe++){let An=wt[Oe],St=null;if(null!==p)St=p.getViewport(An);else{let ve=d.getViewSubImage(u,An);St=ve.viewport,0===Oe&&(t.setRenderTargetTextures(v,ve.colorTexture,u.ignoreDepthValues?void 0:ve.depthStencilTexture),t.setRenderTarget(v))}let rn=te[Oe];rn.matrix.fromArray(An.transform.matrix),rn.projectionMatrix.fromArray(An.projectionMatrix),rn.viewport.set(St.x,St.y,St.width,St.height),0===Oe&&K.matrix.copy(rn.matrix),!0===ft&&K.cameras.push(rn)}}let ct=r.inputSources;for(let wt=0;wt<x.length;wt++)x[wt].update(ct[wt],Ne,a);de&&de(Me,Ne),m=null}),this.setAnimationLoop=function(Me){de=Me},this.dispose=function(){}}};function AFe(n){function i(v,x){v.opacity.value=x.opacity,x.color&&v.diffuse.value.copy(x.color),x.emissive&&v.emissive.value.copy(x.emissive).multiplyScalar(x.emissiveIntensity),x.map&&(v.map.value=x.map),x.alphaMap&&(v.alphaMap.value=x.alphaMap),x.specularMap&&(v.specularMap.value=x.specularMap),x.alphaTest>0&&(v.alphaTest.value=x.alphaTest);let A,H,R=n.get(x).envMap;R&&(v.envMap.value=R,v.flipEnvMap.value=R.isCubeTexture&&!1===R.isRenderTargetTexture?-1:1,v.reflectivity.value=x.reflectivity,v.ior.value=x.ior,v.refractionRatio.value=x.refractionRatio),x.lightMap&&(v.lightMap.value=x.lightMap,v.lightMapIntensity.value=x.lightMapIntensity),x.aoMap&&(v.aoMap.value=x.aoMap,v.aoMapIntensity.value=x.aoMapIntensity),x.map?A=x.map:x.specularMap?A=x.specularMap:x.displacementMap?A=x.displacementMap:x.normalMap?A=x.normalMap:x.bumpMap?A=x.bumpMap:x.roughnessMap?A=x.roughnessMap:x.metalnessMap?A=x.metalnessMap:x.alphaMap?A=x.alphaMap:x.emissiveMap?A=x.emissiveMap:x.clearcoatMap?A=x.clearcoatMap:x.clearcoatNormalMap?A=x.clearcoatNormalMap:x.clearcoatRoughnessMap?A=x.clearcoatRoughnessMap:x.specularIntensityMap?A=x.specularIntensityMap:x.specularColorMap?A=x.specularColorMap:x.transmissionMap?A=x.transmissionMap:x.thicknessMap?A=x.thicknessMap:x.sheenColorMap?A=x.sheenColorMap:x.sheenRoughnessMap&&(A=x.sheenRoughnessMap),void 0!==A&&(A.isWebGLRenderTarget&&(A=A.texture),!0===A.matrixAutoUpdate&&A.updateMatrix(),v.uvTransform.value.copy(A.matrix)),x.aoMap?H=x.aoMap:x.lightMap&&(H=x.lightMap),void 0!==H&&(H.isWebGLRenderTarget&&(H=H.texture),!0===H.matrixAutoUpdate&&H.updateMatrix(),v.uv2Transform.value.copy(H.matrix))}function u(v,x){v.roughness.value=x.roughness,v.metalness.value=x.metalness,x.roughnessMap&&(v.roughnessMap.value=x.roughnessMap),x.metalnessMap&&(v.metalnessMap.value=x.metalnessMap),x.emissiveMap&&(v.emissiveMap.value=x.emissiveMap),x.bumpMap&&(v.bumpMap.value=x.bumpMap,v.bumpScale.value=x.bumpScale,x.side===yo&&(v.bumpScale.value*=-1)),x.normalMap&&(v.normalMap.value=x.normalMap,v.normalScale.value.copy(x.normalScale),x.side===yo&&v.normalScale.value.negate()),x.displacementMap&&(v.displacementMap.value=x.displacementMap,v.displacementScale.value=x.displacementScale,v.displacementBias.value=x.displacementBias),n.get(x).envMap&&(v.envMapIntensity.value=x.envMapIntensity)}return{refreshFogUniforms:function(v,x){v.fogColor.value.copy(x.color),x.isFog?(v.fogNear.value=x.near,v.fogFar.value=x.far):x.isFogExp2&&(v.fogDensity.value=x.density)},refreshMaterialUniforms:function(v,x,R,A,H){x.isMeshBasicMaterial?i(v,x):x.isMeshLambertMaterial?(i(v,x),function(v,x){x.emissiveMap&&(v.emissiveMap.value=x.emissiveMap)}(v,x)):x.isMeshToonMaterial?(i(v,x),function(v,x){x.gradientMap&&(v.gradientMap.value=x.gradientMap),x.emissiveMap&&(v.emissiveMap.value=x.emissiveMap),x.bumpMap&&(v.bumpMap.value=x.bumpMap,v.bumpScale.value=x.bumpScale,x.side===yo&&(v.bumpScale.value*=-1)),x.normalMap&&(v.normalMap.value=x.normalMap,v.normalScale.value.copy(x.normalScale),x.side===yo&&v.normalScale.value.negate()),x.displacementMap&&(v.displacementMap.value=x.displacementMap,v.displacementScale.value=x.displacementScale,v.displacementBias.value=x.displacementBias)}(v,x)):x.isMeshPhongMaterial?(i(v,x),function(v,x){v.specular.value.copy(x.specular),v.shininess.value=Math.max(x.shininess,1e-4),x.emissiveMap&&(v.emissiveMap.value=x.emissiveMap),x.bumpMap&&(v.bumpMap.value=x.bumpMap,v.bumpScale.value=x.bumpScale,x.side===yo&&(v.bumpScale.value*=-1)),x.normalMap&&(v.normalMap.value=x.normalMap,v.normalScale.value.copy(x.normalScale),x.side===yo&&v.normalScale.value.negate()),x.displacementMap&&(v.displacementMap.value=x.displacementMap,v.displacementScale.value=x.displacementScale,v.displacementBias.value=x.displacementBias)}(v,x)):x.isMeshStandardMaterial?(i(v,x),x.isMeshPhysicalMaterial?function(v,x,R){u(v,x),v.ior.value=x.ior,x.sheen>0&&(v.sheenColor.value.copy(x.sheenColor).multiplyScalar(x.sheen),v.sheenRoughness.value=x.sheenRoughness,x.sheenColorMap&&(v.sheenColorMap.value=x.sheenColorMap),x.sheenRoughnessMap&&(v.sheenRoughnessMap.value=x.sheenRoughnessMap)),x.clearcoat>0&&(v.clearcoat.value=x.clearcoat,v.clearcoatRoughness.value=x.clearcoatRoughness,x.clearcoatMap&&(v.clearcoatMap.value=x.clearcoatMap),x.clearcoatRoughnessMap&&(v.clearcoatRoughnessMap.value=x.clearcoatRoughnessMap),x.clearcoatNormalMap&&(v.clearcoatNormalScale.value.copy(x.clearcoatNormalScale),v.clearcoatNormalMap.value=x.clearcoatNormalMap,x.side===yo&&v.clearcoatNormalScale.value.negate())),x.transmission>0&&(v.transmission.value=x.transmission,v.transmissionSamplerMap.value=R.texture,v.transmissionSamplerSize.value.set(R.width,R.height),x.transmissionMap&&(v.transmissionMap.value=x.transmissionMap),v.thickness.value=x.thickness,x.thicknessMap&&(v.thicknessMap.value=x.thicknessMap),v.attenuationDistance.value=x.attenuationDistance,v.attenuationColor.value.copy(x.attenuationColor)),v.specularIntensity.value=x.specularIntensity,v.specularColor.value.copy(x.specularColor),x.specularIntensityMap&&(v.specularIntensityMap.value=x.specularIntensityMap),x.specularColorMap&&(v.specularColorMap.value=x.specularColorMap)}(v,x,H):u(v,x)):x.isMeshMatcapMaterial?(i(v,x),function(v,x){x.matcap&&(v.matcap.value=x.matcap),x.bumpMap&&(v.bumpMap.value=x.bumpMap,v.bumpScale.value=x.bumpScale,x.side===yo&&(v.bumpScale.value*=-1)),x.normalMap&&(v.normalMap.value=x.normalMap,v.normalScale.value.copy(x.normalScale),x.side===yo&&v.normalScale.value.negate()),x.displacementMap&&(v.displacementMap.value=x.displacementMap,v.displacementScale.value=x.displacementScale,v.displacementBias.value=x.displacementBias)}(v,x)):x.isMeshDepthMaterial?(i(v,x),function(v,x){x.displacementMap&&(v.displacementMap.value=x.displacementMap,v.displacementScale.value=x.displacementScale,v.displacementBias.value=x.displacementBias)}(v,x)):x.isMeshDistanceMaterial?(i(v,x),function(v,x){x.displacementMap&&(v.displacementMap.value=x.displacementMap,v.displacementScale.value=x.displacementScale,v.displacementBias.value=x.displacementBias),v.referencePosition.value.copy(x.referencePosition),v.nearDistance.value=x.nearDistance,v.farDistance.value=x.farDistance}(v,x)):x.isMeshNormalMaterial?(i(v,x),function(v,x){x.bumpMap&&(v.bumpMap.value=x.bumpMap,v.bumpScale.value=x.bumpScale,x.side===yo&&(v.bumpScale.value*=-1)),x.normalMap&&(v.normalMap.value=x.normalMap,v.normalScale.value.copy(x.normalScale),x.side===yo&&v.normalScale.value.negate()),x.displacementMap&&(v.displacementMap.value=x.displacementMap,v.displacementScale.value=x.displacementScale,v.displacementBias.value=x.displacementBias)}(v,x)):x.isLineBasicMaterial?(function(v,x){v.diffuse.value.copy(x.color),v.opacity.value=x.opacity}(v,x),x.isLineDashedMaterial&&function(v,x){v.dashSize.value=x.dashSize,v.totalSize.value=x.dashSize+x.gapSize,v.scale.value=x.scale}(v,x)):x.isPointsMaterial?function(v,x,R,A){let H;v.diffuse.value.copy(x.color),v.opacity.value=x.opacity,v.size.value=x.size*R,v.scale.value=.5*A,x.map&&(v.map.value=x.map),x.alphaMap&&(v.alphaMap.value=x.alphaMap),x.alphaTest>0&&(v.alphaTest.value=x.alphaTest),x.map?H=x.map:x.alphaMap&&(H=x.alphaMap),void 0!==H&&(!0===H.matrixAutoUpdate&&H.updateMatrix(),v.uvTransform.value.copy(H.matrix))}(v,x,R,A):x.isSpriteMaterial?function(v,x){let R;v.diffuse.value.copy(x.color),v.opacity.value=x.opacity,v.rotation.value=x.rotation,x.map&&(v.map.value=x.map),x.alphaMap&&(v.alphaMap.value=x.alphaMap),x.alphaTest>0&&(v.alphaTest.value=x.alphaTest),x.map?R=x.map:x.alphaMap&&(R=x.alphaMap),void 0!==R&&(!0===R.matrixAutoUpdate&&R.updateMatrix(),v.uvTransform.value.copy(R.matrix))}(v,x):x.isShadowMaterial?(v.color.value.copy(x.color),v.opacity.value=x.opacity):x.isShaderMaterial&&(x.uniformsNeedUpdate=!1)}}}function qi(n={}){let t=void 0!==n.canvas?n.canvas:function(){let n=Dx("canvas");return n.style.display="block",n}(),e=void 0!==n.context?n.context:null,i=void 0!==n.alpha&&n.alpha,r=void 0===n.depth||n.depth,o=void 0===n.stencil||n.stencil,a=void 0!==n.antialias&&n.antialias,s=void 0===n.premultipliedAlpha||n.premultipliedAlpha,l=void 0!==n.preserveDrawingBuffer&&n.preserveDrawingBuffer,c=void 0!==n.powerPreference?n.powerPreference:"default",d=void 0!==n.failIfMajorPerformanceCaveat&&n.failIfMajorPerformanceCaveat,u=null,p=null,f=[],m=[];this.domElement=t,this.debug={checkShaderErrors:!0},this.autoClear=!0,this.autoClearColor=!0,this.autoClearDepth=!0,this.autoClearStencil=!0,this.sortObjects=!0,this.clippingPlanes=[],this.localClippingEnabled=!1,this.outputEncoding=Mp,this.physicallyCorrectLights=!1,this.toneMapping=bp,this.toneMappingExposure=1;let y=this,M=!1,v=0,x=0,R=null,A=-1,H=null,te=new Ki,K=new Ki,Ce=null,Ze=t.width,Ie=t.height,I=1,re=null,ce=null,fe=new Ki(0,0,Ze,Ie),_e=new Ki(0,0,Ze,Ie),ne=!1,de=new c_,ue=!1,Ge=!1,Me=null,Ne=new Mn,ct=new $,wt={background:null,fog:null,environment:null,overrideMaterial:null,isScene:!0};function ft(){return null===R?I:1}let St,rn,ve,ht,mt,oe,st,Xe,_t,pt,on,wn,ii,Li,Ni,Z,N,He,yt,nn,Be,mn,sn,Oe=e;function An(E,z){for(let Y=0;Y<E.length;Y++){let ae=t.getContext(E[Y],z);if(null!==ae)return ae}return null}try{let E={alpha:!0,depth:r,stencil:o,antialias:a,premultipliedAlpha:s,preserveDrawingBuffer:l,powerPreference:c,failIfMajorPerformanceCaveat:d};if("setAttribute"in t&&t.setAttribute("data-engine",`three.js r${OV}`),t.addEventListener("webglcontextlost",Hn,!1),t.addEventListener("webglcontextrestored",se,!1),null===Oe){let z=["webgl2","webgl","experimental-webgl"];if(!0===y.isWebGL1Renderer&&z.shift(),Oe=An(z,E),null===Oe)throw An(z)?new Error("Error creating WebGL context with your selected attributes."):new Error("Error creating WebGL context.")}void 0===Oe.getShaderPrecisionFormat&&(Oe.getShaderPrecisionFormat=function(){return{rangeMin:1,rangeMax:1,precision:1}})}catch(E){throw console.error("THREE.WebGLRenderer: "+E.message),E}function Nt(){St=new $Pe(Oe),rn=new YPe(Oe,St,n),St.init(rn),mn=new DFe(Oe,St,rn),ve=new EFe(Oe,St,rn),ht=new nOe(Oe),mt=new hFe,oe=new TFe(Oe,St,ve,mt,rn,mn,ht),st=new QPe(y),Xe=new JPe(y),_t=new _Re(Oe,rn),sn=new WPe(Oe,St,_t,rn),pt=new eOe(Oe,_t,ht,sn),on=new aOe(Oe,pt,_t,ht),yt=new oOe(Oe,rn,oe),Z=new XPe(mt),wn=new mFe(y,st,Xe,St,rn,sn,Z),ii=new AFe(mt),Li=new _Fe,Ni=new MFe(St,rn),He=new GPe(y,st,ve,on,i,s),N=new Ste(y,on,rn),nn=new qPe(Oe,St,ht,rn),Be=new tOe(Oe,St,ht,rn),ht.programs=wn.programs,y.capabilities=rn,y.extensions=St,y.properties=mt,y.renderLists=Li,y.shadowMap=N,y.state=ve,y.info=ht}Nt();let Lt=new kB(y,Oe);function Hn(E){E.preventDefault(),console.log("THREE.WebGLRenderer: Context Lost."),M=!0}function se(){console.log("THREE.WebGLRenderer: Context Restored."),M=!1;let E=ht.autoReset,z=N.enabled,Y=N.autoUpdate,J=N.needsUpdate,ae=N.type;Nt(),ht.autoReset=E,N.enabled=z,N.autoUpdate=Y,N.needsUpdate=J,N.type=ae}function tn(E){let z=E.target;z.removeEventListener("dispose",tn),function(E){(function(E){let z=mt.get(E).programs;void 0!==z&&(z.forEach(function(Y){wn.releaseProgram(Y)}),E.isShaderMaterial&&wn.releaseShaderCache(E))})(E),mt.remove(E)}(z)}this.xr=Lt,this.getContext=function(){return Oe},this.getContextAttributes=function(){return Oe.getContextAttributes()},this.forceContextLoss=function(){let E=St.get("WEBGL_lose_context");E&&E.loseContext()},this.forceContextRestore=function(){let E=St.get("WEBGL_lose_context");E&&E.restoreContext()},this.getPixelRatio=function(){return I},this.setPixelRatio=function(E){void 0!==E&&(I=E,this.setSize(Ze,Ie,!1))},this.getSize=function(E){return E.set(Ze,Ie)},this.setSize=function(E,z,Y){Lt.isPresenting?console.warn("THREE.WebGLRenderer: Can't change size while VR device is presenting."):(Ze=E,Ie=z,t.width=Math.floor(E*I),t.height=Math.floor(z*I),!1!==Y&&(t.style.width=E+"px",t.style.height=z+"px"),this.setViewport(0,0,E,z))},this.getDrawingBufferSize=function(E){return E.set(Ze*I,Ie*I).floor()},this.setDrawingBufferSize=function(E,z,Y){Ze=E,Ie=z,I=Y,t.width=Math.floor(E*Y),t.height=Math.floor(z*Y),this.setViewport(0,0,E,z)},this.getCurrentViewport=function(E){return E.copy(te)},this.getViewport=function(E){return E.copy(fe)},this.setViewport=function(E,z,Y,J){E.isVector4?fe.set(E.x,E.y,E.z,E.w):fe.set(E,z,Y,J),ve.viewport(te.copy(fe).multiplyScalar(I).floor())},this.getScissor=function(E){return E.copy(_e)},this.setScissor=function(E,z,Y,J){E.isVector4?_e.set(E.x,E.y,E.z,E.w):_e.set(E,z,Y,J),ve.scissor(K.copy(_e).multiplyScalar(I).floor())},this.getScissorTest=function(){return ne},this.setScissorTest=function(E){ve.setScissorTest(ne=E)},this.setOpaqueSort=function(E){re=E},this.setTransparentSort=function(E){ce=E},this.getClearColor=function(E){return E.copy(He.getClearColor())},this.setClearColor=function(){He.setClearColor.apply(He,arguments)},this.getClearAlpha=function(){return He.getClearAlpha()},this.setClearAlpha=function(){He.setClearAlpha.apply(He,arguments)},this.clear=function(E,z,Y){let J=0;(void 0===E||E)&&(J|=16384),(void 0===z||z)&&(J|=256),(void 0===Y||Y)&&(J|=1024),Oe.clear(J)},this.clearColor=function(){this.clear(!0,!1,!1)},this.clearDepth=function(){this.clear(!1,!0,!1)},this.clearStencil=function(){this.clear(!1,!1,!0)},this.dispose=function(){t.removeEventListener("webglcontextlost",Hn,!1),t.removeEventListener("webglcontextrestored",se,!1),Li.dispose(),Ni.dispose(),mt.dispose(),st.dispose(),Xe.dispose(),on.dispose(),sn.dispose(),wn.dispose(),Lt.dispose(),Lt.removeEventListener("sessionstart",hi),Lt.removeEventListener("sessionend",ur),Me&&(Me.dispose(),Me=null),Uo.stop()},this.renderBufferDirect=function(E,z,Y,J,ae,Ue){null===z&&(z=wt);let et=ae.isMesh&&ae.matrixWorld.determinant()<0,qe=function(E,z,Y,J,ae){!0!==z.isScene&&(z=wt),oe.resetTextureUnits();let Ue=z.fog,qe=null===R?y.outputEncoding:!0===R.isXRRenderTarget?R.texture.encoding:Mp,rt=(J.isMeshStandardMaterial?Xe:st).get(J.envMap||(J.isMeshStandardMaterial?z.environment:null)),dt=!0===J.vertexColors&&!!Y.attributes.color&&4===Y.attributes.color.itemSize,Et=!!J.normalMap&&!!Y.attributes.tangent,At=!!Y.morphAttributes.position,ln=!!Y.morphAttributes.normal,Yi=Y.morphAttributes.position?Y.morphAttributes.position.length:0,xi=J.toneMapped?y.toneMapping:bp,fn=mt.get(J),Pn=p.state.lights;!0!==ue||!0!==Ge&&E===H||Z.setState(J,E,E===H&&J.id===A);let It=!1;J.version===fn.__version?(fn.needsLights&&fn.lightsStateVersion!==Pn.state.version||fn.outputEncoding!==qe||ae.isInstancedMesh&&!1===fn.instancing||!ae.isInstancedMesh&&!0===fn.instancing||ae.isSkinnedMesh&&!1===fn.skinning||!ae.isSkinnedMesh&&!0===fn.skinning||fn.envMap!==rt||J.fog&&fn.fog!==Ue||void 0!==fn.numClippingPlanes&&(fn.numClippingPlanes!==Z.numPlanes||fn.numIntersection!==Z.numIntersection)||fn.vertexAlphas!==dt||fn.vertexTangents!==Et||fn.morphTargets!==At||fn.morphNormals!==ln||fn.toneMapping!==xi||!0===rn.isWebGL2&&fn.morphTargetsCount!==Yi)&&(It=!0):(It=!0,fn.__version=J.version);let gi=fn.currentProgram;!0===It&&(gi=P_(J,z,ae));let ei=!1,jn=!1,Qn=!1,jt=gi.getUniforms(),Bi=fn.uniforms;if(ve.useProgram(gi.program)&&(ei=!0,jn=!0,Qn=!0),J.id!==A&&(A=J.id,jn=!0),ei||H!==E){if(jt.setValue(Oe,"projectionMatrix",E.projectionMatrix),rn.logarithmicDepthBuffer&&jt.setValue(Oe,"logDepthBufFC",2/(Math.log(E.far+1)/Math.LN2)),H!==E&&(H=E,jn=!0,Qn=!0),J.isShaderMaterial||J.isMeshPhongMaterial||J.isMeshToonMaterial||J.isMeshStandardMaterial||J.envMap){let xn=jt.map.cameraPosition;void 0!==xn&&xn.setValue(Oe,ct.setFromMatrixPosition(E.matrixWorld))}(J.isMeshPhongMaterial||J.isMeshToonMaterial||J.isMeshLambertMaterial||J.isMeshBasicMaterial||J.isMeshStandardMaterial||J.isShaderMaterial)&&jt.setValue(Oe,"isOrthographic",!0===E.isOrthographicCamera),(J.isMeshPhongMaterial||J.isMeshToonMaterial||J.isMeshLambertMaterial||J.isMeshBasicMaterial||J.isMeshStandardMaterial||J.isShaderMaterial||J.isShadowMaterial||ae.isSkinnedMesh)&&jt.setValue(Oe,"viewMatrix",E.matrixWorldInverse)}if(ae.isSkinnedMesh){jt.setOptional(Oe,ae,"bindMatrix"),jt.setOptional(Oe,ae,"bindMatrixInverse");let xn=ae.skeleton;xn&&(rn.floatVertexTextures?(null===xn.boneTexture&&xn.computeBoneTexture(),jt.setValue(Oe,"boneTexture",xn.boneTexture,oe),jt.setValue(Oe,"boneTextureSize",xn.boneTextureSize)):jt.setOptional(Oe,xn,"boneMatrices"))}return!!Y&&(void 0!==Y.morphAttributes.position||void 0!==Y.morphAttributes.normal)&&yt.update(ae,Y,J,gi),(jn||fn.receiveShadow!==ae.receiveShadow)&&(fn.receiveShadow=ae.receiveShadow,jt.setValue(Oe,"receiveShadow",ae.receiveShadow)),jn&&(jt.setValue(Oe,"toneMappingExposure",y.toneMappingExposure),fn.needsLights&&function(E,z){E.ambientLightColor.needsUpdate=z,E.lightProbe.needsUpdate=z,E.directionalLights.needsUpdate=z,E.directionalLightShadows.needsUpdate=z,E.pointLights.needsUpdate=z,E.pointLightShadows.needsUpdate=z,E.spotLights.needsUpdate=z,E.spotLightShadows.needsUpdate=z,E.rectAreaLights.needsUpdate=z,E.hemisphereLights.needsUpdate=z}(Bi,Qn),Ue&&J.fog&&ii.refreshFogUniforms(Bi,Ue),ii.refreshMaterialUniforms(Bi,J,I,Ie,Me),Cp.upload(Oe,fn.uniformsList,Bi,oe)),J.isShaderMaterial&&!0===J.uniformsNeedUpdate&&(Cp.upload(Oe,fn.uniformsList,Bi,oe),J.uniformsNeedUpdate=!1),J.isSpriteMaterial&&jt.setValue(Oe,"center",ae.center),jt.setValue(Oe,"modelViewMatrix",ae.modelViewMatrix),jt.setValue(Oe,"normalMatrix",ae.normalMatrix),jt.setValue(Oe,"modelMatrix",ae.matrixWorld),gi}(E,z,Y,J,ae);ve.setMaterial(J,et);let rt=Y.index,dt=Y.attributes.position;if(null===rt){if(void 0===dt||0===dt.count)return}else if(0===rt.count)return;let Et=1;!0===J.wireframe&&(rt=pt.getWireframeAttribute(Y),Et=2),sn.setup(ae,J,qe,Y,rt);let At,ln=nn;null!==rt&&(At=_t.get(rt),ln=Be,ln.setIndex(At));let Yi=null!==rt?rt.count:dt.count,xi=Y.drawRange.start*Et,fn=Y.drawRange.count*Et,Pn=null!==Ue?Ue.start*Et:0,It=null!==Ue?Ue.count*Et:1/0,gi=Math.max(xi,Pn),ei=Math.min(Yi,xi+fn,Pn+It)-1,jn=Math.max(0,ei-gi+1);if(0!==jn){if(ae.isMesh)!0===J.wireframe?(ve.setLineWidth(J.wireframeLinewidth*ft()),ln.setMode(1)):ln.setMode(4);else if(ae.isLine){let Qn=J.linewidth;void 0===Qn&&(Qn=1),ve.setLineWidth(Qn*ft()),ln.setMode(ae.isLineSegments?1:ae.isLineLoop?2:3)}else ae.isPoints?ln.setMode(0):ae.isSprite&&ln.setMode(4);if(ae.isInstancedMesh)ln.renderInstances(gi,jn,ae.count);else if(Y.isInstancedBufferGeometry){let Qn=Math.min(Y.instanceCount,Y._maxInstanceCount);ln.renderInstances(gi,jn,Qn)}else ln.render(gi,jn)}},this.compile=function(E,z){p=Ni.get(E),p.init(),m.push(p),E.traverseVisible(function(Y){Y.isLight&&Y.layers.test(z.layers)&&(p.pushLight(Y),Y.castShadow&&p.pushShadow(Y))}),p.setupLights(y.physicallyCorrectLights),E.traverse(function(Y){let J=Y.material;if(J)if(Array.isArray(J))for(let ae=0;ae<J.length;ae++)P_(J[ae],E,Y);else P_(J,E,Y)}),m.pop(),p=null};let We=null;function hi(){Uo.stop()}function ur(){Uo.start()}let Uo=new hte;function vr(E,z,Y,J){if(!1===E.visible)return;if(E.layers.test(z.layers))if(E.isGroup)Y=E.renderOrder;else if(E.isLOD)!0===E.autoUpdate&&E.update(z);else if(E.isLight)p.pushLight(E),E.castShadow&&p.pushShadow(E);else if(E.isSprite){if(!E.frustumCulled||de.intersectsSprite(E)){J&&ct.setFromMatrixPosition(E.matrixWorld).applyMatrix4(Ne);let et=on.update(E),qe=E.material;qe.visible&&u.push(E,et,qe,Y,ct.z,null)}}else if((E.isMesh||E.isLine||E.isPoints)&&(E.isSkinnedMesh&&E.skeleton.frame!==ht.render.frame&&(E.skeleton.update(),E.skeleton.frame=ht.render.frame),!E.frustumCulled||de.intersectsObject(E))){J&&ct.setFromMatrixPosition(E.matrixWorld).applyMatrix4(Ne);let et=on.update(E),qe=E.material;if(Array.isArray(qe)){let rt=et.groups;for(let dt=0,Et=rt.length;dt<Et;dt++){let At=rt[dt],ln=qe[At.materialIndex];ln&&ln.visible&&u.push(E,et,ln,Y,ct.z,At)}}else qe.visible&&u.push(E,et,qe,Y,ct.z,null)}let Ue=E.children;for(let et=0,qe=Ue.length;et<qe;et++)vr(Ue[et],z,Y,J)}function bs(E,z,Y,J){let ae=E.opaque,Ue=E.transmissive,et=E.transparent;p.setupLightsView(Y),Ue.length>0&&function(E,z,Y){null===Me&&(Me=new(!0===a&&!0===rn.isWebGL2?Ix:Qa)(1024,1024,{generateMipmaps:!0,type:null!==mn.convert(t_)?t_:vp,minFilter:eA,magFilter:bo,wrapS:gs,wrapT:gs,useRenderToTexture:St.has("WEBGL_multisampled_render_to_texture")}));let J=y.getRenderTarget();y.setRenderTarget(Me),y.clear();let ae=y.toneMapping;y.toneMapping=bp,rl(E,z,Y),y.toneMapping=ae,oe.updateMultisampleRenderTarget(Me),oe.updateRenderTargetMipmap(Me),y.setRenderTarget(J)}(ae,z,Y),J&&ve.viewport(te.copy(J)),ae.length>0&&rl(ae,z,Y),Ue.length>0&&rl(Ue,z,Y),et.length>0&&rl(et,z,Y)}function rl(E,z,Y){let J=!0===z.isScene?z.overrideMaterial:null;for(let ae=0,Ue=E.length;ae<Ue;ae++){let et=E[ae],qe=et.object,rt=et.geometry,dt=null===J?et.material:J,Et=et.group;qe.layers.test(Y.layers)&&BA(qe,z,Y,rt,dt,Et)}}function BA(E,z,Y,J,ae,Ue){E.onBeforeRender(y,z,Y,J,ae,Ue),E.modelViewMatrix.multiplyMatrices(Y.matrixWorldInverse,E.matrixWorld),E.normalMatrix.getNormalMatrix(E.modelViewMatrix),ae.onBeforeRender(y,z,Y,J,E,Ue),!0===ae.transparent&&ae.side===o_?(ae.side=yo,ae.needsUpdate=!0,y.renderBufferDirect(Y,z,J,ae,E,Ue),ae.side=Sx,ae.needsUpdate=!0,y.renderBufferDirect(Y,z,J,ae,E,Ue),ae.side=o_):y.renderBufferDirect(Y,z,J,ae,E,Ue),E.onAfterRender(y,z,Y,J,ae,Ue)}function P_(E,z,Y){!0!==z.isScene&&(z=wt);let J=mt.get(E),ae=p.state.lights,et=ae.state.version,qe=wn.getParameters(E,ae.state,p.state.shadowsArray,z,Y),rt=wn.getProgramCacheKey(qe),dt=J.programs;J.environment=E.isMeshStandardMaterial?z.environment:null,J.fog=z.fog,J.envMap=(E.isMeshStandardMaterial?Xe:st).get(E.envMap||J.environment),void 0===dt&&(E.addEventListener("dispose",tn),dt=new Map,J.programs=dt);let Et=dt.get(rt);if(void 0!==Et){if(J.currentProgram===Et&&J.lightsStateVersion===et)return oC(E,qe),Et}else qe.uniforms=wn.getUniforms(E),E.onBuild(Y,qe,y),E.onBeforeCompile(qe,y),Et=wn.acquireProgram(qe,rt),dt.set(rt,Et),J.uniforms=qe.uniforms;let At=J.uniforms;(!E.isShaderMaterial&&!E.isRawShaderMaterial||!0===E.clipping)&&(At.clippingPlanes=Z.uniform),oC(E,qe),J.needsLights=function(E){return E.isMeshLambertMaterial||E.isMeshToonMaterial||E.isMeshPhongMaterial||E.isMeshStandardMaterial||E.isShadowMaterial||E.isShaderMaterial&&!0===E.lights}(E),J.lightsStateVersion=et,J.needsLights&&(At.ambientLightColor.value=ae.state.ambient,At.lightProbe.value=ae.state.probe,At.directionalLights.value=ae.state.directional,At.directionalLightShadows.value=ae.state.directionalShadow,At.spotLights.value=ae.state.spot,At.spotLightShadows.value=ae.state.spotShadow,At.rectAreaLights.value=ae.state.rectArea,At.ltc_1.value=ae.state.rectAreaLTC1,At.ltc_2.value=ae.state.rectAreaLTC2,At.pointLights.value=ae.state.point,At.pointLightShadows.value=ae.state.pointShadow,At.hemisphereLights.value=ae.state.hemi,At.directionalShadowMap.value=ae.state.directionalShadowMap,At.directionalShadowMatrix.value=ae.state.directionalShadowMatrix,At.spotShadowMap.value=ae.state.spotShadowMap,At.spotShadowMatrix.value=ae.state.spotShadowMatrix,At.pointShadowMap.value=ae.state.pointShadowMap,At.pointShadowMatrix.value=ae.state.pointShadowMatrix);let ln=Et.getUniforms(),Yi=Cp.seqWithValue(ln.seq,At);return J.currentProgram=Et,J.uniformsList=Yi,Et}function oC(E,z){let Y=mt.get(E);Y.outputEncoding=z.outputEncoding,Y.instancing=z.instancing,Y.skinning=z.skinning,Y.morphTargets=z.morphTargets,Y.morphNormals=z.morphNormals,Y.morphTargetsCount=z.morphTargetsCount,Y.numClippingPlanes=z.numClippingPlanes,Y.numIntersection=z.numClipIntersection,Y.vertexAlphas=z.vertexAlphas,Y.vertexTangents=z.vertexTangents,Y.toneMapping=z.toneMapping}Uo.setAnimationLoop(function(E){We&&We(E)}),typeof window<"u"&&Uo.setContext(window),this.setAnimationLoop=function(E){We=E,Lt.setAnimationLoop(E),null===E?Uo.stop():Uo.start()},Lt.addEventListener("sessionstart",hi),Lt.addEventListener("sessionend",ur),this.render=function(E,z){if(void 0===z||!0===z.isCamera){if(!0!==M){if(!0===E.autoUpdate&&E.updateMatrixWorld(),null===z.parent&&z.updateMatrixWorld(),!0===Lt.enabled&&!0===Lt.isPresenting&&(!0===Lt.cameraAutoUpdate&&Lt.updateCamera(z),z=Lt.getCamera()),!0===E.isScene&&E.onBeforeRender(y,E,z,R),p=Ni.get(E,m.length),p.init(),m.push(p),Ne.multiplyMatrices(z.projectionMatrix,z.matrixWorldInverse),de.setFromProjectionMatrix(Ne),Ge=this.localClippingEnabled,ue=Z.init(this.clippingPlanes,Ge,z),u=Li.get(E,f.length),u.init(),f.push(u),vr(E,z,0,y.sortObjects),u.finish(),!0===y.sortObjects&&u.sort(re,ce),!0===ue&&Z.beginShadows(),N.render(p.state.shadowsArray,E,z),!0===ue&&Z.endShadows(),!0===this.info.autoReset&&this.info.reset(),He.render(u,E),p.setupLights(y.physicallyCorrectLights),z.isArrayCamera){let J=z.cameras;for(let ae=0,Ue=J.length;ae<Ue;ae++){let et=J[ae];bs(u,E,et,et.viewport)}}else bs(u,E,z);null!==R&&(oe.updateMultisampleRenderTarget(R),oe.updateRenderTargetMipmap(R)),!0===E.isScene&&E.onAfterRender(y,E,z),ve.buffers.depth.setTest(!0),ve.buffers.depth.setMask(!0),ve.buffers.color.setMask(!0),ve.setPolygonOffset(!1),sn.resetDefaultState(),A=-1,H=null,m.pop(),p=m.length>0?m[m.length-1]:null,f.pop(),u=f.length>0?f[f.length-1]:null}}else console.error("THREE.WebGLRenderer.render: camera is not an instance of THREE.Camera.")},this.getActiveCubeFace=function(){return v},this.getActiveMipmapLevel=function(){return x},this.getRenderTarget=function(){return R},this.setRenderTargetTextures=function(E,z,Y){mt.get(E.texture).__webglTexture=z,mt.get(E.depthTexture).__webglTexture=Y;let J=mt.get(E);J.__hasExternalTextures=!0,J.__hasExternalTextures&&(J.__autoAllocateDepthBuffer=void 0===Y,J.__autoAllocateDepthBuffer||E.useRenderToTexture&&(console.warn("render-to-texture extension was disabled because an external texture was provided"),E.useRenderToTexture=!1,E.useRenderbuffer=!0))},this.setRenderTargetFramebuffer=function(E,z){let Y=mt.get(E);Y.__webglFramebuffer=z,Y.__useDefaultFramebuffer=void 0===z},this.setRenderTarget=function(E,z=0,Y=0){R=E,v=z,x=Y;let J=!0;if(E){let rt=mt.get(E);void 0!==rt.__useDefaultFramebuffer?(ve.bindFramebuffer(36160,null),J=!1):void 0===rt.__webglFramebuffer?oe.setupRenderTarget(E):rt.__hasExternalTextures&&oe.rebindTextures(E,mt.get(E.texture).__webglTexture,mt.get(E.depthTexture).__webglTexture)}let ae=null,Ue=!1,et=!1;if(E){let rt=E.texture;(rt.isDataTexture3D||rt.isDataTexture2DArray)&&(et=!0);let dt=mt.get(E).__webglFramebuffer;E.isWebGLCubeRenderTarget?(ae=dt[z],Ue=!0):ae=E.useRenderbuffer?mt.get(E).__webglMultisampledFramebuffer:dt,te.copy(E.viewport),K.copy(E.scissor),Ce=E.scissorTest}else te.copy(fe).multiplyScalar(I).floor(),K.copy(_e).multiplyScalar(I).floor(),Ce=ne;if(ve.bindFramebuffer(36160,ae)&&rn.drawBuffers&&J&&ve.drawBuffers(E,ae),ve.viewport(te),ve.scissor(K),ve.setScissorTest(Ce),Ue){let rt=mt.get(E.texture);Oe.framebufferTexture2D(36160,36064,34069+z,rt.__webglTexture,Y)}else if(et){let rt=mt.get(E.texture);Oe.framebufferTextureLayer(36160,36064,rt.__webglTexture,Y||0,z||0)}A=-1},this.readRenderTargetPixels=function(E,z,Y,J,ae,Ue,et){if(!E||!E.isWebGLRenderTarget)return void console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not THREE.WebGLRenderTarget.");let qe=mt.get(E).__webglFramebuffer;if(E.isWebGLCubeRenderTarget&&void 0!==et&&(qe=qe[et]),qe){ve.bindFramebuffer(36160,qe);try{let rt=E.texture,dt=rt.format,Et=rt.type;if(dt!==ba&&mn.convert(dt)!==Oe.getParameter(35739))return void console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in RGBA or implementation defined format.");let At=Et===t_&&(St.has("EXT_color_buffer_half_float")||rn.isWebGL2&&St.has("EXT_color_buffer_float"));if(!(Et===vp||mn.convert(Et)===Oe.getParameter(35738)||Et===Cm&&(rn.isWebGL2||St.has("OES_texture_float")||St.has("WEBGL_color_buffer_float"))||At))return void console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in UnsignedByteType or implementation defined type.");36053===Oe.checkFramebufferStatus(36160)?z>=0&&z<=E.width-J&&Y>=0&&Y<=E.height-ae&&Oe.readPixels(z,Y,J,ae,mn.convert(dt),mn.convert(Et),Ue):console.error("THREE.WebGLRenderer.readRenderTargetPixels: readPixels from renderTarget failed. Framebuffer not complete.")}finally{let rt=null!==R?mt.get(R).__webglFramebuffer:null;ve.bindFramebuffer(36160,rt)}}},this.copyFramebufferToTexture=function(E,z,Y=0){if(!0!==z.isFramebufferTexture)return void console.error("THREE.WebGLRenderer: copyFramebufferToTexture() can only be used with FramebufferTexture.");let J=Math.pow(2,-Y),ae=Math.floor(z.image.width*J),Ue=Math.floor(z.image.height*J);oe.setTexture2D(z,0),Oe.copyTexSubImage2D(3553,Y,0,0,E.x,E.y,ae,Ue),ve.unbindTexture()},this.copyTextureToTexture=function(E,z,Y,J=0){let ae=z.image.width,Ue=z.image.height,et=mn.convert(Y.format),qe=mn.convert(Y.type);oe.setTexture2D(Y,0),Oe.pixelStorei(37440,Y.flipY),Oe.pixelStorei(37441,Y.premultiplyAlpha),Oe.pixelStorei(3317,Y.unpackAlignment),z.isDataTexture?Oe.texSubImage2D(3553,J,E.x,E.y,ae,Ue,et,qe,z.image.data):z.isCompressedTexture?Oe.compressedTexSubImage2D(3553,J,E.x,E.y,z.mipmaps[0].width,z.mipmaps[0].height,et,z.mipmaps[0].data):Oe.texSubImage2D(3553,J,E.x,E.y,et,qe,z.image),0===J&&Y.generateMipmaps&&Oe.generateMipmap(3553),ve.unbindTexture()},this.copyTextureToTexture3D=function(E,z,Y,J,ae=0){if(y.isWebGL1Renderer)return void console.warn("THREE.WebGLRenderer.copyTextureToTexture3D: can only be used with WebGL2.");let Et,Ue=E.max.x-E.min.x+1,et=E.max.y-E.min.y+1,qe=E.max.z-E.min.z+1,rt=mn.convert(J.format),dt=mn.convert(J.type);if(J.isDataTexture3D)oe.setTexture3D(J,0),Et=32879;else{if(!J.isDataTexture2DArray)return void console.warn("THREE.WebGLRenderer.copyTextureToTexture3D: only supports THREE.DataTexture3D and THREE.DataTexture2DArray.");oe.setTexture2DArray(J,0),Et=35866}Oe.pixelStorei(37440,J.flipY),Oe.pixelStorei(37441,J.premultiplyAlpha),Oe.pixelStorei(3317,J.unpackAlignment);let At=Oe.getParameter(3314),ln=Oe.getParameter(32878),Yi=Oe.getParameter(3316),xi=Oe.getParameter(3315),fn=Oe.getParameter(32877),Pn=Y.isCompressedTexture?Y.mipmaps[0]:Y.image;Oe.pixelStorei(3314,Pn.width),Oe.pixelStorei(32878,Pn.height),Oe.pixelStorei(3316,E.min.x),Oe.pixelStorei(3315,E.min.y),Oe.pixelStorei(32877,E.min.z),Y.isDataTexture||Y.isDataTexture3D?Oe.texSubImage3D(Et,ae,z.x,z.y,z.z,Ue,et,qe,rt,dt,Pn.data):Y.isCompressedTexture?(console.warn("THREE.WebGLRenderer.copyTextureToTexture3D: untested support for compressed srcTexture."),Oe.compressedTexSubImage3D(Et,ae,z.x,z.y,z.z,Ue,et,qe,rt,Pn.data)):Oe.texSubImage3D(Et,ae,z.x,z.y,z.z,Ue,et,qe,rt,dt,Pn),Oe.pixelStorei(3314,At),Oe.pixelStorei(32878,ln),Oe.pixelStorei(3316,Yi),Oe.pixelStorei(3315,xi),Oe.pixelStorei(32877,fn),0===ae&&J.generateMipmaps&&Oe.generateMipmap(Et),ve.unbindTexture()},this.initTexture=function(E){oe.setTexture2D(E,0),ve.unbindTexture()},this.resetState=function(){v=0,x=0,R=null,ve.reset(),sn.reset()},typeof __THREE_DEVTOOLS__<"u"&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("observe",{detail:this}))}qi.prototype.isWebGLRenderer=!0,class extends qi{}.prototype.isWebGL1Renderer=!0;var Fx=class{constructor(t,e=25e-5){this.name="",this.color=new an(t),this.density=e}clone(){return new Fx(this.color,this.density)}toJSON(){return{type:"FogExp2",color:this.color.getHex(),density:this.density}}};Fx.prototype.isFogExp2=!0;var Lx=class{constructor(t,e=1,i=1e3){this.name="",this.color=new an(t),this.near=e,this.far=i}clone(){return new Lx(this.color,this.near,this.far)}toJSON(){return{type:"Fog",color:this.color.getHex(),near:this.near,far:this.far}}};Lx.prototype.isFog=!0;var u_=class extends zi{constructor(){super(),this.type="Scene",this.background=null,this.environment=null,this.fog=null,this.overrideMaterial=null,this.autoUpdate=!0,typeof __THREE_DEVTOOLS__<"u"&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("observe",{detail:this}))}copy(t,e){return super.copy(t,e),null!==t.background&&(this.background=t.background.clone()),null!==t.environment&&(this.environment=t.environment.clone()),null!==t.fog&&(this.fog=t.fog.clone()),null!==t.overrideMaterial&&(this.overrideMaterial=t.overrideMaterial.clone()),this.autoUpdate=t.autoUpdate,this.matrixAutoUpdate=t.matrixAutoUpdate,this}toJSON(t){let e=super.toJSON(t);return null!==this.fog&&(e.object.fog=this.fog.toJSON()),e}};u_.prototype.isScene=!0;var Dm=class{constructor(t,e){this.array=t,this.stride=e,this.count=void 0!==t?t.length/e:0,this.usage=Tx,this.updateRange={offset:0,count:-1},this.version=0,this.uuid=Ql()}onUploadCallback(){}set needsUpdate(t){!0===t&&this.version++}setUsage(t){return this.usage=t,this}copy(t){return this.array=new t.array.constructor(t.array),this.count=t.count,this.stride=t.stride,this.usage=t.usage,this}copyAt(t,e,i){t*=this.stride,i*=e.stride;for(let r=0,o=this.stride;r<o;r++)this.array[t+r]=e.array[i+r];return this}set(t,e=0){return this.array.set(t,e),this}clone(t){void 0===t.arrayBuffers&&(t.arrayBuffers={}),void 0===this.array.buffer._uuid&&(this.array.buffer._uuid=Ql()),void 0===t.arrayBuffers[this.array.buffer._uuid]&&(t.arrayBuffers[this.array.buffer._uuid]=this.array.slice(0).buffer);let e=new this.array.constructor(t.arrayBuffers[this.array.buffer._uuid]),i=new this.constructor(e,this.stride);return i.setUsage(this.usage),i}onUpload(t){return this.onUploadCallback=t,this}toJSON(t){return void 0===t.arrayBuffers&&(t.arrayBuffers={}),void 0===this.array.buffer._uuid&&(this.array.buffer._uuid=Ql()),void 0===t.arrayBuffers[this.array.buffer._uuid]&&(t.arrayBuffers[this.array.buffer._uuid]=Array.prototype.slice.call(new Uint32Array(this.array.buffer))),{uuid:this.uuid,buffer:this.array.buffer._uuid,type:this.array.constructor.name,stride:this.stride}}};Dm.prototype.isInterleavedBuffer=!0;var $r=new $,Im=class{constructor(t,e,i,r=!1){this.name="",this.data=t,this.itemSize=e,this.offset=i,this.normalized=!0===r}get count(){return this.data.count}get array(){return this.data.array}set needsUpdate(t){this.data.needsUpdate=t}applyMatrix4(t){for(let e=0,i=this.data.count;e<i;e++)$r.x=this.getX(e),$r.y=this.getY(e),$r.z=this.getZ(e),$r.applyMatrix4(t),this.setXYZ(e,$r.x,$r.y,$r.z);return this}applyNormalMatrix(t){for(let e=0,i=this.count;e<i;e++)$r.x=this.getX(e),$r.y=this.getY(e),$r.z=this.getZ(e),$r.applyNormalMatrix(t),this.setXYZ(e,$r.x,$r.y,$r.z);return this}transformDirection(t){for(let e=0,i=this.count;e<i;e++)$r.x=this.getX(e),$r.y=this.getY(e),$r.z=this.getZ(e),$r.transformDirection(t),this.setXYZ(e,$r.x,$r.y,$r.z);return this}setX(t,e){return this.data.array[t*this.data.stride+this.offset]=e,this}setY(t,e){return this.data.array[t*this.data.stride+this.offset+1]=e,this}setZ(t,e){return this.data.array[t*this.data.stride+this.offset+2]=e,this}setW(t,e){return this.data.array[t*this.data.stride+this.offset+3]=e,this}getX(t){return this.data.array[t*this.data.stride+this.offset]}getY(t){return this.data.array[t*this.data.stride+this.offset+1]}getZ(t){return this.data.array[t*this.data.stride+this.offset+2]}getW(t){return this.data.array[t*this.data.stride+this.offset+3]}setXY(t,e,i){return this.data.array[(t=t*this.data.stride+this.offset)+0]=e,this.data.array[t+1]=i,this}setXYZ(t,e,i,r){return this.data.array[(t=t*this.data.stride+this.offset)+0]=e,this.data.array[t+1]=i,this.data.array[t+2]=r,this}setXYZW(t,e,i,r,o){return this.data.array[(t=t*this.data.stride+this.offset)+0]=e,this.data.array[t+1]=i,this.data.array[t+2]=r,this.data.array[t+3]=o,this}clone(t){if(void 0===t){console.log("THREE.InterleavedBufferAttribute.clone(): Cloning an interlaved buffer attribute will deinterleave buffer data.");let e=[];for(let i=0;i<this.count;i++){let r=i*this.data.stride+this.offset;for(let o=0;o<this.itemSize;o++)e.push(this.data.array[r+o])}return new Ar(new this.array.constructor(e),this.itemSize,this.normalized)}return void 0===t.interleavedBuffers&&(t.interleavedBuffers={}),void 0===t.interleavedBuffers[this.data.uuid]&&(t.interleavedBuffers[this.data.uuid]=this.data.clone(t)),new Im(t.interleavedBuffers[this.data.uuid],this.itemSize,this.offset,this.normalized)}toJSON(t){if(void 0===t){console.log("THREE.InterleavedBufferAttribute.toJSON(): Serializing an interlaved buffer attribute will deinterleave buffer data.");let e=[];for(let i=0;i<this.count;i++){let r=i*this.data.stride+this.offset;for(let o=0;o<this.itemSize;o++)e.push(this.data.array[r+o])}return{itemSize:this.itemSize,type:this.array.constructor.name,array:e,normalized:this.normalized}}return void 0===t.interleavedBuffers&&(t.interleavedBuffers={}),void 0===t.interleavedBuffers[this.data.uuid]&&(t.interleavedBuffers[this.data.uuid]=this.data.toJSON(t)),{isInterleavedBufferAttribute:!0,itemSize:this.itemSize,data:this.data.uuid,offset:this.offset,normalized:this.normalized}}};Im.prototype.isInterleavedBufferAttribute=!0;var LI=class extends Ro{constructor(t){super(),this.type="SpriteMaterial",this.color=new an(16777215),this.map=null,this.alphaMap=null,this.rotation=0,this.sizeAttenuation=!0,this.transparent=!0,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.alphaMap=t.alphaMap,this.rotation=t.rotation,this.sizeAttenuation=t.sizeAttenuation,this}};LI.prototype.isSpriteMaterial=!0;var Y0,mx=new $,X0=new $,Q0=new $,Z0=new $e,hx=new $e,Ete=new Mn,cI=new $,gx=new $,dI=new $,Nee=new $e,fB=new $e,Bee=new $e;function uI(n,t,e,i,r,o){Z0.subVectors(n,e).addScalar(.5).multiply(i),void 0!==r?(hx.x=o*Z0.x-r*Z0.y,hx.y=r*Z0.x+o*Z0.y):hx.copy(Z0),n.copy(t),n.x+=hx.x,n.y+=hx.y,n.applyMatrix4(Ete)}(class extends zi{constructor(t){if(super(),this.type="Sprite",void 0===Y0){Y0=new Wi;let e=new Float32Array([-.5,-.5,0,0,0,.5,-.5,0,1,0,.5,.5,0,1,1,-.5,.5,0,0,1]),i=new Dm(e,5);Y0.setIndex([0,1,2,0,2,3]),Y0.setAttribute("position",new Im(i,3,0,!1)),Y0.setAttribute("uv",new Im(i,2,3,!1))}this.geometry=Y0,this.material=void 0!==t?t:new LI,this.center=new $e(.5,.5)}raycast(t,e){null===t.camera&&console.error('THREE.Sprite: "Raycaster.camera" needs to be set in order to raycast against sprites.'),X0.setFromMatrixScale(this.matrixWorld),Ete.copy(t.camera.matrixWorld),this.modelViewMatrix.multiplyMatrices(t.camera.matrixWorldInverse,this.matrixWorld),Q0.setFromMatrixPosition(this.modelViewMatrix),t.camera.isPerspectiveCamera&&!1===this.material.sizeAttenuation&&X0.multiplyScalar(-Q0.z);let r,o,i=this.material.rotation;0!==i&&(o=Math.cos(i),r=Math.sin(i));let a=this.center;uI(cI.set(-.5,-.5,0),Q0,a,X0,r,o),uI(gx.set(.5,-.5,0),Q0,a,X0,r,o),uI(dI.set(.5,.5,0),Q0,a,X0,r,o),Nee.set(0,0),fB.set(1,0),Bee.set(1,1);let s=t.ray.intersectTriangle(cI,gx,dI,!1,mx);if(null===s&&(uI(gx.set(-.5,.5,0),Q0,a,X0,r,o),fB.set(0,1),s=t.ray.intersectTriangle(cI,dI,gx,!1,mx),null===s))return;let l=t.ray.origin.distanceTo(mx);l<t.near||l>t.far||e.push({distance:l,point:mx.clone(),uv:jr.getUV(mx,cI,gx,dI,Nee,fB,Bee,new $e),face:null,object:this})}copy(t){return super.copy(t),void 0!==t.center&&this.center.copy(t.center),this.material=t.material,this}}).prototype.isSprite=!0;var Vee=new $,Hee=new Ki,zee=new Ki,kFe=new $,Uee=new Mn,NI=class extends co{constructor(t,e){super(t,e),this.type="SkinnedMesh",this.bindMode="attached",this.bindMatrix=new Mn,this.bindMatrixInverse=new Mn}copy(t){return super.copy(t),this.bindMode=t.bindMode,this.bindMatrix.copy(t.bindMatrix),this.bindMatrixInverse.copy(t.bindMatrixInverse),this.skeleton=t.skeleton,this}bind(t,e){this.skeleton=t,void 0===e&&(this.updateMatrixWorld(!0),this.skeleton.calculateInverses(),e=this.matrixWorld),this.bindMatrix.copy(e),this.bindMatrixInverse.copy(e).invert()}pose(){this.skeleton.pose()}normalizeSkinWeights(){let t=new Ki,e=this.geometry.attributes.skinWeight;for(let i=0,r=e.count;i<r;i++){t.x=e.getX(i),t.y=e.getY(i),t.z=e.getZ(i),t.w=e.getW(i);let o=1/t.manhattanLength();o!==1/0?t.multiplyScalar(o):t.set(1,0,0,0),e.setXYZW(i,t.x,t.y,t.z,t.w)}}updateMatrixWorld(t){super.updateMatrixWorld(t),"attached"===this.bindMode?this.bindMatrixInverse.copy(this.matrixWorld).invert():"detached"===this.bindMode?this.bindMatrixInverse.copy(this.bindMatrix).invert():console.warn("THREE.SkinnedMesh: Unrecognized bindMode: "+this.bindMode)}boneTransform(t,e){let i=this.skeleton,r=this.geometry;Hee.fromBufferAttribute(r.attributes.skinIndex,t),zee.fromBufferAttribute(r.attributes.skinWeight,t),Vee.copy(e).applyMatrix4(this.bindMatrix),e.set(0,0,0);for(let o=0;o<4;o++){let a=zee.getComponent(o);if(0!==a){let s=Hee.getComponent(o);Uee.multiplyMatrices(i.bones[s].matrixWorld,i.boneInverses[s]),e.addScaledVector(kFe.copy(Vee).applyMatrix4(Uee),a)}}return e.applyMatrix4(this.bindMatrixInverse)}};NI.prototype.isSkinnedMesh=!0,class extends zi{constructor(){super(),this.type="Bone"}}.prototype.isBone=!0,class extends uo{constructor(t=null,e=1,i=1,r,o,a,s,l,c=bo,d=bo,u,p){super(null,a,s,l,c,d,r,o,u,p),this.image={data:t,width:e,height:i},this.magFilter=c,this.minFilter=d,this.generateMipmaps=!1,this.flipY=!1,this.unpackAlignment=1}}.prototype.isDataTexture=!0;var Nx=class extends Ar{constructor(t,e,i,r=1){"number"==typeof i&&(r=i,i=!1,console.error("THREE.InstancedBufferAttribute: The constructor now expects normalized as the third argument.")),super(t,e,i),this.meshPerAttribute=r}copy(t){return super.copy(t),this.meshPerAttribute=t.meshPerAttribute,this}toJSON(){let t=super.toJSON();return t.meshPerAttribute=this.meshPerAttribute,t.isInstancedBufferAttribute=!0,t}};Nx.prototype.isInstancedBufferAttribute=!0;var jee=new Mn,Gee=new Mn,pI=[],_x=new co;(class extends co{constructor(t,e,i){super(t,e),this.instanceMatrix=new Nx(new Float32Array(16*i),16),this.instanceColor=null,this.count=i,this.frustumCulled=!1}copy(t){return super.copy(t),this.instanceMatrix.copy(t.instanceMatrix),null!==t.instanceColor&&(this.instanceColor=t.instanceColor.clone()),this.count=t.count,this}getColorAt(t,e){e.fromArray(this.instanceColor.array,3*t)}getMatrixAt(t,e){e.fromArray(this.instanceMatrix.array,16*t)}raycast(t,e){let i=this.matrixWorld,r=this.count;if(_x.geometry=this.geometry,_x.material=this.material,void 0!==_x.material)for(let o=0;o<r;o++){this.getMatrixAt(o,jee),Gee.multiplyMatrices(i,jee),_x.matrixWorld=Gee,_x.raycast(t,pI);for(let a=0,s=pI.length;a<s;a++){let l=pI[a];l.instanceId=o,l.object=this,e.push(l)}pI.length=0}}setColorAt(t,e){null===this.instanceColor&&(this.instanceColor=new Nx(new Float32Array(3*this.instanceMatrix.count),3)),e.toArray(this.instanceColor.array,3*t)}setMatrixAt(t,e){e.toArray(this.instanceMatrix.array,16*t)}updateMorphTargets(){}dispose(){this.dispatchEvent({type:"dispose"})}}).prototype.isInstancedMesh=!0;var Wd=class extends Ro{constructor(t){super(),this.type="LineBasicMaterial",this.color=new an(16777215),this.linewidth=1,this.linecap="round",this.linejoin="round",this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.linewidth=t.linewidth,this.linecap=t.linecap,this.linejoin=t.linejoin,this}};Wd.prototype.isLineBasicMaterial=!0;var Wee=new $,qee=new $,Yee=new Mn,mB=new Sp,fI=new wp,Bx=class extends zi{constructor(t=new Wi,e=new Wd){super(),this.type="Line",this.geometry=t,this.material=e,this.updateMorphTargets()}copy(t){return super.copy(t),this.material=t.material,this.geometry=t.geometry,this}computeLineDistances(){let t=this.geometry;if(t.isBufferGeometry)if(null===t.index){let e=t.attributes.position,i=[0];for(let r=1,o=e.count;r<o;r++)Wee.fromBufferAttribute(e,r-1),qee.fromBufferAttribute(e,r),i[r]=i[r-1],i[r]+=Wee.distanceTo(qee);t.setAttribute("lineDistance",new Br(i,1))}else console.warn("THREE.Line.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.");else t.isGeometry&&console.error("THREE.Line.computeLineDistances() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.");return this}raycast(t,e){let i=this.geometry,r=this.matrixWorld,o=t.params.Line.threshold,a=i.drawRange;if(null===i.boundingSphere&&i.computeBoundingSphere(),fI.copy(i.boundingSphere),fI.applyMatrix4(r),fI.radius+=o,!1===t.ray.intersectsSphere(fI))return;Yee.copy(r).invert(),mB.copy(t.ray).applyMatrix4(Yee);let s=o/((this.scale.x+this.scale.y+this.scale.z)/3),l=s*s,c=new $,d=new $,u=new $,p=new $,f=this.isLineSegments?2:1;if(i.isBufferGeometry){let m=i.index,M=i.attributes.position;if(null!==m)for(let R=Math.max(0,a.start),A=Math.min(m.count,a.start+a.count)-1;R<A;R+=f){let H=m.getX(R),te=m.getX(R+1);if(c.fromBufferAttribute(M,H),d.fromBufferAttribute(M,te),mB.distanceSqToSegment(c,d,p,u)>l)continue;p.applyMatrix4(this.matrixWorld);let Ce=t.ray.origin.distanceTo(p);Ce<t.near||Ce>t.far||e.push({distance:Ce,point:u.clone().applyMatrix4(this.matrixWorld),index:R,face:null,faceIndex:null,object:this})}else for(let R=Math.max(0,a.start),A=Math.min(M.count,a.start+a.count)-1;R<A;R+=f){if(c.fromBufferAttribute(M,R),d.fromBufferAttribute(M,R+1),mB.distanceSqToSegment(c,d,p,u)>l)continue;p.applyMatrix4(this.matrixWorld);let te=t.ray.origin.distanceTo(p);te<t.near||te>t.far||e.push({distance:te,point:u.clone().applyMatrix4(this.matrixWorld),index:R,face:null,faceIndex:null,object:this})}}else i.isGeometry&&console.error("THREE.Line.raycast() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}updateMorphTargets(){let t=this.geometry;if(t.isBufferGeometry){let e=t.morphAttributes,i=Object.keys(e);if(i.length>0){let r=e[i[0]];if(void 0!==r){this.morphTargetInfluences=[],this.morphTargetDictionary={};for(let o=0,a=r.length;o<a;o++){let s=r[o].name||String(o);this.morphTargetInfluences.push(0),this.morphTargetDictionary[s]=o}}}}else{let e=t.morphTargets;void 0!==e&&e.length>0&&console.error("THREE.Line.updateMorphTargets() does not support THREE.Geometry. Use THREE.BufferGeometry instead.")}}};Bx.prototype.isLine=!0;var Xee=new $,Qee=new $,Vx=class extends Bx{constructor(t,e){super(t,e),this.type="LineSegments"}computeLineDistances(){let t=this.geometry;if(t.isBufferGeometry)if(null===t.index){let e=t.attributes.position,i=[];for(let r=0,o=e.count;r<o;r+=2)Xee.fromBufferAttribute(e,r),Qee.fromBufferAttribute(e,r+1),i[r]=0===r?0:i[r-1],i[r+1]=i[r]+Xee.distanceTo(Qee);t.setAttribute("lineDistance",new Br(i,1))}else console.warn("THREE.LineSegments.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.");else t.isGeometry&&console.error("THREE.LineSegments.computeLineDistances() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.");return this}};Vx.prototype.isLineSegments=!0,class extends Bx{constructor(t,e){super(t,e),this.type="LineLoop"}}.prototype.isLineLoop=!0;var BI=class extends Ro{constructor(t){super(),this.type="PointsMaterial",this.color=new an(16777215),this.map=null,this.alphaMap=null,this.size=1,this.sizeAttenuation=!0,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.alphaMap=t.alphaMap,this.size=t.size,this.sizeAttenuation=t.sizeAttenuation,this}};BI.prototype.isPointsMaterial=!0;var Zee=new Mn,VB=new Sp,mI=new wp,hI=new $;function Kee(n,t,e,i,r,o,a){let s=VB.distanceSqToPoint(n);if(s<e){let l=new $;VB.closestPointToPoint(n,l),l.applyMatrix4(i);let c=r.ray.origin.distanceTo(l);if(c<r.near||c>r.far)return;o.push({distance:c,distanceToRay:Math.sqrt(s),point:l,index:t,face:null,object:a})}}(class extends zi{constructor(t=new Wi,e=new BI){super(),this.type="Points",this.geometry=t,this.material=e,this.updateMorphTargets()}copy(t){return super.copy(t),this.material=t.material,this.geometry=t.geometry,this}raycast(t,e){let i=this.geometry,r=this.matrixWorld,o=t.params.Points.threshold,a=i.drawRange;if(null===i.boundingSphere&&i.computeBoundingSphere(),mI.copy(i.boundingSphere),mI.applyMatrix4(r),mI.radius+=o,!1===t.ray.intersectsSphere(mI))return;Zee.copy(r).invert(),VB.copy(t.ray).applyMatrix4(Zee);let s=o/((this.scale.x+this.scale.y+this.scale.z)/3),l=s*s;if(i.isBufferGeometry){let c=i.index,u=i.attributes.position;if(null!==c)for(let m=Math.max(0,a.start),y=Math.min(c.count,a.start+a.count);m<y;m++){let M=c.getX(m);hI.fromBufferAttribute(u,M),Kee(hI,M,l,r,t,e,this)}else for(let m=Math.max(0,a.start),y=Math.min(u.count,a.start+a.count);m<y;m++)hI.fromBufferAttribute(u,m),Kee(hI,m,l,r,t,e,this)}else console.error("THREE.Points.raycast() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}updateMorphTargets(){let t=this.geometry;if(t.isBufferGeometry){let e=t.morphAttributes,i=Object.keys(e);if(i.length>0){let r=e[i[0]];if(void 0!==r){this.morphTargetInfluences=[],this.morphTargetDictionary={};for(let o=0,a=r.length;o<a;o++){let s=r[o].name||String(o);this.morphTargetInfluences.push(0),this.morphTargetDictionary[s]=o}}}}else{let e=t.morphTargets;void 0!==e&&e.length>0&&console.error("THREE.Points.updateMorphTargets() does not support THREE.Geometry. Use THREE.BufferGeometry instead.")}}}).prototype.isPoints=!0,class extends uo{constructor(t,e,i,r,o,a,s,l,c){super(t,e,i,r,o,a,s,l,c),this.minFilter=void 0!==a?a:ra,this.magFilter=void 0!==o?o:ra,this.generateMipmaps=!1;let d=this;"requestVideoFrameCallback"in t&&t.requestVideoFrameCallback(function u(){d.needsUpdate=!0,t.requestVideoFrameCallback(u)})}clone(){return new this.constructor(this.image).copy(this)}update(){let t=this.image;"requestVideoFrameCallback"in t==0&&t.readyState>=t.HAVE_CURRENT_DATA&&(this.needsUpdate=!0)}}.prototype.isVideoTexture=!0,class extends uo{constructor(t,e,i){super({width:t,height:e}),this.format=i,this.magFilter=bo,this.minFilter=bo,this.generateMipmaps=!1,this.needsUpdate=!0}}.prototype.isFramebufferTexture=!0,class extends uo{constructor(t,e,i,r,o,a,s,l,c,d,u,p){super(null,a,s,l,c,d,r,o,u,p),this.image={width:e,height:i},this.mipmaps=t,this.flipY=!1,this.generateMipmaps=!1}}.prototype.isCompressedTexture=!0,class extends uo{constructor(t,e,i,r,o,a,s,l,c){super(t,e,i,r,o,a,s,l,c),this.needsUpdate=!0}}.prototype.isCanvasTexture=!0;var p_=class extends Wi{constructor(t=1,e=8,i=0,r=2*Math.PI){super(),this.type="CircleGeometry",this.parameters={radius:t,segments:e,thetaStart:i,thetaLength:r},e=Math.max(3,e);let o=[],a=[],s=[],l=[],c=new $,d=new $e;a.push(0,0,0),s.push(0,0,1),l.push(.5,.5);for(let u=0,p=3;u<=e;u++,p+=3){let f=i+u/e*r;c.x=t*Math.cos(f),c.y=t*Math.sin(f),a.push(c.x,c.y,c.z),s.push(0,0,1),d.x=(a[p]/t+1)/2,d.y=(a[p+1]/t+1)/2,l.push(d.x,d.y)}for(let u=1;u<=e;u++)o.push(u,u+1,0);this.setIndex(o),this.setAttribute("position",new Br(a,3)),this.setAttribute("normal",new Br(s,3)),this.setAttribute("uv",new Br(l,2))}static fromJSON(t){return new p_(t.radius,t.segments,t.thetaStart,t.thetaLength)}},Za=(new $,new $,new $,new jr,class{constructor(){this.type="Curve",this.arcLengthDivisions=200}getPoint(){return console.warn("THREE.Curve: .getPoint() not implemented."),null}getPointAt(t,e){let i=this.getUtoTmapping(t);return this.getPoint(i,e)}getPoints(t=5){let e=[];for(let i=0;i<=t;i++)e.push(this.getPoint(i/t));return e}getSpacedPoints(t=5){let e=[];for(let i=0;i<=t;i++)e.push(this.getPointAt(i/t));return e}getLength(){let t=this.getLengths();return t[t.length-1]}getLengths(t=this.arcLengthDivisions){if(this.cacheArcLengths&&this.cacheArcLengths.length===t+1&&!this.needsUpdate)return this.cacheArcLengths;this.needsUpdate=!1;let i,e=[],r=this.getPoint(0),o=0;e.push(0);for(let a=1;a<=t;a++)i=this.getPoint(a/t),o+=i.distanceTo(r),e.push(o),r=i;return this.cacheArcLengths=e,e}updateArcLengths(){this.needsUpdate=!0,this.getLengths()}getUtoTmapping(t,e){let a,i=this.getLengths(),r=0,o=i.length;a=e||t*i[o-1];let c,s=0,l=o-1;for(;s<=l;)if(r=Math.floor(s+(l-s)/2),c=i[r]-a,c<0)s=r+1;else{if(!(c>0)){l=r;break}l=r-1}if(r=l,i[r]===a)return r/(o-1);let d=i[r];return(r+(a-d)/(i[r+1]-d))/(o-1)}getTangent(t,e){let r=t-1e-4,o=t+1e-4;r<0&&(r=0),o>1&&(o=1);let a=this.getPoint(r),s=this.getPoint(o),l=e||(a.isVector2?new $e:new $);return l.copy(s).sub(a).normalize(),l}getTangentAt(t,e){let i=this.getUtoTmapping(t);return this.getTangent(i,e)}computeFrenetFrames(t,e){let i=new $,r=[],o=[],a=[],s=new $,l=new Mn;for(let f=0;f<=t;f++)r[f]=this.getTangentAt(f/t,new $);o[0]=new $,a[0]=new $;let c=Number.MAX_VALUE,d=Math.abs(r[0].x),u=Math.abs(r[0].y),p=Math.abs(r[0].z);d<=c&&(c=d,i.set(1,0,0)),u<=c&&(c=u,i.set(0,1,0)),p<=c&&i.set(0,0,1),s.crossVectors(r[0],i).normalize(),o[0].crossVectors(r[0],s),a[0].crossVectors(r[0],o[0]);for(let f=1;f<=t;f++){if(o[f]=o[f-1].clone(),a[f]=a[f-1].clone(),s.crossVectors(r[f-1],r[f]),s.length()>Number.EPSILON){s.normalize();let m=Math.acos(Xa(r[f-1].dot(r[f]),-1,1));o[f].applyMatrix4(l.makeRotationAxis(s,m))}a[f].crossVectors(r[f],o[f])}if(!0===e){let f=Math.acos(Xa(o[0].dot(o[t]),-1,1));f/=t,r[0].dot(s.crossVectors(o[0],o[t]))>0&&(f=-f);for(let m=1;m<=t;m++)o[m].applyMatrix4(l.makeRotationAxis(r[m],f*m)),a[m].crossVectors(r[m],o[m])}return{tangents:r,normals:o,binormals:a}}clone(){return(new this.constructor).copy(this)}copy(t){return this.arcLengthDivisions=t.arcLengthDivisions,this}toJSON(){let t={metadata:{version:4.5,type:"Curve",generator:"Curve.toJSON"}};return t.arcLengthDivisions=this.arcLengthDivisions,t.type=this.type,t}fromJSON(t){return this.arcLengthDivisions=t.arcLengthDivisions,this}}),f_=class extends Za{constructor(t=0,e=0,i=1,r=1,o=0,a=2*Math.PI,s=!1,l=0){super(),this.type="EllipseCurve",this.aX=t,this.aY=e,this.xRadius=i,this.yRadius=r,this.aStartAngle=o,this.aEndAngle=a,this.aClockwise=s,this.aRotation=l}getPoint(t,e){let i=e||new $e,r=2*Math.PI,o=this.aEndAngle-this.aStartAngle,a=Math.abs(o)<Number.EPSILON;for(;o<0;)o+=r;for(;o>r;)o-=r;o<Number.EPSILON&&(o=a?0:r),!0===this.aClockwise&&!a&&(o===r?o=-r:o-=r);let s=this.aStartAngle+t*o,l=this.aX+this.xRadius*Math.cos(s),c=this.aY+this.yRadius*Math.sin(s);if(0!==this.aRotation){let d=Math.cos(this.aRotation),u=Math.sin(this.aRotation),p=l-this.aX,f=c-this.aY;l=p*d-f*u+this.aX,c=p*u+f*d+this.aY}return i.set(l,c)}copy(t){return super.copy(t),this.aX=t.aX,this.aY=t.aY,this.xRadius=t.xRadius,this.yRadius=t.yRadius,this.aStartAngle=t.aStartAngle,this.aEndAngle=t.aEndAngle,this.aClockwise=t.aClockwise,this.aRotation=t.aRotation,this}toJSON(){let t=super.toJSON();return t.aX=this.aX,t.aY=this.aY,t.xRadius=this.xRadius,t.yRadius=this.yRadius,t.aStartAngle=this.aStartAngle,t.aEndAngle=this.aEndAngle,t.aClockwise=this.aClockwise,t.aRotation=this.aRotation,t}fromJSON(t){return super.fromJSON(t),this.aX=t.aX,this.aY=t.aY,this.xRadius=t.xRadius,this.yRadius=t.yRadius,this.aStartAngle=t.aStartAngle,this.aEndAngle=t.aEndAngle,this.aClockwise=t.aClockwise,this.aRotation=t.aRotation,this}};f_.prototype.isEllipseCurve=!0;var VI=class extends f_{constructor(t,e,i,r,o,a){super(t,e,i,i,r,o,a),this.type="ArcCurve"}};function BV(){let n=0,t=0,e=0,i=0;function r(o,a,s,l){n=o,t=s,e=-3*o+3*a-2*s-l,i=2*o-2*a+s+l}return{initCatmullRom:function(o,a,s,l,c){r(a,s,c*(s-o),c*(l-a))},initNonuniformCatmullRom:function(o,a,s,l,c,d,u){let p=(a-o)/c-(s-o)/(c+d)+(s-a)/d,f=(s-a)/d-(l-a)/(d+u)+(l-s)/u;p*=d,f*=d,r(a,s,p,f)},calc:function(o){let a=o*o;return n+t*o+e*a+i*(a*o)}}}VI.prototype.isArcCurve=!0;var gI=new $,hB=new BV,gB=new BV,_B=new BV,HI=class extends Za{constructor(t=[],e=!1,i="centripetal",r=.5){super(),this.type="CatmullRomCurve3",this.points=t,this.closed=e,this.curveType=i,this.tension=r}getPoint(t,e=new $){let c,d,i=e,r=this.points,o=r.length,a=(o-(this.closed?0:1))*t,s=Math.floor(a),l=a-s;this.closed?s+=s>0?0:(Math.floor(Math.abs(s)/o)+1)*o:0===l&&s===o-1&&(s=o-2,l=1),this.closed||s>0?c=r[(s-1)%o]:(gI.subVectors(r[0],r[1]).add(r[0]),c=gI);let u=r[s%o],p=r[(s+1)%o];if(this.closed||s+2<o?d=r[(s+2)%o]:(gI.subVectors(r[o-1],r[o-2]).add(r[o-1]),d=gI),"centripetal"===this.curveType||"chordal"===this.curveType){let f="chordal"===this.curveType?.5:.25,m=Math.pow(c.distanceToSquared(u),f),y=Math.pow(u.distanceToSquared(p),f),M=Math.pow(p.distanceToSquared(d),f);y<1e-4&&(y=1),m<1e-4&&(m=y),M<1e-4&&(M=y),hB.initNonuniformCatmullRom(c.x,u.x,p.x,d.x,m,y,M),gB.initNonuniformCatmullRom(c.y,u.y,p.y,d.y,m,y,M),_B.initNonuniformCatmullRom(c.z,u.z,p.z,d.z,m,y,M)}else"catmullrom"===this.curveType&&(hB.initCatmullRom(c.x,u.x,p.x,d.x,this.tension),gB.initCatmullRom(c.y,u.y,p.y,d.y,this.tension),_B.initCatmullRom(c.z,u.z,p.z,d.z,this.tension));return i.set(hB.calc(l),gB.calc(l),_B.calc(l)),i}copy(t){super.copy(t),this.points=[];for(let e=0,i=t.points.length;e<i;e++)this.points.push(t.points[e].clone());return this.closed=t.closed,this.curveType=t.curveType,this.tension=t.tension,this}toJSON(){let t=super.toJSON();t.points=[];for(let e=0,i=this.points.length;e<i;e++)t.points.push(this.points[e].toArray());return t.closed=this.closed,t.curveType=this.curveType,t.tension=this.tension,t}fromJSON(t){super.fromJSON(t),this.points=[];for(let e=0,i=t.points.length;e<i;e++){let r=t.points[e];this.points.push((new $).fromArray(r))}return this.closed=t.closed,this.curveType=t.curveType,this.tension=t.tension,this}};function Jee(n,t,e,i,r){let o=.5*(i-t),a=.5*(r-e),s=n*n;return(2*e-2*i+o+a)*(n*s)+(-3*e+3*i-2*o-a)*s+o*n+e}function Mx(n,t,e,i){return function(n,t){let e=1-n;return e*e*t}(n,t)+function(n,t){return 2*(1-n)*n*t}(n,e)+function(n,t){return n*n*t}(n,i)}function wx(n,t,e,i,r){return function(n,t){let e=1-n;return e*e*e*t}(n,t)+function(n,t){let e=1-n;return 3*e*e*n*t}(n,e)+function(n,t){return 3*(1-n)*n*n*t}(n,i)+function(n,t){return n*n*n*t}(n,r)}HI.prototype.isCatmullRomCurve3=!0;var Hx=class extends Za{constructor(t=new $e,e=new $e,i=new $e,r=new $e){super(),this.type="CubicBezierCurve",this.v0=t,this.v1=e,this.v2=i,this.v3=r}getPoint(t,e=new $e){let i=e,r=this.v0,o=this.v1,a=this.v2,s=this.v3;return i.set(wx(t,r.x,o.x,a.x,s.x),wx(t,r.y,o.y,a.y,s.y)),i}copy(t){return super.copy(t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this.v3.copy(t.v3),this}toJSON(){let t=super.toJSON();return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t.v3=this.v3.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this.v3.fromArray(t.v3),this}};Hx.prototype.isCubicBezierCurve=!0;var zI=class extends Za{constructor(t=new $,e=new $,i=new $,r=new $){super(),this.type="CubicBezierCurve3",this.v0=t,this.v1=e,this.v2=i,this.v3=r}getPoint(t,e=new $){let i=e,r=this.v0,o=this.v1,a=this.v2,s=this.v3;return i.set(wx(t,r.x,o.x,a.x,s.x),wx(t,r.y,o.y,a.y,s.y),wx(t,r.z,o.z,a.z,s.z)),i}copy(t){return super.copy(t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this.v3.copy(t.v3),this}toJSON(){let t=super.toJSON();return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t.v3=this.v3.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this.v3.fromArray(t.v3),this}};zI.prototype.isCubicBezierCurve3=!0;var m_=class extends Za{constructor(t=new $e,e=new $e){super(),this.type="LineCurve",this.v1=t,this.v2=e}getPoint(t,e=new $e){let i=e;return 1===t?i.copy(this.v2):(i.copy(this.v2).sub(this.v1),i.multiplyScalar(t).add(this.v1)),i}getPointAt(t,e){return this.getPoint(t,e)}getTangent(t,e){let i=e||new $e;return i.copy(this.v2).sub(this.v1).normalize(),i}copy(t){return super.copy(t),this.v1.copy(t.v1),this.v2.copy(t.v2),this}toJSON(){let t=super.toJSON();return t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this}};m_.prototype.isLineCurve=!0;var zx=class extends Za{constructor(t=new $e,e=new $e,i=new $e){super(),this.type="QuadraticBezierCurve",this.v0=t,this.v1=e,this.v2=i}getPoint(t,e=new $e){let i=e,r=this.v0,o=this.v1,a=this.v2;return i.set(Mx(t,r.x,o.x,a.x),Mx(t,r.y,o.y,a.y)),i}copy(t){return super.copy(t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this}toJSON(){let t=super.toJSON();return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this}};zx.prototype.isQuadraticBezierCurve=!0;var UI=class extends Za{constructor(t=new $,e=new $,i=new $){super(),this.type="QuadraticBezierCurve3",this.v0=t,this.v1=e,this.v2=i}getPoint(t,e=new $){let i=e,r=this.v0,o=this.v1,a=this.v2;return i.set(Mx(t,r.x,o.x,a.x),Mx(t,r.y,o.y,a.y),Mx(t,r.z,o.z,a.z)),i}copy(t){return super.copy(t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this}toJSON(){let t=super.toJSON();return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this}};UI.prototype.isQuadraticBezierCurve3=!0;var Ux=class extends Za{constructor(t=[]){super(),this.type="SplineCurve",this.points=t}getPoint(t,e=new $e){let i=e,r=this.points,o=(r.length-1)*t,a=Math.floor(o),s=o-a,l=r[0===a?a:a-1],c=r[a],d=r[a>r.length-2?r.length-1:a+1],u=r[a>r.length-3?r.length-1:a+2];return i.set(Jee(s,l.x,c.x,d.x,u.x),Jee(s,l.y,c.y,d.y,u.y)),i}copy(t){super.copy(t),this.points=[];for(let e=0,i=t.points.length;e<i;e++)this.points.push(t.points[e].clone());return this}toJSON(){let t=super.toJSON();t.points=[];for(let e=0,i=this.points.length;e<i;e++)t.points.push(this.points[e].toArray());return t}fromJSON(t){super.fromJSON(t),this.points=[];for(let e=0,i=t.points.length;e<i;e++){let r=t.points[e];this.points.push((new $e).fromArray(r))}return this}};Ux.prototype.isSplineCurve=!0;var Tte=Object.freeze({__proto__:null,ArcCurve:VI,CatmullRomCurve3:HI,CubicBezierCurve:Hx,CubicBezierCurve3:zI,EllipseCurve:f_,LineCurve:m_,LineCurve3:class extends Za{constructor(t=new $,e=new $){super(),this.type="LineCurve3",this.isLineCurve3=!0,this.v1=t,this.v2=e}getPoint(t,e=new $){let i=e;return 1===t?i.copy(this.v2):(i.copy(this.v2).sub(this.v1),i.multiplyScalar(t).add(this.v1)),i}getPointAt(t,e){return this.getPoint(t,e)}copy(t){return super.copy(t),this.v1.copy(t.v1),this.v2.copy(t.v2),this}toJSON(){let t=super.toJSON();return t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this}},QuadraticBezierCurve:zx,QuadraticBezierCurve3:UI,SplineCurve:Ux}),qB=class extends Za{constructor(){super(),this.type="CurvePath",this.curves=[],this.autoClose=!1}add(t){this.curves.push(t)}closePath(){let t=this.curves[0].getPoint(0),e=this.curves[this.curves.length-1].getPoint(1);t.equals(e)||this.curves.push(new m_(e,t))}getPoint(t,e){let i=t*this.getLength(),r=this.getCurveLengths(),o=0;for(;o<r.length;){if(r[o]>=i){let a=r[o]-i,s=this.curves[o],l=s.getLength();return s.getPointAt(0===l?0:1-a/l,e)}o++}return null}getLength(){let t=this.getCurveLengths();return t[t.length-1]}updateArcLengths(){this.needsUpdate=!0,this.cacheLengths=null,this.getCurveLengths()}getCurveLengths(){if(this.cacheLengths&&this.cacheLengths.length===this.curves.length)return this.cacheLengths;let t=[],e=0;for(let i=0,r=this.curves.length;i<r;i++)e+=this.curves[i].getLength(),t.push(e);return this.cacheLengths=t,t}getSpacedPoints(t=40){let e=[];for(let i=0;i<=t;i++)e.push(this.getPoint(i/t));return this.autoClose&&e.push(e[0]),e}getPoints(t=12){let i,e=[];for(let r=0,o=this.curves;r<o.length;r++){let a=o[r],l=a.getPoints(a&&a.isEllipseCurve?2*t:a&&(a.isLineCurve||a.isLineCurve3)?1:a&&a.isSplineCurve?t*a.points.length:t);for(let c=0;c<l.length;c++){let d=l[c];i&&i.equals(d)||(e.push(d),i=d)}}return this.autoClose&&e.length>1&&!e[e.length-1].equals(e[0])&&e.push(e[0]),e}copy(t){super.copy(t),this.curves=[];for(let e=0,i=t.curves.length;e<i;e++)this.curves.push(t.curves[e].clone());return this.autoClose=t.autoClose,this}toJSON(){let t=super.toJSON();t.autoClose=this.autoClose,t.curves=[];for(let e=0,i=this.curves.length;e<i;e++)t.curves.push(this.curves[e].toJSON());return t}fromJSON(t){super.fromJSON(t),this.autoClose=t.autoClose,this.curves=[];for(let e=0,i=t.curves.length;e<i;e++){let r=t.curves[e];this.curves.push((new Tte[r.type]).fromJSON(r))}return this}},jx=class extends qB{constructor(t){super(),this.type="Path",this.currentPoint=new $e,t&&this.setFromPoints(t)}setFromPoints(t){this.moveTo(t[0].x,t[0].y);for(let e=1,i=t.length;e<i;e++)this.lineTo(t[e].x,t[e].y);return this}moveTo(t,e){return this.currentPoint.set(t,e),this}lineTo(t,e){let i=new m_(this.currentPoint.clone(),new $e(t,e));return this.curves.push(i),this.currentPoint.set(t,e),this}quadraticCurveTo(t,e,i,r){let o=new zx(this.currentPoint.clone(),new $e(t,e),new $e(i,r));return this.curves.push(o),this.currentPoint.set(i,r),this}bezierCurveTo(t,e,i,r,o,a){let s=new Hx(this.currentPoint.clone(),new $e(t,e),new $e(i,r),new $e(o,a));return this.curves.push(s),this.currentPoint.set(o,a),this}splineThru(t){let e=[this.currentPoint.clone()].concat(t),i=new Ux(e);return this.curves.push(i),this.currentPoint.copy(t[t.length-1]),this}arc(t,e,i,r,o,a){return this.absarc(t+this.currentPoint.x,e+this.currentPoint.y,i,r,o,a),this}absarc(t,e,i,r,o,a){return this.absellipse(t,e,i,i,r,o,a),this}ellipse(t,e,i,r,o,a,s,l){return this.absellipse(t+this.currentPoint.x,e+this.currentPoint.y,i,r,o,a,s,l),this}absellipse(t,e,i,r,o,a,s,l){let c=new f_(t,e,i,r,o,a,s,l);if(this.curves.length>0){let u=c.getPoint(0);u.equals(this.currentPoint)||this.lineTo(u.x,u.y)}this.curves.push(c);let d=c.getPoint(1);return this.currentPoint.copy(d),this}copy(t){return super.copy(t),this.currentPoint.copy(t.currentPoint),this}toJSON(){let t=super.toJSON();return t.currentPoint=this.currentPoint.toArray(),t}fromJSON(t){return super.fromJSON(t),this.currentPoint.fromArray(t.currentPoint),this}},qd=class extends jx{constructor(t){super(t),this.uuid=Ql(),this.type="Shape",this.holes=[]}getPointsHoles(t){let e=[];for(let i=0,r=this.holes.length;i<r;i++)e[i]=this.holes[i].getPoints(t);return e}extractPoints(t){return{shape:this.getPoints(t),holes:this.getPointsHoles(t)}}copy(t){super.copy(t),this.holes=[];for(let e=0,i=t.holes.length;e<i;e++)this.holes.push(t.holes[e].clone());return this}toJSON(){let t=super.toJSON();t.uuid=this.uuid,t.holes=[];for(let e=0,i=this.holes.length;e<i;e++)t.holes.push(this.holes[e].toJSON());return t}fromJSON(t){super.fromJSON(t),this.uuid=t.uuid,this.holes=[];for(let e=0,i=t.holes.length;e<i;e++){let r=t.holes[e];this.holes.push((new jx).fromJSON(r))}return this}};function Dte(n,t,e,i,r){let o,a;if(r===function(n,t,e,i){let r=0;for(let o=t,a=e-i;o<e;o+=i)r+=(n[a]-n[o])*(n[o+1]+n[a+1]),a=o;return r}(n,t,e,i)>0)for(o=t;o<e;o+=i)a=$ee(o,n[o],n[o+1],a);else for(o=e-i;o>=t;o-=i)a=$ee(o,n[o],n[o+1],a);return a&&nA(a,a.next)&&(qx(a),a=a.next),a}function Tp(n,t){if(!n)return n;t||(t=n);let i,e=n;do{if(i=!1,e.steiner||!nA(e,e.next)&&0!==Nr(e.prev,e,e.next))e=e.next;else{if(qx(e),e=t=e.prev,e===e.next)break;i=!0}}while(i||e!==t);return t}function Gx(n,t,e,i,r,o,a){if(!n)return;!a&&o&&function(n,t,e,i){let r=n;do{null===r.z&&(r.z=YB(r.x,r.y,t,e,i)),r.prevZ=r.prev,r.nextZ=r.next,r=r.next}while(r!==n);r.prevZ.nextZ=null,r.prevZ=null,function(n){let t,e,i,r,o,a,s,l,c=1;do{for(e=n,n=null,o=null,a=0;e;){for(a++,i=e,s=0,t=0;t<c&&(s++,i=i.nextZ,i);t++);for(l=c;s>0||l>0&&i;)0!==s&&(0===l||!i||e.z<=i.z)?(r=e,e=e.nextZ,s--):(r=i,i=i.nextZ,l--),o?o.nextZ=r:n=r,r.prevZ=o,o=r;e=i}o.nextZ=null,c*=2}while(a>1)}(r)}(n,i,r,o);let l,c,s=n;for(;n.prev!==n.next;)if(l=n.prev,c=n.next,o?UFe(n,i,r,o):zFe(n))t.push(l.i/e),t.push(n.i/e),t.push(c.i/e),qx(n),n=c.next,s=c.next;else if((n=c)===s){a?1===a?Gx(n=jFe(Tp(n),t,e),t,e,i,r,o,2):2===a&&GFe(n,t,e,i,r,o):Gx(Tp(n),t,e,i,r,o,1);break}}function zFe(n){let t=n.prev,e=n,i=n.next;if(Nr(t,e,i)>=0)return!1;let r=n.next.next;for(;r!==n.prev;){if(e_(t.x,t.y,e.x,e.y,i.x,i.y,r.x,r.y)&&Nr(r.prev,r,r.next)>=0)return!1;r=r.next}return!0}function UFe(n,t,e,i){let r=n.prev,o=n,a=n.next;if(Nr(r,o,a)>=0)return!1;let c=r.x>o.x?r.x>a.x?r.x:a.x:o.x>a.x?o.x:a.x,d=r.y>o.y?r.y>a.y?r.y:a.y:o.y>a.y?o.y:a.y,u=YB(r.x<o.x?r.x<a.x?r.x:a.x:o.x<a.x?o.x:a.x,r.y<o.y?r.y<a.y?r.y:a.y:o.y<a.y?o.y:a.y,t,e,i),p=YB(c,d,t,e,i),f=n.prevZ,m=n.nextZ;for(;f&&f.z>=u&&m&&m.z<=p;){if(f!==n.prev&&f!==n.next&&e_(r.x,r.y,o.x,o.y,a.x,a.y,f.x,f.y)&&Nr(f.prev,f,f.next)>=0||(f=f.prevZ,m!==n.prev&&m!==n.next&&e_(r.x,r.y,o.x,o.y,a.x,a.y,m.x,m.y)&&Nr(m.prev,m,m.next)>=0))return!1;m=m.nextZ}for(;f&&f.z>=u;){if(f!==n.prev&&f!==n.next&&e_(r.x,r.y,o.x,o.y,a.x,a.y,f.x,f.y)&&Nr(f.prev,f,f.next)>=0)return!1;f=f.prevZ}for(;m&&m.z<=p;){if(m!==n.prev&&m!==n.next&&e_(r.x,r.y,o.x,o.y,a.x,a.y,m.x,m.y)&&Nr(m.prev,m,m.next)>=0)return!1;m=m.nextZ}return!0}function jFe(n,t,e){let i=n;do{let r=i.prev,o=i.next.next;!nA(r,o)&&Ite(r,i,i.next,o)&&Wx(r,o)&&Wx(o,r)&&(t.push(r.i/e),t.push(i.i/e),t.push(o.i/e),qx(i),qx(i.next),i=n=o),i=i.next}while(i!==n);return Tp(i)}function GFe(n,t,e,i,r,o){let a=n;do{let s=a.next.next;for(;s!==a.prev;){if(a.i!==s.i&&$Fe(a,s)){let l=Ate(a,s);return a=Tp(a,a.next),l=Tp(l,l.next),Gx(a,t,e,i,r,o),void Gx(l,t,e,i,r,o)}s=s.next}a=a.next}while(a!==n)}function qFe(n,t){return n.x-t.x}function YFe(n,t){if(t=function(n,t){let a,e=t,i=n.x,r=n.y,o=-1/0;do{if(r<=e.y&&r>=e.next.y&&e.next.y!==e.y){let p=e.x+(r-e.y)*(e.next.x-e.x)/(e.next.y-e.y);if(p<=i&&p>o){if(o=p,p===i){if(r===e.y)return e;if(r===e.next.y)return e.next}a=e.x<e.next.x?e:e.next}}e=e.next}while(e!==t);if(!a)return null;if(i===o)return a;let u,s=a,l=a.x,c=a.y,d=1/0;e=a;do{i>=e.x&&e.x>=l&&i!==e.x&&e_(r<c?i:o,r,l,c,r<c?o:i,r,e.x,e.y)&&(u=Math.abs(r-e.y)/(i-e.x),Wx(e,n)&&(u<d||u===d&&(e.x>a.x||e.x===a.x&&QFe(a,e)))&&(a=e,d=u)),e=e.next}while(e!==s);return a}(n,t),t){let e=Ate(t,n);Tp(t,t.next),Tp(e,e.next)}}function QFe(n,t){return Nr(n.prev,n,t.prev)<0&&Nr(t.next,n,n.next)<0}function YB(n,t,e,i,r){return(n=1431655765&((n=858993459&((n=252645135&((n=16711935&((n=32767*(n-e)*r)|n<<8))|n<<4))|n<<2))|n<<1))|(t=1431655765&((t=858993459&((t=252645135&((t=16711935&((t=32767*(t-i)*r)|t<<8))|t<<4))|t<<2))|t<<1))<<1}function JFe(n){let t=n,e=n;do{(t.x<e.x||t.x===e.x&&t.y<e.y)&&(e=t),t=t.next}while(t!==n);return e}function e_(n,t,e,i,r,o,a,s){return(r-a)*(t-s)-(n-a)*(o-s)>=0&&(n-a)*(i-s)-(e-a)*(t-s)>=0&&(e-a)*(o-s)-(r-a)*(i-s)>=0}function $Fe(n,t){return n.next.i!==t.i&&n.prev.i!==t.i&&!function(n,t){let e=n;do{if(e.i!==n.i&&e.next.i!==n.i&&e.i!==t.i&&e.next.i!==t.i&&Ite(e,e.next,n,t))return!0;e=e.next}while(e!==n);return!1}(n,t)&&(Wx(n,t)&&Wx(t,n)&&function(n,t){let e=n,i=!1,r=(n.x+t.x)/2,o=(n.y+t.y)/2;do{e.y>o!=e.next.y>o&&e.next.y!==e.y&&r<(e.next.x-e.x)*(o-e.y)/(e.next.y-e.y)+e.x&&(i=!i),e=e.next}while(e!==n);return i}(n,t)&&(Nr(n.prev,n,t.prev)||Nr(n,t.prev,t))||nA(n,t)&&Nr(n.prev,n,n.next)>0&&Nr(t.prev,t,t.next)>0)}function Nr(n,t,e){return(t.y-n.y)*(e.x-t.x)-(t.x-n.x)*(e.y-t.y)}function nA(n,t){return n.x===t.x&&n.y===t.y}function Ite(n,t,e,i){let r=yI(Nr(n,t,e)),o=yI(Nr(n,t,i)),a=yI(Nr(e,i,n)),s=yI(Nr(e,i,t));return!!(r!==o&&a!==s||0===r&&_I(n,e,t)||0===o&&_I(n,i,t)||0===a&&_I(e,n,i)||0===s&&_I(e,t,i))}function _I(n,t,e){return t.x<=Math.max(n.x,e.x)&&t.x>=Math.min(n.x,e.x)&&t.y<=Math.max(n.y,e.y)&&t.y>=Math.min(n.y,e.y)}function yI(n){return n>0?1:n<0?-1:0}function Wx(n,t){return Nr(n.prev,n,n.next)<0?Nr(n,t,n.next)>=0&&Nr(n,n.prev,t)>=0:Nr(n,t,n.prev)<0||Nr(n,n.next,t)<0}function Ate(n,t){let e=new XB(n.i,n.x,n.y),i=new XB(t.i,t.x,t.y),r=n.next,o=t.prev;return n.next=t,t.prev=n,e.next=r,r.prev=e,i.next=e,e.prev=i,o.next=i,i.prev=o,i}function $ee(n,t,e,i){let r=new XB(n,t,e);return i?(r.next=i.next,r.prev=i,i.next.prev=r,i.next=r):(r.prev=r,r.next=r),r}function qx(n){n.next.prev=n.prev,n.prev.next=n.next,n.prevZ&&(n.prevZ.nextZ=n.nextZ),n.nextZ&&(n.nextZ.prevZ=n.prevZ)}function XB(n,t,e){this.i=n,this.x=t,this.y=e,this.prev=null,this.next=null,this.z=null,this.prevZ=null,this.nextZ=null,this.steiner=!1}var Gc=class{static area(t){let e=t.length,i=0;for(let r=e-1,o=0;o<e;r=o++)i+=t[r].x*t[o].y-t[o].x*t[r].y;return.5*i}static isClockWise(t){return Gc.area(t)<0}static triangulateShape(t,e){let i=[],r=[],o=[];ete(t),tte(i,t);let a=t.length;e.forEach(ete);for(let l=0;l<e.length;l++)r.push(a),a+=e[l].length,tte(i,e[l]);let s=function(n,t,e=2){let s,l,c,d,u,p,f,i=t&&t.length,r=i?t[0]*e:n.length,o=Dte(n,0,r,e,!0),a=[];if(!o||o.next===o.prev)return a;if(i&&(o=function(n,t,e,i){let o,a,s,l,c,r=[];for(o=0,a=t.length;o<a;o++)s=t[o]*i,l=o<a-1?t[o+1]*i:n.length,c=Dte(n,s,l,i,!1),c===c.next&&(c.steiner=!0),r.push(JFe(c));for(r.sort(qFe),o=0;o<r.length;o++)YFe(r[o],e),e=Tp(e,e.next);return e}(n,t,o,e)),n.length>80*e){s=c=n[0],l=d=n[1];for(let m=e;m<r;m+=e)u=n[m],p=n[m+1],u<s&&(s=u),p<l&&(l=p),u>c&&(c=u),p>d&&(d=p);f=Math.max(c-s,d-l),f=0!==f?1/f:0}return Gx(o,a,e,s,l,f),a}(i,r);for(let l=0;l<s.length;l+=3)o.push(s.slice(l,l+3));return o}};function ete(n){let t=n.length;t>2&&n[t-1].equals(n[0])&&n.pop()}function tte(n,t){for(let e=0;e<t.length;e++)n.push(t[e].x),n.push(t[e].y)}var Dp=class extends Wi{constructor(t=new qd([new $e(.5,.5),new $e(-.5,.5),new $e(-.5,-.5),new $e(.5,-.5)]),e={}){super(),this.type="ExtrudeGeometry",this.parameters={shapes:t,options:e},t=Array.isArray(t)?t:[t];let i=this,r=[],o=[];for(let s=0,l=t.length;s<l;s++)a(t[s]);function a(s){let l=[],c=void 0!==e.curveSegments?e.curveSegments:12,d=void 0!==e.steps?e.steps:1,u=void 0!==e.depth?e.depth:1,p=void 0===e.bevelEnabled||e.bevelEnabled,f=void 0!==e.bevelThickness?e.bevelThickness:.2,m=void 0!==e.bevelSize?e.bevelSize:f-.1,y=void 0!==e.bevelOffset?e.bevelOffset:0,M=void 0!==e.bevelSegments?e.bevelSegments:3,v=e.extrudePath,x=void 0!==e.UVGenerator?e.UVGenerator:i2e;void 0!==e.amount&&(console.warn("THREE.ExtrudeBufferGeometry: amount has been renamed to depth."),u=e.amount);let R,H,te,K,Ce,A=!1;v&&(R=v.getSpacedPoints(d),A=!0,p=!1,H=v.computeFrenetFrames(d,!1),te=new $,K=new $,Ce=new $),p||(M=0,f=0,m=0,y=0);let Ze=s.extractPoints(c),Ie=Ze.shape,I=Ze.holes;if(!Gc.isClockWise(Ie)){Ie=Ie.reverse();for(let oe=0,st=I.length;oe<st;oe++){let Xe=I[oe];Gc.isClockWise(Xe)&&(I[oe]=Xe.reverse())}}let ce=Gc.triangulateShape(Ie,I),fe=Ie;for(let oe=0,st=I.length;oe<st;oe++)Ie=Ie.concat(I[oe]);function _e(oe,st,Xe){return st||console.error("THREE.ExtrudeGeometry: vec does not exist"),st.clone().multiplyScalar(Xe).add(oe)}let ne=Ie.length,de=ce.length;function ue(oe,st,Xe){let _t,pt,on,wn=oe.x-st.x,ii=oe.y-st.y,Li=Xe.x-oe.x,Ni=Xe.y-oe.y,Z=wn*wn+ii*ii;if(Math.abs(wn*Ni-ii*Li)>Number.EPSILON){let He=Math.sqrt(Z),yt=Math.sqrt(Li*Li+Ni*Ni),nn=st.x-ii/He,Be=st.y+wn/He,Nt=((Xe.x-Ni/yt-nn)*Ni-(Xe.y+Li/yt-Be)*Li)/(wn*Ni-ii*Li);_t=nn+wn*Nt-oe.x,pt=Be+ii*Nt-oe.y;let Lt=_t*_t+pt*pt;if(Lt<=2)return new $e(_t,pt);on=Math.sqrt(Lt/2)}else{let He=!1;wn>Number.EPSILON?Li>Number.EPSILON&&(He=!0):wn<-Number.EPSILON?Li<-Number.EPSILON&&(He=!0):Math.sign(ii)===Math.sign(Ni)&&(He=!0),He?(_t=-ii,pt=wn,on=Math.sqrt(Z)):(_t=wn,pt=ii,on=Math.sqrt(Z/2))}return new $e(_t/on,pt/on)}let Ge=[];for(let oe=0,st=fe.length,Xe=st-1,_t=oe+1;oe<st;oe++,Xe++,_t++)Xe===st&&(Xe=0),_t===st&&(_t=0),Ge[oe]=ue(fe[oe],fe[Xe],fe[_t]);let Ne,Me=[],ct=Ge.concat();for(let oe=0,st=I.length;oe<st;oe++){let Xe=I[oe];Ne=[];for(let _t=0,pt=Xe.length,on=pt-1,wn=_t+1;_t<pt;_t++,on++,wn++)on===pt&&(on=0),wn===pt&&(wn=0),Ne[_t]=ue(Xe[_t],Xe[on],Xe[wn]);Me.push(Ne),ct=ct.concat(Ne)}for(let oe=0;oe<M;oe++){let st=oe/M,Xe=f*Math.cos(st*Math.PI/2),_t=m*Math.sin(st*Math.PI/2)+y;for(let pt=0,on=fe.length;pt<on;pt++){let wn=_e(fe[pt],Ge[pt],_t);St(wn.x,wn.y,-Xe)}for(let pt=0,on=I.length;pt<on;pt++){let wn=I[pt];Ne=Me[pt];for(let ii=0,Li=wn.length;ii<Li;ii++){let Ni=_e(wn[ii],Ne[ii],_t);St(Ni.x,Ni.y,-Xe)}}}let wt=m+y;for(let oe=0;oe<ne;oe++){let st=p?_e(Ie[oe],ct[oe],wt):Ie[oe];A?(K.copy(H.normals[0]).multiplyScalar(st.x),te.copy(H.binormals[0]).multiplyScalar(st.y),Ce.copy(R[0]).add(K).add(te),St(Ce.x,Ce.y,Ce.z)):St(st.x,st.y,0)}for(let oe=1;oe<=d;oe++)for(let st=0;st<ne;st++){let Xe=p?_e(Ie[st],ct[st],wt):Ie[st];A?(K.copy(H.normals[oe]).multiplyScalar(Xe.x),te.copy(H.binormals[oe]).multiplyScalar(Xe.y),Ce.copy(R[oe]).add(K).add(te),St(Ce.x,Ce.y,Ce.z)):St(Xe.x,Xe.y,u/d*oe)}for(let oe=M-1;oe>=0;oe--){let st=oe/M,Xe=f*Math.cos(st*Math.PI/2),_t=m*Math.sin(st*Math.PI/2)+y;for(let pt=0,on=fe.length;pt<on;pt++){let wn=_e(fe[pt],Ge[pt],_t);St(wn.x,wn.y,u+Xe)}for(let pt=0,on=I.length;pt<on;pt++){let wn=I[pt];Ne=Me[pt];for(let ii=0,Li=wn.length;ii<Li;ii++){let Ni=_e(wn[ii],Ne[ii],_t);A?St(Ni.x,Ni.y+R[d-1].y,R[d-1].x+Xe):St(Ni.x,Ni.y,u+Xe)}}}function An(oe,st){let Xe=oe.length;for(;--Xe>=0;){let _t=Xe,pt=Xe-1;pt<0&&(pt=oe.length-1);for(let on=0,wn=d+2*M;on<wn;on++){let ii=ne*on,Li=ne*(on+1);ve(st+_t+ii,st+pt+ii,st+pt+Li,st+_t+Li)}}}function St(oe,st,Xe){l.push(oe),l.push(st),l.push(Xe)}function rn(oe,st,Xe){ht(oe),ht(st),ht(Xe);let _t=r.length/3,pt=x.generateTopUV(i,r,_t-3,_t-2,_t-1);mt(pt[0]),mt(pt[1]),mt(pt[2])}function ve(oe,st,Xe,_t){ht(oe),ht(st),ht(_t),ht(st),ht(Xe),ht(_t);let pt=r.length/3,on=x.generateSideWallUV(i,r,pt-6,pt-3,pt-2,pt-1);mt(on[0]),mt(on[1]),mt(on[3]),mt(on[1]),mt(on[2]),mt(on[3])}function ht(oe){r.push(l[3*oe+0]),r.push(l[3*oe+1]),r.push(l[3*oe+2])}function mt(oe){o.push(oe.x),o.push(oe.y)}(function(){let oe=r.length/3;if(p){let st=0,Xe=ne*st;for(let _t=0;_t<de;_t++){let pt=ce[_t];rn(pt[2]+Xe,pt[1]+Xe,pt[0]+Xe)}st=d+2*M,Xe=ne*st;for(let _t=0;_t<de;_t++){let pt=ce[_t];rn(pt[0]+Xe,pt[1]+Xe,pt[2]+Xe)}}else{for(let st=0;st<de;st++){let Xe=ce[st];rn(Xe[2],Xe[1],Xe[0])}for(let st=0;st<de;st++){let Xe=ce[st];rn(Xe[0]+ne*d,Xe[1]+ne*d,Xe[2]+ne*d)}}i.addGroup(oe,r.length/3-oe,0)})(),function(){let oe=r.length/3,st=0;An(fe,st),st+=fe.length;for(let Xe=0,_t=I.length;Xe<_t;Xe++){let pt=I[Xe];An(pt,st),st+=pt.length}i.addGroup(oe,r.length/3-oe,1)}()}this.setAttribute("position",new Br(r,3)),this.setAttribute("uv",new Br(o,2)),this.computeVertexNormals()}toJSON(){let t=super.toJSON();return function(n,t,e){if(e.shapes=[],Array.isArray(n))for(let i=0,r=n.length;i<r;i++)e.shapes.push(n[i].uuid);else e.shapes.push(n.uuid);return void 0!==t.extrudePath&&(e.options.extrudePath=t.extrudePath.toJSON()),e}(this.parameters.shapes,this.parameters.options,t)}static fromJSON(t,e){let i=[];for(let o=0,a=t.shapes.length;o<a;o++)i.push(e[t.shapes[o]]);let r=t.options.extrudePath;return void 0!==r&&(t.options.extrudePath=(new Tte[r.type]).fromJSON(r)),new Dp(i,t.options)}},i2e={generateTopUV:function(n,t,e,i,r){let s=t[3*i],l=t[3*i+1],c=t[3*r],d=t[3*r+1];return[new $e(t[3*e],t[3*e+1]),new $e(s,l),new $e(c,d)]},generateSideWallUV:function(n,t,e,i,r,o){let a=t[3*e],s=t[3*e+1],l=t[3*e+2],c=t[3*i],d=t[3*i+1],u=t[3*i+2],p=t[3*r],f=t[3*r+1],m=t[3*r+2],y=t[3*o],M=t[3*o+1],v=t[3*o+2];return Math.abs(s-d)<Math.abs(a-c)?[new $e(a,1-l),new $e(c,1-u),new $e(p,1-m),new $e(y,1-v)]:[new $e(s,1-l),new $e(d,1-u),new $e(f,1-m),new $e(M,1-v)]}},Am=class extends Wi{constructor(t=new qd([new $e(0,.5),new $e(-.5,-.5),new $e(.5,-.5)]),e=12){super(),this.type="ShapeGeometry",this.parameters={shapes:t,curveSegments:e};let i=[],r=[],o=[],a=[],s=0,l=0;if(!1===Array.isArray(t))c(t);else for(let d=0;d<t.length;d++)c(t[d]),this.addGroup(s,l,d),s+=l,l=0;function c(d){let u=r.length/3,p=d.extractPoints(e),f=p.shape,m=p.holes;!1===Gc.isClockWise(f)&&(f=f.reverse());for(let M=0,v=m.length;M<v;M++){let x=m[M];!0===Gc.isClockWise(x)&&(m[M]=x.reverse())}let y=Gc.triangulateShape(f,m);for(let M=0,v=m.length;M<v;M++)f=f.concat(m[M]);for(let M=0,v=f.length;M<v;M++){let x=f[M];r.push(x.x,x.y,0),o.push(0,0,1),a.push(x.x,x.y)}for(let M=0,v=y.length;M<v;M++){let x=y[M];i.push(x[0]+u,x[1]+u,x[2]+u),l+=3}}this.setIndex(i),this.setAttribute("position",new Br(r,3)),this.setAttribute("normal",new Br(o,3)),this.setAttribute("uv",new Br(a,2))}toJSON(){let t=super.toJSON();return function(n,t){if(t.shapes=[],Array.isArray(n))for(let e=0,i=n.length;e<i;e++)t.shapes.push(n[e].uuid);else t.shapes.push(n.uuid);return t}(this.parameters.shapes,t)}static fromJSON(t,e){let i=[];for(let r=0,o=t.shapes.length;r<o;r++)i.push(e[t.shapes[r]]);return new Am(i,t.curveSegments)}};(class extends Ro{constructor(t){super(),this.type="ShadowMaterial",this.color=new an(0),this.transparent=!0,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this}}).prototype.isShadowMaterial=!0;var jI=class extends Ro{constructor(t){super(),this.defines={STANDARD:""},this.type="MeshStandardMaterial",this.color=new an(16777215),this.roughness=1,this.metalness=0,this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new an(0),this.emissiveIntensity=1,this.emissiveMap=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=y_,this.normalScale=new $e(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.roughnessMap=null,this.metalnessMap=null,this.alphaMap=null,this.envMap=null,this.envMapIntensity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.flatShading=!1,this.setValues(t)}copy(t){return super.copy(t),this.defines={STANDARD:""},this.color.copy(t.color),this.roughness=t.roughness,this.metalness=t.metalness,this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.roughnessMap=t.roughnessMap,this.metalnessMap=t.metalnessMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.envMapIntensity=t.envMapIntensity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this.flatShading=t.flatShading,this}};jI.prototype.isMeshStandardMaterial=!0,class extends jI{constructor(t){super(),this.defines={STANDARD:"",PHYSICAL:""},this.type="MeshPhysicalMaterial",this.clearcoatMap=null,this.clearcoatRoughness=0,this.clearcoatRoughnessMap=null,this.clearcoatNormalScale=new $e(1,1),this.clearcoatNormalMap=null,this.ior=1.5,Object.defineProperty(this,"reflectivity",{get:function(){return Xa(2.5*(this.ior-1)/(this.ior+1),0,1)},set:function(e){this.ior=(1+.4*e)/(1-.4*e)}}),this.sheenColor=new an(0),this.sheenColorMap=null,this.sheenRoughness=1,this.sheenRoughnessMap=null,this.transmissionMap=null,this.thickness=0,this.thicknessMap=null,this.attenuationDistance=0,this.attenuationColor=new an(1,1,1),this.specularIntensity=1,this.specularIntensityMap=null,this.specularColor=new an(1,1,1),this.specularColorMap=null,this._sheen=0,this._clearcoat=0,this._transmission=0,this.setValues(t)}get sheen(){return this._sheen}set sheen(t){this._sheen>0!=t>0&&this.version++,this._sheen=t}get clearcoat(){return this._clearcoat}set clearcoat(t){this._clearcoat>0!=t>0&&this.version++,this._clearcoat=t}get transmission(){return this._transmission}set transmission(t){this._transmission>0!=t>0&&this.version++,this._transmission=t}copy(t){return super.copy(t),this.defines={STANDARD:"",PHYSICAL:""},this.clearcoat=t.clearcoat,this.clearcoatMap=t.clearcoatMap,this.clearcoatRoughness=t.clearcoatRoughness,this.clearcoatRoughnessMap=t.clearcoatRoughnessMap,this.clearcoatNormalMap=t.clearcoatNormalMap,this.clearcoatNormalScale.copy(t.clearcoatNormalScale),this.ior=t.ior,this.sheen=t.sheen,this.sheenColor.copy(t.sheenColor),this.sheenColorMap=t.sheenColorMap,this.sheenRoughness=t.sheenRoughness,this.sheenRoughnessMap=t.sheenRoughnessMap,this.transmission=t.transmission,this.transmissionMap=t.transmissionMap,this.thickness=t.thickness,this.thicknessMap=t.thicknessMap,this.attenuationDistance=t.attenuationDistance,this.attenuationColor.copy(t.attenuationColor),this.specularIntensity=t.specularIntensity,this.specularIntensityMap=t.specularIntensityMap,this.specularColor.copy(t.specularColor),this.specularColorMap=t.specularColorMap,this}}.prototype.isMeshPhysicalMaterial=!0,class extends Ro{constructor(t){super(),this.type="MeshPhongMaterial",this.color=new an(16777215),this.specular=new an(1118481),this.shininess=30,this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new an(0),this.emissiveIntensity=1,this.emissiveMap=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=y_,this.normalScale=new $e(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.specularMap=null,this.alphaMap=null,this.envMap=null,this.combine=JI,this.reflectivity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.flatShading=!1,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.specular.copy(t.specular),this.shininess=t.shininess,this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.specularMap=t.specularMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.combine=t.combine,this.reflectivity=t.reflectivity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this.flatShading=t.flatShading,this}}.prototype.isMeshPhongMaterial=!0,class extends Ro{constructor(t){super(),this.defines={TOON:""},this.type="MeshToonMaterial",this.color=new an(16777215),this.map=null,this.gradientMap=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new an(0),this.emissiveIntensity=1,this.emissiveMap=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=y_,this.normalScale=new $e(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.alphaMap=null,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.gradientMap=t.gradientMap,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.alphaMap=t.alphaMap,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this}}.prototype.isMeshToonMaterial=!0,class extends Ro{constructor(t){super(),this.type="MeshNormalMaterial",this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=y_,this.normalScale=new $e(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.wireframe=!1,this.wireframeLinewidth=1,this.fog=!1,this.flatShading=!1,this.setValues(t)}copy(t){return super.copy(t),this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.flatShading=t.flatShading,this}}.prototype.isMeshNormalMaterial=!0,class extends Ro{constructor(t){super(),this.type="MeshLambertMaterial",this.color=new an(16777215),this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new an(0),this.emissiveIntensity=1,this.emissiveMap=null,this.specularMap=null,this.alphaMap=null,this.envMap=null,this.combine=JI,this.reflectivity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.specularMap=t.specularMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.combine=t.combine,this.reflectivity=t.reflectivity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this}}.prototype.isMeshLambertMaterial=!0,class extends Ro{constructor(t){super(),this.defines={MATCAP:""},this.type="MeshMatcapMaterial",this.color=new an(16777215),this.matcap=null,this.map=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=y_,this.normalScale=new $e(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.alphaMap=null,this.flatShading=!1,this.setValues(t)}copy(t){return super.copy(t),this.defines={MATCAP:""},this.color.copy(t.color),this.matcap=t.matcap,this.map=t.map,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.alphaMap=t.alphaMap,this.flatShading=t.flatShading,this}}.prototype.isMeshMatcapMaterial=!0,class extends Wd{constructor(t){super(),this.type="LineDashedMaterial",this.scale=1,this.dashSize=3,this.gapSize=1,this.setValues(t)}copy(t){return super.copy(t),this.scale=t.scale,this.dashSize=t.dashSize,this.gapSize=t.gapSize,this}}.prototype.isLineDashedMaterial=!0;var Ir={arraySlice:function(n,t,e){return Ir.isTypedArray(n)?new n.constructor(n.subarray(t,void 0!==e?e:n.length)):n.slice(t,e)},convertArray:function(n,t,e){return!n||!e&&n.constructor===t?n:"number"==typeof t.BYTES_PER_ELEMENT?new t(n):Array.prototype.slice.call(n)},isTypedArray:function(n){return ArrayBuffer.isView(n)&&!(n instanceof DataView)},getKeyframeOrder:function(n){let e=n.length,i=new Array(e);for(let r=0;r!==e;++r)i[r]=r;return i.sort(function(r,o){return n[r]-n[o]}),i},sortedArray:function(n,t,e){let i=n.length,r=new n.constructor(i);for(let o=0,a=0;a!==i;++o){let s=e[o]*t;for(let l=0;l!==t;++l)r[a++]=n[s+l]}return r},flattenJSON:function(n,t,e,i){let r=1,o=n[0];for(;void 0!==o&&void 0===o[i];)o=n[r++];if(void 0===o)return;let a=o[i];if(void 0!==a)if(Array.isArray(a))do{a=o[i],void 0!==a&&(t.push(o.time),e.push.apply(e,a)),o=n[r++]}while(void 0!==o);else if(void 0!==a.toArray)do{a=o[i],void 0!==a&&(t.push(o.time),a.toArray(e,e.length)),o=n[r++]}while(void 0!==o);else do{a=o[i],void 0!==a&&(t.push(o.time),e.push(a)),o=n[r++]}while(void 0!==o)},subclip:function(n,t,e,i,r=30){let o=n.clone();o.name=t;let a=[];for(let l=0;l<o.tracks.length;++l){let c=o.tracks[l],d=c.getValueSize(),u=[],p=[];for(let f=0;f<c.times.length;++f){let m=c.times[f]*r;if(!(m<e||m>=i)){u.push(c.times[f]);for(let y=0;y<d;++y)p.push(c.values[f*d+y])}}0!==u.length&&(c.times=Ir.convertArray(u,c.times.constructor),c.values=Ir.convertArray(p,c.values.constructor),a.push(c))}o.tracks=a;let s=1/0;for(let l=0;l<o.tracks.length;++l)s>o.tracks[l].times[0]&&(s=o.tracks[l].times[0]);for(let l=0;l<o.tracks.length;++l)o.tracks[l].shift(-1*s);return o.resetDuration(),o},makeClipAdditive:function(n,t=0,e=n,i=30){i<=0&&(i=30);let r=e.tracks.length,o=t/i;for(let a=0;a<r;++a){let s=e.tracks[a],l=s.ValueTypeName;if("bool"===l||"string"===l)continue;let c=n.tracks.find(function(v){return v.name===s.name&&v.ValueTypeName===l});if(void 0===c)continue;let d=0,u=s.getValueSize();s.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline&&(d=u/3);let p=0,f=c.getValueSize();c.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline&&(p=f/3);let y,m=s.times.length-1;if(o<=s.times[0])y=Ir.arraySlice(s.values,d,u-d);else if(o>=s.times[m]){let v=m*u+d;y=Ir.arraySlice(s.values,v,v+u-d)}else{let v=s.createInterpolant(),x=d,R=u-d;v.evaluate(o),y=Ir.arraySlice(v.resultBuffer,x,R)}"quaternion"===l&&(new aa).fromArray(y).normalize().conjugate().toArray(y);let M=c.times.length;for(let v=0;v<M;++v){let x=v*f+p;if("quaternion"===l)aa.multiplyQuaternionsFlat(c.values,x,y,0,c.values,x);else{let R=f-2*p;for(let A=0;A<R;++A)c.values[x+A]-=y[A]}}}return n.blendMode=2501,n}},Wc=class{constructor(t,e,i,r){this.parameterPositions=t,this._cachedIndex=0,this.resultBuffer=void 0!==r?r:new e.constructor(i),this.sampleValues=e,this.valueSize=i,this.settings=null,this.DefaultSettings_={}}evaluate(t){let e=this.parameterPositions,i=this._cachedIndex,r=e[i],o=e[i-1];e:{t:{let a;n:{i:if(!(t<r)){for(let s=i+2;;){if(void 0===r){if(t<o)break i;return i=e.length,this._cachedIndex=i,this.afterEnd_(i-1,t,o)}if(i===s)break;if(o=r,r=e[++i],t<r)break t}a=e.length;break n}if(t>=o)break e;{let s=e[1];t<s&&(i=2,o=s);for(let l=i-2;;){if(void 0===o)return this._cachedIndex=0,this.beforeStart_(0,t,r);if(i===l)break;if(r=o,o=e[--i-1],t>=o)break t}a=i,i=0}}for(;i<a;){let s=i+a>>>1;t<e[s]?a=s:i=s+1}if(r=e[i],o=e[i-1],void 0===o)return this._cachedIndex=0,this.beforeStart_(0,t,r);if(void 0===r)return i=e.length,this._cachedIndex=i,this.afterEnd_(i-1,o,t)}this._cachedIndex=i,this.intervalChanged_(i,o,r)}return this.interpolate_(i,o,t,r)}getSettings_(){return this.settings||this.DefaultSettings_}copySampleValue_(t){let e=this.resultBuffer,i=this.sampleValues,r=this.valueSize,o=t*r;for(let a=0;a!==r;++a)e[a]=i[o+a];return e}interpolate_(){throw new Error("call to abstract method")}intervalChanged_(){}};Wc.prototype.beforeStart_=Wc.prototype.copySampleValue_,Wc.prototype.afterEnd_=Wc.prototype.copySampleValue_;var iV=class extends Wc{constructor(t,e,i,r){super(t,e,i,r),this._weightPrev=-0,this._offsetPrev=-0,this._weightNext=-0,this._offsetNext=-0,this.DefaultSettings_={endingStart:J0,endingEnd:J0}}intervalChanged_(t,e,i){let r=this.parameterPositions,o=t-2,a=t+1,s=r[o],l=r[a];if(void 0===s)switch(this.getSettings_().endingStart){case $0:o=t,s=2*e-i;break;case 2402:o=r.length-2,s=e+r[o]-r[o+1];break;default:o=t,s=i}if(void 0===l)switch(this.getSettings_().endingEnd){case $0:a=t,l=2*i-e;break;case 2402:a=1,l=i+r[1]-r[0];break;default:a=t-1,l=e}let c=.5*(i-e),d=this.valueSize;this._weightPrev=c/(e-s),this._weightNext=c/(l-i),this._offsetPrev=o*d,this._offsetNext=a*d}interpolate_(t,e,i,r){let o=this.resultBuffer,a=this.sampleValues,s=this.valueSize,l=t*s,c=l-s,d=this._offsetPrev,u=this._offsetNext,p=this._weightPrev,f=this._weightNext,m=(i-e)/(r-e),y=m*m,M=y*m,v=-p*M+2*p*y-p*m,x=(1+p)*M+(-1.5-2*p)*y+(-.5+p)*m+1,R=(-1-f)*M+(1.5+f)*y+.5*m,A=f*M-f*y;for(let H=0;H!==s;++H)o[H]=v*a[d+H]+x*a[c+H]+R*a[l+H]+A*a[u+H];return o}},GI=class extends Wc{constructor(t,e,i,r){super(t,e,i,r)}interpolate_(t,e,i,r){let o=this.resultBuffer,a=this.sampleValues,s=this.valueSize,l=t*s,c=l-s,d=(i-e)/(r-e),u=1-d;for(let p=0;p!==s;++p)o[p]=a[c+p]*u+a[l+p]*d;return o}},rV=class extends Wc{constructor(t,e,i,r){super(t,e,i,r)}interpolate_(t){return this.copySampleValue_(t-1)}},el=class{constructor(t,e,i,r){if(void 0===t)throw new Error("THREE.KeyframeTrack: track name is undefined");if(void 0===e||0===e.length)throw new Error("THREE.KeyframeTrack: no keyframes in track named "+t);this.name=t,this.times=Ir.convertArray(e,this.TimeBufferType),this.values=Ir.convertArray(i,this.ValueBufferType),this.setInterpolation(r||this.DefaultInterpolation)}static toJSON(t){let i,e=t.constructor;if(e.toJSON!==this.toJSON)i=e.toJSON(t);else{i={name:t.name,times:Ir.convertArray(t.times,Array),values:Ir.convertArray(t.values,Array)};let r=t.getInterpolation();r!==t.DefaultInterpolation&&(i.interpolation=r)}return i.type=t.ValueTypeName,i}InterpolantFactoryMethodDiscrete(t){return new rV(this.times,this.values,this.getValueSize(),t)}InterpolantFactoryMethodLinear(t){return new GI(this.times,this.values,this.getValueSize(),t)}InterpolantFactoryMethodSmooth(t){return new iV(this.times,this.values,this.getValueSize(),t)}setInterpolation(t){let e;switch(t){case 2300:e=this.InterpolantFactoryMethodDiscrete;break;case 2301:e=this.InterpolantFactoryMethodLinear;break;case 2302:e=this.InterpolantFactoryMethodSmooth}if(void 0===e){let i="unsupported interpolation for "+this.ValueTypeName+" keyframe track named "+this.name;if(void 0===this.createInterpolant){if(t===this.DefaultInterpolation)throw new Error(i);this.setInterpolation(this.DefaultInterpolation)}return console.warn("THREE.KeyframeTrack:",i),this}return this.createInterpolant=e,this}getInterpolation(){switch(this.createInterpolant){case this.InterpolantFactoryMethodDiscrete:return 2300;case this.InterpolantFactoryMethodLinear:return 2301;case this.InterpolantFactoryMethodSmooth:return 2302}}getValueSize(){return this.values.length/this.times.length}shift(t){if(0!==t){let e=this.times;for(let i=0,r=e.length;i!==r;++i)e[i]+=t}return this}scale(t){if(1!==t){let e=this.times;for(let i=0,r=e.length;i!==r;++i)e[i]*=t}return this}trim(t,e){let i=this.times,r=i.length,o=0,a=r-1;for(;o!==r&&i[o]<t;)++o;for(;-1!==a&&i[a]>e;)--a;if(++a,0!==o||a!==r){o>=a&&(a=Math.max(a,1),o=a-1);let s=this.getValueSize();this.times=Ir.arraySlice(i,o,a),this.values=Ir.arraySlice(this.values,o*s,a*s)}return this}validate(){let t=!0,e=this.getValueSize();e-Math.floor(e)!=0&&(console.error("THREE.KeyframeTrack: Invalid value size in track.",this),t=!1);let i=this.times,r=this.values,o=i.length;0===o&&(console.error("THREE.KeyframeTrack: Track is empty.",this),t=!1);let a=null;for(let s=0;s!==o;s++){let l=i[s];if("number"==typeof l&&isNaN(l)){console.error("THREE.KeyframeTrack: Time is not a valid number.",this,s,l),t=!1;break}if(null!==a&&a>l){console.error("THREE.KeyframeTrack: Out of order keys.",this,s,l,a),t=!1;break}a=l}if(void 0!==r&&Ir.isTypedArray(r))for(let s=0,l=r.length;s!==l;++s){let c=r[s];if(isNaN(c)){console.error("THREE.KeyframeTrack: Value is not a valid number.",this,s,c),t=!1;break}}return t}optimize(){let t=Ir.arraySlice(this.times),e=Ir.arraySlice(this.values),i=this.getValueSize(),r=2302===this.getInterpolation(),o=t.length-1,a=1;for(let s=1;s<o;++s){let l=!1,c=t[s];if(c!==t[s+1]&&(1!==s||c!==t[0]))if(r)l=!0;else{let u=s*i,p=u-i,f=u+i;for(let m=0;m!==i;++m){let y=e[u+m];if(y!==e[p+m]||y!==e[f+m]){l=!0;break}}}if(l){if(s!==a){t[a]=t[s];let u=s*i,p=a*i;for(let f=0;f!==i;++f)e[p+f]=e[u+f]}++a}}if(o>0){t[a]=t[o];for(let s=o*i,l=a*i,c=0;c!==i;++c)e[l+c]=e[s+c];++a}return a!==t.length?(this.times=Ir.arraySlice(t,0,a),this.values=Ir.arraySlice(e,0,a*i)):(this.times=t,this.values=e),this}clone(){let t=Ir.arraySlice(this.times,0),e=Ir.arraySlice(this.values,0),r=new(0,this.constructor)(this.name,t,e);return r.createInterpolant=this.createInterpolant,r}};el.prototype.TimeBufferType=Float32Array,el.prototype.ValueBufferType=Float32Array,el.prototype.DefaultInterpolation=2301;var Ip=class extends el{};Ip.prototype.ValueTypeName="bool",Ip.prototype.ValueBufferType=Array,Ip.prototype.DefaultInterpolation=2300,Ip.prototype.InterpolantFactoryMethodLinear=void 0,Ip.prototype.InterpolantFactoryMethodSmooth=void 0;var WI=class extends el{};WI.prototype.ValueTypeName="color";var h_=class extends el{};h_.prototype.ValueTypeName="number";var oV=class extends Wc{constructor(t,e,i,r){super(t,e,i,r)}interpolate_(t,e,i,r){let o=this.resultBuffer,a=this.sampleValues,s=this.valueSize,l=(i-e)/(r-e),c=t*s;for(let d=c+s;c!==d;c+=4)aa.slerpFlat(o,0,a,c-s,a,c,l);return o}},Rm=class extends el{InterpolantFactoryMethodLinear(t){return new oV(this.times,this.values,this.getValueSize(),t)}};Rm.prototype.ValueTypeName="quaternion",Rm.prototype.DefaultInterpolation=2301,Rm.prototype.InterpolantFactoryMethodSmooth=void 0;var Ap=class extends el{};Ap.prototype.ValueTypeName="string",Ap.prototype.ValueBufferType=Array,Ap.prototype.DefaultInterpolation=2300,Ap.prototype.InterpolantFactoryMethodLinear=void 0,Ap.prototype.InterpolantFactoryMethodSmooth=void 0;var g_=class extends el{};g_.prototype.ValueTypeName="vector";var qI=class{constructor(t,e=-1,i,r=2500){this.name=t,this.tracks=i,this.duration=e,this.blendMode=r,this.uuid=Ql(),this.duration<0&&this.resetDuration()}static parse(t){let e=[],i=t.tracks,r=1/(t.fps||1);for(let a=0,s=i.length;a!==s;++a)e.push(s2e(i[a]).scale(r));let o=new this(t.name,t.duration,e,t.blendMode);return o.uuid=t.uuid,o}static toJSON(t){let e=[],i=t.tracks,r={name:t.name,duration:t.duration,tracks:e,uuid:t.uuid,blendMode:t.blendMode};for(let o=0,a=i.length;o!==a;++o)e.push(el.toJSON(i[o]));return r}static CreateFromMorphTargetSequence(t,e,i,r){let o=e.length,a=[];for(let s=0;s<o;s++){let l=[],c=[];l.push((s+o-1)%o,s,(s+1)%o),c.push(0,1,0);let d=Ir.getKeyframeOrder(l);l=Ir.sortedArray(l,1,d),c=Ir.sortedArray(c,1,d),!r&&0===l[0]&&(l.push(o),c.push(c[0])),a.push(new h_(".morphTargetInfluences["+e[s].name+"]",l,c).scale(1/i))}return new this(t,-1,a)}static findByName(t,e){let i=t;Array.isArray(t)||(i=t.geometry&&t.geometry.animations||t.animations);for(let r=0;r<i.length;r++)if(i[r].name===e)return i[r];return null}static CreateClipsFromMorphTargetSequences(t,e,i){let r={},o=/^([\w-]*?)([\d]+)$/;for(let s=0,l=t.length;s<l;s++){let c=t[s],d=c.name.match(o);if(d&&d.length>1){let u=d[1],p=r[u];p||(r[u]=p=[]),p.push(c)}}let a=[];for(let s in r)a.push(this.CreateFromMorphTargetSequence(s,r[s],e,i));return a}static parseAnimation(t,e){if(!t)return console.error("THREE.AnimationClip: No animation in JSONLoader data."),null;let i=function(u,p,f,m,y){if(0!==f.length){let M=[],v=[];Ir.flattenJSON(f,M,v,m),0!==M.length&&y.push(new u(p,M,v))}},r=[],o=t.name||"default",a=t.fps||30,s=t.blendMode,l=t.length||-1,c=t.hierarchy||[];for(let u=0;u<c.length;u++){let p=c[u].keys;if(p&&0!==p.length)if(p[0].morphTargets){let m,f={};for(m=0;m<p.length;m++)if(p[m].morphTargets)for(let y=0;y<p[m].morphTargets.length;y++)f[p[m].morphTargets[y]]=-1;for(let y in f){let M=[],v=[];for(let x=0;x!==p[m].morphTargets.length;++x){let R=p[m];M.push(R.time),v.push(R.morphTarget===y?1:0)}r.push(new h_(".morphTargetInfluence["+y+"]",M,v))}l=f.length*(a||1)}else{let f=".bones["+e[u].name+"]";i(g_,f+".position",p,"pos",r),i(Rm,f+".quaternion",p,"rot",r),i(g_,f+".scale",p,"scl",r)}}return 0===r.length?null:new this(o,l,r,s)}resetDuration(){let e=0;for(let i=0,r=this.tracks.length;i!==r;++i){let o=this.tracks[i];e=Math.max(e,o.times[o.times.length-1])}return this.duration=e,this}trim(){for(let t=0;t<this.tracks.length;t++)this.tracks[t].trim(0,this.duration);return this}validate(){let t=!0;for(let e=0;e<this.tracks.length;e++)t=t&&this.tracks[e].validate();return t}optimize(){for(let t=0;t<this.tracks.length;t++)this.tracks[t].optimize();return this}clone(){let t=[];for(let e=0;e<this.tracks.length;e++)t.push(this.tracks[e].clone());return new this.constructor(this.name,this.duration,t,this.blendMode)}toJSON(){return this.constructor.toJSON(this)}};function s2e(n){if(void 0===n.type)throw new Error("THREE.KeyframeTrack: track type undefined, can not parse");let t=function(n){switch(n.toLowerCase()){case"scalar":case"double":case"float":case"number":case"integer":return h_;case"vector":case"vector2":case"vector3":case"vector4":return g_;case"color":return WI;case"quaternion":return Rm;case"bool":case"boolean":return Ip;case"string":return Ap}throw new Error("THREE.KeyframeTrack: Unsupported typeName: "+n)}(n.type);if(void 0===n.times){let e=[],i=[];Ir.flattenJSON(n.keys,e,i,"value"),n.times=e,n.values=i}return void 0!==t.parse?t.parse(n):new t(n.name,n.times,n.values,n.interpolation)}var __={enabled:!1,files:{},add:function(n,t){!1!==this.enabled&&(this.files[n]=t)},get:function(n){if(!1!==this.enabled)return this.files[n]},remove:function(n){delete this.files[n]},clear:function(){this.files={}}},l2e=new class{constructor(t,e,i){let l,r=this,o=!1,a=0,s=0,c=[];this.onStart=void 0,this.onLoad=t,this.onProgress=e,this.onError=i,this.itemStart=function(d){s++,!1===o&&void 0!==r.onStart&&r.onStart(d,a,s),o=!0},this.itemEnd=function(d){a++,void 0!==r.onProgress&&r.onProgress(d,a,s),a===s&&(o=!1,void 0!==r.onLoad&&r.onLoad())},this.itemError=function(d){void 0!==r.onError&&r.onError(d)},this.resolveURL=function(d){return l?l(d):d},this.setURLModifier=function(d){return l=d,this},this.addHandler=function(d,u){return c.push(d,u),this},this.removeHandler=function(d){let u=c.indexOf(d);return-1!==u&&c.splice(u,2),this},this.getHandler=function(d){for(let u=0,p=c.length;u<p;u+=2){let f=c[u],m=c[u+1];if(f.global&&(f.lastIndex=0),f.test(d))return m}return null}}},qc=class{constructor(t){this.manager=void 0!==t?t:l2e,this.crossOrigin="anonymous",this.withCredentials=!1,this.path="",this.resourcePath="",this.requestHeader={}}load(){}loadAsync(t,e){let i=this;return new Promise(function(r,o){i.load(t,r,e,o)})}parse(){}setCrossOrigin(t){return this.crossOrigin=t,this}setWithCredentials(t){return this.withCredentials=t,this}setPath(t){return this.path=t,this}setResourcePath(t){return this.resourcePath=t,this}setRequestHeader(t){return this.requestHeader=t,this}},zd={},sV=class extends qc{constructor(t){super(t)}load(t,e,i,r){void 0===t&&(t=""),void 0!==this.path&&(t=this.path+t),t=this.manager.resolveURL(t);let o=__.get(t);if(void 0!==o)return this.manager.itemStart(t),setTimeout(()=>{e&&e(o),this.manager.itemEnd(t)},0),o;if(void 0!==zd[t])return void zd[t].push({onLoad:e,onProgress:i,onError:r});zd[t]=[],zd[t].push({onLoad:e,onProgress:i,onError:r});let a=new Request(t,{headers:new Headers(this.requestHeader),credentials:this.withCredentials?"include":"same-origin"}),s=this.mimeType,l=this.responseType;fetch(a).then(c=>{if(200===c.status||0===c.status){if(0===c.status&&console.warn("THREE.FileLoader: HTTP Status 0 received."),typeof ReadableStream>"u"||void 0===c.body.getReader)return c;let d=zd[t],u=c.body.getReader(),p=c.headers.get("Content-Length"),f=p?parseInt(p):0,m=0!==f,y=0,M=new ReadableStream({start(v){!function x(){u.read().then(({done:R,value:A})=>{if(R)v.close();else{y+=A.byteLength;let H=new ProgressEvent("progress",{lengthComputable:m,loaded:y,total:f});for(let te=0,K=d.length;te<K;te++){let Ce=d[te];Ce.onProgress&&Ce.onProgress(H)}v.enqueue(A),x()}})}()}});return new Response(M)}throw Error(`fetch for "${c.url}" responded with ${c.status}: ${c.statusText}`)}).then(c=>{switch(l){case"arraybuffer":return c.arrayBuffer();case"blob":return c.blob();case"document":return c.text().then(d=>(new DOMParser).parseFromString(d,s));case"json":return c.json();default:if(void 0===s)return c.text();{let u=/charset="?([^;"\s]*)"?/i.exec(s),p=u&&u[1]?u[1].toLowerCase():void 0,f=new TextDecoder(p);return c.arrayBuffer().then(m=>f.decode(m))}}}).then(c=>{__.add(t,c);let d=zd[t];delete zd[t];for(let u=0,p=d.length;u<p;u++){let f=d[u];f.onLoad&&f.onLoad(c)}}).catch(c=>{let d=zd[t];if(void 0===d)throw this.manager.itemError(t),c;delete zd[t];for(let u=0,p=d.length;u<p;u++){let f=d[u];f.onError&&f.onError(c)}this.manager.itemError(t)}).finally(()=>{this.manager.itemEnd(t)}),this.manager.itemStart(t)}setResponseType(t){return this.responseType=t,this}setMimeType(t){return this.mimeType=t,this}},YI=class extends qc{constructor(t){super(t)}load(t,e,i,r){void 0!==this.path&&(t=this.path+t),t=this.manager.resolveURL(t);let o=this,a=__.get(t);if(void 0!==a)return o.manager.itemStart(t),setTimeout(function(){e&&e(a),o.manager.itemEnd(t)},0),a;let s=Dx("img");function l(){d(),__.add(t,this),e&&e(this),o.manager.itemEnd(t)}function c(u){d(),r&&r(u),o.manager.itemError(t),o.manager.itemEnd(t)}function d(){s.removeEventListener("load",l,!1),s.removeEventListener("error",c,!1)}return s.addEventListener("load",l,!1),s.addEventListener("error",c,!1),"data:"!==t.substr(0,5)&&void 0!==this.crossOrigin&&(s.crossOrigin=this.crossOrigin),o.manager.itemStart(t),s.src=t,s}},lV=class extends qc{constructor(t){super(t)}load(t,e,i,r){let o=new l_,a=new YI(this.manager);a.setCrossOrigin(this.crossOrigin),a.setPath(this.path);let s=0;function l(c){a.load(t[c],function(d){o.images[c]=d,s++,6===s&&(o.needsUpdate=!0,e&&e(o))},void 0,r)}for(let c=0;c<t.length;++c)l(c);return o}},cV=class extends qc{constructor(t){super(t)}load(t,e,i,r){let o=new uo,a=new YI(this.manager);return a.setCrossOrigin(this.crossOrigin),a.setPath(this.path),a.load(t,function(s){o.image=s,o.needsUpdate=!0,void 0!==e&&e(o)},i,r),o}},tl=class extends zi{constructor(t,e=1){super(),this.type="Light",this.color=new an(t),this.intensity=e}dispose(){}copy(t){return super.copy(t),this.color.copy(t.color),this.intensity=t.intensity,this}toJSON(t){let e=super.toJSON(t);return e.object.color=this.color.getHex(),e.object.intensity=this.intensity,void 0!==this.groundColor&&(e.object.groundColor=this.groundColor.getHex()),void 0!==this.distance&&(e.object.distance=this.distance),void 0!==this.angle&&(e.object.angle=this.angle),void 0!==this.decay&&(e.object.decay=this.decay),void 0!==this.penumbra&&(e.object.penumbra=this.penumbra),void 0!==this.shadow&&(e.object.shadow=this.shadow.toJSON()),e}};tl.prototype.isLight=!0,class extends tl{constructor(t,e,i){super(t,i),this.type="HemisphereLight",this.position.copy(zi.DefaultUp),this.updateMatrix(),this.groundColor=new an(e)}copy(t){return tl.prototype.copy.call(this,t),this.groundColor.copy(t.groundColor),this}}.prototype.isHemisphereLight=!0;var nte=new Mn,ite=new $,rte=new $,Yx=class{constructor(t){this.camera=t,this.bias=0,this.normalBias=0,this.radius=1,this.blurSamples=8,this.mapSize=new $e(512,512),this.map=null,this.mapPass=null,this.matrix=new Mn,this.autoUpdate=!0,this.needsUpdate=!1,this._frustum=new c_,this._frameExtents=new $e(1,1),this._viewportCount=1,this._viewports=[new Ki(0,0,1,1)]}getViewportCount(){return this._viewportCount}getFrustum(){return this._frustum}updateMatrices(t){let e=this.camera,i=this.matrix;ite.setFromMatrixPosition(t.matrixWorld),e.position.copy(ite),rte.setFromMatrixPosition(t.target.matrixWorld),e.lookAt(rte),e.updateMatrixWorld(),nte.multiplyMatrices(e.projectionMatrix,e.matrixWorldInverse),this._frustum.setFromProjectionMatrix(nte),i.set(.5,0,0,.5,0,.5,0,.5,0,0,.5,.5,0,0,0,1),i.multiply(e.projectionMatrix),i.multiply(e.matrixWorldInverse)}getViewport(t){return this._viewports[t]}getFrameExtents(){return this._frameExtents}dispose(){this.map&&this.map.dispose(),this.mapPass&&this.mapPass.dispose()}copy(t){return this.camera=t.camera.clone(),this.bias=t.bias,this.radius=t.radius,this.mapSize.copy(t.mapSize),this}clone(){return(new this.constructor).copy(this)}toJSON(){let t={};return 0!==this.bias&&(t.bias=this.bias),0!==this.normalBias&&(t.normalBias=this.normalBias),1!==this.radius&&(t.radius=this.radius),(512!==this.mapSize.x||512!==this.mapSize.y)&&(t.mapSize=this.mapSize.toArray()),t.camera=this.camera.toJSON(!1).object,delete t.camera.matrix,t}},XI=class extends Yx{constructor(){super(new oa(50,1,.5,500)),this.focus=1}updateMatrices(t){let e=this.camera,i=2*EB*t.angle*this.focus,r=this.mapSize.width/this.mapSize.height,o=t.distance||e.far;(i!==e.fov||r!==e.aspect||o!==e.far)&&(e.fov=i,e.aspect=r,e.far=o,e.updateProjectionMatrix()),super.updateMatrices(t)}copy(t){return super.copy(t),this.focus=t.focus,this}};XI.prototype.isSpotLightShadow=!0,class extends tl{constructor(t,e,i=0,r=Math.PI/3,o=0,a=1){super(t,e),this.type="SpotLight",this.position.copy(zi.DefaultUp),this.updateMatrix(),this.target=new zi,this.distance=i,this.angle=r,this.penumbra=o,this.decay=a,this.shadow=new XI}get power(){return this.intensity*Math.PI}set power(t){this.intensity=t/Math.PI}dispose(){this.shadow.dispose()}copy(t){return super.copy(t),this.distance=t.distance,this.angle=t.angle,this.penumbra=t.penumbra,this.decay=t.decay,this.target=t.target.clone(),this.shadow=t.shadow.clone(),this}}.prototype.isSpotLight=!0;var ote=new Mn,yx=new $,yB=new $,QI=class extends Yx{constructor(){super(new oa(90,1,.5,500)),this._frameExtents=new $e(4,2),this._viewportCount=6,this._viewports=[new Ki(2,1,1,1),new Ki(0,1,1,1),new Ki(3,1,1,1),new Ki(1,1,1,1),new Ki(3,0,1,1),new Ki(1,0,1,1)],this._cubeDirections=[new $(1,0,0),new $(-1,0,0),new $(0,0,1),new $(0,0,-1),new $(0,1,0),new $(0,-1,0)],this._cubeUps=[new $(0,1,0),new $(0,1,0),new $(0,1,0),new $(0,1,0),new $(0,0,1),new $(0,0,-1)]}updateMatrices(t,e=0){let i=this.camera,r=this.matrix,o=t.distance||i.far;o!==i.far&&(i.far=o,i.updateProjectionMatrix()),yx.setFromMatrixPosition(t.matrixWorld),i.position.copy(yx),yB.copy(i.position),yB.add(this._cubeDirections[e]),i.up.copy(this._cubeUps[e]),i.lookAt(yB),i.updateMatrixWorld(),r.makeTranslation(-yx.x,-yx.y,-yx.z),ote.multiplyMatrices(i.projectionMatrix,i.matrixWorldInverse),this._frustum.setFromProjectionMatrix(ote)}};QI.prototype.isPointLightShadow=!0,class extends tl{constructor(t,e,i=0,r=1){super(t,e),this.type="PointLight",this.distance=i,this.decay=r,this.shadow=new QI}get power(){return 4*this.intensity*Math.PI}set power(t){this.intensity=t/(4*Math.PI)}dispose(){this.shadow.dispose()}copy(t){return super.copy(t),this.distance=t.distance,this.decay=t.decay,this.shadow=t.shadow.clone(),this}}.prototype.isPointLight=!0;var ZI=class extends Yx{constructor(){super(new Tm(-5,5,5,-5,.5,500))}};ZI.prototype.isDirectionalLightShadow=!0,class extends tl{constructor(t,e){super(t,e),this.type="DirectionalLight",this.position.copy(zi.DefaultUp),this.updateMatrix(),this.target=new zi,this.shadow=new ZI}dispose(){this.shadow.dispose()}copy(t){return super.copy(t),this.target=t.target.clone(),this.shadow=t.shadow.clone(),this}}.prototype.isDirectionalLight=!0,class extends tl{constructor(t,e){super(t,e),this.type="AmbientLight"}}.prototype.isAmbientLight=!0,class extends tl{constructor(t,e,i=10,r=10){super(t,e),this.type="RectAreaLight",this.width=i,this.height=r}get power(){return this.intensity*this.width*this.height*Math.PI}set power(t){this.intensity=t/(this.width*this.height*Math.PI)}copy(t){return super.copy(t),this.width=t.width,this.height=t.height,this}toJSON(t){let e=super.toJSON(t);return e.object.width=this.width,e.object.height=this.height,e}}.prototype.isRectAreaLight=!0;var KI=class{constructor(){this.coefficients=[];for(let t=0;t<9;t++)this.coefficients.push(new $)}set(t){for(let e=0;e<9;e++)this.coefficients[e].copy(t[e]);return this}zero(){for(let t=0;t<9;t++)this.coefficients[t].set(0,0,0);return this}getAt(t,e){let i=t.x,r=t.y,o=t.z,a=this.coefficients;return e.copy(a[0]).multiplyScalar(.282095),e.addScaledVector(a[1],.488603*r),e.addScaledVector(a[2],.488603*o),e.addScaledVector(a[3],.488603*i),e.addScaledVector(a[4],i*r*1.092548),e.addScaledVector(a[5],r*o*1.092548),e.addScaledVector(a[6],.315392*(3*o*o-1)),e.addScaledVector(a[7],i*o*1.092548),e.addScaledVector(a[8],.546274*(i*i-r*r)),e}getIrradianceAt(t,e){let i=t.x,r=t.y,o=t.z,a=this.coefficients;return e.copy(a[0]).multiplyScalar(.886227),e.addScaledVector(a[1],1.023328*r),e.addScaledVector(a[2],1.023328*o),e.addScaledVector(a[3],1.023328*i),e.addScaledVector(a[4],.858086*i*r),e.addScaledVector(a[5],.858086*r*o),e.addScaledVector(a[6],.743125*o*o-.247708),e.addScaledVector(a[7],.858086*i*o),e.addScaledVector(a[8],.429043*(i*i-r*r)),e}add(t){for(let e=0;e<9;e++)this.coefficients[e].add(t.coefficients[e]);return this}addScaledSH(t,e){for(let i=0;i<9;i++)this.coefficients[i].addScaledVector(t.coefficients[i],e);return this}scale(t){for(let e=0;e<9;e++)this.coefficients[e].multiplyScalar(t);return this}lerp(t,e){for(let i=0;i<9;i++)this.coefficients[i].lerp(t.coefficients[i],e);return this}equals(t){for(let e=0;e<9;e++)if(!this.coefficients[e].equals(t.coefficients[e]))return!1;return!0}copy(t){return this.set(t.coefficients)}clone(){return(new this.constructor).copy(this)}fromArray(t,e=0){let i=this.coefficients;for(let r=0;r<9;r++)i[r].fromArray(t,e+3*r);return this}toArray(t=[],e=0){let i=this.coefficients;for(let r=0;r<9;r++)i[r].toArray(t,e+3*r);return t}static getBasisAt(t,e){let i=t.x,r=t.y,o=t.z;e[0]=.282095,e[1]=.488603*r,e[2]=.488603*o,e[3]=.488603*i,e[4]=1.092548*i*r,e[5]=1.092548*r*o,e[6]=.315392*(3*o*o-1),e[7]=1.092548*i*o,e[8]=.546274*(i*i-r*r)}};KI.prototype.isSphericalHarmonics3=!0;var Xx=class extends tl{constructor(t=new KI,e=1){super(void 0,e),this.sh=t}copy(t){return super.copy(t),this.sh.copy(t.sh),this}fromJSON(t){return this.intensity=t.intensity,this.sh.fromArray(t.sh),this}toJSON(t){let e=super.toJSON(t);return e.object.sh=this.sh.toArray(),e}};Xx.prototype.isLightProbe=!0;var gV=class{static decodeText(t){if(typeof TextDecoder<"u")return(new TextDecoder).decode(t);let e="";for(let i=0,r=t.length;i<r;i++)e+=String.fromCharCode(t[i]);try{return decodeURIComponent(escape(e))}catch{return e}}static extractUrlBase(t){let e=t.lastIndexOf("/");return-1===e?"./":t.substr(0,e+1)}static resolveURL(t,e){return"string"!=typeof t||""===t?"":(/^https?:\/\//i.test(e)&&/^\//.test(t)&&(e=e.replace(/(^https?:\/\/[^\/]+).*/i,"$1")),/^(https?:)?\/\//i.test(t)||/^data:.*,.*$/i.test(t)||/^blob:.*$/i.test(t)?t:e+t)}};(class extends Wi{constructor(){super(),this.type="InstancedBufferGeometry",this.instanceCount=1/0}copy(t){return super.copy(t),this.instanceCount=t.instanceCount,this}clone(){return(new this.constructor).copy(this)}toJSON(){let t=super.toJSON(this);return t.instanceCount=this.instanceCount,t.isInstancedBufferGeometry=!0,t}}).prototype.isInstancedBufferGeometry=!0,class extends qc{constructor(t){super(t),typeof createImageBitmap>"u"&&console.warn("THREE.ImageBitmapLoader: createImageBitmap() not supported."),typeof fetch>"u"&&console.warn("THREE.ImageBitmapLoader: fetch() not supported."),this.options={premultiplyAlpha:"none"}}setOptions(t){return this.options=t,this}load(t,e,i,r){void 0===t&&(t=""),void 0!==this.path&&(t=this.path+t),t=this.manager.resolveURL(t);let o=this,a=__.get(t);if(void 0!==a)return o.manager.itemStart(t),setTimeout(function(){e&&e(a),o.manager.itemEnd(t)},0),a;let s={};s.credentials="anonymous"===this.crossOrigin?"same-origin":"include",s.headers=this.requestHeader,fetch(t,s).then(function(l){return l.blob()}).then(function(l){return createImageBitmap(l,Object.assign(o.options,{colorSpaceConversion:"none"}))}).then(function(l){__.add(t,l),e&&e(l),o.manager.itemEnd(t)}).catch(function(l){r&&r(l),o.manager.itemError(t),o.manager.itemEnd(t)}),o.manager.itemStart(t)}}.prototype.isImageBitmapLoader=!0;var bI,bV=class extends qc{constructor(t){super(t)}load(t,e,i,r){let o=this,a=new sV(this.manager);a.setResponseType("arraybuffer"),a.setPath(this.path),a.setRequestHeader(this.requestHeader),a.setWithCredentials(this.withCredentials),a.load(t,function(s){try{let l=s.slice(0);(void 0===bI&&(bI=new(window.AudioContext||window.webkitAudioContext)),bI).decodeAudioData(l,function(d){e(d)})}catch(l){r?r(l):console.error(l),o.manager.itemError(t)}},i,r)}};(class extends Xx{constructor(t,e,i=1){super(void 0,i);let r=(new an).set(t),o=(new an).set(e),a=new $(r.r,r.g,r.b),s=new $(o.r,o.g,o.b),l=Math.sqrt(Math.PI),c=l*Math.sqrt(.75);this.sh.coefficients[0].copy(a).add(s).multiplyScalar(l),this.sh.coefficients[1].copy(a).sub(s).multiplyScalar(c)}}).prototype.isHemisphereLightProbe=!0,class extends Xx{constructor(t,e=1){super(void 0,e);let i=(new an).set(t);this.sh.coefficients[0].set(i.r,i.g,i.b).multiplyScalar(2*Math.sqrt(Math.PI))}}.prototype.isAmbientLightProbe=!0;var wV=class{constructor(t,e,i){let r,o,a;switch(this.binding=t,this.valueSize=i,e){case"quaternion":r=this._slerp,o=this._slerpAdditive,a=this._setAdditiveIdentityQuaternion,this.buffer=new Float64Array(6*i),this._workIndex=5;break;case"string":case"bool":r=this._select,o=this._select,a=this._setAdditiveIdentityOther,this.buffer=new Array(5*i);break;default:r=this._lerp,o=this._lerpAdditive,a=this._setAdditiveIdentityNumeric,this.buffer=new Float64Array(5*i)}this._mixBufferRegion=r,this._mixBufferRegionAdditive=o,this._setIdentity=a,this._origIndex=3,this._addIndex=4,this.cumulativeWeight=0,this.cumulativeWeightAdditive=0,this.useCount=0,this.referenceCount=0}accumulate(t,e){let i=this.buffer,r=this.valueSize,o=t*r+r,a=this.cumulativeWeight;if(0===a){for(let s=0;s!==r;++s)i[o+s]=i[s];a=e}else a+=e,this._mixBufferRegion(i,o,0,e/a,r);this.cumulativeWeight=a}accumulateAdditive(t){let e=this.buffer,i=this.valueSize,r=i*this._addIndex;0===this.cumulativeWeightAdditive&&this._setIdentity(),this._mixBufferRegionAdditive(e,r,0,t,i),this.cumulativeWeightAdditive+=t}apply(t){let e=this.valueSize,i=this.buffer,r=t*e+e,o=this.cumulativeWeight,a=this.cumulativeWeightAdditive,s=this.binding;this.cumulativeWeight=0,this.cumulativeWeightAdditive=0,o<1&&this._mixBufferRegion(i,r,e*this._origIndex,1-o,e),a>0&&this._mixBufferRegionAdditive(i,r,this._addIndex*e,1,e);for(let l=e,c=e+e;l!==c;++l)if(i[l]!==i[l+e]){s.setValue(i,r);break}}saveOriginalState(){let e=this.buffer,i=this.valueSize,r=i*this._origIndex;this.binding.getValue(e,r);for(let o=i,a=r;o!==a;++o)e[o]=e[r+o%i];this._setIdentity(),this.cumulativeWeight=0,this.cumulativeWeightAdditive=0}restoreOriginalState(){this.binding.setValue(this.buffer,3*this.valueSize)}_setAdditiveIdentityNumeric(){let t=this._addIndex*this.valueSize,e=t+this.valueSize;for(let i=t;i<e;i++)this.buffer[i]=0}_setAdditiveIdentityQuaternion(){this._setAdditiveIdentityNumeric(),this.buffer[this._addIndex*this.valueSize+3]=1}_setAdditiveIdentityOther(){let t=this._origIndex*this.valueSize,e=this._addIndex*this.valueSize;for(let i=0;i<this.valueSize;i++)this.buffer[e+i]=this.buffer[t+i]}_select(t,e,i,r,o){if(r>=.5)for(let a=0;a!==o;++a)t[e+a]=t[i+a]}_slerp(t,e,i,r){aa.slerpFlat(t,e,t,e,t,i,r)}_slerpAdditive(t,e,i,r,o){let a=this._workIndex*o;aa.multiplyQuaternionsFlat(t,a,t,e,t,i),aa.slerpFlat(t,e,t,e,t,a,r)}_lerp(t,e,i,r,o){let a=1-r;for(let s=0;s!==o;++s){let l=e+s;t[l]=t[l]*a+t[i+s]*r}}_lerpAdditive(t,e,i,r,o){for(let a=0;a!==o;++a){let s=e+a;t[s]=t[s]+t[i+a]*r}}},VV="\\[\\]\\.:\\/",d2e=new RegExp("["+VV+"]","g"),HV="[^"+VV+"]",u2e="[^"+VV.replace("\\.","")+"]",p2e=/((?:WC+[\/:])*)/.source.replace("WC",HV),f2e=/(WCOD+)?/.source.replace("WCOD",u2e),m2e=/(?:\.(WC+)(?:\[(.+)\])?)?/.source.replace("WC",HV),h2e=/\.(WC+)(?:\[(.+)\])?/.source.replace("WC",HV),g2e=new RegExp("^"+p2e+f2e+m2e+h2e+"$"),_2e=["material","materials","bones"],SV=class{constructor(t,e,i){let r=i||br.parseTrackName(e);this._targetGroup=t,this._bindings=t.subscribe_(e,r)}getValue(t,e){this.bind();let r=this._bindings[this._targetGroup.nCachedObjects_];void 0!==r&&r.getValue(t,e)}setValue(t,e){let i=this._bindings;for(let r=this._targetGroup.nCachedObjects_,o=i.length;r!==o;++r)i[r].setValue(t,e)}bind(){let t=this._bindings;for(let e=this._targetGroup.nCachedObjects_,i=t.length;e!==i;++e)t[e].bind()}unbind(){let t=this._bindings;for(let e=this._targetGroup.nCachedObjects_,i=t.length;e!==i;++e)t[e].unbind()}},br=(()=>{class n{constructor(e,i,r){this.path=i,this.parsedPath=r||n.parseTrackName(i),this.node=n.findNode(e,this.parsedPath.nodeName)||e,this.rootNode=e,this.getValue=this._getValue_unbound,this.setValue=this._setValue_unbound}static create(e,i,r){return e&&e.isAnimationObjectGroup?new n.Composite(e,i,r):new n(e,i,r)}static sanitizeNodeName(e){return e.replace(/\s/g,"_").replace(d2e,"")}static parseTrackName(e){let i=g2e.exec(e);if(!i)throw new Error("PropertyBinding: Cannot parse trackName: "+e);let r={nodeName:i[2],objectName:i[3],objectIndex:i[4],propertyName:i[5],propertyIndex:i[6]},o=r.nodeName&&r.nodeName.lastIndexOf(".");if(void 0!==o&&-1!==o){let a=r.nodeName.substring(o+1);-1!==_2e.indexOf(a)&&(r.nodeName=r.nodeName.substring(0,o),r.objectName=a)}if(null===r.propertyName||0===r.propertyName.length)throw new Error("PropertyBinding: can not parse propertyName from trackName: "+e);return r}static findNode(e,i){if(!i||""===i||"."===i||-1===i||i===e.name||i===e.uuid)return e;if(e.skeleton){let r=e.skeleton.getBoneByName(i);if(void 0!==r)return r}if(e.children){let r=function(a){for(let s=0;s<a.length;s++){let l=a[s];if(l.name===i||l.uuid===i)return l;let c=r(l.children);if(c)return c}return null},o=r(e.children);if(o)return o}return null}_getValue_unavailable(){}_setValue_unavailable(){}_getValue_direct(e,i){e[i]=this.targetObject[this.propertyName]}_getValue_array(e,i){let r=this.resolvedProperty;for(let o=0,a=r.length;o!==a;++o)e[i++]=r[o]}_getValue_arrayElement(e,i){e[i]=this.resolvedProperty[this.propertyIndex]}_getValue_toArray(e,i){this.resolvedProperty.toArray(e,i)}_setValue_direct(e,i){this.targetObject[this.propertyName]=e[i]}_setValue_direct_setNeedsUpdate(e,i){this.targetObject[this.propertyName]=e[i],this.targetObject.needsUpdate=!0}_setValue_direct_setMatrixWorldNeedsUpdate(e,i){this.targetObject[this.propertyName]=e[i],this.targetObject.matrixWorldNeedsUpdate=!0}_setValue_array(e,i){let r=this.resolvedProperty;for(let o=0,a=r.length;o!==a;++o)r[o]=e[i++]}_setValue_array_setNeedsUpdate(e,i){let r=this.resolvedProperty;for(let o=0,a=r.length;o!==a;++o)r[o]=e[i++];this.targetObject.needsUpdate=!0}_setValue_array_setMatrixWorldNeedsUpdate(e,i){let r=this.resolvedProperty;for(let o=0,a=r.length;o!==a;++o)r[o]=e[i++];this.targetObject.matrixWorldNeedsUpdate=!0}_setValue_arrayElement(e,i){this.resolvedProperty[this.propertyIndex]=e[i]}_setValue_arrayElement_setNeedsUpdate(e,i){this.resolvedProperty[this.propertyIndex]=e[i],this.targetObject.needsUpdate=!0}_setValue_arrayElement_setMatrixWorldNeedsUpdate(e,i){this.resolvedProperty[this.propertyIndex]=e[i],this.targetObject.matrixWorldNeedsUpdate=!0}_setValue_fromArray(e,i){this.resolvedProperty.fromArray(e,i)}_setValue_fromArray_setNeedsUpdate(e,i){this.resolvedProperty.fromArray(e,i),this.targetObject.needsUpdate=!0}_setValue_fromArray_setMatrixWorldNeedsUpdate(e,i){this.resolvedProperty.fromArray(e,i),this.targetObject.matrixWorldNeedsUpdate=!0}_getValue_unbound(e,i){this.bind(),this.getValue(e,i)}_setValue_unbound(e,i){this.bind(),this.setValue(e,i)}bind(){let e=this.node,i=this.parsedPath,r=i.objectName,o=i.propertyName,a=i.propertyIndex;if(e||(e=n.findNode(this.rootNode,i.nodeName)||this.rootNode,this.node=e),this.getValue=this._getValue_unavailable,this.setValue=this._setValue_unavailable,!e)return void console.error("THREE.PropertyBinding: Trying to update node for track: "+this.path+" but it wasn't found.");if(r){let d=i.objectIndex;switch(r){case"materials":if(!e.material)return void console.error("THREE.PropertyBinding: Can not bind to material as node does not have a material.",this);if(!e.material.materials)return void console.error("THREE.PropertyBinding: Can not bind to material.materials as node.material does not have a materials array.",this);e=e.material.materials;break;case"bones":if(!e.skeleton)return void console.error("THREE.PropertyBinding: Can not bind to bones as node does not have a skeleton.",this);e=e.skeleton.bones;for(let u=0;u<e.length;u++)if(e[u].name===d){d=u;break}break;default:if(void 0===e[r])return void console.error("THREE.PropertyBinding: Can not bind to objectName of node undefined.",this);e=e[r]}if(void 0!==d){if(void 0===e[d])return void console.error("THREE.PropertyBinding: Trying to bind to objectIndex of objectName, but is undefined.",this,e);e=e[d]}}let s=e[o];if(void 0===s)return void console.error("THREE.PropertyBinding: Trying to update property for track: "+i.nodeName+"."+o+" but it wasn't found.",e);let l=this.Versioning.None;this.targetObject=e,void 0!==e.needsUpdate?l=this.Versioning.NeedsUpdate:void 0!==e.matrixWorldNeedsUpdate&&(l=this.Versioning.MatrixWorldNeedsUpdate);let c=this.BindingType.Direct;if(void 0!==a){if("morphTargetInfluences"===o){if(!e.geometry)return void console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.",this);if(!e.geometry.isBufferGeometry)return void console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences on THREE.Geometry. Use THREE.BufferGeometry instead.",this);if(!e.geometry.morphAttributes)return void console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.morphAttributes.",this);void 0!==e.morphTargetDictionary[a]&&(a=e.morphTargetDictionary[a])}c=this.BindingType.ArrayElement,this.resolvedProperty=s,this.propertyIndex=a}else void 0!==s.fromArray&&void 0!==s.toArray?(c=this.BindingType.HasFromToArray,this.resolvedProperty=s):Array.isArray(s)?(c=this.BindingType.EntireArray,this.resolvedProperty=s):this.propertyName=o;this.getValue=this.GetterByBindingType[c],this.setValue=this.SetterByBindingTypeAndVersioning[c][l]}unbind(){this.node=null,this.getValue=this._getValue_unbound,this.setValue=this._setValue_unbound}}return n.Composite=SV,n})();br.prototype.BindingType={Direct:0,EntireArray:1,ArrayElement:2,HasFromToArray:3},br.prototype.Versioning={None:0,NeedsUpdate:1,MatrixWorldNeedsUpdate:2},br.prototype.GetterByBindingType=[br.prototype._getValue_direct,br.prototype._getValue_array,br.prototype._getValue_arrayElement,br.prototype._getValue_toArray],br.prototype.SetterByBindingTypeAndVersioning=[[br.prototype._setValue_direct,br.prototype._setValue_direct_setNeedsUpdate,br.prototype._setValue_direct_setMatrixWorldNeedsUpdate],[br.prototype._setValue_array,br.prototype._setValue_array_setNeedsUpdate,br.prototype._setValue_array_setMatrixWorldNeedsUpdate],[br.prototype._setValue_arrayElement,br.prototype._setValue_arrayElement_setNeedsUpdate,br.prototype._setValue_arrayElement_setMatrixWorldNeedsUpdate],[br.prototype._setValue_fromArray,br.prototype._setValue_fromArray_setNeedsUpdate,br.prototype._setValue_fromArray_setMatrixWorldNeedsUpdate]],class extends Ud{constructor(t){super(),this._root=t,this._initMemoryManager(),this._accuIndex=0,this.time=0,this.timeScale=1}_bindAction(t,e){let i=t._localRoot||this._root,r=t._clip.tracks,o=r.length,a=t._propertyBindings,s=t._interpolants,l=i.uuid,c=this._bindingsByRootAndName,d=c[l];void 0===d&&(d={},c[l]=d);for(let u=0;u!==o;++u){let p=r[u],f=p.name,m=d[f];if(void 0!==m)++m.referenceCount,a[u]=m;else{if(m=a[u],void 0!==m){null===m._cacheIndex&&(++m.referenceCount,this._addInactiveBinding(m,l,f));continue}m=new wV(br.create(i,f,e&&e._propertyBindings[u].binding.parsedPath),p.ValueTypeName,p.getValueSize()),++m.referenceCount,this._addInactiveBinding(m,l,f),a[u]=m}s[u].resultBuffer=m.buffer}}_activateAction(t){if(!this._isActiveAction(t)){if(null===t._cacheIndex){let i=(t._localRoot||this._root).uuid,r=t._clip.uuid,o=this._actionsByClip[r];this._bindAction(t,o&&o.knownActions[0]),this._addInactiveAction(t,r,i)}let e=t._propertyBindings;for(let i=0,r=e.length;i!==r;++i){let o=e[i];0==o.useCount++&&(this._lendBinding(o),o.saveOriginalState())}this._lendAction(t)}}_deactivateAction(t){if(this._isActiveAction(t)){let e=t._propertyBindings;for(let i=0,r=e.length;i!==r;++i){let o=e[i];0==--o.useCount&&(o.restoreOriginalState(),this._takeBackBinding(o))}this._takeBackAction(t)}}_initMemoryManager(){this._actions=[],this._nActiveActions=0,this._actionsByClip={},this._bindings=[],this._nActiveBindings=0,this._bindingsByRootAndName={},this._controlInterpolants=[],this._nActiveControlInterpolants=0;let t=this;this.stats={actions:{get total(){return t._actions.length},get inUse(){return t._nActiveActions}},bindings:{get total(){return t._bindings.length},get inUse(){return t._nActiveBindings}},controlInterpolants:{get total(){return t._controlInterpolants.length},get inUse(){return t._nActiveControlInterpolants}}}}_isActiveAction(t){let e=t._cacheIndex;return null!==e&&e<this._nActiveActions}_addInactiveAction(t,e,i){let r=this._actions,o=this._actionsByClip,a=o[e];if(void 0===a)a={knownActions:[t],actionByRoot:{}},t._byClipCacheIndex=0,o[e]=a;else{let s=a.knownActions;t._byClipCacheIndex=s.length,s.push(t)}t._cacheIndex=r.length,r.push(t),a.actionByRoot[i]=t}_removeInactiveAction(t){let e=this._actions,i=e[e.length-1],r=t._cacheIndex;i._cacheIndex=r,e[r]=i,e.pop(),t._cacheIndex=null;let o=t._clip.uuid,a=this._actionsByClip,s=a[o],l=s.knownActions,c=l[l.length-1],d=t._byClipCacheIndex;c._byClipCacheIndex=d,l[d]=c,l.pop(),t._byClipCacheIndex=null,delete s.actionByRoot[(t._localRoot||this._root).uuid],0===l.length&&delete a[o],this._removeInactiveBindingsForAction(t)}_removeInactiveBindingsForAction(t){let e=t._propertyBindings;for(let i=0,r=e.length;i!==r;++i){let o=e[i];0==--o.referenceCount&&this._removeInactiveBinding(o)}}_lendAction(t){let e=this._actions,i=t._cacheIndex,r=this._nActiveActions++,o=e[r];t._cacheIndex=r,e[r]=t,o._cacheIndex=i,e[i]=o}_takeBackAction(t){let e=this._actions,i=t._cacheIndex,r=--this._nActiveActions,o=e[r];t._cacheIndex=r,e[r]=t,o._cacheIndex=i,e[i]=o}_addInactiveBinding(t,e,i){let r=this._bindingsByRootAndName,o=this._bindings,a=r[e];void 0===a&&(a={},r[e]=a),a[i]=t,t._cacheIndex=o.length,o.push(t)}_removeInactiveBinding(t){let e=this._bindings,i=t.binding,r=i.rootNode.uuid,o=i.path,a=this._bindingsByRootAndName,s=a[r],l=e[e.length-1],c=t._cacheIndex;l._cacheIndex=c,e[c]=l,e.pop(),delete s[o],0===Object.keys(s).length&&delete a[r]}_lendBinding(t){let e=this._bindings,i=t._cacheIndex,r=this._nActiveBindings++,o=e[r];t._cacheIndex=r,e[r]=t,o._cacheIndex=i,e[i]=o}_takeBackBinding(t){let e=this._bindings,i=t._cacheIndex,r=--this._nActiveBindings,o=e[r];t._cacheIndex=r,e[r]=t,o._cacheIndex=i,e[i]=o}_lendControlInterpolant(){let t=this._controlInterpolants,e=this._nActiveControlInterpolants++,i=t[e];return void 0===i&&(i=new GI(new Float32Array(2),new Float32Array(2),1,this._controlInterpolantsResultBuffer),i.__cacheIndex=e,t[e]=i),i}_takeBackControlInterpolant(t){let e=this._controlInterpolants,i=t.__cacheIndex,r=--this._nActiveControlInterpolants,o=e[r];t.__cacheIndex=r,e[r]=t,o.__cacheIndex=i,e[i]=o}clipAction(t,e,i){let r=e||this._root,o=r.uuid,a="string"==typeof t?qI.findByName(r,t):t,s=null!==a?a.uuid:t,l=this._actionsByClip[s],c=null;if(void 0===i&&(i=null!==a?a.blendMode:2500),void 0!==l){let u=l.actionByRoot[o];if(void 0!==u&&u.blendMode===i)return u;c=l.knownActions[0],null===a&&(a=c._clip)}if(null===a)return null;let d=new class{constructor(t,e,i=null,r=e.blendMode){this._mixer=t,this._clip=e,this._localRoot=i,this.blendMode=r;let o=e.tracks,a=o.length,s=new Array(a),l={endingStart:J0,endingEnd:J0};for(let c=0;c!==a;++c){let d=o[c].createInterpolant(null);s[c]=d,d.settings=l}this._interpolantSettings=l,this._interpolants=s,this._propertyBindings=new Array(a),this._cacheIndex=null,this._byClipCacheIndex=null,this._timeScaleInterpolant=null,this._weightInterpolant=null,this.loop=2201,this._loopCount=-1,this._startTime=null,this.time=0,this.timeScale=1,this._effectiveTimeScale=1,this.weight=1,this._effectiveWeight=1,this.repetitions=1/0,this.paused=!1,this.enabled=!0,this.clampWhenFinished=!1,this.zeroSlopeAtStart=!0,this.zeroSlopeAtEnd=!0}play(){return this._mixer._activateAction(this),this}stop(){return this._mixer._deactivateAction(this),this.reset()}reset(){return this.paused=!1,this.enabled=!0,this.time=0,this._loopCount=-1,this._startTime=null,this.stopFading().stopWarping()}isRunning(){return this.enabled&&!this.paused&&0!==this.timeScale&&null===this._startTime&&this._mixer._isActiveAction(this)}isScheduled(){return this._mixer._isActiveAction(this)}startAt(t){return this._startTime=t,this}setLoop(t,e){return this.loop=t,this.repetitions=e,this}setEffectiveWeight(t){return this.weight=t,this._effectiveWeight=this.enabled?t:0,this.stopFading()}getEffectiveWeight(){return this._effectiveWeight}fadeIn(t){return this._scheduleFading(t,0,1)}fadeOut(t){return this._scheduleFading(t,1,0)}crossFadeFrom(t,e,i){if(t.fadeOut(e),this.fadeIn(e),i){let r=this._clip.duration,o=t._clip.duration,s=r/o;t.warp(1,o/r,e),this.warp(s,1,e)}return this}crossFadeTo(t,e,i){return t.crossFadeFrom(this,e,i)}stopFading(){let t=this._weightInterpolant;return null!==t&&(this._weightInterpolant=null,this._mixer._takeBackControlInterpolant(t)),this}setEffectiveTimeScale(t){return this.timeScale=t,this._effectiveTimeScale=this.paused?0:t,this.stopWarping()}getEffectiveTimeScale(){return this._effectiveTimeScale}setDuration(t){return this.timeScale=this._clip.duration/t,this.stopWarping()}syncWith(t){return this.time=t.time,this.timeScale=t.timeScale,this.stopWarping()}halt(t){return this.warp(this._effectiveTimeScale,0,t)}warp(t,e,i){let r=this._mixer,o=r.time,a=this.timeScale,s=this._timeScaleInterpolant;null===s&&(s=r._lendControlInterpolant(),this._timeScaleInterpolant=s);let l=s.parameterPositions,c=s.sampleValues;return l[0]=o,l[1]=o+i,c[0]=t/a,c[1]=e/a,this}stopWarping(){let t=this._timeScaleInterpolant;return null!==t&&(this._timeScaleInterpolant=null,this._mixer._takeBackControlInterpolant(t)),this}getMixer(){return this._mixer}getClip(){return this._clip}getRoot(){return this._localRoot||this._mixer._root}_update(t,e,i,r){if(!this.enabled)return void this._updateWeight(t);let o=this._startTime;if(null!==o){let l=(t-o)*i;if(l<0||0===i)return;this._startTime=null,e=i*l}e*=this._updateTimeScale(t);let a=this._updateTime(e),s=this._updateWeight(t);if(s>0){let l=this._interpolants,c=this._propertyBindings;if(2501===this.blendMode)for(let d=0,u=l.length;d!==u;++d)l[d].evaluate(a),c[d].accumulateAdditive(s);else for(let d=0,u=l.length;d!==u;++d)l[d].evaluate(a),c[d].accumulate(r,s)}}_updateWeight(t){let e=0;if(this.enabled){e=this.weight;let i=this._weightInterpolant;if(null!==i){let r=i.evaluate(t)[0];e*=r,t>i.parameterPositions[1]&&(this.stopFading(),0===r&&(this.enabled=!1))}}return this._effectiveWeight=e,e}_updateTimeScale(t){let e=0;if(!this.paused){e=this.timeScale;let i=this._timeScaleInterpolant;null!==i&&(e*=i.evaluate(t)[0],t>i.parameterPositions[1]&&(this.stopWarping(),0===e?this.paused=!0:this.timeScale=e))}return this._effectiveTimeScale=e,e}_updateTime(t){let e=this._clip.duration,i=this.loop,r=this.time+t,o=this._loopCount,a=2202===i;if(0===t)return-1===o?r:a&&1==(1&o)?e-r:r;if(2200===i){-1===o&&(this._loopCount=0,this._setEndings(!0,!0,!1));e:{if(r>=e)r=e;else{if(!(r<0)){this.time=r;break e}r=0}this.clampWhenFinished?this.paused=!0:this.enabled=!1,this.time=r,this._mixer.dispatchEvent({type:"finished",action:this,direction:t<0?-1:1})}}else{if(-1===o&&(t>=0?(o=0,this._setEndings(!0,0===this.repetitions,a)):this._setEndings(0===this.repetitions,!0,a)),r>=e||r<0){let s=Math.floor(r/e);r-=e*s,o+=Math.abs(s);let l=this.repetitions-o;if(l<=0)this.clampWhenFinished?this.paused=!0:this.enabled=!1,r=t>0?e:0,this.time=r,this._mixer.dispatchEvent({type:"finished",action:this,direction:t>0?1:-1});else{if(1===l){let c=t<0;this._setEndings(c,!c,a)}else this._setEndings(!1,!1,a);this._loopCount=o,this.time=r,this._mixer.dispatchEvent({type:"loop",action:this,loopDelta:s})}}else this.time=r;if(a&&1==(1&o))return e-r}return r}_setEndings(t,e,i){let r=this._interpolantSettings;i?(r.endingStart=$0,r.endingEnd=$0):(r.endingStart=t?this.zeroSlopeAtStart?$0:J0:2402,r.endingEnd=e?this.zeroSlopeAtEnd?$0:J0:2402)}_scheduleFading(t,e,i){let r=this._mixer,o=r.time,a=this._weightInterpolant;null===a&&(a=r._lendControlInterpolant(),this._weightInterpolant=a);let s=a.parameterPositions,l=a.sampleValues;return s[0]=o,l[0]=e,s[1]=o+t,l[1]=i,this}}(this,a,e,i);return this._bindAction(d,c),this._addInactiveAction(d,s,o),d}existingAction(t,e){let i=e||this._root,r=i.uuid,o="string"==typeof t?qI.findByName(i,t):t,s=this._actionsByClip[o?o.uuid:t];return void 0!==s&&s.actionByRoot[r]||null}stopAllAction(){let t=this._actions;for(let i=this._nActiveActions-1;i>=0;--i)t[i].stop();return this}update(t){let e=this._actions,i=this._nActiveActions,r=this.time+=t*=this.timeScale,o=Math.sign(t),a=this._accuIndex^=1;for(let c=0;c!==i;++c)e[c]._update(r,t,o,a);let s=this._bindings,l=this._nActiveBindings;for(let c=0;c!==l;++c)s[c].apply(a);return this}setTime(t){this.time=0;for(let e=0;e<this._actions.length;e++)this._actions[e].time=0;return this.update(t)}getRoot(){return this._root}uncacheClip(t){let e=this._actions,i=t.uuid,r=this._actionsByClip,o=r[i];if(void 0!==o){let a=o.knownActions;for(let s=0,l=a.length;s!==l;++s){let c=a[s];this._deactivateAction(c);let d=c._cacheIndex,u=e[e.length-1];c._cacheIndex=null,c._byClipCacheIndex=null,u._cacheIndex=d,e[d]=u,e.pop(),this._removeInactiveBindingsForAction(c)}delete r[i]}}uncacheRoot(t){let e=t.uuid,i=this._actionsByClip;for(let a in i){let l=i[a].actionByRoot[e];void 0!==l&&(this._deactivateAction(l),this._removeInactiveAction(l))}let o=this._bindingsByRootAndName[e];if(void 0!==o)for(let a in o){let s=o[a];s.restoreOriginalState(),this._removeInactiveBinding(s)}}uncacheAction(t,e){let i=this.existingAction(t,e);null!==i&&(this._deactivateAction(i),this._removeInactiveAction(i))}}.prototype._controlInterpolantsResultBuffer=new Float32Array(1);var Qx=class{constructor(t){"string"==typeof t&&(console.warn("THREE.Uniform: Type parameter is no longer needed."),t=arguments[1]),this.value=t}clone(){return new Qx(void 0===this.value.clone?this.value:this.value.clone())}};(class extends Dm{constructor(t,e,i=1){super(t,e),this.meshPerAttribute=i}copy(t){return super.copy(t),this.meshPerAttribute=t.meshPerAttribute,this}clone(t){let e=super.clone(t);return e.meshPerAttribute=this.meshPerAttribute,e}toJSON(t){let e=super.toJSON(t);return e.isInstancedInterleavedBuffer=!0,e.meshPerAttribute=this.meshPerAttribute,e}}).prototype.isInstancedInterleavedBuffer=!0;var ate=new $e,km=class{constructor(t=new $e(1/0,1/0),e=new $e(-1/0,-1/0)){this.min=t,this.max=e}set(t,e){return this.min.copy(t),this.max.copy(e),this}setFromPoints(t){this.makeEmpty();for(let e=0,i=t.length;e<i;e++)this.expandByPoint(t[e]);return this}setFromCenterAndSize(t,e){let i=ate.copy(e).multiplyScalar(.5);return this.min.copy(t).sub(i),this.max.copy(t).add(i),this}clone(){return(new this.constructor).copy(this)}copy(t){return this.min.copy(t.min),this.max.copy(t.max),this}makeEmpty(){return this.min.x=this.min.y=1/0,this.max.x=this.max.y=-1/0,this}isEmpty(){return this.max.x<this.min.x||this.max.y<this.min.y}getCenter(t){return this.isEmpty()?t.set(0,0):t.addVectors(this.min,this.max).multiplyScalar(.5)}getSize(t){return this.isEmpty()?t.set(0,0):t.subVectors(this.max,this.min)}expandByPoint(t){return this.min.min(t),this.max.max(t),this}expandByVector(t){return this.min.sub(t),this.max.add(t),this}expandByScalar(t){return this.min.addScalar(-t),this.max.addScalar(t),this}containsPoint(t){return!(t.x<this.min.x||t.x>this.max.x||t.y<this.min.y||t.y>this.max.y)}containsBox(t){return this.min.x<=t.min.x&&t.max.x<=this.max.x&&this.min.y<=t.min.y&&t.max.y<=this.max.y}getParameter(t,e){return e.set((t.x-this.min.x)/(this.max.x-this.min.x),(t.y-this.min.y)/(this.max.y-this.min.y))}intersectsBox(t){return!(t.max.x<this.min.x||t.min.x>this.max.x||t.max.y<this.min.y||t.min.y>this.max.y)}clampPoint(t,e){return e.copy(t).clamp(this.min,this.max)}distanceToPoint(t){return ate.copy(t).clamp(this.min,this.max).sub(t).length()}intersect(t){return this.min.max(t.min),this.max.min(t.max),this}union(t){return this.min.min(t.min),this.max.max(t.max),this}translate(t){return this.min.add(t),this.max.add(t),this}equals(t){return t.min.equals(this.min)&&t.max.equals(this.max)}};km.prototype.isBox2=!0;var _p=new $,xI=new Mn,bB=new Mn;function Rte(n){let t=[];n&&n.isBone&&t.push(n);for(let e=0;e<n.children.length;e++)t.push.apply(t,Rte(n.children[e]));return t}var y2e=new Float32Array(1);function zV(n,t,e){if(1===e)return new an(t);let i=Jf(t);if(!i)throw new Error(`d3 failed to recognize the color: ${t}`);return new an(NN(i,n)(1-e))}new Int32Array(y2e.buffer),Za.create=function(n,t){return console.log("THREE.Curve.create() has been deprecated"),n.prototype=Object.create(Za.prototype),n.prototype.constructor=n,n.prototype.getPoint=t,n},jx.prototype.fromPoints=function(n){return console.warn("THREE.Path: .fromPoints() has been renamed to .setFromPoints()."),this.setFromPoints(n)},class extends Vx{constructor(t=10,e=10,i=4473924,r=8947848){i=new an(i),r=new an(r);let o=e/2,a=t/e,s=t/2,l=[],c=[];for(let p=0,f=0,m=-s;p<=e;p++,m+=a){l.push(-s,0,m,s,0,m),l.push(m,0,-s,m,0,s);let y=p===o?i:r;y.toArray(c,f),f+=3,y.toArray(c,f),f+=3,y.toArray(c,f),f+=3,y.toArray(c,f),f+=3}let d=new Wi;d.setAttribute("position",new Br(l,3)),d.setAttribute("color",new Br(c,3)),super(d,new Wd({vertexColors:!0,toneMapped:!1})),this.type="GridHelper"}}.prototype.setColors=function(){console.error("THREE.GridHelper: setColors() has been deprecated, pass them in the constructor instead.")},class extends Vx{constructor(t){let e=Rte(t),i=new Wi,r=[],o=[],a=new an(0,0,1),s=new an(0,1,0);for(let c=0;c<e.length;c++){let d=e[c];d.parent&&d.parent.isBone&&(r.push(0,0,0),r.push(0,0,0),o.push(a.r,a.g,a.b),o.push(s.r,s.g,s.b))}i.setAttribute("position",new Br(r,3)),i.setAttribute("color",new Br(o,3)),super(i,new Wd({vertexColors:!0,depthTest:!1,depthWrite:!1,toneMapped:!1,transparent:!0})),this.type="SkeletonHelper",this.isSkeletonHelper=!0,this.root=t,this.bones=e,this.matrix=t.matrixWorld,this.matrixAutoUpdate=!1}updateMatrixWorld(t){let e=this.bones,i=this.geometry,r=i.getAttribute("position");bB.copy(this.root.matrixWorld).invert();for(let o=0,a=0;o<e.length;o++){let s=e[o];s.parent&&s.parent.isBone&&(xI.multiplyMatrices(bB,s.matrixWorld),_p.setFromMatrixPosition(xI),r.setXYZ(a,_p.x,_p.y,_p.z),xI.multiplyMatrices(bB,s.parent.matrixWorld),_p.setFromMatrixPosition(xI),r.setXYZ(a+1,_p.x,_p.y,_p.z),a+=2)}i.getAttribute("position").needsUpdate=!0,super.updateMatrixWorld(t)}}.prototype.update=function(){console.error("THREE.SkeletonHelper: update() no longer needs to be called.")},qc.prototype.extractUrlBase=function(n){return console.warn("THREE.Loader: .extractUrlBase() has been deprecated. Use THREE.LoaderUtils.extractUrlBase() instead."),gV.extractUrlBase(n)},qc.Handlers={add:function(){console.error("THREE.Loader: Handlers.add() has been removed. Use LoadingManager.addHandler() instead.")},get:function(){console.error("THREE.Loader: Handlers.get() has been removed. Use LoadingManager.getHandler() instead.")}},km.prototype.center=function(n){return console.warn("THREE.Box2: .center() has been renamed to .getCenter()."),this.getCenter(n)},km.prototype.empty=function(){return console.warn("THREE.Box2: .empty() has been renamed to .isEmpty()."),this.isEmpty()},km.prototype.isIntersectionBox=function(n){return console.warn("THREE.Box2: .isIntersectionBox() has been renamed to .intersectsBox()."),this.intersectsBox(n)},km.prototype.size=function(n){return console.warn("THREE.Box2: .size() has been renamed to .getSize()."),this.getSize(n)},_s.prototype.center=function(n){return console.warn("THREE.Box3: .center() has been renamed to .getCenter()."),this.getCenter(n)},_s.prototype.empty=function(){return console.warn("THREE.Box3: .empty() has been renamed to .isEmpty()."),this.isEmpty()},_s.prototype.isIntersectionBox=function(n){return console.warn("THREE.Box3: .isIntersectionBox() has been renamed to .intersectsBox()."),this.intersectsBox(n)},_s.prototype.isIntersectionSphere=function(n){return console.warn("THREE.Box3: .isIntersectionSphere() has been renamed to .intersectsSphere()."),this.intersectsSphere(n)},_s.prototype.size=function(n){return console.warn("THREE.Box3: .size() has been renamed to .getSize()."),this.getSize(n)},wp.prototype.empty=function(){return console.warn("THREE.Sphere: .empty() has been renamed to .isEmpty()."),this.isEmpty()},c_.prototype.setFromMatrix=function(n){return console.warn("THREE.Frustum: .setFromMatrix() has been renamed to .setFromProjectionMatrix()."),this.setFromProjectionMatrix(n)},vo.prototype.flattenToArrayOffset=function(n,t){return console.warn("THREE.Matrix3: .flattenToArrayOffset() has been deprecated. Use .toArray() instead."),this.toArray(n,t)},vo.prototype.multiplyVector3=function(n){return console.warn("THREE.Matrix3: .multiplyVector3() has been removed. Use vector.applyMatrix3( matrix ) instead."),n.applyMatrix3(this)},vo.prototype.multiplyVector3Array=function(){console.error("THREE.Matrix3: .multiplyVector3Array() has been removed.")},vo.prototype.applyToBufferAttribute=function(n){return console.warn("THREE.Matrix3: .applyToBufferAttribute() has been removed. Use attribute.applyMatrix3( matrix ) instead."),n.applyMatrix3(this)},vo.prototype.applyToVector3Array=function(){console.error("THREE.Matrix3: .applyToVector3Array() has been removed.")},vo.prototype.getInverse=function(n){return console.warn("THREE.Matrix3: .getInverse() has been removed. Use matrixInv.copy( matrix ).invert(); instead."),this.copy(n).invert()},Mn.prototype.extractPosition=function(n){return console.warn("THREE.Matrix4: .extractPosition() has been renamed to .copyPosition()."),this.copyPosition(n)},Mn.prototype.flattenToArrayOffset=function(n,t){return console.warn("THREE.Matrix4: .flattenToArrayOffset() has been deprecated. Use .toArray() instead."),this.toArray(n,t)},Mn.prototype.getPosition=function(){return console.warn("THREE.Matrix4: .getPosition() has been removed. Use Vector3.setFromMatrixPosition( matrix ) instead."),(new $).setFromMatrixColumn(this,3)},Mn.prototype.setRotationFromQuaternion=function(n){return console.warn("THREE.Matrix4: .setRotationFromQuaternion() has been renamed to .makeRotationFromQuaternion()."),this.makeRotationFromQuaternion(n)},Mn.prototype.multiplyToArray=function(){console.warn("THREE.Matrix4: .multiplyToArray() has been removed.")},Mn.prototype.multiplyVector3=function(n){return console.warn("THREE.Matrix4: .multiplyVector3() has been removed. Use vector.applyMatrix4( matrix ) instead."),n.applyMatrix4(this)},Mn.prototype.multiplyVector4=function(n){return console.warn("THREE.Matrix4: .multiplyVector4() has been removed. Use vector.applyMatrix4( matrix ) instead."),n.applyMatrix4(this)},Mn.prototype.multiplyVector3Array=function(){console.error("THREE.Matrix4: .multiplyVector3Array() has been removed.")},Mn.prototype.rotateAxis=function(n){console.warn("THREE.Matrix4: .rotateAxis() has been removed. Use Vector3.transformDirection( matrix ) instead."),n.transformDirection(this)},Mn.prototype.crossVector=function(n){return console.warn("THREE.Matrix4: .crossVector() has been removed. Use vector.applyMatrix4( matrix ) instead."),n.applyMatrix4(this)},Mn.prototype.translate=function(){console.error("THREE.Matrix4: .translate() has been removed.")},Mn.prototype.rotateX=function(){console.error("THREE.Matrix4: .rotateX() has been removed.")},Mn.prototype.rotateY=function(){console.error("THREE.Matrix4: .rotateY() has been removed.")},Mn.prototype.rotateZ=function(){console.error("THREE.Matrix4: .rotateZ() has been removed.")},Mn.prototype.rotateByAxis=function(){console.error("THREE.Matrix4: .rotateByAxis() has been removed.")},Mn.prototype.applyToBufferAttribute=function(n){return console.warn("THREE.Matrix4: .applyToBufferAttribute() has been removed. Use attribute.applyMatrix4( matrix ) instead."),n.applyMatrix4(this)},Mn.prototype.applyToVector3Array=function(){console.error("THREE.Matrix4: .applyToVector3Array() has been removed.")},Mn.prototype.makeFrustum=function(n,t,e,i,r,o){return console.warn("THREE.Matrix4: .makeFrustum() has been removed. Use .makePerspective( left, right, top, bottom, near, far ) instead."),this.makePerspective(n,t,i,e,r,o)},Mn.prototype.getInverse=function(n){return console.warn("THREE.Matrix4: .getInverse() has been removed. Use matrixInv.copy( matrix ).invert(); instead."),this.copy(n).invert()},Xl.prototype.isIntersectionLine=function(n){return console.warn("THREE.Plane: .isIntersectionLine() has been renamed to .intersectsLine()."),this.intersectsLine(n)},aa.prototype.multiplyVector3=function(n){return console.warn("THREE.Quaternion: .multiplyVector3() has been removed. Use is now vector.applyQuaternion( quaternion ) instead."),n.applyQuaternion(this)},aa.prototype.inverse=function(){return console.warn("THREE.Quaternion: .inverse() has been renamed to invert()."),this.invert()},Sp.prototype.isIntersectionBox=function(n){return console.warn("THREE.Ray: .isIntersectionBox() has been renamed to .intersectsBox()."),this.intersectsBox(n)},Sp.prototype.isIntersectionPlane=function(n){return console.warn("THREE.Ray: .isIntersectionPlane() has been renamed to .intersectsPlane()."),this.intersectsPlane(n)},Sp.prototype.isIntersectionSphere=function(n){return console.warn("THREE.Ray: .isIntersectionSphere() has been renamed to .intersectsSphere()."),this.intersectsSphere(n)},jr.prototype.area=function(){return console.warn("THREE.Triangle: .area() has been renamed to .getArea()."),this.getArea()},jr.prototype.barycoordFromPoint=function(n,t){return console.warn("THREE.Triangle: .barycoordFromPoint() has been renamed to .getBarycoord()."),this.getBarycoord(n,t)},jr.prototype.midpoint=function(n){return console.warn("THREE.Triangle: .midpoint() has been renamed to .getMidpoint()."),this.getMidpoint(n)},jr.prototypenormal=function(n){return console.warn("THREE.Triangle: .normal() has been renamed to .getNormal()."),this.getNormal(n)},jr.prototype.plane=function(n){return console.warn("THREE.Triangle: .plane() has been renamed to .getPlane()."),this.getPlane(n)},jr.barycoordFromPoint=function(n,t,e,i,r){return console.warn("THREE.Triangle: .barycoordFromPoint() has been renamed to .getBarycoord()."),jr.getBarycoord(n,t,e,i,r)},jr.normal=function(n,t,e,i){return console.warn("THREE.Triangle: .normal() has been renamed to .getNormal()."),jr.getNormal(n,t,e,i)},qd.prototype.extractAllPoints=function(n){return console.warn("THREE.Shape: .extractAllPoints() has been removed. Use .extractPoints() instead."),this.extractPoints(n)},qd.prototype.extrude=function(n){return console.warn("THREE.Shape: .extrude() has been removed. Use ExtrudeGeometry() instead."),new Dp(this,n)},qd.prototype.makeGeometry=function(n){return console.warn("THREE.Shape: .makeGeometry() has been removed. Use ShapeGeometry() instead."),new Am(this,n)},$e.prototype.fromAttribute=function(n,t,e){return console.warn("THREE.Vector2: .fromAttribute() has been renamed to .fromBufferAttribute()."),this.fromBufferAttribute(n,t,e)},$e.prototype.distanceToManhattan=function(n){return console.warn("THREE.Vector2: .distanceToManhattan() has been renamed to .manhattanDistanceTo()."),this.manhattanDistanceTo(n)},$e.prototype.lengthManhattan=function(){return console.warn("THREE.Vector2: .lengthManhattan() has been renamed to .manhattanLength()."),this.manhattanLength()},$.prototype.setEulerFromRotationMatrix=function(){console.error("THREE.Vector3: .setEulerFromRotationMatrix() has been removed. Use Euler.setFromRotationMatrix() instead.")},$.prototype.setEulerFromQuaternion=function(){console.error("THREE.Vector3: .setEulerFromQuaternion() has been removed. Use Euler.setFromQuaternion() instead.")},$.prototype.getPositionFromMatrix=function(n){return console.warn("THREE.Vector3: .getPositionFromMatrix() has been renamed to .setFromMatrixPosition()."),this.setFromMatrixPosition(n)},$.prototype.getScaleFromMatrix=function(n){return console.warn("THREE.Vector3: .getScaleFromMatrix() has been renamed to .setFromMatrixScale()."),this.setFromMatrixScale(n)},$.prototype.getColumnFromMatrix=function(n,t){return console.warn("THREE.Vector3: .getColumnFromMatrix() has been renamed to .setFromMatrixColumn()."),this.setFromMatrixColumn(t,n)},$.prototype.applyProjection=function(n){return console.warn("THREE.Vector3: .applyProjection() has been removed. Use .applyMatrix4( m ) instead."),this.applyMatrix4(n)},$.prototype.fromAttribute=function(n,t,e){return console.warn("THREE.Vector3: .fromAttribute() has been renamed to .fromBufferAttribute()."),this.fromBufferAttribute(n,t,e)},$.prototype.distanceToManhattan=function(n){return console.warn("THREE.Vector3: .distanceToManhattan() has been renamed to .manhattanDistanceTo()."),this.manhattanDistanceTo(n)},$.prototype.lengthManhattan=function(){return console.warn("THREE.Vector3: .lengthManhattan() has been renamed to .manhattanLength()."),this.manhattanLength()},Ki.prototype.fromAttribute=function(n,t,e){return console.warn("THREE.Vector4: .fromAttribute() has been renamed to .fromBufferAttribute()."),this.fromBufferAttribute(n,t,e)},Ki.prototype.lengthManhattan=function(){return console.warn("THREE.Vector4: .lengthManhattan() has been renamed to .manhattanLength()."),this.manhattanLength()},zi.prototype.getChildByName=function(n){return console.warn("THREE.Object3D: .getChildByName() has been renamed to .getObjectByName()."),this.getObjectByName(n)},zi.prototype.renderDepth=function(){console.warn("THREE.Object3D: .renderDepth has been removed. Use .renderOrder, instead.")},zi.prototype.translate=function(n,t){return console.warn("THREE.Object3D: .translate() has been removed. Use .translateOnAxis( axis, distance ) instead."),this.translateOnAxis(t,n)},zi.prototype.getWorldRotation=function(){console.error("THREE.Object3D: .getWorldRotation() has been removed. Use THREE.Object3D.getWorldQuaternion( target ) instead.")},zi.prototype.applyMatrix=function(n){return console.warn("THREE.Object3D: .applyMatrix() has been renamed to .applyMatrix4()."),this.applyMatrix4(n)},Object.defineProperties(zi.prototype,{eulerOrder:{get:function(){return console.warn("THREE.Object3D: .eulerOrder is now .rotation.order."),this.rotation.order},set:function(n){console.warn("THREE.Object3D: .eulerOrder is now .rotation.order."),this.rotation.order=n}},useQuaternion:{get:function(){console.warn("THREE.Object3D: .useQuaternion has been removed. The library now uses quaternions by default.")},set:function(){console.warn("THREE.Object3D: .useQuaternion has been removed. The library now uses quaternions by default.")}}}),co.prototype.setDrawMode=function(){console.error("THREE.Mesh: .setDrawMode() has been removed. The renderer now always assumes THREE.TrianglesDrawMode. Transform your geometry via BufferGeometryUtils.toTrianglesDrawMode() if necessary.")},Object.defineProperties(co.prototype,{drawMode:{get:function(){return console.error("THREE.Mesh: .drawMode has been removed. The renderer now always assumes THREE.TrianglesDrawMode."),0},set:function(){console.error("THREE.Mesh: .drawMode has been removed. The renderer now always assumes THREE.TrianglesDrawMode. Transform your geometry via BufferGeometryUtils.toTrianglesDrawMode() if necessary.")}}}),NI.prototype.initBones=function(){console.error("THREE.SkinnedMesh: initBones() has been removed.")},oa.prototype.setLens=function(n,t){console.warn("THREE.PerspectiveCamera.setLens is deprecated. Use .setFocalLength and .filmGauge for a photographic setup."),void 0!==t&&(this.filmGauge=t),this.setFocalLength(n)},Object.defineProperties(tl.prototype,{onlyShadow:{set:function(){console.warn("THREE.Light: .onlyShadow has been removed.")}},shadowCameraFov:{set:function(n){console.warn("THREE.Light: .shadowCameraFov is now .shadow.camera.fov."),this.shadow.camera.fov=n}},shadowCameraLeft:{set:function(n){console.warn("THREE.Light: .shadowCameraLeft is now .shadow.camera.left."),this.shadow.camera.left=n}},shadowCameraRight:{set:function(n){console.warn("THREE.Light: .shadowCameraRight is now .shadow.camera.right."),this.shadow.camera.right=n}},shadowCameraTop:{set:function(n){console.warn("THREE.Light: .shadowCameraTop is now .shadow.camera.top."),this.shadow.camera.top=n}},shadowCameraBottom:{set:function(n){console.warn("THREE.Light: .shadowCameraBottom is now .shadow.camera.bottom."),this.shadow.camera.bottom=n}},shadowCameraNear:{set:function(n){console.warn("THREE.Light: .shadowCameraNear is now .shadow.camera.near."),this.shadow.camera.near=n}},shadowCameraFar:{set:function(n){console.warn("THREE.Light: .shadowCameraFar is now .shadow.camera.far."),this.shadow.camera.far=n}},shadowCameraVisible:{set:function(){console.warn("THREE.Light: .shadowCameraVisible has been removed. Use new THREE.CameraHelper( light.shadow.camera ) instead.")}},shadowBias:{set:function(n){console.warn("THREE.Light: .shadowBias is now .shadow.bias."),this.shadow.bias=n}},shadowDarkness:{set:function(){console.warn("THREE.Light: .shadowDarkness has been removed.")}},shadowMapWidth:{set:function(n){console.warn("THREE.Light: .shadowMapWidth is now .shadow.mapSize.width."),this.shadow.mapSize.width=n}},shadowMapHeight:{set:function(n){console.warn("THREE.Light: .shadowMapHeight is now .shadow.mapSize.height."),this.shadow.mapSize.height=n}}}),Object.defineProperties(Ar.prototype,{length:{get:function(){return console.warn("THREE.BufferAttribute: .length has been deprecated. Use .count instead."),this.array.length}},dynamic:{get:function(){return console.warn("THREE.BufferAttribute: .dynamic has been deprecated. Use .usage instead."),this.usage===EI},set:function(){console.warn("THREE.BufferAttribute: .dynamic has been deprecated. Use .usage instead."),this.setUsage(EI)}}}),Ar.prototype.setDynamic=function(n){return console.warn("THREE.BufferAttribute: .setDynamic() has been deprecated. Use .setUsage() instead."),this.setUsage(!0===n?EI:Tx),this},Ar.prototype.copyIndicesArray=function(){console.error("THREE.BufferAttribute: .copyIndicesArray() has been removed.")},Ar.prototype.setArray=function(){console.error("THREE.BufferAttribute: .setArray has been removed. Use BufferGeometry .setAttribute to replace/resize attribute buffers")},Wi.prototype.addIndex=function(n){console.warn("THREE.BufferGeometry: .addIndex() has been renamed to .setIndex()."),this.setIndex(n)},Wi.prototype.addAttribute=function(n,t){return console.warn("THREE.BufferGeometry: .addAttribute() has been renamed to .setAttribute()."),t&&t.isBufferAttribute||t&&t.isInterleavedBufferAttribute?"index"===n?(console.warn("THREE.BufferGeometry.addAttribute: Use .setIndex() for index attribute."),this.setIndex(t),this):this.setAttribute(n,t):(console.warn("THREE.BufferGeometry: .addAttribute() now expects ( name, attribute )."),this.setAttribute(n,new Ar(arguments[1],arguments[2])))},Wi.prototype.addDrawCall=function(n,t,e){void 0!==e&&console.warn("THREE.BufferGeometry: .addDrawCall() no longer supports indexOffset."),console.warn("THREE.BufferGeometry: .addDrawCall() is now .addGroup()."),this.addGroup(n,t)},Wi.prototype.clearDrawCalls=function(){console.warn("THREE.BufferGeometry: .clearDrawCalls() is now .clearGroups()."),this.clearGroups()},Wi.prototype.computeOffsets=function(){console.warn("THREE.BufferGeometry: .computeOffsets() has been removed.")},Wi.prototype.removeAttribute=function(n){return console.warn("THREE.BufferGeometry: .removeAttribute() has been renamed to .deleteAttribute()."),this.deleteAttribute(n)},Wi.prototype.applyMatrix=function(n){return console.warn("THREE.BufferGeometry: .applyMatrix() has been renamed to .applyMatrix4()."),this.applyMatrix4(n)},Object.defineProperties(Wi.prototype,{drawcalls:{get:function(){return console.error("THREE.BufferGeometry: .drawcalls has been renamed to .groups."),this.groups}},offsets:{get:function(){return console.warn("THREE.BufferGeometry: .offsets has been renamed to .groups."),this.groups}}}),Dm.prototype.setDynamic=function(n){return console.warn("THREE.InterleavedBuffer: .setDynamic() has been deprecated. Use .setUsage() instead."),this.setUsage(!0===n?EI:Tx),this},Dm.prototype.setArray=function(){console.error("THREE.InterleavedBuffer: .setArray has been removed. Use BufferGeometry .setAttribute to replace/resize attribute buffers")},Dp.prototype.getArrays=function(){console.error("THREE.ExtrudeGeometry: .getArrays() has been removed.")},Dp.prototype.addShapeList=function(){console.error("THREE.ExtrudeGeometry: .addShapeList() has been removed.")},Dp.prototype.addShape=function(){console.error("THREE.ExtrudeGeometry: .addShape() has been removed.")},u_.prototype.dispose=function(){console.error("THREE.Scene: .dispose() has been removed.")},Qx.prototype.onUpdate=function(){return console.warn("THREE.Uniform: .onUpdate() has been removed. Use object.onBeforeRender() instead."),this},Object.defineProperties(Ro.prototype,{wrapAround:{get:function(){console.warn("THREE.Material: .wrapAround has been removed.")},set:function(){console.warn("THREE.Material: .wrapAround has been removed.")}},overdraw:{get:function(){console.warn("THREE.Material: .overdraw has been removed.")},set:function(){console.warn("THREE.Material: .overdraw has been removed.")}},wrapRGB:{get:function(){return console.warn("THREE.Material: .wrapRGB has been removed."),new an}},shading:{get:function(){console.error("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead.")},set:function(n){console.warn("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead."),this.flatShading=1===n}},stencilMask:{get:function(){return console.warn("THREE."+this.type+": .stencilMask has been removed. Use .stencilFuncMask instead."),this.stencilFuncMask},set:function(n){console.warn("THREE."+this.type+": .stencilMask has been removed. Use .stencilFuncMask instead."),this.stencilFuncMask=n}},vertexTangents:{get:function(){console.warn("THREE."+this.type+": .vertexTangents has been removed.")},set:function(){console.warn("THREE."+this.type+": .vertexTangents has been removed.")}}}),Object.defineProperties(Gd.prototype,{derivatives:{get:function(){return console.warn("THREE.ShaderMaterial: .derivatives has been moved to .extensions.derivatives."),this.extensions.derivatives},set:function(n){console.warn("THREE. ShaderMaterial: .derivatives has been moved to .extensions.derivatives."),this.extensions.derivatives=n}}}),qi.prototype.clearTarget=function(n,t,e,i){console.warn("THREE.WebGLRenderer: .clearTarget() has been deprecated. Use .setRenderTarget() and .clear() instead."),this.setRenderTarget(n),this.clear(t,e,i)},qi.prototype.animate=function(n){console.warn("THREE.WebGLRenderer: .animate() is now .setAnimationLoop()."),this.setAnimationLoop(n)},qi.prototype.getCurrentRenderTarget=function(){return console.warn("THREE.WebGLRenderer: .getCurrentRenderTarget() is now .getRenderTarget()."),this.getRenderTarget()},qi.prototype.getMaxAnisotropy=function(){return console.warn("THREE.WebGLRenderer: .getMaxAnisotropy() is now .capabilities.getMaxAnisotropy()."),this.capabilities.getMaxAnisotropy()},qi.prototype.getPrecision=function(){return console.warn("THREE.WebGLRenderer: .getPrecision() is now .capabilities.precision."),this.capabilities.precision},qi.prototype.resetGLState=function(){return console.warn("THREE.WebGLRenderer: .resetGLState() is now .state.reset()."),this.state.reset()},qi.prototype.supportsFloatTextures=function(){return console.warn("THREE.WebGLRenderer: .supportsFloatTextures() is now .extensions.get( 'OES_texture_float' )."),this.extensions.get("OES_texture_float")},qi.prototype.supportsHalfFloatTextures=function(){return console.warn("THREE.WebGLRenderer: .supportsHalfFloatTextures() is now .extensions.get( 'OES_texture_half_float' )."),this.extensions.get("OES_texture_half_float")},qi.prototype.supportsStandardDerivatives=function(){return console.warn("THREE.WebGLRenderer: .supportsStandardDerivatives() is now .extensions.get( 'OES_standard_derivatives' )."),this.extensions.get("OES_standard_derivatives")},qi.prototype.supportsCompressedTextureS3TC=function(){return console.warn("THREE.WebGLRenderer: .supportsCompressedTextureS3TC() is now .extensions.get( 'WEBGL_compressed_texture_s3tc' )."),this.extensions.get("WEBGL_compressed_texture_s3tc")},qi.prototype.supportsCompressedTexturePVRTC=function(){return console.warn("THREE.WebGLRenderer: .supportsCompressedTexturePVRTC() is now .extensions.get( 'WEBGL_compressed_texture_pvrtc' )."),this.extensions.get("WEBGL_compressed_texture_pvrtc")},qi.prototype.supportsBlendMinMax=function(){return console.warn("THREE.WebGLRenderer: .supportsBlendMinMax() is now .extensions.get( 'EXT_blend_minmax' )."),this.extensions.get("EXT_blend_minmax")},qi.prototype.supportsVertexTextures=function(){return console.warn("THREE.WebGLRenderer: .supportsVertexTextures() is now .capabilities.vertexTextures."),this.capabilities.vertexTextures},qi.prototype.supportsInstancedArrays=function(){return console.warn("THREE.WebGLRenderer: .supportsInstancedArrays() is now .extensions.get( 'ANGLE_instanced_arrays' )."),this.extensions.get("ANGLE_instanced_arrays")},qi.prototype.enableScissorTest=function(n){console.warn("THREE.WebGLRenderer: .enableScissorTest() is now .setScissorTest()."),this.setScissorTest(n)},qi.prototype.initMaterial=function(){console.warn("THREE.WebGLRenderer: .initMaterial() has been removed.")},qi.prototype.addPrePlugin=function(){console.warn("THREE.WebGLRenderer: .addPrePlugin() has been removed.")},qi.prototype.addPostPlugin=function(){console.warn("THREE.WebGLRenderer: .addPostPlugin() has been removed.")},qi.prototype.updateShadowMap=function(){console.warn("THREE.WebGLRenderer: .updateShadowMap() has been removed.")},qi.prototype.setFaceCulling=function(){console.warn("THREE.WebGLRenderer: .setFaceCulling() has been removed.")},qi.prototype.allocTextureUnit=function(){console.warn("THREE.WebGLRenderer: .allocTextureUnit() has been removed.")},qi.prototype.setTexture=function(){console.warn("THREE.WebGLRenderer: .setTexture() has been removed.")},qi.prototype.setTexture2D=function(){console.warn("THREE.WebGLRenderer: .setTexture2D() has been removed.")},qi.prototype.setTextureCube=function(){console.warn("THREE.WebGLRenderer: .setTextureCube() has been removed.")},qi.prototype.getActiveMipMapLevel=function(){return console.warn("THREE.WebGLRenderer: .getActiveMipMapLevel() is now .getActiveMipmapLevel()."),this.getActiveMipmapLevel()},Object.defineProperties(qi.prototype,{shadowMapEnabled:{get:function(){return this.shadowMap.enabled},set:function(n){console.warn("THREE.WebGLRenderer: .shadowMapEnabled is now .shadowMap.enabled."),this.shadowMap.enabled=n}},shadowMapType:{get:function(){return this.shadowMap.type},set:function(n){console.warn("THREE.WebGLRenderer: .shadowMapType is now .shadowMap.type."),this.shadowMap.type=n}},shadowMapCullFace:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMapCullFace has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMapCullFace has been removed. Set Material.shadowSide instead.")}},context:{get:function(){return console.warn("THREE.WebGLRenderer: .context has been removed. Use .getContext() instead."),this.getContext()}},vr:{get:function(){return console.warn("THREE.WebGLRenderer: .vr has been renamed to .xr"),this.xr}},gammaInput:{get:function(){return console.warn("THREE.WebGLRenderer: .gammaInput has been removed. Set the encoding for textures via Texture.encoding instead."),!1},set:function(){console.warn("THREE.WebGLRenderer: .gammaInput has been removed. Set the encoding for textures via Texture.encoding instead.")}},gammaOutput:{get:function(){return console.warn("THREE.WebGLRenderer: .gammaOutput has been removed. Set WebGLRenderer.outputEncoding instead."),!1},set:function(n){console.warn("THREE.WebGLRenderer: .gammaOutput has been removed. Set WebGLRenderer.outputEncoding instead."),this.outputEncoding=!0===n?Dr:Mp}},toneMappingWhitePoint:{get:function(){return console.warn("THREE.WebGLRenderer: .toneMappingWhitePoint has been removed."),1},set:function(){console.warn("THREE.WebGLRenderer: .toneMappingWhitePoint has been removed.")}},gammaFactor:{get:function(){return console.warn("THREE.WebGLRenderer: .gammaFactor has been removed."),2},set:function(){console.warn("THREE.WebGLRenderer: .gammaFactor has been removed.")}}}),Object.defineProperties(Ste.prototype,{cullFace:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMap.cullFace has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMap.cullFace has been removed. Set Material.shadowSide instead.")}},renderReverseSided:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderReverseSided has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderReverseSided has been removed. Set Material.shadowSide instead.")}},renderSingleSided:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderSingleSided has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderSingleSided has been removed. Set Material.shadowSide instead.")}}}),Object.defineProperties(Qa.prototype,{wrapS:{get:function(){return console.warn("THREE.WebGLRenderTarget: .wrapS is now .texture.wrapS."),this.texture.wrapS},set:function(n){console.warn("THREE.WebGLRenderTarget: .wrapS is now .texture.wrapS."),this.texture.wrapS=n}},wrapT:{get:function(){return console.warn("THREE.WebGLRenderTarget: .wrapT is now .texture.wrapT."),this.texture.wrapT},set:function(n){console.warn("THREE.WebGLRenderTarget: .wrapT is now .texture.wrapT."),this.texture.wrapT=n}},magFilter:{get:function(){return console.warn("THREE.WebGLRenderTarget: .magFilter is now .texture.magFilter."),this.texture.magFilter},set:function(n){console.warn("THREE.WebGLRenderTarget: .magFilter is now .texture.magFilter."),this.texture.magFilter=n}},minFilter:{get:function(){return console.warn("THREE.WebGLRenderTarget: .minFilter is now .texture.minFilter."),this.texture.minFilter},set:function(n){console.warn("THREE.WebGLRenderTarget: .minFilter is now .texture.minFilter."),this.texture.minFilter=n}},anisotropy:{get:function(){return console.warn("THREE.WebGLRenderTarget: .anisotropy is now .texture.anisotropy."),this.texture.anisotropy},set:function(n){console.warn("THREE.WebGLRenderTarget: .anisotropy is now .texture.anisotropy."),this.texture.anisotropy=n}},offset:{get:function(){return console.warn("THREE.WebGLRenderTarget: .offset is now .texture.offset."),this.texture.offset},set:function(n){console.warn("THREE.WebGLRenderTarget: .offset is now .texture.offset."),this.texture.offset=n}},repeat:{get:function(){return console.warn("THREE.WebGLRenderTarget: .repeat is now .texture.repeat."),this.texture.repeat},set:function(n){console.warn("THREE.WebGLRenderTarget: .repeat is now .texture.repeat."),this.texture.repeat=n}},format:{get:function(){return console.warn("THREE.WebGLRenderTarget: .format is now .texture.format."),this.texture.format},set:function(n){console.warn("THREE.WebGLRenderTarget: .format is now .texture.format."),this.texture.format=n}},type:{get:function(){return console.warn("THREE.WebGLRenderTarget: .type is now .texture.type."),this.texture.type},set:function(n){console.warn("THREE.WebGLRenderTarget: .type is now .texture.type."),this.texture.type=n}},generateMipmaps:{get:function(){return console.warn("THREE.WebGLRenderTarget: .generateMipmaps is now .texture.generateMipmaps."),this.texture.generateMipmaps},set:function(n){console.warn("THREE.WebGLRenderTarget: .generateMipmaps is now .texture.generateMipmaps."),this.texture.generateMipmaps=n}}}),class extends zi{constructor(t){super(),this.type="Audio",this.listener=t,this.context=t.context,this.gain=this.context.createGain(),this.gain.connect(t.getInput()),this.autoplay=!1,this.buffer=null,this.detune=0,this.loop=!1,this.loopStart=0,this.loopEnd=0,this.offset=0,this.duration=void 0,this.playbackRate=1,this.isPlaying=!1,this.hasPlaybackControl=!0,this.source=null,this.sourceType="empty",this._startedAt=0,this._progress=0,this._connected=!1,this.filters=[]}getOutput(){return this.gain}setNodeSource(t){return this.hasPlaybackControl=!1,this.sourceType="audioNode",this.source=t,this.connect(),this}setMediaElementSource(t){return this.hasPlaybackControl=!1,this.sourceType="mediaNode",this.source=this.context.createMediaElementSource(t),this.connect(),this}setMediaStreamSource(t){return this.hasPlaybackControl=!1,this.sourceType="mediaStreamNode",this.source=this.context.createMediaStreamSource(t),this.connect(),this}setBuffer(t){return this.buffer=t,this.sourceType="buffer",this.autoplay&&this.play(),this}play(t=0){if(!0===this.isPlaying)return void console.warn("THREE.Audio: Audio is already playing.");if(!1===this.hasPlaybackControl)return void console.warn("THREE.Audio: this Audio has no playback control.");this._startedAt=this.context.currentTime+t;let e=this.context.createBufferSource();return e.buffer=this.buffer,e.loop=this.loop,e.loopStart=this.loopStart,e.loopEnd=this.loopEnd,e.onended=this.onEnded.bind(this),e.start(this._startedAt,this._progress+this.offset,this.duration),this.isPlaying=!0,this.source=e,this.setDetune(this.detune),this.setPlaybackRate(this.playbackRate),this.connect()}pause(){if(!1!==this.hasPlaybackControl)return!0===this.isPlaying&&(this._progress+=Math.max(this.context.currentTime-this._startedAt,0)*this.playbackRate,!0===this.loop&&(this._progress=this._progress%(this.duration||this.buffer.duration)),this.source.stop(),this.source.onended=null,this.isPlaying=!1),this;console.warn("THREE.Audio: this Audio has no playback control.")}stop(){if(!1!==this.hasPlaybackControl)return this._progress=0,this.source.stop(),this.source.onended=null,this.isPlaying=!1,this;console.warn("THREE.Audio: this Audio has no playback control.")}connect(){if(this.filters.length>0){this.source.connect(this.filters[0]);for(let t=1,e=this.filters.length;t<e;t++)this.filters[t-1].connect(this.filters[t]);this.filters[this.filters.length-1].connect(this.getOutput())}else this.source.connect(this.getOutput());return this._connected=!0,this}disconnect(){if(this.filters.length>0){this.source.disconnect(this.filters[0]);for(let t=1,e=this.filters.length;t<e;t++)this.filters[t-1].disconnect(this.filters[t]);this.filters[this.filters.length-1].disconnect(this.getOutput())}else this.source.disconnect(this.getOutput());return this._connected=!1,this}getFilters(){return this.filters}setFilters(t){return t||(t=[]),!0===this._connected?(this.disconnect(),this.filters=t.slice(),this.connect()):this.filters=t.slice(),this}setDetune(t){if(this.detune=t,void 0!==this.source.detune)return!0===this.isPlaying&&this.source.detune.setTargetAtTime(this.detune,this.context.currentTime,.01),this}getDetune(){return this.detune}getFilter(){return this.getFilters()[0]}setFilter(t){return this.setFilters(t?[t]:[])}setPlaybackRate(t){if(!1!==this.hasPlaybackControl)return this.playbackRate=t,!0===this.isPlaying&&this.source.playbackRate.setTargetAtTime(this.playbackRate,this.context.currentTime,.01),this;console.warn("THREE.Audio: this Audio has no playback control.")}getPlaybackRate(){return this.playbackRate}onEnded(){this.isPlaying=!1}getLoop(){return!1===this.hasPlaybackControl?(console.warn("THREE.Audio: this Audio has no playback control."),!1):this.loop}setLoop(t){if(!1!==this.hasPlaybackControl)return this.loop=t,!0===this.isPlaying&&(this.source.loop=this.loop),this;console.warn("THREE.Audio: this Audio has no playback control.")}setLoopStart(t){return this.loopStart=t,this}setLoopEnd(t){return this.loopEnd=t,this}getVolume(){return this.gain.gain.value}setVolume(t){return this.gain.gain.setTargetAtTime(t,this.context.currentTime,.01),this}}.prototype.load=function(n){console.warn("THREE.Audio: .load has been deprecated. Use THREE.AudioLoader instead.");let t=this;return(new bV).load(n,function(i){t.setBuffer(i)}),this},Rx.prototype.updateCubeMap=function(n,t){return console.warn("THREE.CubeCamera: .updateCubeMap() is now .update()."),this.update(n,t)},Rx.prototype.clear=function(n,t,e,i){return console.warn("THREE.CubeCamera: .clear() is now .renderTarget.clear()."),this.renderTarget.clear(n,t,e,i)},jd.crossOrigin=void 0,jd.loadTexture=function(n,t,e,i){console.warn("THREE.ImageUtils.loadTexture has been deprecated. Use THREE.TextureLoader() instead.");let r=new cV;r.setCrossOrigin(this.crossOrigin);let o=r.load(n,e,void 0,i);return t&&(o.mapping=t),o},jd.loadTextureCube=function(n,t,e,i){console.warn("THREE.ImageUtils.loadTextureCube has been deprecated. Use THREE.CubeTextureLoader() instead.");let r=new lV;r.setCrossOrigin(this.crossOrigin);let o=r.load(n,e,void 0,i);return t&&(o.mapping=t),o},jd.loadCompressedTexture=function(){console.error("THREE.ImageUtils.loadCompressedTexture has been removed. Use THREE.DDSLoader instead.")},jd.loadCompressedTextureCube=function(){console.error("THREE.ImageUtils.loadCompressedTextureCube has been removed. Use THREE.DDSLoader instead.")},typeof __THREE_DEVTOOLS__<"u"&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("register",{detail:{revision:OV}})),typeof window<"u"&&(window.__THREE__?console.warn("WARNING: Multiple instances of Three.js being imported."):window.__THREE__=OV);var Zl=(()=>(function(n){n[n.CIRCLE=0]="CIRCLE",n[n.LINE=1]="LINE",n[n.TRIANGLE=2]="TRIANGLE",n[n.TRAPEZOID=3]="TRAPEZOID"}(Zl||(Zl={})),Zl))();function Pte(n,t){let e=t.length/2,i=n.attributes.position;(!i||i.count!==3*e)&&(i=new Ar(new Float32Array(3*e),3),n.setAttribute("position",i));let r=i.array;for(let o=0;o<e;o++)r[3*o]=t[2*o],r[3*o+1]=t[2*o+1];i.needsUpdate=!0,n.setDrawRange(0,3*e),n.computeBoundingSphere()}function Ote(n,t,e){let i=Math.max(t.length/2-1,0),r=2*i*3,o=3*r,a=n.attributes.position;(!a||a.count!==r)&&(a=new Ar(new Float32Array(o),3),n.setAttribute("position",a));let s=a.array;for(let l=0;l<i;l++){let[c,d,u,p]=[t[2*l],t[2*l+1],t[2*l+2],t[2*l+3]],f=new $e(c,d),m=new $e(u,p),y=new $e(u-c,p-d),M=new $e(-y.y,y.x).setLength(e/2),v=f.clone().add(M),x=f.clone().sub(M),R=m.clone().add(M),A=m.clone().sub(M),H=[v.x,v.y,0,x.x,x.y,0,R.x,R.y,0,R.x,R.y,0,x.x,x.y,0,A.x,A.y,0];s.set(H,l*H.length)}a.needsUpdate=!0,n.setDrawRange(0,o),n.computeBoundingSphere()}function iA(n,t,e,i){let{visible:r,color:o,opacity:a}=i;if(Array.isArray(t.material))throw new Error("Invariant error: only expect one material on an object");let s=t.material;if(s.visible!==r&&(s.visible=r,s.needsUpdate=!0),!r)return!1;let l=zV(n,o,a??1),c=e(t.geometry);return t.geometry!==c&&(t.geometry=c),s.color.equals(l)||(s.color.set(l),s.needsUpdate=!0),!0}var oA=class{constructor(t){this.rawSeriesData=[],this.series=[],this.paintDirty=!0,this.renderCache=new class{constructor(){this.prevFrameCache=new Map,this.currFrameCache=new Map}getFromPreviousFrame(t){return this.prevFrameCache.get(t)??null}setToCurrentFrame(t,e){this.currFrameCache.set(t,e)}finalizeFrameAndGetRemoved(){let t=[];for(let[e,i]of this.prevFrameCache.entries())this.currFrameCache.has(e)||t.push(i);return this.prevFrameCache=this.currFrameCache,this.currFrameCache=new Map,t}},this.coordinateIdentifier=null,this.layout={x:0,width:1,y:0,height:1},this.getMetadataMapImpl=t.getMetadataMap,this.coordinator=t.coordinator,this.renderer=t.renderer,this.paintBrush=new class{constructor(t,e){this.renderCache=t,this.renderer=e}setLine(t,e,i){let r=this.renderer.createOrUpdateLineObject(this.renderCache.getFromPreviousFrame(t),e,i);r&&this.renderCache.setToCurrentFrame(t,r)}setTriangle(t,e,i){let r=this.renderer.createOrUpdateTriangleObject(this.renderCache.getFromPreviousFrame(t),e,i);r&&this.renderCache.setToCurrentFrame(t,r)}setCircle(t,e,i){let r=this.renderer.createOrUpdateCircleObject(this.renderCache.getFromPreviousFrame(t),e,i);r&&this.renderCache.setToCurrentFrame(t,r)}setTrapezoid(t,e,i,r){let o=this.renderer.createOrUpdateTrapezoidObject(this.renderCache.getFromPreviousFrame(t),e,i,r);o&&this.renderCache.setToCurrentFrame(t,o)}}(this.renderCache,this.renderer)}setLayoutRect(t){(this.layout.x!==t.x||this.layout.width!==t.width||this.layout.y!==t.y||this.layout.height!==t.height)&&(this.paintDirty=!0),this.layout=t}getLayoutRect(){return this.layout}getMetadataMap(){return this.getMetadataMapImpl()}markAsPaintDirty(){this.paintDirty=!0}render(){if(this.transformCoordinatesIfStale(),this.paintDirty){this.redraw();for(let t of this.renderCache.finalizeFrameAndGetRemoved())this.renderer.destroyObject(t);this.paintDirty=!1}}isCoordinateUpdated(){return this.coordinator.getUpdateIdentifier()!==this.coordinateIdentifier}clearCoordinateIdentifier(){this.coordinateIdentifier=null}setData(t){this.clearCoordinateIdentifier(),this.rawSeriesData=t}transformCoordinatesIfStale(){if(!this.isCoordinateUpdated())return;let t=this.getLayoutRect();this.series=new Array(this.rawSeriesData.length);for(let e=0;e<this.rawSeriesData.length;e++){let i=this.rawSeriesData[e];this.series[e]={id:i.id,polyline:new Float32Array(2*i.points.length)};for(let r=0;r<i.points.length;r++){let[o,a]=this.coordinator.transformDataToUiCoord(t,[i.points[r].x,i.points[r].y]);this.series[e].polyline[2*r]=o,this.series[e].polyline[2*r+1]=a}}this.coordinateIdentifier=this.coordinator.getUpdateIdentifier(),this.markAsPaintDirty()}},v_=(()=>(function(n){n[n.NUMBER=0]="NUMBER",n[n.NAN=1]="NAN"}(v_||(v_={})),v_))(),aA=class extends oA{recordPartition(t,e,i){return t?{type:v_.NUMBER,polyline:e}:{type:v_.NAN,polyline:e.map((r,o)=>isNaN(r)?o%2==0?i.x:i.y:r)}}partitionPolyline(t){let e=[],i=0,r=!1,o=this.coordinator.transformDataToUiCoord(this.getLayoutRect(),[0,0]),a={x:o[0],y:o[1]},s=null;for(let l=0;l<t.length;l+=2){let c=t[l],d=t[l+1],u=isNaN(c)||isNaN(d);u!==r&&i!==l&&(e.push(this.recordPartition(!r,t.slice(i,l),null===s?{x:c,y:d}:s)),i=l),u||(s={x:c,y:d}),r=u}return i!==t.length-1&&e.push(this.recordPartition(!r,t.slice(i,t.length),s??a)),e}redraw(){for(let t of this.series){let i=this.getMetadataMap()[t.id];if(!i)continue;if(t.polyline.length%2!=0)throw new Error(`Cannot have odd length-ed polyline: ${t.polyline.length}`);let r=this.partitionPolyline(t.polyline);for(let[o,{type:a,polyline:s}]of r.entries())if(a===v_.NUMBER)2===s.length?this.paintBrush.setCircle(JSON.stringify(["circle",t.id,o]),{x:s[0],y:s[1]},{color:i.color,visible:i.visible,opacity:i.opacity??1,radius:4}):this.paintBrush.setLine(JSON.stringify(["line",t.id,o]),s,{color:i.color,visible:i.visible,opacity:i.opacity??1,width:2});else if(!i.aux)for(let l=0;l<s.length;l+=2)this.paintBrush.setTriangle(JSON.stringify(["NaN",t.id,s[l],s[l+1]]),{x:s[l],y:s[l+1]},{color:i.color,visible:i.visible,opacity:i.opacity??1,size:12})}}},sA=class extends R0{constructor(){super(...arguments),this.camera=new Tm(0,1e3,1e3,0,0,100)}isYAxisPointedDown(){return!1}setDomContainerRect(t){super.setDomContainerRect(t),this.camera.left=t.x,this.camera.right=t.x+t.width,this.camera.top=t.y+t.height,this.camera.bottom=t.y,this.camera.updateProjectionMatrix()}getCamera(){return this.camera}},lA=class{constructor(t){switch(this.metadataMap={},this.shouldRepaint=!1,this.callbacks=t.callbacks,t.type){case Zi.SVG:this.coordinator=new R0,this.renderer=new class{constructor(t){this.svg=t}flush(){}onResize(t){}destroyObject(t){this.svg.removeChild(t.dom)}setUseDarkMode(t){}createPathDString(t){if(!t.length)return"";let e=new Array(t.length/2);e[0]=`M${t[0]},${t[1]}`;for(let i=1;i<t.length/2;i++)e[i]=`L${t[2*i]},${t[2*i+1]}`;return e.join("")}createOrUpdateLineObject(t,e,i){let r=UD(t?.dom,()=>{let o=document.createElementNS("http://www.w3.org/2000/svg","path");o.style.fill="none";let a=this.createPathDString(e);return o.setAttribute("d",a),this.svg.appendChild(o),o},o=>{if(!t?.data||!Gl_arePolylinesEqual(e,t?.data)){let a=this.createPathDString(e);o.setAttribute("d",a)}return o},i);return null===r?null:(r.style.strokeWidth=String(i.width),{dom:r,data:e})}createOrUpdateTriangleObject(t,e,i){let{size:r,color:o}=i,a=r*Math.sqrt(3)/2,s=new Float32Array([e.x-r/2,e.y+a/3,e.x+r/2,e.y+a/3,e.x,e.y-2*a/3]),l=UD(t?.dom,()=>{let c=document.createElementNS("http://www.w3.org/2000/svg","path");c.classList.add("triangle"),c.style.fill="none";let d=this.createPathDString(s);return c.setAttribute("d",d+"Z"),this.svg.appendChild(c),c},c=>{let d=this.createPathDString(s);return c.setAttribute("d",d+"Z"),c},i);return null===l?null:(l.style.fill=o,{dom:l,data:s})}createOrUpdateCircleObject(t,e,i){let{color:r,radius:o}=i,a=UD(t?.dom,()=>{let s=document.createElementNS("http://www.w3.org/2000/svg","circle");return s.style.fill=r,s.setAttribute("cx",String(e.x)),s.setAttribute("cy",String(e.y)),s.setAttribute("r",String(o)),this.svg.appendChild(s),s},s=>(s.style.fill=r,s.setAttribute("cx",String(e.x)),s.setAttribute("cy",String(e.y)),s.setAttribute("r",String(o)),s),i);return null===a?null:{dom:a,data:e}}createOrUpdateTrapezoidObject(t,e,i,r){if(e.y!==i.y)throw new RangeError("Input error: start.y != end.y.");let{altitude:o,color:a}=r,s=2/Math.sqrt(3)*o,l=new Float32Array([e.x-s/2,e.y+o/2,e.x,e.y-o/2,i.x,i.y-o/2,i.x+s/2,i.y+o/2]),c=UD(t?.dom,()=>{let d=document.createElementNS("http://www.w3.org/2000/svg","path");d.classList.add("trapezoid"),d.style.fill="none";let u=this.createPathDString(l);return d.setAttribute("d",u+"Z"),this.svg.appendChild(d),d},d=>{let u=this.createPathDString(l);return d.setAttribute("d",u+"Z"),d},r);return null===c?null:(c.style.fill=a,{dom:c,data:l})}dispose(){}}(t.container);break;case Zi.WEBGL:{let e=new sA;this.coordinator=e,this.renderer=new class{constructor(t,e,i,r){this.coordinator=e,this.scene=new u_,this.backgroundColor="#fff",Gl_isWebGl2OffscreenCanvasSupported()&&t instanceof OffscreenCanvas&&(t.style=t.style||{}),r&&t.addEventListener("webglcontextlost",r),this.renderer=new qi({canvas:t,antialias:!0,alpha:!0}),this.renderer.setPixelRatio(i)}onResize(t){this.renderer.setSize(t.width,t.height)}destroyObject(t){let e=t.obj3d;if(this.scene.remove(e),e instanceof co){e.geometry.dispose();let i=Array.isArray(e.material)?e.material:[e.material];for(let r of i)r.dispose()}}setUseDarkMode(t){this.backgroundColor=t?"#303030":"#fff"}createOrUpdateLineObject(t,e,i){if(!t&&!i.visible)return null;let{visible:r,width:o}=i;if(!t){let d=zV(this.backgroundColor,i.color,i.opacity??1),u=new Wi,p=new Wd({color:d}),f=new co(u,p);return p.visible=r,Ote(u,e,o),this.scene.add(f),{type:Zl.LINE,data:e,obj3d:f,width:o}}let{data:a,obj3d:s,width:l}=t;return iA(this.backgroundColor,s,d=>((o!==l||!a||!Gl_arePolylinesEqual(a,e))&&Ote(d,e,o),d),i)?{type:Zl.LINE,data:e,obj3d:s,width:o}:t}createMesh(t,e){if(!e.visible)return null;let{visible:i,color:r,opacity:o}=e,a=zV(this.backgroundColor,r,o??1),s=new Sm({color:a,visible:i});return new co(t,s)}createOrUpdateTriangleObject(t,e,i){let{size:r}=i,o=r*Math.sqrt(3)/2,a=new Float32Array([e.x-r/2,e.y-o/3,e.x+r/2,e.y-o/3,e.x,e.y+2*o/3]);if(!t){let l=new Wi;Pte(l,a);let c=this.createMesh(l,i);return null===c?null:(this.scene.add(c),{type:Zl.TRIANGLE,data:e,obj3d:c})}return iA(this.backgroundColor,t.obj3d,l=>(Pte(l,a),l),i)?{type:Zl.TRIANGLE,data:e,obj3d:t.obj3d}:t}createOrUpdateCircleObject(t,e,i){let{radius:r}=i,o=new p_(i.radius);if(!t){let s=this.createMesh(o,i);return null===s?null:(s.position.set(e.x,e.y,0),this.scene.add(s),{type:Zl.CIRCLE,data:{loc:e,radius:r},obj3d:s})}return iA(this.backgroundColor,t.obj3d,()=>o,i)?(t.obj3d.position.set(e.x,e.y,0),{type:Zl.CIRCLE,data:{loc:e,radius:r},obj3d:t.obj3d}):t}createOrUpdateTrapezoidObject(t,e,i,r){if(e.y!==i.y)throw new RangeError("Input error: start.y != end.y.");let{altitude:o}=r,a=2/Math.sqrt(3)*o,s=new qd([new $e(e.x-a/2,e.y-o/2),new $e(e.x,e.y+o/2),new $e(i.x,i.y+o/2),new $e(i.x+a/2,i.y-o/2)]);s.autoClose=!0;let l=new Am(s);if(!t){let d=this.createMesh(l,r);return null===d?null:(this.scene.add(d),{type:Zl.TRAPEZOID,data:[e,i],obj3d:d})}return iA(this.backgroundColor,t.obj3d,()=>l,r)?{type:Zl.TRAPEZOID,data:[e,i],obj3d:t.obj3d}:t}flush(){this.renderer.render(this.scene,this.coordinator.getCamera())}dispose(){this.renderer.dispose()}}(t.container,e,t.devicePixelRatio,t.callbacks.onContextLost);break}}this.renderer.setUseDarkMode(t.useDarkMode),this.seriesLineView=new aA({renderer:this.renderer,coordinator:this.coordinator,getMetadataMap:()=>this.metadataMap}),this.resize(t.domDimension)}dispose(){}setXScaleType(t){this.coordinator.setXScale(jl(t)),this.scheduleRepaint()}setYScaleType(t){this.coordinator.setYScale(jl(t)),this.scheduleRepaint()}resize(t){this.coordinator.setDomContainerRect({x:0,y:0,...t}),this.renderer.onResize({x:0,y:0,...t}),this.seriesLineView.setLayoutRect({...t,x:0,y:0}),this.scheduleRepaint()}setMetadata(t){let e=!1;Object.entries(t).forEach(([i,r])=>{let o=this.metadataMap[i];(!o||r.color!==o.color||r.visible!==o.visible||r.opacity!==o.opacity)&&(e=!0),this.metadataMap[i]=r}),e&&this.seriesLineView.markAsPaintDirty(),this.scheduleRepaint()}setViewBox(t){this.coordinator.setViewBoxRect({x:t.x[0],width:t.x[1]-t.x[0],y:t.y[0],height:t.y[1]-t.y[0]}),this.scheduleRepaint()}setData(t){this.seriesLineView.setData(t),this.scheduleRepaint()}setUseDarkMode(t){this.renderer.setUseDarkMode(t),this.seriesLineView.markAsPaintDirty(),this.scheduleRepaint()}scheduleRepaint(){this.shouldRepaint||(this.shouldRepaint=!0,(n=>{self.requestAnimationFrame(n)})(()=>{this.repaint(),this.shouldRepaint=!1}))}repaint(){this.seriesLineView.render(),this.renderer.flush(),this.callbacks.onDrawEnd()}},ys=(()=>(function(n){n[n.SERIES_DATA_UPDATED=0]="SERIES_DATA_UPDATED",n[n.SERIES_METADATA_CHANGED=1]="SERIES_METADATA_CHANGED",n[n.SCALE_UPDATED=2]="SCALE_UPDATED",n[n.VIEW_BOX_UPDATED=3]="VIEW_BOX_UPDATED",n[n.INIT=4]="INIT",n[n.DOM_RESIZED=5]="DOM_RESIZED",n[n.DARK_MODE_UPDATED=6]="DARK_MODE_UPDATED",n[n.DISPOSED=7]="DISPOSED"}(ys||(ys={})),ys))(),x_=(()=>(function(n){n[n.ON_REDRAW_END=0]="ON_REDRAW_END",n[n.ON_CONTEXT_LOST=1]="ON_CONTEXT_LOST"}(x_||(x_={})),x_))();function Lte(n){if(n.includes("/"))throw new RangeError("Worker factory only allows file name and no resource path.");return new Worker(n)}var Pm=class{constructor(t){if(this.callbacks=t.callbacks,t.type!==Zi.WEBGL)throw new RangeError(`Cannot use non WEBGL renderer for the offscreen line chart. Received ${Zi[t.type]} `);let e=new MessageChannel;e.port1.onmessage=o=>{this.onMessageFromWorker(o.data)},this.txMessagePort=e.port1;let i=t.container.transferControlToOffscreen();this.workerInstance=Pm.workerPool.getNext();let r={type:ys.INIT,canvas:i,devicePixelRatio:window.devicePixelRatio,dim:t.domDimension,rendererType:t.type,useDarkMode:t.useDarkMode};this.workerInstance.postMessage(r,[i,e.port2])}dispose(){this.sendMessage({type:ys.DISPOSED}),this.workerInstance.free(),this.txMessagePort.close()}setXScaleType(t){this.sendMessage({type:ys.SCALE_UPDATED,axis:"x",scaleType:t})}setYScaleType(t){this.sendMessage({type:ys.SCALE_UPDATED,axis:"y",scaleType:t})}resize(t){this.sendMessage({type:ys.DOM_RESIZED,dim:t})}setMetadata(t){this.sendMessage({type:ys.SERIES_METADATA_CHANGED,metadata:t})}setViewBox(t){this.sendMessage({type:ys.VIEW_BOX_UPDATED,extent:t})}setData(t){let e=function(n){let t=n.reduce((o,a)=>o+a.points.length,0),e=0,i=new Float64Array(2*t),r=[];for(let o of n){r.push({id:o.id,length:o.points.length});for(let a=0;a<o.points.length;a++)i[e++]=o.points[a].x,i[e++]=o.points[a].y}return{idsAndLengths:r,flattenedSeries:i.buffer}}(t);this.sendMessage({type:ys.SERIES_DATA_UPDATED,compactDataSeries:e},[e.flattenedSeries])}setUseDarkMode(t){this.sendMessage({type:ys.DARK_MODE_UPDATED,useDarkMode:t})}sendMessage(t,e){e?this.txMessagePort.postMessage(t,e):this.txMessagePort.postMessage(t)}onMessageFromWorker(t){switch(t.type){case x_.ON_REDRAW_END:this.callbacks.onDrawEnd();break;case x_.ON_CONTEXT_LOST:this.callbacks.onContextLost()}}};function Yc(n,t){return"x"===t?[0,n.width]:[n.height,0]}function $x(n,t){let e=Math.floor(n/50);return Math.min(e,t)}function dA(n,t,e,i){return{major:[],minor:n.ticks(i,e).map(o=>({value:o,tickFormattedString:t.formatTick(o)}))}}Pm.workerPool=new class{constructor(t,e=10,i=Lte){this.workerResourcePath=t,this.maxPoolSize=e,this.workerFactory=i,this.workers=[]}getNext(){let t;if(this.workers.every(({activeCount:i})=>i>0)&&this.workers.length<this.maxPoolSize){let i=this.workerFactory(this.workerResourcePath);t={activeCount:0,postMessage:(r,o)=>{i.postMessage(r,o)},free:()=>{t.activeCount=Math.max(t.activeCount-1,0)}},this.workers.push(t)}else{let i=this.workers.map(({activeCount:o})=>o),r=i.indexOf(Math.min(...i));t=this.workers[r]}return t.activeCount++,t}}("chart_worker.js?_file_hash=2c1e71c5");var jV=document.createElement("canvas").getContext("2d");function Hte(n){for(let t of n)if(String(t).includes("e"))return!0;return!1}var eC={getStandardTicks:dA,getTicksForTemporalScale:function(n,t,e,i){let[r,o]=i,a=n.ticks(i,2);if(o-r>=864e5||a.length>2)return dA(n,t,e,i);let s=n.ticks(i,e);return{major:a.map(l=>({start:l,tickFormattedString:t.formatShort(l)})),minor:s.map(l=>({value:l,tickFormattedString:t.formatTick(l)}))}},getTicksForLinearScale:function(n,t,e,i){let[r,o]=i,a=Math.abs(o-r);if(a>.001)return dA(n,t,e,i);let s=n.ticks([r,o],e),l=n.ticks([r,o],2);if(Hte(s)||Hte(l))return dA(n,t,e,i);let c=[],d=function(n){let t=n.toExponential().split("e-",2);return 2===t.length?Number(t[1])-1:0}(a);a<1&&l.every(f=>{let m=Math.abs(f);return m>=0&&m<1})&&(d+=1);let u=new Map;for(let f of l){let[m,y=""]=String(f).split(".",2),M=Number(m+"."+y.slice(0,d));u.set(M,{start:M,tickFormattedString:0===M?"\u2014":t.formatReadable(M)})}let p=10*Math.pow(10,-d);for(let f of s)for(let m of[...u.keys()].reverse()){let y=f-m;if(y>=0&&y<p){if(0===m)c.push({value:f,tickFormattedString:t.formatTick(f)});else{let M=String(f).slice(String(m).length);c.push({value:f,tickFormattedString:`\u2026${M||"0"}`})}break}}return{major:Array.from(u.values()),minor:c}},filterTicksByVisibility:function(n,t,e,i,r=5){if(!n.length||!jV)return n;let o="x"===e?1:-1,a=null;return n.filter(s=>{let l=t(s);jV.font=i;let c=jV.measureText(s.tickFormattedString),d="x"===e?c.width:c.actualBoundingBoxAscent-c.actualBoundingBoxDescent;return null===a?!(l+o*d<0||(a=l+o*d,0)):!(o*(a+o*r-l)>0||(a=l+o*d,0))})}};function S2e(n,t){if(1&n&&(Tn(),h(0,"g",17)(1,"text"),T(2),g(),h(3,"title"),T(4),g()()),2&n){let e=t.$implicit,i=w();b(1),Mt("font",i.axisFont),Pe("x",i.textXPosition(e.value))("y",i.textYPosition(e.value)),b(1),ze(" ",e.tickFormattedString," "),b(2),ut(i.getFormatter().formatLong(e.value))}}function E2e(n,t){if(1&n&&(h(0,"span",20)(1,"span"),T(2),g()()),2&n){let e=t.$implicit,i=t.index,r=t.last,o=w(2);Mt("left",o.getMajorXPosition(e),"px")("width",o.getMajorWidthString(e,r,o.majorTicks[i+1]))("bottom",o.getMajorYPosition(e),"px")("height",o.getMajorHeightString(e,r,o.majorTicks[i+1]))("font",o.axisFont),Qe("major-label",!0)("last",r),_("title",o.getFormatter().formatLong(e.start)),b(2),ut(e.tickFormattedString)}}function T2e(n,t){if(1&n&&(h(0,"div",18),S(1,E2e,3,16,"span",19),g()),2&n){let e=w();b(1),_("ngForOf",e.majorTicks)("ngForTrackBy",e.trackByMajorTick)}}var zte=(()=>{class n{constructor(){this.onViewExtentChange=new L,this.editMenuOpened=!1,this.majorTicks=[],this.minorTicks=[]}ngOnChanges(){let e=null,r=$x("x"===this.axis?this.domDim.width:this.domDim.height,this.gridCount);e=this.scale instanceof sx?eC.getTicksForLinearScale(this.scale,this.getFormatter(),r,this.axisExtent):this.scale instanceof lx?eC.getTicksForTemporalScale(this.scale,this.getFormatter(),r,this.axisExtent):eC.getStandardTicks(this.scale,this.getFormatter(),r,this.axisExtent),this.majorTicks=e.major,this.minorTicks=eC.filterTicksByVisibility(e.minor,o=>this.getDomPos(o.value),this.axis,"11px Roboto, sans-serif")}getFormatter(){return this.customFormatter??this.scale.defaultFormatter}trackByMinorTick(e){return e.value}trackByMajorTick(e){return e.start}getDomPos(e){return this.scale.forward(this.axisExtent,Yc(this.domDim,this.axis),e)}textXPosition(e){return"x"===this.axis?String(this.getDomPos(e)):"100%"}textYPosition(e){return"x"===this.axis?"":String(this.getDomPos(e))}getMajorXPosition(e){return"y"===this.axis?0:Math.min(this.domDim.width,Math.max(0,this.getDomPos(e.start)))}getMajorWidthString(e,i,r){return"y"===this.axis?"":(i||!r?this.domDim.width:this.getMajorXPosition(r))-this.getMajorXPosition(e)+"px"}getMajorYPosition(e){return"x"===this.axis?0:this.domDim.height-Math.min(this.domDim.height,Math.max(0,this.getDomPos(e.start)))}getMajorHeightString(e,i,r){return"x"===this.axis?"":(i||!r?this.domDim.height:this.getMajorYPosition(r))-this.getMajorYPosition(e)+"px"}keydownPreventClose(e){"Escape"!==e.key&&e.stopPropagation()}extentChanged(e,i){let r=Number(e),o=Number(i);if(o<r){let a=r;r=o,o=a}!Number.isFinite(r)||!Number.isFinite(o)||this.onViewExtentChange.emit([r,o])}onAxisUpdateMenuOpen(e,i,r){e.value=String(r[0]),i.value=String(r[1]),e.focus()}setEditMenuOpened(e){this.editMenuOpened=e}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["line-chart-axis"]],inputs:{axisExtent:"axisExtent",axis:"axis",scale:"scale",gridCount:"gridCount",domDim:"domDim",customFormatter:"customFormatter"},outputs:{onViewExtentChange:"onViewExtentChange"},features:[Gt],decls:26,vars:13,consts:[[1,"line"],[1,"minor"],[1,"ticks"],["class","minor-tick-label",4,"ngFor","ngForOf","ngForTrackBy"],["mat-icon-button","","title","Click to manually set min & max values",3,"matMenuTriggerFor","menuOpened","menuClosed"],["matMenuTrigger","matMenuTrigger"],["svgIcon","edit_24px"],["class","major ticks",4,"ngIf"],["xPosition","before",3,"yPosition"],["manualControl","matMenu"],[1,"extent-edit-input",3,"click","keydown"],["type","number",3,"value"],["minInput",""],["maxInput",""],[1,"extent-edit-control",3,"keydown"],["mat-raised-button","","color","primary",1,"extent-edit-change",3,"click"],["mat-stroked-button","",1,"extent-edit-cancel",3,"click"],[1,"minor-tick-label"],[1,"major","ticks"],[3,"major-label","last","left","width","bottom","height","font","title",4,"ngFor","ngForOf","ngForTrackBy"],[3,"title"]],template:function(e,i){if(1&e){let r=ge();h(0,"div"),P(1,"div",0),h(2,"div",1),Tn(),h(3,"svg",2),S(4,S2e,5,6,"g",3),g(),Oo(),h(5,"button",4,5),D("menuOpened",function(){X(r);let a=tt(15),s=tt(20);return i.onAxisUpdateMenuOpen(a,s,i.axisExtent),Q(i.setEditMenuOpened(!0))})("menuClosed",function(){return i.setEditMenuOpened(!1)}),P(7,"mat-icon",6),g()(),S(8,T2e,2,2,"div",7),g(),h(9,"mat-menu",8,9)(11,"div",10),D("click",function(a){return a.stopPropagation()})("keydown",function(a){return i.keydownPreventClose(a)}),h(12,"label"),T(13,"min"),g(),P(14,"input",11,12),g(),h(16,"div",10),D("click",function(a){return a.stopPropagation()})("keydown",function(a){return i.keydownPreventClose(a)}),h(17,"label"),T(18,"max"),g(),P(19,"input",11,13),g(),h(21,"div",14),D("keydown",function(a){return i.keydownPreventClose(a)}),h(22,"button",15),D("click",function(){X(r);let a=tt(15),s=tt(20),l=tt(6);return i.extentChanged(a.value,s.value),Q(l.closeMenu())}),T(23," Change "),g(),h(24,"button",16),D("click",function(){return X(r),Q(tt(6).closeMenu())}),T(25," Cancel "),g()()()}if(2&e){let r=tt(10);ka(i.axis+"-axis axis"),b(4),_("ngForOf",i.minorTicks)("ngForTrackBy",i.trackByMinorTick),b(1),Qe("extent-edit-button",!0)("extent-edit-menu-opened",i.editMenuOpened),_("matMenuTriggerFor",r),b(3),_("ngIf",i.majorTicks.length),b(1),_("yPosition","y"===i.axis?"above":"below"),b(5),_("value",i.axisExtent[0]),b(5),_("value",i.axisExtent[1])}},dependencies:[dn,Fe,Fn,Dn,kc,Pc],styles:["[_nghost-%COMP%]{contain:strict;display:flex;overflow:hidden}.major-label[_ngcontent-%COMP%], text[_ngcontent-%COMP%]{fill:currentColor;font-size:11px;user-select:none}.axis[_ngcontent-%COMP%]{display:flex;height:100%;width:100%}.major[_ngcontent-%COMP%], .minor[_ngcontent-%COMP%]{flex:1 0;overflow:hidden}.line[_ngcontent-%COMP%]{background-color:#aaa;flex:0 0 1px;justify-content:stretch}.ticks[_ngcontent-%COMP%]{height:100%;position:relative;width:100%}.x-axis[_ngcontent-%COMP%]{flex-direction:column}.x-axis[_ngcontent-%COMP%]   .line[_ngcontent-%COMP%]{margin-bottom:3px}.x-axis[_ngcontent-%COMP%]   text[_ngcontent-%COMP%]{dominant-baseline:text-before-edge;text-anchor:middle}.x-axis[_ngcontent-%COMP%]   .ticks[_ngcontent-%COMP%]{-webkit-mask-image:linear-gradient(to right, rgba(0, 0, 0, 0) 0%, #000 10%, #000 90%, rgba(0, 0, 0, 0) 100%);mask-image:linear-gradient(to right, rgba(0, 0, 0, 0) 0%, #000 10%, #000 90%, rgba(0, 0, 0, 0) 100%)}.y-axis[_ngcontent-%COMP%]{flex-direction:row-reverse}.y-axis[_ngcontent-%COMP%]   .line[_ngcontent-%COMP%]{margin-left:5px}.y-axis[_ngcontent-%COMP%]   text[_ngcontent-%COMP%]{dominant-baseline:central;text-anchor:end}.y-axis[_ngcontent-%COMP%]   .ticks[_ngcontent-%COMP%]{-webkit-mask-image:linear-gradient(to bottom, rgba(0, 0, 0, 0) 0%, #000 10%, #000 90%, rgba(0, 0, 0, 0) 100%);mask-image:linear-gradient(to bottom, rgba(0, 0, 0, 0) 0%, #000 10%, #000 90%, rgba(0, 0, 0, 0) 100%)}.extent-edit-button[_ngcontent-%COMP%]{background-color:#eee;font-size:0;height:24px;line-height:24px;position:absolute;right:5px;top:5px;visibility:hidden;width:24px}.extent-edit-button[_ngcontent-%COMP%]   mat-icon[_ngcontent-%COMP%]{height:16px;width:16px;line-height:16px}.extent-edit-input[_ngcontent-%COMP%]{align-items:center;column-gap:5px;display:grid;font-size:12px;grid-template-columns:30px minmax(auto, 100px);height:30px;margin:10px 20px}.extent-edit-input[_ngcontent-%COMP%]   input[_ngcontent-%COMP%]{background-color:inherit;border-radius:4px;border-style:solid;color:inherit}.extent-edit-control[_ngcontent-%COMP%]{align-items:center;display:flex;flex-direction:row-reverse;justify-content:flex-end;margin:10px 20px}.extent-edit-control[_ngcontent-%COMP%]   button[_ngcontent-%COMP%]{font-size:12px;height:30px;line-height:1.4;margin-left:5px;padding:0 10px}.axis[_ngcontent-%COMP%]:hover   .extent-edit-button[_ngcontent-%COMP%], .axis[_ngcontent-%COMP%]:focus-within   .extent-edit-button[_ngcontent-%COMP%], .extent-edit-menu-opened[_ngcontent-%COMP%]{visibility:visible}.major[_ngcontent-%COMP%]{position:relative;overflow:hidden;contain:strict}.major[_ngcontent-%COMP%]   .major-label[_ngcontent-%COMP%]{align-items:center;box-sizing:border-box;display:inline-flex;justify-content:center;overflow:hidden;position:absolute;white-space:nowrap}.major[_ngcontent-%COMP%]   .major-label[_ngcontent-%COMP%]   span[_ngcontent-%COMP%]{max-width:100%}.x-axis[_ngcontent-%COMP%]   .major-label[_ngcontent-%COMP%]{border-left:1px solid #9e9e9e;padding:0 5px}.x-axis[_ngcontent-%COMP%]   .major-label.last[_ngcontent-%COMP%]{border-right:1px solid #9e9e9e}.y-axis[_ngcontent-%COMP%]   .major-label[_ngcontent-%COMP%]{border-bottom:1px solid #9e9e9e;height:100%;padding:5px 0;width:100%}.y-axis[_ngcontent-%COMP%]   .major-label.last[_ngcontent-%COMP%]{border-top:1px solid #9e9e9e}.y-axis[_ngcontent-%COMP%]   .major-label[_ngcontent-%COMP%] > span[_ngcontent-%COMP%]{transform:rotate(-90deg);transform-origin:center}"],changeDetection:0}),n})();function tC(n,t){let e=Math.min(Nc(n.map(({x:o})=>o),t),n.length-1),i=Math.max(0,e-1);return Math.abs(n[i].x-t)-Math.abs(n[e].x-t)<=0?i:e}function Ute(n,t,e,i,r,o){let a;switch(n.deltaMode){case WheelEvent.DOM_DELTA_PIXEL:a=1;break;case WheelEvent.DOM_DELTA_LINE:a=8;break;case WheelEvent.DOM_DELTA_PAGE:a=20;break;default:a=1,console.warn(`Unknown WheelEvent deltaMode: ${n.deltaMode}.`)}let s=n.deltaY*a,l=s<0?Math.max(s*i,-.95):s*i,{width:c,height:d}=e,u=[r.reverse(t.x,[0,c],-n.offsetX*l),r.reverse(t.x,[0,c],c+(c-n.offsetX)*l)],p=[o.reverse(t.y,[d,0],-n.offsetY*l),o.reverse(t.y,[d,0],d+(d-n.offsetY)*l)];return{x:u[1]<u[0]?[u[1],u[0]]:u,y:p[1]<p[0]?[p[1],p[0]]:p}}var A2e=["dots"];function R2e(n,t){if(1&n&&(Tn(),P(0,"circle",11)),2&n){let e=w().$implicit,i=w(2);Pe("cx",i.getDomX(e.dataPoint.x))("cy",i.getDomY(e.dataPoint.y))("fill",e.metadata.color)}}function k2e(n,t){if(1&n&&(Tn(),Tt(0),S(1,R2e,1,3,"circle",10),Dt()),2&n){let e=t.$implicit,i=w(2);b(1),_("ngIf",i.shouldRenderTooltipPoint(e.dataPoint))}}function P2e(n,t){if(1&n&&(Tn(),Tt(0),S(1,k2e,2,1,"ng-container",9),Dt()),2&n){let e=w();b(1),_("ngForOf",e.cursoredData)("ngForTrackBy",e.trackBySeriesName)}}function O2e(n,t){if(1&n&&(Tn(),P(0,"rect",12)),2&n){let e=w();Pe("x",e.zoomBoxInUiCoordinate.x)("width",e.zoomBoxInUiCoordinate.width)("y",e.zoomBoxInUiCoordinate.y)("height",e.zoomBoxInUiCoordinate.height)}}var F2e=function(n,t,e){return{data:n,cursorLocationInDataCoord:t,cursorLocation:e}};function L2e(n,t){if(1&n&&(h(0,"div",14),Ti(1,15),g()),2&n){let e=w(2),i=tt(11);b(1),_("ngTemplateOutlet",e.tooltipTemplate?e.tooltipTemplate:i)("ngTemplateOutletContext",Ty(2,F2e,e.cursoredData,e.cursorLocationInDataCoord,e.cursorLocation))}}function N2e(n,t){if(1&n){let e=ge();S(0,L2e,2,6,"ng-template",13),D("detach",function(){return X(e),Q(w().onTooltipDisplayDetached())})}if(2&n){let e=w();_("cdkConnectedOverlayOrigin",e.tooltipOriginEl)("cdkConnectedOverlayOpen",e.tooltipDisplayAttached&&e.state.getValue()===e.InteractionState.NONE)("cdkConnectedOverlayPositions",e.tooltipPositions)("cdkConnectedOverlayScrollStrategy",e.scrollStrategy)("cdkConnectedOverlayLockPosition",!1)("cdkConnectedOverlayFlexibleDimensions",!0)("cdkConnectedOverlayGrowAfterOpen",!0)}}function B2e(n,t){if(1&n&&(Tt(0),h(1,"tr",17)(2,"td",18),P(3,"span"),g(),h(4,"td",19),T(5),g(),h(6,"td"),T(7),g(),h(8,"td"),T(9),g()(),Dt()),2&n){let e=t.$implicit;b(3),Mt("background-color",e.metadata.color),b(2),ut(e.metadata.displayName),b(2),ut(e.dataPoint.y),b(2),ut(e.dataPoint.x)}}function V2e(n,t){if(1&n&&(h(0,"table")(1,"thead")(2,"tr"),P(3,"th",16),h(4,"th"),T(5,"Name"),g(),h(6,"th"),T(7,"Y"),g(),h(8,"th"),T(9,"X"),g()()(),h(10,"tbody"),S(11,B2e,10,5,"ng-container",9),g()()),2&n){let e=t.data,i=w();b(11),_("ngForOf",e)("ngForTrackBy",i.trackBySeriesName)}}function z2e(n){return n.scrollStrategies.reposition()}var jte=(()=>{class n{constructor(e,i){this.changeDetector=e,this.scrollStrategy=i,this.onViewExtentChange=new L,this.onViewExtentReset=new L,this.onInteractionStateChange=new L,this.InteractionState=Tr,this.state=new Ri(Tr.NONE),this.specialKeyPressed=!1,this.zoomBoxInUiCoordinate={x:0,width:0,height:0,y:0},this.tooltipPositions=[{offsetY:5,originX:"start",overlayX:"start",originY:"bottom",overlayY:"top"},{offsetY:5,originX:"end",overlayX:"end",originY:"bottom",overlayY:"top"},{offsetY:-15,originX:"start",overlayX:"start",originY:"top",overlayY:"bottom"},{offsetY:-15,originX:"end",overlayX:"end",originY:"top",overlayY:"bottom"},{offsetX:5,originX:"end",overlayX:"start",originY:"top",overlayY:"top"},{offsetX:-5,originX:"start",overlayX:"end",originY:"top",overlayY:"top"}],this.cursorLocationInDataCoord=null,this.cursorLocation=null,this.cursoredData=[],this.tooltipDisplayAttached=!1,this.showZoomInstruction=!1,this.dragStartCoord=null,this.isCursorInside=!1,this.ngUnsubscribe=new Ae,this.subscriptions=[]}ngAfterViewInit(){this.subscriptions.push(this.state.subscribe(e=>{this.onInteractionStateChange.emit(e)})),this.ngUnsubscribe.pipe(U(()=>{this.subscriptions.forEach(e=>e.unsubscribe())})),ai(this.dotsContainer.nativeElement,"dblclick",{passive:!0}).pipe(ot(this.ngUnsubscribe)).subscribe(()=>{this.onViewExtentReset.emit(),this.state.next(Tr.NONE),this.changeDetector.markForCheck()}),ai(window,"keydown",{passive:!0}).pipe(ot(this.ngUnsubscribe)).subscribe(e=>{let i=this.shouldPan(e);i!==this.specialKeyPressed&&(this.specialKeyPressed=i,this.changeDetector.markForCheck())}),ai(window,"keyup",{passive:!0}).pipe(ot(this.ngUnsubscribe)).subscribe(e=>{let i=this.shouldPan(e);i!==this.specialKeyPressed&&(this.specialKeyPressed=i,this.changeDetector.markForCheck())}),ai(this.dotsContainer.nativeElement,"mousedown",{passive:!0}).pipe(ot(this.ngUnsubscribe)).subscribe(e=>{let i=this.state.getValue(),r=this.shouldPan(e)?Tr.PANNING:Tr.DRAG_ZOOMING;i===Tr.NONE&&r===Tr.DRAG_ZOOMING&&(this.dragStartCoord={x:e.offsetX,y:e.offsetY},this.zoomBoxInUiCoordinate={x:e.offsetX,width:0,y:e.offsetY,height:0}),i!==r&&(this.state.next(r),this.changeDetector.markForCheck())}),ai(this.dotsContainer.nativeElement,"mouseup",{passive:!0}).pipe(ot(this.ngUnsubscribe)).subscribe(e=>{let i=(e.buttons&ps.LEFT)===ps.LEFT;this.dragStartCoord=null;let r=this.zoomBoxInUiCoordinate;if(!i&&this.state.getValue()===Tr.DRAG_ZOOMING&&r.width>0&&r.height>0){let o=this.getDataX(r.x),a=this.getDataX(r.x+r.width),s=this.getDataY(r.y+r.height),l=this.getDataY(r.y);this.onViewExtentChange.emit({dataExtent:{x:[o,a],y:[s,l]}})}this.state.getValue()!==Tr.NONE&&(this.state.next(Tr.NONE),this.changeDetector.markForCheck())}),ai(this.dotsContainer.nativeElement,"mouseenter",{passive:!0}).pipe(ot(this.ngUnsubscribe)).subscribe(e=>{this.isCursorInside=!0,this.updateTooltip(e),this.changeDetector.markForCheck()}),ai(this.dotsContainer.nativeElement,"mouseleave",{passive:!0}).pipe(ot(this.ngUnsubscribe)).subscribe(e=>{this.dragStartCoord=null,this.isCursorInside=!1,this.updateTooltip(e),this.state.next(Tr.NONE),this.changeDetector.markForCheck()}),ai(this.dotsContainer.nativeElement,"mousemove",{passive:!0}).pipe(ot(this.ngUnsubscribe)).subscribe(e=>{switch(this.state.getValue()){case Tr.SCROLL_ZOOMING:this.state.next(Tr.NONE),this.updateTooltip(e),this.changeDetector.markForCheck();break;case Tr.NONE:this.updateTooltip(e),this.changeDetector.markForCheck();break;case Tr.PANNING:{let i=-e.movementX,r=-e.movementY,{width:o,height:a}=this.domDim,s=this.getDataX(i),l=this.getDataX(o+i),c=this.getDataY(a+r),d=this.getDataY(r);this.onViewExtentChange.emit({dataExtent:{x:[s,l],y:[c,d]}});break}case Tr.DRAG_ZOOMING:{if(!this.dragStartCoord)break;let i=[this.dragStartCoord.x,e.offsetX],r=[this.dragStartCoord.y,e.offsetY];this.zoomBoxInUiCoordinate={x:Math.min(...i),width:Math.max(...i)-Math.min(...i),y:Math.min(...r),height:Math.max(...r)-Math.min(...r)}}this.changeDetector.markForCheck()}}),ai(this.dotsContainer.nativeElement,"wheel",{passive:!1}).pipe(ot(this.ngUnsubscribe),yi(e=>{let i=!e.ctrlKey&&!e.shiftKey&&e.altKey;return this.showZoomInstruction=!i,this.changeDetector.markForCheck(),i?(e.preventDefault(),qt(e)):Ja(3e3).pipe(Vt(()=>{this.showZoomInstruction=!1,this.changeDetector.markForCheck()}),U(()=>null))}),Ve(e=>Boolean(e))).subscribe(e=>{this.onViewExtentChange.emit({dataExtent:Ute(e,this.viewExtent,this.domDim,.01,this.xScale,this.yScale)}),this.state.getValue()!==Tr.SCROLL_ZOOMING&&(this.state.next(Tr.SCROLL_ZOOMING),this.changeDetector.markForCheck())})}ngOnChanges(){this.updateCursoredDataAndTooltipVisibility()}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}shouldPan(e){let i=e.shiftKey||e.altKey;if(e instanceof KeyboardEvent)return i;let r=(e.buttons&ps.LEFT)===ps.LEFT,o=(e.buttons&ps.MIDDLE)===ps.MIDDLE;return!(!r&&!o)&&(o&&!r||i)}trackBySeriesName(e,i){return i.id}getDomX(e){return this.xScale.forward(this.viewExtent.x,Yc(this.domDim,"x"),e)}getDataX(e){return this.xScale.reverse(this.viewExtent.x,Yc(this.domDim,"x"),e)}getDomY(e){return this.yScale.forward(this.viewExtent.y,Yc(this.domDim,"y"),e)}getDataY(e){return this.yScale.reverse(this.viewExtent.y,Yc(this.domDim,"y"),e)}shouldRenderTooltipPoint(e){return null!==e&&!isNaN(e.x)&&!isNaN(e.y)}updateTooltip(e){this.cursorLocationInDataCoord={x:this.getDataX(e.offsetX),y:this.getDataY(e.offsetY)},this.cursorLocation={x:e.offsetX,y:e.offsetY},this.updateCursoredDataAndTooltipVisibility()}onTooltipDisplayDetached(){this.tooltipDisplayAttached=!1}updateCursoredDataAndTooltipVisibility(){let e=this.cursorLocationInDataCoord;if(null===e)return this.cursoredData=[],void(this.tooltipDisplayAttached=!1);this.cursoredData=this.isCursorInside?this.seriesData.map(i=>({seriesDatum:i,metadata:this.seriesMetadataMap[i.id]})).filter(({metadata:i})=>i&&i.visible&&!Boolean(i.aux)).map(({seriesDatum:i,metadata:r})=>{let o=tC(i.points,e.x),a=i.points[o];return{id:i.id,closestPointIndex:o,dataPoint:a,domPoint:{x:this.getDomX(a.x),y:this.getDomY(a.y)},metadata:r}}).filter(i=>i):[],this.tooltipDisplayAttached=Boolean(this.cursoredData.length)}}return n.\u0275fac=function(e){return new(e||n)(C(Ft),C(Pf))},n.\u0275cmp=k({type:n,selectors:[["line-chart-interactive-view"]],viewQuery:function(e,i){if(1&e&&(Ye(A2e,7,be),Ye(zu,5)),2&e){let r;we(r=Se())&&(i.dotsContainer=r.first),we(r=Se())&&(i.overlay=r.first)}},hostVars:2,hostBindings:function(e,i){2&e&&Qe("show-zoom-instruction",i.showZoomInstruction)},inputs:{seriesData:"seriesData",seriesMetadataMap:"seriesMetadataMap",viewExtent:"viewExtent",xScale:"xScale",yScale:"yScale",domDim:"domDim",tooltipOriginEl:"tooltipOriginEl",tooltipTemplate:"tooltipTemplate",disableTooltip:"disableTooltip"},outputs:{onViewExtentChange:"onViewExtentChange",onViewExtentReset:"onViewExtentReset",onInteractionStateChange:"onInteractionStateChange"},features:[Rt([{provide:Pf,useFactory:z2e,deps:[Oi]}]),Gt],decls:12,vars:9,consts:[[1,"dots"],["dots",""],[4,"ngIf"],["class","zoom-box",4,"ngIf"],[1,"zoom-instruction"],[1,"instruction-content"],["cdkOverlayOrigin","",1,"tooltip-origin"],["tooltipOrigin","cdkOverlayOrigin"],["defaultTooltip",""],[4,"ngFor","ngForOf","ngForTrackBy"],["r","4",4,"ngIf"],["r","4"],[1,"zoom-box"],["cdkConnectedOverlay","",3,"cdkConnectedOverlayOrigin","cdkConnectedOverlayOpen","cdkConnectedOverlayPositions","cdkConnectedOverlayScrollStrategy","cdkConnectedOverlayLockPosition","cdkConnectedOverlayFlexibleDimensions","cdkConnectedOverlayGrowAfterOpen","detach"],[1,"tooltip-container"],[3,"ngTemplateOutlet","ngTemplateOutletContext"],[1,"circle-header"],[1,"tooltip-row"],[1,"tooltip-row-circle"],[1,"name"]],template:function(e,i){1&e&&(Tn(),h(0,"svg",0,1),S(2,P2e,2,2,"ng-container",2),S(3,O2e,1,4,"rect",3),g(),Oo(),h(4,"div",4)(5,"span",5),T(6,"Alt + Scroll to Zoom"),g()(),P(7,"div",6,7),S(9,N2e,1,7,null,2),S(10,V2e,12,2,"ng-template",null,8,Zt)),2&e&&(Qe("pannable",i.specialKeyPressed)("draggable",i.state.getValue()===i.InteractionState.NONE||i.state.getValue()===i.InteractionState.DRAG_ZOOMING)("panning",i.state.getValue()===i.InteractionState.PANNING),b(2),_("ngIf",i.state.getValue()===i.InteractionState.NONE),b(1),_("ngIf",i.state.getValue()===i.InteractionState.DRAG_ZOOMING),b(6),_("ngIf",!i.disableTooltip))},dependencies:[dn,Fe,Mo,zu,Hu],styles:["[_nghost-%COMP%]{display:flex;position:relative;user-select:none}.dots[_ngcontent-%COMP%]{height:100%;width:100%}.dots.draggable[_ngcontent-%COMP%]{cursor:crosshair}.dots.pannable[_ngcontent-%COMP%]{cursor:grab}.dots.panning[_ngcontent-%COMP%]{cursor:grabbing}.tooltip-row-circle[_ngcontent-%COMP%]{align-items:center;display:inline-flex;height:12px;width:12px}.tooltip-row-circle[_ngcontent-%COMP%] > span[_ngcontent-%COMP%]{border-radius:50%;border:1px solid rgba(255,255,255,.6);display:inline-block;height:10px;width:10px}.tooltip-origin[_ngcontent-%COMP%]{bottom:0;left:0;position:absolute;right:0}.tooltip-container[_ngcontent-%COMP%]{background:rgba(0,0,0,.85);border-radius:4px;color:#fff;contain:paint style layout;font-size:.9em;overflow:auto;padding:5px;pointer-events:none;width:100%}th[_ngcontent-%COMP%], td[_ngcontent-%COMP%]{padding:2px 5px;text-align:left}th[_ngcontent-%COMP%]{font-weight:500;padding-bottom:5px}.zoom-box[_ngcontent-%COMP%]{fill-opacity:.03;fill:#000;stroke:#ccc}.zoom-instruction[_ngcontent-%COMP%]{align-items:center;display:flex;justify-content:center;left:0;opacity:0;pointer-events:none;position:absolute;right:0;top:10px;transition:opacity .5s;z-index:1}.instruction-content[_ngcontent-%COMP%]{background:rgba(0,0,0,.6);border-radius:5px;color:#fff;padding:5px 10px;user-select:none}.show-zoom-instruction[_nghost-%COMP%]   .zoom-instruction[_ngcontent-%COMP%]{opacity:1}"],changeDetection:0}),n})();function j2e(n,t){if(1&n&&(Tn(),P(0,"line",2)),2&n){let e=t.$implicit,i=w();Qe("zero",0===e),Pe("x1",i.getDomX(e))("x2",i.getDomX(e))("y2",i.domDim.height)}}function G2e(n,t){if(1&n&&(Tn(),P(0,"line",3)),2&n){let e=t.$implicit,i=w();Qe("zero",0===e),Pe("y1",i.getDomY(e))("x2",i.domDim.width)("y2",i.getDomY(e))}}var Gte=(()=>{class n{getDomX(e){return this.xScale.forward(this.viewExtent.x,Yc(this.domDim,"x"),e)}getDomY(e){return this.yScale.forward(this.viewExtent.y,Yc(this.domDim,"y"),e)}getXTicks(){return this.xScale.ticks(this.viewExtent.x,$x(this.domDim.width,this.xGridCount))}getYTicks(){return this.yScale.ticks(this.viewExtent.y,$x(this.domDim.height,this.yGridCount))}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["line-chart-grid-view"]],inputs:{viewExtent:"viewExtent",xScale:"xScale",xGridCount:"xGridCount",yScale:"yScale",yGridCount:"yGridCount",domDim:"domDim"},decls:3,vars:2,consts:[["y1","0",3,"zero",4,"ngFor","ngForOf"],["x1","0",3,"zero",4,"ngFor","ngForOf"],["y1","0"],["x1","0"]],template:function(e,i){1&e&&(Tn(),h(0,"svg"),S(1,j2e,1,5,"line",0),S(2,G2e,1,5,"line",1),g()),2&e&&(b(1),_("ngForOf",i.getXTicks()),b(1),_("ngForOf",i.getYTicks()))},dependencies:[dn],styles:["[_nghost-%COMP%] {\n        display: flex;\n        overflow: hidden;\n      }\n\n      svg[_ngcontent-%COMP%] {\n        height: 100%;\n        width: 100%;\n      }\n\n      line[_ngcontent-%COMP%] {\n        stroke: #ccc;\n        stroke-width: 1px;\n      }\n\n      .zero[_ngcontent-%COMP%] {\n        stroke: #aaa;\n        stroke-width: 1.5px;\n      }"],changeDetection:0}),n})(),q2e=["seriesView"],Y2e=["xAxis"],X2e=["yAxis"],Q2e=["chartEl"];function Z2e(n,t){if(1&n&&P(0,"line-chart-grid-view",16),2&n){let e=w();_("viewExtent",e.viewBox)("xScale",e.xScale)("yScale",e.yScale)("xGridCount",e.X_GRID_COUNT)("yGridCount",e.Y_GRID_COUNT)("domDim",e.domDimensions.main)}}function K2e(n,t){1&n&&(Tn(),P(0,"svg",null,17))}function J2e(n,t){1&n&&P(0,"canvas",null,17)}function $2e(n,t){if(1&n&&(Tt(0),S(1,K2e,2,0,"svg",5),S(2,J2e,2,0,"canvas",5),Dt()),2&n){let e=w();b(1),_("ngIf",e.getRendererType()===e.RendererType.SVG),b(1),_("ngIf",e.getRendererType()===e.RendererType.WEBGL)}}function eLe(n,t){if(1&n){let e=ge();h(0,"line-chart-interactive-view",18),D("onViewExtentChange",function(r){return X(e),Q(w().onViewBoxChanged(r))})("onViewExtentReset",function(){return X(e),Q(w().viewBoxReset())})("onInteractionStateChange",function(r){return X(e),Q(w().onInteractionStateChange(r))}),g()}if(2&n){let e=w(),i=tt(1);_("seriesData",e.seriesData)("seriesMetadataMap",e.seriesMetadataMap)("viewExtent",e.viewBox)("xScale",e.xScale)("yScale",e.yScale)("tooltipOriginEl",i)("domDim",e.domDimensions.main)("tooltipTemplate",e.tooltipTemplate)("disableTooltip",e.disableTooltip)}}var tLe=function(n,t,e,i){return{xScale:n,yScale:t,domDimension:e,viewExtent:i}};function nLe(n,t){if(1&n&&(h(0,"div",19),Ti(1,20),g()),2&n){let e=w();b(1),_("ngTemplateOutlet",e.customVisTemplate)("ngTemplateOutletContext",LP(2,tLe,e.xScale,e.yScale,e.domDimensions.main,e.viewBox))}}function iLe(n,t){if(1&n){let e=ge();h(0,"line-chart-axis",21),D("onViewExtentChange",function(r){return X(e),Q(w().onViewBoxChangedFromAxis(r,"y"))}),g()}if(2&n){let e=w();_("axisExtent",e.viewBox.y)("customFormatter",e.customYFormatter)("domDim",e.domDimensions.yAxis)("gridCount",e.Y_GRID_COUNT)("scale",e.yScale)}}function rLe(n,t){if(1&n){let e=ge();h(0,"line-chart-axis",22),D("onViewExtentChange",function(r){return X(e),Q(w().onViewBoxChangedFromAxis(r,"x"))}),g()}if(2&n){let e=w();_("axisExtent",e.viewBox.x)("customFormatter",e.customXFormatter)("domDim",e.domDimensions.xAxis)("gridCount",e.X_GRID_COUNT)("scale",e.xScale)}}function oLe(n,t){1&n&&(h(0,"div",23),P(1,"span",24),g())}var aLe=function(n,t,e,i,r){return{xScale:n,yScale:t,domDimension:e,viewExtent:i,interactionState:r}};function sLe(n,t){if(1&n&&(h(0,"div",25,26),Ti(2,20),g()),2&n){let e=w();b(2),_("ngTemplateOutlet",e.customChartOverlayTemplate)("ngTemplateOutletContext",NP(2,aLe,e.xScale,e.yScale,e.domDimensions.main,e.viewBox,e.interactionState))}}var lLe=function(n,t){return{container:!0,"dark-mode":n,"line-only-mode":t,"line-chart":!0}},GV={x:[0,1],y:[0,1]},C_=(()=>{class n{constructor(e){this.changeDetector=e,this.RendererType=Zi,this.useDarkMode=!1,this.preferredRendererType=Zi.WEBGL,this.xScaleType=ir.LINEAR,this.yScaleType=ir.LINEAR,this.userViewBox=null,this.lineOnly=!1,this.disableTooltip=!1,this.viewBoxChanged=new L,this.onViewBoxOverridden=new Fp(1),this.ignoreYOutliers=!1,this.Y_GRID_COUNT=6,this.X_GRID_COUNT=10,this.xScale=jl(this.xScaleType),this.yScale=jl(this.xScaleType),this.viewBox=GV,this.domDimensions={main:{width:0,height:0},xAxis:{width:0,height:0},yAxis:{width:0,height:0}},this.showChartRendererElement=!0,this.interactionState=Tr.NONE,this.lineChart=null,this.isDataUpdated=!1,this.isMetadataUpdated=!1,this.isFixedViewBoxUpdated=!1,this.isViewBoxOverridden=!1,this.useDarkModeUpdated=!1,this.userViewBoxUpdated=!1,this.isViewBoxChanged=!0,this.scaleUpdated=!0,this.isRenderingContextLost=!1}ngOnInit(){this.onViewBoxOverridden.next(this.isViewBoxOverridden)}ngOnChanges(e){e.xScaleType&&(this.xScale=jl(this.xScaleType),this.scaleUpdated=!0),e.yScaleType&&(this.yScale=jl(this.yScaleType),this.scaleUpdated=!0),e.seriesData&&(this.isDataUpdated=!0),e.fixedViewBox&&(this.isFixedViewBoxUpdated=!0),e.seriesMetadataMap&&(this.isMetadataUpdated=!0),e.useDarkMode&&(this.useDarkModeUpdated=!0),e.userViewBox&&(this.userViewBoxUpdated=!0),this.userViewBoxUpdated?this.setIsViewBoxOverridden(!!this.userViewBox):this.scaleUpdated&&this.setIsViewBoxOverridden(!1),this.isViewBoxChanged=this.isViewBoxChanged||this.userViewBoxUpdated||this.scaleUpdated||!this.isViewBoxOverridden&&this.shouldUpdateDefaultViewBox(e),this.updateLineChart()}ngAfterViewInit(){this.initializeChart(),this.updateLineChart(),this.changeDetector.detectChanges()}recoverRendererIfNeeded(){!this.isRenderingContextLost||this.disableUpdate||(this.showChartRendererElement=!1,this.changeDetector.detectChanges(),this.showChartRendererElement=!0,this.changeDetector.detectChanges(),this.initializeChart(),this.scaleUpdated=!0,this.isMetadataUpdated=!0,this.isDataUpdated=!0,this.useDarkModeUpdated=!0,this.isFixedViewBoxUpdated=!0,this.isViewBoxChanged=!0,this.isRenderingContextLost=!1)}onViewResize(){!this.lineChart||(this.readAndUpdateDomDimensions(),this.lineChart.resize(this.domDimensions.main),this.changeDetector.detectChanges())}shouldUpdateDefaultViewBox(e){if(e.xScaleType||e.yScaleType||e.ignoreYOutliers||e.seriesData)return!0;let r=e.seriesMetadataMap;if(r){let o=r.previousValue;if(Object.keys(this.seriesMetadataMap).length!==Object.keys(o??{}).length)return!0;for(let[a,s]of Object.entries(this.seriesMetadataMap)){let l=o&&o[a];if(!l||s.visible!==l.visible)return!0}}return!1}onContextLost(){this.isRenderingContextLost=!0,this.lineChart&&(this.lineChart.dispose(),this.lineChart=null)}triggerContextLostForTest(){this.onContextLost()}getLineChartForTest(){return this.lineChart}initializeChart(){this.lineChart&&this.lineChart.dispose();let e=this.getRendererType(),i={onDrawEnd:()=>{},onContextLost:this.onContextLost.bind(this)},r=null;switch(this.readAndUpdateDomDimensions(),e){case Zi.SVG:r={type:Zi.SVG,container:this.chartEl.nativeElement,callbacks:i,domDimension:this.domDimensions.main,useDarkMode:this.useDarkMode};break;case Zi.WEBGL:r={type:Zi.WEBGL,container:this.chartEl.nativeElement,devicePixelRatio:window.devicePixelRatio,callbacks:i,domDimension:this.domDimensions.main,useDarkMode:this.useDarkMode};break;default:throw new Error(`<line-chart> does not yet support rendererType: ${e}`)}let a=e!==Zi.SVG&&Gl_isWebGl2OffscreenCanvasSupported()?Pm:lA;this.lineChart=new a(r)}ngOnDestroy(){this.lineChart&&this.lineChart.dispose()}getRendererType(){return function(n){switch(n){case Zi.SVG:return Zi.SVG;case Zi.WEBGL:return Gl_isWebGl2Supported()?Zi.WEBGL:Zi.SVG;default:throw new Error(`Unknown rendererType: ${n}`)}}(this.preferredRendererType)}readAndUpdateDomDimensions(){this.domDimensions={main:{width:this.seriesView.nativeElement.clientWidth,height:this.seriesView.nativeElement.clientHeight},xAxis:{width:this.xAxis.nativeElement.clientWidth,height:this.xAxis.nativeElement.clientHeight},yAxis:{width:this.yAxis.nativeElement.clientWidth,height:this.yAxis.nativeElement.clientHeight}}}updateLineChart(){if(this.recoverRendererIfNeeded(),this.lineChart&&!this.disableUpdate){if(this.scaleUpdated&&(this.scaleUpdated=!1,this.lineChart.setXScaleType(this.xScaleType),this.lineChart.setYScaleType(this.yScaleType)),this.isMetadataUpdated&&(this.isMetadataUpdated=!1,this.lineChart.setMetadata(this.seriesMetadataMap)),this.isDataUpdated&&(this.isDataUpdated=!1,this.lineChart.setData(this.seriesData)),this.useDarkModeUpdated&&(this.useDarkModeUpdated=!1,this.lineChart.setUseDarkMode(this.useDarkMode)),this.userViewBoxUpdated&&(this.userViewBoxUpdated=!1),this.isViewBoxOverridden&&this.userViewBox)this.viewBox=this.userViewBox;else if(!this.isViewBoxOverridden&&this.fixedViewBox)this.viewBox=this.fixedViewBox;else if(!this.isViewBoxOverridden&&this.isViewBoxChanged){let i=function(n,t,e,i,r){let o=null,a=null,s=[];for(let{id:u,points:p}of n){let f=t[u];if(f&&!f.aux&&f.visible)for(let m=0;m<p.length;m++){let{x:y,y:M}=p[m];i(y)&&(o=null===o||y<o?y:o,a=null===a||y>a?y:a),r(M)&&s.push(M)}}s.sort(Ks);let c=s[0],d=s[s.length-1];return e&&s.length>2&&(c=s[Math.ceil(.05*(s.length-1))],d=s[Math.floor(.95*(s.length-1))]),{x:null!==o&&null!==a?[o,a]:void 0,y:void 0!==c&&void 0!==d?[c,d]:void 0}}(this.seriesData,this.seriesMetadataMap,this.ignoreYOutliers,this.xScale.isSafeNumber,this.yScale.isSafeNumber);this.viewBox={x:this.xScale.niceDomain(i.x??GV.x),y:this.yScale.niceDomain(i.y??GV.y)}}(this.isFixedViewBoxUpdated||this.isViewBoxChanged)&&(this.isFixedViewBoxUpdated=!1,this.isViewBoxChanged=!1,this.lineChart.setViewBox(this.viewBox),this.changeDetector.detectChanges())}}onViewBoxChanged({dataExtent:e}){this.viewBoxChanged.emit(e)}viewBoxReset(){this.viewBoxChanged.emit(null)}setIsViewBoxOverridden(e){let i=this.isViewBoxOverridden;this.isViewBoxOverridden=e,i!==e&&this.onViewBoxOverridden.next(e)}onInteractionStateChange(e){this.interactionState=e}getIsViewBoxOverridden(){return this.onViewBoxOverridden}onViewBoxChangedFromAxis(e,i){let r={...this.viewBox,[i]:e};this.onViewBoxChanged({dataExtent:r})}}return n.\u0275fac=function(e){return new(e||n)(C(Ft))},n.\u0275cmp=k({type:n,selectors:[["line-chart"]],viewQuery:function(e,i){if(1&e&&(Ye(q2e,7,be),Ye(Y2e,7,be),Ye(X2e,7,be),Ye(Q2e,5,be)),2&e){let r;we(r=Se())&&(i.seriesView=r.first),we(r=Se())&&(i.xAxis=r.first),we(r=Se())&&(i.yAxis=r.first),we(r=Se())&&(i.chartEl=r.first)}},inputs:{customVisTemplate:"customVisTemplate",customChartOverlayTemplate:"customChartOverlayTemplate",useDarkMode:"useDarkMode",preferredRendererType:"preferredRendererType",seriesData:"seriesData",fixedViewBox:"fixedViewBox",seriesMetadataMap:"seriesMetadataMap",xScaleType:"xScaleType",yScaleType:"yScaleType",customXFormatter:"customXFormatter",customYFormatter:"customYFormatter",tooltipTemplate:"tooltipTemplate",userViewBox:"userViewBox",lineOnly:"lineOnly",disableTooltip:"disableTooltip",disableUpdate:"disableUpdate",ignoreYOutliers:"ignoreYOutliers"},outputs:{viewBoxChanged:"viewBoxChanged"},features:[Gt],decls:16,vars:13,consts:[["detectResize","","cdkOverlayOrigin","",3,"ngClass","resizeEventDebouncePeriodInMs","onResize"],["overlayTarget","cdkOverlayOrigin"],[1,"series-view"],["seriesView",""],[3,"viewExtent","xScale","yScale","xGridCount","yGridCount","domDim",4,"ngIf"],[4,"ngIf"],[3,"seriesData","seriesMetadataMap","viewExtent","xScale","yScale","tooltipOriginEl","domDim","tooltipTemplate","disableTooltip","onViewExtentChange","onViewExtentReset","onInteractionStateChange",4,"ngIf"],["class","custom-vis",4,"ngIf"],[1,"y-axis"],["yAxis",""],["axis","y",3,"axisExtent","customFormatter","domDim","gridCount","scale","onViewExtentChange",4,"ngIf"],[1,"x-axis"],["xAxis",""],["axis","x",3,"axisExtent","customFormatter","domDim","gridCount","scale","onViewExtentChange",4,"ngIf"],["class","dot",4,"ngIf"],["class","custom-vis custom-chart-overlay-vis",4,"ngIf"],[3,"viewExtent","xScale","yScale","xGridCount","yGridCount","domDim"],["chartEl",""],[3,"seriesData","seriesMetadataMap","viewExtent","xScale","yScale","tooltipOriginEl","domDim","tooltipTemplate","disableTooltip","onViewExtentChange","onViewExtentReset","onInteractionStateChange"],[1,"custom-vis"],[3,"ngTemplateOutlet","ngTemplateOutletContext"],["axis","y",3,"axisExtent","customFormatter","domDim","gridCount","scale","onViewExtentChange"],["axis","x",3,"axisExtent","customFormatter","domDim","gridCount","scale","onViewExtentChange"],[1,"dot"],[1,"rect"],[1,"custom-vis","custom-chart-overlay-vis"],["customChartOverlay",""]],template:function(e,i){1&e&&(h(0,"div",0,1),D("onResize",function(){return i.onViewResize()}),h(2,"div",2,3),S(4,Z2e,1,6,"line-chart-grid-view",4),S(5,$2e,3,2,"ng-container",5),S(6,eLe,1,9,"line-chart-interactive-view",6),S(7,nLe,2,7,"div",7),g(),h(8,"div",8,9),S(10,iLe,1,5,"line-chart-axis",10),g(),h(11,"div",11,12),S(13,rLe,1,5,"line-chart-axis",13),g(),S(14,oLe,2,0,"div",14),S(15,sLe,3,8,"div",15),g()),2&e&&(_("ngClass",Pr(10,lLe,i.useDarkMode,i.lineOnly))("resizeEventDebouncePeriodInMs",0),b(4),_("ngIf",!i.lineOnly),b(1),_("ngIf",i.showChartRendererElement),b(1),_("ngIf",!i.lineOnly),b(1),_("ngIf",i.customVisTemplate),b(3),_("ngIf",!i.lineOnly),b(3),_("ngIf",!i.lineOnly),b(1),_("ngIf",!i.lineOnly),b(1),_("ngIf",i.customChartOverlayTemplate))},dependencies:[bn,Fe,Mo,Hu,zte,jte,Gte,qf],styles:['[_nghost-%COMP%]{contain:strict;display:flex;flex-direction:column}[_nghost-%COMP%]     .line-chart:has(.horizontal-prospective-area:hover) .x-axis .extent-edit-button{visibility:visible}[_nghost-%COMP%]   .custom-vis[_ngcontent-%COMP%]{pointer-events:none}.container[_ngcontent-%COMP%]{background:inherit;display:grid;flex-grow:1;height:100%;overflow:hidden;width:100%;grid-template-areas:"yaxis series" "dot xaxis" ". customChartOverlay";grid-template-columns:50px 1fr;grid-auto-rows:1fr 30px 0px}.container.dark-mode[_ngcontent-%COMP%]{color:#fff}.container.line-only-mode[_ngcontent-%COMP%]{grid-template-columns:0 1fr;grid-auto-rows:1fr 0}.series-view[_ngcontent-%COMP%]{grid-area:series;position:relative;overflow:hidden}.series-view[_ngcontent-%COMP%]   .custom-vis[_ngcontent-%COMP%], .series-view[_ngcontent-%COMP%]   canvas[_ngcontent-%COMP%], .series-view[_ngcontent-%COMP%]   svg[_ngcontent-%COMP%], .series-view[_ngcontent-%COMP%]   line-chart-grid-view[_ngcontent-%COMP%], .series-view[_ngcontent-%COMP%]   line-chart-interactive-view[_ngcontent-%COMP%]{height:100%;left:0;position:absolute;top:0;width:100%}.x-axis[_ngcontent-%COMP%]   .custom-vis[_ngcontent-%COMP%], .y-axis[_ngcontent-%COMP%]   .custom-vis[_ngcontent-%COMP%]{height:100%;left:0;overflow:hidden;position:absolute;top:0;width:100%;-webkit-mask-image:linear-gradient(to right, rgba(0, 0, 0, 0) 0%, #000 10%, #000 90%, rgba(0, 0, 0, 0) 100%);mask-image:linear-gradient(to right, rgba(0, 0, 0, 0) 0%, #000 10%, #000 90%, rgba(0, 0, 0, 0) 100%)}.x-axis[_ngcontent-%COMP%]   line-chart-axis[_ngcontent-%COMP%], .y-axis[_ngcontent-%COMP%]   line-chart-axis[_ngcontent-%COMP%]{height:100%}.x-axis[_ngcontent-%COMP%]{grid-area:xaxis;position:relative}.y-axis[_ngcontent-%COMP%]{grid-area:yaxis}.dot[_ngcontent-%COMP%]{align-items:flex-start;display:flex;grid-area:dot;justify-content:flex-end}.dot[_ngcontent-%COMP%]   .rect[_ngcontent-%COMP%]{height:1px;width:1px;background-color:#aaa}.custom-chart-overlay-vis[_ngcontent-%COMP%]{grid-area:customChartOverlay;grid-row-end:2;grid-row-start:1}'],changeDetection:0}),n})();function cLe(n,t){1&n&&Ti(0)}var qte=function(n){return{$implicit:n}};function dLe(n,t){if(1&n&&(h(0,"div",4),S(1,cLe,1,0,"ng-container",5),T(2),g()),2&n){let e=w(),i=tt(6);b(1),_("ngTemplateOutlet",i)("ngTemplateOutletContext",Sn(3,qte,e.datum)),b(1),ze(" ",e.getFormattedDataForColumn()," ")}}function uLe(n,t){1&n&&Ti(0)}function pLe(n,t){if(1&n&&(h(0,"div",4),S(1,uLe,1,0,"ng-container",5),T(2),g()),2&n){let e=w(),i=tt(6);b(1),_("ngTemplateOutlet",i)("ngTemplateOutletContext",Sn(3,qte,e.datum)),b(1),ze(" ",e.getFormattedDataForColumn()," ")}}function fLe(n,t){if(1&n&&(h(0,"div",6),T(1),g()),2&n){let e=w();b(1),ze(" ",e.getFormattedDataForColumn()," ")}}function mLe(n,t){1&n&&P(0,"mat-icon",9)}function hLe(n,t){1&n&&P(0,"mat-icon",10)}function gLe(n,t){if(1&n&&(S(0,mLe,1,0,"mat-icon",7),S(1,hLe,1,0,"mat-icon",8)),2&n){let e=t.$implicit;_("ngIf",e>=0),b(1),_("ngIf",e<0)}}var _Le=["*"],M_=(()=>{class n{constructor(){this.contextMenuOpened=new L,this.ColumnHeaderType=vt}getFormattedDataForColumn(){if(void 0===this.datum)return"";switch(this.header.type){case vt.RUN:return this.datum;case vt.VALUE:case vt.STEP:case vt.SMOOTHED:case vt.START_STEP:case vt.END_STEP:case vt.START_VALUE:case vt.END_VALUE:case vt.MIN_VALUE:case vt.MAX_VALUE:case vt.STEP_AT_MAX:case vt.STEP_AT_MIN:case vt.MEAN:case vt.HPARAM:return"number"==typeof this.datum?I0.formatShort(this.datum):this.datum;case vt.TIME:return new Date(this.datum).toISOString();case vt.RELATIVE_TIME:return A0.formatReadable(this.datum);case vt.VALUE_CHANGE:return I0.formatShort(Math.abs(this.datum));case vt.PERCENTAGE_CHANGE:return Math.round(100*this.datum).toString()+"%";case vt.RAW_CHANGE:return cp.formatShort(Math.abs(this.datum));default:return""}}onContextMenuOpened(e){this.contextMenuOpened.emit(e)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["tb-data-table-content-cell"]],hostBindings:function(e,i){1&e&&D("contextmenu",function(o){return i.onContextMenuOpened(o)})},inputs:{header:"header",datum:"datum"},outputs:{contextMenuOpened:"contextMenuOpened"},ngContentSelectors:_Le,decls:7,vars:3,consts:[[3,"ngSwitch"],["class","cell",4,"ngSwitchCase"],["class","cell extra-right-padding",4,"ngSwitchDefault"],["arrow",""],[1,"cell"],[4,"ngTemplateOutlet","ngTemplateOutletContext"],[1,"cell","extra-right-padding"],["svgIcon","arrow_upward_24px",4,"ngIf"],["svgIcon","arrow_downward_24px",4,"ngIf"],["svgIcon","arrow_upward_24px"],["svgIcon","arrow_downward_24px"]],template:function(e,i){1&e&&(gn(),Tt(0,0),S(1,dLe,3,5,"div",1),S(2,pLe,3,5,"div",1),S(3,fLe,2,1,"div",2),Xt(4),Dt(),S(5,gLe,2,2,"ng-template",null,3,Zt)),2&e&&(_("ngSwitch",i.header.type),b(1),_("ngSwitchCase",i.ColumnHeaderType.VALUE_CHANGE),b(1),_("ngSwitchCase",i.ColumnHeaderType.PERCENTAGE_CHANGE))},dependencies:[Fe,Mo,$i,sr,fu,Dn],styles:["[_nghost-%COMP%]{display:table-cell;padding:4px}.cell[_ngcontent-%COMP%]{align-items:center;display:flex}.cell[_ngcontent-%COMP%]   mat-icon[_ngcontent-%COMP%]{height:12px;width:12px}.cell[_ngcontent-%COMP%]   mat-icon[_ngcontent-%COMP%]     path{fill:unset}.extra-right-padding[_ngcontent-%COMP%]{padding-right:1px}"],changeDetection:0}),n})(),yLe=["*"],uA=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["tb-data-table-content-row"]],ngContentSelectors:yLe,decls:1,vars:0,template:function(e,i){1&e&&(gn(),Xt(0))},styles:["[_nghost-%COMP%] {\n        display: table-row;\n      }"],changeDetection:0}),n})();function bLe(n,t){if(1&n&&P(0,"mat-icon",7),2&n){let e=w(2);_("ngClass",e.header.name===e.sortingInfo.name?"show":"show-on-hover")}}function vLe(n,t){if(1&n&&P(0,"mat-icon",8),2&n){let e=w(2);_("ngClass",e.header.name===e.sortingInfo.name?"show":"show-on-hover")}}function xLe(n,t){if(1&n&&(h(0,"div",4),S(1,bLe,1,1,"mat-icon",5),S(2,vLe,1,1,"mat-icon",6),g()),2&n){let e=w();b(1),_("ngIf",e.sortingInfo.order===e.SortingOrder.ASCENDING||e.header.name!==e.sortingInfo.name),b(1),_("ngIf",e.sortingInfo.order===e.SortingOrder.DESCENDING&&e.header.name===e.sortingInfo.name)}}function CLe(n,t){if(1&n){let e=ge();h(0,"div",9)(1,"mat-icon",10),D("click",function(r){return X(e),Q(w().onContextMenuOpened(r))}),g()()}}var MLe=["*"],w_=(()=>{class n{constructor(){this.hparamsEnabled=!1,this.disableContextMenu=!1,this.dragStart=new L,this.dragEnd=new L,this.dragEnter=new L,this.headerClicked=new L,this.contextMenuOpened=new L,this.highlightStyle$=new Ri({}),this.SortingOrder=so}onContextMenuOpened(e){this.disableContextMenu||this.contextMenuOpened.emit(e)}headerClickedHandler(){this.header.sortable&&this.headerClicked.emit(this.header.name)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["tb-data-table-header-cell"]],hostBindings:function(e,i){1&e&&D("contextmenu",function(o){return i.onContextMenuOpened(o)})},inputs:{header:"header",sortingInfo:"sortingInfo",hparamsEnabled:"hparamsEnabled",disableContextMenu:"disableContextMenu"},outputs:{dragStart:"dragStart",dragEnd:"dragEnd",dragEnter:"dragEnter",headerClicked:"headerClicked",contextMenuOpened:"contextMenuOpened"},ngContentSelectors:MLe,decls:6,vars:7,consts:[[1,"cell",3,"draggable","ngClass","dragstart","dragend","dragenter","click"],[3,"header"],["class","sorting-icon-container",4,"ngIf"],["class","context-menu-container show-on-hover",4,"ngIf"],[1,"sorting-icon-container"],["svgIcon","arrow_upward_24px",3,"ngClass",4,"ngIf"],["svgIcon","arrow_downward_24px",3,"ngClass",4,"ngIf"],["svgIcon","arrow_upward_24px",3,"ngClass"],["svgIcon","arrow_downward_24px",3,"ngClass"],[1,"context-menu-container","show-on-hover"],["svgIcon","more_vert_24px",3,"click"]],template:function(e,i){1&e&&(gn(),h(0,"div",0),D("dragstart",function(){return i.dragStart.emit(i.header)})("dragend",function(){return i.dragEnd.emit()})("dragenter",function(){return i.dragEnter.emit(i.header)})("click",function(){return i.headerClickedHandler()}),G(1,"async"),Xt(2),P(3,"tb-data-table-header",1),S(4,xLe,3,2,"div",2),S(5,CLe,2,0,"div",3),g()),2&e&&(_("draggable",i.header.movable)("ngClass",W(1,5,i.highlightStyle$)),b(3),_("header",i.header),b(1),_("ngIf",i.header.sortable),b(1),_("ngIf",(i.header.removable||i.header.sortable)&&!i.disableContextMenu))},dependencies:[bn,Fe,Dn,qT,lt],styles:["[_nghost-%COMP%]{display:table-cell;padding:2px;vertical-align:bottom}[_nghost-%COMP%]:hover   .show-on-hover[_ngcontent-%COMP%]{opacity:.3}[_nghost-%COMP%]   .show-on-hover[_ngcontent-%COMP%]:hover{opacity:1}.sorting-icon-container[_ngcontent-%COMP%], .context-menu-container[_ngcontent-%COMP%]{width:12px;height:12px;border-radius:5px}.cell[_ngcontent-%COMP%]{align-items:center;display:flex}.cell[_ngcontent-%COMP%]   mat-icon[_ngcontent-%COMP%]{height:12px;width:12px}.cell[_ngcontent-%COMP%]   .sorting-icon-container[_ngcontent-%COMP%]     path{fill:unset}.show[_ngcontent-%COMP%]{opacity:1}.show-on-hover[_ngcontent-%COMP%]{opacity:0}.highlight[_ngcontent-%COMP%]{background-color:#eee}.highlight-border-right[_ngcontent-%COMP%]{border-right:2px solid #ff9800}.highlight-border-left[_ngcontent-%COMP%]{border-left:2px solid #ff9800}"],changeDetection:0}),n})(),wLe=["content"];function SLe(n,t){1&n&&(Tt(0),Xt(1),Dt())}var ELe=["*"],Zte=(()=>{class n{constructor(e){this.viewRef=e,this.onOpen=new L,this.onClose=new L,this.visible$=new Ri(!1),this.canClose=!0,this.clickListener=this.maybeClose.bind(this)}ngOnInit(){this.visible$.subscribe(e=>{window.requestAnimationFrame(()=>{this.canClose=!0,e?(this.ensureContentIsWithinWindow(),this.onOpen.emit()):this.onClose.emit()})})}openAtPosition(e){let i=this.viewRef.element.nativeElement,r=i.getBoundingClientRect().top;0!==r&&(i.style.top=-1*r+i.offsetTop+"px"),this.content.nativeElement.style.left=e.x+"px",this.content.nativeElement.style.top=e.y+"px",this.canClose=!1,this.visible$.next(!0),document.addEventListener("click",this.clickListener)}ensureContentIsWithinWindow(){if(!this.content)return;let e=this.content.nativeElement.getBoundingClientRect();e.left<0&&(this.content.nativeElement.style.left=0),e.left+e.width>window.innerWidth&&(this.content.nativeElement.style.left=window.innerWidth-e.width+"px"),e.top<0&&(this.content.nativeElement.style.top=0),e.top+e.height>window.innerHeight&&(this.content.nativeElement.style.top=window.innerHeight-e.height+"px")}maybeClose(){!this.canClose||this.close()}close(){document.removeEventListener("click",this.clickListener),this.visible$.next(!1)}}return n.\u0275fac=function(e){return new(e||n)(C(Zn))},n.\u0275cmp=k({type:n,selectors:[["custom-modal"]],viewQuery:function(e,i){if(1&e&&Ye(wLe,5),2&e){let r;we(r=Se())&&(i.content=r.first)}},hostBindings:function(e,i){1&e&&D("keydown.escape",function(o){return i.maybeClose(o)},0,uc)},outputs:{onOpen:"onOpen",onClose:"onClose"},ngContentSelectors:ELe,decls:4,vars:3,consts:[[1,"content",3,"click"],["content",""],[4,"ngIf"]],template:function(e,i){1&e&&(gn(),h(0,"div",0,1),D("click",function(o){return o.stopPropagation()}),S(2,SLe,2,0,"ng-container",2),G(3,"async"),g()),2&e&&(b(2),_("ngIf",W(3,1,i.visible$)))},dependencies:[Fe,lt],styles:["[_nghost-%COMP%] {\n        position: fixed;\n        left: 0;\n        z-index: 9001;\n      }\n\n      .content[_ngcontent-%COMP%] {\n        position: absolute;\n      }"]}),n})(),DLe=["search"],ILe=["columnList"],ALe=function(n){return{selected:n}};function RLe(n,t){if(1&n){let e=ge();h(0,"button",8),D("click",function(){let o=X(e).$implicit;return Q(w().selectColumn(o))}),G(1,"async"),T(2),g()}if(2&n){let e=t.$implicit,i=t.index,r=w();_("ngClass",Sn(4,ALe,i===W(1,2,r.selectedIndex$))),b(2),ze(" ",e.displayName," ")}}var pA=(()=>{class n{constructor(){this.selectableColumns=[],this.columnSelected=new L,this.searchInput="",this.selectedIndex$=new Ri(0),this.isActive=!1}ngOnInit(){this.selectedIndex$.subscribe(()=>{if(!this.columnList)return;let e=this.columnList.nativeElement.querySelector("button.selected");if(!e)return;let i=this.columnList.nativeElement.getBoundingClientRect().height,r=e.getBoundingClientRect().height,o=this.columnList.nativeElement.scrollTop;this.selectedIndex$.getValue()*r<o&&(this.columnList.nativeElement.scrollTop=this.selectedIndex$.getValue()*r),(this.selectedIndex$.getValue()+1)*r>o+i&&(this.columnList.nativeElement.scrollTop=(this.selectedIndex$.getValue()+1)*r-i)})}ngAfterViewInit(){this.searchInput="",this.searchField.nativeElement.focus(),this.selectedIndex$.next(0)}focus(){this.searchField?.nativeElement.focus()}getFilteredColumns(){return this.selectableColumns.filter(e=>e.name.toLowerCase().match(this.searchInput.toLowerCase())||e.displayName.toLowerCase().match(this.searchInput.toLowerCase()))}searchInputChanged(){this.selectedIndex$.next(Math.min(this.selectedIndex$.getValue(),this.selectableColumns.length-1))}selectColumn(e){this.selectedIndex$.next(0),this.columnSelected.emit(e)}activate(){this.isActive=!0}deactivate(){this.isActive=!1}onUpArrow(){!this.isActive||this.selectedIndex$.next(Math.max(this.selectedIndex$.getValue()-1,0))}onDownArrow(){!this.isActive||this.selectedIndex$.next(Math.min(this.selectedIndex$.getValue()+1,this.getFilteredColumns().length-1))}onEnterPressed(){!this.isActive||this.selectColumn(this.getFilteredColumns()[this.selectedIndex$.getValue()])}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["tb-data-table-column-selector-component"]],viewQuery:function(e,i){if(1&e&&(Ye(DLe,5),Ye(ILe,5)),2&e){let r;we(r=Se())&&(i.searchField=r.first),we(r=Se())&&(i.columnList=r.first)}},hostBindings:function(e,i){1&e&&D("keydown.arrowup",function(o){return i.onUpArrow(o)},0,uc)("keydown.arrowdown",function(o){return i.onDownArrow(o)},!1,uc)("keydown.enter",function(o){return i.onEnterPressed(o)},!1,uc)},inputs:{selectableColumns:"selectableColumns"},outputs:{columnSelected:"columnSelected"},decls:8,vars:2,consts:[[1,"contents"],[1,"search-area"],["matPrefix","","svgIcon","search_24px",1,"search-icon"],["matInput","","placeholder","Search",3,"ngModel","ngModelChange"],["search",""],[1,"column-list"],["columnList",""],["mat-button","","class","column-button",3,"ngClass","click",4,"ngFor","ngForOf"],["mat-button","",1,"column-button",3,"ngClass","click"]],template:function(e,i){1&e&&(h(0,"div",0)(1,"mat-form-field",1),P(2,"mat-icon",2),h(3,"input",3,4),D("ngModelChange",function(o){return i.searchInput=o})("ngModelChange",function(){return i.searchInputChanged()}),g()(),h(5,"div",5,6),S(7,RLe,3,6,"button",7),g()()),2&e&&(b(3),_("ngModel",i.searchInput),b(4),_("ngForOf",i.getFilteredColumns()))},dependencies:[bn,dn,Dn,Ys,S9,qu,Fn,Ig,pE,iL,lt],styles:[".contents[_ngcontent-%COMP%]{display:flex;flex-direction:column;align-items:flex-start;padding:8px;border-radius:4px;border:1px solid;box-shadow:0px 4px 4px rgba(0,0,0,.25);border-color:#ebebeb;background-color:#fff}body.dark-mode[_nghost-%COMP%]   .contents[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .contents[_ngcontent-%COMP%]{border-color:#555;background-color:#303030}.contents[_ngcontent-%COMP%]   .search-area[_ngcontent-%COMP%]{margin-bottom:4px}.contents[_ngcontent-%COMP%]   .search-area[_ngcontent-%COMP%]   mat-icon.search-icon[_ngcontent-%COMP%]{font-size:1em}.contents[_ngcontent-%COMP%]   .search-area[_ngcontent-%COMP%]   mat-icon.search-icon[_ngcontent-%COMP%]     svg{padding-top:6px}.contents[_ngcontent-%COMP%]   .column-list[_ngcontent-%COMP%]{display:flex;flex-direction:column;width:100%;max-height:200px;overflow-y:scroll}.contents[_ngcontent-%COMP%]   .column-button[_ngcontent-%COMP%]{text-align:left;width:100%}.contents[_ngcontent-%COMP%]   .column-button.selected[_ngcontent-%COMP%]{background-color:#eee}body.dark-mode[_nghost-%COMP%]   .contents[_ngcontent-%COMP%]   .column-button.selected[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .contents[_ngcontent-%COMP%]   .column-button.selected[_ngcontent-%COMP%]{background-color:#bdbdbd}"],changeDetection:0}),n})(),PLe=["columnSelectorModal"],OLe=["contextMenu"];function FLe(n,t){1&n&&(h(0,"div",11),T(1," No Actions Available "),g())}function LLe(n,t){if(1&n){let e=ge();h(0,"button",12),D("click",function(){return X(e),Q(w().contextMenuRemoveColumn())}),P(1,"mat-icon",13),T(2,"Remove "),g()}}function NLe(n,t){1&n&&(Tt(0),P(1,"mat-icon",17),T(2,"Sort Descending "),Dt())}function BLe(n,t){1&n&&(P(0,"mat-icon",18),T(1,"Sort Ascending "))}function VLe(n,t){if(1&n){let e=ge();h(0,"button",14),D("click",function(){X(e);let r=w();return Q(r.sortByHeader(null==r.contextMenuHeader?null:r.contextMenuHeader.name))}),S(1,NLe,3,0,"ng-container",15),S(2,BLe,2,0,"ng-template",null,16,Zt),g()}if(2&n){let e=tt(3),i=w();b(1),_("ngIf",i.sortingInfo.order===i.SortingOrder.ASCENDING&&i.sortingInfo.name===(null==i.contextMenuHeader?null:i.contextMenuHeader.name))("ngIfElse",e)}}function HLe(n,t){if(1&n){let e=ge();h(0,"button",12),D("click",function(r){X(e);let o=w();return Q(o.openColumnSelector(r,{insertTo:o.Side.LEFT,isSubMenu:!0}))}),P(1,"mat-icon",19),T(2,"Insert Column Left "),g()}}function zLe(n,t){if(1&n){let e=ge();h(0,"button",12),D("click",function(r){X(e);let o=w();return Q(o.openColumnSelector(r,{insertTo:o.Side.RIGHT,isSubMenu:!0}))}),P(1,"mat-icon",19),T(2,"Insert Column Right "),g()}}function ULe(n,t){if(1&n){let e=ge();h(0,"custom-modal",20,21),D("onOpen",function(){return X(e),Q(w().focusColumnSelector())}),h(2,"tb-data-table-column-selector-component",22),D("columnSelected",function(r){return X(e),Q(w().onColumnAdded(r))}),g()()}if(2&n){let e=w();b(2),_("selectableColumns",e.selectableColumns)}}function jLe(n,t){if(1&n){let e=ge();h(0,"div",23)(1,"button",24),D("click",function(r){return X(e),Q(w().openColumnSelector(r))}),P(2,"mat-icon",19),g()()}}var GLe=[[["","header",""]],[["","content",""]]],WLe=["[header]","[content]"],Kl=(()=>(function(n){n[n.RIGHT=0]="RIGHT",n[n.LEFT=1]="LEFT"}(Kl||(Kl={})),Kl))(),WV=function(n){n.preventDefault()},fA=(()=>{class n{constructor(){this.headerCellSubscriptions=[],this.contentCellSubscriptions=[],this.contextMenuHeader=void 0,this.insertColumnTo=void 0,this.sortDataBy=new L,this.orderColumns=new L,this.removeColumn=new L,this.addColumn=new L,this.ColumnHeaders=vt,this.SortingOrder=so,this.Side=Kl,this.highlightSide=Kl.RIGHT}ngOnDestroy(){document.removeEventListener("dragover",WV),this.headerCellSubscriptions.forEach(e=>{e.unsubscribe()})}ngAfterContentInit(){this.syncHeaders(),this.headerCells.changes.subscribe(this.syncHeaders.bind(this)),this.syncContent(),this.contentCells.changes.subscribe(this.syncContent.bind(this))}syncHeaders(){this.headerCellSubscriptions.forEach(e=>{e.unsubscribe()}),this.headerCellSubscriptions=[],this.headerCells.forEach(e=>{this.headerCellSubscriptions.push(e.dragStart.subscribe(this.dragStart.bind(this)),e.dragEnter.subscribe(this.dragEnter.bind(this)),e.dragEnd.subscribe(this.dragEnd.bind(this)),e.headerClicked.subscribe(this.sortByHeader.bind(this)),e.contextMenuOpened.subscribe(this.openContextMenu.bind(this,e.header)))})}syncContent(){this.contentCellSubscriptions.forEach(e=>{e.unsubscribe()}),this.contentCellSubscriptions=this.contentCells.map(e=>[e.contextMenuOpened.subscribe(this.openContextMenu.bind(this,e.header))]).flat()}sortByHeader(e){this.sortDataBy.emit(this.sortingInfo.name!==e||this.sortingInfo.order!==so.ASCENDING?{name:e,order:so.ASCENDING}:{name:e,order:so.DESCENDING})}dragStart(e){this.draggingHeaderName=e.name,document.addEventListener("dragover",WV)}dragEnd(){!this.draggingHeaderName||!this.highlightedColumnName||(this.orderColumns.emit(this.moveHeader(this.getIndexOfHeaderWithName(this.draggingHeaderName),this.getIndexOfHeaderWithName(this.highlightedColumnName))),this.draggingHeaderName=void 0,this.highlightedColumnName=void 0,document.removeEventListener("dragover",WV),this.headerCells.forEach(e=>{e.highlightStyle$.next({})}))}dragEnter(e){!this.draggingHeaderName||(this.highlightSide=this.getIndexOfHeaderWithName(e.name)<this.getIndexOfHeaderWithName(this.draggingHeaderName)?Kl.LEFT:Kl.RIGHT,this.highlightedColumnName=e.name,this.headerCells.forEach(i=>{i.highlightStyle$.next(this.getHeaderHighlightStyle(i.header.name))}))}moveHeader(e,i){let r=[...this.headers];return r.splice(e,1),r.splice(i,0,this.headers[e]),r}getHeaderHighlightStyle(e){return e!==this.highlightedColumnName?{}:{highlight:!0,"highlight-border-right":this.highlightSide===Kl.RIGHT,"highlight-border-left":this.highlightSide===Kl.LEFT}}getIndexOfHeaderWithName(e){return this.headers.findIndex(i=>e===i.name)}focusColumnSelector(){this.columnSelector.focus()}openContextMenu(e,i){i.stopPropagation(),i.preventDefault(),this.columnSelectorModal.close(),this.contextMenuHeader=e,this.contextMenu.openAtPosition({x:i.clientX,y:i.clientY})}onContextMenuClosed(){this.contextMenuHeader=void 0}openColumnSelector(e,i){i?.isSubMenu&&e.stopPropagation(),this.insertColumnTo=i?.insertTo;let r=e.target.getBoundingClientRect();this.columnSelectorModal.openAtPosition({x:r.x+r.width,y:r.y+r.height}),this.columnSelector.activate()}onColumnSelectorClosed(){this.insertColumnTo=void 0,this.columnSelector.deactivate()}canContextMenuRemoveColumn(){return this.contextMenuHeader?.removable}canContextMenuInsert(){return this.selectableColumns&&this.selectableColumns.length&&this.contextMenuHeader?.movable}contextMenuRemoveColumn(){void 0!==this.contextMenuHeader&&(this.removeColumn.emit(this.contextMenuHeader),this.contextMenu.close())}getInsertIndex(){if(void 0===this.contextMenuHeader||void 0===this.insertColumnTo)return;let e=this.headers.indexOf(this.contextMenuHeader);return this.insertColumnTo===Kl.LEFT?e:this.insertColumnTo===Kl.RIGHT?Math.min(e+1,this.headers.length):e}onColumnAdded(e){this.addColumn.emit({header:e,index:this.getInsertIndex()})}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["tb-data-table"]],contentQueries:function(e,i,r){if(1&e&&(ci(r,w_,4),ci(r,M_,5)),2&e){let o;we(o=Se())&&(i.headerCells=o),we(o=Se())&&(i.contentCells=o)}},viewQuery:function(e,i){if(1&e&&(Ye(PLe,5),Ye(pA,5),Ye(OLe,5)),2&e){let r;we(r=Se())&&(i.columnSelectorModal=r.first),we(r=Se())&&(i.columnSelector=r.first),we(r=Se())&&(i.contextMenu=r.first)}},inputs:{headers:"headers",sortingInfo:"sortingInfo",columnCustomizationEnabled:"columnCustomizationEnabled",selectableColumns:"selectableColumns"},outputs:{sortDataBy:"sortDataBy",orderColumns:"orderColumns",removeColumn:"removeColumn",addColumn:"addColumn"},ngContentSelectors:WLe,decls:14,vars:7,consts:[[3,"onClose"],["contextMenu",""],[1,"context-menu"],["class","no-actions-message",4,"ngIf"],["class","context-menu-button","mat-button","",3,"click",4,"ngIf"],["class","context-menu-button sort-button","mat-button","",3,"click",4,"ngIf"],["mat-button","","class","context-menu-button",3,"click",4,"ngIf"],["onClose","onColumnSelectorClosed()",3,"onOpen",4,"ngIf"],[1,"data-table"],[1,"header"],["class","add-button-cell",4,"ngIf"],[1,"no-actions-message"],["mat-button","",1,"context-menu-button",3,"click"],["svgIcon","close_24px"],["mat-button","",1,"context-menu-button","sort-button",3,"click"],[4,"ngIf","ngIfElse"],["descending",""],["svgIcon","arrow_downward_24px"],["svgIcon","arrow_upward_24px"],["svgIcon","add_24px"],["onClose","onColumnSelectorClosed()",3,"onOpen"],["columnSelectorModal",""],[3,"selectableColumns","columnSelected"],[1,"add-button-cell"],["mat-icon-button","","title","Add Column",1,"add-column-btn",3,"click"]],template:function(e,i){1&e&&(gn(GLe),h(0,"custom-modal",0,1),D("onClose",function(){return i.onContextMenuClosed()}),h(2,"div",2),S(3,FLe,2,0,"div",3),S(4,LLe,3,0,"button",4),S(5,VLe,4,2,"button",5),S(6,HLe,3,0,"button",6),S(7,zLe,3,0,"button",6),g()(),S(8,ULe,3,1,"custom-modal",7),h(9,"div",8)(10,"div",9),Xt(11),S(12,jLe,3,0,"div",10),g(),Xt(13,1),g()),2&e&&(b(3),_("ngIf",!(null!=i.contextMenuHeader&&i.contextMenuHeader.removable||null!=i.contextMenuHeader&&i.contextMenuHeader.sortable||i.canContextMenuInsert())),b(1),_("ngIf",null==i.contextMenuHeader?null:i.contextMenuHeader.removable),b(1),_("ngIf",null==i.contextMenuHeader?null:i.contextMenuHeader.sortable),b(1),_("ngIf",i.canContextMenuInsert()),b(1),_("ngIf",i.canContextMenuInsert()),b(1),_("ngIf",i.selectableColumns&&i.selectableColumns.length),b(4),_("ngIf",i.selectableColumns&&i.selectableColumns.length))},dependencies:[Fe,Dn,Fn,Zte,pA],styles:[".data-table[_ngcontent-%COMP%]{font-size:13px;display:table;width:100%}.data-table[_ngcontent-%COMP%]   .header[_ngcontent-%COMP%]{display:table-row;z-index:1}.data-table[_ngcontent-%COMP%]   .header[_ngcontent-%COMP%]{background-color:#fff;position:sticky;text-align:left;top:0;font-weight:bold;vertical-align:bottom}.data-table[_ngcontent-%COMP%]   .header[_ngcontent-%COMP%]:hover{cursor:pointer}body.dark-mode[_nghost-%COMP%]   .data-table[_ngcontent-%COMP%]   .header[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .data-table[_ngcontent-%COMP%]   .header[_ngcontent-%COMP%]{background-color:#303030}.add-button-cell[_ngcontent-%COMP%]{display:table-cell;width:40px}.context-menu[_ngcontent-%COMP%]{border-radius:4px;border:1px solid;box-shadow:0px 4px 4px rgba(0,0,0,.25);border-color:#ebebeb;background-color:#fff}body.dark-mode[_nghost-%COMP%]   .context-menu[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .context-menu[_ngcontent-%COMP%]{border-color:#555;background-color:#303030}.context-menu[_ngcontent-%COMP%]   .context-menu-button[_ngcontent-%COMP%]{text-align:left;width:100%}.context-menu[_ngcontent-%COMP%]   .no-actions-message[_ngcontent-%COMP%]{padding:8px;text-wrap:nowrap}.context-menu[_ngcontent-%COMP%]   .sort-button[_ngcontent-%COMP%]     path{fill:unset}"],changeDetection:0}),n})();function qLe(n,t){if(1&n&&P(0,"tb-data-table-header-cell",5),2&n){let e=w().$implicit,i=w();_("header",e)("sortingInfo",i.sortingInfo)("hparamsEnabled",i.hparamsEnabled)}}function YLe(n,t){if(1&n&&(Tt(0),S(1,qLe,1,3,"tb-data-table-header-cell",4),Dt()),2&n){let e=t.$implicit,i=w();b(1),_("ngIf",e.enabled&&(e.type!==i.ColumnHeaderType.SMOOTHED||i.smoothingEnabled))}}function XLe(n,t){if(1&n&&(h(0,"div",9),P(1,"span"),g()),2&n){let e=w(3).$implicit;b(1),Mt("background-color",e.color)}}function QLe(n,t){if(1&n&&(h(0,"tb-data-table-content-cell",7),S(1,XLe,2,2,"div",8),g()),2&n){let e=w().$implicit,i=w().$implicit,r=w();_("header",e)("datum",i[e.name]),b(1),_("ngIf",e.type===r.ColumnHeaderType.COLOR)}}function ZLe(n,t){if(1&n&&(Tt(0),S(1,QLe,2,3,"tb-data-table-content-cell",6),Dt()),2&n){let e=t.$implicit,i=w(2);b(1),_("ngIf",e.enabled&&(e.type!==i.ColumnHeaderType.SMOOTHED||i.smoothingEnabled))}}function KLe(n,t){if(1&n&&(Tt(0),h(1,"tb-data-table-content-row"),S(2,ZLe,2,1,"ng-container",2),g(),Dt()),2&n){let e=w();b(2),_("ngForOf",e.getHeaders())}}var $te=(()=>{class n{constructor(){this.sortDataBy=new L,this.editColumnHeaders=new L,this.removeColumn=new L,this.ColumnHeaderType=vt}getHeaders(){return[{name:"color",displayName:"",type:vt.COLOR,enabled:!0}].concat(this.columnHeaders)}getMinPointInRange(e,i,r){let o=e[i].y,a=e[i];for(let s=i;s<=r;s++)o>e[s].y&&(o=e[s].y,a=e[s]);return a}getMaxPointInRange(e,i,r){let o=e[i].y,a=e[i];for(let s=i;s<=r;s++)o<e[s].y&&(o=e[s].y,a=e[s]);return a}getMean(e,i,r){let o=0;for(let a=i;a<=r;a++)o+=e[a].value;return o/(r-i+1)}getTimeSelectionTableData(){if(!this.stepOrLinkedTimeSelection)return[];let e=this.stepOrLinkedTimeSelection.start.step,i=this.stepOrLinkedTimeSelection.end?.step,r=this.dataSeries.filter(a=>qS(a,this.chartMetadataMap)).map(a=>{let s=this.chartMetadataMap[a.id],l=tC(a.points,e),c=a.points[l],d=null,u=null;null!=i&&(u=tC(a.points,i),d=a.points[u]);let p={id:a.id,color:s.color};for(let f of this.columnHeaders)switch(f.type){case vt.RUN:let m="";s.alias&&(m=`${s.alias.aliasNumber} ${s.alias.aliasText}/`),p[f.name]=`${m}${s.displayName}`;continue;case vt.STEP:p[f.name]=c.step;continue;case vt.VALUE:p[f.name]=c.value;continue;case vt.RELATIVE_TIME:p[f.name]=c.relativeTimeInMs;continue;case vt.SMOOTHED:p[f.name]=c.y;continue;case vt.VALUE_CHANGE:if(!d)continue;p[f.name]=d.y-c.y;continue;case vt.START_STEP:p[f.name]=c.step;continue;case vt.END_STEP:if(!d)continue;p[f.name]=d.step;continue;case vt.START_VALUE:p[f.name]=c.y;continue;case vt.END_VALUE:if(!d)continue;p[f.name]=d.y;continue;case vt.MIN_VALUE:if(!u)continue;p[f.name]=this.getMinPointInRange(a.points,l,u).y;continue;case vt.MAX_VALUE:if(!u)continue;p[f.name]=this.getMaxPointInRange(a.points,l,u).y;continue;case vt.PERCENTAGE_CHANGE:if(!d)continue;p[f.name]=(d.y-c.y)/c.y;continue;case vt.STEP_AT_MAX:if(!u)continue;p[f.name]=this.getMaxPointInRange(a.points,l,u).step;continue;case vt.STEP_AT_MIN:if(!u)continue;p[f.name]=this.getMinPointInRange(a.points,l,u).step;continue;case vt.MEAN:if(!u)continue;p[f.name]=this.getMean(a.points,l,u);continue;case vt.RAW_CHANGE:if(!d)continue;p[f.name]=d.value-c.value;continue;default:continue}return p}),o=this.columnHeaders.find(a=>a.name===this.sortingInfo.name);return void 0!==o&&r.sort((a,s)=>{if(!o)return 0;let l=this.getSortableValue(a,o),c=this.getSortableValue(s,o);return l<c?this.sortingInfo.order===so.ASCENDING?-1:1:l>c?this.sortingInfo.order===so.ASCENDING?1:-1:0}),r}getSortableValue(e,i){return function(n){return"object"==typeof n||Number.isNaN(n)||"NaN"===n||null==n?-1/0:n}(i.type===vt.RUN?this.chartMetadataMap[e.id].displayName:e[i.name])}orderColumns(e){this.editColumnHeaders.emit({headers:e,dataTableMode:this.stepOrLinkedTimeSelection.end?lo.RANGE:lo.SINGLE})}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["scalar-card-data-table"]],inputs:{chartMetadataMap:"chartMetadataMap",dataSeries:"dataSeries",stepOrLinkedTimeSelection:"stepOrLinkedTimeSelection",columnHeaders:"columnHeaders",sortingInfo:"sortingInfo",columnCustomizationEnabled:"columnCustomizationEnabled",smoothingEnabled:"smoothingEnabled",hparamsEnabled:"hparamsEnabled"},outputs:{sortDataBy:"sortDataBy",editColumnHeaders:"editColumnHeaders",removeColumn:"removeColumn"},decls:5,vars:5,consts:[[3,"headers","sortingInfo","columnCustomizationEnabled","sortDataBy","orderColumns","removeColumn"],["header",""],[4,"ngFor","ngForOf"],["content",""],["disableContextMenu","true",3,"header","sortingInfo","hparamsEnabled",4,"ngIf"],["disableContextMenu","true",3,"header","sortingInfo","hparamsEnabled"],[3,"header","datum",4,"ngIf"],[3,"header","datum"],["class","row-circle",4,"ngIf"],[1,"row-circle"]],template:function(e,i){1&e&&(h(0,"tb-data-table",0),D("sortDataBy",function(o){return i.sortDataBy.emit(o)})("orderColumns",function(o){return i.orderColumns(o)})("removeColumn",function(o){return i.removeColumn.emit(o)}),Tt(1,1),S(2,YLe,2,1,"ng-container",2),Dt(),Tt(3,3),S(4,KLe,3,1,"ng-container",2),Dt(),g()),2&e&&(_("headers",i.columnHeaders)("sortingInfo",i.sortingInfo)("columnCustomizationEnabled",i.columnCustomizationEnabled),b(2),_("ngForOf",i.getHeaders()),b(2),_("ngForOf",i.getTimeSelectionTableData()))},dependencies:[dn,Fe,M_,uA,fA,w_],styles:[".row-circle[_ngcontent-%COMP%]{height:12px;width:12px}.row-circle[_ngcontent-%COMP%] > span[_ngcontent-%COMP%]{border-radius:50%;border:1px solid rgba(255,255,255,.4);display:inline-block;height:10px;width:10px;vertical-align:middle}"],changeDetection:0}),n})();var $Le=["stepSpan"];function eNe(n,t){if(1&n){let e=ge();h(0,"button",4),D("click",function(){return X(e),Q(w().fobRemoved.emit())}),P(1,"mat-icon",5),g()}}function tNe(n,t){if(1&n){let e=ge();h(0,"button",4),D("click",function(){return X(e),Q(w().fobRemoved.emit())}),P(1,"mat-icon",6),g()}}var nNe=function(n,t){return{fob:!0,unremovable:n,prospective:t}},ene=(()=>{class n{constructor(){this.allowRemoval=!0,this.isProspective=!1,this.stepChanged=new L,this.fobRemoved=new L}ngOnChanges(e){e.step&&document.activeElement===this.stepSpan.nativeElement&&this.stepSpan.nativeElement.blur()}validateStep(e){let i=String.fromCharCode(e.which);(" "===e.key||isNaN(Number(i)))&&e.preventDefault()}stepTyped(e){e.preventDefault();let i=e.target.innerText;this.stepChanged.emit(""!==i?Number(i):null)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["card-fob"]],viewQuery:function(e,i){if(1&e&&Ye($Le,7,be),2&e){let r;we(r=Se())&&(i.stepSpan=r.first)}},inputs:{step:"step",allowRemoval:"allowRemoval",isProspective:"isProspective"},outputs:{stepChanged:"stepChanged",fobRemoved:"fobRemoved"},features:[Gt],decls:5,vars:7,consts:[[3,"ngClass"],["contenteditable","","role","textbox","aria-label","Edit step",3,"innerHTML","blur","keypress","keydown.enter","keydown.shift.enter"],["stepSpan",""],["aria-label","Deselect fob",3,"click",4,"ngIf"],["aria-label","Deselect fob",3,"click"],["svgIcon","close_24px"],["svgIcon","keep_24px"]],template:function(e,i){1&e&&(h(0,"div",0)(1,"span",1,2),D("blur",function(o){return i.stepTyped(o)})("keypress",function(o){return i.validateStep(o)})("keydown.enter",function(o){return i.stepTyped(o)})("keydown.shift.enter",function(o){return o.preventDefault()}),g(),S(3,eNe,2,0,"button",3),S(4,tNe,2,0,"button",3),g()),2&e&&(_("ngClass",Pr(4,nNe,!i.allowRemoval,i.isProspective)),b(1),_("innerHTML",i.step,bP),b(2),_("ngIf",i.allowRemoval),b(1),_("ngIf",i.isProspective))},dependencies:[bn,Fe,Dn],styles:["[_nghost-%COMP%]{display:inline-block}.fob[_ngcontent-%COMP%]{display:inline-flex;background-color:#e0e0e0;border-radius:25px;padding:2px 2px 2px 4px;font-size:11px;text-align:center;width:min-content}.fob[_ngcontent-%COMP%] > .prospective[_ngcontent-%COMP%]{padding-top:1px}.fob[_ngcontent-%COMP%]:hover{cursor:grab}.fob[_ngcontent-%COMP%]:hover.prospective{cursor:pointer}.fob[_ngcontent-%COMP%]:active{cursor:grabbing}.fob.unremovable[_ngcontent-%COMP%]{padding:2px 4px}.fob.prospective[_ngcontent-%COMP%]{align-items:center;box-sizing:border-box;border:1px dashed #9e9e9e;font-weight:bold;height:17px}span[_ngcontent-%COMP%]{color:inherit;display:inline-block}body.dark-mode[_nghost-%COMP%]   span[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   span[_ngcontent-%COMP%]{color:#616161}button[_ngcontent-%COMP%]{margin-left:2px;padding:0;border:0;border-radius:50%;font-size:11px;width:11px;height:11px;background-color:inherit;color:inherit}button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{width:100%;height:110%}body.dark-mode[_nghost-%COMP%]   button[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   button[_ngcontent-%COMP%]{color:#616161}button[_ngcontent-%COMP%]:hover{background-color:#9e9e9e;color:#eee;cursor:pointer}body.dark-mode[_nghost-%COMP%]   button[_ngcontent-%COMP%]:hover, body.dark-mode   [_nghost-%COMP%]   button[_ngcontent-%COMP%]:hover{background-color:#616161;color:#e0e0e0}"],changeDetection:0}),n})(),rNe=["startFobWrapper"],oNe=["endFobWrapper"],aNe=["prospectiveFobWrapper"];function sNe(n,t){1&n&&P(0,"div",6)}function lNe(n,t){if(1&n&&(h(0,"div",2,3),S(2,sNe,1,0,"div",4),P(3,"card-fob",5),g()),2&n){let e=w();Mt("transform",e.getCssTranslatePxForProspectiveFob()),b(2),_("ngIf",e.showExtendedLine),b(1),_("ngClass",e.isVertical()?"vertical-fob":"horizontal-fob")("allowRemoval",!1)("isProspective",!0)("step",e.prospectiveStep)}}function cNe(n,t){if(1&n){let e=ge();h(0,"div",10),D("mousedown",function(r){X(e);let o=w(2);return Q(o.startDrag(o.Fob.START,o.TimeSelectionAffordance.EXTENDED_LINE,r))}),g()}}function dNe(n,t){if(1&n){let e=ge();h(0,"div",2,7),S(2,cNe,1,0,"div",8),h(3,"card-fob",9),D("mousedown",function(r){X(e);let o=w();return Q(o.startDrag(o.Fob.START,o.TimeSelectionAffordance.FOB,r))})("stepChanged",function(r){X(e);let o=w();return Q(o.stepTyped(o.Fob.START,r))})("fobRemoved",function(){X(e);let r=w();return Q(r.onFobRemoved(r.Fob.START))}),g()()}if(2&n){let e=w();Mt("transform",e.getCssTranslatePxForStartFob()),b(2),_("ngIf",e.showExtendedLine),b(1),_("allowRemoval",!!e.allowFobRemoval||e.timeSelection.end)("ngClass",e.isVertical()?"vertical-fob":"horizontal-fob")("step",e.timeSelection.start.step)}}function uNe(n,t){if(1&n){let e=ge();h(0,"div",10),D("mousedown",function(r){X(e);let o=w(2);return Q(o.startDrag(o.Fob.END,o.TimeSelectionAffordance.EXTENDED_LINE,r))}),g()}}function pNe(n,t){if(1&n){let e=ge();h(0,"div",2,11),S(2,uNe,1,0,"div",8),h(3,"card-fob",12),D("mousedown",function(r){X(e);let o=w();return Q(o.startDrag(o.Fob.END,o.TimeSelectionAffordance.FOB,r))})("stepChanged",function(r){X(e);let o=w();return Q(o.stepTyped(o.Fob.END,r))})("fobRemoved",function(){X(e);let r=w();return Q(r.onFobRemoved(r.Fob.END))}),g()()}if(2&n){let e=w();Mt("transform",e.getCssTranslatePxForEndFob()),b(2),_("ngIf",e.showExtendedLine),b(1),_("ngClass",e.isVertical()?"vertical-fob":"horizontal-fob")("step",e.timeSelection.end.step)}}var Rr=(()=>(function(n){n[n.NONE=0]="NONE",n[n.START=1]="START",n[n.END=2]="END"}(Rr||(Rr={})),Rr))(),fNe={start:Rr.START,end:Rr.END},mA=(()=>{class n{constructor(e){this.root=e,this.showExtendedLine=!1,this.prospectiveStep=null,this.prospectiveStepAxisPosition=null,this.allowFobRemoval=!0,this.onTimeSelectionChanged=new L,this.onTimeSelectionToggled=new L,this.onProspectiveStepChanged=new L,this.hasFobMoved=!1,this.currentDraggingFob=Rr.NONE,this.affordance=ja.NONE,this.mouseListener=this.mouseMove.bind(this),this.stopListener=this.stopDrag.bind(this),this.Fob=Rr,this.TimeSelectionAffordance=ja}getCssTranslatePxForStartFob(){return this.axisDirection===ga.VERTICAL?`translate(0px, ${this.startStepAxisPosition}px)`:`translate(${this.startStepAxisPosition}px, 0px)`}getCssTranslatePxForEndFob(){return null===this.endStepAxisPosition?"":this.axisDirection===ga.VERTICAL?`translate(0px, ${this.endStepAxisPosition}px)`:`translate(${this.endStepAxisPosition}px, 0px)`}getCssTranslatePxForProspectiveFob(){return null===this.prospectiveStep?"":this.axisDirection===ga.VERTICAL?`translate(0px, ${this.prospectiveStepAxisPosition}px)`:`translate(${this.prospectiveStepAxisPosition}px, 0px)`}stopEventPropagation(e){e.stopPropagation(),e.preventDefault()}startDrag(e,i,r){i!==ja.FOB&&this.stopEventPropagation(r),document.addEventListener("mousemove",this.mouseListener),document.addEventListener("mouseup",this.stopListener),this.currentDraggingFob=e,this.affordance=i}stopDrag(){document.removeEventListener("mousemove",this.mouseListener),document.removeEventListener("mouseup",this.stopListener),this.currentDraggingFob=Rr.NONE,this.hasFobMoved&&this.timeSelection&&this.onTimeSelectionChanged.emit({timeSelection:this.timeSelection,affordance:this.affordance}),this.affordance=ja.NONE,this.hasFobMoved=!1}isVertical(){return this.axisDirection===ga.VERTICAL}shouldSwapFobs(e){return!(!this.timeSelection||!this.timeSelection.end)&&(this.currentDraggingFob===Rr.END?e<this.timeSelection.start.step:this.currentDraggingFob===Rr.START&&e>this.timeSelection.end.step)}getNewTimeSelection(e,i){let r={...i};if(!this.timeSelection)return r;if(!this.timeSelection.end)return r.start={step:e},r;if(this.shouldSwapFobs(e)){let[o,a]=this.currentDraggingFob===Rr.END?["end","start"]:["start","end"];return this.currentDraggingFob=fNe[a],r[o]=this.timeSelection[a],r[a]={step:e},r}return this.currentDraggingFob===Rr.END?(r.end={step:e},r):(r.start={step:e},r)}getNewStepFromMouseEvent(e){let i=null,r=this.getMousePositionFromEvent(e),o=this.axisDirection===ga.VERTICAL?e.movementY:e.movementX;return this.isMovingHigher(r,o)?i=this.cardFobHelper.getStepHigherThanAxisPosition(r):this.isMovingLower(r,o)&&(i=this.cardFobHelper.getStepLowerThanAxisPosition(r)),null===i?null:i}mouseMove(e){if(this.currentDraggingFob===Rr.NONE)return;let i=this.getNewStepFromMouseEvent(e);if(null===i||!this.timeSelection)return;let r=this.getNewTimeSelection(i,this.timeSelection);this.onTimeSelectionChanged.emit({timeSelection:r}),this.hasFobMoved=!0}mouseOverProspectiveFobArea(e){if(null!=this.timeSelection?.end)return;let i=this.getNewStepFromMouseEvent(e);null!==i&&this.onProspectiveStepChanged.emit(i)}isMovingLower(e,i){if(this.currentDraggingFob===Rr.NONE&&null===this.prospectiveStep)return!0;let r=this.getCurrentFobStep();return void 0!==r&&e<this.getDraggingFobCenter()&&i<0&&r>this.lowestStep}isMovingHigher(e,i){if(this.currentDraggingFob===Rr.NONE&&null===this.prospectiveStep)return!0;let r=this.getCurrentFobStep();return void 0!==r&&e>this.getDraggingFobCenter()&&i>0&&r<this.highestStep}getDraggingFobCenter(){let e=this.getCurrentFob()?.nativeElement;if(!e)return 0;let i=e.getBoundingClientRect().top,r=e.getBoundingClientRect().left;return this.axisDirection===ga.VERTICAL?i-this.root.nativeElement.getBoundingClientRect().top:r-this.root.nativeElement.getBoundingClientRect().left}getCurrentFob(){switch(this.currentDraggingFob){case Rr.START:return this.startFobWrapper;case Rr.END:return this.endFobWrapper;case Rr.NONE:return this.prospectiveFobWrapper}}getCurrentFobStep(){switch(this.currentDraggingFob){case Rr.START:return this.timeSelection?.start.step;case Rr.END:return this.timeSelection?.end?.step;case Rr.NONE:return this.prospectiveStep??void 0}}getMousePositionFromEvent(e){return this.axisDirection===ga.VERTICAL?e.clientY-this.root.nativeElement.getBoundingClientRect().top:e.clientX-this.root.nativeElement.getBoundingClientRect().left}stepTyped(e,i){if(null===i)return void(null!==this.timeSelection.end&&this.onFobRemoved(e));let r={...this.timeSelection};e===Rr.START?r.start={step:i}:e===Rr.END&&(r.end={step:i}),null!==r.end&&r.start.step>r.end.step&&(r={start:r.end,end:r.start}),this.onTimeSelectionChanged.emit({timeSelection:r,affordance:ja.FOB_TEXT})}prospectiveFobClicked(e){e.stopPropagation();let i=this.getProspectiveTimeSelection();!i||(this.onTimeSelectionChanged.emit({affordance:ja.FOB_ADDED,timeSelection:i}),this.onProspectiveStepChanged.emit(null))}getProspectiveTimeSelection(){if(this.prospectiveStep)return this.timeSelection?{start:{step:Math.min(this.timeSelection.start.step,this.prospectiveStep)},end:{step:Math.max(this.timeSelection.start.step,this.prospectiveStep)}}:{start:{step:this.prospectiveStep},end:null}}onFobRemoved(e){e!==Rr.END?null===this.timeSelection.end?this.onTimeSelectionToggled.emit():this.onTimeSelectionChanged.emit({affordance:ja.FOB_REMOVED,timeSelection:{start:this.timeSelection.end,end:null}}):this.onTimeSelectionChanged.emit({affordance:ja.FOB_REMOVED,timeSelection:{...this.timeSelection,end:null}})}onProspectiveAreaMouseLeave(){this.onProspectiveStepChanged.emit(null)}}return n.\u0275fac=function(e){return new(e||n)(C(be))},n.\u0275cmp=k({type:n,selectors:[["card-fob-controller"]],viewQuery:function(e,i){if(1&e&&(Ye(rNe,5),Ye(oNe,5),Ye(aNe,5)),2&e){let r;we(r=Se())&&(i.startFobWrapper=r.first),we(r=Se())&&(i.endFobWrapper=r.first),we(r=Se())&&(i.prospectiveFobWrapper=r.first)}},inputs:{axisDirection:"axisDirection",timeSelection:"timeSelection",cardFobHelper:"cardFobHelper",startStepAxisPosition:"startStepAxisPosition",endStepAxisPosition:"endStepAxisPosition",highestStep:"highestStep",lowestStep:"lowestStep",showExtendedLine:"showExtendedLine",prospectiveStep:"prospectiveStep",prospectiveStepAxisPosition:"prospectiveStepAxisPosition",allowFobRemoval:"allowFobRemoval"},outputs:{onTimeSelectionChanged:"onTimeSelectionChanged",onTimeSelectionToggled:"onTimeSelectionToggled",onProspectiveStepChanged:"onProspectiveStepChanged"},decls:6,vars:4,consts:[["class","time-fob-wrapper",3,"transform",4,"ngIf"],[1,"prospective-fob-area",3,"ngClass","mousemove","click","mouseleave"],[1,"time-fob-wrapper"],["prospectiveFobWrapper",""],["class","extended-line",4,"ngIf"],[3,"ngClass","allowRemoval","isProspective","step"],[1,"extended-line"],["startFobWrapper",""],["class","extended-line",3,"mousedown",4,"ngIf"],[1,"startFob",3,"allowRemoval","ngClass","step","mousedown","stepChanged","fobRemoved"],[1,"extended-line",3,"mousedown"],["endFobWrapper",""],[1,"endFob",3,"ngClass","step","mousedown","stepChanged","fobRemoved"]],template:function(e,i){1&e&&(h(0,"div"),Tt(1),S(2,lNe,4,7,"div",0),h(3,"div",1),D("mousemove",function(o){return i.mouseOverProspectiveFobArea(o)})("click",function(o){return i.prospectiveFobClicked(o)})("mouseleave",function(){return i.onProspectiveAreaMouseLeave()}),g(),Dt(),S(4,dNe,4,6,"div",0),S(5,pNe,4,5,"div",0),g()),2&e&&(b(2),_("ngIf",null!==i.prospectiveStep),b(1),_("ngClass",i.isVertical()?"vertical-prospective-area":"horizontal-prospective-area"),b(1),_("ngIf",i.timeSelection),b(1),_("ngIf",i.timeSelection&&i.timeSelection.end))},dependencies:[bn,Fe,ene],styles:["[_nghost-%COMP%]{pointer-events:all}.time-fob-wrapper[_ngcontent-%COMP%]{display:inline-block;position:absolute;top:0;width:0}.vertical-fob[_ngcontent-%COMP%]{transform:translateY(-50%)}.horizontal-fob[_ngcontent-%COMP%]{transform:translateX(-50%)}.extended-line[_ngcontent-%COMP%]{border-style:dashed;border-width:0 1px;height:calc(100% - 30px)}.extended-line[_ngcontent-%COMP%]:hover{background:linear-gradient(to right, transparent 18px, #ccc 19px, #ccc 21px, transparent 22px);border:0;cursor:ew-resize;margin-left:-20px;padding:0 20px}.horizontal-prospective-area[_ngcontent-%COMP%]{bottom:0;cursor:pointer;position:absolute;height:30px;width:calc(100% - 74px)}.prospective-area[_ngcontent-%COMP%]{display:block}"],changeDetection:0}),n})(),qV=(()=>{class n{constructor(){this.disableInteraction=!1,this.allowFobRemoval=!0,this.onTimeSelectionChanged=new L,this.onTimeSelectionToggled=new L,this.axisDirection=ga.HORIZONTAL,this.cardFobHelper={getStepHigherThanAxisPosition:this.getStepHigherThanAxisPosition.bind(this),getStepLowerThanAxisPosition:this.getStepLowerThanAxisPosition.bind(this)},this.prospectiveStep=null}getAxisPositionFromStartStep(){return this.timeSelection?this.scale.forward(this.minMaxHorizontalViewExtend,[0,this.axisSize],this.timeSelection.start.step):""}getAxisPositionFromEndStep(){return this.timeSelection?.end?this.scale.forward(this.minMaxHorizontalViewExtend,[0,this.axisSize],this.timeSelection?.end.step??this.minMaxStep.maxStep):null}getAxisPositionFromProspectiveStep(){return null===this.prospectiveStep?null:this.scale.forward(this.minMaxHorizontalViewExtend,[0,this.axisSize],this.prospectiveStep)}onProspectiveStepChanged(e){this.prospectiveStep=e}getHighestStep(){return this.minMaxStep.maxStep}getLowestStep(){return this.minMaxStep.minStep}getStepHigherThanAxisPosition(e){return this.getStepAtMousePostion(e)}getStepLowerThanAxisPosition(e){return this.getStepAtMousePostion(e)}getStepAtMousePostion(e){let i=Math.round(this.scale.reverse(this.minMaxHorizontalViewExtend,[0,this.axisSize],e));return i>this.getHighestStep()?this.getHighestStep():i<this.getLowestStep()?this.getLowestStep():i}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["scalar-card-fob-controller"]],inputs:{timeSelection:"timeSelection",scale:"scale",minMaxHorizontalViewExtend:"minMaxHorizontalViewExtend",minMaxStep:"minMaxStep",axisSize:"axisSize",disableInteraction:"disableInteraction",allowFobRemoval:"allowFobRemoval"},outputs:{onTimeSelectionChanged:"onTimeSelectionChanged",onTimeSelectionToggled:"onTimeSelectionToggled"},decls:1,vars:13,consts:[[3,"axisDirection","timeSelection","startStepAxisPosition","endStepAxisPosition","prospectiveStepAxisPosition","highestStep","lowestStep","prospectiveStep","cardFobHelper","showExtendedLine","allowFobRemoval","onProspectiveStepChanged","onTimeSelectionChanged","onTimeSelectionToggled"]],template:function(e,i){1&e&&(h(0,"card-fob-controller",0),D("onProspectiveStepChanged",function(o){return i.onProspectiveStepChanged(o)})("onTimeSelectionChanged",function(o){return i.onTimeSelectionChanged.emit(o)})("onTimeSelectionToggled",function(o){return i.onTimeSelectionToggled.emit(o)}),g()),2&e&&(Mt("pointer-events",i.disableInteraction?"none":"all"),_("axisDirection",i.axisDirection)("timeSelection",i.timeSelection)("startStepAxisPosition",i.getAxisPositionFromStartStep())("endStepAxisPosition",i.getAxisPositionFromEndStep())("prospectiveStepAxisPosition",i.getAxisPositionFromProspectiveStep())("highestStep",i.getHighestStep())("lowestStep",i.getLowestStep())("prospectiveStep",i.prospectiveStep)("cardFobHelper",i.cardFobHelper)("showExtendedLine",!0)("allowFobRemoval",i.allowFobRemoval))},dependencies:[mA],styles:["scalar-card-fob-controller .time-fob-wrapper{height:100%}"],changeDetection:0}),n})(),mNe=["dataTableContainer"];function hNe(n,t){if(1&n){let e=ge();h(0,"button",27),D("click",function(){return X(e),Q(w().openTableEditMenu())}),P(1,"mat-icon",28),h(2,"span"),T(3,"Edit Table Columns"),g()()}}function gNe(n,t){1&n&&P(0,"mat-spinner",29)}function _Ne(n,t){1&n&&(h(0,"th"),T(1,"Smoothed"),g())}function yNe(n,t){if(1&n&&(Tt(0),P(1,"tb-experiment-alias",35),T(2,"/"),Dt()),2&n){let e=w().$implicit;b(1),_("alias",e.metadata.alias)}}function bNe(n,t){if(1&n&&(h(0,"td"),T(1),g()),2&n){let e=w().$implicit,i=w(2);b(1),ze(" ",i.valueFormatter.formatShort(e.dataPoint.y)," ")}}function vNe(n,t){if(1&n&&(Tt(0),h(1,"tr",33)(2,"td",34),P(3,"span"),g(),h(4,"td",2),S(5,yNe,3,1,"ng-container",24),T(6),g(),S(7,bNe,2,1,"td",24),h(8,"td"),T(9),g(),h(10,"td"),T(11),g(),h(12,"td"),T(13),G(14,"date"),g(),h(15,"td"),T(16),g()(),Dt()),2&n){let e=t.$implicit,i=w(2);b(1),Qe("closest",e.metadata.closest),b(2),Mt("background-color",e.metadata.color),b(2),_("ngIf",e.metadata.alias),b(1),ze("",e.metadata.displayName," "),b(1),_("ngIf",i.smoothingEnabled),b(2),ut(i.valueFormatter.formatShort(e.dataPoint.value)),b(2),ut(i.stepFormatter.formatShort(e.dataPoint.step)),b(2),ut(Jp(14,11,e.dataPoint.wallTime,"short")),b(3),ze(" ",i.relativeXFormatter.formatReadable(e.dataPoint.relativeTimeInMs)," ")}}function xNe(n,t){if(1&n&&(h(0,"table",30)(1,"thead")(2,"tr"),P(3,"th",31),h(4,"th"),T(5,"Run"),g(),S(6,_Ne,2,0,"th",24),h(7,"th"),T(8,"Value"),g(),h(9,"th"),T(10,"Step"),g(),h(11,"th"),T(12,"Time"),g(),h(13,"th"),T(14,"Relative"),g()()(),h(15,"tbody"),S(16,vNe,17,14,"ng-container",32),g()()),2&n){let e=t.data,i=t.cursorLocationInDataCoord,r=t.cursorLocation,o=w();b(6),_("ngIf",o.smoothingEnabled),b(10),_("ngForOf",o.getCursorAwareTooltipData(e,i,r))("ngForTrackBy",o.trackByTooltipDatum)}}function CNe(n,t){if(1&n){let e=ge();h(0,"button",41),D("click",function(){return X(e),Q(w(2).toggleTableExpanded())}),P(1,"mat-icon",9),g()}if(2&n){let e=w(2);_("title",e.shouldExpandTable()?"Expand Table":"Collapse Table"),b(1),_("svgIcon",e.shouldExpandTable()?"expand_more_24px":"expand_less_24px")}}var MNe=function(n){return{"data-table-container":!0,expanded:n}};function wNe(n,t){if(1&n){let e=ge();Tt(0),h(1,"div",36,37)(3,"scalar-card-data-table",38),D("sortDataBy",function(r){return X(e),Q(w().sortDataBy(r))})("editColumnHeaders",function(r){return X(e),Q(w().editColumnHeaders.emit(r))})("removeColumn",function(r){return X(e),Q(w().removeColumn.emit(r))}),g()(),h(4,"div",39),S(5,CNe,2,2,"button",40),g(),Dt()}if(2&n){let e=w();b(1),_("ngClass",Sn(10,MNe,e.cardState.tableExpanded)),b(2),_("chartMetadataMap",e.chartMetadataMap)("dataSeries",e.dataSeries)("stepOrLinkedTimeSelection",e.stepOrLinkedTimeSelection)("columnHeaders",e.columnHeaders)("sortingInfo",e.sortingInfo)("columnCustomizationEnabled",e.columnCustomizationEnabled)("smoothingEnabled",e.smoothingEnabled)("hparamsEnabled",e.hparamsEnabled),b(2),_("ngIf",e.canExpandTable())}}var SNe=function(n){return[0,n]},ENe=function(){return{"out-of-selected-time":!0,end:!0,range:!0}};function TNe(n,t){if(1&n&&P(0,"div",36),2&n){let e=w(2),i=e.viewExtent,r=e.domDimension,o=e.xScale,a=w();Mt("left",o.forward(i.x,Sn(3,SNe,r.width),null==a.stepOrLinkedTimeSelection.end?null:a.stepOrLinkedTimeSelection.end.step)+"px"),_("ngClass",uu(5,ENe))}}var DNe=function(n){return[n,0]},INe=function(n){return{"out-of-selected-time":!0,start:!0,range:n}};function ANe(n,t){if(1&n&&(Tt(0),P(1,"div",36),S(2,TNe,1,6,"div",42),Dt()),2&n){let e=w(),i=e.viewExtent,r=e.domDimension,o=e.xScale,a=w();b(1),Mt("right",o.forward(i.x,Sn(4,DNe,r.width),a.stepOrLinkedTimeSelection.start.step)+"px"),_("ngClass",Sn(6,INe,!(null==a.stepOrLinkedTimeSelection.end||!a.stepOrLinkedTimeSelection.end.step))),b(1),_("ngIf",null==a.stepOrLinkedTimeSelection.end?null:a.stepOrLinkedTimeSelection.end.step)}}function RNe(n,t){1&n&&S(0,ANe,3,8,"ng-container",24),2&n&&_("ngIf",w().stepOrLinkedTimeSelection)}function kNe(n,t){if(1&n){let e=ge();Tt(0),h(1,"scalar-card-fob-controller",43),D("onTimeSelectionChanged",function(r){return X(e),Q(w(2).onTimeSelectionChanged.emit(r))})("onTimeSelectionToggled",function(){return X(e),Q(w(2).onFobRemoved())}),g(),Dt()}if(2&n){let e=w(),i=e.interactionState,r=e.xScale,o=e.viewExtent,a=e.domDimension,s=w();b(1),_("disableInteraction","NONE"!==i)("timeSelection",s.stepOrLinkedTimeSelection)("scale",r)("minMaxHorizontalViewExtend",o.x)("minMaxStep",s.minMaxStep)("axisSize",a.width)}}function PNe(n,t){1&n&&S(0,kNe,2,6,"ng-container",24),2&n&&_("ngIf",w().showFobController())}var ine=(()=>{class n{constructor(e,i){this.ref=e,this.dialog=i,this.DataLoadState=De,this.RendererType=Zi,this.ScaleType=ir,this.onFullSizeToggle=new L,this.onPinClicked=new L,this.onTimeSelectionChanged=new L,this.onStepSelectorToggled=new L,this.onDataTableSorting=new L,this.editColumnHeaders=new L,this.openTableEditMenuToMode=new L,this.removeColumn=new L,this.onLineChartZoom=new L,this.onCardStateChanged=new L,this.sortingInfo={name:"run",order:so.ASCENDING},this.yScaleType=ir.LINEAR,this.isViewBoxOverridden=!1,this.relativeXFormatter=A0,this.valueFormatter=cp,this.stepFormatter=I0}toggleYScaleType(){this.yScaleType=this.yScaleType===ir.LINEAR?ir.LOG10:ir.LINEAR}sortDataBy(e){this.sortingInfo=e,this.onDataTableSorting.emit(e)}resetDomain(){this.lineChart&&this.lineChart.viewBoxReset()}trackByTooltipDatum(e,i){return i.id}getCustomXFormatter(){switch(this.xAxisType){case Pi.RELATIVE:return A0;case Pi.STEP:return k3;default:return}}getCursorAwareTooltipData(e,i,r){let o=e.map(l=>({...l,metadata:{...l.metadata,closest:!1,distToCursorPixels:Math.hypot(l.domPoint.x-r.x,l.domPoint.y-r.y),distToCursorX:l.dataPoint.x-i.x,distToCursorY:l.dataPoint.y-i.y}})),a=1/0,s=0;for(let l=0;l<o.length;l++)a>o[l].metadata.distToCursorPixels&&(a=o[l].metadata.distToCursorPixels,s=l);switch(o.length&&(o[s].metadata.closest=!0),this.tooltipSort){case ao.ASCENDING:return o.sort((l,c)=>l.dataPoint.y-c.dataPoint.y);case ao.DESCENDING:return o.sort((l,c)=>c.dataPoint.y-l.dataPoint.y);case ao.NEAREST:return o.sort((l,c)=>l.metadata.distToCursorPixels-c.metadata.distToCursorPixels);case ao.NEAREST_Y:return o.sort((l,c)=>l.metadata.distToCursorY-c.metadata.distToCursorY);case ao.DEFAULT:case ao.ALPHABETICAL:return o.sort((l,c)=>l.metadata.displayName<c.metadata.displayName?-1:l.metadata.displayName>c.metadata.displayName?1:0)}}openDataDownloadDialog(){this.dialog.open(this.DataDownloadComponent,{data:{cardId:this.cardId}})}onFobRemoved(){this.onStepSelectorToggled.emit(Ga.FOB_DESELECT)}showDataTable(){return this.xAxisType===Pi.STEP&&this.stepOrLinkedTimeSelection}showFobController(){return this.xAxisType===Pi.STEP&&this.minMaxStep}canExpandTable(){return this.dataSeries.filter(i=>qS(i,this.chartMetadataMap)).length>3}shouldExpandTable(){return Boolean(this.dataTableContainer?.nativeElement.style.height||!this.cardState?.tableExpanded)}toggleTableExpanded(){this.onCardStateChanged.emit({...this.cardState,tableExpanded:this.shouldExpandTable()}),this.dataTableContainer&&(this.dataTableContainer.nativeElement.style.height="")}openTableEditMenu(){this.openTableEditMenuToMode.emit(this.rangeEnabled?lo.RANGE:lo.SINGLE)}}return n.\u0275fac=function(e){return new(e||n)(C(be),C(Ll))},n.\u0275cmp=k({type:n,selectors:[["scalar-card-component"]],viewQuery:function(e,i){if(1&e&&(Ye(C_,5),Ye(mNe,5)),2&e){let r;we(r=Se())&&(i.lineChart=r.first),we(r=Se())&&(i.dataTableContainer=r.first)}},inputs:{cardId:"cardId",chartMetadataMap:"chartMetadataMap",cardState:"cardState",DataDownloadComponent:"DataDownloadComponent",dataSeries:"dataSeries",ignoreOutliers:"ignoreOutliers",isCardVisible:"isCardVisible",isPinned:"isPinned",loadState:"loadState",showFullWidth:"showFullWidth",smoothingEnabled:"smoothingEnabled",tag:"tag",title:"title",tooltipSort:"tooltipSort",xAxisType:"xAxisType",xScaleType:"xScaleType",useDarkMode:"useDarkMode",forceSvg:"forceSvg",columnCustomizationEnabled:"columnCustomizationEnabled",linkedTimeSelection:"linkedTimeSelection",stepOrLinkedTimeSelection:"stepOrLinkedTimeSelection",minMaxStep:"minMaxStep",userViewBox:"userViewBox",columnHeaders:"columnHeaders",rangeEnabled:"rangeEnabled",hparamsEnabled:"hparamsEnabled"},outputs:{onFullSizeToggle:"onFullSizeToggle",onPinClicked:"onPinClicked",onTimeSelectionChanged:"onTimeSelectionChanged",onStepSelectorToggled:"onStepSelectorToggled",onDataTableSorting:"onDataTableSorting",editColumnHeaders:"editColumnHeaders",openTableEditMenuToMode:"openTableEditMenuToMode",removeColumn:"removeColumn",onLineChartZoom:"onLineChartZoom",onCardStateChanged:"onCardStateChanged"},decls:38,vars:29,consts:function(){let t,e,i,r,o,a;return t=$localize`:A button that resets line chart domain to the data␟e68a552941ab427a99e7437e08443f30ac71ccd6␟3830646521058268558:Fit line chart domains to data`,e=$localize`:A button to pin a card.␟e665dc712bd5f18d4dfa3a29e125d565cc51e2f6␟7284606426234375344:Pin card`,i=$localize`:A button on line chart that toggles full size mode.␟fc8f767d0b9f930187a1bae34477ad28736ece33␟915721563638926597:Toggle full size mode`,r=$localize`:An overflow menu button that opens more line chart options␟b260fab946a3077ce20fd28e336979f586720e8d␟878053740210336435:More line chart options`,o=$localize`:A button that toggles log scale on y-axis on a line chart␟fe91f96ab9b3baca5a48913f2b0fae84483d93e3␟3374645620638883926:Toggle Y-axis log scale on line chart`,a=$localize`:Expand Table␟9e59ff50bfcb479272e2b103e1e9b11518e2e4ce␟6374880341393020610:Expand Table`,[[1,"always-visible"],[1,"heading"],[1,"name"],[1,"tag",3,"title","value"],[3,"isClipped"],[1,"controls"],["mat-icon-button","","aria-label",t,3,"disabled","title","click"],["svgIcon","settings_overscan_24px"],["mat-icon-button","","aria-label",e,1,"pin-button",3,"click"],[3,"svgIcon"],["mat-icon-button","","aria-label",i,"title","Toggle full size mode",3,"click"],["mat-icon-button","","aria-label",r,"title","More line chart options",3,"matMenuTriggerFor"],["svgIcon","more_vert_24px"],["menu","matMenu"],["mat-menu-item","","aria-label",o,3,"click"],["svgIcon","line_weight_24px"],["mat-menu-item","","aria-label","Open dialog to download data",3,"click"],["svgIcon","get_app_24px"],["mat-menu-item","","aria-label","Open menu to edit data table columns",3,"click",4,"ngIf"],[1,"chart-container"],["chartContainer",""],["diameter","18",4,"ngIf"],[3,"disableUpdate","preferredRendererType","seriesData","seriesMetadataMap","xScaleType","yScaleType","customXFormatter","ignoreYOutliers","tooltipTemplate","useDarkMode","userViewBox","customVisTemplate","customChartOverlayTemplate","onViewBoxOverridden","viewBoxChanged"],["tooltip",""],[4,"ngIf"],["lineChartCustomVis",""],["lineChartCustomXAxisVis",""],["mat-menu-item","","aria-label","Open menu to edit data table columns",3,"click"],["svgIcon","edit_24px"],["diameter","18"],[1,"tooltip"],[1,"circle-header"],[4,"ngFor","ngForOf","ngForTrackBy"],[1,"tooltip-row"],[1,"tooltip-row-circle"],[3,"alias"],[3,"ngClass"],["dataTableContainer",""],[3,"chartMetadataMap","dataSeries","stepOrLinkedTimeSelection","columnHeaders","sortingInfo","columnCustomizationEnabled","smoothingEnabled","hparamsEnabled","sortDataBy","editColumnHeaders","removeColumn"],[1,"bottom-area"],["mat-icon-button","","class","expand-button","aria-label",a,3,"title","click",4,"ngIf"],["mat-icon-button","","aria-label",a,1,"expand-button",3,"title","click"],[3,"ngClass","left",4,"ngIf"],[3,"disableInteraction","timeSelection","scale","minMaxHorizontalViewExtend","minMaxStep","axisSize","onTimeSelectionChanged","onTimeSelectionToggled"]]},template:function(e,i){if(1&e&&(h(0,"div",0)(1,"div",1)(2,"span",2),P(3,"tb-truncated-path",3)(4,"vis-linked-time-selection-warning",4),g(),h(5,"span",5)(6,"button",6),D("click",function(){return i.resetDomain()}),G(7,"async"),G(8,"async"),P(9,"mat-icon",7),g(),h(10,"button",8),D("click",function(){return i.onPinClicked.emit(!i.isPinned)}),P(11,"mat-icon",9),g(),h(12,"button",10),D("click",function(){return i.onFullSizeToggle.emit()}),P(13,"mat-icon",9),g(),h(14,"button",11),P(15,"mat-icon",12),g(),h(16,"mat-menu",null,13)(18,"button",14),D("click",function(){return i.toggleYScaleType()}),P(19,"mat-icon",15),h(20,"span"),T(21,"Toggle Y-axis log scale"),g()(),h(22,"button",16),D("click",function(){return i.openDataDownloadDialog()}),P(23,"mat-icon",17),h(24,"span"),T(25,"Download data"),g()(),S(26,hNe,4,0,"button",18),g()()(),h(27,"div",19,20),S(29,gNe,1,0,"mat-spinner",21),h(30,"line-chart",22),D("onViewBoxOverridden",function(o){return i.isViewBoxOverridden=o})("viewBoxChanged",function(o){return i.onLineChartZoom.emit(o)}),g(),S(31,xNe,17,3,"ng-template",null,23,Zt),g()(),S(33,wNe,6,12,"ng-container",24),S(34,RNe,1,1,"ng-template",null,25,Zt),S(36,PNe,1,1,"ng-template",null,26,Zt)),2&e){let r=tt(17),o=tt(32),a=tt(35),s=tt(37);b(3),Ji("title",i.tag),Ji("value",i.title),b(1),_("isClipped",i.linkedTimeSelection&&i.linkedTimeSelection.clipped),b(2),_("disabled",!i.lineChart||!W(7,25,i.lineChart.getIsViewBoxOverridden()))("title",i.lineChart&&W(8,27,i.lineChart.getIsViewBoxOverridden())?"Line chart is already fitted to data. When data updates, the line chart will auto fit to its domain.":"Fit line chart domains to data"),b(4),Pe("title",i.isPinned?"Unpin card":"Pin card"),b(1),_("svgIcon",i.isPinned?"keep_24px":"keep_outline_24px"),b(2),_("svgIcon",i.showFullWidth?"fullscreen_exit_24px":"fullscreen_24px"),b(1),_("matMenuTriggerFor",r),b(12),_("ngIf",i.columnCustomizationEnabled),b(3),_("ngIf",i.loadState===i.DataLoadState.LOADING),b(1),_("disableUpdate",!i.isCardVisible)("preferredRendererType",i.forceSvg?i.RendererType.SVG:i.RendererType.WEBGL)("seriesData",i.dataSeries)("seriesMetadataMap",i.chartMetadataMap)("xScaleType",i.xScaleType)("yScaleType",i.yScaleType)("customXFormatter",i.getCustomXFormatter())("ignoreYOutliers",i.ignoreOutliers)("tooltipTemplate",o)("useDarkMode",i.useDarkMode)("userViewBox",i.userViewBox)("customVisTemplate",a)("customChartOverlayTemplate",s),b(3),_("ngIf",i.showDataTable())}},dependencies:[bn,dn,Fe,tp,C_,Fn,Dn,kc,Yu,Pc,zr,$te,qV,s0,l0,lt,Ih],styles:["[_nghost-%COMP%]{display:flex;flex-direction:column;box-sizing:border-box;height:100%;padding:16px;padding-top:4px}[_nghost-%COMP%]:has(.expand-button){padding:4px 16px 0}.always-visible[_ngcontent-%COMP%]{display:flex;flex-direction:column;flex-basis:298px}.always-visible[_ngcontent-%COMP%]:not(:has(.expand-button)){flex-grow:1}.heading[_ngcontent-%COMP%]{align-items:center;display:flex;font-size:14px;justify-content:space-between;margin-bottom:4px;position:relative}.heading[_ngcontent-%COMP%]   .name[_ngcontent-%COMP%]{align-items:center;display:grid;gap:5px;grid-template-columns:auto auto}.heading[_ngcontent-%COMP%]   vis-selected-time-clipped[_ngcontent-%COMP%]{font-size:1.2em;line-height:0}.tag[_ngcontent-%COMP%]{overflow:hidden}.pin-button[_ngcontent-%COMP%]   mat-icon[_ngcontent-%COMP%]{height:18px}.controls[_ngcontent-%COMP%]{color:#616161;white-space:nowrap;flex-shrink:0;margin-right:-12px}body.dark-mode[_nghost-%COMP%]   .controls[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .controls[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}.chart-container[_ngcontent-%COMP%]{display:flex;flex-direction:column;flex-grow:1;overflow:hidden;resize:vertical}.chart-container[_ngcontent-%COMP%]   mat-spinner[_ngcontent-%COMP%]{position:absolute;right:11px;top:11px}.chart-container[_ngcontent-%COMP%]   line-chart[_ngcontent-%COMP%]{flex-grow:1}.tooltip[_ngcontent-%COMP%]{border-spacing:4px;font-size:13px}.tooltip[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]{text-align:left}.tooltip[_ngcontent-%COMP%]   .tooltip-row[_ngcontent-%COMP%]{white-space:nowrap}.tooltip[_ngcontent-%COMP%]   .tooltip-row-circle[_ngcontent-%COMP%]{align-items:center;display:inline-flex;height:12px;width:12px}.tooltip[_ngcontent-%COMP%]   .tooltip-row-circle[_ngcontent-%COMP%] > span[_ngcontent-%COMP%]{border-radius:50%;border:1px solid rgba(255,255,255,.4);display:inline-block;height:10px;width:10px}.tooltip[_ngcontent-%COMP%]   .closest[_ngcontent-%COMP%]   .tooltip-row-circle[_ngcontent-%COMP%] > span[_ngcontent-%COMP%]{border-color:#fff;box-shadow:inset 0 0 0 1px #fff}.out-of-selected-time[_ngcontent-%COMP%]{height:100%;position:absolute}.out-of-selected-time.start[_ngcontent-%COMP%]{border-right-width:2px;margin-left:-1px}.out-of-selected-time.start.range[_ngcontent-%COMP%]{left:0}.out-of-selected-time.end[_ngcontent-%COMP%]{border-left-width:2px;margin-right:-1px;right:0}.out-of-selected-time.range[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.5)}body.dark-mode[_nghost-%COMP%]   .out-of-selected-time.range[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .out-of-selected-time.range[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.4)}.data-table-container[_ngcontent-%COMP%]{height:100px;min-height:100px;max-height:50em;overflow:auto;resize:vertical}.data-table-container.expanded[_ngcontent-%COMP%]{height:auto}.bottom-area[_ngcontent-%COMP%]{display:flex;flex-direction:column;align-items:center}.bottom-area[_ngcontent-%COMP%]   .expand-button[_ngcontent-%COMP%]{color:#616161}body.dark-mode[_nghost-%COMP%]   .bottom-area[_ngcontent-%COMP%]   .expand-button[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .bottom-area[_ngcontent-%COMP%]   .expand-button[_ngcontent-%COMP%]{color:rgba(255,255,255,.7);background-color:#303030}"],changeDetection:0}),n})();function FNe(n,t){return n.length===t.length&&n.every((e,i)=>{let r=t[i],o=e.points,a=r.points;return e.runId===r.runId&&o.length===a.length&&o.every((s,l)=>{let c=a[l];return s.x===c.x&&s.y===c.y})})}var rne=(()=>{class n{constructor(e){this.store=e,this.DataDownloadComponent=$Q,this.pinStateChanged=new L,this.isVisible=!1,this.useDarkMode$=this.store.select(El),this.ignoreOutliers$=this.store.select(wf),this.tooltipSort$=this.store.select(Mf),this.xAxisType$=this.store.select(Dl),this.forceSvg$=this.store.select(EF),this.columnCustomizationEnabled$=this.store.select(fS),this.xScaleType$=this.store.select(Dl).pipe(U(i=>{switch(i){case Pi.STEP:case Pi.RELATIVE:return ir.LINEAR;case Pi.WALL_TIME:return ir.TIME;default:throw new Error(`Invalid xAxisType for line chart. ${i}`)}})),this.scalarSmoothing$=this.store.select(gd),this.smoothingEnabled$=this.store.select(gd).pipe(U(i=>i>0)),this.showFullWidth$=this.store.select(js).pipe(U(i=>i[this.cardId]?.fullWidth)),this.ngUnsubscribe=new Ae}onVisibilityChange({visible:e}){this.isVisible=e}isScalarCardMetadata(e){let{plugin:i}=e;return i===qn.SCALARS}onFullSizeToggle(){this.store.dispatch(Kg({cardId:this.cardId}))}ngOnInit(){let i=this.store.select(Us,this.cardId).pipe(Ve(l=>!!l&&this.isScalarCardMetadata(l)),U(l=>l));function a(l){return JSON.stringify(["smoothed",l])}let s=this.store.select(Eu,this.cardId).pipe(ot(this.ngUnsubscribe),Ve(l=>Boolean(l)),U(l=>l),Ea(1)).pipe(Vi(this.store.select(Dl)),U(([l,c])=>Object.keys(l).map(p=>({runId:p,points:this.stepSeriesToLineSeries(l[p],c)}))),ui(FNe)).pipe(Vi(this.store.select(l1)),ot(this.ngUnsubscribe),U(([l,c])=>c?function(n){let t=[];for(let e of n){let i=[],r=Number.isFinite(e.points[0]?.x)?e.points[0].x:-1/0,o=[];for(let a of e.points)Number.isFinite(a.x)?(a.x<r&&(i.push({seriesId:JSON.stringify([e.runId,i.length]),runId:e.runId,points:o}),o=[]),o.push(a),r=a.x):o.push(a);i.push({seriesId:JSON.stringify([e.runId,i.length]),runId:e.runId,points:o});for(let a=0;a<i.length;a++)t.push({...i[a],partitionIndex:a,partitionSize:i.length})}return t}(l):l.map(d=>({...d,seriesId:d.runId,partitionIndex:0,partitionSize:1}))),U(l=>l.map(c=>{let d=c.points[0]?.wallTime;return{...c,points:c.points.map(u=>({...u,relativeTimeInMs:u.wallTime-d}))}})),Vi(this.store.select(Dl)),U(([l,c])=>l.map(d=>({...d,points:d.points.map(u=>{let p;switch(c){case Pi.RELATIVE:p=u.relativeTimeInMs;break;case Pi.WALL_TIME:p=u.wallTime;break;default:p=u.step}return{...u,x:p}})}))),Ea(1));this.userViewBox$=this.store.select($F,this.cardId),this.minMaxSteps$=un([this.store.select(ZW,this.cardId),this.store.select(KW,this.cardId)]).pipe(U(([l,c])=>{if(l&&c)return{minStep:Math.max(l?.minStep,c?.minStep),maxStep:Math.min(l?.maxStep,c?.maxStep)}})),this.dataSeries$=s.pipe(Vi(this.store.select(gd)),yi(([l,c])=>{let d=l.map(({seriesId:u,points:p})=>({id:u,points:p}));return c<=0?qt(d):no(async function(n,t){Number.isFinite(t)||(t=0),t=Math.max(0,Math.min(t,1));let e=[];for(let i of n){let r=i.points[0]?.y;if(i.points.every(c=>c.y==r)){e.push(i);continue}let a=i.points.length>0?0:NaN,s=0,l=i.points.map(c=>{let d=c.y;if(Number.isFinite(d)){a=a*t+(1-t)*d,s++;let u=1===t?1:1-Math.pow(t,s);return{x:c.x,y:a/u}}return{x:c.x,y:d}});e.push({id:i.id,points:l})}return e}(d,c)).pipe(U(u=>{let p=d.map((f,m)=>({id:a(f.id),points:u[m].points.map(({y:y},M)=>({...f.points[M],y:y}))}));return[...d,...p]}))}),Nn([])),this.linkedTimeSelection$=un([this.minMaxSteps$,this.store.select(Du),this.store.select(Au),this.store.select(Dl)]).pipe(U(([l,c,d,u])=>l&&c&&u===Pi.STEP&&d?$h(d,l.minStep,l.maxStep):null)),this.stepOrLinkedTimeSelection$=this.store.select(JW,this.cardId),this.columnHeaders$=this.store.select(g1(this.cardId)),this.chartMetadataMap$=s.pipe(yi(l=>un(l.map(c=>this.getRunDisplayNameAndAlias(c.runId).pipe(U(d=>({...c,...d})))))),Vi(this.store.select(Ru),this.store.select(hf),this.store.select(jQ),this.store.select(ku),this.store.select(gd)),Cr(0),U(([l,c,d,u,p,f])=>{let m={},y=f>0;for(let M of l){let{seriesId:v,runId:x,displayName:R,alias:A,partitionIndex:H,partitionSize:te}=M;m[v]={type:r0.ORIGINAL,id:v,alias:A,displayName:te>1?`${R}: ${H}`:R,visible:Boolean(c&&c.get(x)&&(!d||u.has(x))),color:p[x]??"#fff",aux:!1,opacity:1}}if(!y)return m;for(let[M,v]of Object.entries(m)){let x=a(M);m[x]={...v,id:x,type:r0.DERIVED,aux:!1,originalSeriesId:M},v.aux=!0,v.opacity=.25}return m}),Nn({})),this.loadState$=this.store.select(hd,this.cardId),this.tag$=i.pipe(U(l=>l.tag)),this.cardState$=this.store.select(js).pipe(U(l=>l[this.cardId]||{})),this.title$=this.tag$.pipe(U(l=>a0(l,this.groupName))),this.isPinned$=this.store.select(Tu,this.cardId),this.rangeEnabled$=this.store.select(h1,this.cardId),this.hparamsEnabled$=this.store.select(hf)}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}getRunDisplayNameAndAlias(e){return un([this.store.select(b1,{runId:e}),this.store.select(Bs),this.store.select(v1,{runId:e})]).pipe(U(([i,r,o])=>{let a=null!==i?r[i]??null:null;return{displayName:o||a?o?.name??"...":e,alias:a}}))}stepSeriesToLineSeries(e,i){let r=i===Pi.STEP;return e.map(o=>{let a=1e3*o.wallTime;return{...o,x:r?o.step:a,y:o.value,wallTime:a,relativeTimeInMs:0}})}onDataTableSorting(e){this.store.dispatch(lQ(e))}onCardStateChanged(e){this.store.dispatch(yT({cardId:this.cardId,settings:e}))}onTimeSelectionChanged(e){this.store.dispatch(Yf({...e,cardId:this.cardId}))}onStepSelectorToggled(e){this.store.dispatch(Dd({affordance:e,cardId:this.cardId}))}onLineChartZoom(e){this.store.dispatch(Mv({userViewBox:e,cardId:this.cardId}))}editColumnHeaders(e){this.store.dispatch(e0(e))}openTableEditMenuToMode(e){this.store.dispatch(pT({mode:e}))}onRemoveColumn(e){this.store.dispatch(t0({header:e,cardId:this.cardId}))}}return n.\u0275fac=function(e){return new(e||n)(C(ke))},n.\u0275cmp=k({type:n,selectors:[["scalar-card"]],inputs:{DataDownloadComponent:"DataDownloadComponent",cardId:"cardId",groupName:"groupName"},outputs:{pinStateChanged:"pinStateChanged"},decls:24,vars:72,consts:[["observeIntersection","",3,"cardId","chartMetadataMap","DataDownloadComponent","dataSeries","ignoreOutliers","isCardVisible","isPinned","loadState","showFullWidth","smoothingEnabled","tag","title","cardState","tooltipSort","xAxisType","xScaleType","useDarkMode","linkedTimeSelection","stepOrLinkedTimeSelection","forceSvg","columnCustomizationEnabled","minMaxStep","userViewBox","columnHeaders","rangeEnabled","hparamsEnabled","onFullSizeToggle","onPinClicked","onVisibilityChange","onTimeSelectionChanged","onStepSelectorToggled","onDataTableSorting","onLineChartZoom","editColumnHeaders","onCardStateChanged","openTableEditMenuToMode","removeColumn"]],template:function(e,i){1&e&&(h(0,"scalar-card-component",0),D("onFullSizeToggle",function(){return i.onFullSizeToggle()})("onPinClicked",function(o){return i.pinStateChanged.emit(o)})("onVisibilityChange",function(o){return i.onVisibilityChange(o)})("onTimeSelectionChanged",function(o){return i.onTimeSelectionChanged(o)})("onStepSelectorToggled",function(o){return i.onStepSelectorToggled(o)})("onDataTableSorting",function(o){return i.onDataTableSorting(o)})("onLineChartZoom",function(o){return i.onLineChartZoom(o)})("editColumnHeaders",function(o){return i.editColumnHeaders(o)})("onCardStateChanged",function(o){return i.onCardStateChanged(o)})("openTableEditMenuToMode",function(o){return i.openTableEditMenuToMode(o)})("removeColumn",function(o){return i.onRemoveColumn(o)}),G(1,"async"),G(2,"async"),G(3,"async"),G(4,"async"),G(5,"async"),G(6,"async"),G(7,"async"),G(8,"async"),G(9,"async"),G(10,"async"),G(11,"async"),G(12,"async"),G(13,"async"),G(14,"async"),G(15,"async"),G(16,"async"),G(17,"async"),G(18,"async"),G(19,"async"),G(20,"async"),G(21,"async"),G(22,"async"),G(23,"async"),g()),2&e&&_("cardId",i.cardId)("chartMetadataMap",W(1,26,i.chartMetadataMap$))("DataDownloadComponent",i.DataDownloadComponent)("dataSeries",W(2,28,i.dataSeries$))("ignoreOutliers",W(3,30,i.ignoreOutliers$))("isCardVisible",i.isVisible)("isPinned",W(4,32,i.isPinned$))("loadState",W(5,34,i.loadState$))("showFullWidth",W(6,36,i.showFullWidth$))("smoothingEnabled",W(7,38,i.smoothingEnabled$))("tag",W(8,40,i.tag$))("title",W(9,42,i.title$))("cardState",W(10,44,i.cardState$))("tooltipSort",W(11,46,i.tooltipSort$))("xAxisType",W(12,48,i.xAxisType$))("xScaleType",W(13,50,i.xScaleType$))("useDarkMode",W(14,52,i.useDarkMode$))("linkedTimeSelection",W(15,54,i.linkedTimeSelection$))("stepOrLinkedTimeSelection",W(16,56,i.stepOrLinkedTimeSelection$))("forceSvg",W(17,58,i.forceSvg$))("columnCustomizationEnabled",W(18,60,i.columnCustomizationEnabled$))("minMaxStep",W(19,62,i.minMaxSteps$))("userViewBox",W(20,64,i.userViewBox$))("columnHeaders",W(21,66,i.columnHeaders$))("rangeEnabled",W(22,68,i.rangeEnabled$))("hparamsEnabled",W(23,70,i.hparamsEnabled$))},dependencies:[o0,ine,lt],styles:["[_nghost-%COMP%] {\n        display: block;\n        height: 100%;\n      }"],changeDetection:0}),n})();function BNe(n,t,e){let i=[],{left:r,right:o}=t,a=(o-r)/e,s=0,l=0;for(let c=0;c<e;c++){let d=r+c*a,u=d+a,p=c===e-1,f=l;for(l=0;s<n.length;){let m=n[s],y=VNe(m,d,u,!p);if(f+=y.curr,l+=y.next,m.x+m.dx>u)break;s++}i.push({x:d,dx:a,y:f})}return i}function VNe(n,t,e,i){let r=n.x,o=n.x+n.dx;if(r>e||o<t)return{curr:0,next:0};if(0===n.dx)return i&&o>=e?{curr:0,next:n.y}:{curr:n.y,next:0};let a=Math.min(o,e)-Math.max(r,t);return{curr:n.y*a/n.dx,next:0}}var HNe=1e4,zNe=.001,UNe=Jr(".2~s"),jNe=Jr(".4~r"),GNe=Jr(".2~e");function ane(n){if(0===n)return"0";let t=Math.abs(n);return t>=HNe?UNe(n):t<zNe?GNe(n):jNe(n)}var WNe=["main"],qNe=["xAxis"],YNe=["yAxis"],XNe=["content"],QNe=["histograms"];function ZNe(n,t){if(1&n&&(Tn(),h(0,"g")(1,"text"),T(2),g()()),2&n){let e=w();Mt("transform",e.getCssTranslatePx(e.tooltipData.xAxis.position,9)),b(2),ut(e.tooltipData.xAxis.label)}}function KNe(n,t){if(1&n&&(Tn(),h(0,"g")(1,"text"),T(2),g()()),2&n){let e=w();Mt("transform",e.getGroupTransform(e.tooltipData.closestDatum)),b(1),Pe("y",e.tooltipData.yAxis.position),b(1),ze(" ",e.tooltipData.yAxis.label," ")}}function JNe(n,t){if(1&n){let e=ge();Tn(),Oo(),Tt(0),h(1,"histogram-card-fob-controller",16),D("onTimeSelectionChanged",function(r){return X(e),Q(w().onLinkedTimeSelectionChanged.emit(r))})("onTimeSelectionToggled",function(){return X(e),Q(w().onLinkedTimeToggled.emit())}),g(),Dt()}if(2&n){let e=w();b(1),_("timeSelection",e.timeSelection)("steps",e.getSteps())("temporalScale",e.scales.temporalScale)}}function $Ne(n,t){if(1&n&&(Tn(),h(0,"g"),P(1,"line",17),g()),2&n){let e=t.$implicit;Mt("transform",w().getCssTranslatePx(0,e))}}function e3e(n,t){1&n&&(Tn(),P(0,"line",21))}function t3e(n,t){if(1&n&&(Tn(),P(0,"circle",22)),2&n){let e=w().$implicit,i=w();Mt("transform",i.getCssTranslatePx(i.getUiCoordFromBinForContent(i.getClosestBinFromBinCoordinate(e,i.tooltipData.xPositionInBinCoord)).x,i.getUiCoordFromBinForContent(i.getClosestBinFromBinCoordinate(e,i.tooltipData.xPositionInBinCoord)).y))}}function n3e(n,t){if(1&n){let e=ge();Tn(),h(0,"g",18),D("mouseenter",function(r){let a=X(e).$implicit;return Q(w().updateColorOnHover(r,a,!0))})("mouseleave",function(r){let a=X(e).$implicit;return Q(w().updateColorOnHover(r,a,!1))})("click",function(){let o=X(e).$implicit;return Q(w().onLinkedTimeRangeChanged(o))}),S(1,e3e,1,0,"line",19),P(2,"path"),S(3,t3e,1,2,"circle",20),g()}if(2&n){let e=t.$implicit,i=w();Mt("transform",i.getGroupTransform(e))("color",i.getHistogramFill(e)),Qe("histogram",!0)("no-color",!i.isDatumInTimeSelectionRange(e)),b(1),_("ngIf",i.mode===i.HistogramMode.OFFSET),b(1),Pe("d",i.getHistogramPath(e)),b(1),_("ngIf",i.tooltipData)}}function i3e(n,t){if(1&n&&(Tn(),P(0,"circle",22)),2&n){let e=w(2);Pe("cx",e.getUiCoordFromBinForContent(e.tooltipData.closestBin).x)("cy",e.getUiCoordFromBinForContent(e.tooltipData.closestBin).y)}}function r3e(n,t){if(1&n&&(Tn(),h(0,"g",4)(1,"g"),P(2,"path"),S(3,i3e,1,2,"circle",23),g(),h(4,"g",24)(5,"text",25),T(6),g()()()),2&n){let e=w();b(1),Mt("transform",e.getGroupTransform(e.tooltipData.closestDatum)),b(1),Pe("d",e.getHistogramPath(e.tooltipData.closestDatum)),b(1),_("ngIf",e.tooltipData.closestBin),b(1),Mt("transform",e.getCssTranslatePx(e.tooltipData.value.position.x,e.tooltipData.value.position.y)),b(2),ut(e.tooltipData.value.label)}}var hA=(()=>{class n{constructor(e){this.changeDetector=e,this.mode=Sr.OFFSET,this.timeProperty=oo.STEP,this.timeSelection=null,this.onLinkedTimeSelectionChanged=new L,this.onLinkedTimeToggled=new L,this.HistogramMode=Sr,this.TimeProperty=oo,this.tooltipData=null,this.ngUnsubscribe=new Ae,this.layout={histogramHeight:0,contentClientRect:{height:0,width:0}},this.scales=null,this.formatters={binNumber:ane,count:Jr(".3n"),wallTime:M0("%m/%d %X"),step:Jr(".0f"),relative:i=>Jr(".1r")(i/36e5)+"h"},this.domVisible=!1}ngOnChanges(){this.updateChartIfVisible()}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}ngAfterViewInit(){ai(this.main.nativeElement,"mousemove",{passive:!0}).pipe(ot(this.ngUnsubscribe)).subscribe(e=>this.onMouseMove(e))}getCssTranslatePx(e,i){return`translate(${e}px, ${i}px)`}getClosestBinFromBinCoordinate(e,i){if(!e.bins.length)return{x:0,dx:0,y:0};let r=e.bins[0],o=e.bins.slice(-1)[0];return i<r.x?r:i>=o.x+o.dx?o:e.bins.find(s=>s.x<=i&&i<s.x+s.dx)}getUiCoordFromBinForContent(e){return this.scales?{x:this.scales.binScale(nC(e)),y:this.scales.countScale(e.y)}:{x:0,y:0}}getHistogramPath(e){if(!this.scales||!e.bins.length)return"";let i=this.scales.binScale,r=this.scales.countScale,o=e.bins[0],a=e.bins.slice(-1)[0],s=[`M${i(nC(o))},${r(0)}`];for(let l of e.bins)s.push(`L${i(nC(l))},${r(l.y)}`);return s.push(`L${i(nC(a))},${r(0)}`),s.join("")}trackByWallTime(e){return e.wallTime}getGroupTransform(e){return this.scales&&this.mode!==Sr.OVERLAY?this.getCssTranslatePx(0,this.scales.temporalScale(this.getTimeValue(e))):""}getSteps(){return this.data.map(e=>e.step)}isTimeSelectionEnabled(e){return Boolean(this.mode===Sr.OFFSET&&this.timeProperty===oo.STEP&&this.scales&&e)}isDatumInTimeSelectionRange(e){return!this.isTimeSelectionEnabled(this.timeSelection)||(null===this.timeSelection.end?this.timeSelection.start.step===e.step:this.timeSelection.start.step<=e.step&&this.timeSelection.end.step>=e.step)}getHistogramFill(e){return this.scales?this.scales.d3ColorScale(this.getTimeValue(e)):""}updateColorOnHover(e,i,r){!this.isTimeSelectionEnabled(this.timeSelection)||this.isDatumInTimeSelectionRange(i)||(r?e.target.classList.remove("no-color"):e.target.classList.add("no-color"))}getGridTickYLocs(){if(!this.scales||this.mode===Sr.OFFSET)return[];let e=this.scales.countScale;return e.ticks().map(i=>e(i))}onResize(){this.updateClientRects(),this.updateChartIfVisible()}onVisibilityChange({visible:e}){this.domVisible=e,e&&(this.updateClientRects(),this.updateChartIfVisible())}onLinkedTimeRangeChanged(e){if(!this.isTimeSelectionEnabled(this.timeSelection))return;let i=this.timeSelection.start.step,r=this.timeSelection.end?.step,o=e.step<i?e.step:i,a=r;a=void 0===a?e.step>i?e.step:i:e.step>a?e.step:a,(o!==i||a!==r)&&o!==a&&this.onLinkedTimeSelectionChanged.emit({timeSelection:{start:{step:o},end:{step:a}},affordance:ja.HISTOGRAM_CLICK_TO_RANGE})}getTimeValue(e){switch(this.timeProperty){case oo.WALL_TIME:return e.wallTime;case oo.STEP:return e.step;case oo.RELATIVE:return e.wallTime-this.data[0].wallTime}}updateClientRects(){this.content&&(this.layout.contentClientRect=this.content.nativeElement.getBoundingClientRect(),this.layout.histogramHeight=this.layout.contentClientRect.height/2.5)}updateChartIfVisible(){!this.domVisible||(this.scales=this.computeScales(this.data),this.renderXAxis(),this.renderYAxis(),this.changeDetector.detectChanges())}computeScales(e){let{width:i,height:r}=this.layout.contentClientRect,{min:o,max:a}=sne(e,v=>function(n,t){return n.reduce((e,i)=>Math.min(e,i.x),1/0)}(v.bins),v=>YV(v.bins,({x:x,dx:R})=>x+R)),s=YV(e,v=>YV(v.bins,({y:x})=>x)),l=Ul().domain([o,a]).nice(),c=this.mode!==Sr.OVERLAY&&this.timeProperty==oo.WALL_TIME?fm():Ul(),d=e.map(v=>this.getTimeValue(v)),{min:u,max:p}=sne(d,v=>v),f=[u,p];c.domain(f);let m=Ul();m.domain([0,s]);let y=$f(this.color||"#000"),M=Ul();return M.domain(f),l.range([0,i]),M.range([y.brighter(),y.darker()]),M.interpolate(BN),this.mode===Sr.OVERLAY?(c.range([r,r]),m.range([r,0])):(c.range([r-(this.mode===Sr.OFFSET?r-this.layout.histogramHeight:0),r]),m.range([0,-this.layout.histogramHeight])),{binScale:l,d3ColorScale:M,countScale:m,temporalScale:c}}renderXAxis(){if(!this.scales)return;let{width:e}=this.layout.contentClientRect,i=function(n){return sZ(fN,n)}(this.scales.binScale).ticks(Math.max(2,e/20));i.tickFormat(this.formatters.binNumber),i(sD(this.xAxis.nativeElement))}getYAxisFormatter(){if(this.mode===Sr.OVERLAY)return this.formatters.count;switch(this.timeProperty){case oo.WALL_TIME:return this.formatters.wallTime;case oo.STEP:return this.formatters.step;case oo.RELATIVE:return this.formatters.relative;default:throw RangeError(`Y axis formatter for ${this.timeProperty} must be implemented`)}}getMaxTicks(e){let{height:i}=this.layout.contentClientRect,r=i/15;if(this.timeProperty===oo.STEP){let[o,a]=e.domain(),s=Math.max(a-o+1,1);return Math.min(s,r)}return r}renderYAxis(){if(!this.scales)return;let e=this.mode===Sr.OVERLAY?this.scales.countScale:this.scales.temporalScale,i=this.getMaxTicks(e),r=function(n){return sZ(tD,n)}(e).ticks(Math.max(2,i));r.tickFormat(this.getYAxisFormatter()),r(sD(this.yAxis.nativeElement))}findClosestDatumIndex(e){let i=e.target,r=i;for(;i&&i!==this.histograms.nativeElement;)r=i,i=i.parentElement;return i?Array.from(i.children).indexOf(r):-1}onMouseMoveForTestOnly(e){return this.onMouseMove(e)}onMouseMove(e){if(!this.scales)return;let i=e.offsetX,r=e.offsetY,o=this.findClosestDatumIndex(e);if(o<0)return;let a=this.scales.binScale.invert(i),s=this.data[o],l=this.getClosestBinFromBinCoordinate(s,a);this.tooltipData={value:{position:{x:i,y:r},label:this.mode===Sr.OFFSET?this.formatters.count(l.y):`Step: ${this.formatters.step(s.step)}`},xAxis:{position:this.getUiCoordFromBinForContent(l).x,label:this.formatters.binNumber(nC(l))},yAxis:{position:this.scales.countScale(this.mode===Sr.OFFSET?0:l.y),label:this.mode===Sr.OFFSET?this.getYAxisFormatter()(this.getTimeValue(s)):this.formatters.binNumber(l.y)},xPositionInBinCoord:a,closestDatum:s,closestBin:l},this.changeDetector.detectChanges()}}return n.\u0275fac=function(e){return new(e||n)(C(Ft))},n.\u0275cmp=k({type:n,selectors:[["tb-histogram"]],viewQuery:function(e,i){if(1&e&&(Ye(WNe,5),Ye(qNe,5),Ye(YNe,5),Ye(XNe,5),Ye(QNe,5)),2&e){let r;we(r=Se())&&(i.main=r.first),we(r=Se())&&(i.xAxis=r.first),we(r=Se())&&(i.yAxis=r.first),we(r=Se())&&(i.content=r.first),we(r=Se())&&(i.histograms=r.first)}},inputs:{mode:"mode",timeProperty:"timeProperty",color:"color",data:"data",timeSelection:"timeSelection"},outputs:{onLinkedTimeSelectionChanged:"onLinkedTimeSelectionChanged",onLinkedTimeToggled:"onLinkedTimeToggled"},features:[Gt],decls:22,vars:15,consts:[["detectResize","","observeIntersection","",3,"onResize","onVisibilityChange"],["main",""],[1,"axis","x-axis"],["xAxis",""],[1,"tooltip"],[3,"transform",4,"ngIf"],[1,"axis","y-axis"],["yAxis",""],[4,"ngIf"],[1,"content"],["content",""],[1,"grid"],[3,"transform",4,"ngFor","ngForOf"],["histograms",""],[3,"transform","histogram","no-color","color","mouseenter","mouseleave","click",4,"ngFor","ngForOf","ngForTrackBy"],["class","tooltip",4,"ngIf"],[1,"histogram-card-fob",3,"timeSelection","steps","temporalScale","onTimeSelectionChanged","onTimeSelectionToggled"],["x2","100%",1,"tick"],[3,"mouseenter","mouseleave","click"],["class","baseline","x2","100%",4,"ngIf"],["r","2",3,"transform",4,"ngIf"],["x2","100%",1,"baseline"],["r","2"],["r","2",4,"ngIf"],[1,"value-label"],["x","3","y","-3"]],template:function(e,i){1&e&&(h(0,"div",0,1),D("onResize",function(){return i.onResize()})("onVisibilityChange",function(o){return i.onVisibilityChange(o)}),Tn(),h(2,"svg",2),P(3,"g",null,3),h(5,"g",4),S(6,ZNe,3,3,"g",5),g()(),Oo(),h(7,"div",6),Tn(),h(8,"svg"),P(9,"g",null,7),h(11,"g",4),S(12,KNe,3,4,"g",5),g()(),S(13,JNe,2,3,"ng-container",8),g(),h(14,"svg",9,10)(16,"g",11),S(17,$Ne,2,2,"g",12),g(),h(18,"g",null,13),S(20,n3e,4,11,"g",14),g(),S(21,r3e,7,7,"g",15),g()()),2&e&&(ka("main "+i.mode+" "+i.timeProperty),b(6),_("ngIf",i.tooltipData),b(5),Mt("transform",i.getCssTranslatePx(9,0)),b(1),_("ngIf",i.tooltipData),b(1),_("ngIf",i.isTimeSelectionEnabled(i.timeSelection)),b(4),_("ngForOf",i.getGridTickYLocs()),b(1),Qe("histograms",!0)("linked-time-single-step",i.timeSelection&&!i.timeSelection.end),b(2),_("ngForOf",i.data)("ngForTrackBy",i.trackByWallTime),b(1),_("ngIf",i.tooltipData))},styles:['[_nghost-%COMP%], .main[_ngcontent-%COMP%]{display:inline-block;height:100%;width:100%}[_nghost-%COMP%]{box-sizing:border-box;padding:10px}.main[_ngcontent-%COMP%]{display:grid;grid-template-areas:"content y-axis" "x-axis .";grid-template-columns:1fr 50px;grid-template-rows:1fr 30px}.main.wall_time[_ngcontent-%COMP%]{grid-template-columns:1fr 75px}.tooltip[_ngcontent-%COMP%], .baseline[_ngcontent-%COMP%]{color:#000}body.dark-mode[_nghost-%COMP%]   .tooltip[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .tooltip[_ngcontent-%COMP%]{color:#fff}body.dark-mode[_nghost-%COMP%]   .baseline[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .baseline[_ngcontent-%COMP%]{color:#fff}.linked-time-fob[_ngcontent-%COMP%]   text[_ngcontent-%COMP%], .tooltip[_ngcontent-%COMP%]   text[_ngcontent-%COMP%]{font-weight:bold;font-size:10px}.linked-time-fob[_ngcontent-%COMP%]   text[_ngcontent-%COMP%], .linked-time-fob[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .tooltip[_ngcontent-%COMP%]   text[_ngcontent-%COMP%], .tooltip[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{fill:currentColor}.linked-time-fob[_ngcontent-%COMP%]   .value-label[_ngcontent-%COMP%], .tooltip[_ngcontent-%COMP%]   .value-label[_ngcontent-%COMP%]{dominant-baseline:ideographic;text-anchor:start}.axis[_ngcontent-%COMP%]    {color:#616161;position:relative;overflow:hidden}body.dark-mode[_nghost-%COMP%]   .axis[_ngcontent-%COMP%]    , body.dark-mode   [_nghost-%COMP%]   .axis[_ngcontent-%COMP%]    {color:rgba(255,255,255,.7)}.axis[_ngcontent-%COMP%]     .domain, .axis[_ngcontent-%COMP%]     .tick text{display:none}.axis[_ngcontent-%COMP%]     .tick:nth-child(2n+1) text{display:initial}svg[_ngcontent-%COMP%]{height:100%;width:100%;pointer-events:visiblePainted}svg[_ngcontent-%COMP%]   line[_ngcontent-%COMP%], svg[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], svg[_ngcontent-%COMP%]   .tooltip[_ngcontent-%COMP%]{pointer-events:none}svg[_ngcontent-%COMP%]   g[_ngcontent-%COMP%]{will-change:transform}.x-axis[_ngcontent-%COMP%]{grid-area:x-axis}.x-axis[_ngcontent-%COMP%]   .tooltip[_ngcontent-%COMP%]{dominant-baseline:hanging;text-anchor:middle}.y-axis[_ngcontent-%COMP%]{grid-area:y-axis;overflow:clip visible}.y-axis[_ngcontent-%COMP%]   .tooltip[_ngcontent-%COMP%]{dominant-baseline:middle;text-anchor:start}.histogram-card-fob[_ngcontent-%COMP%]{left:9px;position:absolute}.content[_ngcontent-%COMP%]   .tick[_ngcontent-%COMP%], .axis[_ngcontent-%COMP%]     .tick line{stroke:#ddd}body.dark-mode[_nghost-%COMP%]   .content[_ngcontent-%COMP%]   .tick[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .content[_ngcontent-%COMP%]   .tick[_ngcontent-%COMP%]{stroke:#555}body.dark-mode[_nghost-%COMP%]   .axis[_ngcontent-%COMP%]     .tick line, body.dark-mode   [_nghost-%COMP%]   .axis[_ngcontent-%COMP%]     .tick line{stroke:#555}.content[_ngcontent-%COMP%]{grid-area:content;overflow:visible;z-index:1}.content[_ngcontent-%COMP%]   .tick[_ngcontent-%COMP%]{stroke-width:1px;stroke-dasharray:2}.content[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .content[_ngcontent-%COMP%]   path[_ngcontent-%COMP%]{fill:currentColor;stroke-opacity:.6;stroke-width:1px}.content[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{filter:drop-shadow(0 0 1px rgba(0, 0, 0, 0.6));stroke:#fff;will-change:transform}.content[_ngcontent-%COMP%]   .baseline[_ngcontent-%COMP%]{stroke-opacity:.1;stroke-width:1px;stroke:currentColor;width:100%}.content[_ngcontent-%COMP%]   .tooltip[_ngcontent-%COMP%]   path[_ngcontent-%COMP%]{stroke-opacity:1;stroke:currentColor;fill:rgba(0,0,0,0)}.content[_ngcontent-%COMP%]   .no-color[_ngcontent-%COMP%]{color:rgba(221,221,221,.4) !important}.content[_ngcontent-%COMP%]   .no-color[_ngcontent-%COMP%]   path[_ngcontent-%COMP%]{stroke-opacity:.2}body.dark-mode[_nghost-%COMP%]   .content[_ngcontent-%COMP%]   .no-color[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .content[_ngcontent-%COMP%]   .no-color[_ngcontent-%COMP%]{color:rgba(51,51,51,.4) !important}.offset[_ngcontent-%COMP%]   .content[_ngcontent-%COMP%]   .histograms[_ngcontent-%COMP%]   path[_ngcontent-%COMP%]{stroke:#fff}body.dark-mode[_nghost-%COMP%]   .offset[_ngcontent-%COMP%]   .content[_ngcontent-%COMP%]   .histograms[_ngcontent-%COMP%]   path[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .offset[_ngcontent-%COMP%]   .content[_ngcontent-%COMP%]   .histograms[_ngcontent-%COMP%]   path[_ngcontent-%COMP%]{stroke:#555}.offset[_ngcontent-%COMP%]   .content[_ngcontent-%COMP%]   .histograms.linked-time-single-step[_ngcontent-%COMP%]   [_ngcontent-%COMP%]:not(.no-color)   path[_ngcontent-%COMP%]{stroke:#000}body.dark-mode[_nghost-%COMP%]   .offset[_ngcontent-%COMP%]   .content[_ngcontent-%COMP%]   .histograms.linked-time-single-step[_ngcontent-%COMP%]   [_ngcontent-%COMP%]:not(.no-color)   path[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .offset[_ngcontent-%COMP%]   .content[_ngcontent-%COMP%]   .histograms.linked-time-single-step[_ngcontent-%COMP%]   [_ngcontent-%COMP%]:not(.no-color)   path[_ngcontent-%COMP%]{stroke:#fff}.overlay[_ngcontent-%COMP%]   .x-axis[_ngcontent-%COMP%]     .tick line{display:none}.overlay[_ngcontent-%COMP%]   .content[_ngcontent-%COMP%]   path[_ngcontent-%COMP%]{fill-opacity:0;stroke:currentColor}.tooltip[_ngcontent-%COMP%], .content[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{display:none}.main[_ngcontent-%COMP%]:hover   .content[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .main[_ngcontent-%COMP%]:hover   .tooltip[_ngcontent-%COMP%]{display:block}'],changeDetection:0}),n})();function YV(n,t){return n.reduce((e,i)=>Math.max(e,t(i)),-1/0)}function sne(n,t,e){e||(e=t);let i=1/0,r=-1/0;for(let o of n)i=Math.min(i,t(o)),r=Math.max(r,e(o));return{min:i,max:r}}function nC(n){return n.x+.5*n.dx}function s3e(n,t){1&n&&(h(0,"span",14),P(1,"mat-spinner",15),g())}function l3e(n,t){if(1&n){let e=ge();h(0,"tb-histogram",16),D("onLinkedTimeSelectionChanged",function(r){return X(e),Q(w().onLinkedTimeSelectionChanged.emit(r))})("onLinkedTimeToggled",function(){return X(e),Q(w().onLinkedTimeToggled.emit())}),g()}if(2&n){let e=w();_("data",e.data)("mode",e.mode)("timeProperty",e.timeProperty(e.xAxisType))("color",e.runColorScale(e.runId))("timeSelection",e.convertToTimeSelection(e.linkedTimeSelection))}}function c3e(n,t){1&n&&(h(0,"div",18),T(1," Data failed to load. "),g())}function d3e(n,t){if(1&n&&S(0,c3e,2,0,"div",17),2&n){let e=w();_("ngIf",e.loadState===e.DataLoadState.FAILED)}}var u3e=function(n){return{backgroundColor:n}},lne=(()=>{class n{constructor(){this.DataLoadState=De,this.onFullSizeToggle=new L,this.onPinClicked=new L,this.onLinkedTimeSelectionChanged=new L,this.onLinkedTimeToggled=new L}timeProperty(e){switch(e){case Pi.STEP:return oo.STEP;case Pi.WALL_TIME:return oo.WALL_TIME;case Pi.RELATIVE:return oo.RELATIVE;default:throw new Error("Invalid xAxisType for histogram time property.")}}convertToTimeSelection(e){return null===e?null:{start:{step:e.startStep},end:e.endStep?{step:e.endStep}:null}}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["histogram-card-component"]],inputs:{loadState:"loadState",title:"title",tag:"tag",runId:"runId",data:"data",mode:"mode",xAxisType:"xAxisType",runColorScale:"runColorScale",showFullWidth:"showFullWidth",isPinned:"isPinned",linkedTimeSelection:"linkedTimeSelection",isClosestStepHighlighted:"isClosestStepHighlighted"},outputs:{onFullSizeToggle:"onFullSizeToggle",onPinClicked:"onPinClicked",onLinkedTimeSelectionChanged:"onLinkedTimeSelectionChanged",onLinkedTimeToggled:"onLinkedTimeToggled"},decls:16,vars:14,consts:function(){let t,e;return t=$localize`:A button to pin a card.␟e665dc712bd5f18d4dfa3a29e125d565cc51e2f6␟7284606426234375344:Pin card`,e=$localize`:A button on a histogram card that toggles full size mode.␟fc8f767d0b9f930187a1bae34477ad28736ece33␟915721563638926597:Toggle full size mode`,[[1,"heading"],[1,"tag"],[3,"title","value"],[3,"isClipped","isClosestStepHighlighted"],[1,"run"],[1,"dot",3,"ngStyle"],[1,"run-text",3,"runId"],[1,"controls"],["mat-icon-button","","aria-label",t,1,"pin-button",3,"click"],[3,"svgIcon"],["mat-icon-button","","aria-label",e,"title","Toggle full size mode",3,"click"],["class","spinner",4,"ngIf"],[3,"data","mode","timeProperty","color","timeSelection","onLinkedTimeSelectionChanged","onLinkedTimeToggled",4,"ngIf","ngIfElse"],["noData",""],[1,"spinner"],["diameter","18"],[3,"data","mode","timeProperty","color","timeSelection","onLinkedTimeSelectionChanged","onLinkedTimeToggled"],["class","empty-message",4,"ngIf"],[1,"empty-message"]]},template:function(e,i){if(1&e&&(h(0,"div",0)(1,"div",1),P(2,"tb-truncated-path",2)(3,"vis-linked-time-selection-warning",3),g(),h(4,"div",4),P(5,"span",5)(6,"card-run-name",6),g(),h(7,"span",7)(8,"button",8),D("click",function(){return i.onPinClicked.emit(!i.isPinned)}),P(9,"mat-icon",9),g(),h(10,"button",10),D("click",function(){return i.onFullSizeToggle.emit()}),P(11,"mat-icon",9),g()(),S(12,s3e,2,0,"span",11),g(),S(13,l3e,1,5,"tb-histogram",12),S(14,d3e,1,1,"ng-template",null,13,Zt)),2&e){let r=tt(15);b(2),_("title",i.tag)("value",i.title),b(1),_("isClipped",i.linkedTimeSelection&&i.linkedTimeSelection.clipped)("isClosestStepHighlighted",i.isClosestStepHighlighted),b(2),_("ngStyle",Sn(12,u3e,i.runColorScale(i.runId))),b(1),_("runId",i.runId),b(2),Pe("title",i.isPinned?"Unpin card":"Pin card"),b(1),_("svgIcon",i.isPinned?"keep_24px":"keep_outline_24px"),b(2),_("svgIcon",i.showFullWidth?"fullscreen_exit_24px":"fullscreen_24px"),b(1),_("ngIf",i.loadState===i.DataLoadState.LOADING),b(1),_("ngIf",i.data&&i.data.length)("ngIfElse",r)}},dependencies:[Fe,mu,hA,Fn,Dn,zr,KT,s0,l0],styles:['[_nghost-%COMP%]{box-sizing:border-box;display:flex;flex-basis:318px;flex-direction:column;flex-grow:1;height:100%;overflow:auto;padding:16px;padding-top:4px}.heading[_ngcontent-%COMP%]{align-items:center;display:grid;grid-template-areas:"tag controls" "run spinner";grid-template-columns:1fr auto;font-size:14px;margin-bottom:4px}.tag[_ngcontent-%COMP%]{align-items:center;display:flex;gap:5px;grid-area:tag;overflow:hidden}.tag[_ngcontent-%COMP%]   vis-selected-time-clipped[_ngcontent-%COMP%]{line-height:0}.pin-button[_ngcontent-%COMP%]   mat-icon[_ngcontent-%COMP%]{height:18px}.run[_ngcontent-%COMP%]{grid-area:run;display:flex;white-space:nowrap;font-size:13px}.run[_ngcontent-%COMP%]   .dot[_ngcontent-%COMP%]{flex:none;display:inline-block;width:13px;height:13px;border-radius:50%;margin-right:4px}.run[_ngcontent-%COMP%]   .run-text[_ngcontent-%COMP%]{overflow:hidden;text-overflow:ellipsis;max-width:120px}.controls[_ngcontent-%COMP%]{color:#616161;white-space:nowrap;grid-area:controls;justify-self:flex-end;flex-shrink:0;margin-right:-12px}body.dark-mode[_nghost-%COMP%]   .controls[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .controls[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}.spinner[_ngcontent-%COMP%]{display:flex;grid-area:spinner;height:100%;justify-content:center;position:relative}mat-spinner[_ngcontent-%COMP%]{top:0;right:0;position:absolute}tb-histogram[_ngcontent-%COMP%]{flex-grow:1}.empty-message[_ngcontent-%COMP%]{margin-top:1em;font-size:13px}'],changeDetection:0}),n})(),cne=(()=>{class n{constructor(e){this.store=e,this.pinStateChanged=new L,this.mode$=this.store.select(s1),this.xAxisType$=this.store.select(Dl),this.showFullWidth$=this.store.select(js).pipe(U(i=>i[this.cardId]?.fullWidth))}isHistogramCardMetadata(e){let{plugin:i}=e;return i===qn.HISTOGRAMS}onFullSizeToggle(){this.store.dispatch(Kg({cardId:this.cardId}))}ngOnInit(){let i=this.store.select(Us,this.cardId).pipe(Ve(o=>!!o&&this.isHistogramCardMetadata(o)),U(o=>o)),r=un([i,this.store.select(Eu,this.cardId)]);this.data$=r.pipe(U(([o,a])=>{let s=o.runId;return a&&a.hasOwnProperty(s)?function(n,t=30){if(!n.length||t<1)return[];let e=function(n){let t=null,e=null;for(let{bins:i}of n){if(!i.length)continue;let r=i[i.length-1],o=i[0].x,a=r.x+r.dx;(null===t||o<t)&&(t=o),(null===e||a>e)&&(e=a)}return null===t||null===e?null:{left:t,right:e}}(n);return e&&e.left===e.right&&(e.right=1.1*e.right+1,e.left=e.left/1.1-1),n.map(i=>({step:i.step,wallTime:i.wallTime,bins:e?BNe(i.bins,e,t):[]}))}(a[s].map(d=>{let{wallTime:u,step:p}=d;return{wallTime:u,step:p,bins:d.bins.map(m=>({x:m.min,dx:m.max-m.min,y:m.count}))}})):[]})),this.steps$=this.data$.pipe(U(o=>o.map(a=>a.step))),this.linkedTimeSelection$=un([this.store.select(Au),this.steps$,this.store.select(Iu)]).pipe(U(([o,a,s])=>{if(!o)return null;let l=1/0,c=-1/0;for(let p of a)l=Math.min(p,l),c=Math.max(p,c);return function(n,t){if(null!==n.endStep)return n;let e=function(n,t){let e=1/0,i=null;for(let r of t){let o=Math.abs(n-r);o<e&&(e=o,i=r)}return i}(n.startStep,t);return null!==e?{...n,startStep:e}:n}($h(OF(o,s),l,c),a)})),this.isClosestStepHighlighted$=un([this.store.select(Au),this.linkedTimeSelection$]).pipe(U(([o,a])=>o&&a&&!a.clipped&&null===o.end&&o.start.step!==a.startStep)),this.loadState$=this.store.select(hd,this.cardId),this.tag$=i.pipe(U(o=>o.tag)),this.title$=this.tag$.pipe(U(o=>a0(o,this.groupName))),this.runId$=i.pipe(U(o=>o.runId)),this.isPinned$=this.store.select(Tu,this.cardId)}onLinkedTimeSelectionChanged(e){this.store.dispatch(Yf(e))}onLinkedTimeToggled(){this.store.dispatch(Dd({affordance:Ga.FOB_DESELECT}))}}return n.\u0275fac=function(e){return new(e||n)(C(ke))},n.\u0275cmp=k({type:n,selectors:[["histogram-card"]],inputs:{cardId:"cardId",groupName:"groupName",runColorScale:"runColorScale"},outputs:{pinStateChanged:"pinStateChanged"},decls:12,vars:34,consts:[[3,"loadState","title","tag","runId","data","mode","xAxisType","runColorScale","showFullWidth","isPinned","isClosestStepHighlighted","linkedTimeSelection","onFullSizeToggle","onPinClicked","onLinkedTimeSelectionChanged","onLinkedTimeToggled"]],template:function(e,i){1&e&&(h(0,"histogram-card-component",0),D("onFullSizeToggle",function(){return i.onFullSizeToggle()})("onPinClicked",function(o){return i.pinStateChanged.emit(o)})("onLinkedTimeSelectionChanged",function(o){return i.onLinkedTimeSelectionChanged(o)})("onLinkedTimeToggled",function(){return i.onLinkedTimeToggled()}),G(1,"async"),G(2,"async"),G(3,"async"),G(4,"async"),G(5,"async"),G(6,"async"),G(7,"async"),G(8,"async"),G(9,"async"),G(10,"async"),G(11,"async"),g()),2&e&&_("loadState",W(1,12,i.loadState$))("title",W(2,14,i.title$))("tag",W(3,16,i.tag$))("runId",W(4,18,i.runId$))("data",W(5,20,i.data$))("mode",W(6,22,i.mode$))("xAxisType",W(7,24,i.xAxisType$))("runColorScale",i.runColorScale)("showFullWidth",W(8,26,i.showFullWidth$))("isPinned",W(9,28,i.isPinned$))("isClosestStepHighlighted",W(10,30,i.isClosestStepHighlighted$))("linkedTimeSelection",W(11,32,i.linkedTimeSelection$))},dependencies:[lne,lt],styles:["[_nghost-%COMP%] {\n        display: flex;\n        flex-direction: column;\n        height: 100%;\n      }"],changeDetection:0}),n})();function m3e(n,t){if(1&n){let e=ge();h(0,"image-card",6),D("fullWidthChanged",function(r){return X(e),Q(w(2).onFullWidthChanged(r))})("pinStateChanged",function(){return X(e),Q(w(2).onPinStateChanged())}),g()}if(2&n){let e=w(2);_("cardId",e.cardId)("groupName",e.groupName)("runColorScale",e.runColorScale)}}function h3e(n,t){if(1&n){let e=ge();h(0,"scalar-card",7),D("pinStateChanged",function(){return X(e),Q(w(2).onPinStateChanged())}),g()}if(2&n){let e=w(2);_("cardId",e.cardId)("groupName",e.groupName)}}function g3e(n,t){if(1&n){let e=ge();h(0,"histogram-card",8),D("pinStateChanged",function(){return X(e),Q(w(2).onPinStateChanged())}),g()}if(2&n){let e=w(2);_("cardId",e.cardId)("groupName",e.groupName)("runColorScale",e.runColorScale)}}function _3e(n,t){if(1&n&&(h(0,"div"),T(1),g()),2&n){let e=w(2);b(1),ze("Placeholder error for: ",e.cardId,"")}}function y3e(n,t){if(1&n&&(Tt(0,1),S(1,m3e,1,3,"image-card",2),S(2,h3e,1,2,"scalar-card",3),S(3,g3e,1,3,"histogram-card",4),S(4,_3e,2,1,"div",5),Dt()),2&n){let e=w();_("ngSwitch",e.pluginType),b(1),_("ngSwitchCase",e.PluginType.IMAGES),b(1),_("ngSwitchCase",e.PluginType.SCALARS),b(1),_("ngSwitchCase",e.PluginType.HISTOGRAMS)}}var dne=(()=>{class n{constructor(){this.PluginType=qn,this.fullWidthChanged=new L,this.fullHeightChanged=new L,this.pinStateChanged=new L}onFullWidthChanged(e){this.fullWidthChanged.emit(e)}onFullHeightChanged(e){this.fullHeightChanged.emit(e)}onPinStateChanged(){this.pinStateChanged.emit()}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["card-view-component"]],inputs:{isEverVisible:"isEverVisible",cardId:"cardId",groupName:"groupName",pluginType:"pluginType",runColorScale:"runColorScale"},outputs:{fullWidthChanged:"fullWidthChanged",fullHeightChanged:"fullHeightChanged",pinStateChanged:"pinStateChanged"},decls:1,vars:1,consts:[[3,"ngSwitch",4,"ngIf"],[3,"ngSwitch"],[3,"cardId","groupName","runColorScale","fullWidthChanged","pinStateChanged",4,"ngSwitchCase"],[3,"cardId","groupName","pinStateChanged",4,"ngSwitchCase"],[3,"cardId","groupName","runColorScale","pinStateChanged",4,"ngSwitchCase"],[4,"ngSwitchDefault"],[3,"cardId","groupName","runColorScale","fullWidthChanged","pinStateChanged"],[3,"cardId","groupName","pinStateChanged"],[3,"cardId","groupName","runColorScale","pinStateChanged"]],template:function(e,i){1&e&&S(0,y3e,5,4,"ng-container",0),2&e&&_("ngIf",i.isEverVisible)},dependencies:[Fe,$i,sr,fu,ZQ,rne,cne],encapsulation:2,changeDetection:0}),n})(),une=(()=>{class n{constructor(e){this.store=e,this.isEverVisible=!1,this.fullWidthChanged=new L,this.fullHeightChanged=new L,this.runColorScale$=this.store.select(ku).pipe(eu(350,void 0,{leading:!0,trailing:!0}),U(i=>r=>i.hasOwnProperty(r)?i[r]:"#fff"))}onVisibilityChange({visible:e}){this.isEverVisible=this.isEverVisible||e}onFullWidthChanged(e){this.fullWidthChanged.emit(e)}onFullHeightChanged(e){this.fullHeightChanged.emit(e)}onPinStateChanged(){this.store.select(Tu,this.cardId).pipe(zt(1),Yt(this.store.select(qW))).subscribe(([e,i])=>{this.store.dispatch($g({cardId:this.cardId,canCreateNewPins:i,wasPinned:e}))})}}return n.\u0275fac=function(e){return new(e||n)(C(ke))},n.\u0275cmp=k({type:n,selectors:[["card-view"]],inputs:{cardId:"cardId",groupName:"groupName",pluginType:"pluginType"},outputs:{fullWidthChanged:"fullWidthChanged",fullHeightChanged:"fullHeightChanged"},decls:2,vars:7,consts:[["observeIntersection","","intersectionObserverMargin","200px 200px 200px 200px",3,"isEverVisible","cardId","groupName","pluginType","runColorScale","fullWidthChanged","fullHeightChanged","pinStateChanged","onVisibilityChange"]],template:function(e,i){1&e&&(h(0,"card-view-component",0),D("fullWidthChanged",function(o){return i.onFullWidthChanged(o)})("fullHeightChanged",function(o){return i.onFullHeightChanged(o)})("pinStateChanged",function(){return i.onPinStateChanged()})("onVisibilityChange",function(o){return i.onVisibilityChange(o)}),G(1,"async"),g()),2&e&&_("isEverVisible",i.isEverVisible)("cardId",i.cardId)("groupName",i.groupName)("pluginType",i.pluginType)("runColorScale",W(1,5,i.runColorScale$))},dependencies:[o0,dne,lt],styles:["[_nghost-%COMP%]{background-color:#fff}body.dark-mode   [_nghost-%COMP%]{background-color:#303030}"],changeDetection:0}),n})();function C3e(n,t){1&n&&Ti(0)}var M3e=function(n,t){return{"full-width":n,"full-height":t}};function w3e(n,t){if(1&n){let e=ge();h(0,"div",5)(1,"card-view",6),D("fullWidthChanged",function(r){let a=X(e).$implicit;return Q(w(2).onFullWidthChanged(a.cardId,r))})("fullHeightChanged",function(r){let a=X(e).$implicit;return Q(w(2).onFullHeightChanged(a.cardId,r))}),g()()}if(2&n){let e=t.$implicit,i=w(2);_("ngClass",Pr(6,M3e,i.cardsAtFullWidth.has(e.cardId)||(null==i.cardStateMap[e.cardId]?null:i.cardStateMap[e.cardId].fullWidth),i.cardsAtFullHeight.has(e.cardId)||(null==i.cardStateMap[e.cardId]?null:i.cardStateMap[e.cardId].tableExpanded))),b(1),_("cardId",e.cardId)("groupName",i.groupName)("pluginType",e.plugin)("cardObserver",i.cardObserver)("cardLazyLoader",e.cardId)}}function S3e(n,t){1&n&&Ti(0)}var E3e=function(){return{isBottomControl:!1}},T3e=function(){return{isBottomControl:!0}};function D3e(n,t){if(1&n&&(h(0,"div"),S(1,C3e,1,0,"ng-container",2),h(2,"div",3),S(3,w3e,2,9,"div",4),g(),S(4,S3e,1,0,"ng-container",2),g()),2&n){let e=w(),i=tt(2);b(1),_("ngTemplateOutlet",i)("ngTemplateOutletContext",uu(8,E3e)),b(1),Mt("grid-template-columns",e.gridTemplateColumn),b(1),_("ngForOf",e.cardIdsWithMetadata)("ngForTrackBy",e.trackByCards),b(1),_("ngTemplateOutlet",i)("ngTemplateOutletContext",uu(9,T3e))}}function I3e(n,t){if(1&n){let e=ge();h(0,"button",12),D("click",function(r){X(e);let o=w(3);return Q(o.handlePageChange(o.pageIndex-1,r.target))}),T(1," Previous "),g()}2&n&&_("disabled",0===w(3).pageIndex)}function A3e(n,t){if(1&n){let e=ge();h(0,"span",15)(1,"input",16),D("input",function(r){return X(e),Q(w(4).onPaginationInputChange(r))})("change",function(r){return X(e),Q(w(4).onPaginationInputChange(r))}),g(),T(2),g()}if(2&n){let e=w(4);b(1),_("value",e.pageIndex+1)("max",e.numPages),b(1),ze(" of ",e.numPages,"")}}function R3e(n,t){if(1&n){let e=ge();h(0,"span"),S(1,A3e,3,3,"span",13),h(2,"button",14),D("click",function(r){X(e);let o=w(3);return Q(o.handlePageChange(o.pageIndex+1,r.target))}),T(3," Next "),g()()}if(2&n){let e=w(2).isBottomControl,i=w();b(1),_("ngIf",i.showPaginationInput(e)),b(1),_("disabled",i.pageIndex+1>=i.numPages)}}function k3e(n,t){if(1&n&&(h(0,"div",8)(1,"span",9),S(2,I3e,2,1,"button",10),g(),h(3,"span",11),S(4,R3e,4,2,"span",0),g()()),2&n){let e=w(2);b(2),_("ngIf",e.showPaginationControls),b(2),_("ngIf",e.showPaginationControls)}}function P3e(n,t){1&n&&S(0,k3e,5,2,"div",7),2&n&&_("ngIf",w().showPaginationControls)}var pne=(()=>{class n{constructor(e){this.cdkScrollable=e,this.PluginType=qn,this.gridTemplateColumn="",this.cardsAtFullWidth=new Set,this.cardsAtFullHeight=new Set,this.pageIndexChanged=new L}ngOnInit(){this.isCardWidthValid(this.cardMinWidth)&&(this.gridTemplateColumn=`repeat(auto-fill, minmax(${this.cardMinWidth}px, 1fr))`)}ngOnChanges(e){if(e.cardMinWidth){let i=e.cardMinWidth.currentValue;this.isCardWidthValid(i)?(this.cardMinWidth=i,this.gridTemplateColumn=`repeat(auto-fill, minmax(${this.cardMinWidth}px, 1fr))`):this.gridTemplateColumn=""}}isCardWidthValid(e){return e&&e>=335&&e<=735}showPaginationInput(e){return e}handlePageChange(e,i){let r=i.getBoundingClientRect().top;setTimeout(()=>{this.scrollToKeepTargetPosition(i,r)},0),this.pageIndexChanged.emit(e)}scrollToKeepTargetPosition(e,i){let r=this.cdkScrollable?.getElementRef().nativeElement;r&&r.scrollTo(0,e.getBoundingClientRect().top-i+r.scrollTop)}trackByCards(e,i){return i.cardId}onPaginationInputChange(e){let i=e.target;if("input"===e.type&&""===i.value)return;let r=Number(i.value)-1,o=Math.min(Math.max(0,r),this.numPages-1);i.value!==String(o+1)&&(i.value=String(o+1)),this.handlePageChange(o,i)}onFullWidthChanged(e,i){i?this.cardsAtFullWidth.add(e):this.cardsAtFullWidth.delete(e)}onFullHeightChanged(e,i){i?this.cardsAtFullHeight.add(e):this.cardsAtFullHeight.delete(e)}}return n.\u0275fac=function(e){return new(e||n)(C(Bu,8))},n.\u0275cmp=k({type:n,selectors:[["metrics-card-grid-component"]],inputs:{isGroupExpanded:"isGroupExpanded",pageIndex:"pageIndex",numPages:"numPages",cardIdsWithMetadata:"cardIdsWithMetadata",cardMinWidth:"cardMinWidth",cardObserver:"cardObserver",showPaginationControls:"showPaginationControls",cardStateMap:"cardStateMap"},outputs:{pageIndexChanged:"pageIndexChanged"},features:[Gt],decls:3,vars:1,consts:function(){let t,e;return t=$localize`:A button that sets a group to the previous page.␟575e782fd27f2ee70a034a775efe9ad162472250␟3629960544875360046:Previous page`,e=$localize`:A button that sets a group to the next page.␟ce3cefb1cd0099aa5003dda16ec9eb21fd8ba789␟3337301694210287595:Next page`,[[4,"ngIf"],["groupControls",""],[4,"ngTemplateOutlet","ngTemplateOutletContext"],[1,"card-grid"],["class","card-space",3,"ngClass",4,"ngFor","ngForOf","ngForTrackBy"],[1,"card-space",3,"ngClass"],[3,"cardId","groupName","pluginType","cardObserver","cardLazyLoader","fullWidthChanged","fullHeightChanged"],["class","group-controls",4,"ngIf"],[1,"group-controls"],[1,"prev-container"],["class","prev pagination-button","mat-button","","aria-label",t,3,"disabled","click",4,"ngIf"],[1,"input-and-next-container"],["mat-button","","aria-label",t,1,"prev","pagination-button",3,"disabled","click"],["class","pagination-input",4,"ngIf"],["mat-button","","aria-label",e,1,"next","pagination-button",3,"disabled","click"],[1,"pagination-input"],["type","number","min","1",3,"value","max","input","change"]]},template:function(e,i){1&e&&(S(0,D3e,5,10,"div",0),S(1,P3e,1,1,"ng-template",null,1,Zt)),2&e&&_("ngIf",i.isGroupExpanded)},dependencies:[CQ,une,bn,dn,Fe,Mo,Fn],styles:["[_nghost-%COMP%]{contain:content}.card-grid[_ngcontent-%COMP%]{display:grid;grid-template-columns:repeat(auto-fill, minmax(335px, 1fr));gap:16px;padding:16px}.card-space.full-width[_ngcontent-%COMP%]{grid-column-start:1;grid-column-end:-1}.card-space.full-height[_ngcontent-%COMP%]{min-height:480px}.card-space.full-height[_ngcontent-%COMP%]   card-view[_ngcontent-%COMP%]{height:100%}card-view[_ngcontent-%COMP%]{border:1px solid #ebebeb;border-radius:4px;box-sizing:border-box;contain:layout paint;display:block;min-height:320px}body.dark-mode[_nghost-%COMP%]   card-view[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   card-view[_ngcontent-%COMP%]{border:1px solid #555}.group-controls[_ngcontent-%COMP%]{color:#616161;display:grid;align-items:center;grid-template-columns:1fr 1fr;gap:16px;padding:0 16px}body.dark-mode[_nghost-%COMP%]   .group-controls[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .group-controls[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}.group-controls[_ngcontent-%COMP%]:first-of-type{padding-top:16px}.group-controls[_ngcontent-%COMP%]:last-of-type{padding-bottom:16px}.prev-container[_ngcontent-%COMP%]{justify-self:flex-start}.input-and-next-container[_ngcontent-%COMP%]{justify-self:flex-end}.pagination-input[_ngcontent-%COMP%]{margin-right:16px}.pagination-input[_ngcontent-%COMP%]   input[_ngcontent-%COMP%]{background:rgba(0,0,0,0);border:1px solid currentColor;color:inherit;font:inherit}.pagination-button[_ngcontent-%COMP%]{color:#616161;background-color:#fff}body.dark-mode[_nghost-%COMP%]   .pagination-button[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .pagination-button[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}.pagination-button[_ngcontent-%COMP%]:disabled{color:#757575}body.dark-mode[_nghost-%COMP%]   .pagination-button[_ngcontent-%COMP%]:disabled, body.dark-mode   [_nghost-%COMP%]   .pagination-button[_ngcontent-%COMP%]:disabled{color:#616161}"],changeDetection:0}),n})(),S_=(()=>{class n{constructor(e){this.store=e,this.groupName=null,this.groupName$=new Ri(null),this.pageIndex$=new Ri(0),this.items$=new Ri([]),this.ngUnsubscribe=new Ae,this.cardStateMap$=this.store.select(js),this.numPages$=un([this.items$,this.store.select(Ba.getPageSize)]).pipe(U(([i,r])=>Math.ceil(i.length/r))),this.isGroupExpanded$=this.groupName$.pipe(yi(i=>null!==i?this.store.select(p1,i):qt(!0))),this.showPaginationControls$=this.numPages$.pipe(U(i=>i>1)),this.normalizedPageIndex$=un([this.pageIndex$,this.numPages$]).pipe(ot(this.ngUnsubscribe),Vt(([i,r])=>{0!==r&&(i>=r?this.pageIndex$.next(r-1):i<0&&this.pageIndex$.next(0))}),U(([i,r])=>Math.min(Math.max(i,0),r-1)),Ea(1)),this.pagedItems$=un([this.items$,this.store.select(Ba.getPageSize),this.normalizedPageIndex$,this.isGroupExpanded$]).pipe(U(([i,r,o,a])=>i.slice(r*o,r*o+(a?r:0)))),this.cardMinWidth$=this.store.select(rg)}ngOnChanges(e){e.cardIdsWithMetadata&&this.items$.next(this.cardIdsWithMetadata),e.groupName&&this.groupName$.next(this.groupName)}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}onPageIndexChanged(e){this.pageIndex$.next(e)}}return n.\u0275fac=function(e){return new(e||n)(C(ke))},n.\u0275cmp=k({type:n,selectors:[["metrics-card-grid"]],inputs:{groupName:"groupName",cardIdsWithMetadata:"cardIdsWithMetadata",cardObserver:"cardObserver"},features:[Gt],decls:8,vars:22,consts:[[3,"isGroupExpanded","pageIndex","numPages","showPaginationControls","cardIdsWithMetadata","cardMinWidth","cardObserver","cardStateMap","pageIndexChanged"]],template:function(e,i){1&e&&(h(0,"metrics-card-grid-component",0),D("pageIndexChanged",function(o){return i.onPageIndexChanged(o)}),G(1,"async"),G(2,"async"),G(3,"async"),G(4,"async"),G(5,"async"),G(6,"async"),G(7,"async"),g()),2&e&&_("isGroupExpanded",W(1,8,i.isGroupExpanded$))("pageIndex",W(2,10,i.normalizedPageIndex$))("numPages",W(3,12,i.numPages$))("showPaginationControls",W(4,14,i.showPaginationControls$))("cardIdsWithMetadata",W(5,16,i.pagedItems$))("cardMinWidth",W(6,18,i.cardMinWidth$))("cardObserver",i.cardObserver)("cardStateMap",W(7,20,i.cardStateMap$))},dependencies:[pne,lt],encapsulation:2,changeDetection:0}),n})();function N3e(n,t){if(1&n&&(h(0,"span",7),T(1),G(2,"number"),g()),2&n){let e=w();b(1),ze("",W(2,1,e.numberOfCards)," cards")}}function B3e(n,t){1&n&&P(0,"mat-icon",8)}function V3e(n,t){1&n&&P(0,"mat-icon",9)}var fne=(()=>{class n{constructor(){this.groupExpansionToggled=new L}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["metrics-card-group-toolbar-component"]],inputs:{groupName:"groupName",numberOfCards:"numberOfCards",isGroupExpanded:"isGroupExpanded"},outputs:{groupExpansionToggled:"groupExpansionToggled"},decls:9,vars:5,consts:function(){let t;return t=$localize`:A button that allows user to expand a tag group.␟ffaa11471b878a6dffe2e68c6f37064a9e074853␟5386054325274779258:Expand group`,[["aria-label",t,1,"group-toolbar",3,"click"],[1,"group-title-wrapper"],["aria-role","heading","aria-level","3",1,"group-title",3,"title"],["class","group-card-count",4,"ngIf"],[1,"expand-group-icon"],["svgIcon","expand_less_24px",4,"ngIf","ngIfElse"],["expandMore",""],[1,"group-card-count"],["svgIcon","expand_less_24px"],["svgIcon","expand_more_24px"]]},template:function(e,i){if(1&e&&(h(0,"button",0),D("click",function(){return i.groupExpansionToggled.emit()}),h(1,"span",1)(2,"span",2),T(3),g(),S(4,N3e,3,3,"span",3),g(),h(5,"span",4),S(6,B3e,1,0,"mat-icon",5),S(7,V3e,1,0,"ng-template",null,6,Zt),g()()),2&e){let r=tt(8);b(2),Ji("title",i.groupName),b(1),ut(i.groupName),b(1),_("ngIf",i.numberOfCards>1),b(2),_("ngIf",i.isGroupExpanded)("ngIfElse",r)}},dependencies:[Fe,Dn,Ps],styles:["[_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{background-color:#fff;border-bottom:1px solid #ebebeb;align-items:center;background-color:#fff;display:flex;flex:none;height:42px;margin-bottom:-1px;padding:0 16px;position:sticky;top:0;z-index:1;box-shadow:0px 2px 4px 0px rgba(0,0,0,.15)}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{background-color:#303030}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{border-bottom:1px solid #555}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{box-shadow:0px 2px 4px 0px rgba(255,255,255,.15)}[_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{border:0;border-top:1px solid #ebebeb;color:#212121;top:-1px;display:flex;width:100%;font:inherit}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{border-top:1px solid #555}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{color:#fff}.card-group:first-of-type   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{border-top:0}[_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]:hover{cursor:pointer}.expand-group-icon[_ngcontent-%COMP%]{color:#616161}body.dark-mode[_nghost-%COMP%]   .expand-group-icon[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .expand-group-icon[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}.expand-group-icon[_ngcontent-%COMP%]:disabled{color:#757575}body.dark-mode[_nghost-%COMP%]   .expand-group-icon[_ngcontent-%COMP%]:disabled, body.dark-mode   [_nghost-%COMP%]   .expand-group-icon[_ngcontent-%COMP%]:disabled{color:#616161}.group-title-wrapper[_ngcontent-%COMP%]{flex-grow:1;text-align:left}.group-title[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.group-card-count[_ngcontent-%COMP%]{font-size:12px;font-weight:400;color:#616161;margin-left:6px}body.dark-mode[_nghost-%COMP%]   .group-card-count[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .group-card-count[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}"],changeDetection:0}),n})(),mne=(()=>{class n{constructor(e){this.store=e,this.groupName=null,this.isGroupExpanded$=qt(!1)}ngOnInit(){this.isGroupExpanded$=null!==this.groupName?this.store.select(p1,this.groupName):qt(!1)}onGroupExpansionToggled(){if(null===this.groupName)throw new RangeError("Invariant error: expansion cannot be toggled when groupName is null");this.store.dispatch(NT({tagGroup:this.groupName}))}}return n.\u0275fac=function(e){return new(e||n)(C(ke))},n.\u0275cmp=k({type:n,selectors:[["metrics-card-group-toolbar"]],inputs:{groupName:"groupName",numberOfCards:"numberOfCards"},decls:2,vars:5,consts:[[3,"numberOfCards","isGroupExpanded","groupName","groupExpansionToggled"]],template:function(e,i){1&e&&(h(0,"metrics-card-group-toolbar-component",0),D("groupExpansionToggled",function(){return i.onGroupExpansionToggled()}),G(1,"async"),g()),2&e&&_("numberOfCards",i.numberOfCards)("isGroupExpanded",W(1,3,i.isGroupExpanded$))("groupName",i.groupName)},dependencies:[fne,lt],encapsulation:2,changeDetection:0}),n})();function U3e(n,t){if(1&n&&(h(0,"div",1),P(1,"metrics-card-group-toolbar",2)(2,"metrics-card-grid",3),g()),2&n){let e=t.$implicit,i=w();b(1),_("numberOfCards",e.items.length)("groupName",e.groupName),b(1),_("cardIdsWithMetadata",e.items)("cardObserver",i.cardObserver)("groupName",e.groupName)}}var hne=(()=>{class n{constructor(){this.PluginType=qn}trackByGroup(e,i){return i.groupName}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["metrics-card-groups-component"]],inputs:{cardGroups:"cardGroups",cardObserver:"cardObserver"},decls:1,vars:2,consts:[["class","card-group",4,"ngFor","ngForOf","ngForTrackBy"],[1,"card-group"],[3,"numberOfCards","groupName"],[3,"cardIdsWithMetadata","cardObserver","groupName"]],template:function(e,i){1&e&&S(0,U3e,3,5,"div",0),2&e&&_("ngForOf",i.cardGroups)("ngForTrackBy",i.trackByGroup)},dependencies:[dn,S_,mne],styles:["[_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{background-color:#fff;border-bottom:1px solid #ebebeb;align-items:center;background-color:#fff;display:flex;flex:none;height:42px;margin-bottom:-1px;padding:0 16px;position:sticky;top:0;z-index:1;box-shadow:0px 2px 4px 0px rgba(0,0,0,.15)}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{background-color:#303030}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{border-bottom:1px solid #555}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{box-shadow:0px 2px 4px 0px rgba(255,255,255,.15)}"],changeDetection:0}),n})(),gne=(()=>{class n{constructor(e){this.store=e,this.cardGroups$=this.store.select(Qf).pipe(Vi(this.store.select(wc)),U(([i,r])=>r.size?i.filter(o=>r.has(o.plugin)):i),U(i=>UT(i)))}}return n.\u0275fac=function(e){return new(e||n)(C(ke))},n.\u0275cmp=k({type:n,selectors:[["metrics-card-groups"]],inputs:{cardObserver:"cardObserver"},decls:2,vars:4,consts:[[3,"cardGroups","cardObserver"]],template:function(e,i){1&e&&(P(0,"metrics-card-groups-component",0),G(1,"async")),2&e&&_("cardGroups",W(1,2,i.cardGroups$))("cardObserver",i.cardObserver)},dependencies:[hne,lt],encapsulation:2,changeDetection:0}),n})();function W3e(n,t){if(1&n&&(h(0,"span"),T(1),g()),2&n){let e=w();b(1),ze(" and ",e.getPluginTypeFilterString(e.pluginTypes)," visualization filter")}}var _ne=(()=>{class n{constructor(){this.PluginType=qn,this.listFormatter=new Intl.ListFormat(void 0,{style:"long",type:"disjunction"})}getPluginTypeFilterString(e){let i=[...e].map(r=>{switch(r){case qn.SCALARS:return"scalar";case qn.IMAGES:return"image";case qn.HISTOGRAMS:return"histogram";default:throw new RangeError(`Please implement human readable name for plugin type: ${r}`)}});return this.listFormatter.format(i)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["metrics-empty-tag-match-component"]],inputs:{pluginTypes:"pluginTypes",tagFilterRegex:"tagFilterRegex",tagCounts:"tagCounts"},decls:6,vars:5,consts:[[4,"ngIf"]],template:function(e,i){1&e&&(T(0,"No matches for tag filter "),h(1,"code"),T(2),g(),S(3,W3e,2,1,"span",0),T(4),G(5,"number")),2&e&&(b(2),ze("/",i.tagFilterRegex,"/"),b(1),_("ngIf",i.pluginTypes.size),b(1),ze(" out of ",W(5,3,i.tagCounts)," tags."))},dependencies:[Fe,Ps],encapsulation:2,changeDetection:0}),n})(),yne=(()=>{class n{constructor(e){this.store=e,this.pluginTypes$=this.store.select(wc),this.tagFilterRegex$=this.store.select(Il),this.tagCounts$=this.store.select(Qf).pipe(U(i=>new Set(i.map(({tag:r})=>r)).size))}}return n.\u0275fac=function(e){return new(e||n)(C(ke))},n.\u0275cmp=k({type:n,selectors:[["metrics-empty-tag-match"]],decls:4,vars:9,consts:[[3,"pluginTypes","tagFilterRegex","tagCounts"]],template:function(e,i){1&e&&(P(0,"metrics-empty-tag-match-component",0),G(1,"async"),G(2,"async"),G(3,"async")),2&e&&_("pluginTypes",W(1,3,i.pluginTypes$))("tagFilterRegex",W(2,5,i.tagFilterRegex$))("tagCounts",W(3,7,i.tagCounts$))},dependencies:[_ne,lt],encapsulation:2,changeDetection:0}),n})();function X3e(n,t){if(1&n&&(h(0,"span",6),T(1),G(2,"number"),g()),2&n){let e=w();b(1),ze("",W(2,1,e.cardIdsWithMetadata.length)," cards")}}function Q3e(n,t){1&n&&P(0,"metrics-empty-tag-match",7)}var bne=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["metrics-filtered-view-component"]],inputs:{isEmptyMatch:"isEmptyMatch",cardObserver:"cardObserver",cardIdsWithMetadata:"cardIdsWithMetadata"},decls:7,vars:4,consts:[[1,"group-toolbar"],[1,"group-text"],["aria-role","heading","aria-level","3",1,"group-title"],["class","group-card-count",4,"ngIf"],["class","warn",4,"ngIf"],[3,"cardIdsWithMetadata","cardObserver"],[1,"group-card-count"],[1,"warn"]],template:function(e,i){1&e&&(h(0,"div",0)(1,"span",1)(2,"span",2),T(3,"Tags matching filter"),g(),S(4,X3e,3,3,"span",3),g()(),S(5,Q3e,1,0,"metrics-empty-tag-match",4),P(6,"metrics-card-grid",5)),2&e&&(b(4),_("ngIf",i.cardIdsWithMetadata.length>1),b(1),_("ngIf",i.isEmptyMatch),b(1),_("cardIdsWithMetadata",i.cardIdsWithMetadata)("cardObserver",i.cardObserver))},dependencies:[Fe,S_,yne,Ps],styles:["[_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{background-color:#fff;border-bottom:1px solid #ebebeb;align-items:center;background-color:#fff;display:flex;flex:none;height:42px;margin-bottom:-1px;padding:0 16px;position:sticky;top:0;z-index:1;box-shadow:0px 2px 4px 0px rgba(0,0,0,.15)}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{background-color:#303030}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{border-bottom:1px solid #555}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{box-shadow:0px 2px 4px 0px rgba(255,255,255,.15)}.group-text[_ngcontent-%COMP%]{display:flex;align-items:baseline}.group-title[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.group-card-count[_ngcontent-%COMP%]{font-size:12px;font-weight:400;color:#616161;margin-left:6px}body.dark-mode[_nghost-%COMP%]   .group-card-count[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .group-card-count[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}metrics-empty-tag-match[_ngcontent-%COMP%]{color:#616161;font-size:13px;font-style:italic;padding:16px;text-align:center;display:block}body.dark-mode[_nghost-%COMP%]   metrics-empty-tag-match[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   metrics-empty-tag-match[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}"],changeDetection:0}),n})(),vne=(()=>{class n{constructor(e){this.store=e,this.cardIdsWithMetadata$=this.store.select(Qf).pipe(Vi(this.store.select(wc)),U(([i,r])=>r.size?i.filter(o=>r.has(o.plugin)):i),Vi(this.store.select(Il)),Cr(200),U(([i,r])=>{try{return{cardList:i,regex:new RegExp(r,"i")}}catch{return{cardList:i,regex:null}}}),Ve(({regex:i})=>null!==i),U(({cardList:i,regex:r})=>i.filter(({tag:o})=>r.test(o))),ui((i,r)=>i.length===r.length&&i.every((o,a)=>o.cardId===r[a].cardId)),Sa(),Nn([])),this.isEmptyMatch$=this.cardIdsWithMetadata$.pipe(Vi(this.store.select(Qf)),U(([i,r])=>Boolean(r.length)&&0===i.length))}}return n.\u0275fac=function(e){return new(e||n)(C(ke))},n.\u0275cmp=k({type:n,selectors:[["metrics-filtered-view"]],inputs:{cardObserver:"cardObserver"},decls:3,vars:7,consts:[[3,"isEmptyMatch","cardIdsWithMetadata","cardObserver"]],template:function(e,i){1&e&&(P(0,"metrics-filtered-view-component",0),G(1,"async"),G(2,"async")),2&e&&_("isEmptyMatch",W(1,3,i.isEmptyMatch$))("cardIdsWithMetadata",W(2,5,i.cardIdsWithMetadata$))("cardObserver",i.cardObserver)},dependencies:[bne,lt],encapsulation:2,changeDetection:0}),n})(),$3e=["panel"],eBe=(ji("panelAnimation",[Jn("void, hidden",Bt({opacity:0,transform:"scaleY(0.8)"})),Wn(":enter, hidden => visible",[Gy([Kn("0.03s linear",Bt({opacity:1})),Kn("0.12s cubic-bezier(0, 0, 0.2, 1)",Bt({transform:"scaleY(1)"}))])]),Wn(":leave, visible => hidden",[Kn("0.075s linear",Bt({opacity:0}))])]),0),tBe=Qo(class{}),xne=new ie("mat-autocomplete-default-options",{providedIn:"root",factory:function(){return{autoActiveFirstOption:!1,autoSelectActiveOption:!1,hideSingleSelectionIndicator:!1}}}),Cne=(()=>{class n extends tBe{get isOpen(){return this._isOpen&&this.showPanel}_setColor(e){this._color=e,this._setThemeClasses(this._classList)}get autoActiveFirstOption(){return this._autoActiveFirstOption}set autoActiveFirstOption(e){this._autoActiveFirstOption=Ut(e)}get autoSelectActiveOption(){return this._autoSelectActiveOption}set autoSelectActiveOption(e){this._autoSelectActiveOption=Ut(e)}set classList(e){this._classList=e&&e.length?function(n,t=/\s+/){let e=[];if(null!=n){let i=Array.isArray(n)?n:`${n}`.split(t);for(let r of i){let o=`${r}`.trim();o&&e.push(o)}}return e}(e).reduce((i,r)=>(i[r]=!0,i),{}):{},this._setVisibilityClasses(this._classList),this._setThemeClasses(this._classList),this._elementRef.nativeElement.className=""}constructor(e,i,r,o){super(),this._changeDetectorRef=e,this._elementRef=i,this._defaults=r,this._activeOptionChanges=yn.EMPTY,this.showPanel=!1,this._isOpen=!1,this.displayWith=null,this._autoActiveFirstOption=!!this._defaults.autoActiveFirstOption,this._autoSelectActiveOption=!!this._defaults.autoSelectActiveOption,this.optionSelected=new L,this.opened=new L,this.closed=new L,this.optionActivated=new L,this._classList={},this.id="mat-autocomplete-"+eBe++,this.inertGroups=o?.SAFARI||!1}ngAfterContentInit(){this._keyManager=new hg(this.options).withWrap(),this._activeOptionChanges=this._keyManager.change.subscribe(e=>{this.isOpen&&this.optionActivated.emit({source:this,option:this.options.toArray()[e]||null})}),this._setVisibility()}ngOnDestroy(){this._keyManager?.destroy(),this._activeOptionChanges.unsubscribe()}_setScrollTop(e){this.panel&&(this.panel.nativeElement.scrollTop=e)}_getScrollTop(){return this.panel?this.panel.nativeElement.scrollTop:0}_setVisibility(){this.showPanel=!!this.options.length,this._setVisibilityClasses(this._classList),this._changeDetectorRef.markForCheck()}_emitSelectEvent(e){let i=new class{constructor(t,e){this.source=t,this.option=e}}(this,e);this.optionSelected.emit(i)}_getPanelAriaLabelledby(e){return this.ariaLabel?null:this.ariaLabelledby?(e?e+" ":"")+this.ariaLabelledby:e}_setVisibilityClasses(e){e[this._visibleClass]=this.showPanel,e[this._hiddenClass]=!this.showPanel}_setThemeClasses(e){e["mat-primary"]="primary"===this._color,e["mat-warn"]="warn"===this._color,e["mat-accent"]="accent"===this._color}}return n.\u0275fac=function(e){return new(e||n)(C(Ft),C(be),C(xne),C($n))},n.\u0275dir=xe({type:n,viewQuery:function(e,i){if(1&e&&(Ye(Si,7),Ye($3e,5)),2&e){let r;we(r=Se())&&(i.template=r.first),we(r=Se())&&(i.panel=r.first)}},inputs:{ariaLabel:["aria-label","ariaLabel"],ariaLabelledby:["aria-labelledby","ariaLabelledby"],displayWith:"displayWith",autoActiveFirstOption:"autoActiveFirstOption",autoSelectActiveOption:"autoSelectActiveOption",panelWidth:"panelWidth",classList:["class","classList"]},outputs:{optionSelected:"optionSelected",opened:"opened",closed:"closed",optionActivated:"optionActivated"},features:[Le]}),n})(),iBe={provide:Hr,useExisting:Vn(()=>oBe),multi:!0},Mne=new ie("mat-autocomplete-scroll-strategy"),wne={provide:Mne,deps:[Oi],useFactory:function(n){return()=>n.scrollStrategies.reposition()}},ZV=(()=>{class n{get autocompleteDisabled(){return this._autocompleteDisabled}set autocompleteDisabled(e){this._autocompleteDisabled=Ut(e)}constructor(e,i,r,o,a,s,l,c,d,u,p){this._element=e,this._overlay=i,this._viewContainerRef=r,this._zone=o,this._changeDetectorRef=a,this._dir=l,this._formField=c,this._document=d,this._viewportRuler=u,this._defaults=p,this._componentDestroyed=!1,this._autocompleteDisabled=!1,this._manuallyFloatingLabel=!1,this._viewportSubscription=yn.EMPTY,this._canOpenOnNextFocus=!0,this._closeKeyEventStream=new Ae,this._windowBlurHandler=()=>{this._canOpenOnNextFocus=this._document.activeElement!==this._element.nativeElement||this.panelOpen},this._onChange=()=>{},this._onTouched=()=>{},this.position="auto",this.autocompleteAttribute="off",this._overlayAttached=!1,this.optionSelections=Ka(()=>{let f=this.autocomplete?this.autocomplete.options:null;return f?f.changes.pipe(Nn(f),yi(()=>cn(...f.map(m=>m.onSelectionChange)))):this._zone.onStable.pipe(zt(1),yi(()=>this.optionSelections))}),this._scrollStrategy=s}ngAfterViewInit(){let e=this._getWindow();typeof e<"u"&&this._zone.runOutsideAngular(()=>e.addEventListener("blur",this._windowBlurHandler))}ngOnChanges(e){e.position&&this._positionStrategy&&(this._setStrategyPositions(this._positionStrategy),this.panelOpen&&this._overlayRef.updatePosition())}ngOnDestroy(){let e=this._getWindow();typeof e<"u"&&e.removeEventListener("blur",this._windowBlurHandler),this._viewportSubscription.unsubscribe(),this._componentDestroyed=!0,this._destroyPanel(),this._closeKeyEventStream.complete()}get panelOpen(){return this._overlayAttached&&this.autocomplete.showPanel}openPanel(){this._attachOverlay(),this._floatLabel()}closePanel(){this._resetLabel(),this._overlayAttached&&(this.panelOpen&&this._zone.run(()=>{this.autocomplete.closed.emit()}),this.autocomplete._isOpen=this._overlayAttached=!1,this._pendingAutoselectedOption=null,this._overlayRef&&this._overlayRef.hasAttached()&&(this._overlayRef.detach(),this._closingActionsSubscription.unsubscribe()),this._componentDestroyed||this._changeDetectorRef.detectChanges())}updatePosition(){this._overlayAttached&&this._overlayRef.updatePosition()}get panelClosingActions(){return cn(this.optionSelections,this.autocomplete._keyManager.tabOut.pipe(Ve(()=>this._overlayAttached)),this._closeKeyEventStream,this._getOutsideClickStream(),this._overlayRef?this._overlayRef.detachments().pipe(Ve(()=>this._overlayAttached)):qt()).pipe(U(e=>e instanceof bg?e:null))}get activeOption(){return this.autocomplete&&this.autocomplete._keyManager?this.autocomplete._keyManager.activeItem:null}_getOutsideClickStream(){return cn(ai(this._document,"click"),ai(this._document,"auxclick"),ai(this._document,"touchend")).pipe(Ve(e=>{let i=ds(e),r=this._formField?this._formField._elementRef.nativeElement:null,o=this.connectedTo?this.connectedTo.elementRef.nativeElement:null;return this._overlayAttached&&i!==this._element.nativeElement&&this._document.activeElement!==this._element.nativeElement&&(!r||!r.contains(i))&&(!o||!o.contains(i))&&!!this._overlayRef&&!this._overlayRef.overlayElement.contains(i)}))}writeValue(e){Promise.resolve(null).then(()=>this._assignOptionValue(e))}registerOnChange(e){this._onChange=e}registerOnTouched(e){this._onTouched=e}setDisabledState(e){this._element.nativeElement.disabled=e}_handleKeydown(e){let i=e.keyCode,r=yr(e);if(27===i&&!r&&e.preventDefault(),this.activeOption&&13===i&&this.panelOpen&&!r)this.activeOption._selectViaInteraction(),this._resetActiveItem(),e.preventDefault();else if(this.autocomplete){let o=this.autocomplete._keyManager.activeItem,a=38===i||40===i;9===i||a&&!r&&this.panelOpen?this.autocomplete._keyManager.onKeydown(e):a&&this._canOpen()&&this.openPanel(),(a||this.autocomplete._keyManager.activeItem!==o)&&(this._scrollToOption(this.autocomplete._keyManager.activeItemIndex||0),this.autocomplete.autoSelectActiveOption&&this.activeOption&&(this._pendingAutoselectedOption||(this._valueBeforeAutoSelection=this._element.nativeElement.value),this._pendingAutoselectedOption=this.activeOption,this._assignOptionValue(this.activeOption.value)))}}_handleInput(e){let i=e.target,r=i.value;"number"===i.type&&(r=""==r?null:parseFloat(r)),this._previousValue!==r&&(this._previousValue=r,this._pendingAutoselectedOption=null,this._onChange(r),this._canOpen()&&this._document.activeElement===e.target&&this.openPanel())}_handleFocus(){this._canOpenOnNextFocus?this._canOpen()&&(this._previousValue=this._element.nativeElement.value,this._attachOverlay(),this._floatLabel(!0)):this._canOpenOnNextFocus=!0}_handleClick(){this._canOpen()&&!this.panelOpen&&this.openPanel()}_floatLabel(e=!1){this._formField&&"auto"===this._formField.floatLabel&&(e?this._formField._animateAndLockLabel():this._formField.floatLabel="always",this._manuallyFloatingLabel=!0)}_resetLabel(){this._manuallyFloatingLabel&&(this._formField&&(this._formField.floatLabel="auto"),this._manuallyFloatingLabel=!1)}_subscribeToClosingActions(){return cn(this._zone.onStable.pipe(zt(1)),this.autocomplete.options.changes.pipe(Vt(()=>this._positionStrategy.reapplyLastPosition()),xs(0))).pipe(yi(()=>(this._zone.run(()=>{let r=this.panelOpen;this._resetActiveItem(),this.autocomplete._setVisibility(),this._changeDetectorRef.detectChanges(),this.panelOpen&&this._overlayRef.updatePosition(),r!==this.panelOpen&&(this.panelOpen?this.autocomplete.opened.emit():this.autocomplete.closed.emit())}),this.panelClosingActions)),zt(1)).subscribe(r=>this._setValueAndClose(r))}_destroyPanel(){this._overlayRef&&(this.closePanel(),this._overlayRef.dispose(),this._overlayRef=null)}_assignOptionValue(e){let i=this.autocomplete&&this.autocomplete.displayWith?this.autocomplete.displayWith(e):e;this._updateNativeInputValue(i??"")}_updateNativeInputValue(e){this._formField?this._formField._control.value=e:this._element.nativeElement.value=e,this._previousValue=e}_setValueAndClose(e){let i=e?e.source:this._pendingAutoselectedOption;i&&(this._clearPreviousSelectedOption(i),this._assignOptionValue(i.value),this._onChange(i.value),this.autocomplete._emitSelectEvent(i),this._element.nativeElement.focus()),this.closePanel()}_clearPreviousSelectedOption(e){this.autocomplete.options.forEach(i=>{i!==e&&i.selected&&i.deselect()})}_attachOverlay(){let e=this._overlayRef;e?(this._positionStrategy.setOrigin(this._getConnectedElement()),e.updateSize({width:this._getPanelWidth()})):(this._portal=new Jo(this.autocomplete.template,this._viewContainerRef,{id:this._formField?.getLabelId()}),e=this._overlay.create(this._getOverlayConfig()),this._overlayRef=e,this._handleOverlayEvents(e),this._viewportSubscription=this._viewportRuler.change().subscribe(()=>{this.panelOpen&&e&&e.updateSize({width:this._getPanelWidth()})})),e&&!e.hasAttached()&&(e.attach(this._portal),this._closingActionsSubscription=this._subscribeToClosingActions());let i=this.panelOpen;this.autocomplete._setVisibility(),this.autocomplete._isOpen=this._overlayAttached=!0,this.autocomplete._setColor(this._formField?.color),this.panelOpen&&i!==this.panelOpen&&this.autocomplete.opened.emit()}_getOverlayConfig(){return new Ws({positionStrategy:this._getOverlayPosition(),scrollStrategy:this._scrollStrategy(),width:this._getPanelWidth(),direction:this._dir??void 0,panelClass:this._defaults?.overlayPanelClass})}_getOverlayPosition(){let e=this._overlay.position().flexibleConnectedTo(this._getConnectedElement()).withFlexibleDimensions(!1).withPush(!1);return this._setStrategyPositions(e),this._positionStrategy=e,e}_setStrategyPositions(e){let a,i=[{originX:"start",originY:"bottom",overlayX:"start",overlayY:"top"},{originX:"end",originY:"bottom",overlayX:"end",overlayY:"top"}],r=this._aboveClass,o=[{originX:"start",originY:"top",overlayX:"start",overlayY:"bottom",panelClass:r},{originX:"end",originY:"top",overlayX:"end",overlayY:"bottom",panelClass:r}];a="above"===this.position?o:"below"===this.position?i:[...i,...o],e.withPositions(a)}_getConnectedElement(){return this.connectedTo?this.connectedTo.elementRef:this._formField?this._formField.getConnectedOverlayOrigin():this._element}_getPanelWidth(){return this.autocomplete.panelWidth||this._getHostWidth()}_getHostWidth(){return this._getConnectedElement().nativeElement.getBoundingClientRect().width}_resetActiveItem(){let e=this.autocomplete;e.autoActiveFirstOption?e._keyManager.setFirstItemActive():e._keyManager.setActiveItem(-1)}_canOpen(){let e=this._element.nativeElement;return!e.readOnly&&!e.disabled&&!this._autocompleteDisabled}_getWindow(){return this._document?.defaultView||window}_scrollToOption(e){let i=this.autocomplete,r=Af(e,i.options,i.optionGroups);if(0===e&&1===r)i._setScrollTop(0);else if(i.panel){let o=i.options.toArray()[e];if(o){let a=o._getHostElement(),s=vg(a.offsetTop,a.offsetHeight,i._getScrollTop(),i.panel.nativeElement.offsetHeight);i._setScrollTop(s)}}}_handleOverlayEvents(e){e.keydownEvents().subscribe(i=>{(27===i.keyCode&&!yr(i)||38===i.keyCode&&yr(i,"altKey"))&&(this._pendingAutoselectedOption&&(this._updateNativeInputValue(this._valueBeforeAutoSelection??""),this._pendingAutoselectedOption=null),this._closeKeyEventStream.next(),this._resetActiveItem(),i.stopPropagation(),i.preventDefault())}),e.outsidePointerEvents().subscribe()}}return n.\u0275fac=function(e){return new(e||n)(C(be),C(Oi),C(Zn),C(at),C(Ft),C(Mne),C(Hi,8),C(Bl,9),C(kt,8),C(Ko),C(xne,8))},n.\u0275dir=xe({type:n,inputs:{autocomplete:["matAutocomplete","autocomplete"],position:["matAutocompletePosition","position"],connectedTo:["matAutocompleteConnectedTo","connectedTo"],autocompleteAttribute:["autocomplete","autocompleteAttribute"],autocompleteDisabled:["matAutocompleteDisabled","autocompleteDisabled"]},features:[Gt]}),n})(),oBe=(()=>{class n extends ZV{constructor(){super(...arguments),this._aboveClass="mat-mdc-autocomplete-panel-above"}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Cn(n)))(i||n)}}(),n.\u0275dir=xe({type:n,selectors:[["input","matAutocomplete",""],["textarea","matAutocomplete",""]],hostAttrs:[1,"mat-mdc-autocomplete-trigger"],hostVars:7,hostBindings:function(e,i){1&e&&D("focusin",function(){return i._handleFocus()})("blur",function(){return i._onTouched()})("input",function(o){return i._handleInput(o)})("keydown",function(o){return i._handleKeydown(o)})("click",function(){return i._handleClick()}),2&e&&Pe("autocomplete",i.autocompleteAttribute)("role",i.autocompleteDisabled?null:"combobox")("aria-autocomplete",i.autocompleteDisabled?null:"list")("aria-activedescendant",i.panelOpen&&i.activeOption?i.activeOption.id:null)("aria-expanded",i.autocompleteDisabled?null:i.panelOpen.toString())("aria-owns",i.autocompleteDisabled||!i.panelOpen||null==i.autocomplete?null:i.autocomplete.id)("aria-haspopup",i.autocompleteDisabled?null:"listbox")},exportAs:["matAutocompleteTrigger"],features:[Rt([iBe]),Le]}),n})();function aBe(n,t){if(1&n&&(h(0,"div",0,1),Xt(2),g()),2&n){let e=t.id,i=w();_("id",i.id)("ngClass",i._classList),Pe("aria-label",i.ariaLabel||null)("aria-labelledby",i._getPanelAriaLabelledby(e))}}var sBe=["*"],Sne=(()=>{class n extends Cne{constructor(){super(...arguments),this._visibleClass="mat-autocomplete-visible",this._hiddenClass="mat-autocomplete-hidden"}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Cn(n)))(i||n)}}(),n.\u0275cmp=k({type:n,selectors:[["mat-autocomplete"]],contentQueries:function(e,i,r){if(1&e&&(ci(r,Cd,5),ci(r,Ha,5)),2&e){let o;we(o=Se())&&(i.optionGroups=o),we(o=Se())&&(i.options=o)}},hostAttrs:[1,"mat-autocomplete"],inputs:{disableRipple:"disableRipple"},exportAs:["matAutocomplete"],features:[Rt([{provide:xd,useExisting:n}]),Le],ngContentSelectors:sBe,decls:1,vars:0,consts:[["role","listbox",1,"mat-autocomplete-panel",3,"id","ngClass"],["panel",""]],template:function(e,i){1&e&&(gn(),S(0,aBe,3,4,"ng-template"))},dependencies:[bn],styles:[".mat-autocomplete-panel{min-width:112px;max-width:280px;overflow:auto;-webkit-overflow-scrolling:touch;visibility:hidden;max-width:none;max-height:256px;position:relative;width:100%;border-bottom-left-radius:4px;border-bottom-right-radius:4px}.mat-autocomplete-panel.mat-autocomplete-visible{visibility:visible}.mat-autocomplete-panel.mat-autocomplete-hidden{visibility:hidden}.mat-autocomplete-panel-above .mat-autocomplete-panel{border-radius:0;border-top-left-radius:4px;border-top-right-radius:4px}.mat-autocomplete-panel .mat-divider-horizontal{margin-top:-1px}.cdk-high-contrast-active .mat-autocomplete-panel{outline:solid 1px}mat-autocomplete{display:none}"],encapsulation:2,changeDetection:0}),n})(),lBe={provide:Hr,useExisting:Vn(()=>iC),multi:!0},iC=(()=>{class n extends ZV{constructor(){super(...arguments),this._aboveClass="mat-autocomplete-panel-above"}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Cn(n)))(i||n)}}(),n.\u0275dir=xe({type:n,selectors:[["input","matAutocomplete",""],["textarea","matAutocomplete",""]],hostAttrs:[1,"mat-autocomplete-trigger"],hostVars:7,hostBindings:function(e,i){1&e&&D("focusin",function(){return i._handleFocus()})("blur",function(){return i._onTouched()})("input",function(o){return i._handleInput(o)})("keydown",function(o){return i._handleKeydown(o)})("click",function(){return i._handleClick()}),2&e&&Pe("autocomplete",i.autocompleteAttribute)("role",i.autocompleteDisabled?null:"combobox")("aria-autocomplete",i.autocompleteDisabled?null:"list")("aria-activedescendant",i.panelOpen&&i.activeOption?i.activeOption.id:null)("aria-expanded",i.autocompleteDisabled?null:i.panelOpen.toString())("aria-owns",i.autocompleteDisabled||!i.panelOpen||null==i.autocomplete?null:i.autocomplete.id)("aria-haspopup",i.autocompleteDisabled?null:"listbox")},exportAs:["matAutocompleteTrigger"],features:[Rt([lBe]),Le]}),n})(),gA=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({providers:[wne],imports:[Lr,Sg,Qt,Te,Rc,Sg,Qt]}),n})(),E_=(()=>{class n{constructor(){this.value="",this.placeholder=""}onInputKeyUp(e){"Enter"===e.key&&this.autocompleteTrigger.closePanel()}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["tb-filter-input"]],viewQuery:function(e,i){if(1&e&&Ye(iC,5),2&e){let r;we(r=Se())&&(i.autocompleteTrigger=r.first)}},inputs:{value:"value",matAutocomplete:"matAutocomplete",placeholder:"placeholder"},decls:2,vars:4,consts:[["svgIcon","search_24px"],["type","text","autocomplete","off",3,"placeholder","matAutocomplete","matAutocompleteDisabled","value","keyup"]],template:function(e,i){1&e&&(P(0,"mat-icon",0),h(1,"input",1),D("keyup",function(o){return i.onInputKeyUp(o)}),g()),2&e&&(b(1),_("placeholder",i.placeholder)("matAutocomplete",i.matAutocomplete)("matAutocompleteDisabled",!i.matAutocomplete)("value",i.value))},dependencies:[iC,Dn],styles:["[_nghost-%COMP%]{display:flex;font-size:13px}mat-icon[_ngcontent-%COMP%]{color:#616161;flex:none;margin-right:5px}body.dark-mode[_nghost-%COMP%]   mat-icon[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   mat-icon[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}input[_ngcontent-%COMP%]{background-color:inherit;caret-color:currentColor;color:currentColor;font:inherit;border:none;outline:none;padding:0;flex-grow:1}"]}),n})();function cBe(n,t){1&n&&P(0,"mat-icon",7)}function dBe(n,t){if(1&n&&(h(0,"mat-option",8),T(1),g()),2&n){let e=t.$implicit;_("value",e),Pe("title",e),b(1),ut(e)}}function uBe(n,t){if(1&n&&(h(0,"div",9)(1,"em"),T(2),G(3,"number"),g()()),2&n){let e=w();b(2),ze("and ",W(3,1,e.completions.length-25)," more tags matched")}}var Tne=(()=>{class n{constructor(){this.onRegexFilterValueChange=new L}onCompletionAccepted(e){this.onRegexFilterValueChange.emit(function(n){return n.replace(eye,"\\$&")}(e))}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["metrics-tag-filter-component"]],hostVars:2,hostBindings:function(e,i){2&e&&Qe("valid",i.isRegexFilterValid)},inputs:{regexFilterValue:"regexFilterValue",isRegexFilterValid:"isRegexFilterValid",completions:"completions"},outputs:{onRegexFilterValueChange:"onRegexFilterValueChange"},decls:7,vars:5,consts:[[1,"tag-filter"],["placeholder","Filter tags (regex)",3,"value","matAutocomplete","input"],["svgIcon","error_24px","class","error-icon","title","Invalid regex filter. The result may be stale.",4,"ngIf"],[1,"tag-options",3,"optionSelected"],["filterMatches","matAutocomplete"],["class","option",3,"value",4,"ngFor","ngForOf"],["class","and-more",4,"ngIf"],["svgIcon","error_24px","title","Invalid regex filter. The result may be stale.",1,"error-icon"],[1,"option",3,"value"],[1,"and-more"]],template:function(e,i){if(1&e&&(h(0,"div",0)(1,"tb-filter-input",1),D("input",function(o){return i.onRegexFilterValueChange.emit(o.target.value)}),g(),S(2,cBe,1,0,"mat-icon",2),g(),h(3,"mat-autocomplete",3,4),D("optionSelected",function(o){return i.onCompletionAccepted(o.option.value)}),S(5,dBe,2,3,"mat-option",5),S(6,uBe,4,3,"div",6),g()),2&e){let r=tt(4);b(1),_("value",i.regexFilterValue)("matAutocomplete",r),b(1),_("ngIf",!i.isRegexFilterValid),b(3),_("ngForOf",null==i.completions?null:i.completions.slice(0,25)),b(1),_("ngIf",(null==i.completions?null:i.completions.length)>25)}},dependencies:[dn,Fe,E_,Sne,Ha,Dn,Ps],styles:[".tag-filter[_ngcontent-%COMP%]{display:flex;position:relative}tb-filter-input[_ngcontent-%COMP%]{flex-grow:1}[_nghost-%COMP%]{color:#212121}body.dark-mode   [_nghost-%COMP%]{color:#fff}[_nghost-%COMP%]:not(.valid){color:#c62828}[_nghost-%COMP%]:not(.valid)   .error-icon[_ngcontent-%COMP%]{color:#c62828;position:absolute;right:0}  .tag-options .option,   .tag-options .and-more{-webkit-box-orient:vertical;-webkit-line-clamp:3;display:-webkit-box;font-size:14px;line-height:1.4;padding:8px 16px}  .tag-options .and-more{color:#616161}body.dark-mode[_nghost-%COMP%]     .tag-options .and-more, body.dark-mode   [_nghost-%COMP%]     .tag-options .and-more{color:rgba(255,255,255,.7)}"],changeDetection:0}),n})(),Dne=(()=>{class n{constructor(e){this.store=e,this.tagFilter$=this.store.select(Il),this.isTagFilterRegexValid$=this.tagFilter$.pipe(U(i=>{try{return new RegExp(i),!0}catch{return!1}})),this.completions$=this.store.select(a1).pipe(Vi(this.store.select(wc)),U(([i,r])=>i.filter(({plugin:o})=>!r.size||r.has(o)).map(({tag:o})=>o)),U(i=>[...new Set(i)]),U(i=>i.sort(Sv)),Vi(this.store.select(Il)),U(([i,r])=>{try{return[i,new RegExp(r,"i")]}catch{return[i,null]}}),Ve(([,i])=>null!==i),U(([i,r])=>i.filter(o=>r.test(o))))}onTagFilterChange(e){this.store.dispatch(LT({tagFilter:e}))}}return n.\u0275fac=function(e){return new(e||n)(C(ke))},n.\u0275cmp=k({type:n,selectors:[["metrics-tag-filter"]],decls:4,vars:9,consts:[[3,"regexFilterValue","isRegexFilterValid","completions","onRegexFilterValueChange"]],template:function(e,i){1&e&&(h(0,"metrics-tag-filter-component",0),D("onRegexFilterValueChange",function(o){return i.onTagFilterChange(o)}),G(1,"async"),G(2,"async"),G(3,"async"),g()),2&e&&_("regexFilterValue",W(1,3,i.tagFilter$))("isRegexFilterValid",W(2,5,i.isTagFilterRegexValid$))("completions",W(3,7,i.completions$))},dependencies:[Tne,lt],encapsulation:2,changeDetection:0}),n})();function mBe(n,t){if(1&n&&(h(0,"span",8),T(1),g()),2&n){let e=w();b(1),ze("",e.cardIdsWithMetadata.length," cards")}}function hBe(n,t){1&n&&(h(0,"span",9),T(1,"New card pinned"),g()),2&n&&Pe("data-id",t.$implicit)}function gBe(n,t){if(1&n&&P(0,"metrics-card-grid",10),2&n){let e=w();_("cardIdsWithMetadata",e.cardIdsWithMetadata)("cardObserver",e.cardObserver)}}function _Be(n,t){1&n&&(h(0,"div",11),T(1,"Pin cards for a quick view and comparison"),g())}var Ine=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["metrics-pinned-view-component"]],inputs:{cardObserver:"cardObserver",cardIdsWithMetadata:"cardIdsWithMetadata",newCardPinnedIds:"newCardPinnedIds"},decls:10,vars:4,consts:[[1,"group-toolbar"],["svgIcon","keep_24px"],[1,"group-text"],["aria-role","heading","aria-level","3",1,"group-title"],["class","group-card-count",4,"ngIf"],["class","new-card-pinned",4,"ngFor","ngForOf"],[3,"cardIdsWithMetadata","cardObserver",4,"ngIf","ngIfElse"],["emptyPinnedView",""],[1,"group-card-count"],[1,"new-card-pinned"],[3,"cardIdsWithMetadata","cardObserver"],[1,"empty-message"]],template:function(e,i){if(1&e&&(h(0,"div",0),P(1,"mat-icon",1),h(2,"span",2)(3,"span",3),T(4,"Pinned"),g(),S(5,mBe,2,1,"span",4),S(6,hBe,2,1,"span",5),g()(),S(7,gBe,1,2,"metrics-card-grid",6),S(8,_Be,2,0,"ng-template",null,7,Zt)),2&e){let r=tt(9);b(5),_("ngIf",i.cardIdsWithMetadata.length>1),b(1),_("ngForOf",i.newCardPinnedIds),b(1),_("ngIf",i.cardIdsWithMetadata.length)("ngIfElse",r)}},dependencies:[dn,Fe,Dn,S_],styles:["[_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{background-color:#fff;border-bottom:1px solid #ebebeb;align-items:center;background-color:#fff;display:flex;flex:none;height:42px;margin-bottom:-1px;padding:0 16px;position:sticky;top:0;z-index:1;box-shadow:0px 2px 4px 0px rgba(0,0,0,.15)}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{background-color:#303030}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{border-bottom:1px solid #555}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{box-shadow:0px 2px 4px 0px rgba(255,255,255,.15)}mat-icon[_ngcontent-%COMP%]{color:#616161;flex:none;margin-right:5px}body.dark-mode[_nghost-%COMP%]   mat-icon[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   mat-icon[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}.group-text[_ngcontent-%COMP%]{display:flex;align-items:baseline;gap:6px}.group-title[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.group-card-count[_ngcontent-%COMP%]{font-size:12px;font-weight:400;color:#616161}body.dark-mode[_nghost-%COMP%]   .group-card-count[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .group-card-count[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}.empty-message[_ngcontent-%COMP%]{color:#616161;font-size:13px;font-style:italic;padding:16px;text-align:center}body.dark-mode[_nghost-%COMP%]   .empty-message[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .empty-message[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}.new-card-pinned[_ngcontent-%COMP%]{animation:_ngcontent-%COMP%_pinned-view-fade-out 3s linear;background:#f44336;border-radius:5px;color:#fff;display:inline-block;font-size:13px;opacity:0;padding:3px 5px}@keyframes _ngcontent-%COMP%_pinned-view-fade-out{from{opacity:1}66%{opacity:.99}to{opacity:0}}"],changeDetection:0}),n})(),Ane=(()=>{class n{constructor(e){this.store=e,this.cardIdsWithMetadata$=this.store.select(Sb).pipe(Nn([])),this.newCardPinnedIds$=this.store.select(Sb).pipe($a(1),U(i=>i.map(r=>r.cardId)),Ym(),U(([i,r])=>{let o=new Set(i),a=new Set(r);for(let s of a)if(!o.has(s))return Date.now();return null}),Nn(null),Ym(),U(([i,r])=>null===i&&null===r?null:null===r?[i]:[r]),Ve(i=>null!==i),U(i=>[i[0]]))}}return n.\u0275fac=function(e){return new(e||n)(C(ke))},n.\u0275cmp=k({type:n,selectors:[["metrics-pinned-view"]],inputs:{cardObserver:"cardObserver"},decls:3,vars:7,consts:[[3,"cardIdsWithMetadata","newCardPinnedIds","cardObserver"]],template:function(e,i){1&e&&(P(0,"metrics-pinned-view-component",0),G(1,"async"),G(2,"async")),2&e&&_("cardIdsWithMetadata",W(1,3,i.cardIdsWithMetadata$))("newCardPinnedIds",W(2,5,i.newCardPinnedIds$))("cardObserver",i.cardObserver)},dependencies:[Ine,lt],encapsulation:2,changeDetection:0}),n})();function vBe(n,t){1&n&&P(0,"metrics-filtered-view",13),2&n&&_("cardObserver",w().cardObserver)}function xBe(n,t){1&n&&(h(0,"div",17),P(1,"mat-spinner",18),g())}var CBe=function(n){return{"slide-out-menu-expanded":n}};function MBe(n,t){if(1&n&&(h(0,"div",19),P(1,"metrics-scalar-column-editor"),g()),2&n){let e=w();_("ngClass",Sn(1,CBe,e.slideOutMenuOpen))}}function wBe(n,t){if(1&n){let e=ge();h(0,"div",20)(1,"div",21)(2,"h2",22),T(3,"Settings"),g(),h(4,"button",23),D("click",function(){return X(e),Q(w().onCloseSidepaneButtonClicked.emit())}),P(5,"mat-icon",24),g()(),P(6,"metrics-dashboard-right-pane"),g()}}var SBe=function(n){return{checked:n,"settings-button":!0}},EBe=new ie("Customizable Share Button"),Rne=(()=>{class n{constructor(e,i){this.host=e,this.customShareButton=i,this.onSettingsButtonClicked=new L,this.onCloseSidepaneButtonClicked=new L,this.onPluginTypeToggled=new L,this.onPluginTypeAllToggled=new L,this.PluginType=qn,this.cardObserver=new Ev(this.host.nativeElement,"600px 0px 600px 0px")}}return n.\u0275fac=function(e){return new(e||n)(C(be),C(EBe,8))},n.\u0275cmp=k({type:n,selectors:[["metrics-main-view-component"]],inputs:{showFilteredView:"showFilteredView",isSidepaneOpen:"isSidepaneOpen",filteredPluginTypes:"filteredPluginTypes",initialTagsLoading:"initialTagsLoading",slideOutMenuOpen:"slideOutMenuOpen"},outputs:{onSettingsButtonClicked:"onSettingsButtonClicked",onCloseSidepaneButtonClicked:"onCloseSidepaneButtonClicked",onPluginTypeToggled:"onPluginTypeToggled",onPluginTypeAllToggled:"onPluginTypeAllToggled"},decls:24,vars:23,consts:function(){let t,e;return t=$localize`:Label on a toolbar button to toggle the settings side pane.␟d3516db6bbe6860a55beab66e4969dac625b8d72␟7659285445580838925:Toggle settings side pane`,e=$localize`:Label on a button to close the settings side pane.␟04521dc0b6a65cf5c382944c9a8b4b844a3e9598␟8156766997747165871:Close side pane`,[[1,"toolbar"],["multiple","","appearance","standard",1,"filter-view"],["mat-button","","role","checkbox","data-value","all",1,"filter-view-button",3,"click"],["mat-button","","role","checkbox","data-value","scalars",1,"filter-view-button",3,"click"],["mat-button","","role","checkbox","data-value","image",1,"filter-view-button",3,"click"],["mat-button","","role","checkbox","data-value","histogram",1,"filter-view-button",3,"click"],[3,"customizableComponent"],[1,"right-items"],["mat-stroked-button","","aria-label",t,3,"ngClass","click"],["svgIcon","settings_24px"],[1,"split-content"],["cdkScrollable",""],[3,"cardObserver",4,"ngIf"],[3,"cardObserver"],["class","loading-container",4,"ngIf"],["class","slide-out-menu",3,"ngClass",4,"ngIf"],["class","sidebar",4,"ngIf"],[1,"loading-container"],["diameter","36"],[1,"slide-out-menu",3,"ngClass"],[1,"sidebar"],[1,"header"],[1,"title"],["mat-icon-button","","aria-label",e,3,"click"],["svgIcon","close_24px"]]},template:function(e,i){1&e&&(h(0,"div",0),P(1,"metrics-tag-filter"),h(2,"mat-button-toggle-group",1)(3,"button",2),D("click",function(){return i.onPluginTypeAllToggled.emit()}),T(4," All "),g(),h(5,"button",3),D("click",function(){return i.onPluginTypeToggled.emit(i.PluginType.SCALARS)}),T(6," Scalars "),g(),h(7,"button",4),D("click",function(){return i.onPluginTypeToggled.emit(i.PluginType.IMAGES)}),T(8," Image "),g(),h(9,"button",5),D("click",function(){return i.onPluginTypeToggled.emit(i.PluginType.HISTOGRAMS)}),T(10," Histogram "),g()(),P(11,"tb-customization",6),h(12,"div",7)(13,"button",8),D("click",function(){return i.onSettingsButtonClicked.emit()}),P(14,"mat-icon",9),T(15," Settings "),g()()(),h(16,"div",10)(17,"div",11),S(18,vBe,1,1,"metrics-filtered-view",12),P(19,"metrics-pinned-view",13),S(20,xBe,2,0,"div",14),P(21,"metrics-card-groups",13),g(),S(22,MBe,2,3,"div",15),S(23,wBe,7,0,"div",16),g()),2&e&&(b(3),Pe("aria-checked",0===i.filteredPluginTypes.size),b(2),Pe("aria-checked",i.filteredPluginTypes.has(i.PluginType.SCALARS)),b(2),Pe("aria-checked",i.filteredPluginTypes.has(i.PluginType.IMAGES)),b(2),Pe("aria-checked",i.filteredPluginTypes.has(i.PluginType.HISTOGRAMS)),b(2),_("customizableComponent",i.customShareButton),b(2),_("ngClass",Sn(21,SBe,i.isSidepaneOpen)),Pe("aria-pressed",i.isSidepaneOpen),b(4),Qe("main",!0)("filter-view",i.showFilteredView),b(1),_("ngIf",i.showFilteredView),b(1),Mt("display",i.showFilteredView?"none":""),_("cardObserver",i.cardObserver),b(1),_("ngIf",i.initialTagsLoading),b(1),Mt("display",i.showFilteredView?"none":""),_("cardObserver",i.cardObserver),b(1),_("ngIf",i.isSidepaneOpen),b(1),_("ngIf",i.isSidepaneOpen))},dependencies:[bn,Fe,MQ,Bu,Fn,JL,Dn,zr,PQ,NQ,gne,vne,Dne,Ane],styles:["[_nghost-%COMP%]{display:flex;flex-direction:column;height:100%}.toolbar[_ngcontent-%COMP%]{border-bottom:1px solid #ebebeb;flex:none;display:flex;align-items:center;justify-content:space-between;height:48px;padding:0 16px}body.dark-mode[_nghost-%COMP%]   .toolbar[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .toolbar[_ngcontent-%COMP%]{border-bottom:1px solid #555}.toolbar[_ngcontent-%COMP%]   metrics-tag-filter[_ngcontent-%COMP%]{flex:1 1 100px}.toolbar[_ngcontent-%COMP%]   .right-items[_ngcontent-%COMP%]{border-left:1px solid #ebebeb;margin-left:16px;padding-left:16px}body.dark-mode[_nghost-%COMP%]   .toolbar[_ngcontent-%COMP%]   .right-items[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .toolbar[_ngcontent-%COMP%]   .right-items[_ngcontent-%COMP%]{border-left:1px solid #555}mat-button-toggle-group.filter-view[_ngcontent-%COMP%]{border:1px solid #ebebeb}body.dark-mode[_nghost-%COMP%]   mat-button-toggle-group.filter-view[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   mat-button-toggle-group.filter-view[_ngcontent-%COMP%]{border:1px solid #555}.filter-view[_ngcontent-%COMP%]{border-radius:4px;flex:none;margin-right:5px}.filter-view[_ngcontent-%COMP%]   button[_ngcontent-%COMP%]{border-radius:0;font-size:12px;font-weight:normal;height:25px;line-height:25px;min-width:unset;padding:0 12px}.filter-view[_ngcontent-%COMP%]   button[_ngcontent-%COMP%] + button[_ngcontent-%COMP%]{border-left:1px solid #ebebeb}body.dark-mode[_nghost-%COMP%]   .filter-view[_ngcontent-%COMP%]   button[_ngcontent-%COMP%] + button[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .filter-view[_ngcontent-%COMP%]   button[_ngcontent-%COMP%] + button[_ngcontent-%COMP%]{border-left:1px solid #555}.filter-view[_ngcontent-%COMP%]   button[aria-checked=true][_ngcontent-%COMP%]{background-color:#e0e0e0}body.dark-mode[_nghost-%COMP%]   .filter-view[_ngcontent-%COMP%]   button[aria-checked=true][_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .filter-view[_ngcontent-%COMP%]   button[aria-checked=true][_ngcontent-%COMP%]{background-color:#212121}.split-content[_ngcontent-%COMP%]{display:flex;overflow-y:auto;flex:1}.main[_ngcontent-%COMP%], .sidebar[_ngcontent-%COMP%]{contain:strict;background-color:#fff;overflow-x:hidden;overflow-y:auto;will-change:transform,scroll-position}body.dark-mode[_nghost-%COMP%]   .main[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .main[_ngcontent-%COMP%]{background-color:#303030}body.dark-mode[_nghost-%COMP%]   .sidebar[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .sidebar[_ngcontent-%COMP%]{background-color:#303030}.main[_ngcontent-%COMP%]{background-color:#f5f6f7;flex:1 1;display:flex;flex-direction:column}body.dark-mode[_nghost-%COMP%]   .main[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .main[_ngcontent-%COMP%]{background-color:#3a3a3a}.main[_ngcontent-%COMP%]   metrics-filtered-view[_ngcontent-%COMP%], .main[_ngcontent-%COMP%]   metrics-pinned-view[_ngcontent-%COMP%]{border-bottom:1px solid #ebebeb}body.dark-mode[_nghost-%COMP%]   .main[_ngcontent-%COMP%]   metrics-filtered-view[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .main[_ngcontent-%COMP%]   metrics-filtered-view[_ngcontent-%COMP%]{border-bottom:1px solid #555}body.dark-mode[_nghost-%COMP%]   .main[_ngcontent-%COMP%]   metrics-pinned-view[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .main[_ngcontent-%COMP%]   metrics-pinned-view[_ngcontent-%COMP%]{border-bottom:1px solid #555}.main.filter-view[_ngcontent-%COMP%]{overflow:hidden}.main.filter-view[_ngcontent-%COMP%]   metrics-filtered-view[_ngcontent-%COMP%]{contain:content;overflow:auto;will-change:transform,scroll-position}.loading-container[_ngcontent-%COMP%]{align-items:center;display:flex;justify-content:center;margin:20px 0}.sidebar[_ngcontent-%COMP%]{border-left:1px solid #ebebeb;flex:0 0 250px}body.dark-mode[_nghost-%COMP%]   .sidebar[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .sidebar[_ngcontent-%COMP%]{border-left:1px solid #555}.sidebar[_ngcontent-%COMP%]   .header[_ngcontent-%COMP%]{border-bottom:1px solid #ebebeb;display:flex;align-items:center;justify-content:space-between;height:42px;padding:0 16px}body.dark-mode[_nghost-%COMP%]   .sidebar[_ngcontent-%COMP%]   .header[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .sidebar[_ngcontent-%COMP%]   .header[_ngcontent-%COMP%]{border-bottom:1px solid #555}.sidebar[_ngcontent-%COMP%]   .header[_ngcontent-%COMP%]   .title[_ngcontent-%COMP%]{font-size:18px;font-weight:400;line-height:normal;margin:0}[_nghost-%COMP%]   .settings-button[_ngcontent-%COMP%]{color:#616161;display:inline-flex}body.dark-mode   [_nghost-%COMP%]   .settings-button[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}[_nghost-%COMP%]   .settings-button.checked[_ngcontent-%COMP%]{background-color:#e0e0e0;border-color:#e0e0e0}body.dark-mode   [_nghost-%COMP%]   .settings-button.checked[_ngcontent-%COMP%]{background-color:#212121}[_nghost-%COMP%]   .settings-button[_ngcontent-%COMP%]     .mat-button-wrapper{display:inline-flex;align-items:center}[_nghost-%COMP%]   .settings-button[_ngcontent-%COMP%]   mat-icon[_ngcontent-%COMP%]{margin-right:4px}.slide-out-menu[_ngcontent-%COMP%]{background-color:#fff;height:calc(100% - 49px);position:absolute;right:50px;top:49px;transition:all .75s ease;visibility:hidden;width:200px;border-left:1px solid #ebebeb}body.dark-mode[_nghost-%COMP%]   .slide-out-menu[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .slide-out-menu[_ngcontent-%COMP%]{border-left:1px solid #555}body.dark-mode[_nghost-%COMP%]   .slide-out-menu[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .slide-out-menu[_ngcontent-%COMP%]{background-color:#303030}.slide-out-menu-expanded[_ngcontent-%COMP%]{right:250px;visibility:visible}"],changeDetection:0}),n})(),kne=(()=>{class n{constructor(e){this.store=e,this.isSidepaneOpen$=this.store.select(f1),this.initialTagsLoading$=this.store.select(wb).pipe(U_(i=>null===i.lastLoadedTimeInMs,!0),U(i=>i.state===De.LOADING&&null===i.lastLoadedTimeInMs)),this.showFilteredView$=this.store.select(Il).pipe(U(i=>i.length>0)),this.filteredPluginTypes$=this.store.select(wc),this.isSlideoutMenuOpen$=this.store.select(m1)}onSettingsButtonClicked(){this.store.dispatch(dT())}onCloseSidepaneButtonClicked(){this.store.dispatch(cT())}onPluginVisibilityToggled(e){this.store.dispatch(BT({plugin:e}))}onShowAllPlugins(){this.store.dispatch(VT())}}return n.\u0275fac=function(e){return new(e||n)(C(ke))},n.\u0275cmp=k({type:n,selectors:[["metrics-main-view"]],decls:6,vars:15,consts:[[3,"showFilteredView","isSidepaneOpen","initialTagsLoading","filteredPluginTypes","slideOutMenuOpen","onSettingsButtonClicked","onCloseSidepaneButtonClicked","onPluginTypeToggled","onPluginTypeAllToggled"]],template:function(e,i){1&e&&(h(0,"metrics-main-view-component",0),D("onSettingsButtonClicked",function(){return i.onSettingsButtonClicked()})("onCloseSidepaneButtonClicked",function(){return i.onCloseSidepaneButtonClicked()})("onPluginTypeToggled",function(o){return i.onPluginVisibilityToggled(o)})("onPluginTypeAllToggled",function(){return i.onShowAllPlugins()}),G(1,"async"),G(2,"async"),G(3,"async"),G(4,"async"),G(5,"async"),g()),2&e&&_("showFilteredView",W(1,5,i.showFilteredView$))("isSidepaneOpen",W(2,7,i.isSidepaneOpen$))("initialTagsLoading",W(3,9,i.initialTagsLoading$))("filteredPluginTypes",W(4,11,i.filteredPluginTypes$))("slideOutMenuOpen",W(5,13,i.isSlideoutMenuOpen$))},dependencies:[Rne,lt],encapsulation:2,changeDetection:0}),n})(),xa=(()=>(function(n){n.CHECKBOX="checkbox",n.RUN_NAME="run_name",n.EXPERIMENT_NAME="experiment_name",n.RUN_COLOR="run_color"}(xa||(xa={})),xa))(),IBe=["dialogPopup"],ABe=["hueSlider"],RBe=["alphaSlider"];function kBe(n,t){if(1&n&&P(0,"div"),2&n){let e=w();Dh("arrow arrow-",e.cpUsePosition,""),Mt("top",e.arrowTop,"px")}}function PBe(n,t){if(1&n){let e=ge();h(0,"div",28),D("newValue",function(r){return X(e),Q(w().onColorChange(r))})("dragStart",function(){return X(e),Q(w().onDragStart("saturation-lightness"))})("dragEnd",function(){return X(e),Q(w().onDragEnd("saturation-lightness"))}),P(1,"div",14),g()}if(2&n){let e=w();Mt("background-color",e.hueSliderColor),_("rgX",1)("rgY",1),b(1),Mt("top",null==e.slider?null:e.slider.v,"px")("left",null==e.slider?null:e.slider.s,"px")}}function OBe(n,t){1&n&&(Tn(),h(0,"svg",29),P(1,"path",30)(2,"path",31),g())}function FBe(n,t){if(1&n){let e=ge();h(0,"button",32),D("click",function(r){X(e);let o=w();return Q(o.onAddPresetColor(r,o.selectedColor))}),T(1),g()}if(2&n){let e=w();ka(e.cpAddColorButtonClass),_("disabled",e.cpPresetColors&&e.cpPresetColors.length>=e.cpMaxPresetColorsLength),b(1),ze(" ",e.cpAddColorButtonText," ")}}function LBe(n,t){1&n&&P(0,"div",33)}function NBe(n,t){if(1&n){let e=ge();h(0,"input",39),D("keyup.enter",function(r){return X(e),Q(w(2).onAcceptColor(r))})("newValue",function(r){return X(e),Q(w(2).onAlphaInput(r))}),g()}if(2&n){let e=w(2);_("rg",1)("value",null==e.cmykText?null:e.cmykText.a)}}function BBe(n,t){1&n&&(h(0,"div"),T(1,"A"),g())}function VBe(n,t){if(1&n){let e=ge();h(0,"div",34)(1,"div",35)(2,"input",36),D("keyup.enter",function(r){return X(e),Q(w().onAcceptColor(r))})("newValue",function(r){return X(e),Q(w().onCyanInput(r))}),g(),h(3,"input",36),D("keyup.enter",function(r){return X(e),Q(w().onAcceptColor(r))})("newValue",function(r){return X(e),Q(w().onMagentaInput(r))}),g(),h(4,"input",36),D("keyup.enter",function(r){return X(e),Q(w().onAcceptColor(r))})("newValue",function(r){return X(e),Q(w().onYellowInput(r))}),g(),h(5,"input",36),D("keyup.enter",function(r){return X(e),Q(w().onAcceptColor(r))})("newValue",function(r){return X(e),Q(w().onBlackInput(r))}),g(),S(6,NBe,1,2,"input",37),g(),h(7,"div",35)(8,"div"),T(9,"C"),g(),h(10,"div"),T(11,"M"),g(),h(12,"div"),T(13,"Y"),g(),h(14,"div"),T(15,"K"),g(),S(16,BBe,2,0,"div",38),g()()}if(2&n){let e=w();Mt("display",3!==e.format?"none":"block"),b(2),_("rg",100)("value",null==e.cmykText?null:e.cmykText.c),b(1),_("rg",100)("value",null==e.cmykText?null:e.cmykText.m),b(1),_("rg",100)("value",null==e.cmykText?null:e.cmykText.y),b(1),_("rg",100)("value",null==e.cmykText?null:e.cmykText.k),b(1),_("ngIf","disabled"!==e.cpAlphaChannel),b(10),_("ngIf","disabled"!==e.cpAlphaChannel)}}function HBe(n,t){if(1&n){let e=ge();h(0,"input",39),D("keyup.enter",function(r){return X(e),Q(w(2).onAcceptColor(r))})("newValue",function(r){return X(e),Q(w(2).onAlphaInput(r))}),g()}if(2&n){let e=w(2);_("rg",1)("value",null==e.hslaText?null:e.hslaText.a)}}function zBe(n,t){1&n&&(h(0,"div"),T(1,"A"),g())}function UBe(n,t){if(1&n){let e=ge();h(0,"div",40)(1,"div",35)(2,"input",41),D("keyup.enter",function(r){return X(e),Q(w().onAcceptColor(r))})("newValue",function(r){return X(e),Q(w().onHueInput(r))}),g(),h(3,"input",36),D("keyup.enter",function(r){return X(e),Q(w().onAcceptColor(r))})("newValue",function(r){return X(e),Q(w().onSaturationInput(r))}),g(),h(4,"input",36),D("keyup.enter",function(r){return X(e),Q(w().onAcceptColor(r))})("newValue",function(r){return X(e),Q(w().onLightnessInput(r))}),g(),S(5,HBe,1,2,"input",37),g(),h(6,"div",35)(7,"div"),T(8,"H"),g(),h(9,"div"),T(10,"S"),g(),h(11,"div"),T(12,"L"),g(),S(13,zBe,2,0,"div",38),g()()}if(2&n){let e=w();Mt("display",2!==e.format?"none":"block"),b(2),_("rg",360)("value",null==e.hslaText?null:e.hslaText.h),b(1),_("rg",100)("value",null==e.hslaText?null:e.hslaText.s),b(1),_("rg",100)("value",null==e.hslaText?null:e.hslaText.l),b(1),_("ngIf","disabled"!==e.cpAlphaChannel),b(8),_("ngIf","disabled"!==e.cpAlphaChannel)}}function jBe(n,t){if(1&n){let e=ge();h(0,"input",39),D("keyup.enter",function(r){return X(e),Q(w(2).onAcceptColor(r))})("newValue",function(r){return X(e),Q(w(2).onAlphaInput(r))}),g()}if(2&n){let e=w(2);_("rg",1)("value",null==e.rgbaText?null:e.rgbaText.a)}}function GBe(n,t){1&n&&(h(0,"div"),T(1,"A"),g())}function WBe(n,t){if(1&n){let e=ge();h(0,"div",42)(1,"div",35)(2,"input",43),D("keyup.enter",function(r){return X(e),Q(w().onAcceptColor(r))})("newValue",function(r){return X(e),Q(w().onRedInput(r))}),g(),h(3,"input",43),D("keyup.enter",function(r){return X(e),Q(w().onAcceptColor(r))})("newValue",function(r){return X(e),Q(w().onGreenInput(r))}),g(),h(4,"input",43),D("keyup.enter",function(r){return X(e),Q(w().onAcceptColor(r))})("newValue",function(r){return X(e),Q(w().onBlueInput(r))}),g(),S(5,jBe,1,2,"input",37),g(),h(6,"div",35)(7,"div"),T(8,"R"),g(),h(9,"div"),T(10,"G"),g(),h(11,"div"),T(12,"B"),g(),S(13,GBe,2,0,"div",38),g()()}if(2&n){let e=w();Mt("display",1!==e.format?"none":"block"),b(2),_("rg",255)("value",null==e.rgbaText?null:e.rgbaText.r),b(1),_("rg",255)("value",null==e.rgbaText?null:e.rgbaText.g),b(1),_("rg",255)("value",null==e.rgbaText?null:e.rgbaText.b),b(1),_("ngIf","disabled"!==e.cpAlphaChannel),b(8),_("ngIf","disabled"!==e.cpAlphaChannel)}}function qBe(n,t){if(1&n){let e=ge();h(0,"input",39),D("keyup.enter",function(r){return X(e),Q(w(2).onAcceptColor(r))})("newValue",function(r){return X(e),Q(w(2).onAlphaInput(r))}),g()}if(2&n){let e=w(2);_("rg",1)("value",e.hexAlpha)}}function YBe(n,t){1&n&&(h(0,"div"),T(1,"A"),g())}function XBe(n,t){if(1&n){let e=ge();h(0,"div",44)(1,"div",35)(2,"input",45),D("blur",function(){return X(e),Q(w().onHexInput(null))})("keyup.enter",function(r){return X(e),Q(w().onAcceptColor(r))})("newValue",function(r){return X(e),Q(w().onHexInput(r))}),g(),S(3,qBe,1,2,"input",37),g(),h(4,"div",35)(5,"div"),T(6,"Hex"),g(),S(7,YBe,2,0,"div",38),g()()}if(2&n){let e=w();Mt("display",0!==e.format?"none":"block"),Qe("hex-alpha","forced"===e.cpAlphaChannel),b(2),_("value",e.hexText),b(1),_("ngIf","forced"===e.cpAlphaChannel),b(4),_("ngIf","forced"===e.cpAlphaChannel)}}function QBe(n,t){if(1&n){let e=ge();h(0,"input",39),D("keyup.enter",function(r){return X(e),Q(w(2).onAcceptColor(r))})("newValue",function(r){return X(e),Q(w(2).onAlphaInput(r))}),g()}if(2&n){let e=w(2);_("rg",1)("value",null==e.hslaText?null:e.hslaText.a)}}function ZBe(n,t){if(1&n){let e=ge();h(0,"div",46)(1,"div",35)(2,"input",36),D("keyup.enter",function(r){return X(e),Q(w().onAcceptColor(r))})("newValue",function(r){return X(e),Q(w().onValueInput(r))}),g(),S(3,QBe,1,2,"input",37),g(),h(4,"div",35)(5,"div"),T(6,"V"),g(),h(7,"div"),T(8,"A"),g()()()}if(2&n){let e=w();b(2),_("rg",100)("value",null==e.hslaText?null:e.hslaText.l),b(1),_("ngIf","disabled"!==e.cpAlphaChannel)}}function KBe(n,t){if(1&n){let e=ge();h(0,"div",47)(1,"span",48),D("click",function(){return X(e),Q(w().onFormatToggle(-1))}),g(),h(2,"span",48),D("click",function(){return X(e),Q(w().onFormatToggle(1))}),g()()}}function JBe(n,t){if(1&n){let e=ge();h(0,"span",55),D("click",function(r){X(e);let o=w().$implicit;return Q(w(3).onRemovePresetColor(r,o))}),g()}2&n&&ka(w(4).cpRemoveColorButtonClass)}function $Be(n,t){if(1&n){let e=ge();h(0,"div",53),D("click",function(){let o=X(e).$implicit;return Q(w(3).setColorFromString(o))}),S(1,JBe,1,3,"span",54),g()}if(2&n){let e=t.$implicit,i=w(3);Mt("background-color",e),b(1),_("ngIf",i.cpAddColorButton)}}function eVe(n,t){if(1&n&&(h(0,"div"),S(1,$Be,2,3,"div",52),g()),2&n){let e=w(2);ka(e.cpPresetColorsClass),b(1),_("ngForOf",e.cpPresetColors)}}function tVe(n,t){if(1&n&&(h(0,"div"),T(1),g()),2&n){let e=w(2);ka(e.cpPresetEmptyMessageClass),b(1),ut(e.cpPresetEmptyMessage)}}function nVe(n,t){if(1&n&&(h(0,"div",49),P(1,"hr"),h(2,"div",50),T(3),g(),S(4,eVe,2,4,"div",51),S(5,tVe,2,4,"div",51),g()),2&n){let e=w();b(3),ut(e.cpPresetLabel),b(1),_("ngIf",null==e.cpPresetColors?null:e.cpPresetColors.length),b(1),_("ngIf",!(null!=e.cpPresetColors&&e.cpPresetColors.length)&&e.cpAddColorButton)}}function iVe(n,t){if(1&n){let e=ge();h(0,"button",58),D("click",function(r){return X(e),Q(w(2).onCancelColor(r))}),T(1),g()}if(2&n){let e=w(2);ka(e.cpCancelButtonClass),b(1),ut(e.cpCancelButtonText)}}function rVe(n,t){if(1&n){let e=ge();h(0,"button",58),D("click",function(r){return X(e),Q(w(2).onAcceptColor(r))}),T(1),g()}if(2&n){let e=w(2);ka(e.cpOKButtonClass),b(1),ut(e.cpOKButtonText)}}function oVe(n,t){if(1&n&&(h(0,"div",56),S(1,iVe,2,4,"button",57),S(2,rVe,2,4,"button",57),g()),2&n){let e=w();b(1),_("ngIf",e.cpCancelButton),b(1),_("ngIf",e.cpOKButton)}}function aVe(n,t){1&n&&Ti(0)}function sVe(n,t){if(1&n&&(h(0,"div",59),S(1,aVe,1,0,"ng-container",60),g()),2&n){let e=w();b(1),_("ngTemplateOutlet",e.cpExtraTemplate)}}var zo=(()=>(function(n){n[n.HEX=0]="HEX",n[n.RGBA=1]="RGBA",n[n.HSLA=2]="HSLA",n[n.CMYK=3]="CMYK"}(zo||(zo={})),zo))(),Jl=class{constructor(t,e,i,r){this.r=t,this.g=e,this.b=i,this.a=r}},T_=class{constructor(t,e,i,r){this.h=t,this.s=e,this.v=i,this.a=r}},Yd=class{constructor(t,e,i,r){this.h=t,this.s=e,this.l=i,this.a=r}},Om=class{constructor(t,e,i,r,o=1){this.c=t,this.m=e,this.y=i,this.k=r,this.a=o}},dVe=(()=>{class n{constructor(){this.newValue=new L}inputChange(e){let i=e.target.value;if(void 0===this.rg)this.newValue.emit(i);else{let r=parseFloat(i);this.newValue.emit({v:r,rg:this.rg})}}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275dir=xe({type:n,selectors:[["","text",""]],hostBindings:function(e,i){1&e&&D("input",function(o){return i.inputChange(o)})},inputs:{rg:"rg",text:"text"},outputs:{newValue:"newValue"}}),n})(),uVe=(()=>{class n{constructor(e){this.elRef=e,this.dragEnd=new L,this.dragStart=new L,this.newValue=new L,this.listenerMove=i=>this.move(i),this.listenerStop=()=>this.stop()}mouseDown(e){this.start(e)}touchStart(e){this.start(e)}move(e){e.preventDefault(),this.setCursor(e)}start(e){this.setCursor(e),e.stopPropagation(),document.addEventListener("mouseup",this.listenerStop),document.addEventListener("touchend",this.listenerStop),document.addEventListener("mousemove",this.listenerMove),document.addEventListener("touchmove",this.listenerMove),this.dragStart.emit()}stop(){document.removeEventListener("mouseup",this.listenerStop),document.removeEventListener("touchend",this.listenerStop),document.removeEventListener("mousemove",this.listenerMove),document.removeEventListener("touchmove",this.listenerMove),this.dragEnd.emit()}getX(e){let i=this.elRef.nativeElement.getBoundingClientRect();return(void 0!==e.pageX?e.pageX:e.touches[0].pageX)-i.left-window.pageXOffset}getY(e){let i=this.elRef.nativeElement.getBoundingClientRect();return(void 0!==e.pageY?e.pageY:e.touches[0].pageY)-i.top-window.pageYOffset}setCursor(e){let i=this.elRef.nativeElement.offsetWidth,r=this.elRef.nativeElement.offsetHeight,o=Math.max(0,Math.min(this.getX(e),i)),a=Math.max(0,Math.min(this.getY(e),r));void 0!==this.rgX&&void 0!==this.rgY?this.newValue.emit({s:o/i,v:1-a/r,rgX:this.rgX,rgY:this.rgY}):void 0===this.rgX&&void 0!==this.rgY?this.newValue.emit({v:a/r,rgY:this.rgY}):void 0!==this.rgX&&void 0===this.rgY&&this.newValue.emit({v:o/i,rgX:this.rgX})}}return n.\u0275fac=function(e){return new(e||n)(C(be))},n.\u0275dir=xe({type:n,selectors:[["","slider",""]],hostBindings:function(e,i){1&e&&D("mousedown",function(o){return i.mouseDown(o)})("touchstart",function(o){return i.touchStart(o)})},inputs:{rgX:"rgX",rgY:"rgY",slider:"slider"},outputs:{dragEnd:"dragEnd",dragStart:"dragStart",newValue:"newValue"}}),n})(),_A=class{constructor(t,e,i,r){this.h=t,this.s=e,this.v=i,this.a=r}},yA=class{constructor(t,e,i,r){this.h=t,this.s=e,this.v=i,this.a=r}},JV=(()=>{class n{constructor(){this.active=null}setActive(e){this.active&&this.active!==e&&"inline"!==this.active.cpDialogDisplay&&this.active.closeDialog(),this.active=e}hsva2hsla(e){let i=e.h,r=e.s,o=e.v,a=e.a;if(0===o)return new Yd(i,0,0,a);if(0===r&&1===o)return new Yd(i,1,1,a);{let s=o*(2-r)/2;return new Yd(i,o*r/(1-Math.abs(2*s-1)),s,a)}}hsla2hsva(e){let i=Math.min(e.h,1),r=Math.min(e.s,1),o=Math.min(e.l,1),a=Math.min(e.a,1);if(0===o)return new T_(i,0,0,a);{let s=o+r*(1-Math.abs(2*o-1))/2;return new T_(i,2*(s-o)/s,s,a)}}hsvaToRgba(e){let i,r,o,a=e.h,s=e.s,l=e.v,c=e.a,d=Math.floor(6*a),u=6*a-d,p=l*(1-s),f=l*(1-u*s),m=l*(1-(1-u)*s);switch(d%6){case 0:i=l,r=m,o=p;break;case 1:i=f,r=l,o=p;break;case 2:i=p,r=l,o=m;break;case 3:i=p,r=f,o=l;break;case 4:i=m,r=p,o=l;break;case 5:i=l,r=p,o=f;break;default:i=0,r=0,o=0}return new Jl(i,r,o,c)}cmykToRgb(e){return new Jl((1-e.c)*(1-e.k),(1-e.m)*(1-e.k),(1-e.y)*(1-e.k),e.a)}rgbaToCmyk(e){let i=1-Math.max(e.r,e.g,e.b);return 1===i?new Om(0,0,0,1,e.a):new Om((1-e.r-i)/(1-i),(1-e.g-i)/(1-i),(1-e.b-i)/(1-i),i,e.a)}rgbaToHsva(e){let i,r,o=Math.min(e.r,1),a=Math.min(e.g,1),s=Math.min(e.b,1),l=Math.min(e.a,1),c=Math.max(o,a,s),d=Math.min(o,a,s),u=c,p=c-d;if(r=0===c?0:p/c,c===d)i=0;else{switch(c){case o:i=(a-s)/p+(a<s?6:0);break;case a:i=(s-o)/p+2;break;case s:i=(o-a)/p+4;break;default:i=0}i/=6}return new T_(i,r,u,l)}rgbaToHex(e,i){let r="#"+(16777216|e.r<<16|e.g<<8|e.b).toString(16).substr(1);return i&&(r+=(256|Math.round(255*e.a)).toString(16).substr(1)),r}normalizeCMYK(e){return new Om(e.c/100,e.m/100,e.y/100,e.k/100,e.a)}denormalizeCMYK(e){return new Om(Math.floor(100*e.c),Math.floor(100*e.m),Math.floor(100*e.y),Math.floor(100*e.k),e.a)}denormalizeRGBA(e){return new Jl(Math.round(255*e.r),Math.round(255*e.g),Math.round(255*e.b),e.a)}stringToHsva(e="",i=!1){let r=null;e=(e||"").toLowerCase();let o=[{re:/(rgb)a?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*%?,\s*(\d{1,3})\s*%?(?:,\s*(\d+(?:\.\d+)?)\s*)?\)/,parse:function(a){return new Jl(parseInt(a[2],10)/255,parseInt(a[3],10)/255,parseInt(a[4],10)/255,isNaN(parseFloat(a[5]))?1:parseFloat(a[5]))}},{re:/(hsl)a?\(\s*(\d{1,3})\s*,\s*(\d{1,3})%\s*,\s*(\d{1,3})%\s*(?:,\s*(\d+(?:\.\d+)?)\s*)?\)/,parse:function(a){return new Yd(parseInt(a[2],10)/360,parseInt(a[3],10)/100,parseInt(a[4],10)/100,isNaN(parseFloat(a[5]))?1:parseFloat(a[5]))}}];o.push(i?{re:/#([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})?$/,parse:function(a){return new Jl(parseInt(a[1],16)/255,parseInt(a[2],16)/255,parseInt(a[3],16)/255,parseInt(a[4]||"FF",16)/255)}}:{re:/#([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})$/,parse:function(a){return new Jl(parseInt(a[1],16)/255,parseInt(a[2],16)/255,parseInt(a[3],16)/255,1)}}),o.push({re:/#([a-fA-F0-9])([a-fA-F0-9])([a-fA-F0-9])$/,parse:function(a){return new Jl(parseInt(a[1]+a[1],16)/255,parseInt(a[2]+a[2],16)/255,parseInt(a[3]+a[3],16)/255,1)}});for(let a in o)if(o.hasOwnProperty(a)){let s=o[a],l=s.re.exec(e),c=l&&s.parse(l);if(c)return c instanceof Jl?r=this.rgbaToHsva(c):c instanceof Yd&&(r=this.hsla2hsva(c)),r}return r}outputFormat(e,i,r){switch("auto"===i&&(i=e.a<1?"rgba":"hex"),i){case"hsla":let o=this.hsva2hsla(e),a=new Yd(Math.round(360*o.h),Math.round(100*o.s),Math.round(100*o.l),Math.round(100*o.a)/100);return e.a<1||"always"===r?"hsla("+a.h+","+a.s+"%,"+a.l+"%,"+a.a+")":"hsl("+a.h+","+a.s+"%,"+a.l+"%)";case"rgba":let s=this.denormalizeRGBA(this.hsvaToRgba(e));return e.a<1||"always"===r?"rgba("+s.r+","+s.g+","+s.b+","+Math.round(100*s.a)/100+")":"rgb("+s.r+","+s.g+","+s.b+")";default:let l="always"===r||"forced"===r;return this.rgbaToHex(this.denormalizeRGBA(this.hsvaToRgba(e)),l)}}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})(),Pne=typeof window<"u"&&"ontouchstart"in window,pVe=(()=>{class n{constructor(e,i,r,o,a,s){this.ngZone=e,this.elRef=i,this.cdRef=r,this.document=o,this.platformId=a,this.service=s,this.isIE10=!1,this.dialogArrowSize=10,this.dialogArrowOffset=15,this.dialogInputFields=[zo.HEX,zo.RGBA,zo.HSLA,zo.CMYK],this.useRootViewContainer=!1,this.eyeDropperSupported=bw(this.platformId)&&"EyeDropper"in this.document.defaultView}handleEsc(e){this.show&&"popup"===this.cpDialogDisplay&&this.onCancelColor(e)}handleEnter(e){this.show&&"popup"===this.cpDialogDisplay&&this.onAcceptColor(e)}ngOnInit(){this.slider=new _A(0,0,0,0),this.sliderDimMax=new yA(this.hueSlider.nativeElement.offsetWidth||140,this.cpWidth,130,this.alphaSlider.nativeElement.offsetWidth||140),this.format=this.cpCmykEnabled?zo.CMYK:"rgba"===this.cpOutputFormat?zo.RGBA:"hsla"===this.cpOutputFormat?zo.HSLA:zo.HEX,this.listenerMouseDown=r=>{this.onMouseDown(r)},this.listenerResize=()=>{this.onResize()},this.openDialog(this.initialColor,!1)}ngOnDestroy(){this.closeDialog()}ngAfterViewInit(){230===this.cpWidth&&"inline"!==this.cpDialogDisplay||(this.sliderDimMax=new yA(this.hueSlider.nativeElement.offsetWidth||140,this.cpWidth,130,this.alphaSlider.nativeElement.offsetWidth||140),this.updateColorPicker(!1),this.cdRef.detectChanges())}openDialog(e,i=!0){this.service.setActive(this),this.width||(this.cpWidth=this.directiveElementRef.nativeElement.offsetWidth),this.height||(this.height=320),this.setInitialColor(e),this.setColorFromString(e,i),this.openColorPicker()}closeDialog(){this.closeColorPicker()}setupDialog(e,i,r,o,a,s,l,c,d,u,p,f,m,y,M,v,x,R,A,H,te,K,Ce,Ze,Ie,I,re,ce,fe,_e,ne,de,ue,Ge,Me,Ne,ct,wt){this.setInitialColor(r),this.setColorMode(c),this.isIE10=10===function(){let n="";typeof navigator<"u"&&(n=navigator.userAgent.toLowerCase());let t=n.indexOf("msie ");return t>0&&parseInt(n.substring(t+5,n.indexOf(".",t)),10)}(),this.directiveInstance=e,this.directiveElementRef=i,this.cpDisableInput=f,this.cpCmykEnabled=d,this.cpAlphaChannel=u,this.cpOutputFormat=p,this.cpDialogDisplay=s,this.cpIgnoredElements=m,this.cpSaveClickOutside=y,this.cpCloseClickOutside=M,this.useRootViewContainer=v,this.width=this.cpWidth=parseInt(o,10),this.height=this.cpHeight=parseInt(a,10),this.cpPosition=x,this.cpPositionOffset=parseInt(R,10),this.cpOKButton=I,this.cpOKButtonText=ce,this.cpOKButtonClass=re,this.cpCancelButton=fe,this.cpCancelButtonText=ne,this.cpCancelButtonClass=_e,this.cpEyeDropper=Ne,this.fallbackColor=l||"#fff",this.setPresetConfig(H,te),this.cpPresetColorsClass=K,this.cpMaxPresetColorsLength=Ce,this.cpPresetEmptyMessage=Ze,this.cpPresetEmptyMessageClass=Ie,this.cpAddColorButton=de,this.cpAddColorButtonText=Ge,this.cpAddColorButtonClass=ue,this.cpRemoveColorButtonClass=Me,this.cpTriggerElement=ct,this.cpExtraTemplate=wt,A||(this.dialogArrowOffset=0),"inline"===s&&(this.dialogArrowSize=0,this.dialogArrowOffset=0),"hex"===p&&"always"!==u&&"forced"!==u&&(this.cpAlphaChannel="disabled")}setColorMode(e){switch(e.toString().toUpperCase()){case"1":case"C":case"COLOR":default:this.cpColorMode=1;break;case"2":case"G":case"GRAYSCALE":this.cpColorMode=2;break;case"3":case"P":case"PRESETS":this.cpColorMode=3}}setInitialColor(e){this.initialColor=e}setPresetConfig(e,i){this.cpPresetLabel=e,this.cpPresetColors=i}setColorFromString(e,i=!0,r=!0){let o;"always"===this.cpAlphaChannel||"forced"===this.cpAlphaChannel?(o=this.service.stringToHsva(e,!0),!o&&!this.hsva&&(o=this.service.stringToHsva(e,!1))):o=this.service.stringToHsva(e,!1),!o&&!this.hsva&&(o=this.service.stringToHsva(this.fallbackColor,!1)),o&&(this.hsva=o,this.sliderH=this.hsva.h,"hex"===this.cpOutputFormat&&"disabled"===this.cpAlphaChannel&&(this.hsva.a=1),this.updateColorPicker(i,r))}onResize(){"fixed"===this.position?this.setDialogPosition():"inline"!==this.cpDialogDisplay&&this.closeColorPicker()}onDragEnd(e){this.directiveInstance.sliderDragEnd({slider:e,color:this.outputColor})}onDragStart(e){this.directiveInstance.sliderDragStart({slider:e,color:this.outputColor})}onMouseDown(e){this.show&&!this.isIE10&&"popup"===this.cpDialogDisplay&&e.target!==this.directiveElementRef.nativeElement&&!this.isDescendant(this.elRef.nativeElement,e.target)&&!this.isDescendant(this.directiveElementRef.nativeElement,e.target)&&0===this.cpIgnoredElements.filter(i=>i===e.target).length&&this.ngZone.run(()=>{this.cpSaveClickOutside?this.directiveInstance.colorSelected(this.outputColor):(this.hsva=null,this.setColorFromString(this.initialColor,!1),this.cpCmykEnabled&&this.directiveInstance.cmykChanged(this.cmykColor),this.directiveInstance.colorChanged(this.initialColor),this.directiveInstance.colorCanceled()),this.cpCloseClickOutside&&this.closeColorPicker()})}onAcceptColor(e){e.stopPropagation(),this.outputColor&&this.directiveInstance.colorSelected(this.outputColor),"popup"===this.cpDialogDisplay&&this.closeColorPicker()}onCancelColor(e){this.hsva=null,e.stopPropagation(),this.directiveInstance.colorCanceled(),this.setColorFromString(this.initialColor,!0),"popup"===this.cpDialogDisplay&&(this.cpCmykEnabled&&this.directiveInstance.cmykChanged(this.cmykColor),this.directiveInstance.colorChanged(this.initialColor,!0),this.closeColorPicker())}onEyeDropper(){this.eyeDropperSupported&&(new window.EyeDropper).open().then(i=>{this.setColorFromString(i.sRGBHex,!0)})}onFormatToggle(e){let i=this.dialogInputFields.length-(this.cpCmykEnabled?0:1),r=((this.dialogInputFields.indexOf(this.format)+e)%i+i)%i;this.format=this.dialogInputFields[r]}onColorChange(e){this.hsva.s=e.s/e.rgX,this.hsva.v=e.v/e.rgY,this.updateColorPicker(),this.directiveInstance.sliderChanged({slider:"lightness",value:this.hsva.v,color:this.outputColor}),this.directiveInstance.sliderChanged({slider:"saturation",value:this.hsva.s,color:this.outputColor})}onHueChange(e){this.hsva.h=e.v/e.rgX,this.sliderH=this.hsva.h,this.updateColorPicker(),this.directiveInstance.sliderChanged({slider:"hue",value:this.hsva.h,color:this.outputColor})}onValueChange(e){this.hsva.v=e.v/e.rgX,this.updateColorPicker(),this.directiveInstance.sliderChanged({slider:"value",value:this.hsva.v,color:this.outputColor})}onAlphaChange(e){this.hsva.a=e.v/e.rgX,this.updateColorPicker(),this.directiveInstance.sliderChanged({slider:"alpha",value:this.hsva.a,color:this.outputColor})}onHexInput(e){if(null===e)this.updateColorPicker();else{e&&"#"!==e[0]&&(e="#"+e);let i=/^#([a-f0-9]{3}|[a-f0-9]{6})$/gi;"always"===this.cpAlphaChannel&&(i=/^#([a-f0-9]{3}|[a-f0-9]{6}|[a-f0-9]{8})$/gi);let r=i.test(e);r&&(e.length<5&&(e="#"+e.substring(1).split("").map(o=>o+o).join("")),"forced"===this.cpAlphaChannel&&(e+=Math.round(255*this.hsva.a).toString(16)),this.setColorFromString(e,!0,!1)),this.directiveInstance.inputChanged({input:"hex",valid:r,value:e,color:this.outputColor})}}onRedInput(e){let i=this.service.hsvaToRgba(this.hsva),r=!isNaN(e.v)&&e.v>=0&&e.v<=e.rg;r&&(i.r=e.v/e.rg,this.hsva=this.service.rgbaToHsva(i),this.sliderH=this.hsva.h,this.updateColorPicker()),this.directiveInstance.inputChanged({input:"red",valid:r,value:i.r,color:this.outputColor})}onBlueInput(e){let i=this.service.hsvaToRgba(this.hsva),r=!isNaN(e.v)&&e.v>=0&&e.v<=e.rg;r&&(i.b=e.v/e.rg,this.hsva=this.service.rgbaToHsva(i),this.sliderH=this.hsva.h,this.updateColorPicker()),this.directiveInstance.inputChanged({input:"blue",valid:r,value:i.b,color:this.outputColor})}onGreenInput(e){let i=this.service.hsvaToRgba(this.hsva),r=!isNaN(e.v)&&e.v>=0&&e.v<=e.rg;r&&(i.g=e.v/e.rg,this.hsva=this.service.rgbaToHsva(i),this.sliderH=this.hsva.h,this.updateColorPicker()),this.directiveInstance.inputChanged({input:"green",valid:r,value:i.g,color:this.outputColor})}onHueInput(e){let i=!isNaN(e.v)&&e.v>=0&&e.v<=e.rg;i&&(this.hsva.h=e.v/e.rg,this.sliderH=this.hsva.h,this.updateColorPicker()),this.directiveInstance.inputChanged({input:"hue",valid:i,value:this.hsva.h,color:this.outputColor})}onValueInput(e){let i=!isNaN(e.v)&&e.v>=0&&e.v<=e.rg;i&&(this.hsva.v=e.v/e.rg,this.updateColorPicker()),this.directiveInstance.inputChanged({input:"value",valid:i,value:this.hsva.v,color:this.outputColor})}onAlphaInput(e){let i=!isNaN(e.v)&&e.v>=0&&e.v<=e.rg;i&&(this.hsva.a=e.v/e.rg,this.updateColorPicker()),this.directiveInstance.inputChanged({input:"alpha",valid:i,value:this.hsva.a,color:this.outputColor})}onLightnessInput(e){let i=this.service.hsva2hsla(this.hsva),r=!isNaN(e.v)&&e.v>=0&&e.v<=e.rg;r&&(i.l=e.v/e.rg,this.hsva=this.service.hsla2hsva(i),this.sliderH=this.hsva.h,this.updateColorPicker()),this.directiveInstance.inputChanged({input:"lightness",valid:r,value:i.l,color:this.outputColor})}onSaturationInput(e){let i=this.service.hsva2hsla(this.hsva),r=!isNaN(e.v)&&e.v>=0&&e.v<=e.rg;r&&(i.s=e.v/e.rg,this.hsva=this.service.hsla2hsva(i),this.sliderH=this.hsva.h,this.updateColorPicker()),this.directiveInstance.inputChanged({input:"saturation",valid:r,value:i.s,color:this.outputColor})}onCyanInput(e){!isNaN(e.v)&&e.v>=0&&e.v<=e.rg&&(this.cmyk.c=e.v,this.updateColorPicker(!1,!0,!0)),this.directiveInstance.inputChanged({input:"cyan",valid:!0,value:this.cmyk.c,color:this.outputColor})}onMagentaInput(e){!isNaN(e.v)&&e.v>=0&&e.v<=e.rg&&(this.cmyk.m=e.v,this.updateColorPicker(!1,!0,!0)),this.directiveInstance.inputChanged({input:"magenta",valid:!0,value:this.cmyk.m,color:this.outputColor})}onYellowInput(e){!isNaN(e.v)&&e.v>=0&&e.v<=e.rg&&(this.cmyk.y=e.v,this.updateColorPicker(!1,!0,!0)),this.directiveInstance.inputChanged({input:"yellow",valid:!0,value:this.cmyk.y,color:this.outputColor})}onBlackInput(e){!isNaN(e.v)&&e.v>=0&&e.v<=e.rg&&(this.cmyk.k=e.v,this.updateColorPicker(!1,!0,!0)),this.directiveInstance.inputChanged({input:"black",valid:!0,value:this.cmyk.k,color:this.outputColor})}onAddPresetColor(e,i){e.stopPropagation(),this.cpPresetColors.filter(r=>r===i).length||(this.cpPresetColors=this.cpPresetColors.concat(i),this.directiveInstance.presetColorsChanged(this.cpPresetColors))}onRemovePresetColor(e,i){e.stopPropagation(),this.cpPresetColors=this.cpPresetColors.filter(r=>r!==i),this.directiveInstance.presetColorsChanged(this.cpPresetColors)}openColorPicker(){this.show||(this.show=!0,this.hidden=!0,setTimeout(()=>{this.hidden=!1,this.setDialogPosition(),this.cdRef.detectChanges()},0),this.directiveInstance.stateChanged(!0),this.isIE10||this.ngZone.runOutsideAngular(()=>{Pne?document.addEventListener("touchstart",this.listenerMouseDown):document.addEventListener("mousedown",this.listenerMouseDown)}),window.addEventListener("resize",this.listenerResize))}closeColorPicker(){this.show&&(this.show=!1,this.directiveInstance.stateChanged(!1),this.isIE10||(Pne?document.removeEventListener("touchstart",this.listenerMouseDown):document.removeEventListener("mousedown",this.listenerMouseDown)),window.removeEventListener("resize",this.listenerResize),this.cdRef.destroyed||this.cdRef.detectChanges())}updateColorPicker(e=!0,i=!0,r=!1){if(this.sliderDimMax){2===this.cpColorMode&&(this.hsva.s=0);let o,a,s,l=this.outputColor;if(a=this.service.hsva2hsla(this.hsva),this.cpCmykEnabled?(r?(s=this.service.cmykToRgb(this.service.normalizeCMYK(this.cmyk)),this.hsva=this.service.rgbaToHsva(s)):(s=this.service.hsvaToRgba(this.hsva),this.cmyk=this.service.denormalizeCMYK(this.service.rgbaToCmyk(s))),s=this.service.denormalizeRGBA(s),this.sliderH=this.hsva.h):s=this.service.denormalizeRGBA(this.service.hsvaToRgba(this.hsva)),o=this.service.denormalizeRGBA(this.service.hsvaToRgba(new T_(this.sliderH||this.hsva.h,1,1,1))),i&&(this.hslaText=new Yd(Math.round(360*a.h),Math.round(100*a.s),Math.round(100*a.l),Math.round(100*a.a)/100),this.rgbaText=new Jl(s.r,s.g,s.b,Math.round(100*s.a)/100),this.cpCmykEnabled&&(this.cmykText=new Om(this.cmyk.c,this.cmyk.m,this.cmyk.y,this.cmyk.k,Math.round(100*this.cmyk.a)/100)),this.hexText=this.service.rgbaToHex(s,"always"===this.cpAlphaChannel),this.hexAlpha=this.rgbaText.a),"auto"===this.cpOutputFormat&&this.format!==zo.RGBA&&this.format!==zo.CMYK&&this.format!==zo.HSLA&&this.hsva.a<1&&(this.format=this.hsva.a<1?zo.RGBA:zo.HEX),this.hueSliderColor="rgb("+o.r+","+o.g+","+o.b+")",this.alphaSliderColor="rgb("+s.r+","+s.g+","+s.b+")",this.outputColor=this.service.outputFormat(this.hsva,this.cpOutputFormat,this.cpAlphaChannel),this.selectedColor=this.service.outputFormat(this.hsva,"rgba",null),this.format!==zo.CMYK)this.cmykColor="";else if("always"===this.cpAlphaChannel||"enabled"===this.cpAlphaChannel||"forced"===this.cpAlphaChannel){let c=Math.round(100*this.cmyk.a)/100;this.cmykColor=`cmyka(${this.cmyk.c},${this.cmyk.m},${this.cmyk.y},${this.cmyk.k},${c})`}else this.cmykColor=`cmyk(${this.cmyk.c},${this.cmyk.m},${this.cmyk.y},${this.cmyk.k})`;this.slider=new _A((this.sliderH||this.hsva.h)*this.sliderDimMax.h-8,this.hsva.s*this.sliderDimMax.s-8,(1-this.hsva.v)*this.sliderDimMax.v-8,this.hsva.a*this.sliderDimMax.a-8),e&&l!==this.outputColor&&(this.cpCmykEnabled&&this.directiveInstance.cmykChanged(this.cmykColor),this.directiveInstance.colorChanged(this.outputColor))}}setDialogPosition(){if("inline"===this.cpDialogDisplay)this.position="relative";else{let r,e="static",i="",o=null,a=null,s=this.directiveElementRef.nativeElement.parentNode,l=this.dialogElement.nativeElement.offsetHeight;for(;null!==s&&"HTML"!==s.tagName;){if(r=window.getComputedStyle(s),e=r.getPropertyValue("position"),i=r.getPropertyValue("transform"),"static"!==e&&null===o&&(o=s),i&&"none"!==i&&null===a&&(a=s),"fixed"===e){o=a;break}s=s.parentNode}let c=this.createDialogBox(this.directiveElementRef.nativeElement,"fixed"!==e);if(this.useRootViewContainer||"fixed"===e&&(!o||o instanceof HTMLUnknownElement))this.top=c.top,this.left=c.left;else{null===o&&(o=s);let u=this.createDialogBox(o,"fixed"!==e);this.top=c.top-u.top,this.left=c.left-u.left}"fixed"===e&&(this.position="fixed");let d=this.cpPosition;"auto"===this.cpPosition&&(d=function(n,t){let e="right",i="bottom",{height:r,width:o}=n,{top:a,left:s}=t,l=a+t.height,c=s+t.width,d=a-r<0,u=l+r>(window.innerHeight||document.documentElement.clientHeight),p=s-o<0,f=c+o>(window.innerWidth||document.documentElement.clientWidth);return u&&(i="top"),d&&(i="bottom"),p&&(e="right"),f&&(e="left"),d&&u&&p&&f?["left","right","top","bottom"].reduce((M,v)=>n[M]>n[v]?M:v):p&&f?d?"bottom":u||a>l?"top":"bottom":d&&u?p?"right":f||s>c?"left":"right":`${i}-${e}`}(this.dialogElement.nativeElement.getBoundingClientRect(),this.cpTriggerElement.nativeElement.getBoundingClientRect())),"top"===d?(this.arrowTop=l-1,this.top-=l+this.dialogArrowSize,this.left+=this.cpPositionOffset/100*c.width-this.dialogArrowOffset):"bottom"===d?(this.top+=c.height+this.dialogArrowSize,this.left+=this.cpPositionOffset/100*c.width-this.dialogArrowOffset):"top-left"===d||"left-top"===d?(this.top-=l-c.height+c.height*this.cpPositionOffset/100,this.left-=this.cpWidth+this.dialogArrowSize-2-this.dialogArrowOffset):"top-right"===d||"right-top"===d?(this.top-=l-c.height+c.height*this.cpPositionOffset/100,this.left+=c.width+this.dialogArrowSize-2-this.dialogArrowOffset):"left"===d||"bottom-left"===d||"left-bottom"===d?(this.top+=c.height*this.cpPositionOffset/100-this.dialogArrowOffset,this.left-=this.cpWidth+this.dialogArrowSize-2):(this.top+=c.height*this.cpPositionOffset/100-this.dialogArrowOffset,this.left+=c.width+this.dialogArrowSize-2),this.cpUsePosition=d}}isDescendant(e,i){let r=i.parentNode;for(;null!==r;){if(r===e)return!0;r=r.parentNode}return!1}createDialogBox(e,i){let{top:r,left:o}=e.getBoundingClientRect();return{top:r+(i?window.pageYOffset:0),left:o+(i?window.pageXOffset:0),width:e.offsetWidth,height:e.offsetHeight}}}return n.\u0275fac=function(e){return new(e||n)(C(at),C(be),C(Ft),C(kt),C(hc),C(JV))},n.\u0275cmp=k({type:n,selectors:[["color-picker"]],viewQuery:function(e,i){if(1&e&&(Ye(IBe,7),Ye(ABe,7),Ye(RBe,7)),2&e){let r;we(r=Se())&&(i.dialogElement=r.first),we(r=Se())&&(i.hueSlider=r.first),we(r=Se())&&(i.alphaSlider=r.first)}},hostBindings:function(e,i){1&e&&D("keyup.esc",function(o){return i.handleEsc(o)},0,uc)("keyup.enter",function(o){return i.handleEnter(o)},!1,uc)},decls:30,vars:51,consts:[[1,"color-picker",3,"click"],["dialogPopup",""],[3,"class","top",4,"ngIf"],["class","saturation-lightness",3,"slider","rgX","rgY","background-color","newValue","dragStart","dragEnd",4,"ngIf"],[1,"hue-alpha","box"],[1,"left"],[1,"selected-color-background"],[1,"selected-color",3,"click"],["class","eyedropper-icon","xmlns","http://www.w3.org/2000/svg","height","24px","viewBox","0 0 24 24","width","24px","fill","#000000",4,"ngIf"],["type","button",3,"class","disabled","click",4,"ngIf"],[1,"right"],["style","height: 16px;",4,"ngIf"],[1,"hue",3,"slider","rgX","newValue","dragStart","dragEnd"],["hueSlider",""],[1,"cursor"],[1,"value",3,"slider","rgX","newValue","dragStart","dragEnd"],["valueSlider",""],[1,"alpha",3,"slider","rgX","newValue","dragStart","dragEnd"],["alphaSlider",""],["class","cmyk-text",3,"display",4,"ngIf"],["class","hsla-text",3,"display",4,"ngIf"],["class","rgba-text",3,"display",4,"ngIf"],["class","hex-text",3,"hex-alpha","display",4,"ngIf"],["class","value-text",4,"ngIf"],["class","type-policy",4,"ngIf"],["class","preset-area",4,"ngIf"],["class","button-area",4,"ngIf"],["class","extra-template",4,"ngIf"],[1,"saturation-lightness",3,"slider","rgX","rgY","newValue","dragStart","dragEnd"],["xmlns","http://www.w3.org/2000/svg","height","24px","viewBox","0 0 24 24","width","24px","fill","#000000",1,"eyedropper-icon"],["d","M0 0h24v24H0V0z","fill","none"],["d","M17.66 5.41l.92.92-2.69 2.69-.92-.92 2.69-2.69M17.67 3c-.26 0-.51.1-.71.29l-3.12 3.12-1.93-1.91-1.41 1.41 1.42 1.42L3 16.25V21h4.75l8.92-8.92 1.42 1.42 1.41-1.41-1.92-1.92 3.12-3.12c.4-.4.4-1.03.01-1.42l-2.34-2.34c-.2-.19-.45-.29-.7-.29zM6.92 19L5 17.08l8.06-8.06 1.92 1.92L6.92 19z"],["type","button",3,"disabled","click"],[2,"height","16px"],[1,"cmyk-text"],[1,"box"],["type","number","pattern","[0-9]*","min","0","max","100",3,"text","rg","value","keyup.enter","newValue"],["type","number","pattern","[0-9]+([\\.,][0-9]{1,2})?","min","0","max","1","step","0.1",3,"text","rg","value","keyup.enter","newValue",4,"ngIf"],[4,"ngIf"],["type","number","pattern","[0-9]+([\\.,][0-9]{1,2})?","min","0","max","1","step","0.1",3,"text","rg","value","keyup.enter","newValue"],[1,"hsla-text"],["type","number","pattern","[0-9]*","min","0","max","360",3,"text","rg","value","keyup.enter","newValue"],[1,"rgba-text"],["type","number","pattern","[0-9]*","min","0","max","255",3,"text","rg","value","keyup.enter","newValue"],[1,"hex-text"],[3,"text","value","blur","keyup.enter","newValue"],[1,"value-text"],[1,"type-policy"],[1,"type-policy-arrow",3,"click"],[1,"preset-area"],[1,"preset-label"],[3,"class",4,"ngIf"],["class","preset-color",3,"backgroundColor","click",4,"ngFor","ngForOf"],[1,"preset-color",3,"click"],[3,"class","click",4,"ngIf"],[3,"click"],[1,"button-area"],["type","button",3,"class","click",4,"ngIf"],["type","button",3,"click"],[1,"extra-template"],[4,"ngTemplateOutlet"]],template:function(e,i){1&e&&(h(0,"div",0,1),D("click",function(o){return o.stopPropagation()}),S(2,kBe,1,5,"div",2),S(3,PBe,2,8,"div",3),h(4,"div",4)(5,"div",5),P(6,"div",6),h(7,"div",7),D("click",function(){return i.eyeDropperSupported&&i.cpEyeDropper&&i.onEyeDropper()}),S(8,OBe,3,0,"svg",8),g(),S(9,FBe,2,5,"button",9),g(),h(10,"div",10),S(11,LBe,1,0,"div",11),h(12,"div",12,13),D("newValue",function(o){return i.onHueChange(o)})("dragStart",function(){return i.onDragStart("hue")})("dragEnd",function(){return i.onDragEnd("hue")}),P(14,"div",14),g(),h(15,"div",15,16),D("newValue",function(o){return i.onValueChange(o)})("dragStart",function(){return i.onDragStart("value")})("dragEnd",function(){return i.onDragEnd("value")}),P(17,"div",14),g(),h(18,"div",17,18),D("newValue",function(o){return i.onAlphaChange(o)})("dragStart",function(){return i.onDragStart("alpha")})("dragEnd",function(){return i.onDragEnd("alpha")}),P(20,"div",14),g()()(),S(21,VBe,17,12,"div",19),S(22,UBe,14,10,"div",20),S(23,WBe,14,10,"div",21),S(24,XBe,8,7,"div",22),S(25,ZBe,9,3,"div",23),S(26,KBe,3,0,"div",24),S(27,nVe,6,3,"div",25),S(28,oVe,3,2,"div",26),S(29,sVe,2,1,"div",27),g()),2&e&&(Mt("display",i.show?"block":"none")("visibility",i.hidden?"hidden":"visible")("top",i.top,"px")("left",i.left,"px")("position",i.position)("height",i.cpHeight,"px")("width",i.cpWidth,"px"),Qe("open",i.show),b(2),_("ngIf","popup"===i.cpDialogDisplay),b(1),_("ngIf",1===(i.cpColorMode||1)),b(4),Mt("background-color",i.selectedColor)("cursor",i.eyeDropperSupported&&i.cpEyeDropper?"pointer":null),b(1),_("ngIf",i.eyeDropperSupported&&i.cpEyeDropper),b(1),_("ngIf",i.cpAddColorButton),b(2),_("ngIf","disabled"===i.cpAlphaChannel),b(1),Mt("display",1===(i.cpColorMode||1)?"block":"none"),_("rgX",1),b(2),Mt("left",null==i.slider?null:i.slider.h,"px"),b(1),Mt("display",2===(i.cpColorMode||1)?"block":"none"),_("rgX",1),b(2),Mt("right",null==i.slider?null:i.slider.v,"px"),b(1),Mt("display","disabled"===i.cpAlphaChannel?"none":"block")("background-color",i.alphaSliderColor),_("rgX",1),b(2),Mt("left",null==i.slider?null:i.slider.a,"px"),b(1),_("ngIf",!i.cpDisableInput&&1===(i.cpColorMode||1)),b(1),_("ngIf",!i.cpDisableInput&&1===(i.cpColorMode||1)),b(1),_("ngIf",!i.cpDisableInput&&1===(i.cpColorMode||1)),b(1),_("ngIf",!i.cpDisableInput&&1===(i.cpColorMode||1)),b(1),_("ngIf",!i.cpDisableInput&&2===(i.cpColorMode||1)),b(1),_("ngIf",!i.cpDisableInput&&1===(i.cpColorMode||1)),b(1),_("ngIf",(null==i.cpPresetColors?null:i.cpPresetColors.length)||i.cpAddColorButton),b(1),_("ngIf",i.cpOKButton||i.cpCancelButton),b(1),_("ngIf",i.cpExtraTemplate))},dependencies:[dn,Fe,Mo,dVe,uVe],styles:['.color-picker{position:absolute;z-index:1000;width:230px;height:auto;border:#777 solid 1px;cursor:default;-webkit-user-select:none;user-select:none;background-color:#fff}.color-picker *{box-sizing:border-box;margin:0;font-size:11px}.color-picker input{width:0;height:26px;min-width:0;font-size:13px;text-align:center;color:#000}.color-picker input:invalid,.color-picker input:-moz-ui-invalid,.color-picker input:-moz-submit-invalid{box-shadow:none}.color-picker input::-webkit-inner-spin-button,.color-picker input::-webkit-outer-spin-button{margin:0;-webkit-appearance:none}.color-picker .arrow{position:absolute;z-index:999999;width:0;height:0;border-style:solid}.color-picker .arrow.arrow-top{left:8px;border-width:10px 5px;border-color:#777 rgba(0,0,0,0) rgba(0,0,0,0) rgba(0,0,0,0)}.color-picker .arrow.arrow-bottom{top:-20px;left:8px;border-width:10px 5px;border-color:rgba(0,0,0,0) rgba(0,0,0,0) #777 rgba(0,0,0,0)}.color-picker .arrow.arrow-top-left,.color-picker .arrow.arrow-left-top{right:-21px;bottom:8px;border-width:5px 10px;border-color:rgba(0,0,0,0) rgba(0,0,0,0) rgba(0,0,0,0) #777}.color-picker .arrow.arrow-top-right,.color-picker .arrow.arrow-right-top{bottom:8px;left:-20px;border-width:5px 10px;border-color:rgba(0,0,0,0) #777 rgba(0,0,0,0) rgba(0,0,0,0)}.color-picker .arrow.arrow-left,.color-picker .arrow.arrow-left-bottom,.color-picker .arrow.arrow-bottom-left{top:8px;right:-21px;border-width:5px 10px;border-color:rgba(0,0,0,0) rgba(0,0,0,0) rgba(0,0,0,0) #777}.color-picker .arrow.arrow-right,.color-picker .arrow.arrow-right-bottom,.color-picker .arrow.arrow-bottom-right{top:8px;left:-20px;border-width:5px 10px;border-color:rgba(0,0,0,0) #777 rgba(0,0,0,0) rgba(0,0,0,0)}.color-picker .cursor{position:relative;width:16px;height:16px;border:#222 solid 2px;border-radius:50%;cursor:default}.color-picker .box{display:flex;padding:4px 8px}.color-picker .left{position:relative;padding:16px 8px}.color-picker .right{flex:1 1 auto;padding:12px 8px}.color-picker .button-area{padding:0 16px 16px;text-align:right}.color-picker .button-area button{margin-left:8px}.color-picker .preset-area{padding:4px 15px}.color-picker .preset-area .preset-label{overflow:hidden;width:100%;padding:4px;font-size:11px;white-space:nowrap;text-align:left;text-overflow:ellipsis;color:#555}.color-picker .preset-area .preset-color{position:relative;display:inline-block;width:18px;height:18px;margin:4px 6px 8px;border:#a9a9a9 solid 1px;border-radius:25%;cursor:pointer}.color-picker .preset-area .preset-empty-message{min-height:18px;margin-top:4px;margin-bottom:8px;font-style:italic;text-align:center}.color-picker .hex-text{width:100%;padding:4px 8px;font-size:11px}.color-picker .hex-text .box{padding:0 24px 8px 8px}.color-picker .hex-text .box div{float:left;flex:1 1 auto;text-align:center;color:#555;clear:left}.color-picker .hex-text .box input{flex:1 1 auto;padding:1px;border:#a9a9a9 solid 1px}.color-picker .hex-alpha .box div:first-child,.color-picker .hex-alpha .box input:first-child{flex-grow:3;margin-right:8px}.color-picker .cmyk-text,.color-picker .hsla-text,.color-picker .rgba-text,.color-picker .value-text{width:100%;padding:4px 8px;font-size:11px}.color-picker .cmyk-text .box,.color-picker .hsla-text .box,.color-picker .rgba-text .box{padding:0 24px 8px 8px}.color-picker .value-text .box{padding:0 8px 8px}.color-picker .cmyk-text .box div,.color-picker .hsla-text .box div,.color-picker .rgba-text .box div,.color-picker .value-text .box div{flex:1 1 auto;margin-right:8px;text-align:center;color:#555}.color-picker .cmyk-text .box div:last-child,.color-picker .hsla-text .box div:last-child,.color-picker .rgba-text .box div:last-child,.color-picker .value-text .box div:last-child{margin-right:0}.color-picker .cmyk-text .box input,.color-picker .hsla-text .box input,.color-picker .rgba-text .box input,.color-picker .value-text .box input{float:left;flex:1;padding:1px;margin:0 8px 0 0;border:#a9a9a9 solid 1px}.color-picker .cmyk-text .box input:last-child,.color-picker .hsla-text .box input:last-child,.color-picker .rgba-text .box input:last-child,.color-picker .value-text .box input:last-child{margin-right:0}.color-picker .hue-alpha{align-items:center;margin-bottom:3px}.color-picker .hue{direction:ltr;width:100%;height:16px;margin-bottom:16px;border:none;cursor:pointer;background-size:100% 100%;background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAJYAAAAQCAYAAAD06IYnAAAABmJLR0QA/wD/AP+gvaeTAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAB3RJTUUH4AIWDwkUFWbCCAAAAFxJREFUaN7t0kEKg0AQAME2x83/n2qu5qCgD1iDhCoYdpnbQC9bbY1qVO/jvc6k3ad91s7/7F1/csgPrujuQ17BDYSFsBAWwgJhISyEBcJCWAgLhIWwEBYIi2f7Ar/1TCgFH2X9AAAAAElFTkSuQmCC)}.color-picker .value{direction:rtl;width:100%;height:16px;margin-bottom:16px;border:none;cursor:pointer;background-size:100% 100%;background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAJYAAAAQCAYAAAD06IYnAAACTklEQVR42u3SYUcrABhA4U2SkmRJMmWSJklKJiWZZpKUJJskKUmaTFImKZOUzMySpGRmliRNJilJSpKSJEtmSpIpmWmSdO736/6D+x7OP3gUCoWCv1cqlSQlJZGcnExKSgqpqamkpaWRnp5ORkYGmZmZqFQqsrKyyM7OJicnh9zcXNRqNXl5eeTn56PRaCgoKKCwsJCioiK0Wi3FxcWUlJRQWlpKWVkZ5eXlVFRUUFlZiU6no6qqiurqampqaqitraWurg69Xk99fT0GgwGj0UhDQwONjY00NTXR3NxMS0sLra2ttLW10d7ejslkwmw209HRQWdnJ11dXXR3d9PT00Nvby99fX309/czMDDA4OAgFouFoaEhrFYrw8PDjIyMMDo6ytjYGDabjfHxcSYmJpicnGRqagq73c709DQzMzPMzs4yNzfH/Pw8DocDp9OJy+XC7XazsLDA4uIiS0tLLC8vs7KywurqKmtra3g8HrxeLz6fD7/fz/r6OhsbG2xubrK1tcX29jaBQICdnR2CwSC7u7vs7e2xv7/PwcEBh4eHHB0dcXx8zMnJCaenp5ydnXF+fs7FxQWXl5dcXV1xfX3Nzc0Nt7e33N3dEQqFuL+/5+HhgXA4TCQS4fHxkaenJ56fn3l5eeH19ZVoNMrb2xvv7+98fHwQi8WIx+N8fn6SSCT4+vri+/ubn58ffn9/+VcKgSWwBJbAElgCS2AJLIElsASWwBJYAktgCSyBJbAElsASWAJLYAksgSWwBJbAElgCS2AJLIElsP4/WH8AmJ5Z6jHS4h8AAAAASUVORK5CYII=)}.color-picker .alpha{direction:ltr;width:100%;height:16px;border:none;cursor:pointer;background-size:100% 100%;background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAJYAAAAQCAYAAAD06IYnAAAABmJLR0QA/wD/AP+gvaeTAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAB3RJTUUH4AIWDwYQlZMa3gAAAWVJREFUaN7tmEGO6jAQRCsOArHgBpyAJYGjcGocxAm4A2IHpmoWE0eBH+ezmFlNvU06shJ3W6VEelWMUQAIIF9f6qZpimsA1LYtS2uF51/u27YVAFZVRUkEoGHdPV/sIcbIEIIkUdI/9Xa7neyv61+SWFUVAVCSct00TWn2fv6u3+Ecfd3tXzy/0+nEUu+SPjo/kqzrmiQpScN6v98XewfA8/lMkiLJ2WxGSUopcT6fM6U0NX9/frfbjev1WtfrlZfLhYfDQQHG/AIOlnGwjINlHCxjHCzjYJm/TJWdCwquJXseFFzGwDNNeiKMOJTO8xQdDQaeB29+K9efeLaBo9J7vdvtJj1RjFFjfiv7qv95tjx/7leSQgh93e1ffMeIp6O+YQjho/N791t1XVOSSI7N//K+4/GoxWLBx+PB5/Op5XLJ+/3OlJJWqxU3m83ovv5iGf8KjYNlHCxjHCzjYBkHy5gf5gusvQU7U37jTAAAAABJRU5ErkJggg==)}.color-picker .type-policy{position:absolute;top:218px;right:12px;width:16px;height:24px;background-size:8px 16px;background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABIAAAAgCAYAAAAffCjxAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAACewAAAnsB01CO3AAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAAAIASURBVEiJ7ZY9axRRFIafsxMStrLQJpAgpBFhi+C9w1YSo00I6RZ/g9vZpBf/QOr4GyRgkSKNSrAadsZqQGwCkuAWyRZJsySwvhZ7N/vhzrgbLH3Ld8597jlzz50zJokyxXH8DqDVar0qi6v8BbItqSGpEcfxdlmsFWXkvX8AfAVWg3UKPEnT9GKujMzsAFgZsVaCN1VTQd77XUnrgE1kv+6935268WRpzrnHZvYRWC7YvC3pRZZl3wozqtVqiyH9IgjAspkd1Gq1xUJQtVrdB9ZKIAOthdg/Qc65LUk7wNIMoCVJO865rYFhkqjX6/d7vV4GPJwBMqofURS5JEk6FYBer/eeYb/Mo9WwFnPOvQbeAvfuAAK4BN4sAJtAG/gJIElmNuiJyba3EGNmZiPeZuEVmVell/Y/6N+CzDn3AXhEOOo7Hv/3BeAz8IzQkMPnJbuPx1wC+yYJ7/0nYIP5S/0FHKdp+rwCEEXRS/rf5Hl1Gtb2M0iSpCOpCZzPATmX1EySpHMLAsiy7MjMDoHrGSDXZnaYZdnRwBh7J91utwmczAA6CbG3GgPleX4jqUH/a1CktqRGnuc3hSCAMB32gKspkCtgb3KCQMmkjeP4WNJThrNNZval1WptTIsv7JtQ4tmIdRa8qSoEpWl6YWZNoAN0zKxZNPehpLSBZv2t+Q0CJ9lLnARQLAAAAABJRU5ErkJggg==);background-repeat:no-repeat;background-position:center}.color-picker .type-policy .type-policy-arrow{display:block;width:100%;height:50%}.color-picker .selected-color{position:absolute;top:16px;left:8px;width:40px;height:40px;border:1px solid #a9a9a9;border-radius:50%}.color-picker .selected-color-background{width:40px;height:40px;border-radius:50%;background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAoCAYAAACM/rhtAAAAh0lEQVRYR+2W0QlAMQgD60zdfwOdqa8TmI/wQMr5K0I5bZLIzLOa2nt37VVVbd+dDx5obgCC3KBLwJ2ff4PnVidkf+ucIhw80HQaCLo3DMH3CRK3iFsmAWVl6hPNDwt8EvNE5q+YuEXcMgkonVM6SdyCoEvAnZ8v1Hjx817MilmxSUB5rdLJDycZgUAZUch/AAAAAElFTkSuQmCC)}.color-picker .saturation-lightness{direction:ltr;width:100%;height:130px;border:none;cursor:pointer;touch-action:manipulation;background-size:100% 100%;background-image:url(data:image/png;base64,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)}.color-picker .cp-add-color-button-class{position:absolute;display:inline;padding:0;margin:3px -3px;border:0;cursor:pointer;background:transparent}.color-picker .cp-add-color-button-class:hover{text-decoration:underline}.color-picker .cp-add-color-button-class:disabled{cursor:not-allowed;color:#999}.color-picker .cp-add-color-button-class:disabled:hover{text-decoration:none}.color-picker .cp-remove-color-button-class{position:absolute;top:-5px;right:-5px;display:block;width:10px;height:10px;border-radius:50%;cursor:pointer;text-align:center;background:#fff;box-shadow:1px 1px 5px #333}.color-picker .cp-remove-color-button-class:before{content:"x";position:relative;bottom:3.5px;display:inline-block;font-size:10px}.color-picker .eyedropper-icon{position:absolute;top:50%;left:50%;transform:translate(-50%,-50%);fill:#fff;mix-blend-mode:exclusion}\n'],encapsulation:2}),n})(),bA=(()=>{class n{constructor(e,i,r,o,a,s){this.injector=e,this.cfr=i,this.appRef=r,this.vcRef=o,this.elRef=a,this._service=s,this.dialogCreated=!1,this.ignoreChanges=!1,this.viewAttachedToAppRef=!1,this.cpWidth="230px",this.cpHeight="auto",this.cpToggle=!1,this.cpDisabled=!1,this.cpIgnoredElements=[],this.cpFallbackColor="",this.cpColorMode="color",this.cpCmykEnabled=!1,this.cpOutputFormat="auto",this.cpAlphaChannel="enabled",this.cpDisableInput=!1,this.cpDialogDisplay="popup",this.cpSaveClickOutside=!0,this.cpCloseClickOutside=!0,this.cpUseRootViewContainer=!1,this.cpPosition="auto",this.cpPositionOffset="0%",this.cpPositionRelativeToArrow=!1,this.cpOKButton=!1,this.cpOKButtonText="OK",this.cpOKButtonClass="cp-ok-button-class",this.cpCancelButton=!1,this.cpCancelButtonText="Cancel",this.cpCancelButtonClass="cp-cancel-button-class",this.cpEyeDropper=!1,this.cpPresetLabel="Preset colors",this.cpPresetColorsClass="cp-preset-colors-class",this.cpMaxPresetColorsLength=6,this.cpPresetEmptyMessage="No colors added",this.cpPresetEmptyMessageClass="preset-empty-message",this.cpAddColorButton=!1,this.cpAddColorButtonText="Add color",this.cpAddColorButtonClass="cp-add-color-button-class",this.cpRemoveColorButtonClass="cp-remove-color-button-class",this.cpInputChange=new L(!0),this.cpToggleChange=new L(!0),this.cpSliderChange=new L(!0),this.cpSliderDragEnd=new L(!0),this.cpSliderDragStart=new L(!0),this.colorPickerOpen=new L(!0),this.colorPickerClose=new L(!0),this.colorPickerCancel=new L(!0),this.colorPickerSelect=new L(!0),this.colorPickerChange=new L(!1),this.cpCmykColorChange=new L(!0),this.cpPresetColorsChange=new L(!0)}handleClick(){this.inputFocus()}handleFocus(){this.inputFocus()}handleInput(e){this.inputChange(e)}ngOnDestroy(){null!=this.cmpRef&&(this.viewAttachedToAppRef&&this.appRef.detachView(this.cmpRef.hostView),this.cmpRef.destroy(),this.cmpRef=null,this.dialog=null)}ngOnChanges(e){e.cpToggle&&!this.cpDisabled&&(e.cpToggle.currentValue?this.openDialog():e.cpToggle.currentValue||this.closeDialog()),e.colorPicker&&(this.dialog&&!this.ignoreChanges&&("inline"===this.cpDialogDisplay&&this.dialog.setInitialColor(e.colorPicker.currentValue),this.dialog.setColorFromString(e.colorPicker.currentValue,!1),this.cpUseRootViewContainer&&"inline"!==this.cpDialogDisplay&&this.cmpRef.changeDetectorRef.detectChanges()),this.ignoreChanges=!1),(e.cpPresetLabel||e.cpPresetColors)&&this.dialog&&this.dialog.setPresetConfig(this.cpPresetLabel,this.cpPresetColors)}openDialog(){if(this.dialogCreated)this.dialog&&this.dialog.openDialog(this.colorPicker);else{let e=this.vcRef;if(this.dialogCreated=!0,this.viewAttachedToAppRef=!1,this.cpUseRootViewContainer&&"inline"!==this.cpDialogDisplay){let o=this.injector.get(this.appRef.componentTypes[0],bi.NULL);o!==bi.NULL?e=o.vcRef||o.viewContainerRef||this.vcRef:this.viewAttachedToAppRef=!0}let i=this.cfr.resolveComponentFactory(pVe);if(this.viewAttachedToAppRef)this.cmpRef=i.create(this.injector),this.appRef.attachView(this.cmpRef.hostView),document.body.appendChild(this.cmpRef.hostView.rootNodes[0]);else{let r=bi.create({providers:[],parent:e.injector});this.cmpRef=e.createComponent(i,0,r,[])}this.cmpRef.instance.setupDialog(this,this.elRef,this.colorPicker,this.cpWidth,this.cpHeight,this.cpDialogDisplay,this.cpFallbackColor,this.cpColorMode,this.cpCmykEnabled,this.cpAlphaChannel,this.cpOutputFormat,this.cpDisableInput,this.cpIgnoredElements,this.cpSaveClickOutside,this.cpCloseClickOutside,this.cpUseRootViewContainer,this.cpPosition,this.cpPositionOffset,this.cpPositionRelativeToArrow,this.cpPresetLabel,this.cpPresetColors,this.cpPresetColorsClass,this.cpMaxPresetColorsLength,this.cpPresetEmptyMessage,this.cpPresetEmptyMessageClass,this.cpOKButton,this.cpOKButtonClass,this.cpOKButtonText,this.cpCancelButton,this.cpCancelButtonClass,this.cpCancelButtonText,this.cpAddColorButton,this.cpAddColorButtonClass,this.cpAddColorButtonText,this.cpRemoveColorButtonClass,this.cpEyeDropper,this.elRef,this.cpExtraTemplate),this.dialog=this.cmpRef.instance,this.vcRef!==e&&this.cmpRef.changeDetectorRef.detectChanges()}}closeDialog(){this.dialog&&"popup"===this.cpDialogDisplay&&this.dialog.closeDialog()}cmykChanged(e){this.cpCmykColorChange.emit(e)}stateChanged(e){this.cpToggleChange.emit(e),e?this.colorPickerOpen.emit(this.colorPicker):this.colorPickerClose.emit(this.colorPicker)}colorChanged(e,i=!0){this.ignoreChanges=i,this.colorPickerChange.emit(e)}colorSelected(e){this.colorPickerSelect.emit(e)}colorCanceled(){this.colorPickerCancel.emit()}inputFocus(){let e=this.elRef.nativeElement,i=this.cpIgnoredElements.filter(r=>r===e);!this.cpDisabled&&!i.length&&(typeof document<"u"&&e===document.activeElement?this.openDialog():this.dialog&&this.dialog.show?this.closeDialog():this.openDialog())}inputChange(e){this.dialog?this.dialog.setColorFromString(e.target.value,!0):(this.colorPicker=e.target.value,this.colorPickerChange.emit(this.colorPicker))}inputChanged(e){this.cpInputChange.emit(e)}sliderChanged(e){this.cpSliderChange.emit(e)}sliderDragEnd(e){this.cpSliderDragEnd.emit(e)}sliderDragStart(e){this.cpSliderDragStart.emit(e)}presetColorsChanged(e){this.cpPresetColorsChange.emit(e)}}return n.\u0275fac=function(e){return new(e||n)(C(bi),C(Qr),C(gc),C(Zn),C(be),C(JV))},n.\u0275dir=xe({type:n,selectors:[["","colorPicker",""]],hostBindings:function(e,i){1&e&&D("click",function(){return i.handleClick()})("focus",function(){return i.handleFocus()})("input",function(o){return i.handleInput(o)})},inputs:{colorPicker:"colorPicker",cpWidth:"cpWidth",cpHeight:"cpHeight",cpToggle:"cpToggle",cpDisabled:"cpDisabled",cpIgnoredElements:"cpIgnoredElements",cpFallbackColor:"cpFallbackColor",cpColorMode:"cpColorMode",cpCmykEnabled:"cpCmykEnabled",cpOutputFormat:"cpOutputFormat",cpAlphaChannel:"cpAlphaChannel",cpDisableInput:"cpDisableInput",cpDialogDisplay:"cpDialogDisplay",cpSaveClickOutside:"cpSaveClickOutside",cpCloseClickOutside:"cpCloseClickOutside",cpUseRootViewContainer:"cpUseRootViewContainer",cpPosition:"cpPosition",cpPositionOffset:"cpPositionOffset",cpPositionRelativeToArrow:"cpPositionRelativeToArrow",cpOKButton:"cpOKButton",cpOKButtonText:"cpOKButtonText",cpOKButtonClass:"cpOKButtonClass",cpCancelButton:"cpCancelButton",cpCancelButtonText:"cpCancelButtonText",cpCancelButtonClass:"cpCancelButtonClass",cpEyeDropper:"cpEyeDropper",cpPresetLabel:"cpPresetLabel",cpPresetColors:"cpPresetColors",cpPresetColorsClass:"cpPresetColorsClass",cpMaxPresetColorsLength:"cpMaxPresetColorsLength",cpPresetEmptyMessage:"cpPresetEmptyMessage",cpPresetEmptyMessageClass:"cpPresetEmptyMessageClass",cpAddColorButton:"cpAddColorButton",cpAddColorButtonText:"cpAddColorButtonText",cpAddColorButtonClass:"cpAddColorButtonClass",cpRemoveColorButtonClass:"cpRemoveColorButtonClass",cpExtraTemplate:"cpExtraTemplate"},outputs:{cpInputChange:"cpInputChange",cpToggleChange:"cpToggleChange",cpSliderChange:"cpSliderChange",cpSliderDragEnd:"cpSliderDragEnd",cpSliderDragStart:"cpSliderDragStart",colorPickerOpen:"colorPickerOpen",colorPickerClose:"colorPickerClose",colorPickerCancel:"colorPickerCancel",colorPickerSelect:"colorPickerSelect",colorPickerChange:"colorPickerChange",cpCmykColorChange:"cpCmykColorChange",cpPresetColorsChange:"cpPresetColorsChange"},exportAs:["ngxColorPicker"],features:[Gt]}),n})(),One=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({providers:[JV],imports:[Te]}),n})(),mVe=["regexStringInput"];function hVe(n,t){if(1&n&&(Tt(0),h(1,"li",22),T(2),g(),Dt()),2&n){let e=t.$implicit;b(1),_("title",e.name),b(1),ut(e.name)}}function gVe(n,t){if(1&n&&(h(0,"li",23)(1,"em"),T(2),G(3,"number"),g()()),2&n){let e=w().$implicit;b(2),ze("and ",W(3,1,e.runs.length-5)," more")}}function _Ve(n,t){1&n&&(h(0,"li",24)(1,"em"),T(2,"No runs are in the group"),g()())}var yVe=function(n){return{borderColor:n}},bVe=function(n){return{backgroundColor:n}};function vVe(n,t){if(1&n&&(h(0,"ul",16)(1,"li")(2,"label"),P(3,"span",17),h(4,"code",18),T(5),g()(),h(6,"ul"),S(7,hVe,3,2,"ng-container",19),G(8,"slice"),S(9,gVe,4,3,"li",20),S(10,_Ve,3,0,"li",21),g()()()),2&n){let e=t.$implicit;_("ngStyle",Sn(11,yVe,e.color)),b(3),_("ngStyle",Sn(13,bVe,e.color)),b(1),_("title",e.groupId),b(1),ut(e.groupId),b(2),_("ngForOf",BP(8,7,e.runs,0,5)),b(2),_("ngIf",e.runs.length>5),b(1),_("ngIf",0===e.runs.length)}}function xVe(n,t){if(1&n&&(h(0,"div",14),S(1,vVe,11,15,"ul",15),g()),2&n){let e=w(2);b(1),_("ngForOf",e.colorRunPairList)}}function CVe(n,t){if(1&n&&(h(0,"div",25),T(1," There are no runs matching the regex, "),h(2,"code"),T(3),g(),T(4,". Please check if your regex string is correct. "),g()),2&n){let e=w(2);b(3),ze("/",e.regexString,"/")}}function MVe(n,t){if(1&n&&(h(0,"div",10)(1,"h4"),T(2,"Color group preview"),g(),h(3,"div",11),S(4,xVe,2,1,"div",12),S(5,CVe,5,1,"ng-template",null,13,Zt),g()()),2&n){let e=tt(6),i=w();b(4),_("ngIf",i.colorRunPairList.length)("ngIfElse",e)}}var Lne=(()=>{class n{constructor(e,i){this.dialogRef=e,this.hostElRef=i,this.onSave=new L,this.regexInputOnChange=new L,this.timeOutId=0}resetFocus(){this.hostElRef.nativeElement.contains(document.activeElement)||this.regexStringInput.nativeElement.focus()}onEnter(e){this.onSaveClick(e),this.dialogRef.close()}onSaveClick(e){this.onSave.emit(e)}fillExample(e){this.regexString=e,this.regexInputChange(e)}regexInputChange(e){this.regexInputOnChange.emit(e)}handleFocusOut(){clearTimeout(this.timeOutId),this.timeOutId=setTimeout(this.resetFocus.bind(this),0)}}return n.\u0275fac=function(e){return new(e||n)(C(Sd),C(be))},n.\u0275cmp=k({type:n,selectors:[["regex-edit-dialog-component"]],viewQuery:function(e,i){if(1&e&&Ye(mVe,7),2&e){let r;we(r=Se())&&(i.regexStringInput=r.first)}},inputs:{regexString:"regexString",colorRunPairList:"colorRunPairList"},outputs:{onSave:"onSave",regexInputOnChange:"regexInputOnChange"},decls:30,vars:2,consts:function(){let t;return t=$localize`:Color Runs by Regex Query␟15ed9f6fd2d4906a4803fc1255de3c5db2c56530␟9088985113960312808:Color Runs by Regex Query`,[[1,"regex-edit-dialog",3,"focusout"],["mat-dialog-title",""],["matInput","","aria-label",t,"cdkFocusInitial","",3,"value","keydown.enter","input"],["regexStringInput",""],[1,"example-details"],[3,"click"],["class","group-container",4,"ngIf"],["mat-dialog-actions","","align","end"],["mat-button","","mat-dialog-close",""],["mat-raised-button","","color","primary","mat-dialog-close","",3,"click"],[1,"group-container"],[1,"grouping-preview"],["class","match-container",4,"ngIf","ngIfElse"],["empty",""],[1,"match-container"],["class","group",3,"ngStyle",4,"ngFor","ngForOf"],[1,"group",3,"ngStyle"],[1,"color-swatch",3,"ngStyle"],[1,"group-id",3,"title"],[4,"ngFor","ngForOf"],["class","more",4,"ngIf"],["class","no-match",4,"ngIf"],[3,"title"],[1,"more"],[1,"no-match"],[1,"warning"]]},template:function(e,i){if(1&e){let r=ge();h(0,"div",0),D("focusout",function(){return i.handleFocusOut()}),h(1,"h1",1),T(2,"Color runs by regex"),g(),h(3,"mat-dialog-content")(4,"p"),T(5,"Enter a regex with capturing groups to match against run names:"),g(),h(6,"mat-form-field")(7,"input",2,3),D("keydown.enter",function(a){return i.onEnter(a.target.value)})("input",function(a){return i.regexInputChange(a.target.value)}),g()()(),h(9,"div",4)(10,"p"),T(11,' Each matching run will be assigned a color based on the "key" formed by its matches to the capturing groups. '),P(12,"br"),h(13,"button",5),D("click",function(){return i.fillExample("(train|eval)")}),T(14," Try "),h(15,"code"),T(16,"(train|eval)"),g()(),T(17," to assign all runs containing "),h(18,"code"),T(19,"train"),g(),T(20," to one color and all runs containing "),h(21,"code"),T(22,"eval"),g(),T(23," to another color. "),g()(),S(24,MVe,7,2,"div",6),h(25,"div",7)(26,"button",8),T(27,"Cancel"),g(),h(28,"button",9),D("click",function(){X(r);let a=tt(8);return Q(i.onSaveClick(a.value))}),T(29," Save "),g()()()}2&e&&(b(7),Ji("value",i.regexString),b(17),_("ngIf",i.regexString))},dependencies:[dn,Fe,mu,Ys,Fn,J1,v9,$1,eE,qu,_G,Ps],styles:[".example-details[_ngcontent-%COMP%]   button[_ngcontent-%COMP%]{background-color:rgba(0,0,0,0);padding:0;border:none;cursor:pointer;text-decoration:underline;color:#1976d2}body.dark-mode[_nghost-%COMP%]   .example-details[_ngcontent-%COMP%]   button[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .example-details[_ngcontent-%COMP%]   button[_ngcontent-%COMP%]{color:#42a5f5}.example-details[_ngcontent-%COMP%]   button[_ngcontent-%COMP%]:visited{color:#7b1fa2}body.dark-mode[_nghost-%COMP%]   .example-details[_ngcontent-%COMP%]   button[_ngcontent-%COMP%]:visited, body.dark-mode   [_nghost-%COMP%]   .example-details[_ngcontent-%COMP%]   button[_ngcontent-%COMP%]:visited{color:#ba68c8}.group-container[_ngcontent-%COMP%]{margin:10px 0}.group-container[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%]{margin-bottom:10px}.group-container[_ngcontent-%COMP%]   .warning[_ngcontent-%COMP%]{color:#616161;font-size:.9em}body.dark-mode[_nghost-%COMP%]   .group-container[_ngcontent-%COMP%]   .warning[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .group-container[_ngcontent-%COMP%]   .warning[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}.grouping-preview[_ngcontent-%COMP%]{border:1px solid #ebebeb;max-height:50vh;overflow-y:auto;padding:20px}body.dark-mode[_nghost-%COMP%]   .grouping-preview[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .grouping-preview[_ngcontent-%COMP%]{border:1px solid #555}.match-container[_ngcontent-%COMP%]{align-items:flex-start;display:grid;flex-wrap:wrap;gap:10px;grid-template-columns:repeat(2, minmax(50%, 1fr))}.color-swatch[_ngcontent-%COMP%]{border-radius:50%;box-shadow:0 0 2px #000;display:inline-block;height:15px;width:15px}ul[_ngcontent-%COMP%]{list-style-type:none;padding:0}mat-form-field[_ngcontent-%COMP%]{width:100%}.group[_ngcontent-%COMP%]{border:1px solid #ebebeb;border-radius:3px;margin:0;padding:10px}body.dark-mode[_nghost-%COMP%]   .group[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .group[_ngcontent-%COMP%]{border:1px solid #555}.group[_ngcontent-%COMP%]   label[_ngcontent-%COMP%]{border-bottom:1px solid #ebebeb;align-items:center;display:grid;gap:10px;grid-template-columns:max-content auto;padding:5px 0}body.dark-mode[_nghost-%COMP%]   .group[_ngcontent-%COMP%]   label[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .group[_ngcontent-%COMP%]   label[_ngcontent-%COMP%]{border-bottom:1px solid #555}.group[_ngcontent-%COMP%]   label[_ngcontent-%COMP%]   .group-id[_ngcontent-%COMP%]{font-size:.95em;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.group[_ngcontent-%COMP%]   ul[_ngcontent-%COMP%]{font-size:.9em}.group[_ngcontent-%COMP%]   ul[_ngcontent-%COMP%]   li[_ngcontent-%COMP%]{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.group[_ngcontent-%COMP%]   .more[_ngcontent-%COMP%], .group[_ngcontent-%COMP%]   .no-match[_ngcontent-%COMP%]{color:#616161;margin-top:5px}body.dark-mode[_nghost-%COMP%]   .group[_ngcontent-%COMP%]   .more[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .group[_ngcontent-%COMP%]   .more[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}body.dark-mode[_nghost-%COMP%]   .group[_ngcontent-%COMP%]   .no-match[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .group[_ngcontent-%COMP%]   .no-match[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}"],changeDetection:0}),n})(),Nne=(()=>{class n{constructor(e,i,r){this.store=e,this.dialogRef=i,this.tentativeRegexString$=new Ae,this.groupByRegexString$=Ka(()=>cn(this.store.select(x1).pipe(zt(1)),this.tentativeRegexString$)).pipe(Nn("")),this.colorRunPairList$=Ka(()=>this.groupByRegexString$.pipe(Cr(500),Ve(o=>{try{let a=new RegExp(o);return Boolean(a)}catch{return!1}}),Vi(this.allRuns$,this.runIdToEid$,this.store.select(Ba.getColorPalette),this.store.select(El)),U(([o,a,s,l,c])=>{let u=Ab({key:Qi.REGEX,regexString:o},a,s),p=new Map,f=[];for(let[m,y]of Object.entries(u.matches)){let M=p.get(m);if(!M){let v=l.colors[p.size%l.colors.length];M=c?v.darkHex:v.lightHex,p.set(m,M)}f.push({groupId:m,color:M,runs:y})}return f}))).pipe(Nn([])),this.experimentIds=r.experimentIds,this.runIdToEid$=un(this.experimentIds.map(o=>this.store.select(r7,{experimentId:o}).pipe(U(a=>({experimentId:o,runIds:a}))))).pipe(U(o=>{let a={};for(let{runIds:s,experimentId:l}of o)for(let c of s)a[c]=l;return a})),this.allRuns$=un(this.experimentIds.map(o=>this.store.select(Ec,{experimentId:o}))).pipe(U(o=>o.flat()))}onRegexInputOnChange(e){this.tentativeRegexString$.next(e)}onSave(e){this.store.dispatch(Jh({experimentIds:this.experimentIds,groupBy:{key:Qi.REGEX,regexString:e}}))}}return n.\u0275fac=function(e){return new(e||n)(C(ke),C(Sd),C(Kb))},n.\u0275cmp=k({type:n,selectors:[["regex-edit-dialog"]],decls:3,vars:6,consts:[[3,"regexString","colorRunPairList","onSave","regexInputOnChange"]],template:function(e,i){1&e&&(h(0,"regex-edit-dialog-component",0),D("onSave",function(o){return i.onSave(o)})("regexInputOnChange",function(o){return i.onRegexInputOnChange(o)}),G(1,"async"),G(2,"async"),g()),2&e&&_("regexString",W(1,2,i.groupByRegexString$))("colorRunPairList",W(2,4,i.colorRunPairList$))},dependencies:[Lne,lt],styles:["[_nghost-%COMP%], regex-edit-dialog-component[_ngcontent-%COMP%] {\n        display: block;\n        height: 100%;\n        width: 100%;\n      }"]}),n})();function EVe(n,t){1&n&&P(0,"mat-icon",14)}function TVe(n,t){if(1&n){let e=ge();h(0,"button",13),D("click",function(){X(e);let r=w();return Q(r.onGroupByChange.emit({key:r.GroupByKey.EXPERIMENT}))}),h(1,"span"),S(2,EVe,1,0,"mat-icon",7),g(),h(3,"label"),T(4,"Experiment"),g()()}if(2&n){let e=w();Pe("aria-checked",e.selectedGroupBy.key===e.GroupByKey.EXPERIMENT),b(2),_("ngIf",e.selectedGroupBy.key===e.GroupByKey.EXPERIMENT)}}function DVe(n,t){1&n&&P(0,"mat-icon",14)}function IVe(n,t){1&n&&P(0,"mat-icon",14)}function AVe(n,t){if(1&n&&(h(0,"label"),T(1),g()),2&n){let e=w();b(1),ut(e.regexString)}}function RVe(n,t){1&n&&(h(0,"label",15),T(1,"(none set)"),g())}var Bne=(()=>{class n{constructor(e){this.dialog=e,this.GroupByKey=Qi,this.onGroupByChange=new L}onRegexStringEdit(){this.dialog.open(Nne,{maxHeight:"95vh",maxWidth:"80vw",data:{experimentIds:this.experimentIds}})}onGroupByRegexClick(){this.regexString?this.onGroupByChange.emit({key:Qi.REGEX,regexString:this.regexString}):this.onRegexStringEdit()}}return n.\u0275fac=function(e){return new(e||n)(C(Ll))},n.\u0275cmp=k({type:n,selectors:[["runs-group-menu-button-component"]],inputs:{showExperimentsGroupBy:"showExperimentsGroupBy",experimentIds:"experimentIds",regexString:"regexString",selectedGroupBy:"selectedGroupBy"},outputs:{onGroupByChange:"onGroupByChange"},decls:22,vars:8,consts:[["mat-icon-button","","title","Color runs by...",3,"matMenuTriggerFor"],["svgIcon","palette_24px"],[1,"run-table-color-group-by"],["groupByMenu","matMenu"],[1,"label"],["mat-menu-item","","role","menuitemradio","data-value","experiment",3,"click",4,"ngIf"],["mat-menu-item","","role","menuitemradio","data-value","run",3,"click"],["svgIcon","done_24px",4,"ngIf"],["mat-menu-item","","role","menuitemradio","data-value","regex",3,"click"],["mat-menu-item","","role","menuitem","data-value","regex-edit",1,"display-regex-string",3,"click"],["svgIcon","edit_24px"],[4,"ngIf"],["class","none-set-string",4,"ngIf"],["mat-menu-item","","role","menuitemradio","data-value","experiment",3,"click"],["svgIcon","done_24px"],[1,"none-set-string"]],template:function(e,i){1&e&&(h(0,"button",0),P(1,"mat-icon",1),g(),h(2,"mat-menu",2,3)(4,"div",4),T(5,"Color runs by"),g(),S(6,TVe,5,2,"button",5),h(7,"button",6),D("click",function(){return i.onGroupByChange.emit({key:i.GroupByKey.RUN})}),h(8,"span"),S(9,DVe,1,0,"mat-icon",7),g(),h(10,"label"),T(11,"Run"),g()(),h(12,"button",8),D("click",function(){return i.onGroupByRegexClick()}),h(13,"span"),S(14,IVe,1,0,"mat-icon",7),g(),h(15,"label"),T(16,"Regex"),g()(),h(17,"button",9),D("click",function(){return i.onRegexStringEdit()}),h(18,"span"),P(19,"mat-icon",10),g(),S(20,AVe,2,1,"label",11),S(21,RVe,2,0,"label",12),g()()),2&e&&(_("matMenuTriggerFor",tt(3)),b(6),_("ngIf",i.showExperimentsGroupBy),b(1),Pe("aria-checked",i.selectedGroupBy.key===i.GroupByKey.RUN),b(2),_("ngIf",i.selectedGroupBy.key===i.GroupByKey.RUN),b(3),Pe("aria-checked",i.selectedGroupBy.key===i.GroupByKey.REGEX),b(2),_("ngIf",i.selectedGroupBy.key===i.GroupByKey.REGEX),b(6),_("ngIf",i.regexString),b(1),_("ngIf",!i.regexString))},dependencies:[Fe,Fn,Dn,kc,Yu,Pc],styles:[".run-table-color-group-by{font-size:16px}  .run-table-color-group-by .label{color:#616161;font-size:.9em;margin:10px 0;padding:0 16px;pointer-events:none}  .run-table-color-group-by button{display:grid;gap:2px 10px;grid-template-columns:20px auto}  .run-table-color-group-by mat-icon{height:20px;width:20px}  .run-table-color-group-by .display-regex-string{padding-left:40px}  .run-table-color-group-by .display-regex-string .none-set-string{color:#616161}body.dark-mode[_nghost-%COMP%]     .run-table-color-group-by .display-regex-string .none-set-string, body.dark-mode   [_nghost-%COMP%]     .run-table-color-group-by .display-regex-string .none-set-string{color:rgba(255,255,255,.7)}"],changeDetection:0}),n})(),vA=(()=>{class n{constructor(e){this.store=e,this.showExperimentsGroupBy$=this.store.select(y6).pipe(U(i=>i.has(kn.COMPARE_EXPERIMENT))),this.selectedGroupBy$=this.store.select(a7),this.groupByRegexString$=this.store.select(x1)}onGroupByChange(e){this.store.dispatch(Jh({experimentIds:this.experimentIds,groupBy:e}))}}return n.\u0275fac=function(e){return new(e||n)(C(ke))},n.\u0275cmp=k({type:n,selectors:[["runs-group-menu-button"]],inputs:{experimentIds:"experimentIds"},decls:4,vars:10,consts:[[3,"regexString","selectedGroupBy","showExperimentsGroupBy","experimentIds","onGroupByChange"]],template:function(e,i){1&e&&(h(0,"runs-group-menu-button-component",0),D("onGroupByChange",function(o){return i.onGroupByChange(o)}),G(1,"async"),G(2,"async"),G(3,"async"),g()),2&e&&_("regexString",W(1,4,i.groupByRegexString$))("selectedGroupBy",W(2,6,i.selectedGroupBy$))("showExperimentsGroupBy",W(3,8,i.showExperimentsGroupBy$))("experimentIds",i.experimentIds)},dependencies:[Bne,lt],encapsulation:2,changeDetection:0}),n})();function PVe(n,t){1&n&&(h(0,"div",7),P(1,"mat-spinner",8),g())}function OVe(n,t){if(1&n){let e=ge();h(0,"div")(1,"mat-checkbox",18),D("click",function(r){return X(e),Q(w(4).handleSelectAll(r))}),g()()}if(2&n){let e=w(4);b(1),_("checked",e.allRowsSelected())("indeterminate",!e.allRowsSelected()&&e.someRowsSelected())}}function FVe(n,t){if(1&n&&(h(0,"span",19),P(1,"runs-group-menu-button",20),g()),2&n){let e=w(4);b(1),_("experimentIds",e.experimentIds)}}function LVe(n,t){if(1&n&&(h(0,"tb-data-table-header-cell",14),Tt(1,15),S(2,OVe,2,2,"div",16),S(3,FVe,2,1,"span",17),Dt(),g()),2&n){let e=w().$implicit,i=w(2);_("header",e)("sortingInfo",i.sortingInfo)("hparamsEnabled",!0),b(1),_("ngSwitch",e.name),b(1),_("ngSwitchCase","selected"),b(1),_("ngSwitchCase","color")}}function NVe(n,t){if(1&n&&(Tt(0),S(1,LVe,4,6,"tb-data-table-header-cell",13),Dt()),2&n){let e=t.$implicit;b(1),_("ngIf",e.enabled)}}function BVe(n,t){if(1&n){let e=ge();h(0,"span",24)(1,"button",25),D("colorPickerChange",function(r){X(e);let o=w(3).$implicit;return Q(w(2).onRunColorChange.emit({runId:o.id,newColor:r}))}),g()()}if(2&n){let e=w(3).$implicit;b(1),Mt("background",e.color),_("colorPicker",e.color)("cpDialogDisplay","popup")("cpPositionOffset",-20)("cpUseRootViewContainer",!0)("cpOutputFormat","hex")}}function VVe(n,t){if(1&n){let e=ge();h(0,"div")(1,"mat-checkbox",26),D("click",function(r){X(e);let o=w(3).$implicit;return Q(w(2).selectionClick(r,o.id))}),g()()}if(2&n){let e=w(3).$implicit;b(1),_("checked",e.selected)}}function HVe(n,t){if(1&n&&(h(0,"span"),P(1,"tb-experiment-alias",27),g()),2&n){let e=w(3).$implicit;b(1),_("alias",e.experimentAlias)}}function zVe(n,t){if(1&n&&(h(0,"tb-data-table-content-cell",22),Tt(1,15),S(2,BVe,2,7,"span",23),S(3,VVe,2,1,"div",16),S(4,HVe,2,1,"span",16),Dt(),g()),2&n){let e=w().$implicit,i=w().$implicit;_("header",e)("datum",i[e.name]),b(1),_("ngSwitch",e.name),b(1),_("ngSwitchCase","color"),b(1),_("ngSwitchCase","selected"),b(1),_("ngSwitchCase","experimentAlias")}}function UVe(n,t){if(1&n&&(Tt(0),S(1,zVe,5,6,"tb-data-table-content-cell",21),Dt()),2&n){let e=t.$implicit;b(1),_("ngIf",e.enabled)}}function jVe(n,t){if(1&n&&(Tt(0),h(1,"tb-data-table-content-row"),S(2,UVe,2,1,"ng-container",11),g(),Dt()),2&n){let e=w(2);b(2),_("ngForOf",e.getHeaders())}}function GVe(n,t){if(1&n){let e=ge();h(0,"tb-data-table",9),D("sortDataBy",function(r){return X(e),Q(w().sortDataBy.emit(r))})("orderColumns",function(r){return X(e),Q(w().orderColumns.emit(r))})("addColumn",function(r){return X(e),Q(w().addColumn.emit(r))})("removeColumn",function(r){return X(e),Q(w().removeColumn.emit(r))}),Tt(1,10),S(2,NVe,2,1,"ng-container",11),Dt(),Tt(3,12),S(4,jVe,3,1,"ng-container",11),Dt(),g()}if(2&n){let e=w();_("headers",e.headers)("sortingInfo",e.sortingInfo)("columnCustomizationEnabled",!0)("selectableColumns",e.selectableColumns),b(2),_("ngForOf",e.getHeaders()),b(2),_("ngForOf",e.data)}}var WVe=function(n){return{"full-screen":n}},Hne=(()=>{class n{constructor(){this.ColumnHeaderType=vt,this.sortDataBy=new L,this.orderColumns=new L,this.onSelectionToggle=new L,this.onAllSelectionToggle=new L,this.onRegexFilterChange=new L,this.toggleFullScreen=new L,this.onRunColorChange=new L,this.addColumn=new L,this.removeColumn=new L,this.onSelectionDblClick=new L,this.beforeColumns=[{name:"selected",displayName:"",type:vt.CUSTOM,enabled:!0}],this.afterColumns=[{name:"color",displayName:"",type:vt.COLOR,enabled:!0}]}getHeaders(){return[].concat(this.beforeColumns,this.headers,this.afterColumns)}selectionClick(e,i){e.preventDefault(),1===e.detail&&this.onSelectionToggle.emit(i),2===e.detail&&this.onSelectionDblClick.emit(i)}allRowsSelected(){return this.data.every(e=>e.selected)}someRowsSelected(){return this.data.some(e=>e.selected)}handleSelectAll(e){e.preventDefault(),this.onAllSelectionToggle.emit(this.data.map(i=>i.id))}onFilterKeyUp(e){this.onRegexFilterChange.emit(e.target.value)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["runs-data-table"]],inputs:{headers:"headers",data:"data",sortingInfo:"sortingInfo",experimentIds:"experimentIds",regexFilter:"regexFilter",isFullScreen:"isFullScreen",selectableColumns:"selectableColumns",loading:"loading"},outputs:{sortDataBy:"sortDataBy",orderColumns:"orderColumns",onSelectionToggle:"onSelectionToggle",onAllSelectionToggle:"onAllSelectionToggle",onRegexFilterChange:"onRegexFilterChange",toggleFullScreen:"toggleFullScreen",onRunColorChange:"onRunColorChange",addColumn:"addColumn",removeColumn:"removeColumn",onSelectionDblClick:"onSelectionDblClick"},decls:7,vars:8,consts:[[1,"filter-row"],["placeholder","Filter runs (regex)",1,"run-filter",3,"value","keyup"],["class","loading",4,"ngIf"],[3,"headers","sortingInfo","columnCustomizationEnabled","selectableColumns","sortDataBy","orderColumns","addColumn","removeColumn",4,"ngIf"],[1,"full-screen-toggle",3,"ngClass"],["mat-button","",1,"full-screen-btn",3,"ngClass","click"],[1,"expand-collapse-icon",3,"svgIcon"],[1,"loading"],["mode","indeterminate","diameter","28"],[3,"headers","sortingInfo","columnCustomizationEnabled","selectableColumns","sortDataBy","orderColumns","addColumn","removeColumn"],["header",""],[4,"ngFor","ngForOf"],["content",""],[3,"header","sortingInfo","hparamsEnabled",4,"ngIf"],[3,"header","sortingInfo","hparamsEnabled"],[3,"ngSwitch"],[4,"ngSwitchCase"],["class","group-menu-container",4,"ngSwitchCase"],[3,"checked","indeterminate","click"],[1,"group-menu-container"],[3,"experimentIds"],[3,"header","datum",4,"ngIf"],[3,"header","datum"],["class","color-container",4,"ngSwitchCase"],[1,"color-container"],[1,"run-color-swatch",3,"colorPicker","cpDialogDisplay","cpPositionOffset","cpUseRootViewContainer","cpOutputFormat","colorPickerChange"],[3,"checked","click"],[3,"alias"]],template:function(e,i){1&e&&(h(0,"div",0)(1,"tb-filter-input",1),D("keyup",function(o){return i.onFilterKeyUp(o)}),g()(),S(2,PVe,2,0,"div",2),S(3,GVe,5,6,"tb-data-table",3),h(4,"div",4)(5,"button",5),D("click",function(){return i.toggleFullScreen.emit()}),P(6,"mat-icon",6),g()()),2&e&&(b(1),Ji("value",i.regexFilter),b(1),_("ngIf",i.loading),b(1),_("ngIf",!i.loading),b(1),_("ngClass",Sn(6,WVe,i.isFullScreen)),b(1),_("ngClass",i.isFullScreen?"collapse":"expand"),b(1),_("svgIcon",i.isFullScreen?"arrow_back_24px":"arrow_forward_24px"))},dependencies:[bA,bn,dn,Fe,$i,sr,M_,uA,fA,w_,tp,E_,Fn,Hl,Dn,zr,vA],styles:["[_nghost-%COMP%]{width:100%}[_nghost-%COMP%]{overflow-y:scroll;width:100%}.color-container[_ngcontent-%COMP%]{display:flex;justify-content:center;width:100%}.run-color-swatch[_ngcontent-%COMP%]{border-radius:100%;border:1px solid #ebebeb;height:20px;width:20px;outline:none}.group-menu-container[_ngcontent-%COMP%]{display:flex;justify-content:center;width:100%}tb-data-table-content-row[_ngcontent-%COMP%], tb-data-table-header-cell[_ngcontent-%COMP%]{height:44px}tb-data-table-content-cell[_ngcontent-%COMP%], tb-data-table-header-cell[_ngcontent-%COMP%]{vertical-align:middle;border-bottom:1px solid #ebebeb}body.dark-mode[_nghost-%COMP%]   tb-data-table-content-cell[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   tb-data-table-content-cell[_ngcontent-%COMP%]{border-bottom:1px solid #555}body.dark-mode[_nghost-%COMP%]   tb-data-table-header-cell[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   tb-data-table-header-cell[_ngcontent-%COMP%]{border-bottom:1px solid #555}tb-data-table-content-cell[_ngcontent-%COMP%]:first-child, tb-data-table-header-cell[_ngcontent-%COMP%]:first-child{padding-left:16px}tb-data-table-content-cell[_ngcontent-%COMP%]:last-child, tb-data-table-header-cell[_ngcontent-%COMP%]:last-child{border-right:1px solid #ebebeb}body.dark-mode[_nghost-%COMP%]   tb-data-table-content-cell[_ngcontent-%COMP%]:last-child, body.dark-mode   [_nghost-%COMP%]   tb-data-table-content-cell[_ngcontent-%COMP%]:last-child{border-right:1px solid #555}body.dark-mode[_nghost-%COMP%]   tb-data-table-header-cell[_ngcontent-%COMP%]:last-child, body.dark-mode   [_nghost-%COMP%]   tb-data-table-header-cell[_ngcontent-%COMP%]:last-child{border-right:1px solid #555}tb-data-table-header-cell[_ngcontent-%COMP%]:last-of-type{border-right:1px solid #ebebeb}body.dark-mode[_nghost-%COMP%]   tb-data-table-header-cell[_ngcontent-%COMP%]:last-of-type, body.dark-mode   [_nghost-%COMP%]   tb-data-table-header-cell[_ngcontent-%COMP%]:last-of-type{border-right:1px solid #555}.full-screen-toggle[_ngcontent-%COMP%]{opacity:0;position:absolute;height:100%;left:calc(100% + 2px);top:0;z-index:1;display:flex;align-items:center}.full-screen-toggle[_ngcontent-%COMP%]:hover{opacity:.8}.full-screen-toggle.full-screen[_ngcontent-%COMP%]{left:unset;right:0}.full-screen-toggle[_ngcontent-%COMP%]   .full-screen-btn[_ngcontent-%COMP%]{background-color:gray;padding:0;min-width:16px;width:16px}.full-screen-toggle[_ngcontent-%COMP%]   .full-screen-btn.expand[_ngcontent-%COMP%]{border-radius:0 16px 16px 0}.full-screen-toggle[_ngcontent-%COMP%]   .full-screen-btn.collapse[_ngcontent-%COMP%]{border-radius:16px 0 0 16px}.full-screen-toggle[_ngcontent-%COMP%]   .full-screen-btn[_ngcontent-%COMP%]   .expand-collapse-icon[_ngcontent-%COMP%]{font-size:16px;width:16px}.filter-row[_ngcontent-%COMP%]{border-bottom:1px solid #ebebeb;display:flex;align-items:center;height:48px;padding:0 16px}body.dark-mode[_nghost-%COMP%]   .filter-row[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .filter-row[_ngcontent-%COMP%]{border-bottom:1px solid #555}.filter-row[_ngcontent-%COMP%]   tb-filter-input[_ngcontent-%COMP%]{flex-grow:1}.loading[_ngcontent-%COMP%]{align-items:center;border:0;border-bottom:1px solid #ebebeb;display:flex;height:48px;padding:0 24px;justify-content:center}body.dark-mode[_nghost-%COMP%]   .loading[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .loading[_ngcontent-%COMP%]{border-bottom:1px solid #555}"],changeDetection:0}),n})(),$V=new ie("mat-tooltip-scroll-strategy"),jne={provide:$V,deps:[Oi],useFactory:function(n){return()=>n.scrollStrategies.reposition({scrollThrottle:20})}},Gne=new ie("mat-tooltip-default-options",{providedIn:"root",factory:function(){return{showDelay:0,hideDelay:0,touchendHideDelay:1500}}}),zne="tooltip-panel",Une=Yo({passive:!0}),Wne=(()=>{class n{get position(){return this._position}set position(e){e!==this._position&&(this._position=e,this._overlayRef&&(this._updatePosition(this._overlayRef),this._tooltipInstance?.show(0),this._overlayRef.updatePosition()))}get positionAtOrigin(){return this._positionAtOrigin}set positionAtOrigin(e){this._positionAtOrigin=Ut(e),this._detach(),this._overlayRef=null}get disabled(){return this._disabled}set disabled(e){this._disabled=Ut(e),this._disabled?this.hide(0):this._setupPointerEnterEventsIfNeeded()}get showDelay(){return this._showDelay}set showDelay(e){this._showDelay=Di(e)}get hideDelay(){return this._hideDelay}set hideDelay(e){this._hideDelay=Di(e),this._tooltipInstance&&(this._tooltipInstance._mouseLeaveHideDelay=this._hideDelay)}get message(){return this._message}set message(e){this._ariaDescriber.removeDescription(this._elementRef.nativeElement,this._message,"tooltip"),this._message=null!=e?String(e).trim():"",!this._message&&this._isTooltipVisible()?this.hide(0):(this._setupPointerEnterEventsIfNeeded(),this._updateTooltipMessage(),this._ngZone.runOutsideAngular(()=>{Promise.resolve().then(()=>{this._ariaDescriber.describe(this._elementRef.nativeElement,this.message,"tooltip")})}))}get tooltipClass(){return this._tooltipClass}set tooltipClass(e){this._tooltipClass=e,this._tooltipInstance&&this._setTooltipClass(this._tooltipClass)}constructor(e,i,r,o,a,s,l,c,d,u,p,f){this._overlay=e,this._elementRef=i,this._scrollDispatcher=r,this._viewContainerRef=o,this._ngZone=a,this._platform=s,this._ariaDescriber=l,this._focusMonitor=c,this._dir=u,this._defaultOptions=p,this._position="below",this._positionAtOrigin=!1,this._disabled=!1,this._viewInitialized=!1,this._pointerExitEventsInitialized=!1,this._viewportMargin=8,this._cssClassPrefix="mat",this._showDelay=this._defaultOptions.showDelay,this._hideDelay=this._defaultOptions.hideDelay,this.touchGestures="auto",this._message="",this._passiveListeners=[],this._destroyed=new Ae,this._scrollStrategy=d,this._document=f,p&&(p.position&&(this.position=p.position),p.positionAtOrigin&&(this.positionAtOrigin=p.positionAtOrigin),p.touchGestures&&(this.touchGestures=p.touchGestures)),u.change.pipe(ot(this._destroyed)).subscribe(()=>{this._overlayRef&&this._updatePosition(this._overlayRef)})}ngAfterViewInit(){this._viewInitialized=!0,this._setupPointerEnterEventsIfNeeded(),this._focusMonitor.monitor(this._elementRef).pipe(ot(this._destroyed)).subscribe(e=>{e?"keyboard"===e&&this._ngZone.run(()=>this.show()):this._ngZone.run(()=>this.hide(0))})}ngOnDestroy(){let e=this._elementRef.nativeElement;clearTimeout(this._touchstartTimeout),this._overlayRef&&(this._overlayRef.dispose(),this._tooltipInstance=null),this._passiveListeners.forEach(([i,r])=>{e.removeEventListener(i,r,Une)}),this._passiveListeners.length=0,this._destroyed.next(),this._destroyed.complete(),this._ariaDescriber.removeDescription(e,this.message,"tooltip"),this._focusMonitor.stopMonitoring(e)}show(e=this.showDelay,i){if(this.disabled||!this.message||this._isTooltipVisible())return void this._tooltipInstance?._cancelPendingAnimations();let r=this._createOverlay(i);this._detach(),this._portal=this._portal||new Pl(this._tooltipComponent,this._viewContainerRef);let o=this._tooltipInstance=r.attach(this._portal).instance;o._triggerElement=this._elementRef.nativeElement,o._mouseLeaveHideDelay=this._hideDelay,o.afterHidden().pipe(ot(this._destroyed)).subscribe(()=>this._detach()),this._setTooltipClass(this._tooltipClass),this._updateTooltipMessage(),o.show(e)}hide(e=this.hideDelay){let i=this._tooltipInstance;i&&(i.isVisible()?i.hide(e):(i._cancelPendingAnimations(),this._detach()))}toggle(e){this._isTooltipVisible()?this.hide():this.show(void 0,e)}_isTooltipVisible(){return!!this._tooltipInstance&&this._tooltipInstance.isVisible()}_createOverlay(e){if(this._overlayRef){let o=this._overlayRef.getConfig().positionStrategy;if((!this.positionAtOrigin||!e)&&o._origin instanceof be)return this._overlayRef;this._detach()}let i=this._scrollDispatcher.getAncestorScrollContainers(this._elementRef),r=this._overlay.position().flexibleConnectedTo(this.positionAtOrigin&&e||this._elementRef).withTransformOriginOn(`.${this._cssClassPrefix}-tooltip`).withFlexibleDimensions(!1).withViewportMargin(this._viewportMargin).withScrollableContainers(i);return r.positionChanges.pipe(ot(this._destroyed)).subscribe(o=>{this._updateCurrentPositionClass(o.connectionPair),this._tooltipInstance&&o.scrollableViewProperties.isOverlayClipped&&this._tooltipInstance.isVisible()&&this._ngZone.run(()=>this.hide(0))}),this._overlayRef=this._overlay.create({direction:this._dir,positionStrategy:r,panelClass:`${this._cssClassPrefix}-${zne}`,scrollStrategy:this._scrollStrategy()}),this._updatePosition(this._overlayRef),this._overlayRef.detachments().pipe(ot(this._destroyed)).subscribe(()=>this._detach()),this._overlayRef.outsidePointerEvents().pipe(ot(this._destroyed)).subscribe(()=>this._tooltipInstance?._handleBodyInteraction()),this._overlayRef.keydownEvents().pipe(ot(this._destroyed)).subscribe(o=>{this._isTooltipVisible()&&27===o.keyCode&&!yr(o)&&(o.preventDefault(),o.stopPropagation(),this._ngZone.run(()=>this.hide(0)))}),this._defaultOptions?.disableTooltipInteractivity&&this._overlayRef.addPanelClass(`${this._cssClassPrefix}-tooltip-panel-non-interactive`),this._overlayRef}_detach(){this._overlayRef&&this._overlayRef.hasAttached()&&this._overlayRef.detach(),this._tooltipInstance=null}_updatePosition(e){let i=e.getConfig().positionStrategy,r=this._getOrigin(),o=this._getOverlayPosition();i.withPositions([this._addOffset({...r.main,...o.main}),this._addOffset({...r.fallback,...o.fallback})])}_addOffset(e){return e}_getOrigin(){let r,e=!this._dir||"ltr"==this._dir.value,i=this.position;"above"==i||"below"==i?r={originX:"center",originY:"above"==i?"top":"bottom"}:"before"==i||"left"==i&&e||"right"==i&&!e?r={originX:"start",originY:"center"}:("after"==i||"right"==i&&e||"left"==i&&!e)&&(r={originX:"end",originY:"center"});let{x:o,y:a}=this._invertPosition(r.originX,r.originY);return{main:r,fallback:{originX:o,originY:a}}}_getOverlayPosition(){let r,e=!this._dir||"ltr"==this._dir.value,i=this.position;"above"==i?r={overlayX:"center",overlayY:"bottom"}:"below"==i?r={overlayX:"center",overlayY:"top"}:"before"==i||"left"==i&&e||"right"==i&&!e?r={overlayX:"end",overlayY:"center"}:("after"==i||"right"==i&&e||"left"==i&&!e)&&(r={overlayX:"start",overlayY:"center"});let{x:o,y:a}=this._invertPosition(r.overlayX,r.overlayY);return{main:r,fallback:{overlayX:o,overlayY:a}}}_updateTooltipMessage(){this._tooltipInstance&&(this._tooltipInstance.message=this.message,this._tooltipInstance._markForCheck(),this._ngZone.onMicrotaskEmpty.pipe(zt(1),ot(this._destroyed)).subscribe(()=>{this._tooltipInstance&&this._overlayRef.updatePosition()}))}_setTooltipClass(e){this._tooltipInstance&&(this._tooltipInstance.tooltipClass=e,this._tooltipInstance._markForCheck())}_invertPosition(e,i){return"above"===this.position||"below"===this.position?"top"===i?i="bottom":"bottom"===i&&(i="top"):"end"===e?e="start":"start"===e&&(e="end"),{x:e,y:i}}_updateCurrentPositionClass(e){let a,{overlayY:i,originX:r,originY:o}=e;if(a="center"===i?this._dir&&"rtl"===this._dir.value?"end"===r?"left":"right":"start"===r?"left":"right":"bottom"===i&&"top"===o?"above":"below",a!==this._currentPosition){let s=this._overlayRef;if(s){let l=`${this._cssClassPrefix}-${zne}-`;s.removePanelClass(l+this._currentPosition),s.addPanelClass(l+a)}this._currentPosition=a}}_setupPointerEnterEventsIfNeeded(){this._disabled||!this.message||!this._viewInitialized||this._passiveListeners.length||(this._platformSupportsMouseEvents()?this._passiveListeners.push(["mouseenter",e=>{let i;this._setupPointerExitEventsIfNeeded(),void 0!==e.x&&void 0!==e.y&&(i=e),this.show(void 0,i)}]):"off"!==this.touchGestures&&(this._disableNativeGesturesIfNecessary(),this._passiveListeners.push(["touchstart",e=>{let i=e.targetTouches?.[0],r=i?{x:i.clientX,y:i.clientY}:void 0;this._setupPointerExitEventsIfNeeded(),clearTimeout(this._touchstartTimeout),this._touchstartTimeout=setTimeout(()=>this.show(void 0,r),500)}])),this._addListeners(this._passiveListeners))}_setupPointerExitEventsIfNeeded(){if(this._pointerExitEventsInitialized)return;this._pointerExitEventsInitialized=!0;let e=[];if(this._platformSupportsMouseEvents())e.push(["mouseleave",i=>{let r=i.relatedTarget;(!r||!this._overlayRef?.overlayElement.contains(r))&&this.hide()}],["wheel",i=>this._wheelListener(i)]);else if("off"!==this.touchGestures){this._disableNativeGesturesIfNecessary();let i=()=>{clearTimeout(this._touchstartTimeout),this.hide(this._defaultOptions.touchendHideDelay)};e.push(["touchend",i],["touchcancel",i])}this._addListeners(e),this._passiveListeners.push(...e)}_addListeners(e){e.forEach(([i,r])=>{this._elementRef.nativeElement.addEventListener(i,r,Une)})}_platformSupportsMouseEvents(){return!this._platform.IOS&&!this._platform.ANDROID}_wheelListener(e){if(this._isTooltipVisible()){let i=this._document.elementFromPoint(e.clientX,e.clientY),r=this._elementRef.nativeElement;i!==r&&!r.contains(i)&&this.hide()}}_disableNativeGesturesIfNecessary(){let e=this.touchGestures;if("off"!==e){let i=this._elementRef.nativeElement,r=i.style;("on"===e||"INPUT"!==i.nodeName&&"TEXTAREA"!==i.nodeName)&&(r.userSelect=r.msUserSelect=r.webkitUserSelect=r.MozUserSelect="none"),("on"===e||!i.draggable)&&(r.webkitUserDrag="none"),r.touchAction="none",r.webkitTapHighlightColor="transparent"}}}return n.\u0275fac=function(e){_l()},n.\u0275dir=xe({type:n,inputs:{position:["matTooltipPosition","position"],positionAtOrigin:["matTooltipPositionAtOrigin","positionAtOrigin"],disabled:["matTooltipDisabled","disabled"],showDelay:["matTooltipShowDelay","showDelay"],hideDelay:["matTooltipHideDelay","hideDelay"],touchGestures:["matTooltipTouchGestures","touchGestures"],message:["matTooltip","message"],tooltipClass:["matTooltipClass","tooltipClass"]}}),n})(),qne=(()=>{class n{constructor(e,i){this._changeDetectorRef=e,this._closeOnInteraction=!1,this._isVisible=!1,this._onHide=new Ae,this._animationsDisabled="NoopAnimations"===i}show(e){clearTimeout(this._hideTimeoutId),this._showTimeoutId=setTimeout(()=>{this._toggleVisibility(!0),this._showTimeoutId=void 0},e)}hide(e){clearTimeout(this._showTimeoutId),this._hideTimeoutId=setTimeout(()=>{this._toggleVisibility(!1),this._hideTimeoutId=void 0},e)}afterHidden(){return this._onHide}isVisible(){return this._isVisible}ngOnDestroy(){this._cancelPendingAnimations(),this._onHide.complete(),this._triggerElement=null}_handleBodyInteraction(){this._closeOnInteraction&&this.hide(0)}_markForCheck(){this._changeDetectorRef.markForCheck()}_handleMouseLeave({relatedTarget:e}){(!e||!this._triggerElement.contains(e))&&(this.isVisible()?this.hide(this._mouseLeaveHideDelay):this._finalizeAnimation(!1))}_onShow(){}_handleAnimationEnd({animationName:e}){(e===this._showAnimation||e===this._hideAnimation)&&this._finalizeAnimation(e===this._showAnimation)}_cancelPendingAnimations(){clearTimeout(this._showTimeoutId),clearTimeout(this._hideTimeoutId),this._showTimeoutId=this._hideTimeoutId=void 0}_finalizeAnimation(e){e?this._closeOnInteraction=!0:this.isVisible()||this._onHide.next()}_toggleVisibility(e){let i=this._tooltip.nativeElement,r=this._showAnimation,o=this._hideAnimation;if(i.classList.remove(e?o:r),i.classList.add(e?r:o),this._isVisible=e,e&&!this._animationsDisabled&&"function"==typeof getComputedStyle){let a=getComputedStyle(i);("0s"===a.getPropertyValue("animation-duration")||"none"===a.getPropertyValue("animation-name"))&&(this._animationsDisabled=!0)}e&&this._onShow(),this._animationsDisabled&&(i.classList.add("_mat-animation-noopable"),this._finalizeAnimation(e))}}return n.\u0275fac=function(e){return new(e||n)(C(Ft),C(di,8))},n.\u0275dir=xe({type:n}),n})(),KVe=(ji("state",[Jn("initial, void, hidden",Bt({opacity:0,transform:"scale(0.8)"})),Jn("visible",Bt({transform:"scale(1)"})),Wn("* => visible",Kn("150ms cubic-bezier(0, 0, 0.2, 1)")),Wn("* => hidden",Kn("75ms cubic-bezier(0.4, 0, 1, 1)"))]),["tooltip"]),Yne=(()=>{class n extends Wne{constructor(e,i,r,o,a,s,l,c,d,u,p,f){super(e,i,r,o,a,s,l,c,d,u,p,f),this._tooltipComponent=JVe}}return n.\u0275fac=function(e){return new(e||n)(C(Oi),C(be),C(Rf),C(Zn),C(at),C($n),C(H1),C(lr),C($V),C(Hi,8),C(Gne,8),C(kt))},n.\u0275dir=xe({type:n,selectors:[["","matTooltip",""]],hostAttrs:[1,"mat-tooltip-trigger"],exportAs:["matTooltip"],features:[Le]}),n})(),JVe=(()=>{class n extends qne{constructor(e,i,r){super(e,r),this._breakpointObserver=i,this._isHandset=this._breakpointObserver.observe("(max-width: 599.98px) and (orientation: portrait), (max-width: 959.98px) and (orientation: landscape)"),this._showAnimation="mat-tooltip-show",this._hideAnimation="mat-tooltip-hide"}}return n.\u0275fac=function(e){return new(e||n)(C(Ft),C(Ou),C(di,8))},n.\u0275cmp=k({type:n,selectors:[["mat-tooltip-component"]],viewQuery:function(e,i){if(1&e&&Ye(KVe,7),2&e){let r;we(r=Se())&&(i._tooltip=r.first)}},hostAttrs:["aria-hidden","true"],hostVars:2,hostBindings:function(e,i){1&e&&D("mouseleave",function(o){return i._handleMouseLeave(o)}),2&e&&Mt("zoom",i.isVisible()?1:null)},features:[Le],decls:4,vars:6,consts:[[1,"mat-tooltip",3,"ngClass","animationend"],["tooltip",""]],template:function(e,i){if(1&e&&(h(0,"div",0,1),D("animationend",function(o){return i._handleAnimationEnd(o)}),G(2,"async"),T(3),g()),2&e){let r;Qe("mat-tooltip-handset",null==(r=W(2,4,i._isHandset))?null:r.matches),_("ngClass",i.tooltipClass),b(3),ut(i.message)}},dependencies:[bn,lt],styles:[".mat-tooltip{color:#fff;border-radius:4px;margin:14px;max-width:250px;padding-left:8px;padding-right:8px;overflow:hidden;text-overflow:ellipsis;transform:scale(0)}.mat-tooltip._mat-animation-noopable{animation:none;transform:scale(1)}.cdk-high-contrast-active .mat-tooltip{outline:solid 1px}.mat-tooltip-handset{margin:24px;padding-left:16px;padding-right:16px}.mat-tooltip-panel-non-interactive{pointer-events:none}@keyframes mat-tooltip-show{0%{opacity:0;transform:scale(0)}50%{opacity:.5;transform:scale(0.99)}100%{opacity:1;transform:scale(1)}}@keyframes mat-tooltip-hide{0%{opacity:1;transform:scale(1)}100%{opacity:0;transform:scale(1)}}.mat-tooltip-show{animation:mat-tooltip-show 200ms cubic-bezier(0, 0, 0.2, 1) forwards}.mat-tooltip-hide{animation:mat-tooltip-hide 100ms cubic-bezier(0, 0, 0.2, 1) forwards}"],encapsulation:2,changeDetection:0}),n})(),Xne=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({providers:[jne],imports:[Df,Te,Lr,Qt,Qt,Rc]}),n})(),Xd=(ji("state",[Jn("initial, void, hidden",Bt({opacity:0,transform:"scale(0)"})),Jn("visible",Bt({transform:"scale(1)"})),Wn("* => visible",Kn("200ms cubic-bezier(0, 0, 0.2, 1)",rf([Bt({opacity:0,transform:"scale(0)",offset:0}),Bt({opacity:.5,transform:"scale(0.99)",offset:.5}),Bt({opacity:1,transform:"scale(1)",offset:1})]))),Wn("* => hidden",Kn("100ms cubic-bezier(0, 0, 0.2, 1)",Bt({opacity:0})))]),(()=>{class n{constructor(){this.changes=new Ae,this.itemsPerPageLabel="Items per page:",this.nextPageLabel="Next page",this.previousPageLabel="Previous page",this.firstPageLabel="First page",this.lastPageLabel="Last page",this.getRangeLabel=(e,i,r)=>{if(0==r||0==i)return`0 of ${r}`;let o=e*i;return`${o+1} \u2013 ${o<(r=Math.max(r,0))?Math.min(o+i,r):o+i} of ${r}`}}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=pe({token:n,factory:n.\u0275fac,providedIn:"root"}),n})()),e4={provide:Xd,deps:[[new Aa,new id,Xd]],useFactory:function(n){return n||new Xd}},t4e=(new ie("MAT_PAGINATOR_DEFAULT_OPTIONS"),Kr(jb(class{}))),t4=(()=>{class n extends t4e{get pageIndex(){return this._pageIndex}set pageIndex(e){this._pageIndex=Math.max(Di(e),0),this._changeDetectorRef.markForCheck()}get length(){return this._length}set length(e){this._length=Di(e),this._changeDetectorRef.markForCheck()}get pageSize(){return this._pageSize}set pageSize(e){this._pageSize=Math.max(Di(e),0),this._updateDisplayedPageSizeOptions()}get pageSizeOptions(){return this._pageSizeOptions}set pageSizeOptions(e){this._pageSizeOptions=(e||[]).map(i=>Di(i)),this._updateDisplayedPageSizeOptions()}get hidePageSize(){return this._hidePageSize}set hidePageSize(e){this._hidePageSize=Ut(e)}get showFirstLastButtons(){return this._showFirstLastButtons}set showFirstLastButtons(e){this._showFirstLastButtons=Ut(e)}constructor(e,i,r){if(super(),this._intl=e,this._changeDetectorRef=i,this._pageIndex=0,this._length=0,this._pageSizeOptions=[],this._hidePageSize=!1,this._showFirstLastButtons=!1,this.selectConfig={},this.page=new L,this._intlChanges=e.changes.subscribe(()=>this._changeDetectorRef.markForCheck()),r){let{pageSize:o,pageSizeOptions:a,hidePageSize:s,showFirstLastButtons:l}=r;null!=o&&(this._pageSize=o),null!=a&&(this._pageSizeOptions=a),null!=s&&(this._hidePageSize=s),null!=l&&(this._showFirstLastButtons=l)}}ngOnInit(){this._initialized=!0,this._updateDisplayedPageSizeOptions(),this._markInitialized()}ngOnDestroy(){this._intlChanges.unsubscribe()}nextPage(){if(!this.hasNextPage())return;let e=this.pageIndex;this.pageIndex=this.pageIndex+1,this._emitPageEvent(e)}previousPage(){if(!this.hasPreviousPage())return;let e=this.pageIndex;this.pageIndex=this.pageIndex-1,this._emitPageEvent(e)}firstPage(){if(!this.hasPreviousPage())return;let e=this.pageIndex;this.pageIndex=0,this._emitPageEvent(e)}lastPage(){if(!this.hasNextPage())return;let e=this.pageIndex;this.pageIndex=this.getNumberOfPages()-1,this._emitPageEvent(e)}hasPreviousPage(){return this.pageIndex>=1&&0!=this.pageSize}hasNextPage(){let e=this.getNumberOfPages()-1;return this.pageIndex<e&&0!=this.pageSize}getNumberOfPages(){return this.pageSize?Math.ceil(this.length/this.pageSize):0}_changePageSize(e){let r=this.pageIndex;this.pageIndex=Math.floor(this.pageIndex*this.pageSize/e)||0,this.pageSize=e,this._emitPageEvent(r)}_nextButtonsDisabled(){return this.disabled||!this.hasNextPage()}_previousButtonsDisabled(){return this.disabled||!this.hasPreviousPage()}_updateDisplayedPageSizeOptions(){!this._initialized||(this.pageSize||(this._pageSize=0!=this.pageSizeOptions.length?this.pageSizeOptions[0]:50),this._displayedPageSizeOptions=this.pageSizeOptions.slice(),-1===this._displayedPageSizeOptions.indexOf(this.pageSize)&&this._displayedPageSizeOptions.push(this.pageSize),this._displayedPageSizeOptions.sort((e,i)=>e-i),this._changeDetectorRef.markForCheck())}_emitPageEvent(e){this.page.emit({previousPageIndex:e,pageIndex:this.pageIndex,pageSize:this.pageSize,length:this.length})}}return n.\u0275fac=function(e){_l()},n.\u0275dir=xe({type:n,inputs:{color:"color",pageIndex:"pageIndex",length:"length",pageSize:"pageSize",pageSizeOptions:"pageSizeOptions",hidePageSize:"hidePageSize",showFirstLastButtons:"showFirstLastButtons",selectConfig:"selectConfig"},outputs:{page:"page"},features:[Le]}),n})();function i4e(n,t){if(1&n&&(h(0,"mat-option",19),T(1),g()),2&n){let e=t.$implicit;_("value",e),b(1),ze(" ",e," ")}}function r4e(n,t){if(1&n){let e=ge();h(0,"mat-form-field",16)(1,"mat-select",17),D("selectionChange",function(r){return X(e),Q(w(2)._changePageSize(r.value))}),S(2,i4e,2,2,"mat-option",18),g()()}if(2&n){let e=w(2);_("appearance",e._formFieldAppearance)("color",e.color),b(1),_("value",e.pageSize)("disabled",e.disabled)("panelClass",e.selectConfig.panelClass||"")("disableOptionCentering",e.selectConfig.disableOptionCentering)("aria-label",e._intl.itemsPerPageLabel),b(1),_("ngForOf",e._displayedPageSizeOptions)}}function o4e(n,t){if(1&n&&(h(0,"div",20),T(1),g()),2&n){let e=w(2);b(1),ut(e.pageSize)}}function a4e(n,t){if(1&n&&(h(0,"div",12)(1,"div",13),T(2),g(),S(3,r4e,3,8,"mat-form-field",14),S(4,o4e,2,1,"div",15),g()),2&n){let e=w();b(2),ze(" ",e._intl.itemsPerPageLabel," "),b(1),_("ngIf",e._displayedPageSizeOptions.length>1),b(1),_("ngIf",e._displayedPageSizeOptions.length<=1)}}function s4e(n,t){if(1&n){let e=ge();h(0,"button",21),D("click",function(){return X(e),Q(w().firstPage())}),Tn(),h(1,"svg",7),P(2,"path",22),g()()}if(2&n){let e=w();_("matTooltip",e._intl.firstPageLabel)("matTooltipDisabled",e._previousButtonsDisabled())("matTooltipPosition","above")("disabled",e._previousButtonsDisabled()),Pe("aria-label",e._intl.firstPageLabel)}}function l4e(n,t){if(1&n){let e=ge();Tn(),Oo(),h(0,"button",23),D("click",function(){return X(e),Q(w().lastPage())}),Tn(),h(1,"svg",7),P(2,"path",24),g()()}if(2&n){let e=w();_("matTooltip",e._intl.lastPageLabel)("matTooltipDisabled",e._nextButtonsDisabled())("matTooltipPosition","above")("disabled",e._nextButtonsDisabled()),Pe("aria-label",e._intl.lastPageLabel)}}var c4e=new ie("MAT_LEGACY_PAGINATOR_DEFAULT_OPTIONS"),xA=(()=>{class n extends t4{constructor(e,i,r){super(e,i,r),r&&null!=r.formFieldAppearance&&(this._formFieldAppearance=r.formFieldAppearance)}}return n.\u0275fac=function(e){return new(e||n)(C(Xd),C(Ft),C(c4e,8))},n.\u0275cmp=k({type:n,selectors:[["mat-paginator"]],hostAttrs:["role","group",1,"mat-paginator"],inputs:{disabled:"disabled"},exportAs:["matPaginator"],features:[Le],decls:14,vars:14,consts:[[1,"mat-paginator-outer-container"],[1,"mat-paginator-container"],["class","mat-paginator-page-size",4,"ngIf"],[1,"mat-paginator-range-actions"],[1,"mat-paginator-range-label"],["mat-icon-button","","type","button","class","mat-paginator-navigation-first",3,"matTooltip","matTooltipDisabled","matTooltipPosition","disabled","click",4,"ngIf"],["mat-icon-button","","type","button",1,"mat-paginator-navigation-previous",3,"matTooltip","matTooltipDisabled","matTooltipPosition","disabled","click"],["viewBox","0 0 24 24","focusable","false",1,"mat-paginator-icon"],["d","M15.41 7.41L14 6l-6 6 6 6 1.41-1.41L10.83 12z"],["mat-icon-button","","type","button",1,"mat-paginator-navigation-next",3,"matTooltip","matTooltipDisabled","matTooltipPosition","disabled","click"],["d","M10 6L8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z"],["mat-icon-button","","type","button","class","mat-paginator-navigation-last",3,"matTooltip","matTooltipDisabled","matTooltipPosition","disabled","click",4,"ngIf"],[1,"mat-paginator-page-size"],[1,"mat-paginator-page-size-label"],["class","mat-paginator-page-size-select",3,"appearance","color",4,"ngIf"],["class","mat-paginator-page-size-value",4,"ngIf"],[1,"mat-paginator-page-size-select",3,"appearance","color"],[3,"value","disabled","panelClass","disableOptionCentering","aria-label","selectionChange"],[3,"value",4,"ngFor","ngForOf"],[3,"value"],[1,"mat-paginator-page-size-value"],["mat-icon-button","","type","button",1,"mat-paginator-navigation-first",3,"matTooltip","matTooltipDisabled","matTooltipPosition","disabled","click"],["d","M18.41 16.59L13.82 12l4.59-4.59L17 6l-6 6 6 6zM6 6h2v12H6z"],["mat-icon-button","","type","button",1,"mat-paginator-navigation-last",3,"matTooltip","matTooltipDisabled","matTooltipPosition","disabled","click"],["d","M5.59 7.41L10.18 12l-4.59 4.59L7 18l6-6-6-6zM16 6h2v12h-2z"]],template:function(e,i){1&e&&(h(0,"div",0)(1,"div",1),S(2,a4e,5,3,"div",2),h(3,"div",3)(4,"div",4),T(5),g(),S(6,s4e,3,5,"button",5),h(7,"button",6),D("click",function(){return i.previousPage()}),Tn(),h(8,"svg",7),P(9,"path",8),g()(),Oo(),h(10,"button",9),D("click",function(){return i.nextPage()}),Tn(),h(11,"svg",7),P(12,"path",10),g()(),S(13,l4e,3,5,"button",11),g()()()),2&e&&(b(2),_("ngIf",!i.hidePageSize),b(3),ze(" ",i._intl.getRangeLabel(i.pageIndex,i.pageSize,i.length)," "),b(1),_("ngIf",i.showFirstLastButtons),b(1),_("matTooltip",i._intl.previousPageLabel)("matTooltipDisabled",i._previousButtonsDisabled())("matTooltipPosition","above")("disabled",i._previousButtonsDisabled()),Pe("aria-label",i._intl.previousPageLabel),b(3),_("matTooltip",i._intl.nextPageLabel)("matTooltipDisabled",i._nextButtonsDisabled())("matTooltipPosition","above")("disabled",i._nextButtonsDisabled()),Pe("aria-label",i._intl.nextPageLabel),b(3),_("ngIf",i.showFirstLastButtons))},dependencies:[dn,Fe,Fn,Ys,Gu,Ha,Yne],styles:[".mat-paginator{display:block}.mat-paginator-outer-container{display:flex}.mat-paginator-container{display:flex;align-items:center;justify-content:flex-end;padding:0 8px;flex-wrap:wrap-reverse;width:100%}.mat-paginator-page-size{display:flex;align-items:baseline;margin-right:8px}[dir=rtl] .mat-paginator-page-size{margin-right:0;margin-left:8px}.mat-paginator-page-size-label{margin:0 4px}.mat-paginator-page-size-select{margin:6px 4px 0 4px;width:56px}.mat-paginator-page-size-select.mat-form-field-appearance-outline{width:64px}.mat-paginator-page-size-select.mat-form-field-appearance-fill{width:64px}.mat-paginator-range-label{margin:0 32px 0 24px}.mat-paginator-range-actions{display:flex;align-items:center}.mat-paginator-icon{display:inline-block;width:28px;fill:currentColor}[dir=rtl] .mat-paginator-icon{transform:rotate(180deg)}.cdk-high-contrast-active .mat-paginator-icon{fill:CanvasText}"],encapsulation:2,changeDetection:0}),n})(),Zne=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({providers:[e4],imports:[Te,fi,Xs,Xne,Qt]}),n})(),u4e=["mat-sort-header",""];function p4e(n,t){if(1&n){let e=ge();h(0,"div",3),D("@arrowPosition.start",function(){return X(e),Q(w()._disableViewStateAnimation=!0)})("@arrowPosition.done",function(){return X(e),Q(w()._disableViewStateAnimation=!1)}),P(1,"div",4),h(2,"div",5),P(3,"div",6)(4,"div",7)(5,"div",8),g()()}if(2&n){let e=w();_("@arrowOpacity",e._getArrowViewState())("@arrowPosition",e._getArrowViewState())("@allowChildren",e._getArrowDirectionState()),b(2),_("@indicator",e._getArrowDirectionState()),b(1),_("@leftPointer",e._getArrowDirectionState()),b(1),_("@rightPointer",e._getArrowDirectionState())}}var f4e=["*"],Kne=new ie("MAT_SORT_DEFAULT_OPTIONS"),m4e=jb(Kr(class{})),rC=(()=>{class n extends m4e{get direction(){return this._direction}set direction(e){this._direction=e}get disableClear(){return this._disableClear}set disableClear(e){this._disableClear=Ut(e)}constructor(e){super(),this._defaultOptions=e,this.sortables=new Map,this._stateChanges=new Ae,this.start="asc",this._direction="",this.sortChange=new L}register(e){this.sortables.set(e.id,e)}deregister(e){this.sortables.delete(e.id)}sort(e){this.active!=e.id?(this.active=e.id,this.direction=e.start?e.start:this.start):this.direction=this.getNextSortDirection(e),this.sortChange.emit({active:this.active,direction:this.direction})}getNextSortDirection(e){if(!e)return"";let r=function(n,t){let e=["asc","desc"];return"desc"==n&&e.reverse(),t||e.push(""),e}(e.start||this.start,e?.disableClear??this.disableClear??!!this._defaultOptions?.disableClear),o=r.indexOf(this.direction)+1;return o>=r.length&&(o=0),r[o]}ngOnInit(){this._markInitialized()}ngOnChanges(){this._stateChanges.next()}ngOnDestroy(){this._stateChanges.complete()}}return n.\u0275fac=function(e){return new(e||n)(C(Kne,8))},n.\u0275dir=xe({type:n,selectors:[["","matSort",""]],hostAttrs:[1,"mat-sort"],inputs:{disabled:["matSortDisabled","disabled"],active:["matSortActive","active"],start:["matSortStart","start"],direction:["matSortDirection","direction"],disableClear:["matSortDisableClear","disableClear"]},outputs:{sortChange:"matSortChange"},exportAs:["matSort"],features:[Le,Gt]}),n})(),Rp=E2.ENTERING+" "+S2.STANDARD_CURVE,D_={indicator:ji("indicator",[Jn("active-asc, asc",Bt({transform:"translateY(0px)"})),Jn("active-desc, desc",Bt({transform:"translateY(10px)"})),Wn("active-asc <=> active-desc",Kn(Rp))]),leftPointer:ji("leftPointer",[Jn("active-asc, asc",Bt({transform:"rotate(-45deg)"})),Jn("active-desc, desc",Bt({transform:"rotate(45deg)"})),Wn("active-asc <=> active-desc",Kn(Rp))]),rightPointer:ji("rightPointer",[Jn("active-asc, asc",Bt({transform:"rotate(45deg)"})),Jn("active-desc, desc",Bt({transform:"rotate(-45deg)"})),Wn("active-asc <=> active-desc",Kn(Rp))]),arrowOpacity:ji("arrowOpacity",[Jn("desc-to-active, asc-to-active, active",Bt({opacity:1})),Jn("desc-to-hint, asc-to-hint, hint",Bt({opacity:.54})),Jn("hint-to-desc, active-to-desc, desc, hint-to-asc, active-to-asc, asc, void",Bt({opacity:0})),Wn("* => asc, * => desc, * => active, * => hint, * => void",Kn("0ms")),Wn("* <=> *",Kn(Rp))]),arrowPosition:ji("arrowPosition",[Wn("* => desc-to-hint, * => desc-to-active",Kn(Rp,rf([Bt({transform:"translateY(-25%)"}),Bt({transform:"translateY(0)"})]))),Wn("* => hint-to-desc, * => active-to-desc",Kn(Rp,rf([Bt({transform:"translateY(0)"}),Bt({transform:"translateY(25%)"})]))),Wn("* => asc-to-hint, * => asc-to-active",Kn(Rp,rf([Bt({transform:"translateY(25%)"}),Bt({transform:"translateY(0)"})]))),Wn("* => hint-to-asc, * => active-to-asc",Kn(Rp,rf([Bt({transform:"translateY(0)"}),Bt({transform:"translateY(-25%)"})]))),Jn("desc-to-hint, asc-to-hint, hint, desc-to-active, asc-to-active, active",Bt({transform:"translateY(0)"})),Jn("hint-to-desc, active-to-desc, desc",Bt({transform:"translateY(-25%)"})),Jn("hint-to-asc, active-to-asc, asc",Bt({transform:"translateY(25%)"}))]),allowChildren:ji("allowChildren",[Wn("* <=> *",[dd("@*",cd(),{optional:!0})])])},CA=(()=>{class n{constructor(){this.changes=new Ae}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=pe({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),_4e={provide:CA,deps:[[new Aa,new id,CA]],useFactory:function(n){return n||new CA}},y4e=Kr(class{}),Jne=(()=>{class n extends y4e{get sortActionDescription(){return this._sortActionDescription}set sortActionDescription(e){this._updateSortActionDescription(e)}get disableClear(){return this._disableClear}set disableClear(e){this._disableClear=Ut(e)}constructor(e,i,r,o,a,s,l,c){super(),this._intl=e,this._changeDetectorRef=i,this._sort=r,this._columnDef=o,this._focusMonitor=a,this._elementRef=s,this._ariaDescriber=l,this._showIndicatorHint=!1,this._viewState={},this._arrowDirection="",this._disableViewStateAnimation=!1,this.arrowPosition="after",this._sortActionDescription="Sort",c?.arrowPosition&&(this.arrowPosition=c?.arrowPosition),this._handleStateChanges()}ngOnInit(){!this.id&&this._columnDef&&(this.id=this._columnDef.name),this._updateArrowDirection(),this._setAnimationTransitionState({toState:this._isSorted()?"active":this._arrowDirection}),this._sort.register(this),this._sortButton=this._elementRef.nativeElement.querySelector(".mat-sort-header-container"),this._updateSortActionDescription(this._sortActionDescription)}ngAfterViewInit(){this._focusMonitor.monitor(this._elementRef,!0).subscribe(e=>{let i=!!e;i!==this._showIndicatorHint&&(this._setIndicatorHintVisible(i),this._changeDetectorRef.markForCheck())})}ngOnDestroy(){this._focusMonitor.stopMonitoring(this._elementRef),this._sort.deregister(this),this._rerenderSubscription.unsubscribe()}_setIndicatorHintVisible(e){this._isDisabled()&&e||(this._showIndicatorHint=e,this._isSorted()||(this._updateArrowDirection(),this._setAnimationTransitionState(this._showIndicatorHint?{fromState:this._arrowDirection,toState:"hint"}:{fromState:"hint",toState:this._arrowDirection})))}_setAnimationTransitionState(e){this._viewState=e||{},this._disableViewStateAnimation&&(this._viewState={toState:e.toState})}_toggleOnInteraction(){this._sort.sort(this),("hint"===this._viewState.toState||"active"===this._viewState.toState)&&(this._disableViewStateAnimation=!0)}_handleClick(){this._isDisabled()||this._sort.sort(this)}_handleKeydown(e){!this._isDisabled()&&(32===e.keyCode||13===e.keyCode)&&(e.preventDefault(),this._toggleOnInteraction())}_isSorted(){return this._sort.active==this.id&&("asc"===this._sort.direction||"desc"===this._sort.direction)}_getArrowDirectionState(){return`${this._isSorted()?"active-":""}${this._arrowDirection}`}_getArrowViewState(){let e=this._viewState.fromState;return(e?`${e}-to-`:"")+this._viewState.toState}_updateArrowDirection(){this._arrowDirection=this._isSorted()?this._sort.direction:this.start||this._sort.start}_isDisabled(){return this._sort.disabled||this.disabled}_getAriaSortAttribute(){return this._isSorted()?"asc"==this._sort.direction?"ascending":"descending":"none"}_renderArrow(){return!this._isDisabled()||this._isSorted()}_updateSortActionDescription(e){this._sortButton&&(this._ariaDescriber?.removeDescription(this._sortButton,this._sortActionDescription),this._ariaDescriber?.describe(this._sortButton,e)),this._sortActionDescription=e}_handleStateChanges(){this._rerenderSubscription=cn(this._sort.sortChange,this._sort._stateChanges,this._intl.changes).subscribe(()=>{this._isSorted()&&(this._updateArrowDirection(),("hint"===this._viewState.toState||"active"===this._viewState.toState)&&(this._disableViewStateAnimation=!0),this._setAnimationTransitionState({fromState:this._arrowDirection,toState:"active"}),this._showIndicatorHint=!1),!this._isSorted()&&this._viewState&&"active"===this._viewState.toState&&(this._disableViewStateAnimation=!1,this._setAnimationTransitionState({fromState:"active",toState:this._arrowDirection})),this._changeDetectorRef.markForCheck()})}}return n.\u0275fac=function(e){return new(e||n)(C(CA),C(Ft),C(rC,8),C("MAT_SORT_HEADER_COLUMN_DEF",8),C(lr),C(be),C(H1,8),C(Kne,8))},n.\u0275cmp=k({type:n,selectors:[["","mat-sort-header",""]],hostAttrs:[1,"mat-sort-header"],hostVars:3,hostBindings:function(e,i){1&e&&D("click",function(){return i._handleClick()})("keydown",function(o){return i._handleKeydown(o)})("mouseenter",function(){return i._setIndicatorHintVisible(!0)})("mouseleave",function(){return i._setIndicatorHintVisible(!1)}),2&e&&(Pe("aria-sort",i._getAriaSortAttribute()),Qe("mat-sort-header-disabled",i._isDisabled()))},inputs:{disabled:"disabled",id:["mat-sort-header","id"],arrowPosition:"arrowPosition",start:"start",sortActionDescription:"sortActionDescription",disableClear:"disableClear"},exportAs:["matSortHeader"],features:[Le],attrs:u4e,ngContentSelectors:f4e,decls:4,vars:7,consts:[[1,"mat-sort-header-container","mat-focus-indicator"],[1,"mat-sort-header-content"],["class","mat-sort-header-arrow",4,"ngIf"],[1,"mat-sort-header-arrow"],[1,"mat-sort-header-stem"],[1,"mat-sort-header-indicator"],[1,"mat-sort-header-pointer-left"],[1,"mat-sort-header-pointer-right"],[1,"mat-sort-header-pointer-middle"]],template:function(e,i){1&e&&(gn(),h(0,"div",0)(1,"div",1),Xt(2),g(),S(3,p4e,6,6,"div",2),g()),2&e&&(Qe("mat-sort-header-sorted",i._isSorted())("mat-sort-header-position-before","before"===i.arrowPosition),Pe("tabindex",i._isDisabled()?null:0)("role",i._isDisabled()?null:"button"),b(3),_("ngIf",i._renderArrow()))},dependencies:[Fe],styles:[".mat-sort-header-container{display:flex;cursor:pointer;align-items:center;letter-spacing:normal;outline:0}[mat-sort-header].cdk-keyboard-focused .mat-sort-header-container,[mat-sort-header].cdk-program-focused .mat-sort-header-container{border-bottom:solid 1px currentColor}.mat-sort-header-disabled .mat-sort-header-container{cursor:default}.mat-sort-header-container::before{margin:calc(calc(var(--mat-focus-indicator-border-width, 3px) + 2px) * -1)}.mat-sort-header-content{text-align:center;display:flex;align-items:center}.mat-sort-header-position-before{flex-direction:row-reverse}.mat-sort-header-arrow{height:12px;width:12px;min-width:12px;position:relative;display:flex;opacity:0}.mat-sort-header-arrow,[dir=rtl] .mat-sort-header-position-before .mat-sort-header-arrow{margin:0 0 0 6px}.mat-sort-header-position-before .mat-sort-header-arrow,[dir=rtl] .mat-sort-header-arrow{margin:0 6px 0 0}.mat-sort-header-stem{background:currentColor;height:10px;width:2px;margin:auto;display:flex;align-items:center}.cdk-high-contrast-active .mat-sort-header-stem{width:0;border-left:solid 2px}.mat-sort-header-indicator{width:100%;height:2px;display:flex;align-items:center;position:absolute;top:0;left:0}.mat-sort-header-pointer-middle{margin:auto;height:2px;width:2px;background:currentColor;transform:rotate(45deg)}.cdk-high-contrast-active .mat-sort-header-pointer-middle{width:0;height:0;border-top:solid 2px;border-left:solid 2px}.mat-sort-header-pointer-left,.mat-sort-header-pointer-right{background:currentColor;width:6px;height:2px;position:absolute;top:0}.cdk-high-contrast-active .mat-sort-header-pointer-left,.cdk-high-contrast-active .mat-sort-header-pointer-right{width:0;height:0;border-left:solid 6px;border-top:solid 2px}.mat-sort-header-pointer-left{transform-origin:right;left:0}.mat-sort-header-pointer-right{transform-origin:left;right:0}"],encapsulation:2,data:{animation:[D_.indicator,D_.leftPointer,D_.rightPointer,D_.arrowOpacity,D_.arrowPosition,D_.allowChildren]},changeDetection:0}),n})(),$ne=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({providers:[_4e],imports:[Te,Qt]}),n})();function o4(n){return class extends n{get sticky(){return this._sticky}set sticky(t){let e=this._sticky;this._sticky=Ut(t),this._hasStickyChanged=e!==this._sticky}hasStickyChanged(){let t=this._hasStickyChanged;return this._hasStickyChanged=!1,t}resetStickyChanged(){this._hasStickyChanged=!1}constructor(...t){super(...t),this._sticky=!1,this._hasStickyChanged=!1}}}var a4=new ie("CDK_TABLE"),eie=(new ie("text-column-options"),o4(class{}),new ie("_COALESCED_STYLE_SCHEDULER"),(()=>{class n{constructor(e,i){this.template=e,this._differs=i}ngOnChanges(e){if(!this._columnsDiffer){let i=e.columns&&e.columns.currentValue||[];this._columnsDiffer=this._differs.find(i).create(),this._columnsDiffer.diff(i)}}getColumnsDiff(){return this._columnsDiffer.diff(this.columns)}extractCellTemplate(e){return this instanceof tie?e.headerCell.template:this instanceof nie?e.footerCell.template:e.cell.template}}return n.\u0275fac=function(e){return new(e||n)(C(Si),C(vl))},n.\u0275dir=xe({type:n,features:[Gt]}),n})()),x4e=o4(class extends eie{}),tie=(()=>{class n extends x4e{constructor(e,i,r){super(e,i),this._table=r}ngOnChanges(e){super.ngOnChanges(e)}}return n.\u0275fac=function(e){return new(e||n)(C(Si),C(vl),C(a4,8))},n.\u0275dir=xe({type:n,selectors:[["","cdkHeaderRowDef",""]],inputs:{columns:["cdkHeaderRowDef","columns"],sticky:["cdkHeaderRowDefSticky","sticky"]},features:[Le,Gt]}),n})(),C4e=o4(class extends eie{}),nie=(()=>{class n extends C4e{constructor(e,i,r){super(e,i),this._table=r}ngOnChanges(e){super.ngOnChanges(e)}}return n.\u0275fac=function(e){return new(e||n)(C(Si),C(vl),C(a4,8))},n.\u0275dir=xe({type:n,selectors:[["","cdkFooterRowDef",""]],inputs:{columns:["cdkFooterRowDef","columns"],sticky:["cdkFooterRowDefSticky","sticky"]},features:[Le,Gt]}),n})(),iie=(new ie("CDK_SPL"),(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Md]}),n})()),MA=class extends Wb{get data(){return this._data.value}set data(t){t=Array.isArray(t)?t:[],this._data.next(t),this._renderChangesSubscription||this._filterData(t)}get filter(){return this._filter.value}set filter(t){this._filter.next(t),this._renderChangesSubscription||this._filterData(this.data)}get sort(){return this._sort}set sort(t){this._sort=t,this._updateChangeSubscription()}get paginator(){return this._paginator}set paginator(t){this._paginator=t,this._updateChangeSubscription()}constructor(t=[]){super(),this._renderData=new Ri([]),this._filter=new Ri(""),this._internalPageChanges=new Ae,this._renderChangesSubscription=null,this.sortingDataAccessor=(e,i)=>{let r=e[i];if(l2(r)){let o=Number(r);return o<9007199254740991?o:r}return r},this.sortData=(e,i)=>{let r=i.active,o=i.direction;return r&&""!=o?e.sort((a,s)=>{let l=this.sortingDataAccessor(a,r),c=this.sortingDataAccessor(s,r),d=typeof l,u=typeof c;d!==u&&("number"===d&&(l+=""),"number"===u&&(c+=""));let p=0;return null!=l&&null!=c?l>c?p=1:l<c&&(p=-1):null!=l?p=1:null!=c&&(p=-1),p*("asc"==o?1:-1)}):e},this.filterPredicate=(e,i)=>{let r=Object.keys(e).reduce((a,s)=>a+e[s]+"\u25ec","").toLowerCase(),o=i.trim().toLowerCase();return-1!=r.indexOf(o)},this._data=new Ri(t),this._updateChangeSubscription()}_updateChangeSubscription(){let t=this._sort?cn(this._sort.sortChange,this._sort.initialized):qt(null),e=this._paginator?cn(this._paginator.page,this._internalPageChanges,this._paginator.initialized):qt(null),r=un([this._data,this._filter]).pipe(U(([s])=>this._filterData(s))),o=un([r,t]).pipe(U(([s])=>this._orderData(s))),a=un([o,e]).pipe(U(([s])=>this._pageData(s)));this._renderChangesSubscription?.unsubscribe(),this._renderChangesSubscription=a.subscribe(s=>this._renderData.next(s))}_filterData(t){return this.filteredData=null==this.filter||""===this.filter?t:t.filter(e=>this.filterPredicate(e,this.filter)),this.paginator&&this._updatePaginator(this.filteredData.length),this.filteredData}_orderData(t){return this.sort?this.sortData(t.slice(),this.sort):t}_pageData(t){if(!this.paginator)return t;let e=this.paginator.pageIndex*this.paginator.pageSize;return t.slice(e,e+this.paginator.pageSize)}_updatePaginator(t){Promise.resolve().then(()=>{let e=this.paginator;if(e&&(e.length=t,e.pageIndex>0)){let i=Math.ceil(e.length/e.pageSize)-1||0,r=Math.min(e.pageIndex,i);r!==e.pageIndex&&(e.pageIndex=r,this._internalPageChanges.next())}})}connect(){return this._renderChangesSubscription||this._updateChangeSubscription(),this._renderData}disconnect(){this._renderChangesSubscription?.unsubscribe(),this._renderChangesSubscription=null}},rie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[iie,Qt,Qt]}),n})(),wA=class extends MA{},S4e=["container"];function E4e(n,t){if(1&n){let e=ge();h(0,"mat-slider",4),D("input",function(r){return X(e),Q(w().handleSingleSliderChange(r.value))}),g()}if(2&n){let e=w();_("disabled",!e.enabled)("min",e.min)("max",e.max)("step",1)("value",e.lowerValue)}}function T4e(n,t){if(1&n){let e=ge();h(0,"span",5,6),P(2,"span",7)(3,"span",8),h(4,"span",9),D("mousedown",function(r){X(e);let o=w();return Q(o.handleMouseDown(r,o.Position.LEFT))}),g(),h(5,"span",9),D("mousedown",function(r){X(e);let o=w();return Q(o.handleMouseDown(r,o.Position.RIGHT))}),g()()}if(2&n){let e=w();b(3),Mt("left",e.getThumbPosition(e.lowerValue))("width",e.getTrackWidth()),b(1),Mt("left",e.getThumbPosition(e.lowerValue)),Qe("active",e.isThumbActive(e.Position.LEFT)),b(1),Mt("left",e.getThumbPosition(e.upperValue)),Qe("active",e.isThumbActive(e.Position.RIGHT))}}var nl=(()=>(function(n){n[n.NONE=0]="NONE",n[n.LEFT=1]="LEFT",n[n.RIGHT=2]="RIGHT"}(nl||(nl={})),nl))(),oie=(()=>{class n{constructor(e){this.changeDetector=e,this.tickCount=20,this.enabled=!0,this.returnIntegers=!1,this.rangeValuesChanged=new L,this.singleValueChanged=new L,this.Position=nl,this.activeThumb=nl.NONE,this.offsetXFromOriginOfActiveThumb=0,this.ngUnsubscribe=new Ae}getThumbPosition(e){let i=this.getClippedValue(e),r=this.max-this.min;return r<=0?"50%":(i-this.min)/r*100+"%"}getTrackWidth(){if(null===this.upperValue)return"0%";let e=this.max-this.min;return e<=0?"0%":(this.getClippedValue(this.upperValue)-this.getClippedValue(this.lowerValue))/e*100+"%"}getClippedValue(e){return Math.min(Math.max(e,this.min),this.max)}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}ngOnInit(){ai(document,"mousemove",{passive:!0}).pipe(ot(this.ngUnsubscribe)).subscribe(e=>{this.handleMouseMove(e)}),ai(document,"mouseup",{passive:!0}).pipe(ot(this.ngUnsubscribe)).subscribe(e=>{this.handleMouseOut(e)})}handleMouseDown(e,i){e.stopPropagation(),e.preventDefault(),this.activeThumb=i,this.offsetXFromOriginOfActiveThumb=6-e.offsetX}calculateValueFromMouseEvent(e){let s,{left:i,right:r}=this.container.nativeElement.getBoundingClientRect(),a=e.clientX-i+this.offsetXFromOriginOfActiveThumb;if(null!==this.tickCount&&this.tickCount>0){let c=(r-i)/this.tickCount;s=Math.round(a/c)*c/(r-i)}else s=a/(r-i);let l=this.getClippedValue(this.min+(this.max-this.min)*s);return this.returnIntegers?Math.round(l):Number(l.toFixed(10))}handleMouseMove(e){if(this.activeThumb===nl.NONE||null===this.upperValue)return;let i=this.calculateValueFromMouseEvent(e),r=[this.lowerValue,this.upperValue];this.activeThumb===nl.LEFT?(i>this.upperValue&&(this.activeThumb=nl.RIGHT),r=[i,this.upperValue]):(i<this.lowerValue&&(this.activeThumb=nl.LEFT),r=[this.lowerValue,i]),this.maybeNotifyNextRangeValues(r,"SLIDER"),this.changeDetector.markForCheck()}maybeNotifyNextRangeValues(e,i){let[r,o]=e.sort((a,s)=>a-s);(this.lowerValue!==r||this.upperValue!==o)&&this.rangeValuesChanged.emit({lowerValue:r,upperValue:o,source:i})}handleMouseOut(e){this.activeThumb!==nl.NONE&&(this.activeThumb=nl.NONE,this.changeDetector.markForCheck())}handleSingleSliderChange(e){this.singleValueChanged.emit({value:e,source:"SLIDER"})}handleInputChange(e,i){let r=e.target,o=this.getClippedValue(Number(r.value));isNaN(o)||(i===nl.LEFT?null===this.upperValue?this.singleValueChanged.emit({value:o,source:"TEXT"}):this.maybeNotifyNextRangeValues([o,this.upperValue],"TEXT"):""===r.value?this.singleValueChanged.emit({value:this.lowerValue,source:"TEXT_DELETED"}):this.maybeNotifyNextRangeValues([this.lowerValue,o],"TEXT"))}isThumbActive(e){return this.activeThumb===e}}return n.\u0275fac=function(e){return new(e||n)(C(Ft))},n.\u0275cmp=k({type:n,selectors:[["tb-range-input"]],viewQuery:function(e,i){if(1&e&&Ye(S4e,5,be),2&e){let r;we(r=Se())&&(i.container=r.first)}},inputs:{min:"min",max:"max",lowerValue:"lowerValue",upperValue:"upperValue",tickCount:"tickCount",enabled:"enabled",returnIntegers:"returnIntegers"},outputs:{rangeValuesChanged:"rangeValuesChanged",singleValueChanged:"singleValueChanged"},decls:5,vars:6,consts:[["type","number",1,"lower-input",3,"disabled","value","change"],["type","number",1,"upper-input",3,"disabled","value","change"],["class","single-slider","color","primary",3,"disabled","min","max","step","value","input",4,"ngIf","ngIfElse"],["range",""],["color","primary",1,"single-slider",3,"disabled","min","max","step","value","input"],[1,"container"],["container",""],[1,"slider-track"],[1,"slider-track-fill"],[1,"thumb",3,"mousedown"]],template:function(e,i){if(1&e&&(h(0,"input",0),D("change",function(o){return i.handleInputChange(o,i.Position.LEFT)}),g(),h(1,"input",1),D("change",function(o){return i.handleInputChange(o,i.Position.RIGHT)}),g(),S(2,E4e,1,5,"mat-slider",2),S(3,T4e,6,12,"ng-template",null,3,Zt)),2&e){let r=tt(4);_("disabled",!i.enabled)("value",i.lowerValue),b(1),_("disabled",!i.enabled)("value",null!==i.upperValue?i.upperValue:""),b(1),_("ngIf",null===i.upperValue)("ngIfElse",r)}},dependencies:[Fe,Td],styles:['[_nghost-%COMP%]{box-sizing:border-box;display:inline-grid;grid-gap:10px;grid-template-areas:"lower-input upper-input" "slider slider";grid-template-columns:1fr 1fr;font-size:0;min-width:100px;padding:6px}input[_ngcontent-%COMP%]{background-color:inherit;border-style:solid;box-sizing:border-box;color:inherit;overflow:hidden;width:100%}.lower-input[_ngcontent-%COMP%]{grid-area:lower-input}.upper-input[_ngcontent-%COMP%]{grid-area:upper-input;justify-self:flex-end}.single-slider[_ngcontent-%COMP%]{grid-area:slider;padding:0px}.single-slider[_ngcontent-%COMP%]     .mat-slider-wrapper{top:5px;left:0px;right:0px}  .single-slider.mat-slider-horizontal{height:12px}.container[_ngcontent-%COMP%]{grid-area:slider;align-items:center;box-sizing:border-box;display:inline-flex;height:12px;justify-content:center;position:relative;width:100%}.slider-track[_ngcontent-%COMP%]{background:rgba(0,0,0,.26);height:2px;width:100%}body.dark-mode[_nghost-%COMP%]   .slider-track[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .slider-track[_ngcontent-%COMP%]{background:rgba(255,255,255,.3)}.slider-track-fill[_ngcontent-%COMP%]{position:absolute;height:2px}.thumb[_ngcontent-%COMP%]{box-sadhow:0 0 0 1px rgba(0,0,0,.26);border-radius:100%;display:inline-block;height:12px;margin-left:-6px;position:absolute;top:0;transform-origin:center;transition:transform .3s ease;width:12px;will-change:transform}body.dark-mode[_nghost-%COMP%]   .thumb[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .thumb[_ngcontent-%COMP%]{box-sadhow:0 0 0 1px rgba(255,255,255,.3)}.thumb[_ngcontent-%COMP%]:hover{cursor:grab}.thumb[_ngcontent-%COMP%]:active{cursor:grabbing}.thumb.active[_ngcontent-%COMP%]{transform:scale(1.2)}.slider-track-fill[_ngcontent-%COMP%], .thumb[_ngcontent-%COMP%]{background:#f57c00}body.dark-mode[_nghost-%COMP%]   .slider-track-fill[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .slider-track-fill[_ngcontent-%COMP%]{background:#ef6c00}body.dark-mode[_nghost-%COMP%]   .thumb[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .thumb[_ngcontent-%COMP%]{background:#ef6c00}'],changeDetection:0}),n})(),A4e=["filter"];function R4e(n,t){1&n&&Ti(0)}function k4e(n,t){1&n&&Ti(0)}var P4e=function(n){return{item:n}};function O4e(n,t){if(1&n&&(Tt(0),S(1,k4e,1,0,"ng-container",12),Dt()),2&n){let e=t.$implicit;w();let i=tt(14);b(1),_("ngTemplateOutlet",i)("ngTemplateOutletContext",Sn(2,P4e,e))}}function F4e(n,t){1&n&&(h(0,"div",13),P(1,"mat-spinner",14),g())}function L4e(n,t){1&n&&(h(0,"div",15),T(1,"No Runs"),g())}function N4e(n,t){if(1&n&&(h(0,"div",15)(1,"span"),T(2,'No runs match "'),h(3,"code"),T(4),g(),T(5,'"'),g()()),2&n){let e=w();b(4),ut(e.regexFilter)}}var B4e=function(){return[5,10,20]};function V4e(n,t){if(1&n){let e=ge();h(0,"mat-paginator",16),D("page",function(r){return X(e),Q(w().onPaginationChange.emit(r))}),g()}if(2&n){let e=w();_("pageSizeOptions",uu(4,B4e))("pageIndex",e.paginationOption.pageIndex)("pageSize",e.paginationOption.pageSize)("length",e.filteredItemsLength)}}function H4e(n,t){if(1&n){let e=ge();h(0,"mat-checkbox",26),D("change",function(){return X(e),Q(w(3).handlePageToggle())}),g()}if(2&n){let e=w(3);_("checked",e.allPageItemsSelected())("indeterminate",!e.allPageItemsSelected()&&e.somePageItemsSelected())}}var aie=function(n){return{type:n}};function z4e(n,t){if(1&n&&(h(0,"span",27),T(1,"Experiment"),g()),2&n){let e=w(3);_("mat-sort-header",Sn(1,aie,e.SortType.EXPERIMENT_NAME))}}function U4e(n,t){if(1&n&&(h(0,"span",27),T(1,"Run"),g()),2&n){let e=w(3);_("mat-sort-header",Sn(1,aie,e.SortType.RUN_NAME))}}function j4e(n,t){if(1&n&&(h(0,"span"),P(1,"runs-group-menu-button",28),g()),2&n){let e=w(3);b(1),_("experimentIds",e.experimentIds)}}var sie=function(n){return["column",n]};function G4e(n,t){if(1&n&&(h(0,"span",21),Tt(1,22),S(2,H4e,1,2,"mat-checkbox",23),S(3,z4e,2,3,"span",24),S(4,U4e,2,3,"span",24),S(5,j4e,2,1,"span",25),Dt(),g()),2&n){let e=t.$implicit,i=w(2);_("ngClass",Sn(6,sie,"tb-column-"+e)),b(1),_("ngSwitch",e),b(1),_("ngSwitchCase",i.RunsTableColumn.CHECKBOX),b(1),_("ngSwitchCase",i.RunsTableColumn.EXPERIMENT_NAME),b(1),_("ngSwitchCase",i.RunsTableColumn.RUN_NAME),b(1),_("ngSwitchCase",i.RunsTableColumn.RUN_COLOR)}}function W4e(n,t){if(1&n){let e=ge();Tt(0),h(1,"div",37),D("click",function(r){return r.stopPropagation()}),h(2,"tb-range-input",38),D("rangeValuesChanged",function(r){X(e);let o=w(2).$implicit;return Q(w(2).handleHparamIntervalChanged(o,r))}),g()(),Dt()}if(2&n){let e=w(2).$implicit;b(2),_("min",e.filter.minValue)("max",e.filter.maxValue)("lowerValue",e.filter.filterLowerValue)("upperValue",e.filter.filterUpperValue)}}function q4e(n,t){if(1&n){let e=ge();h(0,"div",40),D("click",function(r){return r.stopPropagation()}),h(1,"mat-checkbox",36),D("change",function(){let o=X(e).$implicit,a=w(3).$implicit;return Q(w(2).handleHparamDiscreteChanged(a,o))}),h(2,"span"),T(3),g()()()}if(2&n){let e=t.$implicit,i=w(3).$implicit;b(1),_("checked",i.filter.filterValues.includes(e)),b(2),ut(e)}}function Y4e(n,t){if(1&n&&(Tt(0),S(1,q4e,4,2,"div",39),Dt()),2&n){let e=w(2).$implicit;b(1),_("ngForOf",e.filter.possibleValues)}}function X4e(n,t){if(1&n){let e=ge();Tt(0),h(1,"button",32),D("click",function(r){return r.stopPropagation()}),P(2,"mat-icon",33),g(),h(3,"mat-menu",null,34)(5,"div",35),D("click",function(r){return r.stopPropagation()}),h(6,"mat-checkbox",36),D("change",function(){X(e);let r=w().$implicit;return Q(w(2).handleHparamIncludeUndefinedToggled(r))}),h(7,"span"),T(8,"(show empty value)"),g()()(),S(9,W4e,3,4,"ng-container",31),S(10,Y4e,2,1,"ng-container",31),g(),Dt()}if(2&n){let e=tt(4),i=w().$implicit,r=w(2);b(1),_("matMenuTriggerFor",e),Pe("aria-label","Filter hparam "+(i.displayName||i.name)),b(5),_("checked",i.filter.includeUndefined),b(3),_("ngIf",i.filter.type===r.DomainType.INTERVAL),b(1),_("ngIf",i.filter.type===r.DomainType.DISCRETE)}}var Q4e=function(n,t){return{type:n,name:t}};function Z4e(n,t){if(1&n&&(h(0,"span",29)(1,"span",30),T(2),g(),S(3,X4e,11,5,"ng-container",31),g()),2&n){let e=t.$implicit,i=w(2);_("mat-sort-header",Pr(3,Q4e,i.SortType.HPARAM,e.name)),b(2),ut(e.displayName||e.name),b(1),_("ngIf",e.filter)}}function K4e(n,t){if(1&n){let e=ge();Tt(0),h(1,"button",32),D("click",function(r){return r.stopPropagation()}),P(2,"mat-icon",33),g(),h(3,"mat-menu",null,34)(5,"div",35),D("click",function(r){return r.stopPropagation()}),h(6,"mat-checkbox",36),D("change",function(){X(e);let r=w().$implicit;return Q(w(2).handleMetricIncludeUndefinedChanged(r))}),h(7,"span"),T(8,"(show empty value)"),g()()(),h(9,"div",37),D("click",function(r){return r.stopPropagation()}),h(10,"tb-range-input",38),D("rangeValuesChanged",function(r){X(e);let o=w().$implicit;return Q(w(2).handleMetricFilterChanged(o,r))}),g()()(),Dt()}if(2&n){let e=tt(4),i=w().$implicit;b(1),_("matMenuTriggerFor",e),Pe("aria-label","Filter metric "+(i.displayName||i.tag)),b(5),_("checked",i.filter.includeUndefined),b(4),_("min",i.filter.minValue)("max",i.filter.maxValue)("lowerValue",i.filter.filterLowerValue)("upperValue",i.filter.filterUpperValue)}}var J4e=function(n,t){return{type:n,tag:t}};function $4e(n,t){if(1&n&&(h(0,"span",29)(1,"span",30),T(2),g(),S(3,K4e,11,7,"ng-container",31),g()),2&n){let e=t.$implicit,i=w(2);_("mat-sort-header",Pr(3,J4e,i.SortType.METRIC,e.tag)),b(2),ut(e.displayName||e.tag),b(1),_("ngIf",e.filter)}}function eHe(n,t){if(1&n){let e=ge();h(0,"div",17)(1,"div",18),D("matSortChange",function(r){return X(e),Q(w().handleSortChange(r))}),S(2,G4e,6,8,"span",19),S(3,Z4e,4,6,"span",20),S(4,$4e,4,6,"span",20),g()()}if(2&n){let e=w();b(1),_("matSortActive",e.sortOption.column),b(1),_("ngForOf",e.columns),b(1),_("ngForOf",e.hparamColumns)("ngForTrackBy",e.trackByHparamColumn),b(1),_("ngForOf",e.metricColumns)("ngForTrackBy",e.trackByMetricColumn)}}function tHe(n,t){if(1&n){let e=ge();h(0,"span")(1,"mat-checkbox",47),D("change",function(){X(e);let r=w(2).item;return Q(w().onSelectionToggle.emit(r))})("dblclick",function(){X(e);let r=w(2).item;return Q(w().onSelectionDblClick.emit(r.run.id))}),g()()}if(2&n){let e=w(2).item;b(1),_("checked",e.selected)}}function nHe(n,t){if(1&n&&P(0,"tb-experiment-alias",48),2&n){let e=w(2).item;_("alias",e.experimentAlias)("title",e.experimentName)}}function iHe(n,t){if(1&n&&(h(0,"span",30),T(1),g()),2&n){let e=w(2).item;b(1),ut(e.run.name)}}var rHe=function(n){return{"run-color-swatch":!0,"no-color":n}};function oHe(n,t){if(1&n){let e=ge();h(0,"span")(1,"button",49),D("colorPickerChange",function(r){X(e);let o=w(2).item;return Q(w().onRunColorChange.emit({runId:o.run.id,newColor:r}))}),g()()}if(2&n){let e=w(2).item;b(1),Mt("background",e.runColor),_("ngClass",Sn(8,rHe,!e.runColor))("colorPicker",e.runColor)("cpDialogDisplay","popup")("cpPositionOffset",-20)("cpUseRootViewContainer",!0)("cpOutputFormat","hex")}}function aHe(n,t){if(1&n&&(h(0,"span",44),Tt(1,22),S(2,tHe,2,1,"span",25),S(3,nHe,1,2,"tb-experiment-alias",45),S(4,iHe,2,1,"span",46),S(5,oHe,2,10,"span",25),Dt(),g()),2&n){let e=t.$implicit,i=w(2);_("ngClass",Sn(6,sie,"tb-column-"+e)),b(1),_("ngSwitch",e),b(1),_("ngSwitchCase",i.RunsTableColumn.CHECKBOX),b(1),_("ngSwitchCase",i.RunsTableColumn.EXPERIMENT_NAME),b(1),_("ngSwitchCase",i.RunsTableColumn.RUN_NAME),b(1),_("ngSwitchCase",i.RunsTableColumn.RUN_COLOR)}}function sHe(n,t){if(1&n&&(h(0,"span",50),T(1),g()),2&n){let e=t.$implicit,i=w().item;b(1),ut(i.hparams.get(e.name))}}function lHe(n,t){if(1&n&&(h(0,"span",50),T(1),g()),2&n){let e=t.$implicit,i=w().item;b(1),ut(i.metrics.get(e.tag))}}function cHe(n,t){if(1&n&&(h(0,"div",41),S(1,aHe,6,8,"span",42),S(2,sHe,2,1,"span",43),S(3,lHe,2,1,"span",43),g()),2&n){let e=t.item,i=w();Pe("data-id",e.run.id),b(1),_("ngForOf",i.columns),b(1),_("ngForOf",i.hparamColumns),b(1),_("ngForOf",i.metricColumns)}}var dHe=(()=>{class n extends Xd{constructor(){super(...arguments),this.itemsPerPageLabel="Show runs:"}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Cn(n)))(i||n)}}(),n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})(),lie=(()=>{class n{constructor(){this.dataSource=new wA,this.DomainType=Un,this.RunsTableColumn=xa,this.SortType=Sc,this.onRegexFilterChange=new L,this.onSelectionToggle=new L,this.onSelectionDblClick=new L,this.onPageSelectionToggle=new L,this.onPaginationChange=new L,this.onSortChange=new L,this.onRunColorChange=new L,this.onHparamDiscreteFilterChanged=new L,this.onHparamIntervalFilterChanged=new L,this.onMetricFilterChanged=new L}ngOnChanges(){this.dataSource.data=this.pageItems}getHparamColumnId(e){return`h:${e.name}`}getMetricColumnId(e){return`m:${e.tag}`}getColumnIds(){return[...this.columns,...this.hparamColumns.map(this.getHparamColumnId),...this.metricColumns.map(this.getMetricColumnId)]}allPageItemsSelected(){return Boolean(this.pageItems.length)&&this.pageItems.every(e=>e.selected)}somePageItemsSelected(){return this.pageItems.some(e=>e.selected)}handlePageToggle(){this.onPageSelectionToggle.emit({items:this.pageItems})}handleSortChange(e){let i;switch(e.direction){case"asc":i=Gs.ASC;break;case"desc":i=Gs.DESC;break;default:i=Gs.UNSET}this.onSortChange.emit({key:e.active,direction:i})}onFilterKeyUp(e){this.onRegexFilterChange.emit(e.target.value)}tableTrackBy(e,i){return i.run.id}handleHparamIncludeUndefinedToggled(e){let{name:i,filter:r}=e;if(!r)throw new RangeError("Invariant error: require filter to exist for it to change");r.type===Un.DISCRETE?this.onHparamDiscreteFilterChanged.emit({hparamName:i,includeUndefined:!r.includeUndefined,filterValues:r.filterValues}):this.onHparamIntervalFilterChanged.emit({name:i,includeUndefined:!r.includeUndefined,filterLowerValue:r.filterLowerValue,filterUpperValue:r.filterUpperValue})}handleHparamIntervalChanged(e,i){let{name:r,filter:o}=e;if(!o)throw new RangeError("Invariant error: require filter to exist for it to change");this.onHparamIntervalFilterChanged.emit({name:r,includeUndefined:o.includeUndefined,filterLowerValue:i.lowerValue,filterUpperValue:i.upperValue})}handleHparamDiscreteChanged(e,i){let{name:r,filter:o}=e;if(!o)throw new RangeError("Invariant error: require filter to exist for it to change");if(o.type!==Un.DISCRETE)throw new RangeError(`Invariant error: expected discrete domain for ${r}`);let a=new Set([...o.filterValues]);a.has(i)?a.delete(i):a.add(i),this.onHparamDiscreteFilterChanged.emit({hparamName:r,includeUndefined:o.includeUndefined,filterValues:[...a]})}handleMetricIncludeUndefinedChanged(e){if(!e.filter)throw new RangeError("Invariant error: require filter to exist for it to change");this.onMetricFilterChanged.emit({name:e.tag,includeUndefined:!e.filter.includeUndefined,filterLowerValue:e.filter.filterLowerValue,filterUpperValue:e.filter.filterUpperValue})}handleMetricFilterChanged(e,i){if(!e.filter)throw new RangeError("Invariant error: require filter to exist for it to change");this.onMetricFilterChanged.emit({name:e.tag,includeUndefined:e.filter.includeUndefined,filterLowerValue:i.lowerValue,filterUpperValue:i.upperValue})}trackByHparamColumn(e){return e.name}trackByMetricColumn(e){return e.tag}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["runs-table-component"]],viewQuery:function(e,i){if(1&e&&(Ye(A4e,7,be),Ye(xA,7),Ye(rC,7)),2&e){let r;we(r=Se())&&(i.filter=r.first),we(r=Se())&&(i.paginator=r.first),we(r=Se())&&(i.sort=r.first)}},hostVars:2,hostBindings:function(e,i){2&e&&Qe("flex-layout",i.useFlexibleLayout)},inputs:{experimentIds:"experimentIds",showExperimentName:"showExperimentName",columns:"columns",hparamColumns:"hparamColumns",metricColumns:"metricColumns",allItemsLength:"allItemsLength",filteredItemsLength:"filteredItemsLength",useFlexibleLayout:"useFlexibleLayout",usePagination:"usePagination",pageItems:"pageItems",loading:"loading",numSelectedItems:"numSelectedItems",sortOption:"sortOption",paginationOption:"paginationOption",regexFilter:"regexFilter"},outputs:{onRegexFilterChange:"onRegexFilterChange",onSelectionToggle:"onSelectionToggle",onSelectionDblClick:"onSelectionDblClick",onPageSelectionToggle:"onPageSelectionToggle",onPaginationChange:"onPaginationChange",onSortChange:"onSortChange",onRunColorChange:"onRunColorChange",onHparamDiscreteFilterChanged:"onHparamDiscreteFilterChanged",onHparamIntervalFilterChanged:"onHparamIntervalFilterChanged",onMetricFilterChanged:"onMetricFilterChanged"},features:[Rt([{provide:Xd,useClass:dHe}]),Gt],decls:15,vars:8,consts:[[1,"filter-row"],["placeholder","Filter runs (regex)",1,"run-filter",3,"value","keyup"],[1,"table-container"],["role","table"],[4,"ngTemplateOutlet"],["role","rowgroup",1,"rows"],[4,"ngFor","ngForOf","ngForTrackBy"],["class","loading",4,"ngIf"],["class","no-runs",4,"ngIf"],["showFirstLastButtons","",3,"pageSizeOptions","pageIndex","pageSize","length","page",4,"ngIf"],["header",""],["row",""],[4,"ngTemplateOutlet","ngTemplateOutletContext"],[1,"loading"],["mode","indeterminate","diameter","28"],[1,"no-runs"],["showFirstLastButtons","",3,"pageSizeOptions","pageIndex","pageSize","length","page"],["role","rowgroup",1,"header"],["matSort","","role","row",3,"matSortActive","matSortChange"],["role","columnheader",3,"ngClass",4,"ngFor","ngForOf"],["role","columnheader","class","column",3,"mat-sort-header",4,"ngFor","ngForOf","ngForTrackBy"],["role","columnheader",3,"ngClass"],[3,"ngSwitch"],[3,"checked","indeterminate","change",4,"ngSwitchCase"],[3,"mat-sort-header",4,"ngSwitchCase"],[4,"ngSwitchCase"],[3,"checked","indeterminate","change"],[3,"mat-sort-header"],[3,"experimentIds"],["role","columnheader",1,"column",3,"mat-sort-header"],[1,"name"],[4,"ngIf"],["mat-icon-button","",3,"matMenuTriggerFor","click"],["svgIcon","filter_alt_24px"],["filterMenu","matMenu"],["mat-menu-item","","role","menuitemcheckbox","disableRipple","",1,"filter-menu-checkbox-row",3,"click"],[3,"checked","change"],["disableRipple","","mat-menu-item","",1,"range-input-container",3,"click"],[3,"min","max","lowerValue","upperValue","rangeValuesChanged"],["mat-menu-item","","class","filter-menu-checkbox-row","role","menuitemcheckbox",3,"click",4,"ngFor","ngForOf"],["mat-menu-item","","role","menuitemcheckbox",1,"filter-menu-checkbox-row",3,"click"],["role","row"],["role","cell",3,"ngClass",4,"ngFor","ngForOf"],["role","cell","class","column",4,"ngFor","ngForOf"],["role","cell",3,"ngClass"],[3,"alias","title",4,"ngSwitchCase"],["class","name",4,"ngSwitchCase"],["title","Click to toggle run selection or double click to select only this run.",3,"checked","change","dblclick"],[3,"alias","title"],[3,"ngClass","colorPicker","cpDialogDisplay","cpPositionOffset","cpUseRootViewContainer","cpOutputFormat","colorPickerChange"],["role","cell",1,"column"]],template:function(e,i){if(1&e&&(h(0,"div",0)(1,"tb-filter-input",1),D("keyup",function(o){return i.onFilterKeyUp(o)}),g()(),h(2,"div",2)(3,"div",3),S(4,R4e,1,0,"ng-container",4),h(5,"div",5),S(6,O4e,2,4,"ng-container",6),g()(),S(7,F4e,2,0,"div",7),S(8,L4e,2,0,"div",8),S(9,N4e,6,1,"div",8),g(),S(10,V4e,1,5,"mat-paginator",9),S(11,eHe,5,6,"ng-template",null,10,Zt),S(13,cHe,4,4,"ng-template",null,11,Zt)),2&e){let r=tt(12);b(1),Ji("value",i.regexFilter),b(3),_("ngTemplateOutlet",r),b(2),_("ngForOf",i.pageItems)("ngForTrackBy",i.tableTrackBy),b(1),_("ngIf",i.loading),b(1),_("ngIf",!i.loading&&0===i.allItemsLength),b(1),_("ngIf",!i.loading&&i.allItemsLength>0&&0===i.filteredItemsLength),b(1),_("ngIf",i.usePagination)}},dependencies:[bA,bn,dn,Fe,Mo,$i,sr,tp,E_,Fn,Hl,Dn,kc,Yu,Pc,xA,zr,rC,Jne,oie,vA],styles:["[_nghost-%COMP%]{display:flex;flex-direction:column;font-size:13px;overflow:hidden}.filter-row[_ngcontent-%COMP%]{flex:none}.table-container[_ngcontent-%COMP%]{contain:layout paint;flex-grow:1;max-width:100%;overflow-x:auto;overflow-y:auto;will-change:transform,scroll-position}.flex-layout[_nghost-%COMP%]   .name[_ngcontent-%COMP%]{word-break:break-word;overflow-wrap:break-word}.flex-layout[_nghost-%COMP%]   mat-paginator[_ngcontent-%COMP%]{border-top:1px solid #ebebeb;padding-bottom:12px}body.dark-mode   .flex-layout[_nghost-%COMP%]   mat-paginator[_ngcontent-%COMP%]{border-top:1px solid #555}[role=table][_ngcontent-%COMP%]{display:table;width:100%}[role=table][_ngcontent-%COMP%]   .header[_ngcontent-%COMP%]{white-space:nowrap}[role=table][_ngcontent-%COMP%]   .header[_ngcontent-%COMP%]   [role=columnheader][_ngcontent-%COMP%]{background-color:#fff;position:sticky;top:0;z-index:1}body.dark-mode[_nghost-%COMP%]   [role=table][_ngcontent-%COMP%]   .header[_ngcontent-%COMP%]   [role=columnheader][_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   [role=table][_ngcontent-%COMP%]   .header[_ngcontent-%COMP%]   [role=columnheader][_ngcontent-%COMP%]{background-color:#303030}[role=table][_ngcontent-%COMP%]   [role=row][_ngcontent-%COMP%]{contain:strict;display:table-row;height:43px}[role=table][_ngcontent-%COMP%]   [role=row][_ngcontent-%COMP%]   .column[_ngcontent-%COMP%]{border-bottom:1px solid #ebebeb;display:table-cell;padding:5px;vertical-align:middle}body.dark-mode[_nghost-%COMP%]   [role=table][_ngcontent-%COMP%]   [role=row][_ngcontent-%COMP%]   .column[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   [role=table][_ngcontent-%COMP%]   [role=row][_ngcontent-%COMP%]   .column[_ngcontent-%COMP%]{border-bottom:1px solid #555}[role=table][_ngcontent-%COMP%]   [role=row][_ngcontent-%COMP%]   .column[_ngcontent-%COMP%]:first-child{padding-left:24px}[role=table][_ngcontent-%COMP%]   [role=row][_ngcontent-%COMP%]   .column[_ngcontent-%COMP%]:last-child{padding-right:24px}[role=rowgroup][_ngcontent-%COMP%]{display:table-row-group}[role=rowgroup].header[_ngcontent-%COMP%]{display:table-header-group}.loading[_ngcontent-%COMP%], .no-runs[_ngcontent-%COMP%]{align-items:center;border:0;border-bottom:1px solid #ebebeb;display:flex;height:48px;padding:0 24px}body.dark-mode[_nghost-%COMP%]   .loading[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .loading[_ngcontent-%COMP%]{border-bottom:1px solid #555}body.dark-mode[_nghost-%COMP%]   .no-runs[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .no-runs[_ngcontent-%COMP%]{border-bottom:1px solid #555}.loading[_ngcontent-%COMP%]{justify-content:center}.select-all[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]{padding-bottom:12px;padding-top:12px}.select-all-content[_ngcontent-%COMP%], .select-all-content[_ngcontent-%COMP%]   button[_ngcontent-%COMP%]{font-weight:400;line-height:1.6;text-align:left}.select-all-content[_ngcontent-%COMP%]   button[_ngcontent-%COMP%]{font-weight:500;padding:0 4px}.filter-row[_ngcontent-%COMP%]{border-bottom:1px solid #ebebeb;display:flex;align-items:center;height:48px;padding:0 16px 0 21px}body.dark-mode[_nghost-%COMP%]   .filter-row[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .filter-row[_ngcontent-%COMP%]{border-bottom:1px solid #555}.filter-row[_ngcontent-%COMP%]   tb-filter-input[_ngcontent-%COMP%]{flex-grow:1}.tb-column-checkbox[_ngcontent-%COMP%], .tb-column-run_color[_ngcontent-%COMP%]{width:20px}.tb-column-run_color[_ngcontent-%COMP%]{text-align:center}.run-color-swatch[_ngcontent-%COMP%]{border-radius:100%;border:1px solid #ebebeb;height:20px;width:20px;outline:none}.run-color-swatch.no-color[_ngcontent-%COMP%]{border-color:#c6cad1;border-width:2px}.range-input-container[_ngcontent-%COMP%]{height:auto}[_nghost-%COMP%]     mat-paginator mat-form-field{margin:0}.filter-menu-checkbox-row[_ngcontent-%COMP%]   mat-checkbox[_ngcontent-%COMP%]     label{display:flex;height:100%;align-items:center}.filter-menu-checkbox-row[_ngcontent-%COMP%]   mat-checkbox[_ngcontent-%COMP%]     label .mat-checkbox-inner-container{margin-left:0}.filter-menu-checkbox-row[_ngcontent-%COMP%]   mat-checkbox[_ngcontent-%COMP%]     label .mat-checkbox-label{overflow:hidden;text-overflow:ellipsis}body.dark-mode[_nghost-%COMP%]   mat-paginator[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   mat-paginator[_ngcontent-%COMP%]{background-color:#303030}"],changeDetection:0}),n})();function pHe(n,t){if(1&n){let e=ge();h(0,"runs-table-component",2),D("onSelectionToggle",function(r){return X(e),Q(w().onRunItemSelectionToggle(r))})("onSelectionDblClick",function(r){return X(e),Q(w().onRunSelectionDblClick(r))})("onPageSelectionToggle",function(r){return X(e),Q(w().onPageSelectionToggle(r))})("onPaginationChange",function(r){return X(e),Q(w().onPaginationChange(r))})("onRegexFilterChange",function(r){return X(e),Q(w().onRegexFilterChange(r))})("onSortChange",function(r){return X(e),Q(w().onSortChange(r))})("onRunColorChange",function(r){return X(e),Q(w().onRunColorChange(r))})("onHparamIntervalFilterChanged",function(r){return X(e),Q(w().onHparamIntervalFilterChanged(r))})("onHparamDiscreteFilterChanged",function(r){return X(e),Q(w().onHparamDiscreteFilterChanged(r))})("onMetricFilterChanged",function(r){return X(e),Q(w().onMetricFilterChanged(r))}),G(1,"async"),G(2,"async"),G(3,"async"),G(4,"async"),G(5,"async"),G(6,"async"),G(7,"async"),G(8,"async"),G(9,"async"),G(10,"async"),g()}if(2&n){let e=w();_("experimentIds",e.experimentIds)("useFlexibleLayout",e.useFlexibleLayout)("numSelectedItems",W(1,15,e.numSelectedItems$))("columns",e.columns)("hparamColumns",W(2,17,e.hparamColumns$))("metricColumns",W(3,19,e.metricColumns$))("showExperimentName",e.isExperimentNameVisible())("pageItems",W(4,21,e.pageItems$))("filteredItemsLength",W(5,23,e.filteredItemsLength$))("allItemsLength",W(6,25,e.allItemsLength$))("loading",W(7,27,e.loading$))("paginationOption",W(8,29,e.paginationOption$))("regexFilter",W(9,31,e.regexFilter$))("sortOption",W(10,33,e.sortOption$))("usePagination",e.usePagination)}}function fHe(n,t){if(1&n){let e=ge();h(0,"runs-data-table",3),D("sortDataBy",function(r){return X(e),Q(w().sortDataBy(r))})("orderColumns",function(r){return X(e),Q(w().orderColumns(r))})("onSelectionToggle",function(r){return X(e),Q(w().onRunSelectionToggle(r))})("onAllSelectionToggle",function(r){return X(e),Q(w().onAllSelectionToggle(r))})("onRunColorChange",function(r){return X(e),Q(w().onRunColorChange(r))})("onRegexFilterChange",function(r){return X(e),Q(w().onRegexFilterChange(r))})("onSelectionDblClick",function(r){return X(e),Q(w().onRunSelectionDblClick(r))})("toggleFullScreen",function(){return X(e),Q(w().toggleFullScreen())})("addColumn",function(r){return X(e),Q(w().addColumn(r))})("removeColumn",function(r){return X(e),Q(w().removeColumn(r))}),G(1,"async"),G(2,"async"),G(3,"async"),G(4,"async"),G(5,"async"),G(6,"async"),G(7,"async"),g()}if(2&n){let e=w();_("headers",W(1,8,e.runsColumns$))("data",W(2,10,e.sortedRunsTableData$))("selectableColumns",W(3,12,e.selectableColumns$))("sortingInfo",W(4,14,e.sortingInfo$))("experimentIds",e.experimentIds)("regexFilter",W(5,16,e.regexFilter$))("isFullScreen",W(6,18,e.runsTableFullScreen$))("loading",W(7,20,e.loading$))}}var mHe=q(Rb,n=>n.state===De.LOADING);function cie(n,t){switch(t.type){case Sc.EXPERIMENT_NAME:return[n.experimentAlias,n.run.name,n.run.id];case Sc.RUN_NAME:return[n.run.name,n.experimentAlias,n.run.id];case Sc.HPARAM:return[n.hparams.get(t.name),n.run.name,n.experimentAlias,n.run.id];case Sc.METRIC:return[n.metrics.get(t.tag),n.run.name,n.experimentAlias,n.run.id];default:throw new Error(`Not yet implemented: ${t}`)}}function die(n,t){return void 0===t?n.includeUndefined:n.type===Un.DISCRETE?n.filterValues.includes(t):n.type===Un.INTERVAL&&n.filterLowerValue<=t&&t<=n.filterUpperValue}var uie=(()=>{class n{constructor(e){this.store=e,this.sortedRunsTableData$=qt([]),this.loading$=null,this.sortingInfo$=this.store.select(u7),this.hparamColumns$=qt([]),this.metricColumns$=qt([]),this.useFlexibleLayout=!1,this.usePagination=!1,this.columns=[xa.RUN_NAME],this.showHparamsAndMetrics=!1,this.forceLegacyTable=!1,this.sortOption$=this.store.select(n2),this.paginationOption$=this.store.select(t2),this.regexFilter$=this.store.select(_d),this.hparamsEnabled=new Ri(!1),this.runsColumns$=this.store.select(d7),this.runsTableFullScreen$=this.store.select(Zh),this.selectableColumns$=this.store.select(rN).pipe(Vi(this.runsColumns$),U(([i,r])=>{let o=new Set(r.map(({name:a})=>a));return i.filter(a=>!o.has(a.name))})),this.allRunsTableData$=this.store.select(iN).pipe(U(i=>i.map(r=>({...Object.fromEntries(r.hparams.entries()),id:r.run.id,run:r.run.name,experimentAlias:r.experimentAlias,selected:r.selected,color:r.runColor})))),this.ngUnsubscribe=new Ae}isExperimentNameVisible(){return this.columns.some(e=>e===xa.EXPERIMENT_NAME)}ngOnInit(){this.store.select(hf).subscribe(a=>{this.hparamsEnabled.next(a)});let e=this.experimentIds.map(a=>this.getRunTableItemsForExperiment(a));this.sortedRunsTableData$=un([this.allRunsTableData$,this.sortingInfo$]).pipe(U(([a,s])=>function(n,t){let e=[...n];return e.sort((i,r)=>{let o=i[t.name],a=r[t.name];return"experimentAlias"===t.name&&(o=o.aliasNumber,a=a.aliasNumber),o===a?0:void 0===o||void 0===a?void 0===a?-1:1:o<a==(t.order===so.ASCENDING)?-1:1}),e}(a,s)));let i=un(e).pipe(U(a=>[].concat(...a)));this.allUnsortedRunTableItems$=i.pipe(ot(this.ngUnsubscribe),Ea(1)),this.allItemsLength$=this.allUnsortedRunTableItems$.pipe(U(a=>a.length));let r=this.getFilteredItems$(this.allUnsortedRunTableItems$).pipe(ot(this.ngUnsubscribe),Ea(1));this.filteredItemsLength$=r.pipe(U(a=>a.length)),this.pageItems$=this.sortedAndSlicedItems$(r),this.numSelectedItems$=this.allUnsortedRunTableItems$.pipe(U(a=>a.reduce((s,l)=>s+Number(l.selected),0)));let o=this.experimentIds.map(a=>this.store.select(mHe,{experimentId:a}));if(this.loading$=un(o).pipe(U(a=>a.some(s=>s))),this.showHparamsAndMetrics){let a=this.store.select(ep.getExperimentsHparamsAndMetricsSpecs,{experimentIds:this.experimentIds});this.hparamColumns$=un([this.store.select(ep.getHparamFilterMap,this.experimentIds),a]).pipe(U(([s,{hparams:l}])=>l.map(({name:c,displayName:d})=>{let p=s.get(c);if(!p)throw new RangeError(`Invariant error: a filter for ${c} must exist when the hparam exists`);return{displayName:d,name:c,filter:p}}))),this.metricColumns$=un([this.store.select(ep.getMetricFilterMap,this.experimentIds),a]).pipe(U(([s,{metrics:l}])=>l.map(({tag:c,displayName:d})=>{let u=s.get(c);if(!u)throw new RangeError(`Invariant error: a filter for ${c} must exist when the metric exists`);return{displayName:d,tag:c,filter:u}})))}this.columns.includes(xa.CHECKBOX)&&this.store.select(fa).pipe(ot(this.ngUnsubscribe),ui((s,l)=>Lo(s,l)),yi(()=>i.pipe(Ve(s=>s.length>500),zt(1)))).subscribe(()=>{this.store.dispatch(lg({localizedMessage:"The number of runs exceeds 500. New runs are unselected for performance reasons."}))}),this.store.dispatch(PS({experimentIds:this.experimentIds}))}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}getFilteredItems$(e){return un([e,this.store.select(_d)]).pipe(U(([i,r])=>{if(!r)return i;let o=this.columns.includes(xa.EXPERIMENT_NAME);return i.filter(a=>og({runName:a.run.name,experimentAlias:a.experimentAlias},r,o))}),yi(i=>this.showHparamsAndMetrics?un(this.store.select(ep.getHparamFilterMap,this.experimentIds),this.store.select(ep.getMetricFilterMap,this.experimentIds)).pipe(U(([r,o])=>i.filter(({hparams:a,metrics:s})=>[...r.entries()].every(([c,d])=>die(d,a.get(c)))&&[...o.entries()].every(([c,d])=>die(d,s.get(c)))))):qt(i)))}sortedAndSlicedItems$(e){let i=un([e,this.store.select(n2)]).pipe(U(([o,a])=>function(n,t){let e=t.key,i=[...n];return null===e||t.direction===Gs.UNSET||i.sort((r,o)=>{let a=cie(r,e),s=cie(o,e);if(a.length!==s.length)throw new Error(`Invariant error: a given sort should result in same number of items: ${t}`);for(let l=0;l<a.length;l++){let c=a[l],d=s[l];if(c!==d){if(void 0===c||void 0===d)return void 0===d?-1:1;if(typeof c!=typeof d)throw new Error(`Cannot compare values of different types: ${typeof c} vs. ${typeof d}`);return c<d==(t.direction===Gs.ASC)?-1:1}}return 0}),i}(o,a)));return un([i,this.store.select(t2)]).pipe(U(([o,a])=>{if(!this.usePagination)return o.slice();let{pageSize:s,pageIndex:l}=a;return o.slice(l*s,(l+1)*s)}),Nn([]))}sortDataBy(e){this.store.dispatch(NS({sortingInfo:e}))}getRunTableItemsForExperiment(e){return un([this.store.select(Ec,{experimentId:e}),this.store.select(GS,{experimentId:e}),this.store.select(Ru),this.store.select(ku),this.store.select(Bs)]).pipe(U(([i,r,o,a,s])=>i.map(l=>{let c=new Map;(l.hparams||[]).forEach(u=>{c.set(u.name,u.value)});let d=new Map;return(l.metrics||[]).forEach(u=>{d.set(u.tag,u.value)}),{run:l,experimentName:r?.name||"",experimentAlias:s[e],selected:Boolean(o&&o.get(l.id)),runColor:a[l.id],hparams:c,metrics:d}})))}onRunItemSelectionToggle(e){this.store.dispatch(_b({runId:e.run.id}))}onRunSelectionToggle(e){this.store.dispatch(_b({runId:e}))}onRunSelectionDblClick(e){this.store.dispatch(IS({runId:e}))}onAllSelectionToggle(e){this.store.dispatch(yb({runIds:e}))}onPageSelectionToggle(e){let{items:i}=e,r=i.map(({run:o})=>o.id);this.store.dispatch(yb({runIds:r}))}onPaginationChange(e){if(!this.usePagination)throw new Error("Pagination events cannot be dispatched when pagination is disabled");let{pageIndex:i,pageSize:r}=e;this.store.dispatch(AS({pageIndex:i,pageSize:r}))}onSortChange(e){this.store.dispatch(RS(e))}onRegexFilterChange(e){this.store.dispatch(bb({regexString:e}))}onRunColorChange({runId:e,newColor:i}){this.store.dispatch(kS({runId:e,newColor:i}))}onHparamDiscreteFilterChanged(e){let{hparamName:i,filterValues:r,includeUndefined:o}=e;this.store.dispatch(bf.hparamsDiscreteHparamFilterChanged({experimentIds:this.experimentIds,hparamName:i,filterValues:r,includeUndefined:o}))}onHparamIntervalFilterChanged(e){let{name:i,filterLowerValue:r,filterUpperValue:o,includeUndefined:a}=e;this.store.dispatch(bf.hparamsIntervalHparamFilterChanged({experimentIds:this.experimentIds,hparamName:i,filterLowerValue:r,filterUpperValue:o,includeUndefined:a}))}onMetricFilterChanged(e){let{name:i,includeUndefined:r,filterLowerValue:o,filterUpperValue:a}=e;this.store.dispatch(bf.hparamsMetricFilterChanged({experimentIds:this.experimentIds,metricTag:i,includeUndefined:r,filterLowerValue:o,filterUpperValue:a}))}toggleFullScreen(){this.store.dispatch(CS())}addColumn({header:e,index:i}){e.enabled=!0,this.store.dispatch(OS({header:e,index:i}))}removeColumn(e){this.store.dispatch(FS({header:e}))}orderColumns(e){this.store.dispatch(LS({newHeaderOrder:e}))}useDataTable(){return this.hparamsEnabled.value&&!this.forceLegacyTable}}return n.\u0275fac=function(e){return new(e||n)(C(ke))},n.\u0275cmp=k({type:n,selectors:[["runs-table"]],hostVars:2,hostBindings:function(e,i){2&e&&Qe("flex-layout",i.useFlexibleLayout)},inputs:{useFlexibleLayout:"useFlexibleLayout",usePagination:"usePagination",columns:"columns",experimentIds:"experimentIds",showHparamsAndMetrics:"showHparamsAndMetrics",forceLegacyTable:"forceLegacyTable"},decls:2,vars:2,consts:[[3,"experimentIds","useFlexibleLayout","numSelectedItems","columns","hparamColumns","metricColumns","showExperimentName","pageItems","filteredItemsLength","allItemsLength","loading","paginationOption","regexFilter","sortOption","usePagination","onSelectionToggle","onSelectionDblClick","onPageSelectionToggle","onPaginationChange","onRegexFilterChange","onSortChange","onRunColorChange","onHparamIntervalFilterChanged","onHparamDiscreteFilterChanged","onMetricFilterChanged",4,"ngIf"],[3,"headers","data","selectableColumns","sortingInfo","experimentIds","regexFilter","isFullScreen","loading","sortDataBy","orderColumns","onSelectionToggle","onAllSelectionToggle","onRunColorChange","onRegexFilterChange","onSelectionDblClick","toggleFullScreen","addColumn","removeColumn",4,"ngIf"],[3,"experimentIds","useFlexibleLayout","numSelectedItems","columns","hparamColumns","metricColumns","showExperimentName","pageItems","filteredItemsLength","allItemsLength","loading","paginationOption","regexFilter","sortOption","usePagination","onSelectionToggle","onSelectionDblClick","onPageSelectionToggle","onPaginationChange","onRegexFilterChange","onSortChange","onRunColorChange","onHparamIntervalFilterChanged","onHparamDiscreteFilterChanged","onMetricFilterChanged"],[3,"headers","data","selectableColumns","sortingInfo","experimentIds","regexFilter","isFullScreen","loading","sortDataBy","orderColumns","onSelectionToggle","onAllSelectionToggle","onRunColorChange","onRegexFilterChange","onSelectionDblClick","toggleFullScreen","addColumn","removeColumn"]],template:function(e,i){1&e&&(S(0,pHe,11,35,"runs-table-component",0),S(1,fHe,8,22,"runs-data-table",1)),2&e&&(_("ngIf",!i.useDataTable()),b(1),_("ngIf",i.useDataTable()))},dependencies:[Fe,Hne,lie,lt],styles:["[_nghost-%COMP%] {\n        position: relative;\n      }\n\n      .flex-layout[_nghost-%COMP%] {\n        display: flex;\n      }\n\n      .flex-layout[_nghost-%COMP%]    > runs-table-component[_ngcontent-%COMP%] {\n        width: 100%;\n      }\n\n      .flex-layout[_nghost-%COMP%]    > tb-data-table[_ngcontent-%COMP%] {\n        overflow-y: scroll;\n        width: 100%;\n      }"],changeDetection:0}),n})(),pie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["runs-selector-component"]],inputs:{experimentIds:"experimentIds",showHparamsAndMetrics:"showHparamsAndMetrics",columns:"columns"},decls:1,vars:4,consts:[[3,"useFlexibleLayout","columns","experimentIds","showHparamsAndMetrics"]],template:function(e,i){1&e&&P(0,"runs-table",0),2&e&&_("useFlexibleLayout",!0)("columns",i.columns)("experimentIds",i.experimentIds)("showHparamsAndMetrics",i.showHparamsAndMetrics)},dependencies:[uie],styles:["runs-table[_ngcontent-%COMP%] {\n        height: 100%;\n      }"],changeDetection:0}),n})(),fie=(()=>{class n{constructor(e){this.store=e,this.experimentIds$=this.store.select(ro).pipe(U(i=>i??[])),this.columns$=this.store.select(ro).pipe(U(i=>[xa.CHECKBOX,xa.RUN_NAME,i&&i.length>1?xa.EXPERIMENT_NAME:null,xa.RUN_COLOR].filter(r=>null!==r)))}}return n.\u0275fac=function(e){return new(e||n)(C(ke))},n.\u0275cmp=k({type:n,selectors:[["runs-selector"]],inputs:{showHparamsAndMetrics:"showHparamsAndMetrics"},decls:3,vars:7,consts:[[3,"experimentIds","columns","showHparamsAndMetrics"]],template:function(e,i){1&e&&(P(0,"runs-selector-component",0),G(1,"async"),G(2,"async")),2&e&&_("experimentIds",W(1,3,i.experimentIds$))("columns",W(2,5,i.columns$))("showHparamsAndMetrics",i.showHparamsAndMetrics)},dependencies:[pie,lt],encapsulation:2,changeDetection:0}),n})();function vHe(n,t){1&n&&P(0,"metrics-main-view",2)}var mie=(()=>{class n{constructor(e){this.store=e,this.showHparamsAndMetrics$=this.store.select(hf),this.runsTableFullScreen$=this.store.select(Zh)}}return n.\u0275fac=function(e){return new(e||n)(C(ke))},n.\u0275cmp=k({type:n,selectors:[["metrics-dashboard"]],decls:5,vars:6,consts:[["sidebar","",3,"showHparamsAndMetrics"],["main","",4,"ngIf"],["main",""]],template:function(e,i){1&e&&(h(0,"tb-dashboard-layout"),P(1,"runs-selector",0),G(2,"async"),S(3,vHe,1,0,"metrics-main-view",1),G(4,"async"),g()),2&e&&(b(1),_("showHparamsAndMetrics",W(2,2,i.showHparamsAndMetrics$)),b(2),_("ngIf",!W(4,4,i.runsTableFullScreen$)))},dependencies:[Fe,xQ,kne,fie,lt],styles:["[_nghost-%COMP%]{contain:strict;display:flex;flex-direction:column;height:100%;justify-content:stretch;overflow:hidden}.notice[_ngcontent-%COMP%]{background-color:rgba(255,245,157,.85);border-bottom:1px solid #ffeb3b;color:#212121;display:block;flex:0 0}tb-dashboard-layout[_ngcontent-%COMP%]{flex:1 1;overflow:hidden}nav[_ngcontent-%COMP%]{background-color:#fff;border-right:1px solid #ebebeb;flex:none;width:340px}body.dark-mode[_nghost-%COMP%]   nav[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   nav[_ngcontent-%COMP%]{background-color:#303030;border-right-color:#555}metrics-main-view[_ngcontent-%COMP%]{flex:1 1}"],changeDetection:0}),n})(),s4=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Te,mi,fi]}),n})(),SA=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Te]}),n})(),EA=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Te,mi]}),n})(),hie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Te,mi,Qs,fi,kg]}),n})(),gie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Te]}),n})(),TA=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Te,mi,fi,EA,gie,hie]}),n})(),_ie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({}),n})(),I_=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Te,_ie]}),n})(),DA=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Te,gA,mi]}),n})(),IA=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Te,Ku]}),n})(),yie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[One,Te,TA,I_,DA,Vf,fi,Wu,wg,Qs,mi,Xu,Zne,Lc,$ne,rie,IA,Q1]}),n})(),bie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Te,yie]}),n})(),A_=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({}),n})(),AA=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Te,mi]}),n})(),vie=(()=>{class n{constructor(){this.onTimeSelectionChanged=new L,this.onTimeSelectionToggled=new L,this.axisDirection=ga.VERTICAL,this.cardFobHelper={getStepHigherThanAxisPosition:this.getStepHigherThanAxisPosition.bind(this),getStepLowerThanAxisPosition:this.getStepLowerThanAxisPosition.bind(this)}}getAxisPositionFromStartStep(){return this.temporalScale(this.timeSelection.start.step)}getAxisPositionFromEndStep(){return null===this.timeSelection.end?null:this.temporalScale(this.timeSelection.end.step)}getHighestStep(){return this.steps[this.steps.length-1]}getLowestStep(){return this.steps[0]}getStepHigherThanAxisPosition(e){let i=0;for(;e>this.temporalScale(this.steps[i])&&i<this.steps.length-1;)i++;return this.steps[i]}getStepLowerThanAxisPosition(e){let i=this.steps.length-1;for(;e<this.temporalScale(this.steps[i])&&i>0;)i--;return this.steps[i]}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["histogram-card-fob-controller"]],inputs:{steps:"steps",timeSelection:"timeSelection",temporalScale:"temporalScale"},outputs:{onTimeSelectionChanged:"onTimeSelectionChanged",onTimeSelectionToggled:"onTimeSelectionToggled"},decls:1,vars:7,consts:[[3,"axisDirection","timeSelection","startStepAxisPosition","endStepAxisPosition","highestStep","lowestStep","cardFobHelper","onTimeSelectionChanged","onTimeSelectionToggled"]],template:function(e,i){1&e&&(h(0,"card-fob-controller",0),D("onTimeSelectionChanged",function(o){return i.onTimeSelectionChanged.emit(o)})("onTimeSelectionToggled",function(){return i.onTimeSelectionToggled.emit()}),g()),2&e&&_("axisDirection",i.axisDirection)("timeSelection",i.timeSelection)("startStepAxisPosition",i.getAxisPositionFromStartStep())("endStepAxisPosition",i.getAxisPositionFromEndStep())("highestStep",i.getHighestStep())("lowestStep",i.getLowestStep())("cardFobHelper",i.cardFobHelper)},dependencies:[mA],encapsulation:2,changeDetection:0}),n})(),xie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[AA,Te,Ju,A_]}),n})();hy(hA,[dn,Fe,qf,o0,vie],[]);var R_=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Te]}),n})(),RA=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Te,I_]}),n})(),k_=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Te,mi]}),n})(),Cie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Te,xie,fi,mi,Lc,RA,R_,k_]}),n})(),kA=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({}),n})(),Mie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Te,kA,fi,mi,Lc,Ku,RA,R_,k_]}),n})(),wie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Te,Lr,fi,mi,Qs,Xu]}),n})(),PA=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Te,Lr,wie,Ju]}),n})(),Sie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Te,kA,kg,fi,wg,Qs,Xs,JS]}),n})(),Eie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Te,TA]}),n})(),Tie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[AA,Te,PA]}),n})(),Die=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Te,Sie,I_,A_,PA,fi,mi,Xu,Lc,Ju,Eie,Tie,R_,k_]}),n})(),Iie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Te,Mie,Die,Cie,A_]}),n})(),Aie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Te,Xs]}),n})(),OA=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Te,Aie,fi,GT,Wu,mi,Xs,Ku,ng,IA]}),n})(),Rie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Te,EA,Wu,wE,mi,fi]}),n})(),kie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Iie,Te,SA,DA,gA,fi,GT,mi,Qs,Lc,OA,Rie,Md]}),n})(),Pie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Te,SA,s4,kie,mi,OA,bie]}),n})(),MHe="Max pin limit exceeded. Remove existing pins before adding more. See https://github.com/tensorflow/tensorboard/issues/4242";function wHe(){return[{actionCreator:$g,alertFromAction:n=>{let{wasPinned:t,canCreateNewPins:e}=n;return t||e?null:{localizedMessage:MHe}}}]}function SHe(){return q(gd,n=>({scalarSmoothing:n}))}function EHe(){return q(wf,n=>({ignoreOutliers:n}))}function THe(){return q(Mf,n=>({tooltipSort:String(n)}))}function DHe(){return q(f1,n=>({timeSeriesSettingsPaneOpened:n}))}function IHe(){return q(rg,n=>({timeSeriesCardMinWidth:n}))}function AHe(){return q(Eb,n=>({stepSelectorEnabled:n}))}function RHe(){return q(Iu,n=>({rangeSelectionEnabled:n}))}function kHe(){return q(Du,n=>({linkedTimeEnabled:n}))}function PHe(){return q(Tb,n=>({singleSelectionHeaders:n}))}function OHe(){return q(Db,n=>({rangeSelectionHeaders:n}))}var Oie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({providers:[{provide:QL,useFactory:yQ,deps:[ZL]},{provide:ZL,useValue:e1}],imports:[Te,Uh,zs,Oc.forPlugin(xb,mie),JS,Pie,wr.forFeature($S,hQ,QL),wo.forFeature([_Q]),Cc.registerAlertActions(wHe),er.defineGlobalSetting(SHe),er.defineGlobalSetting(EHe),er.defineGlobalSetting(THe),er.defineGlobalSetting(DHe),er.defineGlobalSetting(IHe),er.defineGlobalSetting(AHe),er.defineGlobalSetting(RHe),er.defineGlobalSetting(kHe),er.defineGlobalSetting(PHe),er.defineGlobalSetting(OHe)]}),n})(),Fie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[sQ,Oie]}),n})(),Qd=(()=>(function(n){n.CUSTOM_ELEMENT="CUSTOM_ELEMENT",n.IFRAME="IFRAME",n.NG_COMPONENT="NG_COMPONENT",n.NONE="NONE"}(Qd||(Qd={})),Qd))(),FHe=["pluginContainer"],LHe=["ngPluginContainer"];function NHe(n,t){1&n&&Ti(0)}function BHe(n,t){if(1&n&&(Tt(0),S(1,NHe,1,0,"ng-container",9),Dt()),2&n){let e=w(2),i=tt(6);b(1),_("ngTemplateOutlet",e.environmentFailureNotFoundTemplate?e.environmentFailureNotFoundTemplate:i)}}function VHe(n,t){1&n&&Ti(0)}function HHe(n,t){if(1&n&&(Tt(0),S(1,VHe,1,0,"ng-container",9),Dt()),2&n){let e=w(2),i=tt(6);b(1),_("ngTemplateOutlet",e.environmentFailurePermissionDeniedTemplate?e.environmentFailurePermissionDeniedTemplate:i)}}function zHe(n,t){1&n&&Ti(0)}function UHe(n,t){if(1&n&&(Tt(0),S(1,zHe,1,0,"ng-container",9),Dt()),2&n){let e=w(2),i=tt(6);b(1),_("ngTemplateOutlet",e.environmentFailureUnknownTemplate?e.environmentFailureUnknownTemplate:i)}}function jHe(n,t){if(1&n&&(Tt(0),h(1,"h3",10),T(2," There\u2019s no dashboard by the name of \u201c"),h(3,"code"),T(4),g(),T(5,"\u201d. "),g(),h(6,"p"),T(7,"You can select a dashboard from the list above."),g(),h(8,"p"),Ti(9,11),g(),Dt()),2&n){let e=w(2),i=tt(8);b(4),ut(e.activePluginId),b(5),_("ngTemplateOutlet",i)}}function GHe(n,t){if(1&n&&(Tt(0),h(1,"h3",12),T(2," No dashboards are active for the current data set. "),g(),h(3,"p"),T(4,"Probable causes:"),g(),h(5,"ul")(6,"li"),T(7,"You haven\u2019t written any data to your event files."),g(),h(8,"li"),T(9,"TensorBoard can\u2019t find your event files."),g()(),T(10," If you\u2019re new to using TensorBoard, and want to find out how to add data and set up your event files, check out the "),h(11,"a",13),T(12,"README"),g(),T(13," and perhaps the "),h(14,"a",14),T(15,"TensorBoard tutorial"),g(),T(16,". "),h(17,"p"),T(18," If you think TensorBoard is configured properly, please see "),h(19,"a",15),T(20,"the section of the README devoted to missing data problems"),g(),T(21," and consider filing an issue on GitHub. "),g(),h(22,"p"),Ti(23,11),g(),Dt()),2&n){w(2);let e=tt(8);b(23),_("ngTemplateOutlet",e)}}function WHe(n,t){if(1&n&&(h(0,"div",6)(1,"div",7),S(2,BHe,2,1,"ng-container",8),S(3,HHe,2,1,"ng-container",8),S(4,UHe,2,1,"ng-container",8),S(5,jHe,10,2,"ng-container",8),S(6,GHe,24,1,"ng-container",8),g()()),2&n){let e=w();_("ngSwitch",e.pluginLoadState),b(2),_("ngSwitchCase",e.PluginLoadState.ENVIRONMENT_FAILURE_NOT_FOUND),b(1),_("ngSwitchCase",e.PluginLoadState.ENVIRONMENT_FAILURE_PERMISSION_DENIED),b(1),_("ngSwitchCase",e.PluginLoadState.ENVIRONMENT_FAILURE_UNKNOWN),b(1),_("ngSwitchCase",e.PluginLoadState.UNKNOWN_PLUGIN_ID),b(1),_("ngSwitchCase",e.PluginLoadState.NO_ENABLED_PLUGINS)}}function qHe(n,t){if(1&n&&(h(0,"h3",16),T(1,"Data could not be loaded."),g(),h(2,"p"),T(3,"The TensorBoard server may be down or inaccessible."),g(),h(4,"p"),Ti(5,11),g()),2&n){w();let e=tt(8);b(5),_("ngTemplateOutlet",e)}}function YHe(n,t){if(1&n&&(h(0,"p",19)(1,"i"),T(2,"Log directory: "),h(3,"span"),T(4),g()()()),2&n){let e=w(2);b(4),ut(e.dataLocation)}}function XHe(n,t){if(1&n&&(h(0,"span",17),T(1),G(2,"date"),g(),S(3,YHe,5,1,"p",18)),2&n){let e=w();b(1),ze("Last reload: ",Jp(2,2,e.lastUpdated,"medium"),""),b(2),_("ngIf",e.dataLocation)}}var QHe=function(n){return{plugins:!0,"is-first-party-plugin":n}},il=(()=>(function(n){n[n.ENVIRONMENT_FAILURE_NOT_FOUND=0]="ENVIRONMENT_FAILURE_NOT_FOUND",n[n.ENVIRONMENT_FAILURE_PERMISSION_DENIED=1]="ENVIRONMENT_FAILURE_PERMISSION_DENIED",n[n.ENVIRONMENT_FAILURE_UNKNOWN=2]="ENVIRONMENT_FAILURE_UNKNOWN",n[n.NO_ENABLED_PLUGINS=3]="NO_ENABLED_PLUGINS",n[n.UNKNOWN_PLUGIN_ID=4]="UNKNOWN_PLUGIN_ID",n[n.LOADED=5]="LOADED",n[n.LOADING=6]="LOADING"}(il||(il={})),il))(),Lie=(()=>{class n{constructor(e,i,r){this.componentFactoryResolver=e,this.pluginRegistry=i,this.pluginApiHost=r,this.PluginLoadState=il,this.LoadingMechanismType=Qd,this.pluginInstances=new Map}ngOnChanges(e){if(!this.isFeatureFlagsLoaded||!this.activeKnownPlugin||this.settingsLoadState===De.NOT_LOADED||this.settingsLoadState===De.LOADING)return;let i=Boolean(this.activeKnownPlugin&&!this.pluginInstances.has(this.activeKnownPlugin.id));if(e.activeKnownPlugin||e.isFeatureFlagsLoaded||e.settingsLoadState){let r=e.activeKnownPlugin?.previousValue;if(r&&r.id!==this.activeKnownPlugin.id&&this.hidePlugin(r),i){let o=this.createPlugin(this.activeKnownPlugin);o&&this.pluginInstances.set(this.activeKnownPlugin.id,o)}else this.showPlugin(this.activeKnownPlugin)}(i||e.lastUpdated)&&this.reload(this.activeKnownPlugin,i)}hidePlugin(e){if(!this.pluginInstances.has(e.id))return;let i=this.pluginInstances.get(e.id);Object.assign(i.style,{maxHeight:0,overflow:"hidden",visibility:"hidden",position:"absolute"})}showPlugin(e){if(!this.pluginInstances.has(e.id))return;let i=this.pluginInstances.get(e.id);Object.assign(i.style,{maxHeight:null,overflow:null,visibility:null,position:null})}createPlugin(e){let i=null;switch(e.loading_mechanism.type){case Qd.CUSTOM_ELEMENT:i=document.createElement(e.loading_mechanism.element_name),i.reloadOnReady=!1,i.featureFlags=this.featureFlags,this.pluginsContainer.nativeElement.appendChild(i);break;case Qd.IFRAME:if(!this.pluginApiHost)throw Error(`IFRAME-based plugins not supported: ${e.id}`);i=document.createElement("iframe"),i.setAttribute("src",`data/plugin_entry.html?name=${e.id}`),this.pluginApiHost.registerPluginIframe(i,e.id),this.pluginsContainer.nativeElement.appendChild(i);break;case Qd.NG_COMPONENT:let r=this.pluginRegistry.getComponent(e.id);if(r){let o=this.componentFactoryResolver.resolveComponentFactory(r);i=this.ngPluginContainer.createComponent(o).location.nativeElement}else console.error(`No registered Angular component for plugin: ${e.id}`);break;case Qd.NONE:break;default:console.error("Unexpected plugin")}return i}reload(e,i){if(!i&&e.disable_reload)return;let r=this.pluginInstances.get(e.id);r&&r.reload&&r.reload()}}return n.\u0275fac=function(e){return new(e||n)(C(Qr),C(Oc),C(R1,8))},n.\u0275cmp=k({type:n,selectors:[["plugins-component"]],viewQuery:function(e,i){if(1&e&&(Ye(FHe,7,be),Ye(LHe,7,Zn)),2&e){let r;we(r=Se())&&(i.pluginsContainer=r.first),we(r=Se())&&(i.ngPluginContainer=r.first)}},inputs:{activePluginId:"activePluginId",activeKnownPlugin:"activeKnownPlugin",pluginLoadState:"pluginLoadState",dataLocation:"dataLocation",isFeatureFlagsLoaded:"isFeatureFlagsLoaded",settingsLoadState:"settingsLoadState",featureFlags:"featureFlags",lastUpdated:"lastUpdated",environmentFailureNotFoundTemplate:"environmentFailureNotFoundTemplate",environmentFailurePermissionDeniedTemplate:"environmentFailurePermissionDeniedTemplate",environmentFailureUnknownTemplate:"environmentFailureUnknownTemplate"},features:[Gt],decls:9,vars:4,consts:[[3,"ngClass"],["pluginContainer",""],["ngPluginContainer",""],["class","warning",3,"ngSwitch",4,"ngIf"],["environmentFailureDefaultTemplate",""],["dateAndDataLocation",""],[1,"warning",3,"ngSwitch"],[1,"warning-message"],[4,"ngSwitchCase"],[4,"ngTemplateOutlet"],[1,"unknown-plugin"],[3,"ngTemplateOutlet"],[1,"no-active-plugin"],["href","https://github.com/tensorflow/tensorboard/blob/master/README.md"],["href","https://www.tensorflow.org/get_started/summaries_and_tensorboard"],["href","https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"],[1,"environment-not-loaded"],[1,"last-reload-time"],["class","data-location",4,"ngIf"],[1,"data-location"]],template:function(e,i){1&e&&(h(0,"div",0,1),Ti(2,null,2),g(),S(4,WHe,7,6,"div",3),S(5,qHe,6,1,"ng-template",null,4,Zt),S(7,XHe,4,5,"ng-template",null,5,Zt)),2&e&&(_("ngClass",Sn(2,QHe,(null==i.activeKnownPlugin?null:i.activeKnownPlugin.loading_mechanism.type)!==i.LoadingMechanismType.IFRAME)),b(4),_("ngIf",i.pluginLoadState!==i.PluginLoadState.LOADED&&i.pluginLoadState!==i.PluginLoadState.LOADING))},dependencies:[bn,Fe,Mo,$i,sr,Ih],styles:["[_nghost-%COMP%]{background-color:#fff;color:#212121;display:block;position:relative}body.dark-mode   [_nghost-%COMP%]   .plugins.is-first-party-plugin[_ngcontent-%COMP%]{background-color:#303030;color:#fff}.plugins[_ngcontent-%COMP%]{height:100%;position:relative}.warning[_ngcontent-%COMP%]{background:#fff;bottom:0;left:0;position:absolute;right:0;top:0}body.dark-mode[_nghost-%COMP%]   .warning[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .warning[_ngcontent-%COMP%]{background:#303030}.warning-message[_ngcontent-%COMP%]{color:#212121;margin:80px auto 0;max-width:540px}body.dark-mode[_nghost-%COMP%]   .warning-message[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .warning-message[_ngcontent-%COMP%]{color:#fff}.last-reload-time[_ngcontent-%COMP%]{font-style:italic}.plugins[_ngcontent-%COMP%]     iframe{border:0;display:block;height:100%;width:100%}"],changeDetection:0}),n})(),ZHe=q(Qh,qo,(n,t)=>t&&n[t]?Object.assign({id:t},n[t]):null),FA=(()=>{class n{constructor(e){this.store=e,this.activeKnownPlugin$=this.store.select(ZHe),this.activePluginId$=this.store.select(qo),this.pluginLoadState$=un(this.activeKnownPlugin$,this.activePluginId$,this.store.select(SS)).pipe(U(([i,r,o])=>null!==o.failureCode?o.failureCode===Vs.NOT_FOUND?il.ENVIRONMENT_FAILURE_NOT_FOUND:o.failureCode===Vs.PERMISSION_DENIED?il.ENVIRONMENT_FAILURE_PERMISSION_DENIED:il.ENVIRONMENT_FAILURE_UNKNOWN:null!==i?il.LOADED:null===o.lastLoadedTimeInMs&&o.state===De.LOADING?il.LOADING:r?il.UNKNOWN_PLUGIN_ID:il.NO_ENABLED_PLUGINS)),this.lastLoadedTimeInMs$=this.store.select(Xh),this.dataLocation$=this.store.select(ES).pipe(U(i=>i.data_location)),this.isFeatureFlagsLoaded$=this.store.select(Cu),this.featureFlags$=this.store.select(Fa),this.settingsLoadState$=this.store.select(Ba.getSettingsLoadState)}}return n.\u0275fac=function(e){return new(e||n)(C(ke))},n.\u0275cmp=k({type:n,selectors:[["plugins"]],inputs:{environmentFailureNotFoundTemplate:"environmentFailureNotFoundTemplate",environmentFailurePermissionDeniedTemplate:"environmentFailurePermissionDeniedTemplate",environmentFailureUnknownTemplate:"environmentFailureUnknownTemplate"},decls:9,vars:27,consts:[[3,"activeKnownPlugin","activePluginId","dataLocation","lastUpdated","pluginLoadState","isFeatureFlagsLoaded","settingsLoadState","featureFlags","environmentFailureNotFoundTemplate","environmentFailurePermissionDeniedTemplate","environmentFailureUnknownTemplate"]],template:function(e,i){1&e&&(P(0,"plugins-component",0),G(1,"async"),G(2,"async"),G(3,"async"),G(4,"async"),G(5,"async"),G(6,"async"),G(7,"async"),G(8,"async")),2&e&&_("activeKnownPlugin",W(1,11,i.activeKnownPlugin$))("activePluginId",W(2,13,i.activePluginId$))("dataLocation",W(3,15,i.dataLocation$))("lastUpdated",W(4,17,i.lastLoadedTimeInMs$))("pluginLoadState",W(5,19,i.pluginLoadState$))("isFeatureFlagsLoaded",W(6,21,i.isFeatureFlagsLoaded$))("settingsLoadState",W(7,23,i.settingsLoadState$))("featureFlags",W(8,25,i.featureFlags$))("environmentFailureNotFoundTemplate",i.environmentFailureNotFoundTemplate)("environmentFailurePermissionDeniedTemplate",i.environmentFailurePermissionDeniedTemplate)("environmentFailureUnknownTemplate",i.environmentFailureUnknownTemplate)},styles:["plugins-component[_ngcontent-%COMP%] { height: 100%; }"],changeDetection:0}),n})(),LA=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[zs,Te,Oc]}),n})();hy(FA,[Lie],[lt]);var Nie=(()=>{class n{constructor(e,i){this.store=e,this.document=i,this.onVisibilityChange=this.onVisibilityChangeImpl.bind(this),this.reloadEnabled$=this.store.pipe(pn(Ba.getReloadEnabled)),this.reloadPeriodInMs$=this.store.pipe(pn(Ba.getReloadPeriodInMs)),this.reloadTimerId=null,this.missedAutoReload=!1,this.ngUnsubscribe=new Ae}ngOnInit(){this.document.addEventListener("visibilitychange",this.onVisibilityChange),un(this.reloadEnabled$.pipe(ui()),this.reloadPeriodInMs$.pipe(ui())).pipe(ot(this.ngUnsubscribe)).subscribe(([e,i])=>{this.cancelLoad(),e&&this.load(i)})}onVisibilityChangeImpl(){"visible"===this.document.visibilityState&&this.missedAutoReload&&(this.missedAutoReload=!1,this.store.dispatch(ss()))}load(e){this.reloadTimerId=setTimeout(()=>{"visible"===this.document.visibilityState?this.store.dispatch(ss()):this.missedAutoReload=!0,this.load(e)},e)}cancelLoad(){null!==this.reloadTimerId&&clearTimeout(this.reloadTimerId),this.reloadTimerId=null}ngOnDestroy(){this.cancelLoad(),this.document.removeEventListener("visibilitychange",this.onVisibilityChange),this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}}return n.\u0275fac=function(e){return new(e||n)(C(ke),C(kt))},n.\u0275cmp=k({type:n,selectors:[["reloader"]],decls:0,vars:0,template:function(e,i){},encapsulation:2,changeDetection:0}),n})(),Bie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=k({type:n,selectors:[["tensorboard-wrapper-component"]],decls:2,vars:0,consts:[[1,"plugins"]],template:function(e,i){1&e&&P(0,"plugins",0)(1,"reloader")},dependencies:[FA,Nie],styles:["[_nghost-%COMP%] {\n        display: flex;\n        flex-direction: column;\n        height: 100%;\n      }\n\n      .plugins[_ngcontent-%COMP%] {\n        flex: 1 1;\n        overflow: auto;\n        position: relative;\n      }"],changeDetection:0}),n})(),Vie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=pe({token:n,factory:n.\u0275fac}),n})(),l4="smoothing",c4="runColorGroup",d4="tagFilter",u4="runFilter",p4="regex:",NA=class extends Vie{getMetricsPinnedCards(t){return un([t.select(Sb),t.select(WW)]).pipe(U(([e,i])=>{if(!e.length&&!i.length)return[];let o=[...e.map(({plugin:a,tag:s,sample:l,runId:c})=>{let d={plugin:a,tag:s};return cs(a)&&(d.runId=c),ls(a)&&(d.sample=l),d}),...i];return[{key:"pinnedCards",value:JSON.stringify(o)}]}))}serializeStateToQueryParams(t){return un([this.getMetricsPinnedCards(t),t.select(Il).pipe(U(e=>e?[{key:d4,value:e}]:[])),un([t.select(fb),t.select(mf)]).pipe(U(([e,i])=>function(n,t){return Object.entries(n).map(([e,i])=>{if(void 0===i)return{};let r=t[e];return r&&r.queryParamOverride?{key:r.queryParamOverride,value:i?.toString()}:{}}).filter(({key:e,value:i})=>e&&void 0!==i)}(e,i))),t.select(YW).pipe(U(e=>Number.isFinite(e.scalarSmoothing)?[{key:l4,value:String(e.scalarSmoothing)}]:[])),t.select(e2).pipe(U(e=>{if(!e)return[];let i;switch(e.key){case Qi.EXPERIMENT:i="experiment";break;case Qi.RUN:i="run";break;case Qi.REGEX:i=`${p4}${e.regexString}`;break;default:throw new RangeError("Serialization not implemented")}return[{key:c4,value:i}]})),t.select(_d).pipe(U(e=>e?[{key:u4,value:e}]:[]))]).pipe(U(e=>e.flat()))}deserializeQueryParams(t){let e=null,i=null,r=null,o=null,a=null;for(let{key:s,value:l}of t)switch(s){case"pinnedCards":e=$He(l);break;case l4:i=Number(l);break;case c4:switch(l){case"experiment":o={key:Qi.EXPERIMENT};break;case"run":o={key:Qi.RUN}}if(l.startsWith(p4)){let c=l.slice(p4.length);o={key:Qi.REGEX,regexString:c}}break;case d4:r=l;break;case u4:a=l}return{metrics:{pinnedCards:e||[],smoothing:i,tagFilter:r},runs:{groupBy:o,regexFilter:a}}}};function $He(n){let t;try{t=JSON.parse(n)}catch{return null}if(!Array.isArray(t))return null;let e=[];for(let i of t){let o="string"==typeof i.runId,a="number"==typeof i.sample;if(!("string"==typeof i.plugin&&"string"==typeof i.tag&&(o||typeof i.runId>"u")&&(a||typeof i.sample>"u")&&vW(i.plugin)&&i.tag))continue;if(cs(i.plugin)){if(!i.runId)continue}else if(i.runId)continue;if(a&&(!ls(i.plugin)||!Number.isInteger(i.sample)||i.sample<0))continue;let d={plugin:i.plugin,tag:i.tag};o&&(d.runId=i.runId),a&&(d.sample=i.sample),e.push(d)}return e}function zie(){return[{routeKind:kn.EXPERIMENT,path:"/",ngComponent:Bie,defaultRoute:!0,deepLinkProvider:new NA}]}function Uie(){return n=>(t,e)=>n(t,e)}NA=oH([eU()],NA);var jie=new ie("Root reducers token",{factory:()=>({})}),Gie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({providers:[{provide:Ph,useFactory:Uie,multi:!0}],imports:[wr.forRoot(jie,{runtimeChecks:{strictStateImmutability:!0,strictActionImmutability:!0,strictActionSerializability:!1,strictStateSerializability:!1}}),wo.forRoot([])]}),n})(),Wie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({}),n})(),qie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n}),n.\u0275inj=B({imports:[Te,LA,Wie]}),n})(),f4=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=V({type:n,bootstrap:[kY]}),n.\u0275inj=B({imports:[ng,UY,Ew,g8,Uh,PY,wl.registerRoutes(zie),Q1,X1,OY,qie,zs,HY,LY,GY,zS,WY,NY,vF,R1,LA,E1,SE,Gie,Fie]}),n})();"loading"!==document.readyState?fO().bootstrapModule(f4):window.addEventListener("DOMContentLoaded",()=>{fO().bootstrapModule(f4)})})();
/** vim: et:ts=4:sw=4:sts=4
 * @license RequireJS 2.3.6 Copyright jQuery Foundation and other contributors.
 * Released under MIT license, https://github.com/requirejs/requirejs/blob/master/LICENSE
 */
//Not using strict: uneven strict support in browsers, #392, and causes
//problems with requirejs.exec()/transpiler plugins that may not be strict.
/*jslint regexp: true, nomen: true, sloppy: true */
/*global window, navigator, document, importScripts, setTimeout, opera */

var requirejs, require, define;
(function (global, setTimeout) {
    var req, s, head, baseElement, dataMain, src,
        interactiveScript, currentlyAddingScript, mainScript, subPath,
        version = '2.3.6',
        commentRegExp = /\/\*[\s\S]*?\*\/|([^:"'=]|^)\/\/.*$/mg,
        cjsRequireRegExp = /[^.]\s*require\s*\(\s*["']([^'"\s]+)["']\s*\)/g,
        jsSuffixRegExp = /\.js$/,
        currDirRegExp = /^\.\//,
        op = Object.prototype,
        ostring = op.toString,
        hasOwn = op.hasOwnProperty,
        isBrowser = !!(typeof window !== 'undefined' && typeof navigator !== 'undefined' && window.document),
        isWebWorker = !isBrowser && typeof importScripts !== 'undefined',
        //PS3 indicates loaded and complete, but need to wait for complete
        //specifically. Sequence is 'loading', 'loaded', execution,
        // then 'complete'. The UA check is unfortunate, but not sure how
        //to feature test w/o causing perf issues.
        readyRegExp = isBrowser && navigator.platform === 'PLAYSTATION 3' ?
                      /^complete$/ : /^(complete|loaded)$/,
        defContextName = '_',
        //Oh the tragedy, detecting opera. See the usage of isOpera for reason.
        isOpera = typeof opera !== 'undefined' && opera.toString() === '[object Opera]',
        contexts = {},
        cfg = {},
        globalDefQueue = [],
        useInteractive = false;

    //Could match something like ')//comment', do not lose the prefix to comment.
    function commentReplace(match, singlePrefix) {
        return singlePrefix || '';
    }

    function isFunction(it) {
        return ostring.call(it) === '[object Function]';
    }

    function isArray(it) {
        return ostring.call(it) === '[object Array]';
    }

    /**
     * Helper function for iterating over an array. If the func returns
     * a true value, it will break out of the loop.
     */
    function each(ary, func) {
        if (ary) {
            var i;
            for (i = 0; i < ary.length; i += 1) {
                if (ary[i] && func(ary[i], i, ary)) {
                    break;
                }
            }
        }
    }

    /**
     * Helper function for iterating over an array backwards. If the func
     * returns a true value, it will break out of the loop.
     */
    function eachReverse(ary, func) {
        if (ary) {
            var i;
            for (i = ary.length - 1; i > -1; i -= 1) {
                if (ary[i] && func(ary[i], i, ary)) {
                    break;
                }
            }
        }
    }

    function hasProp(obj, prop) {
        return hasOwn.call(obj, prop);
    }

    function getOwn(obj, prop) {
        return hasProp(obj, prop) && obj[prop];
    }

    /**
     * Cycles over properties in an object and calls a function for each
     * property value. If the function returns a truthy value, then the
     * iteration is stopped.
     */
    function eachProp(obj, func) {
        var prop;
        for (prop in obj) {
            if (hasProp(obj, prop)) {
                if (func(obj[prop], prop)) {
                    break;
                }
            }
        }
    }

    /**
     * Simple function to mix in properties from source into target,
     * but only if target does not already have a property of the same name.
     */
    function mixin(target, source, force, deepStringMixin) {
        if (source) {
            eachProp(source, function (value, prop) {
                if (force || !hasProp(target, prop)) {
                    if (deepStringMixin && typeof value === 'object' && value &&
                        !isArray(value) && !isFunction(value) &&
                        !(value instanceof RegExp)) {

                        if (!target[prop]) {
                            target[prop] = {};
                        }
                        mixin(target[prop], value, force, deepStringMixin);
                    } else {
                        target[prop] = value;
                    }
                }
            });
        }
        return target;
    }

    //Similar to Function.prototype.bind, but the 'this' object is specified
    //first, since it is easier to read/figure out what 'this' will be.
    function bind(obj, fn) {
        return function () {
            return fn.apply(obj, arguments);
        };
    }

    function scripts() {
        return document.getElementsByTagName('script');
    }

    function defaultOnError(err) {
        throw err;
    }

    //Allow getting a global that is expressed in
    //dot notation, like 'a.b.c'.
    function getGlobal(value) {
        if (!value) {
            return value;
        }
        var g = global;
        each(value.split('.'), function (part) {
            g = g[part];
        });
        return g;
    }

    /**
     * Constructs an error with a pointer to an URL with more information.
     * @param {String} id the error ID that maps to an ID on a web page.
     * @param {String} message human readable error.
     * @param {Error} [err] the original error, if there is one.
     *
     * @returns {Error}
     */
    function makeError(id, msg, err, requireModules) {
        var e = new Error(msg + '\nhttps://requirejs.org/docs/errors.html#' + id);
        e.requireType = id;
        e.requireModules = requireModules;
        if (err) {
            e.originalError = err;
        }
        return e;
    }

    if (typeof define !== 'undefined') {
        //If a define is already in play via another AMD loader,
        //do not overwrite.
        return;
    }

    if (typeof requirejs !== 'undefined') {
        if (isFunction(requirejs)) {
            //Do not overwrite an existing requirejs instance.
            return;
        }
        cfg = requirejs;
        requirejs = undefined;
    }

    //Allow for a require config object
    if (typeof require !== 'undefined' && !isFunction(require)) {
        //assume it is a config object.
        cfg = require;
        require = undefined;
    }

    function newContext(contextName) {
        var inCheckLoaded, Module, context, handlers,
            checkLoadedTimeoutId,
            config = {
                //Defaults. Do not set a default for map
                //config to speed up normalize(), which
                //will run faster if there is no default.
                waitSeconds: 7,
                baseUrl: './',
                paths: {},
                bundles: {},
                pkgs: {},
                shim: {},
                config: {}
            },
            registry = {},
            //registry of just enabled modules, to speed
            //cycle breaking code when lots of modules
            //are registered, but not activated.
            enabledRegistry = {},
            undefEvents = {},
            defQueue = [],
            defined = {},
            urlFetched = {},
            bundlesMap = {},
            requireCounter = 1,
            unnormalizedCounter = 1;

        /**
         * Trims the . and .. from an array of path segments.
         * It will keep a leading path segment if a .. will become
         * the first path segment, to help with module name lookups,
         * which act like paths, but can be remapped. But the end result,
         * all paths that use this function should look normalized.
         * NOTE: this method MODIFIES the input array.
         * @param {Array} ary the array of path segments.
         */
        function trimDots(ary) {
            var i, part;
            for (i = 0; i < ary.length; i++) {
                part = ary[i];
                if (part === '.') {
                    ary.splice(i, 1);
                    i -= 1;
                } else if (part === '..') {
                    // If at the start, or previous value is still ..,
                    // keep them so that when converted to a path it may
                    // still work when converted to a path, even though
                    // as an ID it is less than ideal. In larger point
                    // releases, may be better to just kick out an error.
                    if (i === 0 || (i === 1 && ary[2] === '..') || ary[i - 1] === '..') {
                        continue;
                    } else if (i > 0) {
                        ary.splice(i - 1, 2);
                        i -= 2;
                    }
                }
            }
        }

        /**
         * Given a relative module name, like ./something, normalize it to
         * a real name that can be mapped to a path.
         * @param {String} name the relative name
         * @param {String} baseName a real name that the name arg is relative
         * to.
         * @param {Boolean} applyMap apply the map config to the value. Should
         * only be done if this normalization is for a dependency ID.
         * @returns {String} normalized name
         */
        function normalize(name, baseName, applyMap) {
            var pkgMain, mapValue, nameParts, i, j, nameSegment, lastIndex,
                foundMap, foundI, foundStarMap, starI, normalizedBaseParts,
                baseParts = (baseName && baseName.split('/')),
                map = config.map,
                starMap = map && map['*'];

            //Adjust any relative paths.
            if (name) {
                name = name.split('/');
                lastIndex = name.length - 1;

                // If wanting node ID compatibility, strip .js from end
                // of IDs. Have to do this here, and not in nameToUrl
                // because node allows either .js or non .js to map
                // to same file.
                if (config.nodeIdCompat && jsSuffixRegExp.test(name[lastIndex])) {
                    name[lastIndex] = name[lastIndex].replace(jsSuffixRegExp, '');
                }

                // Starts with a '.' so need the baseName
                if (name[0].charAt(0) === '.' && baseParts) {
                    //Convert baseName to array, and lop off the last part,
                    //so that . matches that 'directory' and not name of the baseName's
                    //module. For instance, baseName of 'one/two/three', maps to
                    //'one/two/three.js', but we want the directory, 'one/two' for
                    //this normalization.
                    normalizedBaseParts = baseParts.slice(0, baseParts.length - 1);
                    name = normalizedBaseParts.concat(name);
                }

                trimDots(name);
                name = name.join('/');
            }

            //Apply map config if available.
            if (applyMap && map && (baseParts || starMap)) {
                nameParts = name.split('/');

                outerLoop: for (i = nameParts.length; i > 0; i -= 1) {
                    nameSegment = nameParts.slice(0, i).join('/');

                    if (baseParts) {
                        //Find the longest baseName segment match in the config.
                        //So, do joins on the biggest to smallest lengths of baseParts.
                        for (j = baseParts.length; j > 0; j -= 1) {
                            mapValue = getOwn(map, baseParts.slice(0, j).join('/'));

                            //baseName segment has config, find if it has one for
                            //this name.
                            if (mapValue) {
                                mapValue = getOwn(mapValue, nameSegment);
                                if (mapValue) {
                                    //Match, update name to the new value.
                                    foundMap = mapValue;
                                    foundI = i;
                                    break outerLoop;
                                }
                            }
                        }
                    }

                    //Check for a star map match, but just hold on to it,
                    //if there is a shorter segment match later in a matching
                    //config, then favor over this star map.
                    if (!foundStarMap && starMap && getOwn(starMap, nameSegment)) {
                        foundStarMap = getOwn(starMap, nameSegment);
                        starI = i;
                    }
                }

                if (!foundMap && foundStarMap) {
                    foundMap = foundStarMap;
                    foundI = starI;
                }

                if (foundMap) {
                    nameParts.splice(0, foundI, foundMap);
                    name = nameParts.join('/');
                }
            }

            // If the name points to a package's name, use
            // the package main instead.
            pkgMain = getOwn(config.pkgs, name);

            return pkgMain ? pkgMain : name;
        }

        function removeScript(name) {
            if (isBrowser) {
                each(scripts(), function (scriptNode) {
                    if (scriptNode.getAttribute('data-requiremodule') === name &&
                            scriptNode.getAttribute('data-requirecontext') === context.contextName) {
                        scriptNode.parentNode.removeChild(scriptNode);
                        return true;
                    }
                });
            }
        }

        function hasPathFallback(id) {
            var pathConfig = getOwn(config.paths, id);
            if (pathConfig && isArray(pathConfig) && pathConfig.length > 1) {
                //Pop off the first array value, since it failed, and
                //retry
                pathConfig.shift();
                context.require.undef(id);

                //Custom require that does not do map translation, since
                //ID is "absolute", already mapped/resolved.
                context.makeRequire(null, {
                    skipMap: true
                })([id]);

                return true;
            }
        }

        //Turns a plugin!resource to [plugin, resource]
        //with the plugin being undefined if the name
        //did not have a plugin prefix.
        function splitPrefix(name) {
            var prefix,
                index = name ? name.indexOf('!') : -1;
            if (index > -1) {
                prefix = name.substring(0, index);
                name = name.substring(index + 1, name.length);
            }
            return [prefix, name];
        }

        /**
         * Creates a module mapping that includes plugin prefix, module
         * name, and path. If parentModuleMap is provided it will
         * also normalize the name via require.normalize()
         *
         * @param {String} name the module name
         * @param {String} [parentModuleMap] parent module map
         * for the module name, used to resolve relative names.
         * @param {Boolean} isNormalized: is the ID already normalized.
         * This is true if this call is done for a define() module ID.
         * @param {Boolean} applyMap: apply the map config to the ID.
         * Should only be true if this map is for a dependency.
         *
         * @returns {Object}
         */
        function makeModuleMap(name, parentModuleMap, isNormalized, applyMap) {
            var url, pluginModule, suffix, nameParts,
                prefix = null,
                parentName = parentModuleMap ? parentModuleMap.name : null,
                originalName = name,
                isDefine = true,
                normalizedName = '';

            //If no name, then it means it is a require call, generate an
            //internal name.
            if (!name) {
                isDefine = false;
                name = '_@r' + (requireCounter += 1);
            }

            nameParts = splitPrefix(name);
            prefix = nameParts[0];
            name = nameParts[1];

            if (prefix) {
                prefix = normalize(prefix, parentName, applyMap);
                pluginModule = getOwn(defined, prefix);
            }

            //Account for relative paths if there is a base name.
            if (name) {
                if (prefix) {
                    if (isNormalized) {
                        normalizedName = name;
                    } else if (pluginModule && pluginModule.normalize) {
                        //Plugin is loaded, use its normalize method.
                        normalizedName = pluginModule.normalize(name, function (name) {
                            return normalize(name, parentName, applyMap);
                        });
                    } else {
                        // If nested plugin references, then do not try to
                        // normalize, as it will not normalize correctly. This
                        // places a restriction on resourceIds, and the longer
                        // term solution is not to normalize until plugins are
                        // loaded and all normalizations to allow for async
                        // loading of a loader plugin. But for now, fixes the
                        // common uses. Details in #1131
                        normalizedName = name.indexOf('!') === -1 ?
                                         normalize(name, parentName, applyMap) :
                                         name;
                    }
                } else {
                    //A regular module.
                    normalizedName = normalize(name, parentName, applyMap);

                    //Normalized name may be a plugin ID due to map config
                    //application in normalize. The map config values must
                    //already be normalized, so do not need to redo that part.
                    nameParts = splitPrefix(normalizedName);
                    prefix = nameParts[0];
                    normalizedName = nameParts[1];
                    isNormalized = true;

                    url = context.nameToUrl(normalizedName);
                }
            }

            //If the id is a plugin id that cannot be determined if it needs
            //normalization, stamp it with a unique ID so two matching relative
            //ids that may conflict can be separate.
            suffix = prefix && !pluginModule && !isNormalized ?
                     '_unnormalized' + (unnormalizedCounter += 1) :
                     '';

            return {
                prefix: prefix,
                name: normalizedName,
                parentMap: parentModuleMap,
                unnormalized: !!suffix,
                url: url,
                originalName: originalName,
                isDefine: isDefine,
                id: (prefix ?
                        prefix + '!' + normalizedName :
                        normalizedName) + suffix
            };
        }

        function getModule(depMap) {
            var id = depMap.id,
                mod = getOwn(registry, id);

            if (!mod) {
                mod = registry[id] = new context.Module(depMap);
            }

            return mod;
        }

        function on(depMap, name, fn) {
            var id = depMap.id,
                mod = getOwn(registry, id);

            if (hasProp(defined, id) &&
                    (!mod || mod.defineEmitComplete)) {
                if (name === 'defined') {
                    fn(defined[id]);
                }
            } else {
                mod = getModule(depMap);
                if (mod.error && name === 'error') {
                    fn(mod.error);
                } else {
                    mod.on(name, fn);
                }
            }
        }

        function onError(err, errback) {
            var ids = err.requireModules,
                notified = false;

            if (errback) {
                errback(err);
            } else {
                each(ids, function (id) {
                    var mod = getOwn(registry, id);
                    if (mod) {
                        //Set error on module, so it skips timeout checks.
                        mod.error = err;
                        if (mod.events.error) {
                            notified = true;
                            mod.emit('error', err);
                        }
                    }
                });

                if (!notified) {
                    req.onError(err);
                }
            }
        }

        /**
         * Internal method to transfer globalQueue items to this context's
         * defQueue.
         */
        function takeGlobalQueue() {
            //Push all the globalDefQueue items into the context's defQueue
            if (globalDefQueue.length) {
                each(globalDefQueue, function(queueItem) {
                    var id = queueItem[0];
                    if (typeof id === 'string') {
                        context.defQueueMap[id] = true;
                    }
                    defQueue.push(queueItem);
                });
                globalDefQueue = [];
            }
        }

        handlers = {
            'require': function (mod) {
                if (mod.require) {
                    return mod.require;
                } else {
                    return (mod.require = context.makeRequire(mod.map));
                }
            },
            'exports': function (mod) {
                mod.usingExports = true;
                if (mod.map.isDefine) {
                    if (mod.exports) {
                        return (defined[mod.map.id] = mod.exports);
                    } else {
                        return (mod.exports = defined[mod.map.id] = {});
                    }
                }
            },
            'module': function (mod) {
                if (mod.module) {
                    return mod.module;
                } else {
                    return (mod.module = {
                        id: mod.map.id,
                        uri: mod.map.url,
                        config: function () {
                            return getOwn(config.config, mod.map.id) || {};
                        },
                        exports: mod.exports || (mod.exports = {})
                    });
                }
            }
        };

        function cleanRegistry(id) {
            //Clean up machinery used for waiting modules.
            delete registry[id];
            delete enabledRegistry[id];
        }

        function breakCycle(mod, traced, processed) {
            var id = mod.map.id;

            if (mod.error) {
                mod.emit('error', mod.error);
            } else {
                traced[id] = true;
                each(mod.depMaps, function (depMap, i) {
                    var depId = depMap.id,
                        dep = getOwn(registry, depId);

                    //Only force things that have not completed
                    //being defined, so still in the registry,
                    //and only if it has not been matched up
                    //in the module already.
                    if (dep && !mod.depMatched[i] && !processed[depId]) {
                        if (getOwn(traced, depId)) {
                            mod.defineDep(i, defined[depId]);
                            mod.check(); //pass false?
                        } else {
                            breakCycle(dep, traced, processed);
                        }
                    }
                });
                processed[id] = true;
            }
        }

        function checkLoaded() {
            var err, usingPathFallback,
                waitInterval = config.waitSeconds * 1000,
                //It is possible to disable the wait interval by using waitSeconds of 0.
                expired = waitInterval && (context.startTime + waitInterval) < new Date().getTime(),
                noLoads = [],
                reqCalls = [],
                stillLoading = false,
                needCycleCheck = true;

            //Do not bother if this call was a result of a cycle break.
            if (inCheckLoaded) {
                return;
            }

            inCheckLoaded = true;

            //Figure out the state of all the modules.
            eachProp(enabledRegistry, function (mod) {
                var map = mod.map,
                    modId = map.id;

                //Skip things that are not enabled or in error state.
                if (!mod.enabled) {
                    return;
                }

                if (!map.isDefine) {
                    reqCalls.push(mod);
                }

                if (!mod.error) {
                    //If the module should be executed, and it has not
                    //been inited and time is up, remember it.
                    if (!mod.inited && expired) {
                        if (hasPathFallback(modId)) {
                            usingPathFallback = true;
                            stillLoading = true;
                        } else {
                            noLoads.push(modId);
                            removeScript(modId);
                        }
                    } else if (!mod.inited && mod.fetched && map.isDefine) {
                        stillLoading = true;
                        if (!map.prefix) {
                            //No reason to keep looking for unfinished
                            //loading. If the only stillLoading is a
                            //plugin resource though, keep going,
                            //because it may be that a plugin resource
                            //is waiting on a non-plugin cycle.
                            return (needCycleCheck = false);
                        }
                    }
                }
            });

            if (expired && noLoads.length) {
                //If wait time expired, throw error of unloaded modules.
                err = makeError('timeout', 'Load timeout for modules: ' + noLoads, null, noLoads);
                err.contextName = context.contextName;
                return onError(err);
            }

            //Not expired, check for a cycle.
            if (needCycleCheck) {
                each(reqCalls, function (mod) {
                    breakCycle(mod, {}, {});
                });
            }

            //If still waiting on loads, and the waiting load is something
            //other than a plugin resource, or there are still outstanding
            //scripts, then just try back later.
            if ((!expired || usingPathFallback) && stillLoading) {
                //Something is still waiting to load. Wait for it, but only
                //if a timeout is not already in effect.
                if ((isBrowser || isWebWorker) && !checkLoadedTimeoutId) {
                    checkLoadedTimeoutId = setTimeout(function () {
                        checkLoadedTimeoutId = 0;
                        checkLoaded();
                    }, 50);
                }
            }

            inCheckLoaded = false;
        }

        Module = function (map) {
            this.events = getOwn(undefEvents, map.id) || {};
            this.map = map;
            this.shim = getOwn(config.shim, map.id);
            this.depExports = [];
            this.depMaps = [];
            this.depMatched = [];
            this.pluginMaps = {};
            this.depCount = 0;

            /* this.exports this.factory
               this.depMaps = [],
               this.enabled, this.fetched
            */
        };

        Module.prototype = {
            init: function (depMaps, factory, errback, options) {
                options = options || {};

                //Do not do more inits if already done. Can happen if there
                //are multiple define calls for the same module. That is not
                //a normal, common case, but it is also not unexpected.
                if (this.inited) {
                    return;
                }

                this.factory = factory;

                if (errback) {
                    //Register for errors on this module.
                    this.on('error', errback);
                } else if (this.events.error) {
                    //If no errback already, but there are error listeners
                    //on this module, set up an errback to pass to the deps.
                    errback = bind(this, function (err) {
                        this.emit('error', err);
                    });
                }

                //Do a copy of the dependency array, so that
                //source inputs are not modified. For example
                //"shim" deps are passed in here directly, and
                //doing a direct modification of the depMaps array
                //would affect that config.
                this.depMaps = depMaps && depMaps.slice(0);

                this.errback = errback;

                //Indicate this module has be initialized
                this.inited = true;

                this.ignore = options.ignore;

                //Could have option to init this module in enabled mode,
                //or could have been previously marked as enabled. However,
                //the dependencies are not known until init is called. So
                //if enabled previously, now trigger dependencies as enabled.
                if (options.enabled || this.enabled) {
                    //Enable this module and dependencies.
                    //Will call this.check()
                    this.enable();
                } else {
                    this.check();
                }
            },

            defineDep: function (i, depExports) {
                //Because of cycles, defined callback for a given
                //export can be called more than once.
                if (!this.depMatched[i]) {
                    this.depMatched[i] = true;
                    this.depCount -= 1;
                    this.depExports[i] = depExports;
                }
            },

            fetch: function () {
                if (this.fetched) {
                    return;
                }
                this.fetched = true;

                context.startTime = (new Date()).getTime();

                var map = this.map;

                //If the manager is for a plugin managed resource,
                //ask the plugin to load it now.
                if (this.shim) {
                    context.makeRequire(this.map, {
                        enableBuildCallback: true
                    })(this.shim.deps || [], bind(this, function () {
                        return map.prefix ? this.callPlugin() : this.load();
                    }));
                } else {
                    //Regular dependency.
                    return map.prefix ? this.callPlugin() : this.load();
                }
            },

            load: function () {
                var url = this.map.url;

                //Regular dependency.
                if (!urlFetched[url]) {
                    urlFetched[url] = true;
                    context.load(this.map.id, url);
                }
            },

            /**
             * Checks if the module is ready to define itself, and if so,
             * define it.
             */
            check: function () {
                if (!this.enabled || this.enabling) {
                    return;
                }

                var err, cjsModule,
                    id = this.map.id,
                    depExports = this.depExports,
                    exports = this.exports,
                    factory = this.factory;

                if (!this.inited) {
                    // Only fetch if not already in the defQueue.
                    if (!hasProp(context.defQueueMap, id)) {
                        this.fetch();
                    }
                } else if (this.error) {
                    this.emit('error', this.error);
                } else if (!this.defining) {
                    //The factory could trigger another require call
                    //that would result in checking this module to
                    //define itself again. If already in the process
                    //of doing that, skip this work.
                    this.defining = true;

                    if (this.depCount < 1 && !this.defined) {
                        if (isFunction(factory)) {
                            //If there is an error listener, favor passing
                            //to that instead of throwing an error. However,
                            //only do it for define()'d  modules. require
                            //errbacks should not be called for failures in
                            //their callbacks (#699). However if a global
                            //onError is set, use that.
                            if ((this.events.error && this.map.isDefine) ||
                                req.onError !== defaultOnError) {
                                try {
                                    exports = context.execCb(id, factory, depExports, exports);
                                } catch (e) {
                                    err = e;
                                }
                            } else {
                                exports = context.execCb(id, factory, depExports, exports);
                            }

                            // Favor return value over exports. If node/cjs in play,
                            // then will not have a return value anyway. Favor
                            // module.exports assignment over exports object.
                            if (this.map.isDefine && exports === undefined) {
                                cjsModule = this.module;
                                if (cjsModule) {
                                    exports = cjsModule.exports;
                                } else if (this.usingExports) {
                                    //exports already set the defined value.
                                    exports = this.exports;
                                }
                            }

                            if (err) {
                                err.requireMap = this.map;
                                err.requireModules = this.map.isDefine ? [this.map.id] : null;
                                err.requireType = this.map.isDefine ? 'define' : 'require';
                                return onError((this.error = err));
                            }

                        } else {
                            //Just a literal value
                            exports = factory;
                        }

                        this.exports = exports;

                        if (this.map.isDefine && !this.ignore) {
                            defined[id] = exports;

                            if (req.onResourceLoad) {
                                var resLoadMaps = [];
                                each(this.depMaps, function (depMap) {
                                    resLoadMaps.push(depMap.normalizedMap || depMap);
                                });
                                req.onResourceLoad(context, this.map, resLoadMaps);
                            }
                        }

                        //Clean up
                        cleanRegistry(id);

                        this.defined = true;
                    }

                    //Finished the define stage. Allow calling check again
                    //to allow define notifications below in the case of a
                    //cycle.
                    this.defining = false;

                    if (this.defined && !this.defineEmitted) {
                        this.defineEmitted = true;
                        this.emit('defined', this.exports);
                        this.defineEmitComplete = true;
                    }

                }
            },

            callPlugin: function () {
                var map = this.map,
                    id = map.id,
                    //Map already normalized the prefix.
                    pluginMap = makeModuleMap(map.prefix);

                //Mark this as a dependency for this plugin, so it
                //can be traced for cycles.
                this.depMaps.push(pluginMap);

                on(pluginMap, 'defined', bind(this, function (plugin) {
                    var load, normalizedMap, normalizedMod,
                        bundleId = getOwn(bundlesMap, this.map.id),
                        name = this.map.name,
                        parentName = this.map.parentMap ? this.map.parentMap.name : null,
                        localRequire = context.makeRequire(map.parentMap, {
                            enableBuildCallback: true
                        });

                    //If current map is not normalized, wait for that
                    //normalized name to load instead of continuing.
                    if (this.map.unnormalized) {
                        //Normalize the ID if the plugin allows it.
                        if (plugin.normalize) {
                            name = plugin.normalize(name, function (name) {
                                return normalize(name, parentName, true);
                            }) || '';
                        }

                        //prefix and name should already be normalized, no need
                        //for applying map config again either.
                        normalizedMap = makeModuleMap(map.prefix + '!' + name,
                                                      this.map.parentMap,
                                                      true);
                        on(normalizedMap,
                            'defined', bind(this, function (value) {
                                this.map.normalizedMap = normalizedMap;
                                this.init([], function () { return value; }, null, {
                                    enabled: true,
                                    ignore: true
                                });
                            }));

                        normalizedMod = getOwn(registry, normalizedMap.id);
                        if (normalizedMod) {
                            //Mark this as a dependency for this plugin, so it
                            //can be traced for cycles.
                            this.depMaps.push(normalizedMap);

                            if (this.events.error) {
                                normalizedMod.on('error', bind(this, function (err) {
                                    this.emit('error', err);
                                }));
                            }
                            normalizedMod.enable();
                        }

                        return;
                    }

                    //If a paths config, then just load that file instead to
                    //resolve the plugin, as it is built into that paths layer.
                    if (bundleId) {
                        this.map.url = context.nameToUrl(bundleId);
                        this.load();
                        return;
                    }

                    load = bind(this, function (value) {
                        this.init([], function () { return value; }, null, {
                            enabled: true
                        });
                    });

                    load.error = bind(this, function (err) {
                        this.inited = true;
                        this.error = err;
                        err.requireModules = [id];

                        //Remove temp unnormalized modules for this module,
                        //since they will never be resolved otherwise now.
                        eachProp(registry, function (mod) {
                            if (mod.map.id.indexOf(id + '_unnormalized') === 0) {
                                cleanRegistry(mod.map.id);
                            }
                        });

                        onError(err);
                    });

                    //Allow plugins to load other code without having to know the
                    //context or how to 'complete' the load.
                    load.fromText = bind(this, function (text, textAlt) {
                        /*jslint evil: true */
                        var moduleName = map.name,
                            moduleMap = makeModuleMap(moduleName),
                            hasInteractive = useInteractive;

                        //As of 2.1.0, support just passing the text, to reinforce
                        //fromText only being called once per resource. Still
                        //support old style of passing moduleName but discard
                        //that moduleName in favor of the internal ref.
                        if (textAlt) {
                            text = textAlt;
                        }

                        //Turn off interactive script matching for IE for any define
                        //calls in the text, then turn it back on at the end.
                        if (hasInteractive) {
                            useInteractive = false;
                        }

                        //Prime the system by creating a module instance for
                        //it.
                        getModule(moduleMap);

                        //Transfer any config to this other module.
                        if (hasProp(config.config, id)) {
                            config.config[moduleName] = config.config[id];
                        }

                        try {
                            req.exec(text);
                        } catch (e) {
                            return onError(makeError('fromtexteval',
                                             'fromText eval for ' + id +
                                            ' failed: ' + e,
                                             e,
                                             [id]));
                        }

                        if (hasInteractive) {
                            useInteractive = true;
                        }

                        //Mark this as a dependency for the plugin
                        //resource
                        this.depMaps.push(moduleMap);

                        //Support anonymous modules.
                        context.completeLoad(moduleName);

                        //Bind the value of that module to the value for this
                        //resource ID.
                        localRequire([moduleName], load);
                    });

                    //Use parentName here since the plugin's name is not reliable,
                    //could be some weird string with no path that actually wants to
                    //reference the parentName's path.
                    plugin.load(map.name, localRequire, load, config);
                }));

                context.enable(pluginMap, this);
                this.pluginMaps[pluginMap.id] = pluginMap;
            },

            enable: function () {
                enabledRegistry[this.map.id] = this;
                this.enabled = true;

                //Set flag mentioning that the module is enabling,
                //so that immediate calls to the defined callbacks
                //for dependencies do not trigger inadvertent load
                //with the depCount still being zero.
                this.enabling = true;

                //Enable each dependency
                each(this.depMaps, bind(this, function (depMap, i) {
                    var id, mod, handler;

                    if (typeof depMap === 'string') {
                        //Dependency needs to be converted to a depMap
                        //and wired up to this module.
                        depMap = makeModuleMap(depMap,
                                               (this.map.isDefine ? this.map : this.map.parentMap),
                                               false,
                                               !this.skipMap);
                        this.depMaps[i] = depMap;

                        handler = getOwn(handlers, depMap.id);

                        if (handler) {
                            this.depExports[i] = handler(this);
                            return;
                        }

                        this.depCount += 1;

                        on(depMap, 'defined', bind(this, function (depExports) {
                            if (this.undefed) {
                                return;
                            }
                            this.defineDep(i, depExports);
                            this.check();
                        }));

                        if (this.errback) {
                            on(depMap, 'error', bind(this, this.errback));
                        } else if (this.events.error) {
                            // No direct errback on this module, but something
                            // else is listening for errors, so be sure to
                            // propagate the error correctly.
                            on(depMap, 'error', bind(this, function(err) {
                                this.emit('error', err);
                            }));
                        }
                    }

                    id = depMap.id;
                    mod = registry[id];

                    //Skip special modules like 'require', 'exports', 'module'
                    //Also, don't call enable if it is already enabled,
                    //important in circular dependency cases.
                    if (!hasProp(handlers, id) && mod && !mod.enabled) {
                        context.enable(depMap, this);
                    }
                }));

                //Enable each plugin that is used in
                //a dependency
                eachProp(this.pluginMaps, bind(this, function (pluginMap) {
                    var mod = getOwn(registry, pluginMap.id);
                    if (mod && !mod.enabled) {
                        context.enable(pluginMap, this);
                    }
                }));

                this.enabling = false;

                this.check();
            },

            on: function (name, cb) {
                var cbs = this.events[name];
                if (!cbs) {
                    cbs = this.events[name] = [];
                }
                cbs.push(cb);
            },

            emit: function (name, evt) {
                each(this.events[name], function (cb) {
                    cb(evt);
                });
                if (name === 'error') {
                    //Now that the error handler was triggered, remove
                    //the listeners, since this broken Module instance
                    //can stay around for a while in the registry.
                    delete this.events[name];
                }
            }
        };

        function callGetModule(args) {
            //Skip modules already defined.
            if (!hasProp(defined, args[0])) {
                getModule(makeModuleMap(args[0], null, true)).init(args[1], args[2]);
            }
        }

        function removeListener(node, func, name, ieName) {
            //Favor detachEvent because of IE9
            //issue, see attachEvent/addEventListener comment elsewhere
            //in this file.
            if (node.detachEvent && !isOpera) {
                //Probably IE. If not it will throw an error, which will be
                //useful to know.
                if (ieName) {
                    node.detachEvent(ieName, func);
                }
            } else {
                node.removeEventListener(name, func, false);
            }
        }

        /**
         * Given an event from a script node, get the requirejs info from it,
         * and then removes the event listeners on the node.
         * @param {Event} evt
         * @returns {Object}
         */
        function getScriptData(evt) {
            //Using currentTarget instead of target for Firefox 2.0's sake. Not
            //all old browsers will be supported, but this one was easy enough
            //to support and still makes sense.
            var node = evt.currentTarget || evt.srcElement;

            //Remove the listeners once here.
            removeListener(node, context.onScriptLoad, 'load', 'onreadystatechange');
            removeListener(node, context.onScriptError, 'error');

            return {
                node: node,
                id: node && node.getAttribute('data-requiremodule')
            };
        }

        function intakeDefines() {
            var args;

            //Any defined modules in the global queue, intake them now.
            takeGlobalQueue();

            //Make sure any remaining defQueue items get properly processed.
            while (defQueue.length) {
                args = defQueue.shift();
                if (args[0] === null) {
                    return onError(makeError('mismatch', 'Mismatched anonymous define() module: ' +
                        args[args.length - 1]));
                } else {
                    //args are id, deps, factory. Should be normalized by the
                    //define() function.
                    callGetModule(args);
                }
            }
            context.defQueueMap = {};
        }

        context = {
            config: config,
            contextName: contextName,
            registry: registry,
            defined: defined,
            urlFetched: urlFetched,
            defQueue: defQueue,
            defQueueMap: {},
            Module: Module,
            makeModuleMap: makeModuleMap,
            nextTick: req.nextTick,
            onError: onError,

            /**
             * Set a configuration for the context.
             * @param {Object} cfg config object to integrate.
             */
            configure: function (cfg) {
                //Make sure the baseUrl ends in a slash.
                if (cfg.baseUrl) {
                    if (cfg.baseUrl.charAt(cfg.baseUrl.length - 1) !== '/') {
                        cfg.baseUrl += '/';
                    }
                }

                // Convert old style urlArgs string to a function.
                if (typeof cfg.urlArgs === 'string') {
                    var urlArgs = cfg.urlArgs;
                    cfg.urlArgs = function(id, url) {
                        return (url.indexOf('?') === -1 ? '?' : '&') + urlArgs;
                    };
                }

                //Save off the paths since they require special processing,
                //they are additive.
                var shim = config.shim,
                    objs = {
                        paths: true,
                        bundles: true,
                        config: true,
                        map: true
                    };

                eachProp(cfg, function (value, prop) {
                    if (objs[prop]) {
                        if (!config[prop]) {
                            config[prop] = {};
                        }
                        mixin(config[prop], value, true, true);
                    } else {
                        config[prop] = value;
                    }
                });

                //Reverse map the bundles
                if (cfg.bundles) {
                    eachProp(cfg.bundles, function (value, prop) {
                        each(value, function (v) {
                            if (v !== prop) {
                                bundlesMap[v] = prop;
                            }
                        });
                    });
                }

                //Merge shim
                if (cfg.shim) {
                    eachProp(cfg.shim, function (value, id) {
                        //Normalize the structure
                        if (isArray(value)) {
                            value = {
                                deps: value
                            };
                        }
                        if ((value.exports || value.init) && !value.exportsFn) {
                            value.exportsFn = context.makeShimExports(value);
                        }
                        shim[id] = value;
                    });
                    config.shim = shim;
                }

                //Adjust packages if necessary.
                if (cfg.packages) {
                    each(cfg.packages, function (pkgObj) {
                        var location, name;

                        pkgObj = typeof pkgObj === 'string' ? {name: pkgObj} : pkgObj;

                        name = pkgObj.name;
                        location = pkgObj.location;
                        if (location) {
                            config.paths[name] = pkgObj.location;
                        }

                        //Save pointer to main module ID for pkg name.
                        //Remove leading dot in main, so main paths are normalized,
                        //and remove any trailing .js, since different package
                        //envs have different conventions: some use a module name,
                        //some use a file name.
                        config.pkgs[name] = pkgObj.name + '/' + (pkgObj.main || 'main')
                                     .replace(currDirRegExp, '')
                                     .replace(jsSuffixRegExp, '');
                    });
                }

                //If there are any "waiting to execute" modules in the registry,
                //update the maps for them, since their info, like URLs to load,
                //may have changed.
                eachProp(registry, function (mod, id) {
                    //If module already has init called, since it is too
                    //late to modify them, and ignore unnormalized ones
                    //since they are transient.
                    if (!mod.inited && !mod.map.unnormalized) {
                        mod.map = makeModuleMap(id, null, true);
                    }
                });

                //If a deps array or a config callback is specified, then call
                //require with those args. This is useful when require is defined as a
                //config object before require.js is loaded.
                if (cfg.deps || cfg.callback) {
                    context.require(cfg.deps || [], cfg.callback);
                }
            },

            makeShimExports: function (value) {
                function fn() {
                    var ret;
                    if (value.init) {
                        ret = value.init.apply(global, arguments);
                    }
                    return ret || (value.exports && getGlobal(value.exports));
                }
                return fn;
            },

            makeRequire: function (relMap, options) {
                options = options || {};

                function localRequire(deps, callback, errback) {
                    var id, map, requireMod;

                    if (options.enableBuildCallback && callback && isFunction(callback)) {
                        callback.__requireJsBuild = true;
                    }

                    if (typeof deps === 'string') {
                        if (isFunction(callback)) {
                            //Invalid call
                            return onError(makeError('requireargs', 'Invalid require call'), errback);
                        }

                        //If require|exports|module are requested, get the
                        //value for them from the special handlers. Caveat:
                        //this only works while module is being defined.
                        if (relMap && hasProp(handlers, deps)) {
                            return handlers[deps](registry[relMap.id]);
                        }

                        //Synchronous access to one module. If require.get is
                        //available (as in the Node adapter), prefer that.
                        if (req.get) {
                            return req.get(context, deps, relMap, localRequire);
                        }

                        //Normalize module name, if it contains . or ..
                        map = makeModuleMap(deps, relMap, false, true);
                        id = map.id;

                        if (!hasProp(defined, id)) {
                            return onError(makeError('notloaded', 'Module name "' +
                                        id +
                                        '" has not been loaded yet for context: ' +
                                        contextName +
                                        (relMap ? '' : '. Use require([])')));
                        }
                        return defined[id];
                    }

                    //Grab defines waiting in the global queue.
                    intakeDefines();

                    //Mark all the dependencies as needing to be loaded.
                    context.nextTick(function () {
                        //Some defines could have been added since the
                        //require call, collect them.
                        intakeDefines();

                        requireMod = getModule(makeModuleMap(null, relMap));

                        //Store if map config should be applied to this require
                        //call for dependencies.
                        requireMod.skipMap = options.skipMap;

                        requireMod.init(deps, callback, errback, {
                            enabled: true
                        });

                        checkLoaded();
                    });

                    return localRequire;
                }

                mixin(localRequire, {
                    isBrowser: isBrowser,

                    /**
                     * Converts a module name + .extension into an URL path.
                     * *Requires* the use of a module name. It does not support using
                     * plain URLs like nameToUrl.
                     */
                    toUrl: function (moduleNamePlusExt) {
                        var ext,
                            index = moduleNamePlusExt.lastIndexOf('.'),
                            segment = moduleNamePlusExt.split('/')[0],
                            isRelative = segment === '.' || segment === '..';

                        //Have a file extension alias, and it is not the
                        //dots from a relative path.
                        if (index !== -1 && (!isRelative || index > 1)) {
                            ext = moduleNamePlusExt.substring(index, moduleNamePlusExt.length);
                            moduleNamePlusExt = moduleNamePlusExt.substring(0, index);
                        }

                        return context.nameToUrl(normalize(moduleNamePlusExt,
                                                relMap && relMap.id, true), ext,  true);
                    },

                    defined: function (id) {
                        return hasProp(defined, makeModuleMap(id, relMap, false, true).id);
                    },

                    specified: function (id) {
                        id = makeModuleMap(id, relMap, false, true).id;
                        return hasProp(defined, id) || hasProp(registry, id);
                    }
                });

                //Only allow undef on top level require calls
                if (!relMap) {
                    localRequire.undef = function (id) {
                        //Bind any waiting define() calls to this context,
                        //fix for #408
                        takeGlobalQueue();

                        var map = makeModuleMap(id, relMap, true),
                            mod = getOwn(registry, id);

                        mod.undefed = true;
                        removeScript(id);

                        delete defined[id];
                        delete urlFetched[map.url];
                        delete undefEvents[id];

                        //Clean queued defines too. Go backwards
                        //in array so that the splices do not
                        //mess up the iteration.
                        eachReverse(defQueue, function(args, i) {
                            if (args[0] === id) {
                                defQueue.splice(i, 1);
                            }
                        });
                        delete context.defQueueMap[id];

                        if (mod) {
                            //Hold on to listeners in case the
                            //module will be attempted to be reloaded
                            //using a different config.
                            if (mod.events.defined) {
                                undefEvents[id] = mod.events;
                            }

                            cleanRegistry(id);
                        }
                    };
                }

                return localRequire;
            },

            /**
             * Called to enable a module if it is still in the registry
             * awaiting enablement. A second arg, parent, the parent module,
             * is passed in for context, when this method is overridden by
             * the optimizer. Not shown here to keep code compact.
             */
            enable: function (depMap) {
                var mod = getOwn(registry, depMap.id);
                if (mod) {
                    getModule(depMap).enable();
                }
            },

            /**
             * Internal method used by environment adapters to complete a load event.
             * A load event could be a script load or just a load pass from a synchronous
             * load call.
             * @param {String} moduleName the name of the module to potentially complete.
             */
            completeLoad: function (moduleName) {
                var found, args, mod,
                    shim = getOwn(config.shim, moduleName) || {},
                    shExports = shim.exports;

                takeGlobalQueue();

                while (defQueue.length) {
                    args = defQueue.shift();
                    if (args[0] === null) {
                        args[0] = moduleName;
                        //If already found an anonymous module and bound it
                        //to this name, then this is some other anon module
                        //waiting for its completeLoad to fire.
                        if (found) {
                            break;
                        }
                        found = true;
                    } else if (args[0] === moduleName) {
                        //Found matching define call for this script!
                        found = true;
                    }

                    callGetModule(args);
                }
                context.defQueueMap = {};

                //Do this after the cycle of callGetModule in case the result
                //of those calls/init calls changes the registry.
                mod = getOwn(registry, moduleName);

                if (!found && !hasProp(defined, moduleName) && mod && !mod.inited) {
                    if (config.enforceDefine && (!shExports || !getGlobal(shExports))) {
                        if (hasPathFallback(moduleName)) {
                            return;
                        } else {
                            return onError(makeError('nodefine',
                                             'No define call for ' + moduleName,
                                             null,
                                             [moduleName]));
                        }
                    } else {
                        //A script that does not call define(), so just simulate
                        //the call for it.
                        callGetModule([moduleName, (shim.deps || []), shim.exportsFn]);
                    }
                }

                checkLoaded();
            },

            /**
             * Converts a module name to a file path. Supports cases where
             * moduleName may actually be just an URL.
             * Note that it **does not** call normalize on the moduleName,
             * it is assumed to have already been normalized. This is an
             * internal API, not a public one. Use toUrl for the public API.
             */
            nameToUrl: function (moduleName, ext, skipExt) {
                var paths, syms, i, parentModule, url,
                    parentPath, bundleId,
                    pkgMain = getOwn(config.pkgs, moduleName);

                if (pkgMain) {
                    moduleName = pkgMain;
                }

                bundleId = getOwn(bundlesMap, moduleName);

                if (bundleId) {
                    return context.nameToUrl(bundleId, ext, skipExt);
                }

                //If a colon is in the URL, it indicates a protocol is used and it is just
                //an URL to a file, or if it starts with a slash, contains a query arg (i.e. ?)
                //or ends with .js, then assume the user meant to use an url and not a module id.
                //The slash is important for protocol-less URLs as well as full paths.
                if (req.jsExtRegExp.test(moduleName)) {
                    //Just a plain path, not module name lookup, so just return it.
                    //Add extension if it is included. This is a bit wonky, only non-.js things pass
                    //an extension, this method probably needs to be reworked.
                    url = moduleName + (ext || '');
                } else {
                    //A module that needs to be converted to a path.
                    paths = config.paths;

                    syms = moduleName.split('/');
                    //For each module name segment, see if there is a path
                    //registered for it. Start with most specific name
                    //and work up from it.
                    for (i = syms.length; i > 0; i -= 1) {
                        parentModule = syms.slice(0, i).join('/');

                        parentPath = getOwn(paths, parentModule);
                        if (parentPath) {
                            //If an array, it means there are a few choices,
                            //Choose the one that is desired
                            if (isArray(parentPath)) {
                                parentPath = parentPath[0];
                            }
                            syms.splice(0, i, parentPath);
                            break;
                        }
                    }

                    //Join the path parts together, then figure out if baseUrl is needed.
                    url = syms.join('/');
                    url += (ext || (/^data\:|^blob\:|\?/.test(url) || skipExt ? '' : '.js'));
                    url = (url.charAt(0) === '/' || url.match(/^[\w\+\.\-]+:/) ? '' : config.baseUrl) + url;
                }

                return config.urlArgs && !/^blob\:/.test(url) ?
                       url + config.urlArgs(moduleName, url) : url;
            },

            //Delegates to req.load. Broken out as a separate function to
            //allow overriding in the optimizer.
            load: function (id, url) {
                req.load(context, id, url);
            },

            /**
             * Executes a module callback function. Broken out as a separate function
             * solely to allow the build system to sequence the files in the built
             * layer in the right sequence.
             *
             * @private
             */
            execCb: function (name, callback, args, exports) {
                return callback.apply(exports, args);
            },

            /**
             * callback for script loads, used to check status of loading.
             *
             * @param {Event} evt the event from the browser for the script
             * that was loaded.
             */
            onScriptLoad: function (evt) {
                //Using currentTarget instead of target for Firefox 2.0's sake. Not
                //all old browsers will be supported, but this one was easy enough
                //to support and still makes sense.
                if (evt.type === 'load' ||
                        (readyRegExp.test((evt.currentTarget || evt.srcElement).readyState))) {
                    //Reset interactive script so a script node is not held onto for
                    //to long.
                    interactiveScript = null;

                    //Pull out the name of the module and the context.
                    var data = getScriptData(evt);
                    context.completeLoad(data.id);
                }
            },

            /**
             * Callback for script errors.
             */
            onScriptError: function (evt) {
                var data = getScriptData(evt);
                if (!hasPathFallback(data.id)) {
                    var parents = [];
                    eachProp(registry, function(value, key) {
                        if (key.indexOf('_@r') !== 0) {
                            each(value.depMaps, function(depMap) {
                                if (depMap.id === data.id) {
                                    parents.push(key);
                                    return true;
                                }
                            });
                        }
                    });
                    return onError(makeError('scripterror', 'Script error for "' + data.id +
                                             (parents.length ?
                                             '", needed by: ' + parents.join(', ') :
                                             '"'), evt, [data.id]));
                }
            }
        };

        context.require = context.makeRequire();
        return context;
    }

    /**
     * Main entry point.
     *
     * If the only argument to require is a string, then the module that
     * is represented by that string is fetched for the appropriate context.
     *
     * If the first argument is an array, then it will be treated as an array
     * of dependency string names to fetch. An optional function callback can
     * be specified to execute when all of those dependencies are available.
     *
     * Make a local req variable to help Caja compliance (it assumes things
     * on a require that are not standardized), and to give a short
     * name for minification/local scope use.
     */
    req = requirejs = function (deps, callback, errback, optional) {

        //Find the right context, use default
        var context, config,
            contextName = defContextName;

        // Determine if have config object in the call.
        if (!isArray(deps) && typeof deps !== 'string') {
            // deps is a config object
            config = deps;
            if (isArray(callback)) {
                // Adjust args if there are dependencies
                deps = callback;
                callback = errback;
                errback = optional;
            } else {
                deps = [];
            }
        }

        if (config && config.context) {
            contextName = config.context;
        }

        context = getOwn(contexts, contextName);
        if (!context) {
            context = contexts[contextName] = req.s.newContext(contextName);
        }

        if (config) {
            context.configure(config);
        }

        return context.require(deps, callback, errback);
    };

    /**
     * Support require.config() to make it easier to cooperate with other
     * AMD loaders on globally agreed names.
     */
    req.config = function (config) {
        return req(config);
    };

    /**
     * Execute something after the current tick
     * of the event loop. Override for other envs
     * that have a better solution than setTimeout.
     * @param  {Function} fn function to execute later.
     */
    req.nextTick = typeof setTimeout !== 'undefined' ? function (fn) {
        setTimeout(fn, 4);
    } : function (fn) { fn(); };

    /**
     * Export require as a global, but only if it does not already exist.
     */
    if (!require) {
        require = req;
    }

    req.version = version;

    //Used to filter out dependencies that are already paths.
    req.jsExtRegExp = /^\/|:|\?|\.js$/;
    req.isBrowser = isBrowser;
    s = req.s = {
        contexts: contexts,
        newContext: newContext
    };

    //Create default context.
    req({});

    //Exports some context-sensitive methods on global require.
    each([
        'toUrl',
        'undef',
        'defined',
        'specified'
    ], function (prop) {
        //Reference from contexts instead of early binding to default context,
        //so that during builds, the latest instance of the default context
        //with its config gets used.
        req[prop] = function () {
            var ctx = contexts[defContextName];
            return ctx.require[prop].apply(ctx, arguments);
        };
    });

    if (isBrowser) {
        head = s.head = document.getElementsByTagName('head')[0];
        //If BASE tag is in play, using appendChild is a problem for IE6.
        //When that browser dies, this can be removed. Details in this jQuery bug:
        //http://dev.jquery.com/ticket/2709
        baseElement = document.getElementsByTagName('base')[0];
        if (baseElement) {
            head = s.head = baseElement.parentNode;
        }
    }

    /**
     * Any errors that require explicitly generates will be passed to this
     * function. Intercept/override it if you want custom error handling.
     * @param {Error} err the error object.
     */
    req.onError = defaultOnError;

    /**
     * Creates the node for the load command. Only used in browser envs.
     */
    req.createNode = function (config, moduleName, url) {
        var node = config.xhtml ?
                document.createElementNS('http://www.w3.org/1999/xhtml', 'html:script') :
                document.createElement('script');
        node.type = config.scriptType || 'text/javascript';
        node.charset = 'utf-8';
        node.async = true;
        return node;
    };

    /**
     * Does the request to load a module for the browser case.
     * Make this a separate function to allow other environments
     * to override it.
     *
     * @param {Object} context the require context to find state.
     * @param {String} moduleName the name of the module.
     * @param {Object} url the URL to the module.
     */
    req.load = function (context, moduleName, url) {
        var config = (context && context.config) || {},
            node;
        if (isBrowser) {
            //In the browser so use a script tag
            node = req.createNode(config, moduleName, url);

            node.setAttribute('data-requirecontext', context.contextName);
            node.setAttribute('data-requiremodule', moduleName);

            //Set up load listener. Test attachEvent first because IE9 has
            //a subtle issue in its addEventListener and script onload firings
            //that do not match the behavior of all other browsers with
            //addEventListener support, which fire the onload event for a
            //script right after the script execution. See:
            //https://connect.microsoft.com/IE/feedback/details/648057/script-onload-event-is-not-fired-immediately-after-script-execution
            //UNFORTUNATELY Opera implements attachEvent but does not follow the script
            //script execution mode.
            if (node.attachEvent &&
                    //Check if node.attachEvent is artificially added by custom script or
                    //natively supported by browser
                    //read https://github.com/requirejs/requirejs/issues/187
                    //if we can NOT find [native code] then it must NOT natively supported.
                    //in IE8, node.attachEvent does not have toString()
                    //Note the test for "[native code" with no closing brace, see:
                    //https://github.com/requirejs/requirejs/issues/273
                    !(node.attachEvent.toString && node.attachEvent.toString().indexOf('[native code') < 0) &&
                    !isOpera) {
                //Probably IE. IE (at least 6-8) do not fire
                //script onload right after executing the script, so
                //we cannot tie the anonymous define call to a name.
                //However, IE reports the script as being in 'interactive'
                //readyState at the time of the define call.
                useInteractive = true;

                node.attachEvent('onreadystatechange', context.onScriptLoad);
                //It would be great to add an error handler here to catch
                //404s in IE9+. However, onreadystatechange will fire before
                //the error handler, so that does not help. If addEventListener
                //is used, then IE will fire error before load, but we cannot
                //use that pathway given the connect.microsoft.com issue
                //mentioned above about not doing the 'script execute,
                //then fire the script load event listener before execute
                //next script' that other browsers do.
                //Best hope: IE10 fixes the issues,
                //and then destroys all installs of IE 6-9.
                //node.attachEvent('onerror', context.onScriptError);
            } else {
                node.addEventListener('load', context.onScriptLoad, false);
                node.addEventListener('error', context.onScriptError, false);
            }
            node.src = url;

            //Calling onNodeCreated after all properties on the node have been
            //set, but before it is placed in the DOM.
            if (config.onNodeCreated) {
                config.onNodeCreated(node, config, moduleName, url);
            }

            //For some cache cases in IE 6-8, the script executes before the end
            //of the appendChild execution, so to tie an anonymous define
            //call to the module name (which is stored on the node), hold on
            //to a reference to this node, but clear after the DOM insertion.
            currentlyAddingScript = node;
            if (baseElement) {
                head.insertBefore(node, baseElement);
            } else {
                head.appendChild(node);
            }
            currentlyAddingScript = null;

            return node;
        } else if (isWebWorker) {
            try {
                //In a web worker, use importScripts. This is not a very
                //efficient use of importScripts, importScripts will block until
                //its script is downloaded and evaluated. However, if web workers
                //are in play, the expectation is that a build has been done so
                //that only one script needs to be loaded anyway. This may need
                //to be reevaluated if other use cases become common.

                // Post a task to the event loop to work around a bug in WebKit
                // where the worker gets garbage-collected after calling
                // importScripts(): https://webkit.org/b/153317
                setTimeout(function() {}, 0);
                importScripts(url);

                //Account for anonymous modules
                context.completeLoad(moduleName);
            } catch (e) {
                context.onError(makeError('importscripts',
                                'importScripts failed for ' +
                                    moduleName + ' at ' + url,
                                e,
                                [moduleName]));
            }
        }
    };

    function getInteractiveScript() {
        if (interactiveScript && interactiveScript.readyState === 'interactive') {
            return interactiveScript;
        }

        eachReverse(scripts(), function (script) {
            if (script.readyState === 'interactive') {
                return (interactiveScript = script);
            }
        });
        return interactiveScript;
    }

    //Look for a data-main script attribute, which could also adjust the baseUrl.
    if (isBrowser && !cfg.skipDataMain) {
        //Figure out baseUrl. Get it from the script tag with require.js in it.
        eachReverse(scripts(), function (script) {
            //Set the 'head' where we can append children by
            //using the script's parent.
            if (!head) {
                head = script.parentNode;
            }

            //Look for a data-main attribute to set main script for the page
            //to load. If it is there, the path to data main becomes the
            //baseUrl, if it is not already set.
            dataMain = script.getAttribute('data-main');
            if (dataMain) {
                //Preserve dataMain in case it is a path (i.e. contains '?')
                mainScript = dataMain;

                //Set final baseUrl if there is not already an explicit one,
                //but only do so if the data-main value is not a loader plugin
                //module ID.
                if (!cfg.baseUrl && mainScript.indexOf('!') === -1) {
                    //Pull off the directory of data-main for use as the
                    //baseUrl.
                    src = mainScript.split('/');
                    mainScript = src.pop();
                    subPath = src.length ? src.join('/')  + '/' : './';

                    cfg.baseUrl = subPath;
                }

                //Strip off any trailing .js since mainScript is now
                //like a module name.
                mainScript = mainScript.replace(jsSuffixRegExp, '');

                //If mainScript is still a path, fall back to dataMain
                if (req.jsExtRegExp.test(mainScript)) {
                    mainScript = dataMain;
                }

                //Put the data-main script in the files to load.
                cfg.deps = cfg.deps ? cfg.deps.concat(mainScript) : [mainScript];

                return true;
            }
        });
    }

    /**
     * The function that handles definitions of modules. Differs from
     * require() in that a string for the module should be the first argument,
     * and the function to execute after dependencies are loaded should
     * return a value to define the module corresponding to the first argument's
     * name.
     */
    define = function (name, deps, callback) {
        var node, context;

        //Allow for anonymous modules
        if (typeof name !== 'string') {
            //Adjust args appropriately
            callback = deps;
            deps = name;
            name = null;
        }

        //This module may not have dependencies
        if (!isArray(deps)) {
            callback = deps;
            deps = null;
        }

        //If no name, and callback is a function, then figure out if it a
        //CommonJS thing with dependencies.
        if (!deps && isFunction(callback)) {
            deps = [];
            //Remove comments from the callback string,
            //look for require calls, and pull them into the dependencies,
            //but only if there are function args.
            if (callback.length) {
                callback
                    .toString()
                    .replace(commentRegExp, commentReplace)
                    .replace(cjsRequireRegExp, function (match, dep) {
                        deps.push(dep);
                    });

                //May be a CommonJS thing even without require calls, but still
                //could use exports, and module. Avoid doing exports and module
                //work though if it just needs require.
                //REQUIRES the function to expect the CommonJS variables in the
                //order listed below.
                deps = (callback.length === 1 ? ['require'] : ['require', 'exports', 'module']).concat(deps);
            }
        }

        //If in IE 6-8 and hit an anonymous define() call, do the interactive
        //work.
        if (useInteractive) {
            node = currentlyAddingScript || getInteractiveScript();
            if (node) {
                if (!name) {
                    name = node.getAttribute('data-requiremodule');
                }
                context = contexts[node.getAttribute('data-requirecontext')];
            }
        }

        //Always save off evaluating the def call until the script onload handler.
        //This allows multiple modules to be in a file without prematurely
        //tracing dependencies, and allows for anonymous module support,
        //where the module name is not known until the script onload event
        //occurs. If no context, use the global queue, and get it processed
        //in the onscript load callback.
        if (context) {
            context.defQueue.push([name, deps, callback]);
            context.defQueueMap[name] = true;
        } else {
            globalDefQueue.push([name, deps, callback]);
        }
    };

    define.amd = {
        jQuery: true
    };

    /**
     * Executes the text. Normally just uses eval, but can be modified
     * to use a better, environment-specific call. Only used for transpiling
     * loader plugins, not for plain JS modules.
     * @param {String} text the text to execute/evaluate.
     */
    req.exec = function (text) {
        /*jslint evil: true */
        return eval(text);
    };

    //Set up with config info.
    req(cfg);
}(this, (typeof setTimeout === 'undefined' ? undefined : setTimeout)));

", + "ok": true, + "headers": [ + [ + "content-type", + "text/javascript; charset=utf-8" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6006/icon_bundle.svg": { + "data": "<?xml version="1.0" ?><svg><defs><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="add_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M19 13h-6v6h-2v-6H5v-2h6V5h2v6h6v2z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="arrow_back_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M20 11H7.83l5.59-5.59L12 4l-8 8 8 8 1.41-1.41L7.83 13H20v-2z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="arrow_downward_24px"><path fill="#010101" d="M20 12l-1.41-1.41L13 16.17V4h-2v12.17l-5.58-5.59L4 12l8 8 8-8z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="arrow_forward_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M12 4l-1.41 1.41L16.17 11H4v2h12.17l-5.58 5.59L12 20l8-8z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="arrow_upward_24px"><path d="M4 12l1.41 1.41L11 7.83V20h2V7.83l5.58 5.59L20 12l-8-8-8 8z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="brightness_6_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M20 15.31L23.31 12 20 8.69V4h-4.69L12 .69 8.69 4H4v4.69L.69 12 4 15.31V20h4.69L12 23.31 15.31 20H20v-4.69zM12 18V6c3.31 0 6 2.69 6 6s-2.69 6-6 6z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="bug_report_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M20 8h-2.81c-.45-.78-1.07-1.45-1.82-1.96L17 4.41 15.59 3l-2.17 2.17C12.96 5.06 12.49 5 12 5c-.49 0-.96.06-1.41.17L8.41 3 7 4.41l1.62 1.63C7.88 6.55 7.26 7.22 6.81 8H4v2h2.09c-.05.33-.09.66-.09 1v1H4v2h2v1c0 .34.04.67.09 1H4v2h2.81c1.04 1.79 2.97 3 5.19 3s4.15-1.21 5.19-3H20v-2h-2.09c.05-.33.09-.66.09-1v-1h2v-2h-2v-1c0-.34-.04-.67-.09-1H20V8zm-6 8h-4v-2h4v2zm0-4h-4v-2h4v2z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="cancel_24px"><path d="M12 2C6.47 2 2 6.47 2 12s4.47 10 10 10 10-4.47 10-10S17.53 2 12 2zm5 13.59L15.59 17 12 13.41 8.41 17 7 15.59 10.59 12 7 8.41 8.41 7 12 10.59 15.59 7 17 8.41 13.41 12 17 15.59z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="change_history_24px"><path d="M12 7.77L18.39 18H5.61L12 7.77M12 4L2 20h20L12 4z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="chevron_left_24px"><path d="M15.41 7.41L14 6l-6 6 6 6 1.41-1.41L10.83 12z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="chevron_right_24px"><path d="M10 6L8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="clear_24px"><path d="M19 6.41L17.59 5 12 10.59 6.41 5 5 6.41 10.59 12 5 17.59 6.41 19 12 13.41 17.59 19 19 17.59 13.41 12z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="close_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M19 6.41L17.59 5 12 10.59 6.41 5 5 6.41 10.59 12 5 17.59 6.41 19 12 13.41 17.59 19 19 17.59 13.41 12z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="content_copy_24px"><path d="M16 1H4c-1.1 0-2 .9-2 2v14h2V3h12V1zm3 4H8c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h11c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2zm0 16H8V7h11v14z"/></svg><svg xmlns="http://www.w3.org/2000/svg" enable-background="new 0 0 24 24" height="24" viewBox="0 0 24 24" width="24" id="dark_mode_24px"><rect fill="none" height="24" width="24"/><path d="M12,3c-4.97,0-9,4.03-9,9s4.03,9,9,9s9-4.03,9-9c0-0.46-0.04-0.92-0.1-1.36c-0.98,1.37-2.58,2.26-4.4,2.26 c-2.98,0-5.4-2.42-5.4-5.4c0-1.81,0.89-3.42,2.26-4.4C12.92,3.04,12.46,3,12,3L12,3z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="done_24px"><path d="M9 16.2L4.8 12l-1.4 1.4L9 19 21 7l-1.4-1.4L9 16.2z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="drag_indicator_24px"><path d="M0 0h24v24H0V0z" fill="none"/><path d="M11 18c0 1.1-.9 2-2 2s-2-.9-2-2 .9-2 2-2 2 .9 2 2zm-2-8c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm0-6c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm6 4c1.1 0 2-.9 2-2s-.9-2-2-2-2 .9-2 2 .9 2 2 2zm0 2c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm0 6c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="edit_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M3 17.25V21h3.75L17.81 9.94l-3.75-3.75L3 17.25zM20.71 7.04c.39-.39.39-1.02 0-1.41l-2.34-2.34c-.39-.39-1.02-.39-1.41 0l-1.83 1.83 3.75 3.75 1.83-1.83z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="error_24px"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm1 15h-2v-2h2v2zm0-4h-2V7h2v6z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="expand_less_24px"><path d="M12 8l-6 6 1.41 1.41L12 10.83l4.59 4.58L18 14z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="expand_more_24px"><path d="M16.59 8.59L12 13.17 7.41 8.59 6 10l6 6 6-6z"/></svg><svg xmlns="http://www.w3.org/2000/svg" enable-background="new 0 0 24 24" height="24" viewBox="0 0 24 24" width="24" id="filter_alt_24px"><g><path d="M0,0h24 M24,24H0" fill="none"/><path d="M4.25,5.61C6.27,8.2,10,13,10,13v6c0,0.55,0.45,1,1,1h2c0.55,0,1-0.45,1-1v-6c0,0,3.72-4.8,5.74-7.39 C20.25,4.95,19.78,4,18.95,4H5.04C4.21,4,3.74,4.95,4.25,5.61z"/><path d="M0,0h24v24H0V0z" fill="none"/></g></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="flag_24px"><path d="M14.4 6L14 4H5v17h2v-7h5.6l.4 2h7V6z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="fullscreen_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M7 14H5v5h5v-2H7v-3zm-2-4h2V7h3V5H5v5zm12 7h-3v2h5v-5h-2v3zM14 5v2h3v3h2V5h-5z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="fullscreen_exit_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M5 16h3v3h2v-5H5v2zm3-8H5v2h5V5H8v3zm6 11h2v-3h3v-2h-5v5zm2-11V5h-2v5h5V8h-3z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="get_app_24px"><path d="M19 9h-4V3H9v6H5l7 7 7-7zM5 18v2h14v-2H5z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="group_work_24px"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zM8 17.5c-1.38 0-2.5-1.12-2.5-2.5s1.12-2.5 2.5-2.5 2.5 1.12 2.5 2.5-1.12 2.5-2.5 2.5zM9.5 8c0-1.38 1.12-2.5 2.5-2.5s2.5 1.12 2.5 2.5-1.12 2.5-2.5 2.5S9.5 9.38 9.5 8zm6.5 9.5c-1.38 0-2.5-1.12-2.5-2.5s1.12-2.5 2.5-2.5 2.5 1.12 2.5 2.5-1.12 2.5-2.5 2.5z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="help_outline_24px"><path d="M11 18h2v-2h-2v2zm1-16C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8zm0-14c-2.21 0-4 1.79-4 4h2c0-1.1.9-2 2-2s2 .9 2 2c0 2-3 1.75-3 5h2c0-2.25 3-2.5 3-5 0-2.21-1.79-4-4-4z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="image_search_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M0 0h24v24H0V0z" fill="none"/><path d="M18 13v7H4V6h5.02c.05-.71.22-1.38.48-2H4c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2v-5l-2-2zm-1.5 5h-11l2.75-3.53 1.96 2.36 2.75-3.54zm2.8-9.11c.44-.7.7-1.51.7-2.39C20 4.01 17.99 2 15.5 2S11 4.01 11 6.5s2.01 4.5 4.49 4.5c.88 0 1.7-.26 2.39-.7L21 13.42 22.42 12 19.3 8.89zM15.5 9C14.12 9 13 7.88 13 6.5S14.12 4 15.5 4 18 5.12 18 6.5 16.88 9 15.5 9z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="info_outline_24px"><path d="M11 17h2v-6h-2v6zm1-15C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8zM11 9h2V7h-2v2z"/></svg><svg xmlns="http://www.w3.org/2000/svg" enable-background="new 0 0 24 24" height="24" viewBox="0 0 24 24" width="24" id="keep_24px"><g><rect fill="none" height="24" width="24"/></g><g><path d="M16,9V4l1,0c0.55,0,1-0.45,1-1v0c0-0.55-0.45-1-1-1H7C6.45,2,6,2.45,6,3v0 c0,0.55,0.45,1,1,1l1,0v5c0,1.66-1.34,3-3,3h0v2h5.97v7l1,1l1-1v-7H19v-2h0C17.34,12,16,10.66,16,9z" fill-rule="evenodd"/></g></svg><svg xmlns="http://www.w3.org/2000/svg" enable-background="new 0 0 24 24" height="24" viewBox="0 0 24 24" width="24" id="keep_outline_24px"><g><rect fill="none" height="24" width="24"/></g><g><path d="M14,4v5c0,1.12,0.37,2.16,1,3H9c0.65-0.86,1-1.9,1-3V4H14 M17,2H7C6.45,2,6,2.45,6,3c0,0.55,0.45,1,1,1c0,0,0,0,0,0l1,0v5 c0,1.66-1.34,3-3,3v2h5.97v7l1,1l1-1v-7H19v-2c0,0,0,0,0,0c-1.66,0-3-1.34-3-3V4l1,0c0,0,0,0,0,0c0.55,0,1-0.45,1-1 C18,2.45,17.55,2,17,2L17,2z"/></g></svg><svg xmlns="http://www.w3.org/2000/svg" enable-background="new 0 0 24 24" height="24" viewBox="0 0 24 24" width="24" id="light_mode_24px"><rect fill="none" height="24" width="24"/><path d="M12,7c-2.76,0-5,2.24-5,5s2.24,5,5,5s5-2.24,5-5S14.76,7,12,7L12,7z M2,13l2,0c0.55,0,1-0.45,1-1s-0.45-1-1-1l-2,0 c-0.55,0-1,0.45-1,1S1.45,13,2,13z M20,13l2,0c0.55,0,1-0.45,1-1s-0.45-1-1-1l-2,0c-0.55,0-1,0.45-1,1S19.45,13,20,13z M11,2v2 c0,0.55,0.45,1,1,1s1-0.45,1-1V2c0-0.55-0.45-1-1-1S11,1.45,11,2z M11,20v2c0,0.55,0.45,1,1,1s1-0.45,1-1v-2c0-0.55-0.45-1-1-1 C11.45,19,11,19.45,11,20z M5.99,4.58c-0.39-0.39-1.03-0.39-1.41,0c-0.39,0.39-0.39,1.03,0,1.41l1.06,1.06 c0.39,0.39,1.03,0.39,1.41,0s0.39-1.03,0-1.41L5.99,4.58z M18.36,16.95c-0.39-0.39-1.03-0.39-1.41,0c-0.39,0.39-0.39,1.03,0,1.41 l1.06,1.06c0.39,0.39,1.03,0.39,1.41,0c0.39-0.39,0.39-1.03,0-1.41L18.36,16.95z M19.42,5.99c0.39-0.39,0.39-1.03,0-1.41 c-0.39-0.39-1.03-0.39-1.41,0l-1.06,1.06c-0.39,0.39-0.39,1.03,0,1.41s1.03,0.39,1.41,0L19.42,5.99z M7.05,18.36 c0.39-0.39,0.39-1.03,0-1.41c-0.39-0.39-1.03-0.39-1.41,0l-1.06,1.06c-0.39,0.39-0.39,1.03,0,1.41s1.03,0.39,1.41,0L7.05,18.36z"/></svg><svg xmlns="http://www.w3.org/2000/svg" enable-background="new 0 0 24 24" height="24" viewBox="0 0 24 24" width="24" id="line_weight_24px"><g><rect fill="none" height="24" width="24" x="0"/></g><g><g><g><path d="M3,17h18v-2H3V17z M3,20h18v-1H3V20z M3,13h18v-3H3V13z M3,4v4h18V4H3z"/></g></g></g></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="more_vert_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M12 8c1.1 0 2-.9 2-2s-.9-2-2-2-2 .9-2 2 .9 2 2 2zm0 2c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm0 6c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="notifications_none_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M12 22c1.1 0 2-.9 2-2h-4c0 1.1.9 2 2 2zm6-6v-5c0-3.07-1.63-5.64-4.5-6.32V4c0-.83-.67-1.5-1.5-1.5s-1.5.67-1.5 1.5v.68C7.64 5.36 6 7.92 6 11v5l-2 2v1h16v-1l-2-2zm-2 1H8v-6c0-2.48 1.51-4.5 4-4.5s4 2.02 4 4.5v6z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="palette_24px"><path d="M12 3c-4.97 0-9 4.03-9 9s4.03 9 9 9c.83 0 1.5-.67 1.5-1.5 0-.39-.15-.74-.39-1.01-.23-.26-.38-.61-.38-.99 0-.83.67-1.5 1.5-1.5H16c2.76 0 5-2.24 5-5 0-4.42-4.03-8-9-8zm-5.5 9c-.83 0-1.5-.67-1.5-1.5S5.67 9 6.5 9 8 9.67 8 10.5 7.33 12 6.5 12zm3-4C8.67 8 8 7.33 8 6.5S8.67 5 9.5 5s1.5.67 1.5 1.5S10.33 8 9.5 8zm5 0c-.83 0-1.5-.67-1.5-1.5S13.67 5 14.5 5s1.5.67 1.5 1.5S15.33 8 14.5 8zm3 4c-.83 0-1.5-.67-1.5-1.5S16.67 9 17.5 9s1.5.67 1.5 1.5-.67 1.5-1.5 1.5z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="refresh_24px"><path d="M17.65 6.35C16.2 4.9 14.21 4 12 4c-4.42 0-7.99 3.58-7.99 8s3.57 8 7.99 8c3.73 0 6.84-2.55 7.73-6h-2.08c-.82 2.33-3.04 4-5.65 4-3.31 0-6-2.69-6-6s2.69-6 6-6c1.66 0 3.14.69 4.22 1.78L13 11h7V4l-2.35 2.35z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="search_24px"><path d="M15.5 14h-.79l-.28-.27C15.41 12.59 16 11.11 16 9.5 16 5.91 13.09 3 9.5 3S3 5.91 3 9.5 5.91 16 9.5 16c1.61 0 3.09-.59 4.23-1.57l.27.28v.79l5 4.99L20.49 19l-4.99-5zm-6 0C7.01 14 5 11.99 5 9.5S7.01 5 9.5 5 14 7.01 14 9.5 11.99 14 9.5 14z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="settings_24px"><path d="M19.43 12.98c.04-.32.07-.64.07-.98s-.03-.66-.07-.98l2.11-1.65c.19-.15.24-.42.12-.64l-2-3.46c-.12-.22-.39-.3-.61-.22l-2.49 1c-.52-.4-1.08-.73-1.69-.98l-.38-2.65C14.46 2.18 14.25 2 14 2h-4c-.25 0-.46.18-.49.42l-.38 2.65c-.61.25-1.17.59-1.69.98l-2.49-1c-.23-.09-.49 0-.61.22l-2 3.46c-.13.22-.07.49.12.64l2.11 1.65c-.04.32-.07.65-.07.98s.03.66.07.98l-2.11 1.65c-.19.15-.24.42-.12.64l2 3.46c.12.22.39.3.61.22l2.49-1c.52.4 1.08.73 1.69.98l.38 2.65c.03.24.24.42.49.42h4c.25 0 .46-.18.49-.42l.38-2.65c.61-.25 1.17-.59 1.69-.98l2.49 1c.23.09.49 0 .61-.22l2-3.46c.12-.22.07-.49-.12-.64l-2.11-1.65zM12 15.5c-1.93 0-3.5-1.57-3.5-3.5s1.57-3.5 3.5-3.5 3.5 1.57 3.5 3.5-1.57 3.5-3.5 3.5z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="settings_backup_restore_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M14 12c0-1.1-.9-2-2-2s-2 .9-2 2 .9 2 2 2 2-.9 2-2zm-2-9c-4.97 0-9 4.03-9 9H0l4 4 4-4H5c0-3.87 3.13-7 7-7s7 3.13 7 7-3.13 7-7 7c-1.51 0-2.91-.49-4.06-1.3l-1.42 1.44C8.04 20.3 9.94 21 12 21c4.97 0 9-4.03 9-9s-4.03-9-9-9z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="settings_overscan_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M12.01 5.5L10 8h4l-1.99-2.5zM18 10v4l2.5-1.99L18 10zM6 10l-2.5 2.01L6 14v-4zm8 6h-4l2.01 2.5L14 16zm7-13H3c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16.01H3V4.99h18v14.02z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="visibility_off_24px"><path d="M12 7c2.76 0 5 2.24 5 5 0 .65-.13 1.26-.36 1.83l2.92 2.92c1.51-1.26 2.7-2.89 3.43-4.75-1.73-4.39-6-7.5-11-7.5-1.4 0-2.74.25-3.98.7l2.16 2.16C10.74 7.13 11.35 7 12 7zM2 4.27l2.28 2.28.46.46C3.08 8.3 1.78 10.02 1 12c1.73 4.39 6 7.5 11 7.5 1.55 0 3.03-.3 4.38-.84l.42.42L19.73 22 21 20.73 3.27 3 2 4.27zM7.53 9.8l1.55 1.55c-.05.21-.08.43-.08.65 0 1.66 1.34 3 3 3 .22 0 .44-.03.65-.08l1.55 1.55c-.67.33-1.41.53-2.2.53-2.76 0-5-2.24-5-5 0-.79.2-1.53.53-2.2zm4.31-.78l3.15 3.15.02-.16c0-1.66-1.34-3-3-3l-.17.01z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="warning_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M1 21h22L12 2 1 21zm12-3h-2v-2h2v2zm0-4h-2v-4h2v4z"/></svg></defs></svg>
", + "ok": true, + "headers": [ + [ + "content-type", + "image/svg+xml; charset=utf-8" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6006/data/plugins_listing": { + "data": "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", + "ok": true, + "headers": [ + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6006/font-roboto/RxZJdnzeo3R5zSexge8UUZBw1xU1rKptJj_0jans920.woff2": { + "data": "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", + "ok": true, + "headers": [ + [ + "content-type", + "font/woff2" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6006/data/environment": { + "data": "eyJ2ZXJzaW9uIjogIjIuMTQuMSIsICJkYXRhX2xvY2F0aW9uIjogImxvZ3MvZml0IiwgIndpbmRvd190aXRsZSI6ICIiLCAiZXhwZXJpbWVudF9uYW1lIjogIiIsICJleHBlcmltZW50X2Rlc2NyaXB0aW9uIjogIiIsICJjcmVhdGlvbl90aW1lIjogMC4wLCAiZGVidWciOiB7ImRhdGFfcHJvdmlkZXIiOiAiR3JwY0RhdGFQcm92aWRlcihhZGRyPSdsb2NhbGhvc3Q6NDYyMTcnKSIsICJmbGFncyI6IHsibG9nZGlyIjogImxvZ3MvZml0IiwgImxvZ2Rpcl9zcGVjIjogIiIsICJob3N0IjogbnVsbCwgImJpbmRfYWxsIjogZmFsc2UsICJwb3J0IjogbnVsbCwgInJldXNlX3BvcnQiOiBmYWxzZSwgImxvYWRfZmFzdCI6ICJhdXRvIiwgImV4dHJhX2RhdGFfc2VydmVyX2ZsYWdzIjogIiIsICJncnBjX2NyZWRzX3R5cGUiOiAibG9jYWwiLCAiZ3JwY19kYXRhX3Byb3ZpZGVyIjogIiIsICJwdXJnZV9vcnBoYW5lZF9kYXRhIjogdHJ1ZSwgImRiIjogIiIsICJkYl9pbXBvcnQiOiBmYWxzZSwgImluc3BlY3QiOiBmYWxzZSwgInZlcnNpb25fdGIiOiBmYWxzZSwgInRhZyI6ICIiLCAiZXZlbnRfZmlsZSI6ICIiLCAicGF0aF9wcmVmaXgiOiAiIiwgIndpbmRvd190aXRsZSI6ICIiLCAibWF4X3JlbG9hZF90aHJlYWRzIjogMSwgInJlbG9hZF9pbnRlcnZhbCI6IDUuMCwgInJlbG9hZF90YXNrIjogImF1dG8iLCAicmVsb2FkX211bHRpZmlsZSI6IG51bGwsICJyZWxvYWRfbXVsdGlmaWxlX2luYWN0aXZlX3NlY3MiOiA4NjQwMCwgImdlbmVyaWNfZGF0YSI6ICJhdXRvIiwgInNhbXBsZXNfcGVyX3BsdWdpbiI6IHt9LCAiZGV0ZWN0X2ZpbGVfcmVwbGFjZW1lbnQiOiBudWxsLCAiX190ZW5zb3Jib2FyZF9zdWJjb21tYW5kIjogInNlcnZlIn19fQ==", + "ok": true, + "headers": [ + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6006/experiment/defaultExperimentId/data/plugin/hparams/experiment?request=%7B%22experimentName%22:%22defaultExperimentId%22%7D": { + "data": "ewogICJuYW1lIjogIiIsCiAgImRlc2NyaXB0aW9uIjogIiIsCiAgInVzZXIiOiAiIiwKICAidGltZUNyZWF0ZWRTZWNzIjogMC4wLAogICJocGFyYW1JbmZvcyI6IFtdLAogICJtZXRyaWNJbmZvcyI6IFtdCn0=", + "ok": true, + "headers": [ + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6006/experiment/defaultExperimentId/data/runs": { + "data": "WyJyZXNuZXQ1MFYyLzIwMjMxMjA5LTE0MjE1Mi90cmFpbiIsICJyZXNuZXQ1MFYyLzIwMjMxMjA5LTE0MjE1Mi92YWxpZGF0aW9uIiwgImVmZmljaWVudG5ldEIwLzIwMjMxMjA5LTE0MjMxMy90cmFpbiIsICJlZmZpY2llbnRuZXRCMC8yMDIzMTIwOS0xNDIzMTMvdmFsaWRhdGlvbiJd", + "ok": true, + "headers": [ + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6006/font-roboto/oMMgfZMQthOryQo9n22dcuvvDin1pK8aKteLpeZ5c0A.woff2": { + "data": "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", + "ok": true, + "headers": [ + [ + "content-type", + "font/woff2" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6006/data/runs": { + "data": "WyJyZXNuZXQ1MFYyLzIwMjMxMjA5LTE0MjE1Mi90cmFpbiIsICJyZXNuZXQ1MFYyLzIwMjMxMjA5LTE0MjE1Mi92YWxpZGF0aW9uIiwgImVmZmljaWVudG5ldEIwLzIwMjMxMjA5LTE0MjMxMy90cmFpbiIsICJlZmZpY2llbnRuZXRCMC8yMDIzMTIwOS0xNDIzMTMvdmFsaWRhdGlvbiJd", + "ok": true, + "headers": [ + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6006/experiment/defaultExperimentId/data/plugin/hparams/session_groups?request=%7B%22experimentName%22:%22defaultExperimentId%22,%22allowedStatuses%22:%5B%22STATUS_FAILURE%22,%22STATUS_RUNNING%22,%22STATUS_SUCCESS%22,%22STATUS_UNKNOWN%22%5D,%22colParams%22:%5B%5D,%22startIndex%22:0,%22sliceSize%22:1000000%7D": { + "data": "ewogICJzZXNzaW9uR3JvdXBzIjogW10sCiAgInRvdGFsU2l6ZSI6IDAKfQ==", + "ok": true, + "headers": [ + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6006/experiment/defaultExperimentId/data/plugin/timeseries/tags": { + "data": "eyJzY2FsYXJzIjogeyJydW5UYWdJbmZvIjogeyJyZXNuZXQ1MFYyLzIwMjMxMjA5LTE0MjE1Mi92YWxpZGF0aW9uIjogWyJlcG9jaF9hY2N1cmFjeSIsICJlcG9jaF9sb3NzIiwgImV2YWx1YXRpb25fYWNjdXJhY3lfdnNfaXRlcmF0aW9ucyIsICJldmFsdWF0aW9uX2xvc3NfdnNfaXRlcmF0aW9ucyJdLCAiZWZmaWNpZW50bmV0QjAvMjAyMzEyMDktMTQyMzEzL3ZhbGlkYXRpb24iOiBbImVwb2NoX2FjY3VyYWN5IiwgImVwb2NoX2xvc3MiLCAiZXZhbHVhdGlvbl9hY2N1cmFjeV92c19pdGVyYXRpb25zIiwgImV2YWx1YXRpb25fbG9zc192c19pdGVyYXRpb25zIl0sICJlZmZpY2llbnRuZXRCMC8yMDIzMTIwOS0xNDIzMTMvdHJhaW4iOiBbImVwb2NoX2FjY3VyYWN5IiwgImVwb2NoX2xvc3MiXSwgInJlc25ldDUwVjIvMjAyMzEyMDktMTQyMTUyL3RyYWluIjogWyJlcG9jaF9hY2N1cmFjeSIsICJlcG9jaF9sb3NzIl19LCAidGFnRGVzY3JpcHRpb25zIjoge319LCAiaGlzdG9ncmFtcyI6IHsicnVuVGFnSW5mbyI6IHt9LCAidGFnRGVzY3JpcHRpb25zIjoge319LCAiaW1hZ2VzIjogeyJ0YWdEZXNjcmlwdGlvbnMiOiB7fSwgInRhZ1J1blNhbXBsZWRJbmZvIjoge319fQ==", + "ok": true, + "headers": [ + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6006/font-roboto/vPcynSL0qHq_6dX7lKVByXYhjbSpvc47ee6xR_80Hnw.woff2": { + "data": "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", + "ok": true, + "headers": [ + [ + "content-type", + "font/woff2" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6006/experiment/defaultExperimentId/data/plugin/timeseries/timeSeries?requests=%5B%7B%22plugin%22:%22scalars%22,%22tag%22:%22epoch_accuracy%22%7D%5D": { + "data": "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", + "ok": true, + "headers": [ + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6006/experiment/defaultExperimentId/data/plugin/timeseries/timeSeries?requests=%5B%7B%22plugin%22:%22scalars%22,%22tag%22:%22epoch_loss%22%7D%5D": { + "data": "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", + "ok": true, + "headers": [ + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6006/font-roboto/d-6IYplOFocCacKzxwXSOJBw1xU1rKptJj_0jans920.woff2": { + "data": "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", + "ok": true, + "headers": [ + [ + "content-type", + "font/woff2" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6006/chart_worker.js?_file_hash=2c1e71c5": { + "data": "(()=>{var H0=Object.defineProperty,V0=Object.defineProperties;var G0=Object.getOwnPropertyDescriptors;var af=Object.getOwnPropertySymbols;var W0=Object.prototype.hasOwnProperty,q0=Object.prototype.propertyIsEnumerable;var cf=Math.pow,lf=(n,t,e)=>t in n?H0(n,t,{enumerable:!0,configurable:!0,writable:!0,value:e}):n[t]=e,No=(n,t)=>{for(var e in t||(t={}))W0.call(t,e)&&lf(n,e,t[e]);if(af)for(var e of af(t))q0.call(t,e)&&lf(n,e,t[e]);return n},uf=(n,t)=>V0(n,G0(t));var hf=(n,t,e)=>new Promise((i,r)=>{var s=l=>{try{a(e.next(l))}catch(c){r(c)}},o=l=>{try{a(e.throw(l))}catch(c){r(c)}},a=l=>l.done?i(l.value):Promise.resolve(l.value).then(s,o);a((e=e.apply(n,t)).next())});var on;(function(n){n[n.LINEAR=0]="LINEAR",n[n.LOG10=1]="LOG10",n[n.TIME=2]="TIME"})(on||(on={}));function an(n,t){return n<t?-1:n>t?1:n>=t?0:NaN}function is(n){return n.length===1&&(n=X0(n)),{left:function(t,e,i,r){for(i==null&&(i=0),r==null&&(r=t.length);i<r;){var s=i+r>>>1;n(t[s],e)<0?i=s+1:r=s}return i},right:function(t,e,i,r){for(i==null&&(i=0),r==null&&(r=t.length);i<r;){var s=i+r>>>1;n(t[s],e)>0?r=s:i=s+1}return i}}}function X0(n){return function(t,e){return an(n(t),e)}}var ff=is(an),df=ff.right,Y0=ff.left,Bn=df;var pf=Array.prototype,J0=pf.slice,$0=pf.map;var kl=Math.sqrt(50),Hl=Math.sqrt(10),Vl=Math.sqrt(2);function rs(n,t,e){var i,r=-1,s,o,a;if(t=+t,n=+n,e=+e,n===t&&e>0)return[n];if((i=t<n)&&(s=n,n=t,t=s),(a=Ji(n,t,e))===0||!isFinite(a))return[];if(a>0)for(n=Math.ceil(n/a),t=Math.floor(t/a),o=new Array(s=Math.ceil(t-n+1));++r<s;)o[r]=(n+r)*a;else for(n=Math.floor(n*a),t=Math.ceil(t*a),o=new Array(s=Math.ceil(n-t+1));++r<s;)o[r]=(n-r)/a;return i&&o.reverse(),o}function Ji(n,t,e){var i=(t-n)/Math.max(0,e),r=Math.floor(Math.log(i)/Math.LN10),s=i/Math.pow(10,r);return r>=0?(s>=kl?10:s>=Hl?5:s>=Vl?2:1)*Math.pow(10,r):-Math.pow(10,-r)/(s>=kl?10:s>=Hl?5:s>=Vl?2:1)}function _n(n,t,e){var i=Math.abs(t-n)/Math.max(0,e),r=Math.pow(10,Math.floor(Math.log(i)/Math.LN10)),s=i/r;return s>=kl?r*=10:s>=Hl?r*=5:s>=Vl&&(r*=2),t<n?-r:r}var ex=Array.prototype.slice;var nx={value:function(){}};function yf(){for(var n=0,t=arguments.length,e={},i;n<t;++n){if(!(i=arguments[n]+"")||i in e||/[\s.]/.test(i))throw new Error("illegal type: "+i);e[i]=[]}return new zo(e)}function zo(n){this._=n}function ix(n,t){return n.trim().split(/^|\s+/).map(function(e){var i="",r=e.indexOf(".");if(r>=0&&(i=e.slice(r+1),e=e.slice(0,r)),e&&!t.hasOwnProperty(e))throw new Error("unknown type: "+e);return{type:e,name:i}})}zo.prototype=yf.prototype={constructor:zo,on:function(n,t){var e=this._,i=ix(n+"",e),r,s=-1,o=i.length;if(arguments.length<2){for(;++s<o;)if((r=(n=i[s]).type)&&(r=rx(e[r],n.name)))return r;return}if(t!=null&&typeof t!="function")throw new Error("invalid callback: "+t);for(;++s<o;)if(r=(n=i[s]).type)e[r]=xf(e[r],n.name,t);else if(t==null)for(r in e)e[r]=xf(e[r],n.name,null);return this},copy:function(){var n={},t=this._;for(var e in t)n[e]=t[e].slice();return new zo(n)},call:function(n,t){if((r=arguments.length-2)>0)for(var e=new Array(r),i=0,r,s;i<r;++i)e[i]=arguments[i+2];if(!this._.hasOwnProperty(n))throw new Error("unknown type: "+n);for(s=this._[n],i=0,r=s.length;i<r;++i)s[i].value.apply(t,e)},apply:function(n,t,e){if(!this._.hasOwnProperty(n))throw new Error("unknown type: "+n);for(var i=this._[n],r=0,s=i.length;r<s;++r)i[r].value.apply(t,e)}};function rx(n,t){for(var e=0,i=n.length,r;e<i;++e)if((r=n[e]).name===t)return r.value}function xf(n,t,e){for(var i=0,r=n.length;i<r;++i)if(n[i].name===t){n[i]=nx,n=n.slice(0,i).concat(n.slice(i+1));break}return e!=null&&n.push({name:t,value:e}),n}var Wl=yf;var Uo="http://www.w3.org/1999/xhtml",ql={svg:"http://www.w3.org/2000/svg",xhtml:Uo,xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/"};function wn(n){var t=n+="",e=t.indexOf(":");return e>=0&&(t=n.slice(0,e))!=="xmlns"&&(n=n.slice(e+1)),ql.hasOwnProperty(t)?{space:ql[t],local:n}:n}function sx(n){return function(){var t=this.ownerDocument,e=this.namespaceURI;return e===Uo&&t.documentElement.namespaceURI===Uo?t.createElement(n):t.createElementNS(e,n)}}function ox(n){return function(){return this.ownerDocument.createElementNS(n.space,n.local)}}function Bo(n){var t=wn(n);return(t.local?ox:sx)(t)}function ax(){}function di(n){return n==null?ax:function(){return this.querySelector(n)}}function vf(n){typeof n!="function"&&(n=di(n));for(var t=this._groups,e=t.length,i=new Array(e),r=0;r<e;++r)for(var s=t[r],o=s.length,a=i[r]=new Array(o),l,c,u=0;u<o;++u)(l=s[u])&&(c=n.call(l,l.__data__,u,s))&&("__data__"in l&&(c.__data__=l.__data__),a[u]=c);return new ce(i,this._parents)}function lx(){return[]}function os(n){return n==null?lx:function(){return this.querySelectorAll(n)}}function _f(n){typeof n!="function"&&(n=os(n));for(var t=this._groups,e=t.length,i=[],r=[],s=0;s<e;++s)for(var o=t[s],a=o.length,l,c=0;c<a;++c)(l=o[c])&&(i.push(n.call(l,l.__data__,c,o)),r.push(l));return new ce(i,r)}function as(n){return function(){return this.matches(n)}}function wf(n){typeof n!="function"&&(n=as(n));for(var t=this._groups,e=t.length,i=new Array(e),r=0;r<e;++r)for(var s=t[r],o=s.length,a=i[r]=[],l,c=0;c<o;++c)(l=s[c])&&n.call(l,l.__data__,c,s)&&a.push(l);return new ce(i,this._parents)}function Oo(n){return new Array(n.length)}function Mf(){return new ce(this._enter||this._groups.map(Oo),this._parents)}function ls(n,t){this.ownerDocument=n.ownerDocument,this.namespaceURI=n.namespaceURI,this._next=null,this._parent=n,this.__data__=t}ls.prototype={constructor:ls,appendChild:function(n){return this._parent.insertBefore(n,this._next)},insertBefore:function(n,t){return this._parent.insertBefore(n,t)},querySelector:function(n){return this._parent.querySelector(n)},querySelectorAll:function(n){return this._parent.querySelectorAll(n)}};function bf(n){return function(){return n}}var Sf="$";function cx(n,t,e,i,r,s){for(var o=0,a,l=t.length,c=s.length;o<c;++o)(a=t[o])?(a.__data__=s[o],i[o]=a):e[o]=new ls(n,s[o]);for(;o<l;++o)(a=t[o])&&(r[o]=a)}function ux(n,t,e,i,r,s,o){var a,l,c={},u=t.length,h=s.length,f=new Array(u),d;for(a=0;a<u;++a)(l=t[a])&&(f[a]=d=Sf+o.call(l,l.__data__,a,t),d in c?r[a]=l:c[d]=l);for(a=0;a<h;++a)d=Sf+o.call(n,s[a],a,s),(l=c[d])?(i[a]=l,l.__data__=s[a],c[d]=null):e[a]=new ls(n,s[a]);for(a=0;a<u;++a)(l=t[a])&&c[f[a]]===l&&(r[a]=l)}function Ef(n,t){if(!n)return d=new Array(this.size()),c=-1,this.each(function(L){d[++c]=L}),d;var e=t?ux:cx,i=this._parents,r=this._groups;typeof n!="function"&&(n=bf(n));for(var s=r.length,o=new Array(s),a=new Array(s),l=new Array(s),c=0;c<s;++c){var u=i[c],h=r[c],f=h.length,d=n.call(u,u&&u.__data__,c,i),g=d.length,x=a[c]=new Array(g),v=o[c]=new Array(g),m=l[c]=new Array(f);e(u,h,x,v,m,d,t);for(var p=0,b=0,_,S;p<g;++p)if(_=x[p]){for(p>=b&&(b=p+1);!(S=v[b])&&++b<g;);_._next=S||null}}return o=new ce(o,i),o._enter=a,o._exit=l,o}function Tf(){return new ce(this._exit||this._groups.map(Oo),this._parents)}function Af(n,t,e){var i=this.enter(),r=this,s=this.exit();return i=typeof n=="function"?n(i):i.append(n+""),t!=null&&(r=t(r)),e==null?s.remove():e(s),i&&r?i.merge(r).order():r}function Cf(n){for(var t=this._groups,e=n._groups,i=t.length,r=e.length,s=Math.min(i,r),o=new Array(i),a=0;a<s;++a)for(var l=t[a],c=e[a],u=l.length,h=o[a]=new Array(u),f,d=0;d<u;++d)(f=l[d]||c[d])&&(h[d]=f);for(;a<i;++a)o[a]=t[a];return new ce(o,this._parents)}function Rf(){for(var n=this._groups,t=-1,e=n.length;++t<e;)for(var i=n[t],r=i.length-1,s=i[r],o;--r>=0;)(o=i[r])&&(s&&o.compareDocumentPosition(s)^4&&s.parentNode.insertBefore(o,s),s=o);return this}function Lf(n){n||(n=hx);function t(h,f){return h&&f?n(h.__data__,f.__data__):!h-!f}for(var e=this._groups,i=e.length,r=new Array(i),s=0;s<i;++s){for(var o=e[s],a=o.length,l=r[s]=new Array(a),c,u=0;u<a;++u)(c=o[u])&&(l[u]=c);l.sort(t)}return new ce(r,this._parents).order()}function hx(n,t){return n<t?-1:n>t?1:n>=t?0:NaN}function Pf(){var n=arguments[0];return arguments[0]=this,n.apply(null,arguments),this}function Df(){var n=new Array(this.size()),t=-1;return this.each(function(){n[++t]=this}),n}function If(){for(var n=this._groups,t=0,e=n.length;t<e;++t)for(var i=n[t],r=0,s=i.length;r<s;++r){var o=i[r];if(o)return o}return null}function Nf(){var n=0;return this.each(function(){++n}),n}function Ff(){return!this.node()}function zf(n){for(var t=this._groups,e=0,i=t.length;e<i;++e)for(var r=t[e],s=0,o=r.length,a;s<o;++s)(a=r[s])&&n.call(a,a.__data__,s,r);return this}function fx(n){return function(){this.removeAttribute(n)}}function dx(n){return function(){this.removeAttributeNS(n.space,n.local)}}function px(n,t){return function(){this.setAttribute(n,t)}}function mx(n,t){return function(){this.setAttributeNS(n.space,n.local,t)}}function gx(n,t){return function(){var e=t.apply(this,arguments);e==null?this.removeAttribute(n):this.setAttribute(n,e)}}function xx(n,t){return function(){var e=t.apply(this,arguments);e==null?this.removeAttributeNS(n.space,n.local):this.setAttributeNS(n.space,n.local,e)}}function Uf(n,t){var e=wn(n);if(arguments.length<2){var i=this.node();return e.local?i.getAttributeNS(e.space,e.local):i.getAttribute(e)}return this.each((t==null?e.local?dx:fx:typeof t=="function"?e.local?xx:gx:e.local?mx:px)(e,t))}function ko(n){return n.ownerDocument&&n.ownerDocument.defaultView||n.document&&n||n.defaultView}function yx(n){return function(){this.style.removeProperty(n)}}function vx(n,t,e){return function(){this.style.setProperty(n,t,e)}}function _x(n,t,e){return function(){var i=t.apply(this,arguments);i==null?this.style.removeProperty(n):this.style.setProperty(n,i,e)}}function Bf(n,t,e){return arguments.length>1?this.each((t==null?yx:typeof t=="function"?_x:vx)(n,t,e==null?"":e)):On(this.node(),n)}function On(n,t){return n.style.getPropertyValue(t)||ko(n).getComputedStyle(n,null).getPropertyValue(t)}function wx(n){return function(){delete this[n]}}function Mx(n,t){return function(){this[n]=t}}function bx(n,t){return function(){var e=t.apply(this,arguments);e==null?delete this[n]:this[n]=e}}function Of(n,t){return arguments.length>1?this.each((t==null?wx:typeof t=="function"?bx:Mx)(n,t)):this.node()[n]}function kf(n){return n.trim().split(/^|\s+/)}function Xl(n){return n.classList||new Hf(n)}function Hf(n){this._node=n,this._names=kf(n.getAttribute("class")||"")}Hf.prototype={add:function(n){var t=this._names.indexOf(n);t<0&&(this._names.push(n),this._node.setAttribute("class",this._names.join(" ")))},remove:function(n){var t=this._names.indexOf(n);t>=0&&(this._names.splice(t,1),this._node.setAttribute("class",this._names.join(" ")))},contains:function(n){return this._names.indexOf(n)>=0}};function Vf(n,t){for(var e=Xl(n),i=-1,r=t.length;++i<r;)e.add(t[i])}function Gf(n,t){for(var e=Xl(n),i=-1,r=t.length;++i<r;)e.remove(t[i])}function Sx(n){return function(){Vf(this,n)}}function Ex(n){return function(){Gf(this,n)}}function Tx(n,t){return function(){(t.apply(this,arguments)?Vf:Gf)(this,n)}}function Wf(n,t){var e=kf(n+"");if(arguments.length<2){for(var i=Xl(this.node()),r=-1,s=e.length;++r<s;)if(!i.contains(e[r]))return!1;return!0}return this.each((typeof t=="function"?Tx:t?Sx:Ex)(e,t))}function Ax(){this.textContent=""}function Cx(n){return function(){this.textContent=n}}function Rx(n){return function(){var t=n.apply(this,arguments);this.textContent=t==null?"":t}}function qf(n){return arguments.length?this.each(n==null?Ax:(typeof n=="function"?Rx:Cx)(n)):this.node().textContent}function Lx(){this.innerHTML=""}function Px(n){return function(){this.innerHTML=n}}function Dx(n){return function(){var t=n.apply(this,arguments);this.innerHTML=t==null?"":t}}function Xf(n){return arguments.length?this.each(n==null?Lx:(typeof n=="function"?Dx:Px)(n)):this.node().innerHTML}function Ix(){this.nextSibling&&this.parentNode.appendChild(this)}function Yf(){return this.each(Ix)}function Nx(){this.previousSibling&&this.parentNode.insertBefore(this,this.parentNode.firstChild)}function Zf(){return this.each(Nx)}function Jf(n){var t=typeof n=="function"?n:Bo(n);return this.select(function(){return this.appendChild(t.apply(this,arguments))})}function Fx(){return null}function $f(n,t){var e=typeof n=="function"?n:Bo(n),i=t==null?Fx:typeof t=="function"?t:di(t);return this.select(function(){return this.insertBefore(e.apply(this,arguments),i.apply(this,arguments)||null)})}function zx(){var n=this.parentNode;n&&n.removeChild(this)}function Kf(){return this.each(zx)}function Ux(){var n=this.cloneNode(!1),t=this.parentNode;return t?t.insertBefore(n,this.nextSibling):n}function Bx(){var n=this.cloneNode(!0),t=this.parentNode;return t?t.insertBefore(n,this.nextSibling):n}function Qf(n){return this.select(n?Bx:Ux)}function jf(n){return arguments.length?this.property("__data__",n):this.node().__data__}var ed={},Yl=null;typeof document!="undefined"&&(td=document.documentElement,"onmouseenter"in td||(ed={mouseenter:"mouseover",mouseleave:"mouseout"}));var td;function Ox(n,t,e){return n=nd(n,t,e),function(i){var r=i.relatedTarget;(!r||r!==this&&!(r.compareDocumentPosition(this)&8))&&n.call(this,i)}}function nd(n,t,e){return function(i){var r=Yl;Yl=i;try{n.call(this,this.__data__,t,e)}finally{Yl=r}}}function kx(n){return n.trim().split(/^|\s+/).map(function(t){var e="",i=t.indexOf(".");return i>=0&&(e=t.slice(i+1),t=t.slice(0,i)),{type:t,name:e}})}function Hx(n){return function(){var t=this.__on;if(!!t){for(var e=0,i=-1,r=t.length,s;e<r;++e)s=t[e],(!n.type||s.type===n.type)&&s.name===n.name?this.removeEventListener(s.type,s.listener,s.capture):t[++i]=s;++i?t.length=i:delete this.__on}}}function Vx(n,t,e){var i=ed.hasOwnProperty(n.type)?Ox:nd;return function(r,s,o){var a=this.__on,l,c=i(t,s,o);if(a){for(var u=0,h=a.length;u<h;++u)if((l=a[u]).type===n.type&&l.name===n.name){this.removeEventListener(l.type,l.listener,l.capture),this.addEventListener(l.type,l.listener=c,l.capture=e),l.value=t;return}}this.addEventListener(n.type,c,e),l={type:n.type,name:n.name,value:t,listener:c,capture:e},a?a.push(l):this.__on=[l]}}function id(n,t,e){var i=kx(n+""),r,s=i.length,o;if(arguments.length<2){var a=this.node().__on;if(a){for(var l=0,c=a.length,u;l<c;++l)for(r=0,u=a[l];r<s;++r)if((o=i[r]).type===u.type&&o.name===u.name)return u.value}return}for(a=t?Vx:Hx,e==null&&(e=!1),r=0;r<s;++r)this.each(a(i[r],t,e));return this}function rd(n,t,e){var i=ko(n),r=i.CustomEvent;typeof r=="function"?r=new r(t,e):(r=i.document.createEvent("Event"),e?(r.initEvent(t,e.bubbles,e.cancelable),r.detail=e.detail):r.initEvent(t,!1,!1)),n.dispatchEvent(r)}function Gx(n,t){return function(){return rd(this,n,t)}}function Wx(n,t){return function(){return rd(this,n,t.apply(this,arguments))}}function sd(n,t){return this.each((typeof t=="function"?Wx:Gx)(n,t))}var qx=[null];function ce(n,t){this._groups=n,this._parents=t}function od(){return new ce([[document.documentElement]],qx)}ce.prototype=od.prototype={constructor:ce,select:vf,selectAll:_f,filter:wf,data:Ef,enter:Mf,exit:Tf,join:Af,merge:Cf,order:Rf,sort:Lf,call:Pf,nodes:Df,node:If,size:Nf,empty:Ff,each:zf,attr:Uf,style:Bf,property:Of,classed:Wf,text:qf,html:Xf,raise:Yf,lower:Zf,append:Jf,insert:$f,remove:Kf,clone:Qf,datum:jf,on:id,dispatch:sd};var Mn=od;function Ho(n,t,e){n.prototype=t.prototype=e,e.constructor=n}function Zl(n,t){var e=Object.create(n.prototype);for(var i in t)e[i]=t[i];return e}function hs(){}var cs=.7,Go=1/cs,$i="\\s*([+-]?\\d+)\\s*",us="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",cn="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",Xx=/^#([0-9a-f]{3,8})$/,Yx=new RegExp("^rgb\\("+[$i,$i,$i]+"\\)$"),Zx=new RegExp("^rgb\\("+[cn,cn,cn]+"\\)$"),Jx=new RegExp("^rgba\\("+[$i,$i,$i,us]+"\\)$"),$x=new RegExp("^rgba\\("+[cn,cn,cn,us]+"\\)$"),Kx=new RegExp("^hsl\\("+[us,cn,cn]+"\\)$"),Qx=new RegExp("^hsla\\("+[us,cn,cn,us]+"\\)$"),ad={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};Ho(hs,Je,{copy:function(n){return Object.assign(new this.constructor,this,n)},displayable:function(){return this.rgb().displayable()},hex:ld,formatHex:ld,formatHsl:jx,formatRgb:cd,toString:cd});function ld(){return this.rgb().formatHex()}function jx(){return pd(this).formatHsl()}function cd(){return this.rgb().formatRgb()}function Je(n){var t,e;return n=(n+"").trim().toLowerCase(),(t=Xx.exec(n))?(e=t[1].length,t=parseInt(t[1],16),e===6?ud(t):e===3?new Ue(t>>8&15|t>>4&240,t>>4&15|t&240,(t&15)<<4|t&15,1):e===8?Vo(t>>24&255,t>>16&255,t>>8&255,(t&255)/255):e===4?Vo(t>>12&15|t>>8&240,t>>8&15|t>>4&240,t>>4&15|t&240,((t&15)<<4|t&15)/255):null):(t=Yx.exec(n))?new Ue(t[1],t[2],t[3],1):(t=Zx.exec(n))?new Ue(t[1]*255/100,t[2]*255/100,t[3]*255/100,1):(t=Jx.exec(n))?Vo(t[1],t[2],t[3],t[4]):(t=$x.exec(n))?Vo(t[1]*255/100,t[2]*255/100,t[3]*255/100,t[4]):(t=Kx.exec(n))?dd(t[1],t[2]/100,t[3]/100,1):(t=Qx.exec(n))?dd(t[1],t[2]/100,t[3]/100,t[4]):ad.hasOwnProperty(n)?ud(ad[n]):n==="transparent"?new Ue(NaN,NaN,NaN,0):null}function ud(n){return new Ue(n>>16&255,n>>8&255,n&255,1)}function Vo(n,t,e,i){return i<=0&&(n=t=e=NaN),new Ue(n,t,e,i)}function ty(n){return n instanceof hs||(n=Je(n)),n?(n=n.rgb(),new Ue(n.r,n.g,n.b,n.opacity)):new Ue}function Ki(n,t,e,i){return arguments.length===1?ty(n):new Ue(n,t,e,i==null?1:i)}function Ue(n,t,e,i){this.r=+n,this.g=+t,this.b=+e,this.opacity=+i}Ho(Ue,Ki,Zl(hs,{brighter:function(n){return n=n==null?Go:Math.pow(Go,n),new Ue(this.r*n,this.g*n,this.b*n,this.opacity)},darker:function(n){return n=n==null?cs:Math.pow(cs,n),new Ue(this.r*n,this.g*n,this.b*n,this.opacity)},rgb:function(){return this},displayable:function(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:hd,formatHex:hd,formatRgb:fd,toString:fd}));function hd(){return"#"+Jl(this.r)+Jl(this.g)+Jl(this.b)}function fd(){var n=this.opacity;return n=isNaN(n)?1:Math.max(0,Math.min(1,n)),(n===1?"rgb(":"rgba(")+Math.max(0,Math.min(255,Math.round(this.r)||0))+", "+Math.max(0,Math.min(255,Math.round(this.g)||0))+", "+Math.max(0,Math.min(255,Math.round(this.b)||0))+(n===1?")":", "+n+")")}function Jl(n){return n=Math.max(0,Math.min(255,Math.round(n)||0)),(n<16?"0":"")+n.toString(16)}function dd(n,t,e,i){return i<=0?n=t=e=NaN:e<=0||e>=1?n=t=NaN:t<=0&&(n=NaN),new ln(n,t,e,i)}function pd(n){if(n instanceof ln)return new ln(n.h,n.s,n.l,n.opacity);if(n instanceof hs||(n=Je(n)),!n)return new ln;if(n instanceof ln)return n;n=n.rgb();var t=n.r/255,e=n.g/255,i=n.b/255,r=Math.min(t,e,i),s=Math.max(t,e,i),o=NaN,a=s-r,l=(s+r)/2;return a?(t===s?o=(e-i)/a+(e<i)*6:e===s?o=(i-t)/a+2:o=(t-e)/a+4,a/=l<.5?s+r:2-s-r,o*=60):a=l>0&&l<1?0:o,new ln(o,a,l,n.opacity)}function pi(n,t,e,i){return arguments.length===1?pd(n):new ln(n,t,e,i==null?1:i)}function ln(n,t,e,i){this.h=+n,this.s=+t,this.l=+e,this.opacity=+i}Ho(ln,pi,Zl(hs,{brighter:function(n){return n=n==null?Go:Math.pow(Go,n),new ln(this.h,this.s,this.l*n,this.opacity)},darker:function(n){return n=n==null?cs:Math.pow(cs,n),new ln(this.h,this.s,this.l*n,this.opacity)},rgb:function(){var n=this.h%360+(this.h<0)*360,t=isNaN(n)||isNaN(this.s)?0:this.s,e=this.l,i=e+(e<.5?e:1-e)*t,r=2*e-i;return new Ue($l(n>=240?n-240:n+120,r,i),$l(n,r,i),$l(n<120?n+240:n-120,r,i),this.opacity)},displayable:function(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl:function(){var n=this.opacity;return n=isNaN(n)?1:Math.max(0,Math.min(1,n)),(n===1?"hsl(":"hsla(")+(this.h||0)+", "+(this.s||0)*100+"%, "+(this.l||0)*100+"%"+(n===1?")":", "+n+")")}}));function $l(n,t,e){return(n<60?t+(e-t)*n/60:n<180?e:n<240?t+(e-t)*(240-n)/60:t)*255}function Kl(n,t,e,i,r){var s=n*n,o=s*n;return((1-3*n+3*s-o)*t+(4-6*s+3*o)*e+(1+3*n+3*s-3*o)*i+o*r)/6}function md(n){var t=n.length-1;return function(e){var i=e<=0?e=0:e>=1?(e=1,t-1):Math.floor(e*t),r=n[i],s=n[i+1],o=i>0?n[i-1]:2*r-s,a=i<t-1?n[i+2]:2*s-r;return Kl((e-i/t)*t,o,r,s,a)}}function gd(n){var t=n.length;return function(e){var i=Math.floor(((e%=1)<0?++e:e)*t),r=n[(i+t-1)%t],s=n[i%t],o=n[(i+1)%t],a=n[(i+2)%t];return Kl((e-i/t)*t,r,s,o,a)}}function Qi(n){return function(){return n}}function xd(n,t){return function(e){return n+e*t}}function ey(n,t,e){return n=Math.pow(n,e),t=Math.pow(t,e)-n,e=1/e,function(i){return Math.pow(n+i*t,e)}}function yd(n,t){var e=t-n;return e?xd(n,e>180||e<-180?e-360*Math.round(e/360):e):Qi(isNaN(n)?t:n)}function vd(n){return(n=+n)==1?bn:function(t,e){return e-t?ey(t,e,n):Qi(isNaN(t)?e:t)}}function bn(n,t){var e=t-n;return e?xd(n,e):Qi(isNaN(n)?t:n)}var mi=function n(t){var e=vd(t);function i(r,s){var o=e((r=Ki(r)).r,(s=Ki(s)).r),a=e(r.g,s.g),l=e(r.b,s.b),c=bn(r.opacity,s.opacity);return function(u){return r.r=o(u),r.g=a(u),r.b=l(u),r.opacity=c(u),r+""}}return i.gamma=n,i}(1);function _d(n){return function(t){var e=t.length,i=new Array(e),r=new Array(e),s=new Array(e),o,a;for(o=0;o<e;++o)a=Ki(t[o]),i[o]=a.r||0,r[o]=a.g||0,s[o]=a.b||0;return i=n(i),r=n(r),s=n(s),a.opacity=1,function(l){return a.r=i(l),a.g=r(l),a.b=s(l),a+""}}}var ny=_d(md),iy=_d(gd);function wd(n,t){t||(t=[]);var e=n?Math.min(t.length,n.length):0,i=t.slice(),r;return function(s){for(r=0;r<e;++r)i[r]=n[r]*(1-s)+t[r]*s;return i}}function Md(n){return ArrayBuffer.isView(n)&&!(n instanceof DataView)}function bd(n,t){var e=t?t.length:0,i=n?Math.min(e,n.length):0,r=new Array(i),s=new Array(e),o;for(o=0;o<i;++o)r[o]=gi(n[o],t[o]);for(;o<e;++o)s[o]=t[o];return function(a){for(o=0;o<i;++o)s[o]=r[o](a);return s}}function Sd(n,t){var e=new Date;return n=+n,t=+t,function(i){return e.setTime(n*(1-i)+t*i),e}}function ye(n,t){return n=+n,t=+t,function(e){return n*(1-e)+t*e}}function Ed(n,t){var e={},i={},r;(n===null||typeof n!="object")&&(n={}),(t===null||typeof t!="object")&&(t={});for(r in t)r in n?e[r]=gi(n[r],t[r]):i[r]=t[r];return function(s){for(r in e)i[r]=e[r](s);return i}}var jl=/[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,Ql=new RegExp(jl.source,"g");function ry(n){return function(){return n}}function sy(n){return function(t){return n(t)+""}}function fs(n,t){var e=jl.lastIndex=Ql.lastIndex=0,i,r,s,o=-1,a=[],l=[];for(n=n+"",t=t+"";(i=jl.exec(n))&&(r=Ql.exec(t));)(s=r.index)>e&&(s=t.slice(e,s),a[o]?a[o]+=s:a[++o]=s),(i=i[0])===(r=r[0])?a[o]?a[o]+=r:a[++o]=r:(a[++o]=null,l.push({i:o,x:ye(i,r)})),e=Ql.lastIndex;return e<t.length&&(s=t.slice(e),a[o]?a[o]+=s:a[++o]=s),a.length<2?l[0]?sy(l[0].x):ry(t):(t=l.length,function(c){for(var u=0,h;u<t;++u)a[(h=l[u]).i]=h.x(c);return a.join("")})}function gi(n,t){var e=typeof t,i;return t==null||e==="boolean"?Qi(t):(e==="number"?ye:e==="string"?(i=Je(t))?(t=i,mi):fs:t instanceof Je?mi:t instanceof Date?Sd:Md(t)?wd:Array.isArray(t)?bd:typeof t.valueOf!="function"&&typeof t.toString!="function"||isNaN(t)?Ed:ye)(n,t)}function tc(n,t){return n=+n,t=+t,function(e){return Math.round(n*(1-e)+t*e)}}var Td=180/Math.PI,Wo={translateX:0,translateY:0,rotate:0,skewX:0,scaleX:1,scaleY:1};function ec(n,t,e,i,r,s){var o,a,l;return(o=Math.sqrt(n*n+t*t))&&(n/=o,t/=o),(l=n*e+t*i)&&(e-=n*l,i-=t*l),(a=Math.sqrt(e*e+i*i))&&(e/=a,i/=a,l/=a),n*i<t*e&&(n=-n,t=-t,l=-l,o=-o),{translateX:r,translateY:s,rotate:Math.atan2(t,n)*Td,skewX:Math.atan(l)*Td,scaleX:o,scaleY:a}}var ds,nc,Ad,qo;function Cd(n){return n==="none"?Wo:(ds||(ds=document.createElement("DIV"),nc=document.documentElement,Ad=document.defaultView),ds.style.transform=n,n=Ad.getComputedStyle(nc.appendChild(ds),null).getPropertyValue("transform"),nc.removeChild(ds),n=n.slice(7,-1).split(","),ec(+n[0],+n[1],+n[2],+n[3],+n[4],+n[5]))}function Rd(n){return n==null?Wo:(qo||(qo=document.createElementNS("http://www.w3.org/2000/svg","g")),qo.setAttribute("transform",n),(n=qo.transform.baseVal.consolidate())?(n=n.matrix,ec(n.a,n.b,n.c,n.d,n.e,n.f)):Wo)}function Ld(n,t,e,i){function r(c){return c.length?c.pop()+" ":""}function s(c,u,h,f,d,g){if(c!==h||u!==f){var x=d.push("translate(",null,t,null,e);g.push({i:x-4,x:ye(c,h)},{i:x-2,x:ye(u,f)})}else(h||f)&&d.push("translate("+h+t+f+e)}function o(c,u,h,f){c!==u?(c-u>180?u+=360:u-c>180&&(c+=360),f.push({i:h.push(r(h)+"rotate(",null,i)-2,x:ye(c,u)})):u&&h.push(r(h)+"rotate("+u+i)}function a(c,u,h,f){c!==u?f.push({i:h.push(r(h)+"skewX(",null,i)-2,x:ye(c,u)}):u&&h.push(r(h)+"skewX("+u+i)}function l(c,u,h,f,d,g){if(c!==h||u!==f){var x=d.push(r(d)+"scale(",null,",",null,")");g.push({i:x-4,x:ye(c,h)},{i:x-2,x:ye(u,f)})}else(h!==1||f!==1)&&d.push(r(d)+"scale("+h+","+f+")")}return function(c,u){var h=[],f=[];return c=n(c),u=n(u),s(c.translateX,c.translateY,u.translateX,u.translateY,h,f),o(c.rotate,u.rotate,h,f),a(c.skewX,u.skewX,h,f),l(c.scaleX,c.scaleY,u.scaleX,u.scaleY,h,f),c=u=null,function(d){for(var g=-1,x=f.length,v;++g<x;)h[(v=f[g]).i]=v.x(d);return h.join("")}}}var ic=Ld(Cd,"px, ","px)","deg)"),rc=Ld(Rd,", ",")",")");function Pd(n){return function(t,e){var i=n((t=pi(t)).h,(e=pi(e)).h),r=bn(t.s,e.s),s=bn(t.l,e.l),o=bn(t.opacity,e.opacity);return function(a){return t.h=i(a),t.s=r(a),t.l=s(a),t.opacity=o(a),t+""}}}var sc=Pd(yd),oy=Pd(bn);var ji=0,ms=0,ps=0,Id=1e3,Xo,gs,Yo=0,xi=0,Zo=0,xs=typeof performance=="object"&&performance.now?performance:Date,Nd=typeof window=="object"&&window.requestAnimationFrame?window.requestAnimationFrame.bind(window):function(n){setTimeout(n,17)};function tr(){return xi||(Nd(ay),xi=xs.now()+Zo)}function ay(){xi=0}function ys(){this._call=this._time=this._next=null}ys.prototype=Jo.prototype={constructor:ys,restart:function(n,t,e){if(typeof n!="function")throw new TypeError("callback is not a function");e=(e==null?tr():+e)+(t==null?0:+t),!this._next&&gs!==this&&(gs?gs._next=this:Xo=this,gs=this),this._call=n,this._time=e,oc()},stop:function(){this._call&&(this._call=null,this._time=1/0,oc())}};function Jo(n,t,e){var i=new ys;return i.restart(n,t,e),i}function Fd(){tr(),++ji;for(var n=Xo,t;n;)(t=xi-n._time)>=0&&n._call.call(null,t),n=n._next;--ji}function Dd(){xi=(Yo=xs.now())+Zo,ji=ms=0;try{Fd()}finally{ji=0,cy(),xi=0}}function ly(){var n=xs.now(),t=n-Yo;t>Id&&(Zo-=t,Yo=n)}function cy(){for(var n,t=Xo,e,i=1/0;t;)t._call?(i>t._time&&(i=t._time),n=t,t=t._next):(e=t._next,t._next=null,t=n?n._next=e:Xo=e);gs=n,oc(i)}function oc(n){if(!ji){ms&&(ms=clearTimeout(ms));var t=n-xi;t>24?(n<1/0&&(ms=setTimeout(Dd,n-xs.now()-Zo)),ps&&(ps=clearInterval(ps))):(ps||(Yo=xs.now(),ps=setInterval(ly,Id)),ji=1,Nd(Dd))}}function $o(n,t,e){var i=new ys;return t=t==null?0:+t,i.restart(function(r){i.stop(),n(r+t)},t,e),i}var uy=Wl("start","end","cancel","interrupt"),hy=[],Ud=0,ac=1,Qo=2,Ko=3,zd=4,jo=5,vs=6;function kn(n,t,e,i,r,s){var o=n.__transition;if(!o)n.__transition={};else if(e in o)return;fy(n,e,{name:t,index:i,group:r,on:uy,tween:hy,time:s.time,delay:s.delay,duration:s.duration,ease:s.ease,timer:null,state:Ud})}function _s(n,t){var e=ue(n,t);if(e.state>Ud)throw new Error("too late; already scheduled");return e}function Ae(n,t){var e=ue(n,t);if(e.state>Ko)throw new Error("too late; already running");return e}function ue(n,t){var e=n.__transition;if(!e||!(e=e[t]))throw new Error("transition not found");return e}function fy(n,t,e){var i=n.__transition,r;i[t]=e,e.timer=Jo(s,0,e.time);function s(c){e.state=ac,e.timer.restart(o,e.delay,e.time),e.delay<=c&&o(c-e.delay)}function o(c){var u,h,f,d;if(e.state!==ac)return l();for(u in i)if(d=i[u],d.name===e.name){if(d.state===Ko)return $o(o);d.state===zd?(d.state=vs,d.timer.stop(),d.on.call("interrupt",n,n.__data__,d.index,d.group),delete i[u]):+u<t&&(d.state=vs,d.timer.stop(),d.on.call("cancel",n,n.__data__,d.index,d.group),delete i[u])}if($o(function(){e.state===Ko&&(e.state=zd,e.timer.restart(a,e.delay,e.time),a(c))}),e.state=Qo,e.on.call("start",n,n.__data__,e.index,e.group),e.state===Qo){for(e.state=Ko,r=new Array(f=e.tween.length),u=0,h=-1;u<f;++u)(d=e.tween[u].value.call(n,n.__data__,e.index,e.group))&&(r[++h]=d);r.length=h+1}}function a(c){for(var u=c<e.duration?e.ease.call(null,c/e.duration):(e.timer.restart(l),e.state=jo,1),h=-1,f=r.length;++h<f;)r[h].call(n,u);e.state===jo&&(e.on.call("end",n,n.__data__,e.index,e.group),l())}function l(){e.state=vs,e.timer.stop(),delete i[t];for(var c in i)return;delete n.__transition}}function ws(n,t){var e=n.__transition,i,r,s=!0,o;if(!!e){t=t==null?null:t+"";for(o in e){if((i=e[o]).name!==t){s=!1;continue}r=i.state>Qo&&i.state<jo,i.state=vs,i.timer.stop(),i.on.call(r?"interrupt":"cancel",n,n.__data__,i.index,i.group),delete e[o]}s&&delete n.__transition}}function Bd(n){return this.each(function(){ws(this,n)})}function dy(n,t){var e,i;return function(){var r=Ae(this,n),s=r.tween;if(s!==e){i=e=s;for(var o=0,a=i.length;o<a;++o)if(i[o].name===t){i=i.slice(),i.splice(o,1);break}}r.tween=i}}function py(n,t,e){var i,r;if(typeof e!="function")throw new Error;return function(){var s=Ae(this,n),o=s.tween;if(o!==i){r=(i=o).slice();for(var a={name:t,value:e},l=0,c=r.length;l<c;++l)if(r[l].name===t){r[l]=a;break}l===c&&r.push(a)}s.tween=r}}function Od(n,t){var e=this._id;if(n+="",arguments.length<2){for(var i=ue(this.node(),e).tween,r=0,s=i.length,o;r<s;++r)if((o=i[r]).name===n)return o.value;return null}return this.each((t==null?dy:py)(e,n,t))}function er(n,t,e){var i=n._id;return n.each(function(){var r=Ae(this,i);(r.value||(r.value={}))[t]=e.apply(this,arguments)}),function(r){return ue(r,i).value[t]}}function ta(n,t){var e;return(typeof t=="number"?ye:t instanceof Je?mi:(e=Je(t))?(t=e,mi):fs)(n,t)}function my(n){return function(){this.removeAttribute(n)}}function gy(n){return function(){this.removeAttributeNS(n.space,n.local)}}function xy(n,t,e){var i,r=e+"",s;return function(){var o=this.getAttribute(n);return o===r?null:o===i?s:s=t(i=o,e)}}function yy(n,t,e){var i,r=e+"",s;return function(){var o=this.getAttributeNS(n.space,n.local);return o===r?null:o===i?s:s=t(i=o,e)}}function vy(n,t,e){var i,r,s;return function(){var o,a=e(this),l;return a==null?void this.removeAttribute(n):(o=this.getAttribute(n),l=a+"",o===l?null:o===i&&l===r?s:(r=l,s=t(i=o,a)))}}function _y(n,t,e){var i,r,s;return function(){var o,a=e(this),l;return a==null?void this.removeAttributeNS(n.space,n.local):(o=this.getAttributeNS(n.space,n.local),l=a+"",o===l?null:o===i&&l===r?s:(r=l,s=t(i=o,a)))}}function kd(n,t){var e=wn(n),i=e==="transform"?rc:ta;return this.attrTween(n,typeof t=="function"?(e.local?_y:vy)(e,i,er(this,"attr."+n,t)):t==null?(e.local?gy:my)(e):(e.local?yy:xy)(e,i,t))}function wy(n,t){return function(e){this.setAttribute(n,t.call(this,e))}}function My(n,t){return function(e){this.setAttributeNS(n.space,n.local,t.call(this,e))}}function by(n,t){var e,i;function r(){var s=t.apply(this,arguments);return s!==i&&(e=(i=s)&&My(n,s)),e}return r._value=t,r}function Sy(n,t){var e,i;function r(){var s=t.apply(this,arguments);return s!==i&&(e=(i=s)&&wy(n,s)),e}return r._value=t,r}function Hd(n,t){var e="attr."+n;if(arguments.length<2)return(e=this.tween(e))&&e._value;if(t==null)return this.tween(e,null);if(typeof t!="function")throw new Error;var i=wn(n);return this.tween(e,(i.local?by:Sy)(i,t))}function Ey(n,t){return function(){_s(this,n).delay=+t.apply(this,arguments)}}function Ty(n,t){return t=+t,function(){_s(this,n).delay=t}}function Vd(n){var t=this._id;return arguments.length?this.each((typeof n=="function"?Ey:Ty)(t,n)):ue(this.node(),t).delay}function Ay(n,t){return function(){Ae(this,n).duration=+t.apply(this,arguments)}}function Cy(n,t){return t=+t,function(){Ae(this,n).duration=t}}function Gd(n){var t=this._id;return arguments.length?this.each((typeof n=="function"?Ay:Cy)(t,n)):ue(this.node(),t).duration}function Ry(n,t){if(typeof t!="function")throw new Error;return function(){Ae(this,n).ease=t}}function Wd(n){var t=this._id;return arguments.length?this.each(Ry(t,n)):ue(this.node(),t).ease}function qd(n){typeof n!="function"&&(n=as(n));for(var t=this._groups,e=t.length,i=new Array(e),r=0;r<e;++r)for(var s=t[r],o=s.length,a=i[r]=[],l,c=0;c<o;++c)(l=s[c])&&n.call(l,l.__data__,c,s)&&a.push(l);return new we(i,this._parents,this._name,this._id)}function Xd(n){if(n._id!==this._id)throw new Error;for(var t=this._groups,e=n._groups,i=t.length,r=e.length,s=Math.min(i,r),o=new Array(i),a=0;a<s;++a)for(var l=t[a],c=e[a],u=l.length,h=o[a]=new Array(u),f,d=0;d<u;++d)(f=l[d]||c[d])&&(h[d]=f);for(;a<i;++a)o[a]=t[a];return new we(o,this._parents,this._name,this._id)}function Ly(n){return(n+"").trim().split(/^|\s+/).every(function(t){var e=t.indexOf(".");return e>=0&&(t=t.slice(0,e)),!t||t==="start"})}function Py(n,t,e){var i,r,s=Ly(t)?_s:Ae;return function(){var o=s(this,n),a=o.on;a!==i&&(r=(i=a).copy()).on(t,e),o.on=r}}function Yd(n,t){var e=this._id;return arguments.length<2?ue(this.node(),e).on.on(n):this.each(Py(e,n,t))}function Dy(n){return function(){var t=this.parentNode;for(var e in this.__transition)if(+e!==n)return;t&&t.removeChild(this)}}function Zd(){return this.on("end.remove",Dy(this._id))}function Jd(n){var t=this._name,e=this._id;typeof n!="function"&&(n=di(n));for(var i=this._groups,r=i.length,s=new Array(r),o=0;o<r;++o)for(var a=i[o],l=a.length,c=s[o]=new Array(l),u,h,f=0;f<l;++f)(u=a[f])&&(h=n.call(u,u.__data__,f,a))&&("__data__"in u&&(h.__data__=u.__data__),c[f]=h,kn(c[f],t,e,f,c,ue(u,e)));return new we(s,this._parents,t,e)}function $d(n){var t=this._name,e=this._id;typeof n!="function"&&(n=os(n));for(var i=this._groups,r=i.length,s=[],o=[],a=0;a<r;++a)for(var l=i[a],c=l.length,u,h=0;h<c;++h)if(u=l[h]){for(var f=n.call(u,u.__data__,h,l),d,g=ue(u,e),x=0,v=f.length;x<v;++x)(d=f[x])&&kn(d,t,e,x,f,g);s.push(f),o.push(u)}return new we(s,o,t,e)}var Iy=Mn.prototype.constructor;function Kd(){return new Iy(this._groups,this._parents)}function Ny(n,t){var e,i,r;return function(){var s=On(this,n),o=(this.style.removeProperty(n),On(this,n));return s===o?null:s===e&&o===i?r:r=t(e=s,i=o)}}function Qd(n){return function(){this.style.removeProperty(n)}}function Fy(n,t,e){var i,r=e+"",s;return function(){var o=On(this,n);return o===r?null:o===i?s:s=t(i=o,e)}}function zy(n,t,e){var i,r,s;return function(){var o=On(this,n),a=e(this),l=a+"";return a==null&&(l=a=(this.style.removeProperty(n),On(this,n))),o===l?null:o===i&&l===r?s:(r=l,s=t(i=o,a))}}function Uy(n,t){var e,i,r,s="style."+t,o="end."+s,a;return function(){var l=Ae(this,n),c=l.on,u=l.value[s]==null?a||(a=Qd(t)):void 0;(c!==e||r!==u)&&(i=(e=c).copy()).on(o,r=u),l.on=i}}function jd(n,t,e){var i=(n+="")=="transform"?ic:ta;return t==null?this.styleTween(n,Ny(n,i)).on("end.style."+n,Qd(n)):typeof t=="function"?this.styleTween(n,zy(n,i,er(this,"style."+n,t))).each(Uy(this._id,n)):this.styleTween(n,Fy(n,i,t),e).on("end.style."+n,null)}function By(n,t,e){return function(i){this.style.setProperty(n,t.call(this,i),e)}}function Oy(n,t,e){var i,r;function s(){var o=t.apply(this,arguments);return o!==r&&(i=(r=o)&&By(n,o,e)),i}return s._value=t,s}function tp(n,t,e){var i="style."+(n+="");if(arguments.length<2)return(i=this.tween(i))&&i._value;if(t==null)return this.tween(i,null);if(typeof t!="function")throw new Error;return this.tween(i,Oy(n,t,e==null?"":e))}function ky(n){return function(){this.textContent=n}}function Hy(n){return function(){var t=n(this);this.textContent=t==null?"":t}}function ep(n){return this.tween("text",typeof n=="function"?Hy(er(this,"text",n)):ky(n==null?"":n+""))}function Vy(n){return function(t){this.textContent=n.call(this,t)}}function Gy(n){var t,e;function i(){var r=n.apply(this,arguments);return r!==e&&(t=(e=r)&&Vy(r)),t}return i._value=n,i}function np(n){var t="text";if(arguments.length<1)return(t=this.tween(t))&&t._value;if(n==null)return this.tween(t,null);if(typeof n!="function")throw new Error;return this.tween(t,Gy(n))}function ip(){for(var n=this._name,t=this._id,e=ea(),i=this._groups,r=i.length,s=0;s<r;++s)for(var o=i[s],a=o.length,l,c=0;c<a;++c)if(l=o[c]){var u=ue(l,t);kn(l,n,e,c,o,{time:u.time+u.delay+u.duration,delay:0,duration:u.duration,ease:u.ease})}return new we(i,this._parents,n,e)}function rp(){var n,t,e=this,i=e._id,r=e.size();return new Promise(function(s,o){var a={value:o},l={value:function(){--r===0&&s()}};e.each(function(){var c=Ae(this,i),u=c.on;u!==n&&(t=(n=u).copy(),t._.cancel.push(a),t._.interrupt.push(a),t._.end.push(l)),c.on=t})})}var Wy=0;function we(n,t,e,i){this._groups=n,this._parents=t,this._name=e,this._id=i}function lc(n){return Mn().transition(n)}function ea(){return++Wy}var nr=Mn.prototype;we.prototype=lc.prototype={constructor:we,select:Jd,selectAll:$d,filter:qd,merge:Xd,selection:Kd,transition:ip,call:nr.call,nodes:nr.nodes,node:nr.node,size:nr.size,empty:nr.empty,each:nr.each,on:Yd,attr:kd,attrTween:Hd,style:jd,styleTween:tp,text:ep,textTween:np,remove:Zd,tween:Od,delay:Vd,duration:Gd,ease:Wd,end:rp};function na(n){return((n*=2)<=1?n*n*n:(n-=2)*n*n+2)/2}var cc={time:null,delay:0,duration:250,ease:na};function qy(n,t){for(var e;!(e=n.__transition)||!(e=e[t]);)if(!(n=n.parentNode))return cc.time=tr(),cc;return e}function sp(n){var t,e;n instanceof we?(t=n._id,n=n._name):(t=ea(),(e=cc).time=tr(),n=n==null?null:n+"");for(var i=this._groups,r=i.length,s=0;s<r;++s)for(var o=i[s],a=o.length,l,c=0;c<a;++c)(l=o[c])&&kn(l,n,t,c,o,e||qy(l,t));return new we(i,this._parents,n,t)}Mn.prototype.interrupt=Bd;Mn.prototype.transition=sp;function op(n){return[+n[0],+n[1]]}function Xy(n){return[op(n[0]),op(n[1])]}var GP={name:"x",handles:["w","e"].map(uc),input:function(n,t){return n==null?null:[[+n[0],t[0][1]],[+n[1],t[1][1]]]},output:function(n){return n&&[n[0][0],n[1][0]]}},WP={name:"y",handles:["n","s"].map(uc),input:function(n,t){return n==null?null:[[t[0][0],+n[0]],[t[1][0],+n[1]]]},output:function(n){return n&&[n[0][1],n[1][1]]}},qP={name:"xy",handles:["n","w","e","s","nw","ne","sw","se"].map(uc),input:function(n){return n==null?null:Xy(n)},output:function(n){return n}};function uc(n){return{type:n}}var ap=Math.PI,Yy=ap/2,Zy=ap*2;var Jy=Array.prototype.slice;var Be="$";function ia(){}ia.prototype=lp.prototype={constructor:ia,has:function(n){return Be+n in this},get:function(n){return this[Be+n]},set:function(n,t){return this[Be+n]=t,this},remove:function(n){var t=Be+n;return t in this&&delete this[t]},clear:function(){for(var n in this)n[0]===Be&&delete this[n]},keys:function(){var n=[];for(var t in this)t[0]===Be&&n.push(t.slice(1));return n},values:function(){var n=[];for(var t in this)t[0]===Be&&n.push(this[t]);return n},entries:function(){var n=[];for(var t in this)t[0]===Be&&n.push({key:t.slice(1),value:this[t]});return n},size:function(){var n=0;for(var t in this)t[0]===Be&&++n;return n},empty:function(){for(var n in this)if(n[0]===Be)return!1;return!0},each:function(n){for(var t in this)t[0]===Be&&n(this[t],t.slice(1),this)}};function lp(n,t){var e=new ia;if(n instanceof ia)n.each(function(a,l){e.set(l,a)});else if(Array.isArray(n)){var i=-1,r=n.length,s;if(t==null)for(;++i<r;)e.set(i,n[i]);else for(;++i<r;)e.set(t(s=n[i],i,n),s)}else if(n)for(var o in n)e.set(o,n[o]);return e}var yi=lp;function ra(){}var vi=yi.prototype;ra.prototype=$y.prototype={constructor:ra,has:vi.has,add:function(n){return n+="",this[Be+n]=n,this},remove:vi.remove,clear:vi.clear,values:vi.keys,size:vi.size,empty:vi.empty,each:vi.each};function $y(n,t){var e=new ra;if(n instanceof ra)n.each(function(s){e.add(s)});else if(n){var i=-1,r=n.length;if(t==null)for(;++i<r;)e.add(n[i]);else for(;++i<r;)e.add(t(n[i],i,n))}return e}var Ky=Array.prototype,cp=Ky.slice;var TI=Math.PI*(3-Math.sqrt(5));function hp(n){return Math.abs(n=Math.round(n))>=1e21?n.toLocaleString("en").replace(/,/g,""):n.toString(10)}function _i(n,t){if((e=(n=t?n.toExponential(t-1):n.toExponential()).indexOf("e"))<0)return null;var e,i=n.slice(0,e);return[i.length>1?i[0]+i.slice(2):i,+n.slice(e+1)]}function un(n){return n=_i(Math.abs(n)),n?n[1]:NaN}function fp(n,t){return function(e,i){for(var r=e.length,s=[],o=0,a=n[0],l=0;r>0&&a>0&&(l+a+1>i&&(a=Math.max(1,i-l)),s.push(e.substring(r-=a,r+a)),!((l+=a+1)>i));)a=n[o=(o+1)%n.length];return s.reverse().join(t)}}function dp(n){return function(t){return t.replace(/[0-9]/g,function(e){return n[+e]})}}var tv=/^(?:(.)?([<>=^]))?([+\-( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?(~)?([a-z%])?$/i;function Hn(n){if(!(t=tv.exec(n)))throw new Error("invalid format: "+n);var t;return new sa({fill:t[1],align:t[2],sign:t[3],symbol:t[4],zero:t[5],width:t[6],comma:t[7],precision:t[8]&&t[8].slice(1),trim:t[9],type:t[10]})}Hn.prototype=sa.prototype;function sa(n){this.fill=n.fill===void 0?" ":n.fill+"",this.align=n.align===void 0?">":n.align+"",this.sign=n.sign===void 0?"-":n.sign+"",this.symbol=n.symbol===void 0?"":n.symbol+"",this.zero=!!n.zero,this.width=n.width===void 0?void 0:+n.width,this.comma=!!n.comma,this.precision=n.precision===void 0?void 0:+n.precision,this.trim=!!n.trim,this.type=n.type===void 0?"":n.type+""}sa.prototype.toString=function(){return this.fill+this.align+this.sign+this.symbol+(this.zero?"0":"")+(this.width===void 0?"":Math.max(1,this.width|0))+(this.comma?",":"")+(this.precision===void 0?"":"."+Math.max(0,this.precision|0))+(this.trim?"~":"")+this.type};function pp(n){t:for(var t=n.length,e=1,i=-1,r;e<t;++e)switch(n[e]){case".":i=r=e;break;case"0":i===0&&(i=e),r=e;break;default:if(!+n[e])break t;i>0&&(i=0);break}return i>0?n.slice(0,i)+n.slice(r+1):n}var hc;function mp(n,t){var e=_i(n,t);if(!e)return n+"";var i=e[0],r=e[1],s=r-(hc=Math.max(-8,Math.min(8,Math.floor(r/3)))*3)+1,o=i.length;return s===o?i:s>o?i+new Array(s-o+1).join("0"):s>0?i.slice(0,s)+"."+i.slice(s):"0."+new Array(1-s).join("0")+_i(n,Math.max(0,t+s-1))[0]}function fc(n,t){var e=_i(n,t);if(!e)return n+"";var i=e[0],r=e[1];return r<0?"0."+new Array(-r).join("0")+i:i.length>r+1?i.slice(0,r+1)+"."+i.slice(r+1):i+new Array(r-i.length+2).join("0")}var dc={"%":function(n,t){return(n*100).toFixed(t)},b:function(n){return Math.round(n).toString(2)},c:function(n){return n+""},d:hp,e:function(n,t){return n.toExponential(t)},f:function(n,t){return n.toFixed(t)},g:function(n,t){return n.toPrecision(t)},o:function(n){return Math.round(n).toString(8)},p:function(n,t){return fc(n*100,t)},r:fc,s:mp,X:function(n){return Math.round(n).toString(16).toUpperCase()},x:function(n){return Math.round(n).toString(16)}};function pc(n){return n}var gp=Array.prototype.map,xp=["y","z","a","f","p","n","\xB5","m","","k","M","G","T","P","E","Z","Y"];function yp(n){var t=n.grouping===void 0||n.thousands===void 0?pc:fp(gp.call(n.grouping,Number),n.thousands+""),e=n.currency===void 0?"":n.currency[0]+"",i=n.currency===void 0?"":n.currency[1]+"",r=n.decimal===void 0?".":n.decimal+"",s=n.numerals===void 0?pc:dp(gp.call(n.numerals,String)),o=n.percent===void 0?"%":n.percent+"",a=n.minus===void 0?"-":n.minus+"",l=n.nan===void 0?"NaN":n.nan+"";function c(h){h=Hn(h);var f=h.fill,d=h.align,g=h.sign,x=h.symbol,v=h.zero,m=h.width,p=h.comma,b=h.precision,_=h.trim,S=h.type;S==="n"?(p=!0,S="g"):dc[S]||(b===void 0&&(b=12),_=!0,S="g"),(v||f==="0"&&d==="=")&&(v=!0,f="0",d="=");var L=x==="$"?e:x==="#"&&/[boxX]/.test(S)?"0"+S.toLowerCase():"",A=x==="$"?i:/[%p]/.test(S)?o:"",H=dc[S],tt=/[defgprs%]/.test(S);b=b===void 0?6:/[gprs]/.test(S)?Math.max(1,Math.min(21,b)):Math.max(0,Math.min(20,b));function X(y){var R=L,D=A,F,z,N;if(S==="c")D=H(y)+D,y="";else{y=+y;var V=y<0||1/y<0;if(y=isNaN(y)?l:H(Math.abs(y),b),_&&(y=pp(y)),V&&+y==0&&g!=="+"&&(V=!1),R=(V?g==="("?g:a:g==="-"||g==="("?"":g)+R,D=(S==="s"?xp[8+hc/3]:"")+D+(V&&g==="("?")":""),tt){for(F=-1,z=y.length;++F<z;)if(N=y.charCodeAt(F),48>N||N>57){D=(N===46?r+y.slice(F+1):y.slice(F))+D,y=y.slice(0,F);break}}}p&&!v&&(y=t(y,1/0));var Q=R.length+y.length+D.length,at=Q<m?new Array(m-Q+1).join(f):"";switch(p&&v&&(y=t(at+y,at.length?m-D.length:1/0),at=""),d){case"<":y=R+y+D+at;break;case"=":y=R+at+y+D;break;case"^":y=at.slice(0,Q=at.length>>1)+R+y+D+at.slice(Q);break;default:y=at+R+y+D;break}return s(y)}return X.toString=function(){return h+""},X}function u(h,f){var d=c((h=Hn(h),h.type="f",h)),g=Math.max(-8,Math.min(8,Math.floor(un(f)/3)))*3,x=Math.pow(10,-g),v=xp[8+g/3];return function(m){return d(x*m)+v}}return{format:c,formatPrefix:u}}var oa,Oe,aa;mc({decimal:".",thousands:",",grouping:[3],currency:["$",""],minus:"-"});function mc(n){return oa=yp(n),Oe=oa.format,aa=oa.formatPrefix,oa}function gc(n){return Math.max(0,-un(Math.abs(n)))}function xc(n,t){return Math.max(0,Math.max(-8,Math.min(8,Math.floor(un(t)/3)))*3-un(Math.abs(n)))}function yc(n,t){return n=Math.abs(n),t=Math.abs(t)-n,Math.max(0,un(t)-un(n))+1}function We(){return Math.random()}var ev=function n(t){function e(i,r){return i=i==null?0:+i,r=r==null?1:+r,arguments.length===1?(r=i,i=0):r-=i,function(){return t()*r+i}}return e.source=n,e}(We);var vc=function n(t){function e(i,r){var s,o;return i=i==null?0:+i,r=r==null?1:+r,function(){var a;if(s!=null)a=s,s=null;else do s=t()*2-1,a=t()*2-1,o=s*s+a*a;while(!o||o>1);return i+r*a*Math.sqrt(-2*Math.log(o)/o)}}return e.source=n,e}(We);var nv=function n(t){function e(){var i=vc.source(t).apply(this,arguments);return function(){return Math.exp(i())}}return e.source=n,e}(We);var _c=function n(t){function e(i){return function(){for(var r=0,s=0;s<i;++s)r+=t();return r}}return e.source=n,e}(We);var iv=function n(t){function e(i){var r=_c.source(t)(i);return function(){return r()/i}}return e.source=n,e}(We);var rv=function n(t){function e(i){return function(){return-Math.log(1-t())/i}}return e.source=n,e}(We);function Pe(n,t){switch(arguments.length){case 0:break;case 1:this.range(n);break;default:this.range(t).domain(n);break}return this}var vp=Array.prototype,bs=vp.map,wi=vp.slice;function _p(n){return function(){return n}}function wc(n){return+n}var wp=[0,1];function De(n){return n}function Mc(n,t){return(t-=n=+n)?function(e){return(e-n)/t}:_p(isNaN(t)?NaN:.5)}function Mp(n){var t=n[0],e=n[n.length-1],i;return t>e&&(i=t,t=e,e=i),function(r){return Math.max(t,Math.min(e,r))}}function ov(n,t,e){var i=n[0],r=n[1],s=t[0],o=t[1];return r<i?(i=Mc(r,i),s=e(o,s)):(i=Mc(i,r),s=e(s,o)),function(a){return s(i(a))}}function av(n,t,e){var i=Math.min(n.length,t.length)-1,r=new Array(i),s=new Array(i),o=-1;for(n[i]<n[0]&&(n=n.slice().reverse(),t=t.slice().reverse());++o<i;)r[o]=Mc(n[o],n[o+1]),s[o]=e(t[o],t[o+1]);return function(a){var l=Bn(n,a,1,i)-1;return s[l](r[l](a))}}function Vn(n,t){return t.domain(n.domain()).range(n.range()).interpolate(n.interpolate()).clamp(n.clamp()).unknown(n.unknown())}function Ss(){var n=wp,t=wp,e=gi,i,r,s,o=De,a,l,c;function u(){return a=Math.min(n.length,t.length)>2?av:ov,l=c=null,h}function h(f){return isNaN(f=+f)?s:(l||(l=a(n.map(i),t,e)))(i(o(f)))}return h.invert=function(f){return o(r((c||(c=a(t,n.map(i),ye)))(f)))},h.domain=function(f){return arguments.length?(n=bs.call(f,wc),o===De||(o=Mp(n)),u()):n.slice()},h.range=function(f){return arguments.length?(t=wi.call(f),u()):t.slice()},h.rangeRound=function(f){return t=wi.call(f),e=tc,u()},h.clamp=function(f){return arguments.length?(o=f?Mp(n):De,h):o!==De},h.interpolate=function(f){return arguments.length?(e=f,u()):e},h.unknown=function(f){return arguments.length?(s=f,h):s},function(f,d){return i=f,r=d,u()}}function Es(n,t){return Ss()(n,t)}function bc(n,t,e,i){var r=_n(n,t,e),s;switch(i=Hn(i==null?",f":i),i.type){case"s":{var o=Math.max(Math.abs(n),Math.abs(t));return i.precision==null&&!isNaN(s=xc(r,o))&&(i.precision=s),aa(i,o)}case"":case"e":case"g":case"p":case"r":{i.precision==null&&!isNaN(s=yc(r,Math.max(Math.abs(n),Math.abs(t))))&&(i.precision=s-(i.type==="e"));break}case"f":case"%":{i.precision==null&&!isNaN(s=gc(r))&&(i.precision=s-(i.type==="%")*2);break}}return Oe(i)}function Mi(n){var t=n.domain;return n.ticks=function(e){var i=t();return rs(i[0],i[i.length-1],e==null?10:e)},n.tickFormat=function(e,i){var r=t();return bc(r[0],r[r.length-1],e==null?10:e,i)},n.nice=function(e){e==null&&(e=10);var i=t(),r=0,s=i.length-1,o=i[r],a=i[s],l;return a<o&&(l=o,o=a,a=l,l=r,r=s,s=l),l=Ji(o,a,e),l>0?(o=Math.floor(o/l)*l,a=Math.ceil(a/l)*l,l=Ji(o,a,e)):l<0&&(o=Math.ceil(o*l)/l,a=Math.floor(a*l)/l,l=Ji(o,a,e)),l>0?(i[r]=Math.floor(o/l)*l,i[s]=Math.ceil(a/l)*l,t(i)):l<0&&(i[r]=Math.ceil(o*l)/l,i[s]=Math.floor(a*l)/l,t(i)),n},n}function ir(){var n=Es(De,De);return n.copy=function(){return Vn(n,ir())},Pe.apply(n,arguments),Mi(n)}function la(n,t){n=n.slice();var e=0,i=n.length-1,r=n[e],s=n[i],o;return s<r&&(o=e,e=i,i=o,o=r,r=s,s=o),n[e]=t.floor(r),n[i]=t.ceil(s),n}function bp(n){return Math.log(n)}function Sp(n){return Math.exp(n)}function lv(n){return-Math.log(-n)}function cv(n){return-Math.exp(-n)}function uv(n){return isFinite(n)?+("1e"+n):n<0?0:n}function hv(n){return n===10?uv:n===Math.E?Math.exp:function(t){return Math.pow(n,t)}}function fv(n){return n===Math.E?Math.log:n===10&&Math.log10||n===2&&Math.log2||(n=Math.log(n),function(t){return Math.log(t)/n})}function Ep(n){return function(t){return-n(-t)}}function Sc(n){var t=n(bp,Sp),e=t.domain,i=10,r,s;function o(){return r=fv(i),s=hv(i),e()[0]<0?(r=Ep(r),s=Ep(s),n(lv,cv)):n(bp,Sp),t}return t.base=function(a){return arguments.length?(i=+a,o()):i},t.domain=function(a){return arguments.length?(e(a),o()):e()},t.ticks=function(a){var l=e(),c=l[0],u=l[l.length-1],h;(h=u<c)&&(f=c,c=u,u=f);var f=r(c),d=r(u),g,x,v,m=a==null?10:+a,p=[];if(!(i%1)&&d-f<m){if(f=Math.round(f)-1,d=Math.round(d)+1,c>0){for(;f<d;++f)for(x=1,g=s(f);x<i;++x)if(v=g*x,!(v<c)){if(v>u)break;p.push(v)}}else for(;f<d;++f)for(x=i-1,g=s(f);x>=1;--x)if(v=g*x,!(v<c)){if(v>u)break;p.push(v)}}else p=rs(f,d,Math.min(d-f,m)).map(s);return h?p.reverse():p},t.tickFormat=function(a,l){if(l==null&&(l=i===10?".0e":","),typeof l!="function"&&(l=Oe(l)),a===1/0)return l;a==null&&(a=10);var c=Math.max(1,i*a/t.ticks().length);return function(u){var h=u/s(Math.round(r(u)));return h*i<i-.5&&(h*=i),h<=c?l(u):""}},t.nice=function(){return e(la(e(),{floor:function(a){return s(Math.floor(r(a)))},ceil:function(a){return s(Math.ceil(r(a)))}}))},t}function Ts(){var n=Sc(Ss()).domain([1,10]);return n.copy=function(){return Vn(n,Ts()).base(n.base())},Pe.apply(n,arguments),n}var Ec=new Date,Tc=new Date;function Yt(n,t,e,i){function r(s){return n(s=arguments.length===0?new Date:new Date(+s)),s}return r.floor=function(s){return n(s=new Date(+s)),s},r.ceil=function(s){return n(s=new Date(s-1)),t(s,1),n(s),s},r.round=function(s){var o=r(s),a=r.ceil(s);return s-o<a-s?o:a},r.offset=function(s,o){return t(s=new Date(+s),o==null?1:Math.floor(o)),s},r.range=function(s,o,a){var l=[],c;if(s=r.ceil(s),a=a==null?1:Math.floor(a),!(s<o)||!(a>0))return l;do l.push(c=new Date(+s)),t(s,a),n(s);while(c<s&&s<o);return l},r.filter=function(s){return Yt(function(o){if(o>=o)for(;n(o),!s(o);)o.setTime(o-1)},function(o,a){if(o>=o)if(a<0)for(;++a<=0;)for(;t(o,-1),!s(o););else for(;--a>=0;)for(;t(o,1),!s(o););})},e&&(r.count=function(s,o){return Ec.setTime(+s),Tc.setTime(+o),n(Ec),n(Tc),Math.floor(e(Ec,Tc))},r.every=function(s){return s=Math.floor(s),!isFinite(s)||!(s>0)?null:s>1?r.filter(i?function(o){return i(o)%s===0}:function(o){return r.count(0,o)%s===0}):r}),r}var ca=Yt(function(){},function(n,t){n.setTime(+n+t)},function(n,t){return t-n});ca.every=function(n){return n=Math.floor(n),!isFinite(n)||!(n>0)?null:n>1?Yt(function(t){t.setTime(Math.floor(t/n)*n)},function(t,e){t.setTime(+t+e*n)},function(t,e){return(e-t)/n}):ca};var ua=ca,Tp=ca.range;var bi=1e3,Sn=6e4,Ac=36e5,ha=864e5,fa=6048e5;var Ap=Yt(function(n){n.setTime(n-n.getMilliseconds())},function(n,t){n.setTime(+n+t*bi)},function(n,t){return(t-n)/bi},function(n){return n.getUTCSeconds()}),da=Ap,Cp=Ap.range;var Rp=Yt(function(n){n.setTime(n-n.getMilliseconds()-n.getSeconds()*bi)},function(n,t){n.setTime(+n+t*Sn)},function(n,t){return(t-n)/Sn},function(n){return n.getMinutes()}),Cc=Rp,dv=Rp.range;var Lp=Yt(function(n){n.setTime(n-n.getMilliseconds()-n.getSeconds()*bi-n.getMinutes()*Sn)},function(n,t){n.setTime(+n+t*Ac)},function(n,t){return(t-n)/Ac},function(n){return n.getHours()}),Rc=Lp,pv=Lp.range;var Pp=Yt(function(n){n.setHours(0,0,0,0)},function(n,t){n.setDate(n.getDate()+t)},function(n,t){return(t-n-(t.getTimezoneOffset()-n.getTimezoneOffset())*Sn)/ha},function(n){return n.getDate()-1}),rr=Pp,mv=Pp.range;function Si(n){return Yt(function(t){t.setDate(t.getDate()-(t.getDay()+7-n)%7),t.setHours(0,0,0,0)},function(t,e){t.setDate(t.getDate()+e*7)},function(t,e){return(e-t-(e.getTimezoneOffset()-t.getTimezoneOffset())*Sn)/fa})}var Ei=Si(0),sr=Si(1),Dp=Si(2),Ip=Si(3),Gn=Si(4),Np=Si(5),Fp=Si(6),zp=Ei.range,gv=sr.range,xv=Dp.range,yv=Ip.range,vv=Gn.range,_v=Np.range,wv=Fp.range;var Up=Yt(function(n){n.setDate(1),n.setHours(0,0,0,0)},function(n,t){n.setMonth(n.getMonth()+t)},function(n,t){return t.getMonth()-n.getMonth()+(t.getFullYear()-n.getFullYear())*12},function(n){return n.getMonth()}),Lc=Up,Mv=Up.range;var Pc=Yt(function(n){n.setMonth(0,1),n.setHours(0,0,0,0)},function(n,t){n.setFullYear(n.getFullYear()+t)},function(n,t){return t.getFullYear()-n.getFullYear()},function(n){return n.getFullYear()});Pc.every=function(n){return!isFinite(n=Math.floor(n))||!(n>0)?null:Yt(function(t){t.setFullYear(Math.floor(t.getFullYear()/n)*n),t.setMonth(0,1),t.setHours(0,0,0,0)},function(t,e){t.setFullYear(t.getFullYear()+e*n)})};var En=Pc,bv=Pc.range;var Bp=Yt(function(n){n.setUTCHours(0,0,0,0)},function(n,t){n.setUTCDate(n.getUTCDate()+t)},function(n,t){return(t-n)/ha},function(n){return n.getUTCDate()-1}),pa=Bp,Sv=Bp.range;function Ti(n){return Yt(function(t){t.setUTCDate(t.getUTCDate()-(t.getUTCDay()+7-n)%7),t.setUTCHours(0,0,0,0)},function(t,e){t.setUTCDate(t.getUTCDate()+e*7)},function(t,e){return(e-t)/fa})}var As=Ti(0),or=Ti(1),Op=Ti(2),kp=Ti(3),Wn=Ti(4),Hp=Ti(5),Vp=Ti(6),Gp=As.range,Ev=or.range,Tv=Op.range,Av=kp.range,Cv=Wn.range,Rv=Hp.range,Lv=Vp.range;var Dc=Yt(function(n){n.setUTCMonth(0,1),n.setUTCHours(0,0,0,0)},function(n,t){n.setUTCFullYear(n.getUTCFullYear()+t)},function(n,t){return t.getUTCFullYear()-n.getUTCFullYear()},function(n){return n.getUTCFullYear()});Dc.every=function(n){return!isFinite(n=Math.floor(n))||!(n>0)?null:Yt(function(t){t.setUTCFullYear(Math.floor(t.getUTCFullYear()/n)*n),t.setUTCMonth(0,1),t.setUTCHours(0,0,0,0)},function(t,e){t.setUTCFullYear(t.getUTCFullYear()+e*n)})};var Ai=Dc,Pv=Dc.range;function Ic(n){if(0<=n.y&&n.y<100){var t=new Date(-1,n.m,n.d,n.H,n.M,n.S,n.L);return t.setFullYear(n.y),t}return new Date(n.y,n.m,n.d,n.H,n.M,n.S,n.L)}function Nc(n){if(0<=n.y&&n.y<100){var t=new Date(Date.UTC(-1,n.m,n.d,n.H,n.M,n.S,n.L));return t.setUTCFullYear(n.y),t}return new Date(Date.UTC(n.y,n.m,n.d,n.H,n.M,n.S,n.L))}function Cs(n,t,e){return{y:n,m:t,d:e,H:0,M:0,S:0,L:0}}function Fc(n){var t=n.dateTime,e=n.date,i=n.time,r=n.periods,s=n.days,o=n.shortDays,a=n.months,l=n.shortMonths,c=Rs(r),u=Ls(r),h=Rs(s),f=Ls(s),d=Rs(o),g=Ls(o),x=Rs(a),v=Ls(a),m=Rs(l),p=Ls(l),b={a:V,A:Q,b:at,B:G,c:null,d:Jp,e:Jp,f:t_,g:u_,G:f_,H:Kv,I:Qv,j:jv,L:tm,m:e_,M:n_,p:$,q:lt,Q:Qp,s:jp,S:i_,u:r_,U:s_,V:o_,w:a_,W:l_,x:null,X:null,y:c_,Y:h_,Z:d_,"%":Kp},_={a:dt,A:xt,b:k,B:Ft,c:null,d:$p,e:$p,f:x_,g:A_,G:R_,H:p_,I:m_,j:g_,L:nm,m:y_,M:v_,p:mt,q:St,Q:Qp,s:jp,S:__,u:w_,U:M_,V:b_,w:S_,W:E_,x:null,X:null,y:T_,Y:C_,Z:L_,"%":Kp},S={a:X,A:y,b:R,B:D,c:F,d:Yp,e:Yp,f:Yv,g:Xp,G:qp,H:Zp,I:Zp,j:Gv,L:Xv,m:Vv,M:Wv,p:tt,q:Hv,Q:Jv,s:$v,S:qv,u:zv,U:Uv,V:Bv,w:Fv,W:Ov,x:z,X:N,y:Xp,Y:qp,Z:kv,"%":Zv};b.x=L(e,b),b.X=L(i,b),b.c=L(t,b),_.x=L(e,_),_.X=L(i,_),_.c=L(t,_);function L(B,st){return function(nt){var C=[],j=-1,J=0,it=B.length,et,vt,bt;for(nt instanceof Date||(nt=new Date(+nt));++j<it;)B.charCodeAt(j)===37&&(C.push(B.slice(J,j)),(vt=Wp[et=B.charAt(++j)])!=null?et=B.charAt(++j):vt=et==="e"?" ":"0",(bt=st[et])&&(et=bt(nt,vt)),C.push(et),J=j+1);return C.push(B.slice(J,j)),C.join("")}}function A(B,st){return function(nt){var C=Cs(1900,void 0,1),j=H(C,B,nt+="",0),J,it;if(j!=nt.length)return null;if("Q"in C)return new Date(C.Q);if("s"in C)return new Date(C.s*1e3+("L"in C?C.L:0));if(st&&!("Z"in C)&&(C.Z=0),"p"in C&&(C.H=C.H%12+C.p*12),C.m===void 0&&(C.m="q"in C?C.q:0),"V"in C){if(C.V<1||C.V>53)return null;"w"in C||(C.w=1),"Z"in C?(J=Nc(Cs(C.y,0,1)),it=J.getUTCDay(),J=it>4||it===0?or.ceil(J):or(J),J=pa.offset(J,(C.V-1)*7),C.y=J.getUTCFullYear(),C.m=J.getUTCMonth(),C.d=J.getUTCDate()+(C.w+6)%7):(J=Ic(Cs(C.y,0,1)),it=J.getDay(),J=it>4||it===0?sr.ceil(J):sr(J),J=rr.offset(J,(C.V-1)*7),C.y=J.getFullYear(),C.m=J.getMonth(),C.d=J.getDate()+(C.w+6)%7)}else("W"in C||"U"in C)&&("w"in C||(C.w="u"in C?C.u%7:"W"in C?1:0),it="Z"in C?Nc(Cs(C.y,0,1)).getUTCDay():Ic(Cs(C.y,0,1)).getDay(),C.m=0,C.d="W"in C?(C.w+6)%7+C.W*7-(it+5)%7:C.w+C.U*7-(it+6)%7);return"Z"in C?(C.H+=C.Z/100|0,C.M+=C.Z%100,Nc(C)):Ic(C)}}function H(B,st,nt,C){for(var j=0,J=st.length,it=nt.length,et,vt;j<J;){if(C>=it)return-1;if(et=st.charCodeAt(j++),et===37){if(et=st.charAt(j++),vt=S[et in Wp?st.charAt(j++):et],!vt||(C=vt(B,nt,C))<0)return-1}else if(et!=nt.charCodeAt(C++))return-1}return C}function tt(B,st,nt){var C=c.exec(st.slice(nt));return C?(B.p=u[C[0].toLowerCase()],nt+C[0].length):-1}function X(B,st,nt){var C=d.exec(st.slice(nt));return C?(B.w=g[C[0].toLowerCase()],nt+C[0].length):-1}function y(B,st,nt){var C=h.exec(st.slice(nt));return C?(B.w=f[C[0].toLowerCase()],nt+C[0].length):-1}function R(B,st,nt){var C=m.exec(st.slice(nt));return C?(B.m=p[C[0].toLowerCase()],nt+C[0].length):-1}function D(B,st,nt){var C=x.exec(st.slice(nt));return C?(B.m=v[C[0].toLowerCase()],nt+C[0].length):-1}function F(B,st,nt){return H(B,t,st,nt)}function z(B,st,nt){return H(B,e,st,nt)}function N(B,st,nt){return H(B,i,st,nt)}function V(B){return o[B.getDay()]}function Q(B){return s[B.getDay()]}function at(B){return l[B.getMonth()]}function G(B){return a[B.getMonth()]}function $(B){return r[+(B.getHours()>=12)]}function lt(B){return 1+~~(B.getMonth()/3)}function dt(B){return o[B.getUTCDay()]}function xt(B){return s[B.getUTCDay()]}function k(B){return l[B.getUTCMonth()]}function Ft(B){return a[B.getUTCMonth()]}function mt(B){return r[+(B.getUTCHours()>=12)]}function St(B){return 1+~~(B.getUTCMonth()/3)}return{format:function(B){var st=L(B+="",b);return st.toString=function(){return B},st},parse:function(B){var st=A(B+="",!1);return st.toString=function(){return B},st},utcFormat:function(B){var st=L(B+="",_);return st.toString=function(){return B},st},utcParse:function(B){var st=A(B+="",!0);return st.toString=function(){return B},st}}}var Wp={"-":"",_:" ",0:"0"},pe=/^\s*\d+/,Dv=/^%/,Iv=/[\\^$*+?|[\]().{}]/g;function Bt(n,t,e){var i=n<0?"-":"",r=(i?-n:n)+"",s=r.length;return i+(s<e?new Array(e-s+1).join(t)+r:r)}function Nv(n){return n.replace(Iv,"\\$&")}function Rs(n){return new RegExp("^(?:"+n.map(Nv).join("|")+")","i")}function Ls(n){for(var t={},e=-1,i=n.length;++e<i;)t[n[e].toLowerCase()]=e;return t}function Fv(n,t,e){var i=pe.exec(t.slice(e,e+1));return i?(n.w=+i[0],e+i[0].length):-1}function zv(n,t,e){var i=pe.exec(t.slice(e,e+1));return i?(n.u=+i[0],e+i[0].length):-1}function Uv(n,t,e){var i=pe.exec(t.slice(e,e+2));return i?(n.U=+i[0],e+i[0].length):-1}function Bv(n,t,e){var i=pe.exec(t.slice(e,e+2));return i?(n.V=+i[0],e+i[0].length):-1}function Ov(n,t,e){var i=pe.exec(t.slice(e,e+2));return i?(n.W=+i[0],e+i[0].length):-1}function qp(n,t,e){var i=pe.exec(t.slice(e,e+4));return i?(n.y=+i[0],e+i[0].length):-1}function Xp(n,t,e){var i=pe.exec(t.slice(e,e+2));return i?(n.y=+i[0]+(+i[0]>68?1900:2e3),e+i[0].length):-1}function kv(n,t,e){var i=/^(Z)|([+-]\d\d)(?::?(\d\d))?/.exec(t.slice(e,e+6));return i?(n.Z=i[1]?0:-(i[2]+(i[3]||"00")),e+i[0].length):-1}function Hv(n,t,e){var i=pe.exec(t.slice(e,e+1));return i?(n.q=i[0]*3-3,e+i[0].length):-1}function Vv(n,t,e){var i=pe.exec(t.slice(e,e+2));return i?(n.m=i[0]-1,e+i[0].length):-1}function Yp(n,t,e){var i=pe.exec(t.slice(e,e+2));return i?(n.d=+i[0],e+i[0].length):-1}function Gv(n,t,e){var i=pe.exec(t.slice(e,e+3));return i?(n.m=0,n.d=+i[0],e+i[0].length):-1}function Zp(n,t,e){var i=pe.exec(t.slice(e,e+2));return i?(n.H=+i[0],e+i[0].length):-1}function Wv(n,t,e){var i=pe.exec(t.slice(e,e+2));return i?(n.M=+i[0],e+i[0].length):-1}function qv(n,t,e){var i=pe.exec(t.slice(e,e+2));return i?(n.S=+i[0],e+i[0].length):-1}function Xv(n,t,e){var i=pe.exec(t.slice(e,e+3));return i?(n.L=+i[0],e+i[0].length):-1}function Yv(n,t,e){var i=pe.exec(t.slice(e,e+6));return i?(n.L=Math.floor(i[0]/1e3),e+i[0].length):-1}function Zv(n,t,e){var i=Dv.exec(t.slice(e,e+1));return i?e+i[0].length:-1}function Jv(n,t,e){var i=pe.exec(t.slice(e));return i?(n.Q=+i[0],e+i[0].length):-1}function $v(n,t,e){var i=pe.exec(t.slice(e));return i?(n.s=+i[0],e+i[0].length):-1}function Jp(n,t){return Bt(n.getDate(),t,2)}function Kv(n,t){return Bt(n.getHours(),t,2)}function Qv(n,t){return Bt(n.getHours()%12||12,t,2)}function jv(n,t){return Bt(1+rr.count(En(n),n),t,3)}function tm(n,t){return Bt(n.getMilliseconds(),t,3)}function t_(n,t){return tm(n,t)+"000"}function e_(n,t){return Bt(n.getMonth()+1,t,2)}function n_(n,t){return Bt(n.getMinutes(),t,2)}function i_(n,t){return Bt(n.getSeconds(),t,2)}function r_(n){var t=n.getDay();return t===0?7:t}function s_(n,t){return Bt(Ei.count(En(n)-1,n),t,2)}function em(n){var t=n.getDay();return t>=4||t===0?Gn(n):Gn.ceil(n)}function o_(n,t){return n=em(n),Bt(Gn.count(En(n),n)+(En(n).getDay()===4),t,2)}function a_(n){return n.getDay()}function l_(n,t){return Bt(sr.count(En(n)-1,n),t,2)}function c_(n,t){return Bt(n.getFullYear()%100,t,2)}function u_(n,t){return n=em(n),Bt(n.getFullYear()%100,t,2)}function h_(n,t){return Bt(n.getFullYear()%1e4,t,4)}function f_(n,t){var e=n.getDay();return n=e>=4||e===0?Gn(n):Gn.ceil(n),Bt(n.getFullYear()%1e4,t,4)}function d_(n){var t=n.getTimezoneOffset();return(t>0?"-":(t*=-1,"+"))+Bt(t/60|0,"0",2)+Bt(t%60,"0",2)}function $p(n,t){return Bt(n.getUTCDate(),t,2)}function p_(n,t){return Bt(n.getUTCHours(),t,2)}function m_(n,t){return Bt(n.getUTCHours()%12||12,t,2)}function g_(n,t){return Bt(1+pa.count(Ai(n),n),t,3)}function nm(n,t){return Bt(n.getUTCMilliseconds(),t,3)}function x_(n,t){return nm(n,t)+"000"}function y_(n,t){return Bt(n.getUTCMonth()+1,t,2)}function v_(n,t){return Bt(n.getUTCMinutes(),t,2)}function __(n,t){return Bt(n.getUTCSeconds(),t,2)}function w_(n){var t=n.getUTCDay();return t===0?7:t}function M_(n,t){return Bt(As.count(Ai(n)-1,n),t,2)}function im(n){var t=n.getUTCDay();return t>=4||t===0?Wn(n):Wn.ceil(n)}function b_(n,t){return n=im(n),Bt(Wn.count(Ai(n),n)+(Ai(n).getUTCDay()===4),t,2)}function S_(n){return n.getUTCDay()}function E_(n,t){return Bt(or.count(Ai(n)-1,n),t,2)}function T_(n,t){return Bt(n.getUTCFullYear()%100,t,2)}function A_(n,t){return n=im(n),Bt(n.getUTCFullYear()%100,t,2)}function C_(n,t){return Bt(n.getUTCFullYear()%1e4,t,4)}function R_(n,t){var e=n.getUTCDay();return n=e>=4||e===0?Wn(n):Wn.ceil(n),Bt(n.getUTCFullYear()%1e4,t,4)}function L_(){return"+0000"}function Kp(){return"%"}function Qp(n){return+n}function jp(n){return Math.floor(+n/1e3)}var ar,ma,rm,sm,om;zc({dateTime:"%x, %X",date:"%-m/%-d/%Y",time:"%-I:%M:%S %p",periods:["AM","PM"],days:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],shortDays:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],months:["January","February","March","April","May","June","July","August","September","October","November","December"],shortMonths:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]});function zc(n){return ar=Fc(n),ma=ar.format,rm=ar.parse,sm=ar.utcFormat,om=ar.utcParse,ar}var Ps=1e3,Ds=Ps*60,Is=Ds*60,Ns=Is*24,P_=Ns*7,am=Ns*30,Uc=Ns*365;function D_(n){return new Date(n)}function I_(n){return n instanceof Date?+n:+new Date(+n)}function Bc(n,t,e,i,r,s,o,a,l){var c=Es(De,De),u=c.invert,h=c.domain,f=l(".%L"),d=l(":%S"),g=l("%I:%M"),x=l("%I %p"),v=l("%a %d"),m=l("%b %d"),p=l("%B"),b=l("%Y"),_=[[o,1,Ps],[o,5,5*Ps],[o,15,15*Ps],[o,30,30*Ps],[s,1,Ds],[s,5,5*Ds],[s,15,15*Ds],[s,30,30*Ds],[r,1,Is],[r,3,3*Is],[r,6,6*Is],[r,12,12*Is],[i,1,Ns],[i,2,2*Ns],[e,1,P_],[t,1,am],[t,3,3*am],[n,1,Uc]];function S(A){return(o(A)<A?f:s(A)<A?d:r(A)<A?g:i(A)<A?x:t(A)<A?e(A)<A?v:m:n(A)<A?p:b)(A)}function L(A,H,tt,X){if(A==null&&(A=10),typeof A=="number"){var y=Math.abs(tt-H)/A,R=is(function(D){return D[2]}).right(_,y);R===_.length?(X=_n(H/Uc,tt/Uc,A),A=n):R?(R=_[y/_[R-1][2]<_[R][2]/y?R-1:R],X=R[1],A=R[0]):(X=Math.max(_n(H,tt,A),1),A=a)}return X==null?A:A.every(X)}return c.invert=function(A){return new Date(u(A))},c.domain=function(A){return arguments.length?h(bs.call(A,I_)):h().map(D_)},c.ticks=function(A,H){var tt=h(),X=tt[0],y=tt[tt.length-1],R=y<X,D;return R&&(D=X,X=y,y=D),D=L(A,X,y,H),D=D?D.range(X,y+1):[],R?D.reverse():D},c.tickFormat=function(A,H){return H==null?S:l(H)},c.nice=function(A,H){var tt=h();return(A=L(A,tt[0],tt[tt.length-1],H))?h(la(tt,A)):c},c.copy=function(){return Vn(c,Bc(n,t,e,i,r,s,o,a,l))},c}function Fs(){return Pe.apply(Bc(En,Lc,Ei,rr,Rc,Cc,da,ua,ma).domain([new Date(2e3,0,1),new Date(2e3,0,2)]),arguments)}function Oc(){this._=null}function lr(n){n.U=n.C=n.L=n.R=n.P=n.N=null}Oc.prototype={constructor:Oc,insert:function(n,t){var e,i,r;if(n){if(t.P=n,t.N=n.N,n.N&&(n.N.P=t),n.N=t,n.R){for(n=n.R;n.L;)n=n.L;n.L=t}else n.R=t;e=n}else this._?(n=cm(this._),t.P=null,t.N=n,n.P=n.L=t,e=n):(t.P=t.N=null,this._=t,e=null);for(t.L=t.R=null,t.U=e,t.C=!0,n=t;e&&e.C;)i=e.U,e===i.L?(r=i.R,r&&r.C?(e.C=r.C=!1,i.C=!0,n=i):(n===e.R&&(zs(this,e),n=e,e=n.U),e.C=!1,i.C=!0,Us(this,i))):(r=i.L,r&&r.C?(e.C=r.C=!1,i.C=!0,n=i):(n===e.L&&(Us(this,e),n=e,e=n.U),e.C=!1,i.C=!0,zs(this,i))),e=n.U;this._.C=!1},remove:function(n){n.N&&(n.N.P=n.P),n.P&&(n.P.N=n.N),n.N=n.P=null;var t=n.U,e,i=n.L,r=n.R,s,o;if(i?r?s=cm(r):s=i:s=r,t?t.L===n?t.L=s:t.R=s:this._=s,i&&r?(o=s.C,s.C=n.C,s.L=i,i.U=s,s!==r?(t=s.U,s.U=n.U,n=s.R,t.L=n,s.R=r,r.U=s):(s.U=t,t=s,n=s.R)):(o=n.C,n=s),n&&(n.U=t),!o){if(n&&n.C){n.C=!1;return}do{if(n===this._)break;if(n===t.L){if(e=t.R,e.C&&(e.C=!1,t.C=!0,zs(this,t),e=t.R),e.L&&e.L.C||e.R&&e.R.C){(!e.R||!e.R.C)&&(e.L.C=!1,e.C=!0,Us(this,e),e=t.R),e.C=t.C,t.C=e.R.C=!1,zs(this,t),n=this._;break}}else if(e=t.L,e.C&&(e.C=!1,t.C=!0,Us(this,t),e=t.L),e.L&&e.L.C||e.R&&e.R.C){(!e.L||!e.L.C)&&(e.R.C=!1,e.C=!0,zs(this,e),e=t.L),e.C=t.C,t.C=e.L.C=!1,Us(this,t),n=this._;break}e.C=!0,n=t,t=t.U}while(!n.C);n&&(n.C=!1)}}};function zs(n,t){var e=t,i=t.R,r=e.U;r?r.L===e?r.L=i:r.R=i:n._=i,i.U=r,e.U=i,e.R=i.L,e.R&&(e.R.U=e),i.L=e}function Us(n,t){var e=t,i=t.L,r=e.U;r?r.L===e?r.L=i:r.R=i:n._=i,i.U=r,e.U=i,e.L=i.R,e.L&&(e.L.U=e),i.R=e}function cm(n){for(;n.L;)n=n.L;return n}var kc=Oc;function cr(n,t,e,i){var r=[null,null],s=me.push(r)-1;return r.left=n,r.right=t,e&&Bs(r,n,t,e),i&&Bs(r,t,n,i),Ce[n.index].halfedges.push(s),Ce[t.index].halfedges.push(s),r}function ur(n,t,e){var i=[t,e];return i.left=n,i}function Bs(n,t,e,i){!n[0]&&!n[1]?(n[0]=i,n.left=t,n.right=e):n.left===e?n[1]=i:n[0]=i}function z_(n,t,e,i,r){var s=n[0],o=n[1],a=s[0],l=s[1],c=o[0],u=o[1],h=0,f=1,d=c-a,g=u-l,x;if(x=t-a,!(!d&&x>0)){if(x/=d,d<0){if(x<h)return;x<f&&(f=x)}else if(d>0){if(x>f)return;x>h&&(h=x)}if(x=i-a,!(!d&&x<0)){if(x/=d,d<0){if(x>f)return;x>h&&(h=x)}else if(d>0){if(x<h)return;x<f&&(f=x)}if(x=e-l,!(!g&&x>0)){if(x/=g,g<0){if(x<h)return;x<f&&(f=x)}else if(g>0){if(x>f)return;x>h&&(h=x)}if(x=r-l,!(!g&&x<0)){if(x/=g,g<0){if(x>f)return;x>h&&(h=x)}else if(g>0){if(x<h)return;x<f&&(f=x)}return!(h>0)&&!(f<1)||(h>0&&(n[0]=[a+h*d,l+h*g]),f<1&&(n[1]=[a+f*d,l+f*g])),!0}}}}}function U_(n,t,e,i,r){var s=n[1];if(s)return!0;var o=n[0],a=n.left,l=n.right,c=a[0],u=a[1],h=l[0],f=l[1],d=(c+h)/2,g=(u+f)/2,x,v;if(f===u){if(d<t||d>=i)return;if(c>h){if(!o)o=[d,e];else if(o[1]>=r)return;s=[d,r]}else{if(!o)o=[d,r];else if(o[1]<e)return;s=[d,e]}}else if(x=(c-h)/(f-u),v=g-x*d,x<-1||x>1)if(c>h){if(!o)o=[(e-v)/x,e];else if(o[1]>=r)return;s=[(r-v)/x,r]}else{if(!o)o=[(r-v)/x,r];else if(o[1]<e)return;s=[(e-v)/x,e]}else if(u<f){if(!o)o=[t,x*t+v];else if(o[0]>=i)return;s=[i,x*i+v]}else{if(!o)o=[i,x*i+v];else if(o[0]<t)return;s=[t,x*t+v]}return n[0]=o,n[1]=s,!0}function um(n,t,e,i){for(var r=me.length,s;r--;)(!U_(s=me[r],n,t,e,i)||!z_(s,n,t,e,i)||!(Math.abs(s[0][0]-s[1][0])>Xt||Math.abs(s[0][1]-s[1][1])>Xt))&&delete me[r]}function hm(n){return Ce[n.index]={site:n,halfedges:[]}}function B_(n,t){var e=n.site,i=t.left,r=t.right;return e===r&&(r=i,i=e),r?Math.atan2(r[1]-i[1],r[0]-i[0]):(e===i?(i=t[1],r=t[0]):(i=t[0],r=t[1]),Math.atan2(i[0]-r[0],r[1]-i[1]))}function Hc(n,t){return t[+(t.left!==n.site)]}function O_(n,t){return t[+(t.left===n.site)]}function fm(){for(var n=0,t=Ce.length,e,i,r,s;n<t;++n)if((e=Ce[n])&&(s=(i=e.halfedges).length)){var o=new Array(s),a=new Array(s);for(r=0;r<s;++r)o[r]=r,a[r]=B_(e,me[i[r]]);for(o.sort(function(l,c){return a[c]-a[l]}),r=0;r<s;++r)a[r]=i[o[r]];for(r=0;r<s;++r)i[r]=a[r]}}function dm(n,t,e,i){var r=Ce.length,s,o,a,l,c,u,h,f,d,g,x,v,m=!0;for(s=0;s<r;++s)if(o=Ce[s]){for(a=o.site,c=o.halfedges,l=c.length;l--;)me[c[l]]||c.splice(l,1);for(l=0,u=c.length;l<u;)g=O_(o,me[c[l]]),x=g[0],v=g[1],h=Hc(o,me[c[++l%u]]),f=h[0],d=h[1],(Math.abs(x-f)>Xt||Math.abs(v-d)>Xt)&&(c.splice(l,0,me.push(ur(a,g,Math.abs(x-n)<Xt&&i-v>Xt?[n,Math.abs(f-n)<Xt?d:i]:Math.abs(v-i)<Xt&&e-x>Xt?[Math.abs(d-i)<Xt?f:e,i]:Math.abs(x-e)<Xt&&v-t>Xt?[e,Math.abs(f-e)<Xt?d:t]:Math.abs(v-t)<Xt&&x-n>Xt?[Math.abs(d-t)<Xt?f:n,t]:null))-1),++u);u&&(m=!1)}if(m){var p,b,_,S=1/0;for(s=0,m=null;s<r;++s)(o=Ce[s])&&(a=o.site,p=a[0]-n,b=a[1]-t,_=p*p+b*b,_<S&&(S=_,m=o));if(m){var L=[n,t],A=[n,i],H=[e,i],tt=[e,t];m.halfedges.push(me.push(ur(a=m.site,L,A))-1,me.push(ur(a,A,H))-1,me.push(ur(a,H,tt))-1,me.push(ur(a,tt,L))-1)}}for(s=0;s<r;++s)(o=Ce[s])&&(o.halfedges.length||delete Ce[s])}var pm=[],ga;function k_(){lr(this),this.x=this.y=this.arc=this.site=this.cy=null}function Ci(n){var t=n.P,e=n.N;if(!(!t||!e)){var i=t.site,r=n.site,s=e.site;if(i!==s){var o=r[0],a=r[1],l=i[0]-o,c=i[1]-a,u=s[0]-o,h=s[1]-a,f=2*(l*h-c*u);if(!(f>=-mm)){var d=l*l+c*c,g=u*u+h*h,x=(h*d-c*g)/f,v=(l*g-u*d)/f,m=pm.pop()||new k_;m.arc=n,m.site=r,m.x=x+o,m.y=(m.cy=v+a)+Math.sqrt(x*x+v*v),n.circle=m;for(var p=null,b=hr._;b;)if(m.y<b.y||m.y===b.y&&m.x<=b.x)if(b.L)b=b.L;else{p=b.P;break}else if(b.R)b=b.R;else{p=b;break}hr.insert(p,m),p||(ga=m)}}}}function Ri(n){var t=n.circle;t&&(t.P||(ga=t.N),hr.remove(t),pm.push(t),lr(t),n.circle=null)}var xm=[];function H_(){lr(this),this.edge=this.site=this.circle=null}function gm(n){var t=xm.pop()||new H_;return t.site=n,t}function Vc(n){Ri(n),Li.remove(n),xm.push(n),lr(n)}function ym(n){var t=n.circle,e=t.x,i=t.cy,r=[e,i],s=n.P,o=n.N,a=[n];Vc(n);for(var l=s;l.circle&&Math.abs(e-l.circle.x)<Xt&&Math.abs(i-l.circle.cy)<Xt;)s=l.P,a.unshift(l),Vc(l),l=s;a.unshift(l),Ri(l);for(var c=o;c.circle&&Math.abs(e-c.circle.x)<Xt&&Math.abs(i-c.circle.cy)<Xt;)o=c.N,a.push(c),Vc(c),c=o;a.push(c),Ri(c);var u=a.length,h;for(h=1;h<u;++h)c=a[h],l=a[h-1],Bs(c.edge,l.site,c.site,r);l=a[0],c=a[u-1],c.edge=cr(l.site,c.site,null,r),Ci(l),Ci(c)}function vm(n){for(var t=n[0],e=n[1],i,r,s,o,a=Li._;a;)if(s=_m(a,e)-t,s>Xt)a=a.L;else if(o=t-V_(a,e),o>Xt){if(!a.R){i=a;break}a=a.R}else{s>-Xt?(i=a.P,r=a):o>-Xt?(i=a,r=a.N):i=r=a;break}hm(n);var l=gm(n);if(Li.insert(i,l),!(!i&&!r)){if(i===r){Ri(i),r=gm(i.site),Li.insert(l,r),l.edge=r.edge=cr(i.site,l.site),Ci(i),Ci(r);return}if(!r){l.edge=cr(i.site,l.site);return}Ri(i),Ri(r);var c=i.site,u=c[0],h=c[1],f=n[0]-u,d=n[1]-h,g=r.site,x=g[0]-u,v=g[1]-h,m=2*(f*v-d*x),p=f*f+d*d,b=x*x+v*v,_=[(v*p-d*b)/m+u,(f*b-x*p)/m+h];Bs(r.edge,c,g,_),l.edge=cr(c,n,null,_),r.edge=cr(n,g,null,_),Ci(i),Ci(r)}}function _m(n,t){var e=n.site,i=e[0],r=e[1],s=r-t;if(!s)return i;var o=n.P;if(!o)return-1/0;e=o.site;var a=e[0],l=e[1],c=l-t;if(!c)return a;var u=a-i,h=1/s-1/c,f=u/c;return h?(-f+Math.sqrt(f*f-2*h*(u*u/(-2*c)-l+c/2+r-s/2)))/h+i:(i+a)/2}function V_(n,t){var e=n.N;if(e)return _m(e,t);var i=n.site;return i[1]===t?i[0]:1/0}var Xt=1e-6,mm=1e-12,Li,Ce,hr,me;function G_(n,t,e){return(n[0]-e[0])*(t[1]-n[1])-(n[0]-t[0])*(e[1]-n[1])}function W_(n,t){return t[1]-n[1]||t[0]-n[0]}function xa(n,t){var e=n.sort(W_).pop(),i,r,s;for(me=[],Ce=new Array(n.length),Li=new kc,hr=new kc;;)if(s=ga,e&&(!s||e[1]<s.y||e[1]===s.y&&e[0]<s.x))(e[0]!==i||e[1]!==r)&&(vm(e),i=e[0],r=e[1]),e=n.pop();else if(s)ym(s.arc);else break;if(fm(),t){var o=+t[0][0],a=+t[0][1],l=+t[1][0],c=+t[1][1];um(o,a,l,c),dm(o,a,l,c)}this.edges=me,this.cells=Ce,Li=hr=me=Ce=null}xa.prototype={constructor:xa,polygons:function(){var n=this.edges;return this.cells.map(function(t){var e=t.halfedges.map(function(i){return Hc(t,n[i])});return e.data=t.site.data,e})},triangles:function(){var n=[],t=this.edges;return this.cells.forEach(function(e,i){if(!!(a=(s=e.halfedges).length))for(var r=e.site,s,o=-1,a,l,c=t[s[a-1]],u=c.left===r?c.right:c.left;++o<a;)l=u,c=t[s[o]],u=c.left===r?c.right:c.left,l&&u&&i<l.index&&i<u.index&&G_(r,l,u)<0&&n.push([r.data,l.data,u.data])}),n},links:function(){return this.edges.filter(function(n){return n.right}).map(function(n){return{source:n.left.data,target:n.right.data}})},find:function(n,t,e){for(var i=this,r,s=i._found||0,o=i.cells.length,a;!(a=i.cells[s]);)if(++s>=o)return null;var l=n-a.site[0],c=t-a.site[1],u=l*l+c*c;do a=i.cells[r=s],s=null,a.halfedges.forEach(function(h){var f=i.edges[h],d=f.left;if(!((d===a.site||!d)&&!(d=f.right))){var g=n-d[0],x=t-d[1],v=g*g+x*x;v<u&&(u=v,s=d.index)}});while(s!==null);return i._found=r,e==null||u<=e*e?a.site:null}};function Pi(n,t,e){this.k=n,this.x=t,this.y=e}Pi.prototype={constructor:Pi,scale:function(n){return n===1?this:new Pi(this.k*n,this.x,this.y)},translate:function(n,t){return n===0&t===0?this:new Pi(this.k,this.x+this.k*n,this.y+this.k*t)},apply:function(n){return[n[0]*this.k+this.x,n[1]*this.k+this.y]},applyX:function(n){return n*this.k+this.x},applyY:function(n){return n*this.k+this.y},invert:function(n){return[(n[0]-this.x)/this.k,(n[1]-this.y)/this.k]},invertX:function(n){return(n-this.x)/this.k},invertY:function(n){return(n-this.y)/this.k},rescaleX:function(n){return n.copy().domain(n.range().map(this.invertX,this).map(n.invert,n))},rescaleY:function(n){return n.copy().domain(n.range().map(this.invertY,this).map(n.invert,n))},toString:function(){return"translate("+this.x+","+this.y+") scale("+this.k+")"}};var Gc=new Pi(1,0,0);Wc.prototype=Pi.prototype;function Wc(n){for(;!n.__zoom;)if(!(n=n.parentNode))return Gc;return n.__zoom}var bm=1e4,Sm=.001,Em=Oe(".2~e"),q_=Oe(".4~r"),wm=Oe(",~");function Mm(n){if(n===0)return"0";let t=Math.abs(n);return t>=bm||t<Sm?Em(n):q_(n)}var Xc={formatTick:Mm,formatShort:Mm,formatReadable(n){let t=Math.abs(n);return t>=bm||t<Sm?Em(n):wm(n)},formatLong:wm},sk=new Intl.NumberFormat(void 0,{maximumFractionDigits:4});var ok=Oe("0.3~s"),ak=Oe(",.3~f");var X_=1e3,Y_=60*X_,Z_=60*Y_,J_=24*Z_,lk=365*J_,ck=Oe(".4~");var $_=Fs().tickFormat(),qc,Tm={formatTick(n){return $_(new Date(n))},formatShort(n){return new Date(n).toLocaleString(qc,{year:"numeric",month:"short",day:"numeric",hour:"numeric",minute:"numeric",second:"numeric"})},formatReadable(n){return new Date(n).toLocaleString(qc,{year:"numeric",month:"short",day:"numeric",hour:"numeric",minute:"numeric",second:"numeric",timeZoneName:"short"})},formatLong(n){return new Date(n).toLocaleString(qc,{year:"numeric",month:"long",day:"numeric",hour:"numeric",minute:"numeric",second:"numeric",timeZoneName:"short",fractionalSecondDigits:3})}};function fr(n){switch(n){case on.LINEAR:return new Yc;case on.LOG10:return new Zc;case on.TIME:return new Jc;default:let t=n;throw new RangeError(`ScaleType ${t} not supported.`)}}var K_=.05,Yc=class{constructor(){this.defaultFormatter=Xc}transform(t,e,i){let[r,s]=t,o=s-r,[a,l]=e,c=l-a;return o===0?a:c/o*(i-r)+a}forward(t,e,i){return this.transform(t,e,i)}reverse(t,e,i){return this.transform(e,t,i)}niceDomain(t){let[e,i]=t;if(i<e)throw new Error("Unexpected input: min is larger than max");if(i===e)return e===0?[-1,1]:e<0?[2*e,0]:[0,2*e];let r=ir(),s=(i-e+Number.EPSILON)*K_,[o,a]=r.domain([e-s,i+s]).nice().domain();return[o,a]}ticks(t,e){return ir().domain(t).ticks(e)}isSafeNumber(t){return Number.isFinite(t)}},Zc=class{constructor(){this.defaultFormatter=Xc}transform(t){return Math.log10(t>0?t:Number.MIN_VALUE)}untransform(t){return Math.exp(t/Math.LOG10E)}forward(t,e,i){if(i<=0)return e[0];let[r,s]=t,[o,a]=e,l=this.transform(r),u=this.transform(s)-l,h=a-o;return i=this.transform(i),h/(u+Number.EPSILON)*(i-l)+o}reverse(t,e,i){let[r,s]=t,[o,a]=e,l=this.transform(r),u=this.transform(s)-l,h=a-o,f=u/(h+Number.EPSILON)*(i-o)+l;return this.untransform(f)}niceDomain(t){let[e,i]=t;if(e>i)throw new Error("Unexpected input: min is larger than max");let r=Math.max(e,Number.MIN_VALUE),s=Math.max(i,Number.MIN_VALUE);return i<=0?[Number.MIN_VALUE,1]:[Math.max(Number.MIN_VALUE,r*.5),s*2]}ticks(t,e){let i=t[0]<=0?Number.MIN_VALUE:t[0],r=t[1]<=0?Number.MIN_VALUE:t[1],s=Ts().domain([i,r]).ticks(e);return s.length?s:t}isSafeNumber(t){return Number.isFinite(t)&&t>0}},Jc=class{constructor(){this.scale=Fs(),this.defaultFormatter=Tm}forward(t,e,i){return this.scale.domain(t).range(e)(i)}reverse(t,e,i){return this.scale.domain(t).range(e).invert(i).getTime()}niceDomain(t){let[e,i]=this.scale.domain(t).nice().domain();return[e.getTime(),i.getTime()]}ticks(t,e){return this.scale.domain(t).ticks(e).map(i=>i.getTime())}isSafeNumber(t){return Number.isFinite(t)}};function Q_(n){return{x:[n.x,n.x+n.width],y:[n.y,n.y+n.height]}}var $c=!1;if(self.hasOwnProperty("WebGL2RenderingContext")&&self.hasOwnProperty("document")){let n=document.createElement("canvas");n.addEventListener("webglcontextcreationerror",()=>{$c=!1});let t=n.getContext("webgl2");$c=Boolean(t)}function j_(){return $c}function tw(){if(!self.hasOwnProperty("OffscreenCanvas"))return!1;let n=new OffscreenCanvas(0,0).getContext("webgl2");return Boolean(n)}function ew(n,t){if(n.length!==t.length)return!1;for(let e=0;e<n.length;e++)if(n[e]!==t[e])return!1;return!0}function nw(n,t){return n.x[0]===t.x[0]&&n.x[1]===t.x[1]&&n.y[0]===t.y[0]&&n.y[1]===t.y[1]}var Di={convertRectToExtent:Q_,isWebGl2Supported:j_,isWebGl2OffscreenCanvasSupported:tw,arePolylinesEqual:ew,areExtentsEqual:nw};var dr=class{constructor(){this.xScale=fr(on.LINEAR),this.yScale=fr(on.LINEAR),this.domContainerRect={x:0,width:1,y:0,height:1},this.lastUpdated=0,this.currentViewBoxRect={x:0,width:1,y:0,height:1}}getUpdateIdentifier(){return this.lastUpdated}updateIdentifier(){this.lastUpdated++}isYAxisPointedDown(){return!0}setXScale(t){this.xScale=t,this.updateIdentifier()}setYScale(t){this.yScale=t,this.updateIdentifier()}getCurrentViewBoxRect(){return this.currentViewBoxRect}setViewBoxRect(t){this.currentViewBoxRect=t,this.updateIdentifier()}setDomContainerRect(t){this.domContainerRect=t,this.updateIdentifier()}transformDataToUiCoord(t,e){let i=t,r=Di.convertRectToExtent(this.currentViewBoxRect);return[this.xScale.forward(r.x,[i.x,i.x+i.width],e[0]),this.yScale.forward(r.y,this.isYAxisPointedDown()?[i.y+i.height,i.y]:[i.y,i.y+i.height],e[1])]}};var Tn;(function(n){n[n.SVG=0]="SVG",n[n.WEBGL=1]="WEBGL"})(Tn||(Tn={}));function ya(n,t,e,i){let{color:r,visible:s,opacity:o}=i,a=n;return!a&&!s?null:(a=a!=null?a:t(),a=e(a),a.style.display=s?"":"none",a.style.stroke=r,a.style.opacity=String(o!=null?o:1),a)}var Os=class{constructor(t){this.svg=t}flush(){}onResize(t){}destroyObject(t){this.svg.removeChild(t.dom)}setUseDarkMode(t){}createPathDString(t){if(!t.length)return"";let e=new Array(t.length/2);e[0]=`M${t[0]},${t[1]}`;for(let i=1;i<t.length/2;i++)e[i]=`L${t[i*2]},${t[i*2+1]}`;return e.join("")}createOrUpdateLineObject(t,e,i){let r=ya(t==null?void 0:t.dom,()=>{let s=document.createElementNS("http://www.w3.org/2000/svg","path");s.style.fill="none";let o=this.createPathDString(e);return s.setAttribute("d",o),this.svg.appendChild(s),s},s=>{if(!(t!=null&&t.data)||!Di.arePolylinesEqual(e,t==null?void 0:t.data)){let o=this.createPathDString(e);s.setAttribute("d",o)}return s},i);return r===null?null:(r.style.strokeWidth=String(i.width),{dom:r,data:e})}createOrUpdateTriangleObject(t,e,i){let{size:r,color:s}=i,o=r*Math.sqrt(3)/2,a=new Float32Array([e.x-r/2,e.y+o/3,e.x+r/2,e.y+o/3,e.x,e.y-o*2/3]),l=ya(t==null?void 0:t.dom,()=>{let c=document.createElementNS("http://www.w3.org/2000/svg","path");c.classList.add("triangle"),c.style.fill="none";let u=this.createPathDString(a);return c.setAttribute("d",u+"Z"),this.svg.appendChild(c),c},c=>{let u=this.createPathDString(a);return c.setAttribute("d",u+"Z"),c},i);return l===null?null:(l.style.fill=s,{dom:l,data:a})}createOrUpdateCircleObject(t,e,i){let{color:r,radius:s}=i,o=ya(t==null?void 0:t.dom,()=>{let a=document.createElementNS("http://www.w3.org/2000/svg","circle");return a.style.fill=r,a.setAttribute("cx",String(e.x)),a.setAttribute("cy",String(e.y)),a.setAttribute("r",String(s)),this.svg.appendChild(a),a},a=>(a.style.fill=r,a.setAttribute("cx",String(e.x)),a.setAttribute("cy",String(e.y)),a.setAttribute("r",String(s)),a),i);return o===null?null:{dom:o,data:e}}createOrUpdateTrapezoidObject(t,e,i,r){if(e.y!==i.y)throw new RangeError("Input error: start.y != end.y.");let{altitude:s,color:o}=r,a=2/Math.sqrt(3)*s,l=new Float32Array([e.x-a/2,e.y+s/2,e.x,e.y-s/2,i.x,i.y-s/2,i.x+a/2,i.y+s/2]),c=ya(t==null?void 0:t.dom,()=>{let u=document.createElementNS("http://www.w3.org/2000/svg","path");u.classList.add("trapezoid"),u.style.fill="none";let h=this.createPathDString(l);return u.setAttribute("d",h+"Z"),this.svg.appendChild(u),u},u=>{let h=this.createPathDString(l);return u.setAttribute("d",h+"Z"),u},r);return c===null?null:(c.style.fill=o,{dom:c,data:l})}dispose(){}};var $h="137";var iw=0,Am=1,rw=2;var l0=1,sw=2,Js=3,eo=0,he=1,Hr=2,c0=1;var jn=0,Ks=1,Cm=2,Rm=3,Lm=4,ow=5,Ir=100,aw=101,lw=102,Pm=103,Dm=104,cw=200,uw=201,hw=202,fw=203,u0=204,h0=205,dw=206,pw=207,mw=208,gw=209,xw=210,yw=0,vw=1,_w=2,zu=3,ww=4,Mw=5,bw=6,Sw=7,Cl=0,Ew=1,Tw=2,ti=0,Aw=1,Cw=2,Rw=3,Lw=4,Pw=5,f0=300,Ao=301,Co=302,Uu=303,Bu=304,Rl=306,Kh=307,Ou=1e3,Ve=1001,ku=1002,fe=1003,Im=1004;var Nm=1005;var be=1006,Dw=1007;var Ll=1008;var ei=1009,Iw=1010,Nw=1011,no=1012,Fw=1013,Qa=1014,Ui=1015,Ur=1016,zw=1017,Uw=1018,Br=1020,Bw=1021,Re=1023,Ow=1024,kw=1025,Oi=1026,Vr=1027,Hw=1028,Vw=1029,Gw=1030,Ww=1031,qw=1033,Kc=33776,Qc=33777,jc=33778,tu=33779,Fm=35840,zm=35841,Um=35842,Bm=35843,Xw=36196,Om=37492,km=37496,Hm=37808,Vm=37809,Gm=37810,Wm=37811,qm=37812,Xm=37813,Ym=37814,Zm=37815,Jm=37816,$m=37817,Km=37818,Qm=37819,jm=37820,tg=37821,eg=36492,Yw=2200,Zw=2201,Jw=2202,ja=2300,tl=2301,eu=2302,Nr=2400,Fr=2401,el=2402,Qh=2500,d0=2501,$w=0;var ri=3e3,$t=3001,Kw=3200,Qw=3201,ts=0,jw=1;var nu=7680;var tM=519,io=35044,nl=35048;var ng="300 es",Hu=1035,In=class{addEventListener(t,e){this._listeners===void 0&&(this._listeners={});let i=this._listeners;i[t]===void 0&&(i[t]=[]),i[t].indexOf(e)===-1&&i[t].push(e)}hasEventListener(t,e){if(this._listeners===void 0)return!1;let i=this._listeners;return i[t]!==void 0&&i[t].indexOf(e)!==-1}removeEventListener(t,e){if(this._listeners===void 0)return;let r=this._listeners[t];if(r!==void 0){let s=r.indexOf(e);s!==-1&&r.splice(s,1)}}dispatchEvent(t){if(this._listeners===void 0)return;let i=this._listeners[t.type];if(i!==void 0){t.target=this;let r=i.slice(0);for(let s=0,o=r.length;s<o;s++)r[s].call(this,t);t.target=null}}},ve=[];for(let n=0;n<256;n++)ve[n]=(n<16?"0":"")+n.toString(16);var iu=Math.PI/180,Vu=180/Math.PI;function tn(){let n=Math.random()*4294967295|0,t=Math.random()*4294967295|0,e=Math.random()*4294967295|0,i=Math.random()*4294967295|0;return(ve[n&255]+ve[n>>8&255]+ve[n>>16&255]+ve[n>>24&255]+"-"+ve[t&255]+ve[t>>8&255]+"-"+ve[t>>16&15|64]+ve[t>>24&255]+"-"+ve[e&63|128]+ve[e>>8&255]+"-"+ve[e>>16&255]+ve[e>>24&255]+ve[i&255]+ve[i>>8&255]+ve[i>>16&255]+ve[i>>24&255]).toUpperCase()}function Ie(n,t,e){return Math.max(t,Math.min(e,n))}function eM(n,t){return(n%t+t)%t}function ru(n,t,e){return(1-e)*n+e*t}function ig(n){return(n&n-1)===0&&n!==0}function nM(n){return Math.pow(2,Math.floor(Math.log(n)/Math.LN2))}var K=class{constructor(t=0,e=0){this.x=t,this.y=e}get width(){return this.x}set width(t){this.x=t}get height(){return this.y}set height(t){this.y=t}set(t,e){return this.x=t,this.y=e,this}setScalar(t){return this.x=t,this.y=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setComponent(t,e){switch(t){case 0:this.x=e;break;case 1:this.y=e;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y)}copy(t){return this.x=t.x,this.y=t.y,this}add(t,e){return e!==void 0?(console.warn("THREE.Vector2: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(t,e)):(this.x+=t.x,this.y+=t.y,this)}addScalar(t){return this.x+=t,this.y+=t,this}addVectors(t,e){return this.x=t.x+e.x,this.y=t.y+e.y,this}addScaledVector(t,e){return this.x+=t.x*e,this.y+=t.y*e,this}sub(t,e){return e!==void 0?(console.warn("THREE.Vector2: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),this.subVectors(t,e)):(this.x-=t.x,this.y-=t.y,this)}subScalar(t){return this.x-=t,this.y-=t,this}subVectors(t,e){return this.x=t.x-e.x,this.y=t.y-e.y,this}multiply(t){return this.x*=t.x,this.y*=t.y,this}multiplyScalar(t){return this.x*=t,this.y*=t,this}divide(t){return this.x/=t.x,this.y/=t.y,this}divideScalar(t){return this.multiplyScalar(1/t)}applyMatrix3(t){let e=this.x,i=this.y,r=t.elements;return this.x=r[0]*e+r[3]*i+r[6],this.y=r[1]*e+r[4]*i+r[7],this}min(t){return this.x=Math.min(this.x,t.x),this.y=Math.min(this.y,t.y),this}max(t){return this.x=Math.max(this.x,t.x),this.y=Math.max(this.y,t.y),this}clamp(t,e){return this.x=Math.max(t.x,Math.min(e.x,this.x)),this.y=Math.max(t.y,Math.min(e.y,this.y)),this}clampScalar(t,e){return this.x=Math.max(t,Math.min(e,this.x)),this.y=Math.max(t,Math.min(e,this.y)),this}clampLength(t,e){let i=this.length();return this.divideScalar(i||1).multiplyScalar(Math.max(t,Math.min(e,i)))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this}roundToZero(){return this.x=this.x<0?Math.ceil(this.x):Math.floor(this.x),this.y=this.y<0?Math.ceil(this.y):Math.floor(this.y),this}negate(){return this.x=-this.x,this.y=-this.y,this}dot(t){return this.x*t.x+this.y*t.y}cross(t){return this.x*t.y-this.y*t.x}lengthSq(){return this.x*this.x+this.y*this.y}length(){return Math.sqrt(this.x*this.x+this.y*this.y)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)}normalize(){return this.divideScalar(this.length()||1)}angle(){return Math.atan2(-this.y,-this.x)+Math.PI}distanceTo(t){return Math.sqrt(this.distanceToSquared(t))}distanceToSquared(t){let e=this.x-t.x,i=this.y-t.y;return e*e+i*i}manhattanDistanceTo(t){return Math.abs(this.x-t.x)+Math.abs(this.y-t.y)}setLength(t){return this.normalize().multiplyScalar(t)}lerp(t,e){return this.x+=(t.x-this.x)*e,this.y+=(t.y-this.y)*e,this}lerpVectors(t,e,i){return this.x=t.x+(e.x-t.x)*i,this.y=t.y+(e.y-t.y)*i,this}equals(t){return t.x===this.x&&t.y===this.y}fromArray(t,e=0){return this.x=t[e],this.y=t[e+1],this}toArray(t=[],e=0){return t[e]=this.x,t[e+1]=this.y,t}fromBufferAttribute(t,e,i){return i!==void 0&&console.warn("THREE.Vector2: offset has been removed from .fromBufferAttribute()."),this.x=t.getX(e),this.y=t.getY(e),this}rotateAround(t,e){let i=Math.cos(e),r=Math.sin(e),s=this.x-t.x,o=this.y-t.y;return this.x=s*i-o*r+t.x,this.y=s*r+o*i+t.y,this}random(){return this.x=Math.random(),this.y=Math.random(),this}*[Symbol.iterator](){yield this.x,yield this.y}};K.prototype.isVector2=!0;var de=class{constructor(){this.elements=[1,0,0,0,1,0,0,0,1],arguments.length>0&&console.error("THREE.Matrix3: the constructor no longer reads arguments. use .set() instead.")}set(t,e,i,r,s,o,a,l,c){let u=this.elements;return u[0]=t,u[1]=r,u[2]=a,u[3]=e,u[4]=s,u[5]=l,u[6]=i,u[7]=o,u[8]=c,this}identity(){return this.set(1,0,0,0,1,0,0,0,1),this}copy(t){let e=this.elements,i=t.elements;return e[0]=i[0],e[1]=i[1],e[2]=i[2],e[3]=i[3],e[4]=i[4],e[5]=i[5],e[6]=i[6],e[7]=i[7],e[8]=i[8],this}extractBasis(t,e,i){return t.setFromMatrix3Column(this,0),e.setFromMatrix3Column(this,1),i.setFromMatrix3Column(this,2),this}setFromMatrix4(t){let e=t.elements;return this.set(e[0],e[4],e[8],e[1],e[5],e[9],e[2],e[6],e[10]),this}multiply(t){return this.multiplyMatrices(this,t)}premultiply(t){return this.multiplyMatrices(t,this)}multiplyMatrices(t,e){let i=t.elements,r=e.elements,s=this.elements,o=i[0],a=i[3],l=i[6],c=i[1],u=i[4],h=i[7],f=i[2],d=i[5],g=i[8],x=r[0],v=r[3],m=r[6],p=r[1],b=r[4],_=r[7],S=r[2],L=r[5],A=r[8];return s[0]=o*x+a*p+l*S,s[3]=o*v+a*b+l*L,s[6]=o*m+a*_+l*A,s[1]=c*x+u*p+h*S,s[4]=c*v+u*b+h*L,s[7]=c*m+u*_+h*A,s[2]=f*x+d*p+g*S,s[5]=f*v+d*b+g*L,s[8]=f*m+d*_+g*A,this}multiplyScalar(t){let e=this.elements;return e[0]*=t,e[3]*=t,e[6]*=t,e[1]*=t,e[4]*=t,e[7]*=t,e[2]*=t,e[5]*=t,e[8]*=t,this}determinant(){let t=this.elements,e=t[0],i=t[1],r=t[2],s=t[3],o=t[4],a=t[5],l=t[6],c=t[7],u=t[8];return e*o*u-e*a*c-i*s*u+i*a*l+r*s*c-r*o*l}invert(){let t=this.elements,e=t[0],i=t[1],r=t[2],s=t[3],o=t[4],a=t[5],l=t[6],c=t[7],u=t[8],h=u*o-a*c,f=a*l-u*s,d=c*s-o*l,g=e*h+i*f+r*d;if(g===0)return this.set(0,0,0,0,0,0,0,0,0);let x=1/g;return t[0]=h*x,t[1]=(r*c-u*i)*x,t[2]=(a*i-r*o)*x,t[3]=f*x,t[4]=(u*e-r*l)*x,t[5]=(r*s-a*e)*x,t[6]=d*x,t[7]=(i*l-c*e)*x,t[8]=(o*e-i*s)*x,this}transpose(){let t,e=this.elements;return t=e[1],e[1]=e[3],e[3]=t,t=e[2],e[2]=e[6],e[6]=t,t=e[5],e[5]=e[7],e[7]=t,this}getNormalMatrix(t){return this.setFromMatrix4(t).invert().transpose()}transposeIntoArray(t){let e=this.elements;return t[0]=e[0],t[1]=e[3],t[2]=e[6],t[3]=e[1],t[4]=e[4],t[5]=e[7],t[6]=e[2],t[7]=e[5],t[8]=e[8],this}setUvTransform(t,e,i,r,s,o,a){let l=Math.cos(s),c=Math.sin(s);return this.set(i*l,i*c,-i*(l*o+c*a)+o+t,-r*c,r*l,-r*(-c*o+l*a)+a+e,0,0,1),this}scale(t,e){let i=this.elements;return i[0]*=t,i[3]*=t,i[6]*=t,i[1]*=e,i[4]*=e,i[7]*=e,this}rotate(t){let e=Math.cos(t),i=Math.sin(t),r=this.elements,s=r[0],o=r[3],a=r[6],l=r[1],c=r[4],u=r[7];return r[0]=e*s+i*l,r[3]=e*o+i*c,r[6]=e*a+i*u,r[1]=-i*s+e*l,r[4]=-i*o+e*c,r[7]=-i*a+e*u,this}translate(t,e){let i=this.elements;return i[0]+=t*i[2],i[3]+=t*i[5],i[6]+=t*i[8],i[1]+=e*i[2],i[4]+=e*i[5],i[7]+=e*i[8],this}equals(t){let e=this.elements,i=t.elements;for(let r=0;r<9;r++)if(e[r]!==i[r])return!1;return!0}fromArray(t,e=0){for(let i=0;i<9;i++)this.elements[i]=t[i+e];return this}toArray(t=[],e=0){let i=this.elements;return t[e]=i[0],t[e+1]=i[1],t[e+2]=i[2],t[e+3]=i[3],t[e+4]=i[4],t[e+5]=i[5],t[e+6]=i[6],t[e+7]=i[7],t[e+8]=i[8],t}clone(){return new this.constructor().fromArray(this.elements)}};de.prototype.isMatrix3=!0;function p0(n){for(let t=n.length-1;t>=0;--t)if(n[t]>65535)return!0;return!1}function ro(n){return document.createElementNS("http://www.w3.org/1999/xhtml",n)}var m0={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074},$e={h:0,s:0,l:0},va={h:0,s:0,l:0};function su(n,t,e){return e<0&&(e+=1),e>1&&(e-=1),e<1/6?n+(t-n)*6*e:e<1/2?t:e<2/3?n+(t-n)*6*(2/3-e):n}function Or(n){return n<.04045?n*.0773993808:Math.pow(n*.9478672986+.0521327014,2.4)}function ou(n){return n<.0031308?n*12.92:1.055*Math.pow(n,.41666)-.055}var ft=class{constructor(t,e,i){return e===void 0&&i===void 0?this.set(t):this.setRGB(t,e,i)}set(t){return t&&t.isColor?this.copy(t):typeof t=="number"?this.setHex(t):typeof t=="string"&&this.setStyle(t),this}setScalar(t){return this.r=t,this.g=t,this.b=t,this}setHex(t){return t=Math.floor(t),this.r=(t>>16&255)/255,this.g=(t>>8&255)/255,this.b=(t&255)/255,this}setRGB(t,e,i){return this.r=t,this.g=e,this.b=i,this}setHSL(t,e,i){if(t=eM(t,1),e=Ie(e,0,1),i=Ie(i,0,1),e===0)this.r=this.g=this.b=i;else{let r=i<=.5?i*(1+e):i+e-i*e,s=2*i-r;this.r=su(s,r,t+1/3),this.g=su(s,r,t),this.b=su(s,r,t-1/3)}return this}setStyle(t){function e(r){r!==void 0&&parseFloat(r)<1&&console.warn("THREE.Color: Alpha component of "+t+" will be ignored.")}let i;if(i=/^((?:rgb|hsl)a?)\(([^\)]*)\)/.exec(t)){let r,s=i[1],o=i[2];switch(s){case"rgb":case"rgba":if(r=/^\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(o))return this.r=Math.min(255,parseInt(r[1],10))/255,this.g=Math.min(255,parseInt(r[2],10))/255,this.b=Math.min(255,parseInt(r[3],10))/255,e(r[4]),this;if(r=/^\s*(\d+)\%\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(o))return this.r=Math.min(100,parseInt(r[1],10))/100,this.g=Math.min(100,parseInt(r[2],10))/100,this.b=Math.min(100,parseInt(r[3],10))/100,e(r[4]),this;break;case"hsl":case"hsla":if(r=/^\s*(\d*\.?\d+)\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(o)){let a=parseFloat(r[1])/360,l=parseInt(r[2],10)/100,c=parseInt(r[3],10)/100;return e(r[4]),this.setHSL(a,l,c)}break}}else if(i=/^\#([A-Fa-f\d]+)$/.exec(t)){let r=i[1],s=r.length;if(s===3)return this.r=parseInt(r.charAt(0)+r.charAt(0),16)/255,this.g=parseInt(r.charAt(1)+r.charAt(1),16)/255,this.b=parseInt(r.charAt(2)+r.charAt(2),16)/255,this;if(s===6)return this.r=parseInt(r.charAt(0)+r.charAt(1),16)/255,this.g=parseInt(r.charAt(2)+r.charAt(3),16)/255,this.b=parseInt(r.charAt(4)+r.charAt(5),16)/255,this}return t&&t.length>0?this.setColorName(t):this}setColorName(t){let e=m0[t.toLowerCase()];return e!==void 0?this.setHex(e):console.warn("THREE.Color: Unknown color "+t),this}clone(){return new this.constructor(this.r,this.g,this.b)}copy(t){return this.r=t.r,this.g=t.g,this.b=t.b,this}copySRGBToLinear(t){return this.r=Or(t.r),this.g=Or(t.g),this.b=Or(t.b),this}copyLinearToSRGB(t){return this.r=ou(t.r),this.g=ou(t.g),this.b=ou(t.b),this}convertSRGBToLinear(){return this.copySRGBToLinear(this),this}convertLinearToSRGB(){return this.copyLinearToSRGB(this),this}getHex(){return this.r*255<<16^this.g*255<<8^this.b*255<<0}getHexString(){return("000000"+this.getHex().toString(16)).slice(-6)}getHSL(t){let e=this.r,i=this.g,r=this.b,s=Math.max(e,i,r),o=Math.min(e,i,r),a,l,c=(o+s)/2;if(o===s)a=0,l=0;else{let u=s-o;switch(l=c<=.5?u/(s+o):u/(2-s-o),s){case e:a=(i-r)/u+(i<r?6:0);break;case i:a=(r-e)/u+2;break;case r:a=(e-i)/u+4;break}a/=6}return t.h=a,t.s=l,t.l=c,t}getStyle(){return"rgb("+(this.r*255|0)+","+(this.g*255|0)+","+(this.b*255|0)+")"}offsetHSL(t,e,i){return this.getHSL($e),$e.h+=t,$e.s+=e,$e.l+=i,this.setHSL($e.h,$e.s,$e.l),this}add(t){return this.r+=t.r,this.g+=t.g,this.b+=t.b,this}addColors(t,e){return this.r=t.r+e.r,this.g=t.g+e.g,this.b=t.b+e.b,this}addScalar(t){return this.r+=t,this.g+=t,this.b+=t,this}sub(t){return this.r=Math.max(0,this.r-t.r),this.g=Math.max(0,this.g-t.g),this.b=Math.max(0,this.b-t.b),this}multiply(t){return this.r*=t.r,this.g*=t.g,this.b*=t.b,this}multiplyScalar(t){return this.r*=t,this.g*=t,this.b*=t,this}lerp(t,e){return this.r+=(t.r-this.r)*e,this.g+=(t.g-this.g)*e,this.b+=(t.b-this.b)*e,this}lerpColors(t,e,i){return this.r=t.r+(e.r-t.r)*i,this.g=t.g+(e.g-t.g)*i,this.b=t.b+(e.b-t.b)*i,this}lerpHSL(t,e){this.getHSL($e),t.getHSL(va);let i=ru($e.h,va.h,e),r=ru($e.s,va.s,e),s=ru($e.l,va.l,e);return this.setHSL(i,r,s),this}equals(t){return t.r===this.r&&t.g===this.g&&t.b===this.b}fromArray(t,e=0){return this.r=t[e],this.g=t[e+1],this.b=t[e+2],this}toArray(t=[],e=0){return t[e]=this.r,t[e+1]=this.g,t[e+2]=this.b,t}fromBufferAttribute(t,e){return this.r=t.getX(e),this.g=t.getY(e),this.b=t.getZ(e),t.normalized===!0&&(this.r/=255,this.g/=255,this.b/=255),this}toJSON(){return this.getHex()}};ft.NAMES=m0;ft.prototype.isColor=!0;ft.prototype.r=1;ft.prototype.g=1;ft.prototype.b=1;var pr,Nn=class{static getDataURL(t){if(/^data:/i.test(t.src)||typeof HTMLCanvasElement=="undefined")return t.src;let e;if(t instanceof HTMLCanvasElement)e=t;else{pr===void 0&&(pr=ro("canvas")),pr.width=t.width,pr.height=t.height;let i=pr.getContext("2d");t instanceof ImageData?i.putImageData(t,0,0):i.drawImage(t,0,0,t.width,t.height),e=pr}return e.width>2048||e.height>2048?(console.warn("THREE.ImageUtils.getDataURL: Image converted to jpg for performance reasons",t),e.toDataURL("image/jpeg",.6)):e.toDataURL("image/png")}static sRGBToLinear(t){if(typeof HTMLImageElement!="undefined"&&t instanceof HTMLImageElement||typeof HTMLCanvasElement!="undefined"&&t instanceof HTMLCanvasElement||typeof ImageBitmap!="undefined"&&t instanceof ImageBitmap){let e=ro("canvas");e.width=t.width,e.height=t.height;let i=e.getContext("2d");i.drawImage(t,0,0,t.width,t.height);let r=i.getImageData(0,0,t.width,t.height),s=r.data;for(let o=0;o<s.length;o++)s[o]=Or(s[o]/255)*255;return i.putImageData(r,0,0),e}else if(t.data){let e=t.data.slice(0);for(let i=0;i<e.length;i++)e instanceof Uint8Array||e instanceof Uint8ClampedArray?e[i]=Math.floor(Or(e[i]/255)*255):e[i]=Or(e[i]);return{data:e,width:t.width,height:t.height}}else return console.warn("THREE.ImageUtils.sRGBToLinear(): Unsupported image type. No color space conversion applied."),t}},iM=0,ae=class extends In{constructor(t=ae.DEFAULT_IMAGE,e=ae.DEFAULT_MAPPING,i=Ve,r=Ve,s=be,o=Ll,a=Re,l=ei,c=1,u=ri){super(),Object.defineProperty(this,"id",{value:iM++}),this.uuid=tn(),this.name="",this.image=t,this.mipmaps=[],this.mapping=e,this.wrapS=i,this.wrapT=r,this.magFilter=s,this.minFilter=o,this.anisotropy=c,this.format=a,this.internalFormat=null,this.type=l,this.offset=new K(0,0),this.repeat=new K(1,1),this.center=new K(0,0),this.rotation=0,this.matrixAutoUpdate=!0,this.matrix=new de,this.generateMipmaps=!0,this.premultiplyAlpha=!1,this.flipY=!0,this.unpackAlignment=4,this.encoding=u,this.userData={},this.version=0,this.onUpdate=null,this.isRenderTargetTexture=!1,this.needsPMREMUpdate=!1}updateMatrix(){this.matrix.setUvTransform(this.offset.x,this.offset.y,this.repeat.x,this.repeat.y,this.rotation,this.center.x,this.center.y)}clone(){return new this.constructor().copy(this)}copy(t){return this.name=t.name,this.image=t.image,this.mipmaps=t.mipmaps.slice(0),this.mapping=t.mapping,this.wrapS=t.wrapS,this.wrapT=t.wrapT,this.magFilter=t.magFilter,this.minFilter=t.minFilter,this.anisotropy=t.anisotropy,this.format=t.format,this.internalFormat=t.internalFormat,this.type=t.type,this.offset.copy(t.offset),this.repeat.copy(t.repeat),this.center.copy(t.center),this.rotation=t.rotation,this.matrixAutoUpdate=t.matrixAutoUpdate,this.matrix.copy(t.matrix),this.generateMipmaps=t.generateMipmaps,this.premultiplyAlpha=t.premultiplyAlpha,this.flipY=t.flipY,this.unpackAlignment=t.unpackAlignment,this.encoding=t.encoding,this.userData=JSON.parse(JSON.stringify(t.userData)),this}toJSON(t){let e=t===void 0||typeof t=="string";if(!e&&t.textures[this.uuid]!==void 0)return t.textures[this.uuid];let i={metadata:{version:4.5,type:"Texture",generator:"Texture.toJSON"},uuid:this.uuid,name:this.name,mapping:this.mapping,repeat:[this.repeat.x,this.repeat.y],offset:[this.offset.x,this.offset.y],center:[this.center.x,this.center.y],rotation:this.rotation,wrap:[this.wrapS,this.wrapT],format:this.format,type:this.type,encoding:this.encoding,minFilter:this.minFilter,magFilter:this.magFilter,anisotropy:this.anisotropy,flipY:this.flipY,premultiplyAlpha:this.premultiplyAlpha,unpackAlignment:this.unpackAlignment};if(this.image!==void 0){let r=this.image;if(r.uuid===void 0&&(r.uuid=tn()),!e&&t.images[r.uuid]===void 0){let s;if(Array.isArray(r)){s=[];for(let o=0,a=r.length;o<a;o++)r[o].isDataTexture?s.push(au(r[o].image)):s.push(au(r[o]))}else s=au(r);t.images[r.uuid]={uuid:r.uuid,url:s}}i.image=r.uuid}return JSON.stringify(this.userData)!=="{}"&&(i.userData=this.userData),e||(t.textures[this.uuid]=i),i}dispose(){this.dispatchEvent({type:"dispose"})}transformUv(t){if(this.mapping!==f0)return t;if(t.applyMatrix3(this.matrix),t.x<0||t.x>1)switch(this.wrapS){case Ou:t.x=t.x-Math.floor(t.x);break;case Ve:t.x=t.x<0?0:1;break;case ku:Math.abs(Math.floor(t.x)%2)===1?t.x=Math.ceil(t.x)-t.x:t.x=t.x-Math.floor(t.x);break}if(t.y<0||t.y>1)switch(this.wrapT){case Ou:t.y=t.y-Math.floor(t.y);break;case Ve:t.y=t.y<0?0:1;break;case ku:Math.abs(Math.floor(t.y)%2)===1?t.y=Math.ceil(t.y)-t.y:t.y=t.y-Math.floor(t.y);break}return this.flipY&&(t.y=1-t.y),t}set needsUpdate(t){t===!0&&this.version++}};ae.DEFAULT_IMAGE=void 0;ae.DEFAULT_MAPPING=f0;ae.prototype.isTexture=!0;function au(n){return typeof HTMLImageElement!="undefined"&&n instanceof HTMLImageElement||typeof HTMLCanvasElement!="undefined"&&n instanceof HTMLCanvasElement||typeof ImageBitmap!="undefined"&&n instanceof ImageBitmap?Nn.getDataURL(n):n.data?{data:Array.prototype.slice.call(n.data),width:n.width,height:n.height,type:n.data.constructor.name}:(console.warn("THREE.Texture: Unable to serialize Texture."),{})}var Wt=class{constructor(t=0,e=0,i=0,r=1){this.x=t,this.y=e,this.z=i,this.w=r}get width(){return this.z}set width(t){this.z=t}get height(){return this.w}set height(t){this.w=t}set(t,e,i,r){return this.x=t,this.y=e,this.z=i,this.w=r,this}setScalar(t){return this.x=t,this.y=t,this.z=t,this.w=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setZ(t){return this.z=t,this}setW(t){return this.w=t,this}setComponent(t,e){switch(t){case 0:this.x=e;break;case 1:this.y=e;break;case 2:this.z=e;break;case 3:this.w=e;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;case 2:return this.z;case 3:return this.w;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y,this.z,this.w)}copy(t){return this.x=t.x,this.y=t.y,this.z=t.z,this.w=t.w!==void 0?t.w:1,this}add(t,e){return e!==void 0?(console.warn("THREE.Vector4: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(t,e)):(this.x+=t.x,this.y+=t.y,this.z+=t.z,this.w+=t.w,this)}addScalar(t){return this.x+=t,this.y+=t,this.z+=t,this.w+=t,this}addVectors(t,e){return this.x=t.x+e.x,this.y=t.y+e.y,this.z=t.z+e.z,this.w=t.w+e.w,this}addScaledVector(t,e){return this.x+=t.x*e,this.y+=t.y*e,this.z+=t.z*e,this.w+=t.w*e,this}sub(t,e){return e!==void 0?(console.warn("THREE.Vector4: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),this.subVectors(t,e)):(this.x-=t.x,this.y-=t.y,this.z-=t.z,this.w-=t.w,this)}subScalar(t){return this.x-=t,this.y-=t,this.z-=t,this.w-=t,this}subVectors(t,e){return this.x=t.x-e.x,this.y=t.y-e.y,this.z=t.z-e.z,this.w=t.w-e.w,this}multiply(t){return this.x*=t.x,this.y*=t.y,this.z*=t.z,this.w*=t.w,this}multiplyScalar(t){return this.x*=t,this.y*=t,this.z*=t,this.w*=t,this}applyMatrix4(t){let e=this.x,i=this.y,r=this.z,s=this.w,o=t.elements;return this.x=o[0]*e+o[4]*i+o[8]*r+o[12]*s,this.y=o[1]*e+o[5]*i+o[9]*r+o[13]*s,this.z=o[2]*e+o[6]*i+o[10]*r+o[14]*s,this.w=o[3]*e+o[7]*i+o[11]*r+o[15]*s,this}divideScalar(t){return this.multiplyScalar(1/t)}setAxisAngleFromQuaternion(t){this.w=2*Math.acos(t.w);let e=Math.sqrt(1-t.w*t.w);return e<1e-4?(this.x=1,this.y=0,this.z=0):(this.x=t.x/e,this.y=t.y/e,this.z=t.z/e),this}setAxisAngleFromRotationMatrix(t){let e,i,r,s,l=t.elements,c=l[0],u=l[4],h=l[8],f=l[1],d=l[5],g=l[9],x=l[2],v=l[6],m=l[10];if(Math.abs(u-f)<.01&&Math.abs(h-x)<.01&&Math.abs(g-v)<.01){if(Math.abs(u+f)<.1&&Math.abs(h+x)<.1&&Math.abs(g+v)<.1&&Math.abs(c+d+m-3)<.1)return this.set(1,0,0,0),this;e=Math.PI;let b=(c+1)/2,_=(d+1)/2,S=(m+1)/2,L=(u+f)/4,A=(h+x)/4,H=(g+v)/4;return b>_&&b>S?b<.01?(i=0,r=.707106781,s=.707106781):(i=Math.sqrt(b),r=L/i,s=A/i):_>S?_<.01?(i=.707106781,r=0,s=.707106781):(r=Math.sqrt(_),i=L/r,s=H/r):S<.01?(i=.707106781,r=.707106781,s=0):(s=Math.sqrt(S),i=A/s,r=H/s),this.set(i,r,s,e),this}let p=Math.sqrt((v-g)*(v-g)+(h-x)*(h-x)+(f-u)*(f-u));return Math.abs(p)<.001&&(p=1),this.x=(v-g)/p,this.y=(h-x)/p,this.z=(f-u)/p,this.w=Math.acos((c+d+m-1)/2),this}min(t){return this.x=Math.min(this.x,t.x),this.y=Math.min(this.y,t.y),this.z=Math.min(this.z,t.z),this.w=Math.min(this.w,t.w),this}max(t){return this.x=Math.max(this.x,t.x),this.y=Math.max(this.y,t.y),this.z=Math.max(this.z,t.z),this.w=Math.max(this.w,t.w),this}clamp(t,e){return this.x=Math.max(t.x,Math.min(e.x,this.x)),this.y=Math.max(t.y,Math.min(e.y,this.y)),this.z=Math.max(t.z,Math.min(e.z,this.z)),this.w=Math.max(t.w,Math.min(e.w,this.w)),this}clampScalar(t,e){return this.x=Math.max(t,Math.min(e,this.x)),this.y=Math.max(t,Math.min(e,this.y)),this.z=Math.max(t,Math.min(e,this.z)),this.w=Math.max(t,Math.min(e,this.w)),this}clampLength(t,e){let i=this.length();return this.divideScalar(i||1).multiplyScalar(Math.max(t,Math.min(e,i)))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this.z=Math.floor(this.z),this.w=Math.floor(this.w),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this.z=Math.ceil(this.z),this.w=Math.ceil(this.w),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this.z=Math.round(this.z),this.w=Math.round(this.w),this}roundToZero(){return this.x=this.x<0?Math.ceil(this.x):Math.floor(this.x),this.y=this.y<0?Math.ceil(this.y):Math.floor(this.y),this.z=this.z<0?Math.ceil(this.z):Math.floor(this.z),this.w=this.w<0?Math.ceil(this.w):Math.floor(this.w),this}negate(){return this.x=-this.x,this.y=-this.y,this.z=-this.z,this.w=-this.w,this}dot(t){return this.x*t.x+this.y*t.y+this.z*t.z+this.w*t.w}lengthSq(){return this.x*this.x+this.y*this.y+this.z*this.z+this.w*this.w}length(){return Math.sqrt(this.x*this.x+this.y*this.y+this.z*this.z+this.w*this.w)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)+Math.abs(this.z)+Math.abs(this.w)}normalize(){return this.divideScalar(this.length()||1)}setLength(t){return this.normalize().multiplyScalar(t)}lerp(t,e){return this.x+=(t.x-this.x)*e,this.y+=(t.y-this.y)*e,this.z+=(t.z-this.z)*e,this.w+=(t.w-this.w)*e,this}lerpVectors(t,e,i){return this.x=t.x+(e.x-t.x)*i,this.y=t.y+(e.y-t.y)*i,this.z=t.z+(e.z-t.z)*i,this.w=t.w+(e.w-t.w)*i,this}equals(t){return t.x===this.x&&t.y===this.y&&t.z===this.z&&t.w===this.w}fromArray(t,e=0){return this.x=t[e],this.y=t[e+1],this.z=t[e+2],this.w=t[e+3],this}toArray(t=[],e=0){return t[e]=this.x,t[e+1]=this.y,t[e+2]=this.z,t[e+3]=this.w,t}fromBufferAttribute(t,e,i){return i!==void 0&&console.warn("THREE.Vector4: offset has been removed from .fromBufferAttribute()."),this.x=t.getX(e),this.y=t.getY(e),this.z=t.getZ(e),this.w=t.getW(e),this}random(){return this.x=Math.random(),this.y=Math.random(),this.z=Math.random(),this.w=Math.random(),this}*[Symbol.iterator](){yield this.x,yield this.y,yield this.z,yield this.w}};Wt.prototype.isVector4=!0;var Ne=class extends In{constructor(t,e,i={}){super(),this.width=t,this.height=e,this.depth=1,this.scissor=new Wt(0,0,t,e),this.scissorTest=!1,this.viewport=new Wt(0,0,t,e),this.texture=new ae(void 0,i.mapping,i.wrapS,i.wrapT,i.magFilter,i.minFilter,i.format,i.type,i.anisotropy,i.encoding),this.texture.isRenderTargetTexture=!0,this.texture.image={width:t,height:e,depth:1},this.texture.generateMipmaps=i.generateMipmaps!==void 0?i.generateMipmaps:!1,this.texture.internalFormat=i.internalFormat!==void 0?i.internalFormat:null,this.texture.minFilter=i.minFilter!==void 0?i.minFilter:be,this.depthBuffer=i.depthBuffer!==void 0?i.depthBuffer:!0,this.stencilBuffer=i.stencilBuffer!==void 0?i.stencilBuffer:!1,this.depthTexture=i.depthTexture!==void 0?i.depthTexture:null}setTexture(t){t.image={width:this.width,height:this.height,depth:this.depth},this.texture=t}setSize(t,e,i=1){(this.width!==t||this.height!==e||this.depth!==i)&&(this.width=t,this.height=e,this.depth=i,this.texture.image.width=t,this.texture.image.height=e,this.texture.image.depth=i,this.dispose()),this.viewport.set(0,0,t,e),this.scissor.set(0,0,t,e)}clone(){return new this.constructor().copy(this)}copy(t){return this.width=t.width,this.height=t.height,this.depth=t.depth,this.viewport.copy(t.viewport),this.texture=t.texture.clone(),this.texture.image=Object.assign({},t.texture.image),this.depthBuffer=t.depthBuffer,this.stencilBuffer=t.stencilBuffer,this.depthTexture=t.depthTexture,this}dispose(){this.dispatchEvent({type:"dispose"})}};Ne.prototype.isWebGLRenderTarget=!0;var Gu=class extends Ne{constructor(t,e,i){super(t,e);let r=this.texture;this.texture=[];for(let s=0;s<i;s++)this.texture[s]=r.clone()}setSize(t,e,i=1){if(this.width!==t||this.height!==e||this.depth!==i){this.width=t,this.height=e,this.depth=i;for(let r=0,s=this.texture.length;r<s;r++)this.texture[r].image.width=t,this.texture[r].image.height=e,this.texture[r].image.depth=i;this.dispose()}return this.viewport.set(0,0,t,e),this.scissor.set(0,0,t,e),this}copy(t){this.dispose(),this.width=t.width,this.height=t.height,this.depth=t.depth,this.viewport.set(0,0,this.width,this.height),this.scissor.set(0,0,this.width,this.height),this.depthBuffer=t.depthBuffer,this.stencilBuffer=t.stencilBuffer,this.depthTexture=t.depthTexture,this.texture.length=0;for(let e=0,i=t.texture.length;e<i;e++)this.texture[e]=t.texture[e].clone();return this}};Gu.prototype.isWebGLMultipleRenderTargets=!0;var so=class extends Ne{constructor(t,e,i={}){super(t,e,i),this.samples=4,this.ignoreDepthForMultisampleCopy=i.ignoreDepth!==void 0?i.ignoreDepth:!0,this.useRenderToTexture=i.useRenderToTexture!==void 0?i.useRenderToTexture:!1,this.useRenderbuffer=this.useRenderToTexture===!1}copy(t){return super.copy.call(this,t),this.samples=t.samples,this.useRenderToTexture=t.useRenderToTexture,this.useRenderbuffer=t.useRenderbuffer,this}};so.prototype.isWebGLMultisampleRenderTarget=!0;var Ee=class{constructor(t=0,e=0,i=0,r=1){this._x=t,this._y=e,this._z=i,this._w=r}static slerp(t,e,i,r){return console.warn("THREE.Quaternion: Static .slerp() has been deprecated. Use qm.slerpQuaternions( qa, qb, t ) instead."),i.slerpQuaternions(t,e,r)}static slerpFlat(t,e,i,r,s,o,a){let l=i[r+0],c=i[r+1],u=i[r+2],h=i[r+3],f=s[o+0],d=s[o+1],g=s[o+2],x=s[o+3];if(a===0){t[e+0]=l,t[e+1]=c,t[e+2]=u,t[e+3]=h;return}if(a===1){t[e+0]=f,t[e+1]=d,t[e+2]=g,t[e+3]=x;return}if(h!==x||l!==f||c!==d||u!==g){let v=1-a,m=l*f+c*d+u*g+h*x,p=m>=0?1:-1,b=1-m*m;if(b>Number.EPSILON){let S=Math.sqrt(b),L=Math.atan2(S,m*p);v=Math.sin(v*L)/S,a=Math.sin(a*L)/S}let _=a*p;if(l=l*v+f*_,c=c*v+d*_,u=u*v+g*_,h=h*v+x*_,v===1-a){let S=1/Math.sqrt(l*l+c*c+u*u+h*h);l*=S,c*=S,u*=S,h*=S}}t[e]=l,t[e+1]=c,t[e+2]=u,t[e+3]=h}static multiplyQuaternionsFlat(t,e,i,r,s,o){let a=i[r],l=i[r+1],c=i[r+2],u=i[r+3],h=s[o],f=s[o+1],d=s[o+2],g=s[o+3];return t[e]=a*g+u*h+l*d-c*f,t[e+1]=l*g+u*f+c*h-a*d,t[e+2]=c*g+u*d+a*f-l*h,t[e+3]=u*g-a*h-l*f-c*d,t}get x(){return this._x}set x(t){this._x=t,this._onChangeCallback()}get y(){return this._y}set y(t){this._y=t,this._onChangeCallback()}get z(){return this._z}set z(t){this._z=t,this._onChangeCallback()}get w(){return this._w}set w(t){this._w=t,this._onChangeCallback()}set(t,e,i,r){return this._x=t,this._y=e,this._z=i,this._w=r,this._onChangeCallback(),this}clone(){return new this.constructor(this._x,this._y,this._z,this._w)}copy(t){return this._x=t.x,this._y=t.y,this._z=t.z,this._w=t.w,this._onChangeCallback(),this}setFromEuler(t,e){if(!(t&&t.isEuler))throw new Error("THREE.Quaternion: .setFromEuler() now expects an Euler rotation rather than a Vector3 and order.");let i=t._x,r=t._y,s=t._z,o=t._order,a=Math.cos,l=Math.sin,c=a(i/2),u=a(r/2),h=a(s/2),f=l(i/2),d=l(r/2),g=l(s/2);switch(o){case"XYZ":this._x=f*u*h+c*d*g,this._y=c*d*h-f*u*g,this._z=c*u*g+f*d*h,this._w=c*u*h-f*d*g;break;case"YXZ":this._x=f*u*h+c*d*g,this._y=c*d*h-f*u*g,this._z=c*u*g-f*d*h,this._w=c*u*h+f*d*g;break;case"ZXY":this._x=f*u*h-c*d*g,this._y=c*d*h+f*u*g,this._z=c*u*g+f*d*h,this._w=c*u*h-f*d*g;break;case"ZYX":this._x=f*u*h-c*d*g,this._y=c*d*h+f*u*g,this._z=c*u*g-f*d*h,this._w=c*u*h+f*d*g;break;case"YZX":this._x=f*u*h+c*d*g,this._y=c*d*h+f*u*g,this._z=c*u*g-f*d*h,this._w=c*u*h-f*d*g;break;case"XZY":this._x=f*u*h-c*d*g,this._y=c*d*h-f*u*g,this._z=c*u*g+f*d*h,this._w=c*u*h+f*d*g;break;default:console.warn("THREE.Quaternion: .setFromEuler() encountered an unknown order: "+o)}return e!==!1&&this._onChangeCallback(),this}setFromAxisAngle(t,e){let i=e/2,r=Math.sin(i);return this._x=t.x*r,this._y=t.y*r,this._z=t.z*r,this._w=Math.cos(i),this._onChangeCallback(),this}setFromRotationMatrix(t){let e=t.elements,i=e[0],r=e[4],s=e[8],o=e[1],a=e[5],l=e[9],c=e[2],u=e[6],h=e[10],f=i+a+h;if(f>0){let d=.5/Math.sqrt(f+1);this._w=.25/d,this._x=(u-l)*d,this._y=(s-c)*d,this._z=(o-r)*d}else if(i>a&&i>h){let d=2*Math.sqrt(1+i-a-h);this._w=(u-l)/d,this._x=.25*d,this._y=(r+o)/d,this._z=(s+c)/d}else if(a>h){let d=2*Math.sqrt(1+a-i-h);this._w=(s-c)/d,this._x=(r+o)/d,this._y=.25*d,this._z=(l+u)/d}else{let d=2*Math.sqrt(1+h-i-a);this._w=(o-r)/d,this._x=(s+c)/d,this._y=(l+u)/d,this._z=.25*d}return this._onChangeCallback(),this}setFromUnitVectors(t,e){let i=t.dot(e)+1;return i<Number.EPSILON?(i=0,Math.abs(t.x)>Math.abs(t.z)?(this._x=-t.y,this._y=t.x,this._z=0,this._w=i):(this._x=0,this._y=-t.z,this._z=t.y,this._w=i)):(this._x=t.y*e.z-t.z*e.y,this._y=t.z*e.x-t.x*e.z,this._z=t.x*e.y-t.y*e.x,this._w=i),this.normalize()}angleTo(t){return 2*Math.acos(Math.abs(Ie(this.dot(t),-1,1)))}rotateTowards(t,e){let i=this.angleTo(t);if(i===0)return this;let r=Math.min(1,e/i);return this.slerp(t,r),this}identity(){return this.set(0,0,0,1)}invert(){return this.conjugate()}conjugate(){return this._x*=-1,this._y*=-1,this._z*=-1,this._onChangeCallback(),this}dot(t){return this._x*t._x+this._y*t._y+this._z*t._z+this._w*t._w}lengthSq(){return this._x*this._x+this._y*this._y+this._z*this._z+this._w*this._w}length(){return Math.sqrt(this._x*this._x+this._y*this._y+this._z*this._z+this._w*this._w)}normalize(){let t=this.length();return t===0?(this._x=0,this._y=0,this._z=0,this._w=1):(t=1/t,this._x=this._x*t,this._y=this._y*t,this._z=this._z*t,this._w=this._w*t),this._onChangeCallback(),this}multiply(t,e){return e!==void 0?(console.warn("THREE.Quaternion: .multiply() now only accepts one argument. Use .multiplyQuaternions( a, b ) instead."),this.multiplyQuaternions(t,e)):this.multiplyQuaternions(this,t)}premultiply(t){return this.multiplyQuaternions(t,this)}multiplyQuaternions(t,e){let i=t._x,r=t._y,s=t._z,o=t._w,a=e._x,l=e._y,c=e._z,u=e._w;return this._x=i*u+o*a+r*c-s*l,this._y=r*u+o*l+s*a-i*c,this._z=s*u+o*c+i*l-r*a,this._w=o*u-i*a-r*l-s*c,this._onChangeCallback(),this}slerp(t,e){if(e===0)return this;if(e===1)return this.copy(t);let i=this._x,r=this._y,s=this._z,o=this._w,a=o*t._w+i*t._x+r*t._y+s*t._z;if(a<0?(this._w=-t._w,this._x=-t._x,this._y=-t._y,this._z=-t._z,a=-a):this.copy(t),a>=1)return this._w=o,this._x=i,this._y=r,this._z=s,this;let l=1-a*a;if(l<=Number.EPSILON){let d=1-e;return this._w=d*o+e*this._w,this._x=d*i+e*this._x,this._y=d*r+e*this._y,this._z=d*s+e*this._z,this.normalize(),this._onChangeCallback(),this}let c=Math.sqrt(l),u=Math.atan2(c,a),h=Math.sin((1-e)*u)/c,f=Math.sin(e*u)/c;return this._w=o*h+this._w*f,this._x=i*h+this._x*f,this._y=r*h+this._y*f,this._z=s*h+this._z*f,this._onChangeCallback(),this}slerpQuaternions(t,e,i){return this.copy(t).slerp(e,i)}random(){let t=Math.random(),e=Math.sqrt(1-t),i=Math.sqrt(t),r=2*Math.PI*Math.random(),s=2*Math.PI*Math.random();return this.set(e*Math.cos(r),i*Math.sin(s),i*Math.cos(s),e*Math.sin(r))}equals(t){return t._x===this._x&&t._y===this._y&&t._z===this._z&&t._w===this._w}fromArray(t,e=0){return this._x=t[e],this._y=t[e+1],this._z=t[e+2],this._w=t[e+3],this._onChangeCallback(),this}toArray(t=[],e=0){return t[e]=this._x,t[e+1]=this._y,t[e+2]=this._z,t[e+3]=this._w,t}fromBufferAttribute(t,e){return this._x=t.getX(e),this._y=t.getY(e),this._z=t.getZ(e),this._w=t.getW(e),this}_onChange(t){return this._onChangeCallback=t,this}_onChangeCallback(){}};Ee.prototype.isQuaternion=!0;var T=class{constructor(t=0,e=0,i=0){this.x=t,this.y=e,this.z=i}set(t,e,i){return i===void 0&&(i=this.z),this.x=t,this.y=e,this.z=i,this}setScalar(t){return this.x=t,this.y=t,this.z=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setZ(t){return this.z=t,this}setComponent(t,e){switch(t){case 0:this.x=e;break;case 1:this.y=e;break;case 2:this.z=e;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;case 2:return this.z;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y,this.z)}copy(t){return this.x=t.x,this.y=t.y,this.z=t.z,this}add(t,e){return e!==void 0?(console.warn("THREE.Vector3: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(t,e)):(this.x+=t.x,this.y+=t.y,this.z+=t.z,this)}addScalar(t){return this.x+=t,this.y+=t,this.z+=t,this}addVectors(t,e){return this.x=t.x+e.x,this.y=t.y+e.y,this.z=t.z+e.z,this}addScaledVector(t,e){return this.x+=t.x*e,this.y+=t.y*e,this.z+=t.z*e,this}sub(t,e){return e!==void 0?(console.warn("THREE.Vector3: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),this.subVectors(t,e)):(this.x-=t.x,this.y-=t.y,this.z-=t.z,this)}subScalar(t){return this.x-=t,this.y-=t,this.z-=t,this}subVectors(t,e){return this.x=t.x-e.x,this.y=t.y-e.y,this.z=t.z-e.z,this}multiply(t,e){return e!==void 0?(console.warn("THREE.Vector3: .multiply() now only accepts one argument. Use .multiplyVectors( a, b ) instead."),this.multiplyVectors(t,e)):(this.x*=t.x,this.y*=t.y,this.z*=t.z,this)}multiplyScalar(t){return this.x*=t,this.y*=t,this.z*=t,this}multiplyVectors(t,e){return this.x=t.x*e.x,this.y=t.y*e.y,this.z=t.z*e.z,this}applyEuler(t){return t&&t.isEuler||console.error("THREE.Vector3: .applyEuler() now expects an Euler rotation rather than a Vector3 and order."),this.applyQuaternion(rg.setFromEuler(t))}applyAxisAngle(t,e){return this.applyQuaternion(rg.setFromAxisAngle(t,e))}applyMatrix3(t){let e=this.x,i=this.y,r=this.z,s=t.elements;return this.x=s[0]*e+s[3]*i+s[6]*r,this.y=s[1]*e+s[4]*i+s[7]*r,this.z=s[2]*e+s[5]*i+s[8]*r,this}applyNormalMatrix(t){return this.applyMatrix3(t).normalize()}applyMatrix4(t){let e=this.x,i=this.y,r=this.z,s=t.elements,o=1/(s[3]*e+s[7]*i+s[11]*r+s[15]);return this.x=(s[0]*e+s[4]*i+s[8]*r+s[12])*o,this.y=(s[1]*e+s[5]*i+s[9]*r+s[13])*o,this.z=(s[2]*e+s[6]*i+s[10]*r+s[14])*o,this}applyQuaternion(t){let e=this.x,i=this.y,r=this.z,s=t.x,o=t.y,a=t.z,l=t.w,c=l*e+o*r-a*i,u=l*i+a*e-s*r,h=l*r+s*i-o*e,f=-s*e-o*i-a*r;return this.x=c*l+f*-s+u*-a-h*-o,this.y=u*l+f*-o+h*-s-c*-a,this.z=h*l+f*-a+c*-o-u*-s,this}project(t){return this.applyMatrix4(t.matrixWorldInverse).applyMatrix4(t.projectionMatrix)}unproject(t){return this.applyMatrix4(t.projectionMatrixInverse).applyMatrix4(t.matrixWorld)}transformDirection(t){let e=this.x,i=this.y,r=this.z,s=t.elements;return this.x=s[0]*e+s[4]*i+s[8]*r,this.y=s[1]*e+s[5]*i+s[9]*r,this.z=s[2]*e+s[6]*i+s[10]*r,this.normalize()}divide(t){return this.x/=t.x,this.y/=t.y,this.z/=t.z,this}divideScalar(t){return this.multiplyScalar(1/t)}min(t){return this.x=Math.min(this.x,t.x),this.y=Math.min(this.y,t.y),this.z=Math.min(this.z,t.z),this}max(t){return this.x=Math.max(this.x,t.x),this.y=Math.max(this.y,t.y),this.z=Math.max(this.z,t.z),this}clamp(t,e){return this.x=Math.max(t.x,Math.min(e.x,this.x)),this.y=Math.max(t.y,Math.min(e.y,this.y)),this.z=Math.max(t.z,Math.min(e.z,this.z)),this}clampScalar(t,e){return this.x=Math.max(t,Math.min(e,this.x)),this.y=Math.max(t,Math.min(e,this.y)),this.z=Math.max(t,Math.min(e,this.z)),this}clampLength(t,e){let i=this.length();return this.divideScalar(i||1).multiplyScalar(Math.max(t,Math.min(e,i)))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this.z=Math.floor(this.z),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this.z=Math.ceil(this.z),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this.z=Math.round(this.z),this}roundToZero(){return this.x=this.x<0?Math.ceil(this.x):Math.floor(this.x),this.y=this.y<0?Math.ceil(this.y):Math.floor(this.y),this.z=this.z<0?Math.ceil(this.z):Math.floor(this.z),this}negate(){return this.x=-this.x,this.y=-this.y,this.z=-this.z,this}dot(t){return this.x*t.x+this.y*t.y+this.z*t.z}lengthSq(){return this.x*this.x+this.y*this.y+this.z*this.z}length(){return Math.sqrt(this.x*this.x+this.y*this.y+this.z*this.z)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)+Math.abs(this.z)}normalize(){return this.divideScalar(this.length()||1)}setLength(t){return this.normalize().multiplyScalar(t)}lerp(t,e){return this.x+=(t.x-this.x)*e,this.y+=(t.y-this.y)*e,this.z+=(t.z-this.z)*e,this}lerpVectors(t,e,i){return this.x=t.x+(e.x-t.x)*i,this.y=t.y+(e.y-t.y)*i,this.z=t.z+(e.z-t.z)*i,this}cross(t,e){return e!==void 0?(console.warn("THREE.Vector3: .cross() now only accepts one argument. Use .crossVectors( a, b ) instead."),this.crossVectors(t,e)):this.crossVectors(this,t)}crossVectors(t,e){let i=t.x,r=t.y,s=t.z,o=e.x,a=e.y,l=e.z;return this.x=r*l-s*a,this.y=s*o-i*l,this.z=i*a-r*o,this}projectOnVector(t){let e=t.lengthSq();if(e===0)return this.set(0,0,0);let i=t.dot(this)/e;return this.copy(t).multiplyScalar(i)}projectOnPlane(t){return lu.copy(this).projectOnVector(t),this.sub(lu)}reflect(t){return this.sub(lu.copy(t).multiplyScalar(2*this.dot(t)))}angleTo(t){let e=Math.sqrt(this.lengthSq()*t.lengthSq());if(e===0)return Math.PI/2;let i=this.dot(t)/e;return Math.acos(Ie(i,-1,1))}distanceTo(t){return Math.sqrt(this.distanceToSquared(t))}distanceToSquared(t){let e=this.x-t.x,i=this.y-t.y,r=this.z-t.z;return e*e+i*i+r*r}manhattanDistanceTo(t){return Math.abs(this.x-t.x)+Math.abs(this.y-t.y)+Math.abs(this.z-t.z)}setFromSpherical(t){return this.setFromSphericalCoords(t.radius,t.phi,t.theta)}setFromSphericalCoords(t,e,i){let r=Math.sin(e)*t;return this.x=r*Math.sin(i),this.y=Math.cos(e)*t,this.z=r*Math.cos(i),this}setFromCylindrical(t){return this.setFromCylindricalCoords(t.radius,t.theta,t.y)}setFromCylindricalCoords(t,e,i){return this.x=t*Math.sin(e),this.y=i,this.z=t*Math.cos(e),this}setFromMatrixPosition(t){let e=t.elements;return this.x=e[12],this.y=e[13],this.z=e[14],this}setFromMatrixScale(t){let e=this.setFromMatrixColumn(t,0).length(),i=this.setFromMatrixColumn(t,1).length(),r=this.setFromMatrixColumn(t,2).length();return this.x=e,this.y=i,this.z=r,this}setFromMatrixColumn(t,e){return this.fromArray(t.elements,e*4)}setFromMatrix3Column(t,e){return this.fromArray(t.elements,e*3)}equals(t){return t.x===this.x&&t.y===this.y&&t.z===this.z}fromArray(t,e=0){return this.x=t[e],this.y=t[e+1],this.z=t[e+2],this}toArray(t=[],e=0){return t[e]=this.x,t[e+1]=this.y,t[e+2]=this.z,t}fromBufferAttribute(t,e,i){return i!==void 0&&console.warn("THREE.Vector3: offset has been removed from .fromBufferAttribute()."),this.x=t.getX(e),this.y=t.getY(e),this.z=t.getZ(e),this}random(){return this.x=Math.random(),this.y=Math.random(),this.z=Math.random(),this}randomDirection(){let t=(Math.random()-.5)*2,e=Math.random()*Math.PI*2,i=Math.sqrt(1-cf(t,2));return this.x=i*Math.cos(e),this.y=i*Math.sin(e),this.z=t,this}*[Symbol.iterator](){yield this.x,yield this.y,yield this.z}};T.prototype.isVector3=!0;var lu=new T,rg=new Ee,Ge=class{constructor(t=new T(1/0,1/0,1/0),e=new T(-1/0,-1/0,-1/0)){this.min=t,this.max=e}set(t,e){return this.min.copy(t),this.max.copy(e),this}setFromArray(t){let e=1/0,i=1/0,r=1/0,s=-1/0,o=-1/0,a=-1/0;for(let l=0,c=t.length;l<c;l+=3){let u=t[l],h=t[l+1],f=t[l+2];u<e&&(e=u),h<i&&(i=h),f<r&&(r=f),u>s&&(s=u),h>o&&(o=h),f>a&&(a=f)}return this.min.set(e,i,r),this.max.set(s,o,a),this}setFromBufferAttribute(t){let e=1/0,i=1/0,r=1/0,s=-1/0,o=-1/0,a=-1/0;for(let l=0,c=t.count;l<c;l++){let u=t.getX(l),h=t.getY(l),f=t.getZ(l);u<e&&(e=u),h<i&&(i=h),f<r&&(r=f),u>s&&(s=u),h>o&&(o=h),f>a&&(a=f)}return this.min.set(e,i,r),this.max.set(s,o,a),this}setFromPoints(t){this.makeEmpty();for(let e=0,i=t.length;e<i;e++)this.expandByPoint(t[e]);return this}setFromCenterAndSize(t,e){let i=Ii.copy(e).multiplyScalar(.5);return this.min.copy(t).sub(i),this.max.copy(t).add(i),this}setFromObject(t,e=!1){return this.makeEmpty(),this.expandByObject(t,e)}clone(){return new this.constructor().copy(this)}copy(t){return this.min.copy(t.min),this.max.copy(t.max),this}makeEmpty(){return this.min.x=this.min.y=this.min.z=1/0,this.max.x=this.max.y=this.max.z=-1/0,this}isEmpty(){return this.max.x<this.min.x||this.max.y<this.min.y||this.max.z<this.min.z}getCenter(t){return this.isEmpty()?t.set(0,0,0):t.addVectors(this.min,this.max).multiplyScalar(.5)}getSize(t){return this.isEmpty()?t.set(0,0,0):t.subVectors(this.max,this.min)}expandByPoint(t){return this.min.min(t),this.max.max(t),this}expandByVector(t){return this.min.sub(t),this.max.add(t),this}expandByScalar(t){return this.min.addScalar(-t),this.max.addScalar(t),this}expandByObject(t,e=!1){t.updateWorldMatrix(!1,!1);let i=t.geometry;if(i!==void 0)if(e&&i.attributes!=null&&i.attributes.position!==void 0){let s=i.attributes.position;for(let o=0,a=s.count;o<a;o++)Ii.fromBufferAttribute(s,o).applyMatrix4(t.matrixWorld),this.expandByPoint(Ii)}else i.boundingBox===null&&i.computeBoundingBox(),cu.copy(i.boundingBox),cu.applyMatrix4(t.matrixWorld),this.union(cu);let r=t.children;for(let s=0,o=r.length;s<o;s++)this.expandByObject(r[s],e);return this}containsPoint(t){return!(t.x<this.min.x||t.x>this.max.x||t.y<this.min.y||t.y>this.max.y||t.z<this.min.z||t.z>this.max.z)}containsBox(t){return this.min.x<=t.min.x&&t.max.x<=this.max.x&&this.min.y<=t.min.y&&t.max.y<=this.max.y&&this.min.z<=t.min.z&&t.max.z<=this.max.z}getParameter(t,e){return e.set((t.x-this.min.x)/(this.max.x-this.min.x),(t.y-this.min.y)/(this.max.y-this.min.y),(t.z-this.min.z)/(this.max.z-this.min.z))}intersectsBox(t){return!(t.max.x<this.min.x||t.min.x>this.max.x||t.max.y<this.min.y||t.min.y>this.max.y||t.max.z<this.min.z||t.min.z>this.max.z)}intersectsSphere(t){return this.clampPoint(t.center,Ii),Ii.distanceToSquared(t.center)<=t.radius*t.radius}intersectsPlane(t){let e,i;return t.normal.x>0?(e=t.normal.x*this.min.x,i=t.normal.x*this.max.x):(e=t.normal.x*this.max.x,i=t.normal.x*this.min.x),t.normal.y>0?(e+=t.normal.y*this.min.y,i+=t.normal.y*this.max.y):(e+=t.normal.y*this.max.y,i+=t.normal.y*this.min.y),t.normal.z>0?(e+=t.normal.z*this.min.z,i+=t.normal.z*this.max.z):(e+=t.normal.z*this.max.z,i+=t.normal.z*this.min.z),e<=-t.constant&&i>=-t.constant}intersectsTriangle(t){if(this.isEmpty())return!1;this.getCenter(ks),_a.subVectors(this.max,ks),mr.subVectors(t.a,ks),gr.subVectors(t.b,ks),xr.subVectors(t.c,ks),qn.subVectors(gr,mr),Xn.subVectors(xr,gr),Ni.subVectors(mr,xr);let e=[0,-qn.z,qn.y,0,-Xn.z,Xn.y,0,-Ni.z,Ni.y,qn.z,0,-qn.x,Xn.z,0,-Xn.x,Ni.z,0,-Ni.x,-qn.y,qn.x,0,-Xn.y,Xn.x,0,-Ni.y,Ni.x,0];return!uu(e,mr,gr,xr,_a)||(e=[1,0,0,0,1,0,0,0,1],!uu(e,mr,gr,xr,_a))?!1:(wa.crossVectors(qn,Xn),e=[wa.x,wa.y,wa.z],uu(e,mr,gr,xr,_a))}clampPoint(t,e){return e.copy(t).clamp(this.min,this.max)}distanceToPoint(t){return Ii.copy(t).clamp(this.min,this.max).sub(t).length()}getBoundingSphere(t){return this.getCenter(t.center),t.radius=this.getSize(Ii).length()*.5,t}intersect(t){return this.min.max(t.min),this.max.min(t.max),this.isEmpty()&&this.makeEmpty(),this}union(t){return this.min.min(t.min),this.max.max(t.max),this}applyMatrix4(t){return this.isEmpty()?this:(An[0].set(this.min.x,this.min.y,this.min.z).applyMatrix4(t),An[1].set(this.min.x,this.min.y,this.max.z).applyMatrix4(t),An[2].set(this.min.x,this.max.y,this.min.z).applyMatrix4(t),An[3].set(this.min.x,this.max.y,this.max.z).applyMatrix4(t),An[4].set(this.max.x,this.min.y,this.min.z).applyMatrix4(t),An[5].set(this.max.x,this.min.y,this.max.z).applyMatrix4(t),An[6].set(this.max.x,this.max.y,this.min.z).applyMatrix4(t),An[7].set(this.max.x,this.max.y,this.max.z).applyMatrix4(t),this.setFromPoints(An),this)}translate(t){return this.min.add(t),this.max.add(t),this}equals(t){return t.min.equals(this.min)&&t.max.equals(this.max)}};Ge.prototype.isBox3=!0;var An=[new T,new T,new T,new T,new T,new T,new T,new T],Ii=new T,cu=new Ge,mr=new T,gr=new T,xr=new T,qn=new T,Xn=new T,Ni=new T,ks=new T,_a=new T,wa=new T,Fi=new T;function uu(n,t,e,i,r){for(let s=0,o=n.length-3;s<=o;s+=3){Fi.fromArray(n,s);let a=r.x*Math.abs(Fi.x)+r.y*Math.abs(Fi.y)+r.z*Math.abs(Fi.z),l=t.dot(Fi),c=e.dot(Fi),u=i.dot(Fi);if(Math.max(-Math.max(l,c,u),Math.min(l,c,u))>a)return!1}return!0}var rM=new Ge,sg=new T,Ma=new T,hu=new T,si=class{constructor(t=new T,e=-1){this.center=t,this.radius=e}set(t,e){return this.center.copy(t),this.radius=e,this}setFromPoints(t,e){let i=this.center;e!==void 0?i.copy(e):rM.setFromPoints(t).getCenter(i);let r=0;for(let s=0,o=t.length;s<o;s++)r=Math.max(r,i.distanceToSquared(t[s]));return this.radius=Math.sqrt(r),this}copy(t){return this.center.copy(t.center),this.radius=t.radius,this}isEmpty(){return this.radius<0}makeEmpty(){return this.center.set(0,0,0),this.radius=-1,this}containsPoint(t){return t.distanceToSquared(this.center)<=this.radius*this.radius}distanceToPoint(t){return t.distanceTo(this.center)-this.radius}intersectsSphere(t){let e=this.radius+t.radius;return t.center.distanceToSquared(this.center)<=e*e}intersectsBox(t){return t.intersectsSphere(this)}intersectsPlane(t){return Math.abs(t.distanceToPoint(this.center))<=this.radius}clampPoint(t,e){let i=this.center.distanceToSquared(t);return e.copy(t),i>this.radius*this.radius&&(e.sub(this.center).normalize(),e.multiplyScalar(this.radius).add(this.center)),e}getBoundingBox(t){return this.isEmpty()?(t.makeEmpty(),t):(t.set(this.center,this.center),t.expandByScalar(this.radius),t)}applyMatrix4(t){return this.center.applyMatrix4(t),this.radius=this.radius*t.getMaxScaleOnAxis(),this}translate(t){return this.center.add(t),this}expandByPoint(t){hu.subVectors(t,this.center);let e=hu.lengthSq();if(e>this.radius*this.radius){let i=Math.sqrt(e),r=(i-this.radius)*.5;this.center.add(hu.multiplyScalar(r/i)),this.radius+=r}return this}union(t){return this.center.equals(t.center)===!0?Ma.set(0,0,1).multiplyScalar(t.radius):Ma.subVectors(t.center,this.center).normalize().multiplyScalar(t.radius),this.expandByPoint(sg.copy(t.center).add(Ma)),this.expandByPoint(sg.copy(t.center).sub(Ma)),this}equals(t){return t.center.equals(this.center)&&t.radius===this.radius}clone(){return new this.constructor().copy(this)}},Cn=new T,fu=new T,ba=new T,Yn=new T,du=new T,Sa=new T,pu=new T,oi=class{constructor(t=new T,e=new T(0,0,-1)){this.origin=t,this.direction=e}set(t,e){return this.origin.copy(t),this.direction.copy(e),this}copy(t){return this.origin.copy(t.origin),this.direction.copy(t.direction),this}at(t,e){return e.copy(this.direction).multiplyScalar(t).add(this.origin)}lookAt(t){return this.direction.copy(t).sub(this.origin).normalize(),this}recast(t){return this.origin.copy(this.at(t,Cn)),this}closestPointToPoint(t,e){e.subVectors(t,this.origin);let i=e.dot(this.direction);return i<0?e.copy(this.origin):e.copy(this.direction).multiplyScalar(i).add(this.origin)}distanceToPoint(t){return Math.sqrt(this.distanceSqToPoint(t))}distanceSqToPoint(t){let e=Cn.subVectors(t,this.origin).dot(this.direction);return e<0?this.origin.distanceToSquared(t):(Cn.copy(this.direction).multiplyScalar(e).add(this.origin),Cn.distanceToSquared(t))}distanceSqToSegment(t,e,i,r){fu.copy(t).add(e).multiplyScalar(.5),ba.copy(e).sub(t).normalize(),Yn.copy(this.origin).sub(fu);let s=t.distanceTo(e)*.5,o=-this.direction.dot(ba),a=Yn.dot(this.direction),l=-Yn.dot(ba),c=Yn.lengthSq(),u=Math.abs(1-o*o),h,f,d,g;if(u>0)if(h=o*l-a,f=o*a-l,g=s*u,h>=0)if(f>=-g)if(f<=g){let x=1/u;h*=x,f*=x,d=h*(h+o*f+2*a)+f*(o*h+f+2*l)+c}else f=s,h=Math.max(0,-(o*f+a)),d=-h*h+f*(f+2*l)+c;else f=-s,h=Math.max(0,-(o*f+a)),d=-h*h+f*(f+2*l)+c;else f<=-g?(h=Math.max(0,-(-o*s+a)),f=h>0?-s:Math.min(Math.max(-s,-l),s),d=-h*h+f*(f+2*l)+c):f<=g?(h=0,f=Math.min(Math.max(-s,-l),s),d=f*(f+2*l)+c):(h=Math.max(0,-(o*s+a)),f=h>0?s:Math.min(Math.max(-s,-l),s),d=-h*h+f*(f+2*l)+c);else f=o>0?-s:s,h=Math.max(0,-(o*f+a)),d=-h*h+f*(f+2*l)+c;return i&&i.copy(this.direction).multiplyScalar(h).add(this.origin),r&&r.copy(ba).multiplyScalar(f).add(fu),d}intersectSphere(t,e){Cn.subVectors(t.center,this.origin);let i=Cn.dot(this.direction),r=Cn.dot(Cn)-i*i,s=t.radius*t.radius;if(r>s)return null;let o=Math.sqrt(s-r),a=i-o,l=i+o;return a<0&&l<0?null:a<0?this.at(l,e):this.at(a,e)}intersectsSphere(t){return this.distanceSqToPoint(t.center)<=t.radius*t.radius}distanceToPlane(t){let e=t.normal.dot(this.direction);if(e===0)return t.distanceToPoint(this.origin)===0?0:null;let i=-(this.origin.dot(t.normal)+t.constant)/e;return i>=0?i:null}intersectPlane(t,e){let i=this.distanceToPlane(t);return i===null?null:this.at(i,e)}intersectsPlane(t){let e=t.distanceToPoint(this.origin);return e===0||t.normal.dot(this.direction)*e<0}intersectBox(t,e){let i,r,s,o,a,l,c=1/this.direction.x,u=1/this.direction.y,h=1/this.direction.z,f=this.origin;return c>=0?(i=(t.min.x-f.x)*c,r=(t.max.x-f.x)*c):(i=(t.max.x-f.x)*c,r=(t.min.x-f.x)*c),u>=0?(s=(t.min.y-f.y)*u,o=(t.max.y-f.y)*u):(s=(t.max.y-f.y)*u,o=(t.min.y-f.y)*u),i>o||s>r||((s>i||i!==i)&&(i=s),(o<r||r!==r)&&(r=o),h>=0?(a=(t.min.z-f.z)*h,l=(t.max.z-f.z)*h):(a=(t.max.z-f.z)*h,l=(t.min.z-f.z)*h),i>l||a>r)||((a>i||i!==i)&&(i=a),(l<r||r!==r)&&(r=l),r<0)?null:this.at(i>=0?i:r,e)}intersectsBox(t){return this.intersectBox(t,Cn)!==null}intersectTriangle(t,e,i,r,s){du.subVectors(e,t),Sa.subVectors(i,t),pu.crossVectors(du,Sa);let o=this.direction.dot(pu),a;if(o>0){if(r)return null;a=1}else if(o<0)a=-1,o=-o;else return null;Yn.subVectors(this.origin,t);let l=a*this.direction.dot(Sa.crossVectors(Yn,Sa));if(l<0)return null;let c=a*this.direction.dot(du.cross(Yn));if(c<0||l+c>o)return null;let u=-a*Yn.dot(pu);return u<0?null:this.at(u/o,s)}applyMatrix4(t){return this.origin.applyMatrix4(t),this.direction.transformDirection(t),this}equals(t){return t.origin.equals(this.origin)&&t.direction.equals(this.direction)}clone(){return new this.constructor().copy(this)}},wt=class{constructor(){this.elements=[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1],arguments.length>0&&console.error("THREE.Matrix4: the constructor no longer reads arguments. use .set() instead.")}set(t,e,i,r,s,o,a,l,c,u,h,f,d,g,x,v){let m=this.elements;return m[0]=t,m[4]=e,m[8]=i,m[12]=r,m[1]=s,m[5]=o,m[9]=a,m[13]=l,m[2]=c,m[6]=u,m[10]=h,m[14]=f,m[3]=d,m[7]=g,m[11]=x,m[15]=v,this}identity(){return this.set(1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1),this}clone(){return new wt().fromArray(this.elements)}copy(t){let e=this.elements,i=t.elements;return e[0]=i[0],e[1]=i[1],e[2]=i[2],e[3]=i[3],e[4]=i[4],e[5]=i[5],e[6]=i[6],e[7]=i[7],e[8]=i[8],e[9]=i[9],e[10]=i[10],e[11]=i[11],e[12]=i[12],e[13]=i[13],e[14]=i[14],e[15]=i[15],this}copyPosition(t){let e=this.elements,i=t.elements;return e[12]=i[12],e[13]=i[13],e[14]=i[14],this}setFromMatrix3(t){let e=t.elements;return this.set(e[0],e[3],e[6],0,e[1],e[4],e[7],0,e[2],e[5],e[8],0,0,0,0,1),this}extractBasis(t,e,i){return t.setFromMatrixColumn(this,0),e.setFromMatrixColumn(this,1),i.setFromMatrixColumn(this,2),this}makeBasis(t,e,i){return this.set(t.x,e.x,i.x,0,t.y,e.y,i.y,0,t.z,e.z,i.z,0,0,0,0,1),this}extractRotation(t){let e=this.elements,i=t.elements,r=1/yr.setFromMatrixColumn(t,0).length(),s=1/yr.setFromMatrixColumn(t,1).length(),o=1/yr.setFromMatrixColumn(t,2).length();return e[0]=i[0]*r,e[1]=i[1]*r,e[2]=i[2]*r,e[3]=0,e[4]=i[4]*s,e[5]=i[5]*s,e[6]=i[6]*s,e[7]=0,e[8]=i[8]*o,e[9]=i[9]*o,e[10]=i[10]*o,e[11]=0,e[12]=0,e[13]=0,e[14]=0,e[15]=1,this}makeRotationFromEuler(t){t&&t.isEuler||console.error("THREE.Matrix4: .makeRotationFromEuler() now expects a Euler rotation rather than a Vector3 and order.");let e=this.elements,i=t.x,r=t.y,s=t.z,o=Math.cos(i),a=Math.sin(i),l=Math.cos(r),c=Math.sin(r),u=Math.cos(s),h=Math.sin(s);if(t.order==="XYZ"){let f=o*u,d=o*h,g=a*u,x=a*h;e[0]=l*u,e[4]=-l*h,e[8]=c,e[1]=d+g*c,e[5]=f-x*c,e[9]=-a*l,e[2]=x-f*c,e[6]=g+d*c,e[10]=o*l}else if(t.order==="YXZ"){let f=l*u,d=l*h,g=c*u,x=c*h;e[0]=f+x*a,e[4]=g*a-d,e[8]=o*c,e[1]=o*h,e[5]=o*u,e[9]=-a,e[2]=d*a-g,e[6]=x+f*a,e[10]=o*l}else if(t.order==="ZXY"){let f=l*u,d=l*h,g=c*u,x=c*h;e[0]=f-x*a,e[4]=-o*h,e[8]=g+d*a,e[1]=d+g*a,e[5]=o*u,e[9]=x-f*a,e[2]=-o*c,e[6]=a,e[10]=o*l}else if(t.order==="ZYX"){let f=o*u,d=o*h,g=a*u,x=a*h;e[0]=l*u,e[4]=g*c-d,e[8]=f*c+x,e[1]=l*h,e[5]=x*c+f,e[9]=d*c-g,e[2]=-c,e[6]=a*l,e[10]=o*l}else if(t.order==="YZX"){let f=o*l,d=o*c,g=a*l,x=a*c;e[0]=l*u,e[4]=x-f*h,e[8]=g*h+d,e[1]=h,e[5]=o*u,e[9]=-a*u,e[2]=-c*u,e[6]=d*h+g,e[10]=f-x*h}else if(t.order==="XZY"){let f=o*l,d=o*c,g=a*l,x=a*c;e[0]=l*u,e[4]=-h,e[8]=c*u,e[1]=f*h+x,e[5]=o*u,e[9]=d*h-g,e[2]=g*h-d,e[6]=a*u,e[10]=x*h+f}return e[3]=0,e[7]=0,e[11]=0,e[12]=0,e[13]=0,e[14]=0,e[15]=1,this}makeRotationFromQuaternion(t){return this.compose(sM,t,oM)}lookAt(t,e,i){let r=this.elements;return ke.subVectors(t,e),ke.lengthSq()===0&&(ke.z=1),ke.normalize(),Zn.crossVectors(i,ke),Zn.lengthSq()===0&&(Math.abs(i.z)===1?ke.x+=1e-4:ke.z+=1e-4,ke.normalize(),Zn.crossVectors(i,ke)),Zn.normalize(),Ea.crossVectors(ke,Zn),r[0]=Zn.x,r[4]=Ea.x,r[8]=ke.x,r[1]=Zn.y,r[5]=Ea.y,r[9]=ke.y,r[2]=Zn.z,r[6]=Ea.z,r[10]=ke.z,this}multiply(t,e){return e!==void 0?(console.warn("THREE.Matrix4: .multiply() now only accepts one argument. Use .multiplyMatrices( a, b ) instead."),this.multiplyMatrices(t,e)):this.multiplyMatrices(this,t)}premultiply(t){return this.multiplyMatrices(t,this)}multiplyMatrices(t,e){let i=t.elements,r=e.elements,s=this.elements,o=i[0],a=i[4],l=i[8],c=i[12],u=i[1],h=i[5],f=i[9],d=i[13],g=i[2],x=i[6],v=i[10],m=i[14],p=i[3],b=i[7],_=i[11],S=i[15],L=r[0],A=r[4],H=r[8],tt=r[12],X=r[1],y=r[5],R=r[9],D=r[13],F=r[2],z=r[6],N=r[10],V=r[14],Q=r[3],at=r[7],G=r[11],$=r[15];return s[0]=o*L+a*X+l*F+c*Q,s[4]=o*A+a*y+l*z+c*at,s[8]=o*H+a*R+l*N+c*G,s[12]=o*tt+a*D+l*V+c*$,s[1]=u*L+h*X+f*F+d*Q,s[5]=u*A+h*y+f*z+d*at,s[9]=u*H+h*R+f*N+d*G,s[13]=u*tt+h*D+f*V+d*$,s[2]=g*L+x*X+v*F+m*Q,s[6]=g*A+x*y+v*z+m*at,s[10]=g*H+x*R+v*N+m*G,s[14]=g*tt+x*D+v*V+m*$,s[3]=p*L+b*X+_*F+S*Q,s[7]=p*A+b*y+_*z+S*at,s[11]=p*H+b*R+_*N+S*G,s[15]=p*tt+b*D+_*V+S*$,this}multiplyScalar(t){let e=this.elements;return e[0]*=t,e[4]*=t,e[8]*=t,e[12]*=t,e[1]*=t,e[5]*=t,e[9]*=t,e[13]*=t,e[2]*=t,e[6]*=t,e[10]*=t,e[14]*=t,e[3]*=t,e[7]*=t,e[11]*=t,e[15]*=t,this}determinant(){let t=this.elements,e=t[0],i=t[4],r=t[8],s=t[12],o=t[1],a=t[5],l=t[9],c=t[13],u=t[2],h=t[6],f=t[10],d=t[14],g=t[3],x=t[7],v=t[11],m=t[15];return g*(+s*l*h-r*c*h-s*a*f+i*c*f+r*a*d-i*l*d)+x*(+e*l*d-e*c*f+s*o*f-r*o*d+r*c*u-s*l*u)+v*(+e*c*h-e*a*d-s*o*h+i*o*d+s*a*u-i*c*u)+m*(-r*a*u-e*l*h+e*a*f+r*o*h-i*o*f+i*l*u)}transpose(){let t=this.elements,e;return e=t[1],t[1]=t[4],t[4]=e,e=t[2],t[2]=t[8],t[8]=e,e=t[6],t[6]=t[9],t[9]=e,e=t[3],t[3]=t[12],t[12]=e,e=t[7],t[7]=t[13],t[13]=e,e=t[11],t[11]=t[14],t[14]=e,this}setPosition(t,e,i){let r=this.elements;return t.isVector3?(r[12]=t.x,r[13]=t.y,r[14]=t.z):(r[12]=t,r[13]=e,r[14]=i),this}invert(){let t=this.elements,e=t[0],i=t[1],r=t[2],s=t[3],o=t[4],a=t[5],l=t[6],c=t[7],u=t[8],h=t[9],f=t[10],d=t[11],g=t[12],x=t[13],v=t[14],m=t[15],p=h*v*c-x*f*c+x*l*d-a*v*d-h*l*m+a*f*m,b=g*f*c-u*v*c-g*l*d+o*v*d+u*l*m-o*f*m,_=u*x*c-g*h*c+g*a*d-o*x*d-u*a*m+o*h*m,S=g*h*l-u*x*l-g*a*f+o*x*f+u*a*v-o*h*v,L=e*p+i*b+r*_+s*S;if(L===0)return this.set(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0);let A=1/L;return t[0]=p*A,t[1]=(x*f*s-h*v*s-x*r*d+i*v*d+h*r*m-i*f*m)*A,t[2]=(a*v*s-x*l*s+x*r*c-i*v*c-a*r*m+i*l*m)*A,t[3]=(h*l*s-a*f*s-h*r*c+i*f*c+a*r*d-i*l*d)*A,t[4]=b*A,t[5]=(u*v*s-g*f*s+g*r*d-e*v*d-u*r*m+e*f*m)*A,t[6]=(g*l*s-o*v*s-g*r*c+e*v*c+o*r*m-e*l*m)*A,t[7]=(o*f*s-u*l*s+u*r*c-e*f*c-o*r*d+e*l*d)*A,t[8]=_*A,t[9]=(g*h*s-u*x*s-g*i*d+e*x*d+u*i*m-e*h*m)*A,t[10]=(o*x*s-g*a*s+g*i*c-e*x*c-o*i*m+e*a*m)*A,t[11]=(u*a*s-o*h*s-u*i*c+e*h*c+o*i*d-e*a*d)*A,t[12]=S*A,t[13]=(u*x*r-g*h*r+g*i*f-e*x*f-u*i*v+e*h*v)*A,t[14]=(g*a*r-o*x*r-g*i*l+e*x*l+o*i*v-e*a*v)*A,t[15]=(o*h*r-u*a*r+u*i*l-e*h*l-o*i*f+e*a*f)*A,this}scale(t){let e=this.elements,i=t.x,r=t.y,s=t.z;return e[0]*=i,e[4]*=r,e[8]*=s,e[1]*=i,e[5]*=r,e[9]*=s,e[2]*=i,e[6]*=r,e[10]*=s,e[3]*=i,e[7]*=r,e[11]*=s,this}getMaxScaleOnAxis(){let t=this.elements,e=t[0]*t[0]+t[1]*t[1]+t[2]*t[2],i=t[4]*t[4]+t[5]*t[5]+t[6]*t[6],r=t[8]*t[8]+t[9]*t[9]+t[10]*t[10];return Math.sqrt(Math.max(e,i,r))}makeTranslation(t,e,i){return this.set(1,0,0,t,0,1,0,e,0,0,1,i,0,0,0,1),this}makeRotationX(t){let e=Math.cos(t),i=Math.sin(t);return this.set(1,0,0,0,0,e,-i,0,0,i,e,0,0,0,0,1),this}makeRotationY(t){let e=Math.cos(t),i=Math.sin(t);return this.set(e,0,i,0,0,1,0,0,-i,0,e,0,0,0,0,1),this}makeRotationZ(t){let e=Math.cos(t),i=Math.sin(t);return this.set(e,-i,0,0,i,e,0,0,0,0,1,0,0,0,0,1),this}makeRotationAxis(t,e){let i=Math.cos(e),r=Math.sin(e),s=1-i,o=t.x,a=t.y,l=t.z,c=s*o,u=s*a;return this.set(c*o+i,c*a-r*l,c*l+r*a,0,c*a+r*l,u*a+i,u*l-r*o,0,c*l-r*a,u*l+r*o,s*l*l+i,0,0,0,0,1),this}makeScale(t,e,i){return this.set(t,0,0,0,0,e,0,0,0,0,i,0,0,0,0,1),this}makeShear(t,e,i,r,s,o){return this.set(1,i,s,0,t,1,o,0,e,r,1,0,0,0,0,1),this}compose(t,e,i){let r=this.elements,s=e._x,o=e._y,a=e._z,l=e._w,c=s+s,u=o+o,h=a+a,f=s*c,d=s*u,g=s*h,x=o*u,v=o*h,m=a*h,p=l*c,b=l*u,_=l*h,S=i.x,L=i.y,A=i.z;return r[0]=(1-(x+m))*S,r[1]=(d+_)*S,r[2]=(g-b)*S,r[3]=0,r[4]=(d-_)*L,r[5]=(1-(f+m))*L,r[6]=(v+p)*L,r[7]=0,r[8]=(g+b)*A,r[9]=(v-p)*A,r[10]=(1-(f+x))*A,r[11]=0,r[12]=t.x,r[13]=t.y,r[14]=t.z,r[15]=1,this}decompose(t,e,i){let r=this.elements,s=yr.set(r[0],r[1],r[2]).length(),o=yr.set(r[4],r[5],r[6]).length(),a=yr.set(r[8],r[9],r[10]).length();this.determinant()<0&&(s=-s),t.x=r[12],t.y=r[13],t.z=r[14],Ke.copy(this);let c=1/s,u=1/o,h=1/a;return Ke.elements[0]*=c,Ke.elements[1]*=c,Ke.elements[2]*=c,Ke.elements[4]*=u,Ke.elements[5]*=u,Ke.elements[6]*=u,Ke.elements[8]*=h,Ke.elements[9]*=h,Ke.elements[10]*=h,e.setFromRotationMatrix(Ke),i.x=s,i.y=o,i.z=a,this}makePerspective(t,e,i,r,s,o){o===void 0&&console.warn("THREE.Matrix4: .makePerspective() has been redefined and has a new signature. Please check the docs.");let a=this.elements,l=2*s/(e-t),c=2*s/(i-r),u=(e+t)/(e-t),h=(i+r)/(i-r),f=-(o+s)/(o-s),d=-2*o*s/(o-s);return a[0]=l,a[4]=0,a[8]=u,a[12]=0,a[1]=0,a[5]=c,a[9]=h,a[13]=0,a[2]=0,a[6]=0,a[10]=f,a[14]=d,a[3]=0,a[7]=0,a[11]=-1,a[15]=0,this}makeOrthographic(t,e,i,r,s,o){let a=this.elements,l=1/(e-t),c=1/(i-r),u=1/(o-s),h=(e+t)*l,f=(i+r)*c,d=(o+s)*u;return a[0]=2*l,a[4]=0,a[8]=0,a[12]=-h,a[1]=0,a[5]=2*c,a[9]=0,a[13]=-f,a[2]=0,a[6]=0,a[10]=-2*u,a[14]=-d,a[3]=0,a[7]=0,a[11]=0,a[15]=1,this}equals(t){let e=this.elements,i=t.elements;for(let r=0;r<16;r++)if(e[r]!==i[r])return!1;return!0}fromArray(t,e=0){for(let i=0;i<16;i++)this.elements[i]=t[i+e];return this}toArray(t=[],e=0){let i=this.elements;return t[e]=i[0],t[e+1]=i[1],t[e+2]=i[2],t[e+3]=i[3],t[e+4]=i[4],t[e+5]=i[5],t[e+6]=i[6],t[e+7]=i[7],t[e+8]=i[8],t[e+9]=i[9],t[e+10]=i[10],t[e+11]=i[11],t[e+12]=i[12],t[e+13]=i[13],t[e+14]=i[14],t[e+15]=i[15],t}};wt.prototype.isMatrix4=!0;var yr=new T,Ke=new wt,sM=new T(0,0,0),oM=new T(1,1,1),Zn=new T,Ea=new T,ke=new T,og=new wt,ag=new Ee,ai=class{constructor(t=0,e=0,i=0,r=ai.DefaultOrder){this._x=t,this._y=e,this._z=i,this._order=r}get x(){return this._x}set x(t){this._x=t,this._onChangeCallback()}get y(){return this._y}set y(t){this._y=t,this._onChangeCallback()}get z(){return this._z}set z(t){this._z=t,this._onChangeCallback()}get order(){return this._order}set order(t){this._order=t,this._onChangeCallback()}set(t,e,i,r=this._order){return this._x=t,this._y=e,this._z=i,this._order=r,this._onChangeCallback(),this}clone(){return new this.constructor(this._x,this._y,this._z,this._order)}copy(t){return this._x=t._x,this._y=t._y,this._z=t._z,this._order=t._order,this._onChangeCallback(),this}setFromRotationMatrix(t,e=this._order,i=!0){let r=t.elements,s=r[0],o=r[4],a=r[8],l=r[1],c=r[5],u=r[9],h=r[2],f=r[6],d=r[10];switch(e){case"XYZ":this._y=Math.asin(Ie(a,-1,1)),Math.abs(a)<.9999999?(this._x=Math.atan2(-u,d),this._z=Math.atan2(-o,s)):(this._x=Math.atan2(f,c),this._z=0);break;case"YXZ":this._x=Math.asin(-Ie(u,-1,1)),Math.abs(u)<.9999999?(this._y=Math.atan2(a,d),this._z=Math.atan2(l,c)):(this._y=Math.atan2(-h,s),this._z=0);break;case"ZXY":this._x=Math.asin(Ie(f,-1,1)),Math.abs(f)<.9999999?(this._y=Math.atan2(-h,d),this._z=Math.atan2(-o,c)):(this._y=0,this._z=Math.atan2(l,s));break;case"ZYX":this._y=Math.asin(-Ie(h,-1,1)),Math.abs(h)<.9999999?(this._x=Math.atan2(f,d),this._z=Math.atan2(l,s)):(this._x=0,this._z=Math.atan2(-o,c));break;case"YZX":this._z=Math.asin(Ie(l,-1,1)),Math.abs(l)<.9999999?(this._x=Math.atan2(-u,c),this._y=Math.atan2(-h,s)):(this._x=0,this._y=Math.atan2(a,d));break;case"XZY":this._z=Math.asin(-Ie(o,-1,1)),Math.abs(o)<.9999999?(this._x=Math.atan2(f,c),this._y=Math.atan2(a,s)):(this._x=Math.atan2(-u,d),this._y=0);break;default:console.warn("THREE.Euler: .setFromRotationMatrix() encountered an unknown order: "+e)}return this._order=e,i===!0&&this._onChangeCallback(),this}setFromQuaternion(t,e,i){return og.makeRotationFromQuaternion(t),this.setFromRotationMatrix(og,e,i)}setFromVector3(t,e=this._order){return this.set(t.x,t.y,t.z,e)}reorder(t){return ag.setFromEuler(this),this.setFromQuaternion(ag,t)}equals(t){return t._x===this._x&&t._y===this._y&&t._z===this._z&&t._order===this._order}fromArray(t){return this._x=t[0],this._y=t[1],this._z=t[2],t[3]!==void 0&&(this._order=t[3]),this._onChangeCallback(),this}toArray(t=[],e=0){return t[e]=this._x,t[e+1]=this._y,t[e+2]=this._z,t[e+3]=this._order,t}toVector3(t){return t?t.set(this._x,this._y,this._z):new T(this._x,this._y,this._z)}_onChange(t){return this._onChangeCallback=t,this}_onChangeCallback(){}};ai.prototype.isEuler=!0;ai.DefaultOrder="XYZ";ai.RotationOrders=["XYZ","YZX","ZXY","XZY","YXZ","ZYX"];var il=class{constructor(){this.mask=1}set(t){this.mask=(1<<t|0)>>>0}enable(t){this.mask|=1<<t|0}enableAll(){this.mask=-1}toggle(t){this.mask^=1<<t|0}disable(t){this.mask&=~(1<<t|0)}disableAll(){this.mask=0}test(t){return(this.mask&t.mask)!==0}isEnabled(t){return(this.mask&(1<<t|0))!==0}},aM=0,lg=new T,vr=new Ee,Rn=new wt,Ta=new T,Hs=new T,lM=new T,cM=new Ee,cg=new T(1,0,0),ug=new T(0,1,0),hg=new T(0,0,1),uM={type:"added"},fg={type:"removed"},kt=class extends In{constructor(){super(),Object.defineProperty(this,"id",{value:aM++}),this.uuid=tn(),this.name="",this.type="Object3D",this.parent=null,this.children=[],this.up=kt.DefaultUp.clone();let t=new T,e=new ai,i=new Ee,r=new T(1,1,1);function s(){i.setFromEuler(e,!1)}function o(){e.setFromQuaternion(i,void 0,!1)}e._onChange(s),i._onChange(o),Object.defineProperties(this,{position:{configurable:!0,enumerable:!0,value:t},rotation:{configurable:!0,enumerable:!0,value:e},quaternion:{configurable:!0,enumerable:!0,value:i},scale:{configurable:!0,enumerable:!0,value:r},modelViewMatrix:{value:new wt},normalMatrix:{value:new de}}),this.matrix=new wt,this.matrixWorld=new wt,this.matrixAutoUpdate=kt.DefaultMatrixAutoUpdate,this.matrixWorldNeedsUpdate=!1,this.layers=new il,this.visible=!0,this.castShadow=!1,this.receiveShadow=!1,this.frustumCulled=!0,this.renderOrder=0,this.animations=[],this.userData={}}onBeforeRender(){}onAfterRender(){}applyMatrix4(t){this.matrixAutoUpdate&&this.updateMatrix(),this.matrix.premultiply(t),this.matrix.decompose(this.position,this.quaternion,this.scale)}applyQuaternion(t){return this.quaternion.premultiply(t),this}setRotationFromAxisAngle(t,e){this.quaternion.setFromAxisAngle(t,e)}setRotationFromEuler(t){this.quaternion.setFromEuler(t,!0)}setRotationFromMatrix(t){this.quaternion.setFromRotationMatrix(t)}setRotationFromQuaternion(t){this.quaternion.copy(t)}rotateOnAxis(t,e){return vr.setFromAxisAngle(t,e),this.quaternion.multiply(vr),this}rotateOnWorldAxis(t,e){return vr.setFromAxisAngle(t,e),this.quaternion.premultiply(vr),this}rotateX(t){return this.rotateOnAxis(cg,t)}rotateY(t){return this.rotateOnAxis(ug,t)}rotateZ(t){return this.rotateOnAxis(hg,t)}translateOnAxis(t,e){return lg.copy(t).applyQuaternion(this.quaternion),this.position.add(lg.multiplyScalar(e)),this}translateX(t){return this.translateOnAxis(cg,t)}translateY(t){return this.translateOnAxis(ug,t)}translateZ(t){return this.translateOnAxis(hg,t)}localToWorld(t){return t.applyMatrix4(this.matrixWorld)}worldToLocal(t){return t.applyMatrix4(Rn.copy(this.matrixWorld).invert())}lookAt(t,e,i){t.isVector3?Ta.copy(t):Ta.set(t,e,i);let r=this.parent;this.updateWorldMatrix(!0,!1),Hs.setFromMatrixPosition(this.matrixWorld),this.isCamera||this.isLight?Rn.lookAt(Hs,Ta,this.up):Rn.lookAt(Ta,Hs,this.up),this.quaternion.setFromRotationMatrix(Rn),r&&(Rn.extractRotation(r.matrixWorld),vr.setFromRotationMatrix(Rn),this.quaternion.premultiply(vr.invert()))}add(t){if(arguments.length>1){for(let e=0;e<arguments.length;e++)this.add(arguments[e]);return this}return t===this?(console.error("THREE.Object3D.add: object can't be added as a child of itself.",t),this):(t&&t.isObject3D?(t.parent!==null&&t.parent.remove(t),t.parent=this,this.children.push(t),t.dispatchEvent(uM)):console.error("THREE.Object3D.add: object not an instance of THREE.Object3D.",t),this)}remove(t){if(arguments.length>1){for(let i=0;i<arguments.length;i++)this.remove(arguments[i]);return this}let e=this.children.indexOf(t);return e!==-1&&(t.parent=null,this.children.splice(e,1),t.dispatchEvent(fg)),this}removeFromParent(){let t=this.parent;return t!==null&&t.remove(this),this}clear(){for(let t=0;t<this.children.length;t++){let e=this.children[t];e.parent=null,e.dispatchEvent(fg)}return this.children.length=0,this}attach(t){return this.updateWorldMatrix(!0,!1),Rn.copy(this.matrixWorld).invert(),t.parent!==null&&(t.parent.updateWorldMatrix(!0,!1),Rn.multiply(t.parent.matrixWorld)),t.applyMatrix4(Rn),this.add(t),t.updateWorldMatrix(!1,!0),this}getObjectById(t){return this.getObjectByProperty("id",t)}getObjectByName(t){return this.getObjectByProperty("name",t)}getObjectByProperty(t,e){if(this[t]===e)return this;for(let i=0,r=this.children.length;i<r;i++){let o=this.children[i].getObjectByProperty(t,e);if(o!==void 0)return o}}getWorldPosition(t){return this.updateWorldMatrix(!0,!1),t.setFromMatrixPosition(this.matrixWorld)}getWorldQuaternion(t){return this.updateWorldMatrix(!0,!1),this.matrixWorld.decompose(Hs,t,lM),t}getWorldScale(t){return this.updateWorldMatrix(!0,!1),this.matrixWorld.decompose(Hs,cM,t),t}getWorldDirection(t){this.updateWorldMatrix(!0,!1);let e=this.matrixWorld.elements;return t.set(e[8],e[9],e[10]).normalize()}raycast(){}traverse(t){t(this);let e=this.children;for(let i=0,r=e.length;i<r;i++)e[i].traverse(t)}traverseVisible(t){if(this.visible===!1)return;t(this);let e=this.children;for(let i=0,r=e.length;i<r;i++)e[i].traverseVisible(t)}traverseAncestors(t){let e=this.parent;e!==null&&(t(e),e.traverseAncestors(t))}updateMatrix(){this.matrix.compose(this.position,this.quaternion,this.scale),this.matrixWorldNeedsUpdate=!0}updateMatrixWorld(t){this.matrixAutoUpdate&&this.updateMatrix(),(this.matrixWorldNeedsUpdate||t)&&(this.parent===null?this.matrixWorld.copy(this.matrix):this.matrixWorld.multiplyMatrices(this.parent.matrixWorld,this.matrix),this.matrixWorldNeedsUpdate=!1,t=!0);let e=this.children;for(let i=0,r=e.length;i<r;i++)e[i].updateMatrixWorld(t)}updateWorldMatrix(t,e){let i=this.parent;if(t===!0&&i!==null&&i.updateWorldMatrix(!0,!1),this.matrixAutoUpdate&&this.updateMatrix(),this.parent===null?this.matrixWorld.copy(this.matrix):this.matrixWorld.multiplyMatrices(this.parent.matrixWorld,this.matrix),e===!0){let r=this.children;for(let s=0,o=r.length;s<o;s++)r[s].updateWorldMatrix(!1,!0)}}toJSON(t){let e=t===void 0||typeof t=="string",i={};e&&(t={geometries:{},materials:{},textures:{},images:{},shapes:{},skeletons:{},animations:{}},i.metadata={version:4.5,type:"Object",generator:"Object3D.toJSON"});let r={};r.uuid=this.uuid,r.type=this.type,this.name!==""&&(r.name=this.name),this.castShadow===!0&&(r.castShadow=!0),this.receiveShadow===!0&&(r.receiveShadow=!0),this.visible===!1&&(r.visible=!1),this.frustumCulled===!1&&(r.frustumCulled=!1),this.renderOrder!==0&&(r.renderOrder=this.renderOrder),JSON.stringify(this.userData)!=="{}"&&(r.userData=this.userData),r.layers=this.layers.mask,r.matrix=this.matrix.toArray(),this.matrixAutoUpdate===!1&&(r.matrixAutoUpdate=!1),this.isInstancedMesh&&(r.type="InstancedMesh",r.count=this.count,r.instanceMatrix=this.instanceMatrix.toJSON(),this.instanceColor!==null&&(r.instanceColor=this.instanceColor.toJSON()));function s(a,l){return a[l.uuid]===void 0&&(a[l.uuid]=l.toJSON(t)),l.uuid}if(this.isScene)this.background&&(this.background.isColor?r.background=this.background.toJSON():this.background.isTexture&&(r.background=this.background.toJSON(t).uuid)),this.environment&&this.environment.isTexture&&(r.environment=this.environment.toJSON(t).uuid);else if(this.isMesh||this.isLine||this.isPoints){r.geometry=s(t.geometries,this.geometry);let a=this.geometry.parameters;if(a!==void 0&&a.shapes!==void 0){let l=a.shapes;if(Array.isArray(l))for(let c=0,u=l.length;c<u;c++){let h=l[c];s(t.shapes,h)}else s(t.shapes,l)}}if(this.isSkinnedMesh&&(r.bindMode=this.bindMode,r.bindMatrix=this.bindMatrix.toArray(),this.skeleton!==void 0&&(s(t.skeletons,this.skeleton),r.skeleton=this.skeleton.uuid)),this.material!==void 0)if(Array.isArray(this.material)){let a=[];for(let l=0,c=this.material.length;l<c;l++)a.push(s(t.materials,this.material[l]));r.material=a}else r.material=s(t.materials,this.material);if(this.children.length>0){r.children=[];for(let a=0;a<this.children.length;a++)r.children.push(this.children[a].toJSON(t).object)}if(this.animations.length>0){r.animations=[];for(let a=0;a<this.animations.length;a++){let l=this.animations[a];r.animations.push(s(t.animations,l))}}if(e){let a=o(t.geometries),l=o(t.materials),c=o(t.textures),u=o(t.images),h=o(t.shapes),f=o(t.skeletons),d=o(t.animations);a.length>0&&(i.geometries=a),l.length>0&&(i.materials=l),c.length>0&&(i.textures=c),u.length>0&&(i.images=u),h.length>0&&(i.shapes=h),f.length>0&&(i.skeletons=f),d.length>0&&(i.animations=d)}return i.object=r,i;function o(a){let l=[];for(let c in a){let u=a[c];delete u.metadata,l.push(u)}return l}}clone(t){return new this.constructor().copy(this,t)}copy(t,e=!0){if(this.name=t.name,this.up.copy(t.up),this.position.copy(t.position),this.rotation.order=t.rotation.order,this.quaternion.copy(t.quaternion),this.scale.copy(t.scale),this.matrix.copy(t.matrix),this.matrixWorld.copy(t.matrixWorld),this.matrixAutoUpdate=t.matrixAutoUpdate,this.matrixWorldNeedsUpdate=t.matrixWorldNeedsUpdate,this.layers.mask=t.layers.mask,this.visible=t.visible,this.castShadow=t.castShadow,this.receiveShadow=t.receiveShadow,this.frustumCulled=t.frustumCulled,this.renderOrder=t.renderOrder,this.userData=JSON.parse(JSON.stringify(t.userData)),e===!0)for(let i=0;i<t.children.length;i++){let r=t.children[i];this.add(r.clone())}return this}};kt.DefaultUp=new T(0,1,0);kt.DefaultMatrixAutoUpdate=!0;kt.prototype.isObject3D=!0;var Qe=new T,Ln=new T,mu=new T,Pn=new T,_r=new T,wr=new T,dg=new T,gu=new T,xu=new T,yu=new T,re=class{constructor(t=new T,e=new T,i=new T){this.a=t,this.b=e,this.c=i}static getNormal(t,e,i,r){r.subVectors(i,e),Qe.subVectors(t,e),r.cross(Qe);let s=r.lengthSq();return s>0?r.multiplyScalar(1/Math.sqrt(s)):r.set(0,0,0)}static getBarycoord(t,e,i,r,s){Qe.subVectors(r,e),Ln.subVectors(i,e),mu.subVectors(t,e);let o=Qe.dot(Qe),a=Qe.dot(Ln),l=Qe.dot(mu),c=Ln.dot(Ln),u=Ln.dot(mu),h=o*c-a*a;if(h===0)return s.set(-2,-1,-1);let f=1/h,d=(c*l-a*u)*f,g=(o*u-a*l)*f;return s.set(1-d-g,g,d)}static containsPoint(t,e,i,r){return this.getBarycoord(t,e,i,r,Pn),Pn.x>=0&&Pn.y>=0&&Pn.x+Pn.y<=1}static getUV(t,e,i,r,s,o,a,l){return this.getBarycoord(t,e,i,r,Pn),l.set(0,0),l.addScaledVector(s,Pn.x),l.addScaledVector(o,Pn.y),l.addScaledVector(a,Pn.z),l}static isFrontFacing(t,e,i,r){return Qe.subVectors(i,e),Ln.subVectors(t,e),Qe.cross(Ln).dot(r)<0}set(t,e,i){return this.a.copy(t),this.b.copy(e),this.c.copy(i),this}setFromPointsAndIndices(t,e,i,r){return this.a.copy(t[e]),this.b.copy(t[i]),this.c.copy(t[r]),this}setFromAttributeAndIndices(t,e,i,r){return this.a.fromBufferAttribute(t,e),this.b.fromBufferAttribute(t,i),this.c.fromBufferAttribute(t,r),this}clone(){return new this.constructor().copy(this)}copy(t){return this.a.copy(t.a),this.b.copy(t.b),this.c.copy(t.c),this}getArea(){return Qe.subVectors(this.c,this.b),Ln.subVectors(this.a,this.b),Qe.cross(Ln).length()*.5}getMidpoint(t){return t.addVectors(this.a,this.b).add(this.c).multiplyScalar(1/3)}getNormal(t){return re.getNormal(this.a,this.b,this.c,t)}getPlane(t){return t.setFromCoplanarPoints(this.a,this.b,this.c)}getBarycoord(t,e){return re.getBarycoord(t,this.a,this.b,this.c,e)}getUV(t,e,i,r,s){return re.getUV(t,this.a,this.b,this.c,e,i,r,s)}containsPoint(t){return re.containsPoint(t,this.a,this.b,this.c)}isFrontFacing(t){return re.isFrontFacing(this.a,this.b,this.c,t)}intersectsBox(t){return t.intersectsTriangle(this)}closestPointToPoint(t,e){let i=this.a,r=this.b,s=this.c,o,a;_r.subVectors(r,i),wr.subVectors(s,i),gu.subVectors(t,i);let l=_r.dot(gu),c=wr.dot(gu);if(l<=0&&c<=0)return e.copy(i);xu.subVectors(t,r);let u=_r.dot(xu),h=wr.dot(xu);if(u>=0&&h<=u)return e.copy(r);let f=l*h-u*c;if(f<=0&&l>=0&&u<=0)return o=l/(l-u),e.copy(i).addScaledVector(_r,o);yu.subVectors(t,s);let d=_r.dot(yu),g=wr.dot(yu);if(g>=0&&d<=g)return e.copy(s);let x=d*c-l*g;if(x<=0&&c>=0&&g<=0)return a=c/(c-g),e.copy(i).addScaledVector(wr,a);let v=u*g-d*h;if(v<=0&&h-u>=0&&d-g>=0)return dg.subVectors(s,r),a=(h-u)/(h-u+(d-g)),e.copy(r).addScaledVector(dg,a);let m=1/(v+x+f);return o=x*m,a=f*m,e.copy(i).addScaledVector(_r,o).addScaledVector(wr,a)}equals(t){return t.a.equals(this.a)&&t.b.equals(this.b)&&t.c.equals(this.c)}},hM=0,xe=class extends In{constructor(){super(),Object.defineProperty(this,"id",{value:hM++}),this.uuid=tn(),this.name="",this.type="Material",this.fog=!0,this.blending=Ks,this.side=eo,this.vertexColors=!1,this.opacity=1,this.transparent=!1,this.blendSrc=u0,this.blendDst=h0,this.blendEquation=Ir,this.blendSrcAlpha=null,this.blendDstAlpha=null,this.blendEquationAlpha=null,this.depthFunc=zu,this.depthTest=!0,this.depthWrite=!0,this.stencilWriteMask=255,this.stencilFunc=tM,this.stencilRef=0,this.stencilFuncMask=255,this.stencilFail=nu,this.stencilZFail=nu,this.stencilZPass=nu,this.stencilWrite=!1,this.clippingPlanes=null,this.clipIntersection=!1,this.clipShadows=!1,this.shadowSide=null,this.colorWrite=!0,this.alphaWrite=!0,this.precision=null,this.polygonOffset=!1,this.polygonOffsetFactor=0,this.polygonOffsetUnits=0,this.dithering=!1,this.alphaToCoverage=!1,this.premultipliedAlpha=!1,this.visible=!0,this.toneMapped=!0,this.userData={},this.version=0,this._alphaTest=0}get alphaTest(){return this._alphaTest}set alphaTest(t){this._alphaTest>0!=t>0&&this.version++,this._alphaTest=t}onBuild(){}onBeforeRender(){}onBeforeCompile(){}customProgramCacheKey(){return this.onBeforeCompile.toString()}setValues(t){if(t!==void 0)for(let e in t){let i=t[e];if(i===void 0){console.warn("THREE.Material: '"+e+"' parameter is undefined.");continue}if(e==="shading"){console.warn("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead."),this.flatShading=i===c0;continue}let r=this[e];if(r===void 0){console.warn("THREE."+this.type+": '"+e+"' is not a property of this material.");continue}r&&r.isColor?r.set(i):r&&r.isVector3&&i&&i.isVector3?r.copy(i):this[e]=i}}toJSON(t){let e=t===void 0||typeof t=="string";e&&(t={textures:{},images:{}});let i={metadata:{version:4.5,type:"Material",generator:"Material.toJSON"}};i.uuid=this.uuid,i.type=this.type,this.name!==""&&(i.name=this.name),this.color&&this.color.isColor&&(i.color=this.color.getHex()),this.roughness!==void 0&&(i.roughness=this.roughness),this.metalness!==void 0&&(i.metalness=this.metalness),this.sheen!==void 0&&(i.sheen=this.sheen),this.sheenColor&&this.sheenColor.isColor&&(i.sheenColor=this.sheenColor.getHex()),this.sheenRoughness!==void 0&&(i.sheenRoughness=this.sheenRoughness),this.emissive&&this.emissive.isColor&&(i.emissive=this.emissive.getHex()),this.emissiveIntensity&&this.emissiveIntensity!==1&&(i.emissiveIntensity=this.emissiveIntensity),this.specular&&this.specular.isColor&&(i.specular=this.specular.getHex()),this.specularIntensity!==void 0&&(i.specularIntensity=this.specularIntensity),this.specularColor&&this.specularColor.isColor&&(i.specularColor=this.specularColor.getHex()),this.shininess!==void 0&&(i.shininess=this.shininess),this.clearcoat!==void 0&&(i.clearcoat=this.clearcoat),this.clearcoatRoughness!==void 0&&(i.clearcoatRoughness=this.clearcoatRoughness),this.clearcoatMap&&this.clearcoatMap.isTexture&&(i.clearcoatMap=this.clearcoatMap.toJSON(t).uuid),this.clearcoatRoughnessMap&&this.clearcoatRoughnessMap.isTexture&&(i.clearcoatRoughnessMap=this.clearcoatRoughnessMap.toJSON(t).uuid),this.clearcoatNormalMap&&this.clearcoatNormalMap.isTexture&&(i.clearcoatNormalMap=this.clearcoatNormalMap.toJSON(t).uuid,i.clearcoatNormalScale=this.clearcoatNormalScale.toArray()),this.map&&this.map.isTexture&&(i.map=this.map.toJSON(t).uuid),this.matcap&&this.matcap.isTexture&&(i.matcap=this.matcap.toJSON(t).uuid),this.alphaMap&&this.alphaMap.isTexture&&(i.alphaMap=this.alphaMap.toJSON(t).uuid),this.lightMap&&this.lightMap.isTexture&&(i.lightMap=this.lightMap.toJSON(t).uuid,i.lightMapIntensity=this.lightMapIntensity),this.aoMap&&this.aoMap.isTexture&&(i.aoMap=this.aoMap.toJSON(t).uuid,i.aoMapIntensity=this.aoMapIntensity),this.bumpMap&&this.bumpMap.isTexture&&(i.bumpMap=this.bumpMap.toJSON(t).uuid,i.bumpScale=this.bumpScale),this.normalMap&&this.normalMap.isTexture&&(i.normalMap=this.normalMap.toJSON(t).uuid,i.normalMapType=this.normalMapType,i.normalScale=this.normalScale.toArray()),this.displacementMap&&this.displacementMap.isTexture&&(i.displacementMap=this.displacementMap.toJSON(t).uuid,i.displacementScale=this.displacementScale,i.displacementBias=this.displacementBias),this.roughnessMap&&this.roughnessMap.isTexture&&(i.roughnessMap=this.roughnessMap.toJSON(t).uuid),this.metalnessMap&&this.metalnessMap.isTexture&&(i.metalnessMap=this.metalnessMap.toJSON(t).uuid),this.emissiveMap&&this.emissiveMap.isTexture&&(i.emissiveMap=this.emissiveMap.toJSON(t).uuid),this.specularMap&&this.specularMap.isTexture&&(i.specularMap=this.specularMap.toJSON(t).uuid),this.specularIntensityMap&&this.specularIntensityMap.isTexture&&(i.specularIntensityMap=this.specularIntensityMap.toJSON(t).uuid),this.specularColorMap&&this.specularColorMap.isTexture&&(i.specularColorMap=this.specularColorMap.toJSON(t).uuid),this.envMap&&this.envMap.isTexture&&(i.envMap=this.envMap.toJSON(t).uuid,this.combine!==void 0&&(i.combine=this.combine)),this.envMapIntensity!==void 0&&(i.envMapIntensity=this.envMapIntensity),this.reflectivity!==void 0&&(i.reflectivity=this.reflectivity),this.refractionRatio!==void 0&&(i.refractionRatio=this.refractionRatio),this.gradientMap&&this.gradientMap.isTexture&&(i.gradientMap=this.gradientMap.toJSON(t).uuid),this.transmission!==void 0&&(i.transmission=this.transmission),this.transmissionMap&&this.transmissionMap.isTexture&&(i.transmissionMap=this.transmissionMap.toJSON(t).uuid),this.thickness!==void 0&&(i.thickness=this.thickness),this.thicknessMap&&this.thicknessMap.isTexture&&(i.thicknessMap=this.thicknessMap.toJSON(t).uuid),this.attenuationDistance!==void 0&&(i.attenuationDistance=this.attenuationDistance),this.attenuationColor!==void 0&&(i.attenuationColor=this.attenuationColor.getHex()),this.size!==void 0&&(i.size=this.size),this.shadowSide!==null&&(i.shadowSide=this.shadowSide),this.sizeAttenuation!==void 0&&(i.sizeAttenuation=this.sizeAttenuation),this.blending!==Ks&&(i.blending=this.blending),this.side!==eo&&(i.side=this.side),this.vertexColors&&(i.vertexColors=!0),this.opacity<1&&(i.opacity=this.opacity),this.transparent===!0&&(i.transparent=this.transparent),i.depthFunc=this.depthFunc,i.depthTest=this.depthTest,i.depthWrite=this.depthWrite,i.colorWrite=this.colorWrite,i.alphaWrite=this.alphaWrite,i.stencilWrite=this.stencilWrite,i.stencilWriteMask=this.stencilWriteMask,i.stencilFunc=this.stencilFunc,i.stencilRef=this.stencilRef,i.stencilFuncMask=this.stencilFuncMask,i.stencilFail=this.stencilFail,i.stencilZFail=this.stencilZFail,i.stencilZPass=this.stencilZPass,this.rotation&&this.rotation!==0&&(i.rotation=this.rotation),this.polygonOffset===!0&&(i.polygonOffset=!0),this.polygonOffsetFactor!==0&&(i.polygonOffsetFactor=this.polygonOffsetFactor),this.polygonOffsetUnits!==0&&(i.polygonOffsetUnits=this.polygonOffsetUnits),this.linewidth&&this.linewidth!==1&&(i.linewidth=this.linewidth),this.dashSize!==void 0&&(i.dashSize=this.dashSize),this.gapSize!==void 0&&(i.gapSize=this.gapSize),this.scale!==void 0&&(i.scale=this.scale),this.dithering===!0&&(i.dithering=!0),this.alphaTest>0&&(i.alphaTest=this.alphaTest),this.alphaToCoverage===!0&&(i.alphaToCoverage=this.alphaToCoverage),this.premultipliedAlpha===!0&&(i.premultipliedAlpha=this.premultipliedAlpha),this.wireframe===!0&&(i.wireframe=this.wireframe),this.wireframeLinewidth>1&&(i.wireframeLinewidth=this.wireframeLinewidth),this.wireframeLinecap!=="round"&&(i.wireframeLinecap=this.wireframeLinecap),this.wireframeLinejoin!=="round"&&(i.wireframeLinejoin=this.wireframeLinejoin),this.flatShading===!0&&(i.flatShading=this.flatShading),this.visible===!1&&(i.visible=!1),this.toneMapped===!1&&(i.toneMapped=!1),JSON.stringify(this.userData)!=="{}"&&(i.userData=this.userData);function r(s){let o=[];for(let a in s){let l=s[a];delete l.metadata,o.push(l)}return o}if(e){let s=r(t.textures),o=r(t.images);s.length>0&&(i.textures=s),o.length>0&&(i.images=o)}return i}clone(){return new this.constructor().copy(this)}copy(t){this.name=t.name,this.fog=t.fog,this.blending=t.blending,this.side=t.side,this.vertexColors=t.vertexColors,this.opacity=t.opacity,this.transparent=t.transparent,this.blendSrc=t.blendSrc,this.blendDst=t.blendDst,this.blendEquation=t.blendEquation,this.blendSrcAlpha=t.blendSrcAlpha,this.blendDstAlpha=t.blendDstAlpha,this.blendEquationAlpha=t.blendEquationAlpha,this.depthFunc=t.depthFunc,this.depthTest=t.depthTest,this.depthWrite=t.depthWrite,this.stencilWriteMask=t.stencilWriteMask,this.stencilFunc=t.stencilFunc,this.stencilRef=t.stencilRef,this.stencilFuncMask=t.stencilFuncMask,this.stencilFail=t.stencilFail,this.stencilZFail=t.stencilZFail,this.stencilZPass=t.stencilZPass,this.stencilWrite=t.stencilWrite;let e=t.clippingPlanes,i=null;if(e!==null){let r=e.length;i=new Array(r);for(let s=0;s!==r;++s)i[s]=e[s].clone()}return this.clippingPlanes=i,this.clipIntersection=t.clipIntersection,this.clipShadows=t.clipShadows,this.shadowSide=t.shadowSide,this.colorWrite=t.colorWrite,this.alphaWrite=t.alphaWrite,this.precision=t.precision,this.polygonOffset=t.polygonOffset,this.polygonOffsetFactor=t.polygonOffsetFactor,this.polygonOffsetUnits=t.polygonOffsetUnits,this.dithering=t.dithering,this.alphaTest=t.alphaTest,this.alphaToCoverage=t.alphaToCoverage,this.premultipliedAlpha=t.premultipliedAlpha,this.visible=t.visible,this.toneMapped=t.toneMapped,this.userData=JSON.parse(JSON.stringify(t.userData)),this}dispose(){this.dispatchEvent({type:"dispose"})}set needsUpdate(t){t===!0&&this.version++}};xe.prototype.isMaterial=!0;var ki=class extends xe{constructor(t){super(),this.type="MeshBasicMaterial",this.color=new ft(16777215),this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.specularMap=null,this.alphaMap=null,this.envMap=null,this.combine=Cl,this.reflectivity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.specularMap=t.specularMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.combine=t.combine,this.reflectivity=t.reflectivity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this}};ki.prototype.isMeshBasicMaterial=!0;var Jt=new T,Aa=new K,Qt=class{constructor(t,e,i){if(Array.isArray(t))throw new TypeError("THREE.BufferAttribute: array should be a Typed Array.");this.name="",this.array=t,this.itemSize=e,this.count=t!==void 0?t.length/e:0,this.normalized=i===!0,this.usage=io,this.updateRange={offset:0,count:-1},this.version=0}onUploadCallback(){}set needsUpdate(t){t===!0&&this.version++}setUsage(t){return this.usage=t,this}copy(t){return this.name=t.name,this.array=new t.array.constructor(t.array),this.itemSize=t.itemSize,this.count=t.count,this.normalized=t.normalized,this.usage=t.usage,this}copyAt(t,e,i){t*=this.itemSize,i*=e.itemSize;for(let r=0,s=this.itemSize;r<s;r++)this.array[t+r]=e.array[i+r];return this}copyArray(t){return this.array.set(t),this}copyColorsArray(t){let e=this.array,i=0;for(let r=0,s=t.length;r<s;r++){let o=t[r];o===void 0&&(console.warn("THREE.BufferAttribute.copyColorsArray(): color is undefined",r),o=new ft),e[i++]=o.r,e[i++]=o.g,e[i++]=o.b}return this}copyVector2sArray(t){let e=this.array,i=0;for(let r=0,s=t.length;r<s;r++){let o=t[r];o===void 0&&(console.warn("THREE.BufferAttribute.copyVector2sArray(): vector is undefined",r),o=new K),e[i++]=o.x,e[i++]=o.y}return this}copyVector3sArray(t){let e=this.array,i=0;for(let r=0,s=t.length;r<s;r++){let o=t[r];o===void 0&&(console.warn("THREE.BufferAttribute.copyVector3sArray(): vector is undefined",r),o=new T),e[i++]=o.x,e[i++]=o.y,e[i++]=o.z}return this}copyVector4sArray(t){let e=this.array,i=0;for(let r=0,s=t.length;r<s;r++){let o=t[r];o===void 0&&(console.warn("THREE.BufferAttribute.copyVector4sArray(): vector is undefined",r),o=new Wt),e[i++]=o.x,e[i++]=o.y,e[i++]=o.z,e[i++]=o.w}return this}applyMatrix3(t){if(this.itemSize===2)for(let e=0,i=this.count;e<i;e++)Aa.fromBufferAttribute(this,e),Aa.applyMatrix3(t),this.setXY(e,Aa.x,Aa.y);else if(this.itemSize===3)for(let e=0,i=this.count;e<i;e++)Jt.fromBufferAttribute(this,e),Jt.applyMatrix3(t),this.setXYZ(e,Jt.x,Jt.y,Jt.z);return this}applyMatrix4(t){for(let e=0,i=this.count;e<i;e++)Jt.x=this.getX(e),Jt.y=this.getY(e),Jt.z=this.getZ(e),Jt.applyMatrix4(t),this.setXYZ(e,Jt.x,Jt.y,Jt.z);return this}applyNormalMatrix(t){for(let e=0,i=this.count;e<i;e++)Jt.x=this.getX(e),Jt.y=this.getY(e),Jt.z=this.getZ(e),Jt.applyNormalMatrix(t),this.setXYZ(e,Jt.x,Jt.y,Jt.z);return this}transformDirection(t){for(let e=0,i=this.count;e<i;e++)Jt.x=this.getX(e),Jt.y=this.getY(e),Jt.z=this.getZ(e),Jt.transformDirection(t),this.setXYZ(e,Jt.x,Jt.y,Jt.z);return this}set(t,e=0){return this.array.set(t,e),this}getX(t){return this.array[t*this.itemSize]}setX(t,e){return this.array[t*this.itemSize]=e,this}getY(t){return this.array[t*this.itemSize+1]}setY(t,e){return this.array[t*this.itemSize+1]=e,this}getZ(t){return this.array[t*this.itemSize+2]}setZ(t,e){return this.array[t*this.itemSize+2]=e,this}getW(t){return this.array[t*this.itemSize+3]}setW(t,e){return this.array[t*this.itemSize+3]=e,this}setXY(t,e,i){return t*=this.itemSize,this.array[t+0]=e,this.array[t+1]=i,this}setXYZ(t,e,i,r){return t*=this.itemSize,this.array[t+0]=e,this.array[t+1]=i,this.array[t+2]=r,this}setXYZW(t,e,i,r,s){return t*=this.itemSize,this.array[t+0]=e,this.array[t+1]=i,this.array[t+2]=r,this.array[t+3]=s,this}onUpload(t){return this.onUploadCallback=t,this}clone(){return new this.constructor(this.array,this.itemSize).copy(this)}toJSON(){let t={itemSize:this.itemSize,type:this.array.constructor.name,array:Array.prototype.slice.call(this.array),normalized:this.normalized};return this.name!==""&&(t.name=this.name),this.usage!==io&&(t.usage=this.usage),(this.updateRange.offset!==0||this.updateRange.count!==-1)&&(t.updateRange=this.updateRange),t}};Qt.prototype.isBufferAttribute=!0;var rl=class extends Qt{constructor(t,e,i){super(new Uint16Array(t),e,i)}};var sl=class extends Qt{constructor(t,e,i){super(new Uint32Array(t),e,i)}},Wu=class extends Qt{constructor(t,e,i){super(new Uint16Array(t),e,i)}};Wu.prototype.isFloat16BufferAttribute=!0;var ee=class extends Qt{constructor(t,e,i){super(new Float32Array(t),e,i)}};var fM=0,qe=new wt,vu=new kt,Mr=new T,He=new Ge,Vs=new Ge,ge=new T,Ht=class extends In{constructor(){super(),Object.defineProperty(this,"id",{value:fM++}),this.uuid=tn(),this.name="",this.type="BufferGeometry",this.index=null,this.attributes={},this.morphAttributes={},this.morphTargetsRelative=!1,this.groups=[],this.boundingBox=null,this.boundingSphere=null,this.drawRange={start:0,count:1/0},this.userData={}}getIndex(){return this.index}setIndex(t){return Array.isArray(t)?this.index=new(p0(t)?sl:rl)(t,1):this.index=t,this}getAttribute(t){return this.attributes[t]}setAttribute(t,e){return this.attributes[t]=e,this}deleteAttribute(t){return delete this.attributes[t],this}hasAttribute(t){return this.attributes[t]!==void 0}addGroup(t,e,i=0){this.groups.push({start:t,count:e,materialIndex:i})}clearGroups(){this.groups=[]}setDrawRange(t,e){this.drawRange.start=t,this.drawRange.count=e}applyMatrix4(t){let e=this.attributes.position;e!==void 0&&(e.applyMatrix4(t),e.needsUpdate=!0);let i=this.attributes.normal;if(i!==void 0){let s=new de().getNormalMatrix(t);i.applyNormalMatrix(s),i.needsUpdate=!0}let r=this.attributes.tangent;return r!==void 0&&(r.transformDirection(t),r.needsUpdate=!0),this.boundingBox!==null&&this.computeBoundingBox(),this.boundingSphere!==null&&this.computeBoundingSphere(),this}applyQuaternion(t){return qe.makeRotationFromQuaternion(t),this.applyMatrix4(qe),this}rotateX(t){return qe.makeRotationX(t),this.applyMatrix4(qe),this}rotateY(t){return qe.makeRotationY(t),this.applyMatrix4(qe),this}rotateZ(t){return qe.makeRotationZ(t),this.applyMatrix4(qe),this}translate(t,e,i){return qe.makeTranslation(t,e,i),this.applyMatrix4(qe),this}scale(t,e,i){return qe.makeScale(t,e,i),this.applyMatrix4(qe),this}lookAt(t){return vu.lookAt(t),vu.updateMatrix(),this.applyMatrix4(vu.matrix),this}center(){return this.computeBoundingBox(),this.boundingBox.getCenter(Mr).negate(),this.translate(Mr.x,Mr.y,Mr.z),this}setFromPoints(t){let e=[];for(let i=0,r=t.length;i<r;i++){let s=t[i];e.push(s.x,s.y,s.z||0)}return this.setAttribute("position",new ee(e,3)),this}computeBoundingBox(){this.boundingBox===null&&(this.boundingBox=new Ge);let t=this.attributes.position,e=this.morphAttributes.position;if(t&&t.isGLBufferAttribute){console.error('THREE.BufferGeometry.computeBoundingBox(): GLBufferAttribute requires a manual bounding box. Alternatively set "mesh.frustumCulled" to "false".',this),this.boundingBox.set(new T(-1/0,-1/0,-1/0),new T(1/0,1/0,1/0));return}if(t!==void 0){if(this.boundingBox.setFromBufferAttribute(t),e)for(let i=0,r=e.length;i<r;i++){let s=e[i];He.setFromBufferAttribute(s),this.morphTargetsRelative?(ge.addVectors(this.boundingBox.min,He.min),this.boundingBox.expandByPoint(ge),ge.addVectors(this.boundingBox.max,He.max),this.boundingBox.expandByPoint(ge)):(this.boundingBox.expandByPoint(He.min),this.boundingBox.expandByPoint(He.max))}}else this.boundingBox.makeEmpty();(isNaN(this.boundingBox.min.x)||isNaN(this.boundingBox.min.y)||isNaN(this.boundingBox.min.z))&&console.error('THREE.BufferGeometry.computeBoundingBox(): Computed min/max have NaN values. The "position" attribute is likely to have NaN values.',this)}computeBoundingSphere(){this.boundingSphere===null&&(this.boundingSphere=new si);let t=this.attributes.position,e=this.morphAttributes.position;if(t&&t.isGLBufferAttribute){console.error('THREE.BufferGeometry.computeBoundingSphere(): GLBufferAttribute requires a manual bounding sphere. Alternatively set "mesh.frustumCulled" to "false".',this),this.boundingSphere.set(new T,1/0);return}if(t){let i=this.boundingSphere.center;if(He.setFromBufferAttribute(t),e)for(let s=0,o=e.length;s<o;s++){let a=e[s];Vs.setFromBufferAttribute(a),this.morphTargetsRelative?(ge.addVectors(He.min,Vs.min),He.expandByPoint(ge),ge.addVectors(He.max,Vs.max),He.expandByPoint(ge)):(He.expandByPoint(Vs.min),He.expandByPoint(Vs.max))}He.getCenter(i);let r=0;for(let s=0,o=t.count;s<o;s++)ge.fromBufferAttribute(t,s),r=Math.max(r,i.distanceToSquared(ge));if(e)for(let s=0,o=e.length;s<o;s++){let a=e[s],l=this.morphTargetsRelative;for(let c=0,u=a.count;c<u;c++)ge.fromBufferAttribute(a,c),l&&(Mr.fromBufferAttribute(t,c),ge.add(Mr)),r=Math.max(r,i.distanceToSquared(ge))}this.boundingSphere.radius=Math.sqrt(r),isNaN(this.boundingSphere.radius)&&console.error('THREE.BufferGeometry.computeBoundingSphere(): Computed radius is NaN. The "position" attribute is likely to have NaN values.',this)}}computeTangents(){let t=this.index,e=this.attributes;if(t===null||e.position===void 0||e.normal===void 0||e.uv===void 0){console.error("THREE.BufferGeometry: .computeTangents() failed. Missing required attributes (index, position, normal or uv)");return}let i=t.array,r=e.position.array,s=e.normal.array,o=e.uv.array,a=r.length/3;e.tangent===void 0&&this.setAttribute("tangent",new Qt(new Float32Array(4*a),4));let l=e.tangent.array,c=[],u=[];for(let X=0;X<a;X++)c[X]=new T,u[X]=new T;let h=new T,f=new T,d=new T,g=new K,x=new K,v=new K,m=new T,p=new T;function b(X,y,R){h.fromArray(r,X*3),f.fromArray(r,y*3),d.fromArray(r,R*3),g.fromArray(o,X*2),x.fromArray(o,y*2),v.fromArray(o,R*2),f.sub(h),d.sub(h),x.sub(g),v.sub(g);let D=1/(x.x*v.y-v.x*x.y);!isFinite(D)||(m.copy(f).multiplyScalar(v.y).addScaledVector(d,-x.y).multiplyScalar(D),p.copy(d).multiplyScalar(x.x).addScaledVector(f,-v.x).multiplyScalar(D),c[X].add(m),c[y].add(m),c[R].add(m),u[X].add(p),u[y].add(p),u[R].add(p))}let _=this.groups;_.length===0&&(_=[{start:0,count:i.length}]);for(let X=0,y=_.length;X<y;++X){let R=_[X],D=R.start,F=R.count;for(let z=D,N=D+F;z<N;z+=3)b(i[z+0],i[z+1],i[z+2])}let S=new T,L=new T,A=new T,H=new T;function tt(X){A.fromArray(s,X*3),H.copy(A);let y=c[X];S.copy(y),S.sub(A.multiplyScalar(A.dot(y))).normalize(),L.crossVectors(H,y);let D=L.dot(u[X])<0?-1:1;l[X*4]=S.x,l[X*4+1]=S.y,l[X*4+2]=S.z,l[X*4+3]=D}for(let X=0,y=_.length;X<y;++X){let R=_[X],D=R.start,F=R.count;for(let z=D,N=D+F;z<N;z+=3)tt(i[z+0]),tt(i[z+1]),tt(i[z+2])}}computeVertexNormals(){let t=this.index,e=this.getAttribute("position");if(e!==void 0){let i=this.getAttribute("normal");if(i===void 0)i=new Qt(new Float32Array(e.count*3),3),this.setAttribute("normal",i);else for(let f=0,d=i.count;f<d;f++)i.setXYZ(f,0,0,0);let r=new T,s=new T,o=new T,a=new T,l=new T,c=new T,u=new T,h=new T;if(t)for(let f=0,d=t.count;f<d;f+=3){let g=t.getX(f+0),x=t.getX(f+1),v=t.getX(f+2);r.fromBufferAttribute(e,g),s.fromBufferAttribute(e,x),o.fromBufferAttribute(e,v),u.subVectors(o,s),h.subVectors(r,s),u.cross(h),a.fromBufferAttribute(i,g),l.fromBufferAttribute(i,x),c.fromBufferAttribute(i,v),a.add(u),l.add(u),c.add(u),i.setXYZ(g,a.x,a.y,a.z),i.setXYZ(x,l.x,l.y,l.z),i.setXYZ(v,c.x,c.y,c.z)}else for(let f=0,d=e.count;f<d;f+=3)r.fromBufferAttribute(e,f+0),s.fromBufferAttribute(e,f+1),o.fromBufferAttribute(e,f+2),u.subVectors(o,s),h.subVectors(r,s),u.cross(h),i.setXYZ(f+0,u.x,u.y,u.z),i.setXYZ(f+1,u.x,u.y,u.z),i.setXYZ(f+2,u.x,u.y,u.z);this.normalizeNormals(),i.needsUpdate=!0}}merge(t,e){if(!(t&&t.isBufferGeometry)){console.error("THREE.BufferGeometry.merge(): geometry not an instance of THREE.BufferGeometry.",t);return}e===void 0&&(e=0,console.warn("THREE.BufferGeometry.merge(): Overwriting original geometry, starting at offset=0. Use BufferGeometryUtils.mergeBufferGeometries() for lossless merge."));let i=this.attributes;for(let r in i){if(t.attributes[r]===void 0)continue;let o=i[r].array,a=t.attributes[r],l=a.array,c=a.itemSize*e,u=Math.min(l.length,o.length-c);for(let h=0,f=c;h<u;h++,f++)o[f]=l[h]}return this}normalizeNormals(){let t=this.attributes.normal;for(let e=0,i=t.count;e<i;e++)ge.fromBufferAttribute(t,e),ge.normalize(),t.setXYZ(e,ge.x,ge.y,ge.z)}toNonIndexed(){function t(a,l){let c=a.array,u=a.itemSize,h=a.normalized,f=new c.constructor(l.length*u),d=0,g=0;for(let x=0,v=l.length;x<v;x++){a.isInterleavedBufferAttribute?d=l[x]*a.data.stride+a.offset:d=l[x]*u;for(let m=0;m<u;m++)f[g++]=c[d++]}return new Qt(f,u,h)}if(this.index===null)return console.warn("THREE.BufferGeometry.toNonIndexed(): BufferGeometry is already non-indexed."),this;let e=new Ht,i=this.index.array,r=this.attributes;for(let a in r){let l=r[a],c=t(l,i);e.setAttribute(a,c)}let s=this.morphAttributes;for(let a in s){let l=[],c=s[a];for(let u=0,h=c.length;u<h;u++){let f=c[u],d=t(f,i);l.push(d)}e.morphAttributes[a]=l}e.morphTargetsRelative=this.morphTargetsRelative;let o=this.groups;for(let a=0,l=o.length;a<l;a++){let c=o[a];e.addGroup(c.start,c.count,c.materialIndex)}return e}toJSON(){let t={metadata:{version:4.5,type:"BufferGeometry",generator:"BufferGeometry.toJSON"}};if(t.uuid=this.uuid,t.type=this.type,this.name!==""&&(t.name=this.name),Object.keys(this.userData).length>0&&(t.userData=this.userData),this.parameters!==void 0){let l=this.parameters;for(let c in l)l[c]!==void 0&&(t[c]=l[c]);return t}t.data={attributes:{}};let e=this.index;e!==null&&(t.data.index={type:e.array.constructor.name,array:Array.prototype.slice.call(e.array)});let i=this.attributes;for(let l in i){let c=i[l];t.data.attributes[l]=c.toJSON(t.data)}let r={},s=!1;for(let l in this.morphAttributes){let c=this.morphAttributes[l],u=[];for(let h=0,f=c.length;h<f;h++){let d=c[h];u.push(d.toJSON(t.data))}u.length>0&&(r[l]=u,s=!0)}s&&(t.data.morphAttributes=r,t.data.morphTargetsRelative=this.morphTargetsRelative);let o=this.groups;o.length>0&&(t.data.groups=JSON.parse(JSON.stringify(o)));let a=this.boundingSphere;return a!==null&&(t.data.boundingSphere={center:a.center.toArray(),radius:a.radius}),t}clone(){return new this.constructor().copy(this)}copy(t){this.index=null,this.attributes={},this.morphAttributes={},this.groups=[],this.boundingBox=null,this.boundingSphere=null;let e={};this.name=t.name;let i=t.index;i!==null&&this.setIndex(i.clone(e));let r=t.attributes;for(let c in r){let u=r[c];this.setAttribute(c,u.clone(e))}let s=t.morphAttributes;for(let c in s){let u=[],h=s[c];for(let f=0,d=h.length;f<d;f++)u.push(h[f].clone(e));this.morphAttributes[c]=u}this.morphTargetsRelative=t.morphTargetsRelative;let o=t.groups;for(let c=0,u=o.length;c<u;c++){let h=o[c];this.addGroup(h.start,h.count,h.materialIndex)}let a=t.boundingBox;a!==null&&(this.boundingBox=a.clone());let l=t.boundingSphere;return l!==null&&(this.boundingSphere=l.clone()),this.drawRange.start=t.drawRange.start,this.drawRange.count=t.drawRange.count,this.userData=t.userData,t.parameters!==void 0&&(this.parameters=Object.assign({},t.parameters)),this}dispose(){this.dispatchEvent({type:"dispose"})}};Ht.prototype.isBufferGeometry=!0;var pg=new wt,br=new oi,_u=new si,Jn=new T,$n=new T,Kn=new T,wu=new T,Mu=new T,bu=new T,Ca=new T,Ra=new T,La=new T,Pa=new K,Da=new K,Ia=new K,Su=new T,Na=new T,oe=class extends kt{constructor(t=new Ht,e=new ki){super(),this.type="Mesh",this.geometry=t,this.material=e,this.updateMorphTargets()}copy(t){return super.copy(t),t.morphTargetInfluences!==void 0&&(this.morphTargetInfluences=t.morphTargetInfluences.slice()),t.morphTargetDictionary!==void 0&&(this.morphTargetDictionary=Object.assign({},t.morphTargetDictionary)),this.material=t.material,this.geometry=t.geometry,this}updateMorphTargets(){let t=this.geometry;if(t.isBufferGeometry){let e=t.morphAttributes,i=Object.keys(e);if(i.length>0){let r=e[i[0]];if(r!==void 0){this.morphTargetInfluences=[],this.morphTargetDictionary={};for(let s=0,o=r.length;s<o;s++){let a=r[s].name||String(s);this.morphTargetInfluences.push(0),this.morphTargetDictionary[a]=s}}}}else{let e=t.morphTargets;e!==void 0&&e.length>0&&console.error("THREE.Mesh.updateMorphTargets() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}}raycast(t,e){let i=this.geometry,r=this.material,s=this.matrixWorld;if(r===void 0||(i.boundingSphere===null&&i.computeBoundingSphere(),_u.copy(i.boundingSphere),_u.applyMatrix4(s),t.ray.intersectsSphere(_u)===!1)||(pg.copy(s).invert(),br.copy(t.ray).applyMatrix4(pg),i.boundingBox!==null&&br.intersectsBox(i.boundingBox)===!1))return;let o;if(i.isBufferGeometry){let a=i.index,l=i.attributes.position,c=i.morphAttributes.position,u=i.morphTargetsRelative,h=i.attributes.uv,f=i.attributes.uv2,d=i.groups,g=i.drawRange;if(a!==null)if(Array.isArray(r))for(let x=0,v=d.length;x<v;x++){let m=d[x],p=r[m.materialIndex],b=Math.max(m.start,g.start),_=Math.min(a.count,Math.min(m.start+m.count,g.start+g.count));for(let S=b,L=_;S<L;S+=3){let A=a.getX(S),H=a.getX(S+1),tt=a.getX(S+2);o=Fa(this,p,t,br,l,c,u,h,f,A,H,tt),o&&(o.faceIndex=Math.floor(S/3),o.face.materialIndex=m.materialIndex,e.push(o))}}else{let x=Math.max(0,g.start),v=Math.min(a.count,g.start+g.count);for(let m=x,p=v;m<p;m+=3){let b=a.getX(m),_=a.getX(m+1),S=a.getX(m+2);o=Fa(this,r,t,br,l,c,u,h,f,b,_,S),o&&(o.faceIndex=Math.floor(m/3),e.push(o))}}else if(l!==void 0)if(Array.isArray(r))for(let x=0,v=d.length;x<v;x++){let m=d[x],p=r[m.materialIndex],b=Math.max(m.start,g.start),_=Math.min(l.count,Math.min(m.start+m.count,g.start+g.count));for(let S=b,L=_;S<L;S+=3){let A=S,H=S+1,tt=S+2;o=Fa(this,p,t,br,l,c,u,h,f,A,H,tt),o&&(o.faceIndex=Math.floor(S/3),o.face.materialIndex=m.materialIndex,e.push(o))}}else{let x=Math.max(0,g.start),v=Math.min(l.count,g.start+g.count);for(let m=x,p=v;m<p;m+=3){let b=m,_=m+1,S=m+2;o=Fa(this,r,t,br,l,c,u,h,f,b,_,S),o&&(o.faceIndex=Math.floor(m/3),e.push(o))}}}else i.isGeometry&&console.error("THREE.Mesh.raycast() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}};oe.prototype.isMesh=!0;function dM(n,t,e,i,r,s,o,a){let l;if(t.side===he?l=i.intersectTriangle(o,s,r,!0,a):l=i.intersectTriangle(r,s,o,t.side!==Hr,a),l===null)return null;Na.copy(a),Na.applyMatrix4(n.matrixWorld);let c=e.ray.origin.distanceTo(Na);return c<e.near||c>e.far?null:{distance:c,point:Na.clone(),object:n}}function Fa(n,t,e,i,r,s,o,a,l,c,u,h){Jn.fromBufferAttribute(r,c),$n.fromBufferAttribute(r,u),Kn.fromBufferAttribute(r,h);let f=n.morphTargetInfluences;if(s&&f){Ca.set(0,0,0),Ra.set(0,0,0),La.set(0,0,0);for(let g=0,x=s.length;g<x;g++){let v=f[g],m=s[g];v!==0&&(wu.fromBufferAttribute(m,c),Mu.fromBufferAttribute(m,u),bu.fromBufferAttribute(m,h),o?(Ca.addScaledVector(wu,v),Ra.addScaledVector(Mu,v),La.addScaledVector(bu,v)):(Ca.addScaledVector(wu.sub(Jn),v),Ra.addScaledVector(Mu.sub($n),v),La.addScaledVector(bu.sub(Kn),v)))}Jn.add(Ca),$n.add(Ra),Kn.add(La)}n.isSkinnedMesh&&(n.boneTransform(c,Jn),n.boneTransform(u,$n),n.boneTransform(h,Kn));let d=dM(n,t,e,i,Jn,$n,Kn,Su);if(d){a&&(Pa.fromBufferAttribute(a,c),Da.fromBufferAttribute(a,u),Ia.fromBufferAttribute(a,h),d.uv=re.getUV(Su,Jn,$n,Kn,Pa,Da,Ia,new K)),l&&(Pa.fromBufferAttribute(l,c),Da.fromBufferAttribute(l,u),Ia.fromBufferAttribute(l,h),d.uv2=re.getUV(Su,Jn,$n,Kn,Pa,Da,Ia,new K));let g={a:c,b:u,c:h,normal:new T,materialIndex:0};re.getNormal(Jn,$n,Kn,g.normal),d.face=g}return d}var Hi=class extends Ht{constructor(t=1,e=1,i=1,r=1,s=1,o=1){super(),this.type="BoxGeometry",this.parameters={width:t,height:e,depth:i,widthSegments:r,heightSegments:s,depthSegments:o};let a=this;r=Math.floor(r),s=Math.floor(s),o=Math.floor(o);let l=[],c=[],u=[],h=[],f=0,d=0;g("z","y","x",-1,-1,i,e,t,o,s,0),g("z","y","x",1,-1,i,e,-t,o,s,1),g("x","z","y",1,1,t,i,e,r,o,2),g("x","z","y",1,-1,t,i,-e,r,o,3),g("x","y","z",1,-1,t,e,i,r,s,4),g("x","y","z",-1,-1,t,e,-i,r,s,5),this.setIndex(l),this.setAttribute("position",new ee(c,3)),this.setAttribute("normal",new ee(u,3)),this.setAttribute("uv",new ee(h,2));function g(x,v,m,p,b,_,S,L,A,H,tt){let X=_/A,y=S/H,R=_/2,D=S/2,F=L/2,z=A+1,N=H+1,V=0,Q=0,at=new T;for(let G=0;G<N;G++){let $=G*y-D;for(let lt=0;lt<z;lt++){let dt=lt*X-R;at[x]=dt*p,at[v]=$*b,at[m]=F,c.push(at.x,at.y,at.z),at[x]=0,at[v]=0,at[m]=L>0?1:-1,u.push(at.x,at.y,at.z),h.push(lt/A),h.push(1-G/H),V+=1}}for(let G=0;G<H;G++)for(let $=0;$<A;$++){let lt=f+$+z*G,dt=f+$+z*(G+1),xt=f+($+1)+z*(G+1),k=f+($+1)+z*G;l.push(lt,dt,k),l.push(dt,xt,k),Q+=6}a.addGroup(d,Q,tt),d+=Q,f+=V}}static fromJSON(t){return new Hi(t.width,t.height,t.depth,t.widthSegments,t.heightSegments,t.depthSegments)}};function Gr(n){let t={};for(let e in n){t[e]={};for(let i in n[e]){let r=n[e][i];r&&(r.isColor||r.isMatrix3||r.isMatrix4||r.isVector2||r.isVector3||r.isVector4||r.isTexture||r.isQuaternion)?t[e][i]=r.clone():Array.isArray(r)?t[e][i]=r.slice():t[e][i]=r}}return t}function Me(n){let t={};for(let e=0;e<n.length;e++){let i=Gr(n[e]);for(let r in i)t[r]=i[r]}return t}var pM={clone:Gr,merge:Me},mM=`void main() {
	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
}`,gM=`void main() {
	gl_FragColor = vec4( 1.0, 0.0, 0.0, 1.0 );
}`,Fn=class extends xe{constructor(t){super(),this.type="ShaderMaterial",this.defines={},this.uniforms={},this.vertexShader=mM,this.fragmentShader=gM,this.linewidth=1,this.wireframe=!1,this.wireframeLinewidth=1,this.fog=!1,this.lights=!1,this.clipping=!1,this.extensions={derivatives:!1,fragDepth:!1,drawBuffers:!1,shaderTextureLOD:!1},this.defaultAttributeValues={color:[1,1,1],uv:[0,0],uv2:[0,0]},this.index0AttributeName=void 0,this.uniformsNeedUpdate=!1,this.glslVersion=null,t!==void 0&&(t.attributes!==void 0&&console.error("THREE.ShaderMaterial: attributes should now be defined in THREE.BufferGeometry instead."),this.setValues(t))}copy(t){return super.copy(t),this.fragmentShader=t.fragmentShader,this.vertexShader=t.vertexShader,this.uniforms=Gr(t.uniforms),this.defines=Object.assign({},t.defines),this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.lights=t.lights,this.clipping=t.clipping,this.extensions=Object.assign({},t.extensions),this.glslVersion=t.glslVersion,this}toJSON(t){let e=super.toJSON(t);e.glslVersion=this.glslVersion,e.uniforms={};for(let r in this.uniforms){let o=this.uniforms[r].value;o&&o.isTexture?e.uniforms[r]={type:"t",value:o.toJSON(t).uuid}:o&&o.isColor?e.uniforms[r]={type:"c",value:o.getHex()}:o&&o.isVector2?e.uniforms[r]={type:"v2",value:o.toArray()}:o&&o.isVector3?e.uniforms[r]={type:"v3",value:o.toArray()}:o&&o.isVector4?e.uniforms[r]={type:"v4",value:o.toArray()}:o&&o.isMatrix3?e.uniforms[r]={type:"m3",value:o.toArray()}:o&&o.isMatrix4?e.uniforms[r]={type:"m4",value:o.toArray()}:e.uniforms[r]={value:o}}Object.keys(this.defines).length>0&&(e.defines=this.defines),e.vertexShader=this.vertexShader,e.fragmentShader=this.fragmentShader;let i={};for(let r in this.extensions)this.extensions[r]===!0&&(i[r]=!0);return Object.keys(i).length>0&&(e.extensions=i),e}};Fn.prototype.isShaderMaterial=!0;var oo=class extends kt{constructor(){super(),this.type="Camera",this.matrixWorldInverse=new wt,this.projectionMatrix=new wt,this.projectionMatrixInverse=new wt}copy(t,e){return super.copy(t,e),this.matrixWorldInverse.copy(t.matrixWorldInverse),this.projectionMatrix.copy(t.projectionMatrix),this.projectionMatrixInverse.copy(t.projectionMatrixInverse),this}getWorldDirection(t){this.updateWorldMatrix(!0,!1);let e=this.matrixWorld.elements;return t.set(-e[8],-e[9],-e[10]).normalize()}updateMatrixWorld(t){super.updateMatrixWorld(t),this.matrixWorldInverse.copy(this.matrixWorld).invert()}updateWorldMatrix(t,e){super.updateWorldMatrix(t,e),this.matrixWorldInverse.copy(this.matrixWorld).invert()}clone(){return new this.constructor().copy(this)}};oo.prototype.isCamera=!0;var Se=class extends oo{constructor(t=50,e=1,i=.1,r=2e3){super(),this.type="PerspectiveCamera",this.fov=t,this.zoom=1,this.near=i,this.far=r,this.focus=10,this.aspect=e,this.view=null,this.filmGauge=35,this.filmOffset=0,this.updateProjectionMatrix()}copy(t,e){return super.copy(t,e),this.fov=t.fov,this.zoom=t.zoom,this.near=t.near,this.far=t.far,this.focus=t.focus,this.aspect=t.aspect,this.view=t.view===null?null:Object.assign({},t.view),this.filmGauge=t.filmGauge,this.filmOffset=t.filmOffset,this}setFocalLength(t){let e=.5*this.getFilmHeight()/t;this.fov=Vu*2*Math.atan(e),this.updateProjectionMatrix()}getFocalLength(){let t=Math.tan(iu*.5*this.fov);return .5*this.getFilmHeight()/t}getEffectiveFOV(){return Vu*2*Math.atan(Math.tan(iu*.5*this.fov)/this.zoom)}getFilmWidth(){return this.filmGauge*Math.min(this.aspect,1)}getFilmHeight(){return this.filmGauge/Math.max(this.aspect,1)}setViewOffset(t,e,i,r,s,o){this.aspect=t/e,this.view===null&&(this.view={enabled:!0,fullWidth:1,fullHeight:1,offsetX:0,offsetY:0,width:1,height:1}),this.view.enabled=!0,this.view.fullWidth=t,this.view.fullHeight=e,this.view.offsetX=i,this.view.offsetY=r,this.view.width=s,this.view.height=o,this.updateProjectionMatrix()}clearViewOffset(){this.view!==null&&(this.view.enabled=!1),this.updateProjectionMatrix()}updateProjectionMatrix(){let t=this.near,e=t*Math.tan(iu*.5*this.fov)/this.zoom,i=2*e,r=this.aspect*i,s=-.5*r,o=this.view;if(this.view!==null&&this.view.enabled){let l=o.fullWidth,c=o.fullHeight;s+=o.offsetX*r/l,e-=o.offsetY*i/c,r*=o.width/l,i*=o.height/c}let a=this.filmOffset;a!==0&&(s+=t*a/this.getFilmWidth()),this.projectionMatrix.makePerspective(s,s+r,e,e-i,t,this.far),this.projectionMatrixInverse.copy(this.projectionMatrix).invert()}toJSON(t){let e=super.toJSON(t);return e.object.fov=this.fov,e.object.zoom=this.zoom,e.object.near=this.near,e.object.far=this.far,e.object.focus=this.focus,e.object.aspect=this.aspect,this.view!==null&&(e.object.view=Object.assign({},this.view)),e.object.filmGauge=this.filmGauge,e.object.filmOffset=this.filmOffset,e}};Se.prototype.isPerspectiveCamera=!0;var Sr=90,Er=1,ao=class extends kt{constructor(t,e,i){if(super(),this.type="CubeCamera",i.isWebGLCubeRenderTarget!==!0){console.error("THREE.CubeCamera: The constructor now expects an instance of WebGLCubeRenderTarget as third parameter.");return}this.renderTarget=i;let r=new Se(Sr,Er,t,e);r.layers=this.layers,r.up.set(0,-1,0),r.lookAt(new T(1,0,0)),this.add(r);let s=new Se(Sr,Er,t,e);s.layers=this.layers,s.up.set(0,-1,0),s.lookAt(new T(-1,0,0)),this.add(s);let o=new Se(Sr,Er,t,e);o.layers=this.layers,o.up.set(0,0,1),o.lookAt(new T(0,1,0)),this.add(o);let a=new Se(Sr,Er,t,e);a.layers=this.layers,a.up.set(0,0,-1),a.lookAt(new T(0,-1,0)),this.add(a);let l=new Se(Sr,Er,t,e);l.layers=this.layers,l.up.set(0,-1,0),l.lookAt(new T(0,0,1)),this.add(l);let c=new Se(Sr,Er,t,e);c.layers=this.layers,c.up.set(0,-1,0),c.lookAt(new T(0,0,-1)),this.add(c)}update(t,e){this.parent===null&&this.updateMatrixWorld();let i=this.renderTarget,[r,s,o,a,l,c]=this.children,u=t.xr.enabled,h=t.getRenderTarget();t.xr.enabled=!1;let f=i.texture.generateMipmaps;i.texture.generateMipmaps=!1,t.setRenderTarget(i,0),t.render(e,r),t.setRenderTarget(i,1),t.render(e,s),t.setRenderTarget(i,2),t.render(e,o),t.setRenderTarget(i,3),t.render(e,a),t.setRenderTarget(i,4),t.render(e,l),i.texture.generateMipmaps=f,t.setRenderTarget(i,5),t.render(e,c),t.setRenderTarget(h),t.xr.enabled=u,i.texture.needsPMREMUpdate=!0}},Wr=class extends ae{constructor(t,e,i,r,s,o,a,l,c,u){t=t!==void 0?t:[],e=e!==void 0?e:Ao,super(t,e,i,r,s,o,a,l,c,u),this.flipY=!1}get images(){return this.image}set images(t){this.image=t}};Wr.prototype.isCubeTexture=!0;var ol=class extends Ne{constructor(t,e,i){Number.isInteger(e)&&(console.warn("THREE.WebGLCubeRenderTarget: constructor signature is now WebGLCubeRenderTarget( size, options )"),e=i),super(t,t,e),e=e||{},this.texture=new Wr(void 0,e.mapping,e.wrapS,e.wrapT,e.magFilter,e.minFilter,e.format,e.type,e.anisotropy,e.encoding),this.texture.isRenderTargetTexture=!0,this.texture.generateMipmaps=e.generateMipmaps!==void 0?e.generateMipmaps:!1,this.texture.minFilter=e.minFilter!==void 0?e.minFilter:be}fromEquirectangularTexture(t,e){this.texture.type=e.type,this.texture.format=Re,this.texture.encoding=e.encoding,this.texture.generateMipmaps=e.generateMipmaps,this.texture.minFilter=e.minFilter,this.texture.magFilter=e.magFilter;let i={uniforms:{tEquirect:{value:null}},vertexShader:`

				varying vec3 vWorldDirection;

				vec3 transformDirection( in vec3 dir, in mat4 matrix ) {

					return normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );

				}

				void main() {

					vWorldDirection = transformDirection( position, modelMatrix );

					#include <begin_vertex>
					#include <project_vertex>

				}
			`,fragmentShader:`

				uniform sampler2D tEquirect;

				varying vec3 vWorldDirection;

				#include <common>

				void main() {

					vec3 direction = normalize( vWorldDirection );

					vec2 sampleUV = equirectUv( direction );

					gl_FragColor = texture2D( tEquirect, sampleUV );

				}
			`},r=new Hi(5,5,5),s=new Fn({name:"CubemapFromEquirect",uniforms:Gr(i.uniforms),vertexShader:i.vertexShader,fragmentShader:i.fragmentShader,side:he,blending:jn});s.uniforms.tEquirect.value=e;let o=new oe(r,s),a=e.minFilter;return e.minFilter===Ll&&(e.minFilter=be),new ao(1,10,this).update(t,o),e.minFilter=a,o.geometry.dispose(),o.material.dispose(),this}clear(t,e,i,r){let s=t.getRenderTarget();for(let o=0;o<6;o++)t.setRenderTarget(this,o),t.clear(e,i,r);t.setRenderTarget(s)}};ol.prototype.isWebGLCubeRenderTarget=!0;var Eu=new T,xM=new T,yM=new de,je=class{constructor(t=new T(1,0,0),e=0){this.normal=t,this.constant=e}set(t,e){return this.normal.copy(t),this.constant=e,this}setComponents(t,e,i,r){return this.normal.set(t,e,i),this.constant=r,this}setFromNormalAndCoplanarPoint(t,e){return this.normal.copy(t),this.constant=-e.dot(this.normal),this}setFromCoplanarPoints(t,e,i){let r=Eu.subVectors(i,e).cross(xM.subVectors(t,e)).normalize();return this.setFromNormalAndCoplanarPoint(r,t),this}copy(t){return this.normal.copy(t.normal),this.constant=t.constant,this}normalize(){let t=1/this.normal.length();return this.normal.multiplyScalar(t),this.constant*=t,this}negate(){return this.constant*=-1,this.normal.negate(),this}distanceToPoint(t){return this.normal.dot(t)+this.constant}distanceToSphere(t){return this.distanceToPoint(t.center)-t.radius}projectPoint(t,e){return e.copy(this.normal).multiplyScalar(-this.distanceToPoint(t)).add(t)}intersectLine(t,e){let i=t.delta(Eu),r=this.normal.dot(i);if(r===0)return this.distanceToPoint(t.start)===0?e.copy(t.start):null;let s=-(t.start.dot(this.normal)+this.constant)/r;return s<0||s>1?null:e.copy(i).multiplyScalar(s).add(t.start)}intersectsLine(t){let e=this.distanceToPoint(t.start),i=this.distanceToPoint(t.end);return e<0&&i>0||i<0&&e>0}intersectsBox(t){return t.intersectsPlane(this)}intersectsSphere(t){return t.intersectsPlane(this)}coplanarPoint(t){return t.copy(this.normal).multiplyScalar(-this.constant)}applyMatrix4(t,e){let i=e||yM.getNormalMatrix(t),r=this.coplanarPoint(Eu).applyMatrix4(t),s=this.normal.applyMatrix3(i).normalize();return this.constant=-r.dot(s),this}translate(t){return this.constant-=t.dot(this.normal),this}equals(t){return t.normal.equals(this.normal)&&t.constant===this.constant}clone(){return new this.constructor().copy(this)}};je.prototype.isPlane=!0;var Tr=new si,za=new T,qr=class{constructor(t=new je,e=new je,i=new je,r=new je,s=new je,o=new je){this.planes=[t,e,i,r,s,o]}set(t,e,i,r,s,o){let a=this.planes;return a[0].copy(t),a[1].copy(e),a[2].copy(i),a[3].copy(r),a[4].copy(s),a[5].copy(o),this}copy(t){let e=this.planes;for(let i=0;i<6;i++)e[i].copy(t.planes[i]);return this}setFromProjectionMatrix(t){let e=this.planes,i=t.elements,r=i[0],s=i[1],o=i[2],a=i[3],l=i[4],c=i[5],u=i[6],h=i[7],f=i[8],d=i[9],g=i[10],x=i[11],v=i[12],m=i[13],p=i[14],b=i[15];return e[0].setComponents(a-r,h-l,x-f,b-v).normalize(),e[1].setComponents(a+r,h+l,x+f,b+v).normalize(),e[2].setComponents(a+s,h+c,x+d,b+m).normalize(),e[3].setComponents(a-s,h-c,x-d,b-m).normalize(),e[4].setComponents(a-o,h-u,x-g,b-p).normalize(),e[5].setComponents(a+o,h+u,x+g,b+p).normalize(),this}intersectsObject(t){let e=t.geometry;return e.boundingSphere===null&&e.computeBoundingSphere(),Tr.copy(e.boundingSphere).applyMatrix4(t.matrixWorld),this.intersectsSphere(Tr)}intersectsSprite(t){return Tr.center.set(0,0,0),Tr.radius=.7071067811865476,Tr.applyMatrix4(t.matrixWorld),this.intersectsSphere(Tr)}intersectsSphere(t){let e=this.planes,i=t.center,r=-t.radius;for(let s=0;s<6;s++)if(e[s].distanceToPoint(i)<r)return!1;return!0}intersectsBox(t){let e=this.planes;for(let i=0;i<6;i++){let r=e[i];if(za.x=r.normal.x>0?t.max.x:t.min.x,za.y=r.normal.y>0?t.max.y:t.min.y,za.z=r.normal.z>0?t.max.z:t.min.z,r.distanceToPoint(za)<0)return!1}return!0}containsPoint(t){let e=this.planes;for(let i=0;i<6;i++)if(e[i].distanceToPoint(t)<0)return!1;return!0}clone(){return new this.constructor().copy(this)}};function g0(){let n=null,t=!1,e=null,i=null;function r(s,o){e(s,o),i=n.requestAnimationFrame(r)}return{start:function(){t!==!0&&e!==null&&(i=n.requestAnimationFrame(r),t=!0)},stop:function(){n.cancelAnimationFrame(i),t=!1},setAnimationLoop:function(s){e=s},setContext:function(s){n=s}}}function vM(n,t){let e=t.isWebGL2,i=new WeakMap;function r(c,u){let h=c.array,f=c.usage,d=n.createBuffer();n.bindBuffer(u,d),n.bufferData(u,h,f),c.onUploadCallback();let g=5126;return h instanceof Float32Array?g=5126:h instanceof Float64Array?console.warn("THREE.WebGLAttributes: Unsupported data buffer format: Float64Array."):h instanceof Uint16Array?c.isFloat16BufferAttribute?e?g=5131:console.warn("THREE.WebGLAttributes: Usage of Float16BufferAttribute requires WebGL2."):g=5123:h instanceof Int16Array?g=5122:h instanceof Uint32Array?g=5125:h instanceof Int32Array?g=5124:h instanceof Int8Array?g=5120:(h instanceof Uint8Array||h instanceof Uint8ClampedArray)&&(g=5121),{buffer:d,type:g,bytesPerElement:h.BYTES_PER_ELEMENT,version:c.version}}function s(c,u,h){let f=u.array,d=u.updateRange;n.bindBuffer(h,c),d.count===-1?n.bufferSubData(h,0,f):(e?n.bufferSubData(h,d.offset*f.BYTES_PER_ELEMENT,f,d.offset,d.count):n.bufferSubData(h,d.offset*f.BYTES_PER_ELEMENT,f.subarray(d.offset,d.offset+d.count)),d.count=-1)}function o(c){return c.isInterleavedBufferAttribute&&(c=c.data),i.get(c)}function a(c){c.isInterleavedBufferAttribute&&(c=c.data);let u=i.get(c);u&&(n.deleteBuffer(u.buffer),i.delete(c))}function l(c,u){if(c.isGLBufferAttribute){let f=i.get(c);(!f||f.version<c.version)&&i.set(c,{buffer:c.buffer,type:c.type,bytesPerElement:c.elementSize,version:c.version});return}c.isInterleavedBufferAttribute&&(c=c.data);let h=i.get(c);h===void 0?i.set(c,r(c,u)):h.version<c.version&&(s(h.buffer,c,u),h.version=c.version)}return{get:o,remove:a,update:l}}var lo=class extends Ht{constructor(t=1,e=1,i=1,r=1){super(),this.type="PlaneGeometry",this.parameters={width:t,height:e,widthSegments:i,heightSegments:r};let s=t/2,o=e/2,a=Math.floor(i),l=Math.floor(r),c=a+1,u=l+1,h=t/a,f=e/l,d=[],g=[],x=[],v=[];for(let m=0;m<u;m++){let p=m*f-o;for(let b=0;b<c;b++){let _=b*h-s;g.push(_,-p,0),x.push(0,0,1),v.push(b/a),v.push(1-m/l)}}for(let m=0;m<l;m++)for(let p=0;p<a;p++){let b=p+c*m,_=p+c*(m+1),S=p+1+c*(m+1),L=p+1+c*m;d.push(b,_,L),d.push(_,S,L)}this.setIndex(d),this.setAttribute("position",new ee(g,3)),this.setAttribute("normal",new ee(x,3)),this.setAttribute("uv",new ee(v,2))}static fromJSON(t){return new lo(t.width,t.height,t.widthSegments,t.heightSegments)}},_M=`#ifdef USE_ALPHAMAP
	diffuseColor.a *= texture2D( alphaMap, vUv ).g;
#endif`,wM=`#ifdef USE_ALPHAMAP
	uniform sampler2D alphaMap;
#endif`,MM=`#ifdef USE_ALPHATEST
	if ( diffuseColor.a < alphaTest ) discard;
#endif`,bM=`#ifdef USE_ALPHATEST
	uniform float alphaTest;
#endif`,SM=`#ifdef USE_AOMAP
	float ambientOcclusion = ( texture2D( aoMap, vUv2 ).r - 1.0 ) * aoMapIntensity + 1.0;
	reflectedLight.indirectDiffuse *= ambientOcclusion;
	#if defined( USE_ENVMAP ) && defined( STANDARD )
		float dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );
		reflectedLight.indirectSpecular *= computeSpecularOcclusion( dotNV, ambientOcclusion, material.roughness );
	#endif
#endif`,EM=`#ifdef USE_AOMAP
	uniform sampler2D aoMap;
	uniform float aoMapIntensity;
#endif`,TM="vec3 transformed = vec3( position );",AM=`vec3 objectNormal = vec3( normal );
#ifdef USE_TANGENT
	vec3 objectTangent = vec3( tangent.xyz );
#endif`,CM=`vec3 BRDF_Lambert( const in vec3 diffuseColor ) {
	return RECIPROCAL_PI * diffuseColor;
}
vec3 F_Schlick( const in vec3 f0, const in float f90, const in float dotVH ) {
	float fresnel = exp2( ( - 5.55473 * dotVH - 6.98316 ) * dotVH );
	return f0 * ( 1.0 - fresnel ) + ( f90 * fresnel );
}
float V_GGX_SmithCorrelated( const in float alpha, const in float dotNL, const in float dotNV ) {
	float a2 = pow2( alpha );
	float gv = dotNL * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );
	float gl = dotNV * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );
	return 0.5 / max( gv + gl, EPSILON );
}
float D_GGX( const in float alpha, const in float dotNH ) {
	float a2 = pow2( alpha );
	float denom = pow2( dotNH ) * ( a2 - 1.0 ) + 1.0;
	return RECIPROCAL_PI * a2 / pow2( denom );
}
vec3 BRDF_GGX( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in vec3 f0, const in float f90, const in float roughness ) {
	float alpha = pow2( roughness );
	vec3 halfDir = normalize( lightDir + viewDir );
	float dotNL = saturate( dot( normal, lightDir ) );
	float dotNV = saturate( dot( normal, viewDir ) );
	float dotNH = saturate( dot( normal, halfDir ) );
	float dotVH = saturate( dot( viewDir, halfDir ) );
	vec3 F = F_Schlick( f0, f90, dotVH );
	float V = V_GGX_SmithCorrelated( alpha, dotNL, dotNV );
	float D = D_GGX( alpha, dotNH );
	return F * ( V * D );
}
vec2 LTC_Uv( const in vec3 N, const in vec3 V, const in float roughness ) {
	const float LUT_SIZE = 64.0;
	const float LUT_SCALE = ( LUT_SIZE - 1.0 ) / LUT_SIZE;
	const float LUT_BIAS = 0.5 / LUT_SIZE;
	float dotNV = saturate( dot( N, V ) );
	vec2 uv = vec2( roughness, sqrt( 1.0 - dotNV ) );
	uv = uv * LUT_SCALE + LUT_BIAS;
	return uv;
}
float LTC_ClippedSphereFormFactor( const in vec3 f ) {
	float l = length( f );
	return max( ( l * l + f.z ) / ( l + 1.0 ), 0.0 );
}
vec3 LTC_EdgeVectorFormFactor( const in vec3 v1, const in vec3 v2 ) {
	float x = dot( v1, v2 );
	float y = abs( x );
	float a = 0.8543985 + ( 0.4965155 + 0.0145206 * y ) * y;
	float b = 3.4175940 + ( 4.1616724 + y ) * y;
	float v = a / b;
	float theta_sintheta = ( x > 0.0 ) ? v : 0.5 * inversesqrt( max( 1.0 - x * x, 1e-7 ) ) - v;
	return cross( v1, v2 ) * theta_sintheta;
}
vec3 LTC_Evaluate( const in vec3 N, const in vec3 V, const in vec3 P, const in mat3 mInv, const in vec3 rectCoords[ 4 ] ) {
	vec3 v1 = rectCoords[ 1 ] - rectCoords[ 0 ];
	vec3 v2 = rectCoords[ 3 ] - rectCoords[ 0 ];
	vec3 lightNormal = cross( v1, v2 );
	if( dot( lightNormal, P - rectCoords[ 0 ] ) < 0.0 ) return vec3( 0.0 );
	vec3 T1, T2;
	T1 = normalize( V - N * dot( V, N ) );
	T2 = - cross( N, T1 );
	mat3 mat = mInv * transposeMat3( mat3( T1, T2, N ) );
	vec3 coords[ 4 ];
	coords[ 0 ] = mat * ( rectCoords[ 0 ] - P );
	coords[ 1 ] = mat * ( rectCoords[ 1 ] - P );
	coords[ 2 ] = mat * ( rectCoords[ 2 ] - P );
	coords[ 3 ] = mat * ( rectCoords[ 3 ] - P );
	coords[ 0 ] = normalize( coords[ 0 ] );
	coords[ 1 ] = normalize( coords[ 1 ] );
	coords[ 2 ] = normalize( coords[ 2 ] );
	coords[ 3 ] = normalize( coords[ 3 ] );
	vec3 vectorFormFactor = vec3( 0.0 );
	vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 0 ], coords[ 1 ] );
	vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 1 ], coords[ 2 ] );
	vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 2 ], coords[ 3 ] );
	vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 3 ], coords[ 0 ] );
	float result = LTC_ClippedSphereFormFactor( vectorFormFactor );
	return vec3( result );
}
float G_BlinnPhong_Implicit( ) {
	return 0.25;
}
float D_BlinnPhong( const in float shininess, const in float dotNH ) {
	return RECIPROCAL_PI * ( shininess * 0.5 + 1.0 ) * pow( dotNH, shininess );
}
vec3 BRDF_BlinnPhong( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in vec3 specularColor, const in float shininess ) {
	vec3 halfDir = normalize( lightDir + viewDir );
	float dotNH = saturate( dot( normal, halfDir ) );
	float dotVH = saturate( dot( viewDir, halfDir ) );
	vec3 F = F_Schlick( specularColor, 1.0, dotVH );
	float G = G_BlinnPhong_Implicit( );
	float D = D_BlinnPhong( shininess, dotNH );
	return F * ( G * D );
}
#if defined( USE_SHEEN )
float D_Charlie( float roughness, float dotNH ) {
	float alpha = pow2( roughness );
	float invAlpha = 1.0 / alpha;
	float cos2h = dotNH * dotNH;
	float sin2h = max( 1.0 - cos2h, 0.0078125 );
	return ( 2.0 + invAlpha ) * pow( sin2h, invAlpha * 0.5 ) / ( 2.0 * PI );
}
float V_Neubelt( float dotNV, float dotNL ) {
	return saturate( 1.0 / ( 4.0 * ( dotNL + dotNV - dotNL * dotNV ) ) );
}
vec3 BRDF_Sheen( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, vec3 sheenColor, const in float sheenRoughness ) {
	vec3 halfDir = normalize( lightDir + viewDir );
	float dotNL = saturate( dot( normal, lightDir ) );
	float dotNV = saturate( dot( normal, viewDir ) );
	float dotNH = saturate( dot( normal, halfDir ) );
	float D = D_Charlie( sheenRoughness, dotNH );
	float V = V_Neubelt( dotNV, dotNL );
	return sheenColor * ( D * V );
}
#endif`,RM=`#ifdef USE_BUMPMAP
	uniform sampler2D bumpMap;
	uniform float bumpScale;
	vec2 dHdxy_fwd() {
		vec2 dSTdx = dFdx( vUv );
		vec2 dSTdy = dFdy( vUv );
		float Hll = bumpScale * texture2D( bumpMap, vUv ).x;
		float dBx = bumpScale * texture2D( bumpMap, vUv + dSTdx ).x - Hll;
		float dBy = bumpScale * texture2D( bumpMap, vUv + dSTdy ).x - Hll;
		return vec2( dBx, dBy );
	}
	vec3 perturbNormalArb( vec3 surf_pos, vec3 surf_norm, vec2 dHdxy, float faceDirection ) {
		vec3 vSigmaX = vec3( dFdx( surf_pos.x ), dFdx( surf_pos.y ), dFdx( surf_pos.z ) );
		vec3 vSigmaY = vec3( dFdy( surf_pos.x ), dFdy( surf_pos.y ), dFdy( surf_pos.z ) );
		vec3 vN = surf_norm;
		vec3 R1 = cross( vSigmaY, vN );
		vec3 R2 = cross( vN, vSigmaX );
		float fDet = dot( vSigmaX, R1 ) * faceDirection;
		vec3 vGrad = sign( fDet ) * ( dHdxy.x * R1 + dHdxy.y * R2 );
		return normalize( abs( fDet ) * surf_norm - vGrad );
	}
#endif`,LM=`#if NUM_CLIPPING_PLANES > 0
	vec4 plane;
	#pragma unroll_loop_start
	for ( int i = 0; i < UNION_CLIPPING_PLANES; i ++ ) {
		plane = clippingPlanes[ i ];
		if ( dot( vClipPosition, plane.xyz ) > plane.w ) discard;
	}
	#pragma unroll_loop_end
	#if UNION_CLIPPING_PLANES < NUM_CLIPPING_PLANES
		bool clipped = true;
		#pragma unroll_loop_start
		for ( int i = UNION_CLIPPING_PLANES; i < NUM_CLIPPING_PLANES; i ++ ) {
			plane = clippingPlanes[ i ];
			clipped = ( dot( vClipPosition, plane.xyz ) > plane.w ) && clipped;
		}
		#pragma unroll_loop_end
		if ( clipped ) discard;
	#endif
#endif`,PM=`#if NUM_CLIPPING_PLANES > 0
	varying vec3 vClipPosition;
	uniform vec4 clippingPlanes[ NUM_CLIPPING_PLANES ];
#endif`,DM=`#if NUM_CLIPPING_PLANES > 0
	varying vec3 vClipPosition;
#endif`,IM=`#if NUM_CLIPPING_PLANES > 0
	vClipPosition = - mvPosition.xyz;
#endif`,NM=`#if defined( USE_COLOR_ALPHA )
	diffuseColor *= vColor;
#elif defined( USE_COLOR )
	diffuseColor.rgb *= vColor;
#endif`,FM=`#if defined( USE_COLOR_ALPHA )
	varying vec4 vColor;
#elif defined( USE_COLOR )
	varying vec3 vColor;
#endif`,zM=`#if defined( USE_COLOR_ALPHA )
	varying vec4 vColor;
#elif defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR )
	varying vec3 vColor;
#endif`,UM=`#if defined( USE_COLOR_ALPHA )
	vColor = vec4( 1.0 );
#elif defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR )
	vColor = vec3( 1.0 );
#endif
#ifdef USE_COLOR
	vColor *= color;
#endif
#ifdef USE_INSTANCING_COLOR
	vColor.xyz *= instanceColor.xyz;
#endif`,BM=`#define PI 3.141592653589793
#define PI2 6.283185307179586
#define PI_HALF 1.5707963267948966
#define RECIPROCAL_PI 0.3183098861837907
#define RECIPROCAL_PI2 0.15915494309189535
#define EPSILON 1e-6
#ifndef saturate
#define saturate( a ) clamp( a, 0.0, 1.0 )
#endif
#define whiteComplement( a ) ( 1.0 - saturate( a ) )
float pow2( const in float x ) { return x*x; }
float pow3( const in float x ) { return x*x*x; }
float pow4( const in float x ) { float x2 = x*x; return x2*x2; }
float max3( const in vec3 v ) { return max( max( v.x, v.y ), v.z ); }
float average( const in vec3 color ) { return dot( color, vec3( 0.3333 ) ); }
highp float rand( const in vec2 uv ) {
	const highp float a = 12.9898, b = 78.233, c = 43758.5453;
	highp float dt = dot( uv.xy, vec2( a,b ) ), sn = mod( dt, PI );
	return fract( sin( sn ) * c );
}
#ifdef HIGH_PRECISION
	float precisionSafeLength( vec3 v ) { return length( v ); }
#else
	float precisionSafeLength( vec3 v ) {
		float maxComponent = max3( abs( v ) );
		return length( v / maxComponent ) * maxComponent;
	}
#endif
struct IncidentLight {
	vec3 color;
	vec3 direction;
	bool visible;
};
struct ReflectedLight {
	vec3 directDiffuse;
	vec3 directSpecular;
	vec3 indirectDiffuse;
	vec3 indirectSpecular;
};
struct GeometricContext {
	vec3 position;
	vec3 normal;
	vec3 viewDir;
#ifdef USE_CLEARCOAT
	vec3 clearcoatNormal;
#endif
};
vec3 transformDirection( in vec3 dir, in mat4 matrix ) {
	return normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );
}
vec3 inverseTransformDirection( in vec3 dir, in mat4 matrix ) {
	return normalize( ( vec4( dir, 0.0 ) * matrix ).xyz );
}
mat3 transposeMat3( const in mat3 m ) {
	mat3 tmp;
	tmp[ 0 ] = vec3( m[ 0 ].x, m[ 1 ].x, m[ 2 ].x );
	tmp[ 1 ] = vec3( m[ 0 ].y, m[ 1 ].y, m[ 2 ].y );
	tmp[ 2 ] = vec3( m[ 0 ].z, m[ 1 ].z, m[ 2 ].z );
	return tmp;
}
float linearToRelativeLuminance( const in vec3 color ) {
	vec3 weights = vec3( 0.2126, 0.7152, 0.0722 );
	return dot( weights, color.rgb );
}
bool isPerspectiveMatrix( mat4 m ) {
	return m[ 2 ][ 3 ] == - 1.0;
}
vec2 equirectUv( in vec3 dir ) {
	float u = atan( dir.z, dir.x ) * RECIPROCAL_PI2 + 0.5;
	float v = asin( clamp( dir.y, - 1.0, 1.0 ) ) * RECIPROCAL_PI + 0.5;
	return vec2( u, v );
}`,OM=`#ifdef ENVMAP_TYPE_CUBE_UV
	#define cubeUV_maxMipLevel 8.0
	#define cubeUV_minMipLevel 4.0
	#define cubeUV_maxTileSize 256.0
	#define cubeUV_minTileSize 16.0
	float getFace( vec3 direction ) {
		vec3 absDirection = abs( direction );
		float face = - 1.0;
		if ( absDirection.x > absDirection.z ) {
			if ( absDirection.x > absDirection.y )
				face = direction.x > 0.0 ? 0.0 : 3.0;
			else
				face = direction.y > 0.0 ? 1.0 : 4.0;
		} else {
			if ( absDirection.z > absDirection.y )
				face = direction.z > 0.0 ? 2.0 : 5.0;
			else
				face = direction.y > 0.0 ? 1.0 : 4.0;
		}
		return face;
	}
	vec2 getUV( vec3 direction, float face ) {
		vec2 uv;
		if ( face == 0.0 ) {
			uv = vec2( direction.z, direction.y ) / abs( direction.x );
		} else if ( face == 1.0 ) {
			uv = vec2( - direction.x, - direction.z ) / abs( direction.y );
		} else if ( face == 2.0 ) {
			uv = vec2( - direction.x, direction.y ) / abs( direction.z );
		} else if ( face == 3.0 ) {
			uv = vec2( - direction.z, direction.y ) / abs( direction.x );
		} else if ( face == 4.0 ) {
			uv = vec2( - direction.x, direction.z ) / abs( direction.y );
		} else {
			uv = vec2( direction.x, direction.y ) / abs( direction.z );
		}
		return 0.5 * ( uv + 1.0 );
	}
	vec3 bilinearCubeUV( sampler2D envMap, vec3 direction, float mipInt ) {
		float face = getFace( direction );
		float filterInt = max( cubeUV_minMipLevel - mipInt, 0.0 );
		mipInt = max( mipInt, cubeUV_minMipLevel );
		float faceSize = exp2( mipInt );
		float texelSize = 1.0 / ( 3.0 * cubeUV_maxTileSize );
		vec2 uv = getUV( direction, face ) * ( faceSize - 1.0 ) + 0.5;
		if ( face > 2.0 ) {
			uv.y += faceSize;
			face -= 3.0;
		}
		uv.x += face * faceSize;
		if ( mipInt < cubeUV_maxMipLevel ) {
			uv.y += 2.0 * cubeUV_maxTileSize;
		}
		uv.y += filterInt * 2.0 * cubeUV_minTileSize;
		uv.x += 3.0 * max( 0.0, cubeUV_maxTileSize - 2.0 * faceSize );
		uv *= texelSize;
		return texture2D( envMap, uv ).rgb;
	}
	#define r0 1.0
	#define v0 0.339
	#define m0 - 2.0
	#define r1 0.8
	#define v1 0.276
	#define m1 - 1.0
	#define r4 0.4
	#define v4 0.046
	#define m4 2.0
	#define r5 0.305
	#define v5 0.016
	#define m5 3.0
	#define r6 0.21
	#define v6 0.0038
	#define m6 4.0
	float roughnessToMip( float roughness ) {
		float mip = 0.0;
		if ( roughness >= r1 ) {
			mip = ( r0 - roughness ) * ( m1 - m0 ) / ( r0 - r1 ) + m0;
		} else if ( roughness >= r4 ) {
			mip = ( r1 - roughness ) * ( m4 - m1 ) / ( r1 - r4 ) + m1;
		} else if ( roughness >= r5 ) {
			mip = ( r4 - roughness ) * ( m5 - m4 ) / ( r4 - r5 ) + m4;
		} else if ( roughness >= r6 ) {
			mip = ( r5 - roughness ) * ( m6 - m5 ) / ( r5 - r6 ) + m5;
		} else {
			mip = - 2.0 * log2( 1.16 * roughness );		}
		return mip;
	}
	vec4 textureCubeUV( sampler2D envMap, vec3 sampleDir, float roughness ) {
		float mip = clamp( roughnessToMip( roughness ), m0, cubeUV_maxMipLevel );
		float mipF = fract( mip );
		float mipInt = floor( mip );
		vec3 color0 = bilinearCubeUV( envMap, sampleDir, mipInt );
		if ( mipF == 0.0 ) {
			return vec4( color0, 1.0 );
		} else {
			vec3 color1 = bilinearCubeUV( envMap, sampleDir, mipInt + 1.0 );
			return vec4( mix( color0, color1, mipF ), 1.0 );
		}
	}
#endif`,kM=`vec3 transformedNormal = objectNormal;
#ifdef USE_INSTANCING
	mat3 m = mat3( instanceMatrix );
	transformedNormal /= vec3( dot( m[ 0 ], m[ 0 ] ), dot( m[ 1 ], m[ 1 ] ), dot( m[ 2 ], m[ 2 ] ) );
	transformedNormal = m * transformedNormal;
#endif
transformedNormal = normalMatrix * transformedNormal;
#ifdef FLIP_SIDED
	transformedNormal = - transformedNormal;
#endif
#ifdef USE_TANGENT
	vec3 transformedTangent = ( modelViewMatrix * vec4( objectTangent, 0.0 ) ).xyz;
	#ifdef FLIP_SIDED
		transformedTangent = - transformedTangent;
	#endif
#endif`,HM=`#ifdef USE_DISPLACEMENTMAP
	uniform sampler2D displacementMap;
	uniform float displacementScale;
	uniform float displacementBias;
#endif`,VM=`#ifdef USE_DISPLACEMENTMAP
	transformed += normalize( objectNormal ) * ( texture2D( displacementMap, vUv ).x * displacementScale + displacementBias );
#endif`,GM=`#ifdef USE_EMISSIVEMAP
	vec4 emissiveColor = texture2D( emissiveMap, vUv );
	totalEmissiveRadiance *= emissiveColor.rgb;
#endif`,WM=`#ifdef USE_EMISSIVEMAP
	uniform sampler2D emissiveMap;
#endif`,qM="gl_FragColor = linearToOutputTexel( gl_FragColor );",XM=`vec4 LinearToLinear( in vec4 value ) {
	return value;
}
vec4 LinearTosRGB( in vec4 value ) {
	return vec4( mix( pow( value.rgb, vec3( 0.41666 ) ) * 1.055 - vec3( 0.055 ), value.rgb * 12.92, vec3( lessThanEqual( value.rgb, vec3( 0.0031308 ) ) ) ), value.a );
}`,YM=`#ifdef USE_ENVMAP
	#ifdef ENV_WORLDPOS
		vec3 cameraToFrag;
		if ( isOrthographic ) {
			cameraToFrag = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );
		} else {
			cameraToFrag = normalize( vWorldPosition - cameraPosition );
		}
		vec3 worldNormal = inverseTransformDirection( normal, viewMatrix );
		#ifdef ENVMAP_MODE_REFLECTION
			vec3 reflectVec = reflect( cameraToFrag, worldNormal );
		#else
			vec3 reflectVec = refract( cameraToFrag, worldNormal, refractionRatio );
		#endif
	#else
		vec3 reflectVec = vReflect;
	#endif
	#ifdef ENVMAP_TYPE_CUBE
		vec4 envColor = textureCube( envMap, vec3( flipEnvMap * reflectVec.x, reflectVec.yz ) );
	#elif defined( ENVMAP_TYPE_CUBE_UV )
		vec4 envColor = textureCubeUV( envMap, reflectVec, 0.0 );
	#else
		vec4 envColor = vec4( 0.0 );
	#endif
	#ifdef ENVMAP_BLENDING_MULTIPLY
		outgoingLight = mix( outgoingLight, outgoingLight * envColor.xyz, specularStrength * reflectivity );
	#elif defined( ENVMAP_BLENDING_MIX )
		outgoingLight = mix( outgoingLight, envColor.xyz, specularStrength * reflectivity );
	#elif defined( ENVMAP_BLENDING_ADD )
		outgoingLight += envColor.xyz * specularStrength * reflectivity;
	#endif
#endif`,ZM=`#ifdef USE_ENVMAP
	uniform float envMapIntensity;
	uniform float flipEnvMap;
	#ifdef ENVMAP_TYPE_CUBE
		uniform samplerCube envMap;
	#else
		uniform sampler2D envMap;
	#endif
	
#endif`,JM=`#ifdef USE_ENVMAP
	uniform float reflectivity;
	#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG )
		#define ENV_WORLDPOS
	#endif
	#ifdef ENV_WORLDPOS
		varying vec3 vWorldPosition;
		uniform float refractionRatio;
	#else
		varying vec3 vReflect;
	#endif
#endif`,$M=`#ifdef USE_ENVMAP
	#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) ||defined( PHONG )
		#define ENV_WORLDPOS
	#endif
	#ifdef ENV_WORLDPOS
		
		varying vec3 vWorldPosition;
	#else
		varying vec3 vReflect;
		uniform float refractionRatio;
	#endif
#endif`,KM=`#ifdef USE_ENVMAP
	#ifdef ENV_WORLDPOS
		vWorldPosition = worldPosition.xyz;
	#else
		vec3 cameraToVertex;
		if ( isOrthographic ) {
			cameraToVertex = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );
		} else {
			cameraToVertex = normalize( worldPosition.xyz - cameraPosition );
		}
		vec3 worldNormal = inverseTransformDirection( transformedNormal, viewMatrix );
		#ifdef ENVMAP_MODE_REFLECTION
			vReflect = reflect( cameraToVertex, worldNormal );
		#else
			vReflect = refract( cameraToVertex, worldNormal, refractionRatio );
		#endif
	#endif
#endif`,QM=`#ifdef USE_FOG
	vFogDepth = - mvPosition.z;
#endif`,jM=`#ifdef USE_FOG
	varying float vFogDepth;
#endif`,tb=`#ifdef USE_FOG
	#ifdef FOG_EXP2
		float fogFactor = 1.0 - exp( - fogDensity * fogDensity * vFogDepth * vFogDepth );
	#else
		float fogFactor = smoothstep( fogNear, fogFar, vFogDepth );
	#endif
	gl_FragColor.rgb = mix( gl_FragColor.rgb, fogColor, fogFactor );
#endif`,eb=`#ifdef USE_FOG
	uniform vec3 fogColor;
	varying float vFogDepth;
	#ifdef FOG_EXP2
		uniform float fogDensity;
	#else
		uniform float fogNear;
		uniform float fogFar;
	#endif
#endif`,nb=`#ifdef USE_GRADIENTMAP
	uniform sampler2D gradientMap;
#endif
vec3 getGradientIrradiance( vec3 normal, vec3 lightDirection ) {
	float dotNL = dot( normal, lightDirection );
	vec2 coord = vec2( dotNL * 0.5 + 0.5, 0.0 );
	#ifdef USE_GRADIENTMAP
		return vec3( texture2D( gradientMap, coord ).r );
	#else
		return ( coord.x < 0.7 ) ? vec3( 0.7 ) : vec3( 1.0 );
	#endif
}`,ib=`#ifdef USE_LIGHTMAP
	vec4 lightMapTexel = texture2D( lightMap, vUv2 );
	vec3 lightMapIrradiance = lightMapTexel.rgb * lightMapIntensity;
	#ifndef PHYSICALLY_CORRECT_LIGHTS
		lightMapIrradiance *= PI;
	#endif
	reflectedLight.indirectDiffuse += lightMapIrradiance;
#endif`,rb=`#ifdef USE_LIGHTMAP
	uniform sampler2D lightMap;
	uniform float lightMapIntensity;
#endif`,sb=`vec3 diffuse = vec3( 1.0 );
GeometricContext geometry;
geometry.position = mvPosition.xyz;
geometry.normal = normalize( transformedNormal );
geometry.viewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( -mvPosition.xyz );
GeometricContext backGeometry;
backGeometry.position = geometry.position;
backGeometry.normal = -geometry.normal;
backGeometry.viewDir = geometry.viewDir;
vLightFront = vec3( 0.0 );
vIndirectFront = vec3( 0.0 );
#ifdef DOUBLE_SIDED
	vLightBack = vec3( 0.0 );
	vIndirectBack = vec3( 0.0 );
#endif
IncidentLight directLight;
float dotNL;
vec3 directLightColor_Diffuse;
vIndirectFront += getAmbientLightIrradiance( ambientLightColor );
vIndirectFront += getLightProbeIrradiance( lightProbe, geometry.normal );
#ifdef DOUBLE_SIDED
	vIndirectBack += getAmbientLightIrradiance( ambientLightColor );
	vIndirectBack += getLightProbeIrradiance( lightProbe, backGeometry.normal );
#endif
#if NUM_POINT_LIGHTS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {
		getPointLightInfo( pointLights[ i ], geometry, directLight );
		dotNL = dot( geometry.normal, directLight.direction );
		directLightColor_Diffuse = directLight.color;
		vLightFront += saturate( dotNL ) * directLightColor_Diffuse;
		#ifdef DOUBLE_SIDED
			vLightBack += saturate( - dotNL ) * directLightColor_Diffuse;
		#endif
	}
	#pragma unroll_loop_end
#endif
#if NUM_SPOT_LIGHTS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {
		getSpotLightInfo( spotLights[ i ], geometry, directLight );
		dotNL = dot( geometry.normal, directLight.direction );
		directLightColor_Diffuse = directLight.color;
		vLightFront += saturate( dotNL ) * directLightColor_Diffuse;
		#ifdef DOUBLE_SIDED
			vLightBack += saturate( - dotNL ) * directLightColor_Diffuse;
		#endif
	}
	#pragma unroll_loop_end
#endif
#if NUM_DIR_LIGHTS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {
		getDirectionalLightInfo( directionalLights[ i ], geometry, directLight );
		dotNL = dot( geometry.normal, directLight.direction );
		directLightColor_Diffuse = directLight.color;
		vLightFront += saturate( dotNL ) * directLightColor_Diffuse;
		#ifdef DOUBLE_SIDED
			vLightBack += saturate( - dotNL ) * directLightColor_Diffuse;
		#endif
	}
	#pragma unroll_loop_end
#endif
#if NUM_HEMI_LIGHTS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {
		vIndirectFront += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry.normal );
		#ifdef DOUBLE_SIDED
			vIndirectBack += getHemisphereLightIrradiance( hemisphereLights[ i ], backGeometry.normal );
		#endif
	}
	#pragma unroll_loop_end
#endif`,ob=`uniform bool receiveShadow;
uniform vec3 ambientLightColor;
uniform vec3 lightProbe[ 9 ];
vec3 shGetIrradianceAt( in vec3 normal, in vec3 shCoefficients[ 9 ] ) {
	float x = normal.x, y = normal.y, z = normal.z;
	vec3 result = shCoefficients[ 0 ] * 0.886227;
	result += shCoefficients[ 1 ] * 2.0 * 0.511664 * y;
	result += shCoefficients[ 2 ] * 2.0 * 0.511664 * z;
	result += shCoefficients[ 3 ] * 2.0 * 0.511664 * x;
	result += shCoefficients[ 4 ] * 2.0 * 0.429043 * x * y;
	result += shCoefficients[ 5 ] * 2.0 * 0.429043 * y * z;
	result += shCoefficients[ 6 ] * ( 0.743125 * z * z - 0.247708 );
	result += shCoefficients[ 7 ] * 2.0 * 0.429043 * x * z;
	result += shCoefficients[ 8 ] * 0.429043 * ( x * x - y * y );
	return result;
}
vec3 getLightProbeIrradiance( const in vec3 lightProbe[ 9 ], const in vec3 normal ) {
	vec3 worldNormal = inverseTransformDirection( normal, viewMatrix );
	vec3 irradiance = shGetIrradianceAt( worldNormal, lightProbe );
	return irradiance;
}
vec3 getAmbientLightIrradiance( const in vec3 ambientLightColor ) {
	vec3 irradiance = ambientLightColor;
	return irradiance;
}
float getDistanceAttenuation( const in float lightDistance, const in float cutoffDistance, const in float decayExponent ) {
	#if defined ( PHYSICALLY_CORRECT_LIGHTS )
		float distanceFalloff = 1.0 / max( pow( lightDistance, decayExponent ), 0.01 );
		if ( cutoffDistance > 0.0 ) {
			distanceFalloff *= pow2( saturate( 1.0 - pow4( lightDistance / cutoffDistance ) ) );
		}
		return distanceFalloff;
	#else
		if ( cutoffDistance > 0.0 && decayExponent > 0.0 ) {
			return pow( saturate( - lightDistance / cutoffDistance + 1.0 ), decayExponent );
		}
		return 1.0;
	#endif
}
float getSpotAttenuation( const in float coneCosine, const in float penumbraCosine, const in float angleCosine ) {
	return smoothstep( coneCosine, penumbraCosine, angleCosine );
}
#if NUM_DIR_LIGHTS > 0
	struct DirectionalLight {
		vec3 direction;
		vec3 color;
	};
	uniform DirectionalLight directionalLights[ NUM_DIR_LIGHTS ];
	void getDirectionalLightInfo( const in DirectionalLight directionalLight, const in GeometricContext geometry, out IncidentLight light ) {
		light.color = directionalLight.color;
		light.direction = directionalLight.direction;
		light.visible = true;
	}
#endif
#if NUM_POINT_LIGHTS > 0
	struct PointLight {
		vec3 position;
		vec3 color;
		float distance;
		float decay;
	};
	uniform PointLight pointLights[ NUM_POINT_LIGHTS ];
	void getPointLightInfo( const in PointLight pointLight, const in GeometricContext geometry, out IncidentLight light ) {
		vec3 lVector = pointLight.position - geometry.position;
		light.direction = normalize( lVector );
		float lightDistance = length( lVector );
		light.color = pointLight.color;
		light.color *= getDistanceAttenuation( lightDistance, pointLight.distance, pointLight.decay );
		light.visible = ( light.color != vec3( 0.0 ) );
	}
#endif
#if NUM_SPOT_LIGHTS > 0
	struct SpotLight {
		vec3 position;
		vec3 direction;
		vec3 color;
		float distance;
		float decay;
		float coneCos;
		float penumbraCos;
	};
	uniform SpotLight spotLights[ NUM_SPOT_LIGHTS ];
	void getSpotLightInfo( const in SpotLight spotLight, const in GeometricContext geometry, out IncidentLight light ) {
		vec3 lVector = spotLight.position - geometry.position;
		light.direction = normalize( lVector );
		float angleCos = dot( light.direction, spotLight.direction );
		float spotAttenuation = getSpotAttenuation( spotLight.coneCos, spotLight.penumbraCos, angleCos );
		if ( spotAttenuation > 0.0 ) {
			float lightDistance = length( lVector );
			light.color = spotLight.color * spotAttenuation;
			light.color *= getDistanceAttenuation( lightDistance, spotLight.distance, spotLight.decay );
			light.visible = ( light.color != vec3( 0.0 ) );
		} else {
			light.color = vec3( 0.0 );
			light.visible = false;
		}
	}
#endif
#if NUM_RECT_AREA_LIGHTS > 0
	struct RectAreaLight {
		vec3 color;
		vec3 position;
		vec3 halfWidth;
		vec3 halfHeight;
	};
	uniform sampler2D ltc_1;	uniform sampler2D ltc_2;
	uniform RectAreaLight rectAreaLights[ NUM_RECT_AREA_LIGHTS ];
#endif
#if NUM_HEMI_LIGHTS > 0
	struct HemisphereLight {
		vec3 direction;
		vec3 skyColor;
		vec3 groundColor;
	};
	uniform HemisphereLight hemisphereLights[ NUM_HEMI_LIGHTS ];
	vec3 getHemisphereLightIrradiance( const in HemisphereLight hemiLight, const in vec3 normal ) {
		float dotNL = dot( normal, hemiLight.direction );
		float hemiDiffuseWeight = 0.5 * dotNL + 0.5;
		vec3 irradiance = mix( hemiLight.groundColor, hemiLight.skyColor, hemiDiffuseWeight );
		return irradiance;
	}
#endif`,ab=`#if defined( USE_ENVMAP )
	#ifdef ENVMAP_MODE_REFRACTION
		uniform float refractionRatio;
	#endif
	vec3 getIBLIrradiance( const in vec3 normal ) {
		#if defined( ENVMAP_TYPE_CUBE_UV )
			vec3 worldNormal = inverseTransformDirection( normal, viewMatrix );
			vec4 envMapColor = textureCubeUV( envMap, worldNormal, 1.0 );
			return PI * envMapColor.rgb * envMapIntensity;
		#else
			return vec3( 0.0 );
		#endif
	}
	vec3 getIBLRadiance( const in vec3 viewDir, const in vec3 normal, const in float roughness ) {
		#if defined( ENVMAP_TYPE_CUBE_UV )
			vec3 reflectVec;
			#ifdef ENVMAP_MODE_REFLECTION
				reflectVec = reflect( - viewDir, normal );
				reflectVec = normalize( mix( reflectVec, normal, roughness * roughness) );
			#else
				reflectVec = refract( - viewDir, normal, refractionRatio );
			#endif
			reflectVec = inverseTransformDirection( reflectVec, viewMatrix );
			vec4 envMapColor = textureCubeUV( envMap, reflectVec, roughness );
			return envMapColor.rgb * envMapIntensity;
		#else
			return vec3( 0.0 );
		#endif
	}
#endif`,lb=`ToonMaterial material;
material.diffuseColor = diffuseColor.rgb;`,cb=`varying vec3 vViewPosition;
struct ToonMaterial {
	vec3 diffuseColor;
};
void RE_Direct_Toon( const in IncidentLight directLight, const in GeometricContext geometry, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {
	vec3 irradiance = getGradientIrradiance( geometry.normal, directLight.direction ) * directLight.color;
	reflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
}
void RE_IndirectDiffuse_Toon( const in vec3 irradiance, const in GeometricContext geometry, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {
	reflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
}
#define RE_Direct				RE_Direct_Toon
#define RE_IndirectDiffuse		RE_IndirectDiffuse_Toon
#define Material_LightProbeLOD( material )	(0)`,ub=`BlinnPhongMaterial material;
material.diffuseColor = diffuseColor.rgb;
material.specularColor = specular;
material.specularShininess = shininess;
material.specularStrength = specularStrength;`,hb=`varying vec3 vViewPosition;
struct BlinnPhongMaterial {
	vec3 diffuseColor;
	vec3 specularColor;
	float specularShininess;
	float specularStrength;
};
void RE_Direct_BlinnPhong( const in IncidentLight directLight, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {
	float dotNL = saturate( dot( geometry.normal, directLight.direction ) );
	vec3 irradiance = dotNL * directLight.color;
	reflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
	reflectedLight.directSpecular += irradiance * BRDF_BlinnPhong( directLight.direction, geometry.viewDir, geometry.normal, material.specularColor, material.specularShininess ) * material.specularStrength;
}
void RE_IndirectDiffuse_BlinnPhong( const in vec3 irradiance, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {
	reflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
}
#define RE_Direct				RE_Direct_BlinnPhong
#define RE_IndirectDiffuse		RE_IndirectDiffuse_BlinnPhong
#define Material_LightProbeLOD( material )	(0)`,fb=`PhysicalMaterial material;
material.diffuseColor = diffuseColor.rgb * ( 1.0 - metalnessFactor );
vec3 dxy = max( abs( dFdx( geometryNormal ) ), abs( dFdy( geometryNormal ) ) );
float geometryRoughness = max( max( dxy.x, dxy.y ), dxy.z );
material.roughness = max( roughnessFactor, 0.0525 );material.roughness += geometryRoughness;
material.roughness = min( material.roughness, 1.0 );
#ifdef IOR
	#ifdef SPECULAR
		float specularIntensityFactor = specularIntensity;
		vec3 specularColorFactor = specularColor;
		#ifdef USE_SPECULARINTENSITYMAP
			specularIntensityFactor *= texture2D( specularIntensityMap, vUv ).a;
		#endif
		#ifdef USE_SPECULARCOLORMAP
			specularColorFactor *= texture2D( specularColorMap, vUv ).rgb;
		#endif
		material.specularF90 = mix( specularIntensityFactor, 1.0, metalnessFactor );
	#else
		float specularIntensityFactor = 1.0;
		vec3 specularColorFactor = vec3( 1.0 );
		material.specularF90 = 1.0;
	#endif
	material.specularColor = mix( min( pow2( ( ior - 1.0 ) / ( ior + 1.0 ) ) * specularColorFactor, vec3( 1.0 ) ) * specularIntensityFactor, diffuseColor.rgb, metalnessFactor );
#else
	material.specularColor = mix( vec3( 0.04 ), diffuseColor.rgb, metalnessFactor );
	material.specularF90 = 1.0;
#endif
#ifdef USE_CLEARCOAT
	material.clearcoat = clearcoat;
	material.clearcoatRoughness = clearcoatRoughness;
	material.clearcoatF0 = vec3( 0.04 );
	material.clearcoatF90 = 1.0;
	#ifdef USE_CLEARCOATMAP
		material.clearcoat *= texture2D( clearcoatMap, vUv ).x;
	#endif
	#ifdef USE_CLEARCOAT_ROUGHNESSMAP
		material.clearcoatRoughness *= texture2D( clearcoatRoughnessMap, vUv ).y;
	#endif
	material.clearcoat = saturate( material.clearcoat );	material.clearcoatRoughness = max( material.clearcoatRoughness, 0.0525 );
	material.clearcoatRoughness += geometryRoughness;
	material.clearcoatRoughness = min( material.clearcoatRoughness, 1.0 );
#endif
#ifdef USE_SHEEN
	material.sheenColor = sheenColor;
	#ifdef USE_SHEENCOLORMAP
		material.sheenColor *= texture2D( sheenColorMap, vUv ).rgb;
	#endif
	material.sheenRoughness = clamp( sheenRoughness, 0.07, 1.0 );
	#ifdef USE_SHEENROUGHNESSMAP
		material.sheenRoughness *= texture2D( sheenRoughnessMap, vUv ).a;
	#endif
#endif`,db=`struct PhysicalMaterial {
	vec3 diffuseColor;
	float roughness;
	vec3 specularColor;
	float specularF90;
	#ifdef USE_CLEARCOAT
		float clearcoat;
		float clearcoatRoughness;
		vec3 clearcoatF0;
		float clearcoatF90;
	#endif
	#ifdef USE_SHEEN
		vec3 sheenColor;
		float sheenRoughness;
	#endif
};
vec3 clearcoatSpecular = vec3( 0.0 );
vec3 sheenSpecular = vec3( 0.0 );
float IBLSheenBRDF( const in vec3 normal, const in vec3 viewDir, const in float roughness) {
	float dotNV = saturate( dot( normal, viewDir ) );
	float r2 = roughness * roughness;
	float a = roughness < 0.25 ? -339.2 * r2 + 161.4 * roughness - 25.9 : -8.48 * r2 + 14.3 * roughness - 9.95;
	float b = roughness < 0.25 ? 44.0 * r2 - 23.7 * roughness + 3.26 : 1.97 * r2 - 3.27 * roughness + 0.72;
	float DG = exp( a * dotNV + b ) + ( roughness < 0.25 ? 0.0 : 0.1 * ( roughness - 0.25 ) );
	return saturate( DG * RECIPROCAL_PI );
}
vec2 DFGApprox( const in vec3 normal, const in vec3 viewDir, const in float roughness ) {
	float dotNV = saturate( dot( normal, viewDir ) );
	const vec4 c0 = vec4( - 1, - 0.0275, - 0.572, 0.022 );
	const vec4 c1 = vec4( 1, 0.0425, 1.04, - 0.04 );
	vec4 r = roughness * c0 + c1;
	float a004 = min( r.x * r.x, exp2( - 9.28 * dotNV ) ) * r.x + r.y;
	vec2 fab = vec2( - 1.04, 1.04 ) * a004 + r.zw;
	return fab;
}
vec3 EnvironmentBRDF( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float roughness ) {
	vec2 fab = DFGApprox( normal, viewDir, roughness );
	return specularColor * fab.x + specularF90 * fab.y;
}
void computeMultiscattering( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float roughness, inout vec3 singleScatter, inout vec3 multiScatter ) {
	vec2 fab = DFGApprox( normal, viewDir, roughness );
	vec3 FssEss = specularColor * fab.x + specularF90 * fab.y;
	float Ess = fab.x + fab.y;
	float Ems = 1.0 - Ess;
	vec3 Favg = specularColor + ( 1.0 - specularColor ) * 0.047619;	vec3 Fms = FssEss * Favg / ( 1.0 - Ems * Favg );
	singleScatter += FssEss;
	multiScatter += Fms * Ems;
}
#if NUM_RECT_AREA_LIGHTS > 0
	void RE_Direct_RectArea_Physical( const in RectAreaLight rectAreaLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {
		vec3 normal = geometry.normal;
		vec3 viewDir = geometry.viewDir;
		vec3 position = geometry.position;
		vec3 lightPos = rectAreaLight.position;
		vec3 halfWidth = rectAreaLight.halfWidth;
		vec3 halfHeight = rectAreaLight.halfHeight;
		vec3 lightColor = rectAreaLight.color;
		float roughness = material.roughness;
		vec3 rectCoords[ 4 ];
		rectCoords[ 0 ] = lightPos + halfWidth - halfHeight;		rectCoords[ 1 ] = lightPos - halfWidth - halfHeight;
		rectCoords[ 2 ] = lightPos - halfWidth + halfHeight;
		rectCoords[ 3 ] = lightPos + halfWidth + halfHeight;
		vec2 uv = LTC_Uv( normal, viewDir, roughness );
		vec4 t1 = texture2D( ltc_1, uv );
		vec4 t2 = texture2D( ltc_2, uv );
		mat3 mInv = mat3(
			vec3( t1.x, 0, t1.y ),
			vec3(    0, 1,    0 ),
			vec3( t1.z, 0, t1.w )
		);
		vec3 fresnel = ( material.specularColor * t2.x + ( vec3( 1.0 ) - material.specularColor ) * t2.y );
		reflectedLight.directSpecular += lightColor * fresnel * LTC_Evaluate( normal, viewDir, position, mInv, rectCoords );
		reflectedLight.directDiffuse += lightColor * material.diffuseColor * LTC_Evaluate( normal, viewDir, position, mat3( 1.0 ), rectCoords );
	}
#endif
void RE_Direct_Physical( const in IncidentLight directLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {
	float dotNL = saturate( dot( geometry.normal, directLight.direction ) );
	vec3 irradiance = dotNL * directLight.color;
	#ifdef USE_CLEARCOAT
		float dotNLcc = saturate( dot( geometry.clearcoatNormal, directLight.direction ) );
		vec3 ccIrradiance = dotNLcc * directLight.color;
		clearcoatSpecular += ccIrradiance * BRDF_GGX( directLight.direction, geometry.viewDir, geometry.clearcoatNormal, material.clearcoatF0, material.clearcoatF90, material.clearcoatRoughness );
	#endif
	#ifdef USE_SHEEN
		sheenSpecular += irradiance * BRDF_Sheen( directLight.direction, geometry.viewDir, geometry.normal, material.sheenColor, material.sheenRoughness );
	#endif
	reflectedLight.directSpecular += irradiance * BRDF_GGX( directLight.direction, geometry.viewDir, geometry.normal, material.specularColor, material.specularF90, material.roughness );
	reflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
}
void RE_IndirectDiffuse_Physical( const in vec3 irradiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {
	reflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
}
void RE_IndirectSpecular_Physical( const in vec3 radiance, const in vec3 irradiance, const in vec3 clearcoatRadiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight) {
	#ifdef USE_CLEARCOAT
		clearcoatSpecular += clearcoatRadiance * EnvironmentBRDF( geometry.clearcoatNormal, geometry.viewDir, material.clearcoatF0, material.clearcoatF90, material.clearcoatRoughness );
	#endif
	#ifdef USE_SHEEN
		sheenSpecular += irradiance * material.sheenColor * IBLSheenBRDF( geometry.normal, geometry.viewDir, material.sheenRoughness );
	#endif
	vec3 singleScattering = vec3( 0.0 );
	vec3 multiScattering = vec3( 0.0 );
	vec3 cosineWeightedIrradiance = irradiance * RECIPROCAL_PI;
	computeMultiscattering( geometry.normal, geometry.viewDir, material.specularColor, material.specularF90, material.roughness, singleScattering, multiScattering );
	vec3 diffuse = material.diffuseColor * ( 1.0 - ( singleScattering + multiScattering ) );
	reflectedLight.indirectSpecular += radiance * singleScattering;
	reflectedLight.indirectSpecular += multiScattering * cosineWeightedIrradiance;
	reflectedLight.indirectDiffuse += diffuse * cosineWeightedIrradiance;
}
#define RE_Direct				RE_Direct_Physical
#define RE_Direct_RectArea		RE_Direct_RectArea_Physical
#define RE_IndirectDiffuse		RE_IndirectDiffuse_Physical
#define RE_IndirectSpecular		RE_IndirectSpecular_Physical
float computeSpecularOcclusion( const in float dotNV, const in float ambientOcclusion, const in float roughness ) {
	return saturate( pow( dotNV + ambientOcclusion, exp2( - 16.0 * roughness - 1.0 ) ) - 1.0 + ambientOcclusion );
}`,pb=`
GeometricContext geometry;
geometry.position = - vViewPosition;
geometry.normal = normal;
geometry.viewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( vViewPosition );
#ifdef USE_CLEARCOAT
	geometry.clearcoatNormal = clearcoatNormal;
#endif
IncidentLight directLight;
#if ( NUM_POINT_LIGHTS > 0 ) && defined( RE_Direct )
	PointLight pointLight;
	#if defined( USE_SHADOWMAP ) && NUM_POINT_LIGHT_SHADOWS > 0
	PointLightShadow pointLightShadow;
	#endif
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {
		pointLight = pointLights[ i ];
		getPointLightInfo( pointLight, geometry, directLight );
		#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_POINT_LIGHT_SHADOWS )
		pointLightShadow = pointLightShadows[ i ];
		directLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getPointShadow( pointShadowMap[ i ], pointLightShadow.shadowMapSize, pointLightShadow.shadowBias, pointLightShadow.shadowRadius, vPointShadowCoord[ i ], pointLightShadow.shadowCameraNear, pointLightShadow.shadowCameraFar ) : 1.0;
		#endif
		RE_Direct( directLight, geometry, material, reflectedLight );
	}
	#pragma unroll_loop_end
#endif
#if ( NUM_SPOT_LIGHTS > 0 ) && defined( RE_Direct )
	SpotLight spotLight;
	#if defined( USE_SHADOWMAP ) && NUM_SPOT_LIGHT_SHADOWS > 0
	SpotLightShadow spotLightShadow;
	#endif
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {
		spotLight = spotLights[ i ];
		getSpotLightInfo( spotLight, geometry, directLight );
		#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )
		spotLightShadow = spotLightShadows[ i ];
		directLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getShadow( spotShadowMap[ i ], spotLightShadow.shadowMapSize, spotLightShadow.shadowBias, spotLightShadow.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;
		#endif
		RE_Direct( directLight, geometry, material, reflectedLight );
	}
	#pragma unroll_loop_end
#endif
#if ( NUM_DIR_LIGHTS > 0 ) && defined( RE_Direct )
	DirectionalLight directionalLight;
	#if defined( USE_SHADOWMAP ) && NUM_DIR_LIGHT_SHADOWS > 0
	DirectionalLightShadow directionalLightShadow;
	#endif
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {
		directionalLight = directionalLights[ i ];
		getDirectionalLightInfo( directionalLight, geometry, directLight );
		#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS )
		directionalLightShadow = directionalLightShadows[ i ];
		directLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getShadow( directionalShadowMap[ i ], directionalLightShadow.shadowMapSize, directionalLightShadow.shadowBias, directionalLightShadow.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;
		#endif
		RE_Direct( directLight, geometry, material, reflectedLight );
	}
	#pragma unroll_loop_end
#endif
#if ( NUM_RECT_AREA_LIGHTS > 0 ) && defined( RE_Direct_RectArea )
	RectAreaLight rectAreaLight;
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_RECT_AREA_LIGHTS; i ++ ) {
		rectAreaLight = rectAreaLights[ i ];
		RE_Direct_RectArea( rectAreaLight, geometry, material, reflectedLight );
	}
	#pragma unroll_loop_end
#endif
#if defined( RE_IndirectDiffuse )
	vec3 iblIrradiance = vec3( 0.0 );
	vec3 irradiance = getAmbientLightIrradiance( ambientLightColor );
	irradiance += getLightProbeIrradiance( lightProbe, geometry.normal );
	#if ( NUM_HEMI_LIGHTS > 0 )
		#pragma unroll_loop_start
		for ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {
			irradiance += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry.normal );
		}
		#pragma unroll_loop_end
	#endif
#endif
#if defined( RE_IndirectSpecular )
	vec3 radiance = vec3( 0.0 );
	vec3 clearcoatRadiance = vec3( 0.0 );
#endif`,mb=`#if defined( RE_IndirectDiffuse )
	#ifdef USE_LIGHTMAP
		vec4 lightMapTexel = texture2D( lightMap, vUv2 );
		vec3 lightMapIrradiance = lightMapTexel.rgb * lightMapIntensity;
		#ifndef PHYSICALLY_CORRECT_LIGHTS
			lightMapIrradiance *= PI;
		#endif
		irradiance += lightMapIrradiance;
	#endif
	#if defined( USE_ENVMAP ) && defined( STANDARD ) && defined( ENVMAP_TYPE_CUBE_UV )
		iblIrradiance += getIBLIrradiance( geometry.normal );
	#endif
#endif
#if defined( USE_ENVMAP ) && defined( RE_IndirectSpecular )
	radiance += getIBLRadiance( geometry.viewDir, geometry.normal, material.roughness );
	#ifdef USE_CLEARCOAT
		clearcoatRadiance += getIBLRadiance( geometry.viewDir, geometry.clearcoatNormal, material.clearcoatRoughness );
	#endif
#endif`,gb=`#if defined( RE_IndirectDiffuse )
	RE_IndirectDiffuse( irradiance, geometry, material, reflectedLight );
#endif
#if defined( RE_IndirectSpecular )
	RE_IndirectSpecular( radiance, iblIrradiance, clearcoatRadiance, geometry, material, reflectedLight );
#endif`,xb=`#if defined( USE_LOGDEPTHBUF ) && defined( USE_LOGDEPTHBUF_EXT )
	gl_FragDepthEXT = vIsPerspective == 0.0 ? gl_FragCoord.z : log2( vFragDepth ) * logDepthBufFC * 0.5;
#endif`,yb=`#if defined( USE_LOGDEPTHBUF ) && defined( USE_LOGDEPTHBUF_EXT )
	uniform float logDepthBufFC;
	varying float vFragDepth;
	varying float vIsPerspective;
#endif`,vb=`#ifdef USE_LOGDEPTHBUF
	#ifdef USE_LOGDEPTHBUF_EXT
		varying float vFragDepth;
		varying float vIsPerspective;
	#else
		uniform float logDepthBufFC;
	#endif
#endif`,_b=`#ifdef USE_LOGDEPTHBUF
	#ifdef USE_LOGDEPTHBUF_EXT
		vFragDepth = 1.0 + gl_Position.w;
		vIsPerspective = float( isPerspectiveMatrix( projectionMatrix ) );
	#else
		if ( isPerspectiveMatrix( projectionMatrix ) ) {
			gl_Position.z = log2( max( EPSILON, gl_Position.w + 1.0 ) ) * logDepthBufFC - 1.0;
			gl_Position.z *= gl_Position.w;
		}
	#endif
#endif`,wb=`#ifdef USE_MAP
	vec4 sampledDiffuseColor = texture2D( map, vUv );
	#ifdef DECODE_VIDEO_TEXTURE
		sampledDiffuseColor = vec4( mix( pow( sampledDiffuseColor.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), sampledDiffuseColor.rgb * 0.0773993808, vec3( lessThanEqual( sampledDiffuseColor.rgb, vec3( 0.04045 ) ) ) ), sampledDiffuseColor.w );
	#endif
	diffuseColor *= sampledDiffuseColor;
#endif`,Mb=`#ifdef USE_MAP
	uniform sampler2D map;
#endif`,bb=`#if defined( USE_MAP ) || defined( USE_ALPHAMAP )
	vec2 uv = ( uvTransform * vec3( gl_PointCoord.x, 1.0 - gl_PointCoord.y, 1 ) ).xy;
#endif
#ifdef USE_MAP
	diffuseColor *= texture2D( map, uv );
#endif
#ifdef USE_ALPHAMAP
	diffuseColor.a *= texture2D( alphaMap, uv ).g;
#endif`,Sb=`#if defined( USE_MAP ) || defined( USE_ALPHAMAP )
	uniform mat3 uvTransform;
#endif
#ifdef USE_MAP
	uniform sampler2D map;
#endif
#ifdef USE_ALPHAMAP
	uniform sampler2D alphaMap;
#endif`,Eb=`float metalnessFactor = metalness;
#ifdef USE_METALNESSMAP
	vec4 texelMetalness = texture2D( metalnessMap, vUv );
	metalnessFactor *= texelMetalness.b;
#endif`,Tb=`#ifdef USE_METALNESSMAP
	uniform sampler2D metalnessMap;
#endif`,Ab=`#ifdef USE_MORPHNORMALS
	objectNormal *= morphTargetBaseInfluence;
	#ifdef MORPHTARGETS_TEXTURE
		for ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {
			if ( morphTargetInfluences[ i ] != 0.0 ) objectNormal += getMorph( gl_VertexID, i, 1, 2 ) * morphTargetInfluences[ i ];
		}
	#else
		objectNormal += morphNormal0 * morphTargetInfluences[ 0 ];
		objectNormal += morphNormal1 * morphTargetInfluences[ 1 ];
		objectNormal += morphNormal2 * morphTargetInfluences[ 2 ];
		objectNormal += morphNormal3 * morphTargetInfluences[ 3 ];
	#endif
#endif`,Cb=`#ifdef USE_MORPHTARGETS
	uniform float morphTargetBaseInfluence;
	#ifdef MORPHTARGETS_TEXTURE
		uniform float morphTargetInfluences[ MORPHTARGETS_COUNT ];
		uniform sampler2DArray morphTargetsTexture;
		uniform vec2 morphTargetsTextureSize;
		vec3 getMorph( const in int vertexIndex, const in int morphTargetIndex, const in int offset, const in int stride ) {
			float texelIndex = float( vertexIndex * stride + offset );
			float y = floor( texelIndex / morphTargetsTextureSize.x );
			float x = texelIndex - y * morphTargetsTextureSize.x;
			vec3 morphUV = vec3( ( x + 0.5 ) / morphTargetsTextureSize.x, y / morphTargetsTextureSize.y, morphTargetIndex );
			return texture( morphTargetsTexture, morphUV ).xyz;
		}
	#else
		#ifndef USE_MORPHNORMALS
			uniform float morphTargetInfluences[ 8 ];
		#else
			uniform float morphTargetInfluences[ 4 ];
		#endif
	#endif
#endif`,Rb=`#ifdef USE_MORPHTARGETS
	transformed *= morphTargetBaseInfluence;
	#ifdef MORPHTARGETS_TEXTURE
		for ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {
			#ifndef USE_MORPHNORMALS
				if ( morphTargetInfluences[ i ] != 0.0 ) transformed += getMorph( gl_VertexID, i, 0, 1 ) * morphTargetInfluences[ i ];
			#else
				if ( morphTargetInfluences[ i ] != 0.0 ) transformed += getMorph( gl_VertexID, i, 0, 2 ) * morphTargetInfluences[ i ];
			#endif
		}
	#else
		transformed += morphTarget0 * morphTargetInfluences[ 0 ];
		transformed += morphTarget1 * morphTargetInfluences[ 1 ];
		transformed += morphTarget2 * morphTargetInfluences[ 2 ];
		transformed += morphTarget3 * morphTargetInfluences[ 3 ];
		#ifndef USE_MORPHNORMALS
			transformed += morphTarget4 * morphTargetInfluences[ 4 ];
			transformed += morphTarget5 * morphTargetInfluences[ 5 ];
			transformed += morphTarget6 * morphTargetInfluences[ 6 ];
			transformed += morphTarget7 * morphTargetInfluences[ 7 ];
		#endif
	#endif
#endif`,Lb=`float faceDirection = gl_FrontFacing ? 1.0 : - 1.0;
#ifdef FLAT_SHADED
	vec3 fdx = vec3( dFdx( vViewPosition.x ), dFdx( vViewPosition.y ), dFdx( vViewPosition.z ) );
	vec3 fdy = vec3( dFdy( vViewPosition.x ), dFdy( vViewPosition.y ), dFdy( vViewPosition.z ) );
	vec3 normal = normalize( cross( fdx, fdy ) );
#else
	vec3 normal = normalize( vNormal );
	#ifdef DOUBLE_SIDED
		normal = normal * faceDirection;
	#endif
	#ifdef USE_TANGENT
		vec3 tangent = normalize( vTangent );
		vec3 bitangent = normalize( vBitangent );
		#ifdef DOUBLE_SIDED
			tangent = tangent * faceDirection;
			bitangent = bitangent * faceDirection;
		#endif
		#if defined( TANGENTSPACE_NORMALMAP ) || defined( USE_CLEARCOAT_NORMALMAP )
			mat3 vTBN = mat3( tangent, bitangent, normal );
		#endif
	#endif
#endif
vec3 geometryNormal = normal;`,Pb=`#ifdef OBJECTSPACE_NORMALMAP
	normal = texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;
	#ifdef FLIP_SIDED
		normal = - normal;
	#endif
	#ifdef DOUBLE_SIDED
		normal = normal * faceDirection;
	#endif
	normal = normalize( normalMatrix * normal );
#elif defined( TANGENTSPACE_NORMALMAP )
	vec3 mapN = texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;
	mapN.xy *= normalScale;
	#ifdef USE_TANGENT
		normal = normalize( vTBN * mapN );
	#else
		normal = perturbNormal2Arb( - vViewPosition, normal, mapN, faceDirection );
	#endif
#elif defined( USE_BUMPMAP )
	normal = perturbNormalArb( - vViewPosition, normal, dHdxy_fwd(), faceDirection );
#endif`,Db=`#ifndef FLAT_SHADED
	varying vec3 vNormal;
	#ifdef USE_TANGENT
		varying vec3 vTangent;
		varying vec3 vBitangent;
	#endif
#endif`,Ib=`#ifndef FLAT_SHADED
	varying vec3 vNormal;
	#ifdef USE_TANGENT
		varying vec3 vTangent;
		varying vec3 vBitangent;
	#endif
#endif`,Nb=`#ifndef FLAT_SHADED
	vNormal = normalize( transformedNormal );
	#ifdef USE_TANGENT
		vTangent = normalize( transformedTangent );
		vBitangent = normalize( cross( vNormal, vTangent ) * tangent.w );
	#endif
#endif`,Fb=`#ifdef USE_NORMALMAP
	uniform sampler2D normalMap;
	uniform vec2 normalScale;
#endif
#ifdef OBJECTSPACE_NORMALMAP
	uniform mat3 normalMatrix;
#endif
#if ! defined ( USE_TANGENT ) && ( defined ( TANGENTSPACE_NORMALMAP ) || defined ( USE_CLEARCOAT_NORMALMAP ) )
	vec3 perturbNormal2Arb( vec3 eye_pos, vec3 surf_norm, vec3 mapN, float faceDirection ) {
		vec3 q0 = vec3( dFdx( eye_pos.x ), dFdx( eye_pos.y ), dFdx( eye_pos.z ) );
		vec3 q1 = vec3( dFdy( eye_pos.x ), dFdy( eye_pos.y ), dFdy( eye_pos.z ) );
		vec2 st0 = dFdx( vUv.st );
		vec2 st1 = dFdy( vUv.st );
		vec3 N = surf_norm;
		vec3 q1perp = cross( q1, N );
		vec3 q0perp = cross( N, q0 );
		vec3 T = q1perp * st0.x + q0perp * st1.x;
		vec3 B = q1perp * st0.y + q0perp * st1.y;
		float det = max( dot( T, T ), dot( B, B ) );
		float scale = ( det == 0.0 ) ? 0.0 : faceDirection * inversesqrt( det );
		return normalize( T * ( mapN.x * scale ) + B * ( mapN.y * scale ) + N * mapN.z );
	}
#endif`,zb=`#ifdef USE_CLEARCOAT
	vec3 clearcoatNormal = geometryNormal;
#endif`,Ub=`#ifdef USE_CLEARCOAT_NORMALMAP
	vec3 clearcoatMapN = texture2D( clearcoatNormalMap, vUv ).xyz * 2.0 - 1.0;
	clearcoatMapN.xy *= clearcoatNormalScale;
	#ifdef USE_TANGENT
		clearcoatNormal = normalize( vTBN * clearcoatMapN );
	#else
		clearcoatNormal = perturbNormal2Arb( - vViewPosition, clearcoatNormal, clearcoatMapN, faceDirection );
	#endif
#endif`,Bb=`#ifdef USE_CLEARCOATMAP
	uniform sampler2D clearcoatMap;
#endif
#ifdef USE_CLEARCOAT_ROUGHNESSMAP
	uniform sampler2D clearcoatRoughnessMap;
#endif
#ifdef USE_CLEARCOAT_NORMALMAP
	uniform sampler2D clearcoatNormalMap;
	uniform vec2 clearcoatNormalScale;
#endif`,Ob=`#ifdef OPAQUE
diffuseColor.a = 1.0;
#endif
#ifdef USE_TRANSMISSION
diffuseColor.a *= transmissionAlpha + 0.1;
#endif
gl_FragColor = vec4( outgoingLight, diffuseColor.a );`,kb=`vec3 packNormalToRGB( const in vec3 normal ) {
	return normalize( normal ) * 0.5 + 0.5;
}
vec3 unpackRGBToNormal( const in vec3 rgb ) {
	return 2.0 * rgb.xyz - 1.0;
}
const float PackUpscale = 256. / 255.;const float UnpackDownscale = 255. / 256.;
const vec3 PackFactors = vec3( 256. * 256. * 256., 256. * 256., 256. );
const vec4 UnpackFactors = UnpackDownscale / vec4( PackFactors, 1. );
const float ShiftRight8 = 1. / 256.;
vec4 packDepthToRGBA( const in float v ) {
	vec4 r = vec4( fract( v * PackFactors ), v );
	r.yzw -= r.xyz * ShiftRight8;	return r * PackUpscale;
}
float unpackRGBAToDepth( const in vec4 v ) {
	return dot( v, UnpackFactors );
}
vec4 pack2HalfToRGBA( vec2 v ) {
	vec4 r = vec4( v.x, fract( v.x * 255.0 ), v.y, fract( v.y * 255.0 ) );
	return vec4( r.x - r.y / 255.0, r.y, r.z - r.w / 255.0, r.w );
}
vec2 unpackRGBATo2Half( vec4 v ) {
	return vec2( v.x + ( v.y / 255.0 ), v.z + ( v.w / 255.0 ) );
}
float viewZToOrthographicDepth( const in float viewZ, const in float near, const in float far ) {
	return ( viewZ + near ) / ( near - far );
}
float orthographicDepthToViewZ( const in float linearClipZ, const in float near, const in float far ) {
	return linearClipZ * ( near - far ) - near;
}
float viewZToPerspectiveDepth( const in float viewZ, const in float near, const in float far ) {
	return ( ( near + viewZ ) * far ) / ( ( far - near ) * viewZ );
}
float perspectiveDepthToViewZ( const in float invClipZ, const in float near, const in float far ) {
	return ( near * far ) / ( ( far - near ) * invClipZ - far );
}`,Hb=`#ifdef PREMULTIPLIED_ALPHA
	gl_FragColor.rgb *= gl_FragColor.a;
#endif`,Vb=`vec4 mvPosition = vec4( transformed, 1.0 );
#ifdef USE_INSTANCING
	mvPosition = instanceMatrix * mvPosition;
#endif
mvPosition = modelViewMatrix * mvPosition;
gl_Position = projectionMatrix * mvPosition;`,Gb=`#ifdef DITHERING
	gl_FragColor.rgb = dithering( gl_FragColor.rgb );
#endif`,Wb=`#ifdef DITHERING
	vec3 dithering( vec3 color ) {
		float grid_position = rand( gl_FragCoord.xy );
		vec3 dither_shift_RGB = vec3( 0.25 / 255.0, -0.25 / 255.0, 0.25 / 255.0 );
		dither_shift_RGB = mix( 2.0 * dither_shift_RGB, -2.0 * dither_shift_RGB, grid_position );
		return color + dither_shift_RGB;
	}
#endif`,qb=`float roughnessFactor = roughness;
#ifdef USE_ROUGHNESSMAP
	vec4 texelRoughness = texture2D( roughnessMap, vUv );
	roughnessFactor *= texelRoughness.g;
#endif`,Xb=`#ifdef USE_ROUGHNESSMAP
	uniform sampler2D roughnessMap;
#endif`,Yb=`#ifdef USE_SHADOWMAP
	#if NUM_DIR_LIGHT_SHADOWS > 0
		uniform sampler2D directionalShadowMap[ NUM_DIR_LIGHT_SHADOWS ];
		varying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];
		struct DirectionalLightShadow {
			float shadowBias;
			float shadowNormalBias;
			float shadowRadius;
			vec2 shadowMapSize;
		};
		uniform DirectionalLightShadow directionalLightShadows[ NUM_DIR_LIGHT_SHADOWS ];
	#endif
	#if NUM_SPOT_LIGHT_SHADOWS > 0
		uniform sampler2D spotShadowMap[ NUM_SPOT_LIGHT_SHADOWS ];
		varying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHT_SHADOWS ];
		struct SpotLightShadow {
			float shadowBias;
			float shadowNormalBias;
			float shadowRadius;
			vec2 shadowMapSize;
		};
		uniform SpotLightShadow spotLightShadows[ NUM_SPOT_LIGHT_SHADOWS ];
	#endif
	#if NUM_POINT_LIGHT_SHADOWS > 0
		uniform sampler2D pointShadowMap[ NUM_POINT_LIGHT_SHADOWS ];
		varying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];
		struct PointLightShadow {
			float shadowBias;
			float shadowNormalBias;
			float shadowRadius;
			vec2 shadowMapSize;
			float shadowCameraNear;
			float shadowCameraFar;
		};
		uniform PointLightShadow pointLightShadows[ NUM_POINT_LIGHT_SHADOWS ];
	#endif
	float texture2DCompare( sampler2D depths, vec2 uv, float compare ) {
		return step( compare, unpackRGBAToDepth( texture2D( depths, uv ) ) );
	}
	vec2 texture2DDistribution( sampler2D shadow, vec2 uv ) {
		return unpackRGBATo2Half( texture2D( shadow, uv ) );
	}
	float VSMShadow (sampler2D shadow, vec2 uv, float compare ){
		float occlusion = 1.0;
		vec2 distribution = texture2DDistribution( shadow, uv );
		float hard_shadow = step( compare , distribution.x );
		if (hard_shadow != 1.0 ) {
			float distance = compare - distribution.x ;
			float variance = max( 0.00000, distribution.y * distribution.y );
			float softness_probability = variance / (variance + distance * distance );			softness_probability = clamp( ( softness_probability - 0.3 ) / ( 0.95 - 0.3 ), 0.0, 1.0 );			occlusion = clamp( max( hard_shadow, softness_probability ), 0.0, 1.0 );
		}
		return occlusion;
	}
	float getShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord ) {
		float shadow = 1.0;
		shadowCoord.xyz /= shadowCoord.w;
		shadowCoord.z += shadowBias;
		bvec4 inFrustumVec = bvec4 ( shadowCoord.x >= 0.0, shadowCoord.x <= 1.0, shadowCoord.y >= 0.0, shadowCoord.y <= 1.0 );
		bool inFrustum = all( inFrustumVec );
		bvec2 frustumTestVec = bvec2( inFrustum, shadowCoord.z <= 1.0 );
		bool frustumTest = all( frustumTestVec );
		if ( frustumTest ) {
		#if defined( SHADOWMAP_TYPE_PCF )
			vec2 texelSize = vec2( 1.0 ) / shadowMapSize;
			float dx0 = - texelSize.x * shadowRadius;
			float dy0 = - texelSize.y * shadowRadius;
			float dx1 = + texelSize.x * shadowRadius;
			float dy1 = + texelSize.y * shadowRadius;
			float dx2 = dx0 / 2.0;
			float dy2 = dy0 / 2.0;
			float dx3 = dx1 / 2.0;
			float dy3 = dy1 / 2.0;
			shadow = (
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, dy2 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy2 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, dy2 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, 0.0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, 0.0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, 0.0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, 0.0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, dy3 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy3 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, dy3 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy1 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy1 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy1 ), shadowCoord.z )
			) * ( 1.0 / 17.0 );
		#elif defined( SHADOWMAP_TYPE_PCF_SOFT )
			vec2 texelSize = vec2( 1.0 ) / shadowMapSize;
			float dx = texelSize.x;
			float dy = texelSize.y;
			vec2 uv = shadowCoord.xy;
			vec2 f = fract( uv * shadowMapSize + 0.5 );
			uv -= f * texelSize;
			shadow = (
				texture2DCompare( shadowMap, uv, shadowCoord.z ) +
				texture2DCompare( shadowMap, uv + vec2( dx, 0.0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, uv + vec2( 0.0, dy ), shadowCoord.z ) +
				texture2DCompare( shadowMap, uv + texelSize, shadowCoord.z ) +
				mix( texture2DCompare( shadowMap, uv + vec2( -dx, 0.0 ), shadowCoord.z ), 
					 texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, 0.0 ), shadowCoord.z ),
					 f.x ) +
				mix( texture2DCompare( shadowMap, uv + vec2( -dx, dy ), shadowCoord.z ), 
					 texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, dy ), shadowCoord.z ),
					 f.x ) +
				mix( texture2DCompare( shadowMap, uv + vec2( 0.0, -dy ), shadowCoord.z ), 
					 texture2DCompare( shadowMap, uv + vec2( 0.0, 2.0 * dy ), shadowCoord.z ),
					 f.y ) +
				mix( texture2DCompare( shadowMap, uv + vec2( dx, -dy ), shadowCoord.z ), 
					 texture2DCompare( shadowMap, uv + vec2( dx, 2.0 * dy ), shadowCoord.z ),
					 f.y ) +
				mix( mix( texture2DCompare( shadowMap, uv + vec2( -dx, -dy ), shadowCoord.z ), 
						  texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, -dy ), shadowCoord.z ),
						  f.x ),
					 mix( texture2DCompare( shadowMap, uv + vec2( -dx, 2.0 * dy ), shadowCoord.z ), 
						  texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, 2.0 * dy ), shadowCoord.z ),
						  f.x ),
					 f.y )
			) * ( 1.0 / 9.0 );
		#elif defined( SHADOWMAP_TYPE_VSM )
			shadow = VSMShadow( shadowMap, shadowCoord.xy, shadowCoord.z );
		#else
			shadow = texture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z );
		#endif
		}
		return shadow;
	}
	vec2 cubeToUV( vec3 v, float texelSizeY ) {
		vec3 absV = abs( v );
		float scaleToCube = 1.0 / max( absV.x, max( absV.y, absV.z ) );
		absV *= scaleToCube;
		v *= scaleToCube * ( 1.0 - 2.0 * texelSizeY );
		vec2 planar = v.xy;
		float almostATexel = 1.5 * texelSizeY;
		float almostOne = 1.0 - almostATexel;
		if ( absV.z >= almostOne ) {
			if ( v.z > 0.0 )
				planar.x = 4.0 - v.x;
		} else if ( absV.x >= almostOne ) {
			float signX = sign( v.x );
			planar.x = v.z * signX + 2.0 * signX;
		} else if ( absV.y >= almostOne ) {
			float signY = sign( v.y );
			planar.x = v.x + 2.0 * signY + 2.0;
			planar.y = v.z * signY - 2.0;
		}
		return vec2( 0.125, 0.25 ) * planar + vec2( 0.375, 0.75 );
	}
	float getPointShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord, float shadowCameraNear, float shadowCameraFar ) {
		vec2 texelSize = vec2( 1.0 ) / ( shadowMapSize * vec2( 4.0, 2.0 ) );
		vec3 lightToPosition = shadowCoord.xyz;
		float dp = ( length( lightToPosition ) - shadowCameraNear ) / ( shadowCameraFar - shadowCameraNear );		dp += shadowBias;
		vec3 bd3D = normalize( lightToPosition );
		#if defined( SHADOWMAP_TYPE_PCF ) || defined( SHADOWMAP_TYPE_PCF_SOFT ) || defined( SHADOWMAP_TYPE_VSM )
			vec2 offset = vec2( - 1, 1 ) * shadowRadius * texelSize.y;
			return (
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyy, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyy, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyx, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyx, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxy, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxy, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxx, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxx, texelSize.y ), dp )
			) * ( 1.0 / 9.0 );
		#else
			return texture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp );
		#endif
	}
#endif`,Zb=`#ifdef USE_SHADOWMAP
	#if NUM_DIR_LIGHT_SHADOWS > 0
		uniform mat4 directionalShadowMatrix[ NUM_DIR_LIGHT_SHADOWS ];
		varying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];
		struct DirectionalLightShadow {
			float shadowBias;
			float shadowNormalBias;
			float shadowRadius;
			vec2 shadowMapSize;
		};
		uniform DirectionalLightShadow directionalLightShadows[ NUM_DIR_LIGHT_SHADOWS ];
	#endif
	#if NUM_SPOT_LIGHT_SHADOWS > 0
		uniform mat4 spotShadowMatrix[ NUM_SPOT_LIGHT_SHADOWS ];
		varying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHT_SHADOWS ];
		struct SpotLightShadow {
			float shadowBias;
			float shadowNormalBias;
			float shadowRadius;
			vec2 shadowMapSize;
		};
		uniform SpotLightShadow spotLightShadows[ NUM_SPOT_LIGHT_SHADOWS ];
	#endif
	#if NUM_POINT_LIGHT_SHADOWS > 0
		uniform mat4 pointShadowMatrix[ NUM_POINT_LIGHT_SHADOWS ];
		varying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];
		struct PointLightShadow {
			float shadowBias;
			float shadowNormalBias;
			float shadowRadius;
			vec2 shadowMapSize;
			float shadowCameraNear;
			float shadowCameraFar;
		};
		uniform PointLightShadow pointLightShadows[ NUM_POINT_LIGHT_SHADOWS ];
	#endif
#endif`,Jb=`#ifdef USE_SHADOWMAP
	#if NUM_DIR_LIGHT_SHADOWS > 0 || NUM_SPOT_LIGHT_SHADOWS > 0 || NUM_POINT_LIGHT_SHADOWS > 0
		vec3 shadowWorldNormal = inverseTransformDirection( transformedNormal, viewMatrix );
		vec4 shadowWorldPosition;
	#endif
	#if NUM_DIR_LIGHT_SHADOWS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {
		shadowWorldPosition = worldPosition + vec4( shadowWorldNormal * directionalLightShadows[ i ].shadowNormalBias, 0 );
		vDirectionalShadowCoord[ i ] = directionalShadowMatrix[ i ] * shadowWorldPosition;
	}
	#pragma unroll_loop_end
	#endif
	#if NUM_SPOT_LIGHT_SHADOWS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_SPOT_LIGHT_SHADOWS; i ++ ) {
		shadowWorldPosition = worldPosition + vec4( shadowWorldNormal * spotLightShadows[ i ].shadowNormalBias, 0 );
		vSpotShadowCoord[ i ] = spotShadowMatrix[ i ] * shadowWorldPosition;
	}
	#pragma unroll_loop_end
	#endif
	#if NUM_POINT_LIGHT_SHADOWS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {
		shadowWorldPosition = worldPosition + vec4( shadowWorldNormal * pointLightShadows[ i ].shadowNormalBias, 0 );
		vPointShadowCoord[ i ] = pointShadowMatrix[ i ] * shadowWorldPosition;
	}
	#pragma unroll_loop_end
	#endif
#endif`,$b=`float getShadowMask() {
	float shadow = 1.0;
	#ifdef USE_SHADOWMAP
	#if NUM_DIR_LIGHT_SHADOWS > 0
	DirectionalLightShadow directionalLight;
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {
		directionalLight = directionalLightShadows[ i ];
		shadow *= receiveShadow ? getShadow( directionalShadowMap[ i ], directionalLight.shadowMapSize, directionalLight.shadowBias, directionalLight.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;
	}
	#pragma unroll_loop_end
	#endif
	#if NUM_SPOT_LIGHT_SHADOWS > 0
	SpotLightShadow spotLight;
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_SPOT_LIGHT_SHADOWS; i ++ ) {
		spotLight = spotLightShadows[ i ];
		shadow *= receiveShadow ? getShadow( spotShadowMap[ i ], spotLight.shadowMapSize, spotLight.shadowBias, spotLight.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;
	}
	#pragma unroll_loop_end
	#endif
	#if NUM_POINT_LIGHT_SHADOWS > 0
	PointLightShadow pointLight;
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {
		pointLight = pointLightShadows[ i ];
		shadow *= receiveShadow ? getPointShadow( pointShadowMap[ i ], pointLight.shadowMapSize, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ i ], pointLight.shadowCameraNear, pointLight.shadowCameraFar ) : 1.0;
	}
	#pragma unroll_loop_end
	#endif
	#endif
	return shadow;
}`,Kb=`#ifdef USE_SKINNING
	mat4 boneMatX = getBoneMatrix( skinIndex.x );
	mat4 boneMatY = getBoneMatrix( skinIndex.y );
	mat4 boneMatZ = getBoneMatrix( skinIndex.z );
	mat4 boneMatW = getBoneMatrix( skinIndex.w );
#endif`,Qb=`#ifdef USE_SKINNING
	uniform mat4 bindMatrix;
	uniform mat4 bindMatrixInverse;
	#ifdef BONE_TEXTURE
		uniform highp sampler2D boneTexture;
		uniform int boneTextureSize;
		mat4 getBoneMatrix( const in float i ) {
			float j = i * 4.0;
			float x = mod( j, float( boneTextureSize ) );
			float y = floor( j / float( boneTextureSize ) );
			float dx = 1.0 / float( boneTextureSize );
			float dy = 1.0 / float( boneTextureSize );
			y = dy * ( y + 0.5 );
			vec4 v1 = texture2D( boneTexture, vec2( dx * ( x + 0.5 ), y ) );
			vec4 v2 = texture2D( boneTexture, vec2( dx * ( x + 1.5 ), y ) );
			vec4 v3 = texture2D( boneTexture, vec2( dx * ( x + 2.5 ), y ) );
			vec4 v4 = texture2D( boneTexture, vec2( dx * ( x + 3.5 ), y ) );
			mat4 bone = mat4( v1, v2, v3, v4 );
			return bone;
		}
	#else
		uniform mat4 boneMatrices[ MAX_BONES ];
		mat4 getBoneMatrix( const in float i ) {
			mat4 bone = boneMatrices[ int(i) ];
			return bone;
		}
	#endif
#endif`,jb=`#ifdef USE_SKINNING
	vec4 skinVertex = bindMatrix * vec4( transformed, 1.0 );
	vec4 skinned = vec4( 0.0 );
	skinned += boneMatX * skinVertex * skinWeight.x;
	skinned += boneMatY * skinVertex * skinWeight.y;
	skinned += boneMatZ * skinVertex * skinWeight.z;
	skinned += boneMatW * skinVertex * skinWeight.w;
	transformed = ( bindMatrixInverse * skinned ).xyz;
#endif`,t1=`#ifdef USE_SKINNING
	mat4 skinMatrix = mat4( 0.0 );
	skinMatrix += skinWeight.x * boneMatX;
	skinMatrix += skinWeight.y * boneMatY;
	skinMatrix += skinWeight.z * boneMatZ;
	skinMatrix += skinWeight.w * boneMatW;
	skinMatrix = bindMatrixInverse * skinMatrix * bindMatrix;
	objectNormal = vec4( skinMatrix * vec4( objectNormal, 0.0 ) ).xyz;
	#ifdef USE_TANGENT
		objectTangent = vec4( skinMatrix * vec4( objectTangent, 0.0 ) ).xyz;
	#endif
#endif`,e1=`float specularStrength;
#ifdef USE_SPECULARMAP
	vec4 texelSpecular = texture2D( specularMap, vUv );
	specularStrength = texelSpecular.r;
#else
	specularStrength = 1.0;
#endif`,n1=`#ifdef USE_SPECULARMAP
	uniform sampler2D specularMap;
#endif`,i1=`#if defined( TONE_MAPPING )
	gl_FragColor.rgb = toneMapping( gl_FragColor.rgb );
#endif`,r1=`#ifndef saturate
#define saturate( a ) clamp( a, 0.0, 1.0 )
#endif
uniform float toneMappingExposure;
vec3 LinearToneMapping( vec3 color ) {
	return toneMappingExposure * color;
}
vec3 ReinhardToneMapping( vec3 color ) {
	color *= toneMappingExposure;
	return saturate( color / ( vec3( 1.0 ) + color ) );
}
vec3 OptimizedCineonToneMapping( vec3 color ) {
	color *= toneMappingExposure;
	color = max( vec3( 0.0 ), color - 0.004 );
	return pow( ( color * ( 6.2 * color + 0.5 ) ) / ( color * ( 6.2 * color + 1.7 ) + 0.06 ), vec3( 2.2 ) );
}
vec3 RRTAndODTFit( vec3 v ) {
	vec3 a = v * ( v + 0.0245786 ) - 0.000090537;
	vec3 b = v * ( 0.983729 * v + 0.4329510 ) + 0.238081;
	return a / b;
}
vec3 ACESFilmicToneMapping( vec3 color ) {
	const mat3 ACESInputMat = mat3(
		vec3( 0.59719, 0.07600, 0.02840 ),		vec3( 0.35458, 0.90834, 0.13383 ),
		vec3( 0.04823, 0.01566, 0.83777 )
	);
	const mat3 ACESOutputMat = mat3(
		vec3(  1.60475, -0.10208, -0.00327 ),		vec3( -0.53108,  1.10813, -0.07276 ),
		vec3( -0.07367, -0.00605,  1.07602 )
	);
	color *= toneMappingExposure / 0.6;
	color = ACESInputMat * color;
	color = RRTAndODTFit( color );
	color = ACESOutputMat * color;
	return saturate( color );
}
vec3 CustomToneMapping( vec3 color ) { return color; }`,s1=`#ifdef USE_TRANSMISSION
	float transmissionAlpha = 1.0;
	float transmissionFactor = transmission;
	float thicknessFactor = thickness;
	#ifdef USE_TRANSMISSIONMAP
		transmissionFactor *= texture2D( transmissionMap, vUv ).r;
	#endif
	#ifdef USE_THICKNESSMAP
		thicknessFactor *= texture2D( thicknessMap, vUv ).g;
	#endif
	vec3 pos = vWorldPosition;
	vec3 v = normalize( cameraPosition - pos );
	vec3 n = inverseTransformDirection( normal, viewMatrix );
	vec4 transmission = getIBLVolumeRefraction(
		n, v, roughnessFactor, material.diffuseColor, material.specularColor, material.specularF90,
		pos, modelMatrix, viewMatrix, projectionMatrix, ior, thicknessFactor,
		attenuationColor, attenuationDistance );
	totalDiffuse = mix( totalDiffuse, transmission.rgb, transmissionFactor );
	transmissionAlpha = mix( transmissionAlpha, transmission.a, transmissionFactor );
#endif`,o1=`#ifdef USE_TRANSMISSION
	uniform float transmission;
	uniform float thickness;
	uniform float attenuationDistance;
	uniform vec3 attenuationColor;
	#ifdef USE_TRANSMISSIONMAP
		uniform sampler2D transmissionMap;
	#endif
	#ifdef USE_THICKNESSMAP
		uniform sampler2D thicknessMap;
	#endif
	uniform vec2 transmissionSamplerSize;
	uniform sampler2D transmissionSamplerMap;
	uniform mat4 modelMatrix;
	uniform mat4 projectionMatrix;
	varying vec3 vWorldPosition;
	vec3 getVolumeTransmissionRay( const in vec3 n, const in vec3 v, const in float thickness, const in float ior, const in mat4 modelMatrix ) {
		vec3 refractionVector = refract( - v, normalize( n ), 1.0 / ior );
		vec3 modelScale;
		modelScale.x = length( vec3( modelMatrix[ 0 ].xyz ) );
		modelScale.y = length( vec3( modelMatrix[ 1 ].xyz ) );
		modelScale.z = length( vec3( modelMatrix[ 2 ].xyz ) );
		return normalize( refractionVector ) * thickness * modelScale;
	}
	float applyIorToRoughness( const in float roughness, const in float ior ) {
		return roughness * clamp( ior * 2.0 - 2.0, 0.0, 1.0 );
	}
	vec4 getTransmissionSample( const in vec2 fragCoord, const in float roughness, const in float ior ) {
		float framebufferLod = log2( transmissionSamplerSize.x ) * applyIorToRoughness( roughness, ior );
		#ifdef TEXTURE_LOD_EXT
			return texture2DLodEXT( transmissionSamplerMap, fragCoord.xy, framebufferLod );
		#else
			return texture2D( transmissionSamplerMap, fragCoord.xy, framebufferLod );
		#endif
	}
	vec3 applyVolumeAttenuation( const in vec3 radiance, const in float transmissionDistance, const in vec3 attenuationColor, const in float attenuationDistance ) {
		if ( attenuationDistance == 0.0 ) {
			return radiance;
		} else {
			vec3 attenuationCoefficient = -log( attenuationColor ) / attenuationDistance;
			vec3 transmittance = exp( - attenuationCoefficient * transmissionDistance );			return transmittance * radiance;
		}
	}
	vec4 getIBLVolumeRefraction( const in vec3 n, const in vec3 v, const in float roughness, const in vec3 diffuseColor,
		const in vec3 specularColor, const in float specularF90, const in vec3 position, const in mat4 modelMatrix,
		const in mat4 viewMatrix, const in mat4 projMatrix, const in float ior, const in float thickness,
		const in vec3 attenuationColor, const in float attenuationDistance ) {
		vec3 transmissionRay = getVolumeTransmissionRay( n, v, thickness, ior, modelMatrix );
		vec3 refractedRayExit = position + transmissionRay;
		vec4 ndcPos = projMatrix * viewMatrix * vec4( refractedRayExit, 1.0 );
		vec2 refractionCoords = ndcPos.xy / ndcPos.w;
		refractionCoords += 1.0;
		refractionCoords /= 2.0;
		vec4 transmittedLight = getTransmissionSample( refractionCoords, roughness, ior );
		vec3 attenuatedColor = applyVolumeAttenuation( transmittedLight.rgb, length( transmissionRay ), attenuationColor, attenuationDistance );
		vec3 F = EnvironmentBRDF( n, v, specularColor, specularF90, roughness );
		return vec4( ( 1.0 - F ) * attenuatedColor * diffuseColor, transmittedLight.a );
	}
#endif`,a1=`#if ( defined( USE_UV ) && ! defined( UVS_VERTEX_ONLY ) )
	varying vec2 vUv;
#endif`,l1=`#ifdef USE_UV
	#ifdef UVS_VERTEX_ONLY
		vec2 vUv;
	#else
		varying vec2 vUv;
	#endif
	uniform mat3 uvTransform;
#endif`,c1=`#ifdef USE_UV
	vUv = ( uvTransform * vec3( uv, 1 ) ).xy;
#endif`,u1=`#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )
	varying vec2 vUv2;
#endif`,h1=`#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )
	attribute vec2 uv2;
	varying vec2 vUv2;
	uniform mat3 uv2Transform;
#endif`,f1=`#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )
	vUv2 = ( uv2Transform * vec3( uv2, 1 ) ).xy;
#endif`,d1=`#if defined( USE_ENVMAP ) || defined( DISTANCE ) || defined ( USE_SHADOWMAP ) || defined ( USE_TRANSMISSION )
	vec4 worldPosition = vec4( transformed, 1.0 );
	#ifdef USE_INSTANCING
		worldPosition = instanceMatrix * worldPosition;
	#endif
	worldPosition = modelMatrix * worldPosition;
#endif`,p1=`varying vec2 vUv;
uniform mat3 uvTransform;
void main() {
	vUv = ( uvTransform * vec3( uv, 1 ) ).xy;
	gl_Position = vec4( position.xy, 1.0, 1.0 );
}`,m1=`uniform sampler2D t2D;
varying vec2 vUv;
void main() {
	gl_FragColor = texture2D( t2D, vUv );
	#include <tonemapping_fragment>
	#include <encodings_fragment>
}`,g1=`varying vec3 vWorldDirection;
#include <common>
void main() {
	vWorldDirection = transformDirection( position, modelMatrix );
	#include <begin_vertex>
	#include <project_vertex>
	gl_Position.z = gl_Position.w;
}`,x1=`#include <envmap_common_pars_fragment>
uniform float opacity;
varying vec3 vWorldDirection;
#include <cube_uv_reflection_fragment>
void main() {
	vec3 vReflect = vWorldDirection;
	#include <envmap_fragment>
	gl_FragColor = envColor;
	gl_FragColor.a *= opacity;
	#include <tonemapping_fragment>
	#include <encodings_fragment>
}`,y1=`#include <common>
#include <uv_pars_vertex>
#include <displacementmap_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
varying vec2 vHighPrecisionZW;
void main() {
	#include <uv_vertex>
	#include <skinbase_vertex>
	#ifdef USE_DISPLACEMENTMAP
		#include <beginnormal_vertex>
		#include <morphnormal_vertex>
		#include <skinnormal_vertex>
	#endif
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	vHighPrecisionZW = gl_Position.zw;
}`,v1=`#if DEPTH_PACKING == 3200
	uniform float opacity;
#endif
#include <common>
#include <packing>
#include <uv_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
varying vec2 vHighPrecisionZW;
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( 1.0 );
	#if DEPTH_PACKING == 3200
		diffuseColor.a = opacity;
	#endif
	#include <map_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <logdepthbuf_fragment>
	float fragCoordZ = 0.5 * vHighPrecisionZW[0] / vHighPrecisionZW[1] + 0.5;
	#if DEPTH_PACKING == 3200
		gl_FragColor = vec4( vec3( 1.0 - fragCoordZ ), opacity );
	#elif DEPTH_PACKING == 3201
		gl_FragColor = packDepthToRGBA( fragCoordZ );
	#endif
}`,_1=`#define DISTANCE
varying vec3 vWorldPosition;
#include <common>
#include <uv_pars_vertex>
#include <displacementmap_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <skinbase_vertex>
	#ifdef USE_DISPLACEMENTMAP
		#include <beginnormal_vertex>
		#include <morphnormal_vertex>
		#include <skinnormal_vertex>
	#endif
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <worldpos_vertex>
	#include <clipping_planes_vertex>
	vWorldPosition = worldPosition.xyz;
}`,w1=`#define DISTANCE
uniform vec3 referencePosition;
uniform float nearDistance;
uniform float farDistance;
varying vec3 vWorldPosition;
#include <common>
#include <packing>
#include <uv_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <clipping_planes_pars_fragment>
void main () {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( 1.0 );
	#include <map_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	float dist = length( vWorldPosition - referencePosition );
	dist = ( dist - nearDistance ) / ( farDistance - nearDistance );
	dist = saturate( dist );
	gl_FragColor = packDepthToRGBA( dist );
}`,M1=`varying vec3 vWorldDirection;
#include <common>
void main() {
	vWorldDirection = transformDirection( position, modelMatrix );
	#include <begin_vertex>
	#include <project_vertex>
}`,b1=`uniform sampler2D tEquirect;
varying vec3 vWorldDirection;
#include <common>
void main() {
	vec3 direction = normalize( vWorldDirection );
	vec2 sampleUV = equirectUv( direction );
	gl_FragColor = texture2D( tEquirect, sampleUV );
	#include <tonemapping_fragment>
	#include <encodings_fragment>
}`,S1=`uniform float scale;
attribute float lineDistance;
varying float vLineDistance;
#include <common>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <morphtarget_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	vLineDistance = scale * lineDistance;
	#include <color_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	#include <fog_vertex>
}`,E1=`uniform vec3 diffuse;
uniform float opacity;
uniform float dashSize;
uniform float totalSize;
varying float vLineDistance;
#include <common>
#include <color_pars_fragment>
#include <fog_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	if ( mod( vLineDistance, totalSize ) > dashSize ) {
		discard;
	}
	vec3 outgoingLight = vec3( 0.0 );
	vec4 diffuseColor = vec4( diffuse, opacity );
	#include <logdepthbuf_fragment>
	#include <color_fragment>
	outgoingLight = diffuseColor.rgb;
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
}`,T1=`#include <common>
#include <uv_pars_vertex>
#include <uv2_pars_vertex>
#include <envmap_pars_vertex>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <uv2_vertex>
	#include <color_vertex>
	#if defined ( USE_ENVMAP ) || defined ( USE_SKINNING )
		#include <beginnormal_vertex>
		#include <morphnormal_vertex>
		#include <skinbase_vertex>
		#include <skinnormal_vertex>
		#include <defaultnormal_vertex>
	#endif
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	#include <worldpos_vertex>
	#include <envmap_vertex>
	#include <fog_vertex>
}`,A1=`uniform vec3 diffuse;
uniform float opacity;
#ifndef FLAT_SHADED
	varying vec3 vNormal;
#endif
#include <common>
#include <dithering_pars_fragment>
#include <color_pars_fragment>
#include <uv_pars_fragment>
#include <uv2_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <aomap_pars_fragment>
#include <lightmap_pars_fragment>
#include <envmap_common_pars_fragment>
#include <envmap_pars_fragment>
#include <cube_uv_reflection_fragment>
#include <fog_pars_fragment>
#include <specularmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( diffuse, opacity );
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <color_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <specularmap_fragment>
	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
	#ifdef USE_LIGHTMAP
		vec4 lightMapTexel= texture2D( lightMap, vUv2 );
		reflectedLight.indirectDiffuse += lightMapTexel.rgb * lightMapIntensity;
	#else
		reflectedLight.indirectDiffuse += vec3( 1.0 );
	#endif
	#include <aomap_fragment>
	reflectedLight.indirectDiffuse *= diffuseColor.rgb;
	vec3 outgoingLight = reflectedLight.indirectDiffuse;
	#include <envmap_fragment>
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
	#include <dithering_fragment>
}`,C1=`#define LAMBERT
varying vec3 vLightFront;
varying vec3 vIndirectFront;
#ifdef DOUBLE_SIDED
	varying vec3 vLightBack;
	varying vec3 vIndirectBack;
#endif
#include <common>
#include <uv_pars_vertex>
#include <uv2_pars_vertex>
#include <envmap_pars_vertex>
#include <bsdfs>
#include <lights_pars_begin>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <shadowmap_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <uv2_vertex>
	#include <color_vertex>
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	#include <worldpos_vertex>
	#include <envmap_vertex>
	#include <lights_lambert_vertex>
	#include <shadowmap_vertex>
	#include <fog_vertex>
}`,R1=`uniform vec3 diffuse;
uniform vec3 emissive;
uniform float opacity;
varying vec3 vLightFront;
varying vec3 vIndirectFront;
#ifdef DOUBLE_SIDED
	varying vec3 vLightBack;
	varying vec3 vIndirectBack;
#endif
#include <common>
#include <packing>
#include <dithering_pars_fragment>
#include <color_pars_fragment>
#include <uv_pars_fragment>
#include <uv2_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <aomap_pars_fragment>
#include <lightmap_pars_fragment>
#include <emissivemap_pars_fragment>
#include <envmap_common_pars_fragment>
#include <envmap_pars_fragment>
#include <cube_uv_reflection_fragment>
#include <bsdfs>
#include <lights_pars_begin>
#include <fog_pars_fragment>
#include <shadowmap_pars_fragment>
#include <shadowmask_pars_fragment>
#include <specularmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( diffuse, opacity );
	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
	vec3 totalEmissiveRadiance = emissive;
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <color_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <specularmap_fragment>
	#include <emissivemap_fragment>
	#ifdef DOUBLE_SIDED
		reflectedLight.indirectDiffuse += ( gl_FrontFacing ) ? vIndirectFront : vIndirectBack;
	#else
		reflectedLight.indirectDiffuse += vIndirectFront;
	#endif
	#include <lightmap_fragment>
	reflectedLight.indirectDiffuse *= BRDF_Lambert( diffuseColor.rgb );
	#ifdef DOUBLE_SIDED
		reflectedLight.directDiffuse = ( gl_FrontFacing ) ? vLightFront : vLightBack;
	#else
		reflectedLight.directDiffuse = vLightFront;
	#endif
	reflectedLight.directDiffuse *= BRDF_Lambert( diffuseColor.rgb ) * getShadowMask();
	#include <aomap_fragment>
	vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;
	#include <envmap_fragment>
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
	#include <dithering_fragment>
}`,L1=`#define MATCAP
varying vec3 vViewPosition;
#include <common>
#include <uv_pars_vertex>
#include <color_pars_vertex>
#include <displacementmap_pars_vertex>
#include <fog_pars_vertex>
#include <normal_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <color_vertex>
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <normal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	#include <fog_vertex>
	vViewPosition = - mvPosition.xyz;
}`,P1=`#define MATCAP
uniform vec3 diffuse;
uniform float opacity;
uniform sampler2D matcap;
varying vec3 vViewPosition;
#include <common>
#include <dithering_pars_fragment>
#include <color_pars_fragment>
#include <uv_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <fog_pars_fragment>
#include <normal_pars_fragment>
#include <bumpmap_pars_fragment>
#include <normalmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( diffuse, opacity );
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <color_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <normal_fragment_begin>
	#include <normal_fragment_maps>
	vec3 viewDir = normalize( vViewPosition );
	vec3 x = normalize( vec3( viewDir.z, 0.0, - viewDir.x ) );
	vec3 y = cross( viewDir, x );
	vec2 uv = vec2( dot( x, normal ), dot( y, normal ) ) * 0.495 + 0.5;
	#ifdef USE_MATCAP
		vec4 matcapColor = texture2D( matcap, uv );
	#else
		vec4 matcapColor = vec4( vec3( mix( 0.2, 0.8, uv.y ) ), 1.0 );
	#endif
	vec3 outgoingLight = diffuseColor.rgb * matcapColor.rgb;
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
	#include <dithering_fragment>
}`,D1=`#define NORMAL
#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )
	varying vec3 vViewPosition;
#endif
#include <common>
#include <uv_pars_vertex>
#include <displacementmap_pars_vertex>
#include <normal_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <normal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )
	vViewPosition = - mvPosition.xyz;
#endif
}`,I1=`#define NORMAL
uniform float opacity;
#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )
	varying vec3 vViewPosition;
#endif
#include <packing>
#include <uv_pars_fragment>
#include <normal_pars_fragment>
#include <bumpmap_pars_fragment>
#include <normalmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	#include <logdepthbuf_fragment>
	#include <normal_fragment_begin>
	#include <normal_fragment_maps>
	gl_FragColor = vec4( packNormalToRGB( normal ), opacity );
}`,N1=`#define PHONG
varying vec3 vViewPosition;
#include <common>
#include <uv_pars_vertex>
#include <uv2_pars_vertex>
#include <displacementmap_pars_vertex>
#include <envmap_pars_vertex>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <normal_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <shadowmap_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <uv2_vertex>
	#include <color_vertex>
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <normal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	vViewPosition = - mvPosition.xyz;
	#include <worldpos_vertex>
	#include <envmap_vertex>
	#include <shadowmap_vertex>
	#include <fog_vertex>
}`,F1=`#define PHONG
uniform vec3 diffuse;
uniform vec3 emissive;
uniform vec3 specular;
uniform float shininess;
uniform float opacity;
#include <common>
#include <packing>
#include <dithering_pars_fragment>
#include <color_pars_fragment>
#include <uv_pars_fragment>
#include <uv2_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <aomap_pars_fragment>
#include <lightmap_pars_fragment>
#include <emissivemap_pars_fragment>
#include <envmap_common_pars_fragment>
#include <envmap_pars_fragment>
#include <cube_uv_reflection_fragment>
#include <fog_pars_fragment>
#include <bsdfs>
#include <lights_pars_begin>
#include <normal_pars_fragment>
#include <lights_phong_pars_fragment>
#include <shadowmap_pars_fragment>
#include <bumpmap_pars_fragment>
#include <normalmap_pars_fragment>
#include <specularmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( diffuse, opacity );
	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
	vec3 totalEmissiveRadiance = emissive;
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <color_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <specularmap_fragment>
	#include <normal_fragment_begin>
	#include <normal_fragment_maps>
	#include <emissivemap_fragment>
	#include <lights_phong_fragment>
	#include <lights_fragment_begin>
	#include <lights_fragment_maps>
	#include <lights_fragment_end>
	#include <aomap_fragment>
	vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance;
	#include <envmap_fragment>
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
	#include <dithering_fragment>
}`,z1=`#define STANDARD
varying vec3 vViewPosition;
#ifdef USE_TRANSMISSION
	varying vec3 vWorldPosition;
#endif
#include <common>
#include <uv_pars_vertex>
#include <uv2_pars_vertex>
#include <displacementmap_pars_vertex>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <normal_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <shadowmap_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <uv2_vertex>
	#include <color_vertex>
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <normal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	vViewPosition = - mvPosition.xyz;
	#include <worldpos_vertex>
	#include <shadowmap_vertex>
	#include <fog_vertex>
#ifdef USE_TRANSMISSION
	vWorldPosition = worldPosition.xyz;
#endif
}`,U1=`#define STANDARD
#ifdef PHYSICAL
	#define IOR
	#define SPECULAR
#endif
uniform vec3 diffuse;
uniform vec3 emissive;
uniform float roughness;
uniform float metalness;
uniform float opacity;
#ifdef IOR
	uniform float ior;
#endif
#ifdef SPECULAR
	uniform float specularIntensity;
	uniform vec3 specularColor;
	#ifdef USE_SPECULARINTENSITYMAP
		uniform sampler2D specularIntensityMap;
	#endif
	#ifdef USE_SPECULARCOLORMAP
		uniform sampler2D specularColorMap;
	#endif
#endif
#ifdef USE_CLEARCOAT
	uniform float clearcoat;
	uniform float clearcoatRoughness;
#endif
#ifdef USE_SHEEN
	uniform vec3 sheenColor;
	uniform float sheenRoughness;
	#ifdef USE_SHEENCOLORMAP
		uniform sampler2D sheenColorMap;
	#endif
	#ifdef USE_SHEENROUGHNESSMAP
		uniform sampler2D sheenRoughnessMap;
	#endif
#endif
varying vec3 vViewPosition;
#include <common>
#include <packing>
#include <dithering_pars_fragment>
#include <color_pars_fragment>
#include <uv_pars_fragment>
#include <uv2_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <aomap_pars_fragment>
#include <lightmap_pars_fragment>
#include <emissivemap_pars_fragment>
#include <bsdfs>
#include <cube_uv_reflection_fragment>
#include <envmap_common_pars_fragment>
#include <envmap_physical_pars_fragment>
#include <fog_pars_fragment>
#include <lights_pars_begin>
#include <normal_pars_fragment>
#include <lights_physical_pars_fragment>
#include <transmission_pars_fragment>
#include <shadowmap_pars_fragment>
#include <bumpmap_pars_fragment>
#include <normalmap_pars_fragment>
#include <clearcoat_pars_fragment>
#include <roughnessmap_pars_fragment>
#include <metalnessmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( diffuse, opacity );
	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
	vec3 totalEmissiveRadiance = emissive;
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <color_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <roughnessmap_fragment>
	#include <metalnessmap_fragment>
	#include <normal_fragment_begin>
	#include <normal_fragment_maps>
	#include <clearcoat_normal_fragment_begin>
	#include <clearcoat_normal_fragment_maps>
	#include <emissivemap_fragment>
	#include <lights_physical_fragment>
	#include <lights_fragment_begin>
	#include <lights_fragment_maps>
	#include <lights_fragment_end>
	#include <aomap_fragment>
	vec3 totalDiffuse = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse;
	vec3 totalSpecular = reflectedLight.directSpecular + reflectedLight.indirectSpecular;
	#include <transmission_fragment>
	vec3 outgoingLight = totalDiffuse + totalSpecular + totalEmissiveRadiance;
	#ifdef USE_SHEEN
		float sheenEnergyComp = 1.0 - 0.157 * max3( material.sheenColor );
		outgoingLight = outgoingLight * sheenEnergyComp + sheenSpecular;
	#endif
	#ifdef USE_CLEARCOAT
		float dotNVcc = saturate( dot( geometry.clearcoatNormal, geometry.viewDir ) );
		vec3 Fcc = F_Schlick( material.clearcoatF0, material.clearcoatF90, dotNVcc );
		outgoingLight = outgoingLight * ( 1.0 - material.clearcoat * Fcc ) + clearcoatSpecular * material.clearcoat;
	#endif
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
	#include <dithering_fragment>
}`,B1=`#define TOON
varying vec3 vViewPosition;
#include <common>
#include <uv_pars_vertex>
#include <uv2_pars_vertex>
#include <displacementmap_pars_vertex>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <normal_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <shadowmap_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <uv2_vertex>
	#include <color_vertex>
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <normal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	vViewPosition = - mvPosition.xyz;
	#include <worldpos_vertex>
	#include <shadowmap_vertex>
	#include <fog_vertex>
}`,O1=`#define TOON
uniform vec3 diffuse;
uniform vec3 emissive;
uniform float opacity;
#include <common>
#include <packing>
#include <dithering_pars_fragment>
#include <color_pars_fragment>
#include <uv_pars_fragment>
#include <uv2_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <aomap_pars_fragment>
#include <lightmap_pars_fragment>
#include <emissivemap_pars_fragment>
#include <gradientmap_pars_fragment>
#include <fog_pars_fragment>
#include <bsdfs>
#include <lights_pars_begin>
#include <normal_pars_fragment>
#include <lights_toon_pars_fragment>
#include <shadowmap_pars_fragment>
#include <bumpmap_pars_fragment>
#include <normalmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( diffuse, opacity );
	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
	vec3 totalEmissiveRadiance = emissive;
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <color_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <normal_fragment_begin>
	#include <normal_fragment_maps>
	#include <emissivemap_fragment>
	#include <lights_toon_fragment>
	#include <lights_fragment_begin>
	#include <lights_fragment_maps>
	#include <lights_fragment_end>
	#include <aomap_fragment>
	vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
	#include <dithering_fragment>
}`,k1=`uniform float size;
uniform float scale;
#include <common>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <morphtarget_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <color_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <project_vertex>
	gl_PointSize = size;
	#ifdef USE_SIZEATTENUATION
		bool isPerspective = isPerspectiveMatrix( projectionMatrix );
		if ( isPerspective ) gl_PointSize *= ( scale / - mvPosition.z );
	#endif
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	#include <worldpos_vertex>
	#include <fog_vertex>
}`,H1=`uniform vec3 diffuse;
uniform float opacity;
#include <common>
#include <color_pars_fragment>
#include <map_particle_pars_fragment>
#include <alphatest_pars_fragment>
#include <fog_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec3 outgoingLight = vec3( 0.0 );
	vec4 diffuseColor = vec4( diffuse, opacity );
	#include <logdepthbuf_fragment>
	#include <map_particle_fragment>
	#include <color_fragment>
	#include <alphatest_fragment>
	outgoingLight = diffuseColor.rgb;
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
}`,V1=`#include <common>
#include <fog_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <shadowmap_pars_vertex>
void main() {
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <project_vertex>
	#include <worldpos_vertex>
	#include <shadowmap_vertex>
	#include <fog_vertex>
}`,G1=`uniform vec3 color;
uniform float opacity;
#include <common>
#include <packing>
#include <fog_pars_fragment>
#include <bsdfs>
#include <lights_pars_begin>
#include <shadowmap_pars_fragment>
#include <shadowmask_pars_fragment>
void main() {
	gl_FragColor = vec4( color, opacity * ( 1.0 - getShadowMask() ) );
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
}`,W1=`uniform float rotation;
uniform vec2 center;
#include <common>
#include <uv_pars_vertex>
#include <fog_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	vec4 mvPosition = modelViewMatrix * vec4( 0.0, 0.0, 0.0, 1.0 );
	vec2 scale;
	scale.x = length( vec3( modelMatrix[ 0 ].x, modelMatrix[ 0 ].y, modelMatrix[ 0 ].z ) );
	scale.y = length( vec3( modelMatrix[ 1 ].x, modelMatrix[ 1 ].y, modelMatrix[ 1 ].z ) );
	#ifndef USE_SIZEATTENUATION
		bool isPerspective = isPerspectiveMatrix( projectionMatrix );
		if ( isPerspective ) scale *= - mvPosition.z;
	#endif
	vec2 alignedPosition = ( position.xy - ( center - vec2( 0.5 ) ) ) * scale;
	vec2 rotatedPosition;
	rotatedPosition.x = cos( rotation ) * alignedPosition.x - sin( rotation ) * alignedPosition.y;
	rotatedPosition.y = sin( rotation ) * alignedPosition.x + cos( rotation ) * alignedPosition.y;
	mvPosition.xy += rotatedPosition;
	gl_Position = projectionMatrix * mvPosition;
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	#include <fog_vertex>
}`,q1=`uniform vec3 diffuse;
uniform float opacity;
#include <common>
#include <uv_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <fog_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec3 outgoingLight = vec3( 0.0 );
	vec4 diffuseColor = vec4( diffuse, opacity );
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	outgoingLight = diffuseColor.rgb;
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
}`,Pt={alphamap_fragment:_M,alphamap_pars_fragment:wM,alphatest_fragment:MM,alphatest_pars_fragment:bM,aomap_fragment:SM,aomap_pars_fragment:EM,begin_vertex:TM,beginnormal_vertex:AM,bsdfs:CM,bumpmap_pars_fragment:RM,clipping_planes_fragment:LM,clipping_planes_pars_fragment:PM,clipping_planes_pars_vertex:DM,clipping_planes_vertex:IM,color_fragment:NM,color_pars_fragment:FM,color_pars_vertex:zM,color_vertex:UM,common:BM,cube_uv_reflection_fragment:OM,defaultnormal_vertex:kM,displacementmap_pars_vertex:HM,displacementmap_vertex:VM,emissivemap_fragment:GM,emissivemap_pars_fragment:WM,encodings_fragment:qM,encodings_pars_fragment:XM,envmap_fragment:YM,envmap_common_pars_fragment:ZM,envmap_pars_fragment:JM,envmap_pars_vertex:$M,envmap_physical_pars_fragment:ab,envmap_vertex:KM,fog_vertex:QM,fog_pars_vertex:jM,fog_fragment:tb,fog_pars_fragment:eb,gradientmap_pars_fragment:nb,lightmap_fragment:ib,lightmap_pars_fragment:rb,lights_lambert_vertex:sb,lights_pars_begin:ob,lights_toon_fragment:lb,lights_toon_pars_fragment:cb,lights_phong_fragment:ub,lights_phong_pars_fragment:hb,lights_physical_fragment:fb,lights_physical_pars_fragment:db,lights_fragment_begin:pb,lights_fragment_maps:mb,lights_fragment_end:gb,logdepthbuf_fragment:xb,logdepthbuf_pars_fragment:yb,logdepthbuf_pars_vertex:vb,logdepthbuf_vertex:_b,map_fragment:wb,map_pars_fragment:Mb,map_particle_fragment:bb,map_particle_pars_fragment:Sb,metalnessmap_fragment:Eb,metalnessmap_pars_fragment:Tb,morphnormal_vertex:Ab,morphtarget_pars_vertex:Cb,morphtarget_vertex:Rb,normal_fragment_begin:Lb,normal_fragment_maps:Pb,normal_pars_fragment:Db,normal_pars_vertex:Ib,normal_vertex:Nb,normalmap_pars_fragment:Fb,clearcoat_normal_fragment_begin:zb,clearcoat_normal_fragment_maps:Ub,clearcoat_pars_fragment:Bb,output_fragment:Ob,packing:kb,premultiplied_alpha_fragment:Hb,project_vertex:Vb,dithering_fragment:Gb,dithering_pars_fragment:Wb,roughnessmap_fragment:qb,roughnessmap_pars_fragment:Xb,shadowmap_pars_fragment:Yb,shadowmap_pars_vertex:Zb,shadowmap_vertex:Jb,shadowmask_pars_fragment:$b,skinbase_vertex:Kb,skinning_pars_vertex:Qb,skinning_vertex:jb,skinnormal_vertex:t1,specularmap_fragment:e1,specularmap_pars_fragment:n1,tonemapping_fragment:i1,tonemapping_pars_fragment:r1,transmission_fragment:s1,transmission_pars_fragment:o1,uv_pars_fragment:a1,uv_pars_vertex:l1,uv_vertex:c1,uv2_pars_fragment:u1,uv2_pars_vertex:h1,uv2_vertex:f1,worldpos_vertex:d1,background_vert:p1,background_frag:m1,cube_vert:g1,cube_frag:x1,depth_vert:y1,depth_frag:v1,distanceRGBA_vert:_1,distanceRGBA_frag:w1,equirect_vert:M1,equirect_frag:b1,linedashed_vert:S1,linedashed_frag:E1,meshbasic_vert:T1,meshbasic_frag:A1,meshlambert_vert:C1,meshlambert_frag:R1,meshmatcap_vert:L1,meshmatcap_frag:P1,meshnormal_vert:D1,meshnormal_frag:I1,meshphong_vert:N1,meshphong_frag:F1,meshphysical_vert:z1,meshphysical_frag:U1,meshtoon_vert:B1,meshtoon_frag:O1,points_vert:k1,points_frag:H1,shadow_vert:V1,shadow_frag:G1,sprite_vert:W1,sprite_frag:q1},ot={common:{diffuse:{value:new ft(16777215)},opacity:{value:1},map:{value:null},uvTransform:{value:new de},uv2Transform:{value:new de},alphaMap:{value:null},alphaTest:{value:0}},specularmap:{specularMap:{value:null}},envmap:{envMap:{value:null},flipEnvMap:{value:-1},reflectivity:{value:1},ior:{value:1.5},refractionRatio:{value:.98}},aomap:{aoMap:{value:null},aoMapIntensity:{value:1}},lightmap:{lightMap:{value:null},lightMapIntensity:{value:1}},emissivemap:{emissiveMap:{value:null}},bumpmap:{bumpMap:{value:null},bumpScale:{value:1}},normalmap:{normalMap:{value:null},normalScale:{value:new K(1,1)}},displacementmap:{displacementMap:{value:null},displacementScale:{value:1},displacementBias:{value:0}},roughnessmap:{roughnessMap:{value:null}},metalnessmap:{metalnessMap:{value:null}},gradientmap:{gradientMap:{value:null}},fog:{fogDensity:{value:25e-5},fogNear:{value:1},fogFar:{value:2e3},fogColor:{value:new ft(16777215)}},lights:{ambientLightColor:{value:[]},lightProbe:{value:[]},directionalLights:{value:[],properties:{direction:{},color:{}}},directionalLightShadows:{value:[],properties:{shadowBias:{},shadowNormalBias:{},shadowRadius:{},shadowMapSize:{}}},directionalShadowMap:{value:[]},directionalShadowMatrix:{value:[]},spotLights:{value:[],properties:{color:{},position:{},direction:{},distance:{},coneCos:{},penumbraCos:{},decay:{}}},spotLightShadows:{value:[],properties:{shadowBias:{},shadowNormalBias:{},shadowRadius:{},shadowMapSize:{}}},spotShadowMap:{value:[]},spotShadowMatrix:{value:[]},pointLights:{value:[],properties:{color:{},position:{},decay:{},distance:{}}},pointLightShadows:{value:[],properties:{shadowBias:{},shadowNormalBias:{},shadowRadius:{},shadowMapSize:{},shadowCameraNear:{},shadowCameraFar:{}}},pointShadowMap:{value:[]},pointShadowMatrix:{value:[]},hemisphereLights:{value:[],properties:{direction:{},skyColor:{},groundColor:{}}},rectAreaLights:{value:[],properties:{color:{},position:{},width:{},height:{}}},ltc_1:{value:null},ltc_2:{value:null}},points:{diffuse:{value:new ft(16777215)},opacity:{value:1},size:{value:1},scale:{value:1},map:{value:null},alphaMap:{value:null},alphaTest:{value:0},uvTransform:{value:new de}},sprite:{diffuse:{value:new ft(16777215)},opacity:{value:1},center:{value:new K(.5,.5)},rotation:{value:0},map:{value:null},alphaMap:{value:null},alphaTest:{value:0},uvTransform:{value:new de}}},fn={basic:{uniforms:Me([ot.common,ot.specularmap,ot.envmap,ot.aomap,ot.lightmap,ot.fog]),vertexShader:Pt.meshbasic_vert,fragmentShader:Pt.meshbasic_frag},lambert:{uniforms:Me([ot.common,ot.specularmap,ot.envmap,ot.aomap,ot.lightmap,ot.emissivemap,ot.fog,ot.lights,{emissive:{value:new ft(0)}}]),vertexShader:Pt.meshlambert_vert,fragmentShader:Pt.meshlambert_frag},phong:{uniforms:Me([ot.common,ot.specularmap,ot.envmap,ot.aomap,ot.lightmap,ot.emissivemap,ot.bumpmap,ot.normalmap,ot.displacementmap,ot.fog,ot.lights,{emissive:{value:new ft(0)},specular:{value:new ft(1118481)},shininess:{value:30}}]),vertexShader:Pt.meshphong_vert,fragmentShader:Pt.meshphong_frag},standard:{uniforms:Me([ot.common,ot.envmap,ot.aomap,ot.lightmap,ot.emissivemap,ot.bumpmap,ot.normalmap,ot.displacementmap,ot.roughnessmap,ot.metalnessmap,ot.fog,ot.lights,{emissive:{value:new ft(0)},roughness:{value:1},metalness:{value:0},envMapIntensity:{value:1}}]),vertexShader:Pt.meshphysical_vert,fragmentShader:Pt.meshphysical_frag},toon:{uniforms:Me([ot.common,ot.aomap,ot.lightmap,ot.emissivemap,ot.bumpmap,ot.normalmap,ot.displacementmap,ot.gradientmap,ot.fog,ot.lights,{emissive:{value:new ft(0)}}]),vertexShader:Pt.meshtoon_vert,fragmentShader:Pt.meshtoon_frag},matcap:{uniforms:Me([ot.common,ot.bumpmap,ot.normalmap,ot.displacementmap,ot.fog,{matcap:{value:null}}]),vertexShader:Pt.meshmatcap_vert,fragmentShader:Pt.meshmatcap_frag},points:{uniforms:Me([ot.points,ot.fog]),vertexShader:Pt.points_vert,fragmentShader:Pt.points_frag},dashed:{uniforms:Me([ot.common,ot.fog,{scale:{value:1},dashSize:{value:1},totalSize:{value:2}}]),vertexShader:Pt.linedashed_vert,fragmentShader:Pt.linedashed_frag},depth:{uniforms:Me([ot.common,ot.displacementmap]),vertexShader:Pt.depth_vert,fragmentShader:Pt.depth_frag},normal:{uniforms:Me([ot.common,ot.bumpmap,ot.normalmap,ot.displacementmap,{opacity:{value:1}}]),vertexShader:Pt.meshnormal_vert,fragmentShader:Pt.meshnormal_frag},sprite:{uniforms:Me([ot.sprite,ot.fog]),vertexShader:Pt.sprite_vert,fragmentShader:Pt.sprite_frag},background:{uniforms:{uvTransform:{value:new de},t2D:{value:null}},vertexShader:Pt.background_vert,fragmentShader:Pt.background_frag},cube:{uniforms:Me([ot.envmap,{opacity:{value:1}}]),vertexShader:Pt.cube_vert,fragmentShader:Pt.cube_frag},equirect:{uniforms:{tEquirect:{value:null}},vertexShader:Pt.equirect_vert,fragmentShader:Pt.equirect_frag},distanceRGBA:{uniforms:Me([ot.common,ot.displacementmap,{referencePosition:{value:new T},nearDistance:{value:1},farDistance:{value:1e3}}]),vertexShader:Pt.distanceRGBA_vert,fragmentShader:Pt.distanceRGBA_frag},shadow:{uniforms:Me([ot.lights,ot.fog,{color:{value:new ft(0)},opacity:{value:1}}]),vertexShader:Pt.shadow_vert,fragmentShader:Pt.shadow_frag}};fn.physical={uniforms:Me([fn.standard.uniforms,{clearcoat:{value:0},clearcoatMap:{value:null},clearcoatRoughness:{value:0},clearcoatRoughnessMap:{value:null},clearcoatNormalScale:{value:new K(1,1)},clearcoatNormalMap:{value:null},sheen:{value:0},sheenColor:{value:new ft(0)},sheenColorMap:{value:null},sheenRoughness:{value:1},sheenRoughnessMap:{value:null},transmission:{value:0},transmissionMap:{value:null},transmissionSamplerSize:{value:new K},transmissionSamplerMap:{value:null},thickness:{value:0},thicknessMap:{value:null},attenuationDistance:{value:0},attenuationColor:{value:new ft(0)},specularIntensity:{value:1},specularIntensityMap:{value:null},specularColor:{value:new ft(1,1,1)},specularColorMap:{value:null}}]),vertexShader:Pt.meshphysical_vert,fragmentShader:Pt.meshphysical_frag};function X1(n,t,e,i,r,s){let o=new ft(0),a=r===!0?0:1,l,c,u=null,h=0,f=null;function d(x,v){let m=!1,p=v.isScene===!0?v.background:null;p&&p.isTexture&&(p=t.get(p));let b=n.xr,_=b.getSession&&b.getSession();_&&_.environmentBlendMode==="additive"&&(p=null),p===null?g(o,a):p&&p.isColor&&(g(p,1),m=!0),(n.autoClear||m)&&n.clear(n.autoClearColor,n.autoClearDepth,n.autoClearStencil),p&&(p.isCubeTexture||p.mapping===Rl)?(c===void 0&&(c=new oe(new Hi(1,1,1),new Fn({name:"BackgroundCubeMaterial",uniforms:Gr(fn.cube.uniforms),vertexShader:fn.cube.vertexShader,fragmentShader:fn.cube.fragmentShader,side:he,depthTest:!1,depthWrite:!1,fog:!1})),c.geometry.deleteAttribute("normal"),c.geometry.deleteAttribute("uv"),c.onBeforeRender=function(S,L,A){this.matrixWorld.copyPosition(A.matrixWorld)},Object.defineProperty(c.material,"envMap",{get:function(){return this.uniforms.envMap.value}}),i.update(c)),c.material.uniforms.envMap.value=p,c.material.uniforms.flipEnvMap.value=p.isCubeTexture&&p.isRenderTargetTexture===!1?-1:1,(u!==p||h!==p.version||f!==n.toneMapping)&&(c.material.needsUpdate=!0,u=p,h=p.version,f=n.toneMapping),x.unshift(c,c.geometry,c.material,0,0,null)):p&&p.isTexture&&(l===void 0&&(l=new oe(new lo(2,2),new Fn({name:"BackgroundMaterial",uniforms:Gr(fn.background.uniforms),vertexShader:fn.background.vertexShader,fragmentShader:fn.background.fragmentShader,side:eo,depthTest:!1,depthWrite:!1,fog:!1})),l.geometry.deleteAttribute("normal"),Object.defineProperty(l.material,"map",{get:function(){return this.uniforms.t2D.value}}),i.update(l)),l.material.uniforms.t2D.value=p,p.matrixAutoUpdate===!0&&p.updateMatrix(),l.material.uniforms.uvTransform.value.copy(p.matrix),(u!==p||h!==p.version||f!==n.toneMapping)&&(l.material.needsUpdate=!0,u=p,h=p.version,f=n.toneMapping),x.unshift(l,l.geometry,l.material,0,0,null))}function g(x,v){e.buffers.color.setClear(x.r,x.g,x.b,v,s)}return{getClearColor:function(){return o},setClearColor:function(x,v=1){o.set(x),a=v,g(o,a)},getClearAlpha:function(){return a},setClearAlpha:function(x){a=x,g(o,a)},render:d}}function Y1(n,t,e,i){let r=n.getParameter(34921),s=i.isWebGL2?null:t.get("OES_vertex_array_object"),o=i.isWebGL2||s!==null,a={},l=x(null),c=l;function u(D,F,z,N,V){let Q=!1;if(o){let at=g(N,z,F);c!==at&&(c=at,f(c.object)),Q=v(N,V),Q&&m(N,V)}else{let at=F.wireframe===!0;(c.geometry!==N.id||c.program!==z.id||c.wireframe!==at)&&(c.geometry=N.id,c.program=z.id,c.wireframe=at,Q=!0)}D.isInstancedMesh===!0&&(Q=!0),V!==null&&e.update(V,34963),Q&&(A(D,F,z,N),V!==null&&n.bindBuffer(34963,e.get(V).buffer))}function h(){return i.isWebGL2?n.createVertexArray():s.createVertexArrayOES()}function f(D){return i.isWebGL2?n.bindVertexArray(D):s.bindVertexArrayOES(D)}function d(D){return i.isWebGL2?n.deleteVertexArray(D):s.deleteVertexArrayOES(D)}function g(D,F,z){let N=z.wireframe===!0,V=a[D.id];V===void 0&&(V={},a[D.id]=V);let Q=V[F.id];Q===void 0&&(Q={},V[F.id]=Q);let at=Q[N];return at===void 0&&(at=x(h()),Q[N]=at),at}function x(D){let F=[],z=[],N=[];for(let V=0;V<r;V++)F[V]=0,z[V]=0,N[V]=0;return{geometry:null,program:null,wireframe:!1,newAttributes:F,enabledAttributes:z,attributeDivisors:N,object:D,attributes:{},index:null}}function v(D,F){let z=c.attributes,N=D.attributes,V=0;for(let Q in N){let at=z[Q],G=N[Q];if(at===void 0||at.attribute!==G||at.data!==G.data)return!0;V++}return c.attributesNum!==V||c.index!==F}function m(D,F){let z={},N=D.attributes,V=0;for(let Q in N){let at=N[Q],G={};G.attribute=at,at.data&&(G.data=at.data),z[Q]=G,V++}c.attributes=z,c.attributesNum=V,c.index=F}function p(){let D=c.newAttributes;for(let F=0,z=D.length;F<z;F++)D[F]=0}function b(D){_(D,0)}function _(D,F){let z=c.newAttributes,N=c.enabledAttributes,V=c.attributeDivisors;z[D]=1,N[D]===0&&(n.enableVertexAttribArray(D),N[D]=1),V[D]!==F&&((i.isWebGL2?n:t.get("ANGLE_instanced_arrays"))[i.isWebGL2?"vertexAttribDivisor":"vertexAttribDivisorANGLE"](D,F),V[D]=F)}function S(){let D=c.newAttributes,F=c.enabledAttributes;for(let z=0,N=F.length;z<N;z++)F[z]!==D[z]&&(n.disableVertexAttribArray(z),F[z]=0)}function L(D,F,z,N,V,Q){i.isWebGL2===!0&&(z===5124||z===5125)?n.vertexAttribIPointer(D,F,z,V,Q):n.vertexAttribPointer(D,F,z,N,V,Q)}function A(D,F,z,N){if(i.isWebGL2===!1&&(D.isInstancedMesh||N.isInstancedBufferGeometry)&&t.get("ANGLE_instanced_arrays")===null)return;p();let V=N.attributes,Q=z.getAttributes(),at=F.defaultAttributeValues;for(let G in Q){let $=Q[G];if($.location>=0){let lt=V[G];if(lt===void 0&&(G==="instanceMatrix"&&D.instanceMatrix&&(lt=D.instanceMatrix),G==="instanceColor"&&D.instanceColor&&(lt=D.instanceColor)),lt!==void 0){let dt=lt.normalized,xt=lt.itemSize,k=e.get(lt);if(k===void 0)continue;let Ft=k.buffer,mt=k.type,St=k.bytesPerElement;if(lt.isInterleavedBufferAttribute){let B=lt.data,st=B.stride,nt=lt.offset;if(B&&B.isInstancedInterleavedBuffer){for(let C=0;C<$.locationSize;C++)_($.location+C,B.meshPerAttribute);D.isInstancedMesh!==!0&&N._maxInstanceCount===void 0&&(N._maxInstanceCount=B.meshPerAttribute*B.count)}else for(let C=0;C<$.locationSize;C++)b($.location+C);n.bindBuffer(34962,Ft);for(let C=0;C<$.locationSize;C++)L($.location+C,xt/$.locationSize,mt,dt,st*St,(nt+xt/$.locationSize*C)*St)}else{if(lt.isInstancedBufferAttribute){for(let B=0;B<$.locationSize;B++)_($.location+B,lt.meshPerAttribute);D.isInstancedMesh!==!0&&N._maxInstanceCount===void 0&&(N._maxInstanceCount=lt.meshPerAttribute*lt.count)}else for(let B=0;B<$.locationSize;B++)b($.location+B);n.bindBuffer(34962,Ft);for(let B=0;B<$.locationSize;B++)L($.location+B,xt/$.locationSize,mt,dt,xt*St,xt/$.locationSize*B*St)}}else if(at!==void 0){let dt=at[G];if(dt!==void 0)switch(dt.length){case 2:n.vertexAttrib2fv($.location,dt);break;case 3:n.vertexAttrib3fv($.location,dt);break;case 4:n.vertexAttrib4fv($.location,dt);break;default:n.vertexAttrib1fv($.location,dt)}}}}S()}function H(){y();for(let D in a){let F=a[D];for(let z in F){let N=F[z];for(let V in N)d(N[V].object),delete N[V];delete F[z]}delete a[D]}}function tt(D){if(a[D.id]===void 0)return;let F=a[D.id];for(let z in F){let N=F[z];for(let V in N)d(N[V].object),delete N[V];delete F[z]}delete a[D.id]}function X(D){for(let F in a){let z=a[F];if(z[D.id]===void 0)continue;let N=z[D.id];for(let V in N)d(N[V].object),delete N[V];delete z[D.id]}}function y(){R(),c!==l&&(c=l,f(c.object))}function R(){l.geometry=null,l.program=null,l.wireframe=!1}return{setup:u,reset:y,resetDefaultState:R,dispose:H,releaseStatesOfGeometry:tt,releaseStatesOfProgram:X,initAttributes:p,enableAttribute:b,disableUnusedAttributes:S}}function Z1(n,t,e,i){let r=i.isWebGL2,s;function o(c){s=c}function a(c,u){n.drawArrays(s,c,u),e.update(u,s,1)}function l(c,u,h){if(h===0)return;let f,d;if(r)f=n,d="drawArraysInstanced";else if(f=t.get("ANGLE_instanced_arrays"),d="drawArraysInstancedANGLE",f===null){console.error("THREE.WebGLBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.");return}f[d](s,c,u,h),e.update(u,s,h)}this.setMode=o,this.render=a,this.renderInstances=l}function J1(n,t,e){let i;function r(){if(i!==void 0)return i;if(t.has("EXT_texture_filter_anisotropic")===!0){let A=t.get("EXT_texture_filter_anisotropic");i=n.getParameter(A.MAX_TEXTURE_MAX_ANISOTROPY_EXT)}else i=0;return i}function s(A){if(A==="highp"){if(n.getShaderPrecisionFormat(35633,36338).precision>0&&n.getShaderPrecisionFormat(35632,36338).precision>0)return"highp";A="mediump"}return A==="mediump"&&n.getShaderPrecisionFormat(35633,36337).precision>0&&n.getShaderPrecisionFormat(35632,36337).precision>0?"mediump":"lowp"}let o=typeof WebGL2RenderingContext!="undefined"&&n instanceof WebGL2RenderingContext||typeof WebGL2ComputeRenderingContext!="undefined"&&n instanceof WebGL2ComputeRenderingContext,a=e.precision!==void 0?e.precision:"highp",l=s(a);l!==a&&(console.warn("THREE.WebGLRenderer:",a,"not supported, using",l,"instead."),a=l);let c=o||t.has("WEBGL_draw_buffers"),u=e.logarithmicDepthBuffer===!0,h=n.getParameter(34930),f=n.getParameter(35660),d=n.getParameter(3379),g=n.getParameter(34076),x=n.getParameter(34921),v=n.getParameter(36347),m=n.getParameter(36348),p=n.getParameter(36349),b=f>0,_=o||t.has("OES_texture_float"),S=b&&_,L=o?n.getParameter(36183):0;return{isWebGL2:o,drawBuffers:c,getMaxAnisotropy:r,getMaxPrecision:s,precision:a,logarithmicDepthBuffer:u,maxTextures:h,maxVertexTextures:f,maxTextureSize:d,maxCubemapSize:g,maxAttributes:x,maxVertexUniforms:v,maxVaryings:m,maxFragmentUniforms:p,vertexTextures:b,floatFragmentTextures:_,floatVertexTextures:S,maxSamples:L}}function $1(n){let t=this,e=null,i=0,r=!1,s=!1,o=new je,a=new de,l={value:null,needsUpdate:!1};this.uniform=l,this.numPlanes=0,this.numIntersection=0,this.init=function(h,f,d){let g=h.length!==0||f||i!==0||r;return r=f,e=u(h,d,0),i=h.length,g},this.beginShadows=function(){s=!0,u(null)},this.endShadows=function(){s=!1,c()},this.setState=function(h,f,d){let g=h.clippingPlanes,x=h.clipIntersection,v=h.clipShadows,m=n.get(h);if(!r||g===null||g.length===0||s&&!v)s?u(null):c();else{let p=s?0:i,b=p*4,_=m.clippingState||null;l.value=_,_=u(g,f,b,d);for(let S=0;S!==b;++S)_[S]=e[S];m.clippingState=_,this.numIntersection=x?this.numPlanes:0,this.numPlanes+=p}};function c(){l.value!==e&&(l.value=e,l.needsUpdate=i>0),t.numPlanes=i,t.numIntersection=0}function u(h,f,d,g){let x=h!==null?h.length:0,v=null;if(x!==0){if(v=l.value,g!==!0||v===null){let m=d+x*4,p=f.matrixWorldInverse;a.getNormalMatrix(p),(v===null||v.length<m)&&(v=new Float32Array(m));for(let b=0,_=d;b!==x;++b,_+=4)o.copy(h[b]).applyMatrix4(p,a),o.normal.toArray(v,_),v[_+3]=o.constant}l.value=v,l.needsUpdate=!0}return t.numPlanes=x,t.numIntersection=0,v}}function K1(n){let t=new WeakMap;function e(o,a){return a===Uu?o.mapping=Ao:a===Bu&&(o.mapping=Co),o}function i(o){if(o&&o.isTexture&&o.isRenderTargetTexture===!1){let a=o.mapping;if(a===Uu||a===Bu)if(t.has(o)){let l=t.get(o).texture;return e(l,o.mapping)}else{let l=o.image;if(l&&l.height>0){let c=new ol(l.height/2);return c.fromEquirectangularTexture(n,o),t.set(o,c),o.addEventListener("dispose",r),e(c.texture,o.mapping)}else return null}}return o}function r(o){let a=o.target;a.removeEventListener("dispose",r);let l=t.get(a);l!==void 0&&(t.delete(a),l.dispose())}function s(){t=new WeakMap}return{get:i,dispose:s}}var Vi=class extends oo{constructor(t=-1,e=1,i=1,r=-1,s=.1,o=2e3){super(),this.type="OrthographicCamera",this.zoom=1,this.view=null,this.left=t,this.right=e,this.top=i,this.bottom=r,this.near=s,this.far=o,this.updateProjectionMatrix()}copy(t,e){return super.copy(t,e),this.left=t.left,this.right=t.right,this.top=t.top,this.bottom=t.bottom,this.near=t.near,this.far=t.far,this.zoom=t.zoom,this.view=t.view===null?null:Object.assign({},t.view),this}setViewOffset(t,e,i,r,s,o){this.view===null&&(this.view={enabled:!0,fullWidth:1,fullHeight:1,offsetX:0,offsetY:0,width:1,height:1}),this.view.enabled=!0,this.view.fullWidth=t,this.view.fullHeight=e,this.view.offsetX=i,this.view.offsetY=r,this.view.width=s,this.view.height=o,this.updateProjectionMatrix()}clearViewOffset(){this.view!==null&&(this.view.enabled=!1),this.updateProjectionMatrix()}updateProjectionMatrix(){let t=(this.right-this.left)/(2*this.zoom),e=(this.top-this.bottom)/(2*this.zoom),i=(this.right+this.left)/2,r=(this.top+this.bottom)/2,s=i-t,o=i+t,a=r+e,l=r-e;if(this.view!==null&&this.view.enabled){let c=(this.right-this.left)/this.view.fullWidth/this.zoom,u=(this.top-this.bottom)/this.view.fullHeight/this.zoom;s+=c*this.view.offsetX,o=s+c*this.view.width,a-=u*this.view.offsetY,l=a-u*this.view.height}this.projectionMatrix.makeOrthographic(s,o,a,l,this.near,this.far),this.projectionMatrixInverse.copy(this.projectionMatrix).invert()}toJSON(t){let e=super.toJSON(t);return e.object.zoom=this.zoom,e.object.left=this.left,e.object.right=this.right,e.object.top=this.top,e.object.bottom=this.bottom,e.object.near=this.near,e.object.far=this.far,this.view!==null&&(e.object.view=Object.assign({},this.view)),e}};Vi.prototype.isOrthographicCamera=!0;var Xr=class extends Fn{constructor(t){super(t),this.type="RawShaderMaterial"}};Xr.prototype.isRawShaderMaterial=!0;var kr=4,ni=8,hn=Math.pow(2,ni),x0=[.125,.215,.35,.446,.526,.582],y0=ni-kr+1+x0.length,Ar=20,Tu=new Vi,{_lodPlanes:Gs,_sizeLods:mg,_sigmas:Ua}=Q1(),gg=new ft,Au=null,zi=(1+Math.sqrt(5))/2,Cr=1/zi,xg=[new T(1,1,1),new T(-1,1,1),new T(1,1,-1),new T(-1,1,-1),new T(0,zi,Cr),new T(0,zi,-Cr),new T(Cr,0,zi),new T(-Cr,0,zi),new T(zi,Cr,0),new T(-zi,Cr,0)],al=class{constructor(t){this._renderer=t,this._pingPongRenderTarget=null,this._blurMaterial=j1(Ar),this._equirectShader=null,this._cubemapShader=null,this._compileMaterial(this._blurMaterial)}fromScene(t,e=0,i=.1,r=100){Au=this._renderer.getRenderTarget();let s=this._allocateTargets();return this._sceneToCubeUV(t,i,r,s),e>0&&this._blur(s,0,0,e),this._applyPMREM(s),this._cleanup(s),s}fromEquirectangular(t,e=null){return this._fromTexture(t,e)}fromCubemap(t,e=null){return this._fromTexture(t,e)}compileCubemapShader(){this._cubemapShader===null&&(this._cubemapShader=_g(),this._compileMaterial(this._cubemapShader))}compileEquirectangularShader(){this._equirectShader===null&&(this._equirectShader=vg(),this._compileMaterial(this._equirectShader))}dispose(){this._blurMaterial.dispose(),this._pingPongRenderTarget!==null&&this._pingPongRenderTarget.dispose(),this._cubemapShader!==null&&this._cubemapShader.dispose(),this._equirectShader!==null&&this._equirectShader.dispose();for(let t=0;t<Gs.length;t++)Gs[t].dispose()}_cleanup(t){this._renderer.setRenderTarget(Au),t.scissorTest=!1,Ba(t,0,0,t.width,t.height)}_fromTexture(t,e){Au=this._renderer.getRenderTarget();let i=e||this._allocateTargets(t);return this._textureToCubeUV(t,i),this._applyPMREM(i),this._cleanup(i),i}_allocateTargets(t){let e={magFilter:be,minFilter:be,generateMipmaps:!1,type:Ur,format:Re,encoding:ri,depthBuffer:!1},i=yg(e);return i.depthBuffer=!t,this._pingPongRenderTarget===null&&(this._pingPongRenderTarget=yg(e)),i}_compileMaterial(t){let e=new oe(Gs[0],t);this._renderer.compile(e,Tu)}_sceneToCubeUV(t,e,i,r){let a=new Se(90,1,e,i),l=[1,-1,1,1,1,1],c=[1,1,1,-1,-1,-1],u=this._renderer,h=u.autoClear,f=u.toneMapping;u.getClearColor(gg),u.toneMapping=ti,u.autoClear=!1;let d=new ki({name:"PMREM.Background",side:he,depthWrite:!1,depthTest:!1}),g=new oe(new Hi,d),x=!1,v=t.background;v?v.isColor&&(d.color.copy(v),t.background=null,x=!0):(d.color.copy(gg),x=!0);for(let m=0;m<6;m++){let p=m%3;p===0?(a.up.set(0,l[m],0),a.lookAt(c[m],0,0)):p===1?(a.up.set(0,0,l[m]),a.lookAt(0,c[m],0)):(a.up.set(0,l[m],0),a.lookAt(0,0,c[m])),Ba(r,p*hn,m>2?hn:0,hn,hn),u.setRenderTarget(r),x&&u.render(g,a),u.render(t,a)}g.geometry.dispose(),g.material.dispose(),u.toneMapping=f,u.autoClear=h,t.background=v}_textureToCubeUV(t,e){let i=this._renderer,r=t.mapping===Ao||t.mapping===Co;r?(this._cubemapShader===null&&(this._cubemapShader=_g()),this._cubemapShader.uniforms.flipEnvMap.value=t.isRenderTargetTexture===!1?-1:1):this._equirectShader===null&&(this._equirectShader=vg());let s=r?this._cubemapShader:this._equirectShader,o=new oe(Gs[0],s),a=s.uniforms;a.envMap.value=t,r||a.texelSize.value.set(1/t.image.width,1/t.image.height),Ba(e,0,0,3*hn,2*hn),i.setRenderTarget(e),i.render(o,Tu)}_applyPMREM(t){let e=this._renderer,i=e.autoClear;e.autoClear=!1;for(let r=1;r<y0;r++){let s=Math.sqrt(Ua[r]*Ua[r]-Ua[r-1]*Ua[r-1]),o=xg[(r-1)%xg.length];this._blur(t,r-1,r,s,o)}e.autoClear=i}_blur(t,e,i,r,s){let o=this._pingPongRenderTarget;this._halfBlur(t,o,e,i,r,"latitudinal",s),this._halfBlur(o,t,i,i,r,"longitudinal",s)}_halfBlur(t,e,i,r,s,o,a){let l=this._renderer,c=this._blurMaterial;o!=="latitudinal"&&o!=="longitudinal"&&console.error("blur direction must be either latitudinal or longitudinal!");let u=3,h=new oe(Gs[r],c),f=c.uniforms,d=mg[i]-1,g=isFinite(s)?Math.PI/(2*d):2*Math.PI/(2*Ar-1),x=s/g,v=isFinite(s)?1+Math.floor(u*x):Ar;v>Ar&&console.warn(`sigmaRadians, ${s}, is too large and will clip, as it requested ${v} samples when the maximum is set to ${Ar}`);let m=[],p=0;for(let L=0;L<Ar;++L){let A=L/x,H=Math.exp(-A*A/2);m.push(H),L===0?p+=H:L<v&&(p+=2*H)}for(let L=0;L<m.length;L++)m[L]=m[L]/p;f.envMap.value=t.texture,f.samples.value=v,f.weights.value=m,f.latitudinal.value=o==="latitudinal",a&&(f.poleAxis.value=a),f.dTheta.value=g,f.mipInt.value=ni-i;let b=mg[r],_=3*Math.max(0,hn-2*b),S=(r===0?0:2*hn)+2*b*(r>ni-kr?r-ni+kr:0);Ba(e,_,S,3*b,2*b),l.setRenderTarget(e),l.render(h,Tu)}};function Q1(){let n=[],t=[],e=[],i=ni;for(let r=0;r<y0;r++){let s=Math.pow(2,i);t.push(s);let o=1/s;r>ni-kr?o=x0[r-ni+kr-1]:r===0&&(o=0),e.push(o);let a=1/(s-1),l=-a/2,c=1+a/2,u=[l,l,c,l,c,c,l,l,c,c,l,c],h=6,f=6,d=3,g=2,x=1,v=new Float32Array(d*f*h),m=new Float32Array(g*f*h),p=new Float32Array(x*f*h);for(let _=0;_<h;_++){let S=_%3*2/3-1,L=_>2?0:-1,A=[S,L,0,S+2/3,L,0,S+2/3,L+1,0,S,L,0,S+2/3,L+1,0,S,L+1,0];v.set(A,d*f*_),m.set(u,g*f*_);let H=[_,_,_,_,_,_];p.set(H,x*f*_)}let b=new Ht;b.setAttribute("position",new Qt(v,d)),b.setAttribute("uv",new Qt(m,g)),b.setAttribute("faceIndex",new Qt(p,x)),n.push(b),i>kr&&i--}return{_lodPlanes:n,_sizeLods:t,_sigmas:e}}function yg(n){let t=new Ne(3*hn,3*hn,n);return t.texture.mapping=Rl,t.texture.name="PMREM.cubeUv",t.scissorTest=!0,t}function Ba(n,t,e,i,r){n.viewport.set(t,e,i,r),n.scissor.set(t,e,i,r)}function j1(n){let t=new Float32Array(n),e=new T(0,1,0);return new Xr({name:"SphericalGaussianBlur",defines:{n},uniforms:{envMap:{value:null},samples:{value:1},weights:{value:t},latitudinal:{value:!1},dTheta:{value:0},mipInt:{value:0},poleAxis:{value:e}},vertexShader:jh(),fragmentShader:`

			precision mediump float;
			precision mediump int;

			varying vec3 vOutputDirection;

			uniform sampler2D envMap;
			uniform int samples;
			uniform float weights[ n ];
			uniform bool latitudinal;
			uniform float dTheta;
			uniform float mipInt;
			uniform vec3 poleAxis;

			#define ENVMAP_TYPE_CUBE_UV
			#include <cube_uv_reflection_fragment>

			vec3 getSample( float theta, vec3 axis ) {

				float cosTheta = cos( theta );
				// Rodrigues' axis-angle rotation
				vec3 sampleDirection = vOutputDirection * cosTheta
					+ cross( axis, vOutputDirection ) * sin( theta )
					+ axis * dot( axis, vOutputDirection ) * ( 1.0 - cosTheta );

				return bilinearCubeUV( envMap, sampleDirection, mipInt );

			}

			void main() {

				vec3 axis = latitudinal ? poleAxis : cross( poleAxis, vOutputDirection );

				if ( all( equal( axis, vec3( 0.0 ) ) ) ) {

					axis = vec3( vOutputDirection.z, 0.0, - vOutputDirection.x );

				}

				axis = normalize( axis );

				gl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 );
				gl_FragColor.rgb += weights[ 0 ] * getSample( 0.0, axis );

				for ( int i = 1; i < n; i++ ) {

					if ( i >= samples ) {

						break;

					}

					float theta = dTheta * float( i );
					gl_FragColor.rgb += weights[ i ] * getSample( -1.0 * theta, axis );
					gl_FragColor.rgb += weights[ i ] * getSample( theta, axis );

				}

			}
		`,blending:jn,depthTest:!1,depthWrite:!1})}function vg(){let n=new K(1,1);return new Xr({name:"EquirectangularToCubeUV",uniforms:{envMap:{value:null},texelSize:{value:n}},vertexShader:jh(),fragmentShader:`

			precision mediump float;
			precision mediump int;

			varying vec3 vOutputDirection;

			uniform sampler2D envMap;
			uniform vec2 texelSize;

			#include <common>

			void main() {

				gl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 );

				vec3 outputDirection = normalize( vOutputDirection );
				vec2 uv = equirectUv( outputDirection );

				vec2 f = fract( uv / texelSize - 0.5 );
				uv -= f * texelSize;
				vec3 tl = texture2D ( envMap, uv ).rgb;
				uv.x += texelSize.x;
				vec3 tr = texture2D ( envMap, uv ).rgb;
				uv.y += texelSize.y;
				vec3 br = texture2D ( envMap, uv ).rgb;
				uv.x -= texelSize.x;
				vec3 bl = texture2D ( envMap, uv ).rgb;

				vec3 tm = mix( tl, tr, f.x );
				vec3 bm = mix( bl, br, f.x );
				gl_FragColor.rgb = mix( tm, bm, f.y );

			}
		`,blending:jn,depthTest:!1,depthWrite:!1})}function _g(){return new Xr({name:"CubemapToCubeUV",uniforms:{envMap:{value:null},flipEnvMap:{value:-1}},vertexShader:jh(),fragmentShader:`

			precision mediump float;
			precision mediump int;

			uniform float flipEnvMap;

			varying vec3 vOutputDirection;

			uniform samplerCube envMap;

			void main() {

				gl_FragColor = textureCube( envMap, vec3( flipEnvMap * vOutputDirection.x, vOutputDirection.yz ) );

			}
		`,blending:jn,depthTest:!1,depthWrite:!1})}function jh(){return`

		precision mediump float;
		precision mediump int;

		attribute vec3 position;
		attribute vec2 uv;
		attribute float faceIndex;

		varying vec3 vOutputDirection;

		// RH coordinate system; PMREM face-indexing convention
		vec3 getDirection( vec2 uv, float face ) {

			uv = 2.0 * uv - 1.0;

			vec3 direction = vec3( uv, 1.0 );

			if ( face == 0.0 ) {

				direction = direction.zyx; // ( 1, v, u ) pos x

			} else if ( face == 1.0 ) {

				direction = direction.xzy;
				direction.xz *= -1.0; // ( -u, 1, -v ) pos y

			} else if ( face == 2.0 ) {

				direction.x *= -1.0; // ( -u, v, 1 ) pos z

			} else if ( face == 3.0 ) {

				direction = direction.zyx;
				direction.xz *= -1.0; // ( -1, v, -u ) neg x

			} else if ( face == 4.0 ) {

				direction = direction.xzy;
				direction.xy *= -1.0; // ( -u, -1, v ) neg y

			} else if ( face == 5.0 ) {

				direction.z *= -1.0; // ( u, v, -1 ) neg z

			}

			return direction;

		}

		void main() {

			vOutputDirection = getDirection( uv, faceIndex );
			gl_Position = vec4( position, 1.0 );

		}
	`}function tS(n){let t=new WeakMap,e=null;function i(a){if(a&&a.isTexture){let l=a.mapping,c=l===Uu||l===Bu,u=l===Ao||l===Co;if(c||u)if(a.isRenderTargetTexture&&a.needsPMREMUpdate===!0){a.needsPMREMUpdate=!1;let h=t.get(a);return e===null&&(e=new al(n)),h=c?e.fromEquirectangular(a,h):e.fromCubemap(a,h),t.set(a,h),h.texture}else{if(t.has(a))return t.get(a).texture;{let h=a.image;if(c&&h&&h.height>0||u&&h&&r(h)){e===null&&(e=new al(n));let f=c?e.fromEquirectangular(a):e.fromCubemap(a);return t.set(a,f),a.addEventListener("dispose",s),f.texture}else return null}}}return a}function r(a){let l=0,c=6;for(let u=0;u<c;u++)a[u]!==void 0&&l++;return l===c}function s(a){let l=a.target;l.removeEventListener("dispose",s);let c=t.get(l);c!==void 0&&(t.delete(l),c.dispose())}function o(){t=new WeakMap,e!==null&&(e.dispose(),e=null)}return{get:i,dispose:o}}function eS(n){let t={};function e(i){if(t[i]!==void 0)return t[i];let r;switch(i){case"WEBGL_depth_texture":r=n.getExtension("WEBGL_depth_texture")||n.getExtension("MOZ_WEBGL_depth_texture")||n.getExtension("WEBKIT_WEBGL_depth_texture");break;case"EXT_texture_filter_anisotropic":r=n.getExtension("EXT_texture_filter_anisotropic")||n.getExtension("MOZ_EXT_texture_filter_anisotropic")||n.getExtension("WEBKIT_EXT_texture_filter_anisotropic");break;case"WEBGL_compressed_texture_s3tc":r=n.getExtension("WEBGL_compressed_texture_s3tc")||n.getExtension("MOZ_WEBGL_compressed_texture_s3tc")||n.getExtension("WEBKIT_WEBGL_compressed_texture_s3tc");break;case"WEBGL_compressed_texture_pvrtc":r=n.getExtension("WEBGL_compressed_texture_pvrtc")||n.getExtension("WEBKIT_WEBGL_compressed_texture_pvrtc");break;default:r=n.getExtension(i)}return t[i]=r,r}return{has:function(i){return e(i)!==null},init:function(i){i.isWebGL2?e("EXT_color_buffer_float"):(e("WEBGL_depth_texture"),e("OES_texture_float"),e("OES_texture_half_float"),e("OES_texture_half_float_linear"),e("OES_standard_derivatives"),e("OES_element_index_uint"),e("OES_vertex_array_object"),e("ANGLE_instanced_arrays")),e("OES_texture_float_linear"),e("EXT_color_buffer_half_float"),e("WEBGL_multisampled_render_to_texture")},get:function(i){let r=e(i);return r===null&&console.warn("THREE.WebGLRenderer: "+i+" extension not supported."),r}}}function nS(n,t,e,i){let r={},s=new WeakMap;function o(h){let f=h.target;f.index!==null&&t.remove(f.index);for(let g in f.attributes)t.remove(f.attributes[g]);f.removeEventListener("dispose",o),delete r[f.id];let d=s.get(f);d&&(t.remove(d),s.delete(f)),i.releaseStatesOfGeometry(f),f.isInstancedBufferGeometry===!0&&delete f._maxInstanceCount,e.memory.geometries--}function a(h,f){return r[f.id]===!0||(f.addEventListener("dispose",o),r[f.id]=!0,e.memory.geometries++),f}function l(h){let f=h.attributes;for(let g in f)t.update(f[g],34962);let d=h.morphAttributes;for(let g in d){let x=d[g];for(let v=0,m=x.length;v<m;v++)t.update(x[v],34962)}}function c(h){let f=[],d=h.index,g=h.attributes.position,x=0;if(d!==null){let p=d.array;x=d.version;for(let b=0,_=p.length;b<_;b+=3){let S=p[b+0],L=p[b+1],A=p[b+2];f.push(S,L,L,A,A,S)}}else{let p=g.array;x=g.version;for(let b=0,_=p.length/3-1;b<_;b+=3){let S=b+0,L=b+1,A=b+2;f.push(S,L,L,A,A,S)}}let v=new(p0(f)?sl:rl)(f,1);v.version=x;let m=s.get(h);m&&t.remove(m),s.set(h,v)}function u(h){let f=s.get(h);if(f){let d=h.index;d!==null&&f.version<d.version&&c(h)}else c(h);return s.get(h)}return{get:a,update:l,getWireframeAttribute:u}}function iS(n,t,e,i){let r=i.isWebGL2,s;function o(f){s=f}let a,l;function c(f){a=f.type,l=f.bytesPerElement}function u(f,d){n.drawElements(s,d,a,f*l),e.update(d,s,1)}function h(f,d,g){if(g===0)return;let x,v;if(r)x=n,v="drawElementsInstanced";else if(x=t.get("ANGLE_instanced_arrays"),v="drawElementsInstancedANGLE",x===null){console.error("THREE.WebGLIndexedBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.");return}x[v](s,d,a,f*l,g),e.update(d,s,g)}this.setMode=o,this.setIndex=c,this.render=u,this.renderInstances=h}function rS(n){let t={geometries:0,textures:0},e={frame:0,calls:0,triangles:0,points:0,lines:0};function i(s,o,a){switch(e.calls++,o){case 4:e.triangles+=a*(s/3);break;case 1:e.lines+=a*(s/2);break;case 3:e.lines+=a*(s-1);break;case 2:e.lines+=a*s;break;case 0:e.points+=a*s;break;default:console.error("THREE.WebGLInfo: Unknown draw mode:",o);break}}function r(){e.frame++,e.calls=0,e.triangles=0,e.points=0,e.lines=0}return{memory:t,render:e,programs:null,autoReset:!0,reset:r,update:i}}var co=class extends ae{constructor(t=null,e=1,i=1,r=1){super(null),this.image={data:t,width:e,height:i,depth:r},this.magFilter=fe,this.minFilter=fe,this.wrapR=Ve,this.generateMipmaps=!1,this.flipY=!1,this.unpackAlignment=1}};co.prototype.isDataTexture2DArray=!0;function sS(n,t){return n[0]-t[0]}function oS(n,t){return Math.abs(t[1])-Math.abs(n[1])}function wg(n,t){let e=1,i=t.isInterleavedBufferAttribute?t.data.array:t.array;i instanceof Int8Array?e=127:i instanceof Int16Array?e=32767:i instanceof Int32Array?e=2147483647:console.error("THREE.WebGLMorphtargets: Unsupported morph attribute data type: ",i),n.divideScalar(e)}function aS(n,t,e){let i={},r=new Float32Array(8),s=new WeakMap,o=new T,a=[];for(let c=0;c<8;c++)a[c]=[c,0];function l(c,u,h,f){let d=c.morphTargetInfluences;if(t.isWebGL2===!0){let g=u.morphAttributes.position.length,x=s.get(u);if(x===void 0||x.count!==g){let R=function(){X.dispose(),s.delete(u),u.removeEventListener("dispose",R)};x!==void 0&&x.texture.dispose();let p=u.morphAttributes.normal!==void 0,b=u.morphAttributes.position,_=u.morphAttributes.normal||[],S=u.attributes.position.count,L=p===!0?2:1,A=S*L,H=1;A>t.maxTextureSize&&(H=Math.ceil(A/t.maxTextureSize),A=t.maxTextureSize);let tt=new Float32Array(A*H*4*g),X=new co(tt,A,H,g);X.format=Re,X.type=Ui,X.needsUpdate=!0;let y=L*4;for(let D=0;D<g;D++){let F=b[D],z=_[D],N=A*H*4*D;for(let V=0;V<F.count;V++){o.fromBufferAttribute(F,V),F.normalized===!0&&wg(o,F);let Q=V*y;tt[N+Q+0]=o.x,tt[N+Q+1]=o.y,tt[N+Q+2]=o.z,tt[N+Q+3]=0,p===!0&&(o.fromBufferAttribute(z,V),z.normalized===!0&&wg(o,z),tt[N+Q+4]=o.x,tt[N+Q+5]=o.y,tt[N+Q+6]=o.z,tt[N+Q+7]=0)}}x={count:g,texture:X,size:new K(A,H)},s.set(u,x),u.addEventListener("dispose",R)}let v=0;for(let p=0;p<d.length;p++)v+=d[p];let m=u.morphTargetsRelative?1:1-v;f.getUniforms().setValue(n,"morphTargetBaseInfluence",m),f.getUniforms().setValue(n,"morphTargetInfluences",d),f.getUniforms().setValue(n,"morphTargetsTexture",x.texture,e),f.getUniforms().setValue(n,"morphTargetsTextureSize",x.size)}else{let g=d===void 0?0:d.length,x=i[u.id];if(x===void 0||x.length!==g){x=[];for(let _=0;_<g;_++)x[_]=[_,0];i[u.id]=x}for(let _=0;_<g;_++){let S=x[_];S[0]=_,S[1]=d[_]}x.sort(oS);for(let _=0;_<8;_++)_<g&&x[_][1]?(a[_][0]=x[_][0],a[_][1]=x[_][1]):(a[_][0]=Number.MAX_SAFE_INTEGER,a[_][1]=0);a.sort(sS);let v=u.morphAttributes.position,m=u.morphAttributes.normal,p=0;for(let _=0;_<8;_++){let S=a[_],L=S[0],A=S[1];L!==Number.MAX_SAFE_INTEGER&&A?(v&&u.getAttribute("morphTarget"+_)!==v[L]&&u.setAttribute("morphTarget"+_,v[L]),m&&u.getAttribute("morphNormal"+_)!==m[L]&&u.setAttribute("morphNormal"+_,m[L]),r[_]=A,p+=A):(v&&u.hasAttribute("morphTarget"+_)===!0&&u.deleteAttribute("morphTarget"+_),m&&u.hasAttribute("morphNormal"+_)===!0&&u.deleteAttribute("morphNormal"+_),r[_]=0)}let b=u.morphTargetsRelative?1:1-p;f.getUniforms().setValue(n,"morphTargetBaseInfluence",b),f.getUniforms().setValue(n,"morphTargetInfluences",r)}}return{update:l}}function lS(n,t,e,i){let r=new WeakMap;function s(l){let c=i.render.frame,u=l.geometry,h=t.get(l,u);return r.get(h)!==c&&(t.update(h),r.set(h,c)),l.isInstancedMesh&&(l.hasEventListener("dispose",a)===!1&&l.addEventListener("dispose",a),e.update(l.instanceMatrix,34962),l.instanceColor!==null&&e.update(l.instanceColor,34962)),h}function o(){r=new WeakMap}function a(l){let c=l.target;c.removeEventListener("dispose",a),e.remove(c.instanceMatrix),c.instanceColor!==null&&e.remove(c.instanceColor)}return{update:s,dispose:o}}var ll=class extends ae{constructor(t=null,e=1,i=1,r=1){super(null),this.image={data:t,width:e,height:i,depth:r},this.magFilter=fe,this.minFilter=fe,this.wrapR=Ve,this.generateMipmaps=!1,this.flipY=!1,this.unpackAlignment=1}};ll.prototype.isDataTexture3D=!0;var v0=new ae,_0=new co,w0=new ll,M0=new Wr,Mg=[],bg=[],Sg=new Float32Array(16),Eg=new Float32Array(9),Tg=new Float32Array(4);function es(n,t,e){let i=n[0];if(i<=0||i>0)return n;let r=t*e,s=Mg[r];if(s===void 0&&(s=new Float32Array(r),Mg[r]=s),t!==0){i.toArray(s,0);for(let o=1,a=0;o!==t;++o)a+=e,n[o].toArray(s,a)}return s}function Le(n,t){if(n.length!==t.length)return!1;for(let e=0,i=n.length;e<i;e++)if(n[e]!==t[e])return!1;return!0}function Te(n,t){for(let e=0,i=t.length;e<i;e++)n[e]=t[e]}function Pl(n,t){let e=bg[t];e===void 0&&(e=new Int32Array(t),bg[t]=e);for(let i=0;i!==t;++i)e[i]=n.allocateTextureUnit();return e}function cS(n,t){let e=this.cache;e[0]!==t&&(n.uniform1f(this.addr,t),e[0]=t)}function uS(n,t){let e=this.cache;if(t.x!==void 0)(e[0]!==t.x||e[1]!==t.y)&&(n.uniform2f(this.addr,t.x,t.y),e[0]=t.x,e[1]=t.y);else{if(Le(e,t))return;n.uniform2fv(this.addr,t),Te(e,t)}}function hS(n,t){let e=this.cache;if(t.x!==void 0)(e[0]!==t.x||e[1]!==t.y||e[2]!==t.z)&&(n.uniform3f(this.addr,t.x,t.y,t.z),e[0]=t.x,e[1]=t.y,e[2]=t.z);else if(t.r!==void 0)(e[0]!==t.r||e[1]!==t.g||e[2]!==t.b)&&(n.uniform3f(this.addr,t.r,t.g,t.b),e[0]=t.r,e[1]=t.g,e[2]=t.b);else{if(Le(e,t))return;n.uniform3fv(this.addr,t),Te(e,t)}}function fS(n,t){let e=this.cache;if(t.x!==void 0)(e[0]!==t.x||e[1]!==t.y||e[2]!==t.z||e[3]!==t.w)&&(n.uniform4f(this.addr,t.x,t.y,t.z,t.w),e[0]=t.x,e[1]=t.y,e[2]=t.z,e[3]=t.w);else{if(Le(e,t))return;n.uniform4fv(this.addr,t),Te(e,t)}}function dS(n,t){let e=this.cache,i=t.elements;if(i===void 0){if(Le(e,t))return;n.uniformMatrix2fv(this.addr,!1,t),Te(e,t)}else{if(Le(e,i))return;Tg.set(i),n.uniformMatrix2fv(this.addr,!1,Tg),Te(e,i)}}function pS(n,t){let e=this.cache,i=t.elements;if(i===void 0){if(Le(e,t))return;n.uniformMatrix3fv(this.addr,!1,t),Te(e,t)}else{if(Le(e,i))return;Eg.set(i),n.uniformMatrix3fv(this.addr,!1,Eg),Te(e,i)}}function mS(n,t){let e=this.cache,i=t.elements;if(i===void 0){if(Le(e,t))return;n.uniformMatrix4fv(this.addr,!1,t),Te(e,t)}else{if(Le(e,i))return;Sg.set(i),n.uniformMatrix4fv(this.addr,!1,Sg),Te(e,i)}}function gS(n,t){let e=this.cache;e[0]!==t&&(n.uniform1i(this.addr,t),e[0]=t)}function xS(n,t){let e=this.cache;Le(e,t)||(n.uniform2iv(this.addr,t),Te(e,t))}function yS(n,t){let e=this.cache;Le(e,t)||(n.uniform3iv(this.addr,t),Te(e,t))}function vS(n,t){let e=this.cache;Le(e,t)||(n.uniform4iv(this.addr,t),Te(e,t))}function _S(n,t){let e=this.cache;e[0]!==t&&(n.uniform1ui(this.addr,t),e[0]=t)}function wS(n,t){let e=this.cache;Le(e,t)||(n.uniform2uiv(this.addr,t),Te(e,t))}function MS(n,t){let e=this.cache;Le(e,t)||(n.uniform3uiv(this.addr,t),Te(e,t))}function bS(n,t){let e=this.cache;Le(e,t)||(n.uniform4uiv(this.addr,t),Te(e,t))}function SS(n,t,e){let i=this.cache,r=e.allocateTextureUnit();i[0]!==r&&(n.uniform1i(this.addr,r),i[0]=r),e.safeSetTexture2D(t||v0,r)}function ES(n,t,e){let i=this.cache,r=e.allocateTextureUnit();i[0]!==r&&(n.uniform1i(this.addr,r),i[0]=r),e.setTexture3D(t||w0,r)}function TS(n,t,e){let i=this.cache,r=e.allocateTextureUnit();i[0]!==r&&(n.uniform1i(this.addr,r),i[0]=r),e.safeSetTextureCube(t||M0,r)}function AS(n,t,e){let i=this.cache,r=e.allocateTextureUnit();i[0]!==r&&(n.uniform1i(this.addr,r),i[0]=r),e.setTexture2DArray(t||_0,r)}function CS(n){switch(n){case 5126:return cS;case 35664:return uS;case 35665:return hS;case 35666:return fS;case 35674:return dS;case 35675:return pS;case 35676:return mS;case 5124:case 35670:return gS;case 35667:case 35671:return xS;case 35668:case 35672:return yS;case 35669:case 35673:return vS;case 5125:return _S;case 36294:return wS;case 36295:return MS;case 36296:return bS;case 35678:case 36198:case 36298:case 36306:case 35682:return SS;case 35679:case 36299:case 36307:return ES;case 35680:case 36300:case 36308:case 36293:return TS;case 36289:case 36303:case 36311:case 36292:return AS}}function RS(n,t){n.uniform1fv(this.addr,t)}function LS(n,t){let e=es(t,this.size,2);n.uniform2fv(this.addr,e)}function PS(n,t){let e=es(t,this.size,3);n.uniform3fv(this.addr,e)}function DS(n,t){let e=es(t,this.size,4);n.uniform4fv(this.addr,e)}function IS(n,t){let e=es(t,this.size,4);n.uniformMatrix2fv(this.addr,!1,e)}function NS(n,t){let e=es(t,this.size,9);n.uniformMatrix3fv(this.addr,!1,e)}function FS(n,t){let e=es(t,this.size,16);n.uniformMatrix4fv(this.addr,!1,e)}function zS(n,t){n.uniform1iv(this.addr,t)}function US(n,t){n.uniform2iv(this.addr,t)}function BS(n,t){n.uniform3iv(this.addr,t)}function OS(n,t){n.uniform4iv(this.addr,t)}function kS(n,t){n.uniform1uiv(this.addr,t)}function HS(n,t){n.uniform2uiv(this.addr,t)}function VS(n,t){n.uniform3uiv(this.addr,t)}function GS(n,t){n.uniform4uiv(this.addr,t)}function WS(n,t,e){let i=t.length,r=Pl(e,i);n.uniform1iv(this.addr,r);for(let s=0;s!==i;++s)e.safeSetTexture2D(t[s]||v0,r[s])}function qS(n,t,e){let i=t.length,r=Pl(e,i);n.uniform1iv(this.addr,r);for(let s=0;s!==i;++s)e.setTexture3D(t[s]||w0,r[s])}function XS(n,t,e){let i=t.length,r=Pl(e,i);n.uniform1iv(this.addr,r);for(let s=0;s!==i;++s)e.safeSetTextureCube(t[s]||M0,r[s])}function YS(n,t,e){let i=t.length,r=Pl(e,i);n.uniform1iv(this.addr,r);for(let s=0;s!==i;++s)e.setTexture2DArray(t[s]||_0,r[s])}function ZS(n){switch(n){case 5126:return RS;case 35664:return LS;case 35665:return PS;case 35666:return DS;case 35674:return IS;case 35675:return NS;case 35676:return FS;case 5124:case 35670:return zS;case 35667:case 35671:return US;case 35668:case 35672:return BS;case 35669:case 35673:return OS;case 5125:return kS;case 36294:return HS;case 36295:return VS;case 36296:return GS;case 35678:case 36198:case 36298:case 36306:case 35682:return WS;case 35679:case 36299:case 36307:return qS;case 35680:case 36300:case 36308:case 36293:return XS;case 36289:case 36303:case 36311:case 36292:return YS}}function JS(n,t,e){this.id=n,this.addr=e,this.cache=[],this.setValue=CS(t.type)}function b0(n,t,e){this.id=n,this.addr=e,this.cache=[],this.size=t.size,this.setValue=ZS(t.type)}b0.prototype.updateCache=function(n){let t=this.cache;n instanceof Float32Array&&t.length!==n.length&&(this.cache=new Float32Array(n.length)),Te(t,n)};function S0(n){this.id=n,this.seq=[],this.map={}}S0.prototype.setValue=function(n,t,e){let i=this.seq;for(let r=0,s=i.length;r!==s;++r){let o=i[r];o.setValue(n,t[o.id],e)}};var Cu=/(\w+)(\])?(\[|\.)?/g;function Ag(n,t){n.seq.push(t),n.map[t.id]=t}function $S(n,t,e){let i=n.name,r=i.length;for(Cu.lastIndex=0;;){let s=Cu.exec(i),o=Cu.lastIndex,a=s[1],l=s[2]==="]",c=s[3];if(l&&(a=a|0),c===void 0||c==="["&&o+2===r){Ag(e,c===void 0?new JS(a,n,t):new b0(a,n,t));break}else{let h=e.map[a];h===void 0&&(h=new S0(a),Ag(e,h)),e=h}}}function ii(n,t){this.seq=[],this.map={};let e=n.getProgramParameter(t,35718);for(let i=0;i<e;++i){let r=n.getActiveUniform(t,i),s=n.getUniformLocation(t,r.name);$S(r,s,this)}}ii.prototype.setValue=function(n,t,e,i){let r=this.map[t];r!==void 0&&r.setValue(n,e,i)};ii.prototype.setOptional=function(n,t,e){let i=t[e];i!==void 0&&this.setValue(n,e,i)};ii.upload=function(n,t,e,i){for(let r=0,s=t.length;r!==s;++r){let o=t[r],a=e[o.id];a.needsUpdate!==!1&&o.setValue(n,a.value,i)}};ii.seqWithValue=function(n,t){let e=[];for(let i=0,r=n.length;i!==r;++i){let s=n[i];s.id in t&&e.push(s)}return e};function Cg(n,t,e){let i=n.createShader(t);return n.shaderSource(i,e),n.compileShader(i),i}var KS=0;function QS(n){let t=n.split(`
`);for(let e=0;e<t.length;e++)t[e]=e+1+": "+t[e];return t.join(`
`)}function jS(n){switch(n){case ri:return["Linear","( value )"];case $t:return["sRGB","( value )"];default:return console.warn("THREE.WebGLProgram: Unsupported encoding:",n),["Linear","( value )"]}}function Rg(n,t,e){let i=n.getShaderParameter(t,35713),r=n.getShaderInfoLog(t).trim();return i&&r===""?"":e.toUpperCase()+`

`+r+`

`+QS(n.getShaderSource(t))}function tE(n,t){let e=jS(t);return"vec4 "+n+"( vec4 value ) { return LinearTo"+e[0]+e[1]+"; }"}function eE(n,t){let e;switch(t){case Aw:e="Linear";break;case Cw:e="Reinhard";break;case Rw:e="OptimizedCineon";break;case Lw:e="ACESFilmic";break;case Pw:e="Custom";break;default:console.warn("THREE.WebGLProgram: Unsupported toneMapping:",t),e="Linear"}return"vec3 "+n+"( vec3 color ) { return "+e+"ToneMapping( color ); }"}function nE(n){return[n.extensionDerivatives||n.envMapCubeUV||n.bumpMap||n.tangentSpaceNormalMap||n.clearcoatNormalMap||n.flatShading||n.shaderID==="physical"?"#extension GL_OES_standard_derivatives : enable":"",(n.extensionFragDepth||n.logarithmicDepthBuffer)&&n.rendererExtensionFragDepth?"#extension GL_EXT_frag_depth : enable":"",n.extensionDrawBuffers&&n.rendererExtensionDrawBuffers?"#extension GL_EXT_draw_buffers : require":"",(n.extensionShaderTextureLOD||n.envMap||n.transmission)&&n.rendererExtensionShaderTextureLod?"#extension GL_EXT_shader_texture_lod : enable":""].filter($s).join(`
`)}function iE(n){let t=[];for(let e in n){let i=n[e];i!==!1&&t.push("#define "+e+" "+i)}return t.join(`
`)}function rE(n,t){let e={},i=n.getProgramParameter(t,35721);for(let r=0;r<i;r++){let s=n.getActiveAttrib(t,r),o=s.name,a=1;s.type===35674&&(a=2),s.type===35675&&(a=3),s.type===35676&&(a=4),e[o]={type:s.type,location:n.getAttribLocation(t,o),locationSize:a}}return e}function $s(n){return n!==""}function Lg(n,t){return n.replace(/NUM_DIR_LIGHTS/g,t.numDirLights).replace(/NUM_SPOT_LIGHTS/g,t.numSpotLights).replace(/NUM_RECT_AREA_LIGHTS/g,t.numRectAreaLights).replace(/NUM_POINT_LIGHTS/g,t.numPointLights).replace(/NUM_HEMI_LIGHTS/g,t.numHemiLights).replace(/NUM_DIR_LIGHT_SHADOWS/g,t.numDirLightShadows).replace(/NUM_SPOT_LIGHT_SHADOWS/g,t.numSpotLightShadows).replace(/NUM_POINT_LIGHT_SHADOWS/g,t.numPointLightShadows)}function Pg(n,t){return n.replace(/NUM_CLIPPING_PLANES/g,t.numClippingPlanes).replace(/UNION_CLIPPING_PLANES/g,t.numClippingPlanes-t.numClipIntersection)}var sE=/^[ \t]*#include +<([\w\d./]+)>/gm;function qu(n){return n.replace(sE,oE)}function oE(n,t){let e=Pt[t];if(e===void 0)throw new Error("Can not resolve #include <"+t+">");return qu(e)}var aE=/#pragma unroll_loop[\s]+?for \( int i \= (\d+)\; i < (\d+)\; i \+\+ \) \{([\s\S]+?)(?=\})\}/g,lE=/#pragma unroll_loop_start\s+for\s*\(\s*int\s+i\s*=\s*(\d+)\s*;\s*i\s*<\s*(\d+)\s*;\s*i\s*\+\+\s*\)\s*{([\s\S]+?)}\s+#pragma unroll_loop_end/g;function Dg(n){return n.replace(lE,E0).replace(aE,cE)}function cE(n,t,e,i){return console.warn("WebGLProgram: #pragma unroll_loop shader syntax is deprecated. Please use #pragma unroll_loop_start syntax instead."),E0(n,t,e,i)}function E0(n,t,e,i){let r="";for(let s=parseInt(t);s<parseInt(e);s++)r+=i.replace(/\[\s*i\s*\]/g,"[ "+s+" ]").replace(/UNROLLED_LOOP_INDEX/g,s);return r}function Ig(n){let t="precision "+n.precision+` float;
precision `+n.precision+" int;";return n.precision==="highp"?t+=`
#define HIGH_PRECISION`:n.precision==="mediump"?t+=`
#define MEDIUM_PRECISION`:n.precision==="lowp"&&(t+=`
#define LOW_PRECISION`),t}function uE(n){let t="SHADOWMAP_TYPE_BASIC";return n.shadowMapType===l0?t="SHADOWMAP_TYPE_PCF":n.shadowMapType===sw?t="SHADOWMAP_TYPE_PCF_SOFT":n.shadowMapType===Js&&(t="SHADOWMAP_TYPE_VSM"),t}function hE(n){let t="ENVMAP_TYPE_CUBE";if(n.envMap)switch(n.envMapMode){case Ao:case Co:t="ENVMAP_TYPE_CUBE";break;case Rl:case Kh:t="ENVMAP_TYPE_CUBE_UV";break}return t}function fE(n){let t="ENVMAP_MODE_REFLECTION";if(n.envMap)switch(n.envMapMode){case Co:case Kh:t="ENVMAP_MODE_REFRACTION";break}return t}function dE(n){let t="ENVMAP_BLENDING_NONE";if(n.envMap)switch(n.combine){case Cl:t="ENVMAP_BLENDING_MULTIPLY";break;case Ew:t="ENVMAP_BLENDING_MIX";break;case Tw:t="ENVMAP_BLENDING_ADD";break}return t}function pE(n,t,e,i){let r=n.getContext(),s=e.defines,o=e.vertexShader,a=e.fragmentShader,l=uE(e),c=hE(e),u=fE(e),h=dE(e),f=e.isWebGL2?"":nE(e),d=iE(s),g=r.createProgram(),x,v,m=e.glslVersion?"#version "+e.glslVersion+`
`:"";e.isRawShaderMaterial?(x=[d].filter($s).join(`
`),x.length>0&&(x+=`
`),v=[f,d].filter($s).join(`
`),v.length>0&&(v+=`
`)):(x=[Ig(e),"#define SHADER_NAME "+e.shaderName,d,e.instancing?"#define USE_INSTANCING":"",e.instancingColor?"#define USE_INSTANCING_COLOR":"",e.supportsVertexTextures?"#define VERTEX_TEXTURES":"","#define MAX_BONES "+e.maxBones,e.useFog&&e.fog?"#define USE_FOG":"",e.useFog&&e.fogExp2?"#define FOG_EXP2":"",e.map?"#define USE_MAP":"",e.envMap?"#define USE_ENVMAP":"",e.envMap?"#define "+u:"",e.lightMap?"#define USE_LIGHTMAP":"",e.aoMap?"#define USE_AOMAP":"",e.emissiveMap?"#define USE_EMISSIVEMAP":"",e.bumpMap?"#define USE_BUMPMAP":"",e.normalMap?"#define USE_NORMALMAP":"",e.normalMap&&e.objectSpaceNormalMap?"#define OBJECTSPACE_NORMALMAP":"",e.normalMap&&e.tangentSpaceNormalMap?"#define TANGENTSPACE_NORMALMAP":"",e.clearcoatMap?"#define USE_CLEARCOATMAP":"",e.clearcoatRoughnessMap?"#define USE_CLEARCOAT_ROUGHNESSMAP":"",e.clearcoatNormalMap?"#define USE_CLEARCOAT_NORMALMAP":"",e.displacementMap&&e.supportsVertexTextures?"#define USE_DISPLACEMENTMAP":"",e.specularMap?"#define USE_SPECULARMAP":"",e.specularIntensityMap?"#define USE_SPECULARINTENSITYMAP":"",e.specularColorMap?"#define USE_SPECULARCOLORMAP":"",e.roughnessMap?"#define USE_ROUGHNESSMAP":"",e.metalnessMap?"#define USE_METALNESSMAP":"",e.alphaMap?"#define USE_ALPHAMAP":"",e.transmission?"#define USE_TRANSMISSION":"",e.transmissionMap?"#define USE_TRANSMISSIONMAP":"",e.thicknessMap?"#define USE_THICKNESSMAP":"",e.sheenColorMap?"#define USE_SHEENCOLORMAP":"",e.sheenRoughnessMap?"#define USE_SHEENROUGHNESSMAP":"",e.vertexTangents?"#define USE_TANGENT":"",e.vertexColors?"#define USE_COLOR":"",e.vertexAlphas?"#define USE_COLOR_ALPHA":"",e.vertexUvs?"#define USE_UV":"",e.uvsVertexOnly?"#define UVS_VERTEX_ONLY":"",e.flatShading?"#define FLAT_SHADED":"",e.skinning?"#define USE_SKINNING":"",e.useVertexTexture?"#define BONE_TEXTURE":"",e.morphTargets?"#define USE_MORPHTARGETS":"",e.morphNormals&&e.flatShading===!1?"#define USE_MORPHNORMALS":"",e.morphTargets&&e.isWebGL2?"#define MORPHTARGETS_TEXTURE":"",e.morphTargets&&e.isWebGL2?"#define MORPHTARGETS_COUNT "+e.morphTargetsCount:"",e.doubleSided?"#define DOUBLE_SIDED":"",e.flipSided?"#define FLIP_SIDED":"",e.shadowMapEnabled?"#define USE_SHADOWMAP":"",e.shadowMapEnabled?"#define "+l:"",e.sizeAttenuation?"#define USE_SIZEATTENUATION":"",e.logarithmicDepthBuffer?"#define USE_LOGDEPTHBUF":"",e.logarithmicDepthBuffer&&e.rendererExtensionFragDepth?"#define USE_LOGDEPTHBUF_EXT":"","uniform mat4 modelMatrix;","uniform mat4 modelViewMatrix;","uniform mat4 projectionMatrix;","uniform mat4 viewMatrix;","uniform mat3 normalMatrix;","uniform vec3 cameraPosition;","uniform bool isOrthographic;","#ifdef USE_INSTANCING","	attribute mat4 instanceMatrix;","#endif","#ifdef USE_INSTANCING_COLOR","	attribute vec3 instanceColor;","#endif","attribute vec3 position;","attribute vec3 normal;","attribute vec2 uv;","#ifdef USE_TANGENT","	attribute vec4 tangent;","#endif","#if defined( USE_COLOR_ALPHA )","	attribute vec4 color;","#elif defined( USE_COLOR )","	attribute vec3 color;","#endif","#if ( defined( USE_MORPHTARGETS ) && ! defined( MORPHTARGETS_TEXTURE ) )","	attribute vec3 morphTarget0;","	attribute vec3 morphTarget1;","	attribute vec3 morphTarget2;","	attribute vec3 morphTarget3;","	#ifdef USE_MORPHNORMALS","		attribute vec3 morphNormal0;","		attribute vec3 morphNormal1;","		attribute vec3 morphNormal2;","		attribute vec3 morphNormal3;","	#else","		attribute vec3 morphTarget4;","		attribute vec3 morphTarget5;","		attribute vec3 morphTarget6;","		attribute vec3 morphTarget7;","	#endif","#endif","#ifdef USE_SKINNING","	attribute vec4 skinIndex;","	attribute vec4 skinWeight;","#endif",`
`].filter($s).join(`
`),v=[f,Ig(e),"#define SHADER_NAME "+e.shaderName,d,e.useFog&&e.fog?"#define USE_FOG":"",e.useFog&&e.fogExp2?"#define FOG_EXP2":"",e.map?"#define USE_MAP":"",e.matcap?"#define USE_MATCAP":"",e.envMap?"#define USE_ENVMAP":"",e.envMap?"#define "+c:"",e.envMap?"#define "+u:"",e.envMap?"#define "+h:"",e.lightMap?"#define USE_LIGHTMAP":"",e.aoMap?"#define USE_AOMAP":"",e.emissiveMap?"#define USE_EMISSIVEMAP":"",e.bumpMap?"#define USE_BUMPMAP":"",e.normalMap?"#define USE_NORMALMAP":"",e.normalMap&&e.objectSpaceNormalMap?"#define OBJECTSPACE_NORMALMAP":"",e.normalMap&&e.tangentSpaceNormalMap?"#define TANGENTSPACE_NORMALMAP":"",e.clearcoat?"#define USE_CLEARCOAT":"",e.clearcoatMap?"#define USE_CLEARCOATMAP":"",e.clearcoatRoughnessMap?"#define USE_CLEARCOAT_ROUGHNESSMAP":"",e.clearcoatNormalMap?"#define USE_CLEARCOAT_NORMALMAP":"",e.specularMap?"#define USE_SPECULARMAP":"",e.specularIntensityMap?"#define USE_SPECULARINTENSITYMAP":"",e.specularColorMap?"#define USE_SPECULARCOLORMAP":"",e.roughnessMap?"#define USE_ROUGHNESSMAP":"",e.metalnessMap?"#define USE_METALNESSMAP":"",e.alphaMap?"#define USE_ALPHAMAP":"",e.alphaTest?"#define USE_ALPHATEST":"",e.sheen?"#define USE_SHEEN":"",e.sheenColorMap?"#define USE_SHEENCOLORMAP":"",e.sheenRoughnessMap?"#define USE_SHEENROUGHNESSMAP":"",e.transmission?"#define USE_TRANSMISSION":"",e.transmissionMap?"#define USE_TRANSMISSIONMAP":"",e.thicknessMap?"#define USE_THICKNESSMAP":"",e.decodeVideoTexture?"#define DECODE_VIDEO_TEXTURE":"",e.vertexTangents?"#define USE_TANGENT":"",e.vertexColors||e.instancingColor?"#define USE_COLOR":"",e.vertexAlphas?"#define USE_COLOR_ALPHA":"",e.vertexUvs?"#define USE_UV":"",e.uvsVertexOnly?"#define UVS_VERTEX_ONLY":"",e.gradientMap?"#define USE_GRADIENTMAP":"",e.flatShading?"#define FLAT_SHADED":"",e.doubleSided?"#define DOUBLE_SIDED":"",e.flipSided?"#define FLIP_SIDED":"",e.shadowMapEnabled?"#define USE_SHADOWMAP":"",e.shadowMapEnabled?"#define "+l:"",e.premultipliedAlpha?"#define PREMULTIPLIED_ALPHA":"",e.physicallyCorrectLights?"#define PHYSICALLY_CORRECT_LIGHTS":"",e.logarithmicDepthBuffer?"#define USE_LOGDEPTHBUF":"",e.logarithmicDepthBuffer&&e.rendererExtensionFragDepth?"#define USE_LOGDEPTHBUF_EXT":"",(e.extensionShaderTextureLOD||e.envMap)&&e.rendererExtensionShaderTextureLod?"#define TEXTURE_LOD_EXT":"","uniform mat4 viewMatrix;","uniform vec3 cameraPosition;","uniform bool isOrthographic;",e.toneMapping!==ti?"#define TONE_MAPPING":"",e.toneMapping!==ti?Pt.tonemapping_pars_fragment:"",e.toneMapping!==ti?eE("toneMapping",e.toneMapping):"",e.dithering?"#define DITHERING":"",e.alphaWrite?"":"#define OPAQUE",Pt.encodings_pars_fragment,tE("linearToOutputTexel",e.outputEncoding),e.depthPacking?"#define DEPTH_PACKING "+e.depthPacking:"",`
`].filter($s).join(`
`)),o=qu(o),o=Lg(o,e),o=Pg(o,e),a=qu(a),a=Lg(a,e),a=Pg(a,e),o=Dg(o),a=Dg(a),e.isWebGL2&&e.isRawShaderMaterial!==!0&&(m=`#version 300 es
`,x=["precision mediump sampler2DArray;","#define attribute in","#define varying out","#define texture2D texture"].join(`
`)+`
`+x,v=["#define varying in",e.glslVersion===ng?"":"layout(location = 0) out highp vec4 pc_fragColor;",e.glslVersion===ng?"":"#define gl_FragColor pc_fragColor","#define gl_FragDepthEXT gl_FragDepth","#define texture2D texture","#define textureCube texture","#define texture2DProj textureProj","#define texture2DLodEXT textureLod","#define texture2DProjLodEXT textureProjLod","#define textureCubeLodEXT textureLod","#define texture2DGradEXT textureGrad","#define texture2DProjGradEXT textureProjGrad","#define textureCubeGradEXT textureGrad"].join(`
`)+`
`+v);let p=m+x+o,b=m+v+a,_=Cg(r,35633,p),S=Cg(r,35632,b);if(r.attachShader(g,_),r.attachShader(g,S),e.index0AttributeName!==void 0?r.bindAttribLocation(g,0,e.index0AttributeName):e.morphTargets===!0&&r.bindAttribLocation(g,0,"position"),r.linkProgram(g),n.debug.checkShaderErrors){let H=r.getProgramInfoLog(g).trim(),tt=r.getShaderInfoLog(_).trim(),X=r.getShaderInfoLog(S).trim(),y=!0,R=!0;if(r.getProgramParameter(g,35714)===!1){y=!1;let D=Rg(r,_,"vertex"),F=Rg(r,S,"fragment");console.error("THREE.WebGLProgram: Shader Error "+r.getError()+" - VALIDATE_STATUS "+r.getProgramParameter(g,35715)+`

Program Info Log: `+H+`
`+D+`
`+F)}else H!==""?console.warn("THREE.WebGLProgram: Program Info Log:",H):(tt===""||X==="")&&(R=!1);R&&(this.diagnostics={runnable:y,programLog:H,vertexShader:{log:tt,prefix:x},fragmentShader:{log:X,prefix:v}})}r.deleteShader(_),r.deleteShader(S);let L;this.getUniforms=function(){return L===void 0&&(L=new ii(r,g)),L};let A;return this.getAttributes=function(){return A===void 0&&(A=rE(r,g)),A},this.destroy=function(){i.releaseStatesOfProgram(this),r.deleteProgram(g),this.program=void 0},this.name=e.shaderName,this.id=KS++,this.cacheKey=t,this.usedTimes=1,this.program=g,this.vertexShader=_,this.fragmentShader=S,this}var mE=0,Xu=class{constructor(){this.shaderCache=new Map,this.materialCache=new Map}update(t){let e=t.vertexShader,i=t.fragmentShader,r=this._getShaderStage(e),s=this._getShaderStage(i),o=this._getShaderCacheForMaterial(t);return o.has(r)===!1&&(o.add(r),r.usedTimes++),o.has(s)===!1&&(o.add(s),s.usedTimes++),this}remove(t){let e=this.materialCache.get(t);for(let i of e)i.usedTimes--,i.usedTimes===0&&this.shaderCache.delete(i);return this.materialCache.delete(t),this}getVertexShaderID(t){return this._getShaderStage(t.vertexShader).id}getFragmentShaderID(t){return this._getShaderStage(t.fragmentShader).id}dispose(){this.shaderCache.clear(),this.materialCache.clear()}_getShaderCacheForMaterial(t){let e=this.materialCache;return e.has(t)===!1&&e.set(t,new Set),e.get(t)}_getShaderStage(t){let e=this.shaderCache;if(e.has(t)===!1){let i=new Yu;e.set(t,i)}return e.get(t)}},Yu=class{constructor(){this.id=mE++,this.usedTimes=0}};function gE(n,t,e,i,r,s,o){let a=new il,l=new Xu,c=[],u=r.isWebGL2,h=r.logarithmicDepthBuffer,f=r.floatVertexTextures,d=r.maxVertexUniforms,g=r.vertexTextures,x=r.precision,v={MeshDepthMaterial:"depth",MeshDistanceMaterial:"distanceRGBA",MeshNormalMaterial:"normal",MeshBasicMaterial:"basic",MeshLambertMaterial:"lambert",MeshPhongMaterial:"phong",MeshToonMaterial:"toon",MeshStandardMaterial:"physical",MeshPhysicalMaterial:"physical",MeshMatcapMaterial:"matcap",LineBasicMaterial:"basic",LineDashedMaterial:"dashed",PointsMaterial:"points",ShadowMaterial:"shadow",SpriteMaterial:"sprite"};function m(y){let D=y.skeleton.bones;if(f)return 1024;{let z=Math.floor((d-20)/4),N=Math.min(z,D.length);return N<D.length?(console.warn("THREE.WebGLRenderer: Skeleton has "+D.length+" bones. This GPU supports "+N+"."),0):N}}function p(y,R,D,F,z){let N=F.fog,V=y.isMeshStandardMaterial?F.environment:null,Q=(y.isMeshStandardMaterial?e:t).get(y.envMap||V),at=v[y.type],G=z.isSkinnedMesh?m(z):0;y.precision!==null&&(x=r.getMaxPrecision(y.precision),x!==y.precision&&console.warn("THREE.WebGLProgram.getParameters:",y.precision,"not supported, using",x,"instead."));let $,lt,dt,xt;if(at){let B=fn[at];$=B.vertexShader,lt=B.fragmentShader}else $=y.vertexShader,lt=y.fragmentShader,l.update(y),dt=l.getVertexShaderID(y),xt=l.getFragmentShaderID(y);let k=n.getRenderTarget(),Ft=y.alphaTest>0,mt=y.clearcoat>0;return{isWebGL2:u,shaderID:at,shaderName:y.type,vertexShader:$,fragmentShader:lt,defines:y.defines,customVertexShaderID:dt,customFragmentShaderID:xt,isRawShaderMaterial:y.isRawShaderMaterial===!0,glslVersion:y.glslVersion,precision:x,instancing:z.isInstancedMesh===!0,instancingColor:z.isInstancedMesh===!0&&z.instanceColor!==null,supportsVertexTextures:g,outputEncoding:k===null?n.outputEncoding:k.isXRRenderTarget===!0?k.texture.encoding:ri,map:!!y.map,matcap:!!y.matcap,envMap:!!Q,envMapMode:Q&&Q.mapping,envMapCubeUV:!!Q&&(Q.mapping===Rl||Q.mapping===Kh),lightMap:!!y.lightMap,aoMap:!!y.aoMap,emissiveMap:!!y.emissiveMap,bumpMap:!!y.bumpMap,normalMap:!!y.normalMap,objectSpaceNormalMap:y.normalMapType===jw,tangentSpaceNormalMap:y.normalMapType===ts,decodeVideoTexture:!!y.map&&y.map.isVideoTexture===!0&&y.map.encoding===$t,clearcoat:mt,clearcoatMap:mt&&!!y.clearcoatMap,clearcoatRoughnessMap:mt&&!!y.clearcoatRoughnessMap,clearcoatNormalMap:mt&&!!y.clearcoatNormalMap,displacementMap:!!y.displacementMap,roughnessMap:!!y.roughnessMap,metalnessMap:!!y.metalnessMap,specularMap:!!y.specularMap,specularIntensityMap:!!y.specularIntensityMap,specularColorMap:!!y.specularColorMap,alphaMap:!!y.alphaMap,alphaTest:Ft,alphaWrite:y.alphaWrite||y.transparent,gradientMap:!!y.gradientMap,sheen:y.sheen>0,sheenColorMap:!!y.sheenColorMap,sheenRoughnessMap:!!y.sheenRoughnessMap,transmission:y.transmission>0,transmissionMap:!!y.transmissionMap,thicknessMap:!!y.thicknessMap,combine:y.combine,vertexTangents:!!y.normalMap&&!!z.geometry&&!!z.geometry.attributes.tangent,vertexColors:y.vertexColors,vertexAlphas:y.vertexColors===!0&&!!z.geometry&&!!z.geometry.attributes.color&&z.geometry.attributes.color.itemSize===4,vertexUvs:!!y.map||!!y.bumpMap||!!y.normalMap||!!y.specularMap||!!y.alphaMap||!!y.emissiveMap||!!y.roughnessMap||!!y.metalnessMap||!!y.clearcoatMap||!!y.clearcoatRoughnessMap||!!y.clearcoatNormalMap||!!y.displacementMap||!!y.transmissionMap||!!y.thicknessMap||!!y.specularIntensityMap||!!y.specularColorMap||!!y.sheenColorMap||!!y.sheenRoughnessMap,uvsVertexOnly:!(!!y.map||!!y.bumpMap||!!y.normalMap||!!y.specularMap||!!y.alphaMap||!!y.emissiveMap||!!y.roughnessMap||!!y.metalnessMap||!!y.clearcoatNormalMap||y.transmission>0||!!y.transmissionMap||!!y.thicknessMap||!!y.specularIntensityMap||!!y.specularColorMap||y.sheen>0||!!y.sheenColorMap||!!y.sheenRoughnessMap)&&!!y.displacementMap,fog:!!N,useFog:y.fog,fogExp2:N&&N.isFogExp2,flatShading:!!y.flatShading,sizeAttenuation:y.sizeAttenuation,logarithmicDepthBuffer:h,skinning:z.isSkinnedMesh===!0&&G>0,maxBones:G,useVertexTexture:f,morphTargets:!!z.geometry&&!!z.geometry.morphAttributes.position,morphNormals:!!z.geometry&&!!z.geometry.morphAttributes.normal,morphTargetsCount:!!z.geometry&&!!z.geometry.morphAttributes.position?z.geometry.morphAttributes.position.length:0,numDirLights:R.directional.length,numPointLights:R.point.length,numSpotLights:R.spot.length,numRectAreaLights:R.rectArea.length,numHemiLights:R.hemi.length,numDirLightShadows:R.directionalShadowMap.length,numPointLightShadows:R.pointShadowMap.length,numSpotLightShadows:R.spotShadowMap.length,numClippingPlanes:o.numPlanes,numClipIntersection:o.numIntersection,dithering:y.dithering,shadowMapEnabled:n.shadowMap.enabled&&D.length>0,shadowMapType:n.shadowMap.type,toneMapping:y.toneMapped?n.toneMapping:ti,physicallyCorrectLights:n.physicallyCorrectLights,premultipliedAlpha:y.premultipliedAlpha,doubleSided:y.side===Hr,flipSided:y.side===he,depthPacking:y.depthPacking!==void 0?y.depthPacking:!1,index0AttributeName:y.index0AttributeName,extensionDerivatives:y.extensions&&y.extensions.derivatives,extensionFragDepth:y.extensions&&y.extensions.fragDepth,extensionDrawBuffers:y.extensions&&y.extensions.drawBuffers,extensionShaderTextureLOD:y.extensions&&y.extensions.shaderTextureLOD,rendererExtensionFragDepth:u||i.has("EXT_frag_depth"),rendererExtensionDrawBuffers:u||i.has("WEBGL_draw_buffers"),rendererExtensionShaderTextureLod:u||i.has("EXT_shader_texture_lod"),customProgramCacheKey:y.customProgramCacheKey()}}function b(y){let R=[];if(y.shaderID?R.push(y.shaderID):(R.push(y.customVertexShaderID),R.push(y.customFragmentShaderID)),y.defines!==void 0)for(let D in y.defines)R.push(D),R.push(y.defines[D]);return y.isRawShaderMaterial===!1&&(_(R,y),S(R,y),R.push(n.outputEncoding)),R.push(y.customProgramCacheKey),R.join()}function _(y,R){y.push(R.precision),y.push(R.outputEncoding),y.push(R.envMapMode),y.push(R.combine),y.push(R.vertexUvs),y.push(R.fogExp2),y.push(R.sizeAttenuation),y.push(R.maxBones),y.push(R.morphTargetsCount),y.push(R.numDirLights),y.push(R.numPointLights),y.push(R.numSpotLights),y.push(R.numHemiLights),y.push(R.numRectAreaLights),y.push(R.numDirLightShadows),y.push(R.numPointLightShadows),y.push(R.numSpotLightShadows),y.push(R.shadowMapType),y.push(R.toneMapping),y.push(R.numClippingPlanes),y.push(R.numClipIntersection),y.push(R.alphaWrite)}function S(y,R){a.disableAll(),R.isWebGL2&&a.enable(0),R.supportsVertexTextures&&a.enable(1),R.instancing&&a.enable(2),R.instancingColor&&a.enable(3),R.map&&a.enable(4),R.matcap&&a.enable(5),R.envMap&&a.enable(6),R.envMapCubeUV&&a.enable(7),R.lightMap&&a.enable(8),R.aoMap&&a.enable(9),R.emissiveMap&&a.enable(10),R.bumpMap&&a.enable(11),R.normalMap&&a.enable(12),R.objectSpaceNormalMap&&a.enable(13),R.tangentSpaceNormalMap&&a.enable(14),R.clearcoat&&a.enable(15),R.clearcoatMap&&a.enable(16),R.clearcoatRoughnessMap&&a.enable(17),R.clearcoatNormalMap&&a.enable(18),R.displacementMap&&a.enable(19),R.specularMap&&a.enable(20),R.roughnessMap&&a.enable(21),R.metalnessMap&&a.enable(22),R.gradientMap&&a.enable(23),R.alphaMap&&a.enable(24),R.alphaTest&&a.enable(25),R.vertexColors&&a.enable(26),R.vertexAlphas&&a.enable(27),R.vertexUvs&&a.enable(28),R.vertexTangents&&a.enable(29),R.uvsVertexOnly&&a.enable(30),R.fog&&a.enable(31),y.push(a.mask),a.disableAll(),R.useFog&&a.enable(0),R.flatShading&&a.enable(1),R.logarithmicDepthBuffer&&a.enable(2),R.skinning&&a.enable(3),R.useVertexTexture&&a.enable(4),R.morphTargets&&a.enable(5),R.morphNormals&&a.enable(6),R.premultipliedAlpha&&a.enable(7),R.shadowMapEnabled&&a.enable(8),R.physicallyCorrectLights&&a.enable(9),R.doubleSided&&a.enable(10),R.flipSided&&a.enable(11),R.depthPacking&&a.enable(12),R.dithering&&a.enable(13),R.specularIntensityMap&&a.enable(14),R.specularColorMap&&a.enable(15),R.transmission&&a.enable(16),R.transmissionMap&&a.enable(17),R.thicknessMap&&a.enable(18),R.sheen&&a.enable(19),R.sheenColorMap&&a.enable(20),R.sheenRoughnessMap&&a.enable(21),R.decodeVideoTexture&&a.enable(22),y.push(a.mask)}function L(y){let R=v[y.type],D;if(R){let F=fn[R];D=pM.clone(F.uniforms)}else D=y.uniforms;return D}function A(y,R){let D;for(let F=0,z=c.length;F<z;F++){let N=c[F];if(N.cacheKey===R){D=N,++D.usedTimes;break}}return D===void 0&&(D=new pE(n,R,y,s),c.push(D)),D}function H(y){if(--y.usedTimes===0){let R=c.indexOf(y);c[R]=c[c.length-1],c.pop(),y.destroy()}}function tt(y){l.remove(y)}function X(){l.dispose()}return{getParameters:p,getProgramCacheKey:b,getUniforms:L,acquireProgram:A,releaseProgram:H,releaseShaderCache:tt,programs:c,dispose:X}}function xE(){let n=new WeakMap;function t(s){let o=n.get(s);return o===void 0&&(o={},n.set(s,o)),o}function e(s){n.delete(s)}function i(s,o,a){n.get(s)[o]=a}function r(){n=new WeakMap}return{get:t,remove:e,update:i,dispose:r}}function yE(n,t){return n.groupOrder!==t.groupOrder?n.groupOrder-t.groupOrder:n.renderOrder!==t.renderOrder?n.renderOrder-t.renderOrder:n.material.id!==t.material.id?n.material.id-t.material.id:n.z!==t.z?n.z-t.z:n.id-t.id}function Ng(n,t){return n.groupOrder!==t.groupOrder?n.groupOrder-t.groupOrder:n.renderOrder!==t.renderOrder?n.renderOrder-t.renderOrder:n.z!==t.z?t.z-n.z:n.id-t.id}function Fg(){let n=[],t=0,e=[],i=[],r=[];function s(){t=0,e.length=0,i.length=0,r.length=0}function o(h,f,d,g,x,v){let m=n[t];return m===void 0?(m={id:h.id,object:h,geometry:f,material:d,groupOrder:g,renderOrder:h.renderOrder,z:x,group:v},n[t]=m):(m.id=h.id,m.object=h,m.geometry=f,m.material=d,m.groupOrder=g,m.renderOrder=h.renderOrder,m.z=x,m.group=v),t++,m}function a(h,f,d,g,x,v){let m=o(h,f,d,g,x,v);d.transmission>0?i.push(m):d.transparent===!0?r.push(m):e.push(m)}function l(h,f,d,g,x,v){let m=o(h,f,d,g,x,v);d.transmission>0?i.unshift(m):d.transparent===!0?r.unshift(m):e.unshift(m)}function c(h,f){e.length>1&&e.sort(h||yE),i.length>1&&i.sort(f||Ng),r.length>1&&r.sort(f||Ng)}function u(){for(let h=t,f=n.length;h<f;h++){let d=n[h];if(d.id===null)break;d.id=null,d.object=null,d.geometry=null,d.material=null,d.group=null}}return{opaque:e,transmissive:i,transparent:r,init:s,push:a,unshift:l,finish:u,sort:c}}function vE(){let n=new WeakMap;function t(i,r){let s;return n.has(i)===!1?(s=new Fg,n.set(i,[s])):r>=n.get(i).length?(s=new Fg,n.get(i).push(s)):s=n.get(i)[r],s}function e(){n=new WeakMap}return{get:t,dispose:e}}function _E(){let n={};return{get:function(t){if(n[t.id]!==void 0)return n[t.id];let e;switch(t.type){case"DirectionalLight":e={direction:new T,color:new ft};break;case"SpotLight":e={position:new T,direction:new T,color:new ft,distance:0,coneCos:0,penumbraCos:0,decay:0};break;case"PointLight":e={position:new T,color:new ft,distance:0,decay:0};break;case"HemisphereLight":e={direction:new T,skyColor:new ft,groundColor:new ft};break;case"RectAreaLight":e={color:new ft,position:new T,halfWidth:new T,halfHeight:new T};break}return n[t.id]=e,e}}}function wE(){let n={};return{get:function(t){if(n[t.id]!==void 0)return n[t.id];let e;switch(t.type){case"DirectionalLight":e={shadowBias:0,shadowNormalBias:0,shadowRadius:1,shadowMapSize:new K};break;case"SpotLight":e={shadowBias:0,shadowNormalBias:0,shadowRadius:1,shadowMapSize:new K};break;case"PointLight":e={shadowBias:0,shadowNormalBias:0,shadowRadius:1,shadowMapSize:new K,shadowCameraNear:1,shadowCameraFar:1e3};break}return n[t.id]=e,e}}}var ME=0;function bE(n,t){return(t.castShadow?1:0)-(n.castShadow?1:0)}function SE(n,t){let e=new _E,i=wE(),r={version:0,hash:{directionalLength:-1,pointLength:-1,spotLength:-1,rectAreaLength:-1,hemiLength:-1,numDirectionalShadows:-1,numPointShadows:-1,numSpotShadows:-1},ambient:[0,0,0],probe:[],directional:[],directionalShadow:[],directionalShadowMap:[],directionalShadowMatrix:[],spot:[],spotShadow:[],spotShadowMap:[],spotShadowMatrix:[],rectArea:[],rectAreaLTC1:null,rectAreaLTC2:null,point:[],pointShadow:[],pointShadowMap:[],pointShadowMatrix:[],hemi:[]};for(let u=0;u<9;u++)r.probe.push(new T);let s=new T,o=new wt,a=new wt;function l(u,h){let f=0,d=0,g=0;for(let tt=0;tt<9;tt++)r.probe[tt].set(0,0,0);let x=0,v=0,m=0,p=0,b=0,_=0,S=0,L=0;u.sort(bE);let A=h!==!0?Math.PI:1;for(let tt=0,X=u.length;tt<X;tt++){let y=u[tt],R=y.color,D=y.intensity,F=y.distance,z=y.shadow&&y.shadow.map?y.shadow.map.texture:null;if(y.isAmbientLight)f+=R.r*D*A,d+=R.g*D*A,g+=R.b*D*A;else if(y.isLightProbe)for(let N=0;N<9;N++)r.probe[N].addScaledVector(y.sh.coefficients[N],D);else if(y.isDirectionalLight){let N=e.get(y);if(N.color.copy(y.color).multiplyScalar(y.intensity*A),y.castShadow){let V=y.shadow,Q=i.get(y);Q.shadowBias=V.bias,Q.shadowNormalBias=V.normalBias,Q.shadowRadius=V.radius,Q.shadowMapSize=V.mapSize,r.directionalShadow[x]=Q,r.directionalShadowMap[x]=z,r.directionalShadowMatrix[x]=y.shadow.matrix,_++}r.directional[x]=N,x++}else if(y.isSpotLight){let N=e.get(y);if(N.position.setFromMatrixPosition(y.matrixWorld),N.color.copy(R).multiplyScalar(D*A),N.distance=F,N.coneCos=Math.cos(y.angle),N.penumbraCos=Math.cos(y.angle*(1-y.penumbra)),N.decay=y.decay,y.castShadow){let V=y.shadow,Q=i.get(y);Q.shadowBias=V.bias,Q.shadowNormalBias=V.normalBias,Q.shadowRadius=V.radius,Q.shadowMapSize=V.mapSize,r.spotShadow[m]=Q,r.spotShadowMap[m]=z,r.spotShadowMatrix[m]=y.shadow.matrix,L++}r.spot[m]=N,m++}else if(y.isRectAreaLight){let N=e.get(y);N.color.copy(R).multiplyScalar(D),N.halfWidth.set(y.width*.5,0,0),N.halfHeight.set(0,y.height*.5,0),r.rectArea[p]=N,p++}else if(y.isPointLight){let N=e.get(y);if(N.color.copy(y.color).multiplyScalar(y.intensity*A),N.distance=y.distance,N.decay=y.decay,y.castShadow){let V=y.shadow,Q=i.get(y);Q.shadowBias=V.bias,Q.shadowNormalBias=V.normalBias,Q.shadowRadius=V.radius,Q.shadowMapSize=V.mapSize,Q.shadowCameraNear=V.camera.near,Q.shadowCameraFar=V.camera.far,r.pointShadow[v]=Q,r.pointShadowMap[v]=z,r.pointShadowMatrix[v]=y.shadow.matrix,S++}r.point[v]=N,v++}else if(y.isHemisphereLight){let N=e.get(y);N.skyColor.copy(y.color).multiplyScalar(D*A),N.groundColor.copy(y.groundColor).multiplyScalar(D*A),r.hemi[b]=N,b++}}p>0&&(t.isWebGL2||n.has("OES_texture_float_linear")===!0?(r.rectAreaLTC1=ot.LTC_FLOAT_1,r.rectAreaLTC2=ot.LTC_FLOAT_2):n.has("OES_texture_half_float_linear")===!0?(r.rectAreaLTC1=ot.LTC_HALF_1,r.rectAreaLTC2=ot.LTC_HALF_2):console.error("THREE.WebGLRenderer: Unable to use RectAreaLight. Missing WebGL extensions.")),r.ambient[0]=f,r.ambient[1]=d,r.ambient[2]=g;let H=r.hash;(H.directionalLength!==x||H.pointLength!==v||H.spotLength!==m||H.rectAreaLength!==p||H.hemiLength!==b||H.numDirectionalShadows!==_||H.numPointShadows!==S||H.numSpotShadows!==L)&&(r.directional.length=x,r.spot.length=m,r.rectArea.length=p,r.point.length=v,r.hemi.length=b,r.directionalShadow.length=_,r.directionalShadowMap.length=_,r.pointShadow.length=S,r.pointShadowMap.length=S,r.spotShadow.length=L,r.spotShadowMap.length=L,r.directionalShadowMatrix.length=_,r.pointShadowMatrix.length=S,r.spotShadowMatrix.length=L,H.directionalLength=x,H.pointLength=v,H.spotLength=m,H.rectAreaLength=p,H.hemiLength=b,H.numDirectionalShadows=_,H.numPointShadows=S,H.numSpotShadows=L,r.version=ME++)}function c(u,h){let f=0,d=0,g=0,x=0,v=0,m=h.matrixWorldInverse;for(let p=0,b=u.length;p<b;p++){let _=u[p];if(_.isDirectionalLight){let S=r.directional[f];S.direction.setFromMatrixPosition(_.matrixWorld),s.setFromMatrixPosition(_.target.matrixWorld),S.direction.sub(s),S.direction.transformDirection(m),f++}else if(_.isSpotLight){let S=r.spot[g];S.position.setFromMatrixPosition(_.matrixWorld),S.position.applyMatrix4(m),S.direction.setFromMatrixPosition(_.matrixWorld),s.setFromMatrixPosition(_.target.matrixWorld),S.direction.sub(s),S.direction.transformDirection(m),g++}else if(_.isRectAreaLight){let S=r.rectArea[x];S.position.setFromMatrixPosition(_.matrixWorld),S.position.applyMatrix4(m),a.identity(),o.copy(_.matrixWorld),o.premultiply(m),a.extractRotation(o),S.halfWidth.set(_.width*.5,0,0),S.halfHeight.set(0,_.height*.5,0),S.halfWidth.applyMatrix4(a),S.halfHeight.applyMatrix4(a),x++}else if(_.isPointLight){let S=r.point[d];S.position.setFromMatrixPosition(_.matrixWorld),S.position.applyMatrix4(m),d++}else if(_.isHemisphereLight){let S=r.hemi[v];S.direction.setFromMatrixPosition(_.matrixWorld),S.direction.transformDirection(m),S.direction.normalize(),v++}}}return{setup:l,setupView:c,state:r}}function zg(n,t){let e=new SE(n,t),i=[],r=[];function s(){i.length=0,r.length=0}function o(h){i.push(h)}function a(h){r.push(h)}function l(h){e.setup(i,h)}function c(h){e.setupView(i,h)}return{init:s,state:{lightsArray:i,shadowsArray:r,lights:e},setupLights:l,setupLightsView:c,pushLight:o,pushShadow:a}}function EE(n,t){let e=new WeakMap;function i(s,o=0){let a;return e.has(s)===!1?(a=new zg(n,t),e.set(s,[a])):o>=e.get(s).length?(a=new zg(n,t),e.get(s).push(a)):a=e.get(s)[o],a}function r(){e=new WeakMap}return{get:i,dispose:r}}var cl=class extends xe{constructor(t){super(),this.type="MeshDepthMaterial",this.depthPacking=Kw,this.map=null,this.alphaMap=null,this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.wireframe=!1,this.wireframeLinewidth=1,this.fog=!1,this.setValues(t)}copy(t){return super.copy(t),this.depthPacking=t.depthPacking,this.map=t.map,this.alphaMap=t.alphaMap,this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this}};cl.prototype.isMeshDepthMaterial=!0;var ul=class extends xe{constructor(t){super(),this.type="MeshDistanceMaterial",this.referencePosition=new T,this.nearDistance=1,this.farDistance=1e3,this.map=null,this.alphaMap=null,this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.fog=!1,this.setValues(t)}copy(t){return super.copy(t),this.referencePosition.copy(t.referencePosition),this.nearDistance=t.nearDistance,this.farDistance=t.farDistance,this.map=t.map,this.alphaMap=t.alphaMap,this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this}};ul.prototype.isMeshDistanceMaterial=!0;var TE=`void main() {
	gl_Position = vec4( position, 1.0 );
}`,AE=`uniform sampler2D shadow_pass;
uniform vec2 resolution;
uniform float radius;
#include <packing>
void main() {
	const float samples = float( VSM_SAMPLES );
	float mean = 0.0;
	float squared_mean = 0.0;
	float uvStride = samples <= 1.0 ? 0.0 : 2.0 / ( samples - 1.0 );
	float uvStart = samples <= 1.0 ? 0.0 : - 1.0;
	for ( float i = 0.0; i < samples; i ++ ) {
		float uvOffset = uvStart + i * uvStride;
		#ifdef HORIZONTAL_PASS
			vec2 distribution = unpackRGBATo2Half( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( uvOffset, 0.0 ) * radius ) / resolution ) );
			mean += distribution.x;
			squared_mean += distribution.y * distribution.y + distribution.x * distribution.x;
		#else
			float depth = unpackRGBAToDepth( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( 0.0, uvOffset ) * radius ) / resolution ) );
			mean += depth;
			squared_mean += depth * depth;
		#endif
	}
	mean = mean / samples;
	squared_mean = squared_mean / samples;
	float std_dev = sqrt( squared_mean - mean * mean );
	gl_FragColor = pack2HalfToRGBA( vec2( mean, std_dev ) );
}`;function T0(n,t,e){let i=new qr,r=new K,s=new K,o=new Wt,a=new cl({depthPacking:Qw}),l=new ul,c={},u=e.maxTextureSize,h={0:he,1:eo,2:Hr},f=new Fn({defines:{VSM_SAMPLES:8},uniforms:{shadow_pass:{value:null},resolution:{value:new K},radius:{value:4}},vertexShader:TE,fragmentShader:AE}),d=f.clone();d.defines.HORIZONTAL_PASS=1;let g=new Ht;g.setAttribute("position",new Qt(new Float32Array([-1,-1,.5,3,-1,.5,-1,3,.5]),3));let x=new oe(g,f),v=this;this.enabled=!1,this.autoUpdate=!0,this.needsUpdate=!1,this.type=l0,this.render=function(_,S,L){if(v.enabled===!1||v.autoUpdate===!1&&v.needsUpdate===!1||_.length===0)return;let A=n.getRenderTarget(),H=n.getActiveCubeFace(),tt=n.getActiveMipmapLevel(),X=n.state;X.setBlending(jn),X.buffers.color.setClear(1,1,1,1),X.buffers.depth.setTest(!0),X.setScissorTest(!1);for(let y=0,R=_.length;y<R;y++){let D=_[y],F=D.shadow;if(F===void 0){console.warn("THREE.WebGLShadowMap:",D,"has no shadow.");continue}if(F.autoUpdate===!1&&F.needsUpdate===!1)continue;r.copy(F.mapSize);let z=F.getFrameExtents();if(r.multiply(z),s.copy(F.mapSize),(r.x>u||r.y>u)&&(r.x>u&&(s.x=Math.floor(u/z.x),r.x=s.x*z.x,F.mapSize.x=s.x),r.y>u&&(s.y=Math.floor(u/z.y),r.y=s.y*z.y,F.mapSize.y=s.y)),F.map===null&&!F.isPointLightShadow&&this.type===Js){let V={minFilter:be,magFilter:be,format:Re};F.map=new Ne(r.x,r.y,V),F.map.texture.name=D.name+".shadowMap",F.mapPass=new Ne(r.x,r.y,V),F.camera.updateProjectionMatrix()}if(F.map===null){let V={minFilter:fe,magFilter:fe,format:Re};F.map=new Ne(r.x,r.y,V),F.map.texture.name=D.name+".shadowMap",F.camera.updateProjectionMatrix()}n.setRenderTarget(F.map),n.clear();let N=F.getViewportCount();for(let V=0;V<N;V++){let Q=F.getViewport(V);o.set(s.x*Q.x,s.y*Q.y,s.x*Q.z,s.y*Q.w),X.viewport(o),F.updateMatrices(D,V),i=F.getFrustum(),b(S,L,F.camera,D,this.type)}!F.isPointLightShadow&&this.type===Js&&m(F,L),F.needsUpdate=!1}v.needsUpdate=!1,n.setRenderTarget(A,H,tt)};function m(_,S){let L=t.update(x);f.defines.VSM_SAMPLES!==_.blurSamples&&(f.defines.VSM_SAMPLES=_.blurSamples,d.defines.VSM_SAMPLES=_.blurSamples,f.needsUpdate=!0,d.needsUpdate=!0),f.uniforms.shadow_pass.value=_.map.texture,f.uniforms.resolution.value=_.mapSize,f.uniforms.radius.value=_.radius,n.setRenderTarget(_.mapPass),n.clear(),n.renderBufferDirect(S,null,L,f,x,null),d.uniforms.shadow_pass.value=_.mapPass.texture,d.uniforms.resolution.value=_.mapSize,d.uniforms.radius.value=_.radius,n.setRenderTarget(_.map),n.clear(),n.renderBufferDirect(S,null,L,d,x,null)}function p(_,S,L,A,H,tt,X){let y=null,R=A.isPointLight===!0?_.customDistanceMaterial:_.customDepthMaterial;if(R!==void 0?y=R:y=A.isPointLight===!0?l:a,n.localClippingEnabled&&L.clipShadows===!0&&L.clippingPlanes.length!==0||L.displacementMap&&L.displacementScale!==0||L.alphaMap&&L.alphaTest>0){let D=y.uuid,F=L.uuid,z=c[D];z===void 0&&(z={},c[D]=z);let N=z[F];N===void 0&&(N=y.clone(),z[F]=N),y=N}return y.visible=L.visible,y.wireframe=L.wireframe,X===Js?y.side=L.shadowSide!==null?L.shadowSide:L.side:y.side=L.shadowSide!==null?L.shadowSide:h[L.side],y.alphaMap=L.alphaMap,y.alphaTest=L.alphaTest,y.clipShadows=L.clipShadows,y.clippingPlanes=L.clippingPlanes,y.clipIntersection=L.clipIntersection,y.displacementMap=L.displacementMap,y.displacementScale=L.displacementScale,y.displacementBias=L.displacementBias,y.wireframeLinewidth=L.wireframeLinewidth,y.linewidth=L.linewidth,A.isPointLight===!0&&y.isMeshDistanceMaterial===!0&&(y.referencePosition.setFromMatrixPosition(A.matrixWorld),y.nearDistance=H,y.farDistance=tt),y}function b(_,S,L,A,H){if(_.visible===!1)return;if(_.layers.test(S.layers)&&(_.isMesh||_.isLine||_.isPoints)&&(_.castShadow||_.receiveShadow&&H===Js)&&(!_.frustumCulled||i.intersectsObject(_))){_.modelViewMatrix.multiplyMatrices(L.matrixWorldInverse,_.matrixWorld);let y=t.update(_),R=_.material;if(Array.isArray(R)){let D=y.groups;for(let F=0,z=D.length;F<z;F++){let N=D[F],V=R[N.materialIndex];if(V&&V.visible){let Q=p(_,y,V,A,L.near,L.far,H);n.renderBufferDirect(L,null,y,Q,_,N)}}}else if(R.visible){let D=p(_,y,R,A,L.near,L.far,H);n.renderBufferDirect(L,null,y,D,_,null)}}let X=_.children;for(let y=0,R=X.length;y<R;y++)b(X[y],S,L,A,H)}}function CE(n,t,e){let i=e.isWebGL2;function r(){let P=!1,pt=new Wt,ht=null,Et=new Wt(0,0,0,0);return{setMask:function(Y){ht!==Y&&!P&&(n.colorMask(Y,Y,Y,Y),ht=Y)},setLocked:function(Y){P=Y},setClear:function(Y,Mt,Dt,jt,ze){ze===!0&&(Y*=jt,Mt*=jt,Dt*=jt),pt.set(Y,Mt,Dt,jt),Et.equals(pt)===!1&&(n.clearColor(Y,Mt,Dt,jt),Et.copy(pt))},reset:function(){P=!1,ht=null,Et.set(-1,0,0,0)}}}function s(){let P=!1,pt=null,ht=null,Et=null;return{setTest:function(Y){Y?k(2929):Ft(2929)},setMask:function(Y){pt!==Y&&!P&&(n.depthMask(Y),pt=Y)},setFunc:function(Y){if(ht!==Y){if(Y)switch(Y){case yw:n.depthFunc(512);break;case vw:n.depthFunc(519);break;case _w:n.depthFunc(513);break;case zu:n.depthFunc(515);break;case ww:n.depthFunc(514);break;case Mw:n.depthFunc(518);break;case bw:n.depthFunc(516);break;case Sw:n.depthFunc(517);break;default:n.depthFunc(515)}else n.depthFunc(515);ht=Y}},setLocked:function(Y){P=Y},setClear:function(Y){Et!==Y&&(n.clearDepth(Y),Et=Y)},reset:function(){P=!1,pt=null,ht=null,Et=null}}}function o(){let P=!1,pt=null,ht=null,Et=null,Y=null,Mt=null,Dt=null,jt=null,ze=null;return{setTest:function(ne){P||(ne?k(2960):Ft(2960))},setMask:function(ne){pt!==ne&&!P&&(n.stencilMask(ne),pt=ne)},setFunc:function(ne,en,yn){(ht!==ne||Et!==en||Y!==yn)&&(n.stencilFunc(ne,en,yn),ht=ne,Et=en,Y=yn)},setOp:function(ne,en,yn){(Mt!==ne||Dt!==en||jt!==yn)&&(n.stencilOp(ne,en,yn),Mt=ne,Dt=en,jt=yn)},setLocked:function(ne){P=ne},setClear:function(ne){ze!==ne&&(n.clearStencil(ne),ze=ne)},reset:function(){P=!1,pt=null,ht=null,Et=null,Y=null,Mt=null,Dt=null,jt=null,ze=null}}}let a=new r,l=new s,c=new o,u={},h={},f=new WeakMap,d=[],g=null,x=!1,v=null,m=null,p=null,b=null,_=null,S=null,L=null,A=!1,H=null,tt=null,X=null,y=null,R=null,D=n.getParameter(35661),F=!1,z=0,N=n.getParameter(7938);N.indexOf("WebGL")!==-1?(z=parseFloat(/^WebGL (\d)/.exec(N)[1]),F=z>=1):N.indexOf("OpenGL ES")!==-1&&(z=parseFloat(/^OpenGL ES (\d)/.exec(N)[1]),F=z>=2);let V=null,Q={},at=n.getParameter(3088),G=n.getParameter(2978),$=new Wt().fromArray(at),lt=new Wt().fromArray(G);function dt(P,pt,ht){let Et=new Uint8Array(4),Y=n.createTexture();n.bindTexture(P,Y),n.texParameteri(P,10241,9728),n.texParameteri(P,10240,9728);for(let Mt=0;Mt<ht;Mt++)n.texImage2D(pt+Mt,0,6408,1,1,0,6408,5121,Et);return Y}let xt={};xt[3553]=dt(3553,3553,1),xt[34067]=dt(34067,34069,6),a.setClear(0,0,0,1),l.setClear(1),c.setClear(0),k(2929),l.setFunc(zu),J(!1),it(Am),k(2884),C(jn);function k(P){u[P]!==!0&&(n.enable(P),u[P]=!0)}function Ft(P){u[P]!==!1&&(n.disable(P),u[P]=!1)}function mt(P,pt){return h[P]!==pt?(n.bindFramebuffer(P,pt),h[P]=pt,i&&(P===36009&&(h[36160]=pt),P===36160&&(h[36009]=pt)),!0):!1}function St(P,pt){let ht=d,Et=!1;if(P)if(ht=f.get(pt),ht===void 0&&(ht=[],f.set(pt,ht)),P.isWebGLMultipleRenderTargets){let Y=P.texture;if(ht.length!==Y.length||ht[0]!==36064){for(let Mt=0,Dt=Y.length;Mt<Dt;Mt++)ht[Mt]=36064+Mt;ht.length=Y.length,Et=!0}}else ht[0]!==36064&&(ht[0]=36064,Et=!0);else ht[0]!==1029&&(ht[0]=1029,Et=!0);Et&&(e.isWebGL2?n.drawBuffers(ht):t.get("WEBGL_draw_buffers").drawBuffersWEBGL(ht))}function B(P){return g!==P?(n.useProgram(P),g=P,!0):!1}let st={[Ir]:32774,[aw]:32778,[lw]:32779};if(i)st[Pm]=32775,st[Dm]=32776;else{let P=t.get("EXT_blend_minmax");P!==null&&(st[Pm]=P.MIN_EXT,st[Dm]=P.MAX_EXT)}let nt={[cw]:0,[uw]:1,[hw]:768,[u0]:770,[xw]:776,[mw]:774,[dw]:772,[fw]:769,[h0]:771,[gw]:775,[pw]:773};function C(P,pt,ht,Et,Y,Mt,Dt,jt){if(P===jn){x===!0&&(Ft(3042),x=!1);return}if(x===!1&&(k(3042),x=!0),P!==ow){if(P!==v||jt!==A){if((m!==Ir||_!==Ir)&&(n.blendEquation(32774),m=Ir,_=Ir),jt)switch(P){case Ks:n.blendFuncSeparate(1,771,1,771);break;case Cm:n.blendFunc(1,1);break;case Rm:n.blendFuncSeparate(0,769,0,1);break;case Lm:n.blendFuncSeparate(0,768,0,770);break;default:console.error("THREE.WebGLState: Invalid blending: ",P);break}else switch(P){case Ks:n.blendFuncSeparate(770,771,1,771);break;case Cm:n.blendFunc(770,1);break;case Rm:n.blendFuncSeparate(0,769,0,1);break;case Lm:n.blendFunc(0,768);break;default:console.error("THREE.WebGLState: Invalid blending: ",P);break}p=null,b=null,S=null,L=null,v=P,A=jt}return}Y=Y||pt,Mt=Mt||ht,Dt=Dt||Et,(pt!==m||Y!==_)&&(n.blendEquationSeparate(st[pt],st[Y]),m=pt,_=Y),(ht!==p||Et!==b||Mt!==S||Dt!==L)&&(n.blendFuncSeparate(nt[ht],nt[Et],nt[Mt],nt[Dt]),p=ht,b=Et,S=Mt,L=Dt),v=P,A=null}function j(P,pt){P.side===Hr?Ft(2884):k(2884);let ht=P.side===he;pt&&(ht=!ht),J(ht),P.blending===Ks&&P.transparent===!1?C(jn):C(P.blending,P.blendEquation,P.blendSrc,P.blendDst,P.blendEquationAlpha,P.blendSrcAlpha,P.blendDstAlpha,P.premultipliedAlpha),l.setFunc(P.depthFunc),l.setTest(P.depthTest),l.setMask(P.depthWrite),a.setMask(P.colorWrite);let Et=P.stencilWrite;c.setTest(Et),Et&&(c.setMask(P.stencilWriteMask),c.setFunc(P.stencilFunc,P.stencilRef,P.stencilFuncMask),c.setOp(P.stencilFail,P.stencilZFail,P.stencilZPass)),vt(P.polygonOffset,P.polygonOffsetFactor,P.polygonOffsetUnits),P.alphaToCoverage===!0?k(32926):Ft(32926)}function J(P){H!==P&&(P?n.frontFace(2304):n.frontFace(2305),H=P)}function it(P){P!==iw?(k(2884),P!==tt&&(P===Am?n.cullFace(1029):P===rw?n.cullFace(1028):n.cullFace(1032))):Ft(2884),tt=P}function et(P){P!==X&&(F&&n.lineWidth(P),X=P)}function vt(P,pt,ht){P?(k(32823),(y!==pt||R!==ht)&&(n.polygonOffset(pt,ht),y=pt,R=ht)):Ft(32823)}function bt(P){P?k(3089):Ft(3089)}function It(P){P===void 0&&(P=33984+D-1),V!==P&&(n.activeTexture(P),V=P)}function Zt(P,pt){V===null&&It();let ht=Q[V];ht===void 0&&(ht={type:void 0,texture:void 0},Q[V]=ht),(ht.type!==P||ht.texture!==pt)&&(n.bindTexture(P,pt||xt[P]),ht.type=P,ht.texture=pt)}function qt(){let P=Q[V];P!==void 0&&P.type!==void 0&&(n.bindTexture(P.type,null),P.type=void 0,P.texture=void 0)}function E(){try{n.compressedTexImage2D.apply(n,arguments)}catch(P){console.error("THREE.WebGLState:",P)}}function w(){try{n.texSubImage2D.apply(n,arguments)}catch(P){console.error("THREE.WebGLState:",P)}}function q(){try{n.texSubImage3D.apply(n,arguments)}catch(P){console.error("THREE.WebGLState:",P)}}function rt(){try{n.compressedTexSubImage2D.apply(n,arguments)}catch(P){console.error("THREE.WebGLState:",P)}}function gt(){try{n.texStorage2D.apply(n,arguments)}catch(P){console.error("THREE.WebGLState:",P)}}function W(){try{n.texStorage3D.apply(n,arguments)}catch(P){console.error("THREE.WebGLState:",P)}}function _t(){try{n.texImage2D.apply(n,arguments)}catch(P){console.error("THREE.WebGLState:",P)}}function yt(){try{n.texImage3D.apply(n,arguments)}catch(P){console.error("THREE.WebGLState:",P)}}function ut(P){$.equals(P)===!1&&(n.scissor(P.x,P.y,P.z,P.w),$.copy(P))}function ct(P){lt.equals(P)===!1&&(n.viewport(P.x,P.y,P.z,P.w),lt.copy(P))}function At(){n.disable(3042),n.disable(2884),n.disable(2929),n.disable(32823),n.disable(3089),n.disable(2960),n.disable(32926),n.blendEquation(32774),n.blendFunc(1,0),n.blendFuncSeparate(1,0,1,0),n.colorMask(!0,!0,!0,!0),n.clearColor(0,0,0,0),n.depthMask(!0),n.depthFunc(513),n.clearDepth(1),n.stencilMask(4294967295),n.stencilFunc(519,0,4294967295),n.stencilOp(7680,7680,7680),n.clearStencil(0),n.cullFace(1029),n.frontFace(2305),n.polygonOffset(0,0),n.activeTexture(33984),n.bindFramebuffer(36160,null),i===!0&&(n.bindFramebuffer(36009,null),n.bindFramebuffer(36008,null)),n.useProgram(null),n.lineWidth(1),n.scissor(0,0,n.canvas.width,n.canvas.height),n.viewport(0,0,n.canvas.width,n.canvas.height),u={},V=null,Q={},h={},f=new WeakMap,d=[],g=null,x=!1,v=null,m=null,p=null,b=null,_=null,S=null,L=null,A=!1,H=null,tt=null,X=null,y=null,R=null,$.set(0,0,n.canvas.width,n.canvas.height),lt.set(0,0,n.canvas.width,n.canvas.height),a.reset(),l.reset(),c.reset()}return{buffers:{color:a,depth:l,stencil:c},enable:k,disable:Ft,bindFramebuffer:mt,drawBuffers:St,useProgram:B,setBlending:C,setMaterial:j,setFlipSided:J,setCullFace:it,setLineWidth:et,setPolygonOffset:vt,setScissorTest:bt,activeTexture:It,bindTexture:Zt,unbindTexture:qt,compressedTexImage2D:E,texImage2D:_t,texImage3D:yt,texStorage2D:gt,texStorage3D:W,texSubImage2D:w,texSubImage3D:q,compressedTexSubImage2D:rt,scissor:ut,viewport:ct,reset:At}}function RE(n,t,e,i,r,s,o){let a=r.isWebGL2,l=r.maxTextures,c=r.maxCubemapSize,u=r.maxTextureSize,h=r.maxSamples,d=t.has("WEBGL_multisampled_render_to_texture")?t.get("WEBGL_multisampled_render_to_texture"):void 0,g=new WeakMap,x,v=!1;try{v=typeof OffscreenCanvas!="undefined"&&new OffscreenCanvas(1,1).getContext("2d")!==null}catch(E){}function m(E,w){return v?new OffscreenCanvas(E,w):ro("canvas")}function p(E,w,q,rt){let gt=1;if((E.width>rt||E.height>rt)&&(gt=rt/Math.max(E.width,E.height)),gt<1||w===!0)if(typeof HTMLImageElement!="undefined"&&E instanceof HTMLImageElement||typeof HTMLCanvasElement!="undefined"&&E instanceof HTMLCanvasElement||typeof ImageBitmap!="undefined"&&E instanceof ImageBitmap){let W=w?nM:Math.floor,_t=W(gt*E.width),yt=W(gt*E.height);x===void 0&&(x=m(_t,yt));let ut=q?m(_t,yt):x;return ut.width=_t,ut.height=yt,ut.getContext("2d").drawImage(E,0,0,_t,yt),console.warn("THREE.WebGLRenderer: Texture has been resized from ("+E.width+"x"+E.height+") to ("+_t+"x"+yt+")."),ut}else return"data"in E&&console.warn("THREE.WebGLRenderer: Image in DataTexture is too big ("+E.width+"x"+E.height+")."),E;return E}function b(E){return ig(E.width)&&ig(E.height)}function _(E){return a?!1:E.wrapS!==Ve||E.wrapT!==Ve||E.minFilter!==fe&&E.minFilter!==be}function S(E,w){return E.generateMipmaps&&w&&E.minFilter!==fe&&E.minFilter!==be}function L(E){n.generateMipmap(E)}function A(E,w,q,rt,gt=!1){if(a===!1)return w;if(E!==null){if(n[E]!==void 0)return n[E];console.warn("THREE.WebGLRenderer: Attempt to use non-existing WebGL internal format '"+E+"'")}let W=w;return w===6403&&(q===5126&&(W=33326),q===5131&&(W=33325),q===5121&&(W=33321)),w===33319&&(q===5126&&(W=33328),q===5131&&(W=33327),q===5121&&(W=33323)),w===6408&&(q===5126&&(W=34836),q===5131&&(W=34842),q===5121&&(W=rt===$t&&gt===!1?35907:32856),q===32819&&(W=32854),q===32820&&(W=32855)),(W===33325||W===33326||W===33327||W===33328||W===34842||W===34836)&&t.get("EXT_color_buffer_float"),W}function H(E,w,q){return S(E,q)===!0||E.isFramebufferTexture&&E.minFilter!==fe&&E.minFilter!==be?Math.log2(Math.max(w.width,w.height))+1:E.mipmaps!==void 0&&E.mipmaps.length>0?E.mipmaps.length:E.isCompressedTexture&&Array.isArray(E.image)?w.mipmaps.length:1}function tt(E){return E===fe||E===Im||E===Nm?9728:9729}function X(E){let w=E.target;w.removeEventListener("dispose",X),R(w),w.isVideoTexture&&g.delete(w),o.memory.textures--}function y(E){let w=E.target;w.removeEventListener("dispose",y),D(w)}function R(E){let w=i.get(E);w.__webglInit!==void 0&&(n.deleteTexture(w.__webglTexture),i.remove(E))}function D(E){let w=E.texture,q=i.get(E),rt=i.get(w);if(!!E){if(rt.__webglTexture!==void 0&&(n.deleteTexture(rt.__webglTexture),o.memory.textures--),E.depthTexture&&E.depthTexture.dispose(),E.isWebGLCubeRenderTarget)for(let gt=0;gt<6;gt++)n.deleteFramebuffer(q.__webglFramebuffer[gt]),q.__webglDepthbuffer&&n.deleteRenderbuffer(q.__webglDepthbuffer[gt]);else n.deleteFramebuffer(q.__webglFramebuffer),q.__webglDepthbuffer&&n.deleteRenderbuffer(q.__webglDepthbuffer),q.__webglMultisampledFramebuffer&&n.deleteFramebuffer(q.__webglMultisampledFramebuffer),q.__webglColorRenderbuffer&&n.deleteRenderbuffer(q.__webglColorRenderbuffer),q.__webglDepthRenderbuffer&&n.deleteRenderbuffer(q.__webglDepthRenderbuffer);if(E.isWebGLMultipleRenderTargets)for(let gt=0,W=w.length;gt<W;gt++){let _t=i.get(w[gt]);_t.__webglTexture&&(n.deleteTexture(_t.__webglTexture),o.memory.textures--),i.remove(w[gt])}i.remove(w),i.remove(E)}}let F=0;function z(){F=0}function N(){let E=F;return E>=l&&console.warn("THREE.WebGLTextures: Trying to use "+E+" texture units while this GPU supports only "+l),F+=1,E}function V(E,w){let q=i.get(E);if(E.isVideoTexture&&et(E),E.version>0&&q.__version!==E.version){let rt=E.image;if(rt===void 0)console.warn("THREE.WebGLRenderer: Texture marked for update but image is undefined");else if(rt.complete===!1)console.warn("THREE.WebGLRenderer: Texture marked for update but image is incomplete");else{k(q,E,w);return}}e.activeTexture(33984+w),e.bindTexture(3553,q.__webglTexture)}function Q(E,w){let q=i.get(E);if(E.version>0&&q.__version!==E.version){k(q,E,w);return}e.activeTexture(33984+w),e.bindTexture(35866,q.__webglTexture)}function at(E,w){let q=i.get(E);if(E.version>0&&q.__version!==E.version){k(q,E,w);return}e.activeTexture(33984+w),e.bindTexture(32879,q.__webglTexture)}function G(E,w){let q=i.get(E);if(E.version>0&&q.__version!==E.version){Ft(q,E,w);return}e.activeTexture(33984+w),e.bindTexture(34067,q.__webglTexture)}let $={[Ou]:10497,[Ve]:33071,[ku]:33648},lt={[fe]:9728,[Im]:9984,[Nm]:9986,[be]:9729,[Dw]:9985,[Ll]:9987};function dt(E,w,q){if(q?(n.texParameteri(E,10242,$[w.wrapS]),n.texParameteri(E,10243,$[w.wrapT]),(E===32879||E===35866)&&n.texParameteri(E,32882,$[w.wrapR]),n.texParameteri(E,10240,lt[w.magFilter]),n.texParameteri(E,10241,lt[w.minFilter])):(n.texParameteri(E,10242,33071),n.texParameteri(E,10243,33071),(E===32879||E===35866)&&n.texParameteri(E,32882,33071),(w.wrapS!==Ve||w.wrapT!==Ve)&&console.warn("THREE.WebGLRenderer: Texture is not power of two. Texture.wrapS and Texture.wrapT should be set to THREE.ClampToEdgeWrapping."),n.texParameteri(E,10240,tt(w.magFilter)),n.texParameteri(E,10241,tt(w.minFilter)),w.minFilter!==fe&&w.minFilter!==be&&console.warn("THREE.WebGLRenderer: Texture is not power of two. Texture.minFilter should be set to THREE.NearestFilter or THREE.LinearFilter.")),t.has("EXT_texture_filter_anisotropic")===!0){let rt=t.get("EXT_texture_filter_anisotropic");if(w.type===Ui&&t.has("OES_texture_float_linear")===!1||a===!1&&w.type===Ur&&t.has("OES_texture_half_float_linear")===!1)return;(w.anisotropy>1||i.get(w).__currentAnisotropy)&&(n.texParameterf(E,rt.TEXTURE_MAX_ANISOTROPY_EXT,Math.min(w.anisotropy,r.getMaxAnisotropy())),i.get(w).__currentAnisotropy=w.anisotropy)}}function xt(E,w){E.__webglInit===void 0&&(E.__webglInit=!0,w.addEventListener("dispose",X),E.__webglTexture=n.createTexture(),o.memory.textures++)}function k(E,w,q){let rt=3553;w.isDataTexture2DArray&&(rt=35866),w.isDataTexture3D&&(rt=32879),xt(E,w),e.activeTexture(33984+q),e.bindTexture(rt,E.__webglTexture),n.pixelStorei(37440,w.flipY),n.pixelStorei(37441,w.premultiplyAlpha),n.pixelStorei(3317,w.unpackAlignment),n.pixelStorei(37443,0);let gt=_(w)&&b(w.image)===!1,W=p(w.image,gt,!1,u);W=vt(w,W);let _t=b(W)||a,yt=s.convert(w.format,w.encoding),ut=s.convert(w.type),ct=A(w.internalFormat,yt,ut,w.encoding,w.isVideoTexture);dt(rt,w,_t);let At,P=w.mipmaps,pt=a&&w.isVideoTexture!==!0,ht=E.__version===void 0,Et=H(w,W,_t);if(w.isDepthTexture)ct=6402,a?w.type===Ui?ct=36012:w.type===Qa?ct=33190:w.type===Br?ct=35056:ct=33189:w.type===Ui&&console.error("WebGLRenderer: Floating point depth texture requires WebGL2."),w.format===Oi&&ct===6402&&w.type!==no&&w.type!==Qa&&(console.warn("THREE.WebGLRenderer: Use UnsignedShortType or UnsignedIntType for DepthFormat DepthTexture."),w.type=no,ut=s.convert(w.type)),w.format===Vr&&ct===6402&&(ct=34041,w.type!==Br&&(console.warn("THREE.WebGLRenderer: Use UnsignedInt248Type for DepthStencilFormat DepthTexture."),w.type=Br,ut=s.convert(w.type))),pt&&ht?e.texStorage2D(3553,1,ct,W.width,W.height):e.texImage2D(3553,0,ct,W.width,W.height,0,yt,ut,null);else if(w.isDataTexture)if(P.length>0&&_t){pt&&ht&&e.texStorage2D(3553,Et,ct,P[0].width,P[0].height);for(let Y=0,Mt=P.length;Y<Mt;Y++)At=P[Y],pt?e.texSubImage2D(3553,0,0,0,At.width,At.height,yt,ut,At.data):e.texImage2D(3553,Y,ct,At.width,At.height,0,yt,ut,At.data);w.generateMipmaps=!1}else pt?(ht&&e.texStorage2D(3553,Et,ct,W.width,W.height),e.texSubImage2D(3553,0,0,0,W.width,W.height,yt,ut,W.data)):e.texImage2D(3553,0,ct,W.width,W.height,0,yt,ut,W.data);else if(w.isCompressedTexture){pt&&ht&&e.texStorage2D(3553,Et,ct,P[0].width,P[0].height);for(let Y=0,Mt=P.length;Y<Mt;Y++)At=P[Y],w.format!==Re?yt!==null?pt?e.compressedTexSubImage2D(3553,Y,0,0,At.width,At.height,yt,At.data):e.compressedTexImage2D(3553,Y,ct,At.width,At.height,0,At.data):console.warn("THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .uploadTexture()"):pt?e.texSubImage2D(3553,Y,0,0,At.width,At.height,yt,ut,At.data):e.texImage2D(3553,Y,ct,At.width,At.height,0,yt,ut,At.data)}else if(w.isDataTexture2DArray)pt?(ht&&e.texStorage3D(35866,Et,ct,W.width,W.height,W.depth),e.texSubImage3D(35866,0,0,0,0,W.width,W.height,W.depth,yt,ut,W.data)):e.texImage3D(35866,0,ct,W.width,W.height,W.depth,0,yt,ut,W.data);else if(w.isDataTexture3D)pt?(ht&&e.texStorage3D(32879,Et,ct,W.width,W.height,W.depth),e.texSubImage3D(32879,0,0,0,0,W.width,W.height,W.depth,yt,ut,W.data)):e.texImage3D(32879,0,ct,W.width,W.height,W.depth,0,yt,ut,W.data);else if(w.isFramebufferTexture)pt&&ht?e.texStorage2D(3553,Et,ct,W.width,W.height):e.texImage2D(3553,0,ct,W.width,W.height,0,yt,ut,null);else if(P.length>0&&_t){pt&&ht&&e.texStorage2D(3553,Et,ct,P[0].width,P[0].height);for(let Y=0,Mt=P.length;Y<Mt;Y++)At=P[Y],pt?e.texSubImage2D(3553,Y,0,0,yt,ut,At):e.texImage2D(3553,Y,ct,yt,ut,At);w.generateMipmaps=!1}else pt?(ht&&e.texStorage2D(3553,Et,ct,W.width,W.height),e.texSubImage2D(3553,0,0,0,yt,ut,W)):e.texImage2D(3553,0,ct,yt,ut,W);S(w,_t)&&L(rt),E.__version=w.version,w.onUpdate&&w.onUpdate(w)}function Ft(E,w,q){if(w.image.length!==6)return;xt(E,w),e.activeTexture(33984+q),e.bindTexture(34067,E.__webglTexture),n.pixelStorei(37440,w.flipY),n.pixelStorei(37441,w.premultiplyAlpha),n.pixelStorei(3317,w.unpackAlignment),n.pixelStorei(37443,0);let rt=w&&(w.isCompressedTexture||w.image[0].isCompressedTexture),gt=w.image[0]&&w.image[0].isDataTexture,W=[];for(let Y=0;Y<6;Y++)!rt&&!gt?W[Y]=p(w.image[Y],!1,!0,c):W[Y]=gt?w.image[Y].image:w.image[Y],W[Y]=vt(w,W[Y]);let _t=W[0],yt=b(_t)||a,ut=s.convert(w.format,w.encoding),ct=s.convert(w.type),At=A(w.internalFormat,ut,ct,w.encoding),P=a&&w.isVideoTexture!==!0,pt=E.__version===void 0,ht=H(w,_t,yt);dt(34067,w,yt);let Et;if(rt){P&&pt&&e.texStorage2D(34067,ht,At,_t.width,_t.height);for(let Y=0;Y<6;Y++){Et=W[Y].mipmaps;for(let Mt=0;Mt<Et.length;Mt++){let Dt=Et[Mt];w.format!==Re?ut!==null?P?e.compressedTexSubImage2D(34069+Y,Mt,0,0,Dt.width,Dt.height,ut,Dt.data):e.compressedTexImage2D(34069+Y,Mt,At,Dt.width,Dt.height,0,Dt.data):console.warn("THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .setTextureCube()"):P?e.texSubImage2D(34069+Y,Mt,0,0,Dt.width,Dt.height,ut,ct,Dt.data):e.texImage2D(34069+Y,Mt,At,Dt.width,Dt.height,0,ut,ct,Dt.data)}}}else{Et=w.mipmaps,P&&pt&&(Et.length>0&&ht++,e.texStorage2D(34067,ht,At,W[0].width,W[0].height));for(let Y=0;Y<6;Y++)if(gt){P?e.texSubImage2D(34069+Y,0,0,0,W[Y].width,W[Y].height,ut,ct,W[Y].data):e.texImage2D(34069+Y,0,At,W[Y].width,W[Y].height,0,ut,ct,W[Y].data);for(let Mt=0;Mt<Et.length;Mt++){let jt=Et[Mt].image[Y].image;P?e.texSubImage2D(34069+Y,Mt+1,0,0,jt.width,jt.height,ut,ct,jt.data):e.texImage2D(34069+Y,Mt+1,At,jt.width,jt.height,0,ut,ct,jt.data)}}else{P?e.texSubImage2D(34069+Y,0,0,0,ut,ct,W[Y]):e.texImage2D(34069+Y,0,At,ut,ct,W[Y]);for(let Mt=0;Mt<Et.length;Mt++){let Dt=Et[Mt];P?e.texSubImage2D(34069+Y,Mt+1,0,0,ut,ct,Dt.image[Y]):e.texImage2D(34069+Y,Mt+1,At,ut,ct,Dt.image[Y])}}}S(w,yt)&&L(34067),E.__version=w.version,w.onUpdate&&w.onUpdate(w)}function mt(E,w,q,rt,gt){let W=s.convert(q.format,q.encoding),_t=s.convert(q.type),yt=A(q.internalFormat,W,_t,q.encoding);i.get(w).__hasExternalTextures||(gt===32879||gt===35866?e.texImage3D(gt,0,yt,w.width,w.height,w.depth,0,W,_t,null):e.texImage2D(gt,0,yt,w.width,w.height,0,W,_t,null)),e.bindFramebuffer(36160,E),w.useRenderToTexture?d.framebufferTexture2DMultisampleEXT(36160,rt,gt,i.get(q).__webglTexture,0,it(w)):n.framebufferTexture2D(36160,rt,gt,i.get(q).__webglTexture,0),e.bindFramebuffer(36160,null)}function St(E,w,q){if(n.bindRenderbuffer(36161,E),w.depthBuffer&&!w.stencilBuffer){let rt=33189;if(q||w.useRenderToTexture){let gt=w.depthTexture;gt&&gt.isDepthTexture&&(gt.type===Ui?rt=36012:gt.type===Qa&&(rt=33190));let W=it(w);w.useRenderToTexture?d.renderbufferStorageMultisampleEXT(36161,W,rt,w.width,w.height):n.renderbufferStorageMultisample(36161,W,rt,w.width,w.height)}else n.renderbufferStorage(36161,rt,w.width,w.height);n.framebufferRenderbuffer(36160,36096,36161,E)}else if(w.depthBuffer&&w.stencilBuffer){let rt=it(w);q&&w.useRenderbuffer?n.renderbufferStorageMultisample(36161,rt,35056,w.width,w.height):w.useRenderToTexture?d.renderbufferStorageMultisampleEXT(36161,rt,35056,w.width,w.height):n.renderbufferStorage(36161,34041,w.width,w.height),n.framebufferRenderbuffer(36160,33306,36161,E)}else{let rt=w.isWebGLMultipleRenderTargets===!0?w.texture[0]:w.texture,gt=s.convert(rt.format,rt.encoding),W=s.convert(rt.type),_t=A(rt.internalFormat,gt,W,rt.encoding),yt=it(w);q&&w.useRenderbuffer?n.renderbufferStorageMultisample(36161,yt,_t,w.width,w.height):w.useRenderToTexture?d.renderbufferStorageMultisampleEXT(36161,yt,_t,w.width,w.height):n.renderbufferStorage(36161,_t,w.width,w.height)}n.bindRenderbuffer(36161,null)}function B(E,w){if(w&&w.isWebGLCubeRenderTarget)throw new Error("Depth Texture with cube render targets is not supported");if(e.bindFramebuffer(36160,E),!(w.depthTexture&&w.depthTexture.isDepthTexture))throw new Error("renderTarget.depthTexture must be an instance of THREE.DepthTexture");(!i.get(w.depthTexture).__webglTexture||w.depthTexture.image.width!==w.width||w.depthTexture.image.height!==w.height)&&(w.depthTexture.image.width=w.width,w.depthTexture.image.height=w.height,w.depthTexture.needsUpdate=!0),V(w.depthTexture,0);let rt=i.get(w.depthTexture).__webglTexture,gt=it(w);if(w.depthTexture.format===Oi)w.useRenderToTexture?d.framebufferTexture2DMultisampleEXT(36160,36096,3553,rt,0,gt):n.framebufferTexture2D(36160,36096,3553,rt,0);else if(w.depthTexture.format===Vr)w.useRenderToTexture?d.framebufferTexture2DMultisampleEXT(36160,33306,3553,rt,0,gt):n.framebufferTexture2D(36160,33306,3553,rt,0);else throw new Error("Unknown depthTexture format")}function st(E){let w=i.get(E),q=E.isWebGLCubeRenderTarget===!0;if(E.depthTexture&&!w.__autoAllocateDepthBuffer){if(q)throw new Error("target.depthTexture not supported in Cube render targets");B(w.__webglFramebuffer,E)}else if(q){w.__webglDepthbuffer=[];for(let rt=0;rt<6;rt++)e.bindFramebuffer(36160,w.__webglFramebuffer[rt]),w.__webglDepthbuffer[rt]=n.createRenderbuffer(),St(w.__webglDepthbuffer[rt],E,!1)}else e.bindFramebuffer(36160,w.__webglFramebuffer),w.__webglDepthbuffer=n.createRenderbuffer(),St(w.__webglDepthbuffer,E,!1);e.bindFramebuffer(36160,null)}function nt(E,w,q){let rt=i.get(E);w!==void 0&&mt(rt.__webglFramebuffer,E,E.texture,36064,3553),q!==void 0&&st(E)}function C(E){let w=E.texture,q=i.get(E),rt=i.get(w);E.addEventListener("dispose",y),E.isWebGLMultipleRenderTargets!==!0&&(rt.__webglTexture===void 0&&(rt.__webglTexture=n.createTexture()),rt.__version=w.version,o.memory.textures++);let gt=E.isWebGLCubeRenderTarget===!0,W=E.isWebGLMultipleRenderTargets===!0,_t=w.isDataTexture3D||w.isDataTexture2DArray,yt=b(E)||a;if(gt){q.__webglFramebuffer=[];for(let ut=0;ut<6;ut++)q.__webglFramebuffer[ut]=n.createFramebuffer()}else if(q.__webglFramebuffer=n.createFramebuffer(),W)if(r.drawBuffers){let ut=E.texture;for(let ct=0,At=ut.length;ct<At;ct++){let P=i.get(ut[ct]);P.__webglTexture===void 0&&(P.__webglTexture=n.createTexture(),o.memory.textures++)}}else console.warn("THREE.WebGLRenderer: WebGLMultipleRenderTargets can only be used with WebGL2 or WEBGL_draw_buffers extension.");else if(E.useRenderbuffer)if(a){q.__webglMultisampledFramebuffer=n.createFramebuffer(),q.__webglColorRenderbuffer=n.createRenderbuffer(),n.bindRenderbuffer(36161,q.__webglColorRenderbuffer);let ut=s.convert(w.format,w.encoding),ct=s.convert(w.type),At=A(w.internalFormat,ut,ct,w.encoding),P=it(E);n.renderbufferStorageMultisample(36161,P,At,E.width,E.height),e.bindFramebuffer(36160,q.__webglMultisampledFramebuffer),n.framebufferRenderbuffer(36160,36064,36161,q.__webglColorRenderbuffer),n.bindRenderbuffer(36161,null),E.depthBuffer&&(q.__webglDepthRenderbuffer=n.createRenderbuffer(),St(q.__webglDepthRenderbuffer,E,!0)),e.bindFramebuffer(36160,null)}else console.warn("THREE.WebGLRenderer: WebGLMultisampleRenderTarget can only be used with WebGL2.");if(gt){e.bindTexture(34067,rt.__webglTexture),dt(34067,w,yt);for(let ut=0;ut<6;ut++)mt(q.__webglFramebuffer[ut],E,w,36064,34069+ut);S(w,yt)&&L(34067),e.unbindTexture()}else if(W){let ut=E.texture;for(let ct=0,At=ut.length;ct<At;ct++){let P=ut[ct],pt=i.get(P);e.bindTexture(3553,pt.__webglTexture),dt(3553,P,yt),mt(q.__webglFramebuffer,E,P,36064+ct,3553),S(P,yt)&&L(3553)}e.unbindTexture()}else{let ut=3553;_t&&(a?ut=w.isDataTexture3D?32879:35866:console.warn("THREE.DataTexture3D and THREE.DataTexture2DArray only supported with WebGL2.")),e.bindTexture(ut,rt.__webglTexture),dt(ut,w,yt),mt(q.__webglFramebuffer,E,w,36064,ut),S(w,yt)&&L(ut),e.unbindTexture()}E.depthBuffer&&st(E)}function j(E){let w=b(E)||a,q=E.isWebGLMultipleRenderTargets===!0?E.texture:[E.texture];for(let rt=0,gt=q.length;rt<gt;rt++){let W=q[rt];if(S(W,w)){let _t=E.isWebGLCubeRenderTarget?34067:3553,yt=i.get(W).__webglTexture;e.bindTexture(_t,yt),L(_t),e.unbindTexture()}}}function J(E){if(E.useRenderbuffer)if(a){let w=E.width,q=E.height,rt=16384,gt=[36064],W=E.stencilBuffer?33306:36096;E.depthBuffer&&gt.push(W),E.ignoreDepthForMultisampleCopy||(E.depthBuffer&&(rt|=256),E.stencilBuffer&&(rt|=1024));let _t=i.get(E);e.bindFramebuffer(36008,_t.__webglMultisampledFramebuffer),e.bindFramebuffer(36009,_t.__webglFramebuffer),E.ignoreDepthForMultisampleCopy&&(n.invalidateFramebuffer(36008,[W]),n.invalidateFramebuffer(36009,[W])),n.blitFramebuffer(0,0,w,q,0,0,w,q,rt,9728),n.invalidateFramebuffer(36008,gt),e.bindFramebuffer(36008,null),e.bindFramebuffer(36009,_t.__webglMultisampledFramebuffer)}else console.warn("THREE.WebGLRenderer: WebGLMultisampleRenderTarget can only be used with WebGL2.")}function it(E){return a&&(E.useRenderbuffer||E.useRenderToTexture)?Math.min(h,E.samples):0}function et(E){let w=o.render.frame;g.get(E)!==w&&(g.set(E,w),E.update())}function vt(E,w){let q=E.encoding,rt=E.format,gt=E.type;return E.isCompressedTexture===!0||E.isVideoTexture===!0||E.format===Hu||q!==ri&&(q===$t?a===!1?t.has("EXT_sRGB")===!0&&rt===Re?(E.format=Hu,E.minFilter=be,E.generateMipmaps=!1):w=Nn.sRGBToLinear(w):(rt!==Re||gt!==ei)&&console.warn("THREE.WebGLTextures: sRGB encoded textures have to use RGBAFormat and UnsignedByteType."):console.error("THREE.WebGLTextures: Unsupported texture encoding:",q)),w}let bt=!1,It=!1;function Zt(E,w){E&&E.isWebGLRenderTarget&&(bt===!1&&(console.warn("THREE.WebGLTextures.safeSetTexture2D: don't use render targets as textures. Use their .texture property instead."),bt=!0),E=E.texture),V(E,w)}function qt(E,w){E&&E.isWebGLCubeRenderTarget&&(It===!1&&(console.warn("THREE.WebGLTextures.safeSetTextureCube: don't use cube render targets as textures. Use their .texture property instead."),It=!0),E=E.texture),G(E,w)}this.allocateTextureUnit=N,this.resetTextureUnits=z,this.setTexture2D=V,this.setTexture2DArray=Q,this.setTexture3D=at,this.setTextureCube=G,this.rebindTextures=nt,this.setupRenderTarget=C,this.updateRenderTargetMipmap=j,this.updateMultisampleRenderTarget=J,this.setupDepthRenderbuffer=st,this.setupFrameBufferTexture=mt,this.safeSetTexture2D=Zt,this.safeSetTextureCube=qt}function LE(n,t,e){let i=e.isWebGL2;function r(s,o=null){let a;if(s===ei)return 5121;if(s===zw)return 32819;if(s===Uw)return 32820;if(s===Iw)return 5120;if(s===Nw)return 5122;if(s===no)return 5123;if(s===Fw)return 5124;if(s===Qa)return 5125;if(s===Ui)return 5126;if(s===Ur)return i?5131:(a=t.get("OES_texture_half_float"),a!==null?a.HALF_FLOAT_OES:null);if(s===Bw)return 6406;if(s===Re)return 6408;if(s===Ow)return 6409;if(s===kw)return 6410;if(s===Oi)return 6402;if(s===Vr)return 34041;if(s===Hw)return 6403;if(s===Hu)return a=t.get("EXT_sRGB"),a!==null?a.SRGB_ALPHA_EXT:null;if(s===Vw)return 36244;if(s===Gw)return 33319;if(s===Ww)return 33320;if(s===qw)return 36249;if(s===Kc||s===Qc||s===jc||s===tu)if(o===$t)if(a=t.get("WEBGL_compressed_texture_s3tc_srgb"),a!==null){if(s===Kc)return a.COMPRESSED_SRGB_S3TC_DXT1_EXT;if(s===Qc)return a.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT;if(s===jc)return a.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT;if(s===tu)return a.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT}else return null;else if(a=t.get("WEBGL_compressed_texture_s3tc"),a!==null){if(s===Kc)return a.COMPRESSED_RGB_S3TC_DXT1_EXT;if(s===Qc)return a.COMPRESSED_RGBA_S3TC_DXT1_EXT;if(s===jc)return a.COMPRESSED_RGBA_S3TC_DXT3_EXT;if(s===tu)return a.COMPRESSED_RGBA_S3TC_DXT5_EXT}else return null;if(s===Fm||s===zm||s===Um||s===Bm)if(a=t.get("WEBGL_compressed_texture_pvrtc"),a!==null){if(s===Fm)return a.COMPRESSED_RGB_PVRTC_4BPPV1_IMG;if(s===zm)return a.COMPRESSED_RGB_PVRTC_2BPPV1_IMG;if(s===Um)return a.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG;if(s===Bm)return a.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG}else return null;if(s===Xw)return a=t.get("WEBGL_compressed_texture_etc1"),a!==null?a.COMPRESSED_RGB_ETC1_WEBGL:null;if(s===Om||s===km)if(a=t.get("WEBGL_compressed_texture_etc"),a!==null){if(s===Om)return o===$t?a.COMPRESSED_SRGB8_ETC2:a.COMPRESSED_RGB8_ETC2;if(s===km)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:a.COMPRESSED_RGBA8_ETC2_EAC}else return null;if(s===Hm||s===Vm||s===Gm||s===Wm||s===qm||s===Xm||s===Ym||s===Zm||s===Jm||s===$m||s===Km||s===Qm||s===jm||s===tg)if(a=t.get("WEBGL_compressed_texture_astc"),a!==null){if(s===Hm)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR:a.COMPRESSED_RGBA_ASTC_4x4_KHR;if(s===Vm)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR:a.COMPRESSED_RGBA_ASTC_5x4_KHR;if(s===Gm)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR:a.COMPRESSED_RGBA_ASTC_5x5_KHR;if(s===Wm)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR:a.COMPRESSED_RGBA_ASTC_6x5_KHR;if(s===qm)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR:a.COMPRESSED_RGBA_ASTC_6x6_KHR;if(s===Xm)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR:a.COMPRESSED_RGBA_ASTC_8x5_KHR;if(s===Ym)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR:a.COMPRESSED_RGBA_ASTC_8x6_KHR;if(s===Zm)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR:a.COMPRESSED_RGBA_ASTC_8x8_KHR;if(s===Jm)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR:a.COMPRESSED_RGBA_ASTC_10x5_KHR;if(s===$m)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR:a.COMPRESSED_RGBA_ASTC_10x6_KHR;if(s===Km)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR:a.COMPRESSED_RGBA_ASTC_10x8_KHR;if(s===Qm)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR:a.COMPRESSED_RGBA_ASTC_10x10_KHR;if(s===jm)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR:a.COMPRESSED_RGBA_ASTC_12x10_KHR;if(s===tg)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR:a.COMPRESSED_RGBA_ASTC_12x12_KHR}else return null;if(s===eg)if(a=t.get("EXT_texture_compression_bptc"),a!==null){if(s===eg)return o===$t?a.COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT:a.COMPRESSED_RGBA_BPTC_UNORM_EXT}else return null;if(s===Br)return i?34042:(a=t.get("WEBGL_depth_texture"),a!==null?a.UNSIGNED_INT_24_8_WEBGL:null)}return{convert:r}}var hl=class extends Se{constructor(t=[]){super(),this.cameras=t}};hl.prototype.isArrayCamera=!0;var Bi=class extends kt{constructor(){super(),this.type="Group"}};Bi.prototype.isGroup=!0;var PE={type:"move"},Qs=class{constructor(){this._targetRay=null,this._grip=null,this._hand=null}getHandSpace(){return this._hand===null&&(this._hand=new Bi,this._hand.matrixAutoUpdate=!1,this._hand.visible=!1,this._hand.joints={},this._hand.inputState={pinching:!1}),this._hand}getTargetRaySpace(){return this._targetRay===null&&(this._targetRay=new Bi,this._targetRay.matrixAutoUpdate=!1,this._targetRay.visible=!1,this._targetRay.hasLinearVelocity=!1,this._targetRay.linearVelocity=new T,this._targetRay.hasAngularVelocity=!1,this._targetRay.angularVelocity=new T),this._targetRay}getGripSpace(){return this._grip===null&&(this._grip=new Bi,this._grip.matrixAutoUpdate=!1,this._grip.visible=!1,this._grip.hasLinearVelocity=!1,this._grip.linearVelocity=new T,this._grip.hasAngularVelocity=!1,this._grip.angularVelocity=new T),this._grip}dispatchEvent(t){return this._targetRay!==null&&this._targetRay.dispatchEvent(t),this._grip!==null&&this._grip.dispatchEvent(t),this._hand!==null&&this._hand.dispatchEvent(t),this}disconnect(t){return this.dispatchEvent({type:"disconnected",data:t}),this._targetRay!==null&&(this._targetRay.visible=!1),this._grip!==null&&(this._grip.visible=!1),this._hand!==null&&(this._hand.visible=!1),this}update(t,e,i){let r=null,s=null,o=null,a=this._targetRay,l=this._grip,c=this._hand;if(t&&e.session.visibilityState!=="visible-blurred")if(a!==null&&(r=e.getPose(t.targetRaySpace,i),r!==null&&(a.matrix.fromArray(r.transform.matrix),a.matrix.decompose(a.position,a.rotation,a.scale),r.linearVelocity?(a.hasLinearVelocity=!0,a.linearVelocity.copy(r.linearVelocity)):a.hasLinearVelocity=!1,r.angularVelocity?(a.hasAngularVelocity=!0,a.angularVelocity.copy(r.angularVelocity)):a.hasAngularVelocity=!1,this.dispatchEvent(PE))),c&&t.hand){o=!0;for(let x of t.hand.values()){let v=e.getJointPose(x,i);if(c.joints[x.jointName]===void 0){let p=new Bi;p.matrixAutoUpdate=!1,p.visible=!1,c.joints[x.jointName]=p,c.add(p)}let m=c.joints[x.jointName];v!==null&&(m.matrix.fromArray(v.transform.matrix),m.matrix.decompose(m.position,m.rotation,m.scale),m.jointRadius=v.radius),m.visible=v!==null}let u=c.joints["index-finger-tip"],h=c.joints["thumb-tip"],f=u.position.distanceTo(h.position),d=.02,g=.005;c.inputState.pinching&&f>d+g?(c.inputState.pinching=!1,this.dispatchEvent({type:"pinchend",handedness:t.handedness,target:this})):!c.inputState.pinching&&f<=d-g&&(c.inputState.pinching=!0,this.dispatchEvent({type:"pinchstart",handedness:t.handedness,target:this}))}else l!==null&&t.gripSpace&&(s=e.getPose(t.gripSpace,i),s!==null&&(l.matrix.fromArray(s.transform.matrix),l.matrix.decompose(l.position,l.rotation,l.scale),s.linearVelocity?(l.hasLinearVelocity=!0,l.linearVelocity.copy(s.linearVelocity)):l.hasLinearVelocity=!1,s.angularVelocity?(l.hasAngularVelocity=!0,l.angularVelocity.copy(s.angularVelocity)):l.hasAngularVelocity=!1));return a!==null&&(a.visible=r!==null),l!==null&&(l.visible=s!==null),c!==null&&(c.visible=o!==null),this}},uo=class extends ae{constructor(t,e,i,r,s,o,a,l,c,u){if(u=u!==void 0?u:Oi,u!==Oi&&u!==Vr)throw new Error("DepthTexture format must be either THREE.DepthFormat or THREE.DepthStencilFormat");i===void 0&&u===Oi&&(i=no),i===void 0&&u===Vr&&(i=Br),super(null,r,s,o,a,l,u,i,c),this.image={width:t,height:e},this.magFilter=a!==void 0?a:fe,this.minFilter=l!==void 0?l:fe,this.flipY=!1,this.generateMipmaps=!1}};uo.prototype.isDepthTexture=!0;var Zu=class extends In{constructor(t,e){super();let i=this,r=null,s=1,o=null,a="local-floor",l=t.extensions.has("WEBGL_multisampled_render_to_texture"),c=null,u=null,h=null,f=null,d=!1,g=null,x=e.getContextAttributes(),v=null,m=null,p=[],b=new Map,_=new Se;_.layers.enable(1),_.viewport=new Wt;let S=new Se;S.layers.enable(2),S.viewport=new Wt;let L=[_,S],A=new hl;A.layers.enable(1),A.layers.enable(2);let H=null,tt=null;this.cameraAutoUpdate=!0,this.enabled=!1,this.isPresenting=!1,this.getController=function(G){let $=p[G];return $===void 0&&($=new Qs,p[G]=$),$.getTargetRaySpace()},this.getControllerGrip=function(G){let $=p[G];return $===void 0&&($=new Qs,p[G]=$),$.getGripSpace()},this.getHand=function(G){let $=p[G];return $===void 0&&($=new Qs,p[G]=$),$.getHandSpace()};function X(G){let $=b.get(G.inputSource);$&&$.dispatchEvent({type:G.type,data:G.inputSource})}function y(){b.forEach(function(G,$){G.disconnect($)}),b.clear(),H=null,tt=null,t.setRenderTarget(v),f=null,h=null,u=null,r=null,m=null,at.stop(),i.isPresenting=!1,i.dispatchEvent({type:"sessionend"})}this.setFramebufferScaleFactor=function(G){s=G,i.isPresenting===!0&&console.warn("THREE.WebXRManager: Cannot change framebuffer scale while presenting.")},this.setReferenceSpaceType=function(G){a=G,i.isPresenting===!0&&console.warn("THREE.WebXRManager: Cannot change reference space type while presenting.")},this.getReferenceSpace=function(){return o},this.getBaseLayer=function(){return h!==null?h:f},this.getBinding=function(){return u},this.getFrame=function(){return g},this.getSession=function(){return r},this.setSession=function(G){return hf(this,null,function*(){if(r=G,r!==null){if(v=t.getRenderTarget(),r.addEventListener("select",X),r.addEventListener("selectstart",X),r.addEventListener("selectend",X),r.addEventListener("squeeze",X),r.addEventListener("squeezestart",X),r.addEventListener("squeezeend",X),r.addEventListener("end",y),r.addEventListener("inputsourceschange",R),x.xrCompatible!==!0&&(yield e.makeXRCompatible()),r.renderState.layers===void 0||t.capabilities.isWebGL2===!1){let $={antialias:r.renderState.layers===void 0?x.antialias:!0,alpha:x.alpha,depth:x.depth,stencil:x.stencil,framebufferScaleFactor:s};f=new XRWebGLLayer(r,e,$),r.updateRenderState({baseLayer:f}),m=new Ne(f.framebufferWidth,f.framebufferHeight,{format:Re,type:ei,encoding:t.outputEncoding})}else{d=x.antialias;let $=null,lt=null,dt=null;x.depth&&(dt=x.stencil?35056:33190,$=x.stencil?Vr:Oi,lt=x.stencil?Br:no);let xt={colorFormat:t.outputEncoding===$t?35907:32856,depthFormat:dt,scaleFactor:s};u=new XRWebGLBinding(r,e),h=u.createProjectionLayer(xt),r.updateRenderState({layers:[h]}),d?m=new so(h.textureWidth,h.textureHeight,{format:Re,type:ei,depthTexture:new uo(h.textureWidth,h.textureHeight,lt,void 0,void 0,void 0,void 0,void 0,void 0,$),stencilBuffer:x.stencil,ignoreDepth:h.ignoreDepthValues,useRenderToTexture:l,encoding:t.outputEncoding}):m=new Ne(h.textureWidth,h.textureHeight,{format:Re,type:ei,depthTexture:new uo(h.textureWidth,h.textureHeight,lt,void 0,void 0,void 0,void 0,void 0,void 0,$),stencilBuffer:x.stencil,ignoreDepth:h.ignoreDepthValues,encoding:t.outputEncoding})}m.isXRRenderTarget=!0,this.setFoveation(1),o=yield r.requestReferenceSpace(a),at.setContext(r),at.start(),i.isPresenting=!0,i.dispatchEvent({type:"sessionstart"})}})};function R(G){let $=r.inputSources;for(let lt=0;lt<p.length;lt++)b.set($[lt],p[lt]);for(let lt=0;lt<G.removed.length;lt++){let dt=G.removed[lt],xt=b.get(dt);xt&&(xt.dispatchEvent({type:"disconnected",data:dt}),b.delete(dt))}for(let lt=0;lt<G.added.length;lt++){let dt=G.added[lt],xt=b.get(dt);xt&&xt.dispatchEvent({type:"connected",data:dt})}}let D=new T,F=new T;function z(G,$,lt){D.setFromMatrixPosition($.matrixWorld),F.setFromMatrixPosition(lt.matrixWorld);let dt=D.distanceTo(F),xt=$.projectionMatrix.elements,k=lt.projectionMatrix.elements,Ft=xt[14]/(xt[10]-1),mt=xt[14]/(xt[10]+1),St=(xt[9]+1)/xt[5],B=(xt[9]-1)/xt[5],st=(xt[8]-1)/xt[0],nt=(k[8]+1)/k[0],C=Ft*st,j=Ft*nt,J=dt/(-st+nt),it=J*-st;$.matrixWorld.decompose(G.position,G.quaternion,G.scale),G.translateX(it),G.translateZ(J),G.matrixWorld.compose(G.position,G.quaternion,G.scale),G.matrixWorldInverse.copy(G.matrixWorld).invert();let et=Ft+J,vt=mt+J,bt=C-it,It=j+(dt-it),Zt=St*mt/vt*et,qt=B*mt/vt*et;G.projectionMatrix.makePerspective(bt,It,Zt,qt,et,vt)}function N(G,$){$===null?G.matrixWorld.copy(G.matrix):G.matrixWorld.multiplyMatrices($.matrixWorld,G.matrix),G.matrixWorldInverse.copy(G.matrixWorld).invert()}this.updateCamera=function(G){if(r===null)return;A.near=S.near=_.near=G.near,A.far=S.far=_.far=G.far,(H!==A.near||tt!==A.far)&&(r.updateRenderState({depthNear:A.near,depthFar:A.far}),H=A.near,tt=A.far);let $=G.parent,lt=A.cameras;N(A,$);for(let xt=0;xt<lt.length;xt++)N(lt[xt],$);A.matrixWorld.decompose(A.position,A.quaternion,A.scale),G.position.copy(A.position),G.quaternion.copy(A.quaternion),G.scale.copy(A.scale),G.matrix.copy(A.matrix),G.matrixWorld.copy(A.matrixWorld);let dt=G.children;for(let xt=0,k=dt.length;xt<k;xt++)dt[xt].updateMatrixWorld(!0);lt.length===2?z(A,_,S):A.projectionMatrix.copy(_.projectionMatrix)},this.getCamera=function(){return A},this.getFoveation=function(){if(h!==null)return h.fixedFoveation;if(f!==null)return f.fixedFoveation},this.setFoveation=function(G){h!==null&&(h.fixedFoveation=G),f!==null&&f.fixedFoveation!==void 0&&(f.fixedFoveation=G)};let V=null;function Q(G,$){if(c=$.getViewerPose(o),g=$,c!==null){let dt=c.views;f!==null&&(t.setRenderTargetFramebuffer(m,f.framebuffer),t.setRenderTarget(m));let xt=!1;dt.length!==A.cameras.length&&(A.cameras.length=0,xt=!0);for(let k=0;k<dt.length;k++){let Ft=dt[k],mt=null;if(f!==null)mt=f.getViewport(Ft);else{let B=u.getViewSubImage(h,Ft);mt=B.viewport,k===0&&(t.setRenderTargetTextures(m,B.colorTexture,h.ignoreDepthValues?void 0:B.depthStencilTexture),t.setRenderTarget(m))}let St=L[k];St.matrix.fromArray(Ft.transform.matrix),St.projectionMatrix.fromArray(Ft.projectionMatrix),St.viewport.set(mt.x,mt.y,mt.width,mt.height),k===0&&A.matrix.copy(St.matrix),xt===!0&&A.cameras.push(St)}}let lt=r.inputSources;for(let dt=0;dt<p.length;dt++){let xt=p[dt],k=lt[dt];xt.update(k,$,o)}V&&V(G,$),g=null}let at=new g0;at.setAnimationLoop(Q),this.setAnimationLoop=function(G){V=G},this.dispose=function(){}}};function DE(n){function t(m,p){m.fogColor.value.copy(p.color),p.isFog?(m.fogNear.value=p.near,m.fogFar.value=p.far):p.isFogExp2&&(m.fogDensity.value=p.density)}function e(m,p,b,_,S){p.isMeshBasicMaterial?i(m,p):p.isMeshLambertMaterial?(i(m,p),l(m,p)):p.isMeshToonMaterial?(i(m,p),u(m,p)):p.isMeshPhongMaterial?(i(m,p),c(m,p)):p.isMeshStandardMaterial?(i(m,p),p.isMeshPhysicalMaterial?f(m,p,S):h(m,p)):p.isMeshMatcapMaterial?(i(m,p),d(m,p)):p.isMeshDepthMaterial?(i(m,p),g(m,p)):p.isMeshDistanceMaterial?(i(m,p),x(m,p)):p.isMeshNormalMaterial?(i(m,p),v(m,p)):p.isLineBasicMaterial?(r(m,p),p.isLineDashedMaterial&&s(m,p)):p.isPointsMaterial?o(m,p,b,_):p.isSpriteMaterial?a(m,p):p.isShadowMaterial?(m.color.value.copy(p.color),m.opacity.value=p.opacity):p.isShaderMaterial&&(p.uniformsNeedUpdate=!1)}function i(m,p){m.opacity.value=p.opacity,p.color&&m.diffuse.value.copy(p.color),p.emissive&&m.emissive.value.copy(p.emissive).multiplyScalar(p.emissiveIntensity),p.map&&(m.map.value=p.map),p.alphaMap&&(m.alphaMap.value=p.alphaMap),p.specularMap&&(m.specularMap.value=p.specularMap),p.alphaTest>0&&(m.alphaTest.value=p.alphaTest);let b=n.get(p).envMap;b&&(m.envMap.value=b,m.flipEnvMap.value=b.isCubeTexture&&b.isRenderTargetTexture===!1?-1:1,m.reflectivity.value=p.reflectivity,m.ior.value=p.ior,m.refractionRatio.value=p.refractionRatio),p.lightMap&&(m.lightMap.value=p.lightMap,m.lightMapIntensity.value=p.lightMapIntensity),p.aoMap&&(m.aoMap.value=p.aoMap,m.aoMapIntensity.value=p.aoMapIntensity);let _;p.map?_=p.map:p.specularMap?_=p.specularMap:p.displacementMap?_=p.displacementMap:p.normalMap?_=p.normalMap:p.bumpMap?_=p.bumpMap:p.roughnessMap?_=p.roughnessMap:p.metalnessMap?_=p.metalnessMap:p.alphaMap?_=p.alphaMap:p.emissiveMap?_=p.emissiveMap:p.clearcoatMap?_=p.clearcoatMap:p.clearcoatNormalMap?_=p.clearcoatNormalMap:p.clearcoatRoughnessMap?_=p.clearcoatRoughnessMap:p.specularIntensityMap?_=p.specularIntensityMap:p.specularColorMap?_=p.specularColorMap:p.transmissionMap?_=p.transmissionMap:p.thicknessMap?_=p.thicknessMap:p.sheenColorMap?_=p.sheenColorMap:p.sheenRoughnessMap&&(_=p.sheenRoughnessMap),_!==void 0&&(_.isWebGLRenderTarget&&(_=_.texture),_.matrixAutoUpdate===!0&&_.updateMatrix(),m.uvTransform.value.copy(_.matrix));let S;p.aoMap?S=p.aoMap:p.lightMap&&(S=p.lightMap),S!==void 0&&(S.isWebGLRenderTarget&&(S=S.texture),S.matrixAutoUpdate===!0&&S.updateMatrix(),m.uv2Transform.value.copy(S.matrix))}function r(m,p){m.diffuse.value.copy(p.color),m.opacity.value=p.opacity}function s(m,p){m.dashSize.value=p.dashSize,m.totalSize.value=p.dashSize+p.gapSize,m.scale.value=p.scale}function o(m,p,b,_){m.diffuse.value.copy(p.color),m.opacity.value=p.opacity,m.size.value=p.size*b,m.scale.value=_*.5,p.map&&(m.map.value=p.map),p.alphaMap&&(m.alphaMap.value=p.alphaMap),p.alphaTest>0&&(m.alphaTest.value=p.alphaTest);let S;p.map?S=p.map:p.alphaMap&&(S=p.alphaMap),S!==void 0&&(S.matrixAutoUpdate===!0&&S.updateMatrix(),m.uvTransform.value.copy(S.matrix))}function a(m,p){m.diffuse.value.copy(p.color),m.opacity.value=p.opacity,m.rotation.value=p.rotation,p.map&&(m.map.value=p.map),p.alphaMap&&(m.alphaMap.value=p.alphaMap),p.alphaTest>0&&(m.alphaTest.value=p.alphaTest);let b;p.map?b=p.map:p.alphaMap&&(b=p.alphaMap),b!==void 0&&(b.matrixAutoUpdate===!0&&b.updateMatrix(),m.uvTransform.value.copy(b.matrix))}function l(m,p){p.emissiveMap&&(m.emissiveMap.value=p.emissiveMap)}function c(m,p){m.specular.value.copy(p.specular),m.shininess.value=Math.max(p.shininess,1e-4),p.emissiveMap&&(m.emissiveMap.value=p.emissiveMap),p.bumpMap&&(m.bumpMap.value=p.bumpMap,m.bumpScale.value=p.bumpScale,p.side===he&&(m.bumpScale.value*=-1)),p.normalMap&&(m.normalMap.value=p.normalMap,m.normalScale.value.copy(p.normalScale),p.side===he&&m.normalScale.value.negate()),p.displacementMap&&(m.displacementMap.value=p.displacementMap,m.displacementScale.value=p.displacementScale,m.displacementBias.value=p.displacementBias)}function u(m,p){p.gradientMap&&(m.gradientMap.value=p.gradientMap),p.emissiveMap&&(m.emissiveMap.value=p.emissiveMap),p.bumpMap&&(m.bumpMap.value=p.bumpMap,m.bumpScale.value=p.bumpScale,p.side===he&&(m.bumpScale.value*=-1)),p.normalMap&&(m.normalMap.value=p.normalMap,m.normalScale.value.copy(p.normalScale),p.side===he&&m.normalScale.value.negate()),p.displacementMap&&(m.displacementMap.value=p.displacementMap,m.displacementScale.value=p.displacementScale,m.displacementBias.value=p.displacementBias)}function h(m,p){m.roughness.value=p.roughness,m.metalness.value=p.metalness,p.roughnessMap&&(m.roughnessMap.value=p.roughnessMap),p.metalnessMap&&(m.metalnessMap.value=p.metalnessMap),p.emissiveMap&&(m.emissiveMap.value=p.emissiveMap),p.bumpMap&&(m.bumpMap.value=p.bumpMap,m.bumpScale.value=p.bumpScale,p.side===he&&(m.bumpScale.value*=-1)),p.normalMap&&(m.normalMap.value=p.normalMap,m.normalScale.value.copy(p.normalScale),p.side===he&&m.normalScale.value.negate()),p.displacementMap&&(m.displacementMap.value=p.displacementMap,m.displacementScale.value=p.displacementScale,m.displacementBias.value=p.displacementBias),n.get(p).envMap&&(m.envMapIntensity.value=p.envMapIntensity)}function f(m,p,b){h(m,p),m.ior.value=p.ior,p.sheen>0&&(m.sheenColor.value.copy(p.sheenColor).multiplyScalar(p.sheen),m.sheenRoughness.value=p.sheenRoughness,p.sheenColorMap&&(m.sheenColorMap.value=p.sheenColorMap),p.sheenRoughnessMap&&(m.sheenRoughnessMap.value=p.sheenRoughnessMap)),p.clearcoat>0&&(m.clearcoat.value=p.clearcoat,m.clearcoatRoughness.value=p.clearcoatRoughness,p.clearcoatMap&&(m.clearcoatMap.value=p.clearcoatMap),p.clearcoatRoughnessMap&&(m.clearcoatRoughnessMap.value=p.clearcoatRoughnessMap),p.clearcoatNormalMap&&(m.clearcoatNormalScale.value.copy(p.clearcoatNormalScale),m.clearcoatNormalMap.value=p.clearcoatNormalMap,p.side===he&&m.clearcoatNormalScale.value.negate())),p.transmission>0&&(m.transmission.value=p.transmission,m.transmissionSamplerMap.value=b.texture,m.transmissionSamplerSize.value.set(b.width,b.height),p.transmissionMap&&(m.transmissionMap.value=p.transmissionMap),m.thickness.value=p.thickness,p.thicknessMap&&(m.thicknessMap.value=p.thicknessMap),m.attenuationDistance.value=p.attenuationDistance,m.attenuationColor.value.copy(p.attenuationColor)),m.specularIntensity.value=p.specularIntensity,m.specularColor.value.copy(p.specularColor),p.specularIntensityMap&&(m.specularIntensityMap.value=p.specularIntensityMap),p.specularColorMap&&(m.specularColorMap.value=p.specularColorMap)}function d(m,p){p.matcap&&(m.matcap.value=p.matcap),p.bumpMap&&(m.bumpMap.value=p.bumpMap,m.bumpScale.value=p.bumpScale,p.side===he&&(m.bumpScale.value*=-1)),p.normalMap&&(m.normalMap.value=p.normalMap,m.normalScale.value.copy(p.normalScale),p.side===he&&m.normalScale.value.negate()),p.displacementMap&&(m.displacementMap.value=p.displacementMap,m.displacementScale.value=p.displacementScale,m.displacementBias.value=p.displacementBias)}function g(m,p){p.displacementMap&&(m.displacementMap.value=p.displacementMap,m.displacementScale.value=p.displacementScale,m.displacementBias.value=p.displacementBias)}function x(m,p){p.displacementMap&&(m.displacementMap.value=p.displacementMap,m.displacementScale.value=p.displacementScale,m.displacementBias.value=p.displacementBias),m.referencePosition.value.copy(p.referencePosition),m.nearDistance.value=p.nearDistance,m.farDistance.value=p.farDistance}function v(m,p){p.bumpMap&&(m.bumpMap.value=p.bumpMap,m.bumpScale.value=p.bumpScale,p.side===he&&(m.bumpScale.value*=-1)),p.normalMap&&(m.normalMap.value=p.normalMap,m.normalScale.value.copy(p.normalScale),p.side===he&&m.normalScale.value.negate()),p.displacementMap&&(m.displacementMap.value=p.displacementMap,m.displacementScale.value=p.displacementScale,m.displacementBias.value=p.displacementBias)}return{refreshFogUniforms:t,refreshMaterialUniforms:e}}function IE(){let n=ro("canvas");return n.style.display="block",n}function Vt(n={}){let t=n.canvas!==void 0?n.canvas:IE(),e=n.context!==void 0?n.context:null,i=n.alpha!==void 0?n.alpha:!1,r=n.depth!==void 0?n.depth:!0,s=n.stencil!==void 0?n.stencil:!0,o=n.antialias!==void 0?n.antialias:!1,a=n.premultipliedAlpha!==void 0?n.premultipliedAlpha:!0,l=n.preserveDrawingBuffer!==void 0?n.preserveDrawingBuffer:!1,c=n.powerPreference!==void 0?n.powerPreference:"default",u=n.failIfMajorPerformanceCaveat!==void 0?n.failIfMajorPerformanceCaveat:!1,h=null,f=null,d=[],g=[];this.domElement=t,this.debug={checkShaderErrors:!0},this.autoClear=!0,this.autoClearColor=!0,this.autoClearDepth=!0,this.autoClearStencil=!0,this.sortObjects=!0,this.clippingPlanes=[],this.localClippingEnabled=!1,this.outputEncoding=ri,this.physicallyCorrectLights=!1,this.toneMapping=ti,this.toneMappingExposure=1;let x=this,v=!1,m=0,p=0,b=null,_=-1,S=null,L=new Wt,A=new Wt,H=null,tt=t.width,X=t.height,y=1,R=null,D=null,F=new Wt(0,0,tt,X),z=new Wt(0,0,tt,X),N=!1,V=new qr,Q=!1,at=!1,G=null,$=new wt,lt=new T,dt={background:null,fog:null,environment:null,overrideMaterial:null,isScene:!0};function xt(){return b===null?y:1}let k=e;function Ft(M,I){for(let O=0;O<M.length;O++){let U=M[O],Z=t.getContext(U,I);if(Z!==null)return Z}return null}try{let M={alpha:!0,depth:r,stencil:s,antialias:o,premultipliedAlpha:a,preserveDrawingBuffer:l,powerPreference:c,failIfMajorPerformanceCaveat:u};if("setAttribute"in t&&t.setAttribute("data-engine",`three.js r${$h}`),t.addEventListener("webglcontextlost",At,!1),t.addEventListener("webglcontextrestored",P,!1),k===null){let I=["webgl2","webgl","experimental-webgl"];if(x.isWebGL1Renderer===!0&&I.shift(),k=Ft(I,M),k===null)throw Ft(I)?new Error("Error creating WebGL context with your selected attributes."):new Error("Error creating WebGL context.")}k.getShaderPrecisionFormat===void 0&&(k.getShaderPrecisionFormat=function(){return{rangeMin:1,rangeMax:1,precision:1}})}catch(M){throw console.error("THREE.WebGLRenderer: "+M.message),M}let mt,St,B,st,nt,C,j,J,it,et,vt,bt,It,Zt,qt,E,w,q,rt,gt,W,_t,yt;function ut(){mt=new eS(k),St=new J1(k,mt,n),mt.init(St),_t=new LE(k,mt,St),B=new CE(k,mt,St),st=new rS(k),nt=new xE,C=new RE(k,mt,B,nt,St,_t,st),j=new K1(x),J=new tS(x),it=new vM(k,St),yt=new Y1(k,mt,it,St),et=new nS(k,it,st,yt),vt=new lS(k,et,it,st),rt=new aS(k,St,C),E=new $1(nt),bt=new gE(x,j,J,mt,St,yt,E),It=new DE(nt),Zt=new vE,qt=new EE(mt,St),q=new X1(x,j,B,vt,i,a),w=new T0(x,vt,St),gt=new Z1(k,mt,st,St),W=new iS(k,mt,st,St),st.programs=bt.programs,x.capabilities=St,x.extensions=mt,x.properties=nt,x.renderLists=Zt,x.shadowMap=w,x.state=B,x.info=st}ut();let ct=new Zu(x,k);this.xr=ct,this.getContext=function(){return k},this.getContextAttributes=function(){return k.getContextAttributes()},this.forceContextLoss=function(){let M=mt.get("WEBGL_lose_context");M&&M.loseContext()},this.forceContextRestore=function(){let M=mt.get("WEBGL_lose_context");M&&M.restoreContext()},this.getPixelRatio=function(){return y},this.setPixelRatio=function(M){M!==void 0&&(y=M,this.setSize(tt,X,!1))},this.getSize=function(M){return M.set(tt,X)},this.setSize=function(M,I,O){if(ct.isPresenting){console.warn("THREE.WebGLRenderer: Can't change size while VR device is presenting.");return}tt=M,X=I,t.width=Math.floor(M*y),t.height=Math.floor(I*y),O!==!1&&(t.style.width=M+"px",t.style.height=I+"px"),this.setViewport(0,0,M,I)},this.getDrawingBufferSize=function(M){return M.set(tt*y,X*y).floor()},this.setDrawingBufferSize=function(M,I,O){tt=M,X=I,y=O,t.width=Math.floor(M*O),t.height=Math.floor(I*O),this.setViewport(0,0,M,I)},this.getCurrentViewport=function(M){return M.copy(L)},this.getViewport=function(M){return M.copy(F)},this.setViewport=function(M,I,O,U){M.isVector4?F.set(M.x,M.y,M.z,M.w):F.set(M,I,O,U),B.viewport(L.copy(F).multiplyScalar(y).floor())},this.getScissor=function(M){return M.copy(z)},this.setScissor=function(M,I,O,U){M.isVector4?z.set(M.x,M.y,M.z,M.w):z.set(M,I,O,U),B.scissor(A.copy(z).multiplyScalar(y).floor())},this.getScissorTest=function(){return N},this.setScissorTest=function(M){B.setScissorTest(N=M)},this.setOpaqueSort=function(M){R=M},this.setTransparentSort=function(M){D=M},this.getClearColor=function(M){return M.copy(q.getClearColor())},this.setClearColor=function(){q.setClearColor.apply(q,arguments)},this.getClearAlpha=function(){return q.getClearAlpha()},this.setClearAlpha=function(){q.setClearAlpha.apply(q,arguments)},this.clear=function(M,I,O){let U=0;(M===void 0||M)&&(U|=16384),(I===void 0||I)&&(U|=256),(O===void 0||O)&&(U|=1024),k.clear(U)},this.clearColor=function(){this.clear(!0,!1,!1)},this.clearDepth=function(){this.clear(!1,!0,!1)},this.clearStencil=function(){this.clear(!1,!1,!0)},this.dispose=function(){t.removeEventListener("webglcontextlost",At,!1),t.removeEventListener("webglcontextrestored",P,!1),Zt.dispose(),qt.dispose(),nt.dispose(),j.dispose(),J.dispose(),vt.dispose(),yt.dispose(),bt.dispose(),ct.dispose(),ct.removeEventListener("sessionstart",Dt),ct.removeEventListener("sessionend",jt),G&&(G.dispose(),G=null),ze.stop()};function At(M){M.preventDefault(),console.log("THREE.WebGLRenderer: Context Lost."),v=!0}function P(){console.log("THREE.WebGLRenderer: Context Restored."),v=!1;let M=st.autoReset,I=w.enabled,O=w.autoUpdate,U=w.needsUpdate,Z=w.type;ut(),st.autoReset=M,w.enabled=I,w.autoUpdate=O,w.needsUpdate=U,w.type=Z}function pt(M){let I=M.target;I.removeEventListener("dispose",pt),ht(I)}function ht(M){Et(M),nt.remove(M)}function Et(M){let I=nt.get(M).programs;I!==void 0&&(I.forEach(function(O){bt.releaseProgram(O)}),M.isShaderMaterial&&bt.releaseShaderCache(M))}this.renderBufferDirect=function(M,I,O,U,Z,Tt){I===null&&(I=dt);let Ct=Z.isMesh&&Z.matrixWorld.determinant()<0,Lt=B0(M,I,O,U,Z);B.setMaterial(U,Ct);let Rt=O.index,Gt=O.attributes.position;if(Rt===null){if(Gt===void 0||Gt.count===0)return}else if(Rt.count===0)return;let zt=1;U.wireframe===!0&&(Rt=et.getWireframeAttribute(O),zt=2),yt.setup(Z,U,Lt,O,Rt);let Ut,ie=gt;Rt!==null&&(Ut=it.get(Rt),ie=W,ie.setIndex(Ut));let fi=Rt!==null?Rt.count:Gt.count,Zi=O.drawRange.start*zt,Ot=O.drawRange.count*zt,nn=Tt!==null?Tt.start*zt:0,le=Tt!==null?Tt.count*zt:1/0,rn=Math.max(Zi,nn),Io=Math.min(fi,Zi+Ot,nn+le)-1,sn=Math.max(0,Io-rn+1);if(sn!==0){if(Z.isMesh)U.wireframe===!0?(B.setLineWidth(U.wireframeLinewidth*xt()),ie.setMode(1)):ie.setMode(4);else if(Z.isLine){let vn=U.linewidth;vn===void 0&&(vn=1),B.setLineWidth(vn*xt()),Z.isLineSegments?ie.setMode(1):Z.isLineLoop?ie.setMode(2):ie.setMode(3)}else Z.isPoints?ie.setMode(0):Z.isSprite&&ie.setMode(4);if(Z.isInstancedMesh)ie.renderInstances(rn,sn,Z.count);else if(O.isInstancedBufferGeometry){let vn=Math.min(O.instanceCount,O._maxInstanceCount);ie.renderInstances(rn,sn,vn)}else ie.render(rn,sn)}},this.compile=function(M,I){f=qt.get(M),f.init(),g.push(f),M.traverseVisible(function(O){O.isLight&&O.layers.test(I.layers)&&(f.pushLight(O),O.castShadow&&f.pushShadow(O))}),f.setupLights(x.physicallyCorrectLights),M.traverse(function(O){let U=O.material;if(U)if(Array.isArray(U))for(let Z=0;Z<U.length;Z++){let Tt=U[Z];Ol(Tt,M,O)}else Ol(U,M,O)}),g.pop(),f=null};let Y=null;function Mt(M){Y&&Y(M)}function Dt(){ze.stop()}function jt(){ze.start()}let ze=new g0;ze.setAnimationLoop(Mt),typeof window!="undefined"&&ze.setContext(window),this.setAnimationLoop=function(M){Y=M,ct.setAnimationLoop(M),M===null?ze.stop():ze.start()},ct.addEventListener("sessionstart",Dt),ct.addEventListener("sessionend",jt),this.render=function(M,I){if(I!==void 0&&I.isCamera!==!0){console.error("THREE.WebGLRenderer.render: camera is not an instance of THREE.Camera.");return}if(v===!0)return;M.autoUpdate===!0&&M.updateMatrixWorld(),I.parent===null&&I.updateMatrixWorld(),ct.enabled===!0&&ct.isPresenting===!0&&(ct.cameraAutoUpdate===!0&&ct.updateCamera(I),I=ct.getCamera()),M.isScene===!0&&M.onBeforeRender(x,M,I,b),f=qt.get(M,g.length),f.init(),g.push(f),$.multiplyMatrices(I.projectionMatrix,I.matrixWorldInverse),V.setFromProjectionMatrix($),at=this.localClippingEnabled,Q=E.init(this.clippingPlanes,at,I),h=Zt.get(M,d.length),h.init(),d.push(h),ne(M,I,0,x.sortObjects),h.finish(),x.sortObjects===!0&&h.sort(R,D),Q===!0&&E.beginShadows();let O=f.state.shadowsArray;if(w.render(O,M,I),Q===!0&&E.endShadows(),this.info.autoReset===!0&&this.info.reset(),q.render(h,M),f.setupLights(x.physicallyCorrectLights),I.isArrayCamera){let U=I.cameras;for(let Z=0,Tt=U.length;Z<Tt;Z++){let Ct=U[Z];en(h,M,Ct,Ct.viewport)}}else en(h,M,I);b!==null&&(C.updateMultisampleRenderTarget(b),C.updateRenderTargetMipmap(b)),M.isScene===!0&&M.onAfterRender(x,M,I),B.buffers.depth.setTest(!0),B.buffers.depth.setMask(!0),B.buffers.color.setMask(!0),B.setPolygonOffset(!1),yt.resetDefaultState(),_=-1,S=null,g.pop(),g.length>0?f=g[g.length-1]:f=null,d.pop(),d.length>0?h=d[d.length-1]:h=null};function ne(M,I,O,U){if(M.visible===!1)return;if(M.layers.test(I.layers)){if(M.isGroup)O=M.renderOrder;else if(M.isLOD)M.autoUpdate===!0&&M.update(I);else if(M.isLight)f.pushLight(M),M.castShadow&&f.pushShadow(M);else if(M.isSprite){if(!M.frustumCulled||V.intersectsSprite(M)){U&&lt.setFromMatrixPosition(M.matrixWorld).applyMatrix4($);let Ct=vt.update(M),Lt=M.material;Lt.visible&&h.push(M,Ct,Lt,O,lt.z,null)}}else if((M.isMesh||M.isLine||M.isPoints)&&(M.isSkinnedMesh&&M.skeleton.frame!==st.render.frame&&(M.skeleton.update(),M.skeleton.frame=st.render.frame),!M.frustumCulled||V.intersectsObject(M))){U&&lt.setFromMatrixPosition(M.matrixWorld).applyMatrix4($);let Ct=vt.update(M),Lt=M.material;if(Array.isArray(Lt)){let Rt=Ct.groups;for(let Gt=0,zt=Rt.length;Gt<zt;Gt++){let Ut=Rt[Gt],ie=Lt[Ut.materialIndex];ie&&ie.visible&&h.push(M,Ct,ie,O,lt.z,Ut)}}else Lt.visible&&h.push(M,Ct,Lt,O,lt.z,null)}}let Tt=M.children;for(let Ct=0,Lt=Tt.length;Ct<Lt;Ct++)ne(Tt[Ct],I,O,U)}function en(M,I,O,U){let Z=M.opaque,Tt=M.transmissive,Ct=M.transparent;f.setupLightsView(O),Tt.length>0&&yn(Z,I,O),U&&B.viewport(L.copy(U)),Z.length>0&&Do(Z,I,O),Tt.length>0&&Do(Tt,I,O),Ct.length>0&&Do(Ct,I,O)}function yn(M,I,O){if(G===null){let Ct=o===!0&&St.isWebGL2===!0?so:Ne;G=new Ct(1024,1024,{generateMipmaps:!0,type:_t.convert(Ur)!==null?Ur:ei,minFilter:Ll,magFilter:fe,wrapS:Ve,wrapT:Ve,useRenderToTexture:mt.has("WEBGL_multisampled_render_to_texture")})}let U=x.getRenderTarget();x.setRenderTarget(G),x.clear();let Z=x.toneMapping;x.toneMapping=ti,Do(M,I,O),x.toneMapping=Z,C.updateMultisampleRenderTarget(G),C.updateRenderTargetMipmap(G),x.setRenderTarget(U)}function Do(M,I,O){let U=I.isScene===!0?I.overrideMaterial:null;for(let Z=0,Tt=M.length;Z<Tt;Z++){let Ct=M[Z],Lt=Ct.object,Rt=Ct.geometry,Gt=U===null?Ct.material:U,zt=Ct.group;Lt.layers.test(O.layers)&&U0(Lt,I,O,Rt,Gt,zt)}}function U0(M,I,O,U,Z,Tt){M.onBeforeRender(x,I,O,U,Z,Tt),M.modelViewMatrix.multiplyMatrices(O.matrixWorldInverse,M.matrixWorld),M.normalMatrix.getNormalMatrix(M.modelViewMatrix),Z.onBeforeRender(x,I,O,U,M,Tt),Z.transparent===!0&&Z.side===Hr?(Z.side=he,Z.needsUpdate=!0,x.renderBufferDirect(O,I,U,Z,M,Tt),Z.side=eo,Z.needsUpdate=!0,x.renderBufferDirect(O,I,U,Z,M,Tt),Z.side=Hr):x.renderBufferDirect(O,I,U,Z,M,Tt),M.onAfterRender(x,I,O,U,Z,Tt)}function Ol(M,I,O){I.isScene!==!0&&(I=dt);let U=nt.get(M),Z=f.state.lights,Tt=f.state.shadowsArray,Ct=Z.state.version,Lt=bt.getParameters(M,Z.state,Tt,I,O),Rt=bt.getProgramCacheKey(Lt),Gt=U.programs;U.environment=M.isMeshStandardMaterial?I.environment:null,U.fog=I.fog,U.envMap=(M.isMeshStandardMaterial?J:j).get(M.envMap||U.environment),Gt===void 0&&(M.addEventListener("dispose",pt),Gt=new Map,U.programs=Gt);let zt=Gt.get(Rt);if(zt!==void 0){if(U.currentProgram===zt&&U.lightsStateVersion===Ct)return of(M,Lt),zt}else Lt.uniforms=bt.getUniforms(M),M.onBuild(O,Lt,x),M.onBeforeCompile(Lt,x),zt=bt.acquireProgram(Lt,Rt),Gt.set(Rt,zt),U.uniforms=Lt.uniforms;let Ut=U.uniforms;(!M.isShaderMaterial&&!M.isRawShaderMaterial||M.clipping===!0)&&(Ut.clippingPlanes=E.uniform),of(M,Lt),U.needsLights=k0(M),U.lightsStateVersion=Ct,U.needsLights&&(Ut.ambientLightColor.value=Z.state.ambient,Ut.lightProbe.value=Z.state.probe,Ut.directionalLights.value=Z.state.directional,Ut.directionalLightShadows.value=Z.state.directionalShadow,Ut.spotLights.value=Z.state.spot,Ut.spotLightShadows.value=Z.state.spotShadow,Ut.rectAreaLights.value=Z.state.rectArea,Ut.ltc_1.value=Z.state.rectAreaLTC1,Ut.ltc_2.value=Z.state.rectAreaLTC2,Ut.pointLights.value=Z.state.point,Ut.pointLightShadows.value=Z.state.pointShadow,Ut.hemisphereLights.value=Z.state.hemi,Ut.directionalShadowMap.value=Z.state.directionalShadowMap,Ut.directionalShadowMatrix.value=Z.state.directionalShadowMatrix,Ut.spotShadowMap.value=Z.state.spotShadowMap,Ut.spotShadowMatrix.value=Z.state.spotShadowMatrix,Ut.pointShadowMap.value=Z.state.pointShadowMap,Ut.pointShadowMatrix.value=Z.state.pointShadowMatrix);let ie=zt.getUniforms(),fi=ii.seqWithValue(ie.seq,Ut);return U.currentProgram=zt,U.uniformsList=fi,zt}function of(M,I){let O=nt.get(M);O.outputEncoding=I.outputEncoding,O.instancing=I.instancing,O.skinning=I.skinning,O.morphTargets=I.morphTargets,O.morphNormals=I.morphNormals,O.morphTargetsCount=I.morphTargetsCount,O.numClippingPlanes=I.numClippingPlanes,O.numIntersection=I.numClipIntersection,O.vertexAlphas=I.vertexAlphas,O.vertexTangents=I.vertexTangents,O.toneMapping=I.toneMapping}function B0(M,I,O,U,Z){I.isScene!==!0&&(I=dt),C.resetTextureUnits();let Tt=I.fog,Ct=U.isMeshStandardMaterial?I.environment:null,Lt=b===null?x.outputEncoding:b.isXRRenderTarget===!0?b.texture.encoding:ri,Rt=(U.isMeshStandardMaterial?J:j).get(U.envMap||Ct),Gt=U.vertexColors===!0&&!!O.attributes.color&&O.attributes.color.itemSize===4,zt=!!U.normalMap&&!!O.attributes.tangent,Ut=!!O.morphAttributes.position,ie=!!O.morphAttributes.normal,fi=O.morphAttributes.position?O.morphAttributes.position.length:0,Zi=U.toneMapped?x.toneMapping:ti,Ot=nt.get(U),nn=f.state.lights;if(Q===!0&&(at===!0||M!==S)){let Ze=M===S&&U.id===_;E.setState(U,M,Ze)}let le=!1;U.version===Ot.__version?(Ot.needsLights&&Ot.lightsStateVersion!==nn.state.version||Ot.outputEncoding!==Lt||Z.isInstancedMesh&&Ot.instancing===!1||!Z.isInstancedMesh&&Ot.instancing===!0||Z.isSkinnedMesh&&Ot.skinning===!1||!Z.isSkinnedMesh&&Ot.skinning===!0||Ot.envMap!==Rt||U.fog&&Ot.fog!==Tt||Ot.numClippingPlanes!==void 0&&(Ot.numClippingPlanes!==E.numPlanes||Ot.numIntersection!==E.numIntersection)||Ot.vertexAlphas!==Gt||Ot.vertexTangents!==zt||Ot.morphTargets!==Ut||Ot.morphNormals!==ie||Ot.toneMapping!==Zi||St.isWebGL2===!0&&Ot.morphTargetsCount!==fi)&&(le=!0):(le=!0,Ot.__version=U.version);let rn=Ot.currentProgram;le===!0&&(rn=Ol(U,I,Z));let Io=!1,sn=!1,vn=!1,_e=rn.getUniforms(),ns=Ot.uniforms;if(B.useProgram(rn.program)&&(Io=!0,sn=!0,vn=!0),U.id!==_&&(_=U.id,sn=!0),Io||S!==M){if(_e.setValue(k,"projectionMatrix",M.projectionMatrix),St.logarithmicDepthBuffer&&_e.setValue(k,"logDepthBufFC",2/(Math.log(M.far+1)/Math.LN2)),S!==M&&(S=M,sn=!0,vn=!0),U.isShaderMaterial||U.isMeshPhongMaterial||U.isMeshToonMaterial||U.isMeshStandardMaterial||U.envMap){let Ze=_e.map.cameraPosition;Ze!==void 0&&Ze.setValue(k,lt.setFromMatrixPosition(M.matrixWorld))}(U.isMeshPhongMaterial||U.isMeshToonMaterial||U.isMeshLambertMaterial||U.isMeshBasicMaterial||U.isMeshStandardMaterial||U.isShaderMaterial)&&_e.setValue(k,"isOrthographic",M.isOrthographicCamera===!0),(U.isMeshPhongMaterial||U.isMeshToonMaterial||U.isMeshLambertMaterial||U.isMeshBasicMaterial||U.isMeshStandardMaterial||U.isShaderMaterial||U.isShadowMaterial||Z.isSkinnedMesh)&&_e.setValue(k,"viewMatrix",M.matrixWorldInverse)}if(Z.isSkinnedMesh){_e.setOptional(k,Z,"bindMatrix"),_e.setOptional(k,Z,"bindMatrixInverse");let Ze=Z.skeleton;Ze&&(St.floatVertexTextures?(Ze.boneTexture===null&&Ze.computeBoneTexture(),_e.setValue(k,"boneTexture",Ze.boneTexture,C),_e.setValue(k,"boneTextureSize",Ze.boneTextureSize)):_e.setOptional(k,Ze,"boneMatrices"))}return!!O&&(O.morphAttributes.position!==void 0||O.morphAttributes.normal!==void 0)&&rt.update(Z,O,U,rn),(sn||Ot.receiveShadow!==Z.receiveShadow)&&(Ot.receiveShadow=Z.receiveShadow,_e.setValue(k,"receiveShadow",Z.receiveShadow)),sn&&(_e.setValue(k,"toneMappingExposure",x.toneMappingExposure),Ot.needsLights&&O0(ns,vn),Tt&&U.fog&&It.refreshFogUniforms(ns,Tt),It.refreshMaterialUniforms(ns,U,y,X,G),ii.upload(k,Ot.uniformsList,ns,C)),U.isShaderMaterial&&U.uniformsNeedUpdate===!0&&(ii.upload(k,Ot.uniformsList,ns,C),U.uniformsNeedUpdate=!1),U.isSpriteMaterial&&_e.setValue(k,"center",Z.center),_e.setValue(k,"modelViewMatrix",Z.modelViewMatrix),_e.setValue(k,"normalMatrix",Z.normalMatrix),_e.setValue(k,"modelMatrix",Z.matrixWorld),rn}function O0(M,I){M.ambientLightColor.needsUpdate=I,M.lightProbe.needsUpdate=I,M.directionalLights.needsUpdate=I,M.directionalLightShadows.needsUpdate=I,M.pointLights.needsUpdate=I,M.pointLightShadows.needsUpdate=I,M.spotLights.needsUpdate=I,M.spotLightShadows.needsUpdate=I,M.rectAreaLights.needsUpdate=I,M.hemisphereLights.needsUpdate=I}function k0(M){return M.isMeshLambertMaterial||M.isMeshToonMaterial||M.isMeshPhongMaterial||M.isMeshStandardMaterial||M.isShadowMaterial||M.isShaderMaterial&&M.lights===!0}this.getActiveCubeFace=function(){return m},this.getActiveMipmapLevel=function(){return p},this.getRenderTarget=function(){return b},this.setRenderTargetTextures=function(M,I,O){nt.get(M.texture).__webglTexture=I,nt.get(M.depthTexture).__webglTexture=O;let U=nt.get(M);U.__hasExternalTextures=!0,U.__hasExternalTextures&&(U.__autoAllocateDepthBuffer=O===void 0,U.__autoAllocateDepthBuffer||M.useRenderToTexture&&(console.warn("render-to-texture extension was disabled because an external texture was provided"),M.useRenderToTexture=!1,M.useRenderbuffer=!0))},this.setRenderTargetFramebuffer=function(M,I){let O=nt.get(M);O.__webglFramebuffer=I,O.__useDefaultFramebuffer=I===void 0},this.setRenderTarget=function(M,I=0,O=0){b=M,m=I,p=O;let U=!0;if(M){let Rt=nt.get(M);Rt.__useDefaultFramebuffer!==void 0?(B.bindFramebuffer(36160,null),U=!1):Rt.__webglFramebuffer===void 0?C.setupRenderTarget(M):Rt.__hasExternalTextures&&C.rebindTextures(M,nt.get(M.texture).__webglTexture,nt.get(M.depthTexture).__webglTexture)}let Z=null,Tt=!1,Ct=!1;if(M){let Rt=M.texture;(Rt.isDataTexture3D||Rt.isDataTexture2DArray)&&(Ct=!0);let Gt=nt.get(M).__webglFramebuffer;M.isWebGLCubeRenderTarget?(Z=Gt[I],Tt=!0):M.useRenderbuffer?Z=nt.get(M).__webglMultisampledFramebuffer:Z=Gt,L.copy(M.viewport),A.copy(M.scissor),H=M.scissorTest}else L.copy(F).multiplyScalar(y).floor(),A.copy(z).multiplyScalar(y).floor(),H=N;if(B.bindFramebuffer(36160,Z)&&St.drawBuffers&&U&&B.drawBuffers(M,Z),B.viewport(L),B.scissor(A),B.setScissorTest(H),Tt){let Rt=nt.get(M.texture);k.framebufferTexture2D(36160,36064,34069+I,Rt.__webglTexture,O)}else if(Ct){let Rt=nt.get(M.texture),Gt=I||0;k.framebufferTextureLayer(36160,36064,Rt.__webglTexture,O||0,Gt)}_=-1},this.readRenderTargetPixels=function(M,I,O,U,Z,Tt,Ct){if(!(M&&M.isWebGLRenderTarget)){console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not THREE.WebGLRenderTarget.");return}let Lt=nt.get(M).__webglFramebuffer;if(M.isWebGLCubeRenderTarget&&Ct!==void 0&&(Lt=Lt[Ct]),Lt){B.bindFramebuffer(36160,Lt);try{let Rt=M.texture,Gt=Rt.format,zt=Rt.type;if(Gt!==Re&&_t.convert(Gt)!==k.getParameter(35739)){console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in RGBA or implementation defined format.");return}let Ut=zt===Ur&&(mt.has("EXT_color_buffer_half_float")||St.isWebGL2&&mt.has("EXT_color_buffer_float"));if(zt!==ei&&_t.convert(zt)!==k.getParameter(35738)&&!(zt===Ui&&(St.isWebGL2||mt.has("OES_texture_float")||mt.has("WEBGL_color_buffer_float")))&&!Ut){console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in UnsignedByteType or implementation defined type.");return}k.checkFramebufferStatus(36160)===36053?I>=0&&I<=M.width-U&&O>=0&&O<=M.height-Z&&k.readPixels(I,O,U,Z,_t.convert(Gt),_t.convert(zt),Tt):console.error("THREE.WebGLRenderer.readRenderTargetPixels: readPixels from renderTarget failed. Framebuffer not complete.")}finally{let Rt=b!==null?nt.get(b).__webglFramebuffer:null;B.bindFramebuffer(36160,Rt)}}},this.copyFramebufferToTexture=function(M,I,O=0){if(I.isFramebufferTexture!==!0){console.error("THREE.WebGLRenderer: copyFramebufferToTexture() can only be used with FramebufferTexture.");return}let U=Math.pow(2,-O),Z=Math.floor(I.image.width*U),Tt=Math.floor(I.image.height*U);C.setTexture2D(I,0),k.copyTexSubImage2D(3553,O,0,0,M.x,M.y,Z,Tt),B.unbindTexture()},this.copyTextureToTexture=function(M,I,O,U=0){let Z=I.image.width,Tt=I.image.height,Ct=_t.convert(O.format),Lt=_t.convert(O.type);C.setTexture2D(O,0),k.pixelStorei(37440,O.flipY),k.pixelStorei(37441,O.premultiplyAlpha),k.pixelStorei(3317,O.unpackAlignment),I.isDataTexture?k.texSubImage2D(3553,U,M.x,M.y,Z,Tt,Ct,Lt,I.image.data):I.isCompressedTexture?k.compressedTexSubImage2D(3553,U,M.x,M.y,I.mipmaps[0].width,I.mipmaps[0].height,Ct,I.mipmaps[0].data):k.texSubImage2D(3553,U,M.x,M.y,Ct,Lt,I.image),U===0&&O.generateMipmaps&&k.generateMipmap(3553),B.unbindTexture()},this.copyTextureToTexture3D=function(M,I,O,U,Z=0){if(x.isWebGL1Renderer){console.warn("THREE.WebGLRenderer.copyTextureToTexture3D: can only be used with WebGL2.");return}let Tt=M.max.x-M.min.x+1,Ct=M.max.y-M.min.y+1,Lt=M.max.z-M.min.z+1,Rt=_t.convert(U.format),Gt=_t.convert(U.type),zt;if(U.isDataTexture3D)C.setTexture3D(U,0),zt=32879;else if(U.isDataTexture2DArray)C.setTexture2DArray(U,0),zt=35866;else{console.warn("THREE.WebGLRenderer.copyTextureToTexture3D: only supports THREE.DataTexture3D and THREE.DataTexture2DArray.");return}k.pixelStorei(37440,U.flipY),k.pixelStorei(37441,U.premultiplyAlpha),k.pixelStorei(3317,U.unpackAlignment);let Ut=k.getParameter(3314),ie=k.getParameter(32878),fi=k.getParameter(3316),Zi=k.getParameter(3315),Ot=k.getParameter(32877),nn=O.isCompressedTexture?O.mipmaps[0]:O.image;k.pixelStorei(3314,nn.width),k.pixelStorei(32878,nn.height),k.pixelStorei(3316,M.min.x),k.pixelStorei(3315,M.min.y),k.pixelStorei(32877,M.min.z),O.isDataTexture||O.isDataTexture3D?k.texSubImage3D(zt,Z,I.x,I.y,I.z,Tt,Ct,Lt,Rt,Gt,nn.data):O.isCompressedTexture?(console.warn("THREE.WebGLRenderer.copyTextureToTexture3D: untested support for compressed srcTexture."),k.compressedTexSubImage3D(zt,Z,I.x,I.y,I.z,Tt,Ct,Lt,Rt,nn.data)):k.texSubImage3D(zt,Z,I.x,I.y,I.z,Tt,Ct,Lt,Rt,Gt,nn),k.pixelStorei(3314,Ut),k.pixelStorei(32878,ie),k.pixelStorei(3316,fi),k.pixelStorei(3315,Zi),k.pixelStorei(32877,Ot),Z===0&&U.generateMipmaps&&k.generateMipmap(zt),B.unbindTexture()},this.initTexture=function(M){C.setTexture2D(M,0),B.unbindTexture()},this.resetState=function(){m=0,p=0,b=null,B.reset(),yt.reset()},typeof __THREE_DEVTOOLS__!="undefined"&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("observe",{detail:this}))}Vt.prototype.isWebGLRenderer=!0;var Ju=class extends Vt{};Ju.prototype.isWebGL1Renderer=!0;var ho=class{constructor(t,e=25e-5){this.name="",this.color=new ft(t),this.density=e}clone(){return new ho(this.color,this.density)}toJSON(){return{type:"FogExp2",color:this.color.getHex(),density:this.density}}};ho.prototype.isFogExp2=!0;var fo=class{constructor(t,e=1,i=1e3){this.name="",this.color=new ft(t),this.near=e,this.far=i}clone(){return new fo(this.color,this.near,this.far)}toJSON(){return{type:"Fog",color:this.color.getHex(),near:this.near,far:this.far}}};fo.prototype.isFog=!0;var Yr=class extends kt{constructor(){super(),this.type="Scene",this.background=null,this.environment=null,this.fog=null,this.overrideMaterial=null,this.autoUpdate=!0,typeof __THREE_DEVTOOLS__!="undefined"&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("observe",{detail:this}))}copy(t,e){return super.copy(t,e),t.background!==null&&(this.background=t.background.clone()),t.environment!==null&&(this.environment=t.environment.clone()),t.fog!==null&&(this.fog=t.fog.clone()),t.overrideMaterial!==null&&(this.overrideMaterial=t.overrideMaterial.clone()),this.autoUpdate=t.autoUpdate,this.matrixAutoUpdate=t.matrixAutoUpdate,this}toJSON(t){let e=super.toJSON(t);return this.fog!==null&&(e.object.fog=this.fog.toJSON()),e}};Yr.prototype.isScene=!0;var Gi=class{constructor(t,e){this.array=t,this.stride=e,this.count=t!==void 0?t.length/e:0,this.usage=io,this.updateRange={offset:0,count:-1},this.version=0,this.uuid=tn()}onUploadCallback(){}set needsUpdate(t){t===!0&&this.version++}setUsage(t){return this.usage=t,this}copy(t){return this.array=new t.array.constructor(t.array),this.count=t.count,this.stride=t.stride,this.usage=t.usage,this}copyAt(t,e,i){t*=this.stride,i*=e.stride;for(let r=0,s=this.stride;r<s;r++)this.array[t+r]=e.array[i+r];return this}set(t,e=0){return this.array.set(t,e),this}clone(t){t.arrayBuffers===void 0&&(t.arrayBuffers={}),this.array.buffer._uuid===void 0&&(this.array.buffer._uuid=tn()),t.arrayBuffers[this.array.buffer._uuid]===void 0&&(t.arrayBuffers[this.array.buffer._uuid]=this.array.slice(0).buffer);let e=new this.array.constructor(t.arrayBuffers[this.array.buffer._uuid]),i=new this.constructor(e,this.stride);return i.setUsage(this.usage),i}onUpload(t){return this.onUploadCallback=t,this}toJSON(t){return t.arrayBuffers===void 0&&(t.arrayBuffers={}),this.array.buffer._uuid===void 0&&(this.array.buffer._uuid=tn()),t.arrayBuffers[this.array.buffer._uuid]===void 0&&(t.arrayBuffers[this.array.buffer._uuid]=Array.prototype.slice.call(new Uint32Array(this.array.buffer))),{uuid:this.uuid,buffer:this.array.buffer._uuid,type:this.array.constructor.name,stride:this.stride}}};Gi.prototype.isInterleavedBuffer=!0;var se=new T,Wi=class{constructor(t,e,i,r=!1){this.name="",this.data=t,this.itemSize=e,this.offset=i,this.normalized=r===!0}get count(){return this.data.count}get array(){return this.data.array}set needsUpdate(t){this.data.needsUpdate=t}applyMatrix4(t){for(let e=0,i=this.data.count;e<i;e++)se.x=this.getX(e),se.y=this.getY(e),se.z=this.getZ(e),se.applyMatrix4(t),this.setXYZ(e,se.x,se.y,se.z);return this}applyNormalMatrix(t){for(let e=0,i=this.count;e<i;e++)se.x=this.getX(e),se.y=this.getY(e),se.z=this.getZ(e),se.applyNormalMatrix(t),this.setXYZ(e,se.x,se.y,se.z);return this}transformDirection(t){for(let e=0,i=this.count;e<i;e++)se.x=this.getX(e),se.y=this.getY(e),se.z=this.getZ(e),se.transformDirection(t),this.setXYZ(e,se.x,se.y,se.z);return this}setX(t,e){return this.data.array[t*this.data.stride+this.offset]=e,this}setY(t,e){return this.data.array[t*this.data.stride+this.offset+1]=e,this}setZ(t,e){return this.data.array[t*this.data.stride+this.offset+2]=e,this}setW(t,e){return this.data.array[t*this.data.stride+this.offset+3]=e,this}getX(t){return this.data.array[t*this.data.stride+this.offset]}getY(t){return this.data.array[t*this.data.stride+this.offset+1]}getZ(t){return this.data.array[t*this.data.stride+this.offset+2]}getW(t){return this.data.array[t*this.data.stride+this.offset+3]}setXY(t,e,i){return t=t*this.data.stride+this.offset,this.data.array[t+0]=e,this.data.array[t+1]=i,this}setXYZ(t,e,i,r){return t=t*this.data.stride+this.offset,this.data.array[t+0]=e,this.data.array[t+1]=i,this.data.array[t+2]=r,this}setXYZW(t,e,i,r,s){return t=t*this.data.stride+this.offset,this.data.array[t+0]=e,this.data.array[t+1]=i,this.data.array[t+2]=r,this.data.array[t+3]=s,this}clone(t){if(t===void 0){console.log("THREE.InterleavedBufferAttribute.clone(): Cloning an interlaved buffer attribute will deinterleave buffer data.");let e=[];for(let i=0;i<this.count;i++){let r=i*this.data.stride+this.offset;for(let s=0;s<this.itemSize;s++)e.push(this.data.array[r+s])}return new Qt(new this.array.constructor(e),this.itemSize,this.normalized)}else return t.interleavedBuffers===void 0&&(t.interleavedBuffers={}),t.interleavedBuffers[this.data.uuid]===void 0&&(t.interleavedBuffers[this.data.uuid]=this.data.clone(t)),new Wi(t.interleavedBuffers[this.data.uuid],this.itemSize,this.offset,this.normalized)}toJSON(t){if(t===void 0){console.log("THREE.InterleavedBufferAttribute.toJSON(): Serializing an interlaved buffer attribute will deinterleave buffer data.");let e=[];for(let i=0;i<this.count;i++){let r=i*this.data.stride+this.offset;for(let s=0;s<this.itemSize;s++)e.push(this.data.array[r+s])}return{itemSize:this.itemSize,type:this.array.constructor.name,array:e,normalized:this.normalized}}else return t.interleavedBuffers===void 0&&(t.interleavedBuffers={}),t.interleavedBuffers[this.data.uuid]===void 0&&(t.interleavedBuffers[this.data.uuid]=this.data.toJSON(t)),{isInterleavedBufferAttribute:!0,itemSize:this.itemSize,data:this.data.uuid,offset:this.offset,normalized:this.normalized}}};Wi.prototype.isInterleavedBufferAttribute=!0;var fl=class extends xe{constructor(t){super(),this.type="SpriteMaterial",this.color=new ft(16777215),this.map=null,this.alphaMap=null,this.rotation=0,this.sizeAttenuation=!0,this.transparent=!0,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.alphaMap=t.alphaMap,this.rotation=t.rotation,this.sizeAttenuation=t.sizeAttenuation,this}};fl.prototype.isSpriteMaterial=!0;var Rr,Ws=new T,Lr=new T,Pr=new T,Dr=new K,qs=new K,A0=new wt,Oa=new T,Xs=new T,ka=new T,Ug=new K,Ru=new K,Bg=new K,$u=class extends kt{constructor(t){if(super(),this.type="Sprite",Rr===void 0){Rr=new Ht;let e=new Float32Array([-.5,-.5,0,0,0,.5,-.5,0,1,0,.5,.5,0,1,1,-.5,.5,0,0,1]),i=new Gi(e,5);Rr.setIndex([0,1,2,0,2,3]),Rr.setAttribute("position",new Wi(i,3,0,!1)),Rr.setAttribute("uv",new Wi(i,2,3,!1))}this.geometry=Rr,this.material=t!==void 0?t:new fl,this.center=new K(.5,.5)}raycast(t,e){t.camera===null&&console.error('THREE.Sprite: "Raycaster.camera" needs to be set in order to raycast against sprites.'),Lr.setFromMatrixScale(this.matrixWorld),A0.copy(t.camera.matrixWorld),this.modelViewMatrix.multiplyMatrices(t.camera.matrixWorldInverse,this.matrixWorld),Pr.setFromMatrixPosition(this.modelViewMatrix),t.camera.isPerspectiveCamera&&this.material.sizeAttenuation===!1&&Lr.multiplyScalar(-Pr.z);let i=this.material.rotation,r,s;i!==0&&(s=Math.cos(i),r=Math.sin(i));let o=this.center;Ha(Oa.set(-.5,-.5,0),Pr,o,Lr,r,s),Ha(Xs.set(.5,-.5,0),Pr,o,Lr,r,s),Ha(ka.set(.5,.5,0),Pr,o,Lr,r,s),Ug.set(0,0),Ru.set(1,0),Bg.set(1,1);let a=t.ray.intersectTriangle(Oa,Xs,ka,!1,Ws);if(a===null&&(Ha(Xs.set(-.5,.5,0),Pr,o,Lr,r,s),Ru.set(0,1),a=t.ray.intersectTriangle(Oa,ka,Xs,!1,Ws),a===null))return;let l=t.ray.origin.distanceTo(Ws);l<t.near||l>t.far||e.push({distance:l,point:Ws.clone(),uv:re.getUV(Ws,Oa,Xs,ka,Ug,Ru,Bg,new K),face:null,object:this})}copy(t){return super.copy(t),t.center!==void 0&&this.center.copy(t.center),this.material=t.material,this}};$u.prototype.isSprite=!0;function Ha(n,t,e,i,r,s){Dr.subVectors(n,e).addScalar(.5).multiply(i),r!==void 0?(qs.x=s*Dr.x-r*Dr.y,qs.y=r*Dr.x+s*Dr.y):qs.copy(Dr),n.copy(t),n.x+=qs.x,n.y+=qs.y,n.applyMatrix4(A0)}var Og=new T,kg=new Wt,Hg=new Wt,NE=new T,Vg=new wt,dl=class extends oe{constructor(t,e){super(t,e),this.type="SkinnedMesh",this.bindMode="attached",this.bindMatrix=new wt,this.bindMatrixInverse=new wt}copy(t){return super.copy(t),this.bindMode=t.bindMode,this.bindMatrix.copy(t.bindMatrix),this.bindMatrixInverse.copy(t.bindMatrixInverse),this.skeleton=t.skeleton,this}bind(t,e){this.skeleton=t,e===void 0&&(this.updateMatrixWorld(!0),this.skeleton.calculateInverses(),e=this.matrixWorld),this.bindMatrix.copy(e),this.bindMatrixInverse.copy(e).invert()}pose(){this.skeleton.pose()}normalizeSkinWeights(){let t=new Wt,e=this.geometry.attributes.skinWeight;for(let i=0,r=e.count;i<r;i++){t.x=e.getX(i),t.y=e.getY(i),t.z=e.getZ(i),t.w=e.getW(i);let s=1/t.manhattanLength();s!==1/0?t.multiplyScalar(s):t.set(1,0,0,0),e.setXYZW(i,t.x,t.y,t.z,t.w)}}updateMatrixWorld(t){super.updateMatrixWorld(t),this.bindMode==="attached"?this.bindMatrixInverse.copy(this.matrixWorld).invert():this.bindMode==="detached"?this.bindMatrixInverse.copy(this.bindMatrix).invert():console.warn("THREE.SkinnedMesh: Unrecognized bindMode: "+this.bindMode)}boneTransform(t,e){let i=this.skeleton,r=this.geometry;kg.fromBufferAttribute(r.attributes.skinIndex,t),Hg.fromBufferAttribute(r.attributes.skinWeight,t),Og.copy(e).applyMatrix4(this.bindMatrix),e.set(0,0,0);for(let s=0;s<4;s++){let o=Hg.getComponent(s);if(o!==0){let a=kg.getComponent(s);Vg.multiplyMatrices(i.bones[a].matrixWorld,i.boneInverses[a]),e.addScaledVector(NE.copy(Og).applyMatrix4(Vg),o)}}return e.applyMatrix4(this.bindMatrixInverse)}};dl.prototype.isSkinnedMesh=!0;var Ku=class extends kt{constructor(){super(),this.type="Bone"}};Ku.prototype.isBone=!0;var Qu=class extends ae{constructor(t=null,e=1,i=1,r,s,o,a,l,c=fe,u=fe,h,f){super(null,o,a,l,c,u,r,s,h,f),this.image={data:t,width:e,height:i},this.magFilter=c,this.minFilter=u,this.generateMipmaps=!1,this.flipY=!1,this.unpackAlignment=1}};Qu.prototype.isDataTexture=!0;var po=class extends Qt{constructor(t,e,i,r=1){typeof i=="number"&&(r=i,i=!1,console.error("THREE.InstancedBufferAttribute: The constructor now expects normalized as the third argument.")),super(t,e,i),this.meshPerAttribute=r}copy(t){return super.copy(t),this.meshPerAttribute=t.meshPerAttribute,this}toJSON(){let t=super.toJSON();return t.meshPerAttribute=this.meshPerAttribute,t.isInstancedBufferAttribute=!0,t}};po.prototype.isInstancedBufferAttribute=!0;var Gg=new wt,Wg=new wt,Va=[],Ys=new oe,ju=class extends oe{constructor(t,e,i){super(t,e),this.instanceMatrix=new po(new Float32Array(i*16),16),this.instanceColor=null,this.count=i,this.frustumCulled=!1}copy(t){return super.copy(t),this.instanceMatrix.copy(t.instanceMatrix),t.instanceColor!==null&&(this.instanceColor=t.instanceColor.clone()),this.count=t.count,this}getColorAt(t,e){e.fromArray(this.instanceColor.array,t*3)}getMatrixAt(t,e){e.fromArray(this.instanceMatrix.array,t*16)}raycast(t,e){let i=this.matrixWorld,r=this.count;if(Ys.geometry=this.geometry,Ys.material=this.material,Ys.material!==void 0)for(let s=0;s<r;s++){this.getMatrixAt(s,Gg),Wg.multiplyMatrices(i,Gg),Ys.matrixWorld=Wg,Ys.raycast(t,Va);for(let o=0,a=Va.length;o<a;o++){let l=Va[o];l.instanceId=s,l.object=this,e.push(l)}Va.length=0}}setColorAt(t,e){this.instanceColor===null&&(this.instanceColor=new po(new Float32Array(this.instanceMatrix.count*3),3)),e.toArray(this.instanceColor.array,t*3)}setMatrixAt(t,e){e.toArray(this.instanceMatrix.array,t*16)}updateMorphTargets(){}dispose(){this.dispatchEvent({type:"dispose"})}};ju.prototype.isInstancedMesh=!0;var zn=class extends xe{constructor(t){super(),this.type="LineBasicMaterial",this.color=new ft(16777215),this.linewidth=1,this.linecap="round",this.linejoin="round",this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.linewidth=t.linewidth,this.linecap=t.linecap,this.linejoin=t.linejoin,this}};zn.prototype.isLineBasicMaterial=!0;var qg=new T,Xg=new T,Yg=new wt,Lu=new oi,Ga=new si,mo=class extends kt{constructor(t=new Ht,e=new zn){super(),this.type="Line",this.geometry=t,this.material=e,this.updateMorphTargets()}copy(t){return super.copy(t),this.material=t.material,this.geometry=t.geometry,this}computeLineDistances(){let t=this.geometry;if(t.isBufferGeometry)if(t.index===null){let e=t.attributes.position,i=[0];for(let r=1,s=e.count;r<s;r++)qg.fromBufferAttribute(e,r-1),Xg.fromBufferAttribute(e,r),i[r]=i[r-1],i[r]+=qg.distanceTo(Xg);t.setAttribute("lineDistance",new ee(i,1))}else console.warn("THREE.Line.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.");else t.isGeometry&&console.error("THREE.Line.computeLineDistances() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.");return this}raycast(t,e){let i=this.geometry,r=this.matrixWorld,s=t.params.Line.threshold,o=i.drawRange;if(i.boundingSphere===null&&i.computeBoundingSphere(),Ga.copy(i.boundingSphere),Ga.applyMatrix4(r),Ga.radius+=s,t.ray.intersectsSphere(Ga)===!1)return;Yg.copy(r).invert(),Lu.copy(t.ray).applyMatrix4(Yg);let a=s/((this.scale.x+this.scale.y+this.scale.z)/3),l=a*a,c=new T,u=new T,h=new T,f=new T,d=this.isLineSegments?2:1;if(i.isBufferGeometry){let g=i.index,v=i.attributes.position;if(g!==null){let m=Math.max(0,o.start),p=Math.min(g.count,o.start+o.count);for(let b=m,_=p-1;b<_;b+=d){let S=g.getX(b),L=g.getX(b+1);if(c.fromBufferAttribute(v,S),u.fromBufferAttribute(v,L),Lu.distanceSqToSegment(c,u,f,h)>l)continue;f.applyMatrix4(this.matrixWorld);let H=t.ray.origin.distanceTo(f);H<t.near||H>t.far||e.push({distance:H,point:h.clone().applyMatrix4(this.matrixWorld),index:b,face:null,faceIndex:null,object:this})}}else{let m=Math.max(0,o.start),p=Math.min(v.count,o.start+o.count);for(let b=m,_=p-1;b<_;b+=d){if(c.fromBufferAttribute(v,b),u.fromBufferAttribute(v,b+1),Lu.distanceSqToSegment(c,u,f,h)>l)continue;f.applyMatrix4(this.matrixWorld);let L=t.ray.origin.distanceTo(f);L<t.near||L>t.far||e.push({distance:L,point:h.clone().applyMatrix4(this.matrixWorld),index:b,face:null,faceIndex:null,object:this})}}}else i.isGeometry&&console.error("THREE.Line.raycast() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}updateMorphTargets(){let t=this.geometry;if(t.isBufferGeometry){let e=t.morphAttributes,i=Object.keys(e);if(i.length>0){let r=e[i[0]];if(r!==void 0){this.morphTargetInfluences=[],this.morphTargetDictionary={};for(let s=0,o=r.length;s<o;s++){let a=r[s].name||String(s);this.morphTargetInfluences.push(0),this.morphTargetDictionary[a]=s}}}}else{let e=t.morphTargets;e!==void 0&&e.length>0&&console.error("THREE.Line.updateMorphTargets() does not support THREE.Geometry. Use THREE.BufferGeometry instead.")}}};mo.prototype.isLine=!0;var Zg=new T,Jg=new T,go=class extends mo{constructor(t,e){super(t,e),this.type="LineSegments"}computeLineDistances(){let t=this.geometry;if(t.isBufferGeometry)if(t.index===null){let e=t.attributes.position,i=[];for(let r=0,s=e.count;r<s;r+=2)Zg.fromBufferAttribute(e,r),Jg.fromBufferAttribute(e,r+1),i[r]=r===0?0:i[r-1],i[r+1]=i[r]+Zg.distanceTo(Jg);t.setAttribute("lineDistance",new ee(i,1))}else console.warn("THREE.LineSegments.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.");else t.isGeometry&&console.error("THREE.LineSegments.computeLineDistances() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.");return this}};go.prototype.isLineSegments=!0;var th=class extends mo{constructor(t,e){super(t,e),this.type="LineLoop"}};th.prototype.isLineLoop=!0;var pl=class extends xe{constructor(t){super(),this.type="PointsMaterial",this.color=new ft(16777215),this.map=null,this.alphaMap=null,this.size=1,this.sizeAttenuation=!0,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.alphaMap=t.alphaMap,this.size=t.size,this.sizeAttenuation=t.sizeAttenuation,this}};pl.prototype.isPointsMaterial=!0;var $g=new wt,eh=new oi,Wa=new si,qa=new T,nh=class extends kt{constructor(t=new Ht,e=new pl){super(),this.type="Points",this.geometry=t,this.material=e,this.updateMorphTargets()}copy(t){return super.copy(t),this.material=t.material,this.geometry=t.geometry,this}raycast(t,e){let i=this.geometry,r=this.matrixWorld,s=t.params.Points.threshold,o=i.drawRange;if(i.boundingSphere===null&&i.computeBoundingSphere(),Wa.copy(i.boundingSphere),Wa.applyMatrix4(r),Wa.radius+=s,t.ray.intersectsSphere(Wa)===!1)return;$g.copy(r).invert(),eh.copy(t.ray).applyMatrix4($g);let a=s/((this.scale.x+this.scale.y+this.scale.z)/3),l=a*a;if(i.isBufferGeometry){let c=i.index,h=i.attributes.position;if(c!==null){let f=Math.max(0,o.start),d=Math.min(c.count,o.start+o.count);for(let g=f,x=d;g<x;g++){let v=c.getX(g);qa.fromBufferAttribute(h,v),Kg(qa,v,l,r,t,e,this)}}else{let f=Math.max(0,o.start),d=Math.min(h.count,o.start+o.count);for(let g=f,x=d;g<x;g++)qa.fromBufferAttribute(h,g),Kg(qa,g,l,r,t,e,this)}}else console.error("THREE.Points.raycast() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}updateMorphTargets(){let t=this.geometry;if(t.isBufferGeometry){let e=t.morphAttributes,i=Object.keys(e);if(i.length>0){let r=e[i[0]];if(r!==void 0){this.morphTargetInfluences=[],this.morphTargetDictionary={};for(let s=0,o=r.length;s<o;s++){let a=r[s].name||String(s);this.morphTargetInfluences.push(0),this.morphTargetDictionary[a]=s}}}}else{let e=t.morphTargets;e!==void 0&&e.length>0&&console.error("THREE.Points.updateMorphTargets() does not support THREE.Geometry. Use THREE.BufferGeometry instead.")}}};nh.prototype.isPoints=!0;function Kg(n,t,e,i,r,s,o){let a=eh.distanceSqToPoint(n);if(a<e){let l=new T;eh.closestPointToPoint(n,l),l.applyMatrix4(i);let c=r.ray.origin.distanceTo(l);if(c<r.near||c>r.far)return;s.push({distance:c,distanceToRay:Math.sqrt(a),point:l,index:t,face:null,object:o})}}var ih=class extends ae{constructor(t,e,i,r,s,o,a,l,c){super(t,e,i,r,s,o,a,l,c),this.minFilter=o!==void 0?o:be,this.magFilter=s!==void 0?s:be,this.generateMipmaps=!1;let u=this;function h(){u.needsUpdate=!0,t.requestVideoFrameCallback(h)}"requestVideoFrameCallback"in t&&t.requestVideoFrameCallback(h)}clone(){return new this.constructor(this.image).copy(this)}update(){let t=this.image;"requestVideoFrameCallback"in t===!1&&t.readyState>=t.HAVE_CURRENT_DATA&&(this.needsUpdate=!0)}};ih.prototype.isVideoTexture=!0;var rh=class extends ae{constructor(t,e,i){super({width:t,height:e}),this.format=i,this.magFilter=fe,this.minFilter=fe,this.generateMipmaps=!1,this.needsUpdate=!0}};rh.prototype.isFramebufferTexture=!0;var sh=class extends ae{constructor(t,e,i,r,s,o,a,l,c,u,h,f){super(null,o,a,l,c,u,r,s,h,f),this.image={width:e,height:i},this.mipmaps=t,this.flipY=!1,this.generateMipmaps=!1}};sh.prototype.isCompressedTexture=!0;var oh=class extends ae{constructor(t,e,i,r,s,o,a,l,c){super(t,e,i,r,s,o,a,l,c),this.needsUpdate=!0}};oh.prototype.isCanvasTexture=!0;var Zr=class extends Ht{constructor(t=1,e=8,i=0,r=Math.PI*2){super(),this.type="CircleGeometry",this.parameters={radius:t,segments:e,thetaStart:i,thetaLength:r},e=Math.max(3,e);let s=[],o=[],a=[],l=[],c=new T,u=new K;o.push(0,0,0),a.push(0,0,1),l.push(.5,.5);for(let h=0,f=3;h<=e;h++,f+=3){let d=i+h/e*r;c.x=t*Math.cos(d),c.y=t*Math.sin(d),o.push(c.x,c.y,c.z),a.push(0,0,1),u.x=(o[f]/t+1)/2,u.y=(o[f+1]/t+1)/2,l.push(u.x,u.y)}for(let h=1;h<=e;h++)s.push(h,h+1,0);this.setIndex(s),this.setAttribute("position",new ee(o,3)),this.setAttribute("normal",new ee(a,3)),this.setAttribute("uv",new ee(l,2))}static fromJSON(t){return new Zr(t.radius,t.segments,t.thetaStart,t.thetaLength)}};var Sk=new T,Ek=new T,Tk=new T,Ak=new re;var Fe=class{constructor(){this.type="Curve",this.arcLengthDivisions=200}getPoint(){return console.warn("THREE.Curve: .getPoint() not implemented."),null}getPointAt(t,e){let i=this.getUtoTmapping(t);return this.getPoint(i,e)}getPoints(t=5){let e=[];for(let i=0;i<=t;i++)e.push(this.getPoint(i/t));return e}getSpacedPoints(t=5){let e=[];for(let i=0;i<=t;i++)e.push(this.getPointAt(i/t));return e}getLength(){let t=this.getLengths();return t[t.length-1]}getLengths(t=this.arcLengthDivisions){if(this.cacheArcLengths&&this.cacheArcLengths.length===t+1&&!this.needsUpdate)return this.cacheArcLengths;this.needsUpdate=!1;let e=[],i,r=this.getPoint(0),s=0;e.push(0);for(let o=1;o<=t;o++)i=this.getPoint(o/t),s+=i.distanceTo(r),e.push(s),r=i;return this.cacheArcLengths=e,e}updateArcLengths(){this.needsUpdate=!0,this.getLengths()}getUtoTmapping(t,e){let i=this.getLengths(),r=0,s=i.length,o;e?o=e:o=t*i[s-1];let a=0,l=s-1,c;for(;a<=l;)if(r=Math.floor(a+(l-a)/2),c=i[r]-o,c<0)a=r+1;else if(c>0)l=r-1;else{l=r;break}if(r=l,i[r]===o)return r/(s-1);let u=i[r],f=i[r+1]-u,d=(o-u)/f;return(r+d)/(s-1)}getTangent(t,e){let r=t-1e-4,s=t+1e-4;r<0&&(r=0),s>1&&(s=1);let o=this.getPoint(r),a=this.getPoint(s),l=e||(o.isVector2?new K:new T);return l.copy(a).sub(o).normalize(),l}getTangentAt(t,e){let i=this.getUtoTmapping(t);return this.getTangent(i,e)}computeFrenetFrames(t,e){let i=new T,r=[],s=[],o=[],a=new T,l=new wt;for(let d=0;d<=t;d++){let g=d/t;r[d]=this.getTangentAt(g,new T)}s[0]=new T,o[0]=new T;let c=Number.MAX_VALUE,u=Math.abs(r[0].x),h=Math.abs(r[0].y),f=Math.abs(r[0].z);u<=c&&(c=u,i.set(1,0,0)),h<=c&&(c=h,i.set(0,1,0)),f<=c&&i.set(0,0,1),a.crossVectors(r[0],i).normalize(),s[0].crossVectors(r[0],a),o[0].crossVectors(r[0],s[0]);for(let d=1;d<=t;d++){if(s[d]=s[d-1].clone(),o[d]=o[d-1].clone(),a.crossVectors(r[d-1],r[d]),a.length()>Number.EPSILON){a.normalize();let g=Math.acos(Ie(r[d-1].dot(r[d]),-1,1));s[d].applyMatrix4(l.makeRotationAxis(a,g))}o[d].crossVectors(r[d],s[d])}if(e===!0){let d=Math.acos(Ie(s[0].dot(s[t]),-1,1));d/=t,r[0].dot(a.crossVectors(s[0],s[t]))>0&&(d=-d);for(let g=1;g<=t;g++)s[g].applyMatrix4(l.makeRotationAxis(r[g],d*g)),o[g].crossVectors(r[g],s[g])}return{tangents:r,normals:s,binormals:o}}clone(){return new this.constructor().copy(this)}copy(t){return this.arcLengthDivisions=t.arcLengthDivisions,this}toJSON(){let t={metadata:{version:4.5,type:"Curve",generator:"Curve.toJSON"}};return t.arcLengthDivisions=this.arcLengthDivisions,t.type=this.type,t}fromJSON(t){return this.arcLengthDivisions=t.arcLengthDivisions,this}},Jr=class extends Fe{constructor(t=0,e=0,i=1,r=1,s=0,o=Math.PI*2,a=!1,l=0){super(),this.type="EllipseCurve",this.aX=t,this.aY=e,this.xRadius=i,this.yRadius=r,this.aStartAngle=s,this.aEndAngle=o,this.aClockwise=a,this.aRotation=l}getPoint(t,e){let i=e||new K,r=Math.PI*2,s=this.aEndAngle-this.aStartAngle,o=Math.abs(s)<Number.EPSILON;for(;s<0;)s+=r;for(;s>r;)s-=r;s<Number.EPSILON&&(o?s=0:s=r),this.aClockwise===!0&&!o&&(s===r?s=-r:s=s-r);let a=this.aStartAngle+t*s,l=this.aX+this.xRadius*Math.cos(a),c=this.aY+this.yRadius*Math.sin(a);if(this.aRotation!==0){let u=Math.cos(this.aRotation),h=Math.sin(this.aRotation),f=l-this.aX,d=c-this.aY;l=f*u-d*h+this.aX,c=f*h+d*u+this.aY}return i.set(l,c)}copy(t){return super.copy(t),this.aX=t.aX,this.aY=t.aY,this.xRadius=t.xRadius,this.yRadius=t.yRadius,this.aStartAngle=t.aStartAngle,this.aEndAngle=t.aEndAngle,this.aClockwise=t.aClockwise,this.aRotation=t.aRotation,this}toJSON(){let t=super.toJSON();return t.aX=this.aX,t.aY=this.aY,t.xRadius=this.xRadius,t.yRadius=this.yRadius,t.aStartAngle=this.aStartAngle,t.aEndAngle=this.aEndAngle,t.aClockwise=this.aClockwise,t.aRotation=this.aRotation,t}fromJSON(t){return super.fromJSON(t),this.aX=t.aX,this.aY=t.aY,this.xRadius=t.xRadius,this.yRadius=t.yRadius,this.aStartAngle=t.aStartAngle,this.aEndAngle=t.aEndAngle,this.aClockwise=t.aClockwise,this.aRotation=t.aRotation,this}};Jr.prototype.isEllipseCurve=!0;var ml=class extends Jr{constructor(t,e,i,r,s,o){super(t,e,i,i,r,s,o),this.type="ArcCurve"}};ml.prototype.isArcCurve=!0;function tf(){let n=0,t=0,e=0,i=0;function r(s,o,a,l){n=s,t=a,e=-3*s+3*o-2*a-l,i=2*s-2*o+a+l}return{initCatmullRom:function(s,o,a,l,c){r(o,a,c*(a-s),c*(l-o))},initNonuniformCatmullRom:function(s,o,a,l,c,u,h){let f=(o-s)/c-(a-s)/(c+u)+(a-o)/u,d=(a-o)/u-(l-o)/(u+h)+(l-a)/h;f*=u,d*=u,r(o,a,f,d)},calc:function(s){let o=s*s,a=o*s;return n+t*s+e*o+i*a}}}var Xa=new T,Pu=new tf,Du=new tf,Iu=new tf,gl=class extends Fe{constructor(t=[],e=!1,i="centripetal",r=.5){super(),this.type="CatmullRomCurve3",this.points=t,this.closed=e,this.curveType=i,this.tension=r}getPoint(t,e=new T){let i=e,r=this.points,s=r.length,o=(s-(this.closed?0:1))*t,a=Math.floor(o),l=o-a;this.closed?a+=a>0?0:(Math.floor(Math.abs(a)/s)+1)*s:l===0&&a===s-1&&(a=s-2,l=1);let c,u;this.closed||a>0?c=r[(a-1)%s]:(Xa.subVectors(r[0],r[1]).add(r[0]),c=Xa);let h=r[a%s],f=r[(a+1)%s];if(this.closed||a+2<s?u=r[(a+2)%s]:(Xa.subVectors(r[s-1],r[s-2]).add(r[s-1]),u=Xa),this.curveType==="centripetal"||this.curveType==="chordal"){let d=this.curveType==="chordal"?.5:.25,g=Math.pow(c.distanceToSquared(h),d),x=Math.pow(h.distanceToSquared(f),d),v=Math.pow(f.distanceToSquared(u),d);x<1e-4&&(x=1),g<1e-4&&(g=x),v<1e-4&&(v=x),Pu.initNonuniformCatmullRom(c.x,h.x,f.x,u.x,g,x,v),Du.initNonuniformCatmullRom(c.y,h.y,f.y,u.y,g,x,v),Iu.initNonuniformCatmullRom(c.z,h.z,f.z,u.z,g,x,v)}else this.curveType==="catmullrom"&&(Pu.initCatmullRom(c.x,h.x,f.x,u.x,this.tension),Du.initCatmullRom(c.y,h.y,f.y,u.y,this.tension),Iu.initCatmullRom(c.z,h.z,f.z,u.z,this.tension));return i.set(Pu.calc(l),Du.calc(l),Iu.calc(l)),i}copy(t){super.copy(t),this.points=[];for(let e=0,i=t.points.length;e<i;e++){let r=t.points[e];this.points.push(r.clone())}return this.closed=t.closed,this.curveType=t.curveType,this.tension=t.tension,this}toJSON(){let t=super.toJSON();t.points=[];for(let e=0,i=this.points.length;e<i;e++){let r=this.points[e];t.points.push(r.toArray())}return t.closed=this.closed,t.curveType=this.curveType,t.tension=this.tension,t}fromJSON(t){super.fromJSON(t),this.points=[];for(let e=0,i=t.points.length;e<i;e++){let r=t.points[e];this.points.push(new T().fromArray(r))}return this.closed=t.closed,this.curveType=t.curveType,this.tension=t.tension,this}};gl.prototype.isCatmullRomCurve3=!0;function Qg(n,t,e,i,r){let s=(i-t)*.5,o=(r-e)*.5,a=n*n,l=n*a;return(2*e-2*i+s+o)*l+(-3*e+3*i-2*s-o)*a+s*n+e}function FE(n,t){let e=1-n;return e*e*t}function zE(n,t){return 2*(1-n)*n*t}function UE(n,t){return n*n*t}function js(n,t,e,i){return FE(n,t)+zE(n,e)+UE(n,i)}function BE(n,t){let e=1-n;return e*e*e*t}function OE(n,t){let e=1-n;return 3*e*e*n*t}function kE(n,t){return 3*(1-n)*n*n*t}function HE(n,t){return n*n*n*t}function to(n,t,e,i,r){return BE(n,t)+OE(n,e)+kE(n,i)+HE(n,r)}var xo=class extends Fe{constructor(t=new K,e=new K,i=new K,r=new K){super(),this.type="CubicBezierCurve",this.v0=t,this.v1=e,this.v2=i,this.v3=r}getPoint(t,e=new K){let i=e,r=this.v0,s=this.v1,o=this.v2,a=this.v3;return i.set(to(t,r.x,s.x,o.x,a.x),to(t,r.y,s.y,o.y,a.y)),i}copy(t){return super.copy(t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this.v3.copy(t.v3),this}toJSON(){let t=super.toJSON();return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t.v3=this.v3.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this.v3.fromArray(t.v3),this}};xo.prototype.isCubicBezierCurve=!0;var xl=class extends Fe{constructor(t=new T,e=new T,i=new T,r=new T){super(),this.type="CubicBezierCurve3",this.v0=t,this.v1=e,this.v2=i,this.v3=r}getPoint(t,e=new T){let i=e,r=this.v0,s=this.v1,o=this.v2,a=this.v3;return i.set(to(t,r.x,s.x,o.x,a.x),to(t,r.y,s.y,o.y,a.y),to(t,r.z,s.z,o.z,a.z)),i}copy(t){return super.copy(t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this.v3.copy(t.v3),this}toJSON(){let t=super.toJSON();return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t.v3=this.v3.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this.v3.fromArray(t.v3),this}};xl.prototype.isCubicBezierCurve3=!0;var $r=class extends Fe{constructor(t=new K,e=new K){super(),this.type="LineCurve",this.v1=t,this.v2=e}getPoint(t,e=new K){let i=e;return t===1?i.copy(this.v2):(i.copy(this.v2).sub(this.v1),i.multiplyScalar(t).add(this.v1)),i}getPointAt(t,e){return this.getPoint(t,e)}getTangent(t,e){let i=e||new K;return i.copy(this.v2).sub(this.v1).normalize(),i}copy(t){return super.copy(t),this.v1.copy(t.v1),this.v2.copy(t.v2),this}toJSON(){let t=super.toJSON();return t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this}};$r.prototype.isLineCurve=!0;var ah=class extends Fe{constructor(t=new T,e=new T){super(),this.type="LineCurve3",this.isLineCurve3=!0,this.v1=t,this.v2=e}getPoint(t,e=new T){let i=e;return t===1?i.copy(this.v2):(i.copy(this.v2).sub(this.v1),i.multiplyScalar(t).add(this.v1)),i}getPointAt(t,e){return this.getPoint(t,e)}copy(t){return super.copy(t),this.v1.copy(t.v1),this.v2.copy(t.v2),this}toJSON(){let t=super.toJSON();return t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this}},yo=class extends Fe{constructor(t=new K,e=new K,i=new K){super(),this.type="QuadraticBezierCurve",this.v0=t,this.v1=e,this.v2=i}getPoint(t,e=new K){let i=e,r=this.v0,s=this.v1,o=this.v2;return i.set(js(t,r.x,s.x,o.x),js(t,r.y,s.y,o.y)),i}copy(t){return super.copy(t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this}toJSON(){let t=super.toJSON();return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this}};yo.prototype.isQuadraticBezierCurve=!0;var yl=class extends Fe{constructor(t=new T,e=new T,i=new T){super(),this.type="QuadraticBezierCurve3",this.v0=t,this.v1=e,this.v2=i}getPoint(t,e=new T){let i=e,r=this.v0,s=this.v1,o=this.v2;return i.set(js(t,r.x,s.x,o.x),js(t,r.y,s.y,o.y),js(t,r.z,s.z,o.z)),i}copy(t){return super.copy(t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this}toJSON(){let t=super.toJSON();return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this}};yl.prototype.isQuadraticBezierCurve3=!0;var vo=class extends Fe{constructor(t=[]){super(),this.type="SplineCurve",this.points=t}getPoint(t,e=new K){let i=e,r=this.points,s=(r.length-1)*t,o=Math.floor(s),a=s-o,l=r[o===0?o:o-1],c=r[o],u=r[o>r.length-2?r.length-1:o+1],h=r[o>r.length-3?r.length-1:o+2];return i.set(Qg(a,l.x,c.x,u.x,h.x),Qg(a,l.y,c.y,u.y,h.y)),i}copy(t){super.copy(t),this.points=[];for(let e=0,i=t.points.length;e<i;e++){let r=t.points[e];this.points.push(r.clone())}return this}toJSON(){let t=super.toJSON();t.points=[];for(let e=0,i=this.points.length;e<i;e++){let r=this.points[e];t.points.push(r.toArray())}return t}fromJSON(t){super.fromJSON(t),this.points=[];for(let e=0,i=t.points.length;e<i;e++){let r=t.points[e];this.points.push(new K().fromArray(r))}return this}};vo.prototype.isSplineCurve=!0;var C0=Object.freeze({__proto__:null,ArcCurve:ml,CatmullRomCurve3:gl,CubicBezierCurve:xo,CubicBezierCurve3:xl,EllipseCurve:Jr,LineCurve:$r,LineCurve3:ah,QuadraticBezierCurve:yo,QuadraticBezierCurve3:yl,SplineCurve:vo}),lh=class extends Fe{constructor(){super(),this.type="CurvePath",this.curves=[],this.autoClose=!1}add(t){this.curves.push(t)}closePath(){let t=this.curves[0].getPoint(0),e=this.curves[this.curves.length-1].getPoint(1);t.equals(e)||this.curves.push(new $r(e,t))}getPoint(t,e){let i=t*this.getLength(),r=this.getCurveLengths(),s=0;for(;s<r.length;){if(r[s]>=i){let o=r[s]-i,a=this.curves[s],l=a.getLength(),c=l===0?0:1-o/l;return a.getPointAt(c,e)}s++}return null}getLength(){let t=this.getCurveLengths();return t[t.length-1]}updateArcLengths(){this.needsUpdate=!0,this.cacheLengths=null,this.getCurveLengths()}getCurveLengths(){if(this.cacheLengths&&this.cacheLengths.length===this.curves.length)return this.cacheLengths;let t=[],e=0;for(let i=0,r=this.curves.length;i<r;i++)e+=this.curves[i].getLength(),t.push(e);return this.cacheLengths=t,t}getSpacedPoints(t=40){let e=[];for(let i=0;i<=t;i++)e.push(this.getPoint(i/t));return this.autoClose&&e.push(e[0]),e}getPoints(t=12){let e=[],i;for(let r=0,s=this.curves;r<s.length;r++){let o=s[r],a=o&&o.isEllipseCurve?t*2:o&&(o.isLineCurve||o.isLineCurve3)?1:o&&o.isSplineCurve?t*o.points.length:t,l=o.getPoints(a);for(let c=0;c<l.length;c++){let u=l[c];i&&i.equals(u)||(e.push(u),i=u)}}return this.autoClose&&e.length>1&&!e[e.length-1].equals(e[0])&&e.push(e[0]),e}copy(t){super.copy(t),this.curves=[];for(let e=0,i=t.curves.length;e<i;e++){let r=t.curves[e];this.curves.push(r.clone())}return this.autoClose=t.autoClose,this}toJSON(){let t=super.toJSON();t.autoClose=this.autoClose,t.curves=[];for(let e=0,i=this.curves.length;e<i;e++){let r=this.curves[e];t.curves.push(r.toJSON())}return t}fromJSON(t){super.fromJSON(t),this.autoClose=t.autoClose,this.curves=[];for(let e=0,i=t.curves.length;e<i;e++){let r=t.curves[e];this.curves.push(new C0[r.type]().fromJSON(r))}return this}},_o=class extends lh{constructor(t){super(),this.type="Path",this.currentPoint=new K,t&&this.setFromPoints(t)}setFromPoints(t){this.moveTo(t[0].x,t[0].y);for(let e=1,i=t.length;e<i;e++)this.lineTo(t[e].x,t[e].y);return this}moveTo(t,e){return this.currentPoint.set(t,e),this}lineTo(t,e){let i=new $r(this.currentPoint.clone(),new K(t,e));return this.curves.push(i),this.currentPoint.set(t,e),this}quadraticCurveTo(t,e,i,r){let s=new yo(this.currentPoint.clone(),new K(t,e),new K(i,r));return this.curves.push(s),this.currentPoint.set(i,r),this}bezierCurveTo(t,e,i,r,s,o){let a=new xo(this.currentPoint.clone(),new K(t,e),new K(i,r),new K(s,o));return this.curves.push(a),this.currentPoint.set(s,o),this}splineThru(t){let e=[this.currentPoint.clone()].concat(t),i=new vo(e);return this.curves.push(i),this.currentPoint.copy(t[t.length-1]),this}arc(t,e,i,r,s,o){let a=this.currentPoint.x,l=this.currentPoint.y;return this.absarc(t+a,e+l,i,r,s,o),this}absarc(t,e,i,r,s,o){return this.absellipse(t,e,i,i,r,s,o),this}ellipse(t,e,i,r,s,o,a,l){let c=this.currentPoint.x,u=this.currentPoint.y;return this.absellipse(t+c,e+u,i,r,s,o,a,l),this}absellipse(t,e,i,r,s,o,a,l){let c=new Jr(t,e,i,r,s,o,a,l);if(this.curves.length>0){let h=c.getPoint(0);h.equals(this.currentPoint)||this.lineTo(h.x,h.y)}this.curves.push(c);let u=c.getPoint(1);return this.currentPoint.copy(u),this}copy(t){return super.copy(t),this.currentPoint.copy(t.currentPoint),this}toJSON(){let t=super.toJSON();return t.currentPoint=this.currentPoint.toArray(),t}fromJSON(t){return super.fromJSON(t),this.currentPoint.fromArray(t.currentPoint),this}},Un=class extends _o{constructor(t){super(t),this.uuid=tn(),this.type="Shape",this.holes=[]}getPointsHoles(t){let e=[];for(let i=0,r=this.holes.length;i<r;i++)e[i]=this.holes[i].getPoints(t);return e}extractPoints(t){return{shape:this.getPoints(t),holes:this.getPointsHoles(t)}}copy(t){super.copy(t),this.holes=[];for(let e=0,i=t.holes.length;e<i;e++){let r=t.holes[e];this.holes.push(r.clone())}return this}toJSON(){let t=super.toJSON();t.uuid=this.uuid,t.holes=[];for(let e=0,i=this.holes.length;e<i;e++){let r=this.holes[e];t.holes.push(r.toJSON())}return t}fromJSON(t){super.fromJSON(t),this.uuid=t.uuid,this.holes=[];for(let e=0,i=t.holes.length;e<i;e++){let r=t.holes[e];this.holes.push(new _o().fromJSON(r))}return this}},VE={triangulate:function(n,t,e=2){let i=t&&t.length,r=i?t[0]*e:n.length,s=R0(n,0,r,e,!0),o=[];if(!s||s.next===s.prev)return o;let a,l,c,u,h,f,d;if(i&&(s=YE(n,t,s,e)),n.length>80*e){a=c=n[0],l=u=n[1];for(let g=e;g<r;g+=e)h=n[g],f=n[g+1],h<a&&(a=h),f<l&&(l=f),h>c&&(c=h),f>u&&(u=f);d=Math.max(c-a,u-l),d=d!==0?1/d:0}return wo(s,o,e,a,l,d),o}};function R0(n,t,e,i,r){let s,o;if(r===rT(n,t,e,i)>0)for(s=t;s<e;s+=i)o=jg(s,n[s],n[s+1],o);else for(s=e-i;s>=t;s-=i)o=jg(s,n[s],n[s+1],o);return o&&Dl(o,o.next)&&(bo(o),o=o.next),o}function li(n,t){if(!n)return n;t||(t=n);let e=n,i;do if(i=!1,!e.steiner&&(Dl(e,e.next)||te(e.prev,e,e.next)===0)){if(bo(e),e=t=e.prev,e===e.next)break;i=!0}else e=e.next;while(i||e!==t);return t}function wo(n,t,e,i,r,s,o){if(!n)return;!o&&s&&QE(n,i,r,s);let a=n,l,c;for(;n.prev!==n.next;){if(l=n.prev,c=n.next,s?WE(n,i,r,s):GE(n)){t.push(l.i/e),t.push(n.i/e),t.push(c.i/e),bo(n),n=c.next,a=c.next;continue}if(n=c,n===a){o?o===1?(n=qE(li(n),t,e),wo(n,t,e,i,r,s,2)):o===2&&XE(n,t,e,i,r,s):wo(li(n),t,e,i,r,s,1);break}}}function GE(n){let t=n.prev,e=n,i=n.next;if(te(t,e,i)>=0)return!1;let r=n.next.next;for(;r!==n.prev;){if(zr(t.x,t.y,e.x,e.y,i.x,i.y,r.x,r.y)&&te(r.prev,r,r.next)>=0)return!1;r=r.next}return!0}function WE(n,t,e,i){let r=n.prev,s=n,o=n.next;if(te(r,s,o)>=0)return!1;let a=r.x<s.x?r.x<o.x?r.x:o.x:s.x<o.x?s.x:o.x,l=r.y<s.y?r.y<o.y?r.y:o.y:s.y<o.y?s.y:o.y,c=r.x>s.x?r.x>o.x?r.x:o.x:s.x>o.x?s.x:o.x,u=r.y>s.y?r.y>o.y?r.y:o.y:s.y>o.y?s.y:o.y,h=ch(a,l,t,e,i),f=ch(c,u,t,e,i),d=n.prevZ,g=n.nextZ;for(;d&&d.z>=h&&g&&g.z<=f;){if(d!==n.prev&&d!==n.next&&zr(r.x,r.y,s.x,s.y,o.x,o.y,d.x,d.y)&&te(d.prev,d,d.next)>=0||(d=d.prevZ,g!==n.prev&&g!==n.next&&zr(r.x,r.y,s.x,s.y,o.x,o.y,g.x,g.y)&&te(g.prev,g,g.next)>=0))return!1;g=g.nextZ}for(;d&&d.z>=h;){if(d!==n.prev&&d!==n.next&&zr(r.x,r.y,s.x,s.y,o.x,o.y,d.x,d.y)&&te(d.prev,d,d.next)>=0)return!1;d=d.prevZ}for(;g&&g.z<=f;){if(g!==n.prev&&g!==n.next&&zr(r.x,r.y,s.x,s.y,o.x,o.y,g.x,g.y)&&te(g.prev,g,g.next)>=0)return!1;g=g.nextZ}return!0}function qE(n,t,e){let i=n;do{let r=i.prev,s=i.next.next;!Dl(r,s)&&L0(r,i,i.next,s)&&Mo(r,s)&&Mo(s,r)&&(t.push(r.i/e),t.push(i.i/e),t.push(s.i/e),bo(i),bo(i.next),i=n=s),i=i.next}while(i!==n);return li(i)}function XE(n,t,e,i,r,s){let o=n;do{let a=o.next.next;for(;a!==o.prev;){if(o.i!==a.i&&eT(o,a)){let l=P0(o,a);o=li(o,o.next),l=li(l,l.next),wo(o,t,e,i,r,s),wo(l,t,e,i,r,s);return}a=a.next}o=o.next}while(o!==n)}function YE(n,t,e,i){let r=[],s,o,a,l,c;for(s=0,o=t.length;s<o;s++)a=t[s]*i,l=s<o-1?t[s+1]*i:n.length,c=R0(n,a,l,i,!1),c===c.next&&(c.steiner=!0),r.push(tT(c));for(r.sort(ZE),s=0;s<r.length;s++)JE(r[s],e),e=li(e,e.next);return e}function ZE(n,t){return n.x-t.x}function JE(n,t){if(t=$E(n,t),t){let e=P0(t,n);li(t,t.next),li(e,e.next)}}function $E(n,t){let e=t,i=n.x,r=n.y,s=-1/0,o;do{if(r<=e.y&&r>=e.next.y&&e.next.y!==e.y){let f=e.x+(r-e.y)*(e.next.x-e.x)/(e.next.y-e.y);if(f<=i&&f>s){if(s=f,f===i){if(r===e.y)return e;if(r===e.next.y)return e.next}o=e.x<e.next.x?e:e.next}}e=e.next}while(e!==t);if(!o)return null;if(i===s)return o;let a=o,l=o.x,c=o.y,u=1/0,h;e=o;do i>=e.x&&e.x>=l&&i!==e.x&&zr(r<c?i:s,r,l,c,r<c?s:i,r,e.x,e.y)&&(h=Math.abs(r-e.y)/(i-e.x),Mo(e,n)&&(h<u||h===u&&(e.x>o.x||e.x===o.x&&KE(o,e)))&&(o=e,u=h)),e=e.next;while(e!==a);return o}function KE(n,t){return te(n.prev,n,t.prev)<0&&te(t.next,n,n.next)<0}function QE(n,t,e,i){let r=n;do r.z===null&&(r.z=ch(r.x,r.y,t,e,i)),r.prevZ=r.prev,r.nextZ=r.next,r=r.next;while(r!==n);r.prevZ.nextZ=null,r.prevZ=null,jE(r)}function jE(n){let t,e,i,r,s,o,a,l,c=1;do{for(e=n,n=null,s=null,o=0;e;){for(o++,i=e,a=0,t=0;t<c&&(a++,i=i.nextZ,!!i);t++);for(l=c;a>0||l>0&&i;)a!==0&&(l===0||!i||e.z<=i.z)?(r=e,e=e.nextZ,a--):(r=i,i=i.nextZ,l--),s?s.nextZ=r:n=r,r.prevZ=s,s=r;e=i}s.nextZ=null,c*=2}while(o>1);return n}function ch(n,t,e,i,r){return n=32767*(n-e)*r,t=32767*(t-i)*r,n=(n|n<<8)&16711935,n=(n|n<<4)&252645135,n=(n|n<<2)&858993459,n=(n|n<<1)&1431655765,t=(t|t<<8)&16711935,t=(t|t<<4)&252645135,t=(t|t<<2)&858993459,t=(t|t<<1)&1431655765,n|t<<1}function tT(n){let t=n,e=n;do(t.x<e.x||t.x===e.x&&t.y<e.y)&&(e=t),t=t.next;while(t!==n);return e}function zr(n,t,e,i,r,s,o,a){return(r-o)*(t-a)-(n-o)*(s-a)>=0&&(n-o)*(i-a)-(e-o)*(t-a)>=0&&(e-o)*(s-a)-(r-o)*(i-a)>=0}function eT(n,t){return n.next.i!==t.i&&n.prev.i!==t.i&&!nT(n,t)&&(Mo(n,t)&&Mo(t,n)&&iT(n,t)&&(te(n.prev,n,t.prev)||te(n,t.prev,t))||Dl(n,t)&&te(n.prev,n,n.next)>0&&te(t.prev,t,t.next)>0)}function te(n,t,e){return(t.y-n.y)*(e.x-t.x)-(t.x-n.x)*(e.y-t.y)}function Dl(n,t){return n.x===t.x&&n.y===t.y}function L0(n,t,e,i){let r=Za(te(n,t,e)),s=Za(te(n,t,i)),o=Za(te(e,i,n)),a=Za(te(e,i,t));return!!(r!==s&&o!==a||r===0&&Ya(n,e,t)||s===0&&Ya(n,i,t)||o===0&&Ya(e,n,i)||a===0&&Ya(e,t,i))}function Ya(n,t,e){return t.x<=Math.max(n.x,e.x)&&t.x>=Math.min(n.x,e.x)&&t.y<=Math.max(n.y,e.y)&&t.y>=Math.min(n.y,e.y)}function Za(n){return n>0?1:n<0?-1:0}function nT(n,t){let e=n;do{if(e.i!==n.i&&e.next.i!==n.i&&e.i!==t.i&&e.next.i!==t.i&&L0(e,e.next,n,t))return!0;e=e.next}while(e!==n);return!1}function Mo(n,t){return te(n.prev,n,n.next)<0?te(n,t,n.next)>=0&&te(n,n.prev,t)>=0:te(n,t,n.prev)<0||te(n,n.next,t)<0}function iT(n,t){let e=n,i=!1,r=(n.x+t.x)/2,s=(n.y+t.y)/2;do e.y>s!=e.next.y>s&&e.next.y!==e.y&&r<(e.next.x-e.x)*(s-e.y)/(e.next.y-e.y)+e.x&&(i=!i),e=e.next;while(e!==n);return i}function P0(n,t){let e=new uh(n.i,n.x,n.y),i=new uh(t.i,t.x,t.y),r=n.next,s=t.prev;return n.next=t,t.prev=n,e.next=r,r.prev=e,i.next=e,e.prev=i,s.next=i,i.prev=s,i}function jg(n,t,e,i){let r=new uh(n,t,e);return i?(r.next=i.next,r.prev=i,i.next.prev=r,i.next=r):(r.prev=r,r.next=r),r}function bo(n){n.next.prev=n.prev,n.prev.next=n.next,n.prevZ&&(n.prevZ.nextZ=n.nextZ),n.nextZ&&(n.nextZ.prevZ=n.prevZ)}function uh(n,t,e){this.i=n,this.x=t,this.y=e,this.prev=null,this.next=null,this.z=null,this.prevZ=null,this.nextZ=null,this.steiner=!1}function rT(n,t,e,i){let r=0;for(let s=t,o=e-i;s<e;s+=i)r+=(n[o]-n[s])*(n[s+1]+n[o+1]),o=s;return r}var dn=class{static area(t){let e=t.length,i=0;for(let r=e-1,s=0;s<e;r=s++)i+=t[r].x*t[s].y-t[s].x*t[r].y;return i*.5}static isClockWise(t){return dn.area(t)<0}static triangulateShape(t,e){let i=[],r=[],s=[];t0(t),e0(i,t);let o=t.length;e.forEach(t0);for(let l=0;l<e.length;l++)r.push(o),o+=e[l].length,e0(i,e[l]);let a=VE.triangulate(i,r);for(let l=0;l<a.length;l+=3)s.push(a.slice(l,l+3));return s}};function t0(n){let t=n.length;t>2&&n[t-1].equals(n[0])&&n.pop()}function e0(n,t){for(let e=0;e<t.length;e++)n.push(t[e].x),n.push(t[e].y)}var ci=class extends Ht{constructor(t=new Un([new K(.5,.5),new K(-.5,.5),new K(-.5,-.5),new K(.5,-.5)]),e={}){super(),this.type="ExtrudeGeometry",this.parameters={shapes:t,options:e},t=Array.isArray(t)?t:[t];let i=this,r=[],s=[];for(let a=0,l=t.length;a<l;a++){let c=t[a];o(c)}this.setAttribute("position",new ee(r,3)),this.setAttribute("uv",new ee(s,2)),this.computeVertexNormals();function o(a){let l=[],c=e.curveSegments!==void 0?e.curveSegments:12,u=e.steps!==void 0?e.steps:1,h=e.depth!==void 0?e.depth:1,f=e.bevelEnabled!==void 0?e.bevelEnabled:!0,d=e.bevelThickness!==void 0?e.bevelThickness:.2,g=e.bevelSize!==void 0?e.bevelSize:d-.1,x=e.bevelOffset!==void 0?e.bevelOffset:0,v=e.bevelSegments!==void 0?e.bevelSegments:3,m=e.extrudePath,p=e.UVGenerator!==void 0?e.UVGenerator:sT;e.amount!==void 0&&(console.warn("THREE.ExtrudeBufferGeometry: amount has been renamed to depth."),h=e.amount);let b,_=!1,S,L,A,H;m&&(b=m.getSpacedPoints(u),_=!0,f=!1,S=m.computeFrenetFrames(u,!1),L=new T,A=new T,H=new T),f||(v=0,d=0,g=0,x=0);let tt=a.extractPoints(c),X=tt.shape,y=tt.holes;if(!dn.isClockWise(X)){X=X.reverse();for(let C=0,j=y.length;C<j;C++){let J=y[C];dn.isClockWise(J)&&(y[C]=J.reverse())}}let D=dn.triangulateShape(X,y),F=X;for(let C=0,j=y.length;C<j;C++){let J=y[C];X=X.concat(J)}function z(C,j,J){return j||console.error("THREE.ExtrudeGeometry: vec does not exist"),j.clone().multiplyScalar(J).add(C)}let N=X.length,V=D.length;function Q(C,j,J){let it,et,vt,bt=C.x-j.x,It=C.y-j.y,Zt=J.x-C.x,qt=J.y-C.y,E=bt*bt+It*It,w=bt*qt-It*Zt;if(Math.abs(w)>Number.EPSILON){let q=Math.sqrt(E),rt=Math.sqrt(Zt*Zt+qt*qt),gt=j.x-It/q,W=j.y+bt/q,_t=J.x-qt/rt,yt=J.y+Zt/rt,ut=((_t-gt)*qt-(yt-W)*Zt)/(bt*qt-It*Zt);it=gt+bt*ut-C.x,et=W+It*ut-C.y;let ct=it*it+et*et;if(ct<=2)return new K(it,et);vt=Math.sqrt(ct/2)}else{let q=!1;bt>Number.EPSILON?Zt>Number.EPSILON&&(q=!0):bt<-Number.EPSILON?Zt<-Number.EPSILON&&(q=!0):Math.sign(It)===Math.sign(qt)&&(q=!0),q?(it=-It,et=bt,vt=Math.sqrt(E)):(it=bt,et=It,vt=Math.sqrt(E/2))}return new K(it/vt,et/vt)}let at=[];for(let C=0,j=F.length,J=j-1,it=C+1;C<j;C++,J++,it++)J===j&&(J=0),it===j&&(it=0),at[C]=Q(F[C],F[J],F[it]);let G=[],$,lt=at.concat();for(let C=0,j=y.length;C<j;C++){let J=y[C];$=[];for(let it=0,et=J.length,vt=et-1,bt=it+1;it<et;it++,vt++,bt++)vt===et&&(vt=0),bt===et&&(bt=0),$[it]=Q(J[it],J[vt],J[bt]);G.push($),lt=lt.concat($)}for(let C=0;C<v;C++){let j=C/v,J=d*Math.cos(j*Math.PI/2),it=g*Math.sin(j*Math.PI/2)+x;for(let et=0,vt=F.length;et<vt;et++){let bt=z(F[et],at[et],it);mt(bt.x,bt.y,-J)}for(let et=0,vt=y.length;et<vt;et++){let bt=y[et];$=G[et];for(let It=0,Zt=bt.length;It<Zt;It++){let qt=z(bt[It],$[It],it);mt(qt.x,qt.y,-J)}}}let dt=g+x;for(let C=0;C<N;C++){let j=f?z(X[C],lt[C],dt):X[C];_?(A.copy(S.normals[0]).multiplyScalar(j.x),L.copy(S.binormals[0]).multiplyScalar(j.y),H.copy(b[0]).add(A).add(L),mt(H.x,H.y,H.z)):mt(j.x,j.y,0)}for(let C=1;C<=u;C++)for(let j=0;j<N;j++){let J=f?z(X[j],lt[j],dt):X[j];_?(A.copy(S.normals[C]).multiplyScalar(J.x),L.copy(S.binormals[C]).multiplyScalar(J.y),H.copy(b[C]).add(A).add(L),mt(H.x,H.y,H.z)):mt(J.x,J.y,h/u*C)}for(let C=v-1;C>=0;C--){let j=C/v,J=d*Math.cos(j*Math.PI/2),it=g*Math.sin(j*Math.PI/2)+x;for(let et=0,vt=F.length;et<vt;et++){let bt=z(F[et],at[et],it);mt(bt.x,bt.y,h+J)}for(let et=0,vt=y.length;et<vt;et++){let bt=y[et];$=G[et];for(let It=0,Zt=bt.length;It<Zt;It++){let qt=z(bt[It],$[It],it);_?mt(qt.x,qt.y+b[u-1].y,b[u-1].x+J):mt(qt.x,qt.y,h+J)}}}xt(),k();function xt(){let C=r.length/3;if(f){let j=0,J=N*j;for(let it=0;it<V;it++){let et=D[it];St(et[2]+J,et[1]+J,et[0]+J)}j=u+v*2,J=N*j;for(let it=0;it<V;it++){let et=D[it];St(et[0]+J,et[1]+J,et[2]+J)}}else{for(let j=0;j<V;j++){let J=D[j];St(J[2],J[1],J[0])}for(let j=0;j<V;j++){let J=D[j];St(J[0]+N*u,J[1]+N*u,J[2]+N*u)}}i.addGroup(C,r.length/3-C,0)}function k(){let C=r.length/3,j=0;Ft(F,j),j+=F.length;for(let J=0,it=y.length;J<it;J++){let et=y[J];Ft(et,j),j+=et.length}i.addGroup(C,r.length/3-C,1)}function Ft(C,j){let J=C.length;for(;--J>=0;){let it=J,et=J-1;et<0&&(et=C.length-1);for(let vt=0,bt=u+v*2;vt<bt;vt++){let It=N*vt,Zt=N*(vt+1),qt=j+it+It,E=j+et+It,w=j+et+Zt,q=j+it+Zt;B(qt,E,w,q)}}}function mt(C,j,J){l.push(C),l.push(j),l.push(J)}function St(C,j,J){st(C),st(j),st(J);let it=r.length/3,et=p.generateTopUV(i,r,it-3,it-2,it-1);nt(et[0]),nt(et[1]),nt(et[2])}function B(C,j,J,it){st(C),st(j),st(it),st(j),st(J),st(it);let et=r.length/3,vt=p.generateSideWallUV(i,r,et-6,et-3,et-2,et-1);nt(vt[0]),nt(vt[1]),nt(vt[3]),nt(vt[1]),nt(vt[2]),nt(vt[3])}function st(C){r.push(l[C*3+0]),r.push(l[C*3+1]),r.push(l[C*3+2])}function nt(C){s.push(C.x),s.push(C.y)}}}toJSON(){let t=super.toJSON(),e=this.parameters.shapes,i=this.parameters.options;return oT(e,i,t)}static fromJSON(t,e){let i=[];for(let s=0,o=t.shapes.length;s<o;s++){let a=e[t.shapes[s]];i.push(a)}let r=t.options.extrudePath;return r!==void 0&&(t.options.extrudePath=new C0[r.type]().fromJSON(r)),new ci(i,t.options)}},sT={generateTopUV:function(n,t,e,i,r){let s=t[e*3],o=t[e*3+1],a=t[i*3],l=t[i*3+1],c=t[r*3],u=t[r*3+1];return[new K(s,o),new K(a,l),new K(c,u)]},generateSideWallUV:function(n,t,e,i,r,s){let o=t[e*3],a=t[e*3+1],l=t[e*3+2],c=t[i*3],u=t[i*3+1],h=t[i*3+2],f=t[r*3],d=t[r*3+1],g=t[r*3+2],x=t[s*3],v=t[s*3+1],m=t[s*3+2];return Math.abs(a-u)<Math.abs(o-c)?[new K(o,1-l),new K(c,1-h),new K(f,1-g),new K(x,1-m)]:[new K(a,1-l),new K(u,1-h),new K(d,1-g),new K(v,1-m)]}};function oT(n,t,e){if(e.shapes=[],Array.isArray(n))for(let i=0,r=n.length;i<r;i++){let s=n[i];e.shapes.push(s.uuid)}else e.shapes.push(n.uuid);return t.extrudePath!==void 0&&(e.options.extrudePath=t.extrudePath.toJSON()),e}var qi=class extends Ht{constructor(t=new Un([new K(0,.5),new K(-.5,-.5),new K(.5,-.5)]),e=12){super(),this.type="ShapeGeometry",this.parameters={shapes:t,curveSegments:e};let i=[],r=[],s=[],o=[],a=0,l=0;if(Array.isArray(t)===!1)c(t);else for(let u=0;u<t.length;u++)c(t[u]),this.addGroup(a,l,u),a+=l,l=0;this.setIndex(i),this.setAttribute("position",new ee(r,3)),this.setAttribute("normal",new ee(s,3)),this.setAttribute("uv",new ee(o,2));function c(u){let h=r.length/3,f=u.extractPoints(e),d=f.shape,g=f.holes;dn.isClockWise(d)===!1&&(d=d.reverse());for(let v=0,m=g.length;v<m;v++){let p=g[v];dn.isClockWise(p)===!0&&(g[v]=p.reverse())}let x=dn.triangulateShape(d,g);for(let v=0,m=g.length;v<m;v++){let p=g[v];d=d.concat(p)}for(let v=0,m=d.length;v<m;v++){let p=d[v];r.push(p.x,p.y,0),s.push(0,0,1),o.push(p.x,p.y)}for(let v=0,m=x.length;v<m;v++){let p=x[v],b=p[0]+h,_=p[1]+h,S=p[2]+h;i.push(b,_,S),l+=3}}}toJSON(){let t=super.toJSON(),e=this.parameters.shapes;return aT(e,t)}static fromJSON(t,e){let i=[];for(let r=0,s=t.shapes.length;r<s;r++){let o=e[t.shapes[r]];i.push(o)}return new qi(i,t.curveSegments)}};function aT(n,t){if(t.shapes=[],Array.isArray(n))for(let e=0,i=n.length;e<i;e++){let r=n[e];t.shapes.push(r.uuid)}else t.shapes.push(n.uuid);return t}var hh=class extends xe{constructor(t){super(),this.type="ShadowMaterial",this.color=new ft(0),this.transparent=!0,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this}};hh.prototype.isShadowMaterial=!0;var vl=class extends xe{constructor(t){super(),this.defines={STANDARD:""},this.type="MeshStandardMaterial",this.color=new ft(16777215),this.roughness=1,this.metalness=0,this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new ft(0),this.emissiveIntensity=1,this.emissiveMap=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=ts,this.normalScale=new K(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.roughnessMap=null,this.metalnessMap=null,this.alphaMap=null,this.envMap=null,this.envMapIntensity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.flatShading=!1,this.setValues(t)}copy(t){return super.copy(t),this.defines={STANDARD:""},this.color.copy(t.color),this.roughness=t.roughness,this.metalness=t.metalness,this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.roughnessMap=t.roughnessMap,this.metalnessMap=t.metalnessMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.envMapIntensity=t.envMapIntensity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this.flatShading=t.flatShading,this}};vl.prototype.isMeshStandardMaterial=!0;var fh=class extends vl{constructor(t){super(),this.defines={STANDARD:"",PHYSICAL:""},this.type="MeshPhysicalMaterial",this.clearcoatMap=null,this.clearcoatRoughness=0,this.clearcoatRoughnessMap=null,this.clearcoatNormalScale=new K(1,1),this.clearcoatNormalMap=null,this.ior=1.5,Object.defineProperty(this,"reflectivity",{get:function(){return Ie(2.5*(this.ior-1)/(this.ior+1),0,1)},set:function(e){this.ior=(1+.4*e)/(1-.4*e)}}),this.sheenColor=new ft(0),this.sheenColorMap=null,this.sheenRoughness=1,this.sheenRoughnessMap=null,this.transmissionMap=null,this.thickness=0,this.thicknessMap=null,this.attenuationDistance=0,this.attenuationColor=new ft(1,1,1),this.specularIntensity=1,this.specularIntensityMap=null,this.specularColor=new ft(1,1,1),this.specularColorMap=null,this._sheen=0,this._clearcoat=0,this._transmission=0,this.setValues(t)}get sheen(){return this._sheen}set sheen(t){this._sheen>0!=t>0&&this.version++,this._sheen=t}get clearcoat(){return this._clearcoat}set clearcoat(t){this._clearcoat>0!=t>0&&this.version++,this._clearcoat=t}get transmission(){return this._transmission}set transmission(t){this._transmission>0!=t>0&&this.version++,this._transmission=t}copy(t){return super.copy(t),this.defines={STANDARD:"",PHYSICAL:""},this.clearcoat=t.clearcoat,this.clearcoatMap=t.clearcoatMap,this.clearcoatRoughness=t.clearcoatRoughness,this.clearcoatRoughnessMap=t.clearcoatRoughnessMap,this.clearcoatNormalMap=t.clearcoatNormalMap,this.clearcoatNormalScale.copy(t.clearcoatNormalScale),this.ior=t.ior,this.sheen=t.sheen,this.sheenColor.copy(t.sheenColor),this.sheenColorMap=t.sheenColorMap,this.sheenRoughness=t.sheenRoughness,this.sheenRoughnessMap=t.sheenRoughnessMap,this.transmission=t.transmission,this.transmissionMap=t.transmissionMap,this.thickness=t.thickness,this.thicknessMap=t.thicknessMap,this.attenuationDistance=t.attenuationDistance,this.attenuationColor.copy(t.attenuationColor),this.specularIntensity=t.specularIntensity,this.specularIntensityMap=t.specularIntensityMap,this.specularColor.copy(t.specularColor),this.specularColorMap=t.specularColorMap,this}};fh.prototype.isMeshPhysicalMaterial=!0;var dh=class extends xe{constructor(t){super(),this.type="MeshPhongMaterial",this.color=new ft(16777215),this.specular=new ft(1118481),this.shininess=30,this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new ft(0),this.emissiveIntensity=1,this.emissiveMap=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=ts,this.normalScale=new K(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.specularMap=null,this.alphaMap=null,this.envMap=null,this.combine=Cl,this.reflectivity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.flatShading=!1,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.specular.copy(t.specular),this.shininess=t.shininess,this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.specularMap=t.specularMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.combine=t.combine,this.reflectivity=t.reflectivity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this.flatShading=t.flatShading,this}};dh.prototype.isMeshPhongMaterial=!0;var ph=class extends xe{constructor(t){super(),this.defines={TOON:""},this.type="MeshToonMaterial",this.color=new ft(16777215),this.map=null,this.gradientMap=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new ft(0),this.emissiveIntensity=1,this.emissiveMap=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=ts,this.normalScale=new K(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.alphaMap=null,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.gradientMap=t.gradientMap,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.alphaMap=t.alphaMap,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this}};ph.prototype.isMeshToonMaterial=!0;var mh=class extends xe{constructor(t){super(),this.type="MeshNormalMaterial",this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=ts,this.normalScale=new K(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.wireframe=!1,this.wireframeLinewidth=1,this.fog=!1,this.flatShading=!1,this.setValues(t)}copy(t){return super.copy(t),this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.flatShading=t.flatShading,this}};mh.prototype.isMeshNormalMaterial=!0;var gh=class extends xe{constructor(t){super(),this.type="MeshLambertMaterial",this.color=new ft(16777215),this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new ft(0),this.emissiveIntensity=1,this.emissiveMap=null,this.specularMap=null,this.alphaMap=null,this.envMap=null,this.combine=Cl,this.reflectivity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.specularMap=t.specularMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.combine=t.combine,this.reflectivity=t.reflectivity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this}};gh.prototype.isMeshLambertMaterial=!0;var xh=class extends xe{constructor(t){super(),this.defines={MATCAP:""},this.type="MeshMatcapMaterial",this.color=new ft(16777215),this.matcap=null,this.map=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=ts,this.normalScale=new K(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.alphaMap=null,this.flatShading=!1,this.setValues(t)}copy(t){return super.copy(t),this.defines={MATCAP:""},this.color.copy(t.color),this.matcap=t.matcap,this.map=t.map,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.alphaMap=t.alphaMap,this.flatShading=t.flatShading,this}};xh.prototype.isMeshMatcapMaterial=!0;var yh=class extends zn{constructor(t){super(),this.type="LineDashedMaterial",this.scale=1,this.dashSize=3,this.gapSize=1,this.setValues(t)}copy(t){return super.copy(t),this.scale=t.scale,this.dashSize=t.dashSize,this.gapSize=t.gapSize,this}};yh.prototype.isLineDashedMaterial=!0;var Kt={arraySlice:function(n,t,e){return Kt.isTypedArray(n)?new n.constructor(n.subarray(t,e!==void 0?e:n.length)):n.slice(t,e)},convertArray:function(n,t,e){return!n||!e&&n.constructor===t?n:typeof t.BYTES_PER_ELEMENT=="number"?new t(n):Array.prototype.slice.call(n)},isTypedArray:function(n){return ArrayBuffer.isView(n)&&!(n instanceof DataView)},getKeyframeOrder:function(n){function t(r,s){return n[r]-n[s]}let e=n.length,i=new Array(e);for(let r=0;r!==e;++r)i[r]=r;return i.sort(t),i},sortedArray:function(n,t,e){let i=n.length,r=new n.constructor(i);for(let s=0,o=0;o!==i;++s){let a=e[s]*t;for(let l=0;l!==t;++l)r[o++]=n[a+l]}return r},flattenJSON:function(n,t,e,i){let r=1,s=n[0];for(;s!==void 0&&s[i]===void 0;)s=n[r++];if(s===void 0)return;let o=s[i];if(o!==void 0)if(Array.isArray(o))do o=s[i],o!==void 0&&(t.push(s.time),e.push.apply(e,o)),s=n[r++];while(s!==void 0);else if(o.toArray!==void 0)do o=s[i],o!==void 0&&(t.push(s.time),o.toArray(e,e.length)),s=n[r++];while(s!==void 0);else do o=s[i],o!==void 0&&(t.push(s.time),e.push(o)),s=n[r++];while(s!==void 0)},subclip:function(n,t,e,i,r=30){let s=n.clone();s.name=t;let o=[];for(let l=0;l<s.tracks.length;++l){let c=s.tracks[l],u=c.getValueSize(),h=[],f=[];for(let d=0;d<c.times.length;++d){let g=c.times[d]*r;if(!(g<e||g>=i)){h.push(c.times[d]);for(let x=0;x<u;++x)f.push(c.values[d*u+x])}}h.length!==0&&(c.times=Kt.convertArray(h,c.times.constructor),c.values=Kt.convertArray(f,c.values.constructor),o.push(c))}s.tracks=o;let a=1/0;for(let l=0;l<s.tracks.length;++l)a>s.tracks[l].times[0]&&(a=s.tracks[l].times[0]);for(let l=0;l<s.tracks.length;++l)s.tracks[l].shift(-1*a);return s.resetDuration(),s},makeClipAdditive:function(n,t=0,e=n,i=30){i<=0&&(i=30);let r=e.tracks.length,s=t/i;for(let o=0;o<r;++o){let a=e.tracks[o],l=a.ValueTypeName;if(l==="bool"||l==="string")continue;let c=n.tracks.find(function(m){return m.name===a.name&&m.ValueTypeName===l});if(c===void 0)continue;let u=0,h=a.getValueSize();a.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline&&(u=h/3);let f=0,d=c.getValueSize();c.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline&&(f=d/3);let g=a.times.length-1,x;if(s<=a.times[0]){let m=u,p=h-u;x=Kt.arraySlice(a.values,m,p)}else if(s>=a.times[g]){let m=g*h+u,p=m+h-u;x=Kt.arraySlice(a.values,m,p)}else{let m=a.createInterpolant(),p=u,b=h-u;m.evaluate(s),x=Kt.arraySlice(m.resultBuffer,p,b)}l==="quaternion"&&new Ee().fromArray(x).normalize().conjugate().toArray(x);let v=c.times.length;for(let m=0;m<v;++m){let p=m*d+f;if(l==="quaternion")Ee.multiplyQuaternionsFlat(c.values,p,x,0,c.values,p);else{let b=d-f*2;for(let _=0;_<b;++_)c.values[p+_]-=x[_]}}}return n.blendMode=d0,n}},pn=class{constructor(t,e,i,r){this.parameterPositions=t,this._cachedIndex=0,this.resultBuffer=r!==void 0?r:new e.constructor(i),this.sampleValues=e,this.valueSize=i,this.settings=null,this.DefaultSettings_={}}evaluate(t){let e=this.parameterPositions,i=this._cachedIndex,r=e[i],s=e[i-1];t:{e:{let o;n:{i:if(!(t<r)){for(let a=i+2;;){if(r===void 0){if(t<s)break i;return i=e.length,this._cachedIndex=i,this.afterEnd_(i-1,t,s)}if(i===a)break;if(s=r,r=e[++i],t<r)break e}o=e.length;break n}if(!(t>=s)){let a=e[1];t<a&&(i=2,s=a);for(let l=i-2;;){if(s===void 0)return this._cachedIndex=0,this.beforeStart_(0,t,r);if(i===l)break;if(r=s,s=e[--i-1],t>=s)break e}o=i,i=0;break n}break t}for(;i<o;){let a=i+o>>>1;t<e[a]?o=a:i=a+1}if(r=e[i],s=e[i-1],s===void 0)return this._cachedIndex=0,this.beforeStart_(0,t,r);if(r===void 0)return i=e.length,this._cachedIndex=i,this.afterEnd_(i-1,s,t)}this._cachedIndex=i,this.intervalChanged_(i,s,r)}return this.interpolate_(i,s,t,r)}getSettings_(){return this.settings||this.DefaultSettings_}copySampleValue_(t){let e=this.resultBuffer,i=this.sampleValues,r=this.valueSize,s=t*r;for(let o=0;o!==r;++o)e[o]=i[s+o];return e}interpolate_(){throw new Error("call to abstract method")}intervalChanged_(){}};pn.prototype.beforeStart_=pn.prototype.copySampleValue_;pn.prototype.afterEnd_=pn.prototype.copySampleValue_;var vh=class extends pn{constructor(t,e,i,r){super(t,e,i,r),this._weightPrev=-0,this._offsetPrev=-0,this._weightNext=-0,this._offsetNext=-0,this.DefaultSettings_={endingStart:Nr,endingEnd:Nr}}intervalChanged_(t,e,i){let r=this.parameterPositions,s=t-2,o=t+1,a=r[s],l=r[o];if(a===void 0)switch(this.getSettings_().endingStart){case Fr:s=t,a=2*e-i;break;case el:s=r.length-2,a=e+r[s]-r[s+1];break;default:s=t,a=i}if(l===void 0)switch(this.getSettings_().endingEnd){case Fr:o=t,l=2*i-e;break;case el:o=1,l=i+r[1]-r[0];break;default:o=t-1,l=e}let c=(i-e)*.5,u=this.valueSize;this._weightPrev=c/(e-a),this._weightNext=c/(l-i),this._offsetPrev=s*u,this._offsetNext=o*u}interpolate_(t,e,i,r){let s=this.resultBuffer,o=this.sampleValues,a=this.valueSize,l=t*a,c=l-a,u=this._offsetPrev,h=this._offsetNext,f=this._weightPrev,d=this._weightNext,g=(i-e)/(r-e),x=g*g,v=x*g,m=-f*v+2*f*x-f*g,p=(1+f)*v+(-1.5-2*f)*x+(-.5+f)*g+1,b=(-1-d)*v+(1.5+d)*x+.5*g,_=d*v-d*x;for(let S=0;S!==a;++S)s[S]=m*o[u+S]+p*o[c+S]+b*o[l+S]+_*o[h+S];return s}},_l=class extends pn{constructor(t,e,i,r){super(t,e,i,r)}interpolate_(t,e,i,r){let s=this.resultBuffer,o=this.sampleValues,a=this.valueSize,l=t*a,c=l-a,u=(i-e)/(r-e),h=1-u;for(let f=0;f!==a;++f)s[f]=o[c+f]*h+o[l+f]*u;return s}},_h=class extends pn{constructor(t,e,i,r){super(t,e,i,r)}interpolate_(t){return this.copySampleValue_(t-1)}},Xe=class{constructor(t,e,i,r){if(t===void 0)throw new Error("THREE.KeyframeTrack: track name is undefined");if(e===void 0||e.length===0)throw new Error("THREE.KeyframeTrack: no keyframes in track named "+t);this.name=t,this.times=Kt.convertArray(e,this.TimeBufferType),this.values=Kt.convertArray(i,this.ValueBufferType),this.setInterpolation(r||this.DefaultInterpolation)}static toJSON(t){let e=t.constructor,i;if(e.toJSON!==this.toJSON)i=e.toJSON(t);else{i={name:t.name,times:Kt.convertArray(t.times,Array),values:Kt.convertArray(t.values,Array)};let r=t.getInterpolation();r!==t.DefaultInterpolation&&(i.interpolation=r)}return i.type=t.ValueTypeName,i}InterpolantFactoryMethodDiscrete(t){return new _h(this.times,this.values,this.getValueSize(),t)}InterpolantFactoryMethodLinear(t){return new _l(this.times,this.values,this.getValueSize(),t)}InterpolantFactoryMethodSmooth(t){return new vh(this.times,this.values,this.getValueSize(),t)}setInterpolation(t){let e;switch(t){case ja:e=this.InterpolantFactoryMethodDiscrete;break;case tl:e=this.InterpolantFactoryMethodLinear;break;case eu:e=this.InterpolantFactoryMethodSmooth;break}if(e===void 0){let i="unsupported interpolation for "+this.ValueTypeName+" keyframe track named "+this.name;if(this.createInterpolant===void 0)if(t!==this.DefaultInterpolation)this.setInterpolation(this.DefaultInterpolation);else throw new Error(i);return console.warn("THREE.KeyframeTrack:",i),this}return this.createInterpolant=e,this}getInterpolation(){switch(this.createInterpolant){case this.InterpolantFactoryMethodDiscrete:return ja;case this.InterpolantFactoryMethodLinear:return tl;case this.InterpolantFactoryMethodSmooth:return eu}}getValueSize(){return this.values.length/this.times.length}shift(t){if(t!==0){let e=this.times;for(let i=0,r=e.length;i!==r;++i)e[i]+=t}return this}scale(t){if(t!==1){let e=this.times;for(let i=0,r=e.length;i!==r;++i)e[i]*=t}return this}trim(t,e){let i=this.times,r=i.length,s=0,o=r-1;for(;s!==r&&i[s]<t;)++s;for(;o!==-1&&i[o]>e;)--o;if(++o,s!==0||o!==r){s>=o&&(o=Math.max(o,1),s=o-1);let a=this.getValueSize();this.times=Kt.arraySlice(i,s,o),this.values=Kt.arraySlice(this.values,s*a,o*a)}return this}validate(){let t=!0,e=this.getValueSize();e-Math.floor(e)!==0&&(console.error("THREE.KeyframeTrack: Invalid value size in track.",this),t=!1);let i=this.times,r=this.values,s=i.length;s===0&&(console.error("THREE.KeyframeTrack: Track is empty.",this),t=!1);let o=null;for(let a=0;a!==s;a++){let l=i[a];if(typeof l=="number"&&isNaN(l)){console.error("THREE.KeyframeTrack: Time is not a valid number.",this,a,l),t=!1;break}if(o!==null&&o>l){console.error("THREE.KeyframeTrack: Out of order keys.",this,a,l,o),t=!1;break}o=l}if(r!==void 0&&Kt.isTypedArray(r))for(let a=0,l=r.length;a!==l;++a){let c=r[a];if(isNaN(c)){console.error("THREE.KeyframeTrack: Value is not a valid number.",this,a,c),t=!1;break}}return t}optimize(){let t=Kt.arraySlice(this.times),e=Kt.arraySlice(this.values),i=this.getValueSize(),r=this.getInterpolation()===eu,s=t.length-1,o=1;for(let a=1;a<s;++a){let l=!1,c=t[a],u=t[a+1];if(c!==u&&(a!==1||c!==t[0]))if(r)l=!0;else{let h=a*i,f=h-i,d=h+i;for(let g=0;g!==i;++g){let x=e[h+g];if(x!==e[f+g]||x!==e[d+g]){l=!0;break}}}if(l){if(a!==o){t[o]=t[a];let h=a*i,f=o*i;for(let d=0;d!==i;++d)e[f+d]=e[h+d]}++o}}if(s>0){t[o]=t[s];for(let a=s*i,l=o*i,c=0;c!==i;++c)e[l+c]=e[a+c];++o}return o!==t.length?(this.times=Kt.arraySlice(t,0,o),this.values=Kt.arraySlice(e,0,o*i)):(this.times=t,this.values=e),this}clone(){let t=Kt.arraySlice(this.times,0),e=Kt.arraySlice(this.values,0),i=this.constructor,r=new i(this.name,t,e);return r.createInterpolant=this.createInterpolant,r}};Xe.prototype.TimeBufferType=Float32Array;Xe.prototype.ValueBufferType=Float32Array;Xe.prototype.DefaultInterpolation=tl;var ui=class extends Xe{};ui.prototype.ValueTypeName="bool";ui.prototype.ValueBufferType=Array;ui.prototype.DefaultInterpolation=ja;ui.prototype.InterpolantFactoryMethodLinear=void 0;ui.prototype.InterpolantFactoryMethodSmooth=void 0;var wl=class extends Xe{};wl.prototype.ValueTypeName="color";var Kr=class extends Xe{};Kr.prototype.ValueTypeName="number";var wh=class extends pn{constructor(t,e,i,r){super(t,e,i,r)}interpolate_(t,e,i,r){let s=this.resultBuffer,o=this.sampleValues,a=this.valueSize,l=(i-e)/(r-e),c=t*a;for(let u=c+a;c!==u;c+=4)Ee.slerpFlat(s,0,o,c-a,o,c,l);return s}},Xi=class extends Xe{InterpolantFactoryMethodLinear(t){return new wh(this.times,this.values,this.getValueSize(),t)}};Xi.prototype.ValueTypeName="quaternion";Xi.prototype.DefaultInterpolation=tl;Xi.prototype.InterpolantFactoryMethodSmooth=void 0;var hi=class extends Xe{};hi.prototype.ValueTypeName="string";hi.prototype.ValueBufferType=Array;hi.prototype.DefaultInterpolation=ja;hi.prototype.InterpolantFactoryMethodLinear=void 0;hi.prototype.InterpolantFactoryMethodSmooth=void 0;var Qr=class extends Xe{};Qr.prototype.ValueTypeName="vector";var Ml=class{constructor(t,e=-1,i,r=Qh){this.name=t,this.tracks=i,this.duration=e,this.blendMode=r,this.uuid=tn(),this.duration<0&&this.resetDuration()}static parse(t){let e=[],i=t.tracks,r=1/(t.fps||1);for(let o=0,a=i.length;o!==a;++o)e.push(cT(i[o]).scale(r));let s=new this(t.name,t.duration,e,t.blendMode);return s.uuid=t.uuid,s}static toJSON(t){let e=[],i=t.tracks,r={name:t.name,duration:t.duration,tracks:e,uuid:t.uuid,blendMode:t.blendMode};for(let s=0,o=i.length;s!==o;++s)e.push(Xe.toJSON(i[s]));return r}static CreateFromMorphTargetSequence(t,e,i,r){let s=e.length,o=[];for(let a=0;a<s;a++){let l=[],c=[];l.push((a+s-1)%s,a,(a+1)%s),c.push(0,1,0);let u=Kt.getKeyframeOrder(l);l=Kt.sortedArray(l,1,u),c=Kt.sortedArray(c,1,u),!r&&l[0]===0&&(l.push(s),c.push(c[0])),o.push(new Kr(".morphTargetInfluences["+e[a].name+"]",l,c).scale(1/i))}return new this(t,-1,o)}static findByName(t,e){let i=t;if(!Array.isArray(t)){let r=t;i=r.geometry&&r.geometry.animations||r.animations}for(let r=0;r<i.length;r++)if(i[r].name===e)return i[r];return null}static CreateClipsFromMorphTargetSequences(t,e,i){let r={},s=/^([\w-]*?)([\d]+)$/;for(let a=0,l=t.length;a<l;a++){let c=t[a],u=c.name.match(s);if(u&&u.length>1){let h=u[1],f=r[h];f||(r[h]=f=[]),f.push(c)}}let o=[];for(let a in r)o.push(this.CreateFromMorphTargetSequence(a,r[a],e,i));return o}static parseAnimation(t,e){if(!t)return console.error("THREE.AnimationClip: No animation in JSONLoader data."),null;let i=function(h,f,d,g,x){if(d.length!==0){let v=[],m=[];Kt.flattenJSON(d,v,m,g),v.length!==0&&x.push(new h(f,v,m))}},r=[],s=t.name||"default",o=t.fps||30,a=t.blendMode,l=t.length||-1,c=t.hierarchy||[];for(let h=0;h<c.length;h++){let f=c[h].keys;if(!(!f||f.length===0))if(f[0].morphTargets){let d={},g;for(g=0;g<f.length;g++)if(f[g].morphTargets)for(let x=0;x<f[g].morphTargets.length;x++)d[f[g].morphTargets[x]]=-1;for(let x in d){let v=[],m=[];for(let p=0;p!==f[g].morphTargets.length;++p){let b=f[g];v.push(b.time),m.push(b.morphTarget===x?1:0)}r.push(new Kr(".morphTargetInfluence["+x+"]",v,m))}l=d.length*(o||1)}else{let d=".bones["+e[h].name+"]";i(Qr,d+".position",f,"pos",r),i(Xi,d+".quaternion",f,"rot",r),i(Qr,d+".scale",f,"scl",r)}}return r.length===0?null:new this(s,l,r,a)}resetDuration(){let t=this.tracks,e=0;for(let i=0,r=t.length;i!==r;++i){let s=this.tracks[i];e=Math.max(e,s.times[s.times.length-1])}return this.duration=e,this}trim(){for(let t=0;t<this.tracks.length;t++)this.tracks[t].trim(0,this.duration);return this}validate(){let t=!0;for(let e=0;e<this.tracks.length;e++)t=t&&this.tracks[e].validate();return t}optimize(){for(let t=0;t<this.tracks.length;t++)this.tracks[t].optimize();return this}clone(){let t=[];for(let e=0;e<this.tracks.length;e++)t.push(this.tracks[e].clone());return new this.constructor(this.name,this.duration,t,this.blendMode)}toJSON(){return this.constructor.toJSON(this)}};function lT(n){switch(n.toLowerCase()){case"scalar":case"double":case"float":case"number":case"integer":return Kr;case"vector":case"vector2":case"vector3":case"vector4":return Qr;case"color":return wl;case"quaternion":return Xi;case"bool":case"boolean":return ui;case"string":return hi}throw new Error("THREE.KeyframeTrack: Unsupported typeName: "+n)}function cT(n){if(n.type===void 0)throw new Error("THREE.KeyframeTrack: track type undefined, can not parse");let t=lT(n.type);if(n.times===void 0){let e=[],i=[];Kt.flattenJSON(n.keys,e,i,"value"),n.times=e,n.values=i}return t.parse!==void 0?t.parse(n):new t(n.name,n.times,n.values,n.interpolation)}var jr={enabled:!1,files:{},add:function(n,t){this.enabled!==!1&&(this.files[n]=t)},get:function(n){if(this.enabled!==!1)return this.files[n]},remove:function(n){delete this.files[n]},clear:function(){this.files={}}},Mh=class{constructor(t,e,i){let r=this,s=!1,o=0,a=0,l,c=[];this.onStart=void 0,this.onLoad=t,this.onProgress=e,this.onError=i,this.itemStart=function(u){a++,s===!1&&r.onStart!==void 0&&r.onStart(u,o,a),s=!0},this.itemEnd=function(u){o++,r.onProgress!==void 0&&r.onProgress(u,o,a),o===a&&(s=!1,r.onLoad!==void 0&&r.onLoad())},this.itemError=function(u){r.onError!==void 0&&r.onError(u)},this.resolveURL=function(u){return l?l(u):u},this.setURLModifier=function(u){return l=u,this},this.addHandler=function(u,h){return c.push(u,h),this},this.removeHandler=function(u){let h=c.indexOf(u);return h!==-1&&c.splice(h,2),this},this.getHandler=function(u){for(let h=0,f=c.length;h<f;h+=2){let d=c[h],g=c[h+1];if(d.global&&(d.lastIndex=0),d.test(u))return g}return null}}},uT=new Mh,mn=class{constructor(t){this.manager=t!==void 0?t:uT,this.crossOrigin="anonymous",this.withCredentials=!1,this.path="",this.resourcePath="",this.requestHeader={}}load(){}loadAsync(t,e){let i=this;return new Promise(function(r,s){i.load(t,r,e,s)})}parse(){}setCrossOrigin(t){return this.crossOrigin=t,this}setWithCredentials(t){return this.withCredentials=t,this}setPath(t){return this.path=t,this}setResourcePath(t){return this.resourcePath=t,this}setRequestHeader(t){return this.requestHeader=t,this}},Dn={},bh=class extends mn{constructor(t){super(t)}load(t,e,i,r){t===void 0&&(t=""),this.path!==void 0&&(t=this.path+t),t=this.manager.resolveURL(t);let s=jr.get(t);if(s!==void 0)return this.manager.itemStart(t),setTimeout(()=>{e&&e(s),this.manager.itemEnd(t)},0),s;if(Dn[t]!==void 0){Dn[t].push({onLoad:e,onProgress:i,onError:r});return}Dn[t]=[],Dn[t].push({onLoad:e,onProgress:i,onError:r});let o=new Request(t,{headers:new Headers(this.requestHeader),credentials:this.withCredentials?"include":"same-origin"}),a=this.mimeType,l=this.responseType;fetch(o).then(c=>{if(c.status===200||c.status===0){if(c.status===0&&console.warn("THREE.FileLoader: HTTP Status 0 received."),typeof ReadableStream=="undefined"||c.body.getReader===void 0)return c;let u=Dn[t],h=c.body.getReader(),f=c.headers.get("Content-Length"),d=f?parseInt(f):0,g=d!==0,x=0,v=new ReadableStream({start(m){p();function p(){h.read().then(({done:b,value:_})=>{if(b)m.close();else{x+=_.byteLength;let S=new ProgressEvent("progress",{lengthComputable:g,loaded:x,total:d});for(let L=0,A=u.length;L<A;L++){let H=u[L];H.onProgress&&H.onProgress(S)}m.enqueue(_),p()}})}}});return new Response(v)}else throw Error(`fetch for "${c.url}" responded with ${c.status}: ${c.statusText}`)}).then(c=>{switch(l){case"arraybuffer":return c.arrayBuffer();case"blob":return c.blob();case"document":return c.text().then(u=>new DOMParser().parseFromString(u,a));case"json":return c.json();default:if(a===void 0)return c.text();{let h=/charset="?([^;"\s]*)"?/i.exec(a),f=h&&h[1]?h[1].toLowerCase():void 0,d=new TextDecoder(f);return c.arrayBuffer().then(g=>d.decode(g))}}}).then(c=>{jr.add(t,c);let u=Dn[t];delete Dn[t];for(let h=0,f=u.length;h<f;h++){let d=u[h];d.onLoad&&d.onLoad(c)}}).catch(c=>{let u=Dn[t];if(u===void 0)throw this.manager.itemError(t),c;delete Dn[t];for(let h=0,f=u.length;h<f;h++){let d=u[h];d.onError&&d.onError(c)}this.manager.itemError(t)}).finally(()=>{this.manager.itemEnd(t)}),this.manager.itemStart(t)}setResponseType(t){return this.responseType=t,this}setMimeType(t){return this.mimeType=t,this}};var bl=class extends mn{constructor(t){super(t)}load(t,e,i,r){this.path!==void 0&&(t=this.path+t),t=this.manager.resolveURL(t);let s=this,o=jr.get(t);if(o!==void 0)return s.manager.itemStart(t),setTimeout(function(){e&&e(o),s.manager.itemEnd(t)},0),o;let a=ro("img");function l(){u(),jr.add(t,this),e&&e(this),s.manager.itemEnd(t)}function c(h){u(),r&&r(h),s.manager.itemError(t),s.manager.itemEnd(t)}function u(){a.removeEventListener("load",l,!1),a.removeEventListener("error",c,!1)}return a.addEventListener("load",l,!1),a.addEventListener("error",c,!1),t.substr(0,5)!=="data:"&&this.crossOrigin!==void 0&&(a.crossOrigin=this.crossOrigin),s.manager.itemStart(t),a.src=t,a}},Sh=class extends mn{constructor(t){super(t)}load(t,e,i,r){let s=new Wr,o=new bl(this.manager);o.setCrossOrigin(this.crossOrigin),o.setPath(this.path);let a=0;function l(c){o.load(t[c],function(u){s.images[c]=u,a++,a===6&&(s.needsUpdate=!0,e&&e(s))},void 0,r)}for(let c=0;c<t.length;++c)l(c);return s}};var Eh=class extends mn{constructor(t){super(t)}load(t,e,i,r){let s=new ae,o=new bl(this.manager);return o.setCrossOrigin(this.crossOrigin),o.setPath(this.path),o.load(t,function(a){s.image=a,s.needsUpdate=!0,e!==void 0&&e(s)},i,r),s}},Ye=class extends kt{constructor(t,e=1){super(),this.type="Light",this.color=new ft(t),this.intensity=e}dispose(){}copy(t){return super.copy(t),this.color.copy(t.color),this.intensity=t.intensity,this}toJSON(t){let e=super.toJSON(t);return e.object.color=this.color.getHex(),e.object.intensity=this.intensity,this.groundColor!==void 0&&(e.object.groundColor=this.groundColor.getHex()),this.distance!==void 0&&(e.object.distance=this.distance),this.angle!==void 0&&(e.object.angle=this.angle),this.decay!==void 0&&(e.object.decay=this.decay),this.penumbra!==void 0&&(e.object.penumbra=this.penumbra),this.shadow!==void 0&&(e.object.shadow=this.shadow.toJSON()),e}};Ye.prototype.isLight=!0;var Th=class extends Ye{constructor(t,e,i){super(t,i),this.type="HemisphereLight",this.position.copy(kt.DefaultUp),this.updateMatrix(),this.groundColor=new ft(e)}copy(t){return Ye.prototype.copy.call(this,t),this.groundColor.copy(t.groundColor),this}};Th.prototype.isHemisphereLight=!0;var n0=new wt,i0=new T,r0=new T,So=class{constructor(t){this.camera=t,this.bias=0,this.normalBias=0,this.radius=1,this.blurSamples=8,this.mapSize=new K(512,512),this.map=null,this.mapPass=null,this.matrix=new wt,this.autoUpdate=!0,this.needsUpdate=!1,this._frustum=new qr,this._frameExtents=new K(1,1),this._viewportCount=1,this._viewports=[new Wt(0,0,1,1)]}getViewportCount(){return this._viewportCount}getFrustum(){return this._frustum}updateMatrices(t){let e=this.camera,i=this.matrix;i0.setFromMatrixPosition(t.matrixWorld),e.position.copy(i0),r0.setFromMatrixPosition(t.target.matrixWorld),e.lookAt(r0),e.updateMatrixWorld(),n0.multiplyMatrices(e.projectionMatrix,e.matrixWorldInverse),this._frustum.setFromProjectionMatrix(n0),i.set(.5,0,0,.5,0,.5,0,.5,0,0,.5,.5,0,0,0,1),i.multiply(e.projectionMatrix),i.multiply(e.matrixWorldInverse)}getViewport(t){return this._viewports[t]}getFrameExtents(){return this._frameExtents}dispose(){this.map&&this.map.dispose(),this.mapPass&&this.mapPass.dispose()}copy(t){return this.camera=t.camera.clone(),this.bias=t.bias,this.radius=t.radius,this.mapSize.copy(t.mapSize),this}clone(){return new this.constructor().copy(this)}toJSON(){let t={};return this.bias!==0&&(t.bias=this.bias),this.normalBias!==0&&(t.normalBias=this.normalBias),this.radius!==1&&(t.radius=this.radius),(this.mapSize.x!==512||this.mapSize.y!==512)&&(t.mapSize=this.mapSize.toArray()),t.camera=this.camera.toJSON(!1).object,delete t.camera.matrix,t}},Sl=class extends So{constructor(){super(new Se(50,1,.5,500)),this.focus=1}updateMatrices(t){let e=this.camera,i=Vu*2*t.angle*this.focus,r=this.mapSize.width/this.mapSize.height,s=t.distance||e.far;(i!==e.fov||r!==e.aspect||s!==e.far)&&(e.fov=i,e.aspect=r,e.far=s,e.updateProjectionMatrix()),super.updateMatrices(t)}copy(t){return super.copy(t),this.focus=t.focus,this}};Sl.prototype.isSpotLightShadow=!0;var Ah=class extends Ye{constructor(t,e,i=0,r=Math.PI/3,s=0,o=1){super(t,e),this.type="SpotLight",this.position.copy(kt.DefaultUp),this.updateMatrix(),this.target=new kt,this.distance=i,this.angle=r,this.penumbra=s,this.decay=o,this.shadow=new Sl}get power(){return this.intensity*Math.PI}set power(t){this.intensity=t/Math.PI}dispose(){this.shadow.dispose()}copy(t){return super.copy(t),this.distance=t.distance,this.angle=t.angle,this.penumbra=t.penumbra,this.decay=t.decay,this.target=t.target.clone(),this.shadow=t.shadow.clone(),this}};Ah.prototype.isSpotLight=!0;var s0=new wt,Zs=new T,Nu=new T,El=class extends So{constructor(){super(new Se(90,1,.5,500)),this._frameExtents=new K(4,2),this._viewportCount=6,this._viewports=[new Wt(2,1,1,1),new Wt(0,1,1,1),new Wt(3,1,1,1),new Wt(1,1,1,1),new Wt(3,0,1,1),new Wt(1,0,1,1)],this._cubeDirections=[new T(1,0,0),new T(-1,0,0),new T(0,0,1),new T(0,0,-1),new T(0,1,0),new T(0,-1,0)],this._cubeUps=[new T(0,1,0),new T(0,1,0),new T(0,1,0),new T(0,1,0),new T(0,0,1),new T(0,0,-1)]}updateMatrices(t,e=0){let i=this.camera,r=this.matrix,s=t.distance||i.far;s!==i.far&&(i.far=s,i.updateProjectionMatrix()),Zs.setFromMatrixPosition(t.matrixWorld),i.position.copy(Zs),Nu.copy(i.position),Nu.add(this._cubeDirections[e]),i.up.copy(this._cubeUps[e]),i.lookAt(Nu),i.updateMatrixWorld(),r.makeTranslation(-Zs.x,-Zs.y,-Zs.z),s0.multiplyMatrices(i.projectionMatrix,i.matrixWorldInverse),this._frustum.setFromProjectionMatrix(s0)}};El.prototype.isPointLightShadow=!0;var Ch=class extends Ye{constructor(t,e,i=0,r=1){super(t,e),this.type="PointLight",this.distance=i,this.decay=r,this.shadow=new El}get power(){return this.intensity*4*Math.PI}set power(t){this.intensity=t/(4*Math.PI)}dispose(){this.shadow.dispose()}copy(t){return super.copy(t),this.distance=t.distance,this.decay=t.decay,this.shadow=t.shadow.clone(),this}};Ch.prototype.isPointLight=!0;var Tl=class extends So{constructor(){super(new Vi(-5,5,5,-5,.5,500))}};Tl.prototype.isDirectionalLightShadow=!0;var Rh=class extends Ye{constructor(t,e){super(t,e),this.type="DirectionalLight",this.position.copy(kt.DefaultUp),this.updateMatrix(),this.target=new kt,this.shadow=new Tl}dispose(){this.shadow.dispose()}copy(t){return super.copy(t),this.target=t.target.clone(),this.shadow=t.shadow.clone(),this}};Rh.prototype.isDirectionalLight=!0;var Lh=class extends Ye{constructor(t,e){super(t,e),this.type="AmbientLight"}};Lh.prototype.isAmbientLight=!0;var Ph=class extends Ye{constructor(t,e,i=10,r=10){super(t,e),this.type="RectAreaLight",this.width=i,this.height=r}get power(){return this.intensity*this.width*this.height*Math.PI}set power(t){this.intensity=t/(this.width*this.height*Math.PI)}copy(t){return super.copy(t),this.width=t.width,this.height=t.height,this}toJSON(t){let e=super.toJSON(t);return e.object.width=this.width,e.object.height=this.height,e}};Ph.prototype.isRectAreaLight=!0;var Al=class{constructor(){this.coefficients=[];for(let t=0;t<9;t++)this.coefficients.push(new T)}set(t){for(let e=0;e<9;e++)this.coefficients[e].copy(t[e]);return this}zero(){for(let t=0;t<9;t++)this.coefficients[t].set(0,0,0);return this}getAt(t,e){let i=t.x,r=t.y,s=t.z,o=this.coefficients;return e.copy(o[0]).multiplyScalar(.282095),e.addScaledVector(o[1],.488603*r),e.addScaledVector(o[2],.488603*s),e.addScaledVector(o[3],.488603*i),e.addScaledVector(o[4],1.092548*(i*r)),e.addScaledVector(o[5],1.092548*(r*s)),e.addScaledVector(o[6],.315392*(3*s*s-1)),e.addScaledVector(o[7],1.092548*(i*s)),e.addScaledVector(o[8],.546274*(i*i-r*r)),e}getIrradianceAt(t,e){let i=t.x,r=t.y,s=t.z,o=this.coefficients;return e.copy(o[0]).multiplyScalar(.886227),e.addScaledVector(o[1],2*.511664*r),e.addScaledVector(o[2],2*.511664*s),e.addScaledVector(o[3],2*.511664*i),e.addScaledVector(o[4],2*.429043*i*r),e.addScaledVector(o[5],2*.429043*r*s),e.addScaledVector(o[6],.743125*s*s-.247708),e.addScaledVector(o[7],2*.429043*i*s),e.addScaledVector(o[8],.429043*(i*i-r*r)),e}add(t){for(let e=0;e<9;e++)this.coefficients[e].add(t.coefficients[e]);return this}addScaledSH(t,e){for(let i=0;i<9;i++)this.coefficients[i].addScaledVector(t.coefficients[i],e);return this}scale(t){for(let e=0;e<9;e++)this.coefficients[e].multiplyScalar(t);return this}lerp(t,e){for(let i=0;i<9;i++)this.coefficients[i].lerp(t.coefficients[i],e);return this}equals(t){for(let e=0;e<9;e++)if(!this.coefficients[e].equals(t.coefficients[e]))return!1;return!0}copy(t){return this.set(t.coefficients)}clone(){return new this.constructor().copy(this)}fromArray(t,e=0){let i=this.coefficients;for(let r=0;r<9;r++)i[r].fromArray(t,e+r*3);return this}toArray(t=[],e=0){let i=this.coefficients;for(let r=0;r<9;r++)i[r].toArray(t,e+r*3);return t}static getBasisAt(t,e){let i=t.x,r=t.y,s=t.z;e[0]=.282095,e[1]=.488603*r,e[2]=.488603*s,e[3]=.488603*i,e[4]=1.092548*i*r,e[5]=1.092548*r*s,e[6]=.315392*(3*s*s-1),e[7]=1.092548*i*s,e[8]=.546274*(i*i-r*r)}};Al.prototype.isSphericalHarmonics3=!0;var Eo=class extends Ye{constructor(t=new Al,e=1){super(void 0,e),this.sh=t}copy(t){return super.copy(t),this.sh.copy(t.sh),this}fromJSON(t){return this.intensity=t.intensity,this.sh.fromArray(t.sh),this}toJSON(t){let e=super.toJSON(t);return e.object.sh=this.sh.toArray(),e}};Eo.prototype.isLightProbe=!0;var Dh=class{static decodeText(t){if(typeof TextDecoder!="undefined")return new TextDecoder().decode(t);let e="";for(let i=0,r=t.length;i<r;i++)e+=String.fromCharCode(t[i]);try{return decodeURIComponent(escape(e))}catch(i){return e}}static extractUrlBase(t){let e=t.lastIndexOf("/");return e===-1?"./":t.substr(0,e+1)}static resolveURL(t,e){return typeof t!="string"||t===""?"":(/^https?:\/\//i.test(e)&&/^\//.test(t)&&(e=e.replace(/(^https?:\/\/[^\/]+).*/i,"$1")),/^(https?:)?\/\//i.test(t)||/^data:.*,.*$/i.test(t)||/^blob:.*$/i.test(t)?t:e+t)}},Ih=class extends Ht{constructor(){super(),this.type="InstancedBufferGeometry",this.instanceCount=1/0}copy(t){return super.copy(t),this.instanceCount=t.instanceCount,this}clone(){return new this.constructor().copy(this)}toJSON(){let t=super.toJSON(this);return t.instanceCount=this.instanceCount,t.isInstancedBufferGeometry=!0,t}};Ih.prototype.isInstancedBufferGeometry=!0;var Nh=class extends mn{constructor(t){super(t),typeof createImageBitmap=="undefined"&&console.warn("THREE.ImageBitmapLoader: createImageBitmap() not supported."),typeof fetch=="undefined"&&console.warn("THREE.ImageBitmapLoader: fetch() not supported."),this.options={premultiplyAlpha:"none"}}setOptions(t){return this.options=t,this}load(t,e,i,r){t===void 0&&(t=""),this.path!==void 0&&(t=this.path+t),t=this.manager.resolveURL(t);let s=this,o=jr.get(t);if(o!==void 0)return s.manager.itemStart(t),setTimeout(function(){e&&e(o),s.manager.itemEnd(t)},0),o;let a={};a.credentials=this.crossOrigin==="anonymous"?"same-origin":"include",a.headers=this.requestHeader,fetch(t,a).then(function(l){return l.blob()}).then(function(l){return createImageBitmap(l,Object.assign(s.options,{colorSpaceConversion:"none"}))}).then(function(l){jr.add(t,l),e&&e(l),s.manager.itemEnd(t)}).catch(function(l){r&&r(l),s.manager.itemError(t),s.manager.itemEnd(t)}),s.manager.itemStart(t)}};Nh.prototype.isImageBitmapLoader=!0;var Ja,hT={getContext:function(){return Ja===void 0&&(Ja=new(window.AudioContext||window.webkitAudioContext)),Ja},setContext:function(n){Ja=n}},Fh=class extends mn{constructor(t){super(t)}load(t,e,i,r){let s=this,o=new bh(this.manager);o.setResponseType("arraybuffer"),o.setPath(this.path),o.setRequestHeader(this.requestHeader),o.setWithCredentials(this.withCredentials),o.load(t,function(a){try{let l=a.slice(0);hT.getContext().decodeAudioData(l,function(u){e(u)})}catch(l){r?r(l):console.error(l),s.manager.itemError(t)}},i,r)}},zh=class extends Eo{constructor(t,e,i=1){super(void 0,i);let r=new ft().set(t),s=new ft().set(e),o=new T(r.r,r.g,r.b),a=new T(s.r,s.g,s.b),l=Math.sqrt(Math.PI),c=l*Math.sqrt(.75);this.sh.coefficients[0].copy(o).add(a).multiplyScalar(l),this.sh.coefficients[1].copy(o).sub(a).multiplyScalar(c)}};zh.prototype.isHemisphereLightProbe=!0;var Uh=class extends Eo{constructor(t,e=1){super(void 0,e);let i=new ft().set(t);this.sh.coefficients[0].set(i.r,i.g,i.b).multiplyScalar(2*Math.sqrt(Math.PI))}};Uh.prototype.isAmbientLightProbe=!0;var Bh=class extends kt{constructor(t){super(),this.type="Audio",this.listener=t,this.context=t.context,this.gain=this.context.createGain(),this.gain.connect(t.getInput()),this.autoplay=!1,this.buffer=null,this.detune=0,this.loop=!1,this.loopStart=0,this.loopEnd=0,this.offset=0,this.duration=void 0,this.playbackRate=1,this.isPlaying=!1,this.hasPlaybackControl=!0,this.source=null,this.sourceType="empty",this._startedAt=0,this._progress=0,this._connected=!1,this.filters=[]}getOutput(){return this.gain}setNodeSource(t){return this.hasPlaybackControl=!1,this.sourceType="audioNode",this.source=t,this.connect(),this}setMediaElementSource(t){return this.hasPlaybackControl=!1,this.sourceType="mediaNode",this.source=this.context.createMediaElementSource(t),this.connect(),this}setMediaStreamSource(t){return this.hasPlaybackControl=!1,this.sourceType="mediaStreamNode",this.source=this.context.createMediaStreamSource(t),this.connect(),this}setBuffer(t){return this.buffer=t,this.sourceType="buffer",this.autoplay&&this.play(),this}play(t=0){if(this.isPlaying===!0){console.warn("THREE.Audio: Audio is already playing.");return}if(this.hasPlaybackControl===!1){console.warn("THREE.Audio: this Audio has no playback control.");return}this._startedAt=this.context.currentTime+t;let e=this.context.createBufferSource();return e.buffer=this.buffer,e.loop=this.loop,e.loopStart=this.loopStart,e.loopEnd=this.loopEnd,e.onended=this.onEnded.bind(this),e.start(this._startedAt,this._progress+this.offset,this.duration),this.isPlaying=!0,this.source=e,this.setDetune(this.detune),this.setPlaybackRate(this.playbackRate),this.connect()}pause(){if(this.hasPlaybackControl===!1){console.warn("THREE.Audio: this Audio has no playback control.");return}return this.isPlaying===!0&&(this._progress+=Math.max(this.context.currentTime-this._startedAt,0)*this.playbackRate,this.loop===!0&&(this._progress=this._progress%(this.duration||this.buffer.duration)),this.source.stop(),this.source.onended=null,this.isPlaying=!1),this}stop(){if(this.hasPlaybackControl===!1){console.warn("THREE.Audio: this Audio has no playback control.");return}return this._progress=0,this.source.stop(),this.source.onended=null,this.isPlaying=!1,this}connect(){if(this.filters.length>0){this.source.connect(this.filters[0]);for(let t=1,e=this.filters.length;t<e;t++)this.filters[t-1].connect(this.filters[t]);this.filters[this.filters.length-1].connect(this.getOutput())}else this.source.connect(this.getOutput());return this._connected=!0,this}disconnect(){if(this.filters.length>0){this.source.disconnect(this.filters[0]);for(let t=1,e=this.filters.length;t<e;t++)this.filters[t-1].disconnect(this.filters[t]);this.filters[this.filters.length-1].disconnect(this.getOutput())}else this.source.disconnect(this.getOutput());return this._connected=!1,this}getFilters(){return this.filters}setFilters(t){return t||(t=[]),this._connected===!0?(this.disconnect(),this.filters=t.slice(),this.connect()):this.filters=t.slice(),this}setDetune(t){if(this.detune=t,this.source.detune!==void 0)return this.isPlaying===!0&&this.source.detune.setTargetAtTime(this.detune,this.context.currentTime,.01),this}getDetune(){return this.detune}getFilter(){return this.getFilters()[0]}setFilter(t){return this.setFilters(t?[t]:[])}setPlaybackRate(t){if(this.hasPlaybackControl===!1){console.warn("THREE.Audio: this Audio has no playback control.");return}return this.playbackRate=t,this.isPlaying===!0&&this.source.playbackRate.setTargetAtTime(this.playbackRate,this.context.currentTime,.01),this}getPlaybackRate(){return this.playbackRate}onEnded(){this.isPlaying=!1}getLoop(){return this.hasPlaybackControl===!1?(console.warn("THREE.Audio: this Audio has no playback control."),!1):this.loop}setLoop(t){if(this.hasPlaybackControl===!1){console.warn("THREE.Audio: this Audio has no playback control.");return}return this.loop=t,this.isPlaying===!0&&(this.source.loop=this.loop),this}setLoopStart(t){return this.loopStart=t,this}setLoopEnd(t){return this.loopEnd=t,this}getVolume(){return this.gain.gain.value}setVolume(t){return this.gain.gain.setTargetAtTime(t,this.context.currentTime,.01),this}};var Oh=class{constructor(t,e=2048){this.analyser=t.context.createAnalyser(),this.analyser.fftSize=e,this.data=new Uint8Array(this.analyser.frequencyBinCount),t.getOutput().connect(this.analyser)}getFrequencyData(){return this.analyser.getByteFrequencyData(this.data),this.data}getAverageFrequency(){let t=0,e=this.getFrequencyData();for(let i=0;i<e.length;i++)t+=e[i];return t/e.length}},kh=class{constructor(t,e,i){this.binding=t,this.valueSize=i;let r,s,o;switch(e){case"quaternion":r=this._slerp,s=this._slerpAdditive,o=this._setAdditiveIdentityQuaternion,this.buffer=new Float64Array(i*6),this._workIndex=5;break;case"string":case"bool":r=this._select,s=this._select,o=this._setAdditiveIdentityOther,this.buffer=new Array(i*5);break;default:r=this._lerp,s=this._lerpAdditive,o=this._setAdditiveIdentityNumeric,this.buffer=new Float64Array(i*5)}this._mixBufferRegion=r,this._mixBufferRegionAdditive=s,this._setIdentity=o,this._origIndex=3,this._addIndex=4,this.cumulativeWeight=0,this.cumulativeWeightAdditive=0,this.useCount=0,this.referenceCount=0}accumulate(t,e){let i=this.buffer,r=this.valueSize,s=t*r+r,o=this.cumulativeWeight;if(o===0){for(let a=0;a!==r;++a)i[s+a]=i[a];o=e}else{o+=e;let a=e/o;this._mixBufferRegion(i,s,0,a,r)}this.cumulativeWeight=o}accumulateAdditive(t){let e=this.buffer,i=this.valueSize,r=i*this._addIndex;this.cumulativeWeightAdditive===0&&this._setIdentity(),this._mixBufferRegionAdditive(e,r,0,t,i),this.cumulativeWeightAdditive+=t}apply(t){let e=this.valueSize,i=this.buffer,r=t*e+e,s=this.cumulativeWeight,o=this.cumulativeWeightAdditive,a=this.binding;if(this.cumulativeWeight=0,this.cumulativeWeightAdditive=0,s<1){let l=e*this._origIndex;this._mixBufferRegion(i,r,l,1-s,e)}o>0&&this._mixBufferRegionAdditive(i,r,this._addIndex*e,1,e);for(let l=e,c=e+e;l!==c;++l)if(i[l]!==i[l+e]){a.setValue(i,r);break}}saveOriginalState(){let t=this.binding,e=this.buffer,i=this.valueSize,r=i*this._origIndex;t.getValue(e,r);for(let s=i,o=r;s!==o;++s)e[s]=e[r+s%i];this._setIdentity(),this.cumulativeWeight=0,this.cumulativeWeightAdditive=0}restoreOriginalState(){let t=this.valueSize*3;this.binding.setValue(this.buffer,t)}_setAdditiveIdentityNumeric(){let t=this._addIndex*this.valueSize,e=t+this.valueSize;for(let i=t;i<e;i++)this.buffer[i]=0}_setAdditiveIdentityQuaternion(){this._setAdditiveIdentityNumeric(),this.buffer[this._addIndex*this.valueSize+3]=1}_setAdditiveIdentityOther(){let t=this._origIndex*this.valueSize,e=this._addIndex*this.valueSize;for(let i=0;i<this.valueSize;i++)this.buffer[e+i]=this.buffer[t+i]}_select(t,e,i,r,s){if(r>=.5)for(let o=0;o!==s;++o)t[e+o]=t[i+o]}_slerp(t,e,i,r){Ee.slerpFlat(t,e,t,e,t,i,r)}_slerpAdditive(t,e,i,r,s){let o=this._workIndex*s;Ee.multiplyQuaternionsFlat(t,o,t,e,t,i),Ee.slerpFlat(t,e,t,e,t,o,r)}_lerp(t,e,i,r,s){let o=1-r;for(let a=0;a!==s;++a){let l=e+a;t[l]=t[l]*o+t[i+a]*r}}_lerpAdditive(t,e,i,r,s){for(let o=0;o!==s;++o){let a=e+o;t[a]=t[a]+t[i+o]*r}}},ef="\\[\\]\\.:\\/",fT=new RegExp("["+ef+"]","g"),nf="[^"+ef+"]",dT="[^"+ef.replace("\\.","")+"]",pT=/((?:WC+[\/:])*)/.source.replace("WC",nf),mT=/(WCOD+)?/.source.replace("WCOD",dT),gT=/(?:\.(WC+)(?:\[(.+)\])?)?/.source.replace("WC",nf),xT=/\.(WC+)(?:\[(.+)\])?/.source.replace("WC",nf),yT=new RegExp("^"+pT+mT+gT+xT+"$"),vT=["material","materials","bones"],Hh=class{constructor(t,e,i){let r=i||Nt.parseTrackName(e);this._targetGroup=t,this._bindings=t.subscribe_(e,r)}getValue(t,e){this.bind();let i=this._targetGroup.nCachedObjects_,r=this._bindings[i];r!==void 0&&r.getValue(t,e)}setValue(t,e){let i=this._bindings;for(let r=this._targetGroup.nCachedObjects_,s=i.length;r!==s;++r)i[r].setValue(t,e)}bind(){let t=this._bindings;for(let e=this._targetGroup.nCachedObjects_,i=t.length;e!==i;++e)t[e].bind()}unbind(){let t=this._bindings;for(let e=this._targetGroup.nCachedObjects_,i=t.length;e!==i;++e)t[e].unbind()}},Nt=class{constructor(t,e,i){this.path=e,this.parsedPath=i||Nt.parseTrackName(e),this.node=Nt.findNode(t,this.parsedPath.nodeName)||t,this.rootNode=t,this.getValue=this._getValue_unbound,this.setValue=this._setValue_unbound}static create(t,e,i){return t&&t.isAnimationObjectGroup?new Nt.Composite(t,e,i):new Nt(t,e,i)}static sanitizeNodeName(t){return t.replace(/\s/g,"_").replace(fT,"")}static parseTrackName(t){let e=yT.exec(t);if(!e)throw new Error("PropertyBinding: Cannot parse trackName: "+t);let i={nodeName:e[2],objectName:e[3],objectIndex:e[4],propertyName:e[5],propertyIndex:e[6]},r=i.nodeName&&i.nodeName.lastIndexOf(".");if(r!==void 0&&r!==-1){let s=i.nodeName.substring(r+1);vT.indexOf(s)!==-1&&(i.nodeName=i.nodeName.substring(0,r),i.objectName=s)}if(i.propertyName===null||i.propertyName.length===0)throw new Error("PropertyBinding: can not parse propertyName from trackName: "+t);return i}static findNode(t,e){if(!e||e===""||e==="."||e===-1||e===t.name||e===t.uuid)return t;if(t.skeleton){let i=t.skeleton.getBoneByName(e);if(i!==void 0)return i}if(t.children){let i=function(s){for(let o=0;o<s.length;o++){let a=s[o];if(a.name===e||a.uuid===e)return a;let l=i(a.children);if(l)return l}return null},r=i(t.children);if(r)return r}return null}_getValue_unavailable(){}_setValue_unavailable(){}_getValue_direct(t,e){t[e]=this.targetObject[this.propertyName]}_getValue_array(t,e){let i=this.resolvedProperty;for(let r=0,s=i.length;r!==s;++r)t[e++]=i[r]}_getValue_arrayElement(t,e){t[e]=this.resolvedProperty[this.propertyIndex]}_getValue_toArray(t,e){this.resolvedProperty.toArray(t,e)}_setValue_direct(t,e){this.targetObject[this.propertyName]=t[e]}_setValue_direct_setNeedsUpdate(t,e){this.targetObject[this.propertyName]=t[e],this.targetObject.needsUpdate=!0}_setValue_direct_setMatrixWorldNeedsUpdate(t,e){this.targetObject[this.propertyName]=t[e],this.targetObject.matrixWorldNeedsUpdate=!0}_setValue_array(t,e){let i=this.resolvedProperty;for(let r=0,s=i.length;r!==s;++r)i[r]=t[e++]}_setValue_array_setNeedsUpdate(t,e){let i=this.resolvedProperty;for(let r=0,s=i.length;r!==s;++r)i[r]=t[e++];this.targetObject.needsUpdate=!0}_setValue_array_setMatrixWorldNeedsUpdate(t,e){let i=this.resolvedProperty;for(let r=0,s=i.length;r!==s;++r)i[r]=t[e++];this.targetObject.matrixWorldNeedsUpdate=!0}_setValue_arrayElement(t,e){this.resolvedProperty[this.propertyIndex]=t[e]}_setValue_arrayElement_setNeedsUpdate(t,e){this.resolvedProperty[this.propertyIndex]=t[e],this.targetObject.needsUpdate=!0}_setValue_arrayElement_setMatrixWorldNeedsUpdate(t,e){this.resolvedProperty[this.propertyIndex]=t[e],this.targetObject.matrixWorldNeedsUpdate=!0}_setValue_fromArray(t,e){this.resolvedProperty.fromArray(t,e)}_setValue_fromArray_setNeedsUpdate(t,e){this.resolvedProperty.fromArray(t,e),this.targetObject.needsUpdate=!0}_setValue_fromArray_setMatrixWorldNeedsUpdate(t,e){this.resolvedProperty.fromArray(t,e),this.targetObject.matrixWorldNeedsUpdate=!0}_getValue_unbound(t,e){this.bind(),this.getValue(t,e)}_setValue_unbound(t,e){this.bind(),this.setValue(t,e)}bind(){let t=this.node,e=this.parsedPath,i=e.objectName,r=e.propertyName,s=e.propertyIndex;if(t||(t=Nt.findNode(this.rootNode,e.nodeName)||this.rootNode,this.node=t),this.getValue=this._getValue_unavailable,this.setValue=this._setValue_unavailable,!t){console.error("THREE.PropertyBinding: Trying to update node for track: "+this.path+" but it wasn't found.");return}if(i){let c=e.objectIndex;switch(i){case"materials":if(!t.material){console.error("THREE.PropertyBinding: Can not bind to material as node does not have a material.",this);return}if(!t.material.materials){console.error("THREE.PropertyBinding: Can not bind to material.materials as node.material does not have a materials array.",this);return}t=t.material.materials;break;case"bones":if(!t.skeleton){console.error("THREE.PropertyBinding: Can not bind to bones as node does not have a skeleton.",this);return}t=t.skeleton.bones;for(let u=0;u<t.length;u++)if(t[u].name===c){c=u;break}break;default:if(t[i]===void 0){console.error("THREE.PropertyBinding: Can not bind to objectName of node undefined.",this);return}t=t[i]}if(c!==void 0){if(t[c]===void 0){console.error("THREE.PropertyBinding: Trying to bind to objectIndex of objectName, but is undefined.",this,t);return}t=t[c]}}let o=t[r];if(o===void 0){let c=e.nodeName;console.error("THREE.PropertyBinding: Trying to update property for track: "+c+"."+r+" but it wasn't found.",t);return}let a=this.Versioning.None;this.targetObject=t,t.needsUpdate!==void 0?a=this.Versioning.NeedsUpdate:t.matrixWorldNeedsUpdate!==void 0&&(a=this.Versioning.MatrixWorldNeedsUpdate);let l=this.BindingType.Direct;if(s!==void 0){if(r==="morphTargetInfluences"){if(!t.geometry){console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.",this);return}if(t.geometry.isBufferGeometry){if(!t.geometry.morphAttributes){console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.morphAttributes.",this);return}t.morphTargetDictionary[s]!==void 0&&(s=t.morphTargetDictionary[s])}else{console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences on THREE.Geometry. Use THREE.BufferGeometry instead.",this);return}}l=this.BindingType.ArrayElement,this.resolvedProperty=o,this.propertyIndex=s}else o.fromArray!==void 0&&o.toArray!==void 0?(l=this.BindingType.HasFromToArray,this.resolvedProperty=o):Array.isArray(o)?(l=this.BindingType.EntireArray,this.resolvedProperty=o):this.propertyName=r;this.getValue=this.GetterByBindingType[l],this.setValue=this.SetterByBindingTypeAndVersioning[l][a]}unbind(){this.node=null,this.getValue=this._getValue_unbound,this.setValue=this._setValue_unbound}};Nt.Composite=Hh;Nt.prototype.BindingType={Direct:0,EntireArray:1,ArrayElement:2,HasFromToArray:3};Nt.prototype.Versioning={None:0,NeedsUpdate:1,MatrixWorldNeedsUpdate:2};Nt.prototype.GetterByBindingType=[Nt.prototype._getValue_direct,Nt.prototype._getValue_array,Nt.prototype._getValue_arrayElement,Nt.prototype._getValue_toArray];Nt.prototype.SetterByBindingTypeAndVersioning=[[Nt.prototype._setValue_direct,Nt.prototype._setValue_direct_setNeedsUpdate,Nt.prototype._setValue_direct_setMatrixWorldNeedsUpdate],[Nt.prototype._setValue_array,Nt.prototype._setValue_array_setNeedsUpdate,Nt.prototype._setValue_array_setMatrixWorldNeedsUpdate],[Nt.prototype._setValue_arrayElement,Nt.prototype._setValue_arrayElement_setNeedsUpdate,Nt.prototype._setValue_arrayElement_setMatrixWorldNeedsUpdate],[Nt.prototype._setValue_fromArray,Nt.prototype._setValue_fromArray_setNeedsUpdate,Nt.prototype._setValue_fromArray_setMatrixWorldNeedsUpdate]];var Vh=class{constructor(){this.uuid=tn(),this._objects=Array.prototype.slice.call(arguments),this.nCachedObjects_=0;let t={};this._indicesByUUID=t;for(let i=0,r=arguments.length;i!==r;++i)t[arguments[i].uuid]=i;this._paths=[],this._parsedPaths=[],this._bindings=[],this._bindingsIndicesByPath={};let e=this;this.stats={objects:{get total(){return e._objects.length},get inUse(){return this.total-e.nCachedObjects_}},get bindingsPerObject(){return e._bindings.length}}}add(){let t=this._objects,e=this._indicesByUUID,i=this._paths,r=this._parsedPaths,s=this._bindings,o=s.length,a,l=t.length,c=this.nCachedObjects_;for(let u=0,h=arguments.length;u!==h;++u){let f=arguments[u],d=f.uuid,g=e[d];if(g===void 0){g=l++,e[d]=g,t.push(f);for(let x=0,v=o;x!==v;++x)s[x].push(new Nt(f,i[x],r[x]))}else if(g<c){a=t[g];let x=--c,v=t[x];e[v.uuid]=g,t[g]=v,e[d]=x,t[x]=f;for(let m=0,p=o;m!==p;++m){let b=s[m],_=b[x],S=b[g];b[g]=_,S===void 0&&(S=new Nt(f,i[m],r[m])),b[x]=S}}else t[g]!==a&&console.error("THREE.AnimationObjectGroup: Different objects with the same UUID detected. Clean the caches or recreate your infrastructure when reloading scenes.")}this.nCachedObjects_=c}remove(){let t=this._objects,e=this._indicesByUUID,i=this._bindings,r=i.length,s=this.nCachedObjects_;for(let o=0,a=arguments.length;o!==a;++o){let l=arguments[o],c=l.uuid,u=e[c];if(u!==void 0&&u>=s){let h=s++,f=t[h];e[f.uuid]=u,t[u]=f,e[c]=h,t[h]=l;for(let d=0,g=r;d!==g;++d){let x=i[d],v=x[h],m=x[u];x[u]=v,x[h]=m}}}this.nCachedObjects_=s}uncache(){let t=this._objects,e=this._indicesByUUID,i=this._bindings,r=i.length,s=this.nCachedObjects_,o=t.length;for(let a=0,l=arguments.length;a!==l;++a){let c=arguments[a],u=c.uuid,h=e[u];if(h!==void 0)if(delete e[u],h<s){let f=--s,d=t[f],g=--o,x=t[g];e[d.uuid]=h,t[h]=d,e[x.uuid]=f,t[f]=x,t.pop();for(let v=0,m=r;v!==m;++v){let p=i[v],b=p[f],_=p[g];p[h]=b,p[f]=_,p.pop()}}else{let f=--o,d=t[f];f>0&&(e[d.uuid]=h),t[h]=d,t.pop();for(let g=0,x=r;g!==x;++g){let v=i[g];v[h]=v[f],v.pop()}}}this.nCachedObjects_=s}subscribe_(t,e){let i=this._bindingsIndicesByPath,r=i[t],s=this._bindings;if(r!==void 0)return s[r];let o=this._paths,a=this._parsedPaths,l=this._objects,c=l.length,u=this.nCachedObjects_,h=new Array(c);r=s.length,i[t]=r,o.push(t),a.push(e),s.push(h);for(let f=u,d=l.length;f!==d;++f){let g=l[f];h[f]=new Nt(g,t,e)}return h}unsubscribe_(t){let e=this._bindingsIndicesByPath,i=e[t];if(i!==void 0){let r=this._paths,s=this._parsedPaths,o=this._bindings,a=o.length-1,l=o[a],c=t[a];e[c]=i,o[i]=l,o.pop(),s[i]=s[a],s.pop(),r[i]=r[a],r.pop()}}};Vh.prototype.isAnimationObjectGroup=!0;var Gh=class{constructor(t,e,i=null,r=e.blendMode){this._mixer=t,this._clip=e,this._localRoot=i,this.blendMode=r;let s=e.tracks,o=s.length,a=new Array(o),l={endingStart:Nr,endingEnd:Nr};for(let c=0;c!==o;++c){let u=s[c].createInterpolant(null);a[c]=u,u.settings=l}this._interpolantSettings=l,this._interpolants=a,this._propertyBindings=new Array(o),this._cacheIndex=null,this._byClipCacheIndex=null,this._timeScaleInterpolant=null,this._weightInterpolant=null,this.loop=Zw,this._loopCount=-1,this._startTime=null,this.time=0,this.timeScale=1,this._effectiveTimeScale=1,this.weight=1,this._effectiveWeight=1,this.repetitions=1/0,this.paused=!1,this.enabled=!0,this.clampWhenFinished=!1,this.zeroSlopeAtStart=!0,this.zeroSlopeAtEnd=!0}play(){return this._mixer._activateAction(this),this}stop(){return this._mixer._deactivateAction(this),this.reset()}reset(){return this.paused=!1,this.enabled=!0,this.time=0,this._loopCount=-1,this._startTime=null,this.stopFading().stopWarping()}isRunning(){return this.enabled&&!this.paused&&this.timeScale!==0&&this._startTime===null&&this._mixer._isActiveAction(this)}isScheduled(){return this._mixer._isActiveAction(this)}startAt(t){return this._startTime=t,this}setLoop(t,e){return this.loop=t,this.repetitions=e,this}setEffectiveWeight(t){return this.weight=t,this._effectiveWeight=this.enabled?t:0,this.stopFading()}getEffectiveWeight(){return this._effectiveWeight}fadeIn(t){return this._scheduleFading(t,0,1)}fadeOut(t){return this._scheduleFading(t,1,0)}crossFadeFrom(t,e,i){if(t.fadeOut(e),this.fadeIn(e),i){let r=this._clip.duration,s=t._clip.duration,o=s/r,a=r/s;t.warp(1,o,e),this.warp(a,1,e)}return this}crossFadeTo(t,e,i){return t.crossFadeFrom(this,e,i)}stopFading(){let t=this._weightInterpolant;return t!==null&&(this._weightInterpolant=null,this._mixer._takeBackControlInterpolant(t)),this}setEffectiveTimeScale(t){return this.timeScale=t,this._effectiveTimeScale=this.paused?0:t,this.stopWarping()}getEffectiveTimeScale(){return this._effectiveTimeScale}setDuration(t){return this.timeScale=this._clip.duration/t,this.stopWarping()}syncWith(t){return this.time=t.time,this.timeScale=t.timeScale,this.stopWarping()}halt(t){return this.warp(this._effectiveTimeScale,0,t)}warp(t,e,i){let r=this._mixer,s=r.time,o=this.timeScale,a=this._timeScaleInterpolant;a===null&&(a=r._lendControlInterpolant(),this._timeScaleInterpolant=a);let l=a.parameterPositions,c=a.sampleValues;return l[0]=s,l[1]=s+i,c[0]=t/o,c[1]=e/o,this}stopWarping(){let t=this._timeScaleInterpolant;return t!==null&&(this._timeScaleInterpolant=null,this._mixer._takeBackControlInterpolant(t)),this}getMixer(){return this._mixer}getClip(){return this._clip}getRoot(){return this._localRoot||this._mixer._root}_update(t,e,i,r){if(!this.enabled){this._updateWeight(t);return}let s=this._startTime;if(s!==null){let l=(t-s)*i;if(l<0||i===0)return;this._startTime=null,e=i*l}e*=this._updateTimeScale(t);let o=this._updateTime(e),a=this._updateWeight(t);if(a>0){let l=this._interpolants,c=this._propertyBindings;switch(this.blendMode){case d0:for(let u=0,h=l.length;u!==h;++u)l[u].evaluate(o),c[u].accumulateAdditive(a);break;case Qh:default:for(let u=0,h=l.length;u!==h;++u)l[u].evaluate(o),c[u].accumulate(r,a)}}}_updateWeight(t){let e=0;if(this.enabled){e=this.weight;let i=this._weightInterpolant;if(i!==null){let r=i.evaluate(t)[0];e*=r,t>i.parameterPositions[1]&&(this.stopFading(),r===0&&(this.enabled=!1))}}return this._effectiveWeight=e,e}_updateTimeScale(t){let e=0;if(!this.paused){e=this.timeScale;let i=this._timeScaleInterpolant;i!==null&&(e*=i.evaluate(t)[0],t>i.parameterPositions[1]&&(this.stopWarping(),e===0?this.paused=!0:this.timeScale=e))}return this._effectiveTimeScale=e,e}_updateTime(t){let e=this._clip.duration,i=this.loop,r=this.time+t,s=this._loopCount,o=i===Jw;if(t===0)return s===-1?r:o&&(s&1)===1?e-r:r;if(i===Yw){s===-1&&(this._loopCount=0,this._setEndings(!0,!0,!1));t:{if(r>=e)r=e;else if(r<0)r=0;else{this.time=r;break t}this.clampWhenFinished?this.paused=!0:this.enabled=!1,this.time=r,this._mixer.dispatchEvent({type:"finished",action:this,direction:t<0?-1:1})}}else{if(s===-1&&(t>=0?(s=0,this._setEndings(!0,this.repetitions===0,o)):this._setEndings(this.repetitions===0,!0,o)),r>=e||r<0){let a=Math.floor(r/e);r-=e*a,s+=Math.abs(a);let l=this.repetitions-s;if(l<=0)this.clampWhenFinished?this.paused=!0:this.enabled=!1,r=t>0?e:0,this.time=r,this._mixer.dispatchEvent({type:"finished",action:this,direction:t>0?1:-1});else{if(l===1){let c=t<0;this._setEndings(c,!c,o)}else this._setEndings(!1,!1,o);this._loopCount=s,this.time=r,this._mixer.dispatchEvent({type:"loop",action:this,loopDelta:a})}}else this.time=r;if(o&&(s&1)===1)return e-r}return r}_setEndings(t,e,i){let r=this._interpolantSettings;i?(r.endingStart=Fr,r.endingEnd=Fr):(t?r.endingStart=this.zeroSlopeAtStart?Fr:Nr:r.endingStart=el,e?r.endingEnd=this.zeroSlopeAtEnd?Fr:Nr:r.endingEnd=el)}_scheduleFading(t,e,i){let r=this._mixer,s=r.time,o=this._weightInterpolant;o===null&&(o=r._lendControlInterpolant(),this._weightInterpolant=o);let a=o.parameterPositions,l=o.sampleValues;return a[0]=s,l[0]=e,a[1]=s+t,l[1]=i,this}},Wh=class extends In{constructor(t){super(),this._root=t,this._initMemoryManager(),this._accuIndex=0,this.time=0,this.timeScale=1}_bindAction(t,e){let i=t._localRoot||this._root,r=t._clip.tracks,s=r.length,o=t._propertyBindings,a=t._interpolants,l=i.uuid,c=this._bindingsByRootAndName,u=c[l];u===void 0&&(u={},c[l]=u);for(let h=0;h!==s;++h){let f=r[h],d=f.name,g=u[d];if(g!==void 0)++g.referenceCount,o[h]=g;else{if(g=o[h],g!==void 0){g._cacheIndex===null&&(++g.referenceCount,this._addInactiveBinding(g,l,d));continue}let x=e&&e._propertyBindings[h].binding.parsedPath;g=new kh(Nt.create(i,d,x),f.ValueTypeName,f.getValueSize()),++g.referenceCount,this._addInactiveBinding(g,l,d),o[h]=g}a[h].resultBuffer=g.buffer}}_activateAction(t){if(!this._isActiveAction(t)){if(t._cacheIndex===null){let i=(t._localRoot||this._root).uuid,r=t._clip.uuid,s=this._actionsByClip[r];this._bindAction(t,s&&s.knownActions[0]),this._addInactiveAction(t,r,i)}let e=t._propertyBindings;for(let i=0,r=e.length;i!==r;++i){let s=e[i];s.useCount++===0&&(this._lendBinding(s),s.saveOriginalState())}this._lendAction(t)}}_deactivateAction(t){if(this._isActiveAction(t)){let e=t._propertyBindings;for(let i=0,r=e.length;i!==r;++i){let s=e[i];--s.useCount===0&&(s.restoreOriginalState(),this._takeBackBinding(s))}this._takeBackAction(t)}}_initMemoryManager(){this._actions=[],this._nActiveActions=0,this._actionsByClip={},this._bindings=[],this._nActiveBindings=0,this._bindingsByRootAndName={},this._controlInterpolants=[],this._nActiveControlInterpolants=0;let t=this;this.stats={actions:{get total(){return t._actions.length},get inUse(){return t._nActiveActions}},bindings:{get total(){return t._bindings.length},get inUse(){return t._nActiveBindings}},controlInterpolants:{get total(){return t._controlInterpolants.length},get inUse(){return t._nActiveControlInterpolants}}}}_isActiveAction(t){let e=t._cacheIndex;return e!==null&&e<this._nActiveActions}_addInactiveAction(t,e,i){let r=this._actions,s=this._actionsByClip,o=s[e];if(o===void 0)o={knownActions:[t],actionByRoot:{}},t._byClipCacheIndex=0,s[e]=o;else{let a=o.knownActions;t._byClipCacheIndex=a.length,a.push(t)}t._cacheIndex=r.length,r.push(t),o.actionByRoot[i]=t}_removeInactiveAction(t){let e=this._actions,i=e[e.length-1],r=t._cacheIndex;i._cacheIndex=r,e[r]=i,e.pop(),t._cacheIndex=null;let s=t._clip.uuid,o=this._actionsByClip,a=o[s],l=a.knownActions,c=l[l.length-1],u=t._byClipCacheIndex;c._byClipCacheIndex=u,l[u]=c,l.pop(),t._byClipCacheIndex=null;let h=a.actionByRoot,f=(t._localRoot||this._root).uuid;delete h[f],l.length===0&&delete o[s],this._removeInactiveBindingsForAction(t)}_removeInactiveBindingsForAction(t){let e=t._propertyBindings;for(let i=0,r=e.length;i!==r;++i){let s=e[i];--s.referenceCount===0&&this._removeInactiveBinding(s)}}_lendAction(t){let e=this._actions,i=t._cacheIndex,r=this._nActiveActions++,s=e[r];t._cacheIndex=r,e[r]=t,s._cacheIndex=i,e[i]=s}_takeBackAction(t){let e=this._actions,i=t._cacheIndex,r=--this._nActiveActions,s=e[r];t._cacheIndex=r,e[r]=t,s._cacheIndex=i,e[i]=s}_addInactiveBinding(t,e,i){let r=this._bindingsByRootAndName,s=this._bindings,o=r[e];o===void 0&&(o={},r[e]=o),o[i]=t,t._cacheIndex=s.length,s.push(t)}_removeInactiveBinding(t){let e=this._bindings,i=t.binding,r=i.rootNode.uuid,s=i.path,o=this._bindingsByRootAndName,a=o[r],l=e[e.length-1],c=t._cacheIndex;l._cacheIndex=c,e[c]=l,e.pop(),delete a[s],Object.keys(a).length===0&&delete o[r]}_lendBinding(t){let e=this._bindings,i=t._cacheIndex,r=this._nActiveBindings++,s=e[r];t._cacheIndex=r,e[r]=t,s._cacheIndex=i,e[i]=s}_takeBackBinding(t){let e=this._bindings,i=t._cacheIndex,r=--this._nActiveBindings,s=e[r];t._cacheIndex=r,e[r]=t,s._cacheIndex=i,e[i]=s}_lendControlInterpolant(){let t=this._controlInterpolants,e=this._nActiveControlInterpolants++,i=t[e];return i===void 0&&(i=new _l(new Float32Array(2),new Float32Array(2),1,this._controlInterpolantsResultBuffer),i.__cacheIndex=e,t[e]=i),i}_takeBackControlInterpolant(t){let e=this._controlInterpolants,i=t.__cacheIndex,r=--this._nActiveControlInterpolants,s=e[r];t.__cacheIndex=r,e[r]=t,s.__cacheIndex=i,e[i]=s}clipAction(t,e,i){let r=e||this._root,s=r.uuid,o=typeof t=="string"?Ml.findByName(r,t):t,a=o!==null?o.uuid:t,l=this._actionsByClip[a],c=null;if(i===void 0&&(o!==null?i=o.blendMode:i=Qh),l!==void 0){let h=l.actionByRoot[s];if(h!==void 0&&h.blendMode===i)return h;c=l.knownActions[0],o===null&&(o=c._clip)}if(o===null)return null;let u=new Gh(this,o,e,i);return this._bindAction(u,c),this._addInactiveAction(u,a,s),u}existingAction(t,e){let i=e||this._root,r=i.uuid,s=typeof t=="string"?Ml.findByName(i,t):t,o=s?s.uuid:t,a=this._actionsByClip[o];return a!==void 0&&a.actionByRoot[r]||null}stopAllAction(){let t=this._actions,e=this._nActiveActions;for(let i=e-1;i>=0;--i)t[i].stop();return this}update(t){t*=this.timeScale;let e=this._actions,i=this._nActiveActions,r=this.time+=t,s=Math.sign(t),o=this._accuIndex^=1;for(let c=0;c!==i;++c)e[c]._update(r,t,s,o);let a=this._bindings,l=this._nActiveBindings;for(let c=0;c!==l;++c)a[c].apply(o);return this}setTime(t){this.time=0;for(let e=0;e<this._actions.length;e++)this._actions[e].time=0;return this.update(t)}getRoot(){return this._root}uncacheClip(t){let e=this._actions,i=t.uuid,r=this._actionsByClip,s=r[i];if(s!==void 0){let o=s.knownActions;for(let a=0,l=o.length;a!==l;++a){let c=o[a];this._deactivateAction(c);let u=c._cacheIndex,h=e[e.length-1];c._cacheIndex=null,c._byClipCacheIndex=null,h._cacheIndex=u,e[u]=h,e.pop(),this._removeInactiveBindingsForAction(c)}delete r[i]}}uncacheRoot(t){let e=t.uuid,i=this._actionsByClip;for(let o in i){let a=i[o].actionByRoot,l=a[e];l!==void 0&&(this._deactivateAction(l),this._removeInactiveAction(l))}let r=this._bindingsByRootAndName,s=r[e];if(s!==void 0)for(let o in s){let a=s[o];a.restoreOriginalState(),this._removeInactiveBinding(a)}}uncacheAction(t,e){let i=this.existingAction(t,e);i!==null&&(this._deactivateAction(i),this._removeInactiveAction(i))}};Wh.prototype._controlInterpolantsResultBuffer=new Float32Array(1);var To=class{constructor(t){typeof t=="string"&&(console.warn("THREE.Uniform: Type parameter is no longer needed."),t=arguments[1]),this.value=t}clone(){return new To(this.value.clone===void 0?this.value:this.value.clone())}},qh=class extends Gi{constructor(t,e,i=1){super(t,e),this.meshPerAttribute=i}copy(t){return super.copy(t),this.meshPerAttribute=t.meshPerAttribute,this}clone(t){let e=super.clone(t);return e.meshPerAttribute=this.meshPerAttribute,e}toJSON(t){let e=super.toJSON(t);return e.isInstancedInterleavedBuffer=!0,e.meshPerAttribute=this.meshPerAttribute,e}};qh.prototype.isInstancedInterleavedBuffer=!0;var Xh=class{constructor(t,e,i,r,s){this.buffer=t,this.type=e,this.itemSize=i,this.elementSize=r,this.count=s,this.version=0}set needsUpdate(t){t===!0&&this.version++}setBuffer(t){return this.buffer=t,this}setType(t,e){return this.type=t,this.elementSize=e,this}setItemSize(t){return this.itemSize=t,this}setCount(t){return this.count=t,this}};Xh.prototype.isGLBufferAttribute=!0;var o0=new K,Yi=class{constructor(t=new K(1/0,1/0),e=new K(-1/0,-1/0)){this.min=t,this.max=e}set(t,e){return this.min.copy(t),this.max.copy(e),this}setFromPoints(t){this.makeEmpty();for(let e=0,i=t.length;e<i;e++)this.expandByPoint(t[e]);return this}setFromCenterAndSize(t,e){let i=o0.copy(e).multiplyScalar(.5);return this.min.copy(t).sub(i),this.max.copy(t).add(i),this}clone(){return new this.constructor().copy(this)}copy(t){return this.min.copy(t.min),this.max.copy(t.max),this}makeEmpty(){return this.min.x=this.min.y=1/0,this.max.x=this.max.y=-1/0,this}isEmpty(){return this.max.x<this.min.x||this.max.y<this.min.y}getCenter(t){return this.isEmpty()?t.set(0,0):t.addVectors(this.min,this.max).multiplyScalar(.5)}getSize(t){return this.isEmpty()?t.set(0,0):t.subVectors(this.max,this.min)}expandByPoint(t){return this.min.min(t),this.max.max(t),this}expandByVector(t){return this.min.sub(t),this.max.add(t),this}expandByScalar(t){return this.min.addScalar(-t),this.max.addScalar(t),this}containsPoint(t){return!(t.x<this.min.x||t.x>this.max.x||t.y<this.min.y||t.y>this.max.y)}containsBox(t){return this.min.x<=t.min.x&&t.max.x<=this.max.x&&this.min.y<=t.min.y&&t.max.y<=this.max.y}getParameter(t,e){return e.set((t.x-this.min.x)/(this.max.x-this.min.x),(t.y-this.min.y)/(this.max.y-this.min.y))}intersectsBox(t){return!(t.max.x<this.min.x||t.min.x>this.max.x||t.max.y<this.min.y||t.min.y>this.max.y)}clampPoint(t,e){return e.copy(t).clamp(this.min,this.max)}distanceToPoint(t){return o0.copy(t).clamp(this.min,this.max).sub(t).length()}intersect(t){return this.min.max(t.min),this.max.min(t.max),this}union(t){return this.min.min(t.min),this.max.max(t.max),this}translate(t){return this.min.add(t),this.max.add(t),this}equals(t){return t.min.equals(this.min)&&t.max.equals(this.max)}};Yi.prototype.isBox2=!0;var a0=new T,$a=new T,Yh=class{constructor(t=new T,e=new T){this.start=t,this.end=e}set(t,e){return this.start.copy(t),this.end.copy(e),this}copy(t){return this.start.copy(t.start),this.end.copy(t.end),this}getCenter(t){return t.addVectors(this.start,this.end).multiplyScalar(.5)}delta(t){return t.subVectors(this.end,this.start)}distanceSq(){return this.start.distanceToSquared(this.end)}distance(){return this.start.distanceTo(this.end)}at(t,e){return this.delta(e).multiplyScalar(t).add(this.start)}closestPointToPointParameter(t,e){a0.subVectors(t,this.start),$a.subVectors(this.end,this.start);let i=$a.dot($a),s=$a.dot(a0)/i;return e&&(s=Ie(s,0,1)),s}closestPointToPoint(t,e,i){let r=this.closestPointToPointParameter(t,e);return this.delta(i).multiplyScalar(r).add(this.start)}applyMatrix4(t){return this.start.applyMatrix4(t),this.end.applyMatrix4(t),this}equals(t){return t.start.equals(this.start)&&t.end.equals(this.end)}clone(){return new this.constructor().copy(this)}};var Qn=new T,Ka=new wt,Fu=new wt,Zh=class extends go{constructor(t){let e=D0(t),i=new Ht,r=[],s=[],o=new ft(0,0,1),a=new ft(0,1,0);for(let c=0;c<e.length;c++){let u=e[c];u.parent&&u.parent.isBone&&(r.push(0,0,0),r.push(0,0,0),s.push(o.r,o.g,o.b),s.push(a.r,a.g,a.b))}i.setAttribute("position",new ee(r,3)),i.setAttribute("color",new ee(s,3));let l=new zn({vertexColors:!0,depthTest:!1,depthWrite:!1,toneMapped:!1,transparent:!0});super(i,l),this.type="SkeletonHelper",this.isSkeletonHelper=!0,this.root=t,this.bones=e,this.matrix=t.matrixWorld,this.matrixAutoUpdate=!1}updateMatrixWorld(t){let e=this.bones,i=this.geometry,r=i.getAttribute("position");Fu.copy(this.root.matrixWorld).invert();for(let s=0,o=0;s<e.length;s++){let a=e[s];a.parent&&a.parent.isBone&&(Ka.multiplyMatrices(Fu,a.matrixWorld),Qn.setFromMatrixPosition(Ka),r.setXYZ(o,Qn.x,Qn.y,Qn.z),Ka.multiplyMatrices(Fu,a.parent.matrixWorld),Qn.setFromMatrixPosition(Ka),r.setXYZ(o+1,Qn.x,Qn.y,Qn.z),o+=2)}i.getAttribute("position").needsUpdate=!0,super.updateMatrixWorld(t)}};function D0(n){let t=[];n&&n.isBone&&t.push(n);for(let e=0;e<n.children.length;e++)t.push.apply(t,D0(n.children[e]));return t}var Jh=class extends go{constructor(t=10,e=10,i=4473924,r=8947848){i=new ft(i),r=new ft(r);let s=e/2,o=t/e,a=t/2,l=[],c=[];for(let f=0,d=0,g=-a;f<=e;f++,g+=o){l.push(-a,0,g,a,0,g),l.push(g,0,-a,g,0,a);let x=f===s?i:r;x.toArray(c,d),d+=3,x.toArray(c,d),d+=3,x.toArray(c,d),d+=3,x.toArray(c,d),d+=3}let u=new Ht;u.setAttribute("position",new ee(l,3)),u.setAttribute("color",new ee(c,3));let h=new zn({vertexColors:!0,toneMapped:!1});super(u,h),this.type="GridHelper"}};var _T=new Float32Array(1),Ck=new Int32Array(_T.buffer);Fe.create=function(n,t){return console.log("THREE.Curve.create() has been deprecated"),n.prototype=Object.create(Fe.prototype),n.prototype.constructor=n,n.prototype.getPoint=t,n};_o.prototype.fromPoints=function(n){return console.warn("THREE.Path: .fromPoints() has been renamed to .setFromPoints()."),this.setFromPoints(n)};Jh.prototype.setColors=function(){console.error("THREE.GridHelper: setColors() has been deprecated, pass them in the constructor instead.")};Zh.prototype.update=function(){console.error("THREE.SkeletonHelper: update() no longer needs to be called.")};mn.prototype.extractUrlBase=function(n){return console.warn("THREE.Loader: .extractUrlBase() has been deprecated. Use THREE.LoaderUtils.extractUrlBase() instead."),Dh.extractUrlBase(n)};mn.Handlers={add:function(){console.error("THREE.Loader: Handlers.add() has been removed. Use LoadingManager.addHandler() instead.")},get:function(){console.error("THREE.Loader: Handlers.get() has been removed. Use LoadingManager.getHandler() instead.")}};Yi.prototype.center=function(n){return console.warn("THREE.Box2: .center() has been renamed to .getCenter()."),this.getCenter(n)};Yi.prototype.empty=function(){return console.warn("THREE.Box2: .empty() has been renamed to .isEmpty()."),this.isEmpty()};Yi.prototype.isIntersectionBox=function(n){return console.warn("THREE.Box2: .isIntersectionBox() has been renamed to .intersectsBox()."),this.intersectsBox(n)};Yi.prototype.size=function(n){return console.warn("THREE.Box2: .size() has been renamed to .getSize()."),this.getSize(n)};Ge.prototype.center=function(n){return console.warn("THREE.Box3: .center() has been renamed to .getCenter()."),this.getCenter(n)};Ge.prototype.empty=function(){return console.warn("THREE.Box3: .empty() has been renamed to .isEmpty()."),this.isEmpty()};Ge.prototype.isIntersectionBox=function(n){return console.warn("THREE.Box3: .isIntersectionBox() has been renamed to .intersectsBox()."),this.intersectsBox(n)};Ge.prototype.isIntersectionSphere=function(n){return console.warn("THREE.Box3: .isIntersectionSphere() has been renamed to .intersectsSphere()."),this.intersectsSphere(n)};Ge.prototype.size=function(n){return console.warn("THREE.Box3: .size() has been renamed to .getSize()."),this.getSize(n)};si.prototype.empty=function(){return console.warn("THREE.Sphere: .empty() has been renamed to .isEmpty()."),this.isEmpty()};qr.prototype.setFromMatrix=function(n){return console.warn("THREE.Frustum: .setFromMatrix() has been renamed to .setFromProjectionMatrix()."),this.setFromProjectionMatrix(n)};Yh.prototype.center=function(n){return console.warn("THREE.Line3: .center() has been renamed to .getCenter()."),this.getCenter(n)};de.prototype.flattenToArrayOffset=function(n,t){return console.warn("THREE.Matrix3: .flattenToArrayOffset() has been deprecated. Use .toArray() instead."),this.toArray(n,t)};de.prototype.multiplyVector3=function(n){return console.warn("THREE.Matrix3: .multiplyVector3() has been removed. Use vector.applyMatrix3( matrix ) instead."),n.applyMatrix3(this)};de.prototype.multiplyVector3Array=function(){console.error("THREE.Matrix3: .multiplyVector3Array() has been removed.")};de.prototype.applyToBufferAttribute=function(n){return console.warn("THREE.Matrix3: .applyToBufferAttribute() has been removed. Use attribute.applyMatrix3( matrix ) instead."),n.applyMatrix3(this)};de.prototype.applyToVector3Array=function(){console.error("THREE.Matrix3: .applyToVector3Array() has been removed.")};de.prototype.getInverse=function(n){return console.warn("THREE.Matrix3: .getInverse() has been removed. Use matrixInv.copy( matrix ).invert(); instead."),this.copy(n).invert()};wt.prototype.extractPosition=function(n){return console.warn("THREE.Matrix4: .extractPosition() has been renamed to .copyPosition()."),this.copyPosition(n)};wt.prototype.flattenToArrayOffset=function(n,t){return console.warn("THREE.Matrix4: .flattenToArrayOffset() has been deprecated. Use .toArray() instead."),this.toArray(n,t)};wt.prototype.getPosition=function(){return console.warn("THREE.Matrix4: .getPosition() has been removed. Use Vector3.setFromMatrixPosition( matrix ) instead."),new T().setFromMatrixColumn(this,3)};wt.prototype.setRotationFromQuaternion=function(n){return console.warn("THREE.Matrix4: .setRotationFromQuaternion() has been renamed to .makeRotationFromQuaternion()."),this.makeRotationFromQuaternion(n)};wt.prototype.multiplyToArray=function(){console.warn("THREE.Matrix4: .multiplyToArray() has been removed.")};wt.prototype.multiplyVector3=function(n){return console.warn("THREE.Matrix4: .multiplyVector3() has been removed. Use vector.applyMatrix4( matrix ) instead."),n.applyMatrix4(this)};wt.prototype.multiplyVector4=function(n){return console.warn("THREE.Matrix4: .multiplyVector4() has been removed. Use vector.applyMatrix4( matrix ) instead."),n.applyMatrix4(this)};wt.prototype.multiplyVector3Array=function(){console.error("THREE.Matrix4: .multiplyVector3Array() has been removed.")};wt.prototype.rotateAxis=function(n){console.warn("THREE.Matrix4: .rotateAxis() has been removed. Use Vector3.transformDirection( matrix ) instead."),n.transformDirection(this)};wt.prototype.crossVector=function(n){return console.warn("THREE.Matrix4: .crossVector() has been removed. Use vector.applyMatrix4( matrix ) instead."),n.applyMatrix4(this)};wt.prototype.translate=function(){console.error("THREE.Matrix4: .translate() has been removed.")};wt.prototype.rotateX=function(){console.error("THREE.Matrix4: .rotateX() has been removed.")};wt.prototype.rotateY=function(){console.error("THREE.Matrix4: .rotateY() has been removed.")};wt.prototype.rotateZ=function(){console.error("THREE.Matrix4: .rotateZ() has been removed.")};wt.prototype.rotateByAxis=function(){console.error("THREE.Matrix4: .rotateByAxis() has been removed.")};wt.prototype.applyToBufferAttribute=function(n){return console.warn("THREE.Matrix4: .applyToBufferAttribute() has been removed. Use attribute.applyMatrix4( matrix ) instead."),n.applyMatrix4(this)};wt.prototype.applyToVector3Array=function(){console.error("THREE.Matrix4: .applyToVector3Array() has been removed.")};wt.prototype.makeFrustum=function(n,t,e,i,r,s){return console.warn("THREE.Matrix4: .makeFrustum() has been removed. Use .makePerspective( left, right, top, bottom, near, far ) instead."),this.makePerspective(n,t,i,e,r,s)};wt.prototype.getInverse=function(n){return console.warn("THREE.Matrix4: .getInverse() has been removed. Use matrixInv.copy( matrix ).invert(); instead."),this.copy(n).invert()};je.prototype.isIntersectionLine=function(n){return console.warn("THREE.Plane: .isIntersectionLine() has been renamed to .intersectsLine()."),this.intersectsLine(n)};Ee.prototype.multiplyVector3=function(n){return console.warn("THREE.Quaternion: .multiplyVector3() has been removed. Use is now vector.applyQuaternion( quaternion ) instead."),n.applyQuaternion(this)};Ee.prototype.inverse=function(){return console.warn("THREE.Quaternion: .inverse() has been renamed to invert()."),this.invert()};oi.prototype.isIntersectionBox=function(n){return console.warn("THREE.Ray: .isIntersectionBox() has been renamed to .intersectsBox()."),this.intersectsBox(n)};oi.prototype.isIntersectionPlane=function(n){return console.warn("THREE.Ray: .isIntersectionPlane() has been renamed to .intersectsPlane()."),this.intersectsPlane(n)};oi.prototype.isIntersectionSphere=function(n){return console.warn("THREE.Ray: .isIntersectionSphere() has been renamed to .intersectsSphere()."),this.intersectsSphere(n)};re.prototype.area=function(){return console.warn("THREE.Triangle: .area() has been renamed to .getArea()."),this.getArea()};re.prototype.barycoordFromPoint=function(n,t){return console.warn("THREE.Triangle: .barycoordFromPoint() has been renamed to .getBarycoord()."),this.getBarycoord(n,t)};re.prototype.midpoint=function(n){return console.warn("THREE.Triangle: .midpoint() has been renamed to .getMidpoint()."),this.getMidpoint(n)};re.prototypenormal=function(n){return console.warn("THREE.Triangle: .normal() has been renamed to .getNormal()."),this.getNormal(n)};re.prototype.plane=function(n){return console.warn("THREE.Triangle: .plane() has been renamed to .getPlane()."),this.getPlane(n)};re.barycoordFromPoint=function(n,t,e,i,r){return console.warn("THREE.Triangle: .barycoordFromPoint() has been renamed to .getBarycoord()."),re.getBarycoord(n,t,e,i,r)};re.normal=function(n,t,e,i){return console.warn("THREE.Triangle: .normal() has been renamed to .getNormal()."),re.getNormal(n,t,e,i)};Un.prototype.extractAllPoints=function(n){return console.warn("THREE.Shape: .extractAllPoints() has been removed. Use .extractPoints() instead."),this.extractPoints(n)};Un.prototype.extrude=function(n){return console.warn("THREE.Shape: .extrude() has been removed. Use ExtrudeGeometry() instead."),new ci(this,n)};Un.prototype.makeGeometry=function(n){return console.warn("THREE.Shape: .makeGeometry() has been removed. Use ShapeGeometry() instead."),new qi(this,n)};K.prototype.fromAttribute=function(n,t,e){return console.warn("THREE.Vector2: .fromAttribute() has been renamed to .fromBufferAttribute()."),this.fromBufferAttribute(n,t,e)};K.prototype.distanceToManhattan=function(n){return console.warn("THREE.Vector2: .distanceToManhattan() has been renamed to .manhattanDistanceTo()."),this.manhattanDistanceTo(n)};K.prototype.lengthManhattan=function(){return console.warn("THREE.Vector2: .lengthManhattan() has been renamed to .manhattanLength()."),this.manhattanLength()};T.prototype.setEulerFromRotationMatrix=function(){console.error("THREE.Vector3: .setEulerFromRotationMatrix() has been removed. Use Euler.setFromRotationMatrix() instead.")};T.prototype.setEulerFromQuaternion=function(){console.error("THREE.Vector3: .setEulerFromQuaternion() has been removed. Use Euler.setFromQuaternion() instead.")};T.prototype.getPositionFromMatrix=function(n){return console.warn("THREE.Vector3: .getPositionFromMatrix() has been renamed to .setFromMatrixPosition()."),this.setFromMatrixPosition(n)};T.prototype.getScaleFromMatrix=function(n){return console.warn("THREE.Vector3: .getScaleFromMatrix() has been renamed to .setFromMatrixScale()."),this.setFromMatrixScale(n)};T.prototype.getColumnFromMatrix=function(n,t){return console.warn("THREE.Vector3: .getColumnFromMatrix() has been renamed to .setFromMatrixColumn()."),this.setFromMatrixColumn(t,n)};T.prototype.applyProjection=function(n){return console.warn("THREE.Vector3: .applyProjection() has been removed. Use .applyMatrix4( m ) instead."),this.applyMatrix4(n)};T.prototype.fromAttribute=function(n,t,e){return console.warn("THREE.Vector3: .fromAttribute() has been renamed to .fromBufferAttribute()."),this.fromBufferAttribute(n,t,e)};T.prototype.distanceToManhattan=function(n){return console.warn("THREE.Vector3: .distanceToManhattan() has been renamed to .manhattanDistanceTo()."),this.manhattanDistanceTo(n)};T.prototype.lengthManhattan=function(){return console.warn("THREE.Vector3: .lengthManhattan() has been renamed to .manhattanLength()."),this.manhattanLength()};Wt.prototype.fromAttribute=function(n,t,e){return console.warn("THREE.Vector4: .fromAttribute() has been renamed to .fromBufferAttribute()."),this.fromBufferAttribute(n,t,e)};Wt.prototype.lengthManhattan=function(){return console.warn("THREE.Vector4: .lengthManhattan() has been renamed to .manhattanLength()."),this.manhattanLength()};kt.prototype.getChildByName=function(n){return console.warn("THREE.Object3D: .getChildByName() has been renamed to .getObjectByName()."),this.getObjectByName(n)};kt.prototype.renderDepth=function(){console.warn("THREE.Object3D: .renderDepth has been removed. Use .renderOrder, instead.")};kt.prototype.translate=function(n,t){return console.warn("THREE.Object3D: .translate() has been removed. Use .translateOnAxis( axis, distance ) instead."),this.translateOnAxis(t,n)};kt.prototype.getWorldRotation=function(){console.error("THREE.Object3D: .getWorldRotation() has been removed. Use THREE.Object3D.getWorldQuaternion( target ) instead.")};kt.prototype.applyMatrix=function(n){return console.warn("THREE.Object3D: .applyMatrix() has been renamed to .applyMatrix4()."),this.applyMatrix4(n)};Object.defineProperties(kt.prototype,{eulerOrder:{get:function(){return console.warn("THREE.Object3D: .eulerOrder is now .rotation.order."),this.rotation.order},set:function(n){console.warn("THREE.Object3D: .eulerOrder is now .rotation.order."),this.rotation.order=n}},useQuaternion:{get:function(){console.warn("THREE.Object3D: .useQuaternion has been removed. The library now uses quaternions by default.")},set:function(){console.warn("THREE.Object3D: .useQuaternion has been removed. The library now uses quaternions by default.")}}});oe.prototype.setDrawMode=function(){console.error("THREE.Mesh: .setDrawMode() has been removed. The renderer now always assumes THREE.TrianglesDrawMode. Transform your geometry via BufferGeometryUtils.toTrianglesDrawMode() if necessary.")};Object.defineProperties(oe.prototype,{drawMode:{get:function(){return console.error("THREE.Mesh: .drawMode has been removed. The renderer now always assumes THREE.TrianglesDrawMode."),$w},set:function(){console.error("THREE.Mesh: .drawMode has been removed. The renderer now always assumes THREE.TrianglesDrawMode. Transform your geometry via BufferGeometryUtils.toTrianglesDrawMode() if necessary.")}}});dl.prototype.initBones=function(){console.error("THREE.SkinnedMesh: initBones() has been removed.")};Se.prototype.setLens=function(n,t){console.warn("THREE.PerspectiveCamera.setLens is deprecated. Use .setFocalLength and .filmGauge for a photographic setup."),t!==void 0&&(this.filmGauge=t),this.setFocalLength(n)};Object.defineProperties(Ye.prototype,{onlyShadow:{set:function(){console.warn("THREE.Light: .onlyShadow has been removed.")}},shadowCameraFov:{set:function(n){console.warn("THREE.Light: .shadowCameraFov is now .shadow.camera.fov."),this.shadow.camera.fov=n}},shadowCameraLeft:{set:function(n){console.warn("THREE.Light: .shadowCameraLeft is now .shadow.camera.left."),this.shadow.camera.left=n}},shadowCameraRight:{set:function(n){console.warn("THREE.Light: .shadowCameraRight is now .shadow.camera.right."),this.shadow.camera.right=n}},shadowCameraTop:{set:function(n){console.warn("THREE.Light: .shadowCameraTop is now .shadow.camera.top."),this.shadow.camera.top=n}},shadowCameraBottom:{set:function(n){console.warn("THREE.Light: .shadowCameraBottom is now .shadow.camera.bottom."),this.shadow.camera.bottom=n}},shadowCameraNear:{set:function(n){console.warn("THREE.Light: .shadowCameraNear is now .shadow.camera.near."),this.shadow.camera.near=n}},shadowCameraFar:{set:function(n){console.warn("THREE.Light: .shadowCameraFar is now .shadow.camera.far."),this.shadow.camera.far=n}},shadowCameraVisible:{set:function(){console.warn("THREE.Light: .shadowCameraVisible has been removed. Use new THREE.CameraHelper( light.shadow.camera ) instead.")}},shadowBias:{set:function(n){console.warn("THREE.Light: .shadowBias is now .shadow.bias."),this.shadow.bias=n}},shadowDarkness:{set:function(){console.warn("THREE.Light: .shadowDarkness has been removed.")}},shadowMapWidth:{set:function(n){console.warn("THREE.Light: .shadowMapWidth is now .shadow.mapSize.width."),this.shadow.mapSize.width=n}},shadowMapHeight:{set:function(n){console.warn("THREE.Light: .shadowMapHeight is now .shadow.mapSize.height."),this.shadow.mapSize.height=n}}});Object.defineProperties(Qt.prototype,{length:{get:function(){return console.warn("THREE.BufferAttribute: .length has been deprecated. Use .count instead."),this.array.length}},dynamic:{get:function(){return console.warn("THREE.BufferAttribute: .dynamic has been deprecated. Use .usage instead."),this.usage===nl},set:function(){console.warn("THREE.BufferAttribute: .dynamic has been deprecated. Use .usage instead."),this.setUsage(nl)}}});Qt.prototype.setDynamic=function(n){return console.warn("THREE.BufferAttribute: .setDynamic() has been deprecated. Use .setUsage() instead."),this.setUsage(n===!0?nl:io),this};Qt.prototype.copyIndicesArray=function(){console.error("THREE.BufferAttribute: .copyIndicesArray() has been removed.")},Qt.prototype.setArray=function(){console.error("THREE.BufferAttribute: .setArray has been removed. Use BufferGeometry .setAttribute to replace/resize attribute buffers")};Ht.prototype.addIndex=function(n){console.warn("THREE.BufferGeometry: .addIndex() has been renamed to .setIndex()."),this.setIndex(n)};Ht.prototype.addAttribute=function(n,t){return console.warn("THREE.BufferGeometry: .addAttribute() has been renamed to .setAttribute()."),!(t&&t.isBufferAttribute)&&!(t&&t.isInterleavedBufferAttribute)?(console.warn("THREE.BufferGeometry: .addAttribute() now expects ( name, attribute )."),this.setAttribute(n,new Qt(arguments[1],arguments[2]))):n==="index"?(console.warn("THREE.BufferGeometry.addAttribute: Use .setIndex() for index attribute."),this.setIndex(t),this):this.setAttribute(n,t)};Ht.prototype.addDrawCall=function(n,t,e){e!==void 0&&console.warn("THREE.BufferGeometry: .addDrawCall() no longer supports indexOffset."),console.warn("THREE.BufferGeometry: .addDrawCall() is now .addGroup()."),this.addGroup(n,t)};Ht.prototype.clearDrawCalls=function(){console.warn("THREE.BufferGeometry: .clearDrawCalls() is now .clearGroups()."),this.clearGroups()};Ht.prototype.computeOffsets=function(){console.warn("THREE.BufferGeometry: .computeOffsets() has been removed.")};Ht.prototype.removeAttribute=function(n){return console.warn("THREE.BufferGeometry: .removeAttribute() has been renamed to .deleteAttribute()."),this.deleteAttribute(n)};Ht.prototype.applyMatrix=function(n){return console.warn("THREE.BufferGeometry: .applyMatrix() has been renamed to .applyMatrix4()."),this.applyMatrix4(n)};Object.defineProperties(Ht.prototype,{drawcalls:{get:function(){return console.error("THREE.BufferGeometry: .drawcalls has been renamed to .groups."),this.groups}},offsets:{get:function(){return console.warn("THREE.BufferGeometry: .offsets has been renamed to .groups."),this.groups}}});Gi.prototype.setDynamic=function(n){return console.warn("THREE.InterleavedBuffer: .setDynamic() has been deprecated. Use .setUsage() instead."),this.setUsage(n===!0?nl:io),this};Gi.prototype.setArray=function(){console.error("THREE.InterleavedBuffer: .setArray has been removed. Use BufferGeometry .setAttribute to replace/resize attribute buffers")};ci.prototype.getArrays=function(){console.error("THREE.ExtrudeGeometry: .getArrays() has been removed.")};ci.prototype.addShapeList=function(){console.error("THREE.ExtrudeGeometry: .addShapeList() has been removed.")};ci.prototype.addShape=function(){console.error("THREE.ExtrudeGeometry: .addShape() has been removed.")};Yr.prototype.dispose=function(){console.error("THREE.Scene: .dispose() has been removed.")};To.prototype.onUpdate=function(){return console.warn("THREE.Uniform: .onUpdate() has been removed. Use object.onBeforeRender() instead."),this};Object.defineProperties(xe.prototype,{wrapAround:{get:function(){console.warn("THREE.Material: .wrapAround has been removed.")},set:function(){console.warn("THREE.Material: .wrapAround has been removed.")}},overdraw:{get:function(){console.warn("THREE.Material: .overdraw has been removed.")},set:function(){console.warn("THREE.Material: .overdraw has been removed.")}},wrapRGB:{get:function(){return console.warn("THREE.Material: .wrapRGB has been removed."),new ft}},shading:{get:function(){console.error("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead.")},set:function(n){console.warn("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead."),this.flatShading=n===c0}},stencilMask:{get:function(){return console.warn("THREE."+this.type+": .stencilMask has been removed. Use .stencilFuncMask instead."),this.stencilFuncMask},set:function(n){console.warn("THREE."+this.type+": .stencilMask has been removed. Use .stencilFuncMask instead."),this.stencilFuncMask=n}},vertexTangents:{get:function(){console.warn("THREE."+this.type+": .vertexTangents has been removed.")},set:function(){console.warn("THREE."+this.type+": .vertexTangents has been removed.")}}});Object.defineProperties(Fn.prototype,{derivatives:{get:function(){return console.warn("THREE.ShaderMaterial: .derivatives has been moved to .extensions.derivatives."),this.extensions.derivatives},set:function(n){console.warn("THREE. ShaderMaterial: .derivatives has been moved to .extensions.derivatives."),this.extensions.derivatives=n}}});Vt.prototype.clearTarget=function(n,t,e,i){console.warn("THREE.WebGLRenderer: .clearTarget() has been deprecated. Use .setRenderTarget() and .clear() instead."),this.setRenderTarget(n),this.clear(t,e,i)};Vt.prototype.animate=function(n){console.warn("THREE.WebGLRenderer: .animate() is now .setAnimationLoop()."),this.setAnimationLoop(n)};Vt.prototype.getCurrentRenderTarget=function(){return console.warn("THREE.WebGLRenderer: .getCurrentRenderTarget() is now .getRenderTarget()."),this.getRenderTarget()};Vt.prototype.getMaxAnisotropy=function(){return console.warn("THREE.WebGLRenderer: .getMaxAnisotropy() is now .capabilities.getMaxAnisotropy()."),this.capabilities.getMaxAnisotropy()};Vt.prototype.getPrecision=function(){return console.warn("THREE.WebGLRenderer: .getPrecision() is now .capabilities.precision."),this.capabilities.precision};Vt.prototype.resetGLState=function(){return console.warn("THREE.WebGLRenderer: .resetGLState() is now .state.reset()."),this.state.reset()};Vt.prototype.supportsFloatTextures=function(){return console.warn("THREE.WebGLRenderer: .supportsFloatTextures() is now .extensions.get( 'OES_texture_float' )."),this.extensions.get("OES_texture_float")};Vt.prototype.supportsHalfFloatTextures=function(){return console.warn("THREE.WebGLRenderer: .supportsHalfFloatTextures() is now .extensions.get( 'OES_texture_half_float' )."),this.extensions.get("OES_texture_half_float")};Vt.prototype.supportsStandardDerivatives=function(){return console.warn("THREE.WebGLRenderer: .supportsStandardDerivatives() is now .extensions.get( 'OES_standard_derivatives' )."),this.extensions.get("OES_standard_derivatives")};Vt.prototype.supportsCompressedTextureS3TC=function(){return console.warn("THREE.WebGLRenderer: .supportsCompressedTextureS3TC() is now .extensions.get( 'WEBGL_compressed_texture_s3tc' )."),this.extensions.get("WEBGL_compressed_texture_s3tc")};Vt.prototype.supportsCompressedTexturePVRTC=function(){return console.warn("THREE.WebGLRenderer: .supportsCompressedTexturePVRTC() is now .extensions.get( 'WEBGL_compressed_texture_pvrtc' )."),this.extensions.get("WEBGL_compressed_texture_pvrtc")};Vt.prototype.supportsBlendMinMax=function(){return console.warn("THREE.WebGLRenderer: .supportsBlendMinMax() is now .extensions.get( 'EXT_blend_minmax' )."),this.extensions.get("EXT_blend_minmax")};Vt.prototype.supportsVertexTextures=function(){return console.warn("THREE.WebGLRenderer: .supportsVertexTextures() is now .capabilities.vertexTextures."),this.capabilities.vertexTextures};Vt.prototype.supportsInstancedArrays=function(){return console.warn("THREE.WebGLRenderer: .supportsInstancedArrays() is now .extensions.get( 'ANGLE_instanced_arrays' )."),this.extensions.get("ANGLE_instanced_arrays")};Vt.prototype.enableScissorTest=function(n){console.warn("THREE.WebGLRenderer: .enableScissorTest() is now .setScissorTest()."),this.setScissorTest(n)};Vt.prototype.initMaterial=function(){console.warn("THREE.WebGLRenderer: .initMaterial() has been removed.")};Vt.prototype.addPrePlugin=function(){console.warn("THREE.WebGLRenderer: .addPrePlugin() has been removed.")};Vt.prototype.addPostPlugin=function(){console.warn("THREE.WebGLRenderer: .addPostPlugin() has been removed.")};Vt.prototype.updateShadowMap=function(){console.warn("THREE.WebGLRenderer: .updateShadowMap() has been removed.")};Vt.prototype.setFaceCulling=function(){console.warn("THREE.WebGLRenderer: .setFaceCulling() has been removed.")};Vt.prototype.allocTextureUnit=function(){console.warn("THREE.WebGLRenderer: .allocTextureUnit() has been removed.")};Vt.prototype.setTexture=function(){console.warn("THREE.WebGLRenderer: .setTexture() has been removed.")};Vt.prototype.setTexture2D=function(){console.warn("THREE.WebGLRenderer: .setTexture2D() has been removed.")};Vt.prototype.setTextureCube=function(){console.warn("THREE.WebGLRenderer: .setTextureCube() has been removed.")};Vt.prototype.getActiveMipMapLevel=function(){return console.warn("THREE.WebGLRenderer: .getActiveMipMapLevel() is now .getActiveMipmapLevel()."),this.getActiveMipmapLevel()};Object.defineProperties(Vt.prototype,{shadowMapEnabled:{get:function(){return this.shadowMap.enabled},set:function(n){console.warn("THREE.WebGLRenderer: .shadowMapEnabled is now .shadowMap.enabled."),this.shadowMap.enabled=n}},shadowMapType:{get:function(){return this.shadowMap.type},set:function(n){console.warn("THREE.WebGLRenderer: .shadowMapType is now .shadowMap.type."),this.shadowMap.type=n}},shadowMapCullFace:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMapCullFace has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMapCullFace has been removed. Set Material.shadowSide instead.")}},context:{get:function(){return console.warn("THREE.WebGLRenderer: .context has been removed. Use .getContext() instead."),this.getContext()}},vr:{get:function(){return console.warn("THREE.WebGLRenderer: .vr has been renamed to .xr"),this.xr}},gammaInput:{get:function(){return console.warn("THREE.WebGLRenderer: .gammaInput has been removed. Set the encoding for textures via Texture.encoding instead."),!1},set:function(){console.warn("THREE.WebGLRenderer: .gammaInput has been removed. Set the encoding for textures via Texture.encoding instead.")}},gammaOutput:{get:function(){return console.warn("THREE.WebGLRenderer: .gammaOutput has been removed. Set WebGLRenderer.outputEncoding instead."),!1},set:function(n){console.warn("THREE.WebGLRenderer: .gammaOutput has been removed. Set WebGLRenderer.outputEncoding instead."),this.outputEncoding=n===!0?$t:ri}},toneMappingWhitePoint:{get:function(){return console.warn("THREE.WebGLRenderer: .toneMappingWhitePoint has been removed."),1},set:function(){console.warn("THREE.WebGLRenderer: .toneMappingWhitePoint has been removed.")}},gammaFactor:{get:function(){return console.warn("THREE.WebGLRenderer: .gammaFactor has been removed."),2},set:function(){console.warn("THREE.WebGLRenderer: .gammaFactor has been removed.")}}});Object.defineProperties(T0.prototype,{cullFace:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMap.cullFace has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMap.cullFace has been removed. Set Material.shadowSide instead.")}},renderReverseSided:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderReverseSided has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderReverseSided has been removed. Set Material.shadowSide instead.")}},renderSingleSided:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderSingleSided has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderSingleSided has been removed. Set Material.shadowSide instead.")}}});Object.defineProperties(Ne.prototype,{wrapS:{get:function(){return console.warn("THREE.WebGLRenderTarget: .wrapS is now .texture.wrapS."),this.texture.wrapS},set:function(n){console.warn("THREE.WebGLRenderTarget: .wrapS is now .texture.wrapS."),this.texture.wrapS=n}},wrapT:{get:function(){return console.warn("THREE.WebGLRenderTarget: .wrapT is now .texture.wrapT."),this.texture.wrapT},set:function(n){console.warn("THREE.WebGLRenderTarget: .wrapT is now .texture.wrapT."),this.texture.wrapT=n}},magFilter:{get:function(){return console.warn("THREE.WebGLRenderTarget: .magFilter is now .texture.magFilter."),this.texture.magFilter},set:function(n){console.warn("THREE.WebGLRenderTarget: .magFilter is now .texture.magFilter."),this.texture.magFilter=n}},minFilter:{get:function(){return console.warn("THREE.WebGLRenderTarget: .minFilter is now .texture.minFilter."),this.texture.minFilter},set:function(n){console.warn("THREE.WebGLRenderTarget: .minFilter is now .texture.minFilter."),this.texture.minFilter=n}},anisotropy:{get:function(){return console.warn("THREE.WebGLRenderTarget: .anisotropy is now .texture.anisotropy."),this.texture.anisotropy},set:function(n){console.warn("THREE.WebGLRenderTarget: .anisotropy is now .texture.anisotropy."),this.texture.anisotropy=n}},offset:{get:function(){return console.warn("THREE.WebGLRenderTarget: .offset is now .texture.offset."),this.texture.offset},set:function(n){console.warn("THREE.WebGLRenderTarget: .offset is now .texture.offset."),this.texture.offset=n}},repeat:{get:function(){return console.warn("THREE.WebGLRenderTarget: .repeat is now .texture.repeat."),this.texture.repeat},set:function(n){console.warn("THREE.WebGLRenderTarget: .repeat is now .texture.repeat."),this.texture.repeat=n}},format:{get:function(){return console.warn("THREE.WebGLRenderTarget: .format is now .texture.format."),this.texture.format},set:function(n){console.warn("THREE.WebGLRenderTarget: .format is now .texture.format."),this.texture.format=n}},type:{get:function(){return console.warn("THREE.WebGLRenderTarget: .type is now .texture.type."),this.texture.type},set:function(n){console.warn("THREE.WebGLRenderTarget: .type is now .texture.type."),this.texture.type=n}},generateMipmaps:{get:function(){return console.warn("THREE.WebGLRenderTarget: .generateMipmaps is now .texture.generateMipmaps."),this.texture.generateMipmaps},set:function(n){console.warn("THREE.WebGLRenderTarget: .generateMipmaps is now .texture.generateMipmaps."),this.texture.generateMipmaps=n}}});Bh.prototype.load=function(n){console.warn("THREE.Audio: .load has been deprecated. Use THREE.AudioLoader instead.");let t=this;return new Fh().load(n,function(i){t.setBuffer(i)}),this};Oh.prototype.getData=function(){return console.warn("THREE.AudioAnalyser: .getData() is now .getFrequencyData()."),this.getFrequencyData()};ao.prototype.updateCubeMap=function(n,t){return console.warn("THREE.CubeCamera: .updateCubeMap() is now .update()."),this.update(n,t)};ao.prototype.clear=function(n,t,e,i){return console.warn("THREE.CubeCamera: .clear() is now .renderTarget.clear()."),this.renderTarget.clear(n,t,e,i)};Nn.crossOrigin=void 0;Nn.loadTexture=function(n,t,e,i){console.warn("THREE.ImageUtils.loadTexture has been deprecated. Use THREE.TextureLoader() instead.");let r=new Eh;r.setCrossOrigin(this.crossOrigin);let s=r.load(n,e,void 0,i);return t&&(s.mapping=t),s};Nn.loadTextureCube=function(n,t,e,i){console.warn("THREE.ImageUtils.loadTextureCube has been deprecated. Use THREE.CubeTextureLoader() instead.");let r=new Sh;r.setCrossOrigin(this.crossOrigin);let s=r.load(n,e,void 0,i);return t&&(s.mapping=t),s};Nn.loadCompressedTexture=function(){console.error("THREE.ImageUtils.loadCompressedTexture has been removed. Use THREE.DDSLoader instead.")};Nn.loadCompressedTextureCube=function(){console.error("THREE.ImageUtils.loadCompressedTextureCube has been removed. Use THREE.DDSLoader instead.")};typeof __THREE_DEVTOOLS__!="undefined"&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("register",{detail:{revision:$h}}));typeof window!="undefined"&&(window.__THREE__?console.warn("WARNING: Multiple instances of Three.js being imported."):window.__THREE__=$h);function rf(n,t,e){if(e===1)return new ft(t);let i=pi(t);if(!i)throw new Error(`d3 failed to recognize the color: ${t}`);return new ft(sc(i,n)(1-e))}var gn;(function(n){n[n.CIRCLE=0]="CIRCLE",n[n.LINE=1]="LINE",n[n.TRIANGLE=2]="TRIANGLE",n[n.TRAPEZOID=3]="TRAPEZOID"})(gn||(gn={}));function N0(n,t){let e=t.length/2,i=n.attributes.position;(!i||i.count!==e*3)&&(i=new Qt(new Float32Array(e*3),3),n.setAttribute("position",i));let r=i.array;for(let s=0;s<e;s++)r[s*3]=t[s*2],r[s*3+1]=t[s*2+1];i.needsUpdate=!0,n.setDrawRange(0,e*3),n.computeBoundingSphere()}function F0(n,t,e){let i=Math.max(t.length/2-1,0),r=i*2*3,s=r*3,o=n.attributes.position;(!o||o.count!==r)&&(o=new Qt(new Float32Array(s),3),n.setAttribute("position",o));let a=o.array;for(let l=0;l<i;l++){let[c,u,h,f]=[t[2*l],t[2*l+1],t[2*l+2],t[2*l+3]],d=new K(c,u),g=new K(h,f),x=new K(h-c,f-u),v=new K(-x.y,x.x).setLength(e/2),m=d.clone().add(v),p=d.clone().sub(v),b=g.clone().add(v),_=g.clone().sub(v),S=[m.x,m.y,0,p.x,p.y,0,b.x,b.y,0,b.x,b.y,0,p.x,p.y,0,_.x,_.y,0];a.set(S,l*S.length)}o.needsUpdate=!0,n.setDrawRange(0,s),n.computeBoundingSphere()}function Il(n,t,e,i){let{visible:r,color:s,opacity:o}=i;if(Array.isArray(t.material))throw new Error("Invariant error: only expect one material on an object");let a=t.material;if(a.visible!==r&&(a.visible=r,a.needsUpdate=!0),!r)return!1;let l=rf(n,s,o!=null?o:1),c=e(t.geometry);return t.geometry!==c&&(t.geometry=c),a.color.equals(l)||(a.color.set(l),a.needsUpdate=!0),!0}var wT={createScene:()=>new Yr},Ro=class{constructor(t,e,i,r){this.coordinator=e,this.scene=wT.createScene(),this.backgroundColor="#fff",Di.isWebGl2OffscreenCanvasSupported()&&t instanceof OffscreenCanvas&&(t.style=t.style||{}),r&&t.addEventListener("webglcontextlost",r),this.renderer=new Vt({canvas:t,antialias:!0,alpha:!0}),this.renderer.setPixelRatio(i)}onResize(t){this.renderer.setSize(t.width,t.height)}destroyObject(t){let e=t.obj3d;if(this.scene.remove(e),e instanceof oe){e.geometry.dispose();let i=Array.isArray(e.material)?e.material:[e.material];for(let r of i)r.dispose()}}setUseDarkMode(t){this.backgroundColor=t?"#303030":"#fff"}createOrUpdateLineObject(t,e,i){var u;if(!t&&!i.visible)return null;let{visible:r,width:s}=i;if(!t){let h=rf(this.backgroundColor,i.color,(u=i.opacity)!=null?u:1),f=new Ht,d=new zn({color:h}),g=new oe(f,d);return d.visible=r,F0(f,e,s),this.scene.add(g),{type:gn.LINE,data:e,obj3d:g,width:s}}let{data:o,obj3d:a,width:l}=t;return Il(this.backgroundColor,a,h=>((s!==l||!o||!Di.arePolylinesEqual(o,e))&&F0(h,e,s),h),i)?{type:gn.LINE,data:e,obj3d:a,width:s}:t}createMesh(t,e){if(!e.visible)return null;let{visible:i,color:r,opacity:s}=e,o=rf(this.backgroundColor,r,s!=null?s:1),a=new ki({color:o,visible:i});return new oe(t,a)}createOrUpdateTriangleObject(t,e,i){let{size:r}=i,s=r*Math.sqrt(3)/2,o=new Float32Array([e.x-r/2,e.y-s/3,e.x+r/2,e.y-s/3,e.x,e.y+s*2/3]);if(!t){let l=new Ht;N0(l,o);let c=this.createMesh(l,i);return c===null?null:(this.scene.add(c),{type:gn.TRIANGLE,data:e,obj3d:c})}return Il(this.backgroundColor,t.obj3d,l=>(N0(l,o),l),i)?{type:gn.TRIANGLE,data:e,obj3d:t.obj3d}:t}createOrUpdateCircleObject(t,e,i){let{radius:r}=i,s=new Zr(i.radius);if(!t){let a=this.createMesh(s,i);return a===null?null:(a.position.set(e.x,e.y,0),this.scene.add(a),{type:gn.CIRCLE,data:{loc:e,radius:r},obj3d:a})}return Il(this.backgroundColor,t.obj3d,()=>s,i)?(t.obj3d.position.set(e.x,e.y,0),{type:gn.CIRCLE,data:{loc:e,radius:r},obj3d:t.obj3d}):t}createOrUpdateTrapezoidObject(t,e,i,r){if(e.y!==i.y)throw new RangeError("Input error: start.y != end.y.");let{altitude:s}=r,o=2/Math.sqrt(3)*s,a=new Un([new K(e.x-o/2,e.y-s/2),new K(e.x,e.y+s/2),new K(i.x,i.y+s/2),new K(i.x+o/2,i.y-s/2)]);a.autoClose=!0;let l=new qi(a);if(!t){let u=this.createMesh(l,r);return u===null?null:(this.scene.add(u),{type:gn.TRAPEZOID,data:[e,i],obj3d:u})}return Il(this.backgroundColor,t.obj3d,()=>l,r)?{type:gn.TRAPEZOID,data:[e,i],obj3d:t.obj3d}:t}flush(){this.renderer.render(this.scene,this.coordinator.getCamera())}dispose(){this.renderer.dispose()}};var Nl=class{constructor(t,e){this.renderCache=t,this.renderer=e}setLine(t,e,i){let r=this.renderer.createOrUpdateLineObject(this.renderCache.getFromPreviousFrame(t),e,i);r&&this.renderCache.setToCurrentFrame(t,r)}setTriangle(t,e,i){let r=this.renderer.createOrUpdateTriangleObject(this.renderCache.getFromPreviousFrame(t),e,i);r&&this.renderCache.setToCurrentFrame(t,r)}setCircle(t,e,i){let r=this.renderer.createOrUpdateCircleObject(this.renderCache.getFromPreviousFrame(t),e,i);r&&this.renderCache.setToCurrentFrame(t,r)}setTrapezoid(t,e,i,r){let s=this.renderer.createOrUpdateTrapezoidObject(this.renderCache.getFromPreviousFrame(t),e,i,r);s&&this.renderCache.setToCurrentFrame(t,s)}};var sf=class{constructor(){this.prevFrameCache=new Map,this.currFrameCache=new Map}getFromPreviousFrame(t){let e=this.prevFrameCache.get(t);return e!=null?e:null}setToCurrentFrame(t,e){this.currFrameCache.set(t,e)}finalizeFrameAndGetRemoved(){let t=[];for(let[e,i]of this.prevFrameCache.entries())this.currFrameCache.has(e)||t.push(i);return this.prevFrameCache=this.currFrameCache,this.currFrameCache=new Map,t}},Fl=class{constructor(t){this.rawSeriesData=[],this.series=[],this.paintDirty=!0,this.renderCache=new sf,this.coordinateIdentifier=null,this.layout={x:0,width:1,y:0,height:1},this.getMetadataMapImpl=t.getMetadataMap,this.coordinator=t.coordinator,this.renderer=t.renderer,this.paintBrush=new Nl(this.renderCache,this.renderer)}setLayoutRect(t){(this.layout.x!==t.x||this.layout.width!==t.width||this.layout.y!==t.y||this.layout.height!==t.height)&&(this.paintDirty=!0),this.layout=t}getLayoutRect(){return this.layout}getMetadataMap(){return this.getMetadataMapImpl()}markAsPaintDirty(){this.paintDirty=!0}render(){if(this.transformCoordinatesIfStale(),!!this.paintDirty){this.redraw();for(let t of this.renderCache.finalizeFrameAndGetRemoved())this.renderer.destroyObject(t);this.paintDirty=!1}}isCoordinateUpdated(){return this.coordinator.getUpdateIdentifier()!==this.coordinateIdentifier}clearCoordinateIdentifier(){this.coordinateIdentifier=null}setData(t){this.clearCoordinateIdentifier(),this.rawSeriesData=t}transformCoordinatesIfStale(){if(!this.isCoordinateUpdated())return;let t=this.getLayoutRect();this.series=new Array(this.rawSeriesData.length);for(let e=0;e<this.rawSeriesData.length;e++){let i=this.rawSeriesData[e];this.series[e]={id:i.id,polyline:new Float32Array(i.points.length*2)};for(let r=0;r<i.points.length;r++){let[s,o]=this.coordinator.transformDataToUiCoord(t,[i.points[r].x,i.points[r].y]);this.series[e].polyline[r*2]=s,this.series[e].polyline[r*2+1]=o}}this.coordinateIdentifier=this.coordinator.getUpdateIdentifier(),this.markAsPaintDirty()}};var Lo;(function(n){n[n.NUMBER=0]="NUMBER",n[n.NAN=1]="NAN"})(Lo||(Lo={}));var zl=class extends Fl{recordPartition(t,e,i){return t?{type:Lo.NUMBER,polyline:e}:{type:Lo.NAN,polyline:e.map((r,s)=>isNaN(r)?s%2===0?i.x:i.y:r)}}partitionPolyline(t){let e=[],i=0,r=!1,s=this.coordinator.transformDataToUiCoord(this.getLayoutRect(),[0,0]),o={x:s[0],y:s[1]},a=null;for(let l=0;l<t.length;l+=2){let c=t[l],u=t[l+1],h=isNaN(c)||isNaN(u);h!==r&&i!==l&&(e.push(this.recordPartition(!r,t.slice(i,l),a===null?{x:c,y:u}:a)),i=l),h||(a={x:c,y:u}),r=h}return i!==t.length-1&&e.push(this.recordPartition(!r,t.slice(i,t.length),a!=null?a:o)),e}redraw(){var t,e,i;for(let r of this.series){let o=this.getMetadataMap()[r.id];if(!o)continue;if(r.polyline.length%2!==0)throw new Error(`Cannot have odd length-ed polyline: ${r.polyline.length}`);let a=this.partitionPolyline(r.polyline);for(let[l,{type:c,polyline:u}]of a.entries())if(c===Lo.NUMBER)u.length===2?this.paintBrush.setCircle(JSON.stringify(["circle",r.id,l]),{x:u[0],y:u[1]},{color:o.color,visible:o.visible,opacity:(t=o.opacity)!=null?t:1,radius:4}):this.paintBrush.setLine(JSON.stringify(["line",r.id,l]),u,{color:o.color,visible:o.visible,opacity:(e=o.opacity)!=null?e:1,width:2});else if(!o.aux)for(let h=0;h<u.length;h+=2)this.paintBrush.setTriangle(JSON.stringify(["NaN",r.id,u[h],u[h+1]]),{x:u[h],y:u[h+1]},{color:o.color,visible:o.visible,opacity:(i=o.opacity)!=null?i:1,size:12})}}};var Ul=class extends dr{constructor(){super(...arguments),this.camera=new Vi(0,1e3,1e3,0,0,100)}isYAxisPointedDown(){return!1}setDomContainerRect(t){super.setDomContainerRect(t),this.camera.left=t.x,this.camera.right=t.x+t.width,this.camera.top=t.y+t.height,this.camera.bottom=t.y,this.camera.updateProjectionMatrix()}getCamera(){return this.camera}};var MT={requestAnimationFrame:n=>self.requestAnimationFrame(n)},Bl=class{constructor(t){switch(this.metadataMap={},this.shouldRepaint=!1,this.callbacks=t.callbacks,t.type){case Tn.SVG:{this.coordinator=new dr,this.renderer=new Os(t.container);break}case Tn.WEBGL:{let e=new Ul;this.coordinator=e,this.renderer=new Ro(t.container,e,t.devicePixelRatio,t.callbacks.onContextLost);break}}this.renderer.setUseDarkMode(t.useDarkMode),this.seriesLineView=new zl({renderer:this.renderer,coordinator:this.coordinator,getMetadataMap:()=>this.metadataMap}),this.resize(t.domDimension)}dispose(){}setXScaleType(t){this.coordinator.setXScale(fr(t)),this.scheduleRepaint()}setYScaleType(t){this.coordinator.setYScale(fr(t)),this.scheduleRepaint()}resize(t){this.coordinator.setDomContainerRect(No({x:0,y:0},t)),this.renderer.onResize(No({x:0,y:0},t)),this.seriesLineView.setLayoutRect(uf(No({},t),{x:0,y:0})),this.scheduleRepaint()}setMetadata(t){let e=!1;Object.entries(t).forEach(([i,r])=>{let s=this.metadataMap[i];(!s||r.color!==s.color||r.visible!==s.visible||r.opacity!==s.opacity)&&(e=!0),this.metadataMap[i]=r}),e&&this.seriesLineView.markAsPaintDirty(),this.scheduleRepaint()}setViewBox(t){this.coordinator.setViewBoxRect({x:t.x[0],width:t.x[1]-t.x[0],y:t.y[0],height:t.y[1]-t.y[0]}),this.scheduleRepaint()}setData(t){this.seriesLineView.setData(t),this.scheduleRepaint()}setUseDarkMode(t){this.renderer.setUseDarkMode(t),this.seriesLineView.markAsPaintDirty(),this.scheduleRepaint()}scheduleRepaint(){this.shouldRepaint||(this.shouldRepaint=!0,MT.requestAnimationFrame(()=>{this.repaint(),this.shouldRepaint=!1}))}repaint(){this.seriesLineView.render(),this.renderer.flush(),this.callbacks.onDrawEnd()}};function z0(n){let{flattenedSeries:t,idsAndLengths:e}=n,i=new Float64Array(t),r=[];if(i.length%2!==0)throw new Error("`flattenedSeries` must have even number of elements");let s=0;for(let{id:o,length:a}of e){let l=[];for(let c=0;c<a;c++)l.push({x:i[s++],y:i[s++]});r.push({id:o,points:l})}return r}var xn;(function(n){n[n.SERIES_DATA_UPDATED=0]="SERIES_DATA_UPDATED",n[n.SERIES_METADATA_CHANGED=1]="SERIES_METADATA_CHANGED",n[n.SCALE_UPDATED=2]="SCALE_UPDATED",n[n.VIEW_BOX_UPDATED=3]="VIEW_BOX_UPDATED",n[n.INIT=4]="INIT",n[n.DOM_RESIZED=5]="DOM_RESIZED",n[n.DARK_MODE_UPDATED=6]="DARK_MODE_UPDATED",n[n.DISPOSED=7]="DISPOSED"})(xn||(xn={}));var Po;(function(n){n[n.ON_REDRAW_END=0]="ON_REDRAW_END",n[n.ON_CONTEXT_LOST=1]="ON_CONTEXT_LOST"})(Po||(Po={}));self.addEventListener("message",n=>{bT(n.ports[0],n.data)});function bT(n,t){let{canvas:e,devicePixelRatio:i,dim:r,rendererType:s,useDarkMode:o}=t,a={onDrawEnd:()=>{n.postMessage({type:Po.ON_REDRAW_END})},onContextLost:()=>{n.postMessage({type:Po.ON_CONTEXT_LOST})}},l;switch(s){case Tn.WEBGL:l={type:Tn.WEBGL,domDimension:r,callbacks:a,container:e,devicePixelRatio:i,useDarkMode:o};break;default:throw new RangeError(`Invariant error: cannot have Offscreen chart for renderer type: ${s}`)}let c=new Bl(l);n.onmessage=function(u){let h=u.data;switch(h.type){case xn.SERIES_DATA_UPDATED:{let f=z0(h.compactDataSeries);c.setData(f);break}case xn.SERIES_METADATA_CHANGED:{c.setMetadata(h.metadata);break}case xn.VIEW_BOX_UPDATED:{c.setViewBox(h.extent);break}case xn.DOM_RESIZED:{c.resize(h.dim);break}case xn.DARK_MODE_UPDATED:{c.setUseDarkMode(h.useDarkMode);break}case xn.SCALE_UPDATED:{switch(h.axis){case"x":c.setXScaleType(h.scaleType);break;case"y":c.setYScaleType(h.scaleType);break;default:let f=h.axis;throw new RangeError(`Unknown axis: ${f}`)}break}case xn.DISPOSED:{c.dispose();break}}}}})();
/**
 * @license
 * Copyright 2010-2022 Three.js Authors
 * SPDX-License-Identifier: MIT
 */
//# sourceMappingURL=chart_worker.js.map
", + "ok": true, + "headers": [ + [ + "content-type", + "text/javascript; charset=utf-8" + ] + ], + "status": 200, + "status_text": "" + } + }, + "base_uri": "https://localhost:8080/", + "height": 821 + }, + "id": "34DeQPLe8-kd", + "outputId": "59a070f3-0f5e-4018-8251-3fb1fd12f6a9" + }, + "execution_count": 23, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "application/javascript": [ + "\n", + " (async () => {\n", + " const url = new URL(await google.colab.kernel.proxyPort(6006, {'cache': true}));\n", + " url.searchParams.set('tensorboardColab', 'true');\n", + " const iframe = document.createElement('iframe');\n", + " iframe.src = url;\n", + " iframe.setAttribute('width', '100%');\n", + " iframe.setAttribute('height', '800');\n", + " iframe.setAttribute('frameborder', 0);\n", + " document.body.appendChild(iframe);\n", + " })();\n", + " " + ] + }, + "metadata": {} + } + ] + }, { "cell_type": "code", "metadata": { @@ -1111,12 +1366,12 @@ }, "source": [ "# Upload TensorBoard dev records\n", - "!tensorboard dev upload --logdir ./tensorflow_hub/ \\\n", - " --name \"EfficientNetB0 vs. ResNet50V2\" \\\n", - " --description \"Comparing two different TF Hub feature extraction models architectures using 10% of training images\" \\\n", - " --one_shot" + "#!tensorboard dev upload --logdir ./tensorflow_hub/ \\\n", + "# --name \"EfficientNetB0 vs. ResNet50V2\" \\\n", + "# --description \"Comparing two different TF Hub feature extraction models architectures using 10% of training images\" \\\n", + "# --one_shot" ], - "execution_count": 17, + "execution_count": null, "outputs": [ { "output_type": "stream", @@ -1196,7 +1451,7 @@ "# Check out experiments\n", "# !tensorboard dev list # uncomment to see" ], - "execution_count": 21, + "execution_count": null, "outputs": [] }, { @@ -1226,7 +1481,7 @@ "# Delete an experiment\n", "!tensorboard dev delete --experiment_id n6kd8XZ3Rdy1jSgSLH5WjA" ], - "execution_count": 19, + "execution_count": null, "outputs": [ { "output_type": "stream", @@ -1248,7 +1503,7 @@ "# Check to see if experiments still exist\n", "# !tensorboard dev list # uncomment to see" ], - "execution_count": 22, + "execution_count": null, "outputs": [] }, { diff --git a/05_transfer_learning_in_tensorflow_part_2_fine_tuning.ipynb b/05_transfer_learning_in_tensorflow_part_2_fine_tuning.ipynb index defdb61..69330db 100644 --- a/05_transfer_learning_in_tensorflow_part_2_fine_tuning.ipynb +++ b/05_transfer_learning_in_tensorflow_part_2_fine_tuning.ipynb @@ -3,8 +3,7 @@ { "cell_type": "markdown", "metadata": { - "id": "view-in-github", - "colab_type": "text" + "id": "view-in-github" }, "source": [ "\"Open" @@ -83,14 +82,14 @@ "base_uri": "https://localhost:8080/" }, "id": "XOwYRBo8nuLY", - "outputId": "879c4a23-d7b0-45fb-adda-694a502daac7" + "outputId": "4aca8304-ade4-42f4-f105-c98f276cbcbc" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ - "Notebook last run (end-to-end): 2023-08-18 01:39:51.865865\n" + "Notebook last run (end-to-end): 2024-01-14 13:37:32.057265\n" ] } ], @@ -114,6 +113,31 @@ "id": "hC5o11td8Y8I" } }, + { + "cell_type": "code", + "source": [ + "# Settings Tensoboard\n", + "\n", + "%load_ext tensorboard" + ], + "metadata": { + "id": "P0dg9jngLSm6" + }, + "execution_count": 2, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Clear any logs from previous runs\n", + "!rm -rf ./logs/" + ], + "metadata": { + "id": "CYLrH_m0LY4Q" + }, + "execution_count": 3, + "outputs": [] + }, { "cell_type": "code", "source": [ @@ -126,54 +150,54 @@ "base_uri": "https://localhost:8080/" }, "id": "u9BN6XgdP4N1", - "outputId": "0f7376ad-0204-4c34-a54e-480f116ab1b4" + "outputId": "701413cd-9018-4b7b-ada3-4c6fc6f03c40" }, - "execution_count": 2, + "execution_count": 4, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ - "TensorFlow version: 2.12.0\n" + "TensorFlow version: 2.15.0\n" ] } ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 5, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "Nq4kxIpQMpZT", - "outputId": "d24fa621-b874-4eba-c782-2df33f3aa386" + "outputId": "59711ab6-03d1-4303-dde8-f8a699f9edcd" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ - "Fri Aug 18 01:39:54 2023 \n", - "+-----------------------------------------------------------------------------+\n", - "| NVIDIA-SMI 525.105.17 Driver Version: 525.105.17 CUDA Version: 12.0 |\n", - "|-------------------------------+----------------------+----------------------+\n", - "| GPU Name Persistence-M| Bus-Id Disp.A | Volatile Uncorr. ECC |\n", - "| Fan Temp Perf Pwr:Usage/Cap| Memory-Usage | GPU-Util Compute M. |\n", - "| | | MIG M. |\n", - "|===============================+======================+======================|\n", - "| 0 Tesla V100-SXM2... Off | 00000000:00:04.0 Off | 0 |\n", - "| N/A 36C P0 24W / 300W | 0MiB / 16384MiB | 0% Default |\n", - "| | | N/A |\n", - "+-------------------------------+----------------------+----------------------+\n", - " \n", - "+-----------------------------------------------------------------------------+\n", - "| Processes: |\n", - "| GPU GI CI PID Type Process name GPU Memory |\n", - "| ID ID Usage |\n", - "|=============================================================================|\n", - "| No running processes found |\n", - "+-----------------------------------------------------------------------------+\n" + "Sun Jan 14 13:37:37 2024 \n", + "+---------------------------------------------------------------------------------------+\n", + "| NVIDIA-SMI 535.104.05 Driver Version: 535.104.05 CUDA Version: 12.2 |\n", + "|-----------------------------------------+----------------------+----------------------+\n", + "| GPU Name Persistence-M | Bus-Id Disp.A | Volatile Uncorr. ECC |\n", + "| Fan Temp Perf Pwr:Usage/Cap | Memory-Usage | GPU-Util Compute M. |\n", + "| | | MIG M. |\n", + "|=========================================+======================+======================|\n", + "| 0 Tesla T4 Off | 00000000:00:04.0 Off | 0 |\n", + "| N/A 59C P8 10W / 70W | 0MiB / 15360MiB | 0% Default |\n", + "| | | N/A |\n", + "+-----------------------------------------+----------------------+----------------------+\n", + " \n", + "+---------------------------------------------------------------------------------------+\n", + "| Processes: |\n", + "| GPU GI CI PID Type Process name GPU Memory |\n", + "| ID ID Usage |\n", + "|=======================================================================================|\n", + "| No running processes found |\n", + "+---------------------------------------------------------------------------------------+\n" ] } ], @@ -215,29 +239,52 @@ }, { "cell_type": "code", - "execution_count": 4, + "source": [ + "# New TensorBoard Function\n", + "\n", + "# Create tensorboard callback (functionized because need to create a new one for each model)\n", + "import datetime\n", + "import os\n", + "def create_tensorboard_callback(experiment_name):\n", + " logfit_dir = \"logs/fit/\"\n", + " path_experiment = os.path.join(logfit_dir, experiment_name, datetime.datetime.now().strftime(\"%Y%m%d-%H%M%S\"))\n", + " tensorboard_callback = tf.keras.callbacks.TensorBoard(\n", + " log_dir=path_experiment\n", + " )\n", + " print(f\"Saving TensorBoard log files to: {logfit_dir}\")\n", + " return tensorboard_callback" + ], + "metadata": { + "id": "4ZnpQSNSLi-h" + }, + "execution_count": 6, + "outputs": [] + }, + { + "cell_type": "code", + "execution_count": 7, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "wEuiAtXkhsJM", - "outputId": "00958471-9575-490f-9cdf-7aea1e4499a3" + "outputId": "eff5c688-8713-45d5-ceae-e8896c8162f5" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ - "--2023-08-18 01:39:54-- https://raw.githubusercontent.com/mrdbourke/tensorflow-deep-learning/main/extras/helper_functions.py\n", + "--2024-01-14 13:37:37-- https://raw.githubusercontent.com/mrdbourke/tensorflow-deep-learning/main/extras/helper_functions.py\n", "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.108.133, 185.199.109.133, 185.199.110.133, ...\n", "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.108.133|:443... connected.\n", "HTTP request sent, awaiting response... 200 OK\n", "Length: 10246 (10K) [text/plain]\n", "Saving to: ‘helper_functions.py’\n", "\n", - "\rhelper_functions.py 0%[ ] 0 --.-KB/s \rhelper_functions.py 100%[===================>] 10.01K --.-KB/s in 0s \n", + "helper_functions.py 100%[===================>] 10.01K --.-KB/s in 0s \n", "\n", - "2023-08-18 01:39:54 (41.3 MB/s) - ‘helper_functions.py’ saved [10246/10246]\n", + "2024-01-14 13:37:37 (74.6 MB/s) - ‘helper_functions.py’ saved [10246/10246]\n", "\n" ] } @@ -247,7 +294,7 @@ "!wget https://raw.githubusercontent.com/mrdbourke/tensorflow-deep-learning/main/extras/helper_functions.py\n", "\n", "# Import helper functions we're going to use\n", - "from helper_functions import create_tensorboard_callback, plot_loss_curves, unzip_data, walk_through_dir" + "from helper_functions import plot_loss_curves, unzip_data, walk_through_dir" ] }, { @@ -284,29 +331,29 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 8, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "P7m6pjH0JTyJ", - "outputId": "72b8f094-3a4d-4468-b88d-76d99e7ae1d0" + "outputId": "62ad25c5-013f-4409-9d45-dfbf8f21b9db" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ - "--2023-08-18 01:39:55-- https://storage.googleapis.com/ztm_tf_course/food_vision/10_food_classes_10_percent.zip\n", - "Resolving storage.googleapis.com (storage.googleapis.com)... 173.194.203.128, 74.125.199.128, 74.125.195.128, ...\n", - "Connecting to storage.googleapis.com (storage.googleapis.com)|173.194.203.128|:443... connected.\n", + "--2024-01-14 13:37:39-- https://storage.googleapis.com/ztm_tf_course/food_vision/10_food_classes_10_percent.zip\n", + "Resolving storage.googleapis.com (storage.googleapis.com)... 74.125.24.207, 142.251.10.207, 142.251.12.207, ...\n", + "Connecting to storage.googleapis.com (storage.googleapis.com)|74.125.24.207|:443... connected.\n", "HTTP request sent, awaiting response... 200 OK\n", "Length: 168546183 (161M) [application/zip]\n", "Saving to: ‘10_food_classes_10_percent.zip’\n", "\n", - "10_food_classes_10_ 100%[===================>] 160.74M 242MB/s in 0.7s \n", + "10_food_classes_10_ 100%[===================>] 160.74M 22.5MB/s in 8.3s \n", "\n", - "2023-08-18 01:39:56 (242 MB/s) - ‘10_food_classes_10_percent.zip’ saved [168546183/168546183]\n", + "2024-01-14 13:37:47 (19.3 MB/s) - ‘10_food_classes_10_percent.zip’ saved [168546183/168546183]\n", "\n" ] } @@ -332,13 +379,13 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 9, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "8IHQ3i9s2lRm", - "outputId": "087ddaef-4dc9-4b5a-f91d-c68b62e6ce96" + "outputId": "ecc37b51-1a8f-4de9-a27a-9c03d565885b" }, "outputs": [ { @@ -347,27 +394,27 @@ "text": [ "There are 2 directories and 0 images in '10_food_classes_10_percent'.\n", "There are 10 directories and 0 images in '10_food_classes_10_percent/train'.\n", - "There are 0 directories and 75 images in '10_food_classes_10_percent/train/ramen'.\n", + "There are 0 directories and 75 images in '10_food_classes_10_percent/train/chicken_wings'.\n", "There are 0 directories and 75 images in '10_food_classes_10_percent/train/chicken_curry'.\n", + "There are 0 directories and 75 images in '10_food_classes_10_percent/train/fried_rice'.\n", + "There are 0 directories and 75 images in '10_food_classes_10_percent/train/sushi'.\n", + "There are 0 directories and 75 images in '10_food_classes_10_percent/train/hamburger'.\n", "There are 0 directories and 75 images in '10_food_classes_10_percent/train/pizza'.\n", + "There are 0 directories and 75 images in '10_food_classes_10_percent/train/ramen'.\n", "There are 0 directories and 75 images in '10_food_classes_10_percent/train/ice_cream'.\n", - "There are 0 directories and 75 images in '10_food_classes_10_percent/train/grilled_salmon'.\n", "There are 0 directories and 75 images in '10_food_classes_10_percent/train/steak'.\n", - "There are 0 directories and 75 images in '10_food_classes_10_percent/train/chicken_wings'.\n", - "There are 0 directories and 75 images in '10_food_classes_10_percent/train/hamburger'.\n", - "There are 0 directories and 75 images in '10_food_classes_10_percent/train/sushi'.\n", - "There are 0 directories and 75 images in '10_food_classes_10_percent/train/fried_rice'.\n", + "There are 0 directories and 75 images in '10_food_classes_10_percent/train/grilled_salmon'.\n", "There are 10 directories and 0 images in '10_food_classes_10_percent/test'.\n", - "There are 0 directories and 250 images in '10_food_classes_10_percent/test/ramen'.\n", + "There are 0 directories and 250 images in '10_food_classes_10_percent/test/chicken_wings'.\n", "There are 0 directories and 250 images in '10_food_classes_10_percent/test/chicken_curry'.\n", + "There are 0 directories and 250 images in '10_food_classes_10_percent/test/fried_rice'.\n", + "There are 0 directories and 250 images in '10_food_classes_10_percent/test/sushi'.\n", + "There are 0 directories and 250 images in '10_food_classes_10_percent/test/hamburger'.\n", "There are 0 directories and 250 images in '10_food_classes_10_percent/test/pizza'.\n", + "There are 0 directories and 250 images in '10_food_classes_10_percent/test/ramen'.\n", "There are 0 directories and 250 images in '10_food_classes_10_percent/test/ice_cream'.\n", - "There are 0 directories and 250 images in '10_food_classes_10_percent/test/grilled_salmon'.\n", "There are 0 directories and 250 images in '10_food_classes_10_percent/test/steak'.\n", - "There are 0 directories and 250 images in '10_food_classes_10_percent/test/chicken_wings'.\n", - "There are 0 directories and 250 images in '10_food_classes_10_percent/test/hamburger'.\n", - "There are 0 directories and 250 images in '10_food_classes_10_percent/test/sushi'.\n", - "There are 0 directories and 250 images in '10_food_classes_10_percent/test/fried_rice'.\n" + "There are 0 directories and 250 images in '10_food_classes_10_percent/test/grilled_salmon'.\n" ] } ], @@ -389,7 +436,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 10, "metadata": { "id": "tELTNwq6L43a" }, @@ -450,13 +497,13 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 11, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "QcBs8C5wJ0et", - "outputId": "35d11fff-8c73-4f12-a13d-0a7803972e9e" + "outputId": "8936bbe5-1532-474c-cbc7-57097d195101" }, "outputs": [ { @@ -501,24 +548,24 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 12, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "a30VfDiv3ZGc", - "outputId": "00de5349-a99a-4588-aea8-069e85a1a3a9" + "outputId": "62691305-5a58-4dd1-9866-30f1dbb61832" }, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ - "<_BatchDataset element_spec=(TensorSpec(shape=(None, 224, 224, 3), dtype=tf.float32, name=None), TensorSpec(shape=(None, 10), dtype=tf.float32, name=None))>" + "<_PrefetchDataset element_spec=(TensorSpec(shape=(None, 224, 224, 3), dtype=tf.float32, name=None), TensorSpec(shape=(None, 10), dtype=tf.float32, name=None))>" ] }, "metadata": {}, - "execution_count": 9 + "execution_count": 12 } ], "source": [ @@ -547,13 +594,13 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 13, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "9mRe2rnv7YdW", - "outputId": "44780671-7a8f-4cc3-d728-6c46b9e1d087" + "outputId": "fee19872-c22b-4d08-d8a5-68bc0f5df968" }, "outputs": [ { @@ -573,7 +620,7 @@ ] }, "metadata": {}, - "execution_count": 10 + "execution_count": 13 } ], "source": [ @@ -592,13 +639,13 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 14, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "cZ25UPow7q5K", - "outputId": "210f4a33-9a25-42f7-9094-c83c97b42e75" + "outputId": "b4b295a6-6451-4079-e6b3-c7898b0883c0" }, "outputs": [ { @@ -606,345 +653,345 @@ "name": "stdout", "text": [ "tf.Tensor(\n", - "[[[[1.18658157e+02 1.34658173e+02 1.34658173e+02]\n", - " [1.18117348e+02 1.34117340e+02 1.34117340e+02]\n", - " [1.19637756e+02 1.35637756e+02 1.35637756e+02]\n", + "[[[[4.03979607e+01 3.83979607e+01 2.63979588e+01]\n", + " [3.82091827e+01 3.52091827e+01 2.63520412e+01]\n", + " [1.34438801e+01 1.20153084e+01 6.58673620e+00]\n", " ...\n", - " [5.63165398e+01 9.91634979e+01 9.18114929e+01]\n", - " [6.20816345e+01 1.09224518e+02 1.03224518e+02]\n", - " [6.39487991e+01 1.12260063e+02 1.08489639e+02]]\n", + " [4.07655144e+00 9.29084587e+00 1.16479626e+01]\n", + " [5.33162165e+00 1.13316212e+01 1.13316212e+01]\n", + " [9.43889081e-01 4.48470879e+00 5.48470879e+00]]\n", "\n", - " [[1.06357147e+02 1.22357147e+02 1.21357147e+02]\n", - " [1.09709190e+02 1.25709190e+02 1.24709190e+02]\n", - " [1.12872452e+02 1.28872452e+02 1.27872452e+02]\n", + " [[3.23316345e+01 2.99999981e+01 1.89948978e+01]\n", + " [3.34132652e+01 3.04132652e+01 2.34132652e+01]\n", + " [1.73418388e+01 1.59132671e+01 1.16122475e+01]\n", " ...\n", - " [6.32701912e+01 1.05913071e+02 9.67702332e+01]\n", - " [6.22856750e+01 1.07270393e+02 1.02076508e+02]\n", - " [5.61224899e+01 1.01571533e+02 9.63112946e+01]]\n", + " [2.99999046e+00 7.21428490e+00 1.02142849e+01]\n", + " [2.14795732e+00 7.14795732e+00 1.01479568e+01]\n", + " [2.55104303e-02 3.73980474e+00 6.73980474e+00]]\n", "\n", - " [[9.16428604e+01 1.06071434e+02 1.05857147e+02]\n", - " [9.68418427e+01 1.11270416e+02 1.11056129e+02]\n", - " [1.00045921e+02 1.14474495e+02 1.14260208e+02]\n", + " [[2.23520412e+01 1.93520412e+01 1.27806129e+01]\n", + " [3.54744911e+01 3.24030609e+01 2.75459175e+01]\n", + " [2.35510235e+01 2.19081650e+01 1.96938801e+01]\n", " ...\n", - " [8.43824387e+01 1.24550812e+02 1.16336548e+02]\n", - " [7.37497177e+01 1.15162979e+02 1.08994621e+02]\n", - " [2.96886349e+01 7.09029236e+01 6.69029236e+01]]\n", + " [4.50507975e+00 5.93366861e+00 1.01479626e+01]\n", + " [2.03060484e+00 6.48981571e+00 1.11581774e+01]\n", + " [2.42856693e+00 7.21428108e+00 1.38571386e+01]]\n", "\n", " ...\n", "\n", - " [[7.94541016e+01 8.68878021e+01 8.90306473e+01]\n", - " [8.81582336e+01 9.64031525e+01 9.78163910e+01]\n", - " [9.55510254e+01 1.03428596e+02 1.04954079e+02]\n", + " [[3.63571854e+01 2.31429234e+01 1.49286585e+01]\n", + " [4.67960548e+01 3.33675270e+01 2.71532631e+01]\n", + " [4.16276855e+01 2.79184933e+01 2.37246704e+01]\n", " ...\n", - " [1.24428589e+02 1.21428589e+02 1.16000000e+02]\n", - " [1.22801048e+02 1.19586754e+02 1.12158165e+02]\n", - " [1.22933716e+02 1.19719421e+02 1.11862244e+02]]\n", + " [0.00000000e+00 4.00000000e+00 5.00000000e+00]\n", + " [0.00000000e+00 4.00000000e+00 5.00000000e+00]\n", + " [0.00000000e+00 3.78573608e+00 4.78573608e+00]]\n", "\n", - " [[9.76941833e+01 1.07643173e+02 1.08668678e+02]\n", - " [1.03255264e+02 1.13250168e+02 1.12250168e+02]\n", - " [9.99133377e+01 1.10097023e+02 1.08500069e+02]\n", + " [[3.39235458e+01 2.29235477e+01 1.89235477e+01]\n", + " [4.26275215e+01 3.16275234e+01 2.76377296e+01]\n", + " [3.58826218e+01 2.48264866e+01 2.25407963e+01]\n", " ...\n", - " [1.30443985e+02 1.27443985e+02 1.18586807e+02]\n", - " [1.29714355e+02 1.25714355e+02 1.14790840e+02]\n", - " [1.32857300e+02 1.27000122e+02 1.15071533e+02]]\n", + " [0.00000000e+00 3.19898486e+00 4.19898510e+00]\n", + " [0.00000000e+00 3.99489832e+00 4.99489832e+00]\n", + " [1.00000000e+00 5.00000000e+00 6.00000000e+00]]\n", "\n", - " [[9.17858047e+01 1.03785805e+02 1.01785805e+02]\n", - " [8.95970154e+01 1.01597015e+02 9.95970154e+01]\n", - " [8.95051575e+01 1.01505157e+02 9.75051575e+01]\n", + " [[4.15204048e+01 3.25204048e+01 2.75204029e+01]\n", + " [3.45559959e+01 2.45559959e+01 2.25559959e+01]\n", + " [3.27857513e+01 2.27857494e+01 2.15714645e+01]\n", " ...\n", - " [1.35357208e+02 1.33505112e+02 1.22775513e+02]\n", - " [1.34025513e+02 1.30025513e+02 1.18357147e+02]\n", - " [1.33086792e+02 1.29857208e+02 1.15545952e+02]]]\n", + " [0.00000000e+00 2.92345881e+00 3.92345881e+00]\n", + " [0.00000000e+00 2.97449350e+00 3.97449350e+00]\n", + " [0.00000000e+00 4.00000000e+00 5.00000000e+00]]]\n", "\n", "\n", - " [[[1.00561228e+01 1.34846935e+01 1.30714283e+01]\n", - " [1.87397976e+01 1.10255098e+01 8.76530552e+00]\n", - " [2.44948978e+01 1.09336739e+01 4.22448969e+00]\n", + " [[[3.35714293e+00 3.35714293e+00 3.35714293e+00]\n", + " [3.35714293e+00 3.35714293e+00 3.35714293e+00]\n", + " [3.35714293e+00 3.35714293e+00 3.35714293e+00]\n", " ...\n", - " [1.84438972e+01 1.08571215e+01 8.43875980e+00]\n", - " [1.86428566e+01 1.16428576e+01 5.64285707e+00]\n", - " [1.95867577e+01 1.18724718e+01 4.22961426e+00]]\n", + " [4.06427917e+01 1.42852783e+00 3.92347717e+00]\n", + " [3.24999733e+01 6.42857194e-01 1.57141554e+00]\n", + " [2.96428566e+01 6.42857194e-01 2.64285707e+00]]\n", "\n", - " [[1.50255108e+01 1.14030609e+01 1.49285717e+01]\n", - " [1.97806129e+01 9.20408058e+00 1.28622456e+01]\n", - " [1.88571415e+01 7.15816259e+00 6.84183645e+00]\n", + " [[3.92857170e+00 3.92857170e+00 3.92857170e+00]\n", + " [3.92857170e+00 3.92857170e+00 3.92857170e+00]\n", + " [3.92857170e+00 3.92857170e+00 3.92857170e+00]\n", " ...\n", - " [1.63265114e+01 1.22703876e+01 9.66830635e+00]\n", - " [1.59438534e+01 1.30000134e+01 7.72956896e+00]\n", - " [1.64080982e+01 1.43316650e+01 6.19381332e+00]]\n", + " [3.86427917e+01 2.00000000e+00 3.78573608e+00]\n", + " [3.47193642e+01 2.86224651e+00 5.79080486e+00]\n", + " [3.19285717e+01 2.92857170e+00 4.92857170e+00]]\n", "\n", - " [[1.38571434e+01 7.85714293e+00 9.42857170e+00]\n", - " [1.84438782e+01 1.00867357e+01 1.43010216e+01]\n", - " [1.81887741e+01 1.03367348e+01 1.41887751e+01]\n", + " [[6.00000000e+00 6.00000000e+00 6.00000000e+00]\n", + " [6.00000000e+00 6.00000000e+00 6.00000000e+00]\n", + " [6.00000000e+00 6.00000000e+00 6.00000000e+00]\n", " ...\n", - " [1.38112078e+01 1.21683502e+01 8.71933651e+00]\n", - " [1.24285717e+01 1.30000000e+01 7.42857170e+00]\n", - " [1.30765381e+01 1.40765381e+01 8.29082394e+00]]\n", + " [3.90000000e+01 4.66329956e+00 5.49494934e+00]\n", + " [3.51989784e+01 5.19897699e+00 7.19897699e+00]\n", + " [3.39234619e+01 3.92346191e+00 5.92346191e+00]]\n", "\n", " ...\n", "\n", - " [[1.65714722e+01 1.17857361e+01 8.50511646e+00]\n", - " [1.60561237e+01 1.00561237e+01 1.15153484e+01]\n", - " [1.53060913e+01 9.21426392e+00 1.06938648e+01]\n", + " [[1.10566269e+02 1.59785629e+02 1.87571304e+02]\n", + " [1.09642815e+02 1.59658096e+02 1.87158051e+02]\n", + " [1.11811188e+02 1.61428513e+02 1.89071320e+02]\n", " ...\n", - " [1.58775539e+01 1.18316450e+01 8.78573608e+00]\n", - " [1.82703991e+01 1.32703981e+01 1.02703981e+01]\n", - " [1.81377335e+01 1.31377335e+01 9.35199738e+00]]\n", + " [0.00000000e+00 3.00000000e+00 1.49493527e+00]\n", + " [0.00000000e+00 3.01530743e+00 1.01530743e+00]\n", + " [0.00000000e+00 4.00000000e+00 2.00000000e+00]]\n", "\n", - " [[1.50000000e+01 1.00000000e+01 6.64285707e+00]\n", - " [1.59948969e+01 9.99489689e+00 1.19847174e+01]\n", - " [1.60714417e+01 1.00000000e+01 1.42143250e+01]\n", + " [[1.11000000e+02 1.54785675e+02 1.81857117e+02]\n", + " [1.05285713e+02 1.50994873e+02 1.77005051e+02]\n", + " [1.10857147e+02 1.56316315e+02 1.80984680e+02]\n", " ...\n", - " [1.70561352e+01 1.30561342e+01 1.04846621e+01]\n", - " [1.68622208e+01 1.28622208e+01 9.86222076e+00]\n", - " [1.79540749e+01 1.29540758e+01 8.95407581e+00]]\n", + " [1.98956549e-01 2.12751484e+00 0.00000000e+00]\n", + " [0.00000000e+00 1.93366230e+00 9.33662236e-01]\n", + " [0.00000000e+00 2.42861938e+00 1.42861938e+00]]\n", "\n", - " [[1.63571777e+01 1.13571777e+01 8.00003529e+00]\n", - " [1.60000000e+01 1.00000000e+01 1.37142868e+01]\n", - " [1.56428223e+01 8.64282227e+00 1.59234619e+01]\n", + " [[1.06316200e+02 1.46316193e+02 1.72316193e+02]\n", + " [1.07423492e+02 1.48617310e+02 1.73066315e+02]\n", + " [1.11198959e+02 1.52637680e+02 1.76918320e+02]\n", " ...\n", - " [1.78521194e+01 1.44949112e+01 1.32806473e+01]\n", - " [1.59285583e+01 1.19285583e+01 8.92855835e+00]\n", - " [1.73571777e+01 1.23571777e+01 8.35717773e+00]]]\n", + " [2.86241913e+00 3.07668304e+00 1.27565038e+00]\n", + " [3.57177734e-01 2.35717773e+00 1.35717773e+00]\n", + " [6.42822266e-01 1.64282227e+00 3.64282227e+00]]]\n", "\n", "\n", - " [[[9.96428604e+01 4.36428566e+01 2.66428566e+01]\n", - " [1.00974487e+02 4.49744911e+01 2.79744892e+01]\n", - " [1.00928566e+02 4.55714302e+01 2.83571434e+01]\n", + " [[[0.00000000e+00 0.00000000e+00 0.00000000e+00]\n", + " [9.28571701e-01 9.28571701e-01 0.00000000e+00]\n", + " [0.00000000e+00 2.00000000e+00 0.00000000e+00]\n", " ...\n", - " [1.59892273e+02 1.26616730e+02 9.66270294e+01]\n", - " [9.49591599e+01 5.68213806e+01 3.52959061e+01]\n", - " [8.11578674e+01 3.91578674e+01 2.31578693e+01]]\n", + " [2.33164978e+00 6.61736393e+00 5.56102216e-01]\n", + " [6.86227226e+00 1.21479864e+01 2.60205960e+00]\n", + " [1.15000353e+01 1.70153637e+01 4.77042055e+00]]\n", "\n", - " [[9.77397995e+01 4.17397957e+01 2.47397957e+01]\n", - " [9.90051041e+01 4.30051041e+01 2.60051022e+01]\n", - " [1.00770409e+02 4.54132690e+01 2.81989803e+01]\n", + " [[0.00000000e+00 0.00000000e+00 0.00000000e+00]\n", + " [9.28571701e-01 9.28571701e-01 0.00000000e+00]\n", + " [0.00000000e+00 2.00000000e+00 0.00000000e+00]\n", " ...\n", - " [6.65968018e+01 3.01681900e+01 2.42336082e+00]\n", - " [6.98725586e+01 2.89388580e+01 9.08175468e+00]\n", - " [8.22501984e+01 3.64389687e+01 2.14440765e+01]]\n", + " [2.83317585e+01 3.12603302e+01 1.37603302e+01]\n", + " [4.12653542e+01 4.41939240e+01 2.68418865e+01]\n", + " [4.54744873e+01 4.83775444e+01 3.11683693e+01]]\n", "\n", - " [[1.03571426e+02 4.71428566e+01 3.23571434e+01]\n", - " [1.00071426e+02 4.40714264e+01 2.90714283e+01]\n", - " [9.82602081e+01 4.22602043e+01 2.72602043e+01]\n", + " [[0.00000000e+00 0.00000000e+00 0.00000000e+00]\n", + " [9.28571701e-01 9.28571701e-01 0.00000000e+00]\n", + " [0.00000000e+00 2.00000000e+00 0.00000000e+00]\n", " ...\n", - " [8.19692001e+01 4.12548027e+01 1.43263178e+01]\n", - " [8.23265686e+01 3.61989899e+01 1.27245321e+01]\n", - " [8.15460205e+01 3.23317337e+01 1.40460205e+01]]\n", + " [5.45765457e+01 5.73622589e+01 3.06684151e+01]\n", + " [5.38877335e+01 5.58877335e+01 3.24438820e+01]\n", + " [5.05764694e+01 5.24999313e+01 3.17295456e+01]]\n", "\n", " ...\n", "\n", - " [[7.69943161e+01 4.02750015e+01 7.95883179e+00]\n", - " [1.49617050e+02 1.07101807e+02 6.84590378e+01]\n", - " [1.72382751e+02 1.23142990e+02 7.40257111e+01]\n", + " [[1.93520546e+01 8.70917225e+00 0.00000000e+00]\n", + " [1.94847107e+01 8.84182739e+00 0.00000000e+00]\n", + " [1.94285812e+01 8.99999142e+00 0.00000000e+00]\n", " ...\n", - " [1.24050819e+02 1.10096733e+02 6.00713196e+01]\n", - " [1.25897758e+02 1.11469231e+02 6.21835861e+01]\n", - " [1.36408173e+02 1.21979645e+02 7.45511169e+01]]\n", + " [5.45714111e+01 3.49540253e+01 2.14263916e-01]\n", + " [5.56428223e+01 3.28571472e+01 0.00000000e+00]\n", + " [5.00050087e+01 3.23519859e+01 0.00000000e+00]]\n", "\n", - " [[5.31785240e+01 2.17499924e+01 2.08678961e+00]\n", - " [8.83721466e+01 5.16629753e+01 2.31681156e+01]\n", - " [1.69887405e+02 1.21387421e+02 8.01731873e+01]\n", + " [[2.09744968e+01 7.97449589e+00 0.00000000e+00]\n", + " [2.10663280e+01 8.06632710e+00 0.00000000e+00]\n", + " [2.11428757e+01 9.14287472e+00 0.00000000e+00]\n", " ...\n", - " [1.03188866e+02 9.80715027e+01 4.75154610e+01]\n", - " [1.07494804e+02 9.97652588e+01 5.28469086e+01]\n", - " [1.18214325e+02 1.07500092e+02 6.25715332e+01]]\n", + " [5.20714111e+01 3.15560493e+01 2.14263916e-01]\n", + " [5.47907753e+01 3.19387627e+01 8.62248957e-01]\n", + " [4.86937141e+01 3.06887264e+01 0.00000000e+00]]\n", "\n", - " [[4.53569336e+01 1.83263817e+01 7.04070187e+00]\n", - " [5.42549515e+01 2.05866871e+01 1.83662802e-01]\n", - " [1.09019783e+02 6.42289886e+01 2.82239151e+01]\n", + " [[2.30561142e+01 1.00561152e+01 1.41325808e+00]\n", + " [2.33112164e+01 1.03112164e+01 1.31121600e+00]\n", + " [2.28571396e+01 1.08571386e+01 0.00000000e+00]\n", " ...\n", - " [9.87245026e+01 9.85969162e+01 4.91582108e+01]\n", - " [8.90457077e+01 8.59538651e+01 4.18059921e+01]\n", - " [9.70410385e+01 9.20410385e+01 5.07553978e+01]]]\n", + " [4.99286194e+01 3.05714111e+01 4.64285278e+00]\n", + " [5.13316307e+01 3.10000000e+01 5.28570557e+00]\n", + " [4.60560303e+01 2.95407753e+01 2.69891500e+00]]]\n", "\n", "\n", " ...\n", "\n", "\n", - " [[[2.54000000e+02 2.54000000e+02 2.54000000e+02]\n", - " [2.54000000e+02 2.54000000e+02 2.54000000e+02]\n", - " [2.54000000e+02 2.54000000e+02 2.54000000e+02]\n", + " [[[2.26984695e+02 2.44397949e+02 1.98158173e+02]\n", + " [2.25857132e+02 2.43857132e+02 1.94000000e+02]\n", + " [2.29857132e+02 2.49933670e+02 1.96704086e+02]\n", " ...\n", - " [1.03785736e+02 1.04785736e+02 9.07857361e+01]\n", - " [1.04071442e+02 1.05071442e+02 9.10714417e+01]\n", - " [1.05000000e+02 1.06000000e+02 9.20000000e+01]]\n", + " [1.83494812e+02 2.35066284e+02 1.99280548e+02]\n", + " [1.82188797e+02 2.36188797e+02 2.00188797e+02]\n", + " [1.80928467e+02 2.36101974e+02 1.99515228e+02]]\n", "\n", - " [[2.54000000e+02 2.54000000e+02 2.54000000e+02]\n", - " [2.54000000e+02 2.54000000e+02 2.54000000e+02]\n", - " [2.54000000e+02 2.54000000e+02 2.54000000e+02]\n", + " [[2.28903061e+02 2.48903061e+02 1.96096939e+02]\n", + " [2.26285706e+02 2.46285706e+02 1.93295914e+02]\n", + " [2.30586731e+02 2.51229584e+02 1.99872452e+02]\n", " ...\n", - " [1.04729614e+02 1.05729614e+02 9.17296143e+01]\n", - " [1.04933678e+02 1.05933678e+02 9.19336777e+01]\n", - " [1.05000000e+02 1.06000000e+02 9.20000000e+01]]\n", + " [1.86387695e+02 2.36499939e+02 2.01015289e+02]\n", + " [1.85846954e+02 2.37857162e+02 2.01857162e+02]\n", + " [1.86025452e+02 2.38831635e+02 2.02831635e+02]]\n", "\n", - " [[2.54000000e+02 2.54000000e+02 2.54000000e+02]\n", - " [2.54000000e+02 2.54000000e+02 2.54000000e+02]\n", - " [2.54000000e+02 2.54000000e+02 2.54000000e+02]\n", + " [[2.23714294e+02 2.48928574e+02 1.90285721e+02]\n", + " [2.23000000e+02 2.46484680e+02 1.90142853e+02]\n", + " [2.27260193e+02 2.49596939e+02 2.00903061e+02]\n", " ...\n", - " [1.05382637e+02 1.06382637e+02 9.23826370e+01]\n", - " [1.05000000e+02 1.06000000e+02 9.20000000e+01]\n", - " [1.05000000e+02 1.06000000e+02 9.20000000e+01]]\n", + " [1.89336716e+02 2.38188812e+02 2.02806183e+02]\n", + " [1.89943863e+02 2.39301010e+02 2.04086731e+02]\n", + " [1.88147934e+02 2.37505081e+02 2.02719360e+02]]\n", "\n", " ...\n", "\n", - " [[1.51000366e+02 1.23148277e+02 8.75717087e+01]\n", - " [1.81531052e+02 1.54173843e+02 1.14031006e+02]\n", - " [2.01418442e+02 1.77464355e+02 1.29372528e+02]\n", + " [[2.42000061e+02 2.52428589e+02 4.22244301e+01]\n", + " [2.43484741e+02 2.52857162e+02 4.04285278e+01]\n", + " [2.45571472e+02 2.51974548e+02 3.61224136e+01]\n", " ...\n", - " [1.56698837e+02 1.34270309e+02 9.72243958e+01]\n", - " [1.67561020e+02 1.44703964e+02 1.07703964e+02]\n", - " [1.80540848e+02 1.55683792e+02 1.19469528e+02]]\n", + " [2.39785736e+02 2.42000000e+02 9.33149242e+00]\n", + " [2.39000000e+02 2.46872482e+02 5.04076576e+00]\n", + " [2.39137741e+02 2.48494919e+02 1.04847336e+01]]\n", "\n", - " [[1.66280731e+02 1.41760361e+02 1.06020538e+02]\n", - " [1.74851913e+02 1.51122360e+02 1.13341789e+02]\n", - " [1.67749680e+02 1.45892563e+02 1.07321213e+02]\n", + " [[2.44382660e+02 2.51428589e+02 3.36224327e+01]\n", + " [2.40005066e+02 2.47938751e+02 2.70050488e+01]\n", + " [2.45499939e+02 2.51285645e+02 2.87295036e+01]\n", " ...\n", - " [1.67688797e+02 1.49688797e+02 1.11688797e+02]\n", - " [1.50270462e+02 1.32270462e+02 9.61377792e+01]\n", - " [1.44224365e+02 1.26224358e+02 9.02243576e+01]]\n", + " [2.41714294e+02 2.42285767e+02 2.85693359e+00]\n", + " [2.41209229e+02 2.45852020e+02 6.63377419e-02]\n", + " [2.42071442e+02 2.45760162e+02 9.92864990e+00]]\n", "\n", - " [[1.86229233e+02 1.67770065e+02 1.31999649e+02]\n", - " [1.52626785e+02 1.34698318e+02 1.02295227e+02]\n", - " [1.28321167e+02 1.11397705e+02 8.26171722e+01]\n", + " [[2.44459152e+02 2.52459152e+02 2.99183178e+01]\n", + " [2.41520538e+02 2.49852203e+02 2.42807083e+01]\n", + " [2.41566452e+02 2.49061386e+02 1.95766068e+01]\n", " ...\n", - " [1.54229584e+02 1.36306122e+02 9.60765305e+01]\n", - " [1.69928619e+02 1.51928619e+02 1.12020470e+02]\n", - " [1.49765457e+02 1.34765457e+02 9.57654572e+01]]]\n", + " [2.42347031e+02 2.42653183e+02 3.15275550e+00]\n", + " [2.45071533e+02 2.43331665e+02 0.00000000e+00]\n", + " [2.45071533e+02 2.40642822e+02 6.14306641e+00]]]\n", "\n", "\n", - " [[[1.60000000e+01 9.00000000e+00 0.00000000e+00]\n", - " [1.80373096e+01 8.03730869e+00 0.00000000e+00]\n", - " [2.04422836e+01 8.15210438e+00 1.52678585e+00]\n", + " [[[1.26428576e+01 4.64285707e+00 1.64285719e+00]\n", + " [1.29744902e+01 4.97448969e+00 1.97448993e+00]\n", + " [1.48571434e+01 6.85714293e+00 3.85714293e+00]\n", " ...\n", - " [1.41512177e+02 8.60389099e+01 5.67488060e+01]\n", - " [1.31497604e+02 7.44976120e+01 4.74976120e+01]\n", - " [9.87061234e+01 4.07061234e+01 1.82527027e+01]]\n", + " [2.54403122e+02 2.47842194e+02 2.41413666e+02]\n", + " [2.51811249e+02 2.54668365e+02 2.45525482e+02]\n", + " [2.45683319e+02 2.47968964e+02 2.30611786e+02]]\n", "\n", - " [[1.72560596e+01 9.60108471e+00 1.92857170e+00]\n", - " [1.90000000e+01 8.00000000e+00 2.00000000e+00]\n", - " [2.05267868e+01 7.23660707e+00 3.52678585e+00]\n", + " [[1.40000000e+01 7.00000000e+00 1.00000000e+00]\n", + " [1.40000000e+01 7.00000000e+00 1.00000000e+00]\n", + " [1.42857141e+01 7.28571415e+00 1.28571415e+00]\n", " ...\n", - " [1.37288544e+02 7.97384033e+01 5.13768768e+01]\n", - " [1.32715057e+02 7.09780884e+01 4.58486443e+01]\n", - " [1.25001762e+02 6.13413200e+01 3.88709908e+01]]\n", + " [2.55000000e+02 2.53637894e+02 2.47796143e+02]\n", + " [2.51147980e+02 2.55000000e+02 2.48586685e+02]\n", + " [2.42167984e+02 2.42453629e+02 2.26933090e+02]]\n", "\n", - " [[1.80000000e+01 8.78571415e+00 4.42857170e+00]\n", - " [2.12598858e+01 7.25988531e+00 4.25988531e+00]\n", - " [2.27633934e+01 7.23660707e+00 6.52678585e+00]\n", + " [[1.74285717e+01 8.42857170e+00 3.42857170e+00]\n", + " [1.55000000e+01 6.50000000e+00 1.50000000e+00]\n", + " [1.52142859e+01 6.21428585e+00 1.21428585e+00]\n", " ...\n", - " [1.35598724e+02 7.42236252e+01 4.85731277e+01]\n", - " [1.30317886e+02 6.42071915e+01 3.97330399e+01]\n", - " [1.44314301e+02 7.44399185e+01 5.00696678e+01]]\n", + " [2.51596878e+02 2.54234772e+02 2.48500168e+02]\n", + " [2.49943909e+02 2.55000000e+02 2.49515259e+02]\n", + " [2.46663010e+02 2.44076218e+02 2.31234299e+02]]\n", "\n", " ...\n", "\n", - " [[5.50862360e+00 4.50862360e+00 5.08623779e-01]\n", - " [4.74013519e+00 3.74013519e+00 0.00000000e+00]\n", - " [4.00000000e+00 3.00000000e+00 0.00000000e+00]\n", + " [[1.67443893e+02 4.88724251e+01 7.21940184e+00]\n", + " [1.69280670e+02 5.32092361e+01 6.42352057e+00]\n", + " [1.74969254e+02 5.93978310e+01 7.75497341e+00]\n", " ...\n", - " [2.16505070e+01 1.66505070e+01 1.26505070e+01]\n", - " [2.12142639e+01 1.62142639e+01 1.22142639e+01]\n", - " [2.12142639e+01 1.62142639e+01 1.22142639e+01]]\n", + " [2.50168350e+02 1.41168350e+02 5.81683540e+01]\n", + " [2.47872421e+02 1.38872421e+02 5.38724251e+01]\n", + " [2.44719345e+02 1.35719345e+02 5.07193527e+01]]\n", "\n", - " [[5.60107565e+00 4.60107565e+00 6.01075709e-01]\n", - " [5.00000000e+00 4.00000000e+00 0.00000000e+00]\n", - " [5.00000000e+00 4.00000000e+00 0.00000000e+00]\n", + " [[1.73382751e+02 5.90052605e+01 5.57659721e+00]\n", + " [2.03882706e+02 9.28878403e+01 3.64540672e+01]\n", + " [1.64061234e+02 5.55459785e+01 0.00000000e+00]\n", " ...\n", - " [2.64329834e+01 2.14329834e+01 1.74329834e+01]\n", - " [2.13169250e+01 1.63169250e+01 1.23169250e+01]\n", - " [1.90251942e+01 1.40251951e+01 1.00251951e+01]]\n", + " [2.48071442e+02 1.39071442e+02 5.60714417e+01]\n", + " [2.48005096e+02 1.39005096e+02 5.40051041e+01]\n", + " [2.46811218e+02 1.37811218e+02 5.28112221e+01]]\n", "\n", - " [[3.76879120e+00 2.76879120e+00 0.00000000e+00]\n", - " [5.02072906e+00 4.02072906e+00 2.07291134e-02]\n", - " [5.84790373e+00 4.84790373e+00 8.47903728e-01]\n", + " [[2.00730042e+02 9.63984756e+01 2.46585007e+01]\n", + " [1.90377228e+02 8.82853928e+01 1.52597713e+01]\n", + " [2.13363831e+02 1.13869080e+02 4.12261124e+01]\n", " ...\n", - " [2.81019630e+01 2.31019630e+01 1.91019630e+01]\n", - " [2.44732056e+01 1.94732056e+01 1.54732056e+01]\n", - " [2.17098389e+01 1.67098389e+01 1.27098389e+01]]]\n", + " [2.49505081e+02 1.40505081e+02 5.75050888e+01]\n", + " [2.48617310e+02 1.39617310e+02 5.46173058e+01]\n", + " [2.47285645e+02 1.38285645e+02 5.32856445e+01]]]\n", "\n", "\n", - " [[[1.38484695e+02 1.24229591e+02 1.24357140e+02]\n", - " [1.37551025e+02 1.25474495e+02 1.27500008e+02]\n", - " [1.41642853e+02 1.30642853e+02 1.37071426e+02]\n", + " [[[1.21903061e+02 1.13903061e+02 9.49030609e+01]\n", + " [1.25306122e+02 1.17306122e+02 9.83061218e+01]\n", + " [1.13071426e+02 1.07061226e+02 8.85663223e+01]\n", " ...\n", - " [1.36806229e+02 7.66633682e+01 7.10919342e+01]\n", - " [1.23571205e+02 7.72651825e+01 6.48824997e+01]\n", - " [8.62853622e+01 5.75712547e+01 3.92854691e+01]]\n", + " [2.44000000e+02 1.28010239e+02 1.07505119e+02]\n", + " [2.42739822e+02 1.33214355e+02 1.12500053e+02]\n", + " [2.49352142e+02 1.43581757e+02 1.21581749e+02]]\n", "\n", - " [[1.33163269e+02 1.16306122e+02 1.16331627e+02]\n", - " [1.33005096e+02 1.17852043e+02 1.20714287e+02]\n", - " [1.35816330e+02 1.23244896e+02 1.30459183e+02]\n", + " [[1.34668365e+02 1.23668365e+02 1.05668365e+02]\n", + " [1.17265305e+02 1.09265305e+02 9.02653046e+01]\n", + " [1.20423462e+02 1.11994896e+02 9.47091827e+01]\n", " ...\n", - " [9.15152588e+01 5.30867348e+01 5.65152817e+01]\n", - " [7.96835403e+01 5.30356674e+01 5.03111496e+01]\n", - " [5.42649994e+01 4.33110542e+01 3.53110161e+01]]\n", + " [2.46270370e+02 1.36913239e+02 1.15556145e+02]\n", + " [2.44147949e+02 1.39280640e+02 1.17214294e+02]\n", + " [2.40428497e+02 1.40617310e+02 1.17688736e+02]]\n", "\n", - " [[1.42214294e+02 1.21928574e+02 1.23071426e+02]\n", - " [1.40397949e+02 1.24183670e+02 1.27112244e+02]\n", - " [1.40928558e+02 1.28188782e+02 1.35739792e+02]\n", + " [[9.90867310e+01 8.80867310e+01 7.00867310e+01]\n", + " [9.75663223e+01 8.65663223e+01 6.85663223e+01]\n", + " [1.01403061e+02 9.00459137e+01 7.38316269e+01]\n", " ...\n", - " [5.83366356e+01 4.21683273e+01 5.07397346e+01]\n", - " [5.45663376e+01 4.67398643e+01 5.04082108e+01]\n", - " [5.12038918e+01 5.11376419e+01 5.01376076e+01]]\n", + " [2.43642838e+02 1.38642838e+02 1.17474487e+02]\n", + " [2.38199005e+02 1.38071472e+02 1.15699020e+02]\n", + " [2.46622635e+02 1.50622635e+02 1.27051201e+02]]\n", "\n", " ...\n", "\n", - " [[7.41377640e+01 3.99948845e+01 2.08571262e+01]\n", - " [6.82295914e+01 3.51989784e+01 1.61989784e+01]\n", - " [6.40000000e+01 3.34285736e+01 1.58571434e+01]\n", + " [[4.40509872e+01 2.30509853e+01 1.80509853e+01]\n", + " [4.47040977e+01 2.37040977e+01 1.87040977e+01]\n", + " [4.45969009e+01 2.35969009e+01 1.85969009e+01]\n", " ...\n", - " [1.67765320e+02 1.39551056e+02 1.03193848e+02]\n", - " [1.69755112e+02 1.43755112e+02 1.06755119e+02]\n", - " [1.64994873e+02 1.39209167e+02 1.01566284e+02]]\n", + " [2.15785736e+02 2.25785736e+02 2.26785736e+02]\n", + " [2.14142822e+02 2.24142822e+02 2.25142822e+02]\n", + " [2.14571442e+02 2.24571442e+02 2.25571442e+02]]\n", "\n", - " [[7.61020660e+01 3.91938820e+01 2.01479759e+01]\n", - " [7.46531754e+01 3.96531448e+01 2.07194729e+01]\n", - " [6.97041855e+01 3.91327591e+01 2.15613327e+01]\n", + " [[4.53775406e+01 2.13775425e+01 1.73775425e+01]\n", + " [4.85816078e+01 2.45816097e+01 2.05816097e+01]\n", + " [4.61989784e+01 2.21989784e+01 1.81989784e+01]\n", " ...\n", - " [1.71642914e+02 1.43428650e+02 1.07071442e+02]\n", - " [1.69999908e+02 1.43999908e+02 1.06999908e+02]\n", - " [1.64494888e+02 1.39494888e+02 9.94948883e+01]]\n", + " [2.15913254e+02 2.25913254e+02 2.26913254e+02]\n", + " [2.13857117e+02 2.23857117e+02 2.24857117e+02]\n", + " [2.14285736e+02 2.24285736e+02 2.25285736e+02]]\n", "\n", - " [[7.87857056e+01 4.10153008e+01 2.20153008e+01]\n", - " [7.00408401e+01 3.48979874e+01 1.59694157e+01]\n", - " [7.56938705e+01 4.48469353e+01 2.68469372e+01]\n", + " [[4.67449417e+01 2.27449436e+01 1.87449436e+01]\n", + " [4.51938820e+01 2.11938820e+01 1.71938820e+01]\n", + " [4.77143555e+01 2.37143555e+01 1.97143555e+01]\n", " ...\n", - " [1.64714294e+02 1.36500031e+02 1.00142822e+02]\n", - " [1.55663269e+02 1.30663269e+02 9.06632614e+01]\n", - " [1.59474701e+02 1.34474701e+02 9.44746933e+01]]]], shape=(32, 224, 224, 3), dtype=float32) tf.Tensor(\n", - "[[0. 0. 0. 0. 0. 1. 0. 0. 0. 0.]\n", - " [0. 0. 0. 1. 0. 0. 0. 0. 0. 0.]\n", + " [2.15142914e+02 2.25142914e+02 2.26142914e+02]\n", + " [2.14311249e+02 2.24311249e+02 2.25311249e+02]\n", + " [2.15071533e+02 2.25071533e+02 2.26071533e+02]]]], shape=(32, 224, 224, 3), dtype=float32) tf.Tensor(\n", + "[[0. 0. 0. 0. 0. 0. 0. 1. 0. 0.]\n", + " [0. 0. 0. 0. 0. 0. 0. 0. 0. 1.]\n", + " [0. 0. 0. 0. 1. 0. 0. 0. 0. 0.]\n", + " [0. 0. 0. 0. 0. 0. 0. 0. 1. 0.]\n", + " [1. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", + " [0. 1. 0. 0. 0. 0. 0. 0. 0. 0.]\n", + " [0. 0. 0. 0. 0. 0. 0. 0. 1. 0.]\n", + " [0. 0. 0. 0. 0. 0. 1. 0. 0. 0.]\n", " [0. 0. 0. 0. 0. 0. 0. 1. 0. 0.]\n", - " [0. 0. 0. 0. 0. 1. 0. 0. 0. 0.]\n", " [0. 0. 0. 0. 0. 0. 0. 0. 1. 0.]\n", " [0. 0. 0. 0. 0. 0. 0. 1. 0. 0.]\n", - " [0. 0. 0. 1. 0. 0. 0. 0. 0. 0.]\n", - " [0. 0. 0. 0. 1. 0. 0. 0. 0. 0.]\n", " [0. 0. 0. 0. 0. 1. 0. 0. 0. 0.]\n", + " [0. 0. 1. 0. 0. 0. 0. 0. 0. 0.]\n", + " [0. 0. 0. 0. 1. 0. 0. 0. 0. 0.]\n", + " [0. 0. 0. 0. 0. 0. 0. 0. 1. 0.]\n", " [0. 0. 0. 0. 0. 1. 0. 0. 0. 0.]\n", + " [0. 0. 0. 0. 0. 0. 0. 0. 1. 0.]\n", + " [0. 0. 0. 0. 0. 0. 0. 0. 1. 0.]\n", " [1. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", " [0. 0. 0. 0. 0. 0. 1. 0. 0. 0.]\n", - " [0. 0. 1. 0. 0. 0. 0. 0. 0. 0.]\n", - " [0. 0. 0. 0. 0. 0. 0. 1. 0. 0.]\n", - " [0. 0. 0. 0. 0. 0. 1. 0. 0. 0.]\n", - " [0. 0. 1. 0. 0. 0. 0. 0. 0. 0.]\n", - " [0. 0. 0. 0. 0. 0. 0. 0. 0. 1.]\n", - " [0. 1. 0. 0. 0. 0. 0. 0. 0. 0.]\n", - " [0. 0. 0. 0. 0. 0. 0. 0. 0. 1.]\n", " [0. 0. 0. 0. 0. 1. 0. 0. 0. 0.]\n", - " [0. 0. 0. 0. 0. 0. 1. 0. 0. 0.]\n", - " [0. 0. 0. 0. 0. 0. 0. 1. 0. 0.]\n", - " [0. 1. 0. 0. 0. 0. 0. 0. 0. 0.]\n", " [0. 0. 0. 0. 0. 0. 0. 0. 0. 1.]\n", - " [0. 1. 0. 0. 0. 0. 0. 0. 0. 0.]\n", " [0. 0. 0. 0. 1. 0. 0. 0. 0. 0.]\n", " [0. 1. 0. 0. 0. 0. 0. 0. 0. 0.]\n", - " [0. 1. 0. 0. 0. 0. 0. 0. 0. 0.]\n", - " [0. 0. 0. 0. 0. 0. 0. 0. 0. 1.]\n", - " [0. 0. 0. 0. 1. 0. 0. 0. 0. 0.]\n", + " [0. 0. 0. 0. 0. 0. 1. 0. 0. 0.]\n", + " [0. 0. 0. 0. 0. 0. 1. 0. 0. 0.]\n", + " [0. 0. 0. 0. 0. 0. 1. 0. 0. 0.]\n", + " [1. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", " [0. 0. 0. 0. 1. 0. 0. 0. 0. 0.]\n", - " [0. 1. 0. 0. 0. 0. 0. 0. 0. 0.]], shape=(32, 10), dtype=float32)\n" + " [0. 0. 0. 0. 0. 0. 1. 0. 0. 0.]\n", + " [0. 0. 0. 0. 0. 0. 0. 0. 1. 0.]\n", + " [0. 0. 0. 1. 0. 0. 0. 0. 0. 0.]], shape=(32, 10), dtype=float32)\n" ] } ], @@ -996,13 +1043,13 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 15, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "ayNga8DsJLPa", - "outputId": "955e6fca-2837-4207-9bca-cbb7517fa01e" + "outputId": "931ae9a1-80d0-4878-f899-590ba269a624" }, "outputs": [ { @@ -1010,20 +1057,20 @@ "name": "stdout", "text": [ "Downloading data from https://storage.googleapis.com/tensorflow/keras-applications/efficientnet_v2/efficientnetv2-b0_notop.h5\n", - "24274472/24274472 [==============================] - 0s 0us/step\n", + "24274472/24274472 [==============================] - 2s 0us/step\n", "Shape after base_model: (None, 7, 7, 1280)\n", "After GlobalAveragePooling2D(): (None, 1280)\n", - "Saving TensorBoard log files to: transfer_learning/10_percent_feature_extract/20230818-014007\n", + "Saving TensorBoard log files to: logs/fit/\n", "Epoch 1/5\n", - "24/24 [==============================] - 20s 156ms/step - loss: 1.8704 - accuracy: 0.4387 - val_loss: 1.2824 - val_accuracy: 0.7418\n", + "24/24 [==============================] - 21s 371ms/step - loss: 1.9282 - accuracy: 0.4120 - val_loss: 1.3456 - val_accuracy: 0.7220\n", "Epoch 2/5\n", - "24/24 [==============================] - 2s 85ms/step - loss: 1.1395 - accuracy: 0.7533 - val_loss: 0.8783 - val_accuracy: 0.8010\n", + "24/24 [==============================] - 4s 130ms/step - loss: 1.1641 - accuracy: 0.7427 - val_loss: 0.8849 - val_accuracy: 0.8240\n", "Epoch 3/5\n", - "24/24 [==============================] - 2s 67ms/step - loss: 0.8327 - accuracy: 0.8147 - val_loss: 0.7168 - val_accuracy: 0.8322\n", + "24/24 [==============================] - 5s 195ms/step - loss: 0.8507 - accuracy: 0.8200 - val_loss: 0.7335 - val_accuracy: 0.8355\n", "Epoch 4/5\n", - "24/24 [==============================] - 2s 85ms/step - loss: 0.6915 - accuracy: 0.8453 - val_loss: 0.6149 - val_accuracy: 0.8520\n", + "24/24 [==============================] - 5s 174ms/step - loss: 0.6879 - accuracy: 0.8440 - val_loss: 0.6350 - val_accuracy: 0.8388\n", "Epoch 5/5\n", - "24/24 [==============================] - 2s 86ms/step - loss: 0.5813 - accuracy: 0.8720 - val_loss: 0.5555 - val_accuracy: 0.8569\n" + "24/24 [==============================] - 4s 131ms/step - loss: 0.5955 - accuracy: 0.8667 - val_loss: 0.5508 - val_accuracy: 0.8684\n" ] } ], @@ -1071,7 +1118,7 @@ " # Go through less of the validation data so epochs are faster (we want faster experiments!)\n", " validation_steps=int(0.25 * len(test_data_10_percent)),\n", " # Track our model's training logs for visualization later\n", - " callbacks=[create_tensorboard_callback(\"transfer_learning\", \"10_percent_feature_extract\")])" + " callbacks=[create_tensorboard_callback(\"10_percent_feature_extract\")])" ] }, { @@ -1099,13 +1146,13 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 16, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "lUuQOyKv4_27", - "outputId": "7e8f891e-68ba-4a95-e809-f0e1dba4cec2" + "outputId": "59d6b4a5-6122-4b41-a568-9ea8b3a92d78" }, "outputs": [ { @@ -1404,13 +1451,13 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 17, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "0gKubJmUu91N", - "outputId": "c95e6e11-671e-4d43-a83d-10cafb8874a5" + "outputId": "38afc5bf-7cfa-4fcb-c3fc-58a1d180321b" }, "outputs": [ { @@ -1419,774 +1466,771 @@ "text": [ "Model: \"efficientnetv2-b0\"\n", "__________________________________________________________________________________________________\n", - " Layer (type) Output Shape Param # Connected to \n", + " Layer (type) Output Shape Param # Connected to \n", "==================================================================================================\n", - " input_1 (InputLayer) [(None, None, None, 0 [] \n", - " 3)] \n", + " input_1 (InputLayer) [(None, None, None, 3)] 0 [] \n", " \n", - " rescaling (Rescaling) (None, None, None, 0 ['input_1[0][0]'] \n", - " 3) \n", + " rescaling (Rescaling) (None, None, None, 3) 0 ['input_1[0][0]'] \n", " \n", - " normalization (Normalization) (None, None, None, 0 ['rescaling[0][0]'] \n", - " 3) \n", + " normalization (Normalizati (None, None, None, 3) 0 ['rescaling[0][0]'] \n", + " on) \n", " \n", - " stem_conv (Conv2D) (None, None, None, 864 ['normalization[0][0]'] \n", - " 32) \n", + " stem_conv (Conv2D) (None, None, None, 32) 864 ['normalization[0][0]'] \n", " \n", - " stem_bn (BatchNormalization) (None, None, None, 128 ['stem_conv[0][0]'] \n", - " 32) \n", + " stem_bn (BatchNormalizatio (None, None, None, 32) 128 ['stem_conv[0][0]'] \n", + " n) \n", " \n", - " stem_activation (Activation) (None, None, None, 0 ['stem_bn[0][0]'] \n", - " 32) \n", + " stem_activation (Activatio (None, None, None, 32) 0 ['stem_bn[0][0]'] \n", + " n) \n", " \n", - " block1a_project_conv (Conv2D) (None, None, None, 4608 ['stem_activation[0][0]'] \n", - " 16) \n", + " block1a_project_conv (Conv (None, None, None, 16) 4608 ['stem_activation[0][0]'] \n", + " 2D) \n", " \n", - " block1a_project_bn (BatchNorma (None, None, None, 64 ['block1a_project_conv[0][0]'] \n", - " lization) 16) \n", + " block1a_project_bn (BatchN (None, None, None, 16) 64 ['block1a_project_conv[0][0]']\n", + " ormalization) \n", " \n", - " block1a_project_activation (Ac (None, None, None, 0 ['block1a_project_bn[0][0]'] \n", - " tivation) 16) \n", + " block1a_project_activation (None, None, None, 16) 0 ['block1a_project_bn[0][0]'] \n", + " (Activation) \n", " \n", - " block2a_expand_conv (Conv2D) (None, None, None, 9216 ['block1a_project_activation[0][0\n", - " 64) ]'] \n", + " block2a_expand_conv (Conv2 (None, None, None, 64) 9216 ['block1a_project_activation[0\n", + " D) ][0]'] \n", " \n", - " block2a_expand_bn (BatchNormal (None, None, None, 256 ['block2a_expand_conv[0][0]'] \n", - " ization) 64) \n", + " block2a_expand_bn (BatchNo (None, None, None, 64) 256 ['block2a_expand_conv[0][0]'] \n", + " rmalization) \n", " \n", - " block2a_expand_activation (Act (None, None, None, 0 ['block2a_expand_bn[0][0]'] \n", - " ivation) 64) \n", + " block2a_expand_activation (None, None, None, 64) 0 ['block2a_expand_bn[0][0]'] \n", + " (Activation) \n", " \n", - " block2a_project_conv (Conv2D) (None, None, None, 2048 ['block2a_expand_activation[0][0]\n", - " 32) '] \n", + " block2a_project_conv (Conv (None, None, None, 32) 2048 ['block2a_expand_activation[0]\n", + " 2D) [0]'] \n", " \n", - " block2a_project_bn (BatchNorma (None, None, None, 128 ['block2a_project_conv[0][0]'] \n", - " lization) 32) \n", + " block2a_project_bn (BatchN (None, None, None, 32) 128 ['block2a_project_conv[0][0]']\n", + " ormalization) \n", " \n", - " block2b_expand_conv (Conv2D) (None, None, None, 36864 ['block2a_project_bn[0][0]'] \n", - " 128) \n", + " block2b_expand_conv (Conv2 (None, None, None, 128) 36864 ['block2a_project_bn[0][0]'] \n", + " D) \n", " \n", - " block2b_expand_bn (BatchNormal (None, None, None, 512 ['block2b_expand_conv[0][0]'] \n", - " ization) 128) \n", + " block2b_expand_bn (BatchNo (None, None, None, 128) 512 ['block2b_expand_conv[0][0]'] \n", + " rmalization) \n", " \n", - " block2b_expand_activation (Act (None, None, None, 0 ['block2b_expand_bn[0][0]'] \n", - " ivation) 128) \n", + " block2b_expand_activation (None, None, None, 128) 0 ['block2b_expand_bn[0][0]'] \n", + " (Activation) \n", " \n", - " block2b_project_conv (Conv2D) (None, None, None, 4096 ['block2b_expand_activation[0][0]\n", - " 32) '] \n", + " block2b_project_conv (Conv (None, None, None, 32) 4096 ['block2b_expand_activation[0]\n", + " 2D) [0]'] \n", " \n", - " block2b_project_bn (BatchNorma (None, None, None, 128 ['block2b_project_conv[0][0]'] \n", - " lization) 32) \n", + " block2b_project_bn (BatchN (None, None, None, 32) 128 ['block2b_project_conv[0][0]']\n", + " ormalization) \n", " \n", - " block2b_drop (Dropout) (None, None, None, 0 ['block2b_project_bn[0][0]'] \n", - " 32) \n", + " block2b_drop (Dropout) (None, None, None, 32) 0 ['block2b_project_bn[0][0]'] \n", " \n", - " block2b_add (Add) (None, None, None, 0 ['block2b_drop[0][0]', \n", - " 32) 'block2a_project_bn[0][0]'] \n", + " block2b_add (Add) (None, None, None, 32) 0 ['block2b_drop[0][0]', \n", + " 'block2a_project_bn[0][0]'] \n", " \n", - " block3a_expand_conv (Conv2D) (None, None, None, 36864 ['block2b_add[0][0]'] \n", - " 128) \n", + " block3a_expand_conv (Conv2 (None, None, None, 128) 36864 ['block2b_add[0][0]'] \n", + " D) \n", " \n", - " block3a_expand_bn (BatchNormal (None, None, None, 512 ['block3a_expand_conv[0][0]'] \n", - " ization) 128) \n", + " block3a_expand_bn (BatchNo (None, None, None, 128) 512 ['block3a_expand_conv[0][0]'] \n", + " rmalization) \n", " \n", - " block3a_expand_activation (Act (None, None, None, 0 ['block3a_expand_bn[0][0]'] \n", - " ivation) 128) \n", + " block3a_expand_activation (None, None, None, 128) 0 ['block3a_expand_bn[0][0]'] \n", + " (Activation) \n", " \n", - " block3a_project_conv (Conv2D) (None, None, None, 6144 ['block3a_expand_activation[0][0]\n", - " 48) '] \n", + " block3a_project_conv (Conv (None, None, None, 48) 6144 ['block3a_expand_activation[0]\n", + " 2D) [0]'] \n", " \n", - " block3a_project_bn (BatchNorma (None, None, None, 192 ['block3a_project_conv[0][0]'] \n", - " lization) 48) \n", + " block3a_project_bn (BatchN (None, None, None, 48) 192 ['block3a_project_conv[0][0]']\n", + " ormalization) \n", " \n", - " block3b_expand_conv (Conv2D) (None, None, None, 82944 ['block3a_project_bn[0][0]'] \n", - " 192) \n", + " block3b_expand_conv (Conv2 (None, None, None, 192) 82944 ['block3a_project_bn[0][0]'] \n", + " D) \n", " \n", - " block3b_expand_bn (BatchNormal (None, None, None, 768 ['block3b_expand_conv[0][0]'] \n", - " ization) 192) \n", + " block3b_expand_bn (BatchNo (None, None, None, 192) 768 ['block3b_expand_conv[0][0]'] \n", + " rmalization) \n", " \n", - " block3b_expand_activation (Act (None, None, None, 0 ['block3b_expand_bn[0][0]'] \n", - " ivation) 192) \n", + " block3b_expand_activation (None, None, None, 192) 0 ['block3b_expand_bn[0][0]'] \n", + " (Activation) \n", " \n", - " block3b_project_conv (Conv2D) (None, None, None, 9216 ['block3b_expand_activation[0][0]\n", - " 48) '] \n", + " block3b_project_conv (Conv (None, None, None, 48) 9216 ['block3b_expand_activation[0]\n", + " 2D) [0]'] \n", " \n", - " block3b_project_bn (BatchNorma (None, None, None, 192 ['block3b_project_conv[0][0]'] \n", - " lization) 48) \n", + " block3b_project_bn (BatchN (None, None, None, 48) 192 ['block3b_project_conv[0][0]']\n", + " ormalization) \n", " \n", - " block3b_drop (Dropout) (None, None, None, 0 ['block3b_project_bn[0][0]'] \n", - " 48) \n", + " block3b_drop (Dropout) (None, None, None, 48) 0 ['block3b_project_bn[0][0]'] \n", " \n", - " block3b_add (Add) (None, None, None, 0 ['block3b_drop[0][0]', \n", - " 48) 'block3a_project_bn[0][0]'] \n", + " block3b_add (Add) (None, None, None, 48) 0 ['block3b_drop[0][0]', \n", + " 'block3a_project_bn[0][0]'] \n", " \n", - " block4a_expand_conv (Conv2D) (None, None, None, 9216 ['block3b_add[0][0]'] \n", - " 192) \n", + " block4a_expand_conv (Conv2 (None, None, None, 192) 9216 ['block3b_add[0][0]'] \n", + " D) \n", " \n", - " block4a_expand_bn (BatchNormal (None, None, None, 768 ['block4a_expand_conv[0][0]'] \n", - " ization) 192) \n", + " block4a_expand_bn (BatchNo (None, None, None, 192) 768 ['block4a_expand_conv[0][0]'] \n", + " rmalization) \n", " \n", - " block4a_expand_activation (Act (None, None, None, 0 ['block4a_expand_bn[0][0]'] \n", - " ivation) 192) \n", + " block4a_expand_activation (None, None, None, 192) 0 ['block4a_expand_bn[0][0]'] \n", + " (Activation) \n", " \n", - " block4a_dwconv2 (DepthwiseConv (None, None, None, 1728 ['block4a_expand_activation[0][0]\n", - " 2D) 192) '] \n", + " block4a_dwconv2 (Depthwise (None, None, None, 192) 1728 ['block4a_expand_activation[0]\n", + " Conv2D) [0]'] \n", " \n", - " block4a_bn (BatchNormalization (None, None, None, 768 ['block4a_dwconv2[0][0]'] \n", - " ) 192) \n", + " block4a_bn (BatchNormaliza (None, None, None, 192) 768 ['block4a_dwconv2[0][0]'] \n", + " tion) \n", " \n", - " block4a_activation (Activation (None, None, None, 0 ['block4a_bn[0][0]'] \n", - " ) 192) \n", + " block4a_activation (Activa (None, None, None, 192) 0 ['block4a_bn[0][0]'] \n", + " tion) \n", " \n", - " block4a_se_squeeze (GlobalAver (None, 192) 0 ['block4a_activation[0][0]'] \n", - " agePooling2D) \n", + " block4a_se_squeeze (Global (None, 192) 0 ['block4a_activation[0][0]'] \n", + " AveragePooling2D) \n", " \n", - " block4a_se_reshape (Reshape) (None, 1, 1, 192) 0 ['block4a_se_squeeze[0][0]'] \n", + " block4a_se_reshape (Reshap (None, 1, 1, 192) 0 ['block4a_se_squeeze[0][0]'] \n", + " e) \n", " \n", - " block4a_se_reduce (Conv2D) (None, 1, 1, 12) 2316 ['block4a_se_reshape[0][0]'] \n", + " block4a_se_reduce (Conv2D) (None, 1, 1, 12) 2316 ['block4a_se_reshape[0][0]'] \n", " \n", - " block4a_se_expand (Conv2D) (None, 1, 1, 192) 2496 ['block4a_se_reduce[0][0]'] \n", + " block4a_se_expand (Conv2D) (None, 1, 1, 192) 2496 ['block4a_se_reduce[0][0]'] \n", " \n", - " block4a_se_excite (Multiply) (None, None, None, 0 ['block4a_activation[0][0]', \n", - " 192) 'block4a_se_expand[0][0]'] \n", + " block4a_se_excite (Multipl (None, None, None, 192) 0 ['block4a_activation[0][0]', \n", + " y) 'block4a_se_expand[0][0]'] \n", " \n", - " block4a_project_conv (Conv2D) (None, None, None, 18432 ['block4a_se_excite[0][0]'] \n", - " 96) \n", + " block4a_project_conv (Conv (None, None, None, 96) 18432 ['block4a_se_excite[0][0]'] \n", + " 2D) \n", " \n", - " block4a_project_bn (BatchNorma (None, None, None, 384 ['block4a_project_conv[0][0]'] \n", - " lization) 96) \n", + " block4a_project_bn (BatchN (None, None, None, 96) 384 ['block4a_project_conv[0][0]']\n", + " ormalization) \n", " \n", - " block4b_expand_conv (Conv2D) (None, None, None, 36864 ['block4a_project_bn[0][0]'] \n", - " 384) \n", + " block4b_expand_conv (Conv2 (None, None, None, 384) 36864 ['block4a_project_bn[0][0]'] \n", + " D) \n", " \n", - " block4b_expand_bn (BatchNormal (None, None, None, 1536 ['block4b_expand_conv[0][0]'] \n", - " ization) 384) \n", + " block4b_expand_bn (BatchNo (None, None, None, 384) 1536 ['block4b_expand_conv[0][0]'] \n", + " rmalization) \n", " \n", - " block4b_expand_activation (Act (None, None, None, 0 ['block4b_expand_bn[0][0]'] \n", - " ivation) 384) \n", + " block4b_expand_activation (None, None, None, 384) 0 ['block4b_expand_bn[0][0]'] \n", + " (Activation) \n", " \n", - " block4b_dwconv2 (DepthwiseConv (None, None, None, 3456 ['block4b_expand_activation[0][0]\n", - " 2D) 384) '] \n", + " block4b_dwconv2 (Depthwise (None, None, None, 384) 3456 ['block4b_expand_activation[0]\n", + " Conv2D) [0]'] \n", " \n", - " block4b_bn (BatchNormalization (None, None, None, 1536 ['block4b_dwconv2[0][0]'] \n", - " ) 384) \n", + " block4b_bn (BatchNormaliza (None, None, None, 384) 1536 ['block4b_dwconv2[0][0]'] \n", + " tion) \n", " \n", - " block4b_activation (Activation (None, None, None, 0 ['block4b_bn[0][0]'] \n", - " ) 384) \n", + " block4b_activation (Activa (None, None, None, 384) 0 ['block4b_bn[0][0]'] \n", + " tion) \n", " \n", - " block4b_se_squeeze (GlobalAver (None, 384) 0 ['block4b_activation[0][0]'] \n", - " agePooling2D) \n", + " block4b_se_squeeze (Global (None, 384) 0 ['block4b_activation[0][0]'] \n", + " AveragePooling2D) \n", " \n", - " block4b_se_reshape (Reshape) (None, 1, 1, 384) 0 ['block4b_se_squeeze[0][0]'] \n", + " block4b_se_reshape (Reshap (None, 1, 1, 384) 0 ['block4b_se_squeeze[0][0]'] \n", + " e) \n", " \n", - " block4b_se_reduce (Conv2D) (None, 1, 1, 24) 9240 ['block4b_se_reshape[0][0]'] \n", + " block4b_se_reduce (Conv2D) (None, 1, 1, 24) 9240 ['block4b_se_reshape[0][0]'] \n", " \n", - " block4b_se_expand (Conv2D) (None, 1, 1, 384) 9600 ['block4b_se_reduce[0][0]'] \n", + " block4b_se_expand (Conv2D) (None, 1, 1, 384) 9600 ['block4b_se_reduce[0][0]'] \n", " \n", - " block4b_se_excite (Multiply) (None, None, None, 0 ['block4b_activation[0][0]', \n", - " 384) 'block4b_se_expand[0][0]'] \n", + " block4b_se_excite (Multipl (None, None, None, 384) 0 ['block4b_activation[0][0]', \n", + " y) 'block4b_se_expand[0][0]'] \n", " \n", - " block4b_project_conv (Conv2D) (None, None, None, 36864 ['block4b_se_excite[0][0]'] \n", - " 96) \n", + " block4b_project_conv (Conv (None, None, None, 96) 36864 ['block4b_se_excite[0][0]'] \n", + " 2D) \n", " \n", - " block4b_project_bn (BatchNorma (None, None, None, 384 ['block4b_project_conv[0][0]'] \n", - " lization) 96) \n", + " block4b_project_bn (BatchN (None, None, None, 96) 384 ['block4b_project_conv[0][0]']\n", + " ormalization) \n", " \n", - " block4b_drop (Dropout) (None, None, None, 0 ['block4b_project_bn[0][0]'] \n", - " 96) \n", + " block4b_drop (Dropout) (None, None, None, 96) 0 ['block4b_project_bn[0][0]'] \n", " \n", - " block4b_add (Add) (None, None, None, 0 ['block4b_drop[0][0]', \n", - " 96) 'block4a_project_bn[0][0]'] \n", + " block4b_add (Add) (None, None, None, 96) 0 ['block4b_drop[0][0]', \n", + " 'block4a_project_bn[0][0]'] \n", " \n", - " block4c_expand_conv (Conv2D) (None, None, None, 36864 ['block4b_add[0][0]'] \n", - " 384) \n", + " block4c_expand_conv (Conv2 (None, None, None, 384) 36864 ['block4b_add[0][0]'] \n", + " D) \n", " \n", - " block4c_expand_bn (BatchNormal (None, None, None, 1536 ['block4c_expand_conv[0][0]'] \n", - " ization) 384) \n", + " block4c_expand_bn (BatchNo (None, None, None, 384) 1536 ['block4c_expand_conv[0][0]'] \n", + " rmalization) \n", " \n", - " block4c_expand_activation (Act (None, None, None, 0 ['block4c_expand_bn[0][0]'] \n", - " ivation) 384) \n", + " block4c_expand_activation (None, None, None, 384) 0 ['block4c_expand_bn[0][0]'] \n", + " (Activation) \n", " \n", - " block4c_dwconv2 (DepthwiseConv (None, None, None, 3456 ['block4c_expand_activation[0][0]\n", - " 2D) 384) '] \n", + " block4c_dwconv2 (Depthwise (None, None, None, 384) 3456 ['block4c_expand_activation[0]\n", + " Conv2D) [0]'] \n", " \n", - " block4c_bn (BatchNormalization (None, None, None, 1536 ['block4c_dwconv2[0][0]'] \n", - " ) 384) \n", + " block4c_bn (BatchNormaliza (None, None, None, 384) 1536 ['block4c_dwconv2[0][0]'] \n", + " tion) \n", " \n", - " block4c_activation (Activation (None, None, None, 0 ['block4c_bn[0][0]'] \n", - " ) 384) \n", + " block4c_activation (Activa (None, None, None, 384) 0 ['block4c_bn[0][0]'] \n", + " tion) \n", " \n", - " block4c_se_squeeze (GlobalAver (None, 384) 0 ['block4c_activation[0][0]'] \n", - " agePooling2D) \n", + " block4c_se_squeeze (Global (None, 384) 0 ['block4c_activation[0][0]'] \n", + " AveragePooling2D) \n", " \n", - " block4c_se_reshape (Reshape) (None, 1, 1, 384) 0 ['block4c_se_squeeze[0][0]'] \n", + " block4c_se_reshape (Reshap (None, 1, 1, 384) 0 ['block4c_se_squeeze[0][0]'] \n", + " e) \n", " \n", - " block4c_se_reduce (Conv2D) (None, 1, 1, 24) 9240 ['block4c_se_reshape[0][0]'] \n", + " block4c_se_reduce (Conv2D) (None, 1, 1, 24) 9240 ['block4c_se_reshape[0][0]'] \n", " \n", - " block4c_se_expand (Conv2D) (None, 1, 1, 384) 9600 ['block4c_se_reduce[0][0]'] \n", + " block4c_se_expand (Conv2D) (None, 1, 1, 384) 9600 ['block4c_se_reduce[0][0]'] \n", " \n", - " block4c_se_excite (Multiply) (None, None, None, 0 ['block4c_activation[0][0]', \n", - " 384) 'block4c_se_expand[0][0]'] \n", + " block4c_se_excite (Multipl (None, None, None, 384) 0 ['block4c_activation[0][0]', \n", + " y) 'block4c_se_expand[0][0]'] \n", " \n", - " block4c_project_conv (Conv2D) (None, None, None, 36864 ['block4c_se_excite[0][0]'] \n", - " 96) \n", + " block4c_project_conv (Conv (None, None, None, 96) 36864 ['block4c_se_excite[0][0]'] \n", + " 2D) \n", " \n", - " block4c_project_bn (BatchNorma (None, None, None, 384 ['block4c_project_conv[0][0]'] \n", - " lization) 96) \n", + " block4c_project_bn (BatchN (None, None, None, 96) 384 ['block4c_project_conv[0][0]']\n", + " ormalization) \n", " \n", - " block4c_drop (Dropout) (None, None, None, 0 ['block4c_project_bn[0][0]'] \n", - " 96) \n", + " block4c_drop (Dropout) (None, None, None, 96) 0 ['block4c_project_bn[0][0]'] \n", " \n", - " block4c_add (Add) (None, None, None, 0 ['block4c_drop[0][0]', \n", - " 96) 'block4b_add[0][0]'] \n", + " block4c_add (Add) (None, None, None, 96) 0 ['block4c_drop[0][0]', \n", + " 'block4b_add[0][0]'] \n", " \n", - " block5a_expand_conv (Conv2D) (None, None, None, 55296 ['block4c_add[0][0]'] \n", - " 576) \n", + " block5a_expand_conv (Conv2 (None, None, None, 576) 55296 ['block4c_add[0][0]'] \n", + " D) \n", " \n", - " block5a_expand_bn (BatchNormal (None, None, None, 2304 ['block5a_expand_conv[0][0]'] \n", - " ization) 576) \n", + " block5a_expand_bn (BatchNo (None, None, None, 576) 2304 ['block5a_expand_conv[0][0]'] \n", + " rmalization) \n", " \n", - " block5a_expand_activation (Act (None, None, None, 0 ['block5a_expand_bn[0][0]'] \n", - " ivation) 576) \n", + " block5a_expand_activation (None, None, None, 576) 0 ['block5a_expand_bn[0][0]'] \n", + " (Activation) \n", " \n", - " block5a_dwconv2 (DepthwiseConv (None, None, None, 5184 ['block5a_expand_activation[0][0]\n", - " 2D) 576) '] \n", + " block5a_dwconv2 (Depthwise (None, None, None, 576) 5184 ['block5a_expand_activation[0]\n", + " Conv2D) [0]'] \n", " \n", - " block5a_bn (BatchNormalization (None, None, None, 2304 ['block5a_dwconv2[0][0]'] \n", - " ) 576) \n", + " block5a_bn (BatchNormaliza (None, None, None, 576) 2304 ['block5a_dwconv2[0][0]'] \n", + " tion) \n", " \n", - " block5a_activation (Activation (None, None, None, 0 ['block5a_bn[0][0]'] \n", - " ) 576) \n", + " block5a_activation (Activa (None, None, None, 576) 0 ['block5a_bn[0][0]'] \n", + " tion) \n", " \n", - " block5a_se_squeeze (GlobalAver (None, 576) 0 ['block5a_activation[0][0]'] \n", - " agePooling2D) \n", + " block5a_se_squeeze (Global (None, 576) 0 ['block5a_activation[0][0]'] \n", + " AveragePooling2D) \n", " \n", - " block5a_se_reshape (Reshape) (None, 1, 1, 576) 0 ['block5a_se_squeeze[0][0]'] \n", + " block5a_se_reshape (Reshap (None, 1, 1, 576) 0 ['block5a_se_squeeze[0][0]'] \n", + " e) \n", " \n", - " block5a_se_reduce (Conv2D) (None, 1, 1, 24) 13848 ['block5a_se_reshape[0][0]'] \n", + " block5a_se_reduce (Conv2D) (None, 1, 1, 24) 13848 ['block5a_se_reshape[0][0]'] \n", " \n", - " block5a_se_expand (Conv2D) (None, 1, 1, 576) 14400 ['block5a_se_reduce[0][0]'] \n", + " block5a_se_expand (Conv2D) (None, 1, 1, 576) 14400 ['block5a_se_reduce[0][0]'] \n", " \n", - " block5a_se_excite (Multiply) (None, None, None, 0 ['block5a_activation[0][0]', \n", - " 576) 'block5a_se_expand[0][0]'] \n", + " block5a_se_excite (Multipl (None, None, None, 576) 0 ['block5a_activation[0][0]', \n", + " y) 'block5a_se_expand[0][0]'] \n", " \n", - " block5a_project_conv (Conv2D) (None, None, None, 64512 ['block5a_se_excite[0][0]'] \n", - " 112) \n", + " block5a_project_conv (Conv (None, None, None, 112) 64512 ['block5a_se_excite[0][0]'] \n", + " 2D) \n", " \n", - " block5a_project_bn (BatchNorma (None, None, None, 448 ['block5a_project_conv[0][0]'] \n", - " lization) 112) \n", + " block5a_project_bn (BatchN (None, None, None, 112) 448 ['block5a_project_conv[0][0]']\n", + " ormalization) \n", " \n", - " block5b_expand_conv (Conv2D) (None, None, None, 75264 ['block5a_project_bn[0][0]'] \n", - " 672) \n", + " block5b_expand_conv (Conv2 (None, None, None, 672) 75264 ['block5a_project_bn[0][0]'] \n", + " D) \n", " \n", - " block5b_expand_bn (BatchNormal (None, None, None, 2688 ['block5b_expand_conv[0][0]'] \n", - " ization) 672) \n", + " block5b_expand_bn (BatchNo (None, None, None, 672) 2688 ['block5b_expand_conv[0][0]'] \n", + " rmalization) \n", " \n", - " block5b_expand_activation (Act (None, None, None, 0 ['block5b_expand_bn[0][0]'] \n", - " ivation) 672) \n", + " block5b_expand_activation (None, None, None, 672) 0 ['block5b_expand_bn[0][0]'] \n", + " (Activation) \n", " \n", - " block5b_dwconv2 (DepthwiseConv (None, None, None, 6048 ['block5b_expand_activation[0][0]\n", - " 2D) 672) '] \n", + " block5b_dwconv2 (Depthwise (None, None, None, 672) 6048 ['block5b_expand_activation[0]\n", + " Conv2D) [0]'] \n", " \n", - " block5b_bn (BatchNormalization (None, None, None, 2688 ['block5b_dwconv2[0][0]'] \n", - " ) 672) \n", + " block5b_bn (BatchNormaliza (None, None, None, 672) 2688 ['block5b_dwconv2[0][0]'] \n", + " tion) \n", " \n", - " block5b_activation (Activation (None, None, None, 0 ['block5b_bn[0][0]'] \n", - " ) 672) \n", + " block5b_activation (Activa (None, None, None, 672) 0 ['block5b_bn[0][0]'] \n", + " tion) \n", " \n", - " block5b_se_squeeze (GlobalAver (None, 672) 0 ['block5b_activation[0][0]'] \n", - " agePooling2D) \n", + " block5b_se_squeeze (Global (None, 672) 0 ['block5b_activation[0][0]'] \n", + " AveragePooling2D) \n", " \n", - " block5b_se_reshape (Reshape) (None, 1, 1, 672) 0 ['block5b_se_squeeze[0][0]'] \n", + " block5b_se_reshape (Reshap (None, 1, 1, 672) 0 ['block5b_se_squeeze[0][0]'] \n", + " e) \n", " \n", - " block5b_se_reduce (Conv2D) (None, 1, 1, 28) 18844 ['block5b_se_reshape[0][0]'] \n", + " block5b_se_reduce (Conv2D) (None, 1, 1, 28) 18844 ['block5b_se_reshape[0][0]'] \n", " \n", - " block5b_se_expand (Conv2D) (None, 1, 1, 672) 19488 ['block5b_se_reduce[0][0]'] \n", + " block5b_se_expand (Conv2D) (None, 1, 1, 672) 19488 ['block5b_se_reduce[0][0]'] \n", " \n", - " block5b_se_excite (Multiply) (None, None, None, 0 ['block5b_activation[0][0]', \n", - " 672) 'block5b_se_expand[0][0]'] \n", + " block5b_se_excite (Multipl (None, None, None, 672) 0 ['block5b_activation[0][0]', \n", + " y) 'block5b_se_expand[0][0]'] \n", " \n", - " block5b_project_conv (Conv2D) (None, None, None, 75264 ['block5b_se_excite[0][0]'] \n", - " 112) \n", + " block5b_project_conv (Conv (None, None, None, 112) 75264 ['block5b_se_excite[0][0]'] \n", + " 2D) \n", " \n", - " block5b_project_bn (BatchNorma (None, None, None, 448 ['block5b_project_conv[0][0]'] \n", - " lization) 112) \n", + " block5b_project_bn (BatchN (None, None, None, 112) 448 ['block5b_project_conv[0][0]']\n", + " ormalization) \n", " \n", - " block5b_drop (Dropout) (None, None, None, 0 ['block5b_project_bn[0][0]'] \n", - " 112) \n", + " block5b_drop (Dropout) (None, None, None, 112) 0 ['block5b_project_bn[0][0]'] \n", " \n", - " block5b_add (Add) (None, None, None, 0 ['block5b_drop[0][0]', \n", - " 112) 'block5a_project_bn[0][0]'] \n", + " block5b_add (Add) (None, None, None, 112) 0 ['block5b_drop[0][0]', \n", + " 'block5a_project_bn[0][0]'] \n", " \n", - " block5c_expand_conv (Conv2D) (None, None, None, 75264 ['block5b_add[0][0]'] \n", - " 672) \n", + " block5c_expand_conv (Conv2 (None, None, None, 672) 75264 ['block5b_add[0][0]'] \n", + " D) \n", " \n", - " block5c_expand_bn (BatchNormal (None, None, None, 2688 ['block5c_expand_conv[0][0]'] \n", - " ization) 672) \n", + " block5c_expand_bn (BatchNo (None, None, None, 672) 2688 ['block5c_expand_conv[0][0]'] \n", + " rmalization) \n", " \n", - " block5c_expand_activation (Act (None, None, None, 0 ['block5c_expand_bn[0][0]'] \n", - " ivation) 672) \n", + " block5c_expand_activation (None, None, None, 672) 0 ['block5c_expand_bn[0][0]'] \n", + " (Activation) \n", " \n", - " block5c_dwconv2 (DepthwiseConv (None, None, None, 6048 ['block5c_expand_activation[0][0]\n", - " 2D) 672) '] \n", + " block5c_dwconv2 (Depthwise (None, None, None, 672) 6048 ['block5c_expand_activation[0]\n", + " Conv2D) [0]'] \n", " \n", - " block5c_bn (BatchNormalization (None, None, None, 2688 ['block5c_dwconv2[0][0]'] \n", - " ) 672) \n", + " block5c_bn (BatchNormaliza (None, None, None, 672) 2688 ['block5c_dwconv2[0][0]'] \n", + " tion) \n", " \n", - " block5c_activation (Activation (None, None, None, 0 ['block5c_bn[0][0]'] \n", - " ) 672) \n", + " block5c_activation (Activa (None, None, None, 672) 0 ['block5c_bn[0][0]'] \n", + " tion) \n", " \n", - " block5c_se_squeeze (GlobalAver (None, 672) 0 ['block5c_activation[0][0]'] \n", - " agePooling2D) \n", + " block5c_se_squeeze (Global (None, 672) 0 ['block5c_activation[0][0]'] \n", + " AveragePooling2D) \n", " \n", - " block5c_se_reshape (Reshape) (None, 1, 1, 672) 0 ['block5c_se_squeeze[0][0]'] \n", + " block5c_se_reshape (Reshap (None, 1, 1, 672) 0 ['block5c_se_squeeze[0][0]'] \n", + " e) \n", " \n", - " block5c_se_reduce (Conv2D) (None, 1, 1, 28) 18844 ['block5c_se_reshape[0][0]'] \n", + " block5c_se_reduce (Conv2D) (None, 1, 1, 28) 18844 ['block5c_se_reshape[0][0]'] \n", " \n", - " block5c_se_expand (Conv2D) (None, 1, 1, 672) 19488 ['block5c_se_reduce[0][0]'] \n", + " block5c_se_expand (Conv2D) (None, 1, 1, 672) 19488 ['block5c_se_reduce[0][0]'] \n", " \n", - " block5c_se_excite (Multiply) (None, None, None, 0 ['block5c_activation[0][0]', \n", - " 672) 'block5c_se_expand[0][0]'] \n", + " block5c_se_excite (Multipl (None, None, None, 672) 0 ['block5c_activation[0][0]', \n", + " y) 'block5c_se_expand[0][0]'] \n", " \n", - " block5c_project_conv (Conv2D) (None, None, None, 75264 ['block5c_se_excite[0][0]'] \n", - " 112) \n", + " block5c_project_conv (Conv (None, None, None, 112) 75264 ['block5c_se_excite[0][0]'] \n", + " 2D) \n", " \n", - " block5c_project_bn (BatchNorma (None, None, None, 448 ['block5c_project_conv[0][0]'] \n", - " lization) 112) \n", + " block5c_project_bn (BatchN (None, None, None, 112) 448 ['block5c_project_conv[0][0]']\n", + " ormalization) \n", " \n", - " block5c_drop (Dropout) (None, None, None, 0 ['block5c_project_bn[0][0]'] \n", - " 112) \n", + " block5c_drop (Dropout) (None, None, None, 112) 0 ['block5c_project_bn[0][0]'] \n", " \n", - " block5c_add (Add) (None, None, None, 0 ['block5c_drop[0][0]', \n", - " 112) 'block5b_add[0][0]'] \n", + " block5c_add (Add) (None, None, None, 112) 0 ['block5c_drop[0][0]', \n", + " 'block5b_add[0][0]'] \n", " \n", - " block5d_expand_conv (Conv2D) (None, None, None, 75264 ['block5c_add[0][0]'] \n", - " 672) \n", + " block5d_expand_conv (Conv2 (None, None, None, 672) 75264 ['block5c_add[0][0]'] \n", + " D) \n", " \n", - " block5d_expand_bn (BatchNormal (None, None, None, 2688 ['block5d_expand_conv[0][0]'] \n", - " ization) 672) \n", + " block5d_expand_bn (BatchNo (None, None, None, 672) 2688 ['block5d_expand_conv[0][0]'] \n", + " rmalization) \n", " \n", - " block5d_expand_activation (Act (None, None, None, 0 ['block5d_expand_bn[0][0]'] \n", - " ivation) 672) \n", + " block5d_expand_activation (None, None, None, 672) 0 ['block5d_expand_bn[0][0]'] \n", + " (Activation) \n", " \n", - " block5d_dwconv2 (DepthwiseConv (None, None, None, 6048 ['block5d_expand_activation[0][0]\n", - " 2D) 672) '] \n", + " block5d_dwconv2 (Depthwise (None, None, None, 672) 6048 ['block5d_expand_activation[0]\n", + " Conv2D) [0]'] \n", " \n", - " block5d_bn (BatchNormalization (None, None, None, 2688 ['block5d_dwconv2[0][0]'] \n", - " ) 672) \n", + " block5d_bn (BatchNormaliza (None, None, None, 672) 2688 ['block5d_dwconv2[0][0]'] \n", + " tion) \n", " \n", - " block5d_activation (Activation (None, None, None, 0 ['block5d_bn[0][0]'] \n", - " ) 672) \n", + " block5d_activation (Activa (None, None, None, 672) 0 ['block5d_bn[0][0]'] \n", + " tion) \n", " \n", - " block5d_se_squeeze (GlobalAver (None, 672) 0 ['block5d_activation[0][0]'] \n", - " agePooling2D) \n", + " block5d_se_squeeze (Global (None, 672) 0 ['block5d_activation[0][0]'] \n", + " AveragePooling2D) \n", " \n", - " block5d_se_reshape (Reshape) (None, 1, 1, 672) 0 ['block5d_se_squeeze[0][0]'] \n", + " block5d_se_reshape (Reshap (None, 1, 1, 672) 0 ['block5d_se_squeeze[0][0]'] \n", + " e) \n", " \n", - " block5d_se_reduce (Conv2D) (None, 1, 1, 28) 18844 ['block5d_se_reshape[0][0]'] \n", + " block5d_se_reduce (Conv2D) (None, 1, 1, 28) 18844 ['block5d_se_reshape[0][0]'] \n", " \n", - " block5d_se_expand (Conv2D) (None, 1, 1, 672) 19488 ['block5d_se_reduce[0][0]'] \n", + " block5d_se_expand (Conv2D) (None, 1, 1, 672) 19488 ['block5d_se_reduce[0][0]'] \n", " \n", - " block5d_se_excite (Multiply) (None, None, None, 0 ['block5d_activation[0][0]', \n", - " 672) 'block5d_se_expand[0][0]'] \n", + " block5d_se_excite (Multipl (None, None, None, 672) 0 ['block5d_activation[0][0]', \n", + " y) 'block5d_se_expand[0][0]'] \n", " \n", - " block5d_project_conv (Conv2D) (None, None, None, 75264 ['block5d_se_excite[0][0]'] \n", - " 112) \n", + " block5d_project_conv (Conv (None, None, None, 112) 75264 ['block5d_se_excite[0][0]'] \n", + " 2D) \n", " \n", - " block5d_project_bn (BatchNorma (None, None, None, 448 ['block5d_project_conv[0][0]'] \n", - " lization) 112) \n", + " block5d_project_bn (BatchN (None, None, None, 112) 448 ['block5d_project_conv[0][0]']\n", + " ormalization) \n", " \n", - " block5d_drop (Dropout) (None, None, None, 0 ['block5d_project_bn[0][0]'] \n", - " 112) \n", + " block5d_drop (Dropout) (None, None, None, 112) 0 ['block5d_project_bn[0][0]'] \n", " \n", - " block5d_add (Add) (None, None, None, 0 ['block5d_drop[0][0]', \n", - " 112) 'block5c_add[0][0]'] \n", + " block5d_add (Add) (None, None, None, 112) 0 ['block5d_drop[0][0]', \n", + " 'block5c_add[0][0]'] \n", " \n", - " block5e_expand_conv (Conv2D) (None, None, None, 75264 ['block5d_add[0][0]'] \n", - " 672) \n", + " block5e_expand_conv (Conv2 (None, None, None, 672) 75264 ['block5d_add[0][0]'] \n", + " D) \n", " \n", - " block5e_expand_bn (BatchNormal (None, None, None, 2688 ['block5e_expand_conv[0][0]'] \n", - " ization) 672) \n", + " block5e_expand_bn (BatchNo (None, None, None, 672) 2688 ['block5e_expand_conv[0][0]'] \n", + " rmalization) \n", " \n", - " block5e_expand_activation (Act (None, None, None, 0 ['block5e_expand_bn[0][0]'] \n", - " ivation) 672) \n", + " block5e_expand_activation (None, None, None, 672) 0 ['block5e_expand_bn[0][0]'] \n", + " (Activation) \n", " \n", - " block5e_dwconv2 (DepthwiseConv (None, None, None, 6048 ['block5e_expand_activation[0][0]\n", - " 2D) 672) '] \n", + " block5e_dwconv2 (Depthwise (None, None, None, 672) 6048 ['block5e_expand_activation[0]\n", + " Conv2D) [0]'] \n", " \n", - " block5e_bn (BatchNormalization (None, None, None, 2688 ['block5e_dwconv2[0][0]'] \n", - " ) 672) \n", + " block5e_bn (BatchNormaliza (None, None, None, 672) 2688 ['block5e_dwconv2[0][0]'] \n", + " tion) \n", " \n", - " block5e_activation (Activation (None, None, None, 0 ['block5e_bn[0][0]'] \n", - " ) 672) \n", + " block5e_activation (Activa (None, None, None, 672) 0 ['block5e_bn[0][0]'] \n", + " tion) \n", " \n", - " block5e_se_squeeze (GlobalAver (None, 672) 0 ['block5e_activation[0][0]'] \n", - " agePooling2D) \n", + " block5e_se_squeeze (Global (None, 672) 0 ['block5e_activation[0][0]'] \n", + " AveragePooling2D) \n", " \n", - " block5e_se_reshape (Reshape) (None, 1, 1, 672) 0 ['block5e_se_squeeze[0][0]'] \n", + " block5e_se_reshape (Reshap (None, 1, 1, 672) 0 ['block5e_se_squeeze[0][0]'] \n", + " e) \n", " \n", - " block5e_se_reduce (Conv2D) (None, 1, 1, 28) 18844 ['block5e_se_reshape[0][0]'] \n", + " block5e_se_reduce (Conv2D) (None, 1, 1, 28) 18844 ['block5e_se_reshape[0][0]'] \n", " \n", - " block5e_se_expand (Conv2D) (None, 1, 1, 672) 19488 ['block5e_se_reduce[0][0]'] \n", + " block5e_se_expand (Conv2D) (None, 1, 1, 672) 19488 ['block5e_se_reduce[0][0]'] \n", " \n", - " block5e_se_excite (Multiply) (None, None, None, 0 ['block5e_activation[0][0]', \n", - " 672) 'block5e_se_expand[0][0]'] \n", + " block5e_se_excite (Multipl (None, None, None, 672) 0 ['block5e_activation[0][0]', \n", + " y) 'block5e_se_expand[0][0]'] \n", " \n", - " block5e_project_conv (Conv2D) (None, None, None, 75264 ['block5e_se_excite[0][0]'] \n", - " 112) \n", + " block5e_project_conv (Conv (None, None, None, 112) 75264 ['block5e_se_excite[0][0]'] \n", + " 2D) \n", " \n", - " block5e_project_bn (BatchNorma (None, None, None, 448 ['block5e_project_conv[0][0]'] \n", - " lization) 112) \n", + " block5e_project_bn (BatchN (None, None, None, 112) 448 ['block5e_project_conv[0][0]']\n", + " ormalization) \n", " \n", - " block5e_drop (Dropout) (None, None, None, 0 ['block5e_project_bn[0][0]'] \n", - " 112) \n", + " block5e_drop (Dropout) (None, None, None, 112) 0 ['block5e_project_bn[0][0]'] \n", " \n", - " block5e_add (Add) (None, None, None, 0 ['block5e_drop[0][0]', \n", - " 112) 'block5d_add[0][0]'] \n", + " block5e_add (Add) (None, None, None, 112) 0 ['block5e_drop[0][0]', \n", + " 'block5d_add[0][0]'] \n", " \n", - " block6a_expand_conv (Conv2D) (None, None, None, 75264 ['block5e_add[0][0]'] \n", - " 672) \n", + " block6a_expand_conv (Conv2 (None, None, None, 672) 75264 ['block5e_add[0][0]'] \n", + " D) \n", " \n", - " block6a_expand_bn (BatchNormal (None, None, None, 2688 ['block6a_expand_conv[0][0]'] \n", - " ization) 672) \n", + " block6a_expand_bn (BatchNo (None, None, None, 672) 2688 ['block6a_expand_conv[0][0]'] \n", + " rmalization) \n", " \n", - " block6a_expand_activation (Act (None, None, None, 0 ['block6a_expand_bn[0][0]'] \n", - " ivation) 672) \n", + " block6a_expand_activation (None, None, None, 672) 0 ['block6a_expand_bn[0][0]'] \n", + " (Activation) \n", " \n", - " block6a_dwconv2 (DepthwiseConv (None, None, None, 6048 ['block6a_expand_activation[0][0]\n", - " 2D) 672) '] \n", + " block6a_dwconv2 (Depthwise (None, None, None, 672) 6048 ['block6a_expand_activation[0]\n", + " Conv2D) [0]'] \n", " \n", - " block6a_bn (BatchNormalization (None, None, None, 2688 ['block6a_dwconv2[0][0]'] \n", - " ) 672) \n", + " block6a_bn (BatchNormaliza (None, None, None, 672) 2688 ['block6a_dwconv2[0][0]'] \n", + " tion) \n", " \n", - " block6a_activation (Activation (None, None, None, 0 ['block6a_bn[0][0]'] \n", - " ) 672) \n", + " block6a_activation (Activa (None, None, None, 672) 0 ['block6a_bn[0][0]'] \n", + " tion) \n", " \n", - " block6a_se_squeeze (GlobalAver (None, 672) 0 ['block6a_activation[0][0]'] \n", - " agePooling2D) \n", + " block6a_se_squeeze (Global (None, 672) 0 ['block6a_activation[0][0]'] \n", + " AveragePooling2D) \n", " \n", - " block6a_se_reshape (Reshape) (None, 1, 1, 672) 0 ['block6a_se_squeeze[0][0]'] \n", + " block6a_se_reshape (Reshap (None, 1, 1, 672) 0 ['block6a_se_squeeze[0][0]'] \n", + " e) \n", " \n", - " block6a_se_reduce (Conv2D) (None, 1, 1, 28) 18844 ['block6a_se_reshape[0][0]'] \n", + " block6a_se_reduce (Conv2D) (None, 1, 1, 28) 18844 ['block6a_se_reshape[0][0]'] \n", " \n", - " block6a_se_expand (Conv2D) (None, 1, 1, 672) 19488 ['block6a_se_reduce[0][0]'] \n", + " block6a_se_expand (Conv2D) (None, 1, 1, 672) 19488 ['block6a_se_reduce[0][0]'] \n", " \n", - " block6a_se_excite (Multiply) (None, None, None, 0 ['block6a_activation[0][0]', \n", - " 672) 'block6a_se_expand[0][0]'] \n", + " block6a_se_excite (Multipl (None, None, None, 672) 0 ['block6a_activation[0][0]', \n", + " y) 'block6a_se_expand[0][0]'] \n", " \n", - " block6a_project_conv (Conv2D) (None, None, None, 129024 ['block6a_se_excite[0][0]'] \n", - " 192) \n", + " block6a_project_conv (Conv (None, None, None, 192) 129024 ['block6a_se_excite[0][0]'] \n", + " 2D) \n", " \n", - " block6a_project_bn (BatchNorma (None, None, None, 768 ['block6a_project_conv[0][0]'] \n", - " lization) 192) \n", + " block6a_project_bn (BatchN (None, None, None, 192) 768 ['block6a_project_conv[0][0]']\n", + " ormalization) \n", " \n", - " block6b_expand_conv (Conv2D) (None, None, None, 221184 ['block6a_project_bn[0][0]'] \n", - " 1152) \n", + " block6b_expand_conv (Conv2 (None, None, None, 1152) 221184 ['block6a_project_bn[0][0]'] \n", + " D) \n", " \n", - " block6b_expand_bn (BatchNormal (None, None, None, 4608 ['block6b_expand_conv[0][0]'] \n", - " ization) 1152) \n", + " block6b_expand_bn (BatchNo (None, None, None, 1152) 4608 ['block6b_expand_conv[0][0]'] \n", + " rmalization) \n", " \n", - " block6b_expand_activation (Act (None, None, None, 0 ['block6b_expand_bn[0][0]'] \n", - " ivation) 1152) \n", + " block6b_expand_activation (None, None, None, 1152) 0 ['block6b_expand_bn[0][0]'] \n", + " (Activation) \n", " \n", - " block6b_dwconv2 (DepthwiseConv (None, None, None, 10368 ['block6b_expand_activation[0][0]\n", - " 2D) 1152) '] \n", + " block6b_dwconv2 (Depthwise (None, None, None, 1152) 10368 ['block6b_expand_activation[0]\n", + " Conv2D) [0]'] \n", " \n", - " block6b_bn (BatchNormalization (None, None, None, 4608 ['block6b_dwconv2[0][0]'] \n", - " ) 1152) \n", + " block6b_bn (BatchNormaliza (None, None, None, 1152) 4608 ['block6b_dwconv2[0][0]'] \n", + " tion) \n", " \n", - " block6b_activation (Activation (None, None, None, 0 ['block6b_bn[0][0]'] \n", - " ) 1152) \n", + " block6b_activation (Activa (None, None, None, 1152) 0 ['block6b_bn[0][0]'] \n", + " tion) \n", " \n", - " block6b_se_squeeze (GlobalAver (None, 1152) 0 ['block6b_activation[0][0]'] \n", - " agePooling2D) \n", + " block6b_se_squeeze (Global (None, 1152) 0 ['block6b_activation[0][0]'] \n", + " AveragePooling2D) \n", " \n", - " block6b_se_reshape (Reshape) (None, 1, 1, 1152) 0 ['block6b_se_squeeze[0][0]'] \n", + " block6b_se_reshape (Reshap (None, 1, 1, 1152) 0 ['block6b_se_squeeze[0][0]'] \n", + " e) \n", " \n", - " block6b_se_reduce (Conv2D) (None, 1, 1, 48) 55344 ['block6b_se_reshape[0][0]'] \n", + " block6b_se_reduce (Conv2D) (None, 1, 1, 48) 55344 ['block6b_se_reshape[0][0]'] \n", " \n", - " block6b_se_expand (Conv2D) (None, 1, 1, 1152) 56448 ['block6b_se_reduce[0][0]'] \n", + " block6b_se_expand (Conv2D) (None, 1, 1, 1152) 56448 ['block6b_se_reduce[0][0]'] \n", " \n", - " block6b_se_excite (Multiply) (None, None, None, 0 ['block6b_activation[0][0]', \n", - " 1152) 'block6b_se_expand[0][0]'] \n", + " block6b_se_excite (Multipl (None, None, None, 1152) 0 ['block6b_activation[0][0]', \n", + " y) 'block6b_se_expand[0][0]'] \n", " \n", - " block6b_project_conv (Conv2D) (None, None, None, 221184 ['block6b_se_excite[0][0]'] \n", - " 192) \n", + " block6b_project_conv (Conv (None, None, None, 192) 221184 ['block6b_se_excite[0][0]'] \n", + " 2D) \n", " \n", - " block6b_project_bn (BatchNorma (None, None, None, 768 ['block6b_project_conv[0][0]'] \n", - " lization) 192) \n", + " block6b_project_bn (BatchN (None, None, None, 192) 768 ['block6b_project_conv[0][0]']\n", + " ormalization) \n", " \n", - " block6b_drop (Dropout) (None, None, None, 0 ['block6b_project_bn[0][0]'] \n", - " 192) \n", + " block6b_drop (Dropout) (None, None, None, 192) 0 ['block6b_project_bn[0][0]'] \n", " \n", - " block6b_add (Add) (None, None, None, 0 ['block6b_drop[0][0]', \n", - " 192) 'block6a_project_bn[0][0]'] \n", + " block6b_add (Add) (None, None, None, 192) 0 ['block6b_drop[0][0]', \n", + " 'block6a_project_bn[0][0]'] \n", " \n", - " block6c_expand_conv (Conv2D) (None, None, None, 221184 ['block6b_add[0][0]'] \n", - " 1152) \n", + " block6c_expand_conv (Conv2 (None, None, None, 1152) 221184 ['block6b_add[0][0]'] \n", + " D) \n", " \n", - " block6c_expand_bn (BatchNormal (None, None, None, 4608 ['block6c_expand_conv[0][0]'] \n", - " ization) 1152) \n", + " block6c_expand_bn (BatchNo (None, None, None, 1152) 4608 ['block6c_expand_conv[0][0]'] \n", + " rmalization) \n", " \n", - " block6c_expand_activation (Act (None, None, None, 0 ['block6c_expand_bn[0][0]'] \n", - " ivation) 1152) \n", + " block6c_expand_activation (None, None, None, 1152) 0 ['block6c_expand_bn[0][0]'] \n", + " (Activation) \n", " \n", - " block6c_dwconv2 (DepthwiseConv (None, None, None, 10368 ['block6c_expand_activation[0][0]\n", - " 2D) 1152) '] \n", + " block6c_dwconv2 (Depthwise (None, None, None, 1152) 10368 ['block6c_expand_activation[0]\n", + " Conv2D) [0]'] \n", " \n", - " block6c_bn (BatchNormalization (None, None, None, 4608 ['block6c_dwconv2[0][0]'] \n", - " ) 1152) \n", + " block6c_bn (BatchNormaliza (None, None, None, 1152) 4608 ['block6c_dwconv2[0][0]'] \n", + " tion) \n", " \n", - " block6c_activation (Activation (None, None, None, 0 ['block6c_bn[0][0]'] \n", - " ) 1152) \n", + " block6c_activation (Activa (None, None, None, 1152) 0 ['block6c_bn[0][0]'] \n", + " tion) \n", " \n", - " block6c_se_squeeze (GlobalAver (None, 1152) 0 ['block6c_activation[0][0]'] \n", - " agePooling2D) \n", + " block6c_se_squeeze (Global (None, 1152) 0 ['block6c_activation[0][0]'] \n", + " AveragePooling2D) \n", " \n", - " block6c_se_reshape (Reshape) (None, 1, 1, 1152) 0 ['block6c_se_squeeze[0][0]'] \n", + " block6c_se_reshape (Reshap (None, 1, 1, 1152) 0 ['block6c_se_squeeze[0][0]'] \n", + " e) \n", " \n", - " block6c_se_reduce (Conv2D) (None, 1, 1, 48) 55344 ['block6c_se_reshape[0][0]'] \n", + " block6c_se_reduce (Conv2D) (None, 1, 1, 48) 55344 ['block6c_se_reshape[0][0]'] \n", " \n", - " block6c_se_expand (Conv2D) (None, 1, 1, 1152) 56448 ['block6c_se_reduce[0][0]'] \n", + " block6c_se_expand (Conv2D) (None, 1, 1, 1152) 56448 ['block6c_se_reduce[0][0]'] \n", " \n", - " block6c_se_excite (Multiply) (None, None, None, 0 ['block6c_activation[0][0]', \n", - " 1152) 'block6c_se_expand[0][0]'] \n", + " block6c_se_excite (Multipl (None, None, None, 1152) 0 ['block6c_activation[0][0]', \n", + " y) 'block6c_se_expand[0][0]'] \n", " \n", - " block6c_project_conv (Conv2D) (None, None, None, 221184 ['block6c_se_excite[0][0]'] \n", - " 192) \n", + " block6c_project_conv (Conv (None, None, None, 192) 221184 ['block6c_se_excite[0][0]'] \n", + " 2D) \n", " \n", - " block6c_project_bn (BatchNorma (None, None, None, 768 ['block6c_project_conv[0][0]'] \n", - " lization) 192) \n", + " block6c_project_bn (BatchN (None, None, None, 192) 768 ['block6c_project_conv[0][0]']\n", + " ormalization) \n", " \n", - " block6c_drop (Dropout) (None, None, None, 0 ['block6c_project_bn[0][0]'] \n", - " 192) \n", + " block6c_drop (Dropout) (None, None, None, 192) 0 ['block6c_project_bn[0][0]'] \n", " \n", - " block6c_add (Add) (None, None, None, 0 ['block6c_drop[0][0]', \n", - " 192) 'block6b_add[0][0]'] \n", + " block6c_add (Add) (None, None, None, 192) 0 ['block6c_drop[0][0]', \n", + " 'block6b_add[0][0]'] \n", " \n", - " block6d_expand_conv (Conv2D) (None, None, None, 221184 ['block6c_add[0][0]'] \n", - " 1152) \n", + " block6d_expand_conv (Conv2 (None, None, None, 1152) 221184 ['block6c_add[0][0]'] \n", + " D) \n", " \n", - " block6d_expand_bn (BatchNormal (None, None, None, 4608 ['block6d_expand_conv[0][0]'] \n", - " ization) 1152) \n", + " block6d_expand_bn (BatchNo (None, None, None, 1152) 4608 ['block6d_expand_conv[0][0]'] \n", + " rmalization) \n", " \n", - " block6d_expand_activation (Act (None, None, None, 0 ['block6d_expand_bn[0][0]'] \n", - " ivation) 1152) \n", + " block6d_expand_activation (None, None, None, 1152) 0 ['block6d_expand_bn[0][0]'] \n", + " (Activation) \n", " \n", - " block6d_dwconv2 (DepthwiseConv (None, None, None, 10368 ['block6d_expand_activation[0][0]\n", - " 2D) 1152) '] \n", + " block6d_dwconv2 (Depthwise (None, None, None, 1152) 10368 ['block6d_expand_activation[0]\n", + " Conv2D) [0]'] \n", " \n", - " block6d_bn (BatchNormalization (None, None, None, 4608 ['block6d_dwconv2[0][0]'] \n", - " ) 1152) \n", + " block6d_bn (BatchNormaliza (None, None, None, 1152) 4608 ['block6d_dwconv2[0][0]'] \n", + " tion) \n", " \n", - " block6d_activation (Activation (None, None, None, 0 ['block6d_bn[0][0]'] \n", - " ) 1152) \n", + " block6d_activation (Activa (None, None, None, 1152) 0 ['block6d_bn[0][0]'] \n", + " tion) \n", " \n", - " block6d_se_squeeze (GlobalAver (None, 1152) 0 ['block6d_activation[0][0]'] \n", - " agePooling2D) \n", + " block6d_se_squeeze (Global (None, 1152) 0 ['block6d_activation[0][0]'] \n", + " AveragePooling2D) \n", " \n", - " block6d_se_reshape (Reshape) (None, 1, 1, 1152) 0 ['block6d_se_squeeze[0][0]'] \n", + " block6d_se_reshape (Reshap (None, 1, 1, 1152) 0 ['block6d_se_squeeze[0][0]'] \n", + " e) \n", " \n", - " block6d_se_reduce (Conv2D) (None, 1, 1, 48) 55344 ['block6d_se_reshape[0][0]'] \n", + " block6d_se_reduce (Conv2D) (None, 1, 1, 48) 55344 ['block6d_se_reshape[0][0]'] \n", " \n", - " block6d_se_expand (Conv2D) (None, 1, 1, 1152) 56448 ['block6d_se_reduce[0][0]'] \n", + " block6d_se_expand (Conv2D) (None, 1, 1, 1152) 56448 ['block6d_se_reduce[0][0]'] \n", " \n", - " block6d_se_excite (Multiply) (None, None, None, 0 ['block6d_activation[0][0]', \n", - " 1152) 'block6d_se_expand[0][0]'] \n", + " block6d_se_excite (Multipl (None, None, None, 1152) 0 ['block6d_activation[0][0]', \n", + " y) 'block6d_se_expand[0][0]'] \n", " \n", - " block6d_project_conv (Conv2D) (None, None, None, 221184 ['block6d_se_excite[0][0]'] \n", - " 192) \n", + " block6d_project_conv (Conv (None, None, None, 192) 221184 ['block6d_se_excite[0][0]'] \n", + " 2D) \n", " \n", - " block6d_project_bn (BatchNorma (None, None, None, 768 ['block6d_project_conv[0][0]'] \n", - " lization) 192) \n", + " block6d_project_bn (BatchN (None, None, None, 192) 768 ['block6d_project_conv[0][0]']\n", + " ormalization) \n", " \n", - " block6d_drop (Dropout) (None, None, None, 0 ['block6d_project_bn[0][0]'] \n", - " 192) \n", + " block6d_drop (Dropout) (None, None, None, 192) 0 ['block6d_project_bn[0][0]'] \n", " \n", - " block6d_add (Add) (None, None, None, 0 ['block6d_drop[0][0]', \n", - " 192) 'block6c_add[0][0]'] \n", + " block6d_add (Add) (None, None, None, 192) 0 ['block6d_drop[0][0]', \n", + " 'block6c_add[0][0]'] \n", " \n", - " block6e_expand_conv (Conv2D) (None, None, None, 221184 ['block6d_add[0][0]'] \n", - " 1152) \n", + " block6e_expand_conv (Conv2 (None, None, None, 1152) 221184 ['block6d_add[0][0]'] \n", + " D) \n", " \n", - " block6e_expand_bn (BatchNormal (None, None, None, 4608 ['block6e_expand_conv[0][0]'] \n", - " ization) 1152) \n", + " block6e_expand_bn (BatchNo (None, None, None, 1152) 4608 ['block6e_expand_conv[0][0]'] \n", + " rmalization) \n", " \n", - " block6e_expand_activation (Act (None, None, None, 0 ['block6e_expand_bn[0][0]'] \n", - " ivation) 1152) \n", + " block6e_expand_activation (None, None, None, 1152) 0 ['block6e_expand_bn[0][0]'] \n", + " (Activation) \n", " \n", - " block6e_dwconv2 (DepthwiseConv (None, None, None, 10368 ['block6e_expand_activation[0][0]\n", - " 2D) 1152) '] \n", + " block6e_dwconv2 (Depthwise (None, None, None, 1152) 10368 ['block6e_expand_activation[0]\n", + " Conv2D) [0]'] \n", " \n", - " block6e_bn (BatchNormalization (None, None, None, 4608 ['block6e_dwconv2[0][0]'] \n", - " ) 1152) \n", + " block6e_bn (BatchNormaliza (None, None, None, 1152) 4608 ['block6e_dwconv2[0][0]'] \n", + " tion) \n", " \n", - " block6e_activation (Activation (None, None, None, 0 ['block6e_bn[0][0]'] \n", - " ) 1152) \n", + " block6e_activation (Activa (None, None, None, 1152) 0 ['block6e_bn[0][0]'] \n", + " tion) \n", " \n", - " block6e_se_squeeze (GlobalAver (None, 1152) 0 ['block6e_activation[0][0]'] \n", - " agePooling2D) \n", + " block6e_se_squeeze (Global (None, 1152) 0 ['block6e_activation[0][0]'] \n", + " AveragePooling2D) \n", " \n", - " block6e_se_reshape (Reshape) (None, 1, 1, 1152) 0 ['block6e_se_squeeze[0][0]'] \n", + " block6e_se_reshape (Reshap (None, 1, 1, 1152) 0 ['block6e_se_squeeze[0][0]'] \n", + " e) \n", " \n", - " block6e_se_reduce (Conv2D) (None, 1, 1, 48) 55344 ['block6e_se_reshape[0][0]'] \n", + " block6e_se_reduce (Conv2D) (None, 1, 1, 48) 55344 ['block6e_se_reshape[0][0]'] \n", " \n", - " block6e_se_expand (Conv2D) (None, 1, 1, 1152) 56448 ['block6e_se_reduce[0][0]'] \n", + " block6e_se_expand (Conv2D) (None, 1, 1, 1152) 56448 ['block6e_se_reduce[0][0]'] \n", " \n", - " block6e_se_excite (Multiply) (None, None, None, 0 ['block6e_activation[0][0]', \n", - " 1152) 'block6e_se_expand[0][0]'] \n", + " block6e_se_excite (Multipl (None, None, None, 1152) 0 ['block6e_activation[0][0]', \n", + " y) 'block6e_se_expand[0][0]'] \n", " \n", - " block6e_project_conv (Conv2D) (None, None, None, 221184 ['block6e_se_excite[0][0]'] \n", - " 192) \n", + " block6e_project_conv (Conv (None, None, None, 192) 221184 ['block6e_se_excite[0][0]'] \n", + " 2D) \n", " \n", - " block6e_project_bn (BatchNorma (None, None, None, 768 ['block6e_project_conv[0][0]'] \n", - " lization) 192) \n", + " block6e_project_bn (BatchN (None, None, None, 192) 768 ['block6e_project_conv[0][0]']\n", + " ormalization) \n", " \n", - " block6e_drop (Dropout) (None, None, None, 0 ['block6e_project_bn[0][0]'] \n", - " 192) \n", + " block6e_drop (Dropout) (None, None, None, 192) 0 ['block6e_project_bn[0][0]'] \n", " \n", - " block6e_add (Add) (None, None, None, 0 ['block6e_drop[0][0]', \n", - " 192) 'block6d_add[0][0]'] \n", + " block6e_add (Add) (None, None, None, 192) 0 ['block6e_drop[0][0]', \n", + " 'block6d_add[0][0]'] \n", " \n", - " block6f_expand_conv (Conv2D) (None, None, None, 221184 ['block6e_add[0][0]'] \n", - " 1152) \n", + " block6f_expand_conv (Conv2 (None, None, None, 1152) 221184 ['block6e_add[0][0]'] \n", + " D) \n", " \n", - " block6f_expand_bn (BatchNormal (None, None, None, 4608 ['block6f_expand_conv[0][0]'] \n", - " ization) 1152) \n", + " block6f_expand_bn (BatchNo (None, None, None, 1152) 4608 ['block6f_expand_conv[0][0]'] \n", + " rmalization) \n", " \n", - " block6f_expand_activation (Act (None, None, None, 0 ['block6f_expand_bn[0][0]'] \n", - " ivation) 1152) \n", + " block6f_expand_activation (None, None, None, 1152) 0 ['block6f_expand_bn[0][0]'] \n", + " (Activation) \n", " \n", - " block6f_dwconv2 (DepthwiseConv (None, None, None, 10368 ['block6f_expand_activation[0][0]\n", - " 2D) 1152) '] \n", + " block6f_dwconv2 (Depthwise (None, None, None, 1152) 10368 ['block6f_expand_activation[0]\n", + " Conv2D) [0]'] \n", " \n", - " block6f_bn (BatchNormalization (None, None, None, 4608 ['block6f_dwconv2[0][0]'] \n", - " ) 1152) \n", + " block6f_bn (BatchNormaliza (None, None, None, 1152) 4608 ['block6f_dwconv2[0][0]'] \n", + " tion) \n", " \n", - " block6f_activation (Activation (None, None, None, 0 ['block6f_bn[0][0]'] \n", - " ) 1152) \n", + " block6f_activation (Activa (None, None, None, 1152) 0 ['block6f_bn[0][0]'] \n", + " tion) \n", " \n", - " block6f_se_squeeze (GlobalAver (None, 1152) 0 ['block6f_activation[0][0]'] \n", - " agePooling2D) \n", + " block6f_se_squeeze (Global (None, 1152) 0 ['block6f_activation[0][0]'] \n", + " AveragePooling2D) \n", " \n", - " block6f_se_reshape (Reshape) (None, 1, 1, 1152) 0 ['block6f_se_squeeze[0][0]'] \n", + " block6f_se_reshape (Reshap (None, 1, 1, 1152) 0 ['block6f_se_squeeze[0][0]'] \n", + " e) \n", " \n", - " block6f_se_reduce (Conv2D) (None, 1, 1, 48) 55344 ['block6f_se_reshape[0][0]'] \n", + " block6f_se_reduce (Conv2D) (None, 1, 1, 48) 55344 ['block6f_se_reshape[0][0]'] \n", " \n", - " block6f_se_expand (Conv2D) (None, 1, 1, 1152) 56448 ['block6f_se_reduce[0][0]'] \n", + " block6f_se_expand (Conv2D) (None, 1, 1, 1152) 56448 ['block6f_se_reduce[0][0]'] \n", " \n", - " block6f_se_excite (Multiply) (None, None, None, 0 ['block6f_activation[0][0]', \n", - " 1152) 'block6f_se_expand[0][0]'] \n", + " block6f_se_excite (Multipl (None, None, None, 1152) 0 ['block6f_activation[0][0]', \n", + " y) 'block6f_se_expand[0][0]'] \n", " \n", - " block6f_project_conv (Conv2D) (None, None, None, 221184 ['block6f_se_excite[0][0]'] \n", - " 192) \n", + " block6f_project_conv (Conv (None, None, None, 192) 221184 ['block6f_se_excite[0][0]'] \n", + " 2D) \n", " \n", - " block6f_project_bn (BatchNorma (None, None, None, 768 ['block6f_project_conv[0][0]'] \n", - " lization) 192) \n", + " block6f_project_bn (BatchN (None, None, None, 192) 768 ['block6f_project_conv[0][0]']\n", + " ormalization) \n", " \n", - " block6f_drop (Dropout) (None, None, None, 0 ['block6f_project_bn[0][0]'] \n", - " 192) \n", + " block6f_drop (Dropout) (None, None, None, 192) 0 ['block6f_project_bn[0][0]'] \n", " \n", - " block6f_add (Add) (None, None, None, 0 ['block6f_drop[0][0]', \n", - " 192) 'block6e_add[0][0]'] \n", + " block6f_add (Add) (None, None, None, 192) 0 ['block6f_drop[0][0]', \n", + " 'block6e_add[0][0]'] \n", " \n", - " block6g_expand_conv (Conv2D) (None, None, None, 221184 ['block6f_add[0][0]'] \n", - " 1152) \n", + " block6g_expand_conv (Conv2 (None, None, None, 1152) 221184 ['block6f_add[0][0]'] \n", + " D) \n", " \n", - " block6g_expand_bn (BatchNormal (None, None, None, 4608 ['block6g_expand_conv[0][0]'] \n", - " ization) 1152) \n", + " block6g_expand_bn (BatchNo (None, None, None, 1152) 4608 ['block6g_expand_conv[0][0]'] \n", + " rmalization) \n", " \n", - " block6g_expand_activation (Act (None, None, None, 0 ['block6g_expand_bn[0][0]'] \n", - " ivation) 1152) \n", + " block6g_expand_activation (None, None, None, 1152) 0 ['block6g_expand_bn[0][0]'] \n", + " (Activation) \n", " \n", - " block6g_dwconv2 (DepthwiseConv (None, None, None, 10368 ['block6g_expand_activation[0][0]\n", - " 2D) 1152) '] \n", + " block6g_dwconv2 (Depthwise (None, None, None, 1152) 10368 ['block6g_expand_activation[0]\n", + " Conv2D) [0]'] \n", " \n", - " block6g_bn (BatchNormalization (None, None, None, 4608 ['block6g_dwconv2[0][0]'] \n", - " ) 1152) \n", + " block6g_bn (BatchNormaliza (None, None, None, 1152) 4608 ['block6g_dwconv2[0][0]'] \n", + " tion) \n", " \n", - " block6g_activation (Activation (None, None, None, 0 ['block6g_bn[0][0]'] \n", - " ) 1152) \n", + " block6g_activation (Activa (None, None, None, 1152) 0 ['block6g_bn[0][0]'] \n", + " tion) \n", " \n", - " block6g_se_squeeze (GlobalAver (None, 1152) 0 ['block6g_activation[0][0]'] \n", - " agePooling2D) \n", + " block6g_se_squeeze (Global (None, 1152) 0 ['block6g_activation[0][0]'] \n", + " AveragePooling2D) \n", " \n", - " block6g_se_reshape (Reshape) (None, 1, 1, 1152) 0 ['block6g_se_squeeze[0][0]'] \n", + " block6g_se_reshape (Reshap (None, 1, 1, 1152) 0 ['block6g_se_squeeze[0][0]'] \n", + " e) \n", " \n", - " block6g_se_reduce (Conv2D) (None, 1, 1, 48) 55344 ['block6g_se_reshape[0][0]'] \n", + " block6g_se_reduce (Conv2D) (None, 1, 1, 48) 55344 ['block6g_se_reshape[0][0]'] \n", " \n", - " block6g_se_expand (Conv2D) (None, 1, 1, 1152) 56448 ['block6g_se_reduce[0][0]'] \n", + " block6g_se_expand (Conv2D) (None, 1, 1, 1152) 56448 ['block6g_se_reduce[0][0]'] \n", " \n", - " block6g_se_excite (Multiply) (None, None, None, 0 ['block6g_activation[0][0]', \n", - " 1152) 'block6g_se_expand[0][0]'] \n", + " block6g_se_excite (Multipl (None, None, None, 1152) 0 ['block6g_activation[0][0]', \n", + " y) 'block6g_se_expand[0][0]'] \n", " \n", - " block6g_project_conv (Conv2D) (None, None, None, 221184 ['block6g_se_excite[0][0]'] \n", - " 192) \n", + " block6g_project_conv (Conv (None, None, None, 192) 221184 ['block6g_se_excite[0][0]'] \n", + " 2D) \n", " \n", - " block6g_project_bn (BatchNorma (None, None, None, 768 ['block6g_project_conv[0][0]'] \n", - " lization) 192) \n", + " block6g_project_bn (BatchN (None, None, None, 192) 768 ['block6g_project_conv[0][0]']\n", + " ormalization) \n", " \n", - " block6g_drop (Dropout) (None, None, None, 0 ['block6g_project_bn[0][0]'] \n", - " 192) \n", + " block6g_drop (Dropout) (None, None, None, 192) 0 ['block6g_project_bn[0][0]'] \n", " \n", - " block6g_add (Add) (None, None, None, 0 ['block6g_drop[0][0]', \n", - " 192) 'block6f_add[0][0]'] \n", + " block6g_add (Add) (None, None, None, 192) 0 ['block6g_drop[0][0]', \n", + " 'block6f_add[0][0]'] \n", " \n", - " block6h_expand_conv (Conv2D) (None, None, None, 221184 ['block6g_add[0][0]'] \n", - " 1152) \n", + " block6h_expand_conv (Conv2 (None, None, None, 1152) 221184 ['block6g_add[0][0]'] \n", + " D) \n", " \n", - " block6h_expand_bn (BatchNormal (None, None, None, 4608 ['block6h_expand_conv[0][0]'] \n", - " ization) 1152) \n", + " block6h_expand_bn (BatchNo (None, None, None, 1152) 4608 ['block6h_expand_conv[0][0]'] \n", + " rmalization) \n", " \n", - " block6h_expand_activation (Act (None, None, None, 0 ['block6h_expand_bn[0][0]'] \n", - " ivation) 1152) \n", + " block6h_expand_activation (None, None, None, 1152) 0 ['block6h_expand_bn[0][0]'] \n", + " (Activation) \n", " \n", - " block6h_dwconv2 (DepthwiseConv (None, None, None, 10368 ['block6h_expand_activation[0][0]\n", - " 2D) 1152) '] \n", + " block6h_dwconv2 (Depthwise (None, None, None, 1152) 10368 ['block6h_expand_activation[0]\n", + " Conv2D) [0]'] \n", " \n", - " block6h_bn (BatchNormalization (None, None, None, 4608 ['block6h_dwconv2[0][0]'] \n", - " ) 1152) \n", + " block6h_bn (BatchNormaliza (None, None, None, 1152) 4608 ['block6h_dwconv2[0][0]'] \n", + " tion) \n", " \n", - " block6h_activation (Activation (None, None, None, 0 ['block6h_bn[0][0]'] \n", - " ) 1152) \n", + " block6h_activation (Activa (None, None, None, 1152) 0 ['block6h_bn[0][0]'] \n", + " tion) \n", " \n", - " block6h_se_squeeze (GlobalAver (None, 1152) 0 ['block6h_activation[0][0]'] \n", - " agePooling2D) \n", + " block6h_se_squeeze (Global (None, 1152) 0 ['block6h_activation[0][0]'] \n", + " AveragePooling2D) \n", " \n", - " block6h_se_reshape (Reshape) (None, 1, 1, 1152) 0 ['block6h_se_squeeze[0][0]'] \n", + " block6h_se_reshape (Reshap (None, 1, 1, 1152) 0 ['block6h_se_squeeze[0][0]'] \n", + " e) \n", " \n", - " block6h_se_reduce (Conv2D) (None, 1, 1, 48) 55344 ['block6h_se_reshape[0][0]'] \n", + " block6h_se_reduce (Conv2D) (None, 1, 1, 48) 55344 ['block6h_se_reshape[0][0]'] \n", " \n", - " block6h_se_expand (Conv2D) (None, 1, 1, 1152) 56448 ['block6h_se_reduce[0][0]'] \n", + " block6h_se_expand (Conv2D) (None, 1, 1, 1152) 56448 ['block6h_se_reduce[0][0]'] \n", " \n", - " block6h_se_excite (Multiply) (None, None, None, 0 ['block6h_activation[0][0]', \n", - " 1152) 'block6h_se_expand[0][0]'] \n", + " block6h_se_excite (Multipl (None, None, None, 1152) 0 ['block6h_activation[0][0]', \n", + " y) 'block6h_se_expand[0][0]'] \n", " \n", - " block6h_project_conv (Conv2D) (None, None, None, 221184 ['block6h_se_excite[0][0]'] \n", - " 192) \n", + " block6h_project_conv (Conv (None, None, None, 192) 221184 ['block6h_se_excite[0][0]'] \n", + " 2D) \n", " \n", - " block6h_project_bn (BatchNorma (None, None, None, 768 ['block6h_project_conv[0][0]'] \n", - " lization) 192) \n", + " block6h_project_bn (BatchN (None, None, None, 192) 768 ['block6h_project_conv[0][0]']\n", + " ormalization) \n", " \n", - " block6h_drop (Dropout) (None, None, None, 0 ['block6h_project_bn[0][0]'] \n", - " 192) \n", + " block6h_drop (Dropout) (None, None, None, 192) 0 ['block6h_project_bn[0][0]'] \n", " \n", - " block6h_add (Add) (None, None, None, 0 ['block6h_drop[0][0]', \n", - " 192) 'block6g_add[0][0]'] \n", + " block6h_add (Add) (None, None, None, 192) 0 ['block6h_drop[0][0]', \n", + " 'block6g_add[0][0]'] \n", " \n", - " top_conv (Conv2D) (None, None, None, 245760 ['block6h_add[0][0]'] \n", - " 1280) \n", + " top_conv (Conv2D) (None, None, None, 1280) 245760 ['block6h_add[0][0]'] \n", " \n", - " top_bn (BatchNormalization) (None, None, None, 5120 ['top_conv[0][0]'] \n", - " 1280) \n", + " top_bn (BatchNormalization (None, None, None, 1280) 5120 ['top_conv[0][0]'] \n", + " ) \n", " \n", - " top_activation (Activation) (None, None, None, 0 ['top_bn[0][0]'] \n", - " 1280) \n", + " top_activation (Activation (None, None, None, 1280) 0 ['top_bn[0][0]'] \n", + " ) \n", " \n", "==================================================================================================\n", - "Total params: 5,919,312\n", - "Trainable params: 0\n", - "Non-trainable params: 5,919,312\n", + "Total params: 5919312 (22.58 MB)\n", + "Trainable params: 0 (0.00 Byte)\n", + "Non-trainable params: 5919312 (22.58 MB)\n", "__________________________________________________________________________________________________\n" ] } @@ -2208,13 +2252,13 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 18, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "KGY1BjnzJDEx", - "outputId": "e03aee53-fd29-46bf-875b-024fb143c08a" + "outputId": "fe23c59b-d754-4f2e-d007-079d935f05e3" }, "outputs": [ { @@ -2227,18 +2271,19 @@ "=================================================================\n", " input_layer (InputLayer) [(None, 224, 224, 3)] 0 \n", " \n", - " efficientnetv2-b0 (Function (None, None, None, 1280) 5919312 \n", - " al) \n", + " efficientnetv2-b0 (Functio (None, None, None, 1280 5919312 \n", + " nal) ) \n", " \n", - " global_average_pooling_laye (None, 1280) 0 \n", - " r (GlobalAveragePooling2D) \n", + " global_average_pooling_lay (None, 1280) 0 \n", + " er (GlobalAveragePooling2D \n", + " ) \n", " \n", " output_layer (Dense) (None, 10) 12810 \n", " \n", "=================================================================\n", - "Total params: 5,932,122\n", - "Trainable params: 12,810\n", - "Non-trainable params: 5,919,312\n", + "Total params: 5932122 (22.63 MB)\n", + "Trainable params: 12810 (50.04 KB)\n", + "Non-trainable params: 5919312 (22.58 MB)\n", "_________________________________________________________________\n" ] } @@ -2266,14 +2311,14 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 19, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 927 }, "id": "tWYqK_86xSUJ", - "outputId": "ac2fe1d8-5c23-4a5d-fc43-9b94ac20bb15" + "outputId": "cdbbe5d3-c5e5-4357-d77b-5b0e5cff62e4" }, "outputs": [ { @@ -2282,7 +2327,7 @@ "text/plain": [ "
" ], - "image/png": "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\n" + "image/png": "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\n" }, "metadata": {} }, @@ -2292,7 +2337,7 @@ "text/plain": [ "
" ], - "image/png": "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\n" + "image/png": "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\n" }, "metadata": {} } @@ -2319,13 +2364,13 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 20, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "xYNLE0VU_c50", - "outputId": "8cdd64dc-b6ca-48d4-e6cd-e2208959e34f" + "outputId": "ad95afd8-1045-4afd-e515-31d786643379" }, "outputs": [ { @@ -2343,14 +2388,14 @@ " [ 0.9058464 0.29855987 -0.22561555]\n", " [-0.7616443 -1.8917141 -0.93847126]]\n", "\n", - " [[ 0.77852213 -0.47338897 0.97772694]\n", - " [ 0.24694404 0.20573747 -0.5256233 ]\n", - " [ 0.32410017 0.02545409 -0.10638497]\n", - " [-0.6369475 1.1603122 0.2507359 ]]\n", + " [[ 0.77852213 -0.47338894 0.97772694]\n", + " [ 0.24694404 0.20573746 -0.52562326]\n", + " [ 0.32410017 0.02545409 -0.10638496]\n", + " [-0.63694745 1.1603122 0.2507359 ]]\n", "\n", " [[-0.41728503 0.4012578 -1.4145443 ]\n", " [-0.5931857 -1.6617213 0.33567193]\n", - " [ 0.10815629 0.23479682 -0.56668764]\n", + " [ 0.10815628 0.23479679 -0.56668764]\n", " [-0.35819843 0.88698614 0.52744764]]]]\n", "\n", "2D global average pooled random tensor:\n", @@ -2392,13 +2437,13 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 21, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "jBzN5HfAAUHx", - "outputId": "ecc7f3bb-aabb-469a-efd5-f479fd9f121a" + "outputId": "1025fed9-a293-4b1a-dad7-6c7a81d9e476" }, "outputs": [ { @@ -2409,7 +2454,7 @@ ] }, "metadata": {}, - "execution_count": 18 + "execution_count": 21 } ], "source": [ @@ -2461,29 +2506,29 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 22, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "2P1rLJmaCXZN", - "outputId": "430fe00f-00e9-437f-aee2-65f00ca679a1" + "outputId": "8be6346f-0e66-4c0f-d2d8-f9204a3242ce" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ - "--2023-08-18 01:40:38-- https://storage.googleapis.com/ztm_tf_course/food_vision/10_food_classes_1_percent.zip\n", - "Resolving storage.googleapis.com (storage.googleapis.com)... 74.125.20.128, 108.177.98.128, 74.125.197.128, ...\n", - "Connecting to storage.googleapis.com (storage.googleapis.com)|74.125.20.128|:443... connected.\n", + "--2024-01-14 13:38:58-- https://storage.googleapis.com/ztm_tf_course/food_vision/10_food_classes_1_percent.zip\n", + "Resolving storage.googleapis.com (storage.googleapis.com)... 172.217.194.207, 142.250.4.207, 172.253.118.207, ...\n", + "Connecting to storage.googleapis.com (storage.googleapis.com)|172.217.194.207|:443... connected.\n", "HTTP request sent, awaiting response... 200 OK\n", "Length: 133612354 (127M) [application/zip]\n", "Saving to: ‘10_food_classes_1_percent.zip’\n", "\n", - "10_food_classes_1_p 100%[===================>] 127.42M 222MB/s in 0.6s \n", + "10_food_classes_1_p 100%[===================>] 127.42M 21.6MB/s in 7.0s \n", "\n", - "2023-08-18 01:40:39 (222 MB/s) - ‘10_food_classes_1_percent.zip’ saved [133612354/133612354]\n", + "2024-01-14 13:39:06 (18.1 MB/s) - ‘10_food_classes_1_percent.zip’ saved [133612354/133612354]\n", "\n" ] } @@ -2509,13 +2554,13 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 23, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "sqoi0htuo6Sb", - "outputId": "6923f63d-b9ad-47da-f59c-abc12b75befa" + "outputId": "ac7f7e64-76d7-419b-d78f-9cf569ed1e46" }, "outputs": [ { @@ -2524,27 +2569,27 @@ "text": [ "There are 2 directories and 0 images in '10_food_classes_1_percent'.\n", "There are 10 directories and 0 images in '10_food_classes_1_percent/train'.\n", - "There are 0 directories and 7 images in '10_food_classes_1_percent/train/ramen'.\n", + "There are 0 directories and 7 images in '10_food_classes_1_percent/train/chicken_wings'.\n", "There are 0 directories and 7 images in '10_food_classes_1_percent/train/chicken_curry'.\n", + "There are 0 directories and 7 images in '10_food_classes_1_percent/train/fried_rice'.\n", + "There are 0 directories and 7 images in '10_food_classes_1_percent/train/sushi'.\n", + "There are 0 directories and 7 images in '10_food_classes_1_percent/train/hamburger'.\n", "There are 0 directories and 7 images in '10_food_classes_1_percent/train/pizza'.\n", + "There are 0 directories and 7 images in '10_food_classes_1_percent/train/ramen'.\n", "There are 0 directories and 7 images in '10_food_classes_1_percent/train/ice_cream'.\n", - "There are 0 directories and 7 images in '10_food_classes_1_percent/train/grilled_salmon'.\n", "There are 0 directories and 7 images in '10_food_classes_1_percent/train/steak'.\n", - "There are 0 directories and 7 images in '10_food_classes_1_percent/train/chicken_wings'.\n", - "There are 0 directories and 7 images in '10_food_classes_1_percent/train/hamburger'.\n", - "There are 0 directories and 7 images in '10_food_classes_1_percent/train/sushi'.\n", - "There are 0 directories and 7 images in '10_food_classes_1_percent/train/fried_rice'.\n", + "There are 0 directories and 7 images in '10_food_classes_1_percent/train/grilled_salmon'.\n", "There are 10 directories and 0 images in '10_food_classes_1_percent/test'.\n", - "There are 0 directories and 250 images in '10_food_classes_1_percent/test/ramen'.\n", + "There are 0 directories and 250 images in '10_food_classes_1_percent/test/chicken_wings'.\n", "There are 0 directories and 250 images in '10_food_classes_1_percent/test/chicken_curry'.\n", + "There are 0 directories and 250 images in '10_food_classes_1_percent/test/fried_rice'.\n", + "There are 0 directories and 250 images in '10_food_classes_1_percent/test/sushi'.\n", + "There are 0 directories and 250 images in '10_food_classes_1_percent/test/hamburger'.\n", "There are 0 directories and 250 images in '10_food_classes_1_percent/test/pizza'.\n", + "There are 0 directories and 250 images in '10_food_classes_1_percent/test/ramen'.\n", "There are 0 directories and 250 images in '10_food_classes_1_percent/test/ice_cream'.\n", - "There are 0 directories and 250 images in '10_food_classes_1_percent/test/grilled_salmon'.\n", "There are 0 directories and 250 images in '10_food_classes_1_percent/test/steak'.\n", - "There are 0 directories and 250 images in '10_food_classes_1_percent/test/chicken_wings'.\n", - "There are 0 directories and 250 images in '10_food_classes_1_percent/test/hamburger'.\n", - "There are 0 directories and 250 images in '10_food_classes_1_percent/test/sushi'.\n", - "There are 0 directories and 250 images in '10_food_classes_1_percent/test/fried_rice'.\n" + "There are 0 directories and 250 images in '10_food_classes_1_percent/test/grilled_salmon'.\n" ] } ], @@ -2568,13 +2613,13 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 24, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "Llh9sHmdtgf6", - "outputId": "b6594c4f-b770-41e9-98e9-77cab9336c23" + "outputId": "f340e3f9-cb62-4c9a-8ae9-d01318aa5a90" }, "outputs": [ { @@ -2648,7 +2693,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 25, "metadata": { "id": "bjHAalnakGEu" }, @@ -2694,14 +2739,14 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 26, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 839 }, "id": "VBWXrlJXwKkE", - "outputId": "d5ca5ba1-95db-4aa7-ff84-2e0c00e8f611" + "outputId": "591ae2fb-dd3f-45a3-a1b6-8f16068baede" }, "outputs": [ { @@ -2710,7 +2755,7 @@ "text/plain": [ "
" ], - "image/png": "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\n" + "image/png": "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\n" }, "metadata": {} }, @@ -2720,7 +2765,7 @@ "text/plain": [ "
" ], - "image/png": "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\n" + "image/png": "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\n" }, "metadata": {} } @@ -2772,30 +2817,30 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 27, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "xbj-Z7Bhut-Y", - "outputId": "9bd48730-b793-4520-d471-0c77970757cb" + "outputId": "eb42691f-4daf-4596-a342-b956b7de4605" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ - "Saving TensorBoard log files to: transfer_learning/1_percent_data_aug/20230818-014045\n", + "Saving TensorBoard log files to: logs/fit/\n", "Epoch 1/5\n", - "3/3 [==============================] - 12s 2s/step - loss: 2.3484 - accuracy: 0.1000 - val_loss: 2.1935 - val_accuracy: 0.1908\n", + "3/3 [==============================] - 16s 3s/step - loss: 2.4473 - accuracy: 0.1143 - val_loss: 2.2775 - val_accuracy: 0.1908\n", "Epoch 2/5\n", - "3/3 [==============================] - 2s 965ms/step - loss: 2.1591 - accuracy: 0.2000 - val_loss: 2.1027 - val_accuracy: 0.2418\n", + "3/3 [==============================] - 7s 2s/step - loss: 2.2039 - accuracy: 0.2143 - val_loss: 2.1542 - val_accuracy: 0.2599\n", "Epoch 3/5\n", - "3/3 [==============================] - 2s 894ms/step - loss: 1.9803 - accuracy: 0.3571 - val_loss: 2.0100 - val_accuracy: 0.3076\n", + "3/3 [==============================] - 5s 2s/step - loss: 2.0207 - accuracy: 0.3143 - val_loss: 2.0173 - val_accuracy: 0.3355\n", "Epoch 4/5\n", - "3/3 [==============================] - 2s 916ms/step - loss: 1.8378 - accuracy: 0.5000 - val_loss: 1.9392 - val_accuracy: 0.3372\n", + "3/3 [==============================] - 4s 2s/step - loss: 1.8357 - accuracy: 0.5571 - val_loss: 1.9524 - val_accuracy: 0.3668\n", "Epoch 5/5\n", - "3/3 [==============================] - 2s 866ms/step - loss: 1.7660 - accuracy: 0.5429 - val_loss: 1.8595 - val_accuracy: 0.3931\n" + "3/3 [==============================] - 6s 2s/step - loss: 1.6586 - accuracy: 0.5714 - val_loss: 1.8443 - val_accuracy: 0.4145\n" ] } ], @@ -2835,7 +2880,7 @@ " validation_data=test_data,\n", " validation_steps=int(0.25* len(test_data)), # validate for less steps\n", " # Track model training logs\n", - " callbacks=[create_tensorboard_callback(\"transfer_learning\", \"1_percent_data_aug\")])" + " callbacks=[create_tensorboard_callback(\"1_percent_data_aug\")])" ] }, { @@ -2855,13 +2900,13 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 28, "metadata": { "id": "lloN15WdPkgb", "colab": { "base_uri": "https://localhost:8080/" }, - "outputId": "7e247748-78dc-42e4-9651-c3a1888c6729" + "outputId": "93af74b8-c35a-4fad-81b7-4382e9c4a0ce" }, "outputs": [ { @@ -2874,21 +2919,22 @@ "=================================================================\n", " input_layer (InputLayer) [(None, 224, 224, 3)] 0 \n", " \n", - " data_augmentation (Sequenti (None, None, None, 3) 0 \n", - " al) \n", + " data_augmentation (Sequent (None, None, None, 3) 0 \n", + " ial) \n", " \n", - " efficientnetv2-b0 (Function (None, None, None, 1280) 5919312 \n", - " al) \n", + " efficientnetv2-b0 (Functio (None, None, None, 1280 5919312 \n", + " nal) ) \n", " \n", - " global_average_pooling_laye (None, 1280) 0 \n", - " r (GlobalAveragePooling2D) \n", + " global_average_pooling_lay (None, 1280) 0 \n", + " er (GlobalAveragePooling2D \n", + " ) \n", " \n", " output_layer (Dense) (None, 10) 12810 \n", " \n", "=================================================================\n", - "Total params: 5,932,122\n", - "Trainable params: 12,810\n", - "Non-trainable params: 5,919,312\n", + "Total params: 5932122 (22.63 MB)\n", + "Trainable params: 12810 (50.04 KB)\n", + "Non-trainable params: 5919312 (22.58 MB)\n", "_________________________________________________________________\n" ] } @@ -2913,31 +2959,31 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 29, "metadata": { "id": "RgWXERdy8nXP", "colab": { "base_uri": "https://localhost:8080/" }, - "outputId": "5c70086b-57a1-44b6-b148-ee1c194bf17b" + "outputId": "bfee25fa-5021-4a73-abd5-9cbc0ba96f26" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ - "79/79 [==============================] - 3s 36ms/step - loss: 1.8197 - accuracy: 0.4188\n" + "79/79 [==============================] - 7s 82ms/step - loss: 1.8314 - accuracy: 0.4288\n" ] }, { "output_type": "execute_result", "data": { "text/plain": [ - "[1.819704294204712, 0.4187999963760376]" + "[1.8314383029937744, 0.42879998683929443]" ] }, "metadata": {}, - "execution_count": 26 + "execution_count": 29 } ], "source": [ @@ -2959,14 +3005,14 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 30, "metadata": { "id": "ShCcuguspbyz", "colab": { "base_uri": "https://localhost:8080/", "height": 927 }, - "outputId": "45595fa8-0332-40b8-e7d4-8057c859077f" + "outputId": "19974b30-64f5-43b5-b9cc-91abba36ed8b" }, "outputs": [ { @@ -2975,7 +3021,7 @@ "text/plain": [ "
" ], - "image/png": "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\n" + "image/png": "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\n" }, "metadata": {} }, @@ -2985,7 +3031,7 @@ "text/plain": [ "
" ], - "image/png": "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\n" + "image/png": "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\n" }, "metadata": {} } @@ -3033,7 +3079,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 31, "metadata": { "id": "nv75Z8BkuTmy" }, @@ -3058,13 +3104,13 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 32, "metadata": { "id": "0eZ4SzbiC9zX", "colab": { "base_uri": "https://localhost:8080/" }, - "outputId": "2c3575e4-64c1-4ab8-be12-2cd032cac8f1" + "outputId": "d5e06c80-025b-48ab-ff94-d7e0a9dc6290" }, "outputs": [ { @@ -3105,7 +3151,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 33, "metadata": { "id": "RuuP1FWADHfc" }, @@ -3214,7 +3260,7 @@ "metadata": { "id": "9oz0X3CzTC9e" }, - "execution_count": 31, + "execution_count": 34, "outputs": [] }, { @@ -3242,7 +3288,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 35, "metadata": { "id": "11M6B736noly" }, @@ -3278,40 +3324,40 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 36, "metadata": { "id": "ZOgMGhi0nx0u", "colab": { "base_uri": "https://localhost:8080/" }, - "outputId": "300bed32-1f24-4d78-c855-2b6bed8118af" + "outputId": "fff36d1b-a7bb-4019-ce6f-7ef9a895ece1" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ - "Saving TensorBoard log files to: transfer_learning/10_percent_data_aug/20230818-014119\n", + "Saving TensorBoard log files to: logs/fit/\n", "Epoch 1/5\n", - "24/24 [==============================] - ETA: 0s - loss: 2.0057 - accuracy: 0.3360\n", - "Epoch 1: val_loss improved from inf to 1.50455, saving model to ten_percent_model_checkpoints_weights/checkpoint.ckpt\n", - "24/24 [==============================] - 18s 411ms/step - loss: 2.0057 - accuracy: 0.3360 - val_loss: 1.5045 - val_accuracy: 0.6332\n", + "24/24 [==============================] - ETA: 0s - loss: 1.9936 - accuracy: 0.3413\n", + "Epoch 1: val_loss improved from inf to 1.44268, saving model to ten_percent_model_checkpoints_weights/checkpoint.ckpt\n", + "24/24 [==============================] - 40s 1s/step - loss: 1.9936 - accuracy: 0.3413 - val_loss: 1.4427 - val_accuracy: 0.6727\n", "Epoch 2/5\n", - "24/24 [==============================] - ETA: 0s - loss: 1.3970 - accuracy: 0.6413\n", - "Epoch 2: val_loss improved from 1.50455 to 1.04085, saving model to ten_percent_model_checkpoints_weights/checkpoint.ckpt\n", - "24/24 [==============================] - 7s 291ms/step - loss: 1.3970 - accuracy: 0.6413 - val_loss: 1.0408 - val_accuracy: 0.7615\n", + "24/24 [==============================] - ETA: 0s - loss: 1.3843 - accuracy: 0.6453\n", + "Epoch 2: val_loss improved from 1.44268 to 1.01977, saving model to ten_percent_model_checkpoints_weights/checkpoint.ckpt\n", + "24/24 [==============================] - 26s 1s/step - loss: 1.3843 - accuracy: 0.6453 - val_loss: 1.0198 - val_accuracy: 0.7895\n", "Epoch 3/5\n", - "24/24 [==============================] - ETA: 0s - loss: 1.1097 - accuracy: 0.7253\n", - "Epoch 3: val_loss improved from 1.04085 to 0.86102, saving model to ten_percent_model_checkpoints_weights/checkpoint.ckpt\n", - "24/24 [==============================] - 7s 285ms/step - loss: 1.1097 - accuracy: 0.7253 - val_loss: 0.8610 - val_accuracy: 0.7895\n", + "24/24 [==============================] - ETA: 0s - loss: 1.0953 - accuracy: 0.7493\n", + "Epoch 3: val_loss improved from 1.01977 to 0.80980, saving model to ten_percent_model_checkpoints_weights/checkpoint.ckpt\n", + "24/24 [==============================] - 22s 880ms/step - loss: 1.0953 - accuracy: 0.7493 - val_loss: 0.8098 - val_accuracy: 0.8289\n", "Epoch 4/5\n", - "24/24 [==============================] - ETA: 0s - loss: 0.9359 - accuracy: 0.7707\n", - "Epoch 4: val_loss improved from 0.86102 to 0.72648, saving model to ten_percent_model_checkpoints_weights/checkpoint.ckpt\n", - "24/24 [==============================] - 6s 247ms/step - loss: 0.9359 - accuracy: 0.7707 - val_loss: 0.7265 - val_accuracy: 0.8306\n", + "24/24 [==============================] - ETA: 0s - loss: 0.9363 - accuracy: 0.7707\n", + "Epoch 4: val_loss improved from 0.80980 to 0.69079, saving model to ten_percent_model_checkpoints_weights/checkpoint.ckpt\n", + "24/24 [==============================] - 21s 863ms/step - loss: 0.9363 - accuracy: 0.7707 - val_loss: 0.6908 - val_accuracy: 0.8355\n", "Epoch 5/5\n", - "24/24 [==============================] - ETA: 0s - loss: 0.8332 - accuracy: 0.7840\n", - "Epoch 5: val_loss improved from 0.72648 to 0.68383, saving model to ten_percent_model_checkpoints_weights/checkpoint.ckpt\n", - "24/24 [==============================] - 6s 249ms/step - loss: 0.8332 - accuracy: 0.7840 - val_loss: 0.6838 - val_accuracy: 0.8240\n" + "24/24 [==============================] - ETA: 0s - loss: 0.8279 - accuracy: 0.7960\n", + "Epoch 5: val_loss improved from 0.69079 to 0.62048, saving model to ten_percent_model_checkpoints_weights/checkpoint.ckpt\n", + "24/24 [==============================] - 21s 904ms/step - loss: 0.8279 - accuracy: 0.7960 - val_loss: 0.6205 - val_accuracy: 0.8520\n" ] } ], @@ -3322,7 +3368,7 @@ " epochs=initial_epochs,\n", " validation_data=test_data,\n", " validation_steps=int(0.25 * len(test_data)), # do less steps per validation (quicker)\n", - " callbacks=[create_tensorboard_callback(\"transfer_learning\", \"10_percent_data_aug\"),\n", + " callbacks=[create_tensorboard_callback(\"10_percent_data_aug\"),\n", " checkpoint_callback])" ] }, @@ -3339,31 +3385,31 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 37, "metadata": { "id": "3KBwXaDwvlEX", "colab": { "base_uri": "https://localhost:8080/" }, - "outputId": "0abf7631-8004-4185-e0a6-525d67e24c44" + "outputId": "5901ce35-2200-4356-c17e-91fa2b08cd65" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ - "79/79 [==============================] - 3s 34ms/step - loss: 0.6795 - accuracy: 0.8216\n" + "79/79 [==============================] - 6s 67ms/step - loss: 0.6417 - accuracy: 0.8416\n" ] }, { "output_type": "execute_result", "data": { "text/plain": [ - "[0.6794611215591431, 0.8216000199317932]" + "[0.6416528224945068, 0.8416000008583069]" ] }, "metadata": {}, - "execution_count": 34 + "execution_count": 37 } ], "source": [ @@ -3374,14 +3420,14 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 38, "metadata": { "id": "W-TeYMc_Hh0p", "colab": { "base_uri": "https://localhost:8080/", "height": 927 }, - "outputId": "7d221547-8851-4fa7-d43b-d6fac0250fa2" + "outputId": "43e0ae84-ae23-4145-b244-d6b330faf57d" }, "outputs": [ { @@ -3390,7 +3436,7 @@ "text/plain": [ "
" ], - "image/png": "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\n" + "image/png": "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\n" }, "metadata": {} }, @@ -3400,7 +3446,7 @@ "text/plain": [ "
" ], - "image/png": "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\n" + "image/png": "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\n" }, "metadata": {} } @@ -3425,20 +3471,20 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 39, "metadata": { "id": "Yo5uxm9Du_kO", "colab": { "base_uri": "https://localhost:8080/" }, - "outputId": "36cf3923-57ec-4ecd-9ce5-a0dc8286b501" + "outputId": "bde85613-af57-4728-dfc7-ee9075530232" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ - "79/79 [==============================] - 3s 38ms/step - loss: 0.6795 - accuracy: 0.8216\n" + "79/79 [==============================] - 5s 59ms/step - loss: 0.6417 - accuracy: 0.8416\n" ] } ], @@ -3459,24 +3505,24 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 40, "metadata": { "id": "8oF-zsM_wMVQ", "colab": { "base_uri": "https://localhost:8080/" }, - "outputId": "efd0b7ea-5d36-4d6e-885b-ce9f5f539993" + "outputId": "6817ec91-6a59-4010-8704-64c39e529a5d" }, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ - "True" + "False" ] }, "metadata": {}, - "execution_count": 37 + "execution_count": 40 } ], "source": [ @@ -3497,13 +3543,13 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 41, "metadata": { "id": "0u4N8g9mgBI0", "colab": { "base_uri": "https://localhost:8080/" }, - "outputId": "c74f29fa-3124-47ac-95b6-292729bf1f53" + "outputId": "fdedf7de-60ae-4917-e781-94a0b160122d" }, "outputs": [ { @@ -3514,7 +3560,7 @@ ] }, "metadata": {}, - "execution_count": 38 + "execution_count": 41 } ], "source": [ @@ -3525,20 +3571,20 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 42, "metadata": { "id": "6srnISjohK8N", "colab": { "base_uri": "https://localhost:8080/" }, - "outputId": "96c2e390-a8bf-4775-d387-ed8227d89a28" + "outputId": "ef412730-a43c-4cf2-ab04-0e81d8c61900" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ - "[0. 0.]\n" + "[5.96046448e-08 0.00000000e+00]\n" ] } ], @@ -3573,28 +3619,28 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 43, "metadata": { "id": "EfsHnkOIrx9K", "colab": { "base_uri": "https://localhost:8080/" }, - "outputId": "93d940b1-edd4-45d2-cd41-2ad8a8fcad97" + "outputId": "816fdd60-3501-49c3-fa76-c90e3474d0c6" }, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ - "[,\n", - " ,\n", - " ,\n", - " ,\n", - " ]" + "[,\n", + " ,\n", + " ,\n", + " ,\n", + " ]" ] }, "metadata": {}, - "execution_count": 40 + "execution_count": 43 } ], "source": [ @@ -3613,24 +3659,24 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 44, "metadata": { "id": "QpzkIVuqtbXC", "colab": { "base_uri": "https://localhost:8080/" }, - "outputId": "49a6015b-2e9f-45b0-f20f-08cebd4b947f" + "outputId": "c7a2d524-8a53-4a32-b31e-82a288f543f9" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ - "Layer number: 0 | Layer name: input_layer | Layer type: | Trainable? True\n", - "Layer number: 1 | Layer name: data_augmentation | Layer type: | Trainable? True\n", - "Layer number: 2 | Layer name: efficientnetv2-b0 | Layer type: | Trainable? False\n", - "Layer number: 3 | Layer name: global_average_pooling_layer | Layer type: | Trainable? True\n", - "Layer number: 4 | Layer name: output_layer | Layer type: | Trainable? True\n" + "Layer number: 0 | Layer name: input_layer | Layer type: | Trainable? True\n", + "Layer number: 1 | Layer name: data_augmentation | Layer type: | Trainable? True\n", + "Layer number: 2 | Layer name: efficientnetv2-b0 | Layer type: | Trainable? False\n", + "Layer number: 3 | Layer name: global_average_pooling_layer | Layer type: | Trainable? True\n", + "Layer number: 4 | Layer name: output_layer | Layer type: | Trainable? True\n" ] } ], @@ -3654,13 +3700,13 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 45, "metadata": { "id": "w55Z7qFYsUfy", "colab": { "base_uri": "https://localhost:8080/" }, - "outputId": "31079e50-0c46-4be0-8208-2749a672b7a3" + "outputId": "f48d3fce-ad2e-4d0c-93e9-0d54bb1d96a8" }, "outputs": [ { @@ -3673,21 +3719,22 @@ "=================================================================\n", " input_layer (InputLayer) [(None, 224, 224, 3)] 0 \n", " \n", - " data_augmentation (Sequenti (None, None, None, 3) 0 \n", - " al) \n", + " data_augmentation (Sequent (None, None, None, 3) 0 \n", + " ial) \n", " \n", - " efficientnetv2-b0 (Function (None, None, None, 1280) 5919312 \n", - " al) \n", + " efficientnetv2-b0 (Functio (None, None, None, 1280 5919312 \n", + " nal) ) \n", " \n", - " global_average_pooling_laye (None, 1280) 0 \n", - " r (GlobalAveragePooling2D) \n", + " global_average_pooling_lay (None, 1280) 0 \n", + " er (GlobalAveragePooling2D \n", + " ) \n", " \n", " output_layer (Dense) (None, 10) 12810 \n", " \n", "=================================================================\n", - "Total params: 5,932,122\n", - "Trainable params: 12,810\n", - "Non-trainable params: 5,919,312\n", + "Total params: 5932122 (22.63 MB)\n", + "Trainable params: 12810 (50.04 KB)\n", + "Non-trainable params: 5919312 (22.58 MB)\n", "_________________________________________________________________\n" ] } @@ -3720,9 +3767,9 @@ "height": 35 }, "id": "dHBMG7TMAvzi", - "outputId": "fe4bc3ee-12c5-44d9-cd0a-a9dc0e73330b" + "outputId": "5892eff3-4eb6-4163-903e-9c244a35930c" }, - "execution_count": 43, + "execution_count": 46, "outputs": [ { "output_type": "execute_result", @@ -3735,19 +3782,19 @@ } }, "metadata": {}, - "execution_count": 43 + "execution_count": 46 } ] }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 47, "metadata": { "id": "dgSn6yzywHd7", "colab": { "base_uri": "https://localhost:8080/" }, - "outputId": "9a6a20b2-3692-4da2-823f-9bb4e159a8a3" + "outputId": "19196210-dcf1-4ac9-ebdb-ec3f7c76eba4" }, "outputs": [ { @@ -3776,13 +3823,13 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 48, "metadata": { "id": "WGSvBXM7jKIm", "colab": { "base_uri": "https://localhost:8080/" }, - "outputId": "d62e72f5-0789-4d5a-98c4-b6ec30039bb3" + "outputId": "8e9b23ec-4c5e-47e6-a94a-73258f0b617e" }, "outputs": [ { @@ -4097,7 +4144,7 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 49, "metadata": { "id": "0RN8aH82i__f" }, @@ -4127,13 +4174,13 @@ }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 50, "metadata": { "id": "pyKYo9yB7Xjq", "colab": { "base_uri": "https://localhost:8080/" }, - "outputId": "2d441f7a-6c3c-4543-c6e9-eaf0fa9feab9" + "outputId": "b68dc0bb-0804-429c-9234-cf543b9893b3" }, "outputs": [ { @@ -4442,13 +4489,13 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 51, "metadata": { "id": "tbgcdnJIjicF", "colab": { "base_uri": "https://localhost:8080/" }, - "outputId": "1bef0664-4c52-4c89-870e-6f9df39a051c" + "outputId": "423ad68e-d05a-4f9f-8eb2-33b54b680814" }, "outputs": [ { @@ -4480,32 +4527,32 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 52, "metadata": { "id": "uH6XM4ENjfRn", "colab": { "base_uri": "https://localhost:8080/" }, - "outputId": "c92bd601-a47d-4b77-8604-9888474b2956" + "outputId": "5b7c8328-4018-4251-a7cc-9f923aa35573" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ - "Saving TensorBoard log files to: transfer_learning/10_percent_fine_tune_last_10/20230818-014212\n", + "Saving TensorBoard log files to: logs/fit/\n", "Epoch 5/10\n", - "24/24 [==============================] - 19s 333ms/step - loss: 0.7145 - accuracy: 0.8080 - val_loss: 0.5455 - val_accuracy: 0.8355\n", + "24/24 [==============================] - 34s 988ms/step - loss: 0.7075 - accuracy: 0.8067 - val_loss: 0.4608 - val_accuracy: 0.8668\n", "Epoch 6/10\n", - "24/24 [==============================] - 6s 228ms/step - loss: 0.6243 - accuracy: 0.8133 - val_loss: 0.5008 - val_accuracy: 0.8372\n", + "24/24 [==============================] - 20s 839ms/step - loss: 0.6132 - accuracy: 0.8173 - val_loss: 0.4148 - val_accuracy: 0.8750\n", "Epoch 7/10\n", - "24/24 [==============================] - 5s 199ms/step - loss: 0.5388 - accuracy: 0.8333 - val_loss: 0.4581 - val_accuracy: 0.8520\n", + "24/24 [==============================] - 15s 598ms/step - loss: 0.5547 - accuracy: 0.8240 - val_loss: 0.4178 - val_accuracy: 0.8651\n", "Epoch 8/10\n", - "24/24 [==============================] - 5s 215ms/step - loss: 0.5132 - accuracy: 0.8427 - val_loss: 0.4846 - val_accuracy: 0.8487\n", + "24/24 [==============================] - 16s 681ms/step - loss: 0.5028 - accuracy: 0.8413 - val_loss: 0.3980 - val_accuracy: 0.8799\n", "Epoch 9/10\n", - "24/24 [==============================] - 5s 191ms/step - loss: 0.4753 - accuracy: 0.8467 - val_loss: 0.4536 - val_accuracy: 0.8569\n", + "24/24 [==============================] - 15s 641ms/step - loss: 0.4755 - accuracy: 0.8573 - val_loss: 0.4142 - val_accuracy: 0.8766\n", "Epoch 10/10\n", - "24/24 [==============================] - 6s 225ms/step - loss: 0.4245 - accuracy: 0.8653 - val_loss: 0.4656 - val_accuracy: 0.8470\n" + "24/24 [==============================] - 16s 667ms/step - loss: 0.4454 - accuracy: 0.8520 - val_loss: 0.3903 - val_accuracy: 0.8766\n" ] } ], @@ -4519,7 +4566,7 @@ " validation_data=test_data,\n", " initial_epoch=history_10_percent_data_aug.epoch[-1], # start from previous last epoch\n", " validation_steps=int(0.25 * len(test_data)),\n", - " callbacks=[create_tensorboard_callback(\"transfer_learning\", \"10_percent_fine_tune_last_10\")]) # name experiment appropriately" + " callbacks=[create_tensorboard_callback(\"10_percent_fine_tune_last_10\")]) # name experiment appropriately" ] }, { @@ -4535,20 +4582,20 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 53, "metadata": { "id": "zbFET5Pj8U3F", "colab": { "base_uri": "https://localhost:8080/" }, - "outputId": "f75265d6-fd8d-4fa5-9a6b-3aeeda2fd1e5" + "outputId": "cf48cfb5-dab5-4693-ed03-ac518582e4d6" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ - "79/79 [==============================] - 3s 31ms/step - loss: 0.4526 - accuracy: 0.8504\n" + "79/79 [==============================] - 5s 59ms/step - loss: 0.4296 - accuracy: 0.8620\n" ] } ], @@ -4570,7 +4617,7 @@ }, { "cell_type": "code", - "execution_count": 51, + "execution_count": 54, "metadata": { "id": "8du2ihQNkm4W" }, @@ -4631,14 +4678,14 @@ }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 55, "metadata": { "id": "BJANCd2e5Olt", "colab": { "base_uri": "https://localhost:8080/", - "height": 791 + "height": 790 }, - "outputId": "93444c8e-193d-4a70-d4ac-0c8d729faf16" + "outputId": "f0348338-68de-4599-c760-023f2176c2e7" }, "outputs": [ { @@ -4647,7 +4694,7 @@ "text": [ "5\n", "11\n", - "[0.335999995470047, 0.6413333415985107, 0.7253333330154419, 0.7706666588783264, 0.7839999794960022, 0.8080000281333923, 0.8133333325386047, 0.8333333134651184, 0.8426666855812073, 0.846666693687439, 0.8653333187103271]\n" + "[0.3413333296775818, 0.6453333497047424, 0.7493333220481873, 0.7706666588783264, 0.7960000038146973, 0.8066666722297668, 0.8173333406448364, 0.8240000009536743, 0.8413333296775818, 0.8573333621025085, 0.8519999980926514]\n" ] }, { @@ -4656,7 +4703,7 @@ "text/plain": [ "
" ], - "image/png": "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\n" + "image/png": "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\n" }, "metadata": {} } @@ -4692,29 +4739,29 @@ }, { "cell_type": "code", - "execution_count": 53, + "execution_count": 56, "metadata": { "id": "WJp-39zmLgFO", "colab": { "base_uri": "https://localhost:8080/" }, - "outputId": "2cec771a-277f-4e06-adf4-2203fa744086" + "outputId": "d1c8579c-5c15-4b28-b89b-c3abd6b2c4a9" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ - "--2023-08-18 01:43:01-- https://storage.googleapis.com/ztm_tf_course/food_vision/10_food_classes_all_data.zip\n", - "Resolving storage.googleapis.com (storage.googleapis.com)... 173.194.202.128, 173.194.203.128, 74.125.199.128, ...\n", - "Connecting to storage.googleapis.com (storage.googleapis.com)|173.194.202.128|:443... connected.\n", + "--2024-01-14 13:45:18-- https://storage.googleapis.com/ztm_tf_course/food_vision/10_food_classes_all_data.zip\n", + "Resolving storage.googleapis.com (storage.googleapis.com)... 142.250.4.207, 172.253.118.207, 74.125.200.207, ...\n", + "Connecting to storage.googleapis.com (storage.googleapis.com)|142.250.4.207|:443... connected.\n", "HTTP request sent, awaiting response... 200 OK\n", "Length: 519183241 (495M) [application/zip]\n", "Saving to: ‘10_food_classes_all_data.zip’\n", "\n", - "10_food_classes_all 100%[===================>] 495.13M 148MB/s in 3.5s \n", + "10_food_classes_all 100%[===================>] 495.13M 23.3MB/s in 22s \n", "\n", - "2023-08-18 01:43:04 (143 MB/s) - ‘10_food_classes_all_data.zip’ saved [519183241/519183241]\n", + "2024-01-14 13:45:41 (22.3 MB/s) - ‘10_food_classes_all_data.zip’ saved [519183241/519183241]\n", "\n" ] } @@ -4731,13 +4778,13 @@ }, { "cell_type": "code", - "execution_count": 54, + "execution_count": 57, "metadata": { "id": "XUhaT5repEp0", "colab": { "base_uri": "https://localhost:8080/" }, - "outputId": "bdfedbcb-5b9c-4815-8bc5-9e9b312c3993" + "outputId": "3186014a-e90d-45a1-e307-4c9a9babf337" }, "outputs": [ { @@ -4746,27 +4793,27 @@ "text": [ "There are 2 directories and 0 images in '10_food_classes_all_data'.\n", "There are 10 directories and 0 images in '10_food_classes_all_data/train'.\n", - "There are 0 directories and 750 images in '10_food_classes_all_data/train/ramen'.\n", + "There are 0 directories and 750 images in '10_food_classes_all_data/train/chicken_wings'.\n", "There are 0 directories and 750 images in '10_food_classes_all_data/train/chicken_curry'.\n", + "There are 0 directories and 750 images in '10_food_classes_all_data/train/fried_rice'.\n", + "There are 0 directories and 750 images in '10_food_classes_all_data/train/sushi'.\n", + "There are 0 directories and 750 images in '10_food_classes_all_data/train/hamburger'.\n", "There are 0 directories and 750 images in '10_food_classes_all_data/train/pizza'.\n", + "There are 0 directories and 750 images in '10_food_classes_all_data/train/ramen'.\n", "There are 0 directories and 750 images in '10_food_classes_all_data/train/ice_cream'.\n", - "There are 0 directories and 750 images in '10_food_classes_all_data/train/grilled_salmon'.\n", "There are 0 directories and 750 images in '10_food_classes_all_data/train/steak'.\n", - "There are 0 directories and 750 images in '10_food_classes_all_data/train/chicken_wings'.\n", - "There are 0 directories and 750 images in '10_food_classes_all_data/train/hamburger'.\n", - "There are 0 directories and 750 images in '10_food_classes_all_data/train/sushi'.\n", - "There are 0 directories and 750 images in '10_food_classes_all_data/train/fried_rice'.\n", + "There are 0 directories and 750 images in '10_food_classes_all_data/train/grilled_salmon'.\n", "There are 10 directories and 0 images in '10_food_classes_all_data/test'.\n", - "There are 0 directories and 250 images in '10_food_classes_all_data/test/ramen'.\n", + "There are 0 directories and 250 images in '10_food_classes_all_data/test/chicken_wings'.\n", "There are 0 directories and 250 images in '10_food_classes_all_data/test/chicken_curry'.\n", + "There are 0 directories and 250 images in '10_food_classes_all_data/test/fried_rice'.\n", + "There are 0 directories and 250 images in '10_food_classes_all_data/test/sushi'.\n", + "There are 0 directories and 250 images in '10_food_classes_all_data/test/hamburger'.\n", "There are 0 directories and 250 images in '10_food_classes_all_data/test/pizza'.\n", + "There are 0 directories and 250 images in '10_food_classes_all_data/test/ramen'.\n", "There are 0 directories and 250 images in '10_food_classes_all_data/test/ice_cream'.\n", - "There are 0 directories and 250 images in '10_food_classes_all_data/test/grilled_salmon'.\n", "There are 0 directories and 250 images in '10_food_classes_all_data/test/steak'.\n", - "There are 0 directories and 250 images in '10_food_classes_all_data/test/chicken_wings'.\n", - "There are 0 directories and 250 images in '10_food_classes_all_data/test/hamburger'.\n", - "There are 0 directories and 250 images in '10_food_classes_all_data/test/sushi'.\n", - "There are 0 directories and 250 images in '10_food_classes_all_data/test/fried_rice'.\n" + "There are 0 directories and 250 images in '10_food_classes_all_data/test/grilled_salmon'.\n" ] } ], @@ -4786,13 +4833,13 @@ }, { "cell_type": "code", - "execution_count": 55, + "execution_count": 58, "metadata": { "id": "s-bF8cAKLzVt", "colab": { "base_uri": "https://localhost:8080/" }, - "outputId": "b10d37f6-10d6-4c79-e461-88f625c28248" + "outputId": "f2d60b66-51a8-4898-8353-ed7d7f332f6f" }, "outputs": [ { @@ -4835,31 +4882,31 @@ }, { "cell_type": "code", - "execution_count": 56, + "execution_count": 59, "metadata": { "id": "pjrkv4n-428G", "colab": { "base_uri": "https://localhost:8080/" }, - "outputId": "6f50621a-b084-4525-f612-9a9f0462fb36" + "outputId": "9d27391f-826f-419a-a7e2-7245efa6e38b" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ - "79/79 [==============================] - 3s 39ms/step - loss: 0.4526 - accuracy: 0.8504\n" + "79/79 [==============================] - 5s 61ms/step - loss: 0.4296 - accuracy: 0.8620\n" ] }, { "output_type": "execute_result", "data": { "text/plain": [ - "[0.452595591545105, 0.8503999710083008]" + "[0.42959845066070557, 0.8619999885559082]" ] }, "metadata": {}, - "execution_count": 56 + "execution_count": 59 } ], "source": [ @@ -4878,24 +4925,24 @@ }, { "cell_type": "code", - "execution_count": 57, + "execution_count": 60, "metadata": { "id": "1D0wLFb01kaJ", "colab": { "base_uri": "https://localhost:8080/" }, - "outputId": "d319b180-11e8-4ea6-eb39-9274d2c1162b" + "outputId": "a02d76fe-0f95-490e-bfc2-3e1505790ba4" }, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ - "[0.4525955617427826, 0.8503999710083008]" + "[0.42959845066070557, 0.8619999885559082]" ] }, "metadata": {}, - "execution_count": 57 + "execution_count": 60 } ], "source": [ @@ -4930,7 +4977,7 @@ "metadata": { "id": "biBCH4TrEHgO" }, - "execution_count": 58, + "execution_count": 61, "outputs": [] }, { @@ -4953,19 +5000,19 @@ "base_uri": "https://localhost:8080/" }, "id": "L-6k_UsJSz-Z", - "outputId": "276de1dc-c340-41c9-dbb4-2553130ba98e" + "outputId": "c019c9da-bb82-4e39-edd9-2f00890648c2" }, - "execution_count": 59, + "execution_count": 62, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ - "" + "" ] }, "metadata": {}, - "execution_count": 59 + "execution_count": 62 } ] }, @@ -4980,13 +5027,13 @@ }, { "cell_type": "code", - "execution_count": 60, + "execution_count": 63, "metadata": { "id": "L8dRowENskBy", "colab": { "base_uri": "https://localhost:8080/" }, - "outputId": "c040615e-94ed-4f19-e1a5-07ff6a81fb9a" + "outputId": "da790b16-485d-434d-c8b0-be3b84ee2347" }, "outputs": [ { @@ -4999,21 +5046,22 @@ "=================================================================\n", " input_layer (InputLayer) [(None, 224, 224, 3)] 0 \n", " \n", - " data_augmentation (Sequenti (None, None, None, 3) 0 \n", - " al) \n", + " data_augmentation (Sequent (None, None, None, 3) 0 \n", + " ial) \n", " \n", - " efficientnetv2-b0 (Function (None, None, None, 1280) 5919312 \n", - " al) \n", + " efficientnetv2-b0 (Functio (None, None, None, 1280 5919312 \n", + " nal) ) \n", " \n", - " global_average_pooling_laye (None, 1280) 0 \n", - " r (GlobalAveragePooling2D) \n", + " global_average_pooling_lay (None, 1280) 0 \n", + " er (GlobalAveragePooling2D \n", + " ) \n", " \n", " output_layer (Dense) (None, 10) 12810 \n", " \n", "=================================================================\n", - "Total params: 5,932,122\n", - "Trainable params: 12,810\n", - "Non-trainable params: 5,919,312\n", + "Total params: 5932122 (22.63 MB)\n", + "Trainable params: 12810 (50.04 KB)\n", + "Non-trainable params: 5919312 (22.58 MB)\n", "_________________________________________________________________\n" ] } @@ -5032,9 +5080,9 @@ "base_uri": "https://localhost:8080/" }, "id": "lMbRVUbqYv3M", - "outputId": "564b16fb-c4a2-4c3b-e32e-e7fee6a1c215" + "outputId": "972d7301-04b4-4bec-f6fb-db5c30c904ae" }, - "execution_count": 61, + "execution_count": 64, "outputs": [ { "output_type": "stream", @@ -5058,31 +5106,31 @@ }, { "cell_type": "code", - "execution_count": 62, + "execution_count": 65, "metadata": { "id": "wET1oWQC0yc2", "colab": { "base_uri": "https://localhost:8080/" }, - "outputId": "8c85f720-9d70-4597-e252-0891fff035cd" + "outputId": "5f7ebf80-9936-4da4-ccc1-6fa79e7e7984" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ - "79/79 [==============================] - 6s 33ms/step - loss: 0.6795 - accuracy: 0.8216\n" + "79/79 [==============================] - 9s 76ms/step - loss: 0.6417 - accuracy: 0.8416\n" ] }, { "output_type": "execute_result", "data": { "text/plain": [ - "[0.6794609427452087, 0.8216000199317932]" + "[0.6416527628898621, 0.8416000008583069]" ] }, "metadata": {}, - "execution_count": 62 + "execution_count": 65 } ], "source": [ @@ -5109,13 +5157,13 @@ }, { "cell_type": "code", - "execution_count": 63, + "execution_count": 66, "metadata": { "id": "k5MWo0Mu6WYl", "colab": { "base_uri": "https://localhost:8080/" }, - "outputId": "48f8f12b-2bf6-49b6-a568-b3d7297613bf" + "outputId": "2b968742-f714-41ff-9e13-aec0df98a933" }, "outputs": [ { @@ -5161,7 +5209,7 @@ "metadata": { "id": "srxeJzSpYx38" }, - "execution_count": 64, + "execution_count": 67, "outputs": [] }, { @@ -5177,13 +5225,13 @@ }, { "cell_type": "code", - "execution_count": 65, + "execution_count": 68, "metadata": { "id": "ojbNIiUV8oc2", "colab": { "base_uri": "https://localhost:8080/" }, - "outputId": "229fe047-36cc-4c19-a219-a05226017282" + "outputId": "bb0b197e-ce98-420d-ec6a-b2f15f7eb6b4" }, "outputs": [ { @@ -5499,7 +5547,7 @@ "metadata": { "id": "KQSBQkrMFtql" }, - "execution_count": 66, + "execution_count": 69, "outputs": [] }, { @@ -5513,32 +5561,32 @@ }, { "cell_type": "code", - "execution_count": 67, + "execution_count": 70, "metadata": { "id": "SpZS_khtJaYx", "colab": { "base_uri": "https://localhost:8080/" }, - "outputId": "bb0b54f1-8cda-4b5e-963c-10753c014058" + "outputId": "be544717-d8d2-4a6b-c1c5-388a5ab8e63e" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ - "Saving TensorBoard log files to: transfer_learning/full_10_classes_fine_tune_last_10/20230818-014323\n", + "Saving TensorBoard log files to: logs/fit/\n", "Epoch 5/10\n", - "235/235 [==============================] - 43s 144ms/step - loss: 0.7247 - accuracy: 0.7724 - val_loss: 0.3794 - val_accuracy: 0.8832\n", + "235/235 [==============================] - 131s 519ms/step - loss: 0.7082 - accuracy: 0.7764 - val_loss: 0.3545 - val_accuracy: 0.8766\n", "Epoch 6/10\n", - "235/235 [==============================] - 29s 122ms/step - loss: 0.5906 - accuracy: 0.8093 - val_loss: 0.3624 - val_accuracy: 0.8783\n", + "235/235 [==============================] - 99s 422ms/step - loss: 0.5950 - accuracy: 0.8057 - val_loss: 0.2932 - val_accuracy: 0.8980\n", "Epoch 7/10\n", - "235/235 [==============================] - 26s 108ms/step - loss: 0.5465 - accuracy: 0.8220 - val_loss: 0.3211 - val_accuracy: 0.9046\n", + "235/235 [==============================] - 89s 377ms/step - loss: 0.5392 - accuracy: 0.8280 - val_loss: 0.2815 - val_accuracy: 0.9079\n", "Epoch 8/10\n", - "235/235 [==============================] - 24s 102ms/step - loss: 0.5178 - accuracy: 0.8332 - val_loss: 0.3015 - val_accuracy: 0.9095\n", + "235/235 [==============================] - 76s 318ms/step - loss: 0.4961 - accuracy: 0.8388 - val_loss: 0.2630 - val_accuracy: 0.9112\n", "Epoch 9/10\n", - "235/235 [==============================] - 21s 89ms/step - loss: 0.4782 - accuracy: 0.8425 - val_loss: 0.2541 - val_accuracy: 0.9227\n", + "235/235 [==============================] - 67s 282ms/step - loss: 0.4667 - accuracy: 0.8493 - val_loss: 0.2726 - val_accuracy: 0.9046\n", "Epoch 10/10\n", - "235/235 [==============================] - 19s 81ms/step - loss: 0.4562 - accuracy: 0.8501 - val_loss: 0.2632 - val_accuracy: 0.9227\n" + "235/235 [==============================] - 63s 266ms/step - loss: 0.4442 - accuracy: 0.8551 - val_loss: 0.2686 - val_accuracy: 0.9013\n" ] } ], @@ -5551,7 +5599,7 @@ " initial_epoch=history_10_percent_data_aug.epoch[-1],\n", " validation_data=test_data,\n", " validation_steps=int(0.25 * len(test_data)),\n", - " callbacks=[create_tensorboard_callback(\"transfer_learning\", \"full_10_classes_fine_tune_last_10\")])" + " callbacks=[create_tensorboard_callback(\"full_10_classes_fine_tune_last_10\")])" ] }, { @@ -5567,31 +5615,31 @@ }, { "cell_type": "code", - "execution_count": 68, + "execution_count": 71, "metadata": { "id": "zHEcLE3tRTlB", "colab": { "base_uri": "https://localhost:8080/" }, - "outputId": "7f9a7b9e-9688-461d-f310-7d9c1119a019" + "outputId": "6adf5d6d-85fa-4ceb-e0ae-0f04e063a67f" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ - "79/79 [==============================] - 3s 35ms/step - loss: 0.2658 - accuracy: 0.9156\n" + "79/79 [==============================] - 5s 60ms/step - loss: 0.2641 - accuracy: 0.9156\n" ] }, { "output_type": "execute_result", "data": { "text/plain": [ - "[0.2658187747001648, 0.9156000018119812]" + "[0.26409539580345154, 0.9156000018119812]" ] }, "metadata": {}, - "execution_count": 68 + "execution_count": 71 } ], "source": [ @@ -5609,19 +5657,19 @@ "base_uri": "https://localhost:8080/" }, "id": "vSqte3X-aFAI", - "outputId": "e8bb98e0-62e5-46eb-f2a4-7bb25a1d65f7" + "outputId": "545a2dfd-2bf0-4785-8414-6b89950503c1" }, - "execution_count": 69, + "execution_count": 72, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ - "[0.4525955617427826, 0.8503999710083008]" + "[0.42959845066070557, 0.8619999885559082]" ] }, "metadata": {}, - "execution_count": 69 + "execution_count": 72 } ] }, @@ -5636,14 +5684,14 @@ }, { "cell_type": "code", - "execution_count": 70, + "execution_count": 73, "metadata": { "id": "QwxgAW_l5Meg", "colab": { "base_uri": "https://localhost:8080/", - "height": 791 + "height": 790 }, - "outputId": "e4b9c8a4-4aff-4712-8b24-34a6b62ccd03" + "outputId": "395f17e1-d6c3-4b44-a983-c1566c7847b2" }, "outputs": [ { @@ -5652,7 +5700,7 @@ "text": [ "5\n", "11\n", - "[0.335999995470047, 0.6413333415985107, 0.7253333330154419, 0.7706666588783264, 0.7839999794960022, 0.7724000215530396, 0.809333324432373, 0.8220000267028809, 0.8331999778747559, 0.8425333499908447, 0.8501333594322205]\n" + "[0.3413333296775818, 0.6453333497047424, 0.7493333220481873, 0.7706666588783264, 0.7960000038146973, 0.7764000296592712, 0.805733323097229, 0.828000009059906, 0.8388000130653381, 0.8493333458900452, 0.8550666570663452]\n" ] }, { @@ -5661,7 +5709,7 @@ "text/plain": [ "
" ], - "image/png": "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\n" + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAqgAAAK9CAYAAADoo550AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAADmWElEQVR4nOzdeXhM1/8H8Pdkkkwy2feFkEhSYguCVNRaGlu+oqp2CaWt0lL0hyKWqrSoKkpUbS1BKUqtkdLaiiJK7URiSUKQfZ+5vz8muTJZZJFkJsn79TzzJHPn3Hs/M5m2755z7rkSQRAEEBERERFpCR1NF0BERERElB8DKhERERFpFQZUIiIiItIqDKhEREREpFUYUImIiIhIqzCgEhEREZFWYUAlIiIiIq3CgEpEREREWoUBlYiIiIi0CgMqUS0RGBgIZ2fncu07Z84cSCSSii1Iy9y7dw8SiQQbNmyo8nNLJBLMmTNHfL5hwwZIJBLcu3evxH2dnZ0RGBhYofW8yneFiKgiMKASaZhEIinV49ixY5outdb75JNPIJFIcPv27WLbzJgxAxKJBP/++28VVlZ2jx49wpw5cxAREaHpUop07do1SCQSGBgYICEhQdPlEFEVY0Al0rCff/5Z7dG9e/cit3t4eLzSedasWYMbN26Ua9+ZM2ciPT39lc5fEwwdOhQAEBoaWmybLVu2oFmzZmjevHm5zzN8+HCkp6ejfv365T5GSR49eoS5c+cWGVBf5btSUTZt2gR7e3sAwI4dOzRaCxFVPV1NF0BU2w0bNkzt+d9//42wsLBC2wtKS0uDXC4v9Xn09PTKVR8A6OrqQleX/7rw9vaGm5sbtmzZgqCgoEKvnz59GpGRkfjqq69e6TxSqRRSqfSVjvEqXuW7UhEEQUBoaCiGDBmCyMhIbN68GaNHj9ZoTcVJTU2FkZGRpssgqnHYg0pUDXTu3BlNmzbF+fPn0bFjR8jlcnz++ecAgN9++w29e/eGo6MjZDIZXF1d8cUXX0ChUKgdo+C8wrw5l4sXL8YPP/wAV1dXyGQytGnTBufOnVPbt6g5qBKJBOPHj8fu3bvRtGlTyGQyNGnSBAcPHixU/7Fjx9C6dWsYGBjA1dUVq1evLvW81uPHj2PAgAGoV68eZDIZnJyc8Omnnxbq0Q0MDISxsTEePnwIf39/GBsbw8bGBlOmTCn0WSQkJCAwMBBmZmYwNzdHQEBAqYeRhw4diuvXr+PChQuFXgsNDYVEIsHgwYORlZWFoKAgeHl5wczMDEZGRujQoQOOHj1a4jmKmoMqCALmz5+PunXrQi6Xo0uXLvjvv/8K7fvs2TNMmTIFzZo1g7GxMUxNTdGzZ09cunRJbHPs2DG0adMGADBy5EhxGkne/Nui5qCmpqZi8uTJcHJygkwmQ8OGDbF48WIIgqDWrizfi+KcPHkS9+7dw6BBgzBo0CD89ddfePDgQaF2SqUS3333HZo1awYDAwPY2NigR48e+Oeff9Tabdq0CW3btoVcLoeFhQU6duyIw4cPq9Wcfw5wnoLze/P+Ln/++Sc++ugj2Nraom7dugCAqKgofPTRR2jYsCEMDQ1hZWWFAQMGFDmPOCEhAZ9++imcnZ0hk8lQt25djBgxAvHx8UhJSYGRkREmTJhQaL8HDx5AKpUiODi4lJ8kUfXFLhGiauLp06fo2bMnBg0ahGHDhsHOzg6A6j+axsbGmDRpEoyNjfHHH38gKCgISUlJWLRoUYnHDQ0NRXJyMj744ANIJBIsXLgQb7/9Nu7evVtiT9qJEyewc+dOfPTRRzAxMcGyZcvQv39/REdHw8rKCgBw8eJF9OjRAw4ODpg7dy4UCgXmzZsHGxubUr3v7du3Iy0tDWPHjoWVlRXOnj2L5cuX48GDB9i+fbtaW4VCAV9fX3h7e2Px4sU4cuQIvvnmG7i6umLs2LEAVEGvb9++OHHiBD788EN4eHhg165dCAgIKFU9Q4cOxdy5cxEaGopWrVqpnfuXX35Bhw4dUK9ePcTHx+PHH3/E4MGDMWbMGCQnJ2Pt2rXw9fXF2bNn0aJFi1KdL09QUBDmz5+PXr16oVevXrhw4QLeeustZGVlqbW7e/cudu/ejQEDBsDFxQVxcXFYvXo1OnXqhKtXr8LR0REeHh6YN28egoKC8P7776NDhw4AAB8fnyLPLQgC/ve//+Ho0aN477330KJFCxw6dAifffYZHj58iG+//VatfWm+Fy+zefNmuLq6ok2bNmjatCnkcjm2bNmCzz77TK3de++9hw0bNqBnz54YPXo0cnJycPz4cfz9999o3bo1AGDu3LmYM2cOfHx8MG/ePOjr6+PMmTP4448/8NZbb5X688/vo48+go2NDYKCgpCamgoAOHfuHE6dOoVBgwahbt26uHfvHlatWoXOnTvj6tWr4mhHSkoKOnTogGvXrmHUqFFo1aoV4uPjsWfPHjx48AAtWrRAv379sG3bNixZskStJ33Lli0QBEGcakJUowlEpFXGjRsnFPxHs1OnTgIAISQkpFD7tLS0Qts++OADQS6XCxkZGeK2gIAAoX79+uLzyMhIAYBgZWUlPHv2TNz+22+/CQCEvXv3ittmz55dqCYAgr6+vnD79m1x26VLlwQAwvLly8Vtfn5+glwuFx4+fChuu3XrlqCrq1vomEUp6v0FBwcLEolEiIqKUnt/AIR58+aptW3ZsqXg5eUlPt+9e7cAQFi4cKG4LScnR+jQoYMAQFi/fn2JNbVp00aoW7euoFAoxG0HDx4UAAirV68Wj5mZmam23/PnzwU7Ozth1KhRatsBCLNnzxafr1+/XgAgREZGCoIgCI8fPxb09fWF3r17C0qlUmz3+eefCwCEgIAAcVtGRoZaXYKg+lvLZDK1z+bcuXPFvt+C35W8z2z+/Plq7d555x1BIpGofQdK+70oTlZWlmBlZSXMmDFD3DZkyBDB09NTrd0ff/whABA++eSTQsfI+4xu3bol6OjoCP369Sv0meT/HAt+/nnq16+v9tnm/V3eeOMNIScnR61tUd/T06dPCwCEn376SdwWFBQkABB27txZbN2HDh0SAAgHDhxQe7158+ZCp06dCu1HVBNxiJ+ompDJZBg5cmSh7YaGhuLvycnJiI+PR4cOHZCWlobr16+XeNyBAwfCwsJCfJ7Xm3b37t0S9+3WrRtcXV3F582bN4epqam4r0KhwJEjR+Dv7w9HR0exnZubG3r27Fni8QH195eamor4+Hj4+PhAEARcvHixUPsPP/xQ7XmHDh3U3sv+/fuhq6sr9qgCqjmfH3/8canqAVTzhh88eIC//vpL3BYaGgp9fX0MGDBAPKa+vj4A1VD0s2fPkJOTg9atWxc5PeBljhw5gqysLHz88cdq0yImTpxYqK1MJoOOjupf7QqFAk+fPoWxsTEaNmxY5vPm2b9/P6RSKT755BO17ZMnT4YgCDhw4IDa9pK+Fy9z4MABPH36FIMHDxa3DR48GJcuXVKb0vDrr79CIpFg9uzZhY6R9xnt3r0bSqUSQUFB4mdSsE15jBkzptAc4fzf0+zsbDx9+hRubm4wNzdX+9x//fVXeHp6ol+/fsXW3a1bNzg6OmLz5s3ia1euXMG///5b4tx0opqCAZWomqhTp44YePL777//0K9fP5iZmcHU1BQ2Njbif8QSExNLPG69evXUnueF1efPn5d537z98/Z9/Pgx0tPT4ebmVqhdUduKEh0djcDAQFhaWorzSjt16gSg8PvLm4dYXD2Aaq6gg4MDjI2N1do1bNiwVPUAwKBBgyCVSsWr+TMyMrBr1y707NlTLexv3LgRzZs3h4GBAaysrGBjY4N9+/aV6u+SX1RUFADA3d1dbbuNjY3a+QBVGP7222/h7u4OmUwGa2tr2NjY4N9//y3zefOf39HRESYmJmrb81aWyKsvT0nfi5fZtGkTXFxcIJPJcPv2bdy+fRuurq6Qy+Vqge3OnTtwdHSEpaVlsce6c+cOdHR00Lhx4xLPWxYuLi6FtqWnpyMoKEico5v3uSckJKh97nfu3EHTpk1fenwdHR0MHToUu3fvRlpaGgDVtAcDAwPxf4CIajoGVKJqIn8PTZ6EhAR06tQJly5dwrx587B3716EhYXh66+/BqAKKyUp7mpxocDFLxW9b2koFAp0794d+/btw9SpU7F7926EhYWJF/MUfH9VdeW7ra0tunfvjl9//RXZ2dnYu3cvkpOT1eYGbtq0CYGBgXB1dcXatWtx8OBBhIWFoWvXrqX6u5TXggULMGnSJHTs2BGbNm3CoUOHEBYWhiZNmlTqefMr7/ciKSkJe/fuRWRkJNzd3cVH48aNkZaWhtDQ0Ar7bpVGwYvr8hT1z+LHH3+ML7/8Eu+++y5++eUXHD58GGFhYbCysirX5z5ixAikpKRg9+7d4qoGffr0gZmZWZmPRVQd8SIpomrs2LFjePr0KXbu3ImOHTuK2yMjIzVY1Qu2trYwMDAocmH7ly12n+fy5cu4efMmNm7ciBEjRojbw8LCyl1T/fr1ER4ejpSUFLVe1LKu+zl06FAcPHgQBw4cQGhoKExNTeHn5ye+vmPHDjRo0AA7d+5UG04uaki6NDUDwK1bt9CgQQNx+5MnTwr1Su7YsQNdunTB2rVr1bYnJCTA2tpafF6WIe769evjyJEjSE5OVutFzZtCUlHrte7cuRMZGRlYtWqVWq2A6u8zc+ZMnDx5Em+88QZcXV1x6NAhPHv2rNheVFdXVyiVSly9evWlF6VZWFgUWsUhKysLMTExpa59x44dCAgIwDfffCNuy8jIKHRcV1dXXLlypcTjNW3aFC1btsTmzZtRt25dREdHY/ny5aWuh6i6Yw8qUTWW11OVv1cpKysLK1eu1FRJaqRSKbp164bdu3fj0aNH4vbbt28XmrdY3P6A+vsTBAHfffdduWvq1asXcnJysGrVKnGbQqEo83/8/f39IZfLsXLlShw4cABvv/02DAwMXlr7mTNncPr06TLX3K1bN+jp6WH58uVqx1u6dGmhtlKptFAv4/bt2/Hw4UO1bXlrd5Zmea1evXpBoVBgxYoVatu//fZbSCSSUs8nLsmmTZvQoEEDfPjhh3jnnXfUHlOmTIGxsbE4zN+/f38IgoC5c+cWOk7e+/f394eOjg7mzZtXqBcz/2fk6uqqNp8YAH744Ydie1CLUtTnvnz58kLH6N+/Py5duoRdu3YVW3ee4cOH4/Dhw1i6dCmsrKwq7HMmqg7Yg0pUjfn4+MDCwgIBAQHibTh//vnnKh0GLcmcOXNw+PBhtG/fHmPHjhWDTtOmTUu8zWajRo3g6uqKKVOm4OHDhzA1NcWvv/5aqrmMxfHz80P79u0xbdo03Lt3D40bN8bOnTvLPD/T2NgY/v7+4jzUgkv/9OnTBzt37kS/fv3Qu3dvREZGIiQkBI0bN0ZKSkqZzpW3nmtwcDD69OmDXr164eLFizhw4EChnsY+ffpg3rx5GDlyJHx8fHD58mVs3rxZrecVUIUyc3NzhISEwMTEBEZGRvD29i5yfqWfnx+6dOmCGTNm4N69e/D09MThw4fx22+/YeLEiWoXRJXXo0ePcPTo0UIXYuWRyWTw9fXF9u3bsWzZMnTp0gXDhw/HsmXLcOvWLfTo0QNKpRLHjx9Hly5dMH78eLi5uWHGjBn44osv0KFDB7z99tuQyWQ4d+4cHB0dxfVER48ejQ8//BD9+/dH9+7dcenSJRw6dKjQZ/syffr0wc8//wwzMzM0btwYp0+fxpEjRwotq/XZZ59hx44dGDBgAEaNGgUvLy88e/YMe/bsQUhICDw9PcW2Q4YMwf/93/9h165dGDt2rMZvoEBUldiDSlSNWVlZ4ffff4eDgwNmzpyJxYsXo3v37li4cKGmSxN5eXnhwIEDsLCwwKxZs7B27VrMmzcPb775plqPY1H09PSwd+9etGjRAsHBwZg7dy7c3d3x008/lbseHR0d7NmzB0OHDsWmTZswY8YM1KlTBxs3bizzsfJCqYODA7p27ar2WmBgIBYsWIBLly7hk08+waFDh7Bp0yZxfc6ymj9/PubOnYuLFy/is88+w507d3D48OFCdzH6/PPPMXnyZBw6dAgTJkzAhQsXsG/fPjg5Oam109PTw8aNGyGVSvHhhx9i8ODB+PPPP4s8d95nNnHiRPz++++YOHEirl69ikWLFmHJkiXlej8Fbd26FUqlUm2aREF+fn54+vSp2Pu+fv16LFq0CJGRkfjss8+wYMECpKenq63nOm/ePKxbtw7p6emYMWMGgoKCEBUVhTfffFNsM2bMGEydOhV//fUXJk+ejMjISISFhZXpDlHfffcdRowYgc2bN2Py5MmIiYnBkSNHCl2MZ2xsjOPHj2Ps2LHYv38/PvnkE6xcuRINGzYUF/3PY2dnJ67VOnz48FLXQlQTSARt6moholrD398f//33H27duqXpUoi0Vr9+/XD58uVSzdkmqknYg0pEla7gbUlv3bqF/fv3o3PnzpopiKgaiImJwb59+9h7SrUSe1CJqNI5ODggMDAQDRo0QFRUFFatWoXMzExcvHix0NqeRLVdZGQkTp48iR9//BHnzp3DnTt3YG9vr+myiKoUL5IiokrXo0cPbNmyBbGxsZDJZGjXrh0WLFjAcEpUhD///BMjR45EvXr1sHHjRoZTqpXYg0pEREREWoVzUImIiIhIqzCgEhEREZFWqRFzUJVKJR49egQTE5My3b6PiIiIiKqGIAhITk6Go6MjdHRe3kdaIwLqo0ePCi1CTURERETa5/79+4VuTFFQjQioJiYmAFRv2NTUVMPVEBEREVFBSUlJcHJyEnPby9SIgJo3rG9qasqASkRERKTFSjMdkxdJEREREZFWYUAlIiIiIq3CgEpEREREWoUBlYiIiIi0CgMqEREREWkVBlQiIiIi0ioMqERERESkVWrEOqhEVLsIgoD0nHQAgKGuIW9xTERUw7AHlYiqnfScdHiHesM71FsMqkREVHMwoBIRERGRVmFAJSIiIiKtwoBKRERERFqFAZWIiIiItAoDKhERERFpFQZUIiIiItIqDKhEREREpFUYUImIiIhIqzCgEhEREZFWYUAlIiIiIq3CgEpERERlJwiAIlv1k6iC6Wq6ACIiIspHqQSU2YAiSxUAFVnF/56TWXKbQr+XpW128edQZqvq1dEF9I0AfePcn/l/L/gz3+uyol7L/V3XAJBINPt3II1iQCUiIiorpQLISATSnxf9SHum+pmZXETwKyE4KnM0/e7KRpmj+iwyEivumBJp0aE2/3OZSfGv6RsXDsd6hgy91UilBdTvv/8eixYtQmxsLDw9PbF8+XK0bdu2yLbZ2dkIDg7Gxo0b8fDhQzRs2BBff/01evToUVnlERERvQiaeYFS7VHEtrx2GYkAqmhoWyIFpPq5D70CP/P9rit7+eul/r0MbXWkQE4GkJUKZKWofmamvPhdfOR/nlz8a9lpqvcsKIDMRNWj4j7IF2G1yN7bgj2+ecHWoJSfiayIz4czKcurUgLqtm3bMGnSJISEhMDb2xtLly6Fr68vbty4AVtb20LtZ86ciU2bNmHNmjVo1KgRDh06hH79+uHUqVNo2bJlZZRIREQ1iSIHyEgoPlAWFzxftddP3wSQWwCGBR+Wqp8ykwLBsZTBJn/Q1JFWyEdULSgVLwm2Kfl+viwAp+SG5LzQm5p7cCE3HCcDKVX0fl72PxfFfi/K8l0p4X8iSvzu5fsfDS0jEYSKn93s7e2NNm3aYMWKFQAApVIJJycnfPzxx5g2bVqh9o6OjpgxYwbGjRsnbuvfvz8MDQ2xadOmEs+XlJQEMzMzJCYmwtTUtOLeCBFppbTsNHiHegMAzgw5A7meXMMVUYVRZAPpCaXvyUx/rmr/qj1tMtMiQqYFILcsPnwamqv+I0/aTalU9cwWCrnFBeD8vcApBebgZgOKzOKnalS36Rl5+q8Fmr1T6acpS16r8B7UrKwsnD9/HtOnTxe36ejooFu3bjh9+nSR+2RmZsLAwEBtm6GhIU6cOFFs+8zMTPF5UlJSBVRORESVKjsdeHoHeHoLiL8FPL0NpMQVCJqv+O9zA7OXBMpigqeBGYNmTaajoxrSlxkDsKvccxV3gVtOWS9OK6p9WS6YK6Ft3gVueaT6lfu5lEOFB9T4+HgoFArY2al/Cezs7HD9+vUi9/H19cWSJUvQsWNHuLq6Ijw8HDt37oRCoSiyfXBwMObOnVvRpRMR0asSBCA5NjeE3gTib6t+Pr0FJNxH6eZtSooOmi/tzcwLmrz2lzRIRwfQkamG1rVZ3hJhitxQq4WjUFrxT/J3332HMWPGoFGjRpBIJHB1dcXIkSOxbt26IttPnz4dkyZNEp8nJSXBycmpqsolIqLsDODZncIhNP62ao5fcQzMAWt3wPo1wMoNMK1TOHgamGnlnDiiGkMiAXT1VQ8tVeEB1draGlKpFHFxcWrb4+LiYG9vX+Q+NjY22L17NzIyMvD06VM4Ojpi2rRpaNCgQZHtZTIZZDIt/78TIqLqThBUQ/DxN18Myef9nhCNYntDJVLAov6LEGr92otQKrfiUj9EVKIKD6j6+vrw8vJCeHg4/P39AagukgoPD8f48eNfuq+BgQHq1KmD7Oxs/Prrr3j33XcrujwiIipI7A299WJ+aF4gfdmcUAOz3BDqnhtAc0OohYtW98wQkfarlCH+SZMmISAgAK1bt0bbtm2xdOlSpKamYuTIkQCAESNGoE6dOggODgYAnDlzBg8fPkSLFi3w8OFDzJkzB0qlEv/3f/9XGeUREdU+Ym9ogRAaf7OE3lAdwMJZPYRa5QZRI2v2hhJRpaiUgDpw4EA8efIEQUFBiI2NRYsWLXDw4EHxwqno6Gjo5Fu8NiMjAzNnzsTdu3dhbGyMXr164eeff4a5uXlllEdEVHNlZwDP7hZxkVIJvaEys3y9oPlCqKWL9l/wQUQ1TqWsg1rVuA4qUe1S69dBFQQg5XExV8pHA4Ky6P0kOoB5ffWLlPLmhxrZsDeUiCqVRtdBJSKiCpKTqeoNLXSR0u2XL0wvMwOs3QqHUMsG7A0lomqBAZWISNOUSiAxGoj7D4i7CsRdAR5fVQXSl/aG1st3kZLbi9+NbdkbSkTVGgMqEVFVSn+eG0L/Ax7nBtLHV1W3VCyKzDRfL2i+EGrZANAzKHofIqJqjgGViKgy5GSp5oTG/ffi8fgqkPSw6PZSfcCmIWDbBLBrAtg1Vv1uYs/eUCKqdRhQiYhehSAASY/y9Yjm9orG3yx8v+s8ZvVUAdSuCWDbGLBrCli58n7wRES5GFCJiEorMxl4fE29RzTuCpBRzAVLMtPcAJrbI2rXFLD1UC1wT0RExWJAJSIqSJGjuno+f49o3BUgIaro9hKp6ir5/D2ido0BMycOzxMRlQMDKhHVbimPC/eIPrkB5GQU3d7EITeE5vWINlbNHeXyTUREFYYBlYhqh+x04Mn1wks5pT4pur2eXDUcb9ck34VLTQC5ZdXWTURUCzGgElHNolQCCfdeLN8Ud0X1+7M7xawpKlEt2WSXL4TaNgYsXIB8t2QmIqrOlEoBGTkKpGcpkJalQEa26md6tgLutsawMtauUSAGVCKq3qJPA/F3XvSIxl0FslOLbiu3KtAj2hiwaQToG1VtzUREBSiUwovQmBsc07JykJ79IlTm/Z6enT9k5qgHznyvpxfYpzghw1qhR1OHKny3JWNAJSLtJAhAarzqDkuJD1SPhPtAYu4jb436Tf1VbfOT6quCZ/4eUbumvMMSEZVbjkJZKCAW7IlMzw2LYrssBdIK/J6RpUBadk6h1zNzirlrXCWQ6epAri+FoZ4UhvpS6Otq32gRAyoRaUZO5ovgmfjgRfAUg+gDQJFZ9L4SCeDspPrdzEm9R9SuKWDpCkj5rzciUicIAtKzFXielo3nqVl4npaFZ6lZSEjLzv2ZpXotTfXa89RsJGdkIyNbiSxF1QVIQz2pKkDmhki5vhQGatt01V431Fdv8+J33ULHMtSTQkdH+/9Hnf8GJ6KKJwiqW3qqBc77+YLoAyAlrhQHkqjupGTmBJjVVT3M66l6Qs/NVDUZd0Z1QRMR1SqCICA5MwcJqapA+SxNFTCfpWbn/lQFT7UQmpaFrFfsqdSRAHJ93ReBUU89SKqFSn0p5Hq6MNTXgaG+LuR5bfO1KRgmDfR0IOFIDwMqEZWDIlt196Tiej4THxQ/DzQ/XUPAPF/4NKuXL4g6ASaOgK5+4f2y014EVCKq9pRKAUkZql7M52nqAfNF8Mz/mupnjlIo+eBF0JfqwMJIDxZyfdUj3+/mcj1YGr343dRQT60XU6bLAFkVGFCJqLCMxOJ7PhMfAMkxxVwRX4CRTb7eT6fCYVRuyTmhRDVMjkKJhPQXQfJ5ET2bYtBMU4XQhLQslDNrwlBPCgu5HiyM8sKmPizkejCX68My//Z8QVSuL2XI1HIMqES1jVIBJMeqB8/8PZ+J94HMpJKPI9XPFzadCg/DmzoCeoaV/36IqNLkKJRITM8bJs/r4cwNmamqgPm8QK9nUkZOuc9nLNMVQ2RewDSX6+f2aL4Im/l7OQ30pBX4jklbMKASVXdKBZCVmu+RovqZmazq6czf85lwH0h+BChL8R8QQ8viez7N6qp6R7lOKFG1oT6Mntu7mS9kqoXP3IuGkjKyCy2SUVqmBrqwNNIXA6a5XA+WuT2ceb/nD5/mcn2tvJqcNIMBlagqKXJUczPzh8nMFPVgqRY0X/Ja3n456WWvQ0dX1cNZqOcz97lpHUBmXPHvn4gqRN4FQurB8uWB81WG0c0M9cQgmddz+SJ8FujllOvDzFAPulKGTSo/BlSi4ihyCgTDlCKelzFoFnd/94og0QH0TVSLzuc9TOyLHoY3sQd0OCxGpA0EQUBalqJAoCw+cOYtkVTeC4RMZLqqoXKjF3M083o2LcX5mrlB1Egf5gybpAEMqFT7PLsL3A4HHp5XDYMXFzSLW4OzIkikqh5KfePcMFnwZ77fZS95Td/oRSjVlfGCIyItkaNQ4v7zdDx4npZvvmZ2oXmbec/Lu/SRXF8q9mYWFTjzLgyyzN3GYXSqLhhQqebLTgfunQRuhwG3wlT3ZC8LHd3cQGicLywWFRhf9pqReiCV6jNMEtUAGdkK3H2SittPUnD7cQruPFb9jIxPLfPC7vq6OrDKN3yuFjgLXInOC4SopmNApZrp6R1VGL0dBtw7oT60rqML1GsHuHQEjKyL7o3MHy6LWoeTiGqVxPTsFwE0N4zefpyC+8/Tir2IyEBPB/Us5bAykuUGTj21oXTVVeovAqehHpc+IsrDgEo1Q1YacO94big9AjyPVH/dtA7g1g1w7w64dAIMTDVTJxFpLUEQ8CQ5UxU+84XQW49T8CS5+Ck/ZoZ6cLM1hpuNsepn7qOOuWG1uKUkkTZiQKXqSRCA+FuqMHo7TDWEn3/OqI4eUL8d4NZdFUptGnFInYgAAAqlgAfP08QAmj+QJr9kDU87UxncbU3gZmsM13yB1NpYnz2fRBWMAZWqj6xUIPKvF0P3CdHqr5s55esl7QjITDRTJxFphcwcBSLjU9WDaO780MxiLkrSkQD1LOWFQqirrTFMDfSq+B0Q1V4MqKS9BAF4cuPFxU3RpwFF1ovXpfpAfZ8XvaTWr7GXlKgWSs7Ixp0n6kH0zpMURD1NLXbdT31dHTSwNlIbknezNYazlREvPCLSAgyopF0yk4G7f6pC6e1w1V2Q8jOvrwqjbt0Blw6qC5mIqMYTBAHxKVnicPydfGE0Nqn49YVNZLqqntC8R26PqJOlHFLODyXSWgyopFmCADy+lq+X9G9Amf3idakMcH4jN5R2A6zc2EtKVIMplQIeJqSr5oTGqc8PTUzPLnY/GxNZoYuU3GyNYWsi4/xQomqo0gLq999/j0WLFiE2Nhaenp5Yvnw52rZtW2z7pUuXYtWqVYiOjoa1tTXeeecdBAcHw8DAoLJKJE3JSALuHnvRS5r0UP11C5cXvaTObwD6co2USUSVR6kUEPk0FTdjk9VC6N0nqUjPVhS5j0QC1LUwFIOou62JOE/UTM75oUQ1SaUE1G3btmHSpEkICQmBt7c3li5dCl9fX9y4cQO2traF2oeGhmLatGlYt24dfHx8cPPmTQQGBkIikWDJkiWVUSJVJUEA4q7kXtwUDtz/G1Dmu1JW1wBw7pCvl9RVc7USUaV4nJSBiPsJiLifgEsPEvDv/UQkZxZ9xbyeVAKXvPmhNsbiEL2rjTHnhxLVEpUSUJcsWYIxY8Zg5MiRAICQkBDs27cP69atw7Rp0wq1P3XqFNq3b48hQ4YAAJydnTF48GCcOXOmMsqjqpCeANw9mrsMVDiQHKP+upWbqofUrRvg3B7QM9RImURU8ZIzsnH5YSIu3U/EpdxAGpNYeJ6oTFcHDe1NCs0PrWcp573fiWq5Cg+oWVlZOH/+PKZPny5u09HRQbdu3XD69Oki9/Hx8cGmTZtw9uxZtG3bFnfv3sX+/fsxfPjwIttnZmYiM/PFmpdJSUkV+yao7AQBiP33xUL5988CQr5hOl1D1dJPeb2kli6aq5WIKky2Qokbscm4eD9BFUbvJ+D2k5RCd1fSkQCv2ZnAs645PJ3M4elkhtfsTKDHIEpERajwgBofHw+FQgE7Ozu17XZ2drh+/XqR+wwZMgTx8fF44403IAgCcnJy8OGHH+Lzzz8vsn1wcDDmzp1b0aVTWaU9U/WS3joC3AkHUuLUX7d+LXcJqG5APR9Aj/OJqWIo860dlJSRA04/rBqCICDqaRouPcgdqr+fgCuPkpBVxJqidcwN4elkJgbSZnXMYCTjdblEVDpa8W+LY8eOYcGCBVi5ciW8vb1x+/ZtTJgwAV988QVmzZpVqP306dMxadIk8XlSUhKcnJyqsuTaSakEYiJyh+2PAA/OAUK+/zDpGQENOgFub6qCqUV9jZVKNUdiejauxSThekwSrsUk41psEm7EPYW+m+r11xeEw8LQCPWtjOBsJVf9tFb9dLEygrlcj1dxl1N8Sib+fZCAiOgERDxIxL8PEpCQVvhKelMDXXg6maOFkzk865qjuZMZbE34P6REVH4VHlCtra0hlUoRF6femxYXFwd7e/si95k1axaGDx+O0aNHAwCaNWuG1NRUvP/++5gxYwZ0dNSHgGQyGWQyWUWXTkVJewbc+UM1dH8nHEh9ov66TaMXd2+q1w7Q5d+FykehFBD1NFUVQmOScD1WFUgfJqQXbixRQj/f0+dp2XiepurVK8jUQBfO1uoB1iU3wFoZ8RaVedKycnDlYRIu3U9AxANV7+iD54U/e32pDho7mqrCqJMZWjhZwNlKzs+RiCpUhQdUfX19eHl5ITw8HP7+/gAApVKJ8PBwjB8/vsh90tLSCoVQqVR1paZQcCITVT5BAP5ZC0RsAR6eB5Dvb6BvDDTorAqlbt0Ac/ZcU9klZWTjekxybghNwtWYZNyMTS52eaE65obwcDBFYwcTNHIwhYuNHt49pHrtn5nd8CRJwL34VNx7moaop6m49zQVUU/TEJOYgaSMHPz7IBH/PkgsdFxjmS7qW8nhbGUk/nS2VgVZmxq8fmaOQolbj1PEYfqI+wm4GZdc5F2X3GyN4VnXHC2czODpZI5G9qbQ1+W8USKqXJUyxD9p0iQEBASgdevWaNu2LZYuXYrU1FTxqv4RI0agTp06CA4OBgD4+flhyZIlaNmypTjEP2vWLPj5+YlBlapIdgaw52Pg8i8vttk2UQ3bu3cHnF4HdPWL358oH6VSQPSzNFyLUQXRa7Gq3tGieuYAwEBPBw3tTeFhbwIPB1N4OJiiob0JzAzVJ5mmZaeJv8v1pfBwkMPDwbTQ8TKyFYh+lobI+NTc4JobYOPT8CgxHSmZOfjvURL+e1T4QktDPemL8GqdG15zpw/YmRhAp5rchUgQBDx4no5LD/IuYkrE5YeJRf7PgK2JLLdn1BwtnczRtK4Z7z9PRBpRKQF14MCBePLkCYKCghAbG4sWLVrg4MGD4oVT0dHRaj2mM2fOhEQiwcyZM/Hw4UPY2NjAz88PX375ZWWUR8VJeQJsHQI8OAvo6AJdZwLN3gXM6mi6MqoGUjJzVPNEc0PotZgk3IhNRlpW0b2ijmYGYght5KAKpM5WRhV6+0kDPSleszPBa3YmhV7LzFHg/rM03ItPE3tc834+eJ6G9GwFrscm43pscqF9Zbo6qJ8331WcNqDqhXUwM9ToLTQT0rJye0YTxVD6NDWrUDtjmS6a11X1iqp6SM1hb8Z5o0SkHSRCDRhDT0pKgpmZGRITE2FqWrgXhUoh7ioQOhBIjAYMzIB3f1IN5RMVoFSqeuSu5obQvLmi0c/Simyvr6uDhnYm8HB40SvayN4E5vLy98SnZafBO9QbAHBmyBnI9Sr2bmNZOUo8eJ6mFlrzft5/loacosbCc+lLdeBkaZg7beDFfFdnKyM4mhtU6PqeGdkK/PcoSVxr9NL9BNx7WvjvoKsjgYeDqXhVfct65mhgbVxteoGJqGYoS17Tiqv4ScNuHgZ2jAKykgFLV2DINsDaXdNVkRZIzczJ7UXMHaKPScaN2GSkFHMHIHtTA3jkzhPNmzPqbGVU7RZd19fVQQMbYzSwMS70WrZCiUcJ6WrTBaKepiLyaSruP0tDlkKJO09ScedJaqF9dXUkcLKUv5jvaiVHfWtVeK1rYfjSNUEVSgF3n6S8WG/0QQKuxyQXGZZdrI3gmdc76mSOxg6mvAMTEVUrDKi1mSAAf68CDs9QLRfl3EHVcyq31HRlVMXy5inmhdC8QBr1LK3QguuAqpfQ3c5Y7BH1cDCBh70pLIxq/vxkPakO6uf2jgI2aq8plAIeJaTn63FNRWRugI16loasHCUi41MRGZ8KQH1FDKmOBHXMDdUu1rIy0sf12GRcup+Ayw8Ti/wfA2tjfXGI3tPJHM3rmr1S7zQRkTZgQK2tFNnA/s+A8+tVz1uNAHp9wwugaoG0rBzcyJ1bmTdX9HpMcrH3Rbc1kYnzRBvnBlIXayPeAagI0tweUidLOd5wt1Z7TakUEJuUoTZl4F78i98zspWIfpaG6GdpOH4rvsjjG+pJ0ayumbjeqKeTGeqYG9bY1QaIqPZiQK2N0p8DvwQAkX8CkABvzQfajQP4H7kaRRAEPErMwLVHeXNFVYE08mlqkb2ielIJ3GxVc0UbO5iikb2qZ9TKmGvbVgQdHQkczQ3haG4IH1f11wRBwOPkTDGwRub2vj5JzoSbrbHYO+pmY1ztpksQEZUHA2pt8/QOEPou8PS2ak3T/j8CDXtquip6BZk5CkQ9TcOdxym4G5+KO09ScOdJKu4+SUFyRtG9otbGsnwXLal+utoYs1dUQyQSCexMDWBnagDvBlaaLoeISOMYUGuTyOPAtmFARgJg5gQM3grYN9V0VVQKgiDgSUom7j5RBdC7uQH0zpNUPHieVuQC64Dqohw3W2MxiKp6RU1hY8JeUSIi0l4MqLXF+Y3AvkmAMgeo0xoYFAqY2Gm6KiogI1vVG6oKn6ogeic+FXcfpxQ7RxQATGS6aGBjBFcbYzSwMcq9Al21NqdMl1dvExFR9cKAWtMpFUBYEHB6hep503eAvisAPUPN1lWL5fWG3nmcirvxKeLPuyX0hupIgLoWcvUgam0MV1sj2BjX3NtyEhFR7cOAWpNlJgO/jgZuHlQ97/w50On/eDFUFcnrDVX1hKaoDc+/tDfUQBcNbIzham0EV1tjNLBW9YjWt5JzLUsiIqoVGFBrqoT7wJZBQNwVQNcA8F8JNO2v6apqHEEQ8CQ5M3dh9ty5ofGq4fkHz9OLvFoeUPWGOlnKxfD5YmievaFEREQMqDXRg3+ALYOB1MeAkS0weAtQt7Wmq6rWMrIVuPc0VdULmnu1/N2y9IbmDcvn9orWt5JzbigREVExGFBrmss7gN0fAYpMwK6ZKpyaO2m6qmohby3KOwWG4+/Gl7431DX39ph580StjfXZG0pERFRGDKg1hSAAx74C/vxK9bxhL+DtNYCs8L3ESXU3pT9vPMHtfGuH3n2SWuw95gFVb6hrvvDpavNibih7Q4mIiCoOA2pNkJ0O/DYOuPKr6rnPx0C3uYAOQ1NRrj5KwrjQC7n3Q1enIwHqWcpVvaAFLlJibygREVHVYECt7pLjgK1DgIf/ADq6QJ9vgVYjNF2VVhIEAaFnozF371Vk5ShhayJDB3cbtR7ReuwNJSIi0jgG1Oos9jIQOghIegAYWgDv/gy4dNB0VVopOSMbn++6gr2XHgEAujayxTcDPGFhpK/hyoiIiKggBtTq6sYBYMd7QHYqYOUODNkGWLlquiqt9N+jRIwPvYjI+FTo6kjwfz0aYvQbDaCjw+F6IiIibcSAWt0IguquUIdnARCABp2BARtUPaikpuCQvqOZAZYPaQWv+vysiIiItBkDanWSkwXsmwRc/Fn1vPUooOdCQKqn2bq0UHJGNqbvvIzf/40BALzZyBaLOaRPRERULTCgVhdpz4Btw4GoE4BEB/ANBrw/4G1Li3DlYSLGh17Avadp0NWRYGqPRhjdwYVX4BMREVUTDKjVQfwtIPRd4NldQN8EGLAecO+u6aq0jiAI2HwmGvN+55A+ERFRdcaAqu3uHAW2BwAZiYB5PWDwNsCusaar0joFh/S7eaiG9M3lHNInIiKqbhhQtdm5tcD+zwBBATh5AwM3A8Y2mq5K6xQc0p/WsxHee4ND+kRERNUVA6o2UiqAQzOAM6tUz5sPBPyWAXoGmq1LywiCgE1novHF3qvIUihRx9wQy4e0RKt6HNInIiKqzhhQtU1GEvDre8Ctw6rnXWcBHSbzYqgCkjOyMW3nZezjkD4REVGNw4CqTZ5HAVsGAY+vArqGQL8QoIm/pqvSOlceJmJc6AVEcUifiIioRmJA1RbRZ4CtQ4C0eMDYHhi8BajTStNVaRVBELDp7yh88fs1DukTERHVYAyo2uDfX4DfxgGKLMC+OTB4K2BWR9NVaZWkjGxM//Uy9l3OG9K3w+IBzTmkT0REVAMxoGqSUgkc/RI4vlj1vFEf4O0fAH0jzdalZTikT0REVLswoGpKVhqw+0Pg6m+q529MUl0QpaOj2bq0SFFD+iuGtERLDukTERHVaJWWhr7//ns4OzvDwMAA3t7eOHv2bLFtO3fuDIlEUujRu3fvyipPs5JigA29VOFURw/wXwV0m81wmk9SRjbGhV7ArN/+Q5ZCie6N7bD/kw4Mp0RERLVApfSgbtu2DZMmTUJISAi8vb2xdOlS+Pr64saNG7C1tS3UfufOncjKyhKfP336FJ6enhgwYEBllKdZMZeA0EFA8iPA0BIYtBmo76PpqrTKlYeJ+GjzBUQ/Uw3pT+/lgVHtnTmkT0REVEtUSpfdkiVLMGbMGIwcORKNGzdGSEgI5HI51q1bV2R7S0tL2Nvbi4+wsDDI5fKaF1Cv7QXW9VCFU+uGwJg/GE7zEQQBP52+h7dXnkL0szTUMTfE9g/bcb4pERFRLVPhPahZWVk4f/48pk+fLm7T0dFBt27dcPr06VIdY+3atRg0aBCMjIq+WCgzMxOZmZni86SkpFcrurIJAnByKXBkjuq5a1dgwAbAwEyDRWmXpIxsTPv1X+y/HAsA6N7YDovf8YSZXE/DlREREVFVq/CAGh8fD4VCATs7O7XtdnZ2uH79eon7nz17FleuXMHatWuLbRMcHIy5c+e+cq1VIicT2DsRuBSqet72fcA3GJDy+rQ8lx+ortKPfpYGPakE03pySJ+IiKg207qrctauXYtmzZqhbdu2xbaZPn06EhMTxcf9+/ersMIySH0K/OSvCqcSKdBrMdBrEcNpLkEQsPHUPfRfpRrSr2thiO0f+nBIn4iIqJar8KRkbW0NqVSKuLg4te1xcXGwt7d/6b6pqanYunUr5s2b99J2MpkMMpnslWutVI+vA6HvAglRgMxUNaTv9qamq9IaSRnZmLrjXxy4ohrSf6uxHRZxSJ+IiIhQCT2o+vr68PLyQnh4uLhNqVQiPDwc7dq1e+m+27dvR2ZmJoYNG1bRZVWt20eAtd1V4dTCGXgvjOE0n8sPEtFn2QkcuBILPakEQX0aY/VwL4ZTIiIiAlBJy0xNmjQJAQEBaN26Ndq2bYulS5ciNTUVI0eOBACMGDECderUQXBwsNp+a9euhb+/P6ysrCqjrKpxdg1wYCogKIB6PsDATYBRNX4/FUh1lX4UvtynWni/roUhvh/SCp5O5poujYiIiLRIpQTUgQMH4smTJwgKCkJsbCxatGiBgwcPihdORUdHQ6fAovQ3btzAiRMncPjw4cooqfIpcoCD04Bza1TPPYcAfksBXS2filBFEtNVQ/oH/1MN6fs2scPCdzxhZsheUyIiIlInEQRB0HQRryopKQlmZmZITEyEqalp1ReQkQhsDwTu/AFAAnSbA7SfAPBCHwDAvw8SMC70Au4/S4eeVILPe3kg0IdX6VP5pWWnwTvUGwBwZsgZyPXkGq6IiIhKUpa8xsvJX9WzSCB0IBB/A9CTA2//AHj4aboqrZB3lf6X+68hWyFwSJ+IiIhKhQH1VUSdArYOBdKfASaOwJCtgIOnpqvSChzSJyIiovJiQC2vi5uBvRMAZTbg2BIYtAUwddB0VVqBQ/pERET0KhhQy+PEty9uW9q4L+AfAuhzDpwgCNhw6h4W5A7pO1kaYsVgDukTERFR2TCglodzR0DXEPAZD3T+HNDRuhtyVbnE9Gz8345LOPSf6gYNPZrY4+t3mnNIn4iIiMqMAbU86noBH/8DmNXVdCVa4dL9BIzf8mJIf0YvDwRwSJ+IiIjKiQG1vBhOIQgC1p+8h+ADL4b0vx/SCs3rmmu6NCIiIqrGGFCpXBLTsvHZjks4fJVD+kRERFSxGFCpzCLuJ2B86AU8eJ4OfakOZvT2wIh29TmkT0RERBWCAZVKjUP6REREVBUYUKlUCg7p92xqj6/6c0ifiIiIKh4DKpWo4JD+zD4eGP46h/SJiIiocjCgUrEEQcC6k/fwVe6Qfj1LOb4f0grN6pppujQiIiKqwRhQqUgFh/R7NVMN6ZsacEifiIiIKhcDKhWSlaPEOyGncOtxCof0iYiIqMoxoFIhey49wq3HKbAy0seGkW05pE9ERERVijeRJzWCIGDNX3cBAO91cGE4JSIioirHgEpqjt18ghtxyTDSl2Kod31Nl0NERES1EAMqqcnrPR3Uth7XOCUiIiKNYEAl0ZWHiTh15ymkOhKMesNF0+UQERFRLcWASqLVub2nfs0dUMfcUMPVEBERUW3FgEoAgPvP0rD/cgwAYEzHBhquhoiIiGozBlQCAKw9EQmFUsAbbtZo4sgr94mIiEhzGFAJCWlZ2HbuPgDgffaeEhERkYYxoBI2/R2F9GwFPBxM0cHdWtPlEBERUS3HgFrLZWQrsOFUFADg/Y4uvJ0pERERaRwDai236+JDxKdkwtHMAH2aO2q6HCIiIiIG1NpMqRSw5rhqaalRb7hAT8qvAxEREWkeE0ktFn79Me4+SYWJgS4Gta2n6XKIiIiIAFRiQP3+++/h7OwMAwMDeHt74+zZsy9tn5CQgHHjxsHBwQEymQyvvfYa9u/fX1nlEYAf/roDABjqXR/GMl0NV0NERESkUimpZNu2bZg0aRJCQkLg7e2NpUuXwtfXFzdu3ICtrW2h9llZWejevTtsbW2xY8cO1KlTB1FRUTA3N6+M8gjAhejnOHfvOfSkEoxs76zpcoiIiIhElRJQlyxZgjFjxmDkyJEAgJCQEOzbtw/r1q3DtGnTCrVft24dnj17hlOnTkFPTw8A4OzsXBmlUa4f/lTNPe3bog7sTA00XA0RERHRCxU+xJ+VlYXz58+jW7duL06io4Nu3brh9OnTRe6zZ88etGvXDuPGjYOdnR2aNm2KBQsWQKFQFNk+MzMTSUlJag8qvcj4VBy6GguAC/MTERGR9qnwgBofHw+FQgE7Ozu17XZ2doiNjS1yn7t372LHjh1QKBTYv38/Zs2ahW+++Qbz588vsn1wcDDMzMzEh5OTU0W/jRrtx+N3IQhAl4Y2eM3ORNPlEBEREanRiqv4lUolbG1t8cMPP8DLywsDBw7EjBkzEBISUmT76dOnIzExUXzcv3+/iiuuvuJTMrHj/AMAwPsdXTVcDREREVFhFT4H1draGlKpFHFxcWrb4+LiYG9vX+Q+Dg4O0NPTg1QqFbd5eHggNjYWWVlZ0NfXV2svk8kgk8kquvRa4efTUcjMUaJ5XTO83sBS0+UQERERFVLhPaj6+vrw8vJCeHi4uE2pVCI8PBzt2rUrcp/27dvj9u3bUCqV4rabN2/CwcGhUDil8kvPUuCn0/cAqOae8ramREREpI0qZYh/0qRJWLNmDTZu3Ihr165h7NixSE1NFa/qHzFiBKZPny62Hzt2LJ49e4YJEybg5s2b2LdvHxYsWIBx48ZVRnm11o7z9/E8LRtOlobo0aTo3mwiIiIiTauUZaYGDhyIJ0+eICgoCLGxsWjRogUOHjwoXjgVHR0NHZ0X2djJyQmHDh3Cp59+iubNm6NOnTqYMGECpk6dWhnl1UoKpYAfT0QCAEa/0QC6vK0pERERaSmJIAiCpot4VUlJSTAzM0NiYiJMTU01XY5W2n85Bh9tvgBzuR5OTesKuT7vHEXVV1p2GrxDvQEAZ4acgVxPruGKiIioJGXJa+xGqwUEQcDqv1QL8w9/vT7DKREREWk1BtRa4GzkM1y6nwB9XR2MaOes6XKIiIiIXooBtRb4Ibf3tH+rurAx4fJcREREpN0YUGu4W3HJCL/+GBIJMKaDi6bLISIiIioRA2oN9+Nx1ZX73T3s0MDGWMPVEBEREZWMAbUGe5yUgV0XHwIAPujUQMPVEBEREZUOA2oNtuHUPWQplPCqbwGv+rytKREREVUPDKg1VEpmDjb9HQVAdVtTIiIiouqCAbWG2nbuPpIycuBibYTuHnaaLoeIiIio1BhQa6BshRLr8m5r2sEFOjoSDVdEREREVHoMqDXQ/ssxeJiQDisjffRvVVfT5RARERGVCQNqDSMIAlb/qVqYP8DHGQZ6Ug1XRERERFQ2DKg1zKk7T3E1JgmGelIMf72+psshIiIiKjMG1Bpmde5tTd9tXRcWRvoaroaIiIio7BhQa5BrMUn46+YT6EiA0R24tBQRERFVTwyoNcia3N7Tns0c4GQp13A1REREROXDgFpDPEpIx55LjwAAH3BhfiIiIqrGGFBriPUnI5GjFPB6A0s0r2uu6XKIiIiIyo0BtQZIysjGlrP3AfC2pkRERFT9MaDWAKFnopGSmQN3W2N0fs1W0+UQERERvRIG1GouK0eJ9SdVtzUd07EBb2tKRERE1R4DajW359IjxCVlwtZEhr4tHDVdDhEREdErY0CtxgRBEJeWGtneBTJd3taUiIiIqj8G1Grs2M0nuBGXDCN9KYZ419N0OUREREQVggG1GvvhT1Xv6eC29WBmqKfhaoiIiIgqBgNqNXX5QSJO330KXR0JRr3houlyiIiIiCoMA2o1tfqvOwAAP09HOJobargaIiIioorDgFoN3X+Whv2XYwAAYzpwYX4iIiKqWRhQq6G1JyKhFIAO7tZo7Giq6XKIiIiIKhQDajWTkJaFbed4W1MiIiKquSotoH7//fdwdnaGgYEBvL29cfbs2WLbbtiwARKJRO1hYGBQWaVVa5v+jkJ6tgKNHUzxhpu1psshIiIiqnCVElC3bduGSZMmYfbs2bhw4QI8PT3h6+uLx48fF7uPqakpYmJixEdUVFRllFatZWQrsOGU6nN5v2MDSCS8rSkRERHVPJUSUJcsWYIxY8Zg5MiRaNy4MUJCQiCXy7Fu3bpi95FIJLC3txcfdnZ2lVFatbbr4kPEp2TC0cwAvZs7aLocIiIiokpR4QE1KysL58+fR7du3V6cREcH3bp1w+nTp4vdLyUlBfXr14eTkxP69u2L//77r9i2mZmZSEpKUnvUdEqlgDXHVQvzj3rDBXpSTh8mIiKimqnCU058fDwUCkWhHlA7OzvExsYWuU/Dhg2xbt06/Pbbb9i0aROUSiV8fHzw4MGDItsHBwfDzMxMfDg5OVX029A6R67F4e6TVJgY6GJQW97WlIiIiGoureiGa9euHUaMGIEWLVqgU6dO2LlzJ2xsbLB69eoi20+fPh2JiYni4/79+1VccdX74S9V7+mw1+vDWKar4WqIiIiIKk+FJx1ra2tIpVLExcWpbY+Li4O9vX2pjqGnp4eWLVvi9u3bRb4uk8kgk8leudbq4nzUc/wT9Rx6UgkCfZw1XQ4RERFRparwHlR9fX14eXkhPDxc3KZUKhEeHo527dqV6hgKhQKXL1+GgwMvBAKAH3Jva+rfog7sTLn8FhEREdVslTJWPGnSJAQEBKB169Zo27Ytli5ditTUVIwcORIAMGLECNSpUwfBwcEAgHnz5uH111+Hm5sbEhISsGjRIkRFRWH06NGVUV61EhmfisNXVb3RXJifiIiIaoNKCagDBw7EkydPEBQUhNjYWLRo0QIHDx4UL5yKjo6Gjs6Lztvnz59jzJgxiI2NhYWFBby8vHDq1Ck0bty4MsqrVn48fheCAHRtZAt3OxNNl0NERERU6SSCIAiaLuJVJSUlwczMDImJiTA1rTn3po9PyUT7r/5AZo4SW99/Ha83sNJ0SURaIS07Dd6h3gCAM0POQK4n13BFRERUkrLkNa24ip+K9tPpKGTmKOFZ1wzeLpaaLoeIiIioSjCgaqn0LAV+Pn0PAPB+R1fe1pSIiIhqDQZULbX9/H08T8tGPUs5ejQt3fJcRERERDUBA6oWUigF/Hg8EgAwuoMLpDrsPSUiIqLagwFVCx28EovoZ2kwl+vhHa+6mi6HiIiIqEoxoGoZQRDEhflHvF4fcn3e1pSIiIhqFwZULXM28hkuPUiETFcHI3hbUyIiIqqF2D2nZX746y4AoL9XXVgbyzRcDRERVQaFQoHs7GxNl0FU4fT09CCVSl/5OAyoWuRWXDLCrz+GRAKM6cDbmhIR1TSCICA2NhYJCQmaLoWo0pibm8Pe3v6VlshkQNUia46rek/famwHF2sjDVdDREQVLS+c2traQi6Xc41rqlEEQUBaWhoeP34MAHBwcCj3sRhQtcTjpAzsvvgIgGphfiIiqlkUCoUYTq2seOtqqpkMDQ0BAI8fP4atrW25h/t5kZSWWH/qHrIUSrSubwGv+haaLoeIiCpY3pxTuVyu4UqIKlfed/xV5lkzoGqBlMwcbPo7CgDwfkfOPSUiqsk4rE81XUV8xxlQtcDWs9FIzshBA2sjdPOw03Q5RERERBrFgKph2Qol1p+8BwAY3aEBdHhbUyIiquGcnZ2xdOnSUrc/duwYJBIJVz+oRRhQNWz/5Rg8TEiHtbE+3m5VR9PlEBERiSQSyUsfc+bMKddxz507h/fff7/U7X18fBATEwMzM7Nyna88GjVqBJlMhtjY2Co7J73AgKpBgiBg9Z+qpaUC2jnDQO/VF7YlIiKqKDExMeJj6dKlMDU1Vds2ZcoUsa0gCMjJySnVcW1sbMp0sZi+vv4rr6tZFidOnEB6ejreeecdbNy4sUrO+TK18aYODKgadPL2U1yNSYKhnhTDXq+v6XKIiKgKCYKAtKwcjTwEQShVjfb29uLDzMwMEolEfH79+nWYmJjgwIED8PLygkwmw4kTJ3Dnzh307dsXdnZ2MDY2Rps2bXDkyBG14xYc4pdIJPjxxx/Rr18/yOVyuLu7Y8+ePeLrBYf4N2zYAHNzcxw6dAgeHh4wNjZGjx49EBMTI+6Tk5ODTz75BObm5rCyssLUqVMREBAAf3//Et/32rVrMWTIEAwfPhzr1q0r9PqDBw8wePBgWFpawsjICK1bt8aZM2fE1/fu3Ys2bdrAwMAA1tbW6Nevn9p73b17t9rxzM3NsWHDBgDAvXv3IJFIsG3bNnTq1AkGBgbYvHkznj59isGDB6NOnTqQy+Vo1qwZtmzZonYcpVKJhQsXws3NDTKZDPXq1cOXX34JAOjatSvGjx+v1v7JkyfQ19dHeHh4iZ9JVeM6qBq0+q87AICBbZxgYaSv4WqIiKgqpWcr0DjokEbOfXWeL+T6FRMBpk2bhsWLF6NBgwawsLDA/fv30atXL3z55ZeQyWT46aef4Ofnhxs3bqBevXrFHmfu3LlYuHAhFi1ahOXLl2Po0KGIioqCpaVlke3T0tKwePFi/Pzzz9DR0cGwYcMwZcoUbN68GQDw9ddfY/PmzVi/fj08PDzw3XffYffu3ejSpctL309ycjK2b9+OM2fOoFGjRkhMTMTx48fRoUMHAEBKSgo6deqEOnXqYM+ePbC3t8eFCxegVCoBAPv27UO/fv0wY8YM/PTTT8jKysL+/fvL9bl+8803aNmyJQwMDJCRkQEvLy9MnToVpqam2LdvH4YPHw5XV1e0bdsWADB9+nSsWbMG3377Ld544w3ExMTg+vXrAIDRo0dj/Pjx+OabbyCTqW6lvmnTJtSpUwddu3Ytc32VjQFVQ64+SsLxW/HQkQDvveGi6XKIiIjKZd68eejevbv43NLSEp6enuLzL774Art27cKePXsK9eDlFxgYiMGDBwMAFixYgGXLluHs2bPo0aNHke2zs7MREhICV1fVzW3Gjx+PefPmia8vX74c06dPF3svV6xYUaqguHXrVri7u6NJkyYAgEGDBmHt2rViQA0NDcWTJ09w7tw5MTy7ubmJ+3/55ZcYNGgQ5s6dK27L/3mU1sSJE/H222+rbcs/peLjjz/GoUOH8Msvv6Bt27ZITk7Gd999hxUrViAgIAAA4OrqijfeeAMA8Pbbb2P8+PH47bff8O677wJQ9UQHBgZq5dJnDKgakndb017NHOBkyUWbiYhqG0M9Ka7O89XYuStK69at1Z6npKRgzpw52LdvH2JiYpCTk4P09HRER0e/9DjNmzcXfzcyMoKpqal4y8yiyOVyMZwCqttq5rVPTExEXFyc2LMIAFKpFF5eXmJPZ3HWrVuHYcOGic+HDRuGTp06Yfny5TAxMUFERARatmxZbM9uREQExowZ89JzlEbBz1WhUGDBggX45Zdf8PDhQ2RlZSEzM1Ocy3vt2jVkZmbizTffLPJ4BgYG4pSFd999FxcuXMCVK1fUplJoEwZUDXiUkI69l/Jua8qF+YmIaiOJRFJhw+yaZGRkpPZ8ypQpCAsLw+LFi+Hm5gZDQ0O88847yMrKeulx9PT01J5LJJKXhsmi2pd2bm1xrl69ir///htnz57F1KlTxe0KhQJbt27FmDFjxFt5Fqek14uqs6iLoAp+rosWLcJ3332HpUuXolmzZjAyMsLEiRPFz7Wk8wKqYf4WLVrgwYMHWL9+Pbp27Yr69bXzGhheJKUB609GIkcp4PUGlmhe11zT5RAREVWYkydPIjAwEP369UOzZs1gb2+Pe/fuVWkNZmZmsLOzw7lz58RtCoUCFy5ceOl+a9euRceOHXHp0iVERESIj0mTJmHt2rUAVD29ERERePbsWZHHaN68+UsvOrKxsVG7mOvWrVtIS0sr8T2dPHkSffv2xbBhw+Dp6YkGDRrg5s2b4uvu7u4wNDR86bmbNWuG1q1bY82aNQgNDcWoUaNKPK+mMKBWsaSMbGw5ex8A8EFH1xJaExERVS/u7u7YuXMnIiIicOnSJQwZMqTEYfXK8PHHHyM4OBi//fYbbty4gQkTJuD58+fFzrfMzs7Gzz//jMGDB6Np06Zqj9GjR+PMmTP477//MHjwYNjb28Pf3x8nT57E3bt38euvv+L06dMAgNmzZ2PLli2YPXs2rl27hsuXL+Prr78Wz9O1a1esWLECFy9exD///IMPP/ywUG9wUdzd3REWFoZTp07h2rVr+OCDDxAXFye+bmBggKlTp+L//u//8NNPP+HOnTv4+++/xWCdZ/To0fjqq68gCILa6gLahgG1ioWeiUZKZg5eszNG54Y2mi6HiIioQi1ZsgQWFhbw8fGBn58ffH190apVqyqvY+rUqRg8eDBGjBiBdu3awdjYGL6+vjAwMCiy/Z49e/D06dMiQ5uHhwc8PDywdu1a6Ovr4/Dhw7C1tUWvXr3QrFkzfPXVV5BKVfN6O3fujO3bt2PPnj1o0aIFunbtirNnz4rH+uabb+Dk5IQOHTpgyJAhmDJlSqnWhJ05cyZatWoFX19fdO7cWQzJ+c2aNQuTJ09GUFAQPDw8MHDgwELzeAcPHgxdXV0MHjy42M9CG0iEV52woQWSkpJgZmaGxMREmJqaarqcYmXlKNFh4R+IS8rEoneaY0BrJ02XRFQtpWWnwTvUGwBwZsgZyPV4oSFpv4yMDERGRsLFxUWrg0FNpVQq4eHhgXfffRdffPGFpsvRmHv37sHV1RXnzp2rtP9xKO67Xpa8Vv1nZ1cjv0U8RFxSJuxMZejbgrc1JSIiqixRUVE4fPgwOnXqhMzMTKxYsQKRkZEYMmSIpkvTiOzsbDx9+hQzZ87E66+/rpFe7bLgEH8VEQRBXFpqZHsX6OvyoyciIqosOjo62LBhA9q0aYP27dvj8uXLOHLkCDw8PDRdmkacPHkSDg4OOHfuHEJCQjRdTonYg1pFjt14gptxKTCW6WKId/F30iAiIqJX5+TkhJMnT2q6DK3RuXPnV16GqyqxG6+K5N3WdHBbJ5galHy1HhEREVFtVWkB9fvvv4ezszMMDAzg7e2tdgXby2zduhUSiaTQlWnV2b8PEvD33WfQ1ZFgZHve1pSIiIjoZSoloG7btg2TJk3C7NmzceHCBXh6esLX1/eltywDVFeWTZkyRbzfbU3xw1+quad+no5wNC/5Tg9EREREtVmlBNQlS5ZgzJgxGDlyJBo3boyQkBDI5XKsW7eu2H0UCgWGDh2KuXPnokGDmnP7z/vP0rD/suqOEWM61Jz3RURERFRZKjygZmVl4fz58+jWrduLk+jooFu3buJdFooyb9482Nra4r333ivxHJmZmUhKSlJ7aKu1JyKhFIAO7tZo7Ki9a7QSERERaYsKD6jx8fFQKBSws7NT225nZ4fY2Ngi9zlx4gTWrl2LNWvWlOocwcHBMDMzEx9OTtq54P3z1CxsO8fbmhIRERGVhcav4k9OTsbw4cOxZs0aWFtbl2qf6dOnIzExUXzcv3+/kqssn01/RyE9W4HGDqZo72al6XKIiIg0onPnzpg4caL43NnZGUuXLn3pPhKJBLt3737lc1fUcahqVfg6qNbW1pBKpYiLi1PbHhcXB3t7+0Lt79y5g3v37sHPz0/cplQqVcXp6uLGjRtwdVXvfZTJZJDJZBVdeoXKyFZg4+l7AIAPOjWARCLRbEFERERl5Ofnh+zsbBw8eLDQa8ePH0fHjh1x6dIlNG/evEzHPXfuHIyMjCqqTADAnDlzsHv3bkRERKhtj4mJgYWFRYWeqzjp6emoU6cOdHR08PDhQ63PKtqswntQ9fX14eXlhfDwcHGbUqlEeHg42rVrV6h9o0aNcPnyZURERIiP//3vf+jSpQsiIiK0dvi+JDsvPER8ShbqmBuiVzMHTZdDRERUZu+99x7CwsLw4MGDQq+tX78erVu3LnM4BQAbGxvI5fKKKLFE9vb2VRYUf/31VzRp0gSNGjXSeK+tIAjIycnRaA2volKG+CdNmoQ1a9Zg48aNuHbtGsaOHYvU1FSMHDkSADBixAhMnz4dAGBgYICmTZuqPczNzWFiYoKmTZtCX1+/MkqsVEqlgB9zb2s66g0X6Ek1PpOCiIi0jSAAWamaeZTyjkJ9+vSBjY0NNmzYoLY9JSUF27dvx3vvvYenT59i8ODBqFOnDuRyOZo1a4YtW7a89LgFh/hv3bqFjh07wsDAAI0bN0ZYWFihfaZOnYrXXnsNcrkcDRo0wKxZs5CdnQ0A2LBhA+bOnYtLly5BIpFAIpGINRcc4r98+TK6du0KQ0NDWFlZ4f3330dKSor4emBgIPz9/bF48WI4ODjAysoK48aNE8/1MmvXrsWwYcMwbNgwrF27ttDr//33H/r06QNTU1OYmJigQ4cOuHPnjvj6unXr0KRJE8hkMjg4OGD8+PEAVMtwSiQStd7hhIQESCQSHDt2DABw7NgxSCQSHDhwAF5eXpDJZDhx4gTu3LmDvn37ws7ODsbGxmjTpg2OHDmiVldmZiamTp0KJycnyGQyuLm5Ye3atRAEAW5ubli8eLFa+4iICEgkEty+fbvEz6S8KuVWpwMHDsSTJ08QFBSE2NhYtGjRAgcPHhQvnIqOjoaOTs0NbUeuxeFufCpMDXQxsE317AEmIqJKlp0GLHDUzLk/fwTolzzErqurixEjRmDDhg2YMWOGOF1t+/btUCgUGDx4MFJSUuDl5YWpU6fC1NQU+/btw/Dhw+Hq6oq2bduWeA6lUom3334bdnZ2OHPmDBITE9Xmq+YxMTHBhg0b4OjoiMuXL2PMmDEwMTHB//3f/2HgwIG4cuUKDh48KIYvMzOzQsdITU2Fr68v2rVrh3PnzuHx48cYPXo0xo8frxbCjx49CgcHBxw9ehS3b9/GwIED0aJFC4wZM6bY93Hnzh2cPn0aO3fuhCAI+PTTTxEVFYX69esDAB4+fIiOHTuic+fO+OOPP2BqaoqTJ0+KvZyrVq3CpEmT8NVXX6Fnz55ITEws161ap02bhsWLF6NBgwawsLDA/fv30atXL3z55ZeQyWT46aef4Ofnhxs3bqBePdWt10eMGIHTp09j2bJl8PT0RGRkJOLj4yGRSDBq1CisX78eU6ZMEc+xfv16dOzYEW5ubmWur7QqJaACwPjx48XkX1Be2i9Owf9Tq27yFuYf+np9GMsq7SMmIiKqdKNGjcKiRYvw559/onPnzgBUAaV///7iajr5w8vHH3+MQ4cO4ZdffilVQD1y5AiuX7+OQ4cOwdFRFdgXLFiAnj17qrWbOXOm+LuzszOmTJmCrVu34v/+7/9gaGgIY2Nj6OrqFnm9S57Q0FBkZGTgp59+EufArlixAn5+fvj666/FjjQLCwusWLECUqkUjRo1Qu/evREeHv7SgLpu3Tr07NlTnO/q6+uL9evXY86cOQBUd9g0MzPD1q1boaenuuX5a6+9Ju4/f/58TJ48GRMmTBC3tWnTpsTPr6B58+ahe/fu4nNLS0t4enqKz7/44gvs2rULe/bswfjx43Hz5k388ssvCAsLE5cIzb8efWBgIIKCgnD27Fm0bdsW2dnZCA0NLdSrWtGYnirY+ajn+CfqOfSlOhjp46zpcoiISFvpyVU9mZo6dyk1atQIPj4+WLduHTp37ozbt2/j+PHjmDdvHgDVjXYWLFiAX375BQ8fPkRWVhYyMzNLPcf02rVrcHJyEsMpgCKvWdm2bRuWLVuGO3fuICUlBTk5OTA1Ldv64teuXYOnp6faBVrt27eHUqnEjRs3xIDapEkTSKVSsY2DgwMuX75c7HEVCgU2btyI7777Ttw2bNgwTJkyBUFBQdDR0UFERAQ6dOgghtP8Hj9+jEePHuHNN98s0/spSuvWrdWep6SkYM6cOdi3bx9iYmKQk5OD9PR0REdHA1AN10ulUnTq1KnI4zk6OqJ3795Yt24d2rZti7179yIzMxMDBgx45VpfpuaOs2vID3+p5pL4t3SEramBhqshIiKtJZGohtk18SjjyjLvvfcefv31VyQnJ2P9+vVwdXUVA82iRYvw3XffYerUqTh69CgiIiLg6+uLrKysCvuoTp8+jaFDh6JXr174/fffcfHiRcyYMaNCz5FfwRApkUjEFYaKcujQITx8+BADBw6Erq4udHV1MWjQIERFRYkXjRsaFn+r85e9BkCcFinkmztc3JzYgqsjTJkyBbt27cKCBQtw/PhxREREoFmzZuJnV9K5AWD06NHYunUr0tPTsX79egwcOLDSL3JjQK1Ad5+k4PBV1fJa73fkbU2JiKhmePfdd6Gjo4PQ0FD89NNPGDVqlDgf9eTJk+jbty+GDRsGT09PNGjQADdv3iz1sT08PHD//n3ExMSI2/7++2+1NqdOnUL9+vUxY8YMtG7dGu7u7oiKilJro6+vD4VCUeK5Ll26hNTUVHHbyZMnoaOjg4YNG5a65oLWrl2LQYMGqa1IFBERgUGDBokXSzVv3hzHjx8vMliamJjA2dlZbQWk/GxsbABA7TMquJxWcU6ePInAwED069cPzZo1g729Pe7duye+3qxZMyiVSvz555/FHqNXr14wMjLCqlWrcPDgQYwaNapU534VDKgV6McTkRAE4M1GtnCzNdF0OURERBXC2NgYAwcOxPTp0xETE4PAwEDxNXd3d4SFheHUqVO4du0aPvjgg0Jrob9Mt27d8NprryEgIACXLl3C8ePHMWPGDLU27u7uiI6OxtatW3Hnzh0sW7YMu3btUmvj7OyMyMhIREREID4+HpmZmYXONXToUBgYGCAgIABXrlzB0aNH8fHHH2P48OGF7oBZWk+ePMHevXsREBBQaFWiESNGYPfu3Xj27BnGjx+PpKQkDBo0CP/88w9u3bqFn3/+GTdu3ACgWsf1m2++wbJly3Dr1i1cuHABy5cvB6Dq5Xz99dfx1Vdf4dq1a/jzzz/V5uS+jLu7O3bu3ImIiAhcunQJQ4YMUesNdnZ2RkBAAEaNGoXdu3cjMjISx44dwy+//CK2kUqlCAwMxPTp0+Hu7l7kFIyKxoBaQeJTMrHjvGqdOPaeEhFRTfPee+/h+fPn8PX1VZsvOnPmTLRq1Qq+vr7o3Lkz7O3t4e/vX+rj6ujoYNeuXUhPT0fbtm0xevRofPnll2pt/ve//+HTTz/F+PHj0aJFC5w6dQqzZs1Sa9O/f3/06NEDXbp0gY2NTZFLXcnlchw6dAjPnj1DmzZt8M477+DNN9/EihUryvZh5JN3wVVR80fffPNNGBoaYtOmTbCyssIff/yBlJQUdOrUCV5eXlizZo04nSAgIABLly7FypUr0aRJE/Tp0we3bt0Sj7Vu3Trk5OTAy8sLEydOxPz580tV35IlS2BhYQEfHx/4+fnB19cXrVq1UmuzatUqvPPOO/joo4/QqFEjjBkzRq2XGVD9/bOyssQlQyubRBBKuRiaFktKSoKZmRkSExPLPGG6oiw5fAPL/rgNTydz7P7Ih3eOIqpEadlp8A71BgCcGXIG8jJc8EGkKRkZGYiMjISLiwsMDHiNAlUvx48fx5tvvon79++X2Ntc3He9LHmNV/FXgLSsHPz0t2ouzAcdeVtTIiIiqhkyMzPx5MkTzJkzBwMGDCj3VIiy4hB/Bdhx/gES0rJRz1IO3ybFr79GREREVJ1s2bIF9evXR0JCAhYuXFhl52VAfUUKpYAfj0cCAEZ3cIFUh72nREREVDMEBgZCoVDg/PnzqFOnTpWdlwH1FR28EovoZ2mwkOthgBdva0pERET0qhhQX4EgCOLC/MPbOcNQX1rCHkRERERUEgbUV3Am8hkuPUiETFcHAe3qa7ocIiIiohqBAfUV/PDXXQDAO151YWUs03A1RERERDUDA2o53YpLxh/XH0MiAUZ34ML8RERERBWFAbWc8npPfRvbw8XaSMPVEBEREdUcDKjl8DgpA7sjHgIA3u/E3lMiIiJtcuzYMUgkEiQkJGi6lFfi7OyMpUuXaroMjWBALYcNp+4hWyGgjbMFWtWz0HQ5RERElebJkycYO3Ys6tWrB5lMBnt7e/j6+uLkyZNiG4lEgt27d1fI+e7duweJRIKIiIhStSv4GDZsGHx8fBATEwMzM7MKqakoRZ07/2POnDmvfI5z587h/ffff/ViqyHe6rQcRr3hAj2pDlrVZzglIqKarX///sjKysLGjRvRoEEDxMXFITw8HE+fPq3wc2VlZZV5nyNHjqBJkybic0NDQ+jr68PevnLv7BgTEyP+vm3bNgQFBeHGjRviNmNj41c+h42NzSsfo7piD2o5WBvL8Gn319Dptdr7xSEiolcjCALSstM08hAEoVQ1JiQk4Pjx4/j666/RpUsX1K9fH23btsX06dPxv//9D4BqGBoA+vXrB4lEIj6/c+cO+vbtCzs7OxgbG6NNmzY4cuSI2vGdnZ3xxRdfYMSIETA1NcX7778PFxcXAEDLli0hkUjQuXPnl9ZoZWUFe3t78WFmZlZoiH/Dhg0wNzfHoUOH4OHhAWNjY/To0UMtZALAjz/+CA8PDxgYGKBRo0ZYuXJlsecteE6JRCI+DwkJwRtvvKHWfunSpeJnA6ju0OTv74/FixfDwcEBVlZWGDduHLKzs9U+n/xD/BKJBD/++CP69esHuVwOd3d37NmzR+08e/bsgbu7OwwMDNClSxds3LixWk53YA8qERGRBqTnpMM71Fsj5z4z5AzkevIS2xkbG8PY2Bi7d+/G66+/Dpms8JKK586dg62tLdavX48ePXpAKlXdtCYlJQW9evXCl19+CZlMhp9++gl+fn64ceMG6tWrJ+6/ePFiBAUFYfbs2QCAcePGoW3btmLPqL6+foW857S0NCxevBg///wzdHR0MGzYMEyZMgWbN28GAGzevBlBQUFYsWIFWrZsiYsXL2LMmDEwMjJCQEBAhdRQ0NGjR+Hg4ICjR4/i9u3bGDhwIFq0aIExY8YUu8/cuXOxcOFCLFq0CMuXL8fQoUMRFRUFS0tLREZG4p133sGECRMwevRoXLx4EVOmTKmU2isbe1CJiIioSLq6utiwYQM2btwIc3NztG/fHp9//jn+/fdfsU3eMLS5uTns7e3F556envjggw/QtGlTuLu744svvoCrq2uhHr+uXbti8uTJcHV1haurq7h/Xs+opaXlS2v08fERg7SxsTEuXrxYZLvs7GyEhISgdevWaNWqFcaPH4/w8HDx9dmzZ+Obb77B22+/DRcXF7z99tv49NNPsXr16rJ/cKVkYWGBFStWoFGjRujTpw969+6tVlNRAgMDMXjwYLi5uWHBggVISUnB2bNnAQCrV69Gw4YNsWjRIjRs2BCDBg1CYGBgpdVfmdiDSkREpAGGuoY4M+SMxs5dWv3790fv3r1x/Phx/P333zhw4AAWLlyIH3/88aXhJyUlBXPmzMG+ffsQExODnJwcpKenIzo6Wq1d69aty/s2AKjmf3p4eIjPnZyccPr06ULt5HI5XF1dxecODg54/PgxACA1NRV37tzBe++9p9Z7mZOTU6kXWjVp0kTscc6r6fLlyy/dp3nz5uLvRkZGMDU1Fd/HjRs30KZNG7X2bdu2rcCKqw4DKhERkQZIJJJSDbNrAwMDA3Tv3h3du3fHrFmzMHr0aMyePfulAXXKlCkICwvD4sWL4ebmBkNDQ7zzzjuFLoQyMnq1tcSdnJzg5uZWYjs9PT215xKJRJyLm5KSAgBYs2YNvL3Vp13kD5ClpaOjU2ieb/65pS+rSalUvvTY5dmnOmJAJSIiojJp3Lix2rJSenp6UCgUam1OnjyJwMBA9OvXD4AqBN67d6/EY+fNOS14vMpkZ2cHR0dH3L17F0OHDn3l49nY2CA2NhaCIEAikQBAictmVYSGDRti//79atvOnTtX6eetDJyDSkREREV6+vQpunbtik2bNuHff/9FZGQktm/fjoULF6Jv375iO2dnZ4SHhyM2NhbPnz8HALi7u2Pnzp2IiIjApUuXMGTIkFL19Nna2sLQ0BAHDx5EXFwcEhMTK+395Td37lwEBwdj2bJluHnzJi5fvoz169djyZIlZT5W586d8eTJEyxcuBB37tzB999/jwMHDlRC1eo++OADXL9+HVOnTsXNmzfxyy+/YMOGDQAgBuXqggGViIiIimRsbAxvb298++236NixI5o2bYpZs2ZhzJgxWLFihdjum2++QVhYGJycnNCyZUsAwJIlS2BhYQEfHx/4+fnB19cXrVq1KvGcurq6WLZsGVavXg1HR0e1IFyZRo8ejR9//BHr169Hs2bN0KlTJ2zYsEFc9qosPDw8sHLlSnz//ffw9PTE2bNnq+RqehcXF+zYsQM7d+5E8+bNsWrVKsyYMQMAilyBQZtJhNIuhqbFkpKSYGZmhsTERJiammq6HCKqZGnZaeLyPKVdLodI0zIyMhAZGQkXFxcYGBhouhyqJb788kuEhITg/v37VXbO4r7rZclrnINKREREVEOsXLkSbdq0gZWVFU6ePIlFixZh/Pjxmi6rzBhQiYiIiGqIW7duYf78+Xj27Bnq1auHyZMnY/r06Zouq8wqbQ7q999/D2dnZxgYGMDb21tcRLYoO3fuROvWrWFubg4jIyO0aNECP//8c2WVRkTVXN76kWeGnCnTeo5ERDXdt99+i0ePHiEjIwM3b97ErFmzoKtb/fojKyWgbtu2DZMmTcLs2bNx4cIFeHp6wtfXV1xItiBLS0vMmDEDp0+fxr///ouRI0di5MiROHToUGWUR0TVXN76kXI9ebW7MpWIiEpWKQF1yZIlGDNmDEaOHInGjRsjJCQEcrkc69atK7J9586d0a9fP3h4eMDV1RUTJkxA8+bNceLEicooj4iISGNqwLXJRC9VEd/xCg+oWVlZOH/+PLp16/biJDo66NatW5G3HitIEASEh4fjxo0b6NixY5FtMjMzkZSUpPYgIiLSZnl3AEpLS9NwJUSVK+87XvCuV2VR4ZMS4uPjoVAoYGdnp7bdzs4O169fL3a/xMRE1KlTB5mZmZBKpVi5ciW6d+9eZNvg4GDMnTu3QusmIiKqTFKpFObm5uJ0N7mcU1SoZhEEAWlpaXj8+DHMzc3LdZvYPFoza9bExAQRERFISUlBeHg4Jk2ahAYNGqBz586F2k6fPh2TJk0SnyclJcHJyakKqyUiIio7e3t7ACj2mgyimsDc3Fz8rpdXhQdUa2trSKVSxMXFqW2Pi4t7abE6Ojpwc3MDALRo0QLXrl1DcHBwkQFVJpNVuzsiEBERSSQSODg4wNbWFtnZ2Zouh6jC6enpvVLPaZ4KD6j6+vrw8vJCeHg4/P39AQBKpRLh4eFlWihWqVQiMzOzossjIiLSOKlUWiH/ESeqqSpliH/SpEkICAhA69at0bZtWyxduhSpqakYOXIkAGDEiBGoU6cOgoODAajmlLZu3Rqurq7IzMzE/v378fPPP2PVqlWVUR4RERERabFKCagDBw7EkydPEBQUhNjYWLRo0QIHDx4UL5yKjo6Gjs6LBQRSU1Px0Ucf4cGDBzA0NESjRo2wadMmDBw4sDLKIyIiIiItJhFqwIJsSUlJMDMzQ2JiIkxNTTVdDhEREREVUJa8pjVX8b+KvIzN9VCJiIiItFNeTitN32iNCKjJyckAwKWmiIiIiLRccnIyzMzMXtqmRgzxK5VKPHr0CCYmJlW26HHe2qv379/ntIJqiH+/6o9/w+qPf8Pqj3/D6q2q/36CICA5ORmOjo5q1yIVpUb0oOro6KBu3boaObepqSn/oazG+Per/vg3rP74N6z++Des3qry71dSz2mel8dXIiIiIqIqxoBKRERERFqFAbWcZDIZZs+ezVuuVlP8+1V//BtWf/wbVn/8G1Zv2vz3qxEXSRERERFRzcEeVCIiIiLSKgyoRERERKRVGFCJiIiISKswoBIRERGRVmFALYfvv/8ezs7OMDAwgLe3N86ePavpkqiUgoOD0aZNG5iYmMDW1hb+/v64ceOGpsuicvrqq68gkUgwceJETZdCZfDw4UMMGzYMVlZWMDQ0RLNmzfDPP/9ouiwqJYVCgVmzZsHFxQWGhoZwdXXFF198Uar7q5Nm/PXXX/Dz84OjoyMkEgl2796t9rogCAgKCoKDgwMMDQ3RrVs33Lp1SzPF5mJALaNt27Zh0qRJmD17Ni5cuABPT0/4+vri8ePHmi6NSuHPP//EuHHj8PfffyMsLAzZ2dl46623kJqaqunSqIzOnTuH1atXo3nz5pouhcrg+fPnaN++PfT09HDgwAFcvXoV33zzDSwsLDRdGpXS119/jVWrVmHFihW4du0avv76ayxcuBDLly/XdGlUjNTUVHh6euL7778v8vWFCxdi2bJlCAkJwZkzZ2BkZARfX19kZGRUcaUvcJmpMvL29kabNm2wYsUKAIBSqYSTkxM+/vhjTJs2TcPVUVk9efIEtra2+PPPP9GxY0dNl0OllJKSglatWmHlypWYP38+WrRogaVLl2q6LCqFadOm4eTJkzh+/LimS6Fy6tOnD+zs7LB27VpxW//+/WFoaIhNmzZpsDIqDYlEgl27dsHf3x+AqvfU0dERkydPxpQpUwAAiYmJsLOzw4YNGzBo0CCN1Mke1DLIysrC+fPn0a1bN3Gbjo4OunXrhtOnT2uwMiqvxMREAIClpaWGK6GyGDduHHr37q32zyJVD3v27EHr1q0xYMAA2NraomXLllizZo2my6Iy8PHxQXh4OG7evAkAuHTpEk6cOIGePXtquDIqj8jISMTGxqr9+9TMzAze3t4azTa6GjtzNRQfHw+FQgE7Ozu17XZ2drh+/bqGqqLyUiqVmDhxItq3b4+mTZtquhwqpa1bt+LChQs4d+6cpkuhcrh79y5WrVqFSZMm4fPPP8e5c+fwySefQF9fHwEBAZouj0ph2rRpSEpKQqNGjSCVSqFQKPDll19i6NChmi6NyiE2NhYAisw2ea9pAgMq1Vrjxo3DlStXcOLECU2XQqV0//59TJgwAWFhYTAwMNB0OVQOSqUSrVu3xoIFCwAALVu2xJUrVxASEsKAWk388ssv2Lx5M0JDQ9GkSRNERERg4sSJcHR05N+QKgyH+MvA2toaUqkUcXFxatvj4uJgb2+voaqoPMaPH4/ff/8dR48eRd26dTVdDpXS+fPn8fjxY7Rq1Qq6urrQ1dXFn3/+iWXLlkFXVxcKhULTJVIJHBwc0LhxY7VtHh4eiI6O1lBFVFafffYZpk2bhkGDBqFZs2YYPnw4Pv30UwQHB2u6NCqHvPyibdmGAbUM9PX14eXlhfDwcHGbUqlEeHg42rVrp8HKqLQEQcD48eOxa9cu/PHHH3BxcdF0SVQGb775Ji5fvoyIiAjx0bp1awwdOhQRERGQSqWaLpFK0L59+0JLu928eRP169fXUEVUVmlpadDRUY8PUqkUSqVSQxXRq3BxcYG9vb1atklKSsKZM2c0mm04xF9GkyZNQkBAAFq3bo22bdti6dKlSE1NxciRIzVdGpXCuHHjEBoait9++w0mJibi/BozMzMYGhpquDoqiYmJSaH5wkZGRrCysuI84mri008/hY+PDxYsWIB3330XZ8+exQ8//IAffvhB06VRKfn5+eHLL79EvXr10KRJE1y8eBFLlizBqFGjNF0aFSMlJQW3b98Wn0dGRiIiIgKWlpaoV68eJk6ciPnz58Pd3R0uLi6YNWsWHB0dxSv9NUKgMlu+fLlQr149QV9fX2jbtq3w999/a7okKiUART7Wr1+v6dKonDp16iRMmDBB02VQGezdu1do2rSpIJPJhEaNGgk//PCDpkuiMkhKShImTJgg1KtXTzAwMBAaNGggzJgxQ8jMzNR0aVSMo0ePFvnfvoCAAEEQBEGpVAqzZs0S7OzsBJlMJrz55pvCjRs3NFoz10ElIiIiIq3COahEREREpFUYUImIiIhIqzCgEhEREZFWYUAlIiIiIq3CgEpEREREWoUBlYiIiIi0CgMqEREREWkVBlQiIiIi0ioMqERERESkVRhQiYiIiEirMKASERERkVZhQCUiIiIircKASkTlEhgYCGdn53LtO2fOHEgkkootSMvcu3cPEokEGzZsqPJzSyQSzJkzR3y+YcMGSCQS3Lt3r8R9nZ2dERgYWKH1vMp3hYhqJwZUohpGIpGU6nHs2DFNl1rrffLJJ5BIJLh9+3axbWbMmAGJRIJ///23Cisru0ePHmHOnDmIiIjQdCmivP9JWLx4saZLIaIy0tV0AURUsX7++We15z/99BPCwsIKbffw8Hil86xZswZKpbJc+86cORPTpk17pfPXBEOHDsXy5csRGhqKoKCgItts2bIFzZo1Q/Pmzct9nuHDh2PQoEGQyWTlPkZJHj16hLlz58LZ2RktWrRQe+1VvitEVDsxoBLVMMOGDVN7/vfffyMsLKzQ9oLS0tIgl8tLfR49Pb1y1QcAurq60NXlv368vb3h5uaGLVu2FBlQT58+jcjISHz11VevdB6pVAqpVPpKx3gVr/JdIaLaiUP8RLVQ586d0bRpU5w/fx4dO3aEXC7H559/DgD47bff0Lt3bzg6OkImk8HV1RVffPEFFAqF2jEKzivMP5z6ww8/wNXVFTKZDG3atMG5c+fU9i1qDqpEIsH48eOxe/duNG3aFDKZDE2aNMHBgwcL1X/s2DG0bt0aBgYGcHV1xerVq0s9r/X48eMYMGAA6tWrB5lMBicnJ3z66adIT08v9P6MjY3x8OFD+Pv7w9jYGDY2NpgyZUqhzyIhIQGBgYEwMzODubk5AgICkJCQUGItgKoX9fr167hw4UKh10JDQyGRSDB48GBkZWUhKCgIXl5eMDMzg5GRETp06ICjR4+WeI6i5qAKgoD58+ejbt26kMvl6NKlC/77779C+z579gxTpkxBs2bNYGxsDFNTU/Ts2ROXLl0S2xw7dgxt2rQBAIwcOVKcRpI3/7aoOaipqamYPHkynJycIJPJ0LBhQyxevBiCIKi1K8v3orweP36M9957D3Z2djAwMICnpyc2btxYqN3WrVvh5eUFExMTmJqaolmzZvjuu+/E17OzszF37ly4u7vDwMAAVlZWeOONNxAWFlZhtRLVFuzCIKqlnj59ip49e2LQoEEYNmwY7OzsAKjCjLGxMSZNmgRjY2P88ccfCAoKQlJSEhYtWlTicUNDQ5GcnIwPPvgAEokECxcuxNtvv427d++W2JN24sQJ7Ny5Ex999BFMTEywbNky9O/fH9HR0bCysgIAXLx4ET169ICDgwPmzp0LhUKBefPmwcbGplTve/v27UhLS8PYsWNhZWWFs2fPYvny5Xjw4AG2b9+u1lahUMDX1xfe3t5YvHgxjhw5gm+++Qaurq4YO3YsAFXQ69u3L06cOIEPP/wQHh4e2LVrFwICAkpVz9ChQzF37lyEhoaiVatWauf+5Zdf0KFDB9SrVw/x8fH48ccfMXjwYIwZMwbJyclYu3YtfH19cfbs2ULD6iUJCgrC/Pnz0atXL/Tq1QsXLlzAW2+9haysLLV2d+/exe7duzFgwAC4uLggLi4Oq1evRqdOnXD16lU4OjrCw8MD8+bNQ1BQEN5//3106NABAODj41PkuQVBwP/+9z8cPXoU7733Hlq0aIFDhw7hs88+w8OHD/Htt9+qtS/N96K80tPT0blzZ9y+fRvjx4+Hi4sLtm/fjsDAQCQkJGDChAkAgLCwMAwePBhvvvkmvv76awDAtWvXcPLkSbHNnDlzEBwcjNGjR6Nt27ZISkrCP//8gwsXLqB79+6vVCdRrSMQUY02btw4oeA/6p06dRIACCEhIYXap6WlFdr2wQcfCHK5XMjIyBC3BQQECPXr1xefR0ZGCgAEKysr4dmzZ+L23377TQAg7N27V9w2e/bsQjUBEPT19YXbt2+L2y5duiQAEJYvXy5u8/PzE+RyufDw4UNx261btwRdXd1CxyxKUe8vODhYkEgkQlRUlNr7AyDMmzdPrW3Lli0FLy8v8fnu3bsFAMLChQvFbTk5OUKHDh0EAML69etLrKlNmzZC3bp1BYVCIW47ePCgAEBYvXq1eMzMzEy1/Z4/fy7Y2dkJo0aNUtsOQJg9e7b4fP369QIAITIyUhAEQXj8+LGgr68v9O7dW1AqlWK7zz//XAAgBAQEiNsyMjLU6hIE1d9aJpOpfTbnzp0r9v0W/K7kfWbz589Xa/fOO+8IEolE7TtQ2u9FUfK+k4sWLSq2zdKlSwUAwqZNm8RtWVlZQrt27QRjY2MhKSlJEARBmDBhgmBqairk5OQUeyxPT0+hd+/eL62JiEqHQ/xEtZRMJsPIkSMLbTc0NBR/T05ORnx8PDp06IC0tDRcv369xOMOHDgQFhYW4vO83rS7d++WuG+3bt3g6uoqPm/evDlMTU3FfRUKBY4cOQJ/f384OjqK7dzc3NCzZ88Sjw+ov7/U1FTEx8fDx8cHgiDg4sWLhdp/+OGHas87dOig9l72798PXV1dsUcVUM35/Pjjj0tVD6CaN/zgwQP89ddf4rbQ0FDo6+tjwIAB4jH19fUBAEqlEs+ePUNOTg5at25d5PSAlzly5AiysrLw8ccfq02LmDhxYqG2MpkMOjqq/1QoFAo8ffoUxsbGaNiwYZnPm2f//v2QSqX45JNP1LZPnjwZgiDgwIEDattL+l68iv3798Pe3h6DBw8Wt+np6eGTTz5BSkoK/vzzTwCAubk5UlNTXzpcb25ujv/++w+3bt165bqIajsGVKJaqk6dOmLgye+///5Dv379YGZmBlNTU9jY2IgXWCUmJpZ43Hr16qk9zwurz58/L/O+efvn7fv48WOkp6fDzc2tULuithUlOjoagYGBsLS0FOeVdurUCUDh92dgYFBo6kD+egAgKioKDg4OMDY2VmvXsGHDUtUDAIMGDYJUKkVoaCgAICMjA7t27ULPnj3Vwv7GjRvRvHlzcX6jjY0N9u3bV6q/S35RUVEAAHd3d7XtNjY2aucDVGH422+/hbu7O2QyGaytrWFjY4N///23zOfNf35HR0eYmJiobc9bWSKvvjwlfS9eRVRUFNzd3cUQXlwtH330EV577TX07NkTdevWxahRowrNg503bx4SEhLw2muvoVmzZvjss8+0fnkwIm3FgEpUS+XvScyTkJCATp064dKlS5g3bx727t2LsLAwcc5daZYKKu5qcaHAxS8VvW9pKBQKdO/eHfv27cPUqVOxe/duhIWFiRfzFHx/VXXlu62tLbp3745ff/0V2dnZ2Lt3L5KTkzF06FCxzaZNmxAYGAhXV1esXbsWBw8eRFhYGLp27VqpSzgtWLAAkyZNQseOHbFp0yYcOnQIYWFhaNKkSZUtHVXZ34vSsLW1RUREBPbs2SPOn+3Zs6faXOOOHTvizp07WLduHZo2bYoff/wRrVq1wo8//lhldRLVFLxIiohEx44dw9OnT7Fz50507NhR3B4ZGanBql6wtbWFgYFBkQvbv2yx+zyXL1/GzZs3sXHjRowYMULc/ipXWdevXx/h4eFISUlR60W9ceNGmY4zdOhQHDx4EAcOHEBoaChMTU3h5+cnvr5jxw40aNAAO3fuVBuWnz17drlqBoBbt26hQYMG4vYnT54U6pXcsWMHunTpgrVr16ptT0hIgLW1tfi8LHcGq1+/Po4cOYLk5GS1XtS8KSR59VWF+vXr499//4VSqVTrRS2qFn19ffj5+cHPzw9KpRIfffQRVq9ejVmzZok9+JaWlhg5ciRGjhyJlJQUdOzYEXPmzMHo0aOr7D0R1QTsQSUiUV5PVf6eqaysLKxcuVJTJamRSqXo1q0bdu/ejUePHonbb9++XWjeYnH7A+rvTxAEtaWCyqpXr17IycnBqlWrxG0KhQLLly8v03H8/f0hl8uxcuVKHDhwAG+//TYMDAxeWvuZM2dw+vTpMtfcrVs36OnpYfny5WrHW7p0aaG2Uqm0UE/l9u3b8fDhQ7VtRkZGAFCq5bV69eoFhUKBFStWqG3/9ttvIZFISj2fuCL06tULsbGx2LZtm7gtJycHy5cvh7GxsTj94+nTp2r76ejoiDdPyMzMLLKNsbEx3NzcxNeJqPTYg0pEIh8fH1hYWCAgIEC8DefPP/9cpUOpJZkzZw4OHz6M9u3bY+zYsWLQadq0aYm32WzUqBFcXV0xZcoUPHz4EKampvj1119faS6jn58f2rdvj2nTpuHevXto3Lgxdu7cWeb5mcbGxvD39xfnoeYf3geAPn36YOfOnejXrx969+6NyMhIhISEoHHjxkhJSSnTufLWcw0ODkafPn3Qq1cvXLx4EQcOHFDrFc0777x58zBy5Ej4+Pjg8uXL2Lx5s1rPKwC4urrC3NwcISEhMDExgZGREby9veHi4lLo/H5+fujSpQtmzJiBe/fuwdPTE4cPH8Zvv/2GiRMnql0QVRHCw8ORkZFRaLu/vz/ef/99rF69GoGBgTh//jycnZ2xY8cOnDx5EkuXLhV7eEePHo1nz56ha9euqFu3LqKiorB8+XK0aNFCnK/auHFjdO7cGV5eXrC0tMQ///yDHTt2YPz48RX6fohqAwZUIhJZWVnh999/x+TJkzFz5kxYWFhg2LBhePPNN+Hr66vp8gAAXl5eOHDgAKZMmYJZs2bByckJ8+bNw7Vr10pcZUBPTw979+7FJ598guDgYBgYGKBfv34YP348PD09y1WPjo4O9uzZg4kTJ2LTpk2QSCT43//+h2+++QYtW7Ys07GGDh2K0NBQODg4oGvXrmqvBQYGIjY2FqtXr8ahQ4fQuHFjbNq0Cdu3b8exY8fKXPf8+fNhYGCAkJAQHD16FN7e3jh8+DB69+6t1u7zzz9HamoqQkNDsW3bNrRq1Qr79u0rdKtaPT09bNy4EdOnT8eHH36InJwcrF+/vsiAmveZBQUFYdu2bVi/fj2cnZ2xaNEiTJ48uczvpSQHDx4scmF/Z2dnNG3aFMeOHcO0adOwceNGJCUloWHDhli/fj0CAwPFtsOGDcMPP/yAlStXIiEhAfb29hg4cCDmzJkjTg345JNPsGfPHhw+fBiZmZmoX78+5s+fj88++6zC3xNRTScRtKlrhIionPz9/bnEDxFRDcE5qERU7RS8LemtW7ewf/9+dO7cWTMFERFRhWIPKhFVOw4ODggMDESDBg0QFRWFVatWITMzExcvXiy0ticREVU/nINKRNVOjx49sGXLFsTGxkImk6Fdu3ZYsGABwykRUQ3BHlQiIiIi0iqcg0pEREREWoUBlYiIiIi0So2Yg6pUKvHo0SOYmJiU6XZ7RERERFQ1BEFAcnIyHB0d1W4tXJQaEVAfPXoEJycnTZdBRERERCW4f/8+6tat+9I2NSKg5t2K7v79+zA1NdVwNURERERUUFJSEpycnMTc9jI1IqDmDeubmpoyoBIRERFpsdJMx+RFUkRERESkVRhQiYiIiEirMKASERERkVapEXNQiYiIaitBEJCTkwOFQqHpUogglUqhq6v7yst+MqASERFVU1lZWYiJiUFaWpqmSyESyeVyODg4QF9fv9zHYEAlIiKqhpRKJSIjIyGVSuHo6Ah9fX3erIY0ShAEZGVl4cmTJ4iMjIS7u3uJC/IXhwGViIioGsrKyoJSqYSTkxPkcrmmyyECABgaGkJPTw9RUVHIysqCgYFBuY7DgEpE1Y4gCEjPSQcAGOoasteIarXy9lARVZaK+E7yW01E1U56Tjq8Q73hHeotBlUiIqo5GFCJiIiISKswoBIREVG15+zsjKVLl5a6/bFjxyCRSJCQkFBpNVH5MaASERFRlZFIJC99zJkzp1zHPXfuHN5///1St/fx8UFMTAzMzMzKdb7SYhAuH14kRURERFUmJiZG/H3btm0ICgrCjRs3xG3Gxsbi74IgQKFQQFe35LhiY2NTpjr09fVhb29fpn2o6rAHlYiIqIYQBAFpWTlV/hAEodQ12tvbiw8zMzNIJBLx+fXr12FiYoIDBw7Ay8sLMpkMJ06cwJ07d9C3b1/Y2dnB2NgYbdq0wZEjR9SOW3CIXyKR4Mcff0S/fv0gl8vh7u6OPXv2iK8X7NncsGEDzM3NcejQIXh4eMDY2Bg9evRQC9Q5OTn45JNPYG5uDisrK0ydOhUBAQHw9/cv198LAJ4/f44RI0bAwsICcrkcPXv2xK1bt8TXo6Ki4OfnBwsLCxgZGaFJkybYv3+/uO/QoUNhY2MDQ0NDuLu7Y/369eWuRZuwB5WIiKiGSM9WoHHQoSo/79V5vpDrV1ykmDZtGhYvXowGDRrAwsIC9+/fR69evfDll19CJpPhp59+gp+fH27cuIF69eoVe5y5c+di4cKFWLRoEZYvX46hQ4ciKioKlpaWRbZPS0vD4sWL8fPPP0NHRwfDhg3DlClTsHnzZgDA119/jc2bN2P9+vXw8PDAd999h927d6NLly7lfq+BgYG4desW9uzZA1NTU0ydOhW9evXC1atXoaenh3HjxiErKwt//fUXjIyMcPXqVbGXedasWbh69SoOHDgAa2tr3L59G+npNWNlEwZUIiIi0irz5s1D9+7dxeeWlpbw9PQUn3/xxRfYtWsX9uzZg/Hjxxd7nMDAQAwePBgAsGDBAixbtgxnz55Fjx49imyfnZ2NkJAQuLq6AgDGjx+PefPmia8vX74c06dPR79+/QAAK1asEHszyyMvmJ48eRI+Pj4AgM2bN8PJyQm7d+/GgAEDEB0djf79+6NZs2YAgAYNGoj7R0dHo2XLlmjdujUAVS9yTVGmgBocHIydO3fi+vXrMDQ0hI+PD77++ms0bNjwpftt374ds2bNwr179+Du7o6vv/4avXr1El8XBAGzZ8/GmjVrkJCQgPbt22PVqlVwd3cv37siIiKqhQz1pLg6z1cj561IeYErT0pKCubMmYN9+/YhJiYGOTk5SE9PR3R09EuP07x5c/F3IyMjmJqa4vHjx8W2l8vlYjgFAAcHB7F9YmIi4uLi0LZtW/F1qVQKLy8vKJXKMr2/PNeuXYOuri68vb3FbVZWVmjYsCGuXbsGAPjkk08wduxYHD58GN26dUP//v3F9zV27Fj0798fFy5cwFtvvQV/f38x6FZ3ZZqD+ueff2LcuHH4+++/ERYWhuzsbLz11ltITU0tdp9Tp05h8ODBeO+993Dx4kX4+/vD398fV65cEdssXLgQy5YtQ0hICM6cOQMjIyP4+voiIyOj/O+MiIiolpFIJJDr61b5o6Lv5mZkZKT2fMqUKdi1axcWLFiA48ePIyIiAs2aNUNWVtZLj6Onp1fo83lZmCyqfVnm11aG0aNH4+7duxg+fDguX76M1q1bY/ny5QCAnj17IioqCp9++ikePXqEN998E1OmTNFovRWlTAH14MGDCAwMRJMmTeDp6YkNGzYgOjoa58+fL3af7777Dj169MBnn30GDw8PfPHFF2jVqhVWrFgBQNV7unTpUsycORN9+/ZF8+bN8dNPP+HRo0fYvXv3K705IiIiqv5OnjyJwMBA9OvXD82aNYO9vT3u3btXpTWYmZnBzs4O586dE7cpFApcuHCh3Mf08PBATk4Ozpw5I257+vQpbty4gcaNG4vbnJyc8OGHH2Lnzp2YPHky1qxZI75mY2ODgIAAbNq0CUuXLsUPP/xQ7nq0ySvNQU1MTASAYicbA8Dp06cxadIktW2+vr5i+IyMjERsbCy6desmvm5mZgZvb2+cPn0agwYNKnTMzMxMZGZmis+TkpJe5W2Uy824ZNSzlMOggoc1iIiISJ27uzt27twJPz8/SCQSzJo1q9zD6q/i448/RnBwMNzc3NCoUSMsX74cz58/L1UP8uXLl2FiYiI+l0gk8PT0RN++fTFmzBisXr0aJiYmmDZtGurUqYO+ffsCACZOnIiePXvitddew/Pnz3H06FF4eHgAAIKCguDl5YUmTZogMzMTv//+u/hadVfugKpUKjFx4kS0b98eTZs2LbZdbGws7Ozs1LbZ2dkhNjZWfD1vW3FtCgoODsbcuXPLW/orCz0TjTl7/sPQ1+thtl8TjdVBRERUGyxZsgSjRo2Cj48PrK2tMXXqVI10Tk2dOhWxsbEYMWIEpFIp3n//ffj6+kIqLbmzqmPHjmrPpVIpcnJysH79ekyYMAF9+vRBVlYWOnbsiP3794vTDRQKBcaNG4cHDx7A1NQUPXr0wLfffgtAtZbr9OnTce/ePRgaGqJDhw7YunVrxb9xDZAI5ZxcMXbsWBw4cAAnTpxA3bp1i22nr6+PjRs3ilfRAcDKlSsxd+5cxMXF4dSpU2jfvj0ePXoEBwcHsc27774LiUSCbdu2FTpmUT2oTk5OSExMhKmpaXneTpkcvfEYI9eruvg3j/ZGezfrSj8nEb2Qlp0G71DVRQVnhpyBXE+u4YqIql5GRgYiIyPh4uICAwMDTZdTKymVSnh4eODdd9/FF198oelytEZx382kpCSYmZmVKq+Va6H+8ePH4/fff8fRo0dfGk4B1YK8cXFxatvi4uLEuzfk/XxZm4JkMhlMTU3VHlWpS0NbDPFWrbs2ZfslJKZnV+n5iYiIqOpFRUVhzZo1uHnzJi5fvoyxY8ciMjISQ4YM0XRpNU6ZAqogCBg/fjx27dqFP/74Ay4uLiXu065dO4SHh6ttCwsLQ7t27QAALi4usLe3V2uTlJSEM2fOiG200YxeHqhvJUdMYgbm7PlP0+UQERFRJdPR0cGGDRvQpk0btG/fHpcvX8aRI0dqzLxPbVKmOajjxo1DaGgofvvtN5iYmIhzRM3MzGBoaAgAGDFiBOrUqYPg4GAAwP+3d+dxUdX7H8dfwwDDDgKyKSriboo7qZlalJp5Ky2ta6mV1e1n3dRssa6WWXnbzTRtNytL2+y2WUm57xqm5YaSuLGIAgKyzvz+GBwZxWUUGJb38/E4D2fO+Z4znxHLt9/zPd/vQw89RO/evXnllVcYOHAgn332GRs3brQ9ZWYwGBg7dizPPvsszZs3JyoqikmTJhEREXFJS4dVNm+TK68O7cAtc1bz9e8HuaZNKNe1Cz//iSIiIlIjRUZGsmrVKmeXUSc41IM6e/ZssrKy6NOnD+Hh4bat7DjR5ORku3Vre/Towfz583n77beJiYnhiy++YNGiRXYPVj366KM8+OCD3HvvvXTt2pWcnBwWL15c7cfUdG5cj/v7WCf0feLrraRla95WERERkUt10Q9JVSeODLqtaIXFZm56cxV/HsqmT8v6fDCqa4VPWCwi9vSQlIgekpLqy2kPSckp7q4uTB/WAXdXF5buTGf++nMvuyYiIiIi56aAWgGah/ryaL+WADz73Xb+PnL2pV9FRERE5NwUUCvIXT2j6N40iBNFJYxfmEBxSdWvcCEiIiJSGyigVhAXFwMvD43B1+TK5uRM3lq+19kliYiIiNRICqgVqEGAJ0//w7r06Wu/7GLbwSwnVyQiIlI79enTh7Fjx9reN2nShOnTp5/zHIPBwKJFiy75syvqOnJ2CqgVbHCnBvRvG0ax2cK4BQnkF5U4uyQREZFqY9CgQfTv37/cYytWrMBgMPDHH384fN0NGzZw7733Xmp5dp5++mk6dOhwxv7Dhw8zYMCACv2s082dO5eAgIBK/YzqTAG1ghkMBp4f3I5gHxO703J46aedzi5JRESk2rj77rv55ZdfOHDgwBnHPvjgA7p06UL79u0dvm79+vXx8qqaKefCwsIwmUxV8ll1lQJqJQj0dufFm9sB8N7KJFbvOeLkikREpE6wWKAwt+o3B6ZUv/7666lfvz5z586125+Tk8Pnn3/O3XffTUZGBrfddhsNGjTAy8uLdu3a8emnn57zuqff4t+9ezdXXnklHh4etGnThl9++eWMcx577DFatGiBl5cXTZs2ZdKkSRQVFQHWHswpU6awZcsWDAYDBoPBVvPpt/i3bt3KVVddhaenJ0FBQdx7773k5OTYjo8aNYobb7yRl19+mfDwcIKCghgzZoztsy5GcnIyN9xwAz4+Pvj5+TF06FBSU1Ntx7ds2ULfvn3x9fXFz8+Pzp07s3HjRgD27dvHoEGDqFevHt7e3rRt25YffvjhomupDA4tdSoX7qpWodzWLZJP1+9nwsItLB53JX4ebs4uS0REarOiPHg+ouo/94lD4O59QU1dXV0ZMWIEc+fO5cknn7QtbvP5559TUlLCbbfdRk5ODp07d+axxx7Dz8+P77//njvuuIPo6Gi6det23s8wm80MHjyY0NBQ1q1bR1ZWlt141ZN8fX2ZO3cuERERbN26lXvuuQdfX18effRRhg0bxrZt21i8eDFLliwBrEu7ny43N5d+/frRvXt3NmzYQFpaGqNHj+aBBx6wC+G//fYb4eHh/PbbbyQmJjJs2DA6dOjAPffcc0G/b6d/v5PhdNmyZRQXFzNmzBiGDRvG0qVLARg+fDgdO3Zk9uzZGI1GEhIScHOz5pAxY8ZQWFjI8uXL8fb25q+//sLHx8fhOiqTAmol+s/ANqxKzCD5aB5P/+9PXh3awdkliYiION1dd93FSy+9xLJly+jTpw9gvb0/ZMgQ/P398ff3Z8KECbb2Dz74ID/99BMLFy68oIC6ZMkSduzYwU8//UREhDWwP//882eMG/3Pf/5je92kSRMmTJjAZ599xqOPPoqnpyc+Pj64uroSFhZ21s+aP38++fn5zJs3D29va0ifOXMmgwYN4oUXXiA0NBSAevXqMXPmTIxGI61atWLgwIHEx8dfVECNj49n69atJCUlERkZCcC8efNo27YtGzZsoGvXriQnJ/PII4/QqlUrAJo3b247Pzk5mSFDhtCunfVub9OmTR2uobIpoFYib5Mrrw6NYehba/hq80GubRNK/8vCnV2WiIjUVm5e1t5MZ3yuA1q1akWPHj14//336dOnD4mJiaxYsYJnnnkGgJKSEp5//nkWLlzIwYMHKSwspKCg4ILHmG7fvp3IyEhbOAXo3r37Ge0WLFjAjBkz2LNnDzk5ORQXFzu8ZPr27duJiYmxhVOAnj17Yjab2blzpy2gtm3bFqPRaGsTHh7O1q1bHfqssp8ZGRlpC6cAbdq0ISAggO3bt9O1a1fGjx/P6NGj+eijj4iLi+OWW24hOjoagH//+9/cf//9/Pzzz8TFxTFkyJCLGvdbmTQGtZJ1aRLIv3pb/0BM/GoracfznVyRiIjUWgaD9VZ7VW+lt+kdcffdd/Pll19y/PhxPvjgA6Kjo+nduzcAL730Eq+//jqPPfYYv/32GwkJCfTr14/CwsIK+61as2YNw4cP57rrruO7777j999/58knn6zQzyjr5O31kwwGA2Zz5S3q8/TTT/Pnn38ycOBAfv31V9q0acPXX38NwOjRo9m7dy933HEHW7dupUuXLrzxxhuVVsvFUECtAmPjWtAm3I9jeUU8/uVWLA4MJhcREamNhg4diouLC/Pnz2fevHncddddtvGoq1at4oYbbuD2228nJiaGpk2bsmvXrgu+duvWrdm/fz+HDx+27Vu7dq1dm9WrV9O4cWOefPJJunTpQvPmzdm3b59dG3d3d0pKzj1dZOvWrdmyZQu5uaeWOV+1ahUuLi60bNnygmt2xMnvt3//ftu+v/76i8zMTNq0aWPb16JFC8aNG8fPP//M4MGD+eCDD2zHIiMj+de//sVXX33Fww8/zDvvvFMptV4sBdQq4O7qwmvDOuBudOHXHWl8tmH/+U8SERGpxXx8fBg2bBgTJ07k8OHDjBo1ynasefPm/PLLL6xevZrt27dz33332T2hfj5xcXG0aNGCkSNHsmXLFlasWMGTTz5p16Z58+YkJyfz2WefsWfPHmbMmGHrYTypSZMmJCUlkZCQwJEjRygoKDjjs4YPH46HhwcjR45k27Zt/Pbbbzz44IPccccdttv7F6ukpISEhAS7bfv27cTFxdGuXTuGDx/O5s2bWb9+PSNGjKB379506dKFEydO8MADD7B06VL27dvHqlWr2LBhA61btwZg7Nix/PTTTyQlJbF582Z+++0327HqQgG1irQM8+WRftZ/SU397i/2ZeSe5wwREZHa7e677+bYsWP069fPbrzof/7zHzp16kS/fv3o06cPYWFh3HjjjRd8XRcXF77++mtOnDhBt27dGD16NM8995xdm3/84x+MGzeOBx54gA4dOrB69WomTZpk12bIkCH079+fvn37Ur9+/XKnuvLy8uKnn37i6NGjdO3alZtvvpmrr76amTNnOvabUY6cnBw6duxotw0aNAiDwcA333xDvXr1uPLKK4mLi6Np06YsWLAAAKPRSEZGBiNGjKBFixYMHTqUAQMGMGXKFMAafMeMGUPr1q3p378/LVq04M0337zkeiuSwVIL7jdnZ2fj7+9PVlaWw4Obq5LZbOG2d9ayLukonRvXY+F93TG6OD5uR6SuyyvKI3Z+LADr/rkOLwcf0BCpDfLz80lKSiIqKgoPDw9nlyNic7Y/m47kNfWgViEXFwOvDI3Bx+TKpn3HmLNsj7NLEhEREal2FFCrWMN6Xjw1yDqAefqSXfx5KMvJFYmIiIhULwqoTnBz54Zc2yaUohIL4xYkkF907icERUREROoSBVQnMBgMTBvcjmAfd3al5vDKzzudXZKIiIhItaGA6iRBPib+O9i6asO7K5NYuzfDyRWJiIiIVA8KqE4U1yaUYV0isVjg4YVbOJ5f5OySRERERJxOAdXJJg1qQ2SgJwczTzDl27+cXY6IiIiI0zkcUJcvX86gQYOIiIjAYDCwaNGic7YfNWoUBoPhjK1t27a2Nk8//fQZx1u1auXwl6mJfEyuvDq0AwYDfLHpAD/9meLskkREREScyuGAmpubS0xMDLNmzbqg9q+//jqHDx+2bfv37ycwMJBbbrnFrl3btm3t2q1cudLR0mqsrk0Cue/KaAAmfrWV9ONnLqUmIiIiUlc4HFAHDBjAs88+y0033XRB7f39/QkLC7NtGzdu5NixY9x555127VxdXe3aBQcHO1pajTbumua0CvPlaG4hE7/6g1qwwJeIiEitsXTpUgwGA5mZmc4u5ZI0adKE6dOnO7uM86ryMajvvfcecXFxNG7c2G7/7t27iYiIoGnTpgwfPpzk5OSzXqOgoIDs7Gy7raYzuRqZfmsH3I0uLNmexsKN+51dkoiISKVIT0/n/vvvp1GjRphMJsLCwujXrx+rVq2ytbmQYYQX6u+//8ZgMJCQkHBB7U7fbr/9dnr06MHhw4fx9/evkJrKU95nl92efvrpS/6MDRs2cO+99156sZXMtSo/7NChQ/z444/Mnz/fbn9sbCxz586lZcuWHD58mClTptCrVy+2bduGr6/vGdeZNm0aU6ZMqaqyq0yrMD8evrYF037cwTPf/kX3psE0CtIa4yIiUrsMGTKEwsJCPvzwQ5o2bUpqairx8fFkZFT8lIuFhYUOn7NkyRK7Z2U8PT1xd3cnLCysIks7w+HDh22vFyxYwOTJk9m589Rc6T4+Ppf8GfXr17/ka1SFKu1B/fDDDwkICODGG2+02z9gwABuueUW2rdvT79+/fjhhx/IzMxk4cKF5V5n4sSJZGVl2bb9+2tPb+PoXk3p1iSQ3MISxi9MoMSsW/0iInJhLBYLeUV5Vb45MiwtMzOTFStW8MILL9C3b18aN25Mt27dmDhxIv/4xz8A621ogJtuugmDwWB7v2fPHm644QZCQ0Px8fGha9euLFmyxO76TZo0YerUqYwYMQI/Pz/uvfdeoqKiAOjYsSMGg4E+ffqcs8agoCC7YYf+/v5n3OKfO3cuAQEB/PTTT7Ru3RofHx/69+9vFzIB3n33XVq3bo2HhwetWrXizTffPOvnnv6ZBoPB9n7OnDlcccUVdu2nT59u+70B64PpN954Iy+//DLh4eEEBQUxZswYiopOTWN5+i1+g8HAu+++y0033YSXlxfNmzfnf//7n93n/O9//6N58+Z4eHjQt29fPvzww0of7lBlPagWi4X333+fO+64A3d393O2DQgIoEWLFiQmJpZ73GQyYTKZKqNMpzO6GHhlaAz9py9n475jvL18L/f3iXZ2WSIiUgOcKD5B7PzYKv/cdf9ch5fbhd3x8/HxwcfHh0WLFnH55ZeX+/f5hg0bCAkJ4YMPPqB///4YjUYAcnJyuO6663juuecwmUzMmzePQYMGsXPnTho1amQ7/+WXX2by5Mk89dRTAIwZM4Zu3brZekbPl0MuVF5eHi+//DIfffQRLi4u3H777UyYMIFPPvkEgE8++YTJkyczc+ZMOnbsyO+//84999yDt7c3I0eOrJAaTvfbb78RHh7Ob7/9RmJiIsOGDaNDhw7cc889Zz1nypQpvPjii7z00ku88cYbDB8+nH379hEYGEhSUhI333wzDz30EKNHj+b3339nwoQJlVJ7WVXWg7ps2TISExO5++67z9s2JyeHPXv2EB4eXgWVVT+RgV48Nch6a+HVX3by16GaP8ZWREQErA9Fz50713ZXtWfPnjzxxBP88ccftjYnb0MHBAQQFhZmex8TE8N9993HZZddRvPmzZk6dSrR0dFn9PhdddVVPPzww0RHRxMdHW07/2TPaGBg4Dlr7NGjhy1I+/j48Pvvv5fbrqioiDlz5tClSxc6derEAw88QHx8vO34U089xSuvvMLgwYOJiopi8ODBjBs3jrfeesvx37gLVK9ePWbOnEmrVq24/vrrGThwoF1N5Rk1ahS33XYbzZo14/nnnycnJ4f169cD8NZbb9GyZUteeuklWrZsya233sqoUaMqrf6THO5BzcnJsevZTEpKIiEhgcDAQBo1asTEiRM5ePAg8+bNszvvvffeIzY2lssuu+yMa06YMIFBgwbRuHFjDh06xFNPPYXRaOS22267iK9UO9zSpSE//5XKku2pjF+YwDcP9MTkanR2WSIiUo15unqy7p/rnPK5jhgyZAgDBw5kxYoVrF27lh9//JEXX3yRd99995zhJycnh6effprvv/+ew4cPU1xczIkTJ854sLpLly4X8zVsFixYQOvWrW3vIyMjWbNmzRntvLy8iI4+dZczPDyctLQ0wDot5549e7j77rvtei+Li4sr9UGrtm3b2nqcT9a0devWc57Tvn1722tvb2/8/Pxs32Pnzp107drVrn23bt0qsOLyORxQN27cSN++fW3vx48fD8DIkSOZO3cuhw8fPuMPSlZWFl9++SWvv/56udc8cOAAt912GxkZGdSvX58rrriCtWvX1piBvJXBYDDw3yHt6PfaMXakHOfVn3cx8brW5z9RRETqLIPBcMG32p3Nw8ODa665hmuuuYZJkyYxevRonnrqqXMG1AkTJvDLL7/w8ssv06xZMzw9Pbn55pvPeBDK29v7kmqLjIykWbNm523n5uZm995gMNjG4+bk5ADwzjvvEBtrP+yibIC8UC4uLmeM9S07tvRcNZnN5nNe+2LOqWwOB9Q+ffqcczD03Llzz9jn7+9PXl7eWc/57LPPHC2jTgj2MTFtcDvu/WgTb6/Yy1WtQohtGuTsskRERCpcmzZt7KaVcnNzo6SkxK7NqlWrGDVqlG0u9pycHP7+++/zXvvkmNPTr1eZQkNDiYiIYO/evQwfPvySr1e/fn1SUlKwWCwYDAaA806bVRFatmzJDz/8YLdvw4YNlf65VT4Pqjjm2rZh3NK5IRYLPPz5Fo7nn/mvJRERkZoiIyODq666io8//pg//viDpKQkPv/8c1588UVuuOEGW7smTZoQHx9PSkoKx44dA6B58+Z89dVXJCQksGXLFv75z39eUE9fSEgInp6eLF68mNTUVLKysirt+5U1ZcoUpk2bxowZM9i1axdbt27lgw8+4NVXX3X4Wn369CE9PZ0XX3yRPXv2MGvWLH788cdKqNrefffdx44dO3jsscfYtWsXCxcutHVGngzKlUEBtQaYPKgNDet5cuDYCaZ+95ezyxEREbloPj4+xMbG8tprr3HllVdy2WWXMWnSJO655x5mzpxpa/fKK6/wyy+/EBkZSceOHQF49dVXqVevHj169GDQoEH069ePTp06nfczXV1dmTFjBm+99RYRERF2QbgyjR49mnfffZcPPviAdu3a0bt3b+bOnWub9soRrVu35s0332TWrFnExMSwfv36KnmaPioqii+++IKvvvqK9u3bM3v2bJ588kmASp1RyWCpBWtqZmdn4+/vT1ZWFn5+fs4up1KsTzrKsLfXYLHA23d05tq2lTtZsEh1lleUZ5tKx5HpbURqk/z8fJKSkoiKisLDw8PZ5Ugd8txzzzFnzpyzzkN/tj+bjuQ19aDWEN2iArm3V1MAJn61lSM5BU6uSEREROqCN998kw0bNrB3714++ugjXnrppUqbx/UkBdQaZPy1LWgV5ktGbiGPf7nVoZU7RERERC7G7t27ueGGG2jTpg1Tp07l4Ycf5umnn67Uz1RArUFMrkZeHdoBN6OBJdtT+XzjAWeXJCIiIrXca6+9xqFDh8jPz2fXrl1MmjQJV9fKXYxUAbWGaRPhx/hrWgIw5ds/2X/07NN3iYiIiNRECqg10L1XNqVrk3rkFpbw8MItlJh1q19EpK7ScC+pbiriz6QCag1kdDHwyi0d8HY3sv7vo7y7Yq+zSxIRkSp2cvWfcy2EI+IMJ/9Mnr5ClSMqdwCBVJpGQV5Mur4Nj3+1lVd+3sWVLerTOrx2TrElIiJnMhqNBAQE2NZM9/LyqtSJ00XOx2KxkJeXR1paGgEBARe1pOtJCqg12LCukSzZnsqS7WmMW5DANw/0xOR68X8YRESkZgkLs86JfTKkilQHAQEBtj+bF0sBtQYzGAxMG9yezdOXsyPlOK/9spvHB7RydlkiIlJFDAYD4eHhhISEUFSkpbDF+dzc3C6p5/QkBdQarr6viedvase/Pt7EW8v3cHXrELo2CXR2WSIiUoWMRmOFhAKR6kIPSdUC/S8L4+bODbFYYPzCBHIKip1dkoiIiMhFU0CtJZ4a1IYGAZ7sP3qCZ7/7y9nliIiIiFw0BdRawtfDjVeGxmAwwGcb9rPkr1RnlyQiIiJyURRQa5HLmwYx+oooAB7/6g8ycgqcXJGIiIiI4xRQa5mHr21Jy1BfjuQUMvGrrVphRERERGocBdRaxsPNyKvDYnAzGvj5r1S+2HTA2SWJiIiIOEQBtRZqG+HP2LgWAEz59i/2H9UyeCIiIlJzKKDWUv/qHU3nxvXIKShmwudbMJt1q19ERERqBgXUWsroYuDVoTF4uRtZl3SU91YmObskERERkQvicEBdvnw5gwYNIiIiAoPBwKJFi87ZfunSpRgMhjO2lJQUu3azZs2iSZMmeHh4EBsby/r16x0tTU7TOMib/wxsA8BLP+1kZ8pxJ1ckIiIicn4OB9Tc3FxiYmKYNWuWQ+ft3LmTw4cP27aQkBDbsQULFjB+/HieeuopNm/eTExMDP369SMtLc3R8uQ0t3WL5KpWIRSWmBm7IIHCYrOzSxIRERE5J4cD6oABA3j22We56aabHDovJCSEsLAw2+bicuqjX331Ve655x7uvPNO2rRpw5w5c/Dy8uL99993tDw5jcFg4L9D2lHPy43th7OZvmSXs0sSEREROacqG4PaoUMHwsPDueaaa1i1apVtf2FhIZs2bSIuLu5UUS4uxMXFsWbNmnKvVVBQQHZ2tt0mZxfi68G0we0AmLNsD5v2HXVyRSIiIiJnV+kBNTw8nDlz5vDll1/y5ZdfEhkZSZ8+fdi8eTMAR44coaSkhNDQULvzQkNDzxinetK0adPw9/e3bZGRkZX9NWq8/peFM7hTA8wWGLdgC7kFxc4uSURERKRclR5QW7ZsyX333Ufnzp3p0aMH77//Pj169OC111676GtOnDiRrKws27Z///4KrLj2evofbWkQ4Eny0Tye/f4vZ5cjIiIiUi6nTDPVrVs3EhMTAQgODsZoNJKammrXJjU1lbCwsHLPN5lM+Pn52W1yfn4ebrx0S3sAPl2/n/jtqec5Q0RERKTqOSWgJiQkEB4eDoC7uzudO3cmPj7edtxsNhMfH0/37t2dUV6t1iM6mLuviALgsS+3kpFT4OSKREREROy5OnpCTk6OrfcTICkpiYSEBAIDA2nUqBETJ07k4MGDzJs3D4Dp06cTFRVF27Ztyc/P59133+XXX3/l559/tl1j/PjxjBw5ki5dutCtWzemT59Obm4ud955ZwV8RTndI/1asnxXOrvTcnjy623Mvr0TBoPB2WWJiIiIABcRUDdu3Ejfvn1t78ePHw/AyJEjmTt3LocPHyY5Odl2vLCwkIcffpiDBw/i5eVF+/btWbJkid01hg0bRnp6OpMnTyYlJYUOHTqwePHiMx6ckorh4WbktWEduHHWKhb/mcJXmw8ypHNDZ5clIiIiAoDBYrHU+EXas7Oz8ff3Jysrq2rGo5pL4Lfnods94Fv+ONmaYOavu3n55134mlxZPO5KGgR4OrskkQuSV5RH7PxYANb9cx1ebl5OrkhERM7HkbzmlDGoNd6Sp2HFyzD3ejhe/lRYNcG/ekfTsVEAxwuKmbBwC2Zzjf+3ioiIiNQCCqgXo8td4NcQMnbDh4PgeM18Gt7V6MJrQzvg6WZkzd4M3l+V5OySRERERBRQL0pgFIz6zhpSj+yCD6+vsSG1SbA3Tw5sDcCLP+1kV+pxJ1ckIiIidZ0C6sU6I6TW3J7U4bGN6NOyPoXFZsYtSKCw2OzskkRERKQOU0C9FIFRMOpb8GsAR3ZaQ2pOmrOrcpjBYODFIe0J8HLjz0PZzIjf7eySREREpA5TQL1UgU1Le1JLQ+rc62tkSA3x8+D5m9oB8ObSRDbtO+rkikRERKSuUkCtCIFNYeS34BtRo3tSr2sXzk0dG2C2wPiFW8gtKHZ2SSIiIlIHKaBWlKBoa0+qbwSk7ygNqenOrsphT/+jLeH+HuzLyGPKt39q6ikRERGpcgqoFakWhFR/TzdeviUGgIUbDzD83XUcOJbn5KpERESkLlFArWi2kBoO6dth3j9qXEjt2SyYF4e0t82P2n/6ChZu3E8tWHRMREREagAF1MoQFA2jvreG1LS/rCE194izq3LI0K6R/PhQLzo3rkdOQTGPfvEH98zbRPrxAmeXJiIiIrWcAmplCYqGkd+BT5g1pH44qMaF1CbB3iy8rzuP9W+Fu9GFJdtT6Td9OT9uPezs0kRERKQWU0CtTMHNrD2ptpBa83pSjS4G7u8TzTcP9KRVmC9Hcwu5/5PNjFuQQNaJImeXJyIiIrWQAmplC25mHZPqEwZpf5aG1AxnV+Ww1uF+/O+BKxjTNxoXA3z9+0H6T1/Oit01a3ytiIiIVH8KqFUhuLl9SJ1XM0Oqu6sLj/Rrxef/6kGTIC8OZ+Vzx3vrmfzNNvIKNWeqiIiIVAwF1KpiC6mhkLqtxoZUgM6N6/HDQ70Y0b0xAPPW7OO611ewad8xJ1cmIiIitYECalUKbl764NTJkHoD5NXMJUW93F155obL+OjuboT5efB3Rh63zFnNi4t3UFhsdnZ5IiIiUoMpoFa1+i2sIdU7BFK3Wsek1tCQCtCreX1+Gnclg0uXSH1z6R5umLWK7YeznV2aiIiI1FAKqM5Qv4X1dv/JkDqvZodUf083Xh3WgdnDO1HPy43th7O5YeYqZi/dQ4mWShUREREHKaA6S/2WMPJba0hN2Vqjb/efNKBdOD+P601c61AKS8y8sHgHw95aw99Hcp1dmoiIiNQgCqjOFNKqNKTWh5Q/akVIre9r4p0RnXnp5vb4mFzZuO8YA15fwcdr92mpVBEREbkgCqjOFtKqdExq7QmpBoOBW7pEsnhsLy5vGsiJohL+s2gbIz/YQEpWvrPLExERkWpOAbU6ONmT6hVsDakf3VjjQypAw3pezB99OZOvb4PJ1YXlu9K59rVlfJNwUL2pIiIiclYOB9Tly5czaNAgIiIiMBgMLFq06Jztv/rqK6655hrq16+Pn58f3bt356effrJr8/TTT2MwGOy2Vq1aOVpazRbS2vrglFcwHN5iDaknav68oi4uBu66Iorv/92LmIb+ZOcX89BnCYyZv5mjuYXOLk9ERESqIYcDam5uLjExMcyaNeuC2i9fvpxrrrmGH374gU2bNtG3b18GDRrE77//bteubdu2HD582LatXLnS0dJqvpDWp3pSD2+BeTfWipAK0CzEhy/v78H4a1rg6mLgh60pXPvacuK3pzq7NBEREalmXB09YcCAAQwYMOCC20+fPt3u/fPPP88333zDt99+S8eOHU8V4upKWFjYBV2zoKCAgoIC2/vs7Fo052ZoG2tI/XAQHE6Aj26COxaBZ4CTC7t0rkYX/n11c/q2DGH8wgR2p+Vw94cbGdYlkv9c3xpfDzdnlygiIiLVQJWPQTWbzRw/fpzAwEC7/bt37yYiIoKmTZsyfPhwkpOTz3qNadOm4e/vb9siIyMru+yqdTKkegXBod9Lb/dnOruqCtOuoT/fPngF9/SKwmCABRv3M+D1FazdWzOXfhUREZGKVeUB9eWXXyYnJ4ehQ4fa9sXGxjJ37lwWL17M7NmzSUpKolevXhw/frzca0ycOJGsrCzbtn///qoqv+rU8pDq4WbkyYFt+Oyey2lYz5MDx05w2ztrefa7v8gvKnF2eSIiIuJEVRpQ58+fz5QpU1i4cCEhISG2/QMGDOCWW26hffv29OvXjx9++IHMzEwWLlxY7nVMJhN+fn52W60U2hZG/A88A0tD6k21KqQCxDYNYvHYK7m1ayQWC7y7Monr31jJHwcynV2aiIiIOEmVBdTPPvuM0aNHs3DhQuLi4s7ZNiAggBYtWpCYmFhF1VVjYZdZe1I9A+HQZvh4MORnObuqCuVjcuW/Q9rz/qgu1Pc1kZiWw01vrmb6kl0UlZidXZ6IiIhUsSoJqJ9++il33nknn376KQMHDjxv+5ycHPbs2UN4eHgVVFcDhF0GI0t7Ug9usvak1rKQCnBVq1B+HnslA9uFU2K2MH3JbobMXk1iWvlDPURERKR2cjig5uTkkJCQQEJCAgBJSUkkJCTYHmqaOHEiI0aMsLWfP38+I0aM4JVXXiE2NpaUlBRSUlLIyjoVsCZMmMCyZcv4+++/Wb16NTfddBNGo5HbbrvtEr9eLRLW7rSQWvt6UgHqebsz858def3WDvh7uvHHgSwGzljJeyuTMJs1ub+IiEhd4HBA3bhxIx07drRNETV+/Hg6duzI5MmTATh8+LDdE/hvv/02xcXFjBkzhvDwcNv20EMP2docOHCA2267jZYtWzJ06FCCgoJYu3Yt9evXv9TvV7vYQmo9OLix1oZUg8HADR0a8NPYK7myRX0Kis1M/e4v/vnuWvYfzXN2eSIiIlLJDJZasOZkdnY2/v7+ZGVl1d4Hpso6/AfM+4d1Ev+GXeH2r8Cjdn5vi8XC/PXJPPf9dvIKS/AxuTL5+jbc0qUhBoPB2eWJk+QV5RE7PxaAdf9ch5ebl5MrEhGR83Ekr1X5NFNSAcLbw4hvwCMADmwofXCqFi1WUIbBYGB4bGN+fKgXXRrXI6egmEe//IN75m0k7Xi+s8sTERGRSqCAWlOFx1hv99tC6pBaG1IBGgd5s+C+7jw+oBXuRheWbE+j32vL+WHrYWeXJiIiIhVMAbUmswup6+GTm6Gg9j7xbnQx8K/e0fzvwZ60CffjWF4R//fJZsZ+9jtZeUXOLk9EREQqiAJqTRcec+p2//511p7UWhxSAVqF+bFoTE8e6NsMFwMsSjhEv+nLWb4r3dmliYiISAVQQK0NIjqUhlT/OhNS3V1dmNCvJV/c34OoYG9SsvMZ8f56Ji3aRl5hsbPLExERkUuggFpbnBFSa/ft/pM6NarHD//uxcjujQH4aO0+rnt9BZv2HXVyZSIiInKxFFBrk4iOcMei0pC6Fj65pU6EVE93I1NuuIyP744l3N+DvzPyuGXOGl5YvIOC4hJnlyciIiIOUkCtbRp0soZUkz8krykNqTnOrqpKXNE8mMVjr2RwpwaYLTB76R5umLmK7Ydr7+wGIiIitZECam3UoBOMWFQnQ6q/pxuvDu3AnNs7E+jtzo6U4/xj5kreXJpIiZZKFRERqREUUGurBp1gxNelIXV1nQqpAP0vC+OnsVdyTZtQikosvLh4J7fMWU3SkVxnlyYiIiLnoYBamzXoDHd8DSY/a0idP7ROhdT6vibevqMzL98Sg6/Jlc3JmVz3+go+WvM3tWCFXxERkVpLAbW2a9i5dEyqH+xbZQ2phXWnF9FgMHBz54YsHnclPaKDOFFUwqRv/mTE++s5nHXC2eWJiIhIORRQ64KGZXpS962CT+pWSAVoEODJx3fH8vSgNphcXVix+wjXvracqd/9xY4UPUQlIiJSnSig1hUNu8DtX5WG1JUwf1idC6kuLgZG9Yzi+3/3IiYygOP5xby3Mon+01cw6I2VfLj6bzLzCp1dpoiISJ1nsNSCwXjZ2dn4+/uTlZWFn5+fs8up3vZvgI9ugsLj0KQX/HMBuHs7u6oqV2K2sHRnGl9sOsCS7akUlVj/M3A3uhDXJoRbOkfSq3kwrkb9G646yivKI3Z+LADr/rkOLzcvJ1ckIiLn40heU0Cti84IqQvBve7+BX80t5D/JRzk800H+PPQqdv9Ib4mburUgFs6N6RZiK8TK5TTKaCKiNQ8CqhyfvvXw0eDFVJP89ehbL7YdIBFCQc5mnvqdn+HyABu7tyQQTER+Hu6ObFCAQVUEZGaSAFVLkzyOvh4MBTmQNSVcNsChdRShcVmftuZxucbD/DbzjTbJP/uri70axvGLZ0b0rNZMEYXg5MrrZsUUEVEah4FVLlwdiG1N9z2mULqadKPF/BNwkE+33iAnanHbfvD/T0Y3KkBQzo1pGl9HydWWPcooIqI1DwKqOKYsiG1aR9rSHXzdHZV1Y7FYmHbwWy+2LSfb7YcIjOvyHasS+N63Ny5IQPbh+ProSEAlU0BVUSk5lFAFcclr4WPhyikXqCC4hLit6fx+cb9LNuVTukIADzcXBhwWTi3dG7I5U2DcNEQgEqhgCoiUvMooMrF2bfGGlKLchVSHZCWnc9Xvx/k84372ZN+am7ZBgGeDOnckJs7NaRRkAJURVJAFRGpeRzJaw5P8rh8+XIGDRpEREQEBoOBRYsWnfecpUuX0qlTJ0wmE82aNWPu3LlntJk1axZNmjTBw8OD2NhY1q9f72hpcqkad4fbvwQ3b9i71DoV1aEEZ1dV7YX4efCv3tEsGd+br/+vB8NjG+Hr4crBzBPMiN/NlS/9xrC31vDFpgPkFhQ7u1wREZFqz+GAmpubS0xMDLNmzbqg9klJSQwcOJC+ffuSkJDA2LFjGT16ND/99JOtzYIFCxg/fjxPPfUUmzdvJiYmhn79+pGWluZoeXKpGneH27+whtTkNfB2b5h/Kxz63dmVVXsGg4GOjerx3E3t2PBkHK/f2oFezYMxGGBd0lEmfL6Frs8t4ZHPt7Bubwa14OaFiIhIpbikW/wGg4Gvv/6aG2+88axtHnvsMb7//nu2bdtm23frrbeSmZnJ4sWLAYiNjaVr167MnDkTALPZTGRkJA8++CCPP/74eevQLf5KkLEHlr0AWz8Hi9m6r0V/6P0YNOjk3NpqmEOZJ/i6dAjA3xl5tv2NAr24uXNDhnRuSIMADaVwhG7xi4jUPJV6i99Ra9asIS4uzm5fv379WLNmDQCFhYVs2rTJro2LiwtxcXG2NqcrKCggOzvbbpMKFhQNg9+GMeuh/TAwuMCuxfBOX/hkKBzc5OwKa4yIAE/G9G3GbxP68MW/ujOsSyTe7kaSj+bx6i+7uOKFX7n93XUs+v0gJwpLnF2uiIiI01V6QE1JSSE0NNRuX2hoKNnZ2Zw4cYIjR45QUlJSbpuUlJRyrzlt2jT8/f1tW2RkZKXVX+cFNy8Nqhug/a3WoLr7J3jnKvjkFjigoHqhDAYDXZoE8sLN7dnwnzheHRpDj+ggLBZYmXiEsQsS6PbcEiZ+9Qeb9h3TEAAREamzKj2gVoaJEyeSlZVl2/bv3+/skmq/4GYw+C14YCPE3FYaVH+Gd6+Cj2+GAxudXWGN4uXuyuBODZl/z+WseLQv4+JaEBnoyfGCYj5dv58hs1dz9avLeHNpIilZ+c4uV0REpEq5VvYHhIWFkZqaarcvNTUVPz8/PD09MRqNGI3GctuEhYWVe02TyYTJZKq0muUcgqLhpjlw5SOw/GX4YwEk/mLdmsVB78chsquzq6xRIgO9eCiuOQ9e1Yz1fx/l840H+GHrYfam5/Li4p28/NNOejWvz82dG3JNm1A83IzOLllERKRSVXoPavfu3YmPj7fb98svv9C9e3cA3N3d6dy5s10bs9lMfHy8rY1UQ0HRcNNseGADdBgOBiMkLoH34uCjwbBf04Q5ysXFwOVNg3hlaAwb/hPHize3p1uTQMwWWLYrnQc//Z1uzy3hP4u2smV/poYAiIhIreVwD2pOTg6JiYm290lJSSQkJBAYGEijRo2YOHEiBw8eZN68eQD861//YubMmTz66KPcdddd/PrrryxcuJDvv//edo3x48czcuRIunTpQrdu3Zg+fTq5ubnceeedFfAVpVIFRcONb8KVE2D5K7DlU9gTb92ir4I+EyGym7OrrHF8TK4M7RLJ0C6R/H0kly83H+DLTQc4lJXPx2uT+XhtMi1Cfbi5c0Nu7NiAEF8PZ5csIiJSYRyeZmrp0qX07dv3jP0jR45k7ty5jBo1ir///pulS5fanTNu3Dj++usvGjZsyKRJkxg1apTd+TNnzuSll14iJSWFDh06MGPGDGJjYy+oJk0zVY0cTYIVL0PCp2ApfSK9aV9rUG10YT9PKZ/ZbGH1ngy+2LSfH7elUFBsnf7L6GKgTwvrEICrW4fi7lojh5Y7RNNMiYjUPFrqVJzvaBKsKO1RNZeuntS0T2lQvdyppdUG2flFfP/HYT7fuJ/NyZm2/fW83LihQwNu7tyQyxr4O6/ASqaAKiJS8yigSvVx7G9rUE2YfyqoRvW2BtXGGmNcERLTcvhy8wG+2nyA1OwC2/7W4X4MuCyM7tFBxDQMqFU9qwqoIiI1jwKqVD/H9pUG1U/KBNUrS4NqD+fWVkuUmC2s2J3O55sO8MufqRSWmG3HPN2MdI0KpEd0ED2ig2gb4Y/RxeDEai+NAqqISM2jgCrV17F9sPJV+P0TMBdZ9zXpZQ2qTXo6t7ZaJDOvkB+3pbBy9xHW7M3gaG6h3XFfD1cub2oNq92jg2gR4otLDQqsCqgiIjWPAqpUf5nJsOJV+P3j04Lq49DkCufWVsuYzRZ2pR1ndWIGq/dksG5vBscLiu3aBHm7c3lp72qP6GCaBHlhMFTfwKqAKiJS8yigSs2Rud/ao7r5o1NBtfEV1qAa1cu5tdVSxSVm/jyUzeo9GazZm8GGpKOcKCqxaxPu70H3ptbe1R7NgmkQ4OmkasungCoiUvMooErNk7kfVr4Gv38EJaW3oxtfAX0es/asVuPevJqusNjMlgOZpT2sR/g9OdNu/CpA4yCv0uEAwXRvGkR9X+eu5KaAKiJS8yigSs2VdcAaVDfPKxNUe0Lvx6wPVSmoVroThSVsTj7G6j1HWL0ngz8OZFFitv/fRPMQH1tgvbxpIAFe7lVaowKqiEjNo4AqNV/WwdKg+uGpoNqoh7VHNaq3gmoVOp5fxIa/j9rGsP51ONvuuMEAbSP86BEdTPfoILo2CcTH5PAidQ5RQBURqXkUUKX2yDoIq6bDprllgmp3a49q0z4Kqk5wLLeQdUnWsLp6TwaJaTl2x40uBmIa+tMjOpge0UF0alwPDzdjhdaggCoiUvMooErtk30IVk4vDaqlk9FHXm7tUW3aV0HVidKy81mzN8Paw7r3CPuPnrA77u7qQudG9awzBDQLon3DANyMl7ZogAKqiEjNo4AqtVf2YWuP6sYPygTVWGuPavRVCqrVwP6jeazZm8GaPdaHrsqubgXg5W6ka5NA25RWbSL8HF40QAFVRKTmUUCV2i/7MKx6HTZ9AMX51n0Nu1l7VKOvVlCtJiwWC3uP5LJ6TwZrS6e1On3RAD8PV2KbnpqDtUWoz3nnYFVAFRGpeRRQpe44nmINqhvfLxNUu0Lvx6GZgmp1YzZb2Jl63DoH654jrNt79IxFA4J93EtXubKOYW1czqIBCqgiIjWPAqrUPcdTYNUM2PjeqaDaoIt1wv9mcQqq1VRxiZlth7JtwwE2/H2U/CL7OVgj/D1KV7myBtaIAE8FVBGRGkgBVequ46mwegZseA+KSx/WadDZ2qPa/BoF1WquoLiELfuzbHOw/p58jKIS+/9FNQnyomtTHxbn3AUooIqI1BQKqCI5adZb/2WDakQna49q82sVVGuIE4UlbNx3tLSHNYM/DmRitgCGQnxbTQagUfZ0+rZoSJ+W9ekQGYDrJc4QICIilUMBVeSknDRrj+r6d8sE1Y7WHtUW/RRUa5js/CI2JB1leeJBvjo6EoDjO54Bi3UlKz8PV3q1qE/vFvXp06I+IX4ezixXRETKUEAVOV1Oeumt/3ehKM+6LzwG2g62jlENbauwWoOUHYM6sc3XrN6dzYrdR8g6UWTXrk24H71bWsNqp8b1Lnn+VRERuXgKqCJnk5MOa96A9e+cCqoAvuHWp/6bxVkn/vcMcFqJcn7lPSRVYraQsD+TZTvTWLYrnT8OZlH2/26+Jld6NgumT8v69G5Zn3B/TydVLyJSNymgipxP7hHY9iUkLoGkFadu/wMYjNapqprFWUNreAdwUc9bdXIhT/Fn5BSwfHc6y3ams3z3kTPmX20Z6msLq10aB+Luqp+xiEhlUkAVcURRPuxbBYnx1sB6ZKf9ca/gU72r0VeBd7Bz6hQbR6eZKjFb2Howi2U701m6K42E/Zl2vave7kZ6nOxdbVGfhvU0K4CISEVTQBW5FJnJ1qCaGA97l0JhTpmDButDVs3irFuDzmB0dValddalzoN6LLeQFYlHWLozjeW70jmSY9+72izEhz4trL2r3aICMbkaK6x2EZG6qtID6qxZs3jppZdISUkhJiaGN954g27dupXbtk+fPixbtuyM/ddddx3ff/89AKNGjeLDDz+0O96vXz8WL158QfUooEqlKS6E/etOBdbUrfbHPQIgum9p7+rV4BfulDLrmoqcqN9stvDX4WyW7kxj6c50Nicfs05lVcrTzUiP6KDSh61CaBSk3lURkYtRqQF1wYIFjBgxgjlz5hAbG8v06dP5/PPP2blzJyEhIWe0P3r0KIWFp3onMjIyiImJ4d1332XUqFGANaCmpqbywQcf2NqZTCbq1at3QTUpoEqVyT4Me0qHAuz5FfKz7I+Htjs1HCAyFlzdnVNnLVeZK0ll5RWxsrR3ddmudNKOF9gdbxrsTe/SoQCXNw3Cw029qyIiF6JSA2psbCxdu3Zl5syZAJjNZiIjI3nwwQd5/PHHz3v+9OnTmTx5MocPH8bb2xuwBtTMzEwWLVrkSCk2CqjiFCXFcHBTae/qEjj0O1DmPyd3X2ja+1RgDWjktFJrm6pa6tRisbD98HGW7irtXd13jOIy3asmVxe6RwdZ511tGUJUsHel1CEiUhtUWkAtLCzEy8uLL774ghtvvNG2f+TIkWRmZvLNN9+c9xrt2rWje/fuvP3227Z9o0aNYtGiRbi7u1OvXj2uuuoqnn32WYKCgsq9RkFBAQUFp3o1srOziYyMVEAV58o9Yu1VPTkcIO+I/fHglqdmBmjcE9w0ifzFqqqAerrs/CJWJx5h6c50lu1K53BWvt3xxkFepWHV2rvq5a7xySIiJzkSUB36v+eRI0coKSkhNDTUbn9oaCg7duw47/nr169n27ZtvPfee3b7+/fvz+DBg4mKimLPnj088cQTDBgwgDVr1mA0nnn7bNq0aUyZMsWR0kUqn3cwtB9q3cxmOJxwamaAA+utswMc2QlrZ4GrJ0T1OvWwVVC0s6uXC+Dn4Ub/y8Lpf1k4FouFXak5LCvtXd3w91H2ZeQxb80+5q3Zh7urC7FRgbbe1ej63hi0GISIyAVxqAf10KFDNGjQgNWrV9O9e3fb/kcffZRly5axbt26c55/3333sWbNGv74449zttu7dy/R0dEsWbKEq6+++ozj6kGVGufEMeuMACd7V48ftj9eL+pUWI3qBe66VXwuzupBPZecgmJWJx5h2a50lu5M52DmCbvjDet52sJqj+ggvE3qXRWRuqXSelCDg4MxGo2kpqba7U9NTSUsLOyc5+bm5vLZZ5/xzDPPnPdzmjZtSnBwMImJieUGVJPJhMlkcqR0EefyrAdtb7JuFguk/nlq7GryWjiWBBvesW5Gd2jc41Rgrd9Ky7DWAD4mV65tG8a1bcOwWCzsSc+xDQVYt/coB46d4JN1yXyyLhk3o4GuTQJL510NoUWoj3pXRUTKcCiguru707lzZ+Lj421jUM1mM/Hx8TzwwAPnPPfzzz+noKCA22+//byfc+DAATIyMggP15Q9UgsZDBB2mXW7YiwUHIek5dawunsJZCVbe1v3LoWf/wN+Dcssw9obPPyd/AXkfAwGA81CfGkW4svoXk3JKyxm7d4Mlu609q4mH81j9Z4MVu/J4PkfdhDh72GbGaBns2B8Pdyc/RVERJzqoqaZGjlyJG+99RbdunVj+vTpLFy4kB07dhAaGsqIESNo0KAB06ZNszuvV69eNGjQgM8++8xuf05ODlOmTGHIkCGEhYWxZ88eHn30UY4fP87WrVsvqKdUT/FLrWGxwJHdp3pX/14JJWWmOXJxtU5fdTKwhrark8uwVsdb/BfKYrHwd0aebd7VtXszKCg22467uhjo3Liebd7V1uG+6l0VkVqh0m7xAwwbNoz09HQmT55MSkoKHTp0YPHixbYHp5KTk3E57S/MnTt3snLlSn7++eczrmc0Gvnjjz/48MMPyczMJCIigmuvvZapU6fqNr7UPQYD1G9h3br/HxTmlS7DWhpYMxKt7/etgvhnwDvk1MwA0VeBV6Czv4Gch8FgICrYm6jgKO7sGUV+UYmtd3XZrnSSjuSyLuko65KO8uLinQT7mLiiWRA9mwXTq3l9wvw1+4OI1H5a6lSkJjmadOpBq6TlUJRb5qDBuvRq82usoTWiI7jUzknka3IP6vnsy8hl2a50lu1MZ/WeDE4UldgdbxbiwxXNgrmiWTCXRwfho4etRKSGqPSlTqsbBVSpk4oLIHnNqcCa9pf9cc9Aa2Ct3xJCWkP91taeWZOvc+qtQLU5oJZVUFzC5n2ZrExMZ2ViBlsPZNotw+rqYqBjowCuaFafK5oHEdMwAFdj3RvyISI1gwKqSF2UdeDUvKt7l0JBdvnt/COtMwOEtLL+Wr+1NcSafKq03EtRVwLq6bLyili95wgrE63bvow8u+O+Jlcujw6iV/NgejYLpmmw5l4VkepDAVWkrispsi69mroN0nZA+nZI3wk5qWc/pwYF17oaUE+3/2geK3YfYVXiEVbtOUJmXpHd8Qh/D65oHswVzevTMzqIIB+N6xcR51FAFZHy5R2F9B2QVhpY07dbA2xu2tnP8W9UOkzgZGht5fTgqoB6phKzhT8PZbFi9xFW7j7Cpn3HKCwx27VpE+5Hr+bBXNE8mK5NAvFwq51jlEWkelJAFRHH2AXXHaWvq29wVUA9vxOFJaz/+ygrd6ezYvcRdqQctzvu7upC1yb1uKJZfXo1D6ZNuB8uLhoOICKVRwFVRCrGxQbXkNKwWr+19XVwxQZXBVTHpR8vYPWeI7Ye1pTsfLvj9bzc6NEsmF7NrD2sDevp91REKpYCqohUrryjp4XW0iEDVRRcFVAvjXUp1lxW7k5nZeIR1uzJILfQfjqrJkFe1vGrzerTPToIf0+tbiUil0YBVUScIzejNLSWBtaTITY3/ezn2IJrq1MPaZ0nuCqgVqyiEjMJ+zNZuds6O0DC/kxKysxn5WKA9g0DrONXmwXTsVE93F01nZWIOEYBVUSqlwoOrgqolSs7v4i1ezJYlXiEFYlH2Juea3fcy91IbFQgVzS3jl9tHuKj6axE5LwUUEWkZigbXNN2nBoycK7gGtCIvOAWxJbsAmDdbWvxcveuooLrpoOZJ1hV2ru6KvEIGbmFdsdDfE3W1a1Ke1hD/LQcq4icSQFVRGq28wTXPIOB2CaRAKyjCV6DXofAps6suM4wmy1sT8m29q7uPsL6pKMUFNtPZ9Uy1JeezYLp1TyY2KaBeLlrOVYRUUB1djkiUllyMyB9O3mpW4nd8SYA6/7ej5fRBL0fhR7/BqMe5qlK+UUlbNp3zLZgwLZDWZT9W8XNaKBTo3q2Htb2DQMwajorkTpJAVVEajW7Mag0xitphfVASFsY9DpEdnVidXXb0dxC63Ksu609rAczT9gd9/NwpUd0MD2bW6e0ahzkpfGrInWEAqqI1Gp2AfW2tXht/xYWT4QTRwEDdB0NV08GD/3/wJksFgv7MvJYkXiElbvTWb0ng+P5xXZt/DxcaRTkRaNALyIDS3+tZ/01IsBTswWI1CIKqCJSq5X7FH9uBvz8JGz51NrINwKuexFaD3JipVJWcYmZrQezrL2riUf4PfkYRSVn/yvIxQDh/p40Kg2ujYLKhlhPAr3d1fsqUoMooIpIrXbOaab2LoXvxsHRvdb3ra6HAS+Cf4OqL1TOKb+ohOSjeSRn5JF8NI/9x/LYf9T6OvloHvlF5nOe7+1utAXW0wNsgwBPPNyMVfRNRORCOJLX9GiliNQuTfvA/ath+Uuw6nXY8R3sXWa95d/1bnBRaKkuPNyMtAj1pUWo7xnHLBYL6TkFpwJrxgm7EHs4K5/cwhJ2pBxnR8rxM843GCDU18Nu6ECjIE/b+/o+JvW+ilRj6kEVkRrngifqT/0Lvv03HNhgfd+gi/UhqrDLqqhSqSz5RSUczCwNrWV6YU++P33p1tN5uLnYxrue0QtbzwtPd/1DRqSiqQdVRAQgtA3c9TNsfA/in4GDG+Ht3tD9Aej9GLhrBaqaysPNSHR9H6Lrn7kkrsVi4VhekV1gLRtgD2edIL/IzK7UHHal5pR7/fq+JttYV/teWC9CfT1w0VRZIpVKPagiUuNc1FKn2Yfgx0dh+7fW9/WawPWvQfRVlVeoVEuFxWYOZZ5g/zH7Xtfko3nsy8g7Y6aB07kbXWgYeOrhrbK9sJGBnvh6aC5ekfKoB1VE5HR+ETDsY9jxA/wwAY79DR/dBO2HQb/nwTvY2RVKFXF3daFJsDdNgstfIjerTO/rye1AaZg9eOwEhSVm9qbnsjc9t9zzA73dbYG1YT1PQn1NhPp5EOrvQaifB/V9TJo+S+Q8FFBFpG5pdR1E9YJfn4V1b8EfC2D3z3Dtc9Dhn9ana6RO8/dyo52XP+0a+p9xrLjEzOGsfLvZBk72wO4/doKjuYW2bcv+zLN+RpC3OyF+HoT5WcNriJ8HoX4mQn09SsOsiSBvk1bdkjpLt/hFpMa5qFv85TmwCb59CFK3Wt836QXXT4fgZhVTqNQ5x/OL2H/01MNbBzNPkJqdX7oVkHY8/5xzv5ZldDFQ38dEqJ/JPsCW9sSefB/g5aYZCaRGqPRb/LNmzeKll14iJSWFmJgY3njjDbp161Zu27lz53LnnXfa7TOZTOTn59veWywWnnrqKd555x0yMzPp2bMns2fPpnnz5hdTnojIhWnYGe79DdbMgqX/hb9XwOwe0PsR6PEQuLo7u0KpYXw93GgT4UabiPL/8jWbLWSeKCIlK5/U4/mklQbXVLtf8zmSU0CJ2UJKdj4p2flA1lk/093VhRBfE2F+HqW9sSa7AHsy0PqYdNNUag6H/7QuWLCA8ePHM2fOHGJjY5k+fTr9+vVj586dhISElHuOn58fO3futL0//V96L774IjNmzODDDz8kKiqKSZMm0a9fP/766y88PDwcLVFE5MIZ3eCKsdDmBvh+POz51Xr7f+uX1impGsU6u0KpRVxcDAR6uxPo7U4bzt6DVFxiJiO38IzgWvZ92vECjuYWUlhs5sCxExw4duKcn+3tbrQLsGFlhxb4eRDqaz2mBQ6kOnD4Fn9sbCxdu3Zl5syZAJjNZiIjI3nwwQd5/PHHz2g/d+5cxo4dS2ZmZrnXs1gsRERE8PDDDzNhwgQAsrKyCA0NZe7cudx6663nrUm3+EXqlgq7xX86iwW2fgGLH4e8I9Z9Xe6Cq58Cz4CK+QyRClRQXEJa6dCBsj2xadnWHtqUrHzSsgs4XnDumQnKCvBys4XV0LIB1u/U0IJgHxNuRj3oJY6ptFv8hYWFbNq0iYkTJ9r2ubi4EBcXx5o1a856Xk5ODo0bN8ZsNtOpUyeef/552rZtC0BSUhIpKSnExcXZ2vv7+xMbG8uaNWvKDagFBQUUFBTY3mdnZzvyNUREymcwQPtboNnV8Msk+P1j2Pi+9cn/616E1v/QQ1RSrZhcrcu9Rgae+x9puQXFpB0/S09sdoEtzBYUm8nMKyIzr4idqWeu0HWSwQBB3tbxsYHe7vh5uhHg6UaAlxsBnu74e5187166zw0/Tzf1zsoFcyigHjlyhJKSEkJDQ+32h4aGsmPHjnLPadmyJe+//z7t27cnKyuLl19+mR49evDnn3/SsGFDUlJSbNc4/Zonj51u2rRpTJkyxZHSRUQunFcg3DAL2t8K342FjERYOAJaDICBL4N/Q2dXKOIQb5MrUSZXos4ytRZY72hm5xeXE2Ctr1NKX6cdL6DYbOFITgFHcgrOer3yeLi5EOBpDa3+pwXasu/tjnu54+1u1INgdUylj5ju3r073bt3t73v0aMHrVu35q233mLq1KkXdc2JEycyfvx42/vs7GwiIyMvuVYRETtRveBfq2DFK7DyNdj1IyQth6snQbd7wUW9QVJ7GAwG/D2twbBFqO9Z25nNFo7mFdp6XzNPFNp6XbNOFJGZV2j99UQRWXnWXzPzCjFbIL/ITErRyQe/LpyrS2ltZXtmbe/d8fd0JcDL/Yzjfp5umqqrhnIooAYHB2M0GklNTbXbn5qaSlhY2AVdw83NjY4dO5KYmAhgOy81NZXw8HC7a3bo0KHca5hMJkwmkyOli4hcHDcPuOpJuGyIdUqq/WutY1T/WGB9iCo8xtkVilQpFxcDwT7WcahtIy7sHLPZQk5hsTWw5hWReaI0xJYJtZl5ZUPtqfeFxWaKzRYycgvJyC10uF4/D1dbkD295/bke//ThiP4e7lhctU/QJ3JoYDq7u5O586diY+P58YbbwSsD0nFx8fzwAMPXNA1SkpK2Lp1K9dddx0AUVFRhIWFER8fbwuk2dnZrFu3jvvvv9+R8kREKk9IK7jzR9j8IfzyFBz6Hd7uC93HQJ/Hwf3st05F6joXFwN+Hm74ebgRGejYuflFJbZQe6qn9lSAzcwrIvvE6ceLyCl9MCw7v5js/GL2c+5ZDk7n6WYkwMsNXw9XfEyu+Hi44WMyWl+bSl97WF97m4yl7Upfm9zw8XDF22RU0L1IDt/iHz9+PCNHjqRLly5069aN6dOnk5uba5vrdMSIETRo0IBp06YB8Mwzz3D55ZfTrFkzMjMzeemll9i3bx+jR48GrLcUxo4dy7PPPkvz5s1t00xFRETYQrCISLXg4gJd7oSWA6y9qH9+DatnwF+LYOBr0DzuvJcQEcd4uBkJ8zcS5u/YtJNFJeYyvbSnemxP9dQW2gJu2ffZJ4owW+BEUQknsko4fPYpaC+Iu9HFFlZtwbacwHtGyD0t8HqbjLjWoZkTHA6ow4YNIz09ncmTJ5OSkkKHDh1YvHix7SGn5ORkXFxO/QYeO3aMe+65h5SUFOrVq0fnzp1ZvXo1bdq0sbV59NFHyc3N5d577yUzM5MrrriCxYsXaw5UEamefMPglrkQcxt8/zBkJsMnQ+Cym6H/NPApf05oEak6bkYX21AER5jNFo4XWIcjHMsrJKegmOP5xeQUFJNbUGx7f/J1TkExOWWOHy99f6KoBIDCEnPp8reAg724p/Nwc8HHZO3V9T5Lb+6ZAdit9Nip115uRlyq+dhcLXUqIjVOpc2DejEKcuC352HdbLCYwSMArp0KHe/QlFQidVhxiZncwpJTwbVsyM0vE25PC7nlBd7CYnOF12cNt9ag++TA1lzVKvT8J12iSl/qVERESpl8oP/z1vlT//dvSPkD/vcgbFkAg6ZDsJZsFqmLXI0u+Hu64O/pdsnXKiw22/fYniXQnt6La9fjW2jdV2y29kuebG+9fvXrq1RAFRGpCBEd4Z7frD2pvz0P+1bC7B7Qa4J1KVVXzTwiIhfH3dUFd1d36nm7X9J1LBYLBcXmM0Jt8xCfCqq04tSd0bYiIpXN6Ao9HoT/WwvNroGSQlj6PMy5AvatdnZ1IlLHGQwGPNyMBPuYaBLszWUN/Lm8aRBBDo7TrQoKqCIiFa1eYxj+Odz8PniHwJFd8MEA6xCAE8ecXZ2ISLWngCoiUhkMBuvk/g+sh04jrfs2fwgzu8G2L6HmP58qIlJpFFBFRCqTZz34xwzrJP/BLSA3Db64C+YPtU5PJSIiZ1BAFRGpCo17wL9WQp+JYHSH3T/DrFhYPRNKip1dnYhItaKAKiJSVVxN1mVR/7UKGveEojz4+Ul49yrr0qkiIgIooIqIVL36LWDkd/CPN6wT+x/eAu9cBT89aZ34X0SkjlNAFRFxBhcX6DQCHthgXSLVYoY1M+HNy2HXT86uTkTEqRRQRUScyScEbn4Phn8JAY0ga7/1AarPR8HxVGdXJyLiFFpJSkSkOmgeZ53gf+k0WPMm/Pk1JMZDw64QFA2B0dZfg6LBv5F1UQARkVpK/4cTEaku3L3h2meh3VD49t/WB6f2xFu3slzcrIsBlA2tJ1/7NbQOHxARqcEUUEVEqpvw9jA6Hg5ssK5ClbEHju6BjL3WX4vzISPRuu0+7VyjCQKjIKgZBDYtE16bgW+YdQEBEZFqTgFVRKQ6cjFCo8utW1lmMxw/VCa07jn1+mgSlBRA+g7rdjo379LQ2vRUaD0ZYL2DFV5FpNpQQBURqUlcXMC/oXVr2tv+mLnE+pBVRuKp3taMPdb3mclQlAupW63b6Ux+peG1mf2QgcCm4BVYNd9NRKSUAqqISG3hYoR6Taxbs9OOlRTBsX32ofXksIGs/VCQDYcTrNvpPAPPfFDr5GuTb6V/LRGpexRQRUTqAqMbBDezbqcryodjSfbDBo7utYbY44fhxFE4cNQ6JvZ03iFnhtbA0p5Xd6/K/14iUispoIqI1HVuHhDS2rqdrjC3NKye7HXdeyrI5qZDbpp1S15z5rl+DU57UKt03Gu9JtZlX0VEzkIBVUREzs7dG8LaWbfT5WeV6W092fuaaH2dnwnZB63b3yvszzOUjqMNjAavIGtYNbqDqwe4ultnIrD9Wt6xk/vKHjt9n8naVlNuidRICqgiInJxPPyhQSfrdrq8o2eG1pNjXguPWx/aykyu/Bpd3M4eXl1Lw+0lHzPZB+uyx1w9wM0L3Dw1S4KIAxRQRUSk4nkFWrfIrvb7LRbISSudFmsv5Gdbp8YqLiz9tXSz2+fgsbLMRVBYVHXf+6wM1t5oNy/r2Fw3b+t722uv0uMn93mBu0+Z195lzve232d0V/iVWueiAuqsWbN46aWXSElJISYmhjfeeINu3bqV2/add95h3rx5bNu2DYDOnTvz/PPP27UfNWoUH374od15/fr1Y/HixRdTnoiIVFcGA/iGWrfGPSr++haLdcYCu/Caf4FhtwBKCs9z7CzXOtuxksKThUFhjnXLreDvbDCeFlodDb3eZw/CRrcKLrYcZrP1HxIlhaU/u8Iyr8vZbz7L/rO1Lyly7Pqnt7dYrMNSXIzWP78GF+vvuW2fi/1mt+9kO5dy9p1sZzjL9Uo/r9zrVXAtTa6wrk5XjTgcUBcsWMD48eOZM2cOsbGxTJ8+nX79+rFz505CQkLOaL906VJuu+02evTogYeHBy+88ALXXnstf/75Jw0aNLC169+/Px988IHtvcmkAfQiIuIgg6H0Nrs7VIe/RswlUJQHhXnWeWgLc8u8zrO+P/m6KK80xJ58Xdr+5OvT950Mv5YS6zRhBdkVX7+L22mhtTTk2nqCvazfsWzIswuQhaeFwHICoaWk4usWx9wyt+YH1FdffZV77rmHO++8E4A5c+bw/fff8/777/P444+f0f6TTz6xe//uu+/y5ZdfEh8fz4gRI2z7TSYTYWFhjpYjIiJSfbkYrXPFVsZ8sSVFZYLr2UKvo6G49P3J0Ggusj7wlp9Z8fWflcE6ftfFzdqDa3Qv3U6+di1nnzu4nGX/pbR3cbX2MFrM1t8Ti8UayC3mMvvMpfss9vts+832m21f2Xbms1zTXHrd0/edpx67a15APT7VL385FFALCwvZtGkTEydOtO1zcXEhLi6ONWvKmWKkHHl5eRQVFREYaL8yydKlSwkJCaFevXpcddVVPPvsswQFBZV7jYKCAgoKTo0zys6uhH81ioiIVGdGN/AMsG4VyWKx9myW12t7MsDaQnFemaBXNlCeFixdzrK/vPYuxor9PlIjORRQjxw5QklJCaGhoXb7Q0ND2bGjnHWfy/HYY48RERFBXFycbV///v0ZPHgwUVFR7NmzhyeeeIIBAwawZs0ajMYz/6BOmzaNKVOmOFK6iIiIXAhDaQ+mqwnQMrfiHFX6FP9///tfPvvsM5YuXYqHh4dt/6233mp73a5dO9q3b090dDRLly7l6quvPuM6EydOZPz48bb32dnZREZGVm7xIiIiIlIlHJrBODg4GKPRSGpqqt3+1NTU844fffnll/nvf//Lzz//TPv27c/ZtmnTpgQHB5OYmFjucZPJhJ+fn90mIiIiIrWDQwHV3d2dzp07Ex8fb9tnNpuJj4+ne/fuZz3vxRdfZOrUqSxevJguXbqc93MOHDhARkYG4eHhjpQnIiIiIrWAw2vAjR8/nnfeeYcPP/yQ7du3c//995Obm2t7qn/EiBF2D1G98MILTJo0iffff58mTZqQkpJCSkoKOTk5AOTk5PDII4+wdu1a/v77b+Lj47nhhhto1qwZ/fr1q6CvKSIiIiI1hcNjUIcNG0Z6ejqTJ08mJSWFDh06sHjxYtuDU8nJybiUWft49uzZFBYWcvPNN9td56mnnuLpp5/GaDTyxx9/8OGHH5KZmUlERATXXnstU6dO1VyoIiIiInWQwWKxWJxdxKXKzs7G39+frKwsjUcVqQPyivKInR8LwLp/rsPLzcvJFYmIyPk4ktccvsUvIiIiIlKZFFBFREREpFpRQBURERGRakUBVURERESqlSpdSUpEpCJ4unqy7p/rbK9FRKR2UUAVkRrHYDDoyX0RkVpMt/hFREREpFpRQBURERGRakUBVURERESqFQVUEREREalWFFBFREREpFpRQBURERGRakUBVURERESqFQVUEREREalWFFBFREREpFqpFStJWSwWALKzs51ciYiIiIiU52ROO5nbzqVWBNTjx48DEBkZ6eRKRERERORcjh8/jr+//znbGCwXEmOrObPZzKFDh/D19cVgMFTJZ2ZnZxMZGcn+/fvx8/Orks+UiqOfX82nn2HNp59hzaefYc1W1T8/i8XC8ePHiYiIwMXl3KNMa0UPqouLCw0bNnTKZ/v5+ek/yhpMP7+aTz/Dmk8/w5pPP8OarSp/fufrOT1JD0mJiIiISLWigCoiIiIi1YoC6kUymUw89dRTmEwmZ5ciF0E/v5pPP8OaTz/Dmk8/w5qtOv/8asVDUiIiIiJSe6gHVURERESqFQVUEREREalWFFBFREREpFpRQBURERGRakUB9SLMmjWLJk2a4OHhQWxsLOvXr3d2SXKBpk2bRteuXfH19SUkJIQbb7yRnTt3OrssuUj//e9/MRgMjB071tmliAMOHjzI7bffTlBQEJ6enrRr146NGzc6uyy5QCUlJUyaNImoqCg8PT2Jjo5m6tSpF7S+ujjH8uXLGTRoEBERERgMBhYtWmR33GKxMHnyZMLDw/H09CQuLo7du3c7p9hSCqgOWrBgAePHj+epp55i8+bNxMTE0K9fP9LS0pxdmlyAZcuWMWbMGNauXcsvv/xCUVER1157Lbm5uc4uTRy0YcMG3nrrLdq3b+/sUsQBx44do2fPnri5ufHjjz/y119/8corr1CvXj1nlyYX6IUXXmD27NnMnDmT7du388ILL/Diiy/yxhtvOLs0OYvc3FxiYmKYNWtWucdffPFFZsyYwZw5c1i3bh3e3t7069eP/Pz8Kq70FE0z5aDY2Fi6du3KzJkzATCbzURGRvLggw/y+OOPO7k6cVR6ejohISEsW7aMK6+80tnlyAXKycmhU6dOvPnmmzz77LN06NCB6dOnO7ssuQCPP/44q1atYsWKFc4uRS7S9ddfT2hoKO+9955t35AhQ/D09OTjjz92YmVyIQwGA19//TU33ngjYO09jYiI4OGHH2bChAkAZGVlERoayty5c7n11ludUqd6UB1QWFjIpk2biIuLs+1zcXEhLi6ONWvWOLEyuVhZWVkABAYGOrkSccSYMWMYOHCg3X+LUjP873//o0uXLtxyyy2EhITQsWNH3nnnHWeXJQ7o0aMH8fHx7Nq1C4AtW7awcuVKBgwY4OTK5GIkJSWRkpJi9/9Tf39/YmNjnZptXJ32yTXQkSNHKCkpITQ01G5/aGgoO3bscFJVcrHMZjNjx46lZ8+eXHbZZc4uRy7QZ599xubNm9mwYYOzS5GLsHfvXmbPns348eN54okn2LBhA//+979xd3dn5MiRzi5PLsDjjz9OdnY2rVq1wmg0UlJSwnPPPcfw4cOdXZpchJSUFIBys83JY86ggCp11pgxY9i2bRsrV650dilygfbv389DDz3EL7/8goeHh7PLkYtgNpvp0qULzz//PAAdO3Zk27ZtzJkzRwG1hli4cCGffPIJ8+fPp23btiQkJDB27FgiIiL0M5QKo1v8DggODsZoNJKammq3PzU1lbCwMCdVJRfjgQce4LvvvuO3336jYcOGzi5HLtCmTZtIS0ujU6dOuLq64urqyrJly5gxYwaurq6UlJQ4u0Q5j/DwcNq0aWO3r3Xr1iQnJzupInHUI488wuOPP86tt95Ku3btuOOOOxg3bhzTpk1zdmlyEU7ml+qWbRRQHeDu7k7nzp2Jj4+37TObzcTHx9O9e3cnViYXymKx8MADD/D111/z66+/EhUV5eySxAFXX301W7duJSEhwbZ16dKF4cOHk5CQgNFodHaJch49e/Y8Y2q3Xbt20bhxYydVJI7Ky8vDxcU+PhiNRsxms5MqkksRFRVFWFiYXbbJzs5m3bp1Ts02usXvoPHjxzNy5Ei6dOlCt27dmD59Orm5udx5553OLk0uwJgxY5g/fz7ffPMNvr6+tvE1/v7+eHp6Ork6OR9fX98zxgt7e3sTFBSkccQ1xLhx4+jRowfPP/88Q4cOZf369bz99tu8/fbbzi5NLtCgQYN47rnnaNSoEW3btuX333/n1Vdf5a677nJ2aXIWOTk5JCYm2t4nJSWRkJBAYGAgjRo1YuzYsTz77LM0b96cqKgoJk2aREREhO1Jf6ewiMPeeOMNS6NGjSzu7u6Wbt26WdauXevskuQCAeVuH3zwgbNLk4vUu3dvy0MPPeTsMsQB3377reWyyy6zmEwmS6tWrSxvv/22s0sSB2RnZ1seeughS6NGjSweHh6Wpk2bWp588klLQUGBs0uTs/jtt9/K/btv5MiRFovFYjGbzZZJkyZZQkNDLSaTyXL11Vdbdu7c6dSaNQ+qiIiIiFQrGoMqIiIiItWKAqqIiIiIVCsKqCIiIiJSrSigioiIiEi1ooAqIiIiItWKAqqIiIiIVCsKqCIiIiJSrSigioiIiEi1ooAqIlKLLF26FIPBQGZmprNLERG5aAqoIiIiIlKtKKCKiIiISLWigCoiUoHMZjPTpk0jKioKT09PYmJi+OKLL4BTt9+///572rdvj4eHB5dffjnbtm2zu8aXX35J27ZtMZlMNGnShFdeecXueEFBAY899hiRkZGYTCaaNWvGe++9Z9dm06ZNdOnSBS8vL3r06MHOnTsr94uLiFQgBVQRkQo0bdo05s2bx5w5c/jzzz8ZN24ct99+O8uWLbO1eeSRR3jllVfYsGED9evXZ9CgQRQVFQHWYDl06FBuvfVWtm7dytNPP82kSZOYO3eu7fwRI0bw6aefMmPGDLZv385bb72Fj4+PXR1PPvkkr7zyChs3bsTV1ZW77rqrSr6/iEhFMFgsFouzixARqQ0KCgoIDAxkyZIldO/e3bZ/9OjR5OXlce+999K3b18+++wzhg0bBsDRo0dp2LAhc+fOZejQoQwfPpz09HR+/vln2/mPPvoo33//PX/++Se7du2iZcuW/PLLL8TFxZ1Rw9KlS+nbty9Llizh6quvBuCHH35g4MCBnDhxAg8Pj0r+XRARuXTqQRURqSCJiYnk5eVxzTXX4OPjY9vmzZvHnj17bO3KhtfAwEBatmzJ9u3bAdi+fTs9e/a0u27Pnj3ZvXs3JSUlJCQkYDQa6d279zlrad++ve11eHg4AGlpaZf8HUVEqoKrswsQEaktcnJyAPj+++9p0KCB3TGTyWQXUi+Wp6fnBbVzc3OzvTYYDIB1fKyISE2gHlQRkQrSpk0bTCYTycnJNGvWzG6LjIy0tVu7dq3t9bFjx9i1axetW7cGoHXr1qxatcruuqtWraJFixYYjUbatWuH2Wy2G9MqIlLbqAdVRKSC+Pr6MmHCBMaNG4fZbOaKK64gKyuLVatW4efnR+PGjQF45plnCAoKIjQ0lCeffJLg4GBuvPFGAB5++GG6du3K1KlTGTZsGGvWrGHmzJm8+eabADRp0oSRI0dy1113MWPGDGJiYti3bx9paWkMHTrUWV9dRKRCKaCKiFSgqVOnUr9+faZNm8bevXsJCAigU6dOPPHEE7Zb7P/973956KGH2L17Nx06dODbb7/F3d0dgE6dOrFw4UImT57M1KlTCQ8P55lnnmHUqFG2z5g9ezZPPPEE//d//0dGRgaNGjXiiSeecMbXFRGpFHqKX0Skipx8wv7YsWMEBAQ4uxwRkWpLY1BFREREpFpRQBURERGRakW3+EVERESkWlEPqoiIiIhUKwqoIiIiIlKtKKCKiIiISLWigCoiIiIi1YoCqoiIiIhUKwqoIiIiIlKtKKCKiIiISLWigCoiIiIi1cr/A90pIjqaDXIhAAAAAElFTkSuQmCC\n" }, "metadata": {} } @@ -5705,7 +5753,253 @@ }, { "cell_type": "code", - "execution_count": 71, + "source": [ + "%tensorboard --logdir logs/fit" + ], + "metadata": { + "colab": { + "resources": { + "https://localhost:6006/?tensorboardColab=true": { + "data": "<!doctype html><meta name="tb-relative-root" content="./"><!doctype html><!--
@license
Copyright 2019 The TensorFlow Authors. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
--><html><head><meta charset="utf-8">
<title>TensorBoard</title>
<link rel="shortcut icon" href="data:image/png;base64,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">
<link rel="apple-touch-icon" href="data:image/png;base64,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">

<style>
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto'), local('Roboto-Regular'), url(/font-roboto/uYECMKoHcO9x1wdmbyHIm3-_kf6ByYO6CLYdB4HQE-Y.woff2) format('woff2');
  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto'), local('Roboto-Regular'), url(/font-roboto/sTdaA6j0Psb920Vjv-mrzH-_kf6ByYO6CLYdB4HQE-Y.woff2) format('woff2');
  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto'), local('Roboto-Regular'), url(/font-roboto/_VYFx-s824kXq_Ul2BHqYH-_kf6ByYO6CLYdB4HQE-Y.woff2) format('woff2');
  unicode-range: U+0370-03FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto'), local('Roboto-Regular'), url(/font-roboto/tnj4SB6DNbdaQnsM8CFqBX-_kf6ByYO6CLYdB4HQE-Y.woff2) format('woff2');
  unicode-range: U+1F00-1FFF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto'), local('Roboto-Regular'), url(/font-roboto/oMMgfZMQthOryQo9n22dcuvvDin1pK8aKteLpeZ5c0A.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto'), local('Roboto-Regular'), url(/font-roboto/Ks_cVxiCiwUWVsFWFA3Bjn-_kf6ByYO6CLYdB4HQE-Y.woff2) format('woff2');
  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto'), local('Roboto-Regular'), url(/font-roboto/NJ4vxlgWwWbEsv18dAhqnn-_kf6ByYO6CLYdB4HQE-Y.woff2) format('woff2');
  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Bold'), local('Roboto-Bold'), url(/font-roboto/isZ-wbCXNKAbnjo6_TwHToX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Bold'), local('Roboto-Bold'), url(/font-roboto/77FXFjRbGzN4aCrSFhlh3oX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Bold'), local('Roboto-Bold'), url(/font-roboto/jSN2CGVDbcVyCnfJfjSdfIX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0370-03FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Bold'), local('Roboto-Bold'), url(/font-roboto/UX6i4JxQDm3fVTc1CPuwqoX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+1F00-1FFF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Bold'), local('Roboto-Bold'), url(/font-roboto/d-6IYplOFocCacKzxwXSOJBw1xU1rKptJj_0jans920.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Bold'), local('Roboto-Bold'), url(/font-roboto/97uahxiqZRoncBaCEI3aW4X0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Bold'), local('Roboto-Bold'), url(/font-roboto/PwZc-YbIL414wB9rB1IAPYX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 700;
  src: local('Roboto Bold Italic'), local('Roboto-BoldItalic'), url(/font-roboto/t6Nd4cfPRhZP44Q5QAjcC14sYYdJg5dU2qzJEVSuta0.woff2) format('woff2');
  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 700;
  src: local('Roboto Bold Italic'), local('Roboto-BoldItalic'), url(/font-roboto/t6Nd4cfPRhZP44Q5QAjcC_ZraR2Tg8w2lzm7kLNL0-w.woff2) format('woff2');
  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 700;
  src: local('Roboto Bold Italic'), local('Roboto-BoldItalic'), url(/font-roboto/t6Nd4cfPRhZP44Q5QAjcCwt_Rm691LTebKfY2ZkKSmI.woff2) format('woff2');
  unicode-range: U+0370-03FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 700;
  src: local('Roboto Bold Italic'), local('Roboto-BoldItalic'), url(/font-roboto/t6Nd4cfPRhZP44Q5QAjcC1BW26QxpSj-_ZKm_xT4hWw.woff2) format('woff2');
  unicode-range: U+1F00-1FFF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 700;
  src: local('Roboto Bold Italic'), local('Roboto-BoldItalic'), url(/font-roboto/t6Nd4cfPRhZP44Q5QAjcC4gp9Q8gbYrhqGlRav_IXfk.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 700;
  src: local('Roboto Bold Italic'), local('Roboto-BoldItalic'), url(/font-roboto/t6Nd4cfPRhZP44Q5QAjcC6E8kM4xWR1_1bYURRojRGc.woff2) format('woff2');
  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 700;
  src: local('Roboto Bold Italic'), local('Roboto-BoldItalic'), url(/font-roboto/t6Nd4cfPRhZP44Q5QAjcC9DiNsR5a-9Oe_Ivpu8XWlY.woff2) format('woff2');
  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 400;
  src: local('Roboto Italic'), local('Roboto-Italic'), url(/font-roboto/OpXUqTo0UgQQhGj_SFdLWBkAz4rYn47Zy2rvigWQf6w.woff2) format('woff2');
  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 400;
  src: local('Roboto Italic'), local('Roboto-Italic'), url(/font-roboto/WxrXJa0C3KdtC7lMafG4dRkAz4rYn47Zy2rvigWQf6w.woff2) format('woff2');
  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 400;
  src: local('Roboto Italic'), local('Roboto-Italic'), url(/font-roboto/cDKhRaXnQTOVbaoxwdOr9xkAz4rYn47Zy2rvigWQf6w.woff2) format('woff2');
  unicode-range: U+0370-03FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 400;
  src: local('Roboto Italic'), local('Roboto-Italic'), url(/font-roboto/1hZf02POANh32k2VkgEoUBkAz4rYn47Zy2rvigWQf6w.woff2) format('woff2');
  unicode-range: U+1F00-1FFF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 400;
  src: local('Roboto Italic'), local('Roboto-Italic'), url(/font-roboto/vPcynSL0qHq_6dX7lKVByXYhjbSpvc47ee6xR_80Hnw.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 400;
  src: local('Roboto Italic'), local('Roboto-Italic'), url(/font-roboto/vSzulfKSK0LLjjfeaxcREhkAz4rYn47Zy2rvigWQf6w.woff2) format('woff2');
  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 400;
  src: local('Roboto Italic'), local('Roboto-Italic'), url(/font-roboto/K23cxWVTrIFD6DJsEVi07RkAz4rYn47Zy2rvigWQf6w.woff2) format('woff2');
  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 300;
  src: local('Roboto Light'), local('Roboto-Light'), url(/font-roboto/Fl4y0QdOxyyTHEGMXX8kcYX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 300;
  src: local('Roboto Light'), local('Roboto-Light'), url(/font-roboto/0eC6fl06luXEYWpBSJvXCIX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 300;
  src: local('Roboto Light'), local('Roboto-Light'), url(/font-roboto/I3S1wsgSg9YCurV6PUkTOYX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0370-03FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 300;
  src: local('Roboto Light'), local('Roboto-Light'), url(/font-roboto/-L14Jk06m6pUHB-5mXQQnYX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+1F00-1FFF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 300;
  src: local('Roboto Light'), local('Roboto-Light'), url(/font-roboto/Hgo13k-tfSpn0qi1SFdUfZBw1xU1rKptJj_0jans920.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 300;
  src: local('Roboto Light'), local('Roboto-Light'), url(/font-roboto/Pru33qjShpZSmG3z6VYwnYX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 300;
  src: local('Roboto Light'), local('Roboto-Light'), url(/font-roboto/NYDWBdD4gIq26G5XYbHsFIX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 300;
  src: local('Roboto Light Italic'), local('Roboto-LightItalic'), url(/font-roboto/7m8l7TlFO-S3VkhHuR0at14sYYdJg5dU2qzJEVSuta0.woff2) format('woff2');
  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 300;
  src: local('Roboto Light Italic'), local('Roboto-LightItalic'), url(/font-roboto/7m8l7TlFO-S3VkhHuR0at_ZraR2Tg8w2lzm7kLNL0-w.woff2) format('woff2');
  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 300;
  src: local('Roboto Light Italic'), local('Roboto-LightItalic'), url(/font-roboto/7m8l7TlFO-S3VkhHuR0atwt_Rm691LTebKfY2ZkKSmI.woff2) format('woff2');
  unicode-range: U+0370-03FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 300;
  src: local('Roboto Light Italic'), local('Roboto-LightItalic'), url(/font-roboto/7m8l7TlFO-S3VkhHuR0at1BW26QxpSj-_ZKm_xT4hWw.woff2) format('woff2');
  unicode-range: U+1F00-1FFF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 300;
  src: local('Roboto Light Italic'), local('Roboto-LightItalic'), url(/font-roboto/7m8l7TlFO-S3VkhHuR0at4gp9Q8gbYrhqGlRav_IXfk.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 300;
  src: local('Roboto Light Italic'), local('Roboto-LightItalic'), url(/font-roboto/7m8l7TlFO-S3VkhHuR0at6E8kM4xWR1_1bYURRojRGc.woff2) format('woff2');
  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 300;
  src: local('Roboto Light Italic'), local('Roboto-LightItalic'), url(/font-roboto/7m8l7TlFO-S3VkhHuR0at9DiNsR5a-9Oe_Ivpu8XWlY.woff2) format('woff2');
  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 500;
  src: local('Roboto Medium'), local('Roboto-Medium'), url(/font-roboto/oHi30kwQWvpCWqAhzHcCSIX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 500;
  src: local('Roboto Medium'), local('Roboto-Medium'), url(/font-roboto/ZLqKeelYbATG60EpZBSDy4X0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 500;
  src: local('Roboto Medium'), local('Roboto-Medium'), url(/font-roboto/mx9Uck6uB63VIKFYnEMXrYX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0370-03FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 500;
  src: local('Roboto Medium'), local('Roboto-Medium'), url(/font-roboto/rGvHdJnr2l75qb0YND9NyIX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+1F00-1FFF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 500;
  src: local('Roboto Medium'), local('Roboto-Medium'), url(/font-roboto/RxZJdnzeo3R5zSexge8UUZBw1xU1rKptJj_0jans920.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 500;
  src: local('Roboto Medium'), local('Roboto-Medium'), url(/font-roboto/oOeFwZNlrTefzLYmlVV1UIX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 500;
  src: local('Roboto Medium'), local('Roboto-Medium'), url(/font-roboto/mbmhprMH69Zi6eEPBYVFhYX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 500;
  src: local('Roboto Medium Italic'), local('Roboto-MediumItalic'), url(/font-roboto/OLffGBTaF0XFOW1gnuHF0V4sYYdJg5dU2qzJEVSuta0.woff2) format('woff2');
  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 500;
  src: local('Roboto Medium Italic'), local('Roboto-MediumItalic'), url(/font-roboto/OLffGBTaF0XFOW1gnuHF0fZraR2Tg8w2lzm7kLNL0-w.woff2) format('woff2');
  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 500;
  src: local('Roboto Medium Italic'), local('Roboto-MediumItalic'), url(/font-roboto/OLffGBTaF0XFOW1gnuHF0Qt_Rm691LTebKfY2ZkKSmI.woff2) format('woff2');
  unicode-range: U+0370-03FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 500;
  src: local('Roboto Medium Italic'), local('Roboto-MediumItalic'), url(/font-roboto/OLffGBTaF0XFOW1gnuHF0VBW26QxpSj-_ZKm_xT4hWw.woff2) format('woff2');
  unicode-range: U+1F00-1FFF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 500;
  src: local('Roboto Medium Italic'), local('Roboto-MediumItalic'), url(/font-roboto/OLffGBTaF0XFOW1gnuHF0Ygp9Q8gbYrhqGlRav_IXfk.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 500;
  src: local('Roboto Medium Italic'), local('Roboto-MediumItalic'), url(/font-roboto/OLffGBTaF0XFOW1gnuHF0aE8kM4xWR1_1bYURRojRGc.woff2) format('woff2');
  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 500;
  src: local('Roboto Medium Italic'), local('Roboto-MediumItalic'), url(/font-roboto/OLffGBTaF0XFOW1gnuHF0dDiNsR5a-9Oe_Ivpu8XWlY.woff2) format('woff2');
  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto Mono'), local('RobotoMono-Regular'), url(/font-roboto/hMqPNLsu_dywMa4C_DEpY14sYYdJg5dU2qzJEVSuta0.woff2) format('woff2');
  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto Mono'), local('RobotoMono-Regular'), url(/font-roboto/hMqPNLsu_dywMa4C_DEpY_ZraR2Tg8w2lzm7kLNL0-w.woff2) format('woff2');
  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto Mono'), local('RobotoMono-Regular'), url(/font-roboto/hMqPNLsu_dywMa4C_DEpYwt_Rm691LTebKfY2ZkKSmI.woff2) format('woff2');
  unicode-range: U+0370-03FF;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto Mono'), local('RobotoMono-Regular'), url(/font-roboto/hMqPNLsu_dywMa4C_DEpY1BW26QxpSj-_ZKm_xT4hWw.woff2) format('woff2');
  unicode-range: U+1F00-1FFF;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto Mono'), local('RobotoMono-Regular'), url(/font-roboto/hMqPNLsu_dywMa4C_DEpY4gp9Q8gbYrhqGlRav_IXfk.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto Mono'), local('RobotoMono-Regular'), url(/font-roboto/hMqPNLsu_dywMa4C_DEpY6E8kM4xWR1_1bYURRojRGc.woff2) format('woff2');
  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto Mono'), local('RobotoMono-Regular'), url(/font-roboto/hMqPNLsu_dywMa4C_DEpY9DiNsR5a-9Oe_Ivpu8XWlY.woff2) format('woff2');
  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Mono Bold'), local('RobotoMono-Bold'), url(/font-roboto/N4duVc9C58uwPiY8_59Fz1x-M1I1w5OMiqnVF8xBLhU.woff2) format('woff2');
  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Mono Bold'), local('RobotoMono-Bold'), url(/font-roboto/N4duVc9C58uwPiY8_59FzwXaAXup5mZlfK6xRLrhsco.woff2) format('woff2');
  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Mono Bold'), local('RobotoMono-Bold'), url(/font-roboto/N4duVc9C58uwPiY8_59Fzwn6Wqxo-xwxilDXPU8chVU.woff2) format('woff2');
  unicode-range: U+0370-03FF;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Mono Bold'), local('RobotoMono-Bold'), url(/font-roboto/N4duVc9C58uwPiY8_59Fz1T7aJLK6nKpn36IMwTcMMc.woff2) format('woff2');
  unicode-range: U+1F00-1FFF;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Mono Bold'), local('RobotoMono-Bold'), url(/font-roboto/N4duVc9C58uwPiY8_59Fz_79_ZuUxCigM2DespTnFaw.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Mono Bold'), local('RobotoMono-Bold'), url(/font-roboto/N4duVc9C58uwPiY8_59Fz4gd9OEPUCN3AdYW0e8tat4.woff2) format('woff2');
  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Mono Bold'), local('RobotoMono-Bold'), url(/font-roboto/N4duVc9C58uwPiY8_59Fz8bIQSYZnWLaWC9QNCpTK_U.woff2) format('woff2');
  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;
}
</style>



<style>.mat-ripple{overflow:hidden;position:relative}.mat-ripple:not(:empty){transform:translateZ(0)}.mat-ripple.mat-ripple-unbounded{overflow:visible}.mat-ripple-element{position:absolute;border-radius:50%;pointer-events:none;transition:opacity,transform 0ms cubic-bezier(0, 0, 0.2, 1);transform:scale3d(0, 0, 0)}.cdk-high-contrast-active .mat-ripple-element{display:none}.cdk-visually-hidden{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;white-space:nowrap;outline:0;-webkit-appearance:none;-moz-appearance:none;left:0}[dir=rtl] .cdk-visually-hidden{left:auto;right:0}.cdk-overlay-container,.cdk-global-overlay-wrapper{pointer-events:none;top:0;left:0;height:100%;width:100%}.cdk-overlay-container{position:fixed;z-index:1000}.cdk-overlay-container:empty{display:none}.cdk-global-overlay-wrapper{display:flex;position:absolute;z-index:1000}.cdk-overlay-pane{position:absolute;pointer-events:auto;box-sizing:border-box;z-index:1000;display:flex;max-width:100%;max-height:100%}.cdk-overlay-backdrop{position:absolute;top:0;bottom:0;left:0;right:0;z-index:1000;pointer-events:auto;-webkit-tap-highlight-color:rgba(0,0,0,0);transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1);opacity:0}.cdk-overlay-backdrop.cdk-overlay-backdrop-showing{opacity:1}.cdk-high-contrast-active .cdk-overlay-backdrop.cdk-overlay-backdrop-showing{opacity:.6}.cdk-overlay-dark-backdrop{background:rgba(0,0,0,.32)}.cdk-overlay-transparent-backdrop{transition:visibility 1ms linear,opacity 1ms linear;visibility:hidden;opacity:1}.cdk-overlay-transparent-backdrop.cdk-overlay-backdrop-showing{opacity:0;visibility:visible}.cdk-overlay-backdrop-noop-animation{transition:none}.cdk-overlay-connected-position-bounding-box{position:absolute;z-index:1000;display:flex;flex-direction:column;min-width:1px;min-height:1px}.cdk-global-scrollblock{position:fixed;width:100%;overflow-y:scroll}textarea.cdk-textarea-autosize{resize:none}textarea.cdk-textarea-autosize-measuring{padding:2px 0 !important;box-sizing:content-box !important;height:auto !important;overflow:hidden !important}textarea.cdk-textarea-autosize-measuring-firefox{padding:2px 0 !important;box-sizing:content-box !important;height:0 !important}@keyframes cdk-text-field-autofill-start{/*!*/}@keyframes cdk-text-field-autofill-end{/*!*/}.cdk-text-field-autofill-monitored:-webkit-autofill{animation:cdk-text-field-autofill-start 0s 1ms}.cdk-text-field-autofill-monitored:not(:-webkit-autofill){animation:cdk-text-field-autofill-end 0s 1ms}.mat-focus-indicator{position:relative}.mat-focus-indicator::before{top:0;left:0;right:0;bottom:0;position:absolute;box-sizing:border-box;pointer-events:none;display:var(--mat-focus-indicator-display, none);border:var(--mat-focus-indicator-border-width, 3px) var(--mat-focus-indicator-border-style, solid) var(--mat-focus-indicator-border-color, transparent);border-radius:var(--mat-focus-indicator-border-radius, 4px)}.mat-focus-indicator:focus::before{content:""}.cdk-high-contrast-active{--mat-focus-indicator-display: block}.mat-mdc-focus-indicator{position:relative}.mat-mdc-focus-indicator::before{top:0;left:0;right:0;bottom:0;position:absolute;box-sizing:border-box;pointer-events:none;display:var(--mat-mdc-focus-indicator-display, none);border:var(--mat-mdc-focus-indicator-border-width, 3px) var(--mat-mdc-focus-indicator-border-style, solid) var(--mat-mdc-focus-indicator-border-color, transparent);border-radius:var(--mat-mdc-focus-indicator-border-radius, 4px)}.mat-mdc-focus-indicator:focus::before{content:""}.cdk-high-contrast-active{--mat-mdc-focus-indicator-display: block}.mat-h1,.mat-headline,.mat-typography .mat-h1,.mat-typography .mat-headline,.mat-typography h1{font-size:24px;font-weight:400;line-height:32px;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h2,.mat-title,.mat-typography .mat-h2,.mat-typography .mat-title,.mat-typography h2{font-size:20px;font-weight:500;line-height:32px;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h3,.mat-subheading-2,.mat-typography .mat-h3,.mat-typography .mat-subheading-2,.mat-typography h3{font-size:16px;font-weight:400;line-height:28px;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h4,.mat-subheading-1,.mat-typography .mat-h4,.mat-typography .mat-subheading-1,.mat-typography h4{font-size:15px;font-weight:400;line-height:24px;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h5,.mat-typography .mat-h5,.mat-typography h5{font:400 calc(14px * 0.83)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-h6,.mat-typography .mat-h6,.mat-typography h6{font:400 calc(14px * 0.67)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-body-strong,.mat-body-2,.mat-typography .mat-body-strong,.mat-typography .mat-body-2{font-size:14px;font-weight:500;line-height:24px;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body,.mat-body-1,.mat-typography .mat-body,.mat-typography .mat-body-1,.mat-typography{font-size:14px;font-weight:400;line-height:20px;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body p,.mat-body-1 p,.mat-typography .mat-body p,.mat-typography .mat-body-1 p,.mat-typography p{margin:0 0 12px}.mat-small,.mat-caption,.mat-typography .mat-small,.mat-typography .mat-caption{font-size:12px;font-weight:400;line-height:20px;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-display-4,.mat-typography .mat-display-4{font-size:112px;font-weight:300;line-height:112px;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.05em;margin:0 0 56px}.mat-display-3,.mat-typography .mat-display-3{font-size:56px;font-weight:400;line-height:56px;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.02em;margin:0 0 64px}.mat-display-2,.mat-typography .mat-display-2{font-size:45px;font-weight:400;line-height:48px;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.005em;margin:0 0 64px}.mat-display-1,.mat-typography .mat-display-1{font-size:34px;font-weight:400;line-height:40px;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 64px}.mat-badge-content{font-weight:600;font-size:12px;font-family:Roboto, "Helvetica Neue", sans-serif}.mat-badge-small .mat-badge-content{font-size:9px}.mat-badge-large .mat-badge-content{font-size:24px}.mat-bottom-sheet-container{font-size:14px;font-weight:400;line-height:20px;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-button-toggle{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-calendar{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-calendar-body{font-size:13px}.mat-calendar-body-label,.mat-calendar-period-button{font-size:14px;font-weight:500}.mat-calendar-table-header th{font-size:11px;font-weight:400}.mat-expansion-panel-header{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:15px;font-weight:400}.mat-expansion-panel-content{font-size:14px;font-weight:400;line-height:20px;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-grid-tile-header,.mat-grid-tile-footer{font-size:14px}.mat-grid-tile-header .mat-line,.mat-grid-tile-footer .mat-line{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-grid-tile-header .mat-line:nth-child(n+2),.mat-grid-tile-footer .mat-line:nth-child(n+2){font-size:12px}.mat-stepper-vertical,.mat-stepper-horizontal{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-step-label{font-size:14px;font-weight:400}.mat-step-sub-label-error{font-weight:normal}.mat-step-label-error{font-size:14px}.mat-step-label-selected{font-size:14px;font-weight:500}.mat-toolbar,.mat-toolbar h1,.mat-toolbar h2,.mat-toolbar h3,.mat-toolbar h4,.mat-toolbar h5,.mat-toolbar h6{font-size:20px;font-weight:500;line-height:32px;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0}.mat-tree{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tree-node,.mat-nested-tree-node{font-weight:400;font-size:14px}.mat-option{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:16px}.mat-optgroup-label{font-size:14px;font-weight:500;line-height:24px;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-button,.mat-raised-button,.mat-icon-button,.mat-stroked-button,.mat-flat-button,.mat-fab,.mat-mini-fab{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-datepicker-content .mdc-button{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-button-font-family, var(--mdc-typography-font-family, Roboto, "Helvetica Neue", sans-serif));font-size:var(--mdc-typography-button-font-size, 14px);line-height:var(--mdc-typography-button-line-height, 14px);font-weight:var(--mdc-typography-button-font-weight, 500);letter-spacing:var(--mdc-typography-button-letter-spacing, normal);text-decoration:var(--mdc-typography-button-text-decoration, none);text-transform:var(--mdc-typography-button-text-transform, none)}.mat-card{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card-title{font-size:24px;font-weight:500}.mat-card-header .mat-card-title{font-size:20px}.mat-card-subtitle,.mat-card-content{font-size:14px}.mat-tooltip{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:10px;padding-top:6px;padding-bottom:6px}.mat-tooltip-handset{font-size:14px;padding-top:8px;padding-bottom:8px}input.mat-input-element{margin-top:-0.0625em}.mat-form-field{font-size:inherit;font-weight:400;line-height:1.125;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field-wrapper{padding-bottom:1.34375em}.mat-form-field-prefix .mat-icon,.mat-form-field-suffix .mat-icon{font-size:150%;line-height:1.125}.mat-form-field-prefix .mat-icon-button,.mat-form-field-suffix .mat-icon-button{height:1.5em;width:1.5em}.mat-form-field-prefix .mat-icon-button .mat-icon,.mat-form-field-suffix .mat-icon-button .mat-icon{height:1.125em;line-height:1.125}.mat-form-field-infix{padding:.5em 0;border-top:.84375em solid rgba(0,0,0,0)}.mat-form-field-can-float.mat-form-field-should-float .mat-form-field-label,.mat-form-field-can-float .mat-input-server:focus+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.34375em) scale(0.75);width:133.3333333333%}.mat-form-field-can-float .mat-input-server[label]+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.34374em) scale(0.75);width:133.3333433333%}.mat-form-field-label-wrapper{top:-0.84375em;padding-top:.84375em}.mat-form-field-label{top:1.34375em}.mat-form-field-underline{bottom:1.34375em}.mat-form-field-subscript-wrapper{font-size:75%;margin-top:.6666666667em;top:calc(100% - 1.7916666667em)}.mat-form-field-appearance-legacy .mat-form-field-wrapper{padding-bottom:1.25em}.mat-form-field-appearance-legacy .mat-form-field-infix{padding:.4375em 0}.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float .mat-form-field-label,.mat-form-field-appearance-legacy.mat-form-field-can-float .mat-input-server:focus+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.001px);width:133.3333333333%}.mat-form-field-appearance-legacy.mat-form-field-can-float .mat-form-field-autofill-control:-webkit-autofill+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00101px);width:133.3333433333%}.mat-form-field-appearance-legacy.mat-form-field-can-float .mat-input-server[label]+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00102px);width:133.3333533333%}.mat-form-field-appearance-legacy .mat-form-field-label{top:1.28125em}.mat-form-field-appearance-legacy .mat-form-field-underline{bottom:1.25em}.mat-form-field-appearance-legacy .mat-form-field-subscript-wrapper{margin-top:.5416666667em;top:calc(100% - 1.6666666667em)}@media print{.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float .mat-form-field-label,.mat-form-field-appearance-legacy.mat-form-field-can-float .mat-input-server:focus+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.28122em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float .mat-form-field-autofill-control:-webkit-autofill+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.28121em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float .mat-input-server[label]+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.2812em) scale(0.75)}}.mat-form-field-appearance-fill .mat-form-field-infix{padding:.25em 0 .75em 0}.mat-form-field-appearance-fill .mat-form-field-label{top:1.09375em;margin-top:-0.5em}.mat-form-field-appearance-fill.mat-form-field-can-float.mat-form-field-should-float .mat-form-field-label,.mat-form-field-appearance-fill.mat-form-field-can-float .mat-input-server:focus+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-0.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-fill.mat-form-field-can-float .mat-input-server[label]+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-0.59374em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-outline .mat-form-field-infix{padding:1em 0 1em 0}.mat-form-field-appearance-outline .mat-form-field-label{top:1.84375em;margin-top:-0.25em}.mat-form-field-appearance-outline.mat-form-field-can-float.mat-form-field-should-float .mat-form-field-label,.mat-form-field-appearance-outline.mat-form-field-can-float .mat-input-server:focus+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-outline.mat-form-field-can-float .mat-input-server[label]+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.59374em) scale(0.75);width:133.3333433333%}.mat-select{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select-trigger{height:1.125em}.mat-checkbox{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-checkbox-layout .mat-checkbox-label{line-height:24px}.mat-dialog-title{font-size:20px;font-weight:500;line-height:32px;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-chip{font-size:14px;font-weight:500}.mat-chip .mat-chip-trailing-icon.mat-icon,.mat-chip .mat-chip-remove.mat-icon{font-size:18px}.mat-slide-toggle-content{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tab-group{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tab-label,.mat-tab-link{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-radio-button{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-slider-thumb-label-text{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-menu-item{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:400}.mat-list-item{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-option{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-base .mat-list-item{font-size:16px}.mat-list-base .mat-list-item .mat-line{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base .mat-list-item .mat-line:nth-child(n+2){font-size:14px}.mat-list-base .mat-list-option{font-size:16px}.mat-list-base .mat-list-option .mat-line{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base .mat-list-option .mat-line:nth-child(n+2){font-size:14px}.mat-list-base .mat-subheader{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-list-base[dense] .mat-list-item{font-size:12px}.mat-list-base[dense] .mat-list-item .mat-line{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense] .mat-list-item .mat-line:nth-child(n+2){font-size:12px}.mat-list-base[dense] .mat-list-option{font-size:12px}.mat-list-base[dense] .mat-list-option .mat-line{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense] .mat-list-option .mat-line:nth-child(n+2){font-size:12px}.mat-list-base[dense] .mat-subheader{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-paginator,.mat-paginator-page-size .mat-select-trigger{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px}.mat-simple-snackbar{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px}.mat-simple-snackbar-action{line-height:1;font-family:inherit;font-size:inherit;font-weight:500}.mat-table{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-header-cell{font-size:12px;font-weight:500}.mat-cell,.mat-footer-cell{font-size:14px}.mat-badge-content{font-weight:600;font-size:12px;font-family:Roboto, sans-serif}.mat-badge-small .mat-badge-content{font-size:9px}.mat-badge-large .mat-badge-content{font-size:24px}.mat-h1,.mat-headline-5,.mat-typography .mat-h1,.mat-typography .mat-headline-5,.mat-typography h1{font-size:24px;font-weight:400;line-height:32px;font-family:Roboto, sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h2,.mat-headline-6,.mat-typography .mat-h2,.mat-typography .mat-headline-6,.mat-typography h2{font-size:20px;font-weight:500;line-height:32px;font-family:Roboto, sans-serif;letter-spacing:.0125em;margin:0 0 16px}.mat-h3,.mat-subtitle-1,.mat-typography .mat-h3,.mat-typography .mat-subtitle-1,.mat-typography h3{font-size:16px;font-weight:400;line-height:28px;font-family:Roboto, sans-serif;letter-spacing:.009375em;margin:0 0 16px}.mat-h4,.mat-body-1,.mat-typography .mat-h4,.mat-typography .mat-body-1,.mat-typography h4{font-size:16px;font-weight:400;line-height:24px;font-family:Roboto, sans-serif;letter-spacing:.03125em;margin:0 0 16px}.mat-h5,.mat-typography .mat-h5,.mat-typography h5{font:400 calc(14px * 0.83)/20px Roboto, sans-serif;margin:0 0 12px}.mat-h6,.mat-typography .mat-h6,.mat-typography h6{font:400 calc(14px * 0.67)/20px Roboto, sans-serif;margin:0 0 12px}.mat-body-strong,.mat-subtitle-2,.mat-typography .mat-body-strong,.mat-typography .mat-subtitle-2{font-size:14px;font-weight:500;line-height:22px;font-family:Roboto, sans-serif;letter-spacing:.0071428571em}.mat-body,.mat-body-2,.mat-typography .mat-body,.mat-typography .mat-body-2,.mat-typography{font-size:14px;font-weight:400;line-height:20px;font-family:Roboto, sans-serif;letter-spacing:.0178571429em}.mat-body p,.mat-body-2 p,.mat-typography .mat-body p,.mat-typography .mat-body-2 p,.mat-typography p{margin:0 0 12px}.mat-small,.mat-caption,.mat-typography .mat-small,.mat-typography .mat-caption{font-size:12px;font-weight:400;line-height:20px;font-family:Roboto, sans-serif;letter-spacing:.0333333333em}.mat-headline-1,.mat-typography .mat-headline-1{font-size:96px;font-weight:300;line-height:96px;font-family:Roboto, sans-serif;letter-spacing:-0.015625em;margin:0 0 56px}.mat-headline-2,.mat-typography .mat-headline-2{font-size:60px;font-weight:300;line-height:60px;font-family:Roboto, sans-serif;letter-spacing:-.0083333333em;margin:0 0 64px}.mat-headline-3,.mat-typography .mat-headline-3{font-size:48px;font-weight:400;line-height:50px;font-family:Roboto, sans-serif;letter-spacing:normal;margin:0 0 64px}.mat-headline-4,.mat-typography .mat-headline-4{font-size:34px;font-weight:400;line-height:40px;font-family:Roboto, sans-serif;letter-spacing:.0073529412em;margin:0 0 64px}.mat-bottom-sheet-container{font-size:14px;font-weight:400;line-height:20px;font-family:Roboto, sans-serif;letter-spacing:.0178571429em}.mat-button-toggle{font-family:Roboto, sans-serif}.mat-calendar{font-family:Roboto, sans-serif}.mat-calendar-body{font-size:13px}.mat-calendar-body-label,.mat-calendar-period-button{font-size:14px;font-weight:500}.mat-calendar-table-header th{font-size:11px;font-weight:400}.mat-expansion-panel-header{font-family:Roboto, sans-serif;font-size:14px;font-weight:500}.mat-expansion-panel-content{font-size:14px;font-weight:400;line-height:20px;font-family:Roboto, sans-serif;letter-spacing:.0178571429em}.mat-grid-tile-header,.mat-grid-tile-footer{font-size:14px}.mat-grid-tile-header .mat-line,.mat-grid-tile-footer .mat-line{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-grid-tile-header .mat-line:nth-child(n+2),.mat-grid-tile-footer .mat-line:nth-child(n+2){font-size:12px}.mat-stepper-vertical,.mat-stepper-horizontal{font-family:Roboto, sans-serif}.mat-step-label{font-size:14px;font-weight:400}.mat-step-sub-label-error{font-weight:normal}.mat-step-label-error{font-size:16px}.mat-step-label-selected{font-size:16px;font-weight:400}.mat-toolbar,.mat-toolbar h1,.mat-toolbar h2,.mat-toolbar h3,.mat-toolbar h4,.mat-toolbar h5,.mat-toolbar h6{font-size:20px;font-weight:500;line-height:32px;font-family:Roboto, sans-serif;letter-spacing:.0125em;margin:0}.mat-tree{font-family:Roboto, sans-serif}.mat-tree-node,.mat-nested-tree-node{font-weight:400;font-size:14px}.mat-mdc-option{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-body1-font-family, var(--mdc-typography-font-family, Roboto, sans-serif));font-size:var(--mdc-typography-body1-font-size, 16px);line-height:var(--mdc-typography-body1-line-height, 24px);font-weight:var(--mdc-typography-body1-font-weight, 400);letter-spacing:var(--mdc-typography-body1-letter-spacing, 0.03125em)}.mat-mdc-card-title{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-headline6-font-family, var(--mdc-typography-font-family, Roboto, sans-serif));font-size:var(--mdc-typography-headline6-font-size, 20px);line-height:var(--mdc-typography-headline6-line-height, 32px);font-weight:var(--mdc-typography-headline6-font-weight, 500);letter-spacing:var(--mdc-typography-headline6-letter-spacing, 0.0125em);text-decoration:var(--mdc-typography-headline6-text-decoration, inherit);text-transform:var(--mdc-typography-headline6-text-transform, none)}.mat-mdc-card-subtitle{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-subtitle2-font-family, var(--mdc-typography-font-family, Roboto, sans-serif));font-size:var(--mdc-typography-subtitle2-font-size, 14px);line-height:var(--mdc-typography-subtitle2-line-height, 22px);font-weight:var(--mdc-typography-subtitle2-font-weight, 500);letter-spacing:var(--mdc-typography-subtitle2-letter-spacing, 0.0071428571em);text-decoration:var(--mdc-typography-subtitle2-text-decoration, inherit);text-transform:var(--mdc-typography-subtitle2-text-transform, none)}.mat-mdc-tooltip{--mdc-plain-tooltip-supporting-text-font:Roboto, sans-serif;--mdc-plain-tooltip-supporting-text-size:12px;--mdc-plain-tooltip-supporting-text-weight:400;--mdc-plain-tooltip-supporting-text-tracking:0.0333333333em}.mdc-text-field__input{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-subtitle1-font-family, var(--mdc-typography-font-family, Roboto, sans-serif));font-size:var(--mdc-typography-subtitle1-font-size, 16px);font-weight:var(--mdc-typography-subtitle1-font-weight, 400);letter-spacing:var(--mdc-typography-subtitle1-letter-spacing, 0.009375em);text-decoration:var(--mdc-typography-subtitle1-text-decoration, inherit);text-transform:var(--mdc-typography-subtitle1-text-transform, none)}.mdc-text-field__affix{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-subtitle1-font-family, var(--mdc-typography-font-family, Roboto, sans-serif));font-size:var(--mdc-typography-subtitle1-font-size, 16px);font-weight:var(--mdc-typography-subtitle1-font-weight, 400);letter-spacing:var(--mdc-typography-subtitle1-letter-spacing, 0.009375em);text-decoration:var(--mdc-typography-subtitle1-text-decoration, inherit);text-transform:var(--mdc-typography-subtitle1-text-transform, none)}.mdc-text-field--textarea .mdc-text-field__input{line-height:1.5rem}.mdc-floating-label{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-subtitle1-font-family, var(--mdc-typography-font-family, Roboto, sans-serif));font-size:var(--mdc-typography-subtitle1-font-size, 16px);font-weight:var(--mdc-typography-subtitle1-font-weight, 400);letter-spacing:var(--mdc-typography-subtitle1-letter-spacing, 0.009375em);text-decoration:var(--mdc-typography-subtitle1-text-decoration, inherit);text-transform:var(--mdc-typography-subtitle1-text-transform, none)}.mat-mdc-form-field-subscript-wrapper,.mat-mdc-form-field-bottom-align::before{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-caption-font-family, var(--mdc-typography-font-family, Roboto, sans-serif));font-size:var(--mdc-typography-caption-font-size, 12px);line-height:var(--mdc-typography-caption-line-height, 20px);font-weight:var(--mdc-typography-caption-font-weight, 400);letter-spacing:var(--mdc-typography-caption-letter-spacing, 0.0333333333em);text-decoration:var(--mdc-typography-caption-text-decoration, inherit);text-transform:var(--mdc-typography-caption-text-transform, none)}.mat-mdc-form-field,.mat-mdc-floating-label{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-body1-font-family, var(--mdc-typography-font-family, Roboto, sans-serif));font-size:var(--mdc-typography-body1-font-size, 16px);line-height:var(--mdc-typography-body1-line-height, 24px);font-weight:var(--mdc-typography-body1-font-weight, 400);letter-spacing:var(--mdc-typography-body1-letter-spacing, 0.03125em);text-decoration:var(--mdc-typography-body1-text-decoration, inherit);text-transform:var(--mdc-typography-body1-text-transform, none)}.mat-mdc-form-field .mdc-text-field--outlined .mdc-floating-label--float-above{font-size:calc(16px * var(--mat-mdc-form-field-floating-label-scale, 0.75))}.mat-mdc-form-field .mdc-text-field--outlined .mdc-notched-outline--upgraded .mdc-floating-label--float-above{font-size:16px}.mat-mdc-select-panel{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-subtitle1-font-family, var(--mdc-typography-font-family, Roboto, sans-serif));font-size:var(--mdc-typography-subtitle1-font-size, 16px);line-height:var(--mdc-typography-subtitle1-line-height, 28px);font-weight:var(--mdc-typography-subtitle1-font-weight, 400);letter-spacing:var(--mdc-typography-subtitle1-letter-spacing, 0.009375em);text-decoration:var(--mdc-typography-subtitle1-text-decoration, inherit);text-transform:var(--mdc-typography-subtitle1-text-transform, none);line-height:24px}.mat-mdc-select{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-body1-font-family, var(--mdc-typography-font-family, Roboto, sans-serif));font-size:var(--mdc-typography-body1-font-size, 16px);line-height:var(--mdc-typography-body1-line-height, 24px);font-weight:var(--mdc-typography-body1-font-weight, 400);letter-spacing:var(--mdc-typography-body1-letter-spacing, 0.03125em);text-decoration:var(--mdc-typography-body1-text-decoration, inherit);text-transform:var(--mdc-typography-body1-text-transform, none)}.mat-mdc-autocomplete-panel{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-subtitle1-font-family, var(--mdc-typography-font-family, Roboto, sans-serif));font-size:var(--mdc-typography-subtitle1-font-size, 16px);line-height:var(--mdc-typography-subtitle1-line-height, 28px);font-weight:var(--mdc-typography-subtitle1-font-weight, 400);letter-spacing:var(--mdc-typography-subtitle1-letter-spacing, 0.009375em);text-decoration:var(--mdc-typography-subtitle1-text-decoration, inherit);text-transform:var(--mdc-typography-subtitle1-text-transform, none);line-height:24px}.mat-mdc-dialog-container{--mdc-dialog-subhead-font:Roboto, sans-serif;--mdc-dialog-subhead-line-height:32px;--mdc-dialog-subhead-size:20px;--mdc-dialog-subhead-weight:500;--mdc-dialog-subhead-tracking:0.0125em;--mdc-dialog-supporting-text-font:Roboto, sans-serif;--mdc-dialog-supporting-text-line-height:24px;--mdc-dialog-supporting-text-size:16px;--mdc-dialog-supporting-text-weight:400;--mdc-dialog-supporting-text-tracking:0.03125em}.mat-mdc-standard-chip{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-body2-font-family, var(--mdc-typography-font-family, Roboto, sans-serif));font-size:var(--mdc-typography-body2-font-size, 14px);line-height:var(--mdc-typography-body2-line-height, 20px);font-weight:var(--mdc-typography-body2-font-weight, 400);letter-spacing:var(--mdc-typography-body2-letter-spacing, 0.0178571429em);text-decoration:var(--mdc-typography-body2-text-decoration, inherit);text-transform:var(--mdc-typography-body2-text-transform, none)}.mdc-form-field{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-body2-font-family, var(--mdc-typography-font-family, Roboto, sans-serif));font-size:var(--mdc-typography-body2-font-size, 14px);line-height:var(--mdc-typography-body2-line-height, 20px);font-weight:var(--mdc-typography-body2-font-weight, 400);letter-spacing:var(--mdc-typography-body2-letter-spacing, 0.0178571429em);text-decoration:var(--mdc-typography-body2-text-decoration, inherit);text-transform:var(--mdc-typography-body2-text-transform, none)}.mdc-form-field{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-body2-font-family, var(--mdc-typography-font-family, Roboto, sans-serif));font-size:var(--mdc-typography-body2-font-size, 14px);line-height:var(--mdc-typography-body2-line-height, 20px);font-weight:var(--mdc-typography-body2-font-weight, 400);letter-spacing:var(--mdc-typography-body2-letter-spacing, 0.0178571429em);text-decoration:var(--mdc-typography-body2-text-decoration, inherit);text-transform:var(--mdc-typography-body2-text-transform, none)}.mat-mdc-slider{--mdc-slider-label-label-text-font:Roboto, sans-serif;--mdc-slider-label-label-text-size:14px;--mdc-slider-label-label-text-line-height:22px;--mdc-slider-label-label-text-tracking:0.0071428571em;--mdc-slider-label-label-text-weight:500}.mat-mdc-menu-content{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-subtitle1-font-family, var(--mdc-typography-font-family, Roboto, sans-serif));font-size:var(--mdc-typography-subtitle1-font-size, 16px);line-height:var(--mdc-typography-subtitle1-line-height, 28px);font-weight:var(--mdc-typography-subtitle1-font-weight, 400);letter-spacing:var(--mdc-typography-subtitle1-letter-spacing, 0.009375em);text-decoration:var(--mdc-typography-subtitle1-text-decoration, inherit);text-transform:var(--mdc-typography-subtitle1-text-transform, none);line-height:24px}.mat-mdc-menu-content,.mat-mdc-menu-content .mat-mdc-menu-item .mdc-list-item__primary-text{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-body1-font-family, var(--mdc-typography-font-family, Roboto, sans-serif));font-size:var(--mdc-typography-body1-font-size, 16px);line-height:var(--mdc-typography-body1-line-height, 24px);font-weight:var(--mdc-typography-body1-font-weight, 400);letter-spacing:var(--mdc-typography-body1-letter-spacing, 0.03125em);text-decoration:var(--mdc-typography-body1-text-decoration, inherit);text-transform:var(--mdc-typography-body1-text-transform, none)}.mat-mdc-list-base{--mdc-list-list-item-label-text-font:Roboto, sans-serif;--mdc-list-list-item-label-text-line-height:24px;--mdc-list-list-item-label-text-size:16px;--mdc-list-list-item-label-text-tracking:0.03125em;--mdc-list-list-item-label-text-weight:400;--mdc-list-list-item-supporting-text-font:Roboto, sans-serif;--mdc-list-list-item-supporting-text-line-height:20px;--mdc-list-list-item-supporting-text-size:14px;--mdc-list-list-item-supporting-text-tracking:0.0178571429em;--mdc-list-list-item-supporting-text-weight:400;--mdc-list-list-item-trailing-supporting-text-font:Roboto, sans-serif;--mdc-list-list-item-trailing-supporting-text-line-height:20px;--mdc-list-list-item-trailing-supporting-text-size:12px;--mdc-list-list-item-trailing-supporting-text-tracking:0.0333333333em;--mdc-list-list-item-trailing-supporting-text-weight:400}.mdc-list-group__subheader{font-size:16px;font-weight:400;line-height:28px;font-family:Roboto, sans-serif;letter-spacing:.009375em}.mat-mdc-paginator{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-caption-font-family, var(--mdc-typography-font-family, Roboto, sans-serif));font-size:var(--mdc-typography-caption-font-size, 12px);line-height:var(--mdc-typography-caption-line-height, 20px);font-weight:var(--mdc-typography-caption-font-weight, 400);letter-spacing:var(--mdc-typography-caption-letter-spacing, 0.0333333333em);text-decoration:var(--mdc-typography-caption-text-decoration, inherit);text-transform:var(--mdc-typography-caption-text-transform, none)}.mat-mdc-paginator .mat-mdc-select-value{font-size:12px}.mdc-tab{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-button-font-family, var(--mdc-typography-font-family, Roboto, sans-serif));font-size:var(--mdc-typography-button-font-size, 14px);line-height:var(--mdc-typography-button-line-height, 36px);font-weight:var(--mdc-typography-button-font-weight, 500);letter-spacing:var(--mdc-typography-button-letter-spacing, 0.0892857143em);text-decoration:var(--mdc-typography-button-text-decoration, none);text-transform:var(--mdc-typography-button-text-transform, none)}@media all and (-ms-high-contrast: none){.mdc-checkbox .mdc-checkbox__focus-ring{display:none}}.mdc-form-field{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-body2-font-family, var(--mdc-typography-font-family, Roboto, sans-serif));font-size:var(--mdc-typography-body2-font-size, 14px);line-height:var(--mdc-typography-body2-line-height, 20px);font-weight:var(--mdc-typography-body2-font-weight, 400);letter-spacing:var(--mdc-typography-body2-letter-spacing, 0.0178571429em);text-decoration:var(--mdc-typography-body2-text-decoration, inherit);text-transform:var(--mdc-typography-body2-text-transform, none)}.mdc-button{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-button-font-family, var(--mdc-typography-font-family, Roboto, sans-serif));font-size:var(--mdc-typography-button-font-size, 14px);line-height:var(--mdc-typography-button-line-height, 36px);font-weight:var(--mdc-typography-button-font-weight, 500);letter-spacing:var(--mdc-typography-button-letter-spacing, 0.0892857143em);text-decoration:var(--mdc-typography-button-text-decoration, none);text-transform:var(--mdc-typography-button-text-transform, none)}.mdc-fab--extended{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-button-font-family, var(--mdc-typography-font-family, Roboto, sans-serif));font-size:var(--mdc-typography-button-font-size, 14px);line-height:var(--mdc-typography-button-line-height, 36px);font-weight:var(--mdc-typography-button-font-weight, 500);letter-spacing:var(--mdc-typography-button-letter-spacing, 0.0892857143em);text-decoration:var(--mdc-typography-button-text-decoration, none);text-transform:var(--mdc-typography-button-text-transform, none)}.mat-mdc-snack-bar-container{--mdc-snackbar-supporting-text-font:Roboto, sans-serif;--mdc-snackbar-supporting-text-line-height:20px;--mdc-snackbar-supporting-text-size:14px;--mdc-snackbar-supporting-text-weight:400}.mdc-data-table__content{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-body2-font-family, var(--mdc-typography-font-family, Roboto, sans-serif));font-size:var(--mdc-typography-body2-font-size, 14px);line-height:var(--mdc-typography-body2-line-height, 20px);font-weight:var(--mdc-typography-body2-font-weight, 400);letter-spacing:var(--mdc-typography-body2-letter-spacing, 0.0178571429em);text-decoration:var(--mdc-typography-body2-text-decoration, inherit);text-transform:var(--mdc-typography-body2-text-transform, none)}.mdc-data-table__cell{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-body2-font-family, var(--mdc-typography-font-family, Roboto, sans-serif));font-size:var(--mdc-typography-body2-font-size, 14px);line-height:var(--mdc-typography-body2-line-height, 20px);font-weight:var(--mdc-typography-body2-font-weight, 400);letter-spacing:var(--mdc-typography-body2-letter-spacing, 0.0178571429em);text-decoration:var(--mdc-typography-body2-text-decoration, inherit);text-transform:var(--mdc-typography-body2-text-transform, none)}.mdc-data-table__header-cell{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-subtitle2-font-family, var(--mdc-typography-font-family, Roboto, sans-serif));font-size:var(--mdc-typography-subtitle2-font-size, 14px);line-height:var(--mdc-typography-subtitle2-line-height, 22px);font-weight:var(--mdc-typography-subtitle2-font-weight, 500);letter-spacing:var(--mdc-typography-subtitle2-letter-spacing, 0.0071428571em);text-decoration:var(--mdc-typography-subtitle2-text-decoration, inherit);text-transform:var(--mdc-typography-subtitle2-text-transform, none)}.mat-ripple-element{background-color:rgba(0,0,0,.1)}.mat-mdc-option{color:var(--mdc-theme-text-primary-on-background, rgba(0, 0, 0, 0.87))}.mat-mdc-option:hover:not(.mdc-list-item--disabled),.mat-mdc-option:focus:not(.mdc-list-item--disabled),.mat-mdc-option.mat-mdc-option-active,.mat-mdc-option.mdc-list-item--selected:not(.mat-mdc-option-multiple):not(.mdc-list-item--disabled){background:rgba(0,0,0,.04)}.mat-primary .mat-mdc-option.mdc-list-item--selected:not(.mdc-list-item--disabled) .mdc-list-item__primary-text{color:var(--mdc-theme-primary, #f57c00)}.mat-accent .mat-mdc-option.mdc-list-item--selected:not(.mdc-list-item--disabled) .mdc-list-item__primary-text{color:var(--mdc-theme-secondary, #ff9800)}.mat-warn .mat-mdc-option.mdc-list-item--selected:not(.mdc-list-item--disabled) .mdc-list-item__primary-text{color:var(--mdc-theme-error, #f44336)}.mat-mdc-optgroup-label{color:var(--mdc-theme-text-primary-on-background, rgba(0, 0, 0, 0.87))}.mat-pseudo-checkbox-full{color:#616161}.mat-pseudo-checkbox-full.mat-pseudo-checkbox-disabled{color:#b0b0b0}.mat-primary .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,.mat-primary .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#f57c00}.mat-primary .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,.mat-primary .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#f57c00}.mat-primary .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full::after,.mat-primary .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full::after{color:#fff}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,.mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#ff9800}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,.mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#ff9800}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full::after,.mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full::after{color:#fff}.mat-accent .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,.mat-accent .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#ff9800}.mat-accent .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,.mat-accent .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#ff9800}.mat-accent .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full::after,.mat-accent .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full::after{color:#fff}.mat-warn .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,.mat-warn .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#f44336}.mat-warn .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,.mat-warn .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#f44336}.mat-warn .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full::after,.mat-warn .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full::after{color:#fff}.mat-pseudo-checkbox-disabled.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,.mat-pseudo-checkbox-disabled.mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#b0b0b0}.mat-pseudo-checkbox-disabled.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,.mat-pseudo-checkbox-disabled.mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#b0b0b0}.mat-app-background{background-color:#fff;color:#212121}.mat-elevation-z0,.mat-mdc-elevation-specific.mat-elevation-z0{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2), 0px 0px 0px 0px rgba(0, 0, 0, 0.14), 0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z1,.mat-mdc-elevation-specific.mat-elevation-z1{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2), 0px 1px 1px 0px rgba(0, 0, 0, 0.14), 0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z2,.mat-mdc-elevation-specific.mat-elevation-z2{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2), 0px 2px 2px 0px rgba(0, 0, 0, 0.14), 0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z3,.mat-mdc-elevation-specific.mat-elevation-z3{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2), 0px 3px 4px 0px rgba(0, 0, 0, 0.14), 0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z4,.mat-mdc-elevation-specific.mat-elevation-z4{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2), 0px 4px 5px 0px rgba(0, 0, 0, 0.14), 0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z5,.mat-mdc-elevation-specific.mat-elevation-z5{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2), 0px 5px 8px 0px rgba(0, 0, 0, 0.14), 0px 1px 14px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z6,.mat-mdc-elevation-specific.mat-elevation-z6{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2), 0px 6px 10px 0px rgba(0, 0, 0, 0.14), 0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z7,.mat-mdc-elevation-specific.mat-elevation-z7{box-shadow:0px 4px 5px -2px rgba(0, 0, 0, 0.2), 0px 7px 10px 1px rgba(0, 0, 0, 0.14), 0px 2px 16px 1px rgba(0, 0, 0, 0.12)}.mat-elevation-z8,.mat-mdc-elevation-specific.mat-elevation-z8{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2), 0px 8px 10px 1px rgba(0, 0, 0, 0.14), 0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z9,.mat-mdc-elevation-specific.mat-elevation-z9{box-shadow:0px 5px 6px -3px rgba(0, 0, 0, 0.2), 0px 9px 12px 1px rgba(0, 0, 0, 0.14), 0px 3px 16px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z10,.mat-mdc-elevation-specific.mat-elevation-z10{box-shadow:0px 6px 6px -3px rgba(0, 0, 0, 0.2), 0px 10px 14px 1px rgba(0, 0, 0, 0.14), 0px 4px 18px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z11,.mat-mdc-elevation-specific.mat-elevation-z11{box-shadow:0px 6px 7px -4px rgba(0, 0, 0, 0.2), 0px 11px 15px 1px rgba(0, 0, 0, 0.14), 0px 4px 20px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z12,.mat-mdc-elevation-specific.mat-elevation-z12{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2), 0px 12px 17px 2px rgba(0, 0, 0, 0.14), 0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z13,.mat-mdc-elevation-specific.mat-elevation-z13{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2), 0px 13px 19px 2px rgba(0, 0, 0, 0.14), 0px 5px 24px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z14,.mat-mdc-elevation-specific.mat-elevation-z14{box-shadow:0px 7px 9px -4px rgba(0, 0, 0, 0.2), 0px 14px 21px 2px rgba(0, 0, 0, 0.14), 0px 5px 26px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z15,.mat-mdc-elevation-specific.mat-elevation-z15{box-shadow:0px 8px 9px -5px rgba(0, 0, 0, 0.2), 0px 15px 22px 2px rgba(0, 0, 0, 0.14), 0px 6px 28px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z16,.mat-mdc-elevation-specific.mat-elevation-z16{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2), 0px 16px 24px 2px rgba(0, 0, 0, 0.14), 0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z17,.mat-mdc-elevation-specific.mat-elevation-z17{box-shadow:0px 8px 11px -5px rgba(0, 0, 0, 0.2), 0px 17px 26px 2px rgba(0, 0, 0, 0.14), 0px 6px 32px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z18,.mat-mdc-elevation-specific.mat-elevation-z18{box-shadow:0px 9px 11px -5px rgba(0, 0, 0, 0.2), 0px 18px 28px 2px rgba(0, 0, 0, 0.14), 0px 7px 34px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z19,.mat-mdc-elevation-specific.mat-elevation-z19{box-shadow:0px 9px 12px -6px rgba(0, 0, 0, 0.2), 0px 19px 29px 2px rgba(0, 0, 0, 0.14), 0px 7px 36px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z20,.mat-mdc-elevation-specific.mat-elevation-z20{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2), 0px 20px 31px 3px rgba(0, 0, 0, 0.14), 0px 8px 38px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z21,.mat-mdc-elevation-specific.mat-elevation-z21{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2), 0px 21px 33px 3px rgba(0, 0, 0, 0.14), 0px 8px 40px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z22,.mat-mdc-elevation-specific.mat-elevation-z22{box-shadow:0px 10px 14px -6px rgba(0, 0, 0, 0.2), 0px 22px 35px 3px rgba(0, 0, 0, 0.14), 0px 8px 42px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z23,.mat-mdc-elevation-specific.mat-elevation-z23{box-shadow:0px 11px 14px -7px rgba(0, 0, 0, 0.2), 0px 23px 36px 3px rgba(0, 0, 0, 0.14), 0px 9px 44px 8px rgba(0, 0, 0, 0.12)}.mat-elevation-z24,.mat-mdc-elevation-specific.mat-elevation-z24{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2), 0px 24px 38px 3px rgba(0, 0, 0, 0.14), 0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-theme-loaded-marker{display:none}.mat-mdc-card{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2), 0px 1px 1px 0px rgba(0, 0, 0, 0.14), 0px 1px 3px 0px rgba(0, 0, 0, 0.12);--mdc-elevated-card-container-color:#fff}.mat-mdc-card-outlined{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2), 0px 0px 0px 0px rgba(0, 0, 0, 0.14), 0px 0px 0px 0px rgba(0, 0, 0, 0.12);--mdc-outlined-card-outline-color:#e0e0e0}.mat-mdc-card-subtitle{color:#616161}.mat-mdc-progress-bar{--mdc-linear-progress-active-indicator-color:#f57c00}.mat-mdc-progress-bar .mdc-linear-progress__buffer-dots{background-image:url("data:image/svg+xml,%3Csvg version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' enable-background='new 0 0 5 2' xml:space='preserve' viewBox='0 0 5 2' preserveAspectRatio='none slice'%3E%3Ccircle cx='1' cy='1' r='1' fill='rgba(245, 124, 0, 0.25)'/%3E%3C/svg%3E")}.mat-mdc-progress-bar .mdc-linear-progress__buffer-bar{background-color:rgba(245, 124, 0, 0.25)}.mat-mdc-progress-bar.mat-accent{--mdc-linear-progress-active-indicator-color:#ff9800}.mat-mdc-progress-bar.mat-accent .mdc-linear-progress__buffer-dots{background-image:url("data:image/svg+xml,%3Csvg version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' enable-background='new 0 0 5 2' xml:space='preserve' viewBox='0 0 5 2' preserveAspectRatio='none slice'%3E%3Ccircle cx='1' cy='1' r='1' fill='rgba(255, 152, 0, 0.25)'/%3E%3C/svg%3E")}.mat-mdc-progress-bar.mat-accent .mdc-linear-progress__buffer-bar{background-color:rgba(255, 152, 0, 0.25)}.mat-mdc-progress-bar.mat-warn{--mdc-linear-progress-active-indicator-color:#f44336}.mat-mdc-progress-bar.mat-warn .mdc-linear-progress__buffer-dots{background-image:url("data:image/svg+xml,%3Csvg version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' enable-background='new 0 0 5 2' xml:space='preserve' viewBox='0 0 5 2' preserveAspectRatio='none slice'%3E%3Ccircle cx='1' cy='1' r='1' fill='rgba(244, 67, 54, 0.25)'/%3E%3C/svg%3E")}.mat-mdc-progress-bar.mat-warn .mdc-linear-progress__buffer-bar{background-color:rgba(244, 67, 54, 0.25)}.mat-mdc-tooltip{--mdc-plain-tooltip-container-color:#616161;--mdc-plain-tooltip-supporting-text-color:white}.mdc-text-field:not(.mdc-text-field--disabled) .mdc-floating-label{color:rgba(0, 0, 0, 0.6)}.mdc-text-field:not(.mdc-text-field--disabled) .mdc-text-field__input{color:rgba(0, 0, 0, 0.87)}@media all{.mdc-text-field:not(.mdc-text-field--disabled) .mdc-text-field__input::placeholder{color:rgba(0, 0, 0, 0.6)}}@media all{.mdc-text-field:not(.mdc-text-field--disabled) .mdc-text-field__input:-ms-input-placeholder{color:rgba(0, 0, 0, 0.6)}}.mdc-text-field .mdc-text-field__input{caret-color:var(--mdc-theme-primary, #f57c00)}.mdc-text-field:not(.mdc-text-field--disabled)+.mdc-text-field-helper-line .mdc-text-field-helper-text{color:rgba(0, 0, 0, 0.6)}.mdc-text-field:not(.mdc-text-field--disabled) .mdc-text-field-character-counter,.mdc-text-field:not(.mdc-text-field--disabled)+.mdc-text-field-helper-line .mdc-text-field-character-counter{color:rgba(0, 0, 0, 0.6)}.mdc-text-field:not(.mdc-text-field--disabled) .mdc-text-field__icon--leading{color:rgba(0, 0, 0, 0.54)}.mdc-text-field:not(.mdc-text-field--disabled) .mdc-text-field__icon--trailing{color:rgba(0, 0, 0, 0.54)}.mdc-text-field:not(.mdc-text-field--disabled) .mdc-text-field__affix--prefix{color:rgba(0, 0, 0, 0.6)}.mdc-text-field:not(.mdc-text-field--disabled) .mdc-text-field__affix--suffix{color:rgba(0, 0, 0, 0.6)}.mdc-text-field--filled .mdc-text-field__ripple::before,.mdc-text-field--filled .mdc-text-field__ripple::after{background-color:var(--mdc-ripple-color, rgba(0, 0, 0, 0.87))}.mdc-text-field--filled:hover .mdc-text-field__ripple::before,.mdc-text-field--filled.mdc-ripple-surface--hover .mdc-text-field__ripple::before{opacity:var(--mdc-ripple-hover-opacity, 0.04)}.mdc-text-field--filled.mdc-ripple-upgraded--background-focused .mdc-text-field__ripple::before,.mdc-text-field--filled:not(.mdc-ripple-upgraded):focus .mdc-text-field__ripple::before{opacity:var(--mdc-ripple-focus-opacity, 0.12)}.mdc-text-field--filled:not(.mdc-text-field--disabled){background-color:whitesmoke}.mdc-text-field--filled:not(.mdc-text-field--disabled) .mdc-line-ripple::before{border-bottom-color:rgba(0, 0, 0, 0.42)}.mdc-text-field--filled:not(.mdc-text-field--disabled):hover .mdc-line-ripple::before{border-bottom-color:rgba(0, 0, 0, 0.87)}.mdc-text-field--filled .mdc-line-ripple::after{border-bottom-color:var(--mdc-theme-primary, #f57c00)}.mdc-text-field--outlined:not(.mdc-text-field--disabled) .mdc-notched-outline__leading,.mdc-text-field--outlined:not(.mdc-text-field--disabled) .mdc-notched-outline__notch,.mdc-text-field--outlined:not(.mdc-text-field--disabled) .mdc-notched-outline__trailing{border-color:rgba(0, 0, 0, 0.38)}.mdc-text-field--outlined:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__leading,.mdc-text-field--outlined:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__notch,.mdc-text-field--outlined:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__trailing{border-color:rgba(0, 0, 0, 0.87)}.mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__leading,.mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__notch,.mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__trailing{border-color:var(--mdc-theme-primary, #f57c00)}.mdc-text-field--outlined .mdc-text-field__ripple::before,.mdc-text-field--outlined .mdc-text-field__ripple::after{background-color:var(--mdc-ripple-color, transparent)}.mdc-text-field--focused:not(.mdc-text-field--disabled) .mdc-floating-label{color:rgba(245, 124, 0, 0.87)}.mdc-text-field--invalid:not(.mdc-text-field--disabled):hover .mdc-line-ripple::before{border-bottom-color:var(--mdc-theme-error, #f44336)}.mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-line-ripple::after{border-bottom-color:var(--mdc-theme-error, #f44336)}.mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-floating-label{color:var(--mdc-theme-error, #f44336)}.mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--invalid+.mdc-text-field-helper-line .mdc-text-field-helper-text--validation-msg{color:var(--mdc-theme-error, #f44336)}.mdc-text-field--invalid .mdc-text-field__input{caret-color:var(--mdc-theme-error, #f44336)}.mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-text-field__icon--trailing{color:var(--mdc-theme-error, #f44336)}.mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-line-ripple::before{border-bottom-color:var(--mdc-theme-error, #f44336)}.mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__leading,.mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__notch,.mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}.mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__leading,.mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__notch,.mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}.mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__leading,.mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__notch,.mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}.mdc-text-field--disabled .mdc-text-field__input{color:rgba(0, 0, 0, 0.38)}@media all{.mdc-text-field--disabled .mdc-text-field__input::placeholder{color:rgba(0, 0, 0, 0.38)}}@media all{.mdc-text-field--disabled .mdc-text-field__input:-ms-input-placeholder{color:rgba(0, 0, 0, 0.38)}}.mdc-text-field--disabled .mdc-floating-label{color:rgba(0, 0, 0, 0.38)}.mdc-text-field--disabled+.mdc-text-field-helper-line .mdc-text-field-helper-text{color:rgba(0, 0, 0, 0.38)}.mdc-text-field--disabled .mdc-text-field-character-counter,.mdc-text-field--disabled+.mdc-text-field-helper-line .mdc-text-field-character-counter{color:rgba(0, 0, 0, 0.38)}.mdc-text-field--disabled .mdc-text-field__icon--leading{color:rgba(0, 0, 0, 0.3)}.mdc-text-field--disabled .mdc-text-field__icon--trailing{color:rgba(0, 0, 0, 0.3)}.mdc-text-field--disabled .mdc-text-field__affix--prefix{color:rgba(0, 0, 0, 0.38)}.mdc-text-field--disabled .mdc-text-field__affix--suffix{color:rgba(0, 0, 0, 0.38)}.mdc-text-field--disabled .mdc-line-ripple::before{border-bottom-color:rgba(0, 0, 0, 0.06)}.mdc-text-field--disabled .mdc-notched-outline__leading,.mdc-text-field--disabled .mdc-notched-outline__notch,.mdc-text-field--disabled .mdc-notched-outline__trailing{border-color:rgba(0, 0, 0, 0.06)}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mdc-text-field--disabled .mdc-text-field__input::placeholder{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mdc-text-field--disabled .mdc-text-field__input:-ms-input-placeholder{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mdc-text-field--disabled .mdc-floating-label{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mdc-text-field--disabled+.mdc-text-field-helper-line .mdc-text-field-helper-text{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mdc-text-field--disabled .mdc-text-field-character-counter,.mdc-text-field--disabled+.mdc-text-field-helper-line .mdc-text-field-character-counter{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mdc-text-field--disabled .mdc-text-field__icon--leading{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mdc-text-field--disabled .mdc-text-field__icon--trailing{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mdc-text-field--disabled .mdc-text-field__affix--prefix{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mdc-text-field--disabled .mdc-text-field__affix--suffix{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mdc-text-field--disabled .mdc-line-ripple::before{border-bottom-color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mdc-text-field--disabled .mdc-notched-outline__leading,.mdc-text-field--disabled .mdc-notched-outline__notch,.mdc-text-field--disabled .mdc-notched-outline__trailing{border-color:GrayText}}.mdc-text-field--disabled.mdc-text-field--filled{background-color:#fafafa}.mat-mdc-form-field-error{color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field-focus-overlay{background-color:rgba(0,0,0,.87)}.mat-mdc-form-field:hover .mat-mdc-form-field-focus-overlay{opacity:.04}.mat-mdc-form-field.mat-focused .mat-mdc-form-field-focus-overlay{opacity:.12}.mat-mdc-form-field-type-mat-native-select .mat-mdc-form-field-infix::after{color:rgba(0,0,0,.54)}.mat-mdc-form-field-type-mat-native-select.mat-focused.mat-primary .mat-mdc-form-field-infix::after{color:rgba(245,124,0,.87)}.mat-mdc-form-field-type-mat-native-select.mat-focused.mat-accent .mat-mdc-form-field-infix::after{color:rgba(255,152,0,.87)}.mat-mdc-form-field-type-mat-native-select.mat-focused.mat-warn .mat-mdc-form-field-infix::after{color:rgba(244,67,54,.87)}.mat-mdc-form-field-type-mat-native-select.mat-form-field-disabled .mat-mdc-form-field-infix::after{color:rgba(0,0,0,.38)}.mat-mdc-form-field.mat-accent .mdc-text-field__input{caret-color:var(--mdc-theme-secondary, #ff9800)}.mat-mdc-form-field.mat-accent:not(.mdc-text-field--disabled) .mdc-line-ripple::after{border-bottom-color:var(--mdc-theme-secondary, #ff9800)}.mat-mdc-form-field.mat-accent .mdc-text-field--focused:not(.mdc-text-field--disabled) .mdc-floating-label{color:rgba(255, 152, 0, 0.87)}.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled):hover .mdc-line-ripple::before{border-bottom-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-line-ripple::after{border-bottom-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-floating-label{color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--invalid+.mdc-text-field-helper-line .mdc-text-field-helper-text--validation-msg{color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-accent .mdc-text-field--invalid .mdc-text-field__input{caret-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-text-field__icon--trailing{color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-line-ripple::before{border-bottom-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__leading,.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__notch,.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__leading,.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__notch,.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__leading,.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__notch,.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-accent .mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__leading,.mat-mdc-form-field.mat-accent .mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__notch,.mat-mdc-form-field.mat-accent .mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__trailing{border-color:var(--mdc-theme-secondary, #ff9800)}.mat-mdc-form-field.mat-warn .mdc-text-field__input{caret-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-warn:not(.mdc-text-field--disabled) .mdc-line-ripple::after{border-bottom-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-warn .mdc-text-field--focused:not(.mdc-text-field--disabled) .mdc-floating-label{color:rgba(244, 67, 54, 0.87)}.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled):hover .mdc-line-ripple::before{border-bottom-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-line-ripple::after{border-bottom-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-floating-label{color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--invalid+.mdc-text-field-helper-line .mdc-text-field-helper-text--validation-msg{color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-warn .mdc-text-field--invalid .mdc-text-field__input{caret-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-text-field__icon--trailing{color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-line-ripple::before{border-bottom-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__leading,.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__notch,.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__leading,.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__notch,.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__leading,.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__notch,.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-warn .mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__leading,.mat-mdc-form-field.mat-warn .mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__notch,.mat-mdc-form-field.mat-warn .mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-mdc-form-field.mat-mdc-form-field.mat-mdc-form-field.mat-mdc-form-field .mdc-notched-outline__notch{border-left:1px solid rgba(0,0,0,0)}[dir=rtl] .mat-mdc-form-field.mat-mdc-form-field.mat-mdc-form-field.mat-mdc-form-field.mat-mdc-form-field .mdc-notched-outline__notch{border-left:none;border-right:1px solid rgba(0,0,0,0)}.mat-mdc-form-field-infix{min-height:56px}.mat-mdc-text-field-wrapper .mat-mdc-form-field-flex .mat-mdc-floating-label{top:28px}.mat-mdc-text-field-wrapper.mdc-text-field--outlined .mdc-notched-outline--upgraded .mdc-floating-label--float-above{--mat-mdc-form-field-label-transform: translateY( -34.75px) scale(var(--mat-mdc-form-field-floating-label-scale, 0.75));transform:var(--mat-mdc-form-field-label-transform)}.mat-mdc-text-field-wrapper.mdc-text-field--outlined .mat-mdc-form-field-infix{padding-top:16px;padding-bottom:16px}.mat-mdc-text-field-wrapper:not(.mdc-text-field--outlined) .mat-mdc-form-field-infix{padding-top:24px;padding-bottom:8px}.mdc-text-field--no-label:not(.mdc-text-field--outlined):not(.mdc-text-field--textarea) .mat-mdc-form-field-infix{padding-top:16px;padding-bottom:16px}.mdc-menu-surface{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2), 0px 8px 10px 1px rgba(0, 0, 0, 0.14), 0px 3px 14px 2px rgba(0, 0, 0, 0.12);background-color:var(--mdc-theme-surface, #fff);color:var(--mdc-theme-on-surface, #000)}.mdc-list-item__primary-text{color:var(--mdc-theme-text-primary-on-background, rgba(0, 0, 0, 0.87))}.mdc-list-item__secondary-text{color:var(--mdc-theme-text-secondary-on-background, rgba(0, 0, 0, 0.54))}.mdc-list-item__overline-text{color:var(--mdc-theme-text-hint-on-background, rgba(0, 0, 0, 0.38))}.mdc-list-item--with-leading-icon .mdc-list-item__start,.mdc-list-item--with-trailing-icon .mdc-list-item__end{background-color:transparent}.mdc-list-item--with-leading-icon .mdc-list-item__start,.mdc-list-item--with-trailing-icon .mdc-list-item__end{color:var(--mdc-theme-text-icon-on-background, rgba(0, 0, 0, 0.38))}.mdc-list-item__end{color:var(--mdc-theme-text-hint-on-background, rgba(0, 0, 0, 0.38))}.mdc-list-item--disabled .mdc-list-item__start,.mdc-list-item--disabled .mdc-list-item__content,.mdc-list-item--disabled .mdc-list-item__end{opacity:0.38}.mdc-list-item--disabled .mdc-list-item__primary-text{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled .mdc-list-item__secondary-text{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled .mdc-list-item__overline-text{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled.mdc-list-item--with-leading-icon .mdc-list-item__start{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled.mdc-list-item--with-trailing-icon .mdc-list-item__end{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled.mdc-list-item--with-trailing-meta .mdc-list-item__end{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--selected .mdc-list-item__primary-text,.mdc-list-item--activated .mdc-list-item__primary-text{color:var(--mdc-theme-primary, #f57c00)}.mdc-list-item--selected.mdc-list-item--with-leading-icon .mdc-list-item__start,.mdc-list-item--activated.mdc-list-item--with-leading-icon .mdc-list-item__start{color:var(--mdc-theme-primary, #f57c00)}.mdc-deprecated-list-group__subheader{color:var(--mdc-theme-text-primary-on-background, rgba(0, 0, 0, 0.87))}.mdc-list-divider::after{border-bottom-color:white}.mdc-list-divider{background-color:rgba(0, 0, 0, 0.12)}.mat-mdc-select-value{color:rgba(0,0,0,.87)}.mat-mdc-select-placeholder{color:rgba(0,0,0,.6)}.mat-mdc-select-disabled .mat-mdc-select-value{color:rgba(0,0,0,.38)}.mat-mdc-select-arrow{color:rgba(0,0,0,.54)}.mat-mdc-form-field.mat-focused.mat-primary .mat-mdc-select-arrow{color:rgba(245,124,0,.87)}.mat-mdc-form-field.mat-focused.mat-accent .mat-mdc-select-arrow{color:rgba(255,152,0,.87)}.mat-mdc-form-field.mat-focused.mat-warn .mat-mdc-select-arrow{color:rgba(244,67,54,.87)}.mat-mdc-form-field .mat-mdc-select.mat-mdc-select-invalid .mat-mdc-select-arrow{color:rgba(244,67,54,.87)}.mat-mdc-form-field .mat-mdc-select.mat-mdc-select-disabled .mat-mdc-select-arrow{color:rgba(0,0,0,.38)}.mdc-menu-surface{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2), 0px 8px 10px 1px rgba(0, 0, 0, 0.14), 0px 3px 14px 2px rgba(0, 0, 0, 0.12);background-color:var(--mdc-theme-surface, #fff);color:var(--mdc-theme-on-surface, #000)}.mdc-list-item__primary-text{color:var(--mdc-theme-text-primary-on-background, rgba(0, 0, 0, 0.87))}.mdc-list-item__secondary-text{color:var(--mdc-theme-text-secondary-on-background, rgba(0, 0, 0, 0.54))}.mdc-list-item__overline-text{color:var(--mdc-theme-text-hint-on-background, rgba(0, 0, 0, 0.38))}.mdc-list-item--with-leading-icon .mdc-list-item__start,.mdc-list-item--with-trailing-icon .mdc-list-item__end{background-color:transparent}.mdc-list-item--with-leading-icon .mdc-list-item__start,.mdc-list-item--with-trailing-icon .mdc-list-item__end{color:var(--mdc-theme-text-icon-on-background, rgba(0, 0, 0, 0.38))}.mdc-list-item__end{color:var(--mdc-theme-text-hint-on-background, rgba(0, 0, 0, 0.38))}.mdc-list-item--disabled .mdc-list-item__start,.mdc-list-item--disabled .mdc-list-item__content,.mdc-list-item--disabled .mdc-list-item__end{opacity:0.38}.mdc-list-item--disabled .mdc-list-item__primary-text{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled .mdc-list-item__secondary-text{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled .mdc-list-item__overline-text{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled.mdc-list-item--with-leading-icon .mdc-list-item__start{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled.mdc-list-item--with-trailing-icon .mdc-list-item__end{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled.mdc-list-item--with-trailing-meta .mdc-list-item__end{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--selected .mdc-list-item__primary-text,.mdc-list-item--activated .mdc-list-item__primary-text{color:var(--mdc-theme-primary, #f57c00)}.mdc-list-item--selected.mdc-list-item--with-leading-icon .mdc-list-item__start,.mdc-list-item--activated.mdc-list-item--with-leading-icon .mdc-list-item__start{color:var(--mdc-theme-primary, #f57c00)}.mdc-deprecated-list-group__subheader{color:var(--mdc-theme-text-primary-on-background, rgba(0, 0, 0, 0.87))}.mdc-list-divider::after{border-bottom-color:white}.mdc-list-divider{background-color:rgba(0, 0, 0, 0.12)}.mat-mdc-dialog-container{--mdc-dialog-container-color:white;--mdc-dialog-with-divider-divider-color:rgba(0, 0, 0, 0.12);--mdc-dialog-subhead-color:rgba(0, 0, 0, 0.87);--mdc-dialog-supporting-text-color:rgba(0, 0, 0, 0.6)}.mat-mdc-standard-chip{--mdc-chip-elevated-container-color:#e0e0e0;--mdc-chip-elevated-disabled-container-color:#e0e0e0;--mdc-chip-label-text-color:#212121;--mdc-chip-disabled-label-text-color:#212121;--mdc-chip-with-icon-icon-color:#212121;--mdc-chip-with-icon-disabled-icon-color:#212121;--mdc-chip-with-trailing-icon-disabled-trailing-icon-color:#212121;--mdc-chip-with-trailing-icon-trailing-icon-color:#212121;--mdc-chip-with-icon-selected-icon-color:#212121}.mat-mdc-standard-chip.mat-primary.mat-mdc-chip-selected,.mat-mdc-standard-chip.mat-primary.mat-mdc-chip-highlighted{--mdc-chip-elevated-container-color:#f57c00;--mdc-chip-elevated-disabled-container-color:#f57c00;--mdc-chip-label-text-color:white;--mdc-chip-disabled-label-text-color:white;--mdc-chip-with-icon-icon-color:white;--mdc-chip-with-icon-disabled-icon-color:white;--mdc-chip-with-trailing-icon-disabled-trailing-icon-color:white;--mdc-chip-with-trailing-icon-trailing-icon-color:white;--mdc-chip-with-icon-selected-icon-color:white}.mat-mdc-standard-chip.mat-accent.mat-mdc-chip-selected,.mat-mdc-standard-chip.mat-accent.mat-mdc-chip-highlighted{--mdc-chip-elevated-container-color:#ff9800;--mdc-chip-elevated-disabled-container-color:#ff9800;--mdc-chip-label-text-color:white;--mdc-chip-disabled-label-text-color:white;--mdc-chip-with-icon-icon-color:white;--mdc-chip-with-icon-disabled-icon-color:white;--mdc-chip-with-trailing-icon-disabled-trailing-icon-color:white;--mdc-chip-with-trailing-icon-trailing-icon-color:white;--mdc-chip-with-icon-selected-icon-color:white}.mat-mdc-standard-chip.mat-warn.mat-mdc-chip-selected,.mat-mdc-standard-chip.mat-warn.mat-mdc-chip-highlighted{--mdc-chip-elevated-container-color:#f44336;--mdc-chip-elevated-disabled-container-color:#f44336;--mdc-chip-label-text-color:white;--mdc-chip-disabled-label-text-color:white;--mdc-chip-with-icon-icon-color:white;--mdc-chip-with-icon-disabled-icon-color:white;--mdc-chip-with-trailing-icon-disabled-trailing-icon-color:white;--mdc-chip-with-trailing-icon-trailing-icon-color:white;--mdc-chip-with-icon-selected-icon-color:white}.mat-mdc-chip-focus-overlay{background:#000}.mat-mdc-chip{height:32px}.mat-mdc-slide-toggle{--mdc-switch-disabled-selected-handle-color:#424242;--mdc-switch-disabled-unselected-handle-color:#424242;--mdc-switch-disabled-selected-track-color:#424242;--mdc-switch-disabled-unselected-track-color:#424242;--mdc-switch-unselected-focus-state-layer-color:#424242;--mdc-switch-unselected-pressed-state-layer-color:#424242;--mdc-switch-unselected-hover-state-layer-color:#424242;--mdc-switch-unselected-focus-track-color:#e0e0e0;--mdc-switch-unselected-hover-track-color:#e0e0e0;--mdc-switch-unselected-pressed-track-color:#e0e0e0;--mdc-switch-unselected-track-color:#e0e0e0;--mdc-switch-unselected-focus-handle-color:#212121;--mdc-switch-unselected-hover-handle-color:#212121;--mdc-switch-unselected-pressed-handle-color:#212121;--mdc-switch-handle-surface-color:var(--mdc-theme-surface, #fff);--mdc-switch-unselected-handle-color:#616161;--mdc-switch-selected-icon-color:#fff;--mdc-switch-disabled-selected-icon-color:#fff;--mdc-switch-disabled-unselected-icon-color:#fff;--mdc-switch-unselected-icon-color:#fff}.mat-mdc-slide-toggle .mdc-form-field{color:var(--mdc-theme-text-primary-on-background, rgba(0, 0, 0, 0.87))}.mat-mdc-slide-toggle .mdc-switch--disabled+label{color:#757575}.mat-mdc-slide-toggle.mat-primary{--mdc-switch-selected-focus-state-layer-color:#fb8c00;--mdc-switch-selected-handle-color:#fb8c00;--mdc-switch-selected-hover-state-layer-color:#fb8c00;--mdc-switch-selected-pressed-state-layer-color:#fb8c00;--mdc-switch-selected-focus-handle-color:#e65100;--mdc-switch-selected-hover-handle-color:#e65100;--mdc-switch-selected-pressed-handle-color:#e65100;--mdc-switch-selected-focus-track-color:#ffb74d;--mdc-switch-selected-hover-track-color:#ffb74d;--mdc-switch-selected-pressed-track-color:#ffb74d;--mdc-switch-selected-track-color:#ffb74d}.mat-mdc-slide-toggle.mat-accent{--mdc-switch-selected-focus-state-layer-color:#fb8c00;--mdc-switch-selected-handle-color:#fb8c00;--mdc-switch-selected-hover-state-layer-color:#fb8c00;--mdc-switch-selected-pressed-state-layer-color:#fb8c00;--mdc-switch-selected-focus-handle-color:#e65100;--mdc-switch-selected-hover-handle-color:#e65100;--mdc-switch-selected-pressed-handle-color:#e65100;--mdc-switch-selected-focus-track-color:#ffb74d;--mdc-switch-selected-hover-track-color:#ffb74d;--mdc-switch-selected-pressed-track-color:#ffb74d;--mdc-switch-selected-track-color:#ffb74d}.mat-mdc-slide-toggle.mat-warn{--mdc-switch-selected-focus-state-layer-color:#e53935;--mdc-switch-selected-handle-color:#e53935;--mdc-switch-selected-hover-state-layer-color:#e53935;--mdc-switch-selected-pressed-state-layer-color:#e53935;--mdc-switch-selected-focus-handle-color:#b71c1c;--mdc-switch-selected-hover-handle-color:#b71c1c;--mdc-switch-selected-pressed-handle-color:#b71c1c;--mdc-switch-selected-focus-track-color:#e57373;--mdc-switch-selected-hover-track-color:#e57373;--mdc-switch-selected-pressed-track-color:#e57373;--mdc-switch-selected-track-color:#e57373}.mat-mdc-slide-toggle{--mdc-switch-state-layer-size:48px}.mat-mdc-radio-button .mdc-form-field{color:var(--mdc-theme-text-primary-on-background, rgba(0, 0, 0, 0.87))}.mat-mdc-radio-button.mat-primary{--mdc-radio-disabled-selected-icon-color:#000;--mdc-radio-disabled-unselected-icon-color:#000;--mdc-radio-unselected-focus-icon-color:#212121;--mdc-radio-unselected-hover-icon-color:#212121;--mdc-radio-unselected-icon-color:rgba(0, 0, 0, 0.54);--mdc-radio-unselected-pressed-icon-color:rgba(0, 0, 0, 0.54);--mdc-radio-selected-focus-icon-color:#f57c00;--mdc-radio-selected-hover-icon-color:#f57c00;--mdc-radio-selected-icon-color:#f57c00;--mdc-radio-selected-pressed-icon-color:#f57c00;--mat-mdc-radio-ripple-color: #000;--mat-mdc-radio-checked-ripple-color: #f57c00}.mat-mdc-radio-button.mat-primary .mdc-radio--disabled+label{color:#757575}.mat-mdc-radio-button.mat-accent{--mdc-radio-disabled-selected-icon-color:#000;--mdc-radio-disabled-unselected-icon-color:#000;--mdc-radio-unselected-focus-icon-color:#212121;--mdc-radio-unselected-hover-icon-color:#212121;--mdc-radio-unselected-icon-color:rgba(0, 0, 0, 0.54);--mdc-radio-unselected-pressed-icon-color:rgba(0, 0, 0, 0.54);--mdc-radio-selected-focus-icon-color:#ff9800;--mdc-radio-selected-hover-icon-color:#ff9800;--mdc-radio-selected-icon-color:#ff9800;--mdc-radio-selected-pressed-icon-color:#ff9800;--mat-mdc-radio-ripple-color: #000;--mat-mdc-radio-checked-ripple-color: #ff9800}.mat-mdc-radio-button.mat-accent .mdc-radio--disabled+label{color:#757575}.mat-mdc-radio-button.mat-warn{--mdc-radio-disabled-selected-icon-color:#000;--mdc-radio-disabled-unselected-icon-color:#000;--mdc-radio-unselected-focus-icon-color:#212121;--mdc-radio-unselected-hover-icon-color:#212121;--mdc-radio-unselected-icon-color:rgba(0, 0, 0, 0.54);--mdc-radio-unselected-pressed-icon-color:rgba(0, 0, 0, 0.54);--mdc-radio-selected-focus-icon-color:#f44336;--mdc-radio-selected-hover-icon-color:#f44336;--mdc-radio-selected-icon-color:#f44336;--mdc-radio-selected-pressed-icon-color:#f44336;--mat-mdc-radio-ripple-color: #000;--mat-mdc-radio-checked-ripple-color: #f44336}.mat-mdc-radio-button.mat-warn .mdc-radio--disabled+label{color:#757575}.mat-mdc-radio-button .mdc-radio{padding:calc((40px - 20px) / 2)}.mat-mdc-radio-button .mdc-radio .mdc-radio__background::before{top:calc(-1 * (40px - 20px) / 2);left:calc(-1 * (40px - 20px) / 2);width:40px;height:40px}.mat-mdc-radio-button .mdc-radio .mdc-radio__native-control{top:calc((40px - 40px) / 2);right:calc((40px - 40px) / 2);left:calc((40px - 40px) / 2);width:40px;height:40px}.mat-mdc-slider{--mdc-slider-label-container-color:black;--mdc-slider-label-label-text-color:white;--mdc-slider-disabled-handle-color:#000;--mdc-slider-disabled-active-track-color:#000;--mdc-slider-disabled-inactive-track-color:#000;--mdc-slider-with-tick-marks-disabled-container-color:#000;--mat-mdc-slider-value-indicator-opacity: 0.6}.mat-mdc-slider.mat-primary{--mdc-slider-handle-color:#f57c00;--mdc-slider-focus-handle-color:#f57c00;--mdc-slider-hover-handle-color:#f57c00;--mdc-slider-active-track-color:#f57c00;--mdc-slider-inactive-track-color:#f57c00;--mdc-slider-with-tick-marks-active-container-color:#000;--mdc-slider-with-tick-marks-inactive-container-color:#f57c00;--mat-mdc-slider-ripple-color: #f57c00;--mat-mdc-slider-hover-ripple-color: rgba(245, 124, 0, 0.05);--mat-mdc-slider-focus-ripple-color: rgba(245, 124, 0, 0.2)}.mat-mdc-slider.mat-accent{--mdc-slider-handle-color:#ff9800;--mdc-slider-focus-handle-color:#ff9800;--mdc-slider-hover-handle-color:#ff9800;--mdc-slider-active-track-color:#ff9800;--mdc-slider-inactive-track-color:#ff9800;--mdc-slider-with-tick-marks-active-container-color:#000;--mdc-slider-with-tick-marks-inactive-container-color:#ff9800;--mat-mdc-slider-ripple-color: #ff9800;--mat-mdc-slider-hover-ripple-color: rgba(255, 152, 0, 0.05);--mat-mdc-slider-focus-ripple-color: rgba(255, 152, 0, 0.2)}.mat-mdc-slider.mat-warn{--mdc-slider-handle-color:#f44336;--mdc-slider-focus-handle-color:#f44336;--mdc-slider-hover-handle-color:#f44336;--mdc-slider-active-track-color:#f44336;--mdc-slider-inactive-track-color:#f44336;--mdc-slider-with-tick-marks-active-container-color:#fff;--mdc-slider-with-tick-marks-inactive-container-color:#f44336;--mat-mdc-slider-ripple-color: #f44336;--mat-mdc-slider-hover-ripple-color: rgba(244, 67, 54, 0.05);--mat-mdc-slider-focus-ripple-color: rgba(244, 67, 54, 0.2)}.mdc-menu-surface{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2), 0px 8px 10px 1px rgba(0, 0, 0, 0.14), 0px 3px 14px 2px rgba(0, 0, 0, 0.12);background-color:var(--mdc-theme-surface, #fff);color:var(--mdc-theme-on-surface, #000)}.mdc-list-item__primary-text{color:var(--mdc-theme-text-primary-on-background, rgba(0, 0, 0, 0.87))}.mdc-list-item__secondary-text{color:var(--mdc-theme-text-secondary-on-background, rgba(0, 0, 0, 0.54))}.mdc-list-item__overline-text{color:var(--mdc-theme-text-hint-on-background, rgba(0, 0, 0, 0.38))}.mdc-list-item--with-leading-icon .mdc-list-item__start,.mdc-list-item--with-trailing-icon .mdc-list-item__end{background-color:transparent}.mdc-list-item--with-leading-icon .mdc-list-item__start,.mdc-list-item--with-trailing-icon .mdc-list-item__end{color:var(--mdc-theme-text-icon-on-background, rgba(0, 0, 0, 0.38))}.mdc-list-item__end{color:var(--mdc-theme-text-hint-on-background, rgba(0, 0, 0, 0.38))}.mdc-list-item--disabled .mdc-list-item__start,.mdc-list-item--disabled .mdc-list-item__content,.mdc-list-item--disabled .mdc-list-item__end{opacity:0.38}.mdc-list-item--disabled .mdc-list-item__primary-text{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled .mdc-list-item__secondary-text{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled .mdc-list-item__overline-text{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled.mdc-list-item--with-leading-icon .mdc-list-item__start{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled.mdc-list-item--with-trailing-icon .mdc-list-item__end{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled.mdc-list-item--with-trailing-meta .mdc-list-item__end{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--selected .mdc-list-item__primary-text,.mdc-list-item--activated .mdc-list-item__primary-text{color:var(--mdc-theme-primary, #f57c00)}.mdc-list-item--selected.mdc-list-item--with-leading-icon .mdc-list-item__start,.mdc-list-item--activated.mdc-list-item--with-leading-icon .mdc-list-item__start{color:var(--mdc-theme-primary, #f57c00)}.mdc-deprecated-list-group__subheader{color:var(--mdc-theme-text-primary-on-background, rgba(0, 0, 0, 0.87))}.mdc-list-divider::after{border-bottom-color:white}.mdc-list-divider{background-color:rgba(0, 0, 0, 0.12)}.mat-mdc-menu-item[disabled],.mat-mdc-menu-item[disabled] .mat-mdc-menu-submenu-icon,.mat-mdc-menu-item[disabled] .mat-icon-no-color{color:var(--mdc-theme-text-disabled-on-background, rgba(0, 0, 0, 0.38))}.mat-mdc-menu-item .mat-icon-no-color,.mat-mdc-menu-submenu-icon{color:var(--mdc-theme-text-primary-on-background, rgba(0, 0, 0, 0.87))}.mat-mdc-menu-item:hover:not([disabled]),.mat-mdc-menu-item.cdk-program-focused:not([disabled]),.mat-mdc-menu-item.cdk-keyboard-focused:not([disabled]),.mat-mdc-menu-item-highlighted:not([disabled]){background:rgba(0,0,0,.04)}.mat-mdc-list-base{--mdc-list-list-item-label-text-color:#212121;--mdc-list-list-item-supporting-text-color:#616161;--mdc-list-list-item-leading-icon-color:rgba(0, 0, 0, 0.38);--mdc-list-list-item-trailing-supporting-text-color:rgba(0, 0, 0, 0.38);--mdc-list-list-item-trailing-icon-color:rgba(0, 0, 0, 0.38);--mdc-list-list-item-selected-trailing-icon-color:rgba(0, 0, 0, 0.38);--mdc-list-list-item-disabled-label-text-color:black;--mdc-list-list-item-disabled-leading-icon-color:black;--mdc-list-list-item-disabled-trailing-icon-color:black;--mdc-list-list-item-hover-label-text-color:#212121;--mdc-list-list-item-hover-leading-icon-color:rgba(0, 0, 0, 0.38);--mdc-list-list-item-hover-trailing-icon-color:rgba(0, 0, 0, 0.38);--mdc-list-list-item-focus-label-text-color:#212121;--mdc-list-list-item-hover-state-layer-color:black;--mdc-list-list-item-hover-state-layer-opacity:0.04;--mdc-list-list-item-focus-state-layer-color:black;--mdc-list-list-item-focus-state-layer-opacity:0.12}.mat-mdc-list-option .mdc-list-item__start,.mat-mdc-list-option .mdc-list-item__end{--mdc-checkbox-selected-checkmark-color:#000;--mdc-checkbox-selected-focus-icon-color:#f57c00;--mdc-checkbox-selected-hover-icon-color:#f57c00;--mdc-checkbox-selected-icon-color:#f57c00;--mdc-checkbox-selected-pressed-icon-color:#f57c00;--mdc-checkbox-unselected-focus-icon-color:#212121;--mdc-checkbox-unselected-hover-icon-color:#212121;--mdc-checkbox-disabled-selected-icon-color:rgba(0, 0, 0, 0.38);--mdc-checkbox-disabled-unselected-icon-color:rgba(0, 0, 0, 0.38);--mdc-checkbox-unselected-icon-color:rgba(0, 0, 0, 0.54);--mdc-checkbox-unselected-pressed-icon-color:rgba(0, 0, 0, 0.54)}.mat-mdc-list-option .mdc-list-item__start,.mat-mdc-list-option .mdc-list-item__end{--mdc-radio-disabled-selected-icon-color:#000;--mdc-radio-disabled-unselected-icon-color:#000;--mdc-radio-unselected-focus-icon-color:#212121;--mdc-radio-unselected-hover-icon-color:#212121;--mdc-radio-unselected-icon-color:rgba(0, 0, 0, 0.54);--mdc-radio-unselected-pressed-icon-color:rgba(0, 0, 0, 0.54);--mdc-radio-selected-focus-icon-color:#f57c00;--mdc-radio-selected-hover-icon-color:#f57c00;--mdc-radio-selected-icon-color:#f57c00;--mdc-radio-selected-pressed-icon-color:#f57c00;--mat-mdc-radio-ripple-color: #000;--mat-mdc-radio-checked-ripple-color: #f57c00}.mat-mdc-list-option .mdc-list-item__start .mdc-radio--disabled+label,.mat-mdc-list-option .mdc-list-item__end .mdc-radio--disabled+label{color:#757575}.mat-mdc-list-option.mat-accent .mdc-list-item__start,.mat-mdc-list-option.mat-accent .mdc-list-item__end{--mdc-checkbox-selected-checkmark-color:#000;--mdc-checkbox-selected-focus-icon-color:#ff9800;--mdc-checkbox-selected-hover-icon-color:#ff9800;--mdc-checkbox-selected-icon-color:#ff9800;--mdc-checkbox-selected-pressed-icon-color:#ff9800;--mdc-checkbox-unselected-focus-icon-color:#212121;--mdc-checkbox-unselected-hover-icon-color:#212121;--mdc-checkbox-disabled-selected-icon-color:rgba(0, 0, 0, 0.38);--mdc-checkbox-disabled-unselected-icon-color:rgba(0, 0, 0, 0.38);--mdc-checkbox-unselected-icon-color:rgba(0, 0, 0, 0.54);--mdc-checkbox-unselected-pressed-icon-color:rgba(0, 0, 0, 0.54)}.mat-mdc-list-option.mat-accent .mdc-list-item__start,.mat-mdc-list-option.mat-accent .mdc-list-item__end{--mdc-radio-disabled-selected-icon-color:#000;--mdc-radio-disabled-unselected-icon-color:#000;--mdc-radio-unselected-focus-icon-color:#212121;--mdc-radio-unselected-hover-icon-color:#212121;--mdc-radio-unselected-icon-color:rgba(0, 0, 0, 0.54);--mdc-radio-unselected-pressed-icon-color:rgba(0, 0, 0, 0.54);--mdc-radio-selected-focus-icon-color:#ff9800;--mdc-radio-selected-hover-icon-color:#ff9800;--mdc-radio-selected-icon-color:#ff9800;--mdc-radio-selected-pressed-icon-color:#ff9800;--mat-mdc-radio-ripple-color: #000;--mat-mdc-radio-checked-ripple-color: #ff9800}.mat-mdc-list-option.mat-accent .mdc-list-item__start .mdc-radio--disabled+label,.mat-mdc-list-option.mat-accent .mdc-list-item__end .mdc-radio--disabled+label{color:#757575}.mat-mdc-list-option.mat-warn .mdc-list-item__start,.mat-mdc-list-option.mat-warn .mdc-list-item__end{--mdc-checkbox-selected-checkmark-color:#fff;--mdc-checkbox-selected-focus-icon-color:#f44336;--mdc-checkbox-selected-hover-icon-color:#f44336;--mdc-checkbox-selected-icon-color:#f44336;--mdc-checkbox-selected-pressed-icon-color:#f44336;--mdc-checkbox-unselected-focus-icon-color:#212121;--mdc-checkbox-unselected-hover-icon-color:#212121;--mdc-checkbox-disabled-selected-icon-color:rgba(0, 0, 0, 0.38);--mdc-checkbox-disabled-unselected-icon-color:rgba(0, 0, 0, 0.38);--mdc-checkbox-unselected-icon-color:rgba(0, 0, 0, 0.54);--mdc-checkbox-unselected-pressed-icon-color:rgba(0, 0, 0, 0.54)}.mat-mdc-list-option.mat-warn .mdc-list-item__start,.mat-mdc-list-option.mat-warn .mdc-list-item__end{--mdc-radio-disabled-selected-icon-color:#000;--mdc-radio-disabled-unselected-icon-color:#000;--mdc-radio-unselected-focus-icon-color:#212121;--mdc-radio-unselected-hover-icon-color:#212121;--mdc-radio-unselected-icon-color:rgba(0, 0, 0, 0.54);--mdc-radio-unselected-pressed-icon-color:rgba(0, 0, 0, 0.54);--mdc-radio-selected-focus-icon-color:#f44336;--mdc-radio-selected-hover-icon-color:#f44336;--mdc-radio-selected-icon-color:#f44336;--mdc-radio-selected-pressed-icon-color:#f44336;--mat-mdc-radio-ripple-color: #000;--mat-mdc-radio-checked-ripple-color: #f44336}.mat-mdc-list-option.mat-warn .mdc-list-item__start .mdc-radio--disabled+label,.mat-mdc-list-option.mat-warn .mdc-list-item__end .mdc-radio--disabled+label{color:#757575}.mat-mdc-list-base.mat-mdc-list-base .mdc-list-item--selected .mdc-list-item__primary-text,.mat-mdc-list-base.mat-mdc-list-base .mdc-list-item--activated .mdc-list-item__primary-text{color:#f57c00}.mat-mdc-list-base.mat-mdc-list-base .mdc-list-item--selected.mdc-list-item--with-leading-icon .mdc-list-item__start,.mat-mdc-list-base.mat-mdc-list-base .mdc-list-item--activated.mdc-list-item--with-leading-icon .mdc-list-item__start{color:#f57c00}.mat-mdc-list-base .mdc-list-item--disabled .mdc-list-item__start,.mat-mdc-list-base .mdc-list-item--disabled .mdc-list-item__content,.mat-mdc-list-base .mdc-list-item--disabled .mdc-list-item__end{opacity:1}.mat-mdc-list-base{--mdc-list-list-item-one-line-container-height:48px;--mdc-list-list-item-two-line-container-height:64px;--mdc-list-list-item-three-line-container-height:88px}.mat-mdc-list-item.mdc-list-item--with-leading-avatar.mdc-list-item--with-one-line,.mat-mdc-list-item.mdc-list-item--with-leading-checkbox.mdc-list-item--with-one-line,.mat-mdc-list-item.mdc-list-item--with-leading-icon.mdc-list-item--with-one-line{height:56px}.mat-mdc-list-item.mdc-list-item--with-leading-avatar.mdc-list-item--with-two-lines,.mat-mdc-list-item.mdc-list-item--with-leading-checkbox.mdc-list-item--with-two-lines,.mat-mdc-list-item.mdc-list-item--with-leading-icon.mdc-list-item--with-two-lines{height:72px}.mat-mdc-paginator{background:#fff;color:rgba(0,0,0,.87)}.mat-mdc-paginator-icon{fill:rgba(0,0,0,.54)}.mat-mdc-paginator-decrement,.mat-mdc-paginator-increment{border-top:2px solid rgba(0,0,0,.54);border-right:2px solid rgba(0,0,0,.54)}.mat-mdc-paginator-first,.mat-mdc-paginator-last{border-top:2px solid rgba(0,0,0,.54)}.mat-mdc-icon-button[disabled] .mat-mdc-paginator-decrement,.mat-mdc-icon-button[disabled] .mat-mdc-paginator-increment,.mat-mdc-icon-button[disabled] .mat-mdc-paginator-first,.mat-mdc-icon-button[disabled] .mat-mdc-paginator-last{border-color:rgba(0,0,0,.12)}.mat-mdc-icon-button[disabled] .mat-mdc-paginator-icon{fill:rgba(0,0,0,.12)}.mat-mdc-paginator .mat-mdc-form-field-infix{min-height:40px}.mat-mdc-paginator .mat-mdc-text-field-wrapper .mat-mdc-form-field-flex .mat-mdc-floating-label{top:20px}.mat-mdc-paginator .mat-mdc-text-field-wrapper.mdc-text-field--outlined .mdc-notched-outline--upgraded .mdc-floating-label--float-above{--mat-mdc-form-field-label-transform: translateY( -26.75px) scale(var(--mat-mdc-form-field-floating-label-scale, 0.75));transform:var(--mat-mdc-form-field-label-transform)}.mat-mdc-paginator .mat-mdc-text-field-wrapper.mdc-text-field--outlined .mat-mdc-form-field-infix{padding-top:8px;padding-bottom:8px}.mat-mdc-paginator .mat-mdc-text-field-wrapper:not(.mdc-text-field--outlined) .mat-mdc-form-field-infix{padding-top:8px;padding-bottom:8px}.mat-mdc-paginator .mdc-text-field--no-label:not(.mdc-text-field--outlined):not(.mdc-text-field--textarea) .mat-mdc-form-field-infix{padding-top:8px;padding-bottom:8px}.mat-mdc-paginator .mat-mdc-text-field-wrapper:not(.mdc-text-field--outlined) .mat-mdc-floating-label{display:none}.mat-mdc-paginator-container{min-height:56px}.mat-mdc-tab,.mat-mdc-tab-link{background-color:rgba(0,0,0,0)}.mat-mdc-tab .mdc-tab__text-label,.mat-mdc-tab-link .mdc-tab__text-label{color:rgba(0, 0, 0, 0.6)}.mat-mdc-tab.mat-mdc-tab-disabled .mdc-tab__ripple::before,.mat-mdc-tab.mat-mdc-tab-disabled .mat-ripple-element,.mat-mdc-tab-link.mat-mdc-tab-disabled .mdc-tab__ripple::before,.mat-mdc-tab-link.mat-mdc-tab-disabled .mat-ripple-element{background-color:rgba(0,0,0,.38)}.mat-mdc-tab:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label,.mat-mdc-tab-link:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label{color:#f57c00}.mat-mdc-tab:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline,.mat-mdc-tab-link:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline{border-color:var(--mdc-tab-indicator-active-indicator-color, #f57c00)}.mdc-tab__ripple::before,.mat-mdc-tab .mat-ripple-element,.mat-mdc-tab-header-pagination .mat-ripple-element,.mat-mdc-tab-link .mat-ripple-element{background-color:#f57c00}.mat-mdc-tab-group.mat-accent .mat-mdc-tab:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label,.mat-mdc-tab-group.mat-accent .mat-mdc-tab-link:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label,.mat-mdc-tab-nav-bar.mat-accent .mat-mdc-tab:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label,.mat-mdc-tab-nav-bar.mat-accent .mat-mdc-tab-link:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label{color:#ff9800}.mat-mdc-tab-group.mat-accent .mat-mdc-tab:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline,.mat-mdc-tab-group.mat-accent .mat-mdc-tab-link:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline,.mat-mdc-tab-nav-bar.mat-accent .mat-mdc-tab:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline,.mat-mdc-tab-nav-bar.mat-accent .mat-mdc-tab-link:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline{border-color:var(--mdc-tab-indicator-active-indicator-color, #ff9800)}.mat-mdc-tab-group.mat-accent .mdc-tab__ripple::before,.mat-mdc-tab-group.mat-accent .mat-mdc-tab .mat-ripple-element,.mat-mdc-tab-group.mat-accent .mat-mdc-tab-header-pagination .mat-ripple-element,.mat-mdc-tab-group.mat-accent .mat-mdc-tab-link .mat-ripple-element,.mat-mdc-tab-nav-bar.mat-accent .mdc-tab__ripple::before,.mat-mdc-tab-nav-bar.mat-accent .mat-mdc-tab .mat-ripple-element,.mat-mdc-tab-nav-bar.mat-accent .mat-mdc-tab-header-pagination .mat-ripple-element,.mat-mdc-tab-nav-bar.mat-accent .mat-mdc-tab-link .mat-ripple-element{background-color:#ff9800}.mat-mdc-tab-group.mat-warn .mat-mdc-tab:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label,.mat-mdc-tab-group.mat-warn .mat-mdc-tab-link:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label,.mat-mdc-tab-nav-bar.mat-warn .mat-mdc-tab:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label,.mat-mdc-tab-nav-bar.mat-warn .mat-mdc-tab-link:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label{color:#f44336}.mat-mdc-tab-group.mat-warn .mat-mdc-tab:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline,.mat-mdc-tab-group.mat-warn .mat-mdc-tab-link:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline,.mat-mdc-tab-nav-bar.mat-warn .mat-mdc-tab:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline,.mat-mdc-tab-nav-bar.mat-warn .mat-mdc-tab-link:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline{border-color:var(--mdc-tab-indicator-active-indicator-color, #f44336)}.mat-mdc-tab-group.mat-warn .mdc-tab__ripple::before,.mat-mdc-tab-group.mat-warn .mat-mdc-tab .mat-ripple-element,.mat-mdc-tab-group.mat-warn .mat-mdc-tab-header-pagination .mat-ripple-element,.mat-mdc-tab-group.mat-warn .mat-mdc-tab-link .mat-ripple-element,.mat-mdc-tab-nav-bar.mat-warn .mdc-tab__ripple::before,.mat-mdc-tab-nav-bar.mat-warn .mat-mdc-tab .mat-ripple-element,.mat-mdc-tab-nav-bar.mat-warn .mat-mdc-tab-header-pagination .mat-ripple-element,.mat-mdc-tab-nav-bar.mat-warn .mat-mdc-tab-link .mat-ripple-element{background-color:#f44336}.mat-mdc-tab-group.mat-background-primary,.mat-mdc-tab-nav-bar.mat-background-primary{--mat-mdc-tab-header-with-background-background-color: #f57c00;--mat-mdc-tab-header-with-background-foreground-color: #000}.mat-mdc-tab-group.mat-background-accent,.mat-mdc-tab-nav-bar.mat-background-accent{--mat-mdc-tab-header-with-background-background-color: #ff9800;--mat-mdc-tab-header-with-background-foreground-color: #000}.mat-mdc-tab-group.mat-background-warn,.mat-mdc-tab-nav-bar.mat-background-warn{--mat-mdc-tab-header-with-background-background-color: #f44336;--mat-mdc-tab-header-with-background-foreground-color: #fff}.mat-mdc-tab-header-pagination-chevron{border-color:var(--mdc-theme-on-surface, #000)}.mat-mdc-tab-header .mdc-tab{height:48px}.mat-mdc-checkbox .mdc-form-field{color:var(--mdc-theme-text-primary-on-background, rgba(0, 0, 0, 0.87))}.mat-mdc-checkbox .mat-ripple-element{background-color:rgba(0,0,0,.1)}.mat-mdc-checkbox .mdc-checkbox__ripple{background:#000}.mat-mdc-checkbox.mat-primary{--mdc-checkbox-selected-checkmark-color:#000;--mdc-checkbox-selected-focus-icon-color:#f57c00;--mdc-checkbox-selected-hover-icon-color:#f57c00;--mdc-checkbox-selected-icon-color:#f57c00;--mdc-checkbox-selected-pressed-icon-color:#f57c00;--mdc-checkbox-unselected-focus-icon-color:#212121;--mdc-checkbox-unselected-hover-icon-color:#212121;--mdc-checkbox-disabled-selected-icon-color:rgba(0, 0, 0, 0.38);--mdc-checkbox-disabled-unselected-icon-color:rgba(0, 0, 0, 0.38);--mdc-checkbox-unselected-icon-color:rgba(0, 0, 0, 0.54);--mdc-checkbox-unselected-pressed-icon-color:rgba(0, 0, 0, 0.54)}.mat-mdc-checkbox.mat-primary .mdc-checkbox--selected~.mat-mdc-checkbox-ripple .mat-ripple-element{background-color:rgba(245,124,0,.1)}.mat-mdc-checkbox.mat-primary .mdc-checkbox--selected~.mdc-checkbox__ripple{background:#f57c00}.mat-mdc-checkbox.mat-accent{--mdc-checkbox-selected-checkmark-color:#000;--mdc-checkbox-selected-focus-icon-color:#ff9800;--mdc-checkbox-selected-hover-icon-color:#ff9800;--mdc-checkbox-selected-icon-color:#ff9800;--mdc-checkbox-selected-pressed-icon-color:#ff9800;--mdc-checkbox-unselected-focus-icon-color:#212121;--mdc-checkbox-unselected-hover-icon-color:#212121;--mdc-checkbox-disabled-selected-icon-color:rgba(0, 0, 0, 0.38);--mdc-checkbox-disabled-unselected-icon-color:rgba(0, 0, 0, 0.38);--mdc-checkbox-unselected-icon-color:rgba(0, 0, 0, 0.54);--mdc-checkbox-unselected-pressed-icon-color:rgba(0, 0, 0, 0.54)}.mat-mdc-checkbox.mat-accent .mdc-checkbox--selected~.mat-mdc-checkbox-ripple .mat-ripple-element{background-color:rgba(255,152,0,.1)}.mat-mdc-checkbox.mat-accent .mdc-checkbox--selected~.mdc-checkbox__ripple{background:#ff9800}.mat-mdc-checkbox.mat-warn{--mdc-checkbox-selected-checkmark-color:#fff;--mdc-checkbox-selected-focus-icon-color:#f44336;--mdc-checkbox-selected-hover-icon-color:#f44336;--mdc-checkbox-selected-icon-color:#f44336;--mdc-checkbox-selected-pressed-icon-color:#f44336;--mdc-checkbox-unselected-focus-icon-color:#212121;--mdc-checkbox-unselected-hover-icon-color:#212121;--mdc-checkbox-disabled-selected-icon-color:rgba(0, 0, 0, 0.38);--mdc-checkbox-disabled-unselected-icon-color:rgba(0, 0, 0, 0.38);--mdc-checkbox-unselected-icon-color:rgba(0, 0, 0, 0.54);--mdc-checkbox-unselected-pressed-icon-color:rgba(0, 0, 0, 0.54)}.mat-mdc-checkbox.mat-warn .mdc-checkbox--selected~.mat-mdc-checkbox-ripple .mat-ripple-element{background-color:rgba(244,67,54,.1)}.mat-mdc-checkbox.mat-warn .mdc-checkbox--selected~.mdc-checkbox__ripple{background:#f44336}.mat-mdc-checkbox-disabled label{color:#757575}.mat-mdc-checkbox .mdc-checkbox{padding:calc((var(--mdc-checkbox-ripple-size, 40px) - 18px) / 2);margin:calc((var(--mdc-checkbox-touch-target-size, 40px) - 40px) / 2)}.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__background{top:calc((var(--mdc-checkbox-ripple-size, 40px) - 18px) / 2);left:calc((var(--mdc-checkbox-ripple-size, 40px) - 18px) / 2)}.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__native-control{top:calc((40px - var(--mdc-checkbox-touch-target-size, 40px)) / 2);right:calc((40px - var(--mdc-checkbox-touch-target-size, 40px)) / 2);left:calc((40px - var(--mdc-checkbox-touch-target-size, 40px)) / 2);width:var(--mdc-checkbox-touch-target-size, 40px);height:var(--mdc-checkbox-touch-target-size, 40px)}.mat-mdc-button.mat-unthemed{--mdc-text-button-label-text-color:#000}.mat-mdc-button.mat-primary{--mdc-text-button-label-text-color:#f57c00}.mat-mdc-button.mat-accent{--mdc-text-button-label-text-color:#ff9800}.mat-mdc-button.mat-warn{--mdc-text-button-label-text-color:#f44336}.mat-mdc-button[disabled][disabled]{--mdc-text-button-disabled-label-text-color:rgba(0, 0, 0, 0.38);--mdc-text-button-label-text-color:rgba(0, 0, 0, 0.38)}.mat-mdc-unelevated-button.mat-unthemed{--mdc-filled-button-container-color:#fff;--mdc-filled-button-label-text-color:#000}.mat-mdc-unelevated-button.mat-primary{--mdc-filled-button-container-color:#f57c00;--mdc-filled-button-label-text-color:#000}.mat-mdc-unelevated-button.mat-accent{--mdc-filled-button-container-color:#ff9800;--mdc-filled-button-label-text-color:#000}.mat-mdc-unelevated-button.mat-warn{--mdc-filled-button-container-color:#f44336;--mdc-filled-button-label-text-color:#fff}.mat-mdc-unelevated-button[disabled][disabled]{--mdc-filled-button-disabled-container-color:rgba(0, 0, 0, 0.12);--mdc-filled-button-disabled-label-text-color:rgba(0, 0, 0, 0.38);--mdc-filled-button-container-color:rgba(0, 0, 0, 0.12);--mdc-filled-button-label-text-color:rgba(0, 0, 0, 0.38)}.mat-mdc-raised-button.mat-unthemed{--mdc-protected-button-container-color:#fff;--mdc-protected-button-label-text-color:#000}.mat-mdc-raised-button.mat-primary{--mdc-protected-button-container-color:#f57c00;--mdc-protected-button-label-text-color:#000}.mat-mdc-raised-button.mat-accent{--mdc-protected-button-container-color:#ff9800;--mdc-protected-button-label-text-color:#000}.mat-mdc-raised-button.mat-warn{--mdc-protected-button-container-color:#f44336;--mdc-protected-button-label-text-color:#fff}.mat-mdc-raised-button[disabled][disabled]{--mdc-protected-button-disabled-container-color:rgba(0, 0, 0, 0.12);--mdc-protected-button-disabled-label-text-color:rgba(0, 0, 0, 0.38);--mdc-protected-button-container-color:rgba(0, 0, 0, 0.12);--mdc-protected-button-label-text-color:rgba(0, 0, 0, 0.38);--mdc-protected-button-container-elevation:0}.mat-mdc-outlined-button{--mdc-outlined-button-outline-color:rgba(0, 0, 0, 0.12)}.mat-mdc-outlined-button.mat-unthemed{--mdc-outlined-button-label-text-color:#000}.mat-mdc-outlined-button.mat-primary{--mdc-outlined-button-label-text-color:#f57c00}.mat-mdc-outlined-button.mat-accent{--mdc-outlined-button-label-text-color:#ff9800}.mat-mdc-outlined-button.mat-warn{--mdc-outlined-button-label-text-color:#f44336}.mat-mdc-outlined-button[disabled][disabled]{--mdc-outlined-button-label-text-color:rgba(0, 0, 0, 0.38);--mdc-outlined-button-disabled-label-text-color:rgba(0, 0, 0, 0.38);--mdc-outlined-button-outline-color:rgba(0, 0, 0, 0.12);--mdc-outlined-button-disabled-outline-color:rgba(0, 0, 0, 0.12)}.mat-mdc-button,.mat-mdc-outlined-button{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}.mat-mdc-button:hover .mat-mdc-button-persistent-ripple::before,.mat-mdc-outlined-button:hover .mat-mdc-button-persistent-ripple::before{opacity:.04}.mat-mdc-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,.mat-mdc-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before,.mat-mdc-outlined-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,.mat-mdc-outlined-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before{opacity:.12}.mat-mdc-button:active .mat-mdc-button-persistent-ripple::before,.mat-mdc-outlined-button:active .mat-mdc-button-persistent-ripple::before{opacity:.12}.mat-mdc-button.mat-primary,.mat-mdc-outlined-button.mat-primary{--mat-mdc-button-persistent-ripple-color: #f57c00;--mat-mdc-button-ripple-color: rgba(245, 124, 0, 0.1)}.mat-mdc-button.mat-accent,.mat-mdc-outlined-button.mat-accent{--mat-mdc-button-persistent-ripple-color: #ff9800;--mat-mdc-button-ripple-color: rgba(255, 152, 0, 0.1)}.mat-mdc-button.mat-warn,.mat-mdc-outlined-button.mat-warn{--mat-mdc-button-persistent-ripple-color: #f44336;--mat-mdc-button-ripple-color: rgba(244, 67, 54, 0.1)}.mat-mdc-raised-button,.mat-mdc-unelevated-button{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}.mat-mdc-raised-button:hover .mat-mdc-button-persistent-ripple::before,.mat-mdc-unelevated-button:hover .mat-mdc-button-persistent-ripple::before{opacity:.04}.mat-mdc-raised-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,.mat-mdc-raised-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before,.mat-mdc-unelevated-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,.mat-mdc-unelevated-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before{opacity:.12}.mat-mdc-raised-button:active .mat-mdc-button-persistent-ripple::before,.mat-mdc-unelevated-button:active .mat-mdc-button-persistent-ripple::before{opacity:.12}.mat-mdc-raised-button.mat-primary,.mat-mdc-unelevated-button.mat-primary{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}.mat-mdc-raised-button.mat-accent,.mat-mdc-unelevated-button.mat-accent{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}.mat-mdc-raised-button.mat-warn,.mat-mdc-unelevated-button.mat-warn{--mat-mdc-button-persistent-ripple-color: #fff;--mat-mdc-button-ripple-color: rgba(255, 255, 255, 0.1)}.mat-mdc-button.mat-mdc-button-base,.mat-mdc-raised-button.mat-mdc-button-base,.mat-mdc-unelevated-button.mat-mdc-button-base,.mat-mdc-outlined-button.mat-mdc-button-base{height:36px}.mat-mdc-icon-button{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}.mat-mdc-icon-button:hover .mat-mdc-button-persistent-ripple::before{opacity:.04}.mat-mdc-icon-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,.mat-mdc-icon-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before{opacity:.12}.mat-mdc-icon-button:active .mat-mdc-button-persistent-ripple::before{opacity:.12}.mat-mdc-icon-button.mat-primary{--mat-mdc-button-persistent-ripple-color: #f57c00;--mat-mdc-button-ripple-color: rgba(245, 124, 0, 0.1)}.mat-mdc-icon-button.mat-accent{--mat-mdc-button-persistent-ripple-color: #ff9800;--mat-mdc-button-ripple-color: rgba(255, 152, 0, 0.1)}.mat-mdc-icon-button.mat-warn{--mat-mdc-button-persistent-ripple-color: #f44336;--mat-mdc-button-ripple-color: rgba(244, 67, 54, 0.1)}.mat-mdc-icon-button.mat-primary{--mdc-icon-button-icon-color:#f57c00}.mat-mdc-icon-button.mat-accent{--mdc-icon-button-icon-color:#ff9800}.mat-mdc-icon-button.mat-warn{--mdc-icon-button-icon-color:#f44336}.mat-mdc-icon-button[disabled][disabled]{--mdc-icon-button-icon-color:rgba(0, 0, 0, 0.38);--mdc-icon-button-disabled-icon-color:rgba(0, 0, 0, 0.38)}.mat-mdc-icon-button.mat-mdc-button-base{width:48px;height:48px;padding:12px}.mat-mdc-icon-button.mat-mdc-button-base .mdc-icon-button__focus-ring{max-height:48px;max-width:48px}.mat-mdc-icon-button.mat-mdc-button-base.mdc-icon-button--reduced-size .mdc-icon-button__ripple{width:40px;height:40px;margin-top:4px;margin-bottom:4px;margin-right:4px;margin-left:4px}.mat-mdc-icon-button.mat-mdc-button-base.mdc-icon-button--reduced-size .mdc-icon-button__focus-ring{max-height:40px;max-width:40px}.mat-mdc-icon-button.mat-mdc-button-base .mdc-icon-button__touch{position:absolute;top:50%;height:48px;left:50%;width:48px;transform:translate(-50%, -50%)}.mat-mdc-fab,.mat-mdc-mini-fab{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}.mat-mdc-fab:hover .mat-mdc-button-persistent-ripple::before,.mat-mdc-mini-fab:hover .mat-mdc-button-persistent-ripple::before{opacity:.04}.mat-mdc-fab.cdk-program-focused .mat-mdc-button-persistent-ripple::before,.mat-mdc-fab.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before,.mat-mdc-mini-fab.cdk-program-focused .mat-mdc-button-persistent-ripple::before,.mat-mdc-mini-fab.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before{opacity:.12}.mat-mdc-fab:active .mat-mdc-button-persistent-ripple::before,.mat-mdc-mini-fab:active .mat-mdc-button-persistent-ripple::before{opacity:.12}.mat-mdc-fab.mat-primary,.mat-mdc-mini-fab.mat-primary{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}.mat-mdc-fab.mat-accent,.mat-mdc-mini-fab.mat-accent{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}.mat-mdc-fab.mat-warn,.mat-mdc-mini-fab.mat-warn{--mat-mdc-button-persistent-ripple-color: #fff;--mat-mdc-button-ripple-color: rgba(255, 255, 255, 0.1)}.mat-mdc-fab.mat-unthemed,.mat-mdc-mini-fab.mat-unthemed{--mdc-fab-container-color:#fff;--mdc-fab-icon-color:#000;--mat-mdc-fab-color: #000}.mat-mdc-fab.mat-primary,.mat-mdc-mini-fab.mat-primary{--mdc-fab-container-color:#f57c00;--mdc-fab-icon-color:#000;--mat-mdc-fab-color: #000}.mat-mdc-fab.mat-accent,.mat-mdc-mini-fab.mat-accent{--mdc-fab-container-color:#ff9800;--mdc-fab-icon-color:#000;--mat-mdc-fab-color: #000}.mat-mdc-fab.mat-warn,.mat-mdc-mini-fab.mat-warn{--mdc-fab-container-color:#f44336;--mdc-fab-icon-color:#fff;--mat-mdc-fab-color: #fff}.mat-mdc-fab[disabled][disabled],.mat-mdc-mini-fab[disabled][disabled]{--mdc-fab-container-color:rgba(0, 0, 0, 0.12);--mdc-fab-icon-color:rgba(0, 0, 0, 0.38);--mat-mdc-fab-color: rgba(0, 0, 0, 0.38)}.mat-mdc-snack-bar-container{--mat-mdc-snack-bar-button-color: #ff9800;--mdc-snackbar-container-color:#333333;--mdc-snackbar-supporting-text-color:rgba(255, 255, 255, 0.87)}.mdc-data-table{background-color:var(--mdc-theme-surface, #fff);border-color:rgba(0, 0, 0, 0.12)}.mdc-data-table__row{background-color:inherit}.mdc-data-table__header-cell{background-color:var(--mdc-theme-surface, #fff)}.mdc-data-table__row--selected{background-color:rgba(245, 124, 0, 0.04)}.mdc-data-table__pagination-rows-per-page-select--outlined:not(.mdc-select--disabled) .mdc-notched-outline__leading,.mdc-data-table__pagination-rows-per-page-select--outlined:not(.mdc-select--disabled) .mdc-notched-outline__notch,.mdc-data-table__pagination-rows-per-page-select--outlined:not(.mdc-select--disabled) .mdc-notched-outline__trailing{border-color:rgba(0, 0, 0, 0.12)}.mdc-data-table__cell,.mdc-data-table__header-cell{border-bottom-color:rgba(0, 0, 0, 0.12)}.mdc-data-table__pagination{border-top-color:rgba(0, 0, 0, 0.12)}.mdc-data-table__row:not(.mdc-data-table__row--selected):hover{background-color:rgba(0, 0, 0, 0.04)}.mdc-data-table__header-cell{color:rgba(0, 0, 0, 0.87)}.mdc-data-table__pagination-total,.mdc-data-table__pagination-rows-per-page-label,.mdc-data-table__cell{color:rgba(0, 0, 0, 0.87)}.mat-mdc-table{background:#fff}.mat-mdc-table .mdc-data-table__row{height:52px}.mat-mdc-table .mdc-data-table__pagination{min-height:52px}.mat-mdc-table .mdc-data-table__header-row{height:56px}.mat-mdc-progress-spinner{--mdc-circular-progress-active-indicator-color:#f57c00}.mat-mdc-progress-spinner.mat-accent{--mdc-circular-progress-active-indicator-color:#ff9800}.mat-mdc-progress-spinner.mat-warn{--mdc-circular-progress-active-indicator-color:#f44336}.mat-badge{position:relative}.mat-badge.mat-badge{overflow:visible}.mat-badge-hidden .mat-badge-content{display:none}.mat-badge-content{position:absolute;text-align:center;display:inline-block;border-radius:50%;transition:transform 200ms ease-in-out;transform:scale(0.6);overflow:hidden;white-space:nowrap;text-overflow:ellipsis;pointer-events:none}.ng-animate-disabled .mat-badge-content,.mat-badge-content._mat-animation-noopable{transition:none}.mat-badge-content.mat-badge-active{transform:none}.mat-badge-small .mat-badge-content{width:16px;height:16px;line-height:16px}.mat-badge-small.mat-badge-above .mat-badge-content{top:-8px}.mat-badge-small.mat-badge-below .mat-badge-content{bottom:-8px}.mat-badge-small.mat-badge-before .mat-badge-content{left:-16px}[dir=rtl] .mat-badge-small.mat-badge-before .mat-badge-content{left:auto;right:-16px}.mat-badge-small.mat-badge-after .mat-badge-content{right:-16px}[dir=rtl] .mat-badge-small.mat-badge-after .mat-badge-content{right:auto;left:-16px}.mat-badge-small.mat-badge-overlap.mat-badge-before .mat-badge-content{left:-8px}[dir=rtl] .mat-badge-small.mat-badge-overlap.mat-badge-before .mat-badge-content{left:auto;right:-8px}.mat-badge-small.mat-badge-overlap.mat-badge-after .mat-badge-content{right:-8px}[dir=rtl] .mat-badge-small.mat-badge-overlap.mat-badge-after .mat-badge-content{right:auto;left:-8px}.mat-badge-medium .mat-badge-content{width:22px;height:22px;line-height:22px}.mat-badge-medium.mat-badge-above .mat-badge-content{top:-11px}.mat-badge-medium.mat-badge-below .mat-badge-content{bottom:-11px}.mat-badge-medium.mat-badge-before .mat-badge-content{left:-22px}[dir=rtl] .mat-badge-medium.mat-badge-before .mat-badge-content{left:auto;right:-22px}.mat-badge-medium.mat-badge-after .mat-badge-content{right:-22px}[dir=rtl] .mat-badge-medium.mat-badge-after .mat-badge-content{right:auto;left:-22px}.mat-badge-medium.mat-badge-overlap.mat-badge-before .mat-badge-content{left:-11px}[dir=rtl] .mat-badge-medium.mat-badge-overlap.mat-badge-before .mat-badge-content{left:auto;right:-11px}.mat-badge-medium.mat-badge-overlap.mat-badge-after .mat-badge-content{right:-11px}[dir=rtl] .mat-badge-medium.mat-badge-overlap.mat-badge-after .mat-badge-content{right:auto;left:-11px}.mat-badge-large .mat-badge-content{width:28px;height:28px;line-height:28px}.mat-badge-large.mat-badge-above .mat-badge-content{top:-14px}.mat-badge-large.mat-badge-below .mat-badge-content{bottom:-14px}.mat-badge-large.mat-badge-before .mat-badge-content{left:-28px}[dir=rtl] .mat-badge-large.mat-badge-before .mat-badge-content{left:auto;right:-28px}.mat-badge-large.mat-badge-after .mat-badge-content{right:-28px}[dir=rtl] .mat-badge-large.mat-badge-after .mat-badge-content{right:auto;left:-28px}.mat-badge-large.mat-badge-overlap.mat-badge-before .mat-badge-content{left:-14px}[dir=rtl] .mat-badge-large.mat-badge-overlap.mat-badge-before .mat-badge-content{left:auto;right:-14px}.mat-badge-large.mat-badge-overlap.mat-badge-after .mat-badge-content{right:-14px}[dir=rtl] .mat-badge-large.mat-badge-overlap.mat-badge-after .mat-badge-content{right:auto;left:-14px}.mat-badge-content{color:#fff;background:#f57c00}.cdk-high-contrast-active .mat-badge-content{outline:solid 1px;border-radius:0}.mat-badge-accent .mat-badge-content{background:#ff9800;color:#fff}.mat-badge-warn .mat-badge-content{color:#fff;background:#f44336}.mat-badge-disabled .mat-badge-content{background:#bdbdbd;color:#757575}.mat-bottom-sheet-container{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2), 0px 16px 24px 2px rgba(0, 0, 0, 0.14), 0px 6px 30px 5px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-button-toggle-standalone:not([class*=mat-elevation-z]),.mat-button-toggle-group:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2), 0px 2px 2px 0px rgba(0, 0, 0, 0.14), 0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard:not([class*=mat-elevation-z]),.mat-button-toggle-group-appearance-standard:not([class*=mat-elevation-z]){box-shadow:none}.mat-button-toggle{color:rgba(0,0,0,.38)}.mat-button-toggle .mat-button-toggle-focus-overlay{background-color:rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard{color:#212121;background:#fff}.mat-button-toggle-appearance-standard .mat-button-toggle-focus-overlay{background-color:#000}.mat-button-toggle-group-appearance-standard .mat-button-toggle+.mat-button-toggle{border-left:solid 1px #e0e0e0}[dir=rtl] .mat-button-toggle-group-appearance-standard .mat-button-toggle+.mat-button-toggle{border-left:none;border-right:solid 1px #e0e0e0}.mat-button-toggle-group-appearance-standard.mat-button-toggle-vertical .mat-button-toggle+.mat-button-toggle{border-left:none;border-right:none;border-top:solid 1px #e0e0e0}.mat-button-toggle-checked{background-color:#e0e0e0;color:#616161}.mat-button-toggle-checked.mat-button-toggle-appearance-standard{color:#212121}.mat-button-toggle-disabled{color:rgba(0,0,0,.26);background-color:#eee}.mat-button-toggle-disabled.mat-button-toggle-appearance-standard{background:#fff}.mat-button-toggle-disabled.mat-button-toggle-checked{background-color:#bdbdbd}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard,.mat-button-toggle-group-appearance-standard{border:solid 1px #e0e0e0}.mat-button-toggle-appearance-standard .mat-button-toggle-label-content{line-height:48px}.mat-calendar-arrow{fill:rgba(0,0,0,.54)}.mat-datepicker-toggle,.mat-datepicker-content .mat-calendar-next-button,.mat-datepicker-content .mat-calendar-previous-button{color:rgba(0,0,0,.54)}.mat-calendar-table-header-divider::after{background:rgba(0,0,0,.12)}.mat-calendar-table-header,.mat-calendar-body-label{color:#616161}.mat-calendar-body-cell-content,.mat-date-range-input-separator{color:#212121;border-color:rgba(0,0,0,0)}.mat-calendar-body-disabled>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){color:#757575}.mat-form-field-disabled .mat-date-range-input-separator{color:#757575}.mat-calendar-body-in-preview{color:rgba(0,0,0,.24)}.mat-calendar-body-today:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.38)}.mat-calendar-body-disabled>.mat-calendar-body-today:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.18)}.mat-calendar-body-in-range::before{background:rgba(245,124,0,.2)}.mat-calendar-body-comparison-identical,.mat-calendar-body-in-comparison-range::before{background:rgba(249,171,0,.2)}.mat-calendar-body-comparison-bridge-start::before,[dir=rtl] .mat-calendar-body-comparison-bridge-end::before{background:linear-gradient(to right, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-comparison-bridge-end::before,[dir=rtl] .mat-calendar-body-comparison-bridge-start::before{background:linear-gradient(to left, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-in-range>.mat-calendar-body-comparison-identical,.mat-calendar-body-in-comparison-range.mat-calendar-body-in-range::after{background:#a8dab5}.mat-calendar-body-comparison-identical.mat-calendar-body-selected,.mat-calendar-body-in-comparison-range>.mat-calendar-body-selected{background:#46a35e}.mat-calendar-body-selected{background-color:#f57c00;color:#fff}.mat-calendar-body-disabled>.mat-calendar-body-selected{background-color:rgba(245,124,0,.4)}.mat-calendar-body-today.mat-calendar-body-selected{box-shadow:inset 0 0 0 1px #fff}.cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical),.cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(245,124,0,.3)}@media(hover: hover){.mat-calendar-body-cell:not(.mat-calendar-body-disabled):hover>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(245,124,0,.3)}}.mat-datepicker-content{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2), 0px 4px 5px 0px rgba(0, 0, 0, 0.14), 0px 1px 10px 0px rgba(0, 0, 0, 0.12);background-color:#fff;color:#212121}.mat-datepicker-content.mat-accent .mat-calendar-body-in-range::before{background:rgba(255,152,0,.2)}.mat-datepicker-content.mat-accent .mat-calendar-body-comparison-identical,.mat-datepicker-content.mat-accent .mat-calendar-body-in-comparison-range::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-accent .mat-calendar-body-comparison-bridge-start::before,.mat-datepicker-content.mat-accent [dir=rtl] .mat-calendar-body-comparison-bridge-end::before{background:linear-gradient(to right, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent .mat-calendar-body-comparison-bridge-end::before,.mat-datepicker-content.mat-accent [dir=rtl] .mat-calendar-body-comparison-bridge-start::before{background:linear-gradient(to left, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent .mat-calendar-body-in-range>.mat-calendar-body-comparison-identical,.mat-datepicker-content.mat-accent .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range::after{background:#a8dab5}.mat-datepicker-content.mat-accent .mat-calendar-body-comparison-identical.mat-calendar-body-selected,.mat-datepicker-content.mat-accent .mat-calendar-body-in-comparison-range>.mat-calendar-body-selected{background:#46a35e}.mat-datepicker-content.mat-accent .mat-calendar-body-selected{background-color:#ff9800;color:#fff}.mat-datepicker-content.mat-accent .mat-calendar-body-disabled>.mat-calendar-body-selected{background-color:rgba(255,152,0,.4)}.mat-datepicker-content.mat-accent .mat-calendar-body-today.mat-calendar-body-selected{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content.mat-accent .cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical),.mat-datepicker-content.mat-accent .cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(255,152,0,.3)}@media(hover: hover){.mat-datepicker-content.mat-accent .mat-calendar-body-cell:not(.mat-calendar-body-disabled):hover>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(255,152,0,.3)}}.mat-datepicker-content.mat-warn .mat-calendar-body-in-range::before{background:rgba(244,67,54,.2)}.mat-datepicker-content.mat-warn .mat-calendar-body-comparison-identical,.mat-datepicker-content.mat-warn .mat-calendar-body-in-comparison-range::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-warn .mat-calendar-body-comparison-bridge-start::before,.mat-datepicker-content.mat-warn [dir=rtl] .mat-calendar-body-comparison-bridge-end::before{background:linear-gradient(to right, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn .mat-calendar-body-comparison-bridge-end::before,.mat-datepicker-content.mat-warn [dir=rtl] .mat-calendar-body-comparison-bridge-start::before{background:linear-gradient(to left, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn .mat-calendar-body-in-range>.mat-calendar-body-comparison-identical,.mat-datepicker-content.mat-warn .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range::after{background:#a8dab5}.mat-datepicker-content.mat-warn .mat-calendar-body-comparison-identical.mat-calendar-body-selected,.mat-datepicker-content.mat-warn .mat-calendar-body-in-comparison-range>.mat-calendar-body-selected{background:#46a35e}.mat-datepicker-content.mat-warn .mat-calendar-body-selected{background-color:#f44336;color:#fff}.mat-datepicker-content.mat-warn .mat-calendar-body-disabled>.mat-calendar-body-selected{background-color:rgba(244,67,54,.4)}.mat-datepicker-content.mat-warn .mat-calendar-body-today.mat-calendar-body-selected{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content.mat-warn .cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical),.mat-datepicker-content.mat-warn .cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(244,67,54,.3)}@media(hover: hover){.mat-datepicker-content.mat-warn .mat-calendar-body-cell:not(.mat-calendar-body-disabled):hover>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(244,67,54,.3)}}.mat-datepicker-content-touch{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2), 0px 24px 38px 3px rgba(0, 0, 0, 0.14), 0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-datepicker-toggle-active{color:#f57c00}.mat-datepicker-toggle-active.mat-accent{color:#ff9800}.mat-datepicker-toggle-active.mat-warn{color:#f44336}.mat-date-range-input-inner[disabled]{color:#757575}.mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base{width:40px;height:40px;padding:8px}.mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base .mdc-icon-button__focus-ring{max-height:40px;max-width:40px}.mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base.mdc-icon-button--reduced-size .mdc-icon-button__ripple{width:40px;height:40px;margin-top:0px;margin-bottom:0px;margin-right:0px;margin-left:0px}.mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base.mdc-icon-button--reduced-size .mdc-icon-button__focus-ring{max-height:40px;max-width:40px}.mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base .mdc-icon-button__touch{position:absolute;top:50%;height:40px;left:50%;width:40px;transform:translate(-50%, -50%)}.mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base .mat-mdc-button-touch-target{display:none}.mat-divider{border-top-color:rgba(0,0,0,.12)}.mat-divider-vertical{border-right-color:rgba(0,0,0,.12)}.mat-expansion-panel{background:#fff;color:#212121}.mat-expansion-panel:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2), 0px 2px 2px 0px rgba(0, 0, 0, 0.14), 0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-action-row{border-top-color:rgba(0,0,0,.12)}.mat-expansion-panel .mat-expansion-panel-header.cdk-keyboard-focused:not([aria-disabled=true]),.mat-expansion-panel .mat-expansion-panel-header.cdk-program-focused:not([aria-disabled=true]),.mat-expansion-panel:not(.mat-expanded) .mat-expansion-panel-header:hover:not([aria-disabled=true]){background:rgba(0,0,0,.04)}@media(hover: none){.mat-expansion-panel:not(.mat-expanded):not([aria-disabled=true]) .mat-expansion-panel-header:hover{background:#fff}}.mat-expansion-panel-header-title{color:#212121}.mat-expansion-panel-header-description,.mat-expansion-indicator::after{color:#616161}.mat-expansion-panel-header[aria-disabled=true]{color:rgba(0,0,0,.26)}.mat-expansion-panel-header[aria-disabled=true] .mat-expansion-panel-header-title,.mat-expansion-panel-header[aria-disabled=true] .mat-expansion-panel-header-description{color:inherit}.mat-expansion-panel-header{height:48px}.mat-expansion-panel-header.mat-expanded{height:64px}.mat-icon.mat-primary{color:#f57c00}.mat-icon.mat-accent{color:#ff9800}.mat-icon.mat-warn{color:#f44336}.mat-drawer-container{background-color:#fff;color:#212121}.mat-drawer{background-color:#fff;color:#212121}.mat-drawer.mat-drawer-push{background-color:#fff}.mat-drawer:not(.mat-drawer-side){box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2), 0px 16px 24px 2px rgba(0, 0, 0, 0.14), 0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-drawer-side{border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-side.mat-drawer-end{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl] .mat-drawer-side{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl] .mat-drawer-side.mat-drawer-end{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-backdrop.mat-drawer-shown{background-color:rgba(0,0,0,.6)}.mat-step-header.cdk-keyboard-focused,.mat-step-header.cdk-program-focused,.mat-step-header:hover:not([aria-disabled]),.mat-step-header:hover[aria-disabled=false]{background-color:rgba(0,0,0,.04)}.mat-step-header:hover[aria-disabled=true]{cursor:default}@media(hover: none){.mat-step-header:hover{background:none}}.mat-step-header .mat-step-label,.mat-step-header .mat-step-optional{color:#616161}.mat-step-header .mat-step-icon{background-color:#616161;color:#fff}.mat-step-header .mat-step-icon-selected,.mat-step-header .mat-step-icon-state-done,.mat-step-header .mat-step-icon-state-edit{background-color:#f57c00;color:#fff}.mat-step-header.mat-accent .mat-step-icon{color:#fff}.mat-step-header.mat-accent .mat-step-icon-selected,.mat-step-header.mat-accent .mat-step-icon-state-done,.mat-step-header.mat-accent .mat-step-icon-state-edit{background-color:#ff9800;color:#fff}.mat-step-header.mat-warn .mat-step-icon{color:#fff}.mat-step-header.mat-warn .mat-step-icon-selected,.mat-step-header.mat-warn .mat-step-icon-state-done,.mat-step-header.mat-warn .mat-step-icon-state-edit{background-color:#f44336;color:#fff}.mat-step-header .mat-step-icon-state-error{background-color:rgba(0,0,0,0);color:#f44336}.mat-step-header .mat-step-label.mat-step-label-active{color:#212121}.mat-step-header .mat-step-label.mat-step-label-error{color:#f44336}.mat-stepper-horizontal,.mat-stepper-vertical{background-color:#fff}.mat-stepper-vertical-line::before{border-left-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header::before,.mat-horizontal-stepper-header::after,.mat-stepper-horizontal-line{border-top-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header{height:72px}.mat-stepper-label-position-bottom .mat-horizontal-stepper-header,.mat-vertical-stepper-header{padding:24px 24px}.mat-stepper-vertical-line::before{top:-16px;bottom:-16px}.mat-stepper-label-position-bottom .mat-horizontal-stepper-header::after,.mat-stepper-label-position-bottom .mat-horizontal-stepper-header::before{top:36px}.mat-stepper-label-position-bottom .mat-stepper-horizontal-line{top:36px}.mat-sort-header-arrow{color:#616161}.mat-toolbar{background:#f57c00;color:#212121}.mat-toolbar.mat-primary{background:#f57c00;color:#fff}.mat-toolbar.mat-accent{background:#ff9800;color:#fff}.mat-toolbar.mat-warn{background:#f44336;color:#fff}.mat-toolbar .mat-form-field-underline,.mat-toolbar .mat-form-field-ripple,.mat-toolbar .mat-focused .mat-form-field-ripple{background-color:currentColor}.mat-toolbar .mat-form-field-label,.mat-toolbar .mat-focused .mat-form-field-label,.mat-toolbar .mat-select-value,.mat-toolbar .mat-select-arrow,.mat-toolbar .mat-form-field.mat-focused .mat-select-arrow{color:inherit}.mat-toolbar .mat-input-element{caret-color:currentColor}.mat-toolbar-multiple-rows{min-height:64px}.mat-toolbar-row,.mat-toolbar-single-row{height:64px}@media(max-width: 599px){.mat-toolbar-multiple-rows{min-height:56px}.mat-toolbar-row,.mat-toolbar-single-row{height:56px}}.mat-tree{background:#fff}.mat-tree-node,.mat-nested-tree-node{color:#212121}.mat-tree-node{min-height:48px}.mat-button,.mat-icon-button,.mat-stroked-button{color:inherit;background:rgba(0,0,0,0)}.mat-button.mat-primary,.mat-icon-button.mat-primary,.mat-stroked-button.mat-primary{color:#f57c00}.mat-button.mat-accent,.mat-icon-button.mat-accent,.mat-stroked-button.mat-accent{color:#ff9800}.mat-button.mat-warn,.mat-icon-button.mat-warn,.mat-stroked-button.mat-warn{color:#f44336}.mat-button.mat-primary.mat-button-disabled,.mat-button.mat-accent.mat-button-disabled,.mat-button.mat-warn.mat-button-disabled,.mat-button.mat-button-disabled.mat-button-disabled,.mat-icon-button.mat-primary.mat-button-disabled,.mat-icon-button.mat-accent.mat-button-disabled,.mat-icon-button.mat-warn.mat-button-disabled,.mat-icon-button.mat-button-disabled.mat-button-disabled,.mat-stroked-button.mat-primary.mat-button-disabled,.mat-stroked-button.mat-accent.mat-button-disabled,.mat-stroked-button.mat-warn.mat-button-disabled,.mat-stroked-button.mat-button-disabled.mat-button-disabled{color:rgba(0,0,0,.26)}.mat-button.mat-primary .mat-button-focus-overlay,.mat-icon-button.mat-primary .mat-button-focus-overlay,.mat-stroked-button.mat-primary .mat-button-focus-overlay{background-color:#f57c00}.mat-button.mat-accent .mat-button-focus-overlay,.mat-icon-button.mat-accent .mat-button-focus-overlay,.mat-stroked-button.mat-accent .mat-button-focus-overlay{background-color:#ff9800}.mat-button.mat-warn .mat-button-focus-overlay,.mat-icon-button.mat-warn .mat-button-focus-overlay,.mat-stroked-button.mat-warn .mat-button-focus-overlay{background-color:#f44336}.mat-button.mat-button-disabled .mat-button-focus-overlay,.mat-icon-button.mat-button-disabled .mat-button-focus-overlay,.mat-stroked-button.mat-button-disabled .mat-button-focus-overlay{background-color:rgba(0,0,0,0)}.mat-button .mat-ripple-element,.mat-icon-button .mat-ripple-element,.mat-stroked-button .mat-ripple-element{opacity:.1;background-color:currentColor}.mat-button-focus-overlay{background:#000}.mat-stroked-button:not(.mat-button-disabled){border-color:rgba(0,0,0,.12)}.mat-flat-button,.mat-raised-button,.mat-fab,.mat-mini-fab{color:#212121;background-color:#fff}.mat-flat-button.mat-primary,.mat-raised-button.mat-primary,.mat-fab.mat-primary,.mat-mini-fab.mat-primary{color:#fff}.mat-flat-button.mat-accent,.mat-raised-button.mat-accent,.mat-fab.mat-accent,.mat-mini-fab.mat-accent{color:#fff}.mat-flat-button.mat-warn,.mat-raised-button.mat-warn,.mat-fab.mat-warn,.mat-mini-fab.mat-warn{color:#fff}.mat-flat-button.mat-primary.mat-button-disabled,.mat-flat-button.mat-accent.mat-button-disabled,.mat-flat-button.mat-warn.mat-button-disabled,.mat-flat-button.mat-button-disabled.mat-button-disabled,.mat-raised-button.mat-primary.mat-button-disabled,.mat-raised-button.mat-accent.mat-button-disabled,.mat-raised-button.mat-warn.mat-button-disabled,.mat-raised-button.mat-button-disabled.mat-button-disabled,.mat-fab.mat-primary.mat-button-disabled,.mat-fab.mat-accent.mat-button-disabled,.mat-fab.mat-warn.mat-button-disabled,.mat-fab.mat-button-disabled.mat-button-disabled,.mat-mini-fab.mat-primary.mat-button-disabled,.mat-mini-fab.mat-accent.mat-button-disabled,.mat-mini-fab.mat-warn.mat-button-disabled,.mat-mini-fab.mat-button-disabled.mat-button-disabled{color:rgba(0,0,0,.26)}.mat-flat-button.mat-primary,.mat-raised-button.mat-primary,.mat-fab.mat-primary,.mat-mini-fab.mat-primary{background-color:#f57c00}.mat-flat-button.mat-accent,.mat-raised-button.mat-accent,.mat-fab.mat-accent,.mat-mini-fab.mat-accent{background-color:#ff9800}.mat-flat-button.mat-warn,.mat-raised-button.mat-warn,.mat-fab.mat-warn,.mat-mini-fab.mat-warn{background-color:#f44336}.mat-flat-button.mat-primary.mat-button-disabled,.mat-flat-button.mat-accent.mat-button-disabled,.mat-flat-button.mat-warn.mat-button-disabled,.mat-flat-button.mat-button-disabled.mat-button-disabled,.mat-raised-button.mat-primary.mat-button-disabled,.mat-raised-button.mat-accent.mat-button-disabled,.mat-raised-button.mat-warn.mat-button-disabled,.mat-raised-button.mat-button-disabled.mat-button-disabled,.mat-fab.mat-primary.mat-button-disabled,.mat-fab.mat-accent.mat-button-disabled,.mat-fab.mat-warn.mat-button-disabled,.mat-fab.mat-button-disabled.mat-button-disabled,.mat-mini-fab.mat-primary.mat-button-disabled,.mat-mini-fab.mat-accent.mat-button-disabled,.mat-mini-fab.mat-warn.mat-button-disabled,.mat-mini-fab.mat-button-disabled.mat-button-disabled{background-color:rgba(0,0,0,.12)}.mat-flat-button.mat-primary .mat-ripple-element,.mat-raised-button.mat-primary .mat-ripple-element,.mat-fab.mat-primary .mat-ripple-element,.mat-mini-fab.mat-primary .mat-ripple-element{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-accent .mat-ripple-element,.mat-raised-button.mat-accent .mat-ripple-element,.mat-fab.mat-accent .mat-ripple-element,.mat-mini-fab.mat-accent .mat-ripple-element{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-warn .mat-ripple-element,.mat-raised-button.mat-warn .mat-ripple-element,.mat-fab.mat-warn .mat-ripple-element,.mat-mini-fab.mat-warn .mat-ripple-element{background-color:rgba(255,255,255,.1)}.mat-stroked-button:not([class*=mat-elevation-z]),.mat-flat-button:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2), 0px 0px 0px 0px rgba(0, 0, 0, 0.14), 0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2), 0px 2px 2px 0px rgba(0, 0, 0, 0.14), 0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2), 0px 8px 10px 1px rgba(0, 0, 0, 0.14), 0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-raised-button.mat-button-disabled:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2), 0px 0px 0px 0px rgba(0, 0, 0, 0.14), 0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-fab:not([class*=mat-elevation-z]),.mat-mini-fab:not([class*=mat-elevation-z]){box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2), 0px 6px 10px 0px rgba(0, 0, 0, 0.14), 0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-fab:not(.mat-button-disabled):active:not([class*=mat-elevation-z]),.mat-mini-fab:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2), 0px 12px 17px 2px rgba(0, 0, 0, 0.14), 0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-fab.mat-button-disabled:not([class*=mat-elevation-z]),.mat-mini-fab.mat-button-disabled:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2), 0px 0px 0px 0px rgba(0, 0, 0, 0.14), 0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-datepicker-content .mat-mdc-button.mat-unthemed{--mdc-text-button-label-text-color:#000}.mat-datepicker-content .mat-mdc-button.mat-primary{--mdc-text-button-label-text-color:#f57c00}.mat-datepicker-content .mat-mdc-button.mat-accent{--mdc-text-button-label-text-color:#ff9800}.mat-datepicker-content .mat-mdc-button.mat-warn{--mdc-text-button-label-text-color:#f44336}.mat-datepicker-content .mat-mdc-button[disabled][disabled]{--mdc-text-button-disabled-label-text-color:rgba(0, 0, 0, 0.38);--mdc-text-button-label-text-color:rgba(0, 0, 0, 0.38)}.mat-datepicker-content .mat-mdc-unelevated-button.mat-unthemed{--mdc-filled-button-container-color:#fff;--mdc-filled-button-label-text-color:#000}.mat-datepicker-content .mat-mdc-unelevated-button.mat-primary{--mdc-filled-button-container-color:#f57c00;--mdc-filled-button-label-text-color:#000}.mat-datepicker-content .mat-mdc-unelevated-button.mat-accent{--mdc-filled-button-container-color:#ff9800;--mdc-filled-button-label-text-color:#000}.mat-datepicker-content .mat-mdc-unelevated-button.mat-warn{--mdc-filled-button-container-color:#f44336;--mdc-filled-button-label-text-color:#fff}.mat-datepicker-content .mat-mdc-unelevated-button[disabled][disabled]{--mdc-filled-button-disabled-container-color:rgba(0, 0, 0, 0.12);--mdc-filled-button-disabled-label-text-color:rgba(0, 0, 0, 0.38);--mdc-filled-button-container-color:rgba(0, 0, 0, 0.12);--mdc-filled-button-label-text-color:rgba(0, 0, 0, 0.38)}.mat-datepicker-content .mat-mdc-raised-button.mat-unthemed{--mdc-protected-button-container-color:#fff;--mdc-protected-button-label-text-color:#000}.mat-datepicker-content .mat-mdc-raised-button.mat-primary{--mdc-protected-button-container-color:#f57c00;--mdc-protected-button-label-text-color:#000}.mat-datepicker-content .mat-mdc-raised-button.mat-accent{--mdc-protected-button-container-color:#ff9800;--mdc-protected-button-label-text-color:#000}.mat-datepicker-content .mat-mdc-raised-button.mat-warn{--mdc-protected-button-container-color:#f44336;--mdc-protected-button-label-text-color:#fff}.mat-datepicker-content .mat-mdc-raised-button[disabled][disabled]{--mdc-protected-button-disabled-container-color:rgba(0, 0, 0, 0.12);--mdc-protected-button-disabled-label-text-color:rgba(0, 0, 0, 0.38);--mdc-protected-button-container-color:rgba(0, 0, 0, 0.12);--mdc-protected-button-label-text-color:rgba(0, 0, 0, 0.38);--mdc-protected-button-container-elevation:0}.mat-datepicker-content .mat-mdc-outlined-button{--mdc-outlined-button-outline-color:rgba(0, 0, 0, 0.12)}.mat-datepicker-content .mat-mdc-outlined-button.mat-unthemed{--mdc-outlined-button-label-text-color:#000}.mat-datepicker-content .mat-mdc-outlined-button.mat-primary{--mdc-outlined-button-label-text-color:#f57c00}.mat-datepicker-content .mat-mdc-outlined-button.mat-accent{--mdc-outlined-button-label-text-color:#ff9800}.mat-datepicker-content .mat-mdc-outlined-button.mat-warn{--mdc-outlined-button-label-text-color:#f44336}.mat-datepicker-content .mat-mdc-outlined-button[disabled][disabled]{--mdc-outlined-button-label-text-color:rgba(0, 0, 0, 0.38);--mdc-outlined-button-disabled-label-text-color:rgba(0, 0, 0, 0.38);--mdc-outlined-button-outline-color:rgba(0, 0, 0, 0.12);--mdc-outlined-button-disabled-outline-color:rgba(0, 0, 0, 0.12)}.mat-datepicker-content .mat-mdc-button,.mat-datepicker-content .mat-mdc-outlined-button{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}.mat-datepicker-content .mat-mdc-button:hover .mat-mdc-button-persistent-ripple::before,.mat-datepicker-content .mat-mdc-outlined-button:hover .mat-mdc-button-persistent-ripple::before{opacity:.04}.mat-datepicker-content .mat-mdc-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,.mat-datepicker-content .mat-mdc-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before,.mat-datepicker-content .mat-mdc-outlined-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,.mat-datepicker-content .mat-mdc-outlined-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before{opacity:.12}.mat-datepicker-content .mat-mdc-button:active .mat-mdc-button-persistent-ripple::before,.mat-datepicker-content .mat-mdc-outlined-button:active .mat-mdc-button-persistent-ripple::before{opacity:.12}.mat-datepicker-content .mat-mdc-button.mat-primary,.mat-datepicker-content .mat-mdc-outlined-button.mat-primary{--mat-mdc-button-persistent-ripple-color: #f57c00;--mat-mdc-button-ripple-color: rgba(245, 124, 0, 0.1)}.mat-datepicker-content .mat-mdc-button.mat-accent,.mat-datepicker-content .mat-mdc-outlined-button.mat-accent{--mat-mdc-button-persistent-ripple-color: #ff9800;--mat-mdc-button-ripple-color: rgba(255, 152, 0, 0.1)}.mat-datepicker-content .mat-mdc-button.mat-warn,.mat-datepicker-content .mat-mdc-outlined-button.mat-warn{--mat-mdc-button-persistent-ripple-color: #f44336;--mat-mdc-button-ripple-color: rgba(244, 67, 54, 0.1)}.mat-datepicker-content .mat-mdc-raised-button,.mat-datepicker-content .mat-mdc-unelevated-button{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}.mat-datepicker-content .mat-mdc-raised-button:hover .mat-mdc-button-persistent-ripple::before,.mat-datepicker-content .mat-mdc-unelevated-button:hover .mat-mdc-button-persistent-ripple::before{opacity:.04}.mat-datepicker-content .mat-mdc-raised-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,.mat-datepicker-content .mat-mdc-raised-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before,.mat-datepicker-content .mat-mdc-unelevated-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,.mat-datepicker-content .mat-mdc-unelevated-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before{opacity:.12}.mat-datepicker-content .mat-mdc-raised-button:active .mat-mdc-button-persistent-ripple::before,.mat-datepicker-content .mat-mdc-unelevated-button:active .mat-mdc-button-persistent-ripple::before{opacity:.12}.mat-datepicker-content .mat-mdc-raised-button.mat-primary,.mat-datepicker-content .mat-mdc-unelevated-button.mat-primary{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}.mat-datepicker-content .mat-mdc-raised-button.mat-accent,.mat-datepicker-content .mat-mdc-unelevated-button.mat-accent{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}.mat-datepicker-content .mat-mdc-raised-button.mat-warn,.mat-datepicker-content .mat-mdc-unelevated-button.mat-warn{--mat-mdc-button-persistent-ripple-color: #fff;--mat-mdc-button-ripple-color: rgba(255, 255, 255, 0.1)}.mat-datepicker-content .mat-mdc-icon-button{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}.mat-datepicker-content .mat-mdc-icon-button:hover .mat-mdc-button-persistent-ripple::before{opacity:.04}.mat-datepicker-content .mat-mdc-icon-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,.mat-datepicker-content .mat-mdc-icon-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before{opacity:.12}.mat-datepicker-content .mat-mdc-icon-button:active .mat-mdc-button-persistent-ripple::before{opacity:.12}.mat-datepicker-content .mat-mdc-icon-button.mat-primary{--mat-mdc-button-persistent-ripple-color: #f57c00;--mat-mdc-button-ripple-color: rgba(245, 124, 0, 0.1)}.mat-datepicker-content .mat-mdc-icon-button.mat-accent{--mat-mdc-button-persistent-ripple-color: #ff9800;--mat-mdc-button-ripple-color: rgba(255, 152, 0, 0.1)}.mat-datepicker-content .mat-mdc-icon-button.mat-warn{--mat-mdc-button-persistent-ripple-color: #f44336;--mat-mdc-button-ripple-color: rgba(244, 67, 54, 0.1)}.mat-datepicker-content .mat-mdc-icon-button.mat-primary{--mdc-icon-button-icon-color:#f57c00}.mat-datepicker-content .mat-mdc-icon-button.mat-accent{--mdc-icon-button-icon-color:#ff9800}.mat-datepicker-content .mat-mdc-icon-button.mat-warn{--mdc-icon-button-icon-color:#f44336}.mat-datepicker-content .mat-mdc-icon-button[disabled][disabled]{--mdc-icon-button-icon-color:rgba(0, 0, 0, 0.38);--mdc-icon-button-disabled-icon-color:rgba(0, 0, 0, 0.38)}.mat-datepicker-content .mat-mdc-button.mat-mdc-button-base,.mat-datepicker-content .mat-mdc-raised-button.mat-mdc-button-base,.mat-datepicker-content .mat-mdc-unelevated-button.mat-mdc-button-base,.mat-datepicker-content .mat-mdc-outlined-button.mat-mdc-button-base{height:36px}.mat-datepicker-content .mat-mdc-icon-button.mat-mdc-button-base{width:48px;height:48px;padding:12px}.mat-datepicker-content .mat-mdc-icon-button.mat-mdc-button-base .mdc-icon-button__focus-ring{max-height:48px;max-width:48px}.mat-datepicker-content .mat-mdc-icon-button.mat-mdc-button-base.mdc-icon-button--reduced-size .mdc-icon-button__ripple{width:40px;height:40px;margin-top:4px;margin-bottom:4px;margin-right:4px;margin-left:4px}.mat-datepicker-content .mat-mdc-icon-button.mat-mdc-button-base.mdc-icon-button--reduced-size .mdc-icon-button__focus-ring{max-height:40px;max-width:40px}.mat-datepicker-content .mat-mdc-icon-button.mat-mdc-button-base .mdc-icon-button__touch{position:absolute;top:50%;height:48px;left:50%;width:48px;transform:translate(-50%, -50%)}.mat-option{color:#212121}.mat-option:hover:not(.mat-option-disabled),.mat-option:focus:not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-selected:not(.mat-option-multiple):not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-active{background:rgba(0,0,0,.04);color:#212121}.mat-option.mat-option-disabled{color:rgba(0,0,0,.38)}.mat-primary .mat-option.mat-selected:not(.mat-option-disabled){color:#f57c00}.mat-accent .mat-option.mat-selected:not(.mat-option-disabled){color:#ff9800}.mat-warn .mat-option.mat-selected:not(.mat-option-disabled){color:#f44336}.mat-optgroup-label{color:#616161}.mat-optgroup-disabled .mat-optgroup-label{color:rgba(0,0,0,.38)}.mat-ripple-element{background-color:rgba(0,0,0,.1)}.mat-pseudo-checkbox-full{color:#616161}.mat-pseudo-checkbox-full.mat-pseudo-checkbox-disabled{color:#b0b0b0}.mat-primary .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,.mat-primary .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#f57c00}.mat-primary .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,.mat-primary .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#f57c00}.mat-primary .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full::after,.mat-primary .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full::after{color:#fff}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,.mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#ff9800}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,.mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#ff9800}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full::after,.mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full::after{color:#fff}.mat-accent .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,.mat-accent .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#ff9800}.mat-accent .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,.mat-accent .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#ff9800}.mat-accent .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full::after,.mat-accent .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full::after{color:#fff}.mat-warn .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,.mat-warn .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#f44336}.mat-warn .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,.mat-warn .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#f44336}.mat-warn .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full::after,.mat-warn .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full::after{color:#fff}.mat-pseudo-checkbox-disabled.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,.mat-pseudo-checkbox-disabled.mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#b0b0b0}.mat-pseudo-checkbox-disabled.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,.mat-pseudo-checkbox-disabled.mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#b0b0b0}.mat-app-background{background-color:#fff;color:#212121}.mat-elevation-z0{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2), 0px 0px 0px 0px rgba(0, 0, 0, 0.14), 0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z1{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2), 0px 1px 1px 0px rgba(0, 0, 0, 0.14), 0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z2{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2), 0px 2px 2px 0px rgba(0, 0, 0, 0.14), 0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z3{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2), 0px 3px 4px 0px rgba(0, 0, 0, 0.14), 0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z4{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2), 0px 4px 5px 0px rgba(0, 0, 0, 0.14), 0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z5{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2), 0px 5px 8px 0px rgba(0, 0, 0, 0.14), 0px 1px 14px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z6{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2), 0px 6px 10px 0px rgba(0, 0, 0, 0.14), 0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z7{box-shadow:0px 4px 5px -2px rgba(0, 0, 0, 0.2), 0px 7px 10px 1px rgba(0, 0, 0, 0.14), 0px 2px 16px 1px rgba(0, 0, 0, 0.12)}.mat-elevation-z8{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2), 0px 8px 10px 1px rgba(0, 0, 0, 0.14), 0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z9{box-shadow:0px 5px 6px -3px rgba(0, 0, 0, 0.2), 0px 9px 12px 1px rgba(0, 0, 0, 0.14), 0px 3px 16px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z10{box-shadow:0px 6px 6px -3px rgba(0, 0, 0, 0.2), 0px 10px 14px 1px rgba(0, 0, 0, 0.14), 0px 4px 18px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z11{box-shadow:0px 6px 7px -4px rgba(0, 0, 0, 0.2), 0px 11px 15px 1px rgba(0, 0, 0, 0.14), 0px 4px 20px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z12{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2), 0px 12px 17px 2px rgba(0, 0, 0, 0.14), 0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z13{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2), 0px 13px 19px 2px rgba(0, 0, 0, 0.14), 0px 5px 24px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z14{box-shadow:0px 7px 9px -4px rgba(0, 0, 0, 0.2), 0px 14px 21px 2px rgba(0, 0, 0, 0.14), 0px 5px 26px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z15{box-shadow:0px 8px 9px -5px rgba(0, 0, 0, 0.2), 0px 15px 22px 2px rgba(0, 0, 0, 0.14), 0px 6px 28px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z16{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2), 0px 16px 24px 2px rgba(0, 0, 0, 0.14), 0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z17{box-shadow:0px 8px 11px -5px rgba(0, 0, 0, 0.2), 0px 17px 26px 2px rgba(0, 0, 0, 0.14), 0px 6px 32px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z18{box-shadow:0px 9px 11px -5px rgba(0, 0, 0, 0.2), 0px 18px 28px 2px rgba(0, 0, 0, 0.14), 0px 7px 34px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z19{box-shadow:0px 9px 12px -6px rgba(0, 0, 0, 0.2), 0px 19px 29px 2px rgba(0, 0, 0, 0.14), 0px 7px 36px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z20{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2), 0px 20px 31px 3px rgba(0, 0, 0, 0.14), 0px 8px 38px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z21{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2), 0px 21px 33px 3px rgba(0, 0, 0, 0.14), 0px 8px 40px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z22{box-shadow:0px 10px 14px -6px rgba(0, 0, 0, 0.2), 0px 22px 35px 3px rgba(0, 0, 0, 0.14), 0px 8px 42px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z23{box-shadow:0px 11px 14px -7px rgba(0, 0, 0, 0.2), 0px 23px 36px 3px rgba(0, 0, 0, 0.14), 0px 9px 44px 8px rgba(0, 0, 0, 0.12)}.mat-elevation-z24{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2), 0px 24px 38px 3px rgba(0, 0, 0, 0.14), 0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-theme-loaded-marker{display:none}.mat-card{background:#fff;color:#212121}.mat-card:not([class*=mat-elevation-z]){box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2), 0px 1px 1px 0px rgba(0, 0, 0, 0.14), 0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-card.mat-card-flat:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2), 0px 0px 0px 0px rgba(0, 0, 0, 0.14), 0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-card-subtitle{color:#616161}.mat-progress-bar-background{fill:#fddebf}.mat-progress-bar-buffer{background-color:#fddebf}.mat-progress-bar-fill::after{background-color:#f57c00}.mat-progress-bar.mat-accent .mat-progress-bar-background{fill:#ffe5bf}.mat-progress-bar.mat-accent .mat-progress-bar-buffer{background-color:#ffe5bf}.mat-progress-bar.mat-accent .mat-progress-bar-fill::after{background-color:#ff9800}.mat-progress-bar.mat-warn .mat-progress-bar-background{fill:#fcd0cd}.mat-progress-bar.mat-warn .mat-progress-bar-buffer{background-color:#fcd0cd}.mat-progress-bar.mat-warn .mat-progress-bar-fill::after{background-color:#f44336}.mat-progress-spinner circle,.mat-spinner circle{stroke:#f57c00}.mat-progress-spinner.mat-accent circle,.mat-spinner.mat-accent circle{stroke:#ff9800}.mat-progress-spinner.mat-warn circle,.mat-spinner.mat-warn circle{stroke:#f44336}.mat-tooltip{background:rgba(97,97,97,.9)}.mat-form-field-type-mat-native-select .mat-form-field-infix::after{color:#616161}.mat-input-element:disabled,.mat-form-field-type-mat-native-select.mat-form-field-disabled .mat-form-field-infix::after{color:#757575}.mat-input-element{caret-color:#f57c00}.mat-input-element::placeholder{color:rgba(97,97,97,.42)}.mat-input-element::-moz-placeholder{color:rgba(97,97,97,.42)}.mat-input-element::-webkit-input-placeholder{color:rgba(97,97,97,.42)}.mat-input-element:-ms-input-placeholder{color:rgba(97,97,97,.42)}.mat-form-field.mat-accent .mat-input-element{caret-color:#ff9800}.mat-form-field.mat-warn .mat-input-element,.mat-form-field-invalid .mat-input-element{caret-color:#f44336}.mat-form-field-type-mat-native-select.mat-form-field-invalid .mat-form-field-infix::after{color:#f44336}.mat-form-field-disabled .mat-form-field-prefix,.mat-form-field-disabled .mat-form-field-suffix{color:#757575}.mat-form-field-label{color:rgba(97,97,97,.6)}.mat-hint{color:rgba(97,97,97,.6)}.mat-form-field.mat-focused .mat-form-field-label{color:#f57c00}.mat-form-field.mat-focused .mat-form-field-label.mat-accent{color:#ff9800}.mat-form-field.mat-focused .mat-form-field-label.mat-warn{color:#f44336}.mat-focused .mat-form-field-required-marker{color:#ff9800}.mat-form-field-ripple{background-color:rgba(0,0,0,.87)}.mat-form-field.mat-focused .mat-form-field-ripple{background-color:#f57c00}.mat-form-field.mat-focused .mat-form-field-ripple.mat-accent{background-color:#ff9800}.mat-form-field.mat-focused .mat-form-field-ripple.mat-warn{background-color:#f44336}.mat-form-field-type-mat-native-select.mat-focused:not(.mat-form-field-invalid) .mat-form-field-infix::after{color:#f57c00}.mat-form-field-type-mat-native-select.mat-focused:not(.mat-form-field-invalid).mat-accent .mat-form-field-infix::after{color:#ff9800}.mat-form-field-type-mat-native-select.mat-focused:not(.mat-form-field-invalid).mat-warn .mat-form-field-infix::after{color:#f44336}.mat-form-field.mat-form-field-invalid .mat-form-field-label{color:#f44336}.mat-form-field.mat-form-field-invalid .mat-form-field-label.mat-accent,.mat-form-field.mat-form-field-invalid .mat-form-field-label .mat-form-field-required-marker{color:#f44336}.mat-form-field.mat-form-field-invalid .mat-form-field-ripple,.mat-form-field.mat-form-field-invalid .mat-form-field-ripple.mat-accent{background-color:#f44336}.mat-error{color:#f44336}.mat-form-field-appearance-legacy .mat-form-field-label{color:#616161}.mat-form-field-appearance-legacy .mat-hint{color:#616161}.mat-form-field-appearance-legacy .mat-form-field-underline{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-legacy.mat-form-field-disabled .mat-form-field-underline{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-standard .mat-form-field-underline{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-standard.mat-form-field-disabled .mat-form-field-underline{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-fill .mat-form-field-flex{background-color:rgba(0,0,0,.04)}.mat-form-field-appearance-fill.mat-form-field-disabled .mat-form-field-flex{background-color:rgba(0,0,0,.02)}.mat-form-field-appearance-fill .mat-form-field-underline::before{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-fill.mat-form-field-disabled .mat-form-field-label{color:#757575}.mat-form-field-appearance-fill.mat-form-field-disabled .mat-form-field-underline::before{background-color:rgba(0,0,0,0)}.mat-form-field-appearance-outline .mat-form-field-outline{color:rgba(0,0,0,.12)}.mat-form-field-appearance-outline .mat-form-field-outline-thick{color:rgba(0,0,0,.87)}.mat-form-field-appearance-outline.mat-focused .mat-form-field-outline-thick{color:#f57c00}.mat-form-field-appearance-outline.mat-focused.mat-accent .mat-form-field-outline-thick{color:#ff9800}.mat-form-field-appearance-outline.mat-focused.mat-warn .mat-form-field-outline-thick{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-invalid.mat-form-field-invalid .mat-form-field-outline-thick{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-disabled .mat-form-field-label{color:#757575}.mat-form-field-appearance-outline.mat-form-field-disabled .mat-form-field-outline{color:rgba(0,0,0,.06)}.mat-select-value{color:#212121}.mat-select-placeholder{color:rgba(97,97,97,.42)}.mat-select-disabled .mat-select-value{color:#757575}.mat-select-arrow{color:#616161}.mat-select-panel{background:#fff}.mat-select-panel:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2), 0px 4px 5px 0px rgba(0, 0, 0, 0.14), 0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-select-panel .mat-option.mat-selected:not(.mat-option-multiple){background:rgba(0,0,0,.12)}.mat-form-field.mat-focused.mat-primary .mat-select-arrow{color:#f57c00}.mat-form-field.mat-focused.mat-accent .mat-select-arrow{color:#ff9800}.mat-form-field.mat-focused.mat-warn .mat-select-arrow{color:#f44336}.mat-form-field .mat-select.mat-select-invalid .mat-select-arrow{color:#f44336}.mat-form-field .mat-select.mat-select-disabled .mat-select-arrow{color:#757575}.mat-checkbox-frame{border-color:#616161}.mat-checkbox-checkmark{fill:#fff}.mat-checkbox-checkmark-path{stroke:#fff !important}.mat-checkbox-mixedmark{background-color:#fff}.mat-checkbox-indeterminate.mat-primary .mat-checkbox-background,.mat-checkbox-checked.mat-primary .mat-checkbox-background{background-color:#f57c00}.mat-checkbox-indeterminate.mat-accent .mat-checkbox-background,.mat-checkbox-checked.mat-accent .mat-checkbox-background{background-color:#ff9800}.mat-checkbox-indeterminate.mat-warn .mat-checkbox-background,.mat-checkbox-checked.mat-warn .mat-checkbox-background{background-color:#f44336}.mat-checkbox-disabled.mat-checkbox-checked .mat-checkbox-background,.mat-checkbox-disabled.mat-checkbox-indeterminate .mat-checkbox-background{background-color:#b0b0b0}.mat-checkbox-disabled:not(.mat-checkbox-checked) .mat-checkbox-frame{border-color:#b0b0b0}.mat-checkbox-disabled .mat-checkbox-label{color:rgba(0,0,0,.38)}.mat-checkbox .mat-ripple-element{background-color:#000}.mat-checkbox-checked:not(.mat-checkbox-disabled).mat-primary .mat-ripple-element,.mat-checkbox:active:not(.mat-checkbox-disabled).mat-primary .mat-ripple-element{background:#f57c00}.mat-checkbox-checked:not(.mat-checkbox-disabled).mat-accent .mat-ripple-element,.mat-checkbox:active:not(.mat-checkbox-disabled).mat-accent .mat-ripple-element{background:#ff9800}.mat-checkbox-checked:not(.mat-checkbox-disabled).mat-warn .mat-ripple-element,.mat-checkbox:active:not(.mat-checkbox-disabled).mat-warn .mat-ripple-element{background:#f44336}.mat-autocomplete-panel{background:#fff;color:#212121}.mat-autocomplete-panel:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2), 0px 4px 5px 0px rgba(0, 0, 0, 0.14), 0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-autocomplete-panel .mat-option.mat-selected:not(.mat-active):not(:hover){background:#fff}.mat-autocomplete-panel .mat-option.mat-selected:not(.mat-active):not(:hover):not(.mat-option-disabled){color:#212121}.mat-dialog-container{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2), 0px 24px 38px 3px rgba(0, 0, 0, 0.14), 0px 9px 46px 8px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-chip.mat-standard-chip{background-color:#e0e0e0;color:#212121}.mat-chip.mat-standard-chip .mat-chip-remove{color:#212121;opacity:.4}.mat-chip.mat-standard-chip:not(.mat-chip-disabled):active{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2), 0px 3px 4px 0px rgba(0, 0, 0, 0.14), 0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-chip.mat-standard-chip:not(.mat-chip-disabled) .mat-chip-remove:hover{opacity:.54}.mat-chip.mat-standard-chip.mat-chip-disabled{opacity:.4}.mat-chip.mat-standard-chip::after{background:#000}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary{background-color:#f57c00;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary .mat-chip-remove{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary .mat-ripple-element{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn{background-color:#f44336;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn .mat-chip-remove{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn .mat-ripple-element{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent{background-color:#ff9800;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent .mat-chip-remove{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent .mat-ripple-element{background-color:rgba(255,255,255,.1)}.mat-slide-toggle.mat-checked .mat-slide-toggle-thumb{background-color:#ff9800}.mat-slide-toggle.mat-checked .mat-slide-toggle-bar{background-color:rgba(255,152,0,.54)}.mat-slide-toggle.mat-checked .mat-ripple-element{background-color:#ff9800}.mat-slide-toggle.mat-primary.mat-checked .mat-slide-toggle-thumb{background-color:#f57c00}.mat-slide-toggle.mat-primary.mat-checked .mat-slide-toggle-bar{background-color:rgba(245,124,0,.54)}.mat-slide-toggle.mat-primary.mat-checked .mat-ripple-element{background-color:#f57c00}.mat-slide-toggle.mat-warn.mat-checked .mat-slide-toggle-thumb{background-color:#f44336}.mat-slide-toggle.mat-warn.mat-checked .mat-slide-toggle-bar{background-color:rgba(244,67,54,.54)}.mat-slide-toggle.mat-warn.mat-checked .mat-ripple-element{background-color:#f44336}.mat-slide-toggle:not(.mat-checked) .mat-ripple-element{background-color:#000}.mat-slide-toggle-thumb{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2), 0px 1px 1px 0px rgba(0, 0, 0, 0.14), 0px 1px 3px 0px rgba(0, 0, 0, 0.12);background-color:#fafafa}.mat-slide-toggle-bar{background-color:rgba(0,0,0,.38)}.mat-radio-outer-circle{border-color:#616161}.mat-radio-button.mat-primary.mat-radio-checked .mat-radio-outer-circle{border-color:#f57c00}.mat-radio-button.mat-primary .mat-radio-inner-circle,.mat-radio-button.mat-primary .mat-radio-ripple .mat-ripple-element:not(.mat-radio-persistent-ripple),.mat-radio-button.mat-primary.mat-radio-checked .mat-radio-persistent-ripple,.mat-radio-button.mat-primary:active .mat-radio-persistent-ripple{background-color:#f57c00}.mat-radio-button.mat-accent.mat-radio-checked .mat-radio-outer-circle{border-color:#ff9800}.mat-radio-button.mat-accent .mat-radio-inner-circle,.mat-radio-button.mat-accent .mat-radio-ripple .mat-ripple-element:not(.mat-radio-persistent-ripple),.mat-radio-button.mat-accent.mat-radio-checked .mat-radio-persistent-ripple,.mat-radio-button.mat-accent:active .mat-radio-persistent-ripple{background-color:#ff9800}.mat-radio-button.mat-warn.mat-radio-checked .mat-radio-outer-circle{border-color:#f44336}.mat-radio-button.mat-warn .mat-radio-inner-circle,.mat-radio-button.mat-warn .mat-radio-ripple .mat-ripple-element:not(.mat-radio-persistent-ripple),.mat-radio-button.mat-warn.mat-radio-checked .mat-radio-persistent-ripple,.mat-radio-button.mat-warn:active .mat-radio-persistent-ripple{background-color:#f44336}.mat-radio-button.mat-radio-disabled.mat-radio-checked .mat-radio-outer-circle,.mat-radio-button.mat-radio-disabled .mat-radio-outer-circle{border-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled .mat-radio-ripple .mat-ripple-element,.mat-radio-button.mat-radio-disabled .mat-radio-inner-circle{background-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled .mat-radio-label-content{color:rgba(0,0,0,.38)}.mat-radio-button .mat-ripple-element{background-color:#000}.mat-slider-track-background{background-color:rgba(0,0,0,.26)}.mat-slider.mat-primary .mat-slider-track-fill,.mat-slider.mat-primary .mat-slider-thumb,.mat-slider.mat-primary .mat-slider-thumb-label{background-color:#f57c00}.mat-slider.mat-primary .mat-slider-thumb-label-text{color:#fff}.mat-slider.mat-primary .mat-slider-focus-ring{background-color:rgba(245,124,0,.2)}.mat-slider.mat-accent .mat-slider-track-fill,.mat-slider.mat-accent .mat-slider-thumb,.mat-slider.mat-accent .mat-slider-thumb-label{background-color:#ff9800}.mat-slider.mat-accent .mat-slider-thumb-label-text{color:#fff}.mat-slider.mat-accent .mat-slider-focus-ring{background-color:rgba(255,152,0,.2)}.mat-slider.mat-warn .mat-slider-track-fill,.mat-slider.mat-warn .mat-slider-thumb,.mat-slider.mat-warn .mat-slider-thumb-label{background-color:#f44336}.mat-slider.mat-warn .mat-slider-thumb-label-text{color:#fff}.mat-slider.mat-warn .mat-slider-focus-ring{background-color:rgba(244,67,54,.2)}.mat-slider:hover .mat-slider-track-background,.mat-slider.cdk-focused .mat-slider-track-background{background-color:rgba(0,0,0,.38)}.mat-slider.mat-slider-disabled .mat-slider-track-background,.mat-slider.mat-slider-disabled .mat-slider-track-fill,.mat-slider.mat-slider-disabled .mat-slider-thumb{background-color:rgba(0,0,0,.26)}.mat-slider.mat-slider-disabled:hover .mat-slider-track-background{background-color:rgba(0,0,0,.26)}.mat-slider.mat-slider-min-value .mat-slider-focus-ring{background-color:rgba(0,0,0,.12)}.mat-slider.mat-slider-min-value.mat-slider-thumb-label-showing .mat-slider-thumb,.mat-slider.mat-slider-min-value.mat-slider-thumb-label-showing .mat-slider-thumb-label{background-color:rgba(0,0,0,.87)}.mat-slider.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused .mat-slider-thumb,.mat-slider.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused .mat-slider-thumb-label{background-color:rgba(0,0,0,.26)}.mat-slider.mat-slider-min-value:not(.mat-slider-thumb-label-showing) .mat-slider-thumb{border-color:rgba(0,0,0,.26);background-color:rgba(0,0,0,0)}.mat-slider.mat-slider-min-value:not(.mat-slider-thumb-label-showing):hover .mat-slider-thumb,.mat-slider.mat-slider-min-value:not(.mat-slider-thumb-label-showing).cdk-focused .mat-slider-thumb{border-color:rgba(0,0,0,.38)}.mat-slider.mat-slider-min-value:not(.mat-slider-thumb-label-showing):hover.mat-slider-disabled .mat-slider-thumb,.mat-slider.mat-slider-min-value:not(.mat-slider-thumb-label-showing).cdk-focused.mat-slider-disabled .mat-slider-thumb{border-color:rgba(0,0,0,.26)}.mat-slider-has-ticks .mat-slider-wrapper::after{border-color:rgba(0,0,0,.7)}.mat-slider-horizontal .mat-slider-ticks{background-image:repeating-linear-gradient(to right, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent);background-image:-moz-repeating-linear-gradient(0.0001deg, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-slider-vertical .mat-slider-ticks{background-image:repeating-linear-gradient(to bottom, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-menu-panel{background:#fff}.mat-menu-panel:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2), 0px 4px 5px 0px rgba(0, 0, 0, 0.14), 0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-menu-item{background:rgba(0,0,0,0);color:#212121}.mat-menu-item[disabled],.mat-menu-item[disabled] .mat-menu-submenu-icon,.mat-menu-item[disabled] .mat-icon-no-color{color:rgba(0,0,0,.38)}.mat-menu-item .mat-icon-no-color,.mat-menu-submenu-icon{color:rgba(0,0,0,.54)}.mat-menu-item:hover:not([disabled]),.mat-menu-item.cdk-program-focused:not([disabled]),.mat-menu-item.cdk-keyboard-focused:not([disabled]),.mat-menu-item-highlighted:not([disabled]){background:rgba(0,0,0,.04)}.mat-list-base .mat-list-item{color:#212121}.mat-list-base .mat-list-option{color:#212121}.mat-list-base .mat-subheader{color:#616161}.mat-list-base .mat-list-item-disabled{background-color:#eee;color:#757575}.mat-list-option:hover,.mat-list-option:focus,.mat-nav-list .mat-list-item:hover,.mat-nav-list .mat-list-item:focus,.mat-action-list .mat-list-item:hover,.mat-action-list .mat-list-item:focus{background:rgba(0,0,0,.04)}.mat-list-single-selected-option,.mat-list-single-selected-option:hover,.mat-list-single-selected-option:focus{background:rgba(0,0,0,.12)}.mat-paginator{background:#fff}.mat-paginator,.mat-paginator-page-size .mat-select-trigger{color:#616161}.mat-paginator-decrement,.mat-paginator-increment{border-top:2px solid rgba(0,0,0,.54);border-right:2px solid rgba(0,0,0,.54)}.mat-paginator-first,.mat-paginator-last{border-top:2px solid rgba(0,0,0,.54)}.mat-icon-button[disabled] .mat-paginator-decrement,.mat-icon-button[disabled] .mat-paginator-increment,.mat-icon-button[disabled] .mat-paginator-first,.mat-icon-button[disabled] .mat-paginator-last{border-color:rgba(0,0,0,.38)}.mat-paginator-container{min-height:56px}.mat-tab-nav-bar,.mat-tab-header{border-bottom:1px solid rgba(0,0,0,.12)}.mat-tab-group-inverted-header .mat-tab-nav-bar,.mat-tab-group-inverted-header .mat-tab-header{border-top:1px solid rgba(0,0,0,.12);border-bottom:none}.mat-tab-label,.mat-tab-link{color:#212121}.mat-tab-label.mat-tab-disabled,.mat-tab-link.mat-tab-disabled{color:#757575}.mat-tab-header-pagination-chevron{border-color:#212121}.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron{border-color:#757575}.mat-tab-group[class*=mat-background-]>.mat-tab-header,.mat-tab-nav-bar[class*=mat-background-]{border-bottom:none;border-top:none}.mat-tab-group.mat-primary .mat-tab-label.cdk-keyboard-focused,.mat-tab-group.mat-primary .mat-tab-label.cdk-program-focused,.mat-tab-group.mat-primary .mat-tab-link.cdk-keyboard-focused,.mat-tab-group.mat-primary .mat-tab-link.cdk-program-focused,.mat-tab-nav-bar.mat-primary .mat-tab-label.cdk-keyboard-focused,.mat-tab-nav-bar.mat-primary .mat-tab-label.cdk-program-focused,.mat-tab-nav-bar.mat-primary .mat-tab-link.cdk-keyboard-focused,.mat-tab-nav-bar.mat-primary .mat-tab-link.cdk-program-focused{background-color:rgba(255,167,38,.3)}.mat-tab-group.mat-primary .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-group.mat-primary .mat-tab-label.cdk-program-focused.mat-tab-disabled,.mat-tab-group.mat-primary .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-group.mat-primary .mat-tab-link.cdk-program-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-primary .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-primary .mat-tab-label.cdk-program-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-primary .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-primary .mat-tab-link.cdk-program-focused.mat-tab-disabled{background-color:rgba(0,0,0,.1)}.mat-tab-group.mat-primary .mat-ink-bar,.mat-tab-nav-bar.mat-primary .mat-ink-bar{background-color:#f57c00}.mat-tab-group.mat-primary.mat-background-primary>.mat-tab-header .mat-ink-bar,.mat-tab-group.mat-primary.mat-background-primary>.mat-tab-link-container .mat-ink-bar,.mat-tab-nav-bar.mat-primary.mat-background-primary>.mat-tab-header .mat-ink-bar,.mat-tab-nav-bar.mat-primary.mat-background-primary>.mat-tab-link-container .mat-ink-bar{background-color:#fff}.mat-tab-group.mat-accent .mat-tab-label.cdk-keyboard-focused,.mat-tab-group.mat-accent .mat-tab-label.cdk-program-focused,.mat-tab-group.mat-accent .mat-tab-link.cdk-keyboard-focused,.mat-tab-group.mat-accent .mat-tab-link.cdk-program-focused,.mat-tab-nav-bar.mat-accent .mat-tab-label.cdk-keyboard-focused,.mat-tab-nav-bar.mat-accent .mat-tab-label.cdk-program-focused,.mat-tab-nav-bar.mat-accent .mat-tab-link.cdk-keyboard-focused,.mat-tab-nav-bar.mat-accent .mat-tab-link.cdk-program-focused{background-color:rgba(255,224,178,.3)}.mat-tab-group.mat-accent .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-group.mat-accent .mat-tab-label.cdk-program-focused.mat-tab-disabled,.mat-tab-group.mat-accent .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-group.mat-accent .mat-tab-link.cdk-program-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-accent .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-accent .mat-tab-label.cdk-program-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-accent .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-accent .mat-tab-link.cdk-program-focused.mat-tab-disabled{background-color:rgba(0,0,0,.1)}.mat-tab-group.mat-accent .mat-ink-bar,.mat-tab-nav-bar.mat-accent .mat-ink-bar{background-color:#ff9800}.mat-tab-group.mat-accent.mat-background-accent>.mat-tab-header .mat-ink-bar,.mat-tab-group.mat-accent.mat-background-accent>.mat-tab-link-container .mat-ink-bar,.mat-tab-nav-bar.mat-accent.mat-background-accent>.mat-tab-header .mat-ink-bar,.mat-tab-nav-bar.mat-accent.mat-background-accent>.mat-tab-link-container .mat-ink-bar{background-color:#fff}.mat-tab-group.mat-warn .mat-tab-label.cdk-keyboard-focused,.mat-tab-group.mat-warn .mat-tab-label.cdk-program-focused,.mat-tab-group.mat-warn .mat-tab-link.cdk-keyboard-focused,.mat-tab-group.mat-warn .mat-tab-link.cdk-program-focused,.mat-tab-nav-bar.mat-warn .mat-tab-label.cdk-keyboard-focused,.mat-tab-nav-bar.mat-warn .mat-tab-label.cdk-program-focused,.mat-tab-nav-bar.mat-warn .mat-tab-link.cdk-keyboard-focused,.mat-tab-nav-bar.mat-warn .mat-tab-link.cdk-program-focused{background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-warn .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-group.mat-warn .mat-tab-label.cdk-program-focused.mat-tab-disabled,.mat-tab-group.mat-warn .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-group.mat-warn .mat-tab-link.cdk-program-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-warn .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-warn .mat-tab-label.cdk-program-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-warn .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-warn .mat-tab-link.cdk-program-focused.mat-tab-disabled{background-color:rgba(0,0,0,.1)}.mat-tab-group.mat-warn .mat-ink-bar,.mat-tab-nav-bar.mat-warn .mat-ink-bar{background-color:#f44336}.mat-tab-group.mat-warn.mat-background-warn>.mat-tab-header .mat-ink-bar,.mat-tab-group.mat-warn.mat-background-warn>.mat-tab-link-container .mat-ink-bar,.mat-tab-nav-bar.mat-warn.mat-background-warn>.mat-tab-header .mat-ink-bar,.mat-tab-nav-bar.mat-warn.mat-background-warn>.mat-tab-link-container .mat-ink-bar{background-color:#fff}.mat-tab-group.mat-background-primary .mat-tab-label.cdk-keyboard-focused,.mat-tab-group.mat-background-primary .mat-tab-label.cdk-program-focused,.mat-tab-group.mat-background-primary .mat-tab-link.cdk-keyboard-focused,.mat-tab-group.mat-background-primary .mat-tab-link.cdk-program-focused,.mat-tab-nav-bar.mat-background-primary .mat-tab-label.cdk-keyboard-focused,.mat-tab-nav-bar.mat-background-primary .mat-tab-label.cdk-program-focused,.mat-tab-nav-bar.mat-background-primary .mat-tab-link.cdk-keyboard-focused,.mat-tab-nav-bar.mat-background-primary .mat-tab-link.cdk-program-focused{background-color:rgba(255,167,38,.3)}.mat-tab-group.mat-background-primary .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-group.mat-background-primary .mat-tab-label.cdk-program-focused.mat-tab-disabled,.mat-tab-group.mat-background-primary .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-group.mat-background-primary .mat-tab-link.cdk-program-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-background-primary .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-background-primary .mat-tab-label.cdk-program-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-background-primary .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-background-primary .mat-tab-link.cdk-program-focused.mat-tab-disabled{background-color:rgba(0,0,0,.1)}.mat-tab-group.mat-background-primary>.mat-tab-header,.mat-tab-group.mat-background-primary>.mat-tab-link-container,.mat-tab-group.mat-background-primary>.mat-tab-header-pagination,.mat-tab-nav-bar.mat-background-primary>.mat-tab-header,.mat-tab-nav-bar.mat-background-primary>.mat-tab-link-container,.mat-tab-nav-bar.mat-background-primary>.mat-tab-header-pagination{background-color:#f57c00}.mat-tab-group.mat-background-primary>.mat-tab-header .mat-tab-label,.mat-tab-group.mat-background-primary>.mat-tab-link-container .mat-tab-link,.mat-tab-nav-bar.mat-background-primary>.mat-tab-header .mat-tab-label,.mat-tab-nav-bar.mat-background-primary>.mat-tab-link-container .mat-tab-link{color:#fff}.mat-tab-group.mat-background-primary>.mat-tab-header .mat-tab-label.mat-tab-disabled,.mat-tab-group.mat-background-primary>.mat-tab-link-container .mat-tab-link.mat-tab-disabled,.mat-tab-nav-bar.mat-background-primary>.mat-tab-header .mat-tab-label.mat-tab-disabled,.mat-tab-nav-bar.mat-background-primary>.mat-tab-link-container .mat-tab-link.mat-tab-disabled{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary>.mat-tab-header .mat-tab-header-pagination-chevron,.mat-tab-group.mat-background-primary>.mat-tab-header-pagination .mat-tab-header-pagination-chevron,.mat-tab-group.mat-background-primary>.mat-tab-link-container .mat-focus-indicator::before,.mat-tab-group.mat-background-primary>.mat-tab-header .mat-focus-indicator::before,.mat-tab-nav-bar.mat-background-primary>.mat-tab-header .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-primary>.mat-tab-header-pagination .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-primary>.mat-tab-link-container .mat-focus-indicator::before,.mat-tab-nav-bar.mat-background-primary>.mat-tab-header .mat-focus-indicator::before{border-color:#fff}.mat-tab-group.mat-background-primary>.mat-tab-header .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,.mat-tab-group.mat-background-primary>.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-primary>.mat-tab-header .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-primary>.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron{border-color:#fff;opacity:.4}.mat-tab-group.mat-background-primary>.mat-tab-header .mat-ripple-element,.mat-tab-group.mat-background-primary>.mat-tab-link-container .mat-ripple-element,.mat-tab-group.mat-background-primary>.mat-tab-header-pagination .mat-ripple-element,.mat-tab-nav-bar.mat-background-primary>.mat-tab-header .mat-ripple-element,.mat-tab-nav-bar.mat-background-primary>.mat-tab-link-container .mat-ripple-element,.mat-tab-nav-bar.mat-background-primary>.mat-tab-header-pagination .mat-ripple-element{background-color:#fff;opacity:.12}.mat-tab-group.mat-background-accent .mat-tab-label.cdk-keyboard-focused,.mat-tab-group.mat-background-accent .mat-tab-label.cdk-program-focused,.mat-tab-group.mat-background-accent .mat-tab-link.cdk-keyboard-focused,.mat-tab-group.mat-background-accent .mat-tab-link.cdk-program-focused,.mat-tab-nav-bar.mat-background-accent .mat-tab-label.cdk-keyboard-focused,.mat-tab-nav-bar.mat-background-accent .mat-tab-label.cdk-program-focused,.mat-tab-nav-bar.mat-background-accent .mat-tab-link.cdk-keyboard-focused,.mat-tab-nav-bar.mat-background-accent .mat-tab-link.cdk-program-focused{background-color:rgba(255,224,178,.3)}.mat-tab-group.mat-background-accent .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-group.mat-background-accent .mat-tab-label.cdk-program-focused.mat-tab-disabled,.mat-tab-group.mat-background-accent .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-group.mat-background-accent .mat-tab-link.cdk-program-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-background-accent .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-background-accent .mat-tab-label.cdk-program-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-background-accent .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-background-accent .mat-tab-link.cdk-program-focused.mat-tab-disabled{background-color:rgba(0,0,0,.1)}.mat-tab-group.mat-background-accent>.mat-tab-header,.mat-tab-group.mat-background-accent>.mat-tab-link-container,.mat-tab-group.mat-background-accent>.mat-tab-header-pagination,.mat-tab-nav-bar.mat-background-accent>.mat-tab-header,.mat-tab-nav-bar.mat-background-accent>.mat-tab-link-container,.mat-tab-nav-bar.mat-background-accent>.mat-tab-header-pagination{background-color:#ff9800}.mat-tab-group.mat-background-accent>.mat-tab-header .mat-tab-label,.mat-tab-group.mat-background-accent>.mat-tab-link-container .mat-tab-link,.mat-tab-nav-bar.mat-background-accent>.mat-tab-header .mat-tab-label,.mat-tab-nav-bar.mat-background-accent>.mat-tab-link-container .mat-tab-link{color:#fff}.mat-tab-group.mat-background-accent>.mat-tab-header .mat-tab-label.mat-tab-disabled,.mat-tab-group.mat-background-accent>.mat-tab-link-container .mat-tab-link.mat-tab-disabled,.mat-tab-nav-bar.mat-background-accent>.mat-tab-header .mat-tab-label.mat-tab-disabled,.mat-tab-nav-bar.mat-background-accent>.mat-tab-link-container .mat-tab-link.mat-tab-disabled{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent>.mat-tab-header .mat-tab-header-pagination-chevron,.mat-tab-group.mat-background-accent>.mat-tab-header-pagination .mat-tab-header-pagination-chevron,.mat-tab-group.mat-background-accent>.mat-tab-link-container .mat-focus-indicator::before,.mat-tab-group.mat-background-accent>.mat-tab-header .mat-focus-indicator::before,.mat-tab-nav-bar.mat-background-accent>.mat-tab-header .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-accent>.mat-tab-header-pagination .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-accent>.mat-tab-link-container .mat-focus-indicator::before,.mat-tab-nav-bar.mat-background-accent>.mat-tab-header .mat-focus-indicator::before{border-color:#fff}.mat-tab-group.mat-background-accent>.mat-tab-header .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,.mat-tab-group.mat-background-accent>.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-accent>.mat-tab-header .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-accent>.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron{border-color:#fff;opacity:.4}.mat-tab-group.mat-background-accent>.mat-tab-header .mat-ripple-element,.mat-tab-group.mat-background-accent>.mat-tab-link-container .mat-ripple-element,.mat-tab-group.mat-background-accent>.mat-tab-header-pagination .mat-ripple-element,.mat-tab-nav-bar.mat-background-accent>.mat-tab-header .mat-ripple-element,.mat-tab-nav-bar.mat-background-accent>.mat-tab-link-container .mat-ripple-element,.mat-tab-nav-bar.mat-background-accent>.mat-tab-header-pagination .mat-ripple-element{background-color:#fff;opacity:.12}.mat-tab-group.mat-background-warn .mat-tab-label.cdk-keyboard-focused,.mat-tab-group.mat-background-warn .mat-tab-label.cdk-program-focused,.mat-tab-group.mat-background-warn .mat-tab-link.cdk-keyboard-focused,.mat-tab-group.mat-background-warn .mat-tab-link.cdk-program-focused,.mat-tab-nav-bar.mat-background-warn .mat-tab-label.cdk-keyboard-focused,.mat-tab-nav-bar.mat-background-warn .mat-tab-label.cdk-program-focused,.mat-tab-nav-bar.mat-background-warn .mat-tab-link.cdk-keyboard-focused,.mat-tab-nav-bar.mat-background-warn .mat-tab-link.cdk-program-focused{background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-background-warn .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-group.mat-background-warn .mat-tab-label.cdk-program-focused.mat-tab-disabled,.mat-tab-group.mat-background-warn .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-group.mat-background-warn .mat-tab-link.cdk-program-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-background-warn .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-background-warn .mat-tab-label.cdk-program-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-background-warn .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-background-warn .mat-tab-link.cdk-program-focused.mat-tab-disabled{background-color:rgba(0,0,0,.1)}.mat-tab-group.mat-background-warn>.mat-tab-header,.mat-tab-group.mat-background-warn>.mat-tab-link-container,.mat-tab-group.mat-background-warn>.mat-tab-header-pagination,.mat-tab-nav-bar.mat-background-warn>.mat-tab-header,.mat-tab-nav-bar.mat-background-warn>.mat-tab-link-container,.mat-tab-nav-bar.mat-background-warn>.mat-tab-header-pagination{background-color:#f44336}.mat-tab-group.mat-background-warn>.mat-tab-header .mat-tab-label,.mat-tab-group.mat-background-warn>.mat-tab-link-container .mat-tab-link,.mat-tab-nav-bar.mat-background-warn>.mat-tab-header .mat-tab-label,.mat-tab-nav-bar.mat-background-warn>.mat-tab-link-container .mat-tab-link{color:#fff}.mat-tab-group.mat-background-warn>.mat-tab-header .mat-tab-label.mat-tab-disabled,.mat-tab-group.mat-background-warn>.mat-tab-link-container .mat-tab-link.mat-tab-disabled,.mat-tab-nav-bar.mat-background-warn>.mat-tab-header .mat-tab-label.mat-tab-disabled,.mat-tab-nav-bar.mat-background-warn>.mat-tab-link-container .mat-tab-link.mat-tab-disabled{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn>.mat-tab-header .mat-tab-header-pagination-chevron,.mat-tab-group.mat-background-warn>.mat-tab-header-pagination .mat-tab-header-pagination-chevron,.mat-tab-group.mat-background-warn>.mat-tab-link-container .mat-focus-indicator::before,.mat-tab-group.mat-background-warn>.mat-tab-header .mat-focus-indicator::before,.mat-tab-nav-bar.mat-background-warn>.mat-tab-header .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-warn>.mat-tab-header-pagination .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-warn>.mat-tab-link-container .mat-focus-indicator::before,.mat-tab-nav-bar.mat-background-warn>.mat-tab-header .mat-focus-indicator::before{border-color:#fff}.mat-tab-group.mat-background-warn>.mat-tab-header .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,.mat-tab-group.mat-background-warn>.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-warn>.mat-tab-header .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-warn>.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron{border-color:#fff;opacity:.4}.mat-tab-group.mat-background-warn>.mat-tab-header .mat-ripple-element,.mat-tab-group.mat-background-warn>.mat-tab-link-container .mat-ripple-element,.mat-tab-group.mat-background-warn>.mat-tab-header-pagination .mat-ripple-element,.mat-tab-nav-bar.mat-background-warn>.mat-tab-header .mat-ripple-element,.mat-tab-nav-bar.mat-background-warn>.mat-tab-link-container .mat-ripple-element,.mat-tab-nav-bar.mat-background-warn>.mat-tab-header-pagination .mat-ripple-element{background-color:#fff;opacity:.12}.mat-snack-bar-container{color:rgba(255,255,255,.7);background:#323232;box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2), 0px 6px 10px 0px rgba(0, 0, 0, 0.14), 0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-simple-snackbar-action{color:#ff9800}.mat-table{background:#fff}.mat-table thead,.mat-table tbody,.mat-table tfoot,mat-header-row,mat-row,mat-footer-row,[mat-header-row],[mat-row],[mat-footer-row],.mat-table-sticky{background:inherit}mat-row,mat-header-row,mat-footer-row,th.mat-header-cell,td.mat-cell,td.mat-footer-cell{border-bottom-color:rgba(0,0,0,.12)}.mat-header-cell{color:#616161}.mat-cell,.mat-footer-cell{color:#212121}.mat-badge-content{color:#fff;background:#f57c00}.cdk-high-contrast-active .mat-badge-content{outline:solid 1px;border-radius:0}.mat-badge-accent .mat-badge-content{background:#ff9800;color:#fff}.mat-badge-warn .mat-badge-content{color:#fff;background:#f44336}.mat-badge-disabled .mat-badge-content{background:#bdbdbd;color:#757575}.mat-bottom-sheet-container{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2), 0px 16px 24px 2px rgba(0, 0, 0, 0.14), 0px 6px 30px 5px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-button-toggle-standalone:not([class*=mat-elevation-z]),.mat-button-toggle-group:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2), 0px 2px 2px 0px rgba(0, 0, 0, 0.14), 0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard:not([class*=mat-elevation-z]),.mat-button-toggle-group-appearance-standard:not([class*=mat-elevation-z]){box-shadow:none}.mat-button-toggle{color:rgba(0,0,0,.38)}.mat-button-toggle .mat-button-toggle-focus-overlay{background-color:rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard{color:#212121;background:#fff}.mat-button-toggle-appearance-standard .mat-button-toggle-focus-overlay{background-color:#000}.mat-button-toggle-group-appearance-standard .mat-button-toggle+.mat-button-toggle{border-left:solid 1px #e0e0e0}[dir=rtl] .mat-button-toggle-group-appearance-standard .mat-button-toggle+.mat-button-toggle{border-left:none;border-right:solid 1px #e0e0e0}.mat-button-toggle-group-appearance-standard.mat-button-toggle-vertical .mat-button-toggle+.mat-button-toggle{border-left:none;border-right:none;border-top:solid 1px #e0e0e0}.mat-button-toggle-checked{background-color:#e0e0e0;color:#616161}.mat-button-toggle-checked.mat-button-toggle-appearance-standard{color:#212121}.mat-button-toggle-disabled{color:rgba(0,0,0,.26);background-color:#eee}.mat-button-toggle-disabled.mat-button-toggle-appearance-standard{background:#fff}.mat-button-toggle-disabled.mat-button-toggle-checked{background-color:#bdbdbd}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard,.mat-button-toggle-group-appearance-standard{border:solid 1px #e0e0e0}.mat-button-toggle-appearance-standard .mat-button-toggle-label-content{line-height:48px}.mat-calendar-arrow{fill:rgba(0,0,0,.54)}.mat-datepicker-toggle,.mat-datepicker-content .mat-calendar-next-button,.mat-datepicker-content .mat-calendar-previous-button{color:rgba(0,0,0,.54)}.mat-calendar-table-header-divider::after{background:rgba(0,0,0,.12)}.mat-calendar-table-header,.mat-calendar-body-label{color:#616161}.mat-calendar-body-cell-content,.mat-date-range-input-separator{color:#212121;border-color:rgba(0,0,0,0)}.mat-calendar-body-disabled>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){color:#757575}.mat-form-field-disabled .mat-date-range-input-separator{color:#757575}.mat-calendar-body-in-preview{color:rgba(0,0,0,.24)}.mat-calendar-body-today:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.38)}.mat-calendar-body-disabled>.mat-calendar-body-today:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.18)}.mat-calendar-body-in-range::before{background:rgba(245,124,0,.2)}.mat-calendar-body-comparison-identical,.mat-calendar-body-in-comparison-range::before{background:rgba(249,171,0,.2)}.mat-calendar-body-comparison-bridge-start::before,[dir=rtl] .mat-calendar-body-comparison-bridge-end::before{background:linear-gradient(to right, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-comparison-bridge-end::before,[dir=rtl] .mat-calendar-body-comparison-bridge-start::before{background:linear-gradient(to left, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-in-range>.mat-calendar-body-comparison-identical,.mat-calendar-body-in-comparison-range.mat-calendar-body-in-range::after{background:#a8dab5}.mat-calendar-body-comparison-identical.mat-calendar-body-selected,.mat-calendar-body-in-comparison-range>.mat-calendar-body-selected{background:#46a35e}.mat-calendar-body-selected{background-color:#f57c00;color:#fff}.mat-calendar-body-disabled>.mat-calendar-body-selected{background-color:rgba(245,124,0,.4)}.mat-calendar-body-today.mat-calendar-body-selected{box-shadow:inset 0 0 0 1px #fff}.cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical),.cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(245,124,0,.3)}@media(hover: hover){.mat-calendar-body-cell:not(.mat-calendar-body-disabled):hover>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(245,124,0,.3)}}.mat-datepicker-content{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2), 0px 4px 5px 0px rgba(0, 0, 0, 0.14), 0px 1px 10px 0px rgba(0, 0, 0, 0.12);background-color:#fff;color:#212121}.mat-datepicker-content.mat-accent .mat-calendar-body-in-range::before{background:rgba(255,152,0,.2)}.mat-datepicker-content.mat-accent .mat-calendar-body-comparison-identical,.mat-datepicker-content.mat-accent .mat-calendar-body-in-comparison-range::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-accent .mat-calendar-body-comparison-bridge-start::before,.mat-datepicker-content.mat-accent [dir=rtl] .mat-calendar-body-comparison-bridge-end::before{background:linear-gradient(to right, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent .mat-calendar-body-comparison-bridge-end::before,.mat-datepicker-content.mat-accent [dir=rtl] .mat-calendar-body-comparison-bridge-start::before{background:linear-gradient(to left, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent .mat-calendar-body-in-range>.mat-calendar-body-comparison-identical,.mat-datepicker-content.mat-accent .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range::after{background:#a8dab5}.mat-datepicker-content.mat-accent .mat-calendar-body-comparison-identical.mat-calendar-body-selected,.mat-datepicker-content.mat-accent .mat-calendar-body-in-comparison-range>.mat-calendar-body-selected{background:#46a35e}.mat-datepicker-content.mat-accent .mat-calendar-body-selected{background-color:#ff9800;color:#fff}.mat-datepicker-content.mat-accent .mat-calendar-body-disabled>.mat-calendar-body-selected{background-color:rgba(255,152,0,.4)}.mat-datepicker-content.mat-accent .mat-calendar-body-today.mat-calendar-body-selected{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content.mat-accent .cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical),.mat-datepicker-content.mat-accent .cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(255,152,0,.3)}@media(hover: hover){.mat-datepicker-content.mat-accent .mat-calendar-body-cell:not(.mat-calendar-body-disabled):hover>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(255,152,0,.3)}}.mat-datepicker-content.mat-warn .mat-calendar-body-in-range::before{background:rgba(244,67,54,.2)}.mat-datepicker-content.mat-warn .mat-calendar-body-comparison-identical,.mat-datepicker-content.mat-warn .mat-calendar-body-in-comparison-range::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-warn .mat-calendar-body-comparison-bridge-start::before,.mat-datepicker-content.mat-warn [dir=rtl] .mat-calendar-body-comparison-bridge-end::before{background:linear-gradient(to right, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn .mat-calendar-body-comparison-bridge-end::before,.mat-datepicker-content.mat-warn [dir=rtl] .mat-calendar-body-comparison-bridge-start::before{background:linear-gradient(to left, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn .mat-calendar-body-in-range>.mat-calendar-body-comparison-identical,.mat-datepicker-content.mat-warn .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range::after{background:#a8dab5}.mat-datepicker-content.mat-warn .mat-calendar-body-comparison-identical.mat-calendar-body-selected,.mat-datepicker-content.mat-warn .mat-calendar-body-in-comparison-range>.mat-calendar-body-selected{background:#46a35e}.mat-datepicker-content.mat-warn .mat-calendar-body-selected{background-color:#f44336;color:#fff}.mat-datepicker-content.mat-warn .mat-calendar-body-disabled>.mat-calendar-body-selected{background-color:rgba(244,67,54,.4)}.mat-datepicker-content.mat-warn .mat-calendar-body-today.mat-calendar-body-selected{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content.mat-warn .cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical),.mat-datepicker-content.mat-warn .cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(244,67,54,.3)}@media(hover: hover){.mat-datepicker-content.mat-warn .mat-calendar-body-cell:not(.mat-calendar-body-disabled):hover>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(244,67,54,.3)}}.mat-datepicker-content-touch{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2), 0px 24px 38px 3px rgba(0, 0, 0, 0.14), 0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-datepicker-toggle-active{color:#f57c00}.mat-datepicker-toggle-active.mat-accent{color:#ff9800}.mat-datepicker-toggle-active.mat-warn{color:#f44336}.mat-date-range-input-inner[disabled]{color:#757575}.mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base{width:40px;height:40px;padding:8px}.mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base .mdc-icon-button__focus-ring{max-height:40px;max-width:40px}.mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base.mdc-icon-button--reduced-size .mdc-icon-button__ripple{width:40px;height:40px;margin-top:0px;margin-bottom:0px;margin-right:0px;margin-left:0px}.mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base.mdc-icon-button--reduced-size .mdc-icon-button__focus-ring{max-height:40px;max-width:40px}.mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base .mdc-icon-button__touch{position:absolute;top:50%;height:40px;left:50%;width:40px;transform:translate(-50%, -50%)}.mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base .mat-mdc-button-touch-target{display:none}.mat-divider{border-top-color:rgba(0,0,0,.12)}.mat-divider-vertical{border-right-color:rgba(0,0,0,.12)}.mat-expansion-panel{background:#fff;color:#212121}.mat-expansion-panel:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2), 0px 2px 2px 0px rgba(0, 0, 0, 0.14), 0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-action-row{border-top-color:rgba(0,0,0,.12)}.mat-expansion-panel .mat-expansion-panel-header.cdk-keyboard-focused:not([aria-disabled=true]),.mat-expansion-panel .mat-expansion-panel-header.cdk-program-focused:not([aria-disabled=true]),.mat-expansion-panel:not(.mat-expanded) .mat-expansion-panel-header:hover:not([aria-disabled=true]){background:rgba(0,0,0,.04)}@media(hover: none){.mat-expansion-panel:not(.mat-expanded):not([aria-disabled=true]) .mat-expansion-panel-header:hover{background:#fff}}.mat-expansion-panel-header-title{color:#212121}.mat-expansion-panel-header-description,.mat-expansion-indicator::after{color:#616161}.mat-expansion-panel-header[aria-disabled=true]{color:rgba(0,0,0,.26)}.mat-expansion-panel-header[aria-disabled=true] .mat-expansion-panel-header-title,.mat-expansion-panel-header[aria-disabled=true] .mat-expansion-panel-header-description{color:inherit}.mat-expansion-panel-header{height:48px}.mat-expansion-panel-header.mat-expanded{height:64px}.mat-icon.mat-primary{color:#f57c00}.mat-icon.mat-accent{color:#ff9800}.mat-icon.mat-warn{color:#f44336}.mat-drawer-container{background-color:#fff;color:#212121}.mat-drawer{background-color:#fff;color:#212121}.mat-drawer.mat-drawer-push{background-color:#fff}.mat-drawer:not(.mat-drawer-side){box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2), 0px 16px 24px 2px rgba(0, 0, 0, 0.14), 0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-drawer-side{border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-side.mat-drawer-end{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl] .mat-drawer-side{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl] .mat-drawer-side.mat-drawer-end{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-backdrop.mat-drawer-shown{background-color:rgba(0,0,0,.6)}.mat-step-header.cdk-keyboard-focused,.mat-step-header.cdk-program-focused,.mat-step-header:hover:not([aria-disabled]),.mat-step-header:hover[aria-disabled=false]{background-color:rgba(0,0,0,.04)}.mat-step-header:hover[aria-disabled=true]{cursor:default}@media(hover: none){.mat-step-header:hover{background:none}}.mat-step-header .mat-step-label,.mat-step-header .mat-step-optional{color:#616161}.mat-step-header .mat-step-icon{background-color:#616161;color:#fff}.mat-step-header .mat-step-icon-selected,.mat-step-header .mat-step-icon-state-done,.mat-step-header .mat-step-icon-state-edit{background-color:#f57c00;color:#fff}.mat-step-header.mat-accent .mat-step-icon{color:#fff}.mat-step-header.mat-accent .mat-step-icon-selected,.mat-step-header.mat-accent .mat-step-icon-state-done,.mat-step-header.mat-accent .mat-step-icon-state-edit{background-color:#ff9800;color:#fff}.mat-step-header.mat-warn .mat-step-icon{color:#fff}.mat-step-header.mat-warn .mat-step-icon-selected,.mat-step-header.mat-warn .mat-step-icon-state-done,.mat-step-header.mat-warn .mat-step-icon-state-edit{background-color:#f44336;color:#fff}.mat-step-header .mat-step-icon-state-error{background-color:rgba(0,0,0,0);color:#f44336}.mat-step-header .mat-step-label.mat-step-label-active{color:#212121}.mat-step-header .mat-step-label.mat-step-label-error{color:#f44336}.mat-stepper-horizontal,.mat-stepper-vertical{background-color:#fff}.mat-stepper-vertical-line::before{border-left-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header::before,.mat-horizontal-stepper-header::after,.mat-stepper-horizontal-line{border-top-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header{height:72px}.mat-stepper-label-position-bottom .mat-horizontal-stepper-header,.mat-vertical-stepper-header{padding:24px 24px}.mat-stepper-vertical-line::before{top:-16px;bottom:-16px}.mat-stepper-label-position-bottom .mat-horizontal-stepper-header::after,.mat-stepper-label-position-bottom .mat-horizontal-stepper-header::before{top:36px}.mat-stepper-label-position-bottom .mat-stepper-horizontal-line{top:36px}.mat-sort-header-arrow{color:#616161}.mat-toolbar{background:#f57c00;color:#212121}.mat-toolbar.mat-primary{background:#f57c00;color:#fff}.mat-toolbar.mat-accent{background:#ff9800;color:#fff}.mat-toolbar.mat-warn{background:#f44336;color:#fff}.mat-toolbar .mat-form-field-underline,.mat-toolbar .mat-form-field-ripple,.mat-toolbar .mat-focused .mat-form-field-ripple{background-color:currentColor}.mat-toolbar .mat-form-field-label,.mat-toolbar .mat-focused .mat-form-field-label,.mat-toolbar .mat-select-value,.mat-toolbar .mat-select-arrow,.mat-toolbar .mat-form-field.mat-focused .mat-select-arrow{color:inherit}.mat-toolbar .mat-input-element{caret-color:currentColor}.mat-toolbar-multiple-rows{min-height:64px}.mat-toolbar-row,.mat-toolbar-single-row{height:64px}@media(max-width: 599px){.mat-toolbar-multiple-rows{min-height:56px}.mat-toolbar-row,.mat-toolbar-single-row{height:56px}}.mat-tree{background:#fff}.mat-tree-node,.mat-nested-tree-node{color:#212121}.mat-tree-node{min-height:48px}.mat-ripple-element{background-color:rgba(0,0,0,.1)}.mat-mdc-option{color:var(--mdc-theme-text-primary-on-background, rgba(0, 0, 0, 0.87))}.mat-mdc-option:hover:not(.mdc-list-item--disabled),.mat-mdc-option:focus:not(.mdc-list-item--disabled),.mat-mdc-option.mat-mdc-option-active,.mat-mdc-option.mdc-list-item--selected:not(.mat-mdc-option-multiple):not(.mdc-list-item--disabled){background:rgba(0,0,0,.04)}.mat-primary .mat-mdc-option.mdc-list-item--selected:not(.mdc-list-item--disabled) .mdc-list-item__primary-text{color:var(--mdc-theme-primary, #f57c00)}.mat-accent .mat-mdc-option.mdc-list-item--selected:not(.mdc-list-item--disabled) .mdc-list-item__primary-text{color:var(--mdc-theme-secondary, #ff9800)}.mat-warn .mat-mdc-option.mdc-list-item--selected:not(.mdc-list-item--disabled) .mdc-list-item__primary-text{color:var(--mdc-theme-error, #f44336)}.mat-mdc-optgroup-label{color:var(--mdc-theme-text-primary-on-background, rgba(0, 0, 0, 0.87))}.mat-pseudo-checkbox-full{color:#616161}.mat-pseudo-checkbox-full.mat-pseudo-checkbox-disabled{color:#b0b0b0}.mat-primary .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,.mat-primary .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#f57c00}.mat-primary .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,.mat-primary .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#f57c00}.mat-primary .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full::after,.mat-primary .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full::after{color:#fff}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,.mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#ff9800}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,.mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#ff9800}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full::after,.mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full::after{color:#fff}.mat-accent .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,.mat-accent .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#ff9800}.mat-accent .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,.mat-accent .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#ff9800}.mat-accent .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full::after,.mat-accent .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full::after{color:#fff}.mat-warn .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,.mat-warn .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#f44336}.mat-warn .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,.mat-warn .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#f44336}.mat-warn .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full::after,.mat-warn .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full::after{color:#fff}.mat-pseudo-checkbox-disabled.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,.mat-pseudo-checkbox-disabled.mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#b0b0b0}.mat-pseudo-checkbox-disabled.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,.mat-pseudo-checkbox-disabled.mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#b0b0b0}.mat-app-background{background-color:#fff;color:#212121}.mat-elevation-z0,.mat-mdc-elevation-specific.mat-elevation-z0{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2), 0px 0px 0px 0px rgba(0, 0, 0, 0.14), 0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z1,.mat-mdc-elevation-specific.mat-elevation-z1{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2), 0px 1px 1px 0px rgba(0, 0, 0, 0.14), 0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z2,.mat-mdc-elevation-specific.mat-elevation-z2{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2), 0px 2px 2px 0px rgba(0, 0, 0, 0.14), 0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z3,.mat-mdc-elevation-specific.mat-elevation-z3{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2), 0px 3px 4px 0px rgba(0, 0, 0, 0.14), 0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z4,.mat-mdc-elevation-specific.mat-elevation-z4{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2), 0px 4px 5px 0px rgba(0, 0, 0, 0.14), 0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z5,.mat-mdc-elevation-specific.mat-elevation-z5{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2), 0px 5px 8px 0px rgba(0, 0, 0, 0.14), 0px 1px 14px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z6,.mat-mdc-elevation-specific.mat-elevation-z6{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2), 0px 6px 10px 0px rgba(0, 0, 0, 0.14), 0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z7,.mat-mdc-elevation-specific.mat-elevation-z7{box-shadow:0px 4px 5px -2px rgba(0, 0, 0, 0.2), 0px 7px 10px 1px rgba(0, 0, 0, 0.14), 0px 2px 16px 1px rgba(0, 0, 0, 0.12)}.mat-elevation-z8,.mat-mdc-elevation-specific.mat-elevation-z8{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2), 0px 8px 10px 1px rgba(0, 0, 0, 0.14), 0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z9,.mat-mdc-elevation-specific.mat-elevation-z9{box-shadow:0px 5px 6px -3px rgba(0, 0, 0, 0.2), 0px 9px 12px 1px rgba(0, 0, 0, 0.14), 0px 3px 16px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z10,.mat-mdc-elevation-specific.mat-elevation-z10{box-shadow:0px 6px 6px -3px rgba(0, 0, 0, 0.2), 0px 10px 14px 1px rgba(0, 0, 0, 0.14), 0px 4px 18px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z11,.mat-mdc-elevation-specific.mat-elevation-z11{box-shadow:0px 6px 7px -4px rgba(0, 0, 0, 0.2), 0px 11px 15px 1px rgba(0, 0, 0, 0.14), 0px 4px 20px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z12,.mat-mdc-elevation-specific.mat-elevation-z12{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2), 0px 12px 17px 2px rgba(0, 0, 0, 0.14), 0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z13,.mat-mdc-elevation-specific.mat-elevation-z13{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2), 0px 13px 19px 2px rgba(0, 0, 0, 0.14), 0px 5px 24px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z14,.mat-mdc-elevation-specific.mat-elevation-z14{box-shadow:0px 7px 9px -4px rgba(0, 0, 0, 0.2), 0px 14px 21px 2px rgba(0, 0, 0, 0.14), 0px 5px 26px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z15,.mat-mdc-elevation-specific.mat-elevation-z15{box-shadow:0px 8px 9px -5px rgba(0, 0, 0, 0.2), 0px 15px 22px 2px rgba(0, 0, 0, 0.14), 0px 6px 28px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z16,.mat-mdc-elevation-specific.mat-elevation-z16{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2), 0px 16px 24px 2px rgba(0, 0, 0, 0.14), 0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z17,.mat-mdc-elevation-specific.mat-elevation-z17{box-shadow:0px 8px 11px -5px rgba(0, 0, 0, 0.2), 0px 17px 26px 2px rgba(0, 0, 0, 0.14), 0px 6px 32px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z18,.mat-mdc-elevation-specific.mat-elevation-z18{box-shadow:0px 9px 11px -5px rgba(0, 0, 0, 0.2), 0px 18px 28px 2px rgba(0, 0, 0, 0.14), 0px 7px 34px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z19,.mat-mdc-elevation-specific.mat-elevation-z19{box-shadow:0px 9px 12px -6px rgba(0, 0, 0, 0.2), 0px 19px 29px 2px rgba(0, 0, 0, 0.14), 0px 7px 36px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z20,.mat-mdc-elevation-specific.mat-elevation-z20{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2), 0px 20px 31px 3px rgba(0, 0, 0, 0.14), 0px 8px 38px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z21,.mat-mdc-elevation-specific.mat-elevation-z21{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2), 0px 21px 33px 3px rgba(0, 0, 0, 0.14), 0px 8px 40px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z22,.mat-mdc-elevation-specific.mat-elevation-z22{box-shadow:0px 10px 14px -6px rgba(0, 0, 0, 0.2), 0px 22px 35px 3px rgba(0, 0, 0, 0.14), 0px 8px 42px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z23,.mat-mdc-elevation-specific.mat-elevation-z23{box-shadow:0px 11px 14px -7px rgba(0, 0, 0, 0.2), 0px 23px 36px 3px rgba(0, 0, 0, 0.14), 0px 9px 44px 8px rgba(0, 0, 0, 0.12)}.mat-elevation-z24,.mat-mdc-elevation-specific.mat-elevation-z24{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2), 0px 24px 38px 3px rgba(0, 0, 0, 0.14), 0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-theme-loaded-marker{display:none}.mat-mdc-card{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2), 0px 1px 1px 0px rgba(0, 0, 0, 0.14), 0px 1px 3px 0px rgba(0, 0, 0, 0.12);--mdc-elevated-card-container-color:#fff}.mat-mdc-card-outlined{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2), 0px 0px 0px 0px rgba(0, 0, 0, 0.14), 0px 0px 0px 0px rgba(0, 0, 0, 0.12);--mdc-outlined-card-outline-color:#e0e0e0}.mat-mdc-card-subtitle{color:#616161}.mat-mdc-progress-bar{--mdc-linear-progress-active-indicator-color:#f57c00}.mat-mdc-progress-bar .mdc-linear-progress__buffer-dots{background-image:url("data:image/svg+xml,%3Csvg version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' enable-background='new 0 0 5 2' xml:space='preserve' viewBox='0 0 5 2' preserveAspectRatio='none slice'%3E%3Ccircle cx='1' cy='1' r='1' fill='rgba(245, 124, 0, 0.25)'/%3E%3C/svg%3E")}.mat-mdc-progress-bar .mdc-linear-progress__buffer-bar{background-color:rgba(245, 124, 0, 0.25)}.mat-mdc-progress-bar.mat-accent{--mdc-linear-progress-active-indicator-color:#ff9800}.mat-mdc-progress-bar.mat-accent .mdc-linear-progress__buffer-dots{background-image:url("data:image/svg+xml,%3Csvg version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' enable-background='new 0 0 5 2' xml:space='preserve' viewBox='0 0 5 2' preserveAspectRatio='none slice'%3E%3Ccircle cx='1' cy='1' r='1' fill='rgba(255, 152, 0, 0.25)'/%3E%3C/svg%3E")}.mat-mdc-progress-bar.mat-accent .mdc-linear-progress__buffer-bar{background-color:rgba(255, 152, 0, 0.25)}.mat-mdc-progress-bar.mat-warn{--mdc-linear-progress-active-indicator-color:#f44336}.mat-mdc-progress-bar.mat-warn .mdc-linear-progress__buffer-dots{background-image:url("data:image/svg+xml,%3Csvg version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' enable-background='new 0 0 5 2' xml:space='preserve' viewBox='0 0 5 2' preserveAspectRatio='none slice'%3E%3Ccircle cx='1' cy='1' r='1' fill='rgba(244, 67, 54, 0.25)'/%3E%3C/svg%3E")}.mat-mdc-progress-bar.mat-warn .mdc-linear-progress__buffer-bar{background-color:rgba(244, 67, 54, 0.25)}.mat-mdc-tooltip{--mdc-plain-tooltip-container-color:#616161;--mdc-plain-tooltip-supporting-text-color:white}.mdc-text-field:not(.mdc-text-field--disabled) .mdc-floating-label{color:rgba(0, 0, 0, 0.6)}.mdc-text-field:not(.mdc-text-field--disabled) .mdc-text-field__input{color:rgba(0, 0, 0, 0.87)}@media all{.mdc-text-field:not(.mdc-text-field--disabled) .mdc-text-field__input::placeholder{color:rgba(0, 0, 0, 0.6)}}@media all{.mdc-text-field:not(.mdc-text-field--disabled) .mdc-text-field__input:-ms-input-placeholder{color:rgba(0, 0, 0, 0.6)}}.mdc-text-field .mdc-text-field__input{caret-color:var(--mdc-theme-primary, #f57c00)}.mdc-text-field:not(.mdc-text-field--disabled)+.mdc-text-field-helper-line .mdc-text-field-helper-text{color:rgba(0, 0, 0, 0.6)}.mdc-text-field:not(.mdc-text-field--disabled) .mdc-text-field-character-counter,.mdc-text-field:not(.mdc-text-field--disabled)+.mdc-text-field-helper-line .mdc-text-field-character-counter{color:rgba(0, 0, 0, 0.6)}.mdc-text-field:not(.mdc-text-field--disabled) .mdc-text-field__icon--leading{color:rgba(0, 0, 0, 0.54)}.mdc-text-field:not(.mdc-text-field--disabled) .mdc-text-field__icon--trailing{color:rgba(0, 0, 0, 0.54)}.mdc-text-field:not(.mdc-text-field--disabled) .mdc-text-field__affix--prefix{color:rgba(0, 0, 0, 0.6)}.mdc-text-field:not(.mdc-text-field--disabled) .mdc-text-field__affix--suffix{color:rgba(0, 0, 0, 0.6)}.mdc-text-field--filled .mdc-text-field__ripple::before,.mdc-text-field--filled .mdc-text-field__ripple::after{background-color:var(--mdc-ripple-color, rgba(0, 0, 0, 0.87))}.mdc-text-field--filled:hover .mdc-text-field__ripple::before,.mdc-text-field--filled.mdc-ripple-surface--hover .mdc-text-field__ripple::before{opacity:var(--mdc-ripple-hover-opacity, 0.04)}.mdc-text-field--filled.mdc-ripple-upgraded--background-focused .mdc-text-field__ripple::before,.mdc-text-field--filled:not(.mdc-ripple-upgraded):focus .mdc-text-field__ripple::before{opacity:var(--mdc-ripple-focus-opacity, 0.12)}.mdc-text-field--filled:not(.mdc-text-field--disabled){background-color:whitesmoke}.mdc-text-field--filled:not(.mdc-text-field--disabled) .mdc-line-ripple::before{border-bottom-color:rgba(0, 0, 0, 0.42)}.mdc-text-field--filled:not(.mdc-text-field--disabled):hover .mdc-line-ripple::before{border-bottom-color:rgba(0, 0, 0, 0.87)}.mdc-text-field--filled .mdc-line-ripple::after{border-bottom-color:var(--mdc-theme-primary, #f57c00)}.mdc-text-field--outlined:not(.mdc-text-field--disabled) .mdc-notched-outline__leading,.mdc-text-field--outlined:not(.mdc-text-field--disabled) .mdc-notched-outline__notch,.mdc-text-field--outlined:not(.mdc-text-field--disabled) .mdc-notched-outline__trailing{border-color:rgba(0, 0, 0, 0.38)}.mdc-text-field--outlined:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__leading,.mdc-text-field--outlined:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__notch,.mdc-text-field--outlined:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__trailing{border-color:rgba(0, 0, 0, 0.87)}.mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__leading,.mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__notch,.mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__trailing{border-color:var(--mdc-theme-primary, #f57c00)}.mdc-text-field--outlined .mdc-text-field__ripple::before,.mdc-text-field--outlined .mdc-text-field__ripple::after{background-color:var(--mdc-ripple-color, transparent)}.mdc-text-field--focused:not(.mdc-text-field--disabled) .mdc-floating-label{color:rgba(245, 124, 0, 0.87)}.mdc-text-field--invalid:not(.mdc-text-field--disabled):hover .mdc-line-ripple::before{border-bottom-color:var(--mdc-theme-error, #f44336)}.mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-line-ripple::after{border-bottom-color:var(--mdc-theme-error, #f44336)}.mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-floating-label{color:var(--mdc-theme-error, #f44336)}.mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--invalid+.mdc-text-field-helper-line .mdc-text-field-helper-text--validation-msg{color:var(--mdc-theme-error, #f44336)}.mdc-text-field--invalid .mdc-text-field__input{caret-color:var(--mdc-theme-error, #f44336)}.mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-text-field__icon--trailing{color:var(--mdc-theme-error, #f44336)}.mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-line-ripple::before{border-bottom-color:var(--mdc-theme-error, #f44336)}.mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__leading,.mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__notch,.mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}.mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__leading,.mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__notch,.mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}.mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__leading,.mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__notch,.mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}.mdc-text-field--disabled .mdc-text-field__input{color:rgba(0, 0, 0, 0.38)}@media all{.mdc-text-field--disabled .mdc-text-field__input::placeholder{color:rgba(0, 0, 0, 0.38)}}@media all{.mdc-text-field--disabled .mdc-text-field__input:-ms-input-placeholder{color:rgba(0, 0, 0, 0.38)}}.mdc-text-field--disabled .mdc-floating-label{color:rgba(0, 0, 0, 0.38)}.mdc-text-field--disabled+.mdc-text-field-helper-line .mdc-text-field-helper-text{color:rgba(0, 0, 0, 0.38)}.mdc-text-field--disabled .mdc-text-field-character-counter,.mdc-text-field--disabled+.mdc-text-field-helper-line .mdc-text-field-character-counter{color:rgba(0, 0, 0, 0.38)}.mdc-text-field--disabled .mdc-text-field__icon--leading{color:rgba(0, 0, 0, 0.3)}.mdc-text-field--disabled .mdc-text-field__icon--trailing{color:rgba(0, 0, 0, 0.3)}.mdc-text-field--disabled .mdc-text-field__affix--prefix{color:rgba(0, 0, 0, 0.38)}.mdc-text-field--disabled .mdc-text-field__affix--suffix{color:rgba(0, 0, 0, 0.38)}.mdc-text-field--disabled .mdc-line-ripple::before{border-bottom-color:rgba(0, 0, 0, 0.06)}.mdc-text-field--disabled .mdc-notched-outline__leading,.mdc-text-field--disabled .mdc-notched-outline__notch,.mdc-text-field--disabled .mdc-notched-outline__trailing{border-color:rgba(0, 0, 0, 0.06)}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mdc-text-field--disabled .mdc-text-field__input::placeholder{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mdc-text-field--disabled .mdc-text-field__input:-ms-input-placeholder{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mdc-text-field--disabled .mdc-floating-label{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mdc-text-field--disabled+.mdc-text-field-helper-line .mdc-text-field-helper-text{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mdc-text-field--disabled .mdc-text-field-character-counter,.mdc-text-field--disabled+.mdc-text-field-helper-line .mdc-text-field-character-counter{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mdc-text-field--disabled .mdc-text-field__icon--leading{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mdc-text-field--disabled .mdc-text-field__icon--trailing{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mdc-text-field--disabled .mdc-text-field__affix--prefix{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mdc-text-field--disabled .mdc-text-field__affix--suffix{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mdc-text-field--disabled .mdc-line-ripple::before{border-bottom-color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mdc-text-field--disabled .mdc-notched-outline__leading,.mdc-text-field--disabled .mdc-notched-outline__notch,.mdc-text-field--disabled .mdc-notched-outline__trailing{border-color:GrayText}}.mdc-text-field--disabled.mdc-text-field--filled{background-color:#fafafa}.mat-mdc-form-field-error{color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field-focus-overlay{background-color:rgba(0,0,0,.87)}.mat-mdc-form-field:hover .mat-mdc-form-field-focus-overlay{opacity:.04}.mat-mdc-form-field.mat-focused .mat-mdc-form-field-focus-overlay{opacity:.12}.mat-mdc-form-field-type-mat-native-select .mat-mdc-form-field-infix::after{color:rgba(0,0,0,.54)}.mat-mdc-form-field-type-mat-native-select.mat-focused.mat-primary .mat-mdc-form-field-infix::after{color:rgba(245,124,0,.87)}.mat-mdc-form-field-type-mat-native-select.mat-focused.mat-accent .mat-mdc-form-field-infix::after{color:rgba(255,152,0,.87)}.mat-mdc-form-field-type-mat-native-select.mat-focused.mat-warn .mat-mdc-form-field-infix::after{color:rgba(244,67,54,.87)}.mat-mdc-form-field-type-mat-native-select.mat-form-field-disabled .mat-mdc-form-field-infix::after{color:rgba(0,0,0,.38)}.mat-mdc-form-field.mat-accent .mdc-text-field__input{caret-color:var(--mdc-theme-secondary, #ff9800)}.mat-mdc-form-field.mat-accent:not(.mdc-text-field--disabled) .mdc-line-ripple::after{border-bottom-color:var(--mdc-theme-secondary, #ff9800)}.mat-mdc-form-field.mat-accent .mdc-text-field--focused:not(.mdc-text-field--disabled) .mdc-floating-label{color:rgba(255, 152, 0, 0.87)}.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled):hover .mdc-line-ripple::before{border-bottom-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-line-ripple::after{border-bottom-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-floating-label{color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--invalid+.mdc-text-field-helper-line .mdc-text-field-helper-text--validation-msg{color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-accent .mdc-text-field--invalid .mdc-text-field__input{caret-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-text-field__icon--trailing{color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-line-ripple::before{border-bottom-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__leading,.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__notch,.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__leading,.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__notch,.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__leading,.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__notch,.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-accent .mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__leading,.mat-mdc-form-field.mat-accent .mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__notch,.mat-mdc-form-field.mat-accent .mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__trailing{border-color:var(--mdc-theme-secondary, #ff9800)}.mat-mdc-form-field.mat-warn .mdc-text-field__input{caret-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-warn:not(.mdc-text-field--disabled) .mdc-line-ripple::after{border-bottom-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-warn .mdc-text-field--focused:not(.mdc-text-field--disabled) .mdc-floating-label{color:rgba(244, 67, 54, 0.87)}.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled):hover .mdc-line-ripple::before{border-bottom-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-line-ripple::after{border-bottom-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-floating-label{color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--invalid+.mdc-text-field-helper-line .mdc-text-field-helper-text--validation-msg{color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-warn .mdc-text-field--invalid .mdc-text-field__input{caret-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-text-field__icon--trailing{color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-line-ripple::before{border-bottom-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__leading,.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__notch,.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__leading,.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__notch,.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__leading,.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__notch,.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-warn .mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__leading,.mat-mdc-form-field.mat-warn .mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__notch,.mat-mdc-form-field.mat-warn .mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-mdc-form-field.mat-mdc-form-field.mat-mdc-form-field.mat-mdc-form-field .mdc-notched-outline__notch{border-left:1px solid rgba(0,0,0,0)}[dir=rtl] .mat-mdc-form-field.mat-mdc-form-field.mat-mdc-form-field.mat-mdc-form-field.mat-mdc-form-field .mdc-notched-outline__notch{border-left:none;border-right:1px solid rgba(0,0,0,0)}.mat-mdc-form-field-infix{min-height:56px}.mat-mdc-text-field-wrapper .mat-mdc-form-field-flex .mat-mdc-floating-label{top:28px}.mat-mdc-text-field-wrapper.mdc-text-field--outlined .mdc-notched-outline--upgraded .mdc-floating-label--float-above{--mat-mdc-form-field-label-transform: translateY( -34.75px) scale(var(--mat-mdc-form-field-floating-label-scale, 0.75));transform:var(--mat-mdc-form-field-label-transform)}.mat-mdc-text-field-wrapper.mdc-text-field--outlined .mat-mdc-form-field-infix{padding-top:16px;padding-bottom:16px}.mat-mdc-text-field-wrapper:not(.mdc-text-field--outlined) .mat-mdc-form-field-infix{padding-top:24px;padding-bottom:8px}.mdc-text-field--no-label:not(.mdc-text-field--outlined):not(.mdc-text-field--textarea) .mat-mdc-form-field-infix{padding-top:16px;padding-bottom:16px}.mdc-menu-surface{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2), 0px 8px 10px 1px rgba(0, 0, 0, 0.14), 0px 3px 14px 2px rgba(0, 0, 0, 0.12);background-color:var(--mdc-theme-surface, #fff);color:var(--mdc-theme-on-surface, #000)}.mdc-list-item__primary-text{color:var(--mdc-theme-text-primary-on-background, rgba(0, 0, 0, 0.87))}.mdc-list-item__secondary-text{color:var(--mdc-theme-text-secondary-on-background, rgba(0, 0, 0, 0.54))}.mdc-list-item__overline-text{color:var(--mdc-theme-text-hint-on-background, rgba(0, 0, 0, 0.38))}.mdc-list-item--with-leading-icon .mdc-list-item__start,.mdc-list-item--with-trailing-icon .mdc-list-item__end{background-color:transparent}.mdc-list-item--with-leading-icon .mdc-list-item__start,.mdc-list-item--with-trailing-icon .mdc-list-item__end{color:var(--mdc-theme-text-icon-on-background, rgba(0, 0, 0, 0.38))}.mdc-list-item__end{color:var(--mdc-theme-text-hint-on-background, rgba(0, 0, 0, 0.38))}.mdc-list-item--disabled .mdc-list-item__start,.mdc-list-item--disabled .mdc-list-item__content,.mdc-list-item--disabled .mdc-list-item__end{opacity:0.38}.mdc-list-item--disabled .mdc-list-item__primary-text{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled .mdc-list-item__secondary-text{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled .mdc-list-item__overline-text{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled.mdc-list-item--with-leading-icon .mdc-list-item__start{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled.mdc-list-item--with-trailing-icon .mdc-list-item__end{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled.mdc-list-item--with-trailing-meta .mdc-list-item__end{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--selected .mdc-list-item__primary-text,.mdc-list-item--activated .mdc-list-item__primary-text{color:var(--mdc-theme-primary, #f57c00)}.mdc-list-item--selected.mdc-list-item--with-leading-icon .mdc-list-item__start,.mdc-list-item--activated.mdc-list-item--with-leading-icon .mdc-list-item__start{color:var(--mdc-theme-primary, #f57c00)}.mdc-deprecated-list-group__subheader{color:var(--mdc-theme-text-primary-on-background, rgba(0, 0, 0, 0.87))}.mdc-list-divider::after{border-bottom-color:white}.mdc-list-divider{background-color:rgba(0, 0, 0, 0.12)}.mat-mdc-select-value{color:rgba(0,0,0,.87)}.mat-mdc-select-placeholder{color:rgba(0,0,0,.6)}.mat-mdc-select-disabled .mat-mdc-select-value{color:rgba(0,0,0,.38)}.mat-mdc-select-arrow{color:rgba(0,0,0,.54)}.mat-mdc-form-field.mat-focused.mat-primary .mat-mdc-select-arrow{color:rgba(245,124,0,.87)}.mat-mdc-form-field.mat-focused.mat-accent .mat-mdc-select-arrow{color:rgba(255,152,0,.87)}.mat-mdc-form-field.mat-focused.mat-warn .mat-mdc-select-arrow{color:rgba(244,67,54,.87)}.mat-mdc-form-field .mat-mdc-select.mat-mdc-select-invalid .mat-mdc-select-arrow{color:rgba(244,67,54,.87)}.mat-mdc-form-field .mat-mdc-select.mat-mdc-select-disabled .mat-mdc-select-arrow{color:rgba(0,0,0,.38)}.mdc-menu-surface{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2), 0px 8px 10px 1px rgba(0, 0, 0, 0.14), 0px 3px 14px 2px rgba(0, 0, 0, 0.12);background-color:var(--mdc-theme-surface, #fff);color:var(--mdc-theme-on-surface, #000)}.mdc-list-item__primary-text{color:var(--mdc-theme-text-primary-on-background, rgba(0, 0, 0, 0.87))}.mdc-list-item__secondary-text{color:var(--mdc-theme-text-secondary-on-background, rgba(0, 0, 0, 0.54))}.mdc-list-item__overline-text{color:var(--mdc-theme-text-hint-on-background, rgba(0, 0, 0, 0.38))}.mdc-list-item--with-leading-icon .mdc-list-item__start,.mdc-list-item--with-trailing-icon .mdc-list-item__end{background-color:transparent}.mdc-list-item--with-leading-icon .mdc-list-item__start,.mdc-list-item--with-trailing-icon .mdc-list-item__end{color:var(--mdc-theme-text-icon-on-background, rgba(0, 0, 0, 0.38))}.mdc-list-item__end{color:var(--mdc-theme-text-hint-on-background, rgba(0, 0, 0, 0.38))}.mdc-list-item--disabled .mdc-list-item__start,.mdc-list-item--disabled .mdc-list-item__content,.mdc-list-item--disabled .mdc-list-item__end{opacity:0.38}.mdc-list-item--disabled .mdc-list-item__primary-text{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled .mdc-list-item__secondary-text{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled .mdc-list-item__overline-text{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled.mdc-list-item--with-leading-icon .mdc-list-item__start{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled.mdc-list-item--with-trailing-icon .mdc-list-item__end{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled.mdc-list-item--with-trailing-meta .mdc-list-item__end{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--selected .mdc-list-item__primary-text,.mdc-list-item--activated .mdc-list-item__primary-text{color:var(--mdc-theme-primary, #f57c00)}.mdc-list-item--selected.mdc-list-item--with-leading-icon .mdc-list-item__start,.mdc-list-item--activated.mdc-list-item--with-leading-icon .mdc-list-item__start{color:var(--mdc-theme-primary, #f57c00)}.mdc-deprecated-list-group__subheader{color:var(--mdc-theme-text-primary-on-background, rgba(0, 0, 0, 0.87))}.mdc-list-divider::after{border-bottom-color:white}.mdc-list-divider{background-color:rgba(0, 0, 0, 0.12)}.mat-mdc-dialog-container{--mdc-dialog-container-color:white;--mdc-dialog-with-divider-divider-color:rgba(0, 0, 0, 0.12);--mdc-dialog-subhead-color:rgba(0, 0, 0, 0.87);--mdc-dialog-supporting-text-color:rgba(0, 0, 0, 0.6)}.mat-mdc-standard-chip{--mdc-chip-elevated-container-color:#e0e0e0;--mdc-chip-elevated-disabled-container-color:#e0e0e0;--mdc-chip-label-text-color:#212121;--mdc-chip-disabled-label-text-color:#212121;--mdc-chip-with-icon-icon-color:#212121;--mdc-chip-with-icon-disabled-icon-color:#212121;--mdc-chip-with-trailing-icon-disabled-trailing-icon-color:#212121;--mdc-chip-with-trailing-icon-trailing-icon-color:#212121;--mdc-chip-with-icon-selected-icon-color:#212121}.mat-mdc-standard-chip.mat-primary.mat-mdc-chip-selected,.mat-mdc-standard-chip.mat-primary.mat-mdc-chip-highlighted{--mdc-chip-elevated-container-color:#f57c00;--mdc-chip-elevated-disabled-container-color:#f57c00;--mdc-chip-label-text-color:white;--mdc-chip-disabled-label-text-color:white;--mdc-chip-with-icon-icon-color:white;--mdc-chip-with-icon-disabled-icon-color:white;--mdc-chip-with-trailing-icon-disabled-trailing-icon-color:white;--mdc-chip-with-trailing-icon-trailing-icon-color:white;--mdc-chip-with-icon-selected-icon-color:white}.mat-mdc-standard-chip.mat-accent.mat-mdc-chip-selected,.mat-mdc-standard-chip.mat-accent.mat-mdc-chip-highlighted{--mdc-chip-elevated-container-color:#ff9800;--mdc-chip-elevated-disabled-container-color:#ff9800;--mdc-chip-label-text-color:white;--mdc-chip-disabled-label-text-color:white;--mdc-chip-with-icon-icon-color:white;--mdc-chip-with-icon-disabled-icon-color:white;--mdc-chip-with-trailing-icon-disabled-trailing-icon-color:white;--mdc-chip-with-trailing-icon-trailing-icon-color:white;--mdc-chip-with-icon-selected-icon-color:white}.mat-mdc-standard-chip.mat-warn.mat-mdc-chip-selected,.mat-mdc-standard-chip.mat-warn.mat-mdc-chip-highlighted{--mdc-chip-elevated-container-color:#f44336;--mdc-chip-elevated-disabled-container-color:#f44336;--mdc-chip-label-text-color:white;--mdc-chip-disabled-label-text-color:white;--mdc-chip-with-icon-icon-color:white;--mdc-chip-with-icon-disabled-icon-color:white;--mdc-chip-with-trailing-icon-disabled-trailing-icon-color:white;--mdc-chip-with-trailing-icon-trailing-icon-color:white;--mdc-chip-with-icon-selected-icon-color:white}.mat-mdc-chip-focus-overlay{background:#000}.mat-mdc-chip{height:32px}.mat-mdc-slide-toggle{--mdc-switch-disabled-selected-handle-color:#424242;--mdc-switch-disabled-unselected-handle-color:#424242;--mdc-switch-disabled-selected-track-color:#424242;--mdc-switch-disabled-unselected-track-color:#424242;--mdc-switch-unselected-focus-state-layer-color:#424242;--mdc-switch-unselected-pressed-state-layer-color:#424242;--mdc-switch-unselected-hover-state-layer-color:#424242;--mdc-switch-unselected-focus-track-color:#e0e0e0;--mdc-switch-unselected-hover-track-color:#e0e0e0;--mdc-switch-unselected-pressed-track-color:#e0e0e0;--mdc-switch-unselected-track-color:#e0e0e0;--mdc-switch-unselected-focus-handle-color:#212121;--mdc-switch-unselected-hover-handle-color:#212121;--mdc-switch-unselected-pressed-handle-color:#212121;--mdc-switch-handle-surface-color:var(--mdc-theme-surface, #fff);--mdc-switch-unselected-handle-color:#616161;--mdc-switch-selected-icon-color:#fff;--mdc-switch-disabled-selected-icon-color:#fff;--mdc-switch-disabled-unselected-icon-color:#fff;--mdc-switch-unselected-icon-color:#fff}.mat-mdc-slide-toggle .mdc-form-field{color:var(--mdc-theme-text-primary-on-background, rgba(0, 0, 0, 0.87))}.mat-mdc-slide-toggle .mdc-switch--disabled+label{color:#757575}.mat-mdc-slide-toggle.mat-primary{--mdc-switch-selected-focus-state-layer-color:#fb8c00;--mdc-switch-selected-handle-color:#fb8c00;--mdc-switch-selected-hover-state-layer-color:#fb8c00;--mdc-switch-selected-pressed-state-layer-color:#fb8c00;--mdc-switch-selected-focus-handle-color:#e65100;--mdc-switch-selected-hover-handle-color:#e65100;--mdc-switch-selected-pressed-handle-color:#e65100;--mdc-switch-selected-focus-track-color:#ffb74d;--mdc-switch-selected-hover-track-color:#ffb74d;--mdc-switch-selected-pressed-track-color:#ffb74d;--mdc-switch-selected-track-color:#ffb74d}.mat-mdc-slide-toggle.mat-accent{--mdc-switch-selected-focus-state-layer-color:#fb8c00;--mdc-switch-selected-handle-color:#fb8c00;--mdc-switch-selected-hover-state-layer-color:#fb8c00;--mdc-switch-selected-pressed-state-layer-color:#fb8c00;--mdc-switch-selected-focus-handle-color:#e65100;--mdc-switch-selected-hover-handle-color:#e65100;--mdc-switch-selected-pressed-handle-color:#e65100;--mdc-switch-selected-focus-track-color:#ffb74d;--mdc-switch-selected-hover-track-color:#ffb74d;--mdc-switch-selected-pressed-track-color:#ffb74d;--mdc-switch-selected-track-color:#ffb74d}.mat-mdc-slide-toggle.mat-warn{--mdc-switch-selected-focus-state-layer-color:#e53935;--mdc-switch-selected-handle-color:#e53935;--mdc-switch-selected-hover-state-layer-color:#e53935;--mdc-switch-selected-pressed-state-layer-color:#e53935;--mdc-switch-selected-focus-handle-color:#b71c1c;--mdc-switch-selected-hover-handle-color:#b71c1c;--mdc-switch-selected-pressed-handle-color:#b71c1c;--mdc-switch-selected-focus-track-color:#e57373;--mdc-switch-selected-hover-track-color:#e57373;--mdc-switch-selected-pressed-track-color:#e57373;--mdc-switch-selected-track-color:#e57373}.mat-mdc-slide-toggle{--mdc-switch-state-layer-size:48px}.mat-mdc-radio-button .mdc-form-field{color:var(--mdc-theme-text-primary-on-background, rgba(0, 0, 0, 0.87))}.mat-mdc-radio-button.mat-primary{--mdc-radio-disabled-selected-icon-color:#000;--mdc-radio-disabled-unselected-icon-color:#000;--mdc-radio-unselected-focus-icon-color:#212121;--mdc-radio-unselected-hover-icon-color:#212121;--mdc-radio-unselected-icon-color:rgba(0, 0, 0, 0.54);--mdc-radio-unselected-pressed-icon-color:rgba(0, 0, 0, 0.54);--mdc-radio-selected-focus-icon-color:#f57c00;--mdc-radio-selected-hover-icon-color:#f57c00;--mdc-radio-selected-icon-color:#f57c00;--mdc-radio-selected-pressed-icon-color:#f57c00;--mat-mdc-radio-ripple-color: #000;--mat-mdc-radio-checked-ripple-color: #f57c00}.mat-mdc-radio-button.mat-primary .mdc-radio--disabled+label{color:#757575}.mat-mdc-radio-button.mat-accent{--mdc-radio-disabled-selected-icon-color:#000;--mdc-radio-disabled-unselected-icon-color:#000;--mdc-radio-unselected-focus-icon-color:#212121;--mdc-radio-unselected-hover-icon-color:#212121;--mdc-radio-unselected-icon-color:rgba(0, 0, 0, 0.54);--mdc-radio-unselected-pressed-icon-color:rgba(0, 0, 0, 0.54);--mdc-radio-selected-focus-icon-color:#ff9800;--mdc-radio-selected-hover-icon-color:#ff9800;--mdc-radio-selected-icon-color:#ff9800;--mdc-radio-selected-pressed-icon-color:#ff9800;--mat-mdc-radio-ripple-color: #000;--mat-mdc-radio-checked-ripple-color: #ff9800}.mat-mdc-radio-button.mat-accent .mdc-radio--disabled+label{color:#757575}.mat-mdc-radio-button.mat-warn{--mdc-radio-disabled-selected-icon-color:#000;--mdc-radio-disabled-unselected-icon-color:#000;--mdc-radio-unselected-focus-icon-color:#212121;--mdc-radio-unselected-hover-icon-color:#212121;--mdc-radio-unselected-icon-color:rgba(0, 0, 0, 0.54);--mdc-radio-unselected-pressed-icon-color:rgba(0, 0, 0, 0.54);--mdc-radio-selected-focus-icon-color:#f44336;--mdc-radio-selected-hover-icon-color:#f44336;--mdc-radio-selected-icon-color:#f44336;--mdc-radio-selected-pressed-icon-color:#f44336;--mat-mdc-radio-ripple-color: #000;--mat-mdc-radio-checked-ripple-color: #f44336}.mat-mdc-radio-button.mat-warn .mdc-radio--disabled+label{color:#757575}.mat-mdc-radio-button .mdc-radio{padding:calc((40px - 20px) / 2)}.mat-mdc-radio-button .mdc-radio .mdc-radio__background::before{top:calc(-1 * (40px - 20px) / 2);left:calc(-1 * (40px - 20px) / 2);width:40px;height:40px}.mat-mdc-radio-button .mdc-radio .mdc-radio__native-control{top:calc((40px - 40px) / 2);right:calc((40px - 40px) / 2);left:calc((40px - 40px) / 2);width:40px;height:40px}.mat-mdc-slider{--mdc-slider-label-container-color:black;--mdc-slider-label-label-text-color:white;--mdc-slider-disabled-handle-color:#000;--mdc-slider-disabled-active-track-color:#000;--mdc-slider-disabled-inactive-track-color:#000;--mdc-slider-with-tick-marks-disabled-container-color:#000;--mat-mdc-slider-value-indicator-opacity: 0.6}.mat-mdc-slider.mat-primary{--mdc-slider-handle-color:#f57c00;--mdc-slider-focus-handle-color:#f57c00;--mdc-slider-hover-handle-color:#f57c00;--mdc-slider-active-track-color:#f57c00;--mdc-slider-inactive-track-color:#f57c00;--mdc-slider-with-tick-marks-active-container-color:#000;--mdc-slider-with-tick-marks-inactive-container-color:#f57c00;--mat-mdc-slider-ripple-color: #f57c00;--mat-mdc-slider-hover-ripple-color: rgba(245, 124, 0, 0.05);--mat-mdc-slider-focus-ripple-color: rgba(245, 124, 0, 0.2)}.mat-mdc-slider.mat-accent{--mdc-slider-handle-color:#ff9800;--mdc-slider-focus-handle-color:#ff9800;--mdc-slider-hover-handle-color:#ff9800;--mdc-slider-active-track-color:#ff9800;--mdc-slider-inactive-track-color:#ff9800;--mdc-slider-with-tick-marks-active-container-color:#000;--mdc-slider-with-tick-marks-inactive-container-color:#ff9800;--mat-mdc-slider-ripple-color: #ff9800;--mat-mdc-slider-hover-ripple-color: rgba(255, 152, 0, 0.05);--mat-mdc-slider-focus-ripple-color: rgba(255, 152, 0, 0.2)}.mat-mdc-slider.mat-warn{--mdc-slider-handle-color:#f44336;--mdc-slider-focus-handle-color:#f44336;--mdc-slider-hover-handle-color:#f44336;--mdc-slider-active-track-color:#f44336;--mdc-slider-inactive-track-color:#f44336;--mdc-slider-with-tick-marks-active-container-color:#fff;--mdc-slider-with-tick-marks-inactive-container-color:#f44336;--mat-mdc-slider-ripple-color: #f44336;--mat-mdc-slider-hover-ripple-color: rgba(244, 67, 54, 0.05);--mat-mdc-slider-focus-ripple-color: rgba(244, 67, 54, 0.2)}.mdc-menu-surface{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2), 0px 8px 10px 1px rgba(0, 0, 0, 0.14), 0px 3px 14px 2px rgba(0, 0, 0, 0.12);background-color:var(--mdc-theme-surface, #fff);color:var(--mdc-theme-on-surface, #000)}.mdc-list-item__primary-text{color:var(--mdc-theme-text-primary-on-background, rgba(0, 0, 0, 0.87))}.mdc-list-item__secondary-text{color:var(--mdc-theme-text-secondary-on-background, rgba(0, 0, 0, 0.54))}.mdc-list-item__overline-text{color:var(--mdc-theme-text-hint-on-background, rgba(0, 0, 0, 0.38))}.mdc-list-item--with-leading-icon .mdc-list-item__start,.mdc-list-item--with-trailing-icon .mdc-list-item__end{background-color:transparent}.mdc-list-item--with-leading-icon .mdc-list-item__start,.mdc-list-item--with-trailing-icon .mdc-list-item__end{color:var(--mdc-theme-text-icon-on-background, rgba(0, 0, 0, 0.38))}.mdc-list-item__end{color:var(--mdc-theme-text-hint-on-background, rgba(0, 0, 0, 0.38))}.mdc-list-item--disabled .mdc-list-item__start,.mdc-list-item--disabled .mdc-list-item__content,.mdc-list-item--disabled .mdc-list-item__end{opacity:0.38}.mdc-list-item--disabled .mdc-list-item__primary-text{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled .mdc-list-item__secondary-text{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled .mdc-list-item__overline-text{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled.mdc-list-item--with-leading-icon .mdc-list-item__start{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled.mdc-list-item--with-trailing-icon .mdc-list-item__end{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled.mdc-list-item--with-trailing-meta .mdc-list-item__end{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--selected .mdc-list-item__primary-text,.mdc-list-item--activated .mdc-list-item__primary-text{color:var(--mdc-theme-primary, #f57c00)}.mdc-list-item--selected.mdc-list-item--with-leading-icon .mdc-list-item__start,.mdc-list-item--activated.mdc-list-item--with-leading-icon .mdc-list-item__start{color:var(--mdc-theme-primary, #f57c00)}.mdc-deprecated-list-group__subheader{color:var(--mdc-theme-text-primary-on-background, rgba(0, 0, 0, 0.87))}.mdc-list-divider::after{border-bottom-color:white}.mdc-list-divider{background-color:rgba(0, 0, 0, 0.12)}.mat-mdc-menu-item[disabled],.mat-mdc-menu-item[disabled] .mat-mdc-menu-submenu-icon,.mat-mdc-menu-item[disabled] .mat-icon-no-color{color:var(--mdc-theme-text-disabled-on-background, rgba(0, 0, 0, 0.38))}.mat-mdc-menu-item .mat-icon-no-color,.mat-mdc-menu-submenu-icon{color:var(--mdc-theme-text-primary-on-background, rgba(0, 0, 0, 0.87))}.mat-mdc-menu-item:hover:not([disabled]),.mat-mdc-menu-item.cdk-program-focused:not([disabled]),.mat-mdc-menu-item.cdk-keyboard-focused:not([disabled]),.mat-mdc-menu-item-highlighted:not([disabled]){background:rgba(0,0,0,.04)}.mat-mdc-list-base{--mdc-list-list-item-label-text-color:#212121;--mdc-list-list-item-supporting-text-color:#616161;--mdc-list-list-item-leading-icon-color:rgba(0, 0, 0, 0.38);--mdc-list-list-item-trailing-supporting-text-color:rgba(0, 0, 0, 0.38);--mdc-list-list-item-trailing-icon-color:rgba(0, 0, 0, 0.38);--mdc-list-list-item-selected-trailing-icon-color:rgba(0, 0, 0, 0.38);--mdc-list-list-item-disabled-label-text-color:black;--mdc-list-list-item-disabled-leading-icon-color:black;--mdc-list-list-item-disabled-trailing-icon-color:black;--mdc-list-list-item-hover-label-text-color:#212121;--mdc-list-list-item-hover-leading-icon-color:rgba(0, 0, 0, 0.38);--mdc-list-list-item-hover-trailing-icon-color:rgba(0, 0, 0, 0.38);--mdc-list-list-item-focus-label-text-color:#212121;--mdc-list-list-item-hover-state-layer-color:black;--mdc-list-list-item-hover-state-layer-opacity:0.04;--mdc-list-list-item-focus-state-layer-color:black;--mdc-list-list-item-focus-state-layer-opacity:0.12}.mat-mdc-list-option .mdc-list-item__start,.mat-mdc-list-option .mdc-list-item__end{--mdc-checkbox-selected-checkmark-color:#000;--mdc-checkbox-selected-focus-icon-color:#f57c00;--mdc-checkbox-selected-hover-icon-color:#f57c00;--mdc-checkbox-selected-icon-color:#f57c00;--mdc-checkbox-selected-pressed-icon-color:#f57c00;--mdc-checkbox-unselected-focus-icon-color:#212121;--mdc-checkbox-unselected-hover-icon-color:#212121;--mdc-checkbox-disabled-selected-icon-color:rgba(0, 0, 0, 0.38);--mdc-checkbox-disabled-unselected-icon-color:rgba(0, 0, 0, 0.38);--mdc-checkbox-unselected-icon-color:rgba(0, 0, 0, 0.54);--mdc-checkbox-unselected-pressed-icon-color:rgba(0, 0, 0, 0.54)}.mat-mdc-list-option .mdc-list-item__start,.mat-mdc-list-option .mdc-list-item__end{--mdc-radio-disabled-selected-icon-color:#000;--mdc-radio-disabled-unselected-icon-color:#000;--mdc-radio-unselected-focus-icon-color:#212121;--mdc-radio-unselected-hover-icon-color:#212121;--mdc-radio-unselected-icon-color:rgba(0, 0, 0, 0.54);--mdc-radio-unselected-pressed-icon-color:rgba(0, 0, 0, 0.54);--mdc-radio-selected-focus-icon-color:#f57c00;--mdc-radio-selected-hover-icon-color:#f57c00;--mdc-radio-selected-icon-color:#f57c00;--mdc-radio-selected-pressed-icon-color:#f57c00;--mat-mdc-radio-ripple-color: #000;--mat-mdc-radio-checked-ripple-color: #f57c00}.mat-mdc-list-option .mdc-list-item__start .mdc-radio--disabled+label,.mat-mdc-list-option .mdc-list-item__end .mdc-radio--disabled+label{color:#757575}.mat-mdc-list-option.mat-accent .mdc-list-item__start,.mat-mdc-list-option.mat-accent .mdc-list-item__end{--mdc-checkbox-selected-checkmark-color:#000;--mdc-checkbox-selected-focus-icon-color:#ff9800;--mdc-checkbox-selected-hover-icon-color:#ff9800;--mdc-checkbox-selected-icon-color:#ff9800;--mdc-checkbox-selected-pressed-icon-color:#ff9800;--mdc-checkbox-unselected-focus-icon-color:#212121;--mdc-checkbox-unselected-hover-icon-color:#212121;--mdc-checkbox-disabled-selected-icon-color:rgba(0, 0, 0, 0.38);--mdc-checkbox-disabled-unselected-icon-color:rgba(0, 0, 0, 0.38);--mdc-checkbox-unselected-icon-color:rgba(0, 0, 0, 0.54);--mdc-checkbox-unselected-pressed-icon-color:rgba(0, 0, 0, 0.54)}.mat-mdc-list-option.mat-accent .mdc-list-item__start,.mat-mdc-list-option.mat-accent .mdc-list-item__end{--mdc-radio-disabled-selected-icon-color:#000;--mdc-radio-disabled-unselected-icon-color:#000;--mdc-radio-unselected-focus-icon-color:#212121;--mdc-radio-unselected-hover-icon-color:#212121;--mdc-radio-unselected-icon-color:rgba(0, 0, 0, 0.54);--mdc-radio-unselected-pressed-icon-color:rgba(0, 0, 0, 0.54);--mdc-radio-selected-focus-icon-color:#ff9800;--mdc-radio-selected-hover-icon-color:#ff9800;--mdc-radio-selected-icon-color:#ff9800;--mdc-radio-selected-pressed-icon-color:#ff9800;--mat-mdc-radio-ripple-color: #000;--mat-mdc-radio-checked-ripple-color: #ff9800}.mat-mdc-list-option.mat-accent .mdc-list-item__start .mdc-radio--disabled+label,.mat-mdc-list-option.mat-accent .mdc-list-item__end .mdc-radio--disabled+label{color:#757575}.mat-mdc-list-option.mat-warn .mdc-list-item__start,.mat-mdc-list-option.mat-warn .mdc-list-item__end{--mdc-checkbox-selected-checkmark-color:#fff;--mdc-checkbox-selected-focus-icon-color:#f44336;--mdc-checkbox-selected-hover-icon-color:#f44336;--mdc-checkbox-selected-icon-color:#f44336;--mdc-checkbox-selected-pressed-icon-color:#f44336;--mdc-checkbox-unselected-focus-icon-color:#212121;--mdc-checkbox-unselected-hover-icon-color:#212121;--mdc-checkbox-disabled-selected-icon-color:rgba(0, 0, 0, 0.38);--mdc-checkbox-disabled-unselected-icon-color:rgba(0, 0, 0, 0.38);--mdc-checkbox-unselected-icon-color:rgba(0, 0, 0, 0.54);--mdc-checkbox-unselected-pressed-icon-color:rgba(0, 0, 0, 0.54)}.mat-mdc-list-option.mat-warn .mdc-list-item__start,.mat-mdc-list-option.mat-warn .mdc-list-item__end{--mdc-radio-disabled-selected-icon-color:#000;--mdc-radio-disabled-unselected-icon-color:#000;--mdc-radio-unselected-focus-icon-color:#212121;--mdc-radio-unselected-hover-icon-color:#212121;--mdc-radio-unselected-icon-color:rgba(0, 0, 0, 0.54);--mdc-radio-unselected-pressed-icon-color:rgba(0, 0, 0, 0.54);--mdc-radio-selected-focus-icon-color:#f44336;--mdc-radio-selected-hover-icon-color:#f44336;--mdc-radio-selected-icon-color:#f44336;--mdc-radio-selected-pressed-icon-color:#f44336;--mat-mdc-radio-ripple-color: #000;--mat-mdc-radio-checked-ripple-color: #f44336}.mat-mdc-list-option.mat-warn .mdc-list-item__start .mdc-radio--disabled+label,.mat-mdc-list-option.mat-warn .mdc-list-item__end .mdc-radio--disabled+label{color:#757575}.mat-mdc-list-base.mat-mdc-list-base .mdc-list-item--selected .mdc-list-item__primary-text,.mat-mdc-list-base.mat-mdc-list-base .mdc-list-item--activated .mdc-list-item__primary-text{color:#f57c00}.mat-mdc-list-base.mat-mdc-list-base .mdc-list-item--selected.mdc-list-item--with-leading-icon .mdc-list-item__start,.mat-mdc-list-base.mat-mdc-list-base .mdc-list-item--activated.mdc-list-item--with-leading-icon .mdc-list-item__start{color:#f57c00}.mat-mdc-list-base .mdc-list-item--disabled .mdc-list-item__start,.mat-mdc-list-base .mdc-list-item--disabled .mdc-list-item__content,.mat-mdc-list-base .mdc-list-item--disabled .mdc-list-item__end{opacity:1}.mat-mdc-list-base{--mdc-list-list-item-one-line-container-height:48px;--mdc-list-list-item-two-line-container-height:64px;--mdc-list-list-item-three-line-container-height:88px}.mat-mdc-list-item.mdc-list-item--with-leading-avatar.mdc-list-item--with-one-line,.mat-mdc-list-item.mdc-list-item--with-leading-checkbox.mdc-list-item--with-one-line,.mat-mdc-list-item.mdc-list-item--with-leading-icon.mdc-list-item--with-one-line{height:56px}.mat-mdc-list-item.mdc-list-item--with-leading-avatar.mdc-list-item--with-two-lines,.mat-mdc-list-item.mdc-list-item--with-leading-checkbox.mdc-list-item--with-two-lines,.mat-mdc-list-item.mdc-list-item--with-leading-icon.mdc-list-item--with-two-lines{height:72px}.mat-mdc-paginator{background:#fff;color:rgba(0,0,0,.87)}.mat-mdc-paginator-icon{fill:rgba(0,0,0,.54)}.mat-mdc-paginator-decrement,.mat-mdc-paginator-increment{border-top:2px solid rgba(0,0,0,.54);border-right:2px solid rgba(0,0,0,.54)}.mat-mdc-paginator-first,.mat-mdc-paginator-last{border-top:2px solid rgba(0,0,0,.54)}.mat-mdc-icon-button[disabled] .mat-mdc-paginator-decrement,.mat-mdc-icon-button[disabled] .mat-mdc-paginator-increment,.mat-mdc-icon-button[disabled] .mat-mdc-paginator-first,.mat-mdc-icon-button[disabled] .mat-mdc-paginator-last{border-color:rgba(0,0,0,.12)}.mat-mdc-icon-button[disabled] .mat-mdc-paginator-icon{fill:rgba(0,0,0,.12)}.mat-mdc-paginator .mat-mdc-form-field-infix{min-height:40px}.mat-mdc-paginator .mat-mdc-text-field-wrapper .mat-mdc-form-field-flex .mat-mdc-floating-label{top:20px}.mat-mdc-paginator .mat-mdc-text-field-wrapper.mdc-text-field--outlined .mdc-notched-outline--upgraded .mdc-floating-label--float-above{--mat-mdc-form-field-label-transform: translateY( -26.75px) scale(var(--mat-mdc-form-field-floating-label-scale, 0.75));transform:var(--mat-mdc-form-field-label-transform)}.mat-mdc-paginator .mat-mdc-text-field-wrapper.mdc-text-field--outlined .mat-mdc-form-field-infix{padding-top:8px;padding-bottom:8px}.mat-mdc-paginator .mat-mdc-text-field-wrapper:not(.mdc-text-field--outlined) .mat-mdc-form-field-infix{padding-top:8px;padding-bottom:8px}.mat-mdc-paginator .mdc-text-field--no-label:not(.mdc-text-field--outlined):not(.mdc-text-field--textarea) .mat-mdc-form-field-infix{padding-top:8px;padding-bottom:8px}.mat-mdc-paginator .mat-mdc-text-field-wrapper:not(.mdc-text-field--outlined) .mat-mdc-floating-label{display:none}.mat-mdc-paginator-container{min-height:56px}.mat-mdc-tab,.mat-mdc-tab-link{background-color:rgba(0,0,0,0)}.mat-mdc-tab .mdc-tab__text-label,.mat-mdc-tab-link .mdc-tab__text-label{color:rgba(0, 0, 0, 0.6)}.mat-mdc-tab.mat-mdc-tab-disabled .mdc-tab__ripple::before,.mat-mdc-tab.mat-mdc-tab-disabled .mat-ripple-element,.mat-mdc-tab-link.mat-mdc-tab-disabled .mdc-tab__ripple::before,.mat-mdc-tab-link.mat-mdc-tab-disabled .mat-ripple-element{background-color:rgba(0,0,0,.38)}.mat-mdc-tab:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label,.mat-mdc-tab-link:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label{color:#f57c00}.mat-mdc-tab:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline,.mat-mdc-tab-link:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline{border-color:var(--mdc-tab-indicator-active-indicator-color, #f57c00)}.mdc-tab__ripple::before,.mat-mdc-tab .mat-ripple-element,.mat-mdc-tab-header-pagination .mat-ripple-element,.mat-mdc-tab-link .mat-ripple-element{background-color:#f57c00}.mat-mdc-tab-group.mat-accent .mat-mdc-tab:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label,.mat-mdc-tab-group.mat-accent .mat-mdc-tab-link:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label,.mat-mdc-tab-nav-bar.mat-accent .mat-mdc-tab:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label,.mat-mdc-tab-nav-bar.mat-accent .mat-mdc-tab-link:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label{color:#ff9800}.mat-mdc-tab-group.mat-accent .mat-mdc-tab:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline,.mat-mdc-tab-group.mat-accent .mat-mdc-tab-link:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline,.mat-mdc-tab-nav-bar.mat-accent .mat-mdc-tab:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline,.mat-mdc-tab-nav-bar.mat-accent .mat-mdc-tab-link:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline{border-color:var(--mdc-tab-indicator-active-indicator-color, #ff9800)}.mat-mdc-tab-group.mat-accent .mdc-tab__ripple::before,.mat-mdc-tab-group.mat-accent .mat-mdc-tab .mat-ripple-element,.mat-mdc-tab-group.mat-accent .mat-mdc-tab-header-pagination .mat-ripple-element,.mat-mdc-tab-group.mat-accent .mat-mdc-tab-link .mat-ripple-element,.mat-mdc-tab-nav-bar.mat-accent .mdc-tab__ripple::before,.mat-mdc-tab-nav-bar.mat-accent .mat-mdc-tab .mat-ripple-element,.mat-mdc-tab-nav-bar.mat-accent .mat-mdc-tab-header-pagination .mat-ripple-element,.mat-mdc-tab-nav-bar.mat-accent .mat-mdc-tab-link .mat-ripple-element{background-color:#ff9800}.mat-mdc-tab-group.mat-warn .mat-mdc-tab:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label,.mat-mdc-tab-group.mat-warn .mat-mdc-tab-link:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label,.mat-mdc-tab-nav-bar.mat-warn .mat-mdc-tab:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label,.mat-mdc-tab-nav-bar.mat-warn .mat-mdc-tab-link:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label{color:#f44336}.mat-mdc-tab-group.mat-warn .mat-mdc-tab:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline,.mat-mdc-tab-group.mat-warn .mat-mdc-tab-link:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline,.mat-mdc-tab-nav-bar.mat-warn .mat-mdc-tab:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline,.mat-mdc-tab-nav-bar.mat-warn .mat-mdc-tab-link:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline{border-color:var(--mdc-tab-indicator-active-indicator-color, #f44336)}.mat-mdc-tab-group.mat-warn .mdc-tab__ripple::before,.mat-mdc-tab-group.mat-warn .mat-mdc-tab .mat-ripple-element,.mat-mdc-tab-group.mat-warn .mat-mdc-tab-header-pagination .mat-ripple-element,.mat-mdc-tab-group.mat-warn .mat-mdc-tab-link .mat-ripple-element,.mat-mdc-tab-nav-bar.mat-warn .mdc-tab__ripple::before,.mat-mdc-tab-nav-bar.mat-warn .mat-mdc-tab .mat-ripple-element,.mat-mdc-tab-nav-bar.mat-warn .mat-mdc-tab-header-pagination .mat-ripple-element,.mat-mdc-tab-nav-bar.mat-warn .mat-mdc-tab-link .mat-ripple-element{background-color:#f44336}.mat-mdc-tab-group.mat-background-primary,.mat-mdc-tab-nav-bar.mat-background-primary{--mat-mdc-tab-header-with-background-background-color: #f57c00;--mat-mdc-tab-header-with-background-foreground-color: #000}.mat-mdc-tab-group.mat-background-accent,.mat-mdc-tab-nav-bar.mat-background-accent{--mat-mdc-tab-header-with-background-background-color: #ff9800;--mat-mdc-tab-header-with-background-foreground-color: #000}.mat-mdc-tab-group.mat-background-warn,.mat-mdc-tab-nav-bar.mat-background-warn{--mat-mdc-tab-header-with-background-background-color: #f44336;--mat-mdc-tab-header-with-background-foreground-color: #fff}.mat-mdc-tab-header-pagination-chevron{border-color:var(--mdc-theme-on-surface, #000)}.mat-mdc-tab-header .mdc-tab{height:48px}.mat-mdc-checkbox .mdc-form-field{color:var(--mdc-theme-text-primary-on-background, rgba(0, 0, 0, 0.87))}.mat-mdc-checkbox .mat-ripple-element{background-color:rgba(0,0,0,.1)}.mat-mdc-checkbox .mdc-checkbox__ripple{background:#000}.mat-mdc-checkbox.mat-primary{--mdc-checkbox-selected-checkmark-color:#000;--mdc-checkbox-selected-focus-icon-color:#f57c00;--mdc-checkbox-selected-hover-icon-color:#f57c00;--mdc-checkbox-selected-icon-color:#f57c00;--mdc-checkbox-selected-pressed-icon-color:#f57c00;--mdc-checkbox-unselected-focus-icon-color:#212121;--mdc-checkbox-unselected-hover-icon-color:#212121;--mdc-checkbox-disabled-selected-icon-color:rgba(0, 0, 0, 0.38);--mdc-checkbox-disabled-unselected-icon-color:rgba(0, 0, 0, 0.38);--mdc-checkbox-unselected-icon-color:rgba(0, 0, 0, 0.54);--mdc-checkbox-unselected-pressed-icon-color:rgba(0, 0, 0, 0.54)}.mat-mdc-checkbox.mat-primary .mdc-checkbox--selected~.mat-mdc-checkbox-ripple .mat-ripple-element{background-color:rgba(245,124,0,.1)}.mat-mdc-checkbox.mat-primary .mdc-checkbox--selected~.mdc-checkbox__ripple{background:#f57c00}.mat-mdc-checkbox.mat-accent{--mdc-checkbox-selected-checkmark-color:#000;--mdc-checkbox-selected-focus-icon-color:#ff9800;--mdc-checkbox-selected-hover-icon-color:#ff9800;--mdc-checkbox-selected-icon-color:#ff9800;--mdc-checkbox-selected-pressed-icon-color:#ff9800;--mdc-checkbox-unselected-focus-icon-color:#212121;--mdc-checkbox-unselected-hover-icon-color:#212121;--mdc-checkbox-disabled-selected-icon-color:rgba(0, 0, 0, 0.38);--mdc-checkbox-disabled-unselected-icon-color:rgba(0, 0, 0, 0.38);--mdc-checkbox-unselected-icon-color:rgba(0, 0, 0, 0.54);--mdc-checkbox-unselected-pressed-icon-color:rgba(0, 0, 0, 0.54)}.mat-mdc-checkbox.mat-accent .mdc-checkbox--selected~.mat-mdc-checkbox-ripple .mat-ripple-element{background-color:rgba(255,152,0,.1)}.mat-mdc-checkbox.mat-accent .mdc-checkbox--selected~.mdc-checkbox__ripple{background:#ff9800}.mat-mdc-checkbox.mat-warn{--mdc-checkbox-selected-checkmark-color:#fff;--mdc-checkbox-selected-focus-icon-color:#f44336;--mdc-checkbox-selected-hover-icon-color:#f44336;--mdc-checkbox-selected-icon-color:#f44336;--mdc-checkbox-selected-pressed-icon-color:#f44336;--mdc-checkbox-unselected-focus-icon-color:#212121;--mdc-checkbox-unselected-hover-icon-color:#212121;--mdc-checkbox-disabled-selected-icon-color:rgba(0, 0, 0, 0.38);--mdc-checkbox-disabled-unselected-icon-color:rgba(0, 0, 0, 0.38);--mdc-checkbox-unselected-icon-color:rgba(0, 0, 0, 0.54);--mdc-checkbox-unselected-pressed-icon-color:rgba(0, 0, 0, 0.54)}.mat-mdc-checkbox.mat-warn .mdc-checkbox--selected~.mat-mdc-checkbox-ripple .mat-ripple-element{background-color:rgba(244,67,54,.1)}.mat-mdc-checkbox.mat-warn .mdc-checkbox--selected~.mdc-checkbox__ripple{background:#f44336}.mat-mdc-checkbox-disabled label{color:#757575}.mat-mdc-checkbox .mdc-checkbox{padding:calc((var(--mdc-checkbox-ripple-size, 40px) - 18px) / 2);margin:calc((var(--mdc-checkbox-touch-target-size, 40px) - 40px) / 2)}.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__background{top:calc((var(--mdc-checkbox-ripple-size, 40px) - 18px) / 2);left:calc((var(--mdc-checkbox-ripple-size, 40px) - 18px) / 2)}.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__native-control{top:calc((40px - var(--mdc-checkbox-touch-target-size, 40px)) / 2);right:calc((40px - var(--mdc-checkbox-touch-target-size, 40px)) / 2);left:calc((40px - var(--mdc-checkbox-touch-target-size, 40px)) / 2);width:var(--mdc-checkbox-touch-target-size, 40px);height:var(--mdc-checkbox-touch-target-size, 40px)}.mat-mdc-button.mat-unthemed{--mdc-text-button-label-text-color:#000}.mat-mdc-button.mat-primary{--mdc-text-button-label-text-color:#f57c00}.mat-mdc-button.mat-accent{--mdc-text-button-label-text-color:#ff9800}.mat-mdc-button.mat-warn{--mdc-text-button-label-text-color:#f44336}.mat-mdc-button[disabled][disabled]{--mdc-text-button-disabled-label-text-color:rgba(0, 0, 0, 0.38);--mdc-text-button-label-text-color:rgba(0, 0, 0, 0.38)}.mat-mdc-unelevated-button.mat-unthemed{--mdc-filled-button-container-color:#fff;--mdc-filled-button-label-text-color:#000}.mat-mdc-unelevated-button.mat-primary{--mdc-filled-button-container-color:#f57c00;--mdc-filled-button-label-text-color:#000}.mat-mdc-unelevated-button.mat-accent{--mdc-filled-button-container-color:#ff9800;--mdc-filled-button-label-text-color:#000}.mat-mdc-unelevated-button.mat-warn{--mdc-filled-button-container-color:#f44336;--mdc-filled-button-label-text-color:#fff}.mat-mdc-unelevated-button[disabled][disabled]{--mdc-filled-button-disabled-container-color:rgba(0, 0, 0, 0.12);--mdc-filled-button-disabled-label-text-color:rgba(0, 0, 0, 0.38);--mdc-filled-button-container-color:rgba(0, 0, 0, 0.12);--mdc-filled-button-label-text-color:rgba(0, 0, 0, 0.38)}.mat-mdc-raised-button.mat-unthemed{--mdc-protected-button-container-color:#fff;--mdc-protected-button-label-text-color:#000}.mat-mdc-raised-button.mat-primary{--mdc-protected-button-container-color:#f57c00;--mdc-protected-button-label-text-color:#000}.mat-mdc-raised-button.mat-accent{--mdc-protected-button-container-color:#ff9800;--mdc-protected-button-label-text-color:#000}.mat-mdc-raised-button.mat-warn{--mdc-protected-button-container-color:#f44336;--mdc-protected-button-label-text-color:#fff}.mat-mdc-raised-button[disabled][disabled]{--mdc-protected-button-disabled-container-color:rgba(0, 0, 0, 0.12);--mdc-protected-button-disabled-label-text-color:rgba(0, 0, 0, 0.38);--mdc-protected-button-container-color:rgba(0, 0, 0, 0.12);--mdc-protected-button-label-text-color:rgba(0, 0, 0, 0.38);--mdc-protected-button-container-elevation:0}.mat-mdc-outlined-button{--mdc-outlined-button-outline-color:rgba(0, 0, 0, 0.12)}.mat-mdc-outlined-button.mat-unthemed{--mdc-outlined-button-label-text-color:#000}.mat-mdc-outlined-button.mat-primary{--mdc-outlined-button-label-text-color:#f57c00}.mat-mdc-outlined-button.mat-accent{--mdc-outlined-button-label-text-color:#ff9800}.mat-mdc-outlined-button.mat-warn{--mdc-outlined-button-label-text-color:#f44336}.mat-mdc-outlined-button[disabled][disabled]{--mdc-outlined-button-label-text-color:rgba(0, 0, 0, 0.38);--mdc-outlined-button-disabled-label-text-color:rgba(0, 0, 0, 0.38);--mdc-outlined-button-outline-color:rgba(0, 0, 0, 0.12);--mdc-outlined-button-disabled-outline-color:rgba(0, 0, 0, 0.12)}.mat-mdc-button,.mat-mdc-outlined-button{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}.mat-mdc-button:hover .mat-mdc-button-persistent-ripple::before,.mat-mdc-outlined-button:hover .mat-mdc-button-persistent-ripple::before{opacity:.04}.mat-mdc-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,.mat-mdc-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before,.mat-mdc-outlined-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,.mat-mdc-outlined-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before{opacity:.12}.mat-mdc-button:active .mat-mdc-button-persistent-ripple::before,.mat-mdc-outlined-button:active .mat-mdc-button-persistent-ripple::before{opacity:.12}.mat-mdc-button.mat-primary,.mat-mdc-outlined-button.mat-primary{--mat-mdc-button-persistent-ripple-color: #f57c00;--mat-mdc-button-ripple-color: rgba(245, 124, 0, 0.1)}.mat-mdc-button.mat-accent,.mat-mdc-outlined-button.mat-accent{--mat-mdc-button-persistent-ripple-color: #ff9800;--mat-mdc-button-ripple-color: rgba(255, 152, 0, 0.1)}.mat-mdc-button.mat-warn,.mat-mdc-outlined-button.mat-warn{--mat-mdc-button-persistent-ripple-color: #f44336;--mat-mdc-button-ripple-color: rgba(244, 67, 54, 0.1)}.mat-mdc-raised-button,.mat-mdc-unelevated-button{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}.mat-mdc-raised-button:hover .mat-mdc-button-persistent-ripple::before,.mat-mdc-unelevated-button:hover .mat-mdc-button-persistent-ripple::before{opacity:.04}.mat-mdc-raised-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,.mat-mdc-raised-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before,.mat-mdc-unelevated-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,.mat-mdc-unelevated-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before{opacity:.12}.mat-mdc-raised-button:active .mat-mdc-button-persistent-ripple::before,.mat-mdc-unelevated-button:active .mat-mdc-button-persistent-ripple::before{opacity:.12}.mat-mdc-raised-button.mat-primary,.mat-mdc-unelevated-button.mat-primary{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}.mat-mdc-raised-button.mat-accent,.mat-mdc-unelevated-button.mat-accent{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}.mat-mdc-raised-button.mat-warn,.mat-mdc-unelevated-button.mat-warn{--mat-mdc-button-persistent-ripple-color: #fff;--mat-mdc-button-ripple-color: rgba(255, 255, 255, 0.1)}.mat-mdc-button.mat-mdc-button-base,.mat-mdc-raised-button.mat-mdc-button-base,.mat-mdc-unelevated-button.mat-mdc-button-base,.mat-mdc-outlined-button.mat-mdc-button-base{height:36px}.mat-mdc-icon-button{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}.mat-mdc-icon-button:hover .mat-mdc-button-persistent-ripple::before{opacity:.04}.mat-mdc-icon-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,.mat-mdc-icon-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before{opacity:.12}.mat-mdc-icon-button:active .mat-mdc-button-persistent-ripple::before{opacity:.12}.mat-mdc-icon-button.mat-primary{--mat-mdc-button-persistent-ripple-color: #f57c00;--mat-mdc-button-ripple-color: rgba(245, 124, 0, 0.1)}.mat-mdc-icon-button.mat-accent{--mat-mdc-button-persistent-ripple-color: #ff9800;--mat-mdc-button-ripple-color: rgba(255, 152, 0, 0.1)}.mat-mdc-icon-button.mat-warn{--mat-mdc-button-persistent-ripple-color: #f44336;--mat-mdc-button-ripple-color: rgba(244, 67, 54, 0.1)}.mat-mdc-icon-button.mat-primary{--mdc-icon-button-icon-color:#f57c00}.mat-mdc-icon-button.mat-accent{--mdc-icon-button-icon-color:#ff9800}.mat-mdc-icon-button.mat-warn{--mdc-icon-button-icon-color:#f44336}.mat-mdc-icon-button[disabled][disabled]{--mdc-icon-button-icon-color:rgba(0, 0, 0, 0.38);--mdc-icon-button-disabled-icon-color:rgba(0, 0, 0, 0.38)}.mat-mdc-icon-button.mat-mdc-button-base{width:48px;height:48px;padding:12px}.mat-mdc-icon-button.mat-mdc-button-base .mdc-icon-button__focus-ring{max-height:48px;max-width:48px}.mat-mdc-icon-button.mat-mdc-button-base.mdc-icon-button--reduced-size .mdc-icon-button__ripple{width:40px;height:40px;margin-top:4px;margin-bottom:4px;margin-right:4px;margin-left:4px}.mat-mdc-icon-button.mat-mdc-button-base.mdc-icon-button--reduced-size .mdc-icon-button__focus-ring{max-height:40px;max-width:40px}.mat-mdc-icon-button.mat-mdc-button-base .mdc-icon-button__touch{position:absolute;top:50%;height:48px;left:50%;width:48px;transform:translate(-50%, -50%)}.mat-mdc-fab,.mat-mdc-mini-fab{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}.mat-mdc-fab:hover .mat-mdc-button-persistent-ripple::before,.mat-mdc-mini-fab:hover .mat-mdc-button-persistent-ripple::before{opacity:.04}.mat-mdc-fab.cdk-program-focused .mat-mdc-button-persistent-ripple::before,.mat-mdc-fab.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before,.mat-mdc-mini-fab.cdk-program-focused .mat-mdc-button-persistent-ripple::before,.mat-mdc-mini-fab.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before{opacity:.12}.mat-mdc-fab:active .mat-mdc-button-persistent-ripple::before,.mat-mdc-mini-fab:active .mat-mdc-button-persistent-ripple::before{opacity:.12}.mat-mdc-fab.mat-primary,.mat-mdc-mini-fab.mat-primary{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}.mat-mdc-fab.mat-accent,.mat-mdc-mini-fab.mat-accent{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}.mat-mdc-fab.mat-warn,.mat-mdc-mini-fab.mat-warn{--mat-mdc-button-persistent-ripple-color: #fff;--mat-mdc-button-ripple-color: rgba(255, 255, 255, 0.1)}.mat-mdc-fab.mat-unthemed,.mat-mdc-mini-fab.mat-unthemed{--mdc-fab-container-color:#fff;--mdc-fab-icon-color:#000;--mat-mdc-fab-color: #000}.mat-mdc-fab.mat-primary,.mat-mdc-mini-fab.mat-primary{--mdc-fab-container-color:#f57c00;--mdc-fab-icon-color:#000;--mat-mdc-fab-color: #000}.mat-mdc-fab.mat-accent,.mat-mdc-mini-fab.mat-accent{--mdc-fab-container-color:#ff9800;--mdc-fab-icon-color:#000;--mat-mdc-fab-color: #000}.mat-mdc-fab.mat-warn,.mat-mdc-mini-fab.mat-warn{--mdc-fab-container-color:#f44336;--mdc-fab-icon-color:#fff;--mat-mdc-fab-color: #fff}.mat-mdc-fab[disabled][disabled],.mat-mdc-mini-fab[disabled][disabled]{--mdc-fab-container-color:rgba(0, 0, 0, 0.12);--mdc-fab-icon-color:rgba(0, 0, 0, 0.38);--mat-mdc-fab-color: rgba(0, 0, 0, 0.38)}.mat-mdc-snack-bar-container{--mat-mdc-snack-bar-button-color: #ff9800;--mdc-snackbar-container-color:#333333;--mdc-snackbar-supporting-text-color:rgba(255, 255, 255, 0.87)}.mdc-data-table{background-color:var(--mdc-theme-surface, #fff);border-color:rgba(0, 0, 0, 0.12)}.mdc-data-table__row{background-color:inherit}.mdc-data-table__header-cell{background-color:var(--mdc-theme-surface, #fff)}.mdc-data-table__row--selected{background-color:rgba(245, 124, 0, 0.04)}.mdc-data-table__pagination-rows-per-page-select--outlined:not(.mdc-select--disabled) .mdc-notched-outline__leading,.mdc-data-table__pagination-rows-per-page-select--outlined:not(.mdc-select--disabled) .mdc-notched-outline__notch,.mdc-data-table__pagination-rows-per-page-select--outlined:not(.mdc-select--disabled) .mdc-notched-outline__trailing{border-color:rgba(0, 0, 0, 0.12)}.mdc-data-table__cell,.mdc-data-table__header-cell{border-bottom-color:rgba(0, 0, 0, 0.12)}.mdc-data-table__pagination{border-top-color:rgba(0, 0, 0, 0.12)}.mdc-data-table__row:not(.mdc-data-table__row--selected):hover{background-color:rgba(0, 0, 0, 0.04)}.mdc-data-table__header-cell{color:rgba(0, 0, 0, 0.87)}.mdc-data-table__pagination-total,.mdc-data-table__pagination-rows-per-page-label,.mdc-data-table__cell{color:rgba(0, 0, 0, 0.87)}.mat-mdc-table{background:#fff}.mat-mdc-table .mdc-data-table__row{height:52px}.mat-mdc-table .mdc-data-table__pagination{min-height:52px}.mat-mdc-table .mdc-data-table__header-row{height:56px}.mat-mdc-progress-spinner{--mdc-circular-progress-active-indicator-color:#f57c00}.mat-mdc-progress-spinner.mat-accent{--mdc-circular-progress-active-indicator-color:#ff9800}.mat-mdc-progress-spinner.mat-warn{--mdc-circular-progress-active-indicator-color:#f44336}.mat-badge-content{color:#fff;background:#f57c00}.cdk-high-contrast-active .mat-badge-content{outline:solid 1px;border-radius:0}.mat-badge-accent .mat-badge-content{background:#ff9800;color:#fff}.mat-badge-warn .mat-badge-content{color:#fff;background:#f44336}.mat-badge-disabled .mat-badge-content{background:#bdbdbd;color:#757575}.mat-bottom-sheet-container{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2), 0px 16px 24px 2px rgba(0, 0, 0, 0.14), 0px 6px 30px 5px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-button-toggle-standalone:not([class*=mat-elevation-z]),.mat-button-toggle-group:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2), 0px 2px 2px 0px rgba(0, 0, 0, 0.14), 0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard:not([class*=mat-elevation-z]),.mat-button-toggle-group-appearance-standard:not([class*=mat-elevation-z]){box-shadow:none}.mat-button-toggle{color:rgba(0,0,0,.38)}.mat-button-toggle .mat-button-toggle-focus-overlay{background-color:rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard{color:#212121;background:#fff}.mat-button-toggle-appearance-standard .mat-button-toggle-focus-overlay{background-color:#000}.mat-button-toggle-group-appearance-standard .mat-button-toggle+.mat-button-toggle{border-left:solid 1px #e0e0e0}[dir=rtl] .mat-button-toggle-group-appearance-standard .mat-button-toggle+.mat-button-toggle{border-left:none;border-right:solid 1px #e0e0e0}.mat-button-toggle-group-appearance-standard.mat-button-toggle-vertical .mat-button-toggle+.mat-button-toggle{border-left:none;border-right:none;border-top:solid 1px #e0e0e0}.mat-button-toggle-checked{background-color:#e0e0e0;color:#616161}.mat-button-toggle-checked.mat-button-toggle-appearance-standard{color:#212121}.mat-button-toggle-disabled{color:rgba(0,0,0,.26);background-color:#eee}.mat-button-toggle-disabled.mat-button-toggle-appearance-standard{background:#fff}.mat-button-toggle-disabled.mat-button-toggle-checked{background-color:#bdbdbd}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard,.mat-button-toggle-group-appearance-standard{border:solid 1px #e0e0e0}.mat-button-toggle-appearance-standard .mat-button-toggle-label-content{line-height:48px}.mat-calendar-arrow{fill:rgba(0,0,0,.54)}.mat-datepicker-toggle,.mat-datepicker-content .mat-calendar-next-button,.mat-datepicker-content .mat-calendar-previous-button{color:rgba(0,0,0,.54)}.mat-calendar-table-header-divider::after{background:rgba(0,0,0,.12)}.mat-calendar-table-header,.mat-calendar-body-label{color:#616161}.mat-calendar-body-cell-content,.mat-date-range-input-separator{color:#212121;border-color:rgba(0,0,0,0)}.mat-calendar-body-disabled>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){color:#757575}.mat-form-field-disabled .mat-date-range-input-separator{color:#757575}.mat-calendar-body-in-preview{color:rgba(0,0,0,.24)}.mat-calendar-body-today:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.38)}.mat-calendar-body-disabled>.mat-calendar-body-today:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.18)}.mat-calendar-body-in-range::before{background:rgba(245,124,0,.2)}.mat-calendar-body-comparison-identical,.mat-calendar-body-in-comparison-range::before{background:rgba(249,171,0,.2)}.mat-calendar-body-comparison-bridge-start::before,[dir=rtl] .mat-calendar-body-comparison-bridge-end::before{background:linear-gradient(to right, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-comparison-bridge-end::before,[dir=rtl] .mat-calendar-body-comparison-bridge-start::before{background:linear-gradient(to left, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-in-range>.mat-calendar-body-comparison-identical,.mat-calendar-body-in-comparison-range.mat-calendar-body-in-range::after{background:#a8dab5}.mat-calendar-body-comparison-identical.mat-calendar-body-selected,.mat-calendar-body-in-comparison-range>.mat-calendar-body-selected{background:#46a35e}.mat-calendar-body-selected{background-color:#f57c00;color:#fff}.mat-calendar-body-disabled>.mat-calendar-body-selected{background-color:rgba(245,124,0,.4)}.mat-calendar-body-today.mat-calendar-body-selected{box-shadow:inset 0 0 0 1px #fff}.cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical),.cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(245,124,0,.3)}@media(hover: hover){.mat-calendar-body-cell:not(.mat-calendar-body-disabled):hover>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(245,124,0,.3)}}.mat-datepicker-content{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2), 0px 4px 5px 0px rgba(0, 0, 0, 0.14), 0px 1px 10px 0px rgba(0, 0, 0, 0.12);background-color:#fff;color:#212121}.mat-datepicker-content.mat-accent .mat-calendar-body-in-range::before{background:rgba(255,152,0,.2)}.mat-datepicker-content.mat-accent .mat-calendar-body-comparison-identical,.mat-datepicker-content.mat-accent .mat-calendar-body-in-comparison-range::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-accent .mat-calendar-body-comparison-bridge-start::before,.mat-datepicker-content.mat-accent [dir=rtl] .mat-calendar-body-comparison-bridge-end::before{background:linear-gradient(to right, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent .mat-calendar-body-comparison-bridge-end::before,.mat-datepicker-content.mat-accent [dir=rtl] .mat-calendar-body-comparison-bridge-start::before{background:linear-gradient(to left, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent .mat-calendar-body-in-range>.mat-calendar-body-comparison-identical,.mat-datepicker-content.mat-accent .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range::after{background:#a8dab5}.mat-datepicker-content.mat-accent .mat-calendar-body-comparison-identical.mat-calendar-body-selected,.mat-datepicker-content.mat-accent .mat-calendar-body-in-comparison-range>.mat-calendar-body-selected{background:#46a35e}.mat-datepicker-content.mat-accent .mat-calendar-body-selected{background-color:#ff9800;color:#fff}.mat-datepicker-content.mat-accent .mat-calendar-body-disabled>.mat-calendar-body-selected{background-color:rgba(255,152,0,.4)}.mat-datepicker-content.mat-accent .mat-calendar-body-today.mat-calendar-body-selected{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content.mat-accent .cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical),.mat-datepicker-content.mat-accent .cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(255,152,0,.3)}@media(hover: hover){.mat-datepicker-content.mat-accent .mat-calendar-body-cell:not(.mat-calendar-body-disabled):hover>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(255,152,0,.3)}}.mat-datepicker-content.mat-warn .mat-calendar-body-in-range::before{background:rgba(244,67,54,.2)}.mat-datepicker-content.mat-warn .mat-calendar-body-comparison-identical,.mat-datepicker-content.mat-warn .mat-calendar-body-in-comparison-range::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-warn .mat-calendar-body-comparison-bridge-start::before,.mat-datepicker-content.mat-warn [dir=rtl] .mat-calendar-body-comparison-bridge-end::before{background:linear-gradient(to right, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn .mat-calendar-body-comparison-bridge-end::before,.mat-datepicker-content.mat-warn [dir=rtl] .mat-calendar-body-comparison-bridge-start::before{background:linear-gradient(to left, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn .mat-calendar-body-in-range>.mat-calendar-body-comparison-identical,.mat-datepicker-content.mat-warn .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range::after{background:#a8dab5}.mat-datepicker-content.mat-warn .mat-calendar-body-comparison-identical.mat-calendar-body-selected,.mat-datepicker-content.mat-warn .mat-calendar-body-in-comparison-range>.mat-calendar-body-selected{background:#46a35e}.mat-datepicker-content.mat-warn .mat-calendar-body-selected{background-color:#f44336;color:#fff}.mat-datepicker-content.mat-warn .mat-calendar-body-disabled>.mat-calendar-body-selected{background-color:rgba(244,67,54,.4)}.mat-datepicker-content.mat-warn .mat-calendar-body-today.mat-calendar-body-selected{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content.mat-warn .cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical),.mat-datepicker-content.mat-warn .cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(244,67,54,.3)}@media(hover: hover){.mat-datepicker-content.mat-warn .mat-calendar-body-cell:not(.mat-calendar-body-disabled):hover>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(244,67,54,.3)}}.mat-datepicker-content-touch{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2), 0px 24px 38px 3px rgba(0, 0, 0, 0.14), 0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-datepicker-toggle-active{color:#f57c00}.mat-datepicker-toggle-active.mat-accent{color:#ff9800}.mat-datepicker-toggle-active.mat-warn{color:#f44336}.mat-date-range-input-inner[disabled]{color:#757575}.mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base{width:40px;height:40px;padding:8px}.mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base .mdc-icon-button__focus-ring{max-height:40px;max-width:40px}.mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base.mdc-icon-button--reduced-size .mdc-icon-button__ripple{width:40px;height:40px;margin-top:0px;margin-bottom:0px;margin-right:0px;margin-left:0px}.mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base.mdc-icon-button--reduced-size .mdc-icon-button__focus-ring{max-height:40px;max-width:40px}.mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base .mdc-icon-button__touch{position:absolute;top:50%;height:40px;left:50%;width:40px;transform:translate(-50%, -50%)}.mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base .mat-mdc-button-touch-target{display:none}.mat-divider{border-top-color:rgba(0,0,0,.12)}.mat-divider-vertical{border-right-color:rgba(0,0,0,.12)}.mat-expansion-panel{background:#fff;color:#212121}.mat-expansion-panel:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2), 0px 2px 2px 0px rgba(0, 0, 0, 0.14), 0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-action-row{border-top-color:rgba(0,0,0,.12)}.mat-expansion-panel .mat-expansion-panel-header.cdk-keyboard-focused:not([aria-disabled=true]),.mat-expansion-panel .mat-expansion-panel-header.cdk-program-focused:not([aria-disabled=true]),.mat-expansion-panel:not(.mat-expanded) .mat-expansion-panel-header:hover:not([aria-disabled=true]){background:rgba(0,0,0,.04)}@media(hover: none){.mat-expansion-panel:not(.mat-expanded):not([aria-disabled=true]) .mat-expansion-panel-header:hover{background:#fff}}.mat-expansion-panel-header-title{color:#212121}.mat-expansion-panel-header-description,.mat-expansion-indicator::after{color:#616161}.mat-expansion-panel-header[aria-disabled=true]{color:rgba(0,0,0,.26)}.mat-expansion-panel-header[aria-disabled=true] .mat-expansion-panel-header-title,.mat-expansion-panel-header[aria-disabled=true] .mat-expansion-panel-header-description{color:inherit}.mat-expansion-panel-header{height:48px}.mat-expansion-panel-header.mat-expanded{height:64px}.mat-icon.mat-primary{color:#f57c00}.mat-icon.mat-accent{color:#ff9800}.mat-icon.mat-warn{color:#f44336}.mat-drawer-container{background-color:#fff;color:#212121}.mat-drawer{background-color:#fff;color:#212121}.mat-drawer.mat-drawer-push{background-color:#fff}.mat-drawer:not(.mat-drawer-side){box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2), 0px 16px 24px 2px rgba(0, 0, 0, 0.14), 0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-drawer-side{border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-side.mat-drawer-end{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl] .mat-drawer-side{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl] .mat-drawer-side.mat-drawer-end{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-backdrop.mat-drawer-shown{background-color:rgba(0,0,0,.6)}.mat-step-header.cdk-keyboard-focused,.mat-step-header.cdk-program-focused,.mat-step-header:hover:not([aria-disabled]),.mat-step-header:hover[aria-disabled=false]{background-color:rgba(0,0,0,.04)}.mat-step-header:hover[aria-disabled=true]{cursor:default}@media(hover: none){.mat-step-header:hover{background:none}}.mat-step-header .mat-step-label,.mat-step-header .mat-step-optional{color:#616161}.mat-step-header .mat-step-icon{background-color:#616161;color:#fff}.mat-step-header .mat-step-icon-selected,.mat-step-header .mat-step-icon-state-done,.mat-step-header .mat-step-icon-state-edit{background-color:#f57c00;color:#fff}.mat-step-header.mat-accent .mat-step-icon{color:#fff}.mat-step-header.mat-accent .mat-step-icon-selected,.mat-step-header.mat-accent .mat-step-icon-state-done,.mat-step-header.mat-accent .mat-step-icon-state-edit{background-color:#ff9800;color:#fff}.mat-step-header.mat-warn .mat-step-icon{color:#fff}.mat-step-header.mat-warn .mat-step-icon-selected,.mat-step-header.mat-warn .mat-step-icon-state-done,.mat-step-header.mat-warn .mat-step-icon-state-edit{background-color:#f44336;color:#fff}.mat-step-header .mat-step-icon-state-error{background-color:rgba(0,0,0,0);color:#f44336}.mat-step-header .mat-step-label.mat-step-label-active{color:#212121}.mat-step-header .mat-step-label.mat-step-label-error{color:#f44336}.mat-stepper-horizontal,.mat-stepper-vertical{background-color:#fff}.mat-stepper-vertical-line::before{border-left-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header::before,.mat-horizontal-stepper-header::after,.mat-stepper-horizontal-line{border-top-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header{height:72px}.mat-stepper-label-position-bottom .mat-horizontal-stepper-header,.mat-vertical-stepper-header{padding:24px 24px}.mat-stepper-vertical-line::before{top:-16px;bottom:-16px}.mat-stepper-label-position-bottom .mat-horizontal-stepper-header::after,.mat-stepper-label-position-bottom .mat-horizontal-stepper-header::before{top:36px}.mat-stepper-label-position-bottom .mat-stepper-horizontal-line{top:36px}.mat-sort-header-arrow{color:#616161}.mat-toolbar{background:#f57c00;color:#212121}.mat-toolbar.mat-primary{background:#f57c00;color:#fff}.mat-toolbar.mat-accent{background:#ff9800;color:#fff}.mat-toolbar.mat-warn{background:#f44336;color:#fff}.mat-toolbar .mat-form-field-underline,.mat-toolbar .mat-form-field-ripple,.mat-toolbar .mat-focused .mat-form-field-ripple{background-color:currentColor}.mat-toolbar .mat-form-field-label,.mat-toolbar .mat-focused .mat-form-field-label,.mat-toolbar .mat-select-value,.mat-toolbar .mat-select-arrow,.mat-toolbar .mat-form-field.mat-focused .mat-select-arrow{color:inherit}.mat-toolbar .mat-input-element{caret-color:currentColor}.mat-toolbar-multiple-rows{min-height:64px}.mat-toolbar-row,.mat-toolbar-single-row{height:64px}@media(max-width: 599px){.mat-toolbar-multiple-rows{min-height:56px}.mat-toolbar-row,.mat-toolbar-single-row{height:56px}}.mat-tree{background:#fff}.mat-tree-node,.mat-nested-tree-node{color:#212121}.mat-tree-node{min-height:48px}body{overflow:hidden}.cdk-overlay-container{contain:strict}a:not(.mdc-button,.mdc-icon-button){color:#1976d2}a:not(.mdc-button,.mdc-icon-button):visited{color:#7b1fa2}body a,body button.mat-mdc-button-base,body.dark-mode a,body.dark-mode button.mat-mdc-button-base{--tb-icon-size: 24px;--mdc-typography-button-letter-spacing: normal}body a[mat-icon-button].mat-mdc-icon-button,body button.mat-mdc-button-base[mat-icon-button].mat-mdc-icon-button,body.dark-mode a[mat-icon-button].mat-mdc-icon-button,body.dark-mode button.mat-mdc-button-base[mat-icon-button].mat-mdc-icon-button{width:40px;height:40px;display:inline-flex;justify-content:center;align-items:center}body a[mat-icon-button].mat-mdc-icon-button .mat-mdc-button-touch-target,body button.mat-mdc-button-base[mat-icon-button].mat-mdc-icon-button .mat-mdc-button-touch-target,body.dark-mode a[mat-icon-button].mat-mdc-icon-button .mat-mdc-button-touch-target,body.dark-mode button.mat-mdc-button-base[mat-icon-button].mat-mdc-icon-button .mat-mdc-button-touch-target{height:100%;width:100%}body a mat-icon.mat-icon,body button.mat-mdc-button-base mat-icon.mat-icon,body.dark-mode a mat-icon.mat-icon,body.dark-mode button.mat-mdc-button-base mat-icon.mat-icon{flex-shrink:0}body a mat-icon.mat-icon,body a svg,body button.mat-mdc-button-base mat-icon.mat-icon,body button.mat-mdc-button-base svg,body.dark-mode a mat-icon.mat-icon,body.dark-mode a svg,body.dark-mode button.mat-mdc-button-base mat-icon.mat-icon,body.dark-mode button.mat-mdc-button-base svg{width:var(--tb-icon-size);height:var(--tb-icon-size);line-height:var(--tb-icon-size)}body.dark-mode{background-color:#303030}body.dark-mode a:not(.mdc-button,.mdc-icon-button){color:#42a5f5}body.dark-mode a:not(.mdc-button,.mdc-icon-button):visited{color:#ba68c8}body.dark-mode .mat-ripple-element{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-mdc-option{color:var(--mdc-theme-text-primary-on-background, white)}body.dark-mode .mat-mdc-option:hover:not(.mdc-list-item--disabled),body.dark-mode .mat-mdc-option:focus:not(.mdc-list-item--disabled),body.dark-mode .mat-mdc-option.mat-mdc-option-active,body.dark-mode .mat-mdc-option.mdc-list-item--selected:not(.mat-mdc-option-multiple):not(.mdc-list-item--disabled){background:rgba(255,255,255,.08)}body.dark-mode .mat-primary .mat-mdc-option.mdc-list-item--selected:not(.mdc-list-item--disabled) .mdc-list-item__primary-text{color:var(--mdc-theme-primary, #ef6c00)}body.dark-mode .mat-accent .mat-mdc-option.mdc-list-item--selected:not(.mdc-list-item--disabled) .mdc-list-item__primary-text{color:var(--mdc-theme-secondary, #ef6c00)}body.dark-mode .mat-warn .mat-mdc-option.mdc-list-item--selected:not(.mdc-list-item--disabled) .mdc-list-item__primary-text{color:var(--mdc-theme-error, #f44336)}body.dark-mode .mat-mdc-optgroup-label{color:var(--mdc-theme-text-primary-on-background, white)}body.dark-mode .mat-pseudo-checkbox-full{color:rgba(255,255,255,.7)}body.dark-mode .mat-pseudo-checkbox-full.mat-pseudo-checkbox-disabled{color:#686868}body.dark-mode .mat-primary .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,body.dark-mode .mat-primary .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#ef6c00}body.dark-mode .mat-primary .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,body.dark-mode .mat-primary .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#ef6c00}body.dark-mode .mat-primary .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full::after,body.dark-mode .mat-primary .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full::after{color:#303030}body.dark-mode .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,body.dark-mode .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#ef6c00}body.dark-mode .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,body.dark-mode .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#ef6c00}body.dark-mode .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full::after,body.dark-mode .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full::after{color:#303030}body.dark-mode .mat-accent .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,body.dark-mode .mat-accent .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#ef6c00}body.dark-mode .mat-accent .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,body.dark-mode .mat-accent .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#ef6c00}body.dark-mode .mat-accent .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full::after,body.dark-mode .mat-accent .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full::after{color:#303030}body.dark-mode .mat-warn .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,body.dark-mode .mat-warn .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#f44336}body.dark-mode .mat-warn .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,body.dark-mode .mat-warn .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#f44336}body.dark-mode .mat-warn .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full::after,body.dark-mode .mat-warn .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full::after{color:#303030}body.dark-mode .mat-pseudo-checkbox-disabled.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,body.dark-mode .mat-pseudo-checkbox-disabled.mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#686868}body.dark-mode .mat-pseudo-checkbox-disabled.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,body.dark-mode .mat-pseudo-checkbox-disabled.mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#686868}body.dark-mode .mat-app-background,body.dark-mode.mat-app-background{background-color:#303030;color:#fff}body.dark-mode .mat-elevation-z0,body.dark-mode .mat-mdc-elevation-specific.mat-elevation-z0{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2), 0px 0px 0px 0px rgba(0, 0, 0, 0.14), 0px 0px 0px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z1,body.dark-mode .mat-mdc-elevation-specific.mat-elevation-z1{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2), 0px 1px 1px 0px rgba(0, 0, 0, 0.14), 0px 1px 3px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z2,body.dark-mode .mat-mdc-elevation-specific.mat-elevation-z2{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2), 0px 2px 2px 0px rgba(0, 0, 0, 0.14), 0px 1px 5px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z3,body.dark-mode .mat-mdc-elevation-specific.mat-elevation-z3{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2), 0px 3px 4px 0px rgba(0, 0, 0, 0.14), 0px 1px 8px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z4,body.dark-mode .mat-mdc-elevation-specific.mat-elevation-z4{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2), 0px 4px 5px 0px rgba(0, 0, 0, 0.14), 0px 1px 10px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z5,body.dark-mode .mat-mdc-elevation-specific.mat-elevation-z5{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2), 0px 5px 8px 0px rgba(0, 0, 0, 0.14), 0px 1px 14px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z6,body.dark-mode .mat-mdc-elevation-specific.mat-elevation-z6{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2), 0px 6px 10px 0px rgba(0, 0, 0, 0.14), 0px 1px 18px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z7,body.dark-mode .mat-mdc-elevation-specific.mat-elevation-z7{box-shadow:0px 4px 5px -2px rgba(0, 0, 0, 0.2), 0px 7px 10px 1px rgba(0, 0, 0, 0.14), 0px 2px 16px 1px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z8,body.dark-mode .mat-mdc-elevation-specific.mat-elevation-z8{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2), 0px 8px 10px 1px rgba(0, 0, 0, 0.14), 0px 3px 14px 2px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z9,body.dark-mode .mat-mdc-elevation-specific.mat-elevation-z9{box-shadow:0px 5px 6px -3px rgba(0, 0, 0, 0.2), 0px 9px 12px 1px rgba(0, 0, 0, 0.14), 0px 3px 16px 2px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z10,body.dark-mode .mat-mdc-elevation-specific.mat-elevation-z10{box-shadow:0px 6px 6px -3px rgba(0, 0, 0, 0.2), 0px 10px 14px 1px rgba(0, 0, 0, 0.14), 0px 4px 18px 3px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z11,body.dark-mode .mat-mdc-elevation-specific.mat-elevation-z11{box-shadow:0px 6px 7px -4px rgba(0, 0, 0, 0.2), 0px 11px 15px 1px rgba(0, 0, 0, 0.14), 0px 4px 20px 3px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z12,body.dark-mode .mat-mdc-elevation-specific.mat-elevation-z12{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2), 0px 12px 17px 2px rgba(0, 0, 0, 0.14), 0px 5px 22px 4px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z13,body.dark-mode .mat-mdc-elevation-specific.mat-elevation-z13{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2), 0px 13px 19px 2px rgba(0, 0, 0, 0.14), 0px 5px 24px 4px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z14,body.dark-mode .mat-mdc-elevation-specific.mat-elevation-z14{box-shadow:0px 7px 9px -4px rgba(0, 0, 0, 0.2), 0px 14px 21px 2px rgba(0, 0, 0, 0.14), 0px 5px 26px 4px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z15,body.dark-mode .mat-mdc-elevation-specific.mat-elevation-z15{box-shadow:0px 8px 9px -5px rgba(0, 0, 0, 0.2), 0px 15px 22px 2px rgba(0, 0, 0, 0.14), 0px 6px 28px 5px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z16,body.dark-mode .mat-mdc-elevation-specific.mat-elevation-z16{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2), 0px 16px 24px 2px rgba(0, 0, 0, 0.14), 0px 6px 30px 5px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z17,body.dark-mode .mat-mdc-elevation-specific.mat-elevation-z17{box-shadow:0px 8px 11px -5px rgba(0, 0, 0, 0.2), 0px 17px 26px 2px rgba(0, 0, 0, 0.14), 0px 6px 32px 5px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z18,body.dark-mode .mat-mdc-elevation-specific.mat-elevation-z18{box-shadow:0px 9px 11px -5px rgba(0, 0, 0, 0.2), 0px 18px 28px 2px rgba(0, 0, 0, 0.14), 0px 7px 34px 6px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z19,body.dark-mode .mat-mdc-elevation-specific.mat-elevation-z19{box-shadow:0px 9px 12px -6px rgba(0, 0, 0, 0.2), 0px 19px 29px 2px rgba(0, 0, 0, 0.14), 0px 7px 36px 6px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z20,body.dark-mode .mat-mdc-elevation-specific.mat-elevation-z20{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2), 0px 20px 31px 3px rgba(0, 0, 0, 0.14), 0px 8px 38px 7px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z21,body.dark-mode .mat-mdc-elevation-specific.mat-elevation-z21{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2), 0px 21px 33px 3px rgba(0, 0, 0, 0.14), 0px 8px 40px 7px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z22,body.dark-mode .mat-mdc-elevation-specific.mat-elevation-z22{box-shadow:0px 10px 14px -6px rgba(0, 0, 0, 0.2), 0px 22px 35px 3px rgba(0, 0, 0, 0.14), 0px 8px 42px 7px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z23,body.dark-mode .mat-mdc-elevation-specific.mat-elevation-z23{box-shadow:0px 11px 14px -7px rgba(0, 0, 0, 0.2), 0px 23px 36px 3px rgba(0, 0, 0, 0.14), 0px 9px 44px 8px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z24,body.dark-mode .mat-mdc-elevation-specific.mat-elevation-z24{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2), 0px 24px 38px 3px rgba(0, 0, 0, 0.14), 0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-theme-loaded-marker{display:none}body.dark-mode .mat-mdc-card{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2), 0px 1px 1px 0px rgba(0, 0, 0, 0.14), 0px 1px 3px 0px rgba(0, 0, 0, 0.12);--mdc-elevated-card-container-color:#424242}body.dark-mode .mat-mdc-card-outlined{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2), 0px 0px 0px 0px rgba(0, 0, 0, 0.14), 0px 0px 0px 0px rgba(0, 0, 0, 0.12);--mdc-outlined-card-outline-color:#595959}body.dark-mode .mat-mdc-card-subtitle{color:rgba(255,255,255,.7)}body.dark-mode .mat-mdc-progress-bar{--mdc-linear-progress-active-indicator-color:#ef6c00}body.dark-mode .mat-mdc-progress-bar .mdc-linear-progress__buffer-dots{background-image:url("data:image/svg+xml,%3Csvg version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' enable-background='new 0 0 5 2' xml:space='preserve' viewBox='0 0 5 2' preserveAspectRatio='none slice'%3E%3Ccircle cx='1' cy='1' r='1' fill='rgba(239, 108, 0, 0.25)'/%3E%3C/svg%3E")}body.dark-mode .mat-mdc-progress-bar .mdc-linear-progress__buffer-bar{background-color:rgba(239, 108, 0, 0.25)}body.dark-mode .mat-mdc-progress-bar.mat-accent{--mdc-linear-progress-active-indicator-color:#ef6c00}body.dark-mode .mat-mdc-progress-bar.mat-accent .mdc-linear-progress__buffer-dots{background-image:url("data:image/svg+xml,%3Csvg version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' enable-background='new 0 0 5 2' xml:space='preserve' viewBox='0 0 5 2' preserveAspectRatio='none slice'%3E%3Ccircle cx='1' cy='1' r='1' fill='rgba(239, 108, 0, 0.25)'/%3E%3C/svg%3E")}body.dark-mode .mat-mdc-progress-bar.mat-accent .mdc-linear-progress__buffer-bar{background-color:rgba(239, 108, 0, 0.25)}body.dark-mode .mat-mdc-progress-bar.mat-warn{--mdc-linear-progress-active-indicator-color:#f44336}body.dark-mode .mat-mdc-progress-bar.mat-warn .mdc-linear-progress__buffer-dots{background-image:url("data:image/svg+xml,%3Csvg version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' enable-background='new 0 0 5 2' xml:space='preserve' viewBox='0 0 5 2' preserveAspectRatio='none slice'%3E%3Ccircle cx='1' cy='1' r='1' fill='rgba(244, 67, 54, 0.25)'/%3E%3C/svg%3E")}body.dark-mode .mat-mdc-progress-bar.mat-warn .mdc-linear-progress__buffer-bar{background-color:rgba(244, 67, 54, 0.25)}body.dark-mode .mat-mdc-tooltip{--mdc-plain-tooltip-container-color:#616161;--mdc-plain-tooltip-supporting-text-color:white}body.dark-mode .mdc-text-field:not(.mdc-text-field--disabled) .mdc-floating-label{color:rgba(255, 255, 255, 0.6)}body.dark-mode .mdc-text-field:not(.mdc-text-field--disabled) .mdc-text-field__input{color:rgba(255, 255, 255, 0.87)}@media all{body.dark-mode .mdc-text-field:not(.mdc-text-field--disabled) .mdc-text-field__input::placeholder{color:rgba(255, 255, 255, 0.6)}}@media all{body.dark-mode .mdc-text-field:not(.mdc-text-field--disabled) .mdc-text-field__input:-ms-input-placeholder{color:rgba(255, 255, 255, 0.6)}}body.dark-mode .mdc-text-field .mdc-text-field__input{caret-color:var(--mdc-theme-primary, #ef6c00)}body.dark-mode .mdc-text-field:not(.mdc-text-field--disabled)+.mdc-text-field-helper-line .mdc-text-field-helper-text{color:rgba(0, 0, 0, 0.6)}body.dark-mode .mdc-text-field:not(.mdc-text-field--disabled) .mdc-text-field-character-counter,body.dark-mode .mdc-text-field:not(.mdc-text-field--disabled)+.mdc-text-field-helper-line .mdc-text-field-character-counter{color:rgba(0, 0, 0, 0.6)}body.dark-mode .mdc-text-field:not(.mdc-text-field--disabled) .mdc-text-field__icon--leading{color:rgba(0, 0, 0, 0.54)}body.dark-mode .mdc-text-field:not(.mdc-text-field--disabled) .mdc-text-field__icon--trailing{color:rgba(0, 0, 0, 0.54)}body.dark-mode .mdc-text-field:not(.mdc-text-field--disabled) .mdc-text-field__affix--prefix{color:rgba(0, 0, 0, 0.6)}body.dark-mode .mdc-text-field:not(.mdc-text-field--disabled) .mdc-text-field__affix--suffix{color:rgba(0, 0, 0, 0.6)}body.dark-mode .mdc-text-field--filled .mdc-text-field__ripple::before,body.dark-mode .mdc-text-field--filled .mdc-text-field__ripple::after{background-color:var(--mdc-ripple-color, rgba(255, 255, 255, 0.87))}body.dark-mode .mdc-text-field--filled:hover .mdc-text-field__ripple::before,body.dark-mode .mdc-text-field--filled.mdc-ripple-surface--hover .mdc-text-field__ripple::before{opacity:var(--mdc-ripple-hover-opacity, 0.08)}body.dark-mode .mdc-text-field--filled.mdc-ripple-upgraded--background-focused .mdc-text-field__ripple::before,body.dark-mode .mdc-text-field--filled:not(.mdc-ripple-upgraded):focus .mdc-text-field__ripple::before{opacity:var(--mdc-ripple-focus-opacity, 0.24)}body.dark-mode .mdc-text-field--filled:not(.mdc-text-field--disabled){background-color:#4a4a4a}body.dark-mode .mdc-text-field--filled:not(.mdc-text-field--disabled) .mdc-line-ripple::before{border-bottom-color:rgba(255, 255, 255, 0.42)}body.dark-mode .mdc-text-field--filled:not(.mdc-text-field--disabled):hover .mdc-line-ripple::before{border-bottom-color:rgba(255, 255, 255, 0.87)}body.dark-mode .mdc-text-field--filled .mdc-line-ripple::after{border-bottom-color:var(--mdc-theme-primary, #ef6c00)}body.dark-mode .mdc-text-field--outlined:not(.mdc-text-field--disabled) .mdc-notched-outline__leading,body.dark-mode .mdc-text-field--outlined:not(.mdc-text-field--disabled) .mdc-notched-outline__notch,body.dark-mode .mdc-text-field--outlined:not(.mdc-text-field--disabled) .mdc-notched-outline__trailing{border-color:rgba(255, 255, 255, 0.38)}body.dark-mode .mdc-text-field--outlined:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__leading,body.dark-mode .mdc-text-field--outlined:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__notch,body.dark-mode .mdc-text-field--outlined:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__trailing{border-color:rgba(255, 255, 255, 0.87)}body.dark-mode .mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__leading,body.dark-mode .mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__notch,body.dark-mode .mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__trailing{border-color:var(--mdc-theme-primary, #ef6c00)}body.dark-mode .mdc-text-field--outlined .mdc-text-field__ripple::before,body.dark-mode .mdc-text-field--outlined .mdc-text-field__ripple::after{background-color:var(--mdc-ripple-color, transparent)}body.dark-mode .mdc-text-field--focused:not(.mdc-text-field--disabled) .mdc-floating-label{color:rgba(239, 108, 0, 0.87)}body.dark-mode .mdc-text-field--invalid:not(.mdc-text-field--disabled):hover .mdc-line-ripple::before{border-bottom-color:var(--mdc-theme-error, #f44336)}body.dark-mode .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-line-ripple::after{border-bottom-color:var(--mdc-theme-error, #f44336)}body.dark-mode .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-floating-label{color:var(--mdc-theme-error, #f44336)}body.dark-mode .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--invalid+.mdc-text-field-helper-line .mdc-text-field-helper-text--validation-msg{color:var(--mdc-theme-error, #f44336)}body.dark-mode .mdc-text-field--invalid .mdc-text-field__input{caret-color:var(--mdc-theme-error, #f44336)}body.dark-mode .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-text-field__icon--trailing{color:var(--mdc-theme-error, #f44336)}body.dark-mode .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-line-ripple::before{border-bottom-color:var(--mdc-theme-error, #f44336)}body.dark-mode .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__leading,body.dark-mode .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__notch,body.dark-mode .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}body.dark-mode .mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__leading,body.dark-mode .mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__notch,body.dark-mode .mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}body.dark-mode .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__leading,body.dark-mode .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__notch,body.dark-mode .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}body.dark-mode .mdc-text-field--disabled .mdc-text-field__input{color:rgba(255, 255, 255, 0.38)}@media all{body.dark-mode .mdc-text-field--disabled .mdc-text-field__input::placeholder{color:rgba(255, 255, 255, 0.38)}}@media all{body.dark-mode .mdc-text-field--disabled .mdc-text-field__input:-ms-input-placeholder{color:rgba(255, 255, 255, 0.38)}}body.dark-mode .mdc-text-field--disabled .mdc-floating-label{color:rgba(255, 255, 255, 0.38)}body.dark-mode .mdc-text-field--disabled+.mdc-text-field-helper-line .mdc-text-field-helper-text{color:rgba(0, 0, 0, 0.38)}body.dark-mode .mdc-text-field--disabled .mdc-text-field-character-counter,body.dark-mode .mdc-text-field--disabled+.mdc-text-field-helper-line .mdc-text-field-character-counter{color:rgba(0, 0, 0, 0.38)}body.dark-mode .mdc-text-field--disabled .mdc-text-field__icon--leading{color:rgba(0, 0, 0, 0.3)}body.dark-mode .mdc-text-field--disabled .mdc-text-field__icon--trailing{color:rgba(0, 0, 0, 0.3)}body.dark-mode .mdc-text-field--disabled .mdc-text-field__affix--prefix{color:rgba(0, 0, 0, 0.38)}body.dark-mode .mdc-text-field--disabled .mdc-text-field__affix--suffix{color:rgba(0, 0, 0, 0.38)}body.dark-mode .mdc-text-field--disabled .mdc-line-ripple::before{border-bottom-color:rgba(255, 255, 255, 0.06)}body.dark-mode .mdc-text-field--disabled .mdc-notched-outline__leading,body.dark-mode .mdc-text-field--disabled .mdc-notched-outline__notch,body.dark-mode .mdc-text-field--disabled .mdc-notched-outline__trailing{border-color:rgba(255, 255, 255, 0.06)}@media screen and (forced-colors: active),(-ms-high-contrast: active){body.dark-mode .mdc-text-field--disabled .mdc-text-field__input::placeholder{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){body.dark-mode .mdc-text-field--disabled .mdc-text-field__input:-ms-input-placeholder{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){body.dark-mode .mdc-text-field--disabled .mdc-floating-label{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){body.dark-mode .mdc-text-field--disabled+.mdc-text-field-helper-line .mdc-text-field-helper-text{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){body.dark-mode .mdc-text-field--disabled .mdc-text-field-character-counter,body.dark-mode .mdc-text-field--disabled+.mdc-text-field-helper-line .mdc-text-field-character-counter{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){body.dark-mode .mdc-text-field--disabled .mdc-text-field__icon--leading{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){body.dark-mode .mdc-text-field--disabled .mdc-text-field__icon--trailing{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){body.dark-mode .mdc-text-field--disabled .mdc-text-field__affix--prefix{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){body.dark-mode .mdc-text-field--disabled .mdc-text-field__affix--suffix{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){body.dark-mode .mdc-text-field--disabled .mdc-line-ripple::before{border-bottom-color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){body.dark-mode .mdc-text-field--disabled .mdc-notched-outline__leading,body.dark-mode .mdc-text-field--disabled .mdc-notched-outline__notch,body.dark-mode .mdc-text-field--disabled .mdc-notched-outline__trailing{border-color:GrayText}}body.dark-mode .mdc-text-field--disabled.mdc-text-field--filled{background-color:#464646}body.dark-mode .mat-mdc-form-field-error{color:var(--mdc-theme-error, #f44336)}body.dark-mode .mat-mdc-form-field-focus-overlay{background-color:rgba(255,255,255,.87)}body.dark-mode .mat-mdc-form-field:hover .mat-mdc-form-field-focus-overlay{opacity:.08}body.dark-mode .mat-mdc-form-field.mat-focused .mat-mdc-form-field-focus-overlay{opacity:.24}body.dark-mode select.mat-mdc-form-field-input-control:not(.mat-mdc-native-select-inline) option{color:rgba(0,0,0,.87)}body.dark-mode select.mat-mdc-form-field-input-control:not(.mat-mdc-native-select-inline) option:disabled{color:rgba(0,0,0,.38)}body.dark-mode .mat-mdc-form-field-type-mat-native-select .mat-mdc-form-field-infix::after{color:rgba(255,255,255,.54)}body.dark-mode .mat-mdc-form-field-type-mat-native-select.mat-focused.mat-primary .mat-mdc-form-field-infix::after{color:rgba(239,108,0,.87)}body.dark-mode .mat-mdc-form-field-type-mat-native-select.mat-focused.mat-accent .mat-mdc-form-field-infix::after{color:rgba(239,108,0,.87)}body.dark-mode .mat-mdc-form-field-type-mat-native-select.mat-focused.mat-warn .mat-mdc-form-field-infix::after{color:rgba(244,67,54,.87)}body.dark-mode .mat-mdc-form-field-type-mat-native-select.mat-form-field-disabled .mat-mdc-form-field-infix::after{color:rgba(255,255,255,.38)}body.dark-mode .mat-mdc-form-field.mat-accent .mdc-text-field__input{caret-color:var(--mdc-theme-secondary, #ef6c00)}body.dark-mode .mat-mdc-form-field.mat-accent:not(.mdc-text-field--disabled) .mdc-line-ripple::after{border-bottom-color:var(--mdc-theme-secondary, #ef6c00)}body.dark-mode .mat-mdc-form-field.mat-accent .mdc-text-field--focused:not(.mdc-text-field--disabled) .mdc-floating-label{color:rgba(239, 108, 0, 0.87)}body.dark-mode .mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled):hover .mdc-line-ripple::before{border-bottom-color:var(--mdc-theme-error, #f44336)}body.dark-mode .mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-line-ripple::after{border-bottom-color:var(--mdc-theme-error, #f44336)}body.dark-mode .mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-floating-label{color:var(--mdc-theme-error, #f44336)}body.dark-mode .mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--invalid+.mdc-text-field-helper-line .mdc-text-field-helper-text--validation-msg{color:var(--mdc-theme-error, #f44336)}body.dark-mode .mat-mdc-form-field.mat-accent .mdc-text-field--invalid .mdc-text-field__input{caret-color:var(--mdc-theme-error, #f44336)}body.dark-mode .mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-text-field__icon--trailing{color:var(--mdc-theme-error, #f44336)}body.dark-mode .mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-line-ripple::before{border-bottom-color:var(--mdc-theme-error, #f44336)}body.dark-mode .mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__leading,body.dark-mode .mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__notch,body.dark-mode .mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}body.dark-mode .mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__leading,body.dark-mode .mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__notch,body.dark-mode .mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}body.dark-mode .mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__leading,body.dark-mode .mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__notch,body.dark-mode .mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}body.dark-mode .mat-mdc-form-field.mat-accent .mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__leading,body.dark-mode .mat-mdc-form-field.mat-accent .mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__notch,body.dark-mode .mat-mdc-form-field.mat-accent .mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__trailing{border-color:var(--mdc-theme-secondary, #ef6c00)}body.dark-mode .mat-mdc-form-field.mat-warn .mdc-text-field__input{caret-color:var(--mdc-theme-error, #f44336)}body.dark-mode .mat-mdc-form-field.mat-warn:not(.mdc-text-field--disabled) .mdc-line-ripple::after{border-bottom-color:var(--mdc-theme-error, #f44336)}body.dark-mode .mat-mdc-form-field.mat-warn .mdc-text-field--focused:not(.mdc-text-field--disabled) .mdc-floating-label{color:rgba(244, 67, 54, 0.87)}body.dark-mode .mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled):hover .mdc-line-ripple::before{border-bottom-color:var(--mdc-theme-error, #f44336)}body.dark-mode .mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-line-ripple::after{border-bottom-color:var(--mdc-theme-error, #f44336)}body.dark-mode .mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-floating-label{color:var(--mdc-theme-error, #f44336)}body.dark-mode .mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--invalid+.mdc-text-field-helper-line .mdc-text-field-helper-text--validation-msg{color:var(--mdc-theme-error, #f44336)}body.dark-mode .mat-mdc-form-field.mat-warn .mdc-text-field--invalid .mdc-text-field__input{caret-color:var(--mdc-theme-error, #f44336)}body.dark-mode .mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-text-field__icon--trailing{color:var(--mdc-theme-error, #f44336)}body.dark-mode .mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-line-ripple::before{border-bottom-color:var(--mdc-theme-error, #f44336)}body.dark-mode .mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__leading,body.dark-mode .mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__notch,body.dark-mode .mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}body.dark-mode .mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__leading,body.dark-mode .mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__notch,body.dark-mode .mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}body.dark-mode .mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__leading,body.dark-mode .mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__notch,body.dark-mode .mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}body.dark-mode .mat-mdc-form-field.mat-warn .mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__leading,body.dark-mode .mat-mdc-form-field.mat-warn .mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__notch,body.dark-mode .mat-mdc-form-field.mat-warn .mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}body.dark-mode .mat-mdc-form-field.mat-mdc-form-field.mat-mdc-form-field.mat-mdc-form-field.mat-mdc-form-field .mdc-notched-outline__notch{border-left:1px solid rgba(0,0,0,0)}body.dark-mode [dir=rtl] .mat-mdc-form-field.mat-mdc-form-field.mat-mdc-form-field.mat-mdc-form-field.mat-mdc-form-field .mdc-notched-outline__notch{border-left:none;border-right:1px solid rgba(0,0,0,0)}body.dark-mode .mat-mdc-form-field-infix{min-height:56px}body.dark-mode .mat-mdc-text-field-wrapper .mat-mdc-form-field-flex .mat-mdc-floating-label{top:28px}body.dark-mode .mat-mdc-text-field-wrapper.mdc-text-field--outlined .mdc-notched-outline--upgraded .mdc-floating-label--float-above{--mat-mdc-form-field-label-transform: translateY( -34.75px) scale(var(--mat-mdc-form-field-floating-label-scale, 0.75));transform:var(--mat-mdc-form-field-label-transform)}body.dark-mode .mat-mdc-text-field-wrapper.mdc-text-field--outlined .mat-mdc-form-field-infix{padding-top:16px;padding-bottom:16px}body.dark-mode .mat-mdc-text-field-wrapper:not(.mdc-text-field--outlined) .mat-mdc-form-field-infix{padding-top:24px;padding-bottom:8px}body.dark-mode .mdc-text-field--no-label:not(.mdc-text-field--outlined):not(.mdc-text-field--textarea) .mat-mdc-form-field-infix{padding-top:16px;padding-bottom:16px}body.dark-mode .mdc-menu-surface{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2), 0px 8px 10px 1px rgba(0, 0, 0, 0.14), 0px 3px 14px 2px rgba(0, 0, 0, 0.12);background-color:var(--mdc-theme-surface, #424242);color:var(--mdc-theme-on-surface, #fff)}body.dark-mode .mdc-list-item__primary-text{color:var(--mdc-theme-text-primary-on-background, white)}body.dark-mode .mdc-list-item__secondary-text{color:var(--mdc-theme-text-secondary-on-background, rgba(255, 255, 255, 0.7))}body.dark-mode .mdc-list-item__overline-text{color:var(--mdc-theme-text-hint-on-background, rgba(255, 255, 255, 0.5))}body.dark-mode .mdc-list-item--with-leading-icon .mdc-list-item__start,body.dark-mode .mdc-list-item--with-trailing-icon .mdc-list-item__end{background-color:transparent}body.dark-mode .mdc-list-item--with-leading-icon .mdc-list-item__start,body.dark-mode .mdc-list-item--with-trailing-icon .mdc-list-item__end{color:var(--mdc-theme-text-icon-on-background, rgba(255, 255, 255, 0.5))}body.dark-mode .mdc-list-item__end{color:var(--mdc-theme-text-hint-on-background, rgba(255, 255, 255, 0.5))}body.dark-mode .mdc-list-item--disabled .mdc-list-item__start,body.dark-mode .mdc-list-item--disabled .mdc-list-item__content,body.dark-mode .mdc-list-item--disabled .mdc-list-item__end{opacity:0.38}body.dark-mode .mdc-list-item--disabled .mdc-list-item__primary-text{color:var(--mdc-theme-on-surface, #fff)}body.dark-mode .mdc-list-item--disabled .mdc-list-item__secondary-text{color:var(--mdc-theme-on-surface, #fff)}body.dark-mode .mdc-list-item--disabled .mdc-list-item__overline-text{color:var(--mdc-theme-on-surface, #fff)}body.dark-mode .mdc-list-item--disabled.mdc-list-item--with-leading-icon .mdc-list-item__start{color:var(--mdc-theme-on-surface, #fff)}body.dark-mode .mdc-list-item--disabled.mdc-list-item--with-trailing-icon .mdc-list-item__end{color:var(--mdc-theme-on-surface, #fff)}body.dark-mode .mdc-list-item--disabled.mdc-list-item--with-trailing-meta .mdc-list-item__end{color:var(--mdc-theme-on-surface, #fff)}body.dark-mode .mdc-list-item--selected .mdc-list-item__primary-text,body.dark-mode .mdc-list-item--activated .mdc-list-item__primary-text{color:var(--mdc-theme-primary, #ef6c00)}body.dark-mode .mdc-list-item--selected.mdc-list-item--with-leading-icon .mdc-list-item__start,body.dark-mode .mdc-list-item--activated.mdc-list-item--with-leading-icon .mdc-list-item__start{color:var(--mdc-theme-primary, #ef6c00)}body.dark-mode .mdc-deprecated-list-group__subheader{color:var(--mdc-theme-text-primary-on-background, white)}body.dark-mode .mdc-list-divider::after{border-bottom-color:white}body.dark-mode .mdc-list-divider{background-color:rgba(255, 255, 255, 0.2)}body.dark-mode .mat-mdc-select-value{color:rgba(255,255,255,.87)}body.dark-mode .mat-mdc-select-placeholder{color:rgba(255,255,255,.6)}body.dark-mode .mat-mdc-select-disabled .mat-mdc-select-value{color:rgba(255,255,255,.38)}body.dark-mode .mat-mdc-select-arrow{color:rgba(255,255,255,.54)}body.dark-mode .mat-mdc-form-field.mat-focused.mat-primary .mat-mdc-select-arrow{color:rgba(239,108,0,.87)}body.dark-mode .mat-mdc-form-field.mat-focused.mat-accent .mat-mdc-select-arrow{color:rgba(239,108,0,.87)}body.dark-mode .mat-mdc-form-field.mat-focused.mat-warn .mat-mdc-select-arrow{color:rgba(244,67,54,.87)}body.dark-mode .mat-mdc-form-field .mat-mdc-select.mat-mdc-select-invalid .mat-mdc-select-arrow{color:rgba(244,67,54,.87)}body.dark-mode .mat-mdc-form-field .mat-mdc-select.mat-mdc-select-disabled .mat-mdc-select-arrow{color:rgba(255,255,255,.38)}body.dark-mode .mdc-menu-surface{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2), 0px 8px 10px 1px rgba(0, 0, 0, 0.14), 0px 3px 14px 2px rgba(0, 0, 0, 0.12);background-color:var(--mdc-theme-surface, #424242);color:var(--mdc-theme-on-surface, #fff)}body.dark-mode .mdc-list-item__primary-text{color:var(--mdc-theme-text-primary-on-background, white)}body.dark-mode .mdc-list-item__secondary-text{color:var(--mdc-theme-text-secondary-on-background, rgba(255, 255, 255, 0.7))}body.dark-mode .mdc-list-item__overline-text{color:var(--mdc-theme-text-hint-on-background, rgba(255, 255, 255, 0.5))}body.dark-mode .mdc-list-item--with-leading-icon .mdc-list-item__start,body.dark-mode .mdc-list-item--with-trailing-icon .mdc-list-item__end{background-color:transparent}body.dark-mode .mdc-list-item--with-leading-icon .mdc-list-item__start,body.dark-mode .mdc-list-item--with-trailing-icon .mdc-list-item__end{color:var(--mdc-theme-text-icon-on-background, rgba(255, 255, 255, 0.5))}body.dark-mode .mdc-list-item__end{color:var(--mdc-theme-text-hint-on-background, rgba(255, 255, 255, 0.5))}body.dark-mode .mdc-list-item--disabled .mdc-list-item__start,body.dark-mode .mdc-list-item--disabled .mdc-list-item__content,body.dark-mode .mdc-list-item--disabled .mdc-list-item__end{opacity:0.38}body.dark-mode .mdc-list-item--disabled .mdc-list-item__primary-text{color:var(--mdc-theme-on-surface, #fff)}body.dark-mode .mdc-list-item--disabled .mdc-list-item__secondary-text{color:var(--mdc-theme-on-surface, #fff)}body.dark-mode .mdc-list-item--disabled .mdc-list-item__overline-text{color:var(--mdc-theme-on-surface, #fff)}body.dark-mode .mdc-list-item--disabled.mdc-list-item--with-leading-icon .mdc-list-item__start{color:var(--mdc-theme-on-surface, #fff)}body.dark-mode .mdc-list-item--disabled.mdc-list-item--with-trailing-icon .mdc-list-item__end{color:var(--mdc-theme-on-surface, #fff)}body.dark-mode .mdc-list-item--disabled.mdc-list-item--with-trailing-meta .mdc-list-item__end{color:var(--mdc-theme-on-surface, #fff)}body.dark-mode .mdc-list-item--selected .mdc-list-item__primary-text,body.dark-mode .mdc-list-item--activated .mdc-list-item__primary-text{color:var(--mdc-theme-primary, #ef6c00)}body.dark-mode .mdc-list-item--selected.mdc-list-item--with-leading-icon .mdc-list-item__start,body.dark-mode .mdc-list-item--activated.mdc-list-item--with-leading-icon .mdc-list-item__start{color:var(--mdc-theme-primary, #ef6c00)}body.dark-mode .mdc-deprecated-list-group__subheader{color:var(--mdc-theme-text-primary-on-background, white)}body.dark-mode .mdc-list-divider::after{border-bottom-color:white}body.dark-mode .mdc-list-divider{background-color:rgba(255, 255, 255, 0.2)}body.dark-mode .mat-mdc-dialog-container{--mdc-dialog-container-color:#424242;--mdc-dialog-with-divider-divider-color:rgba(255, 255, 255, 0.12);--mdc-dialog-subhead-color:rgba(255, 255, 255, 0.87);--mdc-dialog-supporting-text-color:rgba(255, 255, 255, 0.6)}body.dark-mode .mat-mdc-standard-chip{--mdc-chip-elevated-container-color:#595959;--mdc-chip-elevated-disabled-container-color:#595959;--mdc-chip-label-text-color:#fafafa;--mdc-chip-disabled-label-text-color:#fafafa;--mdc-chip-with-icon-icon-color:#fafafa;--mdc-chip-with-icon-disabled-icon-color:#fafafa;--mdc-chip-with-trailing-icon-disabled-trailing-icon-color:#fafafa;--mdc-chip-with-trailing-icon-trailing-icon-color:#fafafa;--mdc-chip-with-icon-selected-icon-color:#fafafa}body.dark-mode .mat-mdc-standard-chip.mat-primary.mat-mdc-chip-selected,body.dark-mode .mat-mdc-standard-chip.mat-primary.mat-mdc-chip-highlighted{--mdc-chip-elevated-container-color:#ef6c00;--mdc-chip-elevated-disabled-container-color:#ef6c00;--mdc-chip-label-text-color:white;--mdc-chip-disabled-label-text-color:white;--mdc-chip-with-icon-icon-color:white;--mdc-chip-with-icon-disabled-icon-color:white;--mdc-chip-with-trailing-icon-disabled-trailing-icon-color:white;--mdc-chip-with-trailing-icon-trailing-icon-color:white;--mdc-chip-with-icon-selected-icon-color:white}body.dark-mode .mat-mdc-standard-chip.mat-accent.mat-mdc-chip-selected,body.dark-mode .mat-mdc-standard-chip.mat-accent.mat-mdc-chip-highlighted{--mdc-chip-elevated-container-color:#ef6c00;--mdc-chip-elevated-disabled-container-color:#ef6c00;--mdc-chip-label-text-color:white;--mdc-chip-disabled-label-text-color:white;--mdc-chip-with-icon-icon-color:white;--mdc-chip-with-icon-disabled-icon-color:white;--mdc-chip-with-trailing-icon-disabled-trailing-icon-color:white;--mdc-chip-with-trailing-icon-trailing-icon-color:white;--mdc-chip-with-icon-selected-icon-color:white}body.dark-mode .mat-mdc-standard-chip.mat-warn.mat-mdc-chip-selected,body.dark-mode .mat-mdc-standard-chip.mat-warn.mat-mdc-chip-highlighted{--mdc-chip-elevated-container-color:#f44336;--mdc-chip-elevated-disabled-container-color:#f44336;--mdc-chip-label-text-color:white;--mdc-chip-disabled-label-text-color:white;--mdc-chip-with-icon-icon-color:white;--mdc-chip-with-icon-disabled-icon-color:white;--mdc-chip-with-trailing-icon-disabled-trailing-icon-color:white;--mdc-chip-with-trailing-icon-trailing-icon-color:white;--mdc-chip-with-icon-selected-icon-color:white}body.dark-mode .mat-mdc-chip-focus-overlay{background:#fff}body.dark-mode .mat-mdc-chip{height:32px}body.dark-mode .mat-mdc-slide-toggle{--mdc-switch-disabled-selected-handle-color:#000;--mdc-switch-disabled-unselected-handle-color:#000;--mdc-switch-disabled-selected-track-color:#f5f5f5;--mdc-switch-disabled-unselected-track-color:#f5f5f5;--mdc-switch-unselected-focus-state-layer-color:#f5f5f5;--mdc-switch-unselected-pressed-state-layer-color:#f5f5f5;--mdc-switch-unselected-hover-state-layer-color:#f5f5f5;--mdc-switch-unselected-focus-track-color:#616161;--mdc-switch-unselected-hover-track-color:#616161;--mdc-switch-unselected-pressed-track-color:#616161;--mdc-switch-unselected-track-color:#616161;--mdc-switch-unselected-focus-handle-color:#fafafa;--mdc-switch-unselected-hover-handle-color:#fafafa;--mdc-switch-unselected-pressed-handle-color:#fafafa;--mdc-switch-handle-surface-color:var(--mdc-theme-surface, #fff);--mdc-switch-unselected-handle-color:#9e9e9e;--mdc-switch-selected-icon-color:#212121;--mdc-switch-disabled-selected-icon-color:#212121;--mdc-switch-disabled-unselected-icon-color:#212121;--mdc-switch-unselected-icon-color:#212121}body.dark-mode .mat-mdc-slide-toggle .mdc-form-field{color:var(--mdc-theme-text-primary-on-background, white)}body.dark-mode .mat-mdc-slide-toggle .mdc-switch--disabled+label{color:#616161}body.dark-mode .mat-mdc-slide-toggle.mat-primary{--mdc-switch-selected-focus-state-layer-color:#ffb74d;--mdc-switch-selected-handle-color:#ffb74d;--mdc-switch-selected-hover-state-layer-color:#ffb74d;--mdc-switch-selected-pressed-state-layer-color:#ffb74d;--mdc-switch-selected-focus-handle-color:#ffcc80;--mdc-switch-selected-hover-handle-color:#ffcc80;--mdc-switch-selected-pressed-handle-color:#ffcc80;--mdc-switch-selected-focus-track-color:#fb8c00;--mdc-switch-selected-hover-track-color:#fb8c00;--mdc-switch-selected-pressed-track-color:#fb8c00;--mdc-switch-selected-track-color:#fb8c00}body.dark-mode .mat-mdc-slide-toggle.mat-accent{--mdc-switch-selected-focus-state-layer-color:#ffb74d;--mdc-switch-selected-handle-color:#ffb74d;--mdc-switch-selected-hover-state-layer-color:#ffb74d;--mdc-switch-selected-pressed-state-layer-color:#ffb74d;--mdc-switch-selected-focus-handle-color:#ffcc80;--mdc-switch-selected-hover-handle-color:#ffcc80;--mdc-switch-selected-pressed-handle-color:#ffcc80;--mdc-switch-selected-focus-track-color:#fb8c00;--mdc-switch-selected-hover-track-color:#fb8c00;--mdc-switch-selected-pressed-track-color:#fb8c00;--mdc-switch-selected-track-color:#fb8c00}body.dark-mode .mat-mdc-slide-toggle.mat-warn{--mdc-switch-selected-focus-state-layer-color:#e57373;--mdc-switch-selected-handle-color:#e57373;--mdc-switch-selected-hover-state-layer-color:#e57373;--mdc-switch-selected-pressed-state-layer-color:#e57373;--mdc-switch-selected-focus-handle-color:#ef9a9a;--mdc-switch-selected-hover-handle-color:#ef9a9a;--mdc-switch-selected-pressed-handle-color:#ef9a9a;--mdc-switch-selected-focus-track-color:#e53935;--mdc-switch-selected-hover-track-color:#e53935;--mdc-switch-selected-pressed-track-color:#e53935;--mdc-switch-selected-track-color:#e53935}body.dark-mode .mat-mdc-slide-toggle{--mdc-switch-state-layer-size:48px}body.dark-mode .mat-mdc-radio-button .mdc-form-field{color:var(--mdc-theme-text-primary-on-background, white)}body.dark-mode .mat-mdc-radio-button.mat-primary{--mdc-radio-disabled-selected-icon-color:#fff;--mdc-radio-disabled-unselected-icon-color:#fff;--mdc-radio-unselected-focus-icon-color:#eeeeee;--mdc-radio-unselected-hover-icon-color:#eeeeee;--mdc-radio-unselected-icon-color:rgba(255, 255, 255, 0.54);--mdc-radio-unselected-pressed-icon-color:rgba(255, 255, 255, 0.54);--mdc-radio-selected-focus-icon-color:#ef6c00;--mdc-radio-selected-hover-icon-color:#ef6c00;--mdc-radio-selected-icon-color:#ef6c00;--mdc-radio-selected-pressed-icon-color:#ef6c00;--mat-mdc-radio-ripple-color: #fff;--mat-mdc-radio-checked-ripple-color: #ef6c00}body.dark-mode .mat-mdc-radio-button.mat-primary .mdc-radio--disabled+label{color:#616161}body.dark-mode .mat-mdc-radio-button.mat-accent{--mdc-radio-disabled-selected-icon-color:#fff;--mdc-radio-disabled-unselected-icon-color:#fff;--mdc-radio-unselected-focus-icon-color:#eeeeee;--mdc-radio-unselected-hover-icon-color:#eeeeee;--mdc-radio-unselected-icon-color:rgba(255, 255, 255, 0.54);--mdc-radio-unselected-pressed-icon-color:rgba(255, 255, 255, 0.54);--mdc-radio-selected-focus-icon-color:#ef6c00;--mdc-radio-selected-hover-icon-color:#ef6c00;--mdc-radio-selected-icon-color:#ef6c00;--mdc-radio-selected-pressed-icon-color:#ef6c00;--mat-mdc-radio-ripple-color: #fff;--mat-mdc-radio-checked-ripple-color: #ef6c00}body.dark-mode .mat-mdc-radio-button.mat-accent .mdc-radio--disabled+label{color:#616161}body.dark-mode .mat-mdc-radio-button.mat-warn{--mdc-radio-disabled-selected-icon-color:#fff;--mdc-radio-disabled-unselected-icon-color:#fff;--mdc-radio-unselected-focus-icon-color:#eeeeee;--mdc-radio-unselected-hover-icon-color:#eeeeee;--mdc-radio-unselected-icon-color:rgba(255, 255, 255, 0.54);--mdc-radio-unselected-pressed-icon-color:rgba(255, 255, 255, 0.54);--mdc-radio-selected-focus-icon-color:#f44336;--mdc-radio-selected-hover-icon-color:#f44336;--mdc-radio-selected-icon-color:#f44336;--mdc-radio-selected-pressed-icon-color:#f44336;--mat-mdc-radio-ripple-color: #fff;--mat-mdc-radio-checked-ripple-color: #f44336}body.dark-mode .mat-mdc-radio-button.mat-warn .mdc-radio--disabled+label{color:#616161}body.dark-mode .mat-mdc-radio-button .mdc-radio{padding:calc((40px - 20px) / 2)}body.dark-mode .mat-mdc-radio-button .mdc-radio .mdc-radio__background::before{top:calc(-1 * (40px - 20px) / 2);left:calc(-1 * (40px - 20px) / 2);width:40px;height:40px}body.dark-mode .mat-mdc-radio-button .mdc-radio .mdc-radio__native-control{top:calc((40px - 40px) / 2);right:calc((40px - 40px) / 2);left:calc((40px - 40px) / 2);width:40px;height:40px}body.dark-mode .mat-mdc-slider{--mdc-slider-label-container-color:white;--mdc-slider-label-label-text-color:black;--mdc-slider-disabled-handle-color:#fff;--mdc-slider-disabled-active-track-color:#fff;--mdc-slider-disabled-inactive-track-color:#fff;--mdc-slider-with-tick-marks-disabled-container-color:#fff;--mat-mdc-slider-value-indicator-opacity: 0.9}body.dark-mode .mat-mdc-slider.mat-primary{--mdc-slider-handle-color:#ef6c00;--mdc-slider-focus-handle-color:#ef6c00;--mdc-slider-hover-handle-color:#ef6c00;--mdc-slider-active-track-color:#ef6c00;--mdc-slider-inactive-track-color:#ef6c00;--mdc-slider-with-tick-marks-active-container-color:#000;--mdc-slider-with-tick-marks-inactive-container-color:#ef6c00;--mat-mdc-slider-ripple-color: #ef6c00;--mat-mdc-slider-hover-ripple-color: rgba(239, 108, 0, 0.05);--mat-mdc-slider-focus-ripple-color: rgba(239, 108, 0, 0.2)}body.dark-mode .mat-mdc-slider.mat-accent{--mdc-slider-handle-color:#ef6c00;--mdc-slider-focus-handle-color:#ef6c00;--mdc-slider-hover-handle-color:#ef6c00;--mdc-slider-active-track-color:#ef6c00;--mdc-slider-inactive-track-color:#ef6c00;--mdc-slider-with-tick-marks-active-container-color:#000;--mdc-slider-with-tick-marks-inactive-container-color:#ef6c00;--mat-mdc-slider-ripple-color: #ef6c00;--mat-mdc-slider-hover-ripple-color: rgba(239, 108, 0, 0.05);--mat-mdc-slider-focus-ripple-color: rgba(239, 108, 0, 0.2)}body.dark-mode .mat-mdc-slider.mat-warn{--mdc-slider-handle-color:#f44336;--mdc-slider-focus-handle-color:#f44336;--mdc-slider-hover-handle-color:#f44336;--mdc-slider-active-track-color:#f44336;--mdc-slider-inactive-track-color:#f44336;--mdc-slider-with-tick-marks-active-container-color:#fff;--mdc-slider-with-tick-marks-inactive-container-color:#f44336;--mat-mdc-slider-ripple-color: #f44336;--mat-mdc-slider-hover-ripple-color: rgba(244, 67, 54, 0.05);--mat-mdc-slider-focus-ripple-color: rgba(244, 67, 54, 0.2)}body.dark-mode .mdc-menu-surface{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2), 0px 8px 10px 1px rgba(0, 0, 0, 0.14), 0px 3px 14px 2px rgba(0, 0, 0, 0.12);background-color:var(--mdc-theme-surface, #424242);color:var(--mdc-theme-on-surface, #fff)}body.dark-mode .mdc-list-item__primary-text{color:var(--mdc-theme-text-primary-on-background, white)}body.dark-mode .mdc-list-item__secondary-text{color:var(--mdc-theme-text-secondary-on-background, rgba(255, 255, 255, 0.7))}body.dark-mode .mdc-list-item__overline-text{color:var(--mdc-theme-text-hint-on-background, rgba(255, 255, 255, 0.5))}body.dark-mode .mdc-list-item--with-leading-icon .mdc-list-item__start,body.dark-mode .mdc-list-item--with-trailing-icon .mdc-list-item__end{background-color:transparent}body.dark-mode .mdc-list-item--with-leading-icon .mdc-list-item__start,body.dark-mode .mdc-list-item--with-trailing-icon .mdc-list-item__end{color:var(--mdc-theme-text-icon-on-background, rgba(255, 255, 255, 0.5))}body.dark-mode .mdc-list-item__end{color:var(--mdc-theme-text-hint-on-background, rgba(255, 255, 255, 0.5))}body.dark-mode .mdc-list-item--disabled .mdc-list-item__start,body.dark-mode .mdc-list-item--disabled .mdc-list-item__content,body.dark-mode .mdc-list-item--disabled .mdc-list-item__end{opacity:0.38}body.dark-mode .mdc-list-item--disabled .mdc-list-item__primary-text{color:var(--mdc-theme-on-surface, #fff)}body.dark-mode .mdc-list-item--disabled .mdc-list-item__secondary-text{color:var(--mdc-theme-on-surface, #fff)}body.dark-mode .mdc-list-item--disabled .mdc-list-item__overline-text{color:var(--mdc-theme-on-surface, #fff)}body.dark-mode .mdc-list-item--disabled.mdc-list-item--with-leading-icon .mdc-list-item__start{color:var(--mdc-theme-on-surface, #fff)}body.dark-mode .mdc-list-item--disabled.mdc-list-item--with-trailing-icon .mdc-list-item__end{color:var(--mdc-theme-on-surface, #fff)}body.dark-mode .mdc-list-item--disabled.mdc-list-item--with-trailing-meta .mdc-list-item__end{color:var(--mdc-theme-on-surface, #fff)}body.dark-mode .mdc-list-item--selected .mdc-list-item__primary-text,body.dark-mode .mdc-list-item--activated .mdc-list-item__primary-text{color:var(--mdc-theme-primary, #ef6c00)}body.dark-mode .mdc-list-item--selected.mdc-list-item--with-leading-icon .mdc-list-item__start,body.dark-mode .mdc-list-item--activated.mdc-list-item--with-leading-icon .mdc-list-item__start{color:var(--mdc-theme-primary, #ef6c00)}body.dark-mode .mdc-deprecated-list-group__subheader{color:var(--mdc-theme-text-primary-on-background, white)}body.dark-mode .mdc-list-divider::after{border-bottom-color:white}body.dark-mode .mdc-list-divider{background-color:rgba(255, 255, 255, 0.2)}body.dark-mode .mat-mdc-menu-item[disabled],body.dark-mode .mat-mdc-menu-item[disabled] .mat-mdc-menu-submenu-icon,body.dark-mode .mat-mdc-menu-item[disabled] .mat-icon-no-color{color:var(--mdc-theme-text-disabled-on-background, rgba(255, 255, 255, 0.5))}body.dark-mode .mat-mdc-menu-item .mat-icon-no-color,body.dark-mode .mat-mdc-menu-submenu-icon{color:var(--mdc-theme-text-primary-on-background, white)}body.dark-mode .mat-mdc-menu-item:hover:not([disabled]),body.dark-mode .mat-mdc-menu-item.cdk-program-focused:not([disabled]),body.dark-mode .mat-mdc-menu-item.cdk-keyboard-focused:not([disabled]),body.dark-mode .mat-mdc-menu-item-highlighted:not([disabled]){background:rgba(255,255,255,.08)}body.dark-mode .mat-mdc-list-base{--mdc-list-list-item-label-text-color:white;--mdc-list-list-item-supporting-text-color:rgba(255, 255, 255, 0.7);--mdc-list-list-item-leading-icon-color:rgba(255, 255, 255, 0.5);--mdc-list-list-item-trailing-supporting-text-color:rgba(255, 255, 255, 0.5);--mdc-list-list-item-trailing-icon-color:rgba(255, 255, 255, 0.5);--mdc-list-list-item-selected-trailing-icon-color:rgba(255, 255, 255, 0.5);--mdc-list-list-item-disabled-label-text-color:white;--mdc-list-list-item-disabled-leading-icon-color:white;--mdc-list-list-item-disabled-trailing-icon-color:white;--mdc-list-list-item-hover-label-text-color:white;--mdc-list-list-item-hover-leading-icon-color:rgba(255, 255, 255, 0.5);--mdc-list-list-item-hover-trailing-icon-color:rgba(255, 255, 255, 0.5);--mdc-list-list-item-focus-label-text-color:white;--mdc-list-list-item-hover-state-layer-color:white;--mdc-list-list-item-hover-state-layer-opacity:0.08;--mdc-list-list-item-focus-state-layer-color:white;--mdc-list-list-item-focus-state-layer-opacity:0.24}body.dark-mode .mat-mdc-list-option .mdc-list-item__start,body.dark-mode .mat-mdc-list-option .mdc-list-item__end{--mdc-checkbox-selected-checkmark-color:#000;--mdc-checkbox-selected-focus-icon-color:#ef6c00;--mdc-checkbox-selected-hover-icon-color:#ef6c00;--mdc-checkbox-selected-icon-color:#ef6c00;--mdc-checkbox-selected-pressed-icon-color:#ef6c00;--mdc-checkbox-unselected-focus-icon-color:#eeeeee;--mdc-checkbox-unselected-hover-icon-color:#eeeeee;--mdc-checkbox-disabled-selected-icon-color:rgba(255, 255, 255, 0.38);--mdc-checkbox-disabled-unselected-icon-color:rgba(255, 255, 255, 0.38);--mdc-checkbox-unselected-icon-color:rgba(255, 255, 255, 0.54);--mdc-checkbox-unselected-pressed-icon-color:rgba(255, 255, 255, 0.54)}body.dark-mode .mat-mdc-list-option .mdc-list-item__start,body.dark-mode .mat-mdc-list-option .mdc-list-item__end{--mdc-radio-disabled-selected-icon-color:#fff;--mdc-radio-disabled-unselected-icon-color:#fff;--mdc-radio-unselected-focus-icon-color:#eeeeee;--mdc-radio-unselected-hover-icon-color:#eeeeee;--mdc-radio-unselected-icon-color:rgba(255, 255, 255, 0.54);--mdc-radio-unselected-pressed-icon-color:rgba(255, 255, 255, 0.54);--mdc-radio-selected-focus-icon-color:#ef6c00;--mdc-radio-selected-hover-icon-color:#ef6c00;--mdc-radio-selected-icon-color:#ef6c00;--mdc-radio-selected-pressed-icon-color:#ef6c00;--mat-mdc-radio-ripple-color: #fff;--mat-mdc-radio-checked-ripple-color: #ef6c00}body.dark-mode .mat-mdc-list-option .mdc-list-item__start .mdc-radio--disabled+label,body.dark-mode .mat-mdc-list-option .mdc-list-item__end .mdc-radio--disabled+label{color:#616161}body.dark-mode .mat-mdc-list-option.mat-accent .mdc-list-item__start,body.dark-mode .mat-mdc-list-option.mat-accent .mdc-list-item__end{--mdc-checkbox-selected-checkmark-color:#000;--mdc-checkbox-selected-focus-icon-color:#ef6c00;--mdc-checkbox-selected-hover-icon-color:#ef6c00;--mdc-checkbox-selected-icon-color:#ef6c00;--mdc-checkbox-selected-pressed-icon-color:#ef6c00;--mdc-checkbox-unselected-focus-icon-color:#eeeeee;--mdc-checkbox-unselected-hover-icon-color:#eeeeee;--mdc-checkbox-disabled-selected-icon-color:rgba(255, 255, 255, 0.38);--mdc-checkbox-disabled-unselected-icon-color:rgba(255, 255, 255, 0.38);--mdc-checkbox-unselected-icon-color:rgba(255, 255, 255, 0.54);--mdc-checkbox-unselected-pressed-icon-color:rgba(255, 255, 255, 0.54)}body.dark-mode .mat-mdc-list-option.mat-accent .mdc-list-item__start,body.dark-mode .mat-mdc-list-option.mat-accent .mdc-list-item__end{--mdc-radio-disabled-selected-icon-color:#fff;--mdc-radio-disabled-unselected-icon-color:#fff;--mdc-radio-unselected-focus-icon-color:#eeeeee;--mdc-radio-unselected-hover-icon-color:#eeeeee;--mdc-radio-unselected-icon-color:rgba(255, 255, 255, 0.54);--mdc-radio-unselected-pressed-icon-color:rgba(255, 255, 255, 0.54);--mdc-radio-selected-focus-icon-color:#ef6c00;--mdc-radio-selected-hover-icon-color:#ef6c00;--mdc-radio-selected-icon-color:#ef6c00;--mdc-radio-selected-pressed-icon-color:#ef6c00;--mat-mdc-radio-ripple-color: #fff;--mat-mdc-radio-checked-ripple-color: #ef6c00}body.dark-mode .mat-mdc-list-option.mat-accent .mdc-list-item__start .mdc-radio--disabled+label,body.dark-mode .mat-mdc-list-option.mat-accent .mdc-list-item__end .mdc-radio--disabled+label{color:#616161}body.dark-mode .mat-mdc-list-option.mat-warn .mdc-list-item__start,body.dark-mode .mat-mdc-list-option.mat-warn .mdc-list-item__end{--mdc-checkbox-selected-checkmark-color:#fff;--mdc-checkbox-selected-focus-icon-color:#f44336;--mdc-checkbox-selected-hover-icon-color:#f44336;--mdc-checkbox-selected-icon-color:#f44336;--mdc-checkbox-selected-pressed-icon-color:#f44336;--mdc-checkbox-unselected-focus-icon-color:#eeeeee;--mdc-checkbox-unselected-hover-icon-color:#eeeeee;--mdc-checkbox-disabled-selected-icon-color:rgba(255, 255, 255, 0.38);--mdc-checkbox-disabled-unselected-icon-color:rgba(255, 255, 255, 0.38);--mdc-checkbox-unselected-icon-color:rgba(255, 255, 255, 0.54);--mdc-checkbox-unselected-pressed-icon-color:rgba(255, 255, 255, 0.54)}body.dark-mode .mat-mdc-list-option.mat-warn .mdc-list-item__start,body.dark-mode .mat-mdc-list-option.mat-warn .mdc-list-item__end{--mdc-radio-disabled-selected-icon-color:#fff;--mdc-radio-disabled-unselected-icon-color:#fff;--mdc-radio-unselected-focus-icon-color:#eeeeee;--mdc-radio-unselected-hover-icon-color:#eeeeee;--mdc-radio-unselected-icon-color:rgba(255, 255, 255, 0.54);--mdc-radio-unselected-pressed-icon-color:rgba(255, 255, 255, 0.54);--mdc-radio-selected-focus-icon-color:#f44336;--mdc-radio-selected-hover-icon-color:#f44336;--mdc-radio-selected-icon-color:#f44336;--mdc-radio-selected-pressed-icon-color:#f44336;--mat-mdc-radio-ripple-color: #fff;--mat-mdc-radio-checked-ripple-color: #f44336}body.dark-mode .mat-mdc-list-option.mat-warn .mdc-list-item__start .mdc-radio--disabled+label,body.dark-mode .mat-mdc-list-option.mat-warn .mdc-list-item__end .mdc-radio--disabled+label{color:#616161}body.dark-mode .mat-mdc-list-base.mat-mdc-list-base .mdc-list-item--selected .mdc-list-item__primary-text,body.dark-mode .mat-mdc-list-base.mat-mdc-list-base .mdc-list-item--activated .mdc-list-item__primary-text{color:#ef6c00}body.dark-mode .mat-mdc-list-base.mat-mdc-list-base .mdc-list-item--selected.mdc-list-item--with-leading-icon .mdc-list-item__start,body.dark-mode .mat-mdc-list-base.mat-mdc-list-base .mdc-list-item--activated.mdc-list-item--with-leading-icon .mdc-list-item__start{color:#ef6c00}body.dark-mode .mat-mdc-list-base .mdc-list-item--disabled .mdc-list-item__start,body.dark-mode .mat-mdc-list-base .mdc-list-item--disabled .mdc-list-item__content,body.dark-mode .mat-mdc-list-base .mdc-list-item--disabled .mdc-list-item__end{opacity:1}body.dark-mode .mat-mdc-list-base{--mdc-list-list-item-one-line-container-height:48px;--mdc-list-list-item-two-line-container-height:64px;--mdc-list-list-item-three-line-container-height:88px}body.dark-mode .mat-mdc-list-item.mdc-list-item--with-leading-avatar.mdc-list-item--with-one-line,body.dark-mode .mat-mdc-list-item.mdc-list-item--with-leading-checkbox.mdc-list-item--with-one-line,body.dark-mode .mat-mdc-list-item.mdc-list-item--with-leading-icon.mdc-list-item--with-one-line{height:56px}body.dark-mode .mat-mdc-list-item.mdc-list-item--with-leading-avatar.mdc-list-item--with-two-lines,body.dark-mode .mat-mdc-list-item.mdc-list-item--with-leading-checkbox.mdc-list-item--with-two-lines,body.dark-mode .mat-mdc-list-item.mdc-list-item--with-leading-icon.mdc-list-item--with-two-lines{height:72px}body.dark-mode .mat-mdc-paginator{background:#424242;color:rgba(255,255,255,.87)}body.dark-mode .mat-mdc-paginator-icon{fill:rgba(255,255,255,.54)}body.dark-mode .mat-mdc-paginator-decrement,body.dark-mode .mat-mdc-paginator-increment{border-top:2px solid rgba(255,255,255,.54);border-right:2px solid rgba(255,255,255,.54)}body.dark-mode .mat-mdc-paginator-first,body.dark-mode .mat-mdc-paginator-last{border-top:2px solid rgba(255,255,255,.54)}body.dark-mode .mat-mdc-icon-button[disabled] .mat-mdc-paginator-decrement,body.dark-mode .mat-mdc-icon-button[disabled] .mat-mdc-paginator-increment,body.dark-mode .mat-mdc-icon-button[disabled] .mat-mdc-paginator-first,body.dark-mode .mat-mdc-icon-button[disabled] .mat-mdc-paginator-last{border-color:rgba(255,255,255,.12)}body.dark-mode .mat-mdc-icon-button[disabled] .mat-mdc-paginator-icon{fill:rgba(255,255,255,.12)}body.dark-mode .mat-mdc-paginator .mat-mdc-form-field-infix{min-height:40px}body.dark-mode .mat-mdc-paginator .mat-mdc-text-field-wrapper .mat-mdc-form-field-flex .mat-mdc-floating-label{top:20px}body.dark-mode .mat-mdc-paginator .mat-mdc-text-field-wrapper.mdc-text-field--outlined .mdc-notched-outline--upgraded .mdc-floating-label--float-above{--mat-mdc-form-field-label-transform: translateY( -26.75px) scale(var(--mat-mdc-form-field-floating-label-scale, 0.75));transform:var(--mat-mdc-form-field-label-transform)}body.dark-mode .mat-mdc-paginator .mat-mdc-text-field-wrapper.mdc-text-field--outlined .mat-mdc-form-field-infix{padding-top:8px;padding-bottom:8px}body.dark-mode .mat-mdc-paginator .mat-mdc-text-field-wrapper:not(.mdc-text-field--outlined) .mat-mdc-form-field-infix{padding-top:8px;padding-bottom:8px}body.dark-mode .mat-mdc-paginator .mdc-text-field--no-label:not(.mdc-text-field--outlined):not(.mdc-text-field--textarea) .mat-mdc-form-field-infix{padding-top:8px;padding-bottom:8px}body.dark-mode .mat-mdc-paginator .mat-mdc-text-field-wrapper:not(.mdc-text-field--outlined) .mat-mdc-floating-label{display:none}body.dark-mode .mat-mdc-paginator-container{min-height:56px}body.dark-mode .mat-mdc-tab,body.dark-mode .mat-mdc-tab-link{background-color:rgba(0,0,0,0)}body.dark-mode .mat-mdc-tab .mdc-tab__text-label,body.dark-mode .mat-mdc-tab-link .mdc-tab__text-label{color:rgba(255, 255, 255, 0.6)}body.dark-mode .mat-mdc-tab.mat-mdc-tab-disabled .mdc-tab__ripple::before,body.dark-mode .mat-mdc-tab.mat-mdc-tab-disabled .mat-ripple-element,body.dark-mode .mat-mdc-tab-link.mat-mdc-tab-disabled .mdc-tab__ripple::before,body.dark-mode .mat-mdc-tab-link.mat-mdc-tab-disabled .mat-ripple-element{background-color:rgba(255,255,255,.5)}body.dark-mode .mat-mdc-tab:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label,body.dark-mode .mat-mdc-tab-link:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label{color:#ef6c00}body.dark-mode .mat-mdc-tab:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline,body.dark-mode .mat-mdc-tab-link:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline{border-color:var(--mdc-tab-indicator-active-indicator-color, #ef6c00)}body.dark-mode .mdc-tab__ripple::before,body.dark-mode .mat-mdc-tab .mat-ripple-element,body.dark-mode .mat-mdc-tab-header-pagination .mat-ripple-element,body.dark-mode .mat-mdc-tab-link .mat-ripple-element{background-color:#ef6c00}body.dark-mode .mat-mdc-tab-group.mat-accent .mat-mdc-tab:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label,body.dark-mode .mat-mdc-tab-group.mat-accent .mat-mdc-tab-link:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label,body.dark-mode .mat-mdc-tab-nav-bar.mat-accent .mat-mdc-tab:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label,body.dark-mode .mat-mdc-tab-nav-bar.mat-accent .mat-mdc-tab-link:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label{color:#ef6c00}body.dark-mode .mat-mdc-tab-group.mat-accent .mat-mdc-tab:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline,body.dark-mode .mat-mdc-tab-group.mat-accent .mat-mdc-tab-link:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline,body.dark-mode .mat-mdc-tab-nav-bar.mat-accent .mat-mdc-tab:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline,body.dark-mode .mat-mdc-tab-nav-bar.mat-accent .mat-mdc-tab-link:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline{border-color:var(--mdc-tab-indicator-active-indicator-color, #ef6c00)}body.dark-mode .mat-mdc-tab-group.mat-accent .mdc-tab__ripple::before,body.dark-mode .mat-mdc-tab-group.mat-accent .mat-mdc-tab .mat-ripple-element,body.dark-mode .mat-mdc-tab-group.mat-accent .mat-mdc-tab-header-pagination .mat-ripple-element,body.dark-mode .mat-mdc-tab-group.mat-accent .mat-mdc-tab-link .mat-ripple-element,body.dark-mode .mat-mdc-tab-nav-bar.mat-accent .mdc-tab__ripple::before,body.dark-mode .mat-mdc-tab-nav-bar.mat-accent .mat-mdc-tab .mat-ripple-element,body.dark-mode .mat-mdc-tab-nav-bar.mat-accent .mat-mdc-tab-header-pagination .mat-ripple-element,body.dark-mode .mat-mdc-tab-nav-bar.mat-accent .mat-mdc-tab-link .mat-ripple-element{background-color:#ef6c00}body.dark-mode .mat-mdc-tab-group.mat-warn .mat-mdc-tab:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label,body.dark-mode .mat-mdc-tab-group.mat-warn .mat-mdc-tab-link:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label,body.dark-mode .mat-mdc-tab-nav-bar.mat-warn .mat-mdc-tab:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label,body.dark-mode .mat-mdc-tab-nav-bar.mat-warn .mat-mdc-tab-link:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label{color:#f44336}body.dark-mode .mat-mdc-tab-group.mat-warn .mat-mdc-tab:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline,body.dark-mode .mat-mdc-tab-group.mat-warn .mat-mdc-tab-link:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline,body.dark-mode .mat-mdc-tab-nav-bar.mat-warn .mat-mdc-tab:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline,body.dark-mode .mat-mdc-tab-nav-bar.mat-warn .mat-mdc-tab-link:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline{border-color:var(--mdc-tab-indicator-active-indicator-color, #f44336)}body.dark-mode .mat-mdc-tab-group.mat-warn .mdc-tab__ripple::before,body.dark-mode .mat-mdc-tab-group.mat-warn .mat-mdc-tab .mat-ripple-element,body.dark-mode .mat-mdc-tab-group.mat-warn .mat-mdc-tab-header-pagination .mat-ripple-element,body.dark-mode .mat-mdc-tab-group.mat-warn .mat-mdc-tab-link .mat-ripple-element,body.dark-mode .mat-mdc-tab-nav-bar.mat-warn .mdc-tab__ripple::before,body.dark-mode .mat-mdc-tab-nav-bar.mat-warn .mat-mdc-tab .mat-ripple-element,body.dark-mode .mat-mdc-tab-nav-bar.mat-warn .mat-mdc-tab-header-pagination .mat-ripple-element,body.dark-mode .mat-mdc-tab-nav-bar.mat-warn .mat-mdc-tab-link .mat-ripple-element{background-color:#f44336}body.dark-mode .mat-mdc-tab-group.mat-background-primary,body.dark-mode .mat-mdc-tab-nav-bar.mat-background-primary{--mat-mdc-tab-header-with-background-background-color: #ef6c00;--mat-mdc-tab-header-with-background-foreground-color: #000}body.dark-mode .mat-mdc-tab-group.mat-background-accent,body.dark-mode .mat-mdc-tab-nav-bar.mat-background-accent{--mat-mdc-tab-header-with-background-background-color: #ef6c00;--mat-mdc-tab-header-with-background-foreground-color: #000}body.dark-mode .mat-mdc-tab-group.mat-background-warn,body.dark-mode .mat-mdc-tab-nav-bar.mat-background-warn{--mat-mdc-tab-header-with-background-background-color: #f44336;--mat-mdc-tab-header-with-background-foreground-color: #fff}body.dark-mode .mat-mdc-tab-header-pagination-chevron{border-color:var(--mdc-theme-on-surface, #fff)}body.dark-mode .mat-mdc-tab-header .mdc-tab{height:48px}body.dark-mode .mat-mdc-checkbox .mdc-form-field{color:var(--mdc-theme-text-primary-on-background, white)}body.dark-mode .mat-mdc-checkbox .mat-ripple-element{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-mdc-checkbox .mdc-checkbox__ripple{background:#fff}body.dark-mode .mat-mdc-checkbox.mat-primary{--mdc-checkbox-selected-checkmark-color:#000;--mdc-checkbox-selected-focus-icon-color:#ef6c00;--mdc-checkbox-selected-hover-icon-color:#ef6c00;--mdc-checkbox-selected-icon-color:#ef6c00;--mdc-checkbox-selected-pressed-icon-color:#ef6c00;--mdc-checkbox-unselected-focus-icon-color:#eeeeee;--mdc-checkbox-unselected-hover-icon-color:#eeeeee;--mdc-checkbox-disabled-selected-icon-color:rgba(255, 255, 255, 0.38);--mdc-checkbox-disabled-unselected-icon-color:rgba(255, 255, 255, 0.38);--mdc-checkbox-unselected-icon-color:rgba(255, 255, 255, 0.54);--mdc-checkbox-unselected-pressed-icon-color:rgba(255, 255, 255, 0.54)}body.dark-mode .mat-mdc-checkbox.mat-primary .mdc-checkbox--selected~.mat-mdc-checkbox-ripple .mat-ripple-element{background-color:rgba(239,108,0,.1)}body.dark-mode .mat-mdc-checkbox.mat-primary .mdc-checkbox--selected~.mdc-checkbox__ripple{background:#ef6c00}body.dark-mode .mat-mdc-checkbox.mat-accent{--mdc-checkbox-selected-checkmark-color:#000;--mdc-checkbox-selected-focus-icon-color:#ef6c00;--mdc-checkbox-selected-hover-icon-color:#ef6c00;--mdc-checkbox-selected-icon-color:#ef6c00;--mdc-checkbox-selected-pressed-icon-color:#ef6c00;--mdc-checkbox-unselected-focus-icon-color:#eeeeee;--mdc-checkbox-unselected-hover-icon-color:#eeeeee;--mdc-checkbox-disabled-selected-icon-color:rgba(255, 255, 255, 0.38);--mdc-checkbox-disabled-unselected-icon-color:rgba(255, 255, 255, 0.38);--mdc-checkbox-unselected-icon-color:rgba(255, 255, 255, 0.54);--mdc-checkbox-unselected-pressed-icon-color:rgba(255, 255, 255, 0.54)}body.dark-mode .mat-mdc-checkbox.mat-accent .mdc-checkbox--selected~.mat-mdc-checkbox-ripple .mat-ripple-element{background-color:rgba(239,108,0,.1)}body.dark-mode .mat-mdc-checkbox.mat-accent .mdc-checkbox--selected~.mdc-checkbox__ripple{background:#ef6c00}body.dark-mode .mat-mdc-checkbox.mat-warn{--mdc-checkbox-selected-checkmark-color:#fff;--mdc-checkbox-selected-focus-icon-color:#f44336;--mdc-checkbox-selected-hover-icon-color:#f44336;--mdc-checkbox-selected-icon-color:#f44336;--mdc-checkbox-selected-pressed-icon-color:#f44336;--mdc-checkbox-unselected-focus-icon-color:#eeeeee;--mdc-checkbox-unselected-hover-icon-color:#eeeeee;--mdc-checkbox-disabled-selected-icon-color:rgba(255, 255, 255, 0.38);--mdc-checkbox-disabled-unselected-icon-color:rgba(255, 255, 255, 0.38);--mdc-checkbox-unselected-icon-color:rgba(255, 255, 255, 0.54);--mdc-checkbox-unselected-pressed-icon-color:rgba(255, 255, 255, 0.54)}body.dark-mode .mat-mdc-checkbox.mat-warn .mdc-checkbox--selected~.mat-mdc-checkbox-ripple .mat-ripple-element{background-color:rgba(244,67,54,.1)}body.dark-mode .mat-mdc-checkbox.mat-warn .mdc-checkbox--selected~.mdc-checkbox__ripple{background:#f44336}body.dark-mode .mat-mdc-checkbox-disabled label{color:#616161}body.dark-mode .mat-mdc-checkbox .mdc-checkbox{padding:calc((var(--mdc-checkbox-ripple-size, 40px) - 18px) / 2);margin:calc((var(--mdc-checkbox-touch-target-size, 40px) - 40px) / 2)}body.dark-mode .mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__background{top:calc((var(--mdc-checkbox-ripple-size, 40px) - 18px) / 2);left:calc((var(--mdc-checkbox-ripple-size, 40px) - 18px) / 2)}body.dark-mode .mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__native-control{top:calc((40px - var(--mdc-checkbox-touch-target-size, 40px)) / 2);right:calc((40px - var(--mdc-checkbox-touch-target-size, 40px)) / 2);left:calc((40px - var(--mdc-checkbox-touch-target-size, 40px)) / 2);width:var(--mdc-checkbox-touch-target-size, 40px);height:var(--mdc-checkbox-touch-target-size, 40px)}body.dark-mode .mat-mdc-button.mat-unthemed{--mdc-text-button-label-text-color:#fff}body.dark-mode .mat-mdc-button.mat-primary{--mdc-text-button-label-text-color:#ef6c00}body.dark-mode .mat-mdc-button.mat-accent{--mdc-text-button-label-text-color:#ef6c00}body.dark-mode .mat-mdc-button.mat-warn{--mdc-text-button-label-text-color:#f44336}body.dark-mode .mat-mdc-button[disabled][disabled]{--mdc-text-button-disabled-label-text-color:rgba(255, 255, 255, 0.5);--mdc-text-button-label-text-color:rgba(255, 255, 255, 0.5)}body.dark-mode .mat-mdc-unelevated-button.mat-unthemed{--mdc-filled-button-container-color:#424242;--mdc-filled-button-label-text-color:#fff}body.dark-mode .mat-mdc-unelevated-button.mat-primary{--mdc-filled-button-container-color:#ef6c00;--mdc-filled-button-label-text-color:#000}body.dark-mode .mat-mdc-unelevated-button.mat-accent{--mdc-filled-button-container-color:#ef6c00;--mdc-filled-button-label-text-color:#000}body.dark-mode .mat-mdc-unelevated-button.mat-warn{--mdc-filled-button-container-color:#f44336;--mdc-filled-button-label-text-color:#fff}body.dark-mode .mat-mdc-unelevated-button[disabled][disabled]{--mdc-filled-button-disabled-container-color:rgba(255, 255, 255, 0.12);--mdc-filled-button-disabled-label-text-color:rgba(255, 255, 255, 0.5);--mdc-filled-button-container-color:rgba(255, 255, 255, 0.12);--mdc-filled-button-label-text-color:rgba(255, 255, 255, 0.5)}body.dark-mode .mat-mdc-raised-button.mat-unthemed{--mdc-protected-button-container-color:#424242;--mdc-protected-button-label-text-color:#fff}body.dark-mode .mat-mdc-raised-button.mat-primary{--mdc-protected-button-container-color:#ef6c00;--mdc-protected-button-label-text-color:#000}body.dark-mode .mat-mdc-raised-button.mat-accent{--mdc-protected-button-container-color:#ef6c00;--mdc-protected-button-label-text-color:#000}body.dark-mode .mat-mdc-raised-button.mat-warn{--mdc-protected-button-container-color:#f44336;--mdc-protected-button-label-text-color:#fff}body.dark-mode .mat-mdc-raised-button[disabled][disabled]{--mdc-protected-button-disabled-container-color:rgba(255, 255, 255, 0.12);--mdc-protected-button-disabled-label-text-color:rgba(255, 255, 255, 0.5);--mdc-protected-button-container-color:rgba(255, 255, 255, 0.12);--mdc-protected-button-label-text-color:rgba(255, 255, 255, 0.5);--mdc-protected-button-container-elevation:0}body.dark-mode .mat-mdc-outlined-button{--mdc-outlined-button-outline-color:rgba(255, 255, 255, 0.12)}body.dark-mode .mat-mdc-outlined-button.mat-unthemed{--mdc-outlined-button-label-text-color:#fff}body.dark-mode .mat-mdc-outlined-button.mat-primary{--mdc-outlined-button-label-text-color:#ef6c00}body.dark-mode .mat-mdc-outlined-button.mat-accent{--mdc-outlined-button-label-text-color:#ef6c00}body.dark-mode .mat-mdc-outlined-button.mat-warn{--mdc-outlined-button-label-text-color:#f44336}body.dark-mode .mat-mdc-outlined-button[disabled][disabled]{--mdc-outlined-button-label-text-color:rgba(255, 255, 255, 0.5);--mdc-outlined-button-disabled-label-text-color:rgba(255, 255, 255, 0.5);--mdc-outlined-button-outline-color:rgba(255, 255, 255, 0.12);--mdc-outlined-button-disabled-outline-color:rgba(255, 255, 255, 0.12)}body.dark-mode .mat-mdc-button,body.dark-mode .mat-mdc-outlined-button{--mat-mdc-button-persistent-ripple-color: #fff;--mat-mdc-button-ripple-color: rgba(255, 255, 255, 0.1)}body.dark-mode .mat-mdc-button:hover .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-mdc-outlined-button:hover .mat-mdc-button-persistent-ripple::before{opacity:.08}body.dark-mode .mat-mdc-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-mdc-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-mdc-outlined-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-mdc-outlined-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before{opacity:.24}body.dark-mode .mat-mdc-button:active .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-mdc-outlined-button:active .mat-mdc-button-persistent-ripple::before{opacity:.24}body.dark-mode .mat-mdc-button.mat-primary,body.dark-mode .mat-mdc-outlined-button.mat-primary{--mat-mdc-button-persistent-ripple-color: #ef6c00;--mat-mdc-button-ripple-color: rgba(239, 108, 0, 0.1)}body.dark-mode .mat-mdc-button.mat-accent,body.dark-mode .mat-mdc-outlined-button.mat-accent{--mat-mdc-button-persistent-ripple-color: #ef6c00;--mat-mdc-button-ripple-color: rgba(239, 108, 0, 0.1)}body.dark-mode .mat-mdc-button.mat-warn,body.dark-mode .mat-mdc-outlined-button.mat-warn{--mat-mdc-button-persistent-ripple-color: #f44336;--mat-mdc-button-ripple-color: rgba(244, 67, 54, 0.1)}body.dark-mode .mat-mdc-raised-button,body.dark-mode .mat-mdc-unelevated-button{--mat-mdc-button-persistent-ripple-color: #fff;--mat-mdc-button-ripple-color: rgba(255, 255, 255, 0.1)}body.dark-mode .mat-mdc-raised-button:hover .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-mdc-unelevated-button:hover .mat-mdc-button-persistent-ripple::before{opacity:.08}body.dark-mode .mat-mdc-raised-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-mdc-raised-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-mdc-unelevated-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-mdc-unelevated-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before{opacity:.24}body.dark-mode .mat-mdc-raised-button:active .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-mdc-unelevated-button:active .mat-mdc-button-persistent-ripple::before{opacity:.24}body.dark-mode .mat-mdc-raised-button.mat-primary,body.dark-mode .mat-mdc-unelevated-button.mat-primary{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}body.dark-mode .mat-mdc-raised-button.mat-accent,body.dark-mode .mat-mdc-unelevated-button.mat-accent{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}body.dark-mode .mat-mdc-raised-button.mat-warn,body.dark-mode .mat-mdc-unelevated-button.mat-warn{--mat-mdc-button-persistent-ripple-color: #fff;--mat-mdc-button-ripple-color: rgba(255, 255, 255, 0.1)}body.dark-mode .mat-mdc-button.mat-mdc-button-base,body.dark-mode .mat-mdc-raised-button.mat-mdc-button-base,body.dark-mode .mat-mdc-unelevated-button.mat-mdc-button-base,body.dark-mode .mat-mdc-outlined-button.mat-mdc-button-base{height:36px}body.dark-mode .mat-mdc-icon-button{--mat-mdc-button-persistent-ripple-color: #fff;--mat-mdc-button-ripple-color: rgba(255, 255, 255, 0.1)}body.dark-mode .mat-mdc-icon-button:hover .mat-mdc-button-persistent-ripple::before{opacity:.08}body.dark-mode .mat-mdc-icon-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-mdc-icon-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before{opacity:.24}body.dark-mode .mat-mdc-icon-button:active .mat-mdc-button-persistent-ripple::before{opacity:.24}body.dark-mode .mat-mdc-icon-button.mat-primary{--mat-mdc-button-persistent-ripple-color: #ef6c00;--mat-mdc-button-ripple-color: rgba(239, 108, 0, 0.1)}body.dark-mode .mat-mdc-icon-button.mat-accent{--mat-mdc-button-persistent-ripple-color: #ef6c00;--mat-mdc-button-ripple-color: rgba(239, 108, 0, 0.1)}body.dark-mode .mat-mdc-icon-button.mat-warn{--mat-mdc-button-persistent-ripple-color: #f44336;--mat-mdc-button-ripple-color: rgba(244, 67, 54, 0.1)}body.dark-mode .mat-mdc-icon-button.mat-primary{--mdc-icon-button-icon-color:#ef6c00}body.dark-mode .mat-mdc-icon-button.mat-accent{--mdc-icon-button-icon-color:#ef6c00}body.dark-mode .mat-mdc-icon-button.mat-warn{--mdc-icon-button-icon-color:#f44336}body.dark-mode .mat-mdc-icon-button[disabled][disabled]{--mdc-icon-button-icon-color:rgba(255, 255, 255, 0.5);--mdc-icon-button-disabled-icon-color:rgba(255, 255, 255, 0.5)}body.dark-mode .mat-mdc-icon-button.mat-mdc-button-base{width:48px;height:48px;padding:12px}body.dark-mode .mat-mdc-icon-button.mat-mdc-button-base .mdc-icon-button__focus-ring{max-height:48px;max-width:48px}body.dark-mode .mat-mdc-icon-button.mat-mdc-button-base.mdc-icon-button--reduced-size .mdc-icon-button__ripple{width:40px;height:40px;margin-top:4px;margin-bottom:4px;margin-right:4px;margin-left:4px}body.dark-mode .mat-mdc-icon-button.mat-mdc-button-base.mdc-icon-button--reduced-size .mdc-icon-button__focus-ring{max-height:40px;max-width:40px}body.dark-mode .mat-mdc-icon-button.mat-mdc-button-base .mdc-icon-button__touch{position:absolute;top:50%;height:48px;left:50%;width:48px;transform:translate(-50%, -50%)}body.dark-mode .mat-mdc-fab,body.dark-mode .mat-mdc-mini-fab{--mat-mdc-button-persistent-ripple-color: #fff;--mat-mdc-button-ripple-color: rgba(255, 255, 255, 0.1)}body.dark-mode .mat-mdc-fab:hover .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-mdc-mini-fab:hover .mat-mdc-button-persistent-ripple::before{opacity:.08}body.dark-mode .mat-mdc-fab.cdk-program-focused .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-mdc-fab.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-mdc-mini-fab.cdk-program-focused .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-mdc-mini-fab.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before{opacity:.24}body.dark-mode .mat-mdc-fab:active .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-mdc-mini-fab:active .mat-mdc-button-persistent-ripple::before{opacity:.24}body.dark-mode .mat-mdc-fab.mat-primary,body.dark-mode .mat-mdc-mini-fab.mat-primary{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}body.dark-mode .mat-mdc-fab.mat-accent,body.dark-mode .mat-mdc-mini-fab.mat-accent{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}body.dark-mode .mat-mdc-fab.mat-warn,body.dark-mode .mat-mdc-mini-fab.mat-warn{--mat-mdc-button-persistent-ripple-color: #fff;--mat-mdc-button-ripple-color: rgba(255, 255, 255, 0.1)}body.dark-mode .mat-mdc-fab.mat-unthemed,body.dark-mode .mat-mdc-mini-fab.mat-unthemed{--mdc-fab-container-color:#424242;--mdc-fab-icon-color:#fff;--mat-mdc-fab-color: #fff}body.dark-mode .mat-mdc-fab.mat-primary,body.dark-mode .mat-mdc-mini-fab.mat-primary{--mdc-fab-container-color:#ef6c00;--mdc-fab-icon-color:#000;--mat-mdc-fab-color: #000}body.dark-mode .mat-mdc-fab.mat-accent,body.dark-mode .mat-mdc-mini-fab.mat-accent{--mdc-fab-container-color:#ef6c00;--mdc-fab-icon-color:#000;--mat-mdc-fab-color: #000}body.dark-mode .mat-mdc-fab.mat-warn,body.dark-mode .mat-mdc-mini-fab.mat-warn{--mdc-fab-container-color:#f44336;--mdc-fab-icon-color:#fff;--mat-mdc-fab-color: #fff}body.dark-mode .mat-mdc-fab[disabled][disabled],body.dark-mode .mat-mdc-mini-fab[disabled][disabled]{--mdc-fab-container-color:rgba(255, 255, 255, 0.12);--mdc-fab-icon-color:rgba(255, 255, 255, 0.5);--mat-mdc-fab-color: rgba(255, 255, 255, 0.5)}body.dark-mode .mat-mdc-snack-bar-container{--mat-mdc-snack-bar-button-color: rgba(0, 0, 0, 0.87);--mdc-snackbar-container-color:#d9d9d9;--mdc-snackbar-supporting-text-color:rgba(66, 66, 66, 0.87)}body.dark-mode .mdc-data-table{background-color:var(--mdc-theme-surface, #424242);border-color:rgba(255, 255, 255, 0.12)}body.dark-mode .mdc-data-table__row{background-color:inherit}body.dark-mode .mdc-data-table__header-cell{background-color:var(--mdc-theme-surface, #424242)}body.dark-mode .mdc-data-table__row--selected{background-color:rgba(239, 108, 0, 0.04)}body.dark-mode .mdc-data-table__pagination-rows-per-page-select--outlined:not(.mdc-select--disabled) .mdc-notched-outline__leading,body.dark-mode .mdc-data-table__pagination-rows-per-page-select--outlined:not(.mdc-select--disabled) .mdc-notched-outline__notch,body.dark-mode .mdc-data-table__pagination-rows-per-page-select--outlined:not(.mdc-select--disabled) .mdc-notched-outline__trailing{border-color:rgba(255, 255, 255, 0.12)}body.dark-mode .mdc-data-table__cell,body.dark-mode .mdc-data-table__header-cell{border-bottom-color:rgba(255, 255, 255, 0.12)}body.dark-mode .mdc-data-table__pagination{border-top-color:rgba(255, 255, 255, 0.12)}body.dark-mode .mdc-data-table__row:not(.mdc-data-table__row--selected):hover{background-color:rgba(255, 255, 255, 0.04)}body.dark-mode .mdc-data-table__header-cell{color:rgba(255, 255, 255, 0.87)}body.dark-mode .mdc-data-table__pagination-total,body.dark-mode .mdc-data-table__pagination-rows-per-page-label,body.dark-mode .mdc-data-table__cell{color:rgba(255, 255, 255, 0.87)}body.dark-mode .mat-mdc-table{background:#424242}body.dark-mode .mat-mdc-table .mdc-data-table__row{height:52px}body.dark-mode .mat-mdc-table .mdc-data-table__pagination{min-height:52px}body.dark-mode .mat-mdc-table .mdc-data-table__header-row{height:56px}body.dark-mode .mat-mdc-progress-spinner{--mdc-circular-progress-active-indicator-color:#ef6c00}body.dark-mode .mat-mdc-progress-spinner.mat-accent{--mdc-circular-progress-active-indicator-color:#ef6c00}body.dark-mode .mat-mdc-progress-spinner.mat-warn{--mdc-circular-progress-active-indicator-color:#f44336}body.dark-mode .mat-badge-content{color:#fff;background:#ef6c00}.cdk-high-contrast-active body.dark-mode .mat-badge-content{outline:solid 1px;border-radius:0}body.dark-mode .mat-badge-accent .mat-badge-content{background:#ef6c00;color:#fff}body.dark-mode .mat-badge-warn .mat-badge-content{color:#fff;background:#f44336}body.dark-mode .mat-badge-disabled .mat-badge-content{background:#6e6e6e;color:#616161}body.dark-mode .mat-bottom-sheet-container{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2), 0px 16px 24px 2px rgba(0, 0, 0, 0.14), 0px 6px 30px 5px rgba(0, 0, 0, 0.12);background:#424242;color:#fff}body.dark-mode .mat-button-toggle-standalone:not([class*=mat-elevation-z]),body.dark-mode .mat-button-toggle-group:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2), 0px 2px 2px 0px rgba(0, 0, 0, 0.14), 0px 1px 5px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-button-toggle-standalone.mat-button-toggle-appearance-standard:not([class*=mat-elevation-z]),body.dark-mode .mat-button-toggle-group-appearance-standard:not([class*=mat-elevation-z]){box-shadow:none}body.dark-mode .mat-button-toggle{color:rgba(255,255,255,.5)}body.dark-mode .mat-button-toggle .mat-button-toggle-focus-overlay{background-color:rgba(255,255,255,.12)}body.dark-mode .mat-button-toggle-appearance-standard{color:#fff;background:#424242}body.dark-mode .mat-button-toggle-appearance-standard .mat-button-toggle-focus-overlay{background-color:#fff}body.dark-mode .mat-button-toggle-group-appearance-standard .mat-button-toggle+.mat-button-toggle{border-left:solid 1px #595959}body.dark-mode [dir=rtl] .mat-button-toggle-group-appearance-standard .mat-button-toggle+.mat-button-toggle{border-left:none;border-right:solid 1px #595959}body.dark-mode .mat-button-toggle-group-appearance-standard.mat-button-toggle-vertical .mat-button-toggle+.mat-button-toggle{border-left:none;border-right:none;border-top:solid 1px #595959}body.dark-mode .mat-button-toggle-checked{background-color:#212121;color:rgba(255,255,255,.7)}body.dark-mode .mat-button-toggle-checked.mat-button-toggle-appearance-standard{color:#fff}body.dark-mode .mat-button-toggle-disabled{color:rgba(255,255,255,.3);background-color:#000}body.dark-mode .mat-button-toggle-disabled.mat-button-toggle-appearance-standard{background:#424242}body.dark-mode .mat-button-toggle-disabled.mat-button-toggle-checked{background-color:#424242}body.dark-mode .mat-button-toggle-standalone.mat-button-toggle-appearance-standard,body.dark-mode .mat-button-toggle-group-appearance-standard{border:solid 1px #595959}body.dark-mode .mat-button-toggle-appearance-standard .mat-button-toggle-label-content{line-height:48px}body.dark-mode .mat-calendar-arrow{fill:#fff}body.dark-mode .mat-datepicker-toggle,body.dark-mode .mat-datepicker-content .mat-calendar-next-button,body.dark-mode .mat-datepicker-content .mat-calendar-previous-button{color:#fff}body.dark-mode .mat-calendar-table-header-divider::after{background:rgba(255,255,255,.12)}body.dark-mode .mat-calendar-table-header,body.dark-mode .mat-calendar-body-label{color:rgba(255,255,255,.7)}body.dark-mode .mat-calendar-body-cell-content,body.dark-mode .mat-date-range-input-separator{color:#fff;border-color:rgba(0,0,0,0)}body.dark-mode .mat-calendar-body-disabled>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){color:#616161}body.dark-mode .mat-form-field-disabled .mat-date-range-input-separator{color:#616161}body.dark-mode .mat-calendar-body-in-preview{color:rgba(255,255,255,.24)}body.dark-mode .mat-calendar-body-today:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(255,255,255,.5)}body.dark-mode .mat-calendar-body-disabled>.mat-calendar-body-today:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(255,255,255,.3)}body.dark-mode .mat-calendar-body-in-range::before{background:rgba(239,108,0,.2)}body.dark-mode .mat-calendar-body-comparison-identical,body.dark-mode .mat-calendar-body-in-comparison-range::before{background:rgba(249,171,0,.2)}body.dark-mode .mat-calendar-body-comparison-bridge-start::before,body.dark-mode [dir=rtl] .mat-calendar-body-comparison-bridge-end::before{background:linear-gradient(to right, rgba(239, 108, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}body.dark-mode .mat-calendar-body-comparison-bridge-end::before,body.dark-mode [dir=rtl] .mat-calendar-body-comparison-bridge-start::before{background:linear-gradient(to left, rgba(239, 108, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}body.dark-mode .mat-calendar-body-in-range>.mat-calendar-body-comparison-identical,body.dark-mode .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range::after{background:#a8dab5}body.dark-mode .mat-calendar-body-comparison-identical.mat-calendar-body-selected,body.dark-mode .mat-calendar-body-in-comparison-range>.mat-calendar-body-selected{background:#46a35e}body.dark-mode .mat-calendar-body-selected{background-color:#ef6c00;color:#fff}body.dark-mode .mat-calendar-body-disabled>.mat-calendar-body-selected{background-color:rgba(239,108,0,.4)}body.dark-mode .mat-calendar-body-today.mat-calendar-body-selected{box-shadow:inset 0 0 0 1px #fff}body.dark-mode .cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical),body.dark-mode .cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(239,108,0,.3)}@media(hover: hover){body.dark-mode .mat-calendar-body-cell:not(.mat-calendar-body-disabled):hover>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(239,108,0,.3)}}body.dark-mode .mat-datepicker-content{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2), 0px 4px 5px 0px rgba(0, 0, 0, 0.14), 0px 1px 10px 0px rgba(0, 0, 0, 0.12);background-color:#424242;color:#fff}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-in-range::before{background:rgba(239,108,0,.2)}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-comparison-identical,body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-in-comparison-range::before{background:rgba(249,171,0,.2)}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-comparison-bridge-start::before,body.dark-mode .mat-datepicker-content.mat-accent [dir=rtl] .mat-calendar-body-comparison-bridge-end::before{background:linear-gradient(to right, rgba(239, 108, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-comparison-bridge-end::before,body.dark-mode .mat-datepicker-content.mat-accent [dir=rtl] .mat-calendar-body-comparison-bridge-start::before{background:linear-gradient(to left, rgba(239, 108, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-in-range>.mat-calendar-body-comparison-identical,body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range::after{background:#a8dab5}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-comparison-identical.mat-calendar-body-selected,body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-in-comparison-range>.mat-calendar-body-selected{background:#46a35e}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-selected{background-color:#ef6c00;color:#fff}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-disabled>.mat-calendar-body-selected{background-color:rgba(239,108,0,.4)}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-today.mat-calendar-body-selected{box-shadow:inset 0 0 0 1px #fff}body.dark-mode .mat-datepicker-content.mat-accent .cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical),body.dark-mode .mat-datepicker-content.mat-accent .cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(239,108,0,.3)}@media(hover: hover){body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-cell:not(.mat-calendar-body-disabled):hover>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(239,108,0,.3)}}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-in-range::before{background:rgba(244,67,54,.2)}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-comparison-identical,body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-in-comparison-range::before{background:rgba(249,171,0,.2)}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-comparison-bridge-start::before,body.dark-mode .mat-datepicker-content.mat-warn [dir=rtl] .mat-calendar-body-comparison-bridge-end::before{background:linear-gradient(to right, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-comparison-bridge-end::before,body.dark-mode .mat-datepicker-content.mat-warn [dir=rtl] .mat-calendar-body-comparison-bridge-start::before{background:linear-gradient(to left, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-in-range>.mat-calendar-body-comparison-identical,body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range::after{background:#a8dab5}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-comparison-identical.mat-calendar-body-selected,body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-in-comparison-range>.mat-calendar-body-selected{background:#46a35e}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-selected{background-color:#f44336;color:#fff}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-disabled>.mat-calendar-body-selected{background-color:rgba(244,67,54,.4)}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-today.mat-calendar-body-selected{box-shadow:inset 0 0 0 1px #fff}body.dark-mode .mat-datepicker-content.mat-warn .cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical),body.dark-mode .mat-datepicker-content.mat-warn .cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(244,67,54,.3)}@media(hover: hover){body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-cell:not(.mat-calendar-body-disabled):hover>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(244,67,54,.3)}}body.dark-mode .mat-datepicker-content-touch{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2), 0px 24px 38px 3px rgba(0, 0, 0, 0.14), 0px 9px 46px 8px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-datepicker-toggle-active{color:#ef6c00}body.dark-mode .mat-datepicker-toggle-active.mat-accent{color:#ef6c00}body.dark-mode .mat-datepicker-toggle-active.mat-warn{color:#f44336}body.dark-mode .mat-date-range-input-inner[disabled]{color:#616161}body.dark-mode .mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base{width:40px;height:40px;padding:8px}body.dark-mode .mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base .mdc-icon-button__focus-ring{max-height:40px;max-width:40px}body.dark-mode .mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base.mdc-icon-button--reduced-size .mdc-icon-button__ripple{width:40px;height:40px;margin-top:0px;margin-bottom:0px;margin-right:0px;margin-left:0px}body.dark-mode .mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base.mdc-icon-button--reduced-size .mdc-icon-button__focus-ring{max-height:40px;max-width:40px}body.dark-mode .mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base .mdc-icon-button__touch{position:absolute;top:50%;height:40px;left:50%;width:40px;transform:translate(-50%, -50%)}body.dark-mode .mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base .mat-mdc-button-touch-target{display:none}body.dark-mode .mat-divider{border-top-color:rgba(255,255,255,.12)}body.dark-mode .mat-divider-vertical{border-right-color:rgba(255,255,255,.12)}body.dark-mode .mat-expansion-panel{background:#424242;color:#fff}body.dark-mode .mat-expansion-panel:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2), 0px 2px 2px 0px rgba(0, 0, 0, 0.14), 0px 1px 5px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-action-row{border-top-color:rgba(255,255,255,.12)}body.dark-mode .mat-expansion-panel .mat-expansion-panel-header.cdk-keyboard-focused:not([aria-disabled=true]),body.dark-mode .mat-expansion-panel .mat-expansion-panel-header.cdk-program-focused:not([aria-disabled=true]),body.dark-mode .mat-expansion-panel:not(.mat-expanded) .mat-expansion-panel-header:hover:not([aria-disabled=true]){background:rgba(255,255,255,.04)}@media(hover: none){body.dark-mode .mat-expansion-panel:not(.mat-expanded):not([aria-disabled=true]) .mat-expansion-panel-header:hover{background:#424242}}body.dark-mode .mat-expansion-panel-header-title{color:#fff}body.dark-mode .mat-expansion-panel-header-description,body.dark-mode .mat-expansion-indicator::after{color:rgba(255,255,255,.7)}body.dark-mode .mat-expansion-panel-header[aria-disabled=true]{color:rgba(255,255,255,.3)}body.dark-mode .mat-expansion-panel-header[aria-disabled=true] .mat-expansion-panel-header-title,body.dark-mode .mat-expansion-panel-header[aria-disabled=true] .mat-expansion-panel-header-description{color:inherit}body.dark-mode .mat-expansion-panel-header{height:48px}body.dark-mode .mat-expansion-panel-header.mat-expanded{height:64px}body.dark-mode .mat-icon.mat-primary{color:#ef6c00}body.dark-mode .mat-icon.mat-accent{color:#ef6c00}body.dark-mode .mat-icon.mat-warn{color:#f44336}body.dark-mode .mat-drawer-container{background-color:#303030;color:#fff}body.dark-mode .mat-drawer{background-color:#424242;color:#fff}body.dark-mode .mat-drawer.mat-drawer-push{background-color:#424242}body.dark-mode .mat-drawer:not(.mat-drawer-side){box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2), 0px 16px 24px 2px rgba(0, 0, 0, 0.14), 0px 6px 30px 5px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-drawer-side{border-right:solid 1px rgba(255,255,255,.12)}body.dark-mode .mat-drawer-side.mat-drawer-end{border-left:solid 1px rgba(255,255,255,.12);border-right:none}body.dark-mode [dir=rtl] .mat-drawer-side{border-left:solid 1px rgba(255,255,255,.12);border-right:none}body.dark-mode [dir=rtl] .mat-drawer-side.mat-drawer-end{border-left:none;border-right:solid 1px rgba(255,255,255,.12)}body.dark-mode .mat-drawer-backdrop.mat-drawer-shown{background-color:rgba(189,189,189,.6)}body.dark-mode .mat-step-header.cdk-keyboard-focused,body.dark-mode .mat-step-header.cdk-program-focused,body.dark-mode .mat-step-header:hover:not([aria-disabled]),body.dark-mode .mat-step-header:hover[aria-disabled=false]{background-color:rgba(255,255,255,.04)}body.dark-mode .mat-step-header:hover[aria-disabled=true]{cursor:default}@media(hover: none){body.dark-mode .mat-step-header:hover{background:none}}body.dark-mode .mat-step-header .mat-step-label,body.dark-mode .mat-step-header .mat-step-optional{color:rgba(255,255,255,.7)}body.dark-mode .mat-step-header .mat-step-icon{background-color:rgba(255,255,255,.7);color:#fff}body.dark-mode .mat-step-header .mat-step-icon-selected,body.dark-mode .mat-step-header .mat-step-icon-state-done,body.dark-mode .mat-step-header .mat-step-icon-state-edit{background-color:#ef6c00;color:#fff}body.dark-mode .mat-step-header.mat-accent .mat-step-icon{color:#fff}body.dark-mode .mat-step-header.mat-accent .mat-step-icon-selected,body.dark-mode .mat-step-header.mat-accent .mat-step-icon-state-done,body.dark-mode .mat-step-header.mat-accent .mat-step-icon-state-edit{background-color:#ef6c00;color:#fff}body.dark-mode .mat-step-header.mat-warn .mat-step-icon{color:#fff}body.dark-mode .mat-step-header.mat-warn .mat-step-icon-selected,body.dark-mode .mat-step-header.mat-warn .mat-step-icon-state-done,body.dark-mode .mat-step-header.mat-warn .mat-step-icon-state-edit{background-color:#f44336;color:#fff}body.dark-mode .mat-step-header .mat-step-icon-state-error{background-color:rgba(0,0,0,0);color:#f44336}body.dark-mode .mat-step-header .mat-step-label.mat-step-label-active{color:#fff}body.dark-mode .mat-step-header .mat-step-label.mat-step-label-error{color:#f44336}body.dark-mode .mat-stepper-horizontal,body.dark-mode .mat-stepper-vertical{background-color:#424242}body.dark-mode .mat-stepper-vertical-line::before{border-left-color:rgba(255,255,255,.12)}body.dark-mode .mat-horizontal-stepper-header::before,body.dark-mode .mat-horizontal-stepper-header::after,body.dark-mode .mat-stepper-horizontal-line{border-top-color:rgba(255,255,255,.12)}body.dark-mode .mat-horizontal-stepper-header{height:72px}body.dark-mode .mat-stepper-label-position-bottom .mat-horizontal-stepper-header,body.dark-mode .mat-vertical-stepper-header{padding:24px 24px}body.dark-mode .mat-stepper-vertical-line::before{top:-16px;bottom:-16px}body.dark-mode .mat-stepper-label-position-bottom .mat-horizontal-stepper-header::after,body.dark-mode .mat-stepper-label-position-bottom .mat-horizontal-stepper-header::before{top:36px}body.dark-mode .mat-stepper-label-position-bottom .mat-stepper-horizontal-line{top:36px}body.dark-mode .mat-sort-header-arrow{color:#c6c6c6}body.dark-mode .mat-toolbar{background:#ef6c00;color:#fff}body.dark-mode .mat-toolbar.mat-primary{background:#ef6c00;color:#fff}body.dark-mode .mat-toolbar.mat-accent{background:#ef6c00;color:#fff}body.dark-mode .mat-toolbar.mat-warn{background:#f44336;color:#fff}body.dark-mode .mat-toolbar .mat-form-field-underline,body.dark-mode .mat-toolbar .mat-form-field-ripple,body.dark-mode .mat-toolbar .mat-focused .mat-form-field-ripple{background-color:currentColor}body.dark-mode .mat-toolbar .mat-form-field-label,body.dark-mode .mat-toolbar .mat-focused .mat-form-field-label,body.dark-mode .mat-toolbar .mat-select-value,body.dark-mode .mat-toolbar .mat-select-arrow,body.dark-mode .mat-toolbar .mat-form-field.mat-focused .mat-select-arrow{color:inherit}body.dark-mode .mat-toolbar .mat-input-element{caret-color:currentColor}body.dark-mode .mat-toolbar-multiple-rows{min-height:64px}body.dark-mode .mat-toolbar-row,body.dark-mode .mat-toolbar-single-row{height:64px}@media(max-width: 599px){body.dark-mode .mat-toolbar-multiple-rows{min-height:56px}body.dark-mode .mat-toolbar-row,body.dark-mode .mat-toolbar-single-row{height:56px}}body.dark-mode .mat-tree{background:#424242}body.dark-mode .mat-tree-node,body.dark-mode .mat-nested-tree-node{color:#fff}body.dark-mode .mat-tree-node{min-height:48px}body.dark-mode .mat-button,body.dark-mode .mat-icon-button,body.dark-mode .mat-stroked-button{color:inherit;background:rgba(0,0,0,0)}body.dark-mode .mat-button.mat-primary,body.dark-mode .mat-icon-button.mat-primary,body.dark-mode .mat-stroked-button.mat-primary{color:#ef6c00}body.dark-mode .mat-button.mat-accent,body.dark-mode .mat-icon-button.mat-accent,body.dark-mode .mat-stroked-button.mat-accent{color:#ef6c00}body.dark-mode .mat-button.mat-warn,body.dark-mode .mat-icon-button.mat-warn,body.dark-mode .mat-stroked-button.mat-warn{color:#f44336}body.dark-mode .mat-button.mat-primary.mat-button-disabled,body.dark-mode .mat-button.mat-accent.mat-button-disabled,body.dark-mode .mat-button.mat-warn.mat-button-disabled,body.dark-mode .mat-button.mat-button-disabled.mat-button-disabled,body.dark-mode .mat-icon-button.mat-primary.mat-button-disabled,body.dark-mode .mat-icon-button.mat-accent.mat-button-disabled,body.dark-mode .mat-icon-button.mat-warn.mat-button-disabled,body.dark-mode .mat-icon-button.mat-button-disabled.mat-button-disabled,body.dark-mode .mat-stroked-button.mat-primary.mat-button-disabled,body.dark-mode .mat-stroked-button.mat-accent.mat-button-disabled,body.dark-mode .mat-stroked-button.mat-warn.mat-button-disabled,body.dark-mode .mat-stroked-button.mat-button-disabled.mat-button-disabled{color:rgba(255,255,255,.3)}body.dark-mode .mat-button.mat-primary .mat-button-focus-overlay,body.dark-mode .mat-icon-button.mat-primary .mat-button-focus-overlay,body.dark-mode .mat-stroked-button.mat-primary .mat-button-focus-overlay{background-color:#ef6c00}body.dark-mode .mat-button.mat-accent .mat-button-focus-overlay,body.dark-mode .mat-icon-button.mat-accent .mat-button-focus-overlay,body.dark-mode .mat-stroked-button.mat-accent .mat-button-focus-overlay{background-color:#ef6c00}body.dark-mode .mat-button.mat-warn .mat-button-focus-overlay,body.dark-mode .mat-icon-button.mat-warn .mat-button-focus-overlay,body.dark-mode .mat-stroked-button.mat-warn .mat-button-focus-overlay{background-color:#f44336}body.dark-mode .mat-button.mat-button-disabled .mat-button-focus-overlay,body.dark-mode .mat-icon-button.mat-button-disabled .mat-button-focus-overlay,body.dark-mode .mat-stroked-button.mat-button-disabled .mat-button-focus-overlay{background-color:rgba(0,0,0,0)}body.dark-mode .mat-button .mat-ripple-element,body.dark-mode .mat-icon-button .mat-ripple-element,body.dark-mode .mat-stroked-button .mat-ripple-element{opacity:.1;background-color:currentColor}body.dark-mode .mat-button-focus-overlay{background:#fff}body.dark-mode .mat-stroked-button:not(.mat-button-disabled){border-color:rgba(255,255,255,.12)}body.dark-mode .mat-flat-button,body.dark-mode .mat-raised-button,body.dark-mode .mat-fab,body.dark-mode .mat-mini-fab{color:#fff;background-color:#424242}body.dark-mode .mat-flat-button.mat-primary,body.dark-mode .mat-raised-button.mat-primary,body.dark-mode .mat-fab.mat-primary,body.dark-mode .mat-mini-fab.mat-primary{color:#fff}body.dark-mode .mat-flat-button.mat-accent,body.dark-mode .mat-raised-button.mat-accent,body.dark-mode .mat-fab.mat-accent,body.dark-mode .mat-mini-fab.mat-accent{color:#fff}body.dark-mode .mat-flat-button.mat-warn,body.dark-mode .mat-raised-button.mat-warn,body.dark-mode .mat-fab.mat-warn,body.dark-mode .mat-mini-fab.mat-warn{color:#fff}body.dark-mode .mat-flat-button.mat-primary.mat-button-disabled,body.dark-mode .mat-flat-button.mat-accent.mat-button-disabled,body.dark-mode .mat-flat-button.mat-warn.mat-button-disabled,body.dark-mode .mat-flat-button.mat-button-disabled.mat-button-disabled,body.dark-mode .mat-raised-button.mat-primary.mat-button-disabled,body.dark-mode .mat-raised-button.mat-accent.mat-button-disabled,body.dark-mode .mat-raised-button.mat-warn.mat-button-disabled,body.dark-mode .mat-raised-button.mat-button-disabled.mat-button-disabled,body.dark-mode .mat-fab.mat-primary.mat-button-disabled,body.dark-mode .mat-fab.mat-accent.mat-button-disabled,body.dark-mode .mat-fab.mat-warn.mat-button-disabled,body.dark-mode .mat-fab.mat-button-disabled.mat-button-disabled,body.dark-mode .mat-mini-fab.mat-primary.mat-button-disabled,body.dark-mode .mat-mini-fab.mat-accent.mat-button-disabled,body.dark-mode .mat-mini-fab.mat-warn.mat-button-disabled,body.dark-mode .mat-mini-fab.mat-button-disabled.mat-button-disabled{color:rgba(255,255,255,.3)}body.dark-mode .mat-flat-button.mat-primary,body.dark-mode .mat-raised-button.mat-primary,body.dark-mode .mat-fab.mat-primary,body.dark-mode .mat-mini-fab.mat-primary{background-color:#ef6c00}body.dark-mode .mat-flat-button.mat-accent,body.dark-mode .mat-raised-button.mat-accent,body.dark-mode .mat-fab.mat-accent,body.dark-mode .mat-mini-fab.mat-accent{background-color:#ef6c00}body.dark-mode .mat-flat-button.mat-warn,body.dark-mode .mat-raised-button.mat-warn,body.dark-mode .mat-fab.mat-warn,body.dark-mode .mat-mini-fab.mat-warn{background-color:#f44336}body.dark-mode .mat-flat-button.mat-primary.mat-button-disabled,body.dark-mode .mat-flat-button.mat-accent.mat-button-disabled,body.dark-mode .mat-flat-button.mat-warn.mat-button-disabled,body.dark-mode .mat-flat-button.mat-button-disabled.mat-button-disabled,body.dark-mode .mat-raised-button.mat-primary.mat-button-disabled,body.dark-mode .mat-raised-button.mat-accent.mat-button-disabled,body.dark-mode .mat-raised-button.mat-warn.mat-button-disabled,body.dark-mode .mat-raised-button.mat-button-disabled.mat-button-disabled,body.dark-mode .mat-fab.mat-primary.mat-button-disabled,body.dark-mode .mat-fab.mat-accent.mat-button-disabled,body.dark-mode .mat-fab.mat-warn.mat-button-disabled,body.dark-mode .mat-fab.mat-button-disabled.mat-button-disabled,body.dark-mode .mat-mini-fab.mat-primary.mat-button-disabled,body.dark-mode .mat-mini-fab.mat-accent.mat-button-disabled,body.dark-mode .mat-mini-fab.mat-warn.mat-button-disabled,body.dark-mode .mat-mini-fab.mat-button-disabled.mat-button-disabled{background-color:rgba(255,255,255,.12)}body.dark-mode .mat-flat-button.mat-primary .mat-ripple-element,body.dark-mode .mat-raised-button.mat-primary .mat-ripple-element,body.dark-mode .mat-fab.mat-primary .mat-ripple-element,body.dark-mode .mat-mini-fab.mat-primary .mat-ripple-element{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-flat-button.mat-accent .mat-ripple-element,body.dark-mode .mat-raised-button.mat-accent .mat-ripple-element,body.dark-mode .mat-fab.mat-accent .mat-ripple-element,body.dark-mode .mat-mini-fab.mat-accent .mat-ripple-element{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-flat-button.mat-warn .mat-ripple-element,body.dark-mode .mat-raised-button.mat-warn .mat-ripple-element,body.dark-mode .mat-fab.mat-warn .mat-ripple-element,body.dark-mode .mat-mini-fab.mat-warn .mat-ripple-element{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-stroked-button:not([class*=mat-elevation-z]),body.dark-mode .mat-flat-button:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2), 0px 0px 0px 0px rgba(0, 0, 0, 0.14), 0px 0px 0px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-raised-button:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2), 0px 2px 2px 0px rgba(0, 0, 0, 0.14), 0px 1px 5px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-raised-button:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2), 0px 8px 10px 1px rgba(0, 0, 0, 0.14), 0px 3px 14px 2px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-raised-button.mat-button-disabled:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2), 0px 0px 0px 0px rgba(0, 0, 0, 0.14), 0px 0px 0px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-fab:not([class*=mat-elevation-z]),body.dark-mode .mat-mini-fab:not([class*=mat-elevation-z]){box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2), 0px 6px 10px 0px rgba(0, 0, 0, 0.14), 0px 1px 18px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-fab:not(.mat-button-disabled):active:not([class*=mat-elevation-z]),body.dark-mode .mat-mini-fab:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2), 0px 12px 17px 2px rgba(0, 0, 0, 0.14), 0px 5px 22px 4px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-fab.mat-button-disabled:not([class*=mat-elevation-z]),body.dark-mode .mat-mini-fab.mat-button-disabled:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2), 0px 0px 0px 0px rgba(0, 0, 0, 0.14), 0px 0px 0px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-datepicker-content .mat-mdc-button.mat-unthemed{--mdc-text-button-label-text-color:#fff}body.dark-mode .mat-datepicker-content .mat-mdc-button.mat-primary{--mdc-text-button-label-text-color:#ef6c00}body.dark-mode .mat-datepicker-content .mat-mdc-button.mat-accent{--mdc-text-button-label-text-color:#ef6c00}body.dark-mode .mat-datepicker-content .mat-mdc-button.mat-warn{--mdc-text-button-label-text-color:#f44336}body.dark-mode .mat-datepicker-content .mat-mdc-button[disabled][disabled]{--mdc-text-button-disabled-label-text-color:rgba(255, 255, 255, 0.5);--mdc-text-button-label-text-color:rgba(255, 255, 255, 0.5)}body.dark-mode .mat-datepicker-content .mat-mdc-unelevated-button.mat-unthemed{--mdc-filled-button-container-color:#424242;--mdc-filled-button-label-text-color:#fff}body.dark-mode .mat-datepicker-content .mat-mdc-unelevated-button.mat-primary{--mdc-filled-button-container-color:#ef6c00;--mdc-filled-button-label-text-color:#000}body.dark-mode .mat-datepicker-content .mat-mdc-unelevated-button.mat-accent{--mdc-filled-button-container-color:#ef6c00;--mdc-filled-button-label-text-color:#000}body.dark-mode .mat-datepicker-content .mat-mdc-unelevated-button.mat-warn{--mdc-filled-button-container-color:#f44336;--mdc-filled-button-label-text-color:#fff}body.dark-mode .mat-datepicker-content .mat-mdc-unelevated-button[disabled][disabled]{--mdc-filled-button-disabled-container-color:rgba(255, 255, 255, 0.12);--mdc-filled-button-disabled-label-text-color:rgba(255, 255, 255, 0.5);--mdc-filled-button-container-color:rgba(255, 255, 255, 0.12);--mdc-filled-button-label-text-color:rgba(255, 255, 255, 0.5)}body.dark-mode .mat-datepicker-content .mat-mdc-raised-button.mat-unthemed{--mdc-protected-button-container-color:#424242;--mdc-protected-button-label-text-color:#fff}body.dark-mode .mat-datepicker-content .mat-mdc-raised-button.mat-primary{--mdc-protected-button-container-color:#ef6c00;--mdc-protected-button-label-text-color:#000}body.dark-mode .mat-datepicker-content .mat-mdc-raised-button.mat-accent{--mdc-protected-button-container-color:#ef6c00;--mdc-protected-button-label-text-color:#000}body.dark-mode .mat-datepicker-content .mat-mdc-raised-button.mat-warn{--mdc-protected-button-container-color:#f44336;--mdc-protected-button-label-text-color:#fff}body.dark-mode .mat-datepicker-content .mat-mdc-raised-button[disabled][disabled]{--mdc-protected-button-disabled-container-color:rgba(255, 255, 255, 0.12);--mdc-protected-button-disabled-label-text-color:rgba(255, 255, 255, 0.5);--mdc-protected-button-container-color:rgba(255, 255, 255, 0.12);--mdc-protected-button-label-text-color:rgba(255, 255, 255, 0.5);--mdc-protected-button-container-elevation:0}body.dark-mode .mat-datepicker-content .mat-mdc-outlined-button{--mdc-outlined-button-outline-color:rgba(255, 255, 255, 0.12)}body.dark-mode .mat-datepicker-content .mat-mdc-outlined-button.mat-unthemed{--mdc-outlined-button-label-text-color:#fff}body.dark-mode .mat-datepicker-content .mat-mdc-outlined-button.mat-primary{--mdc-outlined-button-label-text-color:#ef6c00}body.dark-mode .mat-datepicker-content .mat-mdc-outlined-button.mat-accent{--mdc-outlined-button-label-text-color:#ef6c00}body.dark-mode .mat-datepicker-content .mat-mdc-outlined-button.mat-warn{--mdc-outlined-button-label-text-color:#f44336}body.dark-mode .mat-datepicker-content .mat-mdc-outlined-button[disabled][disabled]{--mdc-outlined-button-label-text-color:rgba(255, 255, 255, 0.5);--mdc-outlined-button-disabled-label-text-color:rgba(255, 255, 255, 0.5);--mdc-outlined-button-outline-color:rgba(255, 255, 255, 0.12);--mdc-outlined-button-disabled-outline-color:rgba(255, 255, 255, 0.12)}body.dark-mode .mat-datepicker-content .mat-mdc-button,body.dark-mode .mat-datepicker-content .mat-mdc-outlined-button{--mat-mdc-button-persistent-ripple-color: #fff;--mat-mdc-button-ripple-color: rgba(255, 255, 255, 0.1)}body.dark-mode .mat-datepicker-content .mat-mdc-button:hover .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-datepicker-content .mat-mdc-outlined-button:hover .mat-mdc-button-persistent-ripple::before{opacity:.08}body.dark-mode .mat-datepicker-content .mat-mdc-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-datepicker-content .mat-mdc-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-datepicker-content .mat-mdc-outlined-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-datepicker-content .mat-mdc-outlined-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before{opacity:.24}body.dark-mode .mat-datepicker-content .mat-mdc-button:active .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-datepicker-content .mat-mdc-outlined-button:active .mat-mdc-button-persistent-ripple::before{opacity:.24}body.dark-mode .mat-datepicker-content .mat-mdc-button.mat-primary,body.dark-mode .mat-datepicker-content .mat-mdc-outlined-button.mat-primary{--mat-mdc-button-persistent-ripple-color: #ef6c00;--mat-mdc-button-ripple-color: rgba(239, 108, 0, 0.1)}body.dark-mode .mat-datepicker-content .mat-mdc-button.mat-accent,body.dark-mode .mat-datepicker-content .mat-mdc-outlined-button.mat-accent{--mat-mdc-button-persistent-ripple-color: #ef6c00;--mat-mdc-button-ripple-color: rgba(239, 108, 0, 0.1)}body.dark-mode .mat-datepicker-content .mat-mdc-button.mat-warn,body.dark-mode .mat-datepicker-content .mat-mdc-outlined-button.mat-warn{--mat-mdc-button-persistent-ripple-color: #f44336;--mat-mdc-button-ripple-color: rgba(244, 67, 54, 0.1)}body.dark-mode .mat-datepicker-content .mat-mdc-raised-button,body.dark-mode .mat-datepicker-content .mat-mdc-unelevated-button{--mat-mdc-button-persistent-ripple-color: #fff;--mat-mdc-button-ripple-color: rgba(255, 255, 255, 0.1)}body.dark-mode .mat-datepicker-content .mat-mdc-raised-button:hover .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-datepicker-content .mat-mdc-unelevated-button:hover .mat-mdc-button-persistent-ripple::before{opacity:.08}body.dark-mode .mat-datepicker-content .mat-mdc-raised-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-datepicker-content .mat-mdc-raised-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-datepicker-content .mat-mdc-unelevated-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-datepicker-content .mat-mdc-unelevated-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before{opacity:.24}body.dark-mode .mat-datepicker-content .mat-mdc-raised-button:active .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-datepicker-content .mat-mdc-unelevated-button:active .mat-mdc-button-persistent-ripple::before{opacity:.24}body.dark-mode .mat-datepicker-content .mat-mdc-raised-button.mat-primary,body.dark-mode .mat-datepicker-content .mat-mdc-unelevated-button.mat-primary{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}body.dark-mode .mat-datepicker-content .mat-mdc-raised-button.mat-accent,body.dark-mode .mat-datepicker-content .mat-mdc-unelevated-button.mat-accent{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}body.dark-mode .mat-datepicker-content .mat-mdc-raised-button.mat-warn,body.dark-mode .mat-datepicker-content .mat-mdc-unelevated-button.mat-warn{--mat-mdc-button-persistent-ripple-color: #fff;--mat-mdc-button-ripple-color: rgba(255, 255, 255, 0.1)}body.dark-mode .mat-datepicker-content .mat-mdc-icon-button{--mat-mdc-button-persistent-ripple-color: #fff;--mat-mdc-button-ripple-color: rgba(255, 255, 255, 0.1)}body.dark-mode .mat-datepicker-content .mat-mdc-icon-button:hover .mat-mdc-button-persistent-ripple::before{opacity:.08}body.dark-mode .mat-datepicker-content .mat-mdc-icon-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-datepicker-content .mat-mdc-icon-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before{opacity:.24}body.dark-mode .mat-datepicker-content .mat-mdc-icon-button:active .mat-mdc-button-persistent-ripple::before{opacity:.24}body.dark-mode .mat-datepicker-content .mat-mdc-icon-button.mat-primary{--mat-mdc-button-persistent-ripple-color: #ef6c00;--mat-mdc-button-ripple-color: rgba(239, 108, 0, 0.1)}body.dark-mode .mat-datepicker-content .mat-mdc-icon-button.mat-accent{--mat-mdc-button-persistent-ripple-color: #ef6c00;--mat-mdc-button-ripple-color: rgba(239, 108, 0, 0.1)}body.dark-mode .mat-datepicker-content .mat-mdc-icon-button.mat-warn{--mat-mdc-button-persistent-ripple-color: #f44336;--mat-mdc-button-ripple-color: rgba(244, 67, 54, 0.1)}body.dark-mode .mat-datepicker-content .mat-mdc-icon-button.mat-primary{--mdc-icon-button-icon-color:#ef6c00}body.dark-mode .mat-datepicker-content .mat-mdc-icon-button.mat-accent{--mdc-icon-button-icon-color:#ef6c00}body.dark-mode .mat-datepicker-content .mat-mdc-icon-button.mat-warn{--mdc-icon-button-icon-color:#f44336}body.dark-mode .mat-datepicker-content .mat-mdc-icon-button[disabled][disabled]{--mdc-icon-button-icon-color:rgba(255, 255, 255, 0.5);--mdc-icon-button-disabled-icon-color:rgba(255, 255, 255, 0.5)}body.dark-mode .mat-datepicker-content .mat-mdc-button.mat-mdc-button-base,body.dark-mode .mat-datepicker-content .mat-mdc-raised-button.mat-mdc-button-base,body.dark-mode .mat-datepicker-content .mat-mdc-unelevated-button.mat-mdc-button-base,body.dark-mode .mat-datepicker-content .mat-mdc-outlined-button.mat-mdc-button-base{height:36px}body.dark-mode .mat-datepicker-content .mat-mdc-icon-button.mat-mdc-button-base{width:48px;height:48px;padding:12px}body.dark-mode .mat-datepicker-content .mat-mdc-icon-button.mat-mdc-button-base .mdc-icon-button__focus-ring{max-height:48px;max-width:48px}body.dark-mode .mat-datepicker-content .mat-mdc-icon-button.mat-mdc-button-base.mdc-icon-button--reduced-size .mdc-icon-button__ripple{width:40px;height:40px;margin-top:4px;margin-bottom:4px;margin-right:4px;margin-left:4px}body.dark-mode .mat-datepicker-content .mat-mdc-icon-button.mat-mdc-button-base.mdc-icon-button--reduced-size .mdc-icon-button__focus-ring{max-height:40px;max-width:40px}body.dark-mode .mat-datepicker-content .mat-mdc-icon-button.mat-mdc-button-base .mdc-icon-button__touch{position:absolute;top:50%;height:48px;left:50%;width:48px;transform:translate(-50%, -50%)}body.dark-mode .mat-option{color:#fff}body.dark-mode .mat-option:hover:not(.mat-option-disabled),body.dark-mode .mat-option:focus:not(.mat-option-disabled){background:rgba(255,255,255,.04)}body.dark-mode .mat-option.mat-selected:not(.mat-option-multiple):not(.mat-option-disabled){background:rgba(255,255,255,.04)}body.dark-mode .mat-option.mat-active{background:rgba(255,255,255,.04);color:#fff}body.dark-mode .mat-option.mat-option-disabled{color:rgba(255,255,255,.5)}body.dark-mode .mat-primary .mat-option.mat-selected:not(.mat-option-disabled){color:#ef6c00}body.dark-mode .mat-accent .mat-option.mat-selected:not(.mat-option-disabled){color:#ef6c00}body.dark-mode .mat-warn .mat-option.mat-selected:not(.mat-option-disabled){color:#f44336}body.dark-mode .mat-optgroup-label{color:rgba(255,255,255,.7)}body.dark-mode .mat-optgroup-disabled .mat-optgroup-label{color:rgba(255,255,255,.5)}body.dark-mode .mat-ripple-element{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-pseudo-checkbox-full{color:rgba(255,255,255,.7)}body.dark-mode .mat-pseudo-checkbox-full.mat-pseudo-checkbox-disabled{color:#686868}body.dark-mode .mat-primary .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,body.dark-mode .mat-primary .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#ef6c00}body.dark-mode .mat-primary .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,body.dark-mode .mat-primary .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#ef6c00}body.dark-mode .mat-primary .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full::after,body.dark-mode .mat-primary .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full::after{color:#303030}body.dark-mode .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,body.dark-mode .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#ef6c00}body.dark-mode .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,body.dark-mode .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#ef6c00}body.dark-mode .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full::after,body.dark-mode .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full::after{color:#303030}body.dark-mode .mat-accent .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,body.dark-mode .mat-accent .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#ef6c00}body.dark-mode .mat-accent .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,body.dark-mode .mat-accent .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#ef6c00}body.dark-mode .mat-accent .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full::after,body.dark-mode .mat-accent .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full::after{color:#303030}body.dark-mode .mat-warn .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,body.dark-mode .mat-warn .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#f44336}body.dark-mode .mat-warn .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,body.dark-mode .mat-warn .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#f44336}body.dark-mode .mat-warn .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full::after,body.dark-mode .mat-warn .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full::after{color:#303030}body.dark-mode .mat-pseudo-checkbox-disabled.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,body.dark-mode .mat-pseudo-checkbox-disabled.mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#686868}body.dark-mode .mat-pseudo-checkbox-disabled.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,body.dark-mode .mat-pseudo-checkbox-disabled.mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#686868}body.dark-mode .mat-app-background,body.dark-mode.mat-app-background{background-color:#303030;color:#fff}body.dark-mode .mat-elevation-z0{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2), 0px 0px 0px 0px rgba(0, 0, 0, 0.14), 0px 0px 0px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z1{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2), 0px 1px 1px 0px rgba(0, 0, 0, 0.14), 0px 1px 3px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z2{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2), 0px 2px 2px 0px rgba(0, 0, 0, 0.14), 0px 1px 5px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z3{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2), 0px 3px 4px 0px rgba(0, 0, 0, 0.14), 0px 1px 8px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z4{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2), 0px 4px 5px 0px rgba(0, 0, 0, 0.14), 0px 1px 10px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z5{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2), 0px 5px 8px 0px rgba(0, 0, 0, 0.14), 0px 1px 14px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z6{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2), 0px 6px 10px 0px rgba(0, 0, 0, 0.14), 0px 1px 18px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z7{box-shadow:0px 4px 5px -2px rgba(0, 0, 0, 0.2), 0px 7px 10px 1px rgba(0, 0, 0, 0.14), 0px 2px 16px 1px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z8{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2), 0px 8px 10px 1px rgba(0, 0, 0, 0.14), 0px 3px 14px 2px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z9{box-shadow:0px 5px 6px -3px rgba(0, 0, 0, 0.2), 0px 9px 12px 1px rgba(0, 0, 0, 0.14), 0px 3px 16px 2px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z10{box-shadow:0px 6px 6px -3px rgba(0, 0, 0, 0.2), 0px 10px 14px 1px rgba(0, 0, 0, 0.14), 0px 4px 18px 3px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z11{box-shadow:0px 6px 7px -4px rgba(0, 0, 0, 0.2), 0px 11px 15px 1px rgba(0, 0, 0, 0.14), 0px 4px 20px 3px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z12{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2), 0px 12px 17px 2px rgba(0, 0, 0, 0.14), 0px 5px 22px 4px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z13{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2), 0px 13px 19px 2px rgba(0, 0, 0, 0.14), 0px 5px 24px 4px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z14{box-shadow:0px 7px 9px -4px rgba(0, 0, 0, 0.2), 0px 14px 21px 2px rgba(0, 0, 0, 0.14), 0px 5px 26px 4px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z15{box-shadow:0px 8px 9px -5px rgba(0, 0, 0, 0.2), 0px 15px 22px 2px rgba(0, 0, 0, 0.14), 0px 6px 28px 5px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z16{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2), 0px 16px 24px 2px rgba(0, 0, 0, 0.14), 0px 6px 30px 5px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z17{box-shadow:0px 8px 11px -5px rgba(0, 0, 0, 0.2), 0px 17px 26px 2px rgba(0, 0, 0, 0.14), 0px 6px 32px 5px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z18{box-shadow:0px 9px 11px -5px rgba(0, 0, 0, 0.2), 0px 18px 28px 2px rgba(0, 0, 0, 0.14), 0px 7px 34px 6px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z19{box-shadow:0px 9px 12px -6px rgba(0, 0, 0, 0.2), 0px 19px 29px 2px rgba(0, 0, 0, 0.14), 0px 7px 36px 6px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z20{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2), 0px 20px 31px 3px rgba(0, 0, 0, 0.14), 0px 8px 38px 7px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z21{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2), 0px 21px 33px 3px rgba(0, 0, 0, 0.14), 0px 8px 40px 7px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z22{box-shadow:0px 10px 14px -6px rgba(0, 0, 0, 0.2), 0px 22px 35px 3px rgba(0, 0, 0, 0.14), 0px 8px 42px 7px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z23{box-shadow:0px 11px 14px -7px rgba(0, 0, 0, 0.2), 0px 23px 36px 3px rgba(0, 0, 0, 0.14), 0px 9px 44px 8px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z24{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2), 0px 24px 38px 3px rgba(0, 0, 0, 0.14), 0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-theme-loaded-marker{display:none}body.dark-mode .mat-card{background:#424242;color:#fff}body.dark-mode .mat-card:not([class*=mat-elevation-z]){box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2), 0px 1px 1px 0px rgba(0, 0, 0, 0.14), 0px 1px 3px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-card.mat-card-flat:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2), 0px 0px 0px 0px rgba(0, 0, 0, 0.14), 0px 0px 0px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-card-subtitle{color:rgba(255,255,255,.7)}body.dark-mode .mat-progress-bar-background{fill:#603f24}body.dark-mode .mat-progress-bar-buffer{background-color:#603f24}body.dark-mode .mat-progress-bar-fill::after{background-color:#ef6c00}body.dark-mode .mat-progress-bar.mat-accent .mat-progress-bar-background{fill:#603f24}body.dark-mode .mat-progress-bar.mat-accent .mat-progress-bar-buffer{background-color:#603f24}body.dark-mode .mat-progress-bar.mat-accent .mat-progress-bar-fill::after{background-color:#ef6c00}body.dark-mode .mat-progress-bar.mat-warn .mat-progress-bar-background{fill:#613532}body.dark-mode .mat-progress-bar.mat-warn .mat-progress-bar-buffer{background-color:#613532}body.dark-mode .mat-progress-bar.mat-warn .mat-progress-bar-fill::after{background-color:#f44336}body.dark-mode .mat-progress-spinner circle,body.dark-mode .mat-spinner circle{stroke:#ef6c00}body.dark-mode .mat-progress-spinner.mat-accent circle,body.dark-mode .mat-spinner.mat-accent circle{stroke:#ef6c00}body.dark-mode .mat-progress-spinner.mat-warn circle,body.dark-mode .mat-spinner.mat-warn circle{stroke:#f44336}body.dark-mode .mat-tooltip{background:rgba(97,97,97,.9)}body.dark-mode .mat-form-field-type-mat-native-select .mat-form-field-infix::after{color:rgba(255,255,255,.7)}body.dark-mode .mat-input-element:disabled,body.dark-mode .mat-form-field-type-mat-native-select.mat-form-field-disabled .mat-form-field-infix::after{color:#616161}body.dark-mode .mat-input-element{caret-color:#ef6c00}body.dark-mode .mat-input-element::placeholder{color:rgba(255,255,255,.5)}body.dark-mode .mat-input-element::-moz-placeholder{color:rgba(255,255,255,.5)}body.dark-mode .mat-input-element::-webkit-input-placeholder{color:rgba(255,255,255,.5)}body.dark-mode .mat-input-element:-ms-input-placeholder{color:rgba(255,255,255,.5)}body.dark-mode .mat-input-element:not(.mat-native-select-inline) option{color:rgba(0,0,0,.87)}body.dark-mode .mat-input-element:not(.mat-native-select-inline) option:disabled{color:rgba(0,0,0,.38)}body.dark-mode .mat-form-field.mat-accent .mat-input-element{caret-color:#ef6c00}body.dark-mode .mat-form-field.mat-warn .mat-input-element,body.dark-mode .mat-form-field-invalid .mat-input-element{caret-color:#f44336}body.dark-mode .mat-form-field-type-mat-native-select.mat-form-field-invalid .mat-form-field-infix::after{color:#f44336}body.dark-mode .mat-form-field-disabled .mat-form-field-prefix,body.dark-mode .mat-form-field-disabled .mat-form-field-suffix{color:#616161}body.dark-mode .mat-form-field-label{color:rgba(255,255,255,.7)}body.dark-mode .mat-hint{color:rgba(255,255,255,.7)}body.dark-mode .mat-form-field.mat-focused .mat-form-field-label{color:#ef6c00}body.dark-mode .mat-form-field.mat-focused .mat-form-field-label.mat-accent{color:#ef6c00}body.dark-mode .mat-form-field.mat-focused .mat-form-field-label.mat-warn{color:#f44336}body.dark-mode .mat-focused .mat-form-field-required-marker{color:#ef6c00}body.dark-mode .mat-form-field-ripple{background-color:#fff}body.dark-mode .mat-form-field.mat-focused .mat-form-field-ripple{background-color:#ef6c00}body.dark-mode .mat-form-field.mat-focused .mat-form-field-ripple.mat-accent{background-color:#ef6c00}body.dark-mode .mat-form-field.mat-focused .mat-form-field-ripple.mat-warn{background-color:#f44336}body.dark-mode .mat-form-field-type-mat-native-select.mat-focused:not(.mat-form-field-invalid) .mat-form-field-infix::after{color:#ef6c00}body.dark-mode .mat-form-field-type-mat-native-select.mat-focused:not(.mat-form-field-invalid).mat-accent .mat-form-field-infix::after{color:#ef6c00}body.dark-mode .mat-form-field-type-mat-native-select.mat-focused:not(.mat-form-field-invalid).mat-warn .mat-form-field-infix::after{color:#f44336}body.dark-mode .mat-form-field.mat-form-field-invalid .mat-form-field-label{color:#f44336}body.dark-mode .mat-form-field.mat-form-field-invalid .mat-form-field-label.mat-accent,body.dark-mode .mat-form-field.mat-form-field-invalid .mat-form-field-label .mat-form-field-required-marker{color:#f44336}body.dark-mode .mat-form-field.mat-form-field-invalid .mat-form-field-ripple,body.dark-mode .mat-form-field.mat-form-field-invalid .mat-form-field-ripple.mat-accent{background-color:#f44336}body.dark-mode .mat-error{color:#f44336}body.dark-mode .mat-form-field-appearance-legacy .mat-form-field-label{color:rgba(255,255,255,.7)}body.dark-mode .mat-form-field-appearance-legacy .mat-hint{color:rgba(255,255,255,.7)}body.dark-mode .mat-form-field-appearance-legacy .mat-form-field-underline{background-color:rgba(255,255,255,.7)}body.dark-mode .mat-form-field-appearance-legacy.mat-form-field-disabled .mat-form-field-underline{background-image:linear-gradient(to right, rgba(255, 255, 255, 0.7) 0%, rgba(255, 255, 255, 0.7) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}body.dark-mode .mat-form-field-appearance-standard .mat-form-field-underline{background-color:rgba(255,255,255,.7)}body.dark-mode .mat-form-field-appearance-standard.mat-form-field-disabled .mat-form-field-underline{background-image:linear-gradient(to right, rgba(255, 255, 255, 0.7) 0%, rgba(255, 255, 255, 0.7) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}body.dark-mode .mat-form-field-appearance-fill .mat-form-field-flex{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-form-field-appearance-fill.mat-form-field-disabled .mat-form-field-flex{background-color:rgba(255,255,255,.05)}body.dark-mode .mat-form-field-appearance-fill .mat-form-field-underline::before{background-color:rgba(255,255,255,.5)}body.dark-mode .mat-form-field-appearance-fill.mat-form-field-disabled .mat-form-field-label{color:#616161}body.dark-mode .mat-form-field-appearance-fill.mat-form-field-disabled .mat-form-field-underline::before{background-color:rgba(0,0,0,0)}body.dark-mode .mat-form-field-appearance-outline .mat-form-field-outline{color:rgba(255,255,255,.3)}body.dark-mode .mat-form-field-appearance-outline .mat-form-field-outline-thick{color:#fff}body.dark-mode .mat-form-field-appearance-outline.mat-focused .mat-form-field-outline-thick{color:#ef6c00}body.dark-mode .mat-form-field-appearance-outline.mat-focused.mat-accent .mat-form-field-outline-thick{color:#ef6c00}body.dark-mode .mat-form-field-appearance-outline.mat-focused.mat-warn .mat-form-field-outline-thick{color:#f44336}body.dark-mode .mat-form-field-appearance-outline.mat-form-field-invalid.mat-form-field-invalid .mat-form-field-outline-thick{color:#f44336}body.dark-mode .mat-form-field-appearance-outline.mat-form-field-disabled .mat-form-field-label{color:#616161}body.dark-mode .mat-form-field-appearance-outline.mat-form-field-disabled .mat-form-field-outline{color:rgba(255,255,255,.15)}body.dark-mode .mat-select-value{color:#fff}body.dark-mode .mat-select-placeholder{color:rgba(255,255,255,.5)}body.dark-mode .mat-select-disabled .mat-select-value{color:#616161}body.dark-mode .mat-select-arrow{color:rgba(255,255,255,.7)}body.dark-mode .mat-select-panel{background:#424242}body.dark-mode .mat-select-panel:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2), 0px 4px 5px 0px rgba(0, 0, 0, 0.14), 0px 1px 10px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-select-panel .mat-option.mat-selected:not(.mat-option-multiple){background:rgba(255,255,255,.12)}body.dark-mode .mat-form-field.mat-focused.mat-primary .mat-select-arrow{color:#ef6c00}body.dark-mode .mat-form-field.mat-focused.mat-accent .mat-select-arrow{color:#ef6c00}body.dark-mode .mat-form-field.mat-focused.mat-warn .mat-select-arrow{color:#f44336}body.dark-mode .mat-form-field .mat-select.mat-select-invalid .mat-select-arrow{color:#f44336}body.dark-mode .mat-form-field .mat-select.mat-select-disabled .mat-select-arrow{color:#616161}body.dark-mode .mat-checkbox-frame{border-color:rgba(255,255,255,.7)}body.dark-mode .mat-checkbox-checkmark{fill:#303030}body.dark-mode .mat-checkbox-checkmark-path{stroke:#303030 !important}body.dark-mode .mat-checkbox-mixedmark{background-color:#303030}body.dark-mode .mat-checkbox-indeterminate.mat-primary .mat-checkbox-background,body.dark-mode .mat-checkbox-checked.mat-primary .mat-checkbox-background{background-color:#ef6c00}body.dark-mode .mat-checkbox-indeterminate.mat-accent .mat-checkbox-background,body.dark-mode .mat-checkbox-checked.mat-accent .mat-checkbox-background{background-color:#ef6c00}body.dark-mode .mat-checkbox-indeterminate.mat-warn .mat-checkbox-background,body.dark-mode .mat-checkbox-checked.mat-warn .mat-checkbox-background{background-color:#f44336}body.dark-mode .mat-checkbox-disabled.mat-checkbox-checked .mat-checkbox-background,body.dark-mode .mat-checkbox-disabled.mat-checkbox-indeterminate .mat-checkbox-background{background-color:#686868}body.dark-mode .mat-checkbox-disabled:not(.mat-checkbox-checked) .mat-checkbox-frame{border-color:#686868}body.dark-mode .mat-checkbox-disabled .mat-checkbox-label{color:rgba(255,255,255,.5)}body.dark-mode .mat-checkbox .mat-ripple-element{background-color:#fff}body.dark-mode .mat-checkbox-checked:not(.mat-checkbox-disabled).mat-primary .mat-ripple-element,body.dark-mode .mat-checkbox:active:not(.mat-checkbox-disabled).mat-primary .mat-ripple-element{background:#ef6c00}body.dark-mode .mat-checkbox-checked:not(.mat-checkbox-disabled).mat-accent .mat-ripple-element,body.dark-mode .mat-checkbox:active:not(.mat-checkbox-disabled).mat-accent .mat-ripple-element{background:#ef6c00}body.dark-mode .mat-checkbox-checked:not(.mat-checkbox-disabled).mat-warn .mat-ripple-element,body.dark-mode .mat-checkbox:active:not(.mat-checkbox-disabled).mat-warn .mat-ripple-element{background:#f44336}body.dark-mode .mat-autocomplete-panel{background:#424242;color:#fff}body.dark-mode .mat-autocomplete-panel:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2), 0px 4px 5px 0px rgba(0, 0, 0, 0.14), 0px 1px 10px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-autocomplete-panel .mat-option.mat-selected:not(.mat-active):not(:hover){background:#424242}body.dark-mode .mat-autocomplete-panel .mat-option.mat-selected:not(.mat-active):not(:hover):not(.mat-option-disabled){color:#fff}body.dark-mode .mat-dialog-container{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2), 0px 24px 38px 3px rgba(0, 0, 0, 0.14), 0px 9px 46px 8px rgba(0, 0, 0, 0.12);background:#424242;color:#fff}body.dark-mode .mat-chip.mat-standard-chip{background-color:#616161;color:#fff}body.dark-mode .mat-chip.mat-standard-chip .mat-chip-remove{color:#fff;opacity:.4}body.dark-mode .mat-chip.mat-standard-chip:not(.mat-chip-disabled):active{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2), 0px 3px 4px 0px rgba(0, 0, 0, 0.14), 0px 1px 8px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-chip.mat-standard-chip:not(.mat-chip-disabled) .mat-chip-remove:hover{opacity:.54}body.dark-mode .mat-chip.mat-standard-chip.mat-chip-disabled{opacity:.4}body.dark-mode .mat-chip.mat-standard-chip::after{background:#fff}body.dark-mode .mat-chip.mat-standard-chip.mat-chip-selected.mat-primary{background-color:#ef6c00;color:#fff}body.dark-mode .mat-chip.mat-standard-chip.mat-chip-selected.mat-primary .mat-chip-remove{color:#fff;opacity:.4}body.dark-mode .mat-chip.mat-standard-chip.mat-chip-selected.mat-primary .mat-ripple-element{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-chip.mat-standard-chip.mat-chip-selected.mat-warn{background-color:#f44336;color:#fff}body.dark-mode .mat-chip.mat-standard-chip.mat-chip-selected.mat-warn .mat-chip-remove{color:#fff;opacity:.4}body.dark-mode .mat-chip.mat-standard-chip.mat-chip-selected.mat-warn .mat-ripple-element{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-chip.mat-standard-chip.mat-chip-selected.mat-accent{background-color:#ef6c00;color:#fff}body.dark-mode .mat-chip.mat-standard-chip.mat-chip-selected.mat-accent .mat-chip-remove{color:#fff;opacity:.4}body.dark-mode .mat-chip.mat-standard-chip.mat-chip-selected.mat-accent .mat-ripple-element{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-slide-toggle.mat-checked .mat-slide-toggle-thumb{background-color:#ef6c00}body.dark-mode .mat-slide-toggle.mat-checked .mat-slide-toggle-bar{background-color:rgba(239,108,0,.54)}body.dark-mode .mat-slide-toggle.mat-checked .mat-ripple-element{background-color:#ef6c00}body.dark-mode .mat-slide-toggle.mat-primary.mat-checked .mat-slide-toggle-thumb{background-color:#ef6c00}body.dark-mode .mat-slide-toggle.mat-primary.mat-checked .mat-slide-toggle-bar{background-color:rgba(239,108,0,.54)}body.dark-mode .mat-slide-toggle.mat-primary.mat-checked .mat-ripple-element{background-color:#ef6c00}body.dark-mode .mat-slide-toggle.mat-warn.mat-checked .mat-slide-toggle-thumb{background-color:#f44336}body.dark-mode .mat-slide-toggle.mat-warn.mat-checked .mat-slide-toggle-bar{background-color:rgba(244,67,54,.54)}body.dark-mode .mat-slide-toggle.mat-warn.mat-checked .mat-ripple-element{background-color:#f44336}body.dark-mode .mat-slide-toggle:not(.mat-checked) .mat-ripple-element{background-color:#fff}body.dark-mode .mat-slide-toggle-thumb{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2), 0px 1px 1px 0px rgba(0, 0, 0, 0.14), 0px 1px 3px 0px rgba(0, 0, 0, 0.12);background-color:#bdbdbd}body.dark-mode .mat-slide-toggle-bar{background-color:rgba(255,255,255,.5)}body.dark-mode .mat-radio-outer-circle{border-color:rgba(255,255,255,.7)}body.dark-mode .mat-radio-button.mat-primary.mat-radio-checked .mat-radio-outer-circle{border-color:#ef6c00}body.dark-mode .mat-radio-button.mat-primary .mat-radio-inner-circle,body.dark-mode .mat-radio-button.mat-primary .mat-radio-ripple .mat-ripple-element:not(.mat-radio-persistent-ripple),body.dark-mode .mat-radio-button.mat-primary.mat-radio-checked .mat-radio-persistent-ripple,body.dark-mode .mat-radio-button.mat-primary:active .mat-radio-persistent-ripple{background-color:#ef6c00}body.dark-mode .mat-radio-button.mat-accent.mat-radio-checked .mat-radio-outer-circle{border-color:#ef6c00}body.dark-mode .mat-radio-button.mat-accent .mat-radio-inner-circle,body.dark-mode .mat-radio-button.mat-accent .mat-radio-ripple .mat-ripple-element:not(.mat-radio-persistent-ripple),body.dark-mode .mat-radio-button.mat-accent.mat-radio-checked .mat-radio-persistent-ripple,body.dark-mode .mat-radio-button.mat-accent:active .mat-radio-persistent-ripple{background-color:#ef6c00}body.dark-mode .mat-radio-button.mat-warn.mat-radio-checked .mat-radio-outer-circle{border-color:#f44336}body.dark-mode .mat-radio-button.mat-warn .mat-radio-inner-circle,body.dark-mode .mat-radio-button.mat-warn .mat-radio-ripple .mat-ripple-element:not(.mat-radio-persistent-ripple),body.dark-mode .mat-radio-button.mat-warn.mat-radio-checked .mat-radio-persistent-ripple,body.dark-mode .mat-radio-button.mat-warn:active .mat-radio-persistent-ripple{background-color:#f44336}body.dark-mode .mat-radio-button.mat-radio-disabled.mat-radio-checked .mat-radio-outer-circle,body.dark-mode .mat-radio-button.mat-radio-disabled .mat-radio-outer-circle{border-color:rgba(255,255,255,.5)}body.dark-mode .mat-radio-button.mat-radio-disabled .mat-radio-ripple .mat-ripple-element,body.dark-mode .mat-radio-button.mat-radio-disabled .mat-radio-inner-circle{background-color:rgba(255,255,255,.5)}body.dark-mode .mat-radio-button.mat-radio-disabled .mat-radio-label-content{color:rgba(255,255,255,.5)}body.dark-mode .mat-radio-button .mat-ripple-element{background-color:#fff}body.dark-mode .mat-slider-track-background{background-color:rgba(255,255,255,.3)}body.dark-mode .mat-slider.mat-primary .mat-slider-track-fill,body.dark-mode .mat-slider.mat-primary .mat-slider-thumb,body.dark-mode .mat-slider.mat-primary .mat-slider-thumb-label{background-color:#ef6c00}body.dark-mode .mat-slider.mat-primary .mat-slider-thumb-label-text{color:#fff}body.dark-mode .mat-slider.mat-primary .mat-slider-focus-ring{background-color:rgba(239,108,0,.2)}body.dark-mode .mat-slider.mat-accent .mat-slider-track-fill,body.dark-mode .mat-slider.mat-accent .mat-slider-thumb,body.dark-mode .mat-slider.mat-accent .mat-slider-thumb-label{background-color:#ef6c00}body.dark-mode .mat-slider.mat-accent .mat-slider-thumb-label-text{color:#fff}body.dark-mode .mat-slider.mat-accent .mat-slider-focus-ring{background-color:rgba(239,108,0,.2)}body.dark-mode .mat-slider.mat-warn .mat-slider-track-fill,body.dark-mode .mat-slider.mat-warn .mat-slider-thumb,body.dark-mode .mat-slider.mat-warn .mat-slider-thumb-label{background-color:#f44336}body.dark-mode .mat-slider.mat-warn .mat-slider-thumb-label-text{color:#fff}body.dark-mode .mat-slider.mat-warn .mat-slider-focus-ring{background-color:rgba(244,67,54,.2)}body.dark-mode .mat-slider:hover .mat-slider-track-background,body.dark-mode .mat-slider.cdk-focused .mat-slider-track-background{background-color:rgba(255,255,255,.3)}body.dark-mode .mat-slider.mat-slider-disabled .mat-slider-track-background,body.dark-mode .mat-slider.mat-slider-disabled .mat-slider-track-fill,body.dark-mode .mat-slider.mat-slider-disabled .mat-slider-thumb{background-color:rgba(255,255,255,.3)}body.dark-mode .mat-slider.mat-slider-disabled:hover .mat-slider-track-background{background-color:rgba(255,255,255,.3)}body.dark-mode .mat-slider.mat-slider-min-value .mat-slider-focus-ring{background-color:rgba(255,255,255,.12)}body.dark-mode .mat-slider.mat-slider-min-value.mat-slider-thumb-label-showing .mat-slider-thumb,body.dark-mode .mat-slider.mat-slider-min-value.mat-slider-thumb-label-showing .mat-slider-thumb-label{background-color:#fff}body.dark-mode .mat-slider.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused .mat-slider-thumb,body.dark-mode .mat-slider.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused .mat-slider-thumb-label{background-color:rgba(255,255,255,.3)}body.dark-mode .mat-slider.mat-slider-min-value:not(.mat-slider-thumb-label-showing) .mat-slider-thumb{border-color:rgba(255,255,255,.3);background-color:rgba(0,0,0,0)}body.dark-mode .mat-slider.mat-slider-min-value:not(.mat-slider-thumb-label-showing):hover .mat-slider-thumb,body.dark-mode .mat-slider.mat-slider-min-value:not(.mat-slider-thumb-label-showing).cdk-focused .mat-slider-thumb{border-color:rgba(255,255,255,.3)}body.dark-mode .mat-slider.mat-slider-min-value:not(.mat-slider-thumb-label-showing):hover.mat-slider-disabled .mat-slider-thumb,body.dark-mode .mat-slider.mat-slider-min-value:not(.mat-slider-thumb-label-showing).cdk-focused.mat-slider-disabled .mat-slider-thumb{border-color:rgba(255,255,255,.3)}body.dark-mode .mat-slider-has-ticks .mat-slider-wrapper::after{border-color:rgba(255,255,255,.7)}body.dark-mode .mat-slider-horizontal .mat-slider-ticks{background-image:repeating-linear-gradient(to right, rgba(255, 255, 255, 0.7), rgba(255, 255, 255, 0.7) 2px, transparent 0, transparent);background-image:-moz-repeating-linear-gradient(0.0001deg, rgba(255, 255, 255, 0.7), rgba(255, 255, 255, 0.7) 2px, transparent 0, transparent)}body.dark-mode .mat-slider-vertical .mat-slider-ticks{background-image:repeating-linear-gradient(to bottom, rgba(255, 255, 255, 0.7), rgba(255, 255, 255, 0.7) 2px, transparent 0, transparent)}body.dark-mode .mat-menu-panel{background:#424242}body.dark-mode .mat-menu-panel:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2), 0px 4px 5px 0px rgba(0, 0, 0, 0.14), 0px 1px 10px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-menu-item{background:rgba(0,0,0,0);color:#fff}body.dark-mode .mat-menu-item[disabled],body.dark-mode .mat-menu-item[disabled] .mat-menu-submenu-icon,body.dark-mode .mat-menu-item[disabled] .mat-icon-no-color{color:rgba(255,255,255,.5)}body.dark-mode .mat-menu-item .mat-icon-no-color,body.dark-mode .mat-menu-submenu-icon{color:#fff}body.dark-mode .mat-menu-item:hover:not([disabled]),body.dark-mode .mat-menu-item.cdk-program-focused:not([disabled]),body.dark-mode .mat-menu-item.cdk-keyboard-focused:not([disabled]),body.dark-mode .mat-menu-item-highlighted:not([disabled]){background:rgba(255,255,255,.04)}body.dark-mode .mat-list-base .mat-list-item{color:#fff}body.dark-mode .mat-list-base .mat-list-option{color:#fff}body.dark-mode .mat-list-base .mat-subheader{color:rgba(255,255,255,.7)}body.dark-mode .mat-list-base .mat-list-item-disabled{background-color:rgba(255,255,255,.12);color:#616161}body.dark-mode .mat-list-option:hover,body.dark-mode .mat-list-option:focus,body.dark-mode .mat-nav-list .mat-list-item:hover,body.dark-mode .mat-nav-list .mat-list-item:focus,body.dark-mode .mat-action-list .mat-list-item:hover,body.dark-mode .mat-action-list .mat-list-item:focus{background:rgba(255,255,255,.04)}body.dark-mode .mat-list-single-selected-option,body.dark-mode .mat-list-single-selected-option:hover,body.dark-mode .mat-list-single-selected-option:focus{background:rgba(255,255,255,.12)}body.dark-mode .mat-paginator{background:#424242}body.dark-mode .mat-paginator,body.dark-mode .mat-paginator-page-size .mat-select-trigger{color:rgba(255,255,255,.7)}body.dark-mode .mat-paginator-decrement,body.dark-mode .mat-paginator-increment{border-top:2px solid #fff;border-right:2px solid #fff}body.dark-mode .mat-paginator-first,body.dark-mode .mat-paginator-last{border-top:2px solid #fff}body.dark-mode .mat-icon-button[disabled] .mat-paginator-decrement,body.dark-mode .mat-icon-button[disabled] .mat-paginator-increment,body.dark-mode .mat-icon-button[disabled] .mat-paginator-first,body.dark-mode .mat-icon-button[disabled] .mat-paginator-last{border-color:rgba(255,255,255,.5)}body.dark-mode .mat-paginator-container{min-height:56px}body.dark-mode .mat-tab-nav-bar,body.dark-mode .mat-tab-header{border-bottom:1px solid rgba(255,255,255,.12)}body.dark-mode .mat-tab-group-inverted-header .mat-tab-nav-bar,body.dark-mode .mat-tab-group-inverted-header .mat-tab-header{border-top:1px solid rgba(255,255,255,.12);border-bottom:none}body.dark-mode .mat-tab-label,body.dark-mode .mat-tab-link{color:#fff}body.dark-mode .mat-tab-label.mat-tab-disabled,body.dark-mode .mat-tab-link.mat-tab-disabled{color:#616161}body.dark-mode .mat-tab-header-pagination-chevron{border-color:#fff}body.dark-mode .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron{border-color:#616161}body.dark-mode .mat-tab-group[class*=mat-background-]>.mat-tab-header,body.dark-mode .mat-tab-nav-bar[class*=mat-background-]{border-bottom:none;border-top:none}body.dark-mode .mat-tab-group.mat-primary .mat-tab-label.cdk-keyboard-focused,body.dark-mode .mat-tab-group.mat-primary .mat-tab-label.cdk-program-focused,body.dark-mode .mat-tab-group.mat-primary .mat-tab-link.cdk-keyboard-focused,body.dark-mode .mat-tab-group.mat-primary .mat-tab-link.cdk-program-focused,body.dark-mode .mat-tab-nav-bar.mat-primary .mat-tab-label.cdk-keyboard-focused,body.dark-mode .mat-tab-nav-bar.mat-primary .mat-tab-label.cdk-program-focused,body.dark-mode .mat-tab-nav-bar.mat-primary .mat-tab-link.cdk-keyboard-focused,body.dark-mode .mat-tab-nav-bar.mat-primary .mat-tab-link.cdk-program-focused{background-color:rgba(251,140,0,.3)}body.dark-mode .mat-tab-group.mat-primary .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-primary .mat-tab-label.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-primary .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-primary .mat-tab-link.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-primary .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-primary .mat-tab-label.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-primary .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-primary .mat-tab-link.cdk-program-focused.mat-tab-disabled{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-tab-group.mat-primary .mat-ink-bar,body.dark-mode .mat-tab-nav-bar.mat-primary .mat-ink-bar{background-color:#ef6c00}body.dark-mode .mat-tab-group.mat-primary.mat-background-primary>.mat-tab-header .mat-ink-bar,body.dark-mode .mat-tab-group.mat-primary.mat-background-primary>.mat-tab-link-container .mat-ink-bar,body.dark-mode .mat-tab-nav-bar.mat-primary.mat-background-primary>.mat-tab-header .mat-ink-bar,body.dark-mode .mat-tab-nav-bar.mat-primary.mat-background-primary>.mat-tab-link-container .mat-ink-bar{background-color:#fff}body.dark-mode .mat-tab-group.mat-accent .mat-tab-label.cdk-keyboard-focused,body.dark-mode .mat-tab-group.mat-accent .mat-tab-label.cdk-program-focused,body.dark-mode .mat-tab-group.mat-accent .mat-tab-link.cdk-keyboard-focused,body.dark-mode .mat-tab-group.mat-accent .mat-tab-link.cdk-program-focused,body.dark-mode .mat-tab-nav-bar.mat-accent .mat-tab-label.cdk-keyboard-focused,body.dark-mode .mat-tab-nav-bar.mat-accent .mat-tab-label.cdk-program-focused,body.dark-mode .mat-tab-nav-bar.mat-accent .mat-tab-link.cdk-keyboard-focused,body.dark-mode .mat-tab-nav-bar.mat-accent .mat-tab-link.cdk-program-focused{background-color:rgba(251,140,0,.3)}body.dark-mode .mat-tab-group.mat-accent .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-accent .mat-tab-label.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-accent .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-accent .mat-tab-link.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-accent .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-accent .mat-tab-label.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-accent .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-accent .mat-tab-link.cdk-program-focused.mat-tab-disabled{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-tab-group.mat-accent .mat-ink-bar,body.dark-mode .mat-tab-nav-bar.mat-accent .mat-ink-bar{background-color:#ef6c00}body.dark-mode .mat-tab-group.mat-accent.mat-background-accent>.mat-tab-header .mat-ink-bar,body.dark-mode .mat-tab-group.mat-accent.mat-background-accent>.mat-tab-link-container .mat-ink-bar,body.dark-mode .mat-tab-nav-bar.mat-accent.mat-background-accent>.mat-tab-header .mat-ink-bar,body.dark-mode .mat-tab-nav-bar.mat-accent.mat-background-accent>.mat-tab-link-container .mat-ink-bar{background-color:#fff}body.dark-mode .mat-tab-group.mat-warn .mat-tab-label.cdk-keyboard-focused,body.dark-mode .mat-tab-group.mat-warn .mat-tab-label.cdk-program-focused,body.dark-mode .mat-tab-group.mat-warn .mat-tab-link.cdk-keyboard-focused,body.dark-mode .mat-tab-group.mat-warn .mat-tab-link.cdk-program-focused,body.dark-mode .mat-tab-nav-bar.mat-warn .mat-tab-label.cdk-keyboard-focused,body.dark-mode .mat-tab-nav-bar.mat-warn .mat-tab-label.cdk-program-focused,body.dark-mode .mat-tab-nav-bar.mat-warn .mat-tab-link.cdk-keyboard-focused,body.dark-mode .mat-tab-nav-bar.mat-warn .mat-tab-link.cdk-program-focused{background-color:rgba(255,205,210,.3)}body.dark-mode .mat-tab-group.mat-warn .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-warn .mat-tab-label.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-warn .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-warn .mat-tab-link.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-warn .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-warn .mat-tab-label.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-warn .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-warn .mat-tab-link.cdk-program-focused.mat-tab-disabled{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-tab-group.mat-warn .mat-ink-bar,body.dark-mode .mat-tab-nav-bar.mat-warn .mat-ink-bar{background-color:#f44336}body.dark-mode .mat-tab-group.mat-warn.mat-background-warn>.mat-tab-header .mat-ink-bar,body.dark-mode .mat-tab-group.mat-warn.mat-background-warn>.mat-tab-link-container .mat-ink-bar,body.dark-mode .mat-tab-nav-bar.mat-warn.mat-background-warn>.mat-tab-header .mat-ink-bar,body.dark-mode .mat-tab-nav-bar.mat-warn.mat-background-warn>.mat-tab-link-container .mat-ink-bar{background-color:#fff}body.dark-mode .mat-tab-group.mat-background-primary .mat-tab-label.cdk-keyboard-focused,body.dark-mode .mat-tab-group.mat-background-primary .mat-tab-label.cdk-program-focused,body.dark-mode .mat-tab-group.mat-background-primary .mat-tab-link.cdk-keyboard-focused,body.dark-mode .mat-tab-group.mat-background-primary .mat-tab-link.cdk-program-focused,body.dark-mode .mat-tab-nav-bar.mat-background-primary .mat-tab-label.cdk-keyboard-focused,body.dark-mode .mat-tab-nav-bar.mat-background-primary .mat-tab-label.cdk-program-focused,body.dark-mode .mat-tab-nav-bar.mat-background-primary .mat-tab-link.cdk-keyboard-focused,body.dark-mode .mat-tab-nav-bar.mat-background-primary .mat-tab-link.cdk-program-focused{background-color:rgba(251,140,0,.3)}body.dark-mode .mat-tab-group.mat-background-primary .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-background-primary .mat-tab-label.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-background-primary .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-background-primary .mat-tab-link.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-primary .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-primary .mat-tab-label.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-primary .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-primary .mat-tab-link.cdk-program-focused.mat-tab-disabled{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-header,body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-link-container,body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-header-pagination,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-header,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-link-container,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-header-pagination{background-color:#ef6c00}body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-header .mat-tab-label,body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-link-container .mat-tab-link,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-header .mat-tab-label,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-link-container .mat-tab-link{color:#fff}body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-header .mat-tab-label.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-link-container .mat-tab-link.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-header .mat-tab-label.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-link-container .mat-tab-link.mat-tab-disabled{color:rgba(255,255,255,.4)}body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-header .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-header-pagination .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-link-container .mat-focus-indicator::before,body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-header .mat-focus-indicator::before,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-header .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-header-pagination .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-link-container .mat-focus-indicator::before,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-header .mat-focus-indicator::before{border-color:#fff}body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-header .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-header .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron{border-color:#fff;opacity:.4}body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-header .mat-ripple-element,body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-link-container .mat-ripple-element,body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-header-pagination .mat-ripple-element,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-header .mat-ripple-element,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-link-container .mat-ripple-element,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-header-pagination .mat-ripple-element{background-color:#fff;opacity:.12}body.dark-mode .mat-tab-group.mat-background-accent .mat-tab-label.cdk-keyboard-focused,body.dark-mode .mat-tab-group.mat-background-accent .mat-tab-label.cdk-program-focused,body.dark-mode .mat-tab-group.mat-background-accent .mat-tab-link.cdk-keyboard-focused,body.dark-mode .mat-tab-group.mat-background-accent .mat-tab-link.cdk-program-focused,body.dark-mode .mat-tab-nav-bar.mat-background-accent .mat-tab-label.cdk-keyboard-focused,body.dark-mode .mat-tab-nav-bar.mat-background-accent .mat-tab-label.cdk-program-focused,body.dark-mode .mat-tab-nav-bar.mat-background-accent .mat-tab-link.cdk-keyboard-focused,body.dark-mode .mat-tab-nav-bar.mat-background-accent .mat-tab-link.cdk-program-focused{background-color:rgba(251,140,0,.3)}body.dark-mode .mat-tab-group.mat-background-accent .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-background-accent .mat-tab-label.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-background-accent .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-background-accent .mat-tab-link.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-accent .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-accent .mat-tab-label.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-accent .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-accent .mat-tab-link.cdk-program-focused.mat-tab-disabled{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-header,body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-link-container,body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-header-pagination,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-header,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-link-container,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-header-pagination{background-color:#ef6c00}body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-header .mat-tab-label,body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-link-container .mat-tab-link,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-header .mat-tab-label,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-link-container .mat-tab-link{color:#fff}body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-header .mat-tab-label.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-link-container .mat-tab-link.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-header .mat-tab-label.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-link-container .mat-tab-link.mat-tab-disabled{color:rgba(255,255,255,.4)}body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-header .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-header-pagination .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-link-container .mat-focus-indicator::before,body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-header .mat-focus-indicator::before,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-header .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-header-pagination .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-link-container .mat-focus-indicator::before,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-header .mat-focus-indicator::before{border-color:#fff}body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-header .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-header .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron{border-color:#fff;opacity:.4}body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-header .mat-ripple-element,body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-link-container .mat-ripple-element,body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-header-pagination .mat-ripple-element,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-header .mat-ripple-element,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-link-container .mat-ripple-element,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-header-pagination .mat-ripple-element{background-color:#fff;opacity:.12}body.dark-mode .mat-tab-group.mat-background-warn .mat-tab-label.cdk-keyboard-focused,body.dark-mode .mat-tab-group.mat-background-warn .mat-tab-label.cdk-program-focused,body.dark-mode .mat-tab-group.mat-background-warn .mat-tab-link.cdk-keyboard-focused,body.dark-mode .mat-tab-group.mat-background-warn .mat-tab-link.cdk-program-focused,body.dark-mode .mat-tab-nav-bar.mat-background-warn .mat-tab-label.cdk-keyboard-focused,body.dark-mode .mat-tab-nav-bar.mat-background-warn .mat-tab-label.cdk-program-focused,body.dark-mode .mat-tab-nav-bar.mat-background-warn .mat-tab-link.cdk-keyboard-focused,body.dark-mode .mat-tab-nav-bar.mat-background-warn .mat-tab-link.cdk-program-focused{background-color:rgba(255,205,210,.3)}body.dark-mode .mat-tab-group.mat-background-warn .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-background-warn .mat-tab-label.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-background-warn .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-background-warn .mat-tab-link.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-warn .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-warn .mat-tab-label.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-warn .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-warn .mat-tab-link.cdk-program-focused.mat-tab-disabled{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-header,body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-link-container,body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-header-pagination,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-header,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-link-container,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-header-pagination{background-color:#f44336}body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-header .mat-tab-label,body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-link-container .mat-tab-link,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-header .mat-tab-label,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-link-container .mat-tab-link{color:#fff}body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-header .mat-tab-label.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-link-container .mat-tab-link.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-header .mat-tab-label.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-link-container .mat-tab-link.mat-tab-disabled{color:rgba(255,255,255,.4)}body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-header .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-header-pagination .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-link-container .mat-focus-indicator::before,body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-header .mat-focus-indicator::before,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-header .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-header-pagination .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-link-container .mat-focus-indicator::before,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-header .mat-focus-indicator::before{border-color:#fff}body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-header .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-header .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron{border-color:#fff;opacity:.4}body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-header .mat-ripple-element,body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-link-container .mat-ripple-element,body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-header-pagination .mat-ripple-element,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-header .mat-ripple-element,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-link-container .mat-ripple-element,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-header-pagination .mat-ripple-element{background-color:#fff;opacity:.12}body.dark-mode .mat-snack-bar-container{color:rgba(0,0,0,.87);background:#fafafa;box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2), 0px 6px 10px 0px rgba(0, 0, 0, 0.14), 0px 1px 18px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-simple-snackbar-action{color:inherit}body.dark-mode .mat-table{background:#424242}body.dark-mode .mat-table thead,body.dark-mode .mat-table tbody,body.dark-mode .mat-table tfoot,body.dark-mode mat-header-row,body.dark-mode mat-row,body.dark-mode mat-footer-row,body.dark-mode [mat-header-row],body.dark-mode [mat-row],body.dark-mode [mat-footer-row],body.dark-mode .mat-table-sticky{background:inherit}body.dark-mode mat-row,body.dark-mode mat-header-row,body.dark-mode mat-footer-row,body.dark-mode th.mat-header-cell,body.dark-mode td.mat-cell,body.dark-mode td.mat-footer-cell{border-bottom-color:rgba(255,255,255,.12)}body.dark-mode .mat-header-cell{color:rgba(255,255,255,.7)}body.dark-mode .mat-cell,body.dark-mode .mat-footer-cell{color:#fff}body.dark-mode .mat-badge-content{color:#fff;background:#ef6c00}.cdk-high-contrast-active body.dark-mode .mat-badge-content{outline:solid 1px;border-radius:0}body.dark-mode .mat-badge-accent .mat-badge-content{background:#ef6c00;color:#fff}body.dark-mode .mat-badge-warn .mat-badge-content{color:#fff;background:#f44336}body.dark-mode .mat-badge-disabled .mat-badge-content{background:#6e6e6e;color:#616161}body.dark-mode .mat-bottom-sheet-container{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2), 0px 16px 24px 2px rgba(0, 0, 0, 0.14), 0px 6px 30px 5px rgba(0, 0, 0, 0.12);background:#424242;color:#fff}body.dark-mode .mat-button-toggle-standalone:not([class*=mat-elevation-z]),body.dark-mode .mat-button-toggle-group:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2), 0px 2px 2px 0px rgba(0, 0, 0, 0.14), 0px 1px 5px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-button-toggle-standalone.mat-button-toggle-appearance-standard:not([class*=mat-elevation-z]),body.dark-mode .mat-button-toggle-group-appearance-standard:not([class*=mat-elevation-z]){box-shadow:none}body.dark-mode .mat-button-toggle{color:rgba(255,255,255,.5)}body.dark-mode .mat-button-toggle .mat-button-toggle-focus-overlay{background-color:rgba(255,255,255,.12)}body.dark-mode .mat-button-toggle-appearance-standard{color:#fff;background:#424242}body.dark-mode .mat-button-toggle-appearance-standard .mat-button-toggle-focus-overlay{background-color:#fff}body.dark-mode .mat-button-toggle-group-appearance-standard .mat-button-toggle+.mat-button-toggle{border-left:solid 1px #595959}body.dark-mode [dir=rtl] .mat-button-toggle-group-appearance-standard .mat-button-toggle+.mat-button-toggle{border-left:none;border-right:solid 1px #595959}body.dark-mode .mat-button-toggle-group-appearance-standard.mat-button-toggle-vertical .mat-button-toggle+.mat-button-toggle{border-left:none;border-right:none;border-top:solid 1px #595959}body.dark-mode .mat-button-toggle-checked{background-color:#212121;color:rgba(255,255,255,.7)}body.dark-mode .mat-button-toggle-checked.mat-button-toggle-appearance-standard{color:#fff}body.dark-mode .mat-button-toggle-disabled{color:rgba(255,255,255,.3);background-color:#000}body.dark-mode .mat-button-toggle-disabled.mat-button-toggle-appearance-standard{background:#424242}body.dark-mode .mat-button-toggle-disabled.mat-button-toggle-checked{background-color:#424242}body.dark-mode .mat-button-toggle-standalone.mat-button-toggle-appearance-standard,body.dark-mode .mat-button-toggle-group-appearance-standard{border:solid 1px #595959}body.dark-mode .mat-button-toggle-appearance-standard .mat-button-toggle-label-content{line-height:48px}body.dark-mode .mat-calendar-arrow{fill:#fff}body.dark-mode .mat-datepicker-toggle,body.dark-mode .mat-datepicker-content .mat-calendar-next-button,body.dark-mode .mat-datepicker-content .mat-calendar-previous-button{color:#fff}body.dark-mode .mat-calendar-table-header-divider::after{background:rgba(255,255,255,.12)}body.dark-mode .mat-calendar-table-header,body.dark-mode .mat-calendar-body-label{color:rgba(255,255,255,.7)}body.dark-mode .mat-calendar-body-cell-content,body.dark-mode .mat-date-range-input-separator{color:#fff;border-color:rgba(0,0,0,0)}body.dark-mode .mat-calendar-body-disabled>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){color:#616161}body.dark-mode .mat-form-field-disabled .mat-date-range-input-separator{color:#616161}body.dark-mode .mat-calendar-body-in-preview{color:rgba(255,255,255,.24)}body.dark-mode .mat-calendar-body-today:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(255,255,255,.5)}body.dark-mode .mat-calendar-body-disabled>.mat-calendar-body-today:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(255,255,255,.3)}body.dark-mode .mat-calendar-body-in-range::before{background:rgba(239,108,0,.2)}body.dark-mode .mat-calendar-body-comparison-identical,body.dark-mode .mat-calendar-body-in-comparison-range::before{background:rgba(249,171,0,.2)}body.dark-mode .mat-calendar-body-comparison-bridge-start::before,body.dark-mode [dir=rtl] .mat-calendar-body-comparison-bridge-end::before{background:linear-gradient(to right, rgba(239, 108, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}body.dark-mode .mat-calendar-body-comparison-bridge-end::before,body.dark-mode [dir=rtl] .mat-calendar-body-comparison-bridge-start::before{background:linear-gradient(to left, rgba(239, 108, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}body.dark-mode .mat-calendar-body-in-range>.mat-calendar-body-comparison-identical,body.dark-mode .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range::after{background:#a8dab5}body.dark-mode .mat-calendar-body-comparison-identical.mat-calendar-body-selected,body.dark-mode .mat-calendar-body-in-comparison-range>.mat-calendar-body-selected{background:#46a35e}body.dark-mode .mat-calendar-body-selected{background-color:#ef6c00;color:#fff}body.dark-mode .mat-calendar-body-disabled>.mat-calendar-body-selected{background-color:rgba(239,108,0,.4)}body.dark-mode .mat-calendar-body-today.mat-calendar-body-selected{box-shadow:inset 0 0 0 1px #fff}body.dark-mode .cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical),body.dark-mode .cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(239,108,0,.3)}@media(hover: hover){body.dark-mode .mat-calendar-body-cell:not(.mat-calendar-body-disabled):hover>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(239,108,0,.3)}}body.dark-mode .mat-datepicker-content{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2), 0px 4px 5px 0px rgba(0, 0, 0, 0.14), 0px 1px 10px 0px rgba(0, 0, 0, 0.12);background-color:#424242;color:#fff}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-in-range::before{background:rgba(239,108,0,.2)}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-comparison-identical,body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-in-comparison-range::before{background:rgba(249,171,0,.2)}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-comparison-bridge-start::before,body.dark-mode .mat-datepicker-content.mat-accent [dir=rtl] .mat-calendar-body-comparison-bridge-end::before{background:linear-gradient(to right, rgba(239, 108, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-comparison-bridge-end::before,body.dark-mode .mat-datepicker-content.mat-accent [dir=rtl] .mat-calendar-body-comparison-bridge-start::before{background:linear-gradient(to left, rgba(239, 108, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-in-range>.mat-calendar-body-comparison-identical,body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range::after{background:#a8dab5}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-comparison-identical.mat-calendar-body-selected,body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-in-comparison-range>.mat-calendar-body-selected{background:#46a35e}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-selected{background-color:#ef6c00;color:#fff}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-disabled>.mat-calendar-body-selected{background-color:rgba(239,108,0,.4)}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-today.mat-calendar-body-selected{box-shadow:inset 0 0 0 1px #fff}body.dark-mode .mat-datepicker-content.mat-accent .cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical),body.dark-mode .mat-datepicker-content.mat-accent .cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(239,108,0,.3)}@media(hover: hover){body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-cell:not(.mat-calendar-body-disabled):hover>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(239,108,0,.3)}}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-in-range::before{background:rgba(244,67,54,.2)}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-comparison-identical,body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-in-comparison-range::before{background:rgba(249,171,0,.2)}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-comparison-bridge-start::before,body.dark-mode .mat-datepicker-content.mat-warn [dir=rtl] .mat-calendar-body-comparison-bridge-end::before{background:linear-gradient(to right, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-comparison-bridge-end::before,body.dark-mode .mat-datepicker-content.mat-warn [dir=rtl] .mat-calendar-body-comparison-bridge-start::before{background:linear-gradient(to left, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-in-range>.mat-calendar-body-comparison-identical,body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range::after{background:#a8dab5}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-comparison-identical.mat-calendar-body-selected,body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-in-comparison-range>.mat-calendar-body-selected{background:#46a35e}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-selected{background-color:#f44336;color:#fff}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-disabled>.mat-calendar-body-selected{background-color:rgba(244,67,54,.4)}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-today.mat-calendar-body-selected{box-shadow:inset 0 0 0 1px #fff}body.dark-mode .mat-datepicker-content.mat-warn .cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical),body.dark-mode .mat-datepicker-content.mat-warn .cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(244,67,54,.3)}@media(hover: hover){body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-cell:not(.mat-calendar-body-disabled):hover>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(244,67,54,.3)}}body.dark-mode .mat-datepicker-content-touch{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2), 0px 24px 38px 3px rgba(0, 0, 0, 0.14), 0px 9px 46px 8px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-datepicker-toggle-active{color:#ef6c00}body.dark-mode .mat-datepicker-toggle-active.mat-accent{color:#ef6c00}body.dark-mode .mat-datepicker-toggle-active.mat-warn{color:#f44336}body.dark-mode .mat-date-range-input-inner[disabled]{color:#616161}body.dark-mode .mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base{width:40px;height:40px;padding:8px}body.dark-mode .mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base .mdc-icon-button__focus-ring{max-height:40px;max-width:40px}body.dark-mode .mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base.mdc-icon-button--reduced-size .mdc-icon-button__ripple{width:40px;height:40px;margin-top:0px;margin-bottom:0px;margin-right:0px;margin-left:0px}body.dark-mode .mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base.mdc-icon-button--reduced-size .mdc-icon-button__focus-ring{max-height:40px;max-width:40px}body.dark-mode .mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base .mdc-icon-button__touch{position:absolute;top:50%;height:40px;left:50%;width:40px;transform:translate(-50%, -50%)}body.dark-mode .mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base .mat-mdc-button-touch-target{display:none}body.dark-mode .mat-divider{border-top-color:rgba(255,255,255,.12)}body.dark-mode .mat-divider-vertical{border-right-color:rgba(255,255,255,.12)}body.dark-mode .mat-expansion-panel{background:#424242;color:#fff}body.dark-mode .mat-expansion-panel:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2), 0px 2px 2px 0px rgba(0, 0, 0, 0.14), 0px 1px 5px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-action-row{border-top-color:rgba(255,255,255,.12)}body.dark-mode .mat-expansion-panel .mat-expansion-panel-header.cdk-keyboard-focused:not([aria-disabled=true]),body.dark-mode .mat-expansion-panel .mat-expansion-panel-header.cdk-program-focused:not([aria-disabled=true]),body.dark-mode .mat-expansion-panel:not(.mat-expanded) .mat-expansion-panel-header:hover:not([aria-disabled=true]){background:rgba(255,255,255,.04)}@media(hover: none){body.dark-mode .mat-expansion-panel:not(.mat-expanded):not([aria-disabled=true]) .mat-expansion-panel-header:hover{background:#424242}}body.dark-mode .mat-expansion-panel-header-title{color:#fff}body.dark-mode .mat-expansion-panel-header-description,body.dark-mode .mat-expansion-indicator::after{color:rgba(255,255,255,.7)}body.dark-mode .mat-expansion-panel-header[aria-disabled=true]{color:rgba(255,255,255,.3)}body.dark-mode .mat-expansion-panel-header[aria-disabled=true] .mat-expansion-panel-header-title,body.dark-mode .mat-expansion-panel-header[aria-disabled=true] .mat-expansion-panel-header-description{color:inherit}body.dark-mode .mat-expansion-panel-header{height:48px}body.dark-mode .mat-expansion-panel-header.mat-expanded{height:64px}body.dark-mode .mat-icon.mat-primary{color:#ef6c00}body.dark-mode .mat-icon.mat-accent{color:#ef6c00}body.dark-mode .mat-icon.mat-warn{color:#f44336}body.dark-mode .mat-drawer-container{background-color:#303030;color:#fff}body.dark-mode .mat-drawer{background-color:#424242;color:#fff}body.dark-mode .mat-drawer.mat-drawer-push{background-color:#424242}body.dark-mode .mat-drawer:not(.mat-drawer-side){box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2), 0px 16px 24px 2px rgba(0, 0, 0, 0.14), 0px 6px 30px 5px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-drawer-side{border-right:solid 1px rgba(255,255,255,.12)}body.dark-mode .mat-drawer-side.mat-drawer-end{border-left:solid 1px rgba(255,255,255,.12);border-right:none}body.dark-mode [dir=rtl] .mat-drawer-side{border-left:solid 1px rgba(255,255,255,.12);border-right:none}body.dark-mode [dir=rtl] .mat-drawer-side.mat-drawer-end{border-left:none;border-right:solid 1px rgba(255,255,255,.12)}body.dark-mode .mat-drawer-backdrop.mat-drawer-shown{background-color:rgba(189,189,189,.6)}body.dark-mode .mat-step-header.cdk-keyboard-focused,body.dark-mode .mat-step-header.cdk-program-focused,body.dark-mode .mat-step-header:hover:not([aria-disabled]),body.dark-mode .mat-step-header:hover[aria-disabled=false]{background-color:rgba(255,255,255,.04)}body.dark-mode .mat-step-header:hover[aria-disabled=true]{cursor:default}@media(hover: none){body.dark-mode .mat-step-header:hover{background:none}}body.dark-mode .mat-step-header .mat-step-label,body.dark-mode .mat-step-header .mat-step-optional{color:rgba(255,255,255,.7)}body.dark-mode .mat-step-header .mat-step-icon{background-color:rgba(255,255,255,.7);color:#fff}body.dark-mode .mat-step-header .mat-step-icon-selected,body.dark-mode .mat-step-header .mat-step-icon-state-done,body.dark-mode .mat-step-header .mat-step-icon-state-edit{background-color:#ef6c00;color:#fff}body.dark-mode .mat-step-header.mat-accent .mat-step-icon{color:#fff}body.dark-mode .mat-step-header.mat-accent .mat-step-icon-selected,body.dark-mode .mat-step-header.mat-accent .mat-step-icon-state-done,body.dark-mode .mat-step-header.mat-accent .mat-step-icon-state-edit{background-color:#ef6c00;color:#fff}body.dark-mode .mat-step-header.mat-warn .mat-step-icon{color:#fff}body.dark-mode .mat-step-header.mat-warn .mat-step-icon-selected,body.dark-mode .mat-step-header.mat-warn .mat-step-icon-state-done,body.dark-mode .mat-step-header.mat-warn .mat-step-icon-state-edit{background-color:#f44336;color:#fff}body.dark-mode .mat-step-header .mat-step-icon-state-error{background-color:rgba(0,0,0,0);color:#f44336}body.dark-mode .mat-step-header .mat-step-label.mat-step-label-active{color:#fff}body.dark-mode .mat-step-header .mat-step-label.mat-step-label-error{color:#f44336}body.dark-mode .mat-stepper-horizontal,body.dark-mode .mat-stepper-vertical{background-color:#424242}body.dark-mode .mat-stepper-vertical-line::before{border-left-color:rgba(255,255,255,.12)}body.dark-mode .mat-horizontal-stepper-header::before,body.dark-mode .mat-horizontal-stepper-header::after,body.dark-mode .mat-stepper-horizontal-line{border-top-color:rgba(255,255,255,.12)}body.dark-mode .mat-horizontal-stepper-header{height:72px}body.dark-mode .mat-stepper-label-position-bottom .mat-horizontal-stepper-header,body.dark-mode .mat-vertical-stepper-header{padding:24px 24px}body.dark-mode .mat-stepper-vertical-line::before{top:-16px;bottom:-16px}body.dark-mode .mat-stepper-label-position-bottom .mat-horizontal-stepper-header::after,body.dark-mode .mat-stepper-label-position-bottom .mat-horizontal-stepper-header::before{top:36px}body.dark-mode .mat-stepper-label-position-bottom .mat-stepper-horizontal-line{top:36px}body.dark-mode .mat-sort-header-arrow{color:#c6c6c6}body.dark-mode .mat-toolbar{background:#ef6c00;color:#fff}body.dark-mode .mat-toolbar.mat-primary{background:#ef6c00;color:#fff}body.dark-mode .mat-toolbar.mat-accent{background:#ef6c00;color:#fff}body.dark-mode .mat-toolbar.mat-warn{background:#f44336;color:#fff}body.dark-mode .mat-toolbar .mat-form-field-underline,body.dark-mode .mat-toolbar .mat-form-field-ripple,body.dark-mode .mat-toolbar .mat-focused .mat-form-field-ripple{background-color:currentColor}body.dark-mode .mat-toolbar .mat-form-field-label,body.dark-mode .mat-toolbar .mat-focused .mat-form-field-label,body.dark-mode .mat-toolbar .mat-select-value,body.dark-mode .mat-toolbar .mat-select-arrow,body.dark-mode .mat-toolbar .mat-form-field.mat-focused .mat-select-arrow{color:inherit}body.dark-mode .mat-toolbar .mat-input-element{caret-color:currentColor}body.dark-mode .mat-toolbar-multiple-rows{min-height:64px}body.dark-mode .mat-toolbar-row,body.dark-mode .mat-toolbar-single-row{height:64px}@media(max-width: 599px){body.dark-mode .mat-toolbar-multiple-rows{min-height:56px}body.dark-mode .mat-toolbar-row,body.dark-mode .mat-toolbar-single-row{height:56px}}body.dark-mode .mat-tree{background:#424242}body.dark-mode .mat-tree-node,body.dark-mode .mat-nested-tree-node{color:#fff}body.dark-mode .mat-tree-node{min-height:48px}
</style>

<style>
  html,
  body {
    margin: 0;
    padding: 0;
    height: 100%;
    font-family: Roboto, sans-serif;
    color: var(--primary-text-color);

    /* Legacy mechanism to avoid issues with subpixel anti-aliasing on macOS.
     *
     * In the past [1], macOS subpixel AA caused excessive bolding for light-on-dark text; this rule
     * avoids that by requesting non-subpixel AA always, rather than the default behavior, which is
     * to use subpixel AA when available. The original issue was "fixed" by removing subpixel AA in
     * macOS 14 (Mojave), but for legacy reasons they preserved the bolding effect as an option.
     * Chrome then in turn updated its font rendering to apply that bolding effect [2], which means
     * that even though the `-webkit-font-smoothing` docs [3] suggest that setting `antialiased`
     * would have no effect for recent versions of macOS, it still is needed to avoid the bolding.
     *
     * [1]: http://www.lighterra.com/articles/macosxtextaabug/
     * [2]: https://bugs.chromium.org/p/chromium/issues/detail?id=858861
     * [3]: https://developer.mozilla.org/en-US/docs/Web/CSS/font-smooth
     *
     */

    -webkit-font-smoothing: antialiased;
  }
  noscript {
    display: block;
    margin: 0 auto;
    max-width: 600px;
    padding: 10px;
  }
</style>

</head><body><noscript>
    <h1>TensorBoard requires JavaScript</h1>
    <p>Please enable JavaScript and reload this page.</p>
  </noscript><tb-webapp></tb-webapp><script src="index.js?_file_hash=62538f61"></script></body></html>", + "ok": true, + "headers": [ + [ + "content-type", + "text/html; charset=utf-8" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6006/font-roboto/oMMgfZMQthOryQo9n22dcuvvDin1pK8aKteLpeZ5c0A.woff2": { + "data": "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", + "ok": true, + "headers": [ + [ + "content-type", + "font/woff2" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6006/index.js?_file_hash=62538f61": { + "data": "var CLOSURE_NO_DEPS = true;
window.polymerSkipLoadingFontRoboto = true;
// Copyright 2014 Google Inc. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
//     You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//     See the License for the specific language governing permissions and
// limitations under the License.

!function(){var a={},b={},c={};!function(a,b){function c(a){if("number"==typeof a)return a;var b={};for(var c in a)b[c]=a[c];return b}function d(){this._delay=0,this._endDelay=0,this._fill="none",this._iterationStart=0,this._iterations=1,this._duration=0,this._playbackRate=1,this._direction="normal",this._easing="linear",this._easingFunction=x}function e(){return a.isDeprecated("Invalid timing inputs","2016-03-02","TypeError exceptions will be thrown instead.",!0)}function f(b,c,e){var f=new d;return c&&(f.fill="both",f.duration="auto"),"number"!=typeof b||isNaN(b)?void 0!==b&&Object.getOwnPropertyNames(b).forEach(function(c){if("auto"!=b[c]){if(("number"==typeof f[c]||"duration"==c)&&("number"!=typeof b[c]||isNaN(b[c])))return;if("fill"==c&&-1==v.indexOf(b[c]))return;if("direction"==c&&-1==w.indexOf(b[c]))return;if("playbackRate"==c&&1!==b[c]&&a.isDeprecated("AnimationEffectTiming.playbackRate","2014-11-28","Use Animation.playbackRate instead."))return;f[c]=b[c]}}):f.duration=b,f}function g(a){return"number"==typeof a&&(a=isNaN(a)?{duration:0}:{duration:a}),a}function h(b,c){return b=a.numericTimingToObject(b),f(b,c)}function i(a,b,c,d){return a<0||a>1||c<0||c>1?x:function(e){function f(a,b,c){return 3*a*(1-c)*(1-c)*c+3*b*(1-c)*c*c+c*c*c}if(e<=0){var g=0;return a>0?g=b/a:!b&&c>0&&(g=d/c),g*e}if(e>=1){var h=0;return c<1?h=(d-1)/(c-1):1==c&&a<1&&(h=(b-1)/(a-1)),1+h*(e-1)}for(var i=0,j=1;i<j;){var k=(i+j)/2,l=f(a,c,k);if(Math.abs(e-l)<1e-5)return f(b,d,k);l<e?i=k:j=k}return f(b,d,k)}}function j(a,b){return function(c){if(c>=1)return 1;var d=1/a;return(c+=b*d)-c%d}}function k(a){C||(C=document.createElement("div").style),C.animationTimingFunction="",C.animationTimingFunction=a;var b=C.animationTimingFunction;if(""==b&&e())throw new TypeError(a+" is not a valid value for easing");return b}function l(a){if("linear"==a)return x;var b=E.exec(a);if(b)return i.apply(this,b.slice(1).map(Number));var c=F.exec(a);if(c)return j(Number(c[1]),A);var d=G.exec(a);return d?j(Number(d[1]),{start:y,middle:z,end:A}[d[2]]):B[a]||x}function m(a){return Math.abs(n(a)/a.playbackRate)}function n(a){return 0===a.duration||0===a.iterations?0:a.duration*a.iterations}function o(a,b,c){if(null==b)return H;var d=c.delay+a+c.endDelay;return b<Math.min(c.delay,d)?I:b>=Math.min(c.delay+a,d)?J:K}function p(a,b,c,d,e){switch(d){case I:return"backwards"==b||"both"==b?0:null;case K:return c-e;case J:return"forwards"==b||"both"==b?a:null;case H:return null}}function q(a,b,c,d,e){var f=e;return 0===a?b!==I&&(f+=c):f+=d/a,f}function r(a,b,c,d,e,f){var g=a===1/0?b%1:a%1;return 0!==g||c!==J||0===d||0===e&&0!==f||(g=1),g}function s(a,b,c,d){return a===J&&b===1/0?1/0:1===c?Math.floor(d)-1:Math.floor(d)}function t(a,b,c){var d=a;if("normal"!==a&&"reverse"!==a){var e=b;"alternate-reverse"===a&&(e+=1),d="normal",e!==1/0&&e%2!=0&&(d="reverse")}return"normal"===d?c:1-c}function u(a,b,c){var d=o(a,b,c),e=p(a,c.fill,b,d,c.delay);if(null===e)return null;var f=q(c.duration,d,c.iterations,e,c.iterationStart),g=r(f,c.iterationStart,d,c.iterations,e,c.duration),h=s(d,c.iterations,g,f),i=t(c.direction,h,g);return c._easingFunction(i)}var v="backwards|forwards|both|none".split("|"),w="reverse|alternate|alternate-reverse".split("|"),x=function(a){return a};d.prototype={_setMember:function(b,c){this["_"+b]=c,this._effect&&(this._effect._timingInput[b]=c,this._effect._timing=a.normalizeTimingInput(this._effect._timingInput),this._effect.activeDuration=a.calculateActiveDuration(this._effect._timing),this._effect._animation&&this._effect._animation._rebuildUnderlyingAnimation())},get playbackRate(){return this._playbackRate},set delay(a){this._setMember("delay",a)},get delay(){return this._delay},set endDelay(a){this._setMember("endDelay",a)},get endDelay(){return this._endDelay},set fill(a){this._setMember("fill",a)},get fill(){return this._fill},set iterationStart(a){if((isNaN(a)||a<0)&&e())throw new TypeError("iterationStart must be a non-negative number, received: "+a);this._setMember("iterationStart",a)},get iterationStart(){return this._iterationStart},set duration(a){if("auto"!=a&&(isNaN(a)||a<0)&&e())throw new TypeError("duration must be non-negative or auto, received: "+a);this._setMember("duration",a)},get duration(){return this._duration},set direction(a){this._setMember("direction",a)},get direction(){return this._direction},set easing(a){this._easingFunction=l(k(a)),this._setMember("easing",a)},get easing(){return this._easing},set iterations(a){if((isNaN(a)||a<0)&&e())throw new TypeError("iterations must be non-negative, received: "+a);this._setMember("iterations",a)},get iterations(){return this._iterations}};var y=1,z=.5,A=0,B={ease:i(.25,.1,.25,1),"ease-in":i(.42,0,1,1),"ease-out":i(0,0,.58,1),"ease-in-out":i(.42,0,.58,1),"step-start":j(1,y),"step-middle":j(1,z),"step-end":j(1,A)},C=null,D="\\s*(-?\\d+\\.?\\d*|-?\\.\\d+)\\s*",E=new RegExp("cubic-bezier\\("+D+","+D+","+D+","+D+"\\)"),F=/steps\(\s*(\d+)\s*\)/,G=/steps\(\s*(\d+)\s*,\s*(start|middle|end)\s*\)/,H=0,I=1,J=2,K=3;a.cloneTimingInput=c,a.makeTiming=f,a.numericTimingToObject=g,a.normalizeTimingInput=h,a.calculateActiveDuration=m,a.calculateIterationProgress=u,a.calculatePhase=o,a.normalizeEasing=k,a.parseEasingFunction=l}(a),function(a,b){function c(a,b){return a in k?k[a][b]||b:b}function d(a){return"display"===a||0===a.lastIndexOf("animation",0)||0===a.lastIndexOf("transition",0)}function e(a,b,e){if(!d(a)){var f=h[a];if(f){i.style[a]=b;for(var g in f){var j=f[g],k=i.style[j];e[j]=c(j,k)}}else e[a]=c(a,b)}}function f(a){var b=[];for(var c in a)if(!(c in["easing","offset","composite"])){var d=a[c];Array.isArray(d)||(d=[d]);for(var e,f=d.length,g=0;g<f;g++)e={},e.offset="offset"in a?a.offset:1==f?1:g/(f-1),"easing"in a&&(e.easing=a.easing),"composite"in a&&(e.composite=a.composite),e[c]=d[g],b.push(e)}return b.sort(function(a,b){return a.offset-b.offset}),b}function g(b){function c(){var a=d.length;null==d[a-1].offset&&(d[a-1].offset=1),a>1&&null==d[0].offset&&(d[0].offset=0);for(var b=0,c=d[0].offset,e=1;e<a;e++){var f=d[e].offset;if(null!=f){for(var g=1;g<e-b;g++)d[b+g].offset=c+(f-c)*g/(e-b);b=e,c=f}}}if(null==b)return[];window.Symbol&&Symbol.iterator&&Array.prototype.from&&b[Symbol.iterator]&&(b=Array.from(b)),Array.isArray(b)||(b=f(b));for(var d=b.map(function(b){var c={};for(var d in b){var f=b[d];if("offset"==d){if(null!=f){if(f=Number(f),!isFinite(f))throw new TypeError("Keyframe offsets must be numbers.");if(f<0||f>1)throw new TypeError("Keyframe offsets must be between 0 and 1.")}}else if("composite"==d){if("add"==f||"accumulate"==f)throw{type:DOMException.NOT_SUPPORTED_ERR,name:"NotSupportedError",message:"add compositing is not supported"};if("replace"!=f)throw new TypeError("Invalid composite mode "+f+".")}else f="easing"==d?a.normalizeEasing(f):""+f;e(d,f,c)}return void 0==c.offset&&(c.offset=null),void 0==c.easing&&(c.easing="linear"),c}),g=!0,h=-1/0,i=0;i<d.length;i++){var j=d[i].offset;if(null!=j){if(j<h)throw new TypeError("Keyframes are not loosely sorted by offset. Sort or specify offsets.");h=j}else g=!1}return d=d.filter(function(a){return a.offset>=0&&a.offset<=1}),g||c(),d}var h={background:["backgroundImage","backgroundPosition","backgroundSize","backgroundRepeat","backgroundAttachment","backgroundOrigin","backgroundClip","backgroundColor"],border:["borderTopColor","borderTopStyle","borderTopWidth","borderRightColor","borderRightStyle","borderRightWidth","borderBottomColor","borderBottomStyle","borderBottomWidth","borderLeftColor","borderLeftStyle","borderLeftWidth"],borderBottom:["borderBottomWidth","borderBottomStyle","borderBottomColor"],borderColor:["borderTopColor","borderRightColor","borderBottomColor","borderLeftColor"],borderLeft:["borderLeftWidth","borderLeftStyle","borderLeftColor"],borderRadius:["borderTopLeftRadius","borderTopRightRadius","borderBottomRightRadius","borderBottomLeftRadius"],borderRight:["borderRightWidth","borderRightStyle","borderRightColor"],borderTop:["borderTopWidth","borderTopStyle","borderTopColor"],borderWidth:["borderTopWidth","borderRightWidth","borderBottomWidth","borderLeftWidth"],flex:["flexGrow","flexShrink","flexBasis"],font:["fontFamily","fontSize","fontStyle","fontVariant","fontWeight","lineHeight"],margin:["marginTop","marginRight","marginBottom","marginLeft"],outline:["outlineColor","outlineStyle","outlineWidth"],padding:["paddingTop","paddingRight","paddingBottom","paddingLeft"]},i=document.createElementNS("http://www.w3.org/1999/xhtml","div"),j={thin:"1px",medium:"3px",thick:"5px"},k={borderBottomWidth:j,borderLeftWidth:j,borderRightWidth:j,borderTopWidth:j,fontSize:{"xx-small":"60%","x-small":"75%",small:"89%",medium:"100%",large:"120%","x-large":"150%","xx-large":"200%"},fontWeight:{normal:"400",bold:"700"},outlineWidth:j,textShadow:{none:"0px 0px 0px transparent"},boxShadow:{none:"0px 0px 0px 0px transparent"}};a.convertToArrayForm=f,a.normalizeKeyframes=g}(a),function(a){var b={};a.isDeprecated=function(a,c,d,e){var f=e?"are":"is",g=new Date,h=new Date(c);return h.setMonth(h.getMonth()+3),!(g<h&&(a in b||console.warn("Web Animations: "+a+" "+f+" deprecated and will stop working on "+h.toDateString()+". "+d),b[a]=!0,1))},a.deprecated=function(b,c,d,e){var f=e?"are":"is";if(a.isDeprecated(b,c,d,e))throw new Error(b+" "+f+" no longer supported. "+d)}}(a),function(){if(document.documentElement.animate){var c=document.documentElement.animate([],0),d=!0;if(c&&(d=!1,"play|currentTime|pause|reverse|playbackRate|cancel|finish|startTime|playState".split("|").forEach(function(a){void 0===c[a]&&(d=!0)})),!d)return}!function(a,b,c){function d(a){for(var b={},c=0;c<a.length;c++)for(var d in a[c])if("offset"!=d&&"easing"!=d&&"composite"!=d){var e={offset:a[c].offset,easing:a[c].easing,value:a[c][d]};b[d]=b[d]||[],b[d].push(e)}for(var f in b){var g=b[f];if(0!=g[0].offset||1!=g[g.length-1].offset)throw{type:DOMException.NOT_SUPPORTED_ERR,name:"NotSupportedError",message:"Partial keyframes are not supported"}}return b}function e(c){var d=[];for(var e in c)for(var f=c[e],g=0;g<f.length-1;g++){var h=g,i=g+1,j=f[h].offset,k=f[i].offset,l=j,m=k;0==g&&(l=-1/0,0==k&&(i=h)),g==f.length-2&&(m=1/0,1==j&&(h=i)),d.push({applyFrom:l,applyTo:m,startOffset:f[h].offset,endOffset:f[i].offset,easingFunction:a.parseEasingFunction(f[h].easing),property:e,interpolation:b.propertyInterpolation(e,f[h].value,f[i].value)})}return d.sort(function(a,b){return a.startOffset-b.startOffset}),d}b.convertEffectInput=function(c){var f=a.normalizeKeyframes(c),g=d(f),h=e(g);return function(a,c){if(null!=c)h.filter(function(a){return c>=a.applyFrom&&c<a.applyTo}).forEach(function(d){var e=c-d.startOffset,f=d.endOffset-d.startOffset,g=0==f?0:d.easingFunction(e/f);b.apply(a,d.property,d.interpolation(g))});else for(var d in g)"offset"!=d&&"easing"!=d&&"composite"!=d&&b.clear(a,d)}}}(a,b),function(a,b,c){function d(a){return a.replace(/-(.)/g,function(a,b){return b.toUpperCase()})}function e(a,b,c){h[c]=h[c]||[],h[c].push([a,b])}function f(a,b,c){for(var f=0;f<c.length;f++){e(a,b,d(c[f]))}}function g(c,e,f){var g=c;/-/.test(c)&&!a.isDeprecated("Hyphenated property names","2016-03-22","Use camelCase instead.",!0)&&(g=d(c)),"initial"!=e&&"initial"!=f||("initial"==e&&(e=i[g]),"initial"==f&&(f=i[g]));for(var j=e==f?[]:h[g],k=0;j&&k<j.length;k++){var l=j[k][0](e),m=j[k][0](f);if(void 0!==l&&void 0!==m){var n=j[k][1](l,m);if(n){var o=b.Interpolation.apply(null,n);return function(a){return 0==a?e:1==a?f:o(a)}}}}return b.Interpolation(!1,!0,function(a){return a?f:e})}var h={};b.addPropertiesHandler=f;var i={backgroundColor:"transparent",backgroundPosition:"0% 0%",borderBottomColor:"currentColor",borderBottomLeftRadius:"0px",borderBottomRightRadius:"0px",borderBottomWidth:"3px",borderLeftColor:"currentColor",borderLeftWidth:"3px",borderRightColor:"currentColor",borderRightWidth:"3px",borderSpacing:"2px",borderTopColor:"currentColor",borderTopLeftRadius:"0px",borderTopRightRadius:"0px",borderTopWidth:"3px",bottom:"auto",clip:"rect(0px, 0px, 0px, 0px)",color:"black",fontSize:"100%",fontWeight:"400",height:"auto",left:"auto",letterSpacing:"normal",lineHeight:"120%",marginBottom:"0px",marginLeft:"0px",marginRight:"0px",marginTop:"0px",maxHeight:"none",maxWidth:"none",minHeight:"0px",minWidth:"0px",opacity:"1.0",outlineColor:"invert",outlineOffset:"0px",outlineWidth:"3px",paddingBottom:"0px",paddingLeft:"0px",paddingRight:"0px",paddingTop:"0px",right:"auto",strokeDasharray:"none",strokeDashoffset:"0px",textIndent:"0px",textShadow:"0px 0px 0px transparent",top:"auto",transform:"",verticalAlign:"0px",visibility:"visible",width:"auto",wordSpacing:"normal",zIndex:"auto"};b.propertyInterpolation=g}(a,b),function(a,b,c){function d(b){var c=a.calculateActiveDuration(b),d=function(d){return a.calculateIterationProgress(c,d,b)};return d._totalDuration=b.delay+c+b.endDelay,d}b.KeyframeEffect=function(c,e,f,g){var h,i=d(a.normalizeTimingInput(f)),j=b.convertEffectInput(e),k=function(){j(c,h)};return k._update=function(a){return null!==(h=i(a))},k._clear=function(){j(c,null)},k._hasSameTarget=function(a){return c===a},k._target=c,k._totalDuration=i._totalDuration,k._id=g,k}}(a,b),function(a,b){a.apply=function(b,c,d){b.style[a.propertyName(c)]=d},a.clear=function(b,c){b.style[a.propertyName(c)]=""}}(b),function(a){window.Element.prototype.animate=function(b,c){var d="";return c&&c.id&&(d=c.id),a.timeline._play(a.KeyframeEffect(this,b,c,d))}}(b),function(a,b){function c(a,b,d){if("number"==typeof a&&"number"==typeof b)return a*(1-d)+b*d;if("boolean"==typeof a&&"boolean"==typeof b)return d<.5?a:b;if(a.length==b.length){for(var e=[],f=0;f<a.length;f++)e.push(c(a[f],b[f],d));return e}throw"Mismatched interpolation arguments "+a+":"+b}a.Interpolation=function(a,b,d){return function(e){return d(c(a,b,e))}}}(b),function(a,b,c){a.sequenceNumber=0;var d=function(a,b,c){this.target=a,this.currentTime=b,this.timelineTime=c,this.type="finish",this.bubbles=!1,this.cancelable=!1,this.currentTarget=a,this.defaultPrevented=!1,this.eventPhase=Event.AT_TARGET,this.timeStamp=Date.now()};b.Animation=function(b){this.id="",b&&b._id&&(this.id=b._id),this._sequenceNumber=a.sequenceNumber++,this._currentTime=0,this._startTime=null,this._paused=!1,this._playbackRate=1,this._inTimeline=!0,this._finishedFlag=!0,this.onfinish=null,this._finishHandlers=[],this._effect=b,this._inEffect=this._effect._update(0),this._idle=!0,this._currentTimePending=!1},b.Animation.prototype={_ensureAlive:function(){this.playbackRate<0&&0===this.currentTime?this._inEffect=this._effect._update(-1):this._inEffect=this._effect._update(this.currentTime),this._inTimeline||!this._inEffect&&this._finishedFlag||(this._inTimeline=!0,b.timeline._animations.push(this))},_tickCurrentTime:function(a,b){a!=this._currentTime&&(this._currentTime=a,this._isFinished&&!b&&(this._currentTime=this._playbackRate>0?this._totalDuration:0),this._ensureAlive())},get currentTime(){return this._idle||this._currentTimePending?null:this._currentTime},set currentTime(a){a=+a,isNaN(a)||(b.restart(),this._paused||null==this._startTime||(this._startTime=this._timeline.currentTime-a/this._playbackRate),this._currentTimePending=!1,this._currentTime!=a&&(this._idle&&(this._idle=!1,this._paused=!0),this._tickCurrentTime(a,!0),b.applyDirtiedAnimation(this)))},get startTime(){return this._startTime},set startTime(a){a=+a,isNaN(a)||this._paused||this._idle||(this._startTime=a,this._tickCurrentTime((this._timeline.currentTime-this._startTime)*this.playbackRate),b.applyDirtiedAnimation(this))},get playbackRate(){return this._playbackRate},set playbackRate(a){if(a!=this._playbackRate){var c=this.currentTime;this._playbackRate=a,this._startTime=null,"paused"!=this.playState&&"idle"!=this.playState&&(this._finishedFlag=!1,this._idle=!1,this._ensureAlive(),b.applyDirtiedAnimation(this)),null!=c&&(this.currentTime=c)}},get _isFinished(){return!this._idle&&(this._playbackRate>0&&this._currentTime>=this._totalDuration||this._playbackRate<0&&this._currentTime<=0)},get _totalDuration(){return this._effect._totalDuration},get playState(){return this._idle?"idle":null==this._startTime&&!this._paused&&0!=this.playbackRate||this._currentTimePending?"pending":this._paused?"paused":this._isFinished?"finished":"running"},_rewind:function(){if(this._playbackRate>=0)this._currentTime=0;else{if(!(this._totalDuration<1/0))throw new DOMException("Unable to rewind negative playback rate animation with infinite duration","InvalidStateError");this._currentTime=this._totalDuration}},play:function(){this._paused=!1,(this._isFinished||this._idle)&&(this._rewind(),this._startTime=null),this._finishedFlag=!1,this._idle=!1,this._ensureAlive(),b.applyDirtiedAnimation(this)},pause:function(){this._isFinished||this._paused||this._idle?this._idle&&(this._rewind(),this._idle=!1):this._currentTimePending=!0,this._startTime=null,this._paused=!0},finish:function(){this._idle||(this.currentTime=this._playbackRate>0?this._totalDuration:0,this._startTime=this._totalDuration-this.currentTime,this._currentTimePending=!1,b.applyDirtiedAnimation(this))},cancel:function(){this._inEffect&&(this._inEffect=!1,this._idle=!0,this._paused=!1,this._finishedFlag=!0,this._currentTime=0,this._startTime=null,this._effect._update(null),b.applyDirtiedAnimation(this))},reverse:function(){this.playbackRate*=-1,this.play()},addEventListener:function(a,b){"function"==typeof b&&"finish"==a&&this._finishHandlers.push(b)},removeEventListener:function(a,b){if("finish"==a){var c=this._finishHandlers.indexOf(b);c>=0&&this._finishHandlers.splice(c,1)}},_fireEvents:function(a){if(this._isFinished){if(!this._finishedFlag){var b=new d(this,this._currentTime,a),c=this._finishHandlers.concat(this.onfinish?[this.onfinish]:[]);setTimeout(function(){c.forEach(function(a){a.call(b.target,b)})},0),this._finishedFlag=!0}}else this._finishedFlag=!1},_tick:function(a,b){this._idle||this._paused||(null==this._startTime?b&&(this.startTime=a-this._currentTime/this.playbackRate):this._isFinished||this._tickCurrentTime((a-this._startTime)*this.playbackRate)),b&&(this._currentTimePending=!1,this._fireEvents(a))},get _needsTick(){return this.playState in{pending:1,running:1}||!this._finishedFlag},_targetAnimations:function(){var a=this._effect._target;return a._activeAnimations||(a._activeAnimations=[]),a._activeAnimations},_markTarget:function(){var a=this._targetAnimations();-1===a.indexOf(this)&&a.push(this)},_unmarkTarget:function(){var a=this._targetAnimations(),b=a.indexOf(this);-1!==b&&a.splice(b,1)}}}(a,b),function(a,b,c){function d(a){var b=j;j=[],a<q.currentTime&&(a=q.currentTime),q._animations.sort(e),q._animations=h(a,!0,q._animations)[0],b.forEach(function(b){b[1](a)}),g(),l=void 0}function e(a,b){return a._sequenceNumber-b._sequenceNumber}function f(){this._animations=[],this.currentTime=window.performance&&performance.now?performance.now():0}function g(){o.forEach(function(a){a()}),o.length=0}function h(a,c,d){p=!0,n=!1,b.timeline.currentTime=a,m=!1;var e=[],f=[],g=[],h=[];return d.forEach(function(b){b._tick(a,c),b._inEffect?(f.push(b._effect),b._markTarget()):(e.push(b._effect),b._unmarkTarget()),b._needsTick&&(m=!0);var d=b._inEffect||b._needsTick;b._inTimeline=d,d?g.push(b):h.push(b)}),o.push.apply(o,e),o.push.apply(o,f),m&&requestAnimationFrame(function(){}),p=!1,[g,h]}var i=window.requestAnimationFrame,j=[],k=0;window.requestAnimationFrame=function(a){var b=k++;return 0==j.length&&i(d),j.push([b,a]),b},window.cancelAnimationFrame=function(a){j.forEach(function(b){b[0]==a&&(b[1]=function(){})})},f.prototype={_play:function(c){c._timing=a.normalizeTimingInput(c.timing);var d=new b.Animation(c);return d._idle=!1,d._timeline=this,this._animations.push(d),b.restart(),b.applyDirtiedAnimation(d),d}};var l=void 0,m=!1,n=!1;b.restart=function(){return m||(m=!0,requestAnimationFrame(function(){}),n=!0),n},b.applyDirtiedAnimation=function(a){if(!p){a._markTarget();var c=a._targetAnimations();c.sort(e),h(b.timeline.currentTime,!1,c.slice())[1].forEach(function(a){var b=q._animations.indexOf(a);-1!==b&&q._animations.splice(b,1)}),g()}};var o=[],p=!1,q=new f;b.timeline=q}(a,b),function(a){function b(a,b){var c=a.exec(b);if(c)return c=a.ignoreCase?c[0].toLowerCase():c[0],[c,b.substr(c.length)]}function c(a,b){b=b.replace(/^\s*/,"");var c=a(b);if(c)return[c[0],c[1].replace(/^\s*/,"")]}function d(a,d,e){a=c.bind(null,a);for(var f=[];;){var g=a(e);if(!g)return[f,e];if(f.push(g[0]),e=g[1],!(g=b(d,e))||""==g[1])return[f,e];e=g[1]}}function e(a,b){for(var c=0,d=0;d<b.length&&(!/\s|,/.test(b[d])||0!=c);d++)if("("==b[d])c++;else if(")"==b[d]&&(c--,0==c&&d++,c<=0))break;var e=a(b.substr(0,d));return void 0==e?void 0:[e,b.substr(d)]}function f(a,b){for(var c=a,d=b;c&&d;)c>d?c%=d:d%=c;return c=a*b/(c+d)}function g(a){return function(b){var c=a(b);return c&&(c[0]=void 0),c}}function h(a,b){return function(c){return a(c)||[b,c]}}function i(b,c){for(var d=[],e=0;e<b.length;e++){var f=a.consumeTrimmed(b[e],c);if(!f||""==f[0])return;void 0!==f[0]&&d.push(f[0]),c=f[1]}if(""==c)return d}function j(a,b,c,d,e){for(var g=[],h=[],i=[],j=f(d.length,e.length),k=0;k<j;k++){var l=b(d[k%d.length],e[k%e.length]);if(!l)return;g.push(l[0]),h.push(l[1]),i.push(l[2])}return[g,h,function(b){var d=b.map(function(a,b){return i[b](a)}).join(c);return a?a(d):d}]}function k(a,b,c){for(var d=[],e=[],f=[],g=0,h=0;h<c.length;h++)if("function"==typeof c[h]){var i=c[h](a[g],b[g++]);d.push(i[0]),e.push(i[1]),f.push(i[2])}else!function(a){d.push(!1),e.push(!1),f.push(function(){return c[a]})}(h);return[d,e,function(a){for(var b="",c=0;c<a.length;c++)b+=f[c](a[c]);return b}]}a.consumeToken=b,a.consumeTrimmed=c,a.consumeRepeated=d,a.consumeParenthesised=e,a.ignore=g,a.optional=h,a.consumeList=i,a.mergeNestedRepeated=j.bind(null,null),a.mergeWrappedNestedRepeated=j,a.mergeList=k}(b),function(a){function b(b){function c(b){var c=a.consumeToken(/^inset/i,b);return c?(d.inset=!0,c):(c=a.consumeLengthOrPercent(b))?(d.lengths.push(c[0]),c):(c=a.consumeColor(b),c?(d.color=c[0],c):void 0)}var d={inset:!1,lengths:[],color:null},e=a.consumeRepeated(c,/^/,b);if(e&&e[0].length)return[d,e[1]]}function c(c){var d=a.consumeRepeated(b,/^,/,c);if(d&&""==d[1])return d[0]}function d(b,c){for(;b.lengths.length<Math.max(b.lengths.length,c.lengths.length);)b.lengths.push({px:0});for(;c.lengths.length<Math.max(b.lengths.length,c.lengths.length);)c.lengths.push({px:0});if(b.inset==c.inset&&!!b.color==!!c.color){for(var d,e=[],f=[[],0],g=[[],0],h=0;h<b.lengths.length;h++){var i=a.mergeDimensions(b.lengths[h],c.lengths[h],2==h);f[0].push(i[0]),g[0].push(i[1]),e.push(i[2])}if(b.color&&c.color){var j=a.mergeColors(b.color,c.color);f[1]=j[0],g[1]=j[1],d=j[2]}return[f,g,function(a){for(var c=b.inset?"inset ":" ",f=0;f<e.length;f++)c+=e[f](a[0][f])+" ";return d&&(c+=d(a[1])),c}]}}function e(b,c,d,e){function f(a){return{inset:a,color:[0,0,0,0],lengths:[{px:0},{px:0},{px:0},{px:0}]}}for(var g=[],h=[],i=0;i<d.length||i<e.length;i++){var j=d[i]||f(e[i].inset),k=e[i]||f(d[i].inset);g.push(j),h.push(k)}return a.mergeNestedRepeated(b,c,g,h)}var f=e.bind(null,d,", ");a.addPropertiesHandler(c,f,["box-shadow","text-shadow"])}(b),function(a,b){function c(a){return a.toFixed(3).replace(/0+$/,"").replace(/\.$/,"")}function d(a,b,c){return Math.min(b,Math.max(a,c))}function e(a){if(/^\s*[-+]?(\d*\.)?\d+\s*$/.test(a))return Number(a)}function f(a,b){return[a,b,c]}function g(a,b){if(0!=a)return i(0,1/0)(a,b)}function h(a,b){return[a,b,function(a){return Math.round(d(1,1/0,a))}]}function i(a,b){return function(e,f){return[e,f,function(e){return c(d(a,b,e))}]}}function j(a){var b=a.trim().split(/\s*[\s,]\s*/);if(0!==b.length){for(var c=[],d=0;d<b.length;d++){var f=e(b[d]);if(void 0===f)return;c.push(f)}return c}}function k(a,b){if(a.length==b.length)return[a,b,function(a){return a.map(c).join(" ")}]}function l(a,b){return[a,b,Math.round]}a.clamp=d,a.addPropertiesHandler(j,k,["stroke-dasharray"]),a.addPropertiesHandler(e,i(0,1/0),["border-image-width","line-height"]),a.addPropertiesHandler(e,i(0,1),["opacity","shape-image-threshold"]),a.addPropertiesHandler(e,g,["flex-grow","flex-shrink"]),a.addPropertiesHandler(e,h,["orphans","widows"]),a.addPropertiesHandler(e,l,["z-index"]),a.parseNumber=e,a.parseNumberList=j,a.mergeNumbers=f,a.numberToString=c}(b),function(a,b){function c(a,b){if("visible"==a||"visible"==b)return[0,1,function(c){return c<=0?a:c>=1?b:"visible"}]}a.addPropertiesHandler(String,c,["visibility"])}(b),function(a,b){function c(a){a=a.trim(),f.fillStyle="#000",f.fillStyle=a;var b=f.fillStyle;if(f.fillStyle="#fff",f.fillStyle=a,b==f.fillStyle){f.fillRect(0,0,1,1);var c=f.getImageData(0,0,1,1).data;f.clearRect(0,0,1,1);var d=c[3]/255;return[c[0]*d,c[1]*d,c[2]*d,d]}}function d(b,c){return[b,c,function(b){function c(a){return Math.max(0,Math.min(255,a))}if(b[3])for(var d=0;d<3;d++)b[d]=Math.round(c(b[d]/b[3]));return b[3]=a.numberToString(a.clamp(0,1,b[3])),"rgba("+b.join(",")+")"}]}var e=document.createElementNS("http://www.w3.org/1999/xhtml","canvas");e.width=e.height=1;var f=e.getContext("2d");a.addPropertiesHandler(c,d,["background-color","border-bottom-color","border-left-color","border-right-color","border-top-color","color","fill","flood-color","lighting-color","outline-color","stop-color","stroke","text-decoration-color"]),a.consumeColor=a.consumeParenthesised.bind(null,c),a.mergeColors=d}(b),function(a,b){function c(a){function b(){var b=h.exec(a);g=b?b[0]:void 0}function c(){var a=Number(g);return b(),a}function d(){if("("!==g)return c();b();var a=f();return")"!==g?NaN:(b(),a)}function e(){for(var a=d();"*"===g||"/"===g;){var c=g;b();var e=d();"*"===c?a*=e:a/=e}return a}function f(){for(var a=e();"+"===g||"-"===g;){var c=g;b();var d=e();"+"===c?a+=d:a-=d}return a}var g,h=/([\+\-\w\.]+|[\(\)\*\/])/g;return b(),f()}function d(a,b){if("0"==(b=b.trim().toLowerCase())&&"px".search(a)>=0)return{px:0};if(/^[^(]*$|^calc/.test(b)){b=b.replace(/calc\(/g,"(");var d={};b=b.replace(a,function(a){return d[a]=null,"U"+a});for(var e="U("+a.source+")",f=b.replace(/[-+]?(\d*\.)?\d+([Ee][-+]?\d+)?/g,"N").replace(new RegExp("N"+e,"g"),"D").replace(/\s[+-]\s/g,"O").replace(/\s/g,""),g=[/N\*(D)/g,/(N|D)[*\/]N/g,/(N|D)O\1/g,/\((N|D)\)/g],h=0;h<g.length;)g[h].test(f)?(f=f.replace(g[h],"$1"),h=0):h++;if("D"==f){for(var i in d){var j=c(b.replace(new RegExp("U"+i,"g"),"").replace(new RegExp(e,"g"),"*0"));if(!isFinite(j))return;d[i]=j}return d}}}function e(a,b){return f(a,b,!0)}function f(b,c,d){var e,f=[];for(e in b)f.push(e);for(e in c)f.indexOf(e)<0&&f.push(e);return b=f.map(function(a){return b[a]||0}),c=f.map(function(a){return c[a]||0}),[b,c,function(b){var c=b.map(function(c,e){return 1==b.length&&d&&(c=Math.max(c,0)),a.numberToString(c)+f[e]}).join(" + ");return b.length>1?"calc("+c+")":c}]}var g="px|em|ex|ch|rem|vw|vh|vmin|vmax|cm|mm|in|pt|pc",h=d.bind(null,new RegExp(g,"g")),i=d.bind(null,new RegExp(g+"|%","g")),j=d.bind(null,/deg|rad|grad|turn/g);a.parseLength=h,a.parseLengthOrPercent=i,a.consumeLengthOrPercent=a.consumeParenthesised.bind(null,i),a.parseAngle=j,a.mergeDimensions=f;var k=a.consumeParenthesised.bind(null,h),l=a.consumeRepeated.bind(void 0,k,/^/),m=a.consumeRepeated.bind(void 0,l,/^,/);a.consumeSizePairList=m;var n=function(a){var b=m(a);if(b&&""==b[1])return b[0]},o=a.mergeNestedRepeated.bind(void 0,e," "),p=a.mergeNestedRepeated.bind(void 0,o,",");a.mergeNonNegativeSizePair=o,a.addPropertiesHandler(n,p,["background-size"]),a.addPropertiesHandler(i,e,["border-bottom-width","border-image-width","border-left-width","border-right-width","border-top-width","flex-basis","font-size","height","line-height","max-height","max-width","outline-width","width"]),a.addPropertiesHandler(i,f,["border-bottom-left-radius","border-bottom-right-radius","border-top-left-radius","border-top-right-radius","bottom","left","letter-spacing","margin-bottom","margin-left","margin-right","margin-top","min-height","min-width","outline-offset","padding-bottom","padding-left","padding-right","padding-top","perspective","right","shape-margin","stroke-dashoffset","text-indent","top","vertical-align","word-spacing"])}(b),function(a,b){function c(b){return a.consumeLengthOrPercent(b)||a.consumeToken(/^auto/,b)}function d(b){var d=a.consumeList([a.ignore(a.consumeToken.bind(null,/^rect/)),a.ignore(a.consumeToken.bind(null,/^\(/)),a.consumeRepeated.bind(null,c,/^,/),a.ignore(a.consumeToken.bind(null,/^\)/))],b);if(d&&4==d[0].length)return d[0]}function e(b,c){return"auto"==b||"auto"==c?[!0,!1,function(d){var e=d?b:c;if("auto"==e)return"auto";var f=a.mergeDimensions(e,e);return f[2](f[0])}]:a.mergeDimensions(b,c)}function f(a){return"rect("+a+")"}var g=a.mergeWrappedNestedRepeated.bind(null,f,e,", ");a.parseBox=d,a.mergeBoxes=g,a.addPropertiesHandler(d,g,["clip"])}(b),function(a,b){function c(a){return function(b){var c=0;return a.map(function(a){return a===k?b[c++]:a})}}function d(a){return a}function e(b){if("none"==(b=b.toLowerCase().trim()))return[];for(var c,d=/\s*(\w+)\(([^)]*)\)/g,e=[],f=0;c=d.exec(b);){if(c.index!=f)return;f=c.index+c[0].length;var g=c[1],h=n[g];if(!h)return;var i=c[2].split(","),j=h[0];if(j.length<i.length)return;for(var k=[],o=0;o<j.length;o++){var p,q=i[o],r=j[o];if(void 0===(p=q?{A:function(b){return"0"==b.trim()?m:a.parseAngle(b)},N:a.parseNumber,T:a.parseLengthOrPercent,L:a.parseLength}[r.toUpperCase()](q):{a:m,n:k[0],t:l}[r]))return;k.push(p)}if(e.push({t:g,d:k}),d.lastIndex==b.length)return e}}function f(a){return a.toFixed(6).replace(".000000","")}function g(b,c){if(b.decompositionPair!==c){b.decompositionPair=c;var d=a.makeMatrixDecomposition(b)}if(c.decompositionPair!==b){c.decompositionPair=b;var e=a.makeMatrixDecomposition(c)}return null==d[0]||null==e[0]?[[!1],[!0],function(a){return a?c[0].d:b[0].d}]:(d[0].push(0),e[0].push(1),[d,e,function(b){var c=a.quat(d[0][3],e[0][3],b[5]);return a.composeMatrix(b[0],b[1],b[2],c,b[4]).map(f).join(",")}])}function h(a){return a.replace(/[xy]/,"")}function i(a){return a.replace(/(x|y|z|3d)?$/,"3d")}function j(b,c){var d=a.makeMatrixDecomposition&&!0,e=!1;if(!b.length||!c.length){b.length||(e=!0,b=c,c=[]);for(var f=0;f<b.length;f++){var j=b[f].t,k=b[f].d,l="scale"==j.substr(0,5)?1:0;c.push({t:j,d:k.map(function(a){if("number"==typeof a)return l;var b={};for(var c in a)b[c]=l;return b})})}}var m=function(a,b){return"perspective"==a&&"perspective"==b||("matrix"==a||"matrix3d"==a)&&("matrix"==b||"matrix3d"==b)},o=[],p=[],q=[];if(b.length!=c.length){if(!d)return;var r=g(b,c);o=[r[0]],p=[r[1]],q=[["matrix",[r[2]]]]}else for(var f=0;f<b.length;f++){var j,s=b[f].t,t=c[f].t,u=b[f].d,v=c[f].d,w=n[s],x=n[t];if(m(s,t)){if(!d)return;var r=g([b[f]],[c[f]]);o.push(r[0]),p.push(r[1]),q.push(["matrix",[r[2]]])}else{if(s==t)j=s;else if(w[2]&&x[2]&&h(s)==h(t))j=h(s),u=w[2](u),v=x[2](v);else{if(!w[1]||!x[1]||i(s)!=i(t)){if(!d)return;var r=g(b,c);o=[r[0]],p=[r[1]],q=[["matrix",[r[2]]]];break}j=i(s),u=w[1](u),v=x[1](v)}for(var y=[],z=[],A=[],B=0;B<u.length;B++){var C="number"==typeof u[B]?a.mergeNumbers:a.mergeDimensions,r=C(u[B],v[B]);y[B]=r[0],z[B]=r[1],A.push(r[2])}o.push(y),p.push(z),q.push([j,A])}}if(e){var D=o;o=p,p=D}return[o,p,function(a){return a.map(function(a,b){var c=a.map(function(a,c){return q[b][1][c](a)}).join(",");return"matrix"==q[b][0]&&16==c.split(",").length&&(q[b][0]="matrix3d"),q[b][0]+"("+c+")"}).join(" ")}]}var k=null,l={px:0},m={deg:0},n={matrix:["NNNNNN",[k,k,0,0,k,k,0,0,0,0,1,0,k,k,0,1],d],matrix3d:["NNNNNNNNNNNNNNNN",d],rotate:["A"],rotatex:["A"],rotatey:["A"],rotatez:["A"],rotate3d:["NNNA"],perspective:["L"],scale:["Nn",c([k,k,1]),d],scalex:["N",c([k,1,1]),c([k,1])],scaley:["N",c([1,k,1]),c([1,k])],scalez:["N",c([1,1,k])],scale3d:["NNN",d],skew:["Aa",null,d],skewx:["A",null,c([k,m])],skewy:["A",null,c([m,k])],translate:["Tt",c([k,k,l]),d],translatex:["T",c([k,l,l]),c([k,l])],translatey:["T",c([l,k,l]),c([l,k])],translatez:["L",c([l,l,k])],translate3d:["TTL",d]};a.addPropertiesHandler(e,j,["transform"]),a.transformToSvgMatrix=function(b){var c=a.transformListToMatrix(e(b));return"matrix("+f(c[0])+" "+f(c[1])+" "+f(c[4])+" "+f(c[5])+" "+f(c[12])+" "+f(c[13])+")"}}(b),function(a,b){function c(a,b){b.concat([a]).forEach(function(b){b in document.documentElement.style&&(d[a]=b),e[b]=a})}var d={},e={};c("transform",["webkitTransform","msTransform"]),c("transformOrigin",["webkitTransformOrigin"]),c("perspective",["webkitPerspective"]),c("perspectiveOrigin",["webkitPerspectiveOrigin"]),a.propertyName=function(a){return d[a]||a},a.unprefixedPropertyName=function(a){return e[a]||a}}(b)}(),function(){if(void 0===document.createElement("div").animate([]).oncancel){var a;if(window.performance&&performance.now)var a=function(){return performance.now()};else var a=function(){return Date.now()};var b=function(a,b,c){this.target=a,this.currentTime=b,this.timelineTime=c,this.type="cancel",this.bubbles=!1,this.cancelable=!1,this.currentTarget=a,this.defaultPrevented=!1,this.eventPhase=Event.AT_TARGET,this.timeStamp=Date.now()},c=window.Element.prototype.animate;window.Element.prototype.animate=function(d,e){var f=c.call(this,d,e);f._cancelHandlers=[],f.oncancel=null;var g=f.cancel;f.cancel=function(){g.call(this);var c=new b(this,null,a()),d=this._cancelHandlers.concat(this.oncancel?[this.oncancel]:[]);setTimeout(function(){d.forEach(function(a){a.call(c.target,c)})},0)};var h=f.addEventListener;f.addEventListener=function(a,b){"function"==typeof b&&"cancel"==a?this._cancelHandlers.push(b):h.call(this,a,b)};var i=f.removeEventListener;return f.removeEventListener=function(a,b){if("cancel"==a){var c=this._cancelHandlers.indexOf(b);c>=0&&this._cancelHandlers.splice(c,1)}else i.call(this,a,b)},f}}}(),function(a){var b=document.documentElement,c=null,d=!1;try{var e=getComputedStyle(b).getPropertyValue("opacity"),f="0"==e?"1":"0";c=b.animate({opacity:[f,f]},{duration:1}),c.currentTime=0,d=getComputedStyle(b).getPropertyValue("opacity")==f}catch(a){}finally{c&&c.cancel()}if(!d){var g=window.Element.prototype.animate;window.Element.prototype.animate=function(b,c){return window.Symbol&&Symbol.iterator&&Array.prototype.from&&b[Symbol.iterator]&&(b=Array.from(b)),Array.isArray(b)||null===b||(b=a.convertToArrayForm(b)),g.call(this,b,c)}}}(a),function(a,b,c){function d(a){var c=b.timeline;c.currentTime=a,c._discardAnimations(),0==c._animations.length?f=!1:requestAnimationFrame(d)}var e=window.requestAnimationFrame;window.requestAnimationFrame=function(a){return e(function(c){b.timeline._updateAnimationsPromises(),a(c),b.timeline._updateAnimationsPromises()})},b.AnimationTimeline=function(){this._animations=[],this.currentTime=void 0},b.AnimationTimeline.prototype={getAnimations:function(){return this._discardAnimations(),this._animations.slice()},_updateAnimationsPromises:function(){b.animationsWithPromises=b.animationsWithPromises.filter(function(a){return a._updatePromises()})},_discardAnimations:function(){this._updateAnimationsPromises(),this._animations=this._animations.filter(function(a){return"finished"!=a.playState&&"idle"!=a.playState})},_play:function(a){var c=new b.Animation(a,this);return this._animations.push(c),b.restartWebAnimationsNextTick(),c._updatePromises(),c._animation.play(),c._updatePromises(),c},play:function(a){return a&&a.remove(),this._play(a)}};var f=!1;b.restartWebAnimationsNextTick=function(){f||(f=!0,requestAnimationFrame(d))};var g=new b.AnimationTimeline;b.timeline=g;try{Object.defineProperty(window.document,"timeline",{configurable:!0,get:function(){return g}})}catch(a){}try{window.document.timeline=g}catch(a){}}(0,c),function(a,b,c){b.animationsWithPromises=[],b.Animation=function(b,c){if(this.id="",b&&b._id&&(this.id=b._id),this.effect=b,b&&(b._animation=this),!c)throw new Error("Animation with null timeline is not supported");this._timeline=c,this._sequenceNumber=a.sequenceNumber++,this._holdTime=0,this._paused=!1,this._isGroup=!1,this._animation=null,this._childAnimations=[],this._callback=null,this._oldPlayState="idle",this._rebuildUnderlyingAnimation(),this._animation.cancel(),this._updatePromises()},b.Animation.prototype={_updatePromises:function(){var a=this._oldPlayState,b=this.playState;return this._readyPromise&&b!==a&&("idle"==b?(this._rejectReadyPromise(),this._readyPromise=void 0):"pending"==a?this._resolveReadyPromise():"pending"==b&&(this._readyPromise=void 0)),this._finishedPromise&&b!==a&&("idle"==b?(this._rejectFinishedPromise(),this._finishedPromise=void 0):"finished"==b?this._resolveFinishedPromise():"finished"==a&&(this._finishedPromise=void 0)),this._oldPlayState=this.playState,this._readyPromise||this._finishedPromise},_rebuildUnderlyingAnimation:function(){this._updatePromises();var a,c,d,e,f=!!this._animation;f&&(a=this.playbackRate,c=this._paused,d=this.startTime,e=this.currentTime,this._animation.cancel(),this._animation._wrapper=null,this._animation=null),(!this.effect||this.effect instanceof window.KeyframeEffect)&&(this._animation=b.newUnderlyingAnimationForKeyframeEffect(this.effect),b.bindAnimationForKeyframeEffect(this)),(this.effect instanceof window.SequenceEffect||this.effect instanceof window.GroupEffect)&&(this._animation=b.newUnderlyingAnimationForGroup(this.effect),b.bindAnimationForGroup(this)),this.effect&&this.effect._onsample&&b.bindAnimationForCustomEffect(this),f&&(1!=a&&(this.playbackRate=a),null!==d?this.startTime=d:null!==e?this.currentTime=e:null!==this._holdTime&&(this.currentTime=this._holdTime),c&&this.pause()),this._updatePromises()},_updateChildren:function(){if(this.effect&&"idle"!=this.playState){var a=this.effect._timing.delay;this._childAnimations.forEach(function(c){this._arrangeChildren(c,a),this.effect instanceof window.SequenceEffect&&(a+=b.groupChildDuration(c.effect))}.bind(this))}},_setExternalAnimation:function(a){if(this.effect&&this._isGroup)for(var b=0;b<this.effect.children.length;b++)this.effect.children[b]._animation=a,this._childAnimations[b]._setExternalAnimation(a)},_constructChildAnimations:function(){if(this.effect&&this._isGroup){var a=this.effect._timing.delay;this._removeChildAnimations(),this.effect.children.forEach(function(c){var d=b.timeline._play(c);this._childAnimations.push(d),d.playbackRate=this.playbackRate,this._paused&&d.pause(),c._animation=this.effect._animation,this._arrangeChildren(d,a),this.effect instanceof window.SequenceEffect&&(a+=b.groupChildDuration(c))}.bind(this))}},_arrangeChildren:function(a,b){null===this.startTime?a.currentTime=this.currentTime-b/this.playbackRate:a.startTime!==this.startTime+b/this.playbackRate&&(a.startTime=this.startTime+b/this.playbackRate)},get timeline(){return this._timeline},get playState(){return this._animation?this._animation.playState:"idle"},get finished(){return window.Promise?(this._finishedPromise||(-1==b.animationsWithPromises.indexOf(this)&&b.animationsWithPromises.push(this),this._finishedPromise=new Promise(function(a,b){this._resolveFinishedPromise=function(){a(this)},this._rejectFinishedPromise=function(){b({type:DOMException.ABORT_ERR,name:"AbortError"})}}.bind(this)),"finished"==this.playState&&this._resolveFinishedPromise()),this._finishedPromise):(console.warn("Animation Promises require JavaScript Promise constructor"),null)},get ready(){return window.Promise?(this._readyPromise||(-1==b.animationsWithPromises.indexOf(this)&&b.animationsWithPromises.push(this),this._readyPromise=new Promise(function(a,b){this._resolveReadyPromise=function(){a(this)},this._rejectReadyPromise=function(){b({type:DOMException.ABORT_ERR,name:"AbortError"})}}.bind(this)),"pending"!==this.playState&&this._resolveReadyPromise()),this._readyPromise):(console.warn("Animation Promises require JavaScript Promise constructor"),null)},get onfinish(){return this._animation.onfinish},set onfinish(a){this._animation.onfinish="function"==typeof a?function(b){b.target=this,a.call(this,b)}.bind(this):a},get oncancel(){return this._animation.oncancel},set oncancel(a){this._animation.oncancel="function"==typeof a?function(b){b.target=this,a.call(this,b)}.bind(this):a},get currentTime(){this._updatePromises();var a=this._animation.currentTime;return this._updatePromises(),a},set currentTime(a){this._updatePromises(),this._animation.currentTime=isFinite(a)?a:Math.sign(a)*Number.MAX_VALUE,this._register(),this._forEachChild(function(b,c){b.currentTime=a-c}),this._updatePromises()},get startTime(){return this._animation.startTime},set startTime(a){this._updatePromises(),this._animation.startTime=isFinite(a)?a:Math.sign(a)*Number.MAX_VALUE,this._register(),this._forEachChild(function(b,c){b.startTime=a+c}),this._updatePromises()},get playbackRate(){return this._animation.playbackRate},set playbackRate(a){this._updatePromises();var b=this.currentTime;this._animation.playbackRate=a,this._forEachChild(function(b){b.playbackRate=a}),null!==b&&(this.currentTime=b),this._updatePromises()},play:function(){this._updatePromises(),this._paused=!1,this._animation.play(),-1==this._timeline._animations.indexOf(this)&&this._timeline._animations.push(this),this._register(),b.awaitStartTime(this),this._forEachChild(function(a){var b=a.currentTime;a.play(),a.currentTime=b}),this._updatePromises()},pause:function(){this._updatePromises(),this.currentTime&&(this._holdTime=this.currentTime),this._animation.pause(),this._register(),this._forEachChild(function(a){a.pause()}),this._paused=!0,this._updatePromises()},finish:function(){this._updatePromises(),this._animation.finish(),this._register(),this._updatePromises()},cancel:function(){this._updatePromises(),this._animation.cancel(),this._register(),this._removeChildAnimations(),this._updatePromises()},reverse:function(){this._updatePromises();var a=this.currentTime;this._animation.reverse(),this._forEachChild(function(a){a.reverse()}),null!==a&&(this.currentTime=a),this._updatePromises()},addEventListener:function(a,b){var c=b;"function"==typeof b&&(c=function(a){a.target=this,b.call(this,a)}.bind(this),b._wrapper=c),this._animation.addEventListener(a,c)},removeEventListener:function(a,b){this._animation.removeEventListener(a,b&&b._wrapper||b)},_removeChildAnimations:function(){for(;this._childAnimations.length;)this._childAnimations.pop().cancel()},_forEachChild:function(b){var c=0;if(this.effect.children&&this._childAnimations.length<this.effect.children.length&&this._constructChildAnimations(),this._childAnimations.forEach(function(a){b.call(this,a,c),this.effect instanceof window.SequenceEffect&&(c+=a.effect.activeDuration)}.bind(this)),"pending"!=this.playState){var d=this.effect._timing,e=this.currentTime;null!==e&&(e=a.calculateIterationProgress(a.calculateActiveDuration(d),e,d)),(null==e||isNaN(e))&&this._removeChildAnimations()}}},window.Animation=b.Animation}(a,c),function(a,b,c){function d(b){this._frames=a.normalizeKeyframes(b)}function e(){for(var a=!1;i.length;)i.shift()._updateChildren(),a=!0;return a}var f=function(a){if(a._animation=void 0,a instanceof window.SequenceEffect||a instanceof window.GroupEffect)for(var b=0;b<a.children.length;b++)f(a.children[b])};b.removeMulti=function(a){for(var b=[],c=0;c<a.length;c++){var d=a[c];d._parent?(-1==b.indexOf(d._parent)&&b.push(d._parent),d._parent.children.splice(d._parent.children.indexOf(d),1),d._parent=null,f(d)):d._animation&&d._animation.effect==d&&(d._animation.cancel(),d._animation.effect=new KeyframeEffect(null,[]),d._animation._callback&&(d._animation._callback._animation=null),d._animation._rebuildUnderlyingAnimation(),f(d))}for(c=0;c<b.length;c++)b[c]._rebuild()},b.KeyframeEffect=function(b,c,e,f){return this.target=b,this._parent=null,e=a.numericTimingToObject(e),this._timingInput=a.cloneTimingInput(e),this._timing=a.normalizeTimingInput(e),this.timing=a.makeTiming(e,!1,this),this.timing._effect=this,"function"==typeof c?(a.deprecated("Custom KeyframeEffect","2015-06-22","Use KeyframeEffect.onsample instead."),this._normalizedKeyframes=c):this._normalizedKeyframes=new d(c),this._keyframes=c,this.activeDuration=a.calculateActiveDuration(this._timing),this._id=f,this},b.KeyframeEffect.prototype={getFrames:function(){return"function"==typeof this._normalizedKeyframes?this._normalizedKeyframes:this._normalizedKeyframes._frames},set onsample(a){if("function"==typeof this.getFrames())throw new Error("Setting onsample on custom effect KeyframeEffect is not supported.");this._onsample=a,this._animation&&this._animation._rebuildUnderlyingAnimation()},get parent(){return this._parent},clone:function(){if("function"==typeof this.getFrames())throw new Error("Cloning custom effects is not supported.");var b=new KeyframeEffect(this.target,[],a.cloneTimingInput(this._timingInput),this._id);return b._normalizedKeyframes=this._normalizedKeyframes,b._keyframes=this._keyframes,b},remove:function(){b.removeMulti([this])}};var g=Element.prototype.animate;Element.prototype.animate=function(a,c){var d="";return c&&c.id&&(d=c.id),b.timeline._play(new b.KeyframeEffect(this,a,c,d))};var h=document.createElementNS("http://www.w3.org/1999/xhtml","div");b.newUnderlyingAnimationForKeyframeEffect=function(a){if(a){var b=a.target||h,c=a._keyframes;"function"==typeof c&&(c=[]);var d=a._timingInput;d.id=a._id}else var b=h,c=[],d=0;return g.apply(b,[c,d])},b.bindAnimationForKeyframeEffect=function(a){a.effect&&"function"==typeof a.effect._normalizedKeyframes&&b.bindAnimationForCustomEffect(a)};var i=[];b.awaitStartTime=function(a){null===a.startTime&&a._isGroup&&(0==i.length&&requestAnimationFrame(e),i.push(a))};var j=window.getComputedStyle;Object.defineProperty(window,"getComputedStyle",{configurable:!0,enumerable:!0,value:function(){b.timeline._updateAnimationsPromises();var a=j.apply(this,arguments);return e()&&(a=j.apply(this,arguments)),b.timeline._updateAnimationsPromises(),a}}),window.KeyframeEffect=b.KeyframeEffect,window.Element.prototype.getAnimations=function(){return document.timeline.getAnimations().filter(function(a){return null!==a.effect&&a.effect.target==this}.bind(this))}}(a,c),function(a,b,c){function d(a){a._registered||(a._registered=!0,g.push(a),h||(h=!0,requestAnimationFrame(e)))}function e(a){var b=g;g=[],b.sort(function(a,b){return a._sequenceNumber-b._sequenceNumber}),b=b.filter(function(a){a();var b=a._animation?a._animation.playState:"idle";return"running"!=b&&"pending"!=b&&(a._registered=!1),a._registered}),g.push.apply(g,b),g.length?(h=!0,requestAnimationFrame(e)):h=!1}var f=(document.createElementNS("http://www.w3.org/1999/xhtml","div"),0);b.bindAnimationForCustomEffect=function(b){var c,e=b.effect.target,g="function"==typeof b.effect.getFrames();c=g?b.effect.getFrames():b.effect._onsample;var h=b.effect.timing,i=null;h=a.normalizeTimingInput(h);var j=function(){var d=j._animation?j._animation.currentTime:null;null!==d&&(d=a.calculateIterationProgress(a.calculateActiveDuration(h),d,h),isNaN(d)&&(d=null)),d!==i&&(g?c(d,e,b.effect):c(d,b.effect,b.effect._animation)),i=d};j._animation=b,j._registered=!1,j._sequenceNumber=f++,b._callback=j,d(j)};var g=[],h=!1;b.Animation.prototype._register=function(){this._callback&&d(this._callback)}}(a,c),function(a,b,c){function d(a){return a._timing.delay+a.activeDuration+a._timing.endDelay}function e(b,c,d){this._id=d,this._parent=null,this.children=b||[],this._reparent(this.children),c=a.numericTimingToObject(c),this._timingInput=a.cloneTimingInput(c),this._timing=a.normalizeTimingInput(c,!0),this.timing=a.makeTiming(c,!0,this),this.timing._effect=this,"auto"===this._timing.duration&&(this._timing.duration=this.activeDuration)}window.SequenceEffect=function(){e.apply(this,arguments)},window.GroupEffect=function(){e.apply(this,arguments)},e.prototype={_isAncestor:function(a){for(var b=this;null!==b;){if(b==a)return!0;b=b._parent}return!1},_rebuild:function(){for(var a=this;a;)"auto"===a.timing.duration&&(a._timing.duration=a.activeDuration),a=a._parent;this._animation&&this._animation._rebuildUnderlyingAnimation()},_reparent:function(a){b.removeMulti(a);for(var c=0;c<a.length;c++)a[c]._parent=this},_putChild:function(a,b){for(var c=b?"Cannot append an ancestor or self":"Cannot prepend an ancestor or self",d=0;d<a.length;d++)if(this._isAncestor(a[d]))throw{type:DOMException.HIERARCHY_REQUEST_ERR,name:"HierarchyRequestError",message:c};for(var d=0;d<a.length;d++)b?this.children.push(a[d]):this.children.unshift(a[d]);this._reparent(a),this._rebuild()},append:function(){this._putChild(arguments,!0)},prepend:function(){this._putChild(arguments,!1)},get parent(){return this._parent},get firstChild(){return this.children.length?this.children[0]:null},get lastChild(){return this.children.length?this.children[this.children.length-1]:null},clone:function(){for(var b=a.cloneTimingInput(this._timingInput),c=[],d=0;d<this.children.length;d++)c.push(this.children[d].clone());return this instanceof GroupEffect?new GroupEffect(c,b):new SequenceEffect(c,b)},remove:function(){b.removeMulti([this])}},window.SequenceEffect.prototype=Object.create(e.prototype),Object.defineProperty(window.SequenceEffect.prototype,"activeDuration",{get:function(){var a=0;return this.children.forEach(function(b){a+=d(b)}),Math.max(a,0)}}),window.GroupEffect.prototype=Object.create(e.prototype),Object.defineProperty(window.GroupEffect.prototype,"activeDuration",{get:function(){var a=0;return this.children.forEach(function(b){a=Math.max(a,d(b))}),a}}),b.newUnderlyingAnimationForGroup=function(c){var d,e=null,f=function(b){var c=d._wrapper;if(c&&"pending"!=c.playState&&c.effect)return null==b?void c._removeChildAnimations():0==b&&c.playbackRate<0&&(e||(e=a.normalizeTimingInput(c.effect.timing)),b=a.calculateIterationProgress(a.calculateActiveDuration(e),-1,e),isNaN(b)||null==b)?(c._forEachChild(function(a){a.currentTime=-1}),void c._removeChildAnimations()):void 0},g=new KeyframeEffect(null,[],c._timing,c._id);return g.onsample=f,d=b.timeline._play(g)},b.bindAnimationForGroup=function(a){a._animation._wrapper=a,a._isGroup=!0,b.awaitStartTime(a),a._constructChildAnimations(),a._setExternalAnimation(a)},b.groupChildDuration=d}(a,c)}();(()=>{var vve=Object.create;var BM=Object.defineProperty,xve=Object.defineProperties,bve=Object.getOwnPropertyDescriptor,wve=Object.getOwnPropertyDescriptors,Sve=Object.getOwnPropertyNames,hdt=Object.getOwnPropertySymbols,Mve=Object.getPrototypeOf,pdt=Object.prototype.hasOwnProperty,Eve=Object.prototype.propertyIsEnumerable;var TI=Math.pow,fdt=(e,t,r)=>t in e?BM(e,t,{enumerable:!0,configurable:!0,writable:!0,value:r}):e[t]=r,Kl=(e,t)=>{for(var r in t||(t={}))pdt.call(t,r)&&fdt(e,r,t[r]);if(hdt)for(var r of hdt(t))Eve.call(t,r)&&fdt(e,r,t[r]);return e},Mx=(e,t)=>xve(e,wve(t));var Ex=(e=>typeof require!="undefined"?require:typeof Proxy!="undefined"?new Proxy(e,{get:(t,r)=>(typeof require!="undefined"?require:t)[r]}):e)(function(e){if(typeof require!="undefined")return require.apply(this,arguments);throw new Error('Dynamic require of "'+e+'" is not supported')});var M=(e,t)=>()=>(e&&(t=e(e=0)),t);var H=(e,t)=>()=>(t||e((t={exports:{}}).exports,t),t.exports),Ks=(e,t)=>{for(var r in t)BM(e,r,{get:t[r],enumerable:!0})},ddt=(e,t,r,n)=>{if(t&&typeof t=="object"||typeof t=="function")for(let i of Sve(t))!pdt.call(e,i)&&i!==r&&BM(e,i,{get:()=>t[i],enumerable:!(n=bve(t,i))||n.enumerable});return e};var Ee=(e,t,r)=>(r=e!=null?vve(Mve(e)):{},ddt(t||!e||!e.__esModule?BM(r,"default",{value:e,enumerable:!0}):r,e)),Ut=e=>ddt(BM({},"__esModule",{value:!0}),e);var Ri=(e,t,r)=>new Promise((n,i)=>{var o=l=>{try{s(r.next(l))}catch(c){i(c)}},a=l=>{try{s(r.throw(l))}catch(c){i(c)}},s=l=>l.done?n(l.value):Promise.resolve(l.value).then(o,a);s((r=r.apply(e,t)).next())});var Hdt=H((p_r,PI)=>{var mdt,gdt,_dt,ydt,vdt,xdt,bdt,wdt,Sdt,Mdt,Edt,Tdt,Cdt,CI,hG,Adt,Pdt,Idt,Tx,Ldt,kdt,Rdt,Ndt,Ddt,Odt,zdt,Fdt,Bdt,AI;(function(e){var t=typeof global=="object"?global:typeof self=="object"?self:typeof this=="object"?this:{};typeof define=="function"&&define.amd?define("tslib",["exports"],function(n){e(r(t,r(n)))}):typeof PI=="object"&&typeof PI.exports=="object"?e(r(t,r(PI.exports))):e(r(t));function r(n,i){return n!==t&&(typeof Object.create=="function"?Object.defineProperty(n,"__esModule",{value:!0}):n.__esModule=!0),function(o,a){return n[o]=i?i(o,a):a}}})(function(e){var t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(n,i){n.__proto__=i}||function(n,i){for(var o in i)Object.prototype.hasOwnProperty.call(i,o)&&(n[o]=i[o])};mdt=function(n,i){if(typeof i!="function"&&i!==null)throw new TypeError("Class extends value "+String(i)+" is not a constructor or null");t(n,i);function o(){this.constructor=n}n.prototype=i===null?Object.create(i):(o.prototype=i.prototype,new o)},gdt=Object.assign||function(n){for(var i,o=1,a=arguments.length;o<a;o++){i=arguments[o];for(var s in i)Object.prototype.hasOwnProperty.call(i,s)&&(n[s]=i[s])}return n},_dt=function(n,i){var o={};for(var a in n)Object.prototype.hasOwnProperty.call(n,a)&&i.indexOf(a)<0&&(o[a]=n[a]);if(n!=null&&typeof Object.getOwnPropertySymbols=="function")for(var s=0,a=Object.getOwnPropertySymbols(n);s<a.length;s++)i.indexOf(a[s])<0&&Object.prototype.propertyIsEnumerable.call(n,a[s])&&(o[a[s]]=n[a[s]]);return o},ydt=function(n,i,o,a){var s=arguments.length,l=s<3?i:a===null?a=Object.getOwnPropertyDescriptor(i,o):a,c;if(typeof Reflect=="object"&&typeof Reflect.decorate=="function")l=Reflect.decorate(n,i,o,a);else for(var u=n.length-1;u>=0;u--)(c=n[u])&&(l=(s<3?c(l):s>3?c(i,o,l):c(i,o))||l);return s>3&&l&&Object.defineProperty(i,o,l),l},vdt=function(n,i){return function(o,a){i(o,a,n)}},xdt=function(n,i,o,a,s,l){function c(S){if(S!==void 0&&typeof S!="function")throw new TypeError("Function expected");return S}for(var u=a.kind,h=u==="getter"?"get":u==="setter"?"set":"value",f=!i&&n?a.static?n:n.prototype:null,p=i||(f?Object.getOwnPropertyDescriptor(f,a.name):{}),d,g=!1,_=o.length-1;_>=0;_--){var y={};for(var x in a)y[x]=x==="access"?{}:a[x];for(var x in a.access)y.access[x]=a.access[x];y.addInitializer=function(S){if(g)throw new TypeError("Cannot add initializers after decoration has completed");l.push(c(S||null))};var b=(0,o[_])(u==="accessor"?{get:p.get,set:p.set}:p[h],y);if(u==="accessor"){if(b===void 0)continue;if(b===null||typeof b!="object")throw new TypeError("Object expected");(d=c(b.get))&&(p.get=d),(d=c(b.set))&&(p.set=d),(d=c(b.init))&&s.push(d)}else(d=c(b))&&(u==="field"?s.push(d):p[h]=d)}f&&Object.defineProperty(f,a.name,p),g=!0},bdt=function(n,i,o){for(var a=arguments.length>2,s=0;s<i.length;s++)o=a?i[s].call(n,o):i[s].call(n);return a?o:void 0},wdt=function(n){return typeof n=="symbol"?n:"".concat(n)},Sdt=function(n,i,o){return typeof i=="symbol"&&(i=i.description?"[".concat(i.description,"]"):""),Object.defineProperty(n,"name",{configurable:!0,value:o?"".concat(o," ",i):i})},Mdt=function(n,i){if(typeof Reflect=="object"&&typeof Reflect.metadata=="function")return Reflect.metadata(n,i)},Edt=function(n,i,o,a){function s(l){return l instanceof o?l:new o(function(c){c(l)})}return new(o||(o=Promise))(function(l,c){function u(p){try{f(a.next(p))}catch(d){c(d)}}function h(p){try{f(a.throw(p))}catch(d){c(d)}}function f(p){p.done?l(p.value):s(p.value).then(u,h)}f((a=a.apply(n,i||[])).next())})},Tdt=function(n,i){var o={label:0,sent:function(){if(l[0]&1)throw l[1];return l[1]},trys:[],ops:[]},a,s,l,c;return c={next:u(0),throw:u(1),return:u(2)},typeof Symbol=="function"&&(c[Symbol.iterator]=function(){return this}),c;function u(f){return function(p){return h([f,p])}}function h(f){if(a)throw new TypeError("Generator is already executing.");for(;c&&(c=0,f[0]&&(o=0)),o;)try{if(a=1,s&&(l=f[0]&2?s.return:f[0]?s.throw||((l=s.return)&&l.call(s),0):s.next)&&!(l=l.call(s,f[1])).done)return l;switch(s=0,l&&(f=[f[0]&2,l.value]),f[0]){case 0:case 1:l=f;break;case 4:return o.label++,{value:f[1],done:!1};case 5:o.label++,s=f[1],f=[0];continue;case 7:f=o.ops.pop(),o.trys.pop();continue;default:if(l=o.trys,!(l=l.length>0&&l[l.length-1])&&(f[0]===6||f[0]===2)){o=0;continue}if(f[0]===3&&(!l||f[1]>l[0]&&f[1]<l[3])){o.label=f[1];break}if(f[0]===6&&o.label<l[1]){o.label=l[1],l=f;break}if(l&&o.label<l[2]){o.label=l[2],o.ops.push(f);break}l[2]&&o.ops.pop(),o.trys.pop();continue}f=i.call(n,o)}catch(p){f=[6,p],s=0}finally{a=l=0}if(f[0]&5)throw f[1];return{value:f[0]?f[1]:void 0,done:!0}}},Cdt=function(n,i){for(var o in n)o!=="default"&&!Object.prototype.hasOwnProperty.call(i,o)&&AI(i,n,o)},AI=Object.create?function(n,i,o,a){a===void 0&&(a=o);var s=Object.getOwnPropertyDescriptor(i,o);(!s||("get"in s?!i.__esModule:s.writable||s.configurable))&&(s={enumerable:!0,get:function(){return i[o]}}),Object.defineProperty(n,a,s)}:function(n,i,o,a){a===void 0&&(a=o),n[a]=i[o]},CI=function(n){var i=typeof Symbol=="function"&&Symbol.iterator,o=i&&n[i],a=0;if(o)return o.call(n);if(n&&typeof n.length=="number")return{next:function(){return n&&a>=n.length&&(n=void 0),{value:n&&n[a++],done:!n}}};throw new TypeError(i?"Object is not iterable.":"Symbol.iterator is not defined.")},hG=function(n,i){var o=typeof Symbol=="function"&&n[Symbol.iterator];if(!o)return n;var a=o.call(n),s,l=[],c;try{for(;(i===void 0||i-- >0)&&!(s=a.next()).done;)l.push(s.value)}catch(u){c={error:u}}finally{try{s&&!s.done&&(o=a.return)&&o.call(a)}finally{if(c)throw c.error}}return l},Adt=function(){for(var n=[],i=0;i<arguments.length;i++)n=n.concat(hG(arguments[i]));return n},Pdt=function(){for(var n=0,i=0,o=arguments.length;i<o;i++)n+=arguments[i].length;for(var a=Array(n),s=0,i=0;i<o;i++)for(var l=arguments[i],c=0,u=l.length;c<u;c++,s++)a[s]=l[c];return a},Idt=function(n,i,o){if(o||arguments.length===2)for(var a=0,s=i.length,l;a<s;a++)(l||!(a in i))&&(l||(l=Array.prototype.slice.call(i,0,a)),l[a]=i[a]);return n.concat(l||Array.prototype.slice.call(i))},Tx=function(n){return this instanceof Tx?(this.v=n,this):new Tx(n)},Ldt=function(n,i,o){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var a=o.apply(n,i||[]),s,l=[];return s={},c("next"),c("throw"),c("return"),s[Symbol.asyncIterator]=function(){return this},s;function c(g){a[g]&&(s[g]=function(_){return new Promise(function(y,x){l.push([g,_,y,x])>1||u(g,_)})})}function u(g,_){try{h(a[g](_))}catch(y){d(l[0][3],y)}}function h(g){g.value instanceof Tx?Promise.resolve(g.value.v).then(f,p):d(l[0][2],g)}function f(g){u("next",g)}function p(g){u("throw",g)}function d(g,_){g(_),l.shift(),l.length&&u(l[0][0],l[0][1])}},kdt=function(n){var i,o;return i={},a("next"),a("throw",function(s){throw s}),a("return"),i[Symbol.iterator]=function(){return this},i;function a(s,l){i[s]=n[s]?function(c){return(o=!o)?{value:Tx(n[s](c)),done:!1}:l?l(c):c}:l}},Rdt=function(n){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var i=n[Symbol.asyncIterator],o;return i?i.call(n):(n=typeof CI=="function"?CI(n):n[Symbol.iterator](),o={},a("next"),a("throw"),a("return"),o[Symbol.asyncIterator]=function(){return this},o);function a(l){o[l]=n[l]&&function(c){return new Promise(function(u,h){c=n[l](c),s(u,h,c.done,c.value)})}}function s(l,c,u,h){Promise.resolve(h).then(function(f){l({value:f,done:u})},c)}},Ndt=function(n,i){return Object.defineProperty?Object.defineProperty(n,"raw",{value:i}):n.raw=i,n};var r=Object.create?function(n,i){Object.defineProperty(n,"default",{enumerable:!0,value:i})}:function(n,i){n.default=i};Ddt=function(n){if(n&&n.__esModule)return n;var i={};if(n!=null)for(var o in n)o!=="default"&&Object.prototype.hasOwnProperty.call(n,o)&&AI(i,n,o);return r(i,n),i},Odt=function(n){return n&&n.__esModule?n:{default:n}},zdt=function(n,i,o,a){if(o==="a"&&!a)throw new TypeError("Private accessor was defined without a getter");if(typeof i=="function"?n!==i||!a:!i.has(n))throw new TypeError("Cannot read private member from an object whose class did not declare it");return o==="m"?a:o==="a"?a.call(n):a?a.value:i.get(n)},Fdt=function(n,i,o,a,s){if(a==="m")throw new TypeError("Private method is not writable");if(a==="a"&&!s)throw new TypeError("Private accessor was defined without a setter");if(typeof i=="function"?n!==i||!s:!i.has(n))throw new TypeError("Cannot write private member to an object whose class did not declare it");return a==="a"?s.call(n,o):s?s.value=o:i.set(n,o),o},Bdt=function(n,i){if(i===null||typeof i!="object"&&typeof i!="function")throw new TypeError("Cannot use 'in' operator on non-object");return typeof n=="function"?i===n:n.has(i)},e("__extends",mdt),e("__assign",gdt),e("__rest",_dt),e("__decorate",ydt),e("__param",vdt),e("__esDecorate",xdt),e("__runInitializers",bdt),e("__propKey",wdt),e("__setFunctionName",Sdt),e("__metadata",Mdt),e("__awaiter",Edt),e("__generator",Tdt),e("__exportStar",Cdt),e("__createBinding",AI),e("__values",CI),e("__read",hG),e("__spread",Adt),e("__spreadArrays",Pdt),e("__spreadArray",Idt),e("__await",Tx),e("__asyncGenerator",Ldt),e("__asyncDelegator",kdt),e("__asyncValues",Rdt),e("__makeTemplateObject",Ndt),e("__importStar",Ddt),e("__importDefault",Odt),e("__classPrivateFieldGet",zdt),e("__classPrivateFieldSet",Fdt),e("__classPrivateFieldIn",Bdt)})});var Oe=H((Rx,$M)=>{(function(){var e,t="4.17.21",r=200,n="Unsupported core-js use. Try https://npms.io/search?q=ponyfill.",i="Expected a function",o="Invalid `variable` option passed into `_.template`",a="__lodash_hash_undefined__",s=500,l="__lodash_placeholder__",c=1,u=2,h=4,f=1,p=2,d=1,g=2,_=4,y=8,x=16,b=32,S=64,C=128,P=256,k=512,O=30,D="...",B=800,I=16,L=1,R=2,F=3,z=1/0,U=9007199254740991,W=17976931348623157e292,Z=0/0,rt=4294967295,ot=rt-1,st=rt>>>1,St=[["ary",C],["bind",d],["bindKey",g],["curry",y],["curryRight",x],["flip",k],["partial",b],["partialRight",S],["rearg",P]],bt="[object Arguments]",Mt="[object Array]",lt="[object AsyncFunction]",Kt="[object Boolean]",_t="[object Date]",ct="[object DOMException]",X="[object Error]",et="[object Function]",dt="[object GeneratorFunction]",q="[object Map]",pt="[object Number]",ht="[object Null]",wt="[object Object]",kt="[object Promise]",ie="[object Proxy]",ee="[object RegExp]",Le="[object Set]",ar="[object String]",fr="[object Symbol]",tt="[object Undefined]",$="[object WeakMap]",It="[object WeakSet]",$t="[object ArrayBuffer]",he="[object DataView]",Tt="[object Float32Array]",be="[object Float64Array]",nt="[object Int8Array]",Ct="[object Int16Array]",Wt="[object Int32Array]",fe="[object Uint8Array]",at="[object Uint8ClampedArray]",se="[object Uint16Array]",Qt="[object Uint32Array]",Ce=/\b__p \+= '';/g,Pt=/\b(__p \+=) '' \+/g,Nt=/(__e\(.*?\)|\b__t\)) \+\n'';/g,ze=/&(?:amp|lt|gt|quot|#39);/g,yn=/[&<>"']/g,Wi=RegExp(ze.source),Ar=RegExp(yn.source),Pa=/<%-([\s\S]+?)%>/g,ho=/<%([\s\S]+?)%>/g,Ia=/<%=([\s\S]+?)%>/g,lx=/\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,cm=/^\w*$/,J0=/[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g,cn=/[\\^$.*+?()[\]{}|]/g,cx=RegExp(cn.source),rp=/^\s+/,K=/\s/,gt=/\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/,Et=/\{\n\/\* \[wrapped with (.+)\] \*/,xt=/,? & /,Ft=/[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g,Ve=/[()=,{}\[\]\/\s]/,Ue=/\\(\\)?/g,tr=/\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g,Ke=/\w*$/,Xr=/^[-+]0x[0-9a-f]+$/i,_r=/^0b[01]+$/i,Pr=/^\[object .+?Constructor\]$/,jn=/^0o[0-7]+$/i,np=/^(?:0|[1-9]\d*)$/,um=/[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g,mr=/($^)/,Fl=/['\n\r\u2028\u2029\\]/g,Xn="\\ud800-\\udfff",Bl="\\u0300-\\u036f",ux="\\ufe20-\\ufe2f",Hl="\\u20d0-\\u20ff",Vl=Bl+ux+Hl,Yi="\\u2700-\\u27bf",hm="a-z\\xdf-\\xf6\\xf8-\\xff",qs="\\xac\\xb1\\xd7\\xf7",gpe="\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf",_pe="\\u2000-\\u206f",ype=" \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000",qht="A-Z\\xc0-\\xd6\\xd8-\\xde",Ght="\\ufe0e\\ufe0f",Wht=qs+gpe+_pe+ype,eq="['\u2019]",vpe="["+Xn+"]",Yht="["+Wht+"]",H6="["+Vl+"]",jht="\\d+",xpe="["+Yi+"]",Xht="["+hm+"]",$ht="[^"+Xn+Wht+jht+Yi+hm+qht+"]",rq="\\ud83c[\\udffb-\\udfff]",bpe="(?:"+H6+"|"+rq+")",Kht="[^"+Xn+"]",nq="(?:\\ud83c[\\udde6-\\uddff]){2}",iq="[\\ud800-\\udbff][\\udc00-\\udfff]",hx="["+qht+"]",Zht="\\u200d",Jht="(?:"+Xht+"|"+$ht+")",wpe="(?:"+hx+"|"+$ht+")",Qht="(?:"+eq+"(?:d|ll|m|re|s|t|ve))?",tft="(?:"+eq+"(?:D|LL|M|RE|S|T|VE))?",eft=bpe+"?",rft="["+Ght+"]?",Spe="(?:"+Zht+"(?:"+[Kht,nq,iq].join("|")+")"+rft+eft+")*",Mpe="\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])",Epe="\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])",nft=rft+eft+Spe,Tpe="(?:"+[xpe,nq,iq].join("|")+")"+nft,Cpe="(?:"+[Kht+H6+"?",H6,nq,iq,vpe].join("|")+")",Ape=RegExp(eq,"g"),Ppe=RegExp(H6,"g"),oq=RegExp(rq+"(?="+rq+")|"+Cpe+nft,"g"),Ipe=RegExp([hx+"?"+Xht+"+"+Qht+"(?="+[Yht,hx,"$"].join("|")+")",wpe+"+"+tft+"(?="+[Yht,hx+Jht,"$"].join("|")+")",hx+"?"+Jht+"+"+Qht,hx+"+"+tft,Epe,Mpe,jht,Tpe].join("|"),"g"),Lpe=RegExp("["+Zht+Xn+Vl+Ght+"]"),kpe=/[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/,Rpe=["Array","Buffer","DataView","Date","Error","Float32Array","Float64Array","Function","Int8Array","Int16Array","Int32Array","Map","Math","Object","Promise","RegExp","Set","String","Symbol","TypeError","Uint8Array","Uint8ClampedArray","Uint16Array","Uint32Array","WeakMap","_","clearTimeout","isFinite","parseInt","setTimeout"],Npe=-1,kn={};kn[Tt]=kn[be]=kn[nt]=kn[Ct]=kn[Wt]=kn[fe]=kn[at]=kn[se]=kn[Qt]=!0,kn[bt]=kn[Mt]=kn[$t]=kn[Kt]=kn[he]=kn[_t]=kn[X]=kn[et]=kn[q]=kn[pt]=kn[wt]=kn[ee]=kn[Le]=kn[ar]=kn[$]=!1;var Tn={};Tn[bt]=Tn[Mt]=Tn[$t]=Tn[he]=Tn[Kt]=Tn[_t]=Tn[Tt]=Tn[be]=Tn[nt]=Tn[Ct]=Tn[Wt]=Tn[q]=Tn[pt]=Tn[wt]=Tn[ee]=Tn[Le]=Tn[ar]=Tn[fr]=Tn[fe]=Tn[at]=Tn[se]=Tn[Qt]=!0,Tn[X]=Tn[et]=Tn[$]=!1;var Dpe={\u00C0:"A",\u00C1:"A",\u00C2:"A",\u00C3:"A",\u00C4:"A",\u00C5:"A",\u00E0:"a",\u00E1:"a",\u00E2:"a",\u00E3:"a",\u00E4:"a",\u00E5:"a",\u00C7:"C",\u00E7:"c",\u00D0:"D",\u00F0:"d",\u00C8:"E",\u00C9:"E",\u00CA:"E",\u00CB:"E",\u00E8:"e",\u00E9:"e",\u00EA:"e",\u00EB:"e",\u00CC:"I",\u00CD:"I",\u00CE:"I",\u00CF:"I",\u00EC:"i",\u00ED:"i",\u00EE:"i",\u00EF:"i",\u00D1:"N",\u00F1:"n",\u00D2:"O",\u00D3:"O",\u00D4:"O",\u00D5:"O",\u00D6:"O",\u00D8:"O",\u00F2:"o",\u00F3:"o",\u00F4:"o",\u00F5:"o",\u00F6:"o",\u00F8:"o",\u00D9:"U",\u00DA:"U",\u00DB:"U",\u00DC:"U",\u00F9:"u",\u00FA:"u",\u00FB:"u",\u00FC:"u",\u00DD:"Y",\u00FD:"y",\u00FF:"y",\u00C6:"Ae",\u00E6:"ae",\u00DE:"Th",\u00FE:"th",\u00DF:"ss",\u0100:"A",\u0102:"A",\u0104:"A",\u0101:"a",\u0103:"a",\u0105:"a",\u0106:"C",\u0108:"C",\u010A:"C",\u010C:"C",\u0107:"c",\u0109:"c",\u010B:"c",\u010D:"c",\u010E:"D",\u0110:"D",\u010F:"d",\u0111:"d",\u0112:"E",\u0114:"E",\u0116:"E",\u0118:"E",\u011A:"E",\u0113:"e",\u0115:"e",\u0117:"e",\u0119:"e",\u011B:"e",\u011C:"G",\u011E:"G",\u0120:"G",\u0122:"G",\u011D:"g",\u011F:"g",\u0121:"g",\u0123:"g",\u0124:"H",\u0126:"H",\u0125:"h",\u0127:"h",\u0128:"I",\u012A:"I",\u012C:"I",\u012E:"I",\u0130:"I",\u0129:"i",\u012B:"i",\u012D:"i",\u012F:"i",\u0131:"i",\u0134:"J",\u0135:"j",\u0136:"K",\u0137:"k",\u0138:"k",\u0139:"L",\u013B:"L",\u013D:"L",\u013F:"L",\u0141:"L",\u013A:"l",\u013C:"l",\u013E:"l",\u0140:"l",\u0142:"l",\u0143:"N",\u0145:"N",\u0147:"N",\u014A:"N",\u0144:"n",\u0146:"n",\u0148:"n",\u014B:"n",\u014C:"O",\u014E:"O",\u0150:"O",\u014D:"o",\u014F:"o",\u0151:"o",\u0154:"R",\u0156:"R",\u0158:"R",\u0155:"r",\u0157:"r",\u0159:"r",\u015A:"S",\u015C:"S",\u015E:"S",\u0160:"S",\u015B:"s",\u015D:"s",\u015F:"s",\u0161:"s",\u0162:"T",\u0164:"T",\u0166:"T",\u0163:"t",\u0165:"t",\u0167:"t",\u0168:"U",\u016A:"U",\u016C:"U",\u016E:"U",\u0170:"U",\u0172:"U",\u0169:"u",\u016B:"u",\u016D:"u",\u016F:"u",\u0171:"u",\u0173:"u",\u0174:"W",\u0175:"w",\u0176:"Y",\u0177:"y",\u0178:"Y",\u0179:"Z",\u017B:"Z",\u017D:"Z",\u017A:"z",\u017C:"z",\u017E:"z",\u0132:"IJ",\u0133:"ij",\u0152:"Oe",\u0153:"oe",\u0149:"'n",\u017F:"s"},Ope={"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#39;"},zpe={"&amp;":"&","&lt;":"<","&gt;":">","&quot;":'"',"&#39;":"'"},Fpe={"\\":"\\","'":"'","\n":"n","\r":"r","\u2028":"u2028","\u2029":"u2029"},Bpe=parseFloat,Hpe=parseInt,ift=typeof global=="object"&&global&&global.Object===Object&&global,Vpe=typeof self=="object"&&self&&self.Object===Object&&self,fo=ift||Vpe||Function("return this")(),aq=typeof Rx=="object"&&Rx&&!Rx.nodeType&&Rx,Q0=aq&&typeof $M=="object"&&$M&&!$M.nodeType&&$M,oft=Q0&&Q0.exports===aq,sq=oft&&ift.process,Ul=function(){try{var ut=Q0&&Q0.require&&Q0.require("util").types;return ut||sq&&sq.binding&&sq.binding("util")}catch(At){}}(),aft=Ul&&Ul.isArrayBuffer,sft=Ul&&Ul.isDate,lft=Ul&&Ul.isMap,cft=Ul&&Ul.isRegExp,uft=Ul&&Ul.isSet,hft=Ul&&Ul.isTypedArray;function Gs(ut,At,vt){switch(vt.length){case 0:return ut.call(At);case 1:return ut.call(At,vt[0]);case 2:return ut.call(At,vt[0],vt[1]);case 3:return ut.call(At,vt[0],vt[1],vt[2])}return ut.apply(At,vt)}function Upe(ut,At,vt,ge){for(var We=-1,$r=ut==null?0:ut.length;++We<$r;){var ji=ut[We];At(ge,ji,vt(ji),ut)}return ge}function ql(ut,At){for(var vt=-1,ge=ut==null?0:ut.length;++vt<ge&&At(ut[vt],vt,ut)!==!1;);return ut}function qpe(ut,At){for(var vt=ut==null?0:ut.length;vt--&&At(ut[vt],vt,ut)!==!1;);return ut}function fft(ut,At){for(var vt=-1,ge=ut==null?0:ut.length;++vt<ge;)if(!At(ut[vt],vt,ut))return!1;return!0}function fm(ut,At){for(var vt=-1,ge=ut==null?0:ut.length,We=0,$r=[];++vt<ge;){var ji=ut[vt];At(ji,vt,ut)&&($r[We++]=ji)}return $r}function V6(ut,At){var vt=ut==null?0:ut.length;return!!vt&&fx(ut,At,0)>-1}function lq(ut,At,vt){for(var ge=-1,We=ut==null?0:ut.length;++ge<We;)if(vt(At,ut[ge]))return!0;return!1}function $n(ut,At){for(var vt=-1,ge=ut==null?0:ut.length,We=Array(ge);++vt<ge;)We[vt]=At(ut[vt],vt,ut);return We}function pm(ut,At){for(var vt=-1,ge=At.length,We=ut.length;++vt<ge;)ut[We+vt]=At[vt];return ut}function cq(ut,At,vt,ge){var We=-1,$r=ut==null?0:ut.length;for(ge&&$r&&(vt=ut[++We]);++We<$r;)vt=At(vt,ut[We],We,ut);return vt}function Gpe(ut,At,vt,ge){var We=ut==null?0:ut.length;for(ge&&We&&(vt=ut[--We]);We--;)vt=At(vt,ut[We],We,ut);return vt}function uq(ut,At){for(var vt=-1,ge=ut==null?0:ut.length;++vt<ge;)if(At(ut[vt],vt,ut))return!0;return!1}var Wpe=hq("length");function Ype(ut){return ut.split("")}function jpe(ut){return ut.match(Ft)||[]}function pft(ut,At,vt){var ge;return vt(ut,function(We,$r,ji){if(At(We,$r,ji))return ge=$r,!1}),ge}function U6(ut,At,vt,ge){for(var We=ut.length,$r=vt+(ge?1:-1);ge?$r--:++$r<We;)if(At(ut[$r],$r,ut))return $r;return-1}function fx(ut,At,vt){return At===At?ode(ut,At,vt):U6(ut,dft,vt)}function Xpe(ut,At,vt,ge){for(var We=vt-1,$r=ut.length;++We<$r;)if(ge(ut[We],At))return We;return-1}function dft(ut){return ut!==ut}function mft(ut,At){var vt=ut==null?0:ut.length;return vt?pq(ut,At)/vt:Z}function hq(ut){return function(At){return At==null?e:At[ut]}}function fq(ut){return function(At){return ut==null?e:ut[At]}}function gft(ut,At,vt,ge,We){return We(ut,function($r,ji,vn){vt=ge?(ge=!1,$r):At(vt,$r,ji,vn)}),vt}function $pe(ut,At){var vt=ut.length;for(ut.sort(At);vt--;)ut[vt]=ut[vt].value;return ut}function pq(ut,At){for(var vt,ge=-1,We=ut.length;++ge<We;){var $r=At(ut[ge]);$r!==e&&(vt=vt===e?$r:vt+$r)}return vt}function dq(ut,At){for(var vt=-1,ge=Array(ut);++vt<ut;)ge[vt]=At(vt);return ge}function Kpe(ut,At){return $n(At,function(vt){return[vt,ut[vt]]})}function _ft(ut){return ut&&ut.slice(0,bft(ut)+1).replace(rp,"")}function Ws(ut){return function(At){return ut(At)}}function mq(ut,At){return $n(At,function(vt){return ut[vt]})}function MM(ut,At){return ut.has(At)}function yft(ut,At){for(var vt=-1,ge=ut.length;++vt<ge&&fx(At,ut[vt],0)>-1;);return vt}function vft(ut,At){for(var vt=ut.length;vt--&&fx(At,ut[vt],0)>-1;);return vt}function Zpe(ut,At){for(var vt=ut.length,ge=0;vt--;)ut[vt]===At&&++ge;return ge}var Jpe=fq(Dpe),Qpe=fq(Ope);function tde(ut){return"\\"+Fpe[ut]}function ede(ut,At){return ut==null?e:ut[At]}function px(ut){return Lpe.test(ut)}function rde(ut){return kpe.test(ut)}function nde(ut){for(var At,vt=[];!(At=ut.next()).done;)vt.push(At.value);return vt}function gq(ut){var At=-1,vt=Array(ut.size);return ut.forEach(function(ge,We){vt[++At]=[We,ge]}),vt}function xft(ut,At){return function(vt){return ut(At(vt))}}function dm(ut,At){for(var vt=-1,ge=ut.length,We=0,$r=[];++vt<ge;){var ji=ut[vt];(ji===At||ji===l)&&(ut[vt]=l,$r[We++]=vt)}return $r}function q6(ut){var At=-1,vt=Array(ut.size);return ut.forEach(function(ge){vt[++At]=ge}),vt}function ide(ut){var At=-1,vt=Array(ut.size);return ut.forEach(function(ge){vt[++At]=[ge,ge]}),vt}function ode(ut,At,vt){for(var ge=vt-1,We=ut.length;++ge<We;)if(ut[ge]===At)return ge;return-1}function ade(ut,At,vt){for(var ge=vt+1;ge--;)if(ut[ge]===At)return ge;return ge}function dx(ut){return px(ut)?lde(ut):Wpe(ut)}function tu(ut){return px(ut)?cde(ut):Ype(ut)}function bft(ut){for(var At=ut.length;At--&&K.test(ut.charAt(At)););return At}var sde=fq(zpe);function lde(ut){for(var At=oq.lastIndex=0;oq.test(ut);)++At;return At}function cde(ut){return ut.match(oq)||[]}function ude(ut){return ut.match(Ipe)||[]}var hde=function ut(At){At=At==null?fo:mm.defaults(fo.Object(),At,mm.pick(fo,Rpe));var vt=At.Array,ge=At.Date,We=At.Error,$r=At.Function,ji=At.Math,vn=At.Object,_q=At.RegExp,fde=At.String,Gl=At.TypeError,G6=vt.prototype,pde=$r.prototype,mx=vn.prototype,W6=At["__core-js_shared__"],Y6=pde.toString,un=mx.hasOwnProperty,dde=0,wft=function(){var m=/[^.]+$/.exec(W6&&W6.keys&&W6.keys.IE_PROTO||"");return m?"Symbol(src)_1."+m:""}(),j6=mx.toString,mde=Y6.call(vn),gde=fo._,_de=_q("^"+Y6.call(un).replace(cn,"\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g,"$1.*?")+"$"),X6=oft?At.Buffer:e,gm=At.Symbol,$6=At.Uint8Array,Sft=X6?X6.allocUnsafe:e,K6=xft(vn.getPrototypeOf,vn),Mft=vn.create,Eft=mx.propertyIsEnumerable,Z6=G6.splice,Tft=gm?gm.isConcatSpreadable:e,EM=gm?gm.iterator:e,t_=gm?gm.toStringTag:e,J6=function(){try{var m=o_(vn,"defineProperty");return m({},"",{}),m}catch(v){}}(),yde=At.clearTimeout!==fo.clearTimeout&&At.clearTimeout,vde=ge&&ge.now!==fo.Date.now&&ge.now,xde=At.setTimeout!==fo.setTimeout&&At.setTimeout,Q6=ji.ceil,tI=ji.floor,yq=vn.getOwnPropertySymbols,bde=X6?X6.isBuffer:e,Cft=At.isFinite,wde=G6.join,Sde=xft(vn.keys,vn),Xi=ji.max,ra=ji.min,Mde=ge.now,Ede=At.parseInt,Aft=ji.random,Tde=G6.reverse,vq=o_(At,"DataView"),TM=o_(At,"Map"),xq=o_(At,"Promise"),gx=o_(At,"Set"),CM=o_(At,"WeakMap"),AM=o_(vn,"create"),eI=CM&&new CM,_x={},Cde=a_(vq),Ade=a_(TM),Pde=a_(xq),Ide=a_(gx),Lde=a_(CM),rI=gm?gm.prototype:e,PM=rI?rI.valueOf:e,Pft=rI?rI.toString:e;function G(m){if(si(m)&&!$e(m)&&!(m instanceof gr)){if(m instanceof Wl)return m;if(un.call(m,"__wrapped__"))return Ipt(m)}return new Wl(m)}var yx=function(){function m(){}return function(v){if(!ei(v))return{};if(Mft)return Mft(v);m.prototype=v;var T=new m;return m.prototype=e,T}}();function nI(){}function Wl(m,v){this.__wrapped__=m,this.__actions__=[],this.__chain__=!!v,this.__index__=0,this.__values__=e}G.templateSettings={escape:Pa,evaluate:ho,interpolate:Ia,variable:"",imports:{_:G}},G.prototype=nI.prototype,G.prototype.constructor=G,Wl.prototype=yx(nI.prototype),Wl.prototype.constructor=Wl;function gr(m){this.__wrapped__=m,this.__actions__=[],this.__dir__=1,this.__filtered__=!1,this.__iteratees__=[],this.__takeCount__=rt,this.__views__=[]}function kde(){var m=new gr(this.__wrapped__);return m.__actions__=ps(this.__actions__),m.__dir__=this.__dir__,m.__filtered__=this.__filtered__,m.__iteratees__=ps(this.__iteratees__),m.__takeCount__=this.__takeCount__,m.__views__=ps(this.__views__),m}function Rde(){if(this.__filtered__){var m=new gr(this);m.__dir__=-1,m.__filtered__=!0}else m=this.clone(),m.__dir__*=-1;return m}function Nde(){var m=this.__wrapped__.value(),v=this.__dir__,T=$e(m),N=v<0,V=T?m.length:0,Y=Yme(0,V,this.__views__),J=Y.start,it=Y.end,ft=it-J,Dt=N?it:J-1,Ot=this.__iteratees__,Vt=Ot.length,oe=0,Te=ra(ft,this.__takeCount__);if(!T||!N&&V==ft&&Te==ft)return Qft(m,this.__actions__);var Ne=[];t:for(;ft--&&oe<Te;){Dt+=v;for(var er=-1,De=m[Dt];++er<Vt;){var pr=Ot[er],yr=pr.iteratee,Xs=pr.type,Ra=yr(De);if(Xs==R)De=Ra;else if(!Ra){if(Xs==L)continue t;break t}}Ne[oe++]=De}return Ne}gr.prototype=yx(nI.prototype),gr.prototype.constructor=gr;function e_(m){var v=-1,T=m==null?0:m.length;for(this.clear();++v<T;){var N=m[v];this.set(N[0],N[1])}}function Dde(){this.__data__=AM?AM(null):{},this.size=0}function Ode(m){var v=this.has(m)&&delete this.__data__[m];return this.size-=v?1:0,v}function zde(m){var v=this.__data__;if(AM){var T=v[m];return T===a?e:T}return un.call(v,m)?v[m]:e}function Fde(m){var v=this.__data__;return AM?v[m]!==e:un.call(v,m)}function Bde(m,v){var T=this.__data__;return this.size+=this.has(m)?0:1,T[m]=AM&&v===e?a:v,this}e_.prototype.clear=Dde,e_.prototype.delete=Ode,e_.prototype.get=zde,e_.prototype.has=Fde,e_.prototype.set=Bde;function ip(m){var v=-1,T=m==null?0:m.length;for(this.clear();++v<T;){var N=m[v];this.set(N[0],N[1])}}function Hde(){this.__data__=[],this.size=0}function Vde(m){var v=this.__data__,T=iI(v,m);if(T<0)return!1;var N=v.length-1;return T==N?v.pop():Z6.call(v,T,1),--this.size,!0}function Ude(m){var v=this.__data__,T=iI(v,m);return T<0?e:v[T][1]}function qde(m){return iI(this.__data__,m)>-1}function Gde(m,v){var T=this.__data__,N=iI(T,m);return N<0?(++this.size,T.push([m,v])):T[N][1]=v,this}ip.prototype.clear=Hde,ip.prototype.delete=Vde,ip.prototype.get=Ude,ip.prototype.has=qde,ip.prototype.set=Gde;function op(m){var v=-1,T=m==null?0:m.length;for(this.clear();++v<T;){var N=m[v];this.set(N[0],N[1])}}function Wde(){this.size=0,this.__data__={hash:new e_,map:new(TM||ip),string:new e_}}function Yde(m){var v=gI(this,m).delete(m);return this.size-=v?1:0,v}function jde(m){return gI(this,m).get(m)}function Xde(m){return gI(this,m).has(m)}function $de(m,v){var T=gI(this,m),N=T.size;return T.set(m,v),this.size+=T.size==N?0:1,this}op.prototype.clear=Wde,op.prototype.delete=Yde,op.prototype.get=jde,op.prototype.has=Xde,op.prototype.set=$de;function r_(m){var v=-1,T=m==null?0:m.length;for(this.__data__=new op;++v<T;)this.add(m[v])}function Kde(m){return this.__data__.set(m,a),this}function Zde(m){return this.__data__.has(m)}r_.prototype.add=r_.prototype.push=Kde,r_.prototype.has=Zde;function eu(m){var v=this.__data__=new ip(m);this.size=v.size}function Jde(){this.__data__=new ip,this.size=0}function Qde(m){var v=this.__data__,T=v.delete(m);return this.size=v.size,T}function tme(m){return this.__data__.get(m)}function eme(m){return this.__data__.has(m)}function rme(m,v){var T=this.__data__;if(T instanceof ip){var N=T.__data__;if(!TM||N.length<r-1)return N.push([m,v]),this.size=++T.size,this;T=this.__data__=new op(N)}return T.set(m,v),this.size=T.size,this}eu.prototype.clear=Jde,eu.prototype.delete=Qde,eu.prototype.get=tme,eu.prototype.has=eme,eu.prototype.set=rme;function Ift(m,v){var T=$e(m),N=!T&&s_(m),V=!T&&!N&&bm(m),Y=!T&&!N&&!V&&wx(m),J=T||N||V||Y,it=J?dq(m.length,fde):[],ft=it.length;for(var Dt in m)(v||un.call(m,Dt))&&!(J&&(Dt=="length"||V&&(Dt=="offset"||Dt=="parent")||Y&&(Dt=="buffer"||Dt=="byteLength"||Dt=="byteOffset")||cp(Dt,ft)))&&it.push(Dt);return it}function Lft(m){var v=m.length;return v?m[Lq(0,v-1)]:e}function nme(m,v){return _I(ps(m),n_(v,0,m.length))}function ime(m){return _I(ps(m))}function bq(m,v,T){(T!==e&&!ru(m[v],T)||T===e&&!(v in m))&&ap(m,v,T)}function IM(m,v,T){var N=m[v];(!(un.call(m,v)&&ru(N,T))||T===e&&!(v in m))&&ap(m,v,T)}function iI(m,v){for(var T=m.length;T--;)if(ru(m[T][0],v))return T;return-1}function ome(m,v,T,N){return _m(m,function(V,Y,J){v(N,V,T(V),J)}),N}function kft(m,v){return m&&gh(v,po(v),m)}function ame(m,v){return m&&gh(v,ms(v),m)}function ap(m,v,T){v=="__proto__"&&J6?J6(m,v,{configurable:!0,enumerable:!0,value:T,writable:!0}):m[v]=T}function wq(m,v){for(var T=-1,N=v.length,V=vt(N),Y=m==null;++T<N;)V[T]=Y?e:rG(m,v[T]);return V}function n_(m,v,T){return m===m&&(T!==e&&(m=m<=T?m:T),v!==e&&(m=m>=v?m:v)),m}function Yl(m,v,T,N,V,Y){var J,it=v&c,ft=v&u,Dt=v&h;if(T&&(J=V?T(m,N,V,Y):T(m)),J!==e)return J;if(!ei(m))return m;var Ot=$e(m);if(Ot){if(J=Xme(m),!it)return ps(m,J)}else{var Vt=na(m),oe=Vt==et||Vt==dt;if(bm(m))return rpt(m,it);if(Vt==wt||Vt==bt||oe&&!V){if(J=ft||oe?{}:bpt(m),!it)return ft?zme(m,ame(J,m)):Ome(m,kft(J,m))}else{if(!Tn[Vt])return V?m:{};J=$me(m,Vt,it)}}Y||(Y=new eu);var Te=Y.get(m);if(Te)return Te;Y.set(m,J),Kpt(m)?m.forEach(function(De){J.add(Yl(De,v,T,De,m,Y))}):Xpt(m)&&m.forEach(function(De,pr){J.set(pr,Yl(De,v,T,pr,m,Y))});var Ne=Dt?ft?Uq:Vq:ft?ms:po,er=Ot?e:Ne(m);return ql(er||m,function(De,pr){er&&(pr=De,De=m[pr]),IM(J,pr,Yl(De,v,T,pr,m,Y))}),J}function sme(m){var v=po(m);return function(T){return Rft(T,m,v)}}function Rft(m,v,T){var N=T.length;if(m==null)return!N;for(m=vn(m);N--;){var V=T[N],Y=v[V],J=m[V];if(J===e&&!(V in m)||!Y(J))return!1}return!0}function Nft(m,v,T){if(typeof m!="function")throw new Gl(i);return zM(function(){m.apply(e,T)},v)}function LM(m,v,T,N){var V=-1,Y=V6,J=!0,it=m.length,ft=[],Dt=v.length;if(!it)return ft;T&&(v=$n(v,Ws(T))),N?(Y=lq,J=!1):v.length>=r&&(Y=MM,J=!1,v=new r_(v));t:for(;++V<it;){var Ot=m[V],Vt=T==null?Ot:T(Ot);if(Ot=N||Ot!==0?Ot:0,J&&Vt===Vt){for(var oe=Dt;oe--;)if(v[oe]===Vt)continue t;ft.push(Ot)}else Y(v,Vt,N)||ft.push(Ot)}return ft}var _m=spt(mh),Dft=spt(Mq,!0);function lme(m,v){var T=!0;return _m(m,function(N,V,Y){return T=!!v(N,V,Y),T}),T}function oI(m,v,T){for(var N=-1,V=m.length;++N<V;){var Y=m[N],J=v(Y);if(J!=null&&(it===e?J===J&&!js(J):T(J,it)))var it=J,ft=Y}return ft}function cme(m,v,T,N){var V=m.length;for(T=Qe(T),T<0&&(T=-T>V?0:V+T),N=N===e||N>V?V:Qe(N),N<0&&(N+=V),N=T>N?0:Jpt(N);T<N;)m[T++]=v;return m}function Oft(m,v){var T=[];return _m(m,function(N,V,Y){v(N,V,Y)&&T.push(N)}),T}function Ro(m,v,T,N,V){var Y=-1,J=m.length;for(T||(T=Zme),V||(V=[]);++Y<J;){var it=m[Y];v>0&&T(it)?v>1?Ro(it,v-1,T,N,V):pm(V,it):N||(V[V.length]=it)}return V}var Sq=lpt(),zft=lpt(!0);function mh(m,v){return m&&Sq(m,v,po)}function Mq(m,v){return m&&zft(m,v,po)}function aI(m,v){return fm(v,function(T){return up(m[T])})}function i_(m,v){v=vm(v,m);for(var T=0,N=v.length;m!=null&&T<N;)m=m[_h(v[T++])];return T&&T==N?m:e}function Fft(m,v,T){var N=v(m);return $e(m)?N:pm(N,T(m))}function La(m){return m==null?m===e?tt:ht:t_&&t_ in vn(m)?Wme(m):ige(m)}function Eq(m,v){return m>v}function ume(m,v){return m!=null&&un.call(m,v)}function hme(m,v){return m!=null&&v in vn(m)}function fme(m,v,T){return m>=ra(v,T)&&m<Xi(v,T)}function Tq(m,v,T){for(var N=T?lq:V6,V=m[0].length,Y=m.length,J=Y,it=vt(Y),ft=1/0,Dt=[];J--;){var Ot=m[J];J&&v&&(Ot=$n(Ot,Ws(v))),ft=ra(Ot.length,ft),it[J]=!T&&(v||V>=120&&Ot.length>=120)?new r_(J&&Ot):e}Ot=m[0];var Vt=-1,oe=it[0];t:for(;++Vt<V&&Dt.length<ft;){var Te=Ot[Vt],Ne=v?v(Te):Te;if(Te=T||Te!==0?Te:0,!(oe?MM(oe,Ne):N(Dt,Ne,T))){for(J=Y;--J;){var er=it[J];if(!(er?MM(er,Ne):N(m[J],Ne,T)))continue t}oe&&oe.push(Ne),Dt.push(Te)}}return Dt}function pme(m,v,T,N){return mh(m,function(V,Y,J){v(N,T(V),Y,J)}),N}function kM(m,v,T){v=vm(v,m),m=Ept(m,v);var N=m==null?m:m[_h(Xl(v))];return N==null?e:Gs(N,m,T)}function Bft(m){return si(m)&&La(m)==bt}function dme(m){return si(m)&&La(m)==$t}function mme(m){return si(m)&&La(m)==_t}function RM(m,v,T,N,V){return m===v?!0:m==null||v==null||!si(m)&&!si(v)?m!==m&&v!==v:gme(m,v,T,N,RM,V)}function gme(m,v,T,N,V,Y){var J=$e(m),it=$e(v),ft=J?Mt:na(m),Dt=it?Mt:na(v);ft=ft==bt?wt:ft,Dt=Dt==bt?wt:Dt;var Ot=ft==wt,Vt=Dt==wt,oe=ft==Dt;if(oe&&bm(m)){if(!bm(v))return!1;J=!0,Ot=!1}if(oe&&!Ot)return Y||(Y=new eu),J||wx(m)?ypt(m,v,T,N,V,Y):qme(m,v,ft,T,N,V,Y);if(!(T&f)){var Te=Ot&&un.call(m,"__wrapped__"),Ne=Vt&&un.call(v,"__wrapped__");if(Te||Ne){var er=Te?m.value():m,De=Ne?v.value():v;return Y||(Y=new eu),V(er,De,T,N,Y)}}return oe?(Y||(Y=new eu),Gme(m,v,T,N,V,Y)):!1}function _me(m){return si(m)&&na(m)==q}function Cq(m,v,T,N){var V=T.length,Y=V,J=!N;if(m==null)return!Y;for(m=vn(m);V--;){var it=T[V];if(J&&it[2]?it[1]!==m[it[0]]:!(it[0]in m))return!1}for(;++V<Y;){it=T[V];var ft=it[0],Dt=m[ft],Ot=it[1];if(J&&it[2]){if(Dt===e&&!(ft in m))return!1}else{var Vt=new eu;if(N)var oe=N(Dt,Ot,ft,m,v,Vt);if(!(oe===e?RM(Ot,Dt,f|p,N,Vt):oe))return!1}}return!0}function Hft(m){if(!ei(m)||Qme(m))return!1;var v=up(m)?_de:Pr;return v.test(a_(m))}function yme(m){return si(m)&&La(m)==ee}function vme(m){return si(m)&&na(m)==Le}function xme(m){return si(m)&&SI(m.length)&&!!kn[La(m)]}function Vft(m){return typeof m=="function"?m:m==null?gs:typeof m=="object"?$e(m)?Gft(m[0],m[1]):qft(m):cdt(m)}function Aq(m){if(!OM(m))return Sde(m);var v=[];for(var T in vn(m))un.call(m,T)&&T!="constructor"&&v.push(T);return v}function bme(m){if(!ei(m))return nge(m);var v=OM(m),T=[];for(var N in m)N=="constructor"&&(v||!un.call(m,N))||T.push(N);return T}function Pq(m,v){return m<v}function Uft(m,v){var T=-1,N=ds(m)?vt(m.length):[];return _m(m,function(V,Y,J){N[++T]=v(V,Y,J)}),N}function qft(m){var v=Gq(m);return v.length==1&&v[0][2]?Spt(v[0][0],v[0][1]):function(T){return T===m||Cq(T,m,v)}}function Gft(m,v){return Yq(m)&&wpt(v)?Spt(_h(m),v):function(T){var N=rG(T,m);return N===e&&N===v?nG(T,m):RM(v,N,f|p)}}function sI(m,v,T,N,V){m!==v&&Sq(v,function(Y,J){if(V||(V=new eu),ei(Y))wme(m,v,J,T,sI,N,V);else{var it=N?N(Xq(m,J),Y,J+"",m,v,V):e;it===e&&(it=Y),bq(m,J,it)}},ms)}function wme(m,v,T,N,V,Y,J){var it=Xq(m,T),ft=Xq(v,T),Dt=J.get(ft);if(Dt){bq(m,T,Dt);return}var Ot=Y?Y(it,ft,T+"",m,v,J):e,Vt=Ot===e;if(Vt){var oe=$e(ft),Te=!oe&&bm(ft),Ne=!oe&&!Te&&wx(ft);Ot=ft,oe||Te||Ne?$e(it)?Ot=it:xi(it)?Ot=ps(it):Te?(Vt=!1,Ot=rpt(ft,!0)):Ne?(Vt=!1,Ot=npt(ft,!0)):Ot=[]:FM(ft)||s_(ft)?(Ot=it,s_(it)?Ot=Qpt(it):(!ei(it)||up(it))&&(Ot=bpt(ft))):Vt=!1}Vt&&(J.set(ft,Ot),V(Ot,ft,N,Y,J),J.delete(ft)),bq(m,T,Ot)}function Wft(m,v){var T=m.length;if(!!T)return v+=v<0?T:0,cp(v,T)?m[v]:e}function Yft(m,v,T){v.length?v=$n(v,function(Y){return $e(Y)?function(J){return i_(J,Y.length===1?Y[0]:Y)}:Y}):v=[gs];var N=-1;v=$n(v,Ws(ke()));var V=Uft(m,function(Y,J,it){var ft=$n(v,function(Dt){return Dt(Y)});return{criteria:ft,index:++N,value:Y}});return $pe(V,function(Y,J){return Dme(Y,J,T)})}function Sme(m,v){return jft(m,v,function(T,N){return nG(m,N)})}function jft(m,v,T){for(var N=-1,V=v.length,Y={};++N<V;){var J=v[N],it=i_(m,J);T(it,J)&&NM(Y,vm(J,m),it)}return Y}function Mme(m){return function(v){return i_(v,m)}}function Iq(m,v,T,N){var V=N?Xpe:fx,Y=-1,J=v.length,it=m;for(m===v&&(v=ps(v)),T&&(it=$n(m,Ws(T)));++Y<J;)for(var ft=0,Dt=v[Y],Ot=T?T(Dt):Dt;(ft=V(it,Ot,ft,N))>-1;)it!==m&&Z6.call(it,ft,1),Z6.call(m,ft,1);return m}function Xft(m,v){for(var T=m?v.length:0,N=T-1;T--;){var V=v[T];if(T==N||V!==Y){var Y=V;cp(V)?Z6.call(m,V,1):Nq(m,V)}}return m}function Lq(m,v){return m+tI(Aft()*(v-m+1))}function Eme(m,v,T,N){for(var V=-1,Y=Xi(Q6((v-m)/(T||1)),0),J=vt(Y);Y--;)J[N?Y:++V]=m,m+=T;return J}function kq(m,v){var T="";if(!m||v<1||v>U)return T;do v%2&&(T+=m),v=tI(v/2),v&&(m+=m);while(v);return T}function nr(m,v){return $q(Mpt(m,v,gs),m+"")}function Tme(m){return Lft(Sx(m))}function Cme(m,v){var T=Sx(m);return _I(T,n_(v,0,T.length))}function NM(m,v,T,N){if(!ei(m))return m;v=vm(v,m);for(var V=-1,Y=v.length,J=Y-1,it=m;it!=null&&++V<Y;){var ft=_h(v[V]),Dt=T;if(ft==="__proto__"||ft==="constructor"||ft==="prototype")return m;if(V!=J){var Ot=it[ft];Dt=N?N(Ot,ft,it):e,Dt===e&&(Dt=ei(Ot)?Ot:cp(v[V+1])?[]:{})}IM(it,ft,Dt),it=it[ft]}return m}var $ft=eI?function(m,v){return eI.set(m,v),m}:gs,Ame=J6?function(m,v){return J6(m,"toString",{configurable:!0,enumerable:!1,value:oG(v),writable:!0})}:gs;function Pme(m){return _I(Sx(m))}function jl(m,v,T){var N=-1,V=m.length;v<0&&(v=-v>V?0:V+v),T=T>V?V:T,T<0&&(T+=V),V=v>T?0:T-v>>>0,v>>>=0;for(var Y=vt(V);++N<V;)Y[N]=m[N+v];return Y}function Ime(m,v){var T;return _m(m,function(N,V,Y){return T=v(N,V,Y),!T}),!!T}function lI(m,v,T){var N=0,V=m==null?N:m.length;if(typeof v=="number"&&v===v&&V<=st){for(;N<V;){var Y=N+V>>>1,J=m[Y];J!==null&&!js(J)&&(T?J<=v:J<v)?N=Y+1:V=Y}return V}return Rq(m,v,gs,T)}function Rq(m,v,T,N){var V=0,Y=m==null?0:m.length;if(Y===0)return 0;v=T(v);for(var J=v!==v,it=v===null,ft=js(v),Dt=v===e;V<Y;){var Ot=tI((V+Y)/2),Vt=T(m[Ot]),oe=Vt!==e,Te=Vt===null,Ne=Vt===Vt,er=js(Vt);if(J)var De=N||Ne;else Dt?De=Ne&&(N||oe):it?De=Ne&&oe&&(N||!Te):ft?De=Ne&&oe&&!Te&&(N||!er):Te||er?De=!1:De=N?Vt<=v:Vt<v;De?V=Ot+1:Y=Ot}return ra(Y,ot)}function Kft(m,v){for(var T=-1,N=m.length,V=0,Y=[];++T<N;){var J=m[T],it=v?v(J):J;if(!T||!ru(it,ft)){var ft=it;Y[V++]=J===0?0:J}}return Y}function Zft(m){return typeof m=="number"?m:js(m)?Z:+m}function Ys(m){if(typeof m=="string")return m;if($e(m))return $n(m,Ys)+"";if(js(m))return Pft?Pft.call(m):"";var v=m+"";return v=="0"&&1/m==-z?"-0":v}function ym(m,v,T){var N=-1,V=V6,Y=m.length,J=!0,it=[],ft=it;if(T)J=!1,V=lq;else if(Y>=r){var Dt=v?null:Vme(m);if(Dt)return q6(Dt);J=!1,V=MM,ft=new r_}else ft=v?[]:it;t:for(;++N<Y;){var Ot=m[N],Vt=v?v(Ot):Ot;if(Ot=T||Ot!==0?Ot:0,J&&Vt===Vt){for(var oe=ft.length;oe--;)if(ft[oe]===Vt)continue t;v&&ft.push(Vt),it.push(Ot)}else V(ft,Vt,T)||(ft!==it&&ft.push(Vt),it.push(Ot))}return it}function Nq(m,v){return v=vm(v,m),m=Ept(m,v),m==null||delete m[_h(Xl(v))]}function Jft(m,v,T,N){return NM(m,v,T(i_(m,v)),N)}function cI(m,v,T,N){for(var V=m.length,Y=N?V:-1;(N?Y--:++Y<V)&&v(m[Y],Y,m););return T?jl(m,N?0:Y,N?Y+1:V):jl(m,N?Y+1:0,N?V:Y)}function Qft(m,v){var T=m;return T instanceof gr&&(T=T.value()),cq(v,function(N,V){return V.func.apply(V.thisArg,pm([N],V.args))},T)}function Dq(m,v,T){var N=m.length;if(N<2)return N?ym(m[0]):[];for(var V=-1,Y=vt(N);++V<N;)for(var J=m[V],it=-1;++it<N;)it!=V&&(Y[V]=LM(Y[V]||J,m[it],v,T));return ym(Ro(Y,1),v,T)}function tpt(m,v,T){for(var N=-1,V=m.length,Y=v.length,J={};++N<V;){var it=N<Y?v[N]:e;T(J,m[N],it)}return J}function Oq(m){return xi(m)?m:[]}function zq(m){return typeof m=="function"?m:gs}function vm(m,v){return $e(m)?m:Yq(m,v)?[m]:Ppt(on(m))}var Lme=nr;function xm(m,v,T){var N=m.length;return T=T===e?N:T,!v&&T>=N?m:jl(m,v,T)}var ept=yde||function(m){return fo.clearTimeout(m)};function rpt(m,v){if(v)return m.slice();var T=m.length,N=Sft?Sft(T):new m.constructor(T);return m.copy(N),N}function Fq(m){var v=new m.constructor(m.byteLength);return new $6(v).set(new $6(m)),v}function kme(m,v){var T=v?Fq(m.buffer):m.buffer;return new m.constructor(T,m.byteOffset,m.byteLength)}function Rme(m){var v=new m.constructor(m.source,Ke.exec(m));return v.lastIndex=m.lastIndex,v}function Nme(m){return PM?vn(PM.call(m)):{}}function npt(m,v){var T=v?Fq(m.buffer):m.buffer;return new m.constructor(T,m.byteOffset,m.length)}function ipt(m,v){if(m!==v){var T=m!==e,N=m===null,V=m===m,Y=js(m),J=v!==e,it=v===null,ft=v===v,Dt=js(v);if(!it&&!Dt&&!Y&&m>v||Y&&J&&ft&&!it&&!Dt||N&&J&&ft||!T&&ft||!V)return 1;if(!N&&!Y&&!Dt&&m<v||Dt&&T&&V&&!N&&!Y||it&&T&&V||!J&&V||!ft)return-1}return 0}function Dme(m,v,T){for(var N=-1,V=m.criteria,Y=v.criteria,J=V.length,it=T.length;++N<J;){var ft=ipt(V[N],Y[N]);if(ft){if(N>=it)return ft;var Dt=T[N];return ft*(Dt=="desc"?-1:1)}}return m.index-v.index}function opt(m,v,T,N){for(var V=-1,Y=m.length,J=T.length,it=-1,ft=v.length,Dt=Xi(Y-J,0),Ot=vt(ft+Dt),Vt=!N;++it<ft;)Ot[it]=v[it];for(;++V<J;)(Vt||V<Y)&&(Ot[T[V]]=m[V]);for(;Dt--;)Ot[it++]=m[V++];return Ot}function apt(m,v,T,N){for(var V=-1,Y=m.length,J=-1,it=T.length,ft=-1,Dt=v.length,Ot=Xi(Y-it,0),Vt=vt(Ot+Dt),oe=!N;++V<Ot;)Vt[V]=m[V];for(var Te=V;++ft<Dt;)Vt[Te+ft]=v[ft];for(;++J<it;)(oe||V<Y)&&(Vt[Te+T[J]]=m[V++]);return Vt}function ps(m,v){var T=-1,N=m.length;for(v||(v=vt(N));++T<N;)v[T]=m[T];return v}function gh(m,v,T,N){var V=!T;T||(T={});for(var Y=-1,J=v.length;++Y<J;){var it=v[Y],ft=N?N(T[it],m[it],it,T,m):e;ft===e&&(ft=m[it]),V?ap(T,it,ft):IM(T,it,ft)}return T}function Ome(m,v){return gh(m,Wq(m),v)}function zme(m,v){return gh(m,vpt(m),v)}function uI(m,v){return function(T,N){var V=$e(T)?Upe:ome,Y=v?v():{};return V(T,m,ke(N,2),Y)}}function vx(m){return nr(function(v,T){var N=-1,V=T.length,Y=V>1?T[V-1]:e,J=V>2?T[2]:e;for(Y=m.length>3&&typeof Y=="function"?(V--,Y):e,J&&ka(T[0],T[1],J)&&(Y=V<3?e:Y,V=1),v=vn(v);++N<V;){var it=T[N];it&&m(v,it,N,Y)}return v})}function spt(m,v){return function(T,N){if(T==null)return T;if(!ds(T))return m(T,N);for(var V=T.length,Y=v?V:-1,J=vn(T);(v?Y--:++Y<V)&&N(J[Y],Y,J)!==!1;);return T}}function lpt(m){return function(v,T,N){for(var V=-1,Y=vn(v),J=N(v),it=J.length;it--;){var ft=J[m?it:++V];if(T(Y[ft],ft,Y)===!1)break}return v}}function Fme(m,v,T){var N=v&d,V=DM(m);function Y(){var J=this&&this!==fo&&this instanceof Y?V:m;return J.apply(N?T:this,arguments)}return Y}function cpt(m){return function(v){v=on(v);var T=px(v)?tu(v):e,N=T?T[0]:v.charAt(0),V=T?xm(T,1).join(""):v.slice(1);return N[m]()+V}}function xx(m){return function(v){return cq(sdt(adt(v).replace(Ape,"")),m,"")}}function DM(m){return function(){var v=arguments;switch(v.length){case 0:return new m;case 1:return new m(v[0]);case 2:return new m(v[0],v[1]);case 3:return new m(v[0],v[1],v[2]);case 4:return new m(v[0],v[1],v[2],v[3]);case 5:return new m(v[0],v[1],v[2],v[3],v[4]);case 6:return new m(v[0],v[1],v[2],v[3],v[4],v[5]);case 7:return new m(v[0],v[1],v[2],v[3],v[4],v[5],v[6])}var T=yx(m.prototype),N=m.apply(T,v);return ei(N)?N:T}}function Bme(m,v,T){var N=DM(m);function V(){for(var Y=arguments.length,J=vt(Y),it=Y,ft=bx(V);it--;)J[it]=arguments[it];var Dt=Y<3&&J[0]!==ft&&J[Y-1]!==ft?[]:dm(J,ft);if(Y-=Dt.length,Y<T)return dpt(m,v,hI,V.placeholder,e,J,Dt,e,e,T-Y);var Ot=this&&this!==fo&&this instanceof V?N:m;return Gs(Ot,this,J)}return V}function upt(m){return function(v,T,N){var V=vn(v);if(!ds(v)){var Y=ke(T,3);v=po(v),T=function(it){return Y(V[it],it,V)}}var J=m(v,T,N);return J>-1?V[Y?v[J]:J]:e}}function hpt(m){return lp(function(v){var T=v.length,N=T,V=Wl.prototype.thru;for(m&&v.reverse();N--;){var Y=v[N];if(typeof Y!="function")throw new Gl(i);if(V&&!J&&mI(Y)=="wrapper")var J=new Wl([],!0)}for(N=J?N:T;++N<T;){Y=v[N];var it=mI(Y),ft=it=="wrapper"?qq(Y):e;ft&&jq(ft[0])&&ft[1]==(C|y|b|P)&&!ft[4].length&&ft[9]==1?J=J[mI(ft[0])].apply(J,ft[3]):J=Y.length==1&&jq(Y)?J[it]():J.thru(Y)}return function(){var Dt=arguments,Ot=Dt[0];if(J&&Dt.length==1&&$e(Ot))return J.plant(Ot).value();for(var Vt=0,oe=T?v[Vt].apply(this,Dt):Ot;++Vt<T;)oe=v[Vt].call(this,oe);return oe}})}function hI(m,v,T,N,V,Y,J,it,ft,Dt){var Ot=v&C,Vt=v&d,oe=v&g,Te=v&(y|x),Ne=v&k,er=oe?e:DM(m);function De(){for(var pr=arguments.length,yr=vt(pr),Xs=pr;Xs--;)yr[Xs]=arguments[Xs];if(Te)var Ra=bx(De),$s=Zpe(yr,Ra);if(N&&(yr=opt(yr,N,V,Te)),Y&&(yr=apt(yr,Y,J,Te)),pr-=$s,Te&&pr<Dt){var bi=dm(yr,Ra);return dpt(m,v,hI,De.placeholder,T,yr,bi,it,ft,Dt-pr)}var nu=Vt?T:this,fp=oe?nu[m]:m;return pr=yr.length,it?yr=oge(yr,it):Ne&&pr>1&&yr.reverse(),Ot&&ft<pr&&(yr.length=ft),this&&this!==fo&&this instanceof De&&(fp=er||DM(fp)),fp.apply(nu,yr)}return De}function fpt(m,v){return function(T,N){return pme(T,m,v(N),{})}}function fI(m,v){return function(T,N){var V;if(T===e&&N===e)return v;if(T!==e&&(V=T),N!==e){if(V===e)return N;typeof T=="string"||typeof N=="string"?(T=Ys(T),N=Ys(N)):(T=Zft(T),N=Zft(N)),V=m(T,N)}return V}}function Bq(m){return lp(function(v){return v=$n(v,Ws(ke())),nr(function(T){var N=this;return m(v,function(V){return Gs(V,N,T)})})})}function pI(m,v){v=v===e?" ":Ys(v);var T=v.length;if(T<2)return T?kq(v,m):v;var N=kq(v,Q6(m/dx(v)));return px(v)?xm(tu(N),0,m).join(""):N.slice(0,m)}function Hme(m,v,T,N){var V=v&d,Y=DM(m);function J(){for(var it=-1,ft=arguments.length,Dt=-1,Ot=N.length,Vt=vt(Ot+ft),oe=this&&this!==fo&&this instanceof J?Y:m;++Dt<Ot;)Vt[Dt]=N[Dt];for(;ft--;)Vt[Dt++]=arguments[++it];return Gs(oe,V?T:this,Vt)}return J}function ppt(m){return function(v,T,N){return N&&typeof N!="number"&&ka(v,T,N)&&(T=N=e),v=hp(v),T===e?(T=v,v=0):T=hp(T),N=N===e?v<T?1:-1:hp(N),Eme(v,T,N,m)}}function dI(m){return function(v,T){return typeof v=="string"&&typeof T=="string"||(v=$l(v),T=$l(T)),m(v,T)}}function dpt(m,v,T,N,V,Y,J,it,ft,Dt){var Ot=v&y,Vt=Ot?J:e,oe=Ot?e:J,Te=Ot?Y:e,Ne=Ot?e:Y;v|=Ot?b:S,v&=~(Ot?S:b),v&_||(v&=~(d|g));var er=[m,v,V,Te,Vt,Ne,oe,it,ft,Dt],De=T.apply(e,er);return jq(m)&&Tpt(De,er),De.placeholder=N,Cpt(De,m,v)}function Hq(m){var v=ji[m];return function(T,N){if(T=$l(T),N=N==null?0:ra(Qe(N),292),N&&Cft(T)){var V=(on(T)+"e").split("e"),Y=v(V[0]+"e"+(+V[1]+N));return V=(on(Y)+"e").split("e"),+(V[0]+"e"+(+V[1]-N))}return v(T)}}var Vme=gx&&1/q6(new gx([,-0]))[1]==z?function(m){return new gx(m)}:lG;function mpt(m){return function(v){var T=na(v);return T==q?gq(v):T==Le?ide(v):Kpe(v,m(v))}}function sp(m,v,T,N,V,Y,J,it){var ft=v&g;if(!ft&&typeof m!="function")throw new Gl(i);var Dt=N?N.length:0;if(Dt||(v&=~(b|S),N=V=e),J=J===e?J:Xi(Qe(J),0),it=it===e?it:Qe(it),Dt-=V?V.length:0,v&S){var Ot=N,Vt=V;N=V=e}var oe=ft?e:qq(m),Te=[m,v,T,N,V,Ot,Vt,Y,J,it];if(oe&&rge(Te,oe),m=Te[0],v=Te[1],T=Te[2],N=Te[3],V=Te[4],it=Te[9]=Te[9]===e?ft?0:m.length:Xi(Te[9]-Dt,0),!it&&v&(y|x)&&(v&=~(y|x)),!v||v==d)var Ne=Fme(m,v,T);else v==y||v==x?Ne=Bme(m,v,it):(v==b||v==(d|b))&&!V.length?Ne=Hme(m,v,T,N):Ne=hI.apply(e,Te);var er=oe?$ft:Tpt;return Cpt(er(Ne,Te),m,v)}function gpt(m,v,T,N){return m===e||ru(m,mx[T])&&!un.call(N,T)?v:m}function _pt(m,v,T,N,V,Y){return ei(m)&&ei(v)&&(Y.set(v,m),sI(m,v,e,_pt,Y),Y.delete(v)),m}function Ume(m){return FM(m)?e:m}function ypt(m,v,T,N,V,Y){var J=T&f,it=m.length,ft=v.length;if(it!=ft&&!(J&&ft>it))return!1;var Dt=Y.get(m),Ot=Y.get(v);if(Dt&&Ot)return Dt==v&&Ot==m;var Vt=-1,oe=!0,Te=T&p?new r_:e;for(Y.set(m,v),Y.set(v,m);++Vt<it;){var Ne=m[Vt],er=v[Vt];if(N)var De=J?N(er,Ne,Vt,v,m,Y):N(Ne,er,Vt,m,v,Y);if(De!==e){if(De)continue;oe=!1;break}if(Te){if(!uq(v,function(pr,yr){if(!MM(Te,yr)&&(Ne===pr||V(Ne,pr,T,N,Y)))return Te.push(yr)})){oe=!1;break}}else if(!(Ne===er||V(Ne,er,T,N,Y))){oe=!1;break}}return Y.delete(m),Y.delete(v),oe}function qme(m,v,T,N,V,Y,J){switch(T){case he:if(m.byteLength!=v.byteLength||m.byteOffset!=v.byteOffset)return!1;m=m.buffer,v=v.buffer;case $t:return!(m.byteLength!=v.byteLength||!Y(new $6(m),new $6(v)));case Kt:case _t:case pt:return ru(+m,+v);case X:return m.name==v.name&&m.message==v.message;case ee:case ar:return m==v+"";case q:var it=gq;case Le:var ft=N&f;if(it||(it=q6),m.size!=v.size&&!ft)return!1;var Dt=J.get(m);if(Dt)return Dt==v;N|=p,J.set(m,v);var Ot=ypt(it(m),it(v),N,V,Y,J);return J.delete(m),Ot;case fr:if(PM)return PM.call(m)==PM.call(v)}return!1}function Gme(m,v,T,N,V,Y){var J=T&f,it=Vq(m),ft=it.length,Dt=Vq(v),Ot=Dt.length;if(ft!=Ot&&!J)return!1;for(var Vt=ft;Vt--;){var oe=it[Vt];if(!(J?oe in v:un.call(v,oe)))return!1}var Te=Y.get(m),Ne=Y.get(v);if(Te&&Ne)return Te==v&&Ne==m;var er=!0;Y.set(m,v),Y.set(v,m);for(var De=J;++Vt<ft;){oe=it[Vt];var pr=m[oe],yr=v[oe];if(N)var Xs=J?N(yr,pr,oe,v,m,Y):N(pr,yr,oe,m,v,Y);if(!(Xs===e?pr===yr||V(pr,yr,T,N,Y):Xs)){er=!1;break}De||(De=oe=="constructor")}if(er&&!De){var Ra=m.constructor,$s=v.constructor;Ra!=$s&&"constructor"in m&&"constructor"in v&&!(typeof Ra=="function"&&Ra instanceof Ra&&typeof $s=="function"&&$s instanceof $s)&&(er=!1)}return Y.delete(m),Y.delete(v),er}function lp(m){return $q(Mpt(m,e,Rpt),m+"")}function Vq(m){return Fft(m,po,Wq)}function Uq(m){return Fft(m,ms,vpt)}var qq=eI?function(m){return eI.get(m)}:lG;function mI(m){for(var v=m.name+"",T=_x[v],N=un.call(_x,v)?T.length:0;N--;){var V=T[N],Y=V.func;if(Y==null||Y==m)return V.name}return v}function bx(m){var v=un.call(G,"placeholder")?G:m;return v.placeholder}function ke(){var m=G.iteratee||aG;return m=m===aG?Vft:m,arguments.length?m(arguments[0],arguments[1]):m}function gI(m,v){var T=m.__data__;return Jme(v)?T[typeof v=="string"?"string":"hash"]:T.map}function Gq(m){for(var v=po(m),T=v.length;T--;){var N=v[T],V=m[N];v[T]=[N,V,wpt(V)]}return v}function o_(m,v){var T=ede(m,v);return Hft(T)?T:e}function Wme(m){var v=un.call(m,t_),T=m[t_];try{m[t_]=e;var N=!0}catch(Y){}var V=j6.call(m);return N&&(v?m[t_]=T:delete m[t_]),V}var Wq=yq?function(m){return m==null?[]:(m=vn(m),fm(yq(m),function(v){return Eft.call(m,v)}))}:cG,vpt=yq?function(m){for(var v=[];m;)pm(v,Wq(m)),m=K6(m);return v}:cG,na=La;(vq&&na(new vq(new ArrayBuffer(1)))!=he||TM&&na(new TM)!=q||xq&&na(xq.resolve())!=kt||gx&&na(new gx)!=Le||CM&&na(new CM)!=$)&&(na=function(m){var v=La(m),T=v==wt?m.constructor:e,N=T?a_(T):"";if(N)switch(N){case Cde:return he;case Ade:return q;case Pde:return kt;case Ide:return Le;case Lde:return $}return v});function Yme(m,v,T){for(var N=-1,V=T.length;++N<V;){var Y=T[N],J=Y.size;switch(Y.type){case"drop":m+=J;break;case"dropRight":v-=J;break;case"take":v=ra(v,m+J);break;case"takeRight":m=Xi(m,v-J);break}}return{start:m,end:v}}function jme(m){var v=m.match(Et);return v?v[1].split(xt):[]}function xpt(m,v,T){v=vm(v,m);for(var N=-1,V=v.length,Y=!1;++N<V;){var J=_h(v[N]);if(!(Y=m!=null&&T(m,J)))break;m=m[J]}return Y||++N!=V?Y:(V=m==null?0:m.length,!!V&&SI(V)&&cp(J,V)&&($e(m)||s_(m)))}function Xme(m){var v=m.length,T=new m.constructor(v);return v&&typeof m[0]=="string"&&un.call(m,"index")&&(T.index=m.index,T.input=m.input),T}function bpt(m){return typeof m.constructor=="function"&&!OM(m)?yx(K6(m)):{}}function $me(m,v,T){var N=m.constructor;switch(v){case $t:return Fq(m);case Kt:case _t:return new N(+m);case he:return kme(m,T);case Tt:case be:case nt:case Ct:case Wt:case fe:case at:case se:case Qt:return npt(m,T);case q:return new N;case pt:case ar:return new N(m);case ee:return Rme(m);case Le:return new N;case fr:return Nme(m)}}function Kme(m,v){var T=v.length;if(!T)return m;var N=T-1;return v[N]=(T>1?"& ":"")+v[N],v=v.join(T>2?", ":" "),m.replace(gt,`{
/* [wrapped with `+v+`] */
`)}function Zme(m){return $e(m)||s_(m)||!!(Tft&&m&&m[Tft])}function cp(m,v){var T=typeof m;return v=v==null?U:v,!!v&&(T=="number"||T!="symbol"&&np.test(m))&&m>-1&&m%1==0&&m<v}function ka(m,v,T){if(!ei(T))return!1;var N=typeof v;return(N=="number"?ds(T)&&cp(v,T.length):N=="string"&&v in T)?ru(T[v],m):!1}function Yq(m,v){if($e(m))return!1;var T=typeof m;return T=="number"||T=="symbol"||T=="boolean"||m==null||js(m)?!0:cm.test(m)||!lx.test(m)||v!=null&&m in vn(v)}function Jme(m){var v=typeof m;return v=="string"||v=="number"||v=="symbol"||v=="boolean"?m!=="__proto__":m===null}function jq(m){var v=mI(m),T=G[v];if(typeof T!="function"||!(v in gr.prototype))return!1;if(m===T)return!0;var N=qq(T);return!!N&&m===N[0]}function Qme(m){return!!wft&&wft in m}var tge=W6?up:uG;function OM(m){var v=m&&m.constructor,T=typeof v=="function"&&v.prototype||mx;return m===T}function wpt(m){return m===m&&!ei(m)}function Spt(m,v){return function(T){return T==null?!1:T[m]===v&&(v!==e||m in vn(T))}}function ege(m){var v=bI(m,function(N){return T.size===s&&T.clear(),N}),T=v.cache;return v}function rge(m,v){var T=m[1],N=v[1],V=T|N,Y=V<(d|g|C),J=N==C&&T==y||N==C&&T==P&&m[7].length<=v[8]||N==(C|P)&&v[7].length<=v[8]&&T==y;if(!(Y||J))return m;N&d&&(m[2]=v[2],V|=T&d?0:_);var it=v[3];if(it){var ft=m[3];m[3]=ft?opt(ft,it,v[4]):it,m[4]=ft?dm(m[3],l):v[4]}return it=v[5],it&&(ft=m[5],m[5]=ft?apt(ft,it,v[6]):it,m[6]=ft?dm(m[5],l):v[6]),it=v[7],it&&(m[7]=it),N&C&&(m[8]=m[8]==null?v[8]:ra(m[8],v[8])),m[9]==null&&(m[9]=v[9]),m[0]=v[0],m[1]=V,m}function nge(m){var v=[];if(m!=null)for(var T in vn(m))v.push(T);return v}function ige(m){return j6.call(m)}function Mpt(m,v,T){return v=Xi(v===e?m.length-1:v,0),function(){for(var N=arguments,V=-1,Y=Xi(N.length-v,0),J=vt(Y);++V<Y;)J[V]=N[v+V];V=-1;for(var it=vt(v+1);++V<v;)it[V]=N[V];return it[v]=T(J),Gs(m,this,it)}}function Ept(m,v){return v.length<2?m:i_(m,jl(v,0,-1))}function oge(m,v){for(var T=m.length,N=ra(v.length,T),V=ps(m);N--;){var Y=v[N];m[N]=cp(Y,T)?V[Y]:e}return m}function Xq(m,v){if(!(v==="constructor"&&typeof m[v]=="function")&&v!="__proto__")return m[v]}var Tpt=Apt($ft),zM=xde||function(m,v){return fo.setTimeout(m,v)},$q=Apt(Ame);function Cpt(m,v,T){var N=v+"";return $q(m,Kme(N,age(jme(N),T)))}function Apt(m){var v=0,T=0;return function(){var N=Mde(),V=I-(N-T);if(T=N,V>0){if(++v>=B)return arguments[0]}else v=0;return m.apply(e,arguments)}}function _I(m,v){var T=-1,N=m.length,V=N-1;for(v=v===e?N:v;++T<v;){var Y=Lq(T,V),J=m[Y];m[Y]=m[T],m[T]=J}return m.length=v,m}var Ppt=ege(function(m){var v=[];return m.charCodeAt(0)===46&&v.push(""),m.replace(J0,function(T,N,V,Y){v.push(V?Y.replace(Ue,"$1"):N||T)}),v});function _h(m){if(typeof m=="string"||js(m))return m;var v=m+"";return v=="0"&&1/m==-z?"-0":v}function a_(m){if(m!=null){try{return Y6.call(m)}catch(v){}try{return m+""}catch(v){}}return""}function age(m,v){return ql(St,function(T){var N="_."+T[0];v&T[1]&&!V6(m,N)&&m.push(N)}),m.sort()}function Ipt(m){if(m instanceof gr)return m.clone();var v=new Wl(m.__wrapped__,m.__chain__);return v.__actions__=ps(m.__actions__),v.__index__=m.__index__,v.__values__=m.__values__,v}function sge(m,v,T){(T?ka(m,v,T):v===e)?v=1:v=Xi(Qe(v),0);var N=m==null?0:m.length;if(!N||v<1)return[];for(var V=0,Y=0,J=vt(Q6(N/v));V<N;)J[Y++]=jl(m,V,V+=v);return J}function lge(m){for(var v=-1,T=m==null?0:m.length,N=0,V=[];++v<T;){var Y=m[v];Y&&(V[N++]=Y)}return V}function cge(){var m=arguments.length;if(!m)return[];for(var v=vt(m-1),T=arguments[0],N=m;N--;)v[N-1]=arguments[N];return pm($e(T)?ps(T):[T],Ro(v,1))}var uge=nr(function(m,v){return xi(m)?LM(m,Ro(v,1,xi,!0)):[]}),hge=nr(function(m,v){var T=Xl(v);return xi(T)&&(T=e),xi(m)?LM(m,Ro(v,1,xi,!0),ke(T,2)):[]}),fge=nr(function(m,v){var T=Xl(v);return xi(T)&&(T=e),xi(m)?LM(m,Ro(v,1,xi,!0),e,T):[]});function pge(m,v,T){var N=m==null?0:m.length;return N?(v=T||v===e?1:Qe(v),jl(m,v<0?0:v,N)):[]}function dge(m,v,T){var N=m==null?0:m.length;return N?(v=T||v===e?1:Qe(v),v=N-v,jl(m,0,v<0?0:v)):[]}function mge(m,v){return m&&m.length?cI(m,ke(v,3),!0,!0):[]}function gge(m,v){return m&&m.length?cI(m,ke(v,3),!0):[]}function _ge(m,v,T,N){var V=m==null?0:m.length;return V?(T&&typeof T!="number"&&ka(m,v,T)&&(T=0,N=V),cme(m,v,T,N)):[]}function Lpt(m,v,T){var N=m==null?0:m.length;if(!N)return-1;var V=T==null?0:Qe(T);return V<0&&(V=Xi(N+V,0)),U6(m,ke(v,3),V)}function kpt(m,v,T){var N=m==null?0:m.length;if(!N)return-1;var V=N-1;return T!==e&&(V=Qe(T),V=T<0?Xi(N+V,0):ra(V,N-1)),U6(m,ke(v,3),V,!0)}function Rpt(m){var v=m==null?0:m.length;return v?Ro(m,1):[]}function yge(m){var v=m==null?0:m.length;return v?Ro(m,z):[]}function vge(m,v){var T=m==null?0:m.length;return T?(v=v===e?1:Qe(v),Ro(m,v)):[]}function xge(m){for(var v=-1,T=m==null?0:m.length,N={};++v<T;){var V=m[v];N[V[0]]=V[1]}return N}function Npt(m){return m&&m.length?m[0]:e}function bge(m,v,T){var N=m==null?0:m.length;if(!N)return-1;var V=T==null?0:Qe(T);return V<0&&(V=Xi(N+V,0)),fx(m,v,V)}function wge(m){var v=m==null?0:m.length;return v?jl(m,0,-1):[]}var Sge=nr(function(m){var v=$n(m,Oq);return v.length&&v[0]===m[0]?Tq(v):[]}),Mge=nr(function(m){var v=Xl(m),T=$n(m,Oq);return v===Xl(T)?v=e:T.pop(),T.length&&T[0]===m[0]?Tq(T,ke(v,2)):[]}),Ege=nr(function(m){var v=Xl(m),T=$n(m,Oq);return v=typeof v=="function"?v:e,v&&T.pop(),T.length&&T[0]===m[0]?Tq(T,e,v):[]});function Tge(m,v){return m==null?"":wde.call(m,v)}function Xl(m){var v=m==null?0:m.length;return v?m[v-1]:e}function Cge(m,v,T){var N=m==null?0:m.length;if(!N)return-1;var V=N;return T!==e&&(V=Qe(T),V=V<0?Xi(N+V,0):ra(V,N-1)),v===v?ade(m,v,V):U6(m,dft,V,!0)}function Age(m,v){return m&&m.length?Wft(m,Qe(v)):e}var Pge=nr(Dpt);function Dpt(m,v){return m&&m.length&&v&&v.length?Iq(m,v):m}function Ige(m,v,T){return m&&m.length&&v&&v.length?Iq(m,v,ke(T,2)):m}function Lge(m,v,T){return m&&m.length&&v&&v.length?Iq(m,v,e,T):m}var kge=lp(function(m,v){var T=m==null?0:m.length,N=wq(m,v);return Xft(m,$n(v,function(V){return cp(V,T)?+V:V}).sort(ipt)),N});function Rge(m,v){var T=[];if(!(m&&m.length))return T;var N=-1,V=[],Y=m.length;for(v=ke(v,3);++N<Y;){var J=m[N];v(J,N,m)&&(T.push(J),V.push(N))}return Xft(m,V),T}function Kq(m){return m==null?m:Tde.call(m)}function Nge(m,v,T){var N=m==null?0:m.length;return N?(T&&typeof T!="number"&&ka(m,v,T)?(v=0,T=N):(v=v==null?0:Qe(v),T=T===e?N:Qe(T)),jl(m,v,T)):[]}function Dge(m,v){return lI(m,v)}function Oge(m,v,T){return Rq(m,v,ke(T,2))}function zge(m,v){var T=m==null?0:m.length;if(T){var N=lI(m,v);if(N<T&&ru(m[N],v))return N}return-1}function Fge(m,v){return lI(m,v,!0)}function Bge(m,v,T){return Rq(m,v,ke(T,2),!0)}function Hge(m,v){var T=m==null?0:m.length;if(T){var N=lI(m,v,!0)-1;if(ru(m[N],v))return N}return-1}function Vge(m){return m&&m.length?Kft(m):[]}function Uge(m,v){return m&&m.length?Kft(m,ke(v,2)):[]}function qge(m){var v=m==null?0:m.length;return v?jl(m,1,v):[]}function Gge(m,v,T){return m&&m.length?(v=T||v===e?1:Qe(v),jl(m,0,v<0?0:v)):[]}function Wge(m,v,T){var N=m==null?0:m.length;return N?(v=T||v===e?1:Qe(v),v=N-v,jl(m,v<0?0:v,N)):[]}function Yge(m,v){return m&&m.length?cI(m,ke(v,3),!1,!0):[]}function jge(m,v){return m&&m.length?cI(m,ke(v,3)):[]}var Xge=nr(function(m){return ym(Ro(m,1,xi,!0))}),$ge=nr(function(m){var v=Xl(m);return xi(v)&&(v=e),ym(Ro(m,1,xi,!0),ke(v,2))}),Kge=nr(function(m){var v=Xl(m);return v=typeof v=="function"?v:e,ym(Ro(m,1,xi,!0),e,v)});function Zge(m){return m&&m.length?ym(m):[]}function Jge(m,v){return m&&m.length?ym(m,ke(v,2)):[]}function Qge(m,v){return v=typeof v=="function"?v:e,m&&m.length?ym(m,e,v):[]}function Zq(m){if(!(m&&m.length))return[];var v=0;return m=fm(m,function(T){if(xi(T))return v=Xi(T.length,v),!0}),dq(v,function(T){return $n(m,hq(T))})}function Opt(m,v){if(!(m&&m.length))return[];var T=Zq(m);return v==null?T:$n(T,function(N){return Gs(v,e,N)})}var t0e=nr(function(m,v){return xi(m)?LM(m,v):[]}),e0e=nr(function(m){return Dq(fm(m,xi))}),r0e=nr(function(m){var v=Xl(m);return xi(v)&&(v=e),Dq(fm(m,xi),ke(v,2))}),n0e=nr(function(m){var v=Xl(m);return v=typeof v=="function"?v:e,Dq(fm(m,xi),e,v)}),i0e=nr(Zq);function o0e(m,v){return tpt(m||[],v||[],IM)}function a0e(m,v){return tpt(m||[],v||[],NM)}var s0e=nr(function(m){var v=m.length,T=v>1?m[v-1]:e;return T=typeof T=="function"?(m.pop(),T):e,Opt(m,T)});function zpt(m){var v=G(m);return v.__chain__=!0,v}function l0e(m,v){return v(m),m}function yI(m,v){return v(m)}var c0e=lp(function(m){var v=m.length,T=v?m[0]:0,N=this.__wrapped__,V=function(Y){return wq(Y,m)};return v>1||this.__actions__.length||!(N instanceof gr)||!cp(T)?this.thru(V):(N=N.slice(T,+T+(v?1:0)),N.__actions__.push({func:yI,args:[V],thisArg:e}),new Wl(N,this.__chain__).thru(function(Y){return v&&!Y.length&&Y.push(e),Y}))});function u0e(){return zpt(this)}function h0e(){return new Wl(this.value(),this.__chain__)}function f0e(){this.__values__===e&&(this.__values__=Zpt(this.value()));var m=this.__index__>=this.__values__.length,v=m?e:this.__values__[this.__index__++];return{done:m,value:v}}function p0e(){return this}function d0e(m){for(var v,T=this;T instanceof nI;){var N=Ipt(T);N.__index__=0,N.__values__=e,v?V.__wrapped__=N:v=N;var V=N;T=T.__wrapped__}return V.__wrapped__=m,v}function m0e(){var m=this.__wrapped__;if(m instanceof gr){var v=m;return this.__actions__.length&&(v=new gr(this)),v=v.reverse(),v.__actions__.push({func:yI,args:[Kq],thisArg:e}),new Wl(v,this.__chain__)}return this.thru(Kq)}function g0e(){return Qft(this.__wrapped__,this.__actions__)}var _0e=uI(function(m,v,T){un.call(m,T)?++m[T]:ap(m,T,1)});function y0e(m,v,T){var N=$e(m)?fft:lme;return T&&ka(m,v,T)&&(v=e),N(m,ke(v,3))}function v0e(m,v){var T=$e(m)?fm:Oft;return T(m,ke(v,3))}var x0e=upt(Lpt),b0e=upt(kpt);function w0e(m,v){return Ro(vI(m,v),1)}function S0e(m,v){return Ro(vI(m,v),z)}function M0e(m,v,T){return T=T===e?1:Qe(T),Ro(vI(m,v),T)}function Fpt(m,v){var T=$e(m)?ql:_m;return T(m,ke(v,3))}function Bpt(m,v){var T=$e(m)?qpe:Dft;return T(m,ke(v,3))}var E0e=uI(function(m,v,T){un.call(m,T)?m[T].push(v):ap(m,T,[v])});function T0e(m,v,T,N){m=ds(m)?m:Sx(m),T=T&&!N?Qe(T):0;var V=m.length;return T<0&&(T=Xi(V+T,0)),MI(m)?T<=V&&m.indexOf(v,T)>-1:!!V&&fx(m,v,T)>-1}var C0e=nr(function(m,v,T){var N=-1,V=typeof v=="function",Y=ds(m)?vt(m.length):[];return _m(m,function(J){Y[++N]=V?Gs(v,J,T):kM(J,v,T)}),Y}),A0e=uI(function(m,v,T){ap(m,T,v)});function vI(m,v){var T=$e(m)?$n:Uft;return T(m,ke(v,3))}function P0e(m,v,T,N){return m==null?[]:($e(v)||(v=v==null?[]:[v]),T=N?e:T,$e(T)||(T=T==null?[]:[T]),Yft(m,v,T))}var I0e=uI(function(m,v,T){m[T?0:1].push(v)},function(){return[[],[]]});function L0e(m,v,T){var N=$e(m)?cq:gft,V=arguments.length<3;return N(m,ke(v,4),T,V,_m)}function k0e(m,v,T){var N=$e(m)?Gpe:gft,V=arguments.length<3;return N(m,ke(v,4),T,V,Dft)}function R0e(m,v){var T=$e(m)?fm:Oft;return T(m,wI(ke(v,3)))}function N0e(m){var v=$e(m)?Lft:Tme;return v(m)}function D0e(m,v,T){(T?ka(m,v,T):v===e)?v=1:v=Qe(v);var N=$e(m)?nme:Cme;return N(m,v)}function O0e(m){var v=$e(m)?ime:Pme;return v(m)}function z0e(m){if(m==null)return 0;if(ds(m))return MI(m)?dx(m):m.length;var v=na(m);return v==q||v==Le?m.size:Aq(m).length}function F0e(m,v,T){var N=$e(m)?uq:Ime;return T&&ka(m,v,T)&&(v=e),N(m,ke(v,3))}var B0e=nr(function(m,v){if(m==null)return[];var T=v.length;return T>1&&ka(m,v[0],v[1])?v=[]:T>2&&ka(v[0],v[1],v[2])&&(v=[v[0]]),Yft(m,Ro(v,1),[])}),xI=vde||function(){return fo.Date.now()};function H0e(m,v){if(typeof v!="function")throw new Gl(i);return m=Qe(m),function(){if(--m<1)return v.apply(this,arguments)}}function Hpt(m,v,T){return v=T?e:v,v=m&&v==null?m.length:v,sp(m,C,e,e,e,e,v)}function Vpt(m,v){var T;if(typeof v!="function")throw new Gl(i);return m=Qe(m),function(){return--m>0&&(T=v.apply(this,arguments)),m<=1&&(v=e),T}}var Jq=nr(function(m,v,T){var N=d;if(T.length){var V=dm(T,bx(Jq));N|=b}return sp(m,N,v,T,V)}),Upt=nr(function(m,v,T){var N=d|g;if(T.length){var V=dm(T,bx(Upt));N|=b}return sp(v,N,m,T,V)});function qpt(m,v,T){v=T?e:v;var N=sp(m,y,e,e,e,e,e,v);return N.placeholder=qpt.placeholder,N}function Gpt(m,v,T){v=T?e:v;var N=sp(m,x,e,e,e,e,e,v);return N.placeholder=Gpt.placeholder,N}function Wpt(m,v,T){var N,V,Y,J,it,ft,Dt=0,Ot=!1,Vt=!1,oe=!0;if(typeof m!="function")throw new Gl(i);v=$l(v)||0,ei(T)&&(Ot=!!T.leading,Vt="maxWait"in T,Y=Vt?Xi($l(T.maxWait)||0,v):Y,oe="trailing"in T?!!T.trailing:oe);function Te(bi){var nu=N,fp=V;return N=V=e,Dt=bi,J=m.apply(fp,nu),J}function Ne(bi){return Dt=bi,it=zM(pr,v),Ot?Te(bi):J}function er(bi){var nu=bi-ft,fp=bi-Dt,udt=v-nu;return Vt?ra(udt,Y-fp):udt}function De(bi){var nu=bi-ft,fp=bi-Dt;return ft===e||nu>=v||nu<0||Vt&&fp>=Y}function pr(){var bi=xI();if(De(bi))return yr(bi);it=zM(pr,er(bi))}function yr(bi){return it=e,oe&&N?Te(bi):(N=V=e,J)}function Xs(){it!==e&&ept(it),Dt=0,N=ft=V=it=e}function Ra(){return it===e?J:yr(xI())}function $s(){var bi=xI(),nu=De(bi);if(N=arguments,V=this,ft=bi,nu){if(it===e)return Ne(ft);if(Vt)return ept(it),it=zM(pr,v),Te(ft)}return it===e&&(it=zM(pr,v)),J}return $s.cancel=Xs,$s.flush=Ra,$s}var V0e=nr(function(m,v){return Nft(m,1,v)}),U0e=nr(function(m,v,T){return Nft(m,$l(v)||0,T)});function q0e(m){return sp(m,k)}function bI(m,v){if(typeof m!="function"||v!=null&&typeof v!="function")throw new Gl(i);var T=function(){var N=arguments,V=v?v.apply(this,N):N[0],Y=T.cache;if(Y.has(V))return Y.get(V);var J=m.apply(this,N);return T.cache=Y.set(V,J)||Y,J};return T.cache=new(bI.Cache||op),T}bI.Cache=op;function wI(m){if(typeof m!="function")throw new Gl(i);return function(){var v=arguments;switch(v.length){case 0:return!m.call(this);case 1:return!m.call(this,v[0]);case 2:return!m.call(this,v[0],v[1]);case 3:return!m.call(this,v[0],v[1],v[2])}return!m.apply(this,v)}}function G0e(m){return Vpt(2,m)}var W0e=Lme(function(m,v){v=v.length==1&&$e(v[0])?$n(v[0],Ws(ke())):$n(Ro(v,1),Ws(ke()));var T=v.length;return nr(function(N){for(var V=-1,Y=ra(N.length,T);++V<Y;)N[V]=v[V].call(this,N[V]);return Gs(m,this,N)})}),Qq=nr(function(m,v){var T=dm(v,bx(Qq));return sp(m,b,e,v,T)}),Ypt=nr(function(m,v){var T=dm(v,bx(Ypt));return sp(m,S,e,v,T)}),Y0e=lp(function(m,v){return sp(m,P,e,e,e,v)});function j0e(m,v){if(typeof m!="function")throw new Gl(i);return v=v===e?v:Qe(v),nr(m,v)}function X0e(m,v){if(typeof m!="function")throw new Gl(i);return v=v==null?0:Xi(Qe(v),0),nr(function(T){var N=T[v],V=xm(T,0,v);return N&&pm(V,N),Gs(m,this,V)})}function $0e(m,v,T){var N=!0,V=!0;if(typeof m!="function")throw new Gl(i);return ei(T)&&(N="leading"in T?!!T.leading:N,V="trailing"in T?!!T.trailing:V),Wpt(m,v,{leading:N,maxWait:v,trailing:V})}function K0e(m){return Hpt(m,1)}function Z0e(m,v){return Qq(zq(v),m)}function J0e(){if(!arguments.length)return[];var m=arguments[0];return $e(m)?m:[m]}function Q0e(m){return Yl(m,h)}function t_e(m,v){return v=typeof v=="function"?v:e,Yl(m,h,v)}function e_e(m){return Yl(m,c|h)}function r_e(m,v){return v=typeof v=="function"?v:e,Yl(m,c|h,v)}function n_e(m,v){return v==null||Rft(m,v,po(v))}function ru(m,v){return m===v||m!==m&&v!==v}var i_e=dI(Eq),o_e=dI(function(m,v){return m>=v}),s_=Bft(function(){return arguments}())?Bft:function(m){return si(m)&&un.call(m,"callee")&&!Eft.call(m,"callee")},$e=vt.isArray,a_e=aft?Ws(aft):dme;function ds(m){return m!=null&&SI(m.length)&&!up(m)}function xi(m){return si(m)&&ds(m)}function s_e(m){return m===!0||m===!1||si(m)&&La(m)==Kt}var bm=bde||uG,l_e=sft?Ws(sft):mme;function c_e(m){return si(m)&&m.nodeType===1&&!FM(m)}function u_e(m){if(m==null)return!0;if(ds(m)&&($e(m)||typeof m=="string"||typeof m.splice=="function"||bm(m)||wx(m)||s_(m)))return!m.length;var v=na(m);if(v==q||v==Le)return!m.size;if(OM(m))return!Aq(m).length;for(var T in m)if(un.call(m,T))return!1;return!0}function h_e(m,v){return RM(m,v)}function f_e(m,v,T){T=typeof T=="function"?T:e;var N=T?T(m,v):e;return N===e?RM(m,v,e,T):!!N}function tG(m){if(!si(m))return!1;var v=La(m);return v==X||v==ct||typeof m.message=="string"&&typeof m.name=="string"&&!FM(m)}function p_e(m){return typeof m=="number"&&Cft(m)}function up(m){if(!ei(m))return!1;var v=La(m);return v==et||v==dt||v==lt||v==ie}function jpt(m){return typeof m=="number"&&m==Qe(m)}function SI(m){return typeof m=="number"&&m>-1&&m%1==0&&m<=U}function ei(m){var v=typeof m;return m!=null&&(v=="object"||v=="function")}function si(m){return m!=null&&typeof m=="object"}var Xpt=lft?Ws(lft):_me;function d_e(m,v){return m===v||Cq(m,v,Gq(v))}function m_e(m,v,T){return T=typeof T=="function"?T:e,Cq(m,v,Gq(v),T)}function g_e(m){return $pt(m)&&m!=+m}function __e(m){if(tge(m))throw new We(n);return Hft(m)}function y_e(m){return m===null}function v_e(m){return m==null}function $pt(m){return typeof m=="number"||si(m)&&La(m)==pt}function FM(m){if(!si(m)||La(m)!=wt)return!1;var v=K6(m);if(v===null)return!0;var T=un.call(v,"constructor")&&v.constructor;return typeof T=="function"&&T instanceof T&&Y6.call(T)==mde}var eG=cft?Ws(cft):yme;function x_e(m){return jpt(m)&&m>=-U&&m<=U}var Kpt=uft?Ws(uft):vme;function MI(m){return typeof m=="string"||!$e(m)&&si(m)&&La(m)==ar}function js(m){return typeof m=="symbol"||si(m)&&La(m)==fr}var wx=hft?Ws(hft):xme;function b_e(m){return m===e}function w_e(m){return si(m)&&na(m)==$}function S_e(m){return si(m)&&La(m)==It}var M_e=dI(Pq),E_e=dI(function(m,v){return m<=v});function Zpt(m){if(!m)return[];if(ds(m))return MI(m)?tu(m):ps(m);if(EM&&m[EM])return nde(m[EM]());var v=na(m),T=v==q?gq:v==Le?q6:Sx;return T(m)}function hp(m){if(!m)return m===0?m:0;if(m=$l(m),m===z||m===-z){var v=m<0?-1:1;return v*W}return m===m?m:0}function Qe(m){var v=hp(m),T=v%1;return v===v?T?v-T:v:0}function Jpt(m){return m?n_(Qe(m),0,rt):0}function $l(m){if(typeof m=="number")return m;if(js(m))return Z;if(ei(m)){var v=typeof m.valueOf=="function"?m.valueOf():m;m=ei(v)?v+"":v}if(typeof m!="string")return m===0?m:+m;m=_ft(m);var T=_r.test(m);return T||jn.test(m)?Hpe(m.slice(2),T?2:8):Xr.test(m)?Z:+m}function Qpt(m){return gh(m,ms(m))}function T_e(m){return m?n_(Qe(m),-U,U):m===0?m:0}function on(m){return m==null?"":Ys(m)}var C_e=vx(function(m,v){if(OM(v)||ds(v)){gh(v,po(v),m);return}for(var T in v)un.call(v,T)&&IM(m,T,v[T])}),tdt=vx(function(m,v){gh(v,ms(v),m)}),EI=vx(function(m,v,T,N){gh(v,ms(v),m,N)}),A_e=vx(function(m,v,T,N){gh(v,po(v),m,N)}),P_e=lp(wq);function I_e(m,v){var T=yx(m);return v==null?T:kft(T,v)}var L_e=nr(function(m,v){m=vn(m);var T=-1,N=v.length,V=N>2?v[2]:e;for(V&&ka(v[0],v[1],V)&&(N=1);++T<N;)for(var Y=v[T],J=ms(Y),it=-1,ft=J.length;++it<ft;){var Dt=J[it],Ot=m[Dt];(Ot===e||ru(Ot,mx[Dt])&&!un.call(m,Dt))&&(m[Dt]=Y[Dt])}return m}),k_e=nr(function(m){return m.push(e,_pt),Gs(edt,e,m)});function R_e(m,v){return pft(m,ke(v,3),mh)}function N_e(m,v){return pft(m,ke(v,3),Mq)}function D_e(m,v){return m==null?m:Sq(m,ke(v,3),ms)}function O_e(m,v){return m==null?m:zft(m,ke(v,3),ms)}function z_e(m,v){return m&&mh(m,ke(v,3))}function F_e(m,v){return m&&Mq(m,ke(v,3))}function B_e(m){return m==null?[]:aI(m,po(m))}function H_e(m){return m==null?[]:aI(m,ms(m))}function rG(m,v,T){var N=m==null?e:i_(m,v);return N===e?T:N}function V_e(m,v){return m!=null&&xpt(m,v,ume)}function nG(m,v){return m!=null&&xpt(m,v,hme)}var U_e=fpt(function(m,v,T){v!=null&&typeof v.toString!="function"&&(v=j6.call(v)),m[v]=T},oG(gs)),q_e=fpt(function(m,v,T){v!=null&&typeof v.toString!="function"&&(v=j6.call(v)),un.call(m,v)?m[v].push(T):m[v]=[T]},ke),G_e=nr(kM);function po(m){return ds(m)?Ift(m):Aq(m)}function ms(m){return ds(m)?Ift(m,!0):bme(m)}function W_e(m,v){var T={};return v=ke(v,3),mh(m,function(N,V,Y){ap(T,v(N,V,Y),N)}),T}function Y_e(m,v){var T={};return v=ke(v,3),mh(m,function(N,V,Y){ap(T,V,v(N,V,Y))}),T}var j_e=vx(function(m,v,T){sI(m,v,T)}),edt=vx(function(m,v,T,N){sI(m,v,T,N)}),X_e=lp(function(m,v){var T={};if(m==null)return T;var N=!1;v=$n(v,function(Y){return Y=vm(Y,m),N||(N=Y.length>1),Y}),gh(m,Uq(m),T),N&&(T=Yl(T,c|u|h,Ume));for(var V=v.length;V--;)Nq(T,v[V]);return T});function $_e(m,v){return rdt(m,wI(ke(v)))}var K_e=lp(function(m,v){return m==null?{}:Sme(m,v)});function rdt(m,v){if(m==null)return{};var T=$n(Uq(m),function(N){return[N]});return v=ke(v),jft(m,T,function(N,V){return v(N,V[0])})}function Z_e(m,v,T){v=vm(v,m);var N=-1,V=v.length;for(V||(V=1,m=e);++N<V;){var Y=m==null?e:m[_h(v[N])];Y===e&&(N=V,Y=T),m=up(Y)?Y.call(m):Y}return m}function J_e(m,v,T){return m==null?m:NM(m,v,T)}function Q_e(m,v,T,N){return N=typeof N=="function"?N:e,m==null?m:NM(m,v,T,N)}var ndt=mpt(po),idt=mpt(ms);function tye(m,v,T){var N=$e(m),V=N||bm(m)||wx(m);if(v=ke(v,4),T==null){var Y=m&&m.constructor;V?T=N?new Y:[]:ei(m)?T=up(Y)?yx(K6(m)):{}:T={}}return(V?ql:mh)(m,function(J,it,ft){return v(T,J,it,ft)}),T}function eye(m,v){return m==null?!0:Nq(m,v)}function rye(m,v,T){return m==null?m:Jft(m,v,zq(T))}function nye(m,v,T,N){return N=typeof N=="function"?N:e,m==null?m:Jft(m,v,zq(T),N)}function Sx(m){return m==null?[]:mq(m,po(m))}function iye(m){return m==null?[]:mq(m,ms(m))}function oye(m,v,T){return T===e&&(T=v,v=e),T!==e&&(T=$l(T),T=T===T?T:0),v!==e&&(v=$l(v),v=v===v?v:0),n_($l(m),v,T)}function aye(m,v,T){return v=hp(v),T===e?(T=v,v=0):T=hp(T),m=$l(m),fme(m,v,T)}function sye(m,v,T){if(T&&typeof T!="boolean"&&ka(m,v,T)&&(v=T=e),T===e&&(typeof v=="boolean"?(T=v,v=e):typeof m=="boolean"&&(T=m,m=e)),m===e&&v===e?(m=0,v=1):(m=hp(m),v===e?(v=m,m=0):v=hp(v)),m>v){var N=m;m=v,v=N}if(T||m%1||v%1){var V=Aft();return ra(m+V*(v-m+Bpe("1e-"+((V+"").length-1))),v)}return Lq(m,v)}var lye=xx(function(m,v,T){return v=v.toLowerCase(),m+(T?odt(v):v)});function odt(m){return iG(on(m).toLowerCase())}function adt(m){return m=on(m),m&&m.replace(um,Jpe).replace(Ppe,"")}function cye(m,v,T){m=on(m),v=Ys(v);var N=m.length;T=T===e?N:n_(Qe(T),0,N);var V=T;return T-=v.length,T>=0&&m.slice(T,V)==v}function uye(m){return m=on(m),m&&Ar.test(m)?m.replace(yn,Qpe):m}function hye(m){return m=on(m),m&&cx.test(m)?m.replace(cn,"\\$&"):m}var fye=xx(function(m,v,T){return m+(T?"-":"")+v.toLowerCase()}),pye=xx(function(m,v,T){return m+(T?" ":"")+v.toLowerCase()}),dye=cpt("toLowerCase");function mye(m,v,T){m=on(m),v=Qe(v);var N=v?dx(m):0;if(!v||N>=v)return m;var V=(v-N)/2;return pI(tI(V),T)+m+pI(Q6(V),T)}function gye(m,v,T){m=on(m),v=Qe(v);var N=v?dx(m):0;return v&&N<v?m+pI(v-N,T):m}function _ye(m,v,T){m=on(m),v=Qe(v);var N=v?dx(m):0;return v&&N<v?pI(v-N,T)+m:m}function yye(m,v,T){return T||v==null?v=0:v&&(v=+v),Ede(on(m).replace(rp,""),v||0)}function vye(m,v,T){return(T?ka(m,v,T):v===e)?v=1:v=Qe(v),kq(on(m),v)}function xye(){var m=arguments,v=on(m[0]);return m.length<3?v:v.replace(m[1],m[2])}var bye=xx(function(m,v,T){return m+(T?"_":"")+v.toLowerCase()});function wye(m,v,T){return T&&typeof T!="number"&&ka(m,v,T)&&(v=T=e),T=T===e?rt:T>>>0,T?(m=on(m),m&&(typeof v=="string"||v!=null&&!eG(v))&&(v=Ys(v),!v&&px(m))?xm(tu(m),0,T):m.split(v,T)):[]}var Sye=xx(function(m,v,T){return m+(T?" ":"")+iG(v)});function Mye(m,v,T){return m=on(m),T=T==null?0:n_(Qe(T),0,m.length),v=Ys(v),m.slice(T,T+v.length)==v}function Eye(m,v,T){var N=G.templateSettings;T&&ka(m,v,T)&&(v=e),m=on(m),v=EI({},v,N,gpt);var V=EI({},v.imports,N.imports,gpt),Y=po(V),J=mq(V,Y),it,ft,Dt=0,Ot=v.interpolate||mr,Vt="__p += '",oe=_q((v.escape||mr).source+"|"+Ot.source+"|"+(Ot===Ia?tr:mr).source+"|"+(v.evaluate||mr).source+"|$","g"),Te="//# sourceURL="+(un.call(v,"sourceURL")?(v.sourceURL+"").replace(/\s/g," "):"lodash.templateSources["+ ++Npe+"]")+`
`;m.replace(oe,function(De,pr,yr,Xs,Ra,$s){return yr||(yr=Xs),Vt+=m.slice(Dt,$s).replace(Fl,tde),pr&&(it=!0,Vt+=`' +
__e(`+pr+`) +
'`),Ra&&(ft=!0,Vt+=`';
`+Ra+`;
__p += '`),yr&&(Vt+=`' +
((__t = (`+yr+`)) == null ? '' : __t) +
'`),Dt=$s+De.length,De}),Vt+=`';
`;var Ne=un.call(v,"variable")&&v.variable;if(!Ne)Vt=`with (obj) {
`+Vt+`
}
`;else if(Ve.test(Ne))throw new We(o);Vt=(ft?Vt.replace(Ce,""):Vt).replace(Pt,"$1").replace(Nt,"$1;"),Vt="function("+(Ne||"obj")+`) {
`+(Ne?"":`obj || (obj = {});
`)+"var __t, __p = ''"+(it?", __e = _.escape":"")+(ft?`, __j = Array.prototype.join;
function print() { __p += __j.call(arguments, '') }
`:`;
`)+Vt+`return __p
}`;var er=ldt(function(){return $r(Y,Te+"return "+Vt).apply(e,J)});if(er.source=Vt,tG(er))throw er;return er}function Tye(m){return on(m).toLowerCase()}function Cye(m){return on(m).toUpperCase()}function Aye(m,v,T){if(m=on(m),m&&(T||v===e))return _ft(m);if(!m||!(v=Ys(v)))return m;var N=tu(m),V=tu(v),Y=yft(N,V),J=vft(N,V)+1;return xm(N,Y,J).join("")}function Pye(m,v,T){if(m=on(m),m&&(T||v===e))return m.slice(0,bft(m)+1);if(!m||!(v=Ys(v)))return m;var N=tu(m),V=vft(N,tu(v))+1;return xm(N,0,V).join("")}function Iye(m,v,T){if(m=on(m),m&&(T||v===e))return m.replace(rp,"");if(!m||!(v=Ys(v)))return m;var N=tu(m),V=yft(N,tu(v));return xm(N,V).join("")}function Lye(m,v){var T=O,N=D;if(ei(v)){var V="separator"in v?v.separator:V;T="length"in v?Qe(v.length):T,N="omission"in v?Ys(v.omission):N}m=on(m);var Y=m.length;if(px(m)){var J=tu(m);Y=J.length}if(T>=Y)return m;var it=T-dx(N);if(it<1)return N;var ft=J?xm(J,0,it).join(""):m.slice(0,it);if(V===e)return ft+N;if(J&&(it+=ft.length-it),eG(V)){if(m.slice(it).search(V)){var Dt,Ot=ft;for(V.global||(V=_q(V.source,on(Ke.exec(V))+"g")),V.lastIndex=0;Dt=V.exec(Ot);)var Vt=Dt.index;ft=ft.slice(0,Vt===e?it:Vt)}}else if(m.indexOf(Ys(V),it)!=it){var oe=ft.lastIndexOf(V);oe>-1&&(ft=ft.slice(0,oe))}return ft+N}function kye(m){return m=on(m),m&&Wi.test(m)?m.replace(ze,sde):m}var Rye=xx(function(m,v,T){return m+(T?" ":"")+v.toUpperCase()}),iG=cpt("toUpperCase");function sdt(m,v,T){return m=on(m),v=T?e:v,v===e?rde(m)?ude(m):jpe(m):m.match(v)||[]}var ldt=nr(function(m,v){try{return Gs(m,e,v)}catch(T){return tG(T)?T:new We(T)}}),Nye=lp(function(m,v){return ql(v,function(T){T=_h(T),ap(m,T,Jq(m[T],m))}),m});function Dye(m){var v=m==null?0:m.length,T=ke();return m=v?$n(m,function(N){if(typeof N[1]!="function")throw new Gl(i);return[T(N[0]),N[1]]}):[],nr(function(N){for(var V=-1;++V<v;){var Y=m[V];if(Gs(Y[0],this,N))return Gs(Y[1],this,N)}})}function Oye(m){return sme(Yl(m,c))}function oG(m){return function(){return m}}function zye(m,v){return m==null||m!==m?v:m}var Fye=hpt(),Bye=hpt(!0);function gs(m){return m}function aG(m){return Vft(typeof m=="function"?m:Yl(m,c))}function Hye(m){return qft(Yl(m,c))}function Vye(m,v){return Gft(m,Yl(v,c))}var Uye=nr(function(m,v){return function(T){return kM(T,m,v)}}),qye=nr(function(m,v){return function(T){return kM(m,T,v)}});function sG(m,v,T){var N=po(v),V=aI(v,N);T==null&&!(ei(v)&&(V.length||!N.length))&&(T=v,v=m,m=this,V=aI(v,po(v)));var Y=!(ei(T)&&"chain"in T)||!!T.chain,J=up(m);return ql(V,function(it){var ft=v[it];m[it]=ft,J&&(m.prototype[it]=function(){var Dt=this.__chain__;if(Y||Dt){var Ot=m(this.__wrapped__),Vt=Ot.__actions__=ps(this.__actions__);return Vt.push({func:ft,args:arguments,thisArg:m}),Ot.__chain__=Dt,Ot}return ft.apply(m,pm([this.value()],arguments))})}),m}function Gye(){return fo._===this&&(fo._=gde),this}function lG(){}function Wye(m){return m=Qe(m),nr(function(v){return Wft(v,m)})}var Yye=Bq($n),jye=Bq(fft),Xye=Bq(uq);function cdt(m){return Yq(m)?hq(_h(m)):Mme(m)}function $ye(m){return function(v){return m==null?e:i_(m,v)}}var Kye=ppt(),Zye=ppt(!0);function cG(){return[]}function uG(){return!1}function Jye(){return{}}function Qye(){return""}function tve(){return!0}function eve(m,v){if(m=Qe(m),m<1||m>U)return[];var T=rt,N=ra(m,rt);v=ke(v),m-=rt;for(var V=dq(N,v);++T<m;)v(T);return V}function rve(m){return $e(m)?$n(m,_h):js(m)?[m]:ps(Ppt(on(m)))}function nve(m){var v=++dde;return on(m)+v}var ive=fI(function(m,v){return m+v},0),ove=Hq("ceil"),ave=fI(function(m,v){return m/v},1),sve=Hq("floor");function lve(m){return m&&m.length?oI(m,gs,Eq):e}function cve(m,v){return m&&m.length?oI(m,ke(v,2),Eq):e}function uve(m){return mft(m,gs)}function hve(m,v){return mft(m,ke(v,2))}function fve(m){return m&&m.length?oI(m,gs,Pq):e}function pve(m,v){return m&&m.length?oI(m,ke(v,2),Pq):e}var dve=fI(function(m,v){return m*v},1),mve=Hq("round"),gve=fI(function(m,v){return m-v},0);function _ve(m){return m&&m.length?pq(m,gs):0}function yve(m,v){return m&&m.length?pq(m,ke(v,2)):0}return G.after=H0e,G.ary=Hpt,G.assign=C_e,G.assignIn=tdt,G.assignInWith=EI,G.assignWith=A_e,G.at=P_e,G.before=Vpt,G.bind=Jq,G.bindAll=Nye,G.bindKey=Upt,G.castArray=J0e,G.chain=zpt,G.chunk=sge,G.compact=lge,G.concat=cge,G.cond=Dye,G.conforms=Oye,G.constant=oG,G.countBy=_0e,G.create=I_e,G.curry=qpt,G.curryRight=Gpt,G.debounce=Wpt,G.defaults=L_e,G.defaultsDeep=k_e,G.defer=V0e,G.delay=U0e,G.difference=uge,G.differenceBy=hge,G.differenceWith=fge,G.drop=pge,G.dropRight=dge,G.dropRightWhile=mge,G.dropWhile=gge,G.fill=_ge,G.filter=v0e,G.flatMap=w0e,G.flatMapDeep=S0e,G.flatMapDepth=M0e,G.flatten=Rpt,G.flattenDeep=yge,G.flattenDepth=vge,G.flip=q0e,G.flow=Fye,G.flowRight=Bye,G.fromPairs=xge,G.functions=B_e,G.functionsIn=H_e,G.groupBy=E0e,G.initial=wge,G.intersection=Sge,G.intersectionBy=Mge,G.intersectionWith=Ege,G.invert=U_e,G.invertBy=q_e,G.invokeMap=C0e,G.iteratee=aG,G.keyBy=A0e,G.keys=po,G.keysIn=ms,G.map=vI,G.mapKeys=W_e,G.mapValues=Y_e,G.matches=Hye,G.matchesProperty=Vye,G.memoize=bI,G.merge=j_e,G.mergeWith=edt,G.method=Uye,G.methodOf=qye,G.mixin=sG,G.negate=wI,G.nthArg=Wye,G.omit=X_e,G.omitBy=$_e,G.once=G0e,G.orderBy=P0e,G.over=Yye,G.overArgs=W0e,G.overEvery=jye,G.overSome=Xye,G.partial=Qq,G.partialRight=Ypt,G.partition=I0e,G.pick=K_e,G.pickBy=rdt,G.property=cdt,G.propertyOf=$ye,G.pull=Pge,G.pullAll=Dpt,G.pullAllBy=Ige,G.pullAllWith=Lge,G.pullAt=kge,G.range=Kye,G.rangeRight=Zye,G.rearg=Y0e,G.reject=R0e,G.remove=Rge,G.rest=j0e,G.reverse=Kq,G.sampleSize=D0e,G.set=J_e,G.setWith=Q_e,G.shuffle=O0e,G.slice=Nge,G.sortBy=B0e,G.sortedUniq=Vge,G.sortedUniqBy=Uge,G.split=wye,G.spread=X0e,G.tail=qge,G.take=Gge,G.takeRight=Wge,G.takeRightWhile=Yge,G.takeWhile=jge,G.tap=l0e,G.throttle=$0e,G.thru=yI,G.toArray=Zpt,G.toPairs=ndt,G.toPairsIn=idt,G.toPath=rve,G.toPlainObject=Qpt,G.transform=tye,G.unary=K0e,G.union=Xge,G.unionBy=$ge,G.unionWith=Kge,G.uniq=Zge,G.uniqBy=Jge,G.uniqWith=Qge,G.unset=eye,G.unzip=Zq,G.unzipWith=Opt,G.update=rye,G.updateWith=nye,G.values=Sx,G.valuesIn=iye,G.without=t0e,G.words=sdt,G.wrap=Z0e,G.xor=e0e,G.xorBy=r0e,G.xorWith=n0e,G.zip=i0e,G.zipObject=o0e,G.zipObjectDeep=a0e,G.zipWith=s0e,G.entries=ndt,G.entriesIn=idt,G.extend=tdt,G.extendWith=EI,sG(G,G),G.add=ive,G.attempt=ldt,G.camelCase=lye,G.capitalize=odt,G.ceil=ove,G.clamp=oye,G.clone=Q0e,G.cloneDeep=e_e,G.cloneDeepWith=r_e,G.cloneWith=t_e,G.conformsTo=n_e,G.deburr=adt,G.defaultTo=zye,G.divide=ave,G.endsWith=cye,G.eq=ru,G.escape=uye,G.escapeRegExp=hye,G.every=y0e,G.find=x0e,G.findIndex=Lpt,G.findKey=R_e,G.findLast=b0e,G.findLastIndex=kpt,G.findLastKey=N_e,G.floor=sve,G.forEach=Fpt,G.forEachRight=Bpt,G.forIn=D_e,G.forInRight=O_e,G.forOwn=z_e,G.forOwnRight=F_e,G.get=rG,G.gt=i_e,G.gte=o_e,G.has=V_e,G.hasIn=nG,G.head=Npt,G.identity=gs,G.includes=T0e,G.indexOf=bge,G.inRange=aye,G.invoke=G_e,G.isArguments=s_,G.isArray=$e,G.isArrayBuffer=a_e,G.isArrayLike=ds,G.isArrayLikeObject=xi,G.isBoolean=s_e,G.isBuffer=bm,G.isDate=l_e,G.isElement=c_e,G.isEmpty=u_e,G.isEqual=h_e,G.isEqualWith=f_e,G.isError=tG,G.isFinite=p_e,G.isFunction=up,G.isInteger=jpt,G.isLength=SI,G.isMap=Xpt,G.isMatch=d_e,G.isMatchWith=m_e,G.isNaN=g_e,G.isNative=__e,G.isNil=v_e,G.isNull=y_e,G.isNumber=$pt,G.isObject=ei,G.isObjectLike=si,G.isPlainObject=FM,G.isRegExp=eG,G.isSafeInteger=x_e,G.isSet=Kpt,G.isString=MI,G.isSymbol=js,G.isTypedArray=wx,G.isUndefined=b_e,G.isWeakMap=w_e,G.isWeakSet=S_e,G.join=Tge,G.kebabCase=fye,G.last=Xl,G.lastIndexOf=Cge,G.lowerCase=pye,G.lowerFirst=dye,G.lt=M_e,G.lte=E_e,G.max=lve,G.maxBy=cve,G.mean=uve,G.meanBy=hve,G.min=fve,G.minBy=pve,G.stubArray=cG,G.stubFalse=uG,G.stubObject=Jye,G.stubString=Qye,G.stubTrue=tve,G.multiply=dve,G.nth=Age,G.noConflict=Gye,G.noop=lG,G.now=xI,G.pad=mye,G.padEnd=gye,G.padStart=_ye,G.parseInt=yye,G.random=sye,G.reduce=L0e,G.reduceRight=k0e,G.repeat=vye,G.replace=xye,G.result=Z_e,G.round=mve,G.runInContext=ut,G.sample=N0e,G.size=z0e,G.snakeCase=bye,G.some=F0e,G.sortedIndex=Dge,G.sortedIndexBy=Oge,G.sortedIndexOf=zge,G.sortedLastIndex=Fge,G.sortedLastIndexBy=Bge,G.sortedLastIndexOf=Hge,G.startCase=Sye,G.startsWith=Mye,G.subtract=gve,G.sum=_ve,G.sumBy=yve,G.template=Eye,G.times=eve,G.toFinite=hp,G.toInteger=Qe,G.toLength=Jpt,G.toLower=Tye,G.toNumber=$l,G.toSafeInteger=T_e,G.toString=on,G.toUpper=Cye,G.trim=Aye,G.trimEnd=Pye,G.trimStart=Iye,G.truncate=Lye,G.unescape=kye,G.uniqueId=nve,G.upperCase=Rye,G.upperFirst=iG,G.each=Fpt,G.eachRight=Bpt,G.first=Npt,sG(G,function(){var m={};return mh(G,function(v,T){un.call(G.prototype,T)||(m[T]=v)}),m}(),{chain:!1}),G.VERSION=t,ql(["bind","bindKey","curry","curryRight","partial","partialRight"],function(m){G[m].placeholder=G}),ql(["drop","take"],function(m,v){gr.prototype[m]=function(T){T=T===e?1:Xi(Qe(T),0);var N=this.__filtered__&&!v?new gr(this):this.clone();return N.__filtered__?N.__takeCount__=ra(T,N.__takeCount__):N.__views__.push({size:ra(T,rt),type:m+(N.__dir__<0?"Right":"")}),N},gr.prototype[m+"Right"]=function(T){return this.reverse()[m](T).reverse()}}),ql(["filter","map","takeWhile"],function(m,v){var T=v+1,N=T==L||T==F;gr.prototype[m]=function(V){var Y=this.clone();return Y.__iteratees__.push({iteratee:ke(V,3),type:T}),Y.__filtered__=Y.__filtered__||N,Y}}),ql(["head","last"],function(m,v){var T="take"+(v?"Right":"");gr.prototype[m]=function(){return this[T](1).value()[0]}}),ql(["initial","tail"],function(m,v){var T="drop"+(v?"":"Right");gr.prototype[m]=function(){return this.__filtered__?new gr(this):this[T](1)}}),gr.prototype.compact=function(){return this.filter(gs)},gr.prototype.find=function(m){return this.filter(m).head()},gr.prototype.findLast=function(m){return this.reverse().find(m)},gr.prototype.invokeMap=nr(function(m,v){return typeof m=="function"?new gr(this):this.map(function(T){return kM(T,m,v)})}),gr.prototype.reject=function(m){return this.filter(wI(ke(m)))},gr.prototype.slice=function(m,v){m=Qe(m);var T=this;return T.__filtered__&&(m>0||v<0)?new gr(T):(m<0?T=T.takeRight(-m):m&&(T=T.drop(m)),v!==e&&(v=Qe(v),T=v<0?T.dropRight(-v):T.take(v-m)),T)},gr.prototype.takeRightWhile=function(m){return this.reverse().takeWhile(m).reverse()},gr.prototype.toArray=function(){return this.take(rt)},mh(gr.prototype,function(m,v){var T=/^(?:filter|find|map|reject)|While$/.test(v),N=/^(?:head|last)$/.test(v),V=G[N?"take"+(v=="last"?"Right":""):v],Y=N||/^find/.test(v);!V||(G.prototype[v]=function(){var J=this.__wrapped__,it=N?[1]:arguments,ft=J instanceof gr,Dt=it[0],Ot=ft||$e(J),Vt=function(pr){var yr=V.apply(G,pm([pr],it));return N&&oe?yr[0]:yr};Ot&&T&&typeof Dt=="function"&&Dt.length!=1&&(ft=Ot=!1);var oe=this.__chain__,Te=!!this.__actions__.length,Ne=Y&&!oe,er=ft&&!Te;if(!Y&&Ot){J=er?J:new gr(this);var De=m.apply(J,it);return De.__actions__.push({func:yI,args:[Vt],thisArg:e}),new Wl(De,oe)}return Ne&&er?m.apply(this,it):(De=this.thru(Vt),Ne?N?De.value()[0]:De.value():De)})}),ql(["pop","push","shift","sort","splice","unshift"],function(m){var v=G6[m],T=/^(?:push|sort|unshift)$/.test(m)?"tap":"thru",N=/^(?:pop|shift)$/.test(m);G.prototype[m]=function(){var V=arguments;if(N&&!this.__chain__){var Y=this.value();return v.apply($e(Y)?Y:[],V)}return this[T](function(J){return v.apply($e(J)?J:[],V)})}}),mh(gr.prototype,function(m,v){var T=G[v];if(T){var N=T.name+"";un.call(_x,N)||(_x[N]=[]),_x[N].push({name:v,func:T})}}),_x[hI(e,g).name]=[{name:"wrapper",func:e}],gr.prototype.clone=kde,gr.prototype.reverse=Rde,gr.prototype.value=Nde,G.prototype.at=c0e,G.prototype.chain=u0e,G.prototype.commit=h0e,G.prototype.next=f0e,G.prototype.plant=d0e,G.prototype.reverse=m0e,G.prototype.toJSON=G.prototype.valueOf=G.prototype.value=g0e,G.prototype.first=G.prototype.head,EM&&(G.prototype[EM]=p0e),G},mm=hde();typeof define=="function"&&typeof define.amd=="object"&&define.amd?(fo._=mm,define(function(){return mm})):Q0?((Q0.exports=mm)._=mm,aq._=mm):fo._=mm}).call(Rx)});function __t(){for(var e=0,t=arguments.length,r={},n;e<t;++e){if(!(n=arguments[e]+"")||n in r||/[\s.]/.test(n))throw new Error("illegal type: "+n);r[n]=[]}return new J9(r)}function J9(e){this._=e}function g2e(e,t){return e.trim().split(/^|\s+/).map(function(r){var n="",i=r.indexOf(".");if(i>=0&&(n=r.slice(i+1),r=r.slice(0,i)),r&&!t.hasOwnProperty(r))throw new Error("unknown type: "+r);return{type:r,name:n}})}function _2e(e,t){for(var r=0,n=e.length,i;r<n;++r)if((i=e[r]).name===t)return i.value}function g_t(e,t,r){for(var n=0,i=e.length;n<i;++n)if(e[n].name===t){e[n]=m2e,e=e.slice(0,n).concat(e.slice(n+1));break}return r!=null&&e.push({name:t,value:r}),e}var m2e,vs,y_t=M(()=>{m2e={value:function(){}};J9.prototype=__t.prototype={constructor:J9,on:function(e,t){var r=this._,n=g2e(e+"",r),i,o=-1,a=n.length;if(arguments.length<2){for(;++o<a;)if((i=(e=n[o]).type)&&(i=_2e(r[i],e.name)))return i;return}if(t!=null&&typeof t!="function")throw new Error("invalid callback: "+t);for(;++o<a;)if(i=(e=n[o]).type)r[i]=g_t(r[i],e.name,t);else if(t==null)for(i in r)r[i]=g_t(r[i],e.name,null);return this},copy:function(){var e={},t=this._;for(var r in t)e[r]=t[r].slice();return new J9(e)},call:function(e,t){if((i=arguments.length-2)>0)for(var r=new Array(i),n=0,i,o;n<i;++n)r[n]=arguments[n+2];if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(o=this._[e],n=0,i=o.length;n<i;++n)o[n].value.apply(t,r)},apply:function(e,t,r){if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(var n=this._[e],i=0,o=n.length;i<o;++i)n[i].value.apply(t,r)}};vs=__t});var km=M(()=>{y_t()});function _Y(e){return+e}var Cvt=M(()=>{});function yY(e){return e*e}function vY(e){return e*(2-e)}function IL(e){return((e*=2)<=1?e*e:--e*(2-e)+1)/2}var Avt=M(()=>{});function xY(e){return e*e*e}function bY(e){return--e*e*e+1}function xs(e){return((e*=2)<=1?e*e*e:(e-=2)*e*e+2)/2}var Pvt=M(()=>{});var wY,SY,MY,LL,Ivt=M(()=>{wY=3,SY=function e(t){t=+t;function r(n){return Math.pow(n,t)}return r.exponent=e,r}(wY),MY=function e(t){t=+t;function r(n){return 1-Math.pow(1-n,t)}return r.exponent=e,r}(wY),LL=function e(t){t=+t;function r(n){return((n*=2)<=1?Math.pow(n,t):2-Math.pow(2-n,t))/2}return r.exponent=e,r}(wY)});function EY(e){return+e==1?1:1-Math.cos(e*kvt)}function TY(e){return Math.sin(e*kvt)}function kL(e){return(1-Math.cos(Lvt*e))/2}var Lvt,kvt,Rvt=M(()=>{Lvt=Math.PI,kvt=Lvt/2});function Dh(e){return(Math.pow(2,-10*e)-.0009765625)*1.0009775171065494}var CY=M(()=>{});function AY(e){return Dh(1-+e)}function PY(e){return 1-Dh(e)}function RL(e){return((e*=2)<=1?Dh(1-e):2-Dh(e-1))/2}var Nvt=M(()=>{CY()});function IY(e){return 1-Math.sqrt(1-e*e)}function LY(e){return Math.sqrt(1- --e*e)}function NL(e){return((e*=2)<=1?1-Math.sqrt(1-e*e):Math.sqrt(1-(e-=2)*e)+1)/2}var Dvt=M(()=>{});function RY(e){return 1-P_(1-e)}function P_(e){return(e=+e)<kY?DL*e*e:e<uSe?DL*(e-=cSe)*e+hSe:e<pSe?DL*(e-=fSe)*e+dSe:DL*(e-=mSe)*e+gSe}function NY(e){return((e*=2)<=1?1-P_(1-e):P_(e-1)+1)/2}var kY,cSe,uSe,hSe,fSe,pSe,dSe,mSe,gSe,DL,Ovt=M(()=>{kY=.36363636363636365,cSe=6/11,uSe=8/11,hSe=3/4,fSe=9/11,pSe=10/11,dSe=15/16,mSe=21/22,gSe=63/64,DL=1/kY/kY});var DY,OY,zY,OL,zvt=M(()=>{DY=1.70158,OY=function e(t){t=+t;function r(n){return(n=+n)*n*(t*(n-1)+n)}return r.overshoot=e,r}(DY),zY=function e(t){t=+t;function r(n){return--n*n*((n+1)*t+n)+1}return r.overshoot=e,r}(DY),OL=function e(t){t=+t;function r(n){return((n*=2)<1?n*n*((t+1)*n-t):(n-=2)*n*((t+1)*n+t)+2)/2}return r.overshoot=e,r}(DY)});var Sb,FY,BY,HY,zL,VY,Fvt=M(()=>{CY();Sb=2*Math.PI,FY=1,BY=.3,HY=function e(t,r){var n=Math.asin(1/(t=Math.max(1,t)))*(r/=Sb);function i(o){return t*Dh(- --o)*Math.sin((n-o)/r)}return i.amplitude=function(o){return e(o,r*Sb)},i.period=function(o){return e(t,o)},i}(FY,BY),zL=function e(t,r){var n=Math.asin(1/(t=Math.max(1,t)))*(r/=Sb);function i(o){return 1-t*Dh(o=+o)*Math.sin((o+n)/r)}return i.amplitude=function(o){return e(o,r*Sb)},i.period=function(o){return e(t,o)},i}(FY,BY),VY=function e(t,r){var n=Math.asin(1/(t=Math.max(1,t)))*(r/=Sb);function i(o){return((o=o*2-1)<0?t*Dh(-o)*Math.sin((n-o)/r):2-t*Dh(o)*Math.sin((n+o)/r))/2}return i.amplitude=function(o){return e(o,r*Sb)},i.period=function(o){return e(t,o)},i}(FY,BY)});var Bvt={};Ks(Bvt,{easeBack:()=>OL,easeBackIn:()=>OY,easeBackInOut:()=>OL,easeBackOut:()=>zY,easeBounce:()=>P_,easeBounceIn:()=>RY,easeBounceInOut:()=>NY,easeBounceOut:()=>P_,easeCircle:()=>NL,easeCircleIn:()=>IY,easeCircleInOut:()=>NL,easeCircleOut:()=>LY,easeCubic:()=>xs,easeCubicIn:()=>xY,easeCubicInOut:()=>xs,easeCubicOut:()=>bY,easeElastic:()=>zL,easeElasticIn:()=>HY,easeElasticInOut:()=>VY,easeElasticOut:()=>zL,easeExp:()=>RL,easeExpIn:()=>AY,easeExpInOut:()=>RL,easeExpOut:()=>PY,easeLinear:()=>_Y,easePoly:()=>LL,easePolyIn:()=>SY,easePolyInOut:()=>LL,easePolyOut:()=>MY,easeQuad:()=>IL,easeQuadIn:()=>yY,easeQuadInOut:()=>IL,easeQuadOut:()=>vY,easeSin:()=>kL,easeSinIn:()=>EY,easeSinInOut:()=>kL,easeSinOut:()=>TY});var I_=M(()=>{Cvt();Avt();Pvt();Ivt();Rvt();Nvt();Dvt();Ovt();zvt();Fvt()});function YL(){}function Qvt(e,t){var r=new YL;if(e instanceof YL)e.each(function(s,l){r.set(l,s)});else if(Array.isArray(e)){var n=-1,i=e.length,o;if(t==null)for(;++n<i;)r.set(n,e[n]);else for(;++n<i;)r.set(t(o=e[n],n,e),o)}else if(e)for(var a in e)r.set(a,e[a]);return r}var el,Ji,jL=M(()=>{el="$";YL.prototype=Qvt.prototype={constructor:YL,has:function(e){return el+e in this},get:function(e){return this[el+e]},set:function(e,t){return this[el+e]=t,this},remove:function(e){var t=el+e;return t in this&&delete this[t]},clear:function(){for(var e in this)e[0]===el&&delete this[e]},keys:function(){var e=[];for(var t in this)t[0]===el&&e.push(t.slice(1));return e},values:function(){var e=[];for(var t in this)t[0]===el&&e.push(this[t]);return e},entries:function(){var e=[];for(var t in this)t[0]===el&&e.push({key:t.slice(1),value:this[t]});return e},size:function(){var e=0;for(var t in this)t[0]===el&&++e;return e},empty:function(){for(var e in this)if(e[0]===el)return!1;return!0},each:function(e){for(var t in this)t[0]===el&&e(this[t],t.slice(1),this)}};Ji=Qvt});function r1t(){var e=[],t=[],r,n,i;function o(s,l,c,u){if(l>=e.length)return r!=null&&s.sort(r),n!=null?n(s):s;for(var h=-1,f=s.length,p=e[l++],d,g,_=Ji(),y,x=c();++h<f;)(y=_.get(d=p(g=s[h])+""))?y.push(g):_.set(d,[g]);return _.each(function(b,S){u(x,S,o(b,l,c,u))}),x}function a(s,l){if(++l>e.length)return s;var c,u=t[l-1];return n!=null&&l>=e.length?c=s.entries():(c=[],s.each(function(h,f){c.push({key:f,values:a(h,l)})})),u!=null?c.sort(function(h,f){return u(h.key,f.key)}):c}return i={object:function(s){return o(s,0,NSe,DSe)},map:function(s){return o(s,0,t1t,e1t)},entries:function(s){return a(o(s,0,t1t,e1t),0)},key:function(s){return e.push(s),i},sortKeys:function(s){return t[e.length-1]=s,i},sortValues:function(s){return r=s,i},rollup:function(s){return n=s,i}}}function NSe(){return{}}function DSe(e,t,r){e[t]=r}function t1t(){return Ji()}function e1t(e,t,r){e.set(t,r)}var n1t=M(()=>{jL()});function XL(){}function i1t(e,t){var r=new XL;if(e instanceof XL)e.each(function(o){r.add(o)});else if(e){var n=-1,i=e.length;if(t==null)for(;++n<i;)r.add(e[n]);else for(;++n<i;)r.add(t(e[n],n,e))}return r}var k_,o1t,a1t=M(()=>{jL();k_=Ji.prototype;XL.prototype=i1t.prototype={constructor:XL,has:k_.has,add:function(e){return e+="",this[el+e]=e,this},remove:k_.remove,clear:k_.clear,values:k_.keys,size:k_.size,empty:k_.empty,each:k_.each};o1t=i1t});function $L(e){var t=[];for(var r in e)t.push(r);return t}var s1t=M(()=>{});function l1t(e){var t=[];for(var r in e)t.push(e[r]);return t}var c1t=M(()=>{});function u1t(e){var t=[];for(var r in e)t.push({key:r,value:e[r]});return t}var h1t=M(()=>{});var Tb=M(()=>{n1t();a1t();jL();s1t();c1t();h1t()});function v1t(e){return new Function("d","return {"+e.map(function(t,r){return JSON.stringify(t)+": d["+r+'] || ""'}).join(",")+"}")}function GSe(e,t){var r=v1t(e);return function(n,i){return t(r(n),i,e)}}function y1t(e){var t=Object.create(null),r=[];return e.forEach(function(n){for(var i in n)i in t||r.push(t[i]=i)}),r}function ws(e,t){var r=e+"",n=r.length;return n<t?new Array(t-n+1).join(0)+r:r}function WSe(e){return e<0?"-"+ws(-e,6):e>9999?"+"+ws(e,6):ws(e,4)}function YSe(e){var t=e.getUTCHours(),r=e.getUTCMinutes(),n=e.getUTCSeconds(),i=e.getUTCMilliseconds();return isNaN(e)?"Invalid Date":WSe(e.getUTCFullYear(),4)+"-"+ws(e.getUTCMonth()+1,2)+"-"+ws(e.getUTCDate(),2)+(i?"T"+ws(t,2)+":"+ws(r,2)+":"+ws(n,2)+"."+ws(i,3)+"Z":n?"T"+ws(t,2)+":"+ws(r,2)+":"+ws(n,2)+"Z":r||t?"T"+ws(t,2)+":"+ws(r,2)+"Z":"")}function Wm(e){var t=new RegExp('["'+e+`
\r]`),r=e.charCodeAt(0);function n(h,f){var p,d,g=i(h,function(_,y){if(p)return p(_,y-1);d=_,p=f?GSe(_,f):v1t(_)});return g.columns=d||[],g}function i(h,f){var p=[],d=h.length,g=0,_=0,y,x=d<=0,b=!1;h.charCodeAt(d-1)===UE&&--d,h.charCodeAt(d-1)===nj&&--d;function S(){if(x)return ej;if(b)return b=!1,_1t;var P,k=g,O;if(h.charCodeAt(k)===rj){for(;g++<d&&h.charCodeAt(g)!==rj||h.charCodeAt(++g)===rj;);return(P=g)>=d?x=!0:(O=h.charCodeAt(g++))===UE?b=!0:O===nj&&(b=!0,h.charCodeAt(g)===UE&&++g),h.slice(k+1,P-1).replace(/""/g,'"')}for(;g<d;){if((O=h.charCodeAt(P=g++))===UE)b=!0;else if(O===nj)b=!0,h.charCodeAt(g)===UE&&++g;else if(O!==r)continue;return h.slice(k,P)}return x=!0,h.slice(k,d)}for(;(y=S())!==ej;){for(var C=[];y!==_1t&&y!==ej;)C.push(y),y=S();f&&(C=f(C,_++))==null||p.push(C)}return p}function o(h,f){return h.map(function(p){return f.map(function(d){return u(p[d])}).join(e)})}function a(h,f){return f==null&&(f=y1t(h)),[f.map(u).join(e)].concat(o(h,f)).join(`
`)}function s(h,f){return f==null&&(f=y1t(h)),o(h,f).join(`
`)}function l(h){return h.map(c).join(`
`)}function c(h){return h.map(u).join(e)}function u(h){return h==null?"":h instanceof Date?YSe(h):t.test(h+="")?'"'+h.replace(/"/g,'""')+'"':h}return{parse:n,parseRows:i,format:a,formatBody:s,formatRows:l,formatRow:c,formatValue:u}}var _1t,ej,rj,UE,nj,tk=M(()=>{_1t={},ej={},rj=34,UE=10,nj=13});var R_,Cb,x1t,b1t,w1t,S1t,M1t,E1t,T1t=M(()=>{tk();R_=Wm(","),Cb=R_.parse,x1t=R_.parseRows,b1t=R_.format,w1t=R_.formatBody,S1t=R_.formatRows,M1t=R_.formatRow,E1t=R_.formatValue});var N_,Ab,C1t,A1t,P1t,I1t,L1t,k1t,R1t=M(()=>{tk();N_=Wm("	"),Ab=N_.parse,C1t=N_.parseRows,A1t=N_.format,P1t=N_.formatBody,I1t=N_.formatRows,L1t=N_.formatRow,k1t=N_.formatValue});function ij(e){for(var t in e){var r=e[t].trim(),n,i;if(!r)r=null;else if(r==="true")r=!0;else if(r==="false")r=!1;else if(r==="NaN")r=NaN;else if(!isNaN(n=+r))r=n;else if(i=r.match(/^([-+]\d{2})?\d{4}(-\d{2}(-\d{2})?)?(T\d{2}:\d{2}(:\d{2}(\.\d{3})?)?(Z|[-+]\d{2}:\d{2})?)?$/))jSe&&!!i[4]&&!i[7]&&(r=r.replace(/-/g,"/").replace(/T/," ")),r=new Date(r);else continue;e[t]=r}return e}var jSe,N1t=M(()=>{jSe=new Date("2019-01-01T00:00").getHours()||new Date("2019-07-01T00:00").getHours()});var qE=M(()=>{tk();T1t();R1t();N1t()});var pe={};Ks(pe,{__assign:()=>y5e,__asyncDelegator:()=>A5e,__asyncGenerator:()=>C5e,__asyncValues:()=>P5e,__await:()=>U5,__awaiter:()=>S5e,__decorate:()=>x5e,__exportStar:()=>E5e,__extends:()=>_5e,__generator:()=>M5e,__makeTemplateObject:()=>I5e,__metadata:()=>w5e,__param:()=>b5e,__read:()=>nMt,__rest:()=>v5e,__spread:()=>T5e,__values:()=>y$});function _5e(e,t){g5e(e,t);function r(){this.constructor=e}e.prototype=t===null?Object.create(t):(r.prototype=t.prototype,new r)}function v5e(e,t){var r={};for(var n in e)Object.prototype.hasOwnProperty.call(e,n)&&t.indexOf(n)<0&&(r[n]=e[n]);if(e!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,n=Object.getOwnPropertySymbols(e);i<n.length;i++)t.indexOf(n[i])<0&&(r[n[i]]=e[n[i]]);return r}function x5e(e,t,r,n){var i=arguments.length,o=i<3?t:n===null?n=Object.getOwnPropertyDescriptor(t,r):n,a;if(typeof Reflect=="object"&&typeof Reflect.decorate=="function")o=Reflect.decorate(e,t,r,n);else for(var s=e.length-1;s>=0;s--)(a=e[s])&&(o=(i<3?a(o):i>3?a(t,r,o):a(t,r))||o);return i>3&&o&&Object.defineProperty(t,r,o),o}function b5e(e,t){return function(r,n){t(r,n,e)}}function w5e(e,t){if(typeof Reflect=="object"&&typeof Reflect.metadata=="function")return Reflect.metadata(e,t)}function S5e(e,t,r,n){return new(r||(r=Promise))(function(i,o){function a(c){try{l(n.next(c))}catch(u){o(u)}}function s(c){try{l(n.throw(c))}catch(u){o(u)}}function l(c){c.done?i(c.value):new r(function(u){u(c.value)}).then(a,s)}l((n=n.apply(e,t||[])).next())})}function M5e(e,t){var r={label:0,sent:function(){if(o[0]&1)throw o[1];return o[1]},trys:[],ops:[]},n,i,o,a;return a={next:s(0),throw:s(1),return:s(2)},typeof Symbol=="function"&&(a[Symbol.iterator]=function(){return this}),a;function s(c){return function(u){return l([c,u])}}function l(c){if(n)throw new TypeError("Generator is already executing.");for(;r;)try{if(n=1,i&&(o=i[c[0]&2?"return":c[0]?"throw":"next"])&&!(o=o.call(i,c[1])).done)return o;switch(i=0,o&&(c=[0,o.value]),c[0]){case 0:case 1:o=c;break;case 4:return r.label++,{value:c[1],done:!1};case 5:r.label++,i=c[1],c=[0];continue;case 7:c=r.ops.pop(),r.trys.pop();continue;default:if(o=r.trys,!(o=o.length>0&&o[o.length-1])&&(c[0]===6||c[0]===2)){r=0;continue}if(c[0]===3&&(!o||c[1]>o[0]&&c[1]<o[3])){r.label=c[1];break}if(c[0]===6&&r.label<o[1]){r.label=o[1],o=c;break}if(o&&r.label<o[2]){r.label=o[2],r.ops.push(c);break}o[2]&&r.ops.pop(),r.trys.pop();continue}c=t.call(e,r)}catch(u){c=[6,u],i=0}finally{n=o=0}if(c[0]&5)throw c[1];return{value:c[0]?c[1]:void 0,done:!0}}}function E5e(e,t){for(var r in e)t.hasOwnProperty(r)||(t[r]=e[r])}function y$(e){var t=typeof Symbol=="function"&&e[Symbol.iterator],r=0;return t?t.call(e):{next:function(){return e&&r>=e.length&&(e=void 0),{value:e&&e[r++],done:!e}}}}function nMt(e,t){var r=typeof Symbol=="function"&&e[Symbol.iterator];if(!r)return e;var n=r.call(e),i,o=[],a;try{for(;(t===void 0||t-- >0)&&!(i=n.next()).done;)o.push(i.value)}catch(s){a={error:s}}finally{try{i&&!i.done&&(r=n.return)&&r.call(n)}finally{if(a)throw a.error}}return o}function T5e(){for(var e=[],t=0;t<arguments.length;t++)e=e.concat(nMt(arguments[t]));return e}function U5(e){return this instanceof U5?(this.v=e,this):new U5(e)}function C5e(e,t,r){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var n=r.apply(e,t||[]),i,o=[];return i={},a("next"),a("throw"),a("return"),i[Symbol.asyncIterator]=function(){return this},i;function a(f){n[f]&&(i[f]=function(p){return new Promise(function(d,g){o.push([f,p,d,g])>1||s(f,p)})})}function s(f,p){try{l(n[f](p))}catch(d){h(o[0][3],d)}}function l(f){f.value instanceof U5?Promise.resolve(f.value.v).then(c,u):h(o[0][2],f)}function c(f){s("next",f)}function u(f){s("throw",f)}function h(f,p){f(p),o.shift(),o.length&&s(o[0][0],o[0][1])}}function A5e(e){var t,r;return t={},n("next"),n("throw",function(i){throw i}),n("return"),t[Symbol.iterator]=function(){return this},t;function n(i,o){e[i]&&(t[i]=function(a){return(r=!r)?{value:U5(e[i](a)),done:i==="return"}:o?o(a):a})}}function P5e(e){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var t=e[Symbol.asyncIterator];return t?t.call(e):typeof y$=="function"?y$(e):e[Symbol.iterator]()}function I5e(e,t){return Object.defineProperty?Object.defineProperty(e,"raw",{value:t}):e.raw=t,e}var g5e,y5e,de=M(()=>{g5e=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var r in t)t.hasOwnProperty(r)&&(e[r]=t[r])};y5e=Object.assign||function(t){for(var r,n=1,i=arguments.length;n<i;n++){r=arguments[n];for(var o in r)Object.prototype.hasOwnProperty.call(r,o)&&(t[o]=r[o])}return t}});var iMt,oMt=M(()=>{iMt="4.13.0"});function _c(e,t){return e<t?-1:e>t?1:e>=t?0:NaN}var py=M(()=>{});function aR(e){return e.length===1&&(e=L5e(e)),{left:function(t,r,n,i){for(n==null&&(n=0),i==null&&(i=t.length);n<i;){var o=n+i>>>1;e(t[o],r)<0?n=o+1:i=o}return n},right:function(t,r,n,i){for(n==null&&(n=0),i==null&&(i=t.length);n<i;){var o=n+i>>>1;e(t[o],r)>0?i=o:n=o+1}return n}}}function L5e(e){return function(t,r){return _c(e(t),r)}}var v$=M(()=>{py()});var aMt,x$,sMt,sR,b$=M(()=>{py();v$();aMt=aR(_c),x$=aMt.right,sMt=aMt.left,sR=x$});function lMt(e,t){t==null&&(t=w$);for(var r=0,n=e.length-1,i=e[0],o=new Array(n<0?0:n);r<n;)o[r]=t(i,i=e[++r]);return o}function w$(e,t){return[e,t]}var S$=M(()=>{});function cMt(e,t,r){var n=e.length,i=t.length,o=new Array(n*i),a,s,l,c;for(r==null&&(r=w$),a=l=0;a<n;++a)for(c=e[a],s=0;s<i;++s,++l)o[l]=r(c,t[s]);return o}var uMt=M(()=>{S$()});function hMt(e,t){return t<e?-1:t>e?1:t>=e?0:NaN}var fMt=M(()=>{});function al(e){return e===null?NaN:+e}var l2=M(()=>{});function lR(e,t){var r=e.length,n=0,i=-1,o=0,a,s,l=0;if(t==null)for(;++i<r;)isNaN(a=al(e[i]))||(s=a-o,o+=s/++n,l+=s*(a-o));else for(;++i<r;)isNaN(a=al(t(e[i],i,e)))||(s=a-o,o+=s/++n,l+=s*(a-o));if(n>1)return l/(n-1)}var M$=M(()=>{l2()});function cR(e,t){var r=lR(e,t);return r&&Math.sqrt(r)}var E$=M(()=>{M$()});function uR(e,t){var r=e.length,n=-1,i,o,a;if(t==null){for(;++n<r;)if((i=e[n])!=null&&i>=i)for(o=a=i;++n<r;)(i=e[n])!=null&&(o>i&&(o=i),a<i&&(a=i))}else for(;++n<r;)if((i=t(e[n],n,e))!=null&&i>=i)for(o=a=i;++n<r;)(i=t(e[n],n,e))!=null&&(o>i&&(o=i),a<i&&(a=i));return[o,a]}var T$=M(()=>{});var pMt,dMt,mMt,C$=M(()=>{pMt=Array.prototype,dMt=pMt.slice,mMt=pMt.map});function q5(e){return function(){return e}}var gMt=M(()=>{});function _Mt(e){return e}var yMt=M(()=>{});function hR(e,t,r){e=+e,t=+t,r=(i=arguments.length)<2?(t=e,e=0,1):i<3?1:+r;for(var n=-1,i=Math.max(0,Math.ceil((t-e)/r))|0,o=new Array(i);++n<i;)o[n]=e+n*r;return o}var A$=M(()=>{});function vMt(e,t,r){var n,i=-1,o,a,s;if(t=+t,e=+e,r=+r,e===t&&r>0)return[e];if((n=t<e)&&(o=e,e=t,t=o),(s=k$(e,t,r))===0||!isFinite(s))return[];if(s>0)for(e=Math.ceil(e/s),t=Math.floor(t/s),a=new Array(o=Math.ceil(t-e+1));++i<o;)a[i]=(e+i)*s;else for(e=Math.floor(e*s),t=Math.ceil(t*s),a=new Array(o=Math.ceil(e-t+1));++i<o;)a[i]=(e-i)/s;return n&&a.reverse(),a}function k$(e,t,r){var n=(t-e)/Math.max(0,r),i=Math.floor(Math.log(n)/Math.LN10),o=n/Math.pow(10,i);return i>=0?(o>=P$?10:o>=I$?5:o>=L$?2:1)*Math.pow(10,i):-Math.pow(10,-i)/(o>=P$?10:o>=I$?5:o>=L$?2:1)}function fR(e,t,r){var n=Math.abs(t-e)/Math.max(0,r),i=Math.pow(10,Math.floor(Math.log(n)/Math.LN10)),o=n/i;return o>=P$?i*=10:o>=I$?i*=5:o>=L$&&(i*=2),t<e?-i:i}var P$,I$,L$,R$=M(()=>{P$=Math.sqrt(50),I$=Math.sqrt(10),L$=Math.sqrt(2)});function pR(e){return Math.ceil(Math.log(e.length)/Math.LN2)+1}var N$=M(()=>{});function xMt(){var e=_Mt,t=uR,r=pR;function n(i){var o,a=i.length,s,l=new Array(a);for(o=0;o<a;++o)l[o]=e(i[o],o,i);var c=t(l),u=c[0],h=c[1],f=r(l,u,h);Array.isArray(f)||(f=fR(u,h,f),f=hR(Math.ceil(u/f)*f,Math.floor(h/f)*f,f));for(var p=f.length;f[0]<=u;)f.shift(),--p;for(;f[p-1]>h;)f.pop(),--p;var d=new Array(p+1),g;for(o=0;o<=p;++o)g=d[o]=[],g.x0=o>0?f[o-1]:u,g.x1=o<p?f[o]:h;for(o=0;o<a;++o)s=l[o],u<=s&&s<=h&&d[sR(f,s,0,p)].push(i[o]);return d}return n.value=function(i){return arguments.length?(e=typeof i=="function"?i:q5(i),n):e},n.domain=function(i){return arguments.length?(t=typeof i=="function"?i:q5([i[0],i[1]]),n):t},n.thresholds=function(i){return arguments.length?(r=typeof i=="function"?i:Array.isArray(i)?q5(dMt.call(i)):q5(i),n):r},n}var bMt=M(()=>{C$();b$();gMt();T$();yMt();A$();R$();N$()});function dy(e,t,r){if(r==null&&(r=al),!!(n=e.length)){if((t=+t)<=0||n<2)return+r(e[0],0,e);if(t>=1)return+r(e[n-1],n-1,e);var n,i=(n-1)*t,o=Math.floor(i),a=+r(e[o],o,e),s=+r(e[o+1],o+1,e);return a+(s-a)*(i-o)}}var dR=M(()=>{l2()});function wMt(e,t,r){return e=mMt.call(e,al).sort(_c),Math.ceil((r-t)/(2*(dy(e,.75)-dy(e,.25))*Math.pow(e.length,-1/3)))}var SMt=M(()=>{C$();py();l2();dR()});function MMt(e,t,r){return Math.ceil((r-t)/(3.5*cR(e)*Math.pow(e.length,-1/3)))}var EMt=M(()=>{E$()});function TMt(e,t){var r=e.length,n=-1,i,o;if(t==null){for(;++n<r;)if((i=e[n])!=null&&i>=i)for(o=i;++n<r;)(i=e[n])!=null&&i>o&&(o=i)}else for(;++n<r;)if((i=t(e[n],n,e))!=null&&i>=i)for(o=i;++n<r;)(i=t(e[n],n,e))!=null&&i>o&&(o=i);return o}var CMt=M(()=>{});function AMt(e,t){var r=e.length,n=r,i=-1,o,a=0;if(t==null)for(;++i<r;)isNaN(o=al(e[i]))?--n:a+=o;else for(;++i<r;)isNaN(o=al(t(e[i],i,e)))?--n:a+=o;if(n)return a/n}var PMt=M(()=>{l2()});function IMt(e,t){var r=e.length,n=-1,i,o=[];if(t==null)for(;++n<r;)isNaN(i=al(e[n]))||o.push(i);else for(;++n<r;)isNaN(i=al(t(e[n],n,e)))||o.push(i);return dy(o.sort(_c),.5)}var LMt=M(()=>{py();l2();dR()});function kMt(e){for(var t=e.length,r,n=-1,i=0,o,a;++n<t;)i+=e[n].length;for(o=new Array(i);--t>=0;)for(a=e[t],r=a.length;--r>=0;)o[--i]=a[r];return o}var RMt=M(()=>{});function mR(e,t){var r=e.length,n=-1,i,o;if(t==null){for(;++n<r;)if((i=e[n])!=null&&i>=i)for(o=i;++n<r;)(i=e[n])!=null&&o>i&&(o=i)}else for(;++n<r;)if((i=t(e[n],n,e))!=null&&i>=i)for(o=i;++n<r;)(i=t(e[n],n,e))!=null&&o>i&&(o=i);return o}var D$=M(()=>{});function NMt(e,t){for(var r=t.length,n=new Array(r);r--;)n[r]=e[t[r]];return n}var DMt=M(()=>{});function OMt(e,t){if(!!(r=e.length)){var r,n=0,i=0,o,a=e[i];for(t==null&&(t=_c);++n<r;)(t(o=e[n],a)<0||t(a,a)!==0)&&(a=o,i=n);if(t(a,a)===0)return i}}var zMt=M(()=>{py()});function FMt(e,t,r){for(var n=(r==null?e.length:r)-(t=t==null?0:+t),i,o;n;)o=Math.random()*n--|0,i=e[n+t],e[n+t]=e[o+t],e[o+t]=i;return e}var BMt=M(()=>{});function HMt(e,t){var r=e.length,n=-1,i,o=0;if(t==null)for(;++n<r;)(i=+e[n])&&(o+=i);else for(;++n<r;)(i=+t(e[n],n,e))&&(o+=i);return o}var VMt=M(()=>{});function gR(e){if(!(o=e.length))return[];for(var t=-1,r=mR(e,k5e),n=new Array(r);++t<r;)for(var i=-1,o,a=n[t]=new Array(o);++i<o;)a[i]=e[i][t];return n}function k5e(e){return e.length}var O$=M(()=>{D$()});function UMt(){return gR(arguments)}var qMt=M(()=>{O$()});var GMt=M(()=>{b$();py();v$();uMt();fMt();E$();T$();bMt();SMt();EMt();N$();CMt();PMt();LMt();RMt();D$();S$();DMt();dR();A$();zMt();BMt();VMt();R$();O$();M$();qMt()});var _R,WMt=M(()=>{_R=Array.prototype.slice});function YMt(e){return e}var jMt=M(()=>{});function R5e(e){return"translate("+(e+.5)+",0)"}function N5e(e){return"translate(0,"+(e+.5)+")"}function D5e(e){return function(t){return+e(t)}}function O5e(e){var t=Math.max(0,e.bandwidth()-1)/2;return e.round()&&(t=Math.round(t)),function(r){return+e(r)+t}}function z5e(){return!this.__axis}function xR(e,t){var r=[],n=null,i=null,o=6,a=6,s=3,l=e===yR||e===G5?-1:1,c=e===G5||e===vR?"x":"y",u=e===yR||e===z$?R5e:N5e;function h(f){var p=n==null?t.ticks?t.ticks.apply(t,r):t.domain():n,d=i==null?t.tickFormat?t.tickFormat.apply(t,r):YMt:i,g=Math.max(o,0)+s,_=t.range(),y=+_[0]+.5,x=+_[_.length-1]+.5,b=(t.bandwidth?O5e:D5e)(t.copy()),S=f.selection?f.selection():f,C=S.selectAll(".domain").data([null]),P=S.selectAll(".tick").data(p,t).order(),k=P.exit(),O=P.enter().append("g").attr("class","tick"),D=P.select("line"),B=P.select("text");C=C.merge(C.enter().insert("path",".tick").attr("class","domain").attr("stroke","#000")),P=P.merge(O),D=D.merge(O.append("line").attr("stroke","#000").attr(c+"2",l*o)),B=B.merge(O.append("text").attr("fill","#000").attr(c,l*g).attr("dy",e===yR?"0em":e===z$?"0.71em":"0.32em")),f!==S&&(C=C.transition(f),P=P.transition(f),D=D.transition(f),B=B.transition(f),k=k.transition(f).attr("opacity",XMt).attr("transform",function(I){return isFinite(I=b(I))?u(I):this.getAttribute("transform")}),O.attr("opacity",XMt).attr("transform",function(I){var L=this.parentNode.__axis;return u(L&&isFinite(L=L(I))?L:b(I))})),k.remove(),C.attr("d",e===G5||e==vR?"M"+l*a+","+y+"H0.5V"+x+"H"+l*a:"M"+y+","+l*a+"V0.5H"+x+"V"+l*a),P.attr("opacity",1).attr("transform",function(I){return u(b(I))}),D.attr(c+"2",l*o),B.attr(c,l*g).text(d),S.filter(z5e).attr("fill","none").attr("font-size",10).attr("font-family","sans-serif").attr("text-anchor",e===vR?"start":e===G5?"end":"middle"),S.each(function(){this.__axis=b})}return h.scale=function(f){return arguments.length?(t=f,h):t},h.ticks=function(){return r=_R.call(arguments),h},h.tickArguments=function(f){return arguments.length?(r=f==null?[]:_R.call(f),h):r.slice()},h.tickValues=function(f){return arguments.length?(n=f==null?null:_R.call(f),h):n&&n.slice()},h.tickFormat=function(f){return arguments.length?(i=f,h):i},h.tickSize=function(f){return arguments.length?(o=a=+f,h):o},h.tickSizeInner=function(f){return arguments.length?(o=+f,h):o},h.tickSizeOuter=function(f){return arguments.length?(a=+f,h):a},h.tickPadding=function(f){return arguments.length?(s=+f,h):s},h}function $Mt(e){return xR(yR,e)}function KMt(e){return xR(vR,e)}function ZMt(e){return xR(z$,e)}function JMt(e){return xR(G5,e)}var yR,vR,z$,G5,XMt,QMt=M(()=>{WMt();jMt();yR=1,vR=2,z$=3,G5=4,XMt=1e-6});var tEt=M(()=>{QMt()});function rEt(){for(var e=0,t=arguments.length,r={},n;e<t;++e){if(!(n=arguments[e]+"")||n in r||/[\s.]/.test(n))throw new Error("illegal type: "+n);r[n]=[]}return new bR(r)}function bR(e){this._=e}function B5e(e,t){return e.trim().split(/^|\s+/).map(function(r){var n="",i=r.indexOf(".");if(i>=0&&(n=r.slice(i+1),r=r.slice(0,i)),r&&!t.hasOwnProperty(r))throw new Error("unknown type: "+r);return{type:r,name:n}})}function H5e(e,t){for(var r=0,n=e.length,i;r<n;++r)if((i=e[r]).name===t)return i.value}function eEt(e,t,r){for(var n=0,i=e.length;n<i;++n)if(e[n].name===t){e[n]=F5e,e=e.slice(0,n).concat(e.slice(n+1));break}return r!=null&&e.push({name:t,value:r}),e}var F5e,W5,nEt=M(()=>{F5e={value:function(){}};bR.prototype=rEt.prototype={constructor:bR,on:function(e,t){var r=this._,n=B5e(e+"",r),i,o=-1,a=n.length;if(arguments.length<2){for(;++o<a;)if((i=(e=n[o]).type)&&(i=H5e(r[i],e.name)))return i;return}if(t!=null&&typeof t!="function")throw new Error("invalid callback: "+t);for(;++o<a;)if(i=(e=n[o]).type)r[i]=eEt(r[i],e.name,t);else if(t==null)for(i in r)r[i]=eEt(r[i],e.name,null);return this},copy:function(){var e={},t=this._;for(var r in t)e[r]=t[r].slice();return new bR(e)},call:function(e,t){if((i=arguments.length-2)>0)for(var r=new Array(i),n=0,i,o;n<i;++n)r[n]=arguments[n+2];if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(o=this._[e],n=0,i=o.length;n<i;++n)o[n].value.apply(t,r)},apply:function(e,t,r){if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(var n=this._[e],i=0,o=n.length;i<o;++i)n[i].value.apply(t,r)}};W5=rEt});var F$=M(()=>{nEt()});var wR,B$,H$=M(()=>{wR="http://www.w3.org/1999/xhtml",B$={svg:"http://www.w3.org/2000/svg",xhtml:wR,xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/"}});function Vp(e){var t=e+="",r=t.indexOf(":");return r>=0&&(t=e.slice(0,r))!=="xmlns"&&(e=e.slice(r+1)),B$.hasOwnProperty(t)?{space:B$[t],local:e}:e}var SR=M(()=>{H$()});function V5e(e){return function(){var t=this.ownerDocument,r=this.namespaceURI;return r===wR&&t.documentElement.namespaceURI===wR?t.createElement(e):t.createElementNS(r,e)}}function U5e(e){return function(){return this.ownerDocument.createElementNS(e.space,e.local)}}function MR(e){var t=Vp(e);return(t.local?U5e:V5e)(t)}var V$=M(()=>{SR();H$()});function q5e(){}function my(e){return e==null?q5e:function(){return this.querySelector(e)}}var ER=M(()=>{});function iEt(e){typeof e!="function"&&(e=my(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=new Array(a),l,c,u=0;u<a;++u)(l=o[u])&&(c=e.call(l,l.__data__,u,o))&&("__data__"in l&&(c.__data__=l.__data__),s[u]=c);return new fi(n,this._parents)}var oEt=M(()=>{wu();ER()});function G5e(){return[]}function Y5(e){return e==null?G5e:function(){return this.querySelectorAll(e)}}var U$=M(()=>{});function aEt(e){typeof e!="function"&&(e=Y5(e));for(var t=this._groups,r=t.length,n=[],i=[],o=0;o<r;++o)for(var a=t[o],s=a.length,l,c=0;c<s;++c)(l=a[c])&&(n.push(e.call(l,l.__data__,c,a)),i.push(l));return new fi(n,i)}var sEt=M(()=>{wu();U$()});function j5(e){return function(){return this.matches(e)}}var q$=M(()=>{});function lEt(e){typeof e!="function"&&(e=j5(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=[],l,c=0;c<a;++c)(l=o[c])&&e.call(l,l.__data__,c,o)&&s.push(l);return new fi(n,this._parents)}var cEt=M(()=>{wu();q$()});function TR(e){return new Array(e.length)}var G$=M(()=>{});function uEt(){return new fi(this._enter||this._groups.map(TR),this._parents)}function X5(e,t){this.ownerDocument=e.ownerDocument,this.namespaceURI=e.namespaceURI,this._next=null,this._parent=e,this.__data__=t}var W$=M(()=>{G$();wu();X5.prototype={constructor:X5,appendChild:function(e){return this._parent.insertBefore(e,this._next)},insertBefore:function(e,t){return this._parent.insertBefore(e,t)},querySelector:function(e){return this._parent.querySelector(e)},querySelectorAll:function(e){return this._parent.querySelectorAll(e)}}});function hEt(e){return function(){return e}}var fEt=M(()=>{});function W5e(e,t,r,n,i,o){for(var a=0,s,l=t.length,c=o.length;a<c;++a)(s=t[a])?(s.__data__=o[a],n[a]=s):r[a]=new X5(e,o[a]);for(;a<l;++a)(s=t[a])&&(i[a]=s)}function Y5e(e,t,r,n,i,o,a){var s,l,c={},u=t.length,h=o.length,f=new Array(u),p;for(s=0;s<u;++s)(l=t[s])&&(f[s]=p=pEt+a.call(l,l.__data__,s,t),p in c?i[s]=l:c[p]=l);for(s=0;s<h;++s)p=pEt+a.call(e,o[s],s,o),(l=c[p])?(n[s]=l,l.__data__=o[s],c[p]=null):r[s]=new X5(e,o[s]);for(s=0;s<u;++s)(l=t[s])&&c[f[s]]===l&&(i[s]=l)}function dEt(e,t){if(!e)return p=new Array(this.size()),c=-1,this.each(function(P){p[++c]=P}),p;var r=t?Y5e:W5e,n=this._parents,i=this._groups;typeof e!="function"&&(e=hEt(e));for(var o=i.length,a=new Array(o),s=new Array(o),l=new Array(o),c=0;c<o;++c){var u=n[c],h=i[c],f=h.length,p=e.call(u,u&&u.__data__,c,n),d=p.length,g=s[c]=new Array(d),_=a[c]=new Array(d),y=l[c]=new Array(f);r(u,h,g,_,y,p,t);for(var x=0,b=0,S,C;x<d;++x)if(S=g[x]){for(x>=b&&(b=x+1);!(C=_[b])&&++b<d;);S._next=C||null}}return a=new fi(a,n),a._enter=s,a._exit=l,a}var pEt,mEt=M(()=>{wu();W$();fEt();pEt="$"});function gEt(){return new fi(this._exit||this._groups.map(TR),this._parents)}var _Et=M(()=>{G$();wu()});function yEt(e,t,r){var n=this.enter(),i=this,o=this.exit();return n=typeof e=="function"?e(n):n.append(e+""),t!=null&&(i=t(i)),r==null?o.remove():r(o),n&&i?n.merge(i).order():i}var vEt=M(()=>{});function xEt(e){for(var t=this._groups,r=e._groups,n=t.length,i=r.length,o=Math.min(n,i),a=new Array(n),s=0;s<o;++s)for(var l=t[s],c=r[s],u=l.length,h=a[s]=new Array(u),f,p=0;p<u;++p)(f=l[p]||c[p])&&(h[p]=f);for(;s<n;++s)a[s]=t[s];return new fi(a,this._parents)}var bEt=M(()=>{wu()});function wEt(){for(var e=this._groups,t=-1,r=e.length;++t<r;)for(var n=e[t],i=n.length-1,o=n[i],a;--i>=0;)(a=n[i])&&(o&&a.compareDocumentPosition(o)^4&&o.parentNode.insertBefore(a,o),o=a);return this}var SEt=M(()=>{});function MEt(e){e||(e=j5e);function t(h,f){return h&&f?e(h.__data__,f.__data__):!h-!f}for(var r=this._groups,n=r.length,i=new Array(n),o=0;o<n;++o){for(var a=r[o],s=a.length,l=i[o]=new Array(s),c,u=0;u<s;++u)(c=a[u])&&(l[u]=c);l.sort(t)}return new fi(i,this._parents).order()}function j5e(e,t){return e<t?-1:e>t?1:e>=t?0:NaN}var EEt=M(()=>{wu()});function TEt(){var e=arguments[0];return arguments[0]=this,e.apply(null,arguments),this}var CEt=M(()=>{});function AEt(){var e=new Array(this.size()),t=-1;return this.each(function(){e[++t]=this}),e}var PEt=M(()=>{});function IEt(){for(var e=this._groups,t=0,r=e.length;t<r;++t)for(var n=e[t],i=0,o=n.length;i<o;++i){var a=n[i];if(a)return a}return null}var LEt=M(()=>{});function kEt(){var e=0;return this.each(function(){++e}),e}var REt=M(()=>{});function NEt(){return!this.node()}var DEt=M(()=>{});function OEt(e){for(var t=this._groups,r=0,n=t.length;r<n;++r)for(var i=t[r],o=0,a=i.length,s;o<a;++o)(s=i[o])&&e.call(s,s.__data__,o,i);return this}var zEt=M(()=>{});function X5e(e){return function(){this.removeAttribute(e)}}function $5e(e){return function(){this.removeAttributeNS(e.space,e.local)}}function K5e(e,t){return function(){this.setAttribute(e,t)}}function Z5e(e,t){return function(){this.setAttributeNS(e.space,e.local,t)}}function J5e(e,t){return function(){var r=t.apply(this,arguments);r==null?this.removeAttribute(e):this.setAttribute(e,r)}}function Q5e(e,t){return function(){var r=t.apply(this,arguments);r==null?this.removeAttributeNS(e.space,e.local):this.setAttributeNS(e.space,e.local,r)}}function FEt(e,t){var r=Vp(e);if(arguments.length<2){var n=this.node();return r.local?n.getAttributeNS(r.space,r.local):n.getAttribute(r)}return this.each((t==null?r.local?$5e:X5e:typeof t=="function"?r.local?Q5e:J5e:r.local?Z5e:K5e)(r,t))}var BEt=M(()=>{SR()});function CR(e){return e.ownerDocument&&e.ownerDocument.defaultView||e.document&&e||e.defaultView}var Y$=M(()=>{});function tTe(e){return function(){this.style.removeProperty(e)}}function eTe(e,t,r){return function(){this.style.setProperty(e,t,r)}}function rTe(e,t,r){return function(){var n=t.apply(this,arguments);n==null?this.style.removeProperty(e):this.style.setProperty(e,n,r)}}function HEt(e,t,r){return arguments.length>1?this.each((t==null?tTe:typeof t=="function"?rTe:eTe)(e,t,r==null?"":r)):ag(this.node(),e)}function ag(e,t){return e.style.getPropertyValue(t)||CR(e).getComputedStyle(e,null).getPropertyValue(t)}var j$=M(()=>{Y$()});function nTe(e){return function(){delete this[e]}}function iTe(e,t){return function(){this[e]=t}}function oTe(e,t){return function(){var r=t.apply(this,arguments);r==null?delete this[e]:this[e]=r}}function VEt(e,t){return arguments.length>1?this.each((t==null?nTe:typeof t=="function"?oTe:iTe)(e,t)):this.node()[e]}var UEt=M(()=>{});function qEt(e){return e.trim().split(/^|\s+/)}function X$(e){return e.classList||new GEt(e)}function GEt(e){this._node=e,this._names=qEt(e.getAttribute("class")||"")}function WEt(e,t){for(var r=X$(e),n=-1,i=t.length;++n<i;)r.add(t[n])}function YEt(e,t){for(var r=X$(e),n=-1,i=t.length;++n<i;)r.remove(t[n])}function aTe(e){return function(){WEt(this,e)}}function sTe(e){return function(){YEt(this,e)}}function lTe(e,t){return function(){(t.apply(this,arguments)?WEt:YEt)(this,e)}}function jEt(e,t){var r=qEt(e+"");if(arguments.length<2){for(var n=X$(this.node()),i=-1,o=r.length;++i<o;)if(!n.contains(r[i]))return!1;return!0}return this.each((typeof t=="function"?lTe:t?aTe:sTe)(r,t))}var XEt=M(()=>{GEt.prototype={add:function(e){var t=this._names.indexOf(e);t<0&&(this._names.push(e),this._node.setAttribute("class",this._names.join(" ")))},remove:function(e){var t=this._names.indexOf(e);t>=0&&(this._names.splice(t,1),this._node.setAttribute("class",this._names.join(" ")))},contains:function(e){return this._names.indexOf(e)>=0}}});function cTe(){this.textContent=""}function uTe(e){return function(){this.textContent=e}}function hTe(e){return function(){var t=e.apply(this,arguments);this.textContent=t==null?"":t}}function $Et(e){return arguments.length?this.each(e==null?cTe:(typeof e=="function"?hTe:uTe)(e)):this.node().textContent}var KEt=M(()=>{});function fTe(){this.innerHTML=""}function pTe(e){return function(){this.innerHTML=e}}function dTe(e){return function(){var t=e.apply(this,arguments);this.innerHTML=t==null?"":t}}function ZEt(e){return arguments.length?this.each(e==null?fTe:(typeof e=="function"?dTe:pTe)(e)):this.node().innerHTML}var JEt=M(()=>{});function mTe(){this.nextSibling&&this.parentNode.appendChild(this)}function QEt(){return this.each(mTe)}var t5t=M(()=>{});function gTe(){this.previousSibling&&this.parentNode.insertBefore(this,this.parentNode.firstChild)}function e5t(){return this.each(gTe)}var r5t=M(()=>{});function n5t(e){var t=typeof e=="function"?e:MR(e);return this.select(function(){return this.appendChild(t.apply(this,arguments))})}var i5t=M(()=>{V$()});function _Te(){return null}function o5t(e,t){var r=typeof e=="function"?e:MR(e),n=t==null?_Te:typeof t=="function"?t:my(t);return this.select(function(){return this.insertBefore(r.apply(this,arguments),n.apply(this,arguments)||null)})}var a5t=M(()=>{V$();ER()});function yTe(){var e=this.parentNode;e&&e.removeChild(this)}function s5t(){return this.each(yTe)}var l5t=M(()=>{});function vTe(){var e=this.cloneNode(!1),t=this.parentNode;return t?t.insertBefore(e,this.nextSibling):e}function xTe(){var e=this.cloneNode(!0),t=this.parentNode;return t?t.insertBefore(e,this.nextSibling):e}function c5t(e){return this.select(e?xTe:vTe)}var u5t=M(()=>{});function h5t(e){return arguments.length?this.property("__data__",e):this.node().__data__}var f5t=M(()=>{});function bTe(e,t,r){return e=m5t(e,t,r),function(n){var i=n.relatedTarget;(!i||i!==this&&!(i.compareDocumentPosition(this)&8))&&e.call(this,n)}}function m5t(e,t,r){return function(n){var i=wr;wr=n;try{e.call(this,this.__data__,t,r)}finally{wr=i}}}function wTe(e){return e.trim().split(/^|\s+/).map(function(t){var r="",n=t.indexOf(".");return n>=0&&(r=t.slice(n+1),t=t.slice(0,n)),{type:t,name:r}})}function STe(e){return function(){var t=this.__on;if(!!t){for(var r=0,n=-1,i=t.length,o;r<i;++r)o=t[r],(!e.type||o.type===e.type)&&o.name===e.name?this.removeEventListener(o.type,o.listener,o.capture):t[++n]=o;++n?t.length=n:delete this.__on}}}function MTe(e,t,r){var n=d5t.hasOwnProperty(e.type)?bTe:m5t;return function(i,o,a){var s=this.__on,l,c=n(t,o,a);if(s){for(var u=0,h=s.length;u<h;++u)if((l=s[u]).type===e.type&&l.name===e.name){this.removeEventListener(l.type,l.listener,l.capture),this.addEventListener(l.type,l.listener=c,l.capture=r),l.value=t;return}}this.addEventListener(e.type,c,r),l={type:e.type,name:e.name,value:t,listener:c,capture:r},s?s.push(l):this.__on=[l]}}function g5t(e,t,r){var n=wTe(e+""),i,o=n.length,a;if(arguments.length<2){var s=this.node().__on;if(s){for(var l=0,c=s.length,u;l<c;++l)for(i=0,u=s[l];i<o;++i)if((a=n[i]).type===u.type&&a.name===u.name)return u.value}return}for(s=t?MTe:STe,r==null&&(r=!1),i=0;i<o;++i)this.each(s(n[i],t,r));return this}function $$(e,t,r,n){var i=wr;e.sourceEvent=wr,wr=e;try{return t.apply(r,n)}finally{wr=i}}var d5t,wr,p5t,AR=M(()=>{d5t={},wr=null;typeof document!="undefined"&&(p5t=document.documentElement,"onmouseenter"in p5t||(d5t={mouseenter:"mouseover",mouseleave:"mouseout"}))});function _5t(e,t,r){var n=CR(e),i=n.CustomEvent;typeof i=="function"?i=new i(t,r):(i=n.document.createEvent("Event"),r?(i.initEvent(t,r.bubbles,r.cancelable),i.detail=r.detail):i.initEvent(t,!1,!1)),e.dispatchEvent(i)}function ETe(e,t){return function(){return _5t(this,e,t)}}function TTe(e,t){return function(){return _5t(this,e,t.apply(this,arguments))}}function y5t(e,t){return this.each((typeof t=="function"?TTe:ETe)(e,t))}var v5t=M(()=>{Y$()});function fi(e,t){this._groups=e,this._parents=t}function x5t(){return new fi([[document.documentElement]],K$)}var K$,Up,wu=M(()=>{oEt();sEt();cEt();mEt();W$();_Et();vEt();bEt();SEt();EEt();CEt();PEt();LEt();REt();DEt();zEt();BEt();j$();UEt();XEt();KEt();JEt();t5t();r5t();i5t();a5t();l5t();u5t();f5t();AR();v5t();K$=[null];fi.prototype=x5t.prototype={constructor:fi,select:iEt,selectAll:aEt,filter:lEt,data:dEt,enter:uEt,exit:gEt,join:yEt,merge:xEt,order:wEt,sort:MEt,call:TEt,nodes:AEt,node:IEt,size:kEt,empty:NEt,each:OEt,attr:FEt,style:HEt,property:VEt,classed:jEt,text:$Et,html:ZEt,raise:QEt,lower:e5t,append:n5t,insert:o5t,remove:s5t,clone:c5t,datum:h5t,on:g5t,dispatch:y5t};Up=x5t});function qp(e){return typeof e=="string"?new fi([[document.querySelector(e)]],[document.documentElement]):new fi([[e]],K$)}var b5t=M(()=>{wu()});function w5t(){for(var e=wr,t;t=e.sourceEvent;)e=t;return e}var S5t=M(()=>{AR()});function M5t(e,t){var r=e.ownerSVGElement||e;if(r.createSVGPoint){var n=r.createSVGPoint();return n.x=t.clientX,n.y=t.clientY,n=n.matrixTransform(e.getScreenCTM().inverse()),[n.x,n.y]}var i=e.getBoundingClientRect();return[t.clientX-i.left-e.clientLeft,t.clientY-i.top-e.clientTop]}var E5t=M(()=>{});function PR(e){var t=w5t();return t.changedTouches&&(t=t.changedTouches[0]),M5t(e,t)}var T5t=M(()=>{S5t();E5t()});var Es=M(()=>{q$();T5t();SR();b5t();wu();ER();U$();j$();AR()});function IR(){wr.preventDefault(),wr.stopImmediatePropagation()}var C5t=M(()=>{Es()});function Z$(e){var t=e.document.documentElement,r=qp(e).on("dragstart.drag",IR,!0);"onselectstart"in t?r.on("selectstart.drag",IR,!0):(t.__noselect=t.style.MozUserSelect,t.style.MozUserSelect="none")}function J$(e,t){var r=e.document.documentElement,n=qp(e).on("dragstart.drag",null);t&&(n.on("click.drag",IR,!0),setTimeout(function(){n.on("click.drag",null)},0)),"onselectstart"in r?n.on("selectstart.drag",null):(r.style.MozUserSelect=r.__noselect,delete r.__noselect)}var A5t=M(()=>{Es();C5t()});var P5t=M(()=>{A5t()});function LR(e,t,r){e.prototype=t.prototype=r,r.constructor=e}function Q$(e,t){var r=Object.create(e.prototype);for(var n in t)r[n]=t[n];return r}var I5t=M(()=>{});function Z5(){}function k5t(){return this.rgb().formatHex()}function NTe(){return F5t(this).formatHsl()}function R5t(){return this.rgb().formatRgb()}function Su(e){var t,r;return e=(e+"").trim().toLowerCase(),(t=CTe.exec(e))?(r=t[1].length,t=parseInt(t[1],16),r===6?N5t(t):r===3?new sl(t>>8&15|t>>4&240,t>>4&15|t&240,(t&15)<<4|t&15,1):r===8?kR(t>>24&255,t>>16&255,t>>8&255,(t&255)/255):r===4?kR(t>>12&15|t>>8&240,t>>8&15|t>>4&240,t>>4&15|t&240,((t&15)<<4|t&15)/255):null):(t=ATe.exec(e))?new sl(t[1],t[2],t[3],1):(t=PTe.exec(e))?new sl(t[1]*255/100,t[2]*255/100,t[3]*255/100,1):(t=ITe.exec(e))?kR(t[1],t[2],t[3],t[4]):(t=LTe.exec(e))?kR(t[1]*255/100,t[2]*255/100,t[3]*255/100,t[4]):(t=kTe.exec(e))?z5t(t[1],t[2]/100,t[3]/100,1):(t=RTe.exec(e))?z5t(t[1],t[2]/100,t[3]/100,t[4]):L5t.hasOwnProperty(e)?N5t(L5t[e]):e==="transparent"?new sl(NaN,NaN,NaN,0):null}function N5t(e){return new sl(e>>16&255,e>>8&255,e&255,1)}function kR(e,t,r,n){return n<=0&&(e=t=r=NaN),new sl(e,t,r,n)}function DTe(e){return e instanceof Z5||(e=Su(e)),e?(e=e.rgb(),new sl(e.r,e.g,e.b,e.opacity)):new sl}function u2(e,t,r,n){return arguments.length===1?DTe(e):new sl(e,t,r,n==null?1:n)}function sl(e,t,r,n){this.r=+e,this.g=+t,this.b=+r,this.opacity=+n}function D5t(){return"#"+tK(this.r)+tK(this.g)+tK(this.b)}function O5t(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"rgb(":"rgba(")+Math.max(0,Math.min(255,Math.round(this.r)||0))+", "+Math.max(0,Math.min(255,Math.round(this.g)||0))+", "+Math.max(0,Math.min(255,Math.round(this.b)||0))+(e===1?")":", "+e+")")}function tK(e){return e=Math.max(0,Math.min(255,Math.round(e)||0)),(e<16?"0":"")+e.toString(16)}function z5t(e,t,r,n){return n<=0?e=t=r=NaN:r<=0||r>=1?e=t=NaN:t<=0&&(e=NaN),new Kh(e,t,r,n)}function F5t(e){if(e instanceof Kh)return new Kh(e.h,e.s,e.l,e.opacity);if(e instanceof Z5||(e=Su(e)),!e)return new Kh;if(e instanceof Kh)return e;e=e.rgb();var t=e.r/255,r=e.g/255,n=e.b/255,i=Math.min(t,r,n),o=Math.max(t,r,n),a=NaN,s=o-i,l=(o+i)/2;return s?(t===o?a=(r-n)/s+(r<n)*6:r===o?a=(n-t)/s+2:a=(t-r)/s+4,s/=l<.5?o+i:2-o-i,a*=60):s=l>0&&l<1?0:a,new Kh(a,s,l,e.opacity)}function B5t(e,t,r,n){return arguments.length===1?F5t(e):new Kh(e,t,r,n==null?1:n)}function Kh(e,t,r,n){this.h=+e,this.s=+t,this.l=+r,this.opacity=+n}function eK(e,t,r){return(e<60?t+(r-t)*e/60:e<180?r:e<240?t+(r-t)*(240-e)/60:t)*255}var $5,RR,c2,K5,Zh,CTe,ATe,PTe,ITe,LTe,kTe,RTe,L5t,H5t=M(()=>{I5t();$5=.7,RR=1/$5,c2="\\s*([+-]?\\d+)\\s*",K5="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",Zh="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",CTe=/^#([0-9a-f]{3,8})$/,ATe=new RegExp("^rgb\\("+[c2,c2,c2]+"\\)$"),PTe=new RegExp("^rgb\\("+[Zh,Zh,Zh]+"\\)$"),ITe=new RegExp("^rgba\\("+[c2,c2,c2,K5]+"\\)$"),LTe=new RegExp("^rgba\\("+[Zh,Zh,Zh,K5]+"\\)$"),kTe=new RegExp("^hsl\\("+[K5,Zh,Zh]+"\\)$"),RTe=new RegExp("^hsla\\("+[K5,Zh,Zh,K5]+"\\)$"),L5t={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};LR(Z5,Su,{copy:function(e){return Object.assign(new this.constructor,this,e)},displayable:function(){return this.rgb().displayable()},hex:k5t,formatHex:k5t,formatHsl:NTe,formatRgb:R5t,toString:R5t});LR(sl,u2,Q$(Z5,{brighter:function(e){return e=e==null?RR:Math.pow(RR,e),new sl(this.r*e,this.g*e,this.b*e,this.opacity)},darker:function(e){return e=e==null?$5:Math.pow($5,e),new sl(this.r*e,this.g*e,this.b*e,this.opacity)},rgb:function(){return this},displayable:function(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:D5t,formatHex:D5t,formatRgb:O5t,toString:O5t}));LR(Kh,B5t,Q$(Z5,{brighter:function(e){return e=e==null?RR:Math.pow(RR,e),new Kh(this.h,this.s,this.l*e,this.opacity)},darker:function(e){return e=e==null?$5:Math.pow($5,e),new Kh(this.h,this.s,this.l*e,this.opacity)},rgb:function(){var e=this.h%360+(this.h<0)*360,t=isNaN(e)||isNaN(this.s)?0:this.s,r=this.l,n=r+(r<.5?r:1-r)*t,i=2*r-n;return new sl(eK(e>=240?e-240:e+120,i,n),eK(e,i,n),eK(e<120?e+240:e-120,i,n),this.opacity)},displayable:function(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl:function(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"hsl(":"hsla(")+(this.h||0)+", "+(this.s||0)*100+"%, "+(this.l||0)*100+"%"+(e===1?")":", "+e+")")}}))});var NR=M(()=>{H5t()});function rK(e,t,r,n,i){var o=e*e,a=o*e;return((1-3*e+3*o-a)*t+(4-6*o+3*a)*r+(1+3*e+3*o-3*a)*n+a*i)/6}function V5t(e){var t=e.length-1;return function(r){var n=r<=0?r=0:r>=1?(r=1,t-1):Math.floor(r*t),i=e[n],o=e[n+1],a=n>0?e[n-1]:2*i-o,s=n<t-1?e[n+2]:2*o-i;return rK((r-n/t)*t,a,i,o,s)}}var nK=M(()=>{});function U5t(e){var t=e.length;return function(r){var n=Math.floor(((r%=1)<0?++r:r)*t),i=e[(n+t-1)%t],o=e[n%t],a=e[(n+1)%t],s=e[(n+2)%t];return rK((r-n/t)*t,i,o,a,s)}}var q5t=M(()=>{nK()});function J5(e){return function(){return e}}var iK=M(()=>{});function OTe(e,t){return function(r){return e+r*t}}function zTe(e,t,r){return e=Math.pow(e,r),t=Math.pow(t,r)-e,r=1/r,function(n){return Math.pow(e+n*t,r)}}function G5t(e){return(e=+e)==1?DR:function(t,r){return r-t?zTe(t,r,e):J5(isNaN(t)?r:t)}}function DR(e,t){var r=t-e;return r?OTe(e,r):J5(isNaN(e)?t:e)}var W5t=M(()=>{iK()});function Y5t(e){return function(t){var r=t.length,n=new Array(r),i=new Array(r),o=new Array(r),a,s;for(a=0;a<r;++a)s=u2(t[a]),n[a]=s.r||0,i[a]=s.g||0,o[a]=s.b||0;return n=e(n),i=e(i),o=e(o),s.opacity=1,function(l){return s.r=n(l),s.g=i(l),s.b=o(l),s+""}}}var gy,FTe,BTe,oK=M(()=>{NR();nK();q5t();W5t();gy=function e(t){var r=G5t(t);function n(i,o){var a=r((i=u2(i)).r,(o=u2(o)).r),s=r(i.g,o.g),l=r(i.b,o.b),c=DR(i.opacity,o.opacity);return function(u){return i.r=a(u),i.g=s(u),i.b=l(u),i.opacity=c(u),i+""}}return n.gamma=e,n}(1);FTe=Y5t(V5t),BTe=Y5t(U5t)});function j5t(e,t){t||(t=[]);var r=e?Math.min(t.length,e.length):0,n=t.slice(),i;return function(o){for(i=0;i<r;++i)n[i]=e[i]*(1-o)+t[i]*o;return n}}function X5t(e){return ArrayBuffer.isView(e)&&!(e instanceof DataView)}var $5t=M(()=>{});function K5t(e,t){var r=t?t.length:0,n=e?Math.min(r,e.length):0,i=new Array(n),o=new Array(r),a;for(a=0;a<n;++a)i[a]=_y(e[a],t[a]);for(;a<r;++a)o[a]=t[a];return function(s){for(a=0;a<n;++a)o[a]=i[a](s);return o}}var Z5t=M(()=>{OR()});function J5t(e,t){var r=new Date;return e=+e,t=+t,function(n){return r.setTime(e*(1-n)+t*n),r}}var Q5t=M(()=>{});function Ua(e,t){return e=+e,t=+t,function(r){return e*(1-r)+t*r}}var Q5=M(()=>{});function tTt(e,t){var r={},n={},i;(e===null||typeof e!="object")&&(e={}),(t===null||typeof t!="object")&&(t={});for(i in t)i in e?r[i]=_y(e[i],t[i]):n[i]=t[i];return function(o){for(i in r)n[i]=r[i](o);return n}}var eTt=M(()=>{OR()});function HTe(e){return function(){return e}}function VTe(e){return function(t){return e(t)+""}}function tT(e,t){var r=sK.lastIndex=aK.lastIndex=0,n,i,o,a=-1,s=[],l=[];for(e=e+"",t=t+"";(n=sK.exec(e))&&(i=aK.exec(t));)(o=i.index)>r&&(o=t.slice(r,o),s[a]?s[a]+=o:s[++a]=o),(n=n[0])===(i=i[0])?s[a]?s[a]+=i:s[++a]=i:(s[++a]=null,l.push({i:a,x:Ua(n,i)})),r=aK.lastIndex;return r<t.length&&(o=t.slice(r),s[a]?s[a]+=o:s[++a]=o),s.length<2?l[0]?VTe(l[0].x):HTe(t):(t=l.length,function(c){for(var u=0,h;u<t;++u)s[(h=l[u]).i]=h.x(c);return s.join("")})}var sK,aK,lK=M(()=>{Q5();sK=/[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,aK=new RegExp(sK.source,"g")});function _y(e,t){var r=typeof t,n;return t==null||r==="boolean"?J5(t):(r==="number"?Ua:r==="string"?(n=Su(t))?(t=n,gy):tT:t instanceof Su?gy:t instanceof Date?J5t:X5t(t)?j5t:Array.isArray(t)?K5t:typeof t.valueOf!="function"&&typeof t.toString!="function"||isNaN(t)?tTt:Ua)(e,t)}var OR=M(()=>{NR();oK();Z5t();Q5t();Q5();eTt();lK();iK();$5t()});function cK(e,t,r,n,i,o){var a,s,l;return(a=Math.sqrt(e*e+t*t))&&(e/=a,t/=a),(l=e*r+t*n)&&(r-=e*l,n-=t*l),(s=Math.sqrt(r*r+n*n))&&(r/=s,n/=s,l/=s),e*n<t*r&&(e=-e,t=-t,l=-l,a=-a),{translateX:i,translateY:o,rotate:Math.atan2(t,e)*rTt,skewX:Math.atan(l)*rTt,scaleX:a,scaleY:s}}var rTt,zR,nTt=M(()=>{rTt=180/Math.PI,zR={translateX:0,translateY:0,rotate:0,skewX:0,scaleX:1,scaleY:1}});function oTt(e){return e==="none"?zR:(eT||(eT=document.createElement("DIV"),uK=document.documentElement,iTt=document.defaultView),eT.style.transform=e,e=iTt.getComputedStyle(uK.appendChild(eT),null).getPropertyValue("transform"),uK.removeChild(eT),e=e.slice(7,-1).split(","),cK(+e[0],+e[1],+e[2],+e[3],+e[4],+e[5]))}function aTt(e){return e==null?zR:(FR||(FR=document.createElementNS("http://www.w3.org/2000/svg","g")),FR.setAttribute("transform",e),(e=FR.transform.baseVal.consolidate())?(e=e.matrix,cK(e.a,e.b,e.c,e.d,e.e,e.f)):zR)}var eT,uK,iTt,FR,sTt=M(()=>{nTt()});function lTt(e,t,r,n){function i(c){return c.length?c.pop()+" ":""}function o(c,u,h,f,p,d){if(c!==h||u!==f){var g=p.push("translate(",null,t,null,r);d.push({i:g-4,x:Ua(c,h)},{i:g-2,x:Ua(u,f)})}else(h||f)&&p.push("translate("+h+t+f+r)}function a(c,u,h,f){c!==u?(c-u>180?u+=360:u-c>180&&(c+=360),f.push({i:h.push(i(h)+"rotate(",null,n)-2,x:Ua(c,u)})):u&&h.push(i(h)+"rotate("+u+n)}function s(c,u,h,f){c!==u?f.push({i:h.push(i(h)+"skewX(",null,n)-2,x:Ua(c,u)}):u&&h.push(i(h)+"skewX("+u+n)}function l(c,u,h,f,p,d){if(c!==h||u!==f){var g=p.push(i(p)+"scale(",null,",",null,")");d.push({i:g-4,x:Ua(c,h)},{i:g-2,x:Ua(u,f)})}else(h!==1||f!==1)&&p.push(i(p)+"scale("+h+","+f+")")}return function(c,u){var h=[],f=[];return c=e(c),u=e(u),o(c.translateX,c.translateY,u.translateX,u.translateY,h,f),a(c.rotate,u.rotate,h,f),s(c.skewX,u.skewX,h,f),l(c.scaleX,c.scaleY,u.scaleX,u.scaleY,h,f),c=u=null,function(p){for(var d=-1,g=f.length,_;++d<g;)h[(_=f[d]).i]=_.x(p);return h.join("")}}}var hK,fK,cTt=M(()=>{Q5();sTt();hK=lTt(oTt,"px, ","px)","deg)"),fK=lTt(aTt,", ",")",")")});var rT=M(()=>{OR();Q5();lK();cTt();oK()});function f2(){return yy||(fTt(UTe),yy=aT.now()+VR)}function UTe(){yy=0}function sT(){this._call=this._time=this._next=null}function UR(e,t,r){var n=new sT;return n.restart(e,t,r),n}function pTt(){f2(),++h2;for(var e=BR,t;e;)(t=yy-e._time)>=0&&e._call.call(null,t),e=e._next;--h2}function uTt(){yy=(HR=aT.now())+VR,h2=iT=0;try{pTt()}finally{h2=0,GTe(),yy=0}}function qTe(){var e=aT.now(),t=e-HR;t>hTt&&(VR-=t,HR=e)}function GTe(){for(var e,t=BR,r,n=1/0;t;)t._call?(n>t._time&&(n=t._time),e=t,t=t._next):(r=t._next,t._next=null,t=e?e._next=r:BR=r);oT=e,pK(n)}function pK(e){if(!h2){iT&&(iT=clearTimeout(iT));var t=e-yy;t>24?(e<1/0&&(iT=setTimeout(uTt,e-aT.now()-VR)),nT&&(nT=clearInterval(nT))):(nT||(HR=aT.now(),nT=setInterval(qTe,hTt)),h2=1,fTt(uTt))}}var h2,iT,nT,hTt,BR,oT,HR,yy,VR,aT,fTt,dK=M(()=>{h2=0,iT=0,nT=0,hTt=1e3,HR=0,yy=0,VR=0,aT=typeof performance=="object"&&performance.now?performance:Date,fTt=typeof window=="object"&&window.requestAnimationFrame?window.requestAnimationFrame.bind(window):function(e){setTimeout(e,17)};sT.prototype=UR.prototype={constructor:sT,restart:function(e,t,r){if(typeof e!="function")throw new TypeError("callback is not a function");r=(r==null?f2():+r)+(t==null?0:+t),!this._next&&oT!==this&&(oT?oT._next=this:BR=this,oT=this),this._call=e,this._time=r,pK()},stop:function(){this._call&&(this._call=null,this._time=1/0,pK())}}});function qR(e,t,r){var n=new sT;return t=t==null?0:+t,n.restart(function(i){n.stop(),e(i+t)},t,r),n}var dTt=M(()=>{dK()});var mK=M(()=>{dK();dTt()});function sg(e,t,r,n,i,o){var a=e.__transition;if(!a)e.__transition={};else if(r in a)return;jTe(e,r,{name:t,index:n,group:i,on:WTe,tween:YTe,time:o.time,delay:o.delay,duration:o.duration,ease:o.ease,timer:null,state:gTt})}function cT(e,t){var r=Qi(e,t);if(r.state>gTt)throw new Error("too late; already scheduled");return r}function qa(e,t){var r=Qi(e,t);if(r.state>GR)throw new Error("too late; already running");return r}function Qi(e,t){var r=e.__transition;if(!r||!(r=r[t]))throw new Error("transition not found");return r}function jTe(e,t,r){var n=e.__transition,i;n[t]=r,r.timer=UR(o,0,r.time);function o(c){r.state=gK,r.timer.restart(a,r.delay,r.time),r.delay<=c&&a(c-r.delay)}function a(c){var u,h,f,p;if(r.state!==gK)return l();for(u in n)if(p=n[u],p.name===r.name){if(p.state===GR)return qR(a);p.state===mTt?(p.state=lT,p.timer.stop(),p.on.call("interrupt",e,e.__data__,p.index,p.group),delete n[u]):+u<t&&(p.state=lT,p.timer.stop(),p.on.call("cancel",e,e.__data__,p.index,p.group),delete n[u])}if(qR(function(){r.state===GR&&(r.state=mTt,r.timer.restart(s,r.delay,r.time),s(c))}),r.state=WR,r.on.call("start",e,e.__data__,r.index,r.group),r.state===WR){for(r.state=GR,i=new Array(f=r.tween.length),u=0,h=-1;u<f;++u)(p=r.tween[u].value.call(e,e.__data__,r.index,r.group))&&(i[++h]=p);i.length=h+1}}function s(c){for(var u=c<r.duration?r.ease.call(null,c/r.duration):(r.timer.restart(l),r.state=YR,1),h=-1,f=i.length;++h<f;)i[h].call(e,u);r.state===YR&&(r.on.call("end",e,e.__data__,r.index,r.group),l())}function l(){r.state=lT,r.timer.stop(),delete n[t];for(var c in n)return;delete e.__transition}}var WTe,YTe,gTt,gK,WR,GR,mTt,YR,lT,Ts=M(()=>{F$();mK();WTe=W5("start","end","cancel","interrupt"),YTe=[],gTt=0,gK=1,WR=2,GR=3,mTt=4,YR=5,lT=6});function p2(e,t){var r=e.__transition,n,i,o=!0,a;if(!!r){t=t==null?null:t+"";for(a in r){if((n=r[a]).name!==t){o=!1;continue}i=n.state>WR&&n.state<YR,n.state=lT,n.timer.stop(),n.on.call(i?"interrupt":"cancel",e,e.__data__,n.index,n.group),delete r[a]}o&&delete e.__transition}}var _K=M(()=>{Ts()});function _Tt(e){return this.each(function(){p2(this,e)})}var yTt=M(()=>{_K()});function XTe(e,t){var r,n;return function(){var i=qa(this,e),o=i.tween;if(o!==r){n=r=o;for(var a=0,s=n.length;a<s;++a)if(n[a].name===t){n=n.slice(),n.splice(a,1);break}}i.tween=n}}function $Te(e,t,r){var n,i;if(typeof r!="function")throw new Error;return function(){var o=qa(this,e),a=o.tween;if(a!==n){i=(n=a).slice();for(var s={name:t,value:r},l=0,c=i.length;l<c;++l)if(i[l].name===t){i[l]=s;break}l===c&&i.push(s)}o.tween=i}}function vTt(e,t){var r=this._id;if(e+="",arguments.length<2){for(var n=Qi(this.node(),r).tween,i=0,o=n.length,a;i<o;++i)if((a=n[i]).name===e)return a.value;return null}return this.each((t==null?XTe:$Te)(r,e,t))}function d2(e,t,r){var n=e._id;return e.each(function(){var i=qa(this,n);(i.value||(i.value={}))[t]=r.apply(this,arguments)}),function(i){return Qi(i,n).value[t]}}var uT=M(()=>{Ts()});function jR(e,t){var r;return(typeof t=="number"?Ua:t instanceof Su?gy:(r=Su(t))?(t=r,gy):tT)(e,t)}var yK=M(()=>{NR();rT()});function KTe(e){return function(){this.removeAttribute(e)}}function ZTe(e){return function(){this.removeAttributeNS(e.space,e.local)}}function JTe(e,t,r){var n,i=r+"",o;return function(){var a=this.getAttribute(e);return a===i?null:a===n?o:o=t(n=a,r)}}function QTe(e,t,r){var n,i=r+"",o;return function(){var a=this.getAttributeNS(e.space,e.local);return a===i?null:a===n?o:o=t(n=a,r)}}function tCe(e,t,r){var n,i,o;return function(){var a,s=r(this),l;return s==null?void this.removeAttribute(e):(a=this.getAttribute(e),l=s+"",a===l?null:a===n&&l===i?o:(i=l,o=t(n=a,s)))}}function eCe(e,t,r){var n,i,o;return function(){var a,s=r(this),l;return s==null?void this.removeAttributeNS(e.space,e.local):(a=this.getAttributeNS(e.space,e.local),l=s+"",a===l?null:a===n&&l===i?o:(i=l,o=t(n=a,s)))}}function xTt(e,t){var r=Vp(e),n=r==="transform"?fK:jR;return this.attrTween(e,typeof t=="function"?(r.local?eCe:tCe)(r,n,d2(this,"attr."+e,t)):t==null?(r.local?ZTe:KTe)(r):(r.local?QTe:JTe)(r,n,t))}var bTt=M(()=>{rT();Es();uT();yK()});function rCe(e,t){return function(r){this.setAttribute(e,t.call(this,r))}}function nCe(e,t){return function(r){this.setAttributeNS(e.space,e.local,t.call(this,r))}}function iCe(e,t){var r,n;function i(){var o=t.apply(this,arguments);return o!==n&&(r=(n=o)&&nCe(e,o)),r}return i._value=t,i}function oCe(e,t){var r,n;function i(){var o=t.apply(this,arguments);return o!==n&&(r=(n=o)&&rCe(e,o)),r}return i._value=t,i}function wTt(e,t){var r="attr."+e;if(arguments.length<2)return(r=this.tween(r))&&r._value;if(t==null)return this.tween(r,null);if(typeof t!="function")throw new Error;var n=Vp(e);return this.tween(r,(n.local?iCe:oCe)(n,t))}var STt=M(()=>{Es()});function aCe(e,t){return function(){cT(this,e).delay=+t.apply(this,arguments)}}function sCe(e,t){return t=+t,function(){cT(this,e).delay=t}}function MTt(e){var t=this._id;return arguments.length?this.each((typeof e=="function"?aCe:sCe)(t,e)):Qi(this.node(),t).delay}var ETt=M(()=>{Ts()});function lCe(e,t){return function(){qa(this,e).duration=+t.apply(this,arguments)}}function cCe(e,t){return t=+t,function(){qa(this,e).duration=t}}function TTt(e){var t=this._id;return arguments.length?this.each((typeof e=="function"?lCe:cCe)(t,e)):Qi(this.node(),t).duration}var CTt=M(()=>{Ts()});function uCe(e,t){if(typeof t!="function")throw new Error;return function(){qa(this,e).ease=t}}function ATt(e){var t=this._id;return arguments.length?this.each(uCe(t,e)):Qi(this.node(),t).ease}var PTt=M(()=>{Ts()});function ITt(e){typeof e!="function"&&(e=j5(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=[],l,c=0;c<a;++c)(l=o[c])&&e.call(l,l.__data__,c,o)&&s.push(l);return new ua(n,this._parents,this._name,this._id)}var LTt=M(()=>{Es();Gp()});function kTt(e){if(e._id!==this._id)throw new Error;for(var t=this._groups,r=e._groups,n=t.length,i=r.length,o=Math.min(n,i),a=new Array(n),s=0;s<o;++s)for(var l=t[s],c=r[s],u=l.length,h=a[s]=new Array(u),f,p=0;p<u;++p)(f=l[p]||c[p])&&(h[p]=f);for(;s<n;++s)a[s]=t[s];return new ua(a,this._parents,this._name,this._id)}var RTt=M(()=>{Gp()});function hCe(e){return(e+"").trim().split(/^|\s+/).every(function(t){var r=t.indexOf(".");return r>=0&&(t=t.slice(0,r)),!t||t==="start"})}function fCe(e,t,r){var n,i,o=hCe(t)?cT:qa;return function(){var a=o(this,e),s=a.on;s!==n&&(i=(n=s).copy()).on(t,r),a.on=i}}function NTt(e,t){var r=this._id;return arguments.length<2?Qi(this.node(),r).on.on(e):this.each(fCe(r,e,t))}var DTt=M(()=>{Ts()});function pCe(e){return function(){var t=this.parentNode;for(var r in this.__transition)if(+r!==e)return;t&&t.removeChild(this)}}function OTt(){return this.on("end.remove",pCe(this._id))}var zTt=M(()=>{});function FTt(e){var t=this._name,r=this._id;typeof e!="function"&&(e=my(e));for(var n=this._groups,i=n.length,o=new Array(i),a=0;a<i;++a)for(var s=n[a],l=s.length,c=o[a]=new Array(l),u,h,f=0;f<l;++f)(u=s[f])&&(h=e.call(u,u.__data__,f,s))&&("__data__"in u&&(h.__data__=u.__data__),c[f]=h,sg(c[f],t,r,f,c,Qi(u,r)));return new ua(o,this._parents,t,r)}var BTt=M(()=>{Es();Gp();Ts()});function HTt(e){var t=this._name,r=this._id;typeof e!="function"&&(e=Y5(e));for(var n=this._groups,i=n.length,o=[],a=[],s=0;s<i;++s)for(var l=n[s],c=l.length,u,h=0;h<c;++h)if(u=l[h]){for(var f=e.call(u,u.__data__,h,l),p,d=Qi(u,r),g=0,_=f.length;g<_;++g)(p=f[g])&&sg(p,t,r,g,f,d);o.push(f),a.push(u)}return new ua(o,a,t,r)}var VTt=M(()=>{Es();Gp();Ts()});function UTt(){return new dCe(this._groups,this._parents)}var dCe,qTt=M(()=>{Es();dCe=Up.prototype.constructor});function mCe(e,t){var r,n,i;return function(){var o=ag(this,e),a=(this.style.removeProperty(e),ag(this,e));return o===a?null:o===r&&a===n?i:i=t(r=o,n=a)}}function GTt(e){return function(){this.style.removeProperty(e)}}function gCe(e,t,r){var n,i=r+"",o;return function(){var a=ag(this,e);return a===i?null:a===n?o:o=t(n=a,r)}}function _Ce(e,t,r){var n,i,o;return function(){var a=ag(this,e),s=r(this),l=s+"";return s==null&&(l=s=(this.style.removeProperty(e),ag(this,e))),a===l?null:a===n&&l===i?o:(i=l,o=t(n=a,s))}}function yCe(e,t){var r,n,i,o="style."+t,a="end."+o,s;return function(){var l=qa(this,e),c=l.on,u=l.value[o]==null?s||(s=GTt(t)):void 0;(c!==r||i!==u)&&(n=(r=c).copy()).on(a,i=u),l.on=n}}function WTt(e,t,r){var n=(e+="")=="transform"?hK:jR;return t==null?this.styleTween(e,mCe(e,n)).on("end.style."+e,GTt(e)):typeof t=="function"?this.styleTween(e,_Ce(e,n,d2(this,"style."+e,t))).each(yCe(this._id,e)):this.styleTween(e,gCe(e,n,t),r).on("end.style."+e,null)}var YTt=M(()=>{rT();Es();Ts();uT();yK()});function vCe(e,t,r){return function(n){this.style.setProperty(e,t.call(this,n),r)}}function xCe(e,t,r){var n,i;function o(){var a=t.apply(this,arguments);return a!==i&&(n=(i=a)&&vCe(e,a,r)),n}return o._value=t,o}function jTt(e,t,r){var n="style."+(e+="");if(arguments.length<2)return(n=this.tween(n))&&n._value;if(t==null)return this.tween(n,null);if(typeof t!="function")throw new Error;return this.tween(n,xCe(e,t,r==null?"":r))}var XTt=M(()=>{});function bCe(e){return function(){this.textContent=e}}function wCe(e){return function(){var t=e(this);this.textContent=t==null?"":t}}function $Tt(e){return this.tween("text",typeof e=="function"?wCe(d2(this,"text",e)):bCe(e==null?"":e+""))}var KTt=M(()=>{uT()});function SCe(e){return function(t){this.textContent=e.call(this,t)}}function MCe(e){var t,r;function n(){var i=e.apply(this,arguments);return i!==r&&(t=(r=i)&&SCe(i)),t}return n._value=e,n}function ZTt(e){var t="text";if(arguments.length<1)return(t=this.tween(t))&&t._value;if(e==null)return this.tween(t,null);if(typeof e!="function")throw new Error;return this.tween(t,MCe(e))}var JTt=M(()=>{});function QTt(){for(var e=this._name,t=this._id,r=XR(),n=this._groups,i=n.length,o=0;o<i;++o)for(var a=n[o],s=a.length,l,c=0;c<s;++c)if(l=a[c]){var u=Qi(l,t);sg(l,e,r,c,a,{time:u.time+u.delay+u.duration,delay:0,duration:u.duration,ease:u.ease})}return new ua(n,this._parents,e,r)}var tCt=M(()=>{Gp();Ts()});function eCt(){var e,t,r=this,n=r._id,i=r.size();return new Promise(function(o,a){var s={value:a},l={value:function(){--i===0&&o()}};r.each(function(){var c=qa(this,n),u=c.on;u!==e&&(t=(e=u).copy(),t._.cancel.push(s),t._.interrupt.push(s),t._.end.push(l)),c.on=t})})}var rCt=M(()=>{Ts()});function ua(e,t,r,n){this._groups=e,this._parents=t,this._name=r,this._id=n}function vK(e){return Up().transition(e)}function XR(){return++ECe}var ECe,m2,Gp=M(()=>{Es();bTt();STt();ETt();CTt();PTt();LTt();RTt();DTt();zTt();BTt();VTt();qTt();YTt();XTt();KTt();JTt();tCt();uT();rCt();ECe=0;m2=Up.prototype;ua.prototype=vK.prototype={constructor:ua,select:FTt,selectAll:HTt,filter:ITt,merge:kTt,selection:UTt,transition:QTt,call:m2.call,nodes:m2.nodes,node:m2.node,size:m2.size,empty:m2.empty,each:m2.each,on:NTt,attr:xTt,attrTween:wTt,style:WTt,styleTween:jTt,text:$Tt,textTween:ZTt,remove:OTt,tween:vTt,delay:MTt,duration:TTt,ease:ATt,end:eCt}});function TCe(e,t){for(var r;!(r=e.__transition)||!(r=r[t]);)if(!(e=e.parentNode))return xK.time=f2(),xK;return r}function nCt(e){var t,r;e instanceof ua?(t=e._id,e=e._name):(t=XR(),(r=xK).time=f2(),e=e==null?null:e+"");for(var n=this._groups,i=n.length,o=0;o<i;++o)for(var a=n[o],s=a.length,l,c=0;c<s;++c)(l=a[c])&&sg(l,e,t,c,a,r||TCe(l,t));return new ua(n,this._parents,e,t)}var xK,iCt=M(()=>{Gp();Ts();I_();mK();xK={time:null,delay:0,duration:250,ease:xs}});var oCt=M(()=>{Es();yTt();iCt();Up.prototype.interrupt=_Tt;Up.prototype.transition=nCt});var aCt=M(()=>{Gp();Ts()});var sCt=M(()=>{oCt();Gp();aCt();_K()});function bK(e){return function(){return e}}var lCt=M(()=>{});function cCt(e,t,r){this.target=e,this.type=t,this.selection=r}var uCt=M(()=>{});function wK(){wr.stopImmediatePropagation()}function hT(){wr.preventDefault(),wr.stopImmediatePropagation()}var hCt=M(()=>{Es()});function fT(e){return{type:e}}function ICe(){return!wr.button}function LCe(){var e=this.ownerSVGElement||this;return[[0,0],[e.width.baseVal.value,e.height.baseVal.value]]}function MK(e){for(;!e.__brush;)if(!(e=e.parentNode))return;return e.__brush}function EK(e){return e[0][0]===e[1][0]||e[0][1]===e[1][1]}function mCt(e){var t=e.__brush;return t?t.dim.output(t.selection):null}function gCt(){return TK($R)}function _Ct(){return TK(KR)}function yCt(){return TK(CCe)}function TK(e){var t=LCe,r=ICe,n=W5(a,"start","brush","end"),i=6,o;function a(f){var p=f.property("__brush",h).selectAll(".overlay").data([fT("overlay")]);p.enter().append("rect").attr("class","overlay").attr("pointer-events","all").attr("cursor",Wp.overlay).merge(p).each(function(){var g=MK(this).extent;qp(this).attr("x",g[0][0]).attr("y",g[0][1]).attr("width",g[1][0]-g[0][0]).attr("height",g[1][1]-g[0][1])}),f.selectAll(".selection").data([fT("selection")]).enter().append("rect").attr("class","selection").attr("cursor",Wp.selection).attr("fill","#777").attr("fill-opacity",.3).attr("stroke","#fff").attr("shape-rendering","crispEdges");var d=f.selectAll(".handle").data(e.handles,function(g){return g.type});d.exit().remove(),d.enter().append("rect").attr("class",function(g){return"handle handle--"+g.type}).attr("cursor",function(g){return Wp[g.type]}),f.each(s).attr("fill","none").attr("pointer-events","all").style("-webkit-tap-highlight-color","rgba(0,0,0,0)").on("mousedown.brush touchstart.brush",u)}a.move=function(f,p){f.selection?f.on("start.brush",function(){l(this,arguments).beforestart().start()}).on("interrupt.brush end.brush",function(){l(this,arguments).end()}).tween("brush",function(){var d=this,g=d.__brush,_=l(d,arguments),y=g.selection,x=e.input(typeof p=="function"?p.apply(this,arguments):p,g.extent),b=_y(y,x);function S(C){g.selection=C===1&&EK(x)?null:b(C),s.call(d),_.brush()}return y&&x?S:S(1)}):f.each(function(){var d=this,g=arguments,_=d.__brush,y=e.input(typeof p=="function"?p.apply(d,g):p,_.extent),x=l(d,g).beforestart();p2(d),_.selection=y==null||EK(y)?null:y,s.call(d),x.start().brush().end()})};function s(){var f=qp(this),p=MK(this).selection;p?(f.selectAll(".selection").style("display",null).attr("x",p[0][0]).attr("y",p[0][1]).attr("width",p[1][0]-p[0][0]).attr("height",p[1][1]-p[0][1]),f.selectAll(".handle").style("display",null).attr("x",function(d){return d.type[d.type.length-1]==="e"?p[1][0]-i/2:p[0][0]-i/2}).attr("y",function(d){return d.type[0]==="s"?p[1][1]-i/2:p[0][1]-i/2}).attr("width",function(d){return d.type==="n"||d.type==="s"?p[1][0]-p[0][0]+i:i}).attr("height",function(d){return d.type==="e"||d.type==="w"?p[1][1]-p[0][1]+i:i})):f.selectAll(".selection,.handle").style("display","none").attr("x",null).attr("y",null).attr("width",null).attr("height",null)}function l(f,p){return f.__brush.emitter||new c(f,p)}function c(f,p){this.that=f,this.args=p,this.state=f.__brush,this.active=0}c.prototype={beforestart:function(){return++this.active===1&&(this.state.emitter=this,this.starting=!0),this},start:function(){return this.starting&&(this.starting=!1,this.emit("start")),this},brush:function(){return this.emit("brush"),this},end:function(){return--this.active===0&&(delete this.state.emitter,this.emit("end")),this},emit:function(f){$$(new cCt(a,f,e.output(this.state.selection)),n.apply,n,[f,this.that,this.args])}};function u(){if(wr.touches){if(wr.changedTouches.length<wr.touches.length)return hT()}else if(o)return;if(!r.apply(this,arguments))return;var f=this,p=wr.target.__data__.type,d=(wr.metaKey?p="overlay":p)==="selection"?fCt:wr.altKey?_2:g2,g=e===KR?null:ACe[p],_=e===$R?null:PCe[p],y=MK(f),x=y.extent,b=y.selection,S=x[0][0],C,P,k=x[0][1],O,D,B=x[1][0],I,L,R=x[1][1],F,z,U,W,Z,rt=g&&_&&wr.shiftKey,ot,st,St=PR(f),bt=St,Mt=l(f,arguments).beforestart();p==="overlay"?y.selection=b=[[C=e===KR?S:St[0],O=e===$R?k:St[1]],[I=e===KR?B:C,F=e===$R?R:O]]:(C=b[0][0],O=b[0][1],I=b[1][0],F=b[1][1]),P=C,D=O,L=I,z=F;var lt=qp(f).attr("pointer-events","none"),Kt=lt.selectAll(".overlay").attr("cursor",Wp[p]);if(wr.touches)lt.on("touchmove.brush",ct,!0).on("touchend.brush touchcancel.brush",et,!0);else{var _t=qp(wr.view).on("keydown.brush",dt,!0).on("keyup.brush",q,!0).on("mousemove.brush",ct,!0).on("mouseup.brush",et,!0);Z$(wr.view)}wK(),p2(f),s.call(f),Mt.start();function ct(){var pt=PR(f);rt&&!ot&&!st&&(Math.abs(pt[0]-bt[0])>Math.abs(pt[1]-bt[1])?st=!0:ot=!0),bt=pt,Z=!0,hT(),X()}function X(){var pt;switch(U=bt[0]-St[0],W=bt[1]-St[1],d){case SK:case fCt:{g&&(U=Math.max(S-C,Math.min(B-I,U)),P=C+U,L=I+U),_&&(W=Math.max(k-O,Math.min(R-F,W)),D=O+W,z=F+W);break}case g2:{g<0?(U=Math.max(S-C,Math.min(B-C,U)),P=C+U,L=I):g>0&&(U=Math.max(S-I,Math.min(B-I,U)),P=C,L=I+U),_<0?(W=Math.max(k-O,Math.min(R-O,W)),D=O+W,z=F):_>0&&(W=Math.max(k-F,Math.min(R-F,W)),D=O,z=F+W);break}case _2:{g&&(P=Math.max(S,Math.min(B,C-U*g)),L=Math.max(S,Math.min(B,I+U*g))),_&&(D=Math.max(k,Math.min(R,O-W*_)),z=Math.max(k,Math.min(R,F+W*_)));break}}L<P&&(g*=-1,pt=C,C=I,I=pt,pt=P,P=L,L=pt,p in pCt&&Kt.attr("cursor",Wp[p=pCt[p]])),z<D&&(_*=-1,pt=O,O=F,F=pt,pt=D,D=z,z=pt,p in dCt&&Kt.attr("cursor",Wp[p=dCt[p]])),y.selection&&(b=y.selection),ot&&(P=b[0][0],L=b[1][0]),st&&(D=b[0][1],z=b[1][1]),(b[0][0]!==P||b[0][1]!==D||b[1][0]!==L||b[1][1]!==z)&&(y.selection=[[P,D],[L,z]],s.call(f),Mt.brush())}function et(){if(wK(),wr.touches){if(wr.touches.length)return;o&&clearTimeout(o),o=setTimeout(function(){o=null},500),lt.on("touchmove.brush touchend.brush touchcancel.brush",null)}else J$(wr.view,Z),_t.on("keydown.brush keyup.brush mousemove.brush mouseup.brush",null);lt.attr("pointer-events","all"),Kt.attr("cursor",Wp.overlay),y.selection&&(b=y.selection),EK(b)&&(y.selection=null,s.call(f)),Mt.end()}function dt(){switch(wr.keyCode){case 16:{rt=g&&_;break}case 18:{d===g2&&(g&&(I=L-U*g,C=P+U*g),_&&(F=z-W*_,O=D+W*_),d=_2,X());break}case 32:{(d===g2||d===_2)&&(g<0?I=L-U:g>0&&(C=P-U),_<0?F=z-W:_>0&&(O=D-W),d=SK,Kt.attr("cursor",Wp.selection),X());break}default:return}hT()}function q(){switch(wr.keyCode){case 16:{rt&&(ot=st=rt=!1,X());break}case 18:{d===_2&&(g<0?I=L:g>0&&(C=P),_<0?F=z:_>0&&(O=D),d=g2,X());break}case 32:{d===SK&&(wr.altKey?(g&&(I=L-U*g,C=P+U*g),_&&(F=z-W*_,O=D+W*_),d=_2):(g<0?I=L:g>0&&(C=P),_<0?F=z:_>0&&(O=D),d=g2),Kt.attr("cursor",Wp[p]),X());break}default:return}hT()}}function h(){var f=this.__brush||{selection:null};return f.extent=t.apply(this,arguments),f.dim=e,f}return a.extent=function(f){return arguments.length?(t=typeof f=="function"?f:bK([[+f[0][0],+f[0][1]],[+f[1][0],+f[1][1]]]),a):t},a.filter=function(f){return arguments.length?(r=typeof f=="function"?f:bK(!!f),a):r},a.handleSize=function(f){return arguments.length?(i=+f,a):i},a.on=function(){var f=n.on.apply(n,arguments);return f===n?a:f},a}var fCt,SK,g2,_2,$R,KR,CCe,Wp,pCt,dCt,ACe,PCe,vCt=M(()=>{F$();P5t();rT();Es();sCt();lCt();uCt();hCt();fCt={name:"drag"},SK={name:"space"},g2={name:"handle"},_2={name:"center"},$R={name:"x",handles:["e","w"].map(fT),input:function(e,t){return e&&[[e[0],t[0][1]],[e[1],t[1][1]]]},output:function(e){return e&&[e[0][0],e[1][0]]}},KR={name:"y",handles:["n","s"].map(fT),input:function(e,t){return e&&[[t[0][0],e[0]],[t[1][0],e[1]]]},output:function(e){return e&&[e[0][1],e[1][1]]}},CCe={name:"xy",handles:["n","e","s","w","nw","ne","se","sw"].map(fT),input:function(e){return e},output:function(e){return e}},Wp={overlay:"crosshair",selection:"move",n:"ns-resize",e:"ew-resize",s:"ns-resize",w:"ew-resize",nw:"nwse-resize",ne:"nesw-resize",se:"nwse-resize",sw:"nesw-resize"},pCt={e:"w",w:"e",nw:"ne",ne:"nw",se:"sw",sw:"se"},dCt={n:"s",s:"n",nw:"sw",ne:"se",se:"ne",sw:"nw"},ACe={overlay:1,selection:1,n:null,e:1,s:null,w:-1,nw:-1,ne:1,se:1,sw:-1},PCe={overlay:1,selection:1,n:-1,e:null,s:1,w:null,nw:-1,ne:-1,se:1,sw:1}});var xCt=M(()=>{vCt()});function lg(e,t){return e<t?-1:e>t?1:e>=t?0:NaN}var vy=M(()=>{});function CK(e){return e.length===1&&(e=kCe(e)),{left:function(t,r,n,i){for(n==null&&(n=0),i==null&&(i=t.length);n<i;){var o=n+i>>>1;e(t[o],r)<0?n=o+1:i=o}return n},right:function(t,r,n,i){for(n==null&&(n=0),i==null&&(i=t.length);n<i;){var o=n+i>>>1;e(t[o],r)>0?i=o:n=o+1}return n}}}function kCe(e){return function(t,r){return lg(e(t),r)}}var AK=M(()=>{vy()});var bCt,RCe,NCe,PK=M(()=>{vy();AK();bCt=CK(lg),RCe=bCt.right,NCe=bCt.left});var IK=M(()=>{});var wCt=M(()=>{IK()});var SCt=M(()=>{});var y2=M(()=>{});var LK=M(()=>{y2()});var kK=M(()=>{LK()});var RK=M(()=>{});var MCt,OCe,zCe,NK=M(()=>{MCt=Array.prototype,OCe=MCt.slice,zCe=MCt.map});var ECt=M(()=>{});var TCt=M(()=>{});function pT(e,t,r){e=+e,t=+t,r=(i=arguments.length)<2?(t=e,e=0,1):i<3?1:+r;for(var n=-1,i=Math.max(0,Math.ceil((t-e)/r))|0,o=new Array(i);++n<i;)o[n]=e+n*r;return o}var DK=M(()=>{});var Sln,Mln,Eln,OK=M(()=>{Sln=Math.sqrt(50),Mln=Math.sqrt(10),Eln=Math.sqrt(2)});var zK=M(()=>{});var CCt=M(()=>{NK();PK();ECt();RK();TCt();DK();OK();zK()});var JR=M(()=>{y2()});var PCt=M(()=>{NK();vy();y2();JR()});var ICt=M(()=>{kK()});var LCt=M(()=>{});var kCt=M(()=>{y2()});var RCt=M(()=>{vy();y2();JR()});var NCt=M(()=>{});var FK=M(()=>{});var DCt=M(()=>{});var OCt=M(()=>{vy()});var zCt=M(()=>{});var FCt=M(()=>{});var BK=M(()=>{FK()});var BCt=M(()=>{BK()});var HCt=M(()=>{PK();vy();AK();wCt();SCt();kK();RK();CCt();PCt();ICt();zK();LCt();kCt();RCt();NCt();FK();IK();DCt();JR();DK();OCt();zCt();FCt();OK();BK();LK();BCt()});var HK,VK,VCt,dT,UK,qK,GK=M(()=>{HK=Math.cos,VK=Math.sin,VCt=Math.PI,dT=VCt/2,UK=VCt*2,qK=Math.max});function WCe(e){return function(t,r){return e(t.source.value+t.target.value,r.source.value+r.target.value)}}function UCt(){var e=0,t=null,r=null,n=null;function i(o){var a=o.length,s=[],l=pT(a),c=[],u=[],h=u.groups=new Array(a),f=new Array(a*a),p,d,g,_,y,x;for(p=0,y=-1;++y<a;){for(d=0,x=-1;++x<a;)d+=o[y][x];s.push(d),c.push(pT(a)),p+=d}for(t&&l.sort(function(B,I){return t(s[B],s[I])}),r&&c.forEach(function(B,I){B.sort(function(L,R){return r(o[I][L],o[I][R])})}),p=qK(0,UK-e*a)/p,_=p?e:UK/a,d=0,y=-1;++y<a;){for(g=d,x=-1;++x<a;){var b=l[y],S=c[b][x],C=o[b][S],P=d,k=d+=C*p;f[S*a+b]={index:b,subindex:S,startAngle:P,endAngle:k,value:C}}h[b]={index:b,startAngle:g,endAngle:d,value:s[b]},d+=_}for(y=-1;++y<a;)for(x=y-1;++x<a;){var O=f[x*a+y],D=f[y*a+x];(O.value||D.value)&&u.push(O.value<D.value?{source:D,target:O}:{source:O,target:D})}return n?u.sort(n):u}return i.padAngle=function(o){return arguments.length?(e=qK(0,o),i):e},i.sortGroups=function(o){return arguments.length?(t=o,i):t},i.sortSubgroups=function(o){return arguments.length?(r=o,i):r},i.sortChords=function(o){return arguments.length?(o==null?n=null:(n=WCe(o))._=o,i):n&&n._},i}var qCt=M(()=>{HCt();GK()});var GCt,WCt=M(()=>{GCt=Array.prototype.slice});function QR(e){return function(){return e}}var YCt=M(()=>{});function jK(){this._x0=this._y0=this._x1=this._y1=null,this._=""}function jCt(){return new jK}var WK,YK,xy,YCe,XK,XCt=M(()=>{WK=Math.PI,YK=2*WK,xy=1e-6,YCe=YK-xy;jK.prototype=jCt.prototype={constructor:jK,moveTo:function(e,t){this._+="M"+(this._x0=this._x1=+e)+","+(this._y0=this._y1=+t)},closePath:function(){this._x1!==null&&(this._x1=this._x0,this._y1=this._y0,this._+="Z")},lineTo:function(e,t){this._+="L"+(this._x1=+e)+","+(this._y1=+t)},quadraticCurveTo:function(e,t,r,n){this._+="Q"+ +e+","+ +t+","+(this._x1=+r)+","+(this._y1=+n)},bezierCurveTo:function(e,t,r,n,i,o){this._+="C"+ +e+","+ +t+","+ +r+","+ +n+","+(this._x1=+i)+","+(this._y1=+o)},arcTo:function(e,t,r,n,i){e=+e,t=+t,r=+r,n=+n,i=+i;var o=this._x1,a=this._y1,s=r-e,l=n-t,c=o-e,u=a-t,h=c*c+u*u;if(i<0)throw new Error("negative radius: "+i);if(this._x1===null)this._+="M"+(this._x1=e)+","+(this._y1=t);else if(h>xy)if(!(Math.abs(u*s-l*c)>xy)||!i)this._+="L"+(this._x1=e)+","+(this._y1=t);else{var f=r-o,p=n-a,d=s*s+l*l,g=f*f+p*p,_=Math.sqrt(d),y=Math.sqrt(h),x=i*Math.tan((WK-Math.acos((d+h-g)/(2*_*y)))/2),b=x/y,S=x/_;Math.abs(b-1)>xy&&(this._+="L"+(e+b*c)+","+(t+b*u)),this._+="A"+i+","+i+",0,0,"+ +(u*f>c*p)+","+(this._x1=e+S*s)+","+(this._y1=t+S*l)}},arc:function(e,t,r,n,i,o){e=+e,t=+t,r=+r,o=!!o;var a=r*Math.cos(n),s=r*Math.sin(n),l=e+a,c=t+s,u=1^o,h=o?n-i:i-n;if(r<0)throw new Error("negative radius: "+r);this._x1===null?this._+="M"+l+","+c:(Math.abs(this._x1-l)>xy||Math.abs(this._y1-c)>xy)&&(this._+="L"+l+","+c),r&&(h<0&&(h=h%YK+YK),h>YCe?this._+="A"+r+","+r+",0,1,"+u+","+(e-a)+","+(t-s)+"A"+r+","+r+",0,1,"+u+","+(this._x1=l)+","+(this._y1=c):h>xy&&(this._+="A"+r+","+r+",0,"+ +(h>=WK)+","+u+","+(this._x1=e+r*Math.cos(i))+","+(this._y1=t+r*Math.sin(i))))},rect:function(e,t,r,n){this._+="M"+(this._x0=this._x1=+e)+","+(this._y0=this._y1=+t)+"h"+ +r+"v"+ +n+"h"+-r+"Z"},toString:function(){return this._}};XK=jCt});var $Ct=M(()=>{XCt()});function jCe(e){return e.source}function XCe(e){return e.target}function $Ce(e){return e.radius}function KCe(e){return e.startAngle}function ZCe(e){return e.endAngle}function KCt(){var e=jCe,t=XCe,r=$Ce,n=KCe,i=ZCe,o=null;function a(){var s,l=GCt.call(arguments),c=e.apply(this,l),u=t.apply(this,l),h=+r.apply(this,(l[0]=c,l)),f=n.apply(this,l)-dT,p=i.apply(this,l)-dT,d=h*HK(f),g=h*VK(f),_=+r.apply(this,(l[0]=u,l)),y=n.apply(this,l)-dT,x=i.apply(this,l)-dT;if(o||(o=s=XK()),o.moveTo(d,g),o.arc(0,0,h,f,p),(f!==y||p!==x)&&(o.quadraticCurveTo(0,0,_*HK(y),_*VK(y)),o.arc(0,0,_,y,x)),o.quadraticCurveTo(0,0,d,g),o.closePath(),s)return o=null,s+""||null}return a.radius=function(s){return arguments.length?(r=typeof s=="function"?s:QR(+s),a):r},a.startAngle=function(s){return arguments.length?(n=typeof s=="function"?s:QR(+s),a):n},a.endAngle=function(s){return arguments.length?(i=typeof s=="function"?s:QR(+s),a):i},a.source=function(s){return arguments.length?(e=s,a):e},a.target=function(s){return arguments.length?(t=s,a):t},a.context=function(s){return arguments.length?(o=s==null?null:s,a):o},a}var ZCt=M(()=>{WCt();YCt();GK();$Ct()});var JCt=M(()=>{qCt();ZCt()});function tN(){}function QCt(e,t){var r=new tN;if(e instanceof tN)e.each(function(s,l){r.set(l,s)});else if(Array.isArray(e)){var n=-1,i=e.length,o;if(t==null)for(;++n<i;)r.set(n,e[n]);else for(;++n<i;)r.set(t(o=e[n],n,e),o)}else if(e)for(var a in e)r.set(a,e[a]);return r}var ll,by,eN=M(()=>{ll="$";tN.prototype=QCt.prototype={constructor:tN,has:function(e){return ll+e in this},get:function(e){return this[ll+e]},set:function(e,t){return this[ll+e]=t,this},remove:function(e){var t=ll+e;return t in this&&delete this[t]},clear:function(){for(var e in this)e[0]===ll&&delete this[e]},keys:function(){var e=[];for(var t in this)t[0]===ll&&e.push(t.slice(1));return e},values:function(){var e=[];for(var t in this)t[0]===ll&&e.push(this[t]);return e},entries:function(){var e=[];for(var t in this)t[0]===ll&&e.push({key:t.slice(1),value:this[t]});return e},size:function(){var e=0;for(var t in this)t[0]===ll&&++e;return e},empty:function(){for(var e in this)if(e[0]===ll)return!1;return!0},each:function(e){for(var t in this)t[0]===ll&&e(this[t],t.slice(1),this)}};by=QCt});function rAt(){var e=[],t=[],r,n,i;function o(s,l,c,u){if(l>=e.length)return r!=null&&s.sort(r),n!=null?n(s):s;for(var h=-1,f=s.length,p=e[l++],d,g,_=by(),y,x=c();++h<f;)(y=_.get(d=p(g=s[h])+""))?y.push(g):_.set(d,[g]);return _.each(function(b,S){u(x,S,o(b,l,c,u))}),x}function a(s,l){if(++l>e.length)return s;var c,u=t[l-1];return n!=null&&l>=e.length?c=s.entries():(c=[],s.each(function(h,f){c.push({key:f,values:a(h,l)})})),u!=null?c.sort(function(h,f){return u(h.key,f.key)}):c}return i={object:function(s){return o(s,0,JCe,QCe)},map:function(s){return o(s,0,tAt,eAt)},entries:function(s){return a(o(s,0,tAt,eAt),0)},key:function(s){return e.push(s),i},sortKeys:function(s){return t[e.length-1]=s,i},sortValues:function(s){return r=s,i},rollup:function(s){return n=s,i}}}function JCe(){return{}}function QCe(e,t,r){e[t]=r}function tAt(){return by()}function eAt(e,t,r){e.set(t,r)}var nAt=M(()=>{eN()});function rN(){}function iAt(e,t){var r=new rN;if(e instanceof rN)e.each(function(o){r.add(o)});else if(e){var n=-1,i=e.length;if(t==null)for(;++n<i;)r.add(e[n]);else for(;++n<i;)r.add(t(e[n],n,e))}return r}var wy,oAt,aAt=M(()=>{eN();wy=by.prototype;rN.prototype=iAt.prototype={constructor:rN,has:wy.has,add:function(e){return e+="",this[ll+e]=e,this},remove:wy.remove,clear:wy.clear,values:wy.keys,size:wy.size,empty:wy.empty,each:wy.each};oAt=iAt});function sAt(e){var t=[];for(var r in e)t.push(r);return t}var lAt=M(()=>{});function cAt(e){var t=[];for(var r in e)t.push(e[r]);return t}var uAt=M(()=>{});function hAt(e){var t=[];for(var r in e)t.push({key:r,value:e[r]});return t}var fAt=M(()=>{});var pAt=M(()=>{nAt();aAt();eN();lAt();uAt();fAt()});function Yp(e,t,r){e.prototype=t.prototype=r,r.constructor=e}function cg(e,t){var r=Object.create(e.prototype);for(var n in t)r[n]=t[n];return r}var nN=M(()=>{});function tf(){}function x2(e){var t;return e=(e+"").trim().toLowerCase(),(t=tAe.exec(e))?(t=parseInt(t[1],16),new to(t>>8&15|t>>4&240,t>>4&15|t&240,(t&15)<<4|t&15,1)):(t=eAe.exec(e))?mAt(parseInt(t[1],16)):(t=rAe.exec(e))?new to(t[1],t[2],t[3],1):(t=nAe.exec(e))?new to(t[1]*255/100,t[2]*255/100,t[3]*255/100,1):(t=iAe.exec(e))?gAt(t[1],t[2],t[3],t[4]):(t=oAe.exec(e))?gAt(t[1]*255/100,t[2]*255/100,t[3]*255/100,t[4]):(t=aAe.exec(e))?_At(t[1],t[2]/100,t[3]/100,1):(t=sAe.exec(e))?_At(t[1],t[2]/100,t[3]/100,t[4]):dAt.hasOwnProperty(e)?mAt(dAt[e]):e==="transparent"?new to(NaN,NaN,NaN,0):null}function mAt(e){return new to(e>>16&255,e>>8&255,e&255,1)}function gAt(e,t,r,n){return n<=0&&(e=t=r=NaN),new to(e,t,r,n)}function gT(e){return e instanceof tf||(e=x2(e)),e?(e=e.rgb(),new to(e.r,e.g,e.b,e.opacity)):new to}function KK(e,t,r,n){return arguments.length===1?gT(e):new to(e,t,r,n==null?1:n)}function to(e,t,r,n){this.r=+e,this.g=+t,this.b=+r,this.opacity=+n}function _At(e,t,r,n){return n<=0?e=t=r=NaN:r<=0||r>=1?e=t=NaN:t<=0&&(e=NaN),new Jh(e,t,r,n)}function lAe(e){if(e instanceof Jh)return new Jh(e.h,e.s,e.l,e.opacity);if(e instanceof tf||(e=x2(e)),!e)return new Jh;if(e instanceof Jh)return e;e=e.rgb();var t=e.r/255,r=e.g/255,n=e.b/255,i=Math.min(t,r,n),o=Math.max(t,r,n),a=NaN,s=o-i,l=(o+i)/2;return s?(t===o?a=(r-n)/s+(r<n)*6:r===o?a=(n-t)/s+2:a=(t-r)/s+4,s/=l<.5?o+i:2-o-i,a*=60):s=l>0&&l<1?0:a,new Jh(a,s,l,e.opacity)}function ZK(e,t,r,n){return arguments.length===1?lAe(e):new Jh(e,t,r,n==null?1:n)}function Jh(e,t,r,n){this.h=+e,this.s=+t,this.l=+r,this.opacity=+n}function $K(e,t,r){return(e<60?t+(r-t)*e/60:e<180?r:e<240?t+(r-t)*(240-e)/60:t)*255}var ug,Sy,v2,mT,Qh,tAe,eAe,rAe,nAe,iAe,oAe,aAe,sAe,dAt,iN=M(()=>{nN();ug=.7,Sy=1/ug,v2="\\s*([+-]?\\d+)\\s*",mT="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",Qh="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",tAe=/^#([0-9a-f]{3})$/,eAe=/^#([0-9a-f]{6})$/,rAe=new RegExp("^rgb\\("+[v2,v2,v2]+"\\)$"),nAe=new RegExp("^rgb\\("+[Qh,Qh,Qh]+"\\)$"),iAe=new RegExp("^rgba\\("+[v2,v2,v2,mT]+"\\)$"),oAe=new RegExp("^rgba\\("+[Qh,Qh,Qh,mT]+"\\)$"),aAe=new RegExp("^hsl\\("+[mT,Qh,Qh]+"\\)$"),sAe=new RegExp("^hsla\\("+[mT,Qh,Qh,mT]+"\\)$"),dAt={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};Yp(tf,x2,{displayable:function(){return this.rgb().displayable()},toString:function(){return this.rgb()+""}});Yp(to,KK,cg(tf,{brighter:function(e){return e=e==null?Sy:Math.pow(Sy,e),new to(this.r*e,this.g*e,this.b*e,this.opacity)},darker:function(e){return e=e==null?ug:Math.pow(ug,e),new to(this.r*e,this.g*e,this.b*e,this.opacity)},rgb:function(){return this},displayable:function(){return 0<=this.r&&this.r<=255&&0<=this.g&&this.g<=255&&0<=this.b&&this.b<=255&&0<=this.opacity&&this.opacity<=1},toString:function(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"rgb(":"rgba(")+Math.max(0,Math.min(255,Math.round(this.r)||0))+", "+Math.max(0,Math.min(255,Math.round(this.g)||0))+", "+Math.max(0,Math.min(255,Math.round(this.b)||0))+(e===1?")":", "+e+")")}}));Yp(Jh,ZK,cg(tf,{brighter:function(e){return e=e==null?Sy:Math.pow(Sy,e),new Jh(this.h,this.s,this.l*e,this.opacity)},darker:function(e){return e=e==null?ug:Math.pow(ug,e),new Jh(this.h,this.s,this.l*e,this.opacity)},rgb:function(){var e=this.h%360+(this.h<0)*360,t=isNaN(e)||isNaN(this.s)?0:this.s,r=this.l,n=r+(r<.5?r:1-r)*t,i=2*r-n;return new to($K(e>=240?e-240:e+120,i,n),$K(e,i,n),$K(e<120?e+240:e-120,i,n),this.opacity)},displayable:function(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1}}))});var oN,aN,JK=M(()=>{oN=Math.PI/180,aN=180/Math.PI});function nZ(e){if(e instanceof jp)return new jp(e.l,e.a,e.b,e.opacity);if(e instanceof hg){var t=e.h*oN;return new jp(e.l,Math.cos(t)*e.c,Math.sin(t)*e.c,e.opacity)}e instanceof to||(e=gT(e));var r=rZ(e.r),n=rZ(e.g),i=rZ(e.b),o=QK((.4124564*r+.3575761*n+.1804375*i)/yAt),a=QK((.2126729*r+.7151522*n+.072175*i)/vAt),s=QK((.0193339*r+.119192*n+.9503041*i)/xAt);return new jp(116*a-16,500*(o-a),200*(a-s),e.opacity)}function lN(e,t,r,n){return arguments.length===1?nZ(e):new jp(e,t,r,n==null?1:n)}function jp(e,t,r,n){this.l=+e,this.a=+t,this.b=+r,this.opacity=+n}function QK(e){return e>cAe?Math.pow(e,1/3):e/wAt+bAt}function tZ(e){return e>b2?e*e*e:wAt*(e-bAt)}function eZ(e){return 255*(e<=.0031308?12.92*e:1.055*Math.pow(e,1/2.4)-.055)}function rZ(e){return(e/=255)<=.04045?e/12.92:Math.pow((e+.055)/1.055,2.4)}function uAe(e){if(e instanceof hg)return new hg(e.h,e.c,e.l,e.opacity);e instanceof jp||(e=nZ(e));var t=Math.atan2(e.b,e.a)*aN;return new hg(t<0?t+360:t,Math.sqrt(e.a*e.a+e.b*e.b),e.l,e.opacity)}function iZ(e,t,r,n){return arguments.length===1?uAe(e):new hg(e,t,r,n==null?1:n)}function hg(e,t,r,n){this.h=+e,this.c=+t,this.l=+r,this.opacity=+n}var sN,yAt,vAt,xAt,bAt,b2,wAt,cAe,SAt=M(()=>{nN();iN();JK();sN=18,yAt=.95047,vAt=1,xAt=1.08883,bAt=4/29,b2=6/29,wAt=3*b2*b2,cAe=b2*b2*b2;Yp(jp,lN,cg(tf,{brighter:function(e){return new jp(this.l+sN*(e==null?1:e),this.a,this.b,this.opacity)},darker:function(e){return new jp(this.l-sN*(e==null?1:e),this.a,this.b,this.opacity)},rgb:function(){var e=(this.l+16)/116,t=isNaN(this.a)?e:e+this.a/500,r=isNaN(this.b)?e:e-this.b/200;return e=vAt*tZ(e),t=yAt*tZ(t),r=xAt*tZ(r),new to(eZ(3.2404542*t-1.5371385*e-.4985314*r),eZ(-.969266*t+1.8760108*e+.041556*r),eZ(.0556434*t-.2040259*e+1.0572252*r),this.opacity)}}));Yp(hg,iZ,cg(tf,{brighter:function(e){return new hg(this.h,this.c,this.l+sN*(e==null?1:e),this.opacity)},darker:function(e){return new hg(this.h,this.c,this.l-sN*(e==null?1:e),this.opacity)},rgb:function(){return nZ(this).rgb()}}))});function hAe(e){if(e instanceof My)return new My(e.h,e.s,e.l,e.opacity);e instanceof to||(e=gT(e));var t=e.r/255,r=e.g/255,n=e.b/255,i=(TAt*n+MAt*t-EAt*r)/(TAt+MAt-EAt),o=n-i,a=(_T*(r-i)-aZ*o)/cN,s=Math.sqrt(a*a+o*o)/(_T*i*(1-i)),l=s?Math.atan2(a,o)*aN-120:NaN;return new My(l<0?l+360:l,s,i,e.opacity)}function uN(e,t,r,n){return arguments.length===1?hAe(e):new My(e,t,r,n==null?1:n)}function My(e,t,r,n){this.h=+e,this.s=+t,this.l=+r,this.opacity=+n}var CAt,oZ,aZ,cN,_T,MAt,EAt,TAt,AAt=M(()=>{nN();iN();JK();CAt=-.14861,oZ=1.78277,aZ=-.29227,cN=-.90649,_T=1.97294,MAt=_T*cN,EAt=_T*oZ,TAt=oZ*aZ-cN*CAt;Yp(My,uN,cg(tf,{brighter:function(e){return e=e==null?Sy:Math.pow(Sy,e),new My(this.h,this.s,this.l*e,this.opacity)},darker:function(e){return e=e==null?ug:Math.pow(ug,e),new My(this.h,this.s,this.l*e,this.opacity)},rgb:function(){var e=isNaN(this.h)?0:(this.h+120)*oN,t=+this.l,r=isNaN(this.s)?0:this.s*t*(1-t),n=Math.cos(e),i=Math.sin(e);return new to(255*(t+r*(CAt*n+oZ*i)),255*(t+r*(aZ*n+cN*i)),255*(t+r*(_T*n)),this.opacity)}}))});var PAt=M(()=>{iN();SAt();AAt()});function LAt(){for(var e=0,t=arguments.length,r={},n;e<t;++e){if(!(n=arguments[e]+"")||n in r)throw new Error("illegal type: "+n);r[n]=[]}return new hN(r)}function hN(e){this._=e}function pAe(e,t){return e.trim().split(/^|\s+/).map(function(r){var n="",i=r.indexOf(".");if(i>=0&&(n=r.slice(i+1),r=r.slice(0,i)),r&&!t.hasOwnProperty(r))throw new Error("unknown type: "+r);return{type:r,name:n}})}function dAe(e,t){for(var r=0,n=e.length,i;r<n;++r)if((i=e[r]).name===t)return i.value}function IAt(e,t,r){for(var n=0,i=e.length;n<i;++n)if(e[n].name===t){e[n]=fAe,e=e.slice(0,n).concat(e.slice(n+1));break}return r!=null&&e.push({name:t,value:r}),e}var fAe,kAt,RAt=M(()=>{fAe={value:function(){}};hN.prototype=LAt.prototype={constructor:hN,on:function(e,t){var r=this._,n=pAe(e+"",r),i,o=-1,a=n.length;if(arguments.length<2){for(;++o<a;)if((i=(e=n[o]).type)&&(i=dAe(r[i],e.name)))return i;return}if(t!=null&&typeof t!="function")throw new Error("invalid callback: "+t);for(;++o<a;)if(i=(e=n[o]).type)r[i]=IAt(r[i],e.name,t);else if(t==null)for(i in r)r[i]=IAt(r[i],e.name,null);return this},copy:function(){var e={},t=this._;for(var r in t)e[r]=t[r].slice();return new hN(e)},call:function(e,t){if((i=arguments.length-2)>0)for(var r=new Array(i),n=0,i,o;n<i;++n)r[n]=arguments[n+2];if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(o=this._[e],n=0,i=o.length;n<i;++n)o[n].value.apply(t,r)},apply:function(e,t,r){if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(var n=this._[e],i=0,o=n.length;i<o;++i)n[i].value.apply(t,r)}};kAt=LAt});var NAt=M(()=>{RAt()});function OAt(){for(var e=0,t=arguments.length,r={},n;e<t;++e){if(!(n=arguments[e]+"")||n in r||/[\s.]/.test(n))throw new Error("illegal type: "+n);r[n]=[]}return new fN(r)}function fN(e){this._=e}function gAe(e,t){return e.trim().split(/^|\s+/).map(function(r){var n="",i=r.indexOf(".");if(i>=0&&(n=r.slice(i+1),r=r.slice(0,i)),r&&!t.hasOwnProperty(r))throw new Error("unknown type: "+r);return{type:r,name:n}})}function _Ae(e,t){for(var r=0,n=e.length,i;r<n;++r)if((i=e[r]).name===t)return i.value}function DAt(e,t,r){for(var n=0,i=e.length;n<i;++n)if(e[n].name===t){e[n]=mAe,e=e.slice(0,n).concat(e.slice(n+1));break}return r!=null&&e.push({name:t,value:r}),e}var mAe,sZ,zAt=M(()=>{mAe={value:function(){}};fN.prototype=OAt.prototype={constructor:fN,on:function(e,t){var r=this._,n=gAe(e+"",r),i,o=-1,a=n.length;if(arguments.length<2){for(;++o<a;)if((i=(e=n[o]).type)&&(i=_Ae(r[i],e.name)))return i;return}if(t!=null&&typeof t!="function")throw new Error("invalid callback: "+t);for(;++o<a;)if(i=(e=n[o]).type)r[i]=DAt(r[i],e.name,t);else if(t==null)for(i in r)r[i]=DAt(r[i],e.name,null);return this},copy:function(){var e={},t=this._;for(var r in t)e[r]=t[r].slice();return new fN(e)},call:function(e,t){if((i=arguments.length-2)>0)for(var r=new Array(i),n=0,i,o;n<i;++n)r[n]=arguments[n+2];if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(o=this._[e],n=0,i=o.length;n<i;++n)o[n].value.apply(t,r)},apply:function(e,t,r){if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(var n=this._[e],i=0,o=n.length;i<o;++i)n[i].value.apply(t,r)}};sZ=OAt});var FAt=M(()=>{zAt()});var pN,lZ,cZ=M(()=>{pN="http://www.w3.org/1999/xhtml",lZ={svg:"http://www.w3.org/2000/svg",xhtml:pN,xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/"}});function dN(e){var t=e+="",r=t.indexOf(":");return r>=0&&(t=e.slice(0,r))!=="xmlns"&&(e=e.slice(r+1)),lZ.hasOwnProperty(t)?{space:lZ[t],local:e}:e}var uZ=M(()=>{cZ()});function yAe(e){return function(){var t=this.ownerDocument,r=this.namespaceURI;return r===pN&&t.documentElement.namespaceURI===pN?t.createElement(e):t.createElementNS(r,e)}}function vAe(e){return function(){return this.ownerDocument.createElementNS(e.space,e.local)}}function mN(e){var t=dN(e);return(t.local?vAe:yAe)(t)}var hZ=M(()=>{uZ();cZ()});function xAe(){}function gN(e){return e==null?xAe:function(){return this.querySelector(e)}}var fZ=M(()=>{});function BAt(e){typeof e!="function"&&(e=gN(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=new Array(a),l,c,u=0;u<a;++u)(l=o[u])&&(c=e.call(l,l.__data__,u,o))&&("__data__"in l&&(c.__data__=l.__data__),s[u]=c);return new pi(n,this._parents)}var HAt=M(()=>{ef();fZ()});function bAe(){return[]}function VAt(e){return e==null?bAe:function(){return this.querySelectorAll(e)}}var UAt=M(()=>{});function qAt(e){typeof e!="function"&&(e=VAt(e));for(var t=this._groups,r=t.length,n=[],i=[],o=0;o<r;++o)for(var a=t[o],s=a.length,l,c=0;c<s;++c)(l=a[c])&&(n.push(e.call(l,l.__data__,c,a)),i.push(l));return new pi(n,i)}var GAt=M(()=>{ef();UAt()});function WAt(e){return function(){return this.matches(e)}}var YAt=M(()=>{});function jAt(e){typeof e!="function"&&(e=WAt(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=[],l,c=0;c<a;++c)(l=o[c])&&e.call(l,l.__data__,c,o)&&s.push(l);return new pi(n,this._parents)}var XAt=M(()=>{ef();YAt()});function _N(e){return new Array(e.length)}var pZ=M(()=>{});function $At(){return new pi(this._enter||this._groups.map(_N),this._parents)}function yT(e,t){this.ownerDocument=e.ownerDocument,this.namespaceURI=e.namespaceURI,this._next=null,this._parent=e,this.__data__=t}var dZ=M(()=>{pZ();ef();yT.prototype={constructor:yT,appendChild:function(e){return this._parent.insertBefore(e,this._next)},insertBefore:function(e,t){return this._parent.insertBefore(e,t)},querySelector:function(e){return this._parent.querySelector(e)},querySelectorAll:function(e){return this._parent.querySelectorAll(e)}}});function KAt(e){return function(){return e}}var ZAt=M(()=>{});function wAe(e,t,r,n,i,o){for(var a=0,s,l=t.length,c=o.length;a<c;++a)(s=t[a])?(s.__data__=o[a],n[a]=s):r[a]=new yT(e,o[a]);for(;a<l;++a)(s=t[a])&&(i[a]=s)}function SAe(e,t,r,n,i,o,a){var s,l,c={},u=t.length,h=o.length,f=new Array(u),p;for(s=0;s<u;++s)(l=t[s])&&(f[s]=p=JAt+a.call(l,l.__data__,s,t),p in c?i[s]=l:c[p]=l);for(s=0;s<h;++s)p=JAt+a.call(e,o[s],s,o),(l=c[p])?(n[s]=l,l.__data__=o[s],c[p]=null):r[s]=new yT(e,o[s]);for(s=0;s<u;++s)(l=t[s])&&c[f[s]]===l&&(i[s]=l)}function QAt(e,t){if(!e)return p=new Array(this.size()),c=-1,this.each(function(P){p[++c]=P}),p;var r=t?SAe:wAe,n=this._parents,i=this._groups;typeof e!="function"&&(e=KAt(e));for(var o=i.length,a=new Array(o),s=new Array(o),l=new Array(o),c=0;c<o;++c){var u=n[c],h=i[c],f=h.length,p=e.call(u,u&&u.__data__,c,n),d=p.length,g=s[c]=new Array(d),_=a[c]=new Array(d),y=l[c]=new Array(f);r(u,h,g,_,y,p,t);for(var x=0,b=0,S,C;x<d;++x)if(S=g[x]){for(x>=b&&(b=x+1);!(C=_[b])&&++b<d;);S._next=C||null}}return a=new pi(a,n),a._enter=s,a._exit=l,a}var JAt,t4t=M(()=>{ef();dZ();ZAt();JAt="$"});function e4t(){return new pi(this._exit||this._groups.map(_N),this._parents)}var r4t=M(()=>{pZ();ef()});function n4t(e,t,r){var n=this.enter(),i=this,o=this.exit();return n=typeof e=="function"?e(n):n.append(e+""),t!=null&&(i=t(i)),r==null?o.remove():r(o),n&&i?n.merge(i).order():i}var i4t=M(()=>{});function o4t(e){for(var t=this._groups,r=e._groups,n=t.length,i=r.length,o=Math.min(n,i),a=new Array(n),s=0;s<o;++s)for(var l=t[s],c=r[s],u=l.length,h=a[s]=new Array(u),f,p=0;p<u;++p)(f=l[p]||c[p])&&(h[p]=f);for(;s<n;++s)a[s]=t[s];return new pi(a,this._parents)}var a4t=M(()=>{ef()});function s4t(){for(var e=this._groups,t=-1,r=e.length;++t<r;)for(var n=e[t],i=n.length-1,o=n[i],a;--i>=0;)(a=n[i])&&(o&&a.compareDocumentPosition(o)^4&&o.parentNode.insertBefore(a,o),o=a);return this}var l4t=M(()=>{});function c4t(e){e||(e=MAe);function t(h,f){return h&&f?e(h.__data__,f.__data__):!h-!f}for(var r=this._groups,n=r.length,i=new Array(n),o=0;o<n;++o){for(var a=r[o],s=a.length,l=i[o]=new Array(s),c,u=0;u<s;++u)(c=a[u])&&(l[u]=c);l.sort(t)}return new pi(i,this._parents).order()}function MAe(e,t){return e<t?-1:e>t?1:e>=t?0:NaN}var u4t=M(()=>{ef()});function h4t(){var e=arguments[0];return arguments[0]=this,e.apply(null,arguments),this}var f4t=M(()=>{});function p4t(){var e=new Array(this.size()),t=-1;return this.each(function(){e[++t]=this}),e}var d4t=M(()=>{});function m4t(){for(var e=this._groups,t=0,r=e.length;t<r;++t)for(var n=e[t],i=0,o=n.length;i<o;++i){var a=n[i];if(a)return a}return null}var g4t=M(()=>{});function _4t(){var e=0;return this.each(function(){++e}),e}var y4t=M(()=>{});function v4t(){return!this.node()}var x4t=M(()=>{});function b4t(e){for(var t=this._groups,r=0,n=t.length;r<n;++r)for(var i=t[r],o=0,a=i.length,s;o<a;++o)(s=i[o])&&e.call(s,s.__data__,o,i);return this}var w4t=M(()=>{});function EAe(e){return function(){this.removeAttribute(e)}}function TAe(e){return function(){this.removeAttributeNS(e.space,e.local)}}function CAe(e,t){return function(){this.setAttribute(e,t)}}function AAe(e,t){return function(){this.setAttributeNS(e.space,e.local,t)}}function PAe(e,t){return function(){var r=t.apply(this,arguments);r==null?this.removeAttribute(e):this.setAttribute(e,r)}}function IAe(e,t){return function(){var r=t.apply(this,arguments);r==null?this.removeAttributeNS(e.space,e.local):this.setAttributeNS(e.space,e.local,r)}}function S4t(e,t){var r=dN(e);if(arguments.length<2){var n=this.node();return r.local?n.getAttributeNS(r.space,r.local):n.getAttribute(r)}return this.each((t==null?r.local?TAe:EAe:typeof t=="function"?r.local?IAe:PAe:r.local?AAe:CAe)(r,t))}var M4t=M(()=>{uZ()});function yN(e){return e.ownerDocument&&e.ownerDocument.defaultView||e.document&&e||e.defaultView}var mZ=M(()=>{});function LAe(e){return function(){this.style.removeProperty(e)}}function kAe(e,t,r){return function(){this.style.setProperty(e,t,r)}}function RAe(e,t,r){return function(){var n=t.apply(this,arguments);n==null?this.style.removeProperty(e):this.style.setProperty(e,n,r)}}function E4t(e,t,r){return arguments.length>1?this.each((t==null?LAe:typeof t=="function"?RAe:kAe)(e,t,r==null?"":r)):NAe(this.node(),e)}function NAe(e,t){return e.style.getPropertyValue(t)||yN(e).getComputedStyle(e,null).getPropertyValue(t)}var T4t=M(()=>{mZ()});function DAe(e){return function(){delete this[e]}}function OAe(e,t){return function(){this[e]=t}}function zAe(e,t){return function(){var r=t.apply(this,arguments);r==null?delete this[e]:this[e]=r}}function C4t(e,t){return arguments.length>1?this.each((t==null?DAe:typeof t=="function"?zAe:OAe)(e,t)):this.node()[e]}var A4t=M(()=>{});function P4t(e){return e.trim().split(/^|\s+/)}function gZ(e){return e.classList||new I4t(e)}function I4t(e){this._node=e,this._names=P4t(e.getAttribute("class")||"")}function L4t(e,t){for(var r=gZ(e),n=-1,i=t.length;++n<i;)r.add(t[n])}function k4t(e,t){for(var r=gZ(e),n=-1,i=t.length;++n<i;)r.remove(t[n])}function FAe(e){return function(){L4t(this,e)}}function BAe(e){return function(){k4t(this,e)}}function HAe(e,t){return function(){(t.apply(this,arguments)?L4t:k4t)(this,e)}}function R4t(e,t){var r=P4t(e+"");if(arguments.length<2){for(var n=gZ(this.node()),i=-1,o=r.length;++i<o;)if(!n.contains(r[i]))return!1;return!0}return this.each((typeof t=="function"?HAe:t?FAe:BAe)(r,t))}var N4t=M(()=>{I4t.prototype={add:function(e){var t=this._names.indexOf(e);t<0&&(this._names.push(e),this._node.setAttribute("class",this._names.join(" ")))},remove:function(e){var t=this._names.indexOf(e);t>=0&&(this._names.splice(t,1),this._node.setAttribute("class",this._names.join(" ")))},contains:function(e){return this._names.indexOf(e)>=0}}});function VAe(){this.textContent=""}function UAe(e){return function(){this.textContent=e}}function qAe(e){return function(){var t=e.apply(this,arguments);this.textContent=t==null?"":t}}function D4t(e){return arguments.length?this.each(e==null?VAe:(typeof e=="function"?qAe:UAe)(e)):this.node().textContent}var O4t=M(()=>{});function GAe(){this.innerHTML=""}function WAe(e){return function(){this.innerHTML=e}}function YAe(e){return function(){var t=e.apply(this,arguments);this.innerHTML=t==null?"":t}}function z4t(e){return arguments.length?this.each(e==null?GAe:(typeof e=="function"?YAe:WAe)(e)):this.node().innerHTML}var F4t=M(()=>{});function jAe(){this.nextSibling&&this.parentNode.appendChild(this)}function B4t(){return this.each(jAe)}var H4t=M(()=>{});function XAe(){this.previousSibling&&this.parentNode.insertBefore(this,this.parentNode.firstChild)}function V4t(){return this.each(XAe)}var U4t=M(()=>{});function q4t(e){var t=typeof e=="function"?e:mN(e);return this.select(function(){return this.appendChild(t.apply(this,arguments))})}var G4t=M(()=>{hZ()});function $Ae(){return null}function W4t(e,t){var r=typeof e=="function"?e:mN(e),n=t==null?$Ae:typeof t=="function"?t:gN(t);return this.select(function(){return this.insertBefore(r.apply(this,arguments),n.apply(this,arguments)||null)})}var Y4t=M(()=>{hZ();fZ()});function KAe(){var e=this.parentNode;e&&e.removeChild(this)}function j4t(){return this.each(KAe)}var X4t=M(()=>{});function ZAe(){var e=this.cloneNode(!1),t=this.parentNode;return t?t.insertBefore(e,this.nextSibling):e}function JAe(){var e=this.cloneNode(!0),t=this.parentNode;return t?t.insertBefore(e,this.nextSibling):e}function $4t(e){return this.select(e?JAe:ZAe)}var K4t=M(()=>{});function Z4t(e){return arguments.length?this.property("__data__",e):this.node().__data__}var J4t=M(()=>{});function QAe(e,t,r){return e=ePt(e,t,r),function(n){var i=n.relatedTarget;(!i||i!==this&&!(i.compareDocumentPosition(this)&8))&&e.call(this,n)}}function ePt(e,t,r){return function(n){var i=sn;sn=n;try{e.call(this,this.__data__,t,r)}finally{sn=i}}}function t4e(e){return e.trim().split(/^|\s+/).map(function(t){var r="",n=t.indexOf(".");return n>=0&&(r=t.slice(n+1),t=t.slice(0,n)),{type:t,name:r}})}function e4e(e){return function(){var t=this.__on;if(!!t){for(var r=0,n=-1,i=t.length,o;r<i;++r)o=t[r],(!e.type||o.type===e.type)&&o.name===e.name?this.removeEventListener(o.type,o.listener,o.capture):t[++n]=o;++n?t.length=n:delete this.__on}}}function r4e(e,t,r){var n=tPt.hasOwnProperty(e.type)?QAe:ePt;return function(i,o,a){var s=this.__on,l,c=n(t,o,a);if(s){for(var u=0,h=s.length;u<h;++u)if((l=s[u]).type===e.type&&l.name===e.name){this.removeEventListener(l.type,l.listener,l.capture),this.addEventListener(l.type,l.listener=c,l.capture=r),l.value=t;return}}this.addEventListener(e.type,c,r),l={type:e.type,name:e.name,value:t,listener:c,capture:r},s?s.push(l):this.__on=[l]}}function rPt(e,t,r){var n=t4e(e+""),i,o=n.length,a;if(arguments.length<2){var s=this.node().__on;if(s){for(var l=0,c=s.length,u;l<c;++l)for(i=0,u=s[l];i<o;++i)if((a=n[i]).type===u.type&&a.name===u.name)return u.value}return}for(s=t?r4e:e4e,r==null&&(r=!1),i=0;i<o;++i)this.each(s(n[i],t,r));return this}function vN(e,t,r,n){var i=sn;e.sourceEvent=sn,sn=e;try{return t.apply(r,n)}finally{sn=i}}var tPt,sn,Q4t,xN=M(()=>{tPt={},sn=null;typeof document!="undefined"&&(Q4t=document.documentElement,"onmouseenter"in Q4t||(tPt={mouseenter:"mouseover",mouseleave:"mouseout"}))});function nPt(e,t,r){var n=yN(e),i=n.CustomEvent;typeof i=="function"?i=new i(t,r):(i=n.document.createEvent("Event"),r?(i.initEvent(t,r.bubbles,r.cancelable),i.detail=r.detail):i.initEvent(t,!1,!1)),e.dispatchEvent(i)}function n4e(e,t){return function(){return nPt(this,e,t)}}function i4e(e,t){return function(){return nPt(this,e,t.apply(this,arguments))}}function iPt(e,t){return this.each((typeof t=="function"?i4e:n4e)(e,t))}var oPt=M(()=>{mZ()});function pi(e,t){this._groups=e,this._parents=t}function o4e(){return new pi([[document.documentElement]],_Z)}var _Z,ef=M(()=>{HAt();GAt();XAt();t4t();dZ();r4t();i4t();a4t();l4t();u4t();f4t();d4t();g4t();y4t();x4t();w4t();M4t();T4t();A4t();N4t();O4t();F4t();H4t();U4t();G4t();Y4t();X4t();K4t();J4t();xN();oPt();_Z=[null];pi.prototype=o4e.prototype={constructor:pi,select:BAt,selectAll:qAt,filter:jAt,data:QAt,enter:$At,exit:e4t,join:n4t,merge:o4t,order:s4t,sort:c4t,call:h4t,nodes:p4t,node:m4t,size:_4t,empty:v4t,each:b4t,attr:S4t,style:E4t,property:C4t,classed:R4t,text:D4t,html:z4t,raise:B4t,lower:V4t,append:q4t,insert:W4t,remove:j4t,clone:$4t,datum:Z4t,on:rPt,dispatch:iPt}});function Ey(e){return typeof e=="string"?new pi([[document.querySelector(e)]],[document.documentElement]):new pi([[e]],_Z)}var aPt=M(()=>{ef()});function bN(){for(var e=sn,t;t=e.sourceEvent;)e=t;return e}var yZ=M(()=>{xN()});function wN(e,t){var r=e.ownerSVGElement||e;if(r.createSVGPoint){var n=r.createSVGPoint();return n.x=t.clientX,n.y=t.clientY,n=n.matrixTransform(e.getScreenCTM().inverse()),[n.x,n.y]}var i=e.getBoundingClientRect();return[t.clientX-i.left-e.clientLeft,t.clientY-i.top-e.clientTop]}var vZ=M(()=>{});function xZ(e){var t=bN();return t.changedTouches&&(t=t.changedTouches[0]),wN(e,t)}var sPt=M(()=>{yZ();vZ()});function bZ(e,t,r){arguments.length<3&&(r=t,t=bN().changedTouches);for(var n=0,i=t?t.length:0,o;n<i;++n)if((o=t[n]).identifier===r)return wN(e,o);return null}var lPt=M(()=>{yZ();vZ()});var SN=M(()=>{sPt();aPt();lPt();xN()});function MN(){sn.stopImmediatePropagation()}function fg(){sn.preventDefault(),sn.stopImmediatePropagation()}var wZ=M(()=>{SN()});function EN(e){var t=e.document.documentElement,r=Ey(e).on("dragstart.drag",fg,!0);"onselectstart"in t?r.on("selectstart.drag",fg,!0):(t.__noselect=t.style.MozUserSelect,t.style.MozUserSelect="none")}function TN(e,t){var r=e.document.documentElement,n=Ey(e).on("dragstart.drag",null);t&&(n.on("click.drag",fg,!0),setTimeout(function(){n.on("click.drag",null)},0)),"onselectstart"in r?n.on("selectstart.drag",null):(r.style.MozUserSelect=r.__noselect,delete r.__noselect)}var SZ=M(()=>{SN();wZ()});function vT(e){return function(){return e}}var cPt=M(()=>{});function xT(e,t,r,n,i,o,a,s,l,c){this.target=e,this.type=t,this.subject=r,this.identifier=n,this.active=i,this.x=o,this.y=a,this.dx=s,this.dy=l,this._=c}var uPt=M(()=>{xT.prototype.on=function(){var e=this._.on.apply(this._,arguments);return e===this._?this:e}});function a4e(){return!sn.button}function s4e(){return this.parentNode}function l4e(e){return e==null?{x:sn.x,y:sn.y}:e}function c4e(){return"ontouchstart"in this}function hPt(){var e=a4e,t=s4e,r=l4e,n=c4e,i={},o=sZ("start","drag","end"),a=0,s,l,c,u,h=0;function f(S){S.on("mousedown.drag",p).filter(n).on("touchstart.drag",_).on("touchmove.drag",y).on("touchend.drag touchcancel.drag",x).style("touch-action","none").style("-webkit-tap-highlight-color","rgba(0,0,0,0)")}function p(){if(!(u||!e.apply(this,arguments))){var S=b("mouse",t.apply(this,arguments),xZ,this,arguments);!S||(Ey(sn.view).on("mousemove.drag",d,!0).on("mouseup.drag",g,!0),EN(sn.view),MN(),c=!1,s=sn.clientX,l=sn.clientY,S("start"))}}function d(){if(fg(),!c){var S=sn.clientX-s,C=sn.clientY-l;c=S*S+C*C>h}i.mouse("drag")}function g(){Ey(sn.view).on("mousemove.drag mouseup.drag",null),TN(sn.view,c),fg(),i.mouse("end")}function _(){if(!!e.apply(this,arguments)){var S=sn.changedTouches,C=t.apply(this,arguments),P=S.length,k,O;for(k=0;k<P;++k)(O=b(S[k].identifier,C,bZ,this,arguments))&&(MN(),O("start"))}}function y(){var S=sn.changedTouches,C=S.length,P,k;for(P=0;P<C;++P)(k=i[S[P].identifier])&&(fg(),k("drag"))}function x(){var S=sn.changedTouches,C=S.length,P,k;for(u&&clearTimeout(u),u=setTimeout(function(){u=null},500),P=0;P<C;++P)(k=i[S[P].identifier])&&(MN(),k("end"))}function b(S,C,P,k,O){var D=P(C,S),B,I,L,R=o.copy();if(!!vN(new xT(f,"beforestart",B,S,a,D[0],D[1],0,0,R),function(){return(sn.subject=B=r.apply(k,O))==null?!1:(I=B.x-D[0]||0,L=B.y-D[1]||0,!0)}))return function F(z){var U=D,W;switch(z){case"start":i[S]=F,W=a++;break;case"end":delete i[S],--a;case"drag":D=P(C,S),W=a;break}vN(new xT(f,z,B,S,W,D[0]+I,D[1]+L,D[0]-U[0],D[1]-U[1],R),R.apply,R,[z,k,O])}}return f.filter=function(S){return arguments.length?(e=typeof S=="function"?S:vT(!!S),f):e},f.container=function(S){return arguments.length?(t=typeof S=="function"?S:vT(S),f):t},f.subject=function(S){return arguments.length?(r=typeof S=="function"?S:vT(S),f):r},f.touchable=function(S){return arguments.length?(n=typeof S=="function"?S:vT(!!S),f):n},f.on=function(){var S=o.on.apply(o,arguments);return S===o?f:S},f.clickDistance=function(S){return arguments.length?(h=(S=+S)*S,f):Math.sqrt(h)},f}var fPt=M(()=>{FAt();SN();SZ();wZ();cPt();uPt()});var pPt=M(()=>{fPt();SZ()});function mPt(e){return new Function("d","return {"+e.map(function(t,r){return JSON.stringify(t)+": d["+r+"]"}).join(",")+"}")}function u4e(e,t){var r=mPt(e);return function(n,i){return t(r(n),i,e)}}function h4e(e){var t=Object.create(null),r=[];return e.forEach(function(n){for(var i in n)i in t||r.push(t[i]=i)}),r}function w2(e){var t=new RegExp('["'+e+`
\r]`),r=e.charCodeAt(0);function n(c,u){var h,f,p=i(c,function(d,g){if(h)return h(d,g-1);f=d,h=u?u4e(d,u):mPt(d)});return p.columns=f||[],p}function i(c,u){var h=[],f=c.length,p=0,d=0,g,_=f<=0,y=!1;c.charCodeAt(f-1)===bT&&--f,c.charCodeAt(f-1)===TZ&&--f;function x(){if(_)return MZ;if(y)return y=!1,dPt;var S,C=p,P;if(c.charCodeAt(C)===EZ){for(;p++<f&&c.charCodeAt(p)!==EZ||c.charCodeAt(++p)===EZ;);return(S=p)>=f?_=!0:(P=c.charCodeAt(p++))===bT?y=!0:P===TZ&&(y=!0,c.charCodeAt(p)===bT&&++p),c.slice(C+1,S-1).replace(/""/g,'"')}for(;p<f;){if((P=c.charCodeAt(S=p++))===bT)y=!0;else if(P===TZ)y=!0,c.charCodeAt(p)===bT&&++p;else if(P!==r)continue;return c.slice(C,S)}return _=!0,c.slice(C,f)}for(;(g=x())!==MZ;){for(var b=[];g!==dPt&&g!==MZ;)b.push(g),g=x();u&&(b=u(b,d++))==null||h.push(b)}return h}function o(c,u){return u==null&&(u=h4e(c)),[u.map(l).join(e)].concat(c.map(function(h){return u.map(function(f){return l(h[f])}).join(e)})).join(`
`)}function a(c){return c.map(s).join(`
`)}function s(c){return c.map(l).join(e)}function l(c){return c==null?"":t.test(c+="")?'"'+c.replace(/"/g,'""')+'"':c}return{parse:n,parseRows:i,format:o,formatRows:a}}var dPt,MZ,EZ,bT,TZ,CN=M(()=>{dPt={},MZ={},EZ=34,bT=10,TZ=13});var AN,gPt,_Pt,yPt,vPt,xPt=M(()=>{CN();AN=w2(","),gPt=AN.parse,_Pt=AN.parseRows,yPt=AN.format,vPt=AN.formatRows});var PN,bPt,wPt,SPt,MPt,EPt=M(()=>{CN();PN=w2("	"),bPt=PN.parse,wPt=PN.parseRows,SPt=PN.format,MPt=PN.formatRows});var TPt=M(()=>{CN();xPt();EPt()});function CPt(e){return+e}var APt=M(()=>{});function PPt(e){return e*e}function IPt(e){return e*(2-e)}function CZ(e){return((e*=2)<=1?e*e:--e*(2-e)+1)/2}var LPt=M(()=>{});function kPt(e){return e*e*e}function RPt(e){return--e*e*e+1}function AZ(e){return((e*=2)<=1?e*e*e:(e-=2)*e*e+2)/2}var NPt=M(()=>{});var PZ,DPt,OPt,IZ,zPt=M(()=>{PZ=3,DPt=function e(t){t=+t;function r(n){return Math.pow(n,t)}return r.exponent=e,r}(PZ),OPt=function e(t){t=+t;function r(n){return 1-Math.pow(1-n,t)}return r.exponent=e,r}(PZ),IZ=function e(t){t=+t;function r(n){return((n*=2)<=1?Math.pow(n,t):2-Math.pow(2-n,t))/2}return r.exponent=e,r}(PZ)});function HPt(e){return 1-Math.cos(e*BPt)}function VPt(e){return Math.sin(e*BPt)}function LZ(e){return(1-Math.cos(FPt*e))/2}var FPt,BPt,UPt=M(()=>{FPt=Math.PI,BPt=FPt/2});function qPt(e){return Math.pow(2,10*e-10)}function GPt(e){return 1-Math.pow(2,-10*e)}function kZ(e){return((e*=2)<=1?Math.pow(2,10*e-10):2-Math.pow(2,10-10*e))/2}var WPt=M(()=>{});function YPt(e){return 1-Math.sqrt(1-e*e)}function jPt(e){return Math.sqrt(1- --e*e)}function RZ(e){return((e*=2)<=1?1-Math.sqrt(1-e*e):Math.sqrt(1-(e-=2)*e)+1)/2}var XPt=M(()=>{});function $Pt(e){return 1-S2(1-e)}function S2(e){return(e=+e)<NZ?IN*e*e:e<p4e?IN*(e-=f4e)*e+d4e:e<g4e?IN*(e-=m4e)*e+_4e:IN*(e-=y4e)*e+v4e}function KPt(e){return((e*=2)<=1?1-S2(1-e):S2(e-1)+1)/2}var NZ,f4e,p4e,d4e,m4e,g4e,_4e,y4e,v4e,IN,ZPt=M(()=>{NZ=.36363636363636365,f4e=6/11,p4e=8/11,d4e=3/4,m4e=9/11,g4e=10/11,_4e=15/16,y4e=21/22,v4e=63/64,IN=1/NZ/NZ});var DZ,JPt,QPt,OZ,t6t=M(()=>{DZ=1.70158,JPt=function e(t){t=+t;function r(n){return n*n*((t+1)*n-t)}return r.overshoot=e,r}(DZ),QPt=function e(t){t=+t;function r(n){return--n*n*((t+1)*n+t)+1}return r.overshoot=e,r}(DZ),OZ=function e(t){t=+t;function r(n){return((n*=2)<1?n*n*((t+1)*n-t):(n-=2)*n*((t+1)*n+t)+2)/2}return r.overshoot=e,r}(DZ)});var M2,zZ,FZ,e6t,BZ,r6t,n6t=M(()=>{M2=2*Math.PI,zZ=1,FZ=.3,e6t=function e(t,r){var n=Math.asin(1/(t=Math.max(1,t)))*(r/=M2);function i(o){return t*Math.pow(2,10*--o)*Math.sin((n-o)/r)}return i.amplitude=function(o){return e(o,r*M2)},i.period=function(o){return e(t,o)},i}(zZ,FZ),BZ=function e(t,r){var n=Math.asin(1/(t=Math.max(1,t)))*(r/=M2);function i(o){return 1-t*Math.pow(2,-10*(o=+o))*Math.sin((o+n)/r)}return i.amplitude=function(o){return e(o,r*M2)},i.period=function(o){return e(t,o)},i}(zZ,FZ),r6t=function e(t,r){var n=Math.asin(1/(t=Math.max(1,t)))*(r/=M2);function i(o){return((o=o*2-1)<0?t*Math.pow(2,10*o)*Math.sin((n-o)/r):2-t*Math.pow(2,-10*o)*Math.sin((n+o)/r))/2}return i.amplitude=function(o){return e(o,r*M2)},i.period=function(o){return e(t,o)},i}(zZ,FZ)});var i6t=M(()=>{APt();LPt();NPt();zPt();UPt();WPt();XPt();ZPt();t6t();n6t()});function o6t(e,t){var r;e==null&&(e=0),t==null&&(t=0);function n(){var i,o=r.length,a,s=0,l=0;for(i=0;i<o;++i)a=r[i],s+=a.x,l+=a.y;for(s=s/o-e,l=l/o-t,i=0;i<o;++i)a=r[i],a.x-=s,a.y-=l}return n.initialize=function(i){r=i},n.x=function(i){return arguments.length?(e=+i,n):e},n.y=function(i){return arguments.length?(t=+i,n):t},n}var a6t=M(()=>{});function zn(e){return function(){return e}}var Ty=M(()=>{});function Mu(){return(Math.random()-.5)*1e-6}var LN=M(()=>{});function s6t(e){var t=+this._x.call(null,e),r=+this._y.call(null,e);return l6t(this.cover(t,r),t,r,e)}function l6t(e,t,r,n){if(isNaN(t)||isNaN(r))return e;var i,o=e._root,a={data:n},s=e._x0,l=e._y0,c=e._x1,u=e._y1,h,f,p,d,g,_,y,x;if(!o)return e._root=a,e;for(;o.length;)if((g=t>=(h=(s+c)/2))?s=h:c=h,(_=r>=(f=(l+u)/2))?l=f:u=f,i=o,!(o=o[y=_<<1|g]))return i[y]=a,e;if(p=+e._x.call(null,o.data),d=+e._y.call(null,o.data),t===p&&r===d)return a.next=o,i?i[y]=a:e._root=a,e;do i=i?i[y]=new Array(4):e._root=new Array(4),(g=t>=(h=(s+c)/2))?s=h:c=h,(_=r>=(f=(l+u)/2))?l=f:u=f;while((y=_<<1|g)===(x=(d>=f)<<1|p>=h));return i[x]=o,i[y]=a,e}function c6t(e){var t,r,n=e.length,i,o,a=new Array(n),s=new Array(n),l=1/0,c=1/0,u=-1/0,h=-1/0;for(r=0;r<n;++r)isNaN(i=+this._x.call(null,t=e[r]))||isNaN(o=+this._y.call(null,t))||(a[r]=i,s[r]=o,i<l&&(l=i),i>u&&(u=i),o<c&&(c=o),o>h&&(h=o));if(l>u||c>h)return this;for(this.cover(l,c).cover(u,h),r=0;r<n;++r)l6t(this,a[r],s[r],e[r]);return this}var u6t=M(()=>{});function h6t(e,t){if(isNaN(e=+e)||isNaN(t=+t))return this;var r=this._x0,n=this._y0,i=this._x1,o=this._y1;if(isNaN(r))i=(r=Math.floor(e))+1,o=(n=Math.floor(t))+1;else{for(var a=i-r,s=this._root,l,c;r>e||e>=i||n>t||t>=o;)switch(c=(t<n)<<1|e<r,l=new Array(4),l[c]=s,s=l,a*=2,c){case 0:i=r+a,o=n+a;break;case 1:r=i-a,o=n+a;break;case 2:i=r+a,n=o-a;break;case 3:r=i-a,n=o-a;break}this._root&&this._root.length&&(this._root=s)}return this._x0=r,this._y0=n,this._x1=i,this._y1=o,this}var f6t=M(()=>{});function p6t(){var e=[];return this.visit(function(t){if(!t.length)do e.push(t.data);while(t=t.next)}),e}var d6t=M(()=>{});function m6t(e){return arguments.length?this.cover(+e[0][0],+e[0][1]).cover(+e[1][0],+e[1][1]):isNaN(this._x0)?void 0:[[this._x0,this._y0],[this._x1,this._y1]]}var g6t=M(()=>{});function So(e,t,r,n,i){this.node=e,this.x0=t,this.y0=r,this.x1=n,this.y1=i}var kN=M(()=>{});function _6t(e,t,r){var n,i=this._x0,o=this._y0,a,s,l,c,u=this._x1,h=this._y1,f=[],p=this._root,d,g;for(p&&f.push(new So(p,i,o,u,h)),r==null?r=1/0:(i=e-r,o=t-r,u=e+r,h=t+r,r*=r);d=f.pop();)if(!(!(p=d.node)||(a=d.x0)>u||(s=d.y0)>h||(l=d.x1)<i||(c=d.y1)<o))if(p.length){var _=(a+l)/2,y=(s+c)/2;f.push(new So(p[3],_,y,l,c),new So(p[2],a,y,_,c),new So(p[1],_,s,l,y),new So(p[0],a,s,_,y)),(g=(t>=y)<<1|e>=_)&&(d=f[f.length-1],f[f.length-1]=f[f.length-1-g],f[f.length-1-g]=d)}else{var x=e-+this._x.call(null,p.data),b=t-+this._y.call(null,p.data),S=x*x+b*b;if(S<r){var C=Math.sqrt(r=S);i=e-C,o=t-C,u=e+C,h=t+C,n=p.data}}return n}var y6t=M(()=>{kN()});function v6t(e){if(isNaN(u=+this._x.call(null,e))||isNaN(h=+this._y.call(null,e)))return this;var t,r=this._root,n,i,o,a=this._x0,s=this._y0,l=this._x1,c=this._y1,u,h,f,p,d,g,_,y;if(!r)return this;if(r.length)for(;;){if((d=u>=(f=(a+l)/2))?a=f:l=f,(g=h>=(p=(s+c)/2))?s=p:c=p,t=r,!(r=r[_=g<<1|d]))return this;if(!r.length)break;(t[_+1&3]||t[_+2&3]||t[_+3&3])&&(n=t,y=_)}for(;r.data!==e;)if(i=r,!(r=r.next))return this;return(o=r.next)&&delete r.next,i?(o?i.next=o:delete i.next,this):t?(o?t[_]=o:delete t[_],(r=t[0]||t[1]||t[2]||t[3])&&r===(t[3]||t[2]||t[1]||t[0])&&!r.length&&(n?n[y]=r:this._root=r),this):(this._root=o,this)}function x6t(e){for(var t=0,r=e.length;t<r;++t)this.remove(e[t]);return this}var b6t=M(()=>{});function w6t(){return this._root}var S6t=M(()=>{});function M6t(){var e=0;return this.visit(function(t){if(!t.length)do++e;while(t=t.next)}),e}var E6t=M(()=>{});function T6t(e){var t=[],r,n=this._root,i,o,a,s,l;for(n&&t.push(new So(n,this._x0,this._y0,this._x1,this._y1));r=t.pop();)if(!e(n=r.node,o=r.x0,a=r.y0,s=r.x1,l=r.y1)&&n.length){var c=(o+s)/2,u=(a+l)/2;(i=n[3])&&t.push(new So(i,c,u,s,l)),(i=n[2])&&t.push(new So(i,o,u,c,l)),(i=n[1])&&t.push(new So(i,c,a,s,u)),(i=n[0])&&t.push(new So(i,o,a,c,u))}return this}var C6t=M(()=>{kN()});function A6t(e){var t=[],r=[],n;for(this._root&&t.push(new So(this._root,this._x0,this._y0,this._x1,this._y1));n=t.pop();){var i=n.node;if(i.length){var o,a=n.x0,s=n.y0,l=n.x1,c=n.y1,u=(a+l)/2,h=(s+c)/2;(o=i[0])&&t.push(new So(o,a,s,u,h)),(o=i[1])&&t.push(new So(o,u,s,l,h)),(o=i[2])&&t.push(new So(o,a,h,u,c)),(o=i[3])&&t.push(new So(o,u,h,l,c))}r.push(n)}for(;n=r.pop();)e(n.node,n.x0,n.y0,n.x1,n.y1);return this}var P6t=M(()=>{kN()});function I6t(e){return e[0]}function L6t(e){return arguments.length?(this._x=e,this):this._x}var k6t=M(()=>{});function R6t(e){return e[1]}function N6t(e){return arguments.length?(this._y=e,this):this._y}var D6t=M(()=>{});function Cy(e,t,r){var n=new HZ(t==null?I6t:t,r==null?R6t:r,NaN,NaN,NaN,NaN);return e==null?n:n.addAll(e)}function HZ(e,t,r,n,i,o){this._x=e,this._y=t,this._x0=r,this._y0=n,this._x1=i,this._y1=o,this._root=void 0}function O6t(e){for(var t={data:e.data},r=t;e=e.next;)r=r.next={data:e.data};return t}var Ga,z6t=M(()=>{u6t();f6t();d6t();g6t();y6t();b6t();S6t();E6t();C6t();P6t();k6t();D6t();Ga=Cy.prototype=HZ.prototype;Ga.copy=function(){var e=new HZ(this._x,this._y,this._x0,this._y0,this._x1,this._y1),t=this._root,r,n;if(!t)return e;if(!t.length)return e._root=O6t(t),e;for(r=[{source:t,target:e._root=new Array(4)}];t=r.pop();)for(var i=0;i<4;++i)(n=t.source[i])&&(n.length?r.push({source:n,target:t.target[i]=new Array(4)}):t.target[i]=O6t(n));return e};Ga.add=s6t;Ga.addAll=c6t;Ga.cover=h6t;Ga.data=p6t;Ga.extent=m6t;Ga.find=_6t;Ga.remove=v6t;Ga.removeAll=x6t;Ga.root=w6t;Ga.size=M6t;Ga.visit=T6t;Ga.visitAfter=A6t;Ga.x=L6t;Ga.y=N6t});var VZ=M(()=>{z6t()});function x4e(e){return e.x+e.vx}function b4e(e){return e.y+e.vy}function F6t(e){var t,r,n=1,i=1;typeof e!="function"&&(e=zn(e==null?1:+e));function o(){for(var l,c=t.length,u,h,f,p,d,g,_=0;_<i;++_)for(u=Cy(t,x4e,b4e).visitAfter(a),l=0;l<c;++l)h=t[l],d=r[h.index],g=d*d,f=h.x+h.vx,p=h.y+h.vy,u.visit(y);function y(x,b,S,C,P){var k=x.data,O=x.r,D=d+O;if(k){if(k.index>h.index){var B=f-k.x-k.vx,I=p-k.y-k.vy,L=B*B+I*I;L<D*D&&(B===0&&(B=Mu(),L+=B*B),I===0&&(I=Mu(),L+=I*I),L=(D-(L=Math.sqrt(L)))/L*n,h.vx+=(B*=L)*(D=(O*=O)/(g+O)),h.vy+=(I*=L)*D,k.vx-=B*(D=1-D),k.vy-=I*D)}return}return b>f+D||C<f-D||S>p+D||P<p-D}}function a(l){if(l.data)return l.r=r[l.data.index];for(var c=l.r=0;c<4;++c)l[c]&&l[c].r>l.r&&(l.r=l[c].r)}function s(){if(!!t){var l,c=t.length,u;for(r=new Array(c),l=0;l<c;++l)u=t[l],r[u.index]=+e(u,l,t)}}return o.initialize=function(l){t=l,s()},o.iterations=function(l){return arguments.length?(i=+l,o):i},o.strength=function(l){return arguments.length?(n=+l,o):n},o.radius=function(l){return arguments.length?(e=typeof l=="function"?l:zn(+l),s(),o):e},o}var B6t=M(()=>{Ty();LN();VZ()});function RN(){}function H6t(e,t){var r=new RN;if(e instanceof RN)e.each(function(s,l){r.set(l,s)});else if(Array.isArray(e)){var n=-1,i=e.length,o;if(t==null)for(;++n<i;)r.set(n,e[n]);else for(;++n<i;)r.set(t(o=e[n],n,e),o)}else if(e)for(var a in e)r.set(a,e[a]);return r}var cl,pg,NN=M(()=>{cl="$";RN.prototype=H6t.prototype={constructor:RN,has:function(e){return cl+e in this},get:function(e){return this[cl+e]},set:function(e,t){return this[cl+e]=t,this},remove:function(e){var t=cl+e;return t in this&&delete this[t]},clear:function(){for(var e in this)e[0]===cl&&delete this[e]},keys:function(){var e=[];for(var t in this)t[0]===cl&&e.push(t.slice(1));return e},values:function(){var e=[];for(var t in this)t[0]===cl&&e.push(this[t]);return e},entries:function(){var e=[];for(var t in this)t[0]===cl&&e.push({key:t.slice(1),value:this[t]});return e},size:function(){var e=0;for(var t in this)t[0]===cl&&++e;return e},empty:function(){for(var e in this)if(e[0]===cl)return!1;return!0},each:function(e){for(var t in this)t[0]===cl&&e(this[t],t.slice(1),this)}};pg=H6t});var V6t=M(()=>{NN()});function DN(){}function w4e(e,t){var r=new DN;if(e instanceof DN)e.each(function(o){r.add(o)});else if(e){var n=-1,i=e.length;if(t==null)for(;++n<i;)r.add(e[n]);else for(;++n<i;)r.add(t(e[n],n,e))}return r}var Ay,U6t=M(()=>{NN();Ay=pg.prototype;DN.prototype=w4e.prototype={constructor:DN,has:Ay.has,add:function(e){return e+="",this[cl+e]=e,this},remove:Ay.remove,clear:Ay.clear,values:Ay.keys,size:Ay.size,empty:Ay.empty,each:Ay.each}});var q6t=M(()=>{});var G6t=M(()=>{});var W6t=M(()=>{});var UZ=M(()=>{V6t();U6t();NN();q6t();G6t();W6t()});function S4e(e){return e.index}function Y6t(e,t){var r=e.get(t);if(!r)throw new Error("missing: "+t);return r}function j6t(e){var t=S4e,r=u,n,i=zn(30),o,a,s,l,c=1;e==null&&(e=[]);function u(g){return 1/Math.min(s[g.source.index],s[g.target.index])}function h(g){for(var _=0,y=e.length;_<c;++_)for(var x=0,b,S,C,P,k,O,D;x<y;++x)b=e[x],S=b.source,C=b.target,P=C.x+C.vx-S.x-S.vx||Mu(),k=C.y+C.vy-S.y-S.vy||Mu(),O=Math.sqrt(P*P+k*k),O=(O-o[x])/O*g*n[x],P*=O,k*=O,C.vx-=P*(D=l[x]),C.vy-=k*D,S.vx+=P*(D=1-D),S.vy+=k*D}function f(){if(!!a){var g,_=a.length,y=e.length,x=pg(a,t),b;for(g=0,s=new Array(_);g<y;++g)b=e[g],b.index=g,typeof b.source!="object"&&(b.source=Y6t(x,b.source)),typeof b.target!="object"&&(b.target=Y6t(x,b.target)),s[b.source.index]=(s[b.source.index]||0)+1,s[b.target.index]=(s[b.target.index]||0)+1;for(g=0,l=new Array(y);g<y;++g)b=e[g],l[g]=s[b.source.index]/(s[b.source.index]+s[b.target.index]);n=new Array(y),p(),o=new Array(y),d()}}function p(){if(!!a)for(var g=0,_=e.length;g<_;++g)n[g]=+r(e[g],g,e)}function d(){if(!!a)for(var g=0,_=e.length;g<_;++g)o[g]=+i(e[g],g,e)}return h.initialize=function(g){a=g,f()},h.links=function(g){return arguments.length?(e=g,f(),h):e},h.id=function(g){return arguments.length?(t=g,h):t},h.iterations=function(g){return arguments.length?(c=+g,h):c},h.strength=function(g){return arguments.length?(r=typeof g=="function"?g:zn(+g),p(),h):r},h.distance=function(g){return arguments.length?(i=typeof g=="function"?g:zn(+g),d(),h):i},h}var X6t=M(()=>{Ty();LN();UZ()});function K6t(){for(var e=0,t=arguments.length,r={},n;e<t;++e){if(!(n=arguments[e]+"")||n in r||/[\s.]/.test(n))throw new Error("illegal type: "+n);r[n]=[]}return new ON(r)}function ON(e){this._=e}function E4e(e,t){return e.trim().split(/^|\s+/).map(function(r){var n="",i=r.indexOf(".");if(i>=0&&(n=r.slice(i+1),r=r.slice(0,i)),r&&!t.hasOwnProperty(r))throw new Error("unknown type: "+r);return{type:r,name:n}})}function T4e(e,t){for(var r=0,n=e.length,i;r<n;++r)if((i=e[r]).name===t)return i.value}function $6t(e,t,r){for(var n=0,i=e.length;n<i;++n)if(e[n].name===t){e[n]=M4e,e=e.slice(0,n).concat(e.slice(n+1));break}return r!=null&&e.push({name:t,value:r}),e}var M4e,qZ,Z6t=M(()=>{M4e={value:function(){}};ON.prototype=K6t.prototype={constructor:ON,on:function(e,t){var r=this._,n=E4e(e+"",r),i,o=-1,a=n.length;if(arguments.length<2){for(;++o<a;)if((i=(e=n[o]).type)&&(i=T4e(r[i],e.name)))return i;return}if(t!=null&&typeof t!="function")throw new Error("invalid callback: "+t);for(;++o<a;)if(i=(e=n[o]).type)r[i]=$6t(r[i],e.name,t);else if(t==null)for(i in r)r[i]=$6t(r[i],e.name,null);return this},copy:function(){var e={},t=this._;for(var r in t)e[r]=t[r].slice();return new ON(e)},call:function(e,t){if((i=arguments.length-2)>0)for(var r=new Array(i),n=0,i,o;n<i;++n)r[n]=arguments[n+2];if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(o=this._[e],n=0,i=o.length;n<i;++n)o[n].value.apply(t,r)},apply:function(e,t,r){if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(var n=this._[e],i=0,o=n.length;i<o;++i)n[i].value.apply(t,r)}};qZ=K6t});var J6t=M(()=>{Z6t()});function YZ(){return Py||(eIt(C4e),Py=ET.now()+BN)}function C4e(){Py=0}function GZ(){this._call=this._time=this._next=null}function HN(e,t,r){var n=new GZ;return n.restart(e,t,r),n}function rIt(){YZ(),++E2;for(var e=zN,t;e;)(t=Py-e._time)>=0&&e._call.call(null,t),e=e._next;--E2}function Q6t(){Py=(FN=ET.now())+BN,E2=ST=0;try{rIt()}finally{E2=0,P4e(),Py=0}}function A4e(){var e=ET.now(),t=e-FN;t>tIt&&(BN-=t,FN=e)}function P4e(){for(var e,t=zN,r,n=1/0;t;)t._call?(n>t._time&&(n=t._time),e=t,t=t._next):(r=t._next,t._next=null,t=e?e._next=r:zN=r);MT=e,WZ(n)}function WZ(e){if(!E2){ST&&(ST=clearTimeout(ST));var t=e-Py;t>24?(e<1/0&&(ST=setTimeout(Q6t,e-ET.now()-BN)),wT&&(wT=clearInterval(wT))):(wT||(FN=ET.now(),wT=setInterval(A4e,tIt)),E2=1,eIt(Q6t))}}var E2,ST,wT,tIt,zN,MT,FN,Py,BN,ET,eIt,nIt=M(()=>{E2=0,ST=0,wT=0,tIt=1e3,FN=0,Py=0,BN=0,ET=typeof performance=="object"&&performance.now?performance:Date,eIt=typeof window=="object"&&window.requestAnimationFrame?window.requestAnimationFrame.bind(window):function(e){setTimeout(e,17)};GZ.prototype=HN.prototype={constructor:GZ,restart:function(e,t,r){if(typeof e!="function")throw new TypeError("callback is not a function");r=(r==null?YZ():+r)+(t==null?0:+t),!this._next&&MT!==this&&(MT?MT._next=this:zN=this,MT=this),this._call=e,this._time=r,WZ()},stop:function(){this._call&&(this._call=null,this._time=1/0,WZ())}}});var iIt=M(()=>{nIt()});function oIt(e){return e.x}function aIt(e){return e.y}function sIt(e){var t,r=1,n=.001,i=1-Math.pow(n,1/300),o=0,a=.6,s=pg(),l=HN(u),c=qZ("tick","end");e==null&&(e=[]);function u(){h(),c.call("tick",t),r<n&&(l.stop(),c.call("end",t))}function h(){var d,g=e.length,_;for(r+=(o-r)*i,s.each(function(y){y(r)}),d=0;d<g;++d)_=e[d],_.fx==null?_.x+=_.vx*=a:(_.x=_.fx,_.vx=0),_.fy==null?_.y+=_.vy*=a:(_.y=_.fy,_.vy=0)}function f(){for(var d=0,g=e.length,_;d<g;++d){if(_=e[d],_.index=d,isNaN(_.x)||isNaN(_.y)){var y=I4e*Math.sqrt(d),x=d*L4e;_.x=y*Math.cos(x),_.y=y*Math.sin(x)}(isNaN(_.vx)||isNaN(_.vy))&&(_.vx=_.vy=0)}}function p(d){return d.initialize&&d.initialize(e),d}return f(),t={tick:h,restart:function(){return l.restart(u),t},stop:function(){return l.stop(),t},nodes:function(d){return arguments.length?(e=d,f(),s.each(p),t):e},alpha:function(d){return arguments.length?(r=+d,t):r},alphaMin:function(d){return arguments.length?(n=+d,t):n},alphaDecay:function(d){return arguments.length?(i=+d,t):+i},alphaTarget:function(d){return arguments.length?(o=+d,t):o},velocityDecay:function(d){return arguments.length?(a=1-d,t):1-a},force:function(d,g){return arguments.length>1?(g==null?s.remove(d):s.set(d,p(g)),t):s.get(d)},find:function(d,g,_){var y=0,x=e.length,b,S,C,P,k;for(_==null?_=1/0:_*=_,y=0;y<x;++y)P=e[y],b=d-P.x,S=g-P.y,C=b*b+S*S,C<_&&(k=P,_=C);return k},on:function(d,g){return arguments.length>1?(c.on(d,g),t):c.on(d)}}}var I4e,L4e,jZ=M(()=>{J6t();UZ();iIt();I4e=10,L4e=Math.PI*(3-Math.sqrt(5))});function lIt(){var e,t,r,n=zn(-30),i,o=1,a=1/0,s=.81;function l(f){var p,d=e.length,g=Cy(e,oIt,aIt).visitAfter(u);for(r=f,p=0;p<d;++p)t=e[p],g.visit(h)}function c(){if(!!e){var f,p=e.length,d;for(i=new Array(p),f=0;f<p;++f)d=e[f],i[d.index]=+n(d,f,e)}}function u(f){var p=0,d,g,_=0,y,x,b;if(f.length){for(y=x=b=0;b<4;++b)(d=f[b])&&(g=Math.abs(d.value))&&(p+=d.value,_+=g,y+=g*d.x,x+=g*d.y);f.x=y/_,f.y=x/_}else{d=f,d.x=d.data.x,d.y=d.data.y;do p+=i[d.data.index];while(d=d.next)}f.value=p}function h(f,p,d,g){if(!f.value)return!0;var _=f.x-t.x,y=f.y-t.y,x=g-p,b=_*_+y*y;if(x*x/s<b)return b<a&&(_===0&&(_=Mu(),b+=_*_),y===0&&(y=Mu(),b+=y*y),b<o&&(b=Math.sqrt(o*b)),t.vx+=_*f.value*r/b,t.vy+=y*f.value*r/b),!0;if(f.length||b>=a)return;(f.data!==t||f.next)&&(_===0&&(_=Mu(),b+=_*_),y===0&&(y=Mu(),b+=y*y),b<o&&(b=Math.sqrt(o*b)));do f.data!==t&&(x=i[f.data.index]*r/b,t.vx+=_*x,t.vy+=y*x);while(f=f.next)}return l.initialize=function(f){e=f,c()},l.strength=function(f){return arguments.length?(n=typeof f=="function"?f:zn(+f),c(),l):n},l.distanceMin=function(f){return arguments.length?(o=f*f,l):Math.sqrt(o)},l.distanceMax=function(f){return arguments.length?(a=f*f,l):Math.sqrt(a)},l.theta=function(f){return arguments.length?(s=f*f,l):Math.sqrt(s)},l}var cIt=M(()=>{Ty();LN();VZ();jZ()});function uIt(e,t,r){var n,i=zn(.1),o,a;typeof e!="function"&&(e=zn(+e)),t==null&&(t=0),r==null&&(r=0);function s(c){for(var u=0,h=n.length;u<h;++u){var f=n[u],p=f.x-t||1e-6,d=f.y-r||1e-6,g=Math.sqrt(p*p+d*d),_=(a[u]-g)*o[u]*c/g;f.vx+=p*_,f.vy+=d*_}}function l(){if(!!n){var c,u=n.length;for(o=new Array(u),a=new Array(u),c=0;c<u;++c)a[c]=+e(n[c],c,n),o[c]=isNaN(a[c])?0:+i(n[c],c,n)}}return s.initialize=function(c){n=c,l()},s.strength=function(c){return arguments.length?(i=typeof c=="function"?c:zn(+c),l(),s):i},s.radius=function(c){return arguments.length?(e=typeof c=="function"?c:zn(+c),l(),s):e},s.x=function(c){return arguments.length?(t=+c,s):t},s.y=function(c){return arguments.length?(r=+c,s):r},s}var hIt=M(()=>{Ty()});function fIt(e){var t=zn(.1),r,n,i;typeof e!="function"&&(e=zn(e==null?0:+e));function o(s){for(var l=0,c=r.length,u;l<c;++l)u=r[l],u.vx+=(i[l]-u.x)*n[l]*s}function a(){if(!!r){var s,l=r.length;for(n=new Array(l),i=new Array(l),s=0;s<l;++s)n[s]=isNaN(i[s]=+e(r[s],s,r))?0:+t(r[s],s,r)}}return o.initialize=function(s){r=s,a()},o.strength=function(s){return arguments.length?(t=typeof s=="function"?s:zn(+s),a(),o):t},o.x=function(s){return arguments.length?(e=typeof s=="function"?s:zn(+s),a(),o):e},o}var pIt=M(()=>{Ty()});function dIt(e){var t=zn(.1),r,n,i;typeof e!="function"&&(e=zn(e==null?0:+e));function o(s){for(var l=0,c=r.length,u;l<c;++l)u=r[l],u.vy+=(i[l]-u.y)*n[l]*s}function a(){if(!!r){var s,l=r.length;for(n=new Array(l),i=new Array(l),s=0;s<l;++s)n[s]=isNaN(i[s]=+e(r[s],s,r))?0:+t(r[s],s,r)}}return o.initialize=function(s){r=s,a()},o.strength=function(s){return arguments.length?(t=typeof s=="function"?s:zn(+s),a(),o):t},o.y=function(s){return arguments.length?(e=typeof s=="function"?s:zn(+s),a(),o):e},o}var mIt=M(()=>{Ty()});var gIt=M(()=>{a6t();B6t();X6t();cIt();hIt();jZ();pIt();mIt()});function Iy(e,t){if((r=(e=t?e.toExponential(t-1):e.toExponential()).indexOf("e"))<0)return null;var r,n=e.slice(0,r);return[n.length>1?n[0]+n.slice(2):n,+e.slice(r+1)]}var VN=M(()=>{});function rf(e){return e=Iy(Math.abs(e)),e?e[1]:NaN}var TT=M(()=>{VN()});function _It(e,t){return function(r,n){for(var i=r.length,o=[],a=0,s=e[0],l=0;i>0&&s>0&&(l+s+1>n&&(s=Math.max(1,n-l)),o.push(r.substring(i-=s,i+s)),!((l+=s+1)>n));)s=e[a=(a+1)%e.length];return o.reverse().join(t)}}var yIt=M(()=>{});function vIt(e){return function(t){return t.replace(/[0-9]/g,function(r){return e[+r]})}}var xIt=M(()=>{});function bIt(e,t){e=e.toPrecision(t);t:for(var r=e.length,n=1,i=-1,o;n<r;++n)switch(e[n]){case".":i=o=n;break;case"0":i===0&&(i=n),o=n;break;case"e":break t;default:i>0&&(i=0);break}return i>0?e.slice(0,i)+e.slice(o+1):e}var wIt=M(()=>{});function SIt(e,t){var r=Iy(e,t);if(!r)return e+"";var n=r[0],i=r[1],o=i-(XZ=Math.max(-8,Math.min(8,Math.floor(i/3)))*3)+1,a=n.length;return o===a?n:o>a?n+new Array(o-a+1).join("0"):o>0?n.slice(0,o)+"."+n.slice(o):"0."+new Array(1-o).join("0")+Iy(e,Math.max(0,t+o-1))[0]}var XZ,$Z=M(()=>{VN()});function KZ(e,t){var r=Iy(e,t);if(!r)return e+"";var n=r[0],i=r[1];return i<0?"0."+new Array(-i).join("0")+n:n.length>i+1?n.slice(0,i+1)+"."+n.slice(i+1):n+new Array(i-n.length+2).join("0")}var MIt=M(()=>{VN()});var UN,ZZ=M(()=>{wIt();$Z();MIt();UN={"":bIt,"%":function(e,t){return(e*100).toFixed(t)},b:function(e){return Math.round(e).toString(2)},c:function(e){return e+""},d:function(e){return Math.round(e).toString(10)},e:function(e,t){return e.toExponential(t)},f:function(e,t){return e.toFixed(t)},g:function(e,t){return e.toPrecision(t)},o:function(e){return Math.round(e).toString(8)},p:function(e,t){return KZ(e*100,t)},r:KZ,s:SIt,X:function(e){return Math.round(e).toString(16).toUpperCase()},x:function(e){return Math.round(e).toString(16)}}});function Ly(e){return new JZ(e)}function JZ(e){if(!(t=k4e.exec(e)))throw new Error("invalid format: "+e);var t,r=t[1]||" ",n=t[2]||">",i=t[3]||"-",o=t[4]||"",a=!!t[5],s=t[6]&&+t[6],l=!!t[7],c=t[8]&&+t[8].slice(1),u=t[9]||"";u==="n"?(l=!0,u="g"):UN[u]||(u=""),(a||r==="0"&&n==="=")&&(a=!0,r="0",n="="),this.fill=r,this.align=n,this.sign=i,this.symbol=o,this.zero=a,this.width=s,this.comma=l,this.precision=c,this.type=u}var k4e,QZ=M(()=>{ZZ();k4e=/^(?:(.)?([<>=^]))?([+\-\( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?([a-z%])?$/i;Ly.prototype=JZ.prototype;JZ.prototype.toString=function(){return this.fill+this.align+this.sign+this.symbol+(this.zero?"0":"")+(this.width==null?"":Math.max(1,this.width|0))+(this.comma?",":"")+(this.precision==null?"":"."+Math.max(0,this.precision|0))+this.type}});function tJ(e){return e}var EIt=M(()=>{});function qN(e){var t=e.grouping&&e.thousands?_It(e.grouping,e.thousands):tJ,r=e.currency,n=e.decimal,i=e.numerals?vIt(e.numerals):tJ,o=e.percent||"%";function a(l){l=Ly(l);var c=l.fill,u=l.align,h=l.sign,f=l.symbol,p=l.zero,d=l.width,g=l.comma,_=l.precision,y=l.type,x=f==="$"?r[0]:f==="#"&&/[boxX]/.test(y)?"0"+y.toLowerCase():"",b=f==="$"?r[1]:/[%p]/.test(y)?o:"",S=UN[y],C=!y||/[defgprs%]/.test(y);_=_==null?y?6:12:/[gprs]/.test(y)?Math.max(1,Math.min(21,_)):Math.max(0,Math.min(20,_));function P(k){var O=x,D=b,B,I,L;if(y==="c")D=S(k)+D,k="";else{k=+k;var R=k<0;if(k=S(Math.abs(k),_),R&&+k==0&&(R=!1),O=(R?h==="("?h:"-":h==="-"||h==="("?"":h)+O,D=(y==="s"?TIt[8+XZ/3]:"")+D+(R&&h==="("?")":""),C){for(B=-1,I=k.length;++B<I;)if(L=k.charCodeAt(B),48>L||L>57){D=(L===46?n+k.slice(B+1):k.slice(B))+D,k=k.slice(0,B);break}}}g&&!p&&(k=t(k,1/0));var F=O.length+k.length+D.length,z=F<d?new Array(d-F+1).join(c):"";switch(g&&p&&(k=t(z+k,z.length?d-D.length:1/0),z=""),u){case"<":k=O+k+D+z;break;case"=":k=O+z+k+D;break;case"^":k=z.slice(0,F=z.length>>1)+O+k+D+z.slice(F);break;default:k=z+O+k+D;break}return i(k)}return P.toString=function(){return l+""},P}function s(l,c){var u=a((l=Ly(l),l.type="f",l)),h=Math.max(-8,Math.min(8,Math.floor(rf(c)/3)))*3,f=Math.pow(10,-h),p=TIt[8+h/3];return function(d){return u(f*d)+p}}return{format:a,formatPrefix:s}}var TIt,eJ=M(()=>{TT();yIt();xIt();QZ();ZZ();$Z();EIt();TIt=["y","z","a","f","p","n","\xB5","m","","k","M","G","T","P","E","Z","Y"]});function WN(e){return GN=qN(e),rJ=GN.format,nJ=GN.formatPrefix,GN}var GN,rJ,nJ,CIt=M(()=>{eJ();WN({decimal:".",thousands:",",grouping:[3],currency:["$",""]})});function AIt(e){return Math.max(0,-rf(Math.abs(e)))}var PIt=M(()=>{TT()});function IIt(e,t){return Math.max(0,Math.max(-8,Math.min(8,Math.floor(rf(t)/3)))*3-rf(Math.abs(e)))}var LIt=M(()=>{TT()});function kIt(e,t){return e=Math.abs(e),t=Math.abs(t)-e,Math.max(0,rf(t)-rf(e))+1}var RIt=M(()=>{TT()});var NIt=M(()=>{CIt();eJ();QZ();PIt();LIt();RIt()});function Cs(){return new jN}function jN(){this.reset()}function DIt(e,t,r){var n=e.s=t+r,i=n-t,o=n-i;e.t=t-o+(r-i)}var YN,ky=M(()=>{jN.prototype={constructor:jN,reset:function(){this.s=this.t=0},add:function(e){DIt(YN,e,this.t),DIt(this,YN.s,this.s),this.s?this.t+=YN.t:this.s=YN.t},valueOf:function(){return this.s}};YN=new jN});function KN(e){return e>1?0:e<-1?rr:Math.acos(e)}function Zn(e){return e>1?Fn:e<-1?-Fn:Math.asin(e)}function oJ(e){return(e=Jt(e/2))*e}var ce,iJ,rr,Fn,T2,Bi,Ur,we,Ye,yc,Sn,ae,CT,XN,Ry,$N,Jt,dg,Rr,C2,lr=M(()=>{ce=1e-6,iJ=1e-12,rr=Math.PI,Fn=rr/2,T2=rr/4,Bi=rr*2,Ur=180/rr,we=rr/180,Ye=Math.abs,yc=Math.atan,Sn=Math.atan2,ae=Math.cos,CT=Math.ceil,XN=Math.exp,Ry=Math.log,$N=Math.pow,Jt=Math.sin,dg=Math.sign||function(e){return e>0?1:e<0?-1:0},Rr=Math.sqrt,C2=Math.tan});function qr(){}var Xp=M(()=>{});function ZN(e,t){e&&zIt.hasOwnProperty(e.type)&&zIt[e.type](e,t)}function aJ(e,t,r){var n=-1,i=e.length-r,o;for(t.lineStart();++n<i;)o=e[n],t.point(o[0],o[1],o[2]);t.lineEnd()}function FIt(e,t){var r=-1,n=e.length;for(t.polygonStart();++r<n;)aJ(e[r],t,1);t.polygonEnd()}function Mo(e,t){e&&OIt.hasOwnProperty(e.type)?OIt[e.type](e,t):ZN(e,t)}var OIt,zIt,mg=M(()=>{OIt={Feature:function(e,t){ZN(e.geometry,t)},FeatureCollection:function(e,t){for(var r=e.features,n=-1,i=r.length;++n<i;)ZN(r[n].geometry,t)}},zIt={Sphere:function(e,t){t.sphere()},Point:function(e,t){e=e.coordinates,t.point(e[0],e[1],e[2])},MultiPoint:function(e,t){for(var r=e.coordinates,n=-1,i=r.length;++n<i;)e=r[n],t.point(e[0],e[1],e[2])},LineString:function(e,t){aJ(e.coordinates,t,0)},MultiLineString:function(e,t){for(var r=e.coordinates,n=-1,i=r.length;++n<i;)aJ(r[n],t,0)},Polygon:function(e,t){FIt(e.coordinates,t)},MultiPolygon:function(e,t){for(var r=e.coordinates,n=-1,i=r.length;++n<i;)FIt(r[n],t)},GeometryCollection:function(e,t){for(var r=e.geometries,n=-1,i=r.length;++n<i;)ZN(r[n],t)}}});function R4e(){Eu.point=D4e}function N4e(){VIt(BIt,HIt)}function D4e(e,t){Eu.point=VIt,BIt=e,HIt=t,e*=we,t*=we,sJ=e,lJ=ae(t=t/2+T2),cJ=Jt(t)}function VIt(e,t){e*=we,t*=we,t=t/2+T2;var r=e-sJ,n=r>=0?1:-1,i=n*r,o=ae(t),a=Jt(t),s=cJ*a,l=lJ*o+s*ae(i),c=s*n*Jt(i);AT.add(Sn(c,l)),sJ=e,lJ=o,cJ=a}function UIt(e){return JN.reset(),Mo(e,Eu),JN*2}var AT,JN,BIt,HIt,sJ,lJ,cJ,Eu,uJ=M(()=>{ky();lr();Xp();mg();AT=Cs(),JN=Cs(),Eu={point:qr,lineStart:qr,lineEnd:qr,polygonStart:function(){AT.reset(),Eu.lineStart=R4e,Eu.lineEnd=N4e},polygonEnd:function(){var e=+AT;JN.add(e<0?Bi+e:e),this.lineStart=this.lineEnd=this.point=qr},sphere:function(){JN.add(Bi)}}});function Ny(e){return[Sn(e[1],e[0]),Zn(e[2])]}function vc(e){var t=e[0],r=e[1],n=ae(r);return[n*ae(t),n*Jt(t),Jt(r)]}function PT(e,t){return e[0]*t[0]+e[1]*t[1]+e[2]*t[2]}function $p(e,t){return[e[1]*t[2]-e[2]*t[1],e[2]*t[0]-e[0]*t[2],e[0]*t[1]-e[1]*t[0]]}function QN(e,t){e[0]+=t[0],e[1]+=t[1],e[2]+=t[2]}function IT(e,t){return[e[0]*t,e[1]*t,e[2]*t]}function Dy(e){var t=Rr(e[0]*e[0]+e[1]*e[1]+e[2]*e[2]);e[0]/=t,e[1]/=t,e[2]/=t}var A2=M(()=>{lr()});function hJ(e,t){gg.push(Zp=[di=e,Ei=e]),t<hl&&(hl=t),t>xc&&(xc=t)}function XIt(e,t){var r=vc([e*we,t*we]);if(P2){var n=$p(P2,r),i=[n[1],-n[0],0],o=$p(i,n);Dy(o),o=Ny(o);var a=e-Oy,s=a>0?1:-1,l=o[0]*Ur*s,c,u=Ye(a)>180;u^(s*Oy<l&&l<s*e)?(c=o[1]*Ur,c>xc&&(xc=c)):(l=(l+360)%360-180,u^(s*Oy<l&&l<s*e)?(c=-o[1]*Ur,c<hl&&(hl=c)):(t<hl&&(hl=t),t>xc&&(xc=t))),u?e<Oy?ul(di,e)>ul(di,Ei)&&(Ei=e):ul(e,Ei)>ul(di,Ei)&&(di=e):Ei>=di?(e<di&&(di=e),e>Ei&&(Ei=e)):e>Oy?ul(di,e)>ul(di,Ei)&&(Ei=e):ul(e,Ei)>ul(di,Ei)&&(di=e)}else gg.push(Zp=[di=e,Ei=e]);t<hl&&(hl=t),t>xc&&(xc=t),P2=r,Oy=e}function qIt(){Kp.point=XIt}function GIt(){Zp[0]=di,Zp[1]=Ei,Kp.point=hJ,P2=null}function $It(e,t){if(P2){var r=e-Oy;LT.add(Ye(r)>180?r+(r>0?360:-360):r)}else YIt=e,jIt=t;Eu.point(e,t),XIt(e,t)}function O4e(){Eu.lineStart()}function z4e(){$It(YIt,jIt),Eu.lineEnd(),Ye(LT)>ce&&(di=-(Ei=180)),Zp[0]=di,Zp[1]=Ei,P2=null}function ul(e,t){return(t-=e)<0?t+360:t}function F4e(e,t){return e[0]-t[0]}function WIt(e,t){return e[0]<=e[1]?e[0]<=t&&t<=e[1]:t<e[0]||e[1]<t}function KIt(e){var t,r,n,i,o,a,s;if(xc=Ei=-(di=hl=1/0),gg=[],Mo(e,Kp),r=gg.length){for(gg.sort(F4e),t=1,n=gg[0],o=[n];t<r;++t)i=gg[t],WIt(n,i[0])||WIt(n,i[1])?(ul(n[0],i[1])>ul(n[0],n[1])&&(n[1]=i[1]),ul(i[0],n[1])>ul(n[0],n[1])&&(n[0]=i[0])):o.push(n=i);for(a=-1/0,r=o.length-1,t=0,n=o[r];t<=r;n=i,++t)i=o[t],(s=ul(n[1],i[0]))>a&&(a=s,di=i[0],Ei=n[1])}return gg=Zp=null,di===1/0||hl===1/0?[[NaN,NaN],[NaN,NaN]]:[[di,hl],[Ei,xc]]}var di,hl,Ei,xc,Oy,YIt,jIt,P2,LT,gg,Zp,Kp,ZIt=M(()=>{ky();uJ();A2();lr();mg();LT=Cs(),Kp={point:hJ,lineStart:qIt,lineEnd:GIt,polygonStart:function(){Kp.point=$It,Kp.lineStart=O4e,Kp.lineEnd=z4e,LT.reset(),Eu.polygonStart()},polygonEnd:function(){Eu.polygonEnd(),Kp.point=hJ,Kp.lineStart=qIt,Kp.lineEnd=GIt,AT<0?(di=-(Ei=180),hl=-(xc=90)):LT>ce?xc=90:LT<-ce&&(hl=-90),Zp[0]=di,Zp[1]=Ei}}});function mJ(e,t){e*=we,t*=we;var r=ae(t);RT(r*ae(e),r*Jt(e),Jt(t))}function RT(e,t,r){++kT,eD+=(e-eD)/kT,rD+=(t-rD)/kT,nD+=(r-nD)/kT}function JIt(){Tu.point=B4e}function B4e(e,t){e*=we,t*=we;var r=ae(t);Wa=r*ae(e),Ya=r*Jt(e),ja=Jt(t),Tu.point=H4e,RT(Wa,Ya,ja)}function H4e(e,t){e*=we,t*=we;var r=ae(t),n=r*ae(e),i=r*Jt(e),o=Jt(t),a=Sn(Rr((a=Ya*o-ja*i)*a+(a=ja*n-Wa*o)*a+(a=Wa*i-Ya*n)*a),Wa*n+Ya*i+ja*o);tD+=a,iD+=a*(Wa+(Wa=n)),oD+=a*(Ya+(Ya=i)),aD+=a*(ja+(ja=o)),RT(Wa,Ya,ja)}function QIt(){Tu.point=mJ}function V4e(){Tu.point=q4e}function U4e(){r9t(t9t,e9t),Tu.point=mJ}function q4e(e,t){t9t=e,e9t=t,e*=we,t*=we,Tu.point=r9t;var r=ae(t);Wa=r*ae(e),Ya=r*Jt(e),ja=Jt(t),RT(Wa,Ya,ja)}function r9t(e,t){e*=we,t*=we;var r=ae(t),n=r*ae(e),i=r*Jt(e),o=Jt(t),a=Ya*o-ja*i,s=ja*n-Wa*o,l=Wa*i-Ya*n,c=Rr(a*a+s*s+l*l),u=Zn(c),h=c&&-u/c;fJ+=h*a,pJ+=h*s,dJ+=h*l,tD+=u,iD+=u*(Wa+(Wa=n)),oD+=u*(Ya+(Ya=i)),aD+=u*(ja+(ja=o)),RT(Wa,Ya,ja)}function n9t(e){kT=tD=eD=rD=nD=iD=oD=aD=fJ=pJ=dJ=0,Mo(e,Tu);var t=fJ,r=pJ,n=dJ,i=t*t+r*r+n*n;return i<iJ&&(t=iD,r=oD,n=aD,tD<ce&&(t=eD,r=rD,n=nD),i=t*t+r*r+n*n,i<iJ)?[NaN,NaN]:[Sn(r,t)*Ur,Zn(n/Rr(i))*Ur]}var kT,tD,eD,rD,nD,iD,oD,aD,fJ,pJ,dJ,t9t,e9t,Wa,Ya,ja,Tu,i9t=M(()=>{lr();Xp();mg();Tu={sphere:qr,point:mJ,lineStart:JIt,lineEnd:QIt,polygonStart:function(){Tu.lineStart=V4e,Tu.lineEnd=U4e},polygonEnd:function(){Tu.lineStart=JIt,Tu.lineEnd=QIt}}});function zy(e){return function(){return e}}var o9t=M(()=>{});function sD(e,t){function r(n,i){return n=e(n,i),t(n[0],n[1])}return e.invert&&t.invert&&(r.invert=function(n,i){return n=t.invert(n,i),n&&e.invert(n[0],n[1])}),r}var gJ=M(()=>{});function _J(e,t){return[e>rr?e-Bi:e<-rr?e+Bi:e,t]}function NT(e,t,r){return(e%=Bi)?t||r?sD(s9t(e),l9t(t,r)):s9t(e):t||r?l9t(t,r):_J}function a9t(e){return function(t,r){return t+=e,[t>rr?t-Bi:t<-rr?t+Bi:t,r]}}function s9t(e){var t=a9t(e);return t.invert=a9t(-e),t}function l9t(e,t){var r=ae(e),n=Jt(e),i=ae(t),o=Jt(t);function a(s,l){var c=ae(l),u=ae(s)*c,h=Jt(s)*c,f=Jt(l),p=f*r+u*n;return[Sn(h*i-p*o,u*r-f*n),Zn(p*i+h*o)]}return a.invert=function(s,l){var c=ae(l),u=ae(s)*c,h=Jt(s)*c,f=Jt(l),p=f*i-h*o;return[Sn(h*i+f*o,u*r+p*n),Zn(p*r-u*n)]},a}function lD(e){e=NT(e[0]*we,e[1]*we,e.length>2?e[2]*we:0);function t(r){return r=e(r[0]*we,r[1]*we),r[0]*=Ur,r[1]*=Ur,r}return t.invert=function(r){return r=e.invert(r[0]*we,r[1]*we),r[0]*=Ur,r[1]*=Ur,r},t}var DT=M(()=>{gJ();lr();_J.invert=_J});function yJ(e,t,r,n,i,o){if(!!r){var a=ae(t),s=Jt(t),l=n*r;i==null?(i=t+n*Bi,o=t-l/2):(i=c9t(a,i),o=c9t(a,o),(n>0?i<o:i>o)&&(i+=n*Bi));for(var c,u=i;n>0?u>o:u<o;u-=l)c=Ny([a,-s*ae(u),-s*Jt(u)]),e.point(c[0],c[1])}}function c9t(e,t){t=vc(t),t[0]-=e,Dy(t);var r=KN(-t[1]);return((-t[2]<0?-r:r)+Bi-ce)%Bi}function u9t(){var e=zy([0,0]),t=zy(90),r=zy(6),n,i,o={point:a};function a(l,c){n.push(l=i(l,c)),l[0]*=Ur,l[1]*=Ur}function s(){var l=e.apply(this,arguments),c=t.apply(this,arguments)*we,u=r.apply(this,arguments)*we;return n=[],i=NT(-l[0]*we,-l[1]*we,0).invert,yJ(o,c,u,1),l={type:"Polygon",coordinates:[n]},n=i=null,l}return s.center=function(l){return arguments.length?(e=typeof l=="function"?l:zy([+l[0],+l[1]]),s):e},s.radius=function(l){return arguments.length?(t=typeof l=="function"?l:zy(+l),s):t},s.precision=function(l){return arguments.length?(r=typeof l=="function"?l:zy(+l),s):r},s}var vJ=M(()=>{A2();o9t();lr();DT()});function cD(){var e=[],t;return{point:function(r,n){t.push([r,n])},lineStart:function(){e.push(t=[])},lineEnd:qr,rejoin:function(){e.length>1&&e.push(e.pop().concat(e.shift()))},result:function(){var r=e;return e=[],t=null,r}}}var xJ=M(()=>{Xp()});function I2(e,t){return Ye(e[0]-t[0])<ce&&Ye(e[1]-t[1])<ce}var bJ=M(()=>{lr()});function uD(e,t,r,n){this.x=e,this.z=t,this.o=r,this.e=n,this.v=!1,this.n=this.p=null}function hD(e,t,r,n,i){var o=[],a=[],s,l;if(e.forEach(function(d){if(!((g=d.length-1)<=0)){var g,_=d[0],y=d[g],x;if(I2(_,y)){for(i.lineStart(),s=0;s<g;++s)i.point((_=d[s])[0],_[1]);i.lineEnd();return}o.push(x=new uD(_,d,null,!0)),a.push(x.o=new uD(_,null,x,!1)),o.push(x=new uD(y,d,null,!1)),a.push(x.o=new uD(y,null,x,!0))}}),!!o.length){for(a.sort(t),h9t(o),h9t(a),s=0,l=a.length;s<l;++s)a[s].e=r=!r;for(var c=o[0],u,h;;){for(var f=c,p=!0;f.v;)if((f=f.n)===c)return;u=f.z,i.lineStart();do{if(f.v=f.o.v=!0,f.e){if(p)for(s=0,l=u.length;s<l;++s)i.point((h=u[s])[0],h[1]);else n(f.x,f.n.x,1,i);f=f.n}else{if(p)for(u=f.p.z,s=u.length-1;s>=0;--s)i.point((h=u[s])[0],h[1]);else n(f.x,f.p.x,-1,i);f=f.p}f=f.o,u=f.z,p=!p}while(!f.v);i.lineEnd()}}}function h9t(e){if(!!(t=e.length)){for(var t,r=0,n=e[0],i;++r<t;)n.n=i=e[r],i.p=n,n=i;n.n=i=e[0],i.p=n}}var wJ=M(()=>{bJ()});function fD(e,t){var r=t[0],n=t[1],i=[Jt(r),-ae(r),0],o=0,a=0;SJ.reset();for(var s=0,l=e.length;s<l;++s)if(!!(u=(c=e[s]).length))for(var c,u,h=c[u-1],f=h[0],p=h[1]/2+T2,d=Jt(p),g=ae(p),_=0;_<u;++_,f=x,d=S,g=C,h=y){var y=c[_],x=y[0],b=y[1]/2+T2,S=Jt(b),C=ae(b),P=x-f,k=P>=0?1:-1,O=k*P,D=O>rr,B=d*S;if(SJ.add(Sn(B*k*Jt(O),g*C+B*ae(O))),o+=D?P+k*Bi:P,D^f>=r^x>=r){var I=$p(vc(h),vc(y));Dy(I);var L=$p(i,I);Dy(L);var R=(D^P>=0?-1:1)*Zn(L[2]);(n>R||n===R&&(I[0]||I[1]))&&(a+=D^P>=0?1:-1)}}return(o<-ce||o<ce&&SJ<-ce)^a&1}var SJ,MJ=M(()=>{ky();A2();lr();SJ=Cs()});function _g(e,t){return e<t?-1:e>t?1:e>=t?0:NaN}var Fy=M(()=>{});function EJ(e){return e.length===1&&(e=G4e(e)),{left:function(t,r,n,i){for(n==null&&(n=0),i==null&&(i=t.length);n<i;){var o=n+i>>>1;e(t[o],r)<0?n=o+1:i=o}return n},right:function(t,r,n,i){for(n==null&&(n=0),i==null&&(i=t.length);n<i;){var o=n+i>>>1;e(t[o],r)>0?i=o:n=o+1}return n}}}function G4e(e){return function(t,r){return _g(e(t),r)}}var TJ=M(()=>{Fy()});var f9t,W4e,Y4e,CJ=M(()=>{Fy();TJ();f9t=EJ(_g),W4e=f9t.right,Y4e=f9t.left});var AJ=M(()=>{});var p9t=M(()=>{AJ()});var d9t=M(()=>{});var L2=M(()=>{});var PJ=M(()=>{L2()});var IJ=M(()=>{PJ()});var LJ=M(()=>{});var m9t,X4e,$4e,kJ=M(()=>{m9t=Array.prototype,X4e=m9t.slice,$4e=m9t.map});var g9t=M(()=>{});var _9t=M(()=>{});function Jp(e,t,r){e=+e,t=+t,r=(i=arguments.length)<2?(t=e,e=0,1):i<3?1:+r;for(var n=-1,i=Math.max(0,Math.ceil((t-e)/r))|0,o=new Array(i);++n<i;)o[n]=e+n*r;return o}var RJ=M(()=>{});var k0n,R0n,N0n,NJ=M(()=>{k0n=Math.sqrt(50),R0n=Math.sqrt(10),N0n=Math.sqrt(2)});var DJ=M(()=>{});var y9t=M(()=>{kJ();CJ();g9t();LJ();_9t();RJ();NJ();DJ()});var dD=M(()=>{L2()});var x9t=M(()=>{kJ();Fy();L2();dD()});var b9t=M(()=>{IJ()});var w9t=M(()=>{});var S9t=M(()=>{L2()});var M9t=M(()=>{Fy();L2();dD()});function OT(e){for(var t=e.length,r,n=-1,i=0,o,a;++n<t;)i+=e[n].length;for(o=new Array(i);--t>=0;)for(a=e[t],r=a.length;--r>=0;)o[--i]=a[r];return o}var E9t=M(()=>{});var OJ=M(()=>{});var T9t=M(()=>{});var C9t=M(()=>{Fy()});var A9t=M(()=>{});var P9t=M(()=>{});var zJ=M(()=>{OJ()});var I9t=M(()=>{zJ()});var mD=M(()=>{CJ();Fy();TJ();p9t();d9t();IJ();LJ();y9t();x9t();b9t();DJ();w9t();S9t();M9t();E9t();OJ();AJ();T9t();dD();RJ();C9t();A9t();P9t();NJ();zJ();PJ();I9t()});function gD(e,t,r,n){return function(i){var o=t(i),a=cD(),s=t(a),l=!1,c,u,h,f={point:p,lineStart:g,lineEnd:_,polygonStart:function(){f.point=y,f.lineStart=x,f.lineEnd=b,u=[],c=[]},polygonEnd:function(){f.point=p,f.lineStart=g,f.lineEnd=_,u=OT(u);var S=fD(c,n);u.length?(l||(i.polygonStart(),l=!0),hD(u,iPe,S,r,i)):S&&(l||(i.polygonStart(),l=!0),i.lineStart(),r(null,null,1,i),i.lineEnd()),l&&(i.polygonEnd(),l=!1),u=c=null},sphere:function(){i.polygonStart(),i.lineStart(),r(null,null,1,i),i.lineEnd(),i.polygonEnd()}};function p(S,C){e(S,C)&&i.point(S,C)}function d(S,C){o.point(S,C)}function g(){f.point=d,o.lineStart()}function _(){f.point=p,o.lineEnd()}function y(S,C){h.push([S,C]),s.point(S,C)}function x(){s.lineStart(),h=[]}function b(){y(h[0][0],h[0][1]),s.lineEnd();var S=s.clean(),C=a.result(),P,k=C.length,O,D,B;if(h.pop(),c.push(h),h=null,!!k){if(S&1){if(D=C[0],(O=D.length-1)>0){for(l||(i.polygonStart(),l=!0),i.lineStart(),P=0;P<O;++P)i.point((B=D[P])[0],B[1]);i.lineEnd()}return}k>1&&S&2&&C.push(C.pop().concat(C.shift())),u.push(C.filter(nPe))}}return f}}function nPe(e){return e.length>1}function iPe(e,t){return((e=e.x)[0]<0?e[1]-Fn-ce:Fn-e[1])-((t=t.x)[0]<0?t[1]-Fn-ce:Fn-t[1])}var FJ=M(()=>{xJ();wJ();lr();MJ();mD()});function oPe(e){var t=NaN,r=NaN,n=NaN,i;return{lineStart:function(){e.lineStart(),i=1},point:function(o,a){var s=o>0?rr:-rr,l=Ye(o-t);Ye(l-rr)<ce?(e.point(t,r=(r+a)/2>0?Fn:-Fn),e.point(n,r),e.lineEnd(),e.lineStart(),e.point(s,r),e.point(o,r),i=0):n!==s&&l>=rr&&(Ye(t-n)<ce&&(t-=n*ce),Ye(o-s)<ce&&(o-=s*ce),r=aPe(t,r,o,a),e.point(n,r),e.lineEnd(),e.lineStart(),e.point(s,r),i=0),e.point(t=o,r=a),n=s},lineEnd:function(){e.lineEnd(),t=r=NaN},clean:function(){return 2-i}}}function aPe(e,t,r,n){var i,o,a=Jt(e-r);return Ye(a)>ce?yc((Jt(t)*(o=ae(n))*Jt(r)-Jt(n)*(i=ae(t))*Jt(e))/(i*o*a)):(t+n)/2}function sPe(e,t,r,n){var i;if(e==null)i=r*Fn,n.point(-rr,i),n.point(0,i),n.point(rr,i),n.point(rr,0),n.point(rr,-i),n.point(0,-i),n.point(-rr,-i),n.point(-rr,0),n.point(-rr,i);else if(Ye(e[0]-t[0])>ce){var o=e[0]<t[0]?rr:-rr;i=r*o/2,n.point(-o,i),n.point(0,i),n.point(o,i)}else n.point(t[0],t[1])}var zT,BJ=M(()=>{FJ();lr();zT=gD(function(){return!0},oPe,sPe,[-rr,-Fn])});function _D(e){var t=ae(e),r=6*we,n=t>0,i=Ye(t)>ce;function o(u,h,f,p){yJ(p,e,r,f,u,h)}function a(u,h){return ae(u)*ae(h)>t}function s(u){var h,f,p,d,g;return{lineStart:function(){d=p=!1,g=1},point:function(_,y){var x=[_,y],b,S=a(_,y),C=n?S?0:c(_,y):S?c(_+(_<0?rr:-rr),y):0;if(!h&&(d=p=S)&&u.lineStart(),S!==p&&(b=l(h,x),(!b||I2(h,b)||I2(x,b))&&(x[0]+=ce,x[1]+=ce,S=a(x[0],x[1]))),S!==p)g=0,S?(u.lineStart(),b=l(x,h),u.point(b[0],b[1])):(b=l(h,x),u.point(b[0],b[1]),u.lineEnd()),h=b;else if(i&&h&&n^S){var P;!(C&f)&&(P=l(x,h,!0))&&(g=0,n?(u.lineStart(),u.point(P[0][0],P[0][1]),u.point(P[1][0],P[1][1]),u.lineEnd()):(u.point(P[1][0],P[1][1]),u.lineEnd(),u.lineStart(),u.point(P[0][0],P[0][1])))}S&&(!h||!I2(h,x))&&u.point(x[0],x[1]),h=x,p=S,f=C},lineEnd:function(){p&&u.lineEnd(),h=null},clean:function(){return g|(d&&p)<<1}}}function l(u,h,f){var p=vc(u),d=vc(h),g=[1,0,0],_=$p(p,d),y=PT(_,_),x=_[0],b=y-x*x;if(!b)return!f&&u;var S=t*y/b,C=-t*x/b,P=$p(g,_),k=IT(g,S),O=IT(_,C);QN(k,O);var D=P,B=PT(k,D),I=PT(D,D),L=B*B-I*(PT(k,k)-1);if(!(L<0)){var R=Rr(L),F=IT(D,(-B-R)/I);if(QN(F,k),F=Ny(F),!f)return F;var z=u[0],U=h[0],W=u[1],Z=h[1],rt;U<z&&(rt=z,z=U,U=rt);var ot=U-z,st=Ye(ot-rr)<ce,St=st||ot<ce;if(!st&&Z<W&&(rt=W,W=Z,Z=rt),St?st?W+Z>0^F[1]<(Ye(F[0]-z)<ce?W:Z):W<=F[1]&&F[1]<=Z:ot>rr^(z<=F[0]&&F[0]<=U)){var bt=IT(D,(-B+R)/I);return QN(bt,k),[F,Ny(bt)]}}}function c(u,h){var f=n?e:rr-e,p=0;return u<-f?p|=1:u>f&&(p|=2),h<-f?p|=4:h>f&&(p|=8),p}return gD(a,s,o,n?[0,-e]:[-rr,e-rr])}var HJ=M(()=>{A2();vJ();lr();bJ();FJ()});function L9t(e,t,r,n,i,o){var a=e[0],s=e[1],l=t[0],c=t[1],u=0,h=1,f=l-a,p=c-s,d;if(d=r-a,!(!f&&d>0)){if(d/=f,f<0){if(d<u)return;d<h&&(h=d)}else if(f>0){if(d>h)return;d>u&&(u=d)}if(d=i-a,!(!f&&d<0)){if(d/=f,f<0){if(d>h)return;d>u&&(u=d)}else if(f>0){if(d<u)return;d<h&&(h=d)}if(d=n-s,!(!p&&d>0)){if(d/=p,p<0){if(d<u)return;d<h&&(h=d)}else if(p>0){if(d>h)return;d>u&&(u=d)}if(d=o-s,!(!p&&d<0)){if(d/=p,p<0){if(d>h)return;d>u&&(u=d)}else if(p>0){if(d<u)return;d<h&&(h=d)}return u>0&&(e[0]=a+u*f,e[1]=s+u*p),h<1&&(t[0]=a+h*f,t[1]=s+h*p),!0}}}}}var k9t=M(()=>{});function Qp(e,t,r,n){function i(c,u){return e<=c&&c<=r&&t<=u&&u<=n}function o(c,u,h,f){var p=0,d=0;if(c==null||(p=a(c,h))!==(d=a(u,h))||l(c,u)<0^h>0)do f.point(p===0||p===3?e:r,p>1?n:t);while((p=(p+h+4)%4)!==d);else f.point(u[0],u[1])}function a(c,u){return Ye(c[0]-e)<ce?u>0?0:3:Ye(c[0]-r)<ce?u>0?2:1:Ye(c[1]-t)<ce?u>0?1:0:u>0?3:2}function s(c,u){return l(c.x,u.x)}function l(c,u){var h=a(c,1),f=a(u,1);return h!==f?h-f:h===0?u[1]-c[1]:h===1?c[0]-u[0]:h===2?c[1]-u[1]:u[0]-c[0]}return function(c){var u=c,h=cD(),f,p,d,g,_,y,x,b,S,C,P,k={point:O,lineStart:L,lineEnd:R,polygonStart:B,polygonEnd:I};function O(z,U){i(z,U)&&u.point(z,U)}function D(){for(var z=0,U=0,W=p.length;U<W;++U)for(var Z=p[U],rt=1,ot=Z.length,st=Z[0],St,bt,Mt=st[0],lt=st[1];rt<ot;++rt)St=Mt,bt=lt,st=Z[rt],Mt=st[0],lt=st[1],bt<=n?lt>n&&(Mt-St)*(n-bt)>(lt-bt)*(e-St)&&++z:lt<=n&&(Mt-St)*(n-bt)<(lt-bt)*(e-St)&&--z;return z}function B(){u=h,f=[],p=[],P=!0}function I(){var z=D(),U=P&&z,W=(f=OT(f)).length;(U||W)&&(c.polygonStart(),U&&(c.lineStart(),o(null,null,1,c),c.lineEnd()),W&&hD(f,s,z,o,c),c.polygonEnd()),u=c,f=p=d=null}function L(){k.point=F,p&&p.push(d=[]),C=!0,S=!1,x=b=NaN}function R(){f&&(F(g,_),y&&S&&h.rejoin(),f.push(h.result())),k.point=O,S&&u.lineEnd()}function F(z,U){var W=i(z,U);if(p&&d.push([z,U]),C)g=z,_=U,y=W,C=!1,W&&(u.lineStart(),u.point(z,U));else if(W&&S)u.point(z,U);else{var Z=[x=Math.max(yD,Math.min(FT,x)),b=Math.max(yD,Math.min(FT,b))],rt=[z=Math.max(yD,Math.min(FT,z)),U=Math.max(yD,Math.min(FT,U))];L9t(Z,rt,e,t,r,n)?(S||(u.lineStart(),u.point(Z[0],Z[1])),u.point(rt[0],rt[1]),W||u.lineEnd(),P=!1):W&&(u.lineStart(),u.point(z,U),P=!1)}x=z,b=U,S=W}return k}}var FT,yD,BT=M(()=>{lr();xJ();k9t();wJ();mD();FT=1e9,yD=-FT});function R9t(){var e=0,t=0,r=960,n=500,i,o,a;return a={stream:function(s){return i&&o===s?i:i=Qp(e,t,r,n)(o=s)},extent:function(s){return arguments.length?(e=+s[0][0],t=+s[0][1],r=+s[1][0],n=+s[1][1],i=o=null,a):[[e,t],[r,n]]}}}var N9t=M(()=>{BT()});function lPe(){k2.point=uPe,k2.lineEnd=cPe}function cPe(){k2.point=k2.lineEnd=qr}function uPe(e,t){e*=we,t*=we,UJ=e,vD=Jt(t),xD=ae(t),k2.point=hPe}function hPe(e,t){e*=we,t*=we;var r=Jt(t),n=ae(t),i=Ye(e-UJ),o=ae(i),a=Jt(i),s=n*a,l=xD*r-vD*n*o,c=vD*r+xD*n*o;VJ.add(Sn(Rr(s*s+l*l),c)),UJ=e,vD=r,xD=n}function bD(e){return VJ.reset(),Mo(e,k2),+VJ}var VJ,UJ,vD,xD,k2,qJ=M(()=>{ky();lr();Xp();mg();VJ=Cs(),k2={sphere:qr,point:qr,lineStart:lPe,lineEnd:qr,polygonStart:qr,polygonEnd:qr}});function By(e,t){return GJ[0]=e,GJ[1]=t,bD(fPe)}var GJ,fPe,WJ=M(()=>{qJ();GJ=[null,null],fPe={type:"LineString",coordinates:GJ}});function wD(e,t){return e&&O9t.hasOwnProperty(e.type)?O9t[e.type](e,t):!1}function z9t(e,t){return By(e,t)===0}function F9t(e,t){var r=By(e[0],e[1]),n=By(e[0],t),i=By(t,e[1]);return n+i<=r+ce}function B9t(e,t){return!!fD(e.map(pPe),H9t(t))}function pPe(e){return e=e.map(H9t),e.pop(),e}function H9t(e){return[e[0]*we,e[1]*we]}function V9t(e,t){return(e&&D9t.hasOwnProperty(e.type)?D9t[e.type]:wD)(e,t)}var D9t,O9t,U9t=M(()=>{MJ();WJ();lr();D9t={Feature:function(e,t){return wD(e.geometry,t)},FeatureCollection:function(e,t){for(var r=e.features,n=-1,i=r.length;++n<i;)if(wD(r[n].geometry,t))return!0;return!1}},O9t={Sphere:function(){return!0},Point:function(e,t){return z9t(e.coordinates,t)},MultiPoint:function(e,t){for(var r=e.coordinates,n=-1,i=r.length;++n<i;)if(z9t(r[n],t))return!0;return!1},LineString:function(e,t){return F9t(e.coordinates,t)},MultiLineString:function(e,t){for(var r=e.coordinates,n=-1,i=r.length;++n<i;)if(F9t(r[n],t))return!0;return!1},Polygon:function(e,t){return B9t(e.coordinates,t)},MultiPolygon:function(e,t){for(var r=e.coordinates,n=-1,i=r.length;++n<i;)if(B9t(r[n],t))return!0;return!1},GeometryCollection:function(e,t){for(var r=e.geometries,n=-1,i=r.length;++n<i;)if(wD(r[n],t))return!0;return!1}}});function q9t(e,t,r){var n=Jp(e,t-ce,r).concat(t);return function(i){return n.map(function(o){return[i,o]})}}function G9t(e,t,r){var n=Jp(e,t-ce,r).concat(t);return function(i){return n.map(function(o){return[o,i]})}}function SD(){var e,t,r,n,i,o,a,s,l=10,c=l,u=90,h=360,f,p,d,g,_=2.5;function y(){return{type:"MultiLineString",coordinates:x()}}function x(){return Jp(CT(n/u)*u,r,u).map(d).concat(Jp(CT(s/h)*h,a,h).map(g)).concat(Jp(CT(t/l)*l,e,l).filter(function(b){return Ye(b%u)>ce}).map(f)).concat(Jp(CT(o/c)*c,i,c).filter(function(b){return Ye(b%h)>ce}).map(p))}return y.lines=function(){return x().map(function(b){return{type:"LineString",coordinates:b}})},y.outline=function(){return{type:"Polygon",coordinates:[d(n).concat(g(a).slice(1),d(r).reverse().slice(1),g(s).reverse().slice(1))]}},y.extent=function(b){return arguments.length?y.extentMajor(b).extentMinor(b):y.extentMinor()},y.extentMajor=function(b){return arguments.length?(n=+b[0][0],r=+b[1][0],s=+b[0][1],a=+b[1][1],n>r&&(b=n,n=r,r=b),s>a&&(b=s,s=a,a=b),y.precision(_)):[[n,s],[r,a]]},y.extentMinor=function(b){return arguments.length?(t=+b[0][0],e=+b[1][0],o=+b[0][1],i=+b[1][1],t>e&&(b=t,t=e,e=b),o>i&&(b=o,o=i,i=b),y.precision(_)):[[t,o],[e,i]]},y.step=function(b){return arguments.length?y.stepMajor(b).stepMinor(b):y.stepMinor()},y.stepMajor=function(b){return arguments.length?(u=+b[0],h=+b[1],y):[u,h]},y.stepMinor=function(b){return arguments.length?(l=+b[0],c=+b[1],y):[l,c]},y.precision=function(b){return arguments.length?(_=+b,f=q9t(o,i,90),p=G9t(t,e,_),d=q9t(s,a,90),g=G9t(n,r,_),y):_},y.extentMajor([[-180,-90+ce],[180,90-ce]]).extentMinor([[-180,-80-ce],[180,80+ce]])}function W9t(){return SD()()}var Y9t=M(()=>{mD();lr()});function j9t(e,t){var r=e[0]*we,n=e[1]*we,i=t[0]*we,o=t[1]*we,a=ae(n),s=Jt(n),l=ae(o),c=Jt(o),u=a*ae(r),h=a*Jt(r),f=l*ae(i),p=l*Jt(i),d=2*Zn(Rr(oJ(o-n)+a*l*oJ(i-r))),g=Jt(d),_=d?function(y){var x=Jt(y*=d)/g,b=Jt(d-y)/g,S=b*u+x*f,C=b*h+x*p,P=b*s+x*c;return[Sn(C,S)*Ur,Sn(P,Rr(S*S+C*C))*Ur]}:function(){return[r*Ur,n*Ur]};return _.distance=d,_}var X9t=M(()=>{lr()});function nf(e){return e}var MD=M(()=>{});function dPe(){yg.point=mPe}function mPe(e,t){yg.point=Z9t,$9t=XJ=e,K9t=$J=t}function Z9t(e,t){jJ.add($J*e-XJ*t),XJ=e,$J=t}function gPe(){Z9t($9t,K9t)}var YJ,jJ,$9t,K9t,XJ,$J,yg,KJ,J9t=M(()=>{ky();lr();Xp();YJ=Cs(),jJ=Cs(),yg={point:qr,lineStart:qr,lineEnd:qr,polygonStart:function(){yg.lineStart=dPe,yg.lineEnd=gPe},polygonEnd:function(){yg.lineStart=yg.lineEnd=yg.point=qr,YJ.add(Ye(jJ)),jJ.reset()},result:function(){var e=YJ/2;return YJ.reset(),e}};KJ=yg});function yPe(e,t){e<R2&&(R2=e),e>HT&&(HT=e),t<ED&&(ED=t),t>TD&&(TD=t)}var R2,ED,HT,TD,_Pe,N2,ZJ=M(()=>{Xp();R2=1/0,ED=R2,HT=-R2,TD=HT,_Pe={point:yPe,lineStart:qr,lineEnd:qr,polygonStart:qr,polygonEnd:qr,result:function(){var e=[[R2,ED],[HT,TD]];return HT=TD=-(ED=R2=1/0),e}};N2=_Pe});function Hy(e,t){JJ+=e,QJ+=t,++VT}function Q9t(){Cu.point=vPe}function vPe(e,t){Cu.point=xPe,Hy(of=e,af=t)}function xPe(e,t){var r=e-of,n=t-af,i=Rr(r*r+n*n);CD+=i*(of+e)/2,AD+=i*(af+t)/2,D2+=i,Hy(of=e,af=t)}function tLt(){Cu.point=Hy}function bPe(){Cu.point=SPe}function wPe(){nLt(eLt,rLt)}function SPe(e,t){Cu.point=nLt,Hy(eLt=of=e,rLt=af=t)}function nLt(e,t){var r=e-of,n=t-af,i=Rr(r*r+n*n);CD+=i*(of+e)/2,AD+=i*(af+t)/2,D2+=i,i=af*e-of*t,tQ+=i*(of+e),eQ+=i*(af+t),UT+=i*3,Hy(of=e,af=t)}var JJ,QJ,VT,CD,AD,D2,tQ,eQ,UT,eLt,rLt,of,af,Cu,rQ,iLt=M(()=>{lr();JJ=0,QJ=0,VT=0,CD=0,AD=0,D2=0,tQ=0,eQ=0,UT=0,Cu={point:Hy,lineStart:Q9t,lineEnd:tLt,polygonStart:function(){Cu.lineStart=bPe,Cu.lineEnd=wPe},polygonEnd:function(){Cu.point=Hy,Cu.lineStart=Q9t,Cu.lineEnd=tLt},result:function(){var e=UT?[tQ/UT,eQ/UT]:D2?[CD/D2,AD/D2]:VT?[JJ/VT,QJ/VT]:[NaN,NaN];return JJ=QJ=VT=CD=AD=D2=tQ=eQ=UT=0,e}};rQ=Cu});function PD(e){this._context=e}var oLt=M(()=>{lr();Xp();PD.prototype={_radius:4.5,pointRadius:function(e){return this._radius=e,this},polygonStart:function(){this._line=0},polygonEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){this._line===0&&this._context.closePath(),this._point=NaN},point:function(e,t){switch(this._point){case 0:{this._context.moveTo(e,t),this._point=1;break}case 1:{this._context.lineTo(e,t);break}default:{this._context.moveTo(e+this._radius,t),this._context.arc(e,t,this._radius,0,Bi);break}}},result:qr}});function MPe(e,t){ID.point=lLt,aLt=qT=e,sLt=GT=t}function lLt(e,t){qT-=e,GT-=t,iQ.add(Rr(qT*qT+GT*GT)),qT=e,GT=t}var iQ,nQ,aLt,sLt,qT,GT,ID,oQ,cLt=M(()=>{ky();lr();Xp();iQ=Cs(),ID={point:qr,lineStart:function(){ID.point=MPe},lineEnd:function(){nQ&&lLt(aLt,sLt),ID.point=qr},polygonStart:function(){nQ=!0},polygonEnd:function(){nQ=null},result:function(){var e=+iQ;return iQ.reset(),e}};oQ=ID});function LD(){this._string=[]}function uLt(e){return"m0,"+e+"a"+e+","+e+" 0 1,1 0,"+-2*e+"a"+e+","+e+" 0 1,1 0,"+2*e+"z"}var hLt=M(()=>{LD.prototype={_radius:4.5,_circle:uLt(4.5),pointRadius:function(e){return(e=+e)!==this._radius&&(this._radius=e,this._circle=null),this},polygonStart:function(){this._line=0},polygonEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){this._line===0&&this._string.push("Z"),this._point=NaN},point:function(e,t){switch(this._point){case 0:{this._string.push("M",e,",",t),this._point=1;break}case 1:{this._string.push("L",e,",",t);break}default:{this._circle==null&&(this._circle=uLt(this._radius)),this._string.push("M",e,",",t,this._circle);break}}},result:function(){if(this._string.length){var e=this._string.join("");return this._string=[],e}else return null}}});function fLt(e,t){var r=4.5,n,i;function o(a){return a&&(typeof r=="function"&&i.pointRadius(+r.apply(this,arguments)),Mo(a,n(i))),i.result()}return o.area=function(a){return Mo(a,n(KJ)),KJ.result()},o.measure=function(a){return Mo(a,n(oQ)),oQ.result()},o.bounds=function(a){return Mo(a,n(N2)),N2.result()},o.centroid=function(a){return Mo(a,n(rQ)),rQ.result()},o.projection=function(a){return arguments.length?(n=a==null?(e=null,nf):(e=a).stream,o):e},o.context=function(a){return arguments.length?(i=a==null?(t=null,new LD):new PD(t=a),typeof r!="function"&&i.pointRadius(r),o):t},o.pointRadius=function(a){return arguments.length?(r=typeof a=="function"?a:(i.pointRadius(+a),+a),o):r},o.projection(e).context(t)}var pLt=M(()=>{MD();mg();J9t();ZJ();iLt();oLt();cLt();hLt()});function dLt(e){return{stream:vg(e)}}function vg(e){return function(t){var r=new aQ;for(var n in e)r[n]=e[n];return r.stream=t,r}}function aQ(){}var WT=M(()=>{aQ.prototype={constructor:aQ,point:function(e,t){this.stream.point(e,t)},sphere:function(){this.stream.sphere()},lineStart:function(){this.stream.lineStart()},lineEnd:function(){this.stream.lineEnd()},polygonStart:function(){this.stream.polygonStart()},polygonEnd:function(){this.stream.polygonEnd()}}});function sQ(e,t,r){var n=e.clipExtent&&e.clipExtent();return e.scale(150).translate([0,0]),n!=null&&e.clipExtent(null),Mo(r,e.stream(N2)),t(N2.result()),n!=null&&e.clipExtent(n),e}function Vy(e,t,r){return sQ(e,function(n){var i=t[1][0]-t[0][0],o=t[1][1]-t[0][1],a=Math.min(i/(n[1][0]-n[0][0]),o/(n[1][1]-n[0][1])),s=+t[0][0]+(i-a*(n[1][0]+n[0][0]))/2,l=+t[0][1]+(o-a*(n[1][1]+n[0][1]))/2;e.scale(150*a).translate([s,l])},r)}function O2(e,t,r){return Vy(e,[[0,0],t],r)}function z2(e,t,r){return sQ(e,function(n){var i=+t,o=i/(n[1][0]-n[0][0]),a=(i-o*(n[1][0]+n[0][0]))/2,s=-o*n[0][1];e.scale(150*o).translate([a,s])},r)}function F2(e,t,r){return sQ(e,function(n){var i=+t,o=i/(n[1][1]-n[0][1]),a=-o*n[0][0],s=(i-o*(n[1][1]+n[0][1]))/2;e.scale(150*o).translate([a,s])},r)}var kD=M(()=>{mg();ZJ()});function lQ(e,t){return+t?CPe(e,t):TPe(e)}function TPe(e){return vg({point:function(t,r){t=e(t,r),this.stream.point(t[0],t[1])}})}function CPe(e,t){function r(n,i,o,a,s,l,c,u,h,f,p,d,g,_){var y=c-n,x=u-i,b=y*y+x*x;if(b>4*t&&g--){var S=a+f,C=s+p,P=l+d,k=Rr(S*S+C*C+P*P),O=Zn(P/=k),D=Ye(Ye(P)-1)<ce||Ye(o-h)<ce?(o+h)/2:Sn(C,S),B=e(D,O),I=B[0],L=B[1],R=I-n,F=L-i,z=x*R-y*F;(z*z/b>t||Ye((y*R+x*F)/b-.5)>.3||a*f+s*p+l*d<EPe)&&(r(n,i,o,a,s,l,I,L,D,S/=k,C/=k,P,g,_),_.point(I,L),r(I,L,D,S,C,P,c,u,h,f,p,d,g,_))}}return function(n){var i,o,a,s,l,c,u,h,f,p,d,g,_={point:y,lineStart:x,lineEnd:S,polygonStart:function(){n.polygonStart(),_.lineStart=C},polygonEnd:function(){n.polygonEnd(),_.lineStart=x}};function y(O,D){O=e(O,D),n.point(O[0],O[1])}function x(){h=NaN,_.point=b,n.lineStart()}function b(O,D){var B=vc([O,D]),I=e(O,D);r(h,f,u,p,d,g,h=I[0],f=I[1],u=O,p=B[0],d=B[1],g=B[2],mLt,n),n.point(h,f)}function S(){_.point=y,n.lineEnd()}function C(){x(),_.point=P,_.lineEnd=k}function P(O,D){b(i=O,D),o=h,a=f,s=p,l=d,c=g,_.point=b}function k(){r(h,f,u,p,d,g,o,a,i,s,l,c,mLt,n),_.lineEnd=S,S()}return _}}var mLt,EPe,gLt=M(()=>{A2();lr();WT();mLt=16,EPe=ae(30*we)});function PPe(e){return vg({point:function(t,r){var n=e(t,r);return this.stream.point(n[0],n[1])}})}function eo(e){return YT(function(){return e})()}function YT(e){var t,r=150,n=480,i=250,o,a,s=0,l=0,c=0,u=0,h=0,f,p,d=null,g=zT,_=null,y,x,b,S=nf,C=.5,P=lQ(I,C),k,O;function D(F){return F=p(F[0]*we,F[1]*we),[F[0]*r+o,a-F[1]*r]}function B(F){return F=p.invert((F[0]-o)/r,(a-F[1])/r),F&&[F[0]*Ur,F[1]*Ur]}function I(F,z){return F=t(F,z),[F[0]*r+o,a-F[1]*r]}D.stream=function(F){return k&&O===F?k:k=APe(PPe(f)(g(P(S(O=F)))))},D.preclip=function(F){return arguments.length?(g=F,d=void 0,R()):g},D.postclip=function(F){return arguments.length?(S=F,_=y=x=b=null,R()):S},D.clipAngle=function(F){return arguments.length?(g=+F?_D(d=F*we):(d=null,zT),R()):d*Ur},D.clipExtent=function(F){return arguments.length?(S=F==null?(_=y=x=b=null,nf):Qp(_=+F[0][0],y=+F[0][1],x=+F[1][0],b=+F[1][1]),R()):_==null?null:[[_,y],[x,b]]},D.scale=function(F){return arguments.length?(r=+F,L()):r},D.translate=function(F){return arguments.length?(n=+F[0],i=+F[1],L()):[n,i]},D.center=function(F){return arguments.length?(s=F[0]%360*we,l=F[1]%360*we,L()):[s*Ur,l*Ur]},D.rotate=function(F){return arguments.length?(c=F[0]%360*we,u=F[1]%360*we,h=F.length>2?F[2]%360*we:0,L()):[c*Ur,u*Ur,h*Ur]},D.precision=function(F){return arguments.length?(P=lQ(I,C=F*F),R()):Rr(C)},D.fitExtent=function(F,z){return Vy(D,F,z)},D.fitSize=function(F,z){return O2(D,F,z)},D.fitWidth=function(F,z){return z2(D,F,z)},D.fitHeight=function(F,z){return F2(D,F,z)};function L(){p=sD(f=NT(c,u,h),t);var F=t(s,l);return o=n-F[0]*r,a=i+F[1]*r,R()}function R(){return k=O=null,D}return function(){return t=e.apply(this,arguments),D.invert=t.invert&&B,L()}}var APe,Au=M(()=>{BJ();HJ();BT();gJ();MD();lr();DT();WT();kD();gLt();APe=vg({point:function(e,t){this.stream.point(e*we,t*we)}})});function B2(e){var t=0,r=rr/3,n=YT(e),i=n(t,r);return i.parallels=function(o){return arguments.length?n(t=o[0]*we,r=o[1]*we):[t*Ur,r*Ur]},i}var RD=M(()=>{lr();Au()});function _Lt(e){var t=ae(e);function r(n,i){return[n*t,Jt(i)/t]}return r.invert=function(n,i){return[n/t,Zn(i*t)]},r}var yLt=M(()=>{lr()});function cQ(e,t){var r=Jt(e),n=(r+Jt(t))/2;if(Ye(n)<ce)return _Lt(e);var i=1+r*(2*n-r),o=Rr(i)/n;function a(s,l){var c=Rr(i-2*n*Jt(l))/n;return[c*Jt(s*=n),o-c*ae(s)]}return a.invert=function(s,l){var c=o-l;return[Sn(s,Ye(c))/n*dg(c),Zn((i-(s*s+c*c)*n*n)/(2*n))]},a}function Uy(){return B2(cQ).scale(155.424).center([0,33.6442])}var ND=M(()=>{lr();RD();yLt()});function DD(){return Uy().parallels([29.5,45.5]).scale(1070).translate([480,250]).rotate([96,0]).center([-.6,38.7])}var uQ=M(()=>{ND()});function IPe(e){var t=e.length;return{point:function(r,n){for(var i=-1;++i<t;)e[i].point(r,n)},sphere:function(){for(var r=-1;++r<t;)e[r].sphere()},lineStart:function(){for(var r=-1;++r<t;)e[r].lineStart()},lineEnd:function(){for(var r=-1;++r<t;)e[r].lineEnd()},polygonStart:function(){for(var r=-1;++r<t;)e[r].polygonStart()},polygonEnd:function(){for(var r=-1;++r<t;)e[r].polygonEnd()}}}function vLt(){var e,t,r=DD(),n,i=Uy().rotate([154,0]).center([-2,58.5]).parallels([55,65]),o,a=Uy().rotate([157,0]).center([-3,19.9]).parallels([8,18]),s,l,c={point:function(f,p){l=[f,p]}};function u(f){var p=f[0],d=f[1];return l=null,n.point(p,d),l||(o.point(p,d),l)||(s.point(p,d),l)}u.invert=function(f){var p=r.scale(),d=r.translate(),g=(f[0]-d[0])/p,_=(f[1]-d[1])/p;return(_>=.12&&_<.234&&g>=-.425&&g<-.214?i:_>=.166&&_<.234&&g>=-.214&&g<-.115?a:r).invert(f)},u.stream=function(f){return e&&t===f?e:e=IPe([r.stream(t=f),i.stream(f),a.stream(f)])},u.precision=function(f){return arguments.length?(r.precision(f),i.precision(f),a.precision(f),h()):r.precision()},u.scale=function(f){return arguments.length?(r.scale(f),i.scale(f*.35),a.scale(f),u.translate(r.translate())):r.scale()},u.translate=function(f){if(!arguments.length)return r.translate();var p=r.scale(),d=+f[0],g=+f[1];return n=r.translate(f).clipExtent([[d-.455*p,g-.238*p],[d+.455*p,g+.238*p]]).stream(c),o=i.translate([d-.307*p,g+.201*p]).clipExtent([[d-.425*p+ce,g+.12*p+ce],[d-.214*p-ce,g+.234*p-ce]]).stream(c),s=a.translate([d-.205*p,g+.212*p]).clipExtent([[d-.214*p+ce,g+.166*p+ce],[d-.115*p-ce,g+.234*p-ce]]).stream(c),h()},u.fitExtent=function(f,p){return Vy(u,f,p)},u.fitSize=function(f,p){return O2(u,f,p)},u.fitWidth=function(f,p){return z2(u,f,p)},u.fitHeight=function(f,p){return F2(u,f,p)};function h(){return e=t=null,u}return u.scale(1070)}var xLt=M(()=>{lr();uQ();ND();kD()});function OD(e){return function(t,r){var n=ae(t),i=ae(r),o=e(n*i);return[o*i*Jt(t),o*Jt(r)]}}function sf(e){return function(t,r){var n=Rr(t*t+r*r),i=e(n),o=Jt(i),a=ae(i);return[Sn(t*o,n*a),Zn(n&&r*o/n)]}}var H2=M(()=>{lr()});function bLt(){return eo(zD).scale(124.75).clipAngle(180-.001)}var zD,wLt=M(()=>{lr();H2();Au();zD=OD(function(e){return Rr(2/(1+e))});zD.invert=sf(function(e){return 2*Zn(e/2)})});function SLt(){return eo(FD).scale(79.4188).clipAngle(180-.001)}var FD,MLt=M(()=>{lr();H2();Au();FD=OD(function(e){return(e=KN(e))&&e/Jt(e)});FD.invert=sf(function(e){return e})});function qy(e,t){return[e,Ry(C2((Fn+t)/2))]}function ELt(){return hQ(qy).scale(961/Bi)}function hQ(e){var t=eo(e),r=t.center,n=t.scale,i=t.translate,o=t.clipExtent,a=null,s,l,c;t.scale=function(h){return arguments.length?(n(h),u()):n()},t.translate=function(h){return arguments.length?(i(h),u()):i()},t.center=function(h){return arguments.length?(r(h),u()):r()},t.clipExtent=function(h){return arguments.length?(h==null?a=s=l=c=null:(a=+h[0][0],s=+h[0][1],l=+h[1][0],c=+h[1][1]),u()):a==null?null:[[a,s],[l,c]]};function u(){var h=rr*n(),f=t(lD(t.rotate()).invert([0,0]));return o(a==null?[[f[0]-h,f[1]-h],[f[0]+h,f[1]+h]]:e===qy?[[Math.max(f[0]-h,a),s],[Math.min(f[0]+h,l),c]]:[[a,Math.max(f[1]-h,s)],[l,Math.min(f[1]+h,c)]])}return u()}var BD=M(()=>{lr();DT();Au();qy.invert=function(e,t){return[e,2*yc(XN(t))-Fn]}});function HD(e){return C2((Fn+e)/2)}function fQ(e,t){var r=ae(e),n=e===t?Jt(e):Ry(r/ae(t))/Ry(HD(t)/HD(e)),i=r*$N(HD(e),n)/n;if(!n)return qy;function o(a,s){i>0?s<-Fn+ce&&(s=-Fn+ce):s>Fn-ce&&(s=Fn-ce);var l=i/$N(HD(s),n);return[l*Jt(n*a),i-l*ae(n*a)]}return o.invert=function(a,s){var l=i-s,c=dg(n)*Rr(a*a+l*l);return[Sn(a,Ye(l))/n*dg(l),2*yc($N(i/c,1/n))-Fn]},o}function TLt(){return B2(fQ).scale(109.5).parallels([30,30])}var CLt=M(()=>{lr();RD();BD()});function Gy(e,t){return[e,t]}function ALt(){return eo(Gy).scale(152.63)}var pQ=M(()=>{Au();Gy.invert=Gy});function dQ(e,t){var r=ae(e),n=e===t?Jt(e):(r-ae(t))/(t-e),i=r/n+e;if(Ye(n)<ce)return Gy;function o(a,s){var l=i-s,c=n*a;return[l*Jt(c),i-l*ae(c)]}return o.invert=function(a,s){var l=i-s;return[Sn(a,Ye(l))/n*dg(l),i-dg(n)*Rr(a*a+l*l)]},o}function PLt(){return B2(dQ).scale(131.154).center([0,13.9389])}var ILt=M(()=>{lr();RD();pQ()});function VD(e,t){var r=ae(t),n=ae(e)*r;return[r*Jt(e)/n,Jt(t)/n]}function LLt(){return eo(VD).scale(144.049).clipAngle(60)}var kLt=M(()=>{lr();H2();Au();VD.invert=sf(yc)});function UD(e,t,r,n){return e===1&&t===1&&r===0&&n===0?nf:vg({point:function(i,o){this.stream.point(i*e+r,o*t+n)}})}function RLt(){var e=1,t=0,r=0,n=1,i=1,o=nf,a=null,s,l,c,u=nf,h,f,p;function d(){return h=f=null,p}return p={stream:function(g){return h&&f===g?h:h=o(u(f=g))},postclip:function(g){return arguments.length?(u=g,a=s=l=c=null,d()):u},clipExtent:function(g){return arguments.length?(u=g==null?(a=s=l=c=null,nf):Qp(a=+g[0][0],s=+g[0][1],l=+g[1][0],c=+g[1][1]),d()):a==null?null:[[a,s],[l,c]]},scale:function(g){return arguments.length?(o=UD((e=+g)*n,e*i,t,r),d()):e},translate:function(g){return arguments.length?(o=UD(e*n,e*i,t=+g[0],r=+g[1]),d()):[t,r]},reflectX:function(g){return arguments.length?(o=UD(e*(n=g?-1:1),e*i,t,r),d()):n<0},reflectY:function(g){return arguments.length?(o=UD(e*n,e*(i=g?-1:1),t,r),d()):i<0},fitExtent:function(g,_){return Vy(p,g,_)},fitSize:function(g,_){return O2(p,g,_)},fitWidth:function(g,_){return z2(p,g,_)},fitHeight:function(g,_){return F2(p,g,_)}}}var NLt=M(()=>{BT();MD();WT();kD()});function qD(e,t){var r=t*t,n=r*r;return[e*(.8707-.131979*r+n*(-.013791+n*(.003971*r-.001529*n))),t*(1.007226+r*(.015085+n*(-.044475+.028874*r-.005916*n)))]}function DLt(){return eo(qD).scale(175.295)}var OLt=M(()=>{Au();lr();qD.invert=function(e,t){var r=t,n=25,i;do{var o=r*r,a=o*o;r-=i=(r*(1.007226+o*(.015085+a*(-.044475+.028874*o-.005916*a)))-t)/(1.007226+o*(.015085*3+a*(-.044475*7+.028874*9*o-.005916*11*a)))}while(Ye(i)>ce&&--n>0);return[e/(.8707+(o=r*r)*(-.131979+o*(-.013791+o*o*o*(.003971-.001529*o)))),r]}});function GD(e,t){return[ae(t)*Jt(e),Jt(t)]}function zLt(){return eo(GD).scale(249.5).clipAngle(90+ce)}var FLt=M(()=>{lr();H2();Au();GD.invert=sf(Zn)});function WD(e,t){var r=ae(t),n=1+ae(e)*r;return[r*Jt(e)/n,Jt(t)/n]}function BLt(){return eo(WD).scale(250).clipAngle(142)}var HLt=M(()=>{lr();H2();Au();WD.invert=sf(function(e){return 2*yc(e)})});function YD(e,t){return[Ry(C2((Fn+t)/2)),-e]}function VLt(){var e=hQ(YD),t=e.center,r=e.rotate;return e.center=function(n){return arguments.length?t([-n[1],n[0]]):(n=t(),[n[1],-n[0]])},e.rotate=function(n){return arguments.length?r([n[0],n[1],n.length>2?n[2]+90:90]):(n=r(),[n[0],n[1],n[2]-90])},r([0,0,90]).scale(159.155)}var ULt=M(()=>{lr();BD();YD.invert=function(e,t){return[-t,2*yc(XN(e))-Fn]}});var qLt=M(()=>{uJ();ZIt();i9t();vJ();BJ();HJ();N9t();BT();U9t();WJ();Y9t();X9t();qJ();pLt();uQ();xLt();wLt();MLt();CLt();ND();ILt();pQ();kLt();NLt();Au();BD();OLt();FLt();HLt();ULt();DT();mg();WT()});function LPe(e,t){return e.parent===t.parent?1:2}function kPe(e){return e.reduce(RPe,0)/e.length}function RPe(e,t){return e+t.x}function NPe(e){return 1+e.reduce(DPe,0)}function DPe(e,t){return Math.max(e,t.y)}function OPe(e){for(var t;t=e.children;)e=t[0];return e}function zPe(e){for(var t;t=e.children;)e=t[t.length-1];return e}function GLt(){var e=LPe,t=1,r=1,n=!1;function i(o){var a,s=0;o.eachAfter(function(f){var p=f.children;p?(f.x=kPe(p),f.y=NPe(p)):(f.x=a?s+=e(f,a):0,f.y=0,a=f)});var l=OPe(o),c=zPe(o),u=l.x-e(l,c)/2,h=c.x+e(c,l)/2;return o.eachAfter(n?function(f){f.x=(f.x-o.x)*t,f.y=(o.y-f.y)*r}:function(f){f.x=(f.x-u)/(h-u)*t,f.y=(1-(o.y?f.y/o.y:1))*r})}return i.separation=function(o){return arguments.length?(e=o,i):e},i.size=function(o){return arguments.length?(n=!1,t=+o[0],r=+o[1],i):n?null:[t,r]},i.nodeSize=function(o){return arguments.length?(n=!0,t=+o[0],r=+o[1],i):n?[t,r]:null},i}var WLt=M(()=>{});function FPe(e){var t=0,r=e.children,n=r&&r.length;if(!n)t=1;else for(;--n>=0;)t+=r[n].value;e.value=t}function YLt(){return this.eachAfter(FPe)}var jLt=M(()=>{});function XLt(e){var t=this,r,n=[t],i,o,a;do for(r=n.reverse(),n=[];t=r.pop();)if(e(t),i=t.children,i)for(o=0,a=i.length;o<a;++o)n.push(i[o]);while(n.length);return this}var $Lt=M(()=>{});function KLt(e){for(var t=this,r=[t],n,i;t=r.pop();)if(e(t),n=t.children,n)for(i=n.length-1;i>=0;--i)r.push(n[i]);return this}var ZLt=M(()=>{});function JLt(e){for(var t=this,r=[t],n=[],i,o,a;t=r.pop();)if(n.push(t),i=t.children,i)for(o=0,a=i.length;o<a;++o)r.push(i[o]);for(;t=n.pop();)e(t);return this}var QLt=M(()=>{});function tkt(e){return this.eachAfter(function(t){for(var r=+e(t.data)||0,n=t.children,i=n&&n.length;--i>=0;)r+=n[i].value;t.value=r})}var ekt=M(()=>{});function rkt(e){return this.eachBefore(function(t){t.children&&t.children.sort(e)})}var nkt=M(()=>{});function ikt(e){for(var t=this,r=BPe(t,e),n=[t];t!==r;)t=t.parent,n.push(t);for(var i=n.length;e!==r;)n.splice(i,0,e),e=e.parent;return n}function BPe(e,t){if(e===t)return e;var r=e.ancestors(),n=t.ancestors(),i=null;for(e=r.pop(),t=n.pop();e===t;)i=e,e=r.pop(),t=n.pop();return i}var okt=M(()=>{});function akt(){for(var e=this,t=[e];e=e.parent;)t.push(e);return t}var skt=M(()=>{});function lkt(){var e=[];return this.each(function(t){e.push(t)}),e}var ckt=M(()=>{});function ukt(){var e=[];return this.eachBefore(function(t){t.children||e.push(t)}),e}var hkt=M(()=>{});function fkt(){var e=this,t=[];return e.each(function(r){r!==e&&t.push({source:r.parent,target:r})}),t}var pkt=M(()=>{});function jT(e,t){var r=new xg(e),n=+e.value&&(r.value=e.value),i,o=[r],a,s,l,c;for(t==null&&(t=VPe);i=o.pop();)if(n&&(i.value=+i.data.value),(s=t(i.data))&&(c=s.length))for(i.children=new Array(c),l=c-1;l>=0;--l)o.push(a=i.children[l]=new xg(s[l])),a.parent=i,a.depth=i.depth+1;return r.eachBefore(mQ)}function HPe(){return jT(this).eachBefore(UPe)}function VPe(e){return e.children}function UPe(e){e.data=e.data.data}function mQ(e){var t=0;do e.height=t;while((e=e.parent)&&e.height<++t)}function xg(e){this.data=e,this.depth=this.height=0,this.parent=null}var jD=M(()=>{jLt();$Lt();ZLt();QLt();ekt();nkt();okt();skt();ckt();hkt();pkt();xg.prototype=jT.prototype={constructor:xg,count:YLt,each:XLt,eachAfter:JLt,eachBefore:KLt,sum:tkt,sort:rkt,path:ikt,ancestors:akt,descendants:lkt,leaves:ukt,links:fkt,copy:HPe}});function mkt(e){for(var t=e.length,r,n;t;)n=Math.random()*t--|0,r=e[t],e[t]=e[n],e[n]=r;return e}var dkt,gkt=M(()=>{dkt=Array.prototype.slice});function $D(e){for(var t=0,r=(e=mkt(dkt.call(e))).length,n=[],i,o;t<r;)i=e[t],o&&_kt(o,i)?++t:(o=GPe(n=qPe(n,i)),t=0);return o}function qPe(e,t){var r,n;if(gQ(t,e))return[t];for(r=0;r<e.length;++r)if(XD(t,e[r])&&gQ(XT(e[r],t),e))return[e[r],t];for(r=0;r<e.length-1;++r)for(n=r+1;n<e.length;++n)if(XD(XT(e[r],e[n]),t)&&XD(XT(e[r],t),e[n])&&XD(XT(e[n],t),e[r])&&gQ(ykt(e[r],e[n],t),e))return[e[r],e[n],t];throw new Error}function XD(e,t){var r=e.r-t.r,n=t.x-e.x,i=t.y-e.y;return r<0||r*r<n*n+i*i}function _kt(e,t){var r=e.r-t.r+1e-6,n=t.x-e.x,i=t.y-e.y;return r>0&&r*r>n*n+i*i}function gQ(e,t){for(var r=0;r<t.length;++r)if(!_kt(e,t[r]))return!1;return!0}function GPe(e){switch(e.length){case 1:return WPe(e[0]);case 2:return XT(e[0],e[1]);case 3:return ykt(e[0],e[1],e[2])}}function WPe(e){return{x:e.x,y:e.y,r:e.r}}function XT(e,t){var r=e.x,n=e.y,i=e.r,o=t.x,a=t.y,s=t.r,l=o-r,c=a-n,u=s-i,h=Math.sqrt(l*l+c*c);return{x:(r+o+l/h*u)/2,y:(n+a+c/h*u)/2,r:(h+i+s)/2}}function ykt(e,t,r){var n=e.x,i=e.y,o=e.r,a=t.x,s=t.y,l=t.r,c=r.x,u=r.y,h=r.r,f=n-a,p=n-c,d=i-s,g=i-u,_=l-o,y=h-o,x=n*n+i*i-o*o,b=x-a*a-s*s+l*l,S=x-c*c-u*u+h*h,C=p*d-f*g,P=(d*S-g*b)/(C*2)-n,k=(g*_-d*y)/C,O=(p*b-f*S)/(C*2)-i,D=(f*y-p*_)/C,B=k*k+D*D-1,I=2*(o+P*k+O*D),L=P*P+O*O-o*o,R=-(B?(I+Math.sqrt(I*I-4*B*L))/(2*B):L/I);return{x:n+P+k*R,y:i+O+D*R,r:R}}var _Q=M(()=>{gkt()});function vkt(e,t,r){var n=e.x,i=e.y,o=t.r+r.r,a=e.r+r.r,s=t.x-n,l=t.y-i,c=s*s+l*l;if(c){var u=.5+((a*=a)-(o*=o))/(2*c),h=Math.sqrt(Math.max(0,2*o*(a+c)-(a-=c)*a-o*o))/(2*c);r.x=n+u*s+h*l,r.y=i+u*l-h*s}else r.x=n+a,r.y=i}function xkt(e,t){var r=t.x-e.x,n=t.y-e.y,i=e.r+t.r;return i*i-1e-6>r*r+n*n}function bkt(e){var t=e._,r=e.next._,n=t.r+r.r,i=(t.x*r.r+r.x*t.r)/n,o=(t.y*r.r+r.y*t.r)/n;return i*i+o*o}function KD(e){this._=e,this.next=null,this.previous=null}function yQ(e){if(!(i=e.length))return 0;var t,r,n,i,o,a,s,l,c,u,h;if(t=e[0],t.x=0,t.y=0,!(i>1))return t.r;if(r=e[1],t.x=-r.r,r.x=t.r,r.y=0,!(i>2))return t.r+r.r;vkt(r,t,n=e[2]),t=new KD(t),r=new KD(r),n=new KD(n),t.next=n.previous=r,r.next=t.previous=n,n.next=r.previous=t;t:for(s=3;s<i;++s){vkt(t._,r._,n=e[s]),n=new KD(n),l=r.next,c=t.previous,u=r._.r,h=t._.r;do if(u<=h){if(xkt(l._,n._)){r=l,t.next=r,r.previous=t,--s;continue t}u+=l._.r,l=l.next}else{if(xkt(c._,n._)){t=c,t.next=r,r.previous=t,--s;continue t}h+=c._.r,c=c.previous}while(l!==c.next);for(n.previous=t,n.next=r,t.next=r.previous=r=n,o=bkt(t);(n=n.next)!==r;)(a=bkt(n))<o&&(t=n,o=a);r=t.next}for(t=[r._],n=r;(n=n.next)!==r;)t.push(n._);for(n=$D(t),s=0;s<i;++s)t=e[s],t.x-=n.x,t.y-=n.y;return n.r}function wkt(e){return yQ(e),e}var vQ=M(()=>{_Q()});function Skt(e){return e==null?null:V2(e)}function V2(e){if(typeof e!="function")throw new Error;return e}var ZD=M(()=>{});function td(){return 0}function bg(e){return function(){return e}}var xQ=M(()=>{});function YPe(e){return Math.sqrt(e.value)}function Tkt(){var e=null,t=1,r=1,n=td;function i(o){return o.x=t/2,o.y=r/2,e?o.eachBefore(Mkt(e)).eachAfter(bQ(n,.5)).eachBefore(Ekt(1)):o.eachBefore(Mkt(YPe)).eachAfter(bQ(td,1)).eachAfter(bQ(n,o.r/Math.min(t,r))).eachBefore(Ekt(Math.min(t,r)/(2*o.r))),o}return i.radius=function(o){return arguments.length?(e=Skt(o),i):e},i.size=function(o){return arguments.length?(t=+o[0],r=+o[1],i):[t,r]},i.padding=function(o){return arguments.length?(n=typeof o=="function"?o:bg(+o),i):n},i}function Mkt(e){return function(t){t.children||(t.r=Math.max(0,+e(t)||0))}}function bQ(e,t){return function(r){if(n=r.children){var n,i,o=n.length,a=e(r)*t||0,s;if(a)for(i=0;i<o;++i)n[i].r+=a;if(s=yQ(n),a)for(i=0;i<o;++i)n[i].r-=a;r.r=s+a}}}function Ekt(e){return function(t){var r=t.parent;t.r*=e,r&&(t.x=r.x+e*t.x,t.y=r.y+e*t.y)}}var Ckt=M(()=>{vQ();ZD();xQ()});function JD(e){e.x0=Math.round(e.x0),e.y0=Math.round(e.y0),e.x1=Math.round(e.x1),e.y1=Math.round(e.y1)}var wQ=M(()=>{});function lf(e,t,r,n,i){for(var o=e.children,a,s=-1,l=o.length,c=e.value&&(n-t)/e.value;++s<l;)a=o[s],a.y0=r,a.y1=i,a.x0=t,a.x1=t+=a.value*c}var U2=M(()=>{});function Akt(){var e=1,t=1,r=0,n=!1;function i(a){var s=a.height+1;return a.x0=a.y0=r,a.x1=e,a.y1=t/s,a.eachBefore(o(t,s)),n&&a.eachBefore(JD),a}function o(a,s){return function(l){l.children&&lf(l,l.x0,a*(l.depth+1)/s,l.x1,a*(l.depth+2)/s);var c=l.x0,u=l.y0,h=l.x1-r,f=l.y1-r;h<c&&(c=h=(c+h)/2),f<u&&(u=f=(u+f)/2),l.x0=c,l.y0=u,l.x1=h,l.y1=f}}return i.round=function(a){return arguments.length?(n=!!a,i):n},i.size=function(a){return arguments.length?(e=+a[0],t=+a[1],i):[e,t]},i.padding=function(a){return arguments.length?(r=+a,i):r},i}var Pkt=M(()=>{wQ();U2()});function XPe(e){return e.id}function $Pe(e){return e.parentId}function kkt(){var e=XPe,t=$Pe;function r(n){var i,o,a=n.length,s,l,c,u=new Array(a),h,f,p={};for(o=0;o<a;++o)i=n[o],c=u[o]=new xg(i),(h=e(i,o,n))!=null&&(h+="")&&(f=Ikt+(c.id=h),p[f]=f in p?Lkt:c);for(o=0;o<a;++o)if(c=u[o],h=t(n[o],o,n),h==null||!(h+="")){if(s)throw new Error("multiple roots");s=c}else{if(l=p[Ikt+h],!l)throw new Error("missing: "+h);if(l===Lkt)throw new Error("ambiguous: "+h);l.children?l.children.push(c):l.children=[c],c.parent=l}if(!s)throw new Error("no root");if(s.parent=jPe,s.eachBefore(function(d){d.depth=d.parent.depth+1,--a}).eachBefore(mQ),s.parent=null,a>0)throw new Error("cycle");return s}return r.id=function(n){return arguments.length?(e=V2(n),r):e},r.parentId=function(n){return arguments.length?(t=V2(n),r):t},r}var Ikt,jPe,Lkt,Rkt=M(()=>{ZD();jD();Ikt="$",jPe={depth:-1},Lkt={}});function KPe(e,t){return e.parent===t.parent?1:2}function SQ(e){var t=e.children;return t?t[0]:e.t}function MQ(e){var t=e.children;return t?t[t.length-1]:e.t}function ZPe(e,t,r){var n=r/(t.i-e.i);t.c-=n,t.s+=r,e.c+=n,t.z+=r,t.m+=r}function JPe(e){for(var t=0,r=0,n=e.children,i=n.length,o;--i>=0;)o=n[i],o.z+=t,o.m+=t,t+=o.s+(r+=o.c)}function QPe(e,t,r){return e.a.parent===t.parent?e.a:r}function QD(e,t){this._=e,this.parent=null,this.children=null,this.A=null,this.a=this,this.z=0,this.m=0,this.c=0,this.s=0,this.t=null,this.i=t}function t6e(e){for(var t=new QD(e,0),r,n=[t],i,o,a,s;r=n.pop();)if(o=r._.children)for(r.children=new Array(s=o.length),a=s-1;a>=0;--a)n.push(i=r.children[a]=new QD(o[a],a)),i.parent=r;return(t.parent=new QD(null,0)).children=[t],t}function Nkt(){var e=KPe,t=1,r=1,n=null;function i(c){var u=t6e(c);if(u.eachAfter(o),u.parent.m=-u.z,u.eachBefore(a),n)c.eachBefore(l);else{var h=c,f=c,p=c;c.eachBefore(function(x){x.x<h.x&&(h=x),x.x>f.x&&(f=x),x.depth>p.depth&&(p=x)});var d=h===f?1:e(h,f)/2,g=d-h.x,_=t/(f.x+d+g),y=r/(p.depth||1);c.eachBefore(function(x){x.x=(x.x+g)*_,x.y=x.depth*y})}return c}function o(c){var u=c.children,h=c.parent.children,f=c.i?h[c.i-1]:null;if(u){JPe(c);var p=(u[0].z+u[u.length-1].z)/2;f?(c.z=f.z+e(c._,f._),c.m=c.z-p):c.z=p}else f&&(c.z=f.z+e(c._,f._));c.parent.A=s(c,f,c.parent.A||h[0])}function a(c){c._.x=c.z+c.parent.m,c.m+=c.parent.m}function s(c,u,h){if(u){for(var f=c,p=c,d=u,g=f.parent.children[0],_=f.m,y=p.m,x=d.m,b=g.m,S;d=MQ(d),f=SQ(f),d&&f;)g=SQ(g),p=MQ(p),p.a=c,S=d.z+x-f.z-_+e(d._,f._),S>0&&(ZPe(QPe(d,c,h),c,S),_+=S,y+=S),x+=d.m,_+=f.m,b+=g.m,y+=p.m;d&&!MQ(p)&&(p.t=d,p.m+=x-y),f&&!SQ(g)&&(g.t=f,g.m+=_-b,h=c)}return h}function l(c){c.x*=t,c.y=c.depth*r}return i.separation=function(c){return arguments.length?(e=c,i):e},i.size=function(c){return arguments.length?(n=!1,t=+c[0],r=+c[1],i):n?null:[t,r]},i.nodeSize=function(c){return arguments.length?(n=!0,t=+c[0],r=+c[1],i):n?[t,r]:null},i}var Dkt=M(()=>{jD();QD.prototype=Object.create(xg.prototype)});function wg(e,t,r,n,i){for(var o=e.children,a,s=-1,l=o.length,c=e.value&&(i-r)/e.value;++s<l;)a=o[s],a.x0=t,a.x1=n,a.y0=r,a.y1=r+=a.value*c}var $T=M(()=>{});function TQ(e,t,r,n,i,o){for(var a=[],s=t.children,l,c,u=0,h=0,f=s.length,p,d,g=t.value,_,y,x,b,S,C,P;u<f;){p=i-r,d=o-n;do _=s[h++].value;while(!_&&h<f);for(y=x=_,C=Math.max(d/p,p/d)/(g*e),P=_*_*C,S=Math.max(x/P,P/y);h<f;++h){if(_+=c=s[h].value,c<y&&(y=c),c>x&&(x=c),P=_*_*C,b=Math.max(x/P,P/y),b>S){_-=c;break}S=b}a.push(l={value:_,dice:p<d,children:s.slice(u,h)}),l.dice?lf(l,r,n,i,g?n+=d*_/g:o):wg(l,r,n,g?r+=p*_/g:i,o),g-=_,u=h}return a}var EQ,tO,eO=M(()=>{U2();$T();EQ=(1+Math.sqrt(5))/2;tO=function e(t){function r(n,i,o,a,s){TQ(t,n,i,o,a,s)}return r.ratio=function(n){return e((n=+n)>1?n:1)},r}(EQ)});function Okt(){var e=tO,t=!1,r=1,n=1,i=[0],o=td,a=td,s=td,l=td,c=td;function u(f){return f.x0=f.y0=0,f.x1=r,f.y1=n,f.eachBefore(h),i=[0],t&&f.eachBefore(JD),f}function h(f){var p=i[f.depth],d=f.x0+p,g=f.y0+p,_=f.x1-p,y=f.y1-p;_<d&&(d=_=(d+_)/2),y<g&&(g=y=(g+y)/2),f.x0=d,f.y0=g,f.x1=_,f.y1=y,f.children&&(p=i[f.depth+1]=o(f)/2,d+=c(f)-p,g+=a(f)-p,_-=s(f)-p,y-=l(f)-p,_<d&&(d=_=(d+_)/2),y<g&&(g=y=(g+y)/2),e(f,d,g,_,y))}return u.round=function(f){return arguments.length?(t=!!f,u):t},u.size=function(f){return arguments.length?(r=+f[0],n=+f[1],u):[r,n]},u.tile=function(f){return arguments.length?(e=V2(f),u):e},u.padding=function(f){return arguments.length?u.paddingInner(f).paddingOuter(f):u.paddingInner()},u.paddingInner=function(f){return arguments.length?(o=typeof f=="function"?f:bg(+f),u):o},u.paddingOuter=function(f){return arguments.length?u.paddingTop(f).paddingRight(f).paddingBottom(f).paddingLeft(f):u.paddingTop()},u.paddingTop=function(f){return arguments.length?(a=typeof f=="function"?f:bg(+f),u):a},u.paddingRight=function(f){return arguments.length?(s=typeof f=="function"?f:bg(+f),u):s},u.paddingBottom=function(f){return arguments.length?(l=typeof f=="function"?f:bg(+f),u):l},u.paddingLeft=function(f){return arguments.length?(c=typeof f=="function"?f:bg(+f),u):c},u}var zkt=M(()=>{wQ();eO();ZD();xQ()});function Fkt(e,t,r,n,i){var o=e.children,a,s=o.length,l,c=new Array(s+1);for(c[0]=l=a=0;a<s;++a)c[a+1]=l+=o[a].value;u(0,s,e.value,t,r,n,i);function u(h,f,p,d,g,_,y){if(h>=f-1){var x=o[h];x.x0=d,x.y0=g,x.x1=_,x.y1=y;return}for(var b=c[h],S=p/2+b,C=h+1,P=f-1;C<P;){var k=C+P>>>1;c[k]<S?C=k+1:P=k}S-c[C-1]<c[C]-S&&h+1<C&&--C;var O=c[C]-b,D=p-O;if(_-d>y-g){var B=(d*D+_*O)/p;u(h,C,O,d,g,B,y),u(C,f,D,B,g,_,y)}else{var I=(g*D+y*O)/p;u(h,C,O,d,g,_,I),u(C,f,D,d,I,_,y)}}}var Bkt=M(()=>{});function Hkt(e,t,r,n,i){(e.depth&1?wg:lf)(e,t,r,n,i)}var Vkt=M(()=>{U2();$T()});var Ukt,qkt=M(()=>{U2();$T();eO();Ukt=function e(t){function r(n,i,o,a,s){if((l=n._squarify)&&l.ratio===t)for(var l,c,u,h,f=-1,p,d=l.length,g=n.value;++f<d;){for(c=l[f],u=c.children,h=c.value=0,p=u.length;h<p;++h)c.value+=u[h].value;c.dice?lf(c,i,o,a,o+=(s-o)*c.value/g):wg(c,i,o,i+=(a-i)*c.value/g,s),g-=c.value}else n._squarify=l=TQ(t,n,i,o,a,s),l.ratio=t}return r.ratio=function(n){return e((n=+n)>1?n:1)},r}(EQ)});var Gkt=M(()=>{WLt();jD();Ckt();vQ();_Q();Pkt();Rkt();Dkt();zkt();Bkt();U2();$T();Vkt();eO();qkt()});function ed(e,t,r){e.prototype=t.prototype=r,r.constructor=e}function Sg(e,t){var r=Object.create(e.prototype);for(var n in t)r[n]=t[n];return r}var rO=M(()=>{});function hf(){}function Ykt(){return this.rgb().formatHex()}function l6e(){return Jkt(this).formatHsl()}function jkt(){return this.rgb().formatRgb()}function Eg(e){var t,r;return e=(e+"").trim().toLowerCase(),(t=e6e.exec(e))?(r=t[1].length,t=parseInt(t[1],16),r===6?Xkt(t):r===3?new ro(t>>8&15|t>>4&240,t>>4&15|t&240,(t&15)<<4|t&15,1):r===8?nO(t>>24&255,t>>16&255,t>>8&255,(t&255)/255):r===4?nO(t>>12&15|t>>8&240,t>>8&15|t>>4&240,t>>4&15|t&240,((t&15)<<4|t&15)/255):null):(t=r6e.exec(e))?new ro(t[1],t[2],t[3],1):(t=n6e.exec(e))?new ro(t[1]*255/100,t[2]*255/100,t[3]*255/100,1):(t=i6e.exec(e))?nO(t[1],t[2],t[3],t[4]):(t=o6e.exec(e))?nO(t[1]*255/100,t[2]*255/100,t[3]*255/100,t[4]):(t=a6e.exec(e))?Zkt(t[1],t[2]/100,t[3]/100,1):(t=s6e.exec(e))?Zkt(t[1],t[2]/100,t[3]/100,t[4]):Wkt.hasOwnProperty(e)?Xkt(Wkt[e]):e==="transparent"?new ro(NaN,NaN,NaN,0):null}function Xkt(e){return new ro(e>>16&255,e>>8&255,e&255,1)}function nO(e,t,r,n){return n<=0&&(e=t=r=NaN),new ro(e,t,r,n)}function ZT(e){return e instanceof hf||(e=Eg(e)),e?(e=e.rgb(),new ro(e.r,e.g,e.b,e.opacity)):new ro}function G2(e,t,r,n){return arguments.length===1?ZT(e):new ro(e,t,r,n==null?1:n)}function ro(e,t,r,n){this.r=+e,this.g=+t,this.b=+r,this.opacity=+n}function $kt(){return"#"+CQ(this.r)+CQ(this.g)+CQ(this.b)}function Kkt(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"rgb(":"rgba(")+Math.max(0,Math.min(255,Math.round(this.r)||0))+", "+Math.max(0,Math.min(255,Math.round(this.g)||0))+", "+Math.max(0,Math.min(255,Math.round(this.b)||0))+(e===1?")":", "+e+")")}function CQ(e){return e=Math.max(0,Math.min(255,Math.round(e)||0)),(e<16?"0":"")+e.toString(16)}function Zkt(e,t,r,n){return n<=0?e=t=r=NaN:r<=0||r>=1?e=t=NaN:t<=0&&(e=NaN),new cf(e,t,r,n)}function Jkt(e){if(e instanceof cf)return new cf(e.h,e.s,e.l,e.opacity);if(e instanceof hf||(e=Eg(e)),!e)return new cf;if(e instanceof cf)return e;e=e.rgb();var t=e.r/255,r=e.g/255,n=e.b/255,i=Math.min(t,r,n),o=Math.max(t,r,n),a=NaN,s=o-i,l=(o+i)/2;return s?(t===o?a=(r-n)/s+(r<n)*6:r===o?a=(n-t)/s+2:a=(t-r)/s+4,s/=l<.5?o+i:2-o-i,a*=60):s=l>0&&l<1?0:a,new cf(a,s,l,e.opacity)}function JT(e,t,r,n){return arguments.length===1?Jkt(e):new cf(e,t,r,n==null?1:n)}function cf(e,t,r,n){this.h=+e,this.s=+t,this.l=+r,this.opacity=+n}function AQ(e,t,r){return(e<60?t+(r-t)*e/60:e<180?r:e<240?t+(r-t)*(240-e)/60:t)*255}var Mg,Wy,q2,KT,uf,e6e,r6e,n6e,i6e,o6e,a6e,s6e,Wkt,iO=M(()=>{rO();Mg=.7,Wy=1/Mg,q2="\\s*([+-]?\\d+)\\s*",KT="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",uf="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",e6e=/^#([0-9a-f]{3,8})$/,r6e=new RegExp("^rgb\\("+[q2,q2,q2]+"\\)$"),n6e=new RegExp("^rgb\\("+[uf,uf,uf]+"\\)$"),i6e=new RegExp("^rgba\\("+[q2,q2,q2,KT]+"\\)$"),o6e=new RegExp("^rgba\\("+[uf,uf,uf,KT]+"\\)$"),a6e=new RegExp("^hsl\\("+[KT,uf,uf]+"\\)$"),s6e=new RegExp("^hsla\\("+[KT,uf,uf,KT]+"\\)$"),Wkt={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};ed(hf,Eg,{copy:function(e){return Object.assign(new this.constructor,this,e)},displayable:function(){return this.rgb().displayable()},hex:Ykt,formatHex:Ykt,formatHsl:l6e,formatRgb:jkt,toString:jkt});ed(ro,G2,Sg(hf,{brighter:function(e){return e=e==null?Wy:Math.pow(Wy,e),new ro(this.r*e,this.g*e,this.b*e,this.opacity)},darker:function(e){return e=e==null?Mg:Math.pow(Mg,e),new ro(this.r*e,this.g*e,this.b*e,this.opacity)},rgb:function(){return this},displayable:function(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:$kt,formatHex:$kt,formatRgb:Kkt,toString:Kkt}));ed(cf,JT,Sg(hf,{brighter:function(e){return e=e==null?Wy:Math.pow(Wy,e),new cf(this.h,this.s,this.l*e,this.opacity)},darker:function(e){return e=e==null?Mg:Math.pow(Mg,e),new cf(this.h,this.s,this.l*e,this.opacity)},rgb:function(){var e=this.h%360+(this.h<0)*360,t=isNaN(e)||isNaN(this.s)?0:this.s,r=this.l,n=r+(r<.5?r:1-r)*t,i=2*r-n;return new ro(AQ(e>=240?e-240:e+120,i,n),AQ(e,i,n),AQ(e<120?e+240:e-120,i,n),this.opacity)},displayable:function(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl:function(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"hsl(":"hsla(")+(this.h||0)+", "+(this.s||0)*100+"%, "+(this.l||0)*100+"%"+(e===1?")":", "+e+")")}}))});var oO,aO,PQ=M(()=>{oO=Math.PI/180,aO=180/Math.PI});function i8t(e){if(e instanceof ff)return new ff(e.l,e.a,e.b,e.opacity);if(e instanceof rd)return o8t(e);e instanceof ro||(e=ZT(e));var t=RQ(e.r),r=RQ(e.g),n=RQ(e.b),i=IQ((.2225045*t+.7168786*r+.0606169*n)/t8t),o,a;return t===r&&r===n?o=a=i:(o=IQ((.4360747*t+.3850649*r+.1430804*n)/Qkt),a=IQ((.0139322*t+.0971045*r+.7141733*n)/e8t)),new ff(116*i-16,500*(o-i),200*(i-a),e.opacity)}function Y2(e,t,r,n){return arguments.length===1?i8t(e):new ff(e,t,r,n==null?1:n)}function ff(e,t,r,n){this.l=+e,this.a=+t,this.b=+r,this.opacity=+n}function IQ(e){return e>c6e?Math.pow(e,1/3):e/n8t+r8t}function LQ(e){return e>W2?e*e*e:n8t*(e-r8t)}function kQ(e){return 255*(e<=.0031308?12.92*e:1.055*Math.pow(e,1/2.4)-.055)}function RQ(e){return(e/=255)<=.04045?e/12.92:Math.pow((e+.055)/1.055,2.4)}function u6e(e){if(e instanceof rd)return new rd(e.h,e.c,e.l,e.opacity);if(e instanceof ff||(e=i8t(e)),e.a===0&&e.b===0)return new rd(NaN,0<e.l&&e.l<100?0:NaN,e.l,e.opacity);var t=Math.atan2(e.b,e.a)*aO;return new rd(t<0?t+360:t,Math.sqrt(e.a*e.a+e.b*e.b),e.l,e.opacity)}function QT(e,t,r,n){return arguments.length===1?u6e(e):new rd(e,t,r,n==null?1:n)}function rd(e,t,r,n){this.h=+e,this.c=+t,this.l=+r,this.opacity=+n}function o8t(e){if(isNaN(e.h))return new ff(e.l,0,0,e.opacity);var t=e.h*oO;return new ff(e.l,Math.cos(t)*e.c,Math.sin(t)*e.c,e.opacity)}var sO,Qkt,t8t,e8t,r8t,W2,n8t,c6e,a8t=M(()=>{rO();iO();PQ();sO=18,Qkt=.96422,t8t=1,e8t=.82521,r8t=4/29,W2=6/29,n8t=3*W2*W2,c6e=W2*W2*W2;ed(ff,Y2,Sg(hf,{brighter:function(e){return new ff(this.l+sO*(e==null?1:e),this.a,this.b,this.opacity)},darker:function(e){return new ff(this.l-sO*(e==null?1:e),this.a,this.b,this.opacity)},rgb:function(){var e=(this.l+16)/116,t=isNaN(this.a)?e:e+this.a/500,r=isNaN(this.b)?e:e-this.b/200;return t=Qkt*LQ(t),e=t8t*LQ(e),r=e8t*LQ(r),new ro(kQ(3.1338561*t-1.6168667*e-.4906146*r),kQ(-.9787684*t+1.9161415*e+.033454*r),kQ(.0719453*t-.2289914*e+1.4052427*r),this.opacity)}}));ed(rd,QT,Sg(hf,{brighter:function(e){return new rd(this.h,this.c,this.l+sO*(e==null?1:e),this.opacity)},darker:function(e){return new rd(this.h,this.c,this.l-sO*(e==null?1:e),this.opacity)},rgb:function(){return o8t(this).rgb()}}))});function h6e(e){if(e instanceof Yy)return new Yy(e.h,e.s,e.l,e.opacity);e instanceof ro||(e=ZT(e));var t=e.r/255,r=e.g/255,n=e.b/255,i=(c8t*n+s8t*t-l8t*r)/(c8t+s8t-l8t),o=n-i,a=(tC*(r-i)-DQ*o)/lO,s=Math.sqrt(a*a+o*o)/(tC*i*(1-i)),l=s?Math.atan2(a,o)*aO-120:NaN;return new Yy(l<0?l+360:l,s,i,e.opacity)}function j2(e,t,r,n){return arguments.length===1?h6e(e):new Yy(e,t,r,n==null?1:n)}function Yy(e,t,r,n){this.h=+e,this.s=+t,this.l=+r,this.opacity=+n}var u8t,NQ,DQ,lO,tC,s8t,l8t,c8t,h8t=M(()=>{rO();iO();PQ();u8t=-.14861,NQ=1.78277,DQ=-.29227,lO=-.90649,tC=1.97294,s8t=tC*lO,l8t=tC*NQ,c8t=NQ*DQ-lO*u8t;ed(Yy,j2,Sg(hf,{brighter:function(e){return e=e==null?Wy:Math.pow(Wy,e),new Yy(this.h,this.s,this.l*e,this.opacity)},darker:function(e){return e=e==null?Mg:Math.pow(Mg,e),new Yy(this.h,this.s,this.l*e,this.opacity)},rgb:function(){var e=isNaN(this.h)?0:(this.h+120)*oO,t=+this.l,r=isNaN(this.s)?0:this.s*t*(1-t),n=Math.cos(e),i=Math.sin(e);return new ro(255*(t+r*(u8t*n+NQ*i)),255*(t+r*(DQ*n+lO*i)),255*(t+r*(tC*n)),this.opacity)}}))});var jy=M(()=>{iO();a8t();h8t()});function OQ(e,t,r,n,i){var o=e*e,a=o*e;return((1-3*e+3*o-a)*t+(4-6*o+3*a)*r+(1+3*e+3*o-3*a)*n+a*i)/6}function cO(e){var t=e.length-1;return function(r){var n=r<=0?r=0:r>=1?(r=1,t-1):Math.floor(r*t),i=e[n],o=e[n+1],a=n>0?e[n-1]:2*i-o,s=n<t-1?e[n+2]:2*o-i;return OQ((r-n/t)*t,a,i,o,s)}}var uO=M(()=>{});function hO(e){var t=e.length;return function(r){var n=Math.floor(((r%=1)<0?++r:r)*t),i=e[(n+t-1)%t],o=e[n%t],a=e[(n+1)%t],s=e[(n+2)%t];return OQ((r-n/t)*t,i,o,a,s)}}var zQ=M(()=>{uO()});function X2(e){return function(){return e}}var FQ=M(()=>{});function f8t(e,t){return function(r){return e+r*t}}function f6e(e,t,r){return e=Math.pow(e,r),t=Math.pow(t,r)-e,r=1/r,function(n){return Math.pow(e+n*t,r)}}function $2(e,t){var r=t-e;return r?f8t(e,r>180||r<-180?r-360*Math.round(r/360):r):X2(isNaN(e)?t:e)}function p8t(e){return(e=+e)==1?Jn:function(t,r){return r-t?f6e(t,r,e):X2(isNaN(t)?r:t)}}function Jn(e,t){var r=t-e;return r?f8t(e,r):X2(isNaN(e)?t:e)}var K2=M(()=>{FQ()});function d8t(e){return function(t){var r=t.length,n=new Array(r),i=new Array(r),o=new Array(r),a,s;for(a=0;a<r;++a)s=G2(t[a]),n[a]=s.r||0,i[a]=s.g||0,o[a]=s.b||0;return n=e(n),i=e(i),o=e(o),s.opacity=1,function(l){return s.r=n(l),s.g=i(l),s.b=o(l),s+""}}}var eC,m8t,g8t,BQ=M(()=>{jy();uO();zQ();K2();eC=function e(t){var r=p8t(t);function n(i,o){var a=r((i=G2(i)).r,(o=G2(o)).r),s=r(i.g,o.g),l=r(i.b,o.b),c=Jn(i.opacity,o.opacity);return function(u){return i.r=a(u),i.g=s(u),i.b=l(u),i.opacity=c(u),i+""}}return n.gamma=e,n}(1);m8t=d8t(cO),g8t=d8t(hO)});function fO(e,t){var r=t?t.length:0,n=e?Math.min(r,e.length):0,i=new Array(n),o=new Array(r),a;for(a=0;a<n;++a)i[a]=Z2(e[a],t[a]);for(;a<r;++a)o[a]=t[a];return function(s){for(a=0;a<n;++a)o[a]=i[a](s);return o}}var HQ=M(()=>{pO()});function dO(e,t){var r=new Date;return e=+e,t-=e,function(n){return r.setTime(e+t*n),r}}var VQ=M(()=>{});function As(e,t){return e=+e,t-=e,function(r){return e+t*r}}var rC=M(()=>{});function mO(e,t){var r={},n={},i;(e===null||typeof e!="object")&&(e={}),(t===null||typeof t!="object")&&(t={});for(i in t)i in e?r[i]=Z2(e[i],t[i]):n[i]=t[i];return function(o){for(i in r)n[i]=r[i](o);return n}}var UQ=M(()=>{pO()});function p6e(e){return function(){return e}}function d6e(e){return function(t){return e(t)+""}}function gO(e,t){var r=GQ.lastIndex=qQ.lastIndex=0,n,i,o,a=-1,s=[],l=[];for(e=e+"",t=t+"";(n=GQ.exec(e))&&(i=qQ.exec(t));)(o=i.index)>r&&(o=t.slice(r,o),s[a]?s[a]+=o:s[++a]=o),(n=n[0])===(i=i[0])?s[a]?s[a]+=i:s[++a]=i:(s[++a]=null,l.push({i:a,x:As(n,i)})),r=qQ.lastIndex;return r<t.length&&(o=t.slice(r),s[a]?s[a]+=o:s[++a]=o),s.length<2?l[0]?d6e(l[0].x):p6e(t):(t=l.length,function(c){for(var u=0,h;u<t;++u)s[(h=l[u]).i]=h.x(c);return s.join("")})}var GQ,qQ,WQ=M(()=>{rC();GQ=/[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,qQ=new RegExp(GQ.source,"g")});function Z2(e,t){var r=typeof t,n;return t==null||r==="boolean"?X2(t):(r==="number"?As:r==="string"?(n=Eg(t))?(t=n,eC):gO:t instanceof Eg?eC:t instanceof Date?dO:Array.isArray(t)?fO:typeof t.valueOf!="function"&&typeof t.toString!="function"||isNaN(t)?mO:As)(e,t)}var pO=M(()=>{jy();BQ();HQ();VQ();rC();UQ();WQ();FQ()});function _8t(e,t){return e=+e,t-=e,function(r){return Math.round(e+t*r)}}var y8t=M(()=>{});function YQ(e,t,r,n,i,o){var a,s,l;return(a=Math.sqrt(e*e+t*t))&&(e/=a,t/=a),(l=e*r+t*n)&&(r-=e*l,n-=t*l),(s=Math.sqrt(r*r+n*n))&&(r/=s,n/=s,l/=s),e*n<t*r&&(e=-e,t=-t,l=-l,a=-a),{translateX:i,translateY:o,rotate:Math.atan2(t,e)*v8t,skewX:Math.atan(l)*v8t,scaleX:a,scaleY:s}}var v8t,_O,x8t=M(()=>{v8t=180/Math.PI,_O={translateX:0,translateY:0,rotate:0,skewX:0,scaleX:1,scaleY:1}});function w8t(e){return e==="none"?_O:(nC||(nC=document.createElement("DIV"),jQ=document.documentElement,b8t=document.defaultView),nC.style.transform=e,e=b8t.getComputedStyle(jQ.appendChild(nC),null).getPropertyValue("transform"),jQ.removeChild(nC),e=e.slice(7,-1).split(","),YQ(+e[0],+e[1],+e[2],+e[3],+e[4],+e[5]))}function S8t(e){return e==null?_O:(yO||(yO=document.createElementNS("http://www.w3.org/2000/svg","g")),yO.setAttribute("transform",e),(e=yO.transform.baseVal.consolidate())?(e=e.matrix,YQ(e.a,e.b,e.c,e.d,e.e,e.f)):_O)}var nC,jQ,b8t,yO,M8t=M(()=>{x8t()});function E8t(e,t,r,n){function i(c){return c.length?c.pop()+" ":""}function o(c,u,h,f,p,d){if(c!==h||u!==f){var g=p.push("translate(",null,t,null,r);d.push({i:g-4,x:As(c,h)},{i:g-2,x:As(u,f)})}else(h||f)&&p.push("translate("+h+t+f+r)}function a(c,u,h,f){c!==u?(c-u>180?u+=360:u-c>180&&(c+=360),f.push({i:h.push(i(h)+"rotate(",null,n)-2,x:As(c,u)})):u&&h.push(i(h)+"rotate("+u+n)}function s(c,u,h,f){c!==u?f.push({i:h.push(i(h)+"skewX(",null,n)-2,x:As(c,u)}):u&&h.push(i(h)+"skewX("+u+n)}function l(c,u,h,f,p,d){if(c!==h||u!==f){var g=p.push(i(p)+"scale(",null,",",null,")");d.push({i:g-4,x:As(c,h)},{i:g-2,x:As(u,f)})}else(h!==1||f!==1)&&p.push(i(p)+"scale("+h+","+f+")")}return function(c,u){var h=[],f=[];return c=e(c),u=e(u),o(c.translateX,c.translateY,u.translateX,u.translateY,h,f),a(c.rotate,u.rotate,h,f),s(c.skewX,u.skewX,h,f),l(c.scaleX,c.scaleY,u.scaleX,u.scaleY,h,f),c=u=null,function(p){for(var d=-1,g=f.length,_;++d<g;)h[(_=f[d]).i]=_.x(p);return h.join("")}}}var T8t,C8t,A8t=M(()=>{rC();M8t();T8t=E8t(w8t,"px, ","px)","deg)"),C8t=E8t(S8t,", ",")",")")});function I8t(e){return((e=Math.exp(e))+1/e)/2}function g6e(e){return((e=Math.exp(e))-1/e)/2}function _6e(e){return((e=Math.exp(2*e))-1)/(e+1)}function L8t(e,t){var r=e[0],n=e[1],i=e[2],o=t[0],a=t[1],s=t[2],l=o-r,c=a-n,u=l*l+c*c,h,f;if(u<m6e)f=Math.log(s/i)/iC,h=function(x){return[r+x*l,n+x*c,i*Math.exp(iC*x*f)]};else{var p=Math.sqrt(u),d=(s*s-i*i+P8t*u)/(2*i*XQ*p),g=(s*s-i*i-P8t*u)/(2*s*XQ*p),_=Math.log(Math.sqrt(d*d+1)-d),y=Math.log(Math.sqrt(g*g+1)-g);f=(y-_)/iC,h=function(x){var b=x*f,S=I8t(_),C=i/(XQ*p)*(S*_6e(iC*b+_)-g6e(_));return[r+C*l,n+C*c,i*S/I8t(iC*b+_)]}}return h.duration=f*1e3,h}var iC,XQ,P8t,m6e,k8t=M(()=>{iC=Math.SQRT2,XQ=2,P8t=4,m6e=1e-12});function R8t(e){return function(t,r){var n=e((t=JT(t)).h,(r=JT(r)).h),i=Jn(t.s,r.s),o=Jn(t.l,r.l),a=Jn(t.opacity,r.opacity);return function(s){return t.h=n(s),t.s=i(s),t.l=o(s),t.opacity=a(s),t+""}}}var N8t,D8t,O8t=M(()=>{jy();K2();N8t=R8t($2),D8t=R8t(Jn)});function $Q(e,t){var r=Jn((e=Y2(e)).l,(t=Y2(t)).l),n=Jn(e.a,t.a),i=Jn(e.b,t.b),o=Jn(e.opacity,t.opacity);return function(a){return e.l=r(a),e.a=n(a),e.b=i(a),e.opacity=o(a),e+""}}var z8t=M(()=>{jy();K2()});function F8t(e){return function(t,r){var n=e((t=QT(t)).h,(r=QT(r)).h),i=Jn(t.c,r.c),o=Jn(t.l,r.l),a=Jn(t.opacity,r.opacity);return function(s){return t.h=n(s),t.c=i(s),t.l=o(s),t.opacity=a(s),t+""}}}var B8t,H8t,V8t=M(()=>{jy();K2();B8t=F8t($2),H8t=F8t(Jn)});function U8t(e){return function t(r){r=+r;function n(i,o){var a=e((i=j2(i)).h,(o=j2(o)).h),s=Jn(i.s,o.s),l=Jn(i.l,o.l),c=Jn(i.opacity,o.opacity);return function(u){return i.h=a(u),i.s=s(u),i.l=l(Math.pow(u,r)),i.opacity=c(u),i+""}}return n.gamma=t,n}(1)}var q8t,G8t,W8t=M(()=>{jy();K2();q8t=U8t($2),G8t=U8t(Jn)});function Y8t(e,t){for(var r=new Array(t),n=0;n<t;++n)r[n]=e(n/(t-1));return r}var j8t=M(()=>{});var X8t=M(()=>{pO();HQ();uO();zQ();VQ();rC();UQ();y8t();WQ();A8t();k8t();BQ();O8t();z8t();V8t();W8t();j8t()});function JQ(){this._x0=this._y0=this._x1=this._y1=null,this._=""}function $8t(){return new JQ}var KQ,ZQ,Xy,y6e,K8t,Z8t=M(()=>{KQ=Math.PI,ZQ=2*KQ,Xy=1e-6,y6e=ZQ-Xy;JQ.prototype=$8t.prototype={constructor:JQ,moveTo:function(e,t){this._+="M"+(this._x0=this._x1=+e)+","+(this._y0=this._y1=+t)},closePath:function(){this._x1!==null&&(this._x1=this._x0,this._y1=this._y0,this._+="Z")},lineTo:function(e,t){this._+="L"+(this._x1=+e)+","+(this._y1=+t)},quadraticCurveTo:function(e,t,r,n){this._+="Q"+ +e+","+ +t+","+(this._x1=+r)+","+(this._y1=+n)},bezierCurveTo:function(e,t,r,n,i,o){this._+="C"+ +e+","+ +t+","+ +r+","+ +n+","+(this._x1=+i)+","+(this._y1=+o)},arcTo:function(e,t,r,n,i){e=+e,t=+t,r=+r,n=+n,i=+i;var o=this._x1,a=this._y1,s=r-e,l=n-t,c=o-e,u=a-t,h=c*c+u*u;if(i<0)throw new Error("negative radius: "+i);if(this._x1===null)this._+="M"+(this._x1=e)+","+(this._y1=t);else if(h>Xy)if(!(Math.abs(u*s-l*c)>Xy)||!i)this._+="L"+(this._x1=e)+","+(this._y1=t);else{var f=r-o,p=n-a,d=s*s+l*l,g=f*f+p*p,_=Math.sqrt(d),y=Math.sqrt(h),x=i*Math.tan((KQ-Math.acos((d+h-g)/(2*_*y)))/2),b=x/y,S=x/_;Math.abs(b-1)>Xy&&(this._+="L"+(e+b*c)+","+(t+b*u)),this._+="A"+i+","+i+",0,0,"+ +(u*f>c*p)+","+(this._x1=e+S*s)+","+(this._y1=t+S*l)}},arc:function(e,t,r,n,i,o){e=+e,t=+t,r=+r;var a=r*Math.cos(n),s=r*Math.sin(n),l=e+a,c=t+s,u=1^o,h=o?n-i:i-n;if(r<0)throw new Error("negative radius: "+r);this._x1===null?this._+="M"+l+","+c:(Math.abs(this._x1-l)>Xy||Math.abs(this._y1-c)>Xy)&&(this._+="L"+l+","+c),r&&(h<0&&(h=h%ZQ+ZQ),h>y6e?this._+="A"+r+","+r+",0,1,"+u+","+(e-a)+","+(t-s)+"A"+r+","+r+",0,1,"+u+","+(this._x1=l)+","+(this._y1=c):h>Xy&&(this._+="A"+r+","+r+",0,"+ +(h>=KQ)+","+u+","+(this._x1=e+r*Math.cos(i))+","+(this._y1=t+r*Math.sin(i))))},rect:function(e,t,r,n){this._+="M"+(this._x0=this._x1=+e)+","+(this._y0=this._y1=+t)+"h"+ +r+"v"+ +n+"h"+-r+"Z"},toString:function(){return this._}};K8t=$8t});var J8t=M(()=>{Z8t()});function Q8t(e){for(var t=-1,r=e.length,n,i=e[r-1],o=0;++t<r;)n=i,i=e[t],o+=n[1]*i[0]-n[0]*i[1];return o/2}var tRt=M(()=>{});function eRt(e){for(var t=-1,r=e.length,n=0,i=0,o,a=e[r-1],s,l=0;++t<r;)o=a,a=e[t],l+=s=o[0]*a[1]-a[0]*o[1],n+=(o[0]+a[0])*s,i+=(o[1]+a[1])*s;return l*=3,[n/l,i/l]}var rRt=M(()=>{});function nRt(e,t,r){return(t[0]-e[0])*(r[1]-e[1])-(t[1]-e[1])*(r[0]-e[0])}var iRt=M(()=>{});function v6e(e,t){return e[0]-t[0]||e[1]-t[1]}function oRt(e){for(var t=e.length,r=[0,1],n=2,i=2;i<t;++i){for(;n>1&&nRt(e[r[n-2]],e[r[n-1]],e[i])<=0;)--n;r[n++]=i}return r.slice(0,n)}function aRt(e){if((r=e.length)<3)return null;var t,r,n=new Array(r),i=new Array(r);for(t=0;t<r;++t)n[t]=[+e[t][0],+e[t][1],t];for(n.sort(v6e),t=0;t<r;++t)i[t]=[n[t][0],-n[t][1]];var o=oRt(n),a=oRt(i),s=a[0]===o[0],l=a[a.length-1]===o[o.length-1],c=[];for(t=o.length-1;t>=0;--t)c.push(e[n[o[t]][2]]);for(t=+s;t<a.length-l;++t)c.push(e[n[a[t]][2]]);return c}var sRt=M(()=>{iRt()});function lRt(e,t){for(var r=e.length,n=e[r-1],i=t[0],o=t[1],a=n[0],s=n[1],l,c,u=!1,h=0;h<r;++h)n=e[h],l=n[0],c=n[1],c>o!=s>o&&i<(a-l)*(o-c)/(s-c)+l&&(u=!u),a=l,s=c;return u}var cRt=M(()=>{});function uRt(e){for(var t=-1,r=e.length,n=e[r-1],i,o,a=n[0],s=n[1],l=0;++t<r;)i=a,o=s,n=e[t],a=n[0],s=n[1],i-=a,o-=s,l+=Math.sqrt(i*i+o*o);return l}var hRt=M(()=>{});var fRt=M(()=>{tRt();rRt();sRt();cRt();hRt()});function pRt(e){var t=+this._x.call(null,e),r=+this._y.call(null,e);return dRt(this.cover(t,r),t,r,e)}function dRt(e,t,r,n){if(isNaN(t)||isNaN(r))return e;var i,o=e._root,a={data:n},s=e._x0,l=e._y0,c=e._x1,u=e._y1,h,f,p,d,g,_,y,x;if(!o)return e._root=a,e;for(;o.length;)if((g=t>=(h=(s+c)/2))?s=h:c=h,(_=r>=(f=(l+u)/2))?l=f:u=f,i=o,!(o=o[y=_<<1|g]))return i[y]=a,e;if(p=+e._x.call(null,o.data),d=+e._y.call(null,o.data),t===p&&r===d)return a.next=o,i?i[y]=a:e._root=a,e;do i=i?i[y]=new Array(4):e._root=new Array(4),(g=t>=(h=(s+c)/2))?s=h:c=h,(_=r>=(f=(l+u)/2))?l=f:u=f;while((y=_<<1|g)===(x=(d>=f)<<1|p>=h));return i[x]=o,i[y]=a,e}function mRt(e){var t,r,n=e.length,i,o,a=new Array(n),s=new Array(n),l=1/0,c=1/0,u=-1/0,h=-1/0;for(r=0;r<n;++r)isNaN(i=+this._x.call(null,t=e[r]))||isNaN(o=+this._y.call(null,t))||(a[r]=i,s[r]=o,i<l&&(l=i),i>u&&(u=i),o<c&&(c=o),o>h&&(h=o));for(u<l&&(l=this._x0,u=this._x1),h<c&&(c=this._y0,h=this._y1),this.cover(l,c).cover(u,h),r=0;r<n;++r)dRt(this,a[r],s[r],e[r]);return this}var gRt=M(()=>{});function _Rt(e,t){if(isNaN(e=+e)||isNaN(t=+t))return this;var r=this._x0,n=this._y0,i=this._x1,o=this._y1;if(isNaN(r))i=(r=Math.floor(e))+1,o=(n=Math.floor(t))+1;else if(r>e||e>i||n>t||t>o){var a=i-r,s=this._root,l,c;switch(c=(t<(n+o)/2)<<1|e<(r+i)/2){case 0:{do l=new Array(4),l[c]=s,s=l;while(a*=2,i=r+a,o=n+a,e>i||t>o);break}case 1:{do l=new Array(4),l[c]=s,s=l;while(a*=2,r=i-a,o=n+a,r>e||t>o);break}case 2:{do l=new Array(4),l[c]=s,s=l;while(a*=2,i=r+a,n=o-a,e>i||n>t);break}case 3:{do l=new Array(4),l[c]=s,s=l;while(a*=2,r=i-a,n=o-a,r>e||n>t);break}}this._root&&this._root.length&&(this._root=s)}else return this;return this._x0=r,this._y0=n,this._x1=i,this._y1=o,this}var yRt=M(()=>{});function vRt(){var e=[];return this.visit(function(t){if(!t.length)do e.push(t.data);while(t=t.next)}),e}var xRt=M(()=>{});function bRt(e){return arguments.length?this.cover(+e[0][0],+e[0][1]).cover(+e[1][0],+e[1][1]):isNaN(this._x0)?void 0:[[this._x0,this._y0],[this._x1,this._y1]]}var wRt=M(()=>{});function Eo(e,t,r,n,i){this.node=e,this.x0=t,this.y0=r,this.x1=n,this.y1=i}var vO=M(()=>{});function SRt(e,t,r){var n,i=this._x0,o=this._y0,a,s,l,c,u=this._x1,h=this._y1,f=[],p=this._root,d,g;for(p&&f.push(new Eo(p,i,o,u,h)),r==null?r=1/0:(i=e-r,o=t-r,u=e+r,h=t+r,r*=r);d=f.pop();)if(!(!(p=d.node)||(a=d.x0)>u||(s=d.y0)>h||(l=d.x1)<i||(c=d.y1)<o))if(p.length){var _=(a+l)/2,y=(s+c)/2;f.push(new Eo(p[3],_,y,l,c),new Eo(p[2],a,y,_,c),new Eo(p[1],_,s,l,y),new Eo(p[0],a,s,_,y)),(g=(t>=y)<<1|e>=_)&&(d=f[f.length-1],f[f.length-1]=f[f.length-1-g],f[f.length-1-g]=d)}else{var x=e-+this._x.call(null,p.data),b=t-+this._y.call(null,p.data),S=x*x+b*b;if(S<r){var C=Math.sqrt(r=S);i=e-C,o=t-C,u=e+C,h=t+C,n=p.data}}return n}var MRt=M(()=>{vO()});function ERt(e){if(isNaN(u=+this._x.call(null,e))||isNaN(h=+this._y.call(null,e)))return this;var t,r=this._root,n,i,o,a=this._x0,s=this._y0,l=this._x1,c=this._y1,u,h,f,p,d,g,_,y;if(!r)return this;if(r.length)for(;;){if((d=u>=(f=(a+l)/2))?a=f:l=f,(g=h>=(p=(s+c)/2))?s=p:c=p,t=r,!(r=r[_=g<<1|d]))return this;if(!r.length)break;(t[_+1&3]||t[_+2&3]||t[_+3&3])&&(n=t,y=_)}for(;r.data!==e;)if(i=r,!(r=r.next))return this;return(o=r.next)&&delete r.next,i?(o?i.next=o:delete i.next,this):t?(o?t[_]=o:delete t[_],(r=t[0]||t[1]||t[2]||t[3])&&r===(t[3]||t[2]||t[1]||t[0])&&!r.length&&(n?n[y]=r:this._root=r),this):(this._root=o,this)}function TRt(e){for(var t=0,r=e.length;t<r;++t)this.remove(e[t]);return this}var CRt=M(()=>{});function ARt(){return this._root}var PRt=M(()=>{});function IRt(){var e=0;return this.visit(function(t){if(!t.length)do++e;while(t=t.next)}),e}var LRt=M(()=>{});function kRt(e){var t=[],r,n=this._root,i,o,a,s,l;for(n&&t.push(new Eo(n,this._x0,this._y0,this._x1,this._y1));r=t.pop();)if(!e(n=r.node,o=r.x0,a=r.y0,s=r.x1,l=r.y1)&&n.length){var c=(o+s)/2,u=(a+l)/2;(i=n[3])&&t.push(new Eo(i,c,u,s,l)),(i=n[2])&&t.push(new Eo(i,o,u,c,l)),(i=n[1])&&t.push(new Eo(i,c,a,s,u)),(i=n[0])&&t.push(new Eo(i,o,a,c,u))}return this}var RRt=M(()=>{vO()});function NRt(e){var t=[],r=[],n;for(this._root&&t.push(new Eo(this._root,this._x0,this._y0,this._x1,this._y1));n=t.pop();){var i=n.node;if(i.length){var o,a=n.x0,s=n.y0,l=n.x1,c=n.y1,u=(a+l)/2,h=(s+c)/2;(o=i[0])&&t.push(new Eo(o,a,s,u,h)),(o=i[1])&&t.push(new Eo(o,u,s,l,h)),(o=i[2])&&t.push(new Eo(o,a,h,u,c)),(o=i[3])&&t.push(new Eo(o,u,h,l,c))}r.push(n)}for(;n=r.pop();)e(n.node,n.x0,n.y0,n.x1,n.y1);return this}var DRt=M(()=>{vO()});function ORt(e){return e[0]}function zRt(e){return arguments.length?(this._x=e,this):this._x}var FRt=M(()=>{});function BRt(e){return e[1]}function HRt(e){return arguments.length?(this._y=e,this):this._y}var VRt=M(()=>{});function xO(e,t,r){var n=new QQ(t==null?ORt:t,r==null?BRt:r,NaN,NaN,NaN,NaN);return e==null?n:n.addAll(e)}function QQ(e,t,r,n,i,o){this._x=e,this._y=t,this._x0=r,this._y0=n,this._x1=i,this._y1=o,this._root=void 0}function URt(e){for(var t={data:e.data},r=t;e=e.next;)r=r.next={data:e.data};return t}var Xa,qRt=M(()=>{gRt();yRt();xRt();wRt();MRt();CRt();PRt();LRt();RRt();DRt();FRt();VRt();Xa=xO.prototype=QQ.prototype;Xa.copy=function(){var e=new QQ(this._x,this._y,this._x0,this._y0,this._x1,this._y1),t=this._root,r,n;if(!t)return e;if(!t.length)return e._root=URt(t),e;for(r=[{source:t,target:e._root=new Array(4)}];t=r.pop();)for(var i=0;i<4;++i)(n=t.source[i])&&(n.length?r.push({source:n,target:t.target[i]=new Array(4)}):t.target[i]=URt(n));return e};Xa.add=pRt;Xa.addAll=mRt;Xa.cover=_Rt;Xa.data=vRt;Xa.extent=bRt;Xa.find=SRt;Xa.remove=ERt;Xa.removeAll=TRt;Xa.root=ARt;Xa.size=IRt;Xa.visit=kRt;Xa.visitAfter=NRt;Xa.x=zRt;Xa.y=HRt});var GRt=M(()=>{qRt()});var WRt,YRt=M(()=>{WRt=[].slice});function ttt(e){this._size=e,this._call=this._error=null,this._tasks=[],this._data=[],this._waiting=this._active=this._ended=this._start=0}function jRt(e){if(!e._start)try{b6e(e)}catch(t){if(e._tasks[e._ended+e._active-1])ett(e,t);else if(!e._data)throw t}}function b6e(e){for(;e._start=e._waiting&&e._active<e._size;){var t=e._ended+e._active,r=e._tasks[t],n=r.length-1,i=r[n];r[n]=w6e(e,t),--e._waiting,++e._active,r=i.apply(null,r),e._tasks[t]&&(e._tasks[t]=r||x6e)}}function w6e(e,t){return function(r,n){!e._tasks[t]||(--e._active,++e._ended,e._tasks[t]=null,e._error==null&&(r!=null?ett(e,r):(e._data[t]=n,e._waiting?jRt(e):bO(e))))}}function ett(e,t){var r=e._tasks.length,n;for(e._error=t,e._data=void 0,e._waiting=NaN;--r>=0;)if((n=e._tasks[r])&&(e._tasks[r]=null,n.abort))try{n.abort()}catch(i){}e._active=NaN,bO(e)}function bO(e){if(!e._active&&e._call){var t=e._data;e._data=void 0,e._call(e._error,t)}}function wO(e){if(e==null)e=1/0;else if(!((e=+e)>=1))throw new Error("invalid concurrency");return new ttt(e)}var x6e,XRt=M(()=>{YRt();x6e={};ttt.prototype=wO.prototype={constructor:ttt,defer:function(e){if(typeof e!="function")throw new Error("invalid callback");if(this._call)throw new Error("defer after await");if(this._error!=null)return this;var t=WRt.call(arguments,1);return t.push(e),++this._waiting,this._tasks.push(t),jRt(this),this},abort:function(){return this._error==null&&ett(this,new Error("abort")),this},await:function(e){if(typeof e!="function")throw new Error("invalid callback");if(this._call)throw new Error("multiple await");return this._call=function(t,r){e.apply(null,[t].concat(r))},bO(this),this},awaitAll:function(e){if(typeof e!="function")throw new Error("invalid callback");if(this._call)throw new Error("multiple await");return this._call=e,bO(this),this}}});var $Rt=M(()=>{XRt()});function bc(){return Math.random()}var $y=M(()=>{});var KRt,ZRt=M(()=>{$y();KRt=function e(t){function r(n,i){return n=n==null?0:+n,i=i==null?1:+i,arguments.length===1?(i=n,n=0):i-=n,function(){return t()*i+n}}return r.source=e,r}(bc)});var SO,rtt=M(()=>{$y();SO=function e(t){function r(n,i){var o,a;return n=n==null?0:+n,i=i==null?1:+i,function(){var s;if(o!=null)s=o,o=null;else do o=t()*2-1,s=t()*2-1,a=o*o+s*s;while(!a||a>1);return n+i*s*Math.sqrt(-2*Math.log(a)/a)}}return r.source=e,r}(bc)});var JRt,QRt=M(()=>{$y();rtt();JRt=function e(t){function r(){var n=SO.source(t).apply(this,arguments);return function(){return Math.exp(n())}}return r.source=e,r}(bc)});var MO,ntt=M(()=>{$y();MO=function e(t){function r(n){return function(){for(var i=0,o=0;o<n;++o)i+=t();return i}}return r.source=e,r}(bc)});var tNt,eNt=M(()=>{$y();ntt();tNt=function e(t){function r(n){var i=MO.source(t)(n);return function(){return i()/n}}return r.source=e,r}(bc)});var rNt,nNt=M(()=>{$y();rNt=function e(t){function r(n){return function(){return-Math.log(1-t())/n}}return r.source=e,r}(bc)});var iNt=M(()=>{ZRt();rtt();QRt();eNt();ntt();nNt()});function J2(e,t){var r,n=vs("beforesend","progress","load","error"),i,o=Ji(),a=new XMLHttpRequest,s=null,l=null,c,u,h=0;typeof XDomainRequest!="undefined"&&!("withCredentials"in a)&&/^(http(s)?:)?\/\//.test(e)&&(a=new XDomainRequest),"onload"in a?a.onload=a.onerror=a.ontimeout=f:a.onreadystatechange=function(p){a.readyState>3&&f(p)};function f(p){var d=a.status,g;if(!d&&M6e(a)||d>=200&&d<300||d===304){if(c)try{g=c.call(r,a)}catch(_){n.call("error",r,_);return}else g=a;n.call("load",r,g)}else n.call("error",r,p)}if(a.onprogress=function(p){n.call("progress",r,p)},r={header:function(p,d){return p=(p+"").toLowerCase(),arguments.length<2?o.get(p):(d==null?o.remove(p):o.set(p,d+""),r)},mimeType:function(p){return arguments.length?(i=p==null?null:p+"",r):i},responseType:function(p){return arguments.length?(u=p,r):u},timeout:function(p){return arguments.length?(h=+p,r):h},user:function(p){return arguments.length<1?s:(s=p==null?null:p+"",r)},password:function(p){return arguments.length<1?l:(l=p==null?null:p+"",r)},response:function(p){return c=p,r},get:function(p,d){return r.send("GET",p,d)},post:function(p,d){return r.send("POST",p,d)},send:function(p,d,g){return a.open(p,e,!0,s,l),i!=null&&!o.has("accept")&&o.set("accept",i+",*/*"),a.setRequestHeader&&o.each(function(_,y){a.setRequestHeader(y,_)}),i!=null&&a.overrideMimeType&&a.overrideMimeType(i),u!=null&&(a.responseType=u),h>0&&(a.timeout=h),g==null&&typeof d=="function"&&(g=d,d=null),g!=null&&g.length===1&&(g=S6e(g)),g!=null&&r.on("error",g).on("load",function(_){g(null,_)}),n.call("beforesend",r,a),a.send(d==null?null:d),r},abort:function(){return a.abort(),r},on:function(){var p=n.on.apply(n,arguments);return p===n?r:p}},t!=null){if(typeof t!="function")throw new Error("invalid callback: "+t);return r.get(t)}return r}function S6e(e){return function(t,r){e(t==null?r:null)}}function M6e(e){var t=e.responseType;return t&&t!=="text"?e.response:e.responseText}var EO=M(()=>{Tb();km()});function Tg(e,t){return function(r,n){var i=J2(r).mimeType(e).response(t);if(n!=null){if(typeof n!="function")throw new Error("invalid callback: "+n);return i.get(n)}return i}}var oC=M(()=>{EO()});var oNt,aNt=M(()=>{oC();oNt=Tg("text/html",function(e){return document.createRange().createContextualFragment(e.responseText)})});var sNt,lNt=M(()=>{oC();sNt=Tg("application/json",function(e){return JSON.parse(e.responseText)})});var cNt,uNt=M(()=>{oC();cNt=Tg("text/plain",function(e){return e.responseText})});var hNt,fNt=M(()=>{oC();hNt=Tg("application/xml",function(e){var t=e.responseXML;if(!t)throw new Error("parse error");return t})});function TO(e,t){return function(r,n,i){arguments.length<3&&(i=n,n=null);var o=J2(r).mimeType(e);return o.row=function(a){return arguments.length?o.response(E6e(t,n=a)):n},o.row(n),i?o.get(i):o}}function E6e(e,t){return function(r){return e(r.responseText,t)}}var itt=M(()=>{EO()});var pNt,dNt=M(()=>{qE();itt();pNt=TO("text/csv",Cb)});var mNt,gNt=M(()=>{qE();itt();mNt=TO("text/tab-separated-values",Ab)});var _Nt=M(()=>{EO();aNt();lNt();uNt();fNt();dNt();gNt()});function pf(e,t){return e<t?-1:e>t?1:e>=t?0:NaN}var Ky=M(()=>{});function aC(e){return e.length===1&&(e=T6e(e)),{left:function(t,r,n,i){for(n==null&&(n=0),i==null&&(i=t.length);n<i;){var o=n+i>>>1;e(t[o],r)<0?n=o+1:i=o}return n},right:function(t,r,n,i){for(n==null&&(n=0),i==null&&(i=t.length);n<i;){var o=n+i>>>1;e(t[o],r)>0?i=o:n=o+1}return n}}}function T6e(e){return function(t,r){return pf(e(t),r)}}var ott=M(()=>{Ky()});var yNt,vNt,C6e,df,att=M(()=>{Ky();ott();yNt=aC(pf),vNt=yNt.right,C6e=yNt.left,df=vNt});var stt=M(()=>{});var xNt=M(()=>{stt()});var bNt=M(()=>{});function Q2(e){return e===null?NaN:+e}var tw=M(()=>{});var ltt=M(()=>{tw()});var ctt=M(()=>{ltt()});var utt=M(()=>{});var wNt,P6e,I6e,htt=M(()=>{wNt=Array.prototype,P6e=wNt.slice,I6e=wNt.map});var SNt=M(()=>{});var MNt=M(()=>{});function CO(e,t,r){e=+e,t=+t,r=(i=arguments.length)<2?(t=e,e=0,1):i<3?1:+r;for(var n=-1,i=Math.max(0,Math.ceil((t-e)/r))|0,o=new Array(i);++n<i;)o[n]=e+n*r;return o}var ftt=M(()=>{});function sC(e,t,r){var n,i=-1,o,a,s;if(t=+t,e=+e,r=+r,e===t&&r>0)return[e];if((n=t<e)&&(o=e,e=t,t=o),(s=ew(e,t,r))===0||!isFinite(s))return[];if(s>0)for(e=Math.ceil(e/s),t=Math.floor(t/s),a=new Array(o=Math.ceil(t-e+1));++i<o;)a[i]=(e+i)*s;else for(e=Math.floor(e*s),t=Math.ceil(t*s),a=new Array(o=Math.ceil(e-t+1));++i<o;)a[i]=(e-i)/s;return n&&a.reverse(),a}function ew(e,t,r){var n=(t-e)/Math.max(0,r),i=Math.floor(Math.log(n)/Math.LN10),o=n/Math.pow(10,i);return i>=0?(o>=ptt?10:o>=dtt?5:o>=mtt?2:1)*Math.pow(10,i):-Math.pow(10,-i)/(o>=ptt?10:o>=dtt?5:o>=mtt?2:1)}function Zy(e,t,r){var n=Math.abs(t-e)/Math.max(0,r),i=Math.pow(10,Math.floor(Math.log(n)/Math.LN10)),o=n/i;return o>=ptt?i*=10:o>=dtt?i*=5:o>=mtt&&(i*=2),t<e?-i:i}var ptt,dtt,mtt,gtt=M(()=>{ptt=Math.sqrt(50),dtt=Math.sqrt(10),mtt=Math.sqrt(2)});var _tt=M(()=>{});var ENt=M(()=>{htt();att();SNt();utt();MNt();ftt();gtt();_tt()});function lC(e,t,r){if(r==null&&(r=Q2),!!(n=e.length)){if((t=+t)<=0||n<2)return+r(e[0],0,e);if(t>=1)return+r(e[n-1],n-1,e);var n,i=(n-1)*t,o=Math.floor(i),a=+r(e[o],o,e),s=+r(e[o+1],o+1,e);return a+(s-a)*(i-o)}}var AO=M(()=>{tw()});var TNt=M(()=>{htt();Ky();tw();AO()});var CNt=M(()=>{ctt()});var ANt=M(()=>{});var PNt=M(()=>{tw()});var INt=M(()=>{Ky();tw();AO()});var LNt=M(()=>{});var ytt=M(()=>{});var kNt=M(()=>{});var RNt=M(()=>{Ky()});var NNt=M(()=>{});var DNt=M(()=>{});var vtt=M(()=>{ytt()});var ONt=M(()=>{vtt()});var mf=M(()=>{att();Ky();ott();xNt();bNt();ctt();utt();ENt();TNt();CNt();_tt();ANt();PNt();INt();LNt();ytt();stt();kNt();AO();ftt();RNt();NNt();DNt();gtt();vtt();ltt();ONt()});function PO(){}function zNt(e,t){var r=new PO;if(e instanceof PO)e.each(function(s,l){r.set(l,s)});else if(Array.isArray(e)){var n=-1,i=e.length,o;if(t==null)for(;++n<i;)r.set(n,e[n]);else for(;++n<i;)r.set(t(o=e[n],n,e),o)}else if(e)for(var a in e)r.set(a,e[a]);return r}var fl,Jy,IO=M(()=>{fl="$";PO.prototype=zNt.prototype={constructor:PO,has:function(e){return fl+e in this},get:function(e){return this[fl+e]},set:function(e,t){return this[fl+e]=t,this},remove:function(e){var t=fl+e;return t in this&&delete this[t]},clear:function(){for(var e in this)e[0]===fl&&delete this[e]},keys:function(){var e=[];for(var t in this)t[0]===fl&&e.push(t.slice(1));return e},values:function(){var e=[];for(var t in this)t[0]===fl&&e.push(this[t]);return e},entries:function(){var e=[];for(var t in this)t[0]===fl&&e.push({key:t.slice(1),value:this[t]});return e},size:function(){var e=0;for(var t in this)t[0]===fl&&++e;return e},empty:function(){for(var e in this)if(e[0]===fl)return!1;return!0},each:function(e){for(var t in this)t[0]===fl&&e(this[t],t.slice(1),this)}};Jy=zNt});var FNt=M(()=>{IO()});function LO(){}function O6e(e,t){var r=new LO;if(e instanceof LO)e.each(function(o){r.add(o)});else if(e){var n=-1,i=e.length;if(t==null)for(;++n<i;)r.add(e[n]);else for(;++n<i;)r.add(t(e[n],n,e))}return r}var Qy,BNt=M(()=>{IO();Qy=Jy.prototype;LO.prototype=O6e.prototype={constructor:LO,has:Qy.has,add:function(e){return e+="",this[fl+e]=e,this},remove:Qy.remove,clear:Qy.clear,values:Qy.keys,size:Qy.size,empty:Qy.empty,each:Qy.each}});var HNt=M(()=>{});var VNt=M(()=>{});var UNt=M(()=>{});var qNt=M(()=>{FNt();BNt();IO();HNt();VNt();UNt()});var GNt,rw,pl,Cg=M(()=>{GNt=Array.prototype,rw=GNt.map,pl=GNt.slice});function nw(e){var t=Jy(),r=[],n=kO;e=e==null?[]:pl.call(e);function i(o){var a=o+"",s=t.get(a);if(!s){if(n!==kO)return n;t.set(a,s=r.push(o))}return e[(s-1)%e.length]}return i.domain=function(o){if(!arguments.length)return r.slice();r=[],t=Jy();for(var a=-1,s=o.length,l,c;++a<s;)t.has(c=(l=o[a])+"")||t.set(c,r.push(l));return i},i.range=function(o){return arguments.length?(e=pl.call(o),i):e.slice()},i.unknown=function(o){return arguments.length?(n=o,i):n},i.copy=function(){return nw().domain(r).range(e).unknown(n)},i}var kO,xtt=M(()=>{qNt();Cg();kO={name:"implicit"}});function cC(){var e=nw().unknown(void 0),t=e.domain,r=e.range,n=[0,1],i,o,a=!1,s=0,l=0,c=.5;delete e.unknown;function u(){var h=t().length,f=n[1]<n[0],p=n[f-0],d=n[1-f];i=(d-p)/Math.max(1,h-s+l*2),a&&(i=Math.floor(i)),p+=(d-p-i*(h-s))*c,o=i*(1-s),a&&(p=Math.round(p),o=Math.round(o));var g=CO(h).map(function(_){return p+i*_});return r(f?g.reverse():g)}return e.domain=function(h){return arguments.length?(t(h),u()):t()},e.range=function(h){return arguments.length?(n=[+h[0],+h[1]],u()):n.slice()},e.rangeRound=function(h){return n=[+h[0],+h[1]],a=!0,u()},e.bandwidth=function(){return o},e.step=function(){return i},e.round=function(h){return arguments.length?(a=!!h,u()):a},e.padding=function(h){return arguments.length?(s=l=Math.max(0,Math.min(1,h)),u()):s},e.paddingInner=function(h){return arguments.length?(s=Math.max(0,Math.min(1,h)),u()):s},e.paddingOuter=function(h){return arguments.length?(l=Math.max(0,Math.min(1,h)),u()):l},e.align=function(h){return arguments.length?(c=Math.max(0,Math.min(1,h)),u()):c},e.copy=function(){return cC().domain(t()).range(n).round(a).paddingInner(s).paddingOuter(l).align(c)},u()}function WNt(e){var t=e.copy;return e.padding=e.paddingOuter,delete e.paddingInner,delete e.paddingOuter,e.copy=function(){return WNt(t())},e}function YNt(){return WNt(cC().paddingInner(1))}var jNt=M(()=>{mf();xtt()});function iw(e,t,r){e.prototype=t.prototype=r,r.constructor=e}function uC(e,t){var r=Object.create(e.prototype);for(var n in t)r[n]=t[n];return r}var btt=M(()=>{});function ev(){}function $Nt(){return this.rgb().formatHex()}function G6e(){return eDt(this).formatHsl()}function KNt(){return this.rgb().formatRgb()}function Pg(e){var t,r;return e=(e+"").trim().toLowerCase(),(t=z6e.exec(e))?(r=t[1].length,t=parseInt(t[1],16),r===6?ZNt(t):r===3?new ha(t>>8&15|t>>4&240,t>>4&15|t&240,(t&15)<<4|t&15,1):r===8?RO(t>>24&255,t>>16&255,t>>8&255,(t&255)/255):r===4?RO(t>>12&15|t>>8&240,t>>8&15|t>>4&240,t>>4&15|t&240,((t&15)<<4|t&15)/255):null):(t=F6e.exec(e))?new ha(t[1],t[2],t[3],1):(t=B6e.exec(e))?new ha(t[1]*255/100,t[2]*255/100,t[3]*255/100,1):(t=H6e.exec(e))?RO(t[1],t[2],t[3],t[4]):(t=V6e.exec(e))?RO(t[1]*255/100,t[2]*255/100,t[3]*255/100,t[4]):(t=U6e.exec(e))?tDt(t[1],t[2]/100,t[3]/100,1):(t=q6e.exec(e))?tDt(t[1],t[2]/100,t[3]/100,t[4]):XNt.hasOwnProperty(e)?ZNt(XNt[e]):e==="transparent"?new ha(NaN,NaN,NaN,0):null}function ZNt(e){return new ha(e>>16&255,e>>8&255,e&255,1)}function RO(e,t,r,n){return n<=0&&(e=t=r=NaN),new ha(e,t,r,n)}function Mtt(e){return e instanceof ev||(e=Pg(e)),e?(e=e.rgb(),new ha(e.r,e.g,e.b,e.opacity)):new ha}function aw(e,t,r,n){return arguments.length===1?Mtt(e):new ha(e,t,r,n==null?1:n)}function ha(e,t,r,n){this.r=+e,this.g=+t,this.b=+r,this.opacity=+n}function JNt(){return"#"+wtt(this.r)+wtt(this.g)+wtt(this.b)}function QNt(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"rgb(":"rgba(")+Math.max(0,Math.min(255,Math.round(this.r)||0))+", "+Math.max(0,Math.min(255,Math.round(this.g)||0))+", "+Math.max(0,Math.min(255,Math.round(this.b)||0))+(e===1?")":", "+e+")")}function wtt(e){return e=Math.max(0,Math.min(255,Math.round(e)||0)),(e<16?"0":"")+e.toString(16)}function tDt(e,t,r,n){return n<=0?e=t=r=NaN:r<=0||r>=1?e=t=NaN:t<=0&&(e=NaN),new gf(e,t,r,n)}function eDt(e){if(e instanceof gf)return new gf(e.h,e.s,e.l,e.opacity);if(e instanceof ev||(e=Pg(e)),!e)return new gf;if(e instanceof gf)return e;e=e.rgb();var t=e.r/255,r=e.g/255,n=e.b/255,i=Math.min(t,r,n),o=Math.max(t,r,n),a=NaN,s=o-i,l=(o+i)/2;return s?(t===o?a=(r-n)/s+(r<n)*6:r===o?a=(n-t)/s+2:a=(t-r)/s+4,s/=l<.5?o+i:2-o-i,a*=60):s=l>0&&l<1?0:a,new gf(a,s,l,e.opacity)}function rDt(e,t,r,n){return arguments.length===1?eDt(e):new gf(e,t,r,n==null?1:n)}function gf(e,t,r,n){this.h=+e,this.s=+t,this.l=+r,this.opacity=+n}function Stt(e,t,r){return(e<60?t+(r-t)*e/60:e<180?r:e<240?t+(r-t)*(240-e)/60:t)*255}var Ag,tv,ow,hC,_f,z6e,F6e,B6e,H6e,V6e,U6e,q6e,XNt,Ett=M(()=>{btt();Ag=.7,tv=1/Ag,ow="\\s*([+-]?\\d+)\\s*",hC="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",_f="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",z6e=/^#([0-9a-f]{3,8})$/,F6e=new RegExp("^rgb\\("+[ow,ow,ow]+"\\)$"),B6e=new RegExp("^rgb\\("+[_f,_f,_f]+"\\)$"),H6e=new RegExp("^rgba\\("+[ow,ow,ow,hC]+"\\)$"),V6e=new RegExp("^rgba\\("+[_f,_f,_f,hC]+"\\)$"),U6e=new RegExp("^hsl\\("+[hC,_f,_f]+"\\)$"),q6e=new RegExp("^hsla\\("+[hC,_f,_f,hC]+"\\)$"),XNt={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};iw(ev,Pg,{copy:function(e){return Object.assign(new this.constructor,this,e)},displayable:function(){return this.rgb().displayable()},hex:$Nt,formatHex:$Nt,formatHsl:G6e,formatRgb:KNt,toString:KNt});iw(ha,aw,uC(ev,{brighter:function(e){return e=e==null?tv:Math.pow(tv,e),new ha(this.r*e,this.g*e,this.b*e,this.opacity)},darker:function(e){return e=e==null?Ag:Math.pow(Ag,e),new ha(this.r*e,this.g*e,this.b*e,this.opacity)},rgb:function(){return this},displayable:function(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:JNt,formatHex:JNt,formatRgb:QNt,toString:QNt}));iw(gf,rDt,uC(ev,{brighter:function(e){return e=e==null?tv:Math.pow(tv,e),new gf(this.h,this.s,this.l*e,this.opacity)},darker:function(e){return e=e==null?Ag:Math.pow(Ag,e),new gf(this.h,this.s,this.l*e,this.opacity)},rgb:function(){var e=this.h%360+(this.h<0)*360,t=isNaN(e)||isNaN(this.s)?0:this.s,r=this.l,n=r+(r<.5?r:1-r)*t,i=2*r-n;return new ha(Stt(e>=240?e-240:e+120,i,n),Stt(e,i,n),Stt(e<120?e+240:e-120,i,n),this.opacity)},displayable:function(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl:function(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"hsl(":"hsla(")+(this.h||0)+", "+(this.s||0)*100+"%, "+(this.l||0)*100+"%"+(e===1?")":", "+e+")")}}))});var nDt,iDt,oDt=M(()=>{nDt=Math.PI/180,iDt=180/Math.PI});function W6e(e){if(e instanceof rv)return new rv(e.h,e.s,e.l,e.opacity);e instanceof ha||(e=Mtt(e));var t=e.r/255,r=e.g/255,n=e.b/255,i=(lDt*n+aDt*t-sDt*r)/(lDt+aDt-sDt),o=n-i,a=(fC*(r-i)-Ctt*o)/NO,s=Math.sqrt(a*a+o*o)/(fC*i*(1-i)),l=s?Math.atan2(a,o)*iDt-120:NaN;return new rv(l<0?l+360:l,s,i,e.opacity)}function $a(e,t,r,n){return arguments.length===1?W6e(e):new rv(e,t,r,n==null?1:n)}function rv(e,t,r,n){this.h=+e,this.s=+t,this.l=+r,this.opacity=+n}var cDt,Ttt,Ctt,NO,fC,aDt,sDt,lDt,uDt=M(()=>{btt();Ett();oDt();cDt=-.14861,Ttt=1.78277,Ctt=-.29227,NO=-.90649,fC=1.97294,aDt=fC*NO,sDt=fC*Ttt,lDt=Ttt*Ctt-NO*cDt;iw(rv,$a,uC(ev,{brighter:function(e){return e=e==null?tv:Math.pow(tv,e),new rv(this.h,this.s,this.l*e,this.opacity)},darker:function(e){return e=e==null?Ag:Math.pow(Ag,e),new rv(this.h,this.s,this.l*e,this.opacity)},rgb:function(){var e=isNaN(this.h)?0:(this.h+120)*nDt,t=+this.l,r=isNaN(this.s)?0:this.s*t*(1-t),n=Math.cos(e),i=Math.sin(e);return new ha(255*(t+r*(cDt*n+Ttt*i)),255*(t+r*(Ctt*n+NO*i)),255*(t+r*(fC*n)),this.opacity)}}))});var sw=M(()=>{Ett();uDt()});function Att(e,t,r,n,i){var o=e*e,a=o*e;return((1-3*e+3*o-a)*t+(4-6*o+3*a)*r+(1+3*e+3*o-3*a)*n+a*i)/6}function hDt(e){var t=e.length-1;return function(r){var n=r<=0?r=0:r>=1?(r=1,t-1):Math.floor(r*t),i=e[n],o=e[n+1],a=n>0?e[n-1]:2*i-o,s=n<t-1?e[n+2]:2*o-i;return Att((r-n/t)*t,a,i,o,s)}}var Ptt=M(()=>{});function fDt(e){var t=e.length;return function(r){var n=Math.floor(((r%=1)<0?++r:r)*t),i=e[(n+t-1)%t],o=e[n%t],a=e[(n+1)%t],s=e[(n+2)%t];return Att((r-n/t)*t,i,o,a,s)}}var pDt=M(()=>{Ptt()});function lw(e){return function(){return e}}var Itt=M(()=>{});function dDt(e,t){return function(r){return e+r*t}}function Y6e(e,t,r){return e=Math.pow(e,r),t=Math.pow(t,r)-e,r=1/r,function(n){return Math.pow(e+n*t,r)}}function mDt(e,t){var r=t-e;return r?dDt(e,r>180||r<-180?r-360*Math.round(r/360):r):lw(isNaN(e)?t:e)}function gDt(e){return(e=+e)==1?nd:function(t,r){return r-t?Y6e(t,r,e):lw(isNaN(t)?r:t)}}function nd(e,t){var r=t-e;return r?dDt(e,r):lw(isNaN(e)?t:e)}var Ltt=M(()=>{Itt()});function _Dt(e){return function(t){var r=t.length,n=new Array(r),i=new Array(r),o=new Array(r),a,s;for(a=0;a<r;++a)s=aw(t[a]),n[a]=s.r||0,i[a]=s.g||0,o[a]=s.b||0;return n=e(n),i=e(i),o=e(o),s.opacity=1,function(l){return s.r=n(l),s.g=i(l),s.b=o(l),s+""}}}var ktt,_5n,y5n,yDt=M(()=>{sw();Ptt();pDt();Ltt();ktt=function e(t){var r=gDt(t);function n(i,o){var a=r((i=aw(i)).r,(o=aw(o)).r),s=r(i.g,o.g),l=r(i.b,o.b),c=nd(i.opacity,o.opacity);return function(u){return i.r=a(u),i.g=s(u),i.b=l(u),i.opacity=c(u),i+""}}return n.gamma=e,n}(1);_5n=_Dt(hDt),y5n=_Dt(fDt)});function vDt(e,t){t||(t=[]);var r=e?Math.min(t.length,e.length):0,n=t.slice(),i;return function(o){for(i=0;i<r;++i)n[i]=e[i]*(1-o)+t[i]*o;return n}}function xDt(e){return ArrayBuffer.isView(e)&&!(e instanceof DataView)}var bDt=M(()=>{});function wDt(e,t){var r=t?t.length:0,n=e?Math.min(r,e.length):0,i=new Array(n),o=new Array(r),a;for(a=0;a<n;++a)i[a]=nv(e[a],t[a]);for(;a<r;++a)o[a]=t[a];return function(s){for(a=0;a<n;++a)o[a]=i[a](s);return o}}var SDt=M(()=>{DO()});function MDt(e,t){var r=new Date;return e=+e,t=+t,function(n){return r.setTime(e*(1-n)+t*n),r}}var EDt=M(()=>{});function yf(e,t){return e=+e,t=+t,function(r){return e*(1-r)+t*r}}var OO=M(()=>{});function TDt(e,t){var r={},n={},i;(e===null||typeof e!="object")&&(e={}),(t===null||typeof t!="object")&&(t={});for(i in t)i in e?r[i]=nv(e[i],t[i]):n[i]=t[i];return function(o){for(i in r)n[i]=r[i](o);return n}}var CDt=M(()=>{DO()});function j6e(e){return function(){return e}}function X6e(e){return function(t){return e(t)+""}}function ADt(e,t){var r=Ntt.lastIndex=Rtt.lastIndex=0,n,i,o,a=-1,s=[],l=[];for(e=e+"",t=t+"";(n=Ntt.exec(e))&&(i=Rtt.exec(t));)(o=i.index)>r&&(o=t.slice(r,o),s[a]?s[a]+=o:s[++a]=o),(n=n[0])===(i=i[0])?s[a]?s[a]+=i:s[++a]=i:(s[++a]=null,l.push({i:a,x:yf(n,i)})),r=Rtt.lastIndex;return r<t.length&&(o=t.slice(r),s[a]?s[a]+=o:s[++a]=o),s.length<2?l[0]?X6e(l[0].x):j6e(t):(t=l.length,function(c){for(var u=0,h;u<t;++u)s[(h=l[u]).i]=h.x(c);return s.join("")})}var Ntt,Rtt,PDt=M(()=>{OO();Ntt=/[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,Rtt=new RegExp(Ntt.source,"g")});function nv(e,t){var r=typeof t,n;return t==null||r==="boolean"?lw(t):(r==="number"?yf:r==="string"?(n=Pg(t))?(t=n,ktt):ADt:t instanceof Pg?ktt:t instanceof Date?MDt:xDt(t)?vDt:Array.isArray(t)?wDt:typeof t.valueOf!="function"&&typeof t.toString!="function"||isNaN(t)?TDt:yf)(e,t)}var DO=M(()=>{sw();yDt();SDt();EDt();OO();CDt();PDt();Itt();bDt()});function Dtt(e,t){return e=+e,t=+t,function(r){return Math.round(e*(1-r)+t*r)}}var IDt=M(()=>{});function LDt(e){return function t(r){r=+r;function n(i,o){var a=e((i=$a(i)).h,(o=$a(o)).h),s=nd(i.s,o.s),l=nd(i.l,o.l),c=nd(i.opacity,o.opacity);return function(u){return i.h=a(u),i.s=s(u),i.l=l(Math.pow(u,r)),i.opacity=c(u),i+""}}return n.gamma=t,n}(1)}var $6e,cw,kDt=M(()=>{sw();Ltt();$6e=LDt(mDt),cw=LDt(nd)});var uw=M(()=>{DO();OO();IDt();kDt()});function hw(e){return function(){return e}}var zO=M(()=>{});function FO(e){return+e}var Ott=M(()=>{});function pC(e,t){return(t-=e=+e)?function(r){return(r-e)/t}:hw(t)}function K6e(e){return function(t,r){var n=e(t=+t,r=+r);return function(i){return i<=t?0:i>=r?1:n(i)}}}function Z6e(e){return function(t,r){var n=e(t=+t,r=+r);return function(i){return i<=0?t:i>=1?r:n(i)}}}function J6e(e,t,r,n){var i=e[0],o=e[1],a=t[0],s=t[1];return o<i?(i=r(o,i),a=n(s,a)):(i=r(i,o),a=n(a,s)),function(l){return a(i(l))}}function Q6e(e,t,r,n){var i=Math.min(e.length,t.length)-1,o=new Array(i),a=new Array(i),s=-1;for(e[i]<e[0]&&(e=e.slice().reverse(),t=t.slice().reverse());++s<i;)o[s]=r(e[s],e[s+1]),a[s]=n(t[s],t[s+1]);return function(l){var c=df(e,l,1,i)-1;return a[c](o[c](l))}}function Ig(e,t){return t.domain(e.domain()).range(e.range()).interpolate(e.interpolate()).clamp(e.clamp())}function id(e,t){var r=RDt,n=RDt,i=nv,o=!1,a,s,l;function c(){return a=Math.min(r.length,n.length)>2?Q6e:J6e,s=l=null,u}function u(h){return(s||(s=a(r,n,o?K6e(e):e,i)))(+h)}return u.invert=function(h){return(l||(l=a(n,r,pC,o?Z6e(t):t)))(+h)},u.domain=function(h){return arguments.length?(r=rw.call(h,FO),c()):r.slice()},u.range=function(h){return arguments.length?(n=pl.call(h),c()):n.slice()},u.rangeRound=function(h){return n=pl.call(h),i=Dtt,c()},u.clamp=function(h){return arguments.length?(o=!!h,c()):o},u.interpolate=function(h){return arguments.length?(i=h,c()):i},c()}var RDt,dC=M(()=>{mf();uw();Cg();zO();Ott();RDt=[0,1]});function NDt(e){return Math.abs(e=Math.round(e))>=1e21?e.toLocaleString("en").replace(/,/g,""):e.toString(10)}function iv(e,t){if((r=(e=t?e.toExponential(t-1):e.toExponential()).indexOf("e"))<0)return null;var r,n=e.slice(0,r);return[n.length>1?n[0]+n.slice(2):n,+e.slice(r+1)]}var mC=M(()=>{});function vf(e){return e=iv(Math.abs(e)),e?e[1]:NaN}var gC=M(()=>{mC()});function DDt(e,t){return function(r,n){for(var i=r.length,o=[],a=0,s=e[0],l=0;i>0&&s>0&&(l+s+1>n&&(s=Math.max(1,n-l)),o.push(r.substring(i-=s,i+s)),!((l+=s+1)>n));)s=e[a=(a+1)%e.length];return o.reverse().join(t)}}var ODt=M(()=>{});function zDt(e){return function(t){return t.replace(/[0-9]/g,function(r){return e[+r]})}}var FDt=M(()=>{});function Lg(e){if(!(t=tIe.exec(e)))throw new Error("invalid format: "+e);var t;return new BO({fill:t[1],align:t[2],sign:t[3],symbol:t[4],zero:t[5],width:t[6],comma:t[7],precision:t[8]&&t[8].slice(1),trim:t[9],type:t[10]})}function BO(e){this.fill=e.fill===void 0?" ":e.fill+"",this.align=e.align===void 0?">":e.align+"",this.sign=e.sign===void 0?"-":e.sign+"",this.symbol=e.symbol===void 0?"":e.symbol+"",this.zero=!!e.zero,this.width=e.width===void 0?void 0:+e.width,this.comma=!!e.comma,this.precision=e.precision===void 0?void 0:+e.precision,this.trim=!!e.trim,this.type=e.type===void 0?"":e.type+""}var tIe,ztt=M(()=>{tIe=/^(?:(.)?([<>=^]))?([+\-( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?(~)?([a-z%])?$/i;Lg.prototype=BO.prototype;BO.prototype.toString=function(){return this.fill+this.align+this.sign+this.symbol+(this.zero?"0":"")+(this.width===void 0?"":Math.max(1,this.width|0))+(this.comma?",":"")+(this.precision===void 0?"":"."+Math.max(0,this.precision|0))+(this.trim?"~":"")+this.type}});function BDt(e){t:for(var t=e.length,r=1,n=-1,i;r<t;++r)switch(e[r]){case".":n=i=r;break;case"0":n===0&&(n=r),i=r;break;default:if(!+e[r])break t;n>0&&(n=0);break}return n>0?e.slice(0,n)+e.slice(i+1):e}var HDt=M(()=>{});function VDt(e,t){var r=iv(e,t);if(!r)return e+"";var n=r[0],i=r[1],o=i-(Ftt=Math.max(-8,Math.min(8,Math.floor(i/3)))*3)+1,a=n.length;return o===a?n:o>a?n+new Array(o-a+1).join("0"):o>0?n.slice(0,o)+"."+n.slice(o):"0."+new Array(1-o).join("0")+iv(e,Math.max(0,t+o-1))[0]}var Ftt,Btt=M(()=>{mC()});function Htt(e,t){var r=iv(e,t);if(!r)return e+"";var n=r[0],i=r[1];return i<0?"0."+new Array(-i).join("0")+n:n.length>i+1?n.slice(0,i+1)+"."+n.slice(i+1):n+new Array(i-n.length+2).join("0")}var UDt=M(()=>{mC()});var Vtt,qDt=M(()=>{mC();Btt();UDt();Vtt={"%":function(e,t){return(e*100).toFixed(t)},b:function(e){return Math.round(e).toString(2)},c:function(e){return e+""},d:NDt,e:function(e,t){return e.toExponential(t)},f:function(e,t){return e.toFixed(t)},g:function(e,t){return e.toPrecision(t)},o:function(e){return Math.round(e).toString(8)},p:function(e,t){return Htt(e*100,t)},r:Htt,s:VDt,X:function(e){return Math.round(e).toString(16).toUpperCase()},x:function(e){return Math.round(e).toString(16)}}});function Utt(e){return e}var GDt=M(()=>{});function jDt(e){var t=e.grouping===void 0||e.thousands===void 0?Utt:DDt(WDt.call(e.grouping,Number),e.thousands+""),r=e.currency===void 0?"":e.currency[0]+"",n=e.currency===void 0?"":e.currency[1]+"",i=e.decimal===void 0?".":e.decimal+"",o=e.numerals===void 0?Utt:zDt(WDt.call(e.numerals,String)),a=e.percent===void 0?"%":e.percent+"",s=e.minus===void 0?"-":e.minus+"",l=e.nan===void 0?"NaN":e.nan+"";function c(h){h=Lg(h);var f=h.fill,p=h.align,d=h.sign,g=h.symbol,_=h.zero,y=h.width,x=h.comma,b=h.precision,S=h.trim,C=h.type;C==="n"?(x=!0,C="g"):Vtt[C]||(b===void 0&&(b=12),S=!0,C="g"),(_||f==="0"&&p==="=")&&(_=!0,f="0",p="=");var P=g==="$"?r:g==="#"&&/[boxX]/.test(C)?"0"+C.toLowerCase():"",k=g==="$"?n:/[%p]/.test(C)?a:"",O=Vtt[C],D=/[defgprs%]/.test(C);b=b===void 0?6:/[gprs]/.test(C)?Math.max(1,Math.min(21,b)):Math.max(0,Math.min(20,b));function B(I){var L=P,R=k,F,z,U;if(C==="c")R=O(I)+R,I="";else{I=+I;var W=I<0||1/I<0;if(I=isNaN(I)?l:O(Math.abs(I),b),S&&(I=BDt(I)),W&&+I==0&&d!=="+"&&(W=!1),L=(W?d==="("?d:s:d==="-"||d==="("?"":d)+L,R=(C==="s"?YDt[8+Ftt/3]:"")+R+(W&&d==="("?")":""),D){for(F=-1,z=I.length;++F<z;)if(U=I.charCodeAt(F),48>U||U>57){R=(U===46?i+I.slice(F+1):I.slice(F))+R,I=I.slice(0,F);break}}}x&&!_&&(I=t(I,1/0));var Z=L.length+I.length+R.length,rt=Z<y?new Array(y-Z+1).join(f):"";switch(x&&_&&(I=t(rt+I,rt.length?y-R.length:1/0),rt=""),p){case"<":I=L+I+R+rt;break;case"=":I=L+rt+I+R;break;case"^":I=rt.slice(0,Z=rt.length>>1)+L+I+R+rt.slice(Z);break;default:I=rt+L+I+R;break}return o(I)}return B.toString=function(){return h+""},B}function u(h,f){var p=c((h=Lg(h),h.type="f",h)),d=Math.max(-8,Math.min(8,Math.floor(vf(f)/3)))*3,g=Math.pow(10,-d),_=YDt[8+d/3];return function(y){return p(g*y)+_}}return{format:c,formatPrefix:u}}var WDt,YDt,XDt=M(()=>{gC();ODt();FDt();ztt();HDt();qDt();Btt();GDt();WDt=Array.prototype.map,YDt=["y","z","a","f","p","n","\xB5","m","","k","M","G","T","P","E","Z","Y"]});function qtt(e){return HO=jDt(e),fw=HO.format,VO=HO.formatPrefix,HO}var HO,fw,VO,$Dt=M(()=>{XDt();qtt({decimal:".",thousands:",",grouping:[3],currency:["$",""],minus:"-"})});function Gtt(e){return Math.max(0,-vf(Math.abs(e)))}var KDt=M(()=>{gC()});function Wtt(e,t){return Math.max(0,Math.max(-8,Math.min(8,Math.floor(vf(t)/3)))*3-vf(Math.abs(e)))}var ZDt=M(()=>{gC()});function Ytt(e,t){return e=Math.abs(e),t=Math.abs(t)-e,Math.max(0,vf(t)-vf(e))+1}var JDt=M(()=>{gC()});var jtt=M(()=>{$Dt();ztt();KDt();ZDt();JDt()});function QDt(e,t,r){var n=e[0],i=e[e.length-1],o=Zy(n,i,t==null?10:t),a;switch(r=Lg(r==null?",f":r),r.type){case"s":{var s=Math.max(Math.abs(n),Math.abs(i));return r.precision==null&&!isNaN(a=Wtt(o,s))&&(r.precision=a),VO(r,s)}case"":case"e":case"g":case"p":case"r":{r.precision==null&&!isNaN(a=Ytt(o,Math.max(Math.abs(n),Math.abs(i))))&&(r.precision=a-(r.type==="e"));break}case"f":case"%":{r.precision==null&&!isNaN(a=Gtt(o))&&(r.precision=a-(r.type==="%")*2);break}}return fw(r)}var tOt=M(()=>{mf();jtt()});function od(e){var t=e.domain;return e.ticks=function(r){var n=t();return sC(n[0],n[n.length-1],r==null?10:r)},e.tickFormat=function(r,n){return QDt(t(),r,n)},e.nice=function(r){r==null&&(r=10);var n=t(),i=0,o=n.length-1,a=n[i],s=n[o],l;return s<a&&(l=a,a=s,s=l,l=i,i=o,o=l),l=ew(a,s,r),l>0?(a=Math.floor(a/l)*l,s=Math.ceil(s/l)*l,l=ew(a,s,r)):l<0&&(a=Math.ceil(a*l)/l,s=Math.floor(s*l)/l,l=ew(a,s,r)),l>0?(n[i]=Math.floor(a/l)*l,n[o]=Math.ceil(s/l)*l,t(n)):l<0&&(n[i]=Math.ceil(a*l)/l,n[o]=Math.floor(s*l)/l,t(n)),e},e}function UO(){var e=id(pC,yf);return e.copy=function(){return Ig(e,UO())},od(e)}var pw=M(()=>{mf();uw();dC();tOt()});function qO(){var e=[0,1];function t(r){return+r}return t.invert=t,t.domain=t.range=function(r){return arguments.length?(e=rw.call(r,FO),t):e.slice()},t.copy=function(){return qO().domain(e)},od(t)}var eOt=M(()=>{Cg();pw();Ott()});function GO(e,t){e=e.slice();var r=0,n=e.length-1,i=e[r],o=e[n],a;return o<i&&(a=r,r=n,n=a,a=i,i=o,o=a),e[r]=t.floor(i),e[n]=t.ceil(o),e}var Xtt=M(()=>{});function eIe(e,t){return(t=Math.log(t/e))?function(r){return Math.log(r/e)/t}:hw(t)}function rIe(e,t){return e<0?function(r){return-Math.pow(-t,r)*Math.pow(-e,1-r)}:function(r){return Math.pow(t,r)*Math.pow(e,1-r)}}function nIe(e){return isFinite(e)?+("1e"+e):e<0?0:e}function rOt(e){return e===10?nIe:e===Math.E?Math.exp:function(t){return Math.pow(e,t)}}function nOt(e){return e===Math.E?Math.log:e===10&&Math.log10||e===2&&Math.log2||(e=Math.log(e),function(t){return Math.log(t)/e})}function iOt(e){return function(t){return-e(-t)}}function WO(){var e=id(eIe,rIe).domain([1,10]),t=e.domain,r=10,n=nOt(10),i=rOt(10);function o(){return n=nOt(r),i=rOt(r),t()[0]<0&&(n=iOt(n),i=iOt(i)),e}return e.base=function(a){return arguments.length?(r=+a,o()):r},e.domain=function(a){return arguments.length?(t(a),o()):t()},e.ticks=function(a){var s=t(),l=s[0],c=s[s.length-1],u;(u=c<l)&&(h=l,l=c,c=h);var h=n(l),f=n(c),p,d,g,_=a==null?10:+a,y=[];if(!(r%1)&&f-h<_){if(h=Math.round(h)-1,f=Math.round(f)+1,l>0){for(;h<f;++h)for(d=1,p=i(h);d<r;++d)if(g=p*d,!(g<l)){if(g>c)break;y.push(g)}}else for(;h<f;++h)for(d=r-1,p=i(h);d>=1;--d)if(g=p*d,!(g<l)){if(g>c)break;y.push(g)}}else y=sC(h,f,Math.min(f-h,_)).map(i);return u?y.reverse():y},e.tickFormat=function(a,s){if(s==null&&(s=r===10?".0e":","),typeof s!="function"&&(s=fw(s)),a===1/0)return s;a==null&&(a=10);var l=Math.max(1,r*a/e.ticks().length);return function(c){var u=c/i(Math.round(n(c)));return u*r<r-.5&&(u*=r),u<=l?s(c):""}},e.nice=function(){return t(GO(t(),{floor:function(a){return i(Math.floor(n(a)))},ceil:function(a){return i(Math.ceil(n(a)))}}))},e.copy=function(){return Ig(e,WO().base(r))},e}var oOt=M(()=>{mf();jtt();zO();Xtt();dC()});function dw(e,t){return e<0?-Math.pow(-e,t):Math.pow(e,t)}function _C(){var e=1,t=id(n,i),r=t.domain;function n(o,a){return(a=dw(a,e)-(o=dw(o,e)))?function(s){return(dw(s,e)-o)/a}:hw(a)}function i(o,a){return a=dw(a,e)-(o=dw(o,e)),function(s){return dw(o+a*s,1/e)}}return t.exponent=function(o){return arguments.length?(e=+o,r(r())):e},t.copy=function(){return Ig(t,_C().exponent(e))},od(t)}function aOt(){return _C().exponent(.5)}var sOt=M(()=>{zO();pw();dC()});function YO(){var e=[],t=[],r=[];function n(){var o=0,a=Math.max(1,t.length);for(r=new Array(a-1);++o<a;)r[o-1]=lC(e,o/a);return i}function i(o){if(!isNaN(o=+o))return t[df(r,o)]}return i.invertExtent=function(o){var a=t.indexOf(o);return a<0?[NaN,NaN]:[a>0?r[a-1]:e[0],a<r.length?r[a]:e[e.length-1]]},i.domain=function(o){if(!arguments.length)return e.slice();e=[];for(var a=0,s=o.length,l;a<s;++a)l=o[a],l!=null&&!isNaN(l=+l)&&e.push(l);return e.sort(pf),n()},i.range=function(o){return arguments.length?(t=pl.call(o),n()):t.slice()},i.quantiles=function(){return r.slice()},i.copy=function(){return YO().domain(e).range(t)},i}var lOt=M(()=>{mf();Cg()});function jO(){var e=0,t=1,r=1,n=[.5],i=[0,1];function o(s){if(s<=s)return i[df(n,s,0,r)]}function a(){var s=-1;for(n=new Array(r);++s<r;)n[s]=((s+1)*t-(s-r)*e)/(r+1);return o}return o.domain=function(s){return arguments.length?(e=+s[0],t=+s[1],a()):[e,t]},o.range=function(s){return arguments.length?(r=(i=pl.call(s)).length-1,a()):i.slice()},o.invertExtent=function(s){var l=i.indexOf(s);return l<0?[NaN,NaN]:l<1?[e,n[0]]:l>=r?[n[r-1],t]:[n[l-1],n[l]]},o.copy=function(){return jO().domain([e,t]).range(i)},od(o)}var cOt=M(()=>{mf();Cg();pw()});function XO(){var e=[.5],t=[0,1],r=1;function n(i){if(i<=i)return t[df(e,i,0,r)]}return n.domain=function(i){return arguments.length?(e=pl.call(i),r=Math.min(e.length,t.length-1),n):e.slice()},n.range=function(i){return arguments.length?(t=pl.call(i),r=Math.min(e.length,t.length-1),n):t.slice()},n.invertExtent=function(i){var o=t.indexOf(i);return[e[o-1],e[o]]},n.copy=function(){return XO().domain(e).range(t)},n}var uOt=M(()=>{mf();Cg()});function Nr(e,t,r,n){function i(o){return e(o=arguments.length===0?new Date:new Date(+o)),o}return i.floor=function(o){return e(o=new Date(+o)),o},i.ceil=function(o){return e(o=new Date(o-1)),t(o,1),e(o),o},i.round=function(o){var a=i(o),s=i.ceil(o);return o-a<s-o?a:s},i.offset=function(o,a){return t(o=new Date(+o),a==null?1:Math.floor(a)),o},i.range=function(o,a,s){var l=[],c;if(o=i.ceil(o),s=s==null?1:Math.floor(s),!(o<a)||!(s>0))return l;do l.push(c=new Date(+o)),t(o,s),e(o);while(c<o&&o<a);return l},i.filter=function(o){return Nr(function(a){if(a>=a)for(;e(a),!o(a);)a.setTime(a-1)},function(a,s){if(a>=a)if(s<0)for(;++s<=0;)for(;t(a,-1),!o(a););else for(;--s>=0;)for(;t(a,1),!o(a););})},r&&(i.count=function(o,a){return $tt.setTime(+o),Ktt.setTime(+a),e($tt),e(Ktt),Math.floor(r($tt,Ktt))},i.every=function(o){return o=Math.floor(o),!isFinite(o)||!(o>0)?null:o>1?i.filter(n?function(a){return n(a)%o===0}:function(a){return i.count(0,a)%o===0}):i}),i}var $tt,Ktt,Ka=M(()=>{$tt=new Date,Ktt=new Date});var $O,mw,hOt,fOt=M(()=>{Ka();$O=Nr(function(){},function(e,t){e.setTime(+e+t)},function(e,t){return t-e});$O.every=function(e){return e=Math.floor(e),!isFinite(e)||!(e>0)?null:e>1?Nr(function(t){t.setTime(Math.floor(t/e)*e)},function(t,r){t.setTime(+t+r*e)},function(t,r){return(r-t)/e}):$O};mw=$O,hOt=$O.range});var ov,wc,gw,KO,ZO,xf=M(()=>{ov=1e3,wc=6e4,gw=36e5,KO=864e5,ZO=6048e5});var pOt,_w,dOt,mOt=M(()=>{Ka();xf();pOt=Nr(function(e){e.setTime(e-e.getMilliseconds())},function(e,t){e.setTime(+e+t*ov)},function(e,t){return(t-e)/ov},function(e){return e.getUTCSeconds()}),_w=pOt,dOt=pOt.range});var gOt,Ztt,iIe,_Ot=M(()=>{Ka();xf();gOt=Nr(function(e){e.setTime(e-e.getMilliseconds()-e.getSeconds()*ov)},function(e,t){e.setTime(+e+t*wc)},function(e,t){return(t-e)/wc},function(e){return e.getMinutes()}),Ztt=gOt,iIe=gOt.range});var yOt,Jtt,oIe,vOt=M(()=>{Ka();xf();yOt=Nr(function(e){e.setTime(e-e.getMilliseconds()-e.getSeconds()*ov-e.getMinutes()*wc)},function(e,t){e.setTime(+e+t*gw)},function(e,t){return(t-e)/gw},function(e){return e.getHours()}),Jtt=yOt,oIe=yOt.range});var xOt,yw,aIe,bOt=M(()=>{Ka();xf();xOt=Nr(function(e){e.setHours(0,0,0,0)},function(e,t){e.setDate(e.getDate()+t)},function(e,t){return(t-e-(t.getTimezoneOffset()-e.getTimezoneOffset())*wc)/KO},function(e){return e.getDate()-1}),yw=xOt,aIe=xOt.range});function av(e){return Nr(function(t){t.setDate(t.getDate()-(t.getDay()+7-e)%7),t.setHours(0,0,0,0)},function(t,r){t.setDate(t.getDate()+r*7)},function(t,r){return(r-t-(r.getTimezoneOffset()-t.getTimezoneOffset())*wc)/ZO})}var sv,vw,wOt,SOt,kg,MOt,EOt,TOt,sIe,lIe,cIe,uIe,hIe,fIe,COt=M(()=>{Ka();xf();sv=av(0),vw=av(1),wOt=av(2),SOt=av(3),kg=av(4),MOt=av(5),EOt=av(6),TOt=sv.range,sIe=vw.range,lIe=wOt.range,cIe=SOt.range,uIe=kg.range,hIe=MOt.range,fIe=EOt.range});var AOt,Qtt,pIe,POt=M(()=>{Ka();AOt=Nr(function(e){e.setDate(1),e.setHours(0,0,0,0)},function(e,t){e.setMonth(e.getMonth()+t)},function(e,t){return t.getMonth()-e.getMonth()+(t.getFullYear()-e.getFullYear())*12},function(e){return e.getMonth()}),Qtt=AOt,pIe=AOt.range});var tet,ad,dIe,IOt=M(()=>{Ka();tet=Nr(function(e){e.setMonth(0,1),e.setHours(0,0,0,0)},function(e,t){e.setFullYear(e.getFullYear()+t)},function(e,t){return t.getFullYear()-e.getFullYear()},function(e){return e.getFullYear()});tet.every=function(e){return!isFinite(e=Math.floor(e))||!(e>0)?null:Nr(function(t){t.setFullYear(Math.floor(t.getFullYear()/e)*e),t.setMonth(0,1),t.setHours(0,0,0,0)},function(t,r){t.setFullYear(t.getFullYear()+r*e)})};ad=tet,dIe=tet.range});var LOt,eet,mIe,kOt=M(()=>{Ka();xf();LOt=Nr(function(e){e.setUTCSeconds(0,0)},function(e,t){e.setTime(+e+t*wc)},function(e,t){return(t-e)/wc},function(e){return e.getUTCMinutes()}),eet=LOt,mIe=LOt.range});var ROt,ret,gIe,NOt=M(()=>{Ka();xf();ROt=Nr(function(e){e.setUTCMinutes(0,0,0)},function(e,t){e.setTime(+e+t*gw)},function(e,t){return(t-e)/gw},function(e){return e.getUTCHours()}),ret=ROt,gIe=ROt.range});var DOt,xw,_Ie,OOt=M(()=>{Ka();xf();DOt=Nr(function(e){e.setUTCHours(0,0,0,0)},function(e,t){e.setUTCDate(e.getUTCDate()+t)},function(e,t){return(t-e)/KO},function(e){return e.getUTCDate()-1}),xw=DOt,_Ie=DOt.range});function lv(e){return Nr(function(t){t.setUTCDate(t.getUTCDate()-(t.getUTCDay()+7-e)%7),t.setUTCHours(0,0,0,0)},function(t,r){t.setUTCDate(t.getUTCDate()+r*7)},function(t,r){return(r-t)/ZO})}var cv,bw,zOt,FOt,Rg,BOt,HOt,VOt,yIe,vIe,xIe,bIe,wIe,SIe,UOt=M(()=>{Ka();xf();cv=lv(0),bw=lv(1),zOt=lv(2),FOt=lv(3),Rg=lv(4),BOt=lv(5),HOt=lv(6),VOt=cv.range,yIe=bw.range,vIe=zOt.range,xIe=FOt.range,bIe=Rg.range,wIe=BOt.range,SIe=HOt.range});var qOt,net,MIe,GOt=M(()=>{Ka();qOt=Nr(function(e){e.setUTCDate(1),e.setUTCHours(0,0,0,0)},function(e,t){e.setUTCMonth(e.getUTCMonth()+t)},function(e,t){return t.getUTCMonth()-e.getUTCMonth()+(t.getUTCFullYear()-e.getUTCFullYear())*12},function(e){return e.getUTCMonth()}),net=qOt,MIe=qOt.range});var iet,sd,EIe,WOt=M(()=>{Ka();iet=Nr(function(e){e.setUTCMonth(0,1),e.setUTCHours(0,0,0,0)},function(e,t){e.setUTCFullYear(e.getUTCFullYear()+t)},function(e,t){return t.getUTCFullYear()-e.getUTCFullYear()},function(e){return e.getUTCFullYear()});iet.every=function(e){return!isFinite(e=Math.floor(e))||!(e>0)?null:Nr(function(t){t.setUTCFullYear(Math.floor(t.getUTCFullYear()/e)*e),t.setUTCMonth(0,1),t.setUTCHours(0,0,0,0)},function(t,r){t.setUTCFullYear(t.getUTCFullYear()+r*e)})};sd=iet,EIe=iet.range});var JO=M(()=>{fOt();mOt();_Ot();vOt();bOt();COt();POt();IOt();kOt();NOt();OOt();UOt();GOt();WOt()});function oet(e){if(0<=e.y&&e.y<100){var t=new Date(-1,e.m,e.d,e.H,e.M,e.S,e.L);return t.setFullYear(e.y),t}return new Date(e.y,e.m,e.d,e.H,e.M,e.S,e.L)}function aet(e){if(0<=e.y&&e.y<100){var t=new Date(Date.UTC(-1,e.m,e.d,e.H,e.M,e.S,e.L));return t.setUTCFullYear(e.y),t}return new Date(Date.UTC(e.y,e.m,e.d,e.H,e.M,e.S,e.L))}function yC(e,t,r){return{y:e,m:t,d:r,H:0,M:0,S:0,L:0}}function set(e){var t=e.dateTime,r=e.date,n=e.time,i=e.periods,o=e.days,a=e.shortDays,s=e.months,l=e.shortMonths,c=vC(i),u=xC(i),h=vC(o),f=xC(o),p=vC(a),d=xC(a),g=vC(s),_=xC(s),y=vC(l),x=xC(l),b={a:W,A:Z,b:rt,B:ot,c:null,d:ZOt,e:ZOt,f:XIe,g:i9e,G:a9e,H:WIe,I:YIe,j:jIe,L:r7t,m:$Ie,M:KIe,p:st,q:St,Q:t7t,s:e7t,S:ZIe,u:JIe,U:QIe,V:t9e,w:e9e,W:r9e,x:null,X:null,y:n9e,Y:o9e,Z:s9e,"%":QOt},S={a:bt,A:Mt,b:lt,B:Kt,c:null,d:JOt,e:JOt,f:h9e,g:b9e,G:S9e,H:l9e,I:c9e,j:u9e,L:i7t,m:f9e,M:p9e,p:_t,q:ct,Q:t7t,s:e7t,S:d9e,u:m9e,U:g9e,V:_9e,w:y9e,W:v9e,x:null,X:null,y:x9e,Y:w9e,Z:M9e,"%":QOt},C={a:B,A:I,b:L,B:R,c:F,d:$Ot,e:$Ot,f:VIe,g:XOt,G:jOt,H:KOt,I:KOt,j:zIe,L:HIe,m:OIe,M:FIe,p:D,q:DIe,Q:qIe,s:GIe,S:BIe,u:IIe,U:LIe,V:kIe,w:PIe,W:RIe,x:z,X:U,y:XOt,Y:jOt,Z:NIe,"%":UIe};b.x=P(r,b),b.X=P(n,b),b.c=P(t,b),S.x=P(r,S),S.X=P(n,S),S.c=P(t,S);function P(X,et){return function(dt){var q=[],pt=-1,ht=0,wt=X.length,kt,ie,ee;for(dt instanceof Date||(dt=new Date(+dt));++pt<wt;)X.charCodeAt(pt)===37&&(q.push(X.slice(ht,pt)),(ie=YOt[kt=X.charAt(++pt)])!=null?kt=X.charAt(++pt):ie=kt==="e"?" ":"0",(ee=et[kt])&&(kt=ee(dt,ie)),q.push(kt),ht=pt+1);return q.push(X.slice(ht,pt)),q.join("")}}function k(X,et){return function(dt){var q=yC(1900,void 0,1),pt=O(q,X,dt+="",0),ht,wt;if(pt!=dt.length)return null;if("Q"in q)return new Date(q.Q);if("s"in q)return new Date(q.s*1e3+("L"in q?q.L:0));if(et&&!("Z"in q)&&(q.Z=0),"p"in q&&(q.H=q.H%12+q.p*12),q.m===void 0&&(q.m="q"in q?q.q:0),"V"in q){if(q.V<1||q.V>53)return null;"w"in q||(q.w=1),"Z"in q?(ht=aet(yC(q.y,0,1)),wt=ht.getUTCDay(),ht=wt>4||wt===0?bw.ceil(ht):bw(ht),ht=xw.offset(ht,(q.V-1)*7),q.y=ht.getUTCFullYear(),q.m=ht.getUTCMonth(),q.d=ht.getUTCDate()+(q.w+6)%7):(ht=oet(yC(q.y,0,1)),wt=ht.getDay(),ht=wt>4||wt===0?vw.ceil(ht):vw(ht),ht=yw.offset(ht,(q.V-1)*7),q.y=ht.getFullYear(),q.m=ht.getMonth(),q.d=ht.getDate()+(q.w+6)%7)}else("W"in q||"U"in q)&&("w"in q||(q.w="u"in q?q.u%7:"W"in q?1:0),wt="Z"in q?aet(yC(q.y,0,1)).getUTCDay():oet(yC(q.y,0,1)).getDay(),q.m=0,q.d="W"in q?(q.w+6)%7+q.W*7-(wt+5)%7:q.w+q.U*7-(wt+6)%7);return"Z"in q?(q.H+=q.Z/100|0,q.M+=q.Z%100,aet(q)):oet(q)}}function O(X,et,dt,q){for(var pt=0,ht=et.length,wt=dt.length,kt,ie;pt<ht;){if(q>=wt)return-1;if(kt=et.charCodeAt(pt++),kt===37){if(kt=et.charAt(pt++),ie=C[kt in YOt?et.charAt(pt++):kt],!ie||(q=ie(X,dt,q))<0)return-1}else if(kt!=dt.charCodeAt(q++))return-1}return q}function D(X,et,dt){var q=c.exec(et.slice(dt));return q?(X.p=u[q[0].toLowerCase()],dt+q[0].length):-1}function B(X,et,dt){var q=p.exec(et.slice(dt));return q?(X.w=d[q[0].toLowerCase()],dt+q[0].length):-1}function I(X,et,dt){var q=h.exec(et.slice(dt));return q?(X.w=f[q[0].toLowerCase()],dt+q[0].length):-1}function L(X,et,dt){var q=y.exec(et.slice(dt));return q?(X.m=x[q[0].toLowerCase()],dt+q[0].length):-1}function R(X,et,dt){var q=g.exec(et.slice(dt));return q?(X.m=_[q[0].toLowerCase()],dt+q[0].length):-1}function F(X,et,dt){return O(X,t,et,dt)}function z(X,et,dt){return O(X,r,et,dt)}function U(X,et,dt){return O(X,n,et,dt)}function W(X){return a[X.getDay()]}function Z(X){return o[X.getDay()]}function rt(X){return l[X.getMonth()]}function ot(X){return s[X.getMonth()]}function st(X){return i[+(X.getHours()>=12)]}function St(X){return 1+~~(X.getMonth()/3)}function bt(X){return a[X.getUTCDay()]}function Mt(X){return o[X.getUTCDay()]}function lt(X){return l[X.getUTCMonth()]}function Kt(X){return s[X.getUTCMonth()]}function _t(X){return i[+(X.getUTCHours()>=12)]}function ct(X){return 1+~~(X.getUTCMonth()/3)}return{format:function(X){var et=P(X+="",b);return et.toString=function(){return X},et},parse:function(X){var et=k(X+="",!1);return et.toString=function(){return X},et},utcFormat:function(X){var et=P(X+="",S);return et.toString=function(){return X},et},utcParse:function(X){var et=k(X+="",!0);return et.toString=function(){return X},et}}}function Gr(e,t,r){var n=e<0?"-":"",i=(n?-e:e)+"",o=i.length;return n+(o<r?new Array(r-o+1).join(t)+i:i)}function AIe(e){return e.replace(CIe,"\\$&")}function vC(e){return new RegExp("^(?:"+e.map(AIe).join("|")+")","i")}function xC(e){for(var t={},r=-1,n=e.length;++r<n;)t[e[r].toLowerCase()]=r;return t}function PIe(e,t,r){var n=To.exec(t.slice(r,r+1));return n?(e.w=+n[0],r+n[0].length):-1}function IIe(e,t,r){var n=To.exec(t.slice(r,r+1));return n?(e.u=+n[0],r+n[0].length):-1}function LIe(e,t,r){var n=To.exec(t.slice(r,r+2));return n?(e.U=+n[0],r+n[0].length):-1}function kIe(e,t,r){var n=To.exec(t.slice(r,r+2));return n?(e.V=+n[0],r+n[0].length):-1}function RIe(e,t,r){var n=To.exec(t.slice(r,r+2));return n?(e.W=+n[0],r+n[0].length):-1}function jOt(e,t,r){var n=To.exec(t.slice(r,r+4));return n?(e.y=+n[0],r+n[0].length):-1}function XOt(e,t,r){var n=To.exec(t.slice(r,r+2));return n?(e.y=+n[0]+(+n[0]>68?1900:2e3),r+n[0].length):-1}function NIe(e,t,r){var n=/^(Z)|([+-]\d\d)(?::?(\d\d))?/.exec(t.slice(r,r+6));return n?(e.Z=n[1]?0:-(n[2]+(n[3]||"00")),r+n[0].length):-1}function DIe(e,t,r){var n=To.exec(t.slice(r,r+1));return n?(e.q=n[0]*3-3,r+n[0].length):-1}function OIe(e,t,r){var n=To.exec(t.slice(r,r+2));return n?(e.m=n[0]-1,r+n[0].length):-1}function $Ot(e,t,r){var n=To.exec(t.slice(r,r+2));return n?(e.d=+n[0],r+n[0].length):-1}function zIe(e,t,r){var n=To.exec(t.slice(r,r+3));return n?(e.m=0,e.d=+n[0],r+n[0].length):-1}function KOt(e,t,r){var n=To.exec(t.slice(r,r+2));return n?(e.H=+n[0],r+n[0].length):-1}function FIe(e,t,r){var n=To.exec(t.slice(r,r+2));return n?(e.M=+n[0],r+n[0].length):-1}function BIe(e,t,r){var n=To.exec(t.slice(r,r+2));return n?(e.S=+n[0],r+n[0].length):-1}function HIe(e,t,r){var n=To.exec(t.slice(r,r+3));return n?(e.L=+n[0],r+n[0].length):-1}function VIe(e,t,r){var n=To.exec(t.slice(r,r+6));return n?(e.L=Math.floor(n[0]/1e3),r+n[0].length):-1}function UIe(e,t,r){var n=TIe.exec(t.slice(r,r+1));return n?r+n[0].length:-1}function qIe(e,t,r){var n=To.exec(t.slice(r));return n?(e.Q=+n[0],r+n[0].length):-1}function GIe(e,t,r){var n=To.exec(t.slice(r));return n?(e.s=+n[0],r+n[0].length):-1}function ZOt(e,t){return Gr(e.getDate(),t,2)}function WIe(e,t){return Gr(e.getHours(),t,2)}function YIe(e,t){return Gr(e.getHours()%12||12,t,2)}function jIe(e,t){return Gr(1+yw.count(ad(e),e),t,3)}function r7t(e,t){return Gr(e.getMilliseconds(),t,3)}function XIe(e,t){return r7t(e,t)+"000"}function $Ie(e,t){return Gr(e.getMonth()+1,t,2)}function KIe(e,t){return Gr(e.getMinutes(),t,2)}function ZIe(e,t){return Gr(e.getSeconds(),t,2)}function JIe(e){var t=e.getDay();return t===0?7:t}function QIe(e,t){return Gr(sv.count(ad(e)-1,e),t,2)}function n7t(e){var t=e.getDay();return t>=4||t===0?kg(e):kg.ceil(e)}function t9e(e,t){return e=n7t(e),Gr(kg.count(ad(e),e)+(ad(e).getDay()===4),t,2)}function e9e(e){return e.getDay()}function r9e(e,t){return Gr(vw.count(ad(e)-1,e),t,2)}function n9e(e,t){return Gr(e.getFullYear()%100,t,2)}function i9e(e,t){return e=n7t(e),Gr(e.getFullYear()%100,t,2)}function o9e(e,t){return Gr(e.getFullYear()%1e4,t,4)}function a9e(e,t){var r=e.getDay();return e=r>=4||r===0?kg(e):kg.ceil(e),Gr(e.getFullYear()%1e4,t,4)}function s9e(e){var t=e.getTimezoneOffset();return(t>0?"-":(t*=-1,"+"))+Gr(t/60|0,"0",2)+Gr(t%60,"0",2)}function JOt(e,t){return Gr(e.getUTCDate(),t,2)}function l9e(e,t){return Gr(e.getUTCHours(),t,2)}function c9e(e,t){return Gr(e.getUTCHours()%12||12,t,2)}function u9e(e,t){return Gr(1+xw.count(sd(e),e),t,3)}function i7t(e,t){return Gr(e.getUTCMilliseconds(),t,3)}function h9e(e,t){return i7t(e,t)+"000"}function f9e(e,t){return Gr(e.getUTCMonth()+1,t,2)}function p9e(e,t){return Gr(e.getUTCMinutes(),t,2)}function d9e(e,t){return Gr(e.getUTCSeconds(),t,2)}function m9e(e){var t=e.getUTCDay();return t===0?7:t}function g9e(e,t){return Gr(cv.count(sd(e)-1,e),t,2)}function o7t(e){var t=e.getUTCDay();return t>=4||t===0?Rg(e):Rg.ceil(e)}function _9e(e,t){return e=o7t(e),Gr(Rg.count(sd(e),e)+(sd(e).getUTCDay()===4),t,2)}function y9e(e){return e.getUTCDay()}function v9e(e,t){return Gr(bw.count(sd(e)-1,e),t,2)}function x9e(e,t){return Gr(e.getUTCFullYear()%100,t,2)}function b9e(e,t){return e=o7t(e),Gr(e.getUTCFullYear()%100,t,2)}function w9e(e,t){return Gr(e.getUTCFullYear()%1e4,t,4)}function S9e(e,t){var r=e.getUTCDay();return e=r>=4||r===0?Rg(e):Rg.ceil(e),Gr(e.getUTCFullYear()%1e4,t,4)}function M9e(){return"+0000"}function QOt(){return"%"}function t7t(e){return+e}function e7t(e){return Math.floor(+e/1e3)}var YOt,To,TIe,CIe,a7t=M(()=>{JO();YOt={"-":"",_:" ",0:"0"},To=/^\s*\d+/,TIe=/^%/,CIe=/[\\^$*+?|[\]().{}]/g});function cet(e){return ww=set(e),QO=ww.format,s7t=ww.parse,t7=ww.utcFormat,l7t=ww.utcParse,ww}var ww,QO,s7t,t7,l7t,c7t=M(()=>{a7t();cet({dateTime:"%x, %X",date:"%-m/%-d/%Y",time:"%-I:%M:%S %p",periods:["AM","PM"],days:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],shortDays:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],months:["January","February","March","April","May","June","July","August","September","October","November","December"],shortMonths:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]})});var uet=M(()=>{c7t()});function T9e(e){return new Date(e)}function C9e(e){return e instanceof Date?+e:+new Date(+e)}function e7(e,t,r,n,i,o,a,s,l){var c=id(pC,yf),u=c.invert,h=c.domain,f=l(".%L"),p=l(":%S"),d=l("%I:%M"),g=l("%I %p"),_=l("%a %d"),y=l("%b %d"),x=l("%B"),b=l("%Y"),S=[[a,1,bC],[a,5,5*bC],[a,15,15*bC],[a,30,30*bC],[o,1,wC],[o,5,5*wC],[o,15,15*wC],[o,30,30*wC],[i,1,SC],[i,3,3*SC],[i,6,6*SC],[i,12,12*SC],[n,1,MC],[n,2,2*MC],[r,1,E9e],[t,1,u7t],[t,3,3*u7t],[e,1,het]];function C(k){return(a(k)<k?f:o(k)<k?p:i(k)<k?d:n(k)<k?g:t(k)<k?r(k)<k?_:y:e(k)<k?x:b)(k)}function P(k,O,D,B){if(k==null&&(k=10),typeof k=="number"){var I=Math.abs(D-O)/k,L=aC(function(R){return R[2]}).right(S,I);L===S.length?(B=Zy(O/het,D/het,k),k=e):L?(L=S[I/S[L-1][2]<S[L][2]/I?L-1:L],B=L[1],k=L[0]):(B=Math.max(Zy(O,D,k),1),k=s)}return B==null?k:k.every(B)}return c.invert=function(k){return new Date(u(k))},c.domain=function(k){return arguments.length?h(rw.call(k,C9e)):h().map(T9e)},c.ticks=function(k,O){var D=h(),B=D[0],I=D[D.length-1],L=I<B,R;return L&&(R=B,B=I,I=R),R=P(k,B,I,O),R=R?R.range(B,I+1):[],L?R.reverse():R},c.tickFormat=function(k,O){return O==null?C:l(O)},c.nice=function(k,O){var D=h();return(k=P(k,D[0],D[D.length-1],O))?h(GO(D,k)):c},c.copy=function(){return Ig(c,e7(e,t,r,n,i,o,a,s,l))},c}function h7t(){return e7(ad,Qtt,sv,yw,Jtt,Ztt,_w,mw,QO).domain([new Date(2e3,0,1),new Date(2e3,0,2)])}var bC,wC,SC,MC,E9e,u7t,het,fet=M(()=>{mf();uw();JO();uet();Cg();dC();Xtt();bC=1e3,wC=bC*60,SC=wC*60,MC=SC*24,E9e=MC*7,u7t=MC*30,het=MC*365});function f7t(){return e7(sd,net,cv,xw,ret,eet,_w,mw,t7).domain([Date.UTC(2e3,0,1),Date.UTC(2e3,0,2)])}var p7t=M(()=>{fet();uet();JO()});function dl(e){return e.match(/.{6}/g).map(function(t){return"#"+t})}var Sw=M(()=>{});var d7t,m7t=M(()=>{Sw();d7t=dl("1f77b4ff7f0e2ca02cd627289467bd8c564be377c27f7f7fbcbd2217becf")});var g7t,_7t=M(()=>{Sw();g7t=dl("393b795254a36b6ecf9c9ede6379398ca252b5cf6bcedb9c8c6d31bd9e39e7ba52e7cb94843c39ad494ad6616be7969c7b4173a55194ce6dbdde9ed6")});var y7t,v7t=M(()=>{Sw();y7t=dl("3182bd6baed69ecae1c6dbefe6550dfd8d3cfdae6bfdd0a231a35474c476a1d99bc7e9c0756bb19e9ac8bcbddcdadaeb636363969696bdbdbdd9d9d9")});var x7t,b7t=M(()=>{Sw();x7t=dl("1f77b4aec7e8ff7f0effbb782ca02c98df8ad62728ff98969467bdc5b0d58c564bc49c94e377c2f7b6d27f7f7fc7c7c7bcbd22dbdb8d17becf9edae5")});var w7t,S7t=M(()=>{sw();uw();w7t=cw($a(300,.5,0),$a(-240,.5,1))});function T7t(e){(e<0||e>1)&&(e-=Math.floor(e));var t=Math.abs(e-.5);return r7.h=360*e-100,r7.s=1.5-1.5*t,r7.l=.8-.9*t,r7+""}var M7t,E7t,r7,C7t=M(()=>{sw();uw();M7t=cw($a(-100,.75,.35),$a(80,1.5,.8)),E7t=cw($a(260,.75,.35),$a(80,1.5,.8)),r7=$a()});function n7(e){var t=e.length;return function(r){return e[Math.max(0,Math.min(t-1,Math.floor(r*t)))]}}var A7t,P7t,I7t,L7t,k7t=M(()=>{Sw();A7t=n7(dl("44015444025645045745055946075a46085c460a5d460b5e470d60470e6147106347116447136548146748166848176948186a481a6c481b6d481c6e481d6f481f70482071482173482374482475482576482677482878482979472a7a472c7a472d7b472e7c472f7d46307e46327e46337f463480453581453781453882443983443a83443b84433d84433e85423f854240864241864142874144874045884046883f47883f48893e49893e4a893e4c8a3d4d8a3d4e8a3c4f8a3c508b3b518b3b528b3a538b3a548c39558c39568c38588c38598c375a8c375b8d365c8d365d8d355e8d355f8d34608d34618d33628d33638d32648e32658e31668e31678e31688e30698e306a8e2f6b8e2f6c8e2e6d8e2e6e8e2e6f8e2d708e2d718e2c718e2c728e2c738e2b748e2b758e2a768e2a778e2a788e29798e297a8e297b8e287c8e287d8e277e8e277f8e27808e26818e26828e26828e25838e25848e25858e24868e24878e23888e23898e238a8d228b8d228c8d228d8d218e8d218f8d21908d21918c20928c20928c20938c1f948c1f958b1f968b1f978b1f988b1f998a1f9a8a1e9b8a1e9c891e9d891f9e891f9f881fa0881fa1881fa1871fa28720a38620a48621a58521a68522a78522a88423a98324aa8325ab8225ac8226ad8127ad8128ae8029af7f2ab07f2cb17e2db27d2eb37c2fb47c31b57b32b67a34b67935b77937b87838b9773aba763bbb753dbc743fbc7340bd7242be7144bf7046c06f48c16e4ac16d4cc26c4ec36b50c46a52c56954c56856c66758c7655ac8645cc8635ec96260ca6063cb5f65cb5e67cc5c69cd5b6ccd5a6ece5870cf5773d05675d05477d1537ad1517cd2507fd34e81d34d84d44b86d54989d5488bd6468ed64590d74393d74195d84098d83e9bd93c9dd93ba0da39a2da37a5db36a8db34aadc32addc30b0dd2fb2dd2db5de2bb8de29bade28bddf26c0df25c2df23c5e021c8e020cae11fcde11dd0e11cd2e21bd5e21ad8e219dae319dde318dfe318e2e418e5e419e7e419eae51aece51befe51cf1e51df4e61ef6e620f8e621fbe723fde725")),P7t=n7(dl("00000401000501010601010802010902020b02020d03030f03031204041405041606051806051a07061c08071e0907200a08220b09240c09260d0a290e0b2b100b2d110c2f120d31130d34140e36150e38160f3b180f3d19103f1a10421c10441d11471e114920114b21114e22115024125325125527125829115a2a115c2c115f2d11612f116331116533106734106936106b38106c390f6e3b0f703d0f713f0f72400f74420f75440f764510774710784910784a10794c117a4e117b4f127b51127c52137c54137d56147d57157e59157e5a167e5c167f5d177f5f187f601880621980641a80651a80671b80681c816a1c816b1d816d1d816e1e81701f81721f817320817521817621817822817922827b23827c23827e24828025828125818326818426818627818827818928818b29818c29818e2a81902a81912b81932b80942c80962c80982d80992d809b2e7f9c2e7f9e2f7fa02f7fa1307ea3307ea5317ea6317da8327daa337dab337cad347cae347bb0357bb2357bb3367ab5367ab73779b83779ba3878bc3978bd3977bf3a77c03a76c23b75c43c75c53c74c73d73c83e73ca3e72cc3f71cd4071cf4070d0416fd2426fd3436ed5446dd6456cd8456cd9466bdb476adc4869de4968df4a68e04c67e24d66e34e65e44f64e55064e75263e85362e95462ea5661eb5760ec5860ed5a5fee5b5eef5d5ef05f5ef1605df2625df2645cf3655cf4675cf4695cf56b5cf66c5cf66e5cf7705cf7725cf8745cf8765cf9785df9795df97b5dfa7d5efa7f5efa815ffb835ffb8560fb8761fc8961fc8a62fc8c63fc8e64fc9065fd9266fd9467fd9668fd9869fd9a6afd9b6bfe9d6cfe9f6dfea16efea36ffea571fea772fea973feaa74feac76feae77feb078feb27afeb47bfeb67cfeb77efeb97ffebb81febd82febf84fec185fec287fec488fec68afec88cfeca8dfecc8ffecd90fecf92fed194fed395fed597fed799fed89afdda9cfddc9efddea0fde0a1fde2a3fde3a5fde5a7fde7a9fde9aafdebacfcecaefceeb0fcf0b2fcf2b4fcf4b6fcf6b8fcf7b9fcf9bbfcfbbdfcfdbf")),I7t=n7(dl("00000401000501010601010802010a02020c02020e03021004031204031405041706041907051b08051d09061f0a07220b07240c08260d08290e092b10092d110a30120a32140b34150b37160b39180c3c190c3e1b0c411c0c431e0c451f0c48210c4a230c4c240c4f260c51280b53290b552b0b572d0b592f0a5b310a5c320a5e340a5f3609613809623909633b09643d09653e0966400a67420a68440a68450a69470b6a490b6a4a0c6b4c0c6b4d0d6c4f0d6c510e6c520e6d540f6d550f6d57106e59106e5a116e5c126e5d126e5f136e61136e62146e64156e65156e67166e69166e6a176e6c186e6d186e6f196e71196e721a6e741a6e751b6e771c6d781c6d7a1d6d7c1d6d7d1e6d7f1e6c801f6c82206c84206b85216b87216b88226a8a226a8c23698d23698f24699025689225689326679526679727669827669a28659b29649d29649f2a63a02a63a22b62a32c61a52c60a62d60a82e5fa92e5eab2f5ead305dae305cb0315bb1325ab3325ab43359b63458b73557b93556ba3655bc3754bd3853bf3952c03a51c13a50c33b4fc43c4ec63d4dc73e4cc83f4bca404acb4149cc4248ce4347cf4446d04545d24644d34743d44842d54a41d74b3fd84c3ed94d3dda4e3cdb503bdd513ade5238df5337e05536e15635e25734e35933e45a31e55c30e65d2fe75e2ee8602de9612bea632aeb6429eb6628ec6726ed6925ee6a24ef6c23ef6e21f06f20f1711ff1731df2741cf3761bf37819f47918f57b17f57d15f67e14f68013f78212f78410f8850ff8870ef8890cf98b0bf98c0af98e09fa9008fa9207fa9407fb9606fb9706fb9906fb9b06fb9d07fc9f07fca108fca309fca50afca60cfca80dfcaa0ffcac11fcae12fcb014fcb216fcb418fbb61afbb81dfbba1ffbbc21fbbe23fac026fac228fac42afac62df9c72ff9c932f9cb35f8cd37f8cf3af7d13df7d340f6d543f6d746f5d949f5db4cf4dd4ff4df53f4e156f3e35af3e55df2e661f2e865f2ea69f1ec6df1ed71f1ef75f1f179f2f27df2f482f3f586f3f68af4f88ef5f992f6fa96f8fb9af9fc9dfafda1fcffa4")),L7t=n7(dl("0d088710078813078916078a19068c1b068d1d068e20068f2206902406912605912805922a05932c05942e05952f059631059733059735049837049938049a3a049a3c049b3e049c3f049c41049d43039e44039e46039f48039f4903a04b03a14c02a14e02a25002a25102a35302a35502a45601a45801a45901a55b01a55c01a65e01a66001a66100a76300a76400a76600a76700a86900a86a00a86c00a86e00a86f00a87100a87201a87401a87501a87701a87801a87a02a87b02a87d03a87e03a88004a88104a78305a78405a78606a68707a68808a68a09a58b0aa58d0ba58e0ca48f0da4910ea3920fa39410a29511a19613a19814a099159f9a169f9c179e9d189d9e199da01a9ca11b9ba21d9aa31e9aa51f99a62098a72197a82296aa2395ab2494ac2694ad2793ae2892b02991b12a90b22b8fb32c8eb42e8db52f8cb6308bb7318ab83289ba3388bb3488bc3587bd3786be3885bf3984c03a83c13b82c23c81c33d80c43e7fc5407ec6417dc7427cc8437bc9447aca457acb4679cc4778cc4977cd4a76ce4b75cf4c74d04d73d14e72d24f71d35171d45270d5536fd5546ed6556dd7566cd8576bd9586ada5a6ada5b69db5c68dc5d67dd5e66de5f65de6164df6263e06363e16462e26561e26660e3685fe4695ee56a5de56b5de66c5ce76e5be76f5ae87059e97158e97257ea7457eb7556eb7655ec7754ed7953ed7a52ee7b51ef7c51ef7e50f07f4ff0804ef1814df1834cf2844bf3854bf3874af48849f48948f58b47f58c46f68d45f68f44f79044f79143f79342f89441f89540f9973ff9983ef99a3efa9b3dfa9c3cfa9e3bfb9f3afba139fba238fca338fca537fca636fca835fca934fdab33fdac33fdae32fdaf31fdb130fdb22ffdb42ffdb52efeb72dfeb82cfeba2cfebb2bfebd2afebe2afec029fdc229fdc328fdc527fdc627fdc827fdca26fdcb26fccd25fcce25fcd025fcd225fbd324fbd524fbd724fad824fada24f9dc24f9dd25f8df25f8e125f7e225f7e425f6e626f6e826f5e926f5eb27f4ed27f3ee27f3f027f2f227f1f426f1f525f0f724f0f921"))});function i7(e){var t=0,r=1,n=!1;function i(o){var a=(o-t)/(r-t);return e(n?Math.max(0,Math.min(1,a)):a)}return i.domain=function(o){return arguments.length?(t=+o[0],r=+o[1],i):[t,r]},i.clamp=function(o){return arguments.length?(n=!!o,i):n},i.interpolator=function(o){return arguments.length?(e=o,i):e},i.copy=function(){return i7(e).domain([t,r]).clamp(n)},od(i)}var R7t=M(()=>{pw()});var N7t=M(()=>{jNt();eOt();pw();oOt();xtt();sOt();lOt();cOt();uOt();fet();p7t();m7t();_7t();v7t();b7t();S7t();C7t();k7t();R7t()});var o7,EC,a7=M(()=>{o7="http://www.w3.org/1999/xhtml",EC={svg:"http://www.w3.org/2000/svg",xhtml:o7,xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/"}});function Mw(e){var t=e+="",r=t.indexOf(":");return r>=0&&(t=e.slice(0,r))!=="xmlns"&&(e=e.slice(r+1)),EC.hasOwnProperty(t)?{space:EC[t],local:e}:e}var s7=M(()=>{a7()});function A9e(e){return function(){var t=this.ownerDocument,r=this.namespaceURI;return r===o7&&t.documentElement.namespaceURI===o7?t.createElement(e):t.createElementNS(r,e)}}function P9e(e){return function(){return this.ownerDocument.createElementNS(e.space,e.local)}}function Ng(e){var t=Mw(e);return(t.local?P9e:A9e)(t)}var TC=M(()=>{s7();a7()});function I9e(){}function Ew(e){return e==null?I9e:function(){return this.querySelector(e)}}var l7=M(()=>{});function D7t(e){typeof e!="function"&&(e=Ew(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=new Array(a),l,c,u=0;u<a;++u)(l=o[u])&&(c=e.call(l,l.__data__,u,o))&&("__data__"in l&&(c.__data__=l.__data__),s[u]=c);return new Bn(n,this._parents)}var O7t=M(()=>{Sc();l7()});function L9e(){return[]}function c7(e){return e==null?L9e:function(){return this.querySelectorAll(e)}}var pet=M(()=>{});function z7t(e){typeof e!="function"&&(e=c7(e));for(var t=this._groups,r=t.length,n=[],i=[],o=0;o<r;++o)for(var a=t[o],s=a.length,l,c=0;c<s;++c)(l=a[c])&&(n.push(e.call(l,l.__data__,c,a)),i.push(l));return new Bn(n,i)}var F7t=M(()=>{Sc();pet()});var H7t,Tw,B7t,u7,det=M(()=>{H7t=function(e){return function(){return this.matches(e)}};typeof document!="undefined"&&(Tw=document.documentElement,Tw.matches||(B7t=Tw.webkitMatchesSelector||Tw.msMatchesSelector||Tw.mozMatchesSelector||Tw.oMatchesSelector,H7t=function(e){return function(){return B7t.call(this,e)}}));u7=H7t});function V7t(e){typeof e!="function"&&(e=u7(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=[],l,c=0;c<a;++c)(l=o[c])&&e.call(l,l.__data__,c,o)&&s.push(l);return new Bn(n,this._parents)}var U7t=M(()=>{Sc();det()});function h7(e){return new Array(e.length)}var met=M(()=>{});function q7t(){return new Bn(this._enter||this._groups.map(h7),this._parents)}function CC(e,t){this.ownerDocument=e.ownerDocument,this.namespaceURI=e.namespaceURI,this._next=null,this._parent=e,this.__data__=t}var get=M(()=>{met();Sc();CC.prototype={constructor:CC,appendChild:function(e){return this._parent.insertBefore(e,this._next)},insertBefore:function(e,t){return this._parent.insertBefore(e,t)},querySelector:function(e){return this._parent.querySelector(e)},querySelectorAll:function(e){return this._parent.querySelectorAll(e)}}});function G7t(e){return function(){return e}}var W7t=M(()=>{});function k9e(e,t,r,n,i,o){for(var a=0,s,l=t.length,c=o.length;a<c;++a)(s=t[a])?(s.__data__=o[a],n[a]=s):r[a]=new CC(e,o[a]);for(;a<l;++a)(s=t[a])&&(i[a]=s)}function R9e(e,t,r,n,i,o,a){var s,l,c={},u=t.length,h=o.length,f=new Array(u),p;for(s=0;s<u;++s)(l=t[s])&&(f[s]=p=Y7t+a.call(l,l.__data__,s,t),p in c?i[s]=l:c[p]=l);for(s=0;s<h;++s)p=Y7t+a.call(e,o[s],s,o),(l=c[p])?(n[s]=l,l.__data__=o[s],c[p]=null):r[s]=new CC(e,o[s]);for(s=0;s<u;++s)(l=t[s])&&c[f[s]]===l&&(i[s]=l)}function j7t(e,t){if(!e)return p=new Array(this.size()),c=-1,this.each(function(P){p[++c]=P}),p;var r=t?R9e:k9e,n=this._parents,i=this._groups;typeof e!="function"&&(e=G7t(e));for(var o=i.length,a=new Array(o),s=new Array(o),l=new Array(o),c=0;c<o;++c){var u=n[c],h=i[c],f=h.length,p=e.call(u,u&&u.__data__,c,n),d=p.length,g=s[c]=new Array(d),_=a[c]=new Array(d),y=l[c]=new Array(f);r(u,h,g,_,y,p,t);for(var x=0,b=0,S,C;x<d;++x)if(S=g[x]){for(x>=b&&(b=x+1);!(C=_[b])&&++b<d;);S._next=C||null}}return a=new Bn(a,n),a._enter=s,a._exit=l,a}var Y7t,X7t=M(()=>{Sc();get();W7t();Y7t="$"});function $7t(){return new Bn(this._exit||this._groups.map(h7),this._parents)}var K7t=M(()=>{met();Sc()});function Z7t(e){for(var t=this._groups,r=e._groups,n=t.length,i=r.length,o=Math.min(n,i),a=new Array(n),s=0;s<o;++s)for(var l=t[s],c=r[s],u=l.length,h=a[s]=new Array(u),f,p=0;p<u;++p)(f=l[p]||c[p])&&(h[p]=f);for(;s<n;++s)a[s]=t[s];return new Bn(a,this._parents)}var J7t=M(()=>{Sc()});function Q7t(){for(var e=this._groups,t=-1,r=e.length;++t<r;)for(var n=e[t],i=n.length-1,o=n[i],a;--i>=0;)(a=n[i])&&(o&&o!==a.nextSibling&&o.parentNode.insertBefore(a,o),o=a);return this}var tzt=M(()=>{});function ezt(e){e||(e=N9e);function t(h,f){return h&&f?e(h.__data__,f.__data__):!h-!f}for(var r=this._groups,n=r.length,i=new Array(n),o=0;o<n;++o){for(var a=r[o],s=a.length,l=i[o]=new Array(s),c,u=0;u<s;++u)(c=a[u])&&(l[u]=c);l.sort(t)}return new Bn(i,this._parents).order()}function N9e(e,t){return e<t?-1:e>t?1:e>=t?0:NaN}var rzt=M(()=>{Sc()});function nzt(){var e=arguments[0];return arguments[0]=this,e.apply(null,arguments),this}var izt=M(()=>{});function ozt(){var e=new Array(this.size()),t=-1;return this.each(function(){e[++t]=this}),e}var azt=M(()=>{});function szt(){for(var e=this._groups,t=0,r=e.length;t<r;++t)for(var n=e[t],i=0,o=n.length;i<o;++i){var a=n[i];if(a)return a}return null}var lzt=M(()=>{});function czt(){var e=0;return this.each(function(){++e}),e}var uzt=M(()=>{});function hzt(){return!this.node()}var fzt=M(()=>{});function pzt(e){for(var t=this._groups,r=0,n=t.length;r<n;++r)for(var i=t[r],o=0,a=i.length,s;o<a;++o)(s=i[o])&&e.call(s,s.__data__,o,i);return this}var dzt=M(()=>{});function D9e(e){return function(){this.removeAttribute(e)}}function O9e(e){return function(){this.removeAttributeNS(e.space,e.local)}}function z9e(e,t){return function(){this.setAttribute(e,t)}}function F9e(e,t){return function(){this.setAttributeNS(e.space,e.local,t)}}function B9e(e,t){return function(){var r=t.apply(this,arguments);r==null?this.removeAttribute(e):this.setAttribute(e,r)}}function H9e(e,t){return function(){var r=t.apply(this,arguments);r==null?this.removeAttributeNS(e.space,e.local):this.setAttributeNS(e.space,e.local,r)}}function mzt(e,t){var r=Mw(e);if(arguments.length<2){var n=this.node();return r.local?n.getAttributeNS(r.space,r.local):n.getAttribute(r)}return this.each((t==null?r.local?O9e:D9e:typeof t=="function"?r.local?H9e:B9e:r.local?F9e:z9e)(r,t))}var gzt=M(()=>{s7()});function Cw(e){return e.ownerDocument&&e.ownerDocument.defaultView||e.document&&e||e.defaultView}var f7=M(()=>{});function V9e(e){return function(){this.style.removeProperty(e)}}function U9e(e,t,r){return function(){this.style.setProperty(e,t,r)}}function q9e(e,t,r){return function(){var n=t.apply(this,arguments);n==null?this.style.removeProperty(e):this.style.setProperty(e,n,r)}}function _zt(e,t,r){return arguments.length>1?this.each((t==null?V9e:typeof t=="function"?q9e:U9e)(e,t,r==null?"":r)):_et(this.node(),e)}function _et(e,t){return e.style.getPropertyValue(t)||Cw(e).getComputedStyle(e,null).getPropertyValue(t)}var yet=M(()=>{f7()});function G9e(e){return function(){delete this[e]}}function W9e(e,t){return function(){this[e]=t}}function Y9e(e,t){return function(){var r=t.apply(this,arguments);r==null?delete this[e]:this[e]=r}}function yzt(e,t){return arguments.length>1?this.each((t==null?G9e:typeof t=="function"?Y9e:W9e)(e,t)):this.node()[e]}var vzt=M(()=>{});function xzt(e){return e.trim().split(/^|\s+/)}function vet(e){return e.classList||new bzt(e)}function bzt(e){this._node=e,this._names=xzt(e.getAttribute("class")||"")}function wzt(e,t){for(var r=vet(e),n=-1,i=t.length;++n<i;)r.add(t[n])}function Szt(e,t){for(var r=vet(e),n=-1,i=t.length;++n<i;)r.remove(t[n])}function j9e(e){return function(){wzt(this,e)}}function X9e(e){return function(){Szt(this,e)}}function $9e(e,t){return function(){(t.apply(this,arguments)?wzt:Szt)(this,e)}}function Mzt(e,t){var r=xzt(e+"");if(arguments.length<2){for(var n=vet(this.node()),i=-1,o=r.length;++i<o;)if(!n.contains(r[i]))return!1;return!0}return this.each((typeof t=="function"?$9e:t?j9e:X9e)(r,t))}var Ezt=M(()=>{bzt.prototype={add:function(e){var t=this._names.indexOf(e);t<0&&(this._names.push(e),this._node.setAttribute("class",this._names.join(" ")))},remove:function(e){var t=this._names.indexOf(e);t>=0&&(this._names.splice(t,1),this._node.setAttribute("class",this._names.join(" ")))},contains:function(e){return this._names.indexOf(e)>=0}}});function K9e(){this.textContent=""}function Z9e(e){return function(){this.textContent=e}}function J9e(e){return function(){var t=e.apply(this,arguments);this.textContent=t==null?"":t}}function Tzt(e){return arguments.length?this.each(e==null?K9e:(typeof e=="function"?J9e:Z9e)(e)):this.node().textContent}var Czt=M(()=>{});function Q9e(){this.innerHTML=""}function tLe(e){return function(){this.innerHTML=e}}function eLe(e){return function(){var t=e.apply(this,arguments);this.innerHTML=t==null?"":t}}function Azt(e){return arguments.length?this.each(e==null?Q9e:(typeof e=="function"?eLe:tLe)(e)):this.node().innerHTML}var Pzt=M(()=>{});function rLe(){this.nextSibling&&this.parentNode.appendChild(this)}function Izt(){return this.each(rLe)}var Lzt=M(()=>{});function nLe(){this.previousSibling&&this.parentNode.insertBefore(this,this.parentNode.firstChild)}function kzt(){return this.each(nLe)}var Rzt=M(()=>{});function Nzt(e){var t=typeof e=="function"?e:Ng(e);return this.select(function(){return this.appendChild(t.apply(this,arguments))})}var Dzt=M(()=>{TC()});function iLe(){return null}function Ozt(e,t){var r=typeof e=="function"?e:Ng(e),n=t==null?iLe:typeof t=="function"?t:Ew(t);return this.select(function(){return this.insertBefore(r.apply(this,arguments),n.apply(this,arguments)||null)})}var zzt=M(()=>{TC();l7()});function oLe(){var e=this.parentNode;e&&e.removeChild(this)}function Fzt(){return this.each(oLe)}var Bzt=M(()=>{});function aLe(){return this.parentNode.insertBefore(this.cloneNode(!1),this.nextSibling)}function sLe(){return this.parentNode.insertBefore(this.cloneNode(!0),this.nextSibling)}function Hzt(e){return this.select(e?sLe:aLe)}var Vzt=M(()=>{});function Uzt(e){return arguments.length?this.property("__data__",e):this.node().__data__}var qzt=M(()=>{});function lLe(e,t,r){return e=Yzt(e,t,r),function(n){var i=n.relatedTarget;(!i||i!==this&&!(i.compareDocumentPosition(this)&8))&&e.call(this,n)}}function Yzt(e,t,r){return function(n){var i=Pu;Pu=n;try{e.call(this,this.__data__,t,r)}finally{Pu=i}}}function cLe(e){return e.trim().split(/^|\s+/).map(function(t){var r="",n=t.indexOf(".");return n>=0&&(r=t.slice(n+1),t=t.slice(0,n)),{type:t,name:r}})}function uLe(e){return function(){var t=this.__on;if(!!t){for(var r=0,n=-1,i=t.length,o;r<i;++r)o=t[r],(!e.type||o.type===e.type)&&o.name===e.name?this.removeEventListener(o.type,o.listener,o.capture):t[++n]=o;++n?t.length=n:delete this.__on}}}function hLe(e,t,r){var n=Wzt.hasOwnProperty(e.type)?lLe:Yzt;return function(i,o,a){var s=this.__on,l,c=n(t,o,a);if(s){for(var u=0,h=s.length;u<h;++u)if((l=s[u]).type===e.type&&l.name===e.name){this.removeEventListener(l.type,l.listener,l.capture),this.addEventListener(l.type,l.listener=c,l.capture=r),l.value=t;return}}this.addEventListener(e.type,c,r),l={type:e.type,name:e.name,value:t,listener:c,capture:r},s?s.push(l):this.__on=[l]}}function jzt(e,t,r){var n=cLe(e+""),i,o=n.length,a;if(arguments.length<2){var s=this.node().__on;if(s){for(var l=0,c=s.length,u;l<c;++l)for(i=0,u=s[l];i<o;++i)if((a=n[i]).type===u.type&&a.name===u.name)return u.value}return}for(s=t?hLe:uLe,r==null&&(r=!1),i=0;i<o;++i)this.each(s(n[i],t,r));return this}function Xzt(e,t,r,n){var i=Pu;e.sourceEvent=Pu,Pu=e;try{return t.apply(r,n)}finally{Pu=i}}var Wzt,Pu,Gzt,p7=M(()=>{Wzt={},Pu=null;typeof document!="undefined"&&(Gzt=document.documentElement,"onmouseenter"in Gzt||(Wzt={mouseenter:"mouseover",mouseleave:"mouseout"}))});function $zt(e,t,r){var n=Cw(e),i=n.CustomEvent;typeof i=="function"?i=new i(t,r):(i=n.document.createEvent("Event"),r?(i.initEvent(t,r.bubbles,r.cancelable),i.detail=r.detail):i.initEvent(t,!1,!1)),e.dispatchEvent(i)}function fLe(e,t){return function(){return $zt(this,e,t)}}function pLe(e,t){return function(){return $zt(this,e,t.apply(this,arguments))}}function Kzt(e,t){return this.each((typeof t=="function"?pLe:fLe)(e,t))}var Zzt=M(()=>{f7()});function Bn(e,t){this._groups=e,this._parents=t}function Jzt(){return new Bn([[document.documentElement]],AC)}var AC,Qzt,Sc=M(()=>{O7t();F7t();U7t();X7t();get();K7t();J7t();tzt();rzt();izt();azt();lzt();uzt();fzt();dzt();gzt();yet();vzt();Ezt();Czt();Pzt();Lzt();Rzt();Dzt();zzt();Bzt();Vzt();qzt();p7();Zzt();AC=[null];Bn.prototype=Jzt.prototype={constructor:Bn,select:D7t,selectAll:z7t,filter:V7t,data:j7t,enter:q7t,exit:$7t,merge:Z7t,order:Q7t,sort:ezt,call:nzt,nodes:ozt,node:szt,size:czt,empty:hzt,each:pzt,attr:mzt,style:_zt,property:yzt,classed:Mzt,text:Tzt,html:Azt,raise:Izt,lower:kzt,append:Nzt,insert:Ozt,remove:Fzt,clone:Hzt,datum:Uzt,on:jzt,dispatch:Kzt};Qzt=Jzt});function d7(e){return typeof e=="string"?new Bn([[document.querySelector(e)]],[document.documentElement]):new Bn([[e]],AC)}var xet=M(()=>{Sc()});function tFt(e){return d7(Ng(e).call(document.documentElement))}var eFt=M(()=>{TC();xet()});function m7(){return new bet}function bet(){this._="@"+(++dLe).toString(36)}var dLe,rFt=M(()=>{dLe=0;bet.prototype=m7.prototype={constructor:bet,get:function(e){for(var t=this._;!(t in e);)if(!(e=e.parentNode))return;return e[t]},set:function(e,t){return e[this._]=t},remove:function(e){return this._ in e&&delete e[this._]},toString:function(){return this._}}});function Aw(){for(var e=Pu,t;t=e.sourceEvent;)e=t;return e}var g7=M(()=>{p7()});function Dg(e,t){var r=e.ownerSVGElement||e;if(r.createSVGPoint){var n=r.createSVGPoint();return n.x=t.clientX,n.y=t.clientY,n=n.matrixTransform(e.getScreenCTM().inverse()),[n.x,n.y]}var i=e.getBoundingClientRect();return[t.clientX-i.left-e.clientLeft,t.clientY-i.top-e.clientTop]}var PC=M(()=>{});function nFt(e){var t=Aw();return t.changedTouches&&(t=t.changedTouches[0]),Dg(e,t)}var iFt=M(()=>{g7();PC()});function oFt(e){return typeof e=="string"?new Bn([document.querySelectorAll(e)],[document.documentElement]):new Bn([e==null?[]:e],AC)}var aFt=M(()=>{Sc()});function sFt(e,t,r){arguments.length<3&&(r=t,t=Aw().changedTouches);for(var n=0,i=t?t.length:0,o;n<i;++n)if((o=t[n]).identifier===r)return Dg(e,o);return null}var lFt=M(()=>{g7();PC()});function cFt(e,t){t==null&&(t=Aw().touches);for(var r=0,n=t?t.length:0,i=new Array(n);r<n;++r)i[r]=Dg(e,t[r]);return i}var uFt=M(()=>{g7();PC()});var hFt=M(()=>{eFt();TC();rFt();det();iFt();s7();a7();PC();xet();aFt();Sc();l7();pet();yet();lFt();uFt();f7();p7()});function Eet(){this._x0=this._y0=this._x1=this._y1=null,this._=""}function fFt(){return new Eet}var wet,Met,uv,mLe,Iu,pFt=M(()=>{wet=Math.PI,Met=2*wet,uv=1e-6,mLe=Met-uv;Eet.prototype=fFt.prototype={constructor:Eet,moveTo:function(e,t){this._+="M"+(this._x0=this._x1=+e)+","+(this._y0=this._y1=+t)},closePath:function(){this._x1!==null&&(this._x1=this._x0,this._y1=this._y0,this._+="Z")},lineTo:function(e,t){this._+="L"+(this._x1=+e)+","+(this._y1=+t)},quadraticCurveTo:function(e,t,r,n){this._+="Q"+ +e+","+ +t+","+(this._x1=+r)+","+(this._y1=+n)},bezierCurveTo:function(e,t,r,n,i,o){this._+="C"+ +e+","+ +t+","+ +r+","+ +n+","+(this._x1=+i)+","+(this._y1=+o)},arcTo:function(e,t,r,n,i){e=+e,t=+t,r=+r,n=+n,i=+i;var o=this._x1,a=this._y1,s=r-e,l=n-t,c=o-e,u=a-t,h=c*c+u*u;if(i<0)throw new Error("negative radius: "+i);if(this._x1===null)this._+="M"+(this._x1=e)+","+(this._y1=t);else if(h>uv)if(!(Math.abs(u*s-l*c)>uv)||!i)this._+="L"+(this._x1=e)+","+(this._y1=t);else{var f=r-o,p=n-a,d=s*s+l*l,g=f*f+p*p,_=Math.sqrt(d),y=Math.sqrt(h),x=i*Math.tan((wet-Math.acos((d+h-g)/(2*_*y)))/2),b=x/y,S=x/_;Math.abs(b-1)>uv&&(this._+="L"+(e+b*c)+","+(t+b*u)),this._+="A"+i+","+i+",0,0,"+ +(u*f>c*p)+","+(this._x1=e+S*s)+","+(this._y1=t+S*l)}},arc:function(e,t,r,n,i,o){e=+e,t=+t,r=+r,o=!!o;var a=r*Math.cos(n),s=r*Math.sin(n),l=e+a,c=t+s,u=1^o,h=o?n-i:i-n;if(r<0)throw new Error("negative radius: "+r);this._x1===null?this._+="M"+l+","+c:(Math.abs(this._x1-l)>uv||Math.abs(this._y1-c)>uv)&&(this._+="L"+l+","+c),r&&(h<0&&(h=h%Met+Met),h>mLe?this._+="A"+r+","+r+",0,1,"+u+","+(e-a)+","+(t-s)+"A"+r+","+r+",0,1,"+u+","+(this._x1=l)+","+(this._y1=c):h>uv&&(this._+="A"+r+","+r+",0,"+ +(h>=wet)+","+u+","+(this._x1=e+r*Math.cos(i))+","+(this._y1=t+r*Math.sin(i))))},rect:function(e,t,r,n){this._+="M"+(this._x0=this._x1=+e)+","+(this._y0=this._y1=+t)+"h"+ +r+"v"+ +n+"h"+-r+"Z"},toString:function(){return this._}};Iu=fFt});var Pw=M(()=>{pFt()});function Ge(e){return function(){return e}}var Og=M(()=>{});function mFt(e){return e>1?0:e<-1?ku:Math.acos(e)}function Cet(e){return e>=1?IC:e<=-1?-IC:Math.asin(e)}var Tet,Ho,zg,dFt,_7,Lu,hv,Co,ku,IC,Mc,Iw=M(()=>{Tet=Math.abs,Ho=Math.atan2,zg=Math.cos,dFt=Math.max,_7=Math.min,Lu=Math.sin,hv=Math.sqrt,Co=1e-12,ku=Math.PI,IC=ku/2,Mc=2*ku});function gLe(e){return e.innerRadius}function _Le(e){return e.outerRadius}function yLe(e){return e.startAngle}function vLe(e){return e.endAngle}function xLe(e){return e&&e.padAngle}function bLe(e,t,r,n,i,o,a,s){var l=r-e,c=n-t,u=a-i,h=s-o,f=(u*(t-o)-h*(e-i))/(h*l-u*c);return[e+f*l,t+f*c]}function y7(e,t,r,n,i,o,a){var s=e-r,l=t-n,c=(a?o:-o)/hv(s*s+l*l),u=c*l,h=-c*s,f=e+u,p=t+h,d=r+u,g=n+h,_=(f+d)/2,y=(p+g)/2,x=d-f,b=g-p,S=x*x+b*b,C=i-o,P=f*g-d*p,k=(b<0?-1:1)*hv(dFt(0,C*C*S-P*P)),O=(P*b-x*k)/S,D=(-P*x-b*k)/S,B=(P*b+x*k)/S,I=(-P*x+b*k)/S,L=O-_,R=D-y,F=B-_,z=I-y;return L*L+R*R>F*F+z*z&&(O=B,D=I),{cx:O,cy:D,x01:-u,y01:-h,x11:O*(i/C-1),y11:D*(i/C-1)}}function gFt(){var e=gLe,t=_Le,r=Ge(0),n=null,i=yLe,o=vLe,a=xLe,s=null;function l(){var c,u,h=+e.apply(this,arguments),f=+t.apply(this,arguments),p=i.apply(this,arguments)-IC,d=o.apply(this,arguments)-IC,g=Tet(d-p),_=d>p;if(s||(s=c=Iu()),f<h&&(u=f,f=h,h=u),!(f>Co))s.moveTo(0,0);else if(g>Mc-Co)s.moveTo(f*zg(p),f*Lu(p)),s.arc(0,0,f,p,d,!_),h>Co&&(s.moveTo(h*zg(d),h*Lu(d)),s.arc(0,0,h,d,p,_));else{var y=p,x=d,b=p,S=d,C=g,P=g,k=a.apply(this,arguments)/2,O=k>Co&&(n?+n.apply(this,arguments):hv(h*h+f*f)),D=_7(Tet(f-h)/2,+r.apply(this,arguments)),B=D,I=D,L,R;if(O>Co){var F=Cet(O/h*Lu(k)),z=Cet(O/f*Lu(k));(C-=F*2)>Co?(F*=_?1:-1,b+=F,S-=F):(C=0,b=S=(p+d)/2),(P-=z*2)>Co?(z*=_?1:-1,y+=z,x-=z):(P=0,y=x=(p+d)/2)}var U=f*zg(y),W=f*Lu(y),Z=h*zg(S),rt=h*Lu(S);if(D>Co){var ot=f*zg(x),st=f*Lu(x),St=h*zg(b),bt=h*Lu(b);if(g<ku){var Mt=C>Co?bLe(U,W,St,bt,ot,st,Z,rt):[Z,rt],lt=U-Mt[0],Kt=W-Mt[1],_t=ot-Mt[0],ct=st-Mt[1],X=1/Lu(mFt((lt*_t+Kt*ct)/(hv(lt*lt+Kt*Kt)*hv(_t*_t+ct*ct)))/2),et=hv(Mt[0]*Mt[0]+Mt[1]*Mt[1]);B=_7(D,(h-et)/(X-1)),I=_7(D,(f-et)/(X+1))}}P>Co?I>Co?(L=y7(St,bt,U,W,f,I,_),R=y7(ot,st,Z,rt,f,I,_),s.moveTo(L.cx+L.x01,L.cy+L.y01),I<D?s.arc(L.cx,L.cy,I,Ho(L.y01,L.x01),Ho(R.y01,R.x01),!_):(s.arc(L.cx,L.cy,I,Ho(L.y01,L.x01),Ho(L.y11,L.x11),!_),s.arc(0,0,f,Ho(L.cy+L.y11,L.cx+L.x11),Ho(R.cy+R.y11,R.cx+R.x11),!_),s.arc(R.cx,R.cy,I,Ho(R.y11,R.x11),Ho(R.y01,R.x01),!_))):(s.moveTo(U,W),s.arc(0,0,f,y,x,!_)):s.moveTo(U,W),!(h>Co)||!(C>Co)?s.lineTo(Z,rt):B>Co?(L=y7(Z,rt,ot,st,h,-B,_),R=y7(U,W,St,bt,h,-B,_),s.lineTo(L.cx+L.x01,L.cy+L.y01),B<D?s.arc(L.cx,L.cy,B,Ho(L.y01,L.x01),Ho(R.y01,R.x01),!_):(s.arc(L.cx,L.cy,B,Ho(L.y01,L.x01),Ho(L.y11,L.x11),!_),s.arc(0,0,h,Ho(L.cy+L.y11,L.cx+L.x11),Ho(R.cy+R.y11,R.cx+R.x11),_),s.arc(R.cx,R.cy,B,Ho(R.y11,R.x11),Ho(R.y01,R.x01),!_))):s.arc(0,0,h,S,b,_)}if(s.closePath(),c)return s=null,c+""||null}return l.centroid=function(){var c=(+e.apply(this,arguments)+ +t.apply(this,arguments))/2,u=(+i.apply(this,arguments)+ +o.apply(this,arguments))/2-ku/2;return[zg(u)*c,Lu(u)*c]},l.innerRadius=function(c){return arguments.length?(e=typeof c=="function"?c:Ge(+c),l):e},l.outerRadius=function(c){return arguments.length?(t=typeof c=="function"?c:Ge(+c),l):t},l.cornerRadius=function(c){return arguments.length?(r=typeof c=="function"?c:Ge(+c),l):r},l.padRadius=function(c){return arguments.length?(n=c==null?null:typeof c=="function"?c:Ge(+c),l):n},l.startAngle=function(c){return arguments.length?(i=typeof c=="function"?c:Ge(+c),l):i},l.endAngle=function(c){return arguments.length?(o=typeof c=="function"?c:Ge(+c),l):o},l.padAngle=function(c){return arguments.length?(a=typeof c=="function"?c:Ge(+c),l):a},l.context=function(c){return arguments.length?(s=c==null?null:c,l):s},l}var _Ft=M(()=>{Pw();Og();Iw()});function yFt(e){this._context=e}function Fg(e){return new yFt(e)}var LC=M(()=>{yFt.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;default:this._context.lineTo(e,t);break}}}});function Lw(e){return e[0]}function kw(e){return e[1]}var v7=M(()=>{});function Rw(){var e=Lw,t=kw,r=Ge(!0),n=null,i=Fg,o=null;function a(s){var l,c=s.length,u,h=!1,f;for(n==null&&(o=i(f=Iu())),l=0;l<=c;++l)!(l<c&&r(u=s[l],l,s))===h&&((h=!h)?o.lineStart():o.lineEnd()),h&&o.point(+e(u,l,s),+t(u,l,s));if(f)return o=null,f+""||null}return a.x=function(s){return arguments.length?(e=typeof s=="function"?s:Ge(+s),a):e},a.y=function(s){return arguments.length?(t=typeof s=="function"?s:Ge(+s),a):t},a.defined=function(s){return arguments.length?(r=typeof s=="function"?s:Ge(!!s),a):r},a.curve=function(s){return arguments.length?(i=s,n!=null&&(o=i(n)),a):i},a.context=function(s){return arguments.length?(s==null?n=o=null:o=i(n=s),a):n},a}var x7=M(()=>{Pw();Og();LC();v7()});function b7(){var e=Lw,t=null,r=Ge(0),n=kw,i=Ge(!0),o=null,a=Fg,s=null;function l(u){var h,f,p,d=u.length,g,_=!1,y,x=new Array(d),b=new Array(d);for(o==null&&(s=a(y=Iu())),h=0;h<=d;++h){if(!(h<d&&i(g=u[h],h,u))===_)if(_=!_)f=h,s.areaStart(),s.lineStart();else{for(s.lineEnd(),s.lineStart(),p=h-1;p>=f;--p)s.point(x[p],b[p]);s.lineEnd(),s.areaEnd()}_&&(x[h]=+e(g,h,u),b[h]=+r(g,h,u),s.point(t?+t(g,h,u):x[h],n?+n(g,h,u):b[h]))}if(y)return s=null,y+""||null}function c(){return Rw().defined(i).curve(a).context(o)}return l.x=function(u){return arguments.length?(e=typeof u=="function"?u:Ge(+u),t=null,l):e},l.x0=function(u){return arguments.length?(e=typeof u=="function"?u:Ge(+u),l):e},l.x1=function(u){return arguments.length?(t=u==null?null:typeof u=="function"?u:Ge(+u),l):t},l.y=function(u){return arguments.length?(r=typeof u=="function"?u:Ge(+u),n=null,l):r},l.y0=function(u){return arguments.length?(r=typeof u=="function"?u:Ge(+u),l):r},l.y1=function(u){return arguments.length?(n=u==null?null:typeof u=="function"?u:Ge(+u),l):n},l.lineX0=l.lineY0=function(){return c().x(e).y(r)},l.lineY1=function(){return c().x(e).y(n)},l.lineX1=function(){return c().x(t).y(r)},l.defined=function(u){return arguments.length?(i=typeof u=="function"?u:Ge(!!u),l):i},l.curve=function(u){return arguments.length?(a=u,o!=null&&(s=a(o)),l):a},l.context=function(u){return arguments.length?(u==null?o=s=null:s=a(o=u),l):o},l}var Aet=M(()=>{Pw();Og();LC();x7();v7()});function vFt(e,t){return t<e?-1:t>e?1:t>=e?0:NaN}var xFt=M(()=>{});function bFt(e){return e}var wFt=M(()=>{});function SFt(){var e=bFt,t=vFt,r=null,n=Ge(0),i=Ge(Mc),o=Ge(0);function a(s){var l,c=s.length,u,h,f=0,p=new Array(c),d=new Array(c),g=+n.apply(this,arguments),_=Math.min(Mc,Math.max(-Mc,i.apply(this,arguments)-g)),y,x=Math.min(Math.abs(_)/c,o.apply(this,arguments)),b=x*(_<0?-1:1),S;for(l=0;l<c;++l)(S=d[p[l]=l]=+e(s[l],l,s))>0&&(f+=S);for(t!=null?p.sort(function(C,P){return t(d[C],d[P])}):r!=null&&p.sort(function(C,P){return r(s[C],s[P])}),l=0,h=f?(_-c*b)/f:0;l<c;++l,g=y)u=p[l],S=d[u],y=g+(S>0?S*h:0)+b,d[u]={data:s[u],index:l,value:S,startAngle:g,endAngle:y,padAngle:x};return d}return a.value=function(s){return arguments.length?(e=typeof s=="function"?s:Ge(+s),a):e},a.sortValues=function(s){return arguments.length?(t=s,r=null,a):t},a.sort=function(s){return arguments.length?(r=s,t=null,a):r},a.startAngle=function(s){return arguments.length?(n=typeof s=="function"?s:Ge(+s),a):n},a.endAngle=function(s){return arguments.length?(i=typeof s=="function"?s:Ge(+s),a):i},a.padAngle=function(s){return arguments.length?(o=typeof s=="function"?s:Ge(+s),a):o},a}var MFt=M(()=>{Og();xFt();wFt();Iw()});function EFt(e){this._curve=e}function Nw(e){function t(r){return new EFt(e(r))}return t._curve=e,t}var w7,Pet=M(()=>{LC();w7=Nw(Fg);EFt.prototype={areaStart:function(){this._curve.areaStart()},areaEnd:function(){this._curve.areaEnd()},lineStart:function(){this._curve.lineStart()},lineEnd:function(){this._curve.lineEnd()},point:function(e,t){this._curve.point(t*Math.sin(e),t*-Math.cos(e))}}});function Dw(e){var t=e.curve;return e.angle=e.x,delete e.x,e.radius=e.y,delete e.y,e.curve=function(r){return arguments.length?t(Nw(r)):t()._curve},e}function Iet(){return Dw(Rw().curve(w7))}var Let=M(()=>{Pet();x7()});function ket(){var e=b7().curve(w7),t=e.curve,r=e.lineX0,n=e.lineX1,i=e.lineY0,o=e.lineY1;return e.angle=e.x,delete e.x,e.startAngle=e.x0,delete e.x0,e.endAngle=e.x1,delete e.x1,e.radius=e.y,delete e.y,e.innerRadius=e.y0,delete e.y0,e.outerRadius=e.y1,delete e.y1,e.lineStartAngle=function(){return Dw(r())},delete e.lineX0,e.lineEndAngle=function(){return Dw(n())},delete e.lineX1,e.lineInnerRadius=function(){return Dw(i())},delete e.lineY0,e.lineOuterRadius=function(){return Dw(o())},delete e.lineY1,e.curve=function(a){return arguments.length?t(Nw(a)):t()._curve},e}var TFt=M(()=>{Pet();Aet();Let()});function fv(e,t){return[(t=+t)*Math.cos(e-=Math.PI/2),t*Math.sin(e)]}var Ret=M(()=>{});var kC,Net=M(()=>{kC=Array.prototype.slice});function wLe(e){return e.source}function SLe(e){return e.target}function Det(e){var t=wLe,r=SLe,n=Lw,i=kw,o=null;function a(){var s,l=kC.call(arguments),c=t.apply(this,l),u=r.apply(this,l);if(o||(o=s=Iu()),e(o,+n.apply(this,(l[0]=c,l)),+i.apply(this,l),+n.apply(this,(l[0]=u,l)),+i.apply(this,l)),s)return o=null,s+""||null}return a.source=function(s){return arguments.length?(t=s,a):t},a.target=function(s){return arguments.length?(r=s,a):r},a.x=function(s){return arguments.length?(n=typeof s=="function"?s:Ge(+s),a):n},a.y=function(s){return arguments.length?(i=typeof s=="function"?s:Ge(+s),a):i},a.context=function(s){return arguments.length?(o=s==null?null:s,a):o},a}function MLe(e,t,r,n,i){e.moveTo(t,r),e.bezierCurveTo(t=(t+n)/2,r,t,i,n,i)}function ELe(e,t,r,n,i){e.moveTo(t,r),e.bezierCurveTo(t,r=(r+i)/2,n,r,n,i)}function TLe(e,t,r,n,i){var o=fv(t,r),a=fv(t,r=(r+i)/2),s=fv(n,r),l=fv(n,i);e.moveTo(o[0],o[1]),e.bezierCurveTo(a[0],a[1],s[0],s[1],l[0],l[1])}function CFt(){return Det(MLe)}function AFt(){return Det(ELe)}function PFt(){var e=Det(TLe);return e.angle=e.x,delete e.x,e.radius=e.y,delete e.y,e}var IFt=M(()=>{Pw();Net();Og();v7();Ret()});var RC,Oet=M(()=>{Iw();RC={draw:function(e,t){var r=Math.sqrt(t/ku);e.moveTo(r,0),e.arc(0,0,r,0,Mc)}}});var S7,zet=M(()=>{S7={draw:function(e,t){var r=Math.sqrt(t/5)/2;e.moveTo(-3*r,-r),e.lineTo(-r,-r),e.lineTo(-r,-3*r),e.lineTo(r,-3*r),e.lineTo(r,-r),e.lineTo(3*r,-r),e.lineTo(3*r,r),e.lineTo(r,r),e.lineTo(r,3*r),e.lineTo(-r,3*r),e.lineTo(-r,r),e.lineTo(-3*r,r),e.closePath()}}});var LFt,CLe,M7,Fet=M(()=>{LFt=Math.sqrt(.3333333333333333),CLe=LFt*2,M7={draw:function(e,t){var r=Math.sqrt(t/CLe),n=r*LFt;e.moveTo(0,-r),e.lineTo(n,0),e.lineTo(0,r),e.lineTo(-n,0),e.closePath()}}});var ALe,kFt,PLe,ILe,E7,Bet=M(()=>{Iw();ALe=.8908130915292852,kFt=Math.sin(ku/10)/Math.sin(7*ku/10),PLe=Math.sin(Mc/10)*kFt,ILe=-Math.cos(Mc/10)*kFt,E7={draw:function(e,t){var r=Math.sqrt(t*ALe),n=PLe*r,i=ILe*r;e.moveTo(0,-r),e.lineTo(n,i);for(var o=1;o<5;++o){var a=Mc*o/5,s=Math.cos(a),l=Math.sin(a);e.lineTo(l*r,-s*r),e.lineTo(s*n-l*i,l*n+s*i)}e.closePath()}}});var T7,Het=M(()=>{T7={draw:function(e,t){var r=Math.sqrt(t),n=-r/2;e.rect(n,n,r,r)}}});var Vet,C7,Uet=M(()=>{Vet=Math.sqrt(3),C7={draw:function(e,t){var r=-Math.sqrt(t/(Vet*3));e.moveTo(0,r*2),e.lineTo(-Vet*r,-r),e.lineTo(Vet*r,-r),e.closePath()}}});var Ec,Tc,qet,LLe,A7,Get=M(()=>{Ec=-.5,Tc=Math.sqrt(3)/2,qet=1/Math.sqrt(12),LLe=(qet/2+1)*3,A7={draw:function(e,t){var r=Math.sqrt(t/LLe),n=r/2,i=r*qet,o=n,a=r*qet+r,s=-o,l=a;e.moveTo(n,i),e.lineTo(o,a),e.lineTo(s,l),e.lineTo(Ec*n-Tc*i,Tc*n+Ec*i),e.lineTo(Ec*o-Tc*a,Tc*o+Ec*a),e.lineTo(Ec*s-Tc*l,Tc*s+Ec*l),e.lineTo(Ec*n+Tc*i,Ec*i-Tc*n),e.lineTo(Ec*o+Tc*a,Ec*a-Tc*o),e.lineTo(Ec*s+Tc*l,Ec*l-Tc*s),e.closePath()}}});function NFt(){var e=Ge(RC),t=Ge(64),r=null;function n(){var i;if(r||(r=i=Iu()),e.apply(this,arguments).draw(r,+t.apply(this,arguments)),i)return r=null,i+""||null}return n.type=function(i){return arguments.length?(e=typeof i=="function"?i:Ge(i),n):e},n.size=function(i){return arguments.length?(t=typeof i=="function"?i:Ge(+i),n):t},n.context=function(i){return arguments.length?(r=i==null?null:i,n):r},n}var RFt,DFt=M(()=>{Pw();Oet();zet();Fet();Bet();Het();Uet();Get();Og();RFt=[RC,S7,M7,T7,E7,C7,A7]});function Cc(){}var NC=M(()=>{});function Ow(e,t,r){e._context.bezierCurveTo((2*e._x0+e._x1)/3,(2*e._y0+e._y1)/3,(e._x0+2*e._x1)/3,(e._y0+2*e._y1)/3,(e._x0+4*e._x1+t)/6,(e._y0+4*e._y1+r)/6)}function DC(e){this._context=e}function OFt(e){return new DC(e)}var OC=M(()=>{DC.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._y0=this._y1=NaN,this._point=0},lineEnd:function(){switch(this._point){case 3:Ow(this,this._x1,this._y1);case 2:this._context.lineTo(this._x1,this._y1);break}(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;break;case 2:this._point=3,this._context.lineTo((5*this._x0+this._x1)/6,(5*this._y0+this._y1)/6);default:Ow(this,e,t);break}this._x0=this._x1,this._x1=e,this._y0=this._y1,this._y1=t}}});function zFt(e){this._context=e}function FFt(e){return new zFt(e)}var BFt=M(()=>{NC();OC();zFt.prototype={areaStart:Cc,areaEnd:Cc,lineStart:function(){this._x0=this._x1=this._x2=this._x3=this._x4=this._y0=this._y1=this._y2=this._y3=this._y4=NaN,this._point=0},lineEnd:function(){switch(this._point){case 1:{this._context.moveTo(this._x2,this._y2),this._context.closePath();break}case 2:{this._context.moveTo((this._x2+2*this._x3)/3,(this._y2+2*this._y3)/3),this._context.lineTo((this._x3+2*this._x2)/3,(this._y3+2*this._y2)/3),this._context.closePath();break}case 3:{this.point(this._x2,this._y2),this.point(this._x3,this._y3),this.point(this._x4,this._y4);break}}},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._x2=e,this._y2=t;break;case 1:this._point=2,this._x3=e,this._y3=t;break;case 2:this._point=3,this._x4=e,this._y4=t,this._context.moveTo((this._x0+4*this._x1+e)/6,(this._y0+4*this._y1+t)/6);break;default:Ow(this,e,t);break}this._x0=this._x1,this._x1=e,this._y0=this._y1,this._y1=t}}});function HFt(e){this._context=e}function VFt(e){return new HFt(e)}var UFt=M(()=>{OC();HFt.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._y0=this._y1=NaN,this._point=0},lineEnd:function(){(this._line||this._line!==0&&this._point===3)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1;break;case 1:this._point=2;break;case 2:this._point=3;var r=(this._x0+4*this._x1+e)/6,n=(this._y0+4*this._y1+t)/6;this._line?this._context.lineTo(r,n):this._context.moveTo(r,n);break;case 3:this._point=4;default:Ow(this,e,t);break}this._x0=this._x1,this._x1=e,this._y0=this._y1,this._y1=t}}});function qFt(e,t){this._basis=new DC(e),this._beta=t}var GFt,WFt=M(()=>{OC();qFt.prototype={lineStart:function(){this._x=[],this._y=[],this._basis.lineStart()},lineEnd:function(){var e=this._x,t=this._y,r=e.length-1;if(r>0)for(var n=e[0],i=t[0],o=e[r]-n,a=t[r]-i,s=-1,l;++s<=r;)l=s/r,this._basis.point(this._beta*e[s]+(1-this._beta)*(n+l*o),this._beta*t[s]+(1-this._beta)*(i+l*a));this._x=this._y=null,this._basis.lineEnd()},point:function(e,t){this._x.push(+e),this._y.push(+t)}};GFt=function e(t){function r(n){return t===1?new DC(n):new qFt(n,t)}return r.beta=function(n){return e(+n)},r}(.85)});function zw(e,t,r){e._context.bezierCurveTo(e._x1+e._k*(e._x2-e._x0),e._y1+e._k*(e._y2-e._y0),e._x2+e._k*(e._x1-t),e._y2+e._k*(e._y1-r),e._x2,e._y2)}function P7(e,t){this._context=e,this._k=(1-t)/6}var YFt,zC=M(()=>{P7.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x2,this._y2);break;case 3:zw(this,this._x1,this._y1);break}(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2,this._x1=e,this._y1=t;break;case 2:this._point=3;default:zw(this,e,t);break}this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};YFt=function e(t){function r(n){return new P7(n,t)}return r.tension=function(n){return e(+n)},r}(0)});function I7(e,t){this._context=e,this._k=(1-t)/6}var jFt,Wet=M(()=>{NC();zC();I7.prototype={areaStart:Cc,areaEnd:Cc,lineStart:function(){this._x0=this._x1=this._x2=this._x3=this._x4=this._x5=this._y0=this._y1=this._y2=this._y3=this._y4=this._y5=NaN,this._point=0},lineEnd:function(){switch(this._point){case 1:{this._context.moveTo(this._x3,this._y3),this._context.closePath();break}case 2:{this._context.lineTo(this._x3,this._y3),this._context.closePath();break}case 3:{this.point(this._x3,this._y3),this.point(this._x4,this._y4),this.point(this._x5,this._y5);break}}},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._x3=e,this._y3=t;break;case 1:this._point=2,this._context.moveTo(this._x4=e,this._y4=t);break;case 2:this._point=3,this._x5=e,this._y5=t;break;default:zw(this,e,t);break}this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};jFt=function e(t){function r(n){return new I7(n,t)}return r.tension=function(n){return e(+n)},r}(0)});function L7(e,t){this._context=e,this._k=(1-t)/6}var XFt,Yet=M(()=>{zC();L7.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._point=0},lineEnd:function(){(this._line||this._line!==0&&this._point===3)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1;break;case 1:this._point=2;break;case 2:this._point=3,this._line?this._context.lineTo(this._x2,this._y2):this._context.moveTo(this._x2,this._y2);break;case 3:this._point=4;default:zw(this,e,t);break}this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};XFt=function e(t){function r(n){return new L7(n,t)}return r.tension=function(n){return e(+n)},r}(0)});function FC(e,t,r){var n=e._x1,i=e._y1,o=e._x2,a=e._y2;if(e._l01_a>Co){var s=2*e._l01_2a+3*e._l01_a*e._l12_a+e._l12_2a,l=3*e._l01_a*(e._l01_a+e._l12_a);n=(n*s-e._x0*e._l12_2a+e._x2*e._l01_2a)/l,i=(i*s-e._y0*e._l12_2a+e._y2*e._l01_2a)/l}if(e._l23_a>Co){var c=2*e._l23_2a+3*e._l23_a*e._l12_a+e._l12_2a,u=3*e._l23_a*(e._l23_a+e._l12_a);o=(o*c+e._x1*e._l23_2a-t*e._l12_2a)/u,a=(a*c+e._y1*e._l23_2a-r*e._l12_2a)/u}e._context.bezierCurveTo(n,i,o,a,e._x2,e._y2)}function $Ft(e,t){this._context=e,this._alpha=t}var KFt,k7=M(()=>{Iw();zC();$Ft.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._l01_a=this._l12_a=this._l23_a=this._l01_2a=this._l12_2a=this._l23_2a=this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x2,this._y2);break;case 3:this.point(this._x2,this._y2);break}(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){if(e=+e,t=+t,this._point){var r=this._x2-e,n=this._y2-t;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(r*r+n*n,this._alpha))}switch(this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;break;case 2:this._point=3;default:FC(this,e,t);break}this._l01_a=this._l12_a,this._l12_a=this._l23_a,this._l01_2a=this._l12_2a,this._l12_2a=this._l23_2a,this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};KFt=function e(t){function r(n){return t?new $Ft(n,t):new P7(n,0)}return r.alpha=function(n){return e(+n)},r}(.5)});function ZFt(e,t){this._context=e,this._alpha=t}var JFt,QFt=M(()=>{Wet();NC();k7();ZFt.prototype={areaStart:Cc,areaEnd:Cc,lineStart:function(){this._x0=this._x1=this._x2=this._x3=this._x4=this._x5=this._y0=this._y1=this._y2=this._y3=this._y4=this._y5=NaN,this._l01_a=this._l12_a=this._l23_a=this._l01_2a=this._l12_2a=this._l23_2a=this._point=0},lineEnd:function(){switch(this._point){case 1:{this._context.moveTo(this._x3,this._y3),this._context.closePath();break}case 2:{this._context.lineTo(this._x3,this._y3),this._context.closePath();break}case 3:{this.point(this._x3,this._y3),this.point(this._x4,this._y4),this.point(this._x5,this._y5);break}}},point:function(e,t){if(e=+e,t=+t,this._point){var r=this._x2-e,n=this._y2-t;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(r*r+n*n,this._alpha))}switch(this._point){case 0:this._point=1,this._x3=e,this._y3=t;break;case 1:this._point=2,this._context.moveTo(this._x4=e,this._y4=t);break;case 2:this._point=3,this._x5=e,this._y5=t;break;default:FC(this,e,t);break}this._l01_a=this._l12_a,this._l12_a=this._l23_a,this._l01_2a=this._l12_2a,this._l12_2a=this._l23_2a,this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};JFt=function e(t){function r(n){return t?new ZFt(n,t):new I7(n,0)}return r.alpha=function(n){return e(+n)},r}(.5)});function tBt(e,t){this._context=e,this._alpha=t}var eBt,rBt=M(()=>{Yet();k7();tBt.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._l01_a=this._l12_a=this._l23_a=this._l01_2a=this._l12_2a=this._l23_2a=this._point=0},lineEnd:function(){(this._line||this._line!==0&&this._point===3)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){if(e=+e,t=+t,this._point){var r=this._x2-e,n=this._y2-t;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(r*r+n*n,this._alpha))}switch(this._point){case 0:this._point=1;break;case 1:this._point=2;break;case 2:this._point=3,this._line?this._context.lineTo(this._x2,this._y2):this._context.moveTo(this._x2,this._y2);break;case 3:this._point=4;default:FC(this,e,t);break}this._l01_a=this._l12_a,this._l12_a=this._l23_a,this._l01_2a=this._l12_2a,this._l12_2a=this._l23_2a,this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};eBt=function e(t){function r(n){return t?new tBt(n,t):new L7(n,0)}return r.alpha=function(n){return e(+n)},r}(.5)});function nBt(e){this._context=e}function iBt(e){return new nBt(e)}var oBt=M(()=>{NC();nBt.prototype={areaStart:Cc,areaEnd:Cc,lineStart:function(){this._point=0},lineEnd:function(){this._point&&this._context.closePath()},point:function(e,t){e=+e,t=+t,this._point?this._context.lineTo(e,t):(this._point=1,this._context.moveTo(e,t))}}});function aBt(e){return e<0?-1:1}function sBt(e,t,r){var n=e._x1-e._x0,i=t-e._x1,o=(e._y1-e._y0)/(n||i<0&&-0),a=(r-e._y1)/(i||n<0&&-0),s=(o*i+a*n)/(n+i);return(aBt(o)+aBt(a))*Math.min(Math.abs(o),Math.abs(a),.5*Math.abs(s))||0}function lBt(e,t){var r=e._x1-e._x0;return r?(3*(e._y1-e._y0)/r-t)/2:t}function jet(e,t,r){var n=e._x0,i=e._y0,o=e._x1,a=e._y1,s=(o-n)/3;e._context.bezierCurveTo(n+s,i+s*t,o-s,a-s*r,o,a)}function R7(e){this._context=e}function cBt(e){this._context=new uBt(e)}function uBt(e){this._context=e}function hBt(e){return new R7(e)}function fBt(e){return new cBt(e)}var pBt=M(()=>{R7.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._y0=this._y1=this._t0=NaN,this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x1,this._y1);break;case 3:jet(this,this._t0,lBt(this,this._t0));break}(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){var r=NaN;if(e=+e,t=+t,!(e===this._x1&&t===this._y1)){switch(this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;break;case 2:this._point=3,jet(this,lBt(this,r=sBt(this,e,t)),r);break;default:jet(this,this._t0,r=sBt(this,e,t));break}this._x0=this._x1,this._x1=e,this._y0=this._y1,this._y1=t,this._t0=r}}};(cBt.prototype=Object.create(R7.prototype)).point=function(e,t){R7.prototype.point.call(this,t,e)};uBt.prototype={moveTo:function(e,t){this._context.moveTo(t,e)},closePath:function(){this._context.closePath()},lineTo:function(e,t){this._context.lineTo(t,e)},bezierCurveTo:function(e,t,r,n,i,o){this._context.bezierCurveTo(t,e,n,r,o,i)}}});function mBt(e){this._context=e}function dBt(e){var t,r=e.length-1,n,i=new Array(r),o=new Array(r),a=new Array(r);for(i[0]=0,o[0]=2,a[0]=e[0]+2*e[1],t=1;t<r-1;++t)i[t]=1,o[t]=4,a[t]=4*e[t]+2*e[t+1];for(i[r-1]=2,o[r-1]=7,a[r-1]=8*e[r-1]+e[r],t=1;t<r;++t)n=i[t]/o[t-1],o[t]-=n,a[t]-=n*a[t-1];for(i[r-1]=a[r-1]/o[r-1],t=r-2;t>=0;--t)i[t]=(a[t]-i[t+1])/o[t];for(o[r-1]=(e[r]+i[r-1])/2,t=0;t<r-1;++t)o[t]=2*e[t+1]-i[t+1];return[i,o]}function gBt(e){return new mBt(e)}var _Bt=M(()=>{mBt.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x=[],this._y=[]},lineEnd:function(){var e=this._x,t=this._y,r=e.length;if(r)if(this._line?this._context.lineTo(e[0],t[0]):this._context.moveTo(e[0],t[0]),r===2)this._context.lineTo(e[1],t[1]);else for(var n=dBt(e),i=dBt(t),o=0,a=1;a<r;++o,++a)this._context.bezierCurveTo(n[0][o],i[0][o],n[1][o],i[1][o],e[a],t[a]);(this._line||this._line!==0&&r===1)&&this._context.closePath(),this._line=1-this._line,this._x=this._y=null},point:function(e,t){this._x.push(+e),this._y.push(+t)}}});function N7(e,t){this._context=e,this._t=t}function yBt(e){return new N7(e,.5)}function vBt(e){return new N7(e,0)}function xBt(e){return new N7(e,1)}var bBt=M(()=>{N7.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x=this._y=NaN,this._point=0},lineEnd:function(){0<this._t&&this._t<1&&this._point===2&&this._context.lineTo(this._x,this._y),(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line>=0&&(this._t=1-this._t,this._line=1-this._line)},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;default:{if(this._t<=0)this._context.lineTo(this._x,t),this._context.lineTo(e,t);else{var r=this._x*(1-this._t)+e*this._t;this._context.lineTo(r,this._y),this._context.lineTo(r,t)}break}}this._x=e,this._y=t}}});function Ru(e,t){if((a=e.length)>1)for(var r=1,n,i,o=e[t[0]],a,s=o.length;r<a;++r)for(i=o,o=e[t[r]],n=0;n<s;++n)o[n][1]+=o[n][0]=isNaN(i[n][1])?i[n][0]:i[n][1]}var Fw=M(()=>{});function Nu(e){for(var t=e.length,r=new Array(t);--t>=0;)r[t]=t;return r}var Bw=M(()=>{});function kLe(e,t){return e[t]}function wBt(){var e=Ge([]),t=Nu,r=Ru,n=kLe;function i(o){var a=e.apply(this,arguments),s,l=o.length,c=a.length,u=new Array(c),h;for(s=0;s<c;++s){for(var f=a[s],p=u[s]=new Array(l),d=0,g;d<l;++d)p[d]=g=[0,+n(o[d],f,d,o)],g.data=o[d];p.key=f}for(s=0,h=t(u);s<c;++s)u[h[s]].index=s;return r(u,h),u}return i.keys=function(o){return arguments.length?(e=typeof o=="function"?o:Ge(kC.call(o)),i):e},i.value=function(o){return arguments.length?(n=typeof o=="function"?o:Ge(+o),i):n},i.order=function(o){return arguments.length?(t=o==null?Nu:typeof o=="function"?o:Ge(kC.call(o)),i):t},i.offset=function(o){return arguments.length?(r=o==null?Ru:o,i):r},i}var SBt=M(()=>{Net();Og();Fw();Bw()});function MBt(e,t){if((n=e.length)>0){for(var r,n,i=0,o=e[0].length,a;i<o;++i){for(a=r=0;r<n;++r)a+=e[r][i][1]||0;if(a)for(r=0;r<n;++r)e[r][i][1]/=a}Ru(e,t)}}var EBt=M(()=>{Fw()});function TBt(e,t){if((l=e.length)>1)for(var r,n=0,i,o,a,s,l,c=e[t[0]].length;n<c;++n)for(a=s=0,r=0;r<l;++r)(o=(i=e[t[r]][n])[1]-i[0])>=0?(i[0]=a,i[1]=a+=o):o<0?(i[1]=s,i[0]=s+=o):i[0]=a}var CBt=M(()=>{});function ABt(e,t){if((i=e.length)>0){for(var r=0,n=e[t[0]],i,o=n.length;r<o;++r){for(var a=0,s=0;a<i;++a)s+=e[a][r][1]||0;n[r][1]+=n[r][0]=-s/2}Ru(e,t)}}var PBt=M(()=>{Fw()});function IBt(e,t){if(!(!((a=e.length)>0)||!((o=(i=e[t[0]]).length)>0))){for(var r=0,n=1,i,o,a;n<o;++n){for(var s=0,l=0,c=0;s<a;++s){for(var u=e[t[s]],h=u[n][1]||0,f=u[n-1][1]||0,p=(h-f)/2,d=0;d<s;++d){var g=e[t[d]],_=g[n][1]||0,y=g[n-1][1]||0;p+=_-y}l+=h,c+=p*h}i[n-1][1]+=i[n-1][0]=r,l&&(r-=c/l)}i[n-1][1]+=i[n-1][0]=r,Ru(e,t)}}var LBt=M(()=>{Fw()});function D7(e){var t=e.map(Xet);return Nu(e).sort(function(r,n){return t[r]-t[n]})}function Xet(e){for(var t=0,r=-1,n=e.length,i;++r<n;)(i=+e[r][1])&&(t+=i);return t}var O7=M(()=>{Bw()});function kBt(e){return D7(e).reverse()}var RBt=M(()=>{O7()});function NBt(e){var t=e.length,r,n,i=e.map(Xet),o=Nu(e).sort(function(u,h){return i[h]-i[u]}),a=0,s=0,l=[],c=[];for(r=0;r<t;++r)n=o[r],a<s?(a+=i[n],l.push(n)):(s+=i[n],c.push(n));return c.reverse().concat(l)}var DBt=M(()=>{Bw();O7()});function OBt(e){return Nu(e).reverse()}var zBt=M(()=>{Bw()});var FBt=M(()=>{_Ft();Aet();x7();MFt();TFt();Let();Ret();IFt();DFt();Oet();zet();Fet();Het();Bet();Uet();Get();BFt();UFt();OC();WFt();Wet();Yet();zC();QFt();rBt();k7();oBt();LC();pBt();_Bt();bBt();SBt();EBt();CBt();Fw();PBt();LBt();O7();RBt();DBt();Bw();zBt()});function Sr(e,t,r,n){function i(o){return e(o=new Date(+o)),o}return i.floor=i,i.ceil=function(o){return e(o=new Date(o-1)),t(o,1),e(o),o},i.round=function(o){var a=i(o),s=i.ceil(o);return o-a<s-o?a:s},i.offset=function(o,a){return t(o=new Date(+o),a==null?1:Math.floor(a)),o},i.range=function(o,a,s){var l=[],c;if(o=i.ceil(o),s=s==null?1:Math.floor(s),!(o<a)||!(s>0))return l;do l.push(c=new Date(+o)),t(o,s),e(o);while(c<o&&o<a);return l},i.filter=function(o){return Sr(function(a){if(a>=a)for(;e(a),!o(a);)a.setTime(a-1)},function(a,s){if(a>=a)if(s<0)for(;++s<=0;)for(;t(a,-1),!o(a););else for(;--s>=0;)for(;t(a,1),!o(a););})},r&&(i.count=function(o,a){return $et.setTime(+o),Ket.setTime(+a),e($et),e(Ket),Math.floor(r($et,Ket))},i.every=function(o){return o=Math.floor(o),!isFinite(o)||!(o>0)?null:o>1?i.filter(n?function(a){return n(a)%o===0}:function(a){return i.count(0,a)%o===0}):i}),i}var $et,Ket,fa=M(()=>{$et=new Date,Ket=new Date});var z7,Zet,Jet,BBt=M(()=>{fa();z7=Sr(function(){},function(e,t){e.setTime(+e+t)},function(e,t){return t-e});z7.every=function(e){return e=Math.floor(e),!isFinite(e)||!(e>0)?null:e>1?Sr(function(t){t.setTime(Math.floor(t/e)*e)},function(t,r){t.setTime(+t+r*e)},function(t,r){return(r-t)/e}):z7};Zet=z7,Jet=z7.range});var BC,Ps,bf,F7,B7,wf=M(()=>{BC=1e3,Ps=6e4,bf=36e5,F7=864e5,B7=6048e5});var HBt,Qet,trt,VBt=M(()=>{fa();wf();HBt=Sr(function(e){e.setTime(Math.floor(e/BC)*BC)},function(e,t){e.setTime(+e+t*BC)},function(e,t){return(t-e)/BC},function(e){return e.getUTCSeconds()}),Qet=HBt,trt=HBt.range});var UBt,qBt,GBt,WBt=M(()=>{fa();wf();UBt=Sr(function(e){e.setTime(Math.floor(e/Ps)*Ps)},function(e,t){e.setTime(+e+t*Ps)},function(e,t){return(t-e)/Ps},function(e){return e.getMinutes()}),qBt=UBt,GBt=UBt.range});var YBt,jBt,XBt,$Bt=M(()=>{fa();wf();YBt=Sr(function(e){var t=e.getTimezoneOffset()*Ps%bf;t<0&&(t+=bf),e.setTime(Math.floor((+e-t)/bf)*bf+t)},function(e,t){e.setTime(+e+t*bf)},function(e,t){return(t-e)/bf},function(e){return e.getHours()}),jBt=YBt,XBt=YBt.range});var KBt,ZBt,JBt,QBt=M(()=>{fa();wf();KBt=Sr(function(e){e.setHours(0,0,0,0)},function(e,t){e.setDate(e.getDate()+t)},function(e,t){return(t-e-(t.getTimezoneOffset()-e.getTimezoneOffset())*Ps)/F7},function(e){return e.getDate()-1}),ZBt=KBt,JBt=KBt.range});function pv(e){return Sr(function(t){t.setDate(t.getDate()-(t.getDay()+7-e)%7),t.setHours(0,0,0,0)},function(t,r){t.setDate(t.getDate()+r*7)},function(t,r){return(r-t-(r.getTimezoneOffset()-t.getTimezoneOffset())*Ps)/B7})}var H7,ert,rrt,nrt,irt,ort,art,srt,tHt,eHt,rHt,nHt,iHt,oHt,aHt=M(()=>{fa();wf();H7=pv(0),ert=pv(1),rrt=pv(2),nrt=pv(3),irt=pv(4),ort=pv(5),art=pv(6),srt=H7.range,tHt=ert.range,eHt=rrt.range,rHt=nrt.range,nHt=irt.range,iHt=ort.range,oHt=art.range});var sHt,lHt,cHt,uHt=M(()=>{fa();sHt=Sr(function(e){e.setDate(1),e.setHours(0,0,0,0)},function(e,t){e.setMonth(e.getMonth()+t)},function(e,t){return t.getMonth()-e.getMonth()+(t.getFullYear()-e.getFullYear())*12},function(e){return e.getMonth()}),lHt=sHt,cHt=sHt.range});var lrt,hHt,fHt,pHt=M(()=>{fa();lrt=Sr(function(e){e.setMonth(0,1),e.setHours(0,0,0,0)},function(e,t){e.setFullYear(e.getFullYear()+t)},function(e,t){return t.getFullYear()-e.getFullYear()},function(e){return e.getFullYear()});lrt.every=function(e){return!isFinite(e=Math.floor(e))||!(e>0)?null:Sr(function(t){t.setFullYear(Math.floor(t.getFullYear()/e)*e),t.setMonth(0,1),t.setHours(0,0,0,0)},function(t,r){t.setFullYear(t.getFullYear()+r*e)})};hHt=lrt,fHt=lrt.range});var dHt,mHt,gHt,_Ht=M(()=>{fa();wf();dHt=Sr(function(e){e.setUTCSeconds(0,0)},function(e,t){e.setTime(+e+t*Ps)},function(e,t){return(t-e)/Ps},function(e){return e.getUTCMinutes()}),mHt=dHt,gHt=dHt.range});var yHt,vHt,xHt,bHt=M(()=>{fa();wf();yHt=Sr(function(e){e.setUTCMinutes(0,0,0)},function(e,t){e.setTime(+e+t*bf)},function(e,t){return(t-e)/bf},function(e){return e.getUTCHours()}),vHt=yHt,xHt=yHt.range});var wHt,SHt,MHt,EHt=M(()=>{fa();wf();wHt=Sr(function(e){e.setUTCHours(0,0,0,0)},function(e,t){e.setUTCDate(e.getUTCDate()+t)},function(e,t){return(t-e)/F7},function(e){return e.getUTCDate()-1}),SHt=wHt,MHt=wHt.range});function dv(e){return Sr(function(t){t.setUTCDate(t.getUTCDate()-(t.getUTCDay()+7-e)%7),t.setUTCHours(0,0,0,0)},function(t,r){t.setUTCDate(t.getUTCDate()+r*7)},function(t,r){return(r-t)/B7})}var V7,crt,urt,hrt,frt,prt,drt,mrt,THt,CHt,AHt,PHt,IHt,LHt,kHt=M(()=>{fa();wf();V7=dv(0),crt=dv(1),urt=dv(2),hrt=dv(3),frt=dv(4),prt=dv(5),drt=dv(6),mrt=V7.range,THt=crt.range,CHt=urt.range,AHt=hrt.range,PHt=frt.range,IHt=prt.range,LHt=drt.range});var RHt,NHt,DHt,OHt=M(()=>{fa();RHt=Sr(function(e){e.setUTCDate(1),e.setUTCHours(0,0,0,0)},function(e,t){e.setUTCMonth(e.getUTCMonth()+t)},function(e,t){return t.getUTCMonth()-e.getUTCMonth()+(t.getUTCFullYear()-e.getUTCFullYear())*12},function(e){return e.getUTCMonth()}),NHt=RHt,DHt=RHt.range});var grt,zHt,FHt,BHt=M(()=>{fa();grt=Sr(function(e){e.setUTCMonth(0,1),e.setUTCHours(0,0,0,0)},function(e,t){e.setUTCFullYear(e.getUTCFullYear()+t)},function(e,t){return t.getUTCFullYear()-e.getUTCFullYear()},function(e){return e.getUTCFullYear()});grt.every=function(e){return!isFinite(e=Math.floor(e))||!(e>0)?null:Sr(function(t){t.setUTCFullYear(Math.floor(t.getUTCFullYear()/e)*e),t.setUTCMonth(0,1),t.setUTCHours(0,0,0,0)},function(t,r){t.setUTCFullYear(t.getUTCFullYear()+r*e)})};zHt=grt,FHt=grt.range});var HHt=M(()=>{fa();BBt();VBt();WBt();$Bt();QBt();aHt();uHt();pHt();_Ht();bHt();EHt();kHt();OHt();BHt()});function pa(e,t,r,n){function i(o){return e(o=arguments.length===0?new Date:new Date(+o)),o}return i.floor=function(o){return e(o=new Date(+o)),o},i.ceil=function(o){return e(o=new Date(o-1)),t(o,1),e(o),o},i.round=function(o){var a=i(o),s=i.ceil(o);return o-a<s-o?a:s},i.offset=function(o,a){return t(o=new Date(+o),a==null?1:Math.floor(a)),o},i.range=function(o,a,s){var l=[],c;if(o=i.ceil(o),s=s==null?1:Math.floor(s),!(o<a)||!(s>0))return l;do l.push(c=new Date(+o)),t(o,s),e(o);while(c<o&&o<a);return l},i.filter=function(o){return pa(function(a){if(a>=a)for(;e(a),!o(a);)a.setTime(a-1)},function(a,s){if(a>=a)if(s<0)for(;++s<=0;)for(;t(a,-1),!o(a););else for(;--s>=0;)for(;t(a,1),!o(a););})},r&&(i.count=function(o,a){return _rt.setTime(+o),yrt.setTime(+a),e(_rt),e(yrt),Math.floor(r(_rt,yrt))},i.every=function(o){return o=Math.floor(o),!isFinite(o)||!(o>0)?null:o>1?i.filter(n?function(a){return n(a)%o===0}:function(a){return i.count(0,a)%o===0}):i}),i}var _rt,yrt,mv=M(()=>{_rt=new Date,yrt=new Date});var U7,q7,G7,HC=M(()=>{U7=6e4,q7=864e5,G7=6048e5});var VHt,W7,RLe,UHt=M(()=>{mv();HC();VHt=pa(function(e){e.setHours(0,0,0,0)},function(e,t){e.setDate(e.getDate()+t)},function(e,t){return(t-e-(t.getTimezoneOffset()-e.getTimezoneOffset())*U7)/q7},function(e){return e.getDate()-1}),W7=VHt,RLe=VHt.range});function gv(e){return pa(function(t){t.setDate(t.getDate()-(t.getDay()+7-e)%7),t.setHours(0,0,0,0)},function(t,r){t.setDate(t.getDate()+r*7)},function(t,r){return(r-t-(r.getTimezoneOffset()-t.getTimezoneOffset())*U7)/G7})}var VC,Hw,qHt,GHt,Vw,WHt,YHt,jHt,NLe,DLe,OLe,zLe,FLe,BLe,XHt=M(()=>{mv();HC();VC=gv(0),Hw=gv(1),qHt=gv(2),GHt=gv(3),Vw=gv(4),WHt=gv(5),YHt=gv(6),jHt=VC.range,NLe=Hw.range,DLe=qHt.range,OLe=GHt.range,zLe=Vw.range,FLe=WHt.range,BLe=YHt.range});var vrt,_v,HLe,$Ht=M(()=>{mv();vrt=pa(function(e){e.setMonth(0,1),e.setHours(0,0,0,0)},function(e,t){e.setFullYear(e.getFullYear()+t)},function(e,t){return t.getFullYear()-e.getFullYear()},function(e){return e.getFullYear()});vrt.every=function(e){return!isFinite(e=Math.floor(e))||!(e>0)?null:pa(function(t){t.setFullYear(Math.floor(t.getFullYear()/e)*e),t.setMonth(0,1),t.setHours(0,0,0,0)},function(t,r){t.setFullYear(t.getFullYear()+r*e)})};_v=vrt,HLe=vrt.range});var KHt,Y7,VLe,ZHt=M(()=>{mv();HC();KHt=pa(function(e){e.setUTCHours(0,0,0,0)},function(e,t){e.setUTCDate(e.getUTCDate()+t)},function(e,t){return(t-e)/q7},function(e){return e.getUTCDate()-1}),Y7=KHt,VLe=KHt.range});function yv(e){return pa(function(t){t.setUTCDate(t.getUTCDate()-(t.getUTCDay()+7-e)%7),t.setUTCHours(0,0,0,0)},function(t,r){t.setUTCDate(t.getUTCDate()+r*7)},function(t,r){return(r-t)/G7})}var UC,Uw,JHt,QHt,qw,tVt,eVt,rVt,ULe,qLe,GLe,WLe,YLe,jLe,nVt=M(()=>{mv();HC();UC=yv(0),Uw=yv(1),JHt=yv(2),QHt=yv(3),qw=yv(4),tVt=yv(5),eVt=yv(6),rVt=UC.range,ULe=Uw.range,qLe=JHt.range,GLe=QHt.range,WLe=qw.range,YLe=tVt.range,jLe=eVt.range});var xrt,vv,XLe,iVt=M(()=>{mv();xrt=pa(function(e){e.setUTCMonth(0,1),e.setUTCHours(0,0,0,0)},function(e,t){e.setUTCFullYear(e.getUTCFullYear()+t)},function(e,t){return t.getUTCFullYear()-e.getUTCFullYear()},function(e){return e.getUTCFullYear()});xrt.every=function(e){return!isFinite(e=Math.floor(e))||!(e>0)?null:pa(function(t){t.setUTCFullYear(Math.floor(t.getUTCFullYear()/e)*e),t.setUTCMonth(0,1),t.setUTCHours(0,0,0,0)},function(t,r){t.setUTCFullYear(t.getUTCFullYear()+r*e)})};vv=xrt,XLe=xrt.range});var oVt=M(()=>{UHt();XHt();$Ht();ZHt();nVt();iVt()});function $Le(e){if(0<=e.y&&e.y<100){var t=new Date(-1,e.m,e.d,e.H,e.M,e.S,e.L);return t.setFullYear(e.y),t}return new Date(e.y,e.m,e.d,e.H,e.M,e.S,e.L)}function j7(e){if(0<=e.y&&e.y<100){var t=new Date(Date.UTC(-1,e.m,e.d,e.H,e.M,e.S,e.L));return t.setUTCFullYear(e.y),t}return new Date(Date.UTC(e.y,e.m,e.d,e.H,e.M,e.S,e.L))}function qC(e){return{y:e,m:0,d:1,H:0,M:0,S:0,L:0}}function YC(e){var t=e.dateTime,r=e.date,n=e.time,i=e.periods,o=e.days,a=e.shortDays,s=e.months,l=e.shortMonths,c=GC(i),u=WC(i),h=GC(o),f=WC(o),p=GC(a),d=WC(a),g=GC(s),_=WC(s),y=GC(l),x=WC(l),b={a:W,A:Z,b:rt,B:ot,c:null,d:cVt,e:cVt,f:vke,H:gke,I:_ke,j:yke,L:dVt,m:xke,M:bke,p:st,Q:fVt,s:pVt,S:wke,u:Ske,U:Mke,V:Eke,w:Tke,W:Cke,x:null,X:null,y:Ake,Y:Pke,Z:Ike,"%":hVt},S={a:St,A:bt,b:Mt,B:lt,c:null,d:uVt,e:uVt,f:Nke,H:Lke,I:kke,j:Rke,L:mVt,m:Dke,M:Oke,p:Kt,Q:fVt,s:pVt,S:zke,u:Fke,U:Bke,V:Hke,w:Vke,W:Uke,x:null,X:null,y:qke,Y:Gke,Z:Wke,"%":hVt},C={a:B,A:I,b:L,B:R,c:F,d:sVt,e:sVt,f:fke,H:lVt,I:lVt,j:lke,L:hke,m:ske,M:cke,p:D,Q:dke,s:mke,S:uke,u:tke,U:eke,V:rke,w:QLe,W:nke,x:z,X:U,y:oke,Y:ike,Z:ake,"%":pke};b.x=P(r,b),b.X=P(n,b),b.c=P(t,b),S.x=P(r,S),S.X=P(n,S),S.c=P(t,S);function P(_t,ct){return function(X){var et=[],dt=-1,q=0,pt=_t.length,ht,wt,kt;for(X instanceof Date||(X=new Date(+X));++dt<pt;)_t.charCodeAt(dt)===37&&(et.push(_t.slice(q,dt)),(wt=aVt[ht=_t.charAt(++dt)])!=null?ht=_t.charAt(++dt):wt=ht==="e"?" ":"0",(kt=ct[ht])&&(ht=kt(X,wt)),et.push(ht),q=dt+1);return et.push(_t.slice(q,dt)),et.join("")}}function k(_t,ct){return function(X){var et=qC(1900),dt=O(et,_t,X+="",0),q,pt;if(dt!=X.length)return null;if("Q"in et)return new Date(et.Q);if("p"in et&&(et.H=et.H%12+et.p*12),"V"in et){if(et.V<1||et.V>53)return null;"w"in et||(et.w=1),"Z"in et?(q=j7(qC(et.y)),pt=q.getUTCDay(),q=pt>4||pt===0?Uw.ceil(q):Uw(q),q=Y7.offset(q,(et.V-1)*7),et.y=q.getUTCFullYear(),et.m=q.getUTCMonth(),et.d=q.getUTCDate()+(et.w+6)%7):(q=ct(qC(et.y)),pt=q.getDay(),q=pt>4||pt===0?Hw.ceil(q):Hw(q),q=W7.offset(q,(et.V-1)*7),et.y=q.getFullYear(),et.m=q.getMonth(),et.d=q.getDate()+(et.w+6)%7)}else("W"in et||"U"in et)&&("w"in et||(et.w="u"in et?et.u%7:"W"in et?1:0),pt="Z"in et?j7(qC(et.y)).getUTCDay():ct(qC(et.y)).getDay(),et.m=0,et.d="W"in et?(et.w+6)%7+et.W*7-(pt+5)%7:et.w+et.U*7-(pt+6)%7);return"Z"in et?(et.H+=et.Z/100|0,et.M+=et.Z%100,j7(et)):ct(et)}}function O(_t,ct,X,et){for(var dt=0,q=ct.length,pt=X.length,ht,wt;dt<q;){if(et>=pt)return-1;if(ht=ct.charCodeAt(dt++),ht===37){if(ht=ct.charAt(dt++),wt=C[ht in aVt?ct.charAt(dt++):ht],!wt||(et=wt(_t,X,et))<0)return-1}else if(ht!=X.charCodeAt(et++))return-1}return et}function D(_t,ct,X){var et=c.exec(ct.slice(X));return et?(_t.p=u[et[0].toLowerCase()],X+et[0].length):-1}function B(_t,ct,X){var et=p.exec(ct.slice(X));return et?(_t.w=d[et[0].toLowerCase()],X+et[0].length):-1}function I(_t,ct,X){var et=h.exec(ct.slice(X));return et?(_t.w=f[et[0].toLowerCase()],X+et[0].length):-1}function L(_t,ct,X){var et=y.exec(ct.slice(X));return et?(_t.m=x[et[0].toLowerCase()],X+et[0].length):-1}function R(_t,ct,X){var et=g.exec(ct.slice(X));return et?(_t.m=_[et[0].toLowerCase()],X+et[0].length):-1}function F(_t,ct,X){return O(_t,t,ct,X)}function z(_t,ct,X){return O(_t,r,ct,X)}function U(_t,ct,X){return O(_t,n,ct,X)}function W(_t){return a[_t.getDay()]}function Z(_t){return o[_t.getDay()]}function rt(_t){return l[_t.getMonth()]}function ot(_t){return s[_t.getMonth()]}function st(_t){return i[+(_t.getHours()>=12)]}function St(_t){return a[_t.getUTCDay()]}function bt(_t){return o[_t.getUTCDay()]}function Mt(_t){return l[_t.getUTCMonth()]}function lt(_t){return s[_t.getUTCMonth()]}function Kt(_t){return i[+(_t.getUTCHours()>=12)]}return{format:function(_t){var ct=P(_t+="",b);return ct.toString=function(){return _t},ct},parse:function(_t){var ct=k(_t+="",$Le);return ct.toString=function(){return _t},ct},utcFormat:function(_t){var ct=P(_t+="",S);return ct.toString=function(){return _t},ct},utcParse:function(_t){var ct=k(_t,j7);return ct.toString=function(){return _t},ct}}}function gn(e,t,r){var n=e<0?"-":"",i=(n?-e:e)+"",o=i.length;return n+(o<r?new Array(r-o+1).join(t)+i:i)}function JLe(e){return e.replace(ZLe,"\\$&")}function GC(e){return new RegExp("^(?:"+e.map(JLe).join("|")+")","i")}function WC(e){for(var t={},r=-1,n=e.length;++r<n;)t[e[r].toLowerCase()]=r;return t}function QLe(e,t,r){var n=Vo.exec(t.slice(r,r+1));return n?(e.w=+n[0],r+n[0].length):-1}function tke(e,t,r){var n=Vo.exec(t.slice(r,r+1));return n?(e.u=+n[0],r+n[0].length):-1}function eke(e,t,r){var n=Vo.exec(t.slice(r,r+2));return n?(e.U=+n[0],r+n[0].length):-1}function rke(e,t,r){var n=Vo.exec(t.slice(r,r+2));return n?(e.V=+n[0],r+n[0].length):-1}function nke(e,t,r){var n=Vo.exec(t.slice(r,r+2));return n?(e.W=+n[0],r+n[0].length):-1}function ike(e,t,r){var n=Vo.exec(t.slice(r,r+4));return n?(e.y=+n[0],r+n[0].length):-1}function oke(e,t,r){var n=Vo.exec(t.slice(r,r+2));return n?(e.y=+n[0]+(+n[0]>68?1900:2e3),r+n[0].length):-1}function ake(e,t,r){var n=/^(Z)|([+-]\d\d)(?::?(\d\d))?/.exec(t.slice(r,r+6));return n?(e.Z=n[1]?0:-(n[2]+(n[3]||"00")),r+n[0].length):-1}function ske(e,t,r){var n=Vo.exec(t.slice(r,r+2));return n?(e.m=n[0]-1,r+n[0].length):-1}function sVt(e,t,r){var n=Vo.exec(t.slice(r,r+2));return n?(e.d=+n[0],r+n[0].length):-1}function lke(e,t,r){var n=Vo.exec(t.slice(r,r+3));return n?(e.m=0,e.d=+n[0],r+n[0].length):-1}function lVt(e,t,r){var n=Vo.exec(t.slice(r,r+2));return n?(e.H=+n[0],r+n[0].length):-1}function cke(e,t,r){var n=Vo.exec(t.slice(r,r+2));return n?(e.M=+n[0],r+n[0].length):-1}function uke(e,t,r){var n=Vo.exec(t.slice(r,r+2));return n?(e.S=+n[0],r+n[0].length):-1}function hke(e,t,r){var n=Vo.exec(t.slice(r,r+3));return n?(e.L=+n[0],r+n[0].length):-1}function fke(e,t,r){var n=Vo.exec(t.slice(r,r+6));return n?(e.L=Math.floor(n[0]/1e3),r+n[0].length):-1}function pke(e,t,r){var n=KLe.exec(t.slice(r,r+1));return n?r+n[0].length:-1}function dke(e,t,r){var n=Vo.exec(t.slice(r));return n?(e.Q=+n[0],r+n[0].length):-1}function mke(e,t,r){var n=Vo.exec(t.slice(r));return n?(e.Q=+n[0]*1e3,r+n[0].length):-1}function cVt(e,t){return gn(e.getDate(),t,2)}function gke(e,t){return gn(e.getHours(),t,2)}function _ke(e,t){return gn(e.getHours()%12||12,t,2)}function yke(e,t){return gn(1+W7.count(_v(e),e),t,3)}function dVt(e,t){return gn(e.getMilliseconds(),t,3)}function vke(e,t){return dVt(e,t)+"000"}function xke(e,t){return gn(e.getMonth()+1,t,2)}function bke(e,t){return gn(e.getMinutes(),t,2)}function wke(e,t){return gn(e.getSeconds(),t,2)}function Ske(e){var t=e.getDay();return t===0?7:t}function Mke(e,t){return gn(VC.count(_v(e),e),t,2)}function Eke(e,t){var r=e.getDay();return e=r>=4||r===0?Vw(e):Vw.ceil(e),gn(Vw.count(_v(e),e)+(_v(e).getDay()===4),t,2)}function Tke(e){return e.getDay()}function Cke(e,t){return gn(Hw.count(_v(e),e),t,2)}function Ake(e,t){return gn(e.getFullYear()%100,t,2)}function Pke(e,t){return gn(e.getFullYear()%1e4,t,4)}function Ike(e){var t=e.getTimezoneOffset();return(t>0?"-":(t*=-1,"+"))+gn(t/60|0,"0",2)+gn(t%60,"0",2)}function uVt(e,t){return gn(e.getUTCDate(),t,2)}function Lke(e,t){return gn(e.getUTCHours(),t,2)}function kke(e,t){return gn(e.getUTCHours()%12||12,t,2)}function Rke(e,t){return gn(1+Y7.count(vv(e),e),t,3)}function mVt(e,t){return gn(e.getUTCMilliseconds(),t,3)}function Nke(e,t){return mVt(e,t)+"000"}function Dke(e,t){return gn(e.getUTCMonth()+1,t,2)}function Oke(e,t){return gn(e.getUTCMinutes(),t,2)}function zke(e,t){return gn(e.getUTCSeconds(),t,2)}function Fke(e){var t=e.getUTCDay();return t===0?7:t}function Bke(e,t){return gn(UC.count(vv(e),e),t,2)}function Hke(e,t){var r=e.getUTCDay();return e=r>=4||r===0?qw(e):qw.ceil(e),gn(qw.count(vv(e),e)+(vv(e).getUTCDay()===4),t,2)}function Vke(e){return e.getUTCDay()}function Uke(e,t){return gn(Uw.count(vv(e),e),t,2)}function qke(e,t){return gn(e.getUTCFullYear()%100,t,2)}function Gke(e,t){return gn(e.getUTCFullYear()%1e4,t,4)}function Wke(){return"+0000"}function hVt(){return"%"}function fVt(e){return+e}function pVt(e){return Math.floor(+e/1e3)}var aVt,Vo,KLe,ZLe,brt=M(()=>{oVt();aVt={"-":"",_:" ",0:"0"},Vo=/^\s*\d+/,KLe=/^%/,ZLe=/[\\^$*+?|[\]().{}]/g});function X7(e){return Gw=YC(e),wrt=Gw.format,Srt=Gw.parse,jC=Gw.utcFormat,XC=Gw.utcParse,Gw}var Gw,wrt,Srt,jC,XC,$7=M(()=>{brt();X7({dateTime:"%x, %X",date:"%-m/%-d/%Y",time:"%-I:%M:%S %p",periods:["AM","PM"],days:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],shortDays:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],months:["January","February","March","April","May","June","July","August","September","October","November","December"],shortMonths:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]})});function Yke(e){return e.toISOString()}var Mrt,jke,gVt,Ert=M(()=>{$7();Mrt="%Y-%m-%dT%H:%M:%S.%LZ";jke=Date.prototype.toISOString?Yke:jC(Mrt),gVt=jke});function Xke(e){var t=new Date(e);return isNaN(t)?null:t}var $ke,_Vt,yVt=M(()=>{Ert();$7();$ke=+new Date("2000-01-01T00:00:00.000Z")?Xke:XC(Mrt),_Vt=$ke});var vVt=M(()=>{$7();brt();Ert();yVt()});function Yw(){return xv||(wVt(Kke),xv=JC.now()+J7)}function Kke(){xv=0}function bv(){this._call=this._time=this._next=null}function Crt(e,t,r){var n=new bv;return n.restart(e,t,r),n}function Art(){Yw(),++Ww;for(var e=K7,t;e;)(t=xv-e._time)>=0&&e._call.call(null,t),e=e._next;--Ww}function xVt(){xv=(Z7=JC.now())+J7,Ww=KC=0;try{Art()}finally{Ww=0,Jke(),xv=0}}function Zke(){var e=JC.now(),t=e-Z7;t>bVt&&(J7-=t,Z7=e)}function Jke(){for(var e,t=K7,r,n=1/0;t;)t._call?(n>t._time&&(n=t._time),e=t,t=t._next):(r=t._next,t._next=null,t=e?e._next=r:K7=r);ZC=e,Trt(n)}function Trt(e){if(!Ww){KC&&(KC=clearTimeout(KC));var t=e-xv;t>24?(e<1/0&&(KC=setTimeout(xVt,e-JC.now()-J7)),$C&&($C=clearInterval($C))):($C||(Z7=JC.now(),$C=setInterval(Zke,bVt)),Ww=1,wVt(xVt))}}var Ww,KC,$C,bVt,K7,ZC,Z7,xv,J7,JC,wVt,Q7=M(()=>{Ww=0,KC=0,$C=0,bVt=1e3,Z7=0,xv=0,J7=0,JC=typeof performance=="object"&&performance.now?performance:Date,wVt=typeof window=="object"&&window.requestAnimationFrame?window.requestAnimationFrame.bind(window):function(e){setTimeout(e,17)};bv.prototype=Crt.prototype={constructor:bv,restart:function(e,t,r){if(typeof e!="function")throw new TypeError("callback is not a function");r=(r==null?Yw():+r)+(t==null?0:+t),!this._next&&ZC!==this&&(ZC?ZC._next=this:K7=this,ZC=this),this._call=e,this._time=r,Trt()},stop:function(){this._call&&(this._call=null,this._time=1/0,Trt())}}});function SVt(e,t,r){var n=new bv;return t=t==null?0:+t,n.restart(function(i){n.stop(),e(i+t)},t,r),n}var MVt=M(()=>{Q7()});function EVt(e,t,r){var n=new bv,i=t;return t==null?(n.restart(e,t,r),n):(t=+t,r=r==null?Yw():+r,n.restart(function o(a){a+=i,n.restart(o,i+=t,r),e(a)},t,r),n)}var TVt=M(()=>{Q7()});var CVt=M(()=>{Q7();MVt();TVt()});var tz,Prt,Irt=M(()=>{tz="http://www.w3.org/1999/xhtml",Prt={svg:"http://www.w3.org/2000/svg",xhtml:tz,xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/"}});function ld(e){var t=e+="",r=t.indexOf(":");return r>=0&&(t=e.slice(0,r))!=="xmlns"&&(e=e.slice(r+1)),Prt.hasOwnProperty(t)?{space:Prt[t],local:e}:e}var ez=M(()=>{Irt()});function Qke(e){return function(){var t=this.ownerDocument,r=this.namespaceURI;return r===tz&&t.documentElement.namespaceURI===tz?t.createElement(e):t.createElementNS(r,e)}}function t8e(e){return function(){return this.ownerDocument.createElementNS(e.space,e.local)}}function rz(e){var t=ld(e);return(t.local?t8e:Qke)(t)}var Lrt=M(()=>{ez();Irt()});function e8e(){}function wv(e){return e==null?e8e:function(){return this.querySelector(e)}}var nz=M(()=>{});function AVt(e){typeof e!="function"&&(e=wv(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=new Array(a),l,c,u=0;u<a;++u)(l=o[u])&&(c=e.call(l,l.__data__,u,o))&&("__data__"in l&&(c.__data__=l.__data__),s[u]=c);return new no(n,this._parents)}var PVt=M(()=>{Sf();nz()});function r8e(){return[]}function QC(e){return e==null?r8e:function(){return this.querySelectorAll(e)}}var krt=M(()=>{});function IVt(e){typeof e!="function"&&(e=QC(e));for(var t=this._groups,r=t.length,n=[],i=[],o=0;o<r;++o)for(var a=t[o],s=a.length,l,c=0;c<s;++c)(l=a[c])&&(n.push(e.call(l,l.__data__,c,a)),i.push(l));return new no(n,i)}var LVt=M(()=>{Sf();krt()});function tA(e){return function(){return this.matches(e)}}var Rrt=M(()=>{});function kVt(e){typeof e!="function"&&(e=tA(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=[],l,c=0;c<a;++c)(l=o[c])&&e.call(l,l.__data__,c,o)&&s.push(l);return new no(n,this._parents)}var RVt=M(()=>{Sf();Rrt()});function iz(e){return new Array(e.length)}var Nrt=M(()=>{});function NVt(){return new no(this._enter||this._groups.map(iz),this._parents)}function eA(e,t){this.ownerDocument=e.ownerDocument,this.namespaceURI=e.namespaceURI,this._next=null,this._parent=e,this.__data__=t}var Drt=M(()=>{Nrt();Sf();eA.prototype={constructor:eA,appendChild:function(e){return this._parent.insertBefore(e,this._next)},insertBefore:function(e,t){return this._parent.insertBefore(e,t)},querySelector:function(e){return this._parent.querySelector(e)},querySelectorAll:function(e){return this._parent.querySelectorAll(e)}}});function DVt(e){return function(){return e}}var OVt=M(()=>{});function n8e(e,t,r,n,i,o){for(var a=0,s,l=t.length,c=o.length;a<c;++a)(s=t[a])?(s.__data__=o[a],n[a]=s):r[a]=new eA(e,o[a]);for(;a<l;++a)(s=t[a])&&(i[a]=s)}function i8e(e,t,r,n,i,o,a){var s,l,c={},u=t.length,h=o.length,f=new Array(u),p;for(s=0;s<u;++s)(l=t[s])&&(f[s]=p=zVt+a.call(l,l.__data__,s,t),p in c?i[s]=l:c[p]=l);for(s=0;s<h;++s)p=zVt+a.call(e,o[s],s,o),(l=c[p])?(n[s]=l,l.__data__=o[s],c[p]=null):r[s]=new eA(e,o[s]);for(s=0;s<u;++s)(l=t[s])&&c[f[s]]===l&&(i[s]=l)}function FVt(e,t){if(!e)return p=new Array(this.size()),c=-1,this.each(function(P){p[++c]=P}),p;var r=t?i8e:n8e,n=this._parents,i=this._groups;typeof e!="function"&&(e=DVt(e));for(var o=i.length,a=new Array(o),s=new Array(o),l=new Array(o),c=0;c<o;++c){var u=n[c],h=i[c],f=h.length,p=e.call(u,u&&u.__data__,c,n),d=p.length,g=s[c]=new Array(d),_=a[c]=new Array(d),y=l[c]=new Array(f);r(u,h,g,_,y,p,t);for(var x=0,b=0,S,C;x<d;++x)if(S=g[x]){for(x>=b&&(b=x+1);!(C=_[b])&&++b<d;);S._next=C||null}}return a=new no(a,n),a._enter=s,a._exit=l,a}var zVt,BVt=M(()=>{Sf();Drt();OVt();zVt="$"});function HVt(){return new no(this._exit||this._groups.map(iz),this._parents)}var VVt=M(()=>{Nrt();Sf()});function UVt(e,t,r){var n=this.enter(),i=this,o=this.exit();return n=typeof e=="function"?e(n):n.append(e+""),t!=null&&(i=t(i)),r==null?o.remove():r(o),n&&i?n.merge(i).order():i}var qVt=M(()=>{});function GVt(e){for(var t=this._groups,r=e._groups,n=t.length,i=r.length,o=Math.min(n,i),a=new Array(n),s=0;s<o;++s)for(var l=t[s],c=r[s],u=l.length,h=a[s]=new Array(u),f,p=0;p<u;++p)(f=l[p]||c[p])&&(h[p]=f);for(;s<n;++s)a[s]=t[s];return new no(a,this._parents)}var WVt=M(()=>{Sf()});function YVt(){for(var e=this._groups,t=-1,r=e.length;++t<r;)for(var n=e[t],i=n.length-1,o=n[i],a;--i>=0;)(a=n[i])&&(o&&a.compareDocumentPosition(o)^4&&o.parentNode.insertBefore(a,o),o=a);return this}var jVt=M(()=>{});function XVt(e){e||(e=o8e);function t(h,f){return h&&f?e(h.__data__,f.__data__):!h-!f}for(var r=this._groups,n=r.length,i=new Array(n),o=0;o<n;++o){for(var a=r[o],s=a.length,l=i[o]=new Array(s),c,u=0;u<s;++u)(c=a[u])&&(l[u]=c);l.sort(t)}return new no(i,this._parents).order()}function o8e(e,t){return e<t?-1:e>t?1:e>=t?0:NaN}var $Vt=M(()=>{Sf()});function KVt(){var e=arguments[0];return arguments[0]=this,e.apply(null,arguments),this}var ZVt=M(()=>{});function JVt(){var e=new Array(this.size()),t=-1;return this.each(function(){e[++t]=this}),e}var QVt=M(()=>{});function tUt(){for(var e=this._groups,t=0,r=e.length;t<r;++t)for(var n=e[t],i=0,o=n.length;i<o;++i){var a=n[i];if(a)return a}return null}var eUt=M(()=>{});function rUt(){var e=0;return this.each(function(){++e}),e}var nUt=M(()=>{});function iUt(){return!this.node()}var oUt=M(()=>{});function aUt(e){for(var t=this._groups,r=0,n=t.length;r<n;++r)for(var i=t[r],o=0,a=i.length,s;o<a;++o)(s=i[o])&&e.call(s,s.__data__,o,i);return this}var sUt=M(()=>{});function a8e(e){return function(){this.removeAttribute(e)}}function s8e(e){return function(){this.removeAttributeNS(e.space,e.local)}}function l8e(e,t){return function(){this.setAttribute(e,t)}}function c8e(e,t){return function(){this.setAttributeNS(e.space,e.local,t)}}function u8e(e,t){return function(){var r=t.apply(this,arguments);r==null?this.removeAttribute(e):this.setAttribute(e,r)}}function h8e(e,t){return function(){var r=t.apply(this,arguments);r==null?this.removeAttributeNS(e.space,e.local):this.setAttributeNS(e.space,e.local,r)}}function lUt(e,t){var r=ld(e);if(arguments.length<2){var n=this.node();return r.local?n.getAttributeNS(r.space,r.local):n.getAttribute(r)}return this.each((t==null?r.local?s8e:a8e:typeof t=="function"?r.local?h8e:u8e:r.local?c8e:l8e)(r,t))}var cUt=M(()=>{ez()});function oz(e){return e.ownerDocument&&e.ownerDocument.defaultView||e.document&&e||e.defaultView}var Ort=M(()=>{});function f8e(e){return function(){this.style.removeProperty(e)}}function p8e(e,t,r){return function(){this.style.setProperty(e,t,r)}}function d8e(e,t,r){return function(){var n=t.apply(this,arguments);n==null?this.style.removeProperty(e):this.style.setProperty(e,n,r)}}function uUt(e,t,r){return arguments.length>1?this.each((t==null?f8e:typeof t=="function"?d8e:p8e)(e,t,r==null?"":r)):Bg(this.node(),e)}function Bg(e,t){return e.style.getPropertyValue(t)||oz(e).getComputedStyle(e,null).getPropertyValue(t)}var zrt=M(()=>{Ort()});function m8e(e){return function(){delete this[e]}}function g8e(e,t){return function(){this[e]=t}}function _8e(e,t){return function(){var r=t.apply(this,arguments);r==null?delete this[e]:this[e]=r}}function hUt(e,t){return arguments.length>1?this.each((t==null?m8e:typeof t=="function"?_8e:g8e)(e,t)):this.node()[e]}var fUt=M(()=>{});function pUt(e){return e.trim().split(/^|\s+/)}function Frt(e){return e.classList||new dUt(e)}function dUt(e){this._node=e,this._names=pUt(e.getAttribute("class")||"")}function mUt(e,t){for(var r=Frt(e),n=-1,i=t.length;++n<i;)r.add(t[n])}function gUt(e,t){for(var r=Frt(e),n=-1,i=t.length;++n<i;)r.remove(t[n])}function y8e(e){return function(){mUt(this,e)}}function v8e(e){return function(){gUt(this,e)}}function x8e(e,t){return function(){(t.apply(this,arguments)?mUt:gUt)(this,e)}}function _Ut(e,t){var r=pUt(e+"");if(arguments.length<2){for(var n=Frt(this.node()),i=-1,o=r.length;++i<o;)if(!n.contains(r[i]))return!1;return!0}return this.each((typeof t=="function"?x8e:t?y8e:v8e)(r,t))}var yUt=M(()=>{dUt.prototype={add:function(e){var t=this._names.indexOf(e);t<0&&(this._names.push(e),this._node.setAttribute("class",this._names.join(" ")))},remove:function(e){var t=this._names.indexOf(e);t>=0&&(this._names.splice(t,1),this._node.setAttribute("class",this._names.join(" ")))},contains:function(e){return this._names.indexOf(e)>=0}}});function b8e(){this.textContent=""}function w8e(e){return function(){this.textContent=e}}function S8e(e){return function(){var t=e.apply(this,arguments);this.textContent=t==null?"":t}}function vUt(e){return arguments.length?this.each(e==null?b8e:(typeof e=="function"?S8e:w8e)(e)):this.node().textContent}var xUt=M(()=>{});function M8e(){this.innerHTML=""}function E8e(e){return function(){this.innerHTML=e}}function T8e(e){return function(){var t=e.apply(this,arguments);this.innerHTML=t==null?"":t}}function bUt(e){return arguments.length?this.each(e==null?M8e:(typeof e=="function"?T8e:E8e)(e)):this.node().innerHTML}var wUt=M(()=>{});function C8e(){this.nextSibling&&this.parentNode.appendChild(this)}function SUt(){return this.each(C8e)}var MUt=M(()=>{});function A8e(){this.previousSibling&&this.parentNode.insertBefore(this,this.parentNode.firstChild)}function EUt(){return this.each(A8e)}var TUt=M(()=>{});function CUt(e){var t=typeof e=="function"?e:rz(e);return this.select(function(){return this.appendChild(t.apply(this,arguments))})}var AUt=M(()=>{Lrt()});function P8e(){return null}function PUt(e,t){var r=typeof e=="function"?e:rz(e),n=t==null?P8e:typeof t=="function"?t:wv(t);return this.select(function(){return this.insertBefore(r.apply(this,arguments),n.apply(this,arguments)||null)})}var IUt=M(()=>{Lrt();nz()});function I8e(){var e=this.parentNode;e&&e.removeChild(this)}function LUt(){return this.each(I8e)}var kUt=M(()=>{});function L8e(){var e=this.cloneNode(!1),t=this.parentNode;return t?t.insertBefore(e,this.nextSibling):e}function k8e(){var e=this.cloneNode(!0),t=this.parentNode;return t?t.insertBefore(e,this.nextSibling):e}function RUt(e){return this.select(e?k8e:L8e)}var NUt=M(()=>{});function DUt(e){return arguments.length?this.property("__data__",e):this.node().__data__}var OUt=M(()=>{});function R8e(e,t,r){return e=BUt(e,t,r),function(n){var i=n.relatedTarget;(!i||i!==this&&!(i.compareDocumentPosition(this)&8))&&e.call(this,n)}}function BUt(e,t,r){return function(n){var i=Brt;Brt=n;try{e.call(this,this.__data__,t,r)}finally{Brt=i}}}function N8e(e){return e.trim().split(/^|\s+/).map(function(t){var r="",n=t.indexOf(".");return n>=0&&(r=t.slice(n+1),t=t.slice(0,n)),{type:t,name:r}})}function D8e(e){return function(){var t=this.__on;if(!!t){for(var r=0,n=-1,i=t.length,o;r<i;++r)o=t[r],(!e.type||o.type===e.type)&&o.name===e.name?this.removeEventListener(o.type,o.listener,o.capture):t[++n]=o;++n?t.length=n:delete this.__on}}}function O8e(e,t,r){var n=FUt.hasOwnProperty(e.type)?R8e:BUt;return function(i,o,a){var s=this.__on,l,c=n(t,o,a);if(s){for(var u=0,h=s.length;u<h;++u)if((l=s[u]).type===e.type&&l.name===e.name){this.removeEventListener(l.type,l.listener,l.capture),this.addEventListener(l.type,l.listener=c,l.capture=r),l.value=t;return}}this.addEventListener(e.type,c,r),l={type:e.type,name:e.name,value:t,listener:c,capture:r},s?s.push(l):this.__on=[l]}}function HUt(e,t,r){var n=N8e(e+""),i,o=n.length,a;if(arguments.length<2){var s=this.node().__on;if(s){for(var l=0,c=s.length,u;l<c;++l)for(i=0,u=s[l];i<o;++i)if((a=n[i]).type===u.type&&a.name===u.name)return u.value}return}for(s=t?O8e:D8e,r==null&&(r=!1),i=0;i<o;++i)this.each(s(n[i],t,r));return this}var FUt,Brt,zUt,VUt=M(()=>{FUt={},Brt=null;typeof document!="undefined"&&(zUt=document.documentElement,"onmouseenter"in zUt||(FUt={mouseenter:"mouseover",mouseleave:"mouseout"}))});function UUt(e,t,r){var n=oz(e),i=n.CustomEvent;typeof i=="function"?i=new i(t,r):(i=n.document.createEvent("Event"),r?(i.initEvent(t,r.bubbles,r.cancelable),i.detail=r.detail):i.initEvent(t,!1,!1)),e.dispatchEvent(i)}function z8e(e,t){return function(){return UUt(this,e,t)}}function F8e(e,t){return function(){return UUt(this,e,t.apply(this,arguments))}}function qUt(e,t){return this.each((typeof t=="function"?F8e:z8e)(e,t))}var GUt=M(()=>{Ort()});function no(e,t){this._groups=e,this._parents=t}function WUt(){return new no([[document.documentElement]],B8e)}var B8e,cd,Sf=M(()=>{PVt();LVt();RVt();BVt();Drt();VVt();qVt();WVt();jVt();$Vt();ZVt();QVt();eUt();nUt();oUt();sUt();cUt();zrt();fUt();yUt();xUt();wUt();MUt();TUt();AUt();IUt();kUt();NUt();OUt();VUt();GUt();B8e=[null];no.prototype=WUt.prototype={constructor:no,select:AVt,selectAll:IVt,filter:kVt,data:FVt,enter:NVt,exit:HVt,join:UVt,merge:GVt,order:YVt,sort:XVt,call:KVt,nodes:JVt,node:tUt,size:rUt,empty:iUt,each:aUt,attr:lUt,style:uUt,property:hUt,classed:_Ut,text:vUt,html:bUt,raise:SUt,lower:EUt,append:CUt,insert:PUt,remove:LUt,clone:RUt,datum:DUt,on:HUt,dispatch:qUt};cd=WUt});var Mf=M(()=>{Rrt();ez();Sf();nz();krt();zrt()});function jUt(){for(var e=0,t=arguments.length,r={},n;e<t;++e){if(!(n=arguments[e]+"")||n in r||/[\s.]/.test(n))throw new Error("illegal type: "+n);r[n]=[]}return new az(r)}function az(e){this._=e}function V8e(e,t){return e.trim().split(/^|\s+/).map(function(r){var n="",i=r.indexOf(".");if(i>=0&&(n=r.slice(i+1),r=r.slice(0,i)),r&&!t.hasOwnProperty(r))throw new Error("unknown type: "+r);return{type:r,name:n}})}function U8e(e,t){for(var r=0,n=e.length,i;r<n;++r)if((i=e[r]).name===t)return i.value}function YUt(e,t,r){for(var n=0,i=e.length;n<i;++n)if(e[n].name===t){e[n]=H8e,e=e.slice(0,n).concat(e.slice(n+1));break}return r!=null&&e.push({name:t,value:r}),e}var H8e,Hrt,XUt=M(()=>{H8e={value:function(){}};az.prototype=jUt.prototype={constructor:az,on:function(e,t){var r=this._,n=V8e(e+"",r),i,o=-1,a=n.length;if(arguments.length<2){for(;++o<a;)if((i=(e=n[o]).type)&&(i=U8e(r[i],e.name)))return i;return}if(t!=null&&typeof t!="function")throw new Error("invalid callback: "+t);for(;++o<a;)if(i=(e=n[o]).type)r[i]=YUt(r[i],e.name,t);else if(t==null)for(i in r)r[i]=YUt(r[i],e.name,null);return this},copy:function(){var e={},t=this._;for(var r in t)e[r]=t[r].slice();return new az(e)},call:function(e,t){if((i=arguments.length-2)>0)for(var r=new Array(i),n=0,i,o;n<i;++n)r[n]=arguments[n+2];if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(o=this._[e],n=0,i=o.length;n<i;++n)o[n].value.apply(t,r)},apply:function(e,t,r){if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(var n=this._[e],i=0,o=n.length;i<o;++i)n[i].value.apply(t,r)}};Hrt=jUt});var $Ut=M(()=>{XUt()});function Xw(){return Sv||(JUt(q8e),Sv=oA.now()+cz)}function q8e(){Sv=0}function aA(){this._call=this._time=this._next=null}function uz(e,t,r){var n=new aA;return n.restart(e,t,r),n}function QUt(){Xw(),++jw;for(var e=sz,t;e;)(t=Sv-e._time)>=0&&e._call.call(null,t),e=e._next;--jw}function KUt(){Sv=(lz=oA.now())+cz,jw=nA=0;try{QUt()}finally{jw=0,W8e(),Sv=0}}function G8e(){var e=oA.now(),t=e-lz;t>ZUt&&(cz-=t,lz=e)}function W8e(){for(var e,t=sz,r,n=1/0;t;)t._call?(n>t._time&&(n=t._time),e=t,t=t._next):(r=t._next,t._next=null,t=e?e._next=r:sz=r);iA=e,Vrt(n)}function Vrt(e){if(!jw){nA&&(nA=clearTimeout(nA));var t=e-Sv;t>24?(e<1/0&&(nA=setTimeout(KUt,e-oA.now()-cz)),rA&&(rA=clearInterval(rA))):(rA||(lz=oA.now(),rA=setInterval(G8e,ZUt)),jw=1,JUt(KUt))}}var jw,nA,rA,ZUt,sz,iA,lz,Sv,cz,oA,JUt,Urt=M(()=>{jw=0,nA=0,rA=0,ZUt=1e3,lz=0,Sv=0,cz=0,oA=typeof performance=="object"&&performance.now?performance:Date,JUt=typeof window=="object"&&window.requestAnimationFrame?window.requestAnimationFrame.bind(window):function(e){setTimeout(e,17)};aA.prototype=uz.prototype={constructor:aA,restart:function(e,t,r){if(typeof e!="function")throw new TypeError("callback is not a function");r=(r==null?Xw():+r)+(t==null?0:+t),!this._next&&iA!==this&&(iA?iA._next=this:sz=this,iA=this),this._call=e,this._time=r,Vrt()},stop:function(){this._call&&(this._call=null,this._time=1/0,Vrt())}}});function hz(e,t,r){var n=new aA;return t=t==null?0:+t,n.restart(function(i){n.stop(),e(i+t)},t,r),n}var tqt=M(()=>{Urt()});var qrt=M(()=>{Urt();tqt()});function Hg(e,t,r,n,i,o){var a=e.__transition;if(!a)e.__transition={};else if(r in a)return;X8e(e,r,{name:t,index:n,group:i,on:Y8e,tween:j8e,time:o.time,delay:o.delay,duration:o.duration,ease:o.ease,timer:null,state:rqt})}function cA(e,t){var r=io(e,t);if(r.state>rqt)throw new Error("too late; already scheduled");return r}function Du(e,t){var r=io(e,t);if(r.state>lA)throw new Error("too late; already started");return r}function io(e,t){var r=e.__transition;if(!r||!(r=r[t]))throw new Error("transition not found");return r}function X8e(e,t,r){var n=e.__transition,i;n[t]=r,r.timer=uz(o,0,r.time);function o(c){r.state=fz,r.timer.restart(a,r.delay,r.time),r.delay<=c&&a(c-r.delay)}function a(c){var u,h,f,p;if(r.state!==fz)return l();for(u in n)if(p=n[u],p.name===r.name){if(p.state===Grt)return hz(a);p.state===eqt?(p.state=sA,p.timer.stop(),p.on.call("interrupt",e,e.__data__,p.index,p.group),delete n[u]):+u<t&&(p.state=sA,p.timer.stop(),delete n[u])}if(hz(function(){r.state===Grt&&(r.state=eqt,r.timer.restart(s,r.delay,r.time),s(c))}),r.state=lA,r.on.call("start",e,e.__data__,r.index,r.group),r.state===lA){for(r.state=Grt,i=new Array(f=r.tween.length),u=0,h=-1;u<f;++u)(p=r.tween[u].value.call(e,e.__data__,r.index,r.group))&&(i[++h]=p);i.length=h+1}}function s(c){for(var u=c<r.duration?r.ease.call(null,c/r.duration):(r.timer.restart(l),r.state=pz,1),h=-1,f=i.length;++h<f;)i[h].call(null,u);r.state===pz&&(r.on.call("end",e,e.__data__,r.index,r.group),l())}function l(){r.state=sA,r.timer.stop(),delete n[t];for(var c in n)return;delete e.__transition}}var Y8e,j8e,rqt,fz,lA,Grt,eqt,pz,sA,Ac=M(()=>{$Ut();qrt();Y8e=Hrt("start","end","interrupt"),j8e=[],rqt=0,fz=1,lA=2,Grt=3,eqt=4,pz=5,sA=6});function dz(e,t){var r=e.__transition,n,i,o=!0,a;if(!!r){t=t==null?null:t+"";for(a in r){if((n=r[a]).name!==t){o=!1;continue}i=n.state>lA&&n.state<pz,n.state=sA,n.timer.stop(),i&&n.on.call("interrupt",e,e.__data__,n.index,n.group),delete r[a]}o&&delete e.__transition}}var Wrt=M(()=>{Ac()});function nqt(e){return this.each(function(){dz(this,e)})}var iqt=M(()=>{Wrt()});function mz(e,t,r){e.prototype=t.prototype=r,r.constructor=e}function Yrt(e,t){var r=Object.create(e.prototype);for(var n in t)r[n]=t[n];return r}var oqt=M(()=>{});function fA(){}function sqt(){return this.rgb().formatHex()}function rRe(){return pqt(this).formatHsl()}function lqt(){return this.rgb().formatRgb()}function Vg(e){var t,r;return e=(e+"").trim().toLowerCase(),(t=$8e.exec(e))?(r=t[1].length,t=parseInt(t[1],16),r===6?cqt(t):r===3?new ml(t>>8&15|t>>4&240,t>>4&15|t&240,(t&15)<<4|t&15,1):r===8?gz(t>>24&255,t>>16&255,t>>8&255,(t&255)/255):r===4?gz(t>>12&15|t>>8&240,t>>8&15|t>>4&240,t>>4&15|t&240,((t&15)<<4|t&15)/255):null):(t=K8e.exec(e))?new ml(t[1],t[2],t[3],1):(t=Z8e.exec(e))?new ml(t[1]*255/100,t[2]*255/100,t[3]*255/100,1):(t=J8e.exec(e))?gz(t[1],t[2],t[3],t[4]):(t=Q8e.exec(e))?gz(t[1]*255/100,t[2]*255/100,t[3]*255/100,t[4]):(t=tRe.exec(e))?fqt(t[1],t[2]/100,t[3]/100,1):(t=eRe.exec(e))?fqt(t[1],t[2]/100,t[3]/100,t[4]):aqt.hasOwnProperty(e)?cqt(aqt[e]):e==="transparent"?new ml(NaN,NaN,NaN,0):null}function cqt(e){return new ml(e>>16&255,e>>8&255,e&255,1)}function gz(e,t,r,n){return n<=0&&(e=t=r=NaN),new ml(e,t,r,n)}function nRe(e){return e instanceof fA||(e=Vg(e)),e?(e=e.rgb(),new ml(e.r,e.g,e.b,e.opacity)):new ml}function Kw(e,t,r,n){return arguments.length===1?nRe(e):new ml(e,t,r,n==null?1:n)}function ml(e,t,r,n){this.r=+e,this.g=+t,this.b=+r,this.opacity=+n}function uqt(){return"#"+jrt(this.r)+jrt(this.g)+jrt(this.b)}function hqt(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"rgb(":"rgba(")+Math.max(0,Math.min(255,Math.round(this.r)||0))+", "+Math.max(0,Math.min(255,Math.round(this.g)||0))+", "+Math.max(0,Math.min(255,Math.round(this.b)||0))+(e===1?")":", "+e+")")}function jrt(e){return e=Math.max(0,Math.min(255,Math.round(e)||0)),(e<16?"0":"")+e.toString(16)}function fqt(e,t,r,n){return n<=0?e=t=r=NaN:r<=0||r>=1?e=t=NaN:t<=0&&(e=NaN),new Ef(e,t,r,n)}function pqt(e){if(e instanceof Ef)return new Ef(e.h,e.s,e.l,e.opacity);if(e instanceof fA||(e=Vg(e)),!e)return new Ef;if(e instanceof Ef)return e;e=e.rgb();var t=e.r/255,r=e.g/255,n=e.b/255,i=Math.min(t,r,n),o=Math.max(t,r,n),a=NaN,s=o-i,l=(o+i)/2;return s?(t===o?a=(r-n)/s+(r<n)*6:r===o?a=(n-t)/s+2:a=(t-r)/s+4,s/=l<.5?o+i:2-o-i,a*=60):s=l>0&&l<1?0:a,new Ef(a,s,l,e.opacity)}function dqt(e,t,r,n){return arguments.length===1?pqt(e):new Ef(e,t,r,n==null?1:n)}function Ef(e,t,r,n){this.h=+e,this.s=+t,this.l=+r,this.opacity=+n}function Xrt(e,t,r){return(e<60?t+(r-t)*e/60:e<180?r:e<240?t+(r-t)*(240-e)/60:t)*255}var uA,_z,$w,hA,Tf,$8e,K8e,Z8e,J8e,Q8e,tRe,eRe,aqt,mqt=M(()=>{oqt();uA=.7,_z=1/uA,$w="\\s*([+-]?\\d+)\\s*",hA="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",Tf="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",$8e=/^#([0-9a-f]{3,8})$/,K8e=new RegExp("^rgb\\("+[$w,$w,$w]+"\\)$"),Z8e=new RegExp("^rgb\\("+[Tf,Tf,Tf]+"\\)$"),J8e=new RegExp("^rgba\\("+[$w,$w,$w,hA]+"\\)$"),Q8e=new RegExp("^rgba\\("+[Tf,Tf,Tf,hA]+"\\)$"),tRe=new RegExp("^hsl\\("+[hA,Tf,Tf]+"\\)$"),eRe=new RegExp("^hsla\\("+[hA,Tf,Tf,hA]+"\\)$"),aqt={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};mz(fA,Vg,{copy:function(e){return Object.assign(new this.constructor,this,e)},displayable:function(){return this.rgb().displayable()},hex:sqt,formatHex:sqt,formatHsl:rRe,formatRgb:lqt,toString:lqt});mz(ml,Kw,Yrt(fA,{brighter:function(e){return e=e==null?_z:Math.pow(_z,e),new ml(this.r*e,this.g*e,this.b*e,this.opacity)},darker:function(e){return e=e==null?uA:Math.pow(uA,e),new ml(this.r*e,this.g*e,this.b*e,this.opacity)},rgb:function(){return this},displayable:function(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:uqt,formatHex:uqt,formatRgb:hqt,toString:hqt}));mz(Ef,dqt,Yrt(fA,{brighter:function(e){return e=e==null?_z:Math.pow(_z,e),new Ef(this.h,this.s,this.l*e,this.opacity)},darker:function(e){return e=e==null?uA:Math.pow(uA,e),new Ef(this.h,this.s,this.l*e,this.opacity)},rgb:function(){var e=this.h%360+(this.h<0)*360,t=isNaN(e)||isNaN(this.s)?0:this.s,r=this.l,n=r+(r<.5?r:1-r)*t,i=2*r-n;return new ml(Xrt(e>=240?e-240:e+120,i,n),Xrt(e,i,n),Xrt(e<120?e+240:e-120,i,n),this.opacity)},displayable:function(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl:function(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"hsl(":"hsla(")+(this.h||0)+", "+(this.s||0)*100+"%, "+(this.l||0)*100+"%"+(e===1?")":", "+e+")")}}))});var $rt=M(()=>{mqt()});function Krt(e,t,r,n,i){var o=e*e,a=o*e;return((1-3*e+3*o-a)*t+(4-6*o+3*a)*r+(1+3*e+3*o-3*a)*n+a*i)/6}function gqt(e){var t=e.length-1;return function(r){var n=r<=0?r=0:r>=1?(r=1,t-1):Math.floor(r*t),i=e[n],o=e[n+1],a=n>0?e[n-1]:2*i-o,s=n<t-1?e[n+2]:2*o-i;return Krt((r-n/t)*t,a,i,o,s)}}var Zrt=M(()=>{});function _qt(e){var t=e.length;return function(r){var n=Math.floor(((r%=1)<0?++r:r)*t),i=e[(n+t-1)%t],o=e[n%t],a=e[(n+1)%t],s=e[(n+2)%t];return Krt((r-n/t)*t,i,o,a,s)}}var yqt=M(()=>{Zrt()});function Jrt(e){return function(){return e}}var vqt=M(()=>{});function iRe(e,t){return function(r){return e+r*t}}function oRe(e,t,r){return e=Math.pow(e,r),t=Math.pow(t,r)-e,r=1/r,function(n){return Math.pow(e+n*t,r)}}function xqt(e){return(e=+e)==1?yz:function(t,r){return r-t?oRe(t,r,e):Jrt(isNaN(t)?r:t)}}function yz(e,t){var r=t-e;return r?iRe(e,r):Jrt(isNaN(e)?t:e)}var bqt=M(()=>{vqt()});function wqt(e){return function(t){var r=t.length,n=new Array(r),i=new Array(r),o=new Array(r),a,s;for(a=0;a<r;++a)s=Kw(t[a]),n[a]=s.r||0,i[a]=s.g||0,o[a]=s.b||0;return n=e(n),i=e(i),o=e(o),s.opacity=1,function(l){return s.r=n(l),s.g=i(l),s.b=o(l),s+""}}}var vz,aRe,sRe,Sqt=M(()=>{$rt();Zrt();yqt();bqt();vz=function e(t){var r=xqt(t);function n(i,o){var a=r((i=Kw(i)).r,(o=Kw(o)).r),s=r(i.g,o.g),l=r(i.b,o.b),c=yz(i.opacity,o.opacity);return function(u){return i.r=a(u),i.g=s(u),i.b=l(u),i.opacity=c(u),i+""}}return n.gamma=e,n}(1);aRe=wqt(gqt),sRe=wqt(_qt)});function Pc(e,t){return e=+e,t=+t,function(r){return e*(1-r)+t*r}}var xz=M(()=>{});function lRe(e){return function(){return e}}function cRe(e){return function(t){return e(t)+""}}function ent(e,t){var r=tnt.lastIndex=Qrt.lastIndex=0,n,i,o,a=-1,s=[],l=[];for(e=e+"",t=t+"";(n=tnt.exec(e))&&(i=Qrt.exec(t));)(o=i.index)>r&&(o=t.slice(r,o),s[a]?s[a]+=o:s[++a]=o),(n=n[0])===(i=i[0])?s[a]?s[a]+=i:s[++a]=i:(s[++a]=null,l.push({i:a,x:Pc(n,i)})),r=Qrt.lastIndex;return r<t.length&&(o=t.slice(r),s[a]?s[a]+=o:s[++a]=o),s.length<2?l[0]?cRe(l[0].x):lRe(t):(t=l.length,function(c){for(var u=0,h;u<t;++u)s[(h=l[u]).i]=h.x(c);return s.join("")})}var tnt,Qrt,Mqt=M(()=>{xz();tnt=/[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,Qrt=new RegExp(tnt.source,"g")});function rnt(e,t,r,n,i,o){var a,s,l;return(a=Math.sqrt(e*e+t*t))&&(e/=a,t/=a),(l=e*r+t*n)&&(r-=e*l,n-=t*l),(s=Math.sqrt(r*r+n*n))&&(r/=s,n/=s,l/=s),e*n<t*r&&(e=-e,t=-t,l=-l,a=-a),{translateX:i,translateY:o,rotate:Math.atan2(t,e)*Eqt,skewX:Math.atan(l)*Eqt,scaleX:a,scaleY:s}}var Eqt,bz,Tqt=M(()=>{Eqt=180/Math.PI,bz={translateX:0,translateY:0,rotate:0,skewX:0,scaleX:1,scaleY:1}});function Aqt(e){return e==="none"?bz:(pA||(pA=document.createElement("DIV"),nnt=document.documentElement,Cqt=document.defaultView),pA.style.transform=e,e=Cqt.getComputedStyle(nnt.appendChild(pA),null).getPropertyValue("transform"),nnt.removeChild(pA),e=e.slice(7,-1).split(","),rnt(+e[0],+e[1],+e[2],+e[3],+e[4],+e[5]))}function Pqt(e){return e==null?bz:(wz||(wz=document.createElementNS("http://www.w3.org/2000/svg","g")),wz.setAttribute("transform",e),(e=wz.transform.baseVal.consolidate())?(e=e.matrix,rnt(e.a,e.b,e.c,e.d,e.e,e.f)):bz)}var pA,nnt,Cqt,wz,Iqt=M(()=>{Tqt()});function Lqt(e,t,r,n){function i(c){return c.length?c.pop()+" ":""}function o(c,u,h,f,p,d){if(c!==h||u!==f){var g=p.push("translate(",null,t,null,r);d.push({i:g-4,x:Pc(c,h)},{i:g-2,x:Pc(u,f)})}else(h||f)&&p.push("translate("+h+t+f+r)}function a(c,u,h,f){c!==u?(c-u>180?u+=360:u-c>180&&(c+=360),f.push({i:h.push(i(h)+"rotate(",null,n)-2,x:Pc(c,u)})):u&&h.push(i(h)+"rotate("+u+n)}function s(c,u,h,f){c!==u?f.push({i:h.push(i(h)+"skewX(",null,n)-2,x:Pc(c,u)}):u&&h.push(i(h)+"skewX("+u+n)}function l(c,u,h,f,p,d){if(c!==h||u!==f){var g=p.push(i(p)+"scale(",null,",",null,")");d.push({i:g-4,x:Pc(c,h)},{i:g-2,x:Pc(u,f)})}else(h!==1||f!==1)&&p.push(i(p)+"scale("+h+","+f+")")}return function(c,u){var h=[],f=[];return c=e(c),u=e(u),o(c.translateX,c.translateY,u.translateX,u.translateY,h,f),a(c.rotate,u.rotate,h,f),s(c.skewX,u.skewX,h,f),l(c.scaleX,c.scaleY,u.scaleX,u.scaleY,h,f),c=u=null,function(p){for(var d=-1,g=f.length,_;++d<g;)h[(_=f[d]).i]=_.x(p);return h.join("")}}}var int,ont,kqt=M(()=>{xz();Iqt();int=Lqt(Aqt,"px, ","px)","deg)"),ont=Lqt(Pqt,", ",")",")")});var Sz=M(()=>{xz();Mqt();kqt();Sqt()});function uRe(e,t){var r,n;return function(){var i=Du(this,e),o=i.tween;if(o!==r){n=r=o;for(var a=0,s=n.length;a<s;++a)if(n[a].name===t){n=n.slice(),n.splice(a,1);break}}i.tween=n}}function hRe(e,t,r){var n,i;if(typeof r!="function")throw new Error;return function(){var o=Du(this,e),a=o.tween;if(a!==n){i=(n=a).slice();for(var s={name:t,value:r},l=0,c=i.length;l<c;++l)if(i[l].name===t){i[l]=s;break}l===c&&i.push(s)}o.tween=i}}function Rqt(e,t){var r=this._id;if(e+="",arguments.length<2){for(var n=io(this.node(),r).tween,i=0,o=n.length,a;i<o;++i)if((a=n[i]).name===e)return a.value;return null}return this.each((t==null?uRe:hRe)(r,e,t))}function Zw(e,t,r){var n=e._id;return e.each(function(){var i=Du(this,n);(i.value||(i.value={}))[t]=r.apply(this,arguments)}),function(i){return io(i,n).value[t]}}var dA=M(()=>{Ac()});function Mz(e,t){var r;return(typeof t=="number"?Pc:t instanceof Vg?vz:(r=Vg(t))?(t=r,vz):ent)(e,t)}var ant=M(()=>{$rt();Sz()});function fRe(e){return function(){this.removeAttribute(e)}}function pRe(e){return function(){this.removeAttributeNS(e.space,e.local)}}function dRe(e,t,r){var n,i;return function(){var o=this.getAttribute(e);return o===r?null:o===n?i:i=t(n=o,r)}}function mRe(e,t,r){var n,i;return function(){var o=this.getAttributeNS(e.space,e.local);return o===r?null:o===n?i:i=t(n=o,r)}}function gRe(e,t,r){var n,i,o;return function(){var a,s=r(this);return s==null?void this.removeAttribute(e):(a=this.getAttribute(e),a===s?null:a===n&&s===i?o:o=t(n=a,i=s))}}function _Re(e,t,r){var n,i,o;return function(){var a,s=r(this);return s==null?void this.removeAttributeNS(e.space,e.local):(a=this.getAttributeNS(e.space,e.local),a===s?null:a===n&&s===i?o:o=t(n=a,i=s))}}function Nqt(e,t){var r=ld(e),n=r==="transform"?ont:Mz;return this.attrTween(e,typeof t=="function"?(r.local?_Re:gRe)(r,n,Zw(this,"attr."+e,t)):t==null?(r.local?pRe:fRe)(r):(r.local?mRe:dRe)(r,n,t+""))}var Dqt=M(()=>{Sz();Mf();dA();ant()});function yRe(e,t){function r(){var n=this,i=t.apply(n,arguments);return i&&function(o){n.setAttributeNS(e.space,e.local,i(o))}}return r._value=t,r}function vRe(e,t){function r(){var n=this,i=t.apply(n,arguments);return i&&function(o){n.setAttribute(e,i(o))}}return r._value=t,r}function Oqt(e,t){var r="attr."+e;if(arguments.length<2)return(r=this.tween(r))&&r._value;if(t==null)return this.tween(r,null);if(typeof t!="function")throw new Error;var n=ld(e);return this.tween(r,(n.local?yRe:vRe)(n,t))}var zqt=M(()=>{Mf()});function xRe(e,t){return function(){cA(this,e).delay=+t.apply(this,arguments)}}function bRe(e,t){return t=+t,function(){cA(this,e).delay=t}}function Fqt(e){var t=this._id;return arguments.length?this.each((typeof e=="function"?xRe:bRe)(t,e)):io(this.node(),t).delay}var Bqt=M(()=>{Ac()});function wRe(e,t){return function(){Du(this,e).duration=+t.apply(this,arguments)}}function SRe(e,t){return t=+t,function(){Du(this,e).duration=t}}function Hqt(e){var t=this._id;return arguments.length?this.each((typeof e=="function"?wRe:SRe)(t,e)):io(this.node(),t).duration}var Vqt=M(()=>{Ac()});function MRe(e,t){if(typeof t!="function")throw new Error;return function(){Du(this,e).ease=t}}function Uqt(e){var t=this._id;return arguments.length?this.each(MRe(t,e)):io(this.node(),t).ease}var qqt=M(()=>{Ac()});function Gqt(e){typeof e!="function"&&(e=tA(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=[],l,c=0;c<a;++c)(l=o[c])&&e.call(l,l.__data__,c,o)&&s.push(l);return new Uo(n,this._parents,this._name,this._id)}var Wqt=M(()=>{Mf();ud()});function Yqt(e){if(e._id!==this._id)throw new Error;for(var t=this._groups,r=e._groups,n=t.length,i=r.length,o=Math.min(n,i),a=new Array(n),s=0;s<o;++s)for(var l=t[s],c=r[s],u=l.length,h=a[s]=new Array(u),f,p=0;p<u;++p)(f=l[p]||c[p])&&(h[p]=f);for(;s<n;++s)a[s]=t[s];return new Uo(a,this._parents,this._name,this._id)}var jqt=M(()=>{ud()});function ERe(e){return(e+"").trim().split(/^|\s+/).every(function(t){var r=t.indexOf(".");return r>=0&&(t=t.slice(0,r)),!t||t==="start"})}function TRe(e,t,r){var n,i,o=ERe(t)?cA:Du;return function(){var a=o(this,e),s=a.on;s!==n&&(i=(n=s).copy()).on(t,r),a.on=i}}function Xqt(e,t){var r=this._id;return arguments.length<2?io(this.node(),r).on.on(e):this.each(TRe(r,e,t))}var $qt=M(()=>{Ac()});function CRe(e){return function(){var t=this.parentNode;for(var r in this.__transition)if(+r!==e)return;t&&t.removeChild(this)}}function Kqt(){return this.on("end.remove",CRe(this._id))}var Zqt=M(()=>{});function Jqt(e){var t=this._name,r=this._id;typeof e!="function"&&(e=wv(e));for(var n=this._groups,i=n.length,o=new Array(i),a=0;a<i;++a)for(var s=n[a],l=s.length,c=o[a]=new Array(l),u,h,f=0;f<l;++f)(u=s[f])&&(h=e.call(u,u.__data__,f,s))&&("__data__"in u&&(h.__data__=u.__data__),c[f]=h,Hg(c[f],t,r,f,c,io(u,r)));return new Uo(o,this._parents,t,r)}var Qqt=M(()=>{Mf();ud();Ac()});function tGt(e){var t=this._name,r=this._id;typeof e!="function"&&(e=QC(e));for(var n=this._groups,i=n.length,o=[],a=[],s=0;s<i;++s)for(var l=n[s],c=l.length,u,h=0;h<c;++h)if(u=l[h]){for(var f=e.call(u,u.__data__,h,l),p,d=io(u,r),g=0,_=f.length;g<_;++g)(p=f[g])&&Hg(p,t,r,g,f,d);o.push(f),a.push(u)}return new Uo(o,a,t,r)}var eGt=M(()=>{Mf();ud();Ac()});function rGt(){return new ARe(this._groups,this._parents)}var ARe,nGt=M(()=>{Mf();ARe=cd.prototype.constructor});function PRe(e,t){var r,n,i;return function(){var o=Bg(this,e),a=(this.style.removeProperty(e),Bg(this,e));return o===a?null:o===r&&a===n?i:i=t(r=o,n=a)}}function IRe(e){return function(){this.style.removeProperty(e)}}function LRe(e,t,r){var n,i;return function(){var o=Bg(this,e);return o===r?null:o===n?i:i=t(n=o,r)}}function kRe(e,t,r){var n,i,o;return function(){var a=Bg(this,e),s=r(this);return s==null&&(s=(this.style.removeProperty(e),Bg(this,e))),a===s?null:a===n&&s===i?o:o=t(n=a,i=s)}}function iGt(e,t,r){var n=(e+="")=="transform"?int:Mz;return t==null?this.styleTween(e,PRe(e,n)).on("end.style."+e,IRe(e)):this.styleTween(e,typeof t=="function"?kRe(e,n,Zw(this,"style."+e,t)):LRe(e,n,t+""),r)}var oGt=M(()=>{Sz();Mf();dA();ant()});function RRe(e,t,r){function n(){var i=this,o=t.apply(i,arguments);return o&&function(a){i.style.setProperty(e,o(a),r)}}return n._value=t,n}function aGt(e,t,r){var n="style."+(e+="");if(arguments.length<2)return(n=this.tween(n))&&n._value;if(t==null)return this.tween(n,null);if(typeof t!="function")throw new Error;return this.tween(n,RRe(e,t,r==null?"":r))}var sGt=M(()=>{});function NRe(e){return function(){this.textContent=e}}function DRe(e){return function(){var t=e(this);this.textContent=t==null?"":t}}function lGt(e){return this.tween("text",typeof e=="function"?DRe(Zw(this,"text",e)):NRe(e==null?"":e+""))}var cGt=M(()=>{dA()});function uGt(){for(var e=this._name,t=this._id,r=Ez(),n=this._groups,i=n.length,o=0;o<i;++o)for(var a=n[o],s=a.length,l,c=0;c<s;++c)if(l=a[c]){var u=io(l,t);Hg(l,e,r,c,a,{time:u.time+u.delay+u.duration,delay:0,duration:u.duration,ease:u.ease})}return new Uo(n,this._parents,e,r)}var hGt=M(()=>{ud();Ac()});function Uo(e,t,r,n){this._groups=e,this._parents=t,this._name=r,this._id=n}function Tz(e){return cd().transition(e)}function Ez(){return++ORe}var ORe,Jw,ud=M(()=>{Mf();Dqt();zqt();Bqt();Vqt();qqt();Wqt();jqt();$qt();Zqt();Qqt();eGt();nGt();oGt();sGt();cGt();hGt();dA();ORe=0;Jw=cd.prototype;Uo.prototype=Tz.prototype={constructor:Uo,select:Jqt,selectAll:tGt,filter:Gqt,merge:Yqt,selection:rGt,transition:uGt,call:Jw.call,nodes:Jw.nodes,node:Jw.node,size:Jw.size,empty:Jw.empty,each:Jw.each,on:Xqt,attr:Nqt,attrTween:Oqt,style:iGt,styleTween:aGt,text:lGt,remove:Kqt,tween:Rqt,delay:Fqt,duration:Hqt,ease:Uqt}});function zRe(e,t){for(var r;!(r=e.__transition)||!(r=r[t]);)if(!(e=e.parentNode))return snt.time=Xw(),snt;return r}function fGt(e){var t,r;e instanceof Uo?(t=e._id,e=e._name):(t=Ez(),(r=snt).time=Xw(),e=e==null?null:e+"");for(var n=this._groups,i=n.length,o=0;o<i;++o)for(var a=n[o],s=a.length,l,c=0;c<s;++c)(l=a[c])&&Hg(l,e,t,c,a,r||zRe(l,t));return new Uo(n,this._parents,e,t)}var snt,pGt=M(()=>{ud();Ac();I_();qrt();snt={time:null,delay:0,duration:250,ease:xs}});var dGt=M(()=>{Mf();iqt();pGt();cd.prototype.interrupt=nqt;cd.prototype.transition=fGt});function mGt(e,t){var r=e.__transition,n,i;if(r){t=t==null?null:t+"";for(i in r)if((n=r[i]).state>fz&&n.name===t)return new Uo([[e]],FRe,t,+i)}return null}var FRe,gGt=M(()=>{ud();Ac();FRe=[null]});var _Gt=M(()=>{dGt();ud();gGt();Wrt()});function lnt(e){return function(){return e}}var yGt=M(()=>{});function vGt(e){return e[0]}function xGt(e){return e[1]}var bGt=M(()=>{});function cnt(){this._=null}function Qw(e){e.U=e.C=e.L=e.R=e.P=e.N=null}function mA(e,t){var r=t,n=t.R,i=r.U;i?i.L===r?i.L=n:i.R=n:e._=n,n.U=i,r.U=n,r.R=n.L,r.R&&(r.R.U=r),n.L=r}function gA(e,t){var r=t,n=t.L,i=r.U;i?i.L===r?i.L=n:i.R=n:e._=n,n.U=i,r.U=n,r.L=n.R,r.L&&(r.L.U=r),n.R=r}function wGt(e){for(;e.L;)e=e.L;return e}var unt,Cz=M(()=>{cnt.prototype={constructor:cnt,insert:function(e,t){var r,n,i;if(e){if(t.P=e,t.N=e.N,e.N&&(e.N.P=t),e.N=t,e.R){for(e=e.R;e.L;)e=e.L;e.L=t}else e.R=t;r=e}else this._?(e=wGt(this._),t.P=null,t.N=e,e.P=e.L=t,r=e):(t.P=t.N=null,this._=t,r=null);for(t.L=t.R=null,t.U=r,t.C=!0,e=t;r&&r.C;)n=r.U,r===n.L?(i=n.R,i&&i.C?(r.C=i.C=!1,n.C=!0,e=n):(e===r.R&&(mA(this,r),e=r,r=e.U),r.C=!1,n.C=!0,gA(this,n))):(i=n.L,i&&i.C?(r.C=i.C=!1,n.C=!0,e=n):(e===r.L&&(gA(this,r),e=r,r=e.U),r.C=!1,n.C=!0,mA(this,n))),r=e.U;this._.C=!1},remove:function(e){e.N&&(e.N.P=e.P),e.P&&(e.P.N=e.N),e.N=e.P=null;var t=e.U,r,n=e.L,i=e.R,o,a;if(n?i?o=wGt(i):o=n:o=i,t?t.L===e?t.L=o:t.R=o:this._=o,n&&i?(a=o.C,o.C=e.C,o.L=n,n.U=o,o!==i?(t=o.U,o.U=e.U,e=o.R,t.L=e,o.R=i,i.U=o):(o.U=t,t=o,e=o.R)):(a=e.C,e=o),e&&(e.U=t),!a){if(e&&e.C){e.C=!1;return}do{if(e===this._)break;if(e===t.L){if(r=t.R,r.C&&(r.C=!1,t.C=!0,mA(this,t),r=t.R),r.L&&r.L.C||r.R&&r.R.C){(!r.R||!r.R.C)&&(r.L.C=!1,r.C=!0,gA(this,r),r=t.R),r.C=t.C,t.C=r.R.C=!1,mA(this,t),e=this._;break}}else if(r=t.L,r.C&&(r.C=!1,t.C=!0,gA(this,t),r=t.L),r.L&&r.L.C||r.R&&r.R.C){(!r.L||!r.L.C)&&(r.R.C=!1,r.C=!0,mA(this,r),r=t.L),r.C=t.C,t.C=r.L.C=!1,gA(this,t),e=this._;break}r.C=!0,e=t,t=t.U}while(!e.C);e&&(e.C=!1)}}};unt=cnt});function tS(e,t,r,n){var i=[null,null],o=Ao.push(i)-1;return i.left=e,i.right=t,r&&_A(i,e,t,r),n&&_A(i,t,e,n),Za[e.index].halfedges.push(o),Za[t.index].halfedges.push(o),i}function eS(e,t,r){var n=[t,r];return n.left=e,n}function _A(e,t,r,n){!e[0]&&!e[1]?(e[0]=n,e.left=t,e.right=r):e.left===r?e[1]=n:e[0]=n}function BRe(e,t,r,n,i){var o=e[0],a=e[1],s=o[0],l=o[1],c=a[0],u=a[1],h=0,f=1,p=c-s,d=u-l,g;if(g=t-s,!(!p&&g>0)){if(g/=p,p<0){if(g<h)return;g<f&&(f=g)}else if(p>0){if(g>f)return;g>h&&(h=g)}if(g=n-s,!(!p&&g<0)){if(g/=p,p<0){if(g>f)return;g>h&&(h=g)}else if(p>0){if(g<h)return;g<f&&(f=g)}if(g=r-l,!(!d&&g>0)){if(g/=d,d<0){if(g<h)return;g<f&&(f=g)}else if(d>0){if(g>f)return;g>h&&(h=g)}if(g=i-l,!(!d&&g<0)){if(g/=d,d<0){if(g>f)return;g>h&&(h=g)}else if(d>0){if(g<h)return;g<f&&(f=g)}return!(h>0)&&!(f<1)||(h>0&&(e[0]=[s+h*p,l+h*d]),f<1&&(e[1]=[s+f*p,l+f*d])),!0}}}}}function HRe(e,t,r,n,i){var o=e[1];if(o)return!0;var a=e[0],s=e.left,l=e.right,c=s[0],u=s[1],h=l[0],f=l[1],p=(c+h)/2,d=(u+f)/2,g,_;if(f===u){if(p<t||p>=n)return;if(c>h){if(!a)a=[p,r];else if(a[1]>=i)return;o=[p,i]}else{if(!a)a=[p,i];else if(a[1]<r)return;o=[p,r]}}else if(g=(c-h)/(f-u),_=d-g*p,g<-1||g>1)if(c>h){if(!a)a=[(r-_)/g,r];else if(a[1]>=i)return;o=[(i-_)/g,i]}else{if(!a)a=[(i-_)/g,i];else if(a[1]<r)return;o=[(r-_)/g,r]}else if(u<f){if(!a)a=[t,g*t+_];else if(a[0]>=n)return;o=[n,g*n+_]}else{if(!a)a=[n,g*n+_];else if(a[0]<t)return;o=[t,g*t+_]}return e[0]=a,e[1]=o,!0}function SGt(e,t,r,n){for(var i=Ao.length,o;i--;)(!HRe(o=Ao[i],e,t,r,n)||!BRe(o,e,t,r,n)||!(Math.abs(o[0][0]-o[1][0])>Wr||Math.abs(o[0][1]-o[1][1])>Wr))&&delete Ao[i]}var Az=M(()=>{rS()});function MGt(e){return Za[e.index]={site:e,halfedges:[]}}function VRe(e,t){var r=e.site,n=t.left,i=t.right;return r===i&&(i=n,n=r),i?Math.atan2(i[1]-n[1],i[0]-n[0]):(r===n?(n=t[1],i=t[0]):(n=t[0],i=t[1]),Math.atan2(n[0]-i[0],i[1]-n[1]))}function hnt(e,t){return t[+(t.left!==e.site)]}function URe(e,t){return t[+(t.left===e.site)]}function EGt(){for(var e=0,t=Za.length,r,n,i,o;e<t;++e)if((r=Za[e])&&(o=(n=r.halfedges).length)){var a=new Array(o),s=new Array(o);for(i=0;i<o;++i)a[i]=i,s[i]=VRe(r,Ao[n[i]]);for(a.sort(function(l,c){return s[c]-s[l]}),i=0;i<o;++i)s[i]=n[a[i]];for(i=0;i<o;++i)n[i]=s[i]}}function TGt(e,t,r,n){var i=Za.length,o,a,s,l,c,u,h,f,p,d,g,_,y=!0;for(o=0;o<i;++o)if(a=Za[o]){for(s=a.site,c=a.halfedges,l=c.length;l--;)Ao[c[l]]||c.splice(l,1);for(l=0,u=c.length;l<u;)d=URe(a,Ao[c[l]]),g=d[0],_=d[1],h=hnt(a,Ao[c[++l%u]]),f=h[0],p=h[1],(Math.abs(g-f)>Wr||Math.abs(_-p)>Wr)&&(c.splice(l,0,Ao.push(eS(s,d,Math.abs(g-e)<Wr&&n-_>Wr?[e,Math.abs(f-e)<Wr?p:n]:Math.abs(_-n)<Wr&&r-g>Wr?[Math.abs(p-n)<Wr?f:r,n]:Math.abs(g-r)<Wr&&_-t>Wr?[r,Math.abs(f-r)<Wr?p:t]:Math.abs(_-t)<Wr&&g-e>Wr?[Math.abs(p-t)<Wr?f:e,t]:null))-1),++u);u&&(y=!1)}if(y){var x,b,S,C=1/0;for(o=0,y=null;o<i;++o)(a=Za[o])&&(s=a.site,x=s[0]-e,b=s[1]-t,S=x*x+b*b,S<C&&(C=S,y=a));if(y){var P=[e,t],k=[e,n],O=[r,n],D=[r,t];y.halfedges.push(Ao.push(eS(s=y.site,P,k))-1,Ao.push(eS(s,k,O))-1,Ao.push(eS(s,O,D))-1,Ao.push(eS(s,D,P))-1)}}for(o=0;o<i;++o)(a=Za[o])&&(a.halfedges.length||delete Za[o])}var fnt=M(()=>{Az();rS()});function qRe(){Qw(this),this.x=this.y=this.arc=this.site=this.cy=null}function Mv(e){var t=e.P,r=e.N;if(!(!t||!r)){var n=t.site,i=e.site,o=r.site;if(n!==o){var a=i[0],s=i[1],l=n[0]-a,c=n[1]-s,u=o[0]-a,h=o[1]-s,f=2*(l*h-c*u);if(!(f>=-AGt)){var p=l*l+c*c,d=u*u+h*h,g=(h*p-c*d)/f,_=(l*d-u*p)/f,y=CGt.pop()||new qRe;y.arc=e,y.site=i,y.x=g+a,y.y=(y.cy=_+s)+Math.sqrt(g*g+_*_),e.circle=y;for(var x=null,b=nS._;b;)if(y.y<b.y||y.y===b.y&&y.x<=b.x)if(b.L)b=b.L;else{x=b.P;break}else if(b.R)b=b.R;else{x=b;break}nS.insert(x,y),x||(Pz=y)}}}}function Ev(e){var t=e.circle;t&&(t.P||(Pz=t.N),nS.remove(t),CGt.push(t),Qw(t),e.circle=null)}var CGt,Pz,pnt=M(()=>{Cz();rS();CGt=[]});function GRe(){Qw(this),this.edge=this.site=this.circle=null}function PGt(e){var t=IGt.pop()||new GRe;return t.site=e,t}function dnt(e){Ev(e),Tv.remove(e),IGt.push(e),Qw(e)}function LGt(e){var t=e.circle,r=t.x,n=t.cy,i=[r,n],o=e.P,a=e.N,s=[e];dnt(e);for(var l=o;l.circle&&Math.abs(r-l.circle.x)<Wr&&Math.abs(n-l.circle.cy)<Wr;)o=l.P,s.unshift(l),dnt(l),l=o;s.unshift(l),Ev(l);for(var c=a;c.circle&&Math.abs(r-c.circle.x)<Wr&&Math.abs(n-c.circle.cy)<Wr;)a=c.N,s.push(c),dnt(c),c=a;s.push(c),Ev(c);var u=s.length,h;for(h=1;h<u;++h)c=s[h],l=s[h-1],_A(c.edge,l.site,c.site,i);l=s[0],c=s[u-1],c.edge=tS(l.site,c.site,null,i),Mv(l),Mv(c)}function kGt(e){for(var t=e[0],r=e[1],n,i,o,a,s=Tv._;s;)if(o=RGt(s,r)-t,o>Wr)s=s.L;else if(a=t-WRe(s,r),a>Wr){if(!s.R){n=s;break}s=s.R}else{o>-Wr?(n=s.P,i=s):a>-Wr?(n=s,i=s.N):n=i=s;break}MGt(e);var l=PGt(e);if(Tv.insert(n,l),!(!n&&!i)){if(n===i){Ev(n),i=PGt(n.site),Tv.insert(l,i),l.edge=i.edge=tS(n.site,l.site),Mv(n),Mv(i);return}if(!i){l.edge=tS(n.site,l.site);return}Ev(n),Ev(i);var c=n.site,u=c[0],h=c[1],f=e[0]-u,p=e[1]-h,d=i.site,g=d[0]-u,_=d[1]-h,y=2*(f*_-p*g),x=f*f+p*p,b=g*g+_*_,S=[(_*x-p*b)/y+u,(f*b-g*x)/y+h];_A(i.edge,c,d,S),l.edge=tS(c,e,null,S),i.edge=tS(e,d,null,S),Mv(n),Mv(i)}}function RGt(e,t){var r=e.site,n=r[0],i=r[1],o=i-t;if(!o)return n;var a=e.P;if(!a)return-1/0;r=a.site;var s=r[0],l=r[1],c=l-t;if(!c)return s;var u=s-n,h=1/o-1/c,f=u/c;return h?(-f+Math.sqrt(f*f-2*h*(u*u/(-2*c)-l+c/2+i-o/2)))/h+n:(n+s)/2}function WRe(e,t){var r=e.N;if(r)return RGt(r,t);var n=e.site;return n[1]===t?n[0]:1/0}var IGt,NGt=M(()=>{Cz();fnt();pnt();Az();rS();IGt=[]});function YRe(e,t,r){return(e[0]-r[0])*(t[1]-e[1])-(e[0]-t[0])*(r[1]-e[1])}function jRe(e,t){return t[1]-e[1]||t[0]-e[0]}function yA(e,t){var r=e.sort(jRe).pop(),n,i,o;for(Ao=[],Za=new Array(e.length),Tv=new unt,nS=new unt;;)if(o=Pz,r&&(!o||r[1]<o.y||r[1]===o.y&&r[0]<o.x))(r[0]!==n||r[1]!==i)&&(kGt(r),n=r[0],i=r[1]),r=e.pop();else if(o)LGt(o.arc);else break;if(EGt(),t){var a=+t[0][0],s=+t[0][1],l=+t[1][0],c=+t[1][1];SGt(a,s,l,c),TGt(a,s,l,c)}this.edges=Ao,this.cells=Za,Tv=nS=Ao=Za=null}var Wr,AGt,Tv,Za,nS,Ao,rS=M(()=>{NGt();fnt();pnt();Az();Cz();Wr=1e-6,AGt=1e-12;yA.prototype={constructor:yA,polygons:function(){var e=this.edges;return this.cells.map(function(t){var r=t.halfedges.map(function(n){return hnt(t,e[n])});return r.data=t.site.data,r})},triangles:function(){var e=[],t=this.edges;return this.cells.forEach(function(r,n){if(!!(s=(o=r.halfedges).length))for(var i=r.site,o,a=-1,s,l,c=t[o[s-1]],u=c.left===i?c.right:c.left;++a<s;)l=u,c=t[o[a]],u=c.left===i?c.right:c.left,l&&u&&n<l.index&&n<u.index&&YRe(i,l,u)<0&&e.push([i.data,l.data,u.data])}),e},links:function(){return this.edges.filter(function(e){return e.right}).map(function(e){return{source:e.left.data,target:e.right.data}})},find:function(e,t,r){for(var n=this,i,o=n._found||0,a=n.cells.length,s;!(s=n.cells[o]);)if(++o>=a)return null;var l=e-s.site[0],c=t-s.site[1],u=l*l+c*c;do s=n.cells[i=o],o=null,s.halfedges.forEach(function(h){var f=n.edges[h],p=f.left;if(!((p===s.site||!p)&&!(p=f.right))){var d=e-p[0],g=t-p[1],_=d*d+g*g;_<u&&(u=_,o=p.index)}});while(o!==null);return n._found=i,r==null||u<=r*r?s.site:null}}});function DGt(){var e=vGt,t=xGt,r=null;function n(i){return new yA(i.map(function(o,a){var s=[Math.round(e(o,a,i)/Wr)*Wr,Math.round(t(o,a,i)/Wr)*Wr];return s.index=a,s.data=o,s}),r)}return n.polygons=function(i){return n(i).polygons()},n.links=function(i){return n(i).links()},n.triangles=function(i){return n(i).triangles()},n.x=function(i){return arguments.length?(e=typeof i=="function"?i:lnt(+i),n):e},n.y=function(i){return arguments.length?(t=typeof i=="function"?i:lnt(+i),n):t},n.extent=function(i){return arguments.length?(r=i==null?null:[[+i[0][0],+i[0][1]],[+i[1][0],+i[1][1]]],n):r&&[[r[0][0],r[0][1]],[r[1][0],r[1][1]]]},n.size=function(i){return arguments.length?(r=i==null?null:[[0,0],[+i[0],+i[1]]],n):r&&[r[1][0]-r[0][0],r[1][1]-r[0][1]]},n}var OGt=M(()=>{yGt();bGt();rS()});var zGt=M(()=>{OGt()});function BGt(){for(var e=0,t=arguments.length,r={},n;e<t;++e){if(!(n=arguments[e]+"")||n in r||/[\s.]/.test(n))throw new Error("illegal type: "+n);r[n]=[]}return new Iz(r)}function Iz(e){this._=e}function $Re(e,t){return e.trim().split(/^|\s+/).map(function(r){var n="",i=r.indexOf(".");if(i>=0&&(n=r.slice(i+1),r=r.slice(0,i)),r&&!t.hasOwnProperty(r))throw new Error("unknown type: "+r);return{type:r,name:n}})}function KRe(e,t){for(var r=0,n=e.length,i;r<n;++r)if((i=e[r]).name===t)return i.value}function FGt(e,t,r){for(var n=0,i=e.length;n<i;++n)if(e[n].name===t){e[n]=XRe,e=e.slice(0,n).concat(e.slice(n+1));break}return r!=null&&e.push({name:t,value:r}),e}var XRe,vA,HGt=M(()=>{XRe={value:function(){}};Iz.prototype=BGt.prototype={constructor:Iz,on:function(e,t){var r=this._,n=$Re(e+"",r),i,o=-1,a=n.length;if(arguments.length<2){for(;++o<a;)if((i=(e=n[o]).type)&&(i=KRe(r[i],e.name)))return i;return}if(t!=null&&typeof t!="function")throw new Error("invalid callback: "+t);for(;++o<a;)if(i=(e=n[o]).type)r[i]=FGt(r[i],e.name,t);else if(t==null)for(i in r)r[i]=FGt(r[i],e.name,null);return this},copy:function(){var e={},t=this._;for(var r in t)e[r]=t[r].slice();return new Iz(e)},call:function(e,t){if((i=arguments.length-2)>0)for(var r=new Array(i),n=0,i,o;n<i;++n)r[n]=arguments[n+2];if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(o=this._[e],n=0,i=o.length;n<i;++n)o[n].value.apply(t,r)},apply:function(e,t,r){if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(var n=this._[e],i=0,o=n.length;i<o;++i)n[i].value.apply(t,r)}};vA=BGt});var mnt=M(()=>{HGt()});var Lz,gnt,_nt=M(()=>{Lz="http://www.w3.org/1999/xhtml",gnt={svg:"http://www.w3.org/2000/svg",xhtml:Lz,xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/"}});function hd(e){var t=e+="",r=t.indexOf(":");return r>=0&&(t=e.slice(0,r))!=="xmlns"&&(e=e.slice(r+1)),gnt.hasOwnProperty(t)?{space:gnt[t],local:e}:e}var kz=M(()=>{_nt()});function ZRe(e){return function(){var t=this.ownerDocument,r=this.namespaceURI;return r===Lz&&t.documentElement.namespaceURI===Lz?t.createElement(e):t.createElementNS(r,e)}}function JRe(e){return function(){return this.ownerDocument.createElementNS(e.space,e.local)}}function Rz(e){var t=hd(e);return(t.local?JRe:ZRe)(t)}var ynt=M(()=>{kz();_nt()});function QRe(){}function Cv(e){return e==null?QRe:function(){return this.querySelector(e)}}var Nz=M(()=>{});function VGt(e){typeof e!="function"&&(e=Cv(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=new Array(a),l,c,u=0;u<a;++u)(l=o[u])&&(c=e.call(l,l.__data__,u,o))&&("__data__"in l&&(c.__data__=l.__data__),s[u]=c);return new mi(n,this._parents)}var UGt=M(()=>{Ou();Nz()});function tNe(){return[]}function xA(e){return e==null?tNe:function(){return this.querySelectorAll(e)}}var vnt=M(()=>{});function qGt(e){typeof e!="function"&&(e=xA(e));for(var t=this._groups,r=t.length,n=[],i=[],o=0;o<r;++o)for(var a=t[o],s=a.length,l,c=0;c<s;++c)(l=a[c])&&(n.push(e.call(l,l.__data__,c,a)),i.push(l));return new mi(n,i)}var GGt=M(()=>{Ou();vnt()});function bA(e){return function(){return this.matches(e)}}var xnt=M(()=>{});function WGt(e){typeof e!="function"&&(e=bA(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=[],l,c=0;c<a;++c)(l=o[c])&&e.call(l,l.__data__,c,o)&&s.push(l);return new mi(n,this._parents)}var YGt=M(()=>{Ou();xnt()});function Dz(e){return new Array(e.length)}var bnt=M(()=>{});function jGt(){return new mi(this._enter||this._groups.map(Dz),this._parents)}function wA(e,t){this.ownerDocument=e.ownerDocument,this.namespaceURI=e.namespaceURI,this._next=null,this._parent=e,this.__data__=t}var wnt=M(()=>{bnt();Ou();wA.prototype={constructor:wA,appendChild:function(e){return this._parent.insertBefore(e,this._next)},insertBefore:function(e,t){return this._parent.insertBefore(e,t)},querySelector:function(e){return this._parent.querySelector(e)},querySelectorAll:function(e){return this._parent.querySelectorAll(e)}}});function XGt(e){return function(){return e}}var $Gt=M(()=>{});function eNe(e,t,r,n,i,o){for(var a=0,s,l=t.length,c=o.length;a<c;++a)(s=t[a])?(s.__data__=o[a],n[a]=s):r[a]=new wA(e,o[a]);for(;a<l;++a)(s=t[a])&&(i[a]=s)}function rNe(e,t,r,n,i,o,a){var s,l,c={},u=t.length,h=o.length,f=new Array(u),p;for(s=0;s<u;++s)(l=t[s])&&(f[s]=p=KGt+a.call(l,l.__data__,s,t),p in c?i[s]=l:c[p]=l);for(s=0;s<h;++s)p=KGt+a.call(e,o[s],s,o),(l=c[p])?(n[s]=l,l.__data__=o[s],c[p]=null):r[s]=new wA(e,o[s]);for(s=0;s<u;++s)(l=t[s])&&c[f[s]]===l&&(i[s]=l)}function ZGt(e,t){if(!e)return p=new Array(this.size()),c=-1,this.each(function(P){p[++c]=P}),p;var r=t?rNe:eNe,n=this._parents,i=this._groups;typeof e!="function"&&(e=XGt(e));for(var o=i.length,a=new Array(o),s=new Array(o),l=new Array(o),c=0;c<o;++c){var u=n[c],h=i[c],f=h.length,p=e.call(u,u&&u.__data__,c,n),d=p.length,g=s[c]=new Array(d),_=a[c]=new Array(d),y=l[c]=new Array(f);r(u,h,g,_,y,p,t);for(var x=0,b=0,S,C;x<d;++x)if(S=g[x]){for(x>=b&&(b=x+1);!(C=_[b])&&++b<d;);S._next=C||null}}return a=new mi(a,n),a._enter=s,a._exit=l,a}var KGt,JGt=M(()=>{Ou();wnt();$Gt();KGt="$"});function QGt(){return new mi(this._exit||this._groups.map(Dz),this._parents)}var tWt=M(()=>{bnt();Ou()});function eWt(e,t,r){var n=this.enter(),i=this,o=this.exit();return n=typeof e=="function"?e(n):n.append(e+""),t!=null&&(i=t(i)),r==null?o.remove():r(o),n&&i?n.merge(i).order():i}var rWt=M(()=>{});function nWt(e){for(var t=this._groups,r=e._groups,n=t.length,i=r.length,o=Math.min(n,i),a=new Array(n),s=0;s<o;++s)for(var l=t[s],c=r[s],u=l.length,h=a[s]=new Array(u),f,p=0;p<u;++p)(f=l[p]||c[p])&&(h[p]=f);for(;s<n;++s)a[s]=t[s];return new mi(a,this._parents)}var iWt=M(()=>{Ou()});function oWt(){for(var e=this._groups,t=-1,r=e.length;++t<r;)for(var n=e[t],i=n.length-1,o=n[i],a;--i>=0;)(a=n[i])&&(o&&a.compareDocumentPosition(o)^4&&o.parentNode.insertBefore(a,o),o=a);return this}var aWt=M(()=>{});function sWt(e){e||(e=nNe);function t(h,f){return h&&f?e(h.__data__,f.__data__):!h-!f}for(var r=this._groups,n=r.length,i=new Array(n),o=0;o<n;++o){for(var a=r[o],s=a.length,l=i[o]=new Array(s),c,u=0;u<s;++u)(c=a[u])&&(l[u]=c);l.sort(t)}return new mi(i,this._parents).order()}function nNe(e,t){return e<t?-1:e>t?1:e>=t?0:NaN}var lWt=M(()=>{Ou()});function cWt(){var e=arguments[0];return arguments[0]=this,e.apply(null,arguments),this}var uWt=M(()=>{});function hWt(){var e=new Array(this.size()),t=-1;return this.each(function(){e[++t]=this}),e}var fWt=M(()=>{});function pWt(){for(var e=this._groups,t=0,r=e.length;t<r;++t)for(var n=e[t],i=0,o=n.length;i<o;++i){var a=n[i];if(a)return a}return null}var dWt=M(()=>{});function mWt(){var e=0;return this.each(function(){++e}),e}var gWt=M(()=>{});function _Wt(){return!this.node()}var yWt=M(()=>{});function vWt(e){for(var t=this._groups,r=0,n=t.length;r<n;++r)for(var i=t[r],o=0,a=i.length,s;o<a;++o)(s=i[o])&&e.call(s,s.__data__,o,i);return this}var xWt=M(()=>{});function iNe(e){return function(){this.removeAttribute(e)}}function oNe(e){return function(){this.removeAttributeNS(e.space,e.local)}}function aNe(e,t){return function(){this.setAttribute(e,t)}}function sNe(e,t){return function(){this.setAttributeNS(e.space,e.local,t)}}function lNe(e,t){return function(){var r=t.apply(this,arguments);r==null?this.removeAttribute(e):this.setAttribute(e,r)}}function cNe(e,t){return function(){var r=t.apply(this,arguments);r==null?this.removeAttributeNS(e.space,e.local):this.setAttributeNS(e.space,e.local,r)}}function bWt(e,t){var r=hd(e);if(arguments.length<2){var n=this.node();return r.local?n.getAttributeNS(r.space,r.local):n.getAttribute(r)}return this.each((t==null?r.local?oNe:iNe:typeof t=="function"?r.local?cNe:lNe:r.local?sNe:aNe)(r,t))}var wWt=M(()=>{kz()});function Oz(e){return e.ownerDocument&&e.ownerDocument.defaultView||e.document&&e||e.defaultView}var Snt=M(()=>{});function uNe(e){return function(){this.style.removeProperty(e)}}function hNe(e,t,r){return function(){this.style.setProperty(e,t,r)}}function fNe(e,t,r){return function(){var n=t.apply(this,arguments);n==null?this.style.removeProperty(e):this.style.setProperty(e,n,r)}}function SWt(e,t,r){return arguments.length>1?this.each((t==null?uNe:typeof t=="function"?fNe:hNe)(e,t,r==null?"":r)):Ug(this.node(),e)}function Ug(e,t){return e.style.getPropertyValue(t)||Oz(e).getComputedStyle(e,null).getPropertyValue(t)}var Mnt=M(()=>{Snt()});function pNe(e){return function(){delete this[e]}}function dNe(e,t){return function(){this[e]=t}}function mNe(e,t){return function(){var r=t.apply(this,arguments);r==null?delete this[e]:this[e]=r}}function MWt(e,t){return arguments.length>1?this.each((t==null?pNe:typeof t=="function"?mNe:dNe)(e,t)):this.node()[e]}var EWt=M(()=>{});function TWt(e){return e.trim().split(/^|\s+/)}function Ent(e){return e.classList||new CWt(e)}function CWt(e){this._node=e,this._names=TWt(e.getAttribute("class")||"")}function AWt(e,t){for(var r=Ent(e),n=-1,i=t.length;++n<i;)r.add(t[n])}function PWt(e,t){for(var r=Ent(e),n=-1,i=t.length;++n<i;)r.remove(t[n])}function gNe(e){return function(){AWt(this,e)}}function _Ne(e){return function(){PWt(this,e)}}function yNe(e,t){return function(){(t.apply(this,arguments)?AWt:PWt)(this,e)}}function IWt(e,t){var r=TWt(e+"");if(arguments.length<2){for(var n=Ent(this.node()),i=-1,o=r.length;++i<o;)if(!n.contains(r[i]))return!1;return!0}return this.each((typeof t=="function"?yNe:t?gNe:_Ne)(r,t))}var LWt=M(()=>{CWt.prototype={add:function(e){var t=this._names.indexOf(e);t<0&&(this._names.push(e),this._node.setAttribute("class",this._names.join(" ")))},remove:function(e){var t=this._names.indexOf(e);t>=0&&(this._names.splice(t,1),this._node.setAttribute("class",this._names.join(" ")))},contains:function(e){return this._names.indexOf(e)>=0}}});function vNe(){this.textContent=""}function xNe(e){return function(){this.textContent=e}}function bNe(e){return function(){var t=e.apply(this,arguments);this.textContent=t==null?"":t}}function kWt(e){return arguments.length?this.each(e==null?vNe:(typeof e=="function"?bNe:xNe)(e)):this.node().textContent}var RWt=M(()=>{});function wNe(){this.innerHTML=""}function SNe(e){return function(){this.innerHTML=e}}function MNe(e){return function(){var t=e.apply(this,arguments);this.innerHTML=t==null?"":t}}function NWt(e){return arguments.length?this.each(e==null?wNe:(typeof e=="function"?MNe:SNe)(e)):this.node().innerHTML}var DWt=M(()=>{});function ENe(){this.nextSibling&&this.parentNode.appendChild(this)}function OWt(){return this.each(ENe)}var zWt=M(()=>{});function TNe(){this.previousSibling&&this.parentNode.insertBefore(this,this.parentNode.firstChild)}function FWt(){return this.each(TNe)}var BWt=M(()=>{});function HWt(e){var t=typeof e=="function"?e:Rz(e);return this.select(function(){return this.appendChild(t.apply(this,arguments))})}var VWt=M(()=>{ynt()});function CNe(){return null}function UWt(e,t){var r=typeof e=="function"?e:Rz(e),n=t==null?CNe:typeof t=="function"?t:Cv(t);return this.select(function(){return this.insertBefore(r.apply(this,arguments),n.apply(this,arguments)||null)})}var qWt=M(()=>{ynt();Nz()});function ANe(){var e=this.parentNode;e&&e.removeChild(this)}function GWt(){return this.each(ANe)}var WWt=M(()=>{});function PNe(){var e=this.cloneNode(!1),t=this.parentNode;return t?t.insertBefore(e,this.nextSibling):e}function INe(){var e=this.cloneNode(!0),t=this.parentNode;return t?t.insertBefore(e,this.nextSibling):e}function YWt(e){return this.select(e?INe:PNe)}var jWt=M(()=>{});function XWt(e){return arguments.length?this.property("__data__",e):this.node().__data__}var $Wt=M(()=>{});function LNe(e,t,r){return e=JWt(e,t,r),function(n){var i=n.relatedTarget;(!i||i!==this&&!(i.compareDocumentPosition(this)&8))&&e.call(this,n)}}function JWt(e,t,r){return function(n){var i=Yr;Yr=n;try{e.call(this,this.__data__,t,r)}finally{Yr=i}}}function kNe(e){return e.trim().split(/^|\s+/).map(function(t){var r="",n=t.indexOf(".");return n>=0&&(r=t.slice(n+1),t=t.slice(0,n)),{type:t,name:r}})}function RNe(e){return function(){var t=this.__on;if(!!t){for(var r=0,n=-1,i=t.length,o;r<i;++r)o=t[r],(!e.type||o.type===e.type)&&o.name===e.name?this.removeEventListener(o.type,o.listener,o.capture):t[++n]=o;++n?t.length=n:delete this.__on}}}function NNe(e,t,r){var n=ZWt.hasOwnProperty(e.type)?LNe:JWt;return function(i,o,a){var s=this.__on,l,c=n(t,o,a);if(s){for(var u=0,h=s.length;u<h;++u)if((l=s[u]).type===e.type&&l.name===e.name){this.removeEventListener(l.type,l.listener,l.capture),this.addEventListener(l.type,l.listener=c,l.capture=r),l.value=t;return}}this.addEventListener(e.type,c,r),l={type:e.type,name:e.name,value:t,listener:c,capture:r},s?s.push(l):this.__on=[l]}}function QWt(e,t,r){var n=kNe(e+""),i,o=n.length,a;if(arguments.length<2){var s=this.node().__on;if(s){for(var l=0,c=s.length,u;l<c;++l)for(i=0,u=s[l];i<o;++i)if((a=n[i]).type===u.type&&a.name===u.name)return u.value}return}for(s=t?NNe:RNe,r==null&&(r=!1),i=0;i<o;++i)this.each(s(n[i],t,r));return this}function Tnt(e,t,r,n){var i=Yr;e.sourceEvent=Yr,Yr=e;try{return t.apply(r,n)}finally{Yr=i}}var ZWt,Yr,KWt,zz=M(()=>{ZWt={},Yr=null;typeof document!="undefined"&&(KWt=document.documentElement,"onmouseenter"in KWt||(ZWt={mouseenter:"mouseover",mouseleave:"mouseout"}))});function tYt(e,t,r){var n=Oz(e),i=n.CustomEvent;typeof i=="function"?i=new i(t,r):(i=n.document.createEvent("Event"),r?(i.initEvent(t,r.bubbles,r.cancelable),i.detail=r.detail):i.initEvent(t,!1,!1)),e.dispatchEvent(i)}function DNe(e,t){return function(){return tYt(this,e,t)}}function ONe(e,t){return function(){return tYt(this,e,t.apply(this,arguments))}}function eYt(e,t){return this.each((typeof t=="function"?ONe:DNe)(e,t))}var rYt=M(()=>{Snt()});function mi(e,t){this._groups=e,this._parents=t}function nYt(){return new mi([[document.documentElement]],Cnt)}var Cnt,fd,Ou=M(()=>{UGt();GGt();YGt();JGt();wnt();tWt();rWt();iWt();aWt();lWt();uWt();fWt();dWt();gWt();yWt();xWt();wWt();Mnt();EWt();LWt();RWt();DWt();zWt();BWt();VWt();qWt();WWt();jWt();$Wt();zz();rYt();Cnt=[null];mi.prototype=nYt.prototype={constructor:mi,select:VGt,selectAll:qGt,filter:WGt,data:ZGt,enter:jGt,exit:QGt,join:eWt,merge:nWt,order:oWt,sort:sWt,call:cWt,nodes:hWt,node:pWt,size:mWt,empty:_Wt,each:vWt,attr:bWt,style:SWt,property:MWt,classed:IWt,text:kWt,html:NWt,raise:OWt,lower:FWt,append:HWt,insert:UWt,remove:GWt,clone:YWt,datum:XWt,on:QWt,dispatch:eYt};fd=nYt});function pd(e){return typeof e=="string"?new mi([[document.querySelector(e)]],[document.documentElement]):new mi([[e]],Cnt)}var iYt=M(()=>{Ou()});function Fz(){for(var e=Yr,t;t=e.sourceEvent;)e=t;return e}var Ant=M(()=>{zz()});function Bz(e,t){var r=e.ownerSVGElement||e;if(r.createSVGPoint){var n=r.createSVGPoint();return n.x=t.clientX,n.y=t.clientY,n=n.matrixTransform(e.getScreenCTM().inverse()),[n.x,n.y]}var i=e.getBoundingClientRect();return[t.clientX-i.left-e.clientLeft,t.clientY-i.top-e.clientTop]}var Pnt=M(()=>{});function iS(e){var t=Fz();return t.changedTouches&&(t=t.changedTouches[0]),Bz(e,t)}var oYt=M(()=>{Ant();Pnt()});function Hz(e,t,r){arguments.length<3&&(r=t,t=Fz().changedTouches);for(var n=0,i=t?t.length:0,o;n<i;++n)if((o=t[n]).identifier===r)return Bz(e,o);return null}var aYt=M(()=>{Ant();Pnt()});var Is=M(()=>{xnt();oYt();kz();iYt();Ou();Nz();vnt();Mnt();aYt();zz()});function Vz(){Yr.preventDefault(),Yr.stopImmediatePropagation()}var sYt=M(()=>{Is()});function Int(e){var t=e.document.documentElement,r=pd(e).on("dragstart.drag",Vz,!0);"onselectstart"in t?r.on("selectstart.drag",Vz,!0):(t.__noselect=t.style.MozUserSelect,t.style.MozUserSelect="none")}function Lnt(e,t){var r=e.document.documentElement,n=pd(e).on("dragstart.drag",null);t&&(n.on("click.drag",Vz,!0),setTimeout(function(){n.on("click.drag",null)},0)),"onselectstart"in r?n.on("selectstart.drag",null):(r.style.MozUserSelect=r.__noselect,delete r.__noselect)}var lYt=M(()=>{Is();sYt()});var cYt=M(()=>{lYt()});function Uz(e,t,r){e.prototype=t.prototype=r,r.constructor=e}function knt(e,t){var r=Object.create(e.prototype);for(var n in t)r[n]=t[n];return r}var uYt=M(()=>{});function EA(){}function fYt(){return this.rgb().formatHex()}function GNe(){return yYt(this).formatHsl()}function pYt(){return this.rgb().formatRgb()}function qg(e){var t,r;return e=(e+"").trim().toLowerCase(),(t=zNe.exec(e))?(r=t[1].length,t=parseInt(t[1],16),r===6?dYt(t):r===3?new gl(t>>8&15|t>>4&240,t>>4&15|t&240,(t&15)<<4|t&15,1):r===8?qz(t>>24&255,t>>16&255,t>>8&255,(t&255)/255):r===4?qz(t>>12&15|t>>8&240,t>>8&15|t>>4&240,t>>4&15|t&240,((t&15)<<4|t&15)/255):null):(t=FNe.exec(e))?new gl(t[1],t[2],t[3],1):(t=BNe.exec(e))?new gl(t[1]*255/100,t[2]*255/100,t[3]*255/100,1):(t=HNe.exec(e))?qz(t[1],t[2],t[3],t[4]):(t=VNe.exec(e))?qz(t[1]*255/100,t[2]*255/100,t[3]*255/100,t[4]):(t=UNe.exec(e))?_Yt(t[1],t[2]/100,t[3]/100,1):(t=qNe.exec(e))?_Yt(t[1],t[2]/100,t[3]/100,t[4]):hYt.hasOwnProperty(e)?dYt(hYt[e]):e==="transparent"?new gl(NaN,NaN,NaN,0):null}function dYt(e){return new gl(e>>16&255,e>>8&255,e&255,1)}function qz(e,t,r,n){return n<=0&&(e=t=r=NaN),new gl(e,t,r,n)}function WNe(e){return e instanceof EA||(e=qg(e)),e?(e=e.rgb(),new gl(e.r,e.g,e.b,e.opacity)):new gl}function aS(e,t,r,n){return arguments.length===1?WNe(e):new gl(e,t,r,n==null?1:n)}function gl(e,t,r,n){this.r=+e,this.g=+t,this.b=+r,this.opacity=+n}function mYt(){return"#"+Rnt(this.r)+Rnt(this.g)+Rnt(this.b)}function gYt(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"rgb(":"rgba(")+Math.max(0,Math.min(255,Math.round(this.r)||0))+", "+Math.max(0,Math.min(255,Math.round(this.g)||0))+", "+Math.max(0,Math.min(255,Math.round(this.b)||0))+(e===1?")":", "+e+")")}function Rnt(e){return e=Math.max(0,Math.min(255,Math.round(e)||0)),(e<16?"0":"")+e.toString(16)}function _Yt(e,t,r,n){return n<=0?e=t=r=NaN:r<=0||r>=1?e=t=NaN:t<=0&&(e=NaN),new Cf(e,t,r,n)}function yYt(e){if(e instanceof Cf)return new Cf(e.h,e.s,e.l,e.opacity);if(e instanceof EA||(e=qg(e)),!e)return new Cf;if(e instanceof Cf)return e;e=e.rgb();var t=e.r/255,r=e.g/255,n=e.b/255,i=Math.min(t,r,n),o=Math.max(t,r,n),a=NaN,s=o-i,l=(o+i)/2;return s?(t===o?a=(r-n)/s+(r<n)*6:r===o?a=(n-t)/s+2:a=(t-r)/s+4,s/=l<.5?o+i:2-o-i,a*=60):s=l>0&&l<1?0:a,new Cf(a,s,l,e.opacity)}function vYt(e,t,r,n){return arguments.length===1?yYt(e):new Cf(e,t,r,n==null?1:n)}function Cf(e,t,r,n){this.h=+e,this.s=+t,this.l=+r,this.opacity=+n}function Nnt(e,t,r){return(e<60?t+(r-t)*e/60:e<180?r:e<240?t+(r-t)*(240-e)/60:t)*255}var SA,Gz,oS,MA,Af,zNe,FNe,BNe,HNe,VNe,UNe,qNe,hYt,xYt=M(()=>{uYt();SA=.7,Gz=1/SA,oS="\\s*([+-]?\\d+)\\s*",MA="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",Af="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",zNe=/^#([0-9a-f]{3,8})$/,FNe=new RegExp("^rgb\\("+[oS,oS,oS]+"\\)$"),BNe=new RegExp("^rgb\\("+[Af,Af,Af]+"\\)$"),HNe=new RegExp("^rgba\\("+[oS,oS,oS,MA]+"\\)$"),VNe=new RegExp("^rgba\\("+[Af,Af,Af,MA]+"\\)$"),UNe=new RegExp("^hsl\\("+[MA,Af,Af]+"\\)$"),qNe=new RegExp("^hsla\\("+[MA,Af,Af,MA]+"\\)$"),hYt={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};Uz(EA,qg,{copy:function(e){return Object.assign(new this.constructor,this,e)},displayable:function(){return this.rgb().displayable()},hex:fYt,formatHex:fYt,formatHsl:GNe,formatRgb:pYt,toString:pYt});Uz(gl,aS,knt(EA,{brighter:function(e){return e=e==null?Gz:Math.pow(Gz,e),new gl(this.r*e,this.g*e,this.b*e,this.opacity)},darker:function(e){return e=e==null?SA:Math.pow(SA,e),new gl(this.r*e,this.g*e,this.b*e,this.opacity)},rgb:function(){return this},displayable:function(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:mYt,formatHex:mYt,formatRgb:gYt,toString:gYt}));Uz(Cf,vYt,knt(EA,{brighter:function(e){return e=e==null?Gz:Math.pow(Gz,e),new Cf(this.h,this.s,this.l*e,this.opacity)},darker:function(e){return e=e==null?SA:Math.pow(SA,e),new Cf(this.h,this.s,this.l*e,this.opacity)},rgb:function(){var e=this.h%360+(this.h<0)*360,t=isNaN(e)||isNaN(this.s)?0:this.s,r=this.l,n=r+(r<.5?r:1-r)*t,i=2*r-n;return new gl(Nnt(e>=240?e-240:e+120,i,n),Nnt(e,i,n),Nnt(e<120?e+240:e-120,i,n),this.opacity)},displayable:function(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl:function(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"hsl(":"hsla(")+(this.h||0)+", "+(this.s||0)*100+"%, "+(this.l||0)*100+"%"+(e===1?")":", "+e+")")}}))});var Dnt=M(()=>{xYt()});function Ont(e,t,r,n,i){var o=e*e,a=o*e;return((1-3*e+3*o-a)*t+(4-6*o+3*a)*r+(1+3*e+3*o-3*a)*n+a*i)/6}function bYt(e){var t=e.length-1;return function(r){var n=r<=0?r=0:r>=1?(r=1,t-1):Math.floor(r*t),i=e[n],o=e[n+1],a=n>0?e[n-1]:2*i-o,s=n<t-1?e[n+2]:2*o-i;return Ont((r-n/t)*t,a,i,o,s)}}var znt=M(()=>{});function wYt(e){var t=e.length;return function(r){var n=Math.floor(((r%=1)<0?++r:r)*t),i=e[(n+t-1)%t],o=e[n%t],a=e[(n+1)%t],s=e[(n+2)%t];return Ont((r-n/t)*t,i,o,a,s)}}var SYt=M(()=>{znt()});function Fnt(e){return function(){return e}}var MYt=M(()=>{});function YNe(e,t){return function(r){return e+r*t}}function jNe(e,t,r){return e=Math.pow(e,r),t=Math.pow(t,r)-e,r=1/r,function(n){return Math.pow(e+n*t,r)}}function EYt(e){return(e=+e)==1?Wz:function(t,r){return r-t?jNe(t,r,e):Fnt(isNaN(t)?r:t)}}function Wz(e,t){var r=t-e;return r?YNe(e,r):Fnt(isNaN(e)?t:e)}var TYt=M(()=>{MYt()});function CYt(e){return function(t){var r=t.length,n=new Array(r),i=new Array(r),o=new Array(r),a,s;for(a=0;a<r;++a)s=aS(t[a]),n[a]=s.r||0,i[a]=s.g||0,o[a]=s.b||0;return n=e(n),i=e(i),o=e(o),s.opacity=1,function(l){return s.r=n(l),s.g=i(l),s.b=o(l),s+""}}}var Yz,XNe,$Ne,AYt=M(()=>{Dnt();znt();SYt();TYt();Yz=function e(t){var r=EYt(t);function n(i,o){var a=r((i=aS(i)).r,(o=aS(o)).r),s=r(i.g,o.g),l=r(i.b,o.b),c=Wz(i.opacity,o.opacity);return function(u){return i.r=a(u),i.g=s(u),i.b=l(u),i.opacity=c(u),i+""}}return n.gamma=e,n}(1);XNe=CYt(bYt),$Ne=CYt(wYt)});function Ic(e,t){return e=+e,t=+t,function(r){return e*(1-r)+t*r}}var jz=M(()=>{});function KNe(e){return function(){return e}}function ZNe(e){return function(t){return e(t)+""}}function Vnt(e,t){var r=Hnt.lastIndex=Bnt.lastIndex=0,n,i,o,a=-1,s=[],l=[];for(e=e+"",t=t+"";(n=Hnt.exec(e))&&(i=Bnt.exec(t));)(o=i.index)>r&&(o=t.slice(r,o),s[a]?s[a]+=o:s[++a]=o),(n=n[0])===(i=i[0])?s[a]?s[a]+=i:s[++a]=i:(s[++a]=null,l.push({i:a,x:Ic(n,i)})),r=Bnt.lastIndex;return r<t.length&&(o=t.slice(r),s[a]?s[a]+=o:s[++a]=o),s.length<2?l[0]?ZNe(l[0].x):KNe(t):(t=l.length,function(c){for(var u=0,h;u<t;++u)s[(h=l[u]).i]=h.x(c);return s.join("")})}var Hnt,Bnt,PYt=M(()=>{jz();Hnt=/[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,Bnt=new RegExp(Hnt.source,"g")});function Unt(e,t,r,n,i,o){var a,s,l;return(a=Math.sqrt(e*e+t*t))&&(e/=a,t/=a),(l=e*r+t*n)&&(r-=e*l,n-=t*l),(s=Math.sqrt(r*r+n*n))&&(r/=s,n/=s,l/=s),e*n<t*r&&(e=-e,t=-t,l=-l,a=-a),{translateX:i,translateY:o,rotate:Math.atan2(t,e)*IYt,skewX:Math.atan(l)*IYt,scaleX:a,scaleY:s}}var IYt,Xz,LYt=M(()=>{IYt=180/Math.PI,Xz={translateX:0,translateY:0,rotate:0,skewX:0,scaleX:1,scaleY:1}});function RYt(e){return e==="none"?Xz:(TA||(TA=document.createElement("DIV"),qnt=document.documentElement,kYt=document.defaultView),TA.style.transform=e,e=kYt.getComputedStyle(qnt.appendChild(TA),null).getPropertyValue("transform"),qnt.removeChild(TA),e=e.slice(7,-1).split(","),Unt(+e[0],+e[1],+e[2],+e[3],+e[4],+e[5]))}function NYt(e){return e==null?Xz:($z||($z=document.createElementNS("http://www.w3.org/2000/svg","g")),$z.setAttribute("transform",e),(e=$z.transform.baseVal.consolidate())?(e=e.matrix,Unt(e.a,e.b,e.c,e.d,e.e,e.f)):Xz)}var TA,qnt,kYt,$z,DYt=M(()=>{LYt()});function OYt(e,t,r,n){function i(c){return c.length?c.pop()+" ":""}function o(c,u,h,f,p,d){if(c!==h||u!==f){var g=p.push("translate(",null,t,null,r);d.push({i:g-4,x:Ic(c,h)},{i:g-2,x:Ic(u,f)})}else(h||f)&&p.push("translate("+h+t+f+r)}function a(c,u,h,f){c!==u?(c-u>180?u+=360:u-c>180&&(c+=360),f.push({i:h.push(i(h)+"rotate(",null,n)-2,x:Ic(c,u)})):u&&h.push(i(h)+"rotate("+u+n)}function s(c,u,h,f){c!==u?f.push({i:h.push(i(h)+"skewX(",null,n)-2,x:Ic(c,u)}):u&&h.push(i(h)+"skewX("+u+n)}function l(c,u,h,f,p,d){if(c!==h||u!==f){var g=p.push(i(p)+"scale(",null,",",null,")");d.push({i:g-4,x:Ic(c,h)},{i:g-2,x:Ic(u,f)})}else(h!==1||f!==1)&&p.push(i(p)+"scale("+h+","+f+")")}return function(c,u){var h=[],f=[];return c=e(c),u=e(u),o(c.translateX,c.translateY,u.translateX,u.translateY,h,f),a(c.rotate,u.rotate,h,f),s(c.skewX,u.skewX,h,f),l(c.scaleX,c.scaleY,u.scaleX,u.scaleY,h,f),c=u=null,function(p){for(var d=-1,g=f.length,_;++d<g;)h[(_=f[d]).i]=_.x(p);return h.join("")}}}var Gnt,Wnt,zYt=M(()=>{jz();DYt();Gnt=OYt(RYt,"px, ","px)","deg)"),Wnt=OYt(NYt,", ",")",")")});function BYt(e){return((e=Math.exp(e))+1/e)/2}function QNe(e){return((e=Math.exp(e))-1/e)/2}function tDe(e){return((e=Math.exp(2*e))-1)/(e+1)}function jnt(e,t){var r=e[0],n=e[1],i=e[2],o=t[0],a=t[1],s=t[2],l=o-r,c=a-n,u=l*l+c*c,h,f;if(u<JNe)f=Math.log(s/i)/CA,h=function(x){return[r+x*l,n+x*c,i*Math.exp(CA*x*f)]};else{var p=Math.sqrt(u),d=(s*s-i*i+FYt*u)/(2*i*Ynt*p),g=(s*s-i*i-FYt*u)/(2*s*Ynt*p),_=Math.log(Math.sqrt(d*d+1)-d),y=Math.log(Math.sqrt(g*g+1)-g);f=(y-_)/CA,h=function(x){var b=x*f,S=BYt(_),C=i/(Ynt*p)*(S*tDe(CA*b+_)-QNe(_));return[r+C*l,n+C*c,i*S/BYt(CA*b+_)]}}return h.duration=f*1e3,h}var CA,Ynt,FYt,JNe,HYt=M(()=>{CA=Math.SQRT2,Ynt=2,FYt=4,JNe=1e-12});var AA=M(()=>{jz();PYt();zYt();HYt();AYt()});function lS(){return Av||(qYt(eDe),Av=kA.now()+Jz)}function eDe(){Av=0}function RA(){this._call=this._time=this._next=null}function Qz(e,t,r){var n=new RA;return n.restart(e,t,r),n}function GYt(){lS(),++sS;for(var e=Kz,t;e;)(t=Av-e._time)>=0&&e._call.call(null,t),e=e._next;--sS}function VYt(){Av=(Zz=kA.now())+Jz,sS=IA=0;try{GYt()}finally{sS=0,nDe(),Av=0}}function rDe(){var e=kA.now(),t=e-Zz;t>UYt&&(Jz-=t,Zz=e)}function nDe(){for(var e,t=Kz,r,n=1/0;t;)t._call?(n>t._time&&(n=t._time),e=t,t=t._next):(r=t._next,t._next=null,t=e?e._next=r:Kz=r);LA=e,Xnt(n)}function Xnt(e){if(!sS){IA&&(IA=clearTimeout(IA));var t=e-Av;t>24?(e<1/0&&(IA=setTimeout(VYt,e-kA.now()-Jz)),PA&&(PA=clearInterval(PA))):(PA||(Zz=kA.now(),PA=setInterval(rDe,UYt)),sS=1,qYt(VYt))}}var sS,IA,PA,UYt,Kz,LA,Zz,Av,Jz,kA,qYt,$nt=M(()=>{sS=0,IA=0,PA=0,UYt=1e3,Zz=0,Av=0,Jz=0,kA=typeof performance=="object"&&performance.now?performance:Date,qYt=typeof window=="object"&&window.requestAnimationFrame?window.requestAnimationFrame.bind(window):function(e){setTimeout(e,17)};RA.prototype=Qz.prototype={constructor:RA,restart:function(e,t,r){if(typeof e!="function")throw new TypeError("callback is not a function");r=(r==null?lS():+r)+(t==null?0:+t),!this._next&&LA!==this&&(LA?LA._next=this:Kz=this,LA=this),this._call=e,this._time=r,Xnt()},stop:function(){this._call&&(this._call=null,this._time=1/0,Xnt())}}});function tF(e,t,r){var n=new RA;return t=t==null?0:+t,n.restart(function(i){n.stop(),e(i+t)},t,r),n}var WYt=M(()=>{$nt()});var Knt=M(()=>{$nt();WYt()});function Gg(e,t,r,n,i,o){var a=e.__transition;if(!a)e.__transition={};else if(r in a)return;aDe(e,r,{name:t,index:n,group:i,on:iDe,tween:oDe,time:o.time,delay:o.delay,duration:o.duration,ease:o.ease,timer:null,state:jYt})}function DA(e,t){var r=oo(e,t);if(r.state>jYt)throw new Error("too late; already scheduled");return r}function Ja(e,t){var r=oo(e,t);if(r.state>eF)throw new Error("too late; already running");return r}function oo(e,t){var r=e.__transition;if(!r||!(r=r[t]))throw new Error("transition not found");return r}function aDe(e,t,r){var n=e.__transition,i;n[t]=r,r.timer=Qz(o,0,r.time);function o(c){r.state=Znt,r.timer.restart(a,r.delay,r.time),r.delay<=c&&a(c-r.delay)}function a(c){var u,h,f,p;if(r.state!==Znt)return l();for(u in n)if(p=n[u],p.name===r.name){if(p.state===eF)return tF(a);p.state===YYt?(p.state=NA,p.timer.stop(),p.on.call("interrupt",e,e.__data__,p.index,p.group),delete n[u]):+u<t&&(p.state=NA,p.timer.stop(),p.on.call("cancel",e,e.__data__,p.index,p.group),delete n[u])}if(tF(function(){r.state===eF&&(r.state=YYt,r.timer.restart(s,r.delay,r.time),s(c))}),r.state=rF,r.on.call("start",e,e.__data__,r.index,r.group),r.state===rF){for(r.state=eF,i=new Array(f=r.tween.length),u=0,h=-1;u<f;++u)(p=r.tween[u].value.call(e,e.__data__,r.index,r.group))&&(i[++h]=p);i.length=h+1}}function s(c){for(var u=c<r.duration?r.ease.call(null,c/r.duration):(r.timer.restart(l),r.state=nF,1),h=-1,f=i.length;++h<f;)i[h].call(e,u);r.state===nF&&(r.on.call("end",e,e.__data__,r.index,r.group),l())}function l(){r.state=NA,r.timer.stop(),delete n[t];for(var c in n)return;delete e.__transition}}var iDe,oDe,jYt,Znt,rF,eF,YYt,nF,NA,Ls=M(()=>{mnt();Knt();iDe=vA("start","end","cancel","interrupt"),oDe=[],jYt=0,Znt=1,rF=2,eF=3,YYt=4,nF=5,NA=6});function Pv(e,t){var r=e.__transition,n,i,o=!0,a;if(!!r){t=t==null?null:t+"";for(a in r){if((n=r[a]).name!==t){o=!1;continue}i=n.state>rF&&n.state<nF,n.state=NA,n.timer.stop(),n.on.call(i?"interrupt":"cancel",e,e.__data__,n.index,n.group),delete r[a]}o&&delete e.__transition}}var Jnt=M(()=>{Ls()});function XYt(e){return this.each(function(){Pv(this,e)})}var $Yt=M(()=>{Jnt()});function sDe(e,t){var r,n;return function(){var i=Ja(this,e),o=i.tween;if(o!==r){n=r=o;for(var a=0,s=n.length;a<s;++a)if(n[a].name===t){n=n.slice(),n.splice(a,1);break}}i.tween=n}}function lDe(e,t,r){var n,i;if(typeof r!="function")throw new Error;return function(){var o=Ja(this,e),a=o.tween;if(a!==n){i=(n=a).slice();for(var s={name:t,value:r},l=0,c=i.length;l<c;++l)if(i[l].name===t){i[l]=s;break}l===c&&i.push(s)}o.tween=i}}function KYt(e,t){var r=this._id;if(e+="",arguments.length<2){for(var n=oo(this.node(),r).tween,i=0,o=n.length,a;i<o;++i)if((a=n[i]).name===e)return a.value;return null}return this.each((t==null?sDe:lDe)(r,e,t))}function cS(e,t,r){var n=e._id;return e.each(function(){var i=Ja(this,n);(i.value||(i.value={}))[t]=r.apply(this,arguments)}),function(i){return oo(i,n).value[t]}}var OA=M(()=>{Ls()});function iF(e,t){var r;return(typeof t=="number"?Ic:t instanceof qg?Yz:(r=qg(t))?(t=r,Yz):Vnt)(e,t)}var Qnt=M(()=>{Dnt();AA()});function cDe(e){return function(){this.removeAttribute(e)}}function uDe(e){return function(){this.removeAttributeNS(e.space,e.local)}}function hDe(e,t,r){var n,i=r+"",o;return function(){var a=this.getAttribute(e);return a===i?null:a===n?o:o=t(n=a,r)}}function fDe(e,t,r){var n,i=r+"",o;return function(){var a=this.getAttributeNS(e.space,e.local);return a===i?null:a===n?o:o=t(n=a,r)}}function pDe(e,t,r){var n,i,o;return function(){var a,s=r(this),l;return s==null?void this.removeAttribute(e):(a=this.getAttribute(e),l=s+"",a===l?null:a===n&&l===i?o:(i=l,o=t(n=a,s)))}}function dDe(e,t,r){var n,i,o;return function(){var a,s=r(this),l;return s==null?void this.removeAttributeNS(e.space,e.local):(a=this.getAttributeNS(e.space,e.local),l=s+"",a===l?null:a===n&&l===i?o:(i=l,o=t(n=a,s)))}}function ZYt(e,t){var r=hd(e),n=r==="transform"?Wnt:iF;return this.attrTween(e,typeof t=="function"?(r.local?dDe:pDe)(r,n,cS(this,"attr."+e,t)):t==null?(r.local?uDe:cDe)(r):(r.local?fDe:hDe)(r,n,t))}var JYt=M(()=>{AA();Is();OA();Qnt()});function mDe(e,t){return function(r){this.setAttribute(e,t.call(this,r))}}function gDe(e,t){return function(r){this.setAttributeNS(e.space,e.local,t.call(this,r))}}function _De(e,t){var r,n;function i(){var o=t.apply(this,arguments);return o!==n&&(r=(n=o)&&gDe(e,o)),r}return i._value=t,i}function yDe(e,t){var r,n;function i(){var o=t.apply(this,arguments);return o!==n&&(r=(n=o)&&mDe(e,o)),r}return i._value=t,i}function QYt(e,t){var r="attr."+e;if(arguments.length<2)return(r=this.tween(r))&&r._value;if(t==null)return this.tween(r,null);if(typeof t!="function")throw new Error;var n=hd(e);return this.tween(r,(n.local?_De:yDe)(n,t))}var tjt=M(()=>{Is()});function vDe(e,t){return function(){DA(this,e).delay=+t.apply(this,arguments)}}function xDe(e,t){return t=+t,function(){DA(this,e).delay=t}}function ejt(e){var t=this._id;return arguments.length?this.each((typeof e=="function"?vDe:xDe)(t,e)):oo(this.node(),t).delay}var rjt=M(()=>{Ls()});function bDe(e,t){return function(){Ja(this,e).duration=+t.apply(this,arguments)}}function wDe(e,t){return t=+t,function(){Ja(this,e).duration=t}}function njt(e){var t=this._id;return arguments.length?this.each((typeof e=="function"?bDe:wDe)(t,e)):oo(this.node(),t).duration}var ijt=M(()=>{Ls()});function SDe(e,t){if(typeof t!="function")throw new Error;return function(){Ja(this,e).ease=t}}function ojt(e){var t=this._id;return arguments.length?this.each(SDe(t,e)):oo(this.node(),t).ease}var ajt=M(()=>{Ls()});function sjt(e){typeof e!="function"&&(e=bA(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=[],l,c=0;c<a;++c)(l=o[c])&&e.call(l,l.__data__,c,o)&&s.push(l);return new da(n,this._parents,this._name,this._id)}var ljt=M(()=>{Is();dd()});function cjt(e){if(e._id!==this._id)throw new Error;for(var t=this._groups,r=e._groups,n=t.length,i=r.length,o=Math.min(n,i),a=new Array(n),s=0;s<o;++s)for(var l=t[s],c=r[s],u=l.length,h=a[s]=new Array(u),f,p=0;p<u;++p)(f=l[p]||c[p])&&(h[p]=f);for(;s<n;++s)a[s]=t[s];return new da(a,this._parents,this._name,this._id)}var ujt=M(()=>{dd()});function MDe(e){return(e+"").trim().split(/^|\s+/).every(function(t){var r=t.indexOf(".");return r>=0&&(t=t.slice(0,r)),!t||t==="start"})}function EDe(e,t,r){var n,i,o=MDe(t)?DA:Ja;return function(){var a=o(this,e),s=a.on;s!==n&&(i=(n=s).copy()).on(t,r),a.on=i}}function hjt(e,t){var r=this._id;return arguments.length<2?oo(this.node(),r).on.on(e):this.each(EDe(r,e,t))}var fjt=M(()=>{Ls()});function TDe(e){return function(){var t=this.parentNode;for(var r in this.__transition)if(+r!==e)return;t&&t.removeChild(this)}}function pjt(){return this.on("end.remove",TDe(this._id))}var djt=M(()=>{});function mjt(e){var t=this._name,r=this._id;typeof e!="function"&&(e=Cv(e));for(var n=this._groups,i=n.length,o=new Array(i),a=0;a<i;++a)for(var s=n[a],l=s.length,c=o[a]=new Array(l),u,h,f=0;f<l;++f)(u=s[f])&&(h=e.call(u,u.__data__,f,s))&&("__data__"in u&&(h.__data__=u.__data__),c[f]=h,Gg(c[f],t,r,f,c,oo(u,r)));return new da(o,this._parents,t,r)}var gjt=M(()=>{Is();dd();Ls()});function _jt(e){var t=this._name,r=this._id;typeof e!="function"&&(e=xA(e));for(var n=this._groups,i=n.length,o=[],a=[],s=0;s<i;++s)for(var l=n[s],c=l.length,u,h=0;h<c;++h)if(u=l[h]){for(var f=e.call(u,u.__data__,h,l),p,d=oo(u,r),g=0,_=f.length;g<_;++g)(p=f[g])&&Gg(p,t,r,g,f,d);o.push(f),a.push(u)}return new da(o,a,t,r)}var yjt=M(()=>{Is();dd();Ls()});function vjt(){return new CDe(this._groups,this._parents)}var CDe,xjt=M(()=>{Is();CDe=fd.prototype.constructor});function ADe(e,t){var r,n,i;return function(){var o=Ug(this,e),a=(this.style.removeProperty(e),Ug(this,e));return o===a?null:o===r&&a===n?i:i=t(r=o,n=a)}}function bjt(e){return function(){this.style.removeProperty(e)}}function PDe(e,t,r){var n,i=r+"",o;return function(){var a=Ug(this,e);return a===i?null:a===n?o:o=t(n=a,r)}}function IDe(e,t,r){var n,i,o;return function(){var a=Ug(this,e),s=r(this),l=s+"";return s==null&&(l=s=(this.style.removeProperty(e),Ug(this,e))),a===l?null:a===n&&l===i?o:(i=l,o=t(n=a,s))}}function LDe(e,t){var r,n,i,o="style."+t,a="end."+o,s;return function(){var l=Ja(this,e),c=l.on,u=l.value[o]==null?s||(s=bjt(t)):void 0;(c!==r||i!==u)&&(n=(r=c).copy()).on(a,i=u),l.on=n}}function wjt(e,t,r){var n=(e+="")=="transform"?Gnt:iF;return t==null?this.styleTween(e,ADe(e,n)).on("end.style."+e,bjt(e)):typeof t=="function"?this.styleTween(e,IDe(e,n,cS(this,"style."+e,t))).each(LDe(this._id,e)):this.styleTween(e,PDe(e,n,t),r).on("end.style."+e,null)}var Sjt=M(()=>{AA();Is();Ls();OA();Qnt()});function kDe(e,t,r){return function(n){this.style.setProperty(e,t.call(this,n),r)}}function RDe(e,t,r){var n,i;function o(){var a=t.apply(this,arguments);return a!==i&&(n=(i=a)&&kDe(e,a,r)),n}return o._value=t,o}function Mjt(e,t,r){var n="style."+(e+="");if(arguments.length<2)return(n=this.tween(n))&&n._value;if(t==null)return this.tween(n,null);if(typeof t!="function")throw new Error;return this.tween(n,RDe(e,t,r==null?"":r))}var Ejt=M(()=>{});function NDe(e){return function(){this.textContent=e}}function DDe(e){return function(){var t=e(this);this.textContent=t==null?"":t}}function Tjt(e){return this.tween("text",typeof e=="function"?DDe(cS(this,"text",e)):NDe(e==null?"":e+""))}var Cjt=M(()=>{OA()});function ODe(e){return function(t){this.textContent=e.call(this,t)}}function zDe(e){var t,r;function n(){var i=e.apply(this,arguments);return i!==r&&(t=(r=i)&&ODe(i)),t}return n._value=e,n}function Ajt(e){var t="text";if(arguments.length<1)return(t=this.tween(t))&&t._value;if(e==null)return this.tween(t,null);if(typeof e!="function")throw new Error;return this.tween(t,zDe(e))}var Pjt=M(()=>{});function Ijt(){for(var e=this._name,t=this._id,r=oF(),n=this._groups,i=n.length,o=0;o<i;++o)for(var a=n[o],s=a.length,l,c=0;c<s;++c)if(l=a[c]){var u=oo(l,t);Gg(l,e,r,c,a,{time:u.time+u.delay+u.duration,delay:0,duration:u.duration,ease:u.ease})}return new da(n,this._parents,e,r)}var Ljt=M(()=>{dd();Ls()});function kjt(){var e,t,r=this,n=r._id,i=r.size();return new Promise(function(o,a){var s={value:a},l={value:function(){--i===0&&o()}};r.each(function(){var c=Ja(this,n),u=c.on;u!==e&&(t=(e=u).copy(),t._.cancel.push(s),t._.interrupt.push(s),t._.end.push(l)),c.on=t})})}var Rjt=M(()=>{Ls()});function da(e,t,r,n){this._groups=e,this._parents=t,this._name=r,this._id=n}function tit(e){return fd().transition(e)}function oF(){return++FDe}var FDe,uS,dd=M(()=>{Is();JYt();tjt();rjt();ijt();ajt();ljt();ujt();fjt();djt();gjt();yjt();xjt();Sjt();Ejt();Cjt();Pjt();Ljt();OA();Rjt();FDe=0;uS=fd.prototype;da.prototype=tit.prototype={constructor:da,select:mjt,selectAll:_jt,filter:sjt,merge:cjt,selection:vjt,transition:Ijt,call:uS.call,nodes:uS.nodes,node:uS.node,size:uS.size,empty:uS.empty,each:uS.each,on:hjt,attr:ZYt,attrTween:QYt,style:wjt,styleTween:Mjt,text:Tjt,textTween:Ajt,remove:pjt,tween:KYt,delay:ejt,duration:njt,ease:ojt,end:kjt}});function BDe(e,t){for(var r;!(r=e.__transition)||!(r=r[t]);)if(!(e=e.parentNode))return eit.time=lS(),eit;return r}function Njt(e){var t,r;e instanceof da?(t=e._id,e=e._name):(t=oF(),(r=eit).time=lS(),e=e==null?null:e+"");for(var n=this._groups,i=n.length,o=0;o<i;++o)for(var a=n[o],s=a.length,l,c=0;c<s;++c)(l=a[c])&&Gg(l,e,t,c,a,r||BDe(l,t));return new da(n,this._parents,e,t)}var eit,Djt=M(()=>{dd();Ls();I_();Knt();eit={time:null,delay:0,duration:250,ease:xs}});var Ojt=M(()=>{Is();$Yt();Djt();fd.prototype.interrupt=XYt;fd.prototype.transition=Njt});var zjt=M(()=>{dd();Ls()});var Fjt=M(()=>{Ojt();dd();zjt();Jnt()});function zA(e){return function(){return e}}var Bjt=M(()=>{});function rit(e,t,r){this.target=e,this.type=t,this.transform=r}var Hjt=M(()=>{});function Pf(e,t,r){this.k=e,this.x=t,this.y=r}function aF(e){return e.__zoom||hS}var hS,nit=M(()=>{Pf.prototype={constructor:Pf,scale:function(e){return e===1?this:new Pf(this.k*e,this.x,this.y)},translate:function(e,t){return e===0&t===0?this:new Pf(this.k,this.x+this.k*e,this.y+this.k*t)},apply:function(e){return[e[0]*this.k+this.x,e[1]*this.k+this.y]},applyX:function(e){return e*this.k+this.x},applyY:function(e){return e*this.k+this.y},invert:function(e){return[(e[0]-this.x)/this.k,(e[1]-this.y)/this.k]},invertX:function(e){return(e-this.x)/this.k},invertY:function(e){return(e-this.y)/this.k},rescaleX:function(e){return e.copy().domain(e.range().map(this.invertX,this).map(e.invert,e))},rescaleY:function(e){return e.copy().domain(e.range().map(this.invertY,this).map(e.invert,e))},toString:function(){return"translate("+this.x+","+this.y+") scale("+this.k+")"}};hS=new Pf(1,0,0);aF.prototype=Pf.prototype});function sF(){Yr.stopImmediatePropagation()}function fS(){Yr.preventDefault(),Yr.stopImmediatePropagation()}var Vjt=M(()=>{Is()});function HDe(){return!Yr.button}function VDe(){var e=this,t,r;return e instanceof SVGElement?(e=e.ownerSVGElement||e,t=e.width.baseVal.value,r=e.height.baseVal.value):(t=e.clientWidth,r=e.clientHeight),[[0,0],[t,r]]}function Ujt(){return this.__zoom||hS}function UDe(){return-Yr.deltaY*(Yr.deltaMode?120:1)/500}function qDe(){return"ontouchstart"in this}function GDe(e,t,r){var n=e.invertX(t[0][0])-r[0][0],i=e.invertX(t[1][0])-r[1][0],o=e.invertY(t[0][1])-r[0][1],a=e.invertY(t[1][1])-r[1][1];return e.translate(i>n?(n+i)/2:Math.min(0,n)||Math.max(0,i),a>o?(o+a)/2:Math.min(0,o)||Math.max(0,a))}function qjt(){var e=HDe,t=VDe,r=GDe,n=UDe,i=qDe,o=[0,1/0],a=[[-1/0,-1/0],[1/0,1/0]],s=250,l=jnt,c=[],u=vA("start","zoom","end"),h,f,p=500,d=150,g=0;function _(R){R.property("__zoom",Ujt).on("wheel.zoom",k).on("mousedown.zoom",O).on("dblclick.zoom",D).filter(i).on("touchstart.zoom",B).on("touchmove.zoom",I).on("touchend.zoom touchcancel.zoom",L).style("touch-action","none").style("-webkit-tap-highlight-color","rgba(0,0,0,0)")}_.transform=function(R,F){var z=R.selection?R.selection():R;z.property("__zoom",Ujt),R!==z?S(R,F):z.interrupt().each(function(){C(this,arguments).start().zoom(null,typeof F=="function"?F.apply(this,arguments):F).end()})},_.scaleBy=function(R,F){_.scaleTo(R,function(){var z=this.__zoom.k,U=typeof F=="function"?F.apply(this,arguments):F;return z*U})},_.scaleTo=function(R,F){_.transform(R,function(){var z=t.apply(this,arguments),U=this.__zoom,W=b(z),Z=U.invert(W),rt=typeof F=="function"?F.apply(this,arguments):F;return r(x(y(U,rt),W,Z),z,a)})},_.translateBy=function(R,F,z){_.transform(R,function(){return r(this.__zoom.translate(typeof F=="function"?F.apply(this,arguments):F,typeof z=="function"?z.apply(this,arguments):z),t.apply(this,arguments),a)})},_.translateTo=function(R,F,z){_.transform(R,function(){var U=t.apply(this,arguments),W=this.__zoom,Z=b(U);return r(hS.translate(Z[0],Z[1]).scale(W.k).translate(typeof F=="function"?-F.apply(this,arguments):-F,typeof z=="function"?-z.apply(this,arguments):-z),U,a)})};function y(R,F){return F=Math.max(o[0],Math.min(o[1],F)),F===R.k?R:new Pf(F,R.x,R.y)}function x(R,F,z){var U=F[0]-z[0]*R.k,W=F[1]-z[1]*R.k;return U===R.x&&W===R.y?R:new Pf(R.k,U,W)}function b(R){return[(+R[0][0]+ +R[1][0])/2,(+R[0][1]+ +R[1][1])/2]}function S(R,F,z){R.on("start.zoom",function(){C(this,arguments).start()}).on("interrupt.zoom end.zoom",function(){C(this,arguments).end()}).tween("zoom",function(){var U=this,W=arguments,Z=C(U,W),rt=t.apply(U,W),ot=z||b(rt),st=Math.max(rt[1][0]-rt[0][0],rt[1][1]-rt[0][1]),St=U.__zoom,bt=typeof F=="function"?F.apply(U,W):F,Mt=l(St.invert(ot).concat(st/St.k),bt.invert(ot).concat(st/bt.k));return function(lt){if(lt===1)lt=bt;else{var Kt=Mt(lt),_t=st/Kt[2];lt=new Pf(_t,ot[0]-Kt[0]*_t,ot[1]-Kt[1]*_t)}Z.zoom(null,lt)}})}function C(R,F){for(var z=0,U=c.length,W;z<U;++z)if((W=c[z]).that===R)return W;return new P(R,F)}function P(R,F){this.that=R,this.args=F,this.index=-1,this.active=0,this.extent=t.apply(R,F)}P.prototype={start:function(){return++this.active===1&&(this.index=c.push(this)-1,this.emit("start")),this},zoom:function(R,F){return this.mouse&&R!=="mouse"&&(this.mouse[1]=F.invert(this.mouse[0])),this.touch0&&R!=="touch"&&(this.touch0[1]=F.invert(this.touch0[0])),this.touch1&&R!=="touch"&&(this.touch1[1]=F.invert(this.touch1[0])),this.that.__zoom=F,this.emit("zoom"),this},end:function(){return--this.active===0&&(c.splice(this.index,1),this.index=-1,this.emit("end")),this},emit:function(R){Tnt(new rit(_,R,this.that.__zoom),u.apply,u,[R,this.that,this.args])}};function k(){if(!e.apply(this,arguments))return;var R=C(this,arguments),F=this.__zoom,z=Math.max(o[0],Math.min(o[1],F.k*Math.pow(2,n.apply(this,arguments)))),U=iS(this);if(R.wheel)(R.mouse[0][0]!==U[0]||R.mouse[0][1]!==U[1])&&(R.mouse[1]=F.invert(R.mouse[0]=U)),clearTimeout(R.wheel);else{if(F.k===z)return;R.mouse=[U,F.invert(U)],Pv(this),R.start()}fS(),R.wheel=setTimeout(W,d),R.zoom("mouse",r(x(y(F,z),R.mouse[0],R.mouse[1]),R.extent,a));function W(){R.wheel=null,R.end()}}function O(){if(f||!e.apply(this,arguments))return;var R=C(this,arguments),F=pd(Yr.view).on("mousemove.zoom",Z,!0).on("mouseup.zoom",rt,!0),z=iS(this),U=Yr.clientX,W=Yr.clientY;Int(Yr.view),sF(),R.mouse=[z,this.__zoom.invert(z)],Pv(this),R.start();function Z(){if(fS(),!R.moved){var ot=Yr.clientX-U,st=Yr.clientY-W;R.moved=ot*ot+st*st>g}R.zoom("mouse",r(x(R.that.__zoom,R.mouse[0]=iS(R.that),R.mouse[1]),R.extent,a))}function rt(){F.on("mousemove.zoom mouseup.zoom",null),Lnt(Yr.view,R.moved),fS(),R.end()}}function D(){if(!!e.apply(this,arguments)){var R=this.__zoom,F=iS(this),z=R.invert(F),U=R.k*(Yr.shiftKey?.5:2),W=r(x(y(R,U),F,z),t.apply(this,arguments),a);fS(),s>0?pd(this).transition().duration(s).call(S,W,F):pd(this).call(_.transform,W)}}function B(){if(!!e.apply(this,arguments)){var R=C(this,arguments),F=Yr.changedTouches,z,U=F.length,W,Z,rt;for(sF(),W=0;W<U;++W)Z=F[W],rt=Hz(this,F,Z.identifier),rt=[rt,this.__zoom.invert(rt),Z.identifier],R.touch0?R.touch1||(R.touch1=rt):(R.touch0=rt,z=!0);if(h&&(h=clearTimeout(h),!R.touch1)){R.end(),rt=pd(this).on("dblclick.zoom"),rt&&rt.apply(this,arguments);return}z&&(h=setTimeout(function(){h=null},p),Pv(this),R.start())}}function I(){var R=C(this,arguments),F=Yr.changedTouches,z=F.length,U,W,Z,rt;for(fS(),h&&(h=clearTimeout(h)),U=0;U<z;++U)W=F[U],Z=Hz(this,F,W.identifier),R.touch0&&R.touch0[2]===W.identifier?R.touch0[0]=Z:R.touch1&&R.touch1[2]===W.identifier&&(R.touch1[0]=Z);if(W=R.that.__zoom,R.touch1){var ot=R.touch0[0],st=R.touch0[1],St=R.touch1[0],bt=R.touch1[1],Mt=(Mt=St[0]-ot[0])*Mt+(Mt=St[1]-ot[1])*Mt,lt=(lt=bt[0]-st[0])*lt+(lt=bt[1]-st[1])*lt;W=y(W,Math.sqrt(Mt/lt)),Z=[(ot[0]+St[0])/2,(ot[1]+St[1])/2],rt=[(st[0]+bt[0])/2,(st[1]+bt[1])/2]}else if(R.touch0)Z=R.touch0[0],rt=R.touch0[1];else return;R.zoom("touch",r(x(W,Z,rt),R.extent,a))}function L(){var R=C(this,arguments),F=Yr.changedTouches,z=F.length,U,W;for(sF(),f&&clearTimeout(f),f=setTimeout(function(){f=null},p),U=0;U<z;++U)W=F[U],R.touch0&&R.touch0[2]===W.identifier?delete R.touch0:R.touch1&&R.touch1[2]===W.identifier&&delete R.touch1;R.touch1&&!R.touch0&&(R.touch0=R.touch1,delete R.touch1),R.touch0?R.touch0[1]=this.__zoom.invert(R.touch0[0]):R.end()}return _.wheelDelta=function(R){return arguments.length?(n=typeof R=="function"?R:zA(+R),_):n},_.filter=function(R){return arguments.length?(e=typeof R=="function"?R:zA(!!R),_):e},_.touchable=function(R){return arguments.length?(i=typeof R=="function"?R:zA(!!R),_):i},_.extent=function(R){return arguments.length?(t=typeof R=="function"?R:zA([[+R[0][0],+R[0][1]],[+R[1][0],+R[1][1]]]),_):t},_.scaleExtent=function(R){return arguments.length?(o[0]=+R[0],o[1]=+R[1],_):[o[0],o[1]]},_.translateExtent=function(R){return arguments.length?(a[0][0]=+R[0][0],a[1][0]=+R[1][0],a[0][1]=+R[0][1],a[1][1]=+R[1][1],_):[[a[0][0],a[0][1]],[a[1][0],a[1][1]]]},_.constrain=function(R){return arguments.length?(r=R,_):r},_.duration=function(R){return arguments.length?(s=+R,_):s},_.interpolate=function(R){return arguments.length?(l=R,_):l},_.on=function(){var R=u.on.apply(u,arguments);return R===u?_:R},_.clickDistance=function(R){return arguments.length?(g=(R=+R)*R,_):Math.sqrt(g)},_}var Gjt=M(()=>{mnt();cYt();AA();Is();Fjt();Bjt();Hjt();nit();Vjt()});var Wjt=M(()=>{Gjt();nit()});var Mr={};Ks(Mr,{active:()=>mGt,arc:()=>gFt,area:()=>b7,areaRadial:()=>ket,ascending:()=>_c,axisBottom:()=>ZMt,axisLeft:()=>JMt,axisRight:()=>KMt,axisTop:()=>$Mt,bisect:()=>sR,bisectLeft:()=>sMt,bisectRight:()=>x$,bisector:()=>aR,brush:()=>yCt,brushSelection:()=>mCt,brushX:()=>gCt,brushY:()=>_Ct,chord:()=>UCt,clientPoint:()=>Dg,cluster:()=>GLt,color:()=>x2,create:()=>tFt,creator:()=>Ng,cross:()=>cMt,csv:()=>pNt,csvFormat:()=>yPt,csvFormatRows:()=>vPt,csvParse:()=>gPt,csvParseRows:()=>_Pt,cubehelix:()=>uN,curveBasis:()=>OFt,curveBasisClosed:()=>FFt,curveBasisOpen:()=>VFt,curveBundle:()=>GFt,curveCardinal:()=>YFt,curveCardinalClosed:()=>jFt,curveCardinalOpen:()=>XFt,curveCatmullRom:()=>KFt,curveCatmullRomClosed:()=>JFt,curveCatmullRomOpen:()=>eBt,curveLinear:()=>Fg,curveLinearClosed:()=>iBt,curveMonotoneX:()=>hBt,curveMonotoneY:()=>fBt,curveNatural:()=>gBt,curveStep:()=>yBt,curveStepAfter:()=>xBt,curveStepBefore:()=>vBt,customEvent:()=>Xzt,descending:()=>hMt,deviation:()=>cR,dispatch:()=>kAt,drag:()=>hPt,dragDisable:()=>EN,dragEnable:()=>TN,dsvFormat:()=>w2,easeBack:()=>OZ,easeBackIn:()=>JPt,easeBackInOut:()=>OZ,easeBackOut:()=>QPt,easeBounce:()=>S2,easeBounceIn:()=>$Pt,easeBounceInOut:()=>KPt,easeBounceOut:()=>S2,easeCircle:()=>RZ,easeCircleIn:()=>YPt,easeCircleInOut:()=>RZ,easeCircleOut:()=>jPt,easeCubic:()=>AZ,easeCubicIn:()=>kPt,easeCubicInOut:()=>AZ,easeCubicOut:()=>RPt,easeElastic:()=>BZ,easeElasticIn:()=>e6t,easeElasticInOut:()=>r6t,easeElasticOut:()=>BZ,easeExp:()=>kZ,easeExpIn:()=>qPt,easeExpInOut:()=>kZ,easeExpOut:()=>GPt,easeLinear:()=>CPt,easePoly:()=>IZ,easePolyIn:()=>DPt,easePolyInOut:()=>IZ,easePolyOut:()=>OPt,easeQuad:()=>CZ,easeQuadIn:()=>PPt,easeQuadInOut:()=>CZ,easeQuadOut:()=>IPt,easeSin:()=>LZ,easeSinIn:()=>HPt,easeSinInOut:()=>LZ,easeSinOut:()=>VPt,entries:()=>hAt,event:()=>Pu,extent:()=>uR,forceCenter:()=>o6t,forceCollide:()=>F6t,forceLink:()=>j6t,forceManyBody:()=>lIt,forceRadial:()=>uIt,forceSimulation:()=>sIt,forceX:()=>fIt,forceY:()=>dIt,format:()=>rJ,formatDefaultLocale:()=>WN,formatLocale:()=>qN,formatPrefix:()=>nJ,formatSpecifier:()=>Ly,geoAlbers:()=>DD,geoAlbersUsa:()=>vLt,geoArea:()=>UIt,geoAzimuthalEqualArea:()=>bLt,geoAzimuthalEqualAreaRaw:()=>zD,geoAzimuthalEquidistant:()=>SLt,geoAzimuthalEquidistantRaw:()=>FD,geoBounds:()=>KIt,geoCentroid:()=>n9t,geoCircle:()=>u9t,geoClipAntimeridian:()=>zT,geoClipCircle:()=>_D,geoClipExtent:()=>R9t,geoClipRectangle:()=>Qp,geoConicConformal:()=>TLt,geoConicConformalRaw:()=>fQ,geoConicEqualArea:()=>Uy,geoConicEqualAreaRaw:()=>cQ,geoConicEquidistant:()=>PLt,geoConicEquidistantRaw:()=>dQ,geoContains:()=>V9t,geoDistance:()=>By,geoEquirectangular:()=>ALt,geoEquirectangularRaw:()=>Gy,geoGnomonic:()=>LLt,geoGnomonicRaw:()=>VD,geoGraticule:()=>SD,geoGraticule10:()=>W9t,geoIdentity:()=>RLt,geoInterpolate:()=>j9t,geoLength:()=>bD,geoMercator:()=>ELt,geoMercatorRaw:()=>qy,geoNaturalEarth1:()=>DLt,geoNaturalEarth1Raw:()=>qD,geoOrthographic:()=>zLt,geoOrthographicRaw:()=>GD,geoPath:()=>fLt,geoProjection:()=>eo,geoProjectionMutator:()=>YT,geoRotation:()=>lD,geoStereographic:()=>BLt,geoStereographicRaw:()=>WD,geoStream:()=>Mo,geoTransform:()=>dLt,geoTransverseMercator:()=>VLt,geoTransverseMercatorRaw:()=>YD,hcl:()=>iZ,hierarchy:()=>jT,histogram:()=>xMt,hsl:()=>ZK,html:()=>oNt,interpolate:()=>Z2,interpolateArray:()=>fO,interpolateBasis:()=>cO,interpolateBasisClosed:()=>hO,interpolateCool:()=>E7t,interpolateCubehelix:()=>q8t,interpolateCubehelixDefault:()=>w7t,interpolateCubehelixLong:()=>G8t,interpolateDate:()=>dO,interpolateHcl:()=>B8t,interpolateHclLong:()=>H8t,interpolateHsl:()=>N8t,interpolateHslLong:()=>D8t,interpolateInferno:()=>I7t,interpolateLab:()=>$Q,interpolateMagma:()=>P7t,interpolateNumber:()=>As,interpolateObject:()=>mO,interpolatePlasma:()=>L7t,interpolateRainbow:()=>T7t,interpolateRgb:()=>eC,interpolateRgbBasis:()=>m8t,interpolateRgbBasisClosed:()=>g8t,interpolateRound:()=>_8t,interpolateString:()=>gO,interpolateTransformCss:()=>T8t,interpolateTransformSvg:()=>C8t,interpolateViridis:()=>A7t,interpolateWarm:()=>M7t,interpolateZoom:()=>L8t,interrupt:()=>dz,interval:()=>EVt,isoFormat:()=>gVt,isoParse:()=>_Vt,json:()=>sNt,keys:()=>sAt,lab:()=>lN,line:()=>Rw,lineRadial:()=>Iet,linkHorizontal:()=>CFt,linkRadial:()=>PFt,linkVertical:()=>AFt,local:()=>m7,map:()=>by,matcher:()=>u7,max:()=>TMt,mean:()=>AMt,median:()=>IMt,merge:()=>kMt,min:()=>mR,mouse:()=>nFt,namespace:()=>Mw,namespaces:()=>EC,nest:()=>rAt,now:()=>Yw,pack:()=>Tkt,packEnclose:()=>$D,packSiblings:()=>wkt,pairs:()=>lMt,partition:()=>Akt,path:()=>K8t,permute:()=>NMt,pie:()=>SFt,pointRadial:()=>fv,polygonArea:()=>Q8t,polygonCentroid:()=>eRt,polygonContains:()=>lRt,polygonHull:()=>aRt,polygonLength:()=>uRt,precisionFixed:()=>AIt,precisionPrefix:()=>IIt,precisionRound:()=>kIt,quadtree:()=>xO,quantile:()=>dy,quantize:()=>Y8t,queue:()=>wO,radialArea:()=>ket,radialLine:()=>Iet,randomBates:()=>tNt,randomExponential:()=>rNt,randomIrwinHall:()=>MO,randomLogNormal:()=>JRt,randomNormal:()=>SO,randomUniform:()=>KRt,range:()=>hR,request:()=>J2,rgb:()=>KK,ribbon:()=>KCt,scaleBand:()=>cC,scaleIdentity:()=>qO,scaleImplicit:()=>kO,scaleLinear:()=>UO,scaleLog:()=>WO,scaleOrdinal:()=>nw,scalePoint:()=>YNt,scalePow:()=>_C,scaleQuantile:()=>YO,scaleQuantize:()=>jO,scaleSequential:()=>i7,scaleSqrt:()=>aOt,scaleThreshold:()=>XO,scaleTime:()=>h7t,scaleUtc:()=>f7t,scan:()=>OMt,schemeCategory10:()=>d7t,schemeCategory20:()=>x7t,schemeCategory20b:()=>g7t,schemeCategory20c:()=>y7t,select:()=>d7,selectAll:()=>oFt,selection:()=>Qzt,selector:()=>Ew,selectorAll:()=>c7,set:()=>oAt,shuffle:()=>FMt,stack:()=>wBt,stackOffsetDiverging:()=>TBt,stackOffsetExpand:()=>MBt,stackOffsetNone:()=>Ru,stackOffsetSilhouette:()=>ABt,stackOffsetWiggle:()=>IBt,stackOrderAscending:()=>D7,stackOrderDescending:()=>kBt,stackOrderInsideOut:()=>NBt,stackOrderNone:()=>Nu,stackOrderReverse:()=>OBt,stratify:()=>kkt,style:()=>_et,sum:()=>HMt,symbol:()=>NFt,symbolCircle:()=>RC,symbolCross:()=>S7,symbolDiamond:()=>M7,symbolSquare:()=>T7,symbolStar:()=>E7,symbolTriangle:()=>C7,symbolWye:()=>A7,symbols:()=>RFt,text:()=>cNt,thresholdFreedmanDiaconis:()=>wMt,thresholdScott:()=>MMt,thresholdSturges:()=>pR,tickIncrement:()=>k$,tickStep:()=>fR,ticks:()=>vMt,timeDay:()=>ZBt,timeDays:()=>JBt,timeFormat:()=>wrt,timeFormatDefaultLocale:()=>X7,timeFormatLocale:()=>YC,timeFriday:()=>ort,timeFridays:()=>iHt,timeHour:()=>jBt,timeHours:()=>XBt,timeInterval:()=>Sr,timeMillisecond:()=>Zet,timeMilliseconds:()=>Jet,timeMinute:()=>qBt,timeMinutes:()=>GBt,timeMonday:()=>ert,timeMondays:()=>tHt,timeMonth:()=>lHt,timeMonths:()=>cHt,timeParse:()=>Srt,timeSaturday:()=>art,timeSaturdays:()=>oHt,timeSecond:()=>Qet,timeSeconds:()=>trt,timeSunday:()=>H7,timeSundays:()=>srt,timeThursday:()=>irt,timeThursdays:()=>nHt,timeTuesday:()=>rrt,timeTuesdays:()=>eHt,timeWednesday:()=>nrt,timeWednesdays:()=>rHt,timeWeek:()=>H7,timeWeeks:()=>srt,timeYear:()=>hHt,timeYears:()=>fHt,timeout:()=>SVt,timer:()=>Crt,timerFlush:()=>Art,touch:()=>sFt,touches:()=>cFt,transition:()=>Tz,transpose:()=>gR,tree:()=>Nkt,treemap:()=>Okt,treemapBinary:()=>Fkt,treemapDice:()=>lf,treemapResquarify:()=>Ukt,treemapSlice:()=>wg,treemapSliceDice:()=>Hkt,treemapSquarify:()=>tO,tsv:()=>mNt,tsvFormat:()=>SPt,tsvFormatRows:()=>MPt,tsvParse:()=>bPt,tsvParseRows:()=>wPt,utcDay:()=>SHt,utcDays:()=>MHt,utcFormat:()=>jC,utcFriday:()=>prt,utcFridays:()=>IHt,utcHour:()=>vHt,utcHours:()=>xHt,utcMillisecond:()=>Zet,utcMilliseconds:()=>Jet,utcMinute:()=>mHt,utcMinutes:()=>gHt,utcMonday:()=>crt,utcMondays:()=>THt,utcMonth:()=>NHt,utcMonths:()=>DHt,utcParse:()=>XC,utcSaturday:()=>drt,utcSaturdays:()=>LHt,utcSecond:()=>Qet,utcSeconds:()=>trt,utcSunday:()=>V7,utcSundays:()=>mrt,utcThursday:()=>frt,utcThursdays:()=>PHt,utcTuesday:()=>urt,utcTuesdays:()=>CHt,utcWednesday:()=>hrt,utcWednesdays:()=>AHt,utcWeek:()=>V7,utcWeeks:()=>mrt,utcYear:()=>zHt,utcYears:()=>FHt,values:()=>cAt,variance:()=>lR,version:()=>iMt,voronoi:()=>DGt,window:()=>Cw,xml:()=>hNt,zip:()=>UMt,zoom:()=>qjt,zoomIdentity:()=>hS,zoomTransform:()=>aF});var Er=M(()=>{oMt();GMt();tEt();xCt();JCt();pAt();PAt();NAt();pPt();TPt();i6t();gIt();NIt();qLt();Gkt();X8t();J8t();fRt();GRt();$Rt();iNt();_Nt();N7t();hFt();FBt();HHt();vVt();CVt();_Gt();zGt();Wjt()});var $jt=H(Xjt=>{"use strict";Object.defineProperty(Xjt,"__esModule",{value:!0});var Yjt=(Er(),Ut(Mr)),Wg=Yjt,jjt=Yjt;function WDe(e,t){return e.each(function(){var r=t.apply(this,arguments),n=Wg.select(this);for(var i in r)n.attr(i,r[i])})}function YDe(e,t){for(var r in t)e.attr(r,t[r]);return e}function jDe(e){return(typeof e=="function"?WDe:YDe)(this,e)}function XDe(e,t,r){return e.each(function(){var n=t.apply(this,arguments),i=Wg.select(this);for(var o in n)i.style(o,n[o],r)})}function $De(e,t,r){for(var n in t)e.style(n,t[n],r);return e}function KDe(e,t){return(typeof e=="function"?XDe:$De)(this,e,t==null?"":t)}function ZDe(e,t){return e.each(function(){var r=t.apply(this,arguments),n=Wg.select(this);for(var i in r)n.property(i,r[i])})}function JDe(e,t){for(var r in t)e.property(r,t[r]);return e}function QDe(e){return(typeof e=="function"?ZDe:JDe)(this,e)}function tOe(e,t){return e.each(function(){var r=t.apply(this,arguments),n=Wg.select(this).transition(e);for(var i in r)n.attr(i,r[i])})}function eOe(e,t){for(var r in t)e.attr(r,t[r]);return e}function rOe(e){return(typeof e=="function"?tOe:eOe)(this,e)}function nOe(e,t,r){return e.each(function(){var n=t.apply(this,arguments),i=Wg.select(this).transition(e);for(var o in n)i.style(o,n[o],r)})}function iOe(e,t,r){for(var n in t)e.style(n,t[n],r);return e}function oOe(e,t){return(typeof e=="function"?nOe:iOe)(this,e,t==null?"":t)}Wg.selection.prototype.attrs=jDe;Wg.selection.prototype.styles=KDe;Wg.selection.prototype.properties=QDe;jjt.transition.prototype.attrs=rOe;jjt.transition.prototype.styles=oOe});var Yg=H(iit=>{"use strict";Object.defineProperty(iit,"__esModule",{value:!0});var Kjt=(Er(),Ut(Mr));function aOe(e){if(e.attrs==null)if(e.nodes==null){var t=[];return e.each(function(){t.push(this)}),Kjt.selectAll(t)}else return Kjt.selectAll(e.nodes());else return e}iit.coerceExternalD3=aOe});var If=H(oit=>{"use strict";Object.defineProperty(oit,"__esModule",{value:!0});function sOe(e){return e.reduce(function(t,r){return t[r]=r,t},{})}oit.makeEnum=sOe});var Jjt=H(lF=>{"use strict";Object.defineProperty(lF,"__esModule",{value:!0});var dr=(I_(),Ut(Bvt)),lOe=Yg(),cOe=If(),Zjt={linear:dr.easeLinear,quad:dr.easeQuad,quadIn:dr.easeQuadIn,quadOut:dr.easeQuadOut,quadInOut:dr.easeQuadInOut,cubic:dr.easeCubic,cubicIn:dr.easeCubicIn,cubicOut:dr.easeCubicOut,cubicInOut:dr.easeCubicInOut,poly:dr.easePoly,polyIn:dr.easePolyIn,polyOut:dr.easePolyOut,polyInOut:dr.easePolyInOut,sin:dr.easeSin,sinIn:dr.easeSinIn,sinOut:dr.easeSinOut,sinInOut:dr.easeSinInOut,exp:dr.easeExp,expIn:dr.easeExpIn,expOut:dr.easeExpOut,expInOut:dr.easeExpInOut,circle:dr.easeCircle,circleIn:dr.easeCircleIn,circleOut:dr.easeCircleOut,circleInOut:dr.easeCircleInOut,bounce:dr.easeBounce,bounceIn:dr.easeBounceIn,bounceOut:dr.easeBounceOut,bounceInOut:dr.easeBounceInOut,back:dr.easeBack,backIn:dr.easeBackIn,backOut:dr.easeBackOut,backInOut:dr.easeBackInOut,elastic:dr.easeElastic,elasticIn:dr.easeElasticIn,elasticOut:dr.easeElasticOut,elasticInOut:dr.easeElasticInOut};lF.EaseName=cOe.makeEnum(["linear","quad","quadIn","quadOut","quadInOut","cubic","cubicIn","cubicOut","cubicInOut","poly","polyIn","polyOut","polyInOut","sin","sinIn","sinOut","sinInOut","exp","expIn","expOut","expInOut","circle","circleIn","circleOut","circleInOut","bounce","bounceIn","bounceOut","bounceInOut","back","backIn","backOut","backInOut","elastic","elasticIn","elasticOut","elasticInOut"]);var uOe=function(){function e(){this._startDelay=e._DEFAULT_START_DELAY_MILLISECONDS,this._stepDuration=e._DEFAULT_STEP_DURATION_MILLISECONDS,this._stepDelay=e._DEFAULT_ITERATIVE_DELAY_MILLISECONDS,this._maxTotalDuration=e._DEFAULT_MAX_TOTAL_DURATION_MILLISECONDS,this._easingMode=e._DEFAULT_EASING_MODE}return e.prototype.totalTime=function(t){var r=this._getAdjustedIterativeDelay(t);return this.startDelay()+r*Math.max(t-1,0)+this.stepDuration()},e.prototype.animate=function(t,r){var n=this;t=lOe.coerceExternalD3(t);var i=t.size(),o=this._getAdjustedIterativeDelay(i);return t.transition().ease(this._getEaseFactory()).duration(this.stepDuration()).delay(function(a,s){return n.startDelay()+o*s}).attrs(r)},e.prototype.startDelay=function(t){return t==null?this._startDelay:(this._startDelay=t,this)},e.prototype.stepDuration=function(t){return t==null?Math.min(this._stepDuration,this._maxTotalDuration):(this._stepDuration=t,this)},e.prototype.stepDelay=function(t){return t==null?this._stepDelay:(this._stepDelay=t,this)},e.prototype.maxTotalDuration=function(t){return t==null?this._maxTotalDuration:(this._maxTotalDuration=t,this)},e.prototype.easingMode=function(t){return t==null?this._easingMode:(this._easingMode=t,this)},e.prototype._getEaseFactory=function(){var t=this.easingMode();if(typeof t=="string"){var r=Zjt[t];return r==null?Zjt.linear:r}else return t},e.prototype._getAdjustedIterativeDelay=function(t){var r=this.maxTotalDuration()-this.stepDuration();r=Math.max(r,0);var n=r/Math.max(t-1,1);return Math.min(this.stepDelay(),n)},e._DEFAULT_START_DELAY_MILLISECONDS=0,e._DEFAULT_STEP_DURATION_MILLISECONDS=300,e._DEFAULT_ITERATIVE_DELAY_MILLISECONDS=15,e._DEFAULT_MAX_TOTAL_DURATION_MILLISECONDS=1/0,e._DEFAULT_EASING_MODE="expOut",e}();lF.Easing=uOe});var Qjt=H(ait=>{"use strict";Object.defineProperty(ait,"__esModule",{value:!0});var hOe=Yg(),fOe=function(){function e(){}return e.prototype.totalTime=function(t){return 0},e.prototype.animate=function(t,r){return t=hOe.coerceExternalD3(t),t.attrs(r)},e}();ait.Null=fOe});var Lf=H(cF=>{"use strict";Object.defineProperty(cF,"__esModule",{value:!0});var tXt=(de(),Ut(pe));tXt.__exportStar(Jjt(),cF);tXt.__exportStar(Qjt(),cF)});var eXt=H(sit=>{"use strict";Object.defineProperty(sit,"__esModule",{value:!0});var pOe=function(){function e(t){this.cache={},this.compute=t}return e.prototype.get=function(t){return this.cache.hasOwnProperty(t)||(this.cache[t]=this.compute(t)),this.cache[t]},e.prototype.clear=function(){return this.cache={},this},e}();sit.Cache=pOe});var rXt=H(lit=>{"use strict";Object.defineProperty(lit,"__esModule",{value:!0});var dOe=function(){function e(){}return e.arrayEq=function(t,r){if(t==null||r==null)return t===r;if(t.length!==r.length)return!1;for(var n=0;n<t.length;n++)if(t[n]!==r[n])return!1;return!0},e.objEq=function(t,r){if(t==null||r==null)return t===r;var n=Object.keys(t).sort(),i=Object.keys(r).sort(),o=n.map(function(s){return t[s]}),a=i.map(function(s){return r[s]});return e.arrayEq(n,i)&&e.arrayEq(o,a)},e.strictEq=function(t,r){return t===r},e.defaults=function(t){for(var r=[],n=1;n<arguments.length;n++)r[n-1]=arguments[n];if(t==null)throw new TypeError("Cannot convert undefined or null to object");var i=Object(t);return r.forEach(function(o){if(o!=null)for(var a in o)Object.prototype.hasOwnProperty.call(o,a)&&(i[a]=o[a])}),i},e}();lit.Methods=dOe});var nXt=H(cit=>{"use strict";Object.defineProperty(cit,"__esModule",{value:!0});var mOe=function(){function e(){}return e.combineWhitespace=function(t){return t.replace(/[ \t]+/g," ")},e.isNotEmptyString=function(t){return t&&t.trim()!==""},e.trimStart=function(t,r){if(!t)return t;var n=t.split(""),i=r?function(o){return o.split(r).some(e.isNotEmptyString)}:e.isNotEmptyString;return n.reduce(function(o,a){return i(o+a)?o+a:o},"")},e.trimEnd=function(t,r){if(!t)return t;var n=t.split("");return n.reverse(),n=e.trimStart(n.join(""),r).split(""),n.reverse(),n.join("")},e}();cit.StringMethods=mOe});var iXt=H(uit=>{"use strict";Object.defineProperty(uit,"__esModule",{value:!0});var gOe=function(){function e(){this.WordDividerRegExp=new RegExp("\\W"),this.WhitespaceRegExp=new RegExp("\\s")}return e.prototype.tokenize=function(t){var r=this;return t.split("").reduce(function(n,i){return n.slice(0,-1).concat(r.shouldCreateNewToken(n[n.length-1],i))},[""])},e.prototype.shouldCreateNewToken=function(t,r){if(!t)return[r];var n=t[t.length-1];return this.WhitespaceRegExp.test(n)&&this.WhitespaceRegExp.test(r)?[t+r]:this.WhitespaceRegExp.test(n)||this.WhitespaceRegExp.test(r)?[t,r]:this.WordDividerRegExp.test(n)?n===r?[t+r]:[t,r]:[t+r]},e}();uit.Tokenizer=gOe});var pS=H(uF=>{"use strict";function hF(e){for(var t in e)uF.hasOwnProperty(t)||(uF[t]=e[t])}Object.defineProperty(uF,"__esModule",{value:!0});hF(eXt());hF(rXt());hF(nXt());hF(iXt())});var aXt=H(hit=>{"use strict";Object.defineProperty(hit,"__esModule",{value:!0});var oXt=pS(),_Oe={textRotation:0,textShear:0,xAlign:"left",yAlign:"top"},fF=function(){function e(t,r,n){this._measurer=t,this._penFactory=r,this._wrapper=n}return e.prototype.measurer=function(t){return this._measurer=t,this},e.prototype.wrapper=function(t){return this._wrapper=t,this},e.prototype.penFactory=function(t){return this._penFactory=t,this},e.prototype.write=function(t,r,n,i,o){if(i===void 0&&(i={}),i=oXt.Methods.defaults({},_Oe,i),e.SupportedRotation.indexOf(i.textRotation)===-1)throw new Error("unsupported rotation - "+i.textRotation+". Supported rotations are "+e.SupportedRotation.join(", "));if(i.textShear!=null&&i.textShear<-80||i.textShear>80)throw new Error("unsupported shear angle - "+i.textShear+". Must be between -80 and 80");var a=Math.abs(Math.abs(i.textRotation)-90)>45,s=a?r:n,l=a?n:r,c=i.textShear,u=c*Math.PI/180,h=this._measurer.measure().height,f=h*Math.tan(u),p=s/Math.cos(u)-Math.abs(f),d=l*Math.cos(u),g=oXt.StringMethods.combineWhitespace(t),_=this._wrapper?this._wrapper.wrap(g,this._measurer,p,d).wrappedText:g,y=_.split(`
`),x=e.XOffsetFactor[i.xAlign]*p*Math.sin(u),b=e.YOffsetFactor[i.yAlign]*(d-y.length*h),S=x-b,C=[0,0],P=i.textRotation+c;switch(i.textRotation){case 90:C=[r+S,0];break;case-90:C=[-S,n];break;case 180:C=[r,n+S];break;default:C=[0,-S];break}var k=this._penFactory.createPen(t,{translate:C,rotate:P},o);this.writeLines(y,k,p,h,f,i.xAlign),k.destroy!=null&&k.destroy()},e.prototype.writeLines=function(t,r,n,i,o,a){t.forEach(function(s,l){var c=o>0?(l+1)*o:l*o;r.write(s,n,a,c,(l+1)*i)})},e}();fF.XOffsetFactor={center:.5,left:0,right:1};fF.YOffsetFactor={bottom:1,center:.5,top:0};fF.SupportedRotation=[-90,0,180,90];hit.Writer=fF});var FA=H(pF=>{"use strict";function yOe(e){for(var t in e)pF.hasOwnProperty(t)||(pF[t]=e[t])}Object.defineProperty(pF,"__esModule",{value:!0});yOe(aXt())});var fit=H(dF=>{"use strict";Object.defineProperty(dF,"__esModule",{value:!0});var BA=function(){function e(){}return e.append=function(t,r){for(var n=[],i=2;i<arguments.length;i++)n[i-2]=arguments[i];var o=e.create.apply(e,[r].concat(n));return t.appendChild(o),o},e.create=function(t){for(var r=[],n=1;n<arguments.length;n++)r[n-1]=arguments[n];var i=document.createElement(t);return e.addClasses.apply(e,[i].concat(r)),i},e.addClasses=function(t){for(var r=[],n=1;n<arguments.length;n++)r[n-1]=arguments[n];r=r.filter(function(i){return i!=null}),t.classList!=null?r.forEach(function(i){t.classList.add(i)}):t.setAttribute("class",r.join(" "))},e.getDimensions=function(t){if(t.getBoundingClientRect)try{var r=t.getBoundingClientRect(),n=r.width,i=r.height;return{width:n,height:i}}catch(o){}return{height:0,width:0}},e}();dF.HtmlUtils=BA;var vOe=function(){function e(t,r,n){n===void 0&&(n=!1);var i=this;this.element=t,this.className=r,this.addTitle=n,this.createRuler=function(){return function(o){var a=BA.append(i.element,"span","text-tmp",i.className);a.textContent=o;var s=BA.getDimensions(a);return i.element.removeChild(a),s}},this.createPen=function(o,a,s){s==null&&(s=i.element);var l=BA.append(s,"div","text-block",i.className);return l.style.position="relative",l.style.transform="translate(0, -1em) "+("translate("+a.translate[0]+"px, "+a.translate[1]+"px) ")+("rotate("+a.rotate+"deg)"),l.style.transformOrigin="0 1.2em",i.addTitle&&l.setAttribute("title",o),i.createHtmlLinePen(l)}}return e.prototype.setAddTitle=function(t){this.addTitle=t},e.prototype.createHtmlLinePen=function(t){return{write:function(r,n,i,o,a){var s=BA.append(t,"div","text-line");s.textContent=r,s.style.width=n+"px",s.style.textAlign=i,s.style.position="absolute",s.style.whiteSpace="nowrap",s.style.top=a+"px",s.style.left=o+"px"}}},e}();dF.HtmlContext=vOe});var cXt=H(mF=>{"use strict";Object.defineProperty(mF,"__esModule",{value:!0});var xOe=FA(),sXt=fit(),jg=function(){function e(){}return e.append=function(t,r){for(var n=[],i=2;i<arguments.length;i++)n[i-2]=arguments[i];var o=e.create.apply(e,[r].concat(n));return t.appendChild(o),o},e.create=function(t){for(var r=[],n=1;n<arguments.length;n++)r[n-1]=arguments[n];var i=document.createElementNS(e.SVG_NS,t);return sXt.HtmlUtils.addClasses.apply(sXt.HtmlUtils,[i].concat(r)),i},e.getDimensions=function(t){if(t.getBBox)try{var r=t.getBBox(),n=r.width,i=r.height;return{width:n,height:i}}catch(o){}return{height:0,width:0}},e}();jg.SVG_NS="http://www.w3.org/2000/svg";mF.SvgUtils=jg;var lXt=function(){function e(t,r,n){n===void 0&&(n=!1);var i=this;this.element=t,this.className=r,this.addTitleElement=n,this.createRuler=function(){var o=i.getTextElements(i.element),a=o.parentElement,s=o.containerElement,l=o.textElement;return function(c){a.appendChild(s),l.textContent=c;var u=jg.getDimensions(l);return a.removeChild(s),u}},this.createPen=function(o,a,s){s==null&&(s=i.element);var l=jg.append(s,"g","text-container",i.className);i.addTitleElement&&(jg.append(l,"title").textContent=o,l.setAttribute("title",o));var c=jg.append(l,"g","text-area");return c.setAttribute("transform","translate("+a.translate[0]+","+a.translate[1]+")"+("rotate("+a.rotate+")")),i.createSvgLinePen(c)}}return e.prototype.setAddTitleElement=function(t){this.addTitleElement=t},e.prototype.createSvgLinePen=function(t){return{write:function(r,n,i,o,a){o+=n*xOe.Writer.XOffsetFactor[i];var s=jg.append(t,"text","text-line");s.textContent=r,s.setAttribute("text-anchor",e.AnchorMap[i]),s.setAttribute("transform","translate("+o+","+a+")"),s.setAttribute("y","-0.25em")}}},e.prototype.getTextElements=function(t){if(t.tagName==="text"){var r=t.parentElement;return r==null&&(r=t.parentNode),r.removeChild(t),{containerElement:t,parentElement:r,textElement:t}}var n=t.querySelector("text");if(n!=null){var r=n.parentElement;return r==null&&(r=n.parentNode),r.removeChild(n),{containerElement:n,parentElement:r,textElement:n}}var i=jg.create("text",this.className);return{containerElement:i,parentElement:t,textElement:i}},e}();lXt.AnchorMap={center:"middle",left:"start",right:"end"};mF.SvgContext=lXt});var uXt=H(pit=>{"use strict";Object.defineProperty(pit,"__esModule",{value:!0});var bOe=FA(),wOe="#444",SOe=function(){function e(t,r,n){r===void 0&&(r=10),n===void 0&&(n={});var i=this;this.ctx=t,this.lineHeight=r,this.style=n,this.createRuler=function(){return function(o){i.ctx.font=i.style.font;var a=i.ctx.measureText(o).width;return{width:a,height:i.lineHeight}}},this.createPen=function(o,a,s){return s==null&&(s=i.ctx),s.save(),s.translate(a.translate[0],a.translate[1]),s.rotate(a.rotate*Math.PI/180),i.createCanvasPen(s)},this.style.fill===void 0&&(this.style.fill=wOe)}return e.prototype.createCanvasPen=function(t){var r=this;return{destroy:function(){t.restore()},write:function(n,i,o,a,s){a+=i*bOe.Writer.XOffsetFactor[o],t.textAlign=o,r.style.font!=null&&(t.font=r.style.font),r.style.fill!=null&&(t.fillStyle=r.style.fill,t.fillText(n,a,s)),r.style.stroke!=null&&(t.strokeStyle=r.style.fill,t.strokeText(n,a,s))}}},e}();pit.CanvasContext=SOe});var mit=H(gF=>{"use strict";function dit(e){for(var t in e)gF.hasOwnProperty(t)||(gF[t]=e[t])}Object.defineProperty(gF,"__esModule",{value:!0});dit(cXt());dit(uXt());dit(fit())});var _F=H(git=>{"use strict";Object.defineProperty(git,"__esModule",{value:!0});var hXt=function(){function e(t){t.createRuler!=null?this.ruler=t.createRuler():this.ruler=t}return e.prototype.measure=function(t){return t===void 0&&(t=e.HEIGHT_TEXT),this.ruler(t)},e}();hXt.HEIGHT_TEXT="bdpql";git.AbstractMeasurer=hXt});var _it=H(HA=>{"use strict";var MOe=HA&&HA.__extends||function(){var e=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(t,r){t.__proto__=r}||function(t,r){for(var n in r)r.hasOwnProperty(n)&&(t[n]=r[n])};return function(t,r){e(t,r);function n(){this.constructor=t}t.prototype=r===null?Object.create(r):(n.prototype=r.prototype,new n)}}();Object.defineProperty(HA,"__esModule",{value:!0});var yF=_F(),EOe=function(e){MOe(t,e);function t(r,n){n===void 0&&(n=!1);var i=e.call(this,r)||this;return i.useGuards=n,i}return t.prototype._addGuards=function(r){return yF.AbstractMeasurer.HEIGHT_TEXT+r+yF.AbstractMeasurer.HEIGHT_TEXT},t.prototype._measureLine=function(r,n){n===void 0&&(n=!1);var i=this.useGuards||n||/^[\t ]$/.test(r),o=i?this._addGuards(r):r,a=e.prototype.measure.call(this,o);return a.width-=i?2*this.getGuardWidth():0,a},t.prototype.measure=function(r){var n=this;if(r===void 0&&(r=yF.AbstractMeasurer.HEIGHT_TEXT),r.trim()==="")return{width:0,height:0};var i=r.trim().split(`
`).map(function(o){return n._measureLine(o)});return{height:i.reduce(function(o,a){return o+a.height},0),width:i.reduce(function(o,a){return Math.max(o,a.width)},0)}},t.prototype.getGuardWidth=function(){return this.guardWidth==null&&(this.guardWidth=e.prototype.measure.call(this).width),this.guardWidth},t}(yF.AbstractMeasurer);HA.Measurer=EOe});var yit=H(VA=>{"use strict";var TOe=VA&&VA.__extends||function(){var e=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(t,r){t.__proto__=r}||function(t,r){for(var n in r)r.hasOwnProperty(n)&&(t[n]=r[n])};return function(t,r){e(t,r);function n(){this.constructor=t}t.prototype=r===null?Object.create(r):(n.prototype=r.prototype,new n)}}();Object.defineProperty(VA,"__esModule",{value:!0});var COe=_it(),AOe=function(e){TOe(t,e);function t(){return e!==null&&e.apply(this,arguments)||this}return t.prototype._measureCharacter=function(r){return e.prototype._measureLine.call(this,r)},t.prototype._measureLine=function(r){var n=this,i=r.split("").map(function(o){return n._measureCharacter(o)});return{height:i.reduce(function(o,a){return Math.max(o,a.height)},0),width:i.reduce(function(o,a){return o+a.width},0)}},t}(COe.Measurer);VA.CharacterMeasurer=AOe});var vit=H(UA=>{"use strict";var POe=UA&&UA.__extends||function(){var e=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(t,r){t.__proto__=r}||function(t,r){for(var n in r)r.hasOwnProperty(n)&&(t[n]=r[n])};return function(t,r){e(t,r);function n(){this.constructor=t}t.prototype=r===null?Object.create(r):(n.prototype=r.prototype,new n)}}();Object.defineProperty(UA,"__esModule",{value:!0});var IOe=pS(),LOe=yit(),kOe=function(e){POe(t,e);function t(r,n){var i=e.call(this,r,n)||this;return i.cache=new IOe.Cache(function(o){return i._measureCharacterNotFromCache(o)}),i}return t.prototype._measureCharacterNotFromCache=function(r){return e.prototype._measureCharacter.call(this,r)},t.prototype._measureCharacter=function(r){return this.cache.get(r)},t.prototype.reset=function(){this.cache.clear()},t}(LOe.CharacterMeasurer);UA.CacheCharacterMeasurer=kOe});var fXt=H(qA=>{"use strict";var ROe=qA&&qA.__extends||function(){var e=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(t,r){t.__proto__=r}||function(t,r){for(var n in r)r.hasOwnProperty(n)&&(t[n]=r[n])};return function(t,r){e(t,r);function n(){this.constructor=t}t.prototype=r===null?Object.create(r):(n.prototype=r.prototype,new n)}}();Object.defineProperty(qA,"__esModule",{value:!0});var NOe=pS(),DOe=_F(),OOe=vit(),zOe=function(e){ROe(t,e);function t(r){var n=e.call(this,r)||this;return n.dimCache=new NOe.Cache(function(i){return n._measureNotFromCache(i)}),n}return t.prototype._measureNotFromCache=function(r){return e.prototype.measure.call(this,r)},t.prototype.measure=function(r){return r===void 0&&(r=DOe.AbstractMeasurer.HEIGHT_TEXT),this.dimCache.get(r)},t.prototype.reset=function(){this.dimCache.clear(),e.prototype.reset.call(this)},t}(OOe.CacheCharacterMeasurer);qA.CacheMeasurer=zOe});var xit=H(vF=>{"use strict";function GA(e){for(var t in e)vF.hasOwnProperty(t)||(vF[t]=e[t])}Object.defineProperty(vF,"__esModule",{value:!0});GA(_F());GA(vit());GA(fXt());GA(yit());GA(_it())});var wit=H(bit=>{"use strict";Object.defineProperty(bit,"__esModule",{value:!0});var WA=pS(),FOe=function(){function e(){this.maxLines(1/0),this.textTrimming("ellipsis"),this.allowBreakingWords(!1),this._tokenizer=new WA.Tokenizer,this._breakingCharacter="-"}return e.prototype.maxLines=function(t){return t==null?this._maxLines:(this._maxLines=t,this)},e.prototype.textTrimming=function(t){if(t==null)return this._textTrimming;if(t!=="ellipsis"&&t!=="none")throw new Error(t+" - unsupported text trimming option.");return this._textTrimming=t,this},e.prototype.allowBreakingWords=function(t){return t==null?this._allowBreakingWords:(this._allowBreakingWords=t,this)},e.prototype.wrap=function(t,r,n,i){var o=this;i===void 0&&(i=1/0);var a={noBrokeWords:0,noLines:0,originalText:t,truncatedText:"",wrappedText:""},s={availableLines:Math.min(Math.floor(i/r.measure().height),this._maxLines),availableWidth:n,canFitText:!0,currentLine:"",wrapping:a},l=t.split(`
`);return l.reduce(function(c,u,h){return o.breakLineToFitWidth(c,u,h!==l.length-1,r)},s).wrapping},e.prototype.breakLineToFitWidth=function(t,r,n,i){var o=this;!t.canFitText&&t.wrapping.truncatedText!==""&&(t.wrapping.truncatedText+=`
`);var a=this._tokenizer.tokenize(r);t=a.reduce(function(l,c){return o.wrapNextToken(c,l,i)},t);var s=WA.StringMethods.trimEnd(t.currentLine);return t.wrapping.noLines+=+(s!==""),t.wrapping.noLines===t.availableLines&&this._textTrimming!=="none"&&n?t.canFitText=!1:t.wrapping.wrappedText+=s,t.currentLine=`
`,t},e.prototype.canFitToken=function(t,r,n){var i=this,o=t.split("").map(function(a,s){return s!==t.length-1?a+i._breakingCharacter:a});return n.measure(t).width<=r||o.every(function(a){return n.measure(a).width<=r})},e.prototype.addEllipsis=function(t,r,n){if(this._textTrimming==="none")return{remainingToken:"",wrappedToken:t};var i=t.substring(0).trim(),o=n.measure(i).width,a=n.measure("...").width,s=t.length>0&&t[0]===`
`?`
`:"";if(r<=a){var l=a/3,c=Math.floor(r/l);return{remainingToken:t,wrappedToken:s+"...".substr(0,c)}}for(;o+a>r;)i=WA.StringMethods.trimEnd(i.substr(0,i.length-1)),o=n.measure(i).width;return{remainingToken:WA.StringMethods.trimEnd(t.substring(i.length),"-").trim(),wrappedToken:s+i+"..."}},e.prototype.wrapNextToken=function(t,r,n){if(!r.canFitText||r.availableLines===r.wrapping.noLines||!this.canFitToken(t,r.availableWidth,n))return this.finishWrapping(t,r,n);for(var i=t;i;){var o=this.breakTokenToFitInWidth(i,r.currentLine,r.availableWidth,n);if(r.currentLine=o.line,i=o.remainingToken,i!=null)if(r.wrapping.noBrokeWords+=+o.breakWord,++r.wrapping.noLines,r.availableLines===r.wrapping.noLines){var a=this.addEllipsis(r.currentLine,r.availableWidth,n);return r.wrapping.wrappedText+=a.wrappedToken,r.wrapping.truncatedText+=a.remainingToken+i,r.currentLine=`
`,r}else r.wrapping.wrappedText+=WA.StringMethods.trimEnd(r.currentLine),r.currentLine=`
`}return r},e.prototype.finishWrapping=function(t,r,n){if(r.canFitText&&r.availableLines!==r.wrapping.noLines&&this._textTrimming!=="none"){var i=this.addEllipsis(r.currentLine+t,r.availableWidth,n);r.wrapping.wrappedText+=i.wrappedToken,r.wrapping.truncatedText+=i.remainingToken,r.wrapping.noBrokeWords+=+(i.remainingToken.length<t.length),r.wrapping.noLines+=+(i.wrappedToken.length>0),r.currentLine=""}else r.wrapping.truncatedText+=t;return r.canFitText=!1,r},e.prototype.breakTokenToFitInWidth=function(t,r,n,i,o){if(o===void 0&&(o=this._breakingCharacter),i.measure(r+t).width<=n)return{breakWord:!1,line:r+t,remainingToken:null};if(t.trim()==="")return{breakWord:!1,line:r,remainingToken:""};if(!this._allowBreakingWords&&r.trim()!=="")return{breakWord:!1,line:r,remainingToken:t};for(var a=0;a<t.length&&i.measure(r+t.substring(0,a+1)+o).width<=n;)++a;var s="";return a>0&&(s=o),{breakWord:a>0,line:r+t.substring(0,a)+s,remainingToken:t.substring(a)}},e}();bit.Wrapper=FOe});var dXt=H(YA=>{"use strict";var BOe=YA&&YA.__extends||function(){var e=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(t,r){t.__proto__=r}||function(t,r){for(var n in r)r.hasOwnProperty(n)&&(t[n]=r[n])};return function(t,r){e(t,r);function n(){this.constructor=t}t.prototype=r===null?Object.create(r):(n.prototype=r.prototype,new n)}}();Object.defineProperty(YA,"__esModule",{value:!0});var HOe=wit(),pXt=function(e){BOe(t,e);function t(){return e!==null&&e.apply(this,arguments)||this}return t.prototype.wrap=function(r,n,i,o){var a=this;o===void 0&&(o=1/0);var s=r.split(`
`);if(s.length>1)throw new Error("SingleLineWrapper is designed to work only on single line");var l=function(g){return e.prototype.wrap.call(a,r,n,g,o)},c=l(i);if(c.noLines<2)return c;for(var u=0,h=i,f=0;f<t.NO_WRAP_ITERATIONS&&h>u;++f){var p=(h+u)/2,d=l(p);this.areSameResults(c,d)?(h=p,c=d):u=p}return c},t.prototype.areSameResults=function(r,n){return r.noLines===n.noLines&&r.truncatedText===n.truncatedText},t}(HOe.Wrapper);pXt.NO_WRAP_ITERATIONS=5;YA.SingleLineWrapper=pXt});var Sit=H(xF=>{"use strict";function mXt(e){for(var t in e)xF.hasOwnProperty(t)||(xF[t]=e[t])}Object.defineProperty(xF,"__esModule",{value:!0});mXt(dXt());mXt(wit())});var gXt=H(Eit=>{"use strict";Object.defineProperty(Eit,"__esModule",{value:!0});var Mit=mit(),VOe=xit(),UOe=Sit(),qOe=FA(),GOe=function(){function e(t){this.context=t,this.measurer=new VOe.CacheMeasurer(this.context),this.wrapper=new UOe.Wrapper,this.writer=new qOe.Writer(this.measurer,this.context,this.wrapper)}return e.svg=function(t,r,n){return new e(new Mit.SvgContext(t,r,n))},e.canvas=function(t,r,n){return new e(new Mit.CanvasContext(t,r,n))},e.html=function(t,r,n){return new e(new Mit.HtmlContext(t,r,n))},e.prototype.write=function(t,r,n,i,o){this.writer.write(t,r,n,i,o)},e.prototype.clearMeasurerCache=function(){this.measurer.reset()},e}();Eit.Typesetter=GOe});var _l=H(bF=>{"use strict";function dS(e){for(var t in e)bF.hasOwnProperty(t)||(bF[t]=e[t])}Object.defineProperty(bF,"__esModule",{value:!0});dS(mit());dS(xit());dS(gXt());dS(pS());dS(Sit());dS(FA())});var _Xt=H(mS=>{"use strict";Object.defineProperty(mS,"__esModule",{value:!0});var WOe=(Er(),Ut(Mr)),YOe=window.Array;function jOe(e,t){if(e.length!==t.length)throw new Error("attempted to add arrays of unequal length");return e.map(function(r,n){return e[n]+t[n]})}mS.add=jOe;function XOe(e){var t=WOe.set(),r=[];return e.forEach(function(n){t.has(String(n))||(t.add(String(n)),r.push(n))}),r}mS.uniq=XOe;function $Oe(e){return YOe.prototype.concat.apply([],e)}mS.flatten=$Oe;function KOe(e,t){for(var r=[],n=0;n<t;n++)r[n]=typeof e=="function"?e(n):e;return r}mS.createFilledArray=KOe});var xXt=H(jA=>{"use strict";Object.defineProperty(jA,"__esModule",{value:!0});var vXt=(Er(),Ut(Mr)),ZOe=window.Math;function JOe(e,t){var r=yXt(e)+.05,n=yXt(t)+.05;return r>n?r/n:n/r}jA.contrast=JOe;function QOe(e,t){var r=vXt.color(e).brighter(t);return r.rgb().toString()}jA.lightenColor=QOe;function t7e(e,t){e.classed(t,!0);var r=e.style("background-color");if(r==="transparent")return null;var n=/\((.+)\)/.exec(r);if(!n)return null;var i=n[1].split(",").map(function(a){var s=+a,l=s.toString(16);return s<16?"0"+l:l});if(i.length===4&&i[3]==="00")return null;var o="#"+i.join("");return e.classed(t,!1),o}jA.colorTest=t7e;function yXt(e){var t=vXt.rgb(e),r=function(a){return a=a/255,a<=.03928?a/12.92:ZOe.pow((a+.055)/1.055,2.4)},n=r(t.r),i=r(t.g),o=r(t.b);return .2126*n+.7152*i+.0722*o}});var Cit=H(ao=>{"use strict";Object.defineProperty(ao,"__esModule",{value:!0});var Tit=(Er(),Ut(Mr)),ma=window.Math;function e7e(e,t){for(var r=t;r!=null&&r!==e;)r=r.parentNode;return r===e}ao.contains=e7e;function wXt(e){var t;try{t=e.node().getBBox()}catch(r){t={x:0,y:0,width:0,height:0}}return t}ao.elementBBox=wXt;function r7e(e){if(e instanceof SVGElement)return wXt(Tit.select(e));if(e instanceof HTMLElement){var t=e.getBoundingClientRect();return{x:t.left,y:t.top,width:t.width,height:t.height}}else return{x:0,y:0,width:0,height:0}}ao.entityBounds=r7e;ao.SCREEN_REFRESH_RATE_MILLISECONDS=1e3/60;function n7e(e){window.requestAnimationFrame!=null?window.requestAnimationFrame(e):setTimeout(e,ao.SCREEN_REFRESH_RATE_MILLISECONDS)}ao.requestAnimationFramePolyfill=n7e;function i7e(e){var t=e instanceof Tit.selection?e.node():e,r=window.getComputedStyle(t);return kf(r,"width")+kf(r,"padding-left")+kf(r,"padding-right")+kf(r,"border-left-width")+kf(r,"border-right-width")}ao.elementWidth=i7e;function o7e(e){var t=e instanceof Tit.selection?e.node():e,r=window.getComputedStyle(t);return kf(r,"height")+kf(r,"padding-top")+kf(r,"padding-bottom")+kf(r,"border-top-width")+kf(r,"border-bottom-width")}ao.elementHeight=o7e;var Lc="\\s",XA="(?:[-+]?[0-9]*\\.?[0-9]+)",SXt="(?:(?:"+Lc+"+,?"+Lc+"*)|(?:,"+Lc+"*))",a7e=new RegExp("translate"+Lc+"*\\("+Lc+"*("+XA+")(?:"+SXt+"("+XA+"))?"+Lc+"*\\)"),s7e=new RegExp("rotate"+Lc+"*\\("+Lc+"*("+XA+")"+Lc+"*\\)"),l7e=new RegExp("scale"+Lc+"*\\("+Lc+"*("+XA+")(?:"+SXt+"("+XA+"))?"+Lc+"*\\)");function c7e(e){var t=a7e.exec(e.attr("transform"));if(t!=null){var r=t[1],n=t[2],i=n===void 0?0:n;return[+r,+i]}else return[0,0]}ao.getTranslateValues=c7e;function u7e(e){var t=s7e.exec(e.attr("transform"));if(t!=null){var r=t[1];return+r}else return 0}ao.getRotate=u7e;function h7e(e){var t=l7e.exec(e.attr("transform"));if(t!=null){var r=t[1],n=t[2];return[+r,n==null?+r:+n]}else return[0,0]}ao.getScaleValues=h7e;function f7e(e,t){return!(ma.floor(e.right)<=ma.ceil(t.left)||ma.ceil(e.left)>=ma.floor(t.right)||ma.floor(e.bottom)<=ma.ceil(t.top)||ma.ceil(e.top)>=ma.floor(t.bottom))}ao.clientRectsOverlap=f7e;function p7e(e,t){return{left:e.left-t,top:e.top-t,right:e.right+t,bottom:e.bottom+t,width:e.width+t*2,height:e.height+t*2}}ao.expandRect=p7e;function d7e(e,t){return ma.floor(t.left)<=ma.ceil(e.left)&&ma.floor(t.top)<=ma.ceil(e.top)&&ma.floor(e.right)<=ma.ceil(t.right)&&ma.floor(e.bottom)<=ma.ceil(t.bottom)}ao.clientRectInside=d7e;function m7e(e,t,r,n){n===void 0&&(n=.5);var i=bXt(e),o=bXt(t);return r.x+r.width>=i.min-n&&r.x<=i.max+n&&r.y+r.height>=o.min-n&&r.y<=o.max+n}ao.intersectsBBox=m7e;function bXt(e){if(typeof e=="number"){var t=e;return{min:t,max:t}}var r=e;if(r instanceof Object&&"min"in r&&"max"in r)return r;throw new Error("input '"+e+"' can't be parsed as an Range")}function kf(e,t){var r=e.getPropertyValue(t),n=parseFloat(r);return n||0}function g7e(e){for(var t=[];e&&e instanceof HTMLElement;)t.push(e),e=e.parentElement;return t}ao.getHtmlElementAncestors=g7e;function _7e(e){var t=window.getComputedStyle(e,null),r=t.getPropertyValue("-webkit-transform")||t.getPropertyValue("-moz-transform")||t.getPropertyValue("-ms-transform")||t.getPropertyValue("-o-transform")||t.getPropertyValue("transform");return x7e(r)}ao.getElementTransform=_7e;var y7e=/^matrix\(([^)]+)\)$/,v7e=/[, ]+/;function x7e(e){if(e==null||e==="none")return null;var t=e.match(y7e);if(t==null||t.length<2)return null;var r=t[1].split(v7e).map(function(n){return parseFloat(n)});return r.length!=6?null:r}});var Ait=H(so=>{"use strict";Object.defineProperty(so,"__esModule",{value:!0});var SF=(Er(),Ut(Mr)),MXt=Cit(),md=window.Math,b7e=[1,0,0,1,0,0];function w7e(e,t,r){return md.min(t,r)<=e&&e<=md.max(t,r)}so.inRange=w7e;function S7e(e,t,r){return md.min(md.max(t,e),r)}so.clamp=S7e;function M7e(e,t,r){var n=typeof t=="function"?t:null,i=n==null?t:r,o=n==null?SF.max(e):SF.max(e,n);return o!==void 0?o:i}so.max=M7e;function E7e(e,t,r){var n=typeof t=="function"?t:null,i=n==null?t:r,o=n==null?SF.min(e):SF.min(e,n);return o!==void 0?o:i}so.min=E7e;function T7e(e){return e!==e}so.isNaN=T7e;function C7e(e){return typeof e=="number"&&e-e<1}so.isValidNumber=C7e;function A7e(e,t,r){if(r===void 0&&(r=1),r===0)throw new Error("step cannot be 0");for(var n=md.max(md.ceil((t-e)/r),0),i=[],o=0;o<n;++o)i[o]=e+r*o;return i}so.range=A7e;function P7e(e,t){return md.pow(t.y-e.y,2)+md.pow(t.x-e.x,2)}so.distanceSquared=P7e;function I7e(e){return e/360*md.PI*2}so.degreesToRadians=I7e;function L7e(e,t){return t.topLeft.x<=e.x&&t.bottomRight.x>=e.x&&t.topLeft.y<=e.y&&t.bottomRight.y>=e.y}so.within=L7e;function k7e(e,t,r,n,i,o,a,s){return e<=i+a&&i<=e+r&&t<=o+s&&o<=t+n}so.boundsIntersects=k7e;function R7e(e){for(var t=MXt.getHtmlElementAncestors(e),r=b7e,n=null,i=0,o=t;i<o.length;i++){var a=o[i],s=MXt.getElementTransform(a);if(s!=null){var l=a.clientWidth/2,c=a.clientHeight/2;r=wF(r,[l,c]),r=EXt(r,TXt(s)),r=wF(r,[-l,-c])}var u=a.scrollLeft,h=a.scrollTop;(n===null||a===n)&&(u-=a.offsetLeft+a.clientLeft,h-=a.offsetTop+a.clientTop,n=a.offsetParent),r=wF(r,[u,h])}return r}so.getCumulativeTransform=R7e;function EXt(e,t){return[e[0]*t[0]+e[2]*t[1],e[1]*t[0]+e[3]*t[1],e[0]*t[2]+e[2]*t[3],e[1]*t[2]+e[3]*t[3],e[0]*t[4]+e[2]*t[5]+e[4],e[1]*t[4]+e[3]*t[5]+e[5]]}so.multiplyMatrix=EXt;function N7e(e,t){return[t[0],t[1],t[2],t[3],t[4]+e[0],t[5]+e[1]]}so.premultiplyTranslate=N7e;function wF(e,t){return[e[0],e[1],e[2],e[3],e[0]*t[0]+e[2]*t[1]+e[4],e[1]*t[0]+e[3]*t[1]+e[5]]}so.multiplyTranslate=wF;function TXt(e){var t=e[0]*e[3]-e[1]*e[2];if(t===0)throw new Error("singular matrix");var r=1/t;return[r*e[3],r*-e[1],r*-e[2],r*e[0],r*(-e[3]*e[4]+e[2]*e[5]),r*(e[1]*e[4]+-e[0]*e[5])]}so.invertMatrix=TXt;function D7e(e,t){return{x:e[0]*t.x+e[2]*t.y+e[4],y:e[1]*t.x+e[3]*t.y+e[5]}}so.applyTransform=D7e});var CXt=H(MF=>{"use strict";Object.defineProperty(MF,"__esModule",{value:!0});var O7e=function(){function e(){}return e.prototype.split=function(t,r){for(var n=Math.ceil(t.length/2),i=0;i<n;i++)r[0].insert(t[i]);for(var i=n;i<t.length;i++)r[1].insert(t[i])},e}();MF.SplitStrategyTrivial=O7e;var z7e=function(){function e(){}return e.prototype.split=function(t,r){for(t=t.slice(),this.chooseFirstSplit(t,r);t.length>0;)this.addNext(t,r)},e.prototype.chooseFirstSplit=function(t,r){for(var n=0,i=0,o=t.length-1,a=t.length-1,s=1;s<t.length-1;s++){var l=t[s];l.bounds.xl>t[o].bounds.xl?o=s:l.bounds.xh<t[n].bounds.xh&&(n=s),l.bounds.yl>t[a].bounds.yl?a=s:l.bounds.yh<t[i].bounds.yh&&(i=s)}var c=Math.abs(t[n].bounds.xh-t[o].bounds.xl),u=Math.abs(t[i].bounds.yh-t[a].bounds.yl),h=c>u?[n,o]:[i,a],f=h[0],p=h[1];f===p&&(f=0,p=t.length-1),r[0].insert(t.splice(Math.max(f,p),1)[0]),r[1].insert(t.splice(Math.min(f,p),1)[0])},e.prototype.addNext=function(t,r){for(var n=null,i=null,o=null,a=0;a<t.length;a++){var s=t[a],l=r[0].unionAreaDifference(s.bounds),c=r[1].unionAreaDifference(s.bounds);(l<i||n==null)&&(n=a,i=l,o=r[0]),c<i&&(n=a,i=c,o=r[1])}o.insert(t.splice(n,1)[0])},e}();MF.SplitStrategyLinear=z7e});var Iit=H(gd=>{"use strict";Object.defineProperty(gd,"__esModule",{value:!0});var F7e=CXt(),B7e=5,H7e=new F7e.SplitStrategyLinear,Rf;(function(e){e[e.PASS=0]="PASS",e[e.FAIL=1]="FAIL",e[e.PASS_AND_OVERWRITE=2]="PASS_AND_OVERWRITE"})(Rf=gd.QueryPredicateResult||(gd.QueryPredicateResult={}));function EF(e,t,r){var n=1/0,i=1/0,o=1/0;return function(a){var s=t(a.bounds,e),l=r(a.bounds,e);return a.value!=null?s<n?(n=s,i=s,o=l,Rf.PASS_AND_OVERWRITE):s===n?Rf.PASS:Rf.FAIL:s>o?Rf.FAIL:(i=Math.min(s,i),o=Math.max(l,o),Rf.PASS)}}gd.createMinimizingNodePredicate=EF;function Pit(e,t){return function(r,n){return t(n.bounds,e)-t(r.bounds,e)}}gd.createNodeSort=Pit;var V7e=function(){function e(t,r){t===void 0&&(t=B7e),r===void 0&&(r=H7e),this.maxNodeChildren=t,this.splitStrategy=r,this.root=new TF(!0),this.size=0}return e.prototype.getRoot=function(){return this.root},e.prototype.clear=function(){this.root=new TF(!0),this.size=0},e.prototype.insert=function(t,r){for(var n=this.root;!n.leaf;)n=n.subtree(t);var i=TF.valueNode(t,r);for(n.insert(i),this.size+=1;n.overflow(this.maxNodeChildren);)n=n.split(this.splitStrategy),n.parent==null&&(this.root=n);return i},e.prototype.locate=function(t){return this.query(function(r){return r.contains(t)})},e.prototype.locateNearest=function(t){var r=EF(t,Qa.distanceSquaredToNearEdge,Qa.distanceSquaredToFarEdge),n=this.queryNodes(r);return n.map(function(i){return i.value})},e.prototype.locateNearestX=function(t){var r=EF(t,Qa.absoluteDistanceToNearEdgeX,Qa.absoluteDistanceToFarEdgeX),n=this.queryNodes(r);return n.sort(Pit(t,Qa.absoluteDistanceToNearEdgeY)),n.map(function(i){return i.value})},e.prototype.locateNearestY=function(t){var r=EF(t,Qa.absoluteDistanceToNearEdgeY,Qa.absoluteDistanceToFarEdgeY),n=this.queryNodes(r);return n.sort(Pit(t,Qa.absoluteDistanceToNearEdgeX)),n.map(function(i){return i.value})},e.prototype.intersect=function(t){return this.query(function(r){return Qa.isBoundsOverlapBounds(r,t)})},e.prototype.intersectX=function(t){return this.query(function(r){return Qa.isBoundsOverlapX(r,t)})},e.prototype.intersectY=function(t){return this.query(function(r){return Qa.isBoundsOverlapY(r,t)})},e.prototype.query=function(t){var r=[];if(this.root.bounds!=null&&!t(this.root.bounds))return r;for(var n=[this.root];n.length>0;)for(var i=n.shift(),o=0;o<i.entries.length;o++){var a=i.entries[o];t(a.bounds)&&(i.leaf?r.push(a.value):n.push(a))}return r},e.prototype.queryNodes=function(t){var r=[];if(this.root.bounds!=null&&t(this.root)===Rf.FAIL)return r;for(var n=[this.root];n.length>0;)for(var i=n.shift(),o=0;o<i.entries.length;o++){var a=i.entries[o],s=t(a);s===Rf.PASS_AND_OVERWRITE&&(r=[]),(s===Rf.PASS||s===Rf.PASS_AND_OVERWRITE)&&(i.leaf?r.push(a):n.push(a))}return r},e}();gd.RTree=V7e;var TF=function(){function e(t){this.leaf=t,this.bounds=null,this.entries=[],this.parent=null,this.value=null}return e.valueNode=function(t,r){var n=new e(!0);return n.bounds=t,n.value=r,n},e.prototype.overflow=function(t){return this.entries.length>t},e.prototype.insert=function(t){this.entries.push(t),t.parent=this;for(var r=this;r!=null;)r.bounds=Qa.unionAll([r.bounds,t.bounds]),r=r.parent;return this},e.prototype.remove=function(t){var r=this.entries.indexOf(t);if(r>=0){this.entries.splice(r,1);for(var n=this;n!=null;)n.bounds=Qa.unionAll(n.entries.map(function(i){return i.bounds})),n=n.parent}return this},e.prototype.subtree=function(t){for(var r=1/0,n=null,i=0;i<this.entries.length;i++){var o=this.entries[i],a=o.unionAreaDifference(t);(a<r||a===r&&n!=null&&o.entries.length<n.entries.length)&&(n=o)}return n},e.prototype.split=function(t){this.parent!=null&&this.parent.remove(this);var r=[new e(this.leaf),new e(this.leaf)];t.split(this.entries,r);var n=this.parent!=null?this.parent:new e(!1);return n.insert(r[0]),n.insert(r[1]),n.leaf=!1,n},e.prototype.unionAreaDifference=function(t){return Math.abs(Qa.union(this.bounds,t).area()-this.bounds.area())},e.prototype.maxDepth=function(){return this.leaf?1:1+this.entries.map(function(t){return t.maxDepth()}).reduce(function(t,r){return Math.max(t,r)})},e}();gd.RTreeNode=TF;var Qa=function(){function e(t,r,n,i){this.xl=t,this.yl=r,this.xh=n,this.yh=i,this.width=this.xh-this.xl,this.height=this.yh-this.yl}return e.xywh=function(t,r,n,i){return new e(t,r,t+n,r+i)},e.entityBounds=function(t){return new e(t.x,t.y,t.x+t.width,t.y+t.height)},e.bounds=function(t){return e.pointPair(t.topLeft,t.bottomRight)},e.pointPair=function(t,r){return new e(Math.min(t.x,r.x),Math.min(t.y,r.y),Math.max(t.x,r.x),Math.max(t.y,r.y))},e.points=function(t){if(t.length<2)throw new Error("need at least 2 points to create bounds");var r=t.map(function(i){return i.x}),n=t.map(function(i){return i.y});return new e(r.reduce(function(i,o){return Math.min(i,o)}),n.reduce(function(i,o){return Math.min(i,o)}),r.reduce(function(i,o){return Math.max(i,o)}),n.reduce(function(i,o){return Math.max(i,o)}))},e.union=function(t,r){return new e(Math.min(t.xl,r.xl),Math.min(t.yl,r.yl),Math.max(t.xh,r.xh),Math.max(t.yh,r.yh))},e.unionAll=function(t){return t=t.filter(function(r){return r!=null}),t.length===0?null:t.reduce(function(r,n){return e.union(r,n)})},e.isBoundsOverlapBounds=function(t,r){return e.isBoundsOverlapX(t,r)&&e.isBoundsOverlapY(t,r)},e.isBoundsOverlapX=function(t,r){return!(t.xh<r.xl)&&!(t.xl>r.xh)},e.isBoundsOverlapY=function(t,r){return!(t.yh<r.yl)&&!(t.yl>r.yh)},e.absoluteDistanceToNearEdgeX=function(t,r){var n=t.width/2,i=t.xl+n;return Math.max(Math.abs(r.x-i)-n,0)},e.absoluteDistanceToNearEdgeY=function(t,r){var n=t.height/2,i=t.yl+n;return Math.max(Math.abs(r.y-i)-n,0)},e.absoluteDistanceToFarEdgeX=function(t,r){var n=e.absoluteDistanceToNearEdgeX(t,r);return n===0?0:n+t.width},e.absoluteDistanceToFarEdgeY=function(t,r){var n=e.absoluteDistanceToNearEdgeY(t,r);return n===0?0:n+t.height},e.distanceSquaredToNearEdge=function(t,r){var n=e.absoluteDistanceToNearEdgeX(t,r),i=e.absoluteDistanceToNearEdgeY(t,r);return n*n+i*i},e.distanceSquaredToFarEdge=function(t,r){var n=e.absoluteDistanceToFarEdgeX(t,r),i=e.absoluteDistanceToFarEdgeY(t,r);return n*n+i*i},e.prototype.area=function(){return this.areaCached==null&&(this.areaCached=(this.xh-this.xl)*(this.yh-this.yl)),this.areaCached},e.prototype.contains=function(t){return this.xl<=t.x&&this.xh>=t.x&&this.yl<=t.y&&this.yh>=t.y},e}();gd.RTreeBounds=Qa});var IXt=H(_d=>{"use strict";Object.defineProperty(_d,"__esModule",{value:!0});var AXt=(Er(),Ut(Mr)),U7e=Oe(),Xg=Fe(),q7e=If();_d.IStackingOrder=q7e.makeEnum(["topdown","bottomup"]);var PXt=window.Math;function G7e(e,t,r,n){n===void 0&&(n="bottomup");var i=AXt.map(),o=AXt.map(),a=new Xg.Map;n==="topdown"&&(e=e.slice(),e.reverse());for(var s=0,l=e;s<l.length;s++){for(var c=l[s],u=new Xg.Map,h=c.data(),f=h.length,p=0;p<f;p++){var d=h[p],g=t(d,p,c),_=_d.normalizeKey(g),y=+r(d,p,c),x=void 0,b=y>=0?i:o;b.has(_)?(x=b.get(_),b.set(_,x+y)):(x=0,b.set(_,y)),u.set(_,{offset:x,value:y,axisValue:g,originalDatum:d,originalDataset:c,originalIndex:p})}a.set(c,u)}return a}_d.stack=G7e;function W7e(e){var t=new Xg.Map,r=new Xg.Map;return e.forEach(function(n){n.forEach(function(i,o){var a=i.offset+i.value,s=Xg.Math.max([a,i.offset],i.offset),l=Xg.Math.min([a,i.offset],i.offset),c=i.axisValue;t.has(o)?t.get(o).extent<s&&t.set(o,{extent:s,axisValue:c,stackedDatum:i}):t.set(o,{extent:s,axisValue:c,stackedDatum:i}),r.has(o)?r.get(o).extent>l&&r.set(o,{extent:l,axisValue:c,stackedDatum:i}):r.set(o,{extent:l,axisValue:c,stackedDatum:i})})}),{maximumExtents:t,minimumExtents:r}}_d.stackedExtents=W7e;function Y7e(e,t,r){var n=[];e.forEach(function(a,s){for(var l=s.data(),c=l.length,u=0;u<c;u++){var h=l[u];if(!(r!=null&&!r(h,u,s))){var f=a.get(_d.normalizeKey(t(h,u,s)));n.push(f.value+f.offset)}}});var i=Xg.Math.max(n,0),o=Xg.Math.min(n,0);return[PXt.min(o,0),PXt.max(0,i)]}_d.stackedExtent=Y7e;_d.normalizeKey=U7e.memoize(function(e){return String(e)})});var $A=H(CF=>{"use strict";Object.defineProperty(CF,"__esModule",{value:!0});CF.SHOW_WARNINGS=!0;CF.ADD_TITLE_ELEMENTS=!0});var AF=H(gS=>{"use strict";Object.defineProperty(gS,"__esModule",{value:!0});var j7e=$A();function LXt(e){!j7e.SHOW_WARNINGS||console.warn(e)}gS.warn=LXt;function kXt(e,t){for(var r=[],n=2;n<arguments.length;n++)r[n-2]=arguments[n];return t===0?(e(r),-1):window.setTimeout(e,t,r)}gS.setTimeout=kXt;function X7e(e,t,r){var n=null,i=[],o=function(){t.apply(r,i)};return function(){i=Array.prototype.slice.call(arguments),clearTimeout(n),n=kXt(o,e)}}gS.debounce=X7e;function $7e(e,t,r){r===void 0&&(r=""),LXt("Method "+e+" has been deprecated in version "+t+". Please refer to the release notes. "+r)}gS.deprecated=$7e});var RXt=H(Lit=>{"use strict";Object.defineProperty(Lit,"__esModule",{value:!0});var K7e=function(){function e(t,r,n){this.entryIndex=t,this.exitIndex=t,this.minIndex=t,this.maxIndex=t,this.bucketValue=r,this.minValue=n,this.maxValue=n}return e.prototype.isInBucket=function(t){return t==this.bucketValue},e.prototype.addToBucket=function(t,r){t<this.minValue&&(this.minValue=t,this.minIndex=r),t>this.maxValue&&(this.maxValue=t,this.maxIndex=r),this.exitIndex=r},e.prototype.getUniqueIndices=function(){var t=[this.entryIndex,this.maxIndex,this.minIndex,this.exitIndex];return t.filter(function(r,n){return n==0||r!=t[n-1]})},e}();Lit.Bucket=K7e});var Rit=H(kit=>{"use strict";Object.defineProperty(kit,"__esModule",{value:!0});var Z7e=function(){function e(){typeof window.Set=="function"?this._es6Set=new window.Set:this._values=[],this.size=0}return e.prototype.add=function(t){return this._es6Set!=null?(this._es6Set.add(t),this.size=this._es6Set.size,this):(this.has(t)||(this._values.push(t),this.size=this._values.length),this)},e.prototype.delete=function(t){if(this._es6Set!=null){var r=this._es6Set.delete(t);return this.size=this._es6Set.size,r}var n=this._values.indexOf(t);return n!==-1?(this._values.splice(n,1),this.size=this._values.length,!0):!1},e.prototype.has=function(t){return this._es6Set!=null?this._es6Set.has(t):this._values.indexOf(t)!==-1},e.prototype.forEach=function(t,r){var n=this;if(this._es6Set!=null){var i=function(o,a){return t.call(r,o,a,n)};this._es6Set.forEach(i,r);return}this._values.forEach(function(o){t.call(r,o,o,n)})},e}();kit.Set=Z7e});var NXt=H(Nit=>{"use strict";Object.defineProperty(Nit,"__esModule",{value:!0});var J7e=(de(),Ut(pe)),Q7e=Rit(),tze=function(e){J7e.__extends(t,e);function t(){return e!==null&&e.apply(this,arguments)||this}return t.prototype.callCallbacks=function(){for(var r=this,n=[],i=0;i<arguments.length;i++)n[i]=arguments[i];return this.forEach(function(o){o.apply(r,n)}),this},t}(Q7e.Set);Nit.CallbackSet=tze});var DXt=H(Dit=>{"use strict";Object.defineProperty(Dit,"__esModule",{value:!0});var $g=Iit(),eze=function(){function e(){this._entities=[],this._rtree=new $g.RTree}return e.prototype.addAll=function(t,r,n){if(this._entities=this._entities.concat(t),n!==void 0)for(var i=$g.RTreeBounds.bounds(n),o=0;o<t.length;o++){var a=t[o],s=$g.RTreeBounds.entityBounds(r(a));$g.RTreeBounds.isBoundsOverlapBounds(i,s)&&this._rtree.insert(s,a)}else for(var o=0;o<t.length;o++){var a=t[o],s=$g.RTreeBounds.entityBounds(r(a));this._rtree.insert(s,a)}},e.prototype.entityNearest=function(t){return this._rtree.locateNearest(t).pop()},e.prototype.entityNearestX=function(t){return this._rtree.locateNearestX(t).pop()},e.prototype.entityNearestY=function(t){return this._rtree.locateNearestY(t).pop()},e.prototype.entitiesInBounds=function(t){return this._rtree.intersect($g.RTreeBounds.entityBounds(t))},e.prototype.entitiesInXBounds=function(t){return this._rtree.intersectX($g.RTreeBounds.entityBounds(t))},e.prototype.entitiesInYBounds=function(t){return this._rtree.intersectY($g.RTreeBounds.entityBounds(t))},e.prototype.entities=function(){return this._entities},e}();Dit.EntityStore=eze});var OXt=H(Oit=>{"use strict";Object.defineProperty(Oit,"__esModule",{value:!0});var rze=Ait(),nze=function(){function e(){typeof window.Map=="function"?this._es6Map=new window.Map:this._keyValuePairs=[]}return e.prototype.set=function(t,r){if(rze.isNaN(t))throw new Error("NaN may not be used as a key to the Map");if(this._es6Map!=null)return this._es6Map.set(t,r),this;for(var n=0;n<this._keyValuePairs.length;n++)if(this._keyValuePairs[n].key===t)return this._keyValuePairs[n].value=r,this;return this._keyValuePairs.push({key:t,value:r}),this},e.prototype.get=function(t){if(this._es6Map!=null)return this._es6Map.get(t);for(var r=0;r<this._keyValuePairs.length;r++)if(this._keyValuePairs[r].key===t)return this._keyValuePairs[r].value},e.prototype.has=function(t){if(this._es6Map!=null)return this._es6Map.has(t);for(var r=0;r<this._keyValuePairs.length;r++)if(this._keyValuePairs[r].key===t)return!0;return!1},e.prototype.forEach=function(t,r){var n=this;if(this._es6Map!=null){var i=function(o,a){return t.call(r,o,a,n)};this._es6Map.forEach(i,r);return}this._keyValuePairs.forEach(function(o){t.call(r,o.value,o.key,n)})},e.prototype.delete=function(t){if(this._es6Map!=null)return this._es6Map.delete(t);for(var r=0;r<this._keyValuePairs.length;r++)if(this._keyValuePairs[r].key===t)return this._keyValuePairs.splice(r,1),!0;return!1},e}();Oit.Map=nze});var zXt=H(zit=>{"use strict";Object.defineProperty(zit,"__esModule",{value:!0});function ize(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];for(var r={},n=0,i=e;n<i.length;n++)for(var o=i[n],a=Object.keys(o),s=0,l=a;s<l.length;s++){var c=l[s];r[c]=o[c]}return r}zit.assign=ize});var HXt=H(PF=>{"use strict";Object.defineProperty(PF,"__esModule",{value:!0});var Fit=Fe(),FXt="__Plottable_ClientTranslator";function oze(e){var t=e.root().rootElement().node(),r=t[FXt];return r==null&&(r=new BXt(t),t[FXt]=r),r}PF.getTranslator=oze;var BXt=function(){function e(t){this._rootElement=t}return e.prototype.computePosition=function(t,r){var n={x:t,y:r},i=Fit.Math.getCumulativeTransform(this._rootElement);if(i==null)return n;var o=Fit.Math.applyTransform(i,n);return o},e.isEventInside=function(t,r){return Fit.DOM.contains(t.root().rootElement().node(),r.target)},e}();PF.Translator=BXt});var Fe=H(qo=>{"use strict";Object.defineProperty(qo,"__esModule",{value:!0});var Kg=(de(),Ut(pe)),aze=_Xt();qo.Array=aze;var sze=xXt();qo.Color=sze;var lze=Cit();qo.DOM=lze;var cze=Ait();qo.Math=cze;var uze=Iit();qo.RTree=uze;var hze=IXt();qo.Stacking=hze;var fze=AF();qo.Window=fze;Kg.__exportStar(RXt(),qo);Kg.__exportStar(NXt(),qo);Kg.__exportStar(Yg(),qo);Kg.__exportStar(DXt(),qo);Kg.__exportStar(OXt(),qo);Kg.__exportStar(zXt(),qo);Kg.__exportStar(Rit(),qo);Kg.__exportStar(HXt(),qo)});var Hit=H(KA=>{"use strict";Object.defineProperty(KA,"__esModule",{value:!0});var VXt=Fe(),Bit=IF(),pze=function(){function e(){}return e.prototype.render=function(){Bit.flush()},e}();KA.Immediate=pze;var dze=function(){function e(){}return e.prototype.render=function(){VXt.DOM.requestAnimationFramePolyfill(Bit.flush)},e}();KA.AnimationFrame=dze;var mze=function(){function e(){this._timeoutMsec=VXt.DOM.SCREEN_REFRESH_RATE_MILLISECONDS}return e.prototype.render=function(){setTimeout(Bit.flush,this._timeoutMsec)},e}();KA.Timeout=mze});var IF=H(zu=>{"use strict";Object.defineProperty(zu,"__esModule",{value:!0});var _S=Fe(),gze=If(),LF=Hit(),JA=new _S.Set,Vit=new _S.Set,kF=!1,Uit=!1;zu.Policy=gze.makeEnum(["immediate","animationFrame","timeout"]);var ZA=new LF.AnimationFrame;function _ze(e){if(e==null)return ZA;switch(e){case zu.Policy.immediate:ZA=new LF.Immediate;break;case zu.Policy.animationFrame:ZA=new LF.AnimationFrame;break;case zu.Policy.timeout:ZA=new LF.Timeout;break;default:_S.Window.warn("Unrecognized renderPolicy: "+e)}}zu.renderPolicy=_ze;function yze(e){Uit&&_S.Window.warn("Registered to render while other components are flushing: request may be ignored"),JA.add(e),qXt()}zu.registerToRender=yze;function UXt(e){Vit.add(e),JA.add(e),qXt()}zu.registerToComputeLayoutAndRender=UXt;function vze(e){UXt(e)}zu.registerToComputeLayout=vze;function qXt(){kF||(kF=!0,ZA.render())}function xze(){if(kF){Vit.forEach(function(t){return t.computeLayout()}),JA.forEach(function(t){return t.render()}),Uit=!0;var e=new _S.Set;JA.forEach(function(t){try{t.renderImmediately()}catch(r){window.setTimeout(function(){throw r},0),e.add(t)}}),Vit=new _S.Set,JA=e,kF=!1,Uit=!1}}zu.flush=xze});var kc=H(QA=>{"use strict";Object.defineProperty(QA,"__esModule",{value:!0});var GXt=(Er(),Ut(Mr)),RF=IF(),yS=Fe(),bze=Oe(),WXt=Yg(),YXt=If();QA.XAlignment=YXt.makeEnum(["left","center","right"]);QA.YAlignment=YXt.makeEnum(["top","center","bottom"]);var wze=function(){function e(){this._overflowHidden=!1,this._origin={x:0,y:0},this._xAlignment="left",this._yAlignment="top",this._isSetup=!1,this._isAnchored=!1,this._cssClasses=new yS.Set,this._destroyed=!1,this._onAnchorCallbacks=new yS.CallbackSet,this._onDetachCallbacks=new yS.CallbackSet,this._cssClasses.add("component")}return e.prototype.anchor=function(t){if(t=WXt.coerceExternalD3(t),this._destroyed)throw new Error("Can't reuse destroy()-ed Components!");return this.isRoot()&&(this._rootElement=t,this._rootElement.classed("plottable",!0)),this._element!=null?t.node().appendChild(this._element.node()):(this._element=t.append("div"),this._setup()),this._isAnchored=!0,this._onAnchorCallbacks.callCallbacks(this),this},e.prototype.onAnchor=function(t){return this._isAnchored&&t(this),this._onAnchorCallbacks.add(t),this},e.prototype.offAnchor=function(t){return this._onAnchorCallbacks.delete(t),this},e.prototype._setup=function(){var t=this;this._isSetup||(this._cssClasses.forEach(function(r){t._element.classed(r,!0)}),this._cssClasses=new yS.Set,this._backgroundContainer=this._element.append("svg").classed("background-container",!0),this._content=this._element.append("svg").classed("content",!0),this._foregroundContainer=this._element.append("svg").classed("foreground-container",!0),this._overflowHidden?this._content.classed("component-overflow-hidden",!0):this._content.classed("component-overflow-visible",!0),this._isSetup=!0)},e.prototype.requestedSpace=function(t,r){return{minWidth:0,minHeight:0}},e.prototype.computeLayout=function(t,r,n){if(t==null||r==null||n==null){if(this._element==null)throw new Error("anchor() must be called before computeLayout()");if(this._rootElement!=null){t={x:0,y:0};var i=this._rootElement.node();r=yS.DOM.elementWidth(i),n=yS.DOM.elementHeight(i)}else throw new Error("null arguments cannot be passed to computeLayout() on a non-root, unanchored node")}var o=this._sizeFromOffer(r,n),a=o.height,s=o.width,l=e._xAlignToProportion[this._xAlignment],c=e._yAlignToProportion[this._yAlignment],u=t.x+(r-s)*l,h=t.y+(n-a)*c;return this.setBounds(s,a,u,h),this},e.prototype.setBounds=function(t,r,n,i){return n===void 0&&(n=0),i===void 0&&(i=0),this._width=t,this._height=r,this._origin={x:n,y:i},this._element!=null&&this._element.styles({left:n+"px",height:r+"px",top:i+"px",width:t+"px"}),this._resizeHandler!=null&&this._resizeHandler({width:t,height:r}),this},e.prototype._sizeFromOffer=function(t,r){var n=this.requestedSpace(t,r);return{width:this.fixedWidth()?Math.min(t,n.minWidth):t,height:this.fixedHeight()?Math.min(r,n.minHeight):r}},e.prototype.render=function(){return this._isAnchored&&this._isSetup&&this.width()>=0&&this.height()>=0&&RF.registerToRender(this),this},e.prototype.renderLowPriority=function(){return this.render()},e.prototype._scheduleComputeLayout=function(){this._isAnchored&&this._isSetup&&RF.registerToComputeLayoutAndRender(this)},e.prototype.onResize=function(t){return this._resizeHandler=t,this},e.prototype.renderImmediately=function(){return this},e.prototype.redraw=function(){return this._isAnchored&&this._isSetup&&(this.isRoot()?this._scheduleComputeLayout():this.parent().redraw()),this},e.prototype.invalidateCache=function(){},e.prototype.renderTo=function(t){if(this.detach(),t!=null){var r=void 0;if(typeof t=="string"||bze.isElement(t)?r=GXt.select(t):r=WXt.coerceExternalD3(t),!r.node()||r.node().nodeName==null)throw new Error("Plottable requires a valid Element to renderTo");if(r.node().nodeName==="svg")throw new Error("Plottable 3.x and later can only renderTo an HTML component; pass a div instead!");this.anchor(r)}if(this._element==null)throw new Error("If a Component has never been rendered before, then renderTo must be given a node to render to, or a d3.Selection, or a selector string");return RF.registerToComputeLayoutAndRender(this),RF.flush(),this},e.prototype.xAlignment=function(t){if(t==null)return this._xAlignment;if(t=t.toLowerCase(),e._xAlignToProportion[t]==null)throw new Error("Unsupported alignment: "+t);return this._xAlignment=t,this.redraw(),this},e.prototype.yAlignment=function(t){if(t==null)return this._yAlignment;if(t=t.toLowerCase(),e._yAlignToProportion[t]==null)throw new Error("Unsupported alignment: "+t);return this._yAlignment=t,this.redraw(),this},e.prototype.hasClass=function(t){return t==null?!1:this._element==null?this._cssClasses.has(t):this._element.classed(t)},e.prototype.addClass=function(t){return t==null?this:(this._element==null?this._cssClasses.add(t):this._element.classed(t,!0),this)},e.prototype.removeClass=function(t){return t==null?this:(this._element==null?this._cssClasses.delete(t):this._element.classed(t,!1),this)},e.prototype.fixedWidth=function(){return!1},e.prototype.fixedHeight=function(){return!1},e.prototype.detach=function(){return this.parent(null),this._isAnchored&&this._element.remove(),this._isAnchored=!1,this._onDetachCallbacks.callCallbacks(this),this},e.prototype.onDetach=function(t){return this._onDetachCallbacks.add(t),this},e.prototype.offDetach=function(t){return this._onDetachCallbacks.delete(t),this},e.prototype.parent=function(t){if(t===void 0)return this._parent;if(t!==null&&!t.has(this))throw new Error("Passed invalid parent");return this._parent=t,this},e.prototype.bounds=function(){var t=this.origin();return{topLeft:t,bottomRight:{x:t.x+this.width(),y:t.y+this.height()}}},e.prototype.destroy=function(){this._destroyed=!0,this.detach()},e.prototype.width=function(){return this._width},e.prototype.height=function(){return this._height},e.prototype.origin=function(){return{x:this._origin.x,y:this._origin.y}},e.prototype.originToRoot=function(){for(var t=this.origin(),r=this.parent();r!=null;){var n=r.origin();t.x+=n.x,t.y+=n.y,r=r.parent()}return t},e.prototype.root=function(){for(var t=this;!t.isRoot();)t=t.parent();return t},e.prototype.isRoot=function(){return this.parent()==null},e.prototype.foreground=function(){return this._foregroundContainer},e.prototype.content=function(){return this._content},e.prototype.element=function(){return this._element},e.prototype.rootElement=function(){return this.root()._rootElement},e.prototype.background=function(){return this._backgroundContainer},e._xAlignToProportion={left:0,center:.5,right:1},e._yAlignToProportion={top:0,center:.5,bottom:1},e}();QA.Component=wze});var Bu=H(Fu=>{"use strict";Object.defineProperty(Fu,"__esModule",{value:!0});var vS=(Er(),Ut(Mr)),Sze=!1;function Mze(e,t,r){e===void 0&&(e=2),t===void 0&&(t="$"),r===void 0&&(r=!0);var n=qit(e);return function(i){var o=n(Math.abs(i));return o!==""&&(r?o=t+o:o+=t,i<0&&(o="-"+o)),o}}Fu.currency=Mze;function qit(e){return e===void 0&&(e=3),NF(e),function(t){return t.toFixed(e)}}Fu.fixed=qit;function Eze(e){return e===void 0&&(e=3),NF(e),function(t){if(typeof t=="number"){var r=Math.pow(10,e);return String(Math.round(t*r)/r)}else return String(t)}}Fu.general=Eze;function Tze(){return function(e){return String(e)}}Fu.identity=Tze;function Cze(e){e===void 0&&(e=0);var t=qit(e);return function(r){var n=r*100,i=r.toString(),o=Math.pow(10,i.length-(i.indexOf(".")+1));return n=parseInt((n*o).toString(),10)/o,t(n)+"%"}}Fu.percentage=Cze;function Aze(e){return e===void 0&&(e=3),NF(e),function(t){return vS.format("."+e+"s")(t)}}Fu.siSuffix=Aze;function Pze(e){e===void 0&&(e=3),NF(e);var t="KMBTQ",r=vS.format("."+e+"e"),n=vS.format("."+e+"f"),i=Math.pow(10,3*(t.length+1)),o=Math.pow(10,-e);return function(a){var s=Math.abs(a);if((s<o||s>=i)&&s!==0)return r(a);for(var l=-1;s>=Math.pow(1e3,l+2)&&l<t.length-1;)l++;var c="";return l===-1?c=n(a):c=n(a/Math.pow(1e3,l+1))+t[l],(a>0&&c.substr(0,4)==="1000"||a<0&&c.substr(0,5)==="-1000")&&(l<t.length-1?(l++,c=n(a/Math.pow(1e3,l+1))+t[l]):c=r(a)),c}}Fu.shortScale=Pze;function Ize(){var e=[{specifier:".%L",predicate:function(t){return t.getMilliseconds()!==0}},{specifier:":%S",predicate:function(t){return t.getSeconds()!==0}},{specifier:"%I:%M",predicate:function(t){return t.getMinutes()!==0}},{specifier:"%I %p",predicate:function(t){return t.getHours()!==0}},{specifier:"%a %d",predicate:function(t){return t.getDay()!==0&&t.getDate()!==1}},{specifier:"%b %d",predicate:function(t){return t.getDate()!==1}},{specifier:"%b",predicate:function(t){return t.getMonth()!==0}}];return function(t){var r=e.filter(function(i){return i.predicate(t)}),n=r.length>0?r[0].specifier:"%Y";return vS.timeFormat(n)(t)}}Fu.multiTime=Ize;function Lze(e,t){return t===void 0&&(t=Sze),t?vS.utcFormat(e):vS.timeFormat(e)}Fu.time=Lze;function NF(e){if(e<0||e>20)throw new RangeError("Formatter precision must be between 0 and 20");if(e!==Math.floor(e))throw new RangeError("Formatter precision must be an integer")}});var t4=H(DF=>{"use strict";Object.defineProperty(DF,"__esModule",{value:!0});var kze=(de(),Ut(pe)),yd=(Er(),Ut(Mr)),Git=_l(),Rze=kc(),jXt=Bu(),xS=Fe(),Nze=If();DF.AxisOrientation=Nze.makeEnum(["bottom","left","right","top"]);var Dze=function(e){kze.__extends(t,e);function t(r,n){var i=e.call(this)||this;if(i._endTickLength=5,i._innerTickLength=5,i._tickLabelPadding=10,i._margin=15,i._showEndTickLabels=!1,i._annotationsEnabled=!1,i._annotationTierCount=1,r==null||n==null)throw new Error("Axis requires a scale and orientation");return i._scale=r,i.orientation(n),i._setDefaultAlignment(),i.addClass("axis"),i.isHorizontal()?i.addClass("x-axis"):i.addClass("y-axis"),i.formatter(jXt.identity()),i._rescaleCallback=function(o){return i._rescale()},i._scale.onUpdate(i._rescaleCallback),i._annotatedTicks=[],i._annotationFormatter=jXt.identity(),i}return t.prototype.destroy=function(){e.prototype.destroy.call(this),this._scale.offUpdate(this._rescaleCallback)},t.prototype.tickLabelDataOnElement=function(r){if(r!=null){for(var n;r!=null&&r.classList&&n===void 0;)r.classList.contains(t.TICK_LABEL_CLASS)?n=r:r=r.parentNode;return r===void 0?void 0:yd.select(r).datum()}},t.prototype._computeWidth=function(){return this._maxLabelTickLength()},t.prototype._computeHeight=function(){return this._maxLabelTickLength()},t.prototype.requestedSpace=function(r,n){var i=0,o=0;if(this.isHorizontal()){if(o=this._computeHeight()+this._margin,this.annotationsEnabled()){var a=this._annotationMeasurer.measure().height+2*t._ANNOTATION_LABEL_PADDING;o+=a*this.annotationTierCount()}}else if(i=this._computeWidth()+this._margin,this.annotationsEnabled()){var a=this._annotationMeasurer.measure().height+2*t._ANNOTATION_LABEL_PADDING;i+=a*this.annotationTierCount()}return{minWidth:i,minHeight:o}},t.prototype.fixedHeight=function(){return this.isHorizontal()},t.prototype.fixedWidth=function(){return!this.isHorizontal()},t.prototype._rescale=function(){this.render()},t.prototype.computeLayout=function(r,n,i){return e.prototype.computeLayout.call(this,r,n,i),this.isHorizontal()?this._scale.range([0,this.width()]):this._scale.range([this.height(),0]),this},t.prototype._sizeFromOffer=function(r,n){var i=this.requestedSpace(r,n);return this.isHorizontal()?{width:r,height:i.minHeight}:{height:n,width:i.minWidth}},t.prototype._setup=function(){e.prototype._setup.call(this),this._tickMarkContainer=this.content().append("g").classed(t.TICK_MARK_CLASS+"-container",!0),this._tickLabelContainer=this.content().append("g").classed(t.TICK_LABEL_CLASS+"-container",!0),this._baseline=this.content().append("line").classed("baseline",!0),this._annotationContainer=this.content().append("g").classed("annotation-container",!0),this._annotationContainer.append("g").classed("annotation-line-container",!0),this._annotationContainer.append("g").classed("annotation-circle-container",!0),this._annotationContainer.append("g").classed("annotation-rect-container",!0);var r=this._annotationContainer.append("g").classed("annotation-label-container",!0),n=new Git.SvgContext(r.node());this._annotationMeasurer=new Git.CacheMeasurer(n),this._annotationWriter=new Git.Writer(this._annotationMeasurer,n)},t.prototype._getTickValues=function(){return[]},t.prototype.renderImmediately=function(){var r=this._getTickValues(),n=this._tickMarkContainer.selectAll("."+t.TICK_MARK_CLASS).data(r),i=n.enter().append("line").classed(t.TICK_MARK_CLASS,!0).merge(n);return i.attrs(this._generateTickMarkAttrHash()),yd.select(i.nodes()[0]).classed(t.END_TICK_MARK_CLASS,!0).attrs(this._generateTickMarkAttrHash(!0)),yd.select(i.nodes()[r.length-1]).classed(t.END_TICK_MARK_CLASS,!0).attrs(this._generateTickMarkAttrHash(!0)),n.exit().remove(),this._baseline.attrs(this._generateBaselineAttrHash()),this.annotationsEnabled()?this._drawAnnotations():this._removeAnnotations(),this},t.prototype.annotatedTicks=function(r){return r==null?this._annotatedTicks:(this._annotatedTicks=r,this.render(),this)},t.prototype.annotationFormatter=function(r){return r==null?this._annotationFormatter:(this._annotationFormatter=r,this.render(),this)},t.prototype.annotationsEnabled=function(r){return r==null?this._annotationsEnabled:(this._annotationsEnabled=r,this.redraw(),this)},t.prototype.annotationTierCount=function(r){if(r==null)return this._annotationTierCount;if(r<0)throw new Error("annotationTierCount cannot be negative");return this._annotationTierCount=r,this.redraw(),this},t.prototype._drawAnnotations=function(){var r=this,n=t._ANNOTATION_LABEL_PADDING,i=new xS.Map,o=this._annotatedTicksToRender();o.forEach(function(P){var k=r._annotationMeasurer.measure(r.annotationFormatter()(P)),O={width:k.width+2*n,height:k.height+2*n};i.set(P,O)});var a=this._annotationMeasurer.measure().height+2*n,s=this._annotationToTier(i),l=new xS.Set,c=this.isHorizontal()?this.height():this.width(),u=this._coreSize(),h=Math.min(this.annotationTierCount(),Math.floor((c-u)/a));s.forEach(function(P,k){(P===-1||P>=h)&&l.add(k)});var f=function(P,k,O){var D=P.selectAll("."+O).data(o),B=D.enter().append(k).classed(O,!0).merge(D);return D.exit().remove(),B},p=function(P){switch(r.orientation()){case"bottom":case"right":return s.get(P)*a+u;case"top":case"left":return c-u-s.get(P)*a}},d=function(P){return r._scale.scale(P)},g=function(P){return l.has(P)?"hidden":"visible"},_;switch(this.orientation()){case"bottom":case"right":_=0;break;case"top":_=this.height();break;case"left":_=this.width();break}var y=this.isHorizontal();f(this._annotationContainer.select(".annotation-line-container"),"line",t.ANNOTATION_LINE_CLASS).attrs({x1:y?d:_,x2:y?d:p,y1:y?_:d,y2:y?p:d,visibility:g}),f(this._annotationContainer.select(".annotation-circle-container"),"circle",t.ANNOTATION_CIRCLE_CLASS).attrs({cx:y?d:_,cy:y?_:d,r:3});var x=function(P){switch(r.orientation()){case"bottom":case"right":return p(P);case"top":case"left":return p(P)-i.get(P).height}};f(this._annotationContainer.select(".annotation-rect-container"),"rect",t.ANNOTATION_RECT_CLASS).attrs({x:y?d:x,y:y?x:d,width:y?function(P){return i.get(P).width}:function(P){return i.get(P).height},height:y?function(P){return i.get(P).height}:function(P){return i.get(P).width},visibility:g});var b=this._annotationWriter,S=this.annotationFormatter(),C=f(this._annotationContainer.select(".annotation-label-container"),"g",t.ANNOTATION_LABEL_CLASS);C.selectAll(".text-container").remove(),C.attrs({transform:function(P){var k=y?d(P):x(P),O=y?x(P):d(P);return"translate("+k+","+O+")"},visibility:g}).each(function(P){b.write(S(P),y?i.get(P).width:i.get(P).height,y?i.get(P).height:i.get(P).width,{xAlign:"center",yAlign:"center",textRotation:y?0:90},yd.select(this).node())})},t.prototype._annotatedTicksToRender=function(){var r=this,n=this._scale.range();return xS.Array.uniq(this.annotatedTicks().filter(function(i){return i==null?!1:xS.Math.inRange(r._scale.scale(i),n[0],n[1])}))},t.prototype._coreSize=function(){var r=this.isHorizontal()?this.height():this.width(),n=this.isHorizontal()?this._computeHeight():this._computeWidth();return Math.min(n,r)},t.prototype._annotationTierHeight=function(){return this._annotationMeasurer.measure().height+2*t._ANNOTATION_LABEL_PADDING},t.prototype._annotationToTier=function(r){var n=this,i=[[]],o=new xS.Map,a=this.isHorizontal()?this.width():this.height();return this._annotatedTicksToRender().forEach(function(s){var l=n._scale.scale(s),c=r.get(s).width;if(l<0||l+c>a){o.set(s,-1);return}for(var u=function(f){return i[f].some(function(p){var d=n._scale.scale(p),g=r.get(p).width;return l+c>=d&&l<=d+g})},h=0;u(h);)h++,i.length===h&&i.push([]);i[h].push(s),o.set(s,h)}),o},t.prototype._removeAnnotations=function(){this._annotationContainer.selectAll(".annotation-line").remove(),this._annotationContainer.selectAll(".annotation-circle").remove(),this._annotationContainer.selectAll(".annotation-rect").remove(),this._annotationContainer.selectAll(".annotation-label").remove()},t.prototype._generateBaselineAttrHash=function(){var r={x1:0,y1:0,x2:0,y2:0};switch(this._orientation){case"bottom":r.x2=this.width();break;case"top":r.x2=this.width(),r.y1=this.height(),r.y2=this.height();break;case"left":r.x1=this.width(),r.x2=this.width(),r.y2=this.height();break;case"right":r.y2=this.height();break}return r},t.prototype._generateTickMarkAttrHash=function(r){var n=this;r===void 0&&(r=!1);var i={x1:0,y1:0,x2:0,y2:0},o=function(s){return n._scale.scale(s)};this.isHorizontal()?(i.x1=o,i.x2=o):(i.y1=o,i.y2=o);var a=r?this._endTickLength:this._innerTickLength;switch(this._orientation){case"bottom":i.y2=a;break;case"top":i.y1=this.height(),i.y2=this.height()-a;break;case"left":i.x1=this.width(),i.x2=this.width()-a;break;case"right":i.x2=a;break}return i},t.prototype._setDefaultAlignment=function(){switch(this._orientation){case"bottom":this.yAlignment("top");break;case"top":this.yAlignment("bottom");break;case"left":this.xAlignment("right");break;case"right":this.xAlignment("left");break}},t.prototype.isHorizontal=function(){return this._orientation==="top"||this._orientation==="bottom"},t.prototype.getScale=function(){return this._scale},t.prototype.formatter=function(r){return r==null?this._formatter:(this._formatter=r,this.redraw(),this)},t.prototype.innerTickLength=function(r){if(r==null)return this._innerTickLength;if(r<0)throw new Error("inner tick length must be positive");return this._innerTickLength=r,this.redraw(),this},t.prototype.endTickLength=function(r){if(r==null)return this._endTickLength;if(r<0)throw new Error("end tick length must be positive");return this._endTickLength=r,this.redraw(),this},t.prototype._maxLabelTickLength=function(){return this.showEndTickLabels()?Math.max(this.innerTickLength(),this.endTickLength()):this.innerTickLength()},t.prototype.tickLabelPadding=function(r){if(r==null)return this._tickLabelPadding;if(r<0)throw new Error("tick label padding must be positive");return this._tickLabelPadding=r,this.redraw(),this},t.prototype.margin=function(r){if(r==null)return this._margin;if(r<0)throw new Error("margin size must be positive");return this._margin=r,this.redraw(),this},t.prototype.orientation=function(r){if(r==null)return this._orientation;var n=r.toLowerCase();if(n!=="top"&&n!=="bottom"&&n!=="left"&&n!=="right")throw new Error("unsupported orientation");return this._orientation=n,this.redraw(),this},t.prototype.showEndTickLabels=function(r){return r==null?this._showEndTickLabels:(this._showEndTickLabels=r,this.render(),this)},t.prototype._showAllTickMarks=function(){this._tickMarkContainer.selectAll("."+t.TICK_MARK_CLASS).each(function(){yd.select(this).style("visibility","inherit")})},t.prototype._showAllTickLabels=function(){this._tickLabelContainer.selectAll("."+t.TICK_LABEL_CLASS).each(function(){yd.select(this).style("visibility","inherit")})},t.prototype._hideOverflowingTickLabels=function(){var r=this.element().node().getBoundingClientRect(),n=this._tickLabelContainer.selectAll("."+t.TICK_LABEL_CLASS);n.empty()||n.each(function(i,o){xS.DOM.clientRectInside(this.getBoundingClientRect(),r)||yd.select(this).style("visibility","hidden")})},t.prototype._hideTickMarksWithoutLabel=function(){var r=this._tickMarkContainer.selectAll("."+t.TICK_MARK_CLASS),n=this._tickLabelContainer.selectAll("."+t.TICK_LABEL_CLASS).filter(function(o,a){var s=yd.select(this).style("visibility");return s==="inherit"||s==="visible"}),i=n.data();r.each(function(o,a){i.indexOf(o)===-1&&yd.select(this).style("visibility","hidden")})},t.prototype.invalidateCache=function(){e.prototype.invalidateCache.call(this),this._annotationMeasurer.reset()},t.END_TICK_MARK_CLASS="end-tick-mark",t.TICK_MARK_CLASS="tick-mark",t.TICK_LABEL_CLASS="tick-label",t.ANNOTATION_LINE_CLASS="annotation-line",t.ANNOTATION_RECT_CLASS="annotation-rect",t.ANNOTATION_CIRCLE_CLASS="annotation-circle",t.ANNOTATION_LABEL_CLASS="annotation-label",t._ANNOTATION_LABEL_PADDING=4,t}(Rze.Component);DF.Axis=Dze});var $Xt=H(jit=>{"use strict";Object.defineProperty(jit,"__esModule",{value:!0});var Oze=(de(),Ut(pe)),Wit=(Er(),Ut(Mr)),OF=_l(),zze=kc(),XXt=Fe(),Yit=t4(),Fze=function(e){Oze.__extends(t,e);function t(r,n){n===void 0&&(n="bottom");var i=e.call(this,r,n)||this;return i._tickLabelAngle=0,i._tickLabelShearAngle=0,i.addClass("category-axis"),i}return Object.defineProperty(t.prototype,"_wrapper",{get:function(){var r=new OF.Wrapper;return this._tickLabelMaxLines!=null&&r.maxLines(this._tickLabelMaxLines),r},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"_writer",{get:function(){return new OF.Writer(this._measurer,this._typesetterContext,this._wrapper)},enumerable:!0,configurable:!0}),t.prototype._setup=function(){e.prototype._setup.call(this),this._typesetterContext=new OF.SvgContext(this._tickLabelContainer.node()),this._measurer=new OF.CacheMeasurer(this._typesetterContext)},t.prototype._rescale=function(){return this.redraw()},t.prototype.requestedSpace=function(r,n){var i=this.isHorizontal()?0:this._tickSpaceRequired()+this.margin(),o=this.isHorizontal()?this._tickSpaceRequired()+this.margin():0;if(this._scale.domain().length===0)return{minWidth:0,minHeight:0};if(this.annotationsEnabled()){var a=this._annotationTierHeight()*this.annotationTierCount();this.isHorizontal()?o+=a:i+=a}var s=this._measureTickLabels(r,n);return{minWidth:s.usedWidth+i,minHeight:s.usedHeight+o}},t.prototype._coreSize=function(){var r=this.isHorizontal()?this.height():this.width(),n=this.isHorizontal()?this.requestedSpace(this.width(),this.height()).minHeight:this.requestedSpace(this.width(),this.height()).minWidth,i=this.margin()+this._annotationTierHeight(),o=n-i;return Math.min(o,r)},t.prototype._getTickValues=function(){return this.getDownsampleInfo().domain},t.prototype._sizeFromOffer=function(r,n){return zze.Component.prototype._sizeFromOffer.call(this,r,n)},t.prototype.getDownsampleInfo=function(r,n){r===void 0&&(r=this._scale),n===void 0&&(n=r.invertRange());var i=this._tickLabelAngle===0?1:1/Math.cos(this._tickLabelShearAngle/180*Math.PI),o=t._MINIMUM_WIDTH_PER_LABEL_PX*i,a=Math.ceil(o/r.stepWidth());return{domain:n.filter(function(s,l){return l%a===0}),stepWidth:a*r.stepWidth()}},t.prototype.tickLabelAngle=function(r){if(r==null)return this._tickLabelAngle;if(r!==0&&r!==90&&r!==-90)throw new Error("Angle "+r+" not supported; only 0, 90, and -90 are valid values");return this._tickLabelAngle=r,this.redraw(),this},t.prototype.tickLabelShearAngle=function(r){if(r==null)return this._tickLabelShearAngle;if(r<-80||r>80)throw new Error("Angle "+r+" not supported; Must be between [-80, 80]");return this._tickLabelShearAngle=r,this.redraw(),this},t.prototype.tickLabelMaxWidth=function(r){return arguments.length===0?this._tickLabelMaxWidth:(this._tickLabelMaxWidth=r,this.redraw(),this)},t.prototype.tickLabelMaxLines=function(r){return arguments.length===0?this._tickLabelMaxLines:(this._tickLabelMaxLines=r,this.redraw(),this)},t.prototype._tickSpaceRequired=function(){return this._maxLabelTickLength()+this.tickLabelPadding()},t.prototype._drawTicks=function(r,n){var i=this,o,a;switch(this.tickLabelAngle()){case 0:o={left:"right",right:"left",top:"center",bottom:"center"},a={left:"center",right:"center",top:"bottom",bottom:"top"};break;case 90:o={left:"center",right:"center",top:"right",bottom:"left"},a={left:"top",right:"bottom",top:"center",bottom:"center"};break;case-90:o={left:"center",right:"center",top:"left",bottom:"right"},a={left:"bottom",right:"top",top:"center",bottom:"center"};break}n.each(function(s){var l=Wit.select(this),c=i.isHorizontal()?r:i.width()-i._tickSpaceRequired(),u=i.isHorizontal()?i.height()-i._tickSpaceRequired():r,h={xAlign:o[i.orientation()],yAlign:a[i.orientation()],textRotation:i.tickLabelAngle(),textShear:i.tickLabelShearAngle()};if(i._tickLabelMaxWidth!=null){if(i.orientation()==="left"&&c>i._tickLabelMaxWidth){var f=c-i._tickLabelMaxWidth,p=l.attr("transform")+" translate("+f+", 0)";l.attr("transform",p)}c=Math.min(c,i._tickLabelMaxWidth)}i._writer.write(i.formatter()(s),c,u,h,l.node())})},t.prototype._measureTickLabels=function(r,n){var i=this,o=this._scale,a=o.cloneWithoutProviders().range([0,this.isHorizontal()?r:n]),s=this.getDownsampleInfo(a),l=s.domain,c=s.stepWidth,u=r-this._tickSpaceRequired();this.isHorizontal()&&(u=c,this._tickLabelAngle!==0&&(u=n-this._tickSpaceRequired()),u=Math.max(u,0));var h=c;this.isHorizontal()&&(h=n-this._tickSpaceRequired(),this._tickLabelAngle!==0&&(h=r-this._tickSpaceRequired()),h=Math.max(h,0)),this._tickLabelMaxWidth!=null&&(u=Math.min(u,this._tickLabelMaxWidth));var f=l.map(function(x){return i._wrapper.wrap(i.formatter()(x),i._measurer,u,h)}),p=this.isHorizontal()&&this._tickLabelAngle===0?Wit.sum:XXt.Math.max,d=this.isHorizontal()&&this._tickLabelAngle===0?XXt.Math.max:Wit.sum,g=p(f,function(x){return i._measurer.measure(x.wrappedText).width},0),_=d(f,function(x){return i._measurer.measure(x.wrappedText).height},0);return this._tickLabelAngle!==0&&(y=[_,g],g=y[0],_=y[1]),{usedWidth:g,usedHeight:_};var y},t.prototype.renderImmediately=function(){var r=this;e.prototype.renderImmediately.call(this);var n=this._scale,i=this.getDownsampleInfo(n),o=i.domain,a=i.stepWidth,s=a;this.isHorizontal()&&this._tickLabelMaxWidth!=null&&(s=Math.min(s,this._tickLabelMaxWidth));var l=function(p,d){var g=n.scale(p)-s/2,_=r.isHorizontal()?g:0,y=r.isHorizontal()?0:g;return"translate("+_+","+y+")"},c=this._tickLabelContainer.selectAll("."+Yit.Axis.TICK_LABEL_CLASS).data(o),u=c.enter().append("g").classed(Yit.Axis.TICK_LABEL_CLASS,!0).merge(c);c.exit().remove(),u.attr("transform",l),u.text(""),this._drawTicks(a,u);var h=this.orientation()==="right"?this._tickSpaceRequired():0,f=this.orientation()==="bottom"?this._tickSpaceRequired():0;return this._tickLabelContainer.attr("transform","translate("+h+","+f+")"),this._showAllTickMarks(),this._showAllTickLabels(),this._hideTickMarksWithoutLabel(),this},t.prototype.computeLayout=function(r,n,i){return e.prototype.computeLayout.call(this,r,n,i),this.isHorizontal()||this._scale.range([0,this.height()]),this},t.prototype.invalidateCache=function(){e.prototype.invalidateCache.call(this),this._measurer.reset()},t._MINIMUM_WIDTH_PER_LABEL_PX=15,t}(Yit.Axis);jit.Category=Fze});var KXt=H($it=>{"use strict";Object.defineProperty($it,"__esModule",{value:!0});var Bze=(de(),Ut(pe)),zF=(Er(),Ut(Mr)),Xit=_l(),Hze=Bu(),bS=Fe(),wS=t4(),Vze=function(e){Bze.__extends(t,e);function t(r,n){var i=e.call(this,r,n)||this;return i._tickLabelPositioning="center",i._usesTextWidthApproximation=!1,i.formatter(Hze.general()),i}return t.prototype._setup=function(){e.prototype._setup.call(this);var r=new Xit.SvgContext(this._tickLabelContainer.node(),wS.Axis.TICK_LABEL_CLASS);this._measurer=new Xit.CacheMeasurer(r),this._wrapper=new Xit.Wrapper().maxLines(1)},t.prototype._computeWidth=function(){var r=this._usesTextWidthApproximation?this._computeApproximateTextWidth():this._computeExactTextWidth();return this._tickLabelPositioning==="center"?this._maxLabelTickLength()+this.tickLabelPadding()+r:Math.max(this._maxLabelTickLength(),this.tickLabelPadding()+r)},t.prototype._computeExactTextWidth=function(){var r=this,n=this._getTickValues(),i=n.map(function(o){var a=r.formatter()(o);return r._measurer.measure(a).width});return bS.Math.max(i,0)},t.prototype._computeApproximateTextWidth=function(){var r=this,n=this._getTickValues(),i=this._measurer.measure("M").width,o=n.map(function(a){var s=r.formatter()(a);return s.length*i});return bS.Math.max(o,0)},t.prototype._computeHeight=function(){var r=this._measurer.measure().height;return this._tickLabelPositioning==="center"?this._maxLabelTickLength()+this.tickLabelPadding()+r:Math.max(this._maxLabelTickLength(),this.tickLabelPadding()+r)},t.prototype._getTickValues=function(){var r=this._scale,n=r.domain(),i=n[0]<=n[1]?n[0]:n[1],o=n[0]>=n[1]?n[0]:n[1];return r.ticks().filter(function(a){return a>=i&&a<=o})},t.prototype._rescale=function(){if(!!this._isSetup){if(!this.isHorizontal()){var r=this._computeWidth();if(r>this.width()||r<this.width()-this.margin()){this.redraw();return}}this.render()}},t.prototype.renderImmediately=function(){var r=this;e.prototype.renderImmediately.call(this);var n={x:0,y:0,dx:"0em",dy:"0.3em"},i=this._maxLabelTickLength(),o=this.tickLabelPadding(),a="middle",s=0,l=0,c=0,u=0;if(this.isHorizontal())switch(this._tickLabelPositioning){case"left":a="end",s=-o,u=o;break;case"center":u=i+o;break;case"right":a="start",s=o,u=o;break}else switch(this._tickLabelPositioning){case"top":n.dy="-0.3em",c=o,l=-o;break;case"center":c=i+o;break;case"bottom":n.dy="1em",c=o,l=o;break}var h=this._generateTickMarkAttrHash();switch(this.orientation()){case"bottom":n.x=h.x1,n.dy="0.95em",l=h.y1+u;break;case"top":n.x=h.x1,n.dy="-.25em",l=h.y1-u;break;case"left":a="end",s=h.x1-c,n.y=h.y1;break;case"right":a="start",s=h.x1+c,n.y=h.y1;break}var f=this._getTickValues(),p=this._tickLabelContainer.selectAll("."+wS.Axis.TICK_LABEL_CLASS).data(f);p.exit().remove();var d=p.enter().append("text").classed(wS.Axis.TICK_LABEL_CLASS,!0).merge(p);d.style("text-anchor",a).style("visibility","inherit").attrs(n).text(function(_){return r.formatter()(_)});var g="translate("+s+", "+l+")";return this._tickLabelContainer.attr("transform",g),this._showAllTickMarks(),this.showEndTickLabels()||this._hideEndTickLabels(),this._hideOverflowingTickLabels(),this._hideOverlappingTickLabels(),this._tickLabelPositioning!=="center"&&this._hideTickMarksWithoutLabel(),this},t.prototype.tickLabelPosition=function(r){if(r==null)return this._tickLabelPositioning;var n=r.toLowerCase();if(this.isHorizontal()){if(!(n==="left"||n==="center"||n==="right"))throw new Error(n+" is not a valid tick label position for a horizontal NumericAxis")}else if(!(n==="top"||n==="center"||n==="bottom"))throw new Error(n+" is not a valid tick label position for a vertical NumericAxis");return this._tickLabelPositioning=n,this.redraw(),this},t.prototype.usesTextWidthApproximation=function(r){return r==null?this._usesTextWidthApproximation:(this._usesTextWidthApproximation=r,this)},t.prototype._hideEndTickLabels=function(){var r=this.element().node().getBoundingClientRect(),n=this._tickLabelContainer.selectAll("."+wS.Axis.TICK_LABEL_CLASS);if(n.size()!==0){var i=n.nodes()[0];bS.DOM.clientRectInside(i.getBoundingClientRect(),r)||zF.select(i).style("visibility","hidden");var o=n.nodes()[n.size()-1];bS.DOM.clientRectInside(o.getBoundingClientRect(),r)||zF.select(o).style("visibility","hidden")}},t.prototype._hideOverlappingTickLabels=function(){for(var r=this._tickLabelContainer.selectAll("."+wS.Axis.TICK_LABEL_CLASS).filter(function(o,a){var s=zF.select(this).style("visibility");return s==="inherit"||s==="visible"}),n=r.nodes().map(function(o){return o.getBoundingClientRect()}),i=1;!this._hasOverlapWithInterval(i,n)&&i<n.length;)i+=1;r.each(function(o,a){var s=zF.select(this);a%i!==0&&s.style("visibility","hidden")})},t.prototype._hasOverlapWithInterval=function(r,n){for(var i=this._tickLabelPositioning==="center"?this.tickLabelPadding():this.tickLabelPadding()*3,o=n.map(function(c){return bS.DOM.expandRect(c,i)}),a=0;a<o.length-r;a+=r){var s=o[a],l=o[a+r];if(bS.DOM.clientRectsOverlap(s,l))return!1}return!0},t.prototype.invalidateCache=function(){e.prototype.invalidateCache.call(this),this._measurer.reset()},t}(wS.Axis);$it.Numeric=Vze});var ZXt=H(FF=>{"use strict";Object.defineProperty(FF,"__esModule",{value:!0});var Uze=Fe();function qze(e){if(e<=0)throw new Error("interval must be positive number");return function(t){var r=t.domain(),n=Math.min(r[0],r[1]),i=Math.max(r[0],r[1]),o=Math.ceil(n/e)*e,a=Math.floor((i-o)/e)+1,s=n%e===0?[]:[n],l=Uze.Math.range(0,a).map(function(u){return o+u*e}),c=i%e===0?[]:[i];return s.concat(l).concat(c)}}FF.intervalTickGenerator=qze;function Gze(){return function(e){var t=e.defaultTicks();return t.filter(function(r,n){return r%1===0||n===0||n===t.length-1})}}FF.integerTickGenerator=Gze});var e4=H(Iv=>{"use strict";Object.defineProperty(Iv,"__esModule",{value:!0});function Zit(e,t,r){return r-(r-e)*t}Iv.zoomOut=Zit;function Kit(e,t,r){return(e*t-r)/(t-1)}function Wze(e,t,r,n,i,o,a){return t=JXt(e,t,n,i),QXt(e,t,r,o,a)}Iv.constrainedZoom=Wze;function JXt(e,t,r,n){var i=t>1,o=i?n:r;if(o==null)return t;var a=e.getTransformationDomain(),s=a[0],l=a[1],c=Math.abs(l-s),u=i?Math.min:Math.max;return u(t,o/c)}Iv.constrainZoomExtents=JXt;function QXt(e,t,r,n,i){if(t<=1)return{centerPoint:r,zoomAmount:t};if(n==null&&i==null)return{centerPoint:r,zoomAmount:t};var o=t$t(e),a=jze(e),s=a?1/0:-1/0,l=a?-1/0:1/0;n=n==null?s:n,i=i==null?l:i;var c=e.getTransformationDomain(),u=c[0],h=c[1],f=e.scaleTransformation(i),p=e.scaleTransformation(h),d=Zit(p,t,r),g=e.scaleTransformation(n),_=e.scaleTransformation(u),y=Zit(_,t,r),x=Math.abs(f-g),b=Math.abs(d-y);if(b>x){var S=(f-g)/(p-_);if(S!==1){var C=Kit(p,S,f);return{centerPoint:C,zoomAmount:S}}else return{centerPoint:r,zoomAmount:S}}else return d>f!=o?{centerPoint:Kit(p,t,f),zoomAmount:t}:y<g!=o?{centerPoint:Kit(_,t,g),zoomAmount:t}:{centerPoint:r,zoomAmount:t}}Iv.constrainZoomValues=QXt;function Yze(e,t,r,n){var i=e.getTransformationDomain(),o=i[0],a=i[1],s=t$t(e);if(t>0!==s){var l=n;if(l!=null){var c=e.scaleTransformation(a),u=e.scaleTransformation(l);t=(s?Math.max:Math.min)(c+t,u)-c}}else{var l=r;if(l!=null){var h=e.scaleTransformation(o),f=e.scaleTransformation(l);t=(s?Math.min:Math.max)(h+t,f)-h}}return t}Iv.constrainedTranslation=Yze;function t$t(e){var t=e.range();return t[1]<t[0]}function jze(e){var t=e.getTransformationDomain();return t[1]<t[0]}});var Lv=H(Jit=>{"use strict";Object.defineProperty(Jit,"__esModule",{value:!0});var e$t=Fe(),Xze=function(){function e(){this._autoDomainAutomatically=!0,this._domainModificationInProgress=!1,this._updateId=0,this._callbacks=new e$t.CallbackSet,this._includedValuesProviders=new e$t.Set}return e.prototype.extentOfValues=function(t){return[]},e.prototype._getAllIncludedValues=function(t){var r=this;t===void 0&&(t=!1);var n=[];return this._includedValuesProviders.forEach(function(i){var o=i(r,t);n=n.concat(o)}),n},e.prototype._getExtent=function(){return[]},e.prototype.onUpdate=function(t){return this._callbacks.add(t),this},e.prototype.offUpdate=function(t){return this._callbacks.delete(t),this},e.prototype._dispatchUpdate=function(){this._updateId++,this._callbacks.callCallbacks(this)},e.prototype.autoDomain=function(){return this._autoDomainAutomatically=!0,this._setDomain(this._getExtent()),this},e.prototype.autoDomainIfAutomaticMode=function(){this._autoDomainAutomatically&&this.autoDomain()},e.prototype.scale=function(t){throw new Error("Subclasses should override scale")},e.prototype.ticks=function(){return this.domain()},e.prototype.domain=function(t){return t==null?this._getDomain():(this._autoDomainAutomatically=!1,this._setDomain(t),this)},e.prototype._getDomain=function(){throw new Error("Subclasses should override _getDomain")},e.prototype._setDomain=function(t){this._domainModificationInProgress||(this._domainModificationInProgress=!0,this._backingScaleDomain(t),this._dispatchUpdate(),this._domainModificationInProgress=!1)},e.prototype._backingScaleDomain=function(t){throw new Error("Subclasses should override _backingDomain")},e.prototype.range=function(t){return t==null?this._getRange():(this._setRange(t),this)},e.prototype._getRange=function(){throw new Error("Subclasses should override _getRange")},e.prototype._setRange=function(t){throw new Error("Subclasses should override _setRange")},e.prototype.addIncludedValuesProvider=function(t){return this._includedValuesProviders.add(t),this.autoDomainIfAutomaticMode(),this},e.prototype.removeIncludedValuesProvider=function(t){return this._includedValuesProviders.delete(t),this.autoDomainIfAutomaticMode(),this},e.prototype.updateId=function(){return this._updateId},e}();Jit.Scale=Xze});var eot=H(tot=>{"use strict";Object.defineProperty(tot,"__esModule",{value:!0});var $ze=(de(),Ut(pe)),BF=(Er(),Ut(Mr)),Kze=e4(),r$t=Fe(),Zze=Lv(),Qit=[0,1],Jze=function(e){$ze.__extends(t,e);function t(){var r=e.call(this)||this;r._range=[0,1],r._d3Scale=BF.scaleBand(),r._d3Scale.range(Qit),r._d3TransformationScale=BF.scaleLinear(),r._d3TransformationScale.domain(Qit);var n=.3;return r._innerPadding=t._convertToPlottableInnerPadding(n),r._outerPadding=t._convertToPlottableOuterPadding(.5,n),r}return t.prototype.cloneWithoutProviders=function(){var r=new t().domain(this.domain()).range(this.range()).innerPadding(this.innerPadding()).outerPadding(this.outerPadding());return r._d3TransformationScale.domain(this._d3TransformationScale.domain()),r},t.prototype.extentOfValues=function(r){return r$t.Array.uniq(r)},t.prototype._getExtent=function(){return r$t.Array.uniq(this._getAllIncludedValues())},t.prototype.domain=function(r){return e.prototype.domain.call(this,r)},t.prototype.invertRange=function(r){var n=this;r===void 0&&(r=this.range());var i=this._d3Scale.bandwidth(),o=this.invertedTransformation(r[0]),a=this.invertedTransformation(r[1]),s=this._d3Scale.domain(),l=s.map(function(h){return n._d3Scale(h)+i/2}),c=BF.bisect(l,o),u=BF.bisect(l,a);return s.slice(c,u)},t.prototype.range=function(r){return e.prototype.range.call(this,r)},t._convertToPlottableInnerPadding=function(r){return 1/(1-r)-1},t._convertToPlottableOuterPadding=function(r,n){return r/(1-n)},t.prototype._setBands=function(){var r=1-1/(1+this.innerPadding()),n=this.outerPadding()/(1+this.innerPadding());this._d3Scale.paddingInner(r),this._d3Scale.paddingOuter(n)},t.prototype.rangeBand=function(){return this._rescaleBand(this._d3Scale.bandwidth())},t.prototype.stepWidth=function(){return this._rescaleBand(this._d3Scale.bandwidth()*(1+this.innerPadding()))},t.prototype.ticks=function(){return this.domain()},t.prototype.innerPadding=function(r){return r==null?this._innerPadding:(this._innerPadding=r,this.range(this.range()),this._dispatchUpdate(),this)},t.prototype.outerPadding=function(r){return r==null?this._outerPadding:(this._outerPadding=r,this.range(this.range()),this._dispatchUpdate(),this)},t.prototype.scale=function(r){var n=this._d3Scale(r)+this._d3Scale.bandwidth()/2;return this._d3TransformationScale(n)},t.prototype.zoom=function(r,n){var i=this,o=function(a){return i._d3TransformationScale.invert(Kze.zoomOut(a,r,n))};this._d3TransformationScale.domain(this._d3TransformationScale.range().map(o)),this._dispatchUpdate()},t.prototype.pan=function(r){var n=this,i=function(o){return n._d3TransformationScale.invert(o+r)};this._d3TransformationScale.domain(this._d3TransformationScale.range().map(i)),this._dispatchUpdate()},t.prototype.scaleTransformation=function(r){return this._d3TransformationScale(r)},t.prototype.invertedTransformation=function(r){return this._d3TransformationScale.invert(r)},t.prototype.getTransformationExtent=function(){return Qit},t.prototype.getTransformationDomain=function(){return this._d3TransformationScale.domain()},t.prototype.setTransformationDomain=function(r){this._d3TransformationScale.domain(r),this._dispatchUpdate()},t.prototype._getDomain=function(){return this._backingScaleDomain()},t.prototype._backingScaleDomain=function(r){return r==null?this._d3Scale.domain():(this._d3Scale.domain(r),this._setBands(),this)},t.prototype._getRange=function(){return this._range},t.prototype._setRange=function(r){this._range=r,this._d3TransformationScale.range(r),this._setBands()},t.prototype._rescaleBand=function(r){return Math.abs(this._d3TransformationScale(r)-this._d3TransformationScale(0))},t}(Zze.Scale);tot.Category=Jze});var n$t=H(rot=>{"use strict";Object.defineProperty(rot,"__esModule",{value:!0});var Qze=(de(),Ut(pe)),Nf=(Er(),Ut(Mr)),SS=Fe(),tFe=Lv(),eFe=function(){function e(){this.count=0,this.tracker={}}return e.prototype.getIndex=function(t){if(this.tracker[t]!=null)return this.tracker[t];var r=this.count;return this.tracker[t]=r,this.count+=1,r},e.prototype.clear=function(){this.count=0,this.tracker={}},e}(),rFe=function(e){Qze.__extends(t,e);function t(r){var n=e.call(this)||this;n._rangeLength=1,n._tracker=new eFe;var i;switch(r){case null:case void 0:t._plottableColorCache==null&&(t._plottableColorCache=t._getPlottableColors()),i=Nf.scaleOrdinal().range(t._plottableColorCache);break;case"Category10":case"category10":case"10":i=Nf.scaleOrdinal(Nf.schemeCategory10);break;case"Category20":case"category20":case"20":i=Nf.scaleOrdinal(Nf.schemeCategory20);break;case"Category20b":case"category20b":case"20b":i=Nf.scaleOrdinal(Nf.schemeCategory20b);break;case"Category20c":case"category20c":case"20c":i=Nf.scaleOrdinal(Nf.schemeCategory20c);break;default:throw new Error("Unsupported ColorScale type")}return n._d3Scale=i,n._rangeLength=n._d3Scale.range().length,n}return t.prototype.extentOfValues=function(r){return SS.Array.uniq(r)},t.prototype._getExtent=function(){return SS.Array.uniq(this._getAllIncludedValues())},t.invalidateColorCache=function(){t._plottableColorCache=null},t._getPlottableColors=function(){for(var r=[],n=Nf.select("body").append("plottable-color-tester"),i=SS.Color.colorTest(n,""),o=0,a=SS.Color.colorTest(n,"plottable-colors-0");a!=null&&o<this._MAXIMUM_COLORS_FROM_CSS&&!(a===i&&a===r[r.length-1]);)r.push(a),o++,a=SS.Color.colorTest(n,"plottable-colors-"+o);return n.remove(),r},t.prototype.scale=function(r){var n=this._d3Scale(r),i=this._tracker.getIndex(r),o=Math.floor(i/this._rangeLength);if(o===0)return n;var a=Math.log(o*t._LOOP_LIGHTEN_FACTOR+1);return SS.Color.lightenColor(n,a)},t.prototype._getDomain=function(){return this._backingScaleDomain()},t.prototype._backingScaleDomain=function(r){return r==null?this._d3Scale.domain():(this._d3Scale.domain(r),this._tracker.clear(),this)},t.prototype._getRange=function(){return this._d3Scale.range()},t.prototype._setRange=function(r){this._d3Scale.range(r),this._rangeLength=r.length},t._LOOP_LIGHTEN_FACTOR=1.6,t._MAXIMUM_COLORS_FROM_CSS=256,t}(tFe.Scale);rot.Color=rFe});var o$t=H(not=>{"use strict";Object.defineProperty(not,"__esModule",{value:!0});var nFe=(de(),Ut(pe)),MS=(Er(),Ut(Mr)),i$t=Fe(),iFe=Lv(),oFe=function(e){nFe.__extends(t,e);function t(r){r===void 0&&(r="linear");var n=e.call(this)||this;switch(r){case"linear":n._colorScale=MS.scaleLinear();break;case"log":n._colorScale=MS.scaleLog();break;case"sqrt":n._colorScale=MS.scaleSqrt();break;case"pow":n._colorScale=MS.scalePow();break}if(n._colorScale==null)throw new Error("unknown QuantitativeScale scale type "+r);return n.range(t.REDS),n}return t.prototype.extentOfValues=function(r){var n=MS.extent(r);return n[0]==null||n[1]==null?[]:n},t.prototype._d3InterpolatedScale=function(){return this._colorScale.range([0,1]).interpolate(this._interpolateColors())},t.prototype._interpolateColors=function(){var r=this._colorRange;if(r.length<2)throw new Error("Color scale arrays must have at least two elements.");return function(n,i){return function(o){o=Math.max(0,Math.min(1,o));var a=o*(r.length-1),s=Math.floor(a),l=Math.ceil(a),c=a-s;return MS.interpolateLab(r[s],r[l])(c)}}},t.prototype._resetScale=function(){this._d3Scale=this._d3InterpolatedScale(),this.autoDomainIfAutomaticMode(),this._dispatchUpdate()},t.prototype.autoDomain=function(){var r=this._getAllIncludedValues();return r.length>0&&this._setDomain([i$t.Math.min(r,0),i$t.Math.max(r,0)]),this},t.prototype.scale=function(r){return this._d3Scale(r)},t.prototype._getDomain=function(){return this._backingScaleDomain()},t.prototype._backingScaleDomain=function(r){return r==null?this._d3Scale.domain():(this._d3Scale.domain(r),this)},t.prototype._getRange=function(){return this._colorRange},t.prototype._setRange=function(r){this._colorRange=r,this._resetScale()},t.REDS=["#FFFFFF","#FFF6E1","#FEF4C0","#FED976","#FEB24C","#FD8D3C","#FC4E2A","#E31A1C","#B10026"],t.BLUES=["#FFFFFF","#CCFFFF","#A5FFFD","#85F7FB","#6ED3EF","#55A7E0","#417FD0","#2545D3","#0B02E1"],t.POSNEG=["#0B02E1","#2545D3","#417FD0","#55A7E0","#6ED3EF","#85F7FB","#A5FFFD","#CCFFFF","#FFFFFF","#FFF6E1","#FEF4C0","#FED976","#FEB24C","#FD8D3C","#FC4E2A","#E31A1C","#B10026"],t}(iFe.Scale);not.InterpolatedColor=oFe});var vd=H(iot=>{"use strict";Object.defineProperty(iot,"__esModule",{value:!0});var aFe=(de(),Ut(pe)),sFe=(Er(),Ut(Mr)),lFe=e4(),ES=Fe(),cFe=Lv(),uFe=function(e){aFe.__extends(t,e);function t(){var r=e.call(this)||this;return r._tickGenerator=function(n){return n.defaultTicks()},r._padProportion=.05,r._snappingDomainEnabled=!0,r._paddingExceptionsProviders=new ES.Set,r}return t.prototype.autoDomain=function(){return this._domainMin=null,this._domainMax=null,e.prototype.autoDomain.call(this),this},t.prototype.autoDomainIfAutomaticMode=function(){if(this._domainMin!=null&&this._domainMax!=null){this._setDomain([this._domainMin,this._domainMax]);return}var r=this._getExtent();if(this._domainMin!=null){var n=r[1];this._domainMin>=n&&(n=this._expandSingleValueDomain([this._domainMin,this._domainMin])[1]),this._setDomain([this._domainMin,n]);return}if(this._domainMax!=null){var i=r[0];this._domainMax<=i&&(i=this._expandSingleValueDomain([this._domainMax,this._domainMax])[0]),this._setDomain([i,this._domainMax]);return}e.prototype.autoDomainIfAutomaticMode.call(this)},t.prototype._getUnboundedExtent=function(r){r===void 0&&(r=!1);var n=this._getAllIncludedValues(r),i=this._defaultExtent();if(n.length!==0){var o=[ES.Math.min(n,i[0]),ES.Math.max(n,i[1])];i=this._padDomain(o)}return i},t.prototype._getExtent=function(){var r=this._getUnboundedExtent();return this._domainMin!=null&&(r[0]=this._domainMin),this._domainMax!=null&&(r[1]=this._domainMax),r},t.prototype.addPaddingExceptionsProvider=function(r){return this._paddingExceptionsProviders.add(r),this.autoDomainIfAutomaticMode(),this},t.prototype.removePaddingExceptionsProvider=function(r){return this._paddingExceptionsProviders.delete(r),this.autoDomainIfAutomaticMode(),this},t.prototype.padProportion=function(r){if(r==null)return this._padProportion;if(r<0)throw new Error("padProportion must be non-negative");return this._padProportion=r,this.autoDomainIfAutomaticMode(),this},t.prototype._padDomain=function(r){var n=this;if(r[0].valueOf()===r[1].valueOf())return this._expandSingleValueDomain(r);if(this._padProportion===0)return r;var i=this._padProportion/2,o=r[0],a=r[1],s=!1,l=!1;this._paddingExceptionsProviders.forEach(function(f){var p=f(n);p.forEach(function(d){d.valueOf()===o.valueOf()&&(s=!0),d.valueOf()===a.valueOf()&&(l=!0)})});var c=this._backingScaleDomain();this._backingScaleDomain(r);var u=s?o:this.invert(this.scale(o)-(this.scale(a)-this.scale(o))*i),h=l?a:this.invert(this.scale(a)+(this.scale(a)-this.scale(o))*i);return this._backingScaleDomain(c),this._snappingDomainEnabled?this._niceDomain([u,h]):[u,h]},t.prototype.snappingDomainEnabled=function(r){return r==null?this._snappingDomainEnabled:(this._snappingDomainEnabled=r,this.autoDomainIfAutomaticMode(),this)},t.prototype._expandSingleValueDomain=function(r){return r},t.prototype.invert=function(r){throw new Error("Subclasses should override invert")},t.prototype.domain=function(r){return r!=null&&(this._domainMin=r[0],this._domainMax=r[1]),e.prototype.domain.call(this,r)},t.prototype.domainMin=function(r){return r==null?this.domain()[0]:(this._domainMin=r,this.autoDomainIfAutomaticMode(),this)},t.prototype.domainMax=function(r){return r==null?this.domain()[1]:(this._domainMax=r,this.autoDomainIfAutomaticMode(),this)},t.prototype.extentOfValues=function(r){var n=sFe.extent(r.filter(function(i){return ES.Math.isValidNumber(+i)}));return n[0]==null||n[1]==null?[]:n},t.prototype.zoom=function(r,n){var i=this,o=function(a){return i.invert(lFe.zoomOut(a,r,n))};this.domain(this.range().map(o))},t.prototype.pan=function(r){var n=this,i=function(o){return n.invert(o+r)};this.domain(this.range().map(i))},t.prototype.scaleTransformation=function(r){throw new Error("Subclasses should override scaleTransformation")},t.prototype.invertedTransformation=function(r){throw new Error("Subclasses should override invertedTransformation")},t.prototype.getTransformationExtent=function(){throw new Error("Subclasses should override getTransformationExtent")},t.prototype.getTransformationDomain=function(){throw new Error("Subclasses should override getTransformationDomain")},t.prototype.setTransformationDomain=function(r){throw new Error("Subclasses should override setTransformationDomain")},t.prototype._setDomain=function(r){var n=function(i){return ES.Math.isNaN(i)||i===1/0||i===-1/0};if(n(r[0])||n(r[1])){ES.Window.warn("Warning: QuantitativeScales cannot take NaN or Infinity as a domain value. Ignoring.");return}e.prototype._setDomain.call(this,r)},t.prototype.defaultTicks=function(){throw new Error("Subclasses should override _getDefaultTicks")},t.prototype.ticks=function(){return this._tickGenerator(this)},t.prototype._niceDomain=function(r,n){throw new Error("Subclasses should override _niceDomain")},t.prototype._defaultExtent=function(){throw new Error("Subclasses should override _defaultExtent")},t.prototype.tickGenerator=function(r){return r==null?this._tickGenerator:(this._tickGenerator=r,this)},t._DEFAULT_NUM_TICKS=10,t}(cFe.Scale);iot.QuantitativeScale=uFe});var a$t=H(oot=>{"use strict";Object.defineProperty(oot,"__esModule",{value:!0});var hFe=(de(),Ut(pe)),fFe=(Er(),Ut(Mr)),pFe=vd(),dFe=function(e){hFe.__extends(t,e);function t(){var r=e.call(this)||this;return r._d3Scale=fFe.scaleLinear(),r}return t.prototype._defaultExtent=function(){return[0,1]},t.prototype._expandSingleValueDomain=function(r){return r[0]===r[1]?[r[0]-1,r[1]+1]:r},t.prototype.scale=function(r){return this._d3Scale(r)},t.prototype.scaleTransformation=function(r){return this.scale(r)},t.prototype.invertedTransformation=function(r){return this.invert(r)},t.prototype.getTransformationExtent=function(){return this._getUnboundedExtent(!0)},t.prototype.getTransformationDomain=function(){return this.domain()},t.prototype.setTransformationDomain=function(r){this.domain(r)},t.prototype._getDomain=function(){return this._backingScaleDomain()},t.prototype._backingScaleDomain=function(r){return r==null?this._d3Scale.domain():(this._d3Scale.domain(r),this)},t.prototype._getRange=function(){return this._d3Scale.range()},t.prototype._setRange=function(r){this._d3Scale.range(r)},t.prototype.invert=function(r){return this._d3Scale.invert(r)},t.prototype.defaultTicks=function(){return this._d3Scale.ticks(t._DEFAULT_NUM_TICKS)},t.prototype._niceDomain=function(r,n){return this._d3Scale.copy().domain(r).nice(n).domain()},t}(pFe.QuantitativeScale);oot.Linear=dFe});var s$t=H(aot=>{"use strict";Object.defineProperty(aot,"__esModule",{value:!0});var mFe=(de(),Ut(pe)),gFe=(Er(),Ut(Mr)),_Fe=vd(),yFe=function(e){mFe.__extends(t,e);function t(r){r===void 0&&(r=10);var n=e.call(this)||this;return n._d3Scale=gFe.scaleLog().base(r),n._setDomain(n._defaultExtent()),n}return t.prototype._defaultExtent=function(){return[1,this._d3Scale.base()]},t.prototype._expandSingleValueDomain=function(r){return r[0]===r[1]?[r[0]/this._d3Scale.base(),r[1]*this._d3Scale.base()]:r},t.prototype.scale=function(r){return this._d3Scale(r)},t.prototype.scaleTransformation=function(r){return this.scale(r)},t.prototype.invertedTransformation=function(r){return this.invert(r)},t.prototype.getTransformationExtent=function(){return this._getUnboundedExtent(!0)},t.prototype.getTransformationDomain=function(){return this.domain()},t.prototype.setTransformationDomain=function(r){this.domain(r)},t.prototype._getDomain=function(){return this._backingScaleDomain()},t.prototype._backingScaleDomain=function(r){return r==null?this._d3Scale.domain():(this._d3Scale.domain(r),this)},t.prototype._getRange=function(){return this._d3Scale.range()},t.prototype._setRange=function(r){this._d3Scale.range(r)},t.prototype.invert=function(r){return this._d3Scale.invert(r)},t.prototype.defaultTicks=function(){return this._d3Scale.ticks(t._DEFAULT_NUM_TICKS)},t.prototype._niceDomain=function(r,n){return this._d3Scale.copy().domain(r).nice().domain()},t}(_Fe.QuantitativeScale);aot.Log=yFe});var l$t=H(lot=>{"use strict";Object.defineProperty(lot,"__esModule",{value:!0});var vFe=(de(),Ut(pe)),r4=(Er(),Ut(Mr)),TS=Fe(),sot=ks(),xFe=vd(),bFe=function(e){vFe.__extends(t,e);function t(r){r===void 0&&(r=10);var n=e.call(this)||this;if(n._logTickGenerator=function(i){var o=function(x,b,S){return[x,b,S].sort(function(C,P){return C-P})[1]},a=TS.Math.min(n._untransformedDomain,0),s=TS.Math.max(n._untransformedDomain,0),l=a,c=o(a,s,-n._pivot),u=o(a,s,n._pivot),h=s,f=n._logTicks(-c,-l).map(function(x){return-x}).reverse(),p=n._logTicks(u,h),d=Math.max(a,-n._pivot),g=Math.min(s,n._pivot),_=r4.scaleLinear().domain([d,g]).ticks(n._howManyTicks(d,g)),y=f.concat(_).concat(p);return y.length<=1&&(y=r4.scaleLinear().domain([a,s]).ticks(sot.ModifiedLog._DEFAULT_NUM_TICKS)),y},n._d3Scale=r4.scaleLinear(),n._base=r,n._pivot=n._base,n._setDomain(n._defaultExtent()),n.tickGenerator(n._logTickGenerator),r<=1)throw new Error("ModifiedLogScale: The base must be > 1");return n}return t.prototype._adjustedLog=function(r){var n=r<0?-1:1;return r*=n,r<this._pivot&&(r+=(this._pivot-r)/this._pivot),r=Math.log(r)/Math.log(this._base),r*=n,r},t.prototype._invertedAdjustedLog=function(r){var n=r<0?-1:1;return r*=n,r=Math.pow(this._base,r),r<this._pivot&&(r=this._pivot*(r-1)/(this._pivot-1)),r*=n,r},t.prototype.scale=function(r){return this._d3Scale(this._adjustedLog(r))},t.prototype.invert=function(r){return this._invertedAdjustedLog(this._d3Scale.invert(r))},t.prototype.scaleTransformation=function(r){return this.scale(r)},t.prototype.invertedTransformation=function(r){return this.invert(r)},t.prototype.getTransformationExtent=function(){return this._getUnboundedExtent(!0)},t.prototype.getTransformationDomain=function(){return this.domain()},t.prototype.setTransformationDomain=function(r){this.domain(r)},t.prototype._getDomain=function(){return this._untransformedDomain},t.prototype._setDomain=function(r){this._untransformedDomain=r;var n=[this._adjustedLog(r[0]),this._adjustedLog(r[1])];e.prototype._setDomain.call(this,n)},t.prototype._backingScaleDomain=function(r){return r==null?this._d3Scale.domain():(this._d3Scale.domain(r),this)},t.prototype._logTicks=function(r,n){var i=this,o=this._howManyTicks(r,n);if(o===0)return[];var a=Math.floor(Math.log(r)/Math.log(this._base)),s=Math.ceil(Math.log(n)/Math.log(this._base)),l=r4.range(s,a,-Math.ceil((s-a)/o)),c=r4.range(this._base,1,-(this._base-1)).map(Math.floor),u=TS.Array.uniq(c),h=l.map(function(g){return u.map(function(_){return Math.pow(i._base,g-1)*_})}),f=TS.Array.flatten(h),p=f.filter(function(g){return r<=g&&g<=n}),d=p.sort(function(g,_){return g-_});return d},t.prototype._howManyTicks=function(r,n){var i=this._adjustedLog(TS.Math.min(this._untransformedDomain,0)),o=this._adjustedLog(TS.Math.max(this._untransformedDomain,0)),a=this._adjustedLog(r),s=this._adjustedLog(n),l=(s-a)/(o-i),c=Math.ceil(l*sot.ModifiedLog._DEFAULT_NUM_TICKS);return c},t.prototype._niceDomain=function(r,n){return r},t.prototype._defaultExtent=function(){return[0,this._base]},t.prototype._expandSingleValueDomain=function(r){if(r[0]===r[1]){var n=r[0];return n>0?[n/this._base,n*this._base]:n===0?[-this._base,this._base]:[n*this._base,n/this._base]}return r},t.prototype._getRange=function(){return this._d3Scale.range()},t.prototype._setRange=function(r){this._d3Scale.range(r)},t.prototype.defaultTicks=function(){return this._d3Scale.ticks(sot.ModifiedLog._DEFAULT_NUM_TICKS)},t}(xFe.QuantitativeScale);lot.ModifiedLog=bFe});var c$t=H(cot=>{"use strict";Object.defineProperty(cot,"__esModule",{value:!0});var wFe=(de(),Ut(pe)),ga=(Er(),Ut(Mr)),kv=HF(),SFe=vd(),MFe=function(e){wFe.__extends(t,e);function t(){var r=e.call(this)||this;return r._d3Scale=ga.scaleTime(),r.autoDomain(),r}return t.prototype.tickInterval=function(r,n,i){n===void 0&&(n=1),i===void 0&&(i=!1);var o=ga.scaleTime(),a=t.timeIntervalToD3Time(r,i).every(n);return o.domain(this.domain()),o.range(this.range()),o.ticks(a)},t.prototype._setDomain=function(r){if(r[1]<r[0])throw new Error("Scale.Time domain values must be in chronological order");return e.prototype._setDomain.call(this,r)},t.prototype._defaultExtent=function(){return[new Date("1970-01-01"),new Date("1970-01-02")]},t.prototype._expandSingleValueDomain=function(r){var n=r[0].getTime(),i=r[1].getTime();if(n===i){var o=new Date(n);o.setDate(o.getDate()-1);var a=new Date(i);return a.setDate(a.getDate()+1),[o,a]}return r},t.prototype.scale=function(r){return this._d3Scale(r)},t.prototype.scaleTransformation=function(r){return this.scale(new Date(r))},t.prototype.invertedTransformation=function(r){return this.invert(r).getTime()},t.prototype.getTransformationExtent=function(){var r=this._getUnboundedExtent(!0);return[r[0].valueOf(),r[1].valueOf()]},t.prototype.getTransformationDomain=function(){var r=this.domain();return[r[0].valueOf(),r[1].valueOf()]},t.prototype.setTransformationDomain=function(r){var n=r[0],i=r[1];this.domain([new Date(n),new Date(i)])},t.prototype._getDomain=function(){return this._backingScaleDomain()},t.prototype._backingScaleDomain=function(r){return r==null?this._d3Scale.domain():(this._d3Scale.domain(r),this)},t.prototype._getRange=function(){return this._d3Scale.range()},t.prototype._setRange=function(r){this._d3Scale.range(r)},t.prototype.invert=function(r){return this._d3Scale.invert(r)},t.prototype.defaultTicks=function(){return this._d3Scale.ticks(t._DEFAULT_NUM_TICKS)},t.prototype._niceDomain=function(r){return this._d3Scale.copy().domain(r).nice().domain()},t.timeIntervalToD3Time=function(r,n){switch(r){case kv.TimeInterval.second:return n?ga.utcSecond:ga.timeSecond;case kv.TimeInterval.minute:return n?ga.utcMinute:ga.timeMinute;case kv.TimeInterval.hour:return n?ga.utcHour:ga.timeHour;case kv.TimeInterval.day:return n?ga.utcDay:ga.timeDay;case kv.TimeInterval.week:return n?ga.utcWeek:ga.timeWeek;case kv.TimeInterval.month:return n?ga.utcMonth:ga.timeMonth;case kv.TimeInterval.year:return n?ga.utcYear:ga.timeYear;default:throw Error("TimeInterval specified does not exist: "+r)}},t}(SFe.QuantitativeScale);cot.Time=MFe});var ks=H(Hu=>{"use strict";Object.defineProperty(Hu,"__esModule",{value:!0});var Rv=(de(),Ut(pe)),EFe=ZXt();Hu.TickGenerators=EFe;Rv.__exportStar(eot(),Hu);Rv.__exportStar(n$t(),Hu);Rv.__exportStar(o$t(),Hu);Rv.__exportStar(a$t(),Hu);Rv.__exportStar(s$t(),Hu);Rv.__exportStar(l$t(),Hu);Rv.__exportStar(c$t(),Hu);var TFe=eot(),CFe=vd();function AFe(e){return e instanceof CFe.QuantitativeScale||e instanceof TFe.Category}Hu.isTransformable=AFe});var HF=H(Se=>{"use strict";Object.defineProperty(Se,"__esModule",{value:!0});var PFe=(de(),Ut(pe)),Vu=(Er(),Ut(Mr)),u$t=_l(),h$t=Bu(),IFe=ks(),n4=Fe(),uot=If(),ts=t4();Se.TimeInterval=uot.makeEnum(["second","minute","hour","day","week","month","year"]);Se.TimeAxisOrientation=uot.makeEnum(["top","bottom"]);Se.TierLabelPosition=uot.makeEnum(["between","center"]);var LFe=function(e){PFe.__extends(t,e);function t(r,n,i){var o=e.call(this,r,n)||this;return o._maxTimeIntervalPrecision=null,o._tierLabelPositions=[],o._useUTC=i,o.addClass("time-axis"),o.tickLabelPadding(5),o.axisConfigurations(t._DEFAULT_TIME_AXIS_CONFIGURATIONS(o._useUTC)),o.annotationFormatter(h$t.time("%a %b %d, %Y",o._useUTC)),o}return t.prototype.tierLabelPositions=function(r){if(r==null)return this._tierLabelPositions;if(!r.every(function(n){return n.toLowerCase()==="between"||n.toLowerCase()==="center"}))throw new Error("Unsupported position for tier labels");return this._tierLabelPositions=r,this.redraw(),this},t.prototype.maxTimeIntervalPrecision=function(r){return r==null?this._maxTimeIntervalPrecision:(this._maxTimeIntervalPrecision=r,this.redraw(),this)},t.prototype.currentAxisConfiguration=function(){return this._possibleTimeAxisConfigurations[this._mostPreciseConfigIndex]},t.prototype.axisConfigurations=function(r){if(r==null)return this._possibleTimeAxisConfigurations;this._possibleTimeAxisConfigurations=r,this._numTiers=n4.Math.max(this._possibleTimeAxisConfigurations.map(function(a){return a.length}),0),this._isAnchored&&this._setupDomElements();for(var n=this.tierLabelPositions(),i=[],o=0;o<this._numTiers;o++)i.push(n[o]||"between");return this.tierLabelPositions(i),this.redraw(),this},t.prototype._getMostPreciseConfigurationIndex=function(){var r=this,n=this._possibleTimeAxisConfigurations.length;return this._possibleTimeAxisConfigurations.forEach(function(i,o){o<n&&i.every(function(a){return r._checkTimeAxisTierConfiguration(a)})&&(n=o)}),n===this._possibleTimeAxisConfigurations.length&&(n4.Window.warn("zoomed out too far: could not find suitable interval to display labels"),--n),n},t.prototype.orientation=function(r){if(r&&(r.toLowerCase()==="right"||r.toLowerCase()==="left"))throw new Error(r+" is not a supported orientation for TimeAxis - only horizontal orientations are supported");return e.prototype.orientation.call(this,r)},t.prototype._computeHeight=function(){var r=this._measurer.measure().height;this._tierHeights=[];for(var n=0;n<this._numTiers;n++)this._tierHeights.push(r+this.tickLabelPadding()+(this._tierLabelPositions[n]==="between"?0:this._maxLabelTickLength()));return Vu.sum(this._tierHeights)},t.prototype._getIntervalLength=function(r){var n=this._scale.domain()[0],i=IFe.Time.timeIntervalToD3Time(r.interval,this._useUTC),o=i.offset(n,r.step);if(o>this._scale.domain()[1])return this.width();var a=Math.abs(this._scale.scale(o)-this._scale.scale(n));return a},t.prototype._maxWidthForInterval=function(r){return this._measurer.measure(r.formatter(t._LONG_DATE)).width},t.prototype._checkTimeAxisTierConfiguration=function(r){if(this._maxTimeIntervalPrecision!=null){var n=t._SORTED_TIME_INTERVAL_INDEX[this._maxTimeIntervalPrecision],i=t._SORTED_TIME_INTERVAL_INDEX[r.interval];if(n!=null&&i!=null&&i<n)return!1}var o=this._maxWidthForInterval(r)+2*this.tickLabelPadding();return Math.min(this._getIntervalLength(r),this.width())>=o},t.prototype._sizeFromOffer=function(r,n){var i=e.prototype._sizeFromOffer.call(this,r,n),o=this._tierHeights.reduce(function(s,l,c,u){return s+l>i.height?s:s+l}),a=this.margin()+(this.annotationsEnabled()?this.annotationTierCount()*this._annotationTierHeight():0);return i.height=Math.min(i.height,o+a),i},t.prototype._setup=function(){e.prototype._setup.call(this),this._setupDomElements()},t.prototype._setupDomElements=function(){this.content().selectAll("."+t.TIME_AXIS_TIER_CLASS).remove(),this._tierLabelContainers=[],this._tierMarkContainers=[],this._tierBaselines=[],this._tickLabelContainer.remove(),this._baseline.remove();for(var r=0;r<this._numTiers;++r){var n=this.content().append("g").classed(t.TIME_AXIS_TIER_CLASS,!0);this._tierLabelContainers.push(n.append("g").classed(ts.Axis.TICK_LABEL_CLASS+"-container",!0)),this._tierMarkContainers.push(n.append("g").classed(ts.Axis.TICK_MARK_CLASS+"-container",!0)),this._tierBaselines.push(n.append("line").classed("baseline",!0))}var i=new u$t.SvgContext(this._tierLabelContainers[0].node());this._measurer=new u$t.CacheMeasurer(i)},t.prototype._getTickIntervalValues=function(r){return this._scale.tickInterval(r.interval,r.step,this._useUTC)},t.prototype._getTickValues=function(){var r=this;return this._possibleTimeAxisConfigurations[this._mostPreciseConfigIndex].reduce(function(n,i){return n.concat(r._getTickIntervalValues(i))},[])},t.prototype._cleanTiers=function(){for(var r=0;r<this._tierLabelContainers.length;r++)this._tierLabelContainers[r].selectAll("."+ts.Axis.TICK_LABEL_CLASS).remove(),this._tierMarkContainers[r].selectAll("."+ts.Axis.TICK_MARK_CLASS).remove(),this._tierBaselines[r].style("visibility","hidden")},t.prototype._getTickValuesForConfiguration=function(r){var n=this._scale.tickInterval(r.interval,r.step,this._useUTC),i=this._scale.domain(),o=n.map(function(a){return a.valueOf()});return o.indexOf(i[0].valueOf())===-1&&n.unshift(i[0]),o.indexOf(i[1].valueOf())===-1&&n.push(i[1]),n},t.prototype._renderTierLabels=function(r,n,i){var o=this,a=this._getTickValuesForConfiguration(n),s=[];this._tierLabelPositions[i]==="between"&&n.step===1?a.map(function(g,_){_+1>=a.length||s.push(new Date((a[_+1].valueOf()-a[_].valueOf())/2+a[_].valueOf()))}):s=a;var l=r.selectAll("."+ts.Axis.TICK_LABEL_CLASS).data(s,function(g){return String(g.valueOf())}),c=l.enter().append("g").classed(ts.Axis.TICK_LABEL_CLASS,!0);c.append("text");var u=this._tierLabelPositions[i]==="center"||n.step===1?0:this.tickLabelPadding(),h;this.orientation()==="bottom"?h=Vu.sum(this._tierHeights.slice(0,i+1))-this.tickLabelPadding():this._tierLabelPositions[i]==="center"?h=this.height()-Vu.sum(this._tierHeights.slice(0,i))-this.tickLabelPadding()-this._maxLabelTickLength():h=this.height()-Vu.sum(this._tierHeights.slice(0,i))-this.tickLabelPadding();var f=l.merge(c),p=f.selectAll("text");p.size()>0&&p.attr("transform","translate("+u+","+h+")"),l.exit().remove(),f.attr("transform",function(g){return"translate("+o._scale.scale(g)+",0)"});var d=this._tierLabelPositions[i]==="center"||n.step===1?"middle":"start";f.selectAll("text").text(n.formatter).style("text-anchor",d)},t.prototype._renderTickMarks=function(r,n){var i=this._tierMarkContainers[n].selectAll("."+ts.Axis.TICK_MARK_CLASS).data(r),o=i.enter().append("line").classed(ts.Axis.TICK_MARK_CLASS,!0).merge(i),a=this._generateTickMarkAttrHash(),s=this._tierHeights.slice(0,n).reduce(function(l,c){return l+c},0);this.orientation()==="bottom"?(a.y1=s,a.y2=s+(this._tierLabelPositions[n]==="center"?this.innerTickLength():this._tierHeights[n])):(a.y1=this.height()-s,a.y2=this.height()-(s+(this._tierLabelPositions[n]==="center"?this.innerTickLength():this._tierHeights[n]))),o.attrs(a),this.orientation()==="bottom"?(a.y1=s,a.y2=s+(this._tierLabelPositions[n]==="center"?this.endTickLength():this._tierHeights[n])):(a.y1=this.height()-s,a.y2=this.height()-(s+(this._tierLabelPositions[n]==="center"?this.endTickLength():this._tierHeights[n]))),Vu.select(o.nodes()[0]).attrs(a),Vu.select(o.nodes()[o.size()-1]).attrs(a),Vu.select(o.nodes()[0]).classed(ts.Axis.END_TICK_MARK_CLASS,!0),Vu.select(o.nodes()[o.size()-1]).classed(ts.Axis.END_TICK_MARK_CLASS,!0),i.exit().remove()},t.prototype._renderLabellessTickMarks=function(r){var n=this._tickMarkContainer.selectAll("."+ts.Axis.TICK_MARK_CLASS).data(r),i=n.enter().append("line").classed(ts.Axis.TICK_MARK_CLASS,!0).merge(n),o=this._generateTickMarkAttrHash();o.y2=this.orientation()==="bottom"?this.tickLabelPadding():this.height()-this.tickLabelPadding(),i.attrs(o),n.exit().remove()},t.prototype._generateLabellessTicks=function(){return this._mostPreciseConfigIndex<1?[]:this._getTickIntervalValues(this._possibleTimeAxisConfigurations[this._mostPreciseConfigIndex-1][0])},t.prototype.renderImmediately=function(){var r=this;this._mostPreciseConfigIndex=this._getMostPreciseConfigurationIndex();var n=this._possibleTimeAxisConfigurations[this._mostPreciseConfigIndex];this._cleanTiers(),n.forEach(function(h,f){return r._renderTierLabels(r._tierLabelContainers[f],h,f)});for(var i=n.map(function(h,f){return r._getTickValuesForConfiguration(h)}),o=0,a=0;a<Math.max(n.length,1);++a){var s=this._generateBaselineAttrHash();s.y1+=this.orientation()==="bottom"?o:-o,s.y2=s.y1,this._tierBaselines[a].attrs(s).style("visibility","inherit"),o+=this._tierHeights[a]}var l=[],c=this._scale.domain(),u=this._scale.scale(c[1])-this._scale.scale(c[0]);this._getIntervalLength(n[0])*1.5>=u&&(l=this._generateLabellessTicks()),this._renderLabellessTickMarks(l),this._hideOverflowingTiers();for(var a=0;a<n.length;++a)this._renderTickMarks(i[a],a),this._hideOverlappingAndCutOffLabels(a);return this.annotationsEnabled()?this._drawAnnotations():this._removeAnnotations(),this},t.prototype._hideOverflowingTiers=function(){var r=this,n=this.height(),i=0;this.content().selectAll("."+t.TIME_AXIS_TIER_CLASS).attr("visibility",function(o,a){return i+=r._tierHeights[a],i<=n?"inherit":"hidden"})},t.prototype._hideOverlappingAndCutOffLabels=function(r){var n=this,i=this.element().node().getBoundingClientRect(),o=function(u){return Math.floor(i.left)<=Math.ceil(u.left)&&Math.floor(i.top)<=Math.ceil(u.top)&&Math.floor(u.right)<=Math.ceil(i.left+n.width())&&Math.floor(u.bottom)<=Math.ceil(i.top+n.height())},a=this._tierMarkContainers[r].selectAll("."+ts.Axis.TICK_MARK_CLASS).filter(function(u,h){var f=Vu.select(this).style("visibility");return f==="visible"||f==="inherit"}),s=a.nodes().map(function(u){return u.getBoundingClientRect()}),l=this._tierLabelContainers[r].selectAll("."+ts.Axis.TICK_LABEL_CLASS).filter(function(u,h){var f=Vu.select(this).style("visibility");return f==="visible"||f==="inherit"}),c;l.each(function(u,h){var f=this.getBoundingClientRect(),p=Vu.select(this),d=s[h],g=s[h+1],_=c!=null&&n4.DOM.clientRectsOverlap(f,c),y=d!=null&&n4.DOM.clientRectsOverlap(f,d),x=g!=null&&n4.DOM.clientRectsOverlap(f,g);!o(f)||_||y||x?p.style("visibility","hidden"):(c=f,p.style("visibility","inherit"))})},t.prototype.invalidateCache=function(){e.prototype.invalidateCache.call(this),this._measurer.reset()},t.TIME_AXIS_TIER_CLASS="time-axis-tier",t._SORTED_TIME_INTERVAL_INDEX=(xd={},xd[Se.TimeInterval.second]=0,xd[Se.TimeInterval.minute]=1,xd[Se.TimeInterval.hour]=2,xd[Se.TimeInterval.day]=3,xd[Se.TimeInterval.week]=4,xd[Se.TimeInterval.month]=5,xd[Se.TimeInterval.year]=6,xd),t._DEFAULT_TIME_AXIS_CONFIGURATIONS=function(r){var n=function(i){return h$t.time(i,r)};return[[{interval:Se.TimeInterval.second,step:1,formatter:n("%I:%M:%S %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.second,step:5,formatter:n("%I:%M:%S %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.second,step:10,formatter:n("%I:%M:%S %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.second,step:15,formatter:n("%I:%M:%S %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.second,step:30,formatter:n("%I:%M:%S %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.minute,step:1,formatter:n("%I:%M %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.minute,step:5,formatter:n("%I:%M %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.minute,step:10,formatter:n("%I:%M %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.minute,step:15,formatter:n("%I:%M %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.minute,step:30,formatter:n("%I:%M %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.hour,step:1,formatter:n("%I %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.hour,step:3,formatter:n("%I %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.hour,step:6,formatter:n("%I %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.hour,step:12,formatter:n("%I %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.day,step:1,formatter:n("%a %e")},{interval:Se.TimeInterval.month,step:1,formatter:n("%B %Y")}],[{interval:Se.TimeInterval.day,step:1,formatter:n("%e")},{interval:Se.TimeInterval.month,step:1,formatter:n("%B %Y")}],[{interval:Se.TimeInterval.month,step:1,formatter:n("%B")},{interval:Se.TimeInterval.year,step:1,formatter:n("%Y")}],[{interval:Se.TimeInterval.month,step:1,formatter:n("%b")},{interval:Se.TimeInterval.year,step:1,formatter:n("%Y")}],[{interval:Se.TimeInterval.month,step:3,formatter:n("%b")},{interval:Se.TimeInterval.year,step:1,formatter:n("%Y")}],[{interval:Se.TimeInterval.month,step:6,formatter:n("%b")},{interval:Se.TimeInterval.year,step:1,formatter:n("%Y")}],[{interval:Se.TimeInterval.year,step:1,formatter:n("%Y")}],[{interval:Se.TimeInterval.year,step:1,formatter:n("%y")}],[{interval:Se.TimeInterval.year,step:5,formatter:n("%Y")}],[{interval:Se.TimeInterval.year,step:25,formatter:n("%Y")}],[{interval:Se.TimeInterval.year,step:50,formatter:n("%Y")}],[{interval:Se.TimeInterval.year,step:100,formatter:n("%Y")}],[{interval:Se.TimeInterval.year,step:200,formatter:n("%Y")}],[{interval:Se.TimeInterval.year,step:500,formatter:n("%Y")}],[{interval:Se.TimeInterval.year,step:1e3,formatter:n("%Y")}]]},t._LONG_DATE=new Date(9999,8,29,12,59,9999),t}(ts.Axis);Se.Time=LFe;var xd});var f$t=H(i4=>{"use strict";Object.defineProperty(i4,"__esModule",{value:!0});var hot=(de(),Ut(pe));hot.__exportStar($Xt(),i4);hot.__exportStar(KXt(),i4);hot.__exportStar(HF(),i4)});var o4=H(fot=>{"use strict";Object.defineProperty(fot,"__esModule",{value:!0});var kFe=Fe(),RFe=function(){function e(){this._eventToProcessingFunction={},this._eventTarget=document,this._eventNameToCallbackSet={},this._connected=!1}return e.prototype._hasNoCallbacks=function(){for(var t=Object.keys(this._eventNameToCallbackSet),r=0;r<t.length;r++)if(this._eventNameToCallbackSet[t[r]].size!==0)return!1;return!0},e.prototype._connect=function(){var t=this;this._connected||(Object.keys(this._eventToProcessingFunction).forEach(function(r){var n=t._eventToProcessingFunction[r],i=r==="wheel"?{passive:!1}:void 0;t._eventTarget.addEventListener(r,n,i)}),this._connected=!0)},e.prototype._disconnect=function(){var t=this;this._connected&&this._hasNoCallbacks()&&(Object.keys(this._eventToProcessingFunction).forEach(function(r){var n=t._eventToProcessingFunction[r];t._eventTarget.removeEventListener(r,n)}),this._connected=!1)},e.prototype._addCallbackForEvent=function(t,r){this._eventNameToCallbackSet[t]==null&&(this._eventNameToCallbackSet[t]=new kFe.CallbackSet),this._eventNameToCallbackSet[t].add(r),this._connect()},e.prototype._removeCallbackForEvent=function(t,r){this._eventNameToCallbackSet[t]!=null&&this._eventNameToCallbackSet[t].delete(r),this._disconnect()},e.prototype._callCallbacksForEvent=function(t){for(var r=[],n=1;n<arguments.length;n++)r[n-1]=arguments[n];var i=this._eventNameToCallbackSet[t];i!=null&&i.callCallbacks.apply(i,r)},e}();fot.Dispatcher=RFe});var p$t=H(pot=>{"use strict";Object.defineProperty(pot,"__esModule",{value:!0});var NFe=(de(),Ut(pe)),DFe=o4(),OFe=function(e){NFe.__extends(t,e);function t(){var r=e.call(this)||this;return r._eventToProcessingFunction[t._KEYDOWN_EVENT_NAME]=function(n){return r._processKeydown(n)},r._eventToProcessingFunction[t._KEYUP_EVENT_NAME]=function(n){return r._processKeyup(n)},r}return t.getDispatcher=function(){var r=document[t._DISPATCHER_KEY];return r==null&&(r=new t,document[t._DISPATCHER_KEY]=r),r},t.prototype._processKeydown=function(r){this._callCallbacksForEvent(t._KEYDOWN_EVENT_NAME,r.keyCode,r)},t.prototype._processKeyup=function(r){this._callCallbacksForEvent(t._KEYUP_EVENT_NAME,r.keyCode,r)},t.prototype.onKeyDown=function(r){return this._addCallbackForEvent(t._KEYDOWN_EVENT_NAME,r),this},t.prototype.offKeyDown=function(r){return this._removeCallbackForEvent(t._KEYDOWN_EVENT_NAME,r),this},t.prototype.onKeyUp=function(r){return this._addCallbackForEvent(t._KEYUP_EVENT_NAME,r),this},t.prototype.offKeyUp=function(r){return this._removeCallbackForEvent(t._KEYUP_EVENT_NAME,r),this},t._DISPATCHER_KEY="__Plottable_Dispatcher_Key",t._KEYDOWN_EVENT_NAME="keydown",t._KEYUP_EVENT_NAME="keyup",t}(DFe.Dispatcher);pot.Key=OFe});var m$t=H(dot=>{"use strict";Object.defineProperty(dot,"__esModule",{value:!0});var zFe=(de(),Ut(pe)),d$t=Fe(),FFe=o4(),BFe=function(e){zFe.__extends(t,e);function t(r){var n=e.call(this)||this;n._lastMousePosition={x:-1,y:-1},n._translator=d$t.getTranslator(r);var i=function(o){return n._measureAndDispatch(r,o,t._MOUSEMOVE_EVENT_NAME,"page")};return n._eventToProcessingFunction[t._MOUSEOVER_EVENT_NAME]=i,n._eventToProcessingFunction[t._MOUSEMOVE_EVENT_NAME]=i,n._eventToProcessingFunction[t._MOUSEOUT_EVENT_NAME]=i,n._eventToProcessingFunction[t._MOUSEDOWN_EVENT_NAME]=function(o){return n._measureAndDispatch(r,o,t._MOUSEDOWN_EVENT_NAME)},n._eventToProcessingFunction[t._MOUSEUP_EVENT_NAME]=function(o){return n._measureAndDispatch(r,o,t._MOUSEUP_EVENT_NAME,"page")},n._eventToProcessingFunction[t._WHEEL_EVENT_NAME]=function(o){return n._measureAndDispatch(r,o,t._WHEEL_EVENT_NAME)},n._eventToProcessingFunction[t._DBLCLICK_EVENT_NAME]=function(o){return n._measureAndDispatch(r,o,t._DBLCLICK_EVENT_NAME)},n}return t.getDispatcher=function(r){var n=r.root().rootElement(),i=n[t._DISPATCHER_KEY];return i==null&&(i=new t(r),n[t._DISPATCHER_KEY]=i),i},t.prototype.onMouseMove=function(r){return this._addCallbackForEvent(t._MOUSEMOVE_EVENT_NAME,r),this},t.prototype.offMouseMove=function(r){return this._removeCallbackForEvent(t._MOUSEMOVE_EVENT_NAME,r),this},t.prototype.onMouseDown=function(r){return this._addCallbackForEvent(t._MOUSEDOWN_EVENT_NAME,r),this},t.prototype.offMouseDown=function(r){return this._removeCallbackForEvent(t._MOUSEDOWN_EVENT_NAME,r),this},t.prototype.onMouseUp=function(r){return this._addCallbackForEvent(t._MOUSEUP_EVENT_NAME,r),this},t.prototype.offMouseUp=function(r){return this._removeCallbackForEvent(t._MOUSEUP_EVENT_NAME,r),this},t.prototype.onWheel=function(r){return this._addCallbackForEvent(t._WHEEL_EVENT_NAME,r),this},t.prototype.offWheel=function(r){return this._removeCallbackForEvent(t._WHEEL_EVENT_NAME,r),this},t.prototype.onDblClick=function(r){return this._addCallbackForEvent(t._DBLCLICK_EVENT_NAME,r),this},t.prototype.offDblClick=function(r){return this._removeCallbackForEvent(t._DBLCLICK_EVENT_NAME,r),this},t.prototype._measureAndDispatch=function(r,n,i,o){if(o===void 0&&(o="element"),o!=="page"&&o!=="element")throw new Error("Invalid scope '"+o+"', must be 'element' or 'page'");if(o==="page"||this.eventInside(r,n)){var a=this._translator.computePosition(n.clientX,n.clientY);this._lastMousePosition=a,this._callCallbacksForEvent(i,this.lastMousePosition(),n)}},t.prototype.eventInside=function(r,n){return d$t.Translator.isEventInside(r,n)},t.prototype.lastMousePosition=function(){return this._lastMousePosition},t._DISPATCHER_KEY="__Plottable_Dispatcher_Mouse",t._MOUSEOVER_EVENT_NAME="mouseover",t._MOUSEMOVE_EVENT_NAME="mousemove",t._MOUSEOUT_EVENT_NAME="mouseout",t._MOUSEDOWN_EVENT_NAME="mousedown",t._MOUSEUP_EVENT_NAME="mouseup",t._WHEEL_EVENT_NAME="wheel",t._DBLCLICK_EVENT_NAME="dblclick",t}(FFe.Dispatcher);dot.Mouse=BFe});var _$t=H(mot=>{"use strict";Object.defineProperty(mot,"__esModule",{value:!0});var HFe=(de(),Ut(pe)),g$t=Fe(),VFe=o4(),UFe=function(e){HFe.__extends(t,e);function t(r){var n=e.call(this)||this;return n._translator=g$t.getTranslator(r),n._eventToProcessingFunction[t._TOUCHSTART_EVENT_NAME]=function(i){return n._measureAndDispatch(r,i,t._TOUCHSTART_EVENT_NAME,"page")},n._eventToProcessingFunction[t._TOUCHMOVE_EVENT_NAME]=function(i){return n._measureAndDispatch(r,i,t._TOUCHMOVE_EVENT_NAME,"page")},n._eventToProcessingFunction[t._TOUCHEND_EVENT_NAME]=function(i){return n._measureAndDispatch(r,i,t._TOUCHEND_EVENT_NAME,"page")},n._eventToProcessingFunction[t._TOUCHCANCEL_EVENT_NAME]=function(i){return n._measureAndDispatch(r,i,t._TOUCHCANCEL_EVENT_NAME,"page")},n}return t.getDispatcher=function(r){var n=r.root().rootElement(),i=n[t._DISPATCHER_KEY];return i==null&&(i=new t(r),n[t._DISPATCHER_KEY]=i),i},t.prototype.onTouchStart=function(r){return this._addCallbackForEvent(t._TOUCHSTART_EVENT_NAME,r),this},t.prototype.offTouchStart=function(r){return this._removeCallbackForEvent(t._TOUCHSTART_EVENT_NAME,r),this},t.prototype.onTouchMove=function(r){return this._addCallbackForEvent(t._TOUCHMOVE_EVENT_NAME,r),this},t.prototype.offTouchMove=function(r){return this._removeCallbackForEvent(t._TOUCHMOVE_EVENT_NAME,r),this},t.prototype.onTouchEnd=function(r){return this._addCallbackForEvent(t._TOUCHEND_EVENT_NAME,r),this},t.prototype.offTouchEnd=function(r){return this._removeCallbackForEvent(t._TOUCHEND_EVENT_NAME,r),this},t.prototype.onTouchCancel=function(r){return this._addCallbackForEvent(t._TOUCHCANCEL_EVENT_NAME,r),this},t.prototype.offTouchCancel=function(r){return this._removeCallbackForEvent(t._TOUCHCANCEL_EVENT_NAME,r),this},t.prototype._measureAndDispatch=function(r,n,i,o){if(o===void 0&&(o="element"),o!=="page"&&o!=="element")throw new Error("Invalid scope '"+o+"', must be 'element' or 'page'");if(!(o==="element"&&!this.eventInside(r,n))){for(var a=n.changedTouches,s={},l=[],c=0;c<a.length;c++){var u=a[c],h=u.identifier,f=this._translator.computePosition(u.clientX,u.clientY);f!=null&&(s[h]=f,l.push(h))}l.length>0&&this._callCallbacksForEvent(i,l,s,n)}},t.prototype.eventInside=function(r,n){return g$t.Translator.isEventInside(r,n)},t._DISPATCHER_KEY="__Plottable_Dispatcher_Touch",t._TOUCHSTART_EVENT_NAME="touchstart",t._TOUCHMOVE_EVENT_NAME="touchmove",t._TOUCHEND_EVENT_NAME="touchend",t._TOUCHCANCEL_EVENT_NAME="touchcancel",t}(VFe.Dispatcher);mot.Touch=UFe});var Nv=H(a4=>{"use strict";Object.defineProperty(a4,"__esModule",{value:!0});var got=(de(),Ut(pe));got.__exportStar(p$t(),a4);got.__exportStar(m$t(),a4);got.__exportStar(_$t(),a4)});var Dv=H(_ot=>{"use strict";Object.defineProperty(_ot,"__esModule",{value:!0});var qFe=function(){function e(){var t=this;this._anchorCallback=function(r){return t._anchor(r)},this._enabled=!0}return e.prototype.attachTo=function(t){return this._disconnect(),this._componentAttachedTo=t,this._connect(),this},e.prototype.detachFrom=function(t){return this.detach()},e.prototype.detach=function(){return this._disconnect(),this._componentAttachedTo=null,this},e.prototype.enabled=function(t){return t==null?this._enabled:(this._enabled=t,this._enabled?this._connect():this._disconnect(),this)},e.prototype._anchor=function(t){this._isAnchored=!0},e.prototype._unanchor=function(){this._isAnchored=!1},e.prototype._translateToComponentSpace=function(t){var r=this._componentAttachedTo.originToRoot();return{x:t.x-r.x,y:t.y-r.y}},e.prototype._isInsideComponent=function(t){return 0<=t.x&&0<=t.y&&t.x<=this._componentAttachedTo.width()&&t.y<=this._componentAttachedTo.height()},e.prototype._connect=function(){this.enabled()&&this._componentAttachedTo!=null&&!this._isAnchored&&this._componentAttachedTo.onAnchor(this._anchorCallback)},e.prototype._disconnect=function(){this._isAnchored&&this._unanchor(),this._componentAttachedTo!=null&&this._componentAttachedTo.offAnchor(this._anchorCallback)},e}();_ot.Interaction=qFe});var x$t=H(yot=>{"use strict";Object.defineProperty(yot,"__esModule",{value:!0});var GFe=(de(),Ut(pe)),y$t=Nv(),v$t=Fe(),WFe=Dv(),YFe=function(e){GFe.__extends(t,e);function t(){var r=e!==null&&e.apply(this,arguments)||this;return r._clickedDown=!1,r._doubleClicking=!1,r._onClickCallbacks=new v$t.CallbackSet,r._onDoubleClickCallbacks=new v$t.CallbackSet,r._mouseDownCallback=function(n,i){return r._handleClickDown(n,i)},r._mouseUpCallback=function(n,i){return r._handleClickUp(n,i)},r._dblClickCallback=function(n,i){return r._handleDblClick(n,i)},r._touchStartCallback=function(n,i,o){return r._handleClickDown(i[n[0]],o)},r._touchEndCallback=function(n,i,o){return r._handleClickUp(i[n[0]],o)},r._touchCancelCallback=function(n,i){return r._clickedDown=!1},r}return t.prototype._anchor=function(r){e.prototype._anchor.call(this,r),this._mouseDispatcher=y$t.Mouse.getDispatcher(r),this._mouseDispatcher.onMouseDown(this._mouseDownCallback),this._mouseDispatcher.onMouseUp(this._mouseUpCallback),this._mouseDispatcher.onDblClick(this._dblClickCallback),this._touchDispatcher=y$t.Touch.getDispatcher(r),this._touchDispatcher.onTouchStart(this._touchStartCallback),this._touchDispatcher.onTouchEnd(this._touchEndCallback),this._touchDispatcher.onTouchCancel(this._touchCancelCallback)},t.prototype._unanchor=function(){e.prototype._unanchor.call(this),this._mouseDispatcher.offMouseDown(this._mouseDownCallback),this._mouseDispatcher.offMouseUp(this._mouseUpCallback),this._mouseDispatcher.offDblClick(this._dblClickCallback),this._mouseDispatcher=null,this._touchDispatcher.offTouchStart(this._touchStartCallback),this._touchDispatcher.offTouchEnd(this._touchEndCallback),this._touchDispatcher.offTouchCancel(this._touchCancelCallback),this._touchDispatcher=null},t.prototype._handleClickDown=function(r,n){var i=this._translateToComponentSpace(r);this._isInsideComponent(i)&&(this._clickedDown=!0,this._clickedPoint=i)},t.prototype._handleClickUp=function(r,n){var i=this,o=this._translateToComponentSpace(r);this._clickedDown&&t._pointsEqual(o,this._clickedPoint)&&setTimeout(function(){i._doubleClicking||i._onClickCallbacks.callCallbacks(o,n)},0),this._clickedDown=!1},t.prototype._handleDblClick=function(r,n){var i=this,o=this._translateToComponentSpace(r);this._doubleClicking=!0,this._onDoubleClickCallbacks.callCallbacks(o,n),setTimeout(function(){return i._doubleClicking=!1},0)},t._pointsEqual=function(r,n){return r.x===n.x&&r.y===n.y},t.prototype.onClick=function(r){return this._onClickCallbacks.add(r),this},t.prototype.offClick=function(r){return this._onClickCallbacks.delete(r),this},t.prototype.onDoubleClick=function(r){return this._onDoubleClickCallbacks.add(r),this},t.prototype.offDoubleClick=function(r){return this._onDoubleClickCallbacks.delete(r),this},t}(WFe.Interaction);yot.Click=YFe});var w$t=H(vot=>{"use strict";Object.defineProperty(vot,"__esModule",{value:!0});var jFe=(de(),Ut(pe)),b$t=Nv(),s4=Fe(),XFe=Dv(),$Fe=function(e){jFe.__extends(t,e);function t(r){var n=e.call(this)||this;return n._dragging=!1,n._constrainedToComponent=!0,n._mouseFilter=t._DEFAULT_MOUSE_FILTER,n._dragStartCallbacks=new s4.CallbackSet,n._dragCallbacks=new s4.CallbackSet,n._dragEndCallbacks=new s4.CallbackSet,n._mouseDownCallback=function(i,o){return n._startDrag(i,o)},n._mouseMoveCallback=function(i,o){return n._doDrag(i,o)},n._mouseUpCallback=function(i,o){return n._endDrag(i,o)},n._touchStartCallback=function(i,o,a){return n._startDrag(o[i[0]],a)},n._touchMoveCallback=function(i,o,a){return n._doDrag(o[i[0]],a)},n._touchEndCallback=function(i,o,a){return n._endDrag(o[i[0]],a)},n._mouseButton=r!==void 0?r:0,n}return t.prototype._anchor=function(r){e.prototype._anchor.call(this,r),this._mouseDispatcher=b$t.Mouse.getDispatcher(this._componentAttachedTo),this._mouseDispatcher.onMouseDown(this._mouseDownCallback),this._mouseDispatcher.onMouseMove(this._mouseMoveCallback),this._mouseDispatcher.onMouseUp(this._mouseUpCallback),this._touchDispatcher=b$t.Touch.getDispatcher(this._componentAttachedTo),this._touchDispatcher.onTouchStart(this._touchStartCallback),this._touchDispatcher.onTouchMove(this._touchMoveCallback),this._touchDispatcher.onTouchEnd(this._touchEndCallback)},t.prototype._unanchor=function(){e.prototype._unanchor.call(this),this._mouseDispatcher.offMouseDown(this._mouseDownCallback),this._mouseDispatcher.offMouseMove(this._mouseMoveCallback),this._mouseDispatcher.offMouseUp(this._mouseUpCallback),this._mouseDispatcher=null,this._touchDispatcher.offTouchStart(this._touchStartCallback),this._touchDispatcher.offTouchMove(this._touchMoveCallback),this._touchDispatcher.offTouchEnd(this._touchEndCallback),this._touchDispatcher=null},t.prototype._translateAndConstrain=function(r){var n=this._translateToComponentSpace(r);return this._constrainedToComponent?{x:s4.Math.clamp(n.x,0,this._componentAttachedTo.width()),y:s4.Math.clamp(n.y,0,this._componentAttachedTo.height())}:n},t.prototype._startDrag=function(r,n){if(!(n instanceof MouseEvent&&!this._mouseFilter(n))){var i=this._translateToComponentSpace(r);this._isInsideComponent(i)&&(n.preventDefault(),this._dragging=!0,this._dragOrigin=i,this._dragStartCallbacks.callCallbacks(this._dragOrigin))}},t.prototype._doDrag=function(r,n){this._dragging&&this._dragCallbacks.callCallbacks(this._dragOrigin,this._translateAndConstrain(r))},t.prototype._endDrag=function(r,n){n instanceof MouseEvent&&n.button!==this._mouseButton||this._dragging&&(this._dragging=!1,this._dragEndCallbacks.callCallbacks(this._dragOrigin,this._translateAndConstrain(r)))},t.prototype.constrainedToComponent=function(r){return r==null?this._constrainedToComponent:(this._constrainedToComponent=r,this)},t.prototype.mouseFilter=function(r){return arguments.length===0?this._mouseFilter:(this._mouseFilter=r,this)},t.prototype.onDragStart=function(r){return this._dragStartCallbacks.add(r),this},t.prototype.offDragStart=function(r){return this._dragStartCallbacks.delete(r),this},t.prototype.onDrag=function(r){return this._dragCallbacks.add(r),this},t.prototype.offDrag=function(r){return this._dragCallbacks.delete(r),this},t.prototype.onDragEnd=function(r){return this._dragEndCallbacks.add(r),this},t.prototype.offDragEnd=function(r){return this._dragEndCallbacks.delete(r),this},t._DEFAULT_MOUSE_FILTER=function(r){return r.button===0},t}(XFe.Interaction);vot.Drag=$Fe});var wot=H(bot=>{"use strict";Object.defineProperty(bot,"__esModule",{value:!0});var KFe=(de(),Ut(pe)),S$t=Nv(),xot=Fe(),ZFe=Dv(),JFe=function(e){KFe.__extends(t,e);function t(){var r=e!==null&&e.apply(this,arguments)||this;return r._keyPressCallbacks={},r._keyReleaseCallbacks={},r._mouseMoveCallback=function(n){return!1},r._downedKeys=new xot.Set,r._keyDownCallback=function(n,i){return r._handleKeyDownEvent(n,i)},r._keyUpCallback=function(n){return r._handleKeyUpEvent(n)},r}return t.prototype._anchor=function(r){e.prototype._anchor.call(this,r),this._positionDispatcher=S$t.Mouse.getDispatcher(this._componentAttachedTo),this._positionDispatcher.onMouseMove(this._mouseMoveCallback),this._keyDispatcher=S$t.Key.getDispatcher(),this._keyDispatcher.onKeyDown(this._keyDownCallback),this._keyDispatcher.onKeyUp(this._keyUpCallback)},t.prototype._unanchor=function(){e.prototype._unanchor.call(this),this._positionDispatcher.offMouseMove(this._mouseMoveCallback),this._positionDispatcher=null,this._keyDispatcher.offKeyDown(this._keyDownCallback),this._keyDispatcher.offKeyUp(this._keyUpCallback),this._keyDispatcher=null},t.prototype._handleKeyDownEvent=function(r,n){var i=this._translateToComponentSpace(this._positionDispatcher.lastMousePosition());this._isInsideComponent(i)&&!n.repeat&&(this._keyPressCallbacks[r]&&this._keyPressCallbacks[r].callCallbacks(r),this._downedKeys.add(r))},t.prototype._handleKeyUpEvent=function(r){this._downedKeys.has(r)&&this._keyReleaseCallbacks[r]&&this._keyReleaseCallbacks[r].callCallbacks(r),this._downedKeys.delete(r)},t.prototype.onKeyPress=function(r,n){return this._keyPressCallbacks[r]||(this._keyPressCallbacks[r]=new xot.CallbackSet),this._keyPressCallbacks[r].add(n),this},t.prototype.offKeyPress=function(r,n){return this._keyPressCallbacks[r].delete(n),this._keyPressCallbacks[r].size===0&&delete this._keyPressCallbacks[r],this},t.prototype.onKeyRelease=function(r,n){return this._keyReleaseCallbacks[r]||(this._keyReleaseCallbacks[r]=new xot.CallbackSet),this._keyReleaseCallbacks[r].add(n),this},t.prototype.offKeyRelease=function(r,n){return this._keyReleaseCallbacks[r].delete(n),this._keyReleaseCallbacks[r].size===0&&delete this._keyReleaseCallbacks[r],this},t}(ZFe.Interaction);bot.Key=JFe});var C$t=H(Sot=>{"use strict";Object.defineProperty(Sot,"__esModule",{value:!0});var QFe=(de(),Ut(pe)),tBe=(Er(),Ut(Mr)),M$t=Nv(),E$t=ks(),yl=Fe(),eBe=l4(),rBe=Dv(),T$t=e4(),nBe=function(e){QFe.__extends(t,e);function t(r,n){var i=e.call(this)||this;return i._wheelFilter=function(o){return!0},i._wheelCallback=function(o,a){return i._handleWheelEvent(o,a)},i._touchStartCallback=function(o,a,s){return i._handleTouchStart(o,a,s)},i._touchMoveCallback=function(o,a,s){return i._handlePinch(o,a,s)},i._touchEndCallback=function(o,a,s){return i._handleTouchEnd(o,a,s)},i._touchCancelCallback=function(o,a,s){return i._handleTouchEnd(o,a,s)},i._panEndCallbacks=new yl.CallbackSet,i._zoomEndCallbacks=new yl.CallbackSet,i._panZoomUpdateCallbacks=new yl.CallbackSet,i._xScales=new yl.Set,i._yScales=new yl.Set,i._dragInteraction=new eBe.Drag,i._setupDragInteraction(),i._touchIds=tBe.map(),i._minDomainExtents=new yl.Map,i._maxDomainExtents=new yl.Map,i._minDomainValues=new yl.Map,i._maxDomainValues=new yl.Map,r!=null&&i.addXScale(r),n!=null&&i.addYScale(n),i}return t.prototype.dragInteraction=function(){return this._dragInteraction},t.prototype.wheelFilter=function(r){return arguments.length===0?this._wheelFilter:(this._wheelFilter=r,this)},t.prototype.pan=function(r){var n=this;this.xScales().forEach(function(i){i.pan(n._constrainedTranslation(i,r.x))}),this.yScales().forEach(function(i){i.pan(n._constrainedTranslation(i,r.y))}),this._panZoomUpdateCallbacks.callCallbacks()},t.prototype.zoom=function(r,n,i){var o=this;i===void 0&&(i=!0);var a,s;return n!=null&&(a=n.x,s=n.y,i&&(this.xScales().forEach(function(l){var c=o._constrainedZoom(l,r,a);a=c.centerPoint,r=c.zoomAmount}),this.yScales().forEach(function(l){var c=o._constrainedZoom(l,r,s);s=c.centerPoint,r=c.zoomAmount}))),this.xScales().forEach(function(l){var c=l.range(),u=a==null?(c[1]+c[0])/2:a;l.zoom(r,u)}),this.yScales().forEach(function(l){var c=l.range(),u=s==null?(c[1]+c[0])/2:s;l.zoom(r,u)}),this._panZoomUpdateCallbacks.callCallbacks(),{zoomAmount:r,centerValue:{centerX:a,centerY:s}}},t.prototype._anchor=function(r){e.prototype._anchor.call(this,r),this._dragInteraction.attachTo(r),this._mouseDispatcher=M$t.Mouse.getDispatcher(this._componentAttachedTo),this._mouseDispatcher.onWheel(this._wheelCallback),this._touchDispatcher=M$t.Touch.getDispatcher(this._componentAttachedTo),this._touchDispatcher.onTouchStart(this._touchStartCallback),this._touchDispatcher.onTouchMove(this._touchMoveCallback),this._touchDispatcher.onTouchEnd(this._touchEndCallback),this._touchDispatcher.onTouchCancel(this._touchCancelCallback)},t.prototype._unanchor=function(){e.prototype._unanchor.call(this),this._mouseDispatcher.offWheel(this._wheelCallback),this._mouseDispatcher=null,this._touchDispatcher.offTouchStart(this._touchStartCallback),this._touchDispatcher.offTouchMove(this._touchMoveCallback),this._touchDispatcher.offTouchEnd(this._touchEndCallback),this._touchDispatcher.offTouchCancel(this._touchCancelCallback),this._touchDispatcher=null,this._dragInteraction.detach()},t.prototype._handleTouchStart=function(r,n,i){for(var o=0;o<r.length&&this._touchIds.size()<2;o++){var a=r[o];this._touchIds.set(a.toString(),this._translateToComponentSpace(n[a]))}},t.prototype._handlePinch=function(r,n,i){var o=this;if(!(this._touchIds.size()<2)){var a=this._touchIds.values();if(!(!this._isInsideComponent(this._translateToComponentSpace(a[0]))||!this._isInsideComponent(this._translateToComponentSpace(a[1])))){var s=t._pointDistance(a[0],a[1]);if(s!==0){r.forEach(function(S){o._touchIds.has(S.toString())&&o._touchIds.set(S.toString(),o._translateToComponentSpace(n[S]))});var l=this._touchIds.values(),c=t._pointDistance(l[0],l[1]);if(c!==0){var u=s/c,h=l.map(function(S,C){return{x:(S.x-a[C].x)/u,y:(S.y-a[C].y)/u}}),f=t.centerPoint(a[0],a[1]),p=this.zoom(u,f),d=p.centerValue,g=p.zoomAmount,_=d.centerX,y=d.centerY,x=a.map(function(S,C){return{x:h[C].x*g+S.x,y:h[C].y*g+S.y}}),b={x:_-(x[0].x+x[1].x)/2,y:y-(x[0].y+x[1].y)/2};this.pan(b)}}}}},t.centerPoint=function(r,n){var i=Math.min(r.x,n.x),o=Math.max(r.x,n.x),a=Math.min(r.y,n.y),s=Math.max(r.y,n.y);return{x:(i+o)/2,y:(s+a)/2}},t._pointDistance=function(r,n){var i=Math.min(r.x,n.x),o=Math.max(r.x,n.x),a=Math.min(r.y,n.y),s=Math.max(r.y,n.y);return Math.sqrt(Math.pow(o-i,2)+Math.pow(s-a,2))},t.prototype._handleTouchEnd=function(r,n,i){var o=this;r.forEach(function(a){o._touchIds.remove(a.toString())}),this._touchIds.size()>0&&this._zoomEndCallbacks.callCallbacks()},t.prototype._handleWheelEvent=function(r,n){if(!!this._wheelFilter(n)){var i=this._translateToComponentSpace(r);if(this._isInsideComponent(i)){n.preventDefault();var o=n.deltaY!==0?n.deltaY:n.deltaX,a=o*(n.deltaMode?t._PIXELS_PER_LINE:1),s=Math.pow(2,a*.002);this.zoom(s,i),this._zoomEndCallbacks.callCallbacks()}}},t.prototype._constrainedZoom=function(r,n,i){return T$t.constrainedZoom(r,n,i,this.minDomainExtent(r),this.maxDomainExtent(r),this.minDomainValue(r),this.maxDomainValue(r))},t.prototype._constrainedTranslation=function(r,n){return T$t.constrainedTranslation(r,n,this.minDomainValue(r),this.maxDomainValue(r))},t.prototype._setupDragInteraction=function(){var r=this;this._dragInteraction.constrainedToComponent(!1);var n;this._dragInteraction.onDragStart(function(){return n=null}),this._dragInteraction.onDrag(function(i,o){if(!(r._touchIds.size()>=2)){var a={x:(n==null?i.x:n.x)-o.x,y:(n==null?i.y:n.y)-o.y};r.pan(a),n=o}}),this._dragInteraction.onDragEnd(function(){return r._panEndCallbacks.callCallbacks()})},t.prototype._nonLinearScaleWithExtents=function(r){return this.minDomainExtent(r)!=null&&this.maxDomainExtent(r)!=null&&!(r instanceof E$t.Linear)&&!(r instanceof E$t.Time)},t.prototype.xScales=function(r){var n=this;if(r==null){var i=[];return this._xScales.forEach(function(o){i.push(o)}),i}return this._xScales=new yl.Set,r.forEach(function(o){n.addXScale(o)}),this},t.prototype.yScales=function(r){var n=this;if(r==null){var i=[];return this._yScales.forEach(function(o){i.push(o)}),i}return this._yScales=new yl.Set,r.forEach(function(o){n.addYScale(o)}),this},t.prototype.addXScale=function(r){return this._xScales.add(r),this},t.prototype.removeXScale=function(r){return this._xScales.delete(r),this._minDomainExtents.delete(r),this._maxDomainExtents.delete(r),this._minDomainValues.delete(r),this._maxDomainValues.delete(r),this},t.prototype.addYScale=function(r){return this._yScales.add(r),this},t.prototype.removeYScale=function(r){return this._yScales.delete(r),this._minDomainExtents.delete(r),this._maxDomainExtents.delete(r),this._minDomainValues.delete(r),this._maxDomainValues.delete(r),this},t.prototype.minDomainExtent=function(r,n){if(n==null)return this._minDomainExtents.get(r);if(n.valueOf()<0)throw new Error("extent must be non-negative");var i=this.maxDomainExtent(r);if(i!=null&&i.valueOf()<n.valueOf())throw new Error("minDomainExtent must be smaller than maxDomainExtent for the same Scale");return this._nonLinearScaleWithExtents(r)&&yl.Window.warn("Panning and zooming with extents on a nonlinear scale may have unintended behavior."),this._minDomainExtents.set(r,n),this},t.prototype.maxDomainExtent=function(r,n){if(n==null)return this._maxDomainExtents.get(r);if(n.valueOf()<=0)throw new Error("extent must be positive");var i=this.minDomainExtent(r);if(i!=null&&n.valueOf()<i.valueOf())throw new Error("maxDomainExtent must be larger than minDomainExtent for the same Scale");return this._nonLinearScaleWithExtents(r)&&yl.Window.warn("Panning and zooming with extents on a nonlinear scale may have unintended behavior."),this._maxDomainExtents.set(r,n),this},t.prototype.minDomainValue=function(r,n){return n==null?this._minDomainValues.get(r):(this._minDomainValues.set(r,n),this)},t.prototype.maxDomainValue=function(r,n){return n==null?this._maxDomainValues.get(r):(this._maxDomainValues.set(r,n),this)},t.prototype.setMinMaxDomainValuesTo=function(r){this._minDomainValues.delete(r),this._maxDomainValues.delete(r);var n=r.getTransformationDomain(),i=n[0],o=n[1];return this.minDomainValue(r,i),this.maxDomainValue(r,o),this},t.prototype.onPanEnd=function(r){return this._panEndCallbacks.add(r),this},t.prototype.offPanEnd=function(r){return this._panEndCallbacks.delete(r),this},t.prototype.onZoomEnd=function(r){return this._zoomEndCallbacks.add(r),this},t.prototype.offZoomEnd=function(r){return this._zoomEndCallbacks.delete(r),this},t.prototype.onPanZoomUpdate=function(r){return this._panZoomUpdateCallbacks.add(r),this},t.prototype.offPanZoomUpdate=function(r){return this._panZoomUpdateCallbacks.delete(r),this},t._PIXELS_PER_LINE=120,t}(rBe.Interaction);Sot.PanZoom=nBe});var P$t=H(Eot=>{"use strict";Object.defineProperty(Eot,"__esModule",{value:!0});var iBe=(de(),Ut(pe)),A$t=Nv(),Mot=Fe(),oBe=Dv(),aBe=function(e){iBe.__extends(t,e);function t(){var r=e!==null&&e.apply(this,arguments)||this;return r._overComponent=!1,r._pointerEnterCallbacks=new Mot.CallbackSet,r._pointerMoveCallbacks=new Mot.CallbackSet,r._pointerExitCallbacks=new Mot.CallbackSet,r._mouseMoveCallback=function(n,i){return r._handleMouseEvent(n,i)},r._touchStartCallback=function(n,i,o){return r._handleTouchEvent(i[n[0]],o)},r}return t.prototype._anchor=function(r){e.prototype._anchor.call(this,r),this._mouseDispatcher=A$t.Mouse.getDispatcher(this._componentAttachedTo),this._mouseDispatcher.onMouseMove(this._mouseMoveCallback),this._touchDispatcher=A$t.Touch.getDispatcher(this._componentAttachedTo),this._touchDispatcher.onTouchStart(this._touchStartCallback)},t.prototype._unanchor=function(){e.prototype._unanchor.call(this),this._mouseDispatcher.offMouseMove(this._mouseMoveCallback),this._mouseDispatcher=null,this._touchDispatcher.offTouchStart(this._touchStartCallback),this._touchDispatcher=null},t.prototype._handleMouseEvent=function(r,n){var i=this._mouseDispatcher.eventInside(this._componentAttachedTo,n);this._handlePointerEvent(r,i)},t.prototype._handleTouchEvent=function(r,n){var i=this._touchDispatcher.eventInside(this._componentAttachedTo,n);this._handlePointerEvent(r,i)},t.prototype._handlePointerEvent=function(r,n){var i=this._translateToComponentSpace(r),o=this._isInsideComponent(i);o&&n?(this._overComponent||this._pointerEnterCallbacks.callCallbacks(i),this._pointerMoveCallbacks.callCallbacks(i)):this._overComponent&&this._pointerExitCallbacks.callCallbacks(i),this._overComponent=o&&n},t.prototype.onPointerEnter=function(r){return this._pointerEnterCallbacks.add(r),this},t.prototype.offPointerEnter=function(r){return this._pointerEnterCallbacks.delete(r),this},t.prototype.onPointerMove=function(r){return this._pointerMoveCallbacks.add(r),this},t.prototype.offPointerMove=function(r){return this._pointerMoveCallbacks.delete(r),this},t.prototype.onPointerExit=function(r){return this._pointerExitCallbacks.add(r),this},t.prototype.offPointerExit=function(r){return this._pointerExitCallbacks.delete(r),this},t}(oBe.Interaction);Eot.Pointer=aBe});var l4=H(Zg=>{"use strict";Object.defineProperty(Zg,"__esModule",{value:!0});var c4=(de(),Ut(pe));c4.__exportStar(x$t(),Zg);c4.__exportStar(w$t(),Zg);c4.__exportStar(wot(),Zg);c4.__exportStar(C$t(),Zg);c4.__exportStar(P$t(),Zg);var sBe=e4();Zg.zoomOut=sBe.zoomOut});var Tot=H(u4=>{"use strict";Object.defineProperty(u4,"__esModule",{value:!0});var lBe=(de(),Ut(pe)),VF=Fe(),cBe=kc(),es;(function(e){e[e.VALUE=0]="VALUE",e[e.PIXEL=1]="PIXEL"})(es=u4.PropertyMode||(u4.PropertyMode={}));var uBe=function(e){lBe.__extends(t,e);function t(){var r=e.call(this)||this;return r._boxVisible=!1,r._boxBounds={topLeft:{x:0,y:0},bottomRight:{x:0,y:0}},r._xBoundsMode=es.PIXEL,r._yBoundsMode=es.PIXEL,r.addClass("selection-box-layer"),r._adjustBoundsCallback=function(){r.render()},r._overflowHidden=!0,r._xExtent=[void 0,void 0],r._yExtent=[void 0,void 0],r}return t.prototype._setup=function(){e.prototype._setup.call(this),this._box=this.content().append("g").classed("selection-box",!0).remove(),this._boxArea=this._box.append("rect").classed("selection-area",!0)},t.prototype._sizeFromOffer=function(r,n){return{width:r,height:n}},t.prototype.bounds=function(r){return r==null?this._getBounds():(this._setBounds(r),this._xBoundsMode=es.PIXEL,this._yBoundsMode=es.PIXEL,this.render(),this)},t.prototype._setBounds=function(r){var n={x:Math.min(r.topLeft.x,r.bottomRight.x),y:Math.min(r.topLeft.y,r.bottomRight.y)},i={x:Math.max(r.topLeft.x,r.bottomRight.x),y:Math.max(r.topLeft.y,r.bottomRight.y)};this._boxBounds={topLeft:n,bottomRight:i}},t.prototype._getBounds=function(){return{topLeft:{x:this._xBoundsMode===es.PIXEL?this._boxBounds.topLeft.x:this._xScale==null?0:Math.min(this.xScale().scale(this.xExtent()[0]),this.xScale().scale(this.xExtent()[1])),y:this._yBoundsMode===es.PIXEL?this._boxBounds.topLeft.y:this._yScale==null?0:Math.min(this.yScale().scale(this.yExtent()[0]),this.yScale().scale(this.yExtent()[1]))},bottomRight:{x:this._xBoundsMode===es.PIXEL?this._boxBounds.bottomRight.x:this._xScale==null?0:Math.max(this.xScale().scale(this.xExtent()[0]),this.xScale().scale(this.xExtent()[1])),y:this._yBoundsMode===es.PIXEL?this._boxBounds.bottomRight.y:this._yScale==null?0:Math.max(this.yScale().scale(this.yExtent()[0]),this.yScale().scale(this.yExtent()[1]))}}},t.prototype.renderImmediately=function(){if(e.prototype.renderImmediately.call(this),this._boxVisible){var r=this.bounds(),n=r.topLeft.y,i=r.bottomRight.y,o=r.topLeft.x,a=r.bottomRight.x;if(!(VF.Math.isValidNumber(n)&&VF.Math.isValidNumber(i)&&VF.Math.isValidNumber(o)&&VF.Math.isValidNumber(a)))throw new Error("bounds have not been properly set");this._boxArea.attrs({x:o,y:n,width:a-o,height:i-n}),this.content().node().appendChild(this._box.node())}else this._box.remove();return this},t.prototype.boxVisible=function(r){return r==null?this._boxVisible:(this._boxVisible=r,this.render(),this)},t.prototype.fixedWidth=function(){return!0},t.prototype.fixedHeight=function(){return!0},t.prototype.xScale=function(r){return r==null?this._xScale:(this._xScale!=null&&this._xScale.offUpdate(this._adjustBoundsCallback),this._xScale=r,this._xBoundsMode=es.VALUE,this._xScale.onUpdate(this._adjustBoundsCallback),this.render(),this)},t.prototype.yScale=function(r){return r==null?this._yScale:(this._yScale!=null&&this._yScale.offUpdate(this._adjustBoundsCallback),this._yScale=r,this._yBoundsMode=es.VALUE,this._yScale.onUpdate(this._adjustBoundsCallback),this.render(),this)},t.prototype.xExtent=function(r){return r==null?this._getXExtent():(this._setXExtent(r),this._xBoundsMode=es.VALUE,this.render(),this)},t.prototype._getXExtent=function(){return this._xBoundsMode===es.VALUE?this._xExtent:this._xScale==null?[void 0,void 0]:[this._xScale.invert(this._boxBounds.topLeft.x),this._xScale.invert(this._boxBounds.bottomRight.x)]},t.prototype._setXExtent=function(r){this._xExtent=r},t.prototype.yExtent=function(r){return r==null?this._getYExtent():(this._setYExtent(r),this._yBoundsMode=es.VALUE,this.render(),this)},t.prototype._getYExtent=function(){return this._yBoundsMode===es.VALUE?this._yExtent:this._yScale==null?[void 0,void 0]:[this._yScale.invert(this._boxBounds.topLeft.y),this._yScale.invert(this._boxBounds.bottomRight.y)]},t.prototype._setYExtent=function(r){this._yExtent=r},t.prototype.destroy=function(){e.prototype.destroy.call(this),this._xScale!=null&&this.xScale().offUpdate(this._adjustBoundsCallback),this._yScale!=null&&this.yScale().offUpdate(this._adjustBoundsCallback)},t}(cBe.Component);u4.SelectionBoxLayer=uBe});var qF=H(Aot=>{"use strict";Object.defineProperty(Aot,"__esModule",{value:!0});var hBe=(de(),Ut(pe)),fBe=l4(),Cot=Fe(),pBe=Yg(),UF=Pot(),dBe=Tot(),mBe=function(e){hBe.__extends(t,e);function t(){var r=e.call(this)||this;return r._detectionRadius=3,r._resizable=!1,r._movable=!1,r._hasCorners=!0,r.addClass("drag-box-layer"),r._dragInteraction=new fBe.Drag,r._setUpCallbacks(),r._dragInteraction.attachTo(r),r._dragStartCallbacks=new Cot.CallbackSet,r._dragCallbacks=new Cot.CallbackSet,r._dragEndCallbacks=new Cot.CallbackSet,r}return t.prototype._setUpCallbacks=function(){var r=this,n,i,o,a,s={newBox:0,resize:1,move:2},l=s.newBox,c=function(f){n=r._getResizingEdges(f);var p=r.bounds(),d=p.topLeft.x<=f.x&&f.x<=p.bottomRight.x&&p.topLeft.y<=f.y&&f.y<=p.bottomRight.y;r.boxVisible()&&(n.top||n.bottom||n.left||n.right)?l=s.resize:r.boxVisible()&&r.movable()&&d?l=s.move:(l=s.newBox,r._setBounds({topLeft:f,bottomRight:f}),r._xBoundsMode===UF.PropertyMode.VALUE&&r.xScale()!=null&&r._setXExtent([r.xScale().invert(f.x),r.xScale().invert(f.x)]),r._yBoundsMode===UF.PropertyMode.VALUE&&r.yScale()!=null&&r._setYExtent([r.yScale().invert(f.y),r.yScale().invert(f.y)]),r.render()),r.boxVisible(!0),p=r.bounds(),i={x:p.topLeft.x,y:p.topLeft.y},o={x:p.bottomRight.x,y:p.bottomRight.y},a=f,r._dragStartCallbacks.callCallbacks(p)},u=function(f,p){switch(l){case s.newBox:o.x=p.x,o.y=p.y;break;case s.resize:n.bottom?o.y=p.y:n.top&&(i.y=p.y),n.right?o.x=p.x:n.left&&(i.x=p.x);break;case s.move:var d=p.x-a.x,g=p.y-a.y;i.x+=d,i.y+=g,o.x+=d,o.y+=g,a=p;break}r._setBounds({topLeft:i,bottomRight:o}),r._xBoundsMode===UF.PropertyMode.VALUE&&r.xScale()!=null&&r._setXExtent([r.xScale().invert(i.x),r.xScale().invert(o.x)]),r._yBoundsMode===UF.PropertyMode.VALUE&&r.yScale()!=null&&r._setYExtent([r.yScale().invert(i.y),r.yScale().invert(o.y)]),r.render(),r._dragCallbacks.callCallbacks(r.bounds())},h=function(f,p){l===s.newBox&&f.x===p.x&&f.y===p.y&&r.boxVisible(!1),r._dragEndCallbacks.callCallbacks(r.bounds())};this._dragInteraction.onDragStart(c),this._dragInteraction.onDrag(u),this._dragInteraction.onDragEnd(h),this._disconnectInteraction=function(){r._dragInteraction.offDragStart(c),r._dragInteraction.offDrag(u),r._dragInteraction.offDragEnd(h),r._dragInteraction.detach()}},t.prototype._setup=function(){var r=this;e.prototype._setup.call(this);var n=function(){return r._box.append("line").styles({opacity:0,stroke:"pink","pointer-events":"visibleStroke"})};if(this._detectionEdgeT=n().classed("drag-edge-tb",!0),this._detectionEdgeB=n().classed("drag-edge-tb",!0),this._detectionEdgeL=n().classed("drag-edge-lr",!0),this._detectionEdgeR=n().classed("drag-edge-lr",!0),this._hasCorners){var i=function(){return r._box.append("circle").styles({opacity:0,fill:"pink","pointer-events":"visibleFill"})};this._detectionCornerTL=i().classed("drag-corner-tl",!0),this._detectionCornerTR=i().classed("drag-corner-tr",!0),this._detectionCornerBL=i().classed("drag-corner-bl",!0),this._detectionCornerBR=i().classed("drag-corner-br",!0)}},t.prototype._getResizingEdges=function(r){var n={top:!1,bottom:!1,left:!1,right:!1};if(!this.resizable())return n;var i=this.bounds(),o=i.topLeft.y,a=i.bottomRight.y,s=i.topLeft.x,l=i.bottomRight.x,c=this._detectionRadius;return s-c<=r.x&&r.x<=l+c&&(n.top=o-c<=r.y&&r.y<=o+c,n.bottom=a-c<=r.y&&r.y<=a+c),o-c<=r.y&&r.y<=a+c&&(n.left=s-c<=r.x&&r.x<=s+c,n.right=l-c<=r.x&&r.x<=l+c),n},t.prototype.renderImmediately=function(){if(e.prototype.renderImmediately.call(this),this.boxVisible()){var r=this.bounds(),n=r.topLeft.y,i=r.bottomRight.y,o=r.topLeft.x,a=r.bottomRight.x;this._detectionEdgeT.attrs({x1:o,y1:n,x2:a,y2:n,"stroke-width":this._detectionRadius*2}),this._detectionEdgeB.attrs({x1:o,y1:i,x2:a,y2:i,"stroke-width":this._detectionRadius*2}),this._detectionEdgeL.attrs({x1:o,y1:n,x2:o,y2:i,"stroke-width":this._detectionRadius*2}),this._detectionEdgeR.attrs({x1:a,y1:n,x2:a,y2:i,"stroke-width":this._detectionRadius*2}),this._hasCorners&&(this._detectionCornerTL.attrs({cx:o,cy:n,r:this._detectionRadius}),this._detectionCornerTR.attrs({cx:a,cy:n,r:this._detectionRadius}),this._detectionCornerBL.attrs({cx:o,cy:i,r:this._detectionRadius}),this._detectionCornerBR.attrs({cx:a,cy:i,r:this._detectionRadius}))}return this},t.prototype.detectionRadius=function(r){if(r==null)return this._detectionRadius;if(r<0)throw new Error("detection radius cannot be negative.");return this._detectionRadius=r,this.render(),this},t.prototype.resizable=function(r){return r==null?this._resizable:(this._resizable=r,this._setResizableClasses(r),this)},t.prototype._setResizableClasses=function(r){r&&this.enabled()?(this.addClass("x-resizable"),this.addClass("y-resizable")):(this.removeClass("x-resizable"),this.removeClass("y-resizable"))},t.prototype.movable=function(r){return r==null?this._movable:(this._movable=r,this._setMovableClass(),this)},t.prototype._setMovableClass=function(){this.movable()&&this.enabled()?this.addClass("movable"):this.removeClass("movable")},t.prototype.onDragStart=function(r){return this._dragStartCallbacks.add(r),this},t.prototype.offDragStart=function(r){return this._dragStartCallbacks.delete(r),this},t.prototype.onDrag=function(r){return this._dragCallbacks.add(r),this},t.prototype.offDrag=function(r){return this._dragCallbacks.delete(r),this},t.prototype.onDragEnd=function(r){return this._dragEndCallbacks.add(r),this},t.prototype.offDragEnd=function(r){return this._dragEndCallbacks.delete(r),this},t.prototype.dragInteraction=function(){return this._dragInteraction},t.prototype.enabled=function(r){return r==null?this._dragInteraction.enabled():(this._dragInteraction.enabled(r),this._setResizableClasses(this.resizable()),this._setMovableClass(),this)},t.prototype.destroy=function(){var r=this;e.prototype.destroy.call(this),this._dragStartCallbacks.forEach(function(n){return r._dragCallbacks.delete(n)}),this._dragCallbacks.forEach(function(n){return r._dragCallbacks.delete(n)}),this._dragEndCallbacks.forEach(function(n){return r._dragEndCallbacks.delete(n)}),this._disconnectInteraction()},t.prototype.detach=function(){return this._resetState(),this._dragInteraction.detach(),e.prototype.detach.call(this),this},t.prototype.anchor=function(r){return r=pBe.coerceExternalD3(r),this._dragInteraction.attachTo(this),e.prototype.anchor.call(this,r),this},t.prototype._resetState=function(){this.bounds({topLeft:{x:0,y:0},bottomRight:{x:0,y:0}})},t}(dBe.SelectionBoxLayer);Aot.DragBoxLayer=mBe});var Lot=H(Iot=>{"use strict";Object.defineProperty(Iot,"__esModule",{value:!0});var gBe=(de(),Ut(pe)),_Be=Fe(),yBe=kc(),Ov;(function(e){e[e.VALUE=0]="VALUE",e[e.PIXEL=1]="PIXEL"})(Ov||(Ov={}));var vBe=function(e){gBe.__extends(t,e);function t(r){var n=e.call(this)||this;if(n._mode=Ov.VALUE,r!==t.ORIENTATION_VERTICAL&&r!==t.ORIENTATION_HORIZONTAL)throw new Error(r+" is not a valid orientation for GuideLineLayer");return n._orientation=r,n._overflowHidden=!0,n.addClass("guide-line-layer"),n._isVertical()?n.addClass("vertical"):n.addClass("horizontal"),n._scaleUpdateCallback=function(){n._syncPixelPositionAndValue(),n.render()},n}return t.prototype._setup=function(){e.prototype._setup.call(this),this._guideLine=this.content().append("line").classed("guide-line",!0)},t.prototype._sizeFromOffer=function(r,n){return{width:r,height:n}},t.prototype._isVertical=function(){return this._orientation===t.ORIENTATION_VERTICAL},t.prototype.fixedWidth=function(){return!0},t.prototype.fixedHeight=function(){return!0},t.prototype.computeLayout=function(r,n,i){return e.prototype.computeLayout.call(this,r,n,i),this.scale()!=null&&(this._isVertical()?this.scale().range([0,this.width()]):this.scale().range([this.height(),0])),this},t.prototype.renderImmediately=function(){return e.prototype.renderImmediately.call(this),this._syncPixelPositionAndValue(),this._guideLine.attrs({x1:this._isVertical()?this.pixelPosition():0,y1:this._isVertical()?0:this.pixelPosition(),x2:this._isVertical()?this.pixelPosition():this.width(),y2:this._isVertical()?this.height():this.pixelPosition()}),this},t.prototype._syncPixelPositionAndValue=function(){this.scale()!=null&&(this._mode===Ov.VALUE&&this.value()!=null?this._pixelPosition=this.scale().scale(this.value()):this._mode===Ov.PIXEL&&this.pixelPosition()!=null&&(this._value=this.scale().invert(this.pixelPosition())))},t.prototype._setPixelPositionWithoutChangingMode=function(r){this._pixelPosition=r,this.scale()!=null&&(this._value=this.scale().invert(this.pixelPosition())),this.render()},t.prototype.scale=function(r){if(r==null)return this._scale;var n=this._scale;return n!=null&&n.offUpdate(this._scaleUpdateCallback),this._scale=r,this._scale.onUpdate(this._scaleUpdateCallback),this._syncPixelPositionAndValue(),this.redraw(),this},t.prototype.value=function(r){return r==null?this._value:(this._value=r,this._mode=Ov.VALUE,this._syncPixelPositionAndValue(),this.render(),this)},t.prototype.pixelPosition=function(r){if(r==null)return this._pixelPosition;if(!_Be.Math.isValidNumber(r))throw new Error("pixelPosition must be a finite number");return this._pixelPosition=r,this._mode=Ov.PIXEL,this._syncPixelPositionAndValue(),this.render(),this},t.prototype.destroy=function(){e.prototype.destroy.call(this),this.scale()!=null&&this.scale().offUpdate(this._scaleUpdateCallback)},t.ORIENTATION_VERTICAL="vertical",t.ORIENTATION_HORIZONTAL="horizontal",t}(yBe.Component);Iot.GuideLineLayer=vBe});var I$t=H(Rot=>{"use strict";Object.defineProperty(Rot,"__esModule",{value:!0});var xBe=(de(),Ut(pe)),bBe=Lot(),wBe=l4(),kot=Fe(),SBe=function(e){xBe.__extends(t,e);function t(r){var n=e.call(this,r)||this;n._detectionRadius=3,n._enabled=!0,n.addClass("drag-line-layer"),n.addClass("enabled"),n._dragInteraction=new wBe.Drag,n._dragInteraction.attachTo(n);var i=function(c){return n._isVertical()&&n.pixelPosition()-n.detectionRadius()<=c.x&&c.x<=n.pixelPosition()+n.detectionRadius()||!n._isVertical()&&n.pixelPosition()-n.detectionRadius()<=c.y&&c.y<=n.pixelPosition()+n.detectionRadius()},o=!1,a=function(c){i(c)&&(o=!0,n._dragStartCallbacks.callCallbacks(n))};n._dragInteraction.onDragStart(a);var s=function(c,u){o&&(n._setPixelPositionWithoutChangingMode(n._isVertical()?u.x:u.y),n._dragCallbacks.callCallbacks(n))};n._dragInteraction.onDrag(s);var l=function(c,u){o&&(o=!1,n._dragEndCallbacks.callCallbacks(n))};return n._dragInteraction.onDragEnd(l),n._disconnectInteraction=function(){n._dragInteraction.offDragStart(a),n._dragInteraction.offDrag(s),n._dragInteraction.offDragEnd(l),n._dragInteraction.detach()},n._dragStartCallbacks=new kot.CallbackSet,n._dragCallbacks=new kot.CallbackSet,n._dragEndCallbacks=new kot.CallbackSet,n}return t.prototype._setup=function(){e.prototype._setup.call(this),this._detectionEdge=this.content().append("line").styles({opacity:0,stroke:"pink","pointer-events":"visibleStroke"}).classed("drag-edge",!0)},t.prototype.renderImmediately=function(){return e.prototype.renderImmediately.call(this),this._detectionEdge.attrs({x1:this._isVertical()?this.pixelPosition():0,y1:this._isVertical()?0:this.pixelPosition(),x2:this._isVertical()?this.pixelPosition():this.width(),y2:this._isVertical()?this.height():this.pixelPosition(),"stroke-width":this._detectionRadius*2}),this},t.prototype.detectionRadius=function(r){if(r==null)return this._detectionRadius;if(r<0)throw new Error("detection radius cannot be negative.");return this._detectionRadius=r,this.render(),this},t.prototype.enabled=function(r){return r==null?this._enabled:(this._enabled=r,r?this.addClass("enabled"):this.removeClass("enabled"),this._dragInteraction.enabled(r),this)},t.prototype.onDragStart=function(r){return this._dragStartCallbacks.add(r),this},t.prototype.offDragStart=function(r){return this._dragStartCallbacks.delete(r),this},t.prototype.onDrag=function(r){return this._dragCallbacks.add(r),this},t.prototype.offDrag=function(r){return this._dragCallbacks.delete(r),this},t.prototype.onDragEnd=function(r){return this._dragEndCallbacks.add(r),this},t.prototype.offDragEnd=function(r){return this._dragEndCallbacks.delete(r),this},t.prototype.destroy=function(){var r=this;e.prototype.destroy.call(this),this._dragStartCallbacks.forEach(function(n){return r._dragStartCallbacks.delete(n)}),this._dragCallbacks.forEach(function(n){return r._dragCallbacks.delete(n)}),this._dragEndCallbacks.forEach(function(n){return r._dragEndCallbacks.delete(n)}),this._disconnectInteraction()},t}(bBe.GuideLineLayer);Rot.DragLineLayer=SBe});var L$t=H(Not=>{"use strict";Object.defineProperty(Not,"__esModule",{value:!0});var MBe=(de(),Ut(pe)),EBe=kc();function GF(e,t,r){var n={};if(r!==void 0)for(var i=0;i<r.length;i++){var o=r[i-1],a=r[i];n[a]=o}return function(s){var l=e.scale(s);if(!t)return l;var c,u=n[s]===void 0?void 0:e.scale(n[s]);return u!==void 0&&(c=u+(l-u)/2),c}}var TBe=function(e){MBe.__extends(t,e);function t(r,n){var i=e.call(this)||this;return i.addClass("gridlines"),i._xScale=r,i._yScale=n,i._renderCallback=function(o){return i.render()},i._xScale&&i._xScale.onUpdate(i._renderCallback),i._yScale&&i._yScale.onUpdate(i._renderCallback),i}return t.prototype.betweenX=function(r){return r===void 0?this._betweenX:(r!==this._betweenX&&(this._betweenX=r,this.render()),this)},t.prototype.betweenY=function(r){return r===void 0?this._betweenY:(r!==this._betweenY&&(this._betweenY=r,this.render()),this)},t.prototype.destroy=function(){return e.prototype.destroy.call(this),this._xScale&&this._xScale.offUpdate(this._renderCallback),this._yScale&&this._yScale.offUpdate(this._renderCallback),this},t.prototype._setup=function(){e.prototype._setup.call(this),this._xLinesContainer=this.content().append("g").classed("x-gridlines",!0),this._yLinesContainer=this.content().append("g").classed("y-gridlines",!0)},t.prototype.renderImmediately=function(){return e.prototype.renderImmediately.call(this),this._redrawXLines(),this._redrawYLines(),this},t.prototype.computeLayout=function(r,n,i){return e.prototype.computeLayout.call(this,r,n,i),this._xScale!=null&&this._xScale.range([0,this.width()]),this._yScale!=null&&this._yScale.range([this.height(),0]),this},t.prototype._redrawXLines=function(){if(this._xScale){var r=this.betweenX(),n=this._xScale.ticks().slice(r?1:0),i=this._xLinesContainer.selectAll("line").data(n),o=i.enter().append("line").merge(i);o.attr("x1",GF(this._xScale,r,this._xScale.ticks())).attr("y1",0).attr("x2",GF(this._xScale,r,this._xScale.ticks())).attr("y2",this.height()).classed("betweenline",r).classed("zeroline",function(a){return a===0}),i.exit().remove()}},t.prototype._redrawYLines=function(){if(this._yScale){var r=this.betweenY(),n=this._yScale.ticks().slice(r?1:0),i=this._yLinesContainer.selectAll("line").data(n),o=i.enter().append("line").merge(i);o.attr("x1",0).attr("y1",GF(this._yScale,r,this._yScale.ticks())).attr("x2",this.width()).attr("y2",GF(this._yScale,r,this._yScale.ticks())).classed("betweenline",r).classed("zeroline",function(a){return a===0}),i.exit().remove()}},t}(EBe.Component);Not.Gridlines=TBe});var WF=H(Dot=>{"use strict";Object.defineProperty(Dot,"__esModule",{value:!0});var CBe=(de(),Ut(pe)),ABe=Yg(),PBe=kc(),IBe=function(e){CBe.__extends(t,e);function t(){var r=e.call(this)||this;return r._detachCallback=function(n){return r.remove(n)},r}return t.prototype.anchor=function(r){var n=this;return r=ABe.coerceExternalD3(r),e.prototype.anchor.call(this,r),this._forEach(function(i){return i.anchor(n.element())}),this},t.prototype.render=function(){return this._forEach(function(r){return r.render()}),this},t.prototype.has=function(r){throw new Error("has() is not implemented on ComponentContainer")},t.prototype._adoptAndAnchor=function(r){r.parent(this),r.onDetach(this._detachCallback),this._isAnchored&&r.anchor(this.element())},t.prototype.remove=function(r){return this.has(r)&&(r.offDetach(this._detachCallback),this._remove(r),r.detach(),this.redraw()),this},t.prototype._remove=function(r){return!1},t.prototype._forEach=function(r){throw new Error("_forEach() is not implemented on ComponentContainer")},t.prototype.destroy=function(){e.prototype.destroy.call(this),this._forEach(function(r){return r.destroy()})},t.prototype.invalidateCache=function(){this._forEach(function(r){return r.invalidateCache()})},t}(PBe.Component);Dot.ComponentContainer=IBe});var zot=H(Oot=>{"use strict";Object.defineProperty(Oot,"__esModule",{value:!0});var LBe=(de(),Ut(pe)),k$t=Fe(),kBe=WF(),RBe=function(e){LBe.__extends(t,e);function t(r){r===void 0&&(r=[]);var n=e.call(this)||this;return n._components=[],n.addClass("component-group"),r.forEach(function(i){return n.append(i)}),n}return t.prototype._forEach=function(r){this.components().forEach(r)},t.prototype.has=function(r){return this._components.indexOf(r)>=0},t.prototype.requestedSpace=function(r,n){var i=this._components.map(function(o){return o.requestedSpace(r,n)});return{minWidth:k$t.Math.max(i,function(o){return o.minWidth},0),minHeight:k$t.Math.max(i,function(o){return o.minHeight},0)}},t.prototype.computeLayout=function(r,n,i){var o=this;return e.prototype.computeLayout.call(this,r,n,i),this._forEach(function(a){a.computeLayout({x:0,y:0},o.width(),o.height())}),this},t.prototype._sizeFromOffer=function(r,n){return{width:r,height:n}},t.prototype.fixedWidth=function(){return this._components.every(function(r){return r.fixedWidth()})},t.prototype.fixedHeight=function(){return this._components.every(function(r){return r.fixedHeight()})},t.prototype.components=function(){return this._components.slice()},t.prototype.append=function(r){return r!=null&&!this.has(r)&&(r.detach(),this._components.push(r),this._adoptAndAnchor(r),this.redraw()),this},t.prototype._remove=function(r){var n=this._components.indexOf(r);return n>=0?(this._components.splice(n,1),!0):!1},t}(kBe.ComponentContainer);Oot.Group=RBe});var R$t=H(Fot=>{"use strict";Object.defineProperty(Fot,"__esModule",{value:!0});var NBe=(de(),Ut(pe)),YF=_l(),DBe=$A(),OBe=Bu(),zBe=Fe(),FBe=kc(),BBe=function(e){NBe.__extends(t,e);function t(r){var n=e.call(this)||this;if(n._textPadding=5,r==null)throw new Error("InterpolatedColorLegend requires a interpolatedColorScale");return n._scale=r,n._redrawCallback=function(i){return n.redraw()},n._scale.onUpdate(n._redrawCallback),n._formatter=OBe.general(),n._orientation="horizontal",n._expands=!1,n.addClass("legend"),n.addClass("interpolated-color-legend"),n}return t.prototype.destroy=function(){e.prototype.destroy.call(this),this._scale.offUpdate(this._redrawCallback)},t.prototype.formatter=function(r){return r===void 0?this._formatter:(this._formatter=r,this.redraw(),this)},t.prototype.expands=function(r){return r==null?this._expands:(this._expands=r,this.redraw(),this)},t._ensureOrientation=function(r){if(r=r.toLowerCase(),r==="horizontal"||r==="left"||r==="right")return r;throw new Error('"'+r+'" is not a valid orientation for InterpolatedColorLegend')},t.prototype.orientation=function(r){return r==null?this._orientation:(this._orientation=t._ensureOrientation(r),this.redraw(),this)},t.prototype.fixedWidth=function(){return!this.expands()||this._isVertical()},t.prototype.fixedHeight=function(){return!this.expands()||!this._isVertical()},t.prototype._generateTicks=function(r){r===void 0&&(r=t._DEFAULT_NUM_SWATCHES);var n=this._scale.domain();if(r===1)return[n[0]];for(var i=(n[1]-n[0])/(r-1),o=[],a=0;a<r;a++)o.push(n[0]+i*a);return o},t.prototype._setup=function(){e.prototype._setup.call(this),this._swatchContainer=this.content().append("g").classed("swatch-container",!0),this._swatchBoundingBox=this.content().append("rect").classed("swatch-bounding-box",!0),this._lowerLabel=this.content().append("g").classed(t.LEGEND_LABEL_CLASS,!0),this._upperLabel=this.content().append("g").classed(t.LEGEND_LABEL_CLASS,!0);var r=new YF.SvgContext(this.content().node());this._measurer=new YF.Measurer(r),this._wrapper=new YF.Wrapper,this._writer=new YF.Writer(this._measurer,r,this._wrapper)},t.prototype.requestedSpace=function(r,n){var i=this,o=this._measurer.measure().height,a=o,s=this._scale.domain(),l=s.map(function(p){return i._measurer.measure(i._formatter(p)).width}),c,u,h=t._DEFAULT_NUM_SWATCHES;if(this._isVertical()){var f=zBe.Math.max(l,0);u=a+o+this._textPadding+f+this._textPadding,c=h*o}else c=a+o+a,u=this._textPadding+l[0]+h*o+l[1]+this._textPadding;return{minWidth:u,minHeight:c}},t.prototype._isVertical=function(){return this._orientation!=="horizontal"},t.prototype.renderImmediately=function(){var r=this;e.prototype.renderImmediately.call(this);var n=this._scale.domain(),i=this._formatter(n[0]),o=this._measurer.measure(i).width,a=this._formatter(n[1]),s=this._measurer.measure(a).width,l=this._measurer.measure().height,c=this._textPadding,u={x:0,y:0},h={x:0,y:0},f={xAlign:"center",yAlign:"center",textRotation:0},p={xAlign:"center",yAlign:"center",textRotation:0},d,g,_,y,x={x:0,y:0,width:0,height:0},b,S;if(this._isVertical()){S=Math.floor(this.height());var C=Math.max(o,s);b=(this.width()-C-2*this._textPadding)/2,d=Math.max(this.width()-b-2*c-C,0),g=1,y=function(L,R){return r.height()-(R+1)},p.yAlign="top",u.y=0,f.yAlign="bottom",h.y=0,this._orientation==="left"?(_=function(L,R){return c+C+c},p.xAlign="right",u.x=-(b+d+c),f.xAlign="right",h.x=-(b+d+c)):(_=function(L,R){return b},p.xAlign="left",u.x=b+d+c,f.xAlign="left",h.x=b+d+c),x.width=d,x.height=S*g}else b=Math.max(c,(this.height()-l)/2),S=Math.max(Math.floor(this.width()-c*4-o-s),0),d=1,g=Math.max(this.height()-2*b,0),_=function(L,R){return Math.floor(o+2*c)+R},y=function(L,R){return b},p.xAlign="right",u.x=-c,f.xAlign="left",h.x=c,x.y=b,x.width=S*d,x.height=g;x.x=_(null,0),this._upperLabel.text(""),this._writer.write(a,this.width(),this.height(),p,this._upperLabel.node());var P="translate("+u.x+", "+u.y+")";this._upperLabel.attr("transform",P),this._lowerLabel.text(""),this._writer.write(i,this.width(),this.height(),f,this._lowerLabel.node());var k="translate("+h.x+", "+h.y+")";this._lowerLabel.attr("transform",k),this._swatchBoundingBox.attrs(x);var O=this._generateTicks(S),D=this._swatchContainer.selectAll("rect.swatch").data(O),B=D.enter().append("rect").classed("swatch",!0),I=D.merge(B);return D.exit().remove(),I.attrs({fill:function(L,R){return r._scale.scale(L)},width:d,height:g,x:_,y,"shape-rendering":"crispEdges"}),DBe.ADD_TITLE_ELEMENTS&&B.append("title").text(function(L){return r._formatter(L)}),this},t._DEFAULT_NUM_SWATCHES=11,t.LEGEND_LABEL_CLASS="legend-label",t}(FBe.Component);Fot.InterpolatedColorLegend=BBe});var Vot=H(h4=>{"use strict";Object.defineProperty(h4,"__esModule",{value:!0});var Bot=(de(),Ut(pe)),jF=_l(),HBe=kc(),Hot=function(e){Bot.__extends(t,e);function t(r,n){r===void 0&&(r=""),n===void 0&&(n=0);var i=e.call(this)||this;return i.addClass("label"),i.text(r),i.angle(n),i.xAlignment("center").yAlignment("center"),i._padding=0,i}return t.prototype.requestedSpace=function(r,n){var i=this._measurer.measure(this._text),o=(this.angle()===0?i.width:i.height)+2*this.padding(),a=(this.angle()===0?i.height:i.width)+2*this.padding();return{minWidth:o,minHeight:a}},t.prototype._setup=function(){e.prototype._setup.call(this),this._textContainer=this.content().append("g");var r=new jF.SvgContext(this._textContainer.node());this._measurer=new jF.CacheMeasurer(r),this._wrapper=new jF.Wrapper,this._writer=new jF.Writer(this._measurer,r,this._wrapper),this.text(this._text)},t.prototype.text=function(r){if(r==null)return this._text;if(typeof r!="string")throw new Error("Label.text() only takes strings as input");return this._text=r,this.redraw(),this},t.prototype.angle=function(r){if(r==null)return this._angle;if(r%=360,r>180?r-=360:r<-180&&(r+=360),r===-90||r===0||r===90)this._angle=r;else throw new Error(r+" is not a valid angle for Label");return this.redraw(),this},t.prototype.padding=function(r){if(r==null)return this._padding;if(r=+r,r<0)throw new Error(r+" is not a valid padding value. Cannot be less than 0.");return this._padding=r,this.redraw(),this},t.prototype.fixedWidth=function(){return!0},t.prototype.fixedHeight=function(){return!0},t.prototype.renderImmediately=function(){e.prototype.renderImmediately.call(this),this._textContainer.selectAll("g").remove();var r=this._measurer.measure(this._text),n=Math.max(Math.min((this.height()-r.height)/2,this.padding()),0),i=Math.max(Math.min((this.width()-r.width)/2,this.padding()),0);this._textContainer.attr("transform","translate("+i+","+n+")");var o=this.width()-2*i,a=this.height()-2*n,s={xAlign:this.xAlignment(),yAlign:this.yAlignment(),textRotation:this.angle()};return this._writer.write(this._text,o,a,s),this},t.prototype.invalidateCache=function(){e.prototype.invalidateCache.call(this),this._measurer.reset()},t}(HBe.Component);h4.Label=Hot;var VBe=function(e){Bot.__extends(t,e);function t(r,n){var i=e.call(this,r,n)||this;return i.addClass(t.TITLE_LABEL_CLASS),i}return t.TITLE_LABEL_CLASS="title-label",t}(Hot);h4.TitleLabel=VBe;var UBe=function(e){Bot.__extends(t,e);function t(r,n){var i=e.call(this,r,n)||this;return i.addClass(t.AXIS_LABEL_CLASS),i}return t.AXIS_LABEL_CLASS="axis-label",t}(Hot);h4.AxisLabel=UBe});var XF=H(bd=>{"use strict";Object.defineProperty(bd,"__esModule",{value:!0});var Rs=(Er(),Ut(Mr));function qBe(){return function(e){return Rs.symbol().type(Rs.symbolCircle).size(Math.PI*Math.pow(e/2,2))}}bd.circle=qBe;function GBe(){return function(e){return Rs.symbol().type(Rs.symbolSquare).size(Math.pow(e,2))}}bd.square=GBe;function WBe(){return function(e){return Rs.symbol().type(Rs.symbolCross).size(5/9*Math.pow(e,2))}}bd.cross=WBe;function YBe(){return function(e){return Rs.symbol().type(Rs.symbolDiamond).size(Math.tan(Math.PI/6)*Math.pow(e,2)/2)}}bd.diamond=YBe;function jBe(){return function(e){return Rs.symbol().type(Rs.symbolTriangle).size(Math.sqrt(3)*Math.pow(e/2,2))}}bd.triangle=jBe;var XBe=.8908130915292852;function $Be(){return function(e){return Rs.symbol().type(Rs.symbolStar).size(XBe*Math.pow(e/2,2))}}bd.star=$Be;var KBe=(1/Math.sqrt(12)/2+1)*3;function ZBe(){return function(e){return Rs.symbol().type(Rs.symbolWye).size(KBe*Math.pow(e/2.4,2))}}bd.wye=ZBe});var N$t=H(qot=>{"use strict";Object.defineProperty(qot,"__esModule",{value:!0});var JBe=(de(),Ut(pe)),zv=(Er(),Ut(Mr)),$F=_l(),QBe=$A(),tHe=Bu(),eHe=XF(),Jg=Fe(),rHe=kc(),Uot=function(){function e(t,r,n){t===void 0&&(t=[]),r===void 0&&(r=0),n===void 0&&(n=1/0),this.columns=t,this.bottomPadding=r,this.maxWidth=n}return e.prototype.addColumn=function(t){var r=t.width,n=this.getWidthAvailable();t.width=Math.min(n,r),this.columns.push(t)},e.prototype.getBounds=function(t){for(var r=this.columns[t],n=0,i=0;i<t;i++)n+=this.columns[i].width;return{topLeft:{x:n,y:0},bottomRight:{x:n+r.width,y:r.height}}},e.prototype.getHeight=function(){return Jg.Math.max(this.columns.map(function(t){var r=t.height;return r}),0)+this.bottomPadding},e.prototype.getWidth=function(){return Math.min(this.columns.reduce(function(t,r){var n=r.width;return t+n},0),this.maxWidth)},e.prototype.getWidthAvailable=function(){var t=this.getWidth();return Math.max(this.maxWidth-t,0)},e}(),nHe=function(){function e(t,r,n,i){t===void 0&&(t=1/0),r===void 0&&(r=1/0),n===void 0&&(n=0),i===void 0&&(i=[]),this.maxWidth=t,this.maxHeight=r,this.padding=n,this.rows=i}return e.prototype.addRow=function(t){t.maxWidth=this.maxWidth-this.padding*2,this.rows.push(t)},e.prototype.getColumnBounds=function(t,r){var n=this.getRowBounds(t),i=this.rows[t].getBounds(r);return i.topLeft.x+=n.topLeft.x,i.bottomRight.x+=n.topLeft.x,i.topLeft.y+=n.topLeft.y,i.bottomRight.y+=n.topLeft.y,i},e.prototype.getRowBounds=function(t){for(var r=this.padding,n=this.padding,i=0;i<t;i++)n+=this.rows[i].getHeight();var o={topLeft:{x:r,y:n},bottomRight:{x:r+this.rows[t].getWidth(),y:n+this.rows[t].getHeight()}};return o},e.prototype.getHeight=function(){return Math.min(this.rows.reduce(function(t,r){return t+r.getHeight()},0)+this.padding*2,this.maxHeight)},e.prototype.getWidth=function(){return Math.min(Jg.Math.max(this.rows.map(function(t){return t.getWidth()}),0)+this.padding*2,this.maxWidth)},e}(),iHe=function(e){JBe.__extends(t,e);function t(r){var n=e.call(this)||this;if(n._padding=5,n._rowBottomPadding=3,n.addClass("legend"),n.maxEntriesPerRow(1),r==null)throw new Error("Legend requires a colorScale");return n._colorScale=r,n._redrawCallback=function(i){return n.redraw()},n._colorScale.onUpdate(n._redrawCallback),n._formatter=tHe.identity(),n.maxLinesPerEntry(1),n.xAlignment("right").yAlignment("top"),n.comparator(function(i,o){var a=n._colorScale.domain().slice().map(function(s){return n._formatter(s)});return a.indexOf(i)-a.indexOf(o)}),n._symbolFactoryAccessor=function(){return eHe.circle()},n._symbolOpacityAccessor=function(){return 1},n}return t.prototype._setup=function(){e.prototype._setup.call(this);var r=this.content().append("g").classed(t.LEGEND_ROW_CLASS,!0),n=r.append("g").classed(t.LEGEND_ENTRY_CLASS,!0);n.append("text");var i=new $F.SvgContext(r.node(),null,QBe.ADD_TITLE_ELEMENTS);this._measurer=new $F.CacheMeasurer(i),this._wrapper=new $F.Wrapper().maxLines(this.maxLinesPerEntry()),this._writer=new $F.Writer(this._measurer,i,this._wrapper)},t.prototype.formatter=function(r){return r==null?this._formatter:(this._formatter=r,this.redraw(),this)},t.prototype.maxEntriesPerRow=function(r){return r==null?this._maxEntriesPerRow:(this._maxEntriesPerRow=r,this.redraw(),this)},t.prototype.maxLinesPerEntry=function(r){return r==null?this._maxLinesPerEntry:(this._maxLinesPerEntry=r,this.redraw(),this)},t.prototype.maxWidth=function(r){return r==null?this._maxWidth:(this._maxWidth=r,this.redraw(),this)},t.prototype.comparator=function(r){return r==null?this._comparator:(this._comparator=r,this.redraw(),this)},t.prototype.colorScale=function(r){return r!=null?(this._colorScale.offUpdate(this._redrawCallback),this._colorScale=r,this._colorScale.onUpdate(this._redrawCallback),this.redraw(),this):this._colorScale},t.prototype.destroy=function(){e.prototype.destroy.call(this),this._colorScale.offUpdate(this._redrawCallback)},t.prototype._buildLegendTable=function(r,n){var i=this,o=this._measurer.measure().height,a=new nHe(r,n,this._padding),s=this._colorScale.domain().slice().sort(function(c,u){return i._comparator(i._formatter(c),i._formatter(u))}),l=new Uot;return a.addRow(l),l.bottomPadding=this._rowBottomPadding,s.forEach(function(c,u){l.columns.length/2===i.maxEntriesPerRow()&&(l=new Uot,l.bottomPadding=i._rowBottomPadding,a.addRow(l));var h=l.getWidthAvailable(),f=i._formatter(c),p=i._measurer.measure(f).width,d=h-o-p<0;d&&l.columns.length>1&&(l=new Uot,l.bottomPadding=i._rowBottomPadding,a.addRow(l));var g={width:o,height:o,data:{name:c,type:"symbol"}};l.addColumn(g),h=l.getWidthAvailable();var _=Math.min(h,p);i._wrapper.maxLines(i.maxLinesPerEntry());var y=i._wrapper.wrap(f,i._measurer,_).noLines,x=y*o,b={width:_,height:x,data:{name:c,type:"text"}};l.addColumn(b)}),a},t.prototype.requestedSpace=function(r,n){var i=this._buildLegendTable(Jg.Math.min([this.maxWidth(),r],r),n);return{minHeight:i.getHeight(),minWidth:i.getWidth()}},t.prototype.entitiesAt=function(r){var n=this;if(!this._isSetup)return[];var i=this._buildLegendTable(this.width(),this.height());return i.rows.reduce(function(o,a,s){if(o.length!==0)return o;var l=i.getRowBounds(s),c=Jg.Math.within(r,l);return c?a.columns.reduce(function(u,h,f){var p=i.getColumnBounds(s,f),d=Jg.Math.within(r,p);if(d){var g=n.content().selectAll("."+t.LEGEND_ROW_CLASS).nodes()[s],_=zv.select(g).selectAll("."+t.LEGEND_ENTRY_CLASS).nodes()[Math.floor(f/2)],y=zv.select(_).select("."+t.LEGEND_SYMBOL_CLASS),x=Jg.DOM.getTranslateValues(zv.select(g)),b=Jg.DOM.getTranslateValues(y);return[{bounds:Jg.DOM.elementBBox(zv.select(g)),datum:h.data.name,position:{x:x[0]+b[0],y:x[1]+b[1]},selection:zv.select(_),component:n}]}return u},o):o},[])},t.prototype.renderImmediately=function(){e.prototype.renderImmediately.call(this);var r=this._buildLegendTable(this.width(),this.height());this.content().selectAll("*").remove();var n=this.content().selectAll("g."+t.LEGEND_ROW_CLASS).data(r.rows),i=n.enter().append("g").classed(t.LEGEND_ROW_CLASS,!0).merge(n);n.exit().remove(),i.attr("transform",function(a,s){var l=r.getRowBounds(s);return"translate("+l.topLeft.x+", "+l.topLeft.y+")"});var o=this;return i.each(function(a,s){for(var l=[],c=0;c<a.columns.length;c+=2)l.push([a.columns[c],a.columns[c+1]]);var u=zv.select(this).selectAll("g."+t.LEGEND_ENTRY_CLASS).data(l),h=u.enter().append("g").classed(t.LEGEND_ENTRY_CLASS,!0).merge(u);h.append("path").attr("d",function(f,p){var d=f[0];return o.symbol()(d.data.name,s)(d.height*.6)(null)}).attr("transform",function(f,p){var d=f[0],g=r.rows[s].columns.indexOf(d),_=r.getColumnBounds(s,g);return"translate("+(_.topLeft.x+d.width/2)+", "+d.height/2+")"}).attr("fill",function(f){return o._colorScale.scale(f[0].data.name)}).attr("opacity",function(f,p){return o.symbolOpacity()(f[0].data.name,s)}).classed(t.LEGEND_SYMBOL_CLASS,!0),h.append("g").classed("text-container",!0).attr("transform",function(f,p){var d=f[1],g=r.rows[s].columns.indexOf(d),_=r.getColumnBounds(s,g);return"translate("+_.topLeft.x+", 0)"}).each(function(f,p,d){var g=zv.select(this),_=f[1],y={xAlign:"left",yAlign:"top",textRotation:0};o._writer.write(o._formatter(_.data.name),_.width,o.height(),y,g.node())}),u.exit().remove()}),this},t.prototype.symbol=function(r){return r==null?this._symbolFactoryAccessor:(this._symbolFactoryAccessor=r,this.render(),this)},t.prototype.symbolOpacity=function(r){return r==null?this._symbolOpacityAccessor:(typeof r=="number"?this._symbolOpacityAccessor=function(){return r}:this._symbolOpacityAccessor=r,this.render(),this)},t.prototype.fixedWidth=function(){return!0},t.prototype.fixedHeight=function(){return!0},t.prototype.invalidateCache=function(){e.prototype.invalidateCache.call(this),this._measurer.reset()},t.LEGEND_ROW_CLASS="legend-row",t.LEGEND_ENTRY_CLASS="legend-entry",t.LEGEND_SYMBOL_CLASS="legend-symbol",t}(rHe.Component);qot.Legend=iHe});var Got=H(KF=>{"use strict";Object.defineProperty(KF,"__esModule",{value:!0});var oHe;(function(e){e.MAIN="main",e.RESET="reset"})(oHe=KF.Animator||(KF.Animator={}))});var O$t=H((eGn,D$t)=>{"use strict";D$t.exports=function(t){return t!=null&&typeof t=="object"&&Array.isArray(t)===!1}});var B$t=H((rGn,F$t)=>{"use strict";var aHe=O$t();function z$t(e){return aHe(e)===!0&&Object.prototype.toString.call(e)==="[object Object]"}F$t.exports=function(t){var r,n;return!(z$t(t)===!1||(r=t.constructor,typeof r!="function")||(n=r.prototype,z$t(n)===!1)||n.hasOwnProperty("isPrototypeOf")===!1)}});var Yot=H(Wot=>{"use strict";Object.defineProperty(Wot,"__esModule",{value:!0});var sHe=Fe(),H$t=0,lHe=function(){function e(t,r){t===void 0&&(t=[]),r===void 0&&(r={}),this._updateId=H$t++,this._data=t,this._metadata=r,this._callbacks=new sHe.CallbackSet}return e.prototype.onUpdate=function(t){return this._callbacks.add(t),this},e.prototype.offUpdate=function(t){return this._callbacks.delete(t),this},e.prototype.data=function(t){return t==null?this._data:(this._data=t,this._dispatchUpdate(),this)},e.prototype.metadata=function(t){return t==null?this._metadata:(this._metadata=t,this._dispatchUpdate(),this)},e.prototype.updateId=function(){return this._updateId},e.prototype._dispatchUpdate=function(){this._updateId=H$t++,this._callbacks.callCallbacks(this)},e}();Wot.Dataset=lHe});var $ot=H(Rc=>{"use strict";Object.defineProperty(Rc,"__esModule",{value:!0});var jot=(de(),Ut(pe)),cHe=B$t(),uHe=Yot(),hHe=Lv();function Xot(e){return e instanceof p4?e:e instanceof Date?f4(e.valueOf()):e instanceof hHe.Scale?V$t(e):e instanceof uHe.Dataset?U$t(e):cHe(e)?ZF(e):Array.isArray(e)?q$t(e):f4(e)}Rc.sign=Xot;function V$t(e){var t={domain:e.domain(),range:e.range(),updateId:e.updateId(),ref:f4(e)};return ZF(t)}Rc.signScale=V$t;function U$t(e){var t={ref:f4(e),updateId:e.updateId()};return ZF(t)}Rc.signDataset=U$t;function f4(e){return new W$t(e)}Rc.signRef=f4;function q$t(e){return new G$t(e.map(function(t){return Xot(t)}))}Rc.signArray=q$t;function ZF(e){var t={};for(var r in e)e.hasOwnProperty(r)&&(t[r]=Xot(e[r]));return new Y$t(t)}Rc.signObj=ZF;var p4=function(){function e(){}return e.prototype.isDifferent=function(t){return t instanceof this.constructor?this.isSignatureDifferent(t):!0},e}();Rc.Signature=p4;var G$t=function(e){jot.__extends(t,e);function t(r){var n=e.call(this)||this;return n.array=r,n}return t.prototype.isSignatureDifferent=function(r){if(r.array.length!==this.array.length)return!0;for(var n=0;n<this.array.length;n++)if(this.array[n].isDifferent(r.array[n]))return!0;return!1},t}(p4);Rc.ArraySignature=G$t;var W$t=function(e){jot.__extends(t,e);function t(r){var n=e.call(this)||this;return n.ref=r,n}return t.prototype.isSignatureDifferent=function(r){return this.ref!==r.ref},t}(p4);Rc.ReferenceSignature=W$t;var Y$t=function(e){jot.__extends(t,e);function t(r){var n=e.call(this)||this;return n.obj=r,n}return t.prototype.isSignatureDifferent=function(r){var n=Object.keys(this.obj),i=Object.keys(r.obj);if(n.length!==i.length)return!0;for(var o=0,a=n;o<a.length;o++){var s=a[o];if(!r.obj.hasOwnProperty(s)||this.obj[s].isDifferent(r.obj[s]))return!0}return!1},t}(p4);Rc.ObjectSignature=Y$t});var j$t=H(Kot=>{"use strict";Object.defineProperty(Kot,"__esModule",{value:!0});var fHe=$ot();function pHe(e){var t=void 0,r,n=!1,i=!1,o=function(){for(var a=[],s=0;s<arguments.length;s++)a[s]=arguments[s];if(n)return r;var l=fHe.signArray(a);return t===void 0||t.isDifferent(l)?(i&&console.warn("cache miss! computing"),t=l,r=e.apply(this,a)):i&&console.warn("cache hit!"),r};return o.doLocked=function(a){if(n)throw new Error("Locking an already locked memoize function!");n=!0;var s=a.apply(this);return n=!1,s},o.logPerformance=function(a){return a===void 0&&(a=!0),i=a,this},o}Kot.memoize=pHe});var K$t=H(JF=>{"use strict";Object.defineProperty(JF,"__esModule",{value:!0});var dHe=Oe(),Zot=function(){function e(){this.map=Object.create(null),this.exists=Object.create(null)}return e.prototype.delete=function(t){return delete this.map[t],delete this.exists[t],!0},e.prototype.get=function(t){return this.map[t]},e.prototype.has=function(t){return!!this.exists[t]},e.prototype.set=function(t,r){return this.map[t]=r,this.exists[t]=!0,this},e}(),X$t=function(){function e(){this.map=new Zot}return e.prototype.get=function(t){return this.map.get(t[0]).get(t[1])},e.prototype.has=function(t){return this.map.has(t[0])&&this.map.get(t[0]).has(t[1])},e.prototype.set=function(t,r){return this.map.has(t[0])||this.map.set(t[0],new Zot),this.map.get(t[0]).set(t[1],r),this},e.prototype.delete=function(t){return this.map.has(t[0])&&this.map.get(t[0]).delete(t[1]),!0},e.prototype.clear=function(){this.map=new Zot},e.resolver=function(t,r,n){return[n.updateId(),r]},e}();function $$t(e){var t=dHe.memoize(e,X$t.resolver);return t.cache=new X$t,t}JF.memoizeProjector=$$t;function mHe(e){return Object.keys(e).forEach(function(t){e[t]=$$t(e[t])}),e}JF.memoizeProjectors=mHe});var Z$t=H(Jot=>{"use strict";Object.defineProperty(Jot,"__esModule",{value:!0});var gHe=CS();function _He(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=e.slice(0,-1),n=e[e.length-1],i=gHe.memoize(n),o=function(){var a=this,s=r.map(function(l){return l.apply(a)});return i.apply(void 0,s)};return o}Jot.memThunk=_He});var CS=H(AS=>{"use strict";Object.defineProperty(AS,"__esModule",{value:!0});var Qot=(de(),Ut(pe));Qot.__exportStar(j$t(),AS);Qot.__exportStar(K$t(),AS);Qot.__exportStar(Z$t(),AS);var yHe=$ot();AS.sign=yHe.sign});var Fv=H(Nc=>{"use strict";Object.defineProperty(Nc,"__esModule",{value:!0});var J$t=(Er(),Ut(Mr)),vHe=function(){function e(t,r){this._context=t,this._drawStep=r}return e.prototype.getDrawStep=function(){return this._drawStep},e.prototype.draw=function(t,r){var n=r[r.length-1].attrToAppliedProjector;this._context.save(),this._drawStep(this._context,t,n),this._context.restore()},e.prototype.getVisualPrimitives=function(){return[]},e.prototype.getVisualPrimitiveAtIndex=function(t){return null},e.prototype.remove=function(){},e}();Nc.CanvasDrawer=vHe;Nc.ContextStyleAttrs=["fill-opacity","fill","opacity","stroke-opacity","stroke-width","stroke","stroke-dasharray"];function xHe(e,t,r,n){var i=Nc.ContextStyleAttrs.concat(t);return Q$t(e,i,r,n)}Nc.resolveAttributesSubsetWithStyles=xHe;function Q$t(e,t,r,n){for(var i={},o=0,a=t;o<a.length;o++){var s=a[o];e.hasOwnProperty(s)&&(i[s]=e[s](r,n))}return i}Nc.resolveAttributes=Q$t;function bHe(e){var t=e.opacity!=null?parseFloat(e.opacity):1,r=e["stroke-opacity"]!=null?parseFloat(e["stroke-opacity"]):1;return r*t}function wHe(e){var t=e.opacity!=null?parseFloat(e.opacity):1,r=e["fill-opacity"]!=null?parseFloat(e["fill-opacity"]):1;return r*t}function tKt(e){return e["stroke-width"]!=null?parseFloat(e["stroke-width"]):1}Nc.getStrokeWidth=tKt;function eKt(e){var t=e["stroke-dasharray"];if(t!=null)try{return t.split(/[ ,]+/).map(function(r){return parseInt(r,10)})}catch(r){return console.error("getStrokeDashArray failed with: "+r),[]}return[]}Nc.getStrokeDashArray=eKt;function SHe(e,t,r,n){e.save(),e.beginPath(),t.context(e),t(r),e.lineJoin="round",tat(e,n),e.restore()}Nc.renderArea=SHe;function MHe(e,t,r,n){e.save(),e.beginPath(),t.context(e),t(r),e.lineJoin="round",tat(e,n),e.restore()}Nc.renderLine=MHe;function tat(e,t){if(t.stroke){e.lineWidth=tKt(t);var r=J$t.color(t.stroke),n=eKt(t);e.setLineDash(n),r.opacity*=bHe(t),e.strokeStyle=r.toString(),e.stroke()}if(t.fill){var i=J$t.color(t.fill);i.opacity*=wHe(t),e.fillStyle=i.toString(),e.fill()}}Nc.renderPathWithStyle=tat});var Uu=H(eat=>{"use strict";Object.defineProperty(eat,"__esModule",{value:!0});var EHe=function(){function e(t,r){this._svgDrawerFactory=t,this._canvasDrawerFactory=r}return e.prototype.useSVG=function(t){this._currentDrawer!=null&&this._currentDrawer.remove();var r=this._svgDrawerFactory();r.attachTo(t),this._currentDrawer=r},e.prototype.useCanvas=function(t){this._currentDrawer!=null&&this._currentDrawer.remove(),this._currentDrawer=this._canvasDrawerFactory(t.node().getContext("2d"))},e.prototype.getDrawer=function(){return this._currentDrawer},e.prototype.remove=function(){this._currentDrawer!=null&&this._currentDrawer.remove()},e.prototype.draw=function(t,r){this._currentDrawer.draw(t,r)},e.prototype.getVisualPrimitives=function(){return this._currentDrawer.getVisualPrimitives()},e.prototype.getVisualPrimitiveAtIndex=function(t){return this._currentDrawer.getVisualPrimitiveAtIndex(t)},e}();eat.ProxyDrawer=EHe});var Df=H(rat=>{"use strict";Object.defineProperty(rat,"__esModule",{value:!0});var THe=(Er(),Ut(Mr)),rKt=Fe(),CHe=function(){function e(t,r){this._root=THe.select(document.createElementNS("http://www.w3.org/2000/svg","g")),this._className=r,this._svgElementName=t}return e.prototype.draw=function(t,r){var n=this;this._createAndDestroyDOMElements(t);for(var i=0,o=r.length,a=function(l){var c=r[l];rKt.Window.setTimeout(function(){return n._drawStep(c)},i),i+=c.animator.totalTime(t.length)},s=0;s<o;s++)a(s)},e.prototype.getVisualPrimitives=function(){return this._cachedVisualPrimitivesNodes==null&&(this._cachedVisualPrimitivesNodes=this._selection.nodes()),this._cachedVisualPrimitivesNodes},e.prototype.getVisualPrimitiveAtIndex=function(t){return this._cachedVisualPrimitivesNodeMap==null?null:this._cachedVisualPrimitivesNodeMap.get(t)},e.prototype.remove=function(){this._root.remove()},e.prototype.attachTo=function(t){t.node().appendChild(this._root.node())},e.prototype.getRoot=function(){return this._root},e.prototype.selector=function(){return this._svgElementName},e.prototype._applyDefaultAttributes=function(t){},e.prototype._createAndDestroyDOMElements=function(t){var r=t.map(function(a,s){return a!=null?{d:a,i:s}:null}),n=r.filter(function(a){return a!=null}),i=this._root.selectAll(this.selector()).data(n);this._selection=i.enter().append(this._svgElementName).merge(i),i.exit().remove();var o=new rKt.Map;this._selection.each(function(a){o.set(a.i,this)}),this._cachedVisualPrimitivesNodeMap=o,this._cachedVisualPrimitivesNodes=null,this._selection.data(this._selection.data().map(function(a){var s=a.d;return s})),this._className!=null&&this._selection.classed(this._className,!0),this._applyDefaultAttributes(this._selection)},e.prototype._drawStep=function(t){var r=this,n=["fill","stroke"];n.forEach(function(i){t.attrToAppliedProjector[i]!=null&&r._selection.attr(i,t.attrToAppliedProjector[i])}),t.animator.animate(this._selection,t.attrToAppliedProjector),this._className!=null&&this._selection.classed(this._className,!0)},e}();rat.SVGDrawer=CHe});var iat=H(nat=>{"use strict";Object.defineProperty(nat,"__esModule",{value:!0});var nKt=function(){function e(){var t=this;this.scale=0,this.translate=0,this.cachedDomain=[null,null],this.lastSeenDomain=[null,null],this.updateDomain=function(r){t.lastSeenDomain=r.getTransformationDomain();var n=r.scaleTransformation(t.cachedDomain[1])-r.scaleTransformation(t.cachedDomain[0]),i=r.scaleTransformation(t.lastSeenDomain[1])-r.scaleTransformation(t.lastSeenDomain[0]);t.scale=n/i||1,t.translate=r.scaleTransformation(t.cachedDomain[0])-r.scaleTransformation(t.lastSeenDomain[0])*t.scale||0}}return e.prototype.reset=function(){this.scale=1,this.translate=0,this.cachedDomain=this.lastSeenDomain},e.prototype.setDomain=function(t){this.cachedDomain=t.getTransformationDomain()},e}(),AHe=function(){function e(t,r){var n=this;this.renderCallback=t,this.applyTransformCallback=r,this.domainTransformX=new nKt,this.domainTransformY=new nKt,this.renderDeferred=function(){n.applyTransform(),clearTimeout(n.timeoutToken),n.timeoutToken=setTimeout(function(){n.renderCallback()},e.DEFERRED_RENDERING_DELAY)}}return e.prototype.setDomains=function(t,r){t&&this.domainTransformX.setDomain(t),r&&this.domainTransformY.setDomain(r),this.renderDeferred()},e.prototype.updateDomains=function(t,r){t&&this.domainTransformX.updateDomain(t),r&&this.domainTransformY.updateDomain(r),this.renderDeferred()},e.prototype.resetTransforms=function(){this.domainTransformX.reset(),this.domainTransformY.reset(),this.applyTransform()},e.prototype.applyTransform=function(){this.applyTransformCallback(this.domainTransformX.translate,this.domainTransformY.translate,this.domainTransformX.scale,this.domainTransformY.scale)},e.DEFERRED_RENDERING_DELAY=200,e}();nat.DeferredRenderer=AHe});var rs=H(QF=>{"use strict";Object.defineProperty(QF,"__esModule",{value:!0});var PHe=(de(),Ut(pe)),wd=(Er(),Ut(Mr)),d4=Lf(),Sd=Fe(),iKt=Got(),oat=CS(),IHe=kc(),LHe=Fv(),kHe=Uu(),RHe=Df(),NHe=Yg(),DHe=If(),OHe=iat();QF.Renderer=DHe.makeEnum(["svg","canvas"]);var zHe=function(e){PHe.__extends(t,e);function t(){var r=e.call(this)||this;r._dataChanged=!1,r._attrExtents={},r._animate=!1,r._animators={},r._propertyExtents={},r._resetEntityStore=function(){r._cachedEntityStore=void 0},r._overflowHidden=!0,r.addClass("plot"),r._datasetToDrawer=new Sd.Map,r._attrBindings=wd.map(),r._includedValuesProvider=function(i,o){return r._includedValuesForScale(i,o)},r._renderCallback=function(){return r.render()},r._onDatasetUpdateCallback=function(){return r._onDatasetUpdate()},r._propertyBindings=wd.map();var n=new d4.Easing().maxTotalDuration(t._ANIMATION_MAX_DURATION);return r.animator(iKt.Animator.MAIN,n),r.animator(iKt.Animator.RESET,new d4.Null),r._deferredResetEntityStore=Sd.Window.debounce(OHe.DeferredRenderer.DEFERRED_RENDERING_DELAY,r._resetEntityStore),r}return t.getTotalDrawTime=function(r,n){return n.reduce(function(i,o){return i+o.animator.totalTime(r.length)},0)},t.applyDrawSteps=function(r,n){var i=r.map(function(o){var a=o.attrToProjector,s={};return Object.keys(a).forEach(function(l){s[l]=function(c,u){return a[l](c,u,n)}}),{attrToAppliedProjector:s,animator:o.animator}});return i},t.prototype.anchor=function(r){return r=NHe.coerceExternalD3(r),e.prototype.anchor.call(this,r),this._dataChanged=!0,this._resetEntityStore(),this._updateExtents(),this},t.prototype._setup=function(){var r=this;this._isSetup||(e.prototype._setup.call(this),this._canvas!=null&&this._appendCanvasNode(),this._renderArea=this.content().append("g").classed("render-area",!0),this.datasets().forEach(function(n){return r._createNodesForDataset(n)}))},t.prototype._appendCanvasNode=function(){var r=this.element().select(".plot-canvas-container");r.empty()&&(r=this.element().append("div").classed("plot-canvas-container",!0),r.node().appendChild(this._canvas.node()))},t.prototype.setBounds=function(r,n,i,o){if(e.prototype.setBounds.call(this,r,n,i,o),this._updateExtents(),this._canvas!=null){if(this._bufferCanvas&&!this._bufferCanvasValid){this._bufferCanvas.attr("width",this._canvas.attr("width")),this._bufferCanvas.attr("height",this._canvas.attr("height"));var a=this._bufferCanvas.node().getContext("2d");if(a){var s=this._canvas.node();s.width>0&&s.height>0?a.canvas.width>0&&a.canvas.height>0&&a.drawImage(s,0,0):console.warn("Failed to fill buffer canvas with with 0x0 canvas")}this._bufferCanvasValid=!0}var l=window.devicePixelRatio!=null?window.devicePixelRatio:1;this._canvas.attr("width",r*l),this._canvas.attr("height",n*l);var c=this._canvas.node().getContext("2d");if(c&&(c.setTransform(l,0,0,l,0,0),this._bufferCanvas)){var u=this._bufferCanvas.node();u.width>0&&u.height>0?c.canvas.width>0&&c.canvas.height>0&&c.drawImage(u,0,0,r,n):console.warn("Failed to fill canvas with 0x0 buffer canvas")}}return this},t.prototype.destroy=function(){var r=this;e.prototype.destroy.call(this),this._scales().forEach(function(n){return n.offUpdate(r._renderCallback)}),this.datasets([])},t.prototype._createNodesForDataset=function(r){var n=this._datasetToDrawer.get(r);return this.renderer()==="svg"?n.useSVG(this._renderArea):n.useCanvas(this._canvas),n},t.prototype._createDrawer=function(r){return new kHe.ProxyDrawer(function(){return new RHe.SVGDrawer("path","")},function(n){return new LHe.CanvasDrawer(n,function(){})})},t.prototype._getAnimator=function(r){return this._animateOnNextRender()?this._animators[r]||new d4.Null:new d4.Null},t.prototype._onDatasetUpdate=function(){this._updateExtents(),this._dataChanged=!0,this._resetEntityStore(),this.renderLowPriority()},t.prototype.attr=function(r,n,i){return n==null?this._attrBindings.get(r):(this._bindAttr(r,n,i),this.render(),this)},t.prototype._bindProperty=function(r,n,i,o){var a=this._propertyBindings.get(r),s=a!=null?a.scale:null,l=typeof n=="function"?n:function(){return n};this._propertyBindings.set(r,{accessor:l,scale:i,postScale:o}),s!=null&&this._uninstallScaleForKey(s,r),i!=null&&this._installScaleForKey(i,r),this._clearAttrToProjectorCache()},t.prototype._bindAttr=function(r,n,i){var o=this._attrBindings.get(r),a=o!=null?o.scale:null,s=typeof n=="function"?n:function(){return n};this._attrBindings.set(r,{accessor:s,scale:i}),a!=null&&this._uninstallScaleForKey(a,r),i!=null&&this._installScaleForKey(i,r),this._clearAttrToProjectorCache()},t.prototype._clearAttrToProjectorCache=function(){delete this._cachedAttrToProjector},t.prototype._getAttrToProjector=function(){if(this._cachedAttrToProjector==null){var r=this._generateAttrToProjector();t.OPTIMIZE_MEMOIZE_PROJECTORS&&(r=oat.memoizeProjectors(r)),this._cachedAttrToProjector=r}return Sd.assign({},this._cachedAttrToProjector)},t.prototype._generateAttrToProjector=function(){var r={};this._attrBindings.each(function(i,o){r[o]=t._scaledAccessor(i)});var n=this._propertyProjectors();return Object.keys(n).forEach(function(i){r[i]==null&&(r[i]=n[i])}),r},t.prototype.renderImmediately=function(){return e.prototype.renderImmediately.call(this),this._isAnchored&&(this._paint(),this._dataChanged=!1),this},t.prototype.renderLowPriority=function(){return this._renderCallback(),this},t.prototype.animated=function(r){return r==null?this._animate:(this._animate=r,this)},t.prototype.detach=function(){return e.prototype.detach.call(this),this._updateExtents(),this},t.prototype._scales=function(){var r=[];return this._attrBindings.each(function(n,i){var o=n.scale;o!=null&&r.indexOf(o)===-1&&r.push(o)}),this._propertyBindings.each(function(n,i){var o=n.scale;o!=null&&r.indexOf(o)===-1&&r.push(o)}),r},t.prototype._updateExtents=function(){var r=this;this._resetEntityStore(),this._scales().forEach(function(n){return n.addIncludedValuesProvider(r._includedValuesProvider)})},t.prototype._filterForProperty=function(r){return null},t.prototype.getExtentsForAttr=function(r){var n=this;if(this._attrExtents[r]==null){var i=oat.memThunk(function(){return n.datasets()},function(){return n._attrBindings.get(r)},function(o,a){return a==null||a.accessor==null?null:o.map(function(s){return oKt(s,a,null)})});this._attrExtents[r]=i}return this._attrExtents[r]()},t.prototype.getExtentsForProperty=function(r){var n=this;if(this._propertyExtents[r]==null){var i=oat.memThunk(function(){return n.datasets()},function(){return n._propertyBindings.get(r)},function(){return n._filterForProperty(r)},function(o,a,s){return a==null||a.accessor==null?null:o.map(function(l){return oKt(l,a,s)})});this._propertyExtents[r]=i}return this._propertyExtents[r]()},t.prototype._includedValuesForScale=function(r,n){var i=this;if(!this._isAnchored&&!n)return[];var o=[];return this._attrBindings.each(function(a,s){if(a.scale===r){var l=i.getExtentsForAttr(s);l!=null&&(o=o.concat(wd.merge(l)))}}),this._propertyBindings.each(function(a,s){if(a.scale===r){var l=i.getExtentsForProperty(s);l!=null&&(o=o.concat(wd.merge(l)))}}),o},t.prototype.animator=function(r,n){return n===void 0?this._animators[r]:(this._animators[r]=n,this)},t.prototype.renderer=function(r){var n=this;return r===void 0?this._canvas==null?"svg":"canvas":(this._canvas==null&&r==="canvas"?(this._canvas=wd.select(document.createElement("canvas")).classed("plot-canvas",!0),this._bufferCanvas=wd.select(document.createElement("canvas")),this.element()!=null&&this._appendCanvasNode(),this._datasetToDrawer.forEach(function(i){i.useCanvas(n._canvas)}),this.render()):this._canvas!=null&&r=="svg"&&(this._canvas.remove(),this._canvas=null,this._bufferCanvas=null,this._datasetToDrawer.forEach(function(i){i.useSVG(n._renderArea)}),this.render()),this)},t.prototype.addDataset=function(r){return this._addDataset(r),this._onDatasetUpdate(),this},t.prototype._addDataset=function(r){this._removeDataset(r);var n=this._createDrawer(r);return this._datasetToDrawer.set(r,n),this._isSetup&&this._createNodesForDataset(r),r.onUpdate(this._onDatasetUpdateCallback),this},t.prototype.removeDataset=function(r){return this._removeDataset(r),this._onDatasetUpdate(),this},t.prototype._removeDataset=function(r){return this.datasets().indexOf(r)===-1?this:(this._removeDatasetNodes(r),r.offUpdate(this._onDatasetUpdateCallback),this._datasetToDrawer.delete(r),this)},t.prototype._removeDatasetNodes=function(r){var n=this._datasetToDrawer.get(r);n.remove()},t.prototype.datasets=function(r){var n=this,i=[];return this._datasetToDrawer.forEach(function(o,a){return i.push(a)}),r==null?i:(i.forEach(function(o){return n._removeDataset(o)}),r.forEach(function(o){return n._addDataset(o)}),this._onDatasetUpdate(),this)},t.prototype._generateDrawSteps=function(){return[{attrToProjector:this._getAttrToProjector(),animator:new d4.Null}]},t.prototype._additionalPaint=function(r){},t.prototype._buildLightweightPlotEntities=function(r){var n=this,i=[];return r.forEach(function(o,a){for(var s=n._datasetToDrawer.get(o),l=0,c=o.data(),u=c.length,h=function(p){var d=c[p],g=n._pixelPoint(d,p,o);if(Sd.Math.isNaN(g.x)||Sd.Math.isNaN(g.y))return"continue";var _=n;i.push({datum:d,get position(){return _._pixelPoint.call(_,d,p,o)},index:p,dataset:o,datasetIndex:a,component:n,drawer:s,validDatumIndex:l}),l++},f=0;f<u;f++)h(f)}),i},t.prototype._getDataToDraw=function(){var r=new Sd.Map;return this.datasets().forEach(function(n){return r.set(n,n.data())}),r},t.prototype._paint=function(){var r=this;delete this._cachedAttrToProjector;var n=this._generateDrawSteps(),i=this._getDataToDraw(),o=this.datasets().map(function(u){return r._datasetToDrawer.get(u)});if(this.renderer()==="canvas"){var a=this._canvas.node(),s=a.getContext("2d");s.clearRect(0,0,a.clientWidth,a.clientHeight),this._bufferCanvasValid=!1}this.datasets().forEach(function(u,h){var f=t.applyDrawSteps(n,u);o[h].draw(i.get(u),f)});var l=this.datasets().map(function(u,h){return t.getTotalDrawTime(i.get(u),n)}),c=Sd.Math.max(l,0);this._additionalPaint(c)},t.prototype.selections=function(r){var n=this;if(r===void 0&&(r=this.datasets()),this.renderer()==="canvas")return wd.selectAll();var i=[];return r.forEach(function(o){var a=n._datasetToDrawer.get(o);if(a!=null){var s=a.getVisualPrimitives();i.push.apply(i,s)}}),wd.selectAll(i)},t.prototype.entities=function(r){var n=this;return this._getEntityStore(r).entities().map(function(i){return n._lightweightPlotEntityToPlotEntity(i)})},t.prototype.filterEntities=function(r){var n=this;return this._getEntityStore().entities().filter(r).map(function(i){return n._lightweightPlotEntityToPlotEntity(i)})},t.prototype._getEntityStore=function(r){var n=this,i=function(a){return n._entityBounds(a)};if(r!==void 0){var o=new Sd.EntityStore;return o.addAll(this._buildLightweightPlotEntities(r),i,this._localOriginBounds()),o}else if(this._cachedEntityStore===void 0){var o=new Sd.EntityStore;o.addAll(this._buildLightweightPlotEntities(this.datasets()),i,this._localOriginBounds()),this._cachedEntityStore=o}return this._cachedEntityStore},t.prototype._localOriginBounds=function(){return{topLeft:{x:0,y:0},bottomRight:{x:this.width(),y:this.height()}}},t.prototype._entityBounds=function(r){var n=r.datum,i=r.index,o=r.dataset,a=this._pixelPoint(n,i,o),s=a.x,l=a.y;return{x:s,y:l,width:0,height:0}},t.prototype._lightweightPlotEntityToPlotEntity=function(r){var n={bounds:this._entityBounds(r),component:r.component,dataset:r.dataset,datasetIndex:r.datasetIndex,datum:r.datum,index:r.index,position:r.position,selection:wd.select(r.drawer.getVisualPrimitiveAtIndex(r.validDatumIndex))};return n},t.prototype.entitiesAt=function(r){throw new Error("plots must implement entitiesAt")},t.prototype.entityNearest=function(r){var n=this._getEntityStore().entityNearest(r);return n===void 0?void 0:this._lightweightPlotEntityToPlotEntity(n)},t.prototype.entitiesIn=function(r,n){var i;if(n==null){var o=r;i={x:o.topLeft.x,y:o.topLeft.y,width:o.bottomRight.x-o.topLeft.x,height:o.bottomRight.y-o.topLeft.y}}else{var a=r;i={x:a.min,y:n.min,width:a.max-a.min,height:n.max-n.min}}return this.entitiesInBounds(i)},t.prototype.entitiesInBounds=function(r){var n=this,i=this._getEntityStore().entitiesInBounds(r);if(!!i)return i.map(function(o){return n._lightweightPlotEntityToPlotEntity(o)})},t.prototype.entitiesInXBounds=function(r){var n=this,i=this._getEntityStore().entitiesInXBounds(r);if(!!i)return i.map(function(o){return n._lightweightPlotEntityToPlotEntity(o)})},t.prototype.entitiesInYBounds=function(r){var n=this,i=this._getEntityStore().entitiesInYBounds(r);if(!!i)return i.map(function(o){return n._lightweightPlotEntityToPlotEntity(o)})},t.prototype._uninstallScaleForKey=function(r,n){r.offUpdate(this._renderCallback),r.offUpdate(this._deferredResetEntityStore),r.removeIncludedValuesProvider(this._includedValuesProvider)},t.prototype._installScaleForKey=function(r,n){r.onUpdate(this._renderCallback),r.onUpdate(this._deferredResetEntityStore),r.addIncludedValuesProvider(this._includedValuesProvider)},t.prototype._propertyProjectors=function(){return{}},t._scaledAccessor=function(r){var n=r.scale,i=r.accessor,o=r.postScale,a=n==null?i:function(l,c,u){return n.scale(i(l,c,u))},s=o==null?a:function(l,c,u){return o(a(l,c,u),l,c,u)};return s},t.prototype._pixelPoint=function(r,n,i){return{x:0,y:0}},t.prototype._animateOnNextRender=function(){return this._animate&&this._dataChanged},t.OPTIMIZE_MEMOIZE_PROJECTORS=!1,t._ANIMATION_MAX_DURATION=600,t}(IHe.Component);QF.Plot=zHe;function oKt(e,t,r){var n=t.accessor,i=t.scale;if(i==null)return[];var o=e.data();r!=null&&(o=o.filter(function(l,c){return r(l,c,e)}));var a=function(l,c){return n(l,c,e)},s=o.map(a);return i.extentOfValues(s)}});var aKt=H(aat=>{"use strict";Object.defineProperty(aat,"__esModule",{value:!0});var FHe=(de(),Ut(pe)),BHe=rs(),HHe=Fe(),VHe=zot(),UHe=function(e){FHe.__extends(t,e);function t(){return e!==null&&e.apply(this,arguments)||this}return t.prototype.entityNearest=function(r){var n,i=1/0;return this.components().forEach(function(o){var a=o,s=a.entityNearest(r);if(s!=null){var l=HHe.Math.distanceSquared(s.position,r);l<=i&&(i=l,n=s)}}),n},t.prototype.append=function(r){if(r!=null&&!(r instanceof BHe.Plot))throw new Error("Plot Group only accepts plots");return e.prototype.append.call(this,r),this},t}(VHe.Group);aat.PlotGroup=UHe});var sKt=H(sat=>{"use strict";Object.defineProperty(sat,"__esModule",{value:!0});var qHe=(de(),Ut(pe)),qu=(Er(),Ut(Mr)),Go=Fe(),GHe=WF(),WHe=function(e){qHe.__extends(t,e);function t(r){r===void 0&&(r=[]);var n=e.call(this)||this;return n._rowPadding=0,n._columnPadding=0,n._rows=[],n._rowWeights=[],n._columnWeights=[],n._nRows=0,n._nCols=0,n._calculatedLayout=null,n.addClass("table"),r.forEach(function(i,o){i.forEach(function(a,s){a!=null&&n.add(a,o,s)})}),n}return t.prototype._forEach=function(r){for(var n=0;n<this._nRows;n++)for(var i=0;i<this._nCols;i++)this._rows[n][i]!=null&&r(this._rows[n][i])},t.prototype.has=function(r){for(var n=0;n<this._nRows;n++)for(var i=0;i<this._nCols;i++)if(this._rows[n][i]===r)return!0;return!1},t.prototype.componentAt=function(r,n){return r<0||r>=this._nRows||n<0||n>=this._nCols?null:this._rows[r][n]},t.prototype.add=function(r,n,i){if(r==null)throw Error("Cannot add null to a table cell");if(!this.has(r)){var o=this._rows[n]&&this._rows[n][i];if(o!=null)throw new Error("cell is occupied");r.detach(),this._nRows=Math.max(n+1,this._nRows),this._nCols=Math.max(i+1,this._nCols),this._padTableToSize(this._nRows,this._nCols),this._rows[n][i]=r,this._adoptAndAnchor(r),this.redraw()}return this},t.prototype._remove=function(r){for(var n=0;n<this._nRows;n++)for(var i=0;i<this._nCols;i++)if(this._rows[n][i]===r)return this._rows[n][i]=null,!0;return!1},t.prototype._iterateLayout=function(r,n,i){i===void 0&&(i=!1);for(var o=this._rows,a=qu.transpose(this._rows),s=r-this._columnPadding*(this._nCols-1),l=n-this._rowPadding*(this._nRows-1),c=t._calcComponentWeights(this._rowWeights,o,function(z){return z==null||z.fixedHeight()}),u=t._calcComponentWeights(this._columnWeights,a,function(z){return z==null||z.fixedWidth()}),h=u.map(function(z){return z===0?.5:z}),f=c.map(function(z){return z===0?.5:z}),p=t._calcProportionalSpace(h,s),d=t._calcProportionalSpace(f,l),g=Go.Array.createFilledArray(0,this._nCols),_=Go.Array.createFilledArray(0,this._nRows),y,x,b=0,S,C,P;;){var k=Go.Array.add(_,d),O=Go.Array.add(g,p);S=this._determineGuarantees(O,k,i),g=S.guaranteedWidths,_=S.guaranteedHeights,C=S.wantsWidthArr.some(function(z){return z}),P=S.wantsHeightArr.some(function(z){return z});var D=y,B=x;y=s-qu.sum(S.guaranteedWidths),x=l-qu.sum(S.guaranteedHeights);var I=void 0;C?(I=S.wantsWidthArr.map(function(z){return z?.1:0}),I=Go.Array.add(I,u)):I=u;var L=void 0;P?(L=S.wantsHeightArr.map(function(z){return z?.1:0}),L=Go.Array.add(L,c)):L=c,p=t._calcProportionalSpace(I,y),d=t._calcProportionalSpace(L,x),b++;var R=y>0&&y!==D,F=x>0&&x!==B;if(!(R||F)||b>5)break}return y=s-qu.sum(S.guaranteedWidths),x=l-qu.sum(S.guaranteedHeights),p=t._calcProportionalSpace(u,y),d=t._calcProportionalSpace(c,x),{colProportionalSpace:p,rowProportionalSpace:d,guaranteedWidths:S.guaranteedWidths,guaranteedHeights:S.guaranteedHeights,wantsWidth:C,wantsHeight:P}},t.prototype._determineGuarantees=function(r,n,i){i===void 0&&(i=!1);var o=Go.Array.createFilledArray(0,this._nCols),a=Go.Array.createFilledArray(0,this._nRows),s=Go.Array.createFilledArray(!1,this._nCols),l=Go.Array.createFilledArray(!1,this._nRows);return this._rows.forEach(function(c,u){c.forEach(function(h,f){var p;h!=null?p=h.requestedSpace(r[f],n[u]):p={minWidth:0,minHeight:0};var d=i?Math.min(p.minWidth,r[f]):p.minWidth;o[f]=Math.max(o[f],d);var g=i?Math.min(p.minHeight,n[u]):p.minHeight;a[u]=Math.max(a[u],g);var _=p.minWidth>r[f];s[f]=s[f]||_;var y=p.minHeight>n[u];l[u]=l[u]||y})}),{guaranteedWidths:o,guaranteedHeights:a,wantsWidthArr:s,wantsHeightArr:l}},t.prototype.requestedSpace=function(r,n){return this._calculatedLayout=this._iterateLayout(r,n),{minWidth:qu.sum(this._calculatedLayout.guaranteedWidths),minHeight:qu.sum(this._calculatedLayout.guaranteedHeights)}},t.prototype.computeLayout=function(r,n,i){var o=this;e.prototype.computeLayout.call(this,r,n,i);var a=qu.sum(this._calculatedLayout.guaranteedWidths),s=qu.sum(this._calculatedLayout.guaranteedHeights),l=this._calculatedLayout;(a>this.width()||s>this.height())&&(l=this._iterateLayout(this.width(),this.height(),!0));var c=0,u=Go.Array.add(l.rowProportionalSpace,l.guaranteedHeights),h=Go.Array.add(l.colProportionalSpace,l.guaranteedWidths);return this._rows.forEach(function(f,p){var d=0;f.forEach(function(g,_){g!=null&&g.computeLayout({x:d,y:c},h[_],u[p]),d+=h[_]+o._columnPadding}),c+=u[p]+o._rowPadding}),this},t.prototype.rowPadding=function(r){if(r==null)return this._rowPadding;if(!Go.Math.isValidNumber(r)||r<0)throw Error("rowPadding must be a non-negative finite value");return this._rowPadding=r,this.redraw(),this},t.prototype.columnPadding=function(r){if(r==null)return this._columnPadding;if(!Go.Math.isValidNumber(r)||r<0)throw Error("columnPadding must be a non-negative finite value");return this._columnPadding=r,this.redraw(),this},t.prototype.rowWeight=function(r,n){if(n==null)return this._rowWeights[r];if(!Go.Math.isValidNumber(n)||n<0)throw Error("rowWeight must be a non-negative finite value");return this._rowWeights[r]=n,this.redraw(),this},t.prototype.columnWeight=function(r,n){if(n==null)return this._columnWeights[r];if(!Go.Math.isValidNumber(n)||n<0)throw Error("columnWeight must be a non-negative finite value");return this._columnWeights[r]=n,this.redraw(),this},t.prototype.fixedWidth=function(){var r=qu.transpose(this._rows);return t._fixedSpace(r,function(n){return n==null||n.fixedWidth()})},t.prototype.fixedHeight=function(){return t._fixedSpace(this._rows,function(r){return r==null||r.fixedHeight()})},t.prototype._padTableToSize=function(r,n){for(var i=0;i<r;i++){this._rows[i]===void 0&&(this._rows[i]=[],this._rowWeights[i]=null);for(var o=0;o<n;o++)this._rows[i][o]===void 0&&(this._rows[i][o]=null)}for(var o=0;o<n;o++)this._columnWeights[o]===void 0&&(this._columnWeights[o]=null)},t._calcComponentWeights=function(r,n,i){return r.map(function(o,a){if(o!=null)return o;var s=n[a].map(i),l=s.reduce(function(c,u){return c&&u},!0);return l?0:1})},t._calcProportionalSpace=function(r,n){var i=qu.sum(r);return i===0?Go.Array.createFilledArray(0,r.length):r.map(function(o){return n*o/i})},t._fixedSpace=function(r,n){var i=function(a){return a.reduce(function(s,l){return s&&l},!0)},o=function(a){return i(a.map(n))};return i(r.map(o))},t}(GHe.ComponentContainer);sat.Table=WHe});var lKt=H(lat=>{"use strict";Object.defineProperty(lat,"__esModule",{value:!0});var YHe=(de(),Ut(pe)),jHe=Vot(),XHe=2,$He=function(e){YHe.__extends(t,e);function t(){var r=e!==null&&e.apply(this,arguments)||this;return r._maxLines=XHe,r}return t.prototype.requestedSpace=function(r,n){this._wrapper.maxLines(this._maxLines);var i=this.angle()===0?r:n;i===0&&(i=1/0);var o=this._wrapper.wrap(this._text,this._measurer,i),a=this._measurer.measure(o.wrappedText),s=(this.angle()===0?a.width:a.height)+2*this.padding(),l=(this.angle()===0?a.height:a.width)+2*this.padding();return{minWidth:s,minHeight:l}},t.prototype.maxLines=function(r){return arguments.length===0?this._maxLines:(this._maxLines=r,this.redraw(),this)},t}(jHe.Label);lat.WrappedLabel=$He});var cKt=H(cat=>{"use strict";Object.defineProperty(cat,"__esModule",{value:!0});var KHe=(de(),Ut(pe)),ZHe=qF(),JHe=function(e){KHe.__extends(t,e);function t(){var r=e.call(this)||this;return r.addClass("x-drag-box-layer"),r._hasCorners=!1,r}return t.prototype.computeLayout=function(r,n,i){return e.prototype.computeLayout.call(this,r,n,i),this._setBounds(this.bounds()),this},t.prototype._setBounds=function(r){e.prototype._setBounds.call(this,{topLeft:{x:r.topLeft.x,y:0},bottomRight:{x:r.bottomRight.x,y:this.height()}})},t.prototype._setResizableClasses=function(r){r&&this.enabled()?this.addClass("x-resizable"):this.removeClass("x-resizable")},t.prototype.yScale=function(r){if(r==null)return e.prototype.yScale.call(this);throw new Error("yScales cannot be set on an XDragBoxLayer")},t.prototype.yExtent=function(r){if(r==null)return e.prototype.yExtent.call(this);throw new Error("XDragBoxLayer has no yExtent")},t}(ZHe.DragBoxLayer);cat.XDragBoxLayer=JHe});var uKt=H(uat=>{"use strict";Object.defineProperty(uat,"__esModule",{value:!0});var QHe=(de(),Ut(pe)),tVe=qF(),eVe=function(e){QHe.__extends(t,e);function t(){var r=e.call(this)||this;return r.addClass("y-drag-box-layer"),r._hasCorners=!1,r}return t.prototype.computeLayout=function(r,n,i){return e.prototype.computeLayout.call(this,r,n,i),this._setBounds(this.bounds()),this},t.prototype._setBounds=function(r){e.prototype._setBounds.call(this,{topLeft:{x:0,y:r.topLeft.y},bottomRight:{x:this.width(),y:r.bottomRight.y}})},t.prototype._setResizableClasses=function(r){r&&this.enabled()?this.addClass("y-resizable"):this.removeClass("y-resizable")},t.prototype.xScale=function(r){if(r==null)return e.prototype.xScale.call(this);throw new Error("xScales cannot be set on an YDragBoxLayer")},t.prototype.xExtent=function(r){if(r==null)return e.prototype.xExtent.call(this);throw new Error("YDragBoxLayer has no xExtent")},t}(tVe.DragBoxLayer);uat.YDragBoxLayer=eVe});var Pot=H(_a=>{"use strict";Object.defineProperty(_a,"__esModule",{value:!0});var Ns=(de(),Ut(pe));Ns.__exportStar(qF(),_a);Ns.__exportStar(I$t(),_a);Ns.__exportStar(L$t(),_a);Ns.__exportStar(zot(),_a);Ns.__exportStar(Lot(),_a);Ns.__exportStar(R$t(),_a);Ns.__exportStar(Vot(),_a);Ns.__exportStar(N$t(),_a);Ns.__exportStar(aKt(),_a);Ns.__exportStar(Tot(),_a);Ns.__exportStar(sKt(),_a);Ns.__exportStar(lKt(),_a);Ns.__exportStar(cKt(),_a);Ns.__exportStar(uKt(),_a)});var fat=H(hat=>{"use strict";Object.defineProperty(hat,"__esModule",{value:!0});var rVe=(de(),Ut(pe)),nVe=Df(),iVe=function(e){rVe.__extends(t,e);function t(){return e.call(this,"path","arc fill")||this}return t.prototype._applyDefaultAttributes=function(r){r.style("stroke","none")},t}(nVe.SVGDrawer);hat.ArcSVGDrawer=iVe});var dat=H(pat=>{"use strict";Object.defineProperty(pat,"__esModule",{value:!0});var oVe=(de(),Ut(pe)),aVe=Df(),sVe=function(e){oVe.__extends(t,e);function t(){return e.call(this,"path","arc outline")||this}return t.prototype._applyDefaultAttributes=function(r){r.style("fill","none")},t}(aVe.SVGDrawer);pat.ArcOutlineSVGDrawer=sVe});var mat=H(eB=>{"use strict";Object.defineProperty(eB,"__esModule",{value:!0});var lVe=(de(),Ut(pe)),tB=Fv(),cVe=Df(),uVe=function(e){lVe.__extends(t,e);function t(){return e.call(this,"path","area")||this}return t.prototype._applyDefaultAttributes=function(r){r.style("stroke","none")},t.prototype.getVisualPrimitiveAtIndex=function(r){return e.prototype.getVisualPrimitiveAtIndex.call(this,0)},t}(cVe.SVGDrawer);eB.AreaSVGDrawer=uVe;var hVe=["opacity","fill","fill-opacity"],fVe=["opacity","stroke","stroke-width"];function pVe(e,t){return function(r,n,i){var o=tB.resolveAttributes(i,hVe,n[0],0);tB.renderArea(r,e(),n[0],o);var a=tB.resolveAttributes(i,fVe,n[0],0);tB.renderLine(r,t(),n[0],a)}}eB.makeAreaCanvasDrawStep=pVe});var nB=H(rB=>{"use strict";Object.defineProperty(rB,"__esModule",{value:!0});var dVe=(de(),Ut(pe)),hKt=Fv(),mVe=Df(),gVe=function(e){dVe.__extends(t,e);function t(){return e.call(this,"path","line")||this}return t.prototype._applyDefaultAttributes=function(r){r.style("fill","none")},t.prototype.getVisualPrimitiveAtIndex=function(r){return e.prototype.getVisualPrimitiveAtIndex.call(this,0)},t}(mVe.SVGDrawer);rB.LineSVGDrawer=gVe;var _Ve=["opacity","stroke-opacity","stroke-width","stroke","stroke-dasharray"];function yVe(e){return function(t,r,n){var i=hKt.resolveAttributes(n,_Ve,r[0],0);hKt.renderLine(t,e(),r[0],i)}}rB.makeLineCanvasDrawStep=yVe});var oB=H(PS=>{"use strict";Object.defineProperty(PS,"__esModule",{value:!0});var fKt=(de(),Ut(pe)),iB=Fv(),vVe=Df(),xVe=function(e){fKt.__extends(t,e);function t(r){r===void 0&&(r="");var n=e.call(this,"rect","")||this;return n._rootClassName=r,n._root.classed(n._rootClassName,!0),n}return t}(vVe.SVGDrawer);PS.RectangleSVGDrawer=xVe;var bVe=iB.ContextStyleAttrs.concat(["x","y","width","height"]);PS.RectangleCanvasDrawStep=function(e,t,r){e.save();for(var n=t.length,i=0;i<n;i++){var o=t[i];if(o!=null){var a=iB.resolveAttributes(r,bVe,o,i);e.beginPath(),e.rect(a.x,a.y,a.width,a.height),iB.renderPathWithStyle(e,a)}}e.restore()};var wVe=function(e){fKt.__extends(t,e);function t(r){return e.call(this,r,PS.RectangleCanvasDrawStep)||this}return t}(iB.CanvasDrawer);PS.RectangleCanvasDrawer=wVe});var _at=H(gat=>{"use strict";Object.defineProperty(gat,"__esModule",{value:!0});var SVe=(de(),Ut(pe)),MVe=Df(),EVe=function(e){SVe.__extends(t,e);function t(){return e.call(this,"line","")||this}return t}(MVe.SVGDrawer);gat.SegmentSVGDrawer=EVe});var pKt=H(yat=>{"use strict";Object.defineProperty(yat,"__esModule",{value:!0});var TVe=function(){function e(t,r,n){n===void 0&&(n=window.devicePixelRatio),this.screenWidth=t,this.screenHeight=r,this.devicePixelRatio=n,this.pixelWidth=t*n,this.pixelHeight=r*n,this.canvas=document.createElement("canvas"),this.ctx=this.canvas.getContext("2d"),e.sizePixels(this.ctx,t,r,n)}return e.sizePixels=function(t,r,n,i){var o=t.canvas;o.width=r*i,o.height=n*i,o.style.width=r+"px",o.style.height=n+"px",t.setTransform(1,0,0,1,0,0),t.scale(i,i)},e.prototype.blit=function(t,r,n){r===void 0&&(r=0),n===void 0&&(n=0),t.drawImage(this.canvas,r,n,this.screenWidth,this.screenHeight)},e.prototype.blitCenter=function(t,r,n){r===void 0&&(r=0),n===void 0&&(n=0),this.blit(t,Math.floor(r-this.screenWidth/2),Math.floor(n-this.screenHeight/2))},e.prototype.resize=function(t,r,n){n===void 0&&(n=!1);var i=this.devicePixelRatio;return this.screenWidth=t,this.screenHeight=r,this.pixelWidth=t*i,this.pixelHeight=r*i,e.sizePixels(this.ctx,t,r,i),n&&this.ctx.translate(t/2,t/2),this},e.prototype.clear=function(t){var r=this,n=r.pixelWidth,i=r.pixelHeight,o=r.ctx;return o.save(),o.setTransform(1,0,0,1,0,0),t==null?o.clearRect(0,0,n,i):(o.fillStyle=t,o.fillRect(0,0,n,i)),o.restore(),this},e.prototype.getImageData=function(){return this.ctx.getImageData(0,0,this.pixelWidth,this.pixelHeight)},e}();yat.CanvasBuffer=TVe});var vat=H(aB=>{"use strict";Object.defineProperty(aB,"__esModule",{value:!0});var CVe=(de(),Ut(pe)),m4=Fv(),AVe=pKt(),PVe=Df(),IVe=function(e){CVe.__extends(t,e);function t(){return e.call(this,"path","symbol")||this}return t}(PVe.SVGDrawer);aB.SymbolSVGDrawer=IVe;var LVe=m4.ContextStyleAttrs.concat(["x","y"]);function kVe(e,t,r,n){var i=this;return function(o,a,s){for(var l=o.canvas,c=l.clientWidth,u=l.clientHeight,h=n===void 0?new AVe.CanvasBuffer(0,0):n,f=t(),p=r(),d=null,g=null,_=null,y=0;y<a.length;y++){var x=a[y];if(x!=null){var b=m4.resolveAttributes(s,LVe,x,y),S=p(x,y,e);if(!!RVe(c,u,b.x,b.y,S)){var C=NVe(d,b,m4.ContextStyleAttrs),P=f(x,y,i._dataset);if(!(C&&_==S&&g==P)){var k=m4.getStrokeWidth(b),O=S+k+1;(O>h.screenWidth||O>h.screenHeight)&&h.resize(O,O,!0),h.clear();var D=h.ctx;D.beginPath(),P(S).context(D)(null),D.closePath(),m4.renderPathWithStyle(D,b),g=P,_=S,d=b}h.blitCenter(o,b.x,b.y)}}}}}aB.makeSymbolCanvasDrawStep=kVe;function RVe(e,t,r,n,i){return r+i>=0&&r-i<=e&&n+i>=0&&n-i<=t}function NVe(e,t,r){if(e==null)return!1;for(var n=0;n<r.length;n++){var i=r[n];if(e[i]!=t[i])return!1}return!0}});var Bv=H(Dc=>{"use strict";Object.defineProperty(Dc,"__esModule",{value:!0});var Of=(de(),Ut(pe));Of.__exportStar(fat(),Dc);Of.__exportStar(dat(),Dc);Of.__exportStar(mat(),Dc);Of.__exportStar(Fv(),Dc);Of.__exportStar(Uu(),Dc);Of.__exportStar(nB(),Dc);Of.__exportStar(oB(),Dc);Of.__exportStar(_at(),Dc);Of.__exportStar(Df(),Dc);Of.__exportStar(vat(),Dc)});var Hv=H(bat=>{"use strict";Object.defineProperty(bat,"__esModule",{value:!0});var DVe=(de(),Ut(pe)),dKt=ks(),xat=Fe(),OVe=iat(),g4=rs(),zVe=function(e){DVe.__extends(t,e);function t(){var r=e.call(this)||this;return r._autoAdjustXScaleDomain=!1,r._autoAdjustYScaleDomain=!1,r._deferredRendering=!1,r._applyDeferredRenderingTransform=function(n,i,o,a){!r._isAnchored||(r._renderArea!=null&&r._renderArea.attr("transform","translate("+n+", "+i+") scale("+o+", "+a+")"),r._canvas!=null&&r._canvas.style("transform","translate("+n+"px, "+i+"px) scale("+o+", "+a+")"))},r.addClass("xy-plot"),r._adjustYDomainOnChangeFromXCallback=function(n){return r._adjustYDomainOnChangeFromX()},r._adjustXDomainOnChangeFromYCallback=function(n){return r._adjustXDomainOnChangeFromY()},r._renderCallback=function(){if(r.deferredRendering()){var n=r.x()&&r.x().scale,i=r.y()&&r.y().scale;r._deferredRenderer.updateDomains(n,i)}else r.render()},r._deferredRenderer=new OVe.DeferredRenderer(function(){return r.render()},r._applyDeferredRenderingTransform),r}return t.prototype.render=function(){return this.deferredRendering()&&this._deferredRenderer.resetTransforms(),e.prototype.render.call(this)},t.prototype.deferredRendering=function(r){if(r==null)return this._deferredRendering;if(r){var n=this.x()&&this.x().scale,i=this.y()&&this.y().scale;this._deferredRenderer.setDomains(n,i)}return this._deferredRendering=r,this},t.prototype.x=function(r,n,i){if(r==null)return this._propertyBindings.get(t._X_KEY);this._bindProperty(t._X_KEY,r,n,i);var o=this.width();return n!=null&&o!=null&&n.range([0,o]),this._autoAdjustYScaleDomain&&this._updateYExtentsAndAutodomain(),this.render(),this},t.prototype.y=function(r,n,i){if(r==null)return this._propertyBindings.get(t._Y_KEY);this._bindProperty(t._Y_KEY,r,n,i);var o=this.height();return n!=null&&o!=null&&(n instanceof dKt.Category?n.range([0,o]):n.range([o,0])),this._autoAdjustXScaleDomain&&this._updateXExtentsAndAutodomain(),this.render(),this},t.prototype._filterForProperty=function(r){return r==="x"&&this._autoAdjustXScaleDomain?this._makeFilterByProperty("y"):(r==="y"||r==="y0")&&this._autoAdjustYScaleDomain?this._makeFilterByProperty("x"):null},t.prototype._makeFilterByProperty=function(r){var n=this._propertyBindings.get(r);if(n!=null){var i=n.accessor,o=n.scale;if(o!=null)return function(a,s,l){var c=o.range();return xat.Math.inRange(o.scale(i(a,s,l)),c[0],c[1])}}return null},t.prototype._uninstallScaleForKey=function(r,n){e.prototype._uninstallScaleForKey.call(this,r,n);var i=n===t._X_KEY?this._adjustYDomainOnChangeFromXCallback:this._adjustXDomainOnChangeFromYCallback;r.offUpdate(i)},t.prototype._installScaleForKey=function(r,n){e.prototype._installScaleForKey.call(this,r,n);var i=n===t._X_KEY?this._adjustYDomainOnChangeFromXCallback:this._adjustXDomainOnChangeFromYCallback;r.onUpdate(i)},t.prototype.destroy=function(){return e.prototype.destroy.call(this),this.x().scale&&this.x().scale.offUpdate(this._adjustYDomainOnChangeFromXCallback),this.y().scale&&this.y().scale.offUpdate(this._adjustXDomainOnChangeFromYCallback),this},t.prototype.autorangeMode=function(r){if(r==null)return this._autoAdjustXScaleDomain?"x":this._autoAdjustYScaleDomain?"y":"none";switch(r){case"x":this._autoAdjustXScaleDomain=!0,this._autoAdjustYScaleDomain=!1,this._adjustXDomainOnChangeFromY();break;case"y":this._autoAdjustXScaleDomain=!1,this._autoAdjustYScaleDomain=!0,this._adjustYDomainOnChangeFromX();break;case"none":this._autoAdjustXScaleDomain=!1,this._autoAdjustYScaleDomain=!1;break;default:throw new Error("Invalid scale name '"+r+"', must be 'x', 'y' or 'none'")}return this},t.prototype.computeLayout=function(r,n,i){e.prototype.computeLayout.call(this,r,n,i);var o=this.x(),a=o&&o.scale;a!=null&&a.range([0,this.width()]);var s=this.y(),l=s&&s.scale;return l!=null&&(l instanceof dKt.Category?l.range([0,this.height()]):l.range([this.height(),0])),this},t.prototype._updateXExtentsAndAutodomain=function(){var r=this.x().scale;r!=null&&r.autoDomain()},t.prototype._updateYExtentsAndAutodomain=function(){var r=this.y().scale;r!=null&&r.autoDomain()},t.prototype.showAllData=function(){return this._updateXExtentsAndAutodomain(),this._updateYExtentsAndAutodomain(),this},t.prototype._adjustYDomainOnChangeFromX=function(){!this._projectorsReady()||this._autoAdjustYScaleDomain&&this._updateYExtentsAndAutodomain()},t.prototype._adjustXDomainOnChangeFromY=function(){!this._projectorsReady()||this._autoAdjustXScaleDomain&&this._updateXExtentsAndAutodomain()},t.prototype._projectorsReady=function(){var r=this.x(),n=this.y();return r!=null&&r.accessor!=null&&n!=null&&n.accessor!=null},t.prototype._pixelPoint=function(r,n,i){var o=g4.Plot._scaledAccessor(this.x()),a=g4.Plot._scaledAccessor(this.y());return{x:o(r,n,i),y:a(r,n,i)}},t.prototype._getDataToDraw=function(){var r=this,n=e.prototype._getDataToDraw.call(this),i=this.attr("defined"),o=function(a,s,l){var c=g4.Plot._scaledAccessor(r.x())(a,s,l),u=g4.Plot._scaledAccessor(r.y())(a,s,l);return i&&i.accessor(a,s,l)===!1?!1:xat.Math.isValidNumber(c)&&xat.Math.isValidNumber(u)};return this.datasets().forEach(function(a){n.set(a,n.get(a).filter(function(s,l){return o(s,l,a)}))}),n},t._X_KEY="x",t._Y_KEY="y",t}(g4.Plot);bat.XYPlot=zVe});var Sat=H(lB=>{"use strict";Object.defineProperty(lB,"__esModule",{value:!0});var FVe=(de(),Ut(pe)),ya=(Er(),Ut(Mr)),BVe=Lf(),HVe=Bv(),VVe=Uu(),mKt=nB(),UVe=ks(),sB=vd(),Qg=Fe(),qVe=If(),wat=IS(),vl=rs(),GVe=Hv(),gKt={linear:ya.curveLinear,linearClosed:ya.curveLinearClosed,step:ya.curveStep,stepBefore:ya.curveStepBefore,stepAfter:ya.curveStepAfter,basis:ya.curveBasis,basisOpen:ya.curveBasisOpen,basisClosed:ya.curveBasisClosed,bundle:ya.curveBundle,cardinal:ya.curveCardinal,cardinalOpen:ya.curveCardinalOpen,cardinalClosed:ya.curveCardinalClosed,monotone:ya.curveMonotoneX};lB.CurveName=qVe.makeEnum(["linear","linearClosed","step","stepBefore","stepAfter","basis","basisOpen","basisClosed","bundle","cardinal","cardinalOpen","cardinalClosed","monotone"]);var WVe=function(e){FVe.__extends(t,e);function t(){var r=e.call(this)||this;r._curve="linear",r._autorangeSmooth=!1,r._croppedRenderingEnabled=!0,r._collapseDenseVerticalLinesEnabled=!1,r._downsamplingEnabled=!1,r.addClass("line-plot");var n=new BVe.Easing;return n.stepDuration(vl.Plot._ANIMATION_MAX_DURATION),n.easingMode("expInOut"),n.maxTotalDuration(vl.Plot._ANIMATION_MAX_DURATION),r.animator(wat.Animator.MAIN,n),r.attr("stroke",new UVe.Color().range()[0]),r.attr("stroke-width","2px"),r}return t.prototype.x=function(r,n,i){return r==null?e.prototype.x.call(this):(e.prototype.x.call(this,r,n,i),this._setScaleSnapping(),this)},t.prototype.y=function(r,n,i){return r==null?e.prototype.y.call(this):(e.prototype.y.call(this,r,n,i),this._setScaleSnapping(),this)},t.prototype.autorangeMode=function(r){return r==null?e.prototype.autorangeMode.call(this):(e.prototype.autorangeMode.call(this,r),this._setScaleSnapping(),this)},t.prototype.autorangeSmooth=function(r){return r==null?this._autorangeSmooth:(this._autorangeSmooth=r,this._setScaleSnapping(),this)},t.prototype._setScaleSnapping=function(){this.autorangeMode()==="x"&&this.x()&&this.x().scale&&this.x().scale instanceof sB.QuantitativeScale&&this.x().scale.snappingDomainEnabled(!this.autorangeSmooth()),this.autorangeMode()==="y"&&this.y()&&this.y().scale&&this.y().scale instanceof sB.QuantitativeScale&&this.y().scale.snappingDomainEnabled(!this.autorangeSmooth())},t.prototype.curve=function(r){return r==null?this._curve:(this._curve=r,this.render(),this)},t.prototype.downsamplingEnabled=function(r){return r==null?this._downsamplingEnabled:(this._downsamplingEnabled=r,this)},t.prototype.croppedRenderingEnabled=function(r){return r==null?this._croppedRenderingEnabled:(this._croppedRenderingEnabled=r,this.render(),this)},t.prototype.collapseDenseLinesEnabled=function(r){return r==null?this._collapseDenseVerticalLinesEnabled:(this._collapseDenseVerticalLinesEnabled=r,this.render(),this)},t.prototype._createDrawer=function(r){var n=this;return new VVe.ProxyDrawer(function(){return new mKt.LineSVGDrawer},function(i){return new HVe.CanvasDrawer(i,mKt.makeLineCanvasDrawStep(function(){return n._d3LineFactory(r)}))})},t.prototype.getExtentsForProperty=function(r){var n=e.prototype.getExtentsForProperty.call(this,r);if(!this._autorangeSmooth||this.autorangeMode()!==r||this.autorangeMode()!=="x"&&this.autorangeMode()!=="y")return n;var i=this._getEdgeIntersectionPoints(),o;return this.autorangeMode()==="y"?o=i.left.concat(i.right).map(function(a){return a.y}):o=i.top.concat(i.bottom).map(function(a){return a.x}),n.map(function(a){return ya.extent(ya.merge([a,o]))})},t.prototype._getEdgeIntersectionPoints=function(){var r=this;if(!(this.y().scale instanceof sB.QuantitativeScale&&this.x().scale instanceof sB.QuantitativeScale))return{left:[],right:[],top:[],bottom:[]};var n=this.y().scale,i=this.x().scale,o={left:[],right:[],top:[],bottom:[]},a=i.scale(i.domain()[0]),s=i.scale(i.domain()[1]),l=n.scale(n.domain()[0]),c=n.scale(n.domain()[1]);return this.datasets().forEach(function(u){for(var h=u.data(),f,p,d,g,_,y,x,b,S=1;S<h.length;S++)_=x||i.scale(r.x().accessor(h[S-1],S-1,u)),y=b||n.scale(r.y().accessor(h[S-1],S-1,u)),x=i.scale(r.x().accessor(h[S],S,u)),b=n.scale(r.y().accessor(h[S],S,u)),_<a==a<=x&&(f=a-_,p=x-_,g=b-y,d=f*g/p,o.left.push({x:a,y:n.invert(y+d)})),_<s==s<=x&&(f=s-_,p=x-_,g=b-y,d=f*g/p,o.right.push({x:s,y:n.invert(y+d)})),y<c==c<=b&&(p=x-_,d=c-y,g=b-y,f=d*p/g,o.top.push({x:i.invert(_+f),y:c})),y<l==l<=b&&(p=x-_,d=l-y,g=b-y,f=d*p/g,o.bottom.push({x:i.invert(_+f),y:l}))}),o},t.prototype._getResetYFunction=function(){var r=this.y().scale.domain(),n=Math.max(r[0],r[1]),i=Math.min(r[0],r[1]),o=n<0&&n||i>0&&i||0,a=this.y().scale.scale(o);return function(s,l,c){return a}},t.prototype._generateDrawSteps=function(){var r=[];if(this._animateOnNextRender()){var n=this._getAttrToProjector();n.d=this._constructLineProjector(vl.Plot._scaledAccessor(this.x()),this._getResetYFunction()),r.push({attrToProjector:n,animator:this._getAnimator(wat.Animator.RESET)})}return r.push({attrToProjector:this._getAttrToProjector(),animator:this._getAnimator(wat.Animator.MAIN)}),r},t.prototype._generateAttrToProjector=function(){var r=e.prototype._generateAttrToProjector.call(this);return Object.keys(r).forEach(function(n){if(n!=="d"){var i=r[n];r[n]=function(o,a,s){return o.length>0?i(o[0],a,s):null}}}),r},t.prototype.entitiesAt=function(r){var n=this.entityNearestByXThenY(r);return n!=null?[n]:[]},t.prototype.entityNearestByXThenY=function(r){for(var n=1/0,i=1/0,o,a=this.bounds(),s=this.entities(),l=s.length,c=0;c<l;c++){var u=s[c];if(!!Qg.Math.within(u.position,a)){var h=Math.abs(r.x-u.position.x),f=Math.abs(r.y-u.position.y);(h<n||h===n&&f<i)&&(o=u,n=h,i=f)}}return o},t.prototype._propertyProjectors=function(){var r=e.prototype._propertyProjectors.call(this);return r.d=this._constructLineProjector(vl.Plot._scaledAccessor(this.x()),vl.Plot._scaledAccessor(this.y())),r},t.prototype._constructLineProjector=function(r,n){var i=this;return function(o,a,s){return i._d3LineFactory(s,r,n)(o)}},t.prototype._d3LineFactory=function(r,n,i){n===void 0&&(n=vl.Plot._scaledAccessor(this.x())),i===void 0&&(i=vl.Plot._scaledAccessor(this.y()));var o=function(a,s,l){var c=n(a,s,l),u=i(a,s,l);return Qg.Math.isValidNumber(c)&&Qg.Math.isValidNumber(u)};return ya.line().x(function(a,s){return n(a,s,r)}).y(function(a,s){return i(a,s,r)}).curve(this._getCurveFactory()).defined(function(a,s){return o(a,s,r)})},t.prototype._getCurveFactory=function(){var r=this.curve();if(typeof r=="string"){var n=gKt[r];return n==null?gKt.linear:n}else return r},t.prototype._getDataToDraw=function(){var r=this,n=new Qg.Map;return this.datasets().forEach(function(i){var o=i.data();if(!r._croppedRenderingEnabled&&!r._downsamplingEnabled){n.set(i,[o]);return}for(var a=[],s=o.length,l=0;l<s;l++)a[l]=l;r._croppedRenderingEnabled&&(a=r._filterCroppedRendering(i,a)),r._downsamplingEnabled&&(a=r._filterDownsampling(i,a)),r._collapseDenseVerticalLinesEnabled&&(a=r._filterDenseLines(i,a));for(var c=[],u=a.length,l=0;l<u;l++){var h=a[l];c[l]=o[h]}n.set(i,[c])}),n},t.prototype._filterCroppedRendering=function(r,n){for(var i=this,o=vl.Plot._scaledAccessor(this.x()),a=vl.Plot._scaledAccessor(this.y()),s=r.data(),l=[],c=function(x,b){return Qg.Math.inRange(x,0,i.width())&&Qg.Math.inRange(b,0,i.height())},u=0;u<n.length;u++){var h=o(s[n[u]],n[u],r),f=a(s[n[u]],n[u],r),p=c(h,f);if(!p&&n[u-1]!=null&&s[n[u-1]]!=null){var d=o(s[n[u-1]],n[u-1],r),g=a(s[n[u-1]],n[u-1],r);p=p||c(d,g)}if(!p&&n[u+1]!=null&&s[n[u+1]]!=null){var _=o(s[n[u+1]],n[u+1],r),y=a(s[n[u+1]],n[u+1],r);p=p||c(_,y)}p&&l.push(n[u])}return l},t.prototype._filterDownsampling=function(r,n){if(n.length===0)return[];for(var i=r.data(),o=vl.Plot._scaledAccessor(this.x()),a=vl.Plot._scaledAccessor(this.y()),s=[n[0]],l=function(k,O){var D=o(i[n[k]],n[k],r),B=a(i[n[k]],n[k],r),I=o(i[n[k+1]],n[k+1],r),L=a(i[n[k+1]],n[k+1],r);if(O===1/0)return Math.floor(D)===Math.floor(I);var R=B+(I-D)*O;return Math.floor(L)===Math.floor(R)},c=0;c<n.length-1;){for(var u=n[c],h=o(i[n[c]],n[c],r),f=a(i[n[c]],n[c],r),p=o(i[n[c+1]],n[c+1],r),d=a(i[n[c+1]],n[c+1],r),g=Math.floor(h)===Math.floor(p)?1/0:(d-f)/(p-h),_=n[c],y=g===1/0?f:h,x=_,b=y,S=!0;c<n.length-1&&(S||l(c,g));){c++,S=!1;var C=g===1/0?a(i[n[c]],n[c],r):o(i[n[c]],n[c],r);C>b&&(b=C,x=n[c]),C<y&&(y=C,_=n[c])}var P=n[c];_!==u&&s.push(_),x!==_&&x!==u&&s.push(x),P!==u&&P!==_&&P!==x&&s.push(P)}return s},t.prototype._filterDenseLines=function(r,n){if(n.length===0)return[];var i=r.data(),o=vl.Plot._scaledAccessor(this.x()),a=vl.Plot._scaledAccessor(this.y()),s=function(c){return o(i[c],c,r)},l=function(c){return a(i[c],c,r)};return this._bucketByX(r,n,s,l)},t.prototype._bucketByX=function(r,n,i,o){for(var a=[],s=r.data(),l=null,c=n.length,u=0;u<=c;++u){var h=n[u];if(s[h]!=null){var f=Math.floor(i(h)),p=o(h);l==null?l=new Qg.Bucket(h,f,p):l.isInBucket(f)?l.addToBucket(p,h):(a.push.apply(a,l.getUniqueIndices()),l=new Qg.Bucket(h,f,p))}}return l!=null&&a.push.apply(a,l.getUniqueIndices()),a},t}(GVe.XYPlot);lB.Line=WVe});var Tat=H(Eat=>{"use strict";Object.defineProperty(Eat,"__esModule",{value:!0});var YVe=(de(),Ut(pe)),cB=(Er(),Ut(Mr)),jVe=ks(),_4=Fe(),Mat=Bv(),_Kt=mat(),XVe=Uu(),yKt=nB(),uB=IS(),$Ve=Sat(),Ds=rs(),KVe=function(e){YVe.__extends(t,e);function t(){var r=e.call(this)||this;return r.addClass("area-plot"),r.y0(0),r.attr("fill-opacity",.25),r.attr("fill",new jVe.Color().range()[0]),r._lineDrawers=new _4.Map,r}return t.prototype.y=function(r,n){if(r==null)return e.prototype.y.call(this);if(n==null?e.prototype.y.call(this,r):e.prototype.y.call(this,r,n),n!=null){var i=this.y0().accessor;i!=null&&this._bindProperty(t._Y0_KEY,i,n),this._updateYScale()}return this},t.prototype.y0=function(r){if(r==null)return this._propertyBindings.get(t._Y0_KEY);var n=this.y(),i=n&&n.scale;return this._bindProperty(t._Y0_KEY,r,i),this._updateYScale(),this.render(),this},t.prototype._onDatasetUpdate=function(){e.prototype._onDatasetUpdate.call(this),this._updateYScale()},t.prototype._addDataset=function(r){var n=this;return this._lineDrawers.set(r,new Mat.ProxyDrawer(function(){return new yKt.LineSVGDrawer},function(i){return new Mat.CanvasDrawer(i,yKt.makeLineCanvasDrawStep(function(){var o=Ds.Plot._scaledAccessor(n.x()),a=Ds.Plot._scaledAccessor(n.y());return n._d3LineFactory(r,o,a)}))})),e.prototype._addDataset.call(this,r),this},t.prototype._createNodesForDataset=function(r){e.prototype._createNodesForDataset.call(this,r);var n=this._lineDrawers.get(r);return this.renderer()==="svg"?n.useSVG(this._renderArea):n.useCanvas(this._canvas),n},t.prototype._removeDatasetNodes=function(r){e.prototype._removeDatasetNodes.call(this,r),this._lineDrawers.get(r).remove()},t.prototype._additionalPaint=function(){var r=this,n=this._generateLineDrawSteps(),i=this._getDataToDraw();this.datasets().forEach(function(o){var a=Ds.Plot.applyDrawSteps(n,o);r._lineDrawers.get(o).draw(i.get(o),a)})},t.prototype._generateLineDrawSteps=function(){var r=[];if(this._animateOnNextRender()){var n=this._generateLineAttrToProjector();n.d=this._constructLineProjector(Ds.Plot._scaledAccessor(this.x()),this._getResetYFunction()),r.push({attrToProjector:n,animator:this._getAnimator(uB.Animator.RESET)})}return r.push({attrToProjector:this._generateLineAttrToProjector(),animator:this._getAnimator(uB.Animator.MAIN)}),r},t.prototype._generateLineAttrToProjector=function(){var r=this._getAttrToProjector();return r.d=this._constructLineProjector(Ds.Plot._scaledAccessor(this.x()),Ds.Plot._scaledAccessor(this.y())),r},t.prototype._createDrawer=function(r){var n=this;return new XVe.ProxyDrawer(function(){return new _Kt.AreaSVGDrawer},function(i){return new Mat.CanvasDrawer(i,_Kt.makeAreaCanvasDrawStep(function(){var o=n._coordinateProjectors(),a=o[0],s=o[1],l=o[2],c=n._createDefinedProjector(a,s);return n._createAreaGenerator(a,s,l,c,r)},function(){var o=n._coordinateProjectors(),a=o[0],s=o[1],l=n._createDefinedProjector(a,s);return n._createTopLineGenerator(a,s,l,r)}))})},t.prototype._generateDrawSteps=function(){var r=[];if(this._animateOnNextRender()){var n=this._getAttrToProjector();n.d=this._constructAreaProjector(Ds.Plot._scaledAccessor(this.x()),this._getResetYFunction(),Ds.Plot._scaledAccessor(this.y0())),r.push({attrToProjector:n,animator:this._getAnimator(uB.Animator.RESET)})}return r.push({attrToProjector:this._getAttrToProjector(),animator:this._getAnimator(uB.Animator.MAIN)}),r},t.prototype._updateYScale=function(){var r=this.getExtentsForProperty("y0"),n=_4.Array.flatten(r),i=_4.Array.uniq(n),o=i.length===1?i[0]:null,a=this.y(),s=a&&a.scale;s!=null&&(this._constantBaselineValueProvider!=null&&(s.removePaddingExceptionsProvider(this._constantBaselineValueProvider),this._constantBaselineValueProvider=null),o!=null&&(this._constantBaselineValueProvider=function(){return[o]},s.addPaddingExceptionsProvider(this._constantBaselineValueProvider)))},t.prototype._getResetYFunction=function(){return Ds.Plot._scaledAccessor(this.y0())},t.prototype._coordinateProjectors=function(){return[Ds.Plot._scaledAccessor(this.x()),Ds.Plot._scaledAccessor(this.y()),Ds.Plot._scaledAccessor(this.y0())]},t.prototype._propertyProjectors=function(){var r=e.prototype._propertyProjectors.call(this),n=this._coordinateProjectors(),i=n[0],o=n[1],a=n[2];return r.d=this._constructAreaProjector(i,o,a),r},t.prototype.selections=function(r){var n=this;if(r===void 0&&(r=this.datasets()),this.renderer()==="canvas")return cB.selectAll();var i=e.prototype.selections.call(this,r).nodes(),o=r.map(function(a){return n._lineDrawers.get(a)}).filter(function(a){return a!=null});return o.forEach(function(a){return i.push.apply(i,a.getVisualPrimitives())}),cB.selectAll(i)},t.prototype._constructAreaProjector=function(r,n,i){var o=this,a=this._createDefinedProjector(Ds.Plot._scaledAccessor(this.x()),Ds.Plot._scaledAccessor(this.y()));return function(s,l,c){var u=o._createAreaGenerator(r,n,i,a,c);return u(s)}},t.prototype._createDefinedProjector=function(r,n){return function(i,o,a){var s=r(i,o,a),l=n(i,o,a);return _4.Math.isValidNumber(s)&&_4.Math.isValidNumber(l)}},t.prototype._createAreaGenerator=function(r,n,i,o,a){var s=this._getCurveFactory(),l=cB.area().x(function(c,u){return r(c,u,a)}).y1(function(c,u){return n(c,u,a)}).y0(function(c,u){return i(c,u,a)}).curve(s).defined(function(c,u){return o(c,u,a)});return l},t.prototype._createTopLineGenerator=function(r,n,i,o){var a=this._getCurveFactory(),s=cB.line().x(function(l,c){return r(l,c,o)}).y(function(l,c){return n(l,c,o)}).curve(a).defined(function(l,c){return i(l,c,o)});return s},t._Y0_KEY="y0",t}($Ve.Line);Eat.Area=KVe});var y4=H(Gu=>{"use strict";Object.defineProperty(Gu,"__esModule",{value:!0});var ZVe=(de(),Ut(pe)),Aat=(Er(),Ut(Mr)),Cat=_l(),JVe=Lf(),QVe=Bu(),tUe=Bv(),eUe=Uu(),rUe=oB(),nUe=CS(),Pat=ks(),vKt=vd(),xl=Fe(),Lat=If(),xKt=IS(),hB=rs(),iUe=Hv();Gu.BarOrientation=Lat.makeEnum(["vertical","horizontal"]);Gu.LabelsPosition=Lat.makeEnum(["start","middle","end","outside"]);Gu.BarAlignment=Lat.makeEnum(["start","middle","end"]);var Iat=function(e){ZVe.__extends(t,e);function t(r){r===void 0&&(r="vertical");var n=e.call(this)||this;if(n._labelFormatter=QVe.identity(),n._labelsEnabled=!1,n._labelsPosition=Gu.LabelsPosition.end,n._hideBarsIfAnyAreTooWide=!0,n._barAlignment="middle",n._computeBarPixelThickness=nUe.memoize(oUe),n._fixedBarPixelThickness=!0,n.addClass("bar-plot"),r!=="vertical"&&r!=="horizontal")throw new Error(r+" is not a valid orientation for Plots.Bar");return n._isVertical=r==="vertical",n.animator("baseline",new JVe.Null),n.attr("fill",new Pat.Color().range()[0]),n.attr(t._BAR_THICKNESS_KEY,function(){return n._barPixelThickness()}),n._labelConfig=new xl.Map,n._baselineValueProvider=function(){return[n.baselineValue()]},n}return t.prototype.computeLayout=function(r,n,i){return e.prototype.computeLayout.call(this,r,n,i),this._updateExtents(),this},t.prototype.x=function(r,n){return r==null?e.prototype.x.call(this):(n==null?e.prototype.x.call(this,r):e.prototype.x.call(this,r,n),this._updateThicknessAttr(),this._updateLengthScale(),this)},t.prototype.y=function(r,n){return r==null?e.prototype.y.call(this):(n==null?e.prototype.y.call(this,r):e.prototype.y.call(this,r,n),this._updateLengthScale(),this)},t.prototype.length=function(){return this._isVertical?this.y():this.x()},t.prototype.position=function(){return this._isVertical?this.x():this.y()},t.prototype.barEnd=function(r){if(r==null)return this._propertyBindings.get(t._BAR_END_KEY);var n=this.position(),i=n&&n.scale;return this._bindProperty(t._BAR_END_KEY,r,i),this._updateThicknessAttr(),this._updateLengthScale(),this.render(),this},t.prototype.barAlignment=function(r){return r==null?this._barAlignment:(this._barAlignment=r,this._clearAttrToProjectorCache(),this.render(),this)},t.prototype.orientation=function(){return this._isVertical?"vertical":"horizontal"},t.prototype._createDrawer=function(){return new eUe.ProxyDrawer(function(){return new rUe.RectangleSVGDrawer(t._BAR_AREA_CLASS)},function(r){return new tUe.RectangleCanvasDrawer(r)})},t.prototype._setup=function(){e.prototype._setup.call(this),this._baseline=this._renderArea.append("line").classed("baseline",!0)},t.prototype.baselineValue=function(r){if(r==null){if(this._baselineValue!=null)return this._baselineValue;if(!this._projectorsReady())return 0;var n=this.length().scale;return n&&n instanceof Pat.Time?new Date(0):0}return this._baselineValue=r,this._updateLengthScale(),this._clearAttrToProjectorCache(),this.render(),this},t.prototype.addDataset=function(r){return e.prototype.addDataset.call(this,r),this},t.prototype._addDataset=function(r){return e.prototype._addDataset.call(this,r),this},t.prototype.removeDataset=function(r){return e.prototype.removeDataset.call(this,r),this},t.prototype._removeDataset=function(r){return e.prototype._removeDataset.call(this,r),this},t.prototype.datasets=function(r){return r==null?e.prototype.datasets.call(this):(e.prototype.datasets.call(this,r),this)},t.prototype.labelsEnabled=function(r,n){return r==null?this._labelsEnabled:(this._labelsEnabled=r,n!=null&&(this._labelsPosition=n),this._clearAttrToProjectorCache(),this.render(),this)},t.prototype.labelFormatter=function(r){return r==null?this._labelFormatter:(this._labelFormatter=r,this._clearAttrToProjectorCache(),this.render(),this)},t.prototype._createNodesForDataset=function(r){var n=e.prototype._createNodesForDataset.call(this,r),i=this._renderArea.append("g").classed(t._LABEL_AREA_CLASS,!0),o=new Cat.SvgContext(i.node()),a=new Cat.CacheMeasurer(o),s=new Cat.Writer(a,o);return this._labelConfig.set(r,{labelArea:i,measurer:a,writer:s}),n},t.prototype._removeDatasetNodes=function(r){e.prototype._removeDatasetNodes.call(this,r);var n=this._labelConfig.get(r);n!=null&&(n.labelArea.remove(),this._labelConfig.delete(r))},t.prototype.entityNearest=function(r){var n=this,i=function(){var o=n._isVertical?n._getEntityStore().entityNearestX(r):n._getEntityStore().entityNearestY(r);return o===void 0?void 0:n._lightweightPlotEntityToPlotEntity(o)};return this._fixedBarPixelThickness?this._computeBarPixelThickness.doLocked(i):i()},t.prototype.entitiesAt=function(r){var n=this,i=function(){return n._entitiesIntersecting(r.x,r.y)};return this._fixedBarPixelThickness?this._computeBarPixelThickness.doLocked(i):i()},t.prototype.entitiesInBounds=function(r){var n=this,i=function(){return e.prototype.entitiesInBounds.call(n,r)};return this._fixedBarPixelThickness?this._computeBarPixelThickness.doLocked(i):i()},t.prototype.entitiesInXBounds=function(r){var n=this,i=function(){return e.prototype.entitiesInXBounds.call(n,r)};return this._fixedBarPixelThickness?this._computeBarPixelThickness.doLocked(i):i()},t.prototype.entitiesInYBounds=function(r){var n=this,i=function(){return e.prototype.entitiesInYBounds.call(n,r)};return this._fixedBarPixelThickness?this._computeBarPixelThickness.doLocked(i):i()},t.prototype._entitiesIntersecting=function(r,n){for(var i=[],o=this._getEntityStore().entities(),a=o.length,s=0;s<a;s++){var l=o[s];xl.DOM.intersectsBBox(r,n,this._entityBounds(l))&&i.push(this._lightweightPlotEntityToPlotEntity(l))}return i},t.prototype._updateLengthScale=function(){if(!!this._projectorsReady()){var r=this.length().scale;r instanceof vKt.QuantitativeScale&&(r.addPaddingExceptionsProvider(this._baselineValueProvider),r.addIncludedValuesProvider(this._baselineValueProvider))}},t.prototype.renderImmediately=function(){var r=this;return this._barPixelThickness(),this._computeBarPixelThickness.doLocked(function(){return e.prototype.renderImmediately.call(r)})},t.prototype._additionalPaint=function(r){var n=this,i=this.length().scale,o=i.scale(this.baselineValue()),a={x1:this._isVertical?0:o,y1:this._isVertical?o:0,x2:this._isVertical?this.width():o,y2:this._isVertical?o:this.height()};this._getAnimator("baseline").animate(this._baseline,a),this.datasets().forEach(function(s){return n._labelConfig.get(s).labelArea.selectAll("g").remove()}),this._labelsEnabled&&xl.Window.setTimeout(function(){return n._drawLabels()},r)},t.prototype.getExtentsForProperty=function(r){var n=this,i=e.prototype.getExtentsForProperty.call(this,r),o;if(r==="x"&&this._isVertical)o=this.x();else if(r==="y"&&!this._isVertical)o=this.y();else return i;if(!(o&&o.scale&&o.scale instanceof vKt.QuantitativeScale))return i;var a=o.scale,s=this._barPixelThickness();return i=i.map(function(l){return Aat.extent([a.invert(n._getPositionAttr(a.scale(l[0]),s)),a.invert(n._getPositionAttr(a.scale(l[0]),s)+s),a.invert(n._getPositionAttr(a.scale(l[1]),s)),a.invert(n._getPositionAttr(a.scale(l[1]),s)+s)])}),i},t.prototype._getPositionAttr=function(r,n){switch(this._isVertical||(r-=n,n*=-1),this._barAlignment){case"start":return r;case"end":return r-n;case"middle":default:return r-n/2}},t.prototype._drawLabels=function(){var r=this,n=this._getDataToDraw(),i=this._getAttrToProjector(),o=this.datasets().some(function(a){return n.get(a).some(function(s,l){return s==null?!1:r._drawLabel(s,l,a,i)})});this._hideBarsIfAnyAreTooWide&&o&&this.datasets().forEach(function(a){return r._labelConfig.get(a).labelArea.selectAll("g").remove()})},t.prototype._drawLabel=function(r,n,i,o){var a=this._labelConfig.get(i),s=a.labelArea,l=a.measurer,c=a.writer,u=this.length().accessor,h=u(r,n,i),f=this.length().scale,p=f!=null?f.scale(h):h,d=f!=null?f.scale(this.baselineValue()):this.baselineValue(),g={x:o.x(r,n,i),y:o.y(r,n,i)},_={width:o.width(r,n,i),height:o.height(r,n,i)},y=this._labelFormatter(h,r,n,i),x=l.measure(y),b=this._shouldShowLabelOnBar(g,_,x),S=this._isVertical?p<=d:p<d,C=this._calculateLabelProperties(g,_,x,b,S),P=C.containerDimensions,k=C.labelContainerOrigin,O=C.labelOrigin,D=C.alignment,B=o.fill(r,n,i),I=this._createLabelContainer(s,k,O,x,b,B),L={xAlign:D.x,yAlign:D.y};c.write(y,P.width,P.height,L,I.node());var R=this._isVertical?_.width<x.width:_.height<x.height;return R},t.prototype._shouldShowLabelOnBar=function(r,n,i){if(this._labelsPosition===Gu.LabelsPosition.outside)return!1;var o=this._isVertical?r.y:r.x,a=this._isVertical?n.height:n.width,s=this._isVertical?this.height():this.width(),l=this._isVertical?i.height:i.width,c=o+a,u=a;return c>s?u=s-o:o<0&&(u=c),l+t._LABEL_MARGIN_INSIDE_BAR<=u},t.prototype._calculateLabelProperties=function(r,n,i,o,a){var s=this,l=this._isVertical?r.y:r.x,c=this._isVertical?n.height:n.width,u=this._isVertical?i.height:i.width,h="center",f=c,p=l,d=l,g=function(_){switch(_){case"topLeft":h=s._isVertical?"top":"left",p+=t._LABEL_MARGIN_INSIDE_BAR,d+=t._LABEL_MARGIN_INSIDE_BAR;return;case"center":d+=(c+u)/2;return;case"bottomRight":h=s._isVertical?"bottom":"right",p-=t._LABEL_MARGIN_INSIDE_BAR,d+=f-t._LABEL_MARGIN_INSIDE_BAR-u;return}};if(o)switch(this._labelsPosition){case Gu.LabelsPosition.start:g(a?"bottomRight":"topLeft");break;case Gu.LabelsPosition.middle:g("center");break;case Gu.LabelsPosition.end:g(a?"topLeft":"bottomRight");break}else a?(h=this._isVertical?"top":"left",f=c+t._LABEL_MARGIN_INSIDE_BAR+u,p-=t._LABEL_MARGIN_INSIDE_BAR+u,d-=t._LABEL_MARGIN_INSIDE_BAR+u):(h=this._isVertical?"bottom":"right",f=c+t._LABEL_MARGIN_INSIDE_BAR+u,d+=c+t._LABEL_MARGIN_INSIDE_BAR);return{containerDimensions:{width:this._isVertical?n.width:f,height:this._isVertical?f:n.height},labelContainerOrigin:{x:this._isVertical?r.x:p,y:this._isVertical?p:r.y},labelOrigin:{x:this._isVertical?r.x+n.width/2-i.width/2:d,y:this._isVertical?d:r.y+n.height/2-i.height/2},alignment:{x:this._isVertical?"center":h,y:this._isVertical?h:"center"}}},t.prototype._createLabelContainer=function(r,n,i,o,a,s){var l=r.append("g").attr("transform","translate("+n.x+", "+n.y+")");if(a){l.classed("on-bar-label",!0);var c=xl.Color.contrast("white",s)*1.6<xl.Color.contrast("black",s);l.classed(c?"dark-label":"light-label",!0)}else l.classed("off-bar-label",!0);return l},t.prototype._generateDrawSteps=function(){var r=[];if(this._animateOnNextRender()){var n=this._getAttrToProjector(),i=this.length().scale,o=i.scale(this.baselineValue()),a=this._isVertical?"y":"x",s=this._isVertical?"height":"width";n[a]=function(){return o},n[s]=function(){return 0},r.push({attrToProjector:n,animator:this._getAnimator(xKt.Animator.RESET)})}return r.push({attrToProjector:this._getAttrToProjector(),animator:this._getAnimator(xKt.Animator.MAIN)}),r},t.prototype._generateAttrToProjector=function(){var r=this,n=e.prototype._generateAttrToProjector.call(this),i=this.length().scale,o=i.scale(this.baselineValue()),a=this._isVertical?"y":"x",s=this._isVertical?"x":"y",l=hB.Plot._scaledAccessor(this.position()),c=hB.Plot._scaledAccessor(this.length()),u=function(d,g,_){return Math.abs(o-c(d,g,_))},h=n[t._BAR_THICKNESS_KEY],f=n.gap,p=f==null?h:function(d,g,_){var y=h(d,g,_);return y<t._BAR_GAPLESS_THRESHOLD_PX?y:y-f(d,g,_)};return n.width=this._isVertical?p:u,n.height=this._isVertical?u:p,n[a]=function(d,g,_){var y=c(d,g,_);return y>o?o:y},n[s]=function(d,g,_){return r._getPositionAttr(l(d,g,_),h(d,g,_))},n},t.prototype._updateThicknessAttr=function(){var r=this,n=this.position(),i=this.barEnd();n!=null&&i!=null?(this._fixedBarPixelThickness=!1,this.attr(t._BAR_THICKNESS_KEY,function(o,a,s){var l=n.accessor(o,a,s),c=i.accessor(o,a,s);return l=n.scale?n.scale.scale(l):l,c=i.scale?i.scale.scale(c):c,Math.abs(c-l)})):(this._fixedBarPixelThickness=!0,this.attr(t._BAR_THICKNESS_KEY,function(){return r._barPixelThickness()}))},t.prototype._barPixelThickness=function(){return this._fixedBarPixelThickness&&this._projectorsReady()?this._computeBarPixelThickness(this.position(),this.datasets(),this._isVertical?this.width():this.height()):0},t.prototype.entities=function(r){if(r===void 0&&(r=this.datasets()),!this._projectorsReady())return[];var n=e.prototype.entities.call(this,r);return n},t.prototype._entityBounds=function(r){var n=r.datum,i=r.index,o=r.dataset;return this._pixelBounds(n,i,o)},t.prototype._pixelBounds=function(r,n,i){var o=this._getAttrToProjector();return{x:o.x(r,n,i),y:o.y(r,n,i),width:o.width(r,n,i),height:o.height(r,n,i)}},t.prototype._pixelPoint=function(r,n,i){var o=this._pixelBounds(r,n,i),a=(this._isVertical?hB.Plot._scaledAccessor(this.y()):hB.Plot._scaledAccessor(this.x()))(r,n,i),s=(this._isVertical?this.y().scale:this.x().scale).scale(this.baselineValue());return this._pixelPointBar(a,s,o)},t.prototype._pixelPointBar=function(r,n,i){var o,a;return this._isVertical?(o=i.x+i.width/2,a=r<=n?i.y:i.y+i.height):(o=r>=n?i.x+i.width:i.x,a=i.y+i.height/2),{x:o,y:a}},t.prototype._uninstallScaleForKey=function(r,n){e.prototype._uninstallScaleForKey.call(this,r,n)},t.prototype._getDataToDraw=function(){var r=this,n=new xl.Map,i=this._getAttrToProjector(),o=this.width(),a=this.height();return this.datasets().forEach(function(s){var l=s.data().map(function(c,u){var h=r._isDatumOnScreen(i,o,a,c,u,s);return h?c:null});n.set(s,l)}),n},t.prototype._isDatumOnScreen=function(r,n,i,o,a,s){var l=r.x(o,a,s),c=r.y(o,a,s),u=r.width(o,a,s),h=r.height(o,a,s),f=xl.Math.isValidNumber(l)&&xl.Math.isValidNumber(c)&&xl.Math.isValidNumber(u)&&xl.Math.isValidNumber(h);return f?xl.Math.boundsIntersects(l,c,u,h,0,0,n,i):!1},t.prototype.invalidateCache=function(){var r=this;e.prototype.invalidateCache.call(this),this.datasets().forEach(function(n){return r._labelConfig.get(n).measurer.reset()})},t._BAR_THICKNESS_RATIO=.95,t._BAR_GAPLESS_THRESHOLD_PX=3,t._SINGLE_BAR_DIMENSION_RATIO=.4,t._BAR_AREA_CLASS="bar-area",t._BAR_END_KEY="barEnd",t._BAR_THICKNESS_KEY="width",t._LABEL_AREA_CLASS="bar-label-text-area",t._LABEL_MARGIN_INSIDE_BAR=10,t}(iUe.XYPlot);Gu.Bar=Iat;function oUe(e,t,r){var n,i=e.scale;if(i instanceof Pat.Category)n=i.rangeBand();else{var o=e.accessor,a=Aat.set(xl.Array.flatten(t.map(function(c){return c.data().map(function(u,h){return o(u,h,c)}).filter(function(u){return u!=null}).map(function(u){return u.valueOf()})}))).values().map(function(c){return+c});a.sort(function(c,u){return c-u});var s=a.map(function(c){return i.scale(c)}),l=Aat.pairs(s);n=xl.Math.min(l,function(c,u){return Math.abs(c[1]-c[0])},r*Iat._SINGLE_BAR_DIMENSION_RATIO),n*=Iat._BAR_THICKNESS_RATIO}return n}});var wKt=H(kat=>{"use strict";Object.defineProperty(kat,"__esModule",{value:!0});var aUe=(de(),Ut(pe)),sUe=ks(),lUe=Fe(),bKt=y4(),cUe=rs(),uUe=function(e){aUe.__extends(t,e);function t(r){r===void 0&&(r="vertical");var n=e.call(this,r)||this;return n._clusterOffsets=new lUe.Map,n}return t.prototype._generateAttrToProjector=function(){var r=this,n=e.prototype._generateAttrToProjector.call(this),i=this._makeInnerScale(),o=function(l,c){return i.rangeBand()};n.width=this._isVertical?o:n.width,n.height=this._isVertical?n.height:o;var a=n.x,s=n.y;return n.x=this._isVertical?function(l,c,u){return a(l,c,u)+r._clusterOffsets.get(u)}:function(l,c,u){return a(l,c,u)},n.y=this._isVertical?function(l,c,u){return s(l,c,u)}:function(l,c,u){return s(l,c,u)+r._clusterOffsets.get(u)},n},t.prototype._updateClusterPosition=function(){var r=this,n=this._makeInnerScale();this.datasets().forEach(function(i,o){return r._clusterOffsets.set(i,n.scale(String(o))-n.rangeBand()/2)})},t.prototype._makeInnerScale=function(){var r=new sUe.Category;r.domain(this.datasets().map(function(i,o){return String(o)}));var n=cUe.Plot._scaledAccessor(this.attr(bKt.Bar._BAR_THICKNESS_KEY));return r.range([0,n(null,0,null)]),r},t.prototype._getDataToDraw=function(){return this._updateClusterPosition(),e.prototype._getDataToDraw.call(this)},t}(bKt.Bar);kat.ClusteredBar=uUe});var SKt=H(Nat=>{"use strict";Object.defineProperty(Nat,"__esModule",{value:!0});var hUe=(de(),Ut(pe)),v4=(Er(),Ut(Mr)),Rat=_l(),fUe=Lf(),pUe=Bu(),dUe=ks(),Vv=Fe(),mUe=fat(),gUe=dat(),_Ue=Uu(),yUe=AF(),Md=rs(),vUe=function(e){hUe.__extends(t,e);function t(){var r=e.call(this)||this;return r._startAngle=0,r._endAngle=2*Math.PI,r._labelFormatter=pUe.identity(),r._labelsEnabled=!1,r.innerRadius(0),r.outerRadius(function(){var n=r._pieCenter();return Math.min(Math.max(r.width()-n.x,n.x),Math.max(r.height()-n.y,n.y))}),r.addClass("pie-plot"),r.attr("fill",function(n,i){return String(i)},new dUe.Color),r._strokeDrawers=new Vv.Map,r}return t.prototype._setup=function(){var r=this;e.prototype._setup.call(this),this._strokeDrawers.forEach(function(n){return n.attachTo(r._renderArea)})},t.prototype.computeLayout=function(r,n,i){e.prototype.computeLayout.call(this,r,n,i);var o=this._pieCenter();this._renderArea.attr("transform","translate("+o.x+","+o.y+")");var a=Math.min(Math.max(this.width()-o.x,o.x),Math.max(this.height()-o.y,o.y));return this.innerRadius().scale!=null&&this.innerRadius().scale.range([0,a]),this.outerRadius().scale!=null&&this.outerRadius().scale.range([0,a]),this},t.prototype.addDataset=function(r){return e.prototype.addDataset.call(this,r),this},t.prototype._addDataset=function(r){if(this.datasets().length===1)return Vv.Window.warn("Only one dataset is supported in Pie plots"),this;this._updatePieAngles(),e.prototype._addDataset.call(this,r);var n=new gUe.ArcOutlineSVGDrawer;return this._isSetup&&n.attachTo(this._renderArea),this._strokeDrawers.set(r,n),this},t.prototype.removeDataset=function(r){return e.prototype.removeDataset.call(this,r),this},t.prototype._removeDatasetNodes=function(r){e.prototype._removeDatasetNodes.call(this,r),this._strokeDrawers.get(r).remove()},t.prototype._removeDataset=function(r){return e.prototype._removeDataset.call(this,r),this._strokeDrawers.delete(r),this._startAngles=[],this._endAngles=[],this},t.prototype.selections=function(r){var n=this;r===void 0&&(r=this.datasets());var i=e.prototype.selections.call(this,r).nodes();return r.forEach(function(o){var a=n._strokeDrawers.get(o);a!=null&&i.push.apply(i,a.getVisualPrimitives())}),v4.selectAll(i)},t.prototype._onDatasetUpdate=function(){e.prototype._onDatasetUpdate.call(this),this._updatePieAngles(),this.render()},t.prototype._createDrawer=function(){return new _Ue.ProxyDrawer(function(){return new mUe.ArcSVGDrawer},function(){return yUe.warn("canvas renderer is not supported on Pie Plot!"),null})},t.prototype.entities=function(r){var n=this;r===void 0&&(r=this.datasets());var i=e.prototype.entities.call(this,r);return i.map(function(o){o.position.x+=n.width()/2,o.position.y+=n.height()/2;var a=v4.select(n._strokeDrawers.get(o.dataset).getVisualPrimitiveAtIndex(o.index)),s=o;return s.strokeSelection=a,s})},t.prototype.sectorValue=function(r,n){return r==null?this._propertyBindings.get(t._SECTOR_VALUE_KEY):(this._bindProperty(t._SECTOR_VALUE_KEY,r,n),this._updatePieAngles(),this.render(),this)},t.prototype.innerRadius=function(r,n){return r==null?this._propertyBindings.get(t._INNER_RADIUS_KEY):(this._bindProperty(t._INNER_RADIUS_KEY,r,n),this.render(),this)},t.prototype.outerRadius=function(r,n){return r==null?this._propertyBindings.get(t._OUTER_RADIUS_KEY):(this._bindProperty(t._OUTER_RADIUS_KEY,r,n),this.render(),this)},t.prototype.startAngle=function(r){return r==null?this._startAngle:(this._startAngle=r,this._updatePieAngles(),this.render(),this)},t.prototype.endAngle=function(r){return r==null?this._endAngle:(this._endAngle=r,this._updatePieAngles(),this.render(),this)},t.prototype.labelsEnabled=function(r){return r==null?this._labelsEnabled:(this._labelsEnabled=r,this.render(),this)},t.prototype.labelFormatter=function(r){return r==null?this._labelFormatter:(this._labelFormatter=r,this.render(),this)},t.prototype.entitiesAt=function(r){var n={x:this.width()/2,y:this.height()/2},i={x:r.x-n.x,y:r.y-n.y},o=this._sliceIndexForPoint(i);return o==null?[]:[this.entities()[o]]},t.prototype._propertyProjectors=function(){var r=this,n=e.prototype._propertyProjectors.call(this),i=Md.Plot._scaledAccessor(this.innerRadius()),o=Md.Plot._scaledAccessor(this.outerRadius());return n.d=function(a,s,l){return v4.arc().innerRadius(i(a,s,l)).outerRadius(o(a,s,l)).startAngle(r._startAngles[s]).endAngle(r._endAngles[s])(a,s)},n},t.prototype._updatePieAngles=function(){if(this.sectorValue()!=null&&this.datasets().length!==0){var r=Md.Plot._scaledAccessor(this.sectorValue()),n=this.datasets()[0],i=this._getDataToDraw().get(n),o=v4.pie().sort(null).startAngle(this._startAngle).endAngle(this._endAngle).value(function(a,s){return r(a,s,n)})(i);this._startAngles=o.map(function(a){return a.startAngle}),this._endAngles=o.map(function(a){return a.endAngle})}},t.prototype._pieCenter=function(){var r=this._startAngle<this._endAngle?this._startAngle:this._endAngle,n=this._startAngle<this._endAngle?this._endAngle:this._startAngle,i=Math.sin(r),o=Math.cos(r),a=Math.sin(n),s=Math.cos(n),l,c,u,h;return i>=0&&a>=0?o>=0&&s>=0?(l=o,c=0,h=0,u=a):o<0&&s<0?(l=0,c=-s,h=0,u=i):o>=0&&s<0?(l=o,c=-s,h=0,u=i):o<0&&s>=0&&(l=1,c=1,h=1,u=Math.max(i,a)):i>=0&&a<0?o>=0&&s>=0?(l=Math.max(o,s),c=1,h=1,u=1):o<0&&s<0?(l=0,c=1,h=-a,u=i):o>=0&&s<0?(l=o,c=1,h=-a,u=1):o<0&&s>=0&&(l=s,c=1,h=1,u=i):i<0&&a>=0?o>=0&&s>=0?(l=1,c=0,h=-i,u=a):o<0&&s<0?(l=1,c=Math.max(-o,-s),h=1,u=1):o>=0&&s<0?(l=1,c=-s,h=-i,u=1):o<0&&s>=0&&(l=1,c=-o,h=1,u=a):i<0&&a<0&&(o>=0&&s>=0?(l=s,c=0,h=-i,u=0):o<0&&s<0?(l=0,c=-o,h=-a,u=0):o>=0&&s<0?(l=1,c=1,h=Math.max(o,-s),u=1):o<0&&s>=0&&(l=s,c=-o,h=1,u=0)),{x:h+u==0?0:h/(h+u)*this.width(),y:l+c==0?0:l/(l+c)*this.height()}},t.prototype._getDataToDraw=function(){var r=e.prototype._getDataToDraw.call(this);if(this.datasets().length===0)return r;var n=Md.Plot._scaledAccessor(this.sectorValue()),i=this.datasets()[0],o=r.get(i),a=o.filter(function(s,l){return t._isValidData(n(s,l,i))});return r.set(i,a),r},t._isValidData=function(r){return Vv.Math.isValidNumber(r)&&r>=0},t.prototype._pixelPoint=function(r,n,i){var o=Md.Plot._scaledAccessor(this.sectorValue());if(!t._isValidData(o(r,n,i)))return{x:NaN,y:NaN};var a=Md.Plot._scaledAccessor(this.innerRadius())(r,n,i),s=Md.Plot._scaledAccessor(this.outerRadius())(r,n,i),l=(a+s)/2,c=v4.pie().sort(null).value(function(p,d){var g=o(p,d,i);return t._isValidData(g)?g:0}).startAngle(this._startAngle).endAngle(this._endAngle)(i.data()),u=c[n].startAngle,h=c[n].endAngle,f=(u+h)/2;return{x:l*Math.sin(f),y:-l*Math.cos(f)}},t.prototype._additionalPaint=function(r){var n=this;this._renderArea.select(".label-area").remove(),this._labelsEnabled&&Vv.Window.setTimeout(function(){return n._drawLabels()},r);var i=this._generateStrokeDrawSteps(),o=this._getDataToDraw();this.datasets().forEach(function(a){var s=Md.Plot.applyDrawSteps(i,a);n._strokeDrawers.get(a).draw(o.get(a),s)})},t.prototype._generateStrokeDrawSteps=function(){var r=this._getAttrToProjector();return[{attrToProjector:r,animator:new fUe.Null}]},t.prototype._sliceIndexForPoint=function(r){var n=Math.sqrt(Math.pow(r.x,2)+Math.pow(r.y,2)),i=Math.acos(-r.y/n);r.x<0&&(i=Math.PI*2-i);for(var o,a=0;a<this._startAngles.length;a++)if(this._startAngles[a]<i&&this._endAngles[a]>i){o=a;break}if(o!==void 0){var s=this.datasets()[0],l=s.data()[o],c=this.innerRadius().accessor(l,o,s),u=this.outerRadius().accessor(l,o,s);if(n>c&&n<u)return o}return null},t.prototype._drawLabels=function(){for(var r=this,n=this._getAttrToProjector(),i=this._renderArea.append("g").classed("label-area",!0),o=new Rat.SvgContext(i.node()),a=new Rat.CacheMeasurer(o),s=new Rat.Writer(a,o),l=this.datasets()[0],c=this._getDataToDraw().get(l),u=c.length,h=function(d){var g=c[d],_=f.sectorValue().accessor(g,d,l);if(!Vv.Math.isValidNumber(_))return"continue";_=f._labelFormatter(_,g,d,l);var y=a.measure(_),x=(f._endAngles[d]+f._startAngles[d])/2,b=f.outerRadius().accessor(g,d,l);f.outerRadius().scale&&(b=f.outerRadius().scale.scale(b));var S=f.innerRadius().accessor(g,d,l);f.innerRadius().scale&&(S=f.innerRadius().scale.scale(S));var C=(b+S)/2,P=Math.sin(x)*C-y.width/2,k=-Math.cos(x)*C-y.height/2,O=[{x:P,y:k},{x:P,y:k+y.height},{x:P+y.width,y:k},{x:P+y.width,y:k+y.height}],D=O.every(function(z){return Math.abs(z.x)<=r.width()/2&&Math.abs(z.y)<=r.height()/2});if(D){var B=O.map(function(z){return r._sliceIndexForPoint(z)});D=B.every(function(z){return z===d})}var I=n.fill(g,d,l),L=Vv.Color.contrast("white",I)*1.6<Vv.Color.contrast("black",I),R=i.append("g").attr("transform","translate("+P+","+k+")"),F=L?"dark-label":"light-label";R.classed(F,!0),R.style("visibility",D?"inherit":"hidden"),s.write(_,y.width,y.height,{xAlign:"center",yAlign:"center"},R.node())},f=this,p=0;p<u;p++)h(p)},t._INNER_RADIUS_KEY="inner-radius",t._OUTER_RADIUS_KEY="outer-radius",t._SECTOR_VALUE_KEY="sector-value",t}(Md.Plot);Nat.Pie=vUe});var MKt=H(Oat=>{"use strict";Object.defineProperty(Oat,"__esModule",{value:!0});var xUe=(de(),Ut(pe)),bUe=(Er(),Ut(Mr)),Dat=_l(),wUe=Lf(),SUe=Bv(),MUe=Uu(),EUe=oB(),fB=ks(),Oc=Fe(),pB=rs(),TUe=Hv(),CUe=function(e){xUe.__extends(t,e);function t(){var r=e.call(this)||this;return r._labelsEnabled=!1,r._label=null,r.animator("rectangles",new wUe.Null),r.addClass("rectangle-plot"),r.attr("fill",new fB.Color().range()[0]),r}return t.prototype._createDrawer=function(){return new MUe.ProxyDrawer(function(){return new EUe.RectangleSVGDrawer},function(r){return new SUe.RectangleCanvasDrawer(r)})},t.prototype._generateAttrToProjector=function(){var r=this,n=e.prototype._generateAttrToProjector.call(this),i=pB.Plot._scaledAccessor(this.x()),o=n[t._X2_KEY],a=pB.Plot._scaledAccessor(this.y()),s=n[t._Y2_KEY],l=this.x().scale,c=this.y().scale;return o!=null?(n.width=function(u,h,f){return Math.abs(o(u,h,f)-i(u,h,f))},n.x=function(u,h,f){return Math.min(o(u,h,f),i(u,h,f))}):(n.width=function(u,h,f){return r._rectangleWidth(l)},n.x=function(u,h,f){return i(u,h,f)-.5*n.width(u,h,f)}),s!=null?(n.height=function(u,h,f){return Math.abs(s(u,h,f)-a(u,h,f))},n.y=function(u,h,f){return Math.max(s(u,h,f),a(u,h,f))-n.height(u,h,f)}):(n.height=function(u,h,f){return r._rectangleWidth(c)},n.y=function(u,h,f){return a(u,h,f)-.5*n.height(u,h,f)}),delete n[t._X2_KEY],delete n[t._Y2_KEY],n},t.prototype._generateDrawSteps=function(){return[{attrToProjector:this._getAttrToProjector(),animator:this._getAnimator("rectangles")}]},t.prototype._filterForProperty=function(r){return r==="x2"?e.prototype._filterForProperty.call(this,"x"):r==="y2"?e.prototype._filterForProperty.call(this,"y"):e.prototype._filterForProperty.call(this,r)},t.prototype.x=function(r,n,i){if(r==null)return e.prototype.x.call(this);if(n==null?e.prototype.x.call(this,r):e.prototype.x.call(this,r,n,i),n!=null){var o=this.x2(),a=o&&o.accessor;a!=null&&this._bindProperty(t._X2_KEY,a,n,o.postScale)}return n instanceof fB.Category&&n.innerPadding(0).outerPadding(0),this},t.prototype.x2=function(r,n){if(r==null)return this._propertyBindings.get(t._X2_KEY);var i=this.x(),o=i&&i.scale;return this._bindProperty(t._X2_KEY,r,o,n),this.render(),this},t.prototype.y=function(r,n,i){if(r==null)return e.prototype.y.call(this);if(n==null?e.prototype.y.call(this,r):e.prototype.y.call(this,r,n,i),n!=null){var o=this.y2(),a=o&&o.accessor;a!=null&&this._bindProperty(t._Y2_KEY,a,n,o.postScale)}return n instanceof fB.Category&&n.innerPadding(0).outerPadding(0),this},t.prototype.y2=function(r,n){if(r==null)return this._propertyBindings.get(t._Y2_KEY);var i=this.y(),o=i&&i.scale;return this._bindProperty(t._Y2_KEY,r,o,n),this.render(),this},t.prototype.entitiesAt=function(r){var n=this._getAttrToProjector();return this.entities().filter(function(i){var o=i.datum,a=i.index,s=i.dataset,l=n.x(o,a,s),c=n.y(o,a,s),u=n.width(o,a,s),h=n.height(o,a,s);return l<=r.x&&r.x<=l+u&&c<=r.y&&r.y<=c+h})},t.prototype._entityBounds=function(r){var n=r.datum,i=r.index,o=r.dataset;return this._entityBBox(n,i,o,this._getAttrToProjector())},t.prototype._entityBBox=function(r,n,i,o){return{x:o.x(r,n,i),y:o.y(r,n,i),width:o.width(r,n,i),height:o.height(r,n,i)}},t.prototype.label=function(r){return r==null?this._label:(this._label=r,this.render(),this)},t.prototype.labelsEnabled=function(r){return r==null?this._labelsEnabled:(this._labelsEnabled=r,this.render(),this)},t.prototype._propertyProjectors=function(){var r=e.prototype._propertyProjectors.call(this);return this.x2()!=null&&(r.x2=pB.Plot._scaledAccessor(this.x2())),this.y2()!=null&&(r.y2=pB.Plot._scaledAccessor(this.y2())),r},t.prototype._pixelPoint=function(r,n,i){var o=this._getAttrToProjector(),a=o.x(r,n,i),s=o.y(r,n,i),l=o.width(r,n,i),c=o.height(r,n,i),u=a+l/2,h=s+c/2;return{x:u,y:h}},t.prototype._rectangleWidth=function(r){if(r instanceof fB.Category)return r.rangeBand();var n=r===this.x().scale?this.x().accessor:this.y().accessor,i=bUe.set(Oc.Array.flatten(this.datasets().map(function(c){return c.data().map(function(u,h){return n(u,h,c).valueOf()})}))).values().map(function(c){return+c}),o=Oc.Math.min(i,0),a=Oc.Math.max(i,0),s=r.scale(o),l=r.scale(a);return(l-s)/Math.abs(a-o)},t.prototype._getDataToDraw=function(){var r=new Oc.Map,n=this._getAttrToProjector();return this.datasets().forEach(function(i){var o=i.data().map(function(a,s){var l=Oc.Math.isValidNumber(n.x(a,s,i))&&Oc.Math.isValidNumber(n.y(a,s,i))&&Oc.Math.isValidNumber(n.width(a,s,i))&&Oc.Math.isValidNumber(n.height(a,s,i));return l?a:null});r.set(i,o)}),r},t.prototype._additionalPaint=function(r){var n=this;this._renderArea.selectAll(".label-area").remove(),this._labelsEnabled&&this.label()!=null&&Oc.Window.setTimeout(function(){return n._drawLabels()},r)},t.prototype._drawLabels=function(){var r=this,n=this._getDataToDraw();this.datasets().forEach(function(i,o){return r._drawLabel(n,i,o)})},t.prototype._drawLabel=function(r,n,i){for(var o=this._getAttrToProjector(),a=this._renderArea.append("g").classed("label-area",!0),s=new Dat.SvgContext(a.node()),l=new Dat.CacheMeasurer(s),c=new Dat.Writer(l,s),u=this.x().scale.range(),h=this.y().scale.range(),f=Math.min.apply(null,u),p=Math.max.apply(null,u),d=Math.min.apply(null,h),g=Math.max.apply(null,h),_=r.get(n),y=_.length,x=0;x<y;x++){var b=_[x];if(b!=null){var S=""+this.label()(b,x,n),C=l.measure(S),P=o.x(b,x,n),k=o.y(b,x,n),O=o.width(b,x,n),D=o.height(b,x,n);if(C.height<=D&&C.width<=O){var B=(O-C.width)/2,I=(D-C.height)/2;P+=B,k+=I;var L={min:P,max:P+C.width},R={min:k,max:k+C.height};if(L.min<f||L.max>p||R.min<d||R.max>g||this._overlayLabel(L,R,x,i,r))continue;var F=o.fill(b,x,n),z=Oc.Color.contrast("white",F)*1.6<Oc.Color.contrast("black",F),U=a.append("g").attr("transform","translate("+P+","+k+")"),W=z?"dark-label":"light-label";U.classed(W,!0),c.write(S,C.width,C.height,{xAlign:"center",yAlign:"center"},U.node())}}}},t.prototype._overlayLabel=function(r,n,i,o,a){for(var s=this._getAttrToProjector(),l=this.datasets(),c=o;c<l.length;c++)for(var u=l[c],h=a.get(u),f=h.length,p=c===o?i+1:0;p<f;p++)if(Oc.DOM.intersectsBBox(r,n,this._entityBBox(h[p],p,u,s)))return!0;return!1},t._X2_KEY="x2",t._Y2_KEY="y2",t}(TUe.XYPlot);Oat.Rectangle=CUe});var TKt=H(Hat=>{"use strict";Object.defineProperty(Hat,"__esModule",{value:!0});var AUe=(de(),Ut(pe)),zat=_l(),PUe=Bu(),IUe=XF(),LUe=Uu(),EKt=vat(),kUe=Lf(),RUe=Bv(),NUe=ks(),Fat=Fe(),Bat=IS(),bl=rs(),DUe=Hv(),OUe=function(e){AUe.__extends(t,e);function t(){var r=e.call(this)||this;r._labelFormatter=PUe.identity(),r._labelsEnabled=!1,r.addClass("scatter-plot");var n=new kUe.Easing;n.startDelay(5),n.stepDuration(250),n.maxTotalDuration(bl.Plot._ANIMATION_MAX_DURATION),r.animator(Bat.Animator.MAIN,n),r.attr("opacity",.6),r.attr("fill",new NUe.Color().range()[0]),r.size(6);var i=IUe.circle();return r.symbol(function(){return i}),r._labelConfig=new Fat.Map,r}return t.prototype._buildLightweightPlotEntities=function(r){var n=this,i=e.prototype._buildLightweightPlotEntities.call(this,r);return i.map(function(o){var a=bl.Plot._scaledAccessor(n.size())(o.datum,o.index,o.dataset);return o.diameter=a,o})},t.prototype._createDrawer=function(r){var n=this;return new LUe.ProxyDrawer(function(){return new EKt.SymbolSVGDrawer},function(i){return new RUe.CanvasDrawer(i,EKt.makeSymbolCanvasDrawStep(r,function(){return bl.Plot._scaledAccessor(n.symbol())},function(){return bl.Plot._scaledAccessor(n.size())}))})},t.prototype.size=function(r,n){return r==null?this._propertyBindings.get(t._SIZE_KEY):(this._bindProperty(t._SIZE_KEY,r,n),this.render(),this)},t.prototype.symbol=function(r){return r==null?this._propertyBindings.get(t._SYMBOL_KEY):(this._propertyBindings.set(t._SYMBOL_KEY,{accessor:r}),this.render(),this)},t.prototype._generateDrawSteps=function(){var r=[];if(this._animateOnNextRender()){var n=this._getAttrToProjector(),i=bl.Plot._scaledAccessor(this.symbol());n.d=function(o,a,s){return i(o,a,s)(0)(null)},r.push({attrToProjector:n,animator:this._getAnimator(Bat.Animator.RESET)})}return r.push({attrToProjector:this._getAttrToProjector(),animator:this._getAnimator(Bat.Animator.MAIN)}),r},t.prototype._propertyProjectors=function(){var r=e.prototype._propertyProjectors.call(this),n=bl.Plot._scaledAccessor(this.x()),i=bl.Plot._scaledAccessor(this.y());return r.x=n,r.y=i,r.transform=function(o,a,s){return"translate("+n(o,a,s)+","+i(o,a,s)+")"},r.d=this._constructSymbolGenerator(),r},t.prototype._constructSymbolGenerator=function(){var r=bl.Plot._scaledAccessor(this.symbol()),n=bl.Plot._scaledAccessor(this.size());return function(i,o,a){return r(i,o,a)(n(i,o,a))(null)}},t.prototype._entityBounds=function(r){return{x:r.position.x-r.diameter/2,y:r.position.y-r.diameter/2,width:r.diameter,height:r.diameter}},t.prototype._entityVisibleOnPlot=function(r,n){var i={min:n.topLeft.x,max:n.bottomRight.x},o={min:n.topLeft.y,max:n.bottomRight.y},a=this._entityBounds(r);return Fat.DOM.intersectsBBox(i,o,a)},t.prototype.entitiesAt=function(r){var n=bl.Plot._scaledAccessor(this.x()),i=bl.Plot._scaledAccessor(this.y()),o=bl.Plot._scaledAccessor(this.size());return this.entities().filter(function(a){var s=a.datum,l=a.index,c=a.dataset,u=n(s,l,c),h=i(s,l,c),f=o(s,l,c);return u-f/2<=r.x&&r.x<=u+f/2&&h-f/2<=r.y&&r.y<=h+f/2})},t.prototype.labelsEnabled=function(r){return r==null?this._labelsEnabled:(this._labelsEnabled=r,this._clearAttrToProjectorCache(),this.render(),this)},t.prototype._createNodesForDataset=function(r){var n=e.prototype._createNodesForDataset.call(this,r),i=this._renderArea.append("g").classed(t._LABEL_AREA_CLASS,!0),o=new zat.SvgContext(i.node()),a=new zat.CacheMeasurer(o),s=new zat.Writer(a,o);return this._labelConfig.set(r,{labelArea:i,measurer:a,writer:s}),n},t.prototype._removeDatasetNodes=function(r){e.prototype._removeDatasetNodes.call(this,r);var n=this._labelConfig.get(r);n!=null&&(n.labelArea.remove(),this._labelConfig.delete(r))},t.prototype._additionalPaint=function(r){var n=this;this.datasets().forEach(function(i){return n._labelConfig.get(i).labelArea.selectAll("g").remove()}),this._labelsEnabled&&Fat.Window.setTimeout(function(){return n._drawLabels()},r)},t.prototype._drawLabels=function(){var r=this,n=this._getDataToDraw(),i=this._getAttrToProjector();this.datasets().forEach(function(o){for(var a=n.get(o),s=a.length,l=0;l<s;l++){var c=a[l];c!=null&&r._drawLabel(c,l,o,i)}})},t.prototype._drawLabel=function(r,n,i,o){if(r.label!=null){var a=this._labelConfig.get(i),s=a.labelArea,l=a.measurer,c=a.writer,u={x:o.x(r,n,i),y:o.y(r,n,i)},h=bl.Plot._scaledAccessor(this.size()),f=h(r,n,i),p=this._labelFormatter(r.label,r,n,i),d=l.measure(p),g=this._calculateLabelProperties(u,f,d),_=g.containerDimensions,y=g.labelContainerOrigin,x=g.labelOrigin,b=g.alignment,S=this._createLabelContainer(s,y,x,d),C={xAlign:b.x,yAlign:b.y};c.write(p,_.width,_.height,C,S.node())}},t.prototype._calculateLabelProperties=function(r,n,i){var o=n<i.height?n/2+t._LABEL_MARGIN_FROM_BUBBLE:0;return{containerDimensions:{width:i.width,height:i.height},labelContainerOrigin:{x:r.x-i.width/2,y:r.y-i.height/2+o},labelOrigin:{x:r.x,y:r.y},alignment:{x:"center",y:"center"}}},t.prototype._createLabelContainer=function(r,n,i,o){var a=r.append("g").attr("transform","translate("+n.x+", "+n.y+")");return a.classed("on-bar-label",!0),a},t._SIZE_KEY="size",t._SYMBOL_KEY="symbol",t._LABEL_AREA_CLASS="scatter-label-text-area",t._LABEL_MARGIN_FROM_BUBBLE=15,t}(DUe.XYPlot);Hat.Scatter=OUe});var CKt=H(Vat=>{"use strict";Object.defineProperty(Vat,"__esModule",{value:!0});var zUe=(de(),Ut(pe)),FUe=Lf(),BUe=Uu(),HUe=_at(),VUe=ks(),UUe=AF(),LS=rs(),qUe=Hv(),GUe=function(e){zUe.__extends(t,e);function t(){var r=e.call(this)||this;return r.addClass("segment-plot"),r.attr("stroke",new VUe.Color().range()[0]),r.attr("stroke-width","2px"),r}return t.prototype._createDrawer=function(){return new BUe.ProxyDrawer(function(){return new HUe.SegmentSVGDrawer},function(){return UUe.warn("canvas renderer is not supported on Segment Plot!"),null})},t.prototype._generateDrawSteps=function(){return[{attrToProjector:this._getAttrToProjector(),animator:new FUe.Null}]},t.prototype._filterForProperty=function(r){return r==="x2"?e.prototype._filterForProperty.call(this,"x"):r==="y2"?e.prototype._filterForProperty.call(this,"y"):e.prototype._filterForProperty.call(this,r)},t.prototype.x=function(r,n){if(r==null)return e.prototype.x.call(this);if(n==null)e.prototype.x.call(this,r);else{e.prototype.x.call(this,r,n);var i=this.x2(),o=i&&i.accessor;o!=null&&this._bindProperty(t._X2_KEY,o,n)}return this},t.prototype.x2=function(r){if(r==null)return this._propertyBindings.get(t._X2_KEY);var n=this.x(),i=n&&n.scale;return this._bindProperty(t._X2_KEY,r,i),this.render(),this},t.prototype.y=function(r,n){if(r==null)return e.prototype.y.call(this);if(n==null)e.prototype.y.call(this,r);else{e.prototype.y.call(this,r,n);var i=this.y2(),o=i&&i.accessor;o!=null&&this._bindProperty(t._Y2_KEY,o,n)}return this},t.prototype.y2=function(r){if(r==null)return this._propertyBindings.get(t._Y2_KEY);var n=this.y(),i=n&&n.scale;return this._bindProperty(t._Y2_KEY,r,i),this.render(),this},t.prototype._propertyProjectors=function(){var r=e.prototype._propertyProjectors.call(this);return r.x1=LS.Plot._scaledAccessor(this.x()),r.x2=this.x2()==null?LS.Plot._scaledAccessor(this.x()):LS.Plot._scaledAccessor(this.x2()),r.y1=LS.Plot._scaledAccessor(this.y()),r.y2=this.y2()==null?LS.Plot._scaledAccessor(this.y()):LS.Plot._scaledAccessor(this.y2()),r},t.prototype.entitiesAt=function(r){var n=this.entityNearest(r);return n!=null?[n]:[]},t.prototype.entitiesIn=function(r,n){var i,o;if(n==null){var a=r;i={min:a.topLeft.x,max:a.bottomRight.x},o={min:a.topLeft.y,max:a.bottomRight.y}}else i=r,o=n;return this._entitiesIntersecting(i,o)},t.prototype._entitiesIntersecting=function(r,n){for(var i=[],o=this._getAttrToProjector(),a=this.entities(),s=a.length,l=0;l<s;l++){var c=a[l];this._lineIntersectsBox(c,r,n,o)&&i.push(c)}return i},t.prototype._lineIntersectsBox=function(r,n,i,o){var a=this,s=o.x1(r.datum,r.index,r.dataset),l=o.x2(r.datum,r.index,r.dataset),c=o.y1(r.datum,r.index,r.dataset),u=o.y2(r.datum,r.index,r.dataset);if(n.min<=s&&s<=n.max&&i.min<=c&&c<=i.max||n.min<=l&&l<=n.max&&i.min<=u&&u<=i.max)return!0;var h={x:s,y:c},f={x:l,y:u},p=[{x:n.min,y:i.min},{x:n.min,y:i.max},{x:n.max,y:i.max},{x:n.max,y:i.min}],d=p.filter(function(g,_){return _!==0?a._lineIntersectsSegment(h,f,g,p[_-1])&&a._lineIntersectsSegment(g,p[_-1],h,f):!1});return d.length>0},t.prototype._lineIntersectsSegment=function(r,n,i,o){var a=function(s,l,c){return(l.x-s.x)*(c.y-l.y)-(l.y-s.y)*(c.x-l.x)};return a(r,n,i)*a(r,n,o)<0},t._X2_KEY="x2",t._Y2_KEY="y2",t}(qUe.XYPlot);Vat.Segment=GUe});var IKt=H(Uat=>{"use strict";Object.defineProperty(Uat,"__esModule",{value:!0});var WUe=(de(),Ut(pe)),AKt=(Er(),Ut(Mr)),YUe=Lf(),PKt=CS(),t0=Fe(),jUe=Tat(),XUe=rs(),$Ue=function(e){WUe.__extends(t,e);function t(){var r=e.call(this)||this;return r._stackingResult=PKt.memThunk(function(){return r.datasets()},function(){return r.x().accessor},function(){return r.y().accessor},function(){return r._stackingOrder},function(n,i,o,a){return t0.Stacking.stack(n,i,o,a)}),r._stackedExtent=PKt.memThunk(r._stackingResult,function(){return r.x().accessor},function(){return r._filterForProperty("y")},function(n,i,o){return t0.Stacking.stackedExtent(n,i,o)}),r._baselineValue=0,r._stackingOrder="bottomup",r.addClass("stacked-area-plot"),r._baselineValueProvider=function(){return[r._baselineValue]},r.croppedRenderingEnabled(!1),r}return t.prototype.croppedRenderingEnabled=function(r){return r==null?e.prototype.croppedRenderingEnabled.call(this):r?(t0.Window.warn("Warning: Stacked Area Plot does not support cropped rendering."),this):e.prototype.croppedRenderingEnabled.call(this,r)},t.prototype._getAnimator=function(r){return new YUe.Null},t.prototype._setup=function(){e.prototype._setup.call(this),this._baseline=this._renderArea.append("line").classed("baseline",!0)},t.prototype.x=function(r,n){return r==null?e.prototype.x.call(this):(n==null?e.prototype.x.call(this,r):e.prototype.x.call(this,r,n),this._checkSameDomain(),this)},t.prototype.y=function(r,n){return r==null?e.prototype.y.call(this):(n==null?e.prototype.y.call(this,r):e.prototype.y.call(this,r,n),this._checkSameDomain(),this)},t.prototype.yOffset=function(r,n){var i=this._stackingResult();if(i!=null){var o=i.get(r);if(o!=null){var a=o.get(String(n));if(a!=null)return a.offset}}},t.prototype.stackingOrder=function(r){return r==null?this._stackingOrder:(this._stackingOrder=r,this._onDatasetUpdate(),this)},t.prototype.downsamplingEnabled=function(r){return r==null?e.prototype.downsamplingEnabled.call(this):(t0.Window.warn("Warning: Stacked Area Plot does not support downsampling"),this)},t.prototype._additionalPaint=function(){var r=this.y().scale.scale(this._baselineValue),n={x1:0,y1:r,x2:this.width(),y2:r};this._getAnimator("baseline").animate(this._baseline,n)},t.prototype._updateYScale=function(){var r=this.y(),n=r&&r.scale;n!=null&&(n.addPaddingExceptionsProvider(this._baselineValueProvider),n.addIncludedValuesProvider(this._baselineValueProvider))},t.prototype._onDatasetUpdate=function(){return this._checkSameDomain(),e.prototype._onDatasetUpdate.call(this),this},t.prototype.getExtentsForProperty=function(r){var n="y";return r===n?[this._stackedExtent()]:e.prototype.getExtentsForProperty.call(this,r)},t.prototype._checkSameDomain=function(){if(!!this._projectorsReady()){var r=this.datasets(),n=this.x().accessor,i=r.map(function(a){return AKt.set(a.data().map(function(s,l){return t0.Stacking.normalizeKey(n(s,l,a))})).values()}),o=t._domainKeys(r,n);i.some(function(a){return a.length!==o.length})&&t0.Window.warn("the domains across the datasets are not the same. Plot may produce unintended behavior.")}},t._domainKeys=function(r,n){var i=AKt.set();return r.forEach(function(o){for(var a=o.data(),s=a.length,l=0;l<s;l++){var c=a[l];i.add(n(c,l,o))}}),i.values()},t.prototype._coordinateProjectors=function(){var r=this,n=XUe.Plot._scaledAccessor(this.x()),i=this.y().accessor,o=this.x().accessor,a=function(u,h,f){return t0.Stacking.normalizeKey(o(u,h,f))},s=this._stackingResult(),l=function(u,h,f){var p=+i(u,h,f),d=s.get(f).get(a(u,h,f)).offset;return r.y().scale.scale(p+d)},c=function(u,h,f){var p=s.get(f).get(a(u,h,f)).offset;return r.y().scale.scale(p)};return[n,l,c]},t.prototype._propertyProjectors=function(){var r=e.prototype._propertyProjectors.call(this),n=this._coordinateProjectors(),i=n[0],o=n[1],a=n[2];return r.d=this._constructAreaProjector(i,o,a),r},t.prototype._pixelPoint=function(r,n,i){var o=e.prototype._pixelPoint.call(this,r,n,i),a=this.x().accessor(r,n,i),s=this.y().accessor(r,n,i),l=this.y().scale.scale(+s+this._stackingResult().get(i).get(t0.Stacking.normalizeKey(a)).offset);return{x:o.x,y:l}},t}(jUe.Area);Uat.StackedArea=$Ue});var kKt=H(Wat=>{"use strict";Object.defineProperty(Wat,"__esModule",{value:!0});var KUe=(de(),Ut(pe)),qat=_l(),ZUe=Bu(),LKt=CS(),dB=Fe(),Gat=y4(),JUe=rs(),QUe=function(e){KUe.__extends(t,e);function t(r){r===void 0&&(r="vertical");var n=e.call(this,r)||this;return n._extremaFormatter=ZUe.identity(),n._stackingResult=LKt.memThunk(function(){return n.datasets()},function(){return n.position().accessor},function(){return n.length().accessor},function(){return n._stackingOrder},function(i,o,a,s){return dB.Stacking.stack(i,o,a,s)}),n._stackedExtent=LKt.memThunk(n._stackingResult,function(){return n.position().accessor},function(){return n._filterForProperty(n._isVertical?"y":"x")},function(i,o,a){return dB.Stacking.stackedExtent(i,o,a)}),n.addClass("stacked-bar-plot"),n._stackingOrder="bottomup",n}return t.prototype.stackingOrder=function(r){return r==null?this._stackingOrder:(this._stackingOrder=r,this._onDatasetUpdate(),this)},t.prototype.extremaFormatter=function(r){return arguments.length===0?this._extremaFormatter:(this._extremaFormatter=r,this.render(),this)},t.prototype._setup=function(){e.prototype._setup.call(this),this._labelArea=this._renderArea.append("g").classed(Gat.Bar._LABEL_AREA_CLASS,!0);var r=new qat.SvgContext(this._labelArea.node());this._measurer=new qat.CacheMeasurer(r),this._writer=new qat.Writer(this._measurer,r)},t.prototype._drawLabels=function(){var r=this;e.prototype._drawLabels.call(this),this._labelArea.selectAll("g").remove();var n=+this.baselineValue(),i=this.position().scale,o=this.length().scale,a=dB.Stacking.stackedExtents(this._stackingResult()),s=a.maximumExtents,l=a.minimumExtents,c=[],u=function(f,p,d){var g=p.topLeft,_=g.x,y=g.y,x=p.bottomRight.x-p.topLeft.x,b=p.bottomRight.y-p.topLeft.y,S=r._isVertical?x>d:b>d;if(!S){var C=r._labelArea.append("g").attr("transform","translate("+_+", "+y+")");C.classed("stacked-bar-label",!0);var P={xAlign:"center",yAlign:"center"};r._writer.write(f,x,b,P,C.node())}return S},h=function(f,p){var d=r._generateAttrToProjector(),g=r.width(),_=r.height();f.forEach(function(y){if(y.extent!==n){var x=r.extremaFormatter()(y.extent),b=r._measurer.measure(x),S=y.stackedDatum,C=S.originalDatum,P=S.originalIndex,k=S.originalDataset;if(!r._isDatumOnScreen(d,g,_,C,P,k))return;var O=JUe.Plot._scaledAccessor(r.attr(Gat.Bar._BAR_THICKNESS_KEY))(C,P,k),D=o.scale(y.extent),B=r._getPositionAttr(i.scale(y.axisValue),O)+O/2,I=r._isVertical?{x:B,y:D}:{x:D,y:B},L=p(I,b,O),R=u(x,{topLeft:L,bottomRight:{x:L.x+b.width,y:L.y+b.height}},O);c.push(R)}})};h(s,function(f,p,d){var g=r._isVertical?p.width:p.height,_=r._isVertical?p.height:p.width;return{x:r._isVertical?f.x-g/2:f.x+t._EXTREMA_LABEL_MARGIN_FROM_BAR,y:r._isVertical?f.y-_:f.y-g/2}}),h(l,function(f,p,d){var g=r._isVertical?p.width:p.height,_=r._isVertical?p.height:p.width;return{x:r._isVertical?f.x-g/2:f.x-_,y:r._isVertical?f.y+t._EXTREMA_LABEL_MARGIN_FROM_BAR:f.y-g/2}}),c.some(function(f){return f})&&this._labelArea.selectAll("g").remove()},t.prototype._generateAttrToProjector=function(){var r=this,n=e.prototype._generateAttrToProjector.call(this),i=this._isVertical?"y":"x",o=this.length().scale,a=this.length().accessor,s=this.position().accessor,l=function(d,g,_){return dB.Stacking.normalizeKey(s(d,g,_))},c=this._stackingResult(),u=function(d,g,_){return o.scale(c.get(_).get(l(d,g,_)).offset)},h=function(d,g,_){return o.scale(+a(d,g,_)+c.get(_).get(l(d,g,_)).offset)},f=function(d,g,_){return Math.abs(h(d,g,_)-u(d,g,_))};n[this._isVertical?"height":"width"]=f;var p=function(d,g,_){return+a(d,g,_)<0?u(d,g,_):h(d,g,_)};return n[i]=function(d,g,_){return r._isVertical?p(d,g,_):p(d,g,_)-f(d,g,_)},n},t.prototype.getExtentsForProperty=function(r){var n=this._isVertical?"y":"x";return r===n?[this._stackedExtent()]:e.prototype.getExtentsForProperty.call(this,r)},t.prototype.invalidateCache=function(){e.prototype.invalidateCache.call(this),this._measurer.reset()},t._EXTREMA_LABEL_MARGIN_FROM_BAR=5,t}(Gat.Bar);Wat.StackedBar=QUe});var RKt=H(Yat=>{"use strict";Object.defineProperty(Yat,"__esModule",{value:!0});var tqe=(de(),Ut(pe)),eqe=Fe(),rqe=y4(),nqe=rs(),iqe=function(e){tqe.__extends(t,e);function t(){var r=e.call(this)||this;return r._connectorsEnabled=!1,r.addClass("waterfall-plot"),r}return t.prototype.connectorsEnabled=function(r){return r==null?this._connectorsEnabled:(this._connectorsEnabled=r,this)},t.prototype.total=function(r){return r==null?this._propertyBindings.get(t._TOTAL_KEY):(this._bindProperty(t._TOTAL_KEY,r,null),this)},t.prototype._additionalPaint=function(r){var n=this;this._connectorArea.selectAll("line").remove(),this._connectorsEnabled&&eqe.Window.setTimeout(function(){return n._drawConnectors()},r)},t.prototype._createNodesForDataset=function(r){var n=e.prototype._createNodesForDataset.call(this,r);return this._connectorArea=this._renderArea.append("g").classed(t._CONNECTOR_AREA_CLASS,!0),n},t.prototype.getExtentsForProperty=function(r){var n="y";return r===n?[this._extent]:e.prototype.getExtentsForProperty.call(this,r)},t.prototype._generateAttrToProjector=function(){var r=this,n=e.prototype._generateAttrToProjector.call(this),i=this.y().scale,o=nqe.Plot._scaledAccessor(this.total()),a=this.attr("y");a==null&&(n.y=function(l,c,u){var h=r.y().accessor(l,c,u),f=o(l,c,u);if(f)return Math.min(i.scale(h),i.scale(0));var p=r._subtotals[c];if(c===0)return h<0?i.scale(p-h):i.scale(p);var d=r._subtotals[c-1];return p>d?i.scale(p):i.scale(d)});var s=this.attr("height");return s==null&&(n.height=function(l,c,u){var h=o(l,c,u),f=r.y().accessor(l,c,u);if(h)return Math.abs(i.scale(f)-i.scale(0));var p=r._subtotals[c];if(c===0)return Math.abs(i.scale(p)-i.scale(p-f));var d=r._subtotals[c-1];return Math.abs(i.scale(p)-i.scale(d))}),n.class=function(l,c,u){var h="";r.attr("class")!=null&&(h=r.attr("class").accessor(l,c,u)+" ");var f=o(l,c,u);if(f)return h+t._BAR_TOTAL_CLASS;var p=r.y().accessor(l,c,u);return h+(p>0?t._BAR_GROWTH_CLASS:t._BAR_DECLINE_CLASS)},n},t.prototype._onDatasetUpdate=function(){return this._updateSubtotals(),e.prototype._onDatasetUpdate.call(this),this},t.prototype._calculateSubtotalsAndExtent=function(r){for(var n=Number.MAX_VALUE,i=Number.MIN_VALUE,o=0,a=!1,s=r.data(),l=s.length,c=0;c<l;c++){var u=s[c],h=this.y().accessor(u,c,r),f=this.total().accessor(u,c,r);if((!f||c===0)&&(o+=h),this._subtotals.push(o),o<n&&(n=o),o>i&&(i=o),f&&(h<n&&(n=h),h>i&&(i=h)),!a&&f){for(var p=h-o,d=0;d<this._subtotals.length;d++)this._subtotals[d]+=p;a=!0,o+=p,n+=p,i+=p}}this._extent=[n,i]},t.prototype._drawConnectors=function(){for(var r=this._getAttrToProjector(),n=this.datasets()[0],i=1;i<n.data().length;i++){var o=i-1,a=n.data()[i],s=n.data()[o],l=r.x(s,o,n),c=r.x(a,i,n)+r.width(a,i,n),u=r.y(a,i,n);(this._subtotals[i]>0&&this._subtotals[i]>this._subtotals[o]||this._subtotals[i]<0&&this._subtotals[i]>=this._subtotals[o])&&(u=r.y(a,i,n)+r.height(a,i,n)),this._connectorArea.append("line").classed(t._CONNECTOR_CLASS,!0).attr("x1",l).attr("x2",c).attr("y1",u).attr("y2",u)}},t.prototype._updateSubtotals=function(){var r=this.datasets();if(r.length>0){var n=r[r.length-1];this._subtotals=new Array,this._calculateSubtotalsAndExtent(n)}},t._BAR_DECLINE_CLASS="waterfall-decline",t._BAR_GROWTH_CLASS="waterfall-growth",t._BAR_TOTAL_CLASS="waterfall-total",t._CONNECTOR_CLASS="connector",t._CONNECTOR_AREA_CLASS="connector-area",t._TOTAL_KEY="total",t}(rqe.Bar);Yat.Waterfall=iqe});var IS=H(Os=>{"use strict";Object.defineProperty(Os,"__esModule",{value:!0});var zc=(de(),Ut(pe));zc.__exportStar(Tat(),Os);zc.__exportStar(y4(),Os);zc.__exportStar(Got(),Os);zc.__exportStar(wKt(),Os);zc.__exportStar(Sat(),Os);zc.__exportStar(SKt(),Os);zc.__exportStar(MKt(),Os);zc.__exportStar(TKt(),Os);zc.__exportStar(CKt(),Os);zc.__exportStar(IKt(),Os);zc.__exportStar(kKt(),Os);zc.__exportStar(RKt(),Os)});var NKt=H(jat=>{"use strict";Object.defineProperty(jat,"__esModule",{value:!0});jat.version="3.9.0"});var wl=H(ln=>{"use strict";Object.defineProperty(ln,"__esModule",{value:!0});var Fc=(de(),Ut(pe));$jt();var oqe=Lf();ln.Animators=oqe;var aqe=f$t();ln.Axes=aqe;var sqe=Pot();ln.Components=sqe;var lqe=$A();ln.Configs=lqe;var cqe=Bu();ln.Formatters=cqe;var uqe=IF();ln.RenderController=uqe;var hqe=Hit();ln.RenderPolicies=hqe;var fqe=XF();ln.SymbolFactories=fqe;var pqe=Nv();ln.Dispatchers=pqe;var dqe=Bv();ln.Drawers=dqe;var mqe=l4();ln.Interactions=mqe;var gqe=IS();ln.Plots=gqe;var _qe=ks();ln.Scales=_qe;var yqe=Fe();ln.Utils=yqe;Fc.__exportStar(t4(),ln);var vqe=HF();ln.TimeInterval=vqe.TimeInterval;Fc.__exportStar(kc(),ln);Fc.__exportStar(WF(),ln);Fc.__exportStar(Yot(),ln);var xqe=NKt();ln.version=xqe.version;Fc.__exportStar(o4(),ln);Fc.__exportStar(Uu(),ln);Fc.__exportStar(Dv(),ln);Fc.__exportStar(wot(),ln);Fc.__exportStar(Hv(),ln);Fc.__exportStar(rs(),ln);Fc.__exportStar(vd(),ln);Fc.__exportStar(Lv(),ln)});var QKt=H((sXn,JKt)=>{function Bqe(){this.__data__=[],this.size=0}JKt.exports=Bqe});var Yv=H((lXn,tZt)=>{function Hqe(e,t){return e===t||e!==e&&t!==t}tZt.exports=Hqe});var M4=H((cXn,eZt)=>{var Vqe=Yv();function Uqe(e,t){for(var r=e.length;r--;)if(Vqe(e[r][0],t))return r;return-1}eZt.exports=Uqe});var nZt=H((uXn,rZt)=>{var qqe=M4(),Gqe=Array.prototype,Wqe=Gqe.splice;function Yqe(e){var t=this.__data__,r=qqe(t,e);if(r<0)return!1;var n=t.length-1;return r==n?t.pop():Wqe.call(t,r,1),--this.size,!0}rZt.exports=Yqe});var oZt=H((hXn,iZt)=>{var jqe=M4();function Xqe(e){var t=this.__data__,r=jqe(t,e);return r<0?void 0:t[r][1]}iZt.exports=Xqe});var sZt=H((fXn,aZt)=>{var $qe=M4();function Kqe(e){return $qe(this.__data__,e)>-1}aZt.exports=Kqe});var cZt=H((pXn,lZt)=>{var Zqe=M4();function Jqe(e,t){var r=this.__data__,n=Zqe(r,e);return n<0?(++this.size,r.push([e,t])):r[n][1]=t,this}lZt.exports=Jqe});var E4=H((dXn,uZt)=>{var Qqe=QKt(),tGe=nZt(),eGe=oZt(),rGe=sZt(),nGe=cZt();function zS(e){var t=-1,r=e==null?0:e.length;for(this.clear();++t<r;){var n=e[t];this.set(n[0],n[1])}}zS.prototype.clear=Qqe;zS.prototype.delete=tGe;zS.prototype.get=eGe;zS.prototype.has=rGe;zS.prototype.set=nGe;uZt.exports=zS});var fZt=H((mXn,hZt)=>{var iGe=E4();function oGe(){this.__data__=new iGe,this.size=0}hZt.exports=oGe});var dZt=H((gXn,pZt)=>{function aGe(e){var t=this.__data__,r=t.delete(e);return this.size=t.size,r}pZt.exports=aGe});var gZt=H((_Xn,mZt)=>{function sGe(e){return this.__data__.get(e)}mZt.exports=sGe});var yZt=H((yXn,_Zt)=>{function lGe(e){return this.__data__.has(e)}_Zt.exports=lGe});var cst=H((vXn,vZt)=>{var cGe=typeof global=="object"&&global&&global.Object===Object&&global;vZt.exports=cGe});var Hc=H((xXn,xZt)=>{var uGe=cst(),hGe=typeof self=="object"&&self&&self.Object===Object&&self,fGe=uGe||hGe||Function("return this")();xZt.exports=fGe});var jv=H((bXn,bZt)=>{var pGe=Hc(),dGe=pGe.Symbol;bZt.exports=dGe});var EZt=H((wXn,MZt)=>{var wZt=jv(),SZt=Object.prototype,mGe=SZt.hasOwnProperty,gGe=SZt.toString,T4=wZt?wZt.toStringTag:void 0;function _Ge(e){var t=mGe.call(e,T4),r=e[T4];try{e[T4]=void 0;var n=!0}catch(o){}var i=gGe.call(e);return n&&(t?e[T4]=r:delete e[T4]),i}MZt.exports=_Ge});var CZt=H((SXn,TZt)=>{var yGe=Object.prototype,vGe=yGe.toString;function xGe(e){return vGe.call(e)}TZt.exports=xGe});var s0=H((MXn,IZt)=>{var AZt=jv(),bGe=EZt(),wGe=CZt(),SGe="[object Null]",MGe="[object Undefined]",PZt=AZt?AZt.toStringTag:void 0;function EGe(e){return e==null?e===void 0?MGe:SGe:PZt&&PZt in Object(e)?bGe(e):wGe(e)}IZt.exports=EGe});var Ml=H((EXn,LZt)=>{function TGe(e){var t=typeof e;return e!=null&&(t=="object"||t=="function")}LZt.exports=TGe});var FS=H((TXn,kZt)=>{var CGe=s0(),AGe=Ml(),PGe="[object AsyncFunction]",IGe="[object Function]",LGe="[object GeneratorFunction]",kGe="[object Proxy]";function RGe(e){if(!AGe(e))return!1;var t=CGe(e);return t==IGe||t==LGe||t==PGe||t==kGe}kZt.exports=RGe});var NZt=H((CXn,RZt)=>{var NGe=Hc(),DGe=NGe["__core-js_shared__"];RZt.exports=DGe});var zZt=H((AXn,OZt)=>{var ust=NZt(),DZt=function(){var e=/[^.]+$/.exec(ust&&ust.keys&&ust.keys.IE_PROTO||"");return e?"Symbol(src)_1."+e:""}();function OGe(e){return!!DZt&&DZt in e}OZt.exports=OGe});var hst=H((PXn,FZt)=>{var zGe=Function.prototype,FGe=zGe.toString;function BGe(e){if(e!=null){try{return FGe.call(e)}catch(t){}try{return e+""}catch(t){}}return""}FZt.exports=BGe});var HZt=H((IXn,BZt)=>{var HGe=FS(),VGe=zZt(),UGe=Ml(),qGe=hst(),GGe=/[\\^$.*+?()[\]{}|]/g,WGe=/^\[object .+?Constructor\]$/,YGe=Function.prototype,jGe=Object.prototype,XGe=YGe.toString,$Ge=jGe.hasOwnProperty,KGe=RegExp("^"+XGe.call($Ge).replace(GGe,"\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g,"$1.*?")+"$");function ZGe(e){if(!UGe(e)||VGe(e))return!1;var t=HGe(e)?KGe:WGe;return t.test(qGe(e))}BZt.exports=ZGe});var UZt=H((LXn,VZt)=>{function JGe(e,t){return e==null?void 0:e[t]}VZt.exports=JGe});var l0=H((kXn,qZt)=>{var QGe=HZt(),tWe=UZt();function eWe(e,t){var r=tWe(e,t);return QGe(r)?r:void 0}qZt.exports=eWe});var zB=H((RXn,GZt)=>{var rWe=l0(),nWe=Hc(),iWe=rWe(nWe,"Map");GZt.exports=iWe});var C4=H((NXn,WZt)=>{var oWe=l0(),aWe=oWe(Object,"create");WZt.exports=aWe});var XZt=H((DXn,jZt)=>{var YZt=C4();function sWe(){this.__data__=YZt?YZt(null):{},this.size=0}jZt.exports=sWe});var KZt=H((OXn,$Zt)=>{function lWe(e){var t=this.has(e)&&delete this.__data__[e];return this.size-=t?1:0,t}$Zt.exports=lWe});var JZt=H((zXn,ZZt)=>{var cWe=C4(),uWe="__lodash_hash_undefined__",hWe=Object.prototype,fWe=hWe.hasOwnProperty;function pWe(e){var t=this.__data__;if(cWe){var r=t[e];return r===uWe?void 0:r}return fWe.call(t,e)?t[e]:void 0}ZZt.exports=pWe});var tJt=H((FXn,QZt)=>{var dWe=C4(),mWe=Object.prototype,gWe=mWe.hasOwnProperty;function _We(e){var t=this.__data__;return dWe?t[e]!==void 0:gWe.call(t,e)}QZt.exports=_We});var rJt=H((BXn,eJt)=>{var yWe=C4(),vWe="__lodash_hash_undefined__";function xWe(e,t){var r=this.__data__;return this.size+=this.has(e)?0:1,r[e]=yWe&&t===void 0?vWe:t,this}eJt.exports=xWe});var iJt=H((HXn,nJt)=>{var bWe=XZt(),wWe=KZt(),SWe=JZt(),MWe=tJt(),EWe=rJt();function BS(e){var t=-1,r=e==null?0:e.length;for(this.clear();++t<r;){var n=e[t];this.set(n[0],n[1])}}BS.prototype.clear=bWe;BS.prototype.delete=wWe;BS.prototype.get=SWe;BS.prototype.has=MWe;BS.prototype.set=EWe;nJt.exports=BS});var sJt=H((VXn,aJt)=>{var oJt=iJt(),TWe=E4(),CWe=zB();function AWe(){this.size=0,this.__data__={hash:new oJt,map:new(CWe||TWe),string:new oJt}}aJt.exports=AWe});var cJt=H((UXn,lJt)=>{function PWe(e){var t=typeof e;return t=="string"||t=="number"||t=="symbol"||t=="boolean"?e!=="__proto__":e===null}lJt.exports=PWe});var A4=H((qXn,uJt)=>{var IWe=cJt();function LWe(e,t){var r=e.__data__;return IWe(t)?r[typeof t=="string"?"string":"hash"]:r.map}uJt.exports=LWe});var fJt=H((GXn,hJt)=>{var kWe=A4();function RWe(e){var t=kWe(this,e).delete(e);return this.size-=t?1:0,t}hJt.exports=RWe});var dJt=H((WXn,pJt)=>{var NWe=A4();function DWe(e){return NWe(this,e).get(e)}pJt.exports=DWe});var gJt=H((YXn,mJt)=>{var OWe=A4();function zWe(e){return OWe(this,e).has(e)}mJt.exports=zWe});var yJt=H((jXn,_Jt)=>{var FWe=A4();function BWe(e,t){var r=FWe(this,e),n=r.size;return r.set(e,t),this.size+=r.size==n?0:1,this}_Jt.exports=BWe});var FB=H((XXn,vJt)=>{var HWe=sJt(),VWe=fJt(),UWe=dJt(),qWe=gJt(),GWe=yJt();function HS(e){var t=-1,r=e==null?0:e.length;for(this.clear();++t<r;){var n=e[t];this.set(n[0],n[1])}}HS.prototype.clear=HWe;HS.prototype.delete=VWe;HS.prototype.get=UWe;HS.prototype.has=qWe;HS.prototype.set=GWe;vJt.exports=HS});var bJt=H(($Xn,xJt)=>{var WWe=E4(),YWe=zB(),jWe=FB(),XWe=200;function $We(e,t){var r=this.__data__;if(r instanceof WWe){var n=r.__data__;if(!YWe||n.length<XWe-1)return n.push([e,t]),this.size=++r.size,this;r=this.__data__=new jWe(n)}return r.set(e,t),this.size=r.size,this}xJt.exports=$We});var P4=H((KXn,wJt)=>{var KWe=E4(),ZWe=fZt(),JWe=dZt(),QWe=gZt(),tYe=yZt(),eYe=bJt();function VS(e){var t=this.__data__=new KWe(e);this.size=t.size}VS.prototype.clear=ZWe;VS.prototype.delete=JWe;VS.prototype.get=QWe;VS.prototype.has=tYe;VS.prototype.set=eYe;wJt.exports=VS});var BB=H((ZXn,SJt)=>{function rYe(e,t){for(var r=-1,n=e==null?0:e.length;++r<n&&t(e[r],r,e)!==!1;);return e}SJt.exports=rYe});var fst=H((JXn,MJt)=>{var nYe=l0(),iYe=function(){try{var e=nYe(Object,"defineProperty");return e({},"",{}),e}catch(t){}}();MJt.exports=iYe});var I4=H((QXn,TJt)=>{var EJt=fst();function oYe(e,t,r){t=="__proto__"&&EJt?EJt(e,t,{configurable:!0,enumerable:!0,value:r,writable:!0}):e[t]=r}TJt.exports=oYe});var L4=H((t$n,CJt)=>{var aYe=I4(),sYe=Yv(),lYe=Object.prototype,cYe=lYe.hasOwnProperty;function uYe(e,t,r){var n=e[t];(!(cYe.call(e,t)&&sYe(n,r))||r===void 0&&!(t in e))&&aYe(e,t,r)}CJt.exports=uYe});var US=H((e$n,AJt)=>{var hYe=L4(),fYe=I4();function pYe(e,t,r,n){var i=!r;r||(r={});for(var o=-1,a=t.length;++o<a;){var s=t[o],l=n?n(r[s],e[s],s,r,e):void 0;l===void 0&&(l=e[s]),i?fYe(r,s,l):hYe(r,s,l)}return r}AJt.exports=pYe});var IJt=H((r$n,PJt)=>{function dYe(e,t){for(var r=-1,n=Array(e);++r<e;)n[r]=t(r);return n}PJt.exports=dYe});var Yu=H((n$n,LJt)=>{function mYe(e){return e!=null&&typeof e=="object"}LJt.exports=mYe});var RJt=H((i$n,kJt)=>{var gYe=s0(),_Ye=Yu(),yYe="[object Arguments]";function vYe(e){return _Ye(e)&&gYe(e)==yYe}kJt.exports=vYe});var qS=H((o$n,OJt)=>{var NJt=RJt(),xYe=Yu(),DJt=Object.prototype,bYe=DJt.hasOwnProperty,wYe=DJt.propertyIsEnumerable,SYe=NJt(function(){return arguments}())?NJt:function(e){return xYe(e)&&bYe.call(e,"callee")&&!wYe.call(e,"callee")};OJt.exports=SYe});var Ti=H((a$n,zJt)=>{var MYe=Array.isArray;zJt.exports=MYe});var BJt=H((s$n,FJt)=>{function EYe(){return!1}FJt.exports=EYe});var Xv=H((k4,GS)=>{var TYe=Hc(),CYe=BJt(),UJt=typeof k4=="object"&&k4&&!k4.nodeType&&k4,HJt=UJt&&typeof GS=="object"&&GS&&!GS.nodeType&&GS,AYe=HJt&&HJt.exports===UJt,VJt=AYe?TYe.Buffer:void 0,PYe=VJt?VJt.isBuffer:void 0,IYe=PYe||CYe;GS.exports=IYe});var R4=H((l$n,qJt)=>{var LYe=9007199254740991,kYe=/^(?:0|[1-9]\d*)$/;function RYe(e,t){var r=typeof e;return t=t==null?LYe:t,!!t&&(r=="number"||r!="symbol"&&kYe.test(e))&&e>-1&&e%1==0&&e<t}qJt.exports=RYe});var HB=H((c$n,GJt)=>{var NYe=9007199254740991;function DYe(e){return typeof e=="number"&&e>-1&&e%1==0&&e<=NYe}GJt.exports=DYe});var YJt=H((u$n,WJt)=>{var OYe=s0(),zYe=HB(),FYe=Yu(),BYe="[object Arguments]",HYe="[object Array]",VYe="[object Boolean]",UYe="[object Date]",qYe="[object Error]",GYe="[object Function]",WYe="[object Map]",YYe="[object Number]",jYe="[object Object]",XYe="[object RegExp]",$Ye="[object Set]",KYe="[object String]",ZYe="[object WeakMap]",JYe="[object ArrayBuffer]",QYe="[object DataView]",tje="[object Float32Array]",eje="[object Float64Array]",rje="[object Int8Array]",nje="[object Int16Array]",ije="[object Int32Array]",oje="[object Uint8Array]",aje="[object Uint8ClampedArray]",sje="[object Uint16Array]",lje="[object Uint32Array]",Vn={};Vn[tje]=Vn[eje]=Vn[rje]=Vn[nje]=Vn[ije]=Vn[oje]=Vn[aje]=Vn[sje]=Vn[lje]=!0;Vn[BYe]=Vn[HYe]=Vn[JYe]=Vn[VYe]=Vn[QYe]=Vn[UYe]=Vn[qYe]=Vn[GYe]=Vn[WYe]=Vn[YYe]=Vn[jYe]=Vn[XYe]=Vn[$Ye]=Vn[KYe]=Vn[ZYe]=!1;function cje(e){return FYe(e)&&zYe(e.length)&&!!Vn[OYe(e)]}WJt.exports=cje});var N4=H((h$n,jJt)=>{function uje(e){return function(t){return e(t)}}jJt.exports=uje});var VB=H((D4,WS)=>{var hje=cst(),XJt=typeof D4=="object"&&D4&&!D4.nodeType&&D4,O4=XJt&&typeof WS=="object"&&WS&&!WS.nodeType&&WS,fje=O4&&O4.exports===XJt,pst=fje&&hje.process,pje=function(){try{var e=O4&&O4.require&&O4.require("util").types;return e||pst&&pst.binding&&pst.binding("util")}catch(t){}}();WS.exports=pje});var YS=H((f$n,ZJt)=>{var dje=YJt(),mje=N4(),$Jt=VB(),KJt=$Jt&&$Jt.isTypedArray,gje=KJt?mje(KJt):dje;ZJt.exports=gje});var dst=H((p$n,JJt)=>{var _je=IJt(),yje=qS(),vje=Ti(),xje=Xv(),bje=R4(),wje=YS(),Sje=Object.prototype,Mje=Sje.hasOwnProperty;function Eje(e,t){var r=vje(e),n=!r&&yje(e),i=!r&&!n&&xje(e),o=!r&&!n&&!i&&wje(e),a=r||n||i||o,s=a?_je(e.length,String):[],l=s.length;for(var c in e)(t||Mje.call(e,c))&&!(a&&(c=="length"||i&&(c=="offset"||c=="parent")||o&&(c=="buffer"||c=="byteLength"||c=="byteOffset")||bje(c,l)))&&s.push(c);return s}JJt.exports=Eje});var z4=H((d$n,QJt)=>{var Tje=Object.prototype;function Cje(e){var t=e&&e.constructor,r=typeof t=="function"&&t.prototype||Tje;return e===r}QJt.exports=Cje});var mst=H((m$n,tQt)=>{function Aje(e,t){return function(r){return e(t(r))}}tQt.exports=Aje});var rQt=H((g$n,eQt)=>{var Pje=mst(),Ije=Pje(Object.keys,Object);eQt.exports=Ije});var UB=H((_$n,nQt)=>{var Lje=z4(),kje=rQt(),Rje=Object.prototype,Nje=Rje.hasOwnProperty;function Dje(e){if(!Lje(e))return kje(e);var t=[];for(var r in Object(e))Nje.call(e,r)&&r!="constructor"&&t.push(r);return t}nQt.exports=Dje});var Bf=H((y$n,iQt)=>{var Oje=FS(),zje=HB();function Fje(e){return e!=null&&zje(e.length)&&!Oje(e)}iQt.exports=Fje});var Ad=H((v$n,oQt)=>{var Bje=dst(),Hje=UB(),Vje=Bf();function Uje(e){return Vje(e)?Bje(e):Hje(e)}oQt.exports=Uje});var sQt=H((x$n,aQt)=>{var qje=US(),Gje=Ad();function Wje(e,t){return e&&qje(t,Gje(t),e)}aQt.exports=Wje});var cQt=H((b$n,lQt)=>{function Yje(e){var t=[];if(e!=null)for(var r in Object(e))t.push(r);return t}lQt.exports=Yje});var hQt=H((w$n,uQt)=>{var jje=Ml(),Xje=z4(),$je=cQt(),Kje=Object.prototype,Zje=Kje.hasOwnProperty;function Jje(e){if(!jje(e))return $je(e);var t=Xje(e),r=[];for(var n in e)n=="constructor"&&(t||!Zje.call(e,n))||r.push(n);return r}uQt.exports=Jje});var c0=H((S$n,fQt)=>{var Qje=dst(),tXe=hQt(),eXe=Bf();function rXe(e){return eXe(e)?Qje(e,!0):tXe(e)}fQt.exports=rXe});var dQt=H((M$n,pQt)=>{var nXe=US(),iXe=c0();function oXe(e,t){return e&&nXe(t,iXe(t),e)}pQt.exports=oXe});var gst=H((F4,jS)=>{var aXe=Hc(),yQt=typeof F4=="object"&&F4&&!F4.nodeType&&F4,mQt=yQt&&typeof jS=="object"&&jS&&!jS.nodeType&&jS,sXe=mQt&&mQt.exports===yQt,gQt=sXe?aXe.Buffer:void 0,_Qt=gQt?gQt.allocUnsafe:void 0;function lXe(e,t){if(t)return e.slice();var r=e.length,n=_Qt?_Qt(r):new e.constructor(r);return e.copy(n),n}jS.exports=lXe});var _st=H((E$n,vQt)=>{function cXe(e,t){var r=-1,n=e.length;for(t||(t=Array(n));++r<n;)t[r]=e[r];return t}vQt.exports=cXe});var yst=H((T$n,xQt)=>{function uXe(e,t){for(var r=-1,n=e==null?0:e.length,i=0,o=[];++r<n;){var a=e[r];t(a,r,e)&&(o[i++]=a)}return o}xQt.exports=uXe});var vst=H((C$n,bQt)=>{function hXe(){return[]}bQt.exports=hXe});var qB=H((A$n,SQt)=>{var fXe=yst(),pXe=vst(),dXe=Object.prototype,mXe=dXe.propertyIsEnumerable,wQt=Object.getOwnPropertySymbols,gXe=wQt?function(e){return e==null?[]:(e=Object(e),fXe(wQt(e),function(t){return mXe.call(e,t)}))}:pXe;SQt.exports=gXe});var EQt=H((P$n,MQt)=>{var _Xe=US(),yXe=qB();function vXe(e,t){return _Xe(e,yXe(e),t)}MQt.exports=vXe});var GB=H((I$n,TQt)=>{function xXe(e,t){for(var r=-1,n=t.length,i=e.length;++r<n;)e[i+r]=t[r];return e}TQt.exports=xXe});var B4=H((L$n,CQt)=>{var bXe=mst(),wXe=bXe(Object.getPrototypeOf,Object);CQt.exports=wXe});var xst=H((k$n,AQt)=>{var SXe=GB(),MXe=B4(),EXe=qB(),TXe=vst(),CXe=Object.getOwnPropertySymbols,AXe=CXe?function(e){for(var t=[];e;)SXe(t,EXe(e)),e=MXe(e);return t}:TXe;AQt.exports=AXe});var IQt=H((R$n,PQt)=>{var PXe=US(),IXe=xst();function LXe(e,t){return PXe(e,IXe(e),t)}PQt.exports=LXe});var bst=H((N$n,LQt)=>{var kXe=GB(),RXe=Ti();function NXe(e,t,r){var n=t(e);return RXe(e)?n:kXe(n,r(e))}LQt.exports=NXe});var wst=H((D$n,kQt)=>{var DXe=bst(),OXe=qB(),zXe=Ad();function FXe(e){return DXe(e,zXe,OXe)}kQt.exports=FXe});var NQt=H((O$n,RQt)=>{var BXe=bst(),HXe=xst(),VXe=c0();function UXe(e){return BXe(e,VXe,HXe)}RQt.exports=UXe});var OQt=H((z$n,DQt)=>{var qXe=l0(),GXe=Hc(),WXe=qXe(GXe,"DataView");DQt.exports=WXe});var FQt=H((F$n,zQt)=>{var YXe=l0(),jXe=Hc(),XXe=YXe(jXe,"Promise");zQt.exports=XXe});var Sst=H((B$n,BQt)=>{var $Xe=l0(),KXe=Hc(),ZXe=$Xe(KXe,"Set");BQt.exports=ZXe});var VQt=H((H$n,HQt)=>{var JXe=l0(),QXe=Hc(),t$e=JXe(QXe,"WeakMap");HQt.exports=t$e});var Kv=H((V$n,XQt)=>{var Mst=OQt(),Est=zB(),Tst=FQt(),Cst=Sst(),Ast=VQt(),jQt=s0(),XS=hst(),UQt="[object Map]",e$e="[object Object]",qQt="[object Promise]",GQt="[object Set]",WQt="[object WeakMap]",YQt="[object DataView]",r$e=XS(Mst),n$e=XS(Est),i$e=XS(Tst),o$e=XS(Cst),a$e=XS(Ast),$v=jQt;(Mst&&$v(new Mst(new ArrayBuffer(1)))!=YQt||Est&&$v(new Est)!=UQt||Tst&&$v(Tst.resolve())!=qQt||Cst&&$v(new Cst)!=GQt||Ast&&$v(new Ast)!=WQt)&&($v=function(e){var t=jQt(e),r=t==e$e?e.constructor:void 0,n=r?XS(r):"";if(n)switch(n){case r$e:return YQt;case n$e:return UQt;case i$e:return qQt;case o$e:return GQt;case a$e:return WQt}return t});XQt.exports=$v});var KQt=H((U$n,$Qt)=>{var s$e=Object.prototype,l$e=s$e.hasOwnProperty;function c$e(e){var t=e.length,r=new e.constructor(t);return t&&typeof e[0]=="string"&&l$e.call(e,"index")&&(r.index=e.index,r.input=e.input),r}$Qt.exports=c$e});var Pst=H((q$n,ZQt)=>{var u$e=Hc(),h$e=u$e.Uint8Array;ZQt.exports=h$e});var WB=H((G$n,QQt)=>{var JQt=Pst();function f$e(e){var t=new e.constructor(e.byteLength);return new JQt(t).set(new JQt(e)),t}QQt.exports=f$e});var ete=H((W$n,tte)=>{var p$e=WB();function d$e(e,t){var r=t?p$e(e.buffer):e.buffer;return new e.constructor(r,e.byteOffset,e.byteLength)}tte.exports=d$e});var nte=H((Y$n,rte)=>{var m$e=/\w*$/;function g$e(e){var t=new e.constructor(e.source,m$e.exec(e));return t.lastIndex=e.lastIndex,t}rte.exports=g$e});var lte=H((j$n,ste)=>{var ite=jv(),ote=ite?ite.prototype:void 0,ate=ote?ote.valueOf:void 0;function _$e(e){return ate?Object(ate.call(e)):{}}ste.exports=_$e});var Ist=H((X$n,cte)=>{var y$e=WB();function v$e(e,t){var r=t?y$e(e.buffer):e.buffer;return new e.constructor(r,e.byteOffset,e.length)}cte.exports=v$e});var hte=H(($$n,ute)=>{var x$e=WB(),b$e=ete(),w$e=nte(),S$e=lte(),M$e=Ist(),E$e="[object Boolean]",T$e="[object Date]",C$e="[object Map]",A$e="[object Number]",P$e="[object RegExp]",I$e="[object Set]",L$e="[object String]",k$e="[object Symbol]",R$e="[object ArrayBuffer]",N$e="[object DataView]",D$e="[object Float32Array]",O$e="[object Float64Array]",z$e="[object Int8Array]",F$e="[object Int16Array]",B$e="[object Int32Array]",H$e="[object Uint8Array]",V$e="[object Uint8ClampedArray]",U$e="[object Uint16Array]",q$e="[object Uint32Array]";function G$e(e,t,r){var n=e.constructor;switch(t){case R$e:return x$e(e);case E$e:case T$e:return new n(+e);case N$e:return b$e(e,r);case D$e:case O$e:case z$e:case F$e:case B$e:case H$e:case V$e:case U$e:case q$e:return M$e(e,r);case C$e:return new n;case A$e:case L$e:return new n(e);case P$e:return w$e(e);case I$e:return new n;case k$e:return S$e(e)}}ute.exports=G$e});var Lst=H((K$n,pte)=>{var W$e=Ml(),fte=Object.create,Y$e=function(){function e(){}return function(t){if(!W$e(t))return{};if(fte)return fte(t);e.prototype=t;var r=new e;return e.prototype=void 0,r}}();pte.exports=Y$e});var kst=H((Z$n,dte)=>{var j$e=Lst(),X$e=B4(),$$e=z4();function K$e(e){return typeof e.constructor=="function"&&!$$e(e)?j$e(X$e(e)):{}}dte.exports=K$e});var gte=H((J$n,mte)=>{var Z$e=Kv(),J$e=Yu(),Q$e="[object Map]";function tKe(e){return J$e(e)&&Z$e(e)==Q$e}mte.exports=tKe});var xte=H((Q$n,vte)=>{var eKe=gte(),rKe=N4(),_te=VB(),yte=_te&&_te.isMap,nKe=yte?rKe(yte):eKe;vte.exports=nKe});var wte=H((tKn,bte)=>{var iKe=Kv(),oKe=Yu(),aKe="[object Set]";function sKe(e){return oKe(e)&&iKe(e)==aKe}bte.exports=sKe});var Tte=H((eKn,Ete)=>{var lKe=wte(),cKe=N4(),Ste=VB(),Mte=Ste&&Ste.isSet,uKe=Mte?cKe(Mte):lKe;Ete.exports=uKe});var Rst=H((rKn,Ite)=>{var hKe=P4(),fKe=BB(),pKe=L4(),dKe=sQt(),mKe=dQt(),gKe=gst(),_Ke=_st(),yKe=EQt(),vKe=IQt(),xKe=wst(),bKe=NQt(),wKe=Kv(),SKe=KQt(),MKe=hte(),EKe=kst(),TKe=Ti(),CKe=Xv(),AKe=xte(),PKe=Ml(),IKe=Tte(),LKe=Ad(),kKe=c0(),RKe=1,NKe=2,DKe=4,Cte="[object Arguments]",OKe="[object Array]",zKe="[object Boolean]",FKe="[object Date]",BKe="[object Error]",Ate="[object Function]",HKe="[object GeneratorFunction]",VKe="[object Map]",UKe="[object Number]",Pte="[object Object]",qKe="[object RegExp]",GKe="[object Set]",WKe="[object String]",YKe="[object Symbol]",jKe="[object WeakMap]",XKe="[object ArrayBuffer]",$Ke="[object DataView]",KKe="[object Float32Array]",ZKe="[object Float64Array]",JKe="[object Int8Array]",QKe="[object Int16Array]",tZe="[object Int32Array]",eZe="[object Uint8Array]",rZe="[object Uint8ClampedArray]",nZe="[object Uint16Array]",iZe="[object Uint32Array]",Cn={};Cn[Cte]=Cn[OKe]=Cn[XKe]=Cn[$Ke]=Cn[zKe]=Cn[FKe]=Cn[KKe]=Cn[ZKe]=Cn[JKe]=Cn[QKe]=Cn[tZe]=Cn[VKe]=Cn[UKe]=Cn[Pte]=Cn[qKe]=Cn[GKe]=Cn[WKe]=Cn[YKe]=Cn[eZe]=Cn[rZe]=Cn[nZe]=Cn[iZe]=!0;Cn[BKe]=Cn[Ate]=Cn[jKe]=!1;function YB(e,t,r,n,i,o){var a,s=t&RKe,l=t&NKe,c=t&DKe;if(r&&(a=i?r(e,n,i,o):r(e)),a!==void 0)return a;if(!PKe(e))return e;var u=TKe(e);if(u){if(a=SKe(e),!s)return _Ke(e,a)}else{var h=wKe(e),f=h==Ate||h==HKe;if(CKe(e))return gKe(e,s);if(h==Pte||h==Cte||f&&!i){if(a=l||f?{}:EKe(e),!s)return l?vKe(e,mKe(a,e)):yKe(e,dKe(a,e))}else{if(!Cn[h])return i?e:{};a=MKe(e,h,s)}}o||(o=new hKe);var p=o.get(e);if(p)return p;o.set(e,a),IKe(e)?e.forEach(function(_){a.add(YB(_,t,r,_,e,o))}):AKe(e)&&e.forEach(function(_,y){a.set(y,YB(_,t,r,y,e,o))});var d=c?l?bKe:xKe:l?kKe:LKe,g=u?void 0:d(e);return fKe(g||e,function(_,y){g&&(y=_,_=e[y]),pKe(a,y,YB(_,t,r,y,e,o))}),a}Ite.exports=YB});var kte=H((nKn,Lte)=>{var oZe=Rst(),aZe=4;function sZe(e){return oZe(e,aZe)}Lte.exports=sZe});var jB=H((iKn,Rte)=>{function lZe(e){return function(){return e}}Rte.exports=lZe});var Dte=H((oKn,Nte)=>{function cZe(e){return function(t,r,n){for(var i=-1,o=Object(t),a=n(t),s=a.length;s--;){var l=a[e?s:++i];if(r(o[l],l,o)===!1)break}return t}}Nte.exports=cZe});var XB=H((aKn,Ote)=>{var uZe=Dte(),hZe=uZe();Ote.exports=hZe});var $B=H((sKn,zte)=>{var fZe=XB(),pZe=Ad();function dZe(e,t){return e&&fZe(e,t,pZe)}zte.exports=dZe});var Bte=H((lKn,Fte)=>{var mZe=Bf();function gZe(e,t){return function(r,n){if(r==null)return r;if(!mZe(r))return e(r,n);for(var i=r.length,o=t?i:-1,a=Object(r);(t?o--:++o<i)&&n(a[o],o,a)!==!1;);return r}}Fte.exports=gZe});var H4=H((cKn,Hte)=>{var _Ze=$B(),yZe=Bte(),vZe=yZe(_Ze);Hte.exports=vZe});var u0=H((uKn,Vte)=>{function xZe(e){return e}Vte.exports=xZe});var Nst=H((hKn,Ute)=>{var bZe=u0();function wZe(e){return typeof e=="function"?e:bZe}Ute.exports=wZe});var Dst=H((fKn,qte)=>{var SZe=BB(),MZe=H4(),EZe=Nst(),TZe=Ti();function CZe(e,t){var r=TZe(e)?SZe:MZe;return r(e,EZe(t))}qte.exports=CZe});var Ost=H((pKn,Gte)=>{Gte.exports=Dst()});var Yte=H((dKn,Wte)=>{var AZe=H4();function PZe(e,t){var r=[];return AZe(e,function(n,i,o){t(n,i,o)&&r.push(n)}),r}Wte.exports=PZe});var Xte=H((mKn,jte)=>{var IZe="__lodash_hash_undefined__";function LZe(e){return this.__data__.set(e,IZe),this}jte.exports=LZe});var Kte=H((gKn,$te)=>{function kZe(e){return this.__data__.has(e)}$te.exports=kZe});var zst=H((_Kn,Zte)=>{var RZe=FB(),NZe=Xte(),DZe=Kte();function KB(e){var t=-1,r=e==null?0:e.length;for(this.__data__=new RZe;++t<r;)this.add(e[t])}KB.prototype.add=KB.prototype.push=NZe;KB.prototype.has=DZe;Zte.exports=KB});var Qte=H((yKn,Jte)=>{function OZe(e,t){for(var r=-1,n=e==null?0:e.length;++r<n;)if(t(e[r],r,e))return!0;return!1}Jte.exports=OZe});var Fst=H((vKn,tee)=>{function zZe(e,t){return e.has(t)}tee.exports=zZe});var Bst=H((xKn,eee)=>{var FZe=zst(),BZe=Qte(),HZe=Fst(),VZe=1,UZe=2;function qZe(e,t,r,n,i,o){var a=r&VZe,s=e.length,l=t.length;if(s!=l&&!(a&&l>s))return!1;var c=o.get(e),u=o.get(t);if(c&&u)return c==t&&u==e;var h=-1,f=!0,p=r&UZe?new FZe:void 0;for(o.set(e,t),o.set(t,e);++h<s;){var d=e[h],g=t[h];if(n)var _=a?n(g,d,h,t,e,o):n(d,g,h,e,t,o);if(_!==void 0){if(_)continue;f=!1;break}if(p){if(!BZe(t,function(y,x){if(!HZe(p,x)&&(d===y||i(d,y,r,n,o)))return p.push(x)})){f=!1;break}}else if(!(d===g||i(d,g,r,n,o))){f=!1;break}}return o.delete(e),o.delete(t),f}eee.exports=qZe});var nee=H((bKn,ree)=>{function GZe(e){var t=-1,r=Array(e.size);return e.forEach(function(n,i){r[++t]=[i,n]}),r}ree.exports=GZe});var ZB=H((wKn,iee)=>{function WZe(e){var t=-1,r=Array(e.size);return e.forEach(function(n){r[++t]=n}),r}iee.exports=WZe});var cee=H((SKn,lee)=>{var oee=jv(),aee=Pst(),YZe=Yv(),jZe=Bst(),XZe=nee(),$Ze=ZB(),KZe=1,ZZe=2,JZe="[object Boolean]",QZe="[object Date]",tJe="[object Error]",eJe="[object Map]",rJe="[object Number]",nJe="[object RegExp]",iJe="[object Set]",oJe="[object String]",aJe="[object Symbol]",sJe="[object ArrayBuffer]",lJe="[object DataView]",see=oee?oee.prototype:void 0,Hst=see?see.valueOf:void 0;function cJe(e,t,r,n,i,o,a){switch(r){case lJe:if(e.byteLength!=t.byteLength||e.byteOffset!=t.byteOffset)return!1;e=e.buffer,t=t.buffer;case sJe:return!(e.byteLength!=t.byteLength||!o(new aee(e),new aee(t)));case JZe:case QZe:case rJe:return YZe(+e,+t);case tJe:return e.name==t.name&&e.message==t.message;case nJe:case oJe:return e==t+"";case eJe:var s=XZe;case iJe:var l=n&KZe;if(s||(s=$Ze),e.size!=t.size&&!l)return!1;var c=a.get(e);if(c)return c==t;n|=ZZe,a.set(e,t);var u=jZe(s(e),s(t),n,i,o,a);return a.delete(e),u;case aJe:if(Hst)return Hst.call(e)==Hst.call(t)}return!1}lee.exports=cJe});var fee=H((MKn,hee)=>{var uee=wst(),uJe=1,hJe=Object.prototype,fJe=hJe.hasOwnProperty;function pJe(e,t,r,n,i,o){var a=r&uJe,s=uee(e),l=s.length,c=uee(t),u=c.length;if(l!=u&&!a)return!1;for(var h=l;h--;){var f=s[h];if(!(a?f in t:fJe.call(t,f)))return!1}var p=o.get(e),d=o.get(t);if(p&&d)return p==t&&d==e;var g=!0;o.set(e,t),o.set(t,e);for(var _=a;++h<l;){f=s[h];var y=e[f],x=t[f];if(n)var b=a?n(x,y,f,t,e,o):n(y,x,f,e,t,o);if(!(b===void 0?y===x||i(y,x,r,n,o):b)){g=!1;break}_||(_=f=="constructor")}if(g&&!_){var S=e.constructor,C=t.constructor;S!=C&&"constructor"in e&&"constructor"in t&&!(typeof S=="function"&&S instanceof S&&typeof C=="function"&&C instanceof C)&&(g=!1)}return o.delete(e),o.delete(t),g}hee.exports=pJe});var xee=H((EKn,vee)=>{var Vst=P4(),dJe=Bst(),mJe=cee(),gJe=fee(),pee=Kv(),dee=Ti(),mee=Xv(),_Je=YS(),yJe=1,gee="[object Arguments]",_ee="[object Array]",JB="[object Object]",vJe=Object.prototype,yee=vJe.hasOwnProperty;function xJe(e,t,r,n,i,o){var a=dee(e),s=dee(t),l=a?_ee:pee(e),c=s?_ee:pee(t);l=l==gee?JB:l,c=c==gee?JB:c;var u=l==JB,h=c==JB,f=l==c;if(f&&mee(e)){if(!mee(t))return!1;a=!0,u=!1}if(f&&!u)return o||(o=new Vst),a||_Je(e)?dJe(e,t,r,n,i,o):mJe(e,t,l,r,n,i,o);if(!(r&yJe)){var p=u&&yee.call(e,"__wrapped__"),d=h&&yee.call(t,"__wrapped__");if(p||d){var g=p?e.value():e,_=d?t.value():t;return o||(o=new Vst),i(g,_,r,n,o)}}return f?(o||(o=new Vst),gJe(e,t,r,n,i,o)):!1}vee.exports=xJe});var Ust=H((TKn,See)=>{var bJe=xee(),bee=Yu();function wee(e,t,r,n,i){return e===t?!0:e==null||t==null||!bee(e)&&!bee(t)?e!==e&&t!==t:bJe(e,t,r,n,wee,i)}See.exports=wee});var Eee=H((CKn,Mee)=>{var wJe=P4(),SJe=Ust(),MJe=1,EJe=2;function TJe(e,t,r,n){var i=r.length,o=i,a=!n;if(e==null)return!o;for(e=Object(e);i--;){var s=r[i];if(a&&s[2]?s[1]!==e[s[0]]:!(s[0]in e))return!1}for(;++i<o;){s=r[i];var l=s[0],c=e[l],u=s[1];if(a&&s[2]){if(c===void 0&&!(l in e))return!1}else{var h=new wJe;if(n)var f=n(c,u,l,e,t,h);if(!(f===void 0?SJe(u,c,MJe|EJe,n,h):f))return!1}}return!0}Mee.exports=TJe});var qst=H((AKn,Tee)=>{var CJe=Ml();function AJe(e){return e===e&&!CJe(e)}Tee.exports=AJe});var Aee=H((PKn,Cee)=>{var PJe=qst(),IJe=Ad();function LJe(e){for(var t=IJe(e),r=t.length;r--;){var n=t[r],i=e[n];t[r]=[n,i,PJe(i)]}return t}Cee.exports=LJe});var Gst=H((IKn,Pee)=>{function kJe(e,t){return function(r){return r==null?!1:r[e]===t&&(t!==void 0||e in Object(r))}}Pee.exports=kJe});var Lee=H((LKn,Iee)=>{var RJe=Eee(),NJe=Aee(),DJe=Gst();function OJe(e){var t=NJe(e);return t.length==1&&t[0][2]?DJe(t[0][0],t[0][1]):function(r){return r===e||RJe(r,e,t)}}Iee.exports=OJe});var Zv=H((kKn,kee)=>{var zJe=s0(),FJe=Yu(),BJe="[object Symbol]";function HJe(e){return typeof e=="symbol"||FJe(e)&&zJe(e)==BJe}kee.exports=HJe});var QB=H((RKn,Ree)=>{var VJe=Ti(),UJe=Zv(),qJe=/\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,GJe=/^\w*$/;function WJe(e,t){if(VJe(e))return!1;var r=typeof e;return r=="number"||r=="symbol"||r=="boolean"||e==null||UJe(e)?!0:GJe.test(e)||!qJe.test(e)||t!=null&&e in Object(t)}Ree.exports=WJe});var Oee=H((NKn,Dee)=>{var Nee=FB(),YJe="Expected a function";function Wst(e,t){if(typeof e!="function"||t!=null&&typeof t!="function")throw new TypeError(YJe);var r=function(){var n=arguments,i=t?t.apply(this,n):n[0],o=r.cache;if(o.has(i))return o.get(i);var a=e.apply(this,n);return r.cache=o.set(i,a)||o,a};return r.cache=new(Wst.Cache||Nee),r}Wst.Cache=Nee;Dee.exports=Wst});var Fee=H((DKn,zee)=>{var jJe=Oee(),XJe=500;function $Je(e){var t=jJe(e,function(n){return r.size===XJe&&r.clear(),n}),r=t.cache;return t}zee.exports=$Je});var Hee=H((OKn,Bee)=>{var KJe=Fee(),ZJe=/[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g,JJe=/\\(\\)?/g,QJe=KJe(function(e){var t=[];return e.charCodeAt(0)===46&&t.push(""),e.replace(ZJe,function(r,n,i,o){t.push(i?o.replace(JJe,"$1"):n||r)}),t});Bee.exports=QJe});var V4=H((zKn,Vee)=>{function tQe(e,t){for(var r=-1,n=e==null?0:e.length,i=Array(n);++r<n;)i[r]=t(e[r],r,e);return i}Vee.exports=tQe});var jee=H((FKn,Yee)=>{var Uee=jv(),eQe=V4(),rQe=Ti(),nQe=Zv(),iQe=1/0,qee=Uee?Uee.prototype:void 0,Gee=qee?qee.toString:void 0;function Wee(e){if(typeof e=="string")return e;if(rQe(e))return eQe(e,Wee)+"";if(nQe(e))return Gee?Gee.call(e):"";var t=e+"";return t=="0"&&1/e==-iQe?"-0":t}Yee.exports=Wee});var Yst=H((BKn,Xee)=>{var oQe=jee();function aQe(e){return e==null?"":oQe(e)}Xee.exports=aQe});var U4=H((HKn,$ee)=>{var sQe=Ti(),lQe=QB(),cQe=Hee(),uQe=Yst();function hQe(e,t){return sQe(e)?e:lQe(e,t)?[e]:cQe(uQe(e))}$ee.exports=hQe});var $S=H((VKn,Kee)=>{var fQe=Zv(),pQe=1/0;function dQe(e){if(typeof e=="string"||fQe(e))return e;var t=e+"";return t=="0"&&1/e==-pQe?"-0":t}Kee.exports=dQe});var q4=H((UKn,Zee)=>{var mQe=U4(),gQe=$S();function _Qe(e,t){t=mQe(t,e);for(var r=0,n=t.length;e!=null&&r<n;)e=e[gQe(t[r++])];return r&&r==n?e:void 0}Zee.exports=_Qe});var Qee=H((qKn,Jee)=>{var yQe=q4();function vQe(e,t,r){var n=e==null?void 0:yQe(e,t);return n===void 0?r:n}Jee.exports=vQe});var ere=H((GKn,tre)=>{function xQe(e,t){return e!=null&&t in Object(e)}tre.exports=xQe});var jst=H((WKn,rre)=>{var bQe=U4(),wQe=qS(),SQe=Ti(),MQe=R4(),EQe=HB(),TQe=$S();function CQe(e,t,r){t=bQe(t,e);for(var n=-1,i=t.length,o=!1;++n<i;){var a=TQe(t[n]);if(!(o=e!=null&&r(e,a)))break;e=e[a]}return o||++n!=i?o:(i=e==null?0:e.length,!!i&&EQe(i)&&MQe(a,i)&&(SQe(e)||wQe(e)))}rre.exports=CQe});var Xst=H((YKn,nre)=>{var AQe=ere(),PQe=jst();function IQe(e,t){return e!=null&&PQe(e,t,AQe)}nre.exports=IQe});var ore=H((jKn,ire)=>{var LQe=Ust(),kQe=Qee(),RQe=Xst(),NQe=QB(),DQe=qst(),OQe=Gst(),zQe=$S(),FQe=1,BQe=2;function HQe(e,t){return NQe(e)&&DQe(t)?OQe(zQe(e),t):function(r){var n=kQe(r,e);return n===void 0&&n===t?RQe(r,e):LQe(t,n,FQe|BQe)}}ire.exports=HQe});var $st=H((XKn,are)=>{function VQe(e){return function(t){return t==null?void 0:t[e]}}are.exports=VQe});var lre=H(($Kn,sre)=>{var UQe=q4();function qQe(e){return function(t){return UQe(t,e)}}sre.exports=qQe});var ure=H((KKn,cre)=>{var GQe=$st(),WQe=lre(),YQe=QB(),jQe=$S();function XQe(e){return YQe(e)?GQe(jQe(e)):WQe(e)}cre.exports=XQe});var Hf=H((ZKn,hre)=>{var $Qe=Lee(),KQe=ore(),ZQe=u0(),JQe=Ti(),QQe=ure();function ttr(e){return typeof e=="function"?e:e==null?ZQe:typeof e=="object"?JQe(e)?KQe(e[0],e[1]):$Qe(e):QQe(e)}hre.exports=ttr});var Kst=H((JKn,fre)=>{var etr=yst(),rtr=Yte(),ntr=Hf(),itr=Ti();function otr(e,t){var r=itr(e)?etr:rtr;return r(e,ntr(t,3))}fre.exports=otr});var dre=H((QKn,pre)=>{var atr=Object.prototype,str=atr.hasOwnProperty;function ltr(e,t){return e!=null&&str.call(e,t)}pre.exports=ltr});var Zst=H((tZn,mre)=>{var ctr=dre(),utr=jst();function htr(e,t){return e!=null&&utr(e,t,ctr)}mre.exports=htr});var _re=H((eZn,gre)=>{var ftr=UB(),ptr=Kv(),dtr=qS(),mtr=Ti(),gtr=Bf(),_tr=Xv(),ytr=z4(),vtr=YS(),xtr="[object Map]",btr="[object Set]",wtr=Object.prototype,Str=wtr.hasOwnProperty;function Mtr(e){if(e==null)return!0;if(gtr(e)&&(mtr(e)||typeof e=="string"||typeof e.splice=="function"||_tr(e)||vtr(e)||dtr(e)))return!e.length;var t=ptr(e);if(t==xtr||t==btr)return!e.size;if(ytr(e))return!ftr(e).length;for(var r in e)if(Str.call(e,r))return!1;return!0}gre.exports=Mtr});var Jst=H((rZn,yre)=>{function Etr(e){return e===void 0}yre.exports=Etr});var Qst=H((nZn,vre)=>{var Ttr=H4(),Ctr=Bf();function Atr(e,t){var r=-1,n=Ctr(e)?Array(e.length):[];return Ttr(e,function(i,o,a){n[++r]=t(i,o,a)}),n}vre.exports=Atr});var tlt=H((iZn,xre)=>{var Ptr=V4(),Itr=Hf(),Ltr=Qst(),ktr=Ti();function Rtr(e,t){var r=ktr(e)?Ptr:Ltr;return r(e,Itr(t,3))}xre.exports=Rtr});var wre=H((oZn,bre)=>{function Ntr(e,t,r,n){var i=-1,o=e==null?0:e.length;for(n&&o&&(r=e[++i]);++i<o;)r=t(r,e[i],i,e);return r}bre.exports=Ntr});var Mre=H((aZn,Sre)=>{function Dtr(e,t,r,n,i){return i(e,function(o,a,s){r=n?(n=!1,o):t(r,o,a,s)}),r}Sre.exports=Dtr});var elt=H((sZn,Ere)=>{var Otr=wre(),ztr=H4(),Ftr=Hf(),Btr=Mre(),Htr=Ti();function Vtr(e,t,r){var n=Htr(e)?Otr:Btr,i=arguments.length<3;return n(e,Ftr(t,4),r,i,ztr)}Ere.exports=Vtr});var Cre=H((lZn,Tre)=>{var Utr=s0(),qtr=Ti(),Gtr=Yu(),Wtr="[object String]";function Ytr(e){return typeof e=="string"||!qtr(e)&&Gtr(e)&&Utr(e)==Wtr}Tre.exports=Ytr});var Pre=H((cZn,Are)=>{var jtr=$st(),Xtr=jtr("length");Are.exports=Xtr});var Lre=H((uZn,Ire)=>{var $tr="\\ud800-\\udfff",Ktr="\\u0300-\\u036f",Ztr="\\ufe20-\\ufe2f",Jtr="\\u20d0-\\u20ff",Qtr=Ktr+Ztr+Jtr,ter="\\ufe0e\\ufe0f",eer="\\u200d",rer=RegExp("["+eer+$tr+Qtr+ter+"]");function ner(e){return rer.test(e)}Ire.exports=ner});var Hre=H((hZn,Bre)=>{var Rre="\\ud800-\\udfff",ier="\\u0300-\\u036f",oer="\\ufe20-\\ufe2f",aer="\\u20d0-\\u20ff",ser=ier+oer+aer,ler="\\ufe0e\\ufe0f",cer="["+Rre+"]",rlt="["+ser+"]",nlt="\\ud83c[\\udffb-\\udfff]",uer="(?:"+rlt+"|"+nlt+")",Nre="[^"+Rre+"]",Dre="(?:\\ud83c[\\udde6-\\uddff]){2}",Ore="[\\ud800-\\udbff][\\udc00-\\udfff]",her="\\u200d",zre=uer+"?",Fre="["+ler+"]?",fer="(?:"+her+"(?:"+[Nre,Dre,Ore].join("|")+")"+Fre+zre+")*",per=Fre+zre+fer,der="(?:"+[Nre+rlt+"?",rlt,Dre,Ore,cer].join("|")+")",kre=RegExp(nlt+"(?="+nlt+")|"+der+per,"g");function mer(e){for(var t=kre.lastIndex=0;kre.test(e);)++t;return t}Bre.exports=mer});var Ure=H((fZn,Vre)=>{var ger=Pre(),_er=Lre(),yer=Hre();function ver(e){return _er(e)?yer(e):ger(e)}Vre.exports=ver});var Gre=H((pZn,qre)=>{var xer=UB(),ber=Kv(),wer=Bf(),Ser=Cre(),Mer=Ure(),Eer="[object Map]",Ter="[object Set]";function Cer(e){if(e==null)return 0;if(wer(e))return Ser(e)?Mer(e):e.length;var t=ber(e);return t==Eer||t==Ter?e.size:xer(e).length}qre.exports=Cer});var Yre=H((dZn,Wre)=>{var Aer=BB(),Per=Lst(),Ier=$B(),Ler=Hf(),ker=B4(),Rer=Ti(),Ner=Xv(),Der=FS(),Oer=Ml(),zer=YS();function Fer(e,t,r){var n=Rer(e),i=n||Ner(e)||zer(e);if(t=Ler(t,4),r==null){var o=e&&e.constructor;i?r=n?new o:[]:Oer(e)?r=Der(o)?Per(ker(e)):{}:r={}}return(i?Aer:Ier)(e,function(a,s,l){return t(r,a,s,l)}),r}Wre.exports=Fer});var Kre=H((mZn,$re)=>{var jre=jv(),Ber=qS(),Her=Ti(),Xre=jre?jre.isConcatSpreadable:void 0;function Ver(e){return Her(e)||Ber(e)||!!(Xre&&e&&e[Xre])}$re.exports=Ver});var tH=H((gZn,Jre)=>{var Uer=GB(),qer=Kre();function Zre(e,t,r,n,i){var o=-1,a=e.length;for(r||(r=qer),i||(i=[]);++o<a;){var s=e[o];t>0&&r(s)?t>1?Zre(s,t-1,r,n,i):Uer(i,s):n||(i[i.length]=s)}return i}Jre.exports=Zre});var tne=H((_Zn,Qre)=>{function Ger(e,t,r){switch(r.length){case 0:return e.call(t);case 1:return e.call(t,r[0]);case 2:return e.call(t,r[0],r[1]);case 3:return e.call(t,r[0],r[1],r[2])}return e.apply(t,r)}Qre.exports=Ger});var ilt=H((yZn,rne)=>{var Wer=tne(),ene=Math.max;function Yer(e,t,r){return t=ene(t===void 0?e.length-1:t,0),function(){for(var n=arguments,i=-1,o=ene(n.length-t,0),a=Array(o);++i<o;)a[i]=n[t+i];i=-1;for(var s=Array(t+1);++i<t;)s[i]=n[i];return s[t]=r(a),Wer(e,this,s)}}rne.exports=Yer});var one=H((vZn,ine)=>{var jer=jB(),nne=fst(),Xer=u0(),$er=nne?function(e,t){return nne(e,"toString",{configurable:!0,enumerable:!1,value:jer(t),writable:!0})}:Xer;ine.exports=$er});var sne=H((xZn,ane)=>{var Ker=800,Zer=16,Jer=Date.now;function Qer(e){var t=0,r=0;return function(){var n=Jer(),i=Zer-(n-r);if(r=n,i>0){if(++t>=Ker)return arguments[0]}else t=0;return e.apply(void 0,arguments)}}ane.exports=Qer});var olt=H((bZn,lne)=>{var trr=one(),err=sne(),rrr=err(trr);lne.exports=rrr});var G4=H((wZn,cne)=>{var nrr=u0(),irr=ilt(),orr=olt();function arr(e,t){return orr(irr(e,t,nrr),e+"")}cne.exports=arr});var alt=H((SZn,une)=>{function srr(e,t,r,n){for(var i=e.length,o=r+(n?1:-1);n?o--:++o<i;)if(t(e[o],o,e))return o;return-1}une.exports=srr});var fne=H((MZn,hne)=>{function lrr(e){return e!==e}hne.exports=lrr});var dne=H((EZn,pne)=>{function crr(e,t,r){for(var n=r-1,i=e.length;++n<i;)if(e[n]===t)return n;return-1}pne.exports=crr});var gne=H((TZn,mne)=>{var urr=alt(),hrr=fne(),frr=dne();function prr(e,t,r){return t===t?frr(e,t,r):urr(e,hrr,r)}mne.exports=prr});var yne=H((CZn,_ne)=>{var drr=gne();function mrr(e,t){var r=e==null?0:e.length;return!!r&&drr(e,t,0)>-1}_ne.exports=mrr});var xne=H((AZn,vne)=>{function grr(e,t,r){for(var n=-1,i=e==null?0:e.length;++n<i;)if(r(t,e[n]))return!0;return!1}vne.exports=grr});var wne=H((PZn,bne)=>{function _rr(){}bne.exports=_rr});var Mne=H((IZn,Sne)=>{var slt=Sst(),yrr=wne(),vrr=ZB(),xrr=1/0,brr=slt&&1/vrr(new slt([,-0]))[1]==xrr?function(e){return new slt(e)}:yrr;Sne.exports=brr});var Tne=H((LZn,Ene)=>{var wrr=zst(),Srr=yne(),Mrr=xne(),Err=Fst(),Trr=Mne(),Crr=ZB(),Arr=200;function Prr(e,t,r){var n=-1,i=Srr,o=e.length,a=!0,s=[],l=s;if(r)a=!1,i=Mrr;else if(o>=Arr){var c=t?null:Trr(e);if(c)return Crr(c);a=!1,i=Err,l=new wrr}else l=t?[]:s;t:for(;++n<o;){var u=e[n],h=t?t(u):u;if(u=r||u!==0?u:0,a&&h===h){for(var f=l.length;f--;)if(l[f]===h)continue t;t&&l.push(h),s.push(u)}else i(l,h,r)||(l!==s&&l.push(h),s.push(u))}return s}Ene.exports=Prr});var llt=H((kZn,Cne)=>{var Irr=Bf(),Lrr=Yu();function krr(e){return Lrr(e)&&Irr(e)}Cne.exports=krr});var Pne=H((RZn,Ane)=>{var Rrr=tH(),Nrr=G4(),Drr=Tne(),Orr=llt(),zrr=Nrr(function(e){return Drr(Rrr(e,1,Orr,!0))});Ane.exports=zrr});var Lne=H((NZn,Ine)=>{var Frr=V4();function Brr(e,t){return Frr(t,function(r){return e[r]})}Ine.exports=Brr});var clt=H((DZn,kne)=>{var Hrr=Lne(),Vrr=Ad();function Urr(e){return e==null?[]:Hrr(e,Vrr(e))}kne.exports=Urr});var El=H((OZn,Rne)=>{var eH;if(typeof Ex=="function")try{eH={clone:kte(),constant:jB(),each:Ost(),filter:Kst(),has:Zst(),isArray:Ti(),isEmpty:_re(),isFunction:FS(),isUndefined:Jst(),keys:Ad(),map:tlt(),reduce:elt(),size:Gre(),transform:Yre(),union:Pne(),values:clt()}}catch(e){}eH||(eH=window._);Rne.exports=eH});var rH=H((FZn,zne)=>{"use strict";var je=El();zne.exports=cr;var qrr="\0",Jv="\0",Nne="";function cr(e){this._isDirected=je.has(e,"directed")?e.directed:!0,this._isMultigraph=je.has(e,"multigraph")?e.multigraph:!1,this._isCompound=je.has(e,"compound")?e.compound:!1,this._label=void 0,this._defaultNodeLabelFn=je.constant(void 0),this._defaultEdgeLabelFn=je.constant(void 0),this._nodes={},this._isCompound&&(this._parent={},this._children={},this._children[Jv]={}),this._in={},this._preds={},this._out={},this._sucs={},this._edgeObjs={},this._edgeLabels={}}cr.prototype._nodeCount=0;cr.prototype._edgeCount=0;cr.prototype.isDirected=function(){return this._isDirected};cr.prototype.isMultigraph=function(){return this._isMultigraph};cr.prototype.isCompound=function(){return this._isCompound};cr.prototype.setGraph=function(e){return this._label=e,this};cr.prototype.graph=function(){return this._label};cr.prototype.setDefaultNodeLabel=function(e){return je.isFunction(e)||(e=je.constant(e)),this._defaultNodeLabelFn=e,this};cr.prototype.nodeCount=function(){return this._nodeCount};cr.prototype.nodes=function(){return je.keys(this._nodes)};cr.prototype.sources=function(){var e=this;return je.filter(this.nodes(),function(t){return je.isEmpty(e._in[t])})};cr.prototype.sinks=function(){var e=this;return je.filter(this.nodes(),function(t){return je.isEmpty(e._out[t])})};cr.prototype.setNodes=function(e,t){var r=arguments,n=this;return je.each(e,function(i){r.length>1?n.setNode(i,t):n.setNode(i)}),this};cr.prototype.setNode=function(e,t){return je.has(this._nodes,e)?(arguments.length>1&&(this._nodes[e]=t),this):(this._nodes[e]=arguments.length>1?t:this._defaultNodeLabelFn(e),this._isCompound&&(this._parent[e]=Jv,this._children[e]={},this._children[Jv][e]=!0),this._in[e]={},this._preds[e]={},this._out[e]={},this._sucs[e]={},++this._nodeCount,this)};cr.prototype.node=function(e){return this._nodes[e]};cr.prototype.hasNode=function(e){return je.has(this._nodes,e)};cr.prototype.removeNode=function(e){var t=this;if(je.has(this._nodes,e)){var r=function(n){t.removeEdge(t._edgeObjs[n])};delete this._nodes[e],this._isCompound&&(this._removeFromParentsChildList(e),delete this._parent[e],je.each(this.children(e),function(n){t.setParent(n)}),delete this._children[e]),je.each(je.keys(this._in[e]),r),delete this._in[e],delete this._preds[e],je.each(je.keys(this._out[e]),r),delete this._out[e],delete this._sucs[e],--this._nodeCount}return this};cr.prototype.setParent=function(e,t){if(!this._isCompound)throw new Error("Cannot set parent in a non-compound graph");if(je.isUndefined(t))t=Jv;else{t+="";for(var r=t;!je.isUndefined(r);r=this.parent(r))if(r===e)throw new Error("Setting "+t+" as parent of "+e+" would create a cycle");this.setNode(t)}return this.setNode(e),this._removeFromParentsChildList(e),this._parent[e]=t,this._children[t][e]=!0,this};cr.prototype._removeFromParentsChildList=function(e){delete this._children[this._parent[e]][e]};cr.prototype.parent=function(e){if(this._isCompound){var t=this._parent[e];if(t!==Jv)return t}};cr.prototype.children=function(e){if(je.isUndefined(e)&&(e=Jv),this._isCompound){var t=this._children[e];if(t)return je.keys(t)}else{if(e===Jv)return this.nodes();if(this.hasNode(e))return[]}};cr.prototype.predecessors=function(e){var t=this._preds[e];if(t)return je.keys(t)};cr.prototype.successors=function(e){var t=this._sucs[e];if(t)return je.keys(t)};cr.prototype.neighbors=function(e){var t=this.predecessors(e);if(t)return je.union(t,this.successors(e))};cr.prototype.isLeaf=function(e){var t;return this.isDirected()?t=this.successors(e):t=this.neighbors(e),t.length===0};cr.prototype.filterNodes=function(e){var t=new this.constructor({directed:this._isDirected,multigraph:this._isMultigraph,compound:this._isCompound});t.setGraph(this.graph());var r=this;je.each(this._nodes,function(o,a){e(a)&&t.setNode(a,o)}),je.each(this._edgeObjs,function(o){t.hasNode(o.v)&&t.hasNode(o.w)&&t.setEdge(o,r.edge(o))});var n={};function i(o){var a=r.parent(o);return a===void 0||t.hasNode(a)?(n[o]=a,a):a in n?n[a]:i(a)}return this._isCompound&&je.each(t.nodes(),function(o){t.setParent(o,i(o))}),t};cr.prototype.setDefaultEdgeLabel=function(e){return je.isFunction(e)||(e=je.constant(e)),this._defaultEdgeLabelFn=e,this};cr.prototype.edgeCount=function(){return this._edgeCount};cr.prototype.edges=function(){return je.values(this._edgeObjs)};cr.prototype.setPath=function(e,t){var r=this,n=arguments;return je.reduce(e,function(i,o){return n.length>1?r.setEdge(i,o,t):r.setEdge(i,o),o}),this};cr.prototype.setEdge=function(){var e,t,r,n,i=!1,o=arguments[0];typeof o=="object"&&o!==null&&"v"in o?(e=o.v,t=o.w,r=o.name,arguments.length===2&&(n=arguments[1],i=!0)):(e=o,t=arguments[1],r=arguments[3],arguments.length>2&&(n=arguments[2],i=!0)),e=""+e,t=""+t,je.isUndefined(r)||(r=""+r);var a=W4(this._isDirected,e,t,r);if(je.has(this._edgeLabels,a))return i&&(this._edgeLabels[a]=n),this;if(!je.isUndefined(r)&&!this._isMultigraph)throw new Error("Cannot set a named edge when isMultigraph = false");this.setNode(e),this.setNode(t),this._edgeLabels[a]=i?n:this._defaultEdgeLabelFn(e,t,r);var s=Grr(this._isDirected,e,t,r);return e=s.v,t=s.w,Object.freeze(s),this._edgeObjs[a]=s,Dne(this._preds[t],e),Dne(this._sucs[e],t),this._in[t][a]=s,this._out[e][a]=s,this._edgeCount++,this};cr.prototype.edge=function(e,t,r){var n=arguments.length===1?ult(this._isDirected,arguments[0]):W4(this._isDirected,e,t,r);return this._edgeLabels[n]};cr.prototype.hasEdge=function(e,t,r){var n=arguments.length===1?ult(this._isDirected,arguments[0]):W4(this._isDirected,e,t,r);return je.has(this._edgeLabels,n)};cr.prototype.removeEdge=function(e,t,r){var n=arguments.length===1?ult(this._isDirected,arguments[0]):W4(this._isDirected,e,t,r),i=this._edgeObjs[n];return i&&(e=i.v,t=i.w,delete this._edgeLabels[n],delete this._edgeObjs[n],One(this._preds[t],e),One(this._sucs[e],t),delete this._in[t][n],delete this._out[e][n],this._edgeCount--),this};cr.prototype.inEdges=function(e,t){var r=this._in[e];if(r){var n=je.values(r);return t?je.filter(n,function(i){return i.v===t}):n}};cr.prototype.outEdges=function(e,t){var r=this._out[e];if(r){var n=je.values(r);return t?je.filter(n,function(i){return i.w===t}):n}};cr.prototype.nodeEdges=function(e,t){var r=this.inEdges(e,t);if(r)return r.concat(this.outEdges(e,t))};function Dne(e,t){e[t]?e[t]++:e[t]=1}function One(e,t){--e[t]||delete e[t]}function W4(e,t,r,n){var i=""+t,o=""+r;if(!e&&i>o){var a=i;i=o,o=a}return i+Nne+o+Nne+(je.isUndefined(n)?qrr:n)}function Grr(e,t,r,n){var i=""+t,o=""+r;if(!e&&i>o){var a=i;i=o,o=a}var s={v:i,w:o};return n&&(s.name=n),s}function ult(e,t){return W4(e,t.v,t.w,t.name)}});var Bne=H((BZn,Fne)=>{Fne.exports="2.1.8"});var Vne=H((HZn,Hne)=>{Hne.exports={Graph:rH(),version:Bne()}});var qne=H((VZn,Une)=>{var Vf=El(),Wrr=rH();Une.exports={write:Yrr,read:$rr};function Yrr(e){var t={options:{directed:e.isDirected(),multigraph:e.isMultigraph(),compound:e.isCompound()},nodes:jrr(e),edges:Xrr(e)};return Vf.isUndefined(e.graph())||(t.value=Vf.clone(e.graph())),t}function jrr(e){return Vf.map(e.nodes(),function(t){var r=e.node(t),n=e.parent(t),i={v:t};return Vf.isUndefined(r)||(i.value=r),Vf.isUndefined(n)||(i.parent=n),i})}function Xrr(e){return Vf.map(e.edges(),function(t){var r=e.edge(t),n={v:t.v,w:t.w};return Vf.isUndefined(t.name)||(n.name=t.name),Vf.isUndefined(r)||(n.value=r),n})}function $rr(e){var t=new Wrr(e.options).setGraph(e.value);return Vf.each(e.nodes,function(r){t.setNode(r.v,r.value),r.parent&&t.setParent(r.v,r.parent)}),Vf.each(e.edges,function(r){t.setEdge({v:r.v,w:r.w,name:r.name},r.value)}),t}});var Wne=H((UZn,Gne)=>{var nH=El();Gne.exports=Krr;function Krr(e){var t={},r=[],n;function i(o){nH.has(t,o)||(t[o]=!0,n.push(o),nH.each(e.successors(o),i),nH.each(e.predecessors(o),i))}return nH.each(e.nodes(),function(o){n=[],i(o),n.length&&r.push(n)}),r}});var hlt=H((qZn,jne)=>{var Yne=El();jne.exports=Vc;function Vc(){this._arr=[],this._keyIndices={}}Vc.prototype.size=function(){return this._arr.length};Vc.prototype.keys=function(){return this._arr.map(function(e){return e.key})};Vc.prototype.has=function(e){return Yne.has(this._keyIndices,e)};Vc.prototype.priority=function(e){var t=this._keyIndices[e];if(t!==void 0)return this._arr[t].priority};Vc.prototype.min=function(){if(this.size()===0)throw new Error("Queue underflow");return this._arr[0].key};Vc.prototype.add=function(e,t){var r=this._keyIndices;if(e=String(e),!Yne.has(r,e)){var n=this._arr,i=n.length;return r[e]=i,n.push({key:e,priority:t}),this._decrease(i),!0}return!1};Vc.prototype.removeMin=function(){this._swap(0,this._arr.length-1);var e=this._arr.pop();return delete this._keyIndices[e.key],this._heapify(0),e.key};Vc.prototype.decrease=function(e,t){var r=this._keyIndices[e];if(t>this._arr[r].priority)throw new Error("New priority is greater than current priority. Key: "+e+" Old: "+this._arr[r].priority+" New: "+t);this._arr[r].priority=t,this._decrease(r)};Vc.prototype._heapify=function(e){var t=this._arr,r=2*e,n=r+1,i=e;r<t.length&&(i=t[r].priority<t[i].priority?r:i,n<t.length&&(i=t[n].priority<t[i].priority?n:i),i!==e&&(this._swap(e,i),this._heapify(i)))};Vc.prototype._decrease=function(e){for(var t=this._arr,r=t[e].priority,n;e!==0&&(n=e>>1,!(t[n].priority<r));)this._swap(e,n),e=n};Vc.prototype._swap=function(e,t){var r=this._arr,n=this._keyIndices,i=r[e],o=r[t];r[e]=o,r[t]=i,n[o.key]=e,n[i.key]=t}});var flt=H((GZn,Xne)=>{var Zrr=El(),Jrr=hlt();Xne.exports=tnr;var Qrr=Zrr.constant(1);function tnr(e,t,r,n){return enr(e,String(t),r||Qrr,n||function(i){return e.outEdges(i)})}function enr(e,t,r,n){var i={},o=new Jrr,a,s,l=function(c){var u=c.v!==a?c.v:c.w,h=i[u],f=r(c),p=s.distance+f;if(f<0)throw new Error("dijkstra does not allow negative edge weights. Bad edge: "+c+" Weight: "+f);p<h.distance&&(h.distance=p,h.predecessor=a,o.decrease(u,p))};for(e.nodes().forEach(function(c){var u=c===t?0:Number.POSITIVE_INFINITY;i[c]={distance:u},o.add(c,u)});o.size()>0&&(a=o.removeMin(),s=i[a],s.distance!==Number.POSITIVE_INFINITY);)n(a).forEach(l);return i}});var Kne=H((WZn,$ne)=>{var rnr=flt(),nnr=El();$ne.exports=inr;function inr(e,t,r){return nnr.transform(e.nodes(),function(n,i){n[i]=rnr(e,i,t,r)},{})}});var plt=H((YZn,Jne)=>{var Zne=El();Jne.exports=onr;function onr(e){var t=0,r=[],n={},i=[];function o(a){var s=n[a]={onStack:!0,lowlink:t,index:t++};if(r.push(a),e.successors(a).forEach(function(u){Zne.has(n,u)?n[u].onStack&&(s.lowlink=Math.min(s.lowlink,n[u].index)):(o(u),s.lowlink=Math.min(s.lowlink,n[u].lowlink))}),s.lowlink===s.index){var l=[],c;do c=r.pop(),n[c].onStack=!1,l.push(c);while(a!==c);i.push(l)}}return e.nodes().forEach(function(a){Zne.has(n,a)||o(a)}),i}});var tie=H((jZn,Qne)=>{var anr=El(),snr=plt();Qne.exports=lnr;function lnr(e){return anr.filter(snr(e),function(t){return t.length>1||t.length===1&&e.hasEdge(t[0],t[0])})}});var rie=H((XZn,eie)=>{var cnr=El();eie.exports=hnr;var unr=cnr.constant(1);function hnr(e,t,r){return fnr(e,t||unr,r||function(n){return e.outEdges(n)})}function fnr(e,t,r){var n={},i=e.nodes();return i.forEach(function(o){n[o]={},n[o][o]={distance:0},i.forEach(function(a){o!==a&&(n[o][a]={distance:Number.POSITIVE_INFINITY})}),r(o).forEach(function(a){var s=a.v===o?a.w:a.v,l=t(a);n[o][s]={distance:l,predecessor:o}})}),i.forEach(function(o){var a=n[o];i.forEach(function(s){var l=n[s];i.forEach(function(c){var u=l[o],h=a[c],f=l[c],p=u.distance+h.distance;p<f.distance&&(f.distance=p,f.predecessor=h.predecessor)})})}),n}});var dlt=H(($Zn,iie)=>{var Y4=El();iie.exports=nie;nie.CycleException=iH;function nie(e){var t={},r={},n=[];function i(o){if(Y4.has(r,o))throw new iH;Y4.has(t,o)||(r[o]=!0,t[o]=!0,Y4.each(e.predecessors(o),i),delete r[o],n.push(o))}if(Y4.each(e.sinks(),i),Y4.size(t)!==e.nodeCount())throw new iH;return n}function iH(){}iH.prototype=new Error});var sie=H((KZn,aie)=>{var oie=dlt();aie.exports=pnr;function pnr(e){try{oie(e)}catch(t){if(t instanceof oie.CycleException)return!1;throw t}return!0}});var mlt=H((ZZn,cie)=>{var oH=El();cie.exports=dnr;function dnr(e,t,r){oH.isArray(t)||(t=[t]);var n=(e.isDirected()?e.successors:e.neighbors).bind(e),i=[],o={};return oH.each(t,function(a){if(!e.hasNode(a))throw new Error("Graph does not have node: "+a);lie(e,a,r==="post",o,n,i)}),i}function lie(e,t,r,n,i,o){oH.has(n,t)||(n[t]=!0,r||o.push(t),oH.each(i(t),function(a){lie(e,a,r,n,i,o)}),r&&o.push(t))}});var hie=H((JZn,uie)=>{var mnr=mlt();uie.exports=gnr;function gnr(e,t){return mnr(e,t,"post")}});var pie=H((QZn,fie)=>{var _nr=mlt();fie.exports=ynr;function ynr(e,t){return _nr(e,t,"pre")}});var gie=H((tJn,mie)=>{var die=El(),vnr=rH(),xnr=hlt();mie.exports=bnr;function bnr(e,t){var r=new vnr,n={},i=new xnr,o;function a(l){var c=l.v===o?l.w:l.v,u=i.priority(c);if(u!==void 0){var h=t(l);h<u&&(n[c]=o,i.decrease(c,h))}}if(e.nodeCount()===0)return r;die.each(e.nodes(),function(l){i.add(l,Number.POSITIVE_INFINITY),r.setNode(l)}),i.decrease(e.nodes()[0],0);for(var s=!1;i.size()>0;){if(o=i.removeMin(),die.has(n,o))r.setEdge(o,n[o]);else{if(s)throw new Error("Input graph is not connected: "+e);s=!0}e.nodeEdges(o).forEach(a)}return r}});var yie=H((eJn,_ie)=>{_ie.exports={components:Wne(),dijkstra:flt(),dijkstraAll:Kne(),findCycles:tie(),floydWarshall:rie(),isAcyclic:sie(),postorder:hie(),preorder:pie(),prim:gie(),tarjan:plt(),topsort:dlt()}});var bie=H((rJn,xie)=>{var vie=Vne();xie.exports={Graph:vie.Graph,json:qne(),alg:yie(),version:vie.version}});var Uc=H((nJn,wie)=>{var aH;if(typeof Ex=="function")try{aH=bie()}catch(e){}aH||(aH=window.graphlib);wie.exports=aH});var Mie=H((oJn,Sie)=>{var wnr=Rst(),Snr=1,Mnr=4;function Enr(e){return wnr(e,Snr|Mnr)}Sie.exports=Enr});var j4=H((aJn,Eie)=>{var Tnr=Yv(),Cnr=Bf(),Anr=R4(),Pnr=Ml();function Inr(e,t,r){if(!Pnr(r))return!1;var n=typeof t;return(n=="number"?Cnr(r)&&Anr(t,r.length):n=="string"&&t in r)?Tnr(r[t],e):!1}Eie.exports=Inr});var Aie=H((sJn,Cie)=>{var Lnr=G4(),knr=Yv(),Rnr=j4(),Nnr=c0(),Tie=Object.prototype,Dnr=Tie.hasOwnProperty,Onr=Lnr(function(e,t){e=Object(e);var r=-1,n=t.length,i=n>2?t[2]:void 0;for(i&&Rnr(t[0],t[1],i)&&(n=1);++r<n;)for(var o=t[r],a=Nnr(o),s=-1,l=a.length;++s<l;){var c=a[s],u=e[c];(u===void 0||knr(u,Tie[c])&&!Dnr.call(e,c))&&(e[c]=o[c])}return e});Cie.exports=Onr});var Iie=H((lJn,Pie)=>{var znr=Hf(),Fnr=Bf(),Bnr=Ad();function Hnr(e){return function(t,r,n){var i=Object(t);if(!Fnr(t)){var o=znr(r,3);t=Bnr(t),r=function(s){return o(i[s],s,i)}}var a=e(t,r,n);return a>-1?i[o?t[a]:a]:void 0}}Pie.exports=Hnr});var kie=H((cJn,Lie)=>{var Vnr=/\s/;function Unr(e){for(var t=e.length;t--&&Vnr.test(e.charAt(t)););return t}Lie.exports=Unr});var Nie=H((uJn,Rie)=>{var qnr=kie(),Gnr=/^\s+/;function Wnr(e){return e&&e.slice(0,qnr(e)+1).replace(Gnr,"")}Rie.exports=Wnr});var Fie=H((hJn,zie)=>{var Ynr=Nie(),Die=Ml(),jnr=Zv(),Oie=0/0,Xnr=/^[-+]0x[0-9a-f]+$/i,$nr=/^0b[01]+$/i,Knr=/^0o[0-7]+$/i,Znr=parseInt;function Jnr(e){if(typeof e=="number")return e;if(jnr(e))return Oie;if(Die(e)){var t=typeof e.valueOf=="function"?e.valueOf():e;e=Die(t)?t+"":t}if(typeof e!="string")return e===0?e:+e;e=Ynr(e);var r=$nr.test(e);return r||Knr.test(e)?Znr(e.slice(2),r?2:8):Xnr.test(e)?Oie:+e}zie.exports=Jnr});var glt=H((fJn,Hie)=>{var Qnr=Fie(),Bie=1/0,tir=17976931348623157e292;function eir(e){if(!e)return e===0?e:0;if(e=Qnr(e),e===Bie||e===-Bie){var t=e<0?-1:1;return t*tir}return e===e?e:0}Hie.exports=eir});var Uie=H((pJn,Vie)=>{var rir=glt();function nir(e){var t=rir(e),r=t%1;return t===t?r?t-r:t:0}Vie.exports=nir});var Gie=H((dJn,qie)=>{var iir=alt(),oir=Hf(),air=Uie(),sir=Math.max;function lir(e,t,r){var n=e==null?0:e.length;if(!n)return-1;var i=r==null?0:air(r);return i<0&&(i=sir(n+i,0)),iir(e,oir(t,3),i)}qie.exports=lir});var Yie=H((mJn,Wie)=>{var cir=Iie(),uir=Gie(),hir=cir(uir);Wie.exports=hir});var _lt=H((gJn,jie)=>{var fir=tH();function pir(e){var t=e==null?0:e.length;return t?fir(e,1):[]}jie.exports=pir});var $ie=H((_Jn,Xie)=>{var dir=XB(),mir=Nst(),gir=c0();function _ir(e,t){return e==null?e:dir(e,mir(t),gir)}Xie.exports=_ir});var Zie=H((yJn,Kie)=>{function yir(e){var t=e==null?0:e.length;return t?e[t-1]:void 0}Kie.exports=yir});var Qie=H((vJn,Jie)=>{var vir=I4(),xir=$B(),bir=Hf();function wir(e,t){var r={};return t=bir(t,3),xir(e,function(n,i,o){vir(r,i,t(n,i,o))}),r}Jie.exports=wir});var sH=H((xJn,toe)=>{var Sir=Zv();function Mir(e,t,r){for(var n=-1,i=e.length;++n<i;){var o=e[n],a=t(o);if(a!=null&&(s===void 0?a===a&&!Sir(a):r(a,s)))var s=a,l=o}return l}toe.exports=Mir});var roe=H((bJn,eoe)=>{function Eir(e,t){return e>t}eoe.exports=Eir});var ioe=H((wJn,noe)=>{var Tir=sH(),Cir=roe(),Air=u0();function Pir(e){return e&&e.length?Tir(e,Air,Cir):void 0}noe.exports=Pir});var ylt=H((SJn,ooe)=>{var Iir=I4(),Lir=Yv();function kir(e,t,r){(r!==void 0&&!Lir(e[t],r)||r===void 0&&!(t in e))&&Iir(e,t,r)}ooe.exports=kir});var loe=H((MJn,soe)=>{var Rir=s0(),Nir=B4(),Dir=Yu(),Oir="[object Object]",zir=Function.prototype,Fir=Object.prototype,aoe=zir.toString,Bir=Fir.hasOwnProperty,Hir=aoe.call(Object);function Vir(e){if(!Dir(e)||Rir(e)!=Oir)return!1;var t=Nir(e);if(t===null)return!0;var r=Bir.call(t,"constructor")&&t.constructor;return typeof r=="function"&&r instanceof r&&aoe.call(r)==Hir}soe.exports=Vir});var vlt=H((EJn,coe)=>{function Uir(e,t){if(!(t==="constructor"&&typeof e[t]=="function")&&t!="__proto__")return e[t]}coe.exports=Uir});var hoe=H((TJn,uoe)=>{var qir=US(),Gir=c0();function Wir(e){return qir(e,Gir(e))}uoe.exports=Wir});var _oe=H((CJn,goe)=>{var foe=ylt(),Yir=gst(),jir=Ist(),Xir=_st(),$ir=kst(),poe=qS(),doe=Ti(),Kir=llt(),Zir=Xv(),Jir=FS(),Qir=Ml(),tor=loe(),eor=YS(),moe=vlt(),ror=hoe();function nor(e,t,r,n,i,o,a){var s=moe(e,r),l=moe(t,r),c=a.get(l);if(c){foe(e,r,c);return}var u=o?o(s,l,r+"",e,t,a):void 0,h=u===void 0;if(h){var f=doe(l),p=!f&&Zir(l),d=!f&&!p&&eor(l);u=l,f||p||d?doe(s)?u=s:Kir(s)?u=Xir(s):p?(h=!1,u=Yir(l,!0)):d?(h=!1,u=jir(l,!0)):u=[]:tor(l)||poe(l)?(u=s,poe(s)?u=ror(s):(!Qir(s)||Jir(s))&&(u=$ir(l))):h=!1}h&&(a.set(l,u),i(u,l,n,o,a),a.delete(l)),foe(e,r,u)}goe.exports=nor});var xoe=H((AJn,voe)=>{var ior=P4(),oor=ylt(),aor=XB(),sor=_oe(),lor=Ml(),cor=c0(),uor=vlt();function yoe(e,t,r,n,i){e!==t&&aor(t,function(o,a){if(i||(i=new ior),lor(o))sor(e,t,a,r,yoe,n,i);else{var s=n?n(uor(e,a),o,a+"",e,t,i):void 0;s===void 0&&(s=o),oor(e,a,s)}},cor)}voe.exports=yoe});var woe=H((PJn,boe)=>{var hor=G4(),por=j4();function dor(e){return hor(function(t,r){var n=-1,i=r.length,o=i>1?r[i-1]:void 0,a=i>2?r[2]:void 0;for(o=e.length>3&&typeof o=="function"?(i--,o):void 0,a&&por(r[0],r[1],a)&&(o=i<3?void 0:o,i=1),t=Object(t);++n<i;){var s=r[n];s&&e(t,s,n,o)}return t})}boe.exports=dor});var Moe=H((IJn,Soe)=>{var mor=xoe(),gor=woe(),_or=gor(function(e,t,r){mor(e,t,r)});Soe.exports=_or});var xlt=H((LJn,Eoe)=>{function yor(e,t){return e<t}Eoe.exports=yor});var Coe=H((kJn,Toe)=>{var vor=sH(),xor=xlt(),bor=u0();function wor(e){return e&&e.length?vor(e,bor,xor):void 0}Toe.exports=wor});var Poe=H((RJn,Aoe)=>{var Sor=sH(),Mor=Hf(),Eor=xlt();function Tor(e,t){return e&&e.length?Sor(e,Mor(t,2),Eor):void 0}Aoe.exports=Tor});var Loe=H((NJn,Ioe)=>{var Cor=Hc(),Aor=function(){return Cor.Date.now()};Ioe.exports=Aor});var Noe=H((DJn,Roe)=>{var Por=L4(),Ior=U4(),Lor=R4(),koe=Ml(),kor=$S();function Ror(e,t,r,n){if(!koe(e))return e;t=Ior(t,e);for(var i=-1,o=t.length,a=o-1,s=e;s!=null&&++i<o;){var l=kor(t[i]),c=r;if(l==="__proto__"||l==="constructor"||l==="prototype")return e;if(i!=a){var u=s[l];c=n?n(u,l,s):void 0,c===void 0&&(c=koe(u)?u:Lor(t[i+1])?[]:{})}Por(s,l,c),s=s[l]}return e}Roe.exports=Ror});var Ooe=H((OJn,Doe)=>{var Nor=q4(),Dor=Noe(),Oor=U4();function zor(e,t,r){for(var n=-1,i=t.length,o={};++n<i;){var a=t[n],s=Nor(e,a);r(s,a)&&Dor(o,Oor(a,e),s)}return o}Doe.exports=zor});var Foe=H((zJn,zoe)=>{var For=Ooe(),Bor=Xst();function Hor(e,t){return For(e,t,function(r,n){return Bor(e,n)})}zoe.exports=Hor});var Hoe=H((FJn,Boe)=>{var Vor=_lt(),Uor=ilt(),qor=olt();function Gor(e){return qor(Uor(e,void 0,Vor),e+"")}Boe.exports=Gor});var Uoe=H((BJn,Voe)=>{var Wor=Foe(),Yor=Hoe(),jor=Yor(function(e,t){return e==null?{}:Wor(e,t)});Voe.exports=jor});var Goe=H((HJn,qoe)=>{var Xor=Math.ceil,$or=Math.max;function Kor(e,t,r,n){for(var i=-1,o=$or(Xor((t-e)/(r||1)),0),a=Array(o);o--;)a[n?o:++i]=e,e+=r;return a}qoe.exports=Kor});var Yoe=H((VJn,Woe)=>{var Zor=Goe(),Jor=j4(),blt=glt();function Qor(e){return function(t,r,n){return n&&typeof n!="number"&&Jor(t,r,n)&&(r=n=void 0),t=blt(t),r===void 0?(r=t,t=0):r=blt(r),n=n===void 0?t<r?1:-1:blt(n),Zor(t,r,n,e)}}Woe.exports=Qor});var Xoe=H((UJn,joe)=>{var tar=Yoe(),ear=tar();joe.exports=ear});var Koe=H((qJn,$oe)=>{function rar(e,t){var r=e.length;for(e.sort(t);r--;)e[r]=e[r].value;return e}$oe.exports=rar});var Qoe=H((GJn,Joe)=>{var Zoe=Zv();function nar(e,t){if(e!==t){var r=e!==void 0,n=e===null,i=e===e,o=Zoe(e),a=t!==void 0,s=t===null,l=t===t,c=Zoe(t);if(!s&&!c&&!o&&e>t||o&&a&&l&&!s&&!c||n&&a&&l||!r&&l||!i)return 1;if(!n&&!o&&!c&&e<t||c&&r&&i&&!n&&!o||s&&r&&i||!a&&i||!l)return-1}return 0}Joe.exports=nar});var eae=H((WJn,tae)=>{var iar=Qoe();function oar(e,t,r){for(var n=-1,i=e.criteria,o=t.criteria,a=i.length,s=r.length;++n<a;){var l=iar(i[n],o[n]);if(l){if(n>=s)return l;var c=r[n];return l*(c=="desc"?-1:1)}}return e.index-t.index}tae.exports=oar});var nae=H((YJn,rae)=>{var wlt=V4(),aar=q4(),sar=Hf(),lar=Qst(),car=Koe(),uar=N4(),har=eae(),far=u0(),par=Ti();function dar(e,t,r){t.length?t=wlt(t,function(o){return par(o)?function(a){return aar(a,o.length===1?o[0]:o)}:o}):t=[far];var n=-1;t=wlt(t,uar(sar));var i=lar(e,function(o,a,s){var l=wlt(t,function(c){return c(o)});return{criteria:l,index:++n,value:o}});return car(i,function(o,a){return har(o,a,r)})}rae.exports=dar});var aae=H((jJn,oae)=>{var mar=tH(),gar=nae(),_ar=G4(),iae=j4(),yar=_ar(function(e,t){if(e==null)return[];var r=t.length;return r>1&&iae(e,t[0],t[1])?t=[]:r>2&&iae(t[0],t[1],t[2])&&(t=[t[0]]),gar(e,mar(t,1),[])});oae.exports=yar});var lae=H((XJn,sae)=>{var xar=Yst(),bar=0;function war(e){var t=++bar;return xar(e)+t}sae.exports=war});var uae=H(($Jn,cae)=>{function Sar(e,t,r){for(var n=-1,i=e.length,o=t.length,a={};++n<i;){var s=n<o?t[n]:void 0;r(a,e[n],s)}return a}cae.exports=Sar});var fae=H((KJn,hae)=>{var Mar=L4(),Ear=uae();function Tar(e,t){return Ear(e||[],t||[],Mar)}hae.exports=Tar});var Un=H((ZJn,pae)=>{var lH;if(typeof Ex=="function")try{lH={cloneDeep:Mie(),constant:jB(),defaults:Aie(),each:Ost(),filter:Kst(),find:Yie(),flatten:_lt(),forEach:Dst(),forIn:$ie(),has:Zst(),isUndefined:Jst(),last:Zie(),map:tlt(),mapValues:Qie(),max:ioe(),merge:Moe(),min:Coe(),minBy:Poe(),now:Loe(),pick:Uoe(),range:Xoe(),reduce:elt(),sortBy:aae(),uniqueId:lae(),values:clt(),zipObject:fae()}}catch(e){}lH||(lH=window._);pae.exports=lH});var gae=H((QJn,mae)=>{mae.exports=cH;function cH(){var e={};e._next=e._prev=e,this._sentinel=e}cH.prototype.dequeue=function(){var e=this._sentinel,t=e._prev;if(t!==e)return dae(t),t};cH.prototype.enqueue=function(e){var t=this._sentinel;e._prev&&e._next&&dae(e),e._next=t._next,t._next._prev=e,t._next=e,e._prev=t};cH.prototype.toString=function(){for(var e=[],t=this._sentinel,r=t._prev;r!==t;)e.push(JSON.stringify(r,Car)),r=r._prev;return"["+e.join(", ")+"]"};function dae(e){e._prev._next=e._next,e._next._prev=e._prev,delete e._next,delete e._prev}function Car(e,t){if(e!=="_next"&&e!=="_prev")return t}});var yae=H((tQn,_ae)=>{var Pd=Un(),Aar=Uc().Graph,Par=gae();_ae.exports=Lar;var Iar=Pd.constant(1);function Lar(e,t){if(e.nodeCount()<=1)return[];var r=Rar(e,t||Iar),n=kar(r.graph,r.buckets,r.zeroIdx);return Pd.flatten(Pd.map(n,function(i){return e.outEdges(i.v,i.w)}),!0)}function kar(e,t,r){for(var n=[],i=t[t.length-1],o=t[0],a;e.nodeCount();){for(;a=o.dequeue();)Slt(e,t,r,a);for(;a=i.dequeue();)Slt(e,t,r,a);if(e.nodeCount()){for(var s=t.length-2;s>0;--s)if(a=t[s].dequeue(),a){n=n.concat(Slt(e,t,r,a,!0));break}}}return n}function Slt(e,t,r,n,i){var o=i?[]:void 0;return Pd.forEach(e.inEdges(n.v),function(a){var s=e.edge(a),l=e.node(a.v);i&&o.push({v:a.v,w:a.w}),l.out-=s,Mlt(t,r,l)}),Pd.forEach(e.outEdges(n.v),function(a){var s=e.edge(a),l=a.w,c=e.node(l);c.in-=s,Mlt(t,r,c)}),e.removeNode(n.v),o}function Rar(e,t){var r=new Aar,n=0,i=0;Pd.forEach(e.nodes(),function(s){r.setNode(s,{v:s,in:0,out:0})}),Pd.forEach(e.edges(),function(s){var l=r.edge(s.v,s.w)||0,c=t(s),u=l+c;r.setEdge(s.v,s.w,u),i=Math.max(i,r.node(s.v).out+=c),n=Math.max(n,r.node(s.w).in+=c)});var o=Pd.range(i+n+3).map(function(){return new Par}),a=n+1;return Pd.forEach(r.nodes(),function(s){Mlt(o,a,r.node(s))}),{graph:r,buckets:o,zeroIdx:a}}function Mlt(e,t,r){r.out?r.in?e[r.out-r.in+t].enqueue(r):e[e.length-1].enqueue(r):e[0].enqueue(r)}});var xae=H((eQn,vae)=>{"use strict";var Qv=Un(),Nar=yae();vae.exports={run:Dar,undo:zar};function Dar(e){var t=e.graph().acyclicer==="greedy"?Nar(e,r(e)):Oar(e);Qv.forEach(t,function(n){var i=e.edge(n);e.removeEdge(n),i.forwardName=n.name,i.reversed=!0,e.setEdge(n.w,n.v,i,Qv.uniqueId("rev"))});function r(n){return function(i){return n.edge(i).weight}}}function Oar(e){var t=[],r={},n={};function i(o){Qv.has(n,o)||(n[o]=!0,r[o]=!0,Qv.forEach(e.outEdges(o),function(a){Qv.has(r,a.w)?t.push(a):i(a.w)}),delete r[o])}return Qv.forEach(e.nodes(),i),t}function zar(e){Qv.forEach(e.edges(),function(t){var r=e.edge(t);if(r.reversed){e.removeEdge(t);var n=r.forwardName;delete r.reversed,delete r.forwardName,e.setEdge(t.w,t.v,r,n)}})}});var ns=H((rQn,Mae)=>{"use strict";var Qr=Un(),bae=Uc().Graph;Mae.exports={addDummyNode:wae,simplify:Far,asNonCompoundGraph:Bar,successorWeights:Har,predecessorWeights:Var,intersectRect:Uar,buildLayerMatrix:qar,normalizeRanks:Gar,removeEmptyRanks:War,addBorderNode:Yar,maxRank:Sae,partition:jar,time:Xar,notime:$ar};function wae(e,t,r,n){var i;do i=Qr.uniqueId(n);while(e.hasNode(i));return r.dummy=t,e.setNode(i,r),i}function Far(e){var t=new bae().setGraph(e.graph());return Qr.forEach(e.nodes(),function(r){t.setNode(r,e.node(r))}),Qr.forEach(e.edges(),function(r){var n=t.edge(r.v,r.w)||{weight:0,minlen:1},i=e.edge(r);t.setEdge(r.v,r.w,{weight:n.weight+i.weight,minlen:Math.max(n.minlen,i.minlen)})}),t}function Bar(e){var t=new bae({multigraph:e.isMultigraph()}).setGraph(e.graph());return Qr.forEach(e.nodes(),function(r){e.children(r).length||t.setNode(r,e.node(r))}),Qr.forEach(e.edges(),function(r){t.setEdge(r,e.edge(r))}),t}function Har(e){var t=Qr.map(e.nodes(),function(r){var n={};return Qr.forEach(e.outEdges(r),function(i){n[i.w]=(n[i.w]||0)+e.edge(i).weight}),n});return Qr.zipObject(e.nodes(),t)}function Var(e){var t=Qr.map(e.nodes(),function(r){var n={};return Qr.forEach(e.inEdges(r),function(i){n[i.v]=(n[i.v]||0)+e.edge(i).weight}),n});return Qr.zipObject(e.nodes(),t)}function Uar(e,t){var r=e.x,n=e.y,i=t.x-r,o=t.y-n,a=e.width/2,s=e.height/2;if(!i&&!o)throw new Error("Not possible to find intersection inside of the rectangle");var l,c;return Math.abs(o)*a>Math.abs(i)*s?(o<0&&(s=-s),l=s*i/o,c=s):(i<0&&(a=-a),l=a,c=a*o/i),{x:r+l,y:n+c}}function qar(e){var t=Qr.map(Qr.range(Sae(e)+1),function(){return[]});return Qr.forEach(e.nodes(),function(r){var n=e.node(r),i=n.rank;Qr.isUndefined(i)||(t[i][n.order]=r)}),t}function Gar(e){var t=Qr.min(Qr.map(e.nodes(),function(r){return e.node(r).rank}));Qr.forEach(e.nodes(),function(r){var n=e.node(r);Qr.has(n,"rank")&&(n.rank-=t)})}function War(e){var t=Qr.min(Qr.map(e.nodes(),function(o){return e.node(o).rank})),r=[];Qr.forEach(e.nodes(),function(o){var a=e.node(o).rank-t;r[a]||(r[a]=[]),r[a].push(o)});var n=0,i=e.graph().nodeRankFactor;Qr.forEach(r,function(o,a){Qr.isUndefined(o)&&a%i!==0?--n:n&&Qr.forEach(o,function(s){e.node(s).rank+=n})})}function Yar(e,t,r,n){var i={width:0,height:0};return arguments.length>=4&&(i.rank=r,i.order=n),wae(e,"border",i,t)}function Sae(e){return Qr.max(Qr.map(e.nodes(),function(t){var r=e.node(t).rank;if(!Qr.isUndefined(r))return r}))}function jar(e,t){var r={lhs:[],rhs:[]};return Qr.forEach(e,function(n){t(n)?r.lhs.push(n):r.rhs.push(n)}),r}function Xar(e,t){var r=Qr.now();try{return t()}finally{console.log(e+" time: "+(Qr.now()-r)+"ms")}}function $ar(e,t){return t()}});var Cae=H((nQn,Tae)=>{"use strict";var Eae=Un(),Kar=ns();Tae.exports={run:Zar,undo:Qar};function Zar(e){e.graph().dummyChains=[],Eae.forEach(e.edges(),function(t){Jar(e,t)})}function Jar(e,t){var r=t.v,n=e.node(r).rank,i=t.w,o=e.node(i).rank,a=t.name,s=e.edge(t),l=s.labelRank;if(o!==n+1){e.removeEdge(t);var c,u,h;for(h=0,++n;n<o;++h,++n)s.points=[],u={width:0,height:0,edgeLabel:s,edgeObj:t,rank:n},c=Kar.addDummyNode(e,"edge",u,"_d"),n===l&&(u.width=s.width,u.height=s.height,u.dummy="edge-label",u.labelpos=s.labelpos),e.setEdge(r,c,{weight:s.weight},a),h===0&&e.graph().dummyChains.push(c),r=c;e.setEdge(r,i,{weight:s.weight},a)}}function Qar(e){Eae.forEach(e.graph().dummyChains,function(t){var r=e.node(t),n=r.edgeLabel,i;for(e.setEdge(r.edgeObj,n);r.dummy;)i=e.successors(t)[0],e.removeNode(t),n.points.push({x:r.x,y:r.y}),r.dummy==="edge-label"&&(n.x=r.x,n.y=r.y,n.width=r.width,n.height=r.height),t=i,r=e.node(t)})}});var X4=H((iQn,Aae)=>{"use strict";var uH=Un();Aae.exports={longestPath:tsr,slack:esr};function tsr(e){var t={};function r(n){var i=e.node(n);if(uH.has(t,n))return i.rank;t[n]=!0;var o=uH.min(uH.map(e.outEdges(n),function(a){return r(a.w)-e.edge(a).minlen}));return(o===Number.POSITIVE_INFINITY||o===void 0||o===null)&&(o=0),i.rank=o}uH.forEach(e.sources(),r)}function esr(e,t){return e.node(t.w).rank-e.node(t.v).rank-e.edge(t).minlen}});var Elt=H((oQn,Pae)=>{"use strict";var hH=Un(),rsr=Uc().Graph,fH=X4().slack;Pae.exports=nsr;function nsr(e){var t=new rsr({directed:!1}),r=e.nodes()[0],n=e.nodeCount();t.setNode(r,{});for(var i,o;isr(t,e)<n;)i=osr(t,e),o=t.hasNode(i.v)?fH(e,i):-fH(e,i),asr(t,e,o);return t}function isr(e,t){function r(n){hH.forEach(t.nodeEdges(n),function(i){var o=i.v,a=n===o?i.w:o;!e.hasNode(a)&&!fH(t,i)&&(e.setNode(a,{}),e.setEdge(n,a,{}),r(a))})}return hH.forEach(e.nodes(),r),e.nodeCount()}function osr(e,t){return hH.minBy(t.edges(),function(r){if(e.hasNode(r.v)!==e.hasNode(r.w))return fH(t,r)})}function asr(e,t,r){hH.forEach(e.nodes(),function(n){t.node(n).rank+=r})}});var zae=H((aQn,Oae)=>{"use strict";var Id=Un(),ssr=Elt(),lsr=X4().slack,csr=X4().longestPath,usr=Uc().alg.preorder,hsr=Uc().alg.postorder,fsr=ns().simplify;Oae.exports=t1;t1.initLowLimValues=Clt;t1.initCutValues=Tlt;t1.calcCutValue=Lae;t1.leaveEdge=Rae;t1.enterEdge=Nae;t1.exchangeEdges=Dae;function t1(e){e=fsr(e),csr(e);var t=ssr(e);Clt(t),Tlt(t,e);for(var r,n;r=Rae(t);)n=Nae(t,e,r),Dae(t,e,r,n)}function Tlt(e,t){var r=hsr(e,e.nodes());r=r.slice(0,r.length-1),Id.forEach(r,function(n){psr(e,t,n)})}function psr(e,t,r){var n=e.node(r),i=n.parent;e.edge(r,i).cutvalue=Lae(e,t,r)}function Lae(e,t,r){var n=e.node(r),i=n.parent,o=!0,a=t.edge(r,i),s=0;return a||(o=!1,a=t.edge(i,r)),s=a.weight,Id.forEach(t.nodeEdges(r),function(l){var c=l.v===r,u=c?l.w:l.v;if(u!==i){var h=c===o,f=t.edge(l).weight;if(s+=h?f:-f,msr(e,r,u)){var p=e.edge(r,u).cutvalue;s+=h?-p:p}}}),s}function Clt(e,t){arguments.length<2&&(t=e.nodes()[0]),kae(e,{},1,t)}function kae(e,t,r,n,i){var o=r,a=e.node(n);return t[n]=!0,Id.forEach(e.neighbors(n),function(s){Id.has(t,s)||(r=kae(e,t,r,s,n))}),a.low=o,a.lim=r++,i?a.parent=i:delete a.parent,r}function Rae(e){return Id.find(e.edges(),function(t){return e.edge(t).cutvalue<0})}function Nae(e,t,r){var n=r.v,i=r.w;t.hasEdge(n,i)||(n=r.w,i=r.v);var o=e.node(n),a=e.node(i),s=o,l=!1;o.lim>a.lim&&(s=a,l=!0);var c=Id.filter(t.edges(),function(u){return l===Iae(e,e.node(u.v),s)&&l!==Iae(e,e.node(u.w),s)});return Id.minBy(c,function(u){return lsr(t,u)})}function Dae(e,t,r,n){var i=r.v,o=r.w;e.removeEdge(i,o),e.setEdge(n.v,n.w,{}),Clt(e),Tlt(e,t),dsr(e,t)}function dsr(e,t){var r=Id.find(e.nodes(),function(i){return!t.node(i).parent}),n=usr(e,r);n=n.slice(1),Id.forEach(n,function(i){var o=e.node(i).parent,a=t.edge(i,o),s=!1;a||(a=t.edge(o,i),s=!0),t.node(i).rank=t.node(o).rank+(s?a.minlen:-a.minlen)})}function msr(e,t,r){return e.hasEdge(t,r)}function Iae(e,t,r){return r.low<=t.lim&&t.lim<=r.lim}});var Vae=H((sQn,Hae)=>{"use strict";var gsr=X4(),Bae=gsr.longestPath,_sr=Elt(),ysr=zae();Hae.exports=vsr;function vsr(e){switch(e.graph().ranker){case"network-simplex":Fae(e);break;case"tight-tree":bsr(e);break;case"longest-path":xsr(e);break;default:Fae(e)}}var xsr=Bae;function bsr(e){Bae(e),_sr(e)}function Fae(e){ysr(e)}});var qae=H((lQn,Uae)=>{var Alt=Un();Uae.exports=wsr;function wsr(e){var t=Msr(e);Alt.forEach(e.graph().dummyChains,function(r){for(var n=e.node(r),i=n.edgeObj,o=Ssr(e,t,i.v,i.w),a=o.path,s=o.lca,l=0,c=a[l],u=!0;r!==i.w;){if(n=e.node(r),u){for(;(c=a[l])!==s&&e.node(c).maxRank<n.rank;)l++;c===s&&(u=!1)}if(!u){for(;l<a.length-1&&e.node(c=a[l+1]).minRank<=n.rank;)l++;c=a[l]}e.setParent(r,c),r=e.successors(r)[0]}})}function Ssr(e,t,r,n){var i=[],o=[],a=Math.min(t[r].low,t[n].low),s=Math.max(t[r].lim,t[n].lim),l,c;l=r;do l=e.parent(l),i.push(l);while(l&&(t[l].low>a||s>t[l].lim));for(c=l,l=n;(l=e.parent(l))!==c;)o.push(l);return{path:i.concat(o.reverse()),lca:c}}function Msr(e){var t={},r=0;function n(i){var o=r;Alt.forEach(e.children(i),n),t[i]={low:o,lim:r++}}return Alt.forEach(e.children(),n),t}});var Yae=H((cQn,Wae)=>{var Ld=Un(),Plt=ns();Wae.exports={run:Esr,cleanup:Asr};function Esr(e){var t=Plt.addDummyNode(e,"root",{},"_root"),r=Tsr(e),n=Ld.max(Ld.values(r))-1,i=2*n+1;e.graph().nestingRoot=t,Ld.forEach(e.edges(),function(a){e.edge(a).minlen*=i});var o=Csr(e)+1;Ld.forEach(e.children(),function(a){Gae(e,t,i,o,n,r,a)}),e.graph().nodeRankFactor=i}function Gae(e,t,r,n,i,o,a){var s=e.children(a);if(!s.length){a!==t&&e.setEdge(t,a,{weight:0,minlen:r});return}var l=Plt.addBorderNode(e,"_bt"),c=Plt.addBorderNode(e,"_bb"),u=e.node(a);e.setParent(l,a),u.borderTop=l,e.setParent(c,a),u.borderBottom=c,Ld.forEach(s,function(h){Gae(e,t,r,n,i,o,h);var f=e.node(h),p=f.borderTop?f.borderTop:h,d=f.borderBottom?f.borderBottom:h,g=f.borderTop?n:2*n,_=p!==d?1:i-o[a]+1;e.setEdge(l,p,{weight:g,minlen:_,nestingEdge:!0}),e.setEdge(d,c,{weight:g,minlen:_,nestingEdge:!0})}),e.parent(a)||e.setEdge(t,l,{weight:0,minlen:i+o[a]})}function Tsr(e){var t={};function r(n,i){var o=e.children(n);o&&o.length&&Ld.forEach(o,function(a){r(a,i+1)}),t[n]=i}return Ld.forEach(e.children(),function(n){r(n,1)}),t}function Csr(e){return Ld.reduce(e.edges(),function(t,r){return t+e.edge(r).weight},0)}function Asr(e){var t=e.graph();e.removeNode(t.nestingRoot),delete t.nestingRoot,Ld.forEach(e.edges(),function(r){var n=e.edge(r);n.nestingEdge&&e.removeEdge(r)})}});var $ae=H((uQn,Xae)=>{var Ilt=Un(),Psr=ns();Xae.exports=Isr;function Isr(e){function t(r){var n=e.children(r),i=e.node(r);if(n.length&&Ilt.forEach(n,t),Ilt.has(i,"minRank")){i.borderLeft=[],i.borderRight=[];for(var o=i.minRank,a=i.maxRank+1;o<a;++o)jae(e,"borderLeft","_bl",r,i,o),jae(e,"borderRight","_br",r,i,o)}}Ilt.forEach(e.children(),t)}function jae(e,t,r,n,i,o){var a={width:0,height:0,rank:o,borderType:t},s=i[t][o-1],l=Psr.addDummyNode(e,"border",a,r);i[t][o]=l,e.setParent(l,n),s&&e.setEdge(s,l,{weight:1})}});var Qae=H((hQn,Jae)=>{"use strict";var Uf=Un();Jae.exports={adjust:Lsr,undo:ksr};function Lsr(e){var t=e.graph().rankdir.toLowerCase();(t==="lr"||t==="rl")&&Zae(e)}function ksr(e){var t=e.graph().rankdir.toLowerCase();(t==="bt"||t==="rl")&&Rsr(e),(t==="lr"||t==="rl")&&(Nsr(e),Zae(e))}function Zae(e){Uf.forEach(e.nodes(),function(t){Kae(e.node(t))}),Uf.forEach(e.edges(),function(t){Kae(e.edge(t))})}function Kae(e){var t=e.width;e.width=e.height,e.height=t}function Rsr(e){Uf.forEach(e.nodes(),function(t){Llt(e.node(t))}),Uf.forEach(e.edges(),function(t){var r=e.edge(t);Uf.forEach(r.points,Llt),Uf.has(r,"y")&&Llt(r)})}function Llt(e){e.y=-e.y}function Nsr(e){Uf.forEach(e.nodes(),function(t){klt(e.node(t))}),Uf.forEach(e.edges(),function(t){var r=e.edge(t);Uf.forEach(r.points,klt),Uf.has(r,"x")&&klt(r)})}function klt(e){var t=e.x;e.x=e.y,e.y=t}});var ese=H((fQn,tse)=>{"use strict";var kd=Un();tse.exports=Dsr;function Dsr(e){var t={},r=kd.filter(e.nodes(),function(s){return!e.children(s).length}),n=kd.max(kd.map(r,function(s){return e.node(s).rank})),i=kd.map(kd.range(n+1),function(){return[]});function o(s){if(!kd.has(t,s)){t[s]=!0;var l=e.node(s);i[l.rank].push(s),kd.forEach(e.successors(s),o)}}var a=kd.sortBy(r,function(s){return e.node(s).rank});return kd.forEach(a,o),i}});var nse=H((pQn,rse)=>{"use strict";var h0=Un();rse.exports=Osr;function Osr(e,t){for(var r=0,n=1;n<t.length;++n)r+=zsr(e,t[n-1],t[n]);return r}function zsr(e,t,r){for(var n=h0.zipObject(r,h0.map(r,function(c,u){return u})),i=h0.flatten(h0.map(t,function(c){return h0.sortBy(h0.map(e.outEdges(c),function(u){return{pos:n[u.w],weight:e.edge(u).weight}}),"pos")}),!0),o=1;o<r.length;)o<<=1;var a=2*o-1;o-=1;var s=h0.map(new Array(a),function(){return 0}),l=0;return h0.forEach(i.forEach(function(c){var u=c.pos+o;s[u]+=c.weight;for(var h=0;u>0;)u%2&&(h+=s[u+1]),u=u-1>>1,s[u]+=c.weight;l+=c.weight*h})),l}});var ase=H((dQn,ose)=>{var ise=Un();ose.exports=Fsr;function Fsr(e,t){return ise.map(t,function(r){var n=e.inEdges(r);if(n.length){var i=ise.reduce(n,function(o,a){var s=e.edge(a),l=e.node(a.v);return{sum:o.sum+s.weight*l.order,weight:o.weight+s.weight}},{sum:0,weight:0});return{v:r,barycenter:i.sum/i.weight,weight:i.weight}}else return{v:r}})}});var lse=H((mQn,sse)=>{"use strict";var Tl=Un();sse.exports=Bsr;function Bsr(e,t){var r={};Tl.forEach(e,function(i,o){var a=r[i.v]={indegree:0,in:[],out:[],vs:[i.v],i:o};Tl.isUndefined(i.barycenter)||(a.barycenter=i.barycenter,a.weight=i.weight)}),Tl.forEach(t.edges(),function(i){var o=r[i.v],a=r[i.w];!Tl.isUndefined(o)&&!Tl.isUndefined(a)&&(a.indegree++,o.out.push(r[i.w]))});var n=Tl.filter(r,function(i){return!i.indegree});return Hsr(n)}function Hsr(e){var t=[];function r(o){return function(a){a.merged||(Tl.isUndefined(a.barycenter)||Tl.isUndefined(o.barycenter)||a.barycenter>=o.barycenter)&&Vsr(o,a)}}function n(o){return function(a){a.in.push(o),--a.indegree===0&&e.push(a)}}for(;e.length;){var i=e.pop();t.push(i),Tl.forEach(i.in.reverse(),r(i)),Tl.forEach(i.out,n(i))}return Tl.map(Tl.filter(t,function(o){return!o.merged}),function(o){return Tl.pick(o,["vs","i","barycenter","weight"])})}function Vsr(e,t){var r=0,n=0;e.weight&&(r+=e.barycenter*e.weight,n+=e.weight),t.weight&&(r+=t.barycenter*t.weight,n+=t.weight),e.vs=t.vs.concat(e.vs),e.barycenter=r/n,e.weight=n,e.i=Math.min(t.i,e.i),t.merged=!0}});var hse=H((gQn,use)=>{var $4=Un(),Usr=ns();use.exports=qsr;function qsr(e,t){var r=Usr.partition(e,function(u){return $4.has(u,"barycenter")}),n=r.lhs,i=$4.sortBy(r.rhs,function(u){return-u.i}),o=[],a=0,s=0,l=0;n.sort(Gsr(!!t)),l=cse(o,i,l),$4.forEach(n,function(u){l+=u.vs.length,o.push(u.vs),a+=u.barycenter*u.weight,s+=u.weight,l=cse(o,i,l)});var c={vs:$4.flatten(o,!0)};return s&&(c.barycenter=a/s,c.weight=s),c}function cse(e,t,r){for(var n;t.length&&(n=$4.last(t)).i<=r;)t.pop(),e.push(n.vs),r++;return r}function Gsr(e){return function(t,r){return t.barycenter<r.barycenter?-1:t.barycenter>r.barycenter?1:e?r.i-t.i:t.i-r.i}}});var dse=H((_Qn,pse)=>{var f0=Un(),Wsr=ase(),Ysr=lse(),jsr=hse();pse.exports=fse;function fse(e,t,r,n){var i=e.children(t),o=e.node(t),a=o?o.borderLeft:void 0,s=o?o.borderRight:void 0,l={};a&&(i=f0.filter(i,function(d){return d!==a&&d!==s}));var c=Wsr(e,i);f0.forEach(c,function(d){if(e.children(d.v).length){var g=fse(e,d.v,r,n);l[d.v]=g,f0.has(g,"barycenter")&&$sr(d,g)}});var u=Ysr(c,r);Xsr(u,l);var h=jsr(u,n);if(a&&(h.vs=f0.flatten([a,h.vs,s],!0),e.predecessors(a).length)){var f=e.node(e.predecessors(a)[0]),p=e.node(e.predecessors(s)[0]);f0.has(h,"barycenter")||(h.barycenter=0,h.weight=0),h.barycenter=(h.barycenter*h.weight+f.order+p.order)/(h.weight+2),h.weight+=2}return h}function Xsr(e,t){f0.forEach(e,function(r){r.vs=f0.flatten(r.vs.map(function(n){return t[n]?t[n].vs:n}),!0)})}function $sr(e,t){f0.isUndefined(e.barycenter)?(e.barycenter=t.barycenter,e.weight=t.weight):(e.barycenter=(e.barycenter*e.weight+t.barycenter*t.weight)/(e.weight+t.weight),e.weight+=t.weight)}});var gse=H((yQn,mse)=>{var K4=Un(),Ksr=Uc().Graph;mse.exports=Zsr;function Zsr(e,t,r){var n=Jsr(e),i=new Ksr({compound:!0}).setGraph({root:n}).setDefaultNodeLabel(function(o){return e.node(o)});return K4.forEach(e.nodes(),function(o){var a=e.node(o),s=e.parent(o);(a.rank===t||a.minRank<=t&&t<=a.maxRank)&&(i.setNode(o),i.setParent(o,s||n),K4.forEach(e[r](o),function(l){var c=l.v===o?l.w:l.v,u=i.edge(c,o),h=K4.isUndefined(u)?0:u.weight;i.setEdge(c,o,{weight:e.edge(l).weight+h})}),K4.has(a,"minRank")&&i.setNode(o,{borderLeft:a.borderLeft[t],borderRight:a.borderRight[t]}))}),i}function Jsr(e){for(var t;e.hasNode(t=K4.uniqueId("_root")););return t}});var yse=H((vQn,_se)=>{var Qsr=Un();_se.exports=tlr;function tlr(e,t,r){var n={},i;Qsr.forEach(r,function(o){for(var a=e.parent(o),s,l;a;){if(s=e.parent(a),s?(l=n[s],n[s]=a):(l=i,i=a),l&&l!==a){t.setEdge(l,a);return}a=s}})}});var Sse=H((xQn,wse)=>{"use strict";var p0=Un(),elr=ese(),rlr=nse(),nlr=dse(),ilr=gse(),olr=yse(),alr=Uc().Graph,vse=ns();wse.exports=slr;function slr(e){var t=vse.maxRank(e),r=xse(e,p0.range(1,t+1),"inEdges"),n=xse(e,p0.range(t-1,-1,-1),"outEdges"),i=elr(e);bse(e,i);for(var o=Number.POSITIVE_INFINITY,a,s=0,l=0;l<4;++s,++l){llr(s%2?r:n,s%4>=2),i=vse.buildLayerMatrix(e);var c=rlr(e,i);c<o&&(l=0,a=p0.cloneDeep(i),o=c)}bse(e,a)}function xse(e,t,r){return p0.map(t,function(n){return ilr(e,n,r)})}function llr(e,t){var r=new alr;p0.forEach(e,function(n){var i=n.graph().root,o=nlr(n,i,r,t);p0.forEach(o.vs,function(a,s){n.node(a).order=s}),olr(n,r,o.vs)})}function bse(e,t){p0.forEach(t,function(r){p0.forEach(r,function(n,i){e.node(n).order=i})})}});var Rse=H((bQn,kse)=>{"use strict";var Xe=Un(),clr=Uc().Graph,ulr=ns();kse.exports={positionX:plr,findType1Conflicts:Mse,findType2Conflicts:Ese,addConflict:Rlt,hasConflict:Tse,verticalAlignment:Cse,horizontalCompaction:Ase,alignCoordinates:Ise,findSmallestWidthAlignment:Pse,balance:Lse};function Mse(e,t){var r={};function n(i,o){var a=0,s=0,l=i.length,c=Xe.last(o);return Xe.forEach(o,function(u,h){var f=hlr(e,u),p=f?e.node(f).order:l;(f||u===c)&&(Xe.forEach(o.slice(s,h+1),function(d){Xe.forEach(e.predecessors(d),function(g){var _=e.node(g),y=_.order;(y<a||p<y)&&!(_.dummy&&e.node(d).dummy)&&Rlt(r,g,d)})}),s=h+1,a=p)}),o}return Xe.reduce(t,n),r}function Ese(e,t){var r={};function n(o,a,s,l,c){var u;Xe.forEach(Xe.range(a,s),function(h){u=o[h],e.node(u).dummy&&Xe.forEach(e.predecessors(u),function(f){var p=e.node(f);p.dummy&&(p.order<l||p.order>c)&&Rlt(r,f,u)})})}function i(o,a){var s=-1,l,c=0;return Xe.forEach(a,function(u,h){if(e.node(u).dummy==="border"){var f=e.predecessors(u);f.length&&(l=e.node(f[0]).order,n(a,c,h,s,l),c=h,s=l)}n(a,c,a.length,l,o.length)}),a}return Xe.reduce(t,i),r}function hlr(e,t){if(e.node(t).dummy)return Xe.find(e.predecessors(t),function(r){return e.node(r).dummy})}function Rlt(e,t,r){if(t>r){var n=t;t=r,r=n}var i=e[t];i||(e[t]=i={}),i[r]=!0}function Tse(e,t,r){if(t>r){var n=t;t=r,r=n}return Xe.has(e[t],r)}function Cse(e,t,r,n){var i={},o={},a={};return Xe.forEach(t,function(s){Xe.forEach(s,function(l,c){i[l]=l,o[l]=l,a[l]=c})}),Xe.forEach(t,function(s){var l=-1;Xe.forEach(s,function(c){var u=n(c);if(u.length){u=Xe.sortBy(u,function(g){return a[g]});for(var h=(u.length-1)/2,f=Math.floor(h),p=Math.ceil(h);f<=p;++f){var d=u[f];o[c]===c&&l<a[d]&&!Tse(r,c,d)&&(o[d]=c,o[c]=i[c]=i[d],l=a[d])}}})}),{root:i,align:o}}function Ase(e,t,r,n,i){var o={},a=flr(e,t,r,i),s=i?"borderLeft":"borderRight";function l(h,f){for(var p=a.nodes(),d=p.pop(),g={};d;)g[d]?h(d):(g[d]=!0,p.push(d),p=p.concat(f(d))),d=p.pop()}function c(h){o[h]=a.inEdges(h).reduce(function(f,p){return Math.max(f,o[p.v]+a.edge(p))},0)}function u(h){var f=a.outEdges(h).reduce(function(d,g){return Math.min(d,o[g.w]-a.edge(g))},Number.POSITIVE_INFINITY),p=e.node(h);f!==Number.POSITIVE_INFINITY&&p.borderType!==s&&(o[h]=Math.max(o[h],f))}return l(c,a.predecessors.bind(a)),l(u,a.successors.bind(a)),Xe.forEach(n,function(h){o[h]=o[r[h]]}),o}function flr(e,t,r,n){var i=new clr,o=e.graph(),a=dlr(o.nodesep,o.edgesep,n);return Xe.forEach(t,function(s){var l;Xe.forEach(s,function(c){var u=r[c];if(i.setNode(u),l){var h=r[l],f=i.edge(h,u);i.setEdge(h,u,Math.max(a(e,c,l),f||0))}l=c})}),i}function Pse(e,t){return Xe.minBy(Xe.values(t),function(r){var n=Number.NEGATIVE_INFINITY,i=Number.POSITIVE_INFINITY;return Xe.forIn(r,function(o,a){var s=mlr(e,a)/2;n=Math.max(o+s,n),i=Math.min(o-s,i)}),n-i})}function Ise(e,t){var r=Xe.values(t),n=Xe.min(r),i=Xe.max(r);Xe.forEach(["u","d"],function(o){Xe.forEach(["l","r"],function(a){var s=o+a,l=e[s],c;if(l!==t){var u=Xe.values(l);c=a==="l"?n-Xe.min(u):i-Xe.max(u),c&&(e[s]=Xe.mapValues(l,function(h){return h+c}))}})})}function Lse(e,t){return Xe.mapValues(e.ul,function(r,n){if(t)return e[t.toLowerCase()][n];var i=Xe.sortBy(Xe.map(e,n));return(i[1]+i[2])/2})}function plr(e){var t=ulr.buildLayerMatrix(e),r=Xe.merge(Mse(e,t),Ese(e,t)),n={},i;Xe.forEach(["u","d"],function(a){i=a==="u"?t:Xe.values(t).reverse(),Xe.forEach(["l","r"],function(s){s==="r"&&(i=Xe.map(i,function(h){return Xe.values(h).reverse()}));var l=(a==="u"?e.predecessors:e.successors).bind(e),c=Cse(e,i,r,l),u=Ase(e,i,c.root,c.align,s==="r");s==="r"&&(u=Xe.mapValues(u,function(h){return-h})),n[a+s]=u})});var o=Pse(e,n);return Ise(n,o),Lse(n,e.graph().align)}function dlr(e,t,r){return function(n,i,o){var a=n.node(i),s=n.node(o),l=0,c;if(l+=a.width/2,Xe.has(a,"labelpos"))switch(a.labelpos.toLowerCase()){case"l":c=-a.width/2;break;case"r":c=a.width/2;break}if(c&&(l+=r?c:-c),c=0,l+=(a.dummy?t:e)/2,l+=(s.dummy?t:e)/2,l+=s.width/2,Xe.has(s,"labelpos"))switch(s.labelpos.toLowerCase()){case"l":c=s.width/2;break;case"r":c=-s.width/2;break}return c&&(l+=r?c:-c),c=0,l}}function mlr(e,t){return e.node(t).width}});var Ose=H((wQn,Dse)=>{"use strict";var Z4=Un(),Nse=ns(),glr=Rse().positionX;Dse.exports=_lr;function _lr(e){e=Nse.asNonCompoundGraph(e),ylr(e),Z4.forEach(glr(e),function(t,r){e.node(r).x=t})}function ylr(e){var t=Nse.buildLayerMatrix(e),r=e.graph().ranksep,n=0;Z4.forEach(t,function(i){var o=Z4.max(Z4.map(i,function(a){return e.node(a).height}));Z4.forEach(i,function(a){e.node(a).y=n+o/2}),n+=o+r})}});var Use=H((SQn,Vse)=>{"use strict";var ir=Un(),zse=xae(),Fse=Cae(),vlr=Vae(),xlr=ns().normalizeRanks,blr=qae(),wlr=ns().removeEmptyRanks,Bse=Yae(),Slr=$ae(),Hse=Qae(),Mlr=Sse(),Elr=Ose(),d0=ns(),Tlr=Uc().Graph;Vse.exports=Clr;function Clr(e,t){var r=t&&t.debugTiming?d0.time:d0.notime;r("layout",function(){var n=r("  buildLayoutGraph",function(){return Flr(e)});r("  runLayout",function(){Alr(n,r)}),r("  updateInputGraph",function(){Plr(e,n)})})}function Alr(e,t){t("    makeSpaceForEdgeLabels",function(){Blr(e)}),t("    removeSelfEdges",function(){Xlr(e)}),t("    acyclic",function(){zse.run(e)}),t("    nestingGraph.run",function(){Bse.run(e)}),t("    rank",function(){vlr(d0.asNonCompoundGraph(e))}),t("    injectEdgeLabelProxies",function(){Hlr(e)}),t("    removeEmptyRanks",function(){wlr(e)}),t("    nestingGraph.cleanup",function(){Bse.cleanup(e)}),t("    normalizeRanks",function(){xlr(e)}),t("    assignRankMinMax",function(){Vlr(e)}),t("    removeEdgeLabelProxies",function(){Ulr(e)}),t("    normalize.run",function(){Fse.run(e)}),t("    parentDummyChains",function(){blr(e)}),t("    addBorderSegments",function(){Slr(e)}),t("    order",function(){Mlr(e)}),t("    insertSelfEdges",function(){$lr(e)}),t("    adjustCoordinateSystem",function(){Hse.adjust(e)}),t("    position",function(){Elr(e)}),t("    positionSelfEdges",function(){Klr(e)}),t("    removeBorderNodes",function(){jlr(e)}),t("    normalize.undo",function(){Fse.undo(e)}),t("    fixupEdgeLabelCoords",function(){Wlr(e)}),t("    undoCoordinateSystem",function(){Hse.undo(e)}),t("    translateGraph",function(){qlr(e)}),t("    assignNodeIntersects",function(){Glr(e)}),t("    reversePoints",function(){Ylr(e)}),t("    acyclic.undo",function(){zse.undo(e)})}function Plr(e,t){ir.forEach(e.nodes(),function(r){var n=e.node(r),i=t.node(r);n&&(n.x=i.x,n.y=i.y,t.children(r).length&&(n.width=i.width,n.height=i.height))}),ir.forEach(e.edges(),function(r){var n=e.edge(r),i=t.edge(r);n.points=i.points,ir.has(i,"x")&&(n.x=i.x,n.y=i.y)}),e.graph().width=t.graph().width,e.graph().height=t.graph().height}var Ilr=["nodesep","edgesep","ranksep","marginx","marginy"],Llr={ranksep:50,edgesep:20,nodesep:50,rankdir:"tb"},klr=["acyclicer","ranker","rankdir","align"],Rlr=["width","height"],Nlr={width:0,height:0},Dlr=["minlen","weight","width","height","labeloffset"],Olr={minlen:1,weight:1,width:0,height:0,labeloffset:10,labelpos:"r"},zlr=["labelpos"];function Flr(e){var t=new Tlr({multigraph:!0,compound:!0}),r=Dlt(e.graph());return t.setGraph(ir.merge({},Llr,Nlt(r,Ilr),ir.pick(r,klr))),ir.forEach(e.nodes(),function(n){var i=Dlt(e.node(n));t.setNode(n,ir.defaults(Nlt(i,Rlr),Nlr)),t.setParent(n,e.parent(n))}),ir.forEach(e.edges(),function(n){var i=Dlt(e.edge(n));t.setEdge(n,ir.merge({},Olr,Nlt(i,Dlr),ir.pick(i,zlr)))}),t}function Blr(e){var t=e.graph();t.ranksep/=2,ir.forEach(e.edges(),function(r){var n=e.edge(r);n.minlen*=2,n.labelpos.toLowerCase()!=="c"&&(t.rankdir==="TB"||t.rankdir==="BT"?n.width+=n.labeloffset:n.height+=n.labeloffset)})}function Hlr(e){ir.forEach(e.edges(),function(t){var r=e.edge(t);if(r.width&&r.height){var n=e.node(t.v),i=e.node(t.w),o={rank:(i.rank-n.rank)/2+n.rank,e:t};d0.addDummyNode(e,"edge-proxy",o,"_ep")}})}function Vlr(e){var t=0;ir.forEach(e.nodes(),function(r){var n=e.node(r);n.borderTop&&(n.minRank=e.node(n.borderTop).rank,n.maxRank=e.node(n.borderBottom).rank,t=ir.max(t,n.maxRank))}),e.graph().maxRank=t}function Ulr(e){ir.forEach(e.nodes(),function(t){var r=e.node(t);r.dummy==="edge-proxy"&&(e.edge(r.e).labelRank=r.rank,e.removeNode(t))})}function qlr(e){var t=Number.POSITIVE_INFINITY,r=0,n=Number.POSITIVE_INFINITY,i=0,o=e.graph(),a=o.marginx||0,s=o.marginy||0;function l(c){var u=c.x,h=c.y,f=c.width,p=c.height;t=Math.min(t,u-f/2),r=Math.max(r,u+f/2),n=Math.min(n,h-p/2),i=Math.max(i,h+p/2)}ir.forEach(e.nodes(),function(c){l(e.node(c))}),ir.forEach(e.edges(),function(c){var u=e.edge(c);ir.has(u,"x")&&l(u)}),t-=a,n-=s,ir.forEach(e.nodes(),function(c){var u=e.node(c);u.x-=t,u.y-=n}),ir.forEach(e.edges(),function(c){var u=e.edge(c);ir.forEach(u.points,function(h){h.x-=t,h.y-=n}),ir.has(u,"x")&&(u.x-=t),ir.has(u,"y")&&(u.y-=n)}),o.width=r-t+a,o.height=i-n+s}function Glr(e){ir.forEach(e.edges(),function(t){var r=e.edge(t),n=e.node(t.v),i=e.node(t.w),o,a;r.points?(o=r.points[0],a=r.points[r.points.length-1]):(r.points=[],o=i,a=n),r.points.unshift(d0.intersectRect(n,o)),r.points.push(d0.intersectRect(i,a))})}function Wlr(e){ir.forEach(e.edges(),function(t){var r=e.edge(t);if(ir.has(r,"x"))switch((r.labelpos==="l"||r.labelpos==="r")&&(r.width-=r.labeloffset),r.labelpos){case"l":r.x-=r.width/2+r.labeloffset;break;case"r":r.x+=r.width/2+r.labeloffset;break}})}function Ylr(e){ir.forEach(e.edges(),function(t){var r=e.edge(t);r.reversed&&r.points.reverse()})}function jlr(e){ir.forEach(e.nodes(),function(t){if(e.children(t).length){var r=e.node(t),n=e.node(r.borderTop),i=e.node(r.borderBottom),o=e.node(ir.last(r.borderLeft)),a=e.node(ir.last(r.borderRight));r.width=Math.abs(a.x-o.x),r.height=Math.abs(i.y-n.y),r.x=o.x+r.width/2,r.y=n.y+r.height/2}}),ir.forEach(e.nodes(),function(t){e.node(t).dummy==="border"&&e.removeNode(t)})}function Xlr(e){ir.forEach(e.edges(),function(t){if(t.v===t.w){var r=e.node(t.v);r.selfEdges||(r.selfEdges=[]),r.selfEdges.push({e:t,label:e.edge(t)}),e.removeEdge(t)}})}function $lr(e){var t=d0.buildLayerMatrix(e);ir.forEach(t,function(r){var n=0;ir.forEach(r,function(i,o){var a=e.node(i);a.order=o+n,ir.forEach(a.selfEdges,function(s){d0.addDummyNode(e,"selfedge",{width:s.label.width,height:s.label.height,rank:a.rank,order:o+ ++n,e:s.e,label:s.label},"_se")}),delete a.selfEdges})})}function Klr(e){ir.forEach(e.nodes(),function(t){var r=e.node(t);if(r.dummy==="selfedge"){var n=e.node(r.e.v),i=n.x+n.width/2,o=n.y,a=r.x-i,s=n.height/2;e.setEdge(r.e,r.label),e.removeNode(t),r.label.points=[{x:i+2*a/3,y:o-s},{x:i+5*a/6,y:o-s},{x:i+a,y:o},{x:i+5*a/6,y:o+s},{x:i+2*a/3,y:o+s}],r.label.x=r.x,r.label.y=r.y}})}function Nlt(e,t){return ir.mapValues(ir.pick(e,t),Number)}function Dlt(e){var t={};return ir.forEach(e,function(r,n){t[n.toLowerCase()]=r}),t}});var Gse=H((MQn,qse)=>{var pH=Un(),Zlr=ns(),Jlr=Uc().Graph;qse.exports={debugOrdering:Qlr};function Qlr(e){var t=Zlr.buildLayerMatrix(e),r=new Jlr({compound:!0,multigraph:!0}).setGraph({});return pH.forEach(e.nodes(),function(n){r.setNode(n,{label:n}),r.setParent(n,"layer"+e.node(n).rank)}),pH.forEach(e.edges(),function(n){r.setEdge(n.v,n.w,{},n.name)}),pH.forEach(t,function(n,i){var o="layer"+i;r.setNode(o,{rank:"same"}),pH.reduce(n,function(a,s){return r.setEdge(a,s,{style:"invis"}),s})}),r}});var Yse=H((EQn,Wse)=>{Wse.exports="0.8.5"});var Olt=H((TQn,jse)=>{jse.exports={graphlib:Uc(),layout:Use(),debug:Gse(),util:{time:ns().time,notime:ns().notime},version:Yse()}});var Vdt=Ee(Hdt(),1),{__extends:d_r,__assign:m_r,__rest:g_r,__decorate:E,__param:__r,__esDecorate:y_r,__runInitializers:v_r,__propKey:x_r,__setFunctionName:b_r,__metadata:w,__awaiter:w_r,__generator:S_r,__exportStar:M_r,__createBinding:E_r,__values:T_r,__read:C_r,__spread:A_r,__spreadArrays:P_r,__spreadArray:I_r,__await:L_r,__asyncGenerator:k_r,__asyncDelegator:R_r,__asyncValues:N_r,__makeTemplateObject:D_r,__importStar:O_r,__importDefault:z_r,__classPrivateFieldGet:F_r,__classPrivateFieldSet:B_r,__classPrivateFieldIn:H_r}=Vdt.default;function yt(e){return t=>{if(e)if(t.hasOwnProperty("is")){if(e!==t.is)throw new Error(`custom element tag names do not match: (${e} !== ${t.is})`)}else Object.defineProperty(t,"is",{value:e});window.customElements.define(t.is,t)}}function Udt(e,t,r){e.constructor.hasOwnProperty("properties")||Object.defineProperty(e.constructor,"properties",{value:{}}),e.constructor.properties[t]=Object.assign({},e.constructor.properties[t],r)}function A(e){return(t,r)=>{Udt(t,r,e)}}function Bt(...e){return(t,r)=>{t.constructor.hasOwnProperty("observers")||Object.defineProperty(t.constructor,"observers",{value:[]}),t.constructor.observers.push(`${r}(${e.join(",")})`)}}function Rt(e,...t){return(r,n,i)=>{let o=`__compute${n}`;Object.defineProperty(r,o,{value:i.get}),i.get=void 0;let a=[e,...t].join(",");Udt(r,n,{computed:`${o}(${a})`})}}var U_r=qdt((e,t)=>e.querySelector(t)),q_r=qdt((e,t)=>e.querySelectorAll(t));function qdt(e){return t=>(r,n)=>{Object.defineProperty(r,n,{get(){return e(this.shadowRoot,t)},enumerable:!0,configurable:!0})}}window.JSCompiler_renameProperty=function(e,t){return e};var Tve=/(url\()([^)]*)(\))/g,Cve=/(^\/[^\/])|(^#)|(^[\w-\d]*:)/,II,Zs;function l_(e,t){if(e&&Cve.test(e)||e==="//")return e;if(II===void 0){II=!1;try{let r=new URL("b","http://a");r.pathname="c%20d",II=r.href==="http://a/c%20d"}catch(r){}}if(t||(t=document.baseURI||window.location.href),II)try{return new URL(e,t).href}catch(r){return e}return Zs||(Zs=document.implementation.createHTMLDocument("temp"),Zs.base=Zs.createElement("base"),Zs.head.appendChild(Zs.base),Zs.anchor=Zs.createElement("a"),Zs.body.appendChild(Zs.anchor)),Zs.base.href=t,Zs.anchor.href=e,Zs.anchor.href||e}function HM(e,t){return e.replace(Tve,function(r,n,i,o){return n+"'"+l_(i.replace(/["']/g,""),t)+"'"+o})}function Cx(e){return e.substring(0,e.lastIndexOf("/")+1)}var c_=!window.ShadyDOM||!window.ShadyDOM.inUse,$_r=Boolean(!window.ShadyCSS||window.ShadyCSS.nativeCss),K_r=!window.customElements.polyfillWrapFlushCallback,Gdt=c_&&"adoptedStyleSheets"in Document.prototype&&"replaceSync"in CSSStyleSheet.prototype&&(()=>{try{let e=new CSSStyleSheet;e.replaceSync("");let t=document.createElement("div");return t.attachShadow({mode:"open"}),t.shadowRoot.adoptedStyleSheets=[e],t.shadowRoot.adoptedStyleSheets[0]===e}catch(e){return!1}})(),Wdt=window.Polymer&&window.Polymer.rootPath||Cx(document.baseURI||window.location.href);var VM=window.Polymer&&window.Polymer.sanitizeDOMValue||void 0;var Ydt=window.Polymer&&window.Polymer.setPassiveTouchGestures||!1;var iu=window.Polymer&&window.Polymer.strictTemplatePolicy||!1;var jdt=window.Polymer&&window.Polymer.allowTemplateFromDomModule||!1;var pp=window.Polymer&&window.Polymer.legacyOptimizations||!1;var LI=window.Polymer&&window.Polymer.legacyWarnings||!1;var Xdt=window.Polymer&&window.Polymer.syncInitialRender||!1;var kI=window.Polymer&&window.Polymer.legacyUndefined||!1;var $dt=window.Polymer&&window.Polymer.orderedComputed||!1;var fG=!0;var pG=window.Polymer&&window.Polymer.removeNestedTemplates||!1;var RI=window.Polymer&&window.Polymer.fastDomIf||!1;var UM=window.Polymer&&window.Polymer.suppressTemplateNotifications||!1;var qM=window.Polymer&&window.Polymer.legacyNoObservedAttributes||!1;var Kdt=window.Polymer&&window.Polymer.useAdoptedStyleSheetsWithBuiltCSS||!1;var Ave=0;function Zdt(){}Zdt.prototype.__mixinApplications;Zdt.prototype.__mixinSet;var Rn=function(e){let t=e.__mixinApplications;t||(t=new WeakMap,e.__mixinApplications=t);let r=Ave++;function n(i){let o=i.__mixinSet;if(o&&o[r])return i;let a=t,s=a.get(i);if(!s){s=e(i),a.set(i,s);let l=Object.create(s.__mixinSet||o||null);l[r]=!0,s.__mixinSet=l}return s}return n};var dG={},tmt={};function Jdt(e,t){dG[e]=tmt[e.toLowerCase()]=t}function Qdt(e){return dG[e]||tmt[e.toLowerCase()]}function Pve(e){e.querySelector("style")&&console.warn("dom-module %s has style outside template",e.id)}var ou=class extends HTMLElement{static get observedAttributes(){return["id"]}static import(t,r){if(t){let n=Qdt(t);return n&&r?n.querySelector(r):n}return null}attributeChangedCallback(t,r,n,i){r!==n&&this.register()}get assetpath(){if(!this.__assetpath){let t=window.HTMLImports&&HTMLImports.importForElement?HTMLImports.importForElement(this)||document:this.ownerDocument,r=l_(this.getAttribute("assetpath")||"",t.baseURI);this.__assetpath=Cx(r)}return this.__assetpath}register(t){if(t=t||this.id,t){if(iu&&Qdt(t)!==void 0)throw Jdt(t,null),new Error(`strictTemplatePolicy: dom-module ${t} re-registered`);this.id=t,Jdt(t,this),Pve(this)}}};ou.prototype.modules=dG;customElements.define("dom-module",ou);var Ive="link[rel=import][type~=css]",Lve="include",emt="shady-unscoped";function mG(e){return ou.import(e)}function rmt(e){let t=e.body?e.body:e,r=HM(t.textContent,e.baseURI),n=document.createElement("style");return n.textContent=r,n}function kve(e){let t=e.trim().split(/\s+/),r=[];for(let n=0;n<t.length;n++)r.push(...Rve(t[n]));return r}function Rve(e){let t=mG(e);if(!t)return console.warn("Could not find style data in module named",e),[];if(t._styles===void 0){let r=[];r.push(...gG(t));let n=t.querySelector("template");n&&r.push(...NI(n,t.assetpath)),t._styles=r}return t._styles}function NI(e,t){if(!e._styles){let r=[],n=e.content.querySelectorAll("style");for(let i=0;i<n.length;i++){let o=n[i],a=o.getAttribute(Lve);a&&r.push(...kve(a).filter(function(s,l,c){return c.indexOf(s)===l})),t&&(o.textContent=HM(o.textContent,t)),r.push(o)}e._styles=r}return e._styles}function nmt(e){let t=mG(e);return t?gG(t):[]}function gG(e){let t=[],r=e.querySelectorAll(Ive);for(let n=0;n<r.length;n++){let i=r[n];if(i.import){let o=i.import,a=i.hasAttribute(emt);if(a&&!o._unscopedStyle){let s=rmt(o);s.setAttribute(emt,""),o._unscopedStyle=s}else o._style||(o._style=rmt(o));t.push(a?o._unscopedStyle:o._style)}}return t}function imt(e){let t=e.trim().split(/\s+/),r="";for(let n=0;n<t.length;n++)r+=Nve(t[n]);return r}function Nve(e){let t=mG(e);if(t&&t._cssText===void 0){let r=Ove(t),n=t.querySelector("template");n&&(r+=Dve(n,t.assetpath)),t._cssText=r||null}return t||console.warn("Could not find style data in module named",e),t&&t._cssText||""}function Dve(e,t){let r="",n=NI(e,t);for(let i=0;i<n.length;i++){let o=n[i];o.parentNode&&o.parentNode.removeChild(o),r+=o.textContent}return r}function Ove(e){let t="",r=gG(e);for(let n=0;n<r.length;n++)t+=r[n].textContent;return t}var ue=window.ShadyDOM&&window.ShadyDOM.noPatch&&window.ShadyDOM.wrap?window.ShadyDOM.wrap:window.ShadyDOM?e=>ShadyDOM.patch(e):e=>e;function DI(e){return e.indexOf(".")>=0}function au(e){let t=e.indexOf(".");return t===-1?e:e.slice(0,t)}function _G(e,t){return e.indexOf(t+".")===0}function Ax(e,t){return t.indexOf(e+".")===0}function dp(e,t,r){return t+r.slice(e.length)}function OI(e,t){return e===t||_G(e,t)||Ax(e,t)}function Px(e){if(Array.isArray(e)){let t=[];for(let r=0;r<e.length;r++){let n=e[r].toString().split(".");for(let i=0;i<n.length;i++)t.push(n[i])}return t.join(".")}else return e}function omt(e){return Array.isArray(e)?Px(e).split("."):e.toString().split(".")}function No(e,t,r){let n=e,i=omt(t);for(let o=0;o<i.length;o++){if(!n)return;let a=i[o];n=n[a]}return r&&(r.path=i.join(".")),n}function yG(e,t,r){let n=e,i=omt(t),o=i[i.length-1];if(i.length>1){for(let a=0;a<i.length-1;a++){let s=i[a];if(n=n[s],!n)return}n[o]=r}else n[t]=r;return i.join(".")}var zI={},zve=/-[a-z]/g,Fve=/([A-Z])/g;function wm(e){return zI[e]||(zI[e]=e.indexOf("-")<0?e:e.replace(zve,t=>t[1].toUpperCase()))}function Ix(e){return zI[e]||(zI[e]=e.replace(Fve,"-$1").toLowerCase())}var Bve=0,amt=0,Lx=[],Hve=0,vG=!1,smt=document.createTextNode("");new window.MutationObserver(Vve).observe(smt,{characterData:!0});function Vve(){vG=!1;let e=Lx.length;for(let t=0;t<e;t++){let r=Lx[t];if(r)try{r()}catch(n){setTimeout(()=>{throw n})}}Lx.splice(0,e),amt+=e}var mo={after(e){return{run(t){return window.setTimeout(t,e)},cancel(t){window.clearTimeout(t)}}},run(e,t){return window.setTimeout(e,t)},cancel(e){window.clearTimeout(e)}};var Ni={run(e){return window.requestAnimationFrame(e)},cancel(e){window.cancelAnimationFrame(e)}};var kx={run(e){return window.requestIdleCallback?window.requestIdleCallback(e):window.setTimeout(e,16)},cancel(e){window.cancelIdleCallback?window.cancelIdleCallback(e):window.clearTimeout(e)}};var li={run(e){return vG||(vG=!0,smt.textContent=Hve++),Lx.push(e),Bve++},cancel(e){let t=e-amt;if(t>=0){if(!Lx[t])throw new Error("invalid async handle: "+e);Lx[t]=null}}};var Uve=li,FI=Rn(e=>{class t extends e{static createProperties(n){let i=this.prototype;for(let o in n)o in i||i._createPropertyAccessor(o)}static attributeNameForProperty(n){return n.toLowerCase()}static typeForProperty(n){}_createPropertyAccessor(n,i){this._addPropertyToAttributeMap(n),this.hasOwnProperty(JSCompiler_renameProperty("__dataHasAccessor",this))||(this.__dataHasAccessor=Object.assign({},this.__dataHasAccessor)),this.__dataHasAccessor[n]||(this.__dataHasAccessor[n]=!0,this._definePropertyAccessor(n,i))}_addPropertyToAttributeMap(n){this.hasOwnProperty(JSCompiler_renameProperty("__dataAttributes",this))||(this.__dataAttributes=Object.assign({},this.__dataAttributes));let i=this.__dataAttributes[n];return i||(i=this.constructor.attributeNameForProperty(n),this.__dataAttributes[i]=n),i}_definePropertyAccessor(n,i){Object.defineProperty(this,n,{get(){return this.__data[n]},set:i?function(){}:function(o){this._setPendingProperty(n,o,!0)&&this._invalidateProperties()}})}constructor(){super(),this.__dataEnabled=!1,this.__dataReady=!1,this.__dataInvalid=!1,this.__data={},this.__dataPending=null,this.__dataOld=null,this.__dataInstanceProps=null,this.__dataCounter=0,this.__serializing=!1,this._initializeProperties()}ready(){this.__dataReady=!0,this._flushProperties()}_initializeProperties(){for(let n in this.__dataHasAccessor)this.hasOwnProperty(n)&&(this.__dataInstanceProps=this.__dataInstanceProps||{},this.__dataInstanceProps[n]=this[n],delete this[n])}_initializeInstanceProperties(n){Object.assign(this,n)}_setProperty(n,i){this._setPendingProperty(n,i)&&this._invalidateProperties()}_getProperty(n){return this.__data[n]}_setPendingProperty(n,i,o){let a=this.__data[n],s=this._shouldPropertyChange(n,i,a);return s&&(this.__dataPending||(this.__dataPending={},this.__dataOld={}),this.__dataOld&&!(n in this.__dataOld)&&(this.__dataOld[n]=a),this.__data[n]=i,this.__dataPending[n]=i),s}_isPropertyPending(n){return!!(this.__dataPending&&this.__dataPending.hasOwnProperty(n))}_invalidateProperties(){!this.__dataInvalid&&this.__dataReady&&(this.__dataInvalid=!0,Uve.run(()=>{this.__dataInvalid&&(this.__dataInvalid=!1,this._flushProperties())}))}_enableProperties(){this.__dataEnabled||(this.__dataEnabled=!0,this.__dataInstanceProps&&(this._initializeInstanceProperties(this.__dataInstanceProps),this.__dataInstanceProps=null),this.ready())}_flushProperties(){this.__dataCounter++;let n=this.__data,i=this.__dataPending,o=this.__dataOld;this._shouldPropertiesChange(n,i,o)&&(this.__dataPending=null,this.__dataOld=null,this._propertiesChanged(n,i,o)),this.__dataCounter--}_shouldPropertiesChange(n,i,o){return Boolean(i)}_propertiesChanged(n,i,o){}_shouldPropertyChange(n,i,o){return o!==i&&(o===o||i===i)}attributeChangedCallback(n,i,o,a){i!==o&&this._attributeToProperty(n,o),super.attributeChangedCallback&&super.attributeChangedCallback(n,i,o,a)}_attributeToProperty(n,i,o){if(!this.__serializing){let a=this.__dataAttributes,s=a&&a[n]||n;this[s]=this._deserializeValue(i,o||this.constructor.typeForProperty(s))}}_propertyToAttribute(n,i,o){this.__serializing=!0,o=arguments.length<3?this[n]:o,this._valueToNodeAttribute(this,o,i||this.constructor.attributeNameForProperty(n)),this.__serializing=!1}_valueToNodeAttribute(n,i,o){let a=this._serializeValue(i);(o==="class"||o==="name"||o==="slot")&&(n=ue(n)),a===void 0?n.removeAttribute(o):n.setAttribute(o,a)}_serializeValue(n){switch(typeof n){case"boolean":return n?"":void 0;default:return n!=null?n.toString():void 0}}_deserializeValue(n,i){switch(i){case Boolean:return n!==null;case Number:return Number(n);default:return n}}}return t});var lmt={},BI=HTMLElement.prototype;for(;BI;){let e=Object.getOwnPropertyNames(BI);for(let t=0;t<e.length;t++)lmt[e[t]]=!0;BI=Object.getPrototypeOf(BI)}function qve(e,t){if(!lmt[t]){let r=e[t];r!==void 0&&(e.__data?e._setPendingProperty(t,r):(e.__dataProto?e.hasOwnProperty(JSCompiler_renameProperty("__dataProto",e))||(e.__dataProto=Object.create(e.__dataProto)):e.__dataProto={},e.__dataProto[t]=r))}}var HI=Rn(e=>{let t=FI(e);class r extends t{static createPropertiesForAttributes(){let i=this.observedAttributes;for(let o=0;o<i.length;o++)this.prototype._createPropertyAccessor(wm(i[o]))}static attributeNameForProperty(i){return Ix(i)}_initializeProperties(){this.__dataProto&&(this._initializeProtoProperties(this.__dataProto),this.__dataProto=null),super._initializeProperties()}_initializeProtoProperties(i){for(let o in i)this._setProperty(o,i[o])}_ensureAttribute(i,o){let a=this;a.hasAttribute(i)||this._valueToNodeAttribute(a,o,i)}_serializeValue(i){switch(typeof i){case"object":if(i instanceof Date)return i.toString();if(i)try{return JSON.stringify(i)}catch(o){return""}default:return super._serializeValue(i)}}_deserializeValue(i,o){let a;switch(o){case Object:try{a=JSON.parse(i)}catch(s){a=i}break;case Array:try{a=JSON.parse(i)}catch(s){a=null,console.warn(`Polymer::Attributes: couldn't decode Array as JSON: ${i}`)}break;case Date:a=isNaN(i)?String(i):Number(i),a=new Date(a);break;default:a=super._deserializeValue(i,o);break}return a}_definePropertyAccessor(i,o){qve(this,i),super._definePropertyAccessor(i,o)}_hasAccessor(i){return this.__dataHasAccessor&&this.__dataHasAccessor[i]}_isPropertyPending(i){return Boolean(this.__dataPending&&i in this.__dataPending)}}return r});var Gve={"dom-if":!0,"dom-repeat":!0},cmt=!1,umt=!1;function Wve(){if(!cmt){cmt=!0;let e=document.createElement("textarea");e.placeholder="a",umt=e.placeholder===e.textContent}return umt}function Yve(e){Wve()&&e.localName==="textarea"&&e.placeholder&&e.placeholder===e.textContent&&(e.textContent=null)}function jve(e){let t=e.getAttribute("is");if(t&&Gve[t]){let r=e;for(r.removeAttribute("is"),e=r.ownerDocument.createElement(t),r.parentNode.replaceChild(e,r),e.appendChild(r);r.attributes.length;)e.setAttribute(r.attributes[0].name,r.attributes[0].value),r.removeAttribute(r.attributes[0].name)}return e}function hmt(e,t){let r=t.parentInfo&&hmt(e,t.parentInfo);if(r){for(let n=r.firstChild,i=0;n;n=n.nextSibling)if(t.parentIndex===i++)return n}else return e}function Xve(e,t,r,n){n.id&&(t[n.id]=r)}function $ve(e,t,r){if(r.events&&r.events.length)for(let n=0,i=r.events,o;n<i.length&&(o=i[n]);n++)e._addMethodEventListenerToNode(t,o.name,o.value,e)}function Kve(e,t,r,n){r.templateInfo&&(t._templateInfo=r.templateInfo,t._parentTemplateInfo=n)}function Zve(e,t,r){return e=e._methodHost||e,function(i){e[r]?e[r](i,i.detail):console.warn("listener method `"+r+"` not defined")}}var fmt=Rn(e=>{class t extends e{static _parseTemplate(n,i){if(!n._templateInfo){let o=n._templateInfo={};o.nodeInfoList=[],o.nestedTemplate=Boolean(i),o.stripWhiteSpace=i&&i.stripWhiteSpace||n.hasAttribute("strip-whitespace"),this._parseTemplateContent(n,o,{parent:null})}return n._templateInfo}static _parseTemplateContent(n,i,o){return this._parseTemplateNode(n.content,i,o)}static _parseTemplateNode(n,i,o){let a=!1,s=n;return s.localName=="template"&&!s.hasAttribute("preserve-content")?a=this._parseTemplateNestedTemplate(s,i,o)||a:s.localName==="slot"&&(i.hasInsertionPoint=!0),Yve(s),s.firstChild&&this._parseTemplateChildNodes(s,i,o),s.hasAttributes&&s.hasAttributes()&&(a=this._parseTemplateNodeAttributes(s,i,o)||a),a||o.noted}static _parseTemplateChildNodes(n,i,o){if(!(n.localName==="script"||n.localName==="style"))for(let a=n.firstChild,s=0,l;a;a=l){if(a.localName=="template"&&(a=jve(a)),l=a.nextSibling,a.nodeType===Node.TEXT_NODE){let u=l;for(;u&&u.nodeType===Node.TEXT_NODE;)a.textContent+=u.textContent,l=u.nextSibling,n.removeChild(u),u=l;if(i.stripWhiteSpace&&!a.textContent.trim()){n.removeChild(a);continue}}let c={parentIndex:s,parentInfo:o};this._parseTemplateNode(a,i,c)&&(c.infoIndex=i.nodeInfoList.push(c)-1),a.parentNode&&s++}}static _parseTemplateNestedTemplate(n,i,o){let a=n,s=this._parseTemplate(a,i);return(s.content=a.content.ownerDocument.createDocumentFragment()).appendChild(a.content),o.templateInfo=s,!0}static _parseTemplateNodeAttributes(n,i,o){let a=!1,s=Array.from(n.attributes);for(let l=s.length-1,c;c=s[l];l--)a=this._parseTemplateNodeAttribute(n,i,o,c.name,c.value)||a;return a}static _parseTemplateNodeAttribute(n,i,o,a,s){return a.slice(0,3)==="on-"?(n.removeAttribute(a),o.events=o.events||[],o.events.push({name:a.slice(3),value:s}),!0):a==="id"?(o.id=s,!0):!1}static _contentForTemplate(n){let i=n._templateInfo;return i&&i.content||n.content}_stampTemplate(n,i){n&&!n.content&&window.HTMLTemplateElement&&HTMLTemplateElement.decorate&&HTMLTemplateElement.decorate(n),i=i||this.constructor._parseTemplate(n);let o=i.nodeInfoList,a=i.content||n.content,s=document.importNode(a,!0);s.__noInsertionPoint=!i.hasInsertionPoint;let l=s.nodeList=new Array(o.length);s.$={};for(let c=0,u=o.length,h;c<u&&(h=o[c]);c++){let f=l[c]=hmt(s,h);Xve(this,s.$,f,h),Kve(this,f,h,i),$ve(this,f,h)}return s=s,s}_addMethodEventListenerToNode(n,i,o,a){a=a||n;let s=Zve(a,i,o);return this._addEventListenerToNode(n,i,s),s}_addEventListenerToNode(n,i,o){n.addEventListener(i,o)}_removeEventListenerFromNode(n,i,o){n.removeEventListener(i,o)}}return t});var jM=0,XM=[],zr={COMPUTE:"__computeEffects",REFLECT:"__reflectEffects",NOTIFY:"__notifyEffects",PROPAGATE:"__propagateEffects",OBSERVE:"__observeEffects",READ_ONLY:"__readOnly"},xmt="__computeInfo",Jve=/[A-Z]/;function xG(e,t,r){let n=e[t];if(!n)n=e[t]={};else if(!e.hasOwnProperty(t)&&(n=e[t]=Object.create(e[t]),r))for(let i in n){let o=n[i],a=n[i]=Array(o.length);for(let s=0;s<o.length;s++)a[s]=o[s]}return n}function YM(e,t,r,n,i,o){if(t){let a=!1,s=jM++;for(let l in r){let c=i?au(l):l,u=t[c];if(u)for(let h=0,f=u.length,p;h<f&&(p=u[h]);h++)(!p.info||p.info.lastRun!==s)&&(!i||MG(l,p.trigger))&&(p.info&&(p.info.lastRun=s),p.fn(e,l,r,n,p.info,i,o),a=!0)}return a}return!1}function Qve(e,t,r,n,i,o,a,s){let l=!1,c=a?au(n):n,u=t[c];if(u)for(let h=0,f=u.length,p;h<f&&(p=u[h]);h++)(!p.info||p.info.lastRun!==r)&&(!a||MG(n,p.trigger))&&(p.info&&(p.info.lastRun=r),p.fn(e,n,i,o,p.info,a,s),l=!0);return l}function MG(e,t){if(t){let r=t.name;return r==e||!!(t.structured&&_G(r,e))||!!(t.wildcard&&Ax(r,e))}else return!0}function pmt(e,t,r,n,i){let o=typeof i.method=="string"?e[i.method]:i.method,a=i.property;o?o.call(e,e.__data[a],n[a]):i.dynamicFn||console.warn("observer method `"+i.method+"` not defined")}function t1e(e,t,r,n,i){let o=e[zr.NOTIFY],a,s=jM++;for(let c in t)t[c]&&(o&&Qve(e,o,s,c,r,n,i)||i&&e1e(e,c,r))&&(a=!0);let l;a&&(l=e.__dataHost)&&l._invalidateProperties&&l._invalidateProperties()}function e1e(e,t,r){let n=au(t);if(n!==t){let i=Ix(n)+"-changed";return bmt(e,i,r[t],t),!0}return!1}function bmt(e,t,r,n){let i={value:r,queueProperty:!0};n&&(i.path=n),ue(e).dispatchEvent(new CustomEvent(t,{detail:i}))}function r1e(e,t,r,n,i,o){let s=(o?au(t):t)!=t?t:null,l=s?No(e,s):e.__data[t];s&&l===void 0&&(l=r[t]),bmt(e,i.eventName,l,s)}function n1e(e,t,r,n,i){let o,a=e.detail,s=a&&a.path;s?(n=dp(r,n,s),o=a&&a.value):o=e.currentTarget[r],o=i?!o:o,(!t[zr.READ_ONLY]||!t[zr.READ_ONLY][n])&&t._setPendingPropertyOrPath(n,o,!0,Boolean(s))&&(!a||!a.queueProperty)&&t._invalidateProperties()}function i1e(e,t,r,n,i){let o=e.__data[t];VM&&(o=VM(o,i.attrName,"attribute",e)),e._propertyToAttribute(t,i.attrName,o)}function o1e(e,t,r,n){let i=e[zr.COMPUTE];if(i)if($dt){jM++;let o=s1e(e),a=[];for(let l in t)dmt(l,i,a,o,n);let s;for(;s=a.shift();)wmt(e,"",t,r,s)&&dmt(s.methodInfo,i,a,o,n);Object.assign(r,e.__dataOld),Object.assign(t,e.__dataPending),e.__dataPending=null}else{let o=t;for(;YM(e,i,o,r,n);)Object.assign(r,e.__dataOld),Object.assign(t,e.__dataPending),o=e.__dataPending,e.__dataPending=null}}var a1e=(e,t,r)=>{let n=0,i=t.length-1,o=-1;for(;n<=i;){let a=n+i>>1,s=r.get(t[a].methodInfo)-r.get(e.methodInfo);if(s<0)n=a+1;else if(s>0)i=a-1;else{o=a;break}}o<0&&(o=i+1),t.splice(o,0,e)},dmt=(e,t,r,n,i)=>{let o=i?au(e):e,a=t[o];if(a)for(let s=0;s<a.length;s++){let l=a[s];l.info.lastRun!==jM&&(!i||MG(e,l.trigger))&&(l.info.lastRun=jM,a1e(l.info,r,n))}};function s1e(e){let t=e.constructor.__orderedComputedDeps;if(!t){t=new Map;let r=e[zr.COMPUTE],{counts:n,ready:i,total:o}=l1e(e),a;for(;a=i.shift();){t.set(a,t.size);let s=r[a];s&&s.forEach(l=>{let c=l.info.methodInfo;--o,--n[c]===0&&i.push(c)})}o!==0&&console.warn(`Computed graph for ${e.localName} incomplete; circular?`),e.constructor.__orderedComputedDeps=t}return t}function l1e(e){let t=e[xmt],r={},n=e[zr.COMPUTE],i=[],o=0;for(let a in t){let s=t[a];o+=r[a]=s.args.filter(l=>!l.literal).length+(s.dynamicFn?1:0)}for(let a in n)t[a]||i.push(a);return{counts:r,ready:i,total:o}}function wmt(e,t,r,n,i){let o=SG(e,t,r,n,i);if(o===XM)return!1;let a=i.methodInfo;return e.__dataHasAccessor&&e.__dataHasAccessor[a]?e._setPendingProperty(a,o,!0):(e[a]=o,!1)}function c1e(e,t,r){let n=e.__dataLinkedPaths;if(n){let i;for(let o in n){let a=n[o];Ax(o,t)?(i=dp(o,a,t),e._setPendingPropertyOrPath(i,r,!0,!0)):Ax(a,t)&&(i=dp(a,o,t),e._setPendingPropertyOrPath(i,r,!0,!0))}}}function bG(e,t,r,n,i,o,a){r.bindings=r.bindings||[];let s={kind:n,target:i,parts:o,literal:a,isCompound:o.length!==1};if(r.bindings.push(s),d1e(s)){let{event:c,negate:u}=s.parts[0];s.listenerEvent=c||Ix(i)+"-changed",s.listenerNegate=u}let l=t.nodeInfoList.length;for(let c=0;c<s.parts.length;c++){let u=s.parts[c];u.compoundIndex=c,u1e(e,t,s,u,l)}}function u1e(e,t,r,n,i){if(!n.literal)if(r.kind==="attribute"&&r.target[0]==="-")console.warn("Cannot set attribute "+r.target+' because "-" is not a valid attribute starting character');else{let o=n.dependencies,a={index:i,binding:r,part:n,evaluator:e};for(let s=0;s<o.length;s++){let l=o[s];typeof l=="string"&&(l=Mmt(l),l.wildcard=!0),e._addTemplatePropertyEffect(t,l.rootProperty,{fn:h1e,info:a,trigger:l})}}}function h1e(e,t,r,n,i,o,a){let s=a[i.index],l=i.binding,c=i.part;if(o&&c.source&&t.length>c.source.length&&l.kind=="property"&&!l.isCompound&&s.__isPropertyEffectsClient&&s.__dataHasAccessor&&s.__dataHasAccessor[l.target]){let u=r[t];t=dp(c.source,l.target,t),s._setPendingPropertyOrPath(t,u,!1,!0)&&e._enqueueClient(s)}else{let u=i.evaluator._evaluateBinding(e,c,t,r,n,o);u!==XM&&f1e(e,s,l,c,u)}}function f1e(e,t,r,n,i){if(i=p1e(t,i,r,n),VM&&(i=VM(i,r.target,r.kind,t)),r.kind=="attribute")e._valueToNodeAttribute(t,i,r.target);else{let o=r.target;t.__isPropertyEffectsClient&&t.__dataHasAccessor&&t.__dataHasAccessor[o]?(!t[zr.READ_ONLY]||!t[zr.READ_ONLY][o])&&t._setPendingProperty(o,i)&&e._enqueueClient(t):e._setUnmanagedPropertyToNode(t,o,i)}}function p1e(e,t,r,n){if(r.isCompound){let i=e.__dataCompoundStorage[r.target];i[n.compoundIndex]=t,t=i.join("")}return r.kind!=="attribute"&&(r.target==="textContent"||r.target==="value"&&(e.localName==="input"||e.localName==="textarea"))&&(t=t==null?"":t),t}function d1e(e){return Boolean(e.target)&&e.kind!="attribute"&&e.kind!="text"&&!e.isCompound&&e.parts[0].mode==="{"}function m1e(e,t){let{nodeList:r,nodeInfoList:n}=t;if(n.length)for(let i=0;i<n.length;i++){let o=n[i],a=r[i],s=o.bindings;if(s)for(let l=0;l<s.length;l++){let c=s[l];g1e(a,c),_1e(a,e,c)}a.__dataHost=e}}function g1e(e,t){if(t.isCompound){let r=e.__dataCompoundStorage||(e.__dataCompoundStorage={}),n=t.parts,i=new Array(n.length);for(let a=0;a<n.length;a++)i[a]=n[a].literal;let o=t.target;r[o]=i,t.literal&&t.kind=="property"&&(o==="className"&&(e=ue(e)),e[o]=t.literal)}}function _1e(e,t,r){if(r.listenerEvent){let n=r.parts[0];e.addEventListener(r.listenerEvent,function(i){n1e(i,t,r.target,n.source,n.negate)})}}function mmt(e,t,r,n,i,o){o=t.static||o&&(typeof o!="object"||o[t.methodName]);let a={methodName:t.methodName,args:t.args,methodInfo:i,dynamicFn:o};for(let s=0,l;s<t.args.length&&(l=t.args[s]);s++)l.literal||e._addPropertyEffect(l.rootProperty,r,{fn:n,info:a,trigger:l});return o&&e._addPropertyEffect(t.methodName,r,{fn:n,info:a}),a}function SG(e,t,r,n,i){let o=e._methodHost||e,a=o[i.methodName];if(a){let s=e._marshalArgs(i.args,t,r);return s===XM?XM:a.apply(o,s)}else i.dynamicFn||console.warn("method `"+i.methodName+"` not defined")}var y1e=[],Smt="(?:[a-zA-Z_$][\\w.:$\\-*]*)",v1e="(?:[-+]?[0-9]*\\.?[0-9]+(?:[eE][-+]?[0-9]+)?)",x1e="(?:'(?:[^'\\\\]|\\\\.)*')",b1e='(?:"(?:[^"\\\\]|\\\\.)*")',w1e="(?:"+x1e+"|"+b1e+")",gmt="(?:("+Smt+"|"+v1e+"|"+w1e+")\\s*)",S1e="(?:"+gmt+"(?:,\\s*"+gmt+")*)",M1e="(?:\\(\\s*(?:"+S1e+"?)\\)\\s*)",E1e="("+Smt+"\\s*"+M1e+"?)",T1e="(\\[\\[|{{)\\s*",C1e="(?:]]|}})",A1e="(?:(!)\\s*)?",P1e=T1e+A1e+E1e+C1e,_mt=new RegExp(P1e,"g");function ymt(e){let t="";for(let r=0;r<e.length;r++)t+=e[r].literal||"";return t}function wG(e){let t=e.match(/([^\s]+?)\(([\s\S]*)\)/);if(t){let n={methodName:t[1],static:!0,args:y1e};if(t[2].trim()){let i=t[2].replace(/\\,/g,"&comma;").split(",");return I1e(i,n)}else return n}return null}function I1e(e,t){return t.args=e.map(function(r){let n=Mmt(r);return n.literal||(t.static=!1),n},this),t}function Mmt(e){let t=e.trim().replace(/&comma;/g,",").replace(/\\(.)/g,"$1"),r={name:t,value:"",literal:!1},n=t[0];switch(n==="-"&&(n=t[1]),n>="0"&&n<="9"&&(n="#"),n){case"'":case'"':r.value=t.slice(1,-1),r.literal=!0;break;case"#":r.value=Number(t),r.literal=!0;break}return r.literal||(r.rootProperty=au(t),r.structured=DI(t),r.structured&&(r.wildcard=t.slice(-2)==".*",r.wildcard&&(r.name=t.slice(0,-2)))),r}function vmt(e,t,r){let n=No(e,r);return n===void 0&&(n=t[r]),n}function Emt(e,t,r,n){let i={indexSplices:n};kI&&!e._overrideLegacyUndefined&&(t.splices=i),e.notifyPath(r+".splices",i),e.notifyPath(r+".length",t.length),kI&&!e._overrideLegacyUndefined&&(i.indexSplices=[])}function GM(e,t,r,n,i,o){Emt(e,t,r,[{index:n,addedCount:i,removed:o,object:t,type:"splice"}])}function L1e(e){return e[0].toUpperCase()+e.substring(1)}var u_=Rn(e=>{let t=fmt(HI(e));class r extends t{constructor(){super(),this.__isPropertyEffectsClient=!0,this.__dataClientsReady,this.__dataPendingClients,this.__dataToNotify,this.__dataLinkedPaths,this.__dataHasPaths,this.__dataCompoundStorage,this.__dataHost,this.__dataTemp,this.__dataClientsInitialized,this.__data,this.__dataPending,this.__dataOld,this.__computeEffects,this.__computeInfo,this.__reflectEffects,this.__notifyEffects,this.__propagateEffects,this.__observeEffects,this.__readOnly,this.__templateInfo,this._overrideLegacyUndefined}get PROPERTY_EFFECT_TYPES(){return zr}_initializeProperties(){super._initializeProperties(),this._registerHost(),this.__dataClientsReady=!1,this.__dataPendingClients=null,this.__dataToNotify=null,this.__dataLinkedPaths=null,this.__dataHasPaths=!1,this.__dataCompoundStorage=this.__dataCompoundStorage||null,this.__dataHost=this.__dataHost||null,this.__dataTemp={},this.__dataClientsInitialized=!1}_registerHost(){if(WM.length){let i=WM[WM.length-1];i._enqueueClient(this),this.__dataHost=i}}_initializeProtoProperties(i){this.__data=Object.create(i),this.__dataPending=Object.create(i),this.__dataOld={}}_initializeInstanceProperties(i){let o=this[zr.READ_ONLY];for(let a in i)(!o||!o[a])&&(this.__dataPending=this.__dataPending||{},this.__dataOld=this.__dataOld||{},this.__data[a]=this.__dataPending[a]=i[a])}_addPropertyEffect(i,o,a){this._createPropertyAccessor(i,o==zr.READ_ONLY);let s=xG(this,o,!0)[i];s||(s=this[o][i]=[]),s.push(a)}_removePropertyEffect(i,o,a){let s=xG(this,o,!0)[i],l=s.indexOf(a);l>=0&&s.splice(l,1)}_hasPropertyEffect(i,o){let a=this[o];return Boolean(a&&a[i])}_hasReadOnlyEffect(i){return this._hasPropertyEffect(i,zr.READ_ONLY)}_hasNotifyEffect(i){return this._hasPropertyEffect(i,zr.NOTIFY)}_hasReflectEffect(i){return this._hasPropertyEffect(i,zr.REFLECT)}_hasComputedEffect(i){return this._hasPropertyEffect(i,zr.COMPUTE)}_setPendingPropertyOrPath(i,o,a,s){if(s||au(Array.isArray(i)?i[0]:i)!==i){if(!s){let l=No(this,i);if(i=yG(this,i,o),!i||!super._shouldPropertyChange(i,o,l))return!1}if(this.__dataHasPaths=!0,this._setPendingProperty(i,o,a))return c1e(this,i,o),!0}else{if(this.__dataHasAccessor&&this.__dataHasAccessor[i])return this._setPendingProperty(i,o,a);this[i]=o}return!1}_setUnmanagedPropertyToNode(i,o,a){(a!==i[o]||typeof a=="object")&&(o==="className"&&(i=ue(i)),i[o]=a)}_setPendingProperty(i,o,a){let s=this.__dataHasPaths&&DI(i),l=s?this.__dataTemp:this.__data;return this._shouldPropertyChange(i,o,l[i])?(this.__dataPending||(this.__dataPending={},this.__dataOld={}),i in this.__dataOld||(this.__dataOld[i]=this.__data[i]),s?this.__dataTemp[i]=o:this.__data[i]=o,this.__dataPending[i]=o,(s||this[zr.NOTIFY]&&this[zr.NOTIFY][i])&&(this.__dataToNotify=this.__dataToNotify||{},this.__dataToNotify[i]=a),!0):!1}_setProperty(i,o){this._setPendingProperty(i,o,!0)&&this._invalidateProperties()}_invalidateProperties(){this.__dataReady&&this._flushProperties()}_enqueueClient(i){this.__dataPendingClients=this.__dataPendingClients||[],i!==this&&this.__dataPendingClients.push(i)}_flushClients(){this.__dataClientsReady?this.__enableOrFlushClients():(this.__dataClientsReady=!0,this._readyClients(),this.__dataReady=!0)}__enableOrFlushClients(){let i=this.__dataPendingClients;if(i){this.__dataPendingClients=null;for(let o=0;o<i.length;o++){let a=i[o];a.__dataEnabled?a.__dataPending&&a._flushProperties():a._enableProperties()}}}_readyClients(){this.__enableOrFlushClients()}setProperties(i,o){for(let a in i)(o||!this[zr.READ_ONLY]||!this[zr.READ_ONLY][a])&&this._setPendingPropertyOrPath(a,i[a],!0);this._invalidateProperties()}ready(){this._flushProperties(),this.__dataClientsReady||this._flushClients(),this.__dataPending&&this._flushProperties()}_propertiesChanged(i,o,a){let s=this.__dataHasPaths;this.__dataHasPaths=!1;let l;o1e(this,o,a,s),l=this.__dataToNotify,this.__dataToNotify=null,this._propagatePropertyChanges(o,a,s),this._flushClients(),YM(this,this[zr.REFLECT],o,a,s),YM(this,this[zr.OBSERVE],o,a,s),l&&t1e(this,l,o,a,s),this.__dataCounter==1&&(this.__dataTemp={})}_propagatePropertyChanges(i,o,a){this[zr.PROPAGATE]&&YM(this,this[zr.PROPAGATE],i,o,a),this.__templateInfo&&this._runEffectsForTemplate(this.__templateInfo,i,o,a)}_runEffectsForTemplate(i,o,a,s){let l=(c,u)=>{YM(this,i.propertyEffects,c,a,u,i.nodeList);for(let h=i.firstChild;h;h=h.nextSibling)this._runEffectsForTemplate(h,c,a,u)};i.runEffects?i.runEffects(l,o,s):l(o,s)}linkPaths(i,o){i=Px(i),o=Px(o),this.__dataLinkedPaths=this.__dataLinkedPaths||{},this.__dataLinkedPaths[i]=o}unlinkPaths(i){i=Px(i),this.__dataLinkedPaths&&delete this.__dataLinkedPaths[i]}notifySplices(i,o){let a={path:""},s=No(this,i,a);Emt(this,s,a.path,o)}get(i,o){return No(o||this,i)}set(i,o,a){a?yG(a,i,o):(!this[zr.READ_ONLY]||!this[zr.READ_ONLY][i])&&this._setPendingPropertyOrPath(i,o,!0)&&this._invalidateProperties()}push(i,...o){let a={path:""},s=No(this,i,a),l=s.length,c=s.push(...o);return o.length&&GM(this,s,a.path,l,o.length,[]),c}pop(i){let o={path:""},a=No(this,i,o),s=Boolean(a.length),l=a.pop();return s&&GM(this,a,o.path,a.length,0,[l]),l}splice(i,o,a,...s){let l={path:""},c=No(this,i,l);o<0?o=c.length-Math.floor(-o):o&&(o=Math.floor(o));let u;return arguments.length===2?u=c.splice(o):u=c.splice(o,a,...s),(s.length||u.length)&&GM(this,c,l.path,o,s.length,u),u}shift(i){let o={path:""},a=No(this,i,o),s=Boolean(a.length),l=a.shift();return s&&GM(this,a,o.path,0,0,[l]),l}unshift(i,...o){let a={path:""},s=No(this,i,a),l=s.unshift(...o);return o.length&&GM(this,s,a.path,0,o.length,[]),l}notifyPath(i,o){let a;if(arguments.length==1){let s={path:""};o=No(this,i,s),a=s.path}else Array.isArray(i)?a=Px(i):a=i;this._setPendingPropertyOrPath(a,o,!0,!0)&&this._invalidateProperties()}_createReadOnlyProperty(i,o){this._addPropertyEffect(i,zr.READ_ONLY),o&&(this["_set"+L1e(i)]=function(a){this._setProperty(i,a)})}_createPropertyObserver(i,o,a){let s={property:i,method:o,dynamicFn:Boolean(a)};this._addPropertyEffect(i,zr.OBSERVE,{fn:pmt,info:s,trigger:{name:i}}),a&&this._addPropertyEffect(o,zr.OBSERVE,{fn:pmt,info:s,trigger:{name:o}})}_createMethodObserver(i,o){let a=wG(i);if(!a)throw new Error("Malformed observer expression '"+i+"'");mmt(this,a,zr.OBSERVE,SG,null,o)}_createNotifyingProperty(i){this._addPropertyEffect(i,zr.NOTIFY,{fn:r1e,info:{eventName:Ix(i)+"-changed",property:i}})}_createReflectedProperty(i){let o=this.constructor.attributeNameForProperty(i);o[0]==="-"?console.warn("Property "+i+" cannot be reflected to attribute "+o+' because "-" is not a valid starting attribute name. Use a lowercase first letter for the property instead.'):this._addPropertyEffect(i,zr.REFLECT,{fn:i1e,info:{attrName:o}})}_createComputedProperty(i,o,a){let s=wG(o);if(!s)throw new Error("Malformed computed expression '"+o+"'");let l=mmt(this,s,zr.COMPUTE,wmt,i,a);xG(this,xmt)[i]=l}_marshalArgs(i,o,a){let s=this.__data,l=[];for(let c=0,u=i.length;c<u;c++){let{name:h,structured:f,wildcard:p,value:d,literal:g}=i[c];if(!g)if(p){let _=Ax(h,o),y=vmt(s,a,_?o:h);d={path:_?o:h,value:y,base:_?No(s,h):y}}else d=f?vmt(s,a,h):s[h];if(kI&&!this._overrideLegacyUndefined&&d===void 0&&i.length>1)return XM;l[c]=d}return l}static addPropertyEffect(i,o,a){this.prototype._addPropertyEffect(i,o,a)}static createPropertyObserver(i,o,a){this.prototype._createPropertyObserver(i,o,a)}static createMethodObserver(i,o){this.prototype._createMethodObserver(i,o)}static createNotifyingProperty(i){this.prototype._createNotifyingProperty(i)}static createReadOnlyProperty(i,o){this.prototype._createReadOnlyProperty(i,o)}static createReflectedProperty(i){this.prototype._createReflectedProperty(i)}static createComputedProperty(i,o,a){this.prototype._createComputedProperty(i,o,a)}static bindTemplate(i){return this.prototype._bindTemplate(i)}_bindTemplate(i,o){let a=this.constructor._parseTemplate(i),s=this.__preBoundTemplateInfo==a;if(!s)for(let l in a.propertyEffects)this._createPropertyAccessor(l);if(o)if(a=Object.create(a),a.wasPreBound=s,!this.__templateInfo)this.__templateInfo=a;else{let l=i._parentTemplateInfo||this.__templateInfo,c=l.lastChild;a.parent=l,l.lastChild=a,a.previousSibling=c,c?c.nextSibling=a:l.firstChild=a}else this.__preBoundTemplateInfo=a;return a}static _addTemplatePropertyEffect(i,o,a){let s=i.hostProps=i.hostProps||{};s[o]=!0;let l=i.propertyEffects=i.propertyEffects||{};(l[o]=l[o]||[]).push(a)}_stampTemplate(i,o){o=o||this._bindTemplate(i,!0),WM.push(this);let a=super._stampTemplate(i,o);if(WM.pop(),o.nodeList=a.nodeList,!o.wasPreBound){let s=o.childNodes=[];for(let l=a.firstChild;l;l=l.nextSibling)s.push(l)}return a.templateInfo=o,m1e(this,o),this.__dataClientsReady&&(this._runEffectsForTemplate(o,this.__data,null,!1),this._flushClients()),a}_removeBoundDom(i){let o=i.templateInfo,{previousSibling:a,nextSibling:s,parent:l}=o;a?a.nextSibling=s:l&&(l.firstChild=s),s?s.previousSibling=a:l&&(l.lastChild=a),o.nextSibling=o.previousSibling=null;let c=o.childNodes;for(let u=0;u<c.length;u++){let h=c[u];ue(ue(h).parentNode).removeChild(h)}}static _parseTemplateNode(i,o,a){let s=t._parseTemplateNode.call(this,i,o,a);if(i.nodeType===Node.TEXT_NODE){let l=this._parseBindings(i.textContent,o);l&&(i.textContent=ymt(l)||" ",bG(this,o,a,"text","textContent",l),s=!0)}return s}static _parseTemplateNodeAttribute(i,o,a,s,l){let c=this._parseBindings(l,o);if(c){let u=s,h="property";Jve.test(s)?h="attribute":s[s.length-1]=="$"&&(s=s.slice(0,-1),h="attribute");let f=ymt(c);return f&&h=="attribute"&&(s=="class"&&i.hasAttribute("class")&&(f+=" "+i.getAttribute(s)),i.setAttribute(s,f)),h=="attribute"&&u=="disable-upgrade$"&&i.setAttribute(s,""),i.localName==="input"&&u==="value"&&i.setAttribute(u,""),i.removeAttribute(u),h==="property"&&(s=wm(s)),bG(this,o,a,h,s,c,f),!0}else return t._parseTemplateNodeAttribute.call(this,i,o,a,s,l)}static _parseTemplateNestedTemplate(i,o,a){let s=t._parseTemplateNestedTemplate.call(this,i,o,a),l=i.parentNode,c=a.templateInfo,u=l.localName==="dom-if",h=l.localName==="dom-repeat";pG&&(u||h)&&(l.removeChild(i),a=a.parentInfo,a.templateInfo=c,a.noted=!0,s=!1);let f=c.hostProps;if(RI&&u)f&&(o.hostProps=Object.assign(o.hostProps||{},f),pG||(a.parentInfo.noted=!0));else{let p="{";for(let d in f){let g=[{mode:p,source:d,dependencies:[d],hostProp:!0}];bG(this,o,a,"property","_host_"+d,g)}}return s}static _parseBindings(i,o){let a=[],s=0,l;for(;(l=_mt.exec(i))!==null;){l.index>s&&a.push({literal:i.slice(s,l.index)});let c=l[1][0],u=Boolean(l[2]),h=l[3].trim(),f=!1,p="",d=-1;c=="{"&&(d=h.indexOf("::"))>0&&(p=h.substring(d+2),h=h.substring(0,d),f=!0);let g=wG(h),_=[];if(g){let{args:y,methodName:x}=g;for(let S=0;S<y.length;S++){let C=y[S];C.literal||_.push(C)}let b=o.dynamicFns;(b&&b[x]||g.static)&&(_.push(x),g.dynamicFn=!0)}else _.push(h);a.push({source:h,mode:c,negate:u,customEvent:f,signature:g,dependencies:_,event:p}),s=_mt.lastIndex}if(s&&s<i.length){let c=i.substring(s);c&&a.push({literal:c})}return a.length?a:null}static _evaluateBinding(i,o,a,s,l,c){let u;return o.signature?u=SG(i,a,s,l,o.signature):a!=o.source?u=No(i,o.source):c&&DI(a)?u=No(i,a):u=i.__data[a],o.negate&&(u=!u),u}}return r}),WM=[];var k1e=0;function Tmt(){k1e++}var R1e=[];function VI(e){R1e.push(e)}function N1e(e){let t={};for(let r in e){let n=e[r];t[r]=typeof n=="function"?{type:n}:n}return t}var Cmt=Rn(e=>{let t=FI(e);function r(o){let a=Object.getPrototypeOf(o);return a.prototype instanceof i?a:null}function n(o){if(!o.hasOwnProperty(JSCompiler_renameProperty("__ownProperties",o))){let a=null;if(o.hasOwnProperty(JSCompiler_renameProperty("properties",o))){let s=o.properties;s&&(a=N1e(s))}o.__ownProperties=a}return o.__ownProperties}class i extends t{static get observedAttributes(){if(!this.hasOwnProperty(JSCompiler_renameProperty("__observedAttributes",this))){VI(this.prototype);let a=this._properties;this.__observedAttributes=a?Object.keys(a).map(s=>this.prototype._addPropertyToAttributeMap(s)):[]}return this.__observedAttributes}static finalize(){if(!this.hasOwnProperty(JSCompiler_renameProperty("__finalized",this))){let a=r(this);a&&a.finalize(),this.__finalized=!0,this._finalizeClass()}}static _finalizeClass(){let a=n(this);a&&this.createProperties(a)}static get _properties(){if(!this.hasOwnProperty(JSCompiler_renameProperty("__properties",this))){let a=r(this);this.__properties=Object.assign({},a&&a._properties,n(this))}return this.__properties}static typeForProperty(a){let s=this._properties[a];return s&&s.type}_initializeProperties(){Tmt(),this.constructor.finalize(),super._initializeProperties()}connectedCallback(){super.connectedCallback&&super.connectedCallback(),this._enableProperties()}disconnectedCallback(){super.disconnectedCallback&&super.disconnectedCallback()}}return i});var Amt="3.4.1",UI=window.ShadyCSS&&window.ShadyCSS.cssBuild,Sm=Rn(e=>{let t=Cmt(u_(e));function r(l){if(!l.hasOwnProperty(JSCompiler_renameProperty("__propertyDefaults",l))){l.__propertyDefaults=null;let c=l._properties;for(let u in c){let h=c[u];"value"in h&&(l.__propertyDefaults=l.__propertyDefaults||{},l.__propertyDefaults[u]=h)}}return l.__propertyDefaults}function n(l){return l.hasOwnProperty(JSCompiler_renameProperty("__ownObservers",l))||(l.__ownObservers=l.hasOwnProperty(JSCompiler_renameProperty("observers",l))?l.observers:null),l.__ownObservers}function i(l,c,u,h){u.computed&&(u.readOnly=!0),u.computed&&(l._hasReadOnlyEffect(c)?console.warn(`Cannot redefine computed property '${c}'.`):l._createComputedProperty(c,u.computed,h)),u.readOnly&&!l._hasReadOnlyEffect(c)?l._createReadOnlyProperty(c,!u.computed):u.readOnly===!1&&l._hasReadOnlyEffect(c)&&console.warn(`Cannot make readOnly property '${c}' non-readOnly.`),u.reflectToAttribute&&!l._hasReflectEffect(c)?l._createReflectedProperty(c):u.reflectToAttribute===!1&&l._hasReflectEffect(c)&&console.warn(`Cannot make reflected property '${c}' non-reflected.`),u.notify&&!l._hasNotifyEffect(c)?l._createNotifyingProperty(c):u.notify===!1&&l._hasNotifyEffect(c)&&console.warn(`Cannot make notify property '${c}' non-notify.`),u.observer&&l._createPropertyObserver(c,u.observer,h[u.observer]),l._addPropertyToAttributeMap(c)}function o(l,c,u,h){if(!UI){let f=c.content.querySelectorAll("style"),p=NI(c),d=nmt(u),g=c.content.firstElementChild;for(let y=0;y<d.length;y++){let x=d[y];x.textContent=l._processStyleText(x.textContent,h),c.content.insertBefore(x,g)}let _=0;for(let y=0;y<p.length;y++){let x=p[y],b=f[_];b!==x?(x=x.cloneNode(!0),b.parentNode.insertBefore(x,b)):_++,x.textContent=l._processStyleText(x.textContent,h)}}if(window.ShadyCSS&&window.ShadyCSS.prepareTemplate(c,u),Kdt&&UI&&Gdt){let f=c.content.querySelectorAll("style");if(f){let p="";Array.from(f).forEach(d=>{p+=d.textContent,d.parentNode.removeChild(d)}),l._styleSheet=new CSSStyleSheet,l._styleSheet.replaceSync(p)}}}function a(l){let c=null;if(l&&(!iu||jdt)&&(c=ou.import(l,"template"),iu&&!c))throw new Error(`strictTemplatePolicy: expecting dom-module or null template for ${l}`);return c}class s extends t{static get polymerElementVersion(){return Amt}static _finalizeClass(){t._finalizeClass.call(this);let c=n(this);c&&this.createObservers(c,this._properties),this._prepareTemplate()}static _prepareTemplate(){let c=this.template;c&&(typeof c=="string"?(console.error("template getter must return HTMLTemplateElement"),c=null):pp||(c=c.cloneNode(!0))),this.prototype._template=c}static createProperties(c){for(let u in c)i(this.prototype,u,c[u],c)}static createObservers(c,u){let h=this.prototype;for(let f=0;f<c.length;f++)h._createMethodObserver(c[f],u)}static get template(){if(!this.hasOwnProperty(JSCompiler_renameProperty("_template",this))){let c=this.prototype.hasOwnProperty(JSCompiler_renameProperty("_template",this.prototype))?this.prototype._template:void 0;this._template=c!==void 0?c:this.hasOwnProperty(JSCompiler_renameProperty("is",this))&&a(this.is)||Object.getPrototypeOf(this.prototype).constructor.template}return this._template}static set template(c){this._template=c}static get importPath(){if(!this.hasOwnProperty(JSCompiler_renameProperty("_importPath",this))){let c=this.importMeta;if(c)this._importPath=Cx(c.url);else{let u=ou.import(this.is);this._importPath=u&&u.assetpath||Object.getPrototypeOf(this.prototype).constructor.importPath}}return this._importPath}constructor(){super(),this._template,this._importPath,this.rootPath,this.importPath,this.root,this.$}_initializeProperties(){this.constructor.finalize(),this.constructor._finalizeTemplate(this.localName),super._initializeProperties(),this.rootPath=Wdt,this.importPath=this.constructor.importPath;let c=r(this.constructor);if(!!c)for(let u in c){let h=c[u];if(this._canApplyPropertyDefault(u)){let f=typeof h.value=="function"?h.value.call(this):h.value;this._hasAccessor(u)?this._setPendingProperty(u,f,!0):this[u]=f}}}_canApplyPropertyDefault(c){return!this.hasOwnProperty(c)}static _processStyleText(c,u){return HM(c,u)}static _finalizeTemplate(c){let u=this.prototype._template;if(u&&!u.__polymerFinalized){u.__polymerFinalized=!0;let h=this.importPath,f=h?l_(h):"";o(this,u,c,f),this.prototype._bindTemplate(u)}}connectedCallback(){window.ShadyCSS&&this._template&&window.ShadyCSS.styleElement(this),super.connectedCallback()}ready(){this._template&&(this.root=this._stampTemplate(this._template),this.$=this.root.$),super.ready()}_readyClients(){this._template&&(this.root=this._attachDom(this.root)),super._readyClients()}_attachDom(c){let u=ue(this);if(u.attachShadow)return c?(u.shadowRoot||(u.attachShadow({mode:"open",shadyUpgradeFragment:c}),u.shadowRoot.appendChild(c),this.constructor._styleSheet&&(u.shadowRoot.adoptedStyleSheets=[this.constructor._styleSheet])),Xdt&&window.ShadyDOM&&window.ShadyDOM.flushInitial(u.shadowRoot),u.shadowRoot):null;throw new Error("ShadowDOM not available. PolymerElement can create dom as children instead of in ShadowDOM by setting `this.root = this;` before `ready`.")}updateStyles(c){window.ShadyCSS&&window.ShadyCSS.styleSubtree(this,c)}resolveUrl(c,u){return!u&&this.importPath&&(u=l_(this.importPath)),l_(c,u)}static _parseTemplateContent(c,u,h){return u.dynamicFns=u.dynamicFns||this._properties,t._parseTemplateContent.call(this,c,u,h)}static _addTemplatePropertyEffect(c,u,h){return LI&&!(u in this._properties)&&!(h.info.part.signature&&h.info.part.signature.static)&&!h.info.part.hostProp&&!c.nestedTemplate&&console.warn(`Property '${u}' used in template but not declared in 'properties'; attribute will not be observed.`),t._addTemplatePropertyEffect.call(this,c,u,h)}}return s});var qI=class{constructor(t){this.value=t.toString()}toString(){return this.value}};function D1e(e){if(e instanceof qI)return e.value;throw new Error(`non-literal value passed to Polymer's htmlLiteral function: ${e}`)}function O1e(e){if(e instanceof HTMLTemplateElement)return e.innerHTML;if(e instanceof qI)return D1e(e);throw new Error(`non-template value passed to Polymer's html function: ${e}`)}var Q=function(t,...r){let n=document.createElement("template");return n.innerHTML=r.reduce((i,o,a)=>i+O1e(o)+t[a+1],t[0]),n};var mt=Sm(HTMLElement);var fy=Ee(Oe(),1);var h_=!(window.ShadyDOM&&window.ShadyDOM.inUse),GI;function Pmt(e){e&&e.shimcssproperties?GI=!1:GI=h_||Boolean(!navigator.userAgent.match(/AppleWebKit\/601|Edge\/15/)&&window.CSS&&CSS.supports&&CSS.supports("box-shadow","0 0 0 var(--foo)"))}var Mm;window.ShadyCSS&&window.ShadyCSS.cssBuild!==void 0&&(Mm=window.ShadyCSS.cssBuild);var WI=Boolean(window.ShadyCSS&&window.ShadyCSS.disableRuntime);window.ShadyCSS&&window.ShadyCSS.nativeCss!==void 0?GI=window.ShadyCSS.nativeCss:window.ShadyCSS?(Pmt(window.ShadyCSS),window.ShadyCSS=void 0):Pmt(window.WebComponents&&window.WebComponents.flags);var Nx=GI;var YI=class{constructor(){this.start=0,this.end=0,this.previous=null,this.parent=null,this.rules=null,this.parsedCssText="",this.cssText="",this.atRule=!1,this.type=0,this.keyframesName="",this.selector="",this.parsedSelector=""}};function EG(e){return e=z1e(e),Imt(F1e(e),e)}function z1e(e){return e.replace(gp.comments,"").replace(gp.port,"")}function F1e(e){let t=new YI;t.start=0,t.end=e.length;let r=t;for(let n=0,i=e.length;n<i;n++)if(e[n]===Lmt){r.rules||(r.rules=[]);let o=r,a=o.rules[o.rules.length-1]||null;r=new YI,r.start=n+1,r.parent=o,r.previous=a,o.rules.push(r)}else e[n]===kmt&&(r.end=n+1,r=r.parent||t);return t}function Imt(e,t){let r=t.substring(e.start,e.end-1);if(e.parsedCssText=e.cssText=r.trim(),e.parent){let i=e.previous?e.previous.end:e.parent.start;r=t.substring(i,e.start-1),r=B1e(r),r=r.replace(gp.multipleSpaces," "),r=r.substring(r.lastIndexOf(";")+1);let o=e.parsedSelector=e.selector=r.trim();e.atRule=o.indexOf(W1e)===0,e.atRule?o.indexOf(G1e)===0?e.type=mp.MEDIA_RULE:o.match(gp.keyframesRule)&&(e.type=mp.KEYFRAMES_RULE,e.keyframesName=e.selector.split(gp.multipleSpaces).pop()):o.indexOf(Rmt)===0?e.type=mp.MIXIN_RULE:e.type=mp.STYLE_RULE}let n=e.rules;if(n)for(let i=0,o=n.length,a;i<o&&(a=n[i]);i++)Imt(a,t);return e}function B1e(e){return e.replace(/\\([0-9a-f]{1,6})\s/gi,function(){let t=arguments[1],r=6-t.length;for(;r--;)t="0"+t;return"\\"+t})}function TG(e,t,r=""){let n="";if(e.cssText||e.rules){let i=e.rules;if(i&&!H1e(i))for(let o=0,a=i.length,s;o<a&&(s=i[o]);o++)n=TG(s,t,n);else n=t?e.cssText:V1e(e.cssText),n=n.trim(),n&&(n="  "+n+`
`)}return n&&(e.selector&&(r+=e.selector+" "+Lmt+`
`),r+=n,e.selector&&(r+=kmt+`

`)),r}function H1e(e){let t=e[0];return Boolean(t)&&Boolean(t.selector)&&t.selector.indexOf(Rmt)===0}function V1e(e){return e=U1e(e),q1e(e)}function U1e(e){return e.replace(gp.customProp,"").replace(gp.mixinProp,"")}function q1e(e){return e.replace(gp.mixinApply,"").replace(gp.varApply,"")}var mp={STYLE_RULE:1,KEYFRAMES_RULE:7,MEDIA_RULE:4,MIXIN_RULE:1e3},Lmt="{",kmt="}",gp={comments:/\/\*[^*]*\*+([^/*][^*]*\*+)*\//gim,port:/@import[^;]*;/gim,customProp:/(?:^[^;\-\s}]+)?--[^;{}]*?:[^{};]*?(?:[;\n]|$)/gim,mixinProp:/(?:^[^;\-\s}]+)?--[^;{}]*?:[^{};]*?{[^}]*?}(?:[;\n]|$)?/gim,mixinApply:/@apply\s*\(?[^);]*\)?\s*(?:[;\n]|$)?/gim,varApply:/[^;:]*?:[^;]*?var\([^;]*\)(?:[;\n]|$)?/gim,keyframesRule:/^@[^\s]*keyframes/,multipleSpaces:/\s+/g},Rmt="--",G1e="@media",W1e="@";var KM=/(?:^|[;\s{]\s*)(--[\w-]*?)\s*:\s*(?:((?:'(?:\\'|.)*?'|"(?:\\"|.)*?"|\([^)]*?\)|[^};{])+)|\{([^}]*)\}(?:(?=[;\s}])|$))/gi,Dx=/(?:^|\W+)@apply\s*\(?([^);\n]*)\)?/gi;var Nmt=/@media\s(.*)/;var Dmt=new Set,Y1e="shady-unscoped";function Omt(e){let t=e.textContent;if(!Dmt.has(t)){Dmt.add(t);let r=document.createElement("style");r.setAttribute("shady-unscoped",""),r.textContent=t,document.head.appendChild(r)}}function zmt(e){return e.hasAttribute(Y1e)}function ZM(e,t){return e?(typeof e=="string"&&(e=EG(e)),t&&Ox(e,t),TG(e,Nx)):""}function CG(e){return!e.__cssRules&&e.textContent&&(e.__cssRules=EG(e.textContent)),e.__cssRules||null}function Ox(e,t,r,n){if(!e)return;let i=!1,o=e.type;if(n&&o===mp.MEDIA_RULE){let s=e.selector.match(Nmt);s&&(window.matchMedia(s[1]).matches||(i=!0))}o===mp.STYLE_RULE?t(e):r&&o===mp.KEYFRAMES_RULE?r(e):o===mp.MIXIN_RULE&&(i=!0);let a=e.rules;if(a&&!i)for(let s=0,l=a.length,c;s<l&&(c=a[s]);s++)Ox(c,t,r,n)}function j1e(e,t){let r=0;for(let n=t,i=e.length;n<i;n++)if(e[n]==="(")r++;else if(e[n]===")"&&--r===0)return n;return-1}function AG(e,t){let r=e.indexOf("var(");if(r===-1)return t(e,"","","");let n=j1e(e,r+3),i=e.substring(r+4,n),o=e.substring(0,r),a=AG(e.substring(n+1),t),s=i.indexOf(",");if(s===-1)return t(o,i.trim(),"",a);let l=i.substring(0,s).trim(),c=i.substring(s+1).trim();return t(o,l,c,a)}var fvr=window.ShadyDOM&&window.ShadyDOM.wrap||(e=>e);function Fmt(e){let t=e.localName,r="",n="";return t?t.indexOf("-")>-1?r=t:(n=t,r=e.getAttribute&&e.getAttribute("is")||""):(r=e.is,n=e.extends),{is:r,typeExtension:n}}function Bmt(e){let t=[],r=e.querySelectorAll("style");for(let n=0;n<r.length;n++){let i=r[n];zmt(i)?h_||(Omt(i),i.parentNode.removeChild(i)):(t.push(i.textContent),i.parentNode.removeChild(i))}return t.join("").trim()}var Hmt="css-build";function X1e(e){if(Mm!==void 0)return Mm;if(e.__cssBuild===void 0){let t=e.getAttribute(Hmt);if(t)e.__cssBuild=t;else{let r=$1e(e);r!==""&&K1e(e),e.__cssBuild=r}}return e.__cssBuild||""}function PG(e){return X1e(e)!==""}function $1e(e){let t=e.localName==="template"?e.content.firstChild:e.firstChild;if(t instanceof Comment){let r=t.textContent.trim().split(":");if(r[0]===Hmt)return r[1]}return""}function K1e(e){let t=e.localName==="template"?e.content.firstChild:e.firstChild;t.parentNode.removeChild(t)}function JM(e,t){for(let r in t)r===null?e.style.removeProperty(r):e.style.setProperty(r,t[r])}function jI(e,t){let r=window.getComputedStyle(e).getPropertyValue(t);return r?r.trim():""}function Vmt(e){let t=Dx.test(e)||KM.test(e);return Dx.lastIndex=0,KM.lastIndex=0,t}var Z1e=/;\s*/m,J1e=/^\s*(initial)|(inherit)\s*$/,Umt=/\s*!important/,IG="_-_";var LG=class{constructor(){this._map={}}set(t,r){t=t.trim(),this._map[t]={properties:r,dependants:{}}}get(t){return t=t.trim(),this._map[t]||null}},XI=null,Do=class{constructor(){this._currentElement=null,this._measureElement=null,this._map=new LG}detectMixin(t){return Vmt(t)}gatherStyles(t){let r=Bmt(t.content);if(r){let n=document.createElement("style");return n.textContent=r,t.content.insertBefore(n,t.content.firstChild),n}return null}transformTemplate(t,r){t._gatheredStyle===void 0&&(t._gatheredStyle=this.gatherStyles(t));let n=t._gatheredStyle;return n?this.transformStyle(n,r):null}transformStyle(t,r=""){let n=CG(t);return this.transformRules(n,r),t.textContent=ZM(n),n}transformCustomStyle(t){let r=CG(t);return Ox(r,n=>{n.selector===":root"&&(n.selector="html"),this.transformRule(n)}),t.textContent=ZM(r),r}transformRules(t,r){this._currentElement=r,Ox(t,n=>{this.transformRule(n)}),this._currentElement=null}transformRule(t){t.cssText=this.transformCssText(t.parsedCssText,t),t.selector===":root"&&(t.selector=":host > *")}transformCssText(t,r){return t=t.replace(KM,(n,i,o,a)=>this._produceCssProperties(n,i,o,a,r)),this._consumeCssProperties(t,r)}_getInitialValueForProperty(t){return this._measureElement||(this._measureElement=document.createElement("meta"),this._measureElement.setAttribute("apply-shim-measure",""),this._measureElement.style.all="initial",document.head.appendChild(this._measureElement)),window.getComputedStyle(this._measureElement).getPropertyValue(t)}_fallbacksFromPreviousRules(t){let r=t;for(;r.parent;)r=r.parent;let n={},i=!1;return Ox(r,o=>{i=i||o===t,!i&&o.selector===t.selector&&Object.assign(n,this._cssTextToMap(o.parsedCssText))}),n}_consumeCssProperties(t,r){let n=null;for(;n=Dx.exec(t);){let i=n[0],o=n[1],a=n.index,s=a+i.indexOf("@apply"),l=a+i.length,c=t.slice(0,s),u=t.slice(l),h=r?this._fallbacksFromPreviousRules(r):{};Object.assign(h,this._cssTextToMap(c));let f=this._atApplyToCssProperties(o,h);t=`${c}${f}${u}`,Dx.lastIndex=a+f.length}return t}_atApplyToCssProperties(t,r){t=t.replace(Z1e,"");let n=[],i=this._map.get(t);if(i||(this._map.set(t,{}),i=this._map.get(t)),i){this._currentElement&&(i.dependants[this._currentElement]=!0);let o,a,s,l=i.properties;for(o in l)s=r&&r[o],a=[o,": var(",t,IG,o],s&&a.push(",",s.replace(Umt,"")),a.push(")"),Umt.test(l[o])&&a.push(" !important"),n.push(a.join(""))}return n.join("; ")}_replaceInitialOrInherit(t,r){let n=J1e.exec(r);return n&&(n[1]?r=this._getInitialValueForProperty(t):r="apply-shim-inherit"),r}_cssTextToMap(t,r=!1){let n=t.split(";"),i,o,a={};for(let s=0,l,c;s<n.length;s++)l=n[s],l&&(c=l.split(":"),c.length>1&&(i=c[0].trim(),o=c.slice(1).join(":"),r&&(o=this._replaceInitialOrInherit(i,o)),a[i]=o));return a}_invalidateMixinEntry(t){if(!!XI)for(let r in t.dependants)r!==this._currentElement&&XI(r)}_produceCssProperties(t,r,n,i,o){if(n&&AG(n,(_,y)=>{y&&this._map.get(y)&&(i=`@apply ${y};`)}),!i)return t;let a=this._consumeCssProperties(""+i,o),s=t.slice(0,t.indexOf("--")),l=this._cssTextToMap(a,!0),c=l,u=this._map.get(r),h=u&&u.properties;h?c=Object.assign(Object.create(h),l):this._map.set(r,c);let f=[],p,d,g=!1;for(p in c)d=l[p],d===void 0&&(d="initial"),h&&!(p in h)&&(g=!0),f.push(`${r}${IG}${p}: ${d}`);return g&&this._invalidateMixinEntry(u),u&&(u.properties=c),n&&(s=`${t};${s}`),`${s}${f.join("; ")};`}};Do.prototype.detectMixin=Do.prototype.detectMixin;Do.prototype.transformStyle=Do.prototype.transformStyle;Do.prototype.transformCustomStyle=Do.prototype.transformCustomStyle;Do.prototype.transformRules=Do.prototype.transformRules;Do.prototype.transformRule=Do.prototype.transformRule;Do.prototype.transformTemplate=Do.prototype.transformTemplate;Do.prototype._separator=IG;Object.defineProperty(Do.prototype,"invalidCallback",{get(){return XI},set(e){XI=e}});var qmt=Do;var Q1e={},QM=Q1e;var $I="_applyShimCurrentVersion",zx="_applyShimNextVersion",KI="_applyShimValidatingVersion",txe=Promise.resolve();function Gmt(e){let t=QM[e];t&&exe(t)}function exe(e){e[$I]=e[$I]||0,e[KI]=e[KI]||0,e[zx]=(e[zx]||0)+1}function kG(e){return e[$I]===e[zx]}function Wmt(e){return!kG(e)&&e[KI]===e[zx]}function Ymt(e){e[KI]=e[zx],e._validating||(e._validating=!0,txe.then(function(){e[$I]=e[zx],e._validating=!1}))}var RG=null,jmt=window.HTMLImports&&window.HTMLImports.whenReady||null,NG;function ZI(e){requestAnimationFrame(function(){jmt?jmt(e):(RG||(RG=new Promise(t=>{NG=t}),document.readyState==="complete"?NG():document.addEventListener("readystatechange",()=>{document.readyState==="complete"&&NG()})),RG.then(function(){e&&e()}))})}var Xmt="__seenByShadyCSS",JI="__shadyCSSCachedStyle",QI=null,tE=null,Zl=class{constructor(){this.customStyles=[],this.enqueued=!1,ZI(()=>{window.ShadyCSS.flushCustomStyles&&window.ShadyCSS.flushCustomStyles()})}enqueueDocumentValidation(){this.enqueued||!tE||(this.enqueued=!0,ZI(tE))}addCustomStyle(t){t[Xmt]||(t[Xmt]=!0,this.customStyles.push(t),this.enqueueDocumentValidation())}getStyleForCustomStyle(t){if(t[JI])return t[JI];let r;return t.getStyle?r=t.getStyle():r=t,r}processStyles(){let t=this.customStyles;for(let r=0;r<t.length;r++){let n=t[r];if(n[JI])continue;let i=this.getStyleForCustomStyle(n);if(i){let o=i.__appliedElement||i;QI&&QI(o),n[JI]=o}}return t}};Zl.prototype.addCustomStyle=Zl.prototype.addCustomStyle;Zl.prototype.getStyleForCustomStyle=Zl.prototype.getStyleForCustomStyle;Zl.prototype.processStyles=Zl.prototype.processStyles;Object.defineProperties(Zl.prototype,{transformCallback:{get(){return QI},set(e){QI=e}},validateCallback:{get(){return tE},set(e){let t=!1;tE||(t=!0),tE=e,t&&this.enqueueDocumentValidation()}}});var eE=new qmt,DG=class{constructor(){this.customStyleInterface=null,eE.invalidCallback=Gmt}ensure(){this.customStyleInterface||window.ShadyCSS.CustomStyleInterface&&(this.customStyleInterface=window.ShadyCSS.CustomStyleInterface,this.customStyleInterface.transformCallback=t=>{eE.transformCustomStyle(t)},this.customStyleInterface.validateCallback=()=>{requestAnimationFrame(()=>{this.customStyleInterface.enqueued&&this.flushCustomStyles()})})}prepareTemplate(t,r){if(this.ensure(),PG(t))return;QM[r]=t;let n=eE.transformTemplate(t,r);t._styleAst=n}flushCustomStyles(){if(this.ensure(),!this.customStyleInterface)return;let t=this.customStyleInterface.processStyles();if(!!this.customStyleInterface.enqueued){for(let r=0;r<t.length;r++){let n=t[r],i=this.customStyleInterface.getStyleForCustomStyle(n);i&&eE.transformCustomStyle(i)}this.customStyleInterface.enqueued=!1}}styleSubtree(t,r){if(this.ensure(),r&&JM(t,r),t.shadowRoot){this.styleElement(t);let n=t.shadowRoot.children||t.shadowRoot.childNodes;for(let i=0;i<n.length;i++)this.styleSubtree(n[i])}else{let n=t.children||t.childNodes;for(let i=0;i<n.length;i++)this.styleSubtree(n[i])}}styleElement(t){this.ensure();let{is:r}=Fmt(t),n=QM[r];if(!(n&&PG(n))&&n&&!kG(n)){Wmt(n)||(this.prepareTemplate(n,r),Ymt(n));let i=t.shadowRoot;if(i){let o=i.querySelector("style");o&&(o.__cssRules=n._styleAst,o.textContent=ZM(n._styleAst))}}}styleDocument(t){this.ensure(),this.styleSubtree(document.body,t)}};if(!window.ShadyCSS||!window.ShadyCSS.ScopingShim){let e=new DG,t=window.ShadyCSS&&window.ShadyCSS.CustomStyleInterface;window.ShadyCSS={prepareTemplate(r,n,i){e.flushCustomStyles(),e.prepareTemplate(r,n)},prepareTemplateStyles(r,n,i){window.ShadyCSS.prepareTemplate(r,n,i)},prepareTemplateDom(r,n){},styleSubtree(r,n){e.flushCustomStyles(),e.styleSubtree(r,n)},styleElement(r){e.flushCustomStyles(),e.styleElement(r)},styleDocument(r){e.flushCustomStyles(),e.styleDocument(r)},getComputedStyleValue(r,n){return jI(r,n)},flushCustomStyles(){e.flushCustomStyles()},nativeCss:Nx,nativeShadow:h_,cssBuild:Mm,disableRuntime:WI},t&&(window.ShadyCSS.CustomStyleInterface=t)}window.ShadyCSS.ApplyShim=eE;var sr=class{constructor(){this._asyncModule=null,this._callback=null,this._timer=null}setConfig(t,r){this._asyncModule=t,this._callback=r,this._timer=this._asyncModule.run(()=>{this._timer=null,rE.delete(this),this._callback()})}cancel(){this.isActive()&&(this._cancelAsync(),rE.delete(this))}_cancelAsync(){this.isActive()&&(this._asyncModule.cancel(this._timer),this._timer=null)}flush(){this.isActive()&&(this.cancel(),this._callback())}isActive(){return this._timer!=null}static debounce(t,r,n){return t instanceof sr?t._cancelAsync():t=new sr,t.setConfig(r,n),t}},rE=new Set,Jl=function(e){rE.add(e)},$mt=function(){let e=Boolean(rE.size);return rE.forEach(t=>{try{t.flush()}catch(r){setTimeout(()=>{throw r})}}),e};var BG=typeof document.head.style.touchAction=="string",e9="__polymerGestures",t9="__polymerGesturesHandled",zG="__polymerGesturesTouchAction",Kmt=25,Zmt=5,nxe=2,ixe=2500,rgt=["mousedown","mousemove","mouseup","click"],oxe=[0,1,4,2],axe=function(){try{return new MouseEvent("test",{buttons:1}).buttons===1}catch(e){return!1}}();function HG(e){return rgt.indexOf(e)>-1}var VG=!1;(function(){try{let e=Object.defineProperty({},"passive",{get(){VG=!0}});window.addEventListener("test",null,e),window.removeEventListener("test",null,e)}catch(e){}})();function ngt(e){if(!(HG(e)||e==="touchend")&&BG&&VG&&Ydt)return{passive:!0}}var igt=navigator.userAgent.match(/iP(?:[oa]d|hone)|Android/),FG=[],sxe={button:!0,input:!0,keygen:!0,meter:!0,output:!0,textarea:!0,progress:!0,select:!0},lxe={button:!0,command:!0,fieldset:!0,input:!0,keygen:!0,optgroup:!0,option:!0,select:!0,textarea:!0};function cxe(e){return sxe[e.localName]||!1}function uxe(e){let t=Array.prototype.slice.call(e.labels||[]);if(!t.length){t=[];let r=e.getRootNode();if(e.id){let n=r.querySelectorAll(`label[for = ${e.id}]`);for(let i=0;i<n.length;i++)t.push(n[i])}}return t}var Jmt=function(e){let t=e.sourceCapabilities;if(!(t&&!t.firesTouchEvents)&&(e[t9]={skip:!0},e.type==="click")){let r=!1,n=n9(e);for(let i=0;i<n.length;i++){if(n[i].nodeType===Node.ELEMENT_NODE){if(n[i].localName==="label")FG.push(n[i]);else if(cxe(n[i])){let o=uxe(n[i]);for(let a=0;a<o.length;a++)r=r||FG.indexOf(o[a])>-1}}if(n[i]===ia.mouse.target)return}if(r)return;e.preventDefault(),e.stopPropagation()}};function Qmt(e){let t=igt?["click"]:rgt;for(let r=0,n;r<t.length;r++)n=t[r],e?(FG.length=0,document.addEventListener(n,Jmt,!0)):document.removeEventListener(n,Jmt,!0)}function hxe(e){if(!fG)return;ia.mouse.mouseIgnoreJob||Qmt(!0);let t=function(){Qmt(),ia.mouse.target=null,ia.mouse.mouseIgnoreJob=null};ia.mouse.target=n9(e)[0],ia.mouse.mouseIgnoreJob=sr.debounce(ia.mouse.mouseIgnoreJob,mo.after(ixe),t)}function p_(e){let t=e.type;if(!HG(t))return!1;if(t==="mousemove"){let r=e.buttons===void 0?1:e.buttons;return e instanceof window.MouseEvent&&!axe&&(r=oxe[e.which]||0),Boolean(r&1)}else return(e.button===void 0?0:e.button)===0}function fxe(e){if(e.type==="click"){if(e.detail===0)return!0;let t=_p(e);if(!t.nodeType||t.nodeType!==Node.ELEMENT_NODE)return!0;let r=t.getBoundingClientRect(),n=e.pageX,i=e.pageY;return!(n>=r.left&&n<=r.right&&i>=r.top&&i<=r.bottom)}return!1}var ia={mouse:{target:null,mouseIgnoreJob:null},touch:{x:0,y:0,id:-1,scrollDecided:!1}};function pxe(e){let t="auto",r=n9(e);for(let n=0,i;n<r.length;n++)if(i=r[n],i[zG]){t=i[zG];break}return t}function ogt(e,t,r){e.movefn=t,e.upfn=r,document.addEventListener("mousemove",t),document.addEventListener("mouseup",r)}function Fx(e){document.removeEventListener("mousemove",e.movefn),document.removeEventListener("mouseup",e.upfn),e.movefn=null,e.upfn=null}fG&&document.addEventListener("touchend",hxe,VG?{passive:!0}:!1);var n9=window.ShadyDOM&&window.ShadyDOM.noPatch?window.ShadyDOM.composedPath:e=>e.composedPath&&e.composedPath()||[],iE={},f_=[];function dxe(e,t){let r=document.elementFromPoint(e,t),n=r;for(;n&&n.shadowRoot&&!window.ShadyDOM;){let i=n;if(n=n.shadowRoot.elementFromPoint(e,t),i===n)break;n&&(r=n)}return r}function _p(e){let t=n9(e);return t.length>0?t[0]:e.target}function agt(e){let t,r=e.type,i=e.currentTarget[e9];if(!i)return;let o=i[r];if(!!o){if(!e[t9]&&(e[t9]={},r.slice(0,5)==="touch")){e=e;let a=e.changedTouches[0];if(r==="touchstart"&&e.touches.length===1&&(ia.touch.id=a.identifier),ia.touch.id!==a.identifier)return;BG||(r==="touchstart"||r==="touchmove")&&mxe(e)}if(t=e[t9],!t.skip){for(let a=0,s;a<f_.length;a++)s=f_[a],o[s.name]&&!t[s.name]&&s.flow&&s.flow.start.indexOf(e.type)>-1&&s.reset&&s.reset();for(let a=0,s;a<f_.length;a++)s=f_[a],o[s.name]&&!t[s.name]&&(t[s.name]=!0,s[r](e))}}}function mxe(e){let t=e.changedTouches[0],r=e.type;if(r==="touchstart")ia.touch.x=t.clientX,ia.touch.y=t.clientY,ia.touch.scrollDecided=!1;else if(r==="touchmove"){if(ia.touch.scrollDecided)return;ia.touch.scrollDecided=!0;let n=pxe(e),i=!1,o=Math.abs(ia.touch.x-t.clientX),a=Math.abs(ia.touch.y-t.clientY);e.cancelable&&(n==="none"?i=!0:n==="pan-x"?i=a>o:n==="pan-y"&&(i=o>a)),i?e.preventDefault():r9("track")}}function Em(e,t,r){return iE[t]?(gxe(e,t,r),!0):!1}function sgt(e,t,r){return iE[t]?(_xe(e,t,r),!0):!1}function gxe(e,t,r){let n=iE[t],i=n.deps,o=n.name,a=e[e9];a||(e[e9]=a={});for(let s=0,l,c;s<i.length;s++)l=i[s],!(igt&&HG(l)&&l!=="click")&&(c=a[l],c||(a[l]=c={_count:0}),c._count===0&&e.addEventListener(l,agt,ngt(l)),c[o]=(c[o]||0)+1,c._count=(c._count||0)+1);e.addEventListener(t,r),n.touchAction&&d_(e,n.touchAction)}function _xe(e,t,r){let n=iE[t],i=n.deps,o=n.name,a=e[e9];if(a)for(let s=0,l,c;s<i.length;s++)l=i[s],c=a[l],c&&c[o]&&(c[o]=(c[o]||1)-1,c._count=(c._count||1)-1,c._count===0&&e.removeEventListener(l,agt,ngt(l)));e.removeEventListener(t,r)}function UG(e){f_.push(e);for(let t=0;t<e.emits.length;t++)iE[e.emits[t]]=e}function yxe(e){for(let t=0,r;t<f_.length;t++){r=f_[t];for(let n=0,i;n<r.emits.length;n++)if(i=r.emits[n],i===e)return r}return null}function d_(e,t){BG&&e instanceof HTMLElement&&li.run(()=>{e.style.touchAction=t}),e[zG]=t}function qG(e,t,r){let n=new Event(t,{bubbles:!0,cancelable:!0,composed:!0});if(n.detail=r,ue(e).dispatchEvent(n),n.defaultPrevented){let i=r.preventer||r.sourceEvent;i&&i.preventDefault&&i.preventDefault()}}function r9(e){let t=yxe(e);t.info&&(t.info.prevent=!0)}UG({name:"downup",deps:["mousedown","touchstart","touchend"],flow:{start:["mousedown","touchstart"],end:["mouseup","touchend"]},emits:["down","up"],info:{movefn:null,upfn:null},reset:function(){Fx(this.info)},mousedown:function(e){if(!p_(e))return;let t=_p(e),r=this,n=function(a){p_(a)||(nE("up",t,a),Fx(r.info))},i=function(a){p_(a)&&nE("up",t,a),Fx(r.info)};ogt(this.info,n,i),nE("down",t,e)},touchstart:function(e){nE("down",_p(e),e.changedTouches[0],e)},touchend:function(e){nE("up",_p(e),e.changedTouches[0],e)}});function nE(e,t,r,n){!t||qG(t,e,{x:r.clientX,y:r.clientY,sourceEvent:r,preventer:n,prevent:function(i){return r9(i)}})}UG({name:"track",touchAction:"none",deps:["mousedown","touchstart","touchmove","touchend"],flow:{start:["mousedown","touchstart"],end:["mouseup","touchend"]},emits:["track"],info:{x:0,y:0,state:"start",started:!1,moves:[],addMove:function(e){this.moves.length>nxe&&this.moves.shift(),this.moves.push(e)},movefn:null,upfn:null,prevent:!1},reset:function(){this.info.state="start",this.info.started=!1,this.info.moves=[],this.info.x=0,this.info.y=0,this.info.prevent=!1,Fx(this.info)},mousedown:function(e){if(!p_(e))return;let t=_p(e),r=this,n=function(a){let s=a.clientX,l=a.clientY;tgt(r.info,s,l)&&(r.info.state=r.info.started?a.type==="mouseup"?"end":"track":"start",r.info.state==="start"&&r9("tap"),r.info.addMove({x:s,y:l}),p_(a)||(r.info.state="end",Fx(r.info)),t&&OG(r.info,t,a),r.info.started=!0)},i=function(a){r.info.started&&n(a),Fx(r.info)};ogt(this.info,n,i),this.info.x=e.clientX,this.info.y=e.clientY},touchstart:function(e){let t=e.changedTouches[0];this.info.x=t.clientX,this.info.y=t.clientY},touchmove:function(e){let t=_p(e),r=e.changedTouches[0],n=r.clientX,i=r.clientY;tgt(this.info,n,i)&&(this.info.state==="start"&&r9("tap"),this.info.addMove({x:n,y:i}),OG(this.info,t,r),this.info.state="track",this.info.started=!0)},touchend:function(e){let t=_p(e),r=e.changedTouches[0];this.info.started&&(this.info.state="end",this.info.addMove({x:r.clientX,y:r.clientY}),OG(this.info,t,r))}});function tgt(e,t,r){if(e.prevent)return!1;if(e.started)return!0;let n=Math.abs(e.x-t),i=Math.abs(e.y-r);return n>=Zmt||i>=Zmt}function OG(e,t,r){if(!t)return;let n=e.moves[e.moves.length-2],i=e.moves[e.moves.length-1],o=i.x-e.x,a=i.y-e.y,s,l=0;n&&(s=i.x-n.x,l=i.y-n.y),qG(t,"track",{state:e.state,x:r.clientX,y:r.clientY,dx:o,dy:a,ddx:s,ddy:l,sourceEvent:r,hover:function(){return dxe(r.clientX,r.clientY)}})}UG({name:"tap",deps:["mousedown","click","touchstart","touchend"],flow:{start:["mousedown","touchstart"],end:["click","touchend"]},emits:["tap"],info:{x:NaN,y:NaN,prevent:!1},reset:function(){this.info.x=NaN,this.info.y=NaN,this.info.prevent=!1},mousedown:function(e){p_(e)&&(this.info.x=e.clientX,this.info.y=e.clientY)},click:function(e){p_(e)&&egt(this.info,e)},touchstart:function(e){let t=e.changedTouches[0];this.info.x=t.clientX,this.info.y=t.clientY},touchend:function(e){egt(this.info,e.changedTouches[0],e)}});function egt(e,t,r){let n=Math.abs(t.clientX-e.x),i=Math.abs(t.clientY-e.y),o=_p(r||t);!o||lxe[o.localName]&&o.hasAttribute("disabled")||(isNaN(n)||isNaN(i)||n<=Kmt&&i<=Kmt||fxe(t))&&(e.prevent||qG(o,"tap",{x:t.clientX,y:t.clientY,sourceEvent:t,preventer:r}))}var lgt=_p;var yh=Rn(e=>{class t extends e{_addEventListenerToNode(n,i,o){Em(n,i,o)||super._addEventListenerToNode(n,i,o)}_removeEventListenerFromNode(n,i,o){sgt(n,i,o)||super._removeEventListenerFromNode(n,i,o)}}return t});var vxe=/:host\(:dir\((ltr|rtl)\)\)/g,xxe=':host([dir="$1"])',bxe=/([\s\w-#\.\[\]\*]*):dir\((ltr|rtl)\)/g,wxe=':host([dir="$2"]) $1',Sxe=/:dir\((?:ltr|rtl)\)/,ugt=Boolean(window.ShadyDOM&&window.ShadyDOM.inUse),oE=[],aE=null,GG="";function hgt(){GG=document.documentElement.getAttribute("dir")}function fgt(e){e.__autoDirOptOut||e.setAttribute("dir",GG)}function pgt(){hgt(),GG=document.documentElement.getAttribute("dir");for(let e=0;e<oE.length;e++)fgt(oE[e])}function Mxe(){aE&&aE.takeRecords().length&&pgt()}var dgt=Rn(e=>{ugt||aE||(hgt(),aE=new MutationObserver(pgt),aE.observe(document.documentElement,{attributes:!0,attributeFilter:["dir"]}));let t=HI(e);class r extends t{static _processStyleText(i,o){return i=t._processStyleText.call(this,i,o),!ugt&&Sxe.test(i)&&(i=this._replaceDirInCssText(i),this.__activateDir=!0),i}static _replaceDirInCssText(i){let o=i;return o=o.replace(vxe,xxe),o=o.replace(bxe,wxe),o}constructor(){super(),this.__autoDirOptOut=!1}ready(){super.ready(),this.__autoDirOptOut=this.hasAttribute("dir")}connectedCallback(){t.prototype.connectedCallback&&super.connectedCallback(),this.constructor.__activateDir&&(Mxe(),oE.push(this),fgt(this))}disconnectedCallback(){if(t.prototype.disconnectedCallback&&super.disconnectedCallback(),this.constructor.__activateDir){let i=oE.indexOf(this);i>-1&&oE.splice(i,1)}}}return r.__activateDir=!1,r});var i9=!1,mgt=[],ggt=[];function _gt(){i9=!0,requestAnimationFrame(function(){i9=!1,Exe(mgt),setTimeout(function(){Txe(ggt)})})}function Exe(e){for(;e.length;)ygt(e.shift())}function Txe(e){for(let t=0,r=e.length;t<r;t++)ygt(e.shift())}function ygt(e){let t=e[0],r=e[1],n=e[2];try{r.apply(t,n)}catch(i){setTimeout(()=>{throw i})}}function vgt(e,t,r){i9||_gt(),mgt.push([e,t,r])}function Tm(e,t,r){i9||_gt(),ggt.push([e,t,r])}function xgt(){document.body.removeAttribute("unresolved")}document.readyState==="interactive"||document.readyState==="complete"?xgt():window.addEventListener("DOMContentLoaded",xgt);function sE(e,t,r){return{index:e,removed:t,addedCount:r}}var bgt=0,wgt=1,WG=2,YG=3;function Cxe(e,t,r,n,i,o){let a=o-i+1,s=r-t+1,l=new Array(a);for(let c=0;c<a;c++)l[c]=new Array(s),l[c][0]=c;for(let c=0;c<s;c++)l[0][c]=c;for(let c=1;c<a;c++)for(let u=1;u<s;u++)if(jG(e[t+u-1],n[i+c-1]))l[c][u]=l[c-1][u-1];else{let h=l[c-1][u]+1,f=l[c][u-1]+1;l[c][u]=h<f?h:f}return l}function Axe(e){let t=e.length-1,r=e[0].length-1,n=e[t][r],i=[];for(;t>0||r>0;){if(t==0){i.push(WG),r--;continue}if(r==0){i.push(YG),t--;continue}let o=e[t-1][r-1],a=e[t-1][r],s=e[t][r-1],l;a<s?l=a<o?a:o:l=s<o?s:o,l==o?(o==n?i.push(bgt):(i.push(wgt),n=o),t--,r--):l==a?(i.push(YG),t--,n=a):(i.push(WG),r--,n=s)}return i.reverse(),i}function Pxe(e,t,r,n,i,o){let a=0,s=0,l,c=Math.min(r-t,o-i);if(t==0&&i==0&&(a=Ixe(e,n,c)),r==e.length&&o==n.length&&(s=Lxe(e,n,c-a)),t+=a,i+=a,r-=s,o-=s,r-t==0&&o-i==0)return[];if(t==r){for(l=sE(t,[],0);i<o;)l.removed.push(n[i++]);return[l]}else if(i==o)return[sE(t,[],r-t)];let u=Axe(Cxe(e,t,r,n,i,o));l=void 0;let h=[],f=t,p=i;for(let d=0;d<u.length;d++)switch(u[d]){case bgt:l&&(h.push(l),l=void 0),f++,p++;break;case wgt:l||(l=sE(f,[],0)),l.addedCount++,f++,l.removed.push(n[p]),p++;break;case WG:l||(l=sE(f,[],0)),l.addedCount++,f++;break;case YG:l||(l=sE(f,[],0)),l.removed.push(n[p]),p++;break}return l&&h.push(l),h}function Ixe(e,t,r){for(let n=0;n<r;n++)if(!jG(e[n],t[n]))return n;return r}function Lxe(e,t,r){let n=e.length,i=t.length,o=0;for(;o<r&&jG(e[--n],t[--i]);)o++;return o}function o9(e,t){return Pxe(e,0,e.length,t,0,t.length)}function jG(e,t){return e===t}function Bx(e){return e.localName==="slot"}var vh=class{static getFlattenedNodes(e){let t=ue(e);return Bx(e)?(e=e,t.assignedNodes({flatten:!0})):Array.from(t.childNodes).map(r=>Bx(r)?(r=r,ue(r).assignedNodes({flatten:!0})):[r]).reduce((r,n)=>r.concat(n),[])}constructor(e,t){this._shadyChildrenObserver=null,this._nativeChildrenObserver=null,this._connected=!1,this._target=e,this.callback=t,this._effectiveNodes=[],this._observer=null,this._scheduled=!1,this._boundSchedule=()=>{this._schedule()},this.connect(),this._schedule()}connect(){Bx(this._target)?this._listenSlots([this._target]):ue(this._target).children&&(this._listenSlots(ue(this._target).children),window.ShadyDOM?this._shadyChildrenObserver=window.ShadyDOM.observeChildren(this._target,e=>{this._processMutations(e)}):(this._nativeChildrenObserver=new MutationObserver(e=>{this._processMutations(e)}),this._nativeChildrenObserver.observe(this._target,{childList:!0}))),this._connected=!0}disconnect(){Bx(this._target)?this._unlistenSlots([this._target]):ue(this._target).children&&(this._unlistenSlots(ue(this._target).children),window.ShadyDOM&&this._shadyChildrenObserver?(window.ShadyDOM.unobserveChildren(this._shadyChildrenObserver),this._shadyChildrenObserver=null):this._nativeChildrenObserver&&(this._nativeChildrenObserver.disconnect(),this._nativeChildrenObserver=null)),this._connected=!1}_schedule(){this._scheduled||(this._scheduled=!0,li.run(()=>this.flush()))}_processMutations(e){this._processSlotMutations(e),this.flush()}_processSlotMutations(e){if(e)for(let t=0;t<e.length;t++){let r=e[t];r.addedNodes&&this._listenSlots(r.addedNodes),r.removedNodes&&this._unlistenSlots(r.removedNodes)}}flush(){if(!this._connected)return!1;window.ShadyDOM&&ShadyDOM.flush(),this._nativeChildrenObserver?this._processSlotMutations(this._nativeChildrenObserver.takeRecords()):this._shadyChildrenObserver&&this._processSlotMutations(this._shadyChildrenObserver.takeRecords()),this._scheduled=!1;let e={target:this._target,addedNodes:[],removedNodes:[]},t=this.constructor.getFlattenedNodes(this._target),r=o9(t,this._effectiveNodes);for(let i=0,o;i<r.length&&(o=r[i]);i++)for(let a=0,s;a<o.removed.length&&(s=o.removed[a]);a++)e.removedNodes.push(s);for(let i=0,o;i<r.length&&(o=r[i]);i++)for(let a=o.index;a<o.index+o.addedCount;a++)e.addedNodes.push(t[a]);this._effectiveNodes=t;let n=!1;return(e.addedNodes.length||e.removedNodes.length)&&(n=!0,this.callback.call(this._target,e)),n}_listenSlots(e){for(let t=0;t<e.length;t++){let r=e[t];Bx(r)&&r.addEventListener("slotchange",this._boundSchedule)}}_unlistenSlots(e){for(let t=0;t<e.length;t++){let r=e[t];Bx(r)&&r.removeEventListener("slotchange",this._boundSchedule)}}};var ci=function(){let e,t;do e=window.ShadyDOM&&ShadyDOM.flush(),window.ShadyCSS&&window.ShadyCSS.ScopingShim&&window.ShadyCSS.ScopingShim.flush(),t=$mt();while(e||t)};var Hx=Element.prototype,kxe=Hx.matches||Hx.matchesSelector||Hx.mozMatchesSelector||Hx.msMatchesSelector||Hx.oMatchesSelector||Hx.webkitMatchesSelector,$G=function(e,t){return kxe.call(e,t)},Kr=class{constructor(t){window.ShadyDOM&&window.ShadyDOM.inUse&&window.ShadyDOM.patch(t),this.node=t}observeNodes(t){return new vh(this.node,t)}unobserveNodes(t){t.disconnect()}notifyObserver(){}deepContains(t){if(ue(this.node).contains(t))return!0;let r=t,n=t.ownerDocument;for(;r&&r!==n&&r!==this.node;)r=ue(r).parentNode||ue(r).host;return r===this.node}getOwnerRoot(){return ue(this.node).getRootNode()}getDistributedNodes(){return this.node.localName==="slot"?ue(this.node).assignedNodes({flatten:!0}):[]}getDestinationInsertionPoints(){let t=[],r=ue(this.node).assignedSlot;for(;r;)t.push(r),r=ue(r).assignedSlot;return t}importNode(t,r){let n=this.node instanceof Document?this.node:this.node.ownerDocument;return ue(n).importNode(t,r)}getEffectiveChildNodes(){return vh.getFlattenedNodes(this.node)}queryDistributedElements(t){let r=this.getEffectiveChildNodes(),n=[];for(let i=0,o=r.length,a;i<o&&(a=r[i]);i++)a.nodeType===Node.ELEMENT_NODE&&$G(a,t)&&n.push(a);return n}get activeElement(){let t=this.node;return t._activeElement!==void 0?t._activeElement:t.activeElement}};function Rxe(e,t){for(let r=0;r<t.length;r++){let n=t[r];e[n]=function(){return this.node[n].apply(this.node,arguments)}}}function Sgt(e,t){for(let r=0;r<t.length;r++){let n=t[r];Object.defineProperty(e,n,{get:function(){return this.node[n]},configurable:!0})}}function Nxe(e,t){for(let r=0;r<t.length;r++){let n=t[r];Object.defineProperty(e,n,{get:function(){return this.node[n]},set:function(i){this.node[n]=i},configurable:!0})}}var lE=class{constructor(t){this.event=t}get rootTarget(){return this.path[0]}get localTarget(){return this.event.target}get path(){return this.event.composedPath()}};Kr.prototype.cloneNode;Kr.prototype.appendChild;Kr.prototype.insertBefore;Kr.prototype.removeChild;Kr.prototype.replaceChild;Kr.prototype.setAttribute;Kr.prototype.removeAttribute;Kr.prototype.querySelector;Kr.prototype.querySelectorAll;Kr.prototype.parentNode;Kr.prototype.firstChild;Kr.prototype.lastChild;Kr.prototype.nextSibling;Kr.prototype.previousSibling;Kr.prototype.firstElementChild;Kr.prototype.lastElementChild;Kr.prototype.nextElementSibling;Kr.prototype.previousElementSibling;Kr.prototype.childNodes;Kr.prototype.children;Kr.prototype.classList;Kr.prototype.textContent;Kr.prototype.innerHTML;var XG=Kr;if(window.ShadyDOM&&window.ShadyDOM.inUse&&window.ShadyDOM.noPatch&&window.ShadyDOM.Wrapper){class e extends window.ShadyDOM.Wrapper{}Object.getOwnPropertyNames(Kr.prototype).forEach(t=>{t!="activeElement"&&(e.prototype[t]=Kr.prototype[t])}),Sgt(e.prototype,["classList"]),XG=e,Object.defineProperties(lE.prototype,{localTarget:{get(){let t=this.event.currentTarget,r=t&&zt(t).getOwnerRoot(),n=this.path;for(let i=0;i<n.length;i++){let o=n[i];if(zt(o).getOwnerRoot()===r)return o}},configurable:!0},path:{get(){return window.ShadyDOM.composedPath(this.event)},configurable:!0}})}else Rxe(Kr.prototype,["cloneNode","appendChild","insertBefore","removeChild","replaceChild","setAttribute","removeAttribute","querySelector","querySelectorAll"]),Sgt(Kr.prototype,["parentNode","firstChild","lastChild","nextSibling","previousSibling","firstElementChild","lastElementChild","nextElementSibling","previousElementSibling","childNodes","children","classList"]),Nxe(Kr.prototype,["textContent","innerHTML","className"]);var zt=function(e){if(e=e||document,e instanceof XG||e instanceof lE)return e;let t=e.__domApi;return t||(e instanceof Event?t=new lE(e):t=new XG(e),e.__domApi=t),t};var KG=window.ShadyDOM,Mgt=window.ShadyCSS;function Egt(e,t){return ue(e).getRootNode()===t}function Tgt(e,t=!1){if(!KG||!Mgt||!KG.handlesDynamicScoping)return null;let r=Mgt.ScopingShim;if(!r)return null;let n=r.scopeForNode(e),i=ue(e).getRootNode(),o=a=>{if(!Egt(a,i))return;let s=Array.from(KG.nativeMethods.querySelectorAll.call(a,"*"));s.push(a);for(let l=0;l<s.length;l++){let c=s[l];if(!Egt(c,i))continue;let u=r.currentScopeForNode(c);u!==n&&(u!==""&&r.unscopeNode(c,u),r.scopeNode(c,n))}};if(o(e),t){let a=new MutationObserver(s=>{for(let l=0;l<s.length;l++){let c=s[l];for(let u=0;u<c.addedNodes.length;u++){let h=c.addedNodes[u];h.nodeType===Node.ELEMENT_NODE&&o(h)}}});return a.observe(e,{childList:!0,subtree:!0}),a}else return null}var ZG="disable-upgrade",JG=e=>{for(;e;){let t=Object.getOwnPropertyDescriptor(e,"observedAttributes");if(t)return t.get;e=Object.getPrototypeOf(e.prototype).constructor}return()=>[]},E1r=Rn(e=>{let t=Sm(e),r=JG(t);class n extends t{constructor(){super(),this.__isUpgradeDisabled}static get observedAttributes(){return r.call(this).concat(ZG)}_initializeProperties(){this.hasAttribute(ZG)?this.__isUpgradeDisabled=!0:super._initializeProperties()}_enableProperties(){this.__isUpgradeDisabled||super._enableProperties()}_canApplyPropertyDefault(o){return super._canApplyPropertyDefault(o)&&!(this.__isUpgradeDisabled&&this._isPropertyPending(o))}attributeChangedCallback(o,a,s,l){o==ZG?this.__isUpgradeDisabled&&s==null&&(super._initializeProperties(),this.__isUpgradeDisabled=!1,ue(this).isConnected&&super.connectedCallback()):super.attributeChangedCallback(o,a,s,l)}connectedCallback(){this.__isUpgradeDisabled||super.connectedCallback()}disconnectedCallback(){this.__isUpgradeDisabled||super.disconnectedCallback()}}return n});var a9="disable-upgrade",Dxe=window.ShadyCSS,Gt=Rn(e=>{let t=yh(Sm(e)),r=UI?t:dgt(t),n=JG(r),i={x:"pan-x",y:"pan-y",none:"none",all:"auto"};class o extends r{constructor(){super(),this.isAttached,this.__boundListeners,this._debouncers,this.__isUpgradeDisabled,this.__needsAttributesAtConnected,this._legacyForceObservedAttributes}static get importMeta(){return this.prototype.importMeta}created(){}__attributeReaction(s,l,c){(this.__dataAttributes&&this.__dataAttributes[s]||s===a9)&&this.attributeChangedCallback(s,l,c,null)}setAttribute(s,l){if(qM&&!this._legacyForceObservedAttributes){let c=this.getAttribute(s);super.setAttribute(s,l),this.__attributeReaction(s,c,String(l))}else super.setAttribute(s,l)}removeAttribute(s){if(qM&&!this._legacyForceObservedAttributes){let l=this.getAttribute(s);super.removeAttribute(s),this.__attributeReaction(s,l,null)}else super.removeAttribute(s)}static get observedAttributes(){return qM&&!this.prototype._legacyForceObservedAttributes?(this.hasOwnProperty(JSCompiler_renameProperty("__observedAttributes",this))||(this.__observedAttributes=[],VI(this.prototype)),this.__observedAttributes):n.call(this).concat(a9)}_enableProperties(){this.__isUpgradeDisabled||super._enableProperties()}_canApplyPropertyDefault(s){return super._canApplyPropertyDefault(s)&&!(this.__isUpgradeDisabled&&this._isPropertyPending(s))}connectedCallback(){this.__needsAttributesAtConnected&&this._takeAttributes(),this.__isUpgradeDisabled||(super.connectedCallback(),this.isAttached=!0,this.attached())}attached(){}disconnectedCallback(){this.__isUpgradeDisabled||(super.disconnectedCallback(),this.isAttached=!1,this.detached())}detached(){}attributeChangedCallback(s,l,c,u){l!==c&&(s==a9?this.__isUpgradeDisabled&&c==null&&(this._initializeProperties(),this.__isUpgradeDisabled=!1,ue(this).isConnected&&this.connectedCallback()):(super.attributeChangedCallback(s,l,c,u),this.attributeChanged(s,l,c)))}attributeChanged(s,l,c){}_initializeProperties(){if(pp&&this.hasAttribute(a9))this.__isUpgradeDisabled=!0;else{let s=Object.getPrototypeOf(this);s.hasOwnProperty(JSCompiler_renameProperty("__hasRegisterFinished",s))||(this._registered(),s.__hasRegisterFinished=!0),super._initializeProperties(),this.root=this,this.created(),qM&&!this._legacyForceObservedAttributes&&(this.hasAttributes()?this._takeAttributes():this.parentNode||(this.__needsAttributesAtConnected=!0)),this._applyListeners()}}_takeAttributes(){let s=this.attributes;for(let l=0,c=s.length;l<c;l++){let u=s[l];this.__attributeReaction(u.name,null,u.value)}}_registered(){}ready(){this._ensureAttributes(),super.ready()}_ensureAttributes(){}_applyListeners(){}serialize(s){return this._serializeValue(s)}deserialize(s,l){return this._deserializeValue(s,l)}reflectPropertyToAttribute(s,l,c){this._propertyToAttribute(s,l,c)}serializeValueToAttribute(s,l,c){this._valueToNodeAttribute(c||this,s,l)}extend(s,l){if(!(s&&l))return s||l;let c=Object.getOwnPropertyNames(l);for(let u=0,h;u<c.length&&(h=c[u]);u++){let f=Object.getOwnPropertyDescriptor(l,h);f&&Object.defineProperty(s,h,f)}return s}mixin(s,l){for(let c in l)s[c]=l[c];return s}chainObject(s,l){return s&&l&&s!==l&&(s.__proto__=l),s}instanceTemplate(s){let l=this.constructor._contentForTemplate(s);return document.importNode(l,!0)}fire(s,l,c){c=c||{},l=l==null?{}:l;let u=new Event(s,{bubbles:c.bubbles===void 0?!0:c.bubbles,cancelable:Boolean(c.cancelable),composed:c.composed===void 0?!0:c.composed});u.detail=l;let h=c.node||this;return ue(h).dispatchEvent(u),u}listen(s,l,c){s=s||this;let u=this.__boundListeners||(this.__boundListeners=new WeakMap),h=u.get(s);h||(h={},u.set(s,h));let f=l+c;h[f]||(h[f]=this._addMethodEventListenerToNode(s,l,c,this))}unlisten(s,l,c){s=s||this;let u=this.__boundListeners&&this.__boundListeners.get(s),h=l+c,f=u&&u[h];f&&(this._removeEventListenerFromNode(s,l,f),u[h]=null)}setScrollDirection(s,l){d_(l||this,i[s]||"auto")}$$(s){return this.root.querySelector(s)}get domHost(){let s=ue(this).getRootNode();return s instanceof DocumentFragment?s.host:s}distributeContent(){let l=zt(this);window.ShadyDOM&&l.shadowRoot&&ShadyDOM.flush()}getEffectiveChildNodes(){return zt(this).getEffectiveChildNodes()}queryDistributedElements(s){return zt(this).queryDistributedElements(s)}getEffectiveChildren(){return this.getEffectiveChildNodes().filter(function(l){return l.nodeType===Node.ELEMENT_NODE})}getEffectiveTextContent(){let s=this.getEffectiveChildNodes(),l=[];for(let c=0,u;u=s[c];c++)u.nodeType!==Node.COMMENT_NODE&&l.push(u.textContent);return l.join("")}queryEffectiveChildren(s){let l=this.queryDistributedElements(s);return l&&l[0]}queryAllEffectiveChildren(s){return this.queryDistributedElements(s)}getContentChildNodes(s){let l=this.root.querySelector(s||"slot");return l?zt(l).getDistributedNodes():[]}getContentChildren(s){return this.getContentChildNodes(s).filter(function(c){return c.nodeType===Node.ELEMENT_NODE})}isLightDescendant(s){let l=this;return l!==s&&ue(l).contains(s)&&ue(l).getRootNode()===ue(s).getRootNode()}isLocalDescendant(s){return this.root===ue(s).getRootNode()}scopeSubtree(s,l=!1){return Tgt(s,l)}getComputedStyleValue(s){return Dxe.getComputedStyleValue(this,s)}debounce(s,l,c){return this._debouncers=this._debouncers||{},this._debouncers[s]=sr.debounce(this._debouncers[s],c>0?mo.after(c):li,l.bind(this))}isDebouncerActive(s){this._debouncers=this._debouncers||{};let l=this._debouncers[s];return!!(l&&l.isActive())}flushDebouncer(s){this._debouncers=this._debouncers||{};let l=this._debouncers[s];l&&l.flush()}cancelDebouncer(s){this._debouncers=this._debouncers||{};let l=this._debouncers[s];l&&l.cancel()}async(s,l){return l>0?mo.run(s.bind(this),l):~li.run(s.bind(this))}cancelAsync(s){s<0?li.cancel(~s):mo.cancel(s)}create(s,l){let c=document.createElement(s);if(l)if(c.setProperties)c.setProperties(l);else for(let u in l)c[u]=l[u];return c}elementMatches(s,l){return $G(l||this,s)}toggleAttribute(s,l){let c=this;return arguments.length===3&&(c=arguments[2]),arguments.length==1&&(l=!c.hasAttribute(s)),l?(ue(c).setAttribute(s,""),!0):(ue(c).removeAttribute(s),!1)}toggleClass(s,l,c){c=c||this,arguments.length==1&&(l=!c.classList.contains(s)),l?c.classList.add(s):c.classList.remove(s)}transform(s,l){l=l||this,l.style.webkitTransform=s,l.style.transform=s}translate3d(s,l,c,u){u=u||this,this.transform("translate3d("+s+","+l+","+c+")",u)}arrayDelete(s,l){let c;if(Array.isArray(s)){if(c=s.indexOf(l),c>=0)return s.splice(c,1)}else if(c=No(this,s).indexOf(l),c>=0)return this.splice(s,c,1);return null}_logger(s,l){switch(Array.isArray(l)&&l.length===1&&Array.isArray(l[0])&&(l=l[0]),s){case"log":case"warn":case"error":console[s](...l)}}_log(...s){this._logger("log",s)}_warn(...s){this._logger("warn",s)}_error(...s){this._logger("error",s)}_logf(s,...l){return["[%s::%s]",this.is,s,...l]}}return o.prototype.is="",o});var Cm=Ee(Oe(),1);function xh(e,t){let r=0,n=0;for(;;){if(r===e.length)return n===t.length?0:-1;if(n===t.length)return 1;if(m_(e[r])&&m_(t[n])){let i=r,o=n;r=Cgt(e,r+1),n=Cgt(t,n+1);let a=parseFloat(e.slice(i,r)),s=parseFloat(t.slice(o,n));if(a<s)return-1;if(a>s)return 1;continue}if(QG(e[r])){if(!QG(t[n]))return-1}else{if(QG(t[n]))return 1;if(e[r]<t[n])return-1;if(e[r]>t[n])return 1}r++,n++}}function Cgt(e,t){let r;(function(i){i[i.NATURAL=0]="NATURAL",i[i.REAL=1]="REAL",i[i.EXPONENT_SIGN=2]="EXPONENT_SIGN",i[i.EXPONENT=3]="EXPONENT"})(r||(r={}));let n=r.NATURAL;for(;t<e.length;t++)if(n===r.NATURAL){if(e[t]===".")n=r.REAL;else if(e[t]==="e"||e[t]==="E")n=r.EXPONENT_SIGN;else if(!m_(e[t]))break}else if(n===r.REAL){if(e[t]==="e"||e[t]==="E")n=r.EXPONENT_SIGN;else if(!m_(e[t]))break}else if(n===r.EXPONENT_SIGN)if(m_(e[t])||e[t]==="+"||e[t]==="-")n=r.EXPONENT;else break;else if(n===r.EXPONENT&&!m_(e[t]))break;return t}function m_(e){return"0"<=e&&e<="9"}function QG(e){return e==="/"||e==="_"||m_(e)}var Oxe=[];function zxe(e){return Cm.keys(e).sort(xh)}function $i(e){return Cm.union.apply(null,Cm.values(e)).sort(xh)}function Fxe(e,t){let r=[];return t.forEach(n=>r=r.concat(e[n])),Cm.uniq(r).sort(xh)}var Pgt="X-TensorBoard-Feature-Flags",Igt="tensorBoardFeatureFlags";var tW={};Ks(tW,{getFeatureFlags:()=>Hxe,getFeatureFlagsToSendToServer:()=>cE,initializeFeatureFlags:()=>Lgt,setFeatureFlags:()=>Bxe});var s9,l9;Lgt();function Lgt(){s9=null,l9=null}function Bxe(e,t){s9=e,l9=t}function Hxe(){if(s9===null)throw Error("FeatureFlags have not yet been determined by TensorBoard.");return s9}function cE(){if(l9===null)throw Error("FeatureFlags have not yet been determined by TensorBoard.");return l9}var c9=class extends Error{constructor(){super(...arguments),this.name="RequestCancellationError"}},Vx=class extends Error{constructor(t){super(t),this.name="InvalidRequestOptionsError",Object.setPrototypeOf(this,Vx.prototype)}},uE=class extends Error{constructor(t,r){super(),this.message=`RequestNetworkError: ${t.status} at ${r}`,this.name="RequestNetworkError",this.req=t,this.url=r}},Am;(function(e){e.GET="GET",e.POST="POST"})(Am||(Am={}));var Ux=class{validate(){if(this.methodType===Am.GET&&this.body)throw new Vx("body must be missing for a GET request.")}},Ae=class{constructor(t=1e3,r=3){this._queue=[],this._nActiveRequests=0,this._nSimultaneousRequests=t,this._maxRetries=r}request(t,r){let n=Uxe(r);return this.requestWithOptions(t,n)}requestWithOptions(t,r){return r.validate(),new Promise((i,o)=>{let a={resolve:i,reject:o};this._queue.push(a),this.launchRequests()}).then(()=>this.promiseWithRetries(t,this._maxRetries,r)).then(i=>(this._nActiveRequests--,this.launchRequests(),i),i=>(i.name==="RequestNetworkError"&&(this._nActiveRequests--,this.launchRequests()),Promise.reject(i)))}fetch(t,r){return new Promise((n,i)=>{let o={resolve:n,reject:i};this._queue.push(o),this.launchRequests()}).then(()=>{let n=1;return new Promise(i=>{let o=()=>{fetch(t,r).then(a=>{if(!a.ok&&this._maxRetries>n){n++,o();return}i(a),this._nActiveRequests--,this.launchRequests()})};o()})})}clearQueue(){var t;for(;this._queue.length>0;)(t=this._queue.pop())==null||t.reject(new c9("Request cancelled by clearQueue"))}activeRequests(){return this._nActiveRequests}outstandingRequests(){return this._nActiveRequests+this._queue.length}launchRequests(){for(;this._nActiveRequests<this._nSimultaneousRequests&&this._queue.length>0;)this._nActiveRequests++,this._queue.pop().resolve(void 0)}promiseWithRetries(t,r,n){var i=a=>a,o=a=>r>0?this.promiseWithRetries(t,r-1,n):Promise.reject(a);return this._promiseFromUrl(t,n).then(i,o)}_promiseFromUrl(t,r){return new Promise((n,i)=>{let o=Vxe(r.methodType,t,r.withCredentials,r.contentType);o.setRequestHeader(Pgt,JSON.stringify(cE())),o.onload=function(){o.status===200?n(JSON.parse(o.responseText)):i(new uE(o,t))},o.onerror=function(){i(new uE(o,t))},r.body?o.send(r.body):o.send()})}};function Vxe(e,t,r,n){let i=new XMLHttpRequest;return i.open(e,t),r&&(i.withCredentials=r),n&&i.setRequestHeader("Content-Type",n),i}function Uxe(e){let t=new Ux;return e?(t.methodType=Am.POST,t.body=qxe(e),t):(t.methodType=Am.GET,t)}function qxe(e){let t=new FormData;for(let[r,n]of Object.entries(e)){let i=Array.isArray(n)?n:[n];for(let o of i)t.append(r,o)}return t}var kgt="experimentalPlugin",Gxe=new URLSearchParams(window.location.search),Wxe=Rgt();function Rgt(){return{environment:()=>qx("/environment"),experiments:()=>qx("/experiments"),pluginRoute:(e,t,r)=>qx(`/plugin/${e}${t}`,r),pluginRouteForSrc:(e,t,r=new URLSearchParams)=>{let n=cE();return Object.keys(n).length>0&&r.append(Igt,JSON.stringify(n)),qx(`/plugin/${e}${t}`,r)},pluginsListing:()=>qx("/plugins_listing",Ngt({[kgt]:Gxe.getAll(kgt)})),runs:()=>qx("/runs")}}function _e(){return Wxe}function qx(e,t=new URLSearchParams){let r="data"+e;return String(t)&&(r+=(e.includes("?")?"&":"?")+String(t)),r}function Ngt(e={}){let t=Object.keys(e).sort().filter(n=>e[n]),r=new URLSearchParams;return t.forEach(n=>{let i=e[n];(Array.isArray(i)?i:[i]).forEach(a=>r.append(n,a))}),r}var u9=Ee(Oe(),1);var Na;(function(e){e[e.SEARCH_RESULTS=0]="SEARCH_RESULTS",e[e.PREFIX_GROUP=1]="PREFIX_GROUP"})(Na||(Na={}));function Yxe(e,t){let r=(()=>{try{return new RegExp(t)}catch(n){return null}})();return{name:t,metadata:{type:Na.SEARCH_RESULTS,validRegex:!!r,universalRegex:t===".*"},items:r?e.filter(n=>n.match(r)):[]}}function jxe(e,t="/"){let r=[],n={};return e.forEach(i=>{let o=i.indexOf(t),a=o>=0?i.slice(0,o):i;if(!n[a]){let s={name:a,metadata:{type:Na.PREFIX_GROUP},items:[]};n[a]=s,r.push(s)}n[a].items.push(i)}),r}function Xxe(e,t=""){let r=[Yxe(e,t)],n=jxe(e);return Array().concat(r,n)}function hE(e,t,r){let n=$i(e),i=Xxe(n,r),o=$xe(u9.pick(e,t));return i.map(({name:a,metadata:s,items:l})=>({name:a,metadata:s,items:l.map(c=>({tag:c,runs:(o.get(c)||[]).slice()}))}))}function $xe(e){let t=new Map;return Object.keys(e).forEach(r=>{e[r].forEach(n=>{let i=t.get(n)||[];i.push(r),t.set(n,i)})}),t}function Kxe(e,t){let r=xh(e.tag,t.tag);return r!=0?r:xh(e.run,t.run)}function Ql(e,t,r){let n=hE(e,t,r);function i(o){let a=u9.flatten(o.items.map(({tag:s,runs:l})=>l.map(c=>({tag:s,run:c}))));return a.sort(Kxe),{name:o.name,metadata:o.metadata,items:a}}return n.map(i)}var cW={};Ks(cW,{IronResizableBehavior:()=>Js});var Zxe={attached:!0,detached:!0,ready:!0,created:!0,beforeRegister:!0,registered:!0,attributeChanged:!0,listeners:!0,hostAttributes:!0},Fgt={attached:!0,detached:!0,ready:!0,created:!0,beforeRegister:!0,registered:!0,attributeChanged:!0,behaviors:!0,_noAccessors:!0},Jxe=Object.assign({listeners:!0,hostAttributes:!0,properties:!0,observers:!0},Fgt);function Qxe(e,t,r){let n=e._noAccessors,i=Object.getOwnPropertyNames(e);for(let o=0;o<i.length;o++){let a=i[o];if(!(a in r))if(n)t[a]=e[a];else{let s=Object.getOwnPropertyDescriptor(e,a);s&&(s.configurable=!0,Object.defineProperty(t,a,s))}}}function Bgt(e,t){return Ugt({},Gt(t),e)}function tbe(e,t,r){for(let n=0;n<t.length;n++)Hgt(e,t[n],r,Jxe)}function Hgt(e,t,r,n){Qxe(t,e,n);for(let i in Zxe)t[i]&&(r[i]=r[i]||[],r[i].push(t[i]))}function Vgt(e,t,r){t=t||[];for(let n=e.length-1;n>=0;n--){let i=e[n];i?Array.isArray(i)?Vgt(i,t):t.indexOf(i)<0&&(!r||r.indexOf(i)<0)&&t.unshift(i):console.warn("behavior is null, check for missing or 404 import")}return t}function Ogt(e,t){for(let r in t){let n=e[r],i=t[r];!("value"in i)&&n&&"value"in n?e[r]=Object.assign({value:n.value},i):e[r]=i}}var zgt=Gt(HTMLElement);function Ugt(e,t,r){let n,i={};class o extends t{static _finalizeClass(){if(!this.hasOwnProperty(JSCompiler_renameProperty("generatedFrom",this)))t._finalizeClass.call(this);else{if(n)for(let l=0,c;l<n.length;l++)c=n[l],c.properties&&this.createProperties(c.properties),c.observers&&this.createObservers(c.observers,c.properties);e.properties&&this.createProperties(e.properties),e.observers&&this.createObservers(e.observers,e.properties),this._prepareTemplate()}}static get properties(){let l={};if(n)for(let c=0;c<n.length;c++)Ogt(l,n[c].properties);return Ogt(l,e.properties),l}static get observers(){let l=[];if(n)for(let c=0,u;c<n.length;c++)u=n[c],u.observers&&(l=l.concat(u.observers));return e.observers&&(l=l.concat(e.observers)),l}created(){super.created();let l=i.created;if(l)for(let c=0;c<l.length;c++)l[c].call(this)}_registered(){let l=o.prototype;if(!l.hasOwnProperty(JSCompiler_renameProperty("__hasRegisterFinished",l))){l.__hasRegisterFinished=!0,super._registered(),pp&&a(l);let c=Object.getPrototypeOf(this),u=i.beforeRegister;if(u)for(let h=0;h<u.length;h++)u[h].call(c);if(u=i.registered,u)for(let h=0;h<u.length;h++)u[h].call(c)}}_applyListeners(){super._applyListeners();let l=i.listeners;if(l)for(let c=0;c<l.length;c++){let u=l[c];if(u)for(let h in u)this._addMethodEventListenerToNode(this,h,u[h])}}_ensureAttributes(){let l=i.hostAttributes;if(l)for(let c=l.length-1;c>=0;c--){let u=l[c];for(let h in u)this._ensureAttribute(h,u[h])}super._ensureAttributes()}ready(){super.ready();let l=i.ready;if(l)for(let c=0;c<l.length;c++)l[c].call(this)}attached(){super.attached();let l=i.attached;if(l)for(let c=0;c<l.length;c++)l[c].call(this)}detached(){super.detached();let l=i.detached;if(l)for(let c=0;c<l.length;c++)l[c].call(this)}attributeChanged(l,c,u){super.attributeChanged();let h=i.attributeChanged;if(h)for(let f=0;f<h.length;f++)h[f].call(this,l,c,u)}}if(r){Array.isArray(r)||(r=[r]);let s=t.prototype.behaviors;n=Vgt(r,null,s),o.prototype.behaviors=s?s.concat(r):n}let a=s=>{n&&tbe(s,n,i),Hgt(s,e,i,Fgt)};return pp||a(o.prototype),o.generatedFrom=e,o}var h9=function(e,t){e||console.warn("Polymer.Class requires `info` argument");let r=t?t(zgt):zgt;return r=Ugt(e,r,e.behaviors),r.is=r.prototype.is=e.is,r};var Yt=function(e){let t;return typeof e=="function"?t=e:t=Yt.Class(e),e._legacyForceObservedAttributes&&(t.prototype._legacyForceObservedAttributes=e._legacyForceObservedAttributes),customElements.define(t.is,t),t};Yt.Class=h9;function eW(e,t,r,n,i){let o;i&&(o=typeof r=="object"&&r!==null,o&&(n=e.__dataTemp[t]));let a=n!==r&&(n===n||r===r);return o&&a&&(e.__dataTemp[t]=r),a}var Gx=Rn(e=>{class t extends e{_shouldPropertyChange(n,i,o){return eW(this,n,i,o,!0)}}return t}),f9=Rn(e=>{class t extends e{static get properties(){return{mutableData:Boolean}}_shouldPropertyChange(n,i,o){return eW(this,n,i,o,this.mutableData)}}return t});Gx._mutablePropertyChange=eW;var rW=null;function nW(){return rW}nW.prototype=Object.create(HTMLTemplateElement.prototype,{constructor:{value:nW,writable:!0}});var Ggt=u_(nW),ebe=Gx(Ggt);function rbe(e,t){rW=e,Object.setPrototypeOf(e,t.prototype),new t,rW=null}var nbe=u_(class{});function iW(e,t){for(let r=0;r<t.length;r++){let n=t[r];if(Boolean(e)!=Boolean(n.__hideTemplateChildren__))if(n.nodeType===Node.TEXT_NODE)e?(n.__polymerTextContent__=n.textContent,n.textContent=""):n.textContent=n.__polymerTextContent__;else if(n.localName==="slot")if(e)n.__polymerReplaced__=document.createComment("hidden-slot"),ue(ue(n).parentNode).replaceChild(n.__polymerReplaced__,n);else{let i=n.__polymerReplaced__;i&&ue(ue(i).parentNode).replaceChild(n,i)}else n.style&&(e?(n.__polymerDisplay__=n.style.display,n.style.display="none"):n.style.display=n.__polymerDisplay__);n.__hideTemplateChildren__=e,n._showHideChildren&&n._showHideChildren(e)}}var bh=class extends nbe{constructor(t){super(),this._configureProperties(t),this.root=this._stampTemplate(this.__dataHost);let r=[];this.children=r;for(let i=this.root.firstChild;i;i=i.nextSibling)r.push(i),i.__templatizeInstance=this;this.__templatizeOwner&&this.__templatizeOwner.__hideTemplateChildren__&&this._showHideChildren(!0);let n=this.__templatizeOptions;(t&&n.instanceProps||!n.instanceProps)&&this._enableProperties()}_configureProperties(t){if(this.__templatizeOptions.forwardHostProp)for(let n in this.__hostProps)this._setPendingProperty(n,this.__dataHost["_host_"+n]);for(let n in t)this._setPendingProperty(n,t[n])}forwardHostProp(t,r){this._setPendingPropertyOrPath(t,r,!1,!0)&&this.__dataHost._enqueueClient(this)}_addEventListenerToNode(t,r,n){if(this._methodHost&&this.__templatizeOptions.parentModel)this._methodHost._addEventListenerToNode(t,r,i=>{i.model=this,n(i)});else{let i=this.__dataHost.__dataHost;i&&i._addEventListenerToNode(t,r,n)}}_showHideChildren(t){iW(t,this.children)}_setUnmanagedPropertyToNode(t,r,n){t.__hideTemplateChildren__&&t.nodeType==Node.TEXT_NODE&&r=="textContent"?t.__polymerTextContent__=n:super._setUnmanagedPropertyToNode(t,r,n)}get parentModel(){let t=this.__parentModel;if(!t){let r;t=this;do t=t.__dataHost.__dataHost;while((r=t.__templatizeOptions)&&!r.parentModel);this.__parentModel=t}return t}dispatchEvent(t){return!0}};bh.prototype.__dataHost;bh.prototype.__templatizeOptions;bh.prototype._methodHost;bh.prototype.__templatizeOwner;bh.prototype.__hostProps;var ibe=Gx(bh);function qgt(e){let t=e.__dataHost;return t&&t._methodHost||t}function obe(e,t,r){let n=r.mutableData?ibe:bh;tc.mixin&&(n=tc.mixin(n));let i=class extends n{};return i.prototype.__templatizeOptions=r,i.prototype._bindTemplate(e),lbe(i,e,t,r),i}function abe(e,t,r,n){let i=r.forwardHostProp;if(i&&t.hasHostProps){let o=e.localName=="template",a=t.templatizeTemplateClass;if(!a){if(o){let l=r.mutableData?ebe:Ggt;class c extends l{}a=t.templatizeTemplateClass=c}else{let l=e.constructor;class c extends l{}a=t.templatizeTemplateClass=c}let s=t.hostProps;for(let l in s)a.prototype._addPropertyEffect("_host_"+l,a.prototype.PROPERTY_EFFECT_TYPES.PROPAGATE,{fn:sbe(l,i)}),a.prototype._createNotifyingProperty("_host_"+l);LI&&n&&hbe(t,r,n)}if(e.__dataProto&&Object.assign(e.__data,e.__dataProto),o)rbe(e,a),e.__dataTemp={},e.__dataPending=null,e.__dataOld=null,e._enableProperties();else{Object.setPrototypeOf(e,a.prototype);let s=t.hostProps;for(let l in s)if(l="_host_"+l,l in e){let c=e[l];delete e[l],e.__data[l]=c}}}}function sbe(e,t){return function(n,i,o){t.call(n.__templatizeOwner,i.substring(6),o[i])}}function lbe(e,t,r,n){let i=r.hostProps||{};for(let o in n.instanceProps){delete i[o];let a=n.notifyInstanceProp;a&&e.prototype._addPropertyEffect(o,e.prototype.PROPERTY_EFFECT_TYPES.NOTIFY,{fn:cbe(o,a)})}if(n.forwardHostProp&&t.__dataHost)for(let o in i)r.hasHostProps||(r.hasHostProps=!0),e.prototype._addPropertyEffect(o,e.prototype.PROPERTY_EFFECT_TYPES.NOTIFY,{fn:ube()})}function cbe(e,t){return function(n,i,o){t.call(n.__templatizeOwner,n,i,o[i])}}function ube(){return function(t,r,n){t.__dataHost._setPendingPropertyOrPath("_host_"+r,n[r],!0,!0)}}function tc(e,t,r){if(iu&&!qgt(e))throw new Error("strictTemplatePolicy: template owner not trusted");if(r=r||{},e.__templatizeOwner)throw new Error("A <template> can only be templatized once");e.__templatizeOwner=t;let i=(t?t.constructor:bh)._parseTemplate(e),o=i.templatizeInstanceClass;o||(o=obe(e,i,r),i.templatizeInstanceClass=o);let a=qgt(e);abe(e,i,r,a);let s=class extends o{};return s.prototype._methodHost=a,s.prototype.__dataHost=e,s.prototype.__templatizeOwner=t,s.prototype.__hostProps=i.hostProps,s=s,s}function hbe(e,t,r){let n=r.constructor._properties,{propertyEffects:i}=e,{instanceProps:o}=t;for(let a in i)if(!n[a]&&!(o&&o[a])){let s=i[a];for(let l=0;l<s.length;l++){let{part:c}=s[l].info;if(!(c.signature&&c.signature.static)){console.warn(`Property '${a}' used in template but not declared in 'properties'; attribute will not be observed.`);break}}}}function p9(e,t){let r;for(;t;)if(r=t.__dataHost?t:t.__templatizeInstance)if(r.__dataHost!=e)t=r.__dataHost;else return r;else t=ue(t).parentNode;return null}var Wgt={templatize(e,t){this._templatizerTemplate=e,this.ctor=tc(e,this,{mutableData:Boolean(t),parentModel:this._parentModel,instanceProps:this._instanceProps,forwardHostProp:this._forwardHostPropV2,notifyInstanceProp:this._notifyInstancePropV2})},stamp(e){return new this.ctor(e)},modelForElement(e){return p9(this._templatizerTemplate,e)}};var Ygt=!1;function Wx(){if(pp&&!c_){if(!Ygt){Ygt=!0;let e=document.createElement("style");e.textContent="dom-bind,dom-if,dom-repeat{display:none;}",document.head.appendChild(e)}return!0}return!1}var fbe=yh(f9(u_(HTMLElement))),oW=class extends fbe{static get observedAttributes(){return["mutable-data"]}constructor(){if(super(),iu)throw new Error("strictTemplatePolicy: dom-bind not allowed");this.root=null,this.$=null,this.__children=null}attributeChangedCallback(t,r,n,i){this.mutableData=!0}connectedCallback(){Wx()||(this.style.display="none"),this.render()}disconnectedCallback(){this.__removeChildren()}__insertChildren(){ue(ue(this).parentNode).insertBefore(this.root,this)}__removeChildren(){if(this.__children)for(let t=0;t<this.__children.length;t++)this.root.appendChild(this.__children[t])}render(){let t;if(!this.__children){if(t=t||this.querySelector("template"),!t){let r=new MutationObserver(()=>{if(t=this.querySelector("template"),t)r.disconnect(),this.render();else throw new Error("dom-bind requires a <template> child")});r.observe(this,{childList:!0});return}this.root=this._stampTemplate(t),this.$=this.root.$,this.__children=[];for(let r=this.root.firstChild;r;r=r.nextSibling)this.__children[this.__children.length]=r;this._enableProperties()}this.__insertChildren(),this.dispatchEvent(new CustomEvent("dom-change",{bubbles:!0,composed:!0}))}};customElements.define("dom-bind",oW);var pbe=f9(mt),d9=class extends pbe{static get is(){return"dom-repeat"}static get template(){return null}static get properties(){return{items:{type:Array},as:{type:String,value:"item"},indexAs:{type:String,value:"index"},itemsIndexAs:{type:String,value:"itemsIndex"},sort:{type:Function,observer:"__sortChanged"},filter:{type:Function,observer:"__filterChanged"},observe:{type:String,observer:"__observeChanged"},delay:Number,renderedItemCount:{type:Number,notify:!UM,readOnly:!0},initialCount:{type:Number},targetFramerate:{type:Number,value:20},_targetFrameTime:{type:Number,computed:"__computeFrameTime(targetFramerate)"},notifyDomChange:{type:Boolean},reuseChunkedInstances:{type:Boolean}}}static get observers(){return["__itemsChanged(items.*)"]}constructor(){super(),this.__instances=[],this.__renderDebouncer=null,this.__itemsIdxToInstIdx={},this.__chunkCount=null,this.__renderStartTime=null,this.__itemsArrayChanged=!1,this.__shouldMeasureChunk=!1,this.__shouldContinueChunking=!1,this.__chunkingId=0,this.__sortFn=null,this.__filterFn=null,this.__observePaths=null,this.__ctor=null,this.__isDetached=!0,this.template=null,this._templateInfo}disconnectedCallback(){super.disconnectedCallback(),this.__isDetached=!0;for(let t=0;t<this.__instances.length;t++)this.__detachInstance(t)}connectedCallback(){if(super.connectedCallback(),Wx()||(this.style.display="none"),this.__isDetached){this.__isDetached=!1;let t=ue(ue(this).parentNode);for(let r=0;r<this.__instances.length;r++)this.__attachInstance(r,t)}}__ensureTemplatized(){if(!this.__ctor){let t=this,r=this.template=t._templateInfo?t:this.querySelector("template");if(!r){let i=new MutationObserver(()=>{if(this.querySelector("template"))i.disconnect(),this.__render();else throw new Error("dom-repeat requires a <template> child")});return i.observe(this,{childList:!0}),!1}let n={};n[this.as]=!0,n[this.indexAs]=!0,n[this.itemsIndexAs]=!0,this.__ctor=tc(r,this,{mutableData:this.mutableData,parentModel:!0,instanceProps:n,forwardHostProp:function(i,o){let a=this.__instances;for(let s=0,l;s<a.length&&(l=a[s]);s++)l.forwardHostProp(i,o)},notifyInstanceProp:function(i,o,a){if(OI(this.as,o)){let s=i[this.itemsIndexAs];o==this.as&&(this.items[s]=a);let l=dp(this.as,`${JSCompiler_renameProperty("items",this)}.${s}`,o);this.notifyPath(l,a)}}})}return!0}__getMethodHost(){return this.__dataHost._methodHost||this.__dataHost}__functionFromPropertyValue(t){if(typeof t=="string"){let r=t,n=this.__getMethodHost();return function(){return n[r].apply(n,arguments)}}return t}__sortChanged(t){this.__sortFn=this.__functionFromPropertyValue(t),this.items&&this.__debounceRender(this.__render)}__filterChanged(t){this.__filterFn=this.__functionFromPropertyValue(t),this.items&&this.__debounceRender(this.__render)}__computeFrameTime(t){return Math.ceil(1e3/t)}__observeChanged(){this.__observePaths=this.observe&&this.observe.replace(".*",".").split(" ")}__handleObservedPaths(t){if(this.__sortFn||this.__filterFn){if(!t)this.__debounceRender(this.__render,this.delay);else if(this.__observePaths){let r=this.__observePaths;for(let n=0;n<r.length;n++)t.indexOf(r[n])===0&&this.__debounceRender(this.__render,this.delay)}}}__itemsChanged(t){this.items&&!Array.isArray(this.items)&&console.warn("dom-repeat expected array for `items`, found",this.items),this.__handleItemPath(t.path,t.value)||(t.path==="items"&&(this.__itemsArrayChanged=!0),this.__debounceRender(this.__render))}__debounceRender(t,r=0){this.__renderDebouncer=sr.debounce(this.__renderDebouncer,r>0?mo.after(r):li,t.bind(this)),Jl(this.__renderDebouncer)}render(){this.__debounceRender(this.__render),ci()}__render(){if(!this.__ensureTemplatized())return;let t=this.items||[],r=this.__sortAndFilterItems(t),n=this.__calculateLimit(r.length);this.__updateInstances(t,n,r),this.initialCount&&(this.__shouldMeasureChunk||this.__shouldContinueChunking)&&(cancelAnimationFrame(this.__chunkingId),this.__chunkingId=requestAnimationFrame(()=>this.__continueChunking())),this._setRenderedItemCount(this.__instances.length),(!UM||this.notifyDomChange)&&this.dispatchEvent(new CustomEvent("dom-change",{bubbles:!0,composed:!0}))}__sortAndFilterItems(t){let r=new Array(t.length);for(let n=0;n<t.length;n++)r[n]=n;return this.__filterFn&&(r=r.filter((n,i,o)=>this.__filterFn(t[n],i,o))),this.__sortFn&&r.sort((n,i)=>this.__sortFn(t[n],t[i])),r}__calculateLimit(t){let r=t,n=this.__instances.length;if(this.initialCount){let i;!this.__chunkCount||this.__itemsArrayChanged&&!this.reuseChunkedInstances?(r=Math.min(t,this.initialCount),i=Math.max(r-n,0),this.__chunkCount=i||1):(i=Math.min(Math.max(t-n,0),this.__chunkCount),r=Math.min(n+i,t)),this.__shouldMeasureChunk=i===this.__chunkCount,this.__shouldContinueChunking=r<t,this.__renderStartTime=performance.now()}return this.__itemsArrayChanged=!1,r}__continueChunking(){if(this.__shouldMeasureChunk){let t=performance.now()-this.__renderStartTime,r=this._targetFrameTime/t;this.__chunkCount=Math.round(this.__chunkCount*r)||1}this.__shouldContinueChunking&&this.__debounceRender(this.__render)}__updateInstances(t,r,n){let i=this.__itemsIdxToInstIdx={},o;for(o=0;o<r;o++){let a=this.__instances[o],s=n[o],l=t[s];i[s]=o,a?(a._setPendingProperty(this.as,l),a._setPendingProperty(this.indexAs,o),a._setPendingProperty(this.itemsIndexAs,s),a._flushProperties()):this.__insertInstance(l,o,s)}for(let a=this.__instances.length-1;a>=o;a--)this.__detachAndRemoveInstance(a)}__detachInstance(t){let r=this.__instances[t],n=ue(r.root);for(let i=0;i<r.children.length;i++){let o=r.children[i];n.appendChild(o)}return r}__attachInstance(t,r){let n=this.__instances[t];r.insertBefore(n.root,this)}__detachAndRemoveInstance(t){this.__detachInstance(t),this.__instances.splice(t,1)}__stampInstance(t,r,n){let i={};return i[this.as]=t,i[this.indexAs]=r,i[this.itemsIndexAs]=n,new this.__ctor(i)}__insertInstance(t,r,n){let i=this.__stampInstance(t,r,n),o=this.__instances[r+1],a=o?o.children[0]:this;return ue(ue(this).parentNode).insertBefore(i.root,a),this.__instances[r]=i,i}_showHideChildren(t){for(let r=0;r<this.__instances.length;r++)this.__instances[r]._showHideChildren(t)}__handleItemPath(t,r){let n=t.slice(6),i=n.indexOf("."),o=i<0?n:n.substring(0,i);if(o==parseInt(o,10)){let a=i<0?"":n.substring(i+1);this.__handleObservedPaths(a);let s=this.__itemsIdxToInstIdx[o],l=this.__instances[s];if(l){let c=this.as+(a?"."+a:"");l._setPendingPropertyOrPath(c,r,!1,!0),l._flushProperties()}return!0}}itemForElement(t){let r=this.modelForElement(t);return r&&r[this.as]}indexForElement(t){let r=this.modelForElement(t);return r&&r[this.indexAs]}modelForElement(t){return p9(this.template,t)}};customElements.define(d9.is,d9);var m9=class extends mt{static get is(){return"dom-if"}static get template(){return null}static get properties(){return{if:{type:Boolean,observer:"__debounceRender"},restamp:{type:Boolean,observer:"__debounceRender"},notifyDomChange:{type:Boolean}}}constructor(){super(),this.__renderDebouncer=null,this._lastIf=!1,this.__hideTemplateChildren__=!1,this.__template,this._templateInfo}__debounceRender(){this.__renderDebouncer=sr.debounce(this.__renderDebouncer,li,()=>this.__render()),Jl(this.__renderDebouncer)}disconnectedCallback(){super.disconnectedCallback();let t=ue(this).parentNode;(!t||t.nodeType==Node.DOCUMENT_FRAGMENT_NODE&&!ue(t).host)&&this.__teardownInstance()}connectedCallback(){super.connectedCallback(),Wx()||(this.style.display="none"),this.if&&this.__debounceRender()}__ensureTemplate(){if(!this.__template){let t=this,r=t._templateInfo?t:ue(t).querySelector("template");if(!r){let n=new MutationObserver(()=>{if(ue(this).querySelector("template"))n.disconnect(),this.__render();else throw new Error("dom-if requires a <template> child")});return n.observe(this,{childList:!0}),!1}this.__template=r}return!0}__ensureInstance(){let t=ue(this).parentNode;if(this.__hasInstance()){let r=this.__getInstanceNodes();if(r&&r.length&&ue(this).previousSibling!==r[r.length-1])for(let i=0,o;i<r.length&&(o=r[i]);i++)ue(t).insertBefore(o,this)}else{if(!t||!this.__ensureTemplate())return!1;this.__createAndInsertInstance(t)}return!0}render(){ci()}__render(){if(this.if){if(!this.__ensureInstance())return}else this.restamp&&this.__teardownInstance();this._showHideChildren(),(!UM||this.notifyDomChange)&&this.if!=this._lastIf&&(this.dispatchEvent(new CustomEvent("dom-change",{bubbles:!0,composed:!0})),this._lastIf=this.if)}__hasInstance(){}__getInstanceNodes(){}__createAndInsertInstance(t){}__teardownInstance(){}_showHideChildren(){}},aW=class extends m9{constructor(){super(),this.__instance=null,this.__syncInfo=null}__hasInstance(){return Boolean(this.__instance)}__getInstanceNodes(){return this.__instance.templateInfo.childNodes}__createAndInsertInstance(t){let r=this.__dataHost||this;if(iu&&!this.__dataHost)throw new Error("strictTemplatePolicy: template owner not trusted");let n=r._bindTemplate(this.__template,!0);n.runEffects=(i,o,a)=>{let s=this.__syncInfo;if(this.if)s&&(this.__syncInfo=null,this._showHideChildren(),o=Object.assign(s.changedProps,o)),i(o,a);else if(this.__instance)if(s||(s=this.__syncInfo={runEffects:i,changedProps:{}}),a)for(let l in o){let c=au(l);s.changedProps[c]=this.__dataHost[c]}else Object.assign(s.changedProps,o)},this.__instance=r._stampTemplate(this.__template,n),ue(t).insertBefore(this.__instance,this)}__syncHostProperties(){let t=this.__syncInfo;t&&(this.__syncInfo=null,t.runEffects(t.changedProps,!1))}__teardownInstance(){let t=this.__dataHost||this;this.__instance&&(t._removeBoundDom(this.__instance),this.__instance=null,this.__syncInfo=null)}_showHideChildren(){let t=this.__hideTemplateChildren__||!this.if;this.__instance&&Boolean(this.__instance.__hidden)!==t&&(this.__instance.__hidden=t,iW(t,this.__instance.templateInfo.childNodes)),t||this.__syncHostProperties()}},sW=class extends m9{constructor(){super(),this.__ctor=null,this.__instance=null,this.__invalidProps=null}__hasInstance(){return Boolean(this.__instance)}__getInstanceNodes(){return this.__instance.children}__createAndInsertInstance(t){this.__ctor||(this.__ctor=tc(this.__template,this,{mutableData:!0,forwardHostProp:function(r,n){this.__instance&&(this.if?this.__instance.forwardHostProp(r,n):(this.__invalidProps=this.__invalidProps||Object.create(null),this.__invalidProps[au(r)]=!0))}})),this.__instance=new this.__ctor,ue(t).insertBefore(this.__instance.root,this)}__teardownInstance(){if(this.__instance){let t=this.__instance.children;if(t&&t.length){let r=ue(t[0]).parentNode;if(r){r=ue(r);for(let n=0,i;n<t.length&&(i=t[n]);n++)r.removeChild(i)}}this.__invalidProps=null,this.__instance=null}}__syncHostProperties(){let t=this.__invalidProps;if(t){this.__invalidProps=null;for(let r in t)this.__instance._setPendingProperty(r,this.__dataHost[r]);this.__instance._flushProperties()}}_showHideChildren(){let t=this.__hideTemplateChildren__||!this.if;this.__instance&&Boolean(this.__instance.__hidden)!==t&&(this.__instance.__hidden=t,this.__instance._showHideChildren(t)),t||this.__syncHostProperties()}},jgt=RI?aW:sW;customElements.define(jgt.is,jgt);var dbe=Rn(e=>{let t=Sm(e);class r extends t{static get properties(){return{items:{type:Array},multi:{type:Boolean,value:!1},selected:{type:Object,notify:!0},selectedItem:{type:Object,notify:!0},toggle:{type:Boolean,value:!1}}}static get observers(){return["__updateSelection(multi, items.*)"]}constructor(){super(),this.__lastItems=null,this.__lastMulti=null,this.__selectedMap=null}__updateSelection(i,o){let a=o.path;if(a==JSCompiler_renameProperty("items",this)){let s=o.base||[],l=this.__lastItems,c=this.__lastMulti;if(i!==c&&this.clearSelection(),l){let u=o9(s,l);this.__applySplices(u)}this.__lastItems=s,this.__lastMulti=i}else if(o.path==`${JSCompiler_renameProperty("items",this)}.splices`)this.__applySplices(o.value.indexSplices);else{let s=a.slice(`${JSCompiler_renameProperty("items",this)}.`.length),l=parseInt(s,10);s.indexOf(".")<0&&s==l&&this.__deselectChangedIdx(l)}}__applySplices(i){let o=this.__selectedMap;for(let s=0;s<i.length;s++){let l=i[s];o.forEach((c,u)=>{c<l.index||(c>=l.index+l.removed.length?o.set(u,c+l.addedCount-l.removed.length):o.set(u,-1))});for(let c=0;c<l.addedCount;c++){let u=l.index+c;o.has(this.items[u])&&o.set(this.items[u],u)}}this.__updateLinks();let a=0;o.forEach((s,l)=>{s<0?(this.multi?this.splice(JSCompiler_renameProperty("selected",this),a,1):this.selected=this.selectedItem=null,o.delete(l)):a++})}__updateLinks(){if(this.__dataLinkedPaths={},this.multi){let i=0;this.__selectedMap.forEach(o=>{o>=0&&this.linkPaths(`${JSCompiler_renameProperty("items",this)}.${o}`,`${JSCompiler_renameProperty("selected",this)}.${i++}`)})}else this.__selectedMap.forEach(i=>{this.linkPaths(JSCompiler_renameProperty("selected",this),`${JSCompiler_renameProperty("items",this)}.${i}`),this.linkPaths(JSCompiler_renameProperty("selectedItem",this),`${JSCompiler_renameProperty("items",this)}.${i}`)})}clearSelection(){this.__dataLinkedPaths={},this.__selectedMap=new Map,this.selected=this.multi?[]:null,this.selectedItem=null}isSelected(i){return this.__selectedMap.has(i)}isIndexSelected(i){return this.isSelected(this.items[i])}__deselectChangedIdx(i){let o=this.__selectedIndexForItemIndex(i);if(o>=0){let a=0;this.__selectedMap.forEach((s,l)=>{o==a++&&this.deselect(l)})}}__selectedIndexForItemIndex(i){let o=this.__dataLinkedPaths[`${JSCompiler_renameProperty("items",this)}.${i}`];if(o)return parseInt(o.slice(`${JSCompiler_renameProperty("selected",this)}.`.length),10)}deselect(i){let o=this.__selectedMap.get(i);if(o>=0){this.__selectedMap.delete(i);let a;this.multi&&(a=this.__selectedIndexForItemIndex(o)),this.__updateLinks(),this.multi?this.splice(JSCompiler_renameProperty("selected",this),a,1):this.selected=this.selectedItem=null}}deselectIndex(i){this.deselect(this.items[i])}select(i){this.selectIndex(this.items.indexOf(i))}selectIndex(i){let o=this.items[i];this.isSelected(o)?this.toggle&&this.deselectIndex(i):(this.multi||this.__selectedMap.clear(),this.__selectedMap.set(o,i),this.__updateLinks(),this.multi?this.push(JSCompiler_renameProperty("selected",this),o):this.selected=this.selectedItem=o)}}return r});var mbe=dbe(mt),g9=class extends mbe{static get is(){return"array-selector"}static get template(){return null}};customElements.define(g9.is,g9);var _9=new Zl;window.ShadyCSS||(window.ShadyCSS={prepareTemplate(e,t,r){},prepareTemplateDom(e,t){},prepareTemplateStyles(e,t,r){},styleSubtree(e,t){_9.processStyles(),JM(e,t)},styleElement(e){_9.processStyles()},styleDocument(e){_9.processStyles(),JM(document.body,e)},getComputedStyleValue(e,t){return jI(e,t)},flushCustomStyles(){},nativeCss:Nx,nativeShadow:h_,cssBuild:Mm,disableRuntime:WI});window.ShadyCSS.CustomStyleInterface=_9;var Xgt="include",gbe=window.ShadyCSS.CustomStyleInterface,lW=class extends HTMLElement{constructor(){super(),this._style=null,gbe.addCustomStyle(this)}getStyle(){if(this._style)return this._style;let t=this.querySelector("style");if(!t)return null;this._style=t;let r=t.getAttribute(Xgt);return r&&(t.removeAttribute(Xgt),t.textContent=imt(r)+t.textContent),this.ownerDocument!==window.document&&window.document.head.appendChild(this),this._style}};window.customElements.define("custom-style",lW);var $gt;$gt=Gx._mutablePropertyChange;var Kgt={properties:{mutableData:Boolean},_shouldPropertyChange(e,t,r){return $gt(this,e,t,r,this.mutableData)}};var Da=Gt(HTMLElement).prototype;var y9=new Set,Js={properties:{_parentResizable:{type:Object,observer:"_parentResizableChanged"},_notifyingDescendant:{type:Boolean,value:!1}},listeners:{"iron-request-resize-notifications":"_onIronRequestResizeNotifications"},created:function(){this._interestedResizables=[],this._boundNotifyResize=this.notifyResize.bind(this),this._boundOnDescendantIronResize=this._onDescendantIronResize.bind(this)},attached:function(){this._requestResizeNotifications()},detached:function(){this._parentResizable?this._parentResizable.stopResizeNotificationsFor(this):(y9.delete(this),window.removeEventListener("resize",this._boundNotifyResize)),this._parentResizable=null},notifyResize:function(){!this.isAttached||(this._interestedResizables.forEach(function(e){this.resizerShouldNotify(e)&&this._notifyDescendant(e)},this),this._fireResize())},assignParentResizable:function(e){this._parentResizable&&this._parentResizable.stopResizeNotificationsFor(this),this._parentResizable=e,e&&e._interestedResizables.indexOf(this)===-1&&(e._interestedResizables.push(this),e._subscribeIronResize(this))},stopResizeNotificationsFor:function(e){var t=this._interestedResizables.indexOf(e);t>-1&&(this._interestedResizables.splice(t,1),this._unsubscribeIronResize(e))},_subscribeIronResize:function(e){e.addEventListener("iron-resize",this._boundOnDescendantIronResize)},_unsubscribeIronResize:function(e){e.removeEventListener("iron-resize",this._boundOnDescendantIronResize)},resizerShouldNotify:function(e){return!0},_onDescendantIronResize:function(e){if(this._notifyingDescendant){e.stopPropagation();return}c_||this._fireResize()},_fireResize:function(){this.fire("iron-resize",null,{node:this,bubbles:!1})},_onIronRequestResizeNotifications:function(e){var t=zt(e).rootTarget;t!==this&&(t.assignParentResizable(this),this._notifyDescendant(t),e.stopPropagation())},_parentResizableChanged:function(e){e&&window.removeEventListener("resize",this._boundNotifyResize)},_notifyDescendant:function(e){!this.isAttached||(this._notifyingDescendant=!0,e.notifyResize(),this._notifyingDescendant=!1)},_requestResizeNotifications:function(){if(!!this.isAttached)if(document.readyState==="loading"){var e=this._requestResizeNotifications.bind(this);document.addEventListener("readystatechange",function t(){document.removeEventListener("readystatechange",t),e()})}else this._findParent(),this._parentResizable?this._parentResizable._interestedResizables.forEach(function(t){t!==this&&t._findParent()},this):(y9.forEach(function(t){t!==this&&t._findParent()},this),window.addEventListener("resize",this._boundNotifyResize),this.notifyResize())},_findParent:function(){this.assignParentResizable(null),this.fire("iron-request-resize-notifications",null,{node:this,bubbles:!0,cancelable:!0}),this._parentResizable?y9.delete(this):y9.add(this)}};Yt({_template:Q`
    <style>
      :host {
        display: block;
        transition-duration: var(--iron-collapse-transition-duration, 300ms);
        /* Safari 10 needs this property prefixed to correctly apply the custom property */
        -webkit-transition-duration: var(--iron-collapse-transition-duration, 300ms);
        overflow: visible;
      }

      :host(.iron-collapse-closed) {
        display: none;
      }

      :host(:not(.iron-collapse-opened)) {
        overflow: hidden;
      }
    </style>

    <slot></slot>
`,is:"iron-collapse",behaviors:[Js],properties:{horizontal:{type:Boolean,value:!1,observer:"_horizontalChanged"},opened:{type:Boolean,value:!1,notify:!0,observer:"_openedChanged"},transitioning:{type:Boolean,notify:!0,readOnly:!0},noAnimation:{type:Boolean},_desiredSize:{type:String,value:""}},get dimension(){return this.horizontal?"width":"height"},get _dimensionMax(){return this.horizontal?"maxWidth":"maxHeight"},get _dimensionMaxCss(){return this.horizontal?"max-width":"max-height"},hostAttributes:{role:"group","aria-hidden":"true"},listeners:{transitionend:"_onTransitionEnd"},toggle:function(){this.opened=!this.opened},show:function(){this.opened=!0},hide:function(){this.opened=!1},updateSize:function(e,t){e=e==="auto"?"":e;var r=t&&!this.noAnimation&&this.isAttached&&this._desiredSize!==e;if(this._desiredSize=e,this._updateTransition(!1),r){var n=this._calcSize();e===""&&(this.style[this._dimensionMax]="",e=this._calcSize()),this.style[this._dimensionMax]=n,this.scrollTop=this.scrollTop,this._updateTransition(!0),r=e!==n}this.style[this._dimensionMax]=e,r||this._transitionEnd()},enableTransition:function(e){Da._warn("`enableTransition()` is deprecated, use `noAnimation` instead."),this.noAnimation=!e},_updateTransition:function(e){this.style.transitionDuration=e&&!this.noAnimation?"":"0s"},_horizontalChanged:function(){this.style.transitionProperty=this._dimensionMaxCss;var e=this._dimensionMax==="maxWidth"?"maxHeight":"maxWidth";this.style[e]="",this.updateSize(this.opened?"auto":"0px",!1)},_openedChanged:function(){this.setAttribute("aria-hidden",!this.opened),this._setTransitioning(!0),this.toggleClass("iron-collapse-closed",!1),this.toggleClass("iron-collapse-opened",!1),this.updateSize(this.opened?"auto":"0px",!0),this.opened&&this.focus()},_transitionEnd:function(){this.style[this._dimensionMax]=this._desiredSize,this.toggleClass("iron-collapse-closed",!this.opened),this.toggleClass("iron-collapse-opened",this.opened),this._updateTransition(!1),this.notifyResize(),this._setTransitioning(!1)},_onTransitionEnd:function(e){zt(e).rootTarget===this&&this._transitionEnd()},_calcSize:function(){return this.getBoundingClientRect()[this.dimension]+"px"}});var Zgt=Q`
/* Most common used flex styles*/
<dom-module id="iron-flex">
  <template>
    <style>
      .layout.horizontal,
      .layout.vertical {
        display: -ms-flexbox;
        display: -webkit-flex;
        display: flex;
      }

      .layout.inline {
        display: -ms-inline-flexbox;
        display: -webkit-inline-flex;
        display: inline-flex;
      }

      .layout.horizontal {
        -ms-flex-direction: row;
        -webkit-flex-direction: row;
        flex-direction: row;
      }

      .layout.vertical {
        -ms-flex-direction: column;
        -webkit-flex-direction: column;
        flex-direction: column;
      }

      .layout.wrap {
        -ms-flex-wrap: wrap;
        -webkit-flex-wrap: wrap;
        flex-wrap: wrap;
      }

      .layout.no-wrap {
        -ms-flex-wrap: nowrap;
        -webkit-flex-wrap: nowrap;
        flex-wrap: nowrap;
      }

      .layout.center,
      .layout.center-center {
        -ms-flex-align: center;
        -webkit-align-items: center;
        align-items: center;
      }

      .layout.center-justified,
      .layout.center-center {
        -ms-flex-pack: center;
        -webkit-justify-content: center;
        justify-content: center;
      }

      .flex {
        -ms-flex: 1 1 0.000000001px;
        -webkit-flex: 1;
        flex: 1;
        -webkit-flex-basis: 0.000000001px;
        flex-basis: 0.000000001px;
      }

      .flex-auto {
        -ms-flex: 1 1 auto;
        -webkit-flex: 1 1 auto;
        flex: 1 1 auto;
      }

      .flex-none {
        -ms-flex: none;
        -webkit-flex: none;
        flex: none;
      }
    </style>
  </template>
</dom-module>
/* Basic flexbox reverse styles */
<dom-module id="iron-flex-reverse">
  <template>
    <style>
      .layout.horizontal-reverse,
      .layout.vertical-reverse {
        display: -ms-flexbox;
        display: -webkit-flex;
        display: flex;
      }

      .layout.horizontal-reverse {
        -ms-flex-direction: row-reverse;
        -webkit-flex-direction: row-reverse;
        flex-direction: row-reverse;
      }

      .layout.vertical-reverse {
        -ms-flex-direction: column-reverse;
        -webkit-flex-direction: column-reverse;
        flex-direction: column-reverse;
      }

      .layout.wrap-reverse {
        -ms-flex-wrap: wrap-reverse;
        -webkit-flex-wrap: wrap-reverse;
        flex-wrap: wrap-reverse;
      }
    </style>
  </template>
</dom-module>
/* Flexbox alignment */
<dom-module id="iron-flex-alignment">
  <template>
    <style>
      /**
       * Alignment in cross axis.
       */
      .layout.start {
        -ms-flex-align: start;
        -webkit-align-items: flex-start;
        align-items: flex-start;
      }

      .layout.center,
      .layout.center-center {
        -ms-flex-align: center;
        -webkit-align-items: center;
        align-items: center;
      }

      .layout.end {
        -ms-flex-align: end;
        -webkit-align-items: flex-end;
        align-items: flex-end;
      }

      .layout.baseline {
        -ms-flex-align: baseline;
        -webkit-align-items: baseline;
        align-items: baseline;
      }

      /**
       * Alignment in main axis.
       */
      .layout.start-justified {
        -ms-flex-pack: start;
        -webkit-justify-content: flex-start;
        justify-content: flex-start;
      }

      .layout.center-justified,
      .layout.center-center {
        -ms-flex-pack: center;
        -webkit-justify-content: center;
        justify-content: center;
      }

      .layout.end-justified {
        -ms-flex-pack: end;
        -webkit-justify-content: flex-end;
        justify-content: flex-end;
      }

      .layout.around-justified {
        -ms-flex-pack: distribute;
        -webkit-justify-content: space-around;
        justify-content: space-around;
      }

      .layout.justified {
        -ms-flex-pack: justify;
        -webkit-justify-content: space-between;
        justify-content: space-between;
      }

      /**
       * Self alignment.
       */
      .self-start {
        -ms-align-self: flex-start;
        -webkit-align-self: flex-start;
        align-self: flex-start;
      }

      .self-center {
        -ms-align-self: center;
        -webkit-align-self: center;
        align-self: center;
      }

      .self-end {
        -ms-align-self: flex-end;
        -webkit-align-self: flex-end;
        align-self: flex-end;
      }

      .self-stretch {
        -ms-align-self: stretch;
        -webkit-align-self: stretch;
        align-self: stretch;
      }

      .self-baseline {
        -ms-align-self: baseline;
        -webkit-align-self: baseline;
        align-self: baseline;
      }

      /**
       * multi-line alignment in main axis.
       */
      .layout.start-aligned {
        -ms-flex-line-pack: start;  /* IE10 */
        -ms-align-content: flex-start;
        -webkit-align-content: flex-start;
        align-content: flex-start;
      }

      .layout.end-aligned {
        -ms-flex-line-pack: end;  /* IE10 */
        -ms-align-content: flex-end;
        -webkit-align-content: flex-end;
        align-content: flex-end;
      }

      .layout.center-aligned {
        -ms-flex-line-pack: center;  /* IE10 */
        -ms-align-content: center;
        -webkit-align-content: center;
        align-content: center;
      }

      .layout.between-aligned {
        -ms-flex-line-pack: justify;  /* IE10 */
        -ms-align-content: space-between;
        -webkit-align-content: space-between;
        align-content: space-between;
      }

      .layout.around-aligned {
        -ms-flex-line-pack: distribute;  /* IE10 */
        -ms-align-content: space-around;
        -webkit-align-content: space-around;
        align-content: space-around;
      }
    </style>
  </template>
</dom-module>
/* Non-flexbox positioning helper styles */
<dom-module id="iron-flex-factors">
  <template>
    <style>
      .flex,
      .flex-1 {
        -ms-flex: 1 1 0.000000001px;
        -webkit-flex: 1;
        flex: 1;
        -webkit-flex-basis: 0.000000001px;
        flex-basis: 0.000000001px;
      }

      .flex-2 {
        -ms-flex: 2;
        -webkit-flex: 2;
        flex: 2;
      }

      .flex-3 {
        -ms-flex: 3;
        -webkit-flex: 3;
        flex: 3;
      }

      .flex-4 {
        -ms-flex: 4;
        -webkit-flex: 4;
        flex: 4;
      }

      .flex-5 {
        -ms-flex: 5;
        -webkit-flex: 5;
        flex: 5;
      }

      .flex-6 {
        -ms-flex: 6;
        -webkit-flex: 6;
        flex: 6;
      }

      .flex-7 {
        -ms-flex: 7;
        -webkit-flex: 7;
        flex: 7;
      }

      .flex-8 {
        -ms-flex: 8;
        -webkit-flex: 8;
        flex: 8;
      }

      .flex-9 {
        -ms-flex: 9;
        -webkit-flex: 9;
        flex: 9;
      }

      .flex-10 {
        -ms-flex: 10;
        -webkit-flex: 10;
        flex: 10;
      }

      .flex-11 {
        -ms-flex: 11;
        -webkit-flex: 11;
        flex: 11;
      }

      .flex-12 {
        -ms-flex: 12;
        -webkit-flex: 12;
        flex: 12;
      }
    </style>
  </template>
</dom-module>
<dom-module id="iron-positioning">
  <template>
    <style>
      .block {
        display: block;
      }

      [hidden] {
        display: none !important;
      }

      .invisible {
        visibility: hidden !important;
      }

      .relative {
        position: relative;
      }

      .fit {
        position: absolute;
        top: 0;
        right: 0;
        bottom: 0;
        left: 0;
      }

      body.fullbleed {
        margin: 0;
        height: 100vh;
      }

      .scroll {
        -webkit-overflow-scrolling: touch;
        overflow: auto;
      }

      /* fixed position */
      .fixed-bottom,
      .fixed-left,
      .fixed-right,
      .fixed-top {
        position: fixed;
      }

      .fixed-top {
        top: 0;
        left: 0;
        right: 0;
      }

      .fixed-right {
        top: 0;
        right: 0;
        bottom: 0;
      }

      .fixed-bottom {
        right: 0;
        bottom: 0;
        left: 0;
      }

      .fixed-left {
        top: 0;
        bottom: 0;
        left: 0;
      }
    </style>
  </template>
</dom-module>
`;Zgt.setAttribute("style","display: none;");document.head.appendChild(Zgt.content);var Jgt=Q`
<custom-style>
  <style is="custom-style">
    [hidden] {
      display: none !important;
    }
  </style>
</custom-style>
<custom-style>
  <style is="custom-style">
    html {

      --layout: {
        display: -ms-flexbox;
        display: -webkit-flex;
        display: flex;
      };

      --layout-inline: {
        display: -ms-inline-flexbox;
        display: -webkit-inline-flex;
        display: inline-flex;
      };

      --layout-horizontal: {
        @apply --layout;

        -ms-flex-direction: row;
        -webkit-flex-direction: row;
        flex-direction: row;
      };

      --layout-horizontal-reverse: {
        @apply --layout;

        -ms-flex-direction: row-reverse;
        -webkit-flex-direction: row-reverse;
        flex-direction: row-reverse;
      };

      --layout-vertical: {
        @apply --layout;

        -ms-flex-direction: column;
        -webkit-flex-direction: column;
        flex-direction: column;
      };

      --layout-vertical-reverse: {
        @apply --layout;

        -ms-flex-direction: column-reverse;
        -webkit-flex-direction: column-reverse;
        flex-direction: column-reverse;
      };

      --layout-wrap: {
        -ms-flex-wrap: wrap;
        -webkit-flex-wrap: wrap;
        flex-wrap: wrap;
      };

      --layout-wrap-reverse: {
        -ms-flex-wrap: wrap-reverse;
        -webkit-flex-wrap: wrap-reverse;
        flex-wrap: wrap-reverse;
      };

      --layout-flex-auto: {
        -ms-flex: 1 1 auto;
        -webkit-flex: 1 1 auto;
        flex: 1 1 auto;
      };

      --layout-flex-none: {
        -ms-flex: none;
        -webkit-flex: none;
        flex: none;
      };

      --layout-flex: {
        -ms-flex: 1 1 0.000000001px;
        -webkit-flex: 1;
        flex: 1;
        -webkit-flex-basis: 0.000000001px;
        flex-basis: 0.000000001px;
      };

      --layout-flex-2: {
        -ms-flex: 2;
        -webkit-flex: 2;
        flex: 2;
      };

      --layout-flex-3: {
        -ms-flex: 3;
        -webkit-flex: 3;
        flex: 3;
      };

      --layout-flex-4: {
        -ms-flex: 4;
        -webkit-flex: 4;
        flex: 4;
      };

      --layout-flex-5: {
        -ms-flex: 5;
        -webkit-flex: 5;
        flex: 5;
      };

      --layout-flex-6: {
        -ms-flex: 6;
        -webkit-flex: 6;
        flex: 6;
      };

      --layout-flex-7: {
        -ms-flex: 7;
        -webkit-flex: 7;
        flex: 7;
      };

      --layout-flex-8: {
        -ms-flex: 8;
        -webkit-flex: 8;
        flex: 8;
      };

      --layout-flex-9: {
        -ms-flex: 9;
        -webkit-flex: 9;
        flex: 9;
      };

      --layout-flex-10: {
        -ms-flex: 10;
        -webkit-flex: 10;
        flex: 10;
      };

      --layout-flex-11: {
        -ms-flex: 11;
        -webkit-flex: 11;
        flex: 11;
      };

      --layout-flex-12: {
        -ms-flex: 12;
        -webkit-flex: 12;
        flex: 12;
      };

      /* alignment in cross axis */

      --layout-start: {
        -ms-flex-align: start;
        -webkit-align-items: flex-start;
        align-items: flex-start;
      };

      --layout-center: {
        -ms-flex-align: center;
        -webkit-align-items: center;
        align-items: center;
      };

      --layout-end: {
        -ms-flex-align: end;
        -webkit-align-items: flex-end;
        align-items: flex-end;
      };

      --layout-baseline: {
        -ms-flex-align: baseline;
        -webkit-align-items: baseline;
        align-items: baseline;
      };

      /* alignment in main axis */

      --layout-start-justified: {
        -ms-flex-pack: start;
        -webkit-justify-content: flex-start;
        justify-content: flex-start;
      };

      --layout-center-justified: {
        -ms-flex-pack: center;
        -webkit-justify-content: center;
        justify-content: center;
      };

      --layout-end-justified: {
        -ms-flex-pack: end;
        -webkit-justify-content: flex-end;
        justify-content: flex-end;
      };

      --layout-around-justified: {
        -ms-flex-pack: distribute;
        -webkit-justify-content: space-around;
        justify-content: space-around;
      };

      --layout-justified: {
        -ms-flex-pack: justify;
        -webkit-justify-content: space-between;
        justify-content: space-between;
      };

      --layout-center-center: {
        @apply --layout-center;
        @apply --layout-center-justified;
      };

      /* self alignment */

      --layout-self-start: {
        -ms-align-self: flex-start;
        -webkit-align-self: flex-start;
        align-self: flex-start;
      };

      --layout-self-center: {
        -ms-align-self: center;
        -webkit-align-self: center;
        align-self: center;
      };

      --layout-self-end: {
        -ms-align-self: flex-end;
        -webkit-align-self: flex-end;
        align-self: flex-end;
      };

      --layout-self-stretch: {
        -ms-align-self: stretch;
        -webkit-align-self: stretch;
        align-self: stretch;
      };

      --layout-self-baseline: {
        -ms-align-self: baseline;
        -webkit-align-self: baseline;
        align-self: baseline;
      };

      /* multi-line alignment in main axis */

      --layout-start-aligned: {
        -ms-flex-line-pack: start;  /* IE10 */
        -ms-align-content: flex-start;
        -webkit-align-content: flex-start;
        align-content: flex-start;
      };

      --layout-end-aligned: {
        -ms-flex-line-pack: end;  /* IE10 */
        -ms-align-content: flex-end;
        -webkit-align-content: flex-end;
        align-content: flex-end;
      };

      --layout-center-aligned: {
        -ms-flex-line-pack: center;  /* IE10 */
        -ms-align-content: center;
        -webkit-align-content: center;
        align-content: center;
      };

      --layout-between-aligned: {
        -ms-flex-line-pack: justify;  /* IE10 */
        -ms-align-content: space-between;
        -webkit-align-content: space-between;
        align-content: space-between;
      };

      --layout-around-aligned: {
        -ms-flex-line-pack: distribute;  /* IE10 */
        -ms-align-content: space-around;
        -webkit-align-content: space-around;
        align-content: space-around;
      };

      /*******************************
                Other Layout
      *******************************/

      --layout-block: {
        display: block;
      };

      --layout-invisible: {
        visibility: hidden !important;
      };

      --layout-relative: {
        position: relative;
      };

      --layout-fit: {
        position: absolute;
        top: 0;
        right: 0;
        bottom: 0;
        left: 0;
      };

      --layout-scroll: {
        -webkit-overflow-scrolling: touch;
        overflow: auto;
      };

      --layout-fullbleed: {
        margin: 0;
        height: 100vh;
      };

      /* fixed position */

      --layout-fixed-top: {
        position: fixed;
        top: 0;
        left: 0;
        right: 0;
      };

      --layout-fixed-right: {
        position: fixed;
        top: 0;
        right: 0;
        bottom: 0;
      };

      --layout-fixed-bottom: {
        position: fixed;
        right: 0;
        bottom: 0;
        left: 0;
      };

      --layout-fixed-left: {
        position: fixed;
        top: 0;
        bottom: 0;
        left: 0;
      };

    }
  </style>
</custom-style>`;Jgt.setAttribute("style","display: none;");document.head.appendChild(Jgt.content);var Qgt=document.createElement("style");Qgt.textContent="[hidden] { display: none !important; }";document.head.appendChild(Qgt);var go=class{constructor(t){go[" "](t),this.type=t&&t.type||"default",this.key=t&&t.key,t&&"value"in t&&(this.value=t.value)}get value(){var t=this.type,r=this.key;if(t&&r)return go.types[t]&&go.types[t][r]}set value(t){var r=this.type,n=this.key;r&&n&&(r=go.types[r]=go.types[r]||{},t==null?delete r[n]:r[n]=t)}get list(){var t=this.type;if(t){var r=go.types[this.type];return r?Object.keys(r).map(function(n){return _be[this.type][n]},this):[]}}byKey(t){return this.key=t,this.value}};go[" "]=function(){};go.types={};var _be=go.types;Yt({is:"iron-meta",properties:{type:{type:String,value:"default"},key:{type:String},value:{type:String,notify:!0},self:{type:Boolean,observer:"_selfChanged"},__meta:{type:Boolean,computed:"__computeMeta(type, key, value)"}},hostAttributes:{hidden:!0},__computeMeta:function(e,t,r){var n=new go({type:e,key:t});return r!==void 0&&r!==n.value?n.value=r:this.value!==n.value&&(this.value=n.value),n},get list(){return this.__meta&&this.__meta.list},_selfChanged:function(e){e&&(this.value=this)},byKey:function(e){return new go({type:this.type,key:e}).value}});Yt({_template:Q`
    <style>
      :host {
        @apply --layout-inline;
        @apply --layout-center-center;
        position: relative;

        vertical-align: middle;

        fill: var(--iron-icon-fill-color, currentcolor);
        stroke: var(--iron-icon-stroke-color, none);

        width: var(--iron-icon-width, 24px);
        height: var(--iron-icon-height, 24px);
        @apply --iron-icon;
      }

      :host([hidden]) {
        display: none;
      }
    </style>
`,is:"iron-icon",properties:{icon:{type:String},theme:{type:String},src:{type:String},_meta:{value:Da.create("iron-meta",{type:"iconset"})}},observers:["_updateIcon(_meta, isAttached)","_updateIcon(theme, isAttached)","_srcChanged(src, isAttached)","_iconChanged(icon, isAttached)"],_DEFAULT_ICONSET:"icons",_iconChanged:function(e){var t=(e||"").split(":");this._iconName=t.pop(),this._iconsetName=t.pop()||this._DEFAULT_ICONSET,this._updateIcon()},_srcChanged:function(e){this._updateIcon()},_usesIconset:function(){return this.icon||!this.src},_updateIcon:function(){this._usesIconset()?(this._img&&this._img.parentNode&&zt(this.root).removeChild(this._img),this._iconName===""?this._iconset&&this._iconset.removeIcon(this):this._iconsetName&&this._meta&&(this._iconset=this._meta.byKey(this._iconsetName),this._iconset?(this._iconset.applyIcon(this,this._iconName,this.theme),this.unlisten(window,"iron-iconset-added","_updateIcon")):this.listen(window,"iron-iconset-added","_updateIcon"))):(this._iconset&&this._iconset.removeIcon(this),this._img||(this._img=document.createElement("img"),this._img.style.width="100%",this._img.style.height="100%",this._img.draggable=!1),this._img.src=this.src,zt(this.root).appendChild(this._img))}});Yt({is:"iron-iconset-svg",properties:{name:{type:String,observer:"_nameChanged"},size:{type:Number,value:24},rtlMirroring:{type:Boolean,value:!1},useGlobalRtlAttribute:{type:Boolean,value:!1}},created:function(){this._meta=new go({type:"iconset",key:null,value:null})},attached:function(){this.style.display="none"},getIconNames:function(){return this._icons=this._createIconMap(),Object.keys(this._icons).map(function(e){return this.name+":"+e},this)},applyIcon:function(e,t){this.removeIcon(e);var r=this._cloneIcon(t,this.rtlMirroring&&this._targetIsRTL(e));if(r){var n=zt(e.root||e);return n.insertBefore(r,n.childNodes[0]),e._svgIcon=r}return null},removeIcon:function(e){e._svgIcon&&(zt(e.root||e).removeChild(e._svgIcon),e._svgIcon=null)},_targetIsRTL:function(e){if(this.__targetIsRTL==null)if(this.useGlobalRtlAttribute){var t=document.body&&document.body.hasAttribute("dir")?document.body:document.documentElement;this.__targetIsRTL=t.getAttribute("dir")==="rtl"}else e&&e.nodeType!==Node.ELEMENT_NODE&&(e=e.host),this.__targetIsRTL=e&&window.getComputedStyle(e).direction==="rtl";return this.__targetIsRTL},_nameChanged:function(){this._meta.value=null,this._meta.key=this.name,this._meta.value=this,this.async(function(){this.fire("iron-iconset-added",this,{node:window})})},_createIconMap:function(){var e=Object.create(null);return zt(this).querySelectorAll("[id]").forEach(function(t){e[t.id]=t}),e},_cloneIcon:function(e,t){return this._icons=this._icons||this._createIconMap(),this._prepareSvgClone(this._icons[e],this.size,t)},_prepareSvgClone:function(e,t,r){if(e){var n=e.cloneNode(!0),i=document.createElementNS("http://www.w3.org/2000/svg","svg"),o=n.getAttribute("viewBox")||"0 0 "+t+" "+t,a="pointer-events: none; display: block; width: 100%; height: 100%;";return r&&n.hasAttribute("mirror-in-rtl")&&(a+="-webkit-transform:scale(-1,1);transform:scale(-1,1);transform-origin:center;"),i.setAttribute("viewBox",o),i.setAttribute("preserveAspectRatio","xMidYMid meet"),i.setAttribute("focusable","false"),i.style.cssText=a,i.appendChild(n).removeAttribute("id"),i}return null}});var ybe=Q`<iron-iconset-svg name="image" size="24">
<svg><defs>
<g id="add-a-photo"><path d="M3 4V1h2v3h3v2H5v3H3V6H0V4h3zm3 6V7h3V4h7l1.83 2H21c1.1 0 2 .9 2 2v12c0 1.1-.9 2-2 2H5c-1.1 0-2-.9-2-2V10h3zm7 9c2.76 0 5-2.24 5-5s-2.24-5-5-5-5 2.24-5 5 2.24 5 5 5zm-3.2-5c0 1.77 1.43 3.2 3.2 3.2s3.2-1.43 3.2-3.2-1.43-3.2-3.2-3.2-3.2 1.43-3.2 3.2z"></path></g>
<g id="add-to-photos"><path d="M4 6H2v14c0 1.1.9 2 2 2h14v-2H4V6zm16-4H8c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zm-1 9h-4v4h-2v-4H9V9h4V5h2v4h4v2z"></path></g>
<g id="adjust"><path d="M12 2C6.49 2 2 6.49 2 12s4.49 10 10 10 10-4.49 10-10S17.51 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8zm3-8c0 1.66-1.34 3-3 3s-3-1.34-3-3 1.34-3 3-3 3 1.34 3 3z"></path></g>
<g id="assistant"><path d="M19 2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h4l3 3 3-3h4c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zm-5.12 10.88L12 17l-1.88-4.12L6 11l4.12-1.88L12 5l1.88 4.12L18 11l-4.12 1.88z"></path></g>
<g id="assistant-photo"><path d="M14.4 6L14 4H5v17h2v-7h5.6l.4 2h7V6z"></path></g>
<g id="audiotrack"><path d="M12 3v9.28c-.47-.17-.97-.28-1.5-.28C8.01 12 6 14.01 6 16.5S8.01 21 10.5 21c2.31 0 4.2-1.75 4.45-4H15V6h4V3h-7z"></path></g>
<g id="blur-circular"><path d="M10 9c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm0 4c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zM7 9.5c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zm3 7c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zm-3-3c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zm3-6c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zM14 9c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm0-1.5c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zm3 6c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zm0-4c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zM12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8zm2-3.5c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zm0-3.5c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1z"></path></g>
<g id="blur-linear"><path d="M5 17.5c.83 0 1.5-.67 1.5-1.5s-.67-1.5-1.5-1.5-1.5.67-1.5 1.5.67 1.5 1.5 1.5zM9 13c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm0-4c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zM3 21h18v-2H3v2zM5 9.5c.83 0 1.5-.67 1.5-1.5S5.83 6.5 5 6.5 3.5 7.17 3.5 8 4.17 9.5 5 9.5zm0 4c.83 0 1.5-.67 1.5-1.5s-.67-1.5-1.5-1.5-1.5.67-1.5 1.5.67 1.5 1.5 1.5zM9 17c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm8-.5c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zM3 3v2h18V3H3zm14 5.5c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zm0 4c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zM13 9c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm0 4c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm0 4c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1z"></path></g>
<g id="blur-off"><path d="M14 7c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm-.2 4.48l.2.02c.83 0 1.5-.67 1.5-1.5s-.67-1.5-1.5-1.5-1.5.67-1.5 1.5l.02.2c.09.67.61 1.19 1.28 1.28zM14 3.5c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zm-4 0c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zm11 7c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zM10 7c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm8 8c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm0-4c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm0-4c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm-4 13.5c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zM2.5 5.27l3.78 3.78L6 9c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1c0-.1-.03-.19-.06-.28l2.81 2.81c-.71.11-1.25.73-1.25 1.47 0 .83.67 1.5 1.5 1.5.74 0 1.36-.54 1.47-1.25l2.81 2.81c-.09-.03-.18-.06-.28-.06-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1c0-.1-.03-.19-.06-.28l3.78 3.78L20 20.23 3.77 4 2.5 5.27zM10 17c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm11-3.5c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zM6 13c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zM3 9.5c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zm7 11c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zM6 17c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm-3-3.5c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5z"></path></g>
<g id="blur-on"><path d="M6 13c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm0 4c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm0-8c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm-3 .5c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zM6 5c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm15 5.5c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zM14 7c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm0-3.5c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zm-11 10c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zm7 7c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zm0-17c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zM10 7c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm0 5.5c-.83 0-1.5.67-1.5 1.5s.67 1.5 1.5 1.5 1.5-.67 1.5-1.5-.67-1.5-1.5-1.5zm8 .5c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm0 4c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm0-8c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm0-4c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm3 8.5c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zM14 17c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm0 3.5c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zm-4-12c-.83 0-1.5.67-1.5 1.5s.67 1.5 1.5 1.5 1.5-.67 1.5-1.5-.67-1.5-1.5-1.5zm0 8.5c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm4-4.5c-.83 0-1.5.67-1.5 1.5s.67 1.5 1.5 1.5 1.5-.67 1.5-1.5-.67-1.5-1.5-1.5zm0-4c-.83 0-1.5.67-1.5 1.5s.67 1.5 1.5 1.5 1.5-.67 1.5-1.5-.67-1.5-1.5-1.5z"></path></g>
<g id="brightness-1"><circle cx="12" cy="12" r="10"></circle></g>
<g id="brightness-2"><path d="M10 2c-1.82 0-3.53.5-5 1.35C7.99 5.08 10 8.3 10 12s-2.01 6.92-5 8.65C6.47 21.5 8.18 22 10 22c5.52 0 10-4.48 10-10S15.52 2 10 2z"></path></g>
<g id="brightness-3"><path d="M9 2c-1.05 0-2.05.16-3 .46 4.06 1.27 7 5.06 7 9.54 0 4.48-2.94 8.27-7 9.54.95.3 1.95.46 3 .46 5.52 0 10-4.48 10-10S14.52 2 9 2z"></path></g>
<g id="brightness-4"><path d="M20 8.69V4h-4.69L12 .69 8.69 4H4v4.69L.69 12 4 15.31V20h4.69L12 23.31 15.31 20H20v-4.69L23.31 12 20 8.69zM12 18c-.89 0-1.74-.2-2.5-.55C11.56 16.5 13 14.42 13 12s-1.44-4.5-3.5-5.45C10.26 6.2 11.11 6 12 6c3.31 0 6 2.69 6 6s-2.69 6-6 6z"></path></g>
<g id="brightness-5"><path d="M20 15.31L23.31 12 20 8.69V4h-4.69L12 .69 8.69 4H4v4.69L.69 12 4 15.31V20h4.69L12 23.31 15.31 20H20v-4.69zM12 18c-3.31 0-6-2.69-6-6s2.69-6 6-6 6 2.69 6 6-2.69 6-6 6z"></path></g>
<g id="brightness-6"><path d="M20 15.31L23.31 12 20 8.69V4h-4.69L12 .69 8.69 4H4v4.69L.69 12 4 15.31V20h4.69L12 23.31 15.31 20H20v-4.69zM12 18V6c3.31 0 6 2.69 6 6s-2.69 6-6 6z"></path></g>
<g id="brightness-7"><path d="M20 8.69V4h-4.69L12 .69 8.69 4H4v4.69L.69 12 4 15.31V20h4.69L12 23.31 15.31 20H20v-4.69L23.31 12 20 8.69zM12 18c-3.31 0-6-2.69-6-6s2.69-6 6-6 6 2.69 6 6-2.69 6-6 6zm0-10c-2.21 0-4 1.79-4 4s1.79 4 4 4 4-1.79 4-4-1.79-4-4-4z"></path></g>
<g id="broken-image"><path d="M21 5v6.59l-3-3.01-4 4.01-4-4-4 4-3-3.01V5c0-1.1.9-2 2-2h14c1.1 0 2 .9 2 2zm-3 6.42l3 3.01V19c0 1.1-.9 2-2 2H5c-1.1 0-2-.9-2-2v-6.58l3 2.99 4-4 4 4 4-3.99z"></path></g>
<g id="brush"><path d="M7 14c-1.66 0-3 1.34-3 3 0 1.31-1.16 2-2 2 .92 1.22 2.49 2 4 2 2.21 0 4-1.79 4-4 0-1.66-1.34-3-3-3zm13.71-9.37l-1.34-1.34c-.39-.39-1.02-.39-1.41 0L9 12.25 11.75 15l8.96-8.96c.39-.39.39-1.02 0-1.41z"></path></g>
<g id="burst-mode"><path d="M1 5h2v14H1zm4 0h2v14H5zm17 0H10c-.55 0-1 .45-1 1v12c0 .55.45 1 1 1h12c.55 0 1-.45 1-1V6c0-.55-.45-1-1-1zM11 17l2.5-3.15L15.29 16l2.5-3.22L21 17H11z"></path></g>
<g id="camera"><path d="M9.4 10.5l4.77-8.26C13.47 2.09 12.75 2 12 2c-2.4 0-4.6.85-6.32 2.25l3.66 6.35.06-.1zM21.54 9c-.92-2.92-3.15-5.26-6-6.34L11.88 9h9.66zm.26 1h-7.49l.29.5 4.76 8.25C21 16.97 22 14.61 22 12c0-.69-.07-1.35-.2-2zM8.54 12l-3.9-6.75C3.01 7.03 2 9.39 2 12c0 .69.07 1.35.2 2h7.49l-1.15-2zm-6.08 3c.92 2.92 3.15 5.26 6 6.34L12.12 15H2.46zm11.27 0l-3.9 6.76c.7.15 1.42.24 2.17.24 2.4 0 4.6-.85 6.32-2.25l-3.66-6.35-.93 1.6z"></path></g>
<g id="camera-alt"><circle cx="12" cy="12" r="3.2"></circle><path d="M9 2L7.17 4H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2h-3.17L15 2H9zm3 15c-2.76 0-5-2.24-5-5s2.24-5 5-5 5 2.24 5 5-2.24 5-5 5z"></path></g>
<g id="camera-front"><path d="M10 20H5v2h5v2l3-3-3-3v2zm4 0v2h5v-2h-5zM12 8c1.1 0 2-.9 2-2s-.9-2-2-2-1.99.9-1.99 2S10.9 8 12 8zm5-8H7C5.9 0 5 .9 5 2v14c0 1.1.9 2 2 2h10c1.1 0 2-.9 2-2V2c0-1.1-.9-2-2-2zM7 2h10v10.5c0-1.67-3.33-2.5-5-2.5s-5 .83-5 2.5V2z"></path></g>
<g id="camera-rear"><path d="M10 20H5v2h5v2l3-3-3-3v2zm4 0v2h5v-2h-5zm3-20H7C5.9 0 5 .9 5 2v14c0 1.1.9 2 2 2h10c1.1 0 2-.9 2-2V2c0-1.1-.9-2-2-2zm-5 6c-1.11 0-2-.9-2-2s.89-2 1.99-2 2 .9 2 2C14 5.1 13.1 6 12 6z"></path></g>
<g id="camera-roll"><path d="M14 5c0-1.1-.9-2-2-2h-1V2c0-.55-.45-1-1-1H6c-.55 0-1 .45-1 1v1H4c-1.1 0-2 .9-2 2v15c0 1.1.9 2 2 2h8c1.1 0 2-.9 2-2h8V5h-8zm-2 13h-2v-2h2v2zm0-9h-2V7h2v2zm4 9h-2v-2h2v2zm0-9h-2V7h2v2zm4 9h-2v-2h2v2zm0-9h-2V7h2v2z"></path></g>
<g id="center-focus-strong"><path d="M12 8c-2.21 0-4 1.79-4 4s1.79 4 4 4 4-1.79 4-4-1.79-4-4-4zm-7 7H3v4c0 1.1.9 2 2 2h4v-2H5v-4zM5 5h4V3H5c-1.1 0-2 .9-2 2v4h2V5zm14-2h-4v2h4v4h2V5c0-1.1-.9-2-2-2zm0 16h-4v2h4c1.1 0 2-.9 2-2v-4h-2v4z"></path></g>
<g id="center-focus-weak"><path d="M5 15H3v4c0 1.1.9 2 2 2h4v-2H5v-4zM5 5h4V3H5c-1.1 0-2 .9-2 2v4h2V5zm14-2h-4v2h4v4h2V5c0-1.1-.9-2-2-2zm0 16h-4v2h4c1.1 0 2-.9 2-2v-4h-2v4zM12 8c-2.21 0-4 1.79-4 4s1.79 4 4 4 4-1.79 4-4-1.79-4-4-4zm0 6c-1.1 0-2-.9-2-2s.9-2 2-2 2 .9 2 2-.9 2-2 2z"></path></g>
<g id="collections"><path d="M22 16V4c0-1.1-.9-2-2-2H8c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2zm-11-4l2.03 2.71L16 11l4 5H8l3-4zM2 6v14c0 1.1.9 2 2 2h14v-2H4V6H2z"></path></g>
<g id="collections-bookmark"><path d="M4 6H2v14c0 1.1.9 2 2 2h14v-2H4V6zm16-4H8c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zm0 10l-2.5-1.5L15 12V4h5v8z"></path></g>
<g id="color-lens"><path d="M12 3c-4.97 0-9 4.03-9 9s4.03 9 9 9c.83 0 1.5-.67 1.5-1.5 0-.39-.15-.74-.39-1.01-.23-.26-.38-.61-.38-.99 0-.83.67-1.5 1.5-1.5H16c2.76 0 5-2.24 5-5 0-4.42-4.03-8-9-8zm-5.5 9c-.83 0-1.5-.67-1.5-1.5S5.67 9 6.5 9 8 9.67 8 10.5 7.33 12 6.5 12zm3-4C8.67 8 8 7.33 8 6.5S8.67 5 9.5 5s1.5.67 1.5 1.5S10.33 8 9.5 8zm5 0c-.83 0-1.5-.67-1.5-1.5S13.67 5 14.5 5s1.5.67 1.5 1.5S15.33 8 14.5 8zm3 4c-.83 0-1.5-.67-1.5-1.5S16.67 9 17.5 9s1.5.67 1.5 1.5-.67 1.5-1.5 1.5z"></path></g>
<g id="colorize"><path d="M20.71 5.63l-2.34-2.34c-.39-.39-1.02-.39-1.41 0l-3.12 3.12-1.93-1.91-1.41 1.41 1.42 1.42L3 16.25V21h4.75l8.92-8.92 1.42 1.42 1.41-1.41-1.92-1.92 3.12-3.12c.4-.4.4-1.03.01-1.42zM6.92 19L5 17.08l8.06-8.06 1.92 1.92L6.92 19z"></path></g>
<g id="compare"><path d="M10 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h5v2h2V1h-2v2zm0 15H5l5-6v6zm9-15h-5v2h5v13l-5-6v9h5c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2z"></path></g>
<g id="control-point"><path d="M13 7h-2v4H7v2h4v4h2v-4h4v-2h-4V7zm-1-5C6.49 2 2 6.49 2 12s4.49 10 10 10 10-4.49 10-10S17.51 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8z"></path></g>
<g id="control-point-duplicate"><path d="M16 8h-2v3h-3v2h3v3h2v-3h3v-2h-3zM2 12c0-2.79 1.64-5.2 4.01-6.32V3.52C2.52 4.76 0 8.09 0 12s2.52 7.24 6.01 8.48v-2.16C3.64 17.2 2 14.79 2 12zm13-9c-4.96 0-9 4.04-9 9s4.04 9 9 9 9-4.04 9-9-4.04-9-9-9zm0 16c-3.86 0-7-3.14-7-7s3.14-7 7-7 7 3.14 7 7-3.14 7-7 7z"></path></g>
<g id="crop"><path d="M17 15h2V7c0-1.1-.9-2-2-2H9v2h8v8zM7 17V1H5v4H1v2h4v10c0 1.1.9 2 2 2h10v4h2v-4h4v-2H7z"></path></g>
<g id="crop-16-9"><path d="M19 6H5c-1.1 0-2 .9-2 2v8c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V8c0-1.1-.9-2-2-2zm0 10H5V8h14v8z"></path></g>
<g id="crop-3-2"><path d="M19 4H5c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm0 14H5V6h14v12z"></path></g>
<g id="crop-5-4"><path d="M19 5H5c-1.1 0-2 .9-2 2v10c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2zm0 12H5V7h14v10z"></path></g>
<g id="crop-7-5"><path d="M19 7H5c-1.1 0-2 .9-2 2v6c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V9c0-1.1-.9-2-2-2zm0 8H5V9h14v6z"></path></g>
<g id="crop-din"><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16H5V5h14v14z"></path></g>
<g id="crop-free"><path d="M3 5v4h2V5h4V3H5c-1.1 0-2 .9-2 2zm2 10H3v4c0 1.1.9 2 2 2h4v-2H5v-4zm14 4h-4v2h4c1.1 0 2-.9 2-2v-4h-2v4zm0-16h-4v2h4v4h2V5c0-1.1-.9-2-2-2z"></path></g>
<g id="crop-landscape"><path d="M19 5H5c-1.1 0-2 .9-2 2v10c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2zm0 12H5V7h14v10z"></path></g>
<g id="crop-original"><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16H5V5h14v14zm-5.04-6.71l-2.75 3.54-1.96-2.36L6.5 17h11l-3.54-4.71z"></path></g>
<g id="crop-portrait"><path d="M17 3H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h10c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16H7V5h10v14z"></path></g>
<g id="crop-rotate"><path d="M7.47 21.49C4.2 19.93 1.86 16.76 1.5 13H0c.51 6.16 5.66 11 11.95 11 .23 0 .44-.02.66-.03L8.8 20.15l-1.33 1.34zM12.05 0c-.23 0-.44.02-.66.04l3.81 3.81 1.33-1.33C19.8 4.07 22.14 7.24 22.5 11H24c-.51-6.16-5.66-11-11.95-11zM16 14h2V8c0-1.11-.9-2-2-2h-6v2h6v6zm-8 2V4H6v2H4v2h2v8c0 1.1.89 2 2 2h8v2h2v-2h2v-2H8z"></path></g>
<g id="crop-square"><path d="M18 4H6c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm0 14H6V6h12v12z"></path></g>
<g id="dehaze"><path d="M2 15.5v2h20v-2H2zm0-5v2h20v-2H2zm0-5v2h20v-2H2z"></path></g>
<g id="details"><path d="M3 4l9 16 9-16H3zm3.38 2h11.25L12 16 6.38 6z"></path></g>
<g id="edit"><path d="M3 17.25V21h3.75L17.81 9.94l-3.75-3.75L3 17.25zM20.71 7.04c.39-.39.39-1.02 0-1.41l-2.34-2.34c-.39-.39-1.02-.39-1.41 0l-1.83 1.83 3.75 3.75 1.83-1.83z"></path></g>
<g id="exposure"><path d="M15 17v2h2v-2h2v-2h-2v-2h-2v2h-2v2h2zm5-15H4c-1.1 0-2 .9-2 2v16c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zM5 5h6v2H5V5zm15 15H4L20 4v16z"></path></g>
<g id="exposure-neg-1"><path d="M4 11v2h8v-2H4zm15 7h-2V7.38L14 8.4V6.7L18.7 5h.3v13z"></path></g>
<g id="exposure-neg-2"><path d="M15.05 16.29l2.86-3.07c.38-.39.72-.79 1.04-1.18.32-.39.59-.78.82-1.17.23-.39.41-.78.54-1.17s.19-.79.19-1.18c0-.53-.09-1.02-.27-1.46-.18-.44-.44-.81-.78-1.11-.34-.31-.77-.54-1.26-.71-.51-.16-1.08-.24-1.72-.24-.69 0-1.31.11-1.85.32-.54.21-1 .51-1.36.88-.37.37-.65.8-.84 1.3-.18.47-.27.97-.28 1.5h2.14c.01-.31.05-.6.13-.87.09-.29.23-.54.4-.75.18-.21.41-.37.68-.49.27-.12.6-.18.96-.18.31 0 .58.05.81.15.23.1.43.25.59.43.16.18.28.4.37.65.08.25.13.52.13.81 0 .22-.03.43-.08.65-.06.22-.15.45-.29.7-.14.25-.32.53-.56.83-.23.3-.52.65-.88 1.03l-4.17 4.55V18H21v-1.71h-5.95zM2 11v2h8v-2H2z"></path></g>
<g id="exposure-plus-1"><path d="M10 7H8v4H4v2h4v4h2v-4h4v-2h-4V7zm10 11h-2V7.38L15 8.4V6.7L19.7 5h.3v13z"></path></g>
<g id="exposure-plus-2"><path d="M16.05 16.29l2.86-3.07c.38-.39.72-.79 1.04-1.18.32-.39.59-.78.82-1.17.23-.39.41-.78.54-1.17.13-.39.19-.79.19-1.18 0-.53-.09-1.02-.27-1.46-.18-.44-.44-.81-.78-1.11-.34-.31-.77-.54-1.26-.71-.51-.16-1.08-.24-1.72-.24-.69 0-1.31.11-1.85.32-.54.21-1 .51-1.36.88-.37.37-.65.8-.84 1.3-.18.47-.27.97-.28 1.5h2.14c.01-.31.05-.6.13-.87.09-.29.23-.54.4-.75.18-.21.41-.37.68-.49.27-.12.6-.18.96-.18.31 0 .58.05.81.15.23.1.43.25.59.43.16.18.28.4.37.65.08.25.13.52.13.81 0 .22-.03.43-.08.65-.06.22-.15.45-.29.7-.14.25-.32.53-.56.83-.23.3-.52.65-.88 1.03l-4.17 4.55V18H22v-1.71h-5.95zM8 7H6v4H2v2h4v4h2v-4h4v-2H8V7z"></path></g>
<g id="exposure-zero"><path d="M16.14 12.5c0 1-.1 1.85-.3 2.55-.2.7-.48 1.27-.83 1.7-.36.44-.79.75-1.3.95-.51.2-1.07.3-1.7.3-.62 0-1.18-.1-1.69-.3-.51-.2-.95-.51-1.31-.95-.36-.44-.65-1.01-.85-1.7-.2-.7-.3-1.55-.3-2.55v-2.04c0-1 .1-1.85.3-2.55.2-.7.48-1.26.84-1.69.36-.43.8-.74 1.31-.93C10.81 5.1 11.38 5 12 5c.63 0 1.19.1 1.7.29.51.19.95.5 1.31.93.36.43.64.99.84 1.69.2.7.3 1.54.3 2.55v2.04zm-2.11-2.36c0-.64-.05-1.18-.13-1.62-.09-.44-.22-.79-.4-1.06-.17-.27-.39-.46-.64-.58-.25-.13-.54-.19-.86-.19-.32 0-.61.06-.86.18s-.47.31-.64.58c-.17.27-.31.62-.4 1.06s-.13.98-.13 1.62v2.67c0 .64.05 1.18.14 1.62.09.45.23.81.4 1.09s.39.48.64.61.54.19.87.19c.33 0 .62-.06.87-.19s.46-.33.63-.61c.17-.28.3-.64.39-1.09.09-.45.13-.99.13-1.62v-2.66z"></path></g>
<g id="filter"><path d="M15.96 10.29l-2.75 3.54-1.96-2.36L8.5 15h11l-3.54-4.71zM3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm18-4H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14z"></path></g>
<g id="filter-1"><path d="M3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm11 10h2V5h-4v2h2v8zm7-14H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14z"></path></g>
<g id="filter-2"><path d="M3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm18-4H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14zm-4-4h-4v-2h2c1.1 0 2-.89 2-2V7c0-1.11-.9-2-2-2h-4v2h4v2h-2c-1.1 0-2 .89-2 2v4h6v-2z"></path></g>
<g id="filter-3"><path d="M21 1H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14zM3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm14 8v-1.5c0-.83-.67-1.5-1.5-1.5.83 0 1.5-.67 1.5-1.5V7c0-1.11-.9-2-2-2h-4v2h4v2h-2v2h2v2h-4v2h4c1.1 0 2-.89 2-2z"></path></g>
<g id="filter-4"><path d="M3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm12 10h2V5h-2v4h-2V5h-2v6h4v4zm6-14H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14z"></path></g>
<g id="filter-5"><path d="M21 1H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14zM3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm14 8v-2c0-1.11-.9-2-2-2h-2V7h4V5h-6v6h4v2h-4v2h4c1.1 0 2-.89 2-2z"></path></g>
<g id="filter-6"><path d="M3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm18-4H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14zm-8-2h2c1.1 0 2-.89 2-2v-2c0-1.11-.9-2-2-2h-2V7h4V5h-4c-1.1 0-2 .89-2 2v6c0 1.11.9 2 2 2zm0-4h2v2h-2v-2z"></path></g>
<g id="filter-7"><path d="M3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm18-4H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14zm-8-2l4-8V5h-6v2h4l-4 8h2z"></path></g>
<g id="filter-8"><path d="M3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm18-4H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14zm-8-2h2c1.1 0 2-.89 2-2v-1.5c0-.83-.67-1.5-1.5-1.5.83 0 1.5-.67 1.5-1.5V7c0-1.11-.9-2-2-2h-2c-1.1 0-2 .89-2 2v1.5c0 .83.67 1.5 1.5 1.5-.83 0-1.5.67-1.5 1.5V13c0 1.11.9 2 2 2zm0-8h2v2h-2V7zm0 4h2v2h-2v-2z"></path></g>
<g id="filter-9"><path d="M3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm18-4H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14zM15 5h-2c-1.1 0-2 .89-2 2v2c0 1.11.9 2 2 2h2v2h-4v2h4c1.1 0 2-.89 2-2V7c0-1.11-.9-2-2-2zm0 4h-2V7h2v2z"></path></g>
<g id="filter-9-plus"><path d="M3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm11 7V8c0-1.11-.9-2-2-2h-1c-1.1 0-2 .89-2 2v1c0 1.11.9 2 2 2h1v1H9v2h3c1.1 0 2-.89 2-2zm-3-3V8h1v1h-1zm10-8H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 8h-2V7h-2v2h-2v2h2v2h2v-2h2v6H7V3h14v6z"></path></g>
<g id="filter-b-and-w"><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16l-7-8v8H5l7-8V5h7v14z"></path></g>
<g id="filter-center-focus"><path d="M5 15H3v4c0 1.1.9 2 2 2h4v-2H5v-4zM5 5h4V3H5c-1.1 0-2 .9-2 2v4h2V5zm14-2h-4v2h4v4h2V5c0-1.1-.9-2-2-2zm0 16h-4v2h4c1.1 0 2-.9 2-2v-4h-2v4zM12 9c-1.66 0-3 1.34-3 3s1.34 3 3 3 3-1.34 3-3-1.34-3-3-3z"></path></g>
<g id="filter-drama"><path d="M19.35 10.04C18.67 6.59 15.64 4 12 4 9.11 4 6.61 5.64 5.36 8.04 2.35 8.36 0 10.9 0 14c0 3.31 2.69 6 6 6h13c2.76 0 5-2.24 5-5 0-2.64-2.05-4.78-4.65-4.96zM19 18H6c-2.21 0-4-1.79-4-4s1.79-4 4-4 4 1.79 4 4h2c0-2.76-1.86-5.08-4.4-5.78C8.61 6.88 10.2 6 12 6c3.03 0 5.5 2.47 5.5 5.5v.5H19c1.65 0 3 1.35 3 3s-1.35 3-3 3z"></path></g>
<g id="filter-frames"><path d="M20 4h-4l-4-4-4 4H4c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm0 16H4V6h4.52l3.52-3.5L15.52 6H20v14zM18 8H6v10h12"></path></g>
<g id="filter-hdr"><path d="M14 6l-3.75 5 2.85 3.8-1.6 1.2C9.81 13.75 7 10 7 10l-6 8h22L14 6z"></path></g>
<g id="filter-none"><path d="M3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm18-4H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14z"></path></g>
<g id="filter-tilt-shift"><path d="M11 4.07V2.05c-2.01.2-3.84 1-5.32 2.21L7.1 5.69c1.11-.86 2.44-1.44 3.9-1.62zm7.32.19C16.84 3.05 15.01 2.25 13 2.05v2.02c1.46.18 2.79.76 3.9 1.62l1.42-1.43zM19.93 11h2.02c-.2-2.01-1-3.84-2.21-5.32L18.31 7.1c.86 1.11 1.44 2.44 1.62 3.9zM5.69 7.1L4.26 5.68C3.05 7.16 2.25 8.99 2.05 11h2.02c.18-1.46.76-2.79 1.62-3.9zM4.07 13H2.05c.2 2.01 1 3.84 2.21 5.32l1.43-1.43c-.86-1.1-1.44-2.43-1.62-3.89zM15 12c0-1.66-1.34-3-3-3s-3 1.34-3 3 1.34 3 3 3 3-1.34 3-3zm3.31 4.9l1.43 1.43c1.21-1.48 2.01-3.32 2.21-5.32h-2.02c-.18 1.45-.76 2.78-1.62 3.89zM13 19.93v2.02c2.01-.2 3.84-1 5.32-2.21l-1.43-1.43c-1.1.86-2.43 1.44-3.89 1.62zm-7.32-.19C7.16 20.95 9 21.75 11 21.95v-2.02c-1.46-.18-2.79-.76-3.9-1.62l-1.42 1.43z"></path></g>
<g id="filter-vintage"><path d="M18.7 12.4c-.28-.16-.57-.29-.86-.4.29-.11.58-.24.86-.4 1.92-1.11 2.99-3.12 3-5.19-1.79-1.03-4.07-1.11-6 0-.28.16-.54.35-.78.54.05-.31.08-.63.08-.95 0-2.22-1.21-4.15-3-5.19C10.21 1.85 9 3.78 9 6c0 .32.03.64.08.95-.24-.2-.5-.39-.78-.55-1.92-1.11-4.2-1.03-6 0 0 2.07 1.07 4.08 3 5.19.28.16.57.29.86.4-.29.11-.58.24-.86.4-1.92 1.11-2.99 3.12-3 5.19 1.79 1.03 4.07 1.11 6 0 .28-.16.54-.35.78-.54-.05.32-.08.64-.08.96 0 2.22 1.21 4.15 3 5.19 1.79-1.04 3-2.97 3-5.19 0-.32-.03-.64-.08-.95.24.2.5.38.78.54 1.92 1.11 4.2 1.03 6 0-.01-2.07-1.08-4.08-3-5.19zM12 16c-2.21 0-4-1.79-4-4s1.79-4 4-4 4 1.79 4 4-1.79 4-4 4z"></path></g>
<g id="flare"><path d="M7 11H1v2h6v-2zm2.17-3.24L7.05 5.64 5.64 7.05l2.12 2.12 1.41-1.41zM13 1h-2v6h2V1zm5.36 6.05l-1.41-1.41-2.12 2.12 1.41 1.41 2.12-2.12zM17 11v2h6v-2h-6zm-5-2c-1.66 0-3 1.34-3 3s1.34 3 3 3 3-1.34 3-3-1.34-3-3-3zm2.83 7.24l2.12 2.12 1.41-1.41-2.12-2.12-1.41 1.41zm-9.19.71l1.41 1.41 2.12-2.12-1.41-1.41-2.12 2.12zM11 23h2v-6h-2v6z"></path></g>
<g id="flash-auto"><path d="M3 2v12h3v9l7-12H9l4-9H3zm16 0h-2l-3.2 9h1.9l.7-2h3.2l.7 2h1.9L19 2zm-2.15 5.65L18 4l1.15 3.65h-2.3z"></path></g>
<g id="flash-off"><path d="M3.27 3L2 4.27l5 5V13h3v9l3.58-6.14L17.73 20 19 18.73 3.27 3zM17 10h-4l4-8H7v2.18l8.46 8.46L17 10z"></path></g>
<g id="flash-on"><path d="M7 2v11h3v9l7-12h-4l4-8z"></path></g>
<g id="flip"><path d="M15 21h2v-2h-2v2zm4-12h2V7h-2v2zM3 5v14c0 1.1.9 2 2 2h4v-2H5V5h4V3H5c-1.1 0-2 .9-2 2zm16-2v2h2c0-1.1-.9-2-2-2zm-8 20h2V1h-2v22zm8-6h2v-2h-2v2zM15 5h2V3h-2v2zm4 8h2v-2h-2v2zm0 8c1.1 0 2-.9 2-2h-2v2z"></path></g>
<g id="gradient"><path d="M11 9h2v2h-2zm-2 2h2v2H9zm4 0h2v2h-2zm2-2h2v2h-2zM7 9h2v2H7zm12-6H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 18H7v-2h2v2zm4 0h-2v-2h2v2zm4 0h-2v-2h2v2zm2-7h-2v2h2v2h-2v-2h-2v2h-2v-2h-2v2H9v-2H7v2H5v-2h2v-2H5V5h14v6z"></path></g>
<g id="grain"><path d="M10 12c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zM6 8c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm0 8c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm12-8c1.1 0 2-.9 2-2s-.9-2-2-2-2 .9-2 2 .9 2 2 2zm-4 8c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm4-4c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm-4-4c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm-4-4c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2z"></path></g>
<g id="grid-off"><path d="M8 4v1.45l2 2V4h4v4h-3.45l2 2H14v1.45l2 2V10h4v4h-3.45l2 2H20v1.45l2 2V4c0-1.1-.9-2-2-2H4.55l2 2H8zm8 0h4v4h-4V4zM1.27 1.27L0 2.55l2 2V20c0 1.1.9 2 2 2h15.46l2 2 1.27-1.27L1.27 1.27zM10 12.55L11.45 14H10v-1.45zm-6-6L5.45 8H4V6.55zM8 20H4v-4h4v4zm0-6H4v-4h3.45l.55.55V14zm6 6h-4v-4h3.45l.55.54V20zm2 0v-1.46L17.46 20H16z"></path></g>
<g id="grid-on"><path d="M20 2H4c-1.1 0-2 .9-2 2v16c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zM8 20H4v-4h4v4zm0-6H4v-4h4v4zm0-6H4V4h4v4zm6 12h-4v-4h4v4zm0-6h-4v-4h4v4zm0-6h-4V4h4v4zm6 12h-4v-4h4v4zm0-6h-4v-4h4v4zm0-6h-4V4h4v4z"></path></g>
<g id="hdr-off"><path d="M17.5 15v-2h1.1l.9 2H21l-.9-2.1c.5-.2.9-.8.9-1.4v-1c0-.8-.7-1.5-1.5-1.5H16v4.9l1.1 1.1h.4zm0-4.5h2v1h-2v-1zm-4.5 0v.4l1.5 1.5v-1.9c0-.8-.7-1.5-1.5-1.5h-1.9l1.5 1.5h.4zm-3.5-1l-7-7-1.1 1L6.9 9h-.4v2h-2V9H3v6h1.5v-2.5h2V15H8v-4.9l1.5 1.5V15h3.4l7.6 7.6 1.1-1.1-12.1-12z"></path></g>
<g id="hdr-on"><path d="M21 11.5v-1c0-.8-.7-1.5-1.5-1.5H16v6h1.5v-2h1.1l.9 2H21l-.9-2.1c.5-.3.9-.8.9-1.4zm-1.5 0h-2v-1h2v1zm-13-.5h-2V9H3v6h1.5v-2.5h2V15H8V9H6.5v2zM13 9H9.5v6H13c.8 0 1.5-.7 1.5-1.5v-3c0-.8-.7-1.5-1.5-1.5zm0 4.5h-2v-3h2v3z"></path></g>
<g id="hdr-strong"><path d="M17 6c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zM5 8c-2.21 0-4 1.79-4 4s1.79 4 4 4 4-1.79 4-4-1.79-4-4-4zm0 6c-1.1 0-2-.9-2-2s.9-2 2-2 2 .9 2 2-.9 2-2 2z"></path></g>
<g id="hdr-weak"><path d="M5 8c-2.21 0-4 1.79-4 4s1.79 4 4 4 4-1.79 4-4-1.79-4-4-4zm12-2c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm0 10c-2.21 0-4-1.79-4-4s1.79-4 4-4 4 1.79 4 4-1.79 4-4 4z"></path></g>
<g id="healing"><path d="M17.73 12.02l3.98-3.98c.39-.39.39-1.02 0-1.41l-4.34-4.34c-.39-.39-1.02-.39-1.41 0l-3.98 3.98L8 2.29C7.8 2.1 7.55 2 7.29 2c-.25 0-.51.1-.7.29L2.25 6.63c-.39.39-.39 1.02 0 1.41l3.98 3.98L2.25 16c-.39.39-.39 1.02 0 1.41l4.34 4.34c.39.39 1.02.39 1.41 0l3.98-3.98 3.98 3.98c.2.2.45.29.71.29.26 0 .51-.1.71-.29l4.34-4.34c.39-.39.39-1.02 0-1.41l-3.99-3.98zM12 9c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm-4.71 1.96L3.66 7.34l3.63-3.63 3.62 3.62-3.62 3.63zM10 13c-.55 0-1-.45-1-1s.45-1 1-1 1 .45 1 1-.45 1-1 1zm2 2c-.55 0-1-.45-1-1s.45-1 1-1 1 .45 1 1-.45 1-1 1zm2-4c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm2.66 9.34l-3.63-3.62 3.63-3.63 3.62 3.62-3.62 3.63z"></path></g>
<g id="image"><path d="M21 19V5c0-1.1-.9-2-2-2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2zM8.5 13.5l2.5 3.01L14.5 12l4.5 6H5l3.5-4.5z"></path></g>
<g id="image-aspect-ratio"><path d="M16 10h-2v2h2v-2zm0 4h-2v2h2v-2zm-8-4H6v2h2v-2zm4 0h-2v2h2v-2zm8-6H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm0 14H4V6h16v12z"></path></g>
<g id="iso"><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM5.5 7.5h2v-2H9v2h2V9H9v2H7.5V9h-2V7.5zM19 19H5L19 5v14zm-2-2v-1.5h-5V17h5z"></path></g>
<g id="landscape"><path d="M14 6l-3.75 5 2.85 3.8-1.6 1.2C9.81 13.75 7 10 7 10l-6 8h22L14 6z"></path></g>
<g id="leak-add"><path d="M6 3H3v3c1.66 0 3-1.34 3-3zm8 0h-2c0 4.97-4.03 9-9 9v2c6.08 0 11-4.93 11-11zm-4 0H8c0 2.76-2.24 5-5 5v2c3.87 0 7-3.13 7-7zm0 18h2c0-4.97 4.03-9 9-9v-2c-6.07 0-11 4.93-11 11zm8 0h3v-3c-1.66 0-3 1.34-3 3zm-4 0h2c0-2.76 2.24-5 5-5v-2c-3.87 0-7 3.13-7 7z"></path></g>
<g id="leak-remove"><path d="M10 3H8c0 .37-.04.72-.12 1.06l1.59 1.59C9.81 4.84 10 3.94 10 3zM3 4.27l2.84 2.84C5.03 7.67 4.06 8 3 8v2c1.61 0 3.09-.55 4.27-1.46L8.7 9.97C7.14 11.24 5.16 12 3 12v2c2.71 0 5.19-.99 7.11-2.62l2.5 2.5C10.99 15.81 10 18.29 10 21h2c0-2.16.76-4.14 2.03-5.69l1.43 1.43C14.55 17.91 14 19.39 14 21h2c0-1.06.33-2.03.89-2.84L19.73 21 21 19.73 4.27 3 3 4.27zM14 3h-2c0 1.5-.37 2.91-1.02 4.16l1.46 1.46C13.42 6.98 14 5.06 14 3zm5.94 13.12c.34-.08.69-.12 1.06-.12v-2c-.94 0-1.84.19-2.66.52l1.6 1.6zm-4.56-4.56l1.46 1.46C18.09 12.37 19.5 12 21 12v-2c-2.06 0-3.98.58-5.62 1.56z"></path></g>
<g id="lens"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2z"></path></g>
<g id="linked-camera"><circle cx="12" cy="14" r="3.2"></circle><path d="M16 3.33c2.58 0 4.67 2.09 4.67 4.67H22c0-3.31-2.69-6-6-6v1.33M16 6c1.11 0 2 .89 2 2h1.33c0-1.84-1.49-3.33-3.33-3.33V6"></path><path d="M17 9c0-1.11-.89-2-2-2V4H9L7.17 6H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V9h-5zm-5 10c-2.76 0-5-2.24-5-5s2.24-5 5-5 5 2.24 5 5-2.24 5-5 5z"></path></g>
<g id="looks"><path d="M12 10c-3.86 0-7 3.14-7 7h2c0-2.76 2.24-5 5-5s5 2.24 5 5h2c0-3.86-3.14-7-7-7zm0-4C5.93 6 1 10.93 1 17h2c0-4.96 4.04-9 9-9s9 4.04 9 9h2c0-6.07-4.93-11-11-11z"></path></g>
<g id="looks-3"><path d="M19.01 3h-14c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-4 7.5c0 .83-.67 1.5-1.5 1.5.83 0 1.5.67 1.5 1.5V15c0 1.11-.9 2-2 2h-4v-2h4v-2h-2v-2h2V9h-4V7h4c1.1 0 2 .89 2 2v1.5z"></path></g>
<g id="looks-4"><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-4 14h-2v-4H9V7h2v4h2V7h2v10z"></path></g>
<g id="looks-5"><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-4 6h-4v2h2c1.1 0 2 .89 2 2v2c0 1.11-.9 2-2 2H9v-2h4v-2H9V7h6v2z"></path></g>
<g id="looks-6"><path d="M11 15h2v-2h-2v2zm8-12H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-4 6h-4v2h2c1.1 0 2 .89 2 2v2c0 1.11-.9 2-2 2h-2c-1.1 0-2-.89-2-2V9c0-1.11.9-2 2-2h4v2z"></path></g>
<g id="looks-one"><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-5 14h-2V9h-2V7h4v10z"></path></g>
<g id="looks-two"><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-4 8c0 1.11-.9 2-2 2h-2v2h4v2H9v-4c0-1.11.9-2 2-2h2V9H9V7h4c1.1 0 2 .89 2 2v2z"></path></g>
<g id="loupe"><path d="M13 7h-2v4H7v2h4v4h2v-4h4v-2h-4V7zm-1-5C6.49 2 2 6.49 2 12s4.49 10 10 10h8c1.1 0 2-.9 2-2v-8c0-5.51-4.49-10-10-10zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8z"></path></g>
<g id="monochrome-photos"><path d="M20 5h-3.2L15 3H9L7.2 5H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2zm0 14h-8v-1c-2.8 0-5-2.2-5-5s2.2-5 5-5V7h8v12zm-3-6c0-2.8-2.2-5-5-5v1.8c1.8 0 3.2 1.4 3.2 3.2s-1.4 3.2-3.2 3.2V18c2.8 0 5-2.2 5-5zm-8.2 0c0 1.8 1.4 3.2 3.2 3.2V9.8c-1.8 0-3.2 1.4-3.2 3.2z"></path></g>
<g id="movie-creation"><path d="M18 4l2 4h-3l-2-4h-2l2 4h-3l-2-4H8l2 4H7L5 4H4c-1.1 0-1.99.9-1.99 2L2 18c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V4h-4z"></path></g>
<g id="movie-filter"><path d="M18 4l2 3h-3l-2-3h-2l2 3h-3l-2-3H8l2 3H7L5 4H4c-1.1 0-1.99.9-1.99 2L2 18c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V4h-4zm-6.75 11.25L10 18l-1.25-2.75L6 14l2.75-1.25L10 10l1.25 2.75L14 14l-2.75 1.25zm5.69-3.31L16 14l-.94-2.06L13 11l2.06-.94L16 8l.94 2.06L19 11l-2.06.94z"></path></g>
<g id="music-note"><path d="M12 3v10.55c-.59-.34-1.27-.55-2-.55-2.21 0-4 1.79-4 4s1.79 4 4 4 4-1.79 4-4V7h4V3h-6z"></path></g>
<g id="nature"><path d="M13 16.12c3.47-.41 6.17-3.36 6.17-6.95 0-3.87-3.13-7-7-7s-7 3.13-7 7c0 3.47 2.52 6.34 5.83 6.89V20H5v2h14v-2h-6v-3.88z"></path></g>
<g id="nature-people"><path d="M22.17 9.17c0-3.87-3.13-7-7-7s-7 3.13-7 7c0 3.47 2.52 6.34 5.83 6.89V20H6v-3h1v-4c0-.55-.45-1-1-1H3c-.55 0-1 .45-1 1v4h1v5h16v-2h-3v-3.88c3.47-.41 6.17-3.36 6.17-6.95zM4.5 11c.83 0 1.5-.67 1.5-1.5S5.33 8 4.5 8 3 8.67 3 9.5 3.67 11 4.5 11z"></path></g>
<g id="navigate-before"><path d="M15.41 7.41L14 6l-6 6 6 6 1.41-1.41L10.83 12z"></path></g>
<g id="navigate-next"><path d="M10 6L8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z"></path></g>
<g id="palette"><path d="M12 3c-4.97 0-9 4.03-9 9s4.03 9 9 9c.83 0 1.5-.67 1.5-1.5 0-.39-.15-.74-.39-1.01-.23-.26-.38-.61-.38-.99 0-.83.67-1.5 1.5-1.5H16c2.76 0 5-2.24 5-5 0-4.42-4.03-8-9-8zm-5.5 9c-.83 0-1.5-.67-1.5-1.5S5.67 9 6.5 9 8 9.67 8 10.5 7.33 12 6.5 12zm3-4C8.67 8 8 7.33 8 6.5S8.67 5 9.5 5s1.5.67 1.5 1.5S10.33 8 9.5 8zm5 0c-.83 0-1.5-.67-1.5-1.5S13.67 5 14.5 5s1.5.67 1.5 1.5S15.33 8 14.5 8zm3 4c-.83 0-1.5-.67-1.5-1.5S16.67 9 17.5 9s1.5.67 1.5 1.5-.67 1.5-1.5 1.5z"></path></g>
<g id="panorama"><path d="M23 18V6c0-1.1-.9-2-2-2H3c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2zM8.5 12.5l2.5 3.01L14.5 11l4.5 6H5l3.5-4.5z"></path></g>
<g id="panorama-fish-eye"><path d="M12 2C6.47 2 2 6.47 2 12s4.47 10 10 10 10-4.47 10-10S17.53 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8z"></path></g>
<g id="panorama-horizontal"><path d="M20 6.54v10.91c-2.6-.77-5.28-1.16-8-1.16-2.72 0-5.4.39-8 1.16V6.54c2.6.77 5.28 1.16 8 1.16 2.72.01 5.4-.38 8-1.16M21.43 4c-.1 0-.2.02-.31.06C18.18 5.16 15.09 5.7 12 5.7c-3.09 0-6.18-.55-9.12-1.64-.11-.04-.22-.06-.31-.06-.34 0-.57.23-.57.63v14.75c0 .39.23.62.57.62.1 0 .2-.02.31-.06 2.94-1.1 6.03-1.64 9.12-1.64 3.09 0 6.18.55 9.12 1.64.11.04.21.06.31.06.33 0 .57-.23.57-.63V4.63c0-.4-.24-.63-.57-.63z"></path></g>
<g id="panorama-vertical"><path d="M19.94 21.12c-1.1-2.94-1.64-6.03-1.64-9.12 0-3.09.55-6.18 1.64-9.12.04-.11.06-.22.06-.31 0-.34-.23-.57-.63-.57H4.63c-.4 0-.63.23-.63.57 0 .1.02.2.06.31C5.16 5.82 5.71 8.91 5.71 12c0 3.09-.55 6.18-1.64 9.12-.05.11-.07.22-.07.31 0 .33.23.57.63.57h14.75c.39 0 .63-.24.63-.57-.01-.1-.03-.2-.07-.31zM6.54 20c.77-2.6 1.16-5.28 1.16-8 0-2.72-.39-5.4-1.16-8h10.91c-.77 2.6-1.16 5.28-1.16 8 0 2.72.39 5.4 1.16 8H6.54z"></path></g>
<g id="panorama-wide-angle"><path d="M12 6c2.45 0 4.71.2 7.29.64.47 1.78.71 3.58.71 5.36 0 1.78-.24 3.58-.71 5.36-2.58.44-4.84.64-7.29.64s-4.71-.2-7.29-.64C4.24 15.58 4 13.78 4 12c0-1.78.24-3.58.71-5.36C7.29 6.2 9.55 6 12 6m0-2c-2.73 0-5.22.24-7.95.72l-.93.16-.25.9C2.29 7.85 2 9.93 2 12s.29 4.15.87 6.22l.25.89.93.16c2.73.49 5.22.73 7.95.73s5.22-.24 7.95-.72l.93-.16.25-.89c.58-2.08.87-4.16.87-6.23s-.29-4.15-.87-6.22l-.25-.89-.93-.16C17.22 4.24 14.73 4 12 4z"></path></g>
<g id="photo"><path d="M21 19V5c0-1.1-.9-2-2-2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2zM8.5 13.5l2.5 3.01L14.5 12l4.5 6H5l3.5-4.5z"></path></g>
<g id="photo-album"><path d="M18 2H6c-1.1 0-2 .9-2 2v16c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zM6 4h5v8l-2.5-1.5L6 12V4zm0 15l3-3.86 2.14 2.58 3-3.86L18 19H6z"></path></g>
<g id="photo-camera"><circle cx="12" cy="12" r="3.2"></circle><path d="M9 2L7.17 4H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2h-3.17L15 2H9zm3 15c-2.76 0-5-2.24-5-5s2.24-5 5-5 5 2.24 5 5-2.24 5-5 5z"></path></g>
<g id="photo-filter"><path d="M19.02 10v9H5V5h9V3H5.02c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2v-9h-2zM17 10l.94-2.06L20 7l-2.06-.94L17 4l-.94 2.06L14 7l2.06.94zm-3.75.75L12 8l-1.25 2.75L8 12l2.75 1.25L12 16l1.25-2.75L16 12z"></path></g>
<g id="photo-library"><path d="M22 16V4c0-1.1-.9-2-2-2H8c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2zm-11-4l2.03 2.71L16 11l4 5H8l3-4zM2 6v14c0 1.1.9 2 2 2h14v-2H4V6H2z"></path></g>
<g id="photo-size-select-actual"><path d="M21 3H3C2 3 1 4 1 5v14c0 1.1.9 2 2 2h18c1 0 2-1 2-2V5c0-1-1-2-2-2zM5 17l3.5-4.5 2.5 3.01L14.5 11l4.5 6H5z"></path></g>
<g id="photo-size-select-large"><path d="M21 15h2v2h-2v-2zm0-4h2v2h-2v-2zm2 8h-2v2c1 0 2-1 2-2zM13 3h2v2h-2V3zm8 4h2v2h-2V7zm0-4v2h2c0-1-1-2-2-2zM1 7h2v2H1V7zm16-4h2v2h-2V3zm0 16h2v2h-2v-2zM3 3C2 3 1 4 1 5h2V3zm6 0h2v2H9V3zM5 3h2v2H5V3zm-4 8v8c0 1.1.9 2 2 2h12V11H1zm2 8l2.5-3.21 1.79 2.15 2.5-3.22L13 19H3z"></path></g>
<g id="photo-size-select-small"><path d="M23 15h-2v2h2v-2zm0-4h-2v2h2v-2zm0 8h-2v2c1 0 2-1 2-2zM15 3h-2v2h2V3zm8 4h-2v2h2V7zm-2-4v2h2c0-1-1-2-2-2zM3 21h8v-6H1v4c0 1.1.9 2 2 2zM3 7H1v2h2V7zm12 12h-2v2h2v-2zm4-16h-2v2h2V3zm0 16h-2v2h2v-2zM3 3C2 3 1 4 1 5h2V3zm0 8H1v2h2v-2zm8-8H9v2h2V3zM7 3H5v2h2V3z"></path></g>
<g id="picture-as-pdf"><path d="M20 2H8c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zm-8.5 7.5c0 .83-.67 1.5-1.5 1.5H9v2H7.5V7H10c.83 0 1.5.67 1.5 1.5v1zm5 2c0 .83-.67 1.5-1.5 1.5h-2.5V7H15c.83 0 1.5.67 1.5 1.5v3zm4-3H19v1h1.5V11H19v2h-1.5V7h3v1.5zM9 9.5h1v-1H9v1zM4 6H2v14c0 1.1.9 2 2 2h14v-2H4V6zm10 5.5h1v-3h-1v3z"></path></g>
<g id="portrait"><path d="M12 12.25c1.24 0 2.25-1.01 2.25-2.25S13.24 7.75 12 7.75 9.75 8.76 9.75 10s1.01 2.25 2.25 2.25zm4.5 4c0-1.5-3-2.25-4.5-2.25s-4.5.75-4.5 2.25V17h9v-.75zM19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16H5V5h14v14z"></path></g>
<g id="remove-red-eye"><path d="M12 4.5C7 4.5 2.73 7.61 1 12c1.73 4.39 6 7.5 11 7.5s9.27-3.11 11-7.5c-1.73-4.39-6-7.5-11-7.5zM12 17c-2.76 0-5-2.24-5-5s2.24-5 5-5 5 2.24 5 5-2.24 5-5 5zm0-8c-1.66 0-3 1.34-3 3s1.34 3 3 3 3-1.34 3-3-1.34-3-3-3z"></path></g>
<g id="rotate-90-degrees-ccw"><path d="M7.34 6.41L.86 12.9l6.49 6.48 6.49-6.48-6.5-6.49zM3.69 12.9l3.66-3.66L11 12.9l-3.66 3.66-3.65-3.66zm15.67-6.26C17.61 4.88 15.3 4 13 4V.76L8.76 5 13 9.24V6c1.79 0 3.58.68 4.95 2.05 2.73 2.73 2.73 7.17 0 9.9C16.58 19.32 14.79 20 13 20c-.97 0-1.94-.21-2.84-.61l-1.49 1.49C10.02 21.62 11.51 22 13 22c2.3 0 4.61-.88 6.36-2.64 3.52-3.51 3.52-9.21 0-12.72z"></path></g>
<g id="rotate-left"><path d="M7.11 8.53L5.7 7.11C4.8 8.27 4.24 9.61 4.07 11h2.02c.14-.87.49-1.72 1.02-2.47zM6.09 13H4.07c.17 1.39.72 2.73 1.62 3.89l1.41-1.42c-.52-.75-.87-1.59-1.01-2.47zm1.01 5.32c1.16.9 2.51 1.44 3.9 1.61V17.9c-.87-.15-1.71-.49-2.46-1.03L7.1 18.32zM13 4.07V1L8.45 5.55 13 10V6.09c2.84.48 5 2.94 5 5.91s-2.16 5.43-5 5.91v2.02c3.95-.49 7-3.85 7-7.93s-3.05-7.44-7-7.93z"></path></g>
<g id="rotate-right"><path d="M15.55 5.55L11 1v3.07C7.06 4.56 4 7.92 4 12s3.05 7.44 7 7.93v-2.02c-2.84-.48-5-2.94-5-5.91s2.16-5.43 5-5.91V10l4.55-4.45zM19.93 11c-.17-1.39-.72-2.73-1.62-3.89l-1.42 1.42c.54.75.88 1.6 1.02 2.47h2.02zM13 17.9v2.02c1.39-.17 2.74-.71 3.9-1.61l-1.44-1.44c-.75.54-1.59.89-2.46 1.03zm3.89-2.42l1.42 1.41c.9-1.16 1.45-2.5 1.62-3.89h-2.02c-.14.87-.48 1.72-1.02 2.48z"></path></g>
<g id="slideshow"><path d="M10 8v8l5-4-5-4zm9-5H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16H5V5h14v14z"></path></g>
<g id="straighten"><path d="M21 6H3c-1.1 0-2 .9-2 2v8c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2V8c0-1.1-.9-2-2-2zm0 10H3V8h2v4h2V8h2v4h2V8h2v4h2V8h2v4h2V8h2v8z"></path></g>
<g id="style"><path d="M2.53 19.65l1.34.56v-9.03l-2.43 5.86c-.41 1.02.08 2.19 1.09 2.61zm19.5-3.7L17.07 3.98c-.31-.75-1.04-1.21-1.81-1.23-.26 0-.53.04-.79.15L7.1 5.95c-.75.31-1.21 1.03-1.23 1.8-.01.27.04.54.15.8l4.96 11.97c.31.76 1.05 1.22 1.83 1.23.26 0 .52-.05.77-.15l7.36-3.05c1.02-.42 1.51-1.59 1.09-2.6zM7.88 8.75c-.55 0-1-.45-1-1s.45-1 1-1 1 .45 1 1-.45 1-1 1zm-2 11c0 1.1.9 2 2 2h1.45l-3.45-8.34v6.34z"></path></g>
<g id="switch-camera"><path d="M20 4h-3.17L15 2H9L7.17 4H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm-5 11.5V13H9v2.5L5.5 12 9 8.5V11h6V8.5l3.5 3.5-3.5 3.5z"></path></g>
<g id="switch-video"><path d="M18 9.5V6c0-.55-.45-1-1-1H3c-.55 0-1 .45-1 1v12c0 .55.45 1 1 1h14c.55 0 1-.45 1-1v-3.5l4 4v-13l-4 4zm-5 6V13H7v2.5L3.5 12 7 8.5V11h6V8.5l3.5 3.5-3.5 3.5z"></path></g>
<g id="tag-faces"><path d="M11.99 2C6.47 2 2 6.48 2 12s4.47 10 9.99 10C17.52 22 22 17.52 22 12S17.52 2 11.99 2zM12 20c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8zm3.5-9c.83 0 1.5-.67 1.5-1.5S16.33 8 15.5 8 14 8.67 14 9.5s.67 1.5 1.5 1.5zm-7 0c.83 0 1.5-.67 1.5-1.5S9.33 8 8.5 8 7 8.67 7 9.5 7.67 11 8.5 11zm3.5 6.5c2.33 0 4.31-1.46 5.11-3.5H6.89c.8 2.04 2.78 3.5 5.11 3.5z"></path></g>
<g id="texture"><path d="M19.51 3.08L3.08 19.51c.09.34.27.65.51.9.25.24.56.42.9.51L20.93 4.49c-.19-.69-.73-1.23-1.42-1.41zM11.88 3L3 11.88v2.83L14.71 3h-2.83zM5 3c-1.1 0-2 .9-2 2v2l4-4H5zm14 18c.55 0 1.05-.22 1.41-.59.37-.36.59-.86.59-1.41v-2l-4 4h2zm-9.71 0h2.83L21 12.12V9.29L9.29 21z"></path></g>
<g id="timelapse"><path d="M16.24 7.76C15.07 6.59 13.54 6 12 6v6l-4.24 4.24c2.34 2.34 6.14 2.34 8.49 0 2.34-2.34 2.34-6.14-.01-8.48zM12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8z"></path></g>
<g id="timer"><path d="M15 1H9v2h6V1zm-4 13h2V8h-2v6zm8.03-6.61l1.42-1.42c-.43-.51-.9-.99-1.41-1.41l-1.42 1.42C16.07 4.74 14.12 4 12 4c-4.97 0-9 4.03-9 9s4.02 9 9 9 9-4.03 9-9c0-2.12-.74-4.07-1.97-5.61zM12 20c-3.87 0-7-3.13-7-7s3.13-7 7-7 7 3.13 7 7-3.13 7-7 7z"></path></g>
<g id="timer-10"><path d="M0 7.72V9.4l3-1V18h2V6h-.25L0 7.72zm23.78 6.65c-.14-.28-.35-.53-.63-.74-.28-.21-.61-.39-1.01-.53s-.85-.27-1.35-.38c-.35-.07-.64-.15-.87-.23-.23-.08-.41-.16-.55-.25-.14-.09-.23-.19-.28-.3-.05-.11-.08-.24-.08-.39 0-.14.03-.28.09-.41.06-.13.15-.25.27-.34.12-.1.27-.18.45-.24s.4-.09.64-.09c.25 0 .47.04.66.11.19.07.35.17.48.29.13.12.22.26.29.42.06.16.1.32.1.49h1.95c0-.39-.08-.75-.24-1.09-.16-.34-.39-.63-.69-.88-.3-.25-.66-.44-1.09-.59C21.49 9.07 21 9 20.46 9c-.51 0-.98.07-1.39.21-.41.14-.77.33-1.06.57-.29.24-.51.52-.67.84-.16.32-.23.65-.23 1.01s.08.69.23.96c.15.28.36.52.64.73.27.21.6.38.98.53.38.14.81.26 1.27.36.39.08.71.17.95.26s.43.19.57.29c.13.1.22.22.27.34.05.12.07.25.07.39 0 .32-.13.57-.4.77-.27.2-.66.29-1.17.29-.22 0-.43-.02-.64-.08-.21-.05-.4-.13-.56-.24-.17-.11-.3-.26-.41-.44-.11-.18-.17-.41-.18-.67h-1.89c0 .36.08.71.24 1.05.16.34.39.65.7.93.31.27.69.49 1.15.66.46.17.98.25 1.58.25.53 0 1.01-.06 1.44-.19.43-.13.8-.31 1.11-.54.31-.23.54-.51.71-.83.17-.32.25-.67.25-1.06-.02-.4-.09-.74-.24-1.02zm-9.96-7.32c-.34-.4-.75-.7-1.23-.88-.47-.18-1.01-.27-1.59-.27-.58 0-1.11.09-1.59.27-.48.18-.89.47-1.23.88-.34.41-.6.93-.79 1.59-.18.65-.28 1.45-.28 2.39v1.92c0 .94.09 1.74.28 2.39.19.66.45 1.19.8 1.6.34.41.75.71 1.23.89.48.18 1.01.28 1.59.28.59 0 1.12-.09 1.59-.28.48-.18.88-.48 1.22-.89.34-.41.6-.94.78-1.6.18-.65.28-1.45.28-2.39v-1.92c0-.94-.09-1.74-.28-2.39-.18-.66-.44-1.19-.78-1.59zm-.92 6.17c0 .6-.04 1.11-.12 1.53-.08.42-.2.76-.36 1.02-.16.26-.36.45-.59.57-.23.12-.51.18-.82.18-.3 0-.58-.06-.82-.18s-.44-.31-.6-.57c-.16-.26-.29-.6-.38-1.02-.09-.42-.13-.93-.13-1.53v-2.5c0-.6.04-1.11.13-1.52.09-.41.21-.74.38-1 .16-.25.36-.43.6-.55.24-.11.51-.17.81-.17.31 0 .58.06.81.17.24.11.44.29.6.55.16.25.29.58.37.99.08.41.13.92.13 1.52v2.51z"></path></g>
<g id="timer-3"><path d="M11.61 12.97c-.16-.24-.36-.46-.62-.65-.25-.19-.56-.35-.93-.48.3-.14.57-.3.8-.5.23-.2.42-.41.57-.64.15-.23.27-.46.34-.71.08-.24.11-.49.11-.73 0-.55-.09-1.04-.28-1.46-.18-.42-.44-.77-.78-1.06-.33-.28-.73-.5-1.2-.64-.45-.13-.97-.2-1.53-.2-.55 0-1.06.08-1.52.24-.47.17-.87.4-1.2.69-.33.29-.6.63-.78 1.03-.2.39-.29.83-.29 1.29h1.98c0-.26.05-.49.14-.69.09-.2.22-.38.38-.52.17-.14.36-.25.58-.33.22-.08.46-.12.73-.12.61 0 1.06.16 1.36.47.3.31.44.75.44 1.32 0 .27-.04.52-.12.74-.08.22-.21.41-.38.57-.17.16-.38.28-.63.37-.25.09-.55.13-.89.13H6.72v1.57H7.9c.34 0 .64.04.91.11.27.08.5.19.69.35.19.16.34.36.44.61.1.24.16.54.16.87 0 .62-.18 1.09-.53 1.42-.35.33-.84.49-1.45.49-.29 0-.56-.04-.8-.13-.24-.08-.44-.2-.61-.36-.17-.16-.3-.34-.39-.56-.09-.22-.14-.46-.14-.72H4.19c0 .55.11 1.03.32 1.45.21.42.5.77.86 1.05s.77.49 1.24.63.96.21 1.48.21c.57 0 1.09-.08 1.58-.23.49-.15.91-.38 1.26-.68.36-.3.64-.66.84-1.1.2-.43.3-.93.3-1.48 0-.29-.04-.58-.11-.86-.08-.25-.19-.51-.35-.76zm9.26 1.4c-.14-.28-.35-.53-.63-.74-.28-.21-.61-.39-1.01-.53s-.85-.27-1.35-.38c-.35-.07-.64-.15-.87-.23-.23-.08-.41-.16-.55-.25-.14-.09-.23-.19-.28-.3-.05-.11-.08-.24-.08-.39s.03-.28.09-.41c.06-.13.15-.25.27-.34.12-.1.27-.18.45-.24s.4-.09.64-.09c.25 0 .47.04.66.11.19.07.35.17.48.29.13.12.22.26.29.42.06.16.1.32.1.49h1.95c0-.39-.08-.75-.24-1.09-.16-.34-.39-.63-.69-.88-.3-.25-.66-.44-1.09-.59-.43-.15-.92-.22-1.46-.22-.51 0-.98.07-1.39.21-.41.14-.77.33-1.06.57-.29.24-.51.52-.67.84-.16.32-.23.65-.23 1.01s.08.68.23.96c.15.28.37.52.64.73.27.21.6.38.98.53.38.14.81.26 1.27.36.39.08.71.17.95.26s.43.19.57.29c.13.1.22.22.27.34.05.12.07.25.07.39 0 .32-.13.57-.4.77-.27.2-.66.29-1.17.29-.22 0-.43-.02-.64-.08-.21-.05-.4-.13-.56-.24-.17-.11-.3-.26-.41-.44-.11-.18-.17-.41-.18-.67h-1.89c0 .36.08.71.24 1.05.16.34.39.65.7.93.31.27.69.49 1.15.66.46.17.98.25 1.58.25.53 0 1.01-.06 1.44-.19.43-.13.8-.31 1.11-.54.31-.23.54-.51.71-.83.17-.32.25-.67.25-1.06-.02-.4-.09-.74-.24-1.02z"></path></g>
<g id="timer-off"><path d="M19.04 4.55l-1.42 1.42C16.07 4.74 14.12 4 12 4c-1.83 0-3.53.55-4.95 1.48l1.46 1.46C9.53 6.35 10.73 6 12 6c3.87 0 7 3.13 7 7 0 1.27-.35 2.47-.94 3.49l1.45 1.45C20.45 16.53 21 14.83 21 13c0-2.12-.74-4.07-1.97-5.61l1.42-1.42-1.41-1.42zM15 1H9v2h6V1zm-4 8.44l2 2V8h-2v1.44zM3.02 4L1.75 5.27 4.5 8.03C3.55 9.45 3 11.16 3 13c0 4.97 4.02 9 9 9 1.84 0 3.55-.55 4.98-1.5l2.5 2.5 1.27-1.27-7.71-7.71L3.02 4zM12 20c-3.87 0-7-3.13-7-7 0-1.28.35-2.48.95-3.52l9.56 9.56c-1.03.61-2.23.96-3.51.96z"></path></g>
<g id="tonality"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm-1 17.93c-3.94-.49-7-3.85-7-7.93s3.05-7.44 7-7.93v15.86zm2-15.86c1.03.13 2 .45 2.87.93H13v-.93zM13 7h5.24c.25.31.48.65.68 1H13V7zm0 3h6.74c.08.33.15.66.19 1H13v-1zm0 9.93V19h2.87c-.87.48-1.84.8-2.87.93zM18.24 17H13v-1h5.92c-.2.35-.43.69-.68 1zm1.5-3H13v-1h6.93c-.04.34-.11.67-.19 1z"></path></g>
<g id="transform"><path d="M22 18v-2H8V4h2L7 1 4 4h2v2H2v2h4v8c0 1.1.9 2 2 2h8v2h-2l3 3 3-3h-2v-2h4zM10 8h6v6h2V8c0-1.1-.9-2-2-2h-6v2z"></path></g>
<g id="tune"><path d="M3 17v2h6v-2H3zM3 5v2h10V5H3zm10 16v-2h8v-2h-8v-2h-2v6h2zM7 9v2H3v2h4v2h2V9H7zm14 4v-2H11v2h10zm-6-4h2V7h4V5h-4V3h-2v6z"></path></g>
<g id="view-comfy"><path d="M3 9h4V5H3v4zm0 5h4v-4H3v4zm5 0h4v-4H8v4zm5 0h4v-4h-4v4zM8 9h4V5H8v4zm5-4v4h4V5h-4zm5 9h4v-4h-4v4zM3 19h4v-4H3v4zm5 0h4v-4H8v4zm5 0h4v-4h-4v4zm5 0h4v-4h-4v4zm0-14v4h4V5h-4z"></path></g>
<g id="view-compact"><path d="M3 19h6v-7H3v7zm7 0h12v-7H10v7zM3 5v6h19V5H3z"></path></g>
<g id="vignette"><path d="M21 3H3c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-9 15c-4.42 0-8-2.69-8-6s3.58-6 8-6 8 2.69 8 6-3.58 6-8 6z"></path></g>
<g id="wb-auto"><path d="M6.85 12.65h2.3L8 9l-1.15 3.65zM22 7l-1.2 6.29L19.3 7h-1.6l-1.49 6.29L15 7h-.76C12.77 5.17 10.53 4 8 4c-4.42 0-8 3.58-8 8s3.58 8 8 8c3.13 0 5.84-1.81 7.15-4.43l.1.43H17l1.5-6.1L20 16h1.75l2.05-9H22zm-11.7 9l-.7-2H6.4l-.7 2H3.8L7 7h2l3.2 9h-1.9z"></path></g>
<g id="wb-cloudy"><path d="M19.36 10.04C18.67 6.59 15.64 4 12 4 9.11 4 6.6 5.64 5.35 8.04 2.34 8.36 0 10.91 0 14c0 3.31 2.69 6 6 6h13c2.76 0 5-2.24 5-5 0-2.64-2.05-4.78-4.64-4.96z"></path></g>
<g id="wb-incandescent"><path d="M3.55 18.54l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8zM11 22.45h2V19.5h-2v2.95zM4 10.5H1v2h3v-2zm11-4.19V1.5H9v4.81C7.21 7.35 6 9.28 6 11.5c0 3.31 2.69 6 6 6s6-2.69 6-6c0-2.22-1.21-4.15-3-5.19zm5 4.19v2h3v-2h-3zm-2.76 7.66l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4z"></path></g>
<g id="wb-iridescent"><path d="M5 14.5h14v-6H5v6zM11 .55V3.5h2V.55h-2zm8.04 2.5l-1.79 1.79 1.41 1.41 1.8-1.79-1.42-1.41zM13 22.45V19.5h-2v2.95h2zm7.45-3.91l-1.8-1.79-1.41 1.41 1.79 1.8 1.42-1.42zM3.55 4.46l1.79 1.79 1.41-1.41-1.79-1.79-1.41 1.41zm1.41 15.49l1.79-1.8-1.41-1.41-1.79 1.79 1.41 1.42z"></path></g>
<g id="wb-sunny"><path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"></path></g>
</defs></svg>
</iron-iconset-svg>`;document.head.appendChild(ybe.content);var vbe=Q`<iron-iconset-svg name="icons" size="24">
<svg><defs>
<g id="3d-rotation"><path d="M7.52 21.48C4.25 19.94 1.91 16.76 1.55 13H.05C.56 19.16 5.71 24 12 24l.66-.03-3.81-3.81-1.33 1.32zm.89-6.52c-.19 0-.37-.03-.52-.08-.16-.06-.29-.13-.4-.24-.11-.1-.2-.22-.26-.37-.06-.14-.09-.3-.09-.47h-1.3c0 .36.07.68.21.95.14.27.33.5.56.69.24.18.51.32.82.41.3.1.62.15.96.15.37 0 .72-.05 1.03-.15.32-.1.6-.25.83-.44s.42-.43.55-.72c.13-.29.2-.61.2-.97 0-.19-.02-.38-.07-.56-.05-.18-.12-.35-.23-.51-.1-.16-.24-.3-.4-.43-.17-.13-.37-.23-.61-.31.2-.09.37-.2.52-.33.15-.13.27-.27.37-.42.1-.15.17-.3.22-.46.05-.16.07-.32.07-.48 0-.36-.06-.68-.18-.96-.12-.28-.29-.51-.51-.69-.2-.19-.47-.33-.77-.43C9.1 8.05 8.76 8 8.39 8c-.36 0-.69.05-1 .16-.3.11-.57.26-.79.45-.21.19-.38.41-.51.67-.12.26-.18.54-.18.85h1.3c0-.17.03-.32.09-.45s.14-.25.25-.34c.11-.09.23-.17.38-.22.15-.05.3-.08.48-.08.4 0 .7.1.89.31.19.2.29.49.29.86 0 .18-.03.34-.08.49-.05.15-.14.27-.25.37-.11.1-.25.18-.41.24-.16.06-.36.09-.58.09H7.5v1.03h.77c.22 0 .42.02.6.07s.33.13.45.23c.12.11.22.24.29.4.07.16.1.35.1.57 0 .41-.12.72-.35.93-.23.23-.55.33-.95.33zm8.55-5.92c-.32-.33-.7-.59-1.14-.77-.43-.18-.92-.27-1.46-.27H12v8h2.3c.55 0 1.06-.09 1.51-.27.45-.18.84-.43 1.16-.76.32-.33.57-.73.74-1.19.17-.47.26-.99.26-1.57v-.4c0-.58-.09-1.1-.26-1.57-.18-.47-.43-.87-.75-1.2zm-.39 3.16c0 .42-.05.79-.14 1.13-.1.33-.24.62-.43.85-.19.23-.43.41-.71.53-.29.12-.62.18-.99.18h-.91V9.12h.97c.72 0 1.27.23 1.64.69.38.46.57 1.12.57 1.99v.4zM12 0l-.66.03 3.81 3.81 1.33-1.33c3.27 1.55 5.61 4.72 5.96 8.48h1.5C23.44 4.84 18.29 0 12 0z"></path></g>
<g id="accessibility"><path d="M12 2c1.1 0 2 .9 2 2s-.9 2-2 2-2-.9-2-2 .9-2 2-2zm9 7h-6v13h-2v-6h-2v6H9V9H3V7h18v2z"></path></g>
<g id="accessible"><circle cx="12" cy="4" r="2"></circle><path d="M19 13v-2c-1.54.02-3.09-.75-4.07-1.83l-1.29-1.43c-.17-.19-.38-.34-.61-.45-.01 0-.01-.01-.02-.01H13c-.35-.2-.75-.3-1.19-.26C10.76 7.11 10 8.04 10 9.09V15c0 1.1.9 2 2 2h5v5h2v-5.5c0-1.1-.9-2-2-2h-3v-3.45c1.29 1.07 3.25 1.94 5 1.95zm-6.17 5c-.41 1.16-1.52 2-2.83 2-1.66 0-3-1.34-3-3 0-1.31.84-2.41 2-2.83V12.1c-2.28.46-4 2.48-4 4.9 0 2.76 2.24 5 5 5 2.42 0 4.44-1.72 4.9-4h-2.07z"></path></g>
<g id="account-balance"><path d="M4 10v7h3v-7H4zm6 0v7h3v-7h-3zM2 22h19v-3H2v3zm14-12v7h3v-7h-3zm-4.5-9L2 6v2h19V6l-9.5-5z"></path></g>
<g id="account-balance-wallet"><path d="M21 18v1c0 1.1-.9 2-2 2H5c-1.11 0-2-.9-2-2V5c0-1.1.89-2 2-2h14c1.1 0 2 .9 2 2v1h-9c-1.11 0-2 .9-2 2v8c0 1.1.89 2 2 2h9zm-9-2h10V8H12v8zm4-2.5c-.83 0-1.5-.67-1.5-1.5s.67-1.5 1.5-1.5 1.5.67 1.5 1.5-.67 1.5-1.5 1.5z"></path></g>
<g id="account-box"><path d="M3 5v14c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2H5c-1.11 0-2 .9-2 2zm12 4c0 1.66-1.34 3-3 3s-3-1.34-3-3 1.34-3 3-3 3 1.34 3 3zm-9 8c0-2 4-3.1 6-3.1s6 1.1 6 3.1v1H6v-1z"></path></g>
<g id="account-circle"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 3c1.66 0 3 1.34 3 3s-1.34 3-3 3-3-1.34-3-3 1.34-3 3-3zm0 14.2c-2.5 0-4.71-1.28-6-3.22.03-1.99 4-3.08 6-3.08 1.99 0 5.97 1.09 6 3.08-1.29 1.94-3.5 3.22-6 3.22z"></path></g>
<g id="add"><path d="M19 13h-6v6h-2v-6H5v-2h6V5h2v6h6v2z"></path></g>
<g id="add-alert"><path d="M10.01 21.01c0 1.1.89 1.99 1.99 1.99s1.99-.89 1.99-1.99h-3.98zm8.87-4.19V11c0-3.25-2.25-5.97-5.29-6.69v-.72C13.59 2.71 12.88 2 12 2s-1.59.71-1.59 1.59v.72C7.37 5.03 5.12 7.75 5.12 11v5.82L3 18.94V20h18v-1.06l-2.12-2.12zM16 13.01h-3v3h-2v-3H8V11h3V8h2v3h3v2.01z"></path></g>
<g id="add-box"><path d="M19 3H5c-1.11 0-2 .9-2 2v14c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-2 10h-4v4h-2v-4H7v-2h4V7h2v4h4v2z"></path></g>
<g id="add-circle"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm5 11h-4v4h-2v-4H7v-2h4V7h2v4h4v2z"></path></g>
<g id="add-circle-outline"><path d="M13 7h-2v4H7v2h4v4h2v-4h4v-2h-4V7zm-1-5C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8z"></path></g>
<g id="add-shopping-cart"><path d="M11 9h2V6h3V4h-3V1h-2v3H8v2h3v3zm-4 9c-1.1 0-1.99.9-1.99 2S5.9 22 7 22s2-.9 2-2-.9-2-2-2zm10 0c-1.1 0-1.99.9-1.99 2s.89 2 1.99 2 2-.9 2-2-.9-2-2-2zm-9.83-3.25l.03-.12.9-1.63h7.45c.75 0 1.41-.41 1.75-1.03l3.86-7.01L19.42 4h-.01l-1.1 2-2.76 5H8.53l-.13-.27L6.16 6l-.95-2-.94-2H1v2h2l3.6 7.59-1.35 2.45c-.16.28-.25.61-.25.96 0 1.1.9 2 2 2h12v-2H7.42c-.13 0-.25-.11-.25-.25z"></path></g>
<g id="alarm"><path d="M22 5.72l-4.6-3.86-1.29 1.53 4.6 3.86L22 5.72zM7.88 3.39L6.6 1.86 2 5.71l1.29 1.53 4.59-3.85zM12.5 8H11v6l4.75 2.85.75-1.23-4-2.37V8zM12 4c-4.97 0-9 4.03-9 9s4.02 9 9 9c4.97 0 9-4.03 9-9s-4.03-9-9-9zm0 16c-3.87 0-7-3.13-7-7s3.13-7 7-7 7 3.13 7 7-3.13 7-7 7z"></path></g>
<g id="alarm-add"><path d="M7.88 3.39L6.6 1.86 2 5.71l1.29 1.53 4.59-3.85zM22 5.72l-4.6-3.86-1.29 1.53 4.6 3.86L22 5.72zM12 4c-4.97 0-9 4.03-9 9s4.02 9 9 9c4.97 0 9-4.03 9-9s-4.03-9-9-9zm0 16c-3.87 0-7-3.13-7-7s3.13-7 7-7 7 3.13 7 7-3.13 7-7 7zm1-11h-2v3H8v2h3v3h2v-3h3v-2h-3V9z"></path></g>
<g id="alarm-off"><path d="M12 6c3.87 0 7 3.13 7 7 0 .84-.16 1.65-.43 2.4l1.52 1.52c.58-1.19.91-2.51.91-3.92 0-4.97-4.03-9-9-9-1.41 0-2.73.33-3.92.91L9.6 6.43C10.35 6.16 11.16 6 12 6zm10-.28l-4.6-3.86-1.29 1.53 4.6 3.86L22 5.72zM2.92 2.29L1.65 3.57 2.98 4.9l-1.11.93 1.42 1.42 1.11-.94.8.8C3.83 8.69 3 10.75 3 13c0 4.97 4.02 9 9 9 2.25 0 4.31-.83 5.89-2.2l2.2 2.2 1.27-1.27L3.89 3.27l-.97-.98zm13.55 16.1C15.26 19.39 13.7 20 12 20c-3.87 0-7-3.13-7-7 0-1.7.61-3.26 1.61-4.47l9.86 9.86zM8.02 3.28L6.6 1.86l-.86.71 1.42 1.42.86-.71z"></path></g>
<g id="alarm-on"><path d="M22 5.72l-4.6-3.86-1.29 1.53 4.6 3.86L22 5.72zM7.88 3.39L6.6 1.86 2 5.71l1.29 1.53 4.59-3.85zM12 4c-4.97 0-9 4.03-9 9s4.02 9 9 9c4.97 0 9-4.03 9-9s-4.03-9-9-9zm0 16c-3.87 0-7-3.13-7-7s3.13-7 7-7 7 3.13 7 7-3.13 7-7 7zm-1.46-5.47L8.41 12.4l-1.06 1.06 3.18 3.18 6-6-1.06-1.06-4.93 4.95z"></path></g>
<g id="all-out"><path d="M16.21 4.16l4 4v-4zm4 12l-4 4h4zm-12 4l-4-4v4zm-4-12l4-4h-4zm12.95-.95c-2.73-2.73-7.17-2.73-9.9 0s-2.73 7.17 0 9.9 7.17 2.73 9.9 0 2.73-7.16 0-9.9zm-1.1 8.8c-2.13 2.13-5.57 2.13-7.7 0s-2.13-5.57 0-7.7 5.57-2.13 7.7 0 2.13 5.57 0 7.7z"></path></g>
<g id="android"><path d="M6 18c0 .55.45 1 1 1h1v3.5c0 .83.67 1.5 1.5 1.5s1.5-.67 1.5-1.5V19h2v3.5c0 .83.67 1.5 1.5 1.5s1.5-.67 1.5-1.5V19h1c.55 0 1-.45 1-1V8H6v10zM3.5 8C2.67 8 2 8.67 2 9.5v7c0 .83.67 1.5 1.5 1.5S5 17.33 5 16.5v-7C5 8.67 4.33 8 3.5 8zm17 0c-.83 0-1.5.67-1.5 1.5v7c0 .83.67 1.5 1.5 1.5s1.5-.67 1.5-1.5v-7c0-.83-.67-1.5-1.5-1.5zm-4.97-5.84l1.3-1.3c.2-.2.2-.51 0-.71-.2-.2-.51-.2-.71 0l-1.48 1.48C13.85 1.23 12.95 1 12 1c-.96 0-1.86.23-2.66.63L7.85.15c-.2-.2-.51-.2-.71 0-.2.2-.2.51 0 .71l1.31 1.31C6.97 3.26 6 5.01 6 7h12c0-1.99-.97-3.75-2.47-4.84zM10 5H9V4h1v1zm5 0h-1V4h1v1z"></path></g>
<g id="announcement"><path d="M20 2H4c-1.1 0-1.99.9-1.99 2L2 22l4-4h14c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zm-7 9h-2V5h2v6zm0 4h-2v-2h2v2z"></path></g>
<g id="apps"><path d="M4 8h4V4H4v4zm6 12h4v-4h-4v4zm-6 0h4v-4H4v4zm0-6h4v-4H4v4zm6 0h4v-4h-4v4zm6-10v4h4V4h-4zm-6 4h4V4h-4v4zm6 6h4v-4h-4v4zm0 6h4v-4h-4v4z"></path></g>
<g id="archive"><path d="M20.54 5.23l-1.39-1.68C18.88 3.21 18.47 3 18 3H6c-.47 0-.88.21-1.16.55L3.46 5.23C3.17 5.57 3 6.02 3 6.5V19c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V6.5c0-.48-.17-.93-.46-1.27zM12 17.5L6.5 12H10v-2h4v2h3.5L12 17.5zM5.12 5l.81-1h12l.94 1H5.12z"></path></g>
<g id="arrow-back"><path d="M20 11H7.83l5.59-5.59L12 4l-8 8 8 8 1.41-1.41L7.83 13H20v-2z"></path></g>
<g id="arrow-downward"><path d="M20 12l-1.41-1.41L13 16.17V4h-2v12.17l-5.58-5.59L4 12l8 8 8-8z"></path></g>
<g id="arrow-drop-down"><path d="M7 10l5 5 5-5z"></path></g>
<g id="arrow-drop-down-circle"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 12l-4-4h8l-4 4z"></path></g>
<g id="arrow-drop-up"><path d="M7 14l5-5 5 5z"></path></g>
<g id="arrow-forward"><path d="M12 4l-1.41 1.41L16.17 11H4v2h12.17l-5.58 5.59L12 20l8-8z"></path></g>
<g id="arrow-upward"><path d="M4 12l1.41 1.41L11 7.83V20h2V7.83l5.58 5.59L20 12l-8-8-8 8z"></path></g>
<g id="aspect-ratio"><path d="M19 12h-2v3h-3v2h5v-5zM7 9h3V7H5v5h2V9zm14-6H3c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16.01H3V4.99h18v14.02z"></path></g>
<g id="assessment"><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z"></path></g>
<g id="assignment"><path d="M19 3h-4.18C14.4 1.84 13.3 1 12 1c-1.3 0-2.4.84-2.82 2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-7 0c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm2 14H7v-2h7v2zm3-4H7v-2h10v2zm0-4H7V7h10v2z"></path></g>
<g id="assignment-ind"><path d="M19 3h-4.18C14.4 1.84 13.3 1 12 1c-1.3 0-2.4.84-2.82 2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-7 0c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm0 4c1.66 0 3 1.34 3 3s-1.34 3-3 3-3-1.34-3-3 1.34-3 3-3zm6 12H6v-1.4c0-2 4-3.1 6-3.1s6 1.1 6 3.1V19z"></path></g>
<g id="assignment-late"><path d="M19 3h-4.18C14.4 1.84 13.3 1 12 1c-1.3 0-2.4.84-2.82 2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-6 15h-2v-2h2v2zm0-4h-2V8h2v6zm-1-9c-.55 0-1-.45-1-1s.45-1 1-1 1 .45 1 1-.45 1-1 1z"></path></g>
<g id="assignment-return"><path d="M19 3h-4.18C14.4 1.84 13.3 1 12 1c-1.3 0-2.4.84-2.82 2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-7 0c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm4 12h-4v3l-5-5 5-5v3h4v4z"></path></g>
<g id="assignment-returned"><path d="M19 3h-4.18C14.4 1.84 13.3 1 12 1c-1.3 0-2.4.84-2.82 2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-7 0c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm0 15l-5-5h3V9h4v4h3l-5 5z"></path></g>
<g id="assignment-turned-in"><path d="M19 3h-4.18C14.4 1.84 13.3 1 12 1c-1.3 0-2.4.84-2.82 2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-7 0c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm-2 14l-4-4 1.41-1.41L10 14.17l6.59-6.59L18 9l-8 8z"></path></g>
<g id="attachment"><path d="M2 12.5C2 9.46 4.46 7 7.5 7H18c2.21 0 4 1.79 4 4s-1.79 4-4 4H9.5C8.12 15 7 13.88 7 12.5S8.12 10 9.5 10H17v2H9.41c-.55 0-.55 1 0 1H18c1.1 0 2-.9 2-2s-.9-2-2-2H7.5C5.57 9 4 10.57 4 12.5S5.57 16 7.5 16H17v2H7.5C4.46 18 2 15.54 2 12.5z"></path></g>
<g id="autorenew"><path d="M12 6v3l4-4-4-4v3c-4.42 0-8 3.58-8 8 0 1.57.46 3.03 1.24 4.26L6.7 14.8c-.45-.83-.7-1.79-.7-2.8 0-3.31 2.69-6 6-6zm6.76 1.74L17.3 9.2c.44.84.7 1.79.7 2.8 0 3.31-2.69 6-6 6v-3l-4 4 4 4v-3c4.42 0 8-3.58 8-8 0-1.57-.46-3.03-1.24-4.26z"></path></g>
<g id="backspace"><path d="M22 3H7c-.69 0-1.23.35-1.59.88L0 12l5.41 8.11c.36.53.9.89 1.59.89h15c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-3 12.59L17.59 17 14 13.41 10.41 17 9 15.59 12.59 12 9 8.41 10.41 7 14 10.59 17.59 7 19 8.41 15.41 12 19 15.59z"></path></g>
<g id="backup"><path d="M19.35 10.04C18.67 6.59 15.64 4 12 4 9.11 4 6.6 5.64 5.35 8.04 2.34 8.36 0 10.91 0 14c0 3.31 2.69 6 6 6h13c2.76 0 5-2.24 5-5 0-2.64-2.05-4.78-4.65-4.96zM14 13v4h-4v-4H7l5-5 5 5h-3z"></path></g>
<g id="block"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zM4 12c0-4.42 3.58-8 8-8 1.85 0 3.55.63 4.9 1.69L5.69 16.9C4.63 15.55 4 13.85 4 12zm8 8c-1.85 0-3.55-.63-4.9-1.69L18.31 7.1C19.37 8.45 20 10.15 20 12c0 4.42-3.58 8-8 8z"></path></g>
<g id="book"><path d="M18 2H6c-1.1 0-2 .9-2 2v16c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zM6 4h5v8l-2.5-1.5L6 12V4z"></path></g>
<g id="bookmark"><path d="M17 3H7c-1.1 0-1.99.9-1.99 2L5 21l7-3 7 3V5c0-1.1-.9-2-2-2z"></path></g>
<g id="bookmark-border"><path d="M17 3H7c-1.1 0-1.99.9-1.99 2L5 21l7-3 7 3V5c0-1.1-.9-2-2-2zm0 15l-5-2.18L7 18V5h10v13z"></path></g>
<g id="bug-report"><path d="M20 8h-2.81c-.45-.78-1.07-1.45-1.82-1.96L17 4.41 15.59 3l-2.17 2.17C12.96 5.06 12.49 5 12 5c-.49 0-.96.06-1.41.17L8.41 3 7 4.41l1.62 1.63C7.88 6.55 7.26 7.22 6.81 8H4v2h2.09c-.05.33-.09.66-.09 1v1H4v2h2v1c0 .34.04.67.09 1H4v2h2.81c1.04 1.79 2.97 3 5.19 3s4.15-1.21 5.19-3H20v-2h-2.09c.05-.33.09-.66.09-1v-1h2v-2h-2v-1c0-.34-.04-.67-.09-1H20V8zm-6 8h-4v-2h4v2zm0-4h-4v-2h4v2z"></path></g>
<g id="build"><path d="M22.7 19l-9.1-9.1c.9-2.3.4-5-1.5-6.9-2-2-5-2.4-7.4-1.3L9 6 6 9 1.6 4.7C.4 7.1.9 10.1 2.9 12.1c1.9 1.9 4.6 2.4 6.9 1.5l9.1 9.1c.4.4 1 .4 1.4 0l2.3-2.3c.5-.4.5-1.1.1-1.4z"></path></g>
<g id="cached"><path d="M19 8l-4 4h3c0 3.31-2.69 6-6 6-1.01 0-1.97-.25-2.8-.7l-1.46 1.46C8.97 19.54 10.43 20 12 20c4.42 0 8-3.58 8-8h3l-4-4zM6 12c0-3.31 2.69-6 6-6 1.01 0 1.97.25 2.8.7l1.46-1.46C15.03 4.46 13.57 4 12 4c-4.42 0-8 3.58-8 8H1l4 4 4-4H6z"></path></g>
<g id="camera-enhance"><path d="M9 3L7.17 5H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2h-3.17L15 3H9zm3 15c-2.76 0-5-2.24-5-5s2.24-5 5-5 5 2.24 5 5-2.24 5-5 5zm0-1l1.25-2.75L16 13l-2.75-1.25L12 9l-1.25 2.75L8 13l2.75 1.25z"></path></g>
<g id="cancel"><path d="M12 2C6.47 2 2 6.47 2 12s4.47 10 10 10 10-4.47 10-10S17.53 2 12 2zm5 13.59L15.59 17 12 13.41 8.41 17 7 15.59 10.59 12 7 8.41 8.41 7 12 10.59 15.59 7 17 8.41 13.41 12 17 15.59z"></path></g>
<g id="card-giftcard"><path d="M20 6h-2.18c.11-.31.18-.65.18-1 0-1.66-1.34-3-3-3-1.05 0-1.96.54-2.5 1.35l-.5.67-.5-.68C10.96 2.54 10.05 2 9 2 7.34 2 6 3.34 6 5c0 .35.07.69.18 1H4c-1.11 0-1.99.89-1.99 2L2 19c0 1.11.89 2 2 2h16c1.11 0 2-.89 2-2V8c0-1.11-.89-2-2-2zm-5-2c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zM9 4c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm11 15H4v-2h16v2zm0-5H4V8h5.08L7 10.83 8.62 12 11 8.76l1-1.36 1 1.36L15.38 12 17 10.83 14.92 8H20v6z"></path></g>
<g id="card-membership"><path d="M20 2H4c-1.11 0-2 .89-2 2v11c0 1.11.89 2 2 2h4v5l4-2 4 2v-5h4c1.11 0 2-.89 2-2V4c0-1.11-.89-2-2-2zm0 13H4v-2h16v2zm0-5H4V4h16v6z"></path></g>
<g id="card-travel"><path d="M20 6h-3V4c0-1.11-.89-2-2-2H9c-1.11 0-2 .89-2 2v2H4c-1.11 0-2 .89-2 2v11c0 1.11.89 2 2 2h16c1.11 0 2-.89 2-2V8c0-1.11-.89-2-2-2zM9 4h6v2H9V4zm11 15H4v-2h16v2zm0-5H4V8h3v2h2V8h6v2h2V8h3v6z"></path></g>
<g id="change-history"><path d="M12 7.77L18.39 18H5.61L12 7.77M12 4L2 20h20L12 4z"></path></g>
<g id="check"><path d="M9 16.17L4.83 12l-1.42 1.41L9 19 21 7l-1.41-1.41z"></path></g>
<g id="check-box"><path d="M19 3H5c-1.11 0-2 .9-2 2v14c0 1.1.89 2 2 2h14c1.11 0 2-.9 2-2V5c0-1.1-.89-2-2-2zm-9 14l-5-5 1.41-1.41L10 14.17l7.59-7.59L19 8l-9 9z"></path></g>
<g id="check-box-outline-blank"><path d="M19 5v14H5V5h14m0-2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2z"></path></g>
<g id="check-circle"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm-2 15l-5-5 1.41-1.41L10 14.17l7.59-7.59L19 8l-9 9z"></path></g>
<g id="chevron-left"><path d="M15.41 7.41L14 6l-6 6 6 6 1.41-1.41L10.83 12z"></path></g>
<g id="chevron-right"><path d="M10 6L8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z"></path></g>
<g id="chrome-reader-mode"><path d="M13 12h7v1.5h-7zm0-2.5h7V11h-7zm0 5h7V16h-7zM21 4H3c-1.1 0-2 .9-2 2v13c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm0 15h-9V6h9v13z"></path></g>
<g id="class"><path d="M18 2H6c-1.1 0-2 .9-2 2v16c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zM6 4h5v8l-2.5-1.5L6 12V4z"></path></g>
<g id="clear"><path d="M19 6.41L17.59 5 12 10.59 6.41 5 5 6.41 10.59 12 5 17.59 6.41 19 12 13.41 17.59 19 19 17.59 13.41 12z"></path></g>
<g id="close"><path d="M19 6.41L17.59 5 12 10.59 6.41 5 5 6.41 10.59 12 5 17.59 6.41 19 12 13.41 17.59 19 19 17.59 13.41 12z"></path></g>
<g id="cloud"><path d="M19.35 10.04C18.67 6.59 15.64 4 12 4 9.11 4 6.6 5.64 5.35 8.04 2.34 8.36 0 10.91 0 14c0 3.31 2.69 6 6 6h13c2.76 0 5-2.24 5-5 0-2.64-2.05-4.78-4.65-4.96z"></path></g>
<g id="cloud-circle"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm4.5 14H8c-1.66 0-3-1.34-3-3s1.34-3 3-3l.14.01C8.58 8.28 10.13 7 12 7c2.21 0 4 1.79 4 4h.5c1.38 0 2.5 1.12 2.5 2.5S17.88 16 16.5 16z"></path></g>
<g id="cloud-done"><path d="M19.35 10.04C18.67 6.59 15.64 4 12 4 9.11 4 6.6 5.64 5.35 8.04 2.34 8.36 0 10.91 0 14c0 3.31 2.69 6 6 6h13c2.76 0 5-2.24 5-5 0-2.64-2.05-4.78-4.65-4.96zM10 17l-3.5-3.5 1.41-1.41L10 14.17 15.18 9l1.41 1.41L10 17z"></path></g>
<g id="cloud-download"><path d="M19.35 10.04C18.67 6.59 15.64 4 12 4 9.11 4 6.6 5.64 5.35 8.04 2.34 8.36 0 10.91 0 14c0 3.31 2.69 6 6 6h13c2.76 0 5-2.24 5-5 0-2.64-2.05-4.78-4.65-4.96zM17 13l-5 5-5-5h3V9h4v4h3z"></path></g>
<g id="cloud-off"><path d="M19.35 10.04C18.67 6.59 15.64 4 12 4c-1.48 0-2.85.43-4.01 1.17l1.46 1.46C10.21 6.23 11.08 6 12 6c3.04 0 5.5 2.46 5.5 5.5v.5H19c1.66 0 3 1.34 3 3 0 1.13-.64 2.11-1.56 2.62l1.45 1.45C23.16 18.16 24 16.68 24 15c0-2.64-2.05-4.78-4.65-4.96zM3 5.27l2.75 2.74C2.56 8.15 0 10.77 0 14c0 3.31 2.69 6 6 6h11.73l2 2L21 20.73 4.27 4 3 5.27zM7.73 10l8 8H6c-2.21 0-4-1.79-4-4s1.79-4 4-4h1.73z"></path></g>
<g id="cloud-queue"><path d="M19.35 10.04C18.67 6.59 15.64 4 12 4 9.11 4 6.6 5.64 5.35 8.04 2.34 8.36 0 10.91 0 14c0 3.31 2.69 6 6 6h13c2.76 0 5-2.24 5-5 0-2.64-2.05-4.78-4.65-4.96zM19 18H6c-2.21 0-4-1.79-4-4s1.79-4 4-4h.71C7.37 7.69 9.48 6 12 6c3.04 0 5.5 2.46 5.5 5.5v.5H19c1.66 0 3 1.34 3 3s-1.34 3-3 3z"></path></g>
<g id="cloud-upload"><path d="M19.35 10.04C18.67 6.59 15.64 4 12 4 9.11 4 6.6 5.64 5.35 8.04 2.34 8.36 0 10.91 0 14c0 3.31 2.69 6 6 6h13c2.76 0 5-2.24 5-5 0-2.64-2.05-4.78-4.65-4.96zM14 13v4h-4v-4H7l5-5 5 5h-3z"></path></g>
<g id="code"><path d="M9.4 16.6L4.8 12l4.6-4.6L8 6l-6 6 6 6 1.4-1.4zm5.2 0l4.6-4.6-4.6-4.6L16 6l6 6-6 6-1.4-1.4z"></path></g>
<g id="compare-arrows"><path d="M9.01 14H2v2h7.01v3L13 15l-3.99-4v3zm5.98-1v-3H22V8h-7.01V5L11 9l3.99 4z"></path></g>
<g id="content-copy"><path d="M16 1H4c-1.1 0-2 .9-2 2v14h2V3h12V1zm3 4H8c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h11c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2zm0 16H8V7h11v14z"></path></g>
<g id="content-cut"><path d="M9.64 7.64c.23-.5.36-1.05.36-1.64 0-2.21-1.79-4-4-4S2 3.79 2 6s1.79 4 4 4c.59 0 1.14-.13 1.64-.36L10 12l-2.36 2.36C7.14 14.13 6.59 14 6 14c-2.21 0-4 1.79-4 4s1.79 4 4 4 4-1.79 4-4c0-.59-.13-1.14-.36-1.64L12 14l7 7h3v-1L9.64 7.64zM6 8c-1.1 0-2-.89-2-2s.9-2 2-2 2 .89 2 2-.9 2-2 2zm0 12c-1.1 0-2-.89-2-2s.9-2 2-2 2 .89 2 2-.9 2-2 2zm6-7.5c-.28 0-.5-.22-.5-.5s.22-.5.5-.5.5.22.5.5-.22.5-.5.5zM19 3l-6 6 2 2 7-7V3z"></path></g>
<g id="content-paste"><path d="M19 2h-4.18C14.4.84 13.3 0 12 0c-1.3 0-2.4.84-2.82 2H5c-1.1 0-2 .9-2 2v16c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zm-7 0c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm7 18H5V4h2v3h10V4h2v16z"></path></g>
<g id="copyright"><path d="M10.08 10.86c.05-.33.16-.62.3-.87s.34-.46.59-.62c.24-.15.54-.22.91-.23.23.01.44.05.63.13.2.09.38.21.52.36s.25.33.34.53.13.42.14.64h1.79c-.02-.47-.11-.9-.28-1.29s-.4-.73-.7-1.01-.66-.5-1.08-.66-.88-.23-1.39-.23c-.65 0-1.22.11-1.7.34s-.88.53-1.2.92-.56.84-.71 1.36S8 11.29 8 11.87v.27c0 .58.08 1.12.23 1.64s.39.97.71 1.35.72.69 1.2.91 1.05.34 1.7.34c.47 0 .91-.08 1.32-.23s.77-.36 1.08-.63.56-.58.74-.94.29-.74.3-1.15h-1.79c-.01.21-.06.4-.15.58s-.21.33-.36.46-.32.23-.52.3c-.19.07-.39.09-.6.1-.36-.01-.66-.08-.89-.23-.25-.16-.45-.37-.59-.62s-.25-.55-.3-.88-.08-.67-.08-1v-.27c0-.35.03-.68.08-1.01zM12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8z"></path></g>
<g id="create"><path d="M3 17.25V21h3.75L17.81 9.94l-3.75-3.75L3 17.25zM20.71 7.04c.39-.39.39-1.02 0-1.41l-2.34-2.34c-.39-.39-1.02-.39-1.41 0l-1.83 1.83 3.75 3.75 1.83-1.83z"></path></g>
<g id="create-new-folder"><path d="M20 6h-8l-2-2H4c-1.11 0-1.99.89-1.99 2L2 18c0 1.11.89 2 2 2h16c1.11 0 2-.89 2-2V8c0-1.11-.89-2-2-2zm-1 8h-3v3h-2v-3h-3v-2h3V9h2v3h3v2z"></path></g>
<g id="credit-card"><path d="M20 4H4c-1.11 0-1.99.89-1.99 2L2 18c0 1.11.89 2 2 2h16c1.11 0 2-.89 2-2V6c0-1.11-.89-2-2-2zm0 14H4v-6h16v6zm0-10H4V6h16v2z"></path></g>
<g id="dashboard"><path d="M3 13h8V3H3v10zm0 8h8v-6H3v6zm10 0h8V11h-8v10zm0-18v6h8V3h-8z"></path></g>
<g id="date-range"><path d="M9 11H7v2h2v-2zm4 0h-2v2h2v-2zm4 0h-2v2h2v-2zm2-7h-1V2h-2v2H8V2H6v2H5c-1.11 0-1.99.9-1.99 2L3 20c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm0 16H5V9h14v11z"></path></g>
<g id="delete"><path d="M6 19c0 1.1.9 2 2 2h8c1.1 0 2-.9 2-2V7H6v12zM19 4h-3.5l-1-1h-5l-1 1H5v2h14V4z"></path></g>
<g id="delete-forever"><path d="M6 19c0 1.1.9 2 2 2h8c1.1 0 2-.9 2-2V7H6v12zm2.46-7.12l1.41-1.41L12 12.59l2.12-2.12 1.41 1.41L13.41 14l2.12 2.12-1.41 1.41L12 15.41l-2.12 2.12-1.41-1.41L10.59 14l-2.13-2.12zM15.5 4l-1-1h-5l-1 1H5v2h14V4z"></path></g>
<g id="delete-sweep"><path d="M15 16h4v2h-4zm0-8h7v2h-7zm0 4h6v2h-6zM3 18c0 1.1.9 2 2 2h6c1.1 0 2-.9 2-2V8H3v10zM14 5h-3l-1-1H6L5 5H2v2h12z"></path></g>
<g id="description"><path d="M14 2H6c-1.1 0-1.99.9-1.99 2L4 20c0 1.1.89 2 1.99 2H18c1.1 0 2-.9 2-2V8l-6-6zm2 16H8v-2h8v2zm0-4H8v-2h8v2zm-3-5V3.5L18.5 9H13z"></path></g>
<g id="dns"><path d="M20 13H4c-.55 0-1 .45-1 1v6c0 .55.45 1 1 1h16c.55 0 1-.45 1-1v-6c0-.55-.45-1-1-1zM7 19c-1.1 0-2-.9-2-2s.9-2 2-2 2 .9 2 2-.9 2-2 2zM20 3H4c-.55 0-1 .45-1 1v6c0 .55.45 1 1 1h16c.55 0 1-.45 1-1V4c0-.55-.45-1-1-1zM7 9c-1.1 0-2-.9-2-2s.9-2 2-2 2 .9 2 2-.9 2-2 2z"></path></g>
<g id="done"><path d="M9 16.2L4.8 12l-1.4 1.4L9 19 21 7l-1.4-1.4L9 16.2z"></path></g>
<g id="done-all"><path d="M18 7l-1.41-1.41-6.34 6.34 1.41 1.41L18 7zm4.24-1.41L11.66 16.17 7.48 12l-1.41 1.41L11.66 19l12-12-1.42-1.41zM.41 13.41L6 19l1.41-1.41L1.83 12 .41 13.41z"></path></g>
<g id="donut-large"><path d="M11 5.08V2c-5 .5-9 4.81-9 10s4 9.5 9 10v-3.08c-3-.48-6-3.4-6-6.92s3-6.44 6-6.92zM18.97 11H22c-.47-5-4-8.53-9-9v3.08C16 5.51 18.54 8 18.97 11zM13 18.92V22c5-.47 8.53-4 9-9h-3.03c-.43 3-2.97 5.49-5.97 5.92z"></path></g>
<g id="donut-small"><path d="M11 9.16V2c-5 .5-9 4.79-9 10s4 9.5 9 10v-7.16c-1-.41-2-1.52-2-2.84s1-2.43 2-2.84zM14.86 11H22c-.48-4.75-4-8.53-9-9v7.16c1 .3 1.52.98 1.86 1.84zM13 14.84V22c5-.47 8.52-4.25 9-9h-7.14c-.34.86-.86 1.54-1.86 1.84z"></path></g>
<g id="drafts"><path d="M21.99 8c0-.72-.37-1.35-.94-1.7L12 1 2.95 6.3C2.38 6.65 2 7.28 2 8v10c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2l-.01-10zM12 13L3.74 7.84 12 3l8.26 4.84L12 13z"></path></g>
<g id="eject"><path d="M5 17h14v2H5zm7-12L5.33 15h13.34z"></path></g>
<g id="error"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm1 15h-2v-2h2v2zm0-4h-2V7h2v6z"></path></g>
<g id="error-outline"><path d="M11 15h2v2h-2zm0-8h2v6h-2zm.99-5C6.47 2 2 6.48 2 12s4.47 10 9.99 10C17.52 22 22 17.52 22 12S17.52 2 11.99 2zM12 20c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8z"></path></g>
<g id="euro-symbol"><path d="M15 18.5c-2.51 0-4.68-1.42-5.76-3.5H15v-2H8.58c-.05-.33-.08-.66-.08-1s.03-.67.08-1H15V9H9.24C10.32 6.92 12.5 5.5 15 5.5c1.61 0 3.09.59 4.23 1.57L21 5.3C19.41 3.87 17.3 3 15 3c-3.92 0-7.24 2.51-8.48 6H3v2h3.06c-.04.33-.06.66-.06 1 0 .34.02.67.06 1H3v2h3.52c1.24 3.49 4.56 6 8.48 6 2.31 0 4.41-.87 6-2.3l-1.78-1.77c-1.13.98-2.6 1.57-4.22 1.57z"></path></g>
<g id="event"><path d="M17 12h-5v5h5v-5zM16 1v2H8V1H6v2H5c-1.11 0-1.99.9-1.99 2L3 19c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2h-1V1h-2zm3 18H5V8h14v11z"></path></g>
<g id="event-seat"><path d="M4 18v3h3v-3h10v3h3v-6H4zm15-8h3v3h-3zM2 10h3v3H2zm15 3H7V5c0-1.1.9-2 2-2h6c1.1 0 2 .9 2 2v8z"></path></g>
<g id="exit-to-app"><path d="M10.09 15.59L11.5 17l5-5-5-5-1.41 1.41L12.67 11H3v2h9.67l-2.58 2.59zM19 3H5c-1.11 0-2 .9-2 2v4h2V5h14v14H5v-4H3v4c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2z"></path></g>
<g id="expand-less"><path d="M12 8l-6 6 1.41 1.41L12 10.83l4.59 4.58L18 14z"></path></g>
<g id="expand-more"><path d="M16.59 8.59L12 13.17 7.41 8.59 6 10l6 6 6-6z"></path></g>
<g id="explore"><path d="M12 10.9c-.61 0-1.1.49-1.1 1.1s.49 1.1 1.1 1.1c.61 0 1.1-.49 1.1-1.1s-.49-1.1-1.1-1.1zM12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm2.19 12.19L6 18l3.81-8.19L18 6l-3.81 8.19z"></path></g>
<g id="extension"><path d="M20.5 11H19V7c0-1.1-.9-2-2-2h-4V3.5C13 2.12 11.88 1 10.5 1S8 2.12 8 3.5V5H4c-1.1 0-1.99.9-1.99 2v3.8H3.5c1.49 0 2.7 1.21 2.7 2.7s-1.21 2.7-2.7 2.7H2V20c0 1.1.9 2 2 2h3.8v-1.5c0-1.49 1.21-2.7 2.7-2.7 1.49 0 2.7 1.21 2.7 2.7V22H17c1.1 0 2-.9 2-2v-4h1.5c1.38 0 2.5-1.12 2.5-2.5S21.88 11 20.5 11z"></path></g>
<g id="face"><path d="M9 11.75c-.69 0-1.25.56-1.25 1.25s.56 1.25 1.25 1.25 1.25-.56 1.25-1.25-.56-1.25-1.25-1.25zm6 0c-.69 0-1.25.56-1.25 1.25s.56 1.25 1.25 1.25 1.25-.56 1.25-1.25-.56-1.25-1.25-1.25zM12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 0-8-3.59-8-8 0-.29.02-.58.05-.86 2.36-1.05 4.23-2.98 5.21-5.37C11.07 8.33 14.05 10 17.42 10c.78 0 1.53-.09 2.25-.26.21.71.33 1.47.33 2.26 0 4.41-3.59 8-8 8z"></path></g>
<g id="favorite"><path d="M12 21.35l-1.45-1.32C5.4 15.36 2 12.28 2 8.5 2 5.42 4.42 3 7.5 3c1.74 0 3.41.81 4.5 2.09C13.09 3.81 14.76 3 16.5 3 19.58 3 22 5.42 22 8.5c0 3.78-3.4 6.86-8.55 11.54L12 21.35z"></path></g>
<g id="favorite-border"><path d="M16.5 3c-1.74 0-3.41.81-4.5 2.09C10.91 3.81 9.24 3 7.5 3 4.42 3 2 5.42 2 8.5c0 3.78 3.4 6.86 8.55 11.54L12 21.35l1.45-1.32C18.6 15.36 22 12.28 22 8.5 22 5.42 19.58 3 16.5 3zm-4.4 15.55l-.1.1-.1-.1C7.14 14.24 4 11.39 4 8.5 4 6.5 5.5 5 7.5 5c1.54 0 3.04.99 3.57 2.36h1.87C13.46 5.99 14.96 5 16.5 5c2 0 3.5 1.5 3.5 3.5 0 2.89-3.14 5.74-7.9 10.05z"></path></g>
<g id="feedback"><path d="M20 2H4c-1.1 0-1.99.9-1.99 2L2 22l4-4h14c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zm-7 12h-2v-2h2v2zm0-4h-2V6h2v4z"></path></g>
<g id="file-download"><path d="M19 9h-4V3H9v6H5l7 7 7-7zM5 18v2h14v-2H5z"></path></g>
<g id="file-upload"><path d="M9 16h6v-6h4l-7-7-7 7h4zm-4 2h14v2H5z"></path></g>
<g id="filter-list"><path d="M10 18h4v-2h-4v2zM3 6v2h18V6H3zm3 7h12v-2H6v2z"></path></g>
<g id="find-in-page"><path d="M20 19.59V8l-6-6H6c-1.1 0-1.99.9-1.99 2L4 20c0 1.1.89 2 1.99 2H18c.45 0 .85-.15 1.19-.4l-4.43-4.43c-.8.52-1.74.83-2.76.83-2.76 0-5-2.24-5-5s2.24-5 5-5 5 2.24 5 5c0 1.02-.31 1.96-.83 2.75L20 19.59zM9 13c0 1.66 1.34 3 3 3s3-1.34 3-3-1.34-3-3-3-3 1.34-3 3z"></path></g>
<g id="find-replace"><path d="M11 6c1.38 0 2.63.56 3.54 1.46L12 10h6V4l-2.05 2.05C14.68 4.78 12.93 4 11 4c-3.53 0-6.43 2.61-6.92 6H6.1c.46-2.28 2.48-4 4.9-4zm5.64 9.14c.66-.9 1.12-1.97 1.28-3.14H15.9c-.46 2.28-2.48 4-4.9 4-1.38 0-2.63-.56-3.54-1.46L10 12H4v6l2.05-2.05C7.32 17.22 9.07 18 11 18c1.55 0 2.98-.51 4.14-1.36L20 21.49 21.49 20l-4.85-4.86z"></path></g>
<g id="fingerprint"><path d="M17.81 4.47c-.08 0-.16-.02-.23-.06C15.66 3.42 14 3 12.01 3c-1.98 0-3.86.47-5.57 1.41-.24.13-.54.04-.68-.2-.13-.24-.04-.55.2-.68C7.82 2.52 9.86 2 12.01 2c2.13 0 3.99.47 6.03 1.52.25.13.34.43.21.67-.09.18-.26.28-.44.28zM3.5 9.72c-.1 0-.2-.03-.29-.09-.23-.16-.28-.47-.12-.7.99-1.4 2.25-2.5 3.75-3.27C9.98 4.04 14 4.03 17.15 5.65c1.5.77 2.76 1.86 3.75 3.25.16.22.11.54-.12.7-.23.16-.54.11-.7-.12-.9-1.26-2.04-2.25-3.39-2.94-2.87-1.47-6.54-1.47-9.4.01-1.36.7-2.5 1.7-3.4 2.96-.08.14-.23.21-.39.21zm6.25 12.07c-.13 0-.26-.05-.35-.15-.87-.87-1.34-1.43-2.01-2.64-.69-1.23-1.05-2.73-1.05-4.34 0-2.97 2.54-5.39 5.66-5.39s5.66 2.42 5.66 5.39c0 .28-.22.5-.5.5s-.5-.22-.5-.5c0-2.42-2.09-4.39-4.66-4.39-2.57 0-4.66 1.97-4.66 4.39 0 1.44.32 2.77.93 3.85.64 1.15 1.08 1.64 1.85 2.42.19.2.19.51 0 .71-.11.1-.24.15-.37.15zm7.17-1.85c-1.19 0-2.24-.3-3.1-.89-1.49-1.01-2.38-2.65-2.38-4.39 0-.28.22-.5.5-.5s.5.22.5.5c0 1.41.72 2.74 1.94 3.56.71.48 1.54.71 2.54.71.24 0 .64-.03 1.04-.1.27-.05.53.13.58.41.05.27-.13.53-.41.58-.57.11-1.07.12-1.21.12zM14.91 22c-.04 0-.09-.01-.13-.02-1.59-.44-2.63-1.03-3.72-2.1-1.4-1.39-2.17-3.24-2.17-5.22 0-1.62 1.38-2.94 3.08-2.94 1.7 0 3.08 1.32 3.08 2.94 0 1.07.93 1.94 2.08 1.94s2.08-.87 2.08-1.94c0-3.77-3.25-6.83-7.25-6.83-2.84 0-5.44 1.58-6.61 4.03-.39.81-.59 1.76-.59 2.8 0 .78.07 2.01.67 3.61.1.26-.03.55-.29.64-.26.1-.55-.04-.64-.29-.49-1.31-.73-2.61-.73-3.96 0-1.2.23-2.29.68-3.24 1.33-2.79 4.28-4.6 7.51-4.6 4.55 0 8.25 3.51 8.25 7.83 0 1.62-1.38 2.94-3.08 2.94s-3.08-1.32-3.08-2.94c0-1.07-.93-1.94-2.08-1.94s-2.08.87-2.08 1.94c0 1.71.66 3.31 1.87 4.51.95.94 1.86 1.46 3.27 1.85.27.07.42.35.35.61-.05.23-.26.38-.47.38z"></path></g>
<g id="first-page"><path d="M18.41 16.59L13.82 12l4.59-4.59L17 6l-6 6 6 6zM6 6h2v12H6z"></path></g>
<g id="flag"><path d="M14.4 6L14 4H5v17h2v-7h5.6l.4 2h7V6z"></path></g>
<g id="flight-land"><path d="M2.5 19h19v2h-19zm7.18-5.73l4.35 1.16 5.31 1.42c.8.21 1.62-.26 1.84-1.06.21-.8-.26-1.62-1.06-1.84l-5.31-1.42-2.76-9.02L10.12 2v8.28L5.15 8.95l-.93-2.32-1.45-.39v5.17l1.6.43 5.31 1.43z"></path></g>
<g id="flight-takeoff"><path d="M2.5 19h19v2h-19zm19.57-9.36c-.21-.8-1.04-1.28-1.84-1.06L14.92 10l-6.9-6.43-1.93.51 4.14 7.17-4.97 1.33-1.97-1.54-1.45.39 1.82 3.16.77 1.33 1.6-.43 5.31-1.42 4.35-1.16L21 11.49c.81-.23 1.28-1.05 1.07-1.85z"></path></g>
<g id="flip-to-back"><path d="M9 7H7v2h2V7zm0 4H7v2h2v-2zm0-8c-1.11 0-2 .9-2 2h2V3zm4 12h-2v2h2v-2zm6-12v2h2c0-1.1-.9-2-2-2zm-6 0h-2v2h2V3zM9 17v-2H7c0 1.1.89 2 2 2zm10-4h2v-2h-2v2zm0-4h2V7h-2v2zm0 8c1.1 0 2-.9 2-2h-2v2zM5 7H3v12c0 1.1.89 2 2 2h12v-2H5V7zm10-2h2V3h-2v2zm0 12h2v-2h-2v2z"></path></g>
<g id="flip-to-front"><path d="M3 13h2v-2H3v2zm0 4h2v-2H3v2zm2 4v-2H3c0 1.1.89 2 2 2zM3 9h2V7H3v2zm12 12h2v-2h-2v2zm4-18H9c-1.11 0-2 .9-2 2v10c0 1.1.89 2 2 2h10c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 12H9V5h10v10zm-8 6h2v-2h-2v2zm-4 0h2v-2H7v2z"></path></g>
<g id="folder"><path d="M10 4H4c-1.1 0-1.99.9-1.99 2L2 18c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V8c0-1.1-.9-2-2-2h-8l-2-2z"></path></g>
<g id="folder-open"><path d="M20 6h-8l-2-2H4c-1.1 0-1.99.9-1.99 2L2 18c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V8c0-1.1-.9-2-2-2zm0 12H4V8h16v10z"></path></g>
<g id="folder-shared"><path d="M20 6h-8l-2-2H4c-1.1 0-1.99.9-1.99 2L2 18c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V8c0-1.1-.9-2-2-2zm-5 3c1.1 0 2 .9 2 2s-.9 2-2 2-2-.9-2-2 .9-2 2-2zm4 8h-8v-1c0-1.33 2.67-2 4-2s4 .67 4 2v1z"></path></g>
<g id="font-download"><path d="M9.93 13.5h4.14L12 7.98zM20 2H4c-1.1 0-2 .9-2 2v16c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zm-4.05 16.5l-1.14-3H9.17l-1.12 3H5.96l5.11-13h1.86l5.11 13h-2.09z"></path></g>
<g id="forward"><path d="M12 8V4l8 8-8 8v-4H4V8z"></path></g>
<g id="fullscreen"><path d="M7 14H5v5h5v-2H7v-3zm-2-4h2V7h3V5H5v5zm12 7h-3v2h5v-5h-2v3zM14 5v2h3v3h2V5h-5z"></path></g>
<g id="fullscreen-exit"><path d="M5 16h3v3h2v-5H5v2zm3-8H5v2h5V5H8v3zm6 11h2v-3h3v-2h-5v5zm2-11V5h-2v5h5V8h-3z"></path></g>
<g id="g-translate"><path d="M20 5h-9.12L10 2H4c-1.1 0-2 .9-2 2v13c0 1.1.9 2 2 2h7l1 3h8c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2zM7.17 14.59c-2.25 0-4.09-1.83-4.09-4.09s1.83-4.09 4.09-4.09c1.04 0 1.99.37 2.74 1.07l.07.06-1.23 1.18-.06-.05c-.29-.27-.78-.59-1.52-.59-1.31 0-2.38 1.09-2.38 2.42s1.07 2.42 2.38 2.42c1.37 0 1.96-.87 2.12-1.46H7.08V9.91h3.95l.01.07c.04.21.05.4.05.61 0 2.35-1.61 4-3.92 4zm6.03-1.71c.33.6.74 1.18 1.19 1.7l-.54.53-.65-2.23zm.77-.76h-.99l-.31-1.04h3.99s-.34 1.31-1.56 2.74c-.52-.62-.89-1.23-1.13-1.7zM21 20c0 .55-.45 1-1 1h-7l2-2-.81-2.77.92-.92L17.79 18l.73-.73-2.71-2.68c.9-1.03 1.6-2.25 1.92-3.51H19v-1.04h-3.64V9h-1.04v1.04h-1.96L11.18 6H20c.55 0 1 .45 1 1v13z"></path></g>
<g id="gavel"><path d="M1 21h12v2H1zM5.245 8.07l2.83-2.827 14.14 14.142-2.828 2.828zM12.317 1l5.657 5.656-2.83 2.83-5.654-5.66zM3.825 9.485l5.657 5.657-2.828 2.828-5.657-5.657z"></path></g>
<g id="gesture"><path d="M4.59 6.89c.7-.71 1.4-1.35 1.71-1.22.5.2 0 1.03-.3 1.52-.25.42-2.86 3.89-2.86 6.31 0 1.28.48 2.34 1.34 2.98.75.56 1.74.73 2.64.46 1.07-.31 1.95-1.4 3.06-2.77 1.21-1.49 2.83-3.44 4.08-3.44 1.63 0 1.65 1.01 1.76 1.79-3.78.64-5.38 3.67-5.38 5.37 0 1.7 1.44 3.09 3.21 3.09 1.63 0 4.29-1.33 4.69-6.1H21v-2.5h-2.47c-.15-1.65-1.09-4.2-4.03-4.2-2.25 0-4.18 1.91-4.94 2.84-.58.73-2.06 2.48-2.29 2.72-.25.3-.68.84-1.11.84-.45 0-.72-.83-.36-1.92.35-1.09 1.4-2.86 1.85-3.52.78-1.14 1.3-1.92 1.3-3.28C8.95 3.69 7.31 3 6.44 3 5.12 3 3.97 4 3.72 4.25c-.36.36-.66.66-.88.93l1.75 1.71zm9.29 11.66c-.31 0-.74-.26-.74-.72 0-.6.73-2.2 2.87-2.76-.3 2.69-1.43 3.48-2.13 3.48z"></path></g>
<g id="get-app"><path d="M19 9h-4V3H9v6H5l7 7 7-7zM5 18v2h14v-2H5z"></path></g>
<g id="gif"><path d="M11.5 9H13v6h-1.5zM9 9H6c-.6 0-1 .5-1 1v4c0 .5.4 1 1 1h3c.6 0 1-.5 1-1v-2H8.5v1.5h-2v-3H10V10c0-.5-.4-1-1-1zm10 1.5V9h-4.5v6H16v-2h2v-1.5h-2v-1z"></path></g>
<g id="grade"><path d="M12 17.27L18.18 21l-1.64-7.03L22 9.24l-7.19-.61L12 2 9.19 8.63 2 9.24l5.46 4.73L5.82 21z"></path></g>
<g id="group-work"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zM8 17.5c-1.38 0-2.5-1.12-2.5-2.5s1.12-2.5 2.5-2.5 2.5 1.12 2.5 2.5-1.12 2.5-2.5 2.5zM9.5 8c0-1.38 1.12-2.5 2.5-2.5s2.5 1.12 2.5 2.5-1.12 2.5-2.5 2.5S9.5 9.38 9.5 8zm6.5 9.5c-1.38 0-2.5-1.12-2.5-2.5s1.12-2.5 2.5-2.5 2.5 1.12 2.5 2.5-1.12 2.5-2.5 2.5z"></path></g>
<g id="help"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm1 17h-2v-2h2v2zm2.07-7.75l-.9.92C13.45 12.9 13 13.5 13 15h-2v-.5c0-1.1.45-2.1 1.17-2.83l1.24-1.26c.37-.36.59-.86.59-1.41 0-1.1-.9-2-2-2s-2 .9-2 2H8c0-2.21 1.79-4 4-4s4 1.79 4 4c0 .88-.36 1.68-.93 2.25z"></path></g>
<g id="help-outline"><path d="M11 18h2v-2h-2v2zm1-16C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8zm0-14c-2.21 0-4 1.79-4 4h2c0-1.1.9-2 2-2s2 .9 2 2c0 2-3 1.75-3 5h2c0-2.25 3-2.5 3-5 0-2.21-1.79-4-4-4z"></path></g>
<g id="highlight-off"><path d="M14.59 8L12 10.59 9.41 8 8 9.41 10.59 12 8 14.59 9.41 16 12 13.41 14.59 16 16 14.59 13.41 12 16 9.41 14.59 8zM12 2C6.47 2 2 6.47 2 12s4.47 10 10 10 10-4.47 10-10S17.53 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8z"></path></g>
<g id="history"><path d="M13 3c-4.97 0-9 4.03-9 9H1l3.89 3.89.07.14L9 12H6c0-3.87 3.13-7 7-7s7 3.13 7 7-3.13 7-7 7c-1.93 0-3.68-.79-4.94-2.06l-1.42 1.42C8.27 19.99 10.51 21 13 21c4.97 0 9-4.03 9-9s-4.03-9-9-9zm-1 5v5l4.28 2.54.72-1.21-3.5-2.08V8H12z"></path></g>
<g id="home"><path d="M10 20v-6h4v6h5v-8h3L12 3 2 12h3v8z"></path></g>
<g id="hourglass-empty"><path d="M6 2v6h.01L6 8.01 10 12l-4 4 .01.01H6V22h12v-5.99h-.01L18 16l-4-4 4-3.99-.01-.01H18V2H6zm10 14.5V20H8v-3.5l4-4 4 4zm-4-5l-4-4V4h8v3.5l-4 4z"></path></g>
<g id="hourglass-full"><path d="M6 2v6h.01L6 8.01 10 12l-4 4 .01.01H6V22h12v-5.99h-.01L18 16l-4-4 4-3.99-.01-.01H18V2H6z"></path></g>
<g id="http"><path d="M4.5 11h-2V9H1v6h1.5v-2.5h2V15H6V9H4.5v2zm2.5-.5h1.5V15H10v-4.5h1.5V9H7v1.5zm5.5 0H14V15h1.5v-4.5H17V9h-4.5v1.5zm9-1.5H18v6h1.5v-2h2c.8 0 1.5-.7 1.5-1.5v-1c0-.8-.7-1.5-1.5-1.5zm0 2.5h-2v-1h2v1z"></path></g>
<g id="https"><path d="M18 8h-1V6c0-2.76-2.24-5-5-5S7 3.24 7 6v2H6c-1.1 0-2 .9-2 2v10c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V10c0-1.1-.9-2-2-2zm-6 9c-1.1 0-2-.9-2-2s.9-2 2-2 2 .9 2 2-.9 2-2 2zm3.1-9H8.9V6c0-1.71 1.39-3.1 3.1-3.1 1.71 0 3.1 1.39 3.1 3.1v2z"></path></g>
<g id="important-devices"><path d="M23 11.01L18 11c-.55 0-1 .45-1 1v9c0 .55.45 1 1 1h5c.55 0 1-.45 1-1v-9c0-.55-.45-.99-1-.99zM23 20h-5v-7h5v7zM20 2H2C.89 2 0 2.89 0 4v12c0 1.1.89 2 2 2h7v2H7v2h8v-2h-2v-2h2v-2H2V4h18v5h2V4c0-1.11-.9-2-2-2zm-8.03 7L11 6l-.97 3H7l2.47 1.76-.94 2.91 2.47-1.8 2.47 1.8-.94-2.91L15 9h-3.03z"></path></g>
<g id="inbox"><path d="M19 3H4.99c-1.11 0-1.98.89-1.98 2L3 19c0 1.1.88 2 1.99 2H19c1.1 0 2-.9 2-2V5c0-1.11-.9-2-2-2zm0 12h-4c0 1.66-1.35 3-3 3s-3-1.34-3-3H4.99V5H19v10z"></path></g>
<g id="indeterminate-check-box"><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-2 10H7v-2h10v2z"></path></g>
<g id="info"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm1 15h-2v-6h2v6zm0-8h-2V7h2v2z"></path></g>
<g id="info-outline"><path d="M11 17h2v-6h-2v6zm1-15C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8zM11 9h2V7h-2v2z"></path></g>
<g id="input"><path d="M21 3.01H3c-1.1 0-2 .9-2 2V9h2V4.99h18v14.03H3V15H1v4.01c0 1.1.9 1.98 2 1.98h18c1.1 0 2-.88 2-1.98v-14c0-1.11-.9-2-2-2zM11 16l4-4-4-4v3H1v2h10v3z"></path></g>
<g id="invert-colors"><path d="M17.66 7.93L12 2.27 6.34 7.93c-3.12 3.12-3.12 8.19 0 11.31C7.9 20.8 9.95 21.58 12 21.58c2.05 0 4.1-.78 5.66-2.34 3.12-3.12 3.12-8.19 0-11.31zM12 19.59c-1.6 0-3.11-.62-4.24-1.76C6.62 16.69 6 15.19 6 13.59s.62-3.11 1.76-4.24L12 5.1v14.49z"></path></g>
<g id="label"><path d="M17.63 5.84C17.27 5.33 16.67 5 16 5L5 5.01C3.9 5.01 3 5.9 3 7v10c0 1.1.9 1.99 2 1.99L16 19c.67 0 1.27-.33 1.63-.84L22 12l-4.37-6.16z"></path></g>
<g id="label-outline"><path d="M17.63 5.84C17.27 5.33 16.67 5 16 5L5 5.01C3.9 5.01 3 5.9 3 7v10c0 1.1.9 1.99 2 1.99L16 19c.67 0 1.27-.33 1.63-.84L22 12l-4.37-6.16zM16 17H5V7h11l3.55 5L16 17z"></path></g>
<g id="language"><path d="M11.99 2C6.47 2 2 6.48 2 12s4.47 10 9.99 10C17.52 22 22 17.52 22 12S17.52 2 11.99 2zm6.93 6h-2.95c-.32-1.25-.78-2.45-1.38-3.56 1.84.63 3.37 1.91 4.33 3.56zM12 4.04c.83 1.2 1.48 2.53 1.91 3.96h-3.82c.43-1.43 1.08-2.76 1.91-3.96zM4.26 14C4.1 13.36 4 12.69 4 12s.1-1.36.26-2h3.38c-.08.66-.14 1.32-.14 2 0 .68.06 1.34.14 2H4.26zm.82 2h2.95c.32 1.25.78 2.45 1.38 3.56-1.84-.63-3.37-1.9-4.33-3.56zm2.95-8H5.08c.96-1.66 2.49-2.93 4.33-3.56C8.81 5.55 8.35 6.75 8.03 8zM12 19.96c-.83-1.2-1.48-2.53-1.91-3.96h3.82c-.43 1.43-1.08 2.76-1.91 3.96zM14.34 14H9.66c-.09-.66-.16-1.32-.16-2 0-.68.07-1.35.16-2h4.68c.09.65.16 1.32.16 2 0 .68-.07 1.34-.16 2zm.25 5.56c.6-1.11 1.06-2.31 1.38-3.56h2.95c-.96 1.65-2.49 2.93-4.33 3.56zM16.36 14c.08-.66.14-1.32.14-2 0-.68-.06-1.34-.14-2h3.38c.16.64.26 1.31.26 2s-.1 1.36-.26 2h-3.38z"></path></g>
<g id="last-page"><path d="M5.59 7.41L10.18 12l-4.59 4.59L7 18l6-6-6-6zM16 6h2v12h-2z"></path></g>
<g id="launch"><path d="M19 19H5V5h7V3H5c-1.11 0-2 .9-2 2v14c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2v-7h-2v7zM14 3v2h3.59l-9.83 9.83 1.41 1.41L19 6.41V10h2V3h-7z"></path></g>
<g id="lightbulb-outline"><path d="M9 21c0 .55.45 1 1 1h4c.55 0 1-.45 1-1v-1H9v1zm3-19C8.14 2 5 5.14 5 9c0 2.38 1.19 4.47 3 5.74V17c0 .55.45 1 1 1h6c.55 0 1-.45 1-1v-2.26c1.81-1.27 3-3.36 3-5.74 0-3.86-3.14-7-7-7zm2.85 11.1l-.85.6V16h-4v-2.3l-.85-.6C7.8 12.16 7 10.63 7 9c0-2.76 2.24-5 5-5s5 2.24 5 5c0 1.63-.8 3.16-2.15 4.1z"></path></g>
<g id="line-style"><path d="M3 16h5v-2H3v2zm6.5 0h5v-2h-5v2zm6.5 0h5v-2h-5v2zM3 20h2v-2H3v2zm4 0h2v-2H7v2zm4 0h2v-2h-2v2zm4 0h2v-2h-2v2zm4 0h2v-2h-2v2zM3 12h8v-2H3v2zm10 0h8v-2h-8v2zM3 4v4h18V4H3z"></path></g>
<g id="line-weight"><path d="M3 17h18v-2H3v2zm0 3h18v-1H3v1zm0-7h18v-3H3v3zm0-9v4h18V4H3z"></path></g>
<g id="link"><path d="M3.9 12c0-1.71 1.39-3.1 3.1-3.1h4V7H7c-2.76 0-5 2.24-5 5s2.24 5 5 5h4v-1.9H7c-1.71 0-3.1-1.39-3.1-3.1zM8 13h8v-2H8v2zm9-6h-4v1.9h4c1.71 0 3.1 1.39 3.1 3.1s-1.39 3.1-3.1 3.1h-4V17h4c2.76 0 5-2.24 5-5s-2.24-5-5-5z"></path></g>
<g id="list"><path d="M3 13h2v-2H3v2zm0 4h2v-2H3v2zm0-8h2V7H3v2zm4 4h14v-2H7v2zm0 4h14v-2H7v2zM7 7v2h14V7H7z"></path></g>
<g id="lock"><path d="M18 8h-1V6c0-2.76-2.24-5-5-5S7 3.24 7 6v2H6c-1.1 0-2 .9-2 2v10c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V10c0-1.1-.9-2-2-2zm-6 9c-1.1 0-2-.9-2-2s.9-2 2-2 2 .9 2 2-.9 2-2 2zm3.1-9H8.9V6c0-1.71 1.39-3.1 3.1-3.1 1.71 0 3.1 1.39 3.1 3.1v2z"></path></g>
<g id="lock-open"><path d="M12 17c1.1 0 2-.9 2-2s-.9-2-2-2-2 .9-2 2 .9 2 2 2zm6-9h-1V6c0-2.76-2.24-5-5-5S7 3.24 7 6h1.9c0-1.71 1.39-3.1 3.1-3.1 1.71 0 3.1 1.39 3.1 3.1v2H6c-1.1 0-2 .9-2 2v10c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V10c0-1.1-.9-2-2-2zm0 12H6V10h12v10z"></path></g>
<g id="lock-outline"><path d="M12 17c1.1 0 2-.9 2-2s-.9-2-2-2-2 .9-2 2 .9 2 2 2zm6-9h-1V6c0-2.76-2.24-5-5-5S7 3.24 7 6v2H6c-1.1 0-2 .9-2 2v10c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V10c0-1.1-.9-2-2-2zM8.9 6c0-1.71 1.39-3.1 3.1-3.1s3.1 1.39 3.1 3.1v2H8.9V6zM18 20H6V10h12v10z"></path></g>
<g id="low-priority"><path d="M14 5h8v2h-8zm0 5.5h8v2h-8zm0 5.5h8v2h-8zM2 11.5C2 15.08 4.92 18 8.5 18H9v2l3-3-3-3v2h-.5C6.02 16 4 13.98 4 11.5S6.02 7 8.5 7H12V5H8.5C4.92 5 2 7.92 2 11.5z"></path></g>
<g id="loyalty"><path d="M21.41 11.58l-9-9C12.05 2.22 11.55 2 11 2H4c-1.1 0-2 .9-2 2v7c0 .55.22 1.05.59 1.42l9 9c.36.36.86.58 1.41.58.55 0 1.05-.22 1.41-.59l7-7c.37-.36.59-.86.59-1.41 0-.55-.23-1.06-.59-1.42zM5.5 7C4.67 7 4 6.33 4 5.5S4.67 4 5.5 4 7 4.67 7 5.5 6.33 7 5.5 7zm11.77 8.27L13 19.54l-4.27-4.27C8.28 14.81 8 14.19 8 13.5c0-1.38 1.12-2.5 2.5-2.5.69 0 1.32.28 1.77.74l.73.72.73-.73c.45-.45 1.08-.73 1.77-.73 1.38 0 2.5 1.12 2.5 2.5 0 .69-.28 1.32-.73 1.77z"></path></g>
<g id="mail"><path d="M20 4H4c-1.1 0-1.99.9-1.99 2L2 18c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm0 4l-8 5-8-5V6l8 5 8-5v2z"></path></g>
<g id="markunread"><path d="M20 4H4c-1.1 0-1.99.9-1.99 2L2 18c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm0 4l-8 5-8-5V6l8 5 8-5v2z"></path></g>
<g id="markunread-mailbox"><path d="M20 6H10v6H8V4h6V0H6v6H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V8c0-1.1-.9-2-2-2z"></path></g>
<g id="menu"><path d="M3 18h18v-2H3v2zm0-5h18v-2H3v2zm0-7v2h18V6H3z"></path></g>
<g id="more-horiz"><path d="M6 10c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm12 0c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm-6 0c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2z"></path></g>
<g id="more-vert"><path d="M12 8c1.1 0 2-.9 2-2s-.9-2-2-2-2 .9-2 2 .9 2 2 2zm0 2c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm0 6c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2z"></path></g>
<g id="motorcycle"><path d="M19.44 9.03L15.41 5H11v2h3.59l2 2H5c-2.8 0-5 2.2-5 5s2.2 5 5 5c2.46 0 4.45-1.69 4.9-4h1.65l2.77-2.77c-.21.54-.32 1.14-.32 1.77 0 2.8 2.2 5 5 5s5-2.2 5-5c0-2.65-1.97-4.77-4.56-4.97zM7.82 15C7.4 16.15 6.28 17 5 17c-1.63 0-3-1.37-3-3s1.37-3 3-3c1.28 0 2.4.85 2.82 2H5v2h2.82zM19 17c-1.66 0-3-1.34-3-3s1.34-3 3-3 3 1.34 3 3-1.34 3-3 3z"></path></g>
<g id="move-to-inbox"><path d="M19 3H4.99c-1.11 0-1.98.9-1.98 2L3 19c0 1.1.88 2 1.99 2H19c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 12h-4c0 1.66-1.35 3-3 3s-3-1.34-3-3H4.99V5H19v10zm-3-5h-2V7h-4v3H8l4 4 4-4z"></path></g>
<g id="next-week"><path d="M20 7h-4V5c0-.55-.22-1.05-.59-1.41C15.05 3.22 14.55 3 14 3h-4c-1.1 0-2 .9-2 2v2H4c-1.1 0-2 .9-2 2v11c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V9c0-1.1-.9-2-2-2zM10 5h4v2h-4V5zm1 13.5l-1-1 3-3-3-3 1-1 4 4-4 4z"></path></g>
<g id="note-add"><path d="M14 2H6c-1.1 0-1.99.9-1.99 2L4 20c0 1.1.89 2 1.99 2H18c1.1 0 2-.9 2-2V8l-6-6zm2 14h-3v3h-2v-3H8v-2h3v-3h2v3h3v2zm-3-7V3.5L18.5 9H13z"></path></g>
<g id="offline-pin"><path d="M12 2C6.5 2 2 6.5 2 12s4.5 10 10 10 10-4.5 10-10S17.5 2 12 2zm5 16H7v-2h10v2zm-6.7-4L7 10.7l1.4-1.4 1.9 1.9 5.3-5.3L17 7.3 10.3 14z"></path></g>
<g id="opacity"><path d="M17.66 8L12 2.35 6.34 8C4.78 9.56 4 11.64 4 13.64s.78 4.11 2.34 5.67 3.61 2.35 5.66 2.35 4.1-.79 5.66-2.35S20 15.64 20 13.64 19.22 9.56 17.66 8zM6 14c.01-2 .62-3.27 1.76-4.4L12 5.27l4.24 4.38C17.38 10.77 17.99 12 18 14H6z"></path></g>
<g id="open-in-browser"><path d="M19 4H5c-1.11 0-2 .9-2 2v12c0 1.1.89 2 2 2h4v-2H5V8h14v10h-4v2h4c1.1 0 2-.9 2-2V6c0-1.1-.89-2-2-2zm-7 6l-4 4h3v6h2v-6h3l-4-4z"></path></g>
<g id="open-in-new"><path d="M19 19H5V5h7V3H5c-1.11 0-2 .9-2 2v14c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2v-7h-2v7zM14 3v2h3.59l-9.83 9.83 1.41 1.41L19 6.41V10h2V3h-7z"></path></g>
<g id="open-with"><path d="M10 9h4V6h3l-5-5-5 5h3v3zm-1 1H6V7l-5 5 5 5v-3h3v-4zm14 2l-5-5v3h-3v4h3v3l5-5zm-9 3h-4v3H7l5 5 5-5h-3v-3z"></path></g>
<g id="pageview"><path d="M11.5 9C10.12 9 9 10.12 9 11.5s1.12 2.5 2.5 2.5 2.5-1.12 2.5-2.5S12.88 9 11.5 9zM20 4H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm-3.21 14.21l-2.91-2.91c-.69.44-1.51.7-2.39.7C9.01 16 7 13.99 7 11.5S9.01 7 11.5 7 16 9.01 16 11.5c0 .88-.26 1.69-.7 2.39l2.91 2.9-1.42 1.42z"></path></g>
<g id="pan-tool"><path d="M23 5.5V20c0 2.2-1.8 4-4 4h-7.3c-1.08 0-2.1-.43-2.85-1.19L1 14.83s1.26-1.23 1.3-1.25c.22-.19.49-.29.79-.29.22 0 .42.06.6.16.04.01 4.31 2.46 4.31 2.46V4c0-.83.67-1.5 1.5-1.5S11 3.17 11 4v7h1V1.5c0-.83.67-1.5 1.5-1.5S15 .67 15 1.5V11h1V2.5c0-.83.67-1.5 1.5-1.5s1.5.67 1.5 1.5V11h1V5.5c0-.83.67-1.5 1.5-1.5s1.5.67 1.5 1.5z"></path></g>
<g id="payment"><path d="M20 4H4c-1.11 0-1.99.89-1.99 2L2 18c0 1.11.89 2 2 2h16c1.11 0 2-.89 2-2V6c0-1.11-.89-2-2-2zm0 14H4v-6h16v6zm0-10H4V6h16v2z"></path></g>
<g id="perm-camera-mic"><path d="M20 5h-3.17L15 3H9L7.17 5H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h7v-2.09c-2.83-.48-5-2.94-5-5.91h2c0 2.21 1.79 4 4 4s4-1.79 4-4h2c0 2.97-2.17 5.43-5 5.91V21h7c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2zm-6 8c0 1.1-.9 2-2 2s-2-.9-2-2V9c0-1.1.9-2 2-2s2 .9 2 2v4z"></path></g>
<g id="perm-contact-calendar"><path d="M19 3h-1V1h-2v2H8V1H6v2H5c-1.11 0-2 .9-2 2v14c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-7 3c1.66 0 3 1.34 3 3s-1.34 3-3 3-3-1.34-3-3 1.34-3 3-3zm6 12H6v-1c0-2 4-3.1 6-3.1s6 1.1 6 3.1v1z"></path></g>
<g id="perm-data-setting"><path d="M18.99 11.5c.34 0 .67.03 1 .07L20 0 0 20h11.56c-.04-.33-.07-.66-.07-1 0-4.14 3.36-7.5 7.5-7.5zm3.71 7.99c.02-.16.04-.32.04-.49 0-.17-.01-.33-.04-.49l1.06-.83c.09-.08.12-.21.06-.32l-1-1.73c-.06-.11-.19-.15-.31-.11l-1.24.5c-.26-.2-.54-.37-.85-.49l-.19-1.32c-.01-.12-.12-.21-.24-.21h-2c-.12 0-.23.09-.25.21l-.19 1.32c-.3.13-.59.29-.85.49l-1.24-.5c-.11-.04-.24 0-.31.11l-1 1.73c-.06.11-.04.24.06.32l1.06.83c-.02.16-.03.32-.03.49 0 .17.01.33.03.49l-1.06.83c-.09.08-.12.21-.06.32l1 1.73c.06.11.19.15.31.11l1.24-.5c.26.2.54.37.85.49l.19 1.32c.02.12.12.21.25.21h2c.12 0 .23-.09.25-.21l.19-1.32c.3-.13.59-.29.84-.49l1.25.5c.11.04.24 0 .31-.11l1-1.73c.06-.11.03-.24-.06-.32l-1.07-.83zm-3.71 1.01c-.83 0-1.5-.67-1.5-1.5s.67-1.5 1.5-1.5 1.5.67 1.5 1.5-.67 1.5-1.5 1.5z"></path></g>
<g id="perm-device-information"><path d="M13 7h-2v2h2V7zm0 4h-2v6h2v-6zm4-9.99L7 1c-1.1 0-2 .9-2 2v18c0 1.1.9 2 2 2h10c1.1 0 2-.9 2-2V3c0-1.1-.9-1.99-2-1.99zM17 19H7V5h10v14z"></path></g>
<g id="perm-identity"><path d="M12 5.9c1.16 0 2.1.94 2.1 2.1s-.94 2.1-2.1 2.1S9.9 9.16 9.9 8s.94-2.1 2.1-2.1m0 9c2.97 0 6.1 1.46 6.1 2.1v1.1H5.9V17c0-.64 3.13-2.1 6.1-2.1M12 4C9.79 4 8 5.79 8 8s1.79 4 4 4 4-1.79 4-4-1.79-4-4-4zm0 9c-2.67 0-8 1.34-8 4v3h16v-3c0-2.66-5.33-4-8-4z"></path></g>
<g id="perm-media"><path d="M2 6H0v5h.01L0 20c0 1.1.9 2 2 2h18v-2H2V6zm20-2h-8l-2-2H6c-1.1 0-1.99.9-1.99 2L4 16c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zM7 15l4.5-6 3.5 4.51 2.5-3.01L21 15H7z"></path></g>
<g id="perm-phone-msg"><path d="M20 15.5c-1.25 0-2.45-.2-3.57-.57-.35-.11-.74-.03-1.02.24l-2.2 2.2c-2.83-1.44-5.15-3.75-6.59-6.58l2.2-2.21c.28-.27.36-.66.25-1.01C8.7 6.45 8.5 5.25 8.5 4c0-.55-.45-1-1-1H4c-.55 0-1 .45-1 1 0 9.39 7.61 17 17 17 .55 0 1-.45 1-1v-3.5c0-.55-.45-1-1-1zM12 3v10l3-3h6V3h-9z"></path></g>
<g id="perm-scan-wifi"><path d="M12 3C6.95 3 3.15 4.85 0 7.23L12 22 24 7.25C20.85 4.87 17.05 3 12 3zm1 13h-2v-6h2v6zm-2-8V6h2v2h-2z"></path></g>
<g id="pets"><circle cx="4.5" cy="9.5" r="2.5"></circle><circle cx="9" cy="5.5" r="2.5"></circle><circle cx="15" cy="5.5" r="2.5"></circle><circle cx="19.5" cy="9.5" r="2.5"></circle><path d="M17.34 14.86c-.87-1.02-1.6-1.89-2.48-2.91-.46-.54-1.05-1.08-1.75-1.32-.11-.04-.22-.07-.33-.09-.25-.04-.52-.04-.78-.04s-.53 0-.79.05c-.11.02-.22.05-.33.09-.7.24-1.28.78-1.75 1.32-.87 1.02-1.6 1.89-2.48 2.91-1.31 1.31-2.92 2.76-2.62 4.79.29 1.02 1.02 2.03 2.33 2.32.73.15 3.06-.44 5.54-.44h.18c2.48 0 4.81.58 5.54.44 1.31-.29 2.04-1.31 2.33-2.32.31-2.04-1.3-3.49-2.61-4.8z"></path></g>
<g id="picture-in-picture"><path d="M19 7h-8v6h8V7zm2-4H3c-1.1 0-2 .9-2 2v14c0 1.1.9 1.98 2 1.98h18c1.1 0 2-.88 2-1.98V5c0-1.1-.9-2-2-2zm0 16.01H3V4.98h18v14.03z"></path></g>
<g id="picture-in-picture-alt"><path d="M19 11h-8v6h8v-6zm4 8V4.98C23 3.88 22.1 3 21 3H3c-1.1 0-2 .88-2 1.98V19c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2zm-2 .02H3V4.97h18v14.05z"></path></g>
<g id="play-for-work"><path d="M11 5v5.59H7.5l4.5 4.5 4.5-4.5H13V5h-2zm-5 9c0 3.31 2.69 6 6 6s6-2.69 6-6h-2c0 2.21-1.79 4-4 4s-4-1.79-4-4H6z"></path></g>
<g id="polymer"><path d="M19 4h-4L7.11 16.63 4.5 12 9 4H5L.5 12 5 20h4l7.89-12.63L19.5 12 15 20h4l4.5-8z"></path></g>
<g id="power-settings-new"><path d="M13 3h-2v10h2V3zm4.83 2.17l-1.42 1.42C17.99 7.86 19 9.81 19 12c0 3.87-3.13 7-7 7s-7-3.13-7-7c0-2.19 1.01-4.14 2.58-5.42L6.17 5.17C4.23 6.82 3 9.26 3 12c0 4.97 4.03 9 9 9s9-4.03 9-9c0-2.74-1.23-5.18-3.17-6.83z"></path></g>
<g id="pregnant-woman"><path d="M9 4c0-1.11.89-2 2-2s2 .89 2 2-.89 2-2 2-2-.89-2-2zm7 9c-.01-1.34-.83-2.51-2-3 0-1.66-1.34-3-3-3s-3 1.34-3 3v7h2v5h3v-5h3v-4z"></path></g>
<g id="print"><path d="M19 8H5c-1.66 0-3 1.34-3 3v6h4v4h12v-4h4v-6c0-1.66-1.34-3-3-3zm-3 11H8v-5h8v5zm3-7c-.55 0-1-.45-1-1s.45-1 1-1 1 .45 1 1-.45 1-1 1zm-1-9H6v4h12V3z"></path></g>
<g id="query-builder"><path d="M11.99 2C6.47 2 2 6.48 2 12s4.47 10 9.99 10C17.52 22 22 17.52 22 12S17.52 2 11.99 2zM12 20c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8zm.5-13H11v6l5.25 3.15.75-1.23-4.5-2.67z"></path></g>
<g id="question-answer"><path d="M21 6h-2v9H6v2c0 .55.45 1 1 1h11l4 4V7c0-.55-.45-1-1-1zm-4 6V3c0-.55-.45-1-1-1H3c-.55 0-1 .45-1 1v14l4-4h10c.55 0 1-.45 1-1z"></path></g>
<g id="radio-button-checked"><path d="M12 7c-2.76 0-5 2.24-5 5s2.24 5 5 5 5-2.24 5-5-2.24-5-5-5zm0-5C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8z"></path></g>
<g id="radio-button-unchecked"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8z"></path></g>
<g id="receipt"><path d="M18 17H6v-2h12v2zm0-4H6v-2h12v2zm0-4H6V7h12v2zM3 22l1.5-1.5L6 22l1.5-1.5L9 22l1.5-1.5L12 22l1.5-1.5L15 22l1.5-1.5L18 22l1.5-1.5L21 22V2l-1.5 1.5L18 2l-1.5 1.5L15 2l-1.5 1.5L12 2l-1.5 1.5L9 2 7.5 3.5 6 2 4.5 3.5 3 2v20z"></path></g>
<g id="record-voice-over"><circle cx="9" cy="9" r="4"></circle><path d="M9 15c-2.67 0-8 1.34-8 4v2h16v-2c0-2.66-5.33-4-8-4zm7.76-9.64l-1.68 1.69c.84 1.18.84 2.71 0 3.89l1.68 1.69c2.02-2.02 2.02-5.07 0-7.27zM20.07 2l-1.63 1.63c2.77 3.02 2.77 7.56 0 10.74L20.07 16c3.9-3.89 3.91-9.95 0-14z"></path></g>
<g id="redeem"><path d="M20 6h-2.18c.11-.31.18-.65.18-1 0-1.66-1.34-3-3-3-1.05 0-1.96.54-2.5 1.35l-.5.67-.5-.68C10.96 2.54 10.05 2 9 2 7.34 2 6 3.34 6 5c0 .35.07.69.18 1H4c-1.11 0-1.99.89-1.99 2L2 19c0 1.11.89 2 2 2h16c1.11 0 2-.89 2-2V8c0-1.11-.89-2-2-2zm-5-2c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zM9 4c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm11 15H4v-2h16v2zm0-5H4V8h5.08L7 10.83 8.62 12 11 8.76l1-1.36 1 1.36L15.38 12 17 10.83 14.92 8H20v6z"></path></g>
<g id="redo"><path d="M18.4 10.6C16.55 8.99 14.15 8 11.5 8c-4.65 0-8.58 3.03-9.96 7.22L3.9 16c1.05-3.19 4.05-5.5 7.6-5.5 1.95 0 3.73.72 5.12 1.88L13 16h9V7l-3.6 3.6z"></path></g>
<g id="refresh"><path d="M17.65 6.35C16.2 4.9 14.21 4 12 4c-4.42 0-7.99 3.58-7.99 8s3.57 8 7.99 8c3.73 0 6.84-2.55 7.73-6h-2.08c-.82 2.33-3.04 4-5.65 4-3.31 0-6-2.69-6-6s2.69-6 6-6c1.66 0 3.14.69 4.22 1.78L13 11h7V4l-2.35 2.35z"></path></g>
<g id="remove"><path d="M19 13H5v-2h14v2z"></path></g>
<g id="remove-circle"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm5 11H7v-2h10v2z"></path></g>
<g id="remove-circle-outline"><path d="M7 11v2h10v-2H7zm5-9C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8z"></path></g>
<g id="remove-shopping-cart"><path d="M22.73 22.73L2.77 2.77 2 2l-.73-.73L0 2.54l4.39 4.39 2.21 4.66-1.35 2.45c-.16.28-.25.61-.25.96 0 1.1.9 2 2 2h7.46l1.38 1.38c-.5.36-.83.95-.83 1.62 0 1.1.89 2 1.99 2 .67 0 1.26-.33 1.62-.84L21.46 24l1.27-1.27zM7.42 15c-.14 0-.25-.11-.25-.25l.03-.12.9-1.63h2.36l2 2H7.42zm8.13-2c.75 0 1.41-.41 1.75-1.03l3.58-6.49c.08-.14.12-.31.12-.48 0-.55-.45-1-1-1H6.54l9.01 9zM7 18c-1.1 0-1.99.9-1.99 2S5.9 22 7 22s2-.9 2-2-.9-2-2-2z"></path></g>
<g id="reorder"><path d="M3 15h18v-2H3v2zm0 4h18v-2H3v2zm0-8h18V9H3v2zm0-6v2h18V5H3z"></path></g>
<g id="reply"><path d="M10 9V5l-7 7 7 7v-4.1c5 0 8.5 1.6 11 5.1-1-5-4-10-11-11z"></path></g>
<g id="reply-all"><path d="M7 8V5l-7 7 7 7v-3l-4-4 4-4zm6 1V5l-7 7 7 7v-4.1c5 0 8.5 1.6 11 5.1-1-5-4-10-11-11z"></path></g>
<g id="report"><path d="M15.73 3H8.27L3 8.27v7.46L8.27 21h7.46L21 15.73V8.27L15.73 3zM12 17.3c-.72 0-1.3-.58-1.3-1.3 0-.72.58-1.3 1.3-1.3.72 0 1.3.58 1.3 1.3 0 .72-.58 1.3-1.3 1.3zm1-4.3h-2V7h2v6z"></path></g>
<g id="report-problem"><path d="M1 21h22L12 2 1 21zm12-3h-2v-2h2v2zm0-4h-2v-4h2v4z"></path></g>
<g id="restore"><path d="M13 3c-4.97 0-9 4.03-9 9H1l3.89 3.89.07.14L9 12H6c0-3.87 3.13-7 7-7s7 3.13 7 7-3.13 7-7 7c-1.93 0-3.68-.79-4.94-2.06l-1.42 1.42C8.27 19.99 10.51 21 13 21c4.97 0 9-4.03 9-9s-4.03-9-9-9zm-1 5v5l4.28 2.54.72-1.21-3.5-2.08V8H12z"></path></g>
<g id="restore-page"><path d="M14 2H6c-1.1 0-1.99.9-1.99 2L4 20c0 1.1.89 2 1.99 2H18c1.1 0 2-.9 2-2V8l-6-6zm-2 16c-2.05 0-3.81-1.24-4.58-3h1.71c.63.9 1.68 1.5 2.87 1.5 1.93 0 3.5-1.57 3.5-3.5S13.93 9.5 12 9.5c-1.35 0-2.52.78-3.1 1.9l1.6 1.6h-4V9l1.3 1.3C8.69 8.92 10.23 8 12 8c2.76 0 5 2.24 5 5s-2.24 5-5 5z"></path></g>
<g id="room"><path d="M12 2C8.13 2 5 5.13 5 9c0 5.25 7 13 7 13s7-7.75 7-13c0-3.87-3.13-7-7-7zm0 9.5c-1.38 0-2.5-1.12-2.5-2.5s1.12-2.5 2.5-2.5 2.5 1.12 2.5 2.5-1.12 2.5-2.5 2.5z"></path></g>
<g id="rounded-corner"><path d="M19 19h2v2h-2v-2zm0-2h2v-2h-2v2zM3 13h2v-2H3v2zm0 4h2v-2H3v2zm0-8h2V7H3v2zm0-4h2V3H3v2zm4 0h2V3H7v2zm8 16h2v-2h-2v2zm-4 0h2v-2h-2v2zm4 0h2v-2h-2v2zm-8 0h2v-2H7v2zm-4 0h2v-2H3v2zM21 8c0-2.76-2.24-5-5-5h-5v2h5c1.65 0 3 1.35 3 3v5h2V8z"></path></g>
<g id="rowing"><path d="M8.5 14.5L4 19l1.5 1.5L9 17h2l-2.5-2.5zM15 1c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm6 20.01L18 24l-2.99-3.01V19.5l-7.1-7.09c-.31.05-.61.07-.91.07v-2.16c1.66.03 3.61-.87 4.67-2.04l1.4-1.55c.19-.21.43-.38.69-.5.29-.14.62-.23.96-.23h.03C15.99 6.01 17 7.02 17 8.26v5.75c0 .84-.35 1.61-.92 2.16l-3.58-3.58v-2.27c-.63.52-1.43 1.02-2.29 1.39L16.5 18H18l3 3.01z"></path></g>
<g id="save"><path d="M17 3H5c-1.11 0-2 .9-2 2v14c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V7l-4-4zm-5 16c-1.66 0-3-1.34-3-3s1.34-3 3-3 3 1.34 3 3-1.34 3-3 3zm3-10H5V5h10v4z"></path></g>
<g id="schedule"><path d="M11.99 2C6.47 2 2 6.48 2 12s4.47 10 9.99 10C17.52 22 22 17.52 22 12S17.52 2 11.99 2zM12 20c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8zm.5-13H11v6l5.25 3.15.75-1.23-4.5-2.67z"></path></g>
<g id="search"><path d="M15.5 14h-.79l-.28-.27C15.41 12.59 16 11.11 16 9.5 16 5.91 13.09 3 9.5 3S3 5.91 3 9.5 5.91 16 9.5 16c1.61 0 3.09-.59 4.23-1.57l.27.28v.79l5 4.99L20.49 19l-4.99-5zm-6 0C7.01 14 5 11.99 5 9.5S7.01 5 9.5 5 14 7.01 14 9.5 11.99 14 9.5 14z"></path></g>
<g id="select-all"><path d="M3 5h2V3c-1.1 0-2 .9-2 2zm0 8h2v-2H3v2zm4 8h2v-2H7v2zM3 9h2V7H3v2zm10-6h-2v2h2V3zm6 0v2h2c0-1.1-.9-2-2-2zM5 21v-2H3c0 1.1.9 2 2 2zm-2-4h2v-2H3v2zM9 3H7v2h2V3zm2 18h2v-2h-2v2zm8-8h2v-2h-2v2zm0 8c1.1 0 2-.9 2-2h-2v2zm0-12h2V7h-2v2zm0 8h2v-2h-2v2zm-4 4h2v-2h-2v2zm0-16h2V3h-2v2zM7 17h10V7H7v10zm2-8h6v6H9V9z"></path></g>
<g id="send"><path d="M2.01 21L23 12 2.01 3 2 10l15 2-15 2z"></path></g>
<g id="settings"><path d="M19.43 12.98c.04-.32.07-.64.07-.98s-.03-.66-.07-.98l2.11-1.65c.19-.15.24-.42.12-.64l-2-3.46c-.12-.22-.39-.3-.61-.22l-2.49 1c-.52-.4-1.08-.73-1.69-.98l-.38-2.65C14.46 2.18 14.25 2 14 2h-4c-.25 0-.46.18-.49.42l-.38 2.65c-.61.25-1.17.59-1.69.98l-2.49-1c-.23-.09-.49 0-.61.22l-2 3.46c-.13.22-.07.49.12.64l2.11 1.65c-.04.32-.07.65-.07.98s.03.66.07.98l-2.11 1.65c-.19.15-.24.42-.12.64l2 3.46c.12.22.39.3.61.22l2.49-1c.52.4 1.08.73 1.69.98l.38 2.65c.03.24.24.42.49.42h4c.25 0 .46-.18.49-.42l.38-2.65c.61-.25 1.17-.59 1.69-.98l2.49 1c.23.09.49 0 .61-.22l2-3.46c.12-.22.07-.49-.12-.64l-2.11-1.65zM12 15.5c-1.93 0-3.5-1.57-3.5-3.5s1.57-3.5 3.5-3.5 3.5 1.57 3.5 3.5-1.57 3.5-3.5 3.5z"></path></g>
<g id="settings-applications"><path d="M12 10c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm7-7H5c-1.11 0-2 .9-2 2v14c0 1.1.89 2 2 2h14c1.11 0 2-.9 2-2V5c0-1.1-.89-2-2-2zm-1.75 9c0 .23-.02.46-.05.68l1.48 1.16c.13.11.17.3.08.45l-1.4 2.42c-.09.15-.27.21-.43.15l-1.74-.7c-.36.28-.76.51-1.18.69l-.26 1.85c-.03.17-.18.3-.35.3h-2.8c-.17 0-.32-.13-.35-.29l-.26-1.85c-.43-.18-.82-.41-1.18-.69l-1.74.7c-.16.06-.34 0-.43-.15l-1.4-2.42c-.09-.15-.05-.34.08-.45l1.48-1.16c-.03-.23-.05-.46-.05-.69 0-.23.02-.46.05-.68l-1.48-1.16c-.13-.11-.17-.3-.08-.45l1.4-2.42c.09-.15.27-.21.43-.15l1.74.7c.36-.28.76-.51 1.18-.69l.26-1.85c.03-.17.18-.3.35-.3h2.8c.17 0 .32.13.35.29l.26 1.85c.43.18.82.41 1.18.69l1.74-.7c.16-.06.34 0 .43.15l1.4 2.42c.09.15.05.34-.08.45l-1.48 1.16c.03.23.05.46.05.69z"></path></g>
<g id="settings-backup-restore"><path d="M14 12c0-1.1-.9-2-2-2s-2 .9-2 2 .9 2 2 2 2-.9 2-2zm-2-9c-4.97 0-9 4.03-9 9H0l4 4 4-4H5c0-3.87 3.13-7 7-7s7 3.13 7 7-3.13 7-7 7c-1.51 0-2.91-.49-4.06-1.3l-1.42 1.44C8.04 20.3 9.94 21 12 21c4.97 0 9-4.03 9-9s-4.03-9-9-9z"></path></g>
<g id="settings-bluetooth"><path d="M11 24h2v-2h-2v2zm-4 0h2v-2H7v2zm8 0h2v-2h-2v2zm2.71-18.29L12 0h-1v7.59L6.41 3 5 4.41 10.59 10 5 15.59 6.41 17 11 12.41V20h1l5.71-5.71-4.3-4.29 4.3-4.29zM13 3.83l1.88 1.88L13 7.59V3.83zm1.88 10.46L13 16.17v-3.76l1.88 1.88z"></path></g>
<g id="settings-brightness"><path d="M21 3H3c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16.01H3V4.99h18v14.02zM8 16h2.5l1.5 1.5 1.5-1.5H16v-2.5l1.5-1.5-1.5-1.5V8h-2.5L12 6.5 10.5 8H8v2.5L6.5 12 8 13.5V16zm4-7c1.66 0 3 1.34 3 3s-1.34 3-3 3V9z"></path></g>
<g id="settings-cell"><path d="M7 24h2v-2H7v2zm4 0h2v-2h-2v2zm4 0h2v-2h-2v2zM16 .01L8 0C6.9 0 6 .9 6 2v16c0 1.1.9 2 2 2h8c1.1 0 2-.9 2-2V2c0-1.1-.9-1.99-2-1.99zM16 16H8V4h8v12z"></path></g>
<g id="settings-ethernet"><path d="M7.77 6.76L6.23 5.48.82 12l5.41 6.52 1.54-1.28L3.42 12l4.35-5.24zM7 13h2v-2H7v2zm10-2h-2v2h2v-2zm-6 2h2v-2h-2v2zm6.77-7.52l-1.54 1.28L20.58 12l-4.35 5.24 1.54 1.28L23.18 12l-5.41-6.52z"></path></g>
<g id="settings-input-antenna"><path d="M12 5c-3.87 0-7 3.13-7 7h2c0-2.76 2.24-5 5-5s5 2.24 5 5h2c0-3.87-3.13-7-7-7zm1 9.29c.88-.39 1.5-1.26 1.5-2.29 0-1.38-1.12-2.5-2.5-2.5S9.5 10.62 9.5 12c0 1.02.62 1.9 1.5 2.29v3.3L7.59 21 9 22.41l3-3 3 3L16.41 21 13 17.59v-3.3zM12 1C5.93 1 1 5.93 1 12h2c0-4.97 4.03-9 9-9s9 4.03 9 9h2c0-6.07-4.93-11-11-11z"></path></g>
<g id="settings-input-component"><path d="M5 2c0-.55-.45-1-1-1s-1 .45-1 1v4H1v6h6V6H5V2zm4 14c0 1.3.84 2.4 2 2.82V23h2v-4.18c1.16-.41 2-1.51 2-2.82v-2H9v2zm-8 0c0 1.3.84 2.4 2 2.82V23h2v-4.18C6.16 18.4 7 17.3 7 16v-2H1v2zM21 6V2c0-.55-.45-1-1-1s-1 .45-1 1v4h-2v6h6V6h-2zm-8-4c0-.55-.45-1-1-1s-1 .45-1 1v4H9v6h6V6h-2V2zm4 14c0 1.3.84 2.4 2 2.82V23h2v-4.18c1.16-.41 2-1.51 2-2.82v-2h-6v2z"></path></g>
<g id="settings-input-composite"><path d="M5 2c0-.55-.45-1-1-1s-1 .45-1 1v4H1v6h6V6H5V2zm4 14c0 1.3.84 2.4 2 2.82V23h2v-4.18c1.16-.41 2-1.51 2-2.82v-2H9v2zm-8 0c0 1.3.84 2.4 2 2.82V23h2v-4.18C6.16 18.4 7 17.3 7 16v-2H1v2zM21 6V2c0-.55-.45-1-1-1s-1 .45-1 1v4h-2v6h6V6h-2zm-8-4c0-.55-.45-1-1-1s-1 .45-1 1v4H9v6h6V6h-2V2zm4 14c0 1.3.84 2.4 2 2.82V23h2v-4.18c1.16-.41 2-1.51 2-2.82v-2h-6v2z"></path></g>
<g id="settings-input-hdmi"><path d="M18 7V4c0-1.1-.9-2-2-2H8c-1.1 0-2 .9-2 2v3H5v6l3 6v3h8v-3l3-6V7h-1zM8 4h8v3h-2V5h-1v2h-2V5h-1v2H8V4z"></path></g>
<g id="settings-input-svideo"><path d="M8 11.5c0-.83-.67-1.5-1.5-1.5S5 10.67 5 11.5 5.67 13 6.5 13 8 12.33 8 11.5zm7-5c0-.83-.67-1.5-1.5-1.5h-3C9.67 5 9 5.67 9 6.5S9.67 8 10.5 8h3c.83 0 1.5-.67 1.5-1.5zM8.5 15c-.83 0-1.5.67-1.5 1.5S7.67 18 8.5 18s1.5-.67 1.5-1.5S9.33 15 8.5 15zM12 1C5.93 1 1 5.93 1 12s4.93 11 11 11 11-4.93 11-11S18.07 1 12 1zm0 20c-4.96 0-9-4.04-9-9s4.04-9 9-9 9 4.04 9 9-4.04 9-9 9zm5.5-11c-.83 0-1.5.67-1.5 1.5s.67 1.5 1.5 1.5 1.5-.67 1.5-1.5-.67-1.5-1.5-1.5zm-2 5c-.83 0-1.5.67-1.5 1.5s.67 1.5 1.5 1.5 1.5-.67 1.5-1.5-.67-1.5-1.5-1.5z"></path></g>
<g id="settings-overscan"><path d="M12.01 5.5L10 8h4l-1.99-2.5zM18 10v4l2.5-1.99L18 10zM6 10l-2.5 2.01L6 14v-4zm8 6h-4l2.01 2.5L14 16zm7-13H3c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16.01H3V4.99h18v14.02z"></path></g>
<g id="settings-phone"><path d="M13 9h-2v2h2V9zm4 0h-2v2h2V9zm3 6.5c-1.25 0-2.45-.2-3.57-.57-.35-.11-.74-.03-1.02.24l-2.2 2.2c-2.83-1.44-5.15-3.75-6.59-6.58l2.2-2.21c.28-.27.36-.66.25-1.01C8.7 6.45 8.5 5.25 8.5 4c0-.55-.45-1-1-1H4c-.55 0-1 .45-1 1 0 9.39 7.61 17 17 17 .55 0 1-.45 1-1v-3.5c0-.55-.45-1-1-1zM19 9v2h2V9h-2z"></path></g>
<g id="settings-power"><path d="M7 24h2v-2H7v2zm4 0h2v-2h-2v2zm2-22h-2v10h2V2zm3.56 2.44l-1.45 1.45C16.84 6.94 18 8.83 18 11c0 3.31-2.69 6-6 6s-6-2.69-6-6c0-2.17 1.16-4.06 2.88-5.12L7.44 4.44C5.36 5.88 4 8.28 4 11c0 4.42 3.58 8 8 8s8-3.58 8-8c0-2.72-1.36-5.12-3.44-6.56zM15 24h2v-2h-2v2z"></path></g>
<g id="settings-remote"><path d="M15 9H9c-.55 0-1 .45-1 1v12c0 .55.45 1 1 1h6c.55 0 1-.45 1-1V10c0-.55-.45-1-1-1zm-3 6c-1.1 0-2-.9-2-2s.9-2 2-2 2 .9 2 2-.9 2-2 2zM7.05 6.05l1.41 1.41C9.37 6.56 10.62 6 12 6s2.63.56 3.54 1.46l1.41-1.41C15.68 4.78 13.93 4 12 4s-3.68.78-4.95 2.05zM12 0C8.96 0 6.21 1.23 4.22 3.22l1.41 1.41C7.26 3.01 9.51 2 12 2s4.74 1.01 6.36 2.64l1.41-1.41C17.79 1.23 15.04 0 12 0z"></path></g>
<g id="settings-voice"><path d="M7 24h2v-2H7v2zm5-11c1.66 0 2.99-1.34 2.99-3L15 4c0-1.66-1.34-3-3-3S9 2.34 9 4v6c0 1.66 1.34 3 3 3zm-1 11h2v-2h-2v2zm4 0h2v-2h-2v2zm4-14h-1.7c0 3-2.54 5.1-5.3 5.1S6.7 13 6.7 10H5c0 3.41 2.72 6.23 6 6.72V20h2v-3.28c3.28-.49 6-3.31 6-6.72z"></path></g>
<g id="shop"><path d="M16 6V4c0-1.11-.89-2-2-2h-4c-1.11 0-2 .89-2 2v2H2v13c0 1.11.89 2 2 2h16c1.11 0 2-.89 2-2V6h-6zm-6-2h4v2h-4V4zM9 18V9l7.5 4L9 18z"></path></g>
<g id="shop-two"><path d="M3 9H1v11c0 1.11.89 2 2 2h14c1.11 0 2-.89 2-2H3V9zm15-4V3c0-1.11-.89-2-2-2h-4c-1.11 0-2 .89-2 2v2H5v11c0 1.11.89 2 2 2h14c1.11 0 2-.89 2-2V5h-5zm-6-2h4v2h-4V3zm0 12V8l5.5 3-5.5 4z"></path></g>
<g id="shopping-basket"><path d="M17.21 9l-4.38-6.56c-.19-.28-.51-.42-.83-.42-.32 0-.64.14-.83.43L6.79 9H2c-.55 0-1 .45-1 1 0 .09.01.18.04.27l2.54 9.27c.23.84 1 1.46 1.92 1.46h13c.92 0 1.69-.62 1.93-1.46l2.54-9.27L23 10c0-.55-.45-1-1-1h-4.79zM9 9l3-4.4L15 9H9zm3 8c-1.1 0-2-.9-2-2s.9-2 2-2 2 .9 2 2-.9 2-2 2z"></path></g>
<g id="shopping-cart"><path d="M7 18c-1.1 0-1.99.9-1.99 2S5.9 22 7 22s2-.9 2-2-.9-2-2-2zM1 2v2h2l3.6 7.59-1.35 2.45c-.16.28-.25.61-.25.96 0 1.1.9 2 2 2h12v-2H7.42c-.14 0-.25-.11-.25-.25l.03-.12.9-1.63h7.45c.75 0 1.41-.41 1.75-1.03l3.58-6.49c.08-.14.12-.31.12-.48 0-.55-.45-1-1-1H5.21l-.94-2H1zm16 16c-1.1 0-1.99.9-1.99 2s.89 2 1.99 2 2-.9 2-2-.9-2-2-2z"></path></g>
<g id="sort"><path d="M3 18h6v-2H3v2zM3 6v2h18V6H3zm0 7h12v-2H3v2z"></path></g>
<g id="speaker-notes"><path d="M20 2H4c-1.1 0-1.99.9-1.99 2L2 22l4-4h14c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zM8 14H6v-2h2v2zm0-3H6V9h2v2zm0-3H6V6h2v2zm7 6h-5v-2h5v2zm3-3h-8V9h8v2zm0-3h-8V6h8v2z"></path></g>
<g id="speaker-notes-off"><path d="M10.54 11l-.54-.54L7.54 8 6 6.46 2.38 2.84 1.27 1.73 0 3l2.01 2.01L2 22l4-4h9l5.73 5.73L22 22.46 17.54 18l-7-7zM8 14H6v-2h2v2zm-2-3V9l2 2H6zm14-9H4.08L10 7.92V6h8v2h-7.92l1 1H18v2h-4.92l6.99 6.99C21.14 17.95 22 17.08 22 16V4c0-1.1-.9-2-2-2z"></path></g>
<g id="spellcheck"><path d="M12.45 16h2.09L9.43 3H7.57L2.46 16h2.09l1.12-3h5.64l1.14 3zm-6.02-5L8.5 5.48 10.57 11H6.43zm15.16.59l-8.09 8.09L9.83 16l-1.41 1.41 5.09 5.09L23 13l-1.41-1.41z"></path></g>
<g id="star"><path d="M12 17.27L18.18 21l-1.64-7.03L22 9.24l-7.19-.61L12 2 9.19 8.63 2 9.24l5.46 4.73L5.82 21z"></path></g>
<g id="star-border"><path d="M22 9.24l-7.19-.62L12 2 9.19 8.63 2 9.24l5.46 4.73L5.82 21 12 17.27 18.18 21l-1.63-7.03L22 9.24zM12 15.4l-3.76 2.27 1-4.28-3.32-2.88 4.38-.38L12 6.1l1.71 4.04 4.38.38-3.32 2.88 1 4.28L12 15.4z"></path></g>
<g id="star-half"><path d="M22 9.24l-7.19-.62L12 2 9.19 8.63 2 9.24l5.46 4.73L5.82 21 12 17.27 18.18 21l-1.63-7.03L22 9.24zM12 15.4V6.1l1.71 4.04 4.38.38-3.32 2.88 1 4.28L12 15.4z"></path></g>
<g id="stars"><path d="M11.99 2C6.47 2 2 6.48 2 12s4.47 10 9.99 10C17.52 22 22 17.52 22 12S17.52 2 11.99 2zm4.24 16L12 15.45 7.77 18l1.12-4.81-3.73-3.23 4.92-.42L12 5l1.92 4.53 4.92.42-3.73 3.23L16.23 18z"></path></g>
<g id="store"><path d="M20 4H4v2h16V4zm1 10v-2l-1-5H4l-1 5v2h1v6h10v-6h4v6h2v-6h1zm-9 4H6v-4h6v4z"></path></g>
<g id="subdirectory-arrow-left"><path d="M11 9l1.42 1.42L8.83 14H18V4h2v12H8.83l3.59 3.58L11 21l-6-6 6-6z"></path></g>
<g id="subdirectory-arrow-right"><path d="M19 15l-6 6-1.42-1.42L15.17 16H4V4h2v10h9.17l-3.59-3.58L13 9l6 6z"></path></g>
<g id="subject"><path d="M14 17H4v2h10v-2zm6-8H4v2h16V9zM4 15h16v-2H4v2zM4 5v2h16V5H4z"></path></g>
<g id="supervisor-account"><path d="M16.5 12c1.38 0 2.49-1.12 2.49-2.5S17.88 7 16.5 7C15.12 7 14 8.12 14 9.5s1.12 2.5 2.5 2.5zM9 11c1.66 0 2.99-1.34 2.99-3S10.66 5 9 5C7.34 5 6 6.34 6 8s1.34 3 3 3zm7.5 3c-1.83 0-5.5.92-5.5 2.75V19h11v-2.25c0-1.83-3.67-2.75-5.5-2.75zM9 13c-2.33 0-7 1.17-7 3.5V19h7v-2.25c0-.85.33-2.34 2.37-3.47C10.5 13.1 9.66 13 9 13z"></path></g>
<g id="swap-horiz"><path d="M6.99 11L3 15l3.99 4v-3H14v-2H6.99v-3zM21 9l-3.99-4v3H10v2h7.01v3L21 9z"></path></g>
<g id="swap-vert"><path d="M16 17.01V10h-2v7.01h-3L15 21l4-3.99h-3zM9 3L5 6.99h3V14h2V6.99h3L9 3z"></path></g>
<g id="swap-vertical-circle"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zM6.5 9L10 5.5 13.5 9H11v4H9V9H6.5zm11 6L14 18.5 10.5 15H13v-4h2v4h2.5z"></path></g>
<g id="system-update-alt"><path d="M12 16.5l4-4h-3v-9h-2v9H8l4 4zm9-13h-6v1.99h6v14.03H3V5.49h6V3.5H3c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2v-14c0-1.1-.9-2-2-2z"></path></g>
<g id="tab"><path d="M21 3H3c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16H3V5h10v4h8v10z"></path></g>
<g id="tab-unselected"><path d="M1 9h2V7H1v2zm0 4h2v-2H1v2zm0-8h2V3c-1.1 0-2 .9-2 2zm8 16h2v-2H9v2zm-8-4h2v-2H1v2zm2 4v-2H1c0 1.1.9 2 2 2zM21 3h-8v6h10V5c0-1.1-.9-2-2-2zm0 14h2v-2h-2v2zM9 5h2V3H9v2zM5 21h2v-2H5v2zM5 5h2V3H5v2zm16 16c1.1 0 2-.9 2-2h-2v2zm0-8h2v-2h-2v2zm-8 8h2v-2h-2v2zm4 0h2v-2h-2v2z"></path></g>
<g id="text-format"><path d="M5 17v2h14v-2H5zm4.5-4.2h5l.9 2.2h2.1L12.75 4h-1.5L6.5 15h2.1l.9-2.2zM12 5.98L13.87 11h-3.74L12 5.98z"></path></g>
<g id="theaters"><path d="M18 3v2h-2V3H8v2H6V3H4v18h2v-2h2v2h8v-2h2v2h2V3h-2zM8 17H6v-2h2v2zm0-4H6v-2h2v2zm0-4H6V7h2v2zm10 8h-2v-2h2v2zm0-4h-2v-2h2v2zm0-4h-2V7h2v2z"></path></g>
<g id="thumb-down"><path d="M15 3H6c-.83 0-1.54.5-1.84 1.22l-3.02 7.05c-.09.23-.14.47-.14.73v1.91l.01.01L1 14c0 1.1.9 2 2 2h6.31l-.95 4.57-.03.32c0 .41.17.79.44 1.06L9.83 23l6.59-6.59c.36-.36.58-.86.58-1.41V5c0-1.1-.9-2-2-2zm4 0v12h4V3h-4z"></path></g>
<g id="thumb-up"><path d="M1 21h4V9H1v12zm22-11c0-1.1-.9-2-2-2h-6.31l.95-4.57.03-.32c0-.41-.17-.79-.44-1.06L14.17 1 7.59 7.59C7.22 7.95 7 8.45 7 9v10c0 1.1.9 2 2 2h9c.83 0 1.54-.5 1.84-1.22l3.02-7.05c.09-.23.14-.47.14-.73v-1.91l-.01-.01L23 10z"></path></g>
<g id="thumbs-up-down"><path d="M12 6c0-.55-.45-1-1-1H5.82l.66-3.18.02-.23c0-.31-.13-.59-.33-.8L5.38 0 .44 4.94C.17 5.21 0 5.59 0 6v6.5c0 .83.67 1.5 1.5 1.5h6.75c.62 0 1.15-.38 1.38-.91l2.26-5.29c.07-.17.11-.36.11-.55V6zm10.5 4h-6.75c-.62 0-1.15.38-1.38.91l-2.26 5.29c-.07.17-.11.36-.11.55V18c0 .55.45 1 1 1h5.18l-.66 3.18-.02.24c0 .31.13.59.33.8l.79.78 4.94-4.94c.27-.27.44-.65.44-1.06v-6.5c0-.83-.67-1.5-1.5-1.5z"></path></g>
<g id="timeline"><path d="M23 8c0 1.1-.9 2-2 2-.18 0-.35-.02-.51-.07l-3.56 3.55c.05.16.07.34.07.52 0 1.1-.9 2-2 2s-2-.9-2-2c0-.18.02-.36.07-.52l-2.55-2.55c-.16.05-.34.07-.52.07s-.36-.02-.52-.07l-4.55 4.56c.05.16.07.33.07.51 0 1.1-.9 2-2 2s-2-.9-2-2 .9-2 2-2c.18 0 .35.02.51.07l4.56-4.55C8.02 9.36 8 9.18 8 9c0-1.1.9-2 2-2s2 .9 2 2c0 .18-.02.36-.07.52l2.55 2.55c.16-.05.34-.07.52-.07s.36.02.52.07l3.55-3.56C19.02 8.35 19 8.18 19 8c0-1.1.9-2 2-2s2 .9 2 2z"></path></g>
<g id="toc"><path d="M3 9h14V7H3v2zm0 4h14v-2H3v2zm0 4h14v-2H3v2zm16 0h2v-2h-2v2zm0-10v2h2V7h-2zm0 6h2v-2h-2v2z"></path></g>
<g id="today"><path d="M19 3h-1V1h-2v2H8V1H6v2H5c-1.11 0-1.99.9-1.99 2L3 19c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16H5V8h14v11zM7 10h5v5H7z"></path></g>
<g id="toll"><path d="M15 4c-4.42 0-8 3.58-8 8s3.58 8 8 8 8-3.58 8-8-3.58-8-8-8zm0 14c-3.31 0-6-2.69-6-6s2.69-6 6-6 6 2.69 6 6-2.69 6-6 6zM3 12c0-2.61 1.67-4.83 4-5.65V4.26C3.55 5.15 1 8.27 1 12s2.55 6.85 6 7.74v-2.09c-2.33-.82-4-3.04-4-5.65z"></path></g>
<g id="touch-app"><path d="M9 11.24V7.5C9 6.12 10.12 5 11.5 5S14 6.12 14 7.5v3.74c1.21-.81 2-2.18 2-3.74C16 5.01 13.99 3 11.5 3S7 5.01 7 7.5c0 1.56.79 2.93 2 3.74zm9.84 4.63l-4.54-2.26c-.17-.07-.35-.11-.54-.11H13v-6c0-.83-.67-1.5-1.5-1.5S10 6.67 10 7.5v10.74l-3.43-.72c-.08-.01-.15-.03-.24-.03-.31 0-.59.13-.79.33l-.79.8 4.94 4.94c.27.27.65.44 1.06.44h6.79c.75 0 1.33-.55 1.44-1.28l.75-5.27c.01-.07.02-.14.02-.2 0-.62-.38-1.16-.91-1.38z"></path></g>
<g id="track-changes"><path d="M19.07 4.93l-1.41 1.41C19.1 7.79 20 9.79 20 12c0 4.42-3.58 8-8 8s-8-3.58-8-8c0-4.08 3.05-7.44 7-7.93v2.02C8.16 6.57 6 9.03 6 12c0 3.31 2.69 6 6 6s6-2.69 6-6c0-1.66-.67-3.16-1.76-4.24l-1.41 1.41C15.55 9.9 16 10.9 16 12c0 2.21-1.79 4-4 4s-4-1.79-4-4c0-1.86 1.28-3.41 3-3.86v2.14c-.6.35-1 .98-1 1.72 0 1.1.9 2 2 2s2-.9 2-2c0-.74-.4-1.38-1-1.72V2h-1C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10c0-2.76-1.12-5.26-2.93-7.07z"></path></g>
<g id="translate"><path d="M12.87 15.07l-2.54-2.51.03-.03c1.74-1.94 2.98-4.17 3.71-6.53H17V4h-7V2H8v2H1v1.99h11.17C11.5 7.92 10.44 9.75 9 11.35 8.07 10.32 7.3 9.19 6.69 8h-2c.73 1.63 1.73 3.17 2.98 4.56l-5.09 5.02L4 19l5-5 3.11 3.11.76-2.04zM18.5 10h-2L12 22h2l1.12-3h4.75L21 22h2l-4.5-12zm-2.62 7l1.62-4.33L19.12 17h-3.24z"></path></g>
<g id="trending-down"><path d="M16 18l2.29-2.29-4.88-4.88-4 4L2 7.41 3.41 6l6 6 4-4 6.3 6.29L22 12v6z"></path></g>
<g id="trending-flat"><path d="M22 12l-4-4v3H3v2h15v3z"></path></g>
<g id="trending-up"><path d="M16 6l2.29 2.29-4.88 4.88-4-4L2 16.59 3.41 18l6-6 4 4 6.3-6.29L22 12V6z"></path></g>
<g id="turned-in"><path d="M17 3H7c-1.1 0-1.99.9-1.99 2L5 21l7-3 7 3V5c0-1.1-.9-2-2-2z"></path></g>
<g id="turned-in-not"><path d="M17 3H7c-1.1 0-1.99.9-1.99 2L5 21l7-3 7 3V5c0-1.1-.9-2-2-2zm0 15l-5-2.18L7 18V5h10v13z"></path></g>
<g id="unarchive"><path d="M20.55 5.22l-1.39-1.68C18.88 3.21 18.47 3 18 3H6c-.47 0-.88.21-1.15.55L3.46 5.22C3.17 5.57 3 6.01 3 6.5V19c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V6.5c0-.49-.17-.93-.45-1.28zM12 9.5l5.5 5.5H14v2h-4v-2H6.5L12 9.5zM5.12 5l.82-1h12l.93 1H5.12z"></path></g>
<g id="undo"><path d="M12.5 8c-2.65 0-5.05.99-6.9 2.6L2 7v9h9l-3.62-3.62c1.39-1.16 3.16-1.88 5.12-1.88 3.54 0 6.55 2.31 7.6 5.5l2.37-.78C21.08 11.03 17.15 8 12.5 8z"></path></g>
<g id="unfold-less"><path d="M7.41 18.59L8.83 20 12 16.83 15.17 20l1.41-1.41L12 14l-4.59 4.59zm9.18-13.18L15.17 4 12 7.17 8.83 4 7.41 5.41 12 10l4.59-4.59z"></path></g>
<g id="unfold-more"><path d="M12 5.83L15.17 9l1.41-1.41L12 3 7.41 7.59 8.83 9 12 5.83zm0 12.34L8.83 15l-1.41 1.41L12 21l4.59-4.59L15.17 15 12 18.17z"></path></g>
<g id="update"><path d="M21 10.12h-6.78l2.74-2.82c-2.73-2.7-7.15-2.8-9.88-.1-2.73 2.71-2.73 7.08 0 9.79 2.73 2.71 7.15 2.71 9.88 0C18.32 15.65 19 14.08 19 12.1h2c0 1.98-.88 4.55-2.64 6.29-3.51 3.48-9.21 3.48-12.72 0-3.5-3.47-3.53-9.11-.02-12.58 3.51-3.47 9.14-3.47 12.65 0L21 3v7.12zM12.5 8v4.25l3.5 2.08-.72 1.21L11 13V8h1.5z"></path></g>
<g id="verified-user"><path d="M12 1L3 5v6c0 5.55 3.84 10.74 9 12 5.16-1.26 9-6.45 9-12V5l-9-4zm-2 16l-4-4 1.41-1.41L10 14.17l6.59-6.59L18 9l-8 8z"></path></g>
<g id="view-agenda"><path d="M20 13H3c-.55 0-1 .45-1 1v6c0 .55.45 1 1 1h17c.55 0 1-.45 1-1v-6c0-.55-.45-1-1-1zm0-10H3c-.55 0-1 .45-1 1v6c0 .55.45 1 1 1h17c.55 0 1-.45 1-1V4c0-.55-.45-1-1-1z"></path></g>
<g id="view-array"><path d="M4 18h3V5H4v13zM18 5v13h3V5h-3zM8 18h9V5H8v13z"></path></g>
<g id="view-carousel"><path d="M7 19h10V4H7v15zm-5-2h4V6H2v11zM18 6v11h4V6h-4z"></path></g>
<g id="view-column"><path d="M10 18h5V5h-5v13zm-6 0h5V5H4v13zM16 5v13h5V5h-5z"></path></g>
<g id="view-day"><path d="M2 21h19v-3H2v3zM20 8H3c-.55 0-1 .45-1 1v6c0 .55.45 1 1 1h17c.55 0 1-.45 1-1V9c0-.55-.45-1-1-1zM2 3v3h19V3H2z"></path></g>
<g id="view-headline"><path d="M4 15h16v-2H4v2zm0 4h16v-2H4v2zm0-8h16V9H4v2zm0-6v2h16V5H4z"></path></g>
<g id="view-list"><path d="M4 14h4v-4H4v4zm0 5h4v-4H4v4zM4 9h4V5H4v4zm5 5h12v-4H9v4zm0 5h12v-4H9v4zM9 5v4h12V5H9z"></path></g>
<g id="view-module"><path d="M4 11h5V5H4v6zm0 7h5v-6H4v6zm6 0h5v-6h-5v6zm6 0h5v-6h-5v6zm-6-7h5V5h-5v6zm6-6v6h5V5h-5z"></path></g>
<g id="view-quilt"><path d="M10 18h5v-6h-5v6zm-6 0h5V5H4v13zm12 0h5v-6h-5v6zM10 5v6h11V5H10z"></path></g>
<g id="view-stream"><path d="M4 18h17v-6H4v6zM4 5v6h17V5H4z"></path></g>
<g id="view-week"><path d="M6 5H3c-.55 0-1 .45-1 1v12c0 .55.45 1 1 1h3c.55 0 1-.45 1-1V6c0-.55-.45-1-1-1zm14 0h-3c-.55 0-1 .45-1 1v12c0 .55.45 1 1 1h3c.55 0 1-.45 1-1V6c0-.55-.45-1-1-1zm-7 0h-3c-.55 0-1 .45-1 1v12c0 .55.45 1 1 1h3c.55 0 1-.45 1-1V6c0-.55-.45-1-1-1z"></path></g>
<g id="visibility"><path d="M12 4.5C7 4.5 2.73 7.61 1 12c1.73 4.39 6 7.5 11 7.5s9.27-3.11 11-7.5c-1.73-4.39-6-7.5-11-7.5zM12 17c-2.76 0-5-2.24-5-5s2.24-5 5-5 5 2.24 5 5-2.24 5-5 5zm0-8c-1.66 0-3 1.34-3 3s1.34 3 3 3 3-1.34 3-3-1.34-3-3-3z"></path></g>
<g id="visibility-off"><path d="M12 7c2.76 0 5 2.24 5 5 0 .65-.13 1.26-.36 1.83l2.92 2.92c1.51-1.26 2.7-2.89 3.43-4.75-1.73-4.39-6-7.5-11-7.5-1.4 0-2.74.25-3.98.7l2.16 2.16C10.74 7.13 11.35 7 12 7zM2 4.27l2.28 2.28.46.46C3.08 8.3 1.78 10.02 1 12c1.73 4.39 6 7.5 11 7.5 1.55 0 3.03-.3 4.38-.84l.42.42L19.73 22 21 20.73 3.27 3 2 4.27zM7.53 9.8l1.55 1.55c-.05.21-.08.43-.08.65 0 1.66 1.34 3 3 3 .22 0 .44-.03.65-.08l1.55 1.55c-.67.33-1.41.53-2.2.53-2.76 0-5-2.24-5-5 0-.79.2-1.53.53-2.2zm4.31-.78l3.15 3.15.02-.16c0-1.66-1.34-3-3-3l-.17.01z"></path></g>
<g id="warning"><path d="M1 21h22L12 2 1 21zm12-3h-2v-2h2v2zm0-4h-2v-4h2v4z"></path></g>
<g id="watch-later"><path d="M12 2C6.5 2 2 6.5 2 12s4.5 10 10 10 10-4.5 10-10S17.5 2 12 2zm4.2 14.2L11 13V7h1.5v5.2l4.5 2.7-.8 1.3z"></path></g>
<g id="weekend"><path d="M21 10c-1.1 0-2 .9-2 2v3H5v-3c0-1.1-.9-2-2-2s-2 .9-2 2v5c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2v-5c0-1.1-.9-2-2-2zm-3-5H6c-1.1 0-2 .9-2 2v2.15c1.16.41 2 1.51 2 2.82V14h12v-2.03c0-1.3.84-2.4 2-2.82V7c0-1.1-.9-2-2-2z"></path></g>
<g id="work"><path d="M20 6h-4V4c0-1.11-.89-2-2-2h-4c-1.11 0-2 .89-2 2v2H4c-1.11 0-1.99.89-1.99 2L2 19c0 1.11.89 2 2 2h16c1.11 0 2-.89 2-2V8c0-1.11-.89-2-2-2zm-6 0h-4V4h4v2z"></path></g>
<g id="youtube-searched-for"><path d="M17.01 14h-.8l-.27-.27c.98-1.14 1.57-2.61 1.57-4.23 0-3.59-2.91-6.5-6.5-6.5s-6.5 3-6.5 6.5H2l3.84 4 4.16-4H6.51C6.51 7 8.53 5 11.01 5s4.5 2.01 4.5 4.5c0 2.48-2.02 4.5-4.5 4.5-.65 0-1.26-.14-1.82-.38L7.71 15.1c.97.57 2.09.9 3.3.9 1.61 0 3.08-.59 4.22-1.57l.27.27v.79l5.01 4.99L22 19l-4.99-5z"></path></g>
<g id="zoom-in"><path d="M15.5 14h-.79l-.28-.27C15.41 12.59 16 11.11 16 9.5 16 5.91 13.09 3 9.5 3S3 5.91 3 9.5 5.91 16 9.5 16c1.61 0 3.09-.59 4.23-1.57l.27.28v.79l5 4.99L20.49 19l-4.99-5zm-6 0C7.01 14 5 11.99 5 9.5S7.01 5 9.5 5 14 7.01 14 9.5 11.99 14 9.5 14zm2.5-4h-2v2H9v-2H7V9h2V7h1v2h2v1z"></path></g>
<g id="zoom-out"><path d="M15.5 14h-.79l-.28-.27C15.41 12.59 16 11.11 16 9.5 16 5.91 13.09 3 9.5 3S3 5.91 3 9.5 5.91 16 9.5 16c1.61 0 3.09-.59 4.23-1.57l.27.28v.79l5 4.99L20.49 19l-4.99-5zm-6 0C7.01 14 5 11.99 5 9.5S7.01 5 9.5 5 14 7.01 14 9.5 11.99 14 9.5 14zM7 9h5v1H7z"></path></g>
</defs></svg>
</iron-iconset-svg>`;document.head.appendChild(vbe.content);var t0t={"U+0008":"backspace","U+0009":"tab","U+001B":"esc","U+0020":"space","U+007F":"del"},xbe={8:"backspace",9:"tab",13:"enter",27:"esc",33:"pageup",34:"pagedown",35:"end",36:"home",32:"space",37:"left",38:"up",39:"right",40:"down",46:"del",106:"*"},e0t={shift:"shiftKey",ctrl:"ctrlKey",alt:"altKey",meta:"metaKey"},bbe=/[a-z0-9*]/,wbe=/U\+/,Sbe=/^arrow/,Mbe=/^space(bar)?/,Ebe=/^escape$/;function r0t(e,t){var r="";if(e){var n=e.toLowerCase();n===" "||Mbe.test(n)?r="space":Ebe.test(n)?r="esc":n.length==1?(!t||bbe.test(n))&&(r=n):Sbe.test(n)?r=n.replace("arrow",""):n=="multiply"?r="*":r=n}return r}function Tbe(e){var t="";return e&&(e in t0t?t=t0t[e]:wbe.test(e)?(e=parseInt(e.replace("U+","0x"),16),t=String.fromCharCode(e).toLowerCase()):t=e.toLowerCase()),t}function Cbe(e){var t="";return Number(e)&&(e>=65&&e<=90?t=String.fromCharCode(32+e):e>=112&&e<=123?t="f"+(e-112+1):e>=48&&e<=57?t=String(e-48):e>=96&&e<=105?t=String(e-96):t=xbe[e]),t}function Abe(e,t){return e.key?r0t(e.key,t):e.detail&&e.detail.key?r0t(e.detail.key,t):Tbe(e.keyIdentifier)||Cbe(e.keyCode)||""}function n0t(e,t){var r=Abe(t,e.hasModifiers);return r===e.key&&(!e.hasModifiers||!!t.shiftKey==!!e.shiftKey&&!!t.ctrlKey==!!e.ctrlKey&&!!t.altKey==!!e.altKey&&!!t.metaKey==!!e.metaKey)}function Pbe(e){return e.length===1?{combo:e,key:e,event:"keydown"}:e.split("+").reduce(function(t,r){var n=r.split(":"),i=n[0],o=n[1];return i in e0t?(t[e0t[i]]=!0,t.hasModifiers=!0):(t.key=i,t.event=o||"keydown"),t},{combo:e.split(":").shift()})}function i0t(e){return e.trim().split(" ").map(function(t){return Pbe(t)})}var Oo={properties:{keyEventTarget:{type:Object,value:function(){return this}},stopKeyboardEventPropagation:{type:Boolean,value:!1},_boundKeyHandlers:{type:Array,value:function(){return[]}},_imperativeKeyBindings:{type:Object,value:function(){return{}}}},observers:["_resetKeyEventListeners(keyEventTarget, _boundKeyHandlers)"],keyBindings:{},registered:function(){this._prepKeyBindings()},attached:function(){this._listenKeyEventListeners()},detached:function(){this._unlistenKeyEventListeners()},addOwnKeyBinding:function(e,t){this._imperativeKeyBindings[e]=t,this._prepKeyBindings(),this._resetKeyEventListeners()},removeOwnKeyBindings:function(){this._imperativeKeyBindings={},this._prepKeyBindings(),this._resetKeyEventListeners()},keyboardEventMatchesKeys:function(e,t){for(var r=i0t(t),n=0;n<r.length;++n)if(n0t(r[n],e))return!0;return!1},_collectKeyBindings:function(){var e=this.behaviors.map(function(t){return t.keyBindings});return e.indexOf(this.keyBindings)===-1&&e.push(this.keyBindings),e},_prepKeyBindings:function(){this._keyBindings={},this._collectKeyBindings().forEach(function(r){for(var n in r)this._addKeyBinding(n,r[n])},this);for(var e in this._imperativeKeyBindings)this._addKeyBinding(e,this._imperativeKeyBindings[e]);for(var t in this._keyBindings)this._keyBindings[t].sort(function(r,n){var i=r[0].hasModifiers,o=n[0].hasModifiers;return i===o?0:i?-1:1})},_addKeyBinding:function(e,t){i0t(e).forEach(function(r){this._keyBindings[r.event]=this._keyBindings[r.event]||[],this._keyBindings[r.event].push([r,t])},this)},_resetKeyEventListeners:function(){this._unlistenKeyEventListeners(),this.isAttached&&this._listenKeyEventListeners()},_listenKeyEventListeners:function(){!this.keyEventTarget||Object.keys(this._keyBindings).forEach(function(e){var t=this._keyBindings[e],r=this._onKeyBindingEvent.bind(this,t);this._boundKeyHandlers.push([this.keyEventTarget,e,r]),this.keyEventTarget.addEventListener(e,r)},this)},_unlistenKeyEventListeners:function(){for(var e,t,r,n;this._boundKeyHandlers.length;)e=this._boundKeyHandlers.pop(),t=e[0],r=e[1],n=e[2],t.removeEventListener(r,n)},_onKeyBindingEvent:function(e,t){if(this.stopKeyboardEventPropagation&&t.stopPropagation(),!t.defaultPrevented)for(var r=0;r<e.length;r++){var n=e[r][0],i=e[r][1];if(n0t(n,t)&&(this._triggerKeyHandler(n,i,t),t.defaultPrevented))return}},_triggerKeyHandler:function(e,t,r){var n=Object.create(e);n.keyboardEvent=r;var i=new CustomEvent(e.event,{detail:n,cancelable:!0});this[t].call(this,i),i.defaultPrevented&&r.preventDefault()}};var v9={properties:{scrollTarget:{type:HTMLElement,value:function(){return this._defaultScrollTarget}}},observers:["_scrollTargetChanged(scrollTarget, isAttached)"],_shouldHaveListener:!0,_scrollTargetChanged:function(e,t){var r;if(this._oldScrollTarget&&(this._toggleScrollListener(!1,this._oldScrollTarget),this._oldScrollTarget=null),!!t)if(e==="document")this.scrollTarget=this._doc;else if(typeof e=="string"){var n=this.domHost;this.scrollTarget=n&&n.$?n.$[e]:zt(this.ownerDocument).querySelector("#"+e)}else this._isValidScrollTarget()&&(this._oldScrollTarget=e,this._toggleScrollListener(this._shouldHaveListener,e))},_scrollHandler:function(){},get _defaultScrollTarget(){return this._doc},get _doc(){return this.ownerDocument.documentElement},get _scrollTop(){return this._isValidScrollTarget()?this.scrollTarget===this._doc?window.pageYOffset:this.scrollTarget.scrollTop:0},get _scrollLeft(){return this._isValidScrollTarget()?this.scrollTarget===this._doc?window.pageXOffset:this.scrollTarget.scrollLeft:0},set _scrollTop(e){this.scrollTarget===this._doc?window.scrollTo(window.pageXOffset,e):this._isValidScrollTarget()&&(this.scrollTarget.scrollTop=e)},set _scrollLeft(e){this.scrollTarget===this._doc?window.scrollTo(e,window.pageYOffset):this._isValidScrollTarget()&&(this.scrollTarget.scrollLeft=e)},scroll:function(e,t){var r;typeof e=="object"?(r=e.left,t=e.top):r=e,r=r||0,t=t||0,this.scrollTarget===this._doc?window.scrollTo(r,t):this._isValidScrollTarget()&&(this.scrollTarget.scrollLeft=r,this.scrollTarget.scrollTop=t)},get _scrollTargetWidth(){return this._isValidScrollTarget()?this.scrollTarget===this._doc?window.innerWidth:this.scrollTarget.offsetWidth:0},get _scrollTargetHeight(){return this._isValidScrollTarget()?this.scrollTarget===this._doc?window.innerHeight:this.scrollTarget.offsetHeight:0},_isValidScrollTarget:function(){return this.scrollTarget instanceof HTMLElement},_toggleScrollListener:function(e,t){var r=t===this._doc?window:t;e?this._boundScrollHandler||(this._boundScrollHandler=this._scrollHandler.bind(this),r.addEventListener("scroll",this._boundScrollHandler)):this._boundScrollHandler&&(r.removeEventListener("scroll",this._boundScrollHandler),this._boundScrollHandler=null)},toggleScrollListener:function(e){this._shouldHaveListener=e,this._toggleScrollListener(e,this.scrollTarget)}};var o0t=navigator.userAgent.match(/iP(?:hone|ad;(?: U;)? CPU) OS (\d+)/),Ibe=o0t&&o0t[1]>=8,a0t=3,s0t="-10000px",fE=-100;Yt({_template:Q`
    <style>
      :host {
        display: block;
      }

      @media only screen and (-webkit-max-device-pixel-ratio: 1) {
        :host {
          will-change: transform;
        }
      }

      #items {
        @apply --iron-list-items-container;
        position: relative;
      }

      :host(:not([grid])) #items > ::slotted(*) {
        width: 100%;
      }

      #items > ::slotted(*) {
        box-sizing: border-box;
        margin: 0;
        position: absolute;
        top: 0;
        will-change: transform;
      }
    </style>

    <array-selector id="selector" items="{{items}}" selected="{{selectedItems}}" selected-item="{{selectedItem}}"></array-selector>

    <div id="items">
      <slot></slot>
    </div>
`,is:"iron-list",properties:{items:{type:Array},as:{type:String,value:"item"},indexAs:{type:String,value:"index"},selectedAs:{type:String,value:"selected"},grid:{type:Boolean,value:!1,reflectToAttribute:!0,observer:"_gridChanged"},selectionEnabled:{type:Boolean,value:!1},selectedItem:{type:Object,notify:!0},selectedItems:{type:Object,notify:!0},multiSelection:{type:Boolean,value:!1},scrollOffset:{type:Number,value:0}},observers:["_itemsChanged(items.*)","_selectionEnabledChanged(selectionEnabled)","_multiSelectionChanged(multiSelection)","_setOverflow(scrollTarget, scrollOffset)"],behaviors:[Wgt,Js,v9,Kgt],_ratio:.5,_scrollerPaddingTop:0,_scrollPosition:0,_physicalSize:0,_physicalAverage:0,_physicalAverageCount:0,_physicalTop:0,_virtualCount:0,_estScrollHeight:0,_scrollHeight:0,_viewportHeight:0,_viewportWidth:0,_physicalItems:null,_physicalSizes:null,_firstVisibleIndexVal:null,_lastVisibleIndexVal:null,_maxPages:2,_focusedItem:null,_focusedVirtualIndex:-1,_focusedPhysicalIndex:-1,_offscreenFocusedItem:null,_focusBackfillItem:null,_itemsPerRow:1,_itemWidth:0,_rowHeight:0,_templateCost:0,_parentModel:!0,get _physicalBottom(){return this._physicalTop+this._physicalSize},get _scrollBottom(){return this._scrollPosition+this._viewportHeight},get _virtualEnd(){return this._virtualStart+this._physicalCount-1},get _hiddenContentSize(){var e=this.grid?this._physicalRows*this._rowHeight:this._physicalSize;return e-this._viewportHeight},get _itemsParent(){return zt(zt(this._userTemplate).parentNode)},get _maxScrollTop(){return this._estScrollHeight-this._viewportHeight+this._scrollOffset},get _maxVirtualStart(){var e=this._convertIndexToCompleteRow(this._virtualCount);return Math.max(0,e-this._physicalCount)},set _virtualStart(e){e=this._clamp(e,0,this._maxVirtualStart),this.grid&&(e=e-e%this._itemsPerRow),this._virtualStartVal=e},get _virtualStart(){return this._virtualStartVal||0},set _physicalStart(e){e=e%this._physicalCount,e<0&&(e=this._physicalCount+e),this.grid&&(e=e-e%this._itemsPerRow),this._physicalStartVal=e},get _physicalStart(){return this._physicalStartVal||0},get _physicalEnd(){return(this._physicalStart+this._physicalCount-1)%this._physicalCount},set _physicalCount(e){this._physicalCountVal=e},get _physicalCount(){return this._physicalCountVal||0},get _optPhysicalSize(){return this._viewportHeight===0?1/0:this._viewportHeight*this._maxPages},get _isVisible(){return Boolean(this.offsetWidth||this.offsetHeight)},get firstVisibleIndex(){var e=this._firstVisibleIndexVal;if(e==null){var t=this._physicalTop+this._scrollOffset;e=this._iterateItems(function(r,n){if(t+=this._getPhysicalSizeIncrement(r),t>this._scrollPosition)return this.grid?n-n%this._itemsPerRow:n;if(this.grid&&this._virtualCount-1===n)return n-n%this._itemsPerRow})||0,this._firstVisibleIndexVal=e}return e},get lastVisibleIndex(){var e=this._lastVisibleIndexVal;if(e==null){if(this.grid)e=Math.min(this._virtualCount,this.firstVisibleIndex+this._estRowsInView*this._itemsPerRow-1);else{var t=this._physicalTop+this._scrollOffset;this._iterateItems(function(r,n){t<this._scrollBottom&&(e=n),t+=this._getPhysicalSizeIncrement(r)})}this._lastVisibleIndexVal=e}return e},get _defaultScrollTarget(){return this},get _virtualRowCount(){return Math.ceil(this._virtualCount/this._itemsPerRow)},get _estRowsInView(){return Math.ceil(this._viewportHeight/this._rowHeight)},get _physicalRows(){return Math.ceil(this._physicalCount/this._itemsPerRow)},get _scrollOffset(){return this._scrollerPaddingTop+this.scrollOffset},ready:function(){this.addEventListener("focus",this._didFocus.bind(this),!0)},attached:function(){this._debounce("_render",this._render,Ni),this.listen(this,"iron-resize","_resizeHandler"),this.listen(this,"keydown","_keydownHandler")},detached:function(){this.unlisten(this,"iron-resize","_resizeHandler"),this.unlisten(this,"keydown","_keydownHandler")},_setOverflow:function(e){this.style.webkitOverflowScrolling=e===this?"touch":"",this.style.overflowY=e===this?"auto":"",this._lastVisibleIndexVal=null,this._firstVisibleIndexVal=null,this._debounce("_render",this._render,Ni)},updateViewportBoundaries:function(){var e=window.getComputedStyle(this);this._scrollerPaddingTop=this.scrollTarget===this?0:parseInt(e["padding-top"],10),this._isRTL=Boolean(e.direction==="rtl"),this._viewportWidth=this.$.items.offsetWidth,this._viewportHeight=this._scrollTargetHeight,this.grid&&this._updateGridMetrics()},_scrollHandler:function(){var e=Math.max(0,Math.min(this._maxScrollTop,this._scrollTop)),t=e-this._scrollPosition,r=t>=0;if(this._scrollPosition=e,this._firstVisibleIndexVal=null,this._lastVisibleIndexVal=null,Math.abs(t)>this._physicalSize&&this._physicalSize>0){t=t-this._scrollOffset;var n=Math.round(t/this._physicalAverage)*this._itemsPerRow;this._virtualStart=this._virtualStart+n,this._physicalStart=this._physicalStart+n,this._physicalTop=Math.min(Math.floor(this._virtualStart/this._itemsPerRow)*this._physicalAverage,this._scrollPosition),this._update()}else if(this._physicalCount>0){var i=this._getReusables(r);r?(this._physicalTop=i.physicalTop,this._virtualStart=this._virtualStart+i.indexes.length,this._physicalStart=this._physicalStart+i.indexes.length):(this._virtualStart=this._virtualStart-i.indexes.length,this._physicalStart=this._physicalStart-i.indexes.length),this._update(i.indexes,r?null:i.indexes),this._debounce("_increasePoolIfNeeded",this._increasePoolIfNeeded.bind(this,0),li)}},_getReusables:function(e){var t,r,n,i,o=[],a=this._hiddenContentSize*this._ratio,s=this._virtualStart,l=this._virtualEnd,c=this._physicalCount,u=this._physicalTop+this._scrollOffset,h=this._physicalBottom+this._scrollOffset,f=this._scrollPosition,p=this._scrollBottom;for(e?(t=this._physicalStart,r=this._physicalEnd,n=f-u):(t=this._physicalEnd,r=this._physicalStart,n=h-p);i=this._getPhysicalSizeIncrement(t),n=n-i,!(o.length>=c||n<=a);)if(e){if(l+o.length+1>=this._virtualCount||u+i>=f-this._scrollOffset)break;o.push(t),u=u+i,t=(t+1)%c}else{if(s-o.length<=0||u+this._physicalSize-i<=p)break;o.push(t),u=u-i,t=t===0?c-1:t-1}return{indexes:o,physicalTop:u-this._scrollOffset}},_update:function(e,t){if(!(e&&e.length===0||this._physicalCount===0)){if(this._manageFocus(),this._assignModels(e),this._updateMetrics(e),t)for(;t.length;){var r=t.pop();this._physicalTop-=this._getPhysicalSizeIncrement(r)}this._positionItems(),this._updateScrollerSize()}},_createPool:function(e){this._ensureTemplatized();var t,r,n=new Array(e);for(t=0;t<e;t++)r=this.stamp(null),n[t]=r.root.querySelector("*"),this._itemsParent.appendChild(r.root);return n},_isClientFull:function(){return this._scrollBottom!=0&&this._physicalBottom-1>=this._scrollBottom&&this._physicalTop<=this._scrollPosition},_increasePoolIfNeeded:function(e){var t=this._clamp(this._physicalCount+e,a0t,this._virtualCount-this._virtualStart);if(t=this._convertIndexToCompleteRow(t),this.grid){var r=t%this._itemsPerRow;r&&t-r<=this._physicalCount&&(t+=this._itemsPerRow),t-=r}var n=t-this._physicalCount,i=Math.round(this._physicalCount*.5);if(!(n<0)){if(n>0){var o=window.performance.now();[].push.apply(this._physicalItems,this._createPool(n));for(var a=0;a<n;a++)this._physicalSizes.push(0);this._physicalCount=this._physicalCount+n,this._physicalStart>this._physicalEnd&&this._isIndexRendered(this._focusedVirtualIndex)&&this._getPhysicalIndex(this._focusedVirtualIndex)<this._physicalEnd&&(this._physicalStart=this._physicalStart+n),this._update(),this._templateCost=(window.performance.now()-o)/n,i=Math.round(this._physicalCount*.5)}this._virtualEnd>=this._virtualCount-1||i===0||(this._isClientFull()?this._physicalSize<this._optPhysicalSize&&this._debounce("_increasePoolIfNeeded",this._increasePoolIfNeeded.bind(this,this._clamp(Math.round(50/this._templateCost),1,i)),kx):this._debounce("_increasePoolIfNeeded",this._increasePoolIfNeeded.bind(this,i),li))}},_render:function(){if(!(!this.isAttached||!this._isVisible))if(this._physicalCount!==0){var e=this._getReusables(!0);this._physicalTop=e.physicalTop,this._virtualStart=this._virtualStart+e.indexes.length,this._physicalStart=this._physicalStart+e.indexes.length,this._update(e.indexes),this._update(),this._increasePoolIfNeeded(0)}else this._virtualCount>0&&(this.updateViewportBoundaries(),this._increasePoolIfNeeded(a0t))},_ensureTemplatized:function(){if(!this.ctor){this._userTemplate=this.queryEffectiveChildren("template"),this._userTemplate||console.warn("iron-list requires a template to be provided in light-dom");var e={};e.__key__=!0,e[this.as]=!0,e[this.indexAs]=!0,e[this.selectedAs]=!0,e.tabIndex=!0,this._instanceProps=e,this.templatize(this._userTemplate,this.mutableData)}},_gridChanged:function(e,t){typeof t!="undefined"&&(this.notifyResize(),ci(),e&&this._updateGridMetrics())},_itemsChanged:function(e){if(e.path==="items")this._virtualStart=0,this._physicalTop=0,this._virtualCount=this.items?this.items.length:0,this._physicalIndexForKey={},this._firstVisibleIndexVal=null,this._lastVisibleIndexVal=null,this._physicalCount=this._physicalCount||0,this._physicalItems=this._physicalItems||[],this._physicalSizes=this._physicalSizes||[],this._physicalStart=0,this._scrollTop>this._scrollOffset&&this._resetScrollPosition(0),this._removeFocusedItem(),this._debounce("_render",this._render,Ni);else if(e.path==="items.splices"){this._adjustVirtualIndex(e.value.indexSplices),this._virtualCount=this.items?this.items.length:0;var t=e.value.indexSplices.some(function(i){return i.addedCount>0||i.removed.length>0});if(t){var r=this._getActiveElement();this.contains(r)&&r.blur()}var n=e.value.indexSplices.some(function(i){return i.index+i.addedCount>=this._virtualStart&&i.index<=this._virtualEnd},this);(!this._isClientFull()||n)&&this._debounce("_render",this._render,Ni)}else e.path!=="items.length"&&this._forwardItemPath(e.path,e.value)},_forwardItemPath:function(e,t){e=e.slice(6);var r=e.indexOf(".");r===-1&&(r=e.length);var n,i,o,a=this.modelForElement(this._offscreenFocusedItem),s=parseInt(e.substring(0,r),10);n=this._isIndexRendered(s),n?(i=this._getPhysicalIndex(s),o=this.modelForElement(this._physicalItems[i])):a&&(o=a),!(!o||o[this.indexAs]!==s)&&(e=e.substring(r+1),e=this.as+(e?"."+e:""),o._setPendingPropertyOrPath(e,t,!1,!0),o._flushProperties&&o._flushProperties(),n&&(this._updateMetrics([i]),this._positionItems(),this._updateScrollerSize()))},_adjustVirtualIndex:function(e){e.forEach(function(t){if(t.removed.forEach(this._removeItem,this),t.index<this._virtualStart){var r=Math.max(t.addedCount-t.removed.length,t.index-this._virtualStart);this._virtualStart=this._virtualStart+r,this._focusedVirtualIndex>=0&&(this._focusedVirtualIndex=this._focusedVirtualIndex+r)}},this)},_removeItem:function(e){this.$.selector.deselect(e),this._focusedItem&&this.modelForElement(this._focusedItem)[this.as]===e&&this._removeFocusedItem()},_iterateItems:function(e,t){var r,n,i,o;if(arguments.length===2&&t){for(o=0;o<t.length;o++)if(r=t[o],n=this._computeVidx(r),(i=e.call(this,r,n))!=null)return i}else{for(r=this._physicalStart,n=this._virtualStart;r<this._physicalCount;r++,n++)if((i=e.call(this,r,n))!=null)return i;for(r=0;r<this._physicalStart;r++,n++)if((i=e.call(this,r,n))!=null)return i}},_computeVidx:function(e){return e>=this._physicalStart?this._virtualStart+(e-this._physicalStart):this._virtualStart+(this._physicalCount-this._physicalStart)+e},_assignModels:function(e){this._iterateItems(function(t,r){var n=this._physicalItems[t],i=this.items&&this.items[r];if(i!=null){var o=this.modelForElement(n);o.__key__=null,this._forwardProperty(o,this.as,i),this._forwardProperty(o,this.selectedAs,this.$.selector.isSelected(i)),this._forwardProperty(o,this.indexAs,r),this._forwardProperty(o,"tabIndex",this._focusedVirtualIndex===r?0:-1),this._physicalIndexForKey[o.__key__]=t,o._flushProperties&&o._flushProperties(!0),n.removeAttribute("hidden")}else n.setAttribute("hidden","")},e)},_updateMetrics:function(e){ci();var t=0,r=0,n=this._physicalAverageCount,i=this._physicalAverage;this._iterateItems(function(o,a){r+=this._physicalSizes[o],this._physicalSizes[o]=this._physicalItems[o].offsetHeight,t+=this._physicalSizes[o],this._physicalAverageCount+=this._physicalSizes[o]?1:0},e),this.grid?(this._updateGridMetrics(),this._physicalSize=Math.ceil(this._physicalCount/this._itemsPerRow)*this._rowHeight):(r=this._itemsPerRow===1?r:Math.ceil(this._physicalCount/this._itemsPerRow)*this._rowHeight,this._physicalSize=this._physicalSize+t-r,this._itemsPerRow=1),this._physicalAverageCount!==n&&(this._physicalAverage=Math.round((i*n+t)/this._physicalAverageCount))},_updateGridMetrics:function(){this._itemWidth=this._physicalCount>0?this._physicalItems[0].getBoundingClientRect().width:200,this._rowHeight=this._physicalCount>0?this._physicalItems[0].offsetHeight:200,this._itemsPerRow=this._itemWidth?Math.floor(this._viewportWidth/this._itemWidth):this._itemsPerRow},_positionItems:function(){this._adjustScrollPosition();var e=this._physicalTop;if(this.grid){var t=this._itemsPerRow*this._itemWidth,r=(this._viewportWidth-t)/2;this._iterateItems(function(n,i){var o=i%this._itemsPerRow,a=Math.floor(o*this._itemWidth+r);this._isRTL&&(a=a*-1),this.translate3d(a+"px",e+"px",0,this._physicalItems[n]),this._shouldRenderNextRow(i)&&(e+=this._rowHeight)})}else{let n=[];this._iterateItems(function(i,o){let a=this._physicalItems[i];this.translate3d(0,e+"px",0,a),e+=this._physicalSizes[i];let s=a.id;s&&n.push(s)}),n.length&&this.setAttribute("aria-owns",n.join(" "))}},_getPhysicalSizeIncrement:function(e){return this.grid?this._computeVidx(e)%this._itemsPerRow!==this._itemsPerRow-1?0:this._rowHeight:this._physicalSizes[e]},_shouldRenderNextRow:function(e){return e%this._itemsPerRow===this._itemsPerRow-1},_adjustScrollPosition:function(){var e=this._virtualStart===0?this._physicalTop:Math.min(this._scrollPosition+this._physicalTop,0);if(e!==0){this._physicalTop=this._physicalTop-e;var t=this._scrollPosition;!Ibe&&t>0&&this._resetScrollPosition(t-e)}},_resetScrollPosition:function(e){this.scrollTarget&&e>=0&&(this._scrollTop=e,this._scrollPosition=this._scrollTop)},_updateScrollerSize:function(e){this.grid?this._estScrollHeight=this._virtualRowCount*this._rowHeight:this._estScrollHeight=this._physicalBottom+Math.max(this._virtualCount-this._physicalCount-this._virtualStart,0)*this._physicalAverage,e=e||this._scrollHeight===0,e=e||this._scrollPosition>=this._estScrollHeight-this._physicalSize,e=e||this.grid&&this.$.items.style.height<this._estScrollHeight,(e||Math.abs(this._estScrollHeight-this._scrollHeight)>=this._viewportHeight)&&(this.$.items.style.height=this._estScrollHeight+"px",this._scrollHeight=this._estScrollHeight)},scrollToItem:function(e){return this.scrollToIndex(this.items.indexOf(e))},scrollToIndex:function(e){if(!(typeof e!="number"||e<0||e>this.items.length-1)&&(ci(),this._physicalCount!==0)){e=this._clamp(e,0,this._virtualCount-1),(!this._isIndexRendered(e)||e>=this._maxVirtualStart)&&(this._virtualStart=this.grid?e-this._itemsPerRow*2:e-1),this._manageFocus(),this._assignModels(),this._updateMetrics(),this._physicalTop=Math.floor(this._virtualStart/this._itemsPerRow)*this._physicalAverage;for(var t=this._physicalStart,r=this._virtualStart,n=0,i=this._hiddenContentSize;r<e&&n<=i;)n=n+this._getPhysicalSizeIncrement(t),t=(t+1)%this._physicalCount,r++;this._updateScrollerSize(!0),this._positionItems(),this._resetScrollPosition(this._physicalTop+this._scrollOffset+n),this._increasePoolIfNeeded(0),this._firstVisibleIndexVal=null,this._lastVisibleIndexVal=null}},_resetAverage:function(){this._physicalAverage=0,this._physicalAverageCount=0},_resizeHandler:function(){this._debounce("_render",function(){this._firstVisibleIndexVal=null,this._lastVisibleIndexVal=null,this._isVisible?(this.updateViewportBoundaries(),this.toggleScrollListener(!0),this._resetAverage(),this._render()):this.toggleScrollListener(!1)},Ni)},selectItem:function(e){return this.selectIndex(this.items.indexOf(e))},selectIndex:function(e){if(!(e<0||e>=this._virtualCount)){if(!this.multiSelection&&this.selectedItem&&this.clearSelection(),this._isIndexRendered(e)){var t=this.modelForElement(this._physicalItems[this._getPhysicalIndex(e)]);t&&(t[this.selectedAs]=!0),this.updateSizeForIndex(e)}this.$.selector.selectIndex(e)}},deselectItem:function(e){return this.deselectIndex(this.items.indexOf(e))},deselectIndex:function(e){if(!(e<0||e>=this._virtualCount)){if(this._isIndexRendered(e)){var t=this.modelForElement(this._physicalItems[this._getPhysicalIndex(e)]);t[this.selectedAs]=!1,this.updateSizeForIndex(e)}this.$.selector.deselectIndex(e)}},toggleSelectionForItem:function(e){return this.toggleSelectionForIndex(this.items.indexOf(e))},toggleSelectionForIndex:function(e){var t=this.$.selector.isIndexSelected?this.$.selector.isIndexSelected(e):this.$.selector.isSelected(this.items[e]);t?this.deselectIndex(e):this.selectIndex(e)},clearSelection:function(){this._iterateItems(function(e,t){this.modelForElement(this._physicalItems[e])[this.selectedAs]=!1}),this.$.selector.clearSelection()},_selectionEnabledChanged:function(e){var t=e?this.listen:this.unlisten;t.call(this,this,"tap","_selectionHandler")},_selectionHandler:function(e){var t=this.modelForElement(e.target);if(!!t){var r,n,i=zt(e).path[0],o=this._getActiveElement(),a=this._physicalItems[this._getPhysicalIndex(t[this.indexAs])];i.localName==="input"||i.localName==="button"||i.localName==="select"||(r=t.tabIndex,t.tabIndex=fE,n=o?o.tabIndex:-1,t.tabIndex=r,!(o&&a!==o&&a.contains(o)&&n!==fE)&&this.toggleSelectionForItem(t[this.as]))}},_multiSelectionChanged:function(e){this.clearSelection(),this.$.selector.multi=e},updateSizeForItem:function(e){return this.updateSizeForIndex(this.items.indexOf(e))},updateSizeForIndex:function(e){return this._isIndexRendered(e)&&(this._updateMetrics([this._getPhysicalIndex(e)]),this._positionItems()),null},_manageFocus:function(){var e=this._focusedVirtualIndex;e>=0&&e<this._virtualCount?this._isIndexRendered(e)?this._restoreFocusedItem():this._createFocusBackfillItem():this._virtualCount>0&&this._physicalCount>0&&(this._focusedPhysicalIndex=this._physicalStart,this._focusedVirtualIndex=this._virtualStart,this._focusedItem=this._physicalItems[this._physicalStart])},_convertIndexToCompleteRow:function(e){return this._itemsPerRow=this._itemsPerRow||1,this.grid?Math.ceil(e/this._itemsPerRow)*this._itemsPerRow:e},_isIndexRendered:function(e){return e>=this._virtualStart&&e<=this._virtualEnd},_isIndexVisible:function(e){return e>=this.firstVisibleIndex&&e<=this.lastVisibleIndex},_getPhysicalIndex:function(e){return(this._physicalStart+(e-this._virtualStart))%this._physicalCount},focusItem:function(e){this._focusPhysicalItem(e)},_focusPhysicalItem:function(e){if(!(e<0||e>=this._virtualCount)){this._restoreFocusedItem(),this._isIndexRendered(e)||this.scrollToIndex(e);var t=this._physicalItems[this._getPhysicalIndex(e)],r=this.modelForElement(t),n;r.tabIndex=fE,t.tabIndex===fE&&(n=t),n||(n=zt(t).querySelector('[tabindex="'+fE+'"]')),r.tabIndex=0,this._focusedVirtualIndex=e,n&&n.focus()}},_removeFocusedItem:function(){this._offscreenFocusedItem&&this._itemsParent.removeChild(this._offscreenFocusedItem),this._offscreenFocusedItem=null,this._focusBackfillItem=null,this._focusedItem=null,this._focusedVirtualIndex=-1,this._focusedPhysicalIndex=-1},_createFocusBackfillItem:function(){var e=this._focusedPhysicalIndex;if(!(this._offscreenFocusedItem||this._focusedVirtualIndex<0)){if(!this._focusBackfillItem){var t=this.stamp(null);this._focusBackfillItem=t.root.querySelector("*"),this._itemsParent.appendChild(t.root)}this._offscreenFocusedItem=this._physicalItems[e],this.modelForElement(this._offscreenFocusedItem).tabIndex=0,this._physicalItems[e]=this._focusBackfillItem,this._focusedPhysicalIndex=e,this.translate3d(0,s0t,0,this._offscreenFocusedItem)}},_restoreFocusedItem:function(){if(!(!this._offscreenFocusedItem||this._focusedVirtualIndex<0)){this._assignModels();var e=this._focusedPhysicalIndex=this._getPhysicalIndex(this._focusedVirtualIndex),t=this._physicalItems[e];if(!!t){var r=this.modelForElement(t),n=this.modelForElement(this._offscreenFocusedItem);r[this.as]===n[this.as]?(this._focusBackfillItem=t,r.tabIndex=-1,this._physicalItems[e]=this._offscreenFocusedItem,this.translate3d(0,s0t,0,this._focusBackfillItem)):(this._removeFocusedItem(),this._focusBackfillItem=null),this._offscreenFocusedItem=null}}},_didFocus:function(e){var t=this.modelForElement(e.target),r=this.modelForElement(this._focusedItem),n=this._offscreenFocusedItem!==null,i=this._focusedVirtualIndex;!t||(r===t?this._isIndexVisible(i)||this.scrollToIndex(i):(this._restoreFocusedItem(),r&&(r.tabIndex=-1),t.tabIndex=0,i=t[this.indexAs],this._focusedVirtualIndex=i,this._focusedPhysicalIndex=this._getPhysicalIndex(i),this._focusedItem=this._physicalItems[this._focusedPhysicalIndex],n&&!this._offscreenFocusedItem&&this._update()))},_keydownHandler:function(e){switch(e.keyCode){case 40:this._focusedVirtualIndex<this._virtualCount-1&&e.preventDefault(),this._focusPhysicalItem(this._focusedVirtualIndex+(this.grid?this._itemsPerRow:1));break;case 39:this.grid&&this._focusPhysicalItem(this._focusedVirtualIndex+(this._isRTL?-1:1));break;case 38:this._focusedVirtualIndex>0&&e.preventDefault(),this._focusPhysicalItem(this._focusedVirtualIndex-(this.grid?this._itemsPerRow:1));break;case 37:this.grid&&this._focusPhysicalItem(this._focusedVirtualIndex+(this._isRTL?1:-1));break;case 13:this._focusPhysicalItem(this._focusedVirtualIndex),this.selectionEnabled&&this._selectionHandler(e);break}},_clamp:function(e,t,r){return Math.min(r,Math.max(t,e))},_debounce:function(e,t,r){this._debouncers=this._debouncers||{},this._debouncers[e]=sr.debounce(this._debouncers[e],r,t.bind(this)),Jl(this._debouncers[e])},_forwardProperty:function(e,t,r){e._setPendingProperty(t,r)},_forwardHostPropV2:function(e,t){(this._physicalItems||[]).concat([this._offscreenFocusedItem,this._focusBackfillItem]).forEach(function(r){r&&this.modelForElement(r).forwardHostProp(e,t)},this)},_notifyInstancePropV2:function(e,t,r){if(OI(this.as,t)){var n=e[this.indexAs];t==this.as&&(this.items[n]=r),this.notifyPath(dp(this.as,"items."+n,t),r)}},_getStampedChildren:function(){return this._physicalItems},_forwardInstancePath:function(e,t,r){t.indexOf(this.as+".")===0&&this.notifyPath("items."+e.__key__+"."+t.slice(this.as.length+1),r)},_forwardParentPath:function(e,t){(this._physicalItems||[]).concat([this._offscreenFocusedItem,this._focusBackfillItem]).forEach(function(r){r&&this.modelForElement(r).notifyPath(e,t)},this)},_forwardParentProp:function(e,t){(this._physicalItems||[]).concat([this._offscreenFocusedItem,this._focusBackfillItem]).forEach(function(r){r&&(this.modelForElement(r)[e]=t)},this)},_getActiveElement:function(){var e=this._itemsParent.node.domHost;return zt(e?e.root:document).activeElement}});var x9=class{constructor(t){this.selection=[],this.selectCallback=t}get(){return this.multi?this.selection.slice():this.selection[0]}clear(t){this.selection.slice().forEach(function(r){(!t||t.indexOf(r)<0)&&this.setItemSelected(r,!1)},this)}isSelected(t){return this.selection.indexOf(t)>=0}setItemSelected(t,r){if(t!=null&&r!==this.isSelected(t)){if(r)this.selection.push(t);else{var n=this.selection.indexOf(t);n>=0&&this.selection.splice(n,1)}this.selectCallback&&this.selectCallback(t,r)}}select(t){this.multi?this.toggle(t):this.get()!==t&&(this.setItemSelected(this.get(),!1),this.setItemSelected(t,!0))}toggle(t){this.setItemSelected(t,!this.isSelected(t))}};var wh={properties:{attrForSelected:{type:String,value:null},selected:{type:String,notify:!0},selectedItem:{type:Object,readOnly:!0,notify:!0},activateEvent:{type:String,value:"tap",observer:"_activateEventChanged"},selectable:String,selectedClass:{type:String,value:"iron-selected"},selectedAttribute:{type:String,value:null},fallbackSelection:{type:String,value:null},items:{type:Array,readOnly:!0,notify:!0,value:function(){return[]}},_excludedLocalNames:{type:Object,value:function(){return{template:1,"dom-bind":1,"dom-if":1,"dom-repeat":1}}}},observers:["_updateAttrForSelected(attrForSelected)","_updateSelected(selected)","_checkFallback(fallbackSelection)"],created:function(){this._bindFilterItem=this._filterItem.bind(this),this._selection=new x9(this._applySelection.bind(this))},attached:function(){this._observer=this._observeItems(this),this._addListener(this.activateEvent)},detached:function(){this._observer&&zt(this).unobserveNodes(this._observer),this._removeListener(this.activateEvent)},indexOf:function(e){return this.items?this.items.indexOf(e):-1},select:function(e){this.selected=e},selectPrevious:function(){var e=this.items.length,t=e-1;this.selected!==void 0&&(t=(Number(this._valueToIndex(this.selected))-1+e)%e),this.selected=this._indexToValue(t)},selectNext:function(){var e=0;this.selected!==void 0&&(e=(Number(this._valueToIndex(this.selected))+1)%this.items.length),this.selected=this._indexToValue(e)},selectIndex:function(e){this.select(this._indexToValue(e))},forceSynchronousItemUpdate:function(){this._observer&&typeof this._observer.flush=="function"?this._observer.flush():this._updateItems()},get _shouldUpdateSelection(){return this.selected!=null},_checkFallback:function(){this._updateSelected()},_addListener:function(e){this.listen(this,e,"_activateHandler")},_removeListener:function(e){this.unlisten(this,e,"_activateHandler")},_activateEventChanged:function(e,t){this._removeListener(t),this._addListener(e)},_updateItems:function(){var e=zt(this).queryDistributedElements(this.selectable||"*");e=Array.prototype.filter.call(e,this._bindFilterItem),this._setItems(e)},_updateAttrForSelected:function(){this.selectedItem&&(this.selected=this._valueForItem(this.selectedItem))},_updateSelected:function(){this._selectSelected(this.selected)},_selectSelected:function(e){if(!!this.items){var t=this._valueToItem(this.selected);t?this._selection.select(t):this._selection.clear(),this.fallbackSelection&&this.items.length&&this._selection.get()===void 0&&(this.selected=this.fallbackSelection)}},_filterItem:function(e){return!this._excludedLocalNames[e.localName]},_valueToItem:function(e){return e==null?null:this.items[this._valueToIndex(e)]},_valueToIndex:function(e){if(this.attrForSelected){for(var t=0,r;r=this.items[t];t++)if(this._valueForItem(r)==e)return t}else return Number(e)},_indexToValue:function(e){if(this.attrForSelected){var t=this.items[e];if(t)return this._valueForItem(t)}else return e},_valueForItem:function(e){if(!e)return null;if(!this.attrForSelected){var t=this.indexOf(e);return t===-1?null:t}var r=e[wm(this.attrForSelected)];return r!=null?r:e.getAttribute(this.attrForSelected)},_applySelection:function(e,t){this.selectedClass&&this.toggleClass(this.selectedClass,t,e),this.selectedAttribute&&this.toggleAttribute(this.selectedAttribute,t,e),this._selectionChange(),this.fire("iron-"+(t?"select":"deselect"),{item:e})},_selectionChange:function(){this._setSelectedItem(this._selection.get())},_observeItems:function(e){return zt(e).observeNodes(function(t){this._updateItems(),this._updateSelected(),this.fire("iron-items-changed",t,{bubbles:!1,cancelable:!1})})},_activateHandler:function(e){for(var t=e.target,r=this.items;t&&t!=this;){var n=r.indexOf(t);if(n>=0){var i=this._indexToValue(n);this._itemActivate(i,t);return}t=t.parentNode}},_itemActivate:function(e,t){this.fire("iron-activate",{selected:e,item:t},{cancelable:!0}).defaultPrevented||this.select(e)}};Yt({_template:Q`
    <style>
      :host {
        display: block;
      }

      :host > ::slotted(:not(slot):not(.iron-selected)) {
        display: none !important;
      }
    </style>

    <slot></slot>
`,is:"iron-pages",behaviors:[Js,wh],properties:{activateEvent:{type:String,value:null}},observers:["_selectedPageChanged(selected)"],_selectedPageChanged:function(e,t){this.async(this.notifyResize)}});var l0t=Q`
<custom-style>
  <style is="custom-style">
    html {

      --shadow-transition: {
        transition: box-shadow 0.28s cubic-bezier(0.4, 0, 0.2, 1);
      };

      --shadow-none: {
        box-shadow: none;
      };

      /* from http://codepen.io/shyndman/pen/c5394ddf2e8b2a5c9185904b57421cdb */

      --shadow-elevation-2dp: {
        box-shadow: 0 2px 2px 0 rgba(0, 0, 0, 0.14),
                    0 1px 5px 0 rgba(0, 0, 0, 0.12),
                    0 3px 1px -2px rgba(0, 0, 0, 0.2);
      };

      --shadow-elevation-3dp: {
        box-shadow: 0 3px 4px 0 rgba(0, 0, 0, 0.14),
                    0 1px 8px 0 rgba(0, 0, 0, 0.12),
                    0 3px 3px -2px rgba(0, 0, 0, 0.4);
      };

      --shadow-elevation-4dp: {
        box-shadow: 0 4px 5px 0 rgba(0, 0, 0, 0.14),
                    0 1px 10px 0 rgba(0, 0, 0, 0.12),
                    0 2px 4px -1px rgba(0, 0, 0, 0.4);
      };

      --shadow-elevation-6dp: {
        box-shadow: 0 6px 10px 0 rgba(0, 0, 0, 0.14),
                    0 1px 18px 0 rgba(0, 0, 0, 0.12),
                    0 3px 5px -1px rgba(0, 0, 0, 0.4);
      };

      --shadow-elevation-8dp: {
        box-shadow: 0 8px 10px 1px rgba(0, 0, 0, 0.14),
                    0 3px 14px 2px rgba(0, 0, 0, 0.12),
                    0 5px 5px -3px rgba(0, 0, 0, 0.4);
      };

      --shadow-elevation-12dp: {
        box-shadow: 0 12px 16px 1px rgba(0, 0, 0, 0.14),
                    0 4px 22px 3px rgba(0, 0, 0, 0.12),
                    0 6px 7px -4px rgba(0, 0, 0, 0.4);
      };

      --shadow-elevation-16dp: {
        box-shadow: 0 16px 24px 2px rgba(0, 0, 0, 0.14),
                    0  6px 30px 5px rgba(0, 0, 0, 0.12),
                    0  8px 10px -5px rgba(0, 0, 0, 0.4);
      };

      --shadow-elevation-24dp: {
        box-shadow: 0 24px 38px 3px rgba(0, 0, 0, 0.14),
                    0 9px 46px 8px rgba(0, 0, 0, 0.12),
                    0 11px 15px -7px rgba(0, 0, 0, 0.4);
      };
    }
  </style>
</custom-style>`;l0t.setAttribute("style","display: none;");document.head.appendChild(l0t.content);var c0t=Q`
<dom-module id="paper-material-styles">
  <template>
    <style>
      html {
        --paper-material: {
          display: block;
          position: relative;
        };
        --paper-material-elevation-1: {
          @apply --shadow-elevation-2dp;
        };
        --paper-material-elevation-2: {
          @apply --shadow-elevation-4dp;
        };
        --paper-material-elevation-3: {
          @apply --shadow-elevation-6dp;
        };
        --paper-material-elevation-4: {
          @apply --shadow-elevation-8dp;
        };
        --paper-material-elevation-5: {
          @apply --shadow-elevation-16dp;
        };
      }
      .paper-material {
        @apply --paper-material;
      }
      .paper-material[elevation="1"] {
        @apply --paper-material-elevation-1;
      }
      .paper-material[elevation="2"] {
        @apply --paper-material-elevation-2;
      }
      .paper-material[elevation="3"] {
        @apply --paper-material-elevation-3;
      }
      .paper-material[elevation="4"] {
        @apply --paper-material-elevation-4;
      }
      .paper-material[elevation="5"] {
        @apply --paper-material-elevation-5;
      }

      /* Duplicate the styles because of https://github.com/webcomponents/shadycss/issues/193 */
      :host {
        --paper-material: {
          display: block;
          position: relative;
        };
        --paper-material-elevation-1: {
          @apply --shadow-elevation-2dp;
        };
        --paper-material-elevation-2: {
          @apply --shadow-elevation-4dp;
        };
        --paper-material-elevation-3: {
          @apply --shadow-elevation-6dp;
        };
        --paper-material-elevation-4: {
          @apply --shadow-elevation-8dp;
        };
        --paper-material-elevation-5: {
          @apply --shadow-elevation-16dp;
        };
      }
      :host(.paper-material) {
        @apply --paper-material;
      }
      :host(.paper-material[elevation="1"]) {
        @apply --paper-material-elevation-1;
      }
      :host(.paper-material[elevation="2"]) {
        @apply --paper-material-elevation-2;
      }
      :host(.paper-material[elevation="3"]) {
        @apply --paper-material-elevation-3;
      }
      :host(.paper-material[elevation="4"]) {
        @apply --paper-material-elevation-4;
      }
      :host(.paper-material[elevation="5"]) {
        @apply --paper-material-elevation-5;
      }
    </style>
  </template>
</dom-module>`;c0t.setAttribute("style","display: none;");document.head.appendChild(c0t.content);var Di={properties:{focused:{type:Boolean,value:!1,notify:!0,readOnly:!0,reflectToAttribute:!0},disabled:{type:Boolean,value:!1,notify:!0,observer:"_disabledChanged",reflectToAttribute:!0},_oldTabIndex:{type:String},_boundFocusBlurHandler:{type:Function,value:function(){return this._focusBlurHandler.bind(this)}}},observers:["_changedControlState(focused, disabled)"],ready:function(){this.addEventListener("focus",this._boundFocusBlurHandler,!0),this.addEventListener("blur",this._boundFocusBlurHandler,!0)},_focusBlurHandler:function(e){this._setFocused(e.type==="focus")},_disabledChanged:function(e,t){this.setAttribute("aria-disabled",e?"true":"false"),this.style.pointerEvents=e?"none":"",e?(this._oldTabIndex=this.getAttribute("tabindex"),this._setFocused(!1),this.tabIndex=-1,this.blur()):this._oldTabIndex!==void 0&&(this._oldTabIndex===null?this.removeAttribute("tabindex"):this.setAttribute("tabindex",this._oldTabIndex))},_changedControlState:function(){this._controlStateChanged&&this._controlStateChanged()}};var Yx={properties:{pressed:{type:Boolean,readOnly:!0,value:!1,reflectToAttribute:!0,observer:"_pressedChanged"},toggles:{type:Boolean,value:!1,reflectToAttribute:!0},active:{type:Boolean,value:!1,notify:!0,reflectToAttribute:!0},pointerDown:{type:Boolean,readOnly:!0,value:!1},receivedFocusFromKeyboard:{type:Boolean,readOnly:!0},ariaActiveAttribute:{type:String,value:"aria-pressed",observer:"_ariaActiveAttributeChanged"}},listeners:{down:"_downHandler",up:"_upHandler",tap:"_tapHandler"},observers:["_focusChanged(focused)","_activeChanged(active, ariaActiveAttribute)"],keyBindings:{"enter:keydown":"_asyncClick","space:keydown":"_spaceKeyDownHandler","space:keyup":"_spaceKeyUpHandler"},_mouseEventRe:/^mouse/,_tapHandler:function(){this.toggles?this._userActivate(!this.active):this.active=!1},_focusChanged:function(e){this._detectKeyboardFocus(e),e||this._setPressed(!1)},_detectKeyboardFocus:function(e){this._setReceivedFocusFromKeyboard(!this.pointerDown&&e)},_userActivate:function(e){this.active!==e&&(this.active=e,this.fire("change"))},_downHandler:function(e){this._setPointerDown(!0),this._setPressed(!0),this._setReceivedFocusFromKeyboard(!1)},_upHandler:function(){this._setPointerDown(!1),this._setPressed(!1)},_spaceKeyDownHandler:function(e){var t=e.detail.keyboardEvent,r=zt(t).localTarget;this.isLightDescendant(r)||(t.preventDefault(),t.stopImmediatePropagation(),this._setPressed(!0))},_spaceKeyUpHandler:function(e){var t=e.detail.keyboardEvent,r=zt(t).localTarget;this.isLightDescendant(r)||(this.pressed&&this._asyncClick(),this._setPressed(!1))},_asyncClick:function(){this.async(function(){this.click()},1)},_pressedChanged:function(e){this._changedButtonState()},_ariaActiveAttributeChanged:function(e,t){t&&t!=e&&this.hasAttribute(t)&&this.removeAttribute(t)},_activeChanged:function(e,t){this.toggles?this.setAttribute(this.ariaActiveAttribute,e?"true":"false"):this.removeAttribute(this.ariaActiveAttribute),this._changedButtonState()},_controlStateChanged:function(){this.disabled?this._setPressed(!1):this._changedButtonState()},_changedButtonState:function(){this._buttonStateChanged&&this._buttonStateChanged()}},Sh=[Oo,Yx];var Mh={distance:function(e,t,r,n){var i=e-r,o=t-n;return Math.sqrt(i*i+o*o)},now:window.performance&&window.performance.now?window.performance.now.bind(window.performance):Date.now};function u0t(e){this.element=e,this.width=this.boundingRect.width,this.height=this.boundingRect.height,this.size=Math.max(this.width,this.height)}u0t.prototype={get boundingRect(){return this.element.getBoundingClientRect()},furthestCornerDistanceFrom:function(e,t){var r=Mh.distance(e,t,0,0),n=Mh.distance(e,t,this.width,0),i=Mh.distance(e,t,0,this.height),o=Mh.distance(e,t,this.width,this.height);return Math.max(r,n,i,o)}};function g_(e){this.element=e,this.color=window.getComputedStyle(e).color,this.wave=document.createElement("div"),this.waveContainer=document.createElement("div"),this.wave.style.backgroundColor=this.color,this.wave.classList.add("wave"),this.waveContainer.classList.add("wave-container"),zt(this.waveContainer).appendChild(this.wave),this.resetInteractionState()}g_.MAX_RADIUS=300;g_.prototype={get recenters(){return this.element.recenters},get center(){return this.element.center},get mouseDownElapsed(){var e;return this.mouseDownStart?(e=Mh.now()-this.mouseDownStart,this.mouseUpStart&&(e-=this.mouseUpElapsed),e):0},get mouseUpElapsed(){return this.mouseUpStart?Mh.now()-this.mouseUpStart:0},get mouseDownElapsedSeconds(){return this.mouseDownElapsed/1e3},get mouseUpElapsedSeconds(){return this.mouseUpElapsed/1e3},get mouseInteractionSeconds(){return this.mouseDownElapsedSeconds+this.mouseUpElapsedSeconds},get initialOpacity(){return this.element.initialOpacity},get opacityDecayVelocity(){return this.element.opacityDecayVelocity},get radius(){var e=this.containerMetrics.width*this.containerMetrics.width,t=this.containerMetrics.height*this.containerMetrics.height,r=Math.min(Math.sqrt(e+t),g_.MAX_RADIUS)*1.1+5,n=1.1-.2*(r/g_.MAX_RADIUS),i=this.mouseInteractionSeconds/n,o=r*(1-Math.pow(80,-i));return Math.abs(o)},get opacity(){return this.mouseUpStart?Math.max(0,this.initialOpacity-this.mouseUpElapsedSeconds*this.opacityDecayVelocity):this.initialOpacity},get outerOpacity(){var e=this.mouseUpElapsedSeconds*.3,t=this.opacity;return Math.max(0,Math.min(e,t))},get isOpacityFullyDecayed(){return this.opacity<.01&&this.radius>=Math.min(this.maxRadius,g_.MAX_RADIUS)},get isRestingAtMaxRadius(){return this.opacity>=this.initialOpacity&&this.radius>=Math.min(this.maxRadius,g_.MAX_RADIUS)},get isAnimationComplete(){return this.mouseUpStart?this.isOpacityFullyDecayed:this.isRestingAtMaxRadius},get translationFraction(){return Math.min(1,this.radius/this.containerMetrics.size*2/Math.sqrt(2))},get xNow(){return this.xEnd?this.xStart+this.translationFraction*(this.xEnd-this.xStart):this.xStart},get yNow(){return this.yEnd?this.yStart+this.translationFraction*(this.yEnd-this.yStart):this.yStart},get isMouseDown(){return this.mouseDownStart&&!this.mouseUpStart},resetInteractionState:function(){this.maxRadius=0,this.mouseDownStart=0,this.mouseUpStart=0,this.xStart=0,this.yStart=0,this.xEnd=0,this.yEnd=0,this.slideDistance=0,this.containerMetrics=new u0t(this.element)},draw:function(){var e,t,r;this.wave.style.opacity=this.opacity,e=this.radius/(this.containerMetrics.size/2),t=this.xNow-this.containerMetrics.width/2,r=this.yNow-this.containerMetrics.height/2,this.waveContainer.style.webkitTransform="translate("+t+"px, "+r+"px)",this.waveContainer.style.transform="translate3d("+t+"px, "+r+"px, 0)",this.wave.style.webkitTransform="scale("+e+","+e+")",this.wave.style.transform="scale3d("+e+","+e+",1)"},downAction:function(e){var t=this.containerMetrics.width/2,r=this.containerMetrics.height/2;this.resetInteractionState(),this.mouseDownStart=Mh.now(),this.center?(this.xStart=t,this.yStart=r,this.slideDistance=Mh.distance(this.xStart,this.yStart,this.xEnd,this.yEnd)):(this.xStart=e?e.detail.x-this.containerMetrics.boundingRect.left:this.containerMetrics.width/2,this.yStart=e?e.detail.y-this.containerMetrics.boundingRect.top:this.containerMetrics.height/2),this.recenters&&(this.xEnd=t,this.yEnd=r,this.slideDistance=Mh.distance(this.xStart,this.yStart,this.xEnd,this.yEnd)),this.maxRadius=this.containerMetrics.furthestCornerDistanceFrom(this.xStart,this.yStart),this.waveContainer.style.top=(this.containerMetrics.height-this.containerMetrics.size)/2+"px",this.waveContainer.style.left=(this.containerMetrics.width-this.containerMetrics.size)/2+"px",this.waveContainer.style.width=this.containerMetrics.size+"px",this.waveContainer.style.height=this.containerMetrics.size+"px"},upAction:function(e){!this.isMouseDown||(this.mouseUpStart=Mh.now())},remove:function(){zt(zt(this.waveContainer).parentNode).removeChild(this.waveContainer)}};Yt({_template:Q`
    <style>
      :host {
        display: block;
        position: absolute;
        border-radius: inherit;
        overflow: hidden;
        top: 0;
        left: 0;
        right: 0;
        bottom: 0;

        /* See PolymerElements/paper-behaviors/issues/34. On non-Chrome browsers,
         * creating a node (with a position:absolute) in the middle of an event
         * handler "interrupts" that event handler (which happens when the
         * ripple is created on demand) */
        pointer-events: none;
      }

      :host([animating]) {
        /* This resolves a rendering issue in Chrome (as of 40) where the
           ripple is not properly clipped by its parent (which may have
           rounded corners). See: http://jsbin.com/temexa/4

           Note: We only apply this style conditionally. Otherwise, the browser
           will create a new compositing layer for every ripple element on the
           page, and that would be bad. */
        -webkit-transform: translate(0, 0);
        transform: translate3d(0, 0, 0);
      }

      #background,
      #waves,
      .wave-container,
      .wave {
        pointer-events: none;
        position: absolute;
        top: 0;
        left: 0;
        width: 100%;
        height: 100%;
      }

      #background,
      .wave {
        opacity: 0;
      }

      #waves,
      .wave {
        overflow: hidden;
      }

      .wave-container,
      .wave {
        border-radius: 50%;
      }

      :host(.circle) #background,
      :host(.circle) #waves {
        border-radius: 50%;
      }

      :host(.circle) .wave-container {
        overflow: hidden;
      }
    </style>

    <div id="background"></div>
    <div id="waves"></div>
`,is:"paper-ripple",behaviors:[Oo],properties:{initialOpacity:{type:Number,value:.25},opacityDecayVelocity:{type:Number,value:.8},recenters:{type:Boolean,value:!1},center:{type:Boolean,value:!1},ripples:{type:Array,value:function(){return[]}},animating:{type:Boolean,readOnly:!0,reflectToAttribute:!0,value:!1},holdDown:{type:Boolean,value:!1,observer:"_holdDownChanged"},noink:{type:Boolean,value:!1},_animating:{type:Boolean},_boundAnimate:{type:Function,value:function(){return this.animate.bind(this)}}},get target(){return this.keyEventTarget},keyBindings:{"enter:keydown":"_onEnterKeydown","space:keydown":"_onSpaceKeydown","space:keyup":"_onSpaceKeyup"},attached:function(){zt(this).parentNode.nodeType==11?this.keyEventTarget=zt(this).getOwnerRoot().host:this.keyEventTarget=zt(this).parentNode;var e=this.keyEventTarget;this.listen(e,"up","uiUpAction"),this.listen(e,"down","uiDownAction")},detached:function(){this.unlisten(this.keyEventTarget,"up","uiUpAction"),this.unlisten(this.keyEventTarget,"down","uiDownAction"),this.keyEventTarget=null},get shouldKeepAnimating(){for(var e=0;e<this.ripples.length;++e)if(!this.ripples[e].isAnimationComplete)return!0;return!1},simulatedRipple:function(){this.downAction(null),this.async(function(){this.upAction()},1)},uiDownAction:function(e){this.noink||this.downAction(e)},downAction:function(e){if(!(this.holdDown&&this.ripples.length>0)){var t=this.addRipple();t.downAction(e),this._animating||(this._animating=!0,this.animate())}},uiUpAction:function(e){this.noink||this.upAction(e)},upAction:function(e){this.holdDown||(this.ripples.forEach(function(t){t.upAction(e)}),this._animating=!0,this.animate())},onAnimationComplete:function(){this._animating=!1,this.$.background.style.backgroundColor="",this.fire("transitionend")},addRipple:function(){var e=new g_(this);return zt(this.$.waves).appendChild(e.waveContainer),this.$.background.style.backgroundColor=e.color,this.ripples.push(e),this._setAnimating(!0),e},removeRipple:function(e){var t=this.ripples.indexOf(e);t<0||(this.ripples.splice(t,1),e.remove(),this.ripples.length||this._setAnimating(!1))},animate:function(){if(!!this._animating){var e,t;for(e=0;e<this.ripples.length;++e)t=this.ripples[e],t.draw(),this.$.background.style.opacity=t.outerOpacity,t.isOpacityFullyDecayed&&!t.isRestingAtMaxRadius&&this.removeRipple(t);!this.shouldKeepAnimating&&this.ripples.length===0?this.onAnimationComplete():window.requestAnimationFrame(this._boundAnimate)}},animateRipple:function(){return this.animate()},_onEnterKeydown:function(){this.uiDownAction(),this.async(this.uiUpAction,1)},_onSpaceKeydown:function(){this.uiDownAction()},_onSpaceKeyup:function(){this.uiUpAction()},_holdDownChanged:function(e,t){t!==void 0&&(e?this.downAction():this.upAction())}});var su={properties:{noink:{type:Boolean,observer:"_noinkChanged"},_rippleContainer:{type:Object}},_buttonStateChanged:function(){this.focused&&this.ensureRipple()},_downHandler:function(e){Yx._downHandler.call(this,e),this.pressed&&this.ensureRipple(e)},ensureRipple:function(e){if(!this.hasRipple()){this._ripple=this._createRipple(),this._ripple.noink=this.noink;var t=this._rippleContainer||this.root;if(t&&zt(t).appendChild(this._ripple),e){var r=zt(this._rippleContainer||this),n=zt(e).rootTarget;r.deepContains(n)&&this._ripple.uiDownAction(e)}}},getRipple:function(){return this.ensureRipple(),this._ripple},hasRipple:function(){return Boolean(this._ripple)},_createRipple:function(){var e=document.createElement("paper-ripple");return e},_noinkChanged:function(e){this.hasRipple()&&(this._ripple.noink=e)}};var uW={properties:{elevation:{type:Number,reflectToAttribute:!0,readOnly:!0}},observers:["_calculateElevation(focused, disabled, active, pressed, receivedFocusFromKeyboard)","_computeKeyboardClass(receivedFocusFromKeyboard)"],hostAttributes:{role:"button",tabindex:"0",animated:!0},_calculateElevation:function(){var e=1;this.disabled?e=0:this.active||this.pressed?e=4:this.receivedFocusFromKeyboard&&(e=3),this._setElevation(e)},_computeKeyboardClass:function(e){this.toggleClass("keyboard-focus",e)},_spaceKeyDownHandler:function(e){Yx._spaceKeyDownHandler.call(this,e),this.hasRipple()&&this.getRipple().ripples.length<1&&this._ripple.uiDownAction()},_spaceKeyUpHandler:function(e){Yx._spaceKeyUpHandler.call(this,e),this.hasRipple()&&this._ripple.uiUpAction()}},h0t=[Sh,Di,su,uW];var f0t=Q`
  <style include="paper-material-styles">
    /* Need to specify the same specificity as the styles imported from paper-material. */
    :host {
      @apply --layout-inline;
      @apply --layout-center-center;
      position: relative;
      box-sizing: border-box;
      min-width: 5.14em;
      margin: 0 0.29em;
      background: transparent;
      -webkit-tap-highlight-color: rgba(0, 0, 0, 0);
      -webkit-tap-highlight-color: transparent;
      font: inherit;
      text-transform: uppercase;
      outline-width: 0;
      border-radius: 3px;
      -moz-user-select: none;
      -ms-user-select: none;
      -webkit-user-select: none;
      user-select: none;
      cursor: pointer;
      z-index: 0;
      padding: 0.7em 0.57em;

      @apply --paper-font-common-base;
      @apply --paper-button;
    }

    :host([elevation="1"]) {
      @apply --paper-material-elevation-1;
    }

    :host([elevation="2"]) {
      @apply --paper-material-elevation-2;
    }

    :host([elevation="3"]) {
      @apply --paper-material-elevation-3;
    }

    :host([elevation="4"]) {
      @apply --paper-material-elevation-4;
    }

    :host([elevation="5"]) {
      @apply --paper-material-elevation-5;
    }

    :host([hidden]) {
      display: none !important;
    }

    :host([raised].keyboard-focus) {
      font-weight: bold;
      @apply --paper-button-raised-keyboard-focus;
    }

    :host(:not([raised]).keyboard-focus) {
      font-weight: bold;
      @apply --paper-button-flat-keyboard-focus;
    }

    :host([disabled]) {
      background: none;
      color: #a8a8a8;
      cursor: auto;
      pointer-events: none;

      @apply --paper-button-disabled;
    }

    :host([disabled][raised]) {
      background: #eaeaea;
    }


    :host([animated]) {
      @apply --shadow-transition;
    }

    paper-ripple {
      color: var(--paper-button-ink-color);
    }
  </style>

  <slot></slot>`;f0t.setAttribute("strip-whitespace","");Yt({_template:f0t,is:"paper-button",behaviors:[h0t],properties:{raised:{type:Boolean,reflectToAttribute:!0,value:!1,observer:"_calculateElevation"}},_calculateElevation:function(){this.raised?uW._calculateElevation.apply(this):this._setElevation(0)}});var p0t=Q`
<custom-style>
  <style is="custom-style">
    html {

      /* Material Design color palette for Google products */

      --google-red-100: #f4c7c3;
      --google-red-300: #e67c73;
      --google-red-500: #db4437;
      --google-red-700: #c53929;

      --google-blue-100: #c6dafc;
      --google-blue-300: #7baaf7;
      --google-blue-500: #4285f4;
      --google-blue-700: #3367d6;

      --google-green-100: #b7e1cd;
      --google-green-300: #57bb8a;
      --google-green-500: #0f9d58;
      --google-green-700: #0b8043;

      --google-yellow-100: #fce8b2;
      --google-yellow-300: #f7cb4d;
      --google-yellow-500: #f4b400;
      --google-yellow-700: #f09300;

      --google-grey-100: #f5f5f5;
      --google-grey-300: #e0e0e0;
      --google-grey-500: #9e9e9e;
      --google-grey-700: #616161;

      /* Material Design color palette from online spec document */

      --paper-red-50: #ffebee;
      --paper-red-100: #ffcdd2;
      --paper-red-200: #ef9a9a;
      --paper-red-300: #e57373;
      --paper-red-400: #ef5350;
      --paper-red-500: #f44336;
      --paper-red-600: #e53935;
      --paper-red-700: #d32f2f;
      --paper-red-800: #c62828;
      --paper-red-900: #b71c1c;
      --paper-red-a100: #ff8a80;
      --paper-red-a200: #ff5252;
      --paper-red-a400: #ff1744;
      --paper-red-a700: #d50000;

      --paper-pink-50: #fce4ec;
      --paper-pink-100: #f8bbd0;
      --paper-pink-200: #f48fb1;
      --paper-pink-300: #f06292;
      --paper-pink-400: #ec407a;
      --paper-pink-500: #e91e63;
      --paper-pink-600: #d81b60;
      --paper-pink-700: #c2185b;
      --paper-pink-800: #ad1457;
      --paper-pink-900: #880e4f;
      --paper-pink-a100: #ff80ab;
      --paper-pink-a200: #ff4081;
      --paper-pink-a400: #f50057;
      --paper-pink-a700: #c51162;

      --paper-purple-50: #f3e5f5;
      --paper-purple-100: #e1bee7;
      --paper-purple-200: #ce93d8;
      --paper-purple-300: #ba68c8;
      --paper-purple-400: #ab47bc;
      --paper-purple-500: #9c27b0;
      --paper-purple-600: #8e24aa;
      --paper-purple-700: #7b1fa2;
      --paper-purple-800: #6a1b9a;
      --paper-purple-900: #4a148c;
      --paper-purple-a100: #ea80fc;
      --paper-purple-a200: #e040fb;
      --paper-purple-a400: #d500f9;
      --paper-purple-a700: #aa00ff;

      --paper-deep-purple-50: #ede7f6;
      --paper-deep-purple-100: #d1c4e9;
      --paper-deep-purple-200: #b39ddb;
      --paper-deep-purple-300: #9575cd;
      --paper-deep-purple-400: #7e57c2;
      --paper-deep-purple-500: #673ab7;
      --paper-deep-purple-600: #5e35b1;
      --paper-deep-purple-700: #512da8;
      --paper-deep-purple-800: #4527a0;
      --paper-deep-purple-900: #311b92;
      --paper-deep-purple-a100: #b388ff;
      --paper-deep-purple-a200: #7c4dff;
      --paper-deep-purple-a400: #651fff;
      --paper-deep-purple-a700: #6200ea;

      --paper-indigo-50: #e8eaf6;
      --paper-indigo-100: #c5cae9;
      --paper-indigo-200: #9fa8da;
      --paper-indigo-300: #7986cb;
      --paper-indigo-400: #5c6bc0;
      --paper-indigo-500: #3f51b5;
      --paper-indigo-600: #3949ab;
      --paper-indigo-700: #303f9f;
      --paper-indigo-800: #283593;
      --paper-indigo-900: #1a237e;
      --paper-indigo-a100: #8c9eff;
      --paper-indigo-a200: #536dfe;
      --paper-indigo-a400: #3d5afe;
      --paper-indigo-a700: #304ffe;

      --paper-blue-50: #e3f2fd;
      --paper-blue-100: #bbdefb;
      --paper-blue-200: #90caf9;
      --paper-blue-300: #64b5f6;
      --paper-blue-400: #42a5f5;
      --paper-blue-500: #2196f3;
      --paper-blue-600: #1e88e5;
      --paper-blue-700: #1976d2;
      --paper-blue-800: #1565c0;
      --paper-blue-900: #0d47a1;
      --paper-blue-a100: #82b1ff;
      --paper-blue-a200: #448aff;
      --paper-blue-a400: #2979ff;
      --paper-blue-a700: #2962ff;

      --paper-light-blue-50: #e1f5fe;
      --paper-light-blue-100: #b3e5fc;
      --paper-light-blue-200: #81d4fa;
      --paper-light-blue-300: #4fc3f7;
      --paper-light-blue-400: #29b6f6;
      --paper-light-blue-500: #03a9f4;
      --paper-light-blue-600: #039be5;
      --paper-light-blue-700: #0288d1;
      --paper-light-blue-800: #0277bd;
      --paper-light-blue-900: #01579b;
      --paper-light-blue-a100: #80d8ff;
      --paper-light-blue-a200: #40c4ff;
      --paper-light-blue-a400: #00b0ff;
      --paper-light-blue-a700: #0091ea;

      --paper-cyan-50: #e0f7fa;
      --paper-cyan-100: #b2ebf2;
      --paper-cyan-200: #80deea;
      --paper-cyan-300: #4dd0e1;
      --paper-cyan-400: #26c6da;
      --paper-cyan-500: #00bcd4;
      --paper-cyan-600: #00acc1;
      --paper-cyan-700: #0097a7;
      --paper-cyan-800: #00838f;
      --paper-cyan-900: #006064;
      --paper-cyan-a100: #84ffff;
      --paper-cyan-a200: #18ffff;
      --paper-cyan-a400: #00e5ff;
      --paper-cyan-a700: #00b8d4;

      --paper-teal-50: #e0f2f1;
      --paper-teal-100: #b2dfdb;
      --paper-teal-200: #80cbc4;
      --paper-teal-300: #4db6ac;
      --paper-teal-400: #26a69a;
      --paper-teal-500: #009688;
      --paper-teal-600: #00897b;
      --paper-teal-700: #00796b;
      --paper-teal-800: #00695c;
      --paper-teal-900: #004d40;
      --paper-teal-a100: #a7ffeb;
      --paper-teal-a200: #64ffda;
      --paper-teal-a400: #1de9b6;
      --paper-teal-a700: #00bfa5;

      --paper-green-50: #e8f5e9;
      --paper-green-100: #c8e6c9;
      --paper-green-200: #a5d6a7;
      --paper-green-300: #81c784;
      --paper-green-400: #66bb6a;
      --paper-green-500: #4caf50;
      --paper-green-600: #43a047;
      --paper-green-700: #388e3c;
      --paper-green-800: #2e7d32;
      --paper-green-900: #1b5e20;
      --paper-green-a100: #b9f6ca;
      --paper-green-a200: #69f0ae;
      --paper-green-a400: #00e676;
      --paper-green-a700: #00c853;

      --paper-light-green-50: #f1f8e9;
      --paper-light-green-100: #dcedc8;
      --paper-light-green-200: #c5e1a5;
      --paper-light-green-300: #aed581;
      --paper-light-green-400: #9ccc65;
      --paper-light-green-500: #8bc34a;
      --paper-light-green-600: #7cb342;
      --paper-light-green-700: #689f38;
      --paper-light-green-800: #558b2f;
      --paper-light-green-900: #33691e;
      --paper-light-green-a100: #ccff90;
      --paper-light-green-a200: #b2ff59;
      --paper-light-green-a400: #76ff03;
      --paper-light-green-a700: #64dd17;

      --paper-lime-50: #f9fbe7;
      --paper-lime-100: #f0f4c3;
      --paper-lime-200: #e6ee9c;
      --paper-lime-300: #dce775;
      --paper-lime-400: #d4e157;
      --paper-lime-500: #cddc39;
      --paper-lime-600: #c0ca33;
      --paper-lime-700: #afb42b;
      --paper-lime-800: #9e9d24;
      --paper-lime-900: #827717;
      --paper-lime-a100: #f4ff81;
      --paper-lime-a200: #eeff41;
      --paper-lime-a400: #c6ff00;
      --paper-lime-a700: #aeea00;

      --paper-yellow-50: #fffde7;
      --paper-yellow-100: #fff9c4;
      --paper-yellow-200: #fff59d;
      --paper-yellow-300: #fff176;
      --paper-yellow-400: #ffee58;
      --paper-yellow-500: #ffeb3b;
      --paper-yellow-600: #fdd835;
      --paper-yellow-700: #fbc02d;
      --paper-yellow-800: #f9a825;
      --paper-yellow-900: #f57f17;
      --paper-yellow-a100: #ffff8d;
      --paper-yellow-a200: #ffff00;
      --paper-yellow-a400: #ffea00;
      --paper-yellow-a700: #ffd600;

      --paper-amber-50: #fff8e1;
      --paper-amber-100: #ffecb3;
      --paper-amber-200: #ffe082;
      --paper-amber-300: #ffd54f;
      --paper-amber-400: #ffca28;
      --paper-amber-500: #ffc107;
      --paper-amber-600: #ffb300;
      --paper-amber-700: #ffa000;
      --paper-amber-800: #ff8f00;
      --paper-amber-900: #ff6f00;
      --paper-amber-a100: #ffe57f;
      --paper-amber-a200: #ffd740;
      --paper-amber-a400: #ffc400;
      --paper-amber-a700: #ffab00;

      --paper-orange-50: #fff3e0;
      --paper-orange-100: #ffe0b2;
      --paper-orange-200: #ffcc80;
      --paper-orange-300: #ffb74d;
      --paper-orange-400: #ffa726;
      --paper-orange-500: #ff9800;
      --paper-orange-600: #fb8c00;
      --paper-orange-700: #f57c00;
      --paper-orange-800: #ef6c00;
      --paper-orange-900: #e65100;
      --paper-orange-a100: #ffd180;
      --paper-orange-a200: #ffab40;
      --paper-orange-a400: #ff9100;
      --paper-orange-a700: #ff6500;

      --paper-deep-orange-50: #fbe9e7;
      --paper-deep-orange-100: #ffccbc;
      --paper-deep-orange-200: #ffab91;
      --paper-deep-orange-300: #ff8a65;
      --paper-deep-orange-400: #ff7043;
      --paper-deep-orange-500: #ff5722;
      --paper-deep-orange-600: #f4511e;
      --paper-deep-orange-700: #e64a19;
      --paper-deep-orange-800: #d84315;
      --paper-deep-orange-900: #bf360c;
      --paper-deep-orange-a100: #ff9e80;
      --paper-deep-orange-a200: #ff6e40;
      --paper-deep-orange-a400: #ff3d00;
      --paper-deep-orange-a700: #dd2c00;

      --paper-brown-50: #efebe9;
      --paper-brown-100: #d7ccc8;
      --paper-brown-200: #bcaaa4;
      --paper-brown-300: #a1887f;
      --paper-brown-400: #8d6e63;
      --paper-brown-500: #795548;
      --paper-brown-600: #6d4c41;
      --paper-brown-700: #5d4037;
      --paper-brown-800: #4e342e;
      --paper-brown-900: #3e2723;

      --paper-grey-50: #fafafa;
      --paper-grey-100: #f5f5f5;
      --paper-grey-200: #eeeeee;
      --paper-grey-300: #e0e0e0;
      --paper-grey-400: #bdbdbd;
      --paper-grey-500: #9e9e9e;
      --paper-grey-600: #757575;
      --paper-grey-700: #616161;
      --paper-grey-800: #424242;
      --paper-grey-900: #212121;

      --paper-blue-grey-50: #eceff1;
      --paper-blue-grey-100: #cfd8dc;
      --paper-blue-grey-200: #b0bec5;
      --paper-blue-grey-300: #90a4ae;
      --paper-blue-grey-400: #78909c;
      --paper-blue-grey-500: #607d8b;
      --paper-blue-grey-600: #546e7a;
      --paper-blue-grey-700: #455a64;
      --paper-blue-grey-800: #37474f;
      --paper-blue-grey-900: #263238;

      /* opacity for dark text on a light background */
      --dark-divider-opacity: 0.12;
      --dark-disabled-opacity: 0.38; /* or hint text or icon */
      --dark-secondary-opacity: 0.54;
      --dark-primary-opacity: 0.87;

      /* opacity for light text on a dark background */
      --light-divider-opacity: 0.12;
      --light-disabled-opacity: 0.3; /* or hint text or icon */
      --light-secondary-opacity: 0.7;
      --light-primary-opacity: 1.0;

    }

  </style>
</custom-style>
`;p0t.setAttribute("style","display: none;");document.head.appendChild(p0t.content);var d0t=Q`
<custom-style>
  <style is="custom-style">
    html {
      /*
       * You can use these generic variables in your elements for easy theming.
       * For example, if all your elements use \`--primary-text-color\` as its main
       * color, then switching from a light to a dark theme is just a matter of
       * changing the value of \`--primary-text-color\` in your application.
       */
      --primary-text-color: var(--light-theme-text-color);
      --primary-background-color: var(--light-theme-background-color);
      --secondary-text-color: var(--light-theme-secondary-color);
      --disabled-text-color: var(--light-theme-disabled-color);
      --divider-color: var(--light-theme-divider-color);
      --error-color: var(--paper-deep-orange-a700);

      /*
       * Primary and accent colors. Also see color.js for more colors.
       */
      --primary-color: var(--paper-indigo-500);
      --light-primary-color: var(--paper-indigo-100);
      --dark-primary-color: var(--paper-indigo-700);

      --accent-color: var(--paper-pink-a200);
      --light-accent-color: var(--paper-pink-a100);
      --dark-accent-color: var(--paper-pink-a400);


      /*
       * Material Design Light background theme
       */
      --light-theme-background-color: #ffffff;
      --light-theme-base-color: #000000;
      --light-theme-text-color: var(--paper-grey-900);
      --light-theme-secondary-color: #737373;  /* for secondary text and icons */
      --light-theme-disabled-color: #9b9b9b;  /* disabled/hint text */
      --light-theme-divider-color: #dbdbdb;

      /*
       * Material Design Dark background theme
       */
      --dark-theme-background-color: var(--paper-grey-900);
      --dark-theme-base-color: #ffffff;
      --dark-theme-text-color: #ffffff;
      --dark-theme-secondary-color: #bcbcbc;  /* for secondary text and icons */
      --dark-theme-disabled-color: #646464;  /* disabled/hint text */
      --dark-theme-divider-color: #3c3c3c;

      /*
       * Deprecated values because of their confusing names.
       */
      --text-primary-color: var(--dark-theme-text-color);
      --default-primary-color: var(--primary-color);
    }
  </style>
</custom-style>`;d0t.setAttribute("style","display: none;");document.head.appendChild(d0t.content);var Eh={properties:{name:{type:String},value:{notify:!0,type:String},required:{type:Boolean,value:!1}},attached:function(){},detached:function(){}};var hW=null,Th={properties:{validator:{type:String},invalid:{notify:!0,reflectToAttribute:!0,type:Boolean,value:!1,observer:"_invalidChanged"}},registered:function(){hW=new go({type:"validator"})},_invalidChanged:function(){this.invalid?this.setAttribute("aria-invalid","true"):this.removeAttribute("aria-invalid")},get _validator(){return hW&&hW.byKey(this.validator)},hasValidator:function(){return this._validator!=null},validate:function(e){return e===void 0&&this.value!==void 0?this.invalid=!this._getValidity(this.value):this.invalid=!this._getValidity(e),!this.invalid},_getValidity:function(e){return this.hasValidator()?this._validator.validate(e):!0}};var fW={properties:{checked:{type:Boolean,value:!1,reflectToAttribute:!0,notify:!0,observer:"_checkedChanged"},toggles:{type:Boolean,value:!0,reflectToAttribute:!0},value:{type:String,value:"on",observer:"_valueChanged"}},observers:["_requiredChanged(required)"],created:function(){this._hasIronCheckedElementBehavior=!0},_getValidity:function(e){return this.disabled||!this.required||this.checked},_requiredChanged:function(){this.required?this.setAttribute("aria-required","true"):this.removeAttribute("aria-required")},_checkedChanged:function(){this.active=this.checked,this.fire("iron-change")},_valueChanged:function(){(this.value===void 0||this.value===null)&&(this.value="on")}},m0t=[Eh,Th,fW];var pE={observers:["_focusedChanged(receivedFocusFromKeyboard)"],_focusedChanged:function(e){e&&this.ensureRipple(),this.hasRipple()&&(this._ripple.holdDown=e)},_createRipple:function(){var e=su._createRipple();return e.id="ink",e.setAttribute("center",""),e.classList.add("circle"),e}},jx=[Sh,Di,su,pE];var Lbe={_checkedChanged:function(){fW._checkedChanged.call(this),this.hasRipple()&&(this.checked?this._ripple.setAttribute("checked",""):this._ripple.removeAttribute("checked"))},_buttonStateChanged:function(){su._buttonStateChanged.call(this),!this.disabled&&this.isAttached&&(this.checked=this.active)}},Xx=[jx,m0t,Lbe];var g0t=Q`<style>
  :host {
    display: inline-block;
    white-space: nowrap;
    cursor: pointer;
    --calculated-paper-checkbox-size: var(--paper-checkbox-size, 18px);
    /* -1px is a sentinel for the default and is replaced in \`attached\`. */
    --calculated-paper-checkbox-ink-size: var(--paper-checkbox-ink-size, -1px);
    @apply --paper-font-common-base;
    line-height: 0;
    -webkit-tap-highlight-color: transparent;
  }

  :host([hidden]) {
    display: none !important;
  }

  :host(:focus) {
    outline: none;
  }

  .hidden {
    display: none;
  }

  #checkboxContainer {
    display: inline-block;
    position: relative;
    width: var(--calculated-paper-checkbox-size);
    height: var(--calculated-paper-checkbox-size);
    min-width: var(--calculated-paper-checkbox-size);
    margin: var(--paper-checkbox-margin, initial);
    vertical-align: var(--paper-checkbox-vertical-align, middle);
    background-color: var(--paper-checkbox-unchecked-background-color, transparent);
  }

  #ink {
    position: absolute;

    /* Center the ripple in the checkbox by negative offsetting it by
     * (inkWidth - rippleWidth) / 2 */
    top: calc(0px - (var(--calculated-paper-checkbox-ink-size) - var(--calculated-paper-checkbox-size)) / 2);
    left: calc(0px - (var(--calculated-paper-checkbox-ink-size) - var(--calculated-paper-checkbox-size)) / 2);
    width: var(--calculated-paper-checkbox-ink-size);
    height: var(--calculated-paper-checkbox-ink-size);
    color: var(--paper-checkbox-unchecked-ink-color, var(--primary-text-color));
    opacity: 0.6;
    pointer-events: none;
  }

  #ink:dir(rtl) {
    right: calc(0px - (var(--calculated-paper-checkbox-ink-size) - var(--calculated-paper-checkbox-size)) / 2);
    left: auto;
  }

  #ink[checked] {
    color: var(--paper-checkbox-checked-ink-color, var(--primary-color));
  }

  #checkbox {
    position: relative;
    box-sizing: border-box;
    height: 100%;
    border: solid 2px;
    border-color: var(--paper-checkbox-unchecked-color, var(--primary-text-color));
    border-radius: 2px;
    pointer-events: none;
    -webkit-transition: background-color 140ms, border-color 140ms;
    transition: background-color 140ms, border-color 140ms;

    -webkit-transition-duration: var(--paper-checkbox-animation-duration, 140ms);
    transition-duration: var(--paper-checkbox-animation-duration, 140ms);
  }

  /* checkbox checked animations */
  #checkbox.checked #checkmark {
    -webkit-animation: checkmark-expand 140ms ease-out forwards;
    animation: checkmark-expand 140ms ease-out forwards;

    -webkit-animation-duration: var(--paper-checkbox-animation-duration, 140ms);
    animation-duration: var(--paper-checkbox-animation-duration, 140ms);
  }

  @-webkit-keyframes checkmark-expand {
    0% {
      -webkit-transform: scale(0, 0) rotate(45deg);
    }
    100% {
      -webkit-transform: scale(1, 1) rotate(45deg);
    }
  }

  @keyframes checkmark-expand {
    0% {
      transform: scale(0, 0) rotate(45deg);
    }
    100% {
      transform: scale(1, 1) rotate(45deg);
    }
  }

  #checkbox.checked {
    background-color: var(--paper-checkbox-checked-color, var(--primary-color));
    border-color: var(--paper-checkbox-checked-color, var(--primary-color));
  }

  #checkmark {
    position: absolute;
    width: 36%;
    height: 70%;
    border-style: solid;
    border-top: none;
    border-left: none;
    border-right-width: calc(2/15 * var(--calculated-paper-checkbox-size));
    border-bottom-width: calc(2/15 * var(--calculated-paper-checkbox-size));
    border-color: var(--paper-checkbox-checkmark-color, white);
    -webkit-transform-origin: 97% 86%;
    transform-origin: 97% 86%;
    box-sizing: content-box; /* protect against page-level box-sizing */
  }

  #checkmark:dir(rtl) {
    -webkit-transform-origin: 50% 14%;
    transform-origin: 50% 14%;
  }

  /* label */
  #checkboxLabel {
    position: relative;
    display: inline-block;
    vertical-align: middle;
    padding-left: var(--paper-checkbox-label-spacing, 8px);
    white-space: normal;
    line-height: normal;
    color: var(--paper-checkbox-label-color, var(--primary-text-color));
    @apply --paper-checkbox-label;
  }

  :host([checked]) #checkboxLabel {
    color: var(--paper-checkbox-label-checked-color, var(--paper-checkbox-label-color, var(--primary-text-color)));
    @apply --paper-checkbox-label-checked;
  }

  #checkboxLabel:dir(rtl) {
    padding-right: var(--paper-checkbox-label-spacing, 8px);
    padding-left: 0;
  }

  #checkboxLabel[hidden] {
    display: none;
  }

  /* disabled state */

  :host([disabled]) #checkbox {
    opacity: 0.5;
    border-color: var(--paper-checkbox-unchecked-color, var(--primary-text-color));
  }

  :host([disabled][checked]) #checkbox {
    background-color: var(--paper-checkbox-unchecked-color, var(--primary-text-color));
    opacity: 0.5;
  }

  :host([disabled]) #checkboxLabel  {
    opacity: 0.65;
  }

  /* invalid state */
  #checkbox.invalid:not(.checked) {
    border-color: var(--paper-checkbox-error-color, var(--error-color));
  }
</style>

<div id="checkboxContainer">
  <div id="checkbox" class$="[[_computeCheckboxClass(checked, invalid)]]">
    <div id="checkmark" class$="[[_computeCheckmarkClass(checked)]]"></div>
  </div>
</div>

<div id="checkboxLabel"><slot></slot></div>`;g0t.setAttribute("strip-whitespace","");Yt({_template:g0t,is:"paper-checkbox",behaviors:[Xx],hostAttributes:{role:"checkbox","aria-checked":!1,tabindex:0},properties:{ariaActiveAttribute:{type:String,value:"aria-checked"}},attached:function(){Tm(this,function(){var e=this.getComputedStyleValue("--calculated-paper-checkbox-ink-size").trim();if(e==="-1px"){var t=this.getComputedStyleValue("--calculated-paper-checkbox-size").trim(),r="px",n=t.match(/[A-Za-z]+$/);n!==null&&(r=n[0]);var i=parseFloat(t),o=8/3*i;r==="px"&&(o=Math.floor(o),o%2!==i%2&&o++),this.updateStyles({"--paper-checkbox-ink-size":o+r})}})},_computeCheckboxClass:function(e,t){var r="";return e&&(r+="checked "),t&&(r+="invalid"),r},_computeCheckmarkClass:function(e){return e?"":"hidden"},_createRipple:function(){return this._rippleContainer=this.$.checkboxContainer,pE._createRipple.call(this)}});if(!window.polymerSkipLoadingFontRoboto){let e=document.createElement("link");e.rel="stylesheet",e.type="text/css",e.crossOrigin="anonymous",e.href="https://fonts.googleapis.com/css?family=Roboto+Mono:400,700|Roboto:400,300,300italic,400italic,500,500italic,700,700italic",document.head.appendChild(e)}var _0t=Q`<custom-style>
  <style is="custom-style">
    html {

      /* Shared Styles */
      --paper-font-common-base: {
        font-family: 'Roboto', 'Noto', sans-serif;
        -webkit-font-smoothing: antialiased;
      };

      --paper-font-common-code: {
        font-family: 'Roboto Mono', 'Consolas', 'Menlo', monospace;
        -webkit-font-smoothing: antialiased;
      };

      --paper-font-common-expensive-kerning: {
        text-rendering: optimizeLegibility;
      };

      --paper-font-common-nowrap: {
        white-space: nowrap;
        overflow: hidden;
        text-overflow: ellipsis;
      };

      /* Material Font Styles */

      --paper-font-display4: {
        @apply --paper-font-common-base;
        @apply --paper-font-common-nowrap;

        font-size: 112px;
        font-weight: 300;
        letter-spacing: -.044em;
        line-height: 120px;
      };

      --paper-font-display3: {
        @apply --paper-font-common-base;
        @apply --paper-font-common-nowrap;

        font-size: 56px;
        font-weight: 400;
        letter-spacing: -.026em;
        line-height: 60px;
      };

      --paper-font-display2: {
        @apply --paper-font-common-base;

        font-size: 45px;
        font-weight: 400;
        letter-spacing: -.018em;
        line-height: 48px;
      };

      --paper-font-display1: {
        @apply --paper-font-common-base;

        font-size: 34px;
        font-weight: 400;
        letter-spacing: -.01em;
        line-height: 40px;
      };

      --paper-font-headline: {
        @apply --paper-font-common-base;

        font-size: 24px;
        font-weight: 400;
        letter-spacing: -.012em;
        line-height: 32px;
      };

      --paper-font-title: {
        @apply --paper-font-common-base;
        @apply --paper-font-common-nowrap;

        font-size: 20px;
        font-weight: 500;
        line-height: 28px;
      };

      --paper-font-subhead: {
        @apply --paper-font-common-base;

        font-size: 16px;
        font-weight: 400;
        line-height: 24px;
      };

      --paper-font-body2: {
        @apply --paper-font-common-base;

        font-size: 14px;
        font-weight: 500;
        line-height: 24px;
      };

      --paper-font-body1: {
        @apply --paper-font-common-base;

        font-size: 14px;
        font-weight: 400;
        line-height: 20px;
      };

      --paper-font-caption: {
        @apply --paper-font-common-base;
        @apply --paper-font-common-nowrap;

        font-size: 12px;
        font-weight: 400;
        letter-spacing: 0.011em;
        line-height: 20px;
      };

      --paper-font-menu: {
        @apply --paper-font-common-base;
        @apply --paper-font-common-nowrap;

        font-size: 13px;
        font-weight: 500;
        line-height: 24px;
      };

      --paper-font-button: {
        @apply --paper-font-common-base;
        @apply --paper-font-common-nowrap;

        font-size: 14px;
        font-weight: 500;
        letter-spacing: 0.018em;
        line-height: 24px;
        text-transform: uppercase;
      };

      --paper-font-code2: {
        @apply --paper-font-common-code;

        font-size: 14px;
        font-weight: 700;
        line-height: 20px;
      };

      --paper-font-code1: {
        @apply --paper-font-common-code;

        font-size: 14px;
        font-weight: 500;
        line-height: 20px;
      };

    }

  </style>
</custom-style>`;_0t.setAttribute("style","display: none;");document.head.appendChild(_0t.content);var pW=document.createElement("template");pW.setAttribute("style","display: none;");pW.innerHTML=`<dom-module id="paper-dialog-shared-styles">
  <template>
    <style>
      :host {
        display: block;
        margin: 24px 40px;

        background: var(--paper-dialog-background-color, var(--primary-background-color));
        color: var(--paper-dialog-color, var(--primary-text-color));

        @apply --paper-font-body1;
        @apply --shadow-elevation-16dp;
        @apply --paper-dialog;
      }

      :host > ::slotted(*) {
        margin-top: 20px;
        padding: 0 24px;
      }

      :host > ::slotted(.no-padding) {
        padding: 0;
      }

      
      :host > ::slotted(*:first-child) {
        margin-top: 24px;
      }

      :host > ::slotted(*:last-child) {
        margin-bottom: 24px;
      }

      /* In 1.x, this selector was \`:host > ::content h2\`. In 2.x <slot> allows
      to select direct children only, which increases the weight of this
      selector, so we have to re-define first-child/last-child margins below. */
      :host > ::slotted(h2) {
        position: relative;
        margin: 0;

        @apply --paper-font-title;
        @apply --paper-dialog-title;
      }

      /* Apply mixin again, in case it sets margin-top. */
      :host > ::slotted(h2:first-child) {
        margin-top: 24px;
        @apply --paper-dialog-title;
      }

      /* Apply mixin again, in case it sets margin-bottom. */
      :host > ::slotted(h2:last-child) {
        margin-bottom: 24px;
        @apply --paper-dialog-title;
      }

      :host > ::slotted(.paper-dialog-buttons),
      :host > ::slotted(.buttons) {
        position: relative;
        padding: 8px 8px 8px 24px;
        margin: 0;

        color: var(--paper-dialog-button-color, var(--primary-color));

        @apply --layout-horizontal;
        @apply --layout-end-justified;
      }
    </style>
  </template>
</dom-module>`;document.head.appendChild(pW.content);var y0t={properties:{animationConfig:{type:Object},entryAnimation:{observer:"_entryAnimationChanged",type:String},exitAnimation:{observer:"_exitAnimationChanged",type:String}},_entryAnimationChanged:function(){this.animationConfig=this.animationConfig||{},this.animationConfig.entry=[{name:this.entryAnimation,node:this}]},_exitAnimationChanged:function(){this.animationConfig=this.animationConfig||{},this.animationConfig.exit=[{name:this.exitAnimation,node:this}]},_copyProperties:function(e,t){for(var r in t)e[r]=t[r]},_cloneConfig:function(e){var t={isClone:!0};return this._copyProperties(t,e),t},_getAnimationConfigRecursive:function(e,t,r){if(!!this.animationConfig){if(this.animationConfig.value&&typeof this.animationConfig.value=="function"){this._warn(this._logf("playAnimation","Please put 'animationConfig' inside of your components 'properties' object instead of outside of it."));return}var n;if(e?n=this.animationConfig[e]:n=this.animationConfig,Array.isArray(n)||(n=[n]),n)for(var i,o=0;i=n[o];o++)if(i.animatable)i.animatable._getAnimationConfigRecursive(i.type||e,t,r);else if(i.id){var a=t[i.id];a?(a.isClone||(t[i.id]=this._cloneConfig(a),a=t[i.id]),this._copyProperties(a,i)):t[i.id]=i}else r.push(i)}},getAnimationConfig:function(e){var t={},r=[];this._getAnimationConfigRecursive(e,t,r);for(var n in t)r.push(t[n]);return r}};var kbe={_configureAnimations:function(e){var t=[],r=[];if(e.length>0)for(let i,o=0;i=e[o];o++){let a=document.createElement(i.name);if(a.isNeonAnimation){let s=null;a.configure||(a.configure=function(l){return null}),s=a.configure(i),r.push({result:s,config:i,neonAnimation:a})}else console.warn(this.is+":",i.name,"not found!")}for(var n=0;n<r.length;n++){let i=r[n].result,o=r[n].config,a=r[n].neonAnimation;try{typeof i.cancel!="function"&&(i=document.timeline.play(i))}catch(s){i=null,console.warn("Couldnt play","(",o.name,").",s)}i&&t.push({neonAnimation:a,config:o,animation:i})}return t},_shouldComplete:function(e){for(var t=!0,r=0;r<e.length;r++)if(e[r].animation.playState!="finished"){t=!1;break}return t},_complete:function(e){for(var t=0;t<e.length;t++)e[t].neonAnimation.complete(e[t].config);for(var t=0;t<e.length;t++)e[t].animation.cancel()},playAnimation:function(e,t){var r=this.getAnimationConfig(e);if(!!r){this._active=this._active||{},this._active[e]&&(this._complete(this._active[e]),delete this._active[e]);var n=this._configureAnimations(r);if(n.length==0){this.fire("neon-animation-finish",t,{bubbles:!1});return}this._active[e]=n;for(var i=0;i<n.length;i++)n[i].animation.onfinish=function(){this._shouldComplete(n)&&(this._complete(n),delete this._active[e],this.fire("neon-animation-finish",t,{bubbles:!1}))}.bind(this)}},cancelAnimation:function(){for(var e in this._active){var t=this._active[e];for(var r in t)t[r].animation.cancel()}this._active={}}},b9=[y0t,kbe];var w9,Rbe=()=>{if(w9!==void 0)return w9;let e=document.createElement("div");Object.assign(e.style,{overflow:"auto",position:"fixed",left:"0px",top:"0px",maxWidth:"100px",maxHeight:"100px"});let t=document.createElement("div");return t.style.width="200px",t.style.height="200px",e.appendChild(t),document.body.appendChild(e),w9=Math.abs(e.offsetWidth-100)>1?e.offsetWidth-e.clientWidth:0,document.body.removeChild(e),w9},v0t={properties:{sizingTarget:{type:Object,value:function(){return this}},fitInto:{type:Object,value:window},noOverlap:{type:Boolean},positionTarget:{type:Element},horizontalAlign:{type:String},verticalAlign:{type:String},dynamicAlign:{type:Boolean},horizontalOffset:{type:Number,value:0,notify:!0},verticalOffset:{type:Number,value:0,notify:!0},autoFitOnAttach:{type:Boolean,value:!1},expandSizingTargetForScrollbars:{type:Boolean,value:!1},_fitInfo:{type:Object}},get _fitWidth(){var e;return this.fitInto===window?e=this.fitInto.innerWidth:e=this.fitInto.getBoundingClientRect().width,e},get _fitHeight(){var e;return this.fitInto===window?e=this.fitInto.innerHeight:e=this.fitInto.getBoundingClientRect().height,e},get _fitLeft(){var e;return this.fitInto===window?e=0:e=this.fitInto.getBoundingClientRect().left,e},get _fitTop(){var e;return this.fitInto===window?e=0:e=this.fitInto.getBoundingClientRect().top,e},get _defaultPositionTarget(){var e=zt(this).parentNode;return e&&e.nodeType===Node.DOCUMENT_FRAGMENT_NODE&&(e=e.host),e},get _localeHorizontalAlign(){if(this._isRTL){if(this.horizontalAlign==="right")return"left";if(this.horizontalAlign==="left")return"right"}return this.horizontalAlign},get __shouldPosition(){return(this.horizontalAlign||this.verticalAlign)&&this.positionTarget},get _isRTL(){return typeof this._memoizedIsRTL=="undefined"&&(this._memoizedIsRTL=window.getComputedStyle(this).direction=="rtl"),this._memoizedIsRTL},attached:function(){this.positionTarget=this.positionTarget||this._defaultPositionTarget,this.autoFitOnAttach&&(window.getComputedStyle(this).display==="none"?setTimeout(function(){this.fit()}.bind(this)):(window.ShadyDOM&&ShadyDOM.flush(),this.fit()))},detached:function(){this.__deferredFit&&(clearTimeout(this.__deferredFit),this.__deferredFit=null)},fit:function(){this.position(),this.constrain(),this.center()},_discoverInfo:function(){if(!this._fitInfo){var e=window.getComputedStyle(this),t=window.getComputedStyle(this.sizingTarget);this._fitInfo={inlineStyle:{top:this.style.top||"",left:this.style.left||"",position:this.style.position||""},sizerInlineStyle:{maxWidth:this.sizingTarget.style.maxWidth||"",maxHeight:this.sizingTarget.style.maxHeight||"",boxSizing:this.sizingTarget.style.boxSizing||""},positionedBy:{vertically:e.top!=="auto"?"top":e.bottom!=="auto"?"bottom":null,horizontally:e.left!=="auto"?"left":e.right!=="auto"?"right":null},sizedBy:{height:t.maxHeight!=="none",width:t.maxWidth!=="none",minWidth:parseInt(t.minWidth,10)||0,minHeight:parseInt(t.minHeight,10)||0},margin:{top:parseInt(e.marginTop,10)||0,right:parseInt(e.marginRight,10)||0,bottom:parseInt(e.marginBottom,10)||0,left:parseInt(e.marginLeft,10)||0}}}},resetFit:function(){var e=this._fitInfo||{};for(var t in e.sizerInlineStyle)this.sizingTarget.style[t]=e.sizerInlineStyle[t];for(var t in e.inlineStyle)this.style[t]=e.inlineStyle[t];this._fitInfo=null},refit:function(){var e=this.sizingTarget.scrollLeft,t=this.sizingTarget.scrollTop;this.resetFit(),this.fit(),this.sizingTarget.scrollLeft=e,this.sizingTarget.scrollTop=t},position:function(){if(!this.__shouldPosition)return;this._discoverInfo(),window.ShadyDOM&&window.ShadyDOM.flush(),this.style.position="fixed",this.sizingTarget.style.boxSizing="border-box",this.style.left="0px",this.style.top="0px";var e=this.getBoundingClientRect(),t=this.__getNormalizedRect(this.positionTarget),r=this.__getNormalizedRect(this.fitInto);let n,i,o,a;this.expandSizingTargetForScrollbars&&(n=this.sizingTarget.offsetWidth,i=this.sizingTarget.offsetHeight,o=this.sizingTarget.clientWidth,a=this.sizingTarget.clientHeight);var s=this._fitInfo.margin,l={width:e.width+s.left+s.right,height:e.height+s.top+s.bottom},c=this.__getPosition(this._localeHorizontalAlign,this.verticalAlign,l,e,t,r),u=c.left+s.left,h=c.top+s.top,f=Math.min(r.right-s.right,u+e.width),p=Math.min(r.bottom-s.bottom,h+e.height);u=Math.max(r.left+s.left,Math.min(u,f-this._fitInfo.sizedBy.minWidth)),h=Math.max(r.top+s.top,Math.min(h,p-this._fitInfo.sizedBy.minHeight));let d=Math.max(f-u,this._fitInfo.sizedBy.minWidth),g=Math.max(p-h,this._fitInfo.sizedBy.minHeight);this.sizingTarget.style.maxWidth=d+"px",this.sizingTarget.style.maxHeight=g+"px";let _=u-e.left,y=h-e.top;if(this.style.left=`${_}px`,this.style.top=`${y}px`,this.expandSizingTargetForScrollbars){let x=this.sizingTarget.offsetHeight,b=this.sizingTarget.clientHeight,S=i-a,P=x-b-S;if(P>0){let L=r.height-s.top-s.bottom,R=Math.min(L,g+P);this.sizingTarget.style.maxHeight=`${R}px`;let F=this.sizingTarget.offsetHeight,z=F-x,U;c.verticalAlign==="top"?U=y:c.verticalAlign==="middle"?U=y-z/2:c.verticalAlign==="bottom"&&(U=y-z),U=Math.max(r.top+s.top,Math.min(U,r.bottom-s.bottom-F)),this.style.top=`${U}px`}let k=this.sizingTarget.offsetWidth,O=this.sizingTarget.clientWidth,D=n-o,I=k-O-D;if(I>0){let L=Rbe(),R=r.width-s.left-s.right,F=Math.min(R,d+I-L);this.sizingTarget.style.maxWidth=`${F}px`;let z=this.sizingTarget.offsetWidth+L,U=z-k,W;c.horizontalAlign==="left"?W=_:c.horizontalAlign==="center"?W=_-U/2:c.horizontalAlign==="right"&&(W=_-U),W=Math.max(r.left+s.left,Math.min(W,r.right-s.right-z)),this.style.left=`${W}px`}}},constrain:function(){if(!this.__shouldPosition){this._discoverInfo();var e=this._fitInfo;e.positionedBy.vertically||(this.style.position="fixed",this.style.top="0px"),e.positionedBy.horizontally||(this.style.position="fixed",this.style.left="0px"),this.sizingTarget.style.boxSizing="border-box";var t=this.getBoundingClientRect();e.sizedBy.height||this.__sizeDimension(t,e.positionedBy.vertically,"top","bottom","Height"),e.sizedBy.width||this.__sizeDimension(t,e.positionedBy.horizontally,"left","right","Width")}},_sizeDimension:function(e,t,r,n,i){this.__sizeDimension(e,t,r,n,i)},__sizeDimension:function(e,t,r,n,i){var o=this._fitInfo,a=this.__getNormalizedRect(this.fitInto),s=i==="Width"?a.width:a.height,l=t===n,c=l?s-e[n]:e[r],u=o.margin[l?r:n],h="offset"+i,f=this[h]-this.sizingTarget[h];this.sizingTarget.style["max"+i]=s-u-c-f+"px"},center:function(){if(!this.__shouldPosition){this._discoverInfo();var e=this._fitInfo.positionedBy;if(!(e.vertically&&e.horizontally)){this.style.position="fixed",e.vertically||(this.style.top="0px"),e.horizontally||(this.style.left="0px");var t=this.getBoundingClientRect(),r=this.__getNormalizedRect(this.fitInto);if(!e.vertically){var n=r.top-t.top+(r.height-t.height)/2;this.style.top=n+"px"}if(!e.horizontally){var i=r.left-t.left+(r.width-t.width)/2;this.style.left=i+"px"}}}},__getNormalizedRect:function(e){return e===document.documentElement||e===window?{top:0,left:0,width:window.innerWidth,height:window.innerHeight,right:window.innerWidth,bottom:window.innerHeight}:e.getBoundingClientRect()},__getOffscreenArea:function(e,t,r){var n=Math.min(0,e.top)+Math.min(0,r.bottom-(e.top+t.height)),i=Math.min(0,e.left)+Math.min(0,r.right-(e.left+t.width));return Math.abs(n)*t.width+Math.abs(i)*t.height},__getPosition:function(e,t,r,n,i,o){var a=[{verticalAlign:"top",horizontalAlign:"left",top:i.top+this.verticalOffset,left:i.left+this.horizontalOffset},{verticalAlign:"top",horizontalAlign:"right",top:i.top+this.verticalOffset,left:i.right-r.width-this.horizontalOffset},{verticalAlign:"bottom",horizontalAlign:"left",top:i.bottom-r.height-this.verticalOffset,left:i.left+this.horizontalOffset},{verticalAlign:"bottom",horizontalAlign:"right",top:i.bottom-r.height-this.verticalOffset,left:i.right-r.width-this.horizontalOffset}];if(this.noOverlap){for(var s=0,l=a.length;s<l;s++){var c={};for(var u in a[s])c[u]=a[s][u];a.push(c)}a[0].top=a[1].top+=i.height,a[2].top=a[3].top-=i.height,a[4].left=a[6].left+=i.width,a[5].left=a[7].left-=i.width}t=t==="auto"?null:t,e=e==="auto"?null:e,(!e||e==="center")&&(a.push({verticalAlign:"top",horizontalAlign:"center",top:i.top+this.verticalOffset+(this.noOverlap?i.height:0),left:i.left-n.width/2+i.width/2+this.horizontalOffset}),a.push({verticalAlign:"bottom",horizontalAlign:"center",top:i.bottom-r.height-this.verticalOffset-(this.noOverlap?i.height:0),left:i.left-n.width/2+i.width/2+this.horizontalOffset})),(!t||t==="middle")&&(a.push({verticalAlign:"middle",horizontalAlign:"left",top:i.top-n.height/2+i.height/2+this.verticalOffset,left:i.left+this.horizontalOffset+(this.noOverlap?i.width:0)}),a.push({verticalAlign:"middle",horizontalAlign:"right",top:i.top-n.height/2+i.height/2+this.verticalOffset,left:i.right-r.width-this.horizontalOffset-(this.noOverlap?i.width:0)})),t==="middle"&&e==="center"&&a.push({verticalAlign:"middle",horizontalAlign:"center",top:i.top-n.height/2+i.height/2+this.verticalOffset,left:i.left-n.width/2+i.width/2+this.horizontalOffset});for(var h,s=0;s<a.length;s++){var f=a[s],p=f.verticalAlign===t,d=f.horizontalAlign===e;if(!this.dynamicAlign&&!this.noOverlap&&p&&d){h=f;break}var g=(!t||p)&&(!e||d);if(!(!this.dynamicAlign&&!g)){if(f.offscreenArea=this.__getOffscreenArea(f,r,o),f.offscreenArea===0&&g){h=f;break}h=h||f;var _=f.offscreenArea-h.offscreenArea;(_<0||_===0&&(p||d))&&(h=f)}}return h}};var $x=Element.prototype,S9=$x.matches||$x.matchesSelector||$x.mozMatchesSelector||$x.msMatchesSelector||$x.oMatchesSelector||$x.webkitMatchesSelector,dW=class{getTabbableNodes(t){var r=[],n=this._collectTabbableNodes(t,r);return n?this._sortByTabIndex(r):r}isFocusable(t){return S9.call(t,"input, select, textarea, button, object")?S9.call(t,":not([disabled])"):S9.call(t,"a[href], area[href], iframe, [tabindex], [contentEditable]")}isTabbable(t){return this.isFocusable(t)&&S9.call(t,':not([tabindex="-1"])')&&this._isVisible(t)}_normalizedTabIndex(t){if(this.isFocusable(t)){var r=t.getAttribute("tabindex")||0;return Number(r)}return-1}_collectTabbableNodes(t,r){if(t.nodeType!==Node.ELEMENT_NODE)return!1;var n=t;if(!this._isVisible(n))return!1;var i=this._normalizedTabIndex(n),o=i>0;i>=0&&r.push(n);var a;n.localName==="content"||n.localName==="slot"?a=zt(n).getDistributedNodes():a=zt(n.root||n).children;for(var s=0;s<a.length;s++)o=this._collectTabbableNodes(a[s],r)||o;return o}_isVisible(t){var r=t.style;return r.visibility!=="hidden"&&r.display!=="none"?(r=window.getComputedStyle(t),r.visibility!=="hidden"&&r.display!=="none"):!1}_sortByTabIndex(t){var r=t.length;if(r<2)return t;var n=Math.ceil(r/2),i=this._sortByTabIndex(t.slice(0,n)),o=this._sortByTabIndex(t.slice(n));return this._mergeSortByTabIndex(i,o)}_mergeSortByTabIndex(t,r){for(var n=[];t.length>0&&r.length>0;)this._hasLowerTabOrder(t[0],r[0])?n.push(r.shift()):n.push(t.shift());return n.concat(t,r)}_hasLowerTabOrder(t,r){var n=Math.max(t.tabIndex,0),i=Math.max(r.tabIndex,0);return n===0||i===0?i>n:n>i}},x0t=new dW;Yt({_template:Q`
    <style>
      :host {
        position: fixed;
        top: 0;
        left: 0;
        width: 100%;
        height: 100%;
        background-color: var(--iron-overlay-backdrop-background-color, #000);
        opacity: 0;
        transition: opacity 0.2s;
        pointer-events: none;
        @apply --iron-overlay-backdrop;
      }

      :host(.opened) {
        opacity: var(--iron-overlay-backdrop-opacity, 0.6);
        pointer-events: auto;
        @apply --iron-overlay-backdrop-opened;
      }
    </style>

    <slot></slot>
`,is:"iron-overlay-backdrop",properties:{opened:{reflectToAttribute:!0,type:Boolean,value:!1,observer:"_openedChanged"}},listeners:{transitionend:"_onTransitionend"},created:function(){this.__openedRaf=null},attached:function(){this.opened&&this._openedChanged(this.opened)},prepare:function(){this.opened&&!this.parentNode&&zt(document.body).appendChild(this)},open:function(){this.opened=!0},close:function(){this.opened=!1},complete:function(){!this.opened&&this.parentNode===document.body&&zt(this.parentNode).removeChild(this)},_onTransitionend:function(e){e&&e.target===this&&this.complete()},_openedChanged:function(e){if(e)this.prepare();else{var t=window.getComputedStyle(this);(t.transitionDuration==="0s"||t.opacity==0)&&this.complete()}!this.isAttached||(this.__openedRaf&&(window.cancelAnimationFrame(this.__openedRaf),this.__openedRaf=null),this.scrollTop=this.scrollTop,this.__openedRaf=window.requestAnimationFrame(function(){this.__openedRaf=null,this.toggleClass("opened",this.opened)}.bind(this)))}});var mW=class{constructor(){this._overlays=[],this._minimumZ=101,this._backdropElement=null,Em(document.documentElement,"tap",function(){}),document.addEventListener("tap",this._onCaptureClick.bind(this),!0),document.addEventListener("focus",this._onCaptureFocus.bind(this),!0),document.addEventListener("keydown",this._onCaptureKeyDown.bind(this),!0)}get backdropElement(){return this._backdropElement||(this._backdropElement=document.createElement("iron-overlay-backdrop")),this._backdropElement}get deepActiveElement(){var t=document.activeElement;for((!t||!(t instanceof Element))&&(t=document.body);t.root&&zt(t.root).activeElement;)t=zt(t.root).activeElement;return t}_bringOverlayAtIndexToFront(t){var r=this._overlays[t];if(!!r){var n=this._overlays.length-1,i=this._overlays[n];if(i&&this._shouldBeBehindOverlay(r,i)&&n--,!(t>=n)){var o=Math.max(this.currentOverlayZ(),this._minimumZ);for(this._getZ(r)<=o&&this._applyOverlayZ(r,o);t<n;)this._overlays[t]=this._overlays[t+1],t++;this._overlays[n]=r}}}addOrRemoveOverlay(t){t.opened?this.addOverlay(t):this.removeOverlay(t)}addOverlay(t){var r=this._overlays.indexOf(t);if(r>=0){this._bringOverlayAtIndexToFront(r),this.trackBackdrop();return}var n=this._overlays.length,i=this._overlays[n-1],o=Math.max(this._getZ(i),this._minimumZ),a=this._getZ(t);if(i&&this._shouldBeBehindOverlay(t,i)){this._applyOverlayZ(i,o),n--;var s=this._overlays[n-1];o=Math.max(this._getZ(s),this._minimumZ)}a<=o&&this._applyOverlayZ(t,o),this._overlays.splice(n,0,t),this.trackBackdrop()}removeOverlay(t){var r=this._overlays.indexOf(t);r!==-1&&(this._overlays.splice(r,1),this.trackBackdrop())}currentOverlay(){var t=this._overlays.length-1;return this._overlays[t]}currentOverlayZ(){return this._getZ(this.currentOverlay())}ensureMinimumZ(t){this._minimumZ=Math.max(this._minimumZ,t)}focusOverlay(){var t=this.currentOverlay();t&&t._applyFocus()}trackBackdrop(){var t=this._overlayWithBackdrop();!t&&!this._backdropElement||(this.backdropElement.style.zIndex=this._getZ(t)-1,this.backdropElement.opened=!!t,this.backdropElement.prepare())}getBackdrops(){for(var t=[],r=0;r<this._overlays.length;r++)this._overlays[r].withBackdrop&&t.push(this._overlays[r]);return t}backdropZ(){return this._getZ(this._overlayWithBackdrop())-1}_overlayWithBackdrop(){for(var t=this._overlays.length-1;t>=0;t--)if(this._overlays[t].withBackdrop)return this._overlays[t]}_getZ(t){var r=this._minimumZ;if(t){var n=Number(t.style.zIndex||window.getComputedStyle(t).zIndex);n===n&&(r=n)}return r}_setZ(t,r){t.style.zIndex=r}_applyOverlayZ(t,r){this._setZ(t,r+2)}_overlayInPath(t){t=t||[];for(var r=0;r<t.length;r++)if(t[r]._manager===this)return t[r]}_onCaptureClick(t){var r=this._overlays.length-1;if(r!==-1)for(var n=zt(t).path,i;(i=this._overlays[r])&&this._overlayInPath(n)!==i&&(i._onCaptureClick(t),i.allowClickThrough);)r--}_onCaptureFocus(t){var r=this.currentOverlay();r&&r._onCaptureFocus(t)}_onCaptureKeyDown(t){var r=this.currentOverlay();r&&(Oo.keyboardEventMatchesKeys(t,"esc")?r._onCaptureEsc(t):Oo.keyboardEventMatchesKeys(t,"tab")&&r._onCaptureTab(t))}_shouldBeBehindOverlay(t,r){return!t.alwaysOnTop&&r.alwaysOnTop}},b0t=new mW;var E9={pageX:0,pageY:0},w0t=null,gW=[],T9=["wheel","mousewheel","DOMMouseScroll","touchstart","touchmove"],M9,_W;function S0t(e){Ch.indexOf(e)>=0||(Ch.length===0&&Dbe(),Ch.push(e),_W=Ch[Ch.length-1],E0t=[],T0t=[])}function M0t(e){var t=Ch.indexOf(e);t!==-1&&(Ch.splice(t,1),_W=Ch[Ch.length-1],E0t=[],T0t=[],Ch.length===0&&Obe())}var Ch=[],E0t=null,T0t=null;function Nbe(e){if(e.cancelable&&zbe(e)&&e.preventDefault(),e.targetTouches){var t=e.targetTouches[0];E9.pageX=t.pageX,E9.pageY=t.pageY}}function Dbe(){M9=M9||Nbe.bind(void 0);for(var e=0,t=T9.length;e<t;e++)document.addEventListener(T9[e],M9,{capture:!0,passive:!1})}function Obe(){for(var e=0,t=T9.length;e<t;e++)document.removeEventListener(T9[e],M9,{capture:!0,passive:!1})}function zbe(e){var t=zt(e).rootTarget;if(e.type!=="touchmove"&&w0t!==t&&(w0t=t,gW=Fbe(zt(e).path)),!gW.length)return!0;if(e.type==="touchstart")return!1;var r=Hbe(e);return!Bbe(gW,r.deltaX,r.deltaY)}function Fbe(e){for(var t=[],r=e.indexOf(_W),n=0;n<=r;n++)if(e[n].nodeType===Node.ELEMENT_NODE){var i=e[n],o=i.style;o.overflow!=="scroll"&&o.overflow!=="auto"&&(o=window.getComputedStyle(i)),(o.overflow==="scroll"||o.overflow==="auto")&&t.push(i)}return t}function Bbe(e,t,r){if(!(!t&&!r))for(var n=Math.abs(r)>=Math.abs(t),i=0;i<e.length;i++){var o=e[i],a=!1;if(n?a=r<0?o.scrollTop>0:o.scrollTop<o.scrollHeight-o.clientHeight:a=t<0?o.scrollLeft>0:o.scrollLeft<o.scrollWidth-o.clientWidth,a)return o}}function Hbe(e){var t={deltaX:e.deltaX,deltaY:e.deltaY};if(!("deltaX"in e)){if("wheelDeltaX"in e&&"wheelDeltaY"in e)t.deltaX=-e.wheelDeltaX,t.deltaY=-e.wheelDeltaY;else if("wheelDelta"in e)t.deltaX=0,t.deltaY=-e.wheelDelta;else if("axis"in e)t.deltaX=e.axis===1?e.detail:0,t.deltaY=e.axis===2?e.detail:0;else if(e.targetTouches){var r=e.targetTouches[0];t.deltaX=E9.pageX-r.pageX,t.deltaY=E9.pageY-r.pageY}}return t}var Pm={properties:{opened:{observer:"_openedChanged",type:Boolean,value:!1,notify:!0},canceled:{observer:"_canceledChanged",readOnly:!0,type:Boolean,value:!1},withBackdrop:{observer:"_withBackdropChanged",type:Boolean},noAutoFocus:{type:Boolean,value:!1},noCancelOnEscKey:{type:Boolean,value:!1},noCancelOnOutsideClick:{type:Boolean,value:!1},closingReason:{type:Object},restoreFocusOnClose:{type:Boolean,value:!1},allowClickThrough:{type:Boolean},alwaysOnTop:{type:Boolean},scrollAction:{type:String},_manager:{type:Object,value:b0t},_focusedChild:{type:Object}},listeners:{"iron-resize":"_onIronResize"},observers:["__updateScrollObservers(isAttached, opened, scrollAction)"],get backdropElement(){return this._manager.backdropElement},get _focusNode(){return this._focusedChild||zt(this).querySelector("[autofocus]")||this},get _focusableNodes(){return x0t.getTabbableNodes(this)},ready:function(){this.__isAnimating=!1,this.__shouldRemoveTabIndex=!1,this.__firstFocusableNode=this.__lastFocusableNode=null,this.__rafs={},this.__restoreFocusNode=null,this.__scrollTop=this.__scrollLeft=null,this.__onCaptureScroll=this.__onCaptureScroll.bind(this),this.__rootNodes=null,this._ensureSetup()},attached:function(){this.opened&&this._openedChanged(this.opened),this._observer=zt(this).observeNodes(this._onNodesChange)},detached:function(){this._observer&&zt(this).unobserveNodes(this._observer),this._observer=null;for(var e in this.__rafs)this.__rafs[e]!==null&&cancelAnimationFrame(this.__rafs[e]);this.__rafs={},this._manager.removeOverlay(this),this.__isAnimating&&(this.opened?this._finishRenderOpened():(this._applyFocus(),this._finishRenderClosed()))},toggle:function(){this._setCanceled(!1),this.opened=!this.opened},open:function(){this._setCanceled(!1),this.opened=!0},close:function(){this._setCanceled(!1),this.opened=!1},cancel:function(e){var t=this.fire("iron-overlay-canceled",e,{cancelable:!0});t.defaultPrevented||(this._setCanceled(!0),this.opened=!1)},invalidateTabbables:function(){this.__firstFocusableNode=this.__lastFocusableNode=null},_ensureSetup:function(){this._overlaySetup||(this._overlaySetup=!0,this.style.outline="none",this.style.display="none")},_openedChanged:function(e){e?this.removeAttribute("aria-hidden"):this.setAttribute("aria-hidden","true"),this.isAttached&&(this.__isAnimating=!0,this.__deraf("__openedChanged",this.__openedChanged))},_canceledChanged:function(){this.closingReason=this.closingReason||{},this.closingReason.canceled=this.canceled},_withBackdropChanged:function(){this.withBackdrop&&!this.hasAttribute("tabindex")?(this.setAttribute("tabindex","-1"),this.__shouldRemoveTabIndex=!0):this.__shouldRemoveTabIndex&&(this.removeAttribute("tabindex"),this.__shouldRemoveTabIndex=!1),this.opened&&this.isAttached&&this._manager.trackBackdrop()},_prepareRenderOpened:function(){this.__restoreFocusNode=this._manager.deepActiveElement,this._preparePositioning(),this.refit(),this._finishPositioning(),this.noAutoFocus&&document.activeElement===this._focusNode&&(this._focusNode.blur(),this.__restoreFocusNode.focus())},_renderOpened:function(){this._finishRenderOpened()},_renderClosed:function(){this._finishRenderClosed()},_finishRenderOpened:function(){this.notifyResize(),this.__isAnimating=!1,this.fire("iron-overlay-opened")},_finishRenderClosed:function(){this.style.display="none",this.style.zIndex="",this.notifyResize(),this.__isAnimating=!1,this.fire("iron-overlay-closed",this.closingReason)},_preparePositioning:function(){this.style.transition=this.style.webkitTransition="none",this.style.transform=this.style.webkitTransform="none",this.style.display=""},_finishPositioning:function(){this.style.display="none",this.scrollTop=this.scrollTop,this.style.transition=this.style.webkitTransition="",this.style.transform=this.style.webkitTransform="",this.style.display="",this.scrollTop=this.scrollTop},_applyFocus:function(){if(this.opened)this.noAutoFocus||this._focusNode.focus();else{if(this.restoreFocusOnClose&&this.__restoreFocusNode){var e=this._manager.deepActiveElement;(e===document.body||Ube(this,e))&&this.__restoreFocusNode.focus()}this.__restoreFocusNode=null,this._focusNode.blur(),this._focusedChild=null}},_onCaptureClick:function(e){this.noCancelOnOutsideClick||this.cancel(e)},_onCaptureFocus:function(e){if(!!this.withBackdrop){var t=zt(e).path;t.indexOf(this)===-1?(e.stopPropagation(),this._applyFocus()):this._focusedChild=t[0]}},_onCaptureEsc:function(e){this.noCancelOnEscKey||this.cancel(e)},_onCaptureTab:function(e){if(!!this.withBackdrop){this.__ensureFirstLastFocusables();var t=e.shiftKey,r=t?this.__firstFocusableNode:this.__lastFocusableNode,n=t?this.__lastFocusableNode:this.__firstFocusableNode,i=!1;if(r===n)i=!0;else{var o=this._manager.deepActiveElement;i=o===r||o===this}i&&(e.preventDefault(),this._focusedChild=n,this._applyFocus())}},_onIronResize:function(){this.opened&&!this.__isAnimating&&this.__deraf("refit",this.refit)},_onNodesChange:function(){this.opened&&!this.__isAnimating&&(this.invalidateTabbables(),this.notifyResize())},__ensureFirstLastFocusables:function(){var e=this._focusableNodes;this.__firstFocusableNode=e[0],this.__lastFocusableNode=e[e.length-1]},__openedChanged:function(){this.opened?(this._prepareRenderOpened(),this._manager.addOverlay(this),this._applyFocus(),this._renderOpened()):(this._manager.removeOverlay(this),this._applyFocus(),this._renderClosed())},__deraf:function(e,t){var r=this.__rafs;r[e]!==null&&cancelAnimationFrame(r[e]),r[e]=requestAnimationFrame(function(){r[e]=null,t.call(this)}.bind(this))},__updateScrollObservers:function(e,t,r){!e||!t||!this.__isValidScrollAction(r)?(M0t(this),this.__removeScrollListeners()):(r==="lock"&&(this.__saveScrollPosition(),S0t(this)),this.__addScrollListeners())},__addScrollListeners:function(){if(!this.__rootNodes){if(this.__rootNodes=[],c_)for(var e=this;e;)e.nodeType===Node.DOCUMENT_FRAGMENT_NODE&&e.host&&this.__rootNodes.push(e),e=e.host||e.assignedSlot||e.parentNode;this.__rootNodes.push(document)}this.__rootNodes.forEach(function(t){t.addEventListener("scroll",this.__onCaptureScroll,{capture:!0,passive:!0})},this)},__removeScrollListeners:function(){this.__rootNodes&&this.__rootNodes.forEach(function(e){e.removeEventListener("scroll",this.__onCaptureScroll,{capture:!0,passive:!0})},this),this.isAttached||(this.__rootNodes=null)},__isValidScrollAction:function(e){return e==="lock"||e==="refit"||e==="cancel"},__onCaptureScroll:function(e){if(!this.__isAnimating&&!(zt(e).path.indexOf(this)>=0))switch(this.scrollAction){case"lock":this.__restoreScrollPosition();break;case"refit":this.__deraf("refit",this.refit);break;case"cancel":this.cancel(e);break}},__saveScrollPosition:function(){document.scrollingElement?(this.__scrollTop=document.scrollingElement.scrollTop,this.__scrollLeft=document.scrollingElement.scrollLeft):(this.__scrollTop=Math.max(document.documentElement.scrollTop,document.body.scrollTop),this.__scrollLeft=Math.max(document.documentElement.scrollLeft,document.body.scrollLeft))},__restoreScrollPosition:function(){document.scrollingElement?(document.scrollingElement.scrollTop=this.__scrollTop,document.scrollingElement.scrollLeft=this.__scrollLeft):(document.documentElement.scrollTop=document.body.scrollTop=this.__scrollTop,document.documentElement.scrollLeft=document.body.scrollLeft=this.__scrollLeft)}},Vbe=e=>e.assignedSlot||e.parentNode||e.host,Ube=(e,t)=>{for(let r=t;r;r=Vbe(r))if(r===e)return!0;return!1},Kx=[v0t,Js,Pm];var yW={hostAttributes:{role:"dialog",tabindex:"-1"},properties:{modal:{type:Boolean,value:!1},__readied:{type:Boolean,value:!1}},observers:["_modalChanged(modal, __readied)"],listeners:{tap:"_onDialogClick"},ready:function(){this.__prevNoCancelOnOutsideClick=this.noCancelOnOutsideClick,this.__prevNoCancelOnEscKey=this.noCancelOnEscKey,this.__prevWithBackdrop=this.withBackdrop,this.__readied=!0},_modalChanged:function(e,t){!t||(e?(this.__prevNoCancelOnOutsideClick=this.noCancelOnOutsideClick,this.__prevNoCancelOnEscKey=this.noCancelOnEscKey,this.__prevWithBackdrop=this.withBackdrop,this.noCancelOnOutsideClick=!0,this.noCancelOnEscKey=!0,this.withBackdrop=!0):(this.noCancelOnOutsideClick=this.noCancelOnOutsideClick&&this.__prevNoCancelOnOutsideClick,this.noCancelOnEscKey=this.noCancelOnEscKey&&this.__prevNoCancelOnEscKey,this.withBackdrop=this.withBackdrop&&this.__prevWithBackdrop))},_updateClosingReasonConfirmed:function(e){this.closingReason=this.closingReason||{},this.closingReason.confirmed=e},_onDialogClick:function(e){for(var t=zt(e).path,r=0,n=t.indexOf(this);r<n;r++){var i=t[r];if(i.hasAttribute&&(i.hasAttribute("dialog-dismiss")||i.hasAttribute("dialog-confirm"))){this._updateClosingReasonConfirmed(i.hasAttribute("dialog-confirm")),this.close(),e.stopPropagation();break}}}},C0t=[Kx,yW];Yt({_template:Q`
    <style include="paper-dialog-shared-styles"></style>
    <slot></slot>
`,is:"paper-dialog",behaviors:[C0t,b9],listeners:{"neon-animation-finish":"_onNeonAnimationFinish"},_renderOpened:function(){this.cancelAnimation(),this.playAnimation("entry")},_renderClosed:function(){this.cancelAnimation(),this.playAnimation("exit")},_onNeonAnimationFinish:function(){this.opened?this._finishRenderOpened():this._finishRenderClosed()}});Yt({_template:Q`
    <style>

      :host {
        display: block;
        @apply --layout-relative;
      }

      :host(.is-scrolled:not(:first-child))::before {
        content: '';
        position: absolute;
        top: 0;
        left: 0;
        right: 0;
        height: 1px;
        background: var(--divider-color);
      }

      :host(.can-scroll:not(.scrolled-to-bottom):not(:last-child))::after {
        content: '';
        position: absolute;
        bottom: 0;
        left: 0;
        right: 0;
        height: 1px;
        background: var(--divider-color);
      }

      .scrollable {
        padding: 0 24px;

        @apply --layout-scroll;
        @apply --paper-dialog-scrollable;
      }

      .fit {
        @apply --layout-fit;
      }
    </style>

    <div id="scrollable" class="scrollable" on-scroll="updateScrollState">
      <slot></slot>
    </div>
`,is:"paper-dialog-scrollable",properties:{dialogElement:{type:Object}},get scrollTarget(){return this.$.scrollable},ready:function(){this._ensureTarget(),this.classList.add("no-padding")},attached:function(){this._ensureTarget(),requestAnimationFrame(this.updateScrollState.bind(this))},updateScrollState:function(){this.toggleClass("is-scrolled",this.scrollTarget.scrollTop>0),this.toggleClass("can-scroll",this.scrollTarget.offsetHeight<this.scrollTarget.scrollHeight),this.toggleClass("scrolled-to-bottom",this.scrollTarget.scrollTop+this.scrollTarget.offsetHeight>=this.scrollTarget.scrollHeight)},_ensureTarget:function(){this.dialogElement=this.dialogElement||this.parentElement,this.dialogElement&&this.dialogElement.behaviors&&this.dialogElement.behaviors.indexOf(yW)>=0?(this.dialogElement.sizingTarget=this.scrollTarget,this.scrollTarget.classList.remove("fit")):this.dialogElement&&this.scrollTarget.classList.add("fit")}});var ec=Yt({_template:Q`
    <style>
      :host {
        display: inline-block;
        position: fixed;
        clip: rect(0px,0px,0px,0px);
      }
    </style>
    <div aria-live$="[[mode]]">[[_text]]</div>
`,is:"iron-a11y-announcer",properties:{mode:{type:String,value:"polite"},timeout:{type:Number,value:150},_text:{type:String,value:""}},created:function(){ec.instance||(ec.instance=this),document.addEventListener("iron-announce",this._onIronAnnounce.bind(this))},announce:function(e){this._text="",this.async(function(){this._text=e},this.timeout)},_onIronAnnounce:function(e){e.detail&&e.detail.text&&this.announce(e.detail.text)}});ec.instance=null;ec.requestAvailability=function(){ec.instance||(ec.instance=document.createElement("iron-a11y-announcer")),document.body?document.body.appendChild(ec.instance):document.addEventListener("load",function(){document.body.appendChild(ec.instance)})};Yt({_template:Q`
    <style>
      :host {
        display: inline-block;
      }
    </style>
    <slot id="content"></slot>
`,is:"iron-input",behaviors:[Th],properties:{bindValue:{type:String,value:""},value:{type:String,computed:"_computeValue(bindValue)"},allowedPattern:{type:String},autoValidate:{type:Boolean,value:!1},_inputElement:Object},observers:["_bindValueChanged(bindValue, _inputElement)"],listeners:{input:"_onInput",keypress:"_onKeypress"},created:function(){ec.requestAvailability(),this._previousValidInput="",this._patternAlreadyChecked=!1},attached:function(){this._observer=zt(this).observeNodes(function(e){this._initSlottedInput()}.bind(this))},detached:function(){this._observer&&(zt(this).unobserveNodes(this._observer),this._observer=null)},get inputElement(){return this._inputElement},_initSlottedInput:function(){this._inputElement=this.getEffectiveChildren()[0],this.inputElement&&this.inputElement.value&&(this.bindValue=this.inputElement.value),this.fire("iron-input-ready")},get _patternRegExp(){var e;if(this.allowedPattern)e=new RegExp(this.allowedPattern);else switch(this.inputElement.type){case"number":e=/[0-9.,e-]/;break}return e},_bindValueChanged:function(e,t){!t||(e===void 0?t.value=null:e!==t.value&&(this.inputElement.value=e),this.autoValidate&&this.validate(),this.fire("bind-value-changed",{value:e}))},_onInput:function(){if(this.allowedPattern&&!this._patternAlreadyChecked){var e=this._checkPatternValidity();e||(this._announceInvalidCharacter("Invalid string of characters not entered."),this.inputElement.value=this._previousValidInput)}this.bindValue=this._previousValidInput=this.inputElement.value,this._patternAlreadyChecked=!1},_isPrintable:function(e){var t=e.keyCode==8||e.keyCode==9||e.keyCode==13||e.keyCode==27,r=e.keyCode==19||e.keyCode==20||e.keyCode==45||e.keyCode==46||e.keyCode==144||e.keyCode==145||e.keyCode>32&&e.keyCode<41||e.keyCode>111&&e.keyCode<124;return!t&&!(e.charCode==0&&r)},_onKeypress:function(e){if(!(!this.allowedPattern&&this.inputElement.type!=="number")){var t=this._patternRegExp;if(!!t&&!(e.metaKey||e.ctrlKey||e.altKey)){this._patternAlreadyChecked=!0;var r=String.fromCharCode(e.charCode);this._isPrintable(e)&&!t.test(r)&&(e.preventDefault(),this._announceInvalidCharacter("Invalid character "+r+" not entered."))}}},_checkPatternValidity:function(){var e=this._patternRegExp;if(!e)return!0;for(var t=0;t<this.inputElement.value.length;t++)if(!e.test(this.inputElement.value[t]))return!1;return!0},validate:function(){if(!this.inputElement)return this.invalid=!1,!0;var e=this.inputElement.checkValidity();return e&&(this.required&&this.bindValue===""?e=!1:this.hasValidator()&&(e=Th.validate.call(this,this.bindValue))),this.invalid=!e,this.fire("iron-input-validate"),e},_announceInvalidCharacter:function(e){this.fire("iron-announce",{text:e})},_computeValue:function(e){return e}});var C9={attached:function(){this.fire("addon-attached")},update:function(e){}};Yt({_template:Q`
    <style>
      :host {
        display: inline-block;
        float: right;

        @apply --paper-font-caption;
        @apply --paper-input-char-counter;
      }

      :host([hidden]) {
        display: none !important;
      }

      :host(:dir(rtl)) {
        float: left;
      }
    </style>

    <span>[[_charCounterStr]]</span>
`,is:"paper-input-char-counter",behaviors:[C9],properties:{_charCounterStr:{type:String,value:"0"}},update:function(e){if(!!e.inputElement){e.value=e.value||"";var t=e.value.toString().length.toString();e.inputElement.hasAttribute("maxlength")&&(t+="/"+e.inputElement.getAttribute("maxlength")),this._charCounterStr=t}}});var A0t=Q`
<custom-style>
  <style is="custom-style">
    html {
      --paper-input-container-shared-input-style: {
        position: relative; /* to make a stacking context */
        outline: none;
        box-shadow: none;
        padding: 0;
        margin: 0;
        width: 100%;
        max-width: 100%;
        background: transparent;
        border: none;
        color: var(--paper-input-container-input-color, var(--primary-text-color));
        -webkit-appearance: none;
        text-align: inherit;
        vertical-align: var(--paper-input-container-input-align, bottom);

        @apply --paper-font-subhead;
      };
    }
  </style>
</custom-style>
`;A0t.setAttribute("style","display: none;");document.head.appendChild(A0t.content);Yt({_template:Q`
    <style>
      :host {
        display: block;
        padding: 8px 0;
        @apply --paper-input-container;
      }

      :host([inline]) {
        display: inline-block;
      }

      :host([disabled]) {
        pointer-events: none;
        opacity: 0.33;

        @apply --paper-input-container-disabled;
      }

      :host([hidden]) {
        display: none !important;
      }

      [hidden] {
        display: none !important;
      }

      .floated-label-placeholder {
        @apply --paper-font-caption;
      }

      .underline {
        height: 2px;
        position: relative;
      }

      .focused-line {
        @apply --layout-fit;
        border-bottom: 2px solid var(--paper-input-container-focus-color, var(--primary-color));

        -webkit-transform-origin: center center;
        transform-origin: center center;
        -webkit-transform: scale3d(0,1,1);
        transform: scale3d(0,1,1);

        @apply --paper-input-container-underline-focus;
      }

      .underline.is-highlighted .focused-line {
        -webkit-transform: none;
        transform: none;
        -webkit-transition: -webkit-transform 0.25s;
        transition: transform 0.25s;

        @apply --paper-transition-easing;
      }

      .underline.is-invalid .focused-line {
        border-color: var(--paper-input-container-invalid-color, var(--error-color));
        -webkit-transform: none;
        transform: none;
        -webkit-transition: -webkit-transform 0.25s;
        transition: transform 0.25s;

        @apply --paper-transition-easing;
      }

      .unfocused-line {
        @apply --layout-fit;
        border-bottom: 1px solid var(--paper-input-container-color, var(--secondary-text-color));
        @apply --paper-input-container-underline;
      }

      :host([disabled]) .unfocused-line {
        border-bottom: 1px dashed;
        border-color: var(--paper-input-container-color, var(--secondary-text-color));
        @apply --paper-input-container-underline-disabled;
      }

      .input-wrapper {
        @apply --layout-horizontal;
        @apply --layout-center;
        position: relative;
      }

      .input-content {
        @apply --layout-flex-auto;
        @apply --layout-relative;
        max-width: 100%;
      }

      .input-content ::slotted(label),
      .input-content ::slotted(.paper-input-label) {
        position: absolute;
        top: 0;
        left: 0;
        width: 100%;
        font: inherit;
        color: var(--paper-input-container-color, var(--secondary-text-color));
        -webkit-transition: -webkit-transform 0.25s, width 0.25s;
        transition: transform 0.25s, width 0.25s;
        -webkit-transform-origin: left top;
        transform-origin: left top;
        /* Fix for safari not focusing 0-height date/time inputs with -webkit-apperance: none; */
        min-height: 1px;

        @apply --paper-font-common-nowrap;
        @apply --paper-font-subhead;
        @apply --paper-input-container-label;
        @apply --paper-transition-easing;
      }


      .input-content ::slotted(label):before,
      .input-content ::slotted(.paper-input-label):before {
        @apply --paper-input-container-label-before;
      }

      .input-content ::slotted(label):after,
      .input-content ::slotted(.paper-input-label):after {
        @apply --paper-input-container-label-after;
      }

      .input-content.label-is-floating ::slotted(label),
      .input-content.label-is-floating ::slotted(.paper-input-label) {
        -webkit-transform: translateY(-75%) scale(0.75);
        transform: translateY(-75%) scale(0.75);

        /* Since we scale to 75/100 of the size, we actually have 100/75 of the
        original space now available */
        width: 133%;

        @apply --paper-input-container-label-floating;
      }

      :host(:dir(rtl)) .input-content.label-is-floating ::slotted(label),
      :host(:dir(rtl)) .input-content.label-is-floating ::slotted(.paper-input-label) {
        right: 0;
        left: auto;
        -webkit-transform-origin: right top;
        transform-origin: right top;
      }

      .input-content.label-is-highlighted ::slotted(label),
      .input-content.label-is-highlighted ::slotted(.paper-input-label) {
        color: var(--paper-input-container-focus-color, var(--primary-color));

        @apply --paper-input-container-label-focus;
      }

      .input-content.is-invalid ::slotted(label),
      .input-content.is-invalid ::slotted(.paper-input-label) {
        color: var(--paper-input-container-invalid-color, var(--error-color));
      }

      .input-content.label-is-hidden ::slotted(label),
      .input-content.label-is-hidden ::slotted(.paper-input-label) {
        visibility: hidden;
      }

      .input-content ::slotted(input),
      .input-content ::slotted(iron-input),
      .input-content ::slotted(textarea),
      .input-content ::slotted(iron-autogrow-textarea),
      .input-content ::slotted(.paper-input-input) {
        @apply --paper-input-container-shared-input-style;
        /* The apply shim doesn't apply the nested color custom property,
          so we have to re-apply it here. */
        color: var(--paper-input-container-input-color, var(--primary-text-color));
        @apply --paper-input-container-input;
      }

      .input-content ::slotted(input)::-webkit-outer-spin-button,
      .input-content ::slotted(input)::-webkit-inner-spin-button {
        @apply --paper-input-container-input-webkit-spinner;
      }

      .input-content.focused ::slotted(input),
      .input-content.focused ::slotted(iron-input),
      .input-content.focused ::slotted(textarea),
      .input-content.focused ::slotted(iron-autogrow-textarea),
      .input-content.focused ::slotted(.paper-input-input) {
        @apply --paper-input-container-input-focus;
      }

      .input-content.is-invalid ::slotted(input),
      .input-content.is-invalid ::slotted(iron-input),
      .input-content.is-invalid ::slotted(textarea),
      .input-content.is-invalid ::slotted(iron-autogrow-textarea),
      .input-content.is-invalid ::slotted(.paper-input-input) {
        @apply --paper-input-container-input-invalid;
      }

      .prefix ::slotted(*) {
        display: inline-block;
        @apply --paper-font-subhead;
        @apply --layout-flex-none;
        @apply --paper-input-prefix;
      }

      .suffix ::slotted(*) {
        display: inline-block;
        @apply --paper-font-subhead;
        @apply --layout-flex-none;

        @apply --paper-input-suffix;
      }

      /* Firefox sets a min-width on the input, which can cause layout issues */
      .input-content ::slotted(input) {
        min-width: 0;
      }

      .input-content ::slotted(textarea) {
        resize: none;
      }

      .add-on-content {
        position: relative;
      }

      .add-on-content.is-invalid ::slotted(*) {
        color: var(--paper-input-container-invalid-color, var(--error-color));
      }

      .add-on-content.is-highlighted ::slotted(*) {
        color: var(--paper-input-container-focus-color, var(--primary-color));
      }
    </style>

    <div class="floated-label-placeholder" aria-hidden="true" hidden="[[noLabelFloat]]">&nbsp;</div>

    <div class="input-wrapper">
      <span class="prefix"><slot name="prefix"></slot></span>

      <div class$="[[_computeInputContentClass(noLabelFloat,alwaysFloatLabel,focused,invalid,_inputHasContent)]]" id="labelAndInputContainer">
        <slot name="label"></slot>
        <slot name="input"></slot>
      </div>

      <span class="suffix"><slot name="suffix"></slot></span>
    </div>

    <div class$="[[_computeUnderlineClass(focused,invalid)]]">
      <div class="unfocused-line"></div>
      <div class="focused-line"></div>
    </div>

    <div class$="[[_computeAddOnContentClass(focused,invalid)]]">
      <slot name="add-on"></slot>
    </div>
`,is:"paper-input-container",properties:{noLabelFloat:{type:Boolean,value:!1},alwaysFloatLabel:{type:Boolean,value:!1},attrForValue:{type:String,value:"bind-value"},autoValidate:{type:Boolean,value:!1},invalid:{observer:"_invalidChanged",type:Boolean,value:!1},focused:{readOnly:!0,type:Boolean,value:!1,notify:!0},_addons:{type:Array},_inputHasContent:{type:Boolean,value:!1},_inputSelector:{type:String,value:"input,iron-input,textarea,.paper-input-input"},_boundOnFocus:{type:Function,value:function(){return this._onFocus.bind(this)}},_boundOnBlur:{type:Function,value:function(){return this._onBlur.bind(this)}},_boundOnInput:{type:Function,value:function(){return this._onInput.bind(this)}},_boundValueChanged:{type:Function,value:function(){return this._onValueChanged.bind(this)}}},listeners:{"addon-attached":"_onAddonAttached","iron-input-validate":"_onIronInputValidate"},get _valueChangedEvent(){return this.attrForValue+"-changed"},get _propertyForValue(){return wm(this.attrForValue)},get _inputElement(){return zt(this).querySelector(this._inputSelector)},get _inputElementValue(){return this._inputElement[this._propertyForValue]||this._inputElement.value},ready:function(){this.__isFirstValueUpdate=!0,this._addons||(this._addons=[]),this.addEventListener("focus",this._boundOnFocus,!0),this.addEventListener("blur",this._boundOnBlur,!0)},attached:function(){this.attrForValue?this._inputElement.addEventListener(this._valueChangedEvent,this._boundValueChanged):this.addEventListener("input",this._onInput),this._inputElementValue&&this._inputElementValue!=""?this._handleValueAndAutoValidate(this._inputElement):this._handleValue(this._inputElement)},_onAddonAttached:function(e){this._addons||(this._addons=[]);var t=e.target;this._addons.indexOf(t)===-1&&(this._addons.push(t),this.isAttached&&this._handleValue(this._inputElement))},_onFocus:function(){this._setFocused(!0)},_onBlur:function(){this._setFocused(!1),this._handleValueAndAutoValidate(this._inputElement)},_onInput:function(e){this._handleValueAndAutoValidate(e.target)},_onValueChanged:function(e){var t=e.target;this.__isFirstValueUpdate&&(this.__isFirstValueUpdate=!1,t.value===void 0||t.value==="")||this._handleValueAndAutoValidate(e.target)},_handleValue:function(e){var t=this._inputElementValue;t||t===0||e.type==="number"&&!e.checkValidity()?this._inputHasContent=!0:this._inputHasContent=!1,this.updateAddons({inputElement:e,value:t,invalid:this.invalid})},_handleValueAndAutoValidate:function(e){if(this.autoValidate&&e){var t;e.validate?t=e.validate(this._inputElementValue):t=e.checkValidity(),this.invalid=!t}this._handleValue(e)},_onIronInputValidate:function(e){this.invalid=this._inputElement.invalid},_invalidChanged:function(){this._addons&&this.updateAddons({invalid:this.invalid})},updateAddons:function(e){for(var t,r=0;t=this._addons[r];r++)t.update(e)},_computeInputContentClass:function(e,t,r,n,i){var o="input-content";if(e)i&&(o+=" label-is-hidden"),n&&(o+=" is-invalid");else{var a=this.querySelector("label");t||i?(o+=" label-is-floating",this.$.labelAndInputContainer.style.position="static",n?o+=" is-invalid":r&&(o+=" label-is-highlighted")):(a&&(this.$.labelAndInputContainer.style.position="relative"),n&&(o+=" is-invalid"))}return r&&(o+=" focused"),o},_computeUnderlineClass:function(e,t){var r="underline";return t?r+=" is-invalid":e&&(r+=" is-highlighted"),r},_computeAddOnContentClass:function(e,t){var r="add-on-content";return t?r+=" is-invalid":e&&(r+=" is-highlighted"),r}});Yt({_template:Q`
    <style>
      :host {
        display: inline-block;
        visibility: hidden;

        color: var(--paper-input-container-invalid-color, var(--error-color));

        @apply --paper-font-caption;
        @apply --paper-input-error;
        position: absolute;
        left:0;
        right:0;
      }

      :host([invalid]) {
        visibility: visible;
      }

      #a11yWrapper {
        visibility: hidden;
      }

      :host([invalid]) #a11yWrapper {
        visibility: visible;
      }
    </style>

    <!--
    If the paper-input-error element is directly referenced by an
    \`aria-describedby\` attribute, such as when used as a paper-input add-on,
    then applying \`visibility: hidden;\` to the paper-input-error element itself
    does not hide the error.

    For more information, see:
    https://www.w3.org/TR/accname-1.1/#mapping_additional_nd_description
    -->
    <div id="a11yWrapper">
      <slot></slot>
    </div>
`,is:"paper-input-error",behaviors:[C9],properties:{invalid:{readOnly:!0,reflectToAttribute:!0,type:Boolean}},update:function(e){this._setInvalid(e.invalid)}});var Zx={};Zx.NextLabelID=1;Zx.NextAddonID=1;Zx.NextInputID=1;var qbe={properties:{label:{type:String},value:{notify:!0,type:String},disabled:{type:Boolean,value:!1},invalid:{type:Boolean,value:!1,notify:!0},allowedPattern:{type:String},type:{type:String},list:{type:String},pattern:{type:String},required:{type:Boolean,value:!1},errorMessage:{type:String},charCounter:{type:Boolean,value:!1},noLabelFloat:{type:Boolean,value:!1},alwaysFloatLabel:{type:Boolean,value:!1},autoValidate:{type:Boolean,value:!1},validator:{type:String},autocomplete:{type:String,value:"off"},autofocus:{type:Boolean,observer:"_autofocusChanged"},inputmode:{type:String},minlength:{type:Number},maxlength:{type:Number},min:{type:String},max:{type:String},step:{type:String},name:{type:String},placeholder:{type:String,value:""},readonly:{type:Boolean,value:!1},size:{type:Number},autocapitalize:{type:String,value:"none"},autocorrect:{type:String,value:"off"},autosave:{type:String},results:{type:Number},accept:{type:String},multiple:{type:Boolean},_ariaDescribedBy:{type:String,value:""},_ariaLabelledBy:{type:String,value:""},_inputId:{type:String,value:""}},listeners:{"addon-attached":"_onAddonAttached"},keyBindings:{"shift+tab:keydown":"_onShiftTabDown"},hostAttributes:{tabindex:0},get inputElement(){return this.$||(this.$={}),this.$.input||(this._generateInputId(),this.$.input=this.$$("#"+this._inputId)),this.$.input},get _focusableElement(){return this.inputElement},created:function(){this._typesThatHaveText=["date","datetime","datetime-local","month","time","week","file"]},attached:function(){this._updateAriaLabelledBy(),!mt&&this.inputElement&&this._typesThatHaveText.indexOf(this.inputElement.type)!==-1&&(this.alwaysFloatLabel=!0)},_appendStringWithSpace:function(e,t){return e?e=e+" "+t:e=t,e},_onAddonAttached:function(e){var t=zt(e).rootTarget;if(t.id)this._ariaDescribedBy=this._appendStringWithSpace(this._ariaDescribedBy,t.id);else{var r="paper-input-add-on-"+Zx.NextAddonID++;t.id=r,this._ariaDescribedBy=this._appendStringWithSpace(this._ariaDescribedBy,r)}},validate:function(){return this.inputElement.validate()},_focusBlurHandler:function(e){Di._focusBlurHandler.call(this,e),this.focused&&!this._shiftTabPressed&&this._focusableElement&&this._focusableElement.focus()},_onShiftTabDown:function(e){var t=this.getAttribute("tabindex");this._shiftTabPressed=!0,this.setAttribute("tabindex","-1"),this.async(function(){this.setAttribute("tabindex",t),this._shiftTabPressed=!1},1)},_handleAutoValidate:function(){this.autoValidate&&this.validate()},updateValueAndPreserveCaret:function(e){try{var t=this.inputElement.selectionStart;this.value=e,this.inputElement.selectionStart=t,this.inputElement.selectionEnd=t}catch(r){this.value=e}},_computeAlwaysFloatLabel:function(e,t){return t||e},_updateAriaLabelledBy:function(){var e=zt(this.root).querySelector("label");if(!e){this._ariaLabelledBy="";return}var t;e.id?t=e.id:(t="paper-input-label-"+Zx.NextLabelID++,e.id=t),this._ariaLabelledBy=t},_generateInputId:function(){(!this._inputId||this._inputId==="")&&(this._inputId="input-"+Zx.NextInputID++)},_onChange:function(e){this.shadowRoot&&this.fire(e.type,{sourceEvent:e},{node:this,bubbles:e.bubbles,cancelable:e.cancelable})},_autofocusChanged:function(){if(this.autofocus&&this._focusableElement){var e=document.activeElement,t=e instanceof HTMLElement,r=t&&e!==document.body&&e!==document.documentElement;r||this._focusableElement.focus()}}},A9=[Di,Oo,qbe];Yt({is:"paper-input",_template:Q`
    <style>
      :host {
        display: block;
      }

      :host([focused]) {
        outline: none;
      }

      :host([hidden]) {
        display: none !important;
      }

      input {
        /* Firefox sets a min-width on the input, which can cause layout issues */
        min-width: 0;
      }

      /* In 1.x, the <input> is distributed to paper-input-container, which styles it.
      In 2.x the <iron-input> is distributed to paper-input-container, which styles
      it, but in order for this to work correctly, we need to reset some
      of the native input's properties to inherit (from the iron-input) */
      iron-input > input {
        @apply --paper-input-container-shared-input-style;
        font-family: inherit;
        font-weight: inherit;
        font-size: inherit;
        letter-spacing: inherit;
        word-spacing: inherit;
        line-height: inherit;
        text-shadow: inherit;
        color: inherit;
        cursor: inherit;
      }

      input:disabled {
        @apply --paper-input-container-input-disabled;
      }

      input::-webkit-outer-spin-button,
      input::-webkit-inner-spin-button {
        @apply --paper-input-container-input-webkit-spinner;
      }

      input::-webkit-clear-button {
        @apply --paper-input-container-input-webkit-clear;
      }

      input::-webkit-calendar-picker-indicator {
        @apply --paper-input-container-input-webkit-calendar-picker-indicator;
      }

      input::-webkit-input-placeholder {
        color: var(--paper-input-container-color, var(--secondary-text-color));
      }

      input:-moz-placeholder {
        color: var(--paper-input-container-color, var(--secondary-text-color));
      }

      input::-moz-placeholder {
        color: var(--paper-input-container-color, var(--secondary-text-color));
      }

      input::-ms-clear {
        @apply --paper-input-container-ms-clear;
      }

      input::-ms-reveal {
        @apply --paper-input-container-ms-reveal;
      }

      input:-ms-input-placeholder {
        color: var(--paper-input-container-color, var(--secondary-text-color));
      }

      label {
        pointer-events: none;
      }
    </style>

    <paper-input-container id="container" no-label-float="[[noLabelFloat]]" always-float-label="[[_computeAlwaysFloatLabel(alwaysFloatLabel,placeholder)]]" auto-validate$="[[autoValidate]]" disabled$="[[disabled]]" invalid="[[invalid]]">

      <slot name="prefix" slot="prefix"></slot>

      <label hidden$="[[!label]]" aria-hidden="true" for$="[[_inputId]]" slot="label">[[label]]</label>

      <!-- Need to bind maxlength so that the paper-input-char-counter works correctly -->
      <iron-input bind-value="{{value}}" slot="input" class="input-element" id$="[[_inputId]]" maxlength$="[[maxlength]]" allowed-pattern="[[allowedPattern]]" invalid="{{invalid}}" validator="[[validator]]">
        <input aria-labelledby$="[[_ariaLabelledBy]]" aria-describedby$="[[_ariaDescribedBy]]" disabled$="[[disabled]]" title$="[[title]]" type$="[[type]]" pattern$="[[pattern]]" required$="[[required]]" autocomplete$="[[autocomplete]]" autofocus$="[[autofocus]]" inputmode$="[[inputmode]]" minlength$="[[minlength]]" maxlength$="[[maxlength]]" min$="[[min]]" max$="[[max]]" step$="[[step]]" name$="[[name]]" placeholder$="[[placeholder]]" readonly$="[[readonly]]" list$="[[list]]" size$="[[size]]" autocapitalize$="[[autocapitalize]]" autocorrect$="[[autocorrect]]" on-change="_onChange" tabindex$="[[tabIndex]]" autosave$="[[autosave]]" results$="[[results]]" accept$="[[accept]]" multiple$="[[multiple]]" role$="[[inputRole]]" aria-haspopup$="[[inputAriaHaspopup]]">
      </iron-input>

      <slot name="suffix" slot="suffix"></slot>

      <template is="dom-if" if="[[errorMessage]]">
        <paper-input-error aria-live="assertive" slot="add-on">[[errorMessage]]</paper-input-error>
      </template>

      <template is="dom-if" if="[[charCounter]]">
        <paper-input-char-counter slot="add-on"></paper-input-char-counter>
      </template>

    </paper-input-container>
  `,behaviors:[A9,Eh],properties:{value:{type:String},inputRole:{type:String,value:void 0},inputAriaHaspopup:{type:String,value:void 0}},get _focusableElement(){return this.inputElement._inputElement},listeners:{"iron-input-ready":"_onIronInputReady"},_onIronInputReady:function(){this.$.nativeInput||(this.$.nativeInput=this.$$("input")),this.inputElement&&this._typesThatHaveText.indexOf(this.$.nativeInput.type)!==-1&&(this.alwaysFloatLabel=!0),this.inputElement.bindValue&&this.$.container._handleValueAndAutoValidate(this.inputElement)}});Yt({_template:Q`
    <style>
      :host {
        position: fixed;
      }

      #contentWrapper ::slotted(*) {
        overflow: auto;
      }

      #contentWrapper.animating ::slotted(*) {
        overflow: hidden;
        pointer-events: none;
      }
    </style>

    <div id="contentWrapper">
      <slot id="content" name="dropdown-content"></slot>
    </div>
`,is:"iron-dropdown",behaviors:[Di,Oo,Kx,b9],properties:{horizontalAlign:{type:String,value:"left",reflectToAttribute:!0},verticalAlign:{type:String,value:"top",reflectToAttribute:!0},openAnimationConfig:{type:Object},closeAnimationConfig:{type:Object},focusTarget:{type:Object},noAnimations:{type:Boolean,value:!1},allowOutsideScroll:{type:Boolean,value:!1,observer:"_allowOutsideScrollChanged"}},listeners:{"neon-animation-finish":"_onNeonAnimationFinish"},observers:["_updateOverlayPosition(positionTarget, verticalAlign, horizontalAlign, verticalOffset, horizontalOffset)"],get containedElement(){for(var e=zt(this.$.content).getDistributedNodes(),t=0,r=e.length;t<r;t++)if(e[t].nodeType===Node.ELEMENT_NODE)return e[t]},ready:function(){this.scrollAction||(this.scrollAction=this.allowOutsideScroll?"refit":"lock"),this._readied=!0},attached:function(){(!this.sizingTarget||this.sizingTarget===this)&&(this.sizingTarget=this.containedElement||this)},detached:function(){this.cancelAnimation()},_openedChanged:function(){this.opened&&this.disabled?this.cancel():(this.cancelAnimation(),this._updateAnimationConfig(),Pm._openedChanged.apply(this,arguments))},_renderOpened:function(){!this.noAnimations&&this.animationConfig.open?(this.$.contentWrapper.classList.add("animating"),this.playAnimation("open")):Pm._renderOpened.apply(this,arguments)},_renderClosed:function(){!this.noAnimations&&this.animationConfig.close?(this.$.contentWrapper.classList.add("animating"),this.playAnimation("close")):Pm._renderClosed.apply(this,arguments)},_onNeonAnimationFinish:function(){this.$.contentWrapper.classList.remove("animating"),this.opened?this._finishRenderOpened():this._finishRenderClosed()},_updateAnimationConfig:function(){for(var e=this.containedElement,t=[].concat(this.openAnimationConfig||[]).concat(this.closeAnimationConfig||[]),r=0;r<t.length;r++)t[r].node=e;this.animationConfig={open:this.openAnimationConfig,close:this.closeAnimationConfig}},_updateOverlayPosition:function(){this.isAttached&&this.notifyResize()},_allowOutsideScrollChanged:function(e){!this._readied||(e?(!this.scrollAction||this.scrollAction==="lock")&&(this.scrollAction="refit"):this.scrollAction="lock")},_applyFocus:function(){var e=this.focusTarget||this.containedElement;e&&this.opened&&!this.noAutoFocus?e.focus():Pm._applyFocus.apply(this,arguments)}});var yp={properties:{animationTiming:{type:Object,value:function(){return{duration:500,easing:"cubic-bezier(0.4, 0, 0.2, 1)",fill:"both"}}}},isNeonAnimation:!0,created:function(){document.body.animate||console.warn("No web animations detected. This element will not function without a web animations polyfill.")},timingFromConfig:function(e){if(e.timing)for(var t in e.timing)this.animationTiming[t]=e.timing[t];return this.animationTiming},setPrefixedProperty:function(e,t,r){for(var n={transform:["webkitTransform"],transformOrigin:["mozTransformOrigin","webkitTransformOrigin"]},i=n[t],o,a=0;o=i[a];a++)e.style[o]=r;e.style[t]=r},complete:function(e){}};Yt({is:"fade-in-animation",behaviors:[yp],configure:function(e){var t=e.node;return this._effect=new KeyframeEffect(t,[{opacity:"0"},{opacity:"1"}],this.timingFromConfig(e)),this._effect}});Yt({is:"fade-out-animation",behaviors:[yp],configure:function(e){var t=e.node;return this._effect=new KeyframeEffect(t,[{opacity:"1"},{opacity:"0"}],this.timingFromConfig(e)),this._effect}});Yt({is:"paper-menu-grow-height-animation",_template:null,behaviors:[yp],configure:function(e){var t=e.node,r=t.getBoundingClientRect(),n=r.height;return this._effect=new KeyframeEffect(t,[{height:n/2+"px"},{height:n+"px"}],this.timingFromConfig(e)),this._effect}});Yt({is:"paper-menu-grow-width-animation",_template:null,behaviors:[yp],configure:function(e){var t=e.node,r=t.getBoundingClientRect(),n=r.width;return this._effect=new KeyframeEffect(t,[{width:n/2+"px"},{width:n+"px"}],this.timingFromConfig(e)),this._effect}});Yt({is:"paper-menu-shrink-width-animation",_template:null,behaviors:[yp],configure:function(e){var t=e.node,r=t.getBoundingClientRect(),n=r.width;return this._effect=new KeyframeEffect(t,[{width:n+"px"},{width:n-n/20+"px"}],this.timingFromConfig(e)),this._effect}});Yt({is:"paper-menu-shrink-height-animation",_template:null,behaviors:[yp],configure:function(e){var t=e.node,r=t.getBoundingClientRect(),n=r.height;return this.setPrefixedProperty(t,"transformOrigin","0 0"),this._effect=new KeyframeEffect(t,[{height:n+"px",transform:"translateY(0)"},{height:n/2+"px",transform:"translateY(-20px)"}],this.timingFromConfig(e)),this._effect}});var dE={ANIMATION_CUBIC_BEZIER:"cubic-bezier(.3,.95,.5,1)",MAX_ANIMATION_TIME_MS:400},Gbe=Yt({_template:Q`
    <style>
      :host {
        display: inline-block;
        position: relative;
        padding: 8px;
        outline: none;

        @apply --paper-menu-button;
      }

      :host([disabled]) {
        cursor: auto;
        color: var(--disabled-text-color);

        @apply --paper-menu-button-disabled;
      }

      iron-dropdown {
        @apply --paper-menu-button-dropdown;
      }

      .dropdown-content {
        @apply --shadow-elevation-2dp;

        position: relative;
        border-radius: 2px;
        background-color: var(--paper-menu-button-dropdown-background, var(--primary-background-color));

        @apply --paper-menu-button-content;
      }

      :host([vertical-align="top"]) .dropdown-content {
        margin-bottom: 20px;
        margin-top: -10px;
        top: 10px;
      }

      :host([vertical-align="bottom"]) .dropdown-content {
        bottom: 10px;
        margin-bottom: -10px;
        margin-top: 20px;
      }

      #trigger {
        cursor: pointer;
      }
    </style>

    <div id="trigger" on-tap="toggle">
      <slot name="dropdown-trigger"></slot>
    </div>

    <iron-dropdown id="dropdown" opened="{{opened}}" horizontal-align="[[horizontalAlign]]" vertical-align="[[verticalAlign]]" dynamic-align="[[dynamicAlign]]" horizontal-offset="[[horizontalOffset]]" vertical-offset="[[verticalOffset]]" no-overlap="[[noOverlap]]" open-animation-config="[[openAnimationConfig]]" close-animation-config="[[closeAnimationConfig]]" no-animations="[[noAnimations]]" focus-target="[[_dropdownContent]]" allow-outside-scroll="[[allowOutsideScroll]]" restore-focus-on-close="[[restoreFocusOnClose]]" on-iron-overlay-canceled="__onIronOverlayCanceled" expand-sizing-target-for-scrollbars="[[expandSizingTargetForScrollbars]]">
      <div slot="dropdown-content" class="dropdown-content">
        <slot id="content" name="dropdown-content"></slot>
      </div>
    </iron-dropdown>
`,is:"paper-menu-button",behaviors:[Oo,Di],properties:{opened:{type:Boolean,value:!1,notify:!0,observer:"_openedChanged"},horizontalAlign:{type:String,value:"left",reflectToAttribute:!0},verticalAlign:{type:String,value:"top",reflectToAttribute:!0},dynamicAlign:{type:Boolean},horizontalOffset:{type:Number,value:0,notify:!0},verticalOffset:{type:Number,value:0,notify:!0},noOverlap:{type:Boolean},noAnimations:{type:Boolean,value:!1},ignoreSelect:{type:Boolean,value:!1},closeOnActivate:{type:Boolean,value:!1},openAnimationConfig:{type:Object,value:function(){return[{name:"fade-in-animation",timing:{delay:100,duration:200}},{name:"paper-menu-grow-width-animation",timing:{delay:100,duration:150,easing:dE.ANIMATION_CUBIC_BEZIER}},{name:"paper-menu-grow-height-animation",timing:{delay:100,duration:275,easing:dE.ANIMATION_CUBIC_BEZIER}}]}},closeAnimationConfig:{type:Object,value:function(){return[{name:"fade-out-animation",timing:{duration:150}},{name:"paper-menu-shrink-width-animation",timing:{delay:100,duration:50,easing:dE.ANIMATION_CUBIC_BEZIER}},{name:"paper-menu-shrink-height-animation",timing:{duration:200,easing:"ease-in"}}]}},allowOutsideScroll:{type:Boolean,value:!1},restoreFocusOnClose:{type:Boolean,value:!0},expandSizingTargetForScrollbars:{type:Boolean,value:!1},_dropdownContent:{type:Object}},hostAttributes:{role:"group","aria-haspopup":"true"},listeners:{"iron-activate":"_onIronActivate","iron-select":"_onIronSelect"},get contentElement(){for(var e=zt(this.$.content).getDistributedNodes(),t=0,r=e.length;t<r;t++)if(e[t].nodeType===Node.ELEMENT_NODE)return e[t]},toggle:function(){this.opened?this.close():this.open()},open:function(){this.disabled||this.$.dropdown.open()},close:function(){this.$.dropdown.close()},_onIronSelect:function(e){this.ignoreSelect||this.close()},_onIronActivate:function(e){this.closeOnActivate&&this.close()},_openedChanged:function(e,t){e?(this._dropdownContent=this.contentElement,this.fire("paper-dropdown-open")):t!=null&&this.fire("paper-dropdown-close")},_disabledChanged:function(e){Di._disabledChanged.apply(this,arguments),e&&this.opened&&this.close()},__onIronOverlayCanceled:function(e){var t=e.detail,r=this.$.trigger,n=zt(t).path;n.indexOf(r)>-1&&e.preventDefault()}});Object.keys(dE).forEach(function(e){Gbe[e]=dE[e]});var vW=document.createElement("template");vW.setAttribute("style","display: none;");vW.innerHTML=`<iron-iconset-svg name="paper-dropdown-menu" size="24">
<svg><defs>
<g id="arrow-drop-down"><path d="M7 10l5 5 5-5z"></path></g>
</defs></svg>
</iron-iconset-svg>`;document.head.appendChild(vW.content);var xW=document.createElement("template");xW.setAttribute("style","display: none;");xW.innerHTML=`<dom-module id="paper-dropdown-menu-shared-styles">
  <template>
    <style>
      :host {
        display: inline-block;
        position: relative;
        text-align: left;

        /* NOTE(cdata): Both values are needed, since some phones require the
         * value to be \`transparent\`.
         */
        -webkit-tap-highlight-color: rgba(0,0,0,0);
        -webkit-tap-highlight-color: transparent;

        --paper-input-container-input: {
          overflow: hidden;
          white-space: nowrap;
          text-overflow: ellipsis;
          max-width: 100%;
          box-sizing: border-box;
          cursor: pointer;
        };

        @apply --paper-dropdown-menu;
      }

      /* paper-dropdown-menu and paper-dropdown-menu-light both delegate focus
       * to other internal elements which manage focus styling. */
      :host(:focus) {
        outline: none;
      }

      :host(:dir(rtl)) {
        text-align: right;

        @apply(--paper-dropdown-menu);
      }

      :host([disabled]) {
        @apply --paper-dropdown-menu-disabled;
      }

      :host([noink]) paper-ripple {
        display: none;
      }

      :host([no-label-float]) paper-ripple {
        top: 8px;
      }

      paper-ripple {
        top: 12px;
        left: 0px;
        bottom: 8px;
        right: 0px;

        @apply --paper-dropdown-menu-ripple;
      }

      paper-menu-button {
        display: block;
        padding: 0;

        @apply --paper-dropdown-menu-button;
      }

      paper-input {
        @apply --paper-dropdown-menu-input;
      }

      iron-icon {
        color: var(--disabled-text-color);

        @apply --paper-dropdown-menu-icon;
      }
    </style>
  </template>
</dom-module>`;document.head.appendChild(xW.content);var Wbe=Gt(HTMLElement);Yt({_template:Q`
    <style include="paper-dropdown-menu-shared-styles"></style>

    <paper-menu-button id="menuButton" vertical-align="[[verticalAlign]]" horizontal-align="[[horizontalAlign]]" dynamic-align="[[dynamicAlign]]" vertical-offset="[[_computeMenuVerticalOffset(noLabelFloat, verticalOffset)]]" disabled="[[disabled]]" no-animations="[[noAnimations]]" on-iron-select="_onIronSelect" on-iron-deselect="_onIronDeselect" opened="{{opened}}" close-on-activate allow-outside-scroll="[[allowOutsideScroll]]" restore-focus-on-close="[[restoreFocusOnClose]]" expand-sizing-target-for-scrollbars="[[expandSizingTargetForScrollbars]]">
      <!-- support hybrid mode: user might be using paper-menu-button 1.x which distributes via <content> -->
      <div class="dropdown-trigger" slot="dropdown-trigger">
        <paper-ripple></paper-ripple>
        <!-- paper-input has type="text" for a11y, do not remove -->
        <paper-input id="input" type="text" invalid="[[invalid]]" readonly disabled="[[disabled]]" value="[[value]]" placeholder="[[placeholder]]" error-message="[[errorMessage]]" always-float-label="[[alwaysFloatLabel]]" no-label-float="[[noLabelFloat]]" label="[[label]]" input-role="button" input-aria-haspopup="listbox" autocomplete="off">
          <!-- support hybrid mode: user might be using paper-input 1.x which distributes via <content> -->
          <iron-icon icon="paper-dropdown-menu:arrow-drop-down" suffix slot="suffix"></iron-icon>
        </paper-input>
      </div>
      <slot id="content" name="dropdown-content" slot="dropdown-content"></slot>
    </paper-menu-button>
`,is:"paper-dropdown-menu",behaviors:[Sh,Di,Eh,Th],properties:{selectedItemLabel:{type:String,notify:!0,readOnly:!0},selectedItem:{type:Object,notify:!0,readOnly:!0},value:{type:String,notify:!0},label:{type:String},placeholder:{type:String},errorMessage:{type:String},opened:{type:Boolean,notify:!0,value:!1,observer:"_openedChanged"},allowOutsideScroll:{type:Boolean,value:!1},noLabelFloat:{type:Boolean,value:!1,reflectToAttribute:!0},alwaysFloatLabel:{type:Boolean,value:!1},noAnimations:{type:Boolean,value:!1},horizontalAlign:{type:String,value:"right"},verticalAlign:{type:String,value:"top"},verticalOffset:Number,dynamicAlign:{type:Boolean},restoreFocusOnClose:{type:Boolean,value:!0},expandSizingTargetForScrollbars:{type:Boolean,value:!1}},listeners:{tap:"_onTap"},keyBindings:{"up down":"open",esc:"close"},observers:["_selectedItemChanged(selectedItem)"],_attachDom(e){let t=ue(this);return t.attachShadow({mode:"open",delegatesFocus:!0,shadyUpgradeFragment:e}),t.shadowRoot.appendChild(e),Wbe.prototype._attachDom.call(this,e)},focus(){this.$.input._focusableElement.focus()},attached:function(){var e=this.contentElement;e&&e.selectedItem&&this._setSelectedItem(e.selectedItem)},get contentElement(){for(var e=zt(this.$.content).getDistributedNodes(),t=0,r=e.length;t<r;t++)if(e[t].nodeType===Node.ELEMENT_NODE)return e[t]},open:function(){this.$.menuButton.open()},close:function(){this.$.menuButton.close()},_onIronSelect:function(e){this._setSelectedItem(e.detail.item)},_onIronDeselect:function(e){this._setSelectedItem(null)},_onTap:function(e){lgt(e)===this&&this.open()},_selectedItemChanged:function(e){var t="";e?t=e.label||e.getAttribute("label")||e.textContent.trim():t="",this.value=t,this._setSelectedItemLabel(t)},_computeMenuVerticalOffset:function(e,t){return t||(e?-4:8)},_getValidity:function(e){return this.disabled||!this.required||this.required&&!!this.value},_openedChanged:function(){var e=this.opened?"true":"false",t=this.contentElement;t&&t.setAttribute("aria-expanded",e)}});var bW=1,P0t=2,P9={outerScroll:{scroll:!0},shadowMode:{standard:P0t,waterfall:bW,"waterfall-tall":bW},tallMode:{"waterfall-tall":!0}};Yt({_template:Q`
    <style>
      :host {
        @apply --layout-vertical;
        position: relative;
        height: 100%;
        @apply --paper-header-panel;
      }

      #mainContainer {
        @apply --layout-flex;
        position: relative;
        overflow-y: auto;
        overflow-x: hidden;
        -webkit-overflow-scrolling: touch;
      }

      #mainPanel {
        @apply --layout-vertical;
        @apply --layout-flex;
        position: relative;
        min-height: 0;
        @apply --paper-header-panel-body;
      }

      #mainContainer {
        @apply --paper-header-panel-container;
      }

      /*
       * mode: scroll
       */
      :host([mode=scroll]) #mainContainer {
        @apply --paper-header-panel-scroll-container;
        overflow: visible;
      }

      :host([mode=scroll]) {
        overflow-y: auto;
        overflow-x: hidden;
        -webkit-overflow-scrolling: touch;
      }

      /*
       * mode: cover
       */
      :host([mode=cover]) #mainContainer {
        @apply --paper-header-panel-cover-container;
        position: absolute;
        top: 0;
        right: 0;
        bottom: 0;
        left: 0;
      }

      :host([mode=cover]) #mainPanel {
        position: static;
      }

      /*
       * mode: standard
       */
      :host([mode=standard]) #mainContainer {
        @apply --paper-header-panel-standard-container;
      }

      /*
       * mode: seamed
       */
      :host([mode=seamed]) #mainContainer {
        @apply --paper-header-panel-seamed-container;
      }


      /*
       * mode: waterfall
       */
      :host([mode=waterfall]) #mainContainer {
        @apply --paper-header-panel-waterfall-container;
      }

      /*
       * mode: waterfall-tall
       */
      :host([mode=waterfall-tall]) #mainContainer {
        @apply --paper-header-panel-waterfall-tall-container;
      }

      #dropShadow {
        transition: opacity 0.5s;
        height: 6px;
        box-shadow: inset 0px 5px 6px -3px rgba(0, 0, 0, 0.4);
        @apply --paper-header-panel-shadow;
        position: absolute;
        top: 0;
        left: 0;
        right: 0;
        opacity: 0;
        pointer-events: none;
      }

      #dropShadow.has-shadow {
        opacity: 1;
      }

      #mainContainer > ::slotted(.fit) {
        @apply --layout-fit;
      }

    </style>

    <slot id="headerSlot" name="header"></slot>

    <div id="mainPanel">
      <div id="mainContainer" class\$="[[_computeMainContainerClass(mode)]]">
        <slot></slot>
      </div>
      <div id="dropShadow"></div>
    </div>
`,is:"paper-header-panel",properties:{mode:{type:String,value:"standard",observer:"_modeChanged",reflectToAttribute:!0},shadow:{type:Boolean,value:!1},tallClass:{type:String,value:"tall"},atTop:{type:Boolean,value:!0,notify:!0,readOnly:!0,reflectToAttribute:!0}},observers:["_computeDropShadowHidden(atTop, mode, shadow)"],attached:function(){this._addListener(),this._keepScrollingState()},detached:function(){this._removeListener()},ready:function(){this.scrollHandler=this._scroll.bind(this),console.warn(this.is,"is deprecated. Please use app-layout instead!")},get header(){return zt(this.$.headerSlot).getDistributedNodes()[0]},get scroller(){return this._getScrollerForMode(this.mode)},get visibleShadow(){return this.$.dropShadow.classList.contains("has-shadow")},_computeDropShadowHidden:function(e,t,r){var n=P9.shadowMode[t];this.shadow?this.toggleClass("has-shadow",!0,this.$.dropShadow):n===P0t?this.toggleClass("has-shadow",!0,this.$.dropShadow):n===bW&&!e?this.toggleClass("has-shadow",!0,this.$.dropShadow):this.toggleClass("has-shadow",!1,this.$.dropShadow)},_computeMainContainerClass:function(e){var t={};return t.flex=e!=="cover",Object.keys(t).filter(function(r){return t[r]}).join(" ")},_addListener:function(){this.scroller.addEventListener("scroll",this.scrollHandler)},_removeListener:function(){this.scroller.removeEventListener("scroll",this.scrollHandler)},_modeChanged:function(e,t){var r=P9,n=this.header,i=200;n&&(r.tallMode[t]&&!r.tallMode[e]?(n.classList.remove(this.tallClass),this.async(function(){n.classList.remove("animate")},i)):this.toggleClass("animate",r.tallMode[e],n)),this._keepScrollingState()},_keepScrollingState:function(){var e=this.scroller,t=this.header;this._setAtTop(e.scrollTop===0),t&&this.tallClass&&P9.tallMode[this.mode]&&this.toggleClass(this.tallClass,this.atTop||t.classList.contains(this.tallClass)&&e.scrollHeight<this.offsetHeight,t)},_scroll:function(){this._keepScrollingState(),this.fire("content-scroll",{target:this.scroller},{bubbles:!1})},_getScrollerForMode:function(e){return P9.outerScroll[e]?this:this.$.mainContainer}});Yt({is:"paper-icon-button",_template:Q`
    <style>
      :host {
        display: inline-block;
        position: relative;
        padding: 8px;
        outline: none;
        -webkit-user-select: none;
        -moz-user-select: none;
        -ms-user-select: none;
        user-select: none;
        cursor: pointer;
        z-index: 0;
        line-height: 1;

        width: 40px;
        height: 40px;

        /*
          NOTE: Both values are needed, since some phones require the value to
          be \`transparent\`.
        */
        -webkit-tap-highlight-color: rgba(0, 0, 0, 0);
        -webkit-tap-highlight-color: transparent;

        /* Because of polymer/2558, this style has lower specificity than * */
        box-sizing: border-box !important;

        @apply --paper-icon-button;
      }

      :host #ink {
        color: var(--paper-icon-button-ink-color, var(--primary-text-color));
        opacity: 0.6;
      }

      :host([disabled]) {
        color: var(--paper-icon-button-disabled-text, var(--disabled-text-color));
        pointer-events: none;
        cursor: auto;

        @apply --paper-icon-button-disabled;
      }

      :host([hidden]) {
        display: none !important;
      }

      :host(:hover) {
        @apply --paper-icon-button-hover;
      }

      iron-icon {
        --iron-icon-width: 100%;
        --iron-icon-height: 100%;
      }
    </style>

    <iron-icon id="icon" src="[[src]]" icon="[[icon]]"
               alt$="[[alt]]"></iron-icon>
  `,hostAttributes:{role:"button",tabindex:"0"},behaviors:[jx],registered:function(){this._template.setAttribute("strip-whitespace","")},properties:{src:{type:String},icon:{type:String},alt:{type:String,observer:"_altChanged"}},_altChanged:function(e,t){var r=this.getAttribute("aria-label");(!r||t==r)&&this.setAttribute("aria-label",e)}});Yt({_template:Q`
    <style>
      :host {
        display: inline-block;
        position: relative;
        width: 400px;
        border: 1px solid;
        padding: 2px;
        -moz-appearance: textarea;
        -webkit-appearance: textarea;
        overflow: hidden;
      }

      .mirror-text {
        visibility: hidden;
        word-wrap: break-word;
        @apply --iron-autogrow-textarea;
      }

      .fit {
        @apply --layout-fit;
      }

      textarea {
        position: relative;
        outline: none;
        border: none;
        resize: none;
        background: inherit;
        color: inherit;
        /* see comments in template */
        width: 100%;
        height: 100%;
        font-size: inherit;
        font-family: inherit;
        line-height: inherit;
        text-align: inherit;
        @apply --iron-autogrow-textarea;
      }

      textarea::-webkit-input-placeholder {
        @apply --iron-autogrow-textarea-placeholder;
      }

      textarea:-moz-placeholder {
        @apply --iron-autogrow-textarea-placeholder;
      }

      textarea::-moz-placeholder {
        @apply --iron-autogrow-textarea-placeholder;
      }

      textarea:-ms-input-placeholder {
        @apply --iron-autogrow-textarea-placeholder;
      }
    </style>

    <!-- the mirror sizes the input/textarea so it grows with typing -->
    <!-- use &#160; instead &nbsp; of to allow this element to be used in XHTML -->
    <div id="mirror" class="mirror-text" aria-hidden="true">&nbsp;</div>

    <!-- size the input/textarea with a div, because the textarea has intrinsic size in ff -->
    <div class="textarea-container fit">
      <textarea id="textarea" name$="[[name]]" aria-label$="[[label]]" autocomplete$="[[autocomplete]]" autofocus$="[[autofocus]]" autocapitalize$="[[autocapitalize]]" inputmode$="[[inputmode]]" placeholder$="[[placeholder]]" readonly$="[[readonly]]" required$="[[required]]" disabled$="[[disabled]]" rows$="[[rows]]" minlength$="[[minlength]]" maxlength$="[[maxlength]]"></textarea>
    </div>
`,is:"iron-autogrow-textarea",behaviors:[Th,Di],properties:{value:{observer:"_valueChanged",type:String,notify:!0},bindValue:{observer:"_bindValueChanged",type:String,notify:!0},rows:{type:Number,value:1,observer:"_updateCached"},maxRows:{type:Number,value:0,observer:"_updateCached"},autocomplete:{type:String,value:"off"},autofocus:{type:Boolean,value:!1},autocapitalize:{type:String,value:"none"},inputmode:{type:String},placeholder:{type:String},readonly:{type:String},required:{type:Boolean},minlength:{type:Number},maxlength:{type:Number},label:{type:String}},listeners:{input:"_onInput"},get textarea(){return this.$.textarea},get selectionStart(){return this.$.textarea.selectionStart},get selectionEnd(){return this.$.textarea.selectionEnd},set selectionStart(e){this.$.textarea.selectionStart=e},set selectionEnd(e){this.$.textarea.selectionEnd=e},attached:function(){var e=navigator.userAgent.match(/iP(?:[oa]d|hone)/)&&!navigator.userAgent.match(/OS 1[3456789]/);e&&(this.$.textarea.style.marginLeft="-3px")},validate:function(){var e=this.$.textarea.validity.valid;return e&&(this.required&&this.value===""?e=!1:this.hasValidator()&&(e=Th.validate.call(this,this.value))),this.invalid=!e,this.fire("iron-input-validate"),e},_bindValueChanged:function(e){this.value=e},_valueChanged:function(e){var t=this.textarea;!t||(t.value!==e&&(t.value=e||e===0?e:""),this.bindValue=e,this.$.mirror.innerHTML=this._valueForMirror(),this.fire("bind-value-changed",{value:this.bindValue}))},_onInput:function(e){var t=zt(e).path;this.value=t?t[0].value:e.target.value},_constrain:function(e){var t;for(e=e||[""],this.maxRows>0&&e.length>this.maxRows?t=e.slice(0,this.maxRows):t=e.slice(0);this.rows>0&&t.length<this.rows;)t.push("");return t.join("<br/>")+"&#160;"},_valueForMirror:function(){var e=this.textarea;if(!!e)return this.tokens=e&&e.value?e.value.replace(/&/gm,"&amp;").replace(/"/gm,"&quot;").replace(/'/gm,"&#39;").replace(/</gm,"&lt;").replace(/>/gm,"&gt;").split(`
`):[""],this._constrain(this.tokens)},_updateCached:function(){this.$.mirror.innerHTML=this._constrain(this.tokens)}});Yt({_template:Q`
    <style>
      :host {
        display: block;
      }

      :host([hidden]) {
        display: none !important;
      }

      label {
        pointer-events: none;
      }
    </style>

    <paper-input-container no-label-float$="[[noLabelFloat]]" always-float-label="[[_computeAlwaysFloatLabel(alwaysFloatLabel,placeholder)]]" auto-validate$="[[autoValidate]]" disabled$="[[disabled]]" invalid="[[invalid]]">

      <label hidden$="[[!label]]" aria-hidden="true" for$="[[_inputId]]" slot="label">[[label]]</label>

      <iron-autogrow-textarea class="paper-input-input" slot="input" id$="[[_inputId]]" aria-labelledby$="[[_ariaLabelledBy]]" aria-describedby$="[[_ariaDescribedBy]]" bind-value="{{value}}" invalid="{{invalid}}" validator$="[[validator]]" disabled$="[[disabled]]" autocomplete$="[[autocomplete]]" autofocus$="[[autofocus]]" inputmode$="[[inputmode]]" name$="[[name]]" placeholder$="[[placeholder]]" readonly$="[[readonly]]" required$="[[required]]" minlength$="[[minlength]]" maxlength$="[[maxlength]]" autocapitalize$="[[autocapitalize]]" rows$="[[rows]]" max-rows$="[[maxRows]]" on-change="_onChange"></iron-autogrow-textarea>

      <template is="dom-if" if="[[errorMessage]]">
        <paper-input-error aria-live="assertive" slot="add-on">[[errorMessage]]</paper-input-error>
      </template>

      <template is="dom-if" if="[[charCounter]]">
        <paper-input-char-counter slot="add-on"></paper-input-char-counter>
      </template>

    </paper-input-container>
`,is:"paper-textarea",behaviors:[A9,Eh],properties:{_ariaLabelledBy:{observer:"_ariaLabelledByChanged",type:String},_ariaDescribedBy:{observer:"_ariaDescribedByChanged",type:String},value:{type:String},rows:{type:Number,value:1},maxRows:{type:Number,value:0}},get selectionStart(){return this.$.input.textarea.selectionStart},set selectionStart(e){this.$.input.textarea.selectionStart=e},get selectionEnd(){return this.$.input.textarea.selectionEnd},set selectionEnd(e){this.$.input.textarea.selectionEnd=e},_ariaLabelledByChanged:function(e){this._focusableElement.setAttribute("aria-labelledby",e)},_ariaDescribedByChanged:function(e){this._focusableElement.setAttribute("aria-describedby",e)},get _focusableElement(){return this.inputElement.textarea}});var wW=document.createElement("template");wW.setAttribute("style","display: none;");wW.innerHTML=`<dom-module id="paper-item-shared-styles">
  <template>
    <style>
      :host, .paper-item {
        display: block;
        position: relative;
        min-height: var(--paper-item-min-height, 48px);
        padding: 0px 16px;
      }

      .paper-item {
        @apply --paper-font-subhead;
        border:none;
        outline: none;
        background: white;
        width: 100%;
        text-align: left;
      }

      :host([hidden]), .paper-item[hidden] {
        display: none !important;
      }

      :host(.iron-selected), .paper-item.iron-selected {
        font-weight: var(--paper-item-selected-weight, bold);

        @apply --paper-item-selected;
      }

      :host([disabled]), .paper-item[disabled] {
        color: var(--paper-item-disabled-color, var(--disabled-text-color));

        @apply --paper-item-disabled;
      }

      :host(:focus), .paper-item:focus {
        position: relative;
        outline: 0;

        @apply --paper-item-focused;
      }

      :host(:focus):before, .paper-item:focus:before {
        @apply --layout-fit;

        background: currentColor;
        content: '';
        opacity: var(--dark-divider-opacity);
        pointer-events: none;

        @apply --paper-item-focused-before;
      }
    </style>
  </template>
</dom-module>`;document.head.appendChild(wW.content);var Ybe={hostAttributes:{role:"option",tabindex:"0"}},I9=[Sh,Di,Ybe];Yt({_template:Q`
    <style include="paper-item-shared-styles">
      :host {
        @apply --layout-horizontal;
        @apply --layout-center;
        @apply --paper-font-subhead;

        @apply --paper-item;
      }
    </style>
    <slot></slot>
`,is:"paper-item",behaviors:[I9]});Yt({_template:Q`
    <style>
      :host {
        overflow: hidden; /* needed for text-overflow: ellipsis to work on ff */
        @apply --layout-vertical;
        @apply --layout-center-justified;
        @apply --layout-flex;
      }

      :host([two-line]) {
        min-height: var(--paper-item-body-two-line-min-height, 72px);
      }

      :host([three-line]) {
        min-height: var(--paper-item-body-three-line-min-height, 88px);
      }

      :host > ::slotted(*) {
        overflow: hidden;
        text-overflow: ellipsis;
        white-space: nowrap;
      }

      :host > ::slotted([secondary]) {
        @apply --paper-font-body1;

        color: var(--paper-item-body-secondary-color, var(--secondary-text-color));

        @apply --paper-item-body-secondary;
      }
    </style>

    <slot></slot>
`,is:"paper-item-body"});Yt({_template:Q`
    <style include="paper-item-shared-styles"></style>
    <style>
      :host {
        @apply --layout-horizontal;
        @apply --layout-center;
        @apply --paper-font-subhead;

        @apply --paper-item;
        @apply --paper-icon-item;
      }

      .content-icon {
        @apply --layout-horizontal;
        @apply --layout-center;

        width: var(--paper-item-icon-width, 56px);
        @apply --paper-item-icon;
      }
    </style>

    <div id="contentIcon" class="content-icon">
      <slot name="item-icon"></slot>
    </div>
    <slot></slot>
`,is:"paper-icon-item",behaviors:[I9]});var SW={properties:{multi:{type:Boolean,value:!1,observer:"multiChanged"},selectedValues:{type:Array,notify:!0,value:function(){return[]}},selectedItems:{type:Array,readOnly:!0,notify:!0,value:function(){return[]}}},observers:["_updateSelected(selectedValues.splices)"],select:function(e){this.multi?this._toggleSelected(e):this.selected=e},multiChanged:function(e){this._selection.multi=e,this._updateSelected()},get _shouldUpdateSelection(){return this.selected!=null||this.selectedValues!=null&&this.selectedValues.length},_updateAttrForSelected:function(){this.multi?this.selectedItems&&this.selectedItems.length>0&&(this.selectedValues=this.selectedItems.map(function(e){return this._indexToValue(this.indexOf(e))},this).filter(function(e){return e!=null},this)):wh._updateAttrForSelected.apply(this)},_updateSelected:function(){this.multi?this._selectMulti(this.selectedValues):this._selectSelected(this.selected)},_selectMulti:function(e){e=e||[];var t=(this._valuesToItems(e)||[]).filter(function(i){return i!=null});this._selection.clear(t);for(var r=0;r<t.length;r++)this._selection.setItemSelected(t[r],!0);if(this.fallbackSelection&&!this._selection.get().length){var n=this._valueToItem(this.fallbackSelection);n&&this.select(this.fallbackSelection)}},_selectionChange:function(){var e=this._selection.get();this.multi?(this._setSelectedItems(e),this._setSelectedItem(e.length?e[0]:null)):e!=null?(this._setSelectedItems([e]),this._setSelectedItem(e)):(this._setSelectedItems([]),this._setSelectedItem(null))},_toggleSelected:function(e){var t=this.selectedValues.indexOf(e),r=t<0;r?this.push("selectedValues",e):this.splice("selectedValues",t,1)},_valuesToItems:function(e){return e==null?null:e.map(function(t){return this._valueToItem(t)},this)}},I0t=[wh,SW];var __={properties:{focusedItem:{observer:"_focusedItemChanged",readOnly:!0,type:Object},attrForItemTitle:{type:String},disabled:{type:Boolean,value:!1,observer:"_disabledChanged"}},_MODIFIER_KEYS:["Alt","AltGraph","CapsLock","Control","Fn","FnLock","Hyper","Meta","NumLock","OS","ScrollLock","Shift","Super","Symbol","SymbolLock"],_SEARCH_RESET_TIMEOUT_MS:1e3,_previousTabIndex:0,hostAttributes:{role:"menu"},observers:["_updateMultiselectable(multi)"],listeners:{focus:"_onFocus",keydown:"_onKeydown","iron-items-changed":"_onIronItemsChanged"},keyBindings:{up:"_onUpKey",down:"_onDownKey",esc:"_onEscKey","shift+tab:keydown":"_onShiftTabDown"},attached:function(){this._resetTabindices()},select:function(e){this._defaultFocusAsync&&(this.cancelAsync(this._defaultFocusAsync),this._defaultFocusAsync=null);var t=this._valueToItem(e);t&&t.hasAttribute("disabled")||(this._setFocusedItem(t),SW.select.apply(this,arguments))},_resetTabindices:function(){var e=this.multi?this.selectedItems&&this.selectedItems[0]:this.selectedItem;this.items.forEach(function(t){t.setAttribute("tabindex",t===e?"0":"-1"),t.setAttribute("aria-selected",this._selection.isSelected(t))},this)},_updateMultiselectable:function(e){e?this.setAttribute("aria-multiselectable","true"):this.removeAttribute("aria-multiselectable")},_focusWithKeyboardEvent:function(e){if(this._MODIFIER_KEYS.indexOf(e.key)===-1){this.cancelDebouncer("_clearSearchText");var t=this._searchText||"",r=e.key&&e.key.length==1?e.key:String.fromCharCode(e.keyCode);t+=r.toLocaleLowerCase();for(var n=t.length,i=0,o;o=this.items[i];i++)if(!o.hasAttribute("disabled")){var a=this.attrForItemTitle||"textContent",s=(o[a]||o.getAttribute(a)||"").trim();if(!(s.length<n)&&s.slice(0,n).toLocaleLowerCase()==t){this._setFocusedItem(o);break}}this._searchText=t,this.debounce("_clearSearchText",this._clearSearchText,this._SEARCH_RESET_TIMEOUT_MS)}},_clearSearchText:function(){this._searchText=""},_focusPrevious:function(){for(var e=this.items.length,t=Number(this.indexOf(this.focusedItem)),r=1;r<e+1;r++){var n=this.items[(t-r+e)%e];if(!n.hasAttribute("disabled")){var i=zt(n).getOwnerRoot()||document;if(this._setFocusedItem(n),zt(i).activeElement==n)return}}},_focusNext:function(){for(var e=this.items.length,t=Number(this.indexOf(this.focusedItem)),r=1;r<e+1;r++){var n=this.items[(t+r)%e];if(!n.hasAttribute("disabled")){var i=zt(n).getOwnerRoot()||document;if(this._setFocusedItem(n),zt(i).activeElement==n)return}}},_applySelection:function(e,t){t?e.setAttribute("aria-selected","true"):e.setAttribute("aria-selected","false"),wh._applySelection.apply(this,arguments)},_focusedItemChanged:function(e,t){t&&t.setAttribute("tabindex","-1"),e&&!e.hasAttribute("disabled")&&!this.disabled&&(e.setAttribute("tabindex","0"),e.focus())},_onIronItemsChanged:function(e){e.detail.addedNodes.length&&this._resetTabindices()},_onShiftTabDown:function(e){var t=this.getAttribute("tabindex");__._shiftTabPressed=!0,this._setFocusedItem(null),this.setAttribute("tabindex","-1"),this.async(function(){this.setAttribute("tabindex",t),__._shiftTabPressed=!1},1)},_onFocus:function(e){if(!__._shiftTabPressed){var t=zt(e).rootTarget;t!==this&&typeof t.tabIndex!="undefined"&&!this.isLightDescendant(t)||(this._defaultFocusAsync=this.async(function(){var r=this.multi?this.selectedItems&&this.selectedItems[0]:this.selectedItem;this._setFocusedItem(null),r?this._setFocusedItem(r):this.items[0]&&this._focusNext()}))}},_onUpKey:function(e){this._focusPrevious(),e.detail.keyboardEvent.preventDefault()},_onDownKey:function(e){this._focusNext(),e.detail.keyboardEvent.preventDefault()},_onEscKey:function(e){var t=this.focusedItem;t&&t.blur()},_onKeydown:function(e){this.keyboardEventMatchesKeys(e,"up down esc")||this._focusWithKeyboardEvent(e),e.stopPropagation()},_activateHandler:function(e){wh._activateHandler.call(this,e),e.stopPropagation()},_disabledChanged:function(e){e?(this._previousTabIndex=this.hasAttribute("tabindex")?this.tabIndex:0,this.removeAttribute("tabindex")):this.hasAttribute("tabindex")||this.setAttribute("tabindex",this._previousTabIndex)}};__._shiftTabPressed=!1;var L9=[I0t,Oo,__];Yt({_template:Q`
    <style>
      :host {
        display: block;
        padding: 8px 0;

        background: var(--paper-listbox-background-color, var(--primary-background-color));
        color: var(--paper-listbox-color, var(--primary-text-color));

        @apply --paper-listbox;
      }
    </style>

    <slot></slot>
`,is:"paper-listbox",behaviors:[L9],hostAttributes:{role:"listbox"}});var L0t=Q`
<dom-module id="paper-material-shared-styles">
  <template>
    <style>
      :host {
        display: block;
        position: relative;
      }

      :host([elevation="1"]) {
        @apply --shadow-elevation-2dp;
      }

      :host([elevation="2"]) {
        @apply --shadow-elevation-4dp;
      }

      :host([elevation="3"]) {
        @apply --shadow-elevation-6dp;
      }

      :host([elevation="4"]) {
        @apply --shadow-elevation-8dp;
      }

      :host([elevation="5"]) {
        @apply --shadow-elevation-16dp;
      }
    </style>
  </template>
</dom-module>
`;L0t.setAttribute("style","display: none;");document.body.appendChild(L0t.content);Yt({_template:Q`
    <style include="paper-material-shared-styles"></style>
    <style>
      :host([animated]) {
        @apply --shadow-transition;
      }
      :host {
        @apply --paper-material;
      }
    </style>

    <slot></slot>
`,is:"paper-material",properties:{elevation:{type:Number,reflectToAttribute:!0,value:1},animated:{type:Boolean,reflectToAttribute:!0,value:!1}}});var k9={properties:{value:{type:Number,value:0,notify:!0,reflectToAttribute:!0},min:{type:Number,value:0,notify:!0},max:{type:Number,value:100,notify:!0},step:{type:Number,value:1,notify:!0},ratio:{type:Number,value:0,readOnly:!0,notify:!0}},observers:["_update(value, min, max, step)"],_calcRatio:function(e){return(this._clampValue(e)-this.min)/(this.max-this.min)},_clampValue:function(e){return Math.min(this.max,Math.max(this.min,this._calcStep(e)))},_calcStep:function(e){if(e=parseFloat(e),!this.step)return e;var t=Math.round((e-this.min)/this.step);return this.step<1?t/(1/this.step)+this.min:t*this.step+this.min},_validateValue:function(){var e=this._clampValue(this.value);return this.value=this.oldValue=isNaN(e)?this.oldValue:e,this.value!==e},_update:function(){this._validateValue(),this._setRatio(this._calcRatio(this.value)*100)}};Yt({_template:Q`
    <style>
      :host {
        display: block;
        width: 200px;
        position: relative;
        overflow: hidden;
      }

      :host([hidden]), [hidden] {
        display: none !important;
      }

      #progressContainer {
        @apply --paper-progress-container;
        position: relative;
      }

      #progressContainer,
      /* the stripe for the indeterminate animation*/
      .indeterminate::after {
        height: var(--paper-progress-height, 4px);
      }

      #primaryProgress,
      #secondaryProgress,
      .indeterminate::after {
        @apply --layout-fit;
      }

      #progressContainer,
      .indeterminate::after {
        background: var(--paper-progress-container-color, var(--google-grey-300));
      }

      :host(.transiting) #primaryProgress,
      :host(.transiting) #secondaryProgress {
        -webkit-transition-property: -webkit-transform;
        transition-property: transform;

        /* Duration */
        -webkit-transition-duration: var(--paper-progress-transition-duration, 0.08s);
        transition-duration: var(--paper-progress-transition-duration, 0.08s);

        /* Timing function */
        -webkit-transition-timing-function: var(--paper-progress-transition-timing-function, ease);
        transition-timing-function: var(--paper-progress-transition-timing-function, ease);

        /* Delay */
        -webkit-transition-delay: var(--paper-progress-transition-delay, 0s);
        transition-delay: var(--paper-progress-transition-delay, 0s);
      }

      #primaryProgress,
      #secondaryProgress {
        @apply --layout-fit;
        -webkit-transform-origin: left center;
        transform-origin: left center;
        -webkit-transform: scaleX(0);
        transform: scaleX(0);
        will-change: transform;
      }

      #primaryProgress {
        background: var(--paper-progress-active-color, var(--google-green-500));
      }

      #secondaryProgress {
        background: var(--paper-progress-secondary-color, var(--google-green-100));
      }

      :host([disabled]) #primaryProgress {
        background: var(--paper-progress-disabled-active-color, var(--google-grey-500));
      }

      :host([disabled]) #secondaryProgress {
        background: var(--paper-progress-disabled-secondary-color, var(--google-grey-300));
      }

      :host(:not([disabled])) #primaryProgress.indeterminate {
        -webkit-transform-origin: right center;
        transform-origin: right center;
        -webkit-animation: indeterminate-bar var(--paper-progress-indeterminate-cycle-duration, 2s) linear infinite;
        animation: indeterminate-bar var(--paper-progress-indeterminate-cycle-duration, 2s) linear infinite;
      }

      :host(:not([disabled])) #primaryProgress.indeterminate::after {
        content: "";
        -webkit-transform-origin: center center;
        transform-origin: center center;

        -webkit-animation: indeterminate-splitter var(--paper-progress-indeterminate-cycle-duration, 2s) linear infinite;
        animation: indeterminate-splitter var(--paper-progress-indeterminate-cycle-duration, 2s) linear infinite;
      }

      @-webkit-keyframes indeterminate-bar {
        0% {
          -webkit-transform: scaleX(1) translateX(-100%);
        }
        50% {
          -webkit-transform: scaleX(1) translateX(0%);
        }
        75% {
          -webkit-transform: scaleX(1) translateX(0%);
          -webkit-animation-timing-function: cubic-bezier(.28,.62,.37,.91);
        }
        100% {
          -webkit-transform: scaleX(0) translateX(0%);
        }
      }

      @-webkit-keyframes indeterminate-splitter {
        0% {
          -webkit-transform: scaleX(.75) translateX(-125%);
        }
        30% {
          -webkit-transform: scaleX(.75) translateX(-125%);
          -webkit-animation-timing-function: cubic-bezier(.42,0,.6,.8);
        }
        90% {
          -webkit-transform: scaleX(.75) translateX(125%);
        }
        100% {
          -webkit-transform: scaleX(.75) translateX(125%);
        }
      }

      @keyframes indeterminate-bar {
        0% {
          transform: scaleX(1) translateX(-100%);
        }
        50% {
          transform: scaleX(1) translateX(0%);
        }
        75% {
          transform: scaleX(1) translateX(0%);
          animation-timing-function: cubic-bezier(.28,.62,.37,.91);
        }
        100% {
          transform: scaleX(0) translateX(0%);
        }
      }

      @keyframes indeterminate-splitter {
        0% {
          transform: scaleX(.75) translateX(-125%);
        }
        30% {
          transform: scaleX(.75) translateX(-125%);
          animation-timing-function: cubic-bezier(.42,0,.6,.8);
        }
        90% {
          transform: scaleX(.75) translateX(125%);
        }
        100% {
          transform: scaleX(.75) translateX(125%);
        }
      }
    </style>

    <div id="progressContainer">
      <div id="secondaryProgress" hidden\$="[[_hideSecondaryProgress(secondaryRatio)]]"></div>
      <div id="primaryProgress"></div>
    </div>
`,is:"paper-progress",behaviors:[k9],properties:{secondaryProgress:{type:Number,value:0},secondaryRatio:{type:Number,value:0,readOnly:!0},indeterminate:{type:Boolean,value:!1,observer:"_toggleIndeterminate"},disabled:{type:Boolean,value:!1,reflectToAttribute:!0,observer:"_disabledChanged"}},observers:["_progressChanged(secondaryProgress, value, min, max, indeterminate)"],hostAttributes:{role:"progressbar"},_toggleIndeterminate:function(e){this.toggleClass("indeterminate",e,this.$.primaryProgress)},_transformProgress:function(e,t){var r="scaleX("+t/100+")";e.style.transform=e.style.webkitTransform=r},_mainRatioChanged:function(e){this._transformProgress(this.$.primaryProgress,e)},_progressChanged:function(e,t,r,n,i){e=this._clampValue(e),t=this._clampValue(t);var o=this._calcRatio(e)*100,a=this._calcRatio(t)*100;this._setSecondaryRatio(o),this._transformProgress(this.$.secondaryProgress,o),this._transformProgress(this.$.primaryProgress,a),this.secondaryProgress=e,i?this.removeAttribute("aria-valuenow"):this.setAttribute("aria-valuenow",t),this.setAttribute("aria-valuemin",r),this.setAttribute("aria-valuemax",n)},_disabledChanged:function(e){this.setAttribute("aria-disabled",e?"true":"false")},_hideSecondaryProgress:function(e){return e===0}});var k0t=Q`
<style>
  :host {
    display: inline-block;
    line-height: 0;
    white-space: nowrap;
    cursor: pointer;
    @apply --paper-font-common-base;
    --calculated-paper-radio-button-size: var(--paper-radio-button-size, 16px);
    /* -1px is a sentinel for the default and is replace in \`attached\`. */
    --calculated-paper-radio-button-ink-size: var(--paper-radio-button-ink-size, -1px);
  }

  :host(:focus) {
    outline: none;
  }

  #radioContainer {
    @apply --layout-inline;
    @apply --layout-center-center;
    position: relative;
    width: var(--calculated-paper-radio-button-size);
    height: var(--calculated-paper-radio-button-size);
    vertical-align: middle;

    @apply --paper-radio-button-radio-container;
  }

  #ink {
    position: absolute;
    top: 50%;
    left: 50%;
    right: auto;
    width: var(--calculated-paper-radio-button-ink-size);
    height: var(--calculated-paper-radio-button-ink-size);
    color: var(--paper-radio-button-unchecked-ink-color, var(--primary-text-color));
    opacity: 0.6;
    pointer-events: none;
    -webkit-transform: translate(-50%, -50%);
    transform: translate(-50%, -50%);
  }

  #ink[checked] {
    color: var(--paper-radio-button-checked-ink-color, var(--primary-color));
  }

  #offRadio, #onRadio {
    position: absolute;
    box-sizing: border-box;
    top: 0;
    left: 0;
    width: 100%;
    height: 100%;
    border-radius: 50%;
  }

  #offRadio {
    border: 2px solid var(--paper-radio-button-unchecked-color, var(--primary-text-color));
    background-color: var(--paper-radio-button-unchecked-background-color, transparent);
    transition: border-color 0.28s;
  }

  #onRadio {
    background-color: var(--paper-radio-button-checked-color, var(--primary-color));
    -webkit-transform: scale(0);
    transform: scale(0);
    transition: -webkit-transform ease 0.28s;
    transition: transform ease 0.28s;
    will-change: transform;
  }

  :host([checked]) #offRadio {
    border-color: var(--paper-radio-button-checked-color, var(--primary-color));
  }

  :host([checked]) #onRadio {
    -webkit-transform: scale(0.5);
    transform: scale(0.5);
  }

  #radioLabel {
    line-height: normal;
    position: relative;
    display: inline-block;
    vertical-align: middle;
    margin-left: var(--paper-radio-button-label-spacing, 10px);
    white-space: normal;
    color: var(--paper-radio-button-label-color, var(--primary-text-color));

    @apply --paper-radio-button-label;
  }

  :host([checked]) #radioLabel {
    @apply --paper-radio-button-label-checked;
  }

  #radioLabel:dir(rtl) {
    margin-left: 0;
    margin-right: var(--paper-radio-button-label-spacing, 10px);
  }

  #radioLabel[hidden] {
    display: none;
  }

  /* disabled state */

  :host([disabled]) #offRadio {
    border-color: var(--paper-radio-button-unchecked-color, var(--primary-text-color));
    opacity: 0.5;
  }

  :host([disabled][checked]) #onRadio {
    background-color: var(--paper-radio-button-unchecked-color, var(--primary-text-color));
    opacity: 0.5;
  }

  :host([disabled]) #radioLabel {
    /* slightly darker than the button, so that it's readable */
    opacity: 0.65;
  }
</style>

<div id="radioContainer">
  <div id="offRadio"></div>
  <div id="onRadio"></div>
</div>

<div id="radioLabel"><slot></slot></div>`;k0t.setAttribute("strip-whitespace","");Yt({_template:k0t,is:"paper-radio-button",behaviors:[Xx],hostAttributes:{role:"radio","aria-checked":!1,tabindex:0},properties:{ariaActiveAttribute:{type:String,value:"aria-checked"}},ready:function(){this._rippleContainer=this.$.radioContainer},attached:function(){Tm(this,function(){var e=this.getComputedStyleValue("--calculated-paper-radio-button-ink-size").trim();if(e==="-1px"){var t=parseFloat(this.getComputedStyleValue("--calculated-paper-radio-button-size").trim()),r=Math.floor(3*t);r%2!==t%2&&r++,this.updateStyles({"--paper-radio-button-ink-size":r+"px"})}})}});var R9={hostAttributes:{role:"menubar"},keyBindings:{left:"_onLeftKey",right:"_onRightKey"},_onUpKey:function(e){this.focusedItem.click(),e.detail.keyboardEvent.preventDefault()},_onDownKey:function(e){this.focusedItem.click(),e.detail.keyboardEvent.preventDefault()},get _isRTL(){return window.getComputedStyle(this).direction==="rtl"},_onLeftKey:function(e){this._isRTL?this._focusNext():this._focusPrevious(),e.detail.keyboardEvent.preventDefault()},_onRightKey:function(e){this._isRTL?this._focusPrevious():this._focusNext(),e.detail.keyboardEvent.preventDefault()},_onKeydown:function(e){this.keyboardEventMatchesKeys(e,"up down left right esc")||this._focusWithKeyboardEvent(e)}},N9=[L9,R9];Yt({_template:Q`
    <style>
      :host {
        display: inline-block;
      }

      :host ::slotted(*) {
        padding: var(--paper-radio-group-item-padding, 12px);
      }
    </style>

    <slot></slot>
`,is:"paper-radio-group",behaviors:[N9],hostAttributes:{role:"radiogroup"},properties:{attrForSelected:{type:String,value:"name"},selectedAttribute:{type:String,value:"checked"},selectable:{type:String,value:"paper-radio-button"},allowEmptySelection:{type:Boolean,value:!1}},select:function(e){var t=this._valueToItem(e);if(!(t&&t.hasAttribute("disabled"))){if(this.selected){var r=this._valueToItem(this.selected);if(this.selected==e)if(this.allowEmptySelection)e="";else{r&&(r.checked=!0);return}r&&(r.checked=!1)}wh.select.apply(this,[e]),this.fire("paper-radio-group-changed")}},_activateFocusedItem:function(){this._itemActivate(this._valueForItem(this.focusedItem),this.focusedItem)},_onUpKey:function(e){this._focusPrevious(),e.preventDefault(),this._activateFocusedItem()},_onDownKey:function(e){this._focusNext(),e.preventDefault(),this._activateFocusedItem()},_onLeftKey:function(e){R9._onLeftKey.apply(this,arguments),this._activateFocusedItem()},_onRightKey:function(e){R9._onRightKey.apply(this,arguments),this._activateFocusedItem()}});var R0t=Q`
  <style>
    :host {
      @apply --layout;
      @apply --layout-justified;
      @apply --layout-center;
      width: 200px;
      cursor: default;
      -webkit-user-select: none;
      -moz-user-select: none;
      -ms-user-select: none;
      user-select: none;
      -webkit-tap-highlight-color: rgba(0, 0, 0, 0);
      --paper-progress-active-color: var(--paper-slider-active-color, var(--google-blue-700));
      --paper-progress-secondary-color: var(--paper-slider-secondary-color, var(--google-blue-300));
      --paper-progress-disabled-active-color: var(--paper-slider-disabled-active-color, var(--paper-grey-400));
      --paper-progress-disabled-secondary-color: var(--paper-slider-disabled-secondary-color, var(--paper-grey-400));
      --calculated-paper-slider-height: var(--paper-slider-height, 2px);
    }

    /* focus shows the ripple */
    :host(:focus) {
      outline: none;
    }

    /**
      * NOTE(keanulee): Though :host-context is not universally supported, some pages
      * still rely on paper-slider being flipped when dir="rtl" is set on body. For full
      * compatibility, dir="rtl" must be explicitly set on paper-slider.
      */
    :dir(rtl) #sliderContainer {
      -webkit-transform: scaleX(-1);
      transform: scaleX(-1);
    }

    /**
      * NOTE(keanulee): This is separate from the rule above because :host-context may
      * not be recognized.
      */
    :host([dir="rtl"]) #sliderContainer {
      -webkit-transform: scaleX(-1);
      transform: scaleX(-1);
    }

    /**
      * NOTE(keanulee): Needed to override the :host-context rule (where supported)
      * to support LTR sliders in RTL pages.
      */
    :host([dir="ltr"]) #sliderContainer {
      -webkit-transform: scaleX(1);
      transform: scaleX(1);
    }

    #sliderContainer {
      position: relative;
      width: 100%;
      height: calc(30px + var(--calculated-paper-slider-height));
      margin-left: calc(15px + var(--calculated-paper-slider-height)/2);
      margin-right: calc(15px + var(--calculated-paper-slider-height)/2);
    }

    #sliderContainer:focus {
      outline: 0;
    }

    #sliderContainer.editable {
      margin-top: 12px;
      margin-bottom: 12px;
    }

    .bar-container {
      position: absolute;
      top: 0;
      bottom: 0;
      left: 0;
      right: 0;
      overflow: hidden;
    }

    .ring > .bar-container {
      left: calc(5px + var(--calculated-paper-slider-height)/2);
      transition: left 0.18s ease;
    }

    .ring.expand.dragging > .bar-container {
      transition: none;
    }

    .ring.expand:not(.pin) > .bar-container {
      left: calc(8px + var(--calculated-paper-slider-height)/2);
    }

    #sliderBar {
      padding: 15px 0;
      width: 100%;
      background-color: var(--paper-slider-bar-color, transparent);
      --paper-progress-container-color: var(--paper-slider-container-color, var(--paper-grey-400));
      --paper-progress-height: var(--calculated-paper-slider-height);
    }

    .slider-markers {
      position: absolute;
      /* slider-knob is 30px + the slider-height so that the markers should start at a offset of 15px*/
      top: 15px;
      height: var(--calculated-paper-slider-height);
      left: 0;
      right: -1px;
      box-sizing: border-box;
      pointer-events: none;
      @apply --layout-horizontal;
    }

    .slider-marker {
      @apply --layout-flex;
    }
    .slider-markers::after,
    .slider-marker::after {
      content: "";
      display: block;
      margin-left: -1px;
      width: 2px;
      height: var(--calculated-paper-slider-height);
      border-radius: 50%;
      background-color: var(--paper-slider-markers-color, #000);
    }

    .slider-knob {
      position: absolute;
      left: 0;
      top: 0;
      margin-left: calc(-15px - var(--calculated-paper-slider-height)/2);
      width: calc(30px + var(--calculated-paper-slider-height));
      height: calc(30px + var(--calculated-paper-slider-height));
    }

    .transiting > .slider-knob {
      transition: left 0.08s ease;
    }

    .slider-knob:focus {
      outline: none;
    }

    .slider-knob.dragging {
      transition: none;
    }

    .snaps > .slider-knob.dragging {
      transition: -webkit-transform 0.08s ease;
      transition: transform 0.08s ease;
    }

    .slider-knob-inner {
      margin: 10px;
      width: calc(100% - 20px);
      height: calc(100% - 20px);
      background-color: var(--paper-slider-knob-color, var(--google-blue-700));
      border: 2px solid var(--paper-slider-knob-color, var(--google-blue-700));
      border-radius: 50%;

      -moz-box-sizing: border-box;
      box-sizing: border-box;

      transition-property: -webkit-transform, background-color, border;
      transition-property: transform, background-color, border;
      transition-duration: 0.18s;
      transition-timing-function: ease;
    }

    .expand:not(.pin) > .slider-knob > .slider-knob-inner {
      -webkit-transform: scale(1.5);
      transform: scale(1.5);
    }

    .ring > .slider-knob > .slider-knob-inner {
      background-color: var(--paper-slider-knob-start-color, transparent);
      border: 2px solid var(--paper-slider-knob-start-border-color, var(--paper-grey-400));
    }

    .slider-knob-inner::before {
      background-color: var(--paper-slider-pin-color, var(--google-blue-700));
    }

    .pin > .slider-knob > .slider-knob-inner::before {
      content: "";
      position: absolute;
      top: 0;
      left: 50%;
      margin-left: -13px;
      width: 26px;
      height: 26px;
      border-radius: 50% 50% 50% 0;

      -webkit-transform: rotate(-45deg) scale(0) translate(0);
      transform: rotate(-45deg) scale(0) translate(0);
    }

    .slider-knob-inner::before,
    .slider-knob-inner::after {
      transition: -webkit-transform .18s ease, background-color .18s ease;
      transition: transform .18s ease, background-color .18s ease;
    }

    .pin.ring > .slider-knob > .slider-knob-inner::before {
      background-color: var(--paper-slider-pin-start-color, var(--paper-grey-400));
    }

    .pin.expand > .slider-knob > .slider-knob-inner::before {
      -webkit-transform: rotate(-45deg) scale(1) translate(17px, -17px);
      transform: rotate(-45deg) scale(1) translate(17px, -17px);
    }

    .pin > .slider-knob > .slider-knob-inner::after {
      content: attr(value);
      position: absolute;
      top: 0;
      left: 50%;
      margin-left: -16px;
      width: 32px;
      height: 26px;
      text-align: center;
      color: var(--paper-slider-font-color, #fff);
      font-size: 10px;

      -webkit-transform: scale(0) translate(0);
      transform: scale(0) translate(0);
    }

    .pin.expand > .slider-knob > .slider-knob-inner::after {
      -webkit-transform: scale(1) translate(0, -17px);
      transform: scale(1) translate(0, -17px);
    }

    /* paper-input */
    .slider-input {
      width: 50px;
      overflow: hidden;
      --paper-input-container-input: {
        text-align: center;
        @apply --paper-slider-input-container-input;
      };
      @apply --paper-slider-input;
    }

    /* disabled state */
    #sliderContainer.disabled {
      pointer-events: none;
    }

    .disabled > .slider-knob > .slider-knob-inner {
      background-color: var(--paper-slider-disabled-knob-color, var(--paper-grey-400));
      border: 2px solid var(--paper-slider-disabled-knob-color, var(--paper-grey-400));
      -webkit-transform: scale3d(0.75, 0.75, 1);
      transform: scale3d(0.75, 0.75, 1);
    }

    .disabled.ring > .slider-knob > .slider-knob-inner {
      background-color: var(--paper-slider-knob-start-color, transparent);
      border: 2px solid var(--paper-slider-knob-start-border-color, var(--paper-grey-400));
    }

    paper-ripple {
      color: var(--paper-slider-knob-color, var(--google-blue-700));
    }
  </style>

  <div id="sliderContainer" class\$="[[_getClassNames(disabled, pin, snaps, immediateValue, min, expand, dragging, transiting, editable)]]">
    <div class="bar-container">
      <paper-progress disabled\$="[[disabled]]" id="sliderBar" aria-hidden="true" min="[[min]]" max="[[max]]" step="[[step]]" value="[[immediateValue]]" secondary-progress="[[secondaryProgress]]" on-down="_bardown" on-up="_resetKnob" on-track="_bartrack" on-tap="_barclick">
      </paper-progress>
    </div>

    <template is="dom-if" if="[[snaps]]">
      <div class="slider-markers">
        <template is="dom-repeat" items="[[markers]]">
          <div class="slider-marker"></div>
        </template>
      </div>
    </template>

    <div id="sliderKnob" class="slider-knob" on-down="_knobdown" on-up="_resetKnob" on-track="_onTrack" on-transitionend="_knobTransitionEnd">
        <div class="slider-knob-inner" value\$="[[immediateValue]]"></div>
    </div>
  </div>

  <template is="dom-if" if="[[editable]]">
    <paper-input id="input" type="number" step="[[step]]" min="[[min]]" max="[[max]]" class="slider-input" disabled\$="[[disabled]]" value="[[immediateValue]]" on-change="_changeValue" on-keydown="_inputKeyDown" no-label-float>
    </paper-input>
  </template>
`;R0t.setAttribute("strip-whitespace","");Yt({_template:R0t,is:"paper-slider",behaviors:[Oo,Eh,jx,k9],properties:{value:{type:Number,value:0},snaps:{type:Boolean,value:!1,notify:!0},pin:{type:Boolean,value:!1,notify:!0},secondaryProgress:{type:Number,value:0,notify:!0,observer:"_secondaryProgressChanged"},editable:{type:Boolean,value:!1},immediateValue:{type:Number,value:0,readOnly:!0,notify:!0},maxMarkers:{type:Number,value:0,notify:!0},expand:{type:Boolean,value:!1,readOnly:!0},ignoreBarTouch:{type:Boolean,value:!1},dragging:{type:Boolean,value:!1,readOnly:!0,notify:!0},transiting:{type:Boolean,value:!1,readOnly:!0},markers:{type:Array,readOnly:!0,value:function(){return[]}}},observers:["_updateKnob(value, min, max, snaps, step)","_valueChanged(value)","_immediateValueChanged(immediateValue)","_updateMarkers(maxMarkers, min, max, snaps)"],hostAttributes:{role:"slider",tabindex:0},keyBindings:{left:"_leftKey",right:"_rightKey","down pagedown home":"_decrementKey","up pageup end":"_incrementKey"},ready:function(){this.ignoreBarTouch&&d_(this.$.sliderBar,"auto")},increment:function(){this.value=this._clampValue(this.value+this.step)},decrement:function(){this.value=this._clampValue(this.value-this.step)},_updateKnob:function(e,t,r,n,i){this.setAttribute("aria-valuemin",t),this.setAttribute("aria-valuemax",r),this.setAttribute("aria-valuenow",e),this._positionKnob(this._calcRatio(e)*100)},_valueChanged:function(){this.fire("value-change",{composed:!0})},_immediateValueChanged:function(){this.dragging?this.fire("immediate-value-change",{composed:!0}):this.value=this.immediateValue},_secondaryProgressChanged:function(){this.secondaryProgress=this._clampValue(this.secondaryProgress)},_expandKnob:function(){this._setExpand(!0)},_resetKnob:function(){this.cancelDebouncer("expandKnob"),this._setExpand(!1)},_positionKnob:function(e){this._setImmediateValue(this._calcStep(this._calcKnobPosition(e))),this._setRatio(this._calcRatio(this.immediateValue)*100),this.$.sliderKnob.style.left=this.ratio+"%",this.dragging&&(this._knobstartx=this.ratio*this._w/100,this.translate3d(0,0,0,this.$.sliderKnob))},_calcKnobPosition:function(e){return(this.max-this.min)*e/100+this.min},_onTrack:function(e){switch(e.stopPropagation(),e.detail.state){case"start":this._trackStart(e);break;case"track":this._trackX(e);break;case"end":this._trackEnd();break}},_trackStart:function(e){this._setTransiting(!1),this._w=this.$.sliderBar.offsetWidth,this._x=this.ratio*this._w/100,this._startx=this._x,this._knobstartx=this._startx,this._minx=-this._startx,this._maxx=this._w-this._startx,this.$.sliderKnob.classList.add("dragging"),this._setDragging(!0)},_trackX:function(e){this.dragging||this._trackStart(e);var t=this._isRTL?-1:1,r=Math.min(this._maxx,Math.max(this._minx,e.detail.dx*t));this._x=this._startx+r;var n=this._calcStep(this._calcKnobPosition(this._x/this._w*100));this._setImmediateValue(n);var i=this._calcRatio(this.immediateValue)*this._w-this._knobstartx;this.translate3d(i+"px",0,0,this.$.sliderKnob)},_trackEnd:function(){var e=this.$.sliderKnob.style;this.$.sliderKnob.classList.remove("dragging"),this._setDragging(!1),this._resetKnob(),this.value=this.immediateValue,e.transform=e.webkitTransform="",this.fire("change",{composed:!0})},_knobdown:function(e){this._expandKnob(),e.preventDefault(),this.focus()},_bartrack:function(e){this._allowBarEvent(e)&&this._onTrack(e)},_barclick:function(e){this._w=this.$.sliderBar.offsetWidth;var t=this.$.sliderBar.getBoundingClientRect(),r=(e.detail.x-t.left)/this._w*100;this._isRTL&&(r=100-r);var n=this.ratio;this._setTransiting(!0),this._positionKnob(r),n===this.ratio&&this._setTransiting(!1),this.async(function(){this.fire("change",{composed:!0})}),e.preventDefault(),this.focus()},_bardown:function(e){this._allowBarEvent(e)&&(this.debounce("expandKnob",this._expandKnob,60),this._barclick(e))},_knobTransitionEnd:function(e){e.target===this.$.sliderKnob&&this._setTransiting(!1)},_updateMarkers:function(e,t,r,n){n||this._setMarkers([]);var i=Math.round((r-t)/this.step);i>e&&(i=e),(i<0||!isFinite(i))&&(i=0),this._setMarkers(new Array(i))},_mergeClasses:function(e){return Object.keys(e).filter(function(t){return e[t]}).join(" ")},_getClassNames:function(){return this._mergeClasses({disabled:this.disabled,pin:this.pin,snaps:this.snaps,ring:this.immediateValue<=this.min,expand:this.expand,dragging:this.dragging,transiting:this.transiting,editable:this.editable})},_allowBarEvent:function(e){return!this.ignoreBarTouch||e.detail.sourceEvent instanceof MouseEvent},get _isRTL(){return this.__isRTL===void 0&&(this.__isRTL=window.getComputedStyle(this).direction==="rtl"),this.__isRTL},_leftKey:function(e){this._isRTL?this._incrementKey(e):this._decrementKey(e)},_rightKey:function(e){this._isRTL?this._decrementKey(e):this._incrementKey(e)},_incrementKey:function(e){this.disabled||(e.detail.key==="end"?this.value=this.max:this.increment(),this.fire("change"),e.preventDefault())},_decrementKey:function(e){this.disabled||(e.detail.key==="home"?this.value=this.min:this.decrement(),this.fire("change"),e.preventDefault())},_changeValue:function(e){this.value=e.target.value,this.fire("change",{composed:!0})},_inputKeyDown:function(e){e.stopPropagation()},_createRipple:function(){return this._rippleContainer=this.$.sliderKnob,pE._createRipple.call(this)},_focusedChanged:function(e){e&&this.ensureRipple(),this.hasRipple()&&(e?this._ripple.style.display="":this._ripple.style.display="none",this._ripple.holdDown=e)}});var MW=document.createElement("template");MW.setAttribute("style","display: none;");MW.innerHTML=`<dom-module id="paper-spinner-styles">
  <template>
    <style>
      /*
      /**************************/
      /* STYLES FOR THE SPINNER */
      /**************************/

      /*
       * Constants:
       *      ARCSIZE     = 270 degrees (amount of circle the arc takes up)
       *      ARCTIME     = 1333ms (time it takes to expand and contract arc)
       *      ARCSTARTROT = 216 degrees (how much the start location of the arc
       *                                should rotate each time, 216 gives us a
       *                                5 pointed star shape (it's 360/5 * 3).
       *                                For a 7 pointed star, we might do
       *                                360/7 * 3 = 154.286)
       *      SHRINK_TIME = 400ms
       */

      :host {
        display: inline-block;
        position: relative;
        width: 28px;
        height: 28px;

        /* 360 * ARCTIME / (ARCSTARTROT + (360-ARCSIZE)) */
        --paper-spinner-container-rotation-duration: 1568ms;

        /* ARCTIME */
        --paper-spinner-expand-contract-duration: 1333ms;

        /* 4 * ARCTIME */
        --paper-spinner-full-cycle-duration: 5332ms;

        /* SHRINK_TIME */
        --paper-spinner-cooldown-duration: 400ms;
      }

      #spinnerContainer {
        width: 100%;
        height: 100%;

        /* The spinner does not have any contents that would have to be
         * flipped if the direction changes. Always use ltr so that the
         * style works out correctly in both cases. */
        direction: ltr;
      }

      #spinnerContainer.active {
        -webkit-animation: container-rotate var(--paper-spinner-container-rotation-duration) linear infinite;
        animation: container-rotate var(--paper-spinner-container-rotation-duration) linear infinite;
      }

      @-webkit-keyframes container-rotate {
        to { -webkit-transform: rotate(360deg) }
      }

      @keyframes container-rotate {
        to { transform: rotate(360deg) }
      }

      .spinner-layer {
        position: absolute;
        width: 100%;
        height: 100%;
        opacity: 0;
        white-space: nowrap;
        color: var(--paper-spinner-color, var(--google-blue-500));
      }

      .layer-1 {
        color: var(--paper-spinner-layer-1-color, var(--google-blue-500));
      }

      .layer-2 {
        color: var(--paper-spinner-layer-2-color, var(--google-red-500));
      }

      .layer-3 {
        color: var(--paper-spinner-layer-3-color, var(--google-yellow-500));
      }

      .layer-4 {
        color: var(--paper-spinner-layer-4-color, var(--google-green-500));
      }

      /**
       * IMPORTANT NOTE ABOUT CSS ANIMATION PROPERTIES (keanulee):
       *
       * iOS Safari (tested on iOS 8.1) does not handle animation-delay very well - it doesn't
       * guarantee that the animation will start _exactly_ after that value. So we avoid using
       * animation-delay and instead set custom keyframes for each color (as layer-2undant as it
       * seems).
       */
      .active .spinner-layer {
        -webkit-animation-name: fill-unfill-rotate;
        -webkit-animation-duration: var(--paper-spinner-full-cycle-duration);
        -webkit-animation-timing-function: cubic-bezier(0.4, 0.0, 0.2, 1);
        -webkit-animation-iteration-count: infinite;
        animation-name: fill-unfill-rotate;
        animation-duration: var(--paper-spinner-full-cycle-duration);
        animation-timing-function: cubic-bezier(0.4, 0.0, 0.2, 1);
        animation-iteration-count: infinite;
        opacity: 1;
      }

      .active .spinner-layer.layer-1 {
        -webkit-animation-name: fill-unfill-rotate, layer-1-fade-in-out;
        animation-name: fill-unfill-rotate, layer-1-fade-in-out;
      }

      .active .spinner-layer.layer-2 {
        -webkit-animation-name: fill-unfill-rotate, layer-2-fade-in-out;
        animation-name: fill-unfill-rotate, layer-2-fade-in-out;
      }

      .active .spinner-layer.layer-3 {
        -webkit-animation-name: fill-unfill-rotate, layer-3-fade-in-out;
        animation-name: fill-unfill-rotate, layer-3-fade-in-out;
      }

      .active .spinner-layer.layer-4 {
        -webkit-animation-name: fill-unfill-rotate, layer-4-fade-in-out;
        animation-name: fill-unfill-rotate, layer-4-fade-in-out;
      }

      @-webkit-keyframes fill-unfill-rotate {
        12.5% { -webkit-transform: rotate(135deg) } /* 0.5 * ARCSIZE */
        25%   { -webkit-transform: rotate(270deg) } /* 1   * ARCSIZE */
        37.5% { -webkit-transform: rotate(405deg) } /* 1.5 * ARCSIZE */
        50%   { -webkit-transform: rotate(540deg) } /* 2   * ARCSIZE */
        62.5% { -webkit-transform: rotate(675deg) } /* 2.5 * ARCSIZE */
        75%   { -webkit-transform: rotate(810deg) } /* 3   * ARCSIZE */
        87.5% { -webkit-transform: rotate(945deg) } /* 3.5 * ARCSIZE */
        to    { -webkit-transform: rotate(1080deg) } /* 4   * ARCSIZE */
      }

      @keyframes fill-unfill-rotate {
        12.5% { transform: rotate(135deg) } /* 0.5 * ARCSIZE */
        25%   { transform: rotate(270deg) } /* 1   * ARCSIZE */
        37.5% { transform: rotate(405deg) } /* 1.5 * ARCSIZE */
        50%   { transform: rotate(540deg) } /* 2   * ARCSIZE */
        62.5% { transform: rotate(675deg) } /* 2.5 * ARCSIZE */
        75%   { transform: rotate(810deg) } /* 3   * ARCSIZE */
        87.5% { transform: rotate(945deg) } /* 3.5 * ARCSIZE */
        to    { transform: rotate(1080deg) } /* 4   * ARCSIZE */
      }

      @-webkit-keyframes layer-1-fade-in-out {
        0% { opacity: 1 }
        25% { opacity: 1 }
        26% { opacity: 0 }
        89% { opacity: 0 }
        90% { opacity: 1 }
        to { opacity: 1 }
      }

      @keyframes layer-1-fade-in-out {
        0% { opacity: 1 }
        25% { opacity: 1 }
        26% { opacity: 0 }
        89% { opacity: 0 }
        90% { opacity: 1 }
        to { opacity: 1 }
      }

      @-webkit-keyframes layer-2-fade-in-out {
        0% { opacity: 0 }
        15% { opacity: 0 }
        25% { opacity: 1 }
        50% { opacity: 1 }
        51% { opacity: 0 }
        to { opacity: 0 }
      }

      @keyframes layer-2-fade-in-out {
        0% { opacity: 0 }
        15% { opacity: 0 }
        25% { opacity: 1 }
        50% { opacity: 1 }
        51% { opacity: 0 }
        to { opacity: 0 }
      }

      @-webkit-keyframes layer-3-fade-in-out {
        0% { opacity: 0 }
        40% { opacity: 0 }
        50% { opacity: 1 }
        75% { opacity: 1 }
        76% { opacity: 0 }
        to { opacity: 0 }
      }

      @keyframes layer-3-fade-in-out {
        0% { opacity: 0 }
        40% { opacity: 0 }
        50% { opacity: 1 }
        75% { opacity: 1 }
        76% { opacity: 0 }
        to { opacity: 0 }
      }

      @-webkit-keyframes layer-4-fade-in-out {
        0% { opacity: 0 }
        65% { opacity: 0 }
        75% { opacity: 1 }
        90% { opacity: 1 }
        to { opacity: 0 }
      }

      @keyframes layer-4-fade-in-out {
        0% { opacity: 0 }
        65% { opacity: 0 }
        75% { opacity: 1 }
        90% { opacity: 1 }
        to { opacity: 0 }
      }

      .circle-clipper {
        display: inline-block;
        position: relative;
        width: 50%;
        height: 100%;
        overflow: hidden;
      }

      /**
       * Patch the gap that appear between the two adjacent div.circle-clipper while the
       * spinner is rotating (appears on Chrome 50, Safari 9.1.1, and Edge).
       */
      .spinner-layer::after {
        content: '';
        left: 45%;
        width: 10%;
        border-top-style: solid;
      }

      .spinner-layer::after,
      .circle-clipper .circle {
        box-sizing: border-box;
        position: absolute;
        top: 0;
        border-width: var(--paper-spinner-stroke-width, 3px);
        border-radius: 50%;
      }

      .circle-clipper .circle {
        bottom: 0;
        width: 200%;
        border-style: solid;
        border-bottom-color: transparent !important;
      }

      .circle-clipper.left .circle {
        left: 0;
        border-right-color: transparent !important;
        -webkit-transform: rotate(129deg);
        transform: rotate(129deg);
      }

      .circle-clipper.right .circle {
        left: -100%;
        border-left-color: transparent !important;
        -webkit-transform: rotate(-129deg);
        transform: rotate(-129deg);
      }

      .active .gap-patch::after,
      .active .circle-clipper .circle {
        -webkit-animation-duration: var(--paper-spinner-expand-contract-duration);
        -webkit-animation-timing-function: cubic-bezier(0.4, 0.0, 0.2, 1);
        -webkit-animation-iteration-count: infinite;
        animation-duration: var(--paper-spinner-expand-contract-duration);
        animation-timing-function: cubic-bezier(0.4, 0.0, 0.2, 1);
        animation-iteration-count: infinite;
      }

      .active .circle-clipper.left .circle {
        -webkit-animation-name: left-spin;
        animation-name: left-spin;
      }

      .active .circle-clipper.right .circle {
        -webkit-animation-name: right-spin;
        animation-name: right-spin;
      }

      @-webkit-keyframes left-spin {
        0% { -webkit-transform: rotate(130deg) }
        50% { -webkit-transform: rotate(-5deg) }
        to { -webkit-transform: rotate(130deg) }
      }

      @keyframes left-spin {
        0% { transform: rotate(130deg) }
        50% { transform: rotate(-5deg) }
        to { transform: rotate(130deg) }
      }

      @-webkit-keyframes right-spin {
        0% { -webkit-transform: rotate(-130deg) }
        50% { -webkit-transform: rotate(5deg) }
        to { -webkit-transform: rotate(-130deg) }
      }

      @keyframes right-spin {
        0% { transform: rotate(-130deg) }
        50% { transform: rotate(5deg) }
        to { transform: rotate(-130deg) }
      }

      #spinnerContainer.cooldown {
        -webkit-animation: container-rotate var(--paper-spinner-container-rotation-duration) linear infinite, fade-out var(--paper-spinner-cooldown-duration) cubic-bezier(0.4, 0.0, 0.2, 1);
        animation: container-rotate var(--paper-spinner-container-rotation-duration) linear infinite, fade-out var(--paper-spinner-cooldown-duration) cubic-bezier(0.4, 0.0, 0.2, 1);
      }

      @-webkit-keyframes fade-out {
        0% { opacity: 1 }
        to { opacity: 0 }
      }

      @keyframes fade-out {
        0% { opacity: 1 }
        to { opacity: 0 }
      }
    </style>
  </template>
</dom-module>`;document.head.appendChild(MW.content);var D9={properties:{active:{type:Boolean,value:!1,reflectToAttribute:!0,observer:"__activeChanged"},alt:{type:String,value:"loading",observer:"__altChanged"},__coolingDown:{type:Boolean,value:!1}},__computeContainerClasses:function(e,t){return[e||t?"active":"",t?"cooldown":""].join(" ")},__activeChanged:function(e,t){this.__setAriaHidden(!e),this.__coolingDown=!e&&t},__altChanged:function(e){e==="loading"?this.alt=this.getAttribute("aria-label")||e:(this.__setAriaHidden(e===""),this.setAttribute("aria-label",e))},__setAriaHidden:function(e){var t="aria-hidden";e?this.setAttribute(t,"true"):this.removeAttribute(t)},__reset:function(){this.active=!1,this.__coolingDown=!1}};var N0t=Q`
  <style include="paper-spinner-styles"></style>

  <div id="spinnerContainer" class-name="[[__computeContainerClasses(active, __coolingDown)]]" on-animationend="__reset" on-webkit-animation-end="__reset">
    <div class="spinner-layer layer-1">
      <div class="circle-clipper left">
        <div class="circle"></div>
      </div>
      <div class="circle-clipper right">
        <div class="circle"></div>
      </div>
    </div>

    <div class="spinner-layer layer-2">
      <div class="circle-clipper left">
        <div class="circle"></div>
      </div>
      <div class="circle-clipper right">
        <div class="circle"></div>
      </div>
    </div>

    <div class="spinner-layer layer-3">
      <div class="circle-clipper left">
        <div class="circle"></div>
      </div>
      <div class="circle-clipper right">
        <div class="circle"></div>
      </div>
    </div>

    <div class="spinner-layer layer-4">
      <div class="circle-clipper left">
        <div class="circle"></div>
      </div>
      <div class="circle-clipper right">
        <div class="circle"></div>
      </div>
    </div>
  </div>
`;N0t.setAttribute("strip-whitespace","");Yt({_template:N0t,is:"paper-spinner",behaviors:[D9]});var D0t=Q`
  <style include="paper-spinner-styles"></style>

  <div id="spinnerContainer" class-name="[[__computeContainerClasses(active, __coolingDown)]]" on-animationend="__reset" on-webkit-animation-end="__reset">
    <div class="spinner-layer">
      <div class="circle-clipper left">
        <div class="circle"></div>
      </div>
      <div class="circle-clipper right">
        <div class="circle"></div>
      </div>
    </div>
  </div>
`;D0t.setAttribute("strip-whitespace","");Yt({_template:D0t,is:"paper-spinner-lite",behaviors:[D9]});var jbe=Q`<iron-iconset-svg name="paper-tabs" size="24">
<svg><defs>
<g id="chevron-left"><path d="M15.41 7.41L14 6l-6 6 6 6 1.41-1.41L10.83 12z"></path></g>
<g id="chevron-right"><path d="M10 6L8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z"></path></g>
</defs></svg>
</iron-iconset-svg>`;document.head.appendChild(jbe.content);Yt({_template:Q`
    <style>
      :host {
        @apply --layout-inline;
        @apply --layout-center;
        @apply --layout-center-justified;
        @apply --layout-flex-auto;

        position: relative;
        padding: 0 12px;
        overflow: hidden;
        cursor: pointer;
        vertical-align: middle;

        @apply --paper-font-common-base;
        @apply --paper-tab;
      }

      :host(:focus) {
        outline: none;
      }

      :host([link]) {
        padding: 0;
      }

      .tab-content {
        height: 100%;
        transform: translateZ(0);
          -webkit-transform: translateZ(0);
        transition: opacity 0.1s cubic-bezier(0.4, 0.0, 1, 1);
        @apply --layout-horizontal;
        @apply --layout-center-center;
        @apply --layout-flex-auto;
        @apply --paper-tab-content;
      }

      :host(:not(.iron-selected)) > .tab-content {
        opacity: 0.8;

        @apply --paper-tab-content-unselected;
      }

      :host(:focus) .tab-content {
        opacity: 1;
        font-weight: 700;

        @apply --paper-tab-content-focused;
      }

      paper-ripple {
        color: var(--paper-tab-ink, var(--paper-yellow-a100));
      }

      .tab-content > ::slotted(a) {
        @apply --layout-flex-auto;

        height: 100%;
      }
    </style>

    <div class="tab-content">
      <slot></slot>
    </div>
`,is:"paper-tab",behaviors:[Di,Sh,su],properties:{link:{type:Boolean,value:!1,reflectToAttribute:!0}},hostAttributes:{role:"tab"},listeners:{down:"_updateNoink",tap:"_onTap"},attached:function(){this._updateNoink()},get _parentNoink(){var e=zt(this).parentNode;return!!e&&!!e.noink},_updateNoink:function(){this.noink=!!this.noink||!!this._parentNoink},_onTap:function(e){if(this.link){var t=this.queryEffectiveChildren("a");if(!t||e.target===t)return;t.click()}}});Yt({_template:Q`
    <style>
      :host {
        @apply --layout;
        @apply --layout-center;

        height: 48px;
        font-size: 14px;
        font-weight: 500;
        overflow: hidden;
        -moz-user-select: none;
        -ms-user-select: none;
        -webkit-user-select: none;
        user-select: none;

        /* NOTE: Both values are needed, since some phones require the value to be \`transparent\`. */
        -webkit-tap-highlight-color: rgba(0, 0, 0, 0);
        -webkit-tap-highlight-color: transparent;

        @apply --paper-tabs;
      }

      :host(:dir(rtl)) {
        @apply --layout-horizontal-reverse;
      }

      #tabsContainer {
        position: relative;
        height: 100%;
        white-space: nowrap;
        overflow: hidden;
        @apply --layout-flex-auto;
        @apply --paper-tabs-container;
      }

      #tabsContent {
        height: 100%;
        -moz-flex-basis: auto;
        -ms-flex-basis: auto;
        flex-basis: auto;
        @apply --paper-tabs-content;
      }

      #tabsContent.scrollable {
        position: absolute;
        white-space: nowrap;
      }

      #tabsContent:not(.scrollable),
      #tabsContent.scrollable.fit-container {
        @apply --layout-horizontal;
      }

      #tabsContent.scrollable.fit-container {
        min-width: 100%;
      }

      #tabsContent.scrollable.fit-container > ::slotted(*) {
        /* IE - prevent tabs from compressing when they should scroll. */
        -ms-flex: 1 0 auto;
        -webkit-flex: 1 0 auto;
        flex: 1 0 auto;
      }

      .hidden {
        display: none;
      }

      .not-visible {
        opacity: 0;
        cursor: default;
      }

      paper-icon-button {
        width: 48px;
        height: 48px;
        padding: 12px;
        margin: 0 4px;
      }

      #selectionBar {
        position: absolute;
        height: 0;
        bottom: 0;
        left: 0;
        right: 0;
        border-bottom: 2px solid var(--paper-tabs-selection-bar-color, var(--paper-yellow-a100));
          -webkit-transform: scale(0);
        transform: scale(0);
          -webkit-transform-origin: left center;
        transform-origin: left center;
          transition: -webkit-transform;
        transition: transform;

        @apply --paper-tabs-selection-bar;
      }

      #selectionBar.align-bottom {
        top: 0;
        bottom: auto;
      }

      #selectionBar.expand {
        transition-duration: 0.15s;
        transition-timing-function: cubic-bezier(0.4, 0.0, 1, 1);
      }

      #selectionBar.contract {
        transition-duration: 0.18s;
        transition-timing-function: cubic-bezier(0.0, 0.0, 0.2, 1);
      }

      #tabsContent > ::slotted(:not(#selectionBar)) {
        height: 100%;
      }
    </style>

    <paper-icon-button icon="paper-tabs:chevron-left" class$="[[_computeScrollButtonClass(_leftHidden, scrollable, hideScrollButtons)]]" on-up="_onScrollButtonUp" on-down="_onLeftScrollButtonDown" tabindex="-1"></paper-icon-button>

    <div id="tabsContainer" on-track="_scroll" on-down="_down">
      <div id="tabsContent" class$="[[_computeTabsContentClass(scrollable, fitContainer)]]">
        <div id="selectionBar" class$="[[_computeSelectionBarClass(noBar, alignBottom)]]" on-transitionend="_onBarTransitionEnd"></div>
        <slot></slot>
      </div>
    </div>

    <paper-icon-button icon="paper-tabs:chevron-right" class$="[[_computeScrollButtonClass(_rightHidden, scrollable, hideScrollButtons)]]" on-up="_onScrollButtonUp" on-down="_onRightScrollButtonDown" tabindex="-1"></paper-icon-button>
`,is:"paper-tabs",behaviors:[Js,N9],properties:{noink:{type:Boolean,value:!1,observer:"_noinkChanged"},noBar:{type:Boolean,value:!1},noSlide:{type:Boolean,value:!1},scrollable:{type:Boolean,value:!1},fitContainer:{type:Boolean,value:!1},disableDrag:{type:Boolean,value:!1},hideScrollButtons:{type:Boolean,value:!1},alignBottom:{type:Boolean,value:!1},selectable:{type:String,value:"paper-tab"},autoselect:{type:Boolean,value:!1},autoselectDelay:{type:Number,value:0},_step:{type:Number,value:10},_holdDelay:{type:Number,value:1},_leftHidden:{type:Boolean,value:!1},_rightHidden:{type:Boolean,value:!1},_previousTab:{type:Object}},hostAttributes:{role:"tablist"},listeners:{"iron-resize":"_onTabSizingChanged","iron-items-changed":"_onTabSizingChanged","iron-select":"_onIronSelect","iron-deselect":"_onIronDeselect"},keyBindings:{"left:keyup right:keyup":"_onArrowKeyup"},created:function(){this._holdJob=null,this._pendingActivationItem=void 0,this._pendingActivationTimeout=void 0,this._bindDelayedActivationHandler=this._delayedActivationHandler.bind(this),this.addEventListener("blur",this._onBlurCapture.bind(this),!0)},ready:function(){this.setScrollDirection("y",this.$.tabsContainer)},detached:function(){this._cancelPendingActivation()},_noinkChanged:function(e){var t=zt(this).querySelectorAll("paper-tab");t.forEach(e?this._setNoinkAttribute:this._removeNoinkAttribute)},_setNoinkAttribute:function(e){e.setAttribute("noink","")},_removeNoinkAttribute:function(e){e.removeAttribute("noink")},_computeScrollButtonClass:function(e,t,r){return!t||r?"hidden":e?"not-visible":""},_computeTabsContentClass:function(e,t){return e?"scrollable"+(t?" fit-container":""):" fit-container"},_computeSelectionBarClass:function(e,t){return e?"hidden":t?"align-bottom":""},_onTabSizingChanged:function(){this.debounce("_onTabSizingChanged",function(){this._scroll(),this._tabChanged(this.selectedItem)},10)},_onIronSelect:function(e){this._tabChanged(e.detail.item,this._previousTab),this._previousTab=e.detail.item,this.cancelDebouncer("tab-changed")},_onIronDeselect:function(e){this.debounce("tab-changed",function(){this._tabChanged(null,this._previousTab),this._previousTab=null},1)},_activateHandler:function(){this._cancelPendingActivation(),__._activateHandler.apply(this,arguments)},_scheduleActivation:function(e,t){this._pendingActivationItem=e,this._pendingActivationTimeout=this.async(this._bindDelayedActivationHandler,t)},_delayedActivationHandler:function(){var e=this._pendingActivationItem;this._pendingActivationItem=void 0,this._pendingActivationTimeout=void 0,e.fire(this.activateEvent,null,{bubbles:!0,cancelable:!0})},_cancelPendingActivation:function(){this._pendingActivationTimeout!==void 0&&(this.cancelAsync(this._pendingActivationTimeout),this._pendingActivationItem=void 0,this._pendingActivationTimeout=void 0)},_onArrowKeyup:function(e){this.autoselect&&this._scheduleActivation(this.focusedItem,this.autoselectDelay)},_onBlurCapture:function(e){e.target===this._pendingActivationItem&&this._cancelPendingActivation()},get _tabContainerScrollSize(){return Math.max(0,this.$.tabsContainer.scrollWidth-this.$.tabsContainer.offsetWidth)},_scroll:function(e,t){if(!!this.scrollable){var r=t&&-t.ddx||0;this._affectScroll(r)}},_down:function(e){this.async(function(){this._defaultFocusAsync&&(this.cancelAsync(this._defaultFocusAsync),this._defaultFocusAsync=null)},1)},_affectScroll:function(e){this.$.tabsContainer.scrollLeft+=e;var t=this.$.tabsContainer.scrollLeft;this._leftHidden=t===0,this._rightHidden=t===this._tabContainerScrollSize},_onLeftScrollButtonDown:function(){this._scrollToLeft(),this._holdJob=setInterval(this._scrollToLeft.bind(this),this._holdDelay)},_onRightScrollButtonDown:function(){this._scrollToRight(),this._holdJob=setInterval(this._scrollToRight.bind(this),this._holdDelay)},_onScrollButtonUp:function(){clearInterval(this._holdJob),this._holdJob=null},_scrollToLeft:function(){this._affectScroll(-this._step)},_scrollToRight:function(){this._affectScroll(this._step)},_tabChanged:function(e,t){if(!e){this.$.selectionBar.classList.remove("expand"),this.$.selectionBar.classList.remove("contract"),this._positionBar(0,0);return}var r=this.$.tabsContent.getBoundingClientRect(),n=r.width,i=e.getBoundingClientRect(),o=i.left-r.left;if(this._pos={width:this._calcPercent(i.width,n),left:this._calcPercent(o,n)},this.noSlide||t==null){this.$.selectionBar.classList.remove("expand"),this.$.selectionBar.classList.remove("contract"),this._positionBar(this._pos.width,this._pos.left);return}var a=t.getBoundingClientRect(),s=this.items.indexOf(t),l=this.items.indexOf(e),c=5;this.$.selectionBar.classList.add("expand");var u=s<l,h=this._isRTL;h&&(u=!u),u?this._positionBar(this._calcPercent(i.left+i.width-a.left,n)-c,this._left):this._positionBar(this._calcPercent(a.left+a.width-i.left,n)-c,this._calcPercent(o,n)+c),this.scrollable&&this._scrollToSelectedIfNeeded(i.width,o)},_scrollToSelectedIfNeeded:function(e,t){var r=t-this.$.tabsContainer.scrollLeft;r<0?this.$.tabsContainer.scrollLeft+=r:(r+=e-this.$.tabsContainer.offsetWidth,r>0&&(this.$.tabsContainer.scrollLeft+=r))},_calcPercent:function(e,t){return 100*e/t},_positionBar:function(e,t){e=e||0,t=t||0,this._width=e,this._left=t,this.transform("translateX("+t+"%) scaleX("+e/100+")",this.$.selectionBar)},_onBarTransitionEnd:function(e){var t=this.$.selectionBar.classList;t.contains("expand")?(t.remove("expand"),t.add("contract"),this._positionBar(this._pos.width,this._pos.left)):t.contains("contract")&&t.remove("contract")}});var Jx=null;Yt({_template:Q`
    <style>
      :host {
        display: block;
        position: fixed;
        background-color: var(--paper-toast-background-color, #323232);
        color: var(--paper-toast-color, #f1f1f1);
        min-height: 48px;
        min-width: 288px;
        padding: 16px 24px;
        box-sizing: border-box;
        box-shadow: 0 2px 5px 0 rgba(0, 0, 0, 0.26);
        border-radius: 2px;
        margin: 12px;
        font-size: 14px;
        cursor: default;
        -webkit-transition: -webkit-transform 0.3s, opacity 0.3s;
        transition: transform 0.3s, opacity 0.3s;
        opacity: 0;
        -webkit-transform: translateY(100px);
        transform: translateY(100px);
        @apply --paper-font-common-base;
      }

      :host(.capsule) {
        border-radius: 24px;
      }

      :host(.fit-bottom) {
        width: 100%;
        min-width: 0;
        border-radius: 0;
        margin: 0;
      }

      :host(.paper-toast-open) {
        opacity: 1;
        -webkit-transform: translateY(0px);
        transform: translateY(0px);
      }
    </style>

    <span id="label">{{text}}</span>
    <slot></slot>
`,is:"paper-toast",behaviors:[Kx],properties:{fitInto:{type:Object,value:window,observer:"_onFitIntoChanged"},horizontalAlign:{type:String,value:"left"},verticalAlign:{type:String,value:"bottom"},duration:{type:Number,value:3e3},text:{type:String,value:""},noCancelOnOutsideClick:{type:Boolean,value:!0},noAutoFocus:{type:Boolean,value:!0}},listeners:{transitionend:"__onTransitionEnd"},get visible(){return Da._warn("`visible` is deprecated, use `opened` instead"),this.opened},get _canAutoClose(){return this.duration>0&&this.duration!==1/0},created:function(){this._autoClose=null,ec.requestAvailability()},show:function(e){typeof e=="string"&&(e={text:e});for(var t in e)t.indexOf("_")===0?Da._warn('The property "'+t+'" is private and was not set.'):t in this?this[t]=e[t]:Da._warn('The property "'+t+'" is not valid.');this.open()},hide:function(){this.close()},__onTransitionEnd:function(e){e&&e.target===this&&e.propertyName==="opacity"&&(this.opened?this._finishRenderOpened():this._finishRenderClosed())},_openedChanged:function(){this._autoClose!==null&&(this.cancelAsync(this._autoClose),this._autoClose=null),this.opened?(Jx&&Jx!==this&&Jx.close(),Jx=this,this.fire("iron-announce",{text:this.text}),this._canAutoClose&&(this._autoClose=this.async(this.close,this.duration))):Jx===this&&(Jx=null),Pm._openedChanged.apply(this,arguments)},_renderOpened:function(){this.classList.add("paper-toast-open")},_renderClosed:function(){this.classList.remove("paper-toast-open")},_onFitIntoChanged:function(e){this.positionTarget=e}});var O0t=Q`

    <style>
      :host {
        display: inline-block;
        @apply --layout-horizontal;
        @apply --layout-center;
        @apply --paper-font-common-base;
      }

      :host([disabled]) {
        pointer-events: none;
      }

      :host(:focus) {
        outline:none;
      }

      .toggle-bar {
        position: absolute;
        height: 100%;
        width: 100%;
        border-radius: 8px;
        pointer-events: none;
        opacity: 0.4;
        transition: background-color linear .08s;
        background-color: var(--paper-toggle-button-unchecked-bar-color, #000000);

        @apply --paper-toggle-button-unchecked-bar;
      }

      .toggle-button {
        position: absolute;
        top: -3px;
        left: 0;
        height: 20px;
        width: 20px;
        border-radius: 50%;
        box-shadow: 0 1px 5px 0 rgba(0, 0, 0, 0.6);
        transition: -webkit-transform linear .08s, background-color linear .08s;
        transition: transform linear .08s, background-color linear .08s;
        will-change: transform;
        background-color: var(--paper-toggle-button-unchecked-button-color, var(--paper-grey-50));

        @apply --paper-toggle-button-unchecked-button;
      }

      .toggle-button.dragging {
        -webkit-transition: none;
        transition: none;
      }

      :host([checked]:not([disabled])) .toggle-bar {
        opacity: 0.5;
        background-color: var(--paper-toggle-button-checked-bar-color, var(--primary-color));

        @apply --paper-toggle-button-checked-bar;
      }

      :host([disabled]) .toggle-bar {
        background-color: #000;
        opacity: 0.12;
      }

      :host([checked]) .toggle-button {
        -webkit-transform: translate(16px, 0);
        transform: translate(16px, 0);
      }

      :host([checked]:not([disabled])) .toggle-button {
        background-color: var(--paper-toggle-button-checked-button-color, var(--primary-color));

        @apply --paper-toggle-button-checked-button;
      }

      :host([disabled]) .toggle-button {
        background-color: #bdbdbd;
        opacity: 1;
      }

      .toggle-ink {
        position: absolute;
        top: -14px;
        left: -14px;
        right: auto;
        bottom: auto;
        width: 48px;
        height: 48px;
        opacity: 0.5;
        pointer-events: none;
        color: var(--paper-toggle-button-unchecked-ink-color, var(--primary-text-color));

        @apply --paper-toggle-button-unchecked-ink;
      }

      :host([checked]) .toggle-ink {
        color: var(--paper-toggle-button-checked-ink-color, var(--primary-color));

        @apply --paper-toggle-button-checked-ink;
      }

      .toggle-container {
        display: inline-block;
        position: relative;
        width: 36px;
        height: 14px;
        /* The toggle button has an absolute position of -3px; The extra 1px
        /* accounts for the toggle button shadow box. */
        margin: 4px 1px;
      }

      .toggle-label {
        position: relative;
        display: inline-block;
        vertical-align: middle;
        padding-left: var(--paper-toggle-button-label-spacing, 8px);
        pointer-events: none;
        color: var(--paper-toggle-button-label-color, var(--primary-text-color));
      }

      /* invalid state */
      :host([invalid]) .toggle-bar {
        background-color: var(--paper-toggle-button-invalid-bar-color, var(--error-color));
      }

      :host([invalid]) .toggle-button {
        background-color: var(--paper-toggle-button-invalid-button-color, var(--error-color));
      }

      :host([invalid]) .toggle-ink {
        color: var(--paper-toggle-button-invalid-ink-color, var(--error-color));
      }
    </style>

    <div class="toggle-container">
      <div id="toggleBar" class="toggle-bar"></div>
      <div id="toggleButton" class="toggle-button"></div>
    </div>

    <div class="toggle-label"><slot></slot></div>

  `;O0t.setAttribute("strip-whitespace","");Yt({_template:O0t,is:"paper-toggle-button",behaviors:[Xx],hostAttributes:{role:"button","aria-pressed":"false",tabindex:0},properties:{},listeners:{track:"_ontrack"},attached:function(){Tm(this,function(){d_(this,"pan-y")})},_ontrack:function(e){var t=e.detail;t.state==="start"?this._trackStart(t):t.state==="track"?this._trackMove(t):t.state==="end"&&this._trackEnd(t)},_trackStart:function(e){this._width=this.$.toggleBar.offsetWidth/2,this._trackChecked=this.checked,this.$.toggleButton.classList.add("dragging")},_trackMove:function(e){var t=e.dx;this._x=Math.min(this._width,Math.max(0,this._trackChecked?this._width+t:t)),this.translate3d(this._x+"px",0,0,this.$.toggleButton),this._userActivate(this._x>this._width/2)},_trackEnd:function(e){this.$.toggleButton.classList.remove("dragging"),this.transform("",this.$.toggleButton)},_createRipple:function(){this._rippleContainer=this.$.toggleButton;var e=su._createRipple();return e.id="ink",e.setAttribute("recenters",""),e.classList.add("circle","toggle-ink"),e}});Yt({_template:Q`
    <style>
      :host {
        --calculated-paper-toolbar-height: var(--paper-toolbar-height, 64px);
        --calculated-paper-toolbar-sm-height: var(--paper-toolbar-sm-height, 56px);
        display: block;
        position: relative;
        box-sizing: border-box;
        -moz-box-sizing: border-box;
        height: var(--calculated-paper-toolbar-height);
        background: var(--paper-toolbar-background, var(--primary-color));
        color: var(--paper-toolbar-color, var(--dark-theme-text-color));
        @apply --paper-toolbar;
      }

      :host(.animate) {
        transition: var(--paper-toolbar-transition, height 0.18s ease-in);
      }

      :host(.medium-tall) {
        height: calc(var(--calculated-paper-toolbar-height) * 2);
        @apply --paper-toolbar-medium;
      }

      :host(.tall) {
        height: calc(var(--calculated-paper-toolbar-height) * 3);
        @apply --paper-toolbar-tall;
      }

      .toolbar-tools {
        position: relative;
        height: var(--calculated-paper-toolbar-height);
        padding: 0 16px;
        pointer-events: none;
        @apply --layout-horizontal;
        @apply --layout-center;
        @apply --paper-toolbar-content;
      }

      /*
       * TODO: Where should media query breakpoints live so they can be shared between elements?
       */

      @media (max-width: 600px) {
        :host {
          height: var(--calculated-paper-toolbar-sm-height);
        }

        :host(.medium-tall) {
          height: calc(var(--calculated-paper-toolbar-sm-height) * 2);
        }

        :host(.tall) {
          height: calc(var(--calculated-paper-toolbar-sm-height) * 3);
        }

        .toolbar-tools {
          height: var(--calculated-paper-toolbar-sm-height);
        }
      }

      #topBar {
        position: relative;
      }

      /* middle bar */
      #middleBar {
        position: absolute;
        top: 0;
        right: 0;
        left: 0;
      }

      :host(.tall) #middleBar,
      :host(.medium-tall) #middleBar {
        -webkit-transform: translateY(100%);
        transform: translateY(100%);
      }

      /* bottom bar */
      #bottomBar {
        position: absolute;
        right: 0;
        bottom: 0;
        left: 0;
      }

      /*
       * make elements (e.g. buttons) respond to mouse/touch events
       *
       * \`.toolbar-tools\` disables touch events so multiple toolbars can stack and not
       * absorb events. All children must have pointer events re-enabled to work as
       * expected.
       */
      .toolbar-tools > ::slotted(*:not([disabled])) {
        pointer-events: auto;
      }

      .toolbar-tools > ::slotted(.title) {
        @apply --paper-font-common-base;
        white-space: nowrap;
        overflow: hidden;
        text-overflow: ellipsis;
        font-size: 20px;
        font-weight: 400;
        line-height: 1;
        pointer-events: none;
        @apply --layout-flex;
      }

      .toolbar-tools > ::slotted(.title) {
        margin-left: 56px;
      }

      .toolbar-tools > ::slotted(paper-icon-button + .title) {
        margin-left: 0;
      }

      /**
       * The --paper-toolbar-title mixin is applied here instead of above to
       * fix the issue with margin-left being ignored due to css ordering.
       */
      .toolbar-tools > ::slotted(.title) {
        @apply --paper-toolbar-title;
      }

      .toolbar-tools > ::slotted(paper-icon-button[icon=menu]) {
        margin-right: 24px;
      }

      .toolbar-tools > ::slotted(.fit) {
        position: absolute;
        top: auto;
        right: 0;
        bottom: 0;
        left: 0;
        width: auto;
        margin: 0;
      }

      /* TODO(noms): Until we have a better solution for classes that don't use
       * /deep/ create our own.
       */
      .start-justified {
        @apply --layout-start-justified;
      }

      .center-justified {
        @apply --layout-center-justified;
      }

      .end-justified {
        @apply --layout-end-justified;
      }

      .around-justified {
        @apply --layout-around-justified;
      }

      .justified {
        @apply --layout-justified;
      }
    </style>

    <div id="topBar" class\$="toolbar-tools [[_computeBarExtraClasses(justify)]]">
      <slot name="top"></slot>
    </div>

    <div id="middleBar" class\$="toolbar-tools [[_computeBarExtraClasses(middleJustify)]]">
      <slot name="middle"></slot>
    </div>

    <div id="bottomBar" class\$="toolbar-tools [[_computeBarExtraClasses(bottomJustify)]]">
      <slot name="bottom"></slot>
    </div>
`,is:"paper-toolbar",hostAttributes:{role:"toolbar"},properties:{bottomJustify:{type:String,value:""},justify:{type:String,value:""},middleJustify:{type:String,value:""}},ready:function(){console.warn(this.is,"is deprecated. Please use app-layout instead!")},attached:function(){this._observer=this._observe(this),this._updateAriaLabelledBy()},detached:function(){this._observer&&this._observer.disconnect()},_observe:function(e){var t=new MutationObserver(function(){this._updateAriaLabelledBy()}.bind(this));return t.observe(e,{childList:!0,subtree:!0}),t},_updateAriaLabelledBy:function(){ci();for(var e=[],t=Array.prototype.slice.call(zt(this.root).querySelectorAll("slot")).concat(Array.prototype.slice.call(zt(this.root).querySelectorAll("content"))),r,n=0;r=t[n];n++)for(var i=zt(r).getDistributedNodes(),o,a=0;o=i[a];a++)if(o.classList&&o.classList.contains("title"))if(o.id)e.push(o.id);else{var s="paper-toolbar-label-"+Math.floor(Math.random()*1e4);o.id=s,e.push(s)}e.length>0&&this.setAttribute("aria-labelledby",e.join(" "))},_computeBarExtraClasses:function(e){return e?e+(e==="justified"?"":"-justified"):""}});Yt({_template:Q`
    <style>
      :host {
        display: block;
        position: absolute;
        outline: none;
        z-index: 1002;
        -moz-user-select: none;
        -ms-user-select: none;
        -webkit-user-select: none;
        user-select: none;
        cursor: default;
      }

      #tooltip {
        display: block;
        outline: none;
        @apply --paper-font-common-base;
        font-size: 10px;
        line-height: 1;
        background-color: var(--paper-tooltip-background, #616161);
        color: var(--paper-tooltip-text-color, white);
        padding: 8px;
        border-radius: 2px;
        @apply --paper-tooltip;
      }

      @keyframes keyFrameScaleUp {
        0% {
          transform: scale(0.0);
        }
        100% {
          transform: scale(1.0);
        }
      }

      @keyframes keyFrameScaleDown {
        0% {
          transform: scale(1.0);
        }
        100% {
          transform: scale(0.0);
        }
      }

      @keyframes keyFrameFadeInOpacity {
        0% {
          opacity: 0;
        }
        100% {
          opacity: var(--paper-tooltip-opacity, 0.9);
        }
      }

      @keyframes keyFrameFadeOutOpacity {
        0% {
          opacity: var(--paper-tooltip-opacity, 0.9);
        }
        100% {
          opacity: 0;
        }
      }

      @keyframes keyFrameSlideDownIn {
        0% {
          transform: translateY(-2000px);
          opacity: 0;
        }
        10% {
          opacity: 0.2;
        }
        100% {
          transform: translateY(0);
          opacity: var(--paper-tooltip-opacity, 0.9);
        }
      }

      @keyframes keyFrameSlideDownOut {
        0% {
          transform: translateY(0);
          opacity: var(--paper-tooltip-opacity, 0.9);
        }
        10% {
          opacity: 0.2;
        }
        100% {
          transform: translateY(-2000px);
          opacity: 0;
        }
      }

      .fade-in-animation {
        opacity: 0;
        animation-delay: var(--paper-tooltip-delay-in, 500ms);
        animation-name: keyFrameFadeInOpacity;
        animation-iteration-count: 1;
        animation-timing-function: ease-in;
        animation-duration: var(--paper-tooltip-duration-in, 500ms);
        animation-fill-mode: forwards;
        @apply --paper-tooltip-animation;
      }

      .fade-out-animation {
        opacity: var(--paper-tooltip-opacity, 0.9);
        animation-delay: var(--paper-tooltip-delay-out, 0ms);
        animation-name: keyFrameFadeOutOpacity;
        animation-iteration-count: 1;
        animation-timing-function: ease-in;
        animation-duration: var(--paper-tooltip-duration-out, 500ms);
        animation-fill-mode: forwards;
        @apply --paper-tooltip-animation;
      }

      .scale-up-animation {
        transform: scale(0);
        opacity: var(--paper-tooltip-opacity, 0.9);
        animation-delay: var(--paper-tooltip-delay-in, 500ms);
        animation-name: keyFrameScaleUp;
        animation-iteration-count: 1;
        animation-timing-function: ease-in;
        animation-duration: var(--paper-tooltip-duration-in, 500ms);
        animation-fill-mode: forwards;
        @apply --paper-tooltip-animation;
      }

      .scale-down-animation {
        transform: scale(1);
        opacity: var(--paper-tooltip-opacity, 0.9);
        animation-delay: var(--paper-tooltip-delay-out, 500ms);
        animation-name: keyFrameScaleDown;
        animation-iteration-count: 1;
        animation-timing-function: ease-in;
        animation-duration: var(--paper-tooltip-duration-out, 500ms);
        animation-fill-mode: forwards;
        @apply --paper-tooltip-animation;
      }

      .slide-down-animation {
        transform: translateY(-2000px);
        opacity: 0;
        animation-delay: var(--paper-tooltip-delay-out, 500ms);
        animation-name: keyFrameSlideDownIn;
        animation-iteration-count: 1;
        animation-timing-function: cubic-bezier(0.0, 0.0, 0.2, 1);
        animation-duration: var(--paper-tooltip-duration-out, 500ms);
        animation-fill-mode: forwards;
        @apply --paper-tooltip-animation;
      }

      .slide-down-animation-out {
        transform: translateY(0);
        opacity: var(--paper-tooltip-opacity, 0.9);
        animation-delay: var(--paper-tooltip-delay-out, 500ms);
        animation-name: keyFrameSlideDownOut;
        animation-iteration-count: 1;
        animation-timing-function: cubic-bezier(0.4, 0.0, 1, 1);
        animation-duration: var(--paper-tooltip-duration-out, 500ms);
        animation-fill-mode: forwards;
        @apply --paper-tooltip-animation;
      }

      .cancel-animation {
        animation-delay: -30s !important;
      }

      /* Thanks IE 10. */

      .hidden {
        display: none !important;
      }
    </style>

    <div id="tooltip" class="hidden">
      <slot></slot>
    </div>
`,is:"paper-tooltip",hostAttributes:{role:"tooltip",tabindex:-1},properties:{for:{type:String,observer:"_findTarget"},manualMode:{type:Boolean,value:!1,observer:"_manualModeChanged"},position:{type:String,value:"bottom"},fitToVisibleBounds:{type:Boolean,value:!1},offset:{type:Number,value:14},marginTop:{type:Number,value:14},animationDelay:{type:Number,value:500,observer:"_delayChange"},animationEntry:{type:String,value:""},animationExit:{type:String,value:""},animationConfig:{type:Object,value:function(){return{entry:[{name:"fade-in-animation",node:this,timing:{delay:0}}],exit:[{name:"fade-out-animation",node:this}]}}},_showing:{type:Boolean,value:!1}},listeners:{webkitAnimationEnd:"_onAnimationEnd"},get target(){var e=zt(this).parentNode,t=zt(this).getOwnerRoot(),r;return this.for?r=zt(t).querySelector("#"+this.for):r=e.nodeType==Node.DOCUMENT_FRAGMENT_NODE?t.host:e,r},attached:function(){this._findTarget()},detached:function(){this.manualMode||this._removeListeners()},playAnimation:function(e){e==="entry"?this.show():e==="exit"&&this.hide()},cancelAnimation:function(){this.$.tooltip.classList.add("cancel-animation")},show:function(){if(!this._showing){if(zt(this).textContent.trim()===""){for(var e=!0,t=zt(this).getEffectiveChildNodes(),r=0;r<t.length;r++)if(t[r].textContent.trim()!==""){e=!1;break}if(e)return}this._showing=!0,this.$.tooltip.classList.remove("hidden"),this.$.tooltip.classList.remove("cancel-animation"),this.$.tooltip.classList.remove(this._getAnimationType("exit")),this.updatePosition(),this._animationPlaying=!0,this.$.tooltip.classList.add(this._getAnimationType("entry"))}},hide:function(){if(!!this._showing){if(this._animationPlaying){this._showing=!1,this._cancelAnimation();return}else this._onAnimationFinish();this._showing=!1,this._animationPlaying=!0}},updatePosition:function(){if(!(!this._target||!this.offsetParent)){var e=this.offset;this.marginTop!=14&&this.offset==14&&(e=this.marginTop);var t=this.offsetParent.getBoundingClientRect(),r=this._target.getBoundingClientRect(),n=this.getBoundingClientRect(),i=(r.width-n.width)/2,o=(r.height-n.height)/2,a=r.left-t.left,s=r.top-t.top,l,c;switch(this.position){case"top":l=a+i,c=s-n.height-e;break;case"bottom":l=a+i,c=s+r.height+e;break;case"left":l=a-n.width-e,c=s+o;break;case"right":l=a+r.width+e,c=s+o;break}this.fitToVisibleBounds?(t.left+l+n.width>window.innerWidth?(this.style.right="0px",this.style.left="auto"):(this.style.left=Math.max(0,l)+"px",this.style.right="auto"),t.top+c+n.height>window.innerHeight?(this.style.bottom=t.height-s+e+"px",this.style.top="auto"):(this.style.top=Math.max(-t.top,c)+"px",this.style.bottom="auto")):(this.style.left=l+"px",this.style.top=c+"px")}},_addListeners:function(){this._target&&(this.listen(this._target,"mouseenter","show"),this.listen(this._target,"focus","show"),this.listen(this._target,"mouseleave","hide"),this.listen(this._target,"blur","hide"),this.listen(this._target,"tap","hide")),this.listen(this.$.tooltip,"animationend","_onAnimationEnd"),this.listen(this,"mouseenter","hide")},_findTarget:function(){this.manualMode||this._removeListeners(),this._target=this.target,this.manualMode||this._addListeners()},_delayChange:function(e){e!==500&&this.updateStyles({"--paper-tooltip-delay-in":e+"ms"})},_manualModeChanged:function(){this.manualMode?this._removeListeners():this._addListeners()},_cancelAnimation:function(){this.$.tooltip.classList.remove(this._getAnimationType("entry")),this.$.tooltip.classList.remove(this._getAnimationType("exit")),this.$.tooltip.classList.remove("cancel-animation"),this.$.tooltip.classList.add("hidden")},_onAnimationFinish:function(){this._showing&&(this.$.tooltip.classList.remove(this._getAnimationType("entry")),this.$.tooltip.classList.remove("cancel-animation"),this.$.tooltip.classList.add(this._getAnimationType("exit")))},_onAnimationEnd:function(){this._animationPlaying=!1,this._showing||(this.$.tooltip.classList.remove(this._getAnimationType("exit")),this.$.tooltip.classList.add("hidden"))},_getAnimationType:function(e){if(e==="entry"&&this.animationEntry!=="")return this.animationEntry;if(e==="exit"&&this.animationExit!=="")return this.animationExit;if(this.animationConfig[e]&&typeof this.animationConfig[e][0].name=="string"){if(this.animationConfig[e][0].timing&&this.animationConfig[e][0].timing.delay&&this.animationConfig[e][0].timing.delay!==0){var t=this.animationConfig[e][0].timing.delay;e==="entry"?this.updateStyles({"--paper-tooltip-delay-in":t+"ms"}):e==="exit"&&this.updateStyles({"--paper-tooltip-delay-out":t+"ms"})}return this.animationConfig[e][0].name}},_removeListeners:function(){this._target&&(this.unlisten(this._target,"mouseenter","show"),this.unlisten(this._target,"focus","show"),this.unlisten(this._target,"mouseleave","hide"),this.unlisten(this._target,"blur","hide"),this.unlisten(this._target,"tap","hide")),this.unlisten(this.$.tooltip,"animationend","_onAnimationEnd"),this.unlisten(this,"mouseenter","hide")}});var rb=Ee(Oe(),1);var mE=class{constructor(t){this.listener=t}},EW=new Set,O9=new Set;window.addEventListener("hashchange",()=>{EW.forEach(e=>e.listener())});window.addEventListener("storage",()=>{O9.forEach(e=>e.listener())});function gE(e){let t=new mE(e);return EW.add(t),t}function TW(e){let t=new mE(e);return O9.add(t),t}function CW(){O9.forEach(e=>e.listener())}function AW(e){EW.delete(e)}function PW(e){O9.delete(e)}var kW={};Ks(kW,{getFakeHash:()=>LW,setFakeHash:()=>IW,setUseHash:()=>Xbe,useHash:()=>z9});var z0t=!1;function Xbe(e){z0t=e}function z9(){return z0t}var F0t="";function IW(e){F0t=e}function LW(){return F0t}var Qx="__tab__",RW={};function B0t(){return RW}function H0t(e){RW=e}gE(()=>{RW=eb(tb())});function tb(){return z9()?window.location.hash.slice(1):LW()}function eb(e){let t={};return e.split("&").forEach(n=>{let i=n.split("=");i.length===1?t[Qx]=i[0]:i.length===2&&(t[decodeURIComponent(i[0])]=decodeURIComponent(i[1]))}),t}function F9(e,t=!1){if(z9())if(t){let r=new URL(window.location.href);r.hash=e,window.history.replaceState(window.history.state,"",r.toString())}else window.location.hash=e;else IW(e)}function B9(e){let t="";e[Qx]!==void 0&&(t+=e[Qx]);let r=Object.keys(e).map(n=>[n,e[n]]).filter(n=>n[0]!==Qx).map(n=>encodeURIComponent(n[0])+"="+encodeURIComponent(n[1])).join("&");return r.length>0?t+"&"+r:t}function V0t(e,t=!1){let r=eb(tb());delete r[e],F9(B9(r),t)}var q0t="disambiguator",{get:$be,set:Kbe,getInitializer:y_,getObserver:v_,disposeBinding:Zbe}=vE(e=>e,e=>e),{get:Jbe,set:Qbe,getInitializer:vp,getObserver:xp,disposeBinding:t2e}=vE(e=>e==="true"?!0:e==="false"?!1:void 0,e=>e.toString()),{get:NW,set:DW,getInitializer:_E,getObserver:yE,disposeBinding:e2e}=vE(e=>+e,e=>e.toString()),{get:r2e,set:n2e,getInitializer:OW,getObserver:zW,disposeBinding:i2e}=vE(e=>JSON.parse(atob(e)),e=>btoa(JSON.stringify(e)));function vE(e,t){let r=[],n=[];function i(c,u={}){let{defaultValue:h,useLocalStorage:f=!1}=u,p=f?window.localStorage.getItem(c):eb(tb())[c];return p==null?rb.cloneDeep(h):e(p)}function o(c,u,h={}){let{defaultValue:f,useLocalStorage:p=!1,useLocationReplace:d=!1}=h,g=t(u);if(p)window.localStorage.setItem(c,g),CW();else if(!rb.isEqual(u,i(c,{useLocalStorage:p})))if(rb.isEqual(u,f))V0t(c,d);else{let _=eb(tb());_[c]=g,F9(B9(_),d)}}function a(c,u){let h=Kl({defaultValue:u.defaultValue,polymerProperty:c,useLocalStorage:!1},u);return function(){let f=U0t(this,c),p=()=>{let _=i(f,h),y=this[h.polymerProperty];rb.isEqual(_,y)||(this[h.polymerProperty]=_)},g=(h.useLocalStorage?TW:gE)(()=>p());return h.useLocalStorage?n.push(g):r.push(g),p(),this[h.polymerProperty]}}function s(){r.forEach(c=>AW(c)),n.forEach(c=>PW(c))}function l(c,u){let h=Kl({defaultValue:u.defaultValue,polymerProperty:c,useLocalStorage:!1},u);return function(){let f=U0t(this,c),p=this[h.polymerProperty];o(f,p,h)}}return{get:i,set:o,getInitializer:a,getObserver:l,disposeBinding:s}}function o2e(){let e=new Set(["examplesPath","hideModelPane2","modelName1","modelName2","inferenceAddress1","inferenceAddress2","modelType","modelVersion1","modelVersion2","modelSignature1","modelSignature2","maxExamples","labelVocabPath","multiClass","sequenceExamples","maxClassesToDisplay","samplingOdds","usePredictApi","predictInputTensor","predictOutputTensor"]),t=eb(tb());if(t[Qx]==="whatif"){for(let r of e)if(r in t){let n=t[r];t[`p.whatif.${r}`]=n}}F9(B9(t)),H0t(t)}function U0t(e,t){let r=e[q0t];return(r==null?[t]:[r,t]).join(".")}var xE=class extends mt{constructor(){super(...arguments),this._tagFilter=y_("tagFilter",{defaultValue:"",useLocalStorage:!1,polymerProperty:"_tagFilter"}).call(this),this._tagFilterObserver=v_("tagFilter",{defaultValue:"",useLocalStorage:!1,polymerProperty:"_tagFilter"})}_computeTagFilter(){return this._tagFilter}};xE.template=Q`
    <paper-input
      no-label-float=""
      label="Filter tags (regular expressions supported)"
      value="{{_tagFilter}}"
      class="search-input"
    >
      <iron-icon prefix="" icon="search" slot="prefix"></iron-icon>
    </paper-input>
    <style>
      :host {
        display: block;
        margin: 10px 5px 10px 10px;
      }
    </style>
  `;E([A({type:String,notify:!0,computed:"_computeTagFilter(_tagFilter)"}),w("design:type",String)],xE.prototype,"tagFilter",void 0);E([A({type:String,observer:"_tagFilterObserver"}),w("design:type",String)],xE.prototype,"_tagFilter",void 0);xE=E([yt("tf-tag-filterer")],xE);function _s(e){let{moduleName:t,styleContent:r}=e,n=document.createElement("dom-module"),i=document.createElement("template"),o=[];e.styleDependencies&&e.styleDependencies.forEach(s=>{let l=document.createElement("style");l.setAttribute("include",s),o.push(l)});let a=document.createElement("style");Object.assign(a,{textContent:r}),o.forEach(s=>{i.content.appendChild(s)}),i.content.appendChild(a),n.appendChild(i),n.register(t)}_s({moduleName:"dashboard-style",styleDependencies:["iron-flex"],styleContent:`
      :host {
        --sidebar-vertical-padding: 15px;
        --sidebar-left-padding: 30px;
      }

      [slot='sidebar'] {
        box-sizing: border-box;
        display: flex;
        flex-direction: column;
        height: 100%;
        margin-right: 10px;
        overflow-x: hidden;
        padding: 5px 0;
        text-overflow: ellipsis;
      }

      .settings {
        min-height: 50px;
        overflow-x: hidden;
        overflow-y: auto;
        will-change: transform;
      }

      .runs-selector {
        display: flex;
        flex-grow: 1;
        min-height: 200px;
      }

      tf-runs-selector {
        flex-grow: 1;
        flex-shrink: 1;
        left: var(--sidebar-left-padding);
        max-height: calc(100% - var(--sidebar-vertical-padding) * 2);
        overflow: hidden;
        position: absolute;
        right: 0;
      }

      .search-input {
        margin: 10px 5px 0 10px;
      }

      .sidebar-section {
        border-top: solid 1px var(--tb-ui-border);
        margin-right: 10px;
        padding: var(--sidebar-vertical-padding) 0
          var(--sidebar-vertical-padding) var(--sidebar-left-padding);
        position: relative;
        overflow: hidden;
      }

      .sidebar-section:first-of-type {
        border: none;
      }

      .sidebar-section paper-button {
        margin: 5px;
      }

      .sidebar-section paper-button:first-of-type {
        margin-left: 0 !important;
      }

      .sidebar-section paper-button:last-of-type {
        margin-right: 0 !important;
      }

      .sidebar-section > :first-child {
        margin-top: 0;
        padding-top: 0;
      }

      .sidebar-section > :last-child {
        margin-bottom: 0;
        padding-bottom: 0;
      }

      .sidebar-section h3 {
        color: var(--tb-secondary-text-color);
        display: block;
        font-size: 14px;
        font-weight: normal;
        margin: 10px 0 5px;
        pointer-events: none;
      }

      paper-checkbox {
        --paper-checkbox-checked-color: var(--tb-ui-dark-accent);
        --paper-checkbox-unchecked-color: var(--tb-ui-dark-accent);
        font-size: 15px;
        margin-top: 5px;
      }

      a {
        color: var(--tb-link);
      }

      a:visited {
        color: var(--tb-link-visited);
      }
  `});function _o(e){return class extends e{connectedCallback(){super.connectedCallback(),this._maybeSetDarkMode(),this.observer=new MutationObserver(r=>{r.some(i=>i.attributeName==="class")&&this._maybeSetDarkMode()}),this.observer.observe(document.body,{attributes:!0})}disconnectedCallback(){var r;super.disconnectedCallback(),(r=this.observer)==null||r.disconnect()}_maybeSetDarkMode(){this.classList.toggle("dark-mode",document.body.classList.contains("dark-mode"))}}}_s({moduleName:"scrollbar-style",styleContent:`
    .scrollbar::-webkit-scrollbar-track {
      visibility: hidden;
    }

    .scrollbar::-webkit-scrollbar {
      width: 10px;
    }

    .scrollbar::-webkit-scrollbar-thumb {
      border-radius: 10px;
      -webkit-box-shadow: inset 0 0 2px rgba(0, 0, 0, 0.3);
      background-color: var(--paper-grey-500);
      color: var(--paper-grey-900);
    }
    .scrollbar {
      box-sizing: border-box;
    }
  `});var BW=document.createElement("style");BW.setAttribute("is","custom-style");BW.textContent=`
  :root {
    --tb-orange-weak: #ffa726;
    --tb-orange-strong: #f57c00;
    --tb-orange-dark: #dc7320;
    --tb-grey-darker: #e2e2e2;
    --tb-grey-lighter: #f3f3f3;
    --tb-ui-dark-accent: #757575;
    --tb-ui-light-accent: #e0e0e0;
    --tb-ui-border: var(--paper-grey-300);
    --tb-graph-faded: #e0d4b3;
    --tb-secondary-text-color: var(--paper-grey-800);
    --tb-raised-button-shadow-color: rgba(0, 0, 0, 0.2);
    --primary-background-color: #fff;
    --secondary-background-color: #e9e9e9;
    --tb-layout-background-color: #f5f5f5;
    --tb-link: #1976d2; /* material blue 700. */
    --tb-link-visited: #7b1fa2; /* material purple 700. */
  }

  :root .dark-mode {
    --tb-ui-border: var(--paper-grey-700);
    --tb-ui-dark-accent: var(--paper-grey-400);
    --tb-ui-light-accent: var(--paper-grey-600);
    --tb-secondary-text-color: var(--paper-grey-400);
    --tb-raised-button-shadow-color: rgba(255, 255, 255, 0.5);
    --primary-text-color: #fff;
    --secondary-text-color: var(--paper-grey-400);
    --primary-background-color: #303030;  /* material grey A400. */
    --secondary-background-color: #3a3a3a;
    --tb-layout-background-color: #3a3a3a;
    --tb-link: #42a5f5; /* material blue 400. */
    --tb-link-visited: #ba68c8; /* material purple 300. */
    /* Overrides paper-material */
    --shadow-elevation-2dp_-_box-shadow: 0 2px 2px 0 rgba(255, 255, 255, 0.14),
      0 1px 5px 0 rgba(255, 255, 255, 0.12),
      0 3px 1px -2px rgba(255, 255, 255, 0.2);
  }
`;document.head.appendChild(BW);var HW=class extends _o(mt){};HW.template=Q`
    <div id="sidebar">
      <slot name="sidebar"></slot>
    </div>

    <div id="center">
      <slot name="center" class="scollbar"></slot>
    </div>
    <style include="scrollbar-style"></style>
    <style>
      :host {
        background-color: #f5f5f5;
        display: flex;
        flex-direction: row;
        height: 100%;
      }

      :host(.dark-mode) {
        background-color: var(--secondary-background-color);
      }

      #sidebar {
        flex: 0 0 var(--tf-dashboard-layout-sidebar-basis, 25%);
        height: 100%;
        max-width: var(--tf-dashboard-layout-sidebar-max-width, 350px);
        min-width: var(--tf-dashboard-layout-sidebar-min-width, 270px);
        overflow-y: auto;
        text-overflow: ellipsis;
      }

      #center {
        flex-grow: 1;
        flex-shrink: 1;
        height: 100%;
        overflow: hidden;
      }

      ::slotted([slot='center']) {
        contain: strict;
        height: 100%;
        overflow-x: hidden;
        overflow-y: auto;
        width: 100%;
        will-change: transform;
      }

      .tf-graph-dashboard #center {
        background: #fff;
      }
    </style>
  `;HW=E([yt("tf-dashboard-layout")],HW);var G0t="TF.TensorBoard.PaginatedView.limit",a2e=12,Ah=null,VW=new Set;function UW(e){VW.add(e)}function qW(e){VW.delete(e)}function GW(){return Ah==null&&(Ah=NW(G0t,{useLocalStorage:!0}),(Ah==null||!isFinite(Ah)||Ah<=0)&&(Ah=a2e)),Ah}function s2e(e){if(e!==Math.floor(e))throw new Error(`limit must be an integer, but got: ${e}`);if(e<=0)throw new Error(`limit must be positive, but got: ${e}`);e!==Ah&&(Ah=e,DW(G0t,Ah,{useLocalStorage:!0}),VW.forEach(t=>{t()}))}var nb=class extends mt{updateArrayProp(t,r,n){let i=this.get(t),o=r;if(!Array.isArray(o))throw RangeError(`Expected new value to '${t}' to be an array.`);Array.isArray(i)||(i=[],this.set(t,i));let a=new Set(o.map((c,u)=>n(c,u))),s=0,l=0;for(;s<i.length&&l<o.length;){if(a.has(n(i[s],s)))n(i[s],s)==n(o[l],l)?this.set(`${t}.${s}`,o[l]):this.splice(t,s,0,o[l]);else{this.splice(t,s,1);continue}l++,s++}s<i.length&&this.splice(t,s),l<o.length&&this.push(t,...o.slice(l))}};var Oi=class extends nb{constructor(){super(...arguments),this.as="item",this._contentActive=!0,this._domBootstrapped=!1,this._ctor=null,this._renderedItems=[],this._renderedTemplateInst=new Map,this._lruCachedItems=new Map,this._cacheSize=10,this._getItemKey=t=>JSON.stringify(t),this._isConnected=!1}connectedCallback(){super.connectedCallback(),this._isConnected=!0}setCacheSize(t){this._cacheSize=t}setGetItemKey(t){this._getItemKey=t}updateDom(t){this.updateArrayProp("_renderedItems",t,this._getItemKey)}_ensureTemplatized(){if(!this.isConnected)return!1;if(!this._ctor){let t=this.querySelector("template");this._ctor=tc(t,this,{parentModel:!0,instanceProps:{[this.as]:!0,active:this._contentActive},forwardHostProp:function(r,n){this._renderedTemplateInst.forEach(i=>{i.forwardHostProp(r,n)})}})}return!0}_bootstrapDom(){if(!this._ensureTemplatized()||this._domBootstrapped)return;new MutationObserver(r=>{for(let n of r)if(n.type==="childList")for(let i of Array.from(n.addedNodes))i instanceof Element&&i.setAttribute("slot","items")}).observe(this,{childList:!0}),Array.from(this.children).forEach(r=>{this.removeChild(r)}),this._lruCachedItems.clear(),this._renderedItems.forEach((r,n)=>this._insertItem(r,n)),this._domBootstrapped=!0}_updateActive(){!this._domBootstrapped||Array.from(this._renderedTemplateInst.values()).forEach(t=>{t.notifyPath("active",this._contentActive)})}_updateDom(t){if(!!this._domBootstrapped&&!(t.path=="_renderedItems"||t.path=="_renderedItems.length"))if(t.path==="_renderedItems.splices")t.value.indexSplices.forEach(n=>{let{index:i,addedCount:o,object:a,removed:s}=n;s.forEach(l=>{this._removeItem(l,this.children[i])}),a.slice(i,i+o).forEach((l,c)=>this._insertItem(l,i+c)),this._trimCache()});else{let r=this._getItemKey(t.value);this._renderedTemplateInst.has(r)?this._renderedTemplateInst.get(r).notifyPath(this.as,t.value):console.warn(`Expected '${r}' to exist in the DOM but could not find one.`)}}_insertItem(t,r){if(!this._ensureTemplatized())throw new Error("Expected templatized before inserting an item");let n,i=this._getItemKey(t);if(this._lruCachedItems.has(i))n=this._lruCachedItems.get(i),this._lruCachedItems.delete(i),this._renderedTemplateInst.get(i).notifyPath("active",this._contentActive);else{let o={[this.as]:t,active:this._contentActive},a=new this._ctor(o);n=a.root,this._renderedTemplateInst.set(i,a)}this.children[r]?this.insertBefore(n,this.children[r]):((n.nodeType==Node.DOCUMENT_FRAGMENT_NODE?Array.from(n.children):[n]).forEach(a=>a.setAttribute("slot","items")),this.appendChild(n))}_removeItem(t,r){r.parentNode&&r.parentNode.removeChild(r);let n=this._getItemKey(t);this._lruCachedItems.set(n,r),this._renderedTemplateInst.get(n).notifyPath("active",!1)}_trimCache(){for(;this._lruCachedItems.size>this._cacheSize;){let[t]=this._lruCachedItems.keys();this._lruCachedItems.delete(t),this._renderedTemplateInst.delete(t)}}};E([A({type:String}),w("design:type",Object)],Oi.prototype,"as",void 0);E([A({type:Array}),w("design:type",Array)],Oi.prototype,"items",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Oi.prototype,"_contentActive",void 0);E([A({type:Boolean}),w("design:type",Object)],Oi.prototype,"_domBootstrapped",void 0);E([A({type:Object}),w("design:type",Object)],Oi.prototype,"_ctor",void 0);E([A({type:Array}),w("design:type",Array)],Oi.prototype,"_renderedItems",void 0);E([A({type:Object}),w("design:type",Object)],Oi.prototype,"_renderedTemplateInst",void 0);E([A({type:Object}),w("design:type",Object)],Oi.prototype,"_lruCachedItems",void 0);E([A({type:Number}),w("design:type",Object)],Oi.prototype,"_cacheSize",void 0);E([A({type:Object}),w("design:type",Object)],Oi.prototype,"_getItemKey",void 0);E([A({type:Boolean}),w("design:type",Object)],Oi.prototype,"_isConnected",void 0);E([Bt("_isConnected"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Oi.prototype,"_bootstrapDom",null);E([Bt("_contentActive"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Oi.prototype,"_updateActive",null);E([Bt("_renderedItems.*","_domBootstrapped"),w("design:type",Function),w("design:paramtypes",[Object]),w("design:returntype",void 0)],Oi.prototype,"_updateDom",null);E([Bt("_cacheSize"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Oi.prototype,"_trimCache",null);var hn=class extends Oi{constructor(){super(...arguments),this.disablePagination=!1,this.getCategoryItemKey=t=>JSON.stringify(t),this._limit=12,this._activeIndex=0,this._pageInputRawValue="",this._pageInputFocused=!1}_computeCount(){return this.category.items.length}get _hasMultiple(){return this._count>1}_togglePane(){this.opened=!this.opened}_changeContentActive(t){this._contentActive=t}_onPaneRenderedChanged(t,r){t&&t!==r&&this.$.ifRendered.render()}_computePaneRendered(t){return!(t.metadata.type===Na.SEARCH_RESULTS&&t.name==="")}get _itemsRendered(){return this._paneRendered&&this.opened}_computeIsSearchResults(t){return t===Na.SEARCH_RESULTS}_computeIsInvalidSearchResults(t){return t.type===Na.SEARCH_RESULTS&&!t.validRegex}_computeIsUniversalSearchQuery(t){return t.type===Na.SEARCH_RESULTS&&t.universalRegex}_isCompositeSearch(){let{type:t,compositeSearch:r}=this.category.metadata;return r&&t===Na.SEARCH_RESULTS}ready(){super.ready(),this.opened=this.initialOpened==null?!0:this.initialOpened,this._limitListener=()=>{this.set("_limit",GW())},UW(this._limitListener),this._limitListener()}detached(){qW(this._limitListener)}_updateRenderedItems(){var t=this._itemsRendered,r=this._limit,n=this._activeIndex,i=this.disablePagination;if(!t)return;let o=Math.floor(n/r),a=this.category.items||[],s=i?a:a.slice(o*r,(o+1)*r);this.updateDom(s)}_limitChanged(t){this.setCacheSize(t*2)}_getCategoryItemKeyChanged(){this.setGetItemKey(this.getCategoryItemKey)}get _currentPage(){var t=this._limit,r=this._activeIndex;return Math.floor(r/t)+1}_computePageCount(t,r){return this.category?Math.ceil(this.category.items.length/r):0}get _multiplePagesExist(){var t=this._pageCount,r=this.disablePagination;return!r&&t>1}get _hasPreviousPage(){var t=this._currentPage;return t>1}get _hasNextPage(){var t=this._currentPage,r=this._pageCount;return t<r}_computeInputWidth(t){return`calc(${t.toString().length}em + 20px)`}_setActiveIndex(t){let r=(this.category.items||[]).length-1;t>r&&(t=r),t<0&&(t=0),this.set("_activeIndex",t)}_clampActiveIndex(){this._setActiveIndex(this._activeIndex)}_performPreviousPage(){this._setActiveIndex(this._activeIndex-this._limit)}_performNextPage(){this._setActiveIndex(this._activeIndex+this._limit)}_computePageInputValue(t,r,n){return t?r:n.toString()}_handlePageInputEvent(t){this.set("_pageInputRawValue",t.target.value);let r=Number(t.target.value||NaN);if(isNaN(r))return;let n=Math.max(1,Math.min(r,this._pageCount))-1;this._setActiveIndex(this._limit*n)}_handlePageChangeEvent(){this.set("_pageInputRawValue",this._currentPage.toString())}_handlePageFocusEvent(){this.set("_pageInputRawValue",this._pageInputValue),this.set("_pageInputFocused",!0)}_handlePageBlurEvent(){this.set("_pageInputFocused",!1)}_updatePageInputValue(t){var n;let r=(n=this.shadowRoot)==null?void 0:n.querySelector("#page-input input");r&&(r.value=t)}_updateInputWidth(){this.updateStyles({"--tf-category-paginated-view-page-input-width":this._inputWidth})}};hn.template=Q`
    <template is="dom-if" if="[[_paneRendered]]" id="ifRendered">
      <button class="heading" on-tap="_togglePane" open-button$="[[opened]]">
        <span class="name">
          <template is="dom-if" if="[[_isSearchResults]]">
            <template is="dom-if" if="[[_isCompositeSearch(category)]]">
              <span>Tags matching multiple experiments</span>
              <template is="dom-if" if="[[_isInvalidSearchResults]]">
                <span
                  >&nbsp;<strong>(malformed regular expression)</strong></span
                >
              </template>
            </template>
            <template is="dom-if" if="[[!_isCompositeSearch(category)]]">
              <span class="light">Tags matching /</span>
              <span class="category-name" title$="[[category.name]]"
                >[[category.name]]</span
              >
              <span class="light">/</span>
              <template is="dom-if" if="[[_isUniversalSearchQuery]]">
                <span> (all tags)</span>
              </template>
              <template is="dom-if" if="[[_isInvalidSearchResults]]">
                <span> <strong>(malformed regular expression)</strong></span>
              </template>
            </template>
          </template>
          <template is="dom-if" if="[[!_isSearchResults]]">
            <span class="category-name" title$="[[category.name]]"
              >[[category.name]]</span
            >
          </template>
        </span>
        <span class="count">
          <template is="dom-if" if="[[_hasMultiple]]">
            <span>[[_count]]</span>
          </template>
          <iron-icon icon="expand-more" class="expand-arrow"></iron-icon>
        </span>
      </button>
      <!-- TODO(stephanwlee): investigate further. For some reason,
        transitionend that the iron-collapse relies on sometimes does not
        trigger when rendering a chart with a spinner. A toy example cannot
        reproduce this bug. -->
      <iron-collapse opened="[[opened]]" no-animation="">
        <div class="content">
          <span id="top-of-container"></span>
          <template is="dom-if" if="[[_multiplePagesExist]]">
            <div class="big-page-buttons" style="margin-bottom: 10px;">
              <paper-button
                on-tap="_performPreviousPage"
                disabled$="[[!_hasPreviousPage]]"
                >Previous page</paper-button
              >
              <paper-button
                on-tap="_performNextPage"
                disabled$="[[!_hasNextPage]]"
                >Next page</paper-button
              >
            </div>
          </template>

          <div id="items">
            <slot name="items"></slot>
          </div>
          <template is="dom-if" if="[[_multiplePagesExist]]">
            <div id="controls-container">
              <div style="display: inline-block; padding: 0 5px">
                Page
                <paper-input
                  id="page-input"
                  type="number"
                  no-label-float=""
                  min="1"
                  max="[[_pageCount]]"
                  value="[[_pageInputValue]]"
                  on-input="_handlePageInputEvent"
                  on-change="_handlePageChangeEvent"
                  on-focus="_handlePageFocusEvent"
                  on-blur="_handlePageBlurEvent"
                ></paper-input>
                of [[_pageCount]]
              </div>
            </div>

            <div class="big-page-buttons" style="margin-top: 10px;">
              <paper-button
                on-tap="_performPreviousPage"
                disabled$="[[!_hasPreviousPage]]"
                >Previous page</paper-button
              >
              <paper-button
                on-tap="_performNextPage"
                disabled$="[[!_hasNextPage]]"
                >Next page</paper-button
              >
            </div>
          </template>
        </div>
      </iron-collapse>
    </template>
    <style>
      :host {
        display: block;
        margin: 0 5px 1px 10px;
      }

      :host(:first-of-type) {
        margin-top: 10px;
      }

      :host(:last-of-type) {
        margin-bottom: 20px;
      }

      .heading {
        background-color: var(--primary-background-color);
        border: none;
        color: inherit;
        cursor: pointer;
        width: 100%;
        font-size: 15px;
        line-height: 1;
        box-shadow: 0 1px 5px var(--tb-raised-button-shadow-color);
        padding: 10px 15px;
        display: flex;
        align-items: center;
        justify-content: space-between;
      }

      .heading::-moz-focus-inner {
        padding: 10px 15px;
      }

      [open-button] {
        border-bottom-left-radius: 0 !important;
        border-bottom-right-radius: 0 !important;
      }

      [open-button] .expand-arrow {
        transform: rotateZ(180deg);
      }

      .name {
        display: inline-flex;
        overflow: hidden;
      }

      .light {
        color: var(--paper-grey-500);
      }

      .category-name {
        white-space: pre;
        overflow: hidden;
        text-overflow: ellipsis;
        padding: 2px 0;
      }

      .count {
        margin: 0 5px;
        font-size: 12px;
        color: var(--paper-grey-500);
        display: flex;
        align-items: center;
        flex: none;
      }

      .heading::-moz-focus-inner {
        padding: 10px 15px;
      }

      .content {
        display: flex;
        flex-direction: column;
        background-color: var(--primary-background-color);
        border-bottom-left-radius: 2px;
        border-bottom-right-radius: 2px;
        border-top: none;
        border: 1px solid #dedede;
        padding: 15px;
      }

      .light {
        color: var(--paper-grey-500);
      }

      #controls-container {
        justify-content: center;
        display: flex;
        flex-direction: row;
        flex-grow: 0;
        flex-shrink: 0;
        width: 100%;
      }

      #controls-container paper-button {
        display: inline-block;
      }

      .big-page-buttons {
        display: flex;
      }

      .big-page-buttons paper-button {
        background-color: var(--tb-ui-light-accent);
        color: var(--tb-ui-dark-accent);
        display: inline-block;
        flex-basis: 0;
        flex-grow: 1;
        flex-shrink: 1;
        font-size: 13px;
      }

      .big-page-buttons paper-button[disabled] {
        background: none;
      }

      slot {
        display: flex;
        flex-direction: row;
        flex-wrap: wrap;
      }

      ::slotted([slot='items']) {
        /* Tooltip for descriptions and others break with more strict ones. */
        contain: style;
      }

      #page-input {
        display: inline-block;
        width: var(--tf-category-paginated-view-page-input-width, 100%);
      }
    </style>
  `;E([A({type:Object}),w("design:type",Object)],hn.prototype,"category",void 0);E([A({type:Boolean}),w("design:type",Boolean)],hn.prototype,"initialOpened",void 0);E([A({type:Boolean,notify:!0}),w("design:type",Boolean)],hn.prototype,"opened",void 0);E([A({type:Boolean}),w("design:type",Boolean)],hn.prototype,"disablePagination",void 0);E([A({type:Number,computed:"_computeCount(category.items.*)"}),w("design:type",Number)],hn.prototype,"_count",void 0);E([A({type:Boolean,computed:"_computePaneRendered(category)",observer:"_onPaneRenderedChanged"}),w("design:type",Boolean)],hn.prototype,"_paneRendered",void 0);E([A({type:Boolean,computed:"_computeIsSearchResults(category.metadata.type)"}),w("design:type",Boolean)],hn.prototype,"_isSearchResults",void 0);E([A({type:Boolean,computed:"_computeIsInvalidSearchResults(category.metadata)"}),w("design:type",Boolean)],hn.prototype,"_isInvalidSearchResults",void 0);E([A({type:Boolean,computed:"_computeIsUniversalSearchQuery(category.metadata)"}),w("design:type",Boolean)],hn.prototype,"_isUniversalSearchQuery",void 0);E([A({type:Object,observer:"_getCategoryItemKeyChanged"}),w("design:type",Object)],hn.prototype,"getCategoryItemKey",void 0);E([A({type:Number,observer:"_limitChanged"}),w("design:type",Number)],hn.prototype,"_limit",void 0);E([A({type:Number}),w("design:type",Number)],hn.prototype,"_activeIndex",void 0);E([A({type:Number,computed:"_computePageCount(category.items.*, _limit)"}),w("design:type",Number)],hn.prototype,"_pageCount",void 0);E([A({type:String,computed:"_computeInputWidth(_pageCount)",observer:"_updateInputWidth"}),w("design:type",String)],hn.prototype,"_inputWidth",void 0);E([A({type:String,computed:"_computePageInputValue(_pageInputFocused, _pageInputRawValue, _currentPage)",observer:"_updatePageInputValue"}),w("design:type",String)],hn.prototype,"_pageInputValue",void 0);E([A({type:String}),w("design:type",String)],hn.prototype,"_pageInputRawValue",void 0);E([A({type:Boolean}),w("design:type",Boolean)],hn.prototype,"_pageInputFocused",void 0);E([Rt("_count"),w("design:type",Boolean),w("design:paramtypes",[])],hn.prototype,"_hasMultiple",null);E([Bt("opened"),w("design:type",Function),w("design:paramtypes",[Boolean]),w("design:returntype",void 0)],hn.prototype,"_changeContentActive",null);E([Rt("opened","_paneRendered"),w("design:type",Boolean),w("design:paramtypes",[])],hn.prototype,"_itemsRendered",null);E([Bt("_itemsRendered","category.items.*","_limit","_activeIndex","_pageCount","disablePagination"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],hn.prototype,"_updateRenderedItems",null);E([Rt("_limit","_activeIndex"),w("design:type",Number),w("design:paramtypes",[])],hn.prototype,"_currentPage",null);E([Rt("_pageCount","disablePagination"),w("design:type",Boolean),w("design:paramtypes",[])],hn.prototype,"_multiplePagesExist",null);E([Rt("_currentPage"),w("design:type",Boolean),w("design:paramtypes",[])],hn.prototype,"_hasPreviousPage",null);E([Rt("_currentPage","_pageCount"),w("design:type",Boolean),w("design:paramtypes",[])],hn.prototype,"_hasNextPage",null);E([Bt("category.items.*"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],hn.prototype,"_clampActiveIndex",null);hn=E([yt("tf-category-paginated-view")],hn);var W0t=Ee(Oe(),1);var H9=class{constructor(t){this.listener=t}},bp=class{constructor(){this.requestManager=new Ae(1),this._listeners=new Set,this.initialized=!1}refresh(){return this.load().then(()=>{this.initialized=!0})}addListener(t){let r=new H9(t);return this._listeners.add(r),r}removeListenerByKey(t){this._listeners.delete(t)}emitChange(){this._listeners.forEach(t=>{try{t.listener()}catch(r){}})}};var V9=class extends bp{load(){let t=_e().environment();return this.requestManager.request(t).then(r=>{let n={dataLocation:r.data_location,windowTitle:r.window_title};r.experiment_name!==void 0&&(n.experimentName=r.experiment_name),r.experiment_description!==void 0&&(n.experimentDescription=r.experiment_description),r.creation_time!==void 0&&(n.creationTime=r.creation_time),!W0t.isEqual(this.environment,n)&&(this.environment=n,this.emitChange())})}getDataLocation(){return this.environment?this.environment.dataLocation:""}getWindowTitle(){return this.environment?this.environment.windowTitle:""}getExperimentName(){return this.environment?this.environment.experimentName:""}getExperimentDescription(){return this.environment?this.environment.experimentDescription:""}getCreationTime(){return this.environment?this.environment.creationTime:null}},ib=new V9;var Y0t=Ee(Oe(),1);var U9=class extends bp{constructor(){super(...arguments),this._runs=[]}load(){let t=_e().runs();return this.requestManager.request(t).then(r=>{Y0t.isEqual(this._runs,r)||(this._runs=r,this.emitChange())})}getRuns(){return this._runs.slice()}},wp=new U9;var Vr={};Ks(Vr,{FormatSpecifier:()=>GE,active:()=>Vvt,arc:()=>BSt,area:()=>z8,areaRadial:()=>o$,ascending:()=>oa,autoType:()=>ij,axisBottom:()=>Z9,axisLeft:()=>lb,axisRight:()=>m_t,axisTop:()=>d_t,bisect:()=>ys,bisectLeft:()=>$0t,bisectRight:()=>WW,bisector:()=>ob,blob:()=>D1t,brush:()=>GL,brushSelection:()=>UL,brushX:()=>jvt,brushY:()=>qL,buffer:()=>O1t,chord:()=>$vt,clientPoint:()=>Dm,cluster:()=>Wbt,color:()=>rc,contourDensity:()=>g1t,contours:()=>ZL,create:()=>syt,creator:()=>Rm,cross:()=>q9,csv:()=>F1t,csvFormat:()=>b1t,csvFormatBody:()=>w1t,csvFormatRow:()=>M1t,csvFormatRows:()=>S1t,csvFormatValue:()=>E1t,csvParse:()=>Cb,csvParseRows:()=>x1t,cubehelix:()=>la,curveBasis:()=>W8,curveBasisClosed:()=>QSt,curveBasisOpen:()=>e3t,curveBundle:()=>n3t,curveCardinal:()=>i3t,curveCardinalClosed:()=>o3t,curveCardinalOpen:()=>a3t,curveCatmullRom:()=>l3t,curveCatmullRomClosed:()=>u3t,curveCatmullRomOpen:()=>f3t,curveLinear:()=>Yh,curveLinearClosed:()=>d3t,curveMonotoneX:()=>x3t,curveMonotoneY:()=>b3t,curveNatural:()=>M3t,curveStep:()=>E3t,curveStepAfter:()=>C3t,curveStepBefore:()=>T3t,customEvent:()=>Mp,descending:()=>Z0t,deviation:()=>W9,dispatch:()=>vs,drag:()=>pb,dragDisable:()=>zm,dragEnable:()=>Fm,dsv:()=>oj,dsvFormat:()=>Wm,easeBack:()=>OL,easeBackIn:()=>OY,easeBackInOut:()=>OL,easeBackOut:()=>zY,easeBounce:()=>P_,easeBounceIn:()=>RY,easeBounceInOut:()=>NY,easeBounceOut:()=>P_,easeCircle:()=>NL,easeCircleIn:()=>IY,easeCircleInOut:()=>NL,easeCircleOut:()=>LY,easeCubic:()=>xs,easeCubicIn:()=>xY,easeCubicInOut:()=>xs,easeCubicOut:()=>bY,easeElastic:()=>zL,easeElasticIn:()=>HY,easeElasticInOut:()=>VY,easeElasticOut:()=>zL,easeExp:()=>RL,easeExpIn:()=>AY,easeExpInOut:()=>RL,easeExpOut:()=>PY,easeLinear:()=>_Y,easePoly:()=>LL,easePolyIn:()=>SY,easePolyInOut:()=>LL,easePolyOut:()=>MY,easeQuad:()=>IL,easeQuadIn:()=>yY,easeQuadInOut:()=>IL,easeQuadOut:()=>vY,easeSin:()=>kL,easeSinIn:()=>EY,easeSinInOut:()=>kL,easeSinOut:()=>TY,entries:()=>u1t,event:()=>qt,extent:()=>aa,forceCenter:()=>W1t,forceCollide:()=>uxt,forceLink:()=>fxt,forceManyBody:()=>gxt,forceRadial:()=>_xt,forceSimulation:()=>mxt,forceX:()=>yxt,forceY:()=>vxt,format:()=>xn,formatDefaultLocale:()=>nk,formatLocale:()=>ek,formatPrefix:()=>WE,formatSpecifier:()=>Lp,geoAlbers:()=>Uk,geoAlbersUsa:()=>Lbt,geoArea:()=>Nxt,geoAzimuthalEqualArea:()=>kbt,geoAzimuthalEqualAreaRaw:()=>Gk,geoAzimuthalEquidistant:()=>Rbt,geoAzimuthalEquidistantRaw:()=>Wk,geoBounds:()=>Uxt,geoCentroid:()=>Xxt,geoCircle:()=>Qxt,geoClipAntimeridian:()=>e5,geoClipCircle:()=>Ak,geoClipExtent:()=>rbt,geoClipRectangle:()=>Dp,geoConicConformal:()=>Dbt,geoConicConformalRaw:()=>jj,geoConicEqualArea:()=>W_,geoConicEqualAreaRaw:()=>Wj,geoConicEquidistant:()=>zbt,geoConicEquidistantRaw:()=>Xj,geoContains:()=>cbt,geoDistance:()=>Nb,geoEqualEarth:()=>Fbt,geoEqualEarthRaw:()=>Xk,geoEquirectangular:()=>Obt,geoEquirectangularRaw:()=>j_,geoGnomonic:()=>Bbt,geoGnomonicRaw:()=>$k,geoGraticule:()=>Nk,geoGraticule10:()=>fbt,geoIdentity:()=>Hbt,geoInterpolate:()=>pbt,geoLength:()=>kk,geoMercator:()=>Nbt,geoMercatorRaw:()=>Y_,geoNaturalEarth1:()=>Vbt,geoNaturalEarth1Raw:()=>Kk,geoOrthographic:()=>Ubt,geoOrthographicRaw:()=>Zk,geoPath:()=>Tbt,geoProjection:()=>Si,geoProjectionMutator:()=>l5,geoRotation:()=>wk,geoStereographic:()=>qbt,geoStereographicRaw:()=>Jk,geoStream:()=>vo,geoTransform:()=>Cbt,geoTransverseMercator:()=>Gbt,geoTransverseMercatorRaw:()=>Qk,gray:()=>Syt,hcl:()=>gb,hierarchy:()=>p5,histogram:()=>r_t,hsl:()=>Vm,html:()=>q1t,image:()=>H1t,interpolate:()=>nc,interpolateArray:()=>Dyt,interpolateBasis:()=>lL,interpolateBasisClosed:()=>cL,interpolateBlues:()=>xSt,interpolateBrBG:()=>Qwt,interpolateBuGn:()=>lSt,interpolateBuPu:()=>cSt,interpolateCividis:()=>TSt,interpolateCool:()=>PSt,interpolateCubehelix:()=>Jyt,interpolateCubehelixDefault:()=>CSt,interpolateCubehelixLong:()=>E_,interpolateDate:()=>fL,interpolateDiscrete:()=>Oyt,interpolateGnBu:()=>uSt,interpolateGreens:()=>bSt,interpolateGreys:()=>wSt,interpolateHcl:()=>$yt,interpolateHclLong:()=>Kyt,interpolateHsl:()=>Yyt,interpolateHslLong:()=>jyt,interpolateHue:()=>zyt,interpolateInferno:()=>DSt,interpolateLab:()=>M_,interpolateMagma:()=>NSt,interpolateNumber:()=>zi,interpolateNumberArray:()=>yb,interpolateObject:()=>pL,interpolateOrRd:()=>hSt,interpolateOranges:()=>ESt,interpolatePRGn:()=>tSt,interpolatePiYG:()=>eSt,interpolatePlasma:()=>OSt,interpolatePuBu:()=>pSt,interpolatePuBuGn:()=>fSt,interpolatePuOr:()=>rSt,interpolatePuRd:()=>dSt,interpolatePurples:()=>SSt,interpolateRainbow:()=>ISt,interpolateRdBu:()=>nSt,interpolateRdGy:()=>iSt,interpolateRdPu:()=>mSt,interpolateRdYlBu:()=>oSt,interpolateRdYlGn:()=>aSt,interpolateReds:()=>MSt,interpolateRgb:()=>qm,interpolateRgbBasis:()=>uL,interpolateRgbBasisClosed:()=>Nyt,interpolateRound:()=>dL,interpolateSinebow:()=>LSt,interpolateSpectral:()=>sSt,interpolateString:()=>vb,interpolateTransformCss:()=>_L,interpolateTransformSvg:()=>yL,interpolateTurbo:()=>kSt,interpolateViridis:()=>RSt,interpolateWarm:()=>ASt,interpolateYlGn:()=>_St,interpolateYlGnBu:()=>gSt,interpolateYlOrBr:()=>ySt,interpolateYlOrRd:()=>vSt,interpolateZoom:()=>vL,interrupt:()=>hu,interval:()=>nvt,isoFormat:()=>Fwt,isoParse:()=>Bwt,json:()=>V1t,keys:()=>$L,lab:()=>w_,lch:()=>Eyt,line:()=>vu,lineRadial:()=>i$,linkHorizontal:()=>WSt,linkRadial:()=>jSt,linkVertical:()=>YSt,local:()=>eL,map:()=>Ji,matcher:()=>ub,max:()=>lu,mean:()=>o_t,median:()=>a_t,merge:()=>Im,min:()=>Lm,mouse:()=>zo,namespace:()=>Ph,namespaces:()=>SE,nest:()=>r1t,now:()=>Ap,pack:()=>d2t,packEnclose:()=>e8,packSiblings:()=>u2t,pairs:()=>K0t,partition:()=>m2t,path:()=>bs,permute:()=>s_t,pie:()=>qSt,piecewise:()=>dY,pointRadial:()=>ly,polygonArea:()=>M2t,polygonCentroid:()=>E2t,polygonContains:()=>P2t,polygonHull:()=>A2t,polygonLength:()=>I2t,precisionFixed:()=>ik,precisionPrefix:()=>ok,precisionRound:()=>ak,quadtree:()=>zh,quantile:()=>sa,quantize:()=>Qyt,radialArea:()=>o$,radialLine:()=>i$,randomBates:()=>R2t,randomExponential:()=>N2t,randomIrwinHall:()=>s8,randomLogNormal:()=>k2t,randomNormal:()=>a8,randomUniform:()=>L2t,range:()=>Ir,rgb:()=>cu,ribbon:()=>Jvt,scaleBand:()=>Qm,scaleDiverging:()=>I8,scaleDivergingLog:()=>CX,scaleDivergingPow:()=>L8,scaleDivergingSqrt:()=>qwt,scaleDivergingSymlog:()=>AX,scaleIdentity:()=>u8,scaleImplicit:()=>l8,scaleLinear:()=>On,scaleLog:()=>cc,scaleOrdinal:()=>gu,scalePoint:()=>tg,scalePow:()=>K_,scaleQuantile:()=>eg,scaleQuantize:()=>qb,scaleSequential:()=>T8,scaleSequentialLog:()=>EX,scaleSequentialPow:()=>C8,scaleSequentialQuantile:()=>A8,scaleSequentialSqrt:()=>Uwt,scaleSequentialSymlog:()=>TX,scaleSqrt:()=>Y2t,scaleSymlog:()=>f8,scaleThreshold:()=>p8,scaleTime:()=>Yb,scaleUtc:()=>Vwt,scan:()=>l_t,schemeAccent:()=>Gwt,schemeBlues:()=>KX,schemeBrBG:()=>PX,schemeBuGn:()=>FX,schemeBuPu:()=>BX,schemeCategory10:()=>jb,schemeDark2:()=>Wwt,schemeGnBu:()=>HX,schemeGreens:()=>ZX,schemeGreys:()=>JX,schemeOrRd:()=>VX,schemeOranges:()=>e$,schemePRGn:()=>IX,schemePaired:()=>Ywt,schemePastel1:()=>jwt,schemePastel2:()=>Xwt,schemePiYG:()=>LX,schemePuBu:()=>qX,schemePuBuGn:()=>UX,schemePuOr:()=>kX,schemePuRd:()=>GX,schemePurples:()=>QX,schemeRdBu:()=>RX,schemeRdGy:()=>NX,schemeRdPu:()=>WX,schemeRdYlBu:()=>DX,schemeRdYlGn:()=>OX,schemeReds:()=>t$,schemeSet1:()=>$wt,schemeSet2:()=>Kwt,schemeSet3:()=>Zwt,schemeSpectral:()=>zX,schemeTableau10:()=>Jwt,schemeYlGn:()=>jX,schemeYlGnBu:()=>YX,schemeYlOrBr:()=>XX,schemeYlOrRd:()=>$X,select:()=>Ht,selectAll:()=>Ep,selection:()=>Ih,selector:()=>Nm,selectorAll:()=>cb,set:()=>o1t,shuffle:()=>c_t,stack:()=>A3t,stackOffsetDiverging:()=>I3t,stackOffsetExpand:()=>P3t,stackOffsetNone:()=>xu,stackOffsetSilhouette:()=>L3t,stackOffsetWiggle:()=>k3t,stackOrderAppearance:()=>Z8,stackOrderAscending:()=>J8,stackOrderDescending:()=>R3t,stackOrderInsideOut:()=>N3t,stackOrderNone:()=>bu,stackOrderReverse:()=>D3t,stratify:()=>y2t,style:()=>Sp,sum:()=>u_t,svg:()=>G1t,symbol:()=>ZSt,symbolCircle:()=>k5,symbolCross:()=>B8,symbolDiamond:()=>H8,symbolSquare:()=>U8,symbolStar:()=>V8,symbolTriangle:()=>q8,symbolWye:()=>G8,symbols:()=>KSt,text:()=>D_,thresholdFreedmanDiaconis:()=>n_t,thresholdScott:()=>i_t,thresholdSturges:()=>sb,tickFormat:()=>c8,tickIncrement:()=>x_,tickStep:()=>tl,ticks:()=>ab,timeDay:()=>ty,timeDays:()=>Q2t,timeFormat:()=>M5,timeFormatDefaultLocale:()=>S8,timeFormatLocale:()=>S5,timeFriday:()=>uX,timeFridays:()=>iwt,timeHour:()=>y8,timeHours:()=>Z2t,timeInterval:()=>br,timeMillisecond:()=>Z_,timeMilliseconds:()=>aX,timeMinute:()=>_8,timeMinutes:()=>$2t,timeMonday:()=>ry,timeMondays:()=>twt,timeMonth:()=>v8,timeMonths:()=>swt,timeParse:()=>wX,timeSaturday:()=>hX,timeSaturdays:()=>owt,timeSecond:()=>Q_,timeSeconds:()=>sX,timeSunday:()=>rg,timeSundays:()=>fX,timeThursday:()=>zp,timeThursdays:()=>nwt,timeTuesday:()=>lX,timeTuesdays:()=>ewt,timeWednesday:()=>cX,timeWednesdays:()=>rwt,timeWeek:()=>rg,timeWeeks:()=>fX,timeYear:()=>Gh,timeYears:()=>lwt,timeout:()=>zE,timer:()=>A_,timerFlush:()=>gY,touch:()=>Tp,touches:()=>lyt,transition:()=>PL,transpose:()=>Y9,tree:()=>v2t,treemap:()=>x2t,treemapBinary:()=>b2t,treemapDice:()=>Uh,treemapResquarify:()=>S2t,treemapSlice:()=>Jm,treemapSliceDice:()=>w2t,treemapSquarify:()=>o8,tsv:()=>B1t,tsvFormat:()=>A1t,tsvFormatBody:()=>P1t,tsvFormatRow:()=>L1t,tsvFormatRows:()=>I1t,tsvFormatValue:()=>k1t,tsvParse:()=>Ab,tsvParseRows:()=>C1t,utcDay:()=>ny,utcDays:()=>dwt,utcFormat:()=>ay,utcFriday:()=>gX,utcFridays:()=>vwt,utcHour:()=>b8,utcHours:()=>fwt,utcMillisecond:()=>Z_,utcMilliseconds:()=>aX,utcMinute:()=>x8,utcMinutes:()=>uwt,utcMonday:()=>oy,utcMondays:()=>mwt,utcMonth:()=>w8,utcMonths:()=>wwt,utcParse:()=>E5,utcSaturday:()=>_X,utcSaturdays:()=>xwt,utcSecond:()=>Q_,utcSeconds:()=>sX,utcSunday:()=>ng,utcSundays:()=>yX,utcThursday:()=>Fp,utcThursdays:()=>ywt,utcTuesday:()=>dX,utcTuesdays:()=>gwt,utcWednesday:()=>mX,utcWednesdays:()=>_wt,utcWeek:()=>ng,utcWeeks:()=>yX,utcYear:()=>Wh,utcYears:()=>Swt,values:()=>l1t,variance:()=>G9,version:()=>j0t,voronoi:()=>K3t,window:()=>hb,xml:()=>U1t,zip:()=>h_t,zoom:()=>eR,zoomIdentity:()=>Xh,zoomTransform:()=>i2});var j0t="5.7.0";function oa(e,t){return e<t?-1:e>t?1:e>=t?0:NaN}function ob(e){return e.length===1&&(e=l2e(e)),{left:function(t,r,n,i){for(n==null&&(n=0),i==null&&(i=t.length);n<i;){var o=n+i>>>1;e(t[o],r)<0?n=o+1:i=o}return n},right:function(t,r,n,i){for(n==null&&(n=0),i==null&&(i=t.length);n<i;){var o=n+i>>>1;e(t[o],r)>0?i=o:n=o+1}return n}}}function l2e(e){return function(t,r){return oa(e(t),r)}}var X0t=ob(oa),WW=X0t.right,$0t=X0t.left,ys=WW;function K0t(e,t){t==null&&(t=YW);for(var r=0,n=e.length-1,i=e[0],o=new Array(n<0?0:n);r<n;)o[r]=t(i,i=e[++r]);return o}function YW(e,t){return[e,t]}function q9(e,t,r){var n=e.length,i=t.length,o=new Array(n*i),a,s,l,c;for(r==null&&(r=YW),a=l=0;a<n;++a)for(c=e[a],s=0;s<i;++s,++l)o[l]=r(c,t[s]);return o}function Z0t(e,t){return t<e?-1:t>e?1:t>=e?0:NaN}function Qs(e){return e===null?NaN:+e}function G9(e,t){var r=e.length,n=0,i=-1,o=0,a,s,l=0;if(t==null)for(;++i<r;)isNaN(a=Qs(e[i]))||(s=a-o,o+=s/++n,l+=s*(a-o));else for(;++i<r;)isNaN(a=Qs(t(e[i],i,e)))||(s=a-o,o+=s/++n,l+=s*(a-o));if(n>1)return l/(n-1)}function W9(e,t){var r=G9(e,t);return r&&Math.sqrt(r)}function aa(e,t){var r=e.length,n=-1,i,o,a;if(t==null){for(;++n<r;)if((i=e[n])!=null&&i>=i)for(o=a=i;++n<r;)(i=e[n])!=null&&(o>i&&(o=i),a<i&&(a=i))}else for(;++n<r;)if((i=t(e[n],n,e))!=null&&i>=i)for(o=a=i;++n<r;)(i=t(e[n],n,e))!=null&&(o>i&&(o=i),a<i&&(a=i));return[o,a]}var J0t=Array.prototype,Q0t=J0t.slice,t_t=J0t.map;function bE(e){return function(){return e}}function e_t(e){return e}function Ir(e,t,r){e=+e,t=+t,r=(i=arguments.length)<2?(t=e,e=0,1):i<3?1:+r;for(var n=-1,i=Math.max(0,Math.ceil((t-e)/r))|0,o=new Array(i);++n<i;)o[n]=e+n*r;return o}var jW=Math.sqrt(50),XW=Math.sqrt(10),$W=Math.sqrt(2);function ab(e,t,r){var n,i=-1,o,a,s;if(t=+t,e=+e,r=+r,e===t&&r>0)return[e];if((n=t<e)&&(o=e,e=t,t=o),(s=x_(e,t,r))===0||!isFinite(s))return[];if(s>0)for(e=Math.ceil(e/s),t=Math.floor(t/s),a=new Array(o=Math.ceil(t-e+1));++i<o;)a[i]=(e+i)*s;else for(e=Math.floor(e*s),t=Math.ceil(t*s),a=new Array(o=Math.ceil(e-t+1));++i<o;)a[i]=(e-i)/s;return n&&a.reverse(),a}function x_(e,t,r){var n=(t-e)/Math.max(0,r),i=Math.floor(Math.log(n)/Math.LN10),o=n/Math.pow(10,i);return i>=0?(o>=jW?10:o>=XW?5:o>=$W?2:1)*Math.pow(10,i):-Math.pow(10,-i)/(o>=jW?10:o>=XW?5:o>=$W?2:1)}function tl(e,t,r){var n=Math.abs(t-e)/Math.max(0,r),i=Math.pow(10,Math.floor(Math.log(n)/Math.LN10)),o=n/i;return o>=jW?i*=10:o>=XW?i*=5:o>=$W&&(i*=2),t<e?-i:i}function sb(e){return Math.ceil(Math.log(e.length)/Math.LN2)+1}function r_t(){var e=e_t,t=aa,r=sb;function n(i){var o,a=i.length,s,l=new Array(a);for(o=0;o<a;++o)l[o]=e(i[o],o,i);var c=t(l),u=c[0],h=c[1],f=r(l,u,h);Array.isArray(f)||(f=tl(u,h,f),f=Ir(Math.ceil(u/f)*f,h,f));for(var p=f.length;f[0]<=u;)f.shift(),--p;for(;f[p-1]>h;)f.pop(),--p;var d=new Array(p+1),g;for(o=0;o<=p;++o)g=d[o]=[],g.x0=o>0?f[o-1]:u,g.x1=o<p?f[o]:h;for(o=0;o<a;++o)s=l[o],u<=s&&s<=h&&d[ys(f,s,0,p)].push(i[o]);return d}return n.value=function(i){return arguments.length?(e=typeof i=="function"?i:bE(i),n):e},n.domain=function(i){return arguments.length?(t=typeof i=="function"?i:bE([i[0],i[1]]),n):t},n.thresholds=function(i){return arguments.length?(r=typeof i=="function"?i:Array.isArray(i)?bE(Q0t.call(i)):bE(i),n):r},n}function sa(e,t,r){if(r==null&&(r=Qs),!!(n=e.length)){if((t=+t)<=0||n<2)return+r(e[0],0,e);if(t>=1)return+r(e[n-1],n-1,e);var n,i=(n-1)*t,o=Math.floor(i),a=+r(e[o],o,e),s=+r(e[o+1],o+1,e);return a+(s-a)*(i-o)}}function n_t(e,t,r){return e=t_t.call(e,Qs).sort(oa),Math.ceil((r-t)/(2*(sa(e,.75)-sa(e,.25))*Math.pow(e.length,-1/3)))}function i_t(e,t,r){return Math.ceil((r-t)/(3.5*W9(e)*Math.pow(e.length,-1/3)))}function lu(e,t){var r=e.length,n=-1,i,o;if(t==null){for(;++n<r;)if((i=e[n])!=null&&i>=i)for(o=i;++n<r;)(i=e[n])!=null&&i>o&&(o=i)}else for(;++n<r;)if((i=t(e[n],n,e))!=null&&i>=i)for(o=i;++n<r;)(i=t(e[n],n,e))!=null&&i>o&&(o=i);return o}function o_t(e,t){var r=e.length,n=r,i=-1,o,a=0;if(t==null)for(;++i<r;)isNaN(o=Qs(e[i]))?--n:a+=o;else for(;++i<r;)isNaN(o=Qs(t(e[i],i,e)))?--n:a+=o;if(n)return a/n}function a_t(e,t){var r=e.length,n=-1,i,o=[];if(t==null)for(;++n<r;)isNaN(i=Qs(e[n]))||o.push(i);else for(;++n<r;)isNaN(i=Qs(t(e[n],n,e)))||o.push(i);return sa(o.sort(oa),.5)}function Im(e){for(var t=e.length,r,n=-1,i=0,o,a;++n<t;)i+=e[n].length;for(o=new Array(i);--t>=0;)for(a=e[t],r=a.length;--r>=0;)o[--i]=a[r];return o}function Lm(e,t){var r=e.length,n=-1,i,o;if(t==null){for(;++n<r;)if((i=e[n])!=null&&i>=i)for(o=i;++n<r;)(i=e[n])!=null&&o>i&&(o=i)}else for(;++n<r;)if((i=t(e[n],n,e))!=null&&i>=i)for(o=i;++n<r;)(i=t(e[n],n,e))!=null&&o>i&&(o=i);return o}function s_t(e,t){for(var r=t.length,n=new Array(r);r--;)n[r]=e[t[r]];return n}function l_t(e,t){if(!!(r=e.length)){var r,n=0,i=0,o,a=e[i];for(t==null&&(t=oa);++n<r;)(t(o=e[n],a)<0||t(a,a)!==0)&&(a=o,i=n);if(t(a,a)===0)return i}}function c_t(e,t,r){for(var n=(r==null?e.length:r)-(t=t==null?0:+t),i,o;n;)o=Math.random()*n--|0,i=e[n+t],e[n+t]=e[o+t],e[o+t]=i;return e}function u_t(e,t){var r=e.length,n=-1,i,o=0;if(t==null)for(;++n<r;)(i=+e[n])&&(o+=i);else for(;++n<r;)(i=+t(e[n],n,e))&&(o+=i);return o}function Y9(e){if(!(o=e.length))return[];for(var t=-1,r=Lm(e,c2e),n=new Array(r);++t<r;)for(var i=-1,o,a=n[t]=new Array(o);++i<o;)a[i]=e[i][t];return n}function c2e(e){return e.length}function h_t(){return Y9(arguments)}var j9=Array.prototype.slice;function f_t(e){return e}var X9=1,$9=2,KW=3,wE=4,p_t=1e-6;function u2e(e){return"translate("+(e+.5)+",0)"}function h2e(e){return"translate(0,"+(e+.5)+")"}function f2e(e){return function(t){return+e(t)}}function p2e(e){var t=Math.max(0,e.bandwidth()-1)/2;return e.round()&&(t=Math.round(t)),function(r){return+e(r)+t}}function d2e(){return!this.__axis}function K9(e,t){var r=[],n=null,i=null,o=6,a=6,s=3,l=e===X9||e===wE?-1:1,c=e===wE||e===$9?"x":"y",u=e===X9||e===KW?u2e:h2e;function h(f){var p=n==null?t.ticks?t.ticks.apply(t,r):t.domain():n,d=i==null?t.tickFormat?t.tickFormat.apply(t,r):f_t:i,g=Math.max(o,0)+s,_=t.range(),y=+_[0]+.5,x=+_[_.length-1]+.5,b=(t.bandwidth?p2e:f2e)(t.copy()),S=f.selection?f.selection():f,C=S.selectAll(".domain").data([null]),P=S.selectAll(".tick").data(p,t).order(),k=P.exit(),O=P.enter().append("g").attr("class","tick"),D=P.select("line"),B=P.select("text");C=C.merge(C.enter().insert("path",".tick").attr("class","domain").attr("stroke","currentColor")),P=P.merge(O),D=D.merge(O.append("line").attr("stroke","currentColor").attr(c+"2",l*o)),B=B.merge(O.append("text").attr("fill","currentColor").attr(c,l*g).attr("dy",e===X9?"0em":e===KW?"0.71em":"0.32em")),f!==S&&(C=C.transition(f),P=P.transition(f),D=D.transition(f),B=B.transition(f),k=k.transition(f).attr("opacity",p_t).attr("transform",function(I){return isFinite(I=b(I))?u(I):this.getAttribute("transform")}),O.attr("opacity",p_t).attr("transform",function(I){var L=this.parentNode.__axis;return u(L&&isFinite(L=L(I))?L:b(I))})),k.remove(),C.attr("d",e===wE||e==$9?a?"M"+l*a+","+y+"H0.5V"+x+"H"+l*a:"M0.5,"+y+"V"+x:a?"M"+y+","+l*a+"V0.5H"+x+"V"+l*a:"M"+y+",0.5H"+x),P.attr("opacity",1).attr("transform",function(I){return u(b(I))}),D.attr(c+"2",l*o),B.attr(c,l*g).text(d),S.filter(d2e).attr("fill","none").attr("font-size",10).attr("font-family","sans-serif").attr("text-anchor",e===$9?"start":e===wE?"end":"middle"),S.each(function(){this.__axis=b})}return h.scale=function(f){return arguments.length?(t=f,h):t},h.ticks=function(){return r=j9.call(arguments),h},h.tickArguments=function(f){return arguments.length?(r=f==null?[]:j9.call(f),h):r.slice()},h.tickValues=function(f){return arguments.length?(n=f==null?null:j9.call(f),h):n&&n.slice()},h.tickFormat=function(f){return arguments.length?(i=f,h):i},h.tickSize=function(f){return arguments.length?(o=a=+f,h):o},h.tickSizeInner=function(f){return arguments.length?(o=+f,h):o},h.tickSizeOuter=function(f){return arguments.length?(a=+f,h):a},h.tickPadding=function(f){return arguments.length?(s=+f,h):s},h}function d_t(e){return K9(X9,e)}function m_t(e){return K9($9,e)}function Z9(e){return K9(KW,e)}function lb(e){return K9(wE,e)}km();km();var Q9="http://www.w3.org/1999/xhtml",SE={svg:"http://www.w3.org/2000/svg",xhtml:Q9,xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/"};function Ph(e){var t=e+="",r=t.indexOf(":");return r>=0&&(t=e.slice(0,r))!=="xmlns"&&(e=e.slice(r+1)),SE.hasOwnProperty(t)?{space:SE[t],local:e}:e}function y2e(e){return function(){var t=this.ownerDocument,r=this.namespaceURI;return r===Q9&&t.documentElement.namespaceURI===Q9?t.createElement(e):t.createElementNS(r,e)}}function v2e(e){return function(){return this.ownerDocument.createElementNS(e.space,e.local)}}function Rm(e){var t=Ph(e);return(t.local?v2e:y2e)(t)}function x2e(){}function Nm(e){return e==null?x2e:function(){return this.querySelector(e)}}function v_t(e){typeof e!="function"&&(e=Nm(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=new Array(a),l,c,u=0;u<a;++u)(l=o[u])&&(c=e.call(l,l.__data__,u,o))&&("__data__"in l&&(c.__data__=l.__data__),s[u]=c);return new Nn(n,this._parents)}function b2e(){return[]}function cb(e){return e==null?b2e:function(){return this.querySelectorAll(e)}}function x_t(e){typeof e!="function"&&(e=cb(e));for(var t=this._groups,r=t.length,n=[],i=[],o=0;o<r;++o)for(var a=t[o],s=a.length,l,c=0;c<s;++c)(l=a[c])&&(n.push(e.call(l,l.__data__,c,a)),i.push(l));return new Nn(n,i)}function ub(e){return function(){return this.matches(e)}}function b_t(e){typeof e!="function"&&(e=ub(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=[],l,c=0;c<a;++c)(l=o[c])&&e.call(l,l.__data__,c,o)&&s.push(l);return new Nn(n,this._parents)}function tL(e){return new Array(e.length)}function w_t(){return new Nn(this._enter||this._groups.map(tL),this._parents)}function ME(e,t){this.ownerDocument=e.ownerDocument,this.namespaceURI=e.namespaceURI,this._next=null,this._parent=e,this.__data__=t}ME.prototype={constructor:ME,appendChild:function(e){return this._parent.insertBefore(e,this._next)},insertBefore:function(e,t){return this._parent.insertBefore(e,t)},querySelector:function(e){return this._parent.querySelector(e)},querySelectorAll:function(e){return this._parent.querySelectorAll(e)}};function S_t(e){return function(){return e}}var M_t="$";function w2e(e,t,r,n,i,o){for(var a=0,s,l=t.length,c=o.length;a<c;++a)(s=t[a])?(s.__data__=o[a],n[a]=s):r[a]=new ME(e,o[a]);for(;a<l;++a)(s=t[a])&&(i[a]=s)}function S2e(e,t,r,n,i,o,a){var s,l,c={},u=t.length,h=o.length,f=new Array(u),p;for(s=0;s<u;++s)(l=t[s])&&(f[s]=p=M_t+a.call(l,l.__data__,s,t),p in c?i[s]=l:c[p]=l);for(s=0;s<h;++s)p=M_t+a.call(e,o[s],s,o),(l=c[p])?(n[s]=l,l.__data__=o[s],c[p]=null):r[s]=new ME(e,o[s]);for(s=0;s<u;++s)(l=t[s])&&c[f[s]]===l&&(i[s]=l)}function E_t(e,t){if(!e)return p=new Array(this.size()),c=-1,this.each(function(P){p[++c]=P}),p;var r=t?S2e:w2e,n=this._parents,i=this._groups;typeof e!="function"&&(e=S_t(e));for(var o=i.length,a=new Array(o),s=new Array(o),l=new Array(o),c=0;c<o;++c){var u=n[c],h=i[c],f=h.length,p=e.call(u,u&&u.__data__,c,n),d=p.length,g=s[c]=new Array(d),_=a[c]=new Array(d),y=l[c]=new Array(f);r(u,h,g,_,y,p,t);for(var x=0,b=0,S,C;x<d;++x)if(S=g[x]){for(x>=b&&(b=x+1);!(C=_[b])&&++b<d;);S._next=C||null}}return a=new Nn(a,n),a._enter=s,a._exit=l,a}function T_t(){return new Nn(this._exit||this._groups.map(tL),this._parents)}function C_t(e,t,r){var n=this.enter(),i=this,o=this.exit();return n=typeof e=="function"?e(n):n.append(e+""),t!=null&&(i=t(i)),r==null?o.remove():r(o),n&&i?n.merge(i).order():i}function A_t(e){for(var t=this._groups,r=e._groups,n=t.length,i=r.length,o=Math.min(n,i),a=new Array(n),s=0;s<o;++s)for(var l=t[s],c=r[s],u=l.length,h=a[s]=new Array(u),f,p=0;p<u;++p)(f=l[p]||c[p])&&(h[p]=f);for(;s<n;++s)a[s]=t[s];return new Nn(a,this._parents)}function P_t(){for(var e=this._groups,t=-1,r=e.length;++t<r;)for(var n=e[t],i=n.length-1,o=n[i],a;--i>=0;)(a=n[i])&&(o&&a.compareDocumentPosition(o)^4&&o.parentNode.insertBefore(a,o),o=a);return this}function I_t(e){e||(e=M2e);function t(h,f){return h&&f?e(h.__data__,f.__data__):!h-!f}for(var r=this._groups,n=r.length,i=new Array(n),o=0;o<n;++o){for(var a=r[o],s=a.length,l=i[o]=new Array(s),c,u=0;u<s;++u)(c=a[u])&&(l[u]=c);l.sort(t)}return new Nn(i,this._parents).order()}function M2e(e,t){return e<t?-1:e>t?1:e>=t?0:NaN}function L_t(){var e=arguments[0];return arguments[0]=this,e.apply(null,arguments),this}function k_t(){var e=new Array(this.size()),t=-1;return this.each(function(){e[++t]=this}),e}function R_t(){for(var e=this._groups,t=0,r=e.length;t<r;++t)for(var n=e[t],i=0,o=n.length;i<o;++i){var a=n[i];if(a)return a}return null}function N_t(){var e=0;return this.each(function(){++e}),e}function D_t(){return!this.node()}function O_t(e){for(var t=this._groups,r=0,n=t.length;r<n;++r)for(var i=t[r],o=0,a=i.length,s;o<a;++o)(s=i[o])&&e.call(s,s.__data__,o,i);return this}function E2e(e){return function(){this.removeAttribute(e)}}function T2e(e){return function(){this.removeAttributeNS(e.space,e.local)}}function C2e(e,t){return function(){this.setAttribute(e,t)}}function A2e(e,t){return function(){this.setAttributeNS(e.space,e.local,t)}}function P2e(e,t){return function(){var r=t.apply(this,arguments);r==null?this.removeAttribute(e):this.setAttribute(e,r)}}function I2e(e,t){return function(){var r=t.apply(this,arguments);r==null?this.removeAttributeNS(e.space,e.local):this.setAttributeNS(e.space,e.local,r)}}function z_t(e,t){var r=Ph(e);if(arguments.length<2){var n=this.node();return r.local?n.getAttributeNS(r.space,r.local):n.getAttribute(r)}return this.each((t==null?r.local?T2e:E2e:typeof t=="function"?r.local?I2e:P2e:r.local?A2e:C2e)(r,t))}function hb(e){return e.ownerDocument&&e.ownerDocument.defaultView||e.document&&e||e.defaultView}function L2e(e){return function(){this.style.removeProperty(e)}}function k2e(e,t,r){return function(){this.style.setProperty(e,t,r)}}function R2e(e,t,r){return function(){var n=t.apply(this,arguments);n==null?this.style.removeProperty(e):this.style.setProperty(e,n,r)}}function F_t(e,t,r){return arguments.length>1?this.each((t==null?L2e:typeof t=="function"?R2e:k2e)(e,t,r==null?"":r)):Sp(this.node(),e)}function Sp(e,t){return e.style.getPropertyValue(t)||hb(e).getComputedStyle(e,null).getPropertyValue(t)}function N2e(e){return function(){delete this[e]}}function D2e(e,t){return function(){this[e]=t}}function O2e(e,t){return function(){var r=t.apply(this,arguments);r==null?delete this[e]:this[e]=r}}function B_t(e,t){return arguments.length>1?this.each((t==null?N2e:typeof t=="function"?O2e:D2e)(e,t)):this.node()[e]}function H_t(e){return e.trim().split(/^|\s+/)}function ZW(e){return e.classList||new V_t(e)}function V_t(e){this._node=e,this._names=H_t(e.getAttribute("class")||"")}V_t.prototype={add:function(e){var t=this._names.indexOf(e);t<0&&(this._names.push(e),this._node.setAttribute("class",this._names.join(" ")))},remove:function(e){var t=this._names.indexOf(e);t>=0&&(this._names.splice(t,1),this._node.setAttribute("class",this._names.join(" ")))},contains:function(e){return this._names.indexOf(e)>=0}};function U_t(e,t){for(var r=ZW(e),n=-1,i=t.length;++n<i;)r.add(t[n])}function q_t(e,t){for(var r=ZW(e),n=-1,i=t.length;++n<i;)r.remove(t[n])}function z2e(e){return function(){U_t(this,e)}}function F2e(e){return function(){q_t(this,e)}}function B2e(e,t){return function(){(t.apply(this,arguments)?U_t:q_t)(this,e)}}function G_t(e,t){var r=H_t(e+"");if(arguments.length<2){for(var n=ZW(this.node()),i=-1,o=r.length;++i<o;)if(!n.contains(r[i]))return!1;return!0}return this.each((typeof t=="function"?B2e:t?z2e:F2e)(r,t))}function H2e(){this.textContent=""}function V2e(e){return function(){this.textContent=e}}function U2e(e){return function(){var t=e.apply(this,arguments);this.textContent=t==null?"":t}}function W_t(e){return arguments.length?this.each(e==null?H2e:(typeof e=="function"?U2e:V2e)(e)):this.node().textContent}function q2e(){this.innerHTML=""}function G2e(e){return function(){this.innerHTML=e}}function W2e(e){return function(){var t=e.apply(this,arguments);this.innerHTML=t==null?"":t}}function Y_t(e){return arguments.length?this.each(e==null?q2e:(typeof e=="function"?W2e:G2e)(e)):this.node().innerHTML}function Y2e(){this.nextSibling&&this.parentNode.appendChild(this)}function j_t(){return this.each(Y2e)}function j2e(){this.previousSibling&&this.parentNode.insertBefore(this,this.parentNode.firstChild)}function X_t(){return this.each(j2e)}function $_t(e){var t=typeof e=="function"?e:Rm(e);return this.select(function(){return this.appendChild(t.apply(this,arguments))})}function X2e(){return null}function K_t(e,t){var r=typeof e=="function"?e:Rm(e),n=t==null?X2e:typeof t=="function"?t:Nm(t);return this.select(function(){return this.insertBefore(r.apply(this,arguments),n.apply(this,arguments)||null)})}function $2e(){var e=this.parentNode;e&&e.removeChild(this)}function Z_t(){return this.each($2e)}function K2e(){var e=this.cloneNode(!1),t=this.parentNode;return t?t.insertBefore(e,this.nextSibling):e}function Z2e(){var e=this.cloneNode(!0),t=this.parentNode;return t?t.insertBefore(e,this.nextSibling):e}function J_t(e){return this.select(e?Z2e:K2e)}function Q_t(e){return arguments.length?this.property("__data__",e):this.node().__data__}var eyt={},qt=null;typeof document!="undefined"&&(tyt=document.documentElement,"onmouseenter"in tyt||(eyt={mouseenter:"mouseover",mouseleave:"mouseout"}));var tyt;function J2e(e,t,r){return e=ryt(e,t,r),function(n){var i=n.relatedTarget;(!i||i!==this&&!(i.compareDocumentPosition(this)&8))&&e.call(this,n)}}function ryt(e,t,r){return function(n){var i=qt;qt=n;try{e.call(this,this.__data__,t,r)}finally{qt=i}}}function Q2e(e){return e.trim().split(/^|\s+/).map(function(t){var r="",n=t.indexOf(".");return n>=0&&(r=t.slice(n+1),t=t.slice(0,n)),{type:t,name:r}})}function twe(e){return function(){var t=this.__on;if(!!t){for(var r=0,n=-1,i=t.length,o;r<i;++r)o=t[r],(!e.type||o.type===e.type)&&o.name===e.name?this.removeEventListener(o.type,o.listener,o.capture):t[++n]=o;++n?t.length=n:delete this.__on}}}function ewe(e,t,r){var n=eyt.hasOwnProperty(e.type)?J2e:ryt;return function(i,o,a){var s=this.__on,l,c=n(t,o,a);if(s){for(var u=0,h=s.length;u<h;++u)if((l=s[u]).type===e.type&&l.name===e.name){this.removeEventListener(l.type,l.listener,l.capture),this.addEventListener(l.type,l.listener=c,l.capture=r),l.value=t;return}}this.addEventListener(e.type,c,r),l={type:e.type,name:e.name,value:t,listener:c,capture:r},s?s.push(l):this.__on=[l]}}function nyt(e,t,r){var n=Q2e(e+""),i,o=n.length,a;if(arguments.length<2){var s=this.node().__on;if(s){for(var l=0,c=s.length,u;l<c;++l)for(i=0,u=s[l];i<o;++i)if((a=n[i]).type===u.type&&a.name===u.name)return u.value}return}for(s=t?ewe:twe,r==null&&(r=!1),i=0;i<o;++i)this.each(s(n[i],t,r));return this}function Mp(e,t,r,n){var i=qt;e.sourceEvent=qt,qt=e;try{return t.apply(r,n)}finally{qt=i}}function iyt(e,t,r){var n=hb(e),i=n.CustomEvent;typeof i=="function"?i=new i(t,r):(i=n.document.createEvent("Event"),r?(i.initEvent(t,r.bubbles,r.cancelable),i.detail=r.detail):i.initEvent(t,!1,!1)),e.dispatchEvent(i)}function rwe(e,t){return function(){return iyt(this,e,t)}}function nwe(e,t){return function(){return iyt(this,e,t.apply(this,arguments))}}function oyt(e,t){return this.each((typeof t=="function"?nwe:rwe)(e,t))}var EE=[null];function Nn(e,t){this._groups=e,this._parents=t}function ayt(){return new Nn([[document.documentElement]],EE)}Nn.prototype=ayt.prototype={constructor:Nn,select:v_t,selectAll:x_t,filter:b_t,data:E_t,enter:w_t,exit:T_t,join:C_t,merge:A_t,order:P_t,sort:I_t,call:L_t,nodes:k_t,node:R_t,size:N_t,empty:D_t,each:O_t,attr:z_t,style:F_t,property:B_t,classed:G_t,text:W_t,html:Y_t,raise:j_t,lower:X_t,append:$_t,insert:K_t,remove:Z_t,clone:J_t,datum:Q_t,on:nyt,dispatch:oyt};var Ih=ayt;function Ht(e){return typeof e=="string"?new Nn([[document.querySelector(e)]],[document.documentElement]):new Nn([[e]],EE)}function syt(e){return Ht(Rm(e).call(document.documentElement))}var iwe=0;function eL(){return new JW}function JW(){this._="@"+(++iwe).toString(36)}JW.prototype=eL.prototype={constructor:JW,get:function(e){for(var t=this._;!(t in e);)if(!(e=e.parentNode))return;return e[t]},set:function(e,t){return e[this._]=t},remove:function(e){return this._ in e&&delete e[this._]},toString:function(){return this._}};function fb(){for(var e=qt,t;t=e.sourceEvent;)e=t;return e}function Dm(e,t){var r=e.ownerSVGElement||e;if(r.createSVGPoint){var n=r.createSVGPoint();return n.x=t.clientX,n.y=t.clientY,n=n.matrixTransform(e.getScreenCTM().inverse()),[n.x,n.y]}var i=e.getBoundingClientRect();return[t.clientX-i.left-e.clientLeft,t.clientY-i.top-e.clientTop]}function zo(e){var t=fb();return t.changedTouches&&(t=t.changedTouches[0]),Dm(e,t)}function Ep(e){return typeof e=="string"?new Nn([document.querySelectorAll(e)],[document.documentElement]):new Nn([e==null?[]:e],EE)}function Tp(e,t,r){arguments.length<3&&(r=t,t=fb().changedTouches);for(var n=0,i=t?t.length:0,o;n<i;++n)if((o=t[n]).identifier===r)return Dm(e,o);return null}function lyt(e,t){t==null&&(t=fb().touches);for(var r=0,n=t?t.length:0,i=new Array(n);r<n;++r)i[r]=Dm(e,t[r]);return i}function rL(){qt.stopImmediatePropagation()}function Om(){qt.preventDefault(),qt.stopImmediatePropagation()}function zm(e){var t=e.document.documentElement,r=Ht(e).on("dragstart.drag",Om,!0);"onselectstart"in t?r.on("selectstart.drag",Om,!0):(t.__noselect=t.style.MozUserSelect,t.style.MozUserSelect="none")}function Fm(e,t){var r=e.document.documentElement,n=Ht(e).on("dragstart.drag",null);t&&(n.on("click.drag",Om,!0),setTimeout(function(){n.on("click.drag",null)},0)),"onselectstart"in r?n.on("selectstart.drag",null):(r.style.MozUserSelect=r.__noselect,delete r.__noselect)}function TE(e){return function(){return e}}function CE(e,t,r,n,i,o,a,s,l,c){this.target=e,this.type=t,this.subject=r,this.identifier=n,this.active=i,this.x=o,this.y=a,this.dx=s,this.dy=l,this._=c}CE.prototype.on=function(){var e=this._.on.apply(this._,arguments);return e===this._?this:e};function owe(){return!qt.ctrlKey&&!qt.button}function awe(){return this.parentNode}function swe(e){return e==null?{x:qt.x,y:qt.y}:e}function lwe(){return navigator.maxTouchPoints||"ontouchstart"in this}function pb(){var e=owe,t=awe,r=swe,n=lwe,i={},o=vs("start","drag","end"),a=0,s,l,c,u,h=0;function f(S){S.on("mousedown.drag",p).filter(n).on("touchstart.drag",_).on("touchmove.drag",y).on("touchend.drag touchcancel.drag",x).style("touch-action","none").style("-webkit-tap-highlight-color","rgba(0,0,0,0)")}function p(){if(!(u||!e.apply(this,arguments))){var S=b("mouse",t.apply(this,arguments),zo,this,arguments);!S||(Ht(qt.view).on("mousemove.drag",d,!0).on("mouseup.drag",g,!0),zm(qt.view),rL(),c=!1,s=qt.clientX,l=qt.clientY,S("start"))}}function d(){if(Om(),!c){var S=qt.clientX-s,C=qt.clientY-l;c=S*S+C*C>h}i.mouse("drag")}function g(){Ht(qt.view).on("mousemove.drag mouseup.drag",null),Fm(qt.view,c),Om(),i.mouse("end")}function _(){if(!!e.apply(this,arguments)){var S=qt.changedTouches,C=t.apply(this,arguments),P=S.length,k,O;for(k=0;k<P;++k)(O=b(S[k].identifier,C,Tp,this,arguments))&&(rL(),O("start"))}}function y(){var S=qt.changedTouches,C=S.length,P,k;for(P=0;P<C;++P)(k=i[S[P].identifier])&&(Om(),k("drag"))}function x(){var S=qt.changedTouches,C=S.length,P,k;for(u&&clearTimeout(u),u=setTimeout(function(){u=null},500),P=0;P<C;++P)(k=i[S[P].identifier])&&(rL(),k("end"))}function b(S,C,P,k,O){var D=P(C,S),B,I,L,R=o.copy();if(!!Mp(new CE(f,"beforestart",B,S,a,D[0],D[1],0,0,R),function(){return(qt.subject=B=r.apply(k,O))==null?!1:(I=B.x-D[0]||0,L=B.y-D[1]||0,!0)}))return function F(z){var U=D,W;switch(z){case"start":i[S]=F,W=a++;break;case"end":delete i[S],--a;case"drag":D=P(C,S),W=a;break}Mp(new CE(f,z,B,S,W,D[0]+I,D[1]+L,D[0]-U[0],D[1]-U[1],R),R.apply,R,[z,k,O])}}return f.filter=function(S){return arguments.length?(e=typeof S=="function"?S:TE(!!S),f):e},f.container=function(S){return arguments.length?(t=typeof S=="function"?S:TE(S),f):t},f.subject=function(S){return arguments.length?(r=typeof S=="function"?S:TE(S),f):r},f.touchable=function(S){return arguments.length?(n=typeof S=="function"?S:TE(!!S),f):n},f.on=function(){var S=o.on.apply(o,arguments);return S===o?f:S},f.clickDistance=function(S){return arguments.length?(h=(S=+S)*S,f):Math.sqrt(h)},f}function Cp(e,t,r){e.prototype=t.prototype=r,r.constructor=e}function Bm(e,t){var r=Object.create(e.prototype);for(var n in t)r[n]=t[n];return r}function Rh(){}var Hm=.7,b_=1/Hm,db="\\s*([+-]?\\d+)\\s*",AE="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",kh="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",cwe=/^#([0-9a-f]{3,8})$/,uwe=new RegExp("^rgb\\("+[db,db,db]+"\\)$"),hwe=new RegExp("^rgb\\("+[kh,kh,kh]+"\\)$"),fwe=new RegExp("^rgba\\("+[db,db,db,AE]+"\\)$"),pwe=new RegExp("^rgba\\("+[kh,kh,kh,AE]+"\\)$"),dwe=new RegExp("^hsl\\("+[AE,kh,kh]+"\\)$"),mwe=new RegExp("^hsla\\("+[AE,kh,kh,AE]+"\\)$"),cyt={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};Cp(Rh,rc,{copy:function(e){return Object.assign(new this.constructor,this,e)},displayable:function(){return this.rgb().displayable()},hex:uyt,formatHex:uyt,formatHsl:gwe,formatRgb:hyt,toString:hyt});function uyt(){return this.rgb().formatHex()}function gwe(){return gyt(this).formatHsl()}function hyt(){return this.rgb().formatRgb()}function rc(e){var t,r;return e=(e+"").trim().toLowerCase(),(t=cwe.exec(e))?(r=t[1].length,t=parseInt(t[1],16),r===6?fyt(t):r===3?new Ki(t>>8&15|t>>4&240,t>>4&15|t&240,(t&15)<<4|t&15,1):r===8?nL(t>>24&255,t>>16&255,t>>8&255,(t&255)/255):r===4?nL(t>>12&15|t>>8&240,t>>8&15|t>>4&240,t>>4&15|t&240,((t&15)<<4|t&15)/255):null):(t=uwe.exec(e))?new Ki(t[1],t[2],t[3],1):(t=hwe.exec(e))?new Ki(t[1]*255/100,t[2]*255/100,t[3]*255/100,1):(t=fwe.exec(e))?nL(t[1],t[2],t[3],t[4]):(t=pwe.exec(e))?nL(t[1]*255/100,t[2]*255/100,t[3]*255/100,t[4]):(t=dwe.exec(e))?myt(t[1],t[2]/100,t[3]/100,1):(t=mwe.exec(e))?myt(t[1],t[2]/100,t[3]/100,t[4]):cyt.hasOwnProperty(e)?fyt(cyt[e]):e==="transparent"?new Ki(NaN,NaN,NaN,0):null}function fyt(e){return new Ki(e>>16&255,e>>8&255,e&255,1)}function nL(e,t,r,n){return n<=0&&(e=t=r=NaN),new Ki(e,t,r,n)}function PE(e){return e instanceof Rh||(e=rc(e)),e?(e=e.rgb(),new Ki(e.r,e.g,e.b,e.opacity)):new Ki}function cu(e,t,r,n){return arguments.length===1?PE(e):new Ki(e,t,r,n==null?1:n)}function Ki(e,t,r,n){this.r=+e,this.g=+t,this.b=+r,this.opacity=+n}Cp(Ki,cu,Bm(Rh,{brighter:function(e){return e=e==null?b_:Math.pow(b_,e),new Ki(this.r*e,this.g*e,this.b*e,this.opacity)},darker:function(e){return e=e==null?Hm:Math.pow(Hm,e),new Ki(this.r*e,this.g*e,this.b*e,this.opacity)},rgb:function(){return this},displayable:function(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:pyt,formatHex:pyt,formatRgb:dyt,toString:dyt}));function pyt(){return"#"+QW(this.r)+QW(this.g)+QW(this.b)}function dyt(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"rgb(":"rgba(")+Math.max(0,Math.min(255,Math.round(this.r)||0))+", "+Math.max(0,Math.min(255,Math.round(this.g)||0))+", "+Math.max(0,Math.min(255,Math.round(this.b)||0))+(e===1?")":", "+e+")")}function QW(e){return e=Math.max(0,Math.min(255,Math.round(e)||0)),(e<16?"0":"")+e.toString(16)}function myt(e,t,r,n){return n<=0?e=t=r=NaN:r<=0||r>=1?e=t=NaN:t<=0&&(e=NaN),new Lh(e,t,r,n)}function gyt(e){if(e instanceof Lh)return new Lh(e.h,e.s,e.l,e.opacity);if(e instanceof Rh||(e=rc(e)),!e)return new Lh;if(e instanceof Lh)return e;e=e.rgb();var t=e.r/255,r=e.g/255,n=e.b/255,i=Math.min(t,r,n),o=Math.max(t,r,n),a=NaN,s=o-i,l=(o+i)/2;return s?(t===o?a=(r-n)/s+(r<n)*6:r===o?a=(n-t)/s+2:a=(t-r)/s+4,s/=l<.5?o+i:2-o-i,a*=60):s=l>0&&l<1?0:a,new Lh(a,s,l,e.opacity)}function Vm(e,t,r,n){return arguments.length===1?gyt(e):new Lh(e,t,r,n==null?1:n)}function Lh(e,t,r,n){this.h=+e,this.s=+t,this.l=+r,this.opacity=+n}Cp(Lh,Vm,Bm(Rh,{brighter:function(e){return e=e==null?b_:Math.pow(b_,e),new Lh(this.h,this.s,this.l*e,this.opacity)},darker:function(e){return e=e==null?Hm:Math.pow(Hm,e),new Lh(this.h,this.s,this.l*e,this.opacity)},rgb:function(){var e=this.h%360+(this.h<0)*360,t=isNaN(e)||isNaN(this.s)?0:this.s,r=this.l,n=r+(r<.5?r:1-r)*t,i=2*r-n;return new Ki(tY(e>=240?e-240:e+120,i,n),tY(e,i,n),tY(e<120?e+240:e-120,i,n),this.opacity)},displayable:function(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl:function(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"hsl(":"hsla(")+(this.h||0)+", "+(this.s||0)*100+"%, "+(this.l||0)*100+"%"+(e===1?")":", "+e+")")}}));function tY(e,t,r){return(e<60?t+(r-t)*e/60:e<180?r:e<240?t+(r-t)*(240-e)/60:t)*255}var iL=Math.PI/180,oL=180/Math.PI;var aL=18,_yt=.96422,yyt=1,vyt=.82521,xyt=4/29,mb=6/29,byt=3*mb*mb,_we=mb*mb*mb;function wyt(e){if(e instanceof uu)return new uu(e.l,e.a,e.b,e.opacity);if(e instanceof Nh)return Tyt(e);e instanceof Ki||(e=PE(e));var t=iY(e.r),r=iY(e.g),n=iY(e.b),i=eY((.2225045*t+.7168786*r+.0606169*n)/yyt),o,a;return t===r&&r===n?o=a=i:(o=eY((.4360747*t+.3850649*r+.1430804*n)/_yt),a=eY((.0139322*t+.0971045*r+.7141733*n)/vyt)),new uu(116*i-16,500*(o-i),200*(i-a),e.opacity)}function Syt(e,t){return new uu(e,0,0,t==null?1:t)}function w_(e,t,r,n){return arguments.length===1?wyt(e):new uu(e,t,r,n==null?1:n)}function uu(e,t,r,n){this.l=+e,this.a=+t,this.b=+r,this.opacity=+n}Cp(uu,w_,Bm(Rh,{brighter:function(e){return new uu(this.l+aL*(e==null?1:e),this.a,this.b,this.opacity)},darker:function(e){return new uu(this.l-aL*(e==null?1:e),this.a,this.b,this.opacity)},rgb:function(){var e=(this.l+16)/116,t=isNaN(this.a)?e:e+this.a/500,r=isNaN(this.b)?e:e-this.b/200;return t=_yt*rY(t),e=yyt*rY(e),r=vyt*rY(r),new Ki(nY(3.1338561*t-1.6168667*e-.4906146*r),nY(-.9787684*t+1.9161415*e+.033454*r),nY(.0719453*t-.2289914*e+1.4052427*r),this.opacity)}}));function eY(e){return e>_we?Math.pow(e,1/3):e/byt+xyt}function rY(e){return e>mb?e*e*e:byt*(e-xyt)}function nY(e){return 255*(e<=.0031308?12.92*e:1.055*Math.pow(e,1/2.4)-.055)}function iY(e){return(e/=255)<=.04045?e/12.92:Math.pow((e+.055)/1.055,2.4)}function Myt(e){if(e instanceof Nh)return new Nh(e.h,e.c,e.l,e.opacity);if(e instanceof uu||(e=wyt(e)),e.a===0&&e.b===0)return new Nh(NaN,0<e.l&&e.l<100?0:NaN,e.l,e.opacity);var t=Math.atan2(e.b,e.a)*oL;return new Nh(t<0?t+360:t,Math.sqrt(e.a*e.a+e.b*e.b),e.l,e.opacity)}function Eyt(e,t,r,n){return arguments.length===1?Myt(e):new Nh(r,t,e,n==null?1:n)}function gb(e,t,r,n){return arguments.length===1?Myt(e):new Nh(e,t,r,n==null?1:n)}function Nh(e,t,r,n){this.h=+e,this.c=+t,this.l=+r,this.opacity=+n}function Tyt(e){if(isNaN(e.h))return new uu(e.l,0,0,e.opacity);var t=e.h*iL;return new uu(e.l,Math.cos(t)*e.c,Math.sin(t)*e.c,e.opacity)}Cp(Nh,gb,Bm(Rh,{brighter:function(e){return new Nh(this.h,this.c,this.l+aL*(e==null?1:e),this.opacity)},darker:function(e){return new Nh(this.h,this.c,this.l-aL*(e==null?1:e),this.opacity)},rgb:function(){return Tyt(this).rgb()}}));var Iyt=-.14861,oY=1.78277,aY=-.29227,sL=-.90649,IE=1.97294,Cyt=IE*sL,Ayt=IE*oY,Pyt=oY*aY-sL*Iyt;function ywe(e){if(e instanceof S_)return new S_(e.h,e.s,e.l,e.opacity);e instanceof Ki||(e=PE(e));var t=e.r/255,r=e.g/255,n=e.b/255,i=(Pyt*n+Cyt*t-Ayt*r)/(Pyt+Cyt-Ayt),o=n-i,a=(IE*(r-i)-aY*o)/sL,s=Math.sqrt(a*a+o*o)/(IE*i*(1-i)),l=s?Math.atan2(a,o)*oL-120:NaN;return new S_(l<0?l+360:l,s,i,e.opacity)}function la(e,t,r,n){return arguments.length===1?ywe(e):new S_(e,t,r,n==null?1:n)}function S_(e,t,r,n){this.h=+e,this.s=+t,this.l=+r,this.opacity=+n}Cp(S_,la,Bm(Rh,{brighter:function(e){return e=e==null?b_:Math.pow(b_,e),new S_(this.h,this.s,this.l*e,this.opacity)},darker:function(e){return e=e==null?Hm:Math.pow(Hm,e),new S_(this.h,this.s,this.l*e,this.opacity)},rgb:function(){var e=isNaN(this.h)?0:(this.h+120)*iL,t=+this.l,r=isNaN(this.s)?0:this.s*t*(1-t),n=Math.cos(e),i=Math.sin(e);return new Ki(255*(t+r*(Iyt*n+oY*i)),255*(t+r*(aY*n+sL*i)),255*(t+r*(IE*n)),this.opacity)}}));function sY(e,t,r,n,i){var o=e*e,a=o*e;return((1-3*e+3*o-a)*t+(4-6*o+3*a)*r+(1+3*e+3*o-3*a)*n+a*i)/6}function lL(e){var t=e.length-1;return function(r){var n=r<=0?r=0:r>=1?(r=1,t-1):Math.floor(r*t),i=e[n],o=e[n+1],a=n>0?e[n-1]:2*i-o,s=n<t-1?e[n+2]:2*o-i;return sY((r-n/t)*t,a,i,o,s)}}function cL(e){var t=e.length;return function(r){var n=Math.floor(((r%=1)<0?++r:r)*t),i=e[(n+t-1)%t],o=e[n%t],a=e[(n+1)%t],s=e[(n+2)%t];return sY((r-n/t)*t,i,o,a,s)}}function _b(e){return function(){return e}}function Lyt(e,t){return function(r){return e+r*t}}function vwe(e,t,r){return e=Math.pow(e,r),t=Math.pow(t,r)-e,r=1/r,function(n){return Math.pow(e+n*t,r)}}function Um(e,t){var r=t-e;return r?Lyt(e,r>180||r<-180?r-360*Math.round(r/360):r):_b(isNaN(e)?t:e)}function kyt(e){return(e=+e)==1?Kn:function(t,r){return r-t?vwe(t,r,e):_b(isNaN(t)?r:t)}}function Kn(e,t){var r=t-e;return r?Lyt(e,r):_b(isNaN(e)?t:e)}var qm=function e(t){var r=kyt(t);function n(i,o){var a=r((i=cu(i)).r,(o=cu(o)).r),s=r(i.g,o.g),l=r(i.b,o.b),c=Kn(i.opacity,o.opacity);return function(u){return i.r=a(u),i.g=s(u),i.b=l(u),i.opacity=c(u),i+""}}return n.gamma=e,n}(1);function Ryt(e){return function(t){var r=t.length,n=new Array(r),i=new Array(r),o=new Array(r),a,s;for(a=0;a<r;++a)s=cu(t[a]),n[a]=s.r||0,i[a]=s.g||0,o[a]=s.b||0;return n=e(n),i=e(i),o=e(o),s.opacity=1,function(l){return s.r=n(l),s.g=i(l),s.b=o(l),s+""}}}var uL=Ryt(lL),Nyt=Ryt(cL);function yb(e,t){t||(t=[]);var r=e?Math.min(t.length,e.length):0,n=t.slice(),i;return function(o){for(i=0;i<r;++i)n[i]=e[i]*(1-o)+t[i]*o;return n}}function hL(e){return ArrayBuffer.isView(e)&&!(e instanceof DataView)}function Dyt(e,t){return(hL(t)?yb:lY)(e,t)}function lY(e,t){var r=t?t.length:0,n=e?Math.min(r,e.length):0,i=new Array(n),o=new Array(r),a;for(a=0;a<n;++a)i[a]=nc(e[a],t[a]);for(;a<r;++a)o[a]=t[a];return function(s){for(a=0;a<n;++a)o[a]=i[a](s);return o}}function fL(e,t){var r=new Date;return e=+e,t=+t,function(n){return r.setTime(e*(1-n)+t*n),r}}function zi(e,t){return e=+e,t=+t,function(r){return e*(1-r)+t*r}}function pL(e,t){var r={},n={},i;(e===null||typeof e!="object")&&(e={}),(t===null||typeof t!="object")&&(t={});for(i in t)i in e?r[i]=nc(e[i],t[i]):n[i]=t[i];return function(o){for(i in r)n[i]=r[i](o);return n}}var uY=/[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,cY=new RegExp(uY.source,"g");function xwe(e){return function(){return e}}function bwe(e){return function(t){return e(t)+""}}function vb(e,t){var r=uY.lastIndex=cY.lastIndex=0,n,i,o,a=-1,s=[],l=[];for(e=e+"",t=t+"";(n=uY.exec(e))&&(i=cY.exec(t));)(o=i.index)>r&&(o=t.slice(r,o),s[a]?s[a]+=o:s[++a]=o),(n=n[0])===(i=i[0])?s[a]?s[a]+=i:s[++a]=i:(s[++a]=null,l.push({i:a,x:zi(n,i)})),r=cY.lastIndex;return r<t.length&&(o=t.slice(r),s[a]?s[a]+=o:s[++a]=o),s.length<2?l[0]?bwe(l[0].x):xwe(t):(t=l.length,function(c){for(var u=0,h;u<t;++u)s[(h=l[u]).i]=h.x(c);return s.join("")})}function nc(e,t){var r=typeof t,n;return t==null||r==="boolean"?_b(t):(r==="number"?zi:r==="string"?(n=rc(t))?(t=n,qm):vb:t instanceof rc?qm:t instanceof Date?fL:hL(t)?yb:Array.isArray(t)?lY:typeof t.valueOf!="function"&&typeof t.toString!="function"||isNaN(t)?pL:zi)(e,t)}function Oyt(e){var t=e.length;return function(r){return e[Math.max(0,Math.min(t-1,Math.floor(r*t)))]}}function zyt(e,t){var r=Um(+e,+t);return function(n){var i=r(n);return i-360*Math.floor(i/360)}}function dL(e,t){return e=+e,t=+t,function(r){return Math.round(e*(1-r)+t*r)}}var Fyt=180/Math.PI,mL={translateX:0,translateY:0,rotate:0,skewX:0,scaleX:1,scaleY:1};function hY(e,t,r,n,i,o){var a,s,l;return(a=Math.sqrt(e*e+t*t))&&(e/=a,t/=a),(l=e*r+t*n)&&(r-=e*l,n-=t*l),(s=Math.sqrt(r*r+n*n))&&(r/=s,n/=s,l/=s),e*n<t*r&&(e=-e,t=-t,l=-l,a=-a),{translateX:i,translateY:o,rotate:Math.atan2(t,e)*Fyt,skewX:Math.atan(l)*Fyt,scaleX:a,scaleY:s}}var LE,fY,Byt,gL;function Hyt(e){return e==="none"?mL:(LE||(LE=document.createElement("DIV"),fY=document.documentElement,Byt=document.defaultView),LE.style.transform=e,e=Byt.getComputedStyle(fY.appendChild(LE),null).getPropertyValue("transform"),fY.removeChild(LE),e=e.slice(7,-1).split(","),hY(+e[0],+e[1],+e[2],+e[3],+e[4],+e[5]))}function Vyt(e){return e==null?mL:(gL||(gL=document.createElementNS("http://www.w3.org/2000/svg","g")),gL.setAttribute("transform",e),(e=gL.transform.baseVal.consolidate())?(e=e.matrix,hY(e.a,e.b,e.c,e.d,e.e,e.f)):mL)}function Uyt(e,t,r,n){function i(c){return c.length?c.pop()+" ":""}function o(c,u,h,f,p,d){if(c!==h||u!==f){var g=p.push("translate(",null,t,null,r);d.push({i:g-4,x:zi(c,h)},{i:g-2,x:zi(u,f)})}else(h||f)&&p.push("translate("+h+t+f+r)}function a(c,u,h,f){c!==u?(c-u>180?u+=360:u-c>180&&(c+=360),f.push({i:h.push(i(h)+"rotate(",null,n)-2,x:zi(c,u)})):u&&h.push(i(h)+"rotate("+u+n)}function s(c,u,h,f){c!==u?f.push({i:h.push(i(h)+"skewX(",null,n)-2,x:zi(c,u)}):u&&h.push(i(h)+"skewX("+u+n)}function l(c,u,h,f,p,d){if(c!==h||u!==f){var g=p.push(i(p)+"scale(",null,",",null,")");d.push({i:g-4,x:zi(c,h)},{i:g-2,x:zi(u,f)})}else(h!==1||f!==1)&&p.push(i(p)+"scale("+h+","+f+")")}return function(c,u){var h=[],f=[];return c=e(c),u=e(u),o(c.translateX,c.translateY,u.translateX,u.translateY,h,f),a(c.rotate,u.rotate,h,f),s(c.skewX,u.skewX,h,f),l(c.scaleX,c.scaleY,u.scaleX,u.scaleY,h,f),c=u=null,function(p){for(var d=-1,g=f.length,_;++d<g;)h[(_=f[d]).i]=_.x(p);return h.join("")}}}var _L=Uyt(Hyt,"px, ","px)","deg)"),yL=Uyt(Vyt,", ",")",")");var kE=Math.SQRT2,pY=2,qyt=4,wwe=1e-12;function Gyt(e){return((e=Math.exp(e))+1/e)/2}function Swe(e){return((e=Math.exp(e))-1/e)/2}function Mwe(e){return((e=Math.exp(2*e))-1)/(e+1)}function vL(e,t){var r=e[0],n=e[1],i=e[2],o=t[0],a=t[1],s=t[2],l=o-r,c=a-n,u=l*l+c*c,h,f;if(u<wwe)f=Math.log(s/i)/kE,h=function(x){return[r+x*l,n+x*c,i*Math.exp(kE*x*f)]};else{var p=Math.sqrt(u),d=(s*s-i*i+qyt*u)/(2*i*pY*p),g=(s*s-i*i-qyt*u)/(2*s*pY*p),_=Math.log(Math.sqrt(d*d+1)-d),y=Math.log(Math.sqrt(g*g+1)-g);f=(y-_)/kE,h=function(x){var b=x*f,S=Gyt(_),C=i/(pY*p)*(S*Mwe(kE*b+_)-Swe(_));return[r+C*l,n+C*c,i*S/Gyt(kE*b+_)]}}return h.duration=f*1e3,h}function Wyt(e){return function(t,r){var n=e((t=Vm(t)).h,(r=Vm(r)).h),i=Kn(t.s,r.s),o=Kn(t.l,r.l),a=Kn(t.opacity,r.opacity);return function(s){return t.h=n(s),t.s=i(s),t.l=o(s),t.opacity=a(s),t+""}}}var Yyt=Wyt(Um),jyt=Wyt(Kn);function M_(e,t){var r=Kn((e=w_(e)).l,(t=w_(t)).l),n=Kn(e.a,t.a),i=Kn(e.b,t.b),o=Kn(e.opacity,t.opacity);return function(a){return e.l=r(a),e.a=n(a),e.b=i(a),e.opacity=o(a),e+""}}function Xyt(e){return function(t,r){var n=e((t=gb(t)).h,(r=gb(r)).h),i=Kn(t.c,r.c),o=Kn(t.l,r.l),a=Kn(t.opacity,r.opacity);return function(s){return t.h=n(s),t.c=i(s),t.l=o(s),t.opacity=a(s),t+""}}}var $yt=Xyt(Um),Kyt=Xyt(Kn);function Zyt(e){return function t(r){r=+r;function n(i,o){var a=e((i=la(i)).h,(o=la(o)).h),s=Kn(i.s,o.s),l=Kn(i.l,o.l),c=Kn(i.opacity,o.opacity);return function(u){return i.h=a(u),i.s=s(u),i.l=l(Math.pow(u,r)),i.opacity=c(u),i+""}}return n.gamma=t,n}(1)}var Jyt=Zyt(Um),E_=Zyt(Kn);function dY(e,t){for(var r=0,n=t.length-1,i=t[0],o=new Array(n<0?0:n);r<n;)o[r]=e(i,i=t[++r]);return function(a){var s=Math.max(0,Math.min(n-1,Math.floor(a*=n)));return o[s](a-s)}}function Qyt(e,t){for(var r=new Array(t),n=0;n<t;++n)r[n]=e(n/(t-1));return r}km();var xb=0,NE=0,RE=0,evt=1e3,xL,DE,bL=0,T_=0,wL=0,OE=typeof performance=="object"&&performance.now?performance:Date,rvt=typeof window=="object"&&window.requestAnimationFrame?window.requestAnimationFrame.bind(window):function(e){setTimeout(e,17)};function Ap(){return T_||(rvt(Ewe),T_=OE.now()+wL)}function Ewe(){T_=0}function C_(){this._call=this._time=this._next=null}C_.prototype=A_.prototype={constructor:C_,restart:function(e,t,r){if(typeof e!="function")throw new TypeError("callback is not a function");r=(r==null?Ap():+r)+(t==null?0:+t),!this._next&&DE!==this&&(DE?DE._next=this:xL=this,DE=this),this._call=e,this._time=r,mY()},stop:function(){this._call&&(this._call=null,this._time=1/0,mY())}};function A_(e,t,r){var n=new C_;return n.restart(e,t,r),n}function gY(){Ap(),++xb;for(var e=xL,t;e;)(t=T_-e._time)>=0&&e._call.call(null,t),e=e._next;--xb}function tvt(){T_=(bL=OE.now())+wL,xb=NE=0;try{gY()}finally{xb=0,Cwe(),T_=0}}function Twe(){var e=OE.now(),t=e-bL;t>evt&&(wL-=t,bL=e)}function Cwe(){for(var e,t=xL,r,n=1/0;t;)t._call?(n>t._time&&(n=t._time),e=t,t=t._next):(r=t._next,t._next=null,t=e?e._next=r:xL=r);DE=e,mY(n)}function mY(e){if(!xb){NE&&(NE=clearTimeout(NE));var t=e-T_;t>24?(e<1/0&&(NE=setTimeout(tvt,e-OE.now()-wL)),RE&&(RE=clearInterval(RE))):(RE||(bL=OE.now(),RE=setInterval(Twe,evt)),xb=1,rvt(tvt))}}function zE(e,t,r){var n=new C_;return t=t==null?0:+t,n.restart(function(i){n.stop(),e(i+t)},t,r),n}function nvt(e,t,r){var n=new C_,i=t;return t==null?(n.restart(e,t,r),n):(t=+t,r=r==null?Ap():+r,n.restart(function o(a){a+=i,n.restart(o,i+=t,r),e(a)},t,r),n)}var Awe=vs("start","end","cancel","interrupt"),Pwe=[],ovt=0,ML=1,EL=2,SL=3,ivt=4,TL=5,FE=6;function Gm(e,t,r,n,i,o){var a=e.__transition;if(!a)e.__transition={};else if(r in a)return;Iwe(e,r,{name:t,index:n,group:i,on:Awe,tween:Pwe,time:o.time,delay:o.delay,duration:o.duration,ease:o.ease,timer:null,state:ovt})}function BE(e,t){var r=Zi(e,t);if(r.state>ovt)throw new Error("too late; already scheduled");return r}function Oa(e,t){var r=Zi(e,t);if(r.state>SL)throw new Error("too late; already running");return r}function Zi(e,t){var r=e.__transition;if(!r||!(r=r[t]))throw new Error("transition not found");return r}function Iwe(e,t,r){var n=e.__transition,i;n[t]=r,r.timer=A_(o,0,r.time);function o(c){r.state=ML,r.timer.restart(a,r.delay,r.time),r.delay<=c&&a(c-r.delay)}function a(c){var u,h,f,p;if(r.state!==ML)return l();for(u in n)if(p=n[u],p.name===r.name){if(p.state===SL)return zE(a);p.state===ivt?(p.state=FE,p.timer.stop(),p.on.call("interrupt",e,e.__data__,p.index,p.group),delete n[u]):+u<t&&(p.state=FE,p.timer.stop(),p.on.call("cancel",e,e.__data__,p.index,p.group),delete n[u])}if(zE(function(){r.state===SL&&(r.state=ivt,r.timer.restart(s,r.delay,r.time),s(c))}),r.state=EL,r.on.call("start",e,e.__data__,r.index,r.group),r.state===EL){for(r.state=SL,i=new Array(f=r.tween.length),u=0,h=-1;u<f;++u)(p=r.tween[u].value.call(e,e.__data__,r.index,r.group))&&(i[++h]=p);i.length=h+1}}function s(c){for(var u=c<r.duration?r.ease.call(null,c/r.duration):(r.timer.restart(l),r.state=TL,1),h=-1,f=i.length;++h<f;)i[h].call(e,u);r.state===TL&&(r.on.call("end",e,e.__data__,r.index,r.group),l())}function l(){r.state=FE,r.timer.stop(),delete n[t];for(var c in n)return;delete e.__transition}}function hu(e,t){var r=e.__transition,n,i,o=!0,a;if(!!r){t=t==null?null:t+"";for(a in r){if((n=r[a]).name!==t){o=!1;continue}i=n.state>EL&&n.state<TL,n.state=FE,n.timer.stop(),n.on.call(i?"interrupt":"cancel",e,e.__data__,n.index,n.group),delete r[a]}o&&delete e.__transition}}function avt(e){return this.each(function(){hu(this,e)})}function Lwe(e,t){var r,n;return function(){var i=Oa(this,e),o=i.tween;if(o!==r){n=r=o;for(var a=0,s=n.length;a<s;++a)if(n[a].name===t){n=n.slice(),n.splice(a,1);break}}i.tween=n}}function kwe(e,t,r){var n,i;if(typeof r!="function")throw new Error;return function(){var o=Oa(this,e),a=o.tween;if(a!==n){i=(n=a).slice();for(var s={name:t,value:r},l=0,c=i.length;l<c;++l)if(i[l].name===t){i[l]=s;break}l===c&&i.push(s)}o.tween=i}}function svt(e,t){var r=this._id;if(e+="",arguments.length<2){for(var n=Zi(this.node(),r).tween,i=0,o=n.length,a;i<o;++i)if((a=n[i]).name===e)return a.value;return null}return this.each((t==null?Lwe:kwe)(r,e,t))}function bb(e,t,r){var n=e._id;return e.each(function(){var i=Oa(this,n);(i.value||(i.value={}))[t]=r.apply(this,arguments)}),function(i){return Zi(i,n).value[t]}}function CL(e,t){var r;return(typeof t=="number"?zi:t instanceof rc?qm:(r=rc(t))?(t=r,qm):vb)(e,t)}function Rwe(e){return function(){this.removeAttribute(e)}}function Nwe(e){return function(){this.removeAttributeNS(e.space,e.local)}}function Dwe(e,t,r){var n,i=r+"",o;return function(){var a=this.getAttribute(e);return a===i?null:a===n?o:o=t(n=a,r)}}function Owe(e,t,r){var n,i=r+"",o;return function(){var a=this.getAttributeNS(e.space,e.local);return a===i?null:a===n?o:o=t(n=a,r)}}function zwe(e,t,r){var n,i,o;return function(){var a,s=r(this),l;return s==null?void this.removeAttribute(e):(a=this.getAttribute(e),l=s+"",a===l?null:a===n&&l===i?o:(i=l,o=t(n=a,s)))}}function Fwe(e,t,r){var n,i,o;return function(){var a,s=r(this),l;return s==null?void this.removeAttributeNS(e.space,e.local):(a=this.getAttributeNS(e.space,e.local),l=s+"",a===l?null:a===n&&l===i?o:(i=l,o=t(n=a,s)))}}function lvt(e,t){var r=Ph(e),n=r==="transform"?yL:CL;return this.attrTween(e,typeof t=="function"?(r.local?Fwe:zwe)(r,n,bb(this,"attr."+e,t)):t==null?(r.local?Nwe:Rwe)(r):(r.local?Owe:Dwe)(r,n,t))}function Bwe(e,t){return function(r){this.setAttribute(e,t.call(this,r))}}function Hwe(e,t){return function(r){this.setAttributeNS(e.space,e.local,t.call(this,r))}}function Vwe(e,t){var r,n;function i(){var o=t.apply(this,arguments);return o!==n&&(r=(n=o)&&Hwe(e,o)),r}return i._value=t,i}function Uwe(e,t){var r,n;function i(){var o=t.apply(this,arguments);return o!==n&&(r=(n=o)&&Bwe(e,o)),r}return i._value=t,i}function cvt(e,t){var r="attr."+e;if(arguments.length<2)return(r=this.tween(r))&&r._value;if(t==null)return this.tween(r,null);if(typeof t!="function")throw new Error;var n=Ph(e);return this.tween(r,(n.local?Vwe:Uwe)(n,t))}function qwe(e,t){return function(){BE(this,e).delay=+t.apply(this,arguments)}}function Gwe(e,t){return t=+t,function(){BE(this,e).delay=t}}function uvt(e){var t=this._id;return arguments.length?this.each((typeof e=="function"?qwe:Gwe)(t,e)):Zi(this.node(),t).delay}function Wwe(e,t){return function(){Oa(this,e).duration=+t.apply(this,arguments)}}function Ywe(e,t){return t=+t,function(){Oa(this,e).duration=t}}function hvt(e){var t=this._id;return arguments.length?this.each((typeof e=="function"?Wwe:Ywe)(t,e)):Zi(this.node(),t).duration}function jwe(e,t){if(typeof t!="function")throw new Error;return function(){Oa(this,e).ease=t}}function fvt(e){var t=this._id;return arguments.length?this.each(jwe(t,e)):Zi(this.node(),t).ease}function pvt(e){typeof e!="function"&&(e=ub(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=[],l,c=0;c<a;++c)(l=o[c])&&e.call(l,l.__data__,c,o)&&s.push(l);return new Fo(n,this._parents,this._name,this._id)}function dvt(e){if(e._id!==this._id)throw new Error;for(var t=this._groups,r=e._groups,n=t.length,i=r.length,o=Math.min(n,i),a=new Array(n),s=0;s<o;++s)for(var l=t[s],c=r[s],u=l.length,h=a[s]=new Array(u),f,p=0;p<u;++p)(f=l[p]||c[p])&&(h[p]=f);for(;s<n;++s)a[s]=t[s];return new Fo(a,this._parents,this._name,this._id)}function Xwe(e){return(e+"").trim().split(/^|\s+/).every(function(t){var r=t.indexOf(".");return r>=0&&(t=t.slice(0,r)),!t||t==="start"})}function $we(e,t,r){var n,i,o=Xwe(t)?BE:Oa;return function(){var a=o(this,e),s=a.on;s!==n&&(i=(n=s).copy()).on(t,r),a.on=i}}function mvt(e,t){var r=this._id;return arguments.length<2?Zi(this.node(),r).on.on(e):this.each($we(r,e,t))}function Kwe(e){return function(){var t=this.parentNode;for(var r in this.__transition)if(+r!==e)return;t&&t.removeChild(this)}}function gvt(){return this.on("end.remove",Kwe(this._id))}function _vt(e){var t=this._name,r=this._id;typeof e!="function"&&(e=Nm(e));for(var n=this._groups,i=n.length,o=new Array(i),a=0;a<i;++a)for(var s=n[a],l=s.length,c=o[a]=new Array(l),u,h,f=0;f<l;++f)(u=s[f])&&(h=e.call(u,u.__data__,f,s))&&("__data__"in u&&(h.__data__=u.__data__),c[f]=h,Gm(c[f],t,r,f,c,Zi(u,r)));return new Fo(o,this._parents,t,r)}function yvt(e){var t=this._name,r=this._id;typeof e!="function"&&(e=cb(e));for(var n=this._groups,i=n.length,o=[],a=[],s=0;s<i;++s)for(var l=n[s],c=l.length,u,h=0;h<c;++h)if(u=l[h]){for(var f=e.call(u,u.__data__,h,l),p,d=Zi(u,r),g=0,_=f.length;g<_;++g)(p=f[g])&&Gm(p,t,r,g,f,d);o.push(f),a.push(u)}return new Fo(o,a,t,r)}var Zwe=Ih.prototype.constructor;function vvt(){return new Zwe(this._groups,this._parents)}function Jwe(e,t){var r,n,i;return function(){var o=Sp(this,e),a=(this.style.removeProperty(e),Sp(this,e));return o===a?null:o===r&&a===n?i:i=t(r=o,n=a)}}function xvt(e){return function(){this.style.removeProperty(e)}}function Qwe(e,t,r){var n,i=r+"",o;return function(){var a=Sp(this,e);return a===i?null:a===n?o:o=t(n=a,r)}}function tSe(e,t,r){var n,i,o;return function(){var a=Sp(this,e),s=r(this),l=s+"";return s==null&&(l=s=(this.style.removeProperty(e),Sp(this,e))),a===l?null:a===n&&l===i?o:(i=l,o=t(n=a,s))}}function eSe(e,t){var r,n,i,o="style."+t,a="end."+o,s;return function(){var l=Oa(this,e),c=l.on,u=l.value[o]==null?s||(s=xvt(t)):void 0;(c!==r||i!==u)&&(n=(r=c).copy()).on(a,i=u),l.on=n}}function bvt(e,t,r){var n=(e+="")=="transform"?_L:CL;return t==null?this.styleTween(e,Jwe(e,n)).on("end.style."+e,xvt(e)):typeof t=="function"?this.styleTween(e,tSe(e,n,bb(this,"style."+e,t))).each(eSe(this._id,e)):this.styleTween(e,Qwe(e,n,t),r).on("end.style."+e,null)}function rSe(e,t,r){return function(n){this.style.setProperty(e,t.call(this,n),r)}}function nSe(e,t,r){var n,i;function o(){var a=t.apply(this,arguments);return a!==i&&(n=(i=a)&&rSe(e,a,r)),n}return o._value=t,o}function wvt(e,t,r){var n="style."+(e+="");if(arguments.length<2)return(n=this.tween(n))&&n._value;if(t==null)return this.tween(n,null);if(typeof t!="function")throw new Error;return this.tween(n,nSe(e,t,r==null?"":r))}function iSe(e){return function(){this.textContent=e}}function oSe(e){return function(){var t=e(this);this.textContent=t==null?"":t}}function Svt(e){return this.tween("text",typeof e=="function"?oSe(bb(this,"text",e)):iSe(e==null?"":e+""))}function aSe(e){return function(t){this.textContent=e.call(this,t)}}function sSe(e){var t,r;function n(){var i=e.apply(this,arguments);return i!==r&&(t=(r=i)&&aSe(i)),t}return n._value=e,n}function Mvt(e){var t="text";if(arguments.length<1)return(t=this.tween(t))&&t._value;if(e==null)return this.tween(t,null);if(typeof e!="function")throw new Error;return this.tween(t,sSe(e))}function Evt(){for(var e=this._name,t=this._id,r=AL(),n=this._groups,i=n.length,o=0;o<i;++o)for(var a=n[o],s=a.length,l,c=0;c<s;++c)if(l=a[c]){var u=Zi(l,t);Gm(l,e,r,c,a,{time:u.time+u.delay+u.duration,delay:0,duration:u.duration,ease:u.ease})}return new Fo(n,this._parents,e,r)}function Tvt(){var e,t,r=this,n=r._id,i=r.size();return new Promise(function(o,a){var s={value:a},l={value:function(){--i===0&&o()}};r.each(function(){var c=Oa(this,n),u=c.on;u!==e&&(t=(e=u).copy(),t._.cancel.push(s),t._.interrupt.push(s),t._.end.push(l)),c.on=t})})}var lSe=0;function Fo(e,t,r,n){this._groups=e,this._parents=t,this._name=r,this._id=n}function PL(e){return Ih().transition(e)}function AL(){return++lSe}var wb=Ih.prototype;Fo.prototype=PL.prototype={constructor:Fo,select:_vt,selectAll:yvt,filter:pvt,merge:dvt,selection:vvt,transition:Evt,call:wb.call,nodes:wb.nodes,node:wb.node,size:wb.size,empty:wb.empty,each:wb.each,on:mvt,attr:lvt,attrTween:cvt,style:bvt,styleTween:wvt,text:Svt,textTween:Mvt,remove:gvt,tween:svt,delay:uvt,duration:hvt,ease:fvt,end:Tvt};I_();var UY={time:null,delay:0,duration:250,ease:xs};function _Se(e,t){for(var r;!(r=e.__transition)||!(r=r[t]);)if(!(e=e.parentNode))return UY.time=Ap(),UY;return r}function Hvt(e){var t,r;e instanceof Fo?(t=e._id,e=e._name):(t=AL(),(r=UY).time=Ap(),e=e==null?null:e+"");for(var n=this._groups,i=n.length,o=0;o<i;++o)for(var a=n[o],s=a.length,l,c=0;c<s;++c)(l=a[c])&&Gm(l,e,t,c,a,r||_Se(l,t));return new Fo(n,this._parents,e,t)}Ih.prototype.interrupt=avt;Ih.prototype.transition=Hvt;var ySe=[null];function Vvt(e,t){var r=e.__transition,n,i;if(r){t=t==null?null:t+"";for(i in r)if((n=r[i]).state>ML&&n.name===t)return new Fo([[e]],ySe,t,+i)}return null}function FL(e){return function(){return e}}function Uvt(e,t,r){this.target=e,this.type=t,this.selection=r}function qY(){qt.stopImmediatePropagation()}function BL(){qt.preventDefault(),qt.stopImmediatePropagation()}var qvt={name:"drag"},GY={name:"space"},Mb={name:"handle"},Eb={name:"center"};function Gvt(e){return[+e[0],+e[1]]}function YY(e){return[Gvt(e[0]),Gvt(e[1])]}function vSe(e){return function(t){return Tp(t,qt.touches,e)}}var HL={name:"x",handles:["w","e"].map(HE),input:function(e,t){return e==null?null:[[+e[0],t[0][1]],[+e[1],t[1][1]]]},output:function(e){return e&&[e[0][0],e[1][0]]}},VL={name:"y",handles:["n","s"].map(HE),input:function(e,t){return e==null?null:[[t[0][0],+e[0]],[t[1][0],+e[1]]]},output:function(e){return e&&[e[0][1],e[1][1]]}},xSe={name:"xy",handles:["n","w","e","s","nw","ne","sw","se"].map(HE),input:function(e){return e==null?null:YY(e)},output:function(e){return e}},Pp={overlay:"crosshair",selection:"move",n:"ns-resize",e:"ew-resize",s:"ns-resize",w:"ew-resize",nw:"nwse-resize",ne:"nesw-resize",se:"nwse-resize",sw:"nesw-resize"},Wvt={e:"w",w:"e",nw:"ne",ne:"nw",se:"sw",sw:"se"},Yvt={n:"s",s:"n",nw:"sw",ne:"se",se:"ne",sw:"nw"},bSe={overlay:1,selection:1,n:null,e:1,s:null,w:-1,nw:-1,ne:1,se:1,sw:-1},wSe={overlay:1,selection:1,n:-1,e:null,s:1,w:null,nw:-1,ne:-1,se:1,sw:1};function HE(e){return{type:e}}function SSe(){return!qt.ctrlKey&&!qt.button}function MSe(){var e=this.ownerSVGElement||this;return e.hasAttribute("viewBox")?(e=e.viewBox.baseVal,[[e.x,e.y],[e.x+e.width,e.y+e.height]]):[[0,0],[e.width.baseVal.value,e.height.baseVal.value]]}function ESe(){return navigator.maxTouchPoints||"ontouchstart"in this}function WY(e){for(;!e.__brush;)if(!(e=e.parentNode))return;return e.__brush}function TSe(e){return e[0][0]===e[1][0]||e[0][1]===e[1][1]}function UL(e){var t=e.__brush;return t?t.dim.output(t.selection):null}function jvt(){return jY(HL)}function qL(){return jY(VL)}function GL(){return jY(xSe)}function jY(e){var t=MSe,r=SSe,n=ESe,i=!0,o=vs("start","brush","end"),a=6,s;function l(_){var y=_.property("__brush",g).selectAll(".overlay").data([HE("overlay")]);y.enter().append("rect").attr("class","overlay").attr("pointer-events","all").attr("cursor",Pp.overlay).merge(y).each(function(){var b=WY(this).extent;Ht(this).attr("x",b[0][0]).attr("y",b[0][1]).attr("width",b[1][0]-b[0][0]).attr("height",b[1][1]-b[0][1])}),_.selectAll(".selection").data([HE("selection")]).enter().append("rect").attr("class","selection").attr("cursor",Pp.selection).attr("fill","#777").attr("fill-opacity",.3).attr("stroke","#fff").attr("shape-rendering","crispEdges");var x=_.selectAll(".handle").data(e.handles,function(b){return b.type});x.exit().remove(),x.enter().append("rect").attr("class",function(b){return"handle handle--"+b.type}).attr("cursor",function(b){return Pp[b.type]}),_.each(c).attr("fill","none").attr("pointer-events","all").on("mousedown.brush",f).filter(n).on("touchstart.brush",f).on("touchmove.brush",p).on("touchend.brush touchcancel.brush",d).style("touch-action","none").style("-webkit-tap-highlight-color","rgba(0,0,0,0)")}l.move=function(_,y){_.selection?_.on("start.brush",function(){u(this,arguments).beforestart().start()}).on("interrupt.brush end.brush",function(){u(this,arguments).end()}).tween("brush",function(){var x=this,b=x.__brush,S=u(x,arguments),C=b.selection,P=e.input(typeof y=="function"?y.apply(this,arguments):y,b.extent),k=nc(C,P);function O(D){b.selection=D===1&&P===null?null:k(D),c.call(x),S.brush()}return C!==null&&P!==null?O:O(1)}):_.each(function(){var x=this,b=arguments,S=x.__brush,C=e.input(typeof y=="function"?y.apply(x,b):y,S.extent),P=u(x,b).beforestart();hu(x),S.selection=C===null?null:C,c.call(x),P.start().brush().end()})},l.clear=function(_){l.move(_,null)};function c(){var _=Ht(this),y=WY(this).selection;y?(_.selectAll(".selection").style("display",null).attr("x",y[0][0]).attr("y",y[0][1]).attr("width",y[1][0]-y[0][0]).attr("height",y[1][1]-y[0][1]),_.selectAll(".handle").style("display",null).attr("x",function(x){return x.type[x.type.length-1]==="e"?y[1][0]-a/2:y[0][0]-a/2}).attr("y",function(x){return x.type[0]==="s"?y[1][1]-a/2:y[0][1]-a/2}).attr("width",function(x){return x.type==="n"||x.type==="s"?y[1][0]-y[0][0]+a:a}).attr("height",function(x){return x.type==="e"||x.type==="w"?y[1][1]-y[0][1]+a:a})):_.selectAll(".selection,.handle").style("display","none").attr("x",null).attr("y",null).attr("width",null).attr("height",null)}function u(_,y,x){var b=_.__brush.emitter;return b&&(!x||!b.clean)?b:new h(_,y,x)}function h(_,y,x){this.that=_,this.args=y,this.state=_.__brush,this.active=0,this.clean=x}h.prototype={beforestart:function(){return++this.active===1&&(this.state.emitter=this,this.starting=!0),this},start:function(){return this.starting?(this.starting=!1,this.emit("start")):this.emit("brush"),this},brush:function(){return this.emit("brush"),this},end:function(){return--this.active===0&&(delete this.state.emitter,this.emit("end")),this},emit:function(_){Mp(new Uvt(l,_,e.output(this.state.selection)),o.apply,o,[_,this.that,this.args])}};function f(){if(s&&!qt.touches||!r.apply(this,arguments))return;var _=this,y=qt.target.__data__.type,x=(i&&qt.metaKey?y="overlay":y)==="selection"?qvt:i&&qt.altKey?Eb:Mb,b=e===VL?null:bSe[y],S=e===HL?null:wSe[y],C=WY(_),P=C.extent,k=C.selection,O=P[0][0],D,B,I=P[0][1],L,R,F=P[1][0],z,U,W=P[1][1],Z,rt,ot=0,st=0,St,bt=b&&S&&i&&qt.shiftKey,Mt,lt,Kt=qt.touches?vSe(qt.changedTouches[0].identifier):zo,_t=Kt(_),ct=_t,X=u(_,arguments,!0).beforestart();y==="overlay"?(k&&(St=!0),C.selection=k=[[D=e===VL?O:_t[0],L=e===HL?I:_t[1]],[z=e===VL?F:D,Z=e===HL?W:L]]):(D=k[0][0],L=k[0][1],z=k[1][0],Z=k[1][1]),B=D,R=L,U=z,rt=Z;var et=Ht(_).attr("pointer-events","none"),dt=et.selectAll(".overlay").attr("cursor",Pp[y]);if(qt.touches)X.moved=pt,X.ended=wt;else{var q=Ht(qt.view).on("mousemove.brush",pt,!0).on("mouseup.brush",wt,!0);i&&q.on("keydown.brush",kt,!0).on("keyup.brush",ie,!0),zm(qt.view)}qY(),hu(_),c.call(_),X.start();function pt(){var ee=Kt(_);bt&&!Mt&&!lt&&(Math.abs(ee[0]-ct[0])>Math.abs(ee[1]-ct[1])?lt=!0:Mt=!0),ct=ee,St=!0,BL(),ht()}function ht(){var ee;switch(ot=ct[0]-_t[0],st=ct[1]-_t[1],x){case GY:case qvt:{b&&(ot=Math.max(O-D,Math.min(F-z,ot)),B=D+ot,U=z+ot),S&&(st=Math.max(I-L,Math.min(W-Z,st)),R=L+st,rt=Z+st);break}case Mb:{b<0?(ot=Math.max(O-D,Math.min(F-D,ot)),B=D+ot,U=z):b>0&&(ot=Math.max(O-z,Math.min(F-z,ot)),B=D,U=z+ot),S<0?(st=Math.max(I-L,Math.min(W-L,st)),R=L+st,rt=Z):S>0&&(st=Math.max(I-Z,Math.min(W-Z,st)),R=L,rt=Z+st);break}case Eb:{b&&(B=Math.max(O,Math.min(F,D-ot*b)),U=Math.max(O,Math.min(F,z+ot*b))),S&&(R=Math.max(I,Math.min(W,L-st*S)),rt=Math.max(I,Math.min(W,Z+st*S)));break}}U<B&&(b*=-1,ee=D,D=z,z=ee,ee=B,B=U,U=ee,y in Wvt&&dt.attr("cursor",Pp[y=Wvt[y]])),rt<R&&(S*=-1,ee=L,L=Z,Z=ee,ee=R,R=rt,rt=ee,y in Yvt&&dt.attr("cursor",Pp[y=Yvt[y]])),C.selection&&(k=C.selection),Mt&&(B=k[0][0],U=k[1][0]),lt&&(R=k[0][1],rt=k[1][1]),(k[0][0]!==B||k[0][1]!==R||k[1][0]!==U||k[1][1]!==rt)&&(C.selection=[[B,R],[U,rt]],c.call(_),X.brush())}function wt(){if(qY(),qt.touches){if(qt.touches.length)return;s&&clearTimeout(s),s=setTimeout(function(){s=null},500)}else Fm(qt.view,St),q.on("keydown.brush keyup.brush mousemove.brush mouseup.brush",null);et.attr("pointer-events","all"),dt.attr("cursor",Pp.overlay),C.selection&&(k=C.selection),TSe(k)&&(C.selection=null,c.call(_)),X.end()}function kt(){switch(qt.keyCode){case 16:{bt=b&&S;break}case 18:{x===Mb&&(b&&(z=U-ot*b,D=B+ot*b),S&&(Z=rt-st*S,L=R+st*S),x=Eb,ht());break}case 32:{(x===Mb||x===Eb)&&(b<0?z=U-ot:b>0&&(D=B-ot),S<0?Z=rt-st:S>0&&(L=R-st),x=GY,dt.attr("cursor",Pp.selection),ht());break}default:return}BL()}function ie(){switch(qt.keyCode){case 16:{bt&&(Mt=lt=bt=!1,ht());break}case 18:{x===Eb&&(b<0?z=U:b>0&&(D=B),S<0?Z=rt:S>0&&(L=R),x=Mb,ht());break}case 32:{x===GY&&(qt.altKey?(b&&(z=U-ot*b,D=B+ot*b),S&&(Z=rt-st*S,L=R+st*S),x=Eb):(b<0?z=U:b>0&&(D=B),S<0?Z=rt:S>0&&(L=R),x=Mb),dt.attr("cursor",Pp[y]),ht());break}default:return}BL()}}function p(){u(this,arguments).moved()}function d(){u(this,arguments).ended()}function g(){var _=this.__brush||{selection:null};return _.extent=YY(t.apply(this,arguments)),_.dim=e,_}return l.extent=function(_){return arguments.length?(t=typeof _=="function"?_:FL(YY(_)),l):t},l.filter=function(_){return arguments.length?(r=typeof _=="function"?_:FL(!!_),l):r},l.touchable=function(_){return arguments.length?(n=typeof _=="function"?_:FL(!!_),l):n},l.handleSize=function(_){return arguments.length?(a=+_,l):a},l.keyModifiers=function(_){return arguments.length?(i=!!_,l):i},l.on=function(){var _=o.on.apply(o,arguments);return _===o?l:_},l}var XY=Math.cos,$Y=Math.sin,Xvt=Math.PI,VE=Xvt/2,KY=Xvt*2,ZY=Math.max;function CSe(e){return function(t,r){return e(t.source.value+t.target.value,r.source.value+r.target.value)}}function $vt(){var e=0,t=null,r=null,n=null;function i(o){var a=o.length,s=[],l=Ir(a),c=[],u=[],h=u.groups=new Array(a),f=new Array(a*a),p,d,g,_,y,x;for(p=0,y=-1;++y<a;){for(d=0,x=-1;++x<a;)d+=o[y][x];s.push(d),c.push(Ir(a)),p+=d}for(t&&l.sort(function(B,I){return t(s[B],s[I])}),r&&c.forEach(function(B,I){B.sort(function(L,R){return r(o[I][L],o[I][R])})}),p=ZY(0,KY-e*a)/p,_=p?e:KY/a,d=0,y=-1;++y<a;){for(g=d,x=-1;++x<a;){var b=l[y],S=c[b][x],C=o[b][S],P=d,k=d+=C*p;f[S*a+b]={index:b,subindex:S,startAngle:P,endAngle:k,value:C}}h[b]={index:b,startAngle:g,endAngle:d,value:s[b]},d+=_}for(y=-1;++y<a;)for(x=y-1;++x<a;){var O=f[x*a+y],D=f[y*a+x];(O.value||D.value)&&u.push(O.value<D.value?{source:D,target:O}:{source:O,target:D})}return n?u.sort(n):u}return i.padAngle=function(o){return arguments.length?(e=ZY(0,o),i):e},i.sortGroups=function(o){return arguments.length?(t=o,i):t},i.sortSubgroups=function(o){return arguments.length?(r=o,i):r},i.sortChords=function(o){return arguments.length?(o==null?n=null:(n=CSe(o))._=o,i):n&&n._},i}var Kvt=Array.prototype.slice;function WL(e){return function(){return e}}var JY=Math.PI,QY=2*JY,L_=1e-6,ASe=QY-L_;function tj(){this._x0=this._y0=this._x1=this._y1=null,this._=""}function Zvt(){return new tj}tj.prototype=Zvt.prototype={constructor:tj,moveTo:function(e,t){this._+="M"+(this._x0=this._x1=+e)+","+(this._y0=this._y1=+t)},closePath:function(){this._x1!==null&&(this._x1=this._x0,this._y1=this._y0,this._+="Z")},lineTo:function(e,t){this._+="L"+(this._x1=+e)+","+(this._y1=+t)},quadraticCurveTo:function(e,t,r,n){this._+="Q"+ +e+","+ +t+","+(this._x1=+r)+","+(this._y1=+n)},bezierCurveTo:function(e,t,r,n,i,o){this._+="C"+ +e+","+ +t+","+ +r+","+ +n+","+(this._x1=+i)+","+(this._y1=+o)},arcTo:function(e,t,r,n,i){e=+e,t=+t,r=+r,n=+n,i=+i;var o=this._x1,a=this._y1,s=r-e,l=n-t,c=o-e,u=a-t,h=c*c+u*u;if(i<0)throw new Error("negative radius: "+i);if(this._x1===null)this._+="M"+(this._x1=e)+","+(this._y1=t);else if(h>L_)if(!(Math.abs(u*s-l*c)>L_)||!i)this._+="L"+(this._x1=e)+","+(this._y1=t);else{var f=r-o,p=n-a,d=s*s+l*l,g=f*f+p*p,_=Math.sqrt(d),y=Math.sqrt(h),x=i*Math.tan((JY-Math.acos((d+h-g)/(2*_*y)))/2),b=x/y,S=x/_;Math.abs(b-1)>L_&&(this._+="L"+(e+b*c)+","+(t+b*u)),this._+="A"+i+","+i+",0,0,"+ +(u*f>c*p)+","+(this._x1=e+S*s)+","+(this._y1=t+S*l)}},arc:function(e,t,r,n,i,o){e=+e,t=+t,r=+r,o=!!o;var a=r*Math.cos(n),s=r*Math.sin(n),l=e+a,c=t+s,u=1^o,h=o?n-i:i-n;if(r<0)throw new Error("negative radius: "+r);this._x1===null?this._+="M"+l+","+c:(Math.abs(this._x1-l)>L_||Math.abs(this._y1-c)>L_)&&(this._+="L"+l+","+c),r&&(h<0&&(h=h%QY+QY),h>ASe?this._+="A"+r+","+r+",0,1,"+u+","+(e-a)+","+(t-s)+"A"+r+","+r+",0,1,"+u+","+(this._x1=l)+","+(this._y1=c):h>L_&&(this._+="A"+r+","+r+",0,"+ +(h>=JY)+","+u+","+(this._x1=e+r*Math.cos(i))+","+(this._y1=t+r*Math.sin(i))))},rect:function(e,t,r,n){this._+="M"+(this._x0=this._x1=+e)+","+(this._y0=this._y1=+t)+"h"+ +r+"v"+ +n+"h"+-r+"Z"},toString:function(){return this._}};var bs=Zvt;function PSe(e){return e.source}function ISe(e){return e.target}function LSe(e){return e.radius}function kSe(e){return e.startAngle}function RSe(e){return e.endAngle}function Jvt(){var e=PSe,t=ISe,r=LSe,n=kSe,i=RSe,o=null;function a(){var s,l=Kvt.call(arguments),c=e.apply(this,l),u=t.apply(this,l),h=+r.apply(this,(l[0]=c,l)),f=n.apply(this,l)-VE,p=i.apply(this,l)-VE,d=h*XY(f),g=h*$Y(f),_=+r.apply(this,(l[0]=u,l)),y=n.apply(this,l)-VE,x=i.apply(this,l)-VE;if(o||(o=s=bs()),o.moveTo(d,g),o.arc(0,0,h,f,p),(f!==y||p!==x)&&(o.quadraticCurveTo(0,0,_*XY(y),_*$Y(y)),o.arc(0,0,_,y,x)),o.quadraticCurveTo(0,0,d,g),o.closePath(),s)return o=null,s+""||null}return a.radius=function(s){return arguments.length?(r=typeof s=="function"?s:WL(+s),a):r},a.startAngle=function(s){return arguments.length?(n=typeof s=="function"?s:WL(+s),a):n},a.endAngle=function(s){return arguments.length?(i=typeof s=="function"?s:WL(+s),a):i},a.source=function(s){return arguments.length?(e=s,a):e},a.target=function(s){return arguments.length?(t=s,a):t},a.context=function(s){return arguments.length?(o=s==null?null:s,a):o},a}Tb();var OSe=Array.prototype,KL=OSe.slice;function f1t(e,t){return e-t}function p1t(e){for(var t=0,r=e.length,n=e[r-1][1]*e[0][0]-e[r-1][0]*e[0][1];++t<r;)n+=e[t-1][1]*e[t][0]-e[t-1][0]*e[t][1];return n}function Oh(e){return function(){return e}}function d1t(e,t){for(var r=-1,n=t.length,i;++r<n;)if(i=zSe(e,t[r]))return i;return 0}function zSe(e,t){for(var r=t[0],n=t[1],i=-1,o=0,a=e.length,s=a-1;o<a;s=o++){var l=e[o],c=l[0],u=l[1],h=e[s],f=h[0],p=h[1];if(FSe(l,h,t))return 0;u>n!=p>n&&r<(f-c)*(n-u)/(p-u)+c&&(i=-i)}return i}function FSe(e,t,r){var n;return BSe(e,t,r)&&HSe(e[n=+(e[0]===t[0])],r[n],t[n])}function BSe(e,t,r){return(t[0]-e[0])*(r[1]-e[1])===(r[0]-e[0])*(t[1]-e[1])}function HSe(e,t,r){return e<=t&&t<=r||r<=t&&t<=e}function m1t(){}var Ip=[[],[[[1,1.5],[.5,1]]],[[[1.5,1],[1,1.5]]],[[[1.5,1],[.5,1]]],[[[1,.5],[1.5,1]]],[[[1,1.5],[.5,1]],[[1,.5],[1.5,1]]],[[[1,.5],[1,1.5]]],[[[1,.5],[.5,1]]],[[[.5,1],[1,.5]]],[[[1,1.5],[1,.5]]],[[[.5,1],[1,.5]],[[1.5,1],[1,1.5]]],[[[1.5,1],[1,.5]]],[[[.5,1],[1.5,1]]],[[[1,1.5],[1.5,1]]],[[[.5,1],[1,1.5]]],[]];function ZL(){var e=1,t=1,r=sb,n=l;function i(c){var u=r(c);if(Array.isArray(u))u=u.slice().sort(f1t);else{var h=aa(c),f=h[0],p=h[1];u=tl(f,p,u),u=Ir(Math.floor(f/u)*u,Math.floor(p/u)*u,u)}return u.map(function(d){return o(c,d)})}function o(c,u){var h=[],f=[];return a(c,u,function(p){n(p,c,u),p1t(p)>0?h.push([p]):f.push(p)}),f.forEach(function(p){for(var d=0,g=h.length,_;d<g;++d)if(d1t((_=h[d])[0],p)!==-1){_.push(p);return}}),{type:"MultiPolygon",value:u,coordinates:h}}function a(c,u,h){var f=new Array,p=new Array,d,g,_,y,x,b;for(d=g=-1,y=c[0]>=u,Ip[y<<1].forEach(S);++d<e-1;)_=y,y=c[d+1]>=u,Ip[_|y<<1].forEach(S);for(Ip[y<<0].forEach(S);++g<t-1;){for(d=-1,y=c[g*e+e]>=u,x=c[g*e]>=u,Ip[y<<1|x<<2].forEach(S);++d<e-1;)_=y,y=c[g*e+e+d+1]>=u,b=x,x=c[g*e+d+1]>=u,Ip[_|y<<1|x<<2|b<<3].forEach(S);Ip[y|x<<3].forEach(S)}for(d=-1,x=c[g*e]>=u,Ip[x<<2].forEach(S);++d<e-1;)b=x,x=c[g*e+d+1]>=u,Ip[x<<2|b<<3].forEach(S);Ip[x<<3].forEach(S);function S(C){var P=[C[0][0]+d,C[0][1]+g],k=[C[1][0]+d,C[1][1]+g],O=s(P),D=s(k),B,I;(B=p[O])?(I=f[D])?(delete p[B.end],delete f[I.start],B===I?(B.ring.push(k),h(B.ring)):f[B.start]=p[I.end]={start:B.start,end:I.end,ring:B.ring.concat(I.ring)}):(delete p[B.end],B.ring.push(k),p[B.end=D]=B):(B=f[D])?(I=p[O])?(delete f[B.start],delete p[I.end],B===I?(B.ring.push(k),h(B.ring)):f[I.start]=p[B.end]={start:I.start,end:B.end,ring:I.ring.concat(B.ring)}):(delete f[B.start],B.ring.unshift(P),f[B.start=O]=B):f[O]=p[D]={start:O,end:D,ring:[P,k]}}}function s(c){return c[0]*2+c[1]*(e+1)*4}function l(c,u,h){c.forEach(function(f){var p=f[0],d=f[1],g=p|0,_=d|0,y,x=u[_*e+g];p>0&&p<e&&g===p&&(y=u[_*e+g-1],f[0]=p+(h-y)/(x-y)-.5),d>0&&d<t&&_===d&&(y=u[(_-1)*e+g],f[1]=d+(h-y)/(x-y)-.5)})}return i.contour=o,i.size=function(c){if(!arguments.length)return[e,t];var u=Math.ceil(c[0]),h=Math.ceil(c[1]);if(!(u>0)||!(h>0))throw new Error("invalid size");return e=u,t=h,i},i.thresholds=function(c){return arguments.length?(r=typeof c=="function"?c:Array.isArray(c)?Oh(KL.call(c)):Oh(c),i):r},i.smooth=function(c){return arguments.length?(n=c?l:m1t,i):n===l},i}function JL(e,t,r){for(var n=e.width,i=e.height,o=(r<<1)+1,a=0;a<i;++a)for(var s=0,l=0;s<n+r;++s)s<n&&(l+=e.data[s+a*n]),s>=r&&(s>=o&&(l-=e.data[s-o+a*n]),t.data[s-r+a*n]=l/Math.min(s+1,n-1+o-s,o))}function QL(e,t,r){for(var n=e.width,i=e.height,o=(r<<1)+1,a=0;a<n;++a)for(var s=0,l=0;s<i+r;++s)s<i&&(l+=e.data[a+s*n]),s>=r&&(s>=o&&(l-=e.data[a+(s-o)*n]),t.data[a+(s-r)*n]=l/Math.min(s+1,i-1+o-s,o))}function VSe(e){return e[0]}function USe(e){return e[1]}function qSe(){return 1}function g1t(){var e=VSe,t=USe,r=qSe,n=960,i=500,o=20,a=2,s=o*3,l=n+s*2>>a,c=i+s*2>>a,u=Oh(20);function h(y){var x=new Float32Array(l*c),b=new Float32Array(l*c);y.forEach(function(P,k,O){var D=+e(P,k,O)+s>>a,B=+t(P,k,O)+s>>a,I=+r(P,k,O);D>=0&&D<l&&B>=0&&B<c&&(x[D+B*l]+=I)}),JL({width:l,height:c,data:x},{width:l,height:c,data:b},o>>a),QL({width:l,height:c,data:b},{width:l,height:c,data:x},o>>a),JL({width:l,height:c,data:x},{width:l,height:c,data:b},o>>a),QL({width:l,height:c,data:b},{width:l,height:c,data:x},o>>a),JL({width:l,height:c,data:x},{width:l,height:c,data:b},o>>a),QL({width:l,height:c,data:b},{width:l,height:c,data:x},o>>a);var S=u(x);if(!Array.isArray(S)){var C=lu(x);S=tl(0,C,S),S=Ir(0,Math.floor(C/S)*S,S),S.shift()}return ZL().thresholds(S).size([l,c])(x).map(f)}function f(y){return y.value*=Math.pow(2,-2*a),y.coordinates.forEach(p),y}function p(y){y.forEach(d)}function d(y){y.forEach(g)}function g(y){y[0]=y[0]*Math.pow(2,a)-s,y[1]=y[1]*Math.pow(2,a)-s}function _(){return s=o*3,l=n+s*2>>a,c=i+s*2>>a,h}return h.x=function(y){return arguments.length?(e=typeof y=="function"?y:Oh(+y),h):e},h.y=function(y){return arguments.length?(t=typeof y=="function"?y:Oh(+y),h):t},h.weight=function(y){return arguments.length?(r=typeof y=="function"?y:Oh(+y),h):r},h.size=function(y){if(!arguments.length)return[n,i];var x=Math.ceil(y[0]),b=Math.ceil(y[1]);if(!(x>=0)&&!(x>=0))throw new Error("invalid size");return n=x,i=b,_()},h.cellSize=function(y){if(!arguments.length)return 1<<a;if(!((y=+y)>=1))throw new Error("invalid cell size");return a=Math.floor(Math.log(y)/Math.LN2),_()},h.thresholds=function(y){return arguments.length?(u=typeof y=="function"?y:Array.isArray(y)?Oh(KL.call(y)):Oh(y),h):u},h.bandwidth=function(y){if(!arguments.length)return Math.sqrt(o*(o+1));if(!((y=+y)>=0))throw new Error("invalid bandwidth");return o=Math.round((Math.sqrt(4*y*y+1)-1)/2),_()},h}km();qE();I_();function XSe(e){if(!e.ok)throw new Error(e.status+" "+e.statusText);return e.blob()}function D1t(e,t){return fetch(e,t).then(XSe)}function $Se(e){if(!e.ok)throw new Error(e.status+" "+e.statusText);return e.arrayBuffer()}function O1t(e,t){return fetch(e,t).then($Se)}qE();function KSe(e){if(!e.ok)throw new Error(e.status+" "+e.statusText);return e.text()}function D_(e,t){return fetch(e,t).then(KSe)}function z1t(e){return function(t,r,n){return arguments.length===2&&typeof r=="function"&&(n=r,r=void 0),D_(t,r).then(function(i){return e(i,n)})}}function oj(e,t,r,n){arguments.length===3&&typeof r=="function"&&(n=r,r=void 0);var i=Wm(e);return D_(t,r).then(function(o){return i.parse(o,n)})}var F1t=z1t(Cb),B1t=z1t(Ab);function H1t(e,t){return new Promise(function(r,n){var i=new Image;for(var o in t)i[o]=t[o];i.onerror=n,i.onload=function(){r(i)},i.src=e})}function ZSe(e){if(!e.ok)throw new Error(e.status+" "+e.statusText);if(!(e.status===204||e.status===205))return e.json()}function V1t(e,t){return fetch(e,t).then(ZSe)}function aj(e){return function(t,r){return D_(t,r).then(function(n){return new DOMParser().parseFromString(n,e)})}}var U1t=aj("application/xml"),q1t=aj("text/html"),G1t=aj("image/svg+xml");function W1t(e,t){var r;e==null&&(e=0),t==null&&(t=0);function n(){var i,o=r.length,a,s=0,l=0;for(i=0;i<o;++i)a=r[i],s+=a.x,l+=a.y;for(s=s/o-e,l=l/o-t,i=0;i<o;++i)a=r[i],a.x-=s,a.y-=l}return n.initialize=function(i){r=i},n.x=function(i){return arguments.length?(e=+i,n):e},n.y=function(i){return arguments.length?(t=+i,n):t},n}function Dn(e){return function(){return e}}function fu(){return(Math.random()-.5)*1e-6}function Y1t(e){var t=+this._x.call(null,e),r=+this._y.call(null,e);return j1t(this.cover(t,r),t,r,e)}function j1t(e,t,r,n){if(isNaN(t)||isNaN(r))return e;var i,o=e._root,a={data:n},s=e._x0,l=e._y0,c=e._x1,u=e._y1,h,f,p,d,g,_,y,x;if(!o)return e._root=a,e;for(;o.length;)if((g=t>=(h=(s+c)/2))?s=h:c=h,(_=r>=(f=(l+u)/2))?l=f:u=f,i=o,!(o=o[y=_<<1|g]))return i[y]=a,e;if(p=+e._x.call(null,o.data),d=+e._y.call(null,o.data),t===p&&r===d)return a.next=o,i?i[y]=a:e._root=a,e;do i=i?i[y]=new Array(4):e._root=new Array(4),(g=t>=(h=(s+c)/2))?s=h:c=h,(_=r>=(f=(l+u)/2))?l=f:u=f;while((y=_<<1|g)===(x=(d>=f)<<1|p>=h));return i[x]=o,i[y]=a,e}function X1t(e){var t,r,n=e.length,i,o,a=new Array(n),s=new Array(n),l=1/0,c=1/0,u=-1/0,h=-1/0;for(r=0;r<n;++r)isNaN(i=+this._x.call(null,t=e[r]))||isNaN(o=+this._y.call(null,t))||(a[r]=i,s[r]=o,i<l&&(l=i),i>u&&(u=i),o<c&&(c=o),o>h&&(h=o));if(l>u||c>h)return this;for(this.cover(l,c).cover(u,h),r=0;r<n;++r)j1t(this,a[r],s[r],e[r]);return this}function $1t(e,t){if(isNaN(e=+e)||isNaN(t=+t))return this;var r=this._x0,n=this._y0,i=this._x1,o=this._y1;if(isNaN(r))i=(r=Math.floor(e))+1,o=(n=Math.floor(t))+1;else{for(var a=i-r,s=this._root,l,c;r>e||e>=i||n>t||t>=o;)switch(c=(t<n)<<1|e<r,l=new Array(4),l[c]=s,s=l,a*=2,c){case 0:i=r+a,o=n+a;break;case 1:r=i-a,o=n+a;break;case 2:i=r+a,n=o-a;break;case 3:r=i-a,n=o-a;break}this._root&&this._root.length&&(this._root=s)}return this._x0=r,this._y0=n,this._x1=i,this._y1=o,this}function K1t(){var e=[];return this.visit(function(t){if(!t.length)do e.push(t.data);while(t=t.next)}),e}function Z1t(e){return arguments.length?this.cover(+e[0][0],+e[0][1]).cover(+e[1][0],+e[1][1]):isNaN(this._x0)?void 0:[[this._x0,this._y0],[this._x1,this._y1]]}function yo(e,t,r,n,i){this.node=e,this.x0=t,this.y0=r,this.x1=n,this.y1=i}function J1t(e,t,r){var n,i=this._x0,o=this._y0,a,s,l,c,u=this._x1,h=this._y1,f=[],p=this._root,d,g;for(p&&f.push(new yo(p,i,o,u,h)),r==null?r=1/0:(i=e-r,o=t-r,u=e+r,h=t+r,r*=r);d=f.pop();)if(!(!(p=d.node)||(a=d.x0)>u||(s=d.y0)>h||(l=d.x1)<i||(c=d.y1)<o))if(p.length){var _=(a+l)/2,y=(s+c)/2;f.push(new yo(p[3],_,y,l,c),new yo(p[2],a,y,_,c),new yo(p[1],_,s,l,y),new yo(p[0],a,s,_,y)),(g=(t>=y)<<1|e>=_)&&(d=f[f.length-1],f[f.length-1]=f[f.length-1-g],f[f.length-1-g]=d)}else{var x=e-+this._x.call(null,p.data),b=t-+this._y.call(null,p.data),S=x*x+b*b;if(S<r){var C=Math.sqrt(r=S);i=e-C,o=t-C,u=e+C,h=t+C,n=p.data}}return n}function Q1t(e){if(isNaN(u=+this._x.call(null,e))||isNaN(h=+this._y.call(null,e)))return this;var t,r=this._root,n,i,o,a=this._x0,s=this._y0,l=this._x1,c=this._y1,u,h,f,p,d,g,_,y;if(!r)return this;if(r.length)for(;;){if((d=u>=(f=(a+l)/2))?a=f:l=f,(g=h>=(p=(s+c)/2))?s=p:c=p,t=r,!(r=r[_=g<<1|d]))return this;if(!r.length)break;(t[_+1&3]||t[_+2&3]||t[_+3&3])&&(n=t,y=_)}for(;r.data!==e;)if(i=r,!(r=r.next))return this;return(o=r.next)&&delete r.next,i?(o?i.next=o:delete i.next,this):t?(o?t[_]=o:delete t[_],(r=t[0]||t[1]||t[2]||t[3])&&r===(t[3]||t[2]||t[1]||t[0])&&!r.length&&(n?n[y]=r:this._root=r),this):(this._root=o,this)}function txt(e){for(var t=0,r=e.length;t<r;++t)this.remove(e[t]);return this}function ext(){return this._root}function rxt(){var e=0;return this.visit(function(t){if(!t.length)do++e;while(t=t.next)}),e}function nxt(e){var t=[],r,n=this._root,i,o,a,s,l;for(n&&t.push(new yo(n,this._x0,this._y0,this._x1,this._y1));r=t.pop();)if(!e(n=r.node,o=r.x0,a=r.y0,s=r.x1,l=r.y1)&&n.length){var c=(o+s)/2,u=(a+l)/2;(i=n[3])&&t.push(new yo(i,c,u,s,l)),(i=n[2])&&t.push(new yo(i,o,u,c,l)),(i=n[1])&&t.push(new yo(i,c,a,s,u)),(i=n[0])&&t.push(new yo(i,o,a,c,u))}return this}function ixt(e){var t=[],r=[],n;for(this._root&&t.push(new yo(this._root,this._x0,this._y0,this._x1,this._y1));n=t.pop();){var i=n.node;if(i.length){var o,a=n.x0,s=n.y0,l=n.x1,c=n.y1,u=(a+l)/2,h=(s+c)/2;(o=i[0])&&t.push(new yo(o,a,s,u,h)),(o=i[1])&&t.push(new yo(o,u,s,l,h)),(o=i[2])&&t.push(new yo(o,a,h,u,c)),(o=i[3])&&t.push(new yo(o,u,h,l,c))}r.push(n)}for(;n=r.pop();)e(n.node,n.x0,n.y0,n.x1,n.y1);return this}function oxt(e){return e[0]}function axt(e){return arguments.length?(this._x=e,this):this._x}function sxt(e){return e[1]}function lxt(e){return arguments.length?(this._y=e,this):this._y}function zh(e,t,r){var n=new sj(t==null?oxt:t,r==null?sxt:r,NaN,NaN,NaN,NaN);return e==null?n:n.addAll(e)}function sj(e,t,r,n,i,o){this._x=e,this._y=t,this._x0=r,this._y0=n,this._x1=i,this._y1=o,this._root=void 0}function cxt(e){for(var t={data:e.data},r=t;e=e.next;)r=r.next={data:e.data};return t}var za=zh.prototype=sj.prototype;za.copy=function(){var e=new sj(this._x,this._y,this._x0,this._y0,this._x1,this._y1),t=this._root,r,n;if(!t)return e;if(!t.length)return e._root=cxt(t),e;for(r=[{source:t,target:e._root=new Array(4)}];t=r.pop();)for(var i=0;i<4;++i)(n=t.source[i])&&(n.length?r.push({source:n,target:t.target[i]=new Array(4)}):t.target[i]=cxt(n));return e};za.add=Y1t;za.addAll=X1t;za.cover=$1t;za.data=K1t;za.extent=Z1t;za.find=J1t;za.remove=Q1t;za.removeAll=txt;za.root=ext;za.size=rxt;za.visit=nxt;za.visitAfter=ixt;za.x=axt;za.y=lxt;function JSe(e){return e.x+e.vx}function QSe(e){return e.y+e.vy}function uxt(e){var t,r,n=1,i=1;typeof e!="function"&&(e=Dn(e==null?1:+e));function o(){for(var l,c=t.length,u,h,f,p,d,g,_=0;_<i;++_)for(u=zh(t,JSe,QSe).visitAfter(a),l=0;l<c;++l)h=t[l],d=r[h.index],g=d*d,f=h.x+h.vx,p=h.y+h.vy,u.visit(y);function y(x,b,S,C,P){var k=x.data,O=x.r,D=d+O;if(k){if(k.index>h.index){var B=f-k.x-k.vx,I=p-k.y-k.vy,L=B*B+I*I;L<D*D&&(B===0&&(B=fu(),L+=B*B),I===0&&(I=fu(),L+=I*I),L=(D-(L=Math.sqrt(L)))/L*n,h.vx+=(B*=L)*(D=(O*=O)/(g+O)),h.vy+=(I*=L)*D,k.vx-=B*(D=1-D),k.vy-=I*D)}return}return b>f+D||C<f-D||S>p+D||P<p-D}}function a(l){if(l.data)return l.r=r[l.data.index];for(var c=l.r=0;c<4;++c)l[c]&&l[c].r>l.r&&(l.r=l[c].r)}function s(){if(!!t){var l,c=t.length,u;for(r=new Array(c),l=0;l<c;++l)u=t[l],r[u.index]=+e(u,l,t)}}return o.initialize=function(l){t=l,s()},o.iterations=function(l){return arguments.length?(i=+l,o):i},o.strength=function(l){return arguments.length?(n=+l,o):n},o.radius=function(l){return arguments.length?(e=typeof l=="function"?l:Dn(+l),s(),o):e},o}Tb();function t3e(e){return e.index}function hxt(e,t){var r=e.get(t);if(!r)throw new Error("missing: "+t);return r}function fxt(e){var t=t3e,r=u,n,i=Dn(30),o,a,s,l,c=1;e==null&&(e=[]);function u(g){return 1/Math.min(s[g.source.index],s[g.target.index])}function h(g){for(var _=0,y=e.length;_<c;++_)for(var x=0,b,S,C,P,k,O,D;x<y;++x)b=e[x],S=b.source,C=b.target,P=C.x+C.vx-S.x-S.vx||fu(),k=C.y+C.vy-S.y-S.vy||fu(),O=Math.sqrt(P*P+k*k),O=(O-o[x])/O*g*n[x],P*=O,k*=O,C.vx-=P*(D=l[x]),C.vy-=k*D,S.vx+=P*(D=1-D),S.vy+=k*D}function f(){if(!!a){var g,_=a.length,y=e.length,x=Ji(a,t),b;for(g=0,s=new Array(_);g<y;++g)b=e[g],b.index=g,typeof b.source!="object"&&(b.source=hxt(x,b.source)),typeof b.target!="object"&&(b.target=hxt(x,b.target)),s[b.source.index]=(s[b.source.index]||0)+1,s[b.target.index]=(s[b.target.index]||0)+1;for(g=0,l=new Array(y);g<y;++g)b=e[g],l[g]=s[b.source.index]/(s[b.source.index]+s[b.target.index]);n=new Array(y),p(),o=new Array(y),d()}}function p(){if(!!a)for(var g=0,_=e.length;g<_;++g)n[g]=+r(e[g],g,e)}function d(){if(!!a)for(var g=0,_=e.length;g<_;++g)o[g]=+i(e[g],g,e)}return h.initialize=function(g){a=g,f()},h.links=function(g){return arguments.length?(e=g,f(),h):e},h.id=function(g){return arguments.length?(t=g,h):t},h.iterations=function(g){return arguments.length?(c=+g,h):c},h.strength=function(g){return arguments.length?(r=typeof g=="function"?g:Dn(+g),p(),h):r},h.distance=function(g){return arguments.length?(i=typeof g=="function"?g:Dn(+g),d(),h):i},h}km();Tb();function pxt(e){return e.x}function dxt(e){return e.y}var e3e=10,r3e=Math.PI*(3-Math.sqrt(5));function mxt(e){var t,r=1,n=.001,i=1-Math.pow(n,1/300),o=0,a=.6,s=Ji(),l=A_(u),c=vs("tick","end");e==null&&(e=[]);function u(){h(),c.call("tick",t),r<n&&(l.stop(),c.call("end",t))}function h(d){var g,_=e.length,y;d===void 0&&(d=1);for(var x=0;x<d;++x)for(r+=(o-r)*i,s.each(function(b){b(r)}),g=0;g<_;++g)y=e[g],y.fx==null?y.x+=y.vx*=a:(y.x=y.fx,y.vx=0),y.fy==null?y.y+=y.vy*=a:(y.y=y.fy,y.vy=0);return t}function f(){for(var d=0,g=e.length,_;d<g;++d){if(_=e[d],_.index=d,_.fx!=null&&(_.x=_.fx),_.fy!=null&&(_.y=_.fy),isNaN(_.x)||isNaN(_.y)){var y=e3e*Math.sqrt(d),x=d*r3e;_.x=y*Math.cos(x),_.y=y*Math.sin(x)}(isNaN(_.vx)||isNaN(_.vy))&&(_.vx=_.vy=0)}}function p(d){return d.initialize&&d.initialize(e),d}return f(),t={tick:h,restart:function(){return l.restart(u),t},stop:function(){return l.stop(),t},nodes:function(d){return arguments.length?(e=d,f(),s.each(p),t):e},alpha:function(d){return arguments.length?(r=+d,t):r},alphaMin:function(d){return arguments.length?(n=+d,t):n},alphaDecay:function(d){return arguments.length?(i=+d,t):+i},alphaTarget:function(d){return arguments.length?(o=+d,t):o},velocityDecay:function(d){return arguments.length?(a=1-d,t):1-a},force:function(d,g){return arguments.length>1?(g==null?s.remove(d):s.set(d,p(g)),t):s.get(d)},find:function(d,g,_){var y=0,x=e.length,b,S,C,P,k;for(_==null?_=1/0:_*=_,y=0;y<x;++y)P=e[y],b=d-P.x,S=g-P.y,C=b*b+S*S,C<_&&(k=P,_=C);return k},on:function(d,g){return arguments.length>1?(c.on(d,g),t):c.on(d)}}}function gxt(){var e,t,r,n=Dn(-30),i,o=1,a=1/0,s=.81;function l(f){var p,d=e.length,g=zh(e,pxt,dxt).visitAfter(u);for(r=f,p=0;p<d;++p)t=e[p],g.visit(h)}function c(){if(!!e){var f,p=e.length,d;for(i=new Array(p),f=0;f<p;++f)d=e[f],i[d.index]=+n(d,f,e)}}function u(f){var p=0,d,g,_=0,y,x,b;if(f.length){for(y=x=b=0;b<4;++b)(d=f[b])&&(g=Math.abs(d.value))&&(p+=d.value,_+=g,y+=g*d.x,x+=g*d.y);f.x=y/_,f.y=x/_}else{d=f,d.x=d.data.x,d.y=d.data.y;do p+=i[d.data.index];while(d=d.next)}f.value=p}function h(f,p,d,g){if(!f.value)return!0;var _=f.x-t.x,y=f.y-t.y,x=g-p,b=_*_+y*y;if(x*x/s<b)return b<a&&(_===0&&(_=fu(),b+=_*_),y===0&&(y=fu(),b+=y*y),b<o&&(b=Math.sqrt(o*b)),t.vx+=_*f.value*r/b,t.vy+=y*f.value*r/b),!0;if(f.length||b>=a)return;(f.data!==t||f.next)&&(_===0&&(_=fu(),b+=_*_),y===0&&(y=fu(),b+=y*y),b<o&&(b=Math.sqrt(o*b)));do f.data!==t&&(x=i[f.data.index]*r/b,t.vx+=_*x,t.vy+=y*x);while(f=f.next)}return l.initialize=function(f){e=f,c()},l.strength=function(f){return arguments.length?(n=typeof f=="function"?f:Dn(+f),c(),l):n},l.distanceMin=function(f){return arguments.length?(o=f*f,l):Math.sqrt(o)},l.distanceMax=function(f){return arguments.length?(a=f*f,l):Math.sqrt(a)},l.theta=function(f){return arguments.length?(s=f*f,l):Math.sqrt(s)},l}function _xt(e,t,r){var n,i=Dn(.1),o,a;typeof e!="function"&&(e=Dn(+e)),t==null&&(t=0),r==null&&(r=0);function s(c){for(var u=0,h=n.length;u<h;++u){var f=n[u],p=f.x-t||1e-6,d=f.y-r||1e-6,g=Math.sqrt(p*p+d*d),_=(a[u]-g)*o[u]*c/g;f.vx+=p*_,f.vy+=d*_}}function l(){if(!!n){var c,u=n.length;for(o=new Array(u),a=new Array(u),c=0;c<u;++c)a[c]=+e(n[c],c,n),o[c]=isNaN(a[c])?0:+i(n[c],c,n)}}return s.initialize=function(c){n=c,l()},s.strength=function(c){return arguments.length?(i=typeof c=="function"?c:Dn(+c),l(),s):i},s.radius=function(c){return arguments.length?(e=typeof c=="function"?c:Dn(+c),l(),s):e},s.x=function(c){return arguments.length?(t=+c,s):t},s.y=function(c){return arguments.length?(r=+c,s):r},s}function yxt(e){var t=Dn(.1),r,n,i;typeof e!="function"&&(e=Dn(e==null?0:+e));function o(s){for(var l=0,c=r.length,u;l<c;++l)u=r[l],u.vx+=(i[l]-u.x)*n[l]*s}function a(){if(!!r){var s,l=r.length;for(n=new Array(l),i=new Array(l),s=0;s<l;++s)n[s]=isNaN(i[s]=+e(r[s],s,r))?0:+t(r[s],s,r)}}return o.initialize=function(s){r=s,a()},o.strength=function(s){return arguments.length?(t=typeof s=="function"?s:Dn(+s),a(),o):t},o.x=function(s){return arguments.length?(e=typeof s=="function"?s:Dn(+s),a(),o):e},o}function vxt(e){var t=Dn(.1),r,n,i;typeof e!="function"&&(e=Dn(e==null?0:+e));function o(s){for(var l=0,c=r.length,u;l<c;++l)u=r[l],u.vy+=(i[l]-u.y)*n[l]*s}function a(){if(!!r){var s,l=r.length;for(n=new Array(l),i=new Array(l),s=0;s<l;++s)n[s]=isNaN(i[s]=+e(r[s],s,r))?0:+t(r[s],s,r)}}return o.initialize=function(s){r=s,a()},o.strength=function(s){return arguments.length?(t=typeof s=="function"?s:Dn(+s),a(),o):t},o.y=function(s){return arguments.length?(e=typeof s=="function"?s:Dn(+s),a(),o):e},o}function xxt(e){return Math.abs(e=Math.round(e))>=1e21?e.toLocaleString("en").replace(/,/g,""):e.toString(10)}function O_(e,t){if((r=(e=t?e.toExponential(t-1):e.toExponential()).indexOf("e"))<0)return null;var r,n=e.slice(0,r);return[n.length>1?n[0]+n.slice(2):n,+e.slice(r+1)]}function Fh(e){return e=O_(Math.abs(e)),e?e[1]:NaN}function bxt(e,t){return function(r,n){for(var i=r.length,o=[],a=0,s=e[0],l=0;i>0&&s>0&&(l+s+1>n&&(s=Math.max(1,n-l)),o.push(r.substring(i-=s,i+s)),!((l+=s+1)>n));)s=e[a=(a+1)%e.length];return o.reverse().join(t)}}function wxt(e){return function(t){return t.replace(/[0-9]/g,function(r){return e[+r]})}}var n3e=/^(?:(.)?([<>=^]))?([+\-( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?(~)?([a-z%])?$/i;function Lp(e){if(!(t=n3e.exec(e)))throw new Error("invalid format: "+e);var t;return new GE({fill:t[1],align:t[2],sign:t[3],symbol:t[4],zero:t[5],width:t[6],comma:t[7],precision:t[8]&&t[8].slice(1),trim:t[9],type:t[10]})}Lp.prototype=GE.prototype;function GE(e){this.fill=e.fill===void 0?" ":e.fill+"",this.align=e.align===void 0?">":e.align+"",this.sign=e.sign===void 0?"-":e.sign+"",this.symbol=e.symbol===void 0?"":e.symbol+"",this.zero=!!e.zero,this.width=e.width===void 0?void 0:+e.width,this.comma=!!e.comma,this.precision=e.precision===void 0?void 0:+e.precision,this.trim=!!e.trim,this.type=e.type===void 0?"":e.type+""}GE.prototype.toString=function(){return this.fill+this.align+this.sign+this.symbol+(this.zero?"0":"")+(this.width===void 0?"":Math.max(1,this.width|0))+(this.comma?",":"")+(this.precision===void 0?"":"."+Math.max(0,this.precision|0))+(this.trim?"~":"")+this.type};function Sxt(e){t:for(var t=e.length,r=1,n=-1,i;r<t;++r)switch(e[r]){case".":n=i=r;break;case"0":n===0&&(n=r),i=r;break;default:if(!+e[r])break t;n>0&&(n=0);break}return n>0?e.slice(0,n)+e.slice(i+1):e}var lj;function Mxt(e,t){var r=O_(e,t);if(!r)return e+"";var n=r[0],i=r[1],o=i-(lj=Math.max(-8,Math.min(8,Math.floor(i/3)))*3)+1,a=n.length;return o===a?n:o>a?n+new Array(o-a+1).join("0"):o>0?n.slice(0,o)+"."+n.slice(o):"0."+new Array(1-o).join("0")+O_(e,Math.max(0,t+o-1))[0]}function cj(e,t){var r=O_(e,t);if(!r)return e+"";var n=r[0],i=r[1];return i<0?"0."+new Array(-i).join("0")+n:n.length>i+1?n.slice(0,i+1)+"."+n.slice(i+1):n+new Array(i-n.length+2).join("0")}var uj={"%":function(e,t){return(e*100).toFixed(t)},b:function(e){return Math.round(e).toString(2)},c:function(e){return e+""},d:xxt,e:function(e,t){return e.toExponential(t)},f:function(e,t){return e.toFixed(t)},g:function(e,t){return e.toPrecision(t)},o:function(e){return Math.round(e).toString(8)},p:function(e,t){return cj(e*100,t)},r:cj,s:Mxt,X:function(e){return Math.round(e).toString(16).toUpperCase()},x:function(e){return Math.round(e).toString(16)}};function hj(e){return e}var Ext=Array.prototype.map,Txt=["y","z","a","f","p","n","\xB5","m","","k","M","G","T","P","E","Z","Y"];function ek(e){var t=e.grouping===void 0||e.thousands===void 0?hj:bxt(Ext.call(e.grouping,Number),e.thousands+""),r=e.currency===void 0?"":e.currency[0]+"",n=e.currency===void 0?"":e.currency[1]+"",i=e.decimal===void 0?".":e.decimal+"",o=e.numerals===void 0?hj:wxt(Ext.call(e.numerals,String)),a=e.percent===void 0?"%":e.percent+"",s=e.minus===void 0?"-":e.minus+"",l=e.nan===void 0?"NaN":e.nan+"";function c(h){h=Lp(h);var f=h.fill,p=h.align,d=h.sign,g=h.symbol,_=h.zero,y=h.width,x=h.comma,b=h.precision,S=h.trim,C=h.type;C==="n"?(x=!0,C="g"):uj[C]||(b===void 0&&(b=12),S=!0,C="g"),(_||f==="0"&&p==="=")&&(_=!0,f="0",p="=");var P=g==="$"?r:g==="#"&&/[boxX]/.test(C)?"0"+C.toLowerCase():"",k=g==="$"?n:/[%p]/.test(C)?a:"",O=uj[C],D=/[defgprs%]/.test(C);b=b===void 0?6:/[gprs]/.test(C)?Math.max(1,Math.min(21,b)):Math.max(0,Math.min(20,b));function B(I){var L=P,R=k,F,z,U;if(C==="c")R=O(I)+R,I="";else{I=+I;var W=I<0||1/I<0;if(I=isNaN(I)?l:O(Math.abs(I),b),S&&(I=Sxt(I)),W&&+I==0&&d!=="+"&&(W=!1),L=(W?d==="("?d:s:d==="-"||d==="("?"":d)+L,R=(C==="s"?Txt[8+lj/3]:"")+R+(W&&d==="("?")":""),D){for(F=-1,z=I.length;++F<z;)if(U=I.charCodeAt(F),48>U||U>57){R=(U===46?i+I.slice(F+1):I.slice(F))+R,I=I.slice(0,F);break}}}x&&!_&&(I=t(I,1/0));var Z=L.length+I.length+R.length,rt=Z<y?new Array(y-Z+1).join(f):"";switch(x&&_&&(I=t(rt+I,rt.length?y-R.length:1/0),rt=""),p){case"<":I=L+I+R+rt;break;case"=":I=L+rt+I+R;break;case"^":I=rt.slice(0,Z=rt.length>>1)+L+I+R+rt.slice(Z);break;default:I=rt+L+I+R;break}return o(I)}return B.toString=function(){return h+""},B}function u(h,f){var p=c((h=Lp(h),h.type="f",h)),d=Math.max(-8,Math.min(8,Math.floor(Fh(f)/3)))*3,g=Math.pow(10,-d),_=Txt[8+d/3];return function(y){return p(g*y)+_}}return{format:c,formatPrefix:u}}var rk,xn,WE;nk({decimal:".",thousands:",",grouping:[3],currency:["$",""],minus:"-"});function nk(e){return rk=ek(e),xn=rk.format,WE=rk.formatPrefix,rk}function ik(e){return Math.max(0,-Fh(Math.abs(e)))}function ok(e,t){return Math.max(0,Math.max(-8,Math.min(8,Math.floor(Fh(t)/3)))*3-Fh(Math.abs(e)))}function ak(e,t){return e=Math.abs(e),t=Math.abs(t)-e,Math.max(0,Fh(t)-Fh(e))+1}function Ss(){return new lk}function lk(){this.reset()}lk.prototype={constructor:lk,reset:function(){this.s=this.t=0},add:function(e){Cxt(sk,e,this.t),Cxt(this,sk.s,this.s),this.s?this.t+=sk.t:this.s=sk.t},valueOf:function(){return this.s}};var sk=new lk;function Cxt(e,t,r){var n=e.s=t+r,i=n-t,o=n-i;e.t=t-o+(r-i)}var le=1e-6,z_=1e-12,Be=Math.PI,mn=Be/2,Pb=Be/4,wi=Be*2,vr=180/Be,ye=Be/180,Re=Math.abs,ic=Math.atan,bn=Math.atan2,Zt=Math.cos,YE=Math.ceil,ck=Math.exp;var F_=Math.log,uk=Math.pow,Xt=Math.sin,ca=Math.sign||function(e){return e>0?1:e<0?-1:0},xr=Math.sqrt,Ib=Math.tan;function hk(e){return e>1?0:e<-1?Be:Math.acos(e)}function wn(e){return e>1?mn:e<-1?-mn:Math.asin(e)}function fj(e){return(e=Xt(e/2))*e}function Fr(){}function fk(e,t){e&&Pxt.hasOwnProperty(e.type)&&Pxt[e.type](e,t)}var Axt={Feature:function(e,t){fk(e.geometry,t)},FeatureCollection:function(e,t){for(var r=e.features,n=-1,i=r.length;++n<i;)fk(r[n].geometry,t)}},Pxt={Sphere:function(e,t){t.sphere()},Point:function(e,t){e=e.coordinates,t.point(e[0],e[1],e[2])},MultiPoint:function(e,t){for(var r=e.coordinates,n=-1,i=r.length;++n<i;)e=r[n],t.point(e[0],e[1],e[2])},LineString:function(e,t){pj(e.coordinates,t,0)},MultiLineString:function(e,t){for(var r=e.coordinates,n=-1,i=r.length;++n<i;)pj(r[n],t,0)},Polygon:function(e,t){Ixt(e.coordinates,t)},MultiPolygon:function(e,t){for(var r=e.coordinates,n=-1,i=r.length;++n<i;)Ixt(r[n],t)},GeometryCollection:function(e,t){for(var r=e.geometries,n=-1,i=r.length;++n<i;)fk(r[n],t)}};function pj(e,t,r){var n=-1,i=e.length-r,o;for(t.lineStart();++n<i;)o=e[n],t.point(o[0],o[1],o[2]);t.lineEnd()}function Ixt(e,t){var r=-1,n=e.length;for(t.polygonStart();++r<n;)pj(e[r],t,1);t.polygonEnd()}function vo(e,t){e&&Axt.hasOwnProperty(e.type)?Axt[e.type](e,t):fk(e,t)}var jE=Ss(),pk=Ss(),Lxt,kxt,dj,mj,gj,pu={point:Fr,lineStart:Fr,lineEnd:Fr,polygonStart:function(){jE.reset(),pu.lineStart=i3e,pu.lineEnd=o3e},polygonEnd:function(){var e=+jE;pk.add(e<0?wi+e:e),this.lineStart=this.lineEnd=this.point=Fr},sphere:function(){pk.add(wi)}};function i3e(){pu.point=a3e}function o3e(){Rxt(Lxt,kxt)}function a3e(e,t){pu.point=Rxt,Lxt=e,kxt=t,e*=ye,t*=ye,dj=e,mj=Zt(t=t/2+Pb),gj=Xt(t)}function Rxt(e,t){e*=ye,t*=ye,t=t/2+Pb;var r=e-dj,n=r>=0?1:-1,i=n*r,o=Zt(t),a=Xt(t),s=gj*a,l=mj*o+s*Zt(i),c=s*n*Xt(i);jE.add(bn(c,l)),dj=e,mj=o,gj=a}function Nxt(e){return pk.reset(),vo(e,pu),pk*2}function B_(e){return[bn(e[1],e[0]),wn(e[2])]}function oc(e){var t=e[0],r=e[1],n=Zt(r);return[n*Zt(t),n*Xt(t),Xt(r)]}function XE(e,t){return e[0]*t[0]+e[1]*t[1]+e[2]*t[2]}function kp(e,t){return[e[1]*t[2]-e[2]*t[1],e[2]*t[0]-e[0]*t[2],e[0]*t[1]-e[1]*t[0]]}function dk(e,t){e[0]+=t[0],e[1]+=t[1],e[2]+=t[2]}function $E(e,t){return[e[0]*t,e[1]*t,e[2]*t]}function H_(e){var t=xr(e[0]*e[0]+e[1]*e[1]+e[2]*e[2]);e[0]/=t,e[1]/=t,e[2]/=t}var ri,Ms,ui,nl,V_,Fxt,Bxt,Lb,KE=Ss(),Ym,Np,Rp={point:_j,lineStart:Dxt,lineEnd:Oxt,polygonStart:function(){Rp.point=Vxt,Rp.lineStart=s3e,Rp.lineEnd=l3e,KE.reset(),pu.polygonStart()},polygonEnd:function(){pu.polygonEnd(),Rp.point=_j,Rp.lineStart=Dxt,Rp.lineEnd=Oxt,jE<0?(ri=-(ui=180),Ms=-(nl=90)):KE>le?nl=90:KE<-le&&(Ms=-90),Np[0]=ri,Np[1]=ui},sphere:function(){ri=-(ui=180),Ms=-(nl=90)}};function _j(e,t){Ym.push(Np=[ri=e,ui=e]),t<Ms&&(Ms=t),t>nl&&(nl=t)}function Hxt(e,t){var r=oc([e*ye,t*ye]);if(Lb){var n=kp(Lb,r),i=[n[1],-n[0],0],o=kp(i,n);H_(o),o=B_(o);var a=e-V_,s=a>0?1:-1,l=o[0]*vr*s,c,u=Re(a)>180;u^(s*V_<l&&l<s*e)?(c=o[1]*vr,c>nl&&(nl=c)):(l=(l+360)%360-180,u^(s*V_<l&&l<s*e)?(c=-o[1]*vr,c<Ms&&(Ms=c)):(t<Ms&&(Ms=t),t>nl&&(nl=t))),u?e<V_?rl(ri,e)>rl(ri,ui)&&(ui=e):rl(e,ui)>rl(ri,ui)&&(ri=e):ui>=ri?(e<ri&&(ri=e),e>ui&&(ui=e)):e>V_?rl(ri,e)>rl(ri,ui)&&(ui=e):rl(e,ui)>rl(ri,ui)&&(ri=e)}else Ym.push(Np=[ri=e,ui=e]);t<Ms&&(Ms=t),t>nl&&(nl=t),Lb=r,V_=e}function Dxt(){Rp.point=Hxt}function Oxt(){Np[0]=ri,Np[1]=ui,Rp.point=_j,Lb=null}function Vxt(e,t){if(Lb){var r=e-V_;KE.add(Re(r)>180?r+(r>0?360:-360):r)}else Fxt=e,Bxt=t;pu.point(e,t),Hxt(e,t)}function s3e(){pu.lineStart()}function l3e(){Vxt(Fxt,Bxt),pu.lineEnd(),Re(KE)>le&&(ri=-(ui=180)),Np[0]=ri,Np[1]=ui,Lb=null}function rl(e,t){return(t-=e)<0?t+360:t}function c3e(e,t){return e[0]-t[0]}function zxt(e,t){return e[0]<=e[1]?e[0]<=t&&t<=e[1]:t<e[0]||e[1]<t}function Uxt(e){var t,r,n,i,o,a,s;if(nl=ui=-(ri=Ms=1/0),Ym=[],vo(e,Rp),r=Ym.length){for(Ym.sort(c3e),t=1,n=Ym[0],o=[n];t<r;++t)i=Ym[t],zxt(n,i[0])||zxt(n,i[1])?(rl(n[0],i[1])>rl(n[0],n[1])&&(n[1]=i[1]),rl(i[0],n[1])>rl(n[0],n[1])&&(n[0]=i[0])):o.push(n=i);for(a=-1/0,r=o.length-1,t=0,n=o[r];t<=r;n=i,++t)i=o[t],(s=rl(n[1],i[0]))>a&&(a=s,ri=i[0],ui=n[1])}return Ym=Np=null,ri===1/0||Ms===1/0?[[NaN,NaN],[NaN,NaN]]:[[ri,Ms],[ui,nl]]}var ZE,mk,gk,_k,yk,vk,xk,bk,yj,vj,xj,Wxt,Yxt,Fa,Ba,Ha,du={sphere:Fr,point:bj,lineStart:qxt,lineEnd:Gxt,polygonStart:function(){du.lineStart=f3e,du.lineEnd=p3e},polygonEnd:function(){du.lineStart=qxt,du.lineEnd=Gxt}};function bj(e,t){e*=ye,t*=ye;var r=Zt(t);JE(r*Zt(e),r*Xt(e),Xt(t))}function JE(e,t,r){++ZE,gk+=(e-gk)/ZE,_k+=(t-_k)/ZE,yk+=(r-yk)/ZE}function qxt(){du.point=u3e}function u3e(e,t){e*=ye,t*=ye;var r=Zt(t);Fa=r*Zt(e),Ba=r*Xt(e),Ha=Xt(t),du.point=h3e,JE(Fa,Ba,Ha)}function h3e(e,t){e*=ye,t*=ye;var r=Zt(t),n=r*Zt(e),i=r*Xt(e),o=Xt(t),a=bn(xr((a=Ba*o-Ha*i)*a+(a=Ha*n-Fa*o)*a+(a=Fa*i-Ba*n)*a),Fa*n+Ba*i+Ha*o);mk+=a,vk+=a*(Fa+(Fa=n)),xk+=a*(Ba+(Ba=i)),bk+=a*(Ha+(Ha=o)),JE(Fa,Ba,Ha)}function Gxt(){du.point=bj}function f3e(){du.point=d3e}function p3e(){jxt(Wxt,Yxt),du.point=bj}function d3e(e,t){Wxt=e,Yxt=t,e*=ye,t*=ye,du.point=jxt;var r=Zt(t);Fa=r*Zt(e),Ba=r*Xt(e),Ha=Xt(t),JE(Fa,Ba,Ha)}function jxt(e,t){e*=ye,t*=ye;var r=Zt(t),n=r*Zt(e),i=r*Xt(e),o=Xt(t),a=Ba*o-Ha*i,s=Ha*n-Fa*o,l=Fa*i-Ba*n,c=xr(a*a+s*s+l*l),u=wn(c),h=c&&-u/c;yj+=h*a,vj+=h*s,xj+=h*l,mk+=u,vk+=u*(Fa+(Fa=n)),xk+=u*(Ba+(Ba=i)),bk+=u*(Ha+(Ha=o)),JE(Fa,Ba,Ha)}function Xxt(e){ZE=mk=gk=_k=yk=vk=xk=bk=yj=vj=xj=0,vo(e,du);var t=yj,r=vj,n=xj,i=t*t+r*r+n*n;return i<z_&&(t=vk,r=xk,n=bk,mk<le&&(t=gk,r=_k,n=yk),i=t*t+r*r+n*n,i<z_)?[NaN,NaN]:[bn(r,t)*vr,wn(n/xr(i))*vr]}function U_(e){return function(){return e}}function QE(e,t){function r(n,i){return n=e(n,i),t(n[0],n[1])}return e.invert&&t.invert&&(r.invert=function(n,i){return n=t.invert(n,i),n&&e.invert(n[0],n[1])}),r}function wj(e,t){return[Re(e)>Be?e+Math.round(-e/wi)*wi:e,t]}wj.invert=wj;function t5(e,t,r){return(e%=wi)?t||r?QE(Kxt(e),Zxt(t,r)):Kxt(e):t||r?Zxt(t,r):wj}function $xt(e){return function(t,r){return t+=e,[t>Be?t-wi:t<-Be?t+wi:t,r]}}function Kxt(e){var t=$xt(e);return t.invert=$xt(-e),t}function Zxt(e,t){var r=Zt(e),n=Xt(e),i=Zt(t),o=Xt(t);function a(s,l){var c=Zt(l),u=Zt(s)*c,h=Xt(s)*c,f=Xt(l),p=f*r+u*n;return[bn(h*i-p*o,u*r-f*n),wn(p*i+h*o)]}return a.invert=function(s,l){var c=Zt(l),u=Zt(s)*c,h=Xt(s)*c,f=Xt(l),p=f*i-h*o;return[bn(h*i+f*o,u*r+p*n),wn(p*r-u*n)]},a}function wk(e){e=t5(e[0]*ye,e[1]*ye,e.length>2?e[2]*ye:0);function t(r){return r=e(r[0]*ye,r[1]*ye),r[0]*=vr,r[1]*=vr,r}return t.invert=function(r){return r=e.invert(r[0]*ye,r[1]*ye),r[0]*=vr,r[1]*=vr,r},t}function Sj(e,t,r,n,i,o){if(!!r){var a=Zt(t),s=Xt(t),l=n*r;i==null?(i=t+n*wi,o=t-l/2):(i=Jxt(a,i),o=Jxt(a,o),(n>0?i<o:i>o)&&(i+=n*wi));for(var c,u=i;n>0?u>o:u<o;u-=l)c=B_([a,-s*Zt(u),-s*Xt(u)]),e.point(c[0],c[1])}}function Jxt(e,t){t=oc(t),t[0]-=e,H_(t);var r=hk(-t[1]);return((-t[2]<0?-r:r)+wi-le)%wi}function Qxt(){var e=U_([0,0]),t=U_(90),r=U_(6),n,i,o={point:a};function a(l,c){n.push(l=i(l,c)),l[0]*=vr,l[1]*=vr}function s(){var l=e.apply(this,arguments),c=t.apply(this,arguments)*ye,u=r.apply(this,arguments)*ye;return n=[],i=t5(-l[0]*ye,-l[1]*ye,0).invert,Sj(o,c,u,1),l={type:"Polygon",coordinates:[n]},n=i=null,l}return s.center=function(l){return arguments.length?(e=typeof l=="function"?l:U_([+l[0],+l[1]]),s):e},s.radius=function(l){return arguments.length?(t=typeof l=="function"?l:U_(+l),s):t},s.precision=function(l){return arguments.length?(r=typeof l=="function"?l:U_(+l),s):r},s}function Sk(){var e=[],t;return{point:function(r,n,i){t.push([r,n,i])},lineStart:function(){e.push(t=[])},lineEnd:Fr,rejoin:function(){e.length>1&&e.push(e.pop().concat(e.shift()))},result:function(){var r=e;return e=[],t=null,r}}}function kb(e,t){return Re(e[0]-t[0])<le&&Re(e[1]-t[1])<le}function Mk(e,t,r,n){this.x=e,this.z=t,this.o=r,this.e=n,this.v=!1,this.n=this.p=null}function Ek(e,t,r,n,i){var o=[],a=[],s,l;if(e.forEach(function(d){if(!((g=d.length-1)<=0)){var g,_=d[0],y=d[g],x;if(kb(_,y)){if(!_[2]&&!y[2]){for(i.lineStart(),s=0;s<g;++s)i.point((_=d[s])[0],_[1]);i.lineEnd();return}y[0]+=2*le}o.push(x=new Mk(_,d,null,!0)),a.push(x.o=new Mk(_,null,x,!1)),o.push(x=new Mk(y,d,null,!1)),a.push(x.o=new Mk(y,null,x,!0))}}),!!o.length){for(a.sort(t),tbt(o),tbt(a),s=0,l=a.length;s<l;++s)a[s].e=r=!r;for(var c=o[0],u,h;;){for(var f=c,p=!0;f.v;)if((f=f.n)===c)return;u=f.z,i.lineStart();do{if(f.v=f.o.v=!0,f.e){if(p)for(s=0,l=u.length;s<l;++s)i.point((h=u[s])[0],h[1]);else n(f.x,f.n.x,1,i);f=f.n}else{if(p)for(u=f.p.z,s=u.length-1;s>=0;--s)i.point((h=u[s])[0],h[1]);else n(f.x,f.p.x,-1,i);f=f.p}f=f.o,u=f.z,p=!p}while(!f.v);i.lineEnd()}}}function tbt(e){if(!!(t=e.length)){for(var t,r=0,n=e[0],i;++r<t;)n.n=i=e[r],i.p=n,n=i;n.n=i=e[0],i.p=n}}var Mj=Ss();function Ej(e){return Re(e[0])<=Be?e[0]:ca(e[0])*((Re(e[0])+Be)%wi-Be)}function Tk(e,t){var r=Ej(t),n=t[1],i=Xt(n),o=[Xt(r),-Zt(r),0],a=0,s=0;Mj.reset(),i===1?n=mn+le:i===-1&&(n=-mn-le);for(var l=0,c=e.length;l<c;++l)if(!!(h=(u=e[l]).length))for(var u,h,f=u[h-1],p=Ej(f),d=f[1]/2+Pb,g=Xt(d),_=Zt(d),y=0;y<h;++y,p=b,g=C,_=P,f=x){var x=u[y],b=Ej(x),S=x[1]/2+Pb,C=Xt(S),P=Zt(S),k=b-p,O=k>=0?1:-1,D=O*k,B=D>Be,I=g*C;if(Mj.add(bn(I*O*Xt(D),_*P+I*Zt(D))),a+=B?k+O*wi:k,B^p>=r^b>=r){var L=kp(oc(f),oc(x));H_(L);var R=kp(o,L);H_(R);var F=(B^k>=0?-1:1)*wn(R[2]);(n>F||n===F&&(L[0]||L[1]))&&(s+=B^k>=0?1:-1)}}return(a<-le||a<le&&Mj<-le)^s&1}function Ck(e,t,r,n){return function(i){var o=t(i),a=Sk(),s=t(a),l=!1,c,u,h,f={point:p,lineStart:g,lineEnd:_,polygonStart:function(){f.point=y,f.lineStart=x,f.lineEnd=b,u=[],c=[]},polygonEnd:function(){f.point=p,f.lineStart=g,f.lineEnd=_,u=Im(u);var S=Tk(c,n);u.length?(l||(i.polygonStart(),l=!0),Ek(u,g3e,S,r,i)):S&&(l||(i.polygonStart(),l=!0),i.lineStart(),r(null,null,1,i),i.lineEnd()),l&&(i.polygonEnd(),l=!1),u=c=null},sphere:function(){i.polygonStart(),i.lineStart(),r(null,null,1,i),i.lineEnd(),i.polygonEnd()}};function p(S,C){e(S,C)&&i.point(S,C)}function d(S,C){o.point(S,C)}function g(){f.point=d,o.lineStart()}function _(){f.point=p,o.lineEnd()}function y(S,C){h.push([S,C]),s.point(S,C)}function x(){s.lineStart(),h=[]}function b(){y(h[0][0],h[0][1]),s.lineEnd();var S=s.clean(),C=a.result(),P,k=C.length,O,D,B;if(h.pop(),c.push(h),h=null,!!k){if(S&1){if(D=C[0],(O=D.length-1)>0){for(l||(i.polygonStart(),l=!0),i.lineStart(),P=0;P<O;++P)i.point((B=D[P])[0],B[1]);i.lineEnd()}return}k>1&&S&2&&C.push(C.pop().concat(C.shift())),u.push(C.filter(m3e))}}return f}}function m3e(e){return e.length>1}function g3e(e,t){return((e=e.x)[0]<0?e[1]-mn-le:mn-e[1])-((t=t.x)[0]<0?t[1]-mn-le:mn-t[1])}var e5=Ck(function(){return!0},_3e,v3e,[-Be,-mn]);function _3e(e){var t=NaN,r=NaN,n=NaN,i;return{lineStart:function(){e.lineStart(),i=1},point:function(o,a){var s=o>0?Be:-Be,l=Re(o-t);Re(l-Be)<le?(e.point(t,r=(r+a)/2>0?mn:-mn),e.point(n,r),e.lineEnd(),e.lineStart(),e.point(s,r),e.point(o,r),i=0):n!==s&&l>=Be&&(Re(t-n)<le&&(t-=n*le),Re(o-s)<le&&(o-=s*le),r=y3e(t,r,o,a),e.point(n,r),e.lineEnd(),e.lineStart(),e.point(s,r),i=0),e.point(t=o,r=a),n=s},lineEnd:function(){e.lineEnd(),t=r=NaN},clean:function(){return 2-i}}}function y3e(e,t,r,n){var i,o,a=Xt(e-r);return Re(a)>le?ic((Xt(t)*(o=Zt(n))*Xt(r)-Xt(n)*(i=Zt(t))*Xt(e))/(i*o*a)):(t+n)/2}function v3e(e,t,r,n){var i;if(e==null)i=r*mn,n.point(-Be,i),n.point(0,i),n.point(Be,i),n.point(Be,0),n.point(Be,-i),n.point(0,-i),n.point(-Be,-i),n.point(-Be,0),n.point(-Be,i);else if(Re(e[0]-t[0])>le){var o=e[0]<t[0]?Be:-Be;i=r*o/2,n.point(-o,i),n.point(0,i),n.point(o,i)}else n.point(t[0],t[1])}function Ak(e){var t=Zt(e),r=6*ye,n=t>0,i=Re(t)>le;function o(u,h,f,p){Sj(p,e,r,f,u,h)}function a(u,h){return Zt(u)*Zt(h)>t}function s(u){var h,f,p,d,g;return{lineStart:function(){d=p=!1,g=1},point:function(_,y){var x=[_,y],b,S=a(_,y),C=n?S?0:c(_,y):S?c(_+(_<0?Be:-Be),y):0;if(!h&&(d=p=S)&&u.lineStart(),S!==p&&(b=l(h,x),(!b||kb(h,b)||kb(x,b))&&(x[2]=1)),S!==p)g=0,S?(u.lineStart(),b=l(x,h),u.point(b[0],b[1])):(b=l(h,x),u.point(b[0],b[1],2),u.lineEnd()),h=b;else if(i&&h&&n^S){var P;!(C&f)&&(P=l(x,h,!0))&&(g=0,n?(u.lineStart(),u.point(P[0][0],P[0][1]),u.point(P[1][0],P[1][1]),u.lineEnd()):(u.point(P[1][0],P[1][1]),u.lineEnd(),u.lineStart(),u.point(P[0][0],P[0][1],3)))}S&&(!h||!kb(h,x))&&u.point(x[0],x[1]),h=x,p=S,f=C},lineEnd:function(){p&&u.lineEnd(),h=null},clean:function(){return g|(d&&p)<<1}}}function l(u,h,f){var p=oc(u),d=oc(h),g=[1,0,0],_=kp(p,d),y=XE(_,_),x=_[0],b=y-x*x;if(!b)return!f&&u;var S=t*y/b,C=-t*x/b,P=kp(g,_),k=$E(g,S),O=$E(_,C);dk(k,O);var D=P,B=XE(k,D),I=XE(D,D),L=B*B-I*(XE(k,k)-1);if(!(L<0)){var R=xr(L),F=$E(D,(-B-R)/I);if(dk(F,k),F=B_(F),!f)return F;var z=u[0],U=h[0],W=u[1],Z=h[1],rt;U<z&&(rt=z,z=U,U=rt);var ot=U-z,st=Re(ot-Be)<le,St=st||ot<le;if(!st&&Z<W&&(rt=W,W=Z,Z=rt),St?st?W+Z>0^F[1]<(Re(F[0]-z)<le?W:Z):W<=F[1]&&F[1]<=Z:ot>Be^(z<=F[0]&&F[0]<=U)){var bt=$E(D,(-B+R)/I);return dk(bt,k),[F,B_(bt)]}}}function c(u,h){var f=n?e:Be-e,p=0;return u<-f?p|=1:u>f&&(p|=2),h<-f?p|=4:h>f&&(p|=8),p}return Ck(a,s,o,n?[0,-e]:[-Be,e-Be])}function ebt(e,t,r,n,i,o){var a=e[0],s=e[1],l=t[0],c=t[1],u=0,h=1,f=l-a,p=c-s,d;if(d=r-a,!(!f&&d>0)){if(d/=f,f<0){if(d<u)return;d<h&&(h=d)}else if(f>0){if(d>h)return;d>u&&(u=d)}if(d=i-a,!(!f&&d<0)){if(d/=f,f<0){if(d>h)return;d>u&&(u=d)}else if(f>0){if(d<u)return;d<h&&(h=d)}if(d=n-s,!(!p&&d>0)){if(d/=p,p<0){if(d<u)return;d<h&&(h=d)}else if(p>0){if(d>h)return;d>u&&(u=d)}if(d=o-s,!(!p&&d<0)){if(d/=p,p<0){if(d>h)return;d>u&&(u=d)}else if(p>0){if(d<u)return;d<h&&(h=d)}return u>0&&(e[0]=a+u*f,e[1]=s+u*p),h<1&&(t[0]=a+h*f,t[1]=s+h*p),!0}}}}}var r5=1e9,Pk=-r5;function Dp(e,t,r,n){function i(c,u){return e<=c&&c<=r&&t<=u&&u<=n}function o(c,u,h,f){var p=0,d=0;if(c==null||(p=a(c,h))!==(d=a(u,h))||l(c,u)<0^h>0)do f.point(p===0||p===3?e:r,p>1?n:t);while((p=(p+h+4)%4)!==d);else f.point(u[0],u[1])}function a(c,u){return Re(c[0]-e)<le?u>0?0:3:Re(c[0]-r)<le?u>0?2:1:Re(c[1]-t)<le?u>0?1:0:u>0?3:2}function s(c,u){return l(c.x,u.x)}function l(c,u){var h=a(c,1),f=a(u,1);return h!==f?h-f:h===0?u[1]-c[1]:h===1?c[0]-u[0]:h===2?c[1]-u[1]:u[0]-c[0]}return function(c){var u=c,h=Sk(),f,p,d,g,_,y,x,b,S,C,P,k={point:O,lineStart:L,lineEnd:R,polygonStart:B,polygonEnd:I};function O(z,U){i(z,U)&&u.point(z,U)}function D(){for(var z=0,U=0,W=p.length;U<W;++U)for(var Z=p[U],rt=1,ot=Z.length,st=Z[0],St,bt,Mt=st[0],lt=st[1];rt<ot;++rt)St=Mt,bt=lt,st=Z[rt],Mt=st[0],lt=st[1],bt<=n?lt>n&&(Mt-St)*(n-bt)>(lt-bt)*(e-St)&&++z:lt<=n&&(Mt-St)*(n-bt)<(lt-bt)*(e-St)&&--z;return z}function B(){u=h,f=[],p=[],P=!0}function I(){var z=D(),U=P&&z,W=(f=Im(f)).length;(U||W)&&(c.polygonStart(),U&&(c.lineStart(),o(null,null,1,c),c.lineEnd()),W&&Ek(f,s,z,o,c),c.polygonEnd()),u=c,f=p=d=null}function L(){k.point=F,p&&p.push(d=[]),C=!0,S=!1,x=b=NaN}function R(){f&&(F(g,_),y&&S&&h.rejoin(),f.push(h.result())),k.point=O,S&&u.lineEnd()}function F(z,U){var W=i(z,U);if(p&&d.push([z,U]),C)g=z,_=U,y=W,C=!1,W&&(u.lineStart(),u.point(z,U));else if(W&&S)u.point(z,U);else{var Z=[x=Math.max(Pk,Math.min(r5,x)),b=Math.max(Pk,Math.min(r5,b))],rt=[z=Math.max(Pk,Math.min(r5,z)),U=Math.max(Pk,Math.min(r5,U))];ebt(Z,rt,e,t,r,n)?(S||(u.lineStart(),u.point(Z[0],Z[1])),u.point(rt[0],rt[1]),W||u.lineEnd(),P=!1):W&&(u.lineStart(),u.point(z,U),P=!1)}x=z,b=U,S=W}return k}}function rbt(){var e=0,t=0,r=960,n=500,i,o,a;return a={stream:function(s){return i&&o===s?i:i=Dp(e,t,r,n)(o=s)},extent:function(s){return arguments.length?(e=+s[0][0],t=+s[0][1],r=+s[1][0],n=+s[1][1],i=o=null,a):[[e,t],[r,n]]}}}var Tj=Ss(),Cj,Ik,Lk,Rb={sphere:Fr,point:Fr,lineStart:x3e,lineEnd:Fr,polygonStart:Fr,polygonEnd:Fr};function x3e(){Rb.point=w3e,Rb.lineEnd=b3e}function b3e(){Rb.point=Rb.lineEnd=Fr}function w3e(e,t){e*=ye,t*=ye,Cj=e,Ik=Xt(t),Lk=Zt(t),Rb.point=S3e}function S3e(e,t){e*=ye,t*=ye;var r=Xt(t),n=Zt(t),i=Re(e-Cj),o=Zt(i),a=Xt(i),s=n*a,l=Lk*r-Ik*n*o,c=Ik*r+Lk*n*o;Tj.add(bn(xr(s*s+l*l),c)),Cj=e,Ik=r,Lk=n}function kk(e){return Tj.reset(),vo(e,Rb),+Tj}var Aj=[null,null],M3e={type:"LineString",coordinates:Aj};function Nb(e,t){return Aj[0]=e,Aj[1]=t,kk(M3e)}var nbt={Feature:function(e,t){return Rk(e.geometry,t)},FeatureCollection:function(e,t){for(var r=e.features,n=-1,i=r.length;++n<i;)if(Rk(r[n].geometry,t))return!0;return!1}},ibt={Sphere:function(){return!0},Point:function(e,t){return obt(e.coordinates,t)},MultiPoint:function(e,t){for(var r=e.coordinates,n=-1,i=r.length;++n<i;)if(obt(r[n],t))return!0;return!1},LineString:function(e,t){return abt(e.coordinates,t)},MultiLineString:function(e,t){for(var r=e.coordinates,n=-1,i=r.length;++n<i;)if(abt(r[n],t))return!0;return!1},Polygon:function(e,t){return sbt(e.coordinates,t)},MultiPolygon:function(e,t){for(var r=e.coordinates,n=-1,i=r.length;++n<i;)if(sbt(r[n],t))return!0;return!1},GeometryCollection:function(e,t){for(var r=e.geometries,n=-1,i=r.length;++n<i;)if(Rk(r[n],t))return!0;return!1}};function Rk(e,t){return e&&ibt.hasOwnProperty(e.type)?ibt[e.type](e,t):!1}function obt(e,t){return Nb(e,t)===0}function abt(e,t){for(var r,n,i,o=0,a=e.length;o<a;o++){if(n=Nb(e[o],t),n===0||o>0&&(i=Nb(e[o],e[o-1]),i>0&&r<=i&&n<=i&&(r+n-i)*(1-Math.pow((r-n)/i,2))<z_*i))return!0;r=n}return!1}function sbt(e,t){return!!Tk(e.map(E3e),lbt(t))}function E3e(e){return e=e.map(lbt),e.pop(),e}function lbt(e){return[e[0]*ye,e[1]*ye]}function cbt(e,t){return(e&&nbt.hasOwnProperty(e.type)?nbt[e.type]:Rk)(e,t)}function ubt(e,t,r){var n=Ir(e,t-le,r).concat(t);return function(i){return n.map(function(o){return[i,o]})}}function hbt(e,t,r){var n=Ir(e,t-le,r).concat(t);return function(i){return n.map(function(o){return[o,i]})}}function Nk(){var e,t,r,n,i,o,a,s,l=10,c=l,u=90,h=360,f,p,d,g,_=2.5;function y(){return{type:"MultiLineString",coordinates:x()}}function x(){return Ir(YE(n/u)*u,r,u).map(d).concat(Ir(YE(s/h)*h,a,h).map(g)).concat(Ir(YE(t/l)*l,e,l).filter(function(b){return Re(b%u)>le}).map(f)).concat(Ir(YE(o/c)*c,i,c).filter(function(b){return Re(b%h)>le}).map(p))}return y.lines=function(){return x().map(function(b){return{type:"LineString",coordinates:b}})},y.outline=function(){return{type:"Polygon",coordinates:[d(n).concat(g(a).slice(1),d(r).reverse().slice(1),g(s).reverse().slice(1))]}},y.extent=function(b){return arguments.length?y.extentMajor(b).extentMinor(b):y.extentMinor()},y.extentMajor=function(b){return arguments.length?(n=+b[0][0],r=+b[1][0],s=+b[0][1],a=+b[1][1],n>r&&(b=n,n=r,r=b),s>a&&(b=s,s=a,a=b),y.precision(_)):[[n,s],[r,a]]},y.extentMinor=function(b){return arguments.length?(t=+b[0][0],e=+b[1][0],o=+b[0][1],i=+b[1][1],t>e&&(b=t,t=e,e=b),o>i&&(b=o,o=i,i=b),y.precision(_)):[[t,o],[e,i]]},y.step=function(b){return arguments.length?y.stepMajor(b).stepMinor(b):y.stepMinor()},y.stepMajor=function(b){return arguments.length?(u=+b[0],h=+b[1],y):[u,h]},y.stepMinor=function(b){return arguments.length?(l=+b[0],c=+b[1],y):[l,c]},y.precision=function(b){return arguments.length?(_=+b,f=ubt(o,i,90),p=hbt(t,e,_),d=ubt(s,a,90),g=hbt(n,r,_),y):_},y.extentMajor([[-180,-90+le],[180,90-le]]).extentMinor([[-180,-80-le],[180,80+le]])}function fbt(){return Nk()()}function pbt(e,t){var r=e[0]*ye,n=e[1]*ye,i=t[0]*ye,o=t[1]*ye,a=Zt(n),s=Xt(n),l=Zt(o),c=Xt(o),u=a*Zt(r),h=a*Xt(r),f=l*Zt(i),p=l*Xt(i),d=2*wn(xr(fj(o-n)+a*l*fj(i-r))),g=Xt(d),_=d?function(y){var x=Xt(y*=d)/g,b=Xt(d-y)/g,S=b*u+x*f,C=b*h+x*p,P=b*s+x*c;return[bn(C,S)*vr,bn(P,xr(S*S+C*C))*vr]}:function(){return[r*vr,n*vr]};return _.distance=d,_}function jm(e){return e}var Pj=Ss(),Ij=Ss(),dbt,mbt,Lj,kj,Xm={point:Fr,lineStart:Fr,lineEnd:Fr,polygonStart:function(){Xm.lineStart=T3e,Xm.lineEnd=A3e},polygonEnd:function(){Xm.lineStart=Xm.lineEnd=Xm.point=Fr,Pj.add(Re(Ij)),Ij.reset()},result:function(){var e=Pj/2;return Pj.reset(),e}};function T3e(){Xm.point=C3e}function C3e(e,t){Xm.point=gbt,dbt=Lj=e,mbt=kj=t}function gbt(e,t){Ij.add(kj*e-Lj*t),Lj=e,kj=t}function A3e(){gbt(dbt,mbt)}var Rj=Xm;var Db=1/0,Dk=Db,n5=-Db,Ok=n5,P3e={point:I3e,lineStart:Fr,lineEnd:Fr,polygonStart:Fr,polygonEnd:Fr,result:function(){var e=[[Db,Dk],[n5,Ok]];return n5=Ok=-(Dk=Db=1/0),e}};function I3e(e,t){e<Db&&(Db=e),e>n5&&(n5=e),t<Dk&&(Dk=t),t>Ok&&(Ok=t)}var Ob=P3e;var Nj=0,Dj=0,i5=0,zk=0,Fk=0,zb=0,Oj=0,zj=0,o5=0,vbt,xbt,Bh,Hh,mu={point:q_,lineStart:_bt,lineEnd:ybt,polygonStart:function(){mu.lineStart=R3e,mu.lineEnd=N3e},polygonEnd:function(){mu.point=q_,mu.lineStart=_bt,mu.lineEnd=ybt},result:function(){var e=o5?[Oj/o5,zj/o5]:zb?[zk/zb,Fk/zb]:i5?[Nj/i5,Dj/i5]:[NaN,NaN];return Nj=Dj=i5=zk=Fk=zb=Oj=zj=o5=0,e}};function q_(e,t){Nj+=e,Dj+=t,++i5}function _bt(){mu.point=L3e}function L3e(e,t){mu.point=k3e,q_(Bh=e,Hh=t)}function k3e(e,t){var r=e-Bh,n=t-Hh,i=xr(r*r+n*n);zk+=i*(Bh+e)/2,Fk+=i*(Hh+t)/2,zb+=i,q_(Bh=e,Hh=t)}function ybt(){mu.point=q_}function R3e(){mu.point=D3e}function N3e(){bbt(vbt,xbt)}function D3e(e,t){mu.point=bbt,q_(vbt=Bh=e,xbt=Hh=t)}function bbt(e,t){var r=e-Bh,n=t-Hh,i=xr(r*r+n*n);zk+=i*(Bh+e)/2,Fk+=i*(Hh+t)/2,zb+=i,i=Hh*e-Bh*t,Oj+=i*(Bh+e),zj+=i*(Hh+t),o5+=i*3,q_(Bh=e,Hh=t)}var Fj=mu;function Bk(e){this._context=e}Bk.prototype={_radius:4.5,pointRadius:function(e){return this._radius=e,this},polygonStart:function(){this._line=0},polygonEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){this._line===0&&this._context.closePath(),this._point=NaN},point:function(e,t){switch(this._point){case 0:{this._context.moveTo(e,t),this._point=1;break}case 1:{this._context.lineTo(e,t);break}default:{this._context.moveTo(e+this._radius,t),this._context.arc(e,t,this._radius,0,wi);break}}},result:Fr};var Hj=Ss(),Bj,wbt,Sbt,a5,s5,Hk={point:Fr,lineStart:function(){Hk.point=O3e},lineEnd:function(){Bj&&Mbt(wbt,Sbt),Hk.point=Fr},polygonStart:function(){Bj=!0},polygonEnd:function(){Bj=null},result:function(){var e=+Hj;return Hj.reset(),e}};function O3e(e,t){Hk.point=Mbt,wbt=a5=e,Sbt=s5=t}function Mbt(e,t){a5-=e,s5-=t,Hj.add(xr(a5*a5+s5*s5)),a5=e,s5=t}var Vj=Hk;function Vk(){this._string=[]}Vk.prototype={_radius:4.5,_circle:Ebt(4.5),pointRadius:function(e){return(e=+e)!==this._radius&&(this._radius=e,this._circle=null),this},polygonStart:function(){this._line=0},polygonEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){this._line===0&&this._string.push("Z"),this._point=NaN},point:function(e,t){switch(this._point){case 0:{this._string.push("M",e,",",t),this._point=1;break}case 1:{this._string.push("L",e,",",t);break}default:{this._circle==null&&(this._circle=Ebt(this._radius)),this._string.push("M",e,",",t,this._circle);break}}},result:function(){if(this._string.length){var e=this._string.join("");return this._string=[],e}else return null}};function Ebt(e){return"m0,"+e+"a"+e+","+e+" 0 1,1 0,"+-2*e+"a"+e+","+e+" 0 1,1 0,"+2*e+"z"}function Tbt(e,t){var r=4.5,n,i;function o(a){return a&&(typeof r=="function"&&i.pointRadius(+r.apply(this,arguments)),vo(a,n(i))),i.result()}return o.area=function(a){return vo(a,n(Rj)),Rj.result()},o.measure=function(a){return vo(a,n(Vj)),Vj.result()},o.bounds=function(a){return vo(a,n(Ob)),Ob.result()},o.centroid=function(a){return vo(a,n(Fj)),Fj.result()},o.projection=function(a){return arguments.length?(n=a==null?(e=null,jm):(e=a).stream,o):e},o.context=function(a){return arguments.length?(i=a==null?(t=null,new Vk):new Bk(t=a),typeof r!="function"&&i.pointRadius(r),o):t},o.pointRadius=function(a){return arguments.length?(r=typeof a=="function"?a:(i.pointRadius(+a),+a),o):r},o.projection(e).context(t)}function Cbt(e){return{stream:$m(e)}}function $m(e){return function(t){var r=new Uj;for(var n in e)r[n]=e[n];return r.stream=t,r}}function Uj(){}Uj.prototype={constructor:Uj,point:function(e,t){this.stream.point(e,t)},sphere:function(){this.stream.sphere()},lineStart:function(){this.stream.lineStart()},lineEnd:function(){this.stream.lineEnd()},polygonStart:function(){this.stream.polygonStart()},polygonEnd:function(){this.stream.polygonEnd()}};function qj(e,t,r){var n=e.clipExtent&&e.clipExtent();return e.scale(150).translate([0,0]),n!=null&&e.clipExtent(null),vo(r,e.stream(Ob)),t(Ob.result()),n!=null&&e.clipExtent(n),e}function G_(e,t,r){return qj(e,function(n){var i=t[1][0]-t[0][0],o=t[1][1]-t[0][1],a=Math.min(i/(n[1][0]-n[0][0]),o/(n[1][1]-n[0][1])),s=+t[0][0]+(i-a*(n[1][0]+n[0][0]))/2,l=+t[0][1]+(o-a*(n[1][1]+n[0][1]))/2;e.scale(150*a).translate([s,l])},r)}function Fb(e,t,r){return G_(e,[[0,0],t],r)}function Bb(e,t,r){return qj(e,function(n){var i=+t,o=i/(n[1][0]-n[0][0]),a=(i-o*(n[1][0]+n[0][0]))/2,s=-o*n[0][1];e.scale(150*o).translate([a,s])},r)}function Hb(e,t,r){return qj(e,function(n){var i=+t,o=i/(n[1][1]-n[0][1]),a=-o*n[0][0],s=(i-o*(n[1][1]+n[0][1]))/2;e.scale(150*o).translate([a,s])},r)}var Abt=16,z3e=Zt(30*ye);function Gj(e,t){return+t?B3e(e,t):F3e(e)}function F3e(e){return $m({point:function(t,r){t=e(t,r),this.stream.point(t[0],t[1])}})}function B3e(e,t){function r(n,i,o,a,s,l,c,u,h,f,p,d,g,_){var y=c-n,x=u-i,b=y*y+x*x;if(b>4*t&&g--){var S=a+f,C=s+p,P=l+d,k=xr(S*S+C*C+P*P),O=wn(P/=k),D=Re(Re(P)-1)<le||Re(o-h)<le?(o+h)/2:bn(C,S),B=e(D,O),I=B[0],L=B[1],R=I-n,F=L-i,z=x*R-y*F;(z*z/b>t||Re((y*R+x*F)/b-.5)>.3||a*f+s*p+l*d<z3e)&&(r(n,i,o,a,s,l,I,L,D,S/=k,C/=k,P,g,_),_.point(I,L),r(I,L,D,S,C,P,c,u,h,f,p,d,g,_))}}return function(n){var i,o,a,s,l,c,u,h,f,p,d,g,_={point:y,lineStart:x,lineEnd:S,polygonStart:function(){n.polygonStart(),_.lineStart=C},polygonEnd:function(){n.polygonEnd(),_.lineStart=x}};function y(O,D){O=e(O,D),n.point(O[0],O[1])}function x(){h=NaN,_.point=b,n.lineStart()}function b(O,D){var B=oc([O,D]),I=e(O,D);r(h,f,u,p,d,g,h=I[0],f=I[1],u=O,p=B[0],d=B[1],g=B[2],Abt,n),n.point(h,f)}function S(){_.point=y,n.lineEnd()}function C(){x(),_.point=P,_.lineEnd=k}function P(O,D){b(i=O,D),o=h,a=f,s=p,l=d,c=g,_.point=b}function k(){r(h,f,u,p,d,g,o,a,i,s,l,c,Abt,n),_.lineEnd=S,S()}return _}}var H3e=$m({point:function(e,t){this.stream.point(e*ye,t*ye)}});function V3e(e){return $m({point:function(t,r){var n=e(t,r);return this.stream.point(n[0],n[1])}})}function U3e(e,t,r,n,i){function o(a,s){return a*=n,s*=i,[t+e*a,r-e*s]}return o.invert=function(a,s){return[(a-t)/e*n,(r-s)/e*i]},o}function Pbt(e,t,r,n,i,o){var a=Zt(o),s=Xt(o),l=a*e,c=s*e,u=a/e,h=s/e,f=(s*r-a*t)/e,p=(s*t+a*r)/e;function d(g,_){return g*=n,_*=i,[l*g-c*_+t,r-c*g-l*_]}return d.invert=function(g,_){return[n*(u*g-h*_+f),i*(p-h*g-u*_)]},d}function Si(e){return l5(function(){return e})()}function l5(e){var t,r=150,n=480,i=250,o=0,a=0,s=0,l=0,c=0,u,h=0,f=1,p=1,d=null,g=e5,_=null,y,x,b,S=jm,C=.5,P,k,O,D,B;function I(z){return O(z[0]*ye,z[1]*ye)}function L(z){return z=O.invert(z[0],z[1]),z&&[z[0]*vr,z[1]*vr]}I.stream=function(z){return D&&B===z?D:D=H3e(V3e(u)(g(P(S(B=z)))))},I.preclip=function(z){return arguments.length?(g=z,d=void 0,F()):g},I.postclip=function(z){return arguments.length?(S=z,_=y=x=b=null,F()):S},I.clipAngle=function(z){return arguments.length?(g=+z?Ak(d=z*ye):(d=null,e5),F()):d*vr},I.clipExtent=function(z){return arguments.length?(S=z==null?(_=y=x=b=null,jm):Dp(_=+z[0][0],y=+z[0][1],x=+z[1][0],b=+z[1][1]),F()):_==null?null:[[_,y],[x,b]]},I.scale=function(z){return arguments.length?(r=+z,R()):r},I.translate=function(z){return arguments.length?(n=+z[0],i=+z[1],R()):[n,i]},I.center=function(z){return arguments.length?(o=z[0]%360*ye,a=z[1]%360*ye,R()):[o*vr,a*vr]},I.rotate=function(z){return arguments.length?(s=z[0]%360*ye,l=z[1]%360*ye,c=z.length>2?z[2]%360*ye:0,R()):[s*vr,l*vr,c*vr]},I.angle=function(z){return arguments.length?(h=z%360*ye,R()):h*vr},I.reflectX=function(z){return arguments.length?(f=z?-1:1,R()):f<0},I.reflectY=function(z){return arguments.length?(p=z?-1:1,R()):p<0},I.precision=function(z){return arguments.length?(P=Gj(k,C=z*z),F()):xr(C)},I.fitExtent=function(z,U){return G_(I,z,U)},I.fitSize=function(z,U){return Fb(I,z,U)},I.fitWidth=function(z,U){return Bb(I,z,U)},I.fitHeight=function(z,U){return Hb(I,z,U)};function R(){var z=Pbt(r,0,0,f,p,h).apply(null,t(o,a)),U=(h?Pbt:U3e)(r,n-z[0],i-z[1],f,p,h);return u=t5(s,l,c),k=QE(t,U),O=QE(u,k),P=Gj(k,C),F()}function F(){return D=B=null,I}return function(){return t=e.apply(this,arguments),I.invert=t.invert&&L,R()}}function Vb(e){var t=0,r=Be/3,n=l5(e),i=n(t,r);return i.parallels=function(o){return arguments.length?n(t=o[0]*ye,r=o[1]*ye):[t*vr,r*vr]},i}function Ibt(e){var t=Zt(e);function r(n,i){return[n*t,Xt(i)/t]}return r.invert=function(n,i){return[n/t,wn(i*t)]},r}function Wj(e,t){var r=Xt(e),n=(r+Xt(t))/2;if(Re(n)<le)return Ibt(e);var i=1+r*(2*n-r),o=xr(i)/n;function a(s,l){var c=xr(i-2*n*Xt(l))/n;return[c*Xt(s*=n),o-c*Zt(s)]}return a.invert=function(s,l){var c=o-l,u=bn(s,Re(c))*ca(c);return c*n<0&&(u-=Be*ca(s)*ca(c)),[u/n,wn((i-(s*s+c*c)*n*n)/(2*n))]},a}function W_(){return Vb(Wj).scale(155.424).center([0,33.6442])}function Uk(){return W_().parallels([29.5,45.5]).scale(1070).translate([480,250]).rotate([96,0]).center([-.6,38.7])}function q3e(e){var t=e.length;return{point:function(r,n){for(var i=-1;++i<t;)e[i].point(r,n)},sphere:function(){for(var r=-1;++r<t;)e[r].sphere()},lineStart:function(){for(var r=-1;++r<t;)e[r].lineStart()},lineEnd:function(){for(var r=-1;++r<t;)e[r].lineEnd()},polygonStart:function(){for(var r=-1;++r<t;)e[r].polygonStart()},polygonEnd:function(){for(var r=-1;++r<t;)e[r].polygonEnd()}}}function Lbt(){var e,t,r=Uk(),n,i=W_().rotate([154,0]).center([-2,58.5]).parallels([55,65]),o,a=W_().rotate([157,0]).center([-3,19.9]).parallels([8,18]),s,l,c={point:function(f,p){l=[f,p]}};function u(f){var p=f[0],d=f[1];return l=null,n.point(p,d),l||(o.point(p,d),l)||(s.point(p,d),l)}u.invert=function(f){var p=r.scale(),d=r.translate(),g=(f[0]-d[0])/p,_=(f[1]-d[1])/p;return(_>=.12&&_<.234&&g>=-.425&&g<-.214?i:_>=.166&&_<.234&&g>=-.214&&g<-.115?a:r).invert(f)},u.stream=function(f){return e&&t===f?e:e=q3e([r.stream(t=f),i.stream(f),a.stream(f)])},u.precision=function(f){return arguments.length?(r.precision(f),i.precision(f),a.precision(f),h()):r.precision()},u.scale=function(f){return arguments.length?(r.scale(f),i.scale(f*.35),a.scale(f),u.translate(r.translate())):r.scale()},u.translate=function(f){if(!arguments.length)return r.translate();var p=r.scale(),d=+f[0],g=+f[1];return n=r.translate(f).clipExtent([[d-.455*p,g-.238*p],[d+.455*p,g+.238*p]]).stream(c),o=i.translate([d-.307*p,g+.201*p]).clipExtent([[d-.425*p+le,g+.12*p+le],[d-.214*p-le,g+.234*p-le]]).stream(c),s=a.translate([d-.205*p,g+.212*p]).clipExtent([[d-.214*p+le,g+.166*p+le],[d-.115*p-le,g+.234*p-le]]).stream(c),h()},u.fitExtent=function(f,p){return G_(u,f,p)},u.fitSize=function(f,p){return Fb(u,f,p)},u.fitWidth=function(f,p){return Bb(u,f,p)},u.fitHeight=function(f,p){return Hb(u,f,p)};function h(){return e=t=null,u}return u.scale(1070)}function qk(e){return function(t,r){var n=Zt(t),i=Zt(r),o=e(n*i);return[o*i*Xt(t),o*Xt(r)]}}function Vh(e){return function(t,r){var n=xr(t*t+r*r),i=e(n),o=Xt(i),a=Zt(i);return[bn(t*o,n*a),wn(n&&r*o/n)]}}var Gk=qk(function(e){return xr(2/(1+e))});Gk.invert=Vh(function(e){return 2*wn(e/2)});function kbt(){return Si(Gk).scale(124.75).clipAngle(180-.001)}var Wk=qk(function(e){return(e=hk(e))&&e/Xt(e)});Wk.invert=Vh(function(e){return e});function Rbt(){return Si(Wk).scale(79.4188).clipAngle(180-.001)}function Y_(e,t){return[e,F_(Ib((mn+t)/2))]}Y_.invert=function(e,t){return[e,2*ic(ck(t))-mn]};function Nbt(){return Yj(Y_).scale(961/wi)}function Yj(e){var t=Si(e),r=t.center,n=t.scale,i=t.translate,o=t.clipExtent,a=null,s,l,c;t.scale=function(h){return arguments.length?(n(h),u()):n()},t.translate=function(h){return arguments.length?(i(h),u()):i()},t.center=function(h){return arguments.length?(r(h),u()):r()},t.clipExtent=function(h){return arguments.length?(h==null?a=s=l=c=null:(a=+h[0][0],s=+h[0][1],l=+h[1][0],c=+h[1][1]),u()):a==null?null:[[a,s],[l,c]]};function u(){var h=Be*n(),f=t(wk(t.rotate()).invert([0,0]));return o(a==null?[[f[0]-h,f[1]-h],[f[0]+h,f[1]+h]]:e===Y_?[[Math.max(f[0]-h,a),s],[Math.min(f[0]+h,l),c]]:[[a,Math.max(f[1]-h,s)],[l,Math.min(f[1]+h,c)]])}return u()}function Yk(e){return Ib((mn+e)/2)}function jj(e,t){var r=Zt(e),n=e===t?Xt(e):F_(r/Zt(t))/F_(Yk(t)/Yk(e)),i=r*uk(Yk(e),n)/n;if(!n)return Y_;function o(a,s){i>0?s<-mn+le&&(s=-mn+le):s>mn-le&&(s=mn-le);var l=i/uk(Yk(s),n);return[l*Xt(n*a),i-l*Zt(n*a)]}return o.invert=function(a,s){var l=i-s,c=ca(n)*xr(a*a+l*l),u=bn(a,Re(l))*ca(l);return l*n<0&&(u-=Be*ca(a)*ca(l)),[u/n,2*ic(uk(i/c,1/n))-mn]},o}function Dbt(){return Vb(jj).scale(109.5).parallels([30,30])}function j_(e,t){return[e,t]}j_.invert=j_;function Obt(){return Si(j_).scale(152.63)}function Xj(e,t){var r=Zt(e),n=e===t?Xt(e):(r-Zt(t))/(t-e),i=r/n+e;if(Re(n)<le)return j_;function o(a,s){var l=i-s,c=n*a;return[l*Xt(c),i-l*Zt(c)]}return o.invert=function(a,s){var l=i-s,c=bn(a,Re(l))*ca(l);return l*n<0&&(c-=Be*ca(a)*ca(l)),[c/n,i-ca(n)*xr(a*a+l*l)]},o}function zbt(){return Vb(Xj).scale(131.154).center([0,13.9389])}var c5=1.340264,u5=-.081106,h5=893e-6,f5=.003796,jk=xr(3)/2,G3e=12;function Xk(e,t){var r=wn(jk*Xt(t)),n=r*r,i=n*n*n;return[e*Zt(r)/(jk*(c5+3*u5*n+i*(7*h5+9*f5*n))),r*(c5+u5*n+i*(h5+f5*n))]}Xk.invert=function(e,t){for(var r=t,n=r*r,i=n*n*n,o=0,a,s,l;o<G3e&&(s=r*(c5+u5*n+i*(h5+f5*n))-t,l=c5+3*u5*n+i*(7*h5+9*f5*n),r-=a=s/l,n=r*r,i=n*n*n,!(Re(a)<z_));++o);return[jk*e*(c5+3*u5*n+i*(7*h5+9*f5*n))/Zt(r),wn(Xt(r)/jk)]};function Fbt(){return Si(Xk).scale(177.158)}function $k(e,t){var r=Zt(t),n=Zt(e)*r;return[r*Xt(e)/n,Xt(t)/n]}$k.invert=Vh(ic);function Bbt(){return Si($k).scale(144.049).clipAngle(60)}function Hbt(){var e=1,t=0,r=0,n=1,i=1,o=0,a,s,l=null,c,u,h,f=1,p=1,d=$m({point:function(S,C){var P=b([S,C]);this.stream.point(P[0],P[1])}}),g=jm,_,y;function x(){return f=e*n,p=e*i,_=y=null,b}function b(S){var C=S[0]*f,P=S[1]*p;if(o){var k=P*a-C*s;C=C*a+P*s,P=k}return[C+t,P+r]}return b.invert=function(S){var C=S[0]-t,P=S[1]-r;if(o){var k=P*a+C*s;C=C*a-P*s,P=k}return[C/f,P/p]},b.stream=function(S){return _&&y===S?_:_=d(g(y=S))},b.postclip=function(S){return arguments.length?(g=S,l=c=u=h=null,x()):g},b.clipExtent=function(S){return arguments.length?(g=S==null?(l=c=u=h=null,jm):Dp(l=+S[0][0],c=+S[0][1],u=+S[1][0],h=+S[1][1]),x()):l==null?null:[[l,c],[u,h]]},b.scale=function(S){return arguments.length?(e=+S,x()):e},b.translate=function(S){return arguments.length?(t=+S[0],r=+S[1],x()):[t,r]},b.angle=function(S){return arguments.length?(o=S%360*ye,s=Xt(o),a=Zt(o),x()):o*vr},b.reflectX=function(S){return arguments.length?(n=S?-1:1,x()):n<0},b.reflectY=function(S){return arguments.length?(i=S?-1:1,x()):i<0},b.fitExtent=function(S,C){return G_(b,S,C)},b.fitSize=function(S,C){return Fb(b,S,C)},b.fitWidth=function(S,C){return Bb(b,S,C)},b.fitHeight=function(S,C){return Hb(b,S,C)},b}function Kk(e,t){var r=t*t,n=r*r;return[e*(.8707-.131979*r+n*(-.013791+n*(.003971*r-.001529*n))),t*(1.007226+r*(.015085+n*(-.044475+.028874*r-.005916*n)))]}Kk.invert=function(e,t){var r=t,n=25,i;do{var o=r*r,a=o*o;r-=i=(r*(1.007226+o*(.015085+a*(-.044475+.028874*o-.005916*a)))-t)/(1.007226+o*(.015085*3+a*(-.044475*7+.028874*9*o-.005916*11*a)))}while(Re(i)>le&&--n>0);return[e/(.8707+(o=r*r)*(-.131979+o*(-.013791+o*o*o*(.003971-.001529*o)))),r]};function Vbt(){return Si(Kk).scale(175.295)}function Zk(e,t){return[Zt(t)*Xt(e),Xt(t)]}Zk.invert=Vh(wn);function Ubt(){return Si(Zk).scale(249.5).clipAngle(90+le)}function Jk(e,t){var r=Zt(t),n=1+Zt(e)*r;return[r*Xt(e)/n,Xt(t)/n]}Jk.invert=Vh(function(e){return 2*ic(e)});function qbt(){return Si(Jk).scale(250).clipAngle(142)}function Qk(e,t){return[F_(Ib((mn+t)/2)),-e]}Qk.invert=function(e,t){return[-t,2*ic(ck(e))-mn]};function Gbt(){var e=Yj(Qk),t=e.center,r=e.rotate;return e.center=function(n){return arguments.length?t([-n[1],n[0]]):(n=t(),[n[1],-n[0]])},e.rotate=function(n){return arguments.length?r([n[0],n[1],n.length>2?n[2]+90:90]):(n=r(),[n[0],n[1],n[2]-90])},r([0,0,90]).scale(159.155)}function W3e(e,t){return e.parent===t.parent?1:2}function Y3e(e){return e.reduce(j3e,0)/e.length}function j3e(e,t){return e+t.x}function X3e(e){return 1+e.reduce($3e,0)}function $3e(e,t){return Math.max(e,t.y)}function K3e(e){for(var t;t=e.children;)e=t[0];return e}function Z3e(e){for(var t;t=e.children;)e=t[t.length-1];return e}function Wbt(){var e=W3e,t=1,r=1,n=!1;function i(o){var a,s=0;o.eachAfter(function(f){var p=f.children;p?(f.x=Y3e(p),f.y=X3e(p)):(f.x=a?s+=e(f,a):0,f.y=0,a=f)});var l=K3e(o),c=Z3e(o),u=l.x-e(l,c)/2,h=c.x+e(c,l)/2;return o.eachAfter(n?function(f){f.x=(f.x-o.x)*t,f.y=(o.y-f.y)*r}:function(f){f.x=(f.x-u)/(h-u)*t,f.y=(1-(o.y?f.y/o.y:1))*r})}return i.separation=function(o){return arguments.length?(e=o,i):e},i.size=function(o){return arguments.length?(n=!1,t=+o[0],r=+o[1],i):n?null:[t,r]},i.nodeSize=function(o){return arguments.length?(n=!0,t=+o[0],r=+o[1],i):n?[t,r]:null},i}function J3e(e){var t=0,r=e.children,n=r&&r.length;if(!n)t=1;else for(;--n>=0;)t+=r[n].value;e.value=t}function Ybt(){return this.eachAfter(J3e)}function jbt(e){var t=this,r,n=[t],i,o,a;do for(r=n.reverse(),n=[];t=r.pop();)if(e(t),i=t.children,i)for(o=0,a=i.length;o<a;++o)n.push(i[o]);while(n.length);return this}function Xbt(e){for(var t=this,r=[t],n,i;t=r.pop();)if(e(t),n=t.children,n)for(i=n.length-1;i>=0;--i)r.push(n[i]);return this}function $bt(e){for(var t=this,r=[t],n=[],i,o,a;t=r.pop();)if(n.push(t),i=t.children,i)for(o=0,a=i.length;o<a;++o)r.push(i[o]);for(;t=n.pop();)e(t);return this}function Kbt(e){return this.eachAfter(function(t){for(var r=+e(t.data)||0,n=t.children,i=n&&n.length;--i>=0;)r+=n[i].value;t.value=r})}function Zbt(e){return this.eachBefore(function(t){t.children&&t.children.sort(e)})}function Jbt(e){for(var t=this,r=Q3e(t,e),n=[t];t!==r;)t=t.parent,n.push(t);for(var i=n.length;e!==r;)n.splice(i,0,e),e=e.parent;return n}function Q3e(e,t){if(e===t)return e;var r=e.ancestors(),n=t.ancestors(),i=null;for(e=r.pop(),t=n.pop();e===t;)i=e,e=r.pop(),t=n.pop();return i}function Qbt(){for(var e=this,t=[e];e=e.parent;)t.push(e);return t}function t2t(){var e=[];return this.each(function(t){e.push(t)}),e}function e2t(){var e=[];return this.eachBefore(function(t){t.children||e.push(t)}),e}function r2t(){var e=this,t=[];return e.each(function(r){r!==e&&t.push({source:r.parent,target:r})}),t}function p5(e,t){var r=new Km(e),n=+e.value&&(r.value=e.value),i,o=[r],a,s,l,c;for(t==null&&(t=eMe);i=o.pop();)if(n&&(i.value=+i.data.value),(s=t(i.data))&&(c=s.length))for(i.children=new Array(c),l=c-1;l>=0;--l)o.push(a=i.children[l]=new Km(s[l])),a.parent=i,a.depth=i.depth+1;return r.eachBefore($j)}function tMe(){return p5(this).eachBefore(rMe)}function eMe(e){return e.children}function rMe(e){e.data=e.data.data}function $j(e){var t=0;do e.height=t;while((e=e.parent)&&e.height<++t)}function Km(e){this.data=e,this.depth=this.height=0,this.parent=null}Km.prototype=p5.prototype={constructor:Km,count:Ybt,each:jbt,eachAfter:$bt,eachBefore:Xbt,sum:Kbt,sort:Zbt,path:Jbt,ancestors:Qbt,descendants:t2t,leaves:e2t,links:r2t,copy:tMe};var n2t=Array.prototype.slice;function i2t(e){for(var t=e.length,r,n;t;)n=Math.random()*t--|0,r=e[t],e[t]=e[n],e[n]=r;return e}function e8(e){for(var t=0,r=(e=i2t(n2t.call(e))).length,n=[],i,o;t<r;)i=e[t],o&&o2t(o,i)?++t:(o=iMe(n=nMe(n,i)),t=0);return o}function nMe(e,t){var r,n;if(Kj(t,e))return[t];for(r=0;r<e.length;++r)if(t8(t,e[r])&&Kj(d5(e[r],t),e))return[e[r],t];for(r=0;r<e.length-1;++r)for(n=r+1;n<e.length;++n)if(t8(d5(e[r],e[n]),t)&&t8(d5(e[r],t),e[n])&&t8(d5(e[n],t),e[r])&&Kj(a2t(e[r],e[n],t),e))return[e[r],e[n],t];throw new Error}function t8(e,t){var r=e.r-t.r,n=t.x-e.x,i=t.y-e.y;return r<0||r*r<n*n+i*i}function o2t(e,t){var r=e.r-t.r+1e-6,n=t.x-e.x,i=t.y-e.y;return r>0&&r*r>n*n+i*i}function Kj(e,t){for(var r=0;r<t.length;++r)if(!o2t(e,t[r]))return!1;return!0}function iMe(e){switch(e.length){case 1:return oMe(e[0]);case 2:return d5(e[0],e[1]);case 3:return a2t(e[0],e[1],e[2])}}function oMe(e){return{x:e.x,y:e.y,r:e.r}}function d5(e,t){var r=e.x,n=e.y,i=e.r,o=t.x,a=t.y,s=t.r,l=o-r,c=a-n,u=s-i,h=Math.sqrt(l*l+c*c);return{x:(r+o+l/h*u)/2,y:(n+a+c/h*u)/2,r:(h+i+s)/2}}function a2t(e,t,r){var n=e.x,i=e.y,o=e.r,a=t.x,s=t.y,l=t.r,c=r.x,u=r.y,h=r.r,f=n-a,p=n-c,d=i-s,g=i-u,_=l-o,y=h-o,x=n*n+i*i-o*o,b=x-a*a-s*s+l*l,S=x-c*c-u*u+h*h,C=p*d-f*g,P=(d*S-g*b)/(C*2)-n,k=(g*_-d*y)/C,O=(p*b-f*S)/(C*2)-i,D=(f*y-p*_)/C,B=k*k+D*D-1,I=2*(o+P*k+O*D),L=P*P+O*O-o*o,R=-(B?(I+Math.sqrt(I*I-4*B*L))/(2*B):L/I);return{x:n+P+k*R,y:i+O+D*R,r:R}}function s2t(e,t,r){var n=e.x-t.x,i,o,a=e.y-t.y,s,l,c=n*n+a*a;c?(o=t.r+r.r,o*=o,l=e.r+r.r,l*=l,o>l?(i=(c+l-o)/(2*c),s=Math.sqrt(Math.max(0,l/c-i*i)),r.x=e.x-i*n-s*a,r.y=e.y-i*a+s*n):(i=(c+o-l)/(2*c),s=Math.sqrt(Math.max(0,o/c-i*i)),r.x=t.x+i*n-s*a,r.y=t.y+i*a+s*n)):(r.x=t.x+r.r,r.y=t.y)}function l2t(e,t){var r=e.r+t.r-1e-6,n=t.x-e.x,i=t.y-e.y;return r>0&&r*r>n*n+i*i}function c2t(e){var t=e._,r=e.next._,n=t.r+r.r,i=(t.x*r.r+r.x*t.r)/n,o=(t.y*r.r+r.y*t.r)/n;return i*i+o*o}function r8(e){this._=e,this.next=null,this.previous=null}function Zj(e){if(!(i=e.length))return 0;var t,r,n,i,o,a,s,l,c,u,h;if(t=e[0],t.x=0,t.y=0,!(i>1))return t.r;if(r=e[1],t.x=-r.r,r.x=t.r,r.y=0,!(i>2))return t.r+r.r;s2t(r,t,n=e[2]),t=new r8(t),r=new r8(r),n=new r8(n),t.next=n.previous=r,r.next=t.previous=n,n.next=r.previous=t;t:for(s=3;s<i;++s){s2t(t._,r._,n=e[s]),n=new r8(n),l=r.next,c=t.previous,u=r._.r,h=t._.r;do if(u<=h){if(l2t(l._,n._)){r=l,t.next=r,r.previous=t,--s;continue t}u+=l._.r,l=l.next}else{if(l2t(c._,n._)){t=c,t.next=r,r.previous=t,--s;continue t}h+=c._.r,c=c.previous}while(l!==c.next);for(n.previous=t,n.next=r,t.next=r.previous=r=n,o=c2t(t);(n=n.next)!==r;)(a=c2t(n))<o&&(t=n,o=a);r=t.next}for(t=[r._],n=r;(n=n.next)!==r;)t.push(n._);for(n=e8(t),s=0;s<i;++s)t=e[s],t.x-=n.x,t.y-=n.y;return n.r}function u2t(e){return Zj(e),e}function h2t(e){return e==null?null:Ub(e)}function Ub(e){if(typeof e!="function")throw new Error;return e}function Op(){return 0}function Zm(e){return function(){return e}}function aMe(e){return Math.sqrt(e.value)}function d2t(){var e=null,t=1,r=1,n=Op;function i(o){return o.x=t/2,o.y=r/2,e?o.eachBefore(f2t(e)).eachAfter(Jj(n,.5)).eachBefore(p2t(1)):o.eachBefore(f2t(aMe)).eachAfter(Jj(Op,1)).eachAfter(Jj(n,o.r/Math.min(t,r))).eachBefore(p2t(Math.min(t,r)/(2*o.r))),o}return i.radius=function(o){return arguments.length?(e=h2t(o),i):e},i.size=function(o){return arguments.length?(t=+o[0],r=+o[1],i):[t,r]},i.padding=function(o){return arguments.length?(n=typeof o=="function"?o:Zm(+o),i):n},i}function f2t(e){return function(t){t.children||(t.r=Math.max(0,+e(t)||0))}}function Jj(e,t){return function(r){if(n=r.children){var n,i,o=n.length,a=e(r)*t||0,s;if(a)for(i=0;i<o;++i)n[i].r+=a;if(s=Zj(n),a)for(i=0;i<o;++i)n[i].r-=a;r.r=s+a}}}function p2t(e){return function(t){var r=t.parent;t.r*=e,r&&(t.x=r.x+e*t.x,t.y=r.y+e*t.y)}}function n8(e){e.x0=Math.round(e.x0),e.y0=Math.round(e.y0),e.x1=Math.round(e.x1),e.y1=Math.round(e.y1)}function Uh(e,t,r,n,i){for(var o=e.children,a,s=-1,l=o.length,c=e.value&&(n-t)/e.value;++s<l;)a=o[s],a.y0=r,a.y1=i,a.x0=t,a.x1=t+=a.value*c}function m2t(){var e=1,t=1,r=0,n=!1;function i(a){var s=a.height+1;return a.x0=a.y0=r,a.x1=e,a.y1=t/s,a.eachBefore(o(t,s)),n&&a.eachBefore(n8),a}function o(a,s){return function(l){l.children&&Uh(l,l.x0,a*(l.depth+1)/s,l.x1,a*(l.depth+2)/s);var c=l.x0,u=l.y0,h=l.x1-r,f=l.y1-r;h<c&&(c=h=(c+h)/2),f<u&&(u=f=(u+f)/2),l.x0=c,l.y0=u,l.x1=h,l.y1=f}}return i.round=function(a){return arguments.length?(n=!!a,i):n},i.size=function(a){return arguments.length?(e=+a[0],t=+a[1],i):[e,t]},i.padding=function(a){return arguments.length?(r=+a,i):r},i}var g2t="$",sMe={depth:-1},_2t={};function lMe(e){return e.id}function cMe(e){return e.parentId}function y2t(){var e=lMe,t=cMe;function r(n){var i,o,a=n.length,s,l,c,u=new Array(a),h,f,p={};for(o=0;o<a;++o)i=n[o],c=u[o]=new Km(i),(h=e(i,o,n))!=null&&(h+="")&&(f=g2t+(c.id=h),p[f]=f in p?_2t:c);for(o=0;o<a;++o)if(c=u[o],h=t(n[o],o,n),h==null||!(h+="")){if(s)throw new Error("multiple roots");s=c}else{if(l=p[g2t+h],!l)throw new Error("missing: "+h);if(l===_2t)throw new Error("ambiguous: "+h);l.children?l.children.push(c):l.children=[c],c.parent=l}if(!s)throw new Error("no root");if(s.parent=sMe,s.eachBefore(function(d){d.depth=d.parent.depth+1,--a}).eachBefore($j),s.parent=null,a>0)throw new Error("cycle");return s}return r.id=function(n){return arguments.length?(e=Ub(n),r):e},r.parentId=function(n){return arguments.length?(t=Ub(n),r):t},r}function uMe(e,t){return e.parent===t.parent?1:2}function Qj(e){var t=e.children;return t?t[0]:e.t}function tX(e){var t=e.children;return t?t[t.length-1]:e.t}function hMe(e,t,r){var n=r/(t.i-e.i);t.c-=n,t.s+=r,e.c+=n,t.z+=r,t.m+=r}function fMe(e){for(var t=0,r=0,n=e.children,i=n.length,o;--i>=0;)o=n[i],o.z+=t,o.m+=t,t+=o.s+(r+=o.c)}function pMe(e,t,r){return e.a.parent===t.parent?e.a:r}function i8(e,t){this._=e,this.parent=null,this.children=null,this.A=null,this.a=this,this.z=0,this.m=0,this.c=0,this.s=0,this.t=null,this.i=t}i8.prototype=Object.create(Km.prototype);function dMe(e){for(var t=new i8(e,0),r,n=[t],i,o,a,s;r=n.pop();)if(o=r._.children)for(r.children=new Array(s=o.length),a=s-1;a>=0;--a)n.push(i=r.children[a]=new i8(o[a],a)),i.parent=r;return(t.parent=new i8(null,0)).children=[t],t}function v2t(){var e=uMe,t=1,r=1,n=null;function i(c){var u=dMe(c);if(u.eachAfter(o),u.parent.m=-u.z,u.eachBefore(a),n)c.eachBefore(l);else{var h=c,f=c,p=c;c.eachBefore(function(x){x.x<h.x&&(h=x),x.x>f.x&&(f=x),x.depth>p.depth&&(p=x)});var d=h===f?1:e(h,f)/2,g=d-h.x,_=t/(f.x+d+g),y=r/(p.depth||1);c.eachBefore(function(x){x.x=(x.x+g)*_,x.y=x.depth*y})}return c}function o(c){var u=c.children,h=c.parent.children,f=c.i?h[c.i-1]:null;if(u){fMe(c);var p=(u[0].z+u[u.length-1].z)/2;f?(c.z=f.z+e(c._,f._),c.m=c.z-p):c.z=p}else f&&(c.z=f.z+e(c._,f._));c.parent.A=s(c,f,c.parent.A||h[0])}function a(c){c._.x=c.z+c.parent.m,c.m+=c.parent.m}function s(c,u,h){if(u){for(var f=c,p=c,d=u,g=f.parent.children[0],_=f.m,y=p.m,x=d.m,b=g.m,S;d=tX(d),f=Qj(f),d&&f;)g=Qj(g),p=tX(p),p.a=c,S=d.z+x-f.z-_+e(d._,f._),S>0&&(hMe(pMe(d,c,h),c,S),_+=S,y+=S),x+=d.m,_+=f.m,b+=g.m,y+=p.m;d&&!tX(p)&&(p.t=d,p.m+=x-y),f&&!Qj(g)&&(g.t=f,g.m+=_-b,h=c)}return h}function l(c){c.x*=t,c.y=c.depth*r}return i.separation=function(c){return arguments.length?(e=c,i):e},i.size=function(c){return arguments.length?(n=!1,t=+c[0],r=+c[1],i):n?null:[t,r]},i.nodeSize=function(c){return arguments.length?(n=!0,t=+c[0],r=+c[1],i):n?[t,r]:null},i}function Jm(e,t,r,n,i){for(var o=e.children,a,s=-1,l=o.length,c=e.value&&(i-r)/e.value;++s<l;)a=o[s],a.x0=t,a.x1=n,a.y0=r,a.y1=r+=a.value*c}var eX=(1+Math.sqrt(5))/2;function rX(e,t,r,n,i,o){for(var a=[],s=t.children,l,c,u=0,h=0,f=s.length,p,d,g=t.value,_,y,x,b,S,C,P;u<f;){p=i-r,d=o-n;do _=s[h++].value;while(!_&&h<f);for(y=x=_,C=Math.max(d/p,p/d)/(g*e),P=_*_*C,S=Math.max(x/P,P/y);h<f;++h){if(_+=c=s[h].value,c<y&&(y=c),c>x&&(x=c),P=_*_*C,b=Math.max(x/P,P/y),b>S){_-=c;break}S=b}a.push(l={value:_,dice:p<d,children:s.slice(u,h)}),l.dice?Uh(l,r,n,i,g?n+=d*_/g:o):Jm(l,r,n,g?r+=p*_/g:i,o),g-=_,u=h}return a}var o8=function e(t){function r(n,i,o,a,s){rX(t,n,i,o,a,s)}return r.ratio=function(n){return e((n=+n)>1?n:1)},r}(eX);function x2t(){var e=o8,t=!1,r=1,n=1,i=[0],o=Op,a=Op,s=Op,l=Op,c=Op;function u(f){return f.x0=f.y0=0,f.x1=r,f.y1=n,f.eachBefore(h),i=[0],t&&f.eachBefore(n8),f}function h(f){var p=i[f.depth],d=f.x0+p,g=f.y0+p,_=f.x1-p,y=f.y1-p;_<d&&(d=_=(d+_)/2),y<g&&(g=y=(g+y)/2),f.x0=d,f.y0=g,f.x1=_,f.y1=y,f.children&&(p=i[f.depth+1]=o(f)/2,d+=c(f)-p,g+=a(f)-p,_-=s(f)-p,y-=l(f)-p,_<d&&(d=_=(d+_)/2),y<g&&(g=y=(g+y)/2),e(f,d,g,_,y))}return u.round=function(f){return arguments.length?(t=!!f,u):t},u.size=function(f){return arguments.length?(r=+f[0],n=+f[1],u):[r,n]},u.tile=function(f){return arguments.length?(e=Ub(f),u):e},u.padding=function(f){return arguments.length?u.paddingInner(f).paddingOuter(f):u.paddingInner()},u.paddingInner=function(f){return arguments.length?(o=typeof f=="function"?f:Zm(+f),u):o},u.paddingOuter=function(f){return arguments.length?u.paddingTop(f).paddingRight(f).paddingBottom(f).paddingLeft(f):u.paddingTop()},u.paddingTop=function(f){return arguments.length?(a=typeof f=="function"?f:Zm(+f),u):a},u.paddingRight=function(f){return arguments.length?(s=typeof f=="function"?f:Zm(+f),u):s},u.paddingBottom=function(f){return arguments.length?(l=typeof f=="function"?f:Zm(+f),u):l},u.paddingLeft=function(f){return arguments.length?(c=typeof f=="function"?f:Zm(+f),u):c},u}function b2t(e,t,r,n,i){var o=e.children,a,s=o.length,l,c=new Array(s+1);for(c[0]=l=a=0;a<s;++a)c[a+1]=l+=o[a].value;u(0,s,e.value,t,r,n,i);function u(h,f,p,d,g,_,y){if(h>=f-1){var x=o[h];x.x0=d,x.y0=g,x.x1=_,x.y1=y;return}for(var b=c[h],S=p/2+b,C=h+1,P=f-1;C<P;){var k=C+P>>>1;c[k]<S?C=k+1:P=k}S-c[C-1]<c[C]-S&&h+1<C&&--C;var O=c[C]-b,D=p-O;if(_-d>y-g){var B=(d*D+_*O)/p;u(h,C,O,d,g,B,y),u(C,f,D,B,g,_,y)}else{var I=(g*D+y*O)/p;u(h,C,O,d,g,_,I),u(C,f,D,d,I,_,y)}}}function w2t(e,t,r,n,i){(e.depth&1?Jm:Uh)(e,t,r,n,i)}var S2t=function e(t){function r(n,i,o,a,s){if((l=n._squarify)&&l.ratio===t)for(var l,c,u,h,f=-1,p,d=l.length,g=n.value;++f<d;){for(c=l[f],u=c.children,h=c.value=0,p=u.length;h<p;++h)c.value+=u[h].value;c.dice?Uh(c,i,o,a,o+=(s-o)*c.value/g):Jm(c,i,o,i+=(a-i)*c.value/g,s),g-=c.value}else n._squarify=l=rX(t,n,i,o,a,s),l.ratio=t}return r.ratio=function(n){return e((n=+n)>1?n:1)},r}(eX);function M2t(e){for(var t=-1,r=e.length,n,i=e[r-1],o=0;++t<r;)n=i,i=e[t],o+=n[1]*i[0]-n[0]*i[1];return o/2}function E2t(e){for(var t=-1,r=e.length,n=0,i=0,o,a=e[r-1],s,l=0;++t<r;)o=a,a=e[t],l+=s=o[0]*a[1]-a[0]*o[1],n+=(o[0]+a[0])*s,i+=(o[1]+a[1])*s;return l*=3,[n/l,i/l]}function T2t(e,t,r){return(t[0]-e[0])*(r[1]-e[1])-(t[1]-e[1])*(r[0]-e[0])}function mMe(e,t){return e[0]-t[0]||e[1]-t[1]}function C2t(e){for(var t=e.length,r=[0,1],n=2,i=2;i<t;++i){for(;n>1&&T2t(e[r[n-2]],e[r[n-1]],e[i])<=0;)--n;r[n++]=i}return r.slice(0,n)}function A2t(e){if((r=e.length)<3)return null;var t,r,n=new Array(r),i=new Array(r);for(t=0;t<r;++t)n[t]=[+e[t][0],+e[t][1],t];for(n.sort(mMe),t=0;t<r;++t)i[t]=[n[t][0],-n[t][1]];var o=C2t(n),a=C2t(i),s=a[0]===o[0],l=a[a.length-1]===o[o.length-1],c=[];for(t=o.length-1;t>=0;--t)c.push(e[n[o[t]][2]]);for(t=+s;t<a.length-l;++t)c.push(e[n[a[t]][2]]);return c}function P2t(e,t){for(var r=e.length,n=e[r-1],i=t[0],o=t[1],a=n[0],s=n[1],l,c,u=!1,h=0;h<r;++h)n=e[h],l=n[0],c=n[1],c>o!=s>o&&i<(a-l)*(o-c)/(s-c)+l&&(u=!u),a=l,s=c;return u}function I2t(e){for(var t=-1,r=e.length,n=e[r-1],i,o,a=n[0],s=n[1],l=0;++t<r;)i=a,o=s,n=e[t],a=n[0],s=n[1],i-=a,o-=s,l+=Math.sqrt(i*i+o*o);return l}function ac(){return Math.random()}var L2t=function e(t){function r(n,i){return n=n==null?0:+n,i=i==null?1:+i,arguments.length===1?(i=n,n=0):i-=n,function(){return t()*i+n}}return r.source=e,r}(ac);var a8=function e(t){function r(n,i){var o,a;return n=n==null?0:+n,i=i==null?1:+i,function(){var s;if(o!=null)s=o,o=null;else do o=t()*2-1,s=t()*2-1,a=o*o+s*s;while(!a||a>1);return n+i*s*Math.sqrt(-2*Math.log(a)/a)}}return r.source=e,r}(ac);var k2t=function e(t){function r(){var n=a8.source(t).apply(this,arguments);return function(){return Math.exp(n())}}return r.source=e,r}(ac);var s8=function e(t){function r(n){return function(){for(var i=0,o=0;o<n;++o)i+=t();return i}}return r.source=e,r}(ac);var R2t=function e(t){function r(n){var i=s8.source(t)(n);return function(){return i()/n}}return r.source=e,r}(ac);var N2t=function e(t){function r(n){return function(){return-Math.log(1-t())/n}}return r.source=e,r}(ac);function hi(e,t){switch(arguments.length){case 0:break;case 1:this.range(e);break;default:this.range(t).domain(e);break}return this}function sc(e,t){switch(arguments.length){case 0:break;case 1:this.interpolator(e);break;default:this.interpolator(t).domain(e);break}return this}Tb();var D2t=Array.prototype,X_=D2t.map,lc=D2t.slice;var l8={name:"implicit"};function gu(){var e=Ji(),t=[],r=[],n=l8;function i(o){var a=o+"",s=e.get(a);if(!s){if(n!==l8)return n;e.set(a,s=t.push(o))}return r[(s-1)%r.length]}return i.domain=function(o){if(!arguments.length)return t.slice();t=[],e=Ji();for(var a=-1,s=o.length,l,c;++a<s;)e.has(c=(l=o[a])+"")||e.set(c,t.push(l));return i},i.range=function(o){return arguments.length?(r=lc.call(o),i):r.slice()},i.unknown=function(o){return arguments.length?(n=o,i):n},i.copy=function(){return gu(t,r).unknown(n)},hi.apply(i,arguments),i}function Qm(){var e=gu().unknown(void 0),t=e.domain,r=e.range,n=[0,1],i,o,a=!1,s=0,l=0,c=.5;delete e.unknown;function u(){var h=t().length,f=n[1]<n[0],p=n[f-0],d=n[1-f];i=(d-p)/Math.max(1,h-s+l*2),a&&(i=Math.floor(i)),p+=(d-p-i*(h-s))*c,o=i*(1-s),a&&(p=Math.round(p),o=Math.round(o));var g=Ir(h).map(function(_){return p+i*_});return r(f?g.reverse():g)}return e.domain=function(h){return arguments.length?(t(h),u()):t()},e.range=function(h){return arguments.length?(n=[+h[0],+h[1]],u()):n.slice()},e.rangeRound=function(h){return n=[+h[0],+h[1]],a=!0,u()},e.bandwidth=function(){return o},e.step=function(){return i},e.round=function(h){return arguments.length?(a=!!h,u()):a},e.padding=function(h){return arguments.length?(s=Math.min(1,l=+h),u()):s},e.paddingInner=function(h){return arguments.length?(s=Math.min(1,h),u()):s},e.paddingOuter=function(h){return arguments.length?(l=+h,u()):l},e.align=function(h){return arguments.length?(c=Math.max(0,Math.min(1,h)),u()):c},e.copy=function(){return Qm(t(),n).round(a).paddingInner(s).paddingOuter(l).align(c)},hi.apply(u(),arguments)}function O2t(e){var t=e.copy;return e.padding=e.paddingOuter,delete e.paddingInner,delete e.paddingOuter,e.copy=function(){return O2t(t())},e}function tg(){return O2t(Qm.apply(null,arguments).paddingInner(1))}function z2t(e){return function(){return e}}function m5(e){return+e}var F2t=[0,1];function ni(e){return e}function nX(e,t){return(t-=e=+e)?function(r){return(r-e)/t}:z2t(isNaN(t)?NaN:.5)}function B2t(e){var t=e[0],r=e[e.length-1],n;return t>r&&(n=t,t=r,r=n),function(i){return Math.max(t,Math.min(r,i))}}function gMe(e,t,r){var n=e[0],i=e[1],o=t[0],a=t[1];return i<n?(n=nX(i,n),o=r(a,o)):(n=nX(n,i),o=r(o,a)),function(s){return o(n(s))}}function _Me(e,t,r){var n=Math.min(e.length,t.length)-1,i=new Array(n),o=new Array(n),a=-1;for(e[n]<e[0]&&(e=e.slice().reverse(),t=t.slice().reverse());++a<n;)i[a]=nX(e[a],e[a+1]),o[a]=r(t[a],t[a+1]);return function(s){var l=ys(e,s,1,n)-1;return o[l](i[l](s))}}function qh(e,t){return t.domain(e.domain()).range(e.range()).interpolate(e.interpolate()).clamp(e.clamp()).unknown(e.unknown())}function $_(){var e=F2t,t=F2t,r=nc,n,i,o,a=ni,s,l,c;function u(){return s=Math.min(e.length,t.length)>2?_Me:gMe,l=c=null,h}function h(f){return isNaN(f=+f)?o:(l||(l=s(e.map(n),t,r)))(n(a(f)))}return h.invert=function(f){return a(i((c||(c=s(t,e.map(n),zi)))(f)))},h.domain=function(f){return arguments.length?(e=X_.call(f,m5),a===ni||(a=B2t(e)),u()):e.slice()},h.range=function(f){return arguments.length?(t=lc.call(f),u()):t.slice()},h.rangeRound=function(f){return t=lc.call(f),r=dL,u()},h.clamp=function(f){return arguments.length?(a=f?B2t(e):ni,h):a!==ni},h.interpolate=function(f){return arguments.length?(r=f,u()):r},h.unknown=function(f){return arguments.length?(o=f,h):o},function(f,p){return n=f,i=p,u()}}function g5(e,t){return $_()(e,t)}function c8(e,t,r,n){var i=tl(e,t,r),o;switch(n=Lp(n==null?",f":n),n.type){case"s":{var a=Math.max(Math.abs(e),Math.abs(t));return n.precision==null&&!isNaN(o=ok(i,a))&&(n.precision=o),WE(n,a)}case"":case"e":case"g":case"p":case"r":{n.precision==null&&!isNaN(o=ak(i,Math.max(Math.abs(e),Math.abs(t))))&&(n.precision=o-(n.type==="e"));break}case"f":case"%":{n.precision==null&&!isNaN(o=ik(i))&&(n.precision=o-(n.type==="%")*2);break}}return xn(n)}function il(e){var t=e.domain;return e.ticks=function(r){var n=t();return ab(n[0],n[n.length-1],r==null?10:r)},e.tickFormat=function(r,n){var i=t();return c8(i[0],i[i.length-1],r==null?10:r,n)},e.nice=function(r){r==null&&(r=10);var n=t(),i=0,o=n.length-1,a=n[i],s=n[o],l;return s<a&&(l=a,a=s,s=l,l=i,i=o,o=l),l=x_(a,s,r),l>0?(a=Math.floor(a/l)*l,s=Math.ceil(s/l)*l,l=x_(a,s,r)):l<0&&(a=Math.ceil(a*l)/l,s=Math.floor(s*l)/l,l=x_(a,s,r)),l>0?(n[i]=Math.floor(a/l)*l,n[o]=Math.ceil(s/l)*l,t(n)):l<0&&(n[i]=Math.ceil(a*l)/l,n[o]=Math.floor(s*l)/l,t(n)),e},e}function On(){var e=g5(ni,ni);return e.copy=function(){return qh(e,On())},hi.apply(e,arguments),il(e)}function u8(e){var t;function r(n){return isNaN(n=+n)?t:n}return r.invert=r,r.domain=r.range=function(n){return arguments.length?(e=X_.call(n,m5),r):e.slice()},r.unknown=function(n){return arguments.length?(t=n,r):t},r.copy=function(){return u8(e).unknown(t)},e=arguments.length?X_.call(e,m5):[0,1],il(r)}function h8(e,t){e=e.slice();var r=0,n=e.length-1,i=e[r],o=e[n],a;return o<i&&(a=r,r=n,n=a,a=i,i=o,o=a),e[r]=t.floor(i),e[n]=t.ceil(o),e}function H2t(e){return Math.log(e)}function V2t(e){return Math.exp(e)}function yMe(e){return-Math.log(-e)}function vMe(e){return-Math.exp(-e)}function xMe(e){return isFinite(e)?+("1e"+e):e<0?0:e}function bMe(e){return e===10?xMe:e===Math.E?Math.exp:function(t){return Math.pow(e,t)}}function wMe(e){return e===Math.E?Math.log:e===10&&Math.log10||e===2&&Math.log2||(e=Math.log(e),function(t){return Math.log(t)/e})}function U2t(e){return function(t){return-e(-t)}}function _5(e){var t=e(H2t,V2t),r=t.domain,n=10,i,o;function a(){return i=wMe(n),o=bMe(n),r()[0]<0?(i=U2t(i),o=U2t(o),e(yMe,vMe)):e(H2t,V2t),t}return t.base=function(s){return arguments.length?(n=+s,a()):n},t.domain=function(s){return arguments.length?(r(s),a()):r()},t.ticks=function(s){var l=r(),c=l[0],u=l[l.length-1],h;(h=u<c)&&(f=c,c=u,u=f);var f=i(c),p=i(u),d,g,_,y=s==null?10:+s,x=[];if(!(n%1)&&p-f<y){if(f=Math.round(f)-1,p=Math.round(p)+1,c>0){for(;f<p;++f)for(g=1,d=o(f);g<n;++g)if(_=d*g,!(_<c)){if(_>u)break;x.push(_)}}else for(;f<p;++f)for(g=n-1,d=o(f);g>=1;--g)if(_=d*g,!(_<c)){if(_>u)break;x.push(_)}}else x=ab(f,p,Math.min(p-f,y)).map(o);return h?x.reverse():x},t.tickFormat=function(s,l){if(l==null&&(l=n===10?".0e":","),typeof l!="function"&&(l=xn(l)),s===1/0)return l;s==null&&(s=10);var c=Math.max(1,n*s/t.ticks().length);return function(u){var h=u/o(Math.round(i(u)));return h*n<n-.5&&(h*=n),h<=c?l(u):""}},t.nice=function(){return r(h8(r(),{floor:function(s){return o(Math.floor(i(s)))},ceil:function(s){return o(Math.ceil(i(s)))}}))},t}function cc(){var e=_5($_()).domain([1,10]);return e.copy=function(){return qh(e,cc()).base(e.base())},hi.apply(e,arguments),e}function q2t(e){return function(t){return Math.sign(t)*Math.log1p(Math.abs(t/e))}}function G2t(e){return function(t){return Math.sign(t)*Math.expm1(Math.abs(t))*e}}function y5(e){var t=1,r=e(q2t(t),G2t(t));return r.constant=function(n){return arguments.length?e(q2t(t=+n),G2t(t)):t},il(r)}function f8(){var e=y5($_());return e.copy=function(){return qh(e,f8()).constant(e.constant())},hi.apply(e,arguments)}function W2t(e){return function(t){return t<0?-Math.pow(-t,e):Math.pow(t,e)}}function SMe(e){return e<0?-Math.sqrt(-e):Math.sqrt(e)}function MMe(e){return e<0?-e*e:e*e}function v5(e){var t=e(ni,ni),r=1;function n(){return r===1?e(ni,ni):r===.5?e(SMe,MMe):e(W2t(r),W2t(1/r))}return t.exponent=function(i){return arguments.length?(r=+i,n()):r},il(t)}function K_(){var e=v5($_());return e.copy=function(){return qh(e,K_()).exponent(e.exponent())},hi.apply(e,arguments),e}function Y2t(){return K_.apply(null,arguments).exponent(.5)}function eg(){var e=[],t=[],r=[],n;function i(){var a=0,s=Math.max(1,t.length);for(r=new Array(s-1);++a<s;)r[a-1]=sa(e,a/s);return o}function o(a){return isNaN(a=+a)?n:t[ys(r,a)]}return o.invertExtent=function(a){var s=t.indexOf(a);return s<0?[NaN,NaN]:[s>0?r[s-1]:e[0],s<r.length?r[s]:e[e.length-1]]},o.domain=function(a){if(!arguments.length)return e.slice();e=[];for(var s=0,l=a.length,c;s<l;++s)c=a[s],c!=null&&!isNaN(c=+c)&&e.push(c);return e.sort(oa),i()},o.range=function(a){return arguments.length?(t=lc.call(a),i()):t.slice()},o.unknown=function(a){return arguments.length?(n=a,o):n},o.quantiles=function(){return r.slice()},o.copy=function(){return eg().domain(e).range(t).unknown(n)},hi.apply(o,arguments)}function qb(){var e=0,t=1,r=1,n=[.5],i=[0,1],o;function a(l){return l<=l?i[ys(n,l,0,r)]:o}function s(){var l=-1;for(n=new Array(r);++l<r;)n[l]=((l+1)*t-(l-r)*e)/(r+1);return a}return a.domain=function(l){return arguments.length?(e=+l[0],t=+l[1],s()):[e,t]},a.range=function(l){return arguments.length?(r=(i=lc.call(l)).length-1,s()):i.slice()},a.invertExtent=function(l){var c=i.indexOf(l);return c<0?[NaN,NaN]:c<1?[e,n[0]]:c>=r?[n[r-1],t]:[n[c-1],n[c]]},a.unknown=function(l){return arguments.length&&(o=l),a},a.thresholds=function(){return n.slice()},a.copy=function(){return qb().domain([e,t]).range(i).unknown(o)},hi.apply(il(a),arguments)}function p8(){var e=[.5],t=[0,1],r,n=1;function i(o){return o<=o?t[ys(e,o,0,n)]:r}return i.domain=function(o){return arguments.length?(e=lc.call(o),n=Math.min(e.length,t.length-1),i):e.slice()},i.range=function(o){return arguments.length?(t=lc.call(o),n=Math.min(e.length,t.length-1),i):t.slice()},i.invertExtent=function(o){var a=t.indexOf(o);return[e[a-1],e[a]]},i.unknown=function(o){return arguments.length?(r=o,i):r},i.copy=function(){return p8().domain(e).range(t).unknown(r)},hi.apply(i,arguments)}var iX=new Date,oX=new Date;function br(e,t,r,n){function i(o){return e(o=arguments.length===0?new Date:new Date(+o)),o}return i.floor=function(o){return e(o=new Date(+o)),o},i.ceil=function(o){return e(o=new Date(o-1)),t(o,1),e(o),o},i.round=function(o){var a=i(o),s=i.ceil(o);return o-a<s-o?a:s},i.offset=function(o,a){return t(o=new Date(+o),a==null?1:Math.floor(a)),o},i.range=function(o,a,s){var l=[],c;if(o=i.ceil(o),s=s==null?1:Math.floor(s),!(o<a)||!(s>0))return l;do l.push(c=new Date(+o)),t(o,s),e(o);while(c<o&&o<a);return l},i.filter=function(o){return br(function(a){if(a>=a)for(;e(a),!o(a);)a.setTime(a-1)},function(a,s){if(a>=a)if(s<0)for(;++s<=0;)for(;t(a,-1),!o(a););else for(;--s>=0;)for(;t(a,1),!o(a););})},r&&(i.count=function(o,a){return iX.setTime(+o),oX.setTime(+a),e(iX),e(oX),Math.floor(r(iX,oX))},i.every=function(o){return o=Math.floor(o),!isFinite(o)||!(o>0)?null:o>1?i.filter(n?function(a){return n(a)%o===0}:function(a){return i.count(0,a)%o===0}):i}),i}var d8=br(function(){},function(e,t){e.setTime(+e+t)},function(e,t){return t-e});d8.every=function(e){return e=Math.floor(e),!isFinite(e)||!(e>0)?null:e>1?br(function(t){t.setTime(Math.floor(t/e)*e)},function(t,r){t.setTime(+t+r*e)},function(t,r){return(r-t)/e}):d8};var Z_=d8,aX=d8.range;var J_=1e3,uc=6e4,Gb=36e5,m8=864e5,g8=6048e5;var j2t=br(function(e){e.setTime(e-e.getMilliseconds())},function(e,t){e.setTime(+e+t*J_)},function(e,t){return(t-e)/J_},function(e){return e.getUTCSeconds()}),Q_=j2t,sX=j2t.range;var X2t=br(function(e){e.setTime(e-e.getMilliseconds()-e.getSeconds()*J_)},function(e,t){e.setTime(+e+t*uc)},function(e,t){return(t-e)/uc},function(e){return e.getMinutes()}),_8=X2t,$2t=X2t.range;var K2t=br(function(e){e.setTime(e-e.getMilliseconds()-e.getSeconds()*J_-e.getMinutes()*uc)},function(e,t){e.setTime(+e+t*Gb)},function(e,t){return(t-e)/Gb},function(e){return e.getHours()}),y8=K2t,Z2t=K2t.range;var J2t=br(function(e){e.setHours(0,0,0,0)},function(e,t){e.setDate(e.getDate()+t)},function(e,t){return(t-e-(t.getTimezoneOffset()-e.getTimezoneOffset())*uc)/m8},function(e){return e.getDate()-1}),ty=J2t,Q2t=J2t.range;function ey(e){return br(function(t){t.setDate(t.getDate()-(t.getDay()+7-e)%7),t.setHours(0,0,0,0)},function(t,r){t.setDate(t.getDate()+r*7)},function(t,r){return(r-t-(r.getTimezoneOffset()-t.getTimezoneOffset())*uc)/g8})}var rg=ey(0),ry=ey(1),lX=ey(2),cX=ey(3),zp=ey(4),uX=ey(5),hX=ey(6),fX=rg.range,twt=ry.range,ewt=lX.range,rwt=cX.range,nwt=zp.range,iwt=uX.range,owt=hX.range;var awt=br(function(e){e.setDate(1),e.setHours(0,0,0,0)},function(e,t){e.setMonth(e.getMonth()+t)},function(e,t){return t.getMonth()-e.getMonth()+(t.getFullYear()-e.getFullYear())*12},function(e){return e.getMonth()}),v8=awt,swt=awt.range;var pX=br(function(e){e.setMonth(0,1),e.setHours(0,0,0,0)},function(e,t){e.setFullYear(e.getFullYear()+t)},function(e,t){return t.getFullYear()-e.getFullYear()},function(e){return e.getFullYear()});pX.every=function(e){return!isFinite(e=Math.floor(e))||!(e>0)?null:br(function(t){t.setFullYear(Math.floor(t.getFullYear()/e)*e),t.setMonth(0,1),t.setHours(0,0,0,0)},function(t,r){t.setFullYear(t.getFullYear()+r*e)})};var Gh=pX,lwt=pX.range;var cwt=br(function(e){e.setUTCSeconds(0,0)},function(e,t){e.setTime(+e+t*uc)},function(e,t){return(t-e)/uc},function(e){return e.getUTCMinutes()}),x8=cwt,uwt=cwt.range;var hwt=br(function(e){e.setUTCMinutes(0,0,0)},function(e,t){e.setTime(+e+t*Gb)},function(e,t){return(t-e)/Gb},function(e){return e.getUTCHours()}),b8=hwt,fwt=hwt.range;var pwt=br(function(e){e.setUTCHours(0,0,0,0)},function(e,t){e.setUTCDate(e.getUTCDate()+t)},function(e,t){return(t-e)/m8},function(e){return e.getUTCDate()-1}),ny=pwt,dwt=pwt.range;function iy(e){return br(function(t){t.setUTCDate(t.getUTCDate()-(t.getUTCDay()+7-e)%7),t.setUTCHours(0,0,0,0)},function(t,r){t.setUTCDate(t.getUTCDate()+r*7)},function(t,r){return(r-t)/g8})}var ng=iy(0),oy=iy(1),dX=iy(2),mX=iy(3),Fp=iy(4),gX=iy(5),_X=iy(6),yX=ng.range,mwt=oy.range,gwt=dX.range,_wt=mX.range,ywt=Fp.range,vwt=gX.range,xwt=_X.range;var bwt=br(function(e){e.setUTCDate(1),e.setUTCHours(0,0,0,0)},function(e,t){e.setUTCMonth(e.getUTCMonth()+t)},function(e,t){return t.getUTCMonth()-e.getUTCMonth()+(t.getUTCFullYear()-e.getUTCFullYear())*12},function(e){return e.getUTCMonth()}),w8=bwt,wwt=bwt.range;var vX=br(function(e){e.setUTCMonth(0,1),e.setUTCHours(0,0,0,0)},function(e,t){e.setUTCFullYear(e.getUTCFullYear()+t)},function(e,t){return t.getUTCFullYear()-e.getUTCFullYear()},function(e){return e.getUTCFullYear()});vX.every=function(e){return!isFinite(e=Math.floor(e))||!(e>0)?null:br(function(t){t.setUTCFullYear(Math.floor(t.getUTCFullYear()/e)*e),t.setUTCMonth(0,1),t.setUTCHours(0,0,0,0)},function(t,r){t.setUTCFullYear(t.getUTCFullYear()+r*e)})};var Wh=vX,Swt=vX.range;function xX(e){if(0<=e.y&&e.y<100){var t=new Date(-1,e.m,e.d,e.H,e.M,e.S,e.L);return t.setFullYear(e.y),t}return new Date(e.y,e.m,e.d,e.H,e.M,e.S,e.L)}function bX(e){if(0<=e.y&&e.y<100){var t=new Date(Date.UTC(-1,e.m,e.d,e.H,e.M,e.S,e.L));return t.setUTCFullYear(e.y),t}return new Date(Date.UTC(e.y,e.m,e.d,e.H,e.M,e.S,e.L))}function x5(e,t,r){return{y:e,m:t,d:r,H:0,M:0,S:0,L:0}}function S5(e){var t=e.dateTime,r=e.date,n=e.time,i=e.periods,o=e.days,a=e.shortDays,s=e.months,l=e.shortMonths,c=b5(i),u=w5(i),h=b5(o),f=w5(o),p=b5(a),d=w5(a),g=b5(s),_=w5(s),y=b5(l),x=w5(l),b={a:W,A:Z,b:rt,B:ot,c:null,d:Pwt,e:Pwt,f:jMe,g:nEe,G:oEe,H:GMe,I:WMe,j:YMe,L:Nwt,m:XMe,M:$Me,p:st,q:St,Q:kwt,s:Rwt,S:KMe,u:ZMe,U:JMe,V:QMe,w:tEe,W:eEe,x:null,X:null,y:rEe,Y:iEe,Z:aEe,"%":Lwt},S={a:bt,A:Mt,b:lt,B:Kt,c:null,d:Iwt,e:Iwt,f:uEe,g:xEe,G:wEe,H:sEe,I:lEe,j:cEe,L:Owt,m:hEe,M:fEe,p:_t,q:ct,Q:kwt,s:Rwt,S:pEe,u:dEe,U:mEe,V:gEe,w:_Ee,W:yEe,x:null,X:null,y:vEe,Y:bEe,Z:SEe,"%":Lwt},C={a:B,A:I,b:L,B:R,c:F,d:Cwt,e:Cwt,f:HMe,g:Twt,G:Ewt,H:Awt,I:Awt,j:OMe,L:BMe,m:DMe,M:zMe,p:D,q:NMe,Q:UMe,s:qMe,S:FMe,u:PMe,U:IMe,V:LMe,w:AMe,W:kMe,x:z,X:U,y:Twt,Y:Ewt,Z:RMe,"%":VMe};b.x=P(r,b),b.X=P(n,b),b.c=P(t,b),S.x=P(r,S),S.X=P(n,S),S.c=P(t,S);function P(X,et){return function(dt){var q=[],pt=-1,ht=0,wt=X.length,kt,ie,ee;for(dt instanceof Date||(dt=new Date(+dt));++pt<wt;)X.charCodeAt(pt)===37&&(q.push(X.slice(ht,pt)),(ie=Mwt[kt=X.charAt(++pt)])!=null?kt=X.charAt(++pt):ie=kt==="e"?" ":"0",(ee=et[kt])&&(kt=ee(dt,ie)),q.push(kt),ht=pt+1);return q.push(X.slice(ht,pt)),q.join("")}}function k(X,et){return function(dt){var q=x5(1900,void 0,1),pt=O(q,X,dt+="",0),ht,wt;if(pt!=dt.length)return null;if("Q"in q)return new Date(q.Q);if("s"in q)return new Date(q.s*1e3+("L"in q?q.L:0));if(et&&!("Z"in q)&&(q.Z=0),"p"in q&&(q.H=q.H%12+q.p*12),q.m===void 0&&(q.m="q"in q?q.q:0),"V"in q){if(q.V<1||q.V>53)return null;"w"in q||(q.w=1),"Z"in q?(ht=bX(x5(q.y,0,1)),wt=ht.getUTCDay(),ht=wt>4||wt===0?oy.ceil(ht):oy(ht),ht=ny.offset(ht,(q.V-1)*7),q.y=ht.getUTCFullYear(),q.m=ht.getUTCMonth(),q.d=ht.getUTCDate()+(q.w+6)%7):(ht=xX(x5(q.y,0,1)),wt=ht.getDay(),ht=wt>4||wt===0?ry.ceil(ht):ry(ht),ht=ty.offset(ht,(q.V-1)*7),q.y=ht.getFullYear(),q.m=ht.getMonth(),q.d=ht.getDate()+(q.w+6)%7)}else("W"in q||"U"in q)&&("w"in q||(q.w="u"in q?q.u%7:"W"in q?1:0),wt="Z"in q?bX(x5(q.y,0,1)).getUTCDay():xX(x5(q.y,0,1)).getDay(),q.m=0,q.d="W"in q?(q.w+6)%7+q.W*7-(wt+5)%7:q.w+q.U*7-(wt+6)%7);return"Z"in q?(q.H+=q.Z/100|0,q.M+=q.Z%100,bX(q)):xX(q)}}function O(X,et,dt,q){for(var pt=0,ht=et.length,wt=dt.length,kt,ie;pt<ht;){if(q>=wt)return-1;if(kt=et.charCodeAt(pt++),kt===37){if(kt=et.charAt(pt++),ie=C[kt in Mwt?et.charAt(pt++):kt],!ie||(q=ie(X,dt,q))<0)return-1}else if(kt!=dt.charCodeAt(q++))return-1}return q}function D(X,et,dt){var q=c.exec(et.slice(dt));return q?(X.p=u[q[0].toLowerCase()],dt+q[0].length):-1}function B(X,et,dt){var q=p.exec(et.slice(dt));return q?(X.w=d[q[0].toLowerCase()],dt+q[0].length):-1}function I(X,et,dt){var q=h.exec(et.slice(dt));return q?(X.w=f[q[0].toLowerCase()],dt+q[0].length):-1}function L(X,et,dt){var q=y.exec(et.slice(dt));return q?(X.m=x[q[0].toLowerCase()],dt+q[0].length):-1}function R(X,et,dt){var q=g.exec(et.slice(dt));return q?(X.m=_[q[0].toLowerCase()],dt+q[0].length):-1}function F(X,et,dt){return O(X,t,et,dt)}function z(X,et,dt){return O(X,r,et,dt)}function U(X,et,dt){return O(X,n,et,dt)}function W(X){return a[X.getDay()]}function Z(X){return o[X.getDay()]}function rt(X){return l[X.getMonth()]}function ot(X){return s[X.getMonth()]}function st(X){return i[+(X.getHours()>=12)]}function St(X){return 1+~~(X.getMonth()/3)}function bt(X){return a[X.getUTCDay()]}function Mt(X){return o[X.getUTCDay()]}function lt(X){return l[X.getUTCMonth()]}function Kt(X){return s[X.getUTCMonth()]}function _t(X){return i[+(X.getUTCHours()>=12)]}function ct(X){return 1+~~(X.getUTCMonth()/3)}return{format:function(X){var et=P(X+="",b);return et.toString=function(){return X},et},parse:function(X){var et=k(X+="",!1);return et.toString=function(){return X},et},utcFormat:function(X){var et=P(X+="",S);return et.toString=function(){return X},et},utcParse:function(X){var et=k(X+="",!0);return et.toString=function(){return X},et}}}var Mwt={"-":"",_:" ",0:"0"},xo=/^\s*\d+/,EMe=/^%/,TMe=/[\\^$*+?|[\]().{}]/g;function Br(e,t,r){var n=e<0?"-":"",i=(n?-e:e)+"",o=i.length;return n+(o<r?new Array(r-o+1).join(t)+i:i)}function CMe(e){return e.replace(TMe,"\\$&")}function b5(e){return new RegExp("^(?:"+e.map(CMe).join("|")+")","i")}function w5(e){for(var t={},r=-1,n=e.length;++r<n;)t[e[r].toLowerCase()]=r;return t}function AMe(e,t,r){var n=xo.exec(t.slice(r,r+1));return n?(e.w=+n[0],r+n[0].length):-1}function PMe(e,t,r){var n=xo.exec(t.slice(r,r+1));return n?(e.u=+n[0],r+n[0].length):-1}function IMe(e,t,r){var n=xo.exec(t.slice(r,r+2));return n?(e.U=+n[0],r+n[0].length):-1}function LMe(e,t,r){var n=xo.exec(t.slice(r,r+2));return n?(e.V=+n[0],r+n[0].length):-1}function kMe(e,t,r){var n=xo.exec(t.slice(r,r+2));return n?(e.W=+n[0],r+n[0].length):-1}function Ewt(e,t,r){var n=xo.exec(t.slice(r,r+4));return n?(e.y=+n[0],r+n[0].length):-1}function Twt(e,t,r){var n=xo.exec(t.slice(r,r+2));return n?(e.y=+n[0]+(+n[0]>68?1900:2e3),r+n[0].length):-1}function RMe(e,t,r){var n=/^(Z)|([+-]\d\d)(?::?(\d\d))?/.exec(t.slice(r,r+6));return n?(e.Z=n[1]?0:-(n[2]+(n[3]||"00")),r+n[0].length):-1}function NMe(e,t,r){var n=xo.exec(t.slice(r,r+1));return n?(e.q=n[0]*3-3,r+n[0].length):-1}function DMe(e,t,r){var n=xo.exec(t.slice(r,r+2));return n?(e.m=n[0]-1,r+n[0].length):-1}function Cwt(e,t,r){var n=xo.exec(t.slice(r,r+2));return n?(e.d=+n[0],r+n[0].length):-1}function OMe(e,t,r){var n=xo.exec(t.slice(r,r+3));return n?(e.m=0,e.d=+n[0],r+n[0].length):-1}function Awt(e,t,r){var n=xo.exec(t.slice(r,r+2));return n?(e.H=+n[0],r+n[0].length):-1}function zMe(e,t,r){var n=xo.exec(t.slice(r,r+2));return n?(e.M=+n[0],r+n[0].length):-1}function FMe(e,t,r){var n=xo.exec(t.slice(r,r+2));return n?(e.S=+n[0],r+n[0].length):-1}function BMe(e,t,r){var n=xo.exec(t.slice(r,r+3));return n?(e.L=+n[0],r+n[0].length):-1}function HMe(e,t,r){var n=xo.exec(t.slice(r,r+6));return n?(e.L=Math.floor(n[0]/1e3),r+n[0].length):-1}function VMe(e,t,r){var n=EMe.exec(t.slice(r,r+1));return n?r+n[0].length:-1}function UMe(e,t,r){var n=xo.exec(t.slice(r));return n?(e.Q=+n[0],r+n[0].length):-1}function qMe(e,t,r){var n=xo.exec(t.slice(r));return n?(e.s=+n[0],r+n[0].length):-1}function Pwt(e,t){return Br(e.getDate(),t,2)}function GMe(e,t){return Br(e.getHours(),t,2)}function WMe(e,t){return Br(e.getHours()%12||12,t,2)}function YMe(e,t){return Br(1+ty.count(Gh(e),e),t,3)}function Nwt(e,t){return Br(e.getMilliseconds(),t,3)}function jMe(e,t){return Nwt(e,t)+"000"}function XMe(e,t){return Br(e.getMonth()+1,t,2)}function $Me(e,t){return Br(e.getMinutes(),t,2)}function KMe(e,t){return Br(e.getSeconds(),t,2)}function ZMe(e){var t=e.getDay();return t===0?7:t}function JMe(e,t){return Br(rg.count(Gh(e)-1,e),t,2)}function Dwt(e){var t=e.getDay();return t>=4||t===0?zp(e):zp.ceil(e)}function QMe(e,t){return e=Dwt(e),Br(zp.count(Gh(e),e)+(Gh(e).getDay()===4),t,2)}function tEe(e){return e.getDay()}function eEe(e,t){return Br(ry.count(Gh(e)-1,e),t,2)}function rEe(e,t){return Br(e.getFullYear()%100,t,2)}function nEe(e,t){return e=Dwt(e),Br(e.getFullYear()%100,t,2)}function iEe(e,t){return Br(e.getFullYear()%1e4,t,4)}function oEe(e,t){var r=e.getDay();return e=r>=4||r===0?zp(e):zp.ceil(e),Br(e.getFullYear()%1e4,t,4)}function aEe(e){var t=e.getTimezoneOffset();return(t>0?"-":(t*=-1,"+"))+Br(t/60|0,"0",2)+Br(t%60,"0",2)}function Iwt(e,t){return Br(e.getUTCDate(),t,2)}function sEe(e,t){return Br(e.getUTCHours(),t,2)}function lEe(e,t){return Br(e.getUTCHours()%12||12,t,2)}function cEe(e,t){return Br(1+ny.count(Wh(e),e),t,3)}function Owt(e,t){return Br(e.getUTCMilliseconds(),t,3)}function uEe(e,t){return Owt(e,t)+"000"}function hEe(e,t){return Br(e.getUTCMonth()+1,t,2)}function fEe(e,t){return Br(e.getUTCMinutes(),t,2)}function pEe(e,t){return Br(e.getUTCSeconds(),t,2)}function dEe(e){var t=e.getUTCDay();return t===0?7:t}function mEe(e,t){return Br(ng.count(Wh(e)-1,e),t,2)}function zwt(e){var t=e.getUTCDay();return t>=4||t===0?Fp(e):Fp.ceil(e)}function gEe(e,t){return e=zwt(e),Br(Fp.count(Wh(e),e)+(Wh(e).getUTCDay()===4),t,2)}function _Ee(e){return e.getUTCDay()}function yEe(e,t){return Br(oy.count(Wh(e)-1,e),t,2)}function vEe(e,t){return Br(e.getUTCFullYear()%100,t,2)}function xEe(e,t){return e=zwt(e),Br(e.getUTCFullYear()%100,t,2)}function bEe(e,t){return Br(e.getUTCFullYear()%1e4,t,4)}function wEe(e,t){var r=e.getUTCDay();return e=r>=4||r===0?Fp(e):Fp.ceil(e),Br(e.getUTCFullYear()%1e4,t,4)}function SEe(){return"+0000"}function Lwt(){return"%"}function kwt(e){return+e}function Rwt(e){return Math.floor(+e/1e3)}var Wb,M5,wX,ay,E5;S8({dateTime:"%x, %X",date:"%-m/%-d/%Y",time:"%-I:%M:%S %p",periods:["AM","PM"],days:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],shortDays:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],months:["January","February","March","April","May","June","July","August","September","October","November","December"],shortMonths:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]});function S8(e){return Wb=S5(e),M5=Wb.format,wX=Wb.parse,ay=Wb.utcFormat,E5=Wb.utcParse,Wb}var SX="%Y-%m-%dT%H:%M:%S.%LZ";function MEe(e){return e.toISOString()}var EEe=Date.prototype.toISOString?MEe:ay(SX),Fwt=EEe;function TEe(e){var t=new Date(e);return isNaN(t)?null:t}var CEe=+new Date("2000-01-01T00:00:00.000Z")?TEe:E5(SX),Bwt=CEe;var T5=1e3,C5=T5*60,A5=C5*60,P5=A5*24,AEe=P5*7,Hwt=P5*30,MX=P5*365;function PEe(e){return new Date(e)}function IEe(e){return e instanceof Date?+e:+new Date(+e)}function M8(e,t,r,n,i,o,a,s,l){var c=g5(ni,ni),u=c.invert,h=c.domain,f=l(".%L"),p=l(":%S"),d=l("%I:%M"),g=l("%I %p"),_=l("%a %d"),y=l("%b %d"),x=l("%B"),b=l("%Y"),S=[[a,1,T5],[a,5,5*T5],[a,15,15*T5],[a,30,30*T5],[o,1,C5],[o,5,5*C5],[o,15,15*C5],[o,30,30*C5],[i,1,A5],[i,3,3*A5],[i,6,6*A5],[i,12,12*A5],[n,1,P5],[n,2,2*P5],[r,1,AEe],[t,1,Hwt],[t,3,3*Hwt],[e,1,MX]];function C(k){return(a(k)<k?f:o(k)<k?p:i(k)<k?d:n(k)<k?g:t(k)<k?r(k)<k?_:y:e(k)<k?x:b)(k)}function P(k,O,D,B){if(k==null&&(k=10),typeof k=="number"){var I=Math.abs(D-O)/k,L=ob(function(R){return R[2]}).right(S,I);L===S.length?(B=tl(O/MX,D/MX,k),k=e):L?(L=S[I/S[L-1][2]<S[L][2]/I?L-1:L],B=L[1],k=L[0]):(B=Math.max(tl(O,D,k),1),k=s)}return B==null?k:k.every(B)}return c.invert=function(k){return new Date(u(k))},c.domain=function(k){return arguments.length?h(X_.call(k,IEe)):h().map(PEe)},c.ticks=function(k,O){var D=h(),B=D[0],I=D[D.length-1],L=I<B,R;return L&&(R=B,B=I,I=R),R=P(k,B,I,O),R=R?R.range(B,I+1):[],L?R.reverse():R},c.tickFormat=function(k,O){return O==null?C:l(O)},c.nice=function(k,O){var D=h();return(k=P(k,D[0],D[D.length-1],O))?h(h8(D,k)):c},c.copy=function(){return qh(c,M8(e,t,r,n,i,o,a,s,l))},c}function Yb(){return hi.apply(M8(Gh,v8,rg,ty,y8,_8,Q_,Z_,M5).domain([new Date(2e3,0,1),new Date(2e3,0,2)]),arguments)}function Vwt(){return hi.apply(M8(Wh,w8,ng,ny,b8,x8,Q_,Z_,ay).domain([Date.UTC(2e3,0,1),Date.UTC(2e3,0,2)]),arguments)}function E8(){var e=0,t=1,r,n,i,o,a=ni,s=!1,l;function c(u){return isNaN(u=+u)?l:a(i===0?.5:(u=(o(u)-r)*i,s?Math.max(0,Math.min(1,u)):u))}return c.domain=function(u){return arguments.length?(r=o(e=+u[0]),n=o(t=+u[1]),i=r===n?0:1/(n-r),c):[e,t]},c.clamp=function(u){return arguments.length?(s=!!u,c):s},c.interpolator=function(u){return arguments.length?(a=u,c):a},c.unknown=function(u){return arguments.length?(l=u,c):l},function(u){return o=u,r=u(e),n=u(t),i=r===n?0:1/(n-r),c}}function Bp(e,t){return t.domain(e.domain()).interpolator(e.interpolator()).clamp(e.clamp()).unknown(e.unknown())}function T8(){var e=il(E8()(ni));return e.copy=function(){return Bp(e,T8())},sc.apply(e,arguments)}function EX(){var e=_5(E8()).domain([1,10]);return e.copy=function(){return Bp(e,EX()).base(e.base())},sc.apply(e,arguments)}function TX(){var e=y5(E8());return e.copy=function(){return Bp(e,TX()).constant(e.constant())},sc.apply(e,arguments)}function C8(){var e=v5(E8());return e.copy=function(){return Bp(e,C8()).exponent(e.exponent())},sc.apply(e,arguments)}function Uwt(){return C8.apply(null,arguments).exponent(.5)}function A8(){var e=[],t=ni;function r(n){if(!isNaN(n=+n))return t((ys(e,n)-1)/(e.length-1))}return r.domain=function(n){if(!arguments.length)return e.slice();e=[];for(var i=0,o=n.length,a;i<o;++i)a=n[i],a!=null&&!isNaN(a=+a)&&e.push(a);return e.sort(oa),r},r.interpolator=function(n){return arguments.length?(t=n,r):t},r.copy=function(){return A8(t).domain(e)},sc.apply(r,arguments)}function P8(){var e=0,t=.5,r=1,n,i,o,a,s,l=ni,c,u=!1,h;function f(p){return isNaN(p=+p)?h:(p=.5+((p=+c(p))-i)*(p<i?a:s),l(u?Math.max(0,Math.min(1,p)):p))}return f.domain=function(p){return arguments.length?(n=c(e=+p[0]),i=c(t=+p[1]),o=c(r=+p[2]),a=n===i?0:.5/(i-n),s=i===o?0:.5/(o-i),f):[e,t,r]},f.clamp=function(p){return arguments.length?(u=!!p,f):u},f.interpolator=function(p){return arguments.length?(l=p,f):l},f.unknown=function(p){return arguments.length?(h=p,f):h},function(p){return c=p,n=p(e),i=p(t),o=p(r),a=n===i?0:.5/(i-n),s=i===o?0:.5/(o-i),f}}function I8(){var e=il(P8()(ni));return e.copy=function(){return Bp(e,I8())},sc.apply(e,arguments)}function CX(){var e=_5(P8()).domain([.1,1,10]);return e.copy=function(){return Bp(e,CX()).base(e.base())},sc.apply(e,arguments)}function AX(){var e=y5(P8());return e.copy=function(){return Bp(e,AX()).constant(e.constant())},sc.apply(e,arguments)}function L8(){var e=v5(P8());return e.copy=function(){return Bp(e,L8()).exponent(e.exponent())},sc.apply(e,arguments)}function qwt(){return L8.apply(null,arguments).exponent(.5)}function te(e){for(var t=e.length/6|0,r=new Array(t),n=0;n<t;)r[n]="#"+e.slice(n*6,++n*6);return r}var jb=te("1f77b4ff7f0e2ca02cd627289467bd8c564be377c27f7f7fbcbd2217becf");var Gwt=te("7fc97fbeaed4fdc086ffff99386cb0f0027fbf5b17666666");var Wwt=te("1b9e77d95f027570b3e7298a66a61ee6ab02a6761d666666");var Ywt=te("a6cee31f78b4b2df8a33a02cfb9a99e31a1cfdbf6fff7f00cab2d66a3d9affff99b15928");var jwt=te("fbb4aeb3cde3ccebc5decbe4fed9a6ffffcce5d8bdfddaecf2f2f2");var Xwt=te("b3e2cdfdcdaccbd5e8f4cae4e6f5c9fff2aef1e2cccccccc");var $wt=te("e41a1c377eb84daf4a984ea3ff7f00ffff33a65628f781bf999999");var Kwt=te("66c2a5fc8d628da0cbe78ac3a6d854ffd92fe5c494b3b3b3");var Zwt=te("8dd3c7ffffb3bebadafb807280b1d3fdb462b3de69fccde5d9d9d9bc80bdccebc5ffed6f");var Jwt=te("4e79a7f28e2ce1575976b7b259a14fedc949af7aa1ff9da79c755fbab0ab");function Ie(e){return uL(e[e.length-1])}var PX=new Array(3).concat("d8b365f5f5f55ab4ac","a6611adfc27d80cdc1018571","a6611adfc27df5f5f580cdc1018571","8c510ad8b365f6e8c3c7eae55ab4ac01665e","8c510ad8b365f6e8c3f5f5f5c7eae55ab4ac01665e","8c510abf812ddfc27df6e8c3c7eae580cdc135978f01665e","8c510abf812ddfc27df6e8c3f5f5f5c7eae580cdc135978f01665e","5430058c510abf812ddfc27df6e8c3c7eae580cdc135978f01665e003c30","5430058c510abf812ddfc27df6e8c3f5f5f5c7eae580cdc135978f01665e003c30").map(te),Qwt=Ie(PX);var IX=new Array(3).concat("af8dc3f7f7f77fbf7b","7b3294c2a5cfa6dba0008837","7b3294c2a5cff7f7f7a6dba0008837","762a83af8dc3e7d4e8d9f0d37fbf7b1b7837","762a83af8dc3e7d4e8f7f7f7d9f0d37fbf7b1b7837","762a839970abc2a5cfe7d4e8d9f0d3a6dba05aae611b7837","762a839970abc2a5cfe7d4e8f7f7f7d9f0d3a6dba05aae611b7837","40004b762a839970abc2a5cfe7d4e8d9f0d3a6dba05aae611b783700441b","40004b762a839970abc2a5cfe7d4e8f7f7f7d9f0d3a6dba05aae611b783700441b").map(te),tSt=Ie(IX);var LX=new Array(3).concat("e9a3c9f7f7f7a1d76a","d01c8bf1b6dab8e1864dac26","d01c8bf1b6daf7f7f7b8e1864dac26","c51b7de9a3c9fde0efe6f5d0a1d76a4d9221","c51b7de9a3c9fde0eff7f7f7e6f5d0a1d76a4d9221","c51b7dde77aef1b6dafde0efe6f5d0b8e1867fbc414d9221","c51b7dde77aef1b6dafde0eff7f7f7e6f5d0b8e1867fbc414d9221","8e0152c51b7dde77aef1b6dafde0efe6f5d0b8e1867fbc414d9221276419","8e0152c51b7dde77aef1b6dafde0eff7f7f7e6f5d0b8e1867fbc414d9221276419").map(te),eSt=Ie(LX);var kX=new Array(3).concat("998ec3f7f7f7f1a340","5e3c99b2abd2fdb863e66101","5e3c99b2abd2f7f7f7fdb863e66101","542788998ec3d8daebfee0b6f1a340b35806","542788998ec3d8daebf7f7f7fee0b6f1a340b35806","5427888073acb2abd2d8daebfee0b6fdb863e08214b35806","5427888073acb2abd2d8daebf7f7f7fee0b6fdb863e08214b35806","2d004b5427888073acb2abd2d8daebfee0b6fdb863e08214b358067f3b08","2d004b5427888073acb2abd2d8daebf7f7f7fee0b6fdb863e08214b358067f3b08").map(te),rSt=Ie(kX);var RX=new Array(3).concat("ef8a62f7f7f767a9cf","ca0020f4a58292c5de0571b0","ca0020f4a582f7f7f792c5de0571b0","b2182bef8a62fddbc7d1e5f067a9cf2166ac","b2182bef8a62fddbc7f7f7f7d1e5f067a9cf2166ac","b2182bd6604df4a582fddbc7d1e5f092c5de4393c32166ac","b2182bd6604df4a582fddbc7f7f7f7d1e5f092c5de4393c32166ac","67001fb2182bd6604df4a582fddbc7d1e5f092c5de4393c32166ac053061","67001fb2182bd6604df4a582fddbc7f7f7f7d1e5f092c5de4393c32166ac053061").map(te),nSt=Ie(RX);var NX=new Array(3).concat("ef8a62ffffff999999","ca0020f4a582bababa404040","ca0020f4a582ffffffbababa404040","b2182bef8a62fddbc7e0e0e09999994d4d4d","b2182bef8a62fddbc7ffffffe0e0e09999994d4d4d","b2182bd6604df4a582fddbc7e0e0e0bababa8787874d4d4d","b2182bd6604df4a582fddbc7ffffffe0e0e0bababa8787874d4d4d","67001fb2182bd6604df4a582fddbc7e0e0e0bababa8787874d4d4d1a1a1a","67001fb2182bd6604df4a582fddbc7ffffffe0e0e0bababa8787874d4d4d1a1a1a").map(te),iSt=Ie(NX);var DX=new Array(3).concat("fc8d59ffffbf91bfdb","d7191cfdae61abd9e92c7bb6","d7191cfdae61ffffbfabd9e92c7bb6","d73027fc8d59fee090e0f3f891bfdb4575b4","d73027fc8d59fee090ffffbfe0f3f891bfdb4575b4","d73027f46d43fdae61fee090e0f3f8abd9e974add14575b4","d73027f46d43fdae61fee090ffffbfe0f3f8abd9e974add14575b4","a50026d73027f46d43fdae61fee090e0f3f8abd9e974add14575b4313695","a50026d73027f46d43fdae61fee090ffffbfe0f3f8abd9e974add14575b4313695").map(te),oSt=Ie(DX);var OX=new Array(3).concat("fc8d59ffffbf91cf60","d7191cfdae61a6d96a1a9641","d7191cfdae61ffffbfa6d96a1a9641","d73027fc8d59fee08bd9ef8b91cf601a9850","d73027fc8d59fee08bffffbfd9ef8b91cf601a9850","d73027f46d43fdae61fee08bd9ef8ba6d96a66bd631a9850","d73027f46d43fdae61fee08bffffbfd9ef8ba6d96a66bd631a9850","a50026d73027f46d43fdae61fee08bd9ef8ba6d96a66bd631a9850006837","a50026d73027f46d43fdae61fee08bffffbfd9ef8ba6d96a66bd631a9850006837").map(te),aSt=Ie(OX);var zX=new Array(3).concat("fc8d59ffffbf99d594","d7191cfdae61abdda42b83ba","d7191cfdae61ffffbfabdda42b83ba","d53e4ffc8d59fee08be6f59899d5943288bd","d53e4ffc8d59fee08bffffbfe6f59899d5943288bd","d53e4ff46d43fdae61fee08be6f598abdda466c2a53288bd","d53e4ff46d43fdae61fee08bffffbfe6f598abdda466c2a53288bd","9e0142d53e4ff46d43fdae61fee08be6f598abdda466c2a53288bd5e4fa2","9e0142d53e4ff46d43fdae61fee08bffffbfe6f598abdda466c2a53288bd5e4fa2").map(te),sSt=Ie(zX);var FX=new Array(3).concat("e5f5f999d8c92ca25f","edf8fbb2e2e266c2a4238b45","edf8fbb2e2e266c2a42ca25f006d2c","edf8fbccece699d8c966c2a42ca25f006d2c","edf8fbccece699d8c966c2a441ae76238b45005824","f7fcfde5f5f9ccece699d8c966c2a441ae76238b45005824","f7fcfde5f5f9ccece699d8c966c2a441ae76238b45006d2c00441b").map(te),lSt=Ie(FX);var BX=new Array(3).concat("e0ecf49ebcda8856a7","edf8fbb3cde38c96c688419d","edf8fbb3cde38c96c68856a7810f7c","edf8fbbfd3e69ebcda8c96c68856a7810f7c","edf8fbbfd3e69ebcda8c96c68c6bb188419d6e016b","f7fcfde0ecf4bfd3e69ebcda8c96c68c6bb188419d6e016b","f7fcfde0ecf4bfd3e69ebcda8c96c68c6bb188419d810f7c4d004b").map(te),cSt=Ie(BX);var HX=new Array(3).concat("e0f3dba8ddb543a2ca","f0f9e8bae4bc7bccc42b8cbe","f0f9e8bae4bc7bccc443a2ca0868ac","f0f9e8ccebc5a8ddb57bccc443a2ca0868ac","f0f9e8ccebc5a8ddb57bccc44eb3d32b8cbe08589e","f7fcf0e0f3dbccebc5a8ddb57bccc44eb3d32b8cbe08589e","f7fcf0e0f3dbccebc5a8ddb57bccc44eb3d32b8cbe0868ac084081").map(te),uSt=Ie(HX);var VX=new Array(3).concat("fee8c8fdbb84e34a33","fef0d9fdcc8afc8d59d7301f","fef0d9fdcc8afc8d59e34a33b30000","fef0d9fdd49efdbb84fc8d59e34a33b30000","fef0d9fdd49efdbb84fc8d59ef6548d7301f990000","fff7ecfee8c8fdd49efdbb84fc8d59ef6548d7301f990000","fff7ecfee8c8fdd49efdbb84fc8d59ef6548d7301fb300007f0000").map(te),hSt=Ie(VX);var UX=new Array(3).concat("ece2f0a6bddb1c9099","f6eff7bdc9e167a9cf02818a","f6eff7bdc9e167a9cf1c9099016c59","f6eff7d0d1e6a6bddb67a9cf1c9099016c59","f6eff7d0d1e6a6bddb67a9cf3690c002818a016450","fff7fbece2f0d0d1e6a6bddb67a9cf3690c002818a016450","fff7fbece2f0d0d1e6a6bddb67a9cf3690c002818a016c59014636").map(te),fSt=Ie(UX);var qX=new Array(3).concat("ece7f2a6bddb2b8cbe","f1eef6bdc9e174a9cf0570b0","f1eef6bdc9e174a9cf2b8cbe045a8d","f1eef6d0d1e6a6bddb74a9cf2b8cbe045a8d","f1eef6d0d1e6a6bddb74a9cf3690c00570b0034e7b","fff7fbece7f2d0d1e6a6bddb74a9cf3690c00570b0034e7b","fff7fbece7f2d0d1e6a6bddb74a9cf3690c00570b0045a8d023858").map(te),pSt=Ie(qX);var GX=new Array(3).concat("e7e1efc994c7dd1c77","f1eef6d7b5d8df65b0ce1256","f1eef6d7b5d8df65b0dd1c77980043","f1eef6d4b9dac994c7df65b0dd1c77980043","f1eef6d4b9dac994c7df65b0e7298ace125691003f","f7f4f9e7e1efd4b9dac994c7df65b0e7298ace125691003f","f7f4f9e7e1efd4b9dac994c7df65b0e7298ace125698004367001f").map(te),dSt=Ie(GX);var WX=new Array(3).concat("fde0ddfa9fb5c51b8a","feebe2fbb4b9f768a1ae017e","feebe2fbb4b9f768a1c51b8a7a0177","feebe2fcc5c0fa9fb5f768a1c51b8a7a0177","feebe2fcc5c0fa9fb5f768a1dd3497ae017e7a0177","fff7f3fde0ddfcc5c0fa9fb5f768a1dd3497ae017e7a0177","fff7f3fde0ddfcc5c0fa9fb5f768a1dd3497ae017e7a017749006a").map(te),mSt=Ie(WX);var YX=new Array(3).concat("edf8b17fcdbb2c7fb8","ffffcca1dab441b6c4225ea8","ffffcca1dab441b6c42c7fb8253494","ffffccc7e9b47fcdbb41b6c42c7fb8253494","ffffccc7e9b47fcdbb41b6c41d91c0225ea80c2c84","ffffd9edf8b1c7e9b47fcdbb41b6c41d91c0225ea80c2c84","ffffd9edf8b1c7e9b47fcdbb41b6c41d91c0225ea8253494081d58").map(te),gSt=Ie(YX);var jX=new Array(3).concat("f7fcb9addd8e31a354","ffffccc2e69978c679238443","ffffccc2e69978c67931a354006837","ffffccd9f0a3addd8e78c67931a354006837","ffffccd9f0a3addd8e78c67941ab5d238443005a32","ffffe5f7fcb9d9f0a3addd8e78c67941ab5d238443005a32","ffffe5f7fcb9d9f0a3addd8e78c67941ab5d238443006837004529").map(te),_St=Ie(jX);var XX=new Array(3).concat("fff7bcfec44fd95f0e","ffffd4fed98efe9929cc4c02","ffffd4fed98efe9929d95f0e993404","ffffd4fee391fec44ffe9929d95f0e993404","ffffd4fee391fec44ffe9929ec7014cc4c028c2d04","ffffe5fff7bcfee391fec44ffe9929ec7014cc4c028c2d04","ffffe5fff7bcfee391fec44ffe9929ec7014cc4c02993404662506").map(te),ySt=Ie(XX);var $X=new Array(3).concat("ffeda0feb24cf03b20","ffffb2fecc5cfd8d3ce31a1c","ffffb2fecc5cfd8d3cf03b20bd0026","ffffb2fed976feb24cfd8d3cf03b20bd0026","ffffb2fed976feb24cfd8d3cfc4e2ae31a1cb10026","ffffccffeda0fed976feb24cfd8d3cfc4e2ae31a1cb10026","ffffccffeda0fed976feb24cfd8d3cfc4e2ae31a1cbd0026800026").map(te),vSt=Ie($X);var KX=new Array(3).concat("deebf79ecae13182bd","eff3ffbdd7e76baed62171b5","eff3ffbdd7e76baed63182bd08519c","eff3ffc6dbef9ecae16baed63182bd08519c","eff3ffc6dbef9ecae16baed64292c62171b5084594","f7fbffdeebf7c6dbef9ecae16baed64292c62171b5084594","f7fbffdeebf7c6dbef9ecae16baed64292c62171b508519c08306b").map(te),xSt=Ie(KX);var ZX=new Array(3).concat("e5f5e0a1d99b31a354","edf8e9bae4b374c476238b45","edf8e9bae4b374c47631a354006d2c","edf8e9c7e9c0a1d99b74c47631a354006d2c","edf8e9c7e9c0a1d99b74c47641ab5d238b45005a32","f7fcf5e5f5e0c7e9c0a1d99b74c47641ab5d238b45005a32","f7fcf5e5f5e0c7e9c0a1d99b74c47641ab5d238b45006d2c00441b").map(te),bSt=Ie(ZX);var JX=new Array(3).concat("f0f0f0bdbdbd636363","f7f7f7cccccc969696525252","f7f7f7cccccc969696636363252525","f7f7f7d9d9d9bdbdbd969696636363252525","f7f7f7d9d9d9bdbdbd969696737373525252252525","fffffff0f0f0d9d9d9bdbdbd969696737373525252252525","fffffff0f0f0d9d9d9bdbdbd969696737373525252252525000000").map(te),wSt=Ie(JX);var QX=new Array(3).concat("efedf5bcbddc756bb1","f2f0f7cbc9e29e9ac86a51a3","f2f0f7cbc9e29e9ac8756bb154278f","f2f0f7dadaebbcbddc9e9ac8756bb154278f","f2f0f7dadaebbcbddc9e9ac8807dba6a51a34a1486","fcfbfdefedf5dadaebbcbddc9e9ac8807dba6a51a34a1486","fcfbfdefedf5dadaebbcbddc9e9ac8807dba6a51a354278f3f007d").map(te),SSt=Ie(QX);var t$=new Array(3).concat("fee0d2fc9272de2d26","fee5d9fcae91fb6a4acb181d","fee5d9fcae91fb6a4ade2d26a50f15","fee5d9fcbba1fc9272fb6a4ade2d26a50f15","fee5d9fcbba1fc9272fb6a4aef3b2ccb181d99000d","fff5f0fee0d2fcbba1fc9272fb6a4aef3b2ccb181d99000d","fff5f0fee0d2fcbba1fc9272fb6a4aef3b2ccb181da50f1567000d").map(te),MSt=Ie(t$);var e$=new Array(3).concat("fee6cefdae6be6550d","feeddefdbe85fd8d3cd94701","feeddefdbe85fd8d3ce6550da63603","feeddefdd0a2fdae6bfd8d3ce6550da63603","feeddefdd0a2fdae6bfd8d3cf16913d948018c2d04","fff5ebfee6cefdd0a2fdae6bfd8d3cf16913d948018c2d04","fff5ebfee6cefdd0a2fdae6bfd8d3cf16913d94801a636037f2704").map(te),ESt=Ie(e$);function TSt(e){return e=Math.max(0,Math.min(1,e)),"rgb("+Math.max(0,Math.min(255,Math.round(-4.54-e*(35.34-e*(2381.73-e*(6402.7-e*(7024.72-e*2710.57)))))))+", "+Math.max(0,Math.min(255,Math.round(32.49+e*(170.73+e*(52.82-e*(131.46-e*(176.58-e*67.37)))))))+", "+Math.max(0,Math.min(255,Math.round(81.24+e*(442.36-e*(2482.43-e*(6167.24-e*(6614.94-e*2475.67)))))))+")"}var CSt=E_(la(300,.5,0),la(-240,.5,1));var ASt=E_(la(-100,.75,.35),la(80,1.5,.8)),PSt=E_(la(260,.75,.35),la(80,1.5,.8)),k8=la();function ISt(e){(e<0||e>1)&&(e-=Math.floor(e));var t=Math.abs(e-.5);return k8.h=360*e-100,k8.s=1.5-1.5*t,k8.l=.8-.9*t,k8+""}var R8=cu(),LEe=Math.PI/3,kEe=Math.PI*2/3;function LSt(e){var t;return e=(.5-e)*Math.PI,R8.r=255*(t=Math.sin(e))*t,R8.g=255*(t=Math.sin(e+LEe))*t,R8.b=255*(t=Math.sin(e+kEe))*t,R8+""}function kSt(e){return e=Math.max(0,Math.min(1,e)),"rgb("+Math.max(0,Math.min(255,Math.round(34.61+e*(1172.33-e*(10793.56-e*(33300.12-e*(38394.49-e*14825.05)))))))+", "+Math.max(0,Math.min(255,Math.round(23.31+e*(557.33+e*(1225.33-e*(3574.96-e*(1073.77+e*707.56)))))))+", "+Math.max(0,Math.min(255,Math.round(27.2+e*(3211.1-e*(15327.97-e*(27814-e*(22569.18-e*6838.66)))))))+")"}function N8(e){var t=e.length;return function(r){return e[Math.max(0,Math.min(t-1,Math.floor(r*t)))]}}var RSt=N8(te("44015444025645045745055946075a46085c460a5d460b5e470d60470e6147106347116447136548146748166848176948186a481a6c481b6d481c6e481d6f481f70482071482173482374482475482576482677482878482979472a7a472c7a472d7b472e7c472f7d46307e46327e46337f463480453581453781453882443983443a83443b84433d84433e85423f854240864241864142874144874045884046883f47883f48893e49893e4a893e4c8a3d4d8a3d4e8a3c4f8a3c508b3b518b3b528b3a538b3a548c39558c39568c38588c38598c375a8c375b8d365c8d365d8d355e8d355f8d34608d34618d33628d33638d32648e32658e31668e31678e31688e30698e306a8e2f6b8e2f6c8e2e6d8e2e6e8e2e6f8e2d708e2d718e2c718e2c728e2c738e2b748e2b758e2a768e2a778e2a788e29798e297a8e297b8e287c8e287d8e277e8e277f8e27808e26818e26828e26828e25838e25848e25858e24868e24878e23888e23898e238a8d228b8d228c8d228d8d218e8d218f8d21908d21918c20928c20928c20938c1f948c1f958b1f968b1f978b1f988b1f998a1f9a8a1e9b8a1e9c891e9d891f9e891f9f881fa0881fa1881fa1871fa28720a38620a48621a58521a68522a78522a88423a98324aa8325ab8225ac8226ad8127ad8128ae8029af7f2ab07f2cb17e2db27d2eb37c2fb47c31b57b32b67a34b67935b77937b87838b9773aba763bbb753dbc743fbc7340bd7242be7144bf7046c06f48c16e4ac16d4cc26c4ec36b50c46a52c56954c56856c66758c7655ac8645cc8635ec96260ca6063cb5f65cb5e67cc5c69cd5b6ccd5a6ece5870cf5773d05675d05477d1537ad1517cd2507fd34e81d34d84d44b86d54989d5488bd6468ed64590d74393d74195d84098d83e9bd93c9dd93ba0da39a2da37a5db36a8db34aadc32addc30b0dd2fb2dd2db5de2bb8de29bade28bddf26c0df25c2df23c5e021c8e020cae11fcde11dd0e11cd2e21bd5e21ad8e219dae319dde318dfe318e2e418e5e419e7e419eae51aece51befe51cf1e51df4e61ef6e620f8e621fbe723fde725")),NSt=N8(te("00000401000501010601010802010902020b02020d03030f03031204041405041606051806051a07061c08071e0907200a08220b09240c09260d0a290e0b2b100b2d110c2f120d31130d34140e36150e38160f3b180f3d19103f1a10421c10441d11471e114920114b21114e22115024125325125527125829115a2a115c2c115f2d11612f116331116533106734106936106b38106c390f6e3b0f703d0f713f0f72400f74420f75440f764510774710784910784a10794c117a4e117b4f127b51127c52137c54137d56147d57157e59157e5a167e5c167f5d177f5f187f601880621980641a80651a80671b80681c816a1c816b1d816d1d816e1e81701f81721f817320817521817621817822817922827b23827c23827e24828025828125818326818426818627818827818928818b29818c29818e2a81902a81912b81932b80942c80962c80982d80992d809b2e7f9c2e7f9e2f7fa02f7fa1307ea3307ea5317ea6317da8327daa337dab337cad347cae347bb0357bb2357bb3367ab5367ab73779b83779ba3878bc3978bd3977bf3a77c03a76c23b75c43c75c53c74c73d73c83e73ca3e72cc3f71cd4071cf4070d0416fd2426fd3436ed5446dd6456cd8456cd9466bdb476adc4869de4968df4a68e04c67e24d66e34e65e44f64e55064e75263e85362e95462ea5661eb5760ec5860ed5a5fee5b5eef5d5ef05f5ef1605df2625df2645cf3655cf4675cf4695cf56b5cf66c5cf66e5cf7705cf7725cf8745cf8765cf9785df9795df97b5dfa7d5efa7f5efa815ffb835ffb8560fb8761fc8961fc8a62fc8c63fc8e64fc9065fd9266fd9467fd9668fd9869fd9a6afd9b6bfe9d6cfe9f6dfea16efea36ffea571fea772fea973feaa74feac76feae77feb078feb27afeb47bfeb67cfeb77efeb97ffebb81febd82febf84fec185fec287fec488fec68afec88cfeca8dfecc8ffecd90fecf92fed194fed395fed597fed799fed89afdda9cfddc9efddea0fde0a1fde2a3fde3a5fde5a7fde7a9fde9aafdebacfcecaefceeb0fcf0b2fcf2b4fcf4b6fcf6b8fcf7b9fcf9bbfcfbbdfcfdbf")),DSt=N8(te("00000401000501010601010802010a02020c02020e03021004031204031405041706041907051b08051d09061f0a07220b07240c08260d08290e092b10092d110a30120a32140b34150b37160b39180c3c190c3e1b0c411c0c431e0c451f0c48210c4a230c4c240c4f260c51280b53290b552b0b572d0b592f0a5b310a5c320a5e340a5f3609613809623909633b09643d09653e0966400a67420a68440a68450a69470b6a490b6a4a0c6b4c0c6b4d0d6c4f0d6c510e6c520e6d540f6d550f6d57106e59106e5a116e5c126e5d126e5f136e61136e62146e64156e65156e67166e69166e6a176e6c186e6d186e6f196e71196e721a6e741a6e751b6e771c6d781c6d7a1d6d7c1d6d7d1e6d7f1e6c801f6c82206c84206b85216b87216b88226a8a226a8c23698d23698f24699025689225689326679526679727669827669a28659b29649d29649f2a63a02a63a22b62a32c61a52c60a62d60a82e5fa92e5eab2f5ead305dae305cb0315bb1325ab3325ab43359b63458b73557b93556ba3655bc3754bd3853bf3952c03a51c13a50c33b4fc43c4ec63d4dc73e4cc83f4bca404acb4149cc4248ce4347cf4446d04545d24644d34743d44842d54a41d74b3fd84c3ed94d3dda4e3cdb503bdd513ade5238df5337e05536e15635e25734e35933e45a31e55c30e65d2fe75e2ee8602de9612bea632aeb6429eb6628ec6726ed6925ee6a24ef6c23ef6e21f06f20f1711ff1731df2741cf3761bf37819f47918f57b17f57d15f67e14f68013f78212f78410f8850ff8870ef8890cf98b0bf98c0af98e09fa9008fa9207fa9407fb9606fb9706fb9906fb9b06fb9d07fc9f07fca108fca309fca50afca60cfca80dfcaa0ffcac11fcae12fcb014fcb216fcb418fbb61afbb81dfbba1ffbbc21fbbe23fac026fac228fac42afac62df9c72ff9c932f9cb35f8cd37f8cf3af7d13df7d340f6d543f6d746f5d949f5db4cf4dd4ff4df53f4e156f3e35af3e55df2e661f2e865f2ea69f1ec6df1ed71f1ef75f1f179f2f27df2f482f3f586f3f68af4f88ef5f992f6fa96f8fb9af9fc9dfafda1fcffa4")),OSt=N8(te("0d088710078813078916078a19068c1b068d1d068e20068f2206902406912605912805922a05932c05942e05952f059631059733059735049837049938049a3a049a3c049b3e049c3f049c41049d43039e44039e46039f48039f4903a04b03a14c02a14e02a25002a25102a35302a35502a45601a45801a45901a55b01a55c01a65e01a66001a66100a76300a76400a76600a76700a86900a86a00a86c00a86e00a86f00a87100a87201a87401a87501a87701a87801a87a02a87b02a87d03a87e03a88004a88104a78305a78405a78606a68707a68808a68a09a58b0aa58d0ba58e0ca48f0da4910ea3920fa39410a29511a19613a19814a099159f9a169f9c179e9d189d9e199da01a9ca11b9ba21d9aa31e9aa51f99a62098a72197a82296aa2395ab2494ac2694ad2793ae2892b02991b12a90b22b8fb32c8eb42e8db52f8cb6308bb7318ab83289ba3388bb3488bc3587bd3786be3885bf3984c03a83c13b82c23c81c33d80c43e7fc5407ec6417dc7427cc8437bc9447aca457acb4679cc4778cc4977cd4a76ce4b75cf4c74d04d73d14e72d24f71d35171d45270d5536fd5546ed6556dd7566cd8576bd9586ada5a6ada5b69db5c68dc5d67dd5e66de5f65de6164df6263e06363e16462e26561e26660e3685fe4695ee56a5de56b5de66c5ce76e5be76f5ae87059e97158e97257ea7457eb7556eb7655ec7754ed7953ed7a52ee7b51ef7c51ef7e50f07f4ff0804ef1814df1834cf2844bf3854bf3874af48849f48948f58b47f58c46f68d45f68f44f79044f79143f79342f89441f89540f9973ff9983ef99a3efa9b3dfa9c3cfa9e3bfb9f3afba139fba238fca338fca537fca636fca835fca934fdab33fdac33fdae32fdaf31fdb130fdb22ffdb42ffdb52efeb72dfeb82cfeba2cfebb2bfebd2afebe2afec029fdc229fdc328fdc527fdc627fdc827fdca26fdcb26fccd25fcce25fcd025fcd225fbd324fbd524fbd724fad824fada24f9dc24f9dd25f8df25f8e125f7e225f7e425f6e626f6e826f5e926f5eb27f4ed27f3ee27f3f027f2f227f1f426f1f525f0f724f0f921"));function qe(e){return function(){return e}}var r$=Math.abs,Bo=Math.atan2,ig=Math.cos,zSt=Math.max,D8=Math.min,_u=Math.sin,sy=Math.sqrt,bo=1e-12,yu=Math.PI,I5=yu/2,hc=2*yu;function FSt(e){return e>1?0:e<-1?yu:Math.acos(e)}function n$(e){return e>=1?I5:e<=-1?-I5:Math.asin(e)}function REe(e){return e.innerRadius}function NEe(e){return e.outerRadius}function DEe(e){return e.startAngle}function OEe(e){return e.endAngle}function zEe(e){return e&&e.padAngle}function FEe(e,t,r,n,i,o,a,s){var l=r-e,c=n-t,u=a-i,h=s-o,f=h*l-u*c;if(!(f*f<bo))return f=(u*(t-o)-h*(e-i))/f,[e+f*l,t+f*c]}function O8(e,t,r,n,i,o,a){var s=e-r,l=t-n,c=(a?o:-o)/sy(s*s+l*l),u=c*l,h=-c*s,f=e+u,p=t+h,d=r+u,g=n+h,_=(f+d)/2,y=(p+g)/2,x=d-f,b=g-p,S=x*x+b*b,C=i-o,P=f*g-d*p,k=(b<0?-1:1)*sy(zSt(0,C*C*S-P*P)),O=(P*b-x*k)/S,D=(-P*x-b*k)/S,B=(P*b+x*k)/S,I=(-P*x+b*k)/S,L=O-_,R=D-y,F=B-_,z=I-y;return L*L+R*R>F*F+z*z&&(O=B,D=I),{cx:O,cy:D,x01:-u,y01:-h,x11:O*(i/C-1),y11:D*(i/C-1)}}function BSt(){var e=REe,t=NEe,r=qe(0),n=null,i=DEe,o=OEe,a=zEe,s=null;function l(){var c,u,h=+e.apply(this,arguments),f=+t.apply(this,arguments),p=i.apply(this,arguments)-I5,d=o.apply(this,arguments)-I5,g=r$(d-p),_=d>p;if(s||(s=c=bs()),f<h&&(u=f,f=h,h=u),!(f>bo))s.moveTo(0,0);else if(g>hc-bo)s.moveTo(f*ig(p),f*_u(p)),s.arc(0,0,f,p,d,!_),h>bo&&(s.moveTo(h*ig(d),h*_u(d)),s.arc(0,0,h,d,p,_));else{var y=p,x=d,b=p,S=d,C=g,P=g,k=a.apply(this,arguments)/2,O=k>bo&&(n?+n.apply(this,arguments):sy(h*h+f*f)),D=D8(r$(f-h)/2,+r.apply(this,arguments)),B=D,I=D,L,R;if(O>bo){var F=n$(O/h*_u(k)),z=n$(O/f*_u(k));(C-=F*2)>bo?(F*=_?1:-1,b+=F,S-=F):(C=0,b=S=(p+d)/2),(P-=z*2)>bo?(z*=_?1:-1,y+=z,x-=z):(P=0,y=x=(p+d)/2)}var U=f*ig(y),W=f*_u(y),Z=h*ig(S),rt=h*_u(S);if(D>bo){var ot=f*ig(x),st=f*_u(x),St=h*ig(b),bt=h*_u(b),Mt;if(g<yu&&(Mt=FEe(U,W,St,bt,ot,st,Z,rt))){var lt=U-Mt[0],Kt=W-Mt[1],_t=ot-Mt[0],ct=st-Mt[1],X=1/_u(FSt((lt*_t+Kt*ct)/(sy(lt*lt+Kt*Kt)*sy(_t*_t+ct*ct)))/2),et=sy(Mt[0]*Mt[0]+Mt[1]*Mt[1]);B=D8(D,(h-et)/(X-1)),I=D8(D,(f-et)/(X+1))}}P>bo?I>bo?(L=O8(St,bt,U,W,f,I,_),R=O8(ot,st,Z,rt,f,I,_),s.moveTo(L.cx+L.x01,L.cy+L.y01),I<D?s.arc(L.cx,L.cy,I,Bo(L.y01,L.x01),Bo(R.y01,R.x01),!_):(s.arc(L.cx,L.cy,I,Bo(L.y01,L.x01),Bo(L.y11,L.x11),!_),s.arc(0,0,f,Bo(L.cy+L.y11,L.cx+L.x11),Bo(R.cy+R.y11,R.cx+R.x11),!_),s.arc(R.cx,R.cy,I,Bo(R.y11,R.x11),Bo(R.y01,R.x01),!_))):(s.moveTo(U,W),s.arc(0,0,f,y,x,!_)):s.moveTo(U,W),!(h>bo)||!(C>bo)?s.lineTo(Z,rt):B>bo?(L=O8(Z,rt,ot,st,h,-B,_),R=O8(U,W,St,bt,h,-B,_),s.lineTo(L.cx+L.x01,L.cy+L.y01),B<D?s.arc(L.cx,L.cy,B,Bo(L.y01,L.x01),Bo(R.y01,R.x01),!_):(s.arc(L.cx,L.cy,B,Bo(L.y01,L.x01),Bo(L.y11,L.x11),!_),s.arc(0,0,h,Bo(L.cy+L.y11,L.cx+L.x11),Bo(R.cy+R.y11,R.cx+R.x11),_),s.arc(R.cx,R.cy,B,Bo(R.y11,R.x11),Bo(R.y01,R.x01),!_))):s.arc(0,0,h,S,b,_)}if(s.closePath(),c)return s=null,c+""||null}return l.centroid=function(){var c=(+e.apply(this,arguments)+ +t.apply(this,arguments))/2,u=(+i.apply(this,arguments)+ +o.apply(this,arguments))/2-yu/2;return[ig(u)*c,_u(u)*c]},l.innerRadius=function(c){return arguments.length?(e=typeof c=="function"?c:qe(+c),l):e},l.outerRadius=function(c){return arguments.length?(t=typeof c=="function"?c:qe(+c),l):t},l.cornerRadius=function(c){return arguments.length?(r=typeof c=="function"?c:qe(+c),l):r},l.padRadius=function(c){return arguments.length?(n=c==null?null:typeof c=="function"?c:qe(+c),l):n},l.startAngle=function(c){return arguments.length?(i=typeof c=="function"?c:qe(+c),l):i},l.endAngle=function(c){return arguments.length?(o=typeof c=="function"?c:qe(+c),l):o},l.padAngle=function(c){return arguments.length?(a=typeof c=="function"?c:qe(+c),l):a},l.context=function(c){return arguments.length?(s=c==null?null:c,l):s},l}function HSt(e){this._context=e}HSt.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;default:this._context.lineTo(e,t);break}}};function Yh(e){return new HSt(e)}function Xb(e){return e[0]}function $b(e){return e[1]}function vu(){var e=Xb,t=$b,r=qe(!0),n=null,i=Yh,o=null;function a(s){var l,c=s.length,u,h=!1,f;for(n==null&&(o=i(f=bs())),l=0;l<=c;++l)!(l<c&&r(u=s[l],l,s))===h&&((h=!h)?o.lineStart():o.lineEnd()),h&&o.point(+e(u,l,s),+t(u,l,s));if(f)return o=null,f+""||null}return a.x=function(s){return arguments.length?(e=typeof s=="function"?s:qe(+s),a):e},a.y=function(s){return arguments.length?(t=typeof s=="function"?s:qe(+s),a):t},a.defined=function(s){return arguments.length?(r=typeof s=="function"?s:qe(!!s),a):r},a.curve=function(s){return arguments.length?(i=s,n!=null&&(o=i(n)),a):i},a.context=function(s){return arguments.length?(s==null?n=o=null:o=i(n=s),a):n},a}function z8(){var e=Xb,t=null,r=qe(0),n=$b,i=qe(!0),o=null,a=Yh,s=null;function l(u){var h,f,p,d=u.length,g,_=!1,y,x=new Array(d),b=new Array(d);for(o==null&&(s=a(y=bs())),h=0;h<=d;++h){if(!(h<d&&i(g=u[h],h,u))===_)if(_=!_)f=h,s.areaStart(),s.lineStart();else{for(s.lineEnd(),s.lineStart(),p=h-1;p>=f;--p)s.point(x[p],b[p]);s.lineEnd(),s.areaEnd()}_&&(x[h]=+e(g,h,u),b[h]=+r(g,h,u),s.point(t?+t(g,h,u):x[h],n?+n(g,h,u):b[h]))}if(y)return s=null,y+""||null}function c(){return vu().defined(i).curve(a).context(o)}return l.x=function(u){return arguments.length?(e=typeof u=="function"?u:qe(+u),t=null,l):e},l.x0=function(u){return arguments.length?(e=typeof u=="function"?u:qe(+u),l):e},l.x1=function(u){return arguments.length?(t=u==null?null:typeof u=="function"?u:qe(+u),l):t},l.y=function(u){return arguments.length?(r=typeof u=="function"?u:qe(+u),n=null,l):r},l.y0=function(u){return arguments.length?(r=typeof u=="function"?u:qe(+u),l):r},l.y1=function(u){return arguments.length?(n=u==null?null:typeof u=="function"?u:qe(+u),l):n},l.lineX0=l.lineY0=function(){return c().x(e).y(r)},l.lineY1=function(){return c().x(e).y(n)},l.lineX1=function(){return c().x(t).y(r)},l.defined=function(u){return arguments.length?(i=typeof u=="function"?u:qe(!!u),l):i},l.curve=function(u){return arguments.length?(a=u,o!=null&&(s=a(o)),l):a},l.context=function(u){return arguments.length?(u==null?o=s=null:s=a(o=u),l):o},l}function VSt(e,t){return t<e?-1:t>e?1:t>=e?0:NaN}function USt(e){return e}function qSt(){var e=USt,t=VSt,r=null,n=qe(0),i=qe(hc),o=qe(0);function a(s){var l,c=s.length,u,h,f=0,p=new Array(c),d=new Array(c),g=+n.apply(this,arguments),_=Math.min(hc,Math.max(-hc,i.apply(this,arguments)-g)),y,x=Math.min(Math.abs(_)/c,o.apply(this,arguments)),b=x*(_<0?-1:1),S;for(l=0;l<c;++l)(S=d[p[l]=l]=+e(s[l],l,s))>0&&(f+=S);for(t!=null?p.sort(function(C,P){return t(d[C],d[P])}):r!=null&&p.sort(function(C,P){return r(s[C],s[P])}),l=0,h=f?(_-c*b)/f:0;l<c;++l,g=y)u=p[l],S=d[u],y=g+(S>0?S*h:0)+b,d[u]={data:s[u],index:l,value:S,startAngle:g,endAngle:y,padAngle:x};return d}return a.value=function(s){return arguments.length?(e=typeof s=="function"?s:qe(+s),a):e},a.sortValues=function(s){return arguments.length?(t=s,r=null,a):t},a.sort=function(s){return arguments.length?(r=s,t=null,a):r},a.startAngle=function(s){return arguments.length?(n=typeof s=="function"?s:qe(+s),a):n},a.endAngle=function(s){return arguments.length?(i=typeof s=="function"?s:qe(+s),a):i},a.padAngle=function(s){return arguments.length?(o=typeof s=="function"?s:qe(+s),a):o},a}var F8=Kb(Yh);function GSt(e){this._curve=e}GSt.prototype={areaStart:function(){this._curve.areaStart()},areaEnd:function(){this._curve.areaEnd()},lineStart:function(){this._curve.lineStart()},lineEnd:function(){this._curve.lineEnd()},point:function(e,t){this._curve.point(t*Math.sin(e),t*-Math.cos(e))}};function Kb(e){function t(r){return new GSt(e(r))}return t._curve=e,t}function Zb(e){var t=e.curve;return e.angle=e.x,delete e.x,e.radius=e.y,delete e.y,e.curve=function(r){return arguments.length?t(Kb(r)):t()._curve},e}function i$(){return Zb(vu().curve(F8))}function o$(){var e=z8().curve(F8),t=e.curve,r=e.lineX0,n=e.lineX1,i=e.lineY0,o=e.lineY1;return e.angle=e.x,delete e.x,e.startAngle=e.x0,delete e.x0,e.endAngle=e.x1,delete e.x1,e.radius=e.y,delete e.y,e.innerRadius=e.y0,delete e.y0,e.outerRadius=e.y1,delete e.y1,e.lineStartAngle=function(){return Zb(r())},delete e.lineX0,e.lineEndAngle=function(){return Zb(n())},delete e.lineX1,e.lineInnerRadius=function(){return Zb(i())},delete e.lineY0,e.lineOuterRadius=function(){return Zb(o())},delete e.lineY1,e.curve=function(a){return arguments.length?t(Kb(a)):t()._curve},e}function ly(e,t){return[(t=+t)*Math.cos(e-=Math.PI/2),t*Math.sin(e)]}var L5=Array.prototype.slice;function BEe(e){return e.source}function HEe(e){return e.target}function a$(e){var t=BEe,r=HEe,n=Xb,i=$b,o=null;function a(){var s,l=L5.call(arguments),c=t.apply(this,l),u=r.apply(this,l);if(o||(o=s=bs()),e(o,+n.apply(this,(l[0]=c,l)),+i.apply(this,l),+n.apply(this,(l[0]=u,l)),+i.apply(this,l)),s)return o=null,s+""||null}return a.source=function(s){return arguments.length?(t=s,a):t},a.target=function(s){return arguments.length?(r=s,a):r},a.x=function(s){return arguments.length?(n=typeof s=="function"?s:qe(+s),a):n},a.y=function(s){return arguments.length?(i=typeof s=="function"?s:qe(+s),a):i},a.context=function(s){return arguments.length?(o=s==null?null:s,a):o},a}function VEe(e,t,r,n,i){e.moveTo(t,r),e.bezierCurveTo(t=(t+n)/2,r,t,i,n,i)}function UEe(e,t,r,n,i){e.moveTo(t,r),e.bezierCurveTo(t,r=(r+i)/2,n,r,n,i)}function qEe(e,t,r,n,i){var o=ly(t,r),a=ly(t,r=(r+i)/2),s=ly(n,r),l=ly(n,i);e.moveTo(o[0],o[1]),e.bezierCurveTo(a[0],a[1],s[0],s[1],l[0],l[1])}function WSt(){return a$(VEe)}function YSt(){return a$(UEe)}function jSt(){var e=a$(qEe);return e.angle=e.x,delete e.x,e.radius=e.y,delete e.y,e}var k5={draw:function(e,t){var r=Math.sqrt(t/yu);e.moveTo(r,0),e.arc(0,0,r,0,hc)}};var B8={draw:function(e,t){var r=Math.sqrt(t/5)/2;e.moveTo(-3*r,-r),e.lineTo(-r,-r),e.lineTo(-r,-3*r),e.lineTo(r,-3*r),e.lineTo(r,-r),e.lineTo(3*r,-r),e.lineTo(3*r,r),e.lineTo(r,r),e.lineTo(r,3*r),e.lineTo(-r,3*r),e.lineTo(-r,r),e.lineTo(-3*r,r),e.closePath()}};var XSt=Math.sqrt(.3333333333333333),GEe=XSt*2,H8={draw:function(e,t){var r=Math.sqrt(t/GEe),n=r*XSt;e.moveTo(0,-r),e.lineTo(n,0),e.lineTo(0,r),e.lineTo(-n,0),e.closePath()}};var WEe=.8908130915292852,$St=Math.sin(yu/10)/Math.sin(7*yu/10),YEe=Math.sin(hc/10)*$St,jEe=-Math.cos(hc/10)*$St,V8={draw:function(e,t){var r=Math.sqrt(t*WEe),n=YEe*r,i=jEe*r;e.moveTo(0,-r),e.lineTo(n,i);for(var o=1;o<5;++o){var a=hc*o/5,s=Math.cos(a),l=Math.sin(a);e.lineTo(l*r,-s*r),e.lineTo(s*n-l*i,l*n+s*i)}e.closePath()}};var U8={draw:function(e,t){var r=Math.sqrt(t),n=-r/2;e.rect(n,n,r,r)}};var s$=Math.sqrt(3),q8={draw:function(e,t){var r=-Math.sqrt(t/(s$*3));e.moveTo(0,r*2),e.lineTo(-s$*r,-r),e.lineTo(s$*r,-r),e.closePath()}};var fc=-.5,pc=Math.sqrt(3)/2,l$=1/Math.sqrt(12),XEe=(l$/2+1)*3,G8={draw:function(e,t){var r=Math.sqrt(t/XEe),n=r/2,i=r*l$,o=n,a=r*l$+r,s=-o,l=a;e.moveTo(n,i),e.lineTo(o,a),e.lineTo(s,l),e.lineTo(fc*n-pc*i,pc*n+fc*i),e.lineTo(fc*o-pc*a,pc*o+fc*a),e.lineTo(fc*s-pc*l,pc*s+fc*l),e.lineTo(fc*n+pc*i,fc*i-pc*n),e.lineTo(fc*o+pc*a,fc*a-pc*o),e.lineTo(fc*s+pc*l,fc*l-pc*s),e.closePath()}};var KSt=[k5,B8,H8,U8,V8,q8,G8];function ZSt(){var e=qe(k5),t=qe(64),r=null;function n(){var i;if(r||(r=i=bs()),e.apply(this,arguments).draw(r,+t.apply(this,arguments)),i)return r=null,i+""||null}return n.type=function(i){return arguments.length?(e=typeof i=="function"?i:qe(i),n):e},n.size=function(i){return arguments.length?(t=typeof i=="function"?i:qe(+i),n):t},n.context=function(i){return arguments.length?(r=i==null?null:i,n):r},n}function dc(){}function Jb(e,t,r){e._context.bezierCurveTo((2*e._x0+e._x1)/3,(2*e._y0+e._y1)/3,(e._x0+2*e._x1)/3,(e._y0+2*e._y1)/3,(e._x0+4*e._x1+t)/6,(e._y0+4*e._y1+r)/6)}function R5(e){this._context=e}R5.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._y0=this._y1=NaN,this._point=0},lineEnd:function(){switch(this._point){case 3:Jb(this,this._x1,this._y1);case 2:this._context.lineTo(this._x1,this._y1);break}(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;break;case 2:this._point=3,this._context.lineTo((5*this._x0+this._x1)/6,(5*this._y0+this._y1)/6);default:Jb(this,e,t);break}this._x0=this._x1,this._x1=e,this._y0=this._y1,this._y1=t}};function W8(e){return new R5(e)}function JSt(e){this._context=e}JSt.prototype={areaStart:dc,areaEnd:dc,lineStart:function(){this._x0=this._x1=this._x2=this._x3=this._x4=this._y0=this._y1=this._y2=this._y3=this._y4=NaN,this._point=0},lineEnd:function(){switch(this._point){case 1:{this._context.moveTo(this._x2,this._y2),this._context.closePath();break}case 2:{this._context.moveTo((this._x2+2*this._x3)/3,(this._y2+2*this._y3)/3),this._context.lineTo((this._x3+2*this._x2)/3,(this._y3+2*this._y2)/3),this._context.closePath();break}case 3:{this.point(this._x2,this._y2),this.point(this._x3,this._y3),this.point(this._x4,this._y4);break}}},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._x2=e,this._y2=t;break;case 1:this._point=2,this._x3=e,this._y3=t;break;case 2:this._point=3,this._x4=e,this._y4=t,this._context.moveTo((this._x0+4*this._x1+e)/6,(this._y0+4*this._y1+t)/6);break;default:Jb(this,e,t);break}this._x0=this._x1,this._x1=e,this._y0=this._y1,this._y1=t}};function QSt(e){return new JSt(e)}function t3t(e){this._context=e}t3t.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._y0=this._y1=NaN,this._point=0},lineEnd:function(){(this._line||this._line!==0&&this._point===3)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1;break;case 1:this._point=2;break;case 2:this._point=3;var r=(this._x0+4*this._x1+e)/6,n=(this._y0+4*this._y1+t)/6;this._line?this._context.lineTo(r,n):this._context.moveTo(r,n);break;case 3:this._point=4;default:Jb(this,e,t);break}this._x0=this._x1,this._x1=e,this._y0=this._y1,this._y1=t}};function e3t(e){return new t3t(e)}function r3t(e,t){this._basis=new R5(e),this._beta=t}r3t.prototype={lineStart:function(){this._x=[],this._y=[],this._basis.lineStart()},lineEnd:function(){var e=this._x,t=this._y,r=e.length-1;if(r>0)for(var n=e[0],i=t[0],o=e[r]-n,a=t[r]-i,s=-1,l;++s<=r;)l=s/r,this._basis.point(this._beta*e[s]+(1-this._beta)*(n+l*o),this._beta*t[s]+(1-this._beta)*(i+l*a));this._x=this._y=null,this._basis.lineEnd()},point:function(e,t){this._x.push(+e),this._y.push(+t)}};var n3t=function e(t){function r(n){return t===1?new R5(n):new r3t(n,t)}return r.beta=function(n){return e(+n)},r}(.85);function Qb(e,t,r){e._context.bezierCurveTo(e._x1+e._k*(e._x2-e._x0),e._y1+e._k*(e._y2-e._y0),e._x2+e._k*(e._x1-t),e._y2+e._k*(e._y1-r),e._x2,e._y2)}function Y8(e,t){this._context=e,this._k=(1-t)/6}Y8.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x2,this._y2);break;case 3:Qb(this,this._x1,this._y1);break}(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2,this._x1=e,this._y1=t;break;case 2:this._point=3;default:Qb(this,e,t);break}this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};var i3t=function e(t){function r(n){return new Y8(n,t)}return r.tension=function(n){return e(+n)},r}(0);function j8(e,t){this._context=e,this._k=(1-t)/6}j8.prototype={areaStart:dc,areaEnd:dc,lineStart:function(){this._x0=this._x1=this._x2=this._x3=this._x4=this._x5=this._y0=this._y1=this._y2=this._y3=this._y4=this._y5=NaN,this._point=0},lineEnd:function(){switch(this._point){case 1:{this._context.moveTo(this._x3,this._y3),this._context.closePath();break}case 2:{this._context.lineTo(this._x3,this._y3),this._context.closePath();break}case 3:{this.point(this._x3,this._y3),this.point(this._x4,this._y4),this.point(this._x5,this._y5);break}}},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._x3=e,this._y3=t;break;case 1:this._point=2,this._context.moveTo(this._x4=e,this._y4=t);break;case 2:this._point=3,this._x5=e,this._y5=t;break;default:Qb(this,e,t);break}this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};var o3t=function e(t){function r(n){return new j8(n,t)}return r.tension=function(n){return e(+n)},r}(0);function X8(e,t){this._context=e,this._k=(1-t)/6}X8.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._point=0},lineEnd:function(){(this._line||this._line!==0&&this._point===3)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1;break;case 1:this._point=2;break;case 2:this._point=3,this._line?this._context.lineTo(this._x2,this._y2):this._context.moveTo(this._x2,this._y2);break;case 3:this._point=4;default:Qb(this,e,t);break}this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};var a3t=function e(t){function r(n){return new X8(n,t)}return r.tension=function(n){return e(+n)},r}(0);function N5(e,t,r){var n=e._x1,i=e._y1,o=e._x2,a=e._y2;if(e._l01_a>bo){var s=2*e._l01_2a+3*e._l01_a*e._l12_a+e._l12_2a,l=3*e._l01_a*(e._l01_a+e._l12_a);n=(n*s-e._x0*e._l12_2a+e._x2*e._l01_2a)/l,i=(i*s-e._y0*e._l12_2a+e._y2*e._l01_2a)/l}if(e._l23_a>bo){var c=2*e._l23_2a+3*e._l23_a*e._l12_a+e._l12_2a,u=3*e._l23_a*(e._l23_a+e._l12_a);o=(o*c+e._x1*e._l23_2a-t*e._l12_2a)/u,a=(a*c+e._y1*e._l23_2a-r*e._l12_2a)/u}e._context.bezierCurveTo(n,i,o,a,e._x2,e._y2)}function s3t(e,t){this._context=e,this._alpha=t}s3t.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._l01_a=this._l12_a=this._l23_a=this._l01_2a=this._l12_2a=this._l23_2a=this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x2,this._y2);break;case 3:this.point(this._x2,this._y2);break}(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){if(e=+e,t=+t,this._point){var r=this._x2-e,n=this._y2-t;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(r*r+n*n,this._alpha))}switch(this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;break;case 2:this._point=3;default:N5(this,e,t);break}this._l01_a=this._l12_a,this._l12_a=this._l23_a,this._l01_2a=this._l12_2a,this._l12_2a=this._l23_2a,this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};var l3t=function e(t){function r(n){return t?new s3t(n,t):new Y8(n,0)}return r.alpha=function(n){return e(+n)},r}(.5);function c3t(e,t){this._context=e,this._alpha=t}c3t.prototype={areaStart:dc,areaEnd:dc,lineStart:function(){this._x0=this._x1=this._x2=this._x3=this._x4=this._x5=this._y0=this._y1=this._y2=this._y3=this._y4=this._y5=NaN,this._l01_a=this._l12_a=this._l23_a=this._l01_2a=this._l12_2a=this._l23_2a=this._point=0},lineEnd:function(){switch(this._point){case 1:{this._context.moveTo(this._x3,this._y3),this._context.closePath();break}case 2:{this._context.lineTo(this._x3,this._y3),this._context.closePath();break}case 3:{this.point(this._x3,this._y3),this.point(this._x4,this._y4),this.point(this._x5,this._y5);break}}},point:function(e,t){if(e=+e,t=+t,this._point){var r=this._x2-e,n=this._y2-t;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(r*r+n*n,this._alpha))}switch(this._point){case 0:this._point=1,this._x3=e,this._y3=t;break;case 1:this._point=2,this._context.moveTo(this._x4=e,this._y4=t);break;case 2:this._point=3,this._x5=e,this._y5=t;break;default:N5(this,e,t);break}this._l01_a=this._l12_a,this._l12_a=this._l23_a,this._l01_2a=this._l12_2a,this._l12_2a=this._l23_2a,this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};var u3t=function e(t){function r(n){return t?new c3t(n,t):new j8(n,0)}return r.alpha=function(n){return e(+n)},r}(.5);function h3t(e,t){this._context=e,this._alpha=t}h3t.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._l01_a=this._l12_a=this._l23_a=this._l01_2a=this._l12_2a=this._l23_2a=this._point=0},lineEnd:function(){(this._line||this._line!==0&&this._point===3)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){if(e=+e,t=+t,this._point){var r=this._x2-e,n=this._y2-t;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(r*r+n*n,this._alpha))}switch(this._point){case 0:this._point=1;break;case 1:this._point=2;break;case 2:this._point=3,this._line?this._context.lineTo(this._x2,this._y2):this._context.moveTo(this._x2,this._y2);break;case 3:this._point=4;default:N5(this,e,t);break}this._l01_a=this._l12_a,this._l12_a=this._l23_a,this._l01_2a=this._l12_2a,this._l12_2a=this._l23_2a,this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};var f3t=function e(t){function r(n){return t?new h3t(n,t):new X8(n,0)}return r.alpha=function(n){return e(+n)},r}(.5);function p3t(e){this._context=e}p3t.prototype={areaStart:dc,areaEnd:dc,lineStart:function(){this._point=0},lineEnd:function(){this._point&&this._context.closePath()},point:function(e,t){e=+e,t=+t,this._point?this._context.lineTo(e,t):(this._point=1,this._context.moveTo(e,t))}};function d3t(e){return new p3t(e)}function m3t(e){return e<0?-1:1}function g3t(e,t,r){var n=e._x1-e._x0,i=t-e._x1,o=(e._y1-e._y0)/(n||i<0&&-0),a=(r-e._y1)/(i||n<0&&-0),s=(o*i+a*n)/(n+i);return(m3t(o)+m3t(a))*Math.min(Math.abs(o),Math.abs(a),.5*Math.abs(s))||0}function _3t(e,t){var r=e._x1-e._x0;return r?(3*(e._y1-e._y0)/r-t)/2:t}function c$(e,t,r){var n=e._x0,i=e._y0,o=e._x1,a=e._y1,s=(o-n)/3;e._context.bezierCurveTo(n+s,i+s*t,o-s,a-s*r,o,a)}function $8(e){this._context=e}$8.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._y0=this._y1=this._t0=NaN,this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x1,this._y1);break;case 3:c$(this,this._t0,_3t(this,this._t0));break}(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){var r=NaN;if(e=+e,t=+t,!(e===this._x1&&t===this._y1)){switch(this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;break;case 2:this._point=3,c$(this,_3t(this,r=g3t(this,e,t)),r);break;default:c$(this,this._t0,r=g3t(this,e,t));break}this._x0=this._x1,this._x1=e,this._y0=this._y1,this._y1=t,this._t0=r}}};function y3t(e){this._context=new v3t(e)}(y3t.prototype=Object.create($8.prototype)).point=function(e,t){$8.prototype.point.call(this,t,e)};function v3t(e){this._context=e}v3t.prototype={moveTo:function(e,t){this._context.moveTo(t,e)},closePath:function(){this._context.closePath()},lineTo:function(e,t){this._context.lineTo(t,e)},bezierCurveTo:function(e,t,r,n,i,o){this._context.bezierCurveTo(t,e,n,r,o,i)}};function x3t(e){return new $8(e)}function b3t(e){return new y3t(e)}function S3t(e){this._context=e}S3t.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x=[],this._y=[]},lineEnd:function(){var e=this._x,t=this._y,r=e.length;if(r)if(this._line?this._context.lineTo(e[0],t[0]):this._context.moveTo(e[0],t[0]),r===2)this._context.lineTo(e[1],t[1]);else for(var n=w3t(e),i=w3t(t),o=0,a=1;a<r;++o,++a)this._context.bezierCurveTo(n[0][o],i[0][o],n[1][o],i[1][o],e[a],t[a]);(this._line||this._line!==0&&r===1)&&this._context.closePath(),this._line=1-this._line,this._x=this._y=null},point:function(e,t){this._x.push(+e),this._y.push(+t)}};function w3t(e){var t,r=e.length-1,n,i=new Array(r),o=new Array(r),a=new Array(r);for(i[0]=0,o[0]=2,a[0]=e[0]+2*e[1],t=1;t<r-1;++t)i[t]=1,o[t]=4,a[t]=4*e[t]+2*e[t+1];for(i[r-1]=2,o[r-1]=7,a[r-1]=8*e[r-1]+e[r],t=1;t<r;++t)n=i[t]/o[t-1],o[t]-=n,a[t]-=n*a[t-1];for(i[r-1]=a[r-1]/o[r-1],t=r-2;t>=0;--t)i[t]=(a[t]-i[t+1])/o[t];for(o[r-1]=(e[r]+i[r-1])/2,t=0;t<r-1;++t)o[t]=2*e[t+1]-i[t+1];return[i,o]}function M3t(e){return new S3t(e)}function K8(e,t){this._context=e,this._t=t}K8.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x=this._y=NaN,this._point=0},lineEnd:function(){0<this._t&&this._t<1&&this._point===2&&this._context.lineTo(this._x,this._y),(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line>=0&&(this._t=1-this._t,this._line=1-this._line)},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;default:{if(this._t<=0)this._context.lineTo(this._x,t),this._context.lineTo(e,t);else{var r=this._x*(1-this._t)+e*this._t;this._context.lineTo(r,this._y),this._context.lineTo(r,t)}break}}this._x=e,this._y=t}};function E3t(e){return new K8(e,.5)}function T3t(e){return new K8(e,0)}function C3t(e){return new K8(e,1)}function xu(e,t){if((a=e.length)>1)for(var r=1,n,i,o=e[t[0]],a,s=o.length;r<a;++r)for(i=o,o=e[t[r]],n=0;n<s;++n)o[n][1]+=o[n][0]=isNaN(i[n][1])?i[n][0]:i[n][1]}function bu(e){for(var t=e.length,r=new Array(t);--t>=0;)r[t]=t;return r}function $Ee(e,t){return e[t]}function A3t(){var e=qe([]),t=bu,r=xu,n=$Ee;function i(o){var a=e.apply(this,arguments),s,l=o.length,c=a.length,u=new Array(c),h;for(s=0;s<c;++s){for(var f=a[s],p=u[s]=new Array(l),d=0,g;d<l;++d)p[d]=g=[0,+n(o[d],f,d,o)],g.data=o[d];p.key=f}for(s=0,h=t(u);s<c;++s)u[h[s]].index=s;return r(u,h),u}return i.keys=function(o){return arguments.length?(e=typeof o=="function"?o:qe(L5.call(o)),i):e},i.value=function(o){return arguments.length?(n=typeof o=="function"?o:qe(+o),i):n},i.order=function(o){return arguments.length?(t=o==null?bu:typeof o=="function"?o:qe(L5.call(o)),i):t},i.offset=function(o){return arguments.length?(r=o==null?xu:o,i):r},i}function P3t(e,t){if((n=e.length)>0){for(var r,n,i=0,o=e[0].length,a;i<o;++i){for(a=r=0;r<n;++r)a+=e[r][i][1]||0;if(a)for(r=0;r<n;++r)e[r][i][1]/=a}xu(e,t)}}function I3t(e,t){if((l=e.length)>0)for(var r,n=0,i,o,a,s,l,c=e[t[0]].length;n<c;++n)for(a=s=0,r=0;r<l;++r)(o=(i=e[t[r]][n])[1]-i[0])>0?(i[0]=a,i[1]=a+=o):o<0?(i[1]=s,i[0]=s+=o):(i[0]=0,i[1]=o)}function L3t(e,t){if((i=e.length)>0){for(var r=0,n=e[t[0]],i,o=n.length;r<o;++r){for(var a=0,s=0;a<i;++a)s+=e[a][r][1]||0;n[r][1]+=n[r][0]=-s/2}xu(e,t)}}function k3t(e,t){if(!(!((a=e.length)>0)||!((o=(i=e[t[0]]).length)>0))){for(var r=0,n=1,i,o,a;n<o;++n){for(var s=0,l=0,c=0;s<a;++s){for(var u=e[t[s]],h=u[n][1]||0,f=u[n-1][1]||0,p=(h-f)/2,d=0;d<s;++d){var g=e[t[d]],_=g[n][1]||0,y=g[n-1][1]||0;p+=_-y}l+=h,c+=p*h}i[n-1][1]+=i[n-1][0]=r,l&&(r-=c/l)}i[n-1][1]+=i[n-1][0]=r,xu(e,t)}}function Z8(e){var t=e.map(KEe);return bu(e).sort(function(r,n){return t[r]-t[n]})}function KEe(e){for(var t=-1,r=0,n=e.length,i,o=-1/0;++t<n;)(i=+e[t][1])>o&&(o=i,r=t);return r}function J8(e){var t=e.map(u$);return bu(e).sort(function(r,n){return t[r]-t[n]})}function u$(e){for(var t=0,r=-1,n=e.length,i;++r<n;)(i=+e[r][1])&&(t+=i);return t}function R3t(e){return J8(e).reverse()}function N3t(e){var t=e.length,r,n,i=e.map(u$),o=Z8(e),a=0,s=0,l=[],c=[];for(r=0;r<t;++r)n=o[r],a<s?(a+=i[n],l.push(n)):(s+=i[n],c.push(n));return c.reverse().concat(l)}function D3t(e){return bu(e).reverse()}function h$(e){return function(){return e}}function O3t(e){return e[0]}function z3t(e){return e[1]}function f$(){this._=null}function t2(e){e.U=e.C=e.L=e.R=e.P=e.N=null}f$.prototype={constructor:f$,insert:function(e,t){var r,n,i;if(e){if(t.P=e,t.N=e.N,e.N&&(e.N.P=t),e.N=t,e.R){for(e=e.R;e.L;)e=e.L;e.L=t}else e.R=t;r=e}else this._?(e=F3t(this._),t.P=null,t.N=e,e.P=e.L=t,r=e):(t.P=t.N=null,this._=t,r=null);for(t.L=t.R=null,t.U=r,t.C=!0,e=t;r&&r.C;)n=r.U,r===n.L?(i=n.R,i&&i.C?(r.C=i.C=!1,n.C=!0,e=n):(e===r.R&&(D5(this,r),e=r,r=e.U),r.C=!1,n.C=!0,O5(this,n))):(i=n.L,i&&i.C?(r.C=i.C=!1,n.C=!0,e=n):(e===r.L&&(O5(this,r),e=r,r=e.U),r.C=!1,n.C=!0,D5(this,n))),r=e.U;this._.C=!1},remove:function(e){e.N&&(e.N.P=e.P),e.P&&(e.P.N=e.N),e.N=e.P=null;var t=e.U,r,n=e.L,i=e.R,o,a;if(n?i?o=F3t(i):o=n:o=i,t?t.L===e?t.L=o:t.R=o:this._=o,n&&i?(a=o.C,o.C=e.C,o.L=n,n.U=o,o!==i?(t=o.U,o.U=e.U,e=o.R,t.L=e,o.R=i,i.U=o):(o.U=t,t=o,e=o.R)):(a=e.C,e=o),e&&(e.U=t),!a){if(e&&e.C){e.C=!1;return}do{if(e===this._)break;if(e===t.L){if(r=t.R,r.C&&(r.C=!1,t.C=!0,D5(this,t),r=t.R),r.L&&r.L.C||r.R&&r.R.C){(!r.R||!r.R.C)&&(r.L.C=!1,r.C=!0,O5(this,r),r=t.R),r.C=t.C,t.C=r.R.C=!1,D5(this,t),e=this._;break}}else if(r=t.L,r.C&&(r.C=!1,t.C=!0,O5(this,t),r=t.L),r.L&&r.L.C||r.R&&r.R.C){(!r.L||!r.L.C)&&(r.R.C=!1,r.C=!0,D5(this,r),r=t.L),r.C=t.C,t.C=r.L.C=!1,O5(this,t),e=this._;break}r.C=!0,e=t,t=t.U}while(!e.C);e&&(e.C=!1)}}};function D5(e,t){var r=t,n=t.R,i=r.U;i?i.L===r?i.L=n:i.R=n:e._=n,n.U=i,r.U=n,r.R=n.L,r.R&&(r.R.U=r),n.L=r}function O5(e,t){var r=t,n=t.L,i=r.U;i?i.L===r?i.L=n:i.R=n:e._=n,n.U=i,r.U=n,r.L=n.R,r.L&&(r.L.U=r),n.R=r}function F3t(e){for(;e.L;)e=e.L;return e}var p$=f$;function e2(e,t,r,n){var i=[null,null],o=wo.push(i)-1;return i.left=e,i.right=t,r&&z5(i,e,t,r),n&&z5(i,t,e,n),Va[e.index].halfedges.push(o),Va[t.index].halfedges.push(o),i}function r2(e,t,r){var n=[t,r];return n.left=e,n}function z5(e,t,r,n){!e[0]&&!e[1]?(e[0]=n,e.left=t,e.right=r):e.left===r?e[1]=n:e[0]=n}function ZEe(e,t,r,n,i){var o=e[0],a=e[1],s=o[0],l=o[1],c=a[0],u=a[1],h=0,f=1,p=c-s,d=u-l,g;if(g=t-s,!(!p&&g>0)){if(g/=p,p<0){if(g<h)return;g<f&&(f=g)}else if(p>0){if(g>f)return;g>h&&(h=g)}if(g=n-s,!(!p&&g<0)){if(g/=p,p<0){if(g>f)return;g>h&&(h=g)}else if(p>0){if(g<h)return;g<f&&(f=g)}if(g=r-l,!(!d&&g>0)){if(g/=d,d<0){if(g<h)return;g<f&&(f=g)}else if(d>0){if(g>f)return;g>h&&(h=g)}if(g=i-l,!(!d&&g<0)){if(g/=d,d<0){if(g>f)return;g>h&&(h=g)}else if(d>0){if(g<h)return;g<f&&(f=g)}return!(h>0)&&!(f<1)||(h>0&&(e[0]=[s+h*p,l+h*d]),f<1&&(e[1]=[s+f*p,l+f*d])),!0}}}}}function JEe(e,t,r,n,i){var o=e[1];if(o)return!0;var a=e[0],s=e.left,l=e.right,c=s[0],u=s[1],h=l[0],f=l[1],p=(c+h)/2,d=(u+f)/2,g,_;if(f===u){if(p<t||p>=n)return;if(c>h){if(!a)a=[p,r];else if(a[1]>=i)return;o=[p,i]}else{if(!a)a=[p,i];else if(a[1]<r)return;o=[p,r]}}else if(g=(c-h)/(f-u),_=d-g*p,g<-1||g>1)if(c>h){if(!a)a=[(r-_)/g,r];else if(a[1]>=i)return;o=[(i-_)/g,i]}else{if(!a)a=[(i-_)/g,i];else if(a[1]<r)return;o=[(r-_)/g,r]}else if(u<f){if(!a)a=[t,g*t+_];else if(a[0]>=n)return;o=[n,g*n+_]}else{if(!a)a=[n,g*n+_];else if(a[0]<t)return;o=[t,g*t+_]}return e[0]=a,e[1]=o,!0}function B3t(e,t,r,n){for(var i=wo.length,o;i--;)(!JEe(o=wo[i],e,t,r,n)||!ZEe(o,e,t,r,n)||!(Math.abs(o[0][0]-o[1][0])>Hr||Math.abs(o[0][1]-o[1][1])>Hr))&&delete wo[i]}function H3t(e){return Va[e.index]={site:e,halfedges:[]}}function QEe(e,t){var r=e.site,n=t.left,i=t.right;return r===i&&(i=n,n=r),i?Math.atan2(i[1]-n[1],i[0]-n[0]):(r===n?(n=t[1],i=t[0]):(n=t[0],i=t[1]),Math.atan2(n[0]-i[0],i[1]-n[1]))}function d$(e,t){return t[+(t.left!==e.site)]}function t5e(e,t){return t[+(t.left===e.site)]}function V3t(){for(var e=0,t=Va.length,r,n,i,o;e<t;++e)if((r=Va[e])&&(o=(n=r.halfedges).length)){var a=new Array(o),s=new Array(o);for(i=0;i<o;++i)a[i]=i,s[i]=QEe(r,wo[n[i]]);for(a.sort(function(l,c){return s[c]-s[l]}),i=0;i<o;++i)s[i]=n[a[i]];for(i=0;i<o;++i)n[i]=s[i]}}function U3t(e,t,r,n){var i=Va.length,o,a,s,l,c,u,h,f,p,d,g,_,y=!0;for(o=0;o<i;++o)if(a=Va[o]){for(s=a.site,c=a.halfedges,l=c.length;l--;)wo[c[l]]||c.splice(l,1);for(l=0,u=c.length;l<u;)d=t5e(a,wo[c[l]]),g=d[0],_=d[1],h=d$(a,wo[c[++l%u]]),f=h[0],p=h[1],(Math.abs(g-f)>Hr||Math.abs(_-p)>Hr)&&(c.splice(l,0,wo.push(r2(s,d,Math.abs(g-e)<Hr&&n-_>Hr?[e,Math.abs(f-e)<Hr?p:n]:Math.abs(_-n)<Hr&&r-g>Hr?[Math.abs(p-n)<Hr?f:r,n]:Math.abs(g-r)<Hr&&_-t>Hr?[r,Math.abs(f-r)<Hr?p:t]:Math.abs(_-t)<Hr&&g-e>Hr?[Math.abs(p-t)<Hr?f:e,t]:null))-1),++u);u&&(y=!1)}if(y){var x,b,S,C=1/0;for(o=0,y=null;o<i;++o)(a=Va[o])&&(s=a.site,x=s[0]-e,b=s[1]-t,S=x*x+b*b,S<C&&(C=S,y=a));if(y){var P=[e,t],k=[e,n],O=[r,n],D=[r,t];y.halfedges.push(wo.push(r2(s=y.site,P,k))-1,wo.push(r2(s,k,O))-1,wo.push(r2(s,O,D))-1,wo.push(r2(s,D,P))-1)}}for(o=0;o<i;++o)(a=Va[o])&&(a.halfedges.length||delete Va[o])}var q3t=[],Q8;function e5e(){t2(this),this.x=this.y=this.arc=this.site=this.cy=null}function cy(e){var t=e.P,r=e.N;if(!(!t||!r)){var n=t.site,i=e.site,o=r.site;if(n!==o){var a=i[0],s=i[1],l=n[0]-a,c=n[1]-s,u=o[0]-a,h=o[1]-s,f=2*(l*h-c*u);if(!(f>=-G3t)){var p=l*l+c*c,d=u*u+h*h,g=(h*p-c*d)/f,_=(l*d-u*p)/f,y=q3t.pop()||new e5e;y.arc=e,y.site=i,y.x=g+a,y.y=(y.cy=_+s)+Math.sqrt(g*g+_*_),e.circle=y;for(var x=null,b=n2._;b;)if(y.y<b.y||y.y===b.y&&y.x<=b.x)if(b.L)b=b.L;else{x=b.P;break}else if(b.R)b=b.R;else{x=b;break}n2.insert(x,y),x||(Q8=y)}}}}function uy(e){var t=e.circle;t&&(t.P||(Q8=t.N),n2.remove(t),q3t.push(t),t2(t),e.circle=null)}var Y3t=[];function r5e(){t2(this),this.edge=this.site=this.circle=null}function W3t(e){var t=Y3t.pop()||new r5e;return t.site=e,t}function m$(e){uy(e),hy.remove(e),Y3t.push(e),t2(e)}function j3t(e){var t=e.circle,r=t.x,n=t.cy,i=[r,n],o=e.P,a=e.N,s=[e];m$(e);for(var l=o;l.circle&&Math.abs(r-l.circle.x)<Hr&&Math.abs(n-l.circle.cy)<Hr;)o=l.P,s.unshift(l),m$(l),l=o;s.unshift(l),uy(l);for(var c=a;c.circle&&Math.abs(r-c.circle.x)<Hr&&Math.abs(n-c.circle.cy)<Hr;)a=c.N,s.push(c),m$(c),c=a;s.push(c),uy(c);var u=s.length,h;for(h=1;h<u;++h)c=s[h],l=s[h-1],z5(c.edge,l.site,c.site,i);l=s[0],c=s[u-1],c.edge=e2(l.site,c.site,null,i),cy(l),cy(c)}function X3t(e){for(var t=e[0],r=e[1],n,i,o,a,s=hy._;s;)if(o=$3t(s,r)-t,o>Hr)s=s.L;else if(a=t-n5e(s,r),a>Hr){if(!s.R){n=s;break}s=s.R}else{o>-Hr?(n=s.P,i=s):a>-Hr?(n=s,i=s.N):n=i=s;break}H3t(e);var l=W3t(e);if(hy.insert(n,l),!(!n&&!i)){if(n===i){uy(n),i=W3t(n.site),hy.insert(l,i),l.edge=i.edge=e2(n.site,l.site),cy(n),cy(i);return}if(!i){l.edge=e2(n.site,l.site);return}uy(n),uy(i);var c=n.site,u=c[0],h=c[1],f=e[0]-u,p=e[1]-h,d=i.site,g=d[0]-u,_=d[1]-h,y=2*(f*_-p*g),x=f*f+p*p,b=g*g+_*_,S=[(_*x-p*b)/y+u,(f*b-g*x)/y+h];z5(i.edge,c,d,S),l.edge=e2(c,e,null,S),i.edge=e2(e,d,null,S),cy(n),cy(i)}}function $3t(e,t){var r=e.site,n=r[0],i=r[1],o=i-t;if(!o)return n;var a=e.P;if(!a)return-1/0;r=a.site;var s=r[0],l=r[1],c=l-t;if(!c)return s;var u=s-n,h=1/o-1/c,f=u/c;return h?(-f+Math.sqrt(f*f-2*h*(u*u/(-2*c)-l+c/2+i-o/2)))/h+n:(n+s)/2}function n5e(e,t){var r=e.N;if(r)return $3t(r,t);var n=e.site;return n[1]===t?n[0]:1/0}var Hr=1e-6,G3t=1e-12,hy,Va,n2,wo;function i5e(e,t,r){return(e[0]-r[0])*(t[1]-e[1])-(e[0]-t[0])*(r[1]-e[1])}function o5e(e,t){return t[1]-e[1]||t[0]-e[0]}function F5(e,t){var r=e.sort(o5e).pop(),n,i,o;for(wo=[],Va=new Array(e.length),hy=new p$,n2=new p$;;)if(o=Q8,r&&(!o||r[1]<o.y||r[1]===o.y&&r[0]<o.x))(r[0]!==n||r[1]!==i)&&(X3t(r),n=r[0],i=r[1]),r=e.pop();else if(o)j3t(o.arc);else break;if(V3t(),t){var a=+t[0][0],s=+t[0][1],l=+t[1][0],c=+t[1][1];B3t(a,s,l,c),U3t(a,s,l,c)}this.edges=wo,this.cells=Va,hy=n2=wo=Va=null}F5.prototype={constructor:F5,polygons:function(){var e=this.edges;return this.cells.map(function(t){var r=t.halfedges.map(function(n){return d$(t,e[n])});return r.data=t.site.data,r})},triangles:function(){var e=[],t=this.edges;return this.cells.forEach(function(r,n){if(!!(s=(o=r.halfedges).length))for(var i=r.site,o,a=-1,s,l,c=t[o[s-1]],u=c.left===i?c.right:c.left;++a<s;)l=u,c=t[o[a]],u=c.left===i?c.right:c.left,l&&u&&n<l.index&&n<u.index&&i5e(i,l,u)<0&&e.push([i.data,l.data,u.data])}),e},links:function(){return this.edges.filter(function(e){return e.right}).map(function(e){return{source:e.left.data,target:e.right.data}})},find:function(e,t,r){for(var n=this,i,o=n._found||0,a=n.cells.length,s;!(s=n.cells[o]);)if(++o>=a)return null;var l=e-s.site[0],c=t-s.site[1],u=l*l+c*c;do s=n.cells[i=o],o=null,s.halfedges.forEach(function(h){var f=n.edges[h],p=f.left;if(!((p===s.site||!p)&&!(p=f.right))){var d=e-p[0],g=t-p[1],_=d*d+g*g;_<u&&(u=_,o=p.index)}});while(o!==null);return n._found=i,r==null||u<=r*r?s.site:null}};function K3t(){var e=O3t,t=z3t,r=null;function n(i){return new F5(i.map(function(o,a){var s=[Math.round(e(o,a,i)/Hr)*Hr,Math.round(t(o,a,i)/Hr)*Hr];return s.index=a,s.data=o,s}),r)}return n.polygons=function(i){return n(i).polygons()},n.links=function(i){return n(i).links()},n.triangles=function(i){return n(i).triangles()},n.x=function(i){return arguments.length?(e=typeof i=="function"?i:h$(+i),n):e},n.y=function(i){return arguments.length?(t=typeof i=="function"?i:h$(+i),n):t},n.extent=function(i){return arguments.length?(r=i==null?null:[[+i[0][0],+i[0][1]],[+i[1][0],+i[1][1]]],n):r&&[[r[0][0],r[0][1]],[r[1][0],r[1][1]]]},n.size=function(i){return arguments.length?(r=i==null?null:[[0,0],[+i[0],+i[1]]],n):r&&[r[1][0]-r[0][0],r[1][1]-r[0][1]]},n}km();function B5(e){return function(){return e}}function g$(e,t,r){this.target=e,this.type=t,this.transform=r}function jh(e,t,r){this.k=e,this.x=t,this.y=r}jh.prototype={constructor:jh,scale:function(e){return e===1?this:new jh(this.k*e,this.x,this.y)},translate:function(e,t){return e===0&t===0?this:new jh(this.k,this.x+this.k*e,this.y+this.k*t)},apply:function(e){return[e[0]*this.k+this.x,e[1]*this.k+this.y]},applyX:function(e){return e*this.k+this.x},applyY:function(e){return e*this.k+this.y},invert:function(e){return[(e[0]-this.x)/this.k,(e[1]-this.y)/this.k]},invertX:function(e){return(e-this.x)/this.k},invertY:function(e){return(e-this.y)/this.k},rescaleX:function(e){return e.copy().domain(e.range().map(this.invertX,this).map(e.invert,e))},rescaleY:function(e){return e.copy().domain(e.range().map(this.invertY,this).map(e.invert,e))},toString:function(){return"translate("+this.x+","+this.y+") scale("+this.k+")"}};var Xh=new jh(1,0,0);i2.prototype=jh.prototype;function i2(e){for(;!e.__zoom;)if(!(e=e.parentNode))return Xh;return e.__zoom}function tR(){qt.stopImmediatePropagation()}function o2(){qt.preventDefault(),qt.stopImmediatePropagation()}function a5e(){return!qt.ctrlKey&&!qt.button}function s5e(){var e=this;return e instanceof SVGElement?(e=e.ownerSVGElement||e,e.hasAttribute("viewBox")?(e=e.viewBox.baseVal,[[e.x,e.y],[e.x+e.width,e.y+e.height]]):[[0,0],[e.width.baseVal.value,e.height.baseVal.value]]):[[0,0],[e.clientWidth,e.clientHeight]]}function Z3t(){return this.__zoom||Xh}function l5e(){return-qt.deltaY*(qt.deltaMode===1?.05:qt.deltaMode?1:.002)}function c5e(){return navigator.maxTouchPoints||"ontouchstart"in this}function u5e(e,t,r){var n=e.invertX(t[0][0])-r[0][0],i=e.invertX(t[1][0])-r[1][0],o=e.invertY(t[0][1])-r[0][1],a=e.invertY(t[1][1])-r[1][1];return e.translate(i>n?(n+i)/2:Math.min(0,n)||Math.max(0,i),a>o?(o+a)/2:Math.min(0,o)||Math.max(0,a))}function eR(){var e=a5e,t=s5e,r=u5e,n=l5e,i=c5e,o=[0,1/0],a=[[-1/0,-1/0],[1/0,1/0]],s=250,l=vL,c=vs("start","zoom","end"),u,h,f=500,p=150,d=0;function g(L){L.property("__zoom",Z3t).on("wheel.zoom",P).on("mousedown.zoom",k).on("dblclick.zoom",O).filter(i).on("touchstart.zoom",D).on("touchmove.zoom",B).on("touchend.zoom touchcancel.zoom",I).style("touch-action","none").style("-webkit-tap-highlight-color","rgba(0,0,0,0)")}g.transform=function(L,R,F){var z=L.selection?L.selection():L;z.property("__zoom",Z3t),L!==z?b(L,R,F):z.interrupt().each(function(){S(this,arguments).start().zoom(null,typeof R=="function"?R.apply(this,arguments):R).end()})},g.scaleBy=function(L,R,F){g.scaleTo(L,function(){var z=this.__zoom.k,U=typeof R=="function"?R.apply(this,arguments):R;return z*U},F)},g.scaleTo=function(L,R,F){g.transform(L,function(){var z=t.apply(this,arguments),U=this.__zoom,W=F==null?x(z):typeof F=="function"?F.apply(this,arguments):F,Z=U.invert(W),rt=typeof R=="function"?R.apply(this,arguments):R;return r(y(_(U,rt),W,Z),z,a)},F)},g.translateBy=function(L,R,F){g.transform(L,function(){return r(this.__zoom.translate(typeof R=="function"?R.apply(this,arguments):R,typeof F=="function"?F.apply(this,arguments):F),t.apply(this,arguments),a)})},g.translateTo=function(L,R,F,z){g.transform(L,function(){var U=t.apply(this,arguments),W=this.__zoom,Z=z==null?x(U):typeof z=="function"?z.apply(this,arguments):z;return r(Xh.translate(Z[0],Z[1]).scale(W.k).translate(typeof R=="function"?-R.apply(this,arguments):-R,typeof F=="function"?-F.apply(this,arguments):-F),U,a)},z)};function _(L,R){return R=Math.max(o[0],Math.min(o[1],R)),R===L.k?L:new jh(R,L.x,L.y)}function y(L,R,F){var z=R[0]-F[0]*L.k,U=R[1]-F[1]*L.k;return z===L.x&&U===L.y?L:new jh(L.k,z,U)}function x(L){return[(+L[0][0]+ +L[1][0])/2,(+L[0][1]+ +L[1][1])/2]}function b(L,R,F){L.on("start.zoom",function(){S(this,arguments).start()}).on("interrupt.zoom end.zoom",function(){S(this,arguments).end()}).tween("zoom",function(){var z=this,U=arguments,W=S(z,U),Z=t.apply(z,U),rt=F==null?x(Z):typeof F=="function"?F.apply(z,U):F,ot=Math.max(Z[1][0]-Z[0][0],Z[1][1]-Z[0][1]),st=z.__zoom,St=typeof R=="function"?R.apply(z,U):R,bt=l(st.invert(rt).concat(ot/st.k),St.invert(rt).concat(ot/St.k));return function(Mt){if(Mt===1)Mt=St;else{var lt=bt(Mt),Kt=ot/lt[2];Mt=new jh(Kt,rt[0]-lt[0]*Kt,rt[1]-lt[1]*Kt)}W.zoom(null,Mt)}})}function S(L,R,F){return!F&&L.__zooming||new C(L,R)}function C(L,R){this.that=L,this.args=R,this.active=0,this.extent=t.apply(L,R),this.taps=0}C.prototype={start:function(){return++this.active===1&&(this.that.__zooming=this,this.emit("start")),this},zoom:function(L,R){return this.mouse&&L!=="mouse"&&(this.mouse[1]=R.invert(this.mouse[0])),this.touch0&&L!=="touch"&&(this.touch0[1]=R.invert(this.touch0[0])),this.touch1&&L!=="touch"&&(this.touch1[1]=R.invert(this.touch1[0])),this.that.__zoom=R,this.emit("zoom"),this},end:function(){return--this.active===0&&(delete this.that.__zooming,this.emit("end")),this},emit:function(L){Mp(new g$(g,L,this.that.__zoom),c.apply,c,[L,this.that,this.args])}};function P(){if(!e.apply(this,arguments))return;var L=S(this,arguments),R=this.__zoom,F=Math.max(o[0],Math.min(o[1],R.k*Math.pow(2,n.apply(this,arguments)))),z=zo(this);if(L.wheel)(L.mouse[0][0]!==z[0]||L.mouse[0][1]!==z[1])&&(L.mouse[1]=R.invert(L.mouse[0]=z)),clearTimeout(L.wheel);else{if(R.k===F)return;L.mouse=[z,R.invert(z)],hu(this),L.start()}o2(),L.wheel=setTimeout(U,p),L.zoom("mouse",r(y(_(R,F),L.mouse[0],L.mouse[1]),L.extent,a));function U(){L.wheel=null,L.end()}}function k(){if(h||!e.apply(this,arguments))return;var L=S(this,arguments,!0),R=Ht(qt.view).on("mousemove.zoom",W,!0).on("mouseup.zoom",Z,!0),F=zo(this),z=qt.clientX,U=qt.clientY;zm(qt.view),tR(),L.mouse=[F,this.__zoom.invert(F)],hu(this),L.start();function W(){if(o2(),!L.moved){var rt=qt.clientX-z,ot=qt.clientY-U;L.moved=rt*rt+ot*ot>d}L.zoom("mouse",r(y(L.that.__zoom,L.mouse[0]=zo(L.that),L.mouse[1]),L.extent,a))}function Z(){R.on("mousemove.zoom mouseup.zoom",null),Fm(qt.view,L.moved),o2(),L.end()}}function O(){if(!!e.apply(this,arguments)){var L=this.__zoom,R=zo(this),F=L.invert(R),z=L.k*(qt.shiftKey?.5:2),U=r(y(_(L,z),R,F),t.apply(this,arguments),a);o2(),s>0?Ht(this).transition().duration(s).call(b,U,R):Ht(this).call(g.transform,U)}}function D(){if(!!e.apply(this,arguments)){var L=qt.touches,R=L.length,F=S(this,arguments,qt.changedTouches.length===R),z,U,W,Z;for(tR(),U=0;U<R;++U)W=L[U],Z=Tp(this,L,W.identifier),Z=[Z,this.__zoom.invert(Z),W.identifier],F.touch0?!F.touch1&&F.touch0[2]!==Z[2]&&(F.touch1=Z,F.taps=0):(F.touch0=Z,z=!0,F.taps=1+!!u);u&&(u=clearTimeout(u)),z&&(F.taps<2&&(u=setTimeout(function(){u=null},f)),hu(this),F.start())}}function B(){if(!!this.__zooming){var L=S(this,arguments),R=qt.changedTouches,F=R.length,z,U,W,Z;for(o2(),u&&(u=clearTimeout(u)),L.taps=0,z=0;z<F;++z)U=R[z],W=Tp(this,R,U.identifier),L.touch0&&L.touch0[2]===U.identifier?L.touch0[0]=W:L.touch1&&L.touch1[2]===U.identifier&&(L.touch1[0]=W);if(U=L.that.__zoom,L.touch1){var rt=L.touch0[0],ot=L.touch0[1],st=L.touch1[0],St=L.touch1[1],bt=(bt=st[0]-rt[0])*bt+(bt=st[1]-rt[1])*bt,Mt=(Mt=St[0]-ot[0])*Mt+(Mt=St[1]-ot[1])*Mt;U=_(U,Math.sqrt(bt/Mt)),W=[(rt[0]+st[0])/2,(rt[1]+st[1])/2],Z=[(ot[0]+St[0])/2,(ot[1]+St[1])/2]}else if(L.touch0)W=L.touch0[0],Z=L.touch0[1];else return;L.zoom("touch",r(y(U,W,Z),L.extent,a))}}function I(){if(!!this.__zooming){var L=S(this,arguments),R=qt.changedTouches,F=R.length,z,U;for(tR(),h&&clearTimeout(h),h=setTimeout(function(){h=null},f),z=0;z<F;++z)U=R[z],L.touch0&&L.touch0[2]===U.identifier?delete L.touch0:L.touch1&&L.touch1[2]===U.identifier&&delete L.touch1;if(L.touch1&&!L.touch0&&(L.touch0=L.touch1,delete L.touch1),L.touch0)L.touch0[1]=this.__zoom.invert(L.touch0[0]);else if(L.end(),L.taps===2){var W=Ht(this).on("dblclick.zoom");W&&W.apply(this,arguments)}}}return g.wheelDelta=function(L){return arguments.length?(n=typeof L=="function"?L:B5(+L),g):n},g.filter=function(L){return arguments.length?(e=typeof L=="function"?L:B5(!!L),g):e},g.touchable=function(L){return arguments.length?(i=typeof L=="function"?L:B5(!!L),g):i},g.extent=function(L){return arguments.length?(t=typeof L=="function"?L:B5([[+L[0][0],+L[0][1]],[+L[1][0],+L[1][1]]]),g):t},g.scaleExtent=function(L){return arguments.length?(o[0]=+L[0],o[1]=+L[1],g):[o[0],o[1]]},g.translateExtent=function(L){return arguments.length?(a[0][0]=+L[0][0],a[1][0]=+L[1][0],a[0][1]=+L[0][1],a[1][1]=+L[1][1],g):[[a[0][0],a[0][1]],[a[1][0],a[1][1]]]},g.constrain=function(L){return arguments.length?(r=L,g):r},g.duration=function(L){return arguments.length?(s=+L,g):s},g.interpolate=function(L){return arguments.length?(l=L,g):l},g.on=function(){var L=c.on.apply(c,arguments);return L===c?g:L},g.clickDistance=function(L){return arguments.length?(d=(L=+L)*L,g):Math.sqrt(d)},g}var J3t=Ee(Oe(),1);var rR=class extends bp{constructor(){super(...arguments),this._experiments=[]}load(){let t=_e().experiments();return this.requestManager.request(t).then(r=>{J3t.isEqual(this._experiments,r)||(this._experiments=r,this.emitChange())})}getExperiments(){return this._experiments.slice()}},nR=new rR;var h5e={googleStandard:["#db4437","#ff7043","#f4b400","#0f9d58","#00796b","#00acc1","#4285f4","#5c6bc0","#ab47bc"],googleCool:["#9e9d24","#0f9d58","#00796b","#00acc1","#4285f4","#5c6bc0","#607d8b"],googleWarm:["#795548","#ab47bc","#f06292","#c2185b","#db4437","#ff7043","#f4b400"],googleColorBlindAssist:["#ff7043","#00ACC1","#AB47BC","#2A56C6","#0b8043","#F7CB4D","#c0ca33","#5e35b1","#A52714"],tensorboardColorBlindAssist:["#ff7043","#0077bb","#cc3311","#33bbee","#ee3377","#009988","#bbbbbb"],colorBlindAssist1:["#4477aa","#44aaaa","#aaaa44","#aa7744","#aa4455","#aa4488"],colorBlindAssist2:["#88ccee","#44aa99","#117733","#999933","#ddcc77","#cc6677","#882255","#aa4499"],colorBlindAssist3:["#332288","#6699cc","#88ccee","#44aa99","#117733","#999933","#ddcc77","#cc6677","#aa4466","#882255","#661100","#aa4499"],colorBlindAssist4:["#4477aa","#66ccee","#228833","#ccbb44","#ee6677","#aa3377","#bbbbbb"],colorBlindAssist5:["#FF6DB6","#920000","#924900","#DBD100","#24FF24","#006DDB","#490092"],mldash:["#E47EAD","#F4640D","#FAA300","#F5E636","#00A077","#0077B8","#00B7ED"]},iR=h5e.tensorboardColorBlindAssist;var _$=class{constructor(t=iR){this.palette=t,this.identifiers=Ji()}setDomain(t){return this.identifiers=Ji(),t.forEach((r,n)=>{this.identifiers.set(r,this.palette[n%this.palette.length])}),this}getColor(t){if(!this.identifiers.has(t))throw new Error(`String ${t} was not in the domain.`);return this.identifiers.get(t)}};function Q3t(e,t){let r=new _$;function n(){r.setDomain(t())}return e.addListener(n),n(),i=>r.getColor(i)}var fn=Q3t(wp,()=>wp.getRuns()),vQr=Q3t(nR,()=>nR.getExperiments().map(({name:e})=>e));var og=Ee(Oe(),1);_s({moduleName:"run-color-style",styleContent:`
    [color-class='light-blue'] paper-checkbox {
      --paper-checkbox-checked-color: var(--paper-light-blue-500);
      --paper-checkbox-checked-ink-color: var(--paper-light-blue-500);
      --paper-checkbox-unchecked-color: var(--paper-light-blue-900);
      --paper-checkbox-unchecked-ink-color: var(--paper-light-blue-900);
    }
    [color-class='red'] paper-checkbox {
      --paper-checkbox-checked-color: var(--paper-red-500);
      --paper-checkbox-checked-ink-color: var(--paper-red-500);
      --paper-checkbox-unchecked-color: var(--paper-red-900);
      --paper-checkbox-unchecked-ink-color: var(--paper-red-900);
    }
    [color-class='green'] paper-checkbox {
      --paper-checkbox-checked-color: var(--paper-green-500);
      --paper-checkbox-checked-ink-color: var(--paper-green-500);
      --paper-checkbox-unchecked-color: var(--paper-green-900);
      --paper-checkbox-unchecked-ink-color: var(--paper-green-900);
    }
    [color-class='purple'] paper-checkbox {
      --paper-checkbox-checked-color: var(--paper-purple-500);
      --paper-checkbox-checked-ink-color: var(--paper-purple-500);
      --paper-checkbox-unchecked-color: var(--paper-purple-900);
      --paper-checkbox-unchecked-ink-color: var(--paper-purple-900);
    }
    [color-class='teal'] paper-checkbox {
      --paper-checkbox-checked-color: var(--paper-teal-500);
      --paper-checkbox-checked-ink-color: var(--paper-teal-500);
      --paper-checkbox-unchecked-color: var(--paper-teal-900);
      --paper-checkbox-unchecked-ink-color: var(--paper-teal-900);
    }
    [color-class='pink'] paper-checkbox {
      --paper-checkbox-checked-color: var(--paper-pink-500);
      --paper-checkbox-checked-ink-color: var(--paper-pink-500);
      --paper-checkbox-unchecked-color: var(--paper-pink-900);
      --paper-checkbox-unchecked-ink-color: var(--paper-pink-900);
    }
    [color-class='orange'] paper-checkbox {
      --paper-checkbox-checked-color: var(--paper-orange-500);
      --paper-checkbox-checked-ink-color: var(--paper-orange-500);
      --paper-checkbox-unchecked-color: var(--paper-orange-900);
      --paper-checkbox-unchecked-ink-color: var(--paper-orange-900);
    }
    [color-class='brown'] paper-checkbox {
      --paper-checkbox-checked-color: var(--paper-brown-500);
      --paper-checkbox-checked-ink-color: var(--paper-brown-500);
      --paper-checkbox-unchecked-color: var(--paper-brown-900);
      --paper-checkbox-unchecked-ink-color: var(--paper-brown-900);
    }
    [color-class='indigo'] paper-checkbox {
      --paper-checkbox-checked-color: var(--paper-indigo-500);
      --paper-checkbox-checked-ink-color: var(--paper-indigo-500);
      --paper-checkbox-unchecked-color: var(--paper-indigo-900);
      --paper-checkbox-unchecked-ink-color: var(--paper-indigo-900);
    }
  `});var ol=class extends Gt(mt){constructor(){super(...arguments),this.names=[],this.coloring={getColor:()=>""},this.regex="",this.selectionState={},this.maxNamesToEnableByDefault=40,this._debouncedRegexChange=this._debouncedRegexChangeImpl()}_debouncedRegexChangeImpl(){var t=og.debounce(r=>{this.regex=r},150,{leading:!1});return function(){var r=this.$$("#names-regex").value;r==""?this.async(()=>{this.regex=r},30):t(r)}}get _regex(){var t=this.regex;try{return new RegExp(t)}catch(r){return null}}_setIsolatorIcon(){var i;var t=this.selectionState,r=og.filter(og.values(t)).length,n=Array.prototype.slice.call((i=this.root)==null?void 0:i.querySelectorAll(".isolator"));n.forEach(function(o){r===1&&t[o.name]?o.icon="radio-button-checked":o.icon="radio-button-unchecked"})}computeNamesMatchingRegex(t,r){let n=this._regex;return n?this.names.filter(i=>n.test(i)):this.names}computeOutSelected(t,r){var n=this.selectionState,i=this.maxNamesToEnableByDefault,o=this.namesMatchingRegex.length<=i;return this.namesMatchingRegex.filter(a=>n[a]==null?o:n[a])}synchronizeColors(t){var i,o,a,s;this._setIsolatorIcon(),((o=(i=this.root)==null?void 0:i.querySelectorAll("paper-checkbox"))!=null?o:[]).forEach(l=>{let c=this.coloring.getColor(l.name);l.updateStyles({"--paper-checkbox-checked-color":c,"--paper-checkbox-checked-ink-color":c,"--paper-checkbox-unchecked-color":c,"--paper-checkbox-unchecked-ink-color":c})}),((s=(a=this.root)==null?void 0:a.querySelectorAll(".isolator"))!=null?s:[]).forEach(l=>{let c=this.coloring.getColor(l.name);l.style.color=c}),window.requestAnimationFrame(()=>{this.updateStyles()})}_isolateName(t){var r=t.target.name,n={};this.names.forEach(function(i){n[i]=i==r}),this.selectionState=n}_checkboxChange(t){var r=t.target;let n=og.clone(this.selectionState);n[r.name]=r.checked,this.selectionState=n}_isChecked(t,r){return this.outSelected.indexOf(t)!=-1}toggleAll(){let t=this.namesMatchingRegex.some(n=>this.outSelected.includes(n)),r={};this.names.forEach(n=>{r[n]=!t}),this.selectionState=r}};ol.template=Q`
    <style include="scrollbar-style"></style>
    <style include="run-color-style"></style>

    <paper-input
      id="names-regex"
      no-label-float=""
      label="Write a regex to filter runs"
      value="[[regex]]"
      on-bind-value-changed="_debouncedRegexChange"
    ></paper-input>
    <div id="outer-container" class="scrollbar">
      <template
        is="dom-repeat"
        items="[[namesMatchingRegex]]"
        on-dom-change="synchronizeColors"
      >
        <div class="name-row">
          <div
            class="icon-container checkbox-container vertical-align-container"
          >
            <paper-checkbox
              class="checkbox vertical-align-center"
              id$="checkbox-[[item]]"
              name="[[item]]"
              checked$="[[_isChecked(item, selectionState.*)]]"
              on-change="_checkboxChange"
            ></paper-checkbox>
          </div>
          <div
            class="icon-container isolator-container vertical-align-container"
          >
            <paper-icon-button
              icon="radio-button-unchecked"
              class="isolator vertical-align-center"
              on-tap="_isolateName"
              name="[[item]]"
            ></paper-icon-button>
          </div>
          <div class="item-label-container">
            <span>[[item]]</span>
          </div>
        </div>
      </template>
    </div>
    <style>
      paper-input {
        --paper-input-container-focus-color: var(--tb-orange-strong);
        --paper-input-container-input: {
          font-size: 14px;
        }
        --paper-input-container-label: {
          font-size: 14px;
        }
      }
      :host {
        display: flex;
        flex-direction: column;
        height: 100%;
        overflow: hidden;
      }
      #outer-container {
        contain: content;
        flex-grow: 1;
        flex-shrink: 1;
        overflow-x: hidden;
        overflow-y: auto;
        width: 100%;
        will-change: transform;
        word-wrap: break-word;
      }
      .name-row {
        contain: content;
        padding-top: 5px;
        padding-bottom: 5px;
        display: flex;
        flex-direction: row;
        font-size: 13px;
        word-break: break-all; /* makes wrapping of hyperparam strings better */
      }
      .icon-container {
        flex-grow: 0;
        flex-shrink: 0;
        padding-left: 2px;
      }
      .checkbox {
        padding-left: 2px;
        width: 18px;
        height: 18px;
      }
      .isolator {
        width: 18px;
        height: 18px;
        padding: 0px;
      }
      .isolator-container {
        padding-left: 6px;
        padding-right: 3px;
      }
      .checkbox-container {
        padding-left: 2px;
      }
      .item-label-container {
        padding-left: 5px;
        flex-grow: 1;
        flex-shrink: 1;
        width: 0px; /* hack to get the flex-grow to work properly */
      }
      .tooltip-value-container {
        display: flex;
        justify-content: center;
        flex-grow: 0;
        flex-shrink: 0;
        text-align: right;
        padding-left: 2px;
      }
      .vertical-align-container {
        display: flex;
        justify-content: center;
      }
      .vertical-align-container .vertical-align-center {
        align-self: center;
      }
      .vertical-align-container .vertical-align-top {
        align-self: start;
      }
    </style>
  `;E([A({type:Array}),w("design:type",Array)],ol.prototype,"names",void 0);E([A({type:Object}),w("design:type",Object)],ol.prototype,"coloring",void 0);E([A({type:String,notify:!0}),w("design:type",String)],ol.prototype,"regex",void 0);E([A({type:Array,computed:"computeNamesMatchingRegex(names.*, _regex)"}),w("design:type",Array)],ol.prototype,"namesMatchingRegex",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],ol.prototype,"selectionState",void 0);E([A({type:Array,notify:!0,computed:"computeOutSelected(namesMatchingRegex.*, selectionState.*)"}),w("design:type",Array)],ol.prototype,"outSelected",void 0);E([A({type:Number}),w("design:type",Number)],ol.prototype,"maxNamesToEnableByDefault",void 0);E([A({type:Object}),w("design:type",Object)],ol.prototype,"_debouncedRegexChange",void 0);E([Rt("regex"),w("design:type",Object),w("design:paramtypes",[])],ol.prototype,"_regex",null);E([Bt("selectionState","names"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],ol.prototype,"_setIsolatorIcon",null);ol=E([yt("tf-multi-checkbox")],ol);var a2=class extends mt{get _parts(){var t=this.value,r=this.delimiterPattern;let n=[];for(;;){let i=new RegExp(r,"g");if(i.test(t),i.lastIndex===0){n.push(t);break}else n.push(t.slice(0,i.lastIndex)),t=t.slice(i.lastIndex)}return n}};a2.template=Q`
    <!--
      This ugly formatting is required to prevent spaces from slipping
      into the HTML.
    -->
    <template is="dom-repeat" items="[[_parts]]" as="part"
      >[[part]]<wbr
    /></template>
  `;E([A({type:String}),w("design:type",String)],a2.prototype,"value",void 0);E([A({type:String}),w("design:type",String)],a2.prototype,"delimiterPattern",void 0);E([Rt("value","delimiterPattern"),w("design:type",Array),w("design:paramtypes",[])],a2.prototype,"_parts",null);a2=E([yt("tf-wbr-string")],a2);var mc=class extends Gt(mt){constructor(){super(...arguments),this.runSelectionState=OW("runSelectionState",{defaultValue:{}}).call(this),this.regexInput=y_("regexInput",{defaultValue:""}).call(this),this._dataLocationClipLength=250,this._dataLocationDelimiterPattern="[/=_,-]",this.coloring={getColor:fn},this._storeRunSelectionState=zW("runSelectionState",{defaultValue:{}}),this._regexObserver=v_("regexInput",{defaultValue:""})}attached(){this._runStoreListener=wp.addListener(()=>{this.set("runs",wp.getRuns())}),this.set("runs",wp.getRuns()),this._envStoreListener=ib.addListener(()=>{this.set("dataLocation",ib.getDataLocation())}),this.set("dataLocation",ib.getDataLocation())}detached(){wp.removeListenerByKey(this._runStoreListener),ib.removeListenerByKey(this._envStoreListener)}_toggleAll(){this.$.multiCheckbox.toggleAll()}get _clippedDataLocation(){var t=this.dataLocation,r=this._dataLocationClipLength;if(t!==void 0)return t.length>r?t.substring(0,r):t}_openDataLocationDialog(t){t.preventDefault(),this.$$("#data-location-dialog").open()}_shouldShowExpandDataLocationButton(t,r){return t&&t.length>r}};mc.template=Q`
    <paper-dialog with-backdrop="" id="data-location-dialog">
      <h2>Data Location</h2>
      <tf-wbr-string
        value="[[dataLocation]]"
        delimiter-pattern="[[_dataLocationDelimiterPattern]]"
      >
      </tf-wbr-string
    ></paper-dialog>
    <div id="top-text">
      <h3 id="tooltip-help" class="tooltip-container">Runs</h3>
    </div>
    <tf-multi-checkbox
      id="multiCheckbox"
      names="[[runs]]"
      selection-state="{{runSelectionState}}"
      out-selected="{{selectedRuns}}"
      regex="{{regexInput}}"
      coloring="[[coloring]]"
    ></tf-multi-checkbox>
    <paper-button class="x-button" id="toggle-all" on-tap="_toggleAll">
      Toggle All Runs
    </paper-button>
    <template is="dom-if" if="[[dataLocation]]">
      <div id="data-location">
        <tf-wbr-string
          value="[[_clippedDataLocation]]"
          delimiter-pattern="[[_dataLocationDelimiterPattern]]"
        ></tf-wbr-string
        ><!--
          We use HTML comments to remove spaces before the ellipsis.
        --><template
          is="dom-if"
          if="[[_shouldShowExpandDataLocationButton(dataLocation, _dataLocationClipLength)]]"
          ><!--
          --><a href="" on-click="_openDataLocationDialog">…</a>
        </template>
      </div>
    </template>
    <style>
      :host {
        box-sizing: border-box;
        display: flex;
        flex-direction: column;
        padding-bottom: 10px;
      }
      #top-text {
        color: var(--tb-secondary-text-color);
        width: 100%;
        flex-grow: 0;
        flex-shrink: 0;
        padding-right: 16px;
        box-sizing: border-box;
      }
      tf-wbr-string {
        overflow-wrap: break-word;
      }
      tf-multi-checkbox {
        display: flex;
        flex-grow: 1;
        flex-shrink: 1;
        overflow: hidden;
      }
      .x-button {
        font-size: 13px;
        background-color: var(--tb-ui-light-accent);
        color: var(--tb-ui-dark-accent);
      }
      #tooltip-help {
        color: var(--tb-secondary-text-color);
        margin: 0;
        font-weight: normal;
        font-size: 14px;
        margin-bottom: 5px;
      }
      paper-button {
        margin-left: 0;
      }
      #data-location {
        color: var(--tb-ui-dark-accent);
        font-size: 13px;
        margin: 5px 0 0 0;
        max-width: 288px;
      }
    </style>
  `;E([A({type:Object,observer:"_storeRunSelectionState"}),w("design:type",Object)],mc.prototype,"runSelectionState",void 0);E([A({type:String,observer:"_regexObserver"}),w("design:type",String)],mc.prototype,"regexInput",void 0);E([A({type:Array,notify:!0}),w("design:type",Array)],mc.prototype,"selectedRuns",void 0);E([A({type:Array}),w("design:type",Array)],mc.prototype,"runs",void 0);E([A({type:String,notify:!0}),w("design:type",String)],mc.prototype,"dataLocation",void 0);E([A({type:Number}),w("design:type",Number)],mc.prototype,"_dataLocationClipLength",void 0);E([A({type:String}),w("design:type",String)],mc.prototype,"_dataLocationDelimiterPattern",void 0);E([A({type:Object}),w("design:type",Object)],mc.prototype,"coloring",void 0);E([Rt("dataLocation","_dataLocationClipLength"),w("design:type",Object),w("design:paramtypes",[])],mc.prototype,"_clippedDataLocation",null);mc=E([yt("tf-runs-selector")],mc);var an=class{constructor(){this.cancellationCount=0}cancellable(t){let r=this.cancellationCount;return n=>{let i=this.cancellationCount!==r;return t({value:n,cancelled:i})}}cancelAll(){this.cancellationCount++}};var H5=class extends Gt(mt){constructor(){super(...arguments),this.html=""}get sanitizedHtml(){return this.html}attached(){window.requestAnimationFrame(()=>{this.scopeSubtree(this.$.markdown,!0)})}};H5.template=Q`
    <div id="markdown" inner-h-t-m-l="[[sanitizedHtml]]"></div>
    <style>
      /*
       * Reduce topmost and bottommost margins from 16px to 0.3em (renders
       * at about 4.8px) to keep the layout compact. This improves the
       * appearance when there is only one line of text; standard Markdown
       * renderers will still include a \`<p>\` element.
       *
       * By targeting only the top-level, extremal elements, we preserve any
       * actual paragraph breaks and only change the padding against the
       * component edges.
       */
      #markdown > p:first-child {
        margin-top: 0.3em;
      }
      #markdown > p:last-child {
        margin-bottom: 0.3em;
      }

      /* Pleasant styles for Markdown tables. */
      #markdown table {
        border-collapse: collapse;
      }
      #markdown table th {
        font-weight: 600;
      }
      #markdown table th,
      #markdown table td {
        padding: 6px 13px;
        border: 1px solid var(--tb-ui-border, #dfe2e5);
      }
      #markdown table tr {
        background-color: inherit;
        border-top: 1px solid var(--tb-ui-border, #c6cbd1);
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],H5.prototype,"html",void 0);E([Rt("html"),w("design:type",Object),w("design:paramtypes",[])],H5.prototype,"sanitizedHtml",null);H5=E([yt("tf-markdown-view")],H5);_s({moduleName:"tf-card-heading-style",styleContent:`
    figcaption {
      width: 100%;
    }

    /** Horizontal line of labels. */
    .heading-row {
      margin-top: -4px;
      display: flex;
      flex-direction: row;
      flex-wrap: wrap;
    }

    /** Piece of text in the figure caption. */
    .heading-label {
      flex-grow: 1;
      margin-top: 4px;
      max-width: 100%;
      word-wrap: break-word;
    }

    /** Makes label show on the right. */
    .heading-right {
      flex-grow: 0;
    }
  `});function s2(e){return e?e.toString().replace(/GMT-\d+ \(([^)]+)\)/,"$1"):""}function tMt(e){let t=p5e(e);return t?Math.round((t[0]*299+t[1]*587+t[2]*114)/1e3)>125?"inherit":"#eee":"inherit"}function p5e(e){if(!e)return null;let t=e.match(/^#([0-9a-f]{1,2})([0-9a-f]{1,2})([0-9a-f]{1,2})$/);if(!t)return null;if(e.length==4)for(var r=1;r<=3;r++)t[r]=t[r]+t[r];return[parseInt(t[1],16),parseInt(t[2],16),parseInt(t[3],16)]}var gc=class extends mt{constructor(){super(...arguments),this.displayName=null,this.tag=null,this.run=null,this.description=null,this.color=null}_updateHeadingStyle(){this.updateStyles({"--tf-card-heading-background-color":this._runBackground,"--tf-card-heading-color":this._runColor})}_computeRunBackground(t){return t||"none"}_computeRunColor(t){return tMt(t)}get _nameLabel(){var t=this.displayName,r=this.tag;return t||r||""}get _tagLabel(){var t=this.displayName,r=this.tag;return r&&r!==t?r:""}_toggleDescriptionDialog(t){let r=this.$.descriptionDialog;r.positionTarget=t.target,r.toggle()}};gc.template=Q`
    <div class="container">
      <figcaption class="content">
        <div class="heading-row">
          <template is="dom-if" if="[[_nameLabel]]">
            <div itemprop="name" class="heading-label name">[[_nameLabel]]</div>
          </template>
          <template is="dom-if" if="[[run]]">
            <!-- Extra wrapping span needed to avoid flexbox blockification. -->
            <!-- (see flexbox spec, section 4 "Flex Items") -->
            <span>
              <span
                itemprop="run"
                id="heading-run"
                class="heading-label heading-right run"
                >[[run]]</span
              >
            </span>
          </template>
        </div>
        <template is="dom-if" if="[[_tagLabel]]">
          <div class="heading-row">
            <div class="heading-label">
              tag: <span itemprop="tag">[[_tagLabel]]</span>
            </div>
          </div>
        </template>
        <slot></slot>
      </figcaption>
      <template is="dom-if" if="[[description]]">
        <paper-icon-button
          icon="info"
          on-tap="_toggleDescriptionDialog"
          title="Show summary description"
        ></paper-icon-button>
      </template>
      <paper-dialog
        id="descriptionDialog"
        no-overlap=""
        horizontal-align="auto"
        vertical-align="auto"
      >
        <paper-dialog-scrollable>
          <tf-markdown-view html="[[description]]"></tf-markdown-view>
        </paper-dialog-scrollable>
      </paper-dialog>
    </div>
    <style include="tf-card-heading-style">
      .container {
        display: flex;
      }
      .content {
        font-size: 12px;
        flex-grow: 1;
      }
      .name {
        font-size: 14px;
      }
      .run {
        font-size: 11px;
        width: auto;
        border-radius: 3px;
        font-weight: bold;
        padding: 1px 4px 2px;
      }
      paper-icon-button {
        flex-grow: 0;
      }
      paper-dialog-scrollable {
        max-width: 640px;
      }
      #heading-run {
        background: var(--tf-card-heading-background-color);
        color: var(--tf-card-heading-color);
      }
    </style>
  `;E([A({type:String}),w("design:type",Object)],gc.prototype,"displayName",void 0);E([A({type:String}),w("design:type",Object)],gc.prototype,"tag",void 0);E([A({type:String}),w("design:type",Object)],gc.prototype,"run",void 0);E([A({type:String}),w("design:type",Object)],gc.prototype,"description",void 0);E([A({type:String}),w("design:type",Object)],gc.prototype,"color",void 0);E([A({type:String,computed:"_computeRunBackground(color)",readOnly:!0,observer:"_updateHeadingStyle"}),w("design:type",String)],gc.prototype,"_runBackground",void 0);E([A({type:String,computed:"_computeRunColor(color)",readOnly:!0,observer:"_updateHeadingStyle"}),w("design:type",String)],gc.prototype,"_runColor",void 0);E([Rt("displayName","tag"),w("design:type",String),w("design:paramtypes",[])],gc.prototype,"_nameLabel",null);E([Rt("displayName","tag"),w("design:type",String),w("design:paramtypes",[])],gc.prototype,"_tagLabel",null);gc=E([yt("tf-card-heading")],gc);var Fi=class extends Gt(mt){constructor(){super(...arguments),this._metadataCanceller=new an,this._steps=[],this._attached=!1}get _runColor(){var t=this.run;return fn(t)}get _hasAtLeastOneStep(){var t=this._steps;return!!t&&t.length>0}get _hasMultipleSteps(){var t=this._steps;return!!t&&t.length>1}get _maxStepIndex(){var t=this._steps;return t.length-1}get _currentDatum(){var t=this._steps,r=this._stepIndex;return t[r]}get _sampleText(){var t=this.sample;return`${t+1}`}get _hasMultipleSamples(){var t=this.totalSamples;return t>1}attached(){this._attached=!0,this.reload()}_reloadOnRunTagChange(){this.reload()}reload(){if(!this._attached)return;this._metadataCanceller.cancelAll();let r=_e().pluginRoute("audio","/audio",new URLSearchParams({tag:this.tag,run:this.run,sample:String(this.sample)})),n=this._metadataCanceller.cancellable(i=>{if(i.cancelled)return;let a=i.value.map(this._createStepDatum.bind(this));this.set("_steps",a),this.set("_stepIndex",a.length-1)});this.requestManager.request(r).then(n)}_createStepDatum(t){let r=new URLSearchParams(t.query);r.append("ts",String(t.wall_time));let n=_e().pluginRouteForSrc("audio","/individualAudio",r);return{wall_time:s2(new Date(t.wall_time*1e3)),step:t.step,label:t.label,contentType:t.contentType,url:n}}};Fi.template=Q`
    <tf-card-heading
      tag="[[tag]]"
      run="[[run]]"
      display-name="[[tagMetadata.displayName]]"
      description="[[tagMetadata.description]]"
      color="[[_runColor]]"
    >
      <template is="dom-if" if="[[_hasMultipleSamples]]">
        <div class="heading-row">
          <div class="heading-label">
            sample: [[_sampleText]] of [[totalSamples]]
          </div>
        </div>
      </template>
      <template is="dom-if" if="[[_hasAtLeastOneStep]]">
        <div class="heading-row">
          <div class="heading-label">
            step <strong>[[_currentDatum.step]]</strong>
          </div>
          <template is="dom-if" if="[[_currentDatum.wall_time]]">
            <div class="heading-label heading-right">
              [[_currentDatum.wall_time]]
            </div>
          </template>
        </div>
      </template>
      <template is="dom-if" if="[[_hasMultipleSteps]]">
        <div class="heading-row">
          <paper-slider
            id="steps"
            immediate-value="{{_stepIndex}}"
            max="[[_maxStepIndex]]"
            max-markers="[[_maxStepIndex]]"
            snaps=""
            step="1"
            value="{{_stepIndex}}"
          ></paper-slider>
        </div>
      </template>
    </tf-card-heading>
    <template is="dom-if" if="[[_hasAtLeastOneStep]]">
      <audio
        controls=""
        src$="[[_currentDatum.url]]"
        type$="[[_currentDatum.contentType]]"
      ></audio>
      <tf-markdown-view html="[[_currentDatum.label]]"></tf-markdown-view>
    </template>
    <div id="main-audio-container"></div>

    <style include="tf-card-heading-style">
      :host {
        display: block;
        width: 350px;
        height: auto;
        position: relative;
        --step-slider-knob-color: #424242;
        margin-right: 15px;
        margin-bottom: 15px;
      }

      #steps {
        height: 15px;
        margin: 0 0 0 -15px;
        width: 100%;
        box-sizing: border-box;
        padding: 0 5px; /* so the slider knob doesn't butt out */
        margin-top: 5px;
        --paper-slider-active-color: var(--step-slider-knob-color);
        --paper-slider-knob-color: var(--step-slider-knob-color);
        --paper-slider-pin-color: var(--step-slider-knob-color);
        --paper-slider-knob-start-color: var(--step-slider-knob-color);
        --paper-slider-knob-start-border-color: var(--step-slider-knob-color);
        --paper-slider-pin-start-color: var(--step-slider-knob-color);
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],Fi.prototype,"run",void 0);E([A({type:String}),w("design:type",String)],Fi.prototype,"tag",void 0);E([A({type:Number}),w("design:type",Number)],Fi.prototype,"sample",void 0);E([A({type:Number}),w("design:type",Number)],Fi.prototype,"totalSamples",void 0);E([A({type:Object}),w("design:type",Object)],Fi.prototype,"tagMetadata",void 0);E([A({type:Object}),w("design:type",Ae)],Fi.prototype,"requestManager",void 0);E([A({type:Object}),w("design:type",an)],Fi.prototype,"_metadataCanceller",void 0);E([A({type:Array}),w("design:type",Array)],Fi.prototype,"_steps",void 0);E([A({type:Number}),w("design:type",Number)],Fi.prototype,"_stepIndex",void 0);E([Rt("run"),w("design:type",String),w("design:paramtypes",[])],Fi.prototype,"_runColor",null);E([Rt("_steps"),w("design:type",Boolean),w("design:paramtypes",[])],Fi.prototype,"_hasAtLeastOneStep",null);E([Rt("_steps"),w("design:type",Boolean),w("design:paramtypes",[])],Fi.prototype,"_hasMultipleSteps",null);E([Rt("_steps"),w("design:type",Number),w("design:paramtypes",[])],Fi.prototype,"_maxStepIndex",null);E([Rt("_steps","_stepIndex"),w("design:type",Object),w("design:paramtypes",[])],Fi.prototype,"_currentDatum",null);E([Rt("sample"),w("design:type",String),w("design:paramtypes",[])],Fi.prototype,"_sampleText",null);E([Rt("totalSamples"),w("design:type",Boolean),w("design:paramtypes",[])],Fi.prototype,"_hasMultipleSamples",null);E([Bt("run","tag"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Fi.prototype,"_reloadOnRunTagChange",null);Fi=E([yt("tf-audio-loader")],Fi);var $h=class extends Gt(mt){constructor(){super(...arguments),this.reloadOnReady=!0,this._tagFilter="",this._requestManager=new Ae}ready(){super.ready(),this.reloadOnReady&&this.reload()}reload(){this._fetchTags().then(()=>{this._reloadAudio()})}_fetchTags(){let t=_e().pluginRoute("audio","/tags");return this._requestManager.request(t).then(r=>{if(fy.isEqual(r,this._runToTagInfo))return;let n=fy.mapValues(r,o=>Object.keys(o)),i=$i(n);this.set("_dataNotFound",i.length===0),this.set("_runToTagInfo",r)})}_reloadAudio(){var t;(t=this.root)==null||t.querySelectorAll("tf-audio-loader").forEach(r=>{r.reload()})}_shouldOpen(t){return t<=2}get _categories(){var t=this._runToTagInfo,r=this._selectedRuns,n=this._tagFilter;let i=fy.mapValues(t,l=>Object.keys(l)),o=Ql(i,r,n);function a(l){let c=t[l.run][l.tag].samples;return fy.range(c).map(u=>Object.assign({},l,{sample:u,totalSamples:c}))}return o.map(l=>Object.assign({},l,{items:[].concat.apply([],l.items.map(a))}))}_tagMetadata(t,r,n){return t[r][n]}};$h.template=Q`
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <div class="sidebar-section runs-selector">
          <tf-runs-selector
            id="runs-selector"
            selected-runs="{{_selectedRuns}}"
          ></tf-runs-selector>
        </div>
      </div>
      <div class="center" slot="center">
        <template is="dom-if" if="[[_dataNotFound]]">
          <div class="no-data-warning">
            <h3>No audio data was found.</h3>
            <p>Probable causes:</p>
            <ul>
              <li>You haven’t written any audio data to your event files.</li>
              <li>TensorBoard can’t find your event files.</li>
            </ul>

            <p>
              If you’re new to using TensorBoard, and want to find out how to
              add data and set up your event files, check out the
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
                >README</a
              >
              and perhaps the
              <a
                href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
                >TensorBoard tutorial</a
              >.
            </p>

            <p>
              If you think TensorBoard is configured properly, please see
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"
                >the section of the README devoted to missing data problems</a
              >
              and consider filing an issue on GitHub.
            </p>
          </div>
        </template>
        <template is="dom-if" if="[[!_dataNotFound]]">
          <tf-tag-filterer tag-filter="{{_tagFilter}}"></tf-tag-filterer>
          <template is="dom-repeat" items="[[_categories]]" as="category">
            <tf-category-paginated-view
              category="[[category]]"
              initial-opened="[[_shouldOpen(index)]]"
            >
              <template>
                <tf-audio-loader
                  active="[[active]]"
                  run="[[item.run]]"
                  tag="[[item.tag]]"
                  sample="[[item.sample]]"
                  total-samples="[[item.totalSamples]]"
                  tag-metadata="[[_tagMetadata(_runToTagInfo, item.run, item.tag)]]"
                  request-manager="[[_requestManager]]"
                ></tf-audio-loader>
              </template>
            </tf-category-paginated-view>
          </template>
        </template>
      </div>
    </tf-dashboard-layout>
    <style include="dashboard-style"></style>
    <style>
      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }
    </style>
  `;E([A({type:Boolean}),w("design:type",Boolean)],$h.prototype,"reloadOnReady",void 0);E([A({type:Array}),w("design:type",Array)],$h.prototype,"_selectedRuns",void 0);E([A({type:Object}),w("design:type",Object)],$h.prototype,"_runToTagInfo",void 0);E([A({type:Boolean}),w("design:type",Boolean)],$h.prototype,"_dataNotFound",void 0);E([A({type:String}),w("design:type",String)],$h.prototype,"_tagFilter",void 0);E([A({type:Object}),w("design:type",Ae)],$h.prototype,"_requestManager",void 0);E([Rt("_runToTagInfo","_selectedRuns","_tagFilter"),w("design:type",Array),w("design:paramtypes",[])],$h.prototype,"_categories",null);$h=E([yt("tf-audio-dashboard")],$h);var V5=class extends Gt(mt){attached(){this.async(function(){this.getEffectiveChildren().forEach(function(t){this.listen(t,"tap","_selectTarget")}.bind(this))})}_selectTarget(t){this.selectedId=t.currentTarget.id}_selectedIdChanged(){var t=this.queryEffectiveChildren("#"+this.selectedId);!t||(this.getEffectiveChildren().forEach(function(r){r.classList.remove("selected")}),t.classList.add("selected"))}};V5.template=Q`
    <div id="wrap">
      <h3>[[name]]</h3>
      <div class="content-wrapper"><slot></slot></div>
    </div>
    <style>
      .content-wrapper ::slotted(*) {
        background: none;
        color: var(--tb-ui-dark-accent);
        font-size: 13px;
        margin-top: 10px;
      }

      .content-wrapper ::slotted(*) {
        background: none;
        color: var(--tb-ui-dark-accent);
        font-size: 13px;
        margin-top: 10px;
      }

      .content-wrapper ::slotted(.selected) {
        background-color: var(--tb-ui-dark-accent);
        color: white !important;
      }

      h3 {
        color: var(--tb-secondary-text-color);
        display: block;
        font-size: 14px;
        font-weight: normal;
        margin: 0 0 5px;
        pointer-events: none;
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],V5.prototype,"name",void 0);E([A({type:String,notify:!0,observer:"_selectedIdChanged"}),w("design:type",String)],V5.prototype,"selectedId",void 0);V5=E([yt("tf-option-selector")],V5);function oR(e,t){let r,n={};Object.keys(e).forEach(a=>{let s=e[a];r===void 0&&(r=s.displayName),r!==s.displayName&&(r=null),n[s.description]===void 0&&(n[s.description]=[]),n[s.description].push(a)});let i=r!=null?r:t,o=(()=>{let a=Object.keys(n);return a.length===0?"":a.length===1?a[0]:`<p><strong>Multiple descriptions:</strong></p><ul>${a.map(c=>{let u=n[c].map(p=>`<code>${p.replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/&/g,"&amp;")}</code>`),h=u.length>2?u.slice(0,u.length-1).join(", ")+", and "+u[u.length-1]:u.join(" and ");return`<li><p>For ${d5e(u.length,"run","runs")} ${h}:</p>${c}</li>`}).join("")}</ul>`})();return{displayName:i,description:o}}function d5e(e,t,r){return e===1?t:r}var rMt=Ee(Oe(),1);var Hp=class extends mt{constructor(){super(...arguments),this.weight=.6,this._updateWeight=rMt.debounce(function(t){this.weight=t},250)}_immediateWeightNumberForPaperSliderChanged(){this._inputWeightStringForPaperInput=this._immediateWeightNumberForPaperSlider.toString(),this._updateWeight.call(this,this._immediateWeightNumberForPaperSlider)}_inputWeightStringForPaperInputChanged(){+this._inputWeightStringForPaperInput<0?this._inputWeightStringForPaperInput="0":+this._inputWeightStringForPaperInput>1&&(this._inputWeightStringForPaperInput="1");var t=+this._inputWeightStringForPaperInput;isNaN(t)||this._updateWeight.call(this,t)}};Hp.template=Q`
    <h3 class="title">Smoothing</h3>
    <div class="smoothing-block">
      <paper-slider
        id="slider"
        immediate-value="{{_immediateWeightNumberForPaperSlider}}"
        max="[[max]]"
        min="[[min]]"
        pin
        step="[[step]]"
        type="number"
        value="{{weight}}"
      ></paper-slider>
      <paper-input
        id="input"
        label="weight"
        no-label-float
        value="{{_inputWeightStringForPaperInput}}"
        type="number"
        step="[[step]]"
        min="[[min]]"
        max="[[max]]"
      ></paper-input>
    </div>
    <style>
      .title {
        color: var(--tb-secondary-text-color);
        margin: 0;
        font-weight: normal;
        font-size: 14px;
        margin-bottom: 5px;
      }

      .smoothing-block {
        display: flex;
      }

      paper-slider {
        --paper-slider-active-color: var(--tb-orange-strong);
        --paper-slider-knob-color: var(--tb-orange-strong);
        --paper-slider-knob-start-border-color: var(--tb-orange-strong);
        --paper-slider-knob-start-color: var(--tb-orange-strong);
        --paper-slider-markers-color: var(--tb-orange-strong);
        --paper-slider-pin-color: var(--tb-orange-strong);
        --paper-slider-pin-start-color: var(--tb-orange-strong);
        flex-grow: 2;
      }

      paper-input {
        --paper-input-container-focus-color: var(--tb-orange-strong);
        --paper-input-container-input: {
          font-size: 14px;
        }
        --paper-input-container-label: {
          font-size: 14px;
        }
        width: 60px;
      }
    </style>
  `;E([A({type:Number}),w("design:type",Number)],Hp.prototype,"step",void 0);E([A({type:Number}),w("design:type",Number)],Hp.prototype,"max",void 0);E([A({type:Number}),w("design:type",Number)],Hp.prototype,"min",void 0);E([A({type:Number,notify:!0}),w("design:type",Number)],Hp.prototype,"weight",void 0);E([A({type:Number,notify:!0,observer:"_immediateWeightNumberForPaperSliderChanged"}),w("design:type",Number)],Hp.prototype,"_immediateWeightNumberForPaperSlider",void 0);E([A({type:String,notify:!0,observer:"_inputWeightStringForPaperInputChanged"}),w("design:type",String)],Hp.prototype,"_inputWeightStringForPaperInput",void 0);Hp=E([yt("tf-smoothing-input")],Hp);var Yo=Ee(Oe(),1);function Mi(e,t){let r=Object.keys(t).sort().filter(a=>t[a]!==void 0);if(!r.length)return e;let n=e.indexOf("?")!==-1?"&":"?",o=Array().concat(...r.map(a=>{let s=t[a];return(Array.isArray(s)?s:[s]).map(c=>`${a}=${m5e(c)}`)})).join("&");return e+n+o}function m5e(e){return encodeURIComponent(e).replace(/\(/g,"%28").replace(/\)/g,"%29")}var $Kt=Ee(Oe(),1),ZWn=Ee(wl(),1);var DKt=Ee(Oe(),1);var x4;(function(e){e[e.LOADING=0]="LOADING",e[e.LOADED=1]="LOADED"})(x4||(x4={}));function kS(e){return class extends e{constructor(){super(...arguments),this.loadKey="",this.dataToLoad=[],this.getDataLoadName=r=>String(r),this.dataLoading=!1,this.dataLoadedAtLeastOnce=!1,this._isConnected=!1,this._dataLoadState=new Map,this._canceller=new an,this._loadDataAsync=null,this._loadData=DKt.throttle(this._loadDataImpl,100,{leading:!0,trailing:!0})}connectedCallback(){super.connectedCallback(),this._isConnected=!0}disconnectedCallback(){super.disconnectedCallback(),this._isConnected=!1}static get properties(){return{active:{type:Boolean,observer:"_loadDataIfActive"},_isConnected:{type:Boolean},loadKey:{type:String},dataToLoad:{type:Array},getDataLoadName:{type:Object},loadDataCallback:{type:Object},requestData:{type:Object}}}static get observers(){return["_dataToLoadChanged(_isConnected, dataToLoad.*)"]}onLoadFinish(){}reload(){this._dataLoadState.clear(),this._loadData()}reset(){this._loadDataAsync!=null&&(clearTimeout(this._loadDataAsync),this._loadDataAsync=null),this._canceller&&this._canceller.cancelAll(),this._dataLoadState&&this._dataLoadState.clear(),this._isConnected&&this._loadData()}_dataToLoadChanged(){this._isConnected&&this._loadData()}detached(){this._loadDataAsync!=null&&(clearTimeout(this._loadDataAsync),this._loadDataAsync=null)}_loadDataIfActive(){this.active&&this._loadData()}_loadDataImpl(){!this.active||(this._loadDataAsync!==null&&clearTimeout(this._loadDataAsync),this._loadDataAsync=setTimeout(this._canceller.cancellable(r=>{if(r.cancelled)return;this.dataLoading=!0;let n=this.dataToLoad.filter(a=>{let s=this.getDataLoadName(a);return!this._dataLoadState.has(s)});for(let a of n){let s=this.getDataLoadName(a);this._dataLoadState.set(s,x4.LOADING)}let i=this._canceller.cancellable(a=>{if(a.cancelled)return;let{item:s,data:l}=a.value,c=this.getDataLoadName(s);this._dataLoadState.set(c,x4.LOADED),this.loadDataCallback(this,s,l)}),o=this._canceller.cancellable(a=>{if(!a.cancelled){let l=a.value,c=new Set(n.map(h=>this.getDataLoadName(h)));this.dataToLoad.some(h=>c.has(this.getDataLoadName(h)))&&this.onLoadFinish(),this._loadDataAsync=null,this.dataLoadedAtLeastOnce=!0}Array.from(this._dataLoadState.values()).includes(x4.LOADING)||(this.dataLoading=!1)});this.requestData(n,i,()=>o(void 0))})))}}}var bqe=Ee(Oe(),1),Wo=Ee(wl(),1),RS=[{character:"\u25FC",method:Wo.SymbolFactories.square},{character:"\u25C6",method:Wo.SymbolFactories.diamond},{character:"\u25B2",method:Wo.SymbolFactories.triangle},{character:"\u2605",method:Wo.SymbolFactories.star},{character:"\u271A",method:Wo.SymbolFactories.cross}],Ed;(function(e){e.STEP="step",e.RELATIVE="relative",e.WALL_TIME="wall_time"})(Ed||(Ed={}));var e0=4,wqe=4,mB=3,gB=20,_B=4,OKt=6;function Wu(e){return t=>{let r=Math.abs(t);r<1e-15&&(r=0);let n;return r>=1e4?n=xn("."+e+"~e"):r>0&&r<.01?n=xn("."+e+"~e"):n=xn("."+e+"~g"),n(t)}}var b4=xn(`.${wqe}~s`);function Xat(){let e=new Wo.Scales.Linear;e.tickGenerator(Wo.Scales.TickGenerators.integerTickGenerator());let t=new Wo.Axes.Numeric(e,"bottom");return t.formatter(b4),{scale:e,axis:t,accessor:r=>r.step}}var yB=Wo.Formatters.time("%a %b %e, %H:%M:%S");function Sqe(){let e=new Wo.Scales.Time;return{scale:e,axis:new Wo.Axes.Time(e,"bottom"),accessor:t=>t.wall_time}}var r0=(e,t,r)=>{if(e.relative!=null)return e.relative;let n=r.data(),i=n.length>0?+n[0].wall_time:0;return(+e.wall_time-i)/(60*60*1e3)},vB=e=>{let t="",r=Math.floor(e/24);e-=r*24,r&&(t+=r+"d ");let n=Math.floor(e);e-=n,e*=60,(n||r)&&(t+=n+"h ");let i=Math.floor(e);e-=i,e*=60,(i||n||r)&&(t+=i+"m ");let o=Math.floor(e);return t+o+"s"};function Mqe(){let e=new Wo.Scales.Linear;return{scale:e,axis:new Wo.Axes.Numeric(e,"bottom"),accessor:r0}}function xB(e){switch(e){case Ed.STEP:return Xat();case Ed.WALL_TIME:return Sqe();case Ed.RELATIVE:return Mqe();default:throw new Error("invalid xType: "+e)}}var zs=Ee(Oe(),1),Mn=Ee(wl(),1);var va=Ee(wl(),1);function Eqe(e){let t=[],r=e;for(;r&&r instanceof HTMLElement;)if(t.push(r),r.assignedSlot)r=r.assignedSlot;else if(r.parentElement)r=r.parentElement;else{let n=r.parentNode;n instanceof DocumentFragment?r=n.host:r=n!==r?n:null}return t}var Tqe=[1,0,0,1,0,0];function Cqe(e){let t=Eqe(e),r=Tqe,n=null;for(let i of t){let o=va.Utils.DOM.getElementTransform(i);if(o!=null){let l=i.clientWidth/2,c=i.clientHeight/2;r=va.Utils.Math.multiplyTranslate(r,[l,c]),r=va.Utils.Math.multiplyMatrix(r,va.Utils.Math.invertMatrix(o)),r=va.Utils.Math.multiplyTranslate(r,[-l,-c])}let a=i.scrollLeft,s=i.scrollTop;(n===null||i===n)&&(a-=i.offsetLeft+i.clientLeft,s-=i.offsetTop+i.clientTop,n=i.offsetParent),r=va.Utils.Math.multiplyTranslate(r,[a,s])}return r}var wB=class extends va.Utils.Translator{computePosition(t,r){let n={x:t,y:r},i=Cqe(this._rootElement);return i==null?n:va.Utils.Math.applyTransform(i,n)}},Uv=class extends va.Dispatchers.Mouse{constructor(t){super(t),this._eventTarget=t.root().rootElement().node(),this._translator=new wB(t.root().rootElement().node())}static getDispatcher(t){let r=t.root().rootElement(),n=r[Uv._DISPATCHER_KEY];return n||(n=new Uv(t),r[Uv._DISPATCHER_KEY]=n),n}},qv=class extends va.Dispatchers.Touch{constructor(t){super(t),this._eventTarget=t.root().rootElement().node(),this._translator=new wB(t.root().rootElement().node())}static getDispatcher(t){let r=t.root().rootElement(),n=r[qv._DISPATCHER_KEY];return n||(n=new qv(t),r[qv._DISPATCHER_KEY]=n),n}};va.Interaction.prototype._isInsideComponent=function(e){return 0<=e.x&&0<=e.y&&e.x<this._componentAttachedTo.width()&&e.y<this._componentAttachedTo.height()};var SB=class extends va.Interactions.Pointer{_anchor(t){let r=this;r._isAnchored=!0,r._mouseDispatcher=Uv.getDispatcher(r._componentAttachedTo),r._mouseDispatcher.onMouseMove(r._mouseMoveCallback),r._touchDispatcher=qv.getDispatcher(r._componentAttachedTo),r._touchDispatcher.onTouchStart(r._touchStartCallback)}};var zKt=Ee(Oe(),1);var Gv;(function(e){e.AUTO="auto",e.BOTTOM="bottom",e.RIGHT="right"})(Gv||(Gv={}));var Aqe={boxShadow:"0 1px 4px rgba(0, 0, 0, .3)",opacity:0,position:"fixed",willChange:"transform",zIndex:5},w4=class extends Gt(mt){constructor(){super(...arguments),this.position=Gv.AUTO,this.minDistFromEdge=15,this._styleCache=null,this._raf=null,this._tunnel=null}ready(){this._styleCache=null,this._raf=null,this._tunnel=null}attached(){this._tunnel=this._createTunnel(),this._hideOnBlur=()=>{document.hidden&&this.hide()},window.addEventListener("visibilitychange",this._hideOnBlur)}detached(){this.hide(),this._removeTunnel(this._tunnel),this._tunnel=null,window.removeEventListener("visibilitychange",this._hideOnBlur)}content(){return this._tunnel.shadowRoot}hide(){this._raf!==null&&window.cancelAnimationFrame(this._raf),this._styleCache=null,this._tunnel.style.opacity=0}updateAndPosition(t){this._raf!==null&&window.cancelAnimationFrame(this._raf),this._raf=window.requestAnimationFrame(()=>{!this.isAttached||this._repositionImpl(t)})}_repositionImpl(t){let r=this._tunnel,n=t.getBoundingClientRect(),i=r.getBoundingClientRect(),o=window.innerHeight,a=document.body.clientWidth,s=n.top,l=s+n.height,c=i.height+gB,u=null,h=Math.max(this.minDistFromEdge,n.left),f=null,p=s;this.position==Gv.RIGHT?h=n.right:(p=l+gB,a<h+i.width+this.minDistFromEdge&&(h=null,f=this.minDistFromEdge)),this.position==Gv.AUTO&&n.top-c>0&&o<n.top+n.height+c&&(p=null,u=o-s+gB);let d={contain:"content",opacity:1,left:h?`${h}px`:null,right:f?`${f}px`:null,top:p?`${p}px`:null,bottom:u?`${u}px`:null};zKt.isEqual(this._styleCache,d)||(Object.assign(r.style,d),this._styleCache=d)}_createTunnel(){if(!this.contentComponentName)throw new RangeError("Require `contentComponentName` to be a name of a Polymer component");let t=document.createElement(this.contentComponentName);return Object.assign(t.style,Aqe),document.body.appendChild(t),t}_removeTunnel(t){document.body.removeChild(t)}};E([A({type:String}),w("design:type",String)],w4.prototype,"contentComponentName",void 0);E([A({type:String}),w("design:type",String)],w4.prototype,"position",void 0);E([A({type:Number}),w("design:type",Number)],w4.prototype,"minDistFromEdge",void 0);w4=E([yt("vz-chart-tooltip")],w4);var NS=Ee(wl(),1);var HKt=1e4,VKt=.001,UKt=xn(".2~e"),Pqe=xn(".4~r"),FKt=xn(",~");function BKt(e){if(e===0)return"0";let t=Math.abs(e);return t>=HKt||t<VKt?UKt(e):Pqe(e)}var Kat={formatTick:BKt,formatShort:BKt,formatReadable(e){let t=Math.abs(e);return t>=HKt||t<VKt?UKt(e):FKt(e)},formatLong:FKt},iWn=new Intl.NumberFormat(void 0,{maximumFractionDigits:4});var oWn=xn("0.3~s"),aWn=xn(",.3~f");var Iqe=1e3,Lqe=60*Iqe,kqe=60*Lqe,Rqe=24*kqe,sWn=365*Rqe,lWn=xn(".4~");var Nqe=Yb().tickFormat(),$at,qKt={formatTick(e){return Nqe(new Date(e))},formatShort(e){return new Date(e).toLocaleString($at,{year:"numeric",month:"short",day:"numeric",hour:"numeric",minute:"numeric",second:"numeric"})},formatReadable(e){return new Date(e).toLocaleString($at,{year:"numeric",month:"short",day:"numeric",hour:"numeric",minute:"numeric",second:"numeric",timeZoneName:"short"})},formatLong(e){return new Date(e).toLocaleString($at,{year:"numeric",month:"long",day:"numeric",hour:"numeric",minute:"numeric",second:"numeric",timeZoneName:"short",fractionalSecondDigits:3})}};var Td;(function(e){e[e.LINEAR=0]="LINEAR",e[e.LOG10=1]="LOG10",e[e.TIME=2]="TIME"})(Td||(Td={}));function GKt(e){switch(e){case Td.LINEAR:return new Zat;case Td.LOG10:return new Jat;case Td.TIME:return new Qat;default:let t=e;throw new RangeError(`ScaleType ${t} not supported.`)}}var Dqe=.05,Zat=class{constructor(){this.defaultFormatter=Kat}transform(t,r,n){let[i,o]=t,a=o-i,[s,l]=r,c=l-s;return a===0?s:c/a*(n-i)+s}forward(t,r,n){return this.transform(t,r,n)}reverse(t,r,n){return this.transform(r,t,n)}niceDomain(t){let[r,n]=t;if(n<r)throw new Error("Unexpected input: min is larger than max");if(n===r)return r===0?[-1,1]:r<0?[2*r,0]:[0,2*r];let i=On(),o=(n-r+Number.EPSILON)*Dqe,[a,s]=i.domain([r-o,n+o]).nice().domain();return[a,s]}ticks(t,r){return On().domain(t).ticks(r)}isSafeNumber(t){return Number.isFinite(t)}},Jat=class{constructor(){this.defaultFormatter=Kat}transform(t){return Math.log10(t>0?t:Number.MIN_VALUE)}untransform(t){return Math.exp(t/Math.LOG10E)}forward(t,r,n){if(n<=0)return r[0];let[i,o]=t,[a,s]=r,l=this.transform(i),u=this.transform(o)-l,h=s-a;return n=this.transform(n),h/(u+Number.EPSILON)*(n-l)+a}reverse(t,r,n){let[i,o]=t,[a,s]=r,l=this.transform(i),u=this.transform(o)-l,h=s-a,f=u/(h+Number.EPSILON)*(n-a)+l;return this.untransform(f)}niceDomain(t){let[r,n]=t;if(r>n)throw new Error("Unexpected input: min is larger than max");let i=Math.max(r,Number.MIN_VALUE),o=Math.max(n,Number.MIN_VALUE);return n<=0?[Number.MIN_VALUE,1]:[Math.max(Number.MIN_VALUE,i*.5),o*2]}ticks(t,r){let n=t[0]<=0?Number.MIN_VALUE:t[0],i=t[1]<=0?Number.MIN_VALUE:t[1],o=cc().domain([n,i]).ticks(r);return o.length?o:t}isSafeNumber(t){return Number.isFinite(t)&&t>0}},Qat=class{constructor(){this.scale=Yb(),this.defaultFormatter=qKt}forward(t,r,n){return this.scale.domain(t).range(r)(n)}reverse(t,r,n){return this.scale.domain(t).range(r).invert(n).getTime()}niceDomain(t){let[r,n]=this.scale.domain(t).nice().domain();return[r.getTime(),n.getTime()]}ticks(t,r){return this.scale.domain(t).ticks(r).map(n=>n.getTime())}isSafeNumber(t){return Number.isFinite(t)}};var MB=class extends NS.Scales.Linear{constructor(){super(),this._ignoreOutlier=!1,this.padProportion(.2)}setValueProviderForDomain(t){return this._valueProviderForDomain=t,this}_niceDomain(t,r){let[n,i]=t;return GKt(Td.LINEAR).niceDomain([n,i])}_getUnboundedExtent(t){let r=this._getAllIncludedValues(t),n=this._defaultExtent();if(r.length!==0){let i=[NS.Utils.Math.min(r,n[0]),NS.Utils.Math.max(r,n[1])];n=this._niceDomain(i)}return n}_getAllIncludedValues(t=!1){let r=this._valueProviderForDomain?this._valueProviderForDomain():[];return this.extentOfValues(r)}extentOfValues(t){let r=t.filter(o=>NS.Utils.Math.isValidNumber(o)),n=r;if(this.ignoreOutlier()){let o=r.sort((l,c)=>l-c),a=sa(o,.05),s=sa(o,.95);n=r.filter(l=>l>=a&&l<=s)}let i=aa(n);return i[0]==null||i[1]==null?[]:i}ignoreOutlier(t){return typeof t=="boolean"?(this._ignoreOutlier=t,this):this._ignoreOutlier}};var CB=Ee(wl(),1);var WKt=Ee(wl(),1),EB=class extends WKt.QuantitativeScale{constructor(){super(...arguments),this._ignoreOutlier=!1}setValueProviderForDomain(t){return this._valueProviderForDomain=t,this}ignoreOutlier(t){return typeof t=="boolean"?(this._ignoreOutlier=t,this):this._ignoreOutlier}_getAllIncludedValues(t=!1){let r=this._valueProviderForDomain?this._valueProviderForDomain():[];return this.extentOfValues(r)}};var TB=Math.pow(2,-1074);function S4(e){return Math.log10(e)}function tst(e){return Math.pow(10,e)}var AB=class extends EB{constructor(){super(),this._d3LogScale=cc(),this.padProportion(.2)}scale(t){return t<=0?NaN:this._d3LogScale(t)}invert(t){return this._d3LogScale.invert(t)}scaleTransformation(t){return this.scale(t)}invertedTransformation(t){return this.invert(t)}getTransformationDomain(){return this.domain()}setTransformationDomain(t){this.domain(t)}getTransformationExtent(){return this._getUnboundedExtent(!0)}_getDomain(){return this._untransformedDomain}_setDomain(t){this._untransformedDomain=t;let[r,n]=t;super._setDomain([Math.max(TB,r),n])}_niceDomain(t,r){let[n,i]=t,o=Math.max(S4(TB),S4(n)),a=S4(i),s=a-o,l=s?s*this.padProportion():1;return[tst(Math.max(S4(TB),o-l)),tst(a+l)]}_getUnboundedExtent(t){let r=this._getAllIncludedValues(t),n=this._defaultExtent();if(r.length!==0){let i=[CB.Utils.Math.min(r,n[0]),CB.Utils.Math.max(r,n[1])];n=this._niceDomain(i)}return n}_getAllIncludedValues(t=!1){return super._getAllIncludedValues().map(n=>n>0?n:TB)}_defaultExtent(){return[1,10]}_backingScaleDomain(t){return t==null?this._d3LogScale.domain():(this._d3LogScale.domain(t),this)}_getRange(){return this._d3LogScale.range()}_setRange(t){this._d3LogScale.range(t)}defaultTicks(){return this._d3LogScale.ticks(1)}ticks(){return this._d3LogScale.ticks()}extentOfValues(t){let r=t.filter(o=>CB.Utils.Math.isValidNumber(o)&&o>0),n=r;if(this.ignoreOutlier()){let a=r.map(S4).sort((c,u)=>c-u),s=sa(a,.05),l=sa(a,.95);n=a.filter(c=>c>=s&&c<=l).map(tst)}let i=aa(n);return i[0]==null||i[1]==null?[]:i}};var Cd=Ee(wl(),1);var n0=Ee(wl(),1),PB=class extends n0.Components.SelectionBoxLayer{constructor(t,r,n){super(),this.easeFn=xs,this._animationTime=750,this.xScale(t),this.yScale(r),this._dragInteraction=new n0.Interactions.Drag,this._doubleClickInteraction=new n0.Interactions.Click,this.setupCallbacks(),this.unzoomMethod=n,this.onDetach(()=>{this._doubleClickInteraction.detachFrom(this),this._dragInteraction.detachFrom(this)}),this.onAnchor(()=>{this._doubleClickInteraction.attachTo(this),this._dragInteraction.attachTo(this)})}interactionStart(t){this.onStart=t}interactionEnd(t){this.onEnd=t}dragInteraction(){return this._dragInteraction}setupCallbacks(){let t=!1;this._dragInteraction.onDragStart(r=>{this.bounds({topLeft:r,bottomRight:r}),this.onStart()}),this._dragInteraction.onDrag((r,n)=>{this.bounds({topLeft:r,bottomRight:n}),this.boxVisible(!0),t=!0}),this._dragInteraction.onDragEnd((r,n)=>{this.boxVisible(!1),this.bounds({topLeft:r,bottomRight:n}),t?this.zoom():this.onEnd(),t=!1}),this._doubleClickInteraction.onDoubleClick(this.unzoom.bind(this))}animationTime(t){if(t==null)return this._animationTime;if(t<0)throw new Error("animationTime cannot be negative");return this._animationTime=t,this}ease(t){if(typeof t!="function")throw new Error("ease function must be a function");return(t(0)!==0||t(1)!==1)&&n0.Utils.Window.warn("Easing function does not maintain invariant f(0)==0 && f(1)==1. Bad behavior may result."),this.easeFn=t,this}zoom(){let t=this.xExtent()[0].valueOf(),r=this.xExtent()[1].valueOf(),n=this.yExtent()[1].valueOf(),i=this.yExtent()[0].valueOf();t===r||n===i||this.interpolateZoom(t,r,n,i)}unzoom(){let t=this.xScale();t._domainMin=null,t._domainMax=null;let r=t._getExtent();this.xScale().domain(r),this.unzoomMethod()}isZooming(t){this._dragInteraction.enabled(!t),this._doubleClickInteraction.enabled(!t)}interpolateZoom(t,r,n,i){let o=this.xScale().domain()[0].valueOf(),a=this.xScale().domain()[1].valueOf(),s=this.yScale().domain()[0].valueOf(),l=this.yScale().domain()[1].valueOf(),c=this.easeFn,u=(p,d,g)=>zi(p,d)(c(g));this.isZooming(!0);let h=Date.now(),f=()=>{let d=Date.now()-h,g=this._animationTime===0?1:Math.min(1,d/this._animationTime),_=u(o,t,g),y=u(a,r,g),x=u(s,n,g),b=u(l,i,g);this.xScale().domain([_,y]),this.yScale().domain([x,b]),g<1?n0.Utils.DOM.requestAnimationFramePolyfill(f):(this.onEnd(),this.isZooming(!1))};f()}};var xa;(function(e){e[e.NONE=0]="NONE",e[e.DRAG_ZOOMING=1]="DRAG_ZOOMING",e[e.PANNING=2]="PANNING"})(xa||(xa={}));var zf=class extends Cd.Components.Group{constructor(t,r,n){super(),this.state=xa.NONE,this.panStartCallback=new Cd.Utils.CallbackSet,this.panEndCallback=new Cd.Utils.CallbackSet,this.panZoom=new Cd.Interactions.PanZoom(t,r),this.panZoom.dragInteraction().mouseFilter(o=>zf.isPanKey(o)&&o.button===0),this.panZoom.wheelFilter(this.canScrollZoom),this.dragZoomLayer=new PB(t,r,n),this.dragZoomLayer.dragInteraction().mouseFilter(o=>!zf.isPanKey(o)&&o.button===0),this.append(this.dragZoomLayer);let i=this.onWheel.bind(this);this.onAnchor(()=>{this._mouseDispatcher=Cd.Dispatchers.Mouse.getDispatcher(this),this._mouseDispatcher.onWheel(i),this.panZoom.attachTo(this)}),this.onDetach(()=>{this.panZoom.detachFrom(this),this._mouseDispatcher&&(this._mouseDispatcher.offWheel(i),this._mouseDispatcher=null)}),this.panZoom.dragInteraction().onDragStart(()=>{this.state==xa.NONE&&this.setState(xa.PANNING)}),this.panZoom.dragInteraction().onDragEnd(()=>{this.state==xa.PANNING&&this.setState(xa.NONE)}),this.dragZoomLayer.dragInteraction().onDragStart(()=>{this.state==xa.NONE&&this.setState(xa.DRAG_ZOOMING)}),this.dragZoomLayer.dragInteraction().onDragEnd(()=>{this.state==xa.DRAG_ZOOMING&&this.setState(xa.NONE)})}onWheel(t,r){if(this.canScrollZoom(r))return;let n=this.element();if(!n.select(".help").empty())return;let i=n.append("div").classed("help",!0);i.append("span").text("Alt + Scroll to Zoom"),i.on("animationend",()=>void i.remove())}static isPanKey(t){return Boolean(t.altKey)||Boolean(t.shiftKey)}canScrollZoom(t){return t.altKey}setState(t){if(this.state==t)return;let r=this.state;this.state=t,this.root().removeClass(this.stateClassName(r)),this.root().addClass(this.stateClassName(t)),r==xa.PANNING&&this.panEndCallback.callCallbacks(),t==xa.PANNING&&this.panStartCallback.callCallbacks()}stateClassName(t){switch(t){case xa.PANNING:return"panning";case xa.DRAG_ZOOMING:return"drag-zooming";case xa.NONE:default:return""}}onPanStart(t){this.panStartCallback.add(t)}onPanEnd(t){this.panEndCallback.add(t)}onScrollZoom(t){this.panZoom.onZoomEnd(t)}onDragZoomStart(t){this.dragZoomLayer.interactionStart(t)}onDragZoomEnd(t){this.dragZoomLayer.interactionEnd(t)}};var IB;(function(e){e[e.TEXT=0]="TEXT",e[e.DOM=1]="DOM"})(IB||(IB={}));var Ff;(function(e){e.LOG="log",e.LINEAR="linear"})(Ff||(Ff={}));var YKt=20,DS=class{constructor(t,r,n,i,o,a,s,l,c,u,h){this.dirtyDatasets=new Set,this.seriesNames=[],this.name2datasets={},this.colorScale=i,this.tooltip=o,this.datasets=[],this._ignoreYOutliers=!1,this.lastPointsDataset=new Mn.Dataset,this.nanDataset=new Mn.Dataset,this.yValueAccessor=r,this.symbolFunction=u,this._defaultXRange=l,this._defaultYRange=c,this.tooltipColumns=a,this.buildChart(t,r,n,s,h)}buildChart(t,r,n,i,o){this.destroy();let a=t();this.xAccessor=a.accessor,this.xScale=a.scale,this.xAxis=a.axis,this.xAxis.margin(1).tickLabelPadding(3),o&&this.xAxis.formatter(o),this.yScale=DS.getYScaleFromType(n),this.yScale.setValueProviderForDomain(()=>this.getValuesForYAxisDomainCompute()),this.yAxis=new Mn.Axes.Numeric(this.yScale,"left");let s=Wu(mB);this.yAxis.margin(0).tickLabelPadding(5).formatter(s),this.yAxis.usesTextWidthApproximation(!0),this.fillArea=i;let l=new zf(this.xScale,this.yScale,()=>this.resetDomain());this.tooltipInteraction=this.createTooltipInteraction(l),this.tooltipPointsComponent=new Mn.Component;let c=this.buildPlot(this.xScale,this.yScale,i);this.gridlines=new Mn.Components.Gridlines(this.xScale,this.yScale);let u=null;n!==Ff.LOG&&(u=new Mn.Components.GuideLineLayer("horizontal"),u.scale(this.yScale).value(0));let h=new Mn.Components.GuideLineLayer("vertical");h.scale(this.xScale).value(0),this.center=new Mn.Components.Group([this.gridlines,u,h,c,this.tooltipPointsComponent,l]),this.center.addClass("main"),this.outer=new Mn.Components.Table([[this.yAxis,this.center],[null,this.xAxis]])}buildPlot(t,r,n){n&&(this.marginAreaPlot=new Mn.Plots.Area,this.marginAreaPlot.x(this.xAccessor,t),this.marginAreaPlot.y(n.higherAccessor,r),this.marginAreaPlot.y0(n.lowerAccessor),this.marginAreaPlot.attr("fill",(c,u,h)=>this.colorScale.scale(h.metadata().name)),this.marginAreaPlot.attr("fill-opacity",.3),this.marginAreaPlot.attr("stroke-width",0)),this.smoothedAccessor=c=>c.smoothed;let i=new Mn.Plots.Line;i.x(this.xAccessor,t),i.y(this.yValueAccessor,r),i.attr("stroke",(c,u,h)=>this.colorScale.scale(h.metadata().name)),this.linePlot=i,this.setupTooltips(i);let o=new Mn.Plots.Line;if(o.x(this.xAccessor,t),o.y(this.smoothedAccessor,r),o.attr("stroke",(c,u,h)=>this.colorScale.scale(h.metadata().name)),this.smoothLinePlot=o,this.symbolFunction){let c=new Mn.Plots.Scatter;c.x(this.xAccessor,t),c.y(this.yValueAccessor,r),c.attr("fill",(u,h,f)=>this.colorScale.scale(f.metadata().name)),c.attr("opacity",1),c.size(_B*2),c.symbol((u,h,f)=>this.symbolFunction(f.metadata().name)),this.markersScatterPlot=c}let a=new Mn.Plots.Scatter;a.x(this.xAccessor,t),a.y(this.yValueAccessor,r),a.attr("fill",c=>this.colorScale.scale(c.name)),a.attr("opacity",1),a.size(_B*2),a.datasets([this.lastPointsDataset]),this.scatterPlot=a;let s=new Mn.Plots.Scatter;s.x(this.xAccessor,t),s.y(c=>c.displayY,r),s.attr("fill",c=>this.colorScale.scale(c.name)),s.attr("opacity",1),s.size(OKt*2),s.datasets([this.nanDataset]),s.symbol(Mn.SymbolFactories.triangle),this.nanDisplay=s;let l=[s,a,o,i];return this.marginAreaPlot&&l.push(this.marginAreaPlot),this.markersScatterPlot&&l.push(this.markersScatterPlot),new Mn.Components.Group(l)}ignoreYOutliers(t){t!==this._ignoreYOutliers&&(this._ignoreYOutliers=t,this.updateSpecialDatasets(),this.yScale.ignoreOutlier(t),this.resetYDomain())}getValuesForYAxisDomainCompute(){let t=this.getAccessorsForComputingYRange(),r=n=>t.map(i=>n.data().map(o=>i(o,-1,n)));return zs.flattenDeep(this.datasets.map(r)).filter(isFinite)}updateSpecialDatasets(){let t=this.getYAxisAccessor(),r=this.datasets.map(o=>{let a=null,s=o.data().filter(l=>!isNaN(t(l,-1,o)));if(s.length>0){let l=s.length-1;a=s[l],a.name=o.metadata().name,a.relative=r0(a,-1,o)}return a}).filter(o=>o!=null);this.lastPointsDataset.data(r),this.markersScatterPlot&&this.markersScatterPlot.datasets(this.datasets.map(this.createSampledDatasetForMarkers));let n=o=>{let a=null,s=o.data(),l=0;for(;l<s.length&&a==null;)isNaN(t(s[l],-1,o))||(a=t(s[l],-1,o)),l++;a==null&&(a=0);let c=[];for(l=0;l<s.length;l++)isNaN(t(s[l],-1,o))?(s[l].name=o.metadata().name,s[l].displayY=a,s[l].relative=r0(s[l],-1,o),c.push(s[l])):a=t(s[l],-1,o);return c},i=zs.flatten(this.datasets.map(n));this.nanDataset.data(i)}resetDomain(){this.resetXDomain(),this.resetYDomain()}resetXDomain(){let t;if(this._defaultXRange!=null)t=this._defaultXRange;else{let r=this.xScale;r._domainMin=null,r._domainMax=null,t=r._getExtent()}this.xScale.domain(t)}resetYDomain(){this._defaultYRange!=null?this.yScale.domain(this._defaultYRange):(this.yScale.autoDomain(),this.yScale.domain(this.yScale.domain()))}getAccessorsForComputingYRange(){let t=[this.getYAxisAccessor()];return this.fillArea&&t.push(this.fillArea.lowerAccessor,this.fillArea.higherAccessor),t}getYAxisAccessor(){return this.smoothingEnabled?this.smoothedAccessor:this.yValueAccessor}createTooltipInteraction(t){let r=new SB,n=()=>{r.enabled(!1),this.hideTooltips()},i=()=>r.enabled(!0);return t.onPanStart(n),t.onDragZoomStart(n),t.onPanEnd(i),t.onDragZoomEnd(i),t.onScrollZoom(()=>this.updateTooltipContent(this._lastMousePosition)),r.onPointerMove(o=>{this._lastMousePosition=o,this.updateTooltipContent(o)}),r.onPointerExit(()=>this.hideTooltips()),r}updateTooltipContent(t){!this.linePlot||(window.cancelAnimationFrame(this._tooltipUpdateAnimationFrame),this._tooltipUpdateAnimationFrame=window.requestAnimationFrame(()=>{let r={x:t.x,y:t.y},n=this.gridlines.content().node().getBBox(),i=this.linePlot.datasets().map(l=>this.findClosestPoint(r,l)).filter(l=>Boolean(l)),o=Mn.Utils.DOM.intersectsBBox,a=i.filter(l=>o(l.x,l.y,n)||isNaN(this.yValueAccessor(l.datum,0,l.dataset))),s=a.filter(l=>!isNaN(this.yValueAccessor(l.datum,0,l.dataset)));if(i.length!==0){this.scatterPlot.attr("display","none");let l=this.tooltipPointsComponent.content().selectAll(".point").data(s,c=>c.dataset.metadata().name);l.enter().append("circle").classed("point",!0),l.attr("r",_B).attr("cx",c=>c.x).attr("cy",c=>c.y).style("stroke","none").attr("fill",c=>this.colorScale.scale(c.dataset.metadata().name)),l.exit().remove(),this.drawTooltips(a,r,this.tooltipColumns)}else this.hideTooltips()}))}hideTooltips(){window.cancelAnimationFrame(this._tooltipUpdateAnimationFrame),this.tooltip.hide(),this.scatterPlot.attr("display","block"),this.tooltipPointsComponent.content().selectAll(".point").remove()}setupTooltips(t){t.onDetach(()=>{this.tooltipInteraction.detachFrom(t),this.tooltipInteraction.enabled(!1)}),t.onAnchor(()=>{this.tooltipInteraction.attachTo(t),this.tooltipInteraction.enabled(!0)})}drawTooltips(t,r,n){if(!t.length){this.tooltip.hide();return}let{colorScale:i}=this;n=[{title:"",static:!1,evalType:IB.DOM,evaluate(d){return Ht(this).select("span").style("background-color",()=>i.scale(d.dataset.metadata().name)),""},enter(d){Ht(this).append("span").classed("swatch",!0).style("background-color",()=>i.scale(d.dataset.metadata().name))}},...n];let a=Wu(e0),s=d=>Math.pow(d.x-r.x,2)+Math.pow(d.y-r.y,2),l=zs.min(t.map(s)),c=this.smoothingEnabled?this.smoothedAccessor:this.yValueAccessor;this.tooltipSortingMethod==="ascending"?t=zs.sortBy(t,d=>c(d.datum,-1,d.dataset)):this.tooltipSortingMethod==="descending"?t=zs.sortBy(t,d=>c(d.datum,-1,d.dataset)).reverse():this.tooltipSortingMethod==="nearest"?t=zs.sortBy(t,s):t=t.slice(0).reverse();let u=this,h=Ht(this.tooltip.content()).select("table"),f=h.select("thead").selectAll("th").data(n,(d,g,_)=>d.title);f.enter().append("th").text(d=>d.title).nodes(),f.exit().remove();let p=h.select("tbody").selectAll("tr").data(t,(d,g,_)=>d.dataset.metadata().name);p.classed("distant",d=>{let g=d.dataset.data()[0],_=zs.last(d.dataset.data()),y=this.xScale.scale(this.xAccessor(g,0,d.dataset)),x=this.xScale.scale(this.xAccessor(_,0,d.dataset)),b=this.smoothingEnabled?d.datum.smoothed:this.yValueAccessor(d.datum,0,d.dataset);return r.x<y||r.x>x||isNaN(b)}).classed("closest",d=>s(d)===l).each(function(d){u.drawTooltipRow(this,n,d)}).order(),p.exit().remove(),p.enter().append("tr").each(function(d){u.drawTooltipRow(this,n,d)}).nodes(),this.tooltip.updateAndPosition(this.targetSVG.node())}drawTooltipRow(t,r,n){let i=this,o=Ht(t).selectAll("td").data(r);o.each(function(a){a.static||i.drawTooltipColumn.call(i,this,a,n)}),o.exit().remove(),o.enter().append("td").each(function(a){"enter"in a&&a.enter.call(this,n),i.drawTooltipColumn.call(i,this,a,n)})}drawTooltipColumn(t,r,n){let{smoothingEnabled:i}=this;"evalType"in r&&r.evalType==IB.DOM?r.evaluate.call(t,n,{smoothingEnabled:i}):Ht(t).text(r.evaluate.call(t,n,{smoothingEnabled:i}))}findClosestPoint(t,r){let n=r.data().map((s,l)=>this.xScale.scale(this.xAccessor(s,l,r))),i=zs.sortedIndex(n,t.x);if(n.length==0)return null;if(i===n.length)i=i-1;else if(i!==0){let s=Math.abs(n[i-1]-t.x),l=Math.abs(n[i]-t.x);i=s<l?i-1:i}let o=r.data()[i],a=this.smoothingEnabled?this.smoothedAccessor(o,i,r):this.yValueAccessor(o,i,r);return{x:n[i],y:this.yScale.scale(a),datum:o,dataset:r}}resmoothDataset(t){let r=t.data(),n=this.smoothingWeight,i=r.length>0?0:NaN,o=0,a=r.map((l,c)=>this.yValueAccessor(l,c,t)),s=a.every(l=>l==a[0]);r.forEach((l,c)=>{let u=a[c];if(s||!Number.isFinite(u))l.smoothed=u;else{i=i*n+(1-n)*u,o++;let h=1;n!==1&&(h=1-Math.pow(n,o)),l.smoothed=i/h}})}getDataset(t){return this.name2datasets[t]===void 0&&(this.name2datasets[t]=new Mn.Dataset([],{name:t,meta:null})),this.name2datasets[t]}static getYScaleFromType(t){if(t===Ff.LOG)return new AB;if(t===Ff.LINEAR)return new MB;throw new Error("Unrecognized yScale type "+t)}setVisibleSeries(t){this.disableChanges(),t=t.sort(),t.reverse(),this.seriesNames=t}disableChanges(){this.dirtyDatasets.size||(this.linePlot.datasets([]),this.smoothLinePlot&&this.smoothLinePlot.datasets([]),this.marginAreaPlot&&this.marginAreaPlot.datasets([]))}commitChanges(){this.datasets=this.seriesNames.map(t=>this.getDataset(t)),[...this.dirtyDatasets].forEach(t=>{this.smoothingEnabled&&this.resmoothDataset(this.getDataset(t))}),this.updateSpecialDatasets(),this.linePlot.datasets(this.datasets),this.smoothingEnabled&&this.smoothLinePlot.datasets(this.datasets),this.marginAreaPlot&&this.marginAreaPlot.datasets(this.datasets),this.measureBBoxAndMaybeInvalidateLayoutInRaf(),this.dirtyDatasets.clear()}createSampledDatasetForMarkers(t){let r=t.data();if(r.length<=YKt)return t;let n=Math.ceil(r.length/YKt),i=new Array(Math.floor(r.length/n));for(let o=0,a=0;o<i.length;o++,a+=n)i[o]=r[a];return new Mn.Dataset(i,t.metadata())}setSeriesData(t,r){this.disableChanges(),this.getDataset(t).data(r),this.dirtyDatasets.add(t)}setSeriesMetadata(t,r){this.disableChanges(),this.getDataset(t).metadata(Mx(Kl({},this.getDataset(t).metadata()),{meta:r})),this.dirtyDatasets.add(t)}smoothingUpdate(t){this.smoothingWeight=t,this.datasets.forEach(r=>this.resmoothDataset(r)),this.smoothingEnabled||(this.linePlot.addClass("ghost"),this.scatterPlot.y(this.smoothedAccessor,this.yScale),this.smoothingEnabled=!0,this.smoothLinePlot.datasets(this.datasets)),this.markersScatterPlot&&this.markersScatterPlot.y(this.getYAxisAccessor(),this.yScale),this.updateSpecialDatasets()}smoothingDisable(){this.smoothingEnabled&&(this.linePlot.removeClass("ghost"),this.scatterPlot.y(this.yValueAccessor,this.yScale),this.smoothLinePlot.datasets([]),this.smoothingEnabled=!1,this.updateSpecialDatasets()),this.markersScatterPlot&&this.markersScatterPlot.y(this.getYAxisAccessor(),this.yScale)}setColorScale(t){this.colorScale=t}setTooltipColumns(t){this.tooltipColumns=t}setTooltipSortingMethod(t){this.tooltipSortingMethod=t}renderTo(t){this.targetSVG=t,this.outer.renderTo(t),this._defaultXRange!=null&&this.resetXDomain(),this._defaultYRange!=null&&this.resetYDomain(),this.measureBBoxAndMaybeInvalidateLayoutInRaf()}redraw(){window.cancelAnimationFrame(this._redrawRaf),this._redrawRaf=window.requestAnimationFrame(()=>{this.measureBBoxAndMaybeInvalidateLayout(),this.outer.redraw()})}measureBBoxAndMaybeInvalidateLayoutInRaf(){window.cancelAnimationFrame(this._invalidateLayoutRaf),this._invalidateLayoutRaf=window.requestAnimationFrame(()=>{this.measureBBoxAndMaybeInvalidateLayout()})}measureBBoxAndMaybeInvalidateLayout(){if(this._lastDrawBBox){let{width:t}=this._lastDrawBBox,{width:r}=this.targetSVG.node().getBoundingClientRect();t==0&&t<r&&this.outer.invalidateCache()}this._lastDrawBBox=this.targetSVG.node().getBoundingClientRect()}destroy(){window.cancelAnimationFrame(this._redrawRaf),window.cancelAnimationFrame(this._invalidateLayoutRaf),this.outer&&this.outer.destroy()}onAnchor(t){this.outer&&this.outer.onAnchor(t)}isDataFitToDomain(){return t(this.xAxis.getScale())&&t(this.yAxis.getScale());function t(r){let n=r.getTransformationDomain(),i=r.getTransformationExtent();return i[0]===n[0]&&i[1]===n[1]}}};var XKt=Ee(Oe(),1),nst=Ee(wl(),1);_s({moduleName:"plottable-style",styleContent:`
    
.plottable-colors-0 {
  background-color: #5279c7; /* INDIGO */
}

.plottable-colors-1 {
  background-color: #fd373e; /* CORAL_RED */
}

.plottable-colors-2 {
  background-color: #63c261; /* FERN */
}

.plottable-colors-3 {
  background-color: #fad419; /* BRIGHT_SUN */
}

.plottable-colors-4 {
  background-color: #2c2b6f; /* JACARTA */
}

.plottable-colors-5 {
  background-color: #ff7939; /* BURNING_ORANGE */
}

.plottable-colors-6 {
  background-color: #db2e65; /* CERISE_RED */
}

.plottable-colors-7 {
  background-color: #99ce50; /* CONIFER */
}

.plottable-colors-8 {
  background-color: #962565; /* ROYAL_HEATH */
}

.plottable-colors-9 {
  background-color: #06cccc; /* ROBINS_EGG_BLUE */
}

/**
 * User-supplied renderTo element.
 */
.plottable {
  display: block; /* must be block elements for width/height calculations to work in Firefox. */
  pointer-events: visibleFill;
  position: relative;
  /**
   * Pre 3.0, users could set the dimension of the root element in two ways: either using CSS
   * (inline or through a stylesheet), or using the SVG width/height attributes. By default, we
   * set the SVG width/height attributes to 100%.
   *
   * Post 3.0 the root element is always a normal div and the only way to set the dimensions is
   * to use CSS. To replicate the "100%-by-default" behavior, we apply width/height 100%.
   */
  width: 100%;
  height: 100%;
}

/**
 * The _element that roots each Component's DOM.
 */
.plottable .component {
  /* Allow components to be positioned with explicit left/top/width/height styles */
  position: absolute;
}

.plottable .background-container,
.plottable .content,
.plottable .foreground-container {
  position: absolute;
  width: 100%;
  height: 100%;
}

/**
 * Don't allow svg elements above the content to steal events
 */
.plottable .foreground-container {
  pointer-events: none;
}

.plottable .component-overflow-hidden {
  overflow: hidden;
}

.plottable .component-overflow-visible {
  overflow: visible;
}

.plottable .plot-canvas-container {
  width: 100%;
  height: 100%;
  overflow: hidden;
}

.plottable .plot-canvas {
  width: 100%;
  height: 100%;
  /**
   * Play well with deferred rendering.
   */
  transform-origin: 0px 0px 0px;
}

.plottable text {
  text-rendering: geometricPrecision;
}

.plottable .label text {
  fill: #32313F;
}

.plottable .bar-label-text-area text,
.plottable .scatter-label-text-area text {
  font-size: 12px;
}

.plottable .label-area text {
  fill: #32313F;
  font-size: 14px;
}

.plottable .light-label text {
  fill: white;
}

.plottable .dark-label text {
  fill: #32313F;
}

.plottable .off-bar-label text {
  fill: #32313F;
}

.plottable .stacked-bar-label text {
  fill: #32313F;
  font-style: normal;
}

.plottable .stacked-bar-plot .off-bar-label {
  /* HACKHACK #2795: correct off-bar label logic to be implemented on StackedBar */
  visibility: hidden !important;
}

.plottable .axis-label text {
  font-size: 10px;
  font-weight: bold;
  letter-spacing: 1px;
  line-height: normal;
  text-transform: uppercase;
}

.plottable .title-label text {
  font-size: 20px;
  font-weight: bold;
}

.plottable .axis line.baseline {
  stroke: #CCC;
  stroke-width: 1px;
}

.plottable .axis line.tick-mark {
  stroke: #CCC;
  stroke-width: 1px;
}

.plottable .axis text {
  fill: #32313F;
  font-size: 12px;
  font-weight: 200;
  line-height: normal;
}

.plottable .axis .annotation-circle {
  fill: white;
  stroke-width: 1px;
  stroke: #CCC;
}

.plottable .axis .annotation-line {
  stroke: #CCC;
  stroke-width: 1px;
}

.plottable .axis .annotation-rect {
  stroke: #CCC;
  stroke-width: 1px;
  fill: white;
}

.plottable .bar-plot .baseline {
  stroke: #999;
}

.plottable .gridlines line {
  stroke: #3C3C3C; /* hackhack: gridlines should be solid; see #820 */
  opacity: 0.25;
  stroke-width: 1px;
}

.plottable .selection-box-layer .selection-area {
  fill: black;
  fill-opacity: 0.03;
  stroke: #CCC;
}
/* DragBoxLayer */
.plottable .drag-box-layer.x-resizable .drag-edge-lr {
  cursor: ew-resize;
}
.plottable .drag-box-layer.y-resizable .drag-edge-tb {
  cursor: ns-resize;
}

.plottable .drag-box-layer.x-resizable.y-resizable .drag-corner-tl {
  cursor: nwse-resize;
}
.plottable .drag-box-layer.x-resizable.y-resizable .drag-corner-tr {
  cursor: nesw-resize;
}
.plottable .drag-box-layer.x-resizable.y-resizable .drag-corner-bl {
  cursor: nesw-resize;
}
.plottable .drag-box-layer.x-resizable.y-resizable .drag-corner-br {
  cursor: nwse-resize;
}

.plottable .drag-box-layer.movable .selection-area {
  cursor: move; /* IE fallback */
  cursor: -moz-grab;
  cursor: -webkit-grab;
  cursor: grab;
}

.plottable .drag-box-layer.movable .selection-area:active {
  cursor: -moz-grabbing;
  cursor: -webkit-grabbing;
  cursor: grabbing;
}
/* /DragBoxLayer */

.plottable .guide-line-layer line.guide-line {
  stroke: #CCC;
  stroke-width: 1px;
}

.plottable .drag-line-layer.enabled.vertical line.drag-edge {
  cursor: ew-resize;
}

.plottable .drag-line-layer.enabled.horizontal line.drag-edge {
  cursor: ns-resize;
}

.plottable .legend text {
  fill: #32313F;
  font-size: 12px;
  font-weight: bold;
  line-height: normal;
}

.plottable .interpolated-color-legend rect.swatch-bounding-box {
  fill: none;
  stroke: #CCC;
  stroke-width: 1px;
  pointer-events: none;
}

.plottable .waterfall-plot line.connector {
  stroke: #CCC;
  stroke-width: 1px;
}

.plottable .pie-plot .arc.outline {
  stroke-linejoin: round;
}

`});var i0;(function(e){e.GROUP="G",e.DIV="DIV",e.SVG="SVG",e.TEXT="TEXT"})(i0||(i0={}));var est=class{constructor(t){this.uniqueId=0,this.root=t}exportAsString(){let t=this.convert(this.root);if(!t)return"";let r=this.createRootSvg();return r.appendChild(t),r.outerHTML}createUniqueId(t){return`${t}_${this.uniqueId++}`}getSize(){return this.root.getBoundingClientRect()}createRootSvg(){let t=document.createElement("svg"),r=this.getSize();return t.setAttributeNS("svg","viewBox",`0 0 ${r.width} ${r.height}`),t.setAttribute("xmlns","http://www.w3.org/2000/svg"),t}createConvertedNode(t){let r=t.nodeName.toUpperCase();if(t.nodeType==Node.ELEMENT_NODE&&(r==i0.DIV||r==i0.SVG)){let n=document.createElement(i0.GROUP),i=window.getComputedStyle(t),o=parseInt(i.left,10),a=parseInt(i.top,10);if(o||a){let s=this.createUniqueId("clip");n.setAttribute("transform",`translate(${o}, ${a})`),n.setAttribute("clip-path",`url(#${s})`);let l=parseInt(i.width,10),c=parseInt(i.height,10),u=document.createElement("rect");u.setAttribute("width",String(l)),u.setAttribute("height",String(c));let h=document.createElementNS("svg","clipPath");h.id=s,h.appendChild(u),n.appendChild(h)}return n}else return t.cloneNode()}convert(t){let r=this.createConvertedNode(t);return Array.from(t.childNodes).map(i=>this.convert(i)).filter(Boolean).forEach(i=>{r.appendChild(i)}),r.nodeName.toUpperCase()==i0.GROUP&&!r.hasChildNodes()||this.shouldOmitNode(t)?null:this.stripClass(this.transferStyle(t,r))}stripClass(t){return t.nodeType==Node.ELEMENT_NODE&&t.removeAttribute("class"),t}transferStyle(t,r){if(r.nodeType!=Node.ELEMENT_NODE)return r;let n=r,i=r.nodeName.toUpperCase(),o=window.getComputedStyle(t);return i==i0.TEXT&&Object.assign(n.style,{fontFamily:o.fontFamily,fontSize:o.fontSize,fontWeight:o.fontWeight}),i!=i0.GROUP&&(n.setAttribute("fill",o.fill),n.setAttribute("stroke",o.stroke),n.setAttribute("stroke-width",o.strokeWidth)),o.opacity!="1"&&n.setAttribute("opacity",o.opacity),r}shouldOmitNode(t){return!1}},LB=class extends est{shouldOmitNode(t){return t.nodeType==Node.ELEMENT_NODE?t.classList.contains("scatter-plot"):!1}};_s({moduleName:"vz-pan-zoom-style",styleContent:`
    .help {
      align-items: center;
      animation-delay: 1s;
      animation-duration: 1s;
      animation-name: fade-out;
      background: rgba(30, 30, 30, 0.6);
      bottom: 0;
      color: #fff;
      display: flex;
      justify-content: center;
      left: 0;
      opacity: 1;
      padding: 20px;
      pointer-events: none;
      position: absolute;
      right: 0;
      top: 0;
    }

    .help > span {
      white-space: normal;
    }

    @keyframes fade-out {
      0% {
        opacity: 1;
      }

      100% {
        opacity: 0;
      }
    }
  `});var Oqe=Wu(e0),jKt=e=>isNaN(e)?"NaN":Oqe(e),ist=[{title:"Name",evaluate:e=>e.dataset.metadata().name},{title:"Smoothed",evaluate(e,t){let{smoothingEnabled:r}=t;return jKt(r?e.datum.smoothed:e.datum.scalar)}},{title:"Value",evaluate:e=>jKt(e.datum.scalar)},{title:"Step",evaluate:e=>b4(e.datum.step)},{title:"Time",evaluate:e=>yB(e.datum.wall_time)},{title:"Relative",evaluate:e=>vB(r0(e.datum,-1,e.dataset))}],Zr=class extends Gt(mt){constructor(){super(...arguments),this.colorScale=new nst.Scales.Color().range(jb.slice(0)),this.smoothingEnabled=!1,this.smoothingWeight=.6,this.xType=null,this.xComponentsCreationMethod=null,this.yValueAccessor=t=>t.scalar,this.tooltipColumns=ist,this.yScaleType=Ff.LINEAR,this.ignoreYOutliers=!1,this.tooltipSortingMethod="default",this.tooltipPosition=Gv.BOTTOM,this._visibleSeriesCache=[],this._seriesDataCache={},this._seriesMetadataCache={},this._makeChartAsyncCallbackId=null}ready(){super.ready(),this.scopeSubtree(this.$.chartdiv,!0)}attached(){let t={capture:!0,passive:!0};this._listen(this,"mousedown",this._onMouseDown.bind(this),t),this._listen(this,"mouseup",this._onMouseUp.bind(this),t),this._listen(window,"keydown",this._onKeyDown.bind(this),t),this._listen(window,"keyup",this._onKeyUp.bind(this),t)}detached(){this._makeChartAsyncCallbackId!==null&&(this.cancelAsync(this._makeChartAsyncCallbackId),this._makeChartAsyncCallbackId=null),this._chart&&(this._chart.destroy(),this._chart=void 0),this._listeners&&(this._listeners.forEach(({node:t,eventName:r,func:n,option:i})=>{t.removeEventListener(r,n,i)}),this._listeners.clear())}_listen(t,r,n,i={}){this._listeners||(this._listeners=new Set),this._listeners.add({node:t,eventName:r,func:n,option:i}),t.addEventListener(r,n,i)}_onKeyDown(t){this.toggleClass("pankey",zf.isPanKey(t))}_onKeyUp(t){this.toggleClass("pankey",zf.isPanKey(t))}_onMouseDown(t){this.toggleClass("mousedown",!0)}_onMouseUp(t){this.toggleClass("mousedown",!1)}isDataFitToDomain(){return this._chart?this._chart.isDataFitToDomain():!0}setVisibleSeries(t){XKt.isEqual(this._visibleSeriesCache,t)||(this._visibleSeriesCache=t)}setSeriesData(t,r){this._seriesDataCache[t]=r,this._chart&&this._chart.setSeriesData(t,r)}setSeriesMetadata(t,r){this._seriesMetadataCache[t]=r,this._chart&&this._chart.setSeriesMetadata(t,r)}commitChanges(){!this._chart||this._chart.commitChanges()}resetDomain(){this._chart&&this._chart.resetDomain()}redraw(){this._chart&&this._chart.redraw()}_makeChart(){this._makeChartAsyncCallbackId!==null&&(this.cancelAsync(this._makeChartAsyncCallbackId),this._makeChartAsyncCallbackId=null),this._makeChartAsyncCallbackId=this.async(function(){this._makeChartAsyncCallbackId=null;let t=this.xComponentsCreationMethod;if(!this.xType&&!t?t=Xat:this.xType&&(t=()=>xB(this.xType)),!(!t||!this.yValueAccessor||!this.tooltipColumns)){var r=new DS(t,this.yValueAccessor,this.yScaleType,this.colorScale,this.$.tooltip,this.tooltipColumns,this.fillArea,this.defaultXRange,this.defaultYRange,this.symbolFunction,this.xAxisFormatter),n=Ht(this.$.chartdiv);r.renderTo(n),this._chart&&this._chart.destroy(),this._chart=r,this._chart.onAnchor(()=>this.fire("chart-attached"))}},350)}_reloadFromCache(){!this._chart||(this._visibleSeriesCache.forEach(t=>{this._chart.setSeriesData(t,this._seriesDataCache[t]||[])}),this._visibleSeriesCache.filter(t=>this._seriesMetadataCache[t]).forEach(t=>{this._chart.setSeriesMetadata(t,this._seriesMetadataCache[t])}),this._chart.setVisibleSeries(this._visibleSeriesCache),this._chart.commitChanges())}_smoothingChanged(){!this._chart||(this.smoothingEnabled?this._chart.smoothingUpdate(this.smoothingWeight):this._chart.smoothingDisable())}_outliersChanged(){!this._chart||this._chart.ignoreYOutliers(this.ignoreYOutliers)}_colorScaleChanged(){!this._chart||(this._chart.setColorScale(this.colorScale),this._chart.redraw())}_tooltipColumnsChanged(){!this._chart||this._chart.setTooltipColumns(this.tooltipColumns)}_tooltipSortingMethodChanged(){!this._chart||this._chart.setTooltipSortingMethod(this.tooltipSortingMethod)}getExporter(){return new LB(this.$.chartdiv)}};Zr.template=Q`
    <div id="chartdiv"></div>
    <vz-chart-tooltip
      id="tooltip"
      position="[[tooltipPosition]]"
      content-component-name="vz-line-chart-tooltip"
    ></vz-chart-tooltip>
    <style include="plottable-style"></style>
    <style include="vz-pan-zoom-style"></style>
    <style>
      :host {
        -moz-user-select: none;
        -webkit-user-select: none;
        display: flex;
        flex-direction: column;
        flex-grow: 1;
        flex-shrink: 1;
        outline: none;
        position: relative;
        white-space: nowrap;
      }
      div {
        -webkit-user-select: none;
        -moz-user-select: none;
        flex-grow: 1;
        flex-shrink: 1;
      }

      #chartdiv .main {
        contain: strict;
        cursor: crosshair;
      }

      :host(.pankey) #chartdiv :not(.drag-zooming) .main {
        cursor: -webkit-grab;
        cursor: grab;
      }

      :host(.mousedown) #chartdiv .panning .main {
        cursor: -webkit-grabbing;
        cursor: grabbing;
      }

      #chartdiv {
        contain: strict;
      }

      #chartdiv line.guide-line {
        stroke: #999;
        stroke-width: 1.5px;
      }
      #chartdiv:hover .main {
        will-change: transform;
      }

      .ghost {
        opacity: 0.2;
        stroke-width: 1px;
      }

      .plottable .axis text {
        fill: currentColor;
      }

      .plottable .gridlines line {
        stroke: var(--tb-secondary-text-color);
      }
    </style>
  `;E([A({type:Object}),w("design:type",nst.Scales.Color)],Zr.prototype,"colorScale",void 0);E([A({type:Object}),w("design:type",Function)],Zr.prototype,"symbolFunction",void 0);E([A({type:Boolean,notify:!0}),w("design:type",Boolean)],Zr.prototype,"smoothingEnabled",void 0);E([A({type:Number}),w("design:type",Number)],Zr.prototype,"smoothingWeight",void 0);E([A({type:String}),w("design:type",Object)],Zr.prototype,"xType",void 0);E([A({type:Object}),w("design:type",Object)],Zr.prototype,"xComponentsCreationMethod",void 0);E([A({type:Object}),w("design:type",Function)],Zr.prototype,"xAxisFormatter",void 0);E([A({type:Object}),w("design:type",Function)],Zr.prototype,"yValueAccessor",void 0);E([A({type:Array}),w("design:type",Array)],Zr.prototype,"tooltipColumns",void 0);E([A({type:Object}),w("design:type",Object)],Zr.prototype,"fillArea",void 0);E([A({type:Array}),w("design:type",Array)],Zr.prototype,"defaultXRange",void 0);E([A({type:Array}),w("design:type",Array)],Zr.prototype,"defaultYRange",void 0);E([A({type:String}),w("design:type",String)],Zr.prototype,"yScaleType",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Zr.prototype,"ignoreYOutliers",void 0);E([A({type:String}),w("design:type",String)],Zr.prototype,"tooltipSortingMethod",void 0);E([A({type:String}),w("design:type",String)],Zr.prototype,"tooltipPosition",void 0);E([A({type:Object}),w("design:type",Object)],Zr.prototype,"_chart",void 0);E([A({type:Array}),w("design:type",Array)],Zr.prototype,"_visibleSeriesCache",void 0);E([A({type:Object}),w("design:type",Object)],Zr.prototype,"_seriesDataCache",void 0);E([A({type:Object}),w("design:type",Object)],Zr.prototype,"_seriesMetadataCache",void 0);E([A({type:Number}),w("design:type",Object)],Zr.prototype,"_makeChartAsyncCallbackId",void 0);E([Bt("xComponentsCreationMethod","xType","yValueAccessor","yScaleType","isAttached"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Zr.prototype,"_makeChart",null);E([Bt("_chart","_visibleSeriesCache"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Zr.prototype,"_reloadFromCache",null);E([Bt("smoothingEnabled","smoothingWeight","_chart"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Zr.prototype,"_smoothingChanged",null);E([Bt("ignoreYOutliers","_chart"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Zr.prototype,"_outliersChanged",null);E([Bt("colorScale"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Zr.prototype,"_colorScaleChanged",null);E([Bt("tooltipColumns"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Zr.prototype,"_tooltipColumnsChanged",null);E([Bt("tooltipSortingMethod","_chart"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Zr.prototype,"_tooltipSortingMethodChanged",null);Zr=E([yt("vz-line-chart2")],Zr);var rst=class extends mt{};rst.template=Q`
    <div class="content">
      <table>
        <thead></thead>
        <tbody></tbody>
      </table>
    </div>
    <style>
      :host {
        pointer-events: none;
      }

      .content {
        background: rgba(0, 0, 0, 0.8);
        border-radius: 4px;
        color: #fff;
        overflow: hidden;
        pointer-events: none;
      }

      table {
        font-size: 13px;
        line-height: 1.4em;
        margin-top: 10px;
        padding: 8px;
      }

      thead {
        font-size: 14px;
      }

      tbody {
        font-size: 13px;
        line-height: 21px;
        white-space: nowrap;
      }

      td {
        padding: 0 5px;
      }

      .swatch {
        border-radius: 50%;
        display: block;
        height: 18px;
        width: 18px;
      }

      .closest .swatch {
        box-shadow: inset 0 0 0 2px #fff;
      }

      th {
        padding: 0 5px;
        text-align: left;
      }

      .distant td:not(.swatch) {
        opacity: 0.8;
      }

      .ghost {
        opacity: 0.2;
        stroke-width: 1px;
      }
    </style>
  `;rst=E([yt("vz-line-chart-tooltip")],rst);var ost=[],zqe=0,Fqe=$Kt.throttle(function e(){if(ost.length==0)return;let t=ost.shift();t&&t.active&&(t.redraw(),t._maybeRenderedInBadState=!1),window.cancelAnimationFrame(zqe),window.requestAnimationFrame(e)},100),Hn=class extends kS(Gt(mt)){constructor(){super(...arguments),this._redrawRaf=null,this.active=!1,this.logScaleActive=!1,this.colorScale={scale:fn},this._resetDomainOnNextLoad=!0,this._maybeRenderedInBadState=!1}onLoadFinish(){this.commitChanges(),this.dataToLoad.length>0&&this._resetDomainOnNextLoad&&(this._resetDomainOnNextLoad=!1,this.getChart().resetDomain()),this.redraw()}disconnectedCallback(){super.disconnectedCallback(),this._redrawRaf!==null&&cancelAnimationFrame(this._redrawRaf)}exportAsSvgString(){return this.getChart().getExporter().exportAsString()}getChart(){return this.$.chart}resetDomain(){this.getChart().resetDomain()}setSeriesData(t,r){this.getChart().setSeriesData(t,r)}setSeriesMetadata(t,r){this.getChart().setSeriesMetadata(t,r)}commitChanges(){this.getChart().commitChanges()}redraw(){this._redrawRaf!==null&&cancelAnimationFrame(this._redrawRaf),this._redrawRaf=window.requestAnimationFrame(()=>{this.active?this.getChart().redraw():this._maybeRenderedInBadState=!0})}_loadKeyChanged(){this.reset(),this._resetDomainOnNextLoad=!0}_dataSeriesChanged(){this.getChart().setVisibleSeries(this.dataSeries)}_logScaleChanged(t){let r=this.getChart();r.yScaleType=t?Ff.LOG:Ff.LINEAR,this.redraw()}_fixBadStateWhenActive(){this.active&&this._maybeRenderedInBadState&&(ost.push(this),Fqe())}_onChartAttached(){this.active||(this._maybeRenderedInBadState=!0)}};Hn.template=Q`
    <div id="chart-and-spinner-container">
      <vz-line-chart2
        id="chart"
        data-loading$="[[dataLoading]]"
        data-loaded-once$="[[dataLoadedAtLeastOnce]]"
        color-scale="[[colorScale]]"
        default-x-range="[[defaultXRange]]"
        default-y-range="[[defaultYRange]]"
        fill-area="[[fillArea]]"
        ignore-y-outliers="[[ignoreYOutliers]]"
        on-chart-attached="_onChartAttached"
        smoothing-enabled="[[smoothingEnabled]]"
        smoothing-weight="[[smoothingWeight]]"
        symbol-function="[[symbolFunction]]"
        tooltip-columns="[[tooltipColumns]]"
        tooltip-position="[[tooltipPosition]]"
        tooltip-sorting-method="[[tooltipSortingMethod]]"
        x-components-creation-method="[[xComponentsCreationMethod]]"
        x-type="[[xType]]"
        y-value-accessor="[[yValueAccessor]]"
      ></vz-line-chart2>
      <template is="dom-if" if="[[dataLoading]]">
        <div id="loading-spinner-container">
          <paper-spinner-lite active=""></paper-spinner-lite>
        </div>
      </template>
    </div>
    <style>
      :host {
        height: 100%;
        width: 100%;
        display: flex;
        flex-direction: column;
      }

      :host([_maybe-rendered-in-bad-state]) vz-line-chart {
        visibility: hidden;
      }

      #chart-and-spinner-container {
        display: flex;
        flex-grow: 1;
        position: relative;
      }

      #loading-spinner-container {
        align-items: center;
        bottom: 0;
        display: flex;
        display: flex;
        justify-content: center;
        left: 0;
        pointer-events: none;
        position: absolute;
        right: 0;
        top: 0;
      }

      vz-line-chart2 {
        -webkit-user-select: none;
        -moz-user-select: none;
      }

      vz-line-chart2[data-loading] {
        opacity: 0.3;
      }
    </style>
  `;E([A({type:Boolean,observer:"_fixBadStateWhenActive"}),w("design:type",Boolean)],Hn.prototype,"active",void 0);E([A({type:Array}),w("design:type",Array)],Hn.prototype,"dataSeries",void 0);E([A({type:Object}),w("design:type",Ae)],Hn.prototype,"requestManager",void 0);E([A({type:Boolean,observer:"_logScaleChanged"}),w("design:type",Boolean)],Hn.prototype,"logScaleActive",void 0);E([A({type:Object}),w("design:type",Object)],Hn.prototype,"xComponentsCreationMethod",void 0);E([A({type:String}),w("design:type",String)],Hn.prototype,"xType",void 0);E([A({type:Object}),w("design:type",Function)],Hn.prototype,"yValueAccessor",void 0);E([A({type:Object}),w("design:type",Object)],Hn.prototype,"fillArea",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Hn.prototype,"smoothingEnabled",void 0);E([A({type:Number}),w("design:type",Number)],Hn.prototype,"smoothingWeight",void 0);E([A({type:Array}),w("design:type",Array)],Hn.prototype,"tooltipColumns",void 0);E([A({type:String}),w("design:type",Object)],Hn.prototype,"tooltipSortingMethod",void 0);E([A({type:String}),w("design:type",String)],Hn.prototype,"tooltipPosition",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Hn.prototype,"ignoreYOutliers",void 0);E([A({type:Array}),w("design:type",Array)],Hn.prototype,"defaultXRange",void 0);E([A({type:Array}),w("design:type",Array)],Hn.prototype,"defaultYRange",void 0);E([A({type:Object}),w("design:type",Function)],Hn.prototype,"symbolFunction",void 0);E([A({type:Object}),w("design:type",Object)],Hn.prototype,"colorScale",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Hn.prototype,"_resetDomainOnNextLoad",void 0);E([A({type:Boolean,reflectToAttribute:!0}),w("design:type",Boolean)],Hn.prototype,"_maybeRenderedInBadState",void 0);E([Bt("loadKey"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Hn.prototype,"_loadKeyChanged",null);E([Bt("dataSeries.*"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Hn.prototype,"_dataSeriesChanged",null);Hn=E([yt("tf-line-chart-data-loader")],Hn);_s({moduleName:"tf-custom-scalar-card-style",styleContent:`
    :host {
      margin: 5px 10px;
      display: inline-block;
      width: 330px;
      vertical-align: text-top;
    }

    :host([_expanded]) {
      width: 100%;
    }

    :host([_expanded]) #tf-line-chart-data-loader-container {
      height: 400px;
    }

    h1 {
      font-size: 19px;
      font-weight: normal;
    }

    #tf-line-chart-data-loader-container {
      height: 200px;
      width: 100%;
    }

    #buttons {
      display: flex;
      flex-direction: row;
    }

    paper-icon-button {
      color: #2196f3;
      border-radius: 100%;
      width: 32px;
      height: 32px;
      padding: 4px;
    }

    paper-icon-button[selected] {
      background: var(--tb-ui-light-accent);
    }

    .download-links {
      display: flex;
      height: 32px;
    }

    .download-links a {
      font-size: 10px;
      align-self: center;
      margin: 2px;
    }

    .download-links paper-dropdown-menu {
      width: 100px;
      --paper-input-container-label: {
        font-size: 10px;
      }
      --paper-input-container-input: {
        font-size: 10px;
      }
    }
  `});var OS=class{constructor(t,r,n,i,o){this.run=t,this.tag=r,this.name=n,this.scalarData=i,this.symbol=o}getName(){return this.name}setData(t){this.scalarData=t}getData(){return this.scalarData}getRun(){return this.run}getTag(){return this.tag}getSymbol(){return this.symbol}};function kB(e,t){return`${t} (${e})`}var Wv=class{constructor(t){this.runBasedColorScale=t}scale(t){return this.runBasedColorScale.scale(this.parseRunName(t))}parseRunName(t){let r=t.match(/\((.*)\)$/);return r?r[1]:""}};var Jr=class extends Gt(mt){constructor(){super(...arguments),this.active=!0,this._colorScale=new Wv({scale:fn}),this._nameToDataSeries={},this._expanded=!1,this._requestData=(t,r,n)=>{let o=_e().pluginRoute("custom_scalars","/scalars");Promise.all(t.map(a=>{let s=a,l=this._tagFilter,c=Mi(o,{tag:l,run:s});return this.requestManager.request(c).then(u=>void r({item:a,data:u}))})).finally(()=>void n())},this._runToNextAvailableSymbolIndex={},this._matchesListOpened=!1,this._fillArea={lowerAccessor:t=>t.lower,higherAccessor:t=>t.upper},this._tooltipColumns=(()=>{let t=Wu(e0),r=n=>isNaN(n)?"NaN":t(n);return[{title:"Name",evaluate:n=>n.dataset.metadata().name},{title:"Value",evaluate:n=>r(n.datum.scalar)},{title:"Lower Margin",evaluate:n=>r(n.datum.lower)},{title:"Upper Margin",evaluate:n=>r(n.datum.upper)},{title:"Step",evaluate:n=>b4(n.datum.step)},{title:"Time",evaluate:n=>yB(n.datum.wall_time)},{title:"Relative",evaluate:n=>vB(r0(n.datum,-1,n.dataset))}]})(),this._missingTags=[],this._missingTagsCollapsibleOpened=!1}reload(){this.$.loader.reload()}redraw(){this.$.loader.redraw()}_toggleExpanded(t){this.set("_expanded",!this._expanded),this.redraw()}_toggleLogScale(){this.set("_logScaleActive",!this._logScaleActive)}_resetDomain(){let t=this.$.loader;t&&t.resetDomain()}_csvUrl(t,r){if(!r)return"";let n=this._downloadDataUrl(t,r);return Mi(n,{format:"csv"})}_jsonUrl(t,r){if(!r)return"";let n=this._downloadDataUrl(t,r);return Mi(n,{format:"json"})}_downloadDataUrl(t,r){let n=t[r],i=new URLSearchParams({tag:n.getTag(),run:n.getRun()});return _e().pluginRouteForSrc("custom_scalars","/download_data",i)}_createProcessDataFunction(t){return(r,n,i)=>{if(!i.regex_valid){this.set("_tagFilterInvalid",!0);return}let o=Yo.clone(this._nameToDataSeries),a=[];Yo.forEach(t,l=>{let c=!1,u=i.tag_to_events[l.value],h=i.tag_to_events[l.lower],f=i.tag_to_events[l.upper];if(Yo.isUndefined(u)&&(a.push(l.value),c=!0),Yo.isUndefined(h)&&(a.push(l.lower),c=!0),Yo.isUndefined(f)&&(a.push(l.upper),c=!0),c)return;let p=b=>b[1],d=this._findStepMismatch(l,u.map(p),h.map(p),f.map(p));if(d){this.set("_stepsMismatch",d);return}let g=b=>b[2],_=u.map((b,S)=>({wall_time:new Date(b[0]*1e3),step:p(b),scalar:g(b),lower:g(h[S]),upper:g(f[S])})),y=kB(n,l.value),x=o[y];if(x)x.setData(_);else{let b=this._createNewDataSeries(n,l.value,y,_);o[y]=b}}),this.set("_nameToDataSeries",o);let s=Yo.findIndex(this._missingTags,l=>l.run===n);if(a.length&&a.length!=3){let l={run:n,tags:a};s>=0?this.splice("_missingTags",s,1,l):this.push("_missingTags",l)}else s>=0&&this.splice("_missingTags",s,1)}}_findStepMismatch(t,r,n,i){return Yo.isEqual(n,r)&&Yo.isEqual(i,r)?null:{seriesObject:t,valueSteps:r,lowerSteps:n,upperSteps:i}}_createNewDataSeries(t,r,n,i){this._runToNextAvailableSymbolIndex[t]|=0;let o=RS[this._runToNextAvailableSymbolIndex[t]],a=new OS(t,r,n,i,o),s=RS.length;return this._runToNextAvailableSymbolIndex[t]=(this._runToNextAvailableSymbolIndex[t]+1)%s,a}_updateChart(){var t=this._nameToDataSeries;Yo.forOwn(t,r=>{this.$.loader.setSeriesData(r.getName(),r.getData())}),this.$.loader.commitChanges()}get _seriesNames(){let t=new Set(this.runs);return Object.entries(this._nameToDataSeries).filter(([r,n])=>t.has(n.run)).map(([r])=>r)}_determineColor(t,r){return t.scale(r)}_refreshDataSeries(){var t=this._tagFilter;this.set("_nameToDataSeries",{})}_createSymbolFunction(){return t=>this._nameToDataSeries[t].getSymbol().method()}_determineSymbol(t,r){return t[r].getSymbol().character}get _tagFilter(){var t=this.marginChartSeries;return Yo.flatten(t.map(i=>[i.value,i.lower,i.upper])).map(i=>"("+this._escapeRegexCharacters(i)+")").join("|")}_escapeRegexCharacters(t){return t.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}_getToggleCollapsibleIcon(t){return t?"expand-less":"expand-more"}_toggleMatchesOpen(){this.set("_matchesListOpened",!this._matchesListOpened)}get _titleDisplayString(){var t=this.title;return t||"untitled"}_separateWithCommas(t){return t.join(", ")}_toggleMissingTagsCollapsibleOpen(){this.set("_missingTagsCollapsibleOpened",!this._missingTagsCollapsibleOpened)}_matchListEntryColorUpdated(){var r;let t=this.$$("#match-list-repeat");!t||(r=this.root)==null||r.querySelectorAll(".match-list-entry").forEach(n=>{let i=t.itemForElement(n);n.style.color=this._determineColor(this._colorScale,i)})}};Jr.template=Q`
    <tf-card-heading display-name="[[_titleDisplayString]]"></tf-card-heading>
    <div id="tf-line-chart-data-loader-container">
      <tf-line-chart-data-loader
        id="loader"
        active="[[active]]"
        color-scale="[[_colorScale]]"
        data-series="[[_seriesNames]]"
        fill-area="[[_fillArea]]"
        ignore-y-outliers="[[ignoreYOutliers]]"
        load-key="[[_tagFilter]]"
        data-to-load="[[runs]]"
        request-data="[[_requestData]]"
        log-scale-active="[[_logScaleActive]]"
        load-data-callback="[[_createProcessDataFunction(marginChartSeries)]]"
        request-manager="[[requestManager]]"
        symbol-function="[[_createSymbolFunction()]]"
        tooltip-columns="[[_tooltipColumns]]"
        tooltip-sorting-method="[[tooltipSortingMethod]]"
        x-type="[[xType]]"
      >
      </tf-line-chart-data-loader>
    </div>
    <div id="buttons">
      <paper-icon-button
        selected$="[[_expanded]]"
        icon="fullscreen"
        on-tap="_toggleExpanded"
      ></paper-icon-button>
      <paper-icon-button
        selected$="[[_logScaleActive]]"
        icon="line-weight"
        on-tap="_toggleLogScale"
        title="Toggle y-axis log scale"
      ></paper-icon-button>
      <paper-icon-button
        icon="settings-overscan"
        on-tap="_resetDomain"
        title="Fit domain to data"
      ></paper-icon-button>
      <span style="flex-grow: 1"></span>
      <template is="dom-if" if="[[showDownloadLinks]]">
        <div class="download-links">
          <paper-dropdown-menu
            no-label-float="true"
            label="series to download"
            selected-item-label="{{_dataSeriesNameToDownload}}"
          >
            <paper-listbox class="dropdown-content" slot="dropdown-content">
              <template
                is="dom-repeat"
                items="[[_seriesNames]]"
                as="dataSeriesName"
              >
                <paper-item no-label-float="true"
                  >[[dataSeriesName]]</paper-item
                >
              </template>
            </paper-listbox>
          </paper-dropdown-menu>
          <a
            download="[[_dataSeriesNameToDownload]].csv"
            href="[[_csvUrl(_nameToDataSeries, _dataSeriesNameToDownload)]]"
            >CSV</a
          >
          <a
            download="[[_dataSeriesNameToDownload]].json"
            href="[[_jsonUrl(_nameToDataSeries, _dataSeriesNameToDownload)]]"
            >JSON</a
          >
        </div>
      </template>
    </div>

    <!-- here -->
    <template is="dom-if" if="[[_missingTags.length]]">
      <div class="collapsible-list-title">
        <paper-icon-button
          icon="[[_getToggleCollapsibleIcon(_missingTagsCollapsibleOpened)]]"
          on-click="_toggleMissingTagsCollapsibleOpen"
          class="toggle-collapsible-button"
        >
        </paper-icon-button>
        <span class="collapsible-title-text">
          <iron-icon icon="icons:error"></iron-icon> Missing Tags
        </span>
      </div>
      <iron-collapse opened="[[_missingTagsCollapsibleOpened]]">
        <div class="error-content">
          <iron-icon class="error-icon" icon="icons:error"></iron-icon>
          <template is="dom-repeat" items="[[_missingTags]]" as="missingEntry">
            <div class="missing-tags-for-run-container">
              Run "[[missingEntry.run]]" lacks data for tags
              <ul>
                <template
                  is="dom-repeat"
                  items="[[missingEntry.tags]]"
                  as="tag"
                >
                  <li>[[tag]]</li>
                </template>
              </ul>
            </div>
          </template>
        </div>
      </iron-collapse>
    </template>

    <template is="dom-if" if="[[_tagFilterInvalid]]">
      <div class="error-content">
        <iron-icon class="error-icon" icon="icons:error"></iron-icon>
        This regular expresion is invalid:<br />
        <span class="invalid-regex">[[_tagFilter]]</span>
      </div>
    </template>

    <template is="dom-if" if="[[_stepsMismatch]]">
      <div class="error-content">
        <iron-icon class="error-icon" icon="icons:error"></iron-icon>
        The steps for value, lower, and upper tags do not match:
        <ul>
          <li>
            <span class="tag-name">[[_stepsMismatch.seriesObject.value]]</span>:
            [[_separateWithCommas(_stepsMismatch.valueSteps)]]
          </li>
          <li>
            <span class="tag-name">[[_stepsMismatch.seriesObject.lower]]</span>:
            [[_separateWithCommas(_stepsMismatch.lowerSteps)]]
          </li>
          <li>
            <span class="tag-name">[[_stepsMismatch.seriesObject.upper]]</span>:
            [[_separateWithCommas(_stepsMismatch.upperSteps)]]
          </li>
        </ul>
      </div>
    </template>

    <div id="matches-container">
      <div class="collapsible-list-title">
        <template is="dom-if" if="[[_seriesNames.length]]">
          <paper-icon-button
            icon="[[_getToggleCollapsibleIcon(_matchesListOpened)]]"
            on-click="_toggleMatchesOpen"
            class="toggle-matches-button"
          >
          </paper-icon-button>
        </template>

        <span class="collapsible-title-text">
          Matches ([[_seriesNames.length]])
        </span>
      </div>
      <template is="dom-if" if="[[_seriesNames.length]]">
        <iron-collapse opened="[[_matchesListOpened]]">
          <div id="matches-list">
            <template
              is="dom-repeat"
              items="[[_seriesNames]]"
              as="seriesName"
              id="match-list-repeat"
              on-dom-change="_matchListEntryColorUpdated"
            >
              <div class="match-list-entry">
                <span class="match-entry-symbol">
                  [[_determineSymbol(_nameToDataSeries, seriesName)]]
                </span>
                [[seriesName]]
              </div>
            </template>
          </div>
        </iron-collapse>
      </template>
    </div>

    <style include="tf-custom-scalar-card-style"></style>
    <style>
      .error-content {
        background: #f00;
        border-radius: 5px;
        color: #fff;
        margin: 10px 0 0 0;
        padding: 10px;
      }

      .error-icon {
        display: block;
        fill: #fff;
        margin: 0 auto 5px auto;
      }

      .invalid-regex {
        font-weight: bold;
      }

      .error-content ul {
        margin: 1px 0 0 0;
        padding: 0 0 0 19px;
      }

      .tag-name {
        font-weight: bold;
      }

      .collapsible-list-title {
        margin: 10px 0 5px 0;
      }

      .collapsible-title-text {
        vertical-align: middle;
      }

      #matches-list {
        max-height: 200px;
        overflow-y: auto;
      }

      .match-list-entry {
        margin: 0 0 5px 0;
      }

      .match-entry-symbol {
        font-family: arial, sans-serif;
        display: inline-block;
        width: 10px;
      }

      .missing-tags-for-run-container {
        margin: 8px 0 0 0;
      }
    </style>
  `;E([A({type:Array}),w("design:type",Array)],Jr.prototype,"runs",void 0);E([A({type:String}),w("design:type",String)],Jr.prototype,"xType",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Jr.prototype,"active",void 0);E([A({type:String}),w("design:type",String)],Jr.prototype,"title",void 0);E([A({type:Array}),w("design:type",Array)],Jr.prototype,"marginChartSeries",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Jr.prototype,"ignoreYOutliers",void 0);E([A({type:Object}),w("design:type",Ae)],Jr.prototype,"requestManager",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Jr.prototype,"showDownloadLinks",void 0);E([A({type:Object}),w("design:type",Object)],Jr.prototype,"tagMetadata",void 0);E([A({type:String}),w("design:type",String)],Jr.prototype,"tooltipSortingMethod",void 0);E([A({type:Object}),w("design:type",Object)],Jr.prototype,"_colorScale",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Jr.prototype,"_tagFilterInvalid",void 0);E([A({type:Object}),w("design:type",Object)],Jr.prototype,"_nameToDataSeries",void 0);E([A({type:Boolean,reflectToAttribute:!0}),w("design:type",Boolean)],Jr.prototype,"_expanded",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Jr.prototype,"_logScaleActive",void 0);E([A({type:Object}),w("design:type",Function)],Jr.prototype,"_requestData",void 0);E([A({type:Object}),w("design:type",Object)],Jr.prototype,"_runToNextAvailableSymbolIndex",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Jr.prototype,"_matchesListOpened",void 0);E([A({type:Object}),w("design:type",Object)],Jr.prototype,"_fillArea",void 0);E([A({type:Array}),w("design:type",Array)],Jr.prototype,"_tooltipColumns",void 0);E([A({type:Array}),w("design:type",Array)],Jr.prototype,"_missingTags",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Jr.prototype,"_missingTagsCollapsibleOpened",void 0);E([A({type:Object}),w("design:type",Object)],Jr.prototype,"_stepsMismatch",void 0);E([Bt("_nameToDataSeries"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Jr.prototype,"_updateChart",null);E([Rt("_nameToDataSeries","runs"),w("design:type",Object),w("design:paramtypes",[])],Jr.prototype,"_seriesNames",null);E([Bt("_tagFilter"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Jr.prototype,"_refreshDataSeries",null);E([Rt("marginChartSeries"),w("design:type",String),w("design:paramtypes",[])],Jr.prototype,"_tagFilter",null);E([Rt("title"),w("design:type",String),w("design:paramtypes",[])],Jr.prototype,"_titleDisplayString",null);Jr=E([yt("tf-custom-scalar-margin-chart-card")],Jr);var o0=Ee(Oe(),1);var RB={};Ks(RB,{BaseStore:()=>bp,Canceller:()=>an,EnvironmentStore:()=>V9,ExperimentsStore:()=>rR,HttpMethodType:()=>Am,InvalidRequestOptionsError:()=>Vx,ListenKey:()=>H9,RequestCancellationError:()=>c9,RequestManager:()=>Ae,RequestNetworkError:()=>uE,RequestOptions:()=>Ux,RunsStore:()=>U9,TYPES:()=>Oxe,addParams:()=>Mi,createRouter:()=>Rgt,createSearchParam:()=>Ngt,environmentStore:()=>ib,experimentsStore:()=>nR,filterTags:()=>Fxe,getRouter:()=>_e,getRunsNamed:()=>zxe,getTags:()=>$i,runsStore:()=>wp});var En=class extends Gt(mt){constructor(){super(...arguments),this.active=!0,this._colorScale=new Wv({scale:fn}),this._nameToDataSeries={},this._expanded=!1,this._requestData=(t,r,n)=>{let o=_e().pluginRoute("custom_scalars","/scalars");Promise.all(t.map(a=>{let s=a,l=this._tagFilter,c=Mi(o,{tag:l,run:s});return this.requestManager.request(c).then(u=>void r({item:a,data:u}))})).finally(()=>void n())},this._runToNextAvailableSymbolIndex={},this._matchesListOpened=!1}reload(){this.$.loader.reload()}redraw(){this.$.loader.redraw()}_toggleExpanded(t){this.set("_expanded",!this._expanded),this.redraw()}_toggleLogScale(){this.set("_logScaleActive",!this._logScaleActive)}_resetDomain(){let t=this.$.loader;t&&t.resetDomain()}_csvUrl(t,r){if(!r)return"";let n=this._downloadDataUrl(t,r);return Mi(n,{format:"csv"})}_jsonUrl(t,r){if(!r)return"";let n=this._downloadDataUrl(t,r);return Mi(n,{format:"json"})}_downloadDataUrl(t,r){let n=t[r],i=new URLSearchParams({tag:n.getTag(),run:n.getRun()});return _e().pluginRouteForSrc("custom_scalars","/download_data",i)}_createProcessDataFunction(){return(t,r,n)=>{if(n.regex_valid){let i=o0.clone(this._nameToDataSeries);o0.forOwn(n.tag_to_events,(o,a)=>{let s=o.map(u=>({wall_time:new Date(u[0]*1e3),step:u[1],scalar:u[2]})),l=kB(r,a),c=i[l];if(c)c.setData(s);else{o0.isUndefined(this._runToNextAvailableSymbolIndex[r])&&(this._runToNextAvailableSymbolIndex[r]=0);let u=RS[this._runToNextAvailableSymbolIndex[r]],h=new OS(r,a,l,s,u);i[l]=h;let f=RS.length;this._runToNextAvailableSymbolIndex[r]=(this._runToNextAvailableSymbolIndex[r]+1)%f}}),this.set("_nameToDataSeries",i)}}}_updateChart(){var t=this._nameToDataSeries;Object.entries(t).forEach(([r,n])=>{this.$.loader.setSeriesData(r,n.getData())}),this.$.loader.commitChanges()}_computeSelectedRunsSet(t){let r={};return o0.forEach(t,n=>{r[n]=1}),r}get _seriesNames(){let t=new Set(this.runs);return Object.entries(this._nameToDataSeries).filter(([r,n])=>t.has(n.run)).map(([r])=>r)}_determineColor(t,r){return t.scale(r)}_refreshDataSeries(){var t=this._tagFilter;this.set("_nameToDataSeries",{})}_createSymbolFunction(){return t=>this._nameToDataSeries[t].getSymbol().method()}_determineSymbol(t,r){return t[r].getSymbol().character}get _tagFilter(){var t=this.tagRegexes;return t.length===1?t[0]:t.map(r=>"("+r+")").join("|")}_getToggleMatchesIcon(t){return t?"expand-less":"expand-more"}_toggleMatchesOpen(){this.set("_matchesListOpened",!this._matchesListOpened)}get _titleDisplayString(){var t=this.title;return t||"untitled"}_matchListEntryColorUpdated(t){var n;let r=this.$$("#match-list-repeat");!r||(n=this.root)==null||n.querySelectorAll(".match-list-entry").forEach(i=>{let o=r.itemForElement(i);i.style.color=this._determineColor(this._colorScale,o)})}};En.template=Q`
    <tf-card-heading display-name="[[_titleDisplayString]]"></tf-card-heading>
    <div id="tf-line-chart-data-loader-container">
      <tf-line-chart-data-loader
        id="loader"
        active="[[active]]"
        color-scale="[[_colorScale]]"
        data-series="[[_seriesNames]]"
        ignore-y-outliers="[[ignoreYOutliers]]"
        load-key="[[_tagFilter]]"
        data-to-load="[[runs]]"
        request-data="[[_requestData]]"
        log-scale-active="[[_logScaleActive]]"
        load-data-callback="[[_createProcessDataFunction()]]"
        request-manager="[[requestManager]]"
        smoothing-enabled="[[smoothingEnabled]]"
        smoothing-weight="[[smoothingWeight]]"
        symbol-function="[[_createSymbolFunction()]]"
        tooltip-sorting-method="[[tooltipSortingMethod]]"
        x-type="[[xType]]"
      >
      </tf-line-chart-data-loader>
    </div>
    <div id="buttons">
      <paper-icon-button
        selected$="[[_expanded]]"
        icon="fullscreen"
        on-tap="_toggleExpanded"
      ></paper-icon-button>
      <paper-icon-button
        selected$="[[_logScaleActive]]"
        icon="line-weight"
        on-tap="_toggleLogScale"
        title="Toggle y-axis log scale"
      ></paper-icon-button>
      <paper-icon-button
        icon="settings-overscan"
        on-tap="_resetDomain"
        title="Fit domain to data"
      ></paper-icon-button>
      <span style="flex-grow: 1"></span>
      <template is="dom-if" if="[[showDownloadLinks]]">
        <div class="download-links">
          <paper-dropdown-menu
            no-label-float="true"
            label="series to download"
            selected-item-label="{{_dataSeriesNameToDownload}}"
          >
            <paper-listbox class="dropdown-content" slot="dropdown-content">
              <template
                is="dom-repeat"
                items="[[_seriesNames]]"
                as="dataSeriesName"
              >
                <paper-item no-label-float="true"
                  >[[dataSeriesName]]</paper-item
                >
              </template>
            </paper-listbox>
          </paper-dropdown-menu>
          <a
            download="[[_dataSeriesNameToDownload]].csv"
            href="[[_csvUrl(_nameToDataSeries, _dataSeriesNameToDownload)]]"
            >CSV</a
          >
          <a
            download="[[_dataSeriesNameToDownload]].json"
            href="[[_jsonUrl(_nameToDataSeries, _dataSeriesNameToDownload)]]"
            >JSON</a
          >
        </div>
      </template>
    </div>
    <div id="matches-container">
      <div id="matches-list-title">
        <template is="dom-if" if="[[_seriesNames.length]]">
          <paper-icon-button
            icon="[[_getToggleMatchesIcon(_matchesListOpened)]]"
            on-click="_toggleMatchesOpen"
            class="toggle-matches-button"
          >
          </paper-icon-button>
        </template>

        <span class="matches-text"> Matches ([[_seriesNames.length]]) </span>
      </div>
      <template is="dom-if" if="[[_seriesNames.length]]">
        <iron-collapse opened="[[_matchesListOpened]]">
          <div id="matches-list">
            <template
              is="dom-repeat"
              items="[[_seriesNames]]"
              as="seriesName"
              id="match-list-repeat"
              on-dom-change="_matchListEntryColorUpdated"
            >
              <div class="match-list-entry">
                <span class="match-entry-symbol">
                  [[_determineSymbol(_nameToDataSeries, seriesName)]]
                </span>
                [[seriesName]]
              </div>
            </template>
          </div>
        </iron-collapse>
      </template>
    </div>

    <style include="tf-custom-scalar-card-style"></style>
    <style>
      #matches-list-title {
        margin: 10px 0 5px 0;
      }

      #matches-list {
        max-height: 200px;
        overflow-y: auto;
      }

      .match-list-entry {
        margin: 0 0 5px 0;
      }

      .match-entry-symbol {
        font-family: arial, sans-serif;
        display: inline-block;
        width: 10px;
      }

      .matches-text {
        vertical-align: middle;
      }
    </style>
  `;E([A({type:Array}),w("design:type",Array)],En.prototype,"runs",void 0);E([A({type:String}),w("design:type",String)],En.prototype,"xType",void 0);E([A({type:Boolean}),w("design:type",Boolean)],En.prototype,"active",void 0);E([A({type:String}),w("design:type",String)],En.prototype,"title",void 0);E([A({type:Array}),w("design:type",Array)],En.prototype,"tagRegexes",void 0);E([A({type:Boolean}),w("design:type",Boolean)],En.prototype,"ignoreYOutliers",void 0);E([A({type:Object}),w("design:type",Ae)],En.prototype,"requestManager",void 0);E([A({type:Boolean}),w("design:type",Boolean)],En.prototype,"showDownloadLinks",void 0);E([A({type:Boolean}),w("design:type",Boolean)],En.prototype,"smoothingEnabled",void 0);E([A({type:Number}),w("design:type",Number)],En.prototype,"smoothingWeight",void 0);E([A({type:Object}),w("design:type",Object)],En.prototype,"tagMetadata",void 0);E([A({type:String}),w("design:type",String)],En.prototype,"tooltipSortingMethod",void 0);E([A({type:Object}),w("design:type",Wv)],En.prototype,"_colorScale",void 0);E([A({type:Object}),w("design:type",Object)],En.prototype,"_nameToDataSeries",void 0);E([A({type:Boolean,reflectToAttribute:!0}),w("design:type",Boolean)],En.prototype,"_expanded",void 0);E([A({type:Boolean}),w("design:type",Boolean)],En.prototype,"_logScaleActive",void 0);E([A({type:Object}),w("design:type",Function)],En.prototype,"_requestData",void 0);E([A({type:Object}),w("design:type",Object)],En.prototype,"_runToNextAvailableSymbolIndex",void 0);E([A({type:Boolean}),w("design:type",Boolean)],En.prototype,"_matchesListOpened",void 0);E([Bt("_nameToDataSeries"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],En.prototype,"_updateChart",null);E([Rt("_nameToDataSeries","runs"),w("design:type",Object),w("design:paramtypes",[])],En.prototype,"_seriesNames",null);E([Bt("_tagFilter"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],En.prototype,"_refreshDataSeries",null);E([Rt("tagRegexes"),w("design:type",String),w("design:paramtypes",[])],En.prototype,"_tagFilter",null);E([Rt("title"),w("design:type",String),w("design:paramtypes",[])],En.prototype,"_titleDisplayString",null);En=E([yt("tf-custom-scalar-multi-line-chart-card")],En);var jo=class extends mt{constructor(){super(...arguments),this._requestManager=new Ae(50),this._canceller=new an,this._showDownloadLinks=vp("_showDownloadLinks",{defaultValue:!1,useLocalStorage:!0}).call(this),this._smoothingWeight=_E("_smoothingWeight",{defaultValue:.6}).call(this),this._ignoreYOutliers=vp("_ignoreYOutliers",{defaultValue:!0,useLocalStorage:!0}).call(this),this._xType="step",this._active=!0,this.reloadOnReady=!0,this._showDownloadLinksObserver=xp("_showDownloadLinks",{defaultValue:!1,useLocalStorage:!0}),this._smoothingWeightObserver=yE("_smoothingWeight",{defaultValue:.6}),this._ignoreYOutliersObserver=xp("_ignoreYOutliers",{defaultValue:!0,useLocalStorage:!0})}ready(){super.ready(),this.reloadOnReady&&this.reload()}reload(){let t=_e().pluginsListing(),r=this._canceller.cancellable(n=>{n.cancelled||(this.set("_dataNotFound",!n.value.custom_scalars),!this._dataNotFound&&this._retrieveLayoutAndData())});this._requestManager.request(t).then(r)}_reloadCharts(){var r;let t=(r=this.root)==null?void 0:r.querySelectorAll("tf-custom-scalar-margin-chart-card, tf-custom-scalar-multi-line-chart-card");t==null||t.forEach(n=>{n.reload()})}_retrieveLayoutAndData(){let t=_e().pluginRoute("custom_scalars","/layout"),r=this._canceller.cancellable(n=>{n.cancelled||(this.set("_layout",n.value),this._dataNotFound||this._reloadCharts())});this._requestManager.request(t).then(r)}get _smoothingEnabled(){var t=this._smoothingWeight;return t>0}get _categories(){var t=this._layout;if(!t.category)return[];let r=!1;return this._openedCategories||(r=!0,this._openedCategories={}),t.category.map(i=>(r&&!i.closed&&(this._openedCategories[i.title]=!0),{name:i.title,items:i.chart,metadata:{type:Na.PREFIX_GROUP,opened:!!this._openedCategories[i.title]}}))}_categoryOpenedToggled(t){let r=t.target;r.opened?this._openedCategories[r.category.name]=!0:delete this._openedCategories[r.category.name]}};jo.template=Q`
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <div class="settings">
          <div class="sidebar-section">
            <div class="line-item">
              <paper-checkbox checked="{{_showDownloadLinks}}"
                >Show data download links</paper-checkbox
              >
            </div>
            <div class="line-item">
              <paper-checkbox checked="{{_ignoreYOutliers}}"
                >Ignore outliers in chart scaling</paper-checkbox
              >
            </div>
            <div id="tooltip-sorting">
              <div id="tooltip-sorting-label">Tooltip sorting method:</div>
              <paper-dropdown-menu
                no-label-float=""
                selected-item-label="{{_tooltipSortingMethod}}"
              >
                <paper-listbox
                  class="dropdown-content"
                  selected="0"
                  slot="dropdown-content"
                >
                  <paper-item>default</paper-item>
                  <paper-item>descending</paper-item>
                  <paper-item>ascending</paper-item>
                  <paper-item>nearest</paper-item>
                </paper-listbox>
              </paper-dropdown-menu>
            </div>
          </div>
          <div class="sidebar-section">
            <tf-smoothing-input
              weight="{{_smoothingWeight}}"
              step="0.001"
              min="0"
              max="1"
            ></tf-smoothing-input>
          </div>
          <div class="sidebar-section">
            <tf-option-selector
              id="x-type-selector"
              name="Horizontal Axis"
              selected-id="{{_xType}}"
            >
              <paper-button id="step">step</paper-button
              ><!--
            --><paper-button id="relative">relative</paper-button
              ><!--
            --><paper-button id="wall_time">wall</paper-button>
            </tf-option-selector>
          </div>
        </div>
        <div class="sidebar-section runs-selector">
          <tf-runs-selector selected-runs="{{_selectedRuns}}">
          </tf-runs-selector>
        </div>
      </div>
      <div class="center" slot="center" id="categories-container">
        <template is="dom-if" if="[[_dataNotFound]]">
          <div class="no-data-warning">
            <h3>The custom scalars dashboard is inactive.</h3>
            <p>Probable causes:</p>
            <ol>
              <li>You haven't laid out the dashboard.</li>
              <li>You haven’t written any scalar data to your event files.</li>
            </ol>

            <p>
              To lay out the dashboard, pass a <code>Layout</code> protobuffer
              to the <code>set_layout</code> method. For example,
            </p>
            <pre>
from tensorboard import summary
from tensorboard.plugins.custom_scalar import layout_pb2
...
# This action does not have to be performed at every step, so the action is not
# taken care of by an op in the graph. We only need to specify the layout once
# (instead of per step).
layout_summary = summary_lib.custom_scalar_pb(layout_pb2.Layout(
  category=[
    layout_pb2.Category(
      title='losses',
      chart=[
          layout_pb2.Chart(
              title='losses',
              multiline=layout_pb2.MultilineChartContent(
                tag=[r'loss.*'],
              )),
          layout_pb2.Chart(
              title='baz',
              margin=layout_pb2.MarginChartContent(
                series=[
                  layout_pb2.MarginChartContent.Series(
                    value='loss/baz/scalar_summary',
                    lower='baz_lower/baz/scalar_summary',
                    upper='baz_upper/baz/scalar_summary'),
                ],
              )),
      ]),
    layout_pb2.Category(
      title='trig functions',
      chart=[
          layout_pb2.Chart(
              title='wave trig functions',
              multiline=layout_pb2.MultilineChartContent(
                tag=[r'trigFunctions/cosine', r'trigFunctions/sine'],
              )),
          # The range of tangent is different. Let's give it its own chart.
          layout_pb2.Chart(
              title='tan',
              multiline=layout_pb2.MultilineChartContent(
                tag=[r'trigFunctions/tangent'],
              )),
      ],
      # This category we care less about. Let's make it initially closed.
      closed=True),
  ]))
writer.add_summary(layout_summary)
</pre
            >
            <p>
              If you’re new to using TensorBoard, and want to find out how to
              add data and set up your event files, check out the
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
                >README</a
              >
              and perhaps the
              <a
                href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
                >TensorBoard tutorial</a
              >.
            </p>
          </div>
        </template>
        <template is="dom-if" if="[[!_dataNotFound]]">
          <template is="dom-repeat" items="[[_categories]]" as="category">
            <tf-category-paginated-view
              as="chart"
              category="[[category]]"
              disable-pagination
              initial-opened="[[category.metadata.opened]]"
            >
              <template>
                <template is="dom-if" if="[[chart.multiline]]">
                  <tf-custom-scalar-multi-line-chart-card
                    active="[[active]]"
                    request-manager="[[_requestManager]]"
                    runs="[[_selectedRuns]]"
                    title="[[chart.title]]"
                    x-type="[[_xType]]"
                    smoothing-enabled="[[_smoothingEnabled]]"
                    smoothing-weight="[[_smoothingWeight]]"
                    tooltip-sorting-method="[[tooltipSortingMethod]]"
                    ignore-y-outliers="[[_ignoreYOutliers]]"
                    show-download-links="[[_showDownloadLinks]]"
                    tag-regexes="[[chart.multiline.tag]]"
                  ></tf-custom-scalar-multi-line-chart-card>
                </template>
                <template is="dom-if" if="[[chart.margin]]">
                  <tf-custom-scalar-margin-chart-card
                    active="[[active]]"
                    request-manager="[[_requestManager]]"
                    runs="[[_selectedRuns]]"
                    title="[[chart.title]]"
                    x-type="[[_xType]]"
                    tooltip-sorting-method="[[tooltipSortingMethod]]"
                    ignore-y-outliers="[[_ignoreYOutliers]]"
                    show-download-links="[[_showDownloadLinks]]"
                    margin-chart-series="[[chart.margin.series]]"
                  ></tf-custom-scalar-margin-chart-card>
                </template>
              </template>
            </tf-category-paginated-view>
          </template>
        </template>
      </div>
    </tf-dashboard-layout>

    <style include="dashboard-style"></style>
    <style>
      #tooltip-sorting {
        align-items: center;
        display: flex;
        font-size: 14px;
        margin-top: 15px;
      }
      #tooltip-sorting paper-dropdown-menu {
        margin-left: 10px;
        --paper-input-container-focus-color: var(--tb-orange-strong);
        width: 105px;
      }
      .line-item {
        display: block;
        padding-top: 5px;
      }
      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }
    </style>
  `;E([A({type:Object}),w("design:type",Ae)],jo.prototype,"_requestManager",void 0);E([A({type:Object}),w("design:type",an)],jo.prototype,"_canceller",void 0);E([A({type:Array}),w("design:type",Array)],jo.prototype,"_selectedRuns",void 0);E([A({type:Boolean,notify:!0,observer:"_showDownloadLinksObserver"}),w("design:type",Boolean)],jo.prototype,"_showDownloadLinks",void 0);E([A({type:Number,notify:!0,observer:"_smoothingWeightObserver"}),w("design:type",Number)],jo.prototype,"_smoothingWeight",void 0);E([A({type:Boolean,observer:"_ignoreYOutliersObserver"}),w("design:type",Boolean)],jo.prototype,"_ignoreYOutliers",void 0);E([A({type:String}),w("design:type",String)],jo.prototype,"_xType",void 0);E([A({type:Object}),w("design:type",Object)],jo.prototype,"_layout",void 0);E([A({type:Boolean}),w("design:type",Boolean)],jo.prototype,"_dataNotFound",void 0);E([A({type:Object}),w("design:type",Object)],jo.prototype,"_openedCategories",void 0);E([A({type:Boolean}),w("design:type",Boolean)],jo.prototype,"_active",void 0);E([A({type:Boolean}),w("design:type",Boolean)],jo.prototype,"reloadOnReady",void 0);E([Rt("_smoothingWeight"),w("design:type",Boolean),w("design:paramtypes",[])],jo.prototype,"_smoothingEnabled",null);E([Rt("_layout"),w("design:type",Array),w("design:paramtypes",[])],jo.prototype,"_categories",null);jo=E([yt("tf-custom-scalar-dashboard")],jo);var DB=Ee(Oe(),1);var ast=Ee(Oe(),1),ba=Ee(wl(),1);var NB=class{constructor(t,r){this.run2datasets={},this.colorScale=r,this.buildChart(t)}getDataset(t){return this.run2datasets[t]===void 0&&(this.run2datasets[t]=new ba.Dataset([],{run:t})),this.run2datasets[t]}buildChart(t){this.outer&&this.outer.destroy();let r=xB(t);this.xAccessor=r.accessor,this.xScale=r.scale,this.xAxis=r.axis,this.xAxis.margin(0),this.xAxis.tickLabelPadding(3),this.yScale=new ba.Scales.Linear,this.yAxis=new ba.Axes.Numeric(this.yScale,"left");let n=Wu(mB);this.yAxis.margin(0).tickLabelPadding(5).formatter(n),this.yAxis.usesTextWidthApproximation(!0);let i=this.buildPlot(this.xAccessor,this.xScale,this.yScale);this.gridlines=new ba.Components.Gridlines(this.xScale,this.yScale),this.center=new ba.Components.Group([this.gridlines,i]),this.outer=new ba.Components.Table([[this.yAxis,this.center],[null,this.xAxis]])}buildPlot(t,r,n){let i=[0,228,1587,3085,5e3,6915,8413,9772,1e4],o=ast.range(i.length-1).map(h=>(i[h+1]-i[h])/2500),a=i.map((h,f)=>p=>p[f][1]),s=4,l=a[s],c=ast.range(a.length-1).map(h=>{let f=new ba.Plots.Area;f.x(t,r);let p=h>s?a[h]:a[h+1],d=h>s?a[h+1]:a[h];return f.y(d,n),f.y0(p),f.attr("fill",(g,_,y)=>this.colorScale.scale(y.metadata().run)),f.attr("stroke",(g,_,y)=>this.colorScale.scale(y.metadata().run)),f.attr("stroke-weight",(g,_,y)=>"0.5px"),f.attr("stroke-opacity",()=>o[h]),f.attr("fill-opacity",()=>o[h]),f}),u=new ba.Plots.Line;return u.x(t,r),u.y(l,n),u.attr("stroke",(h,f,p)=>this.colorScale.scale(p.run)),this.plots=c,new ba.Components.Group(c)}setVisibleSeries(t){this.runs=t;let r=t.map(n=>this.getDataset(n));this.plots.forEach(n=>n.datasets(r))}setSeriesData(t,r){this.getDataset(t).data(r)}renderTo(t){this.targetSVG=t,this.outer.renderTo(t)}redraw(){this.outer.redraw()}destroy(){this.outer.destroy()}},Bc=class extends Gt(mt){constructor(){super(...arguments),this.colorScale=new ba.Scales.Color().range(jb.slice()),this.xType="step",this._visibleSeriesCache=[],this._seriesDataCache={},this._makeChartAsyncCallbackId=null}setVisibleSeries(t){this._visibleSeriesCache=t,this._chart&&(this._chart.setVisibleSeries(t),this.redraw())}setSeriesData(t,r){this._seriesDataCache[t]=r,this._chart&&this._chart.setSeriesData(t,r)}redraw(){this._chart.redraw()}_makeChart(){var t=this.xType,r=this.colorScale,n=this._attached;this._makeChartAsyncCallbackId!==null&&this.cancelAsync(this._makeChartAsyncCallbackId),this._makeChartAsyncCallbackId=this.async(function(){if(this._makeChartAsyncCallbackId=null,!!n){this._chart&&this._chart.destroy();var i=new NB(t,r),o=Ht(this.$.chartdiv);i.renderTo(o),this._chart=i}},350)}_reloadFromCache(){this._chart&&(this._chart.setVisibleSeries(this._visibleSeriesCache),this._visibleSeriesCache.forEach(function(t){this._chart.setSeriesData(t,this._seriesDataCache[t]||[])}.bind(this)))}attached(){this._attached=!0}detached(){this._attached=!1}};Bc.template=Q`
    <style include="plottable-style"></style>
    <div id="chartdiv"></div>
    <style>
      :host {
        -webkit-user-select: none;
        -moz-user-select: none;
        display: flex;
        flex-direction: column;
        flex-grow: 1;
        flex-shrink: 1;
        position: relative;
      }
      #chartdiv {
        -webkit-user-select: none;
        -moz-user-select: none;
        flex-grow: 1;
        flex-shrink: 1;
      }
      .plottable .axis text {
        fill: currentColor;
      }
    </style>
  `;E([A({type:Object}),w("design:type",ba.Scales.Color)],Bc.prototype,"colorScale",void 0);E([A({type:String}),w("design:type",String)],Bc.prototype,"xType",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Bc.prototype,"_attached",void 0);E([A({type:Object}),w("design:type",NB)],Bc.prototype,"_chart",void 0);E([A({type:Array}),w("design:type",Array)],Bc.prototype,"_visibleSeriesCache",void 0);E([A({type:Object}),w("design:type",Object)],Bc.prototype,"_seriesDataCache",void 0);E([A({type:Number}),w("design:type",Object)],Bc.prototype,"_makeChartAsyncCallbackId",void 0);E([Bt("xType","colorScale","_attached"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Bc.prototype,"_makeChart",null);E([Bt("_chart"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Bc.prototype,"_reloadFromCache",null);Bc=E([yt("vz-distribution-chart")],Bc);var wa=class extends kS(Gt(mt)){constructor(){super(...arguments),this.getDataLoadName=({run:t})=>t,this.requestData=(t,r,n)=>{let o=_e().pluginRoute("distributions","/distributions");Promise.all(t.map(a=>{let s=Mi(o,{tag:a.tag,run:a.run});return this.requestManager.request(s).then(l=>void r({item:a,data:l}))})).finally(()=>void n())},this.loadDataCallback=(t,r,n)=>{let i=n.map(a=>{let[s,l,c]=a;return c.wall_time=new Date(s*1e3),c.step=l,c}),o=this.getDataLoadName(r);this.$.chart.setSeriesData(o,i),this.$.chart.setVisibleSeries([o])},this._colorScale={scale:fn},this._expanded=!1,this._canceller=new an}_reloadOnRunTagChange(){this.reload()}_updateDataToLoad(){var t=this.run,r=this.tag;this.dataToLoad=[{run:t,tag:r}]}get _runColor(){var t=this.run;return this._colorScale.scale(t)}redraw(){this.$.chart.redraw()}_toggleExpanded(t){this.set("_expanded",!this._expanded),this.redraw()}};wa.template=Q`
    <tf-card-heading
      tag="[[tag]]"
      run="[[run]]"
      display-name="[[tagMetadata.displayName]]"
      description="[[tagMetadata.description]]"
      color="[[_runColor]]"
    ></tf-card-heading>
    <!--
      The main distribution that we render. Data is set directly with
      \`setSeriesData\`, not with a bound property.
    -->
    <vz-distribution-chart
      id="chart"
      x-type="[[xType]]"
      color-scale="[[_colorScale]]"
    ></vz-distribution-chart>
    <div style="display: flex; flex-direction: row;">
      <paper-icon-button
        selected$="[[_expanded]]"
        icon="fullscreen"
        on-tap="_toggleExpanded"
      ></paper-icon-button>
    </div>
    <style>
      :host {
        display: flex;
        flex-direction: column;
        width: 330px;
        height: 235px;
        margin-right: 10px;
        margin-bottom: 15px;
      }
      :host([_expanded]) {
        width: 700px;
        height: 500px;
      }

      vz-histogram-timeseries {
        -moz-user-select: none;
        -webkit-user-select: none;
      }

      paper-icon-button {
        color: #2196f3;
        border-radius: 100%;
        width: 32px;
        height: 32px;
        padding: 4px;
      }
      paper-icon-button[selected] {
        background: var(--tb-ui-light-accent);
      }

      tf-card-heading {
        margin-bottom: 10px;
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],wa.prototype,"run",void 0);E([A({type:String}),w("design:type",String)],wa.prototype,"tag",void 0);E([A({type:Object}),w("design:type",Object)],wa.prototype,"tagMetadata",void 0);E([A({type:String}),w("design:type",String)],wa.prototype,"xType",void 0);E([A({type:Object}),w("design:type",Object)],wa.prototype,"getDataLoadName",void 0);E([A({type:Object}),w("design:type",Object)],wa.prototype,"loadDataCallback",void 0);E([A({type:Object}),w("design:type",Object)],wa.prototype,"_colorScale",void 0);E([A({type:Boolean,reflectToAttribute:!0}),w("design:type",Boolean)],wa.prototype,"_expanded",void 0);E([A({type:Object}),w("design:type",Ae)],wa.prototype,"requestManager",void 0);E([A({type:Object}),w("design:type",an)],wa.prototype,"_canceller",void 0);E([Bt("run","tag"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],wa.prototype,"_reloadOnRunTagChange",null);E([Bt("run","tag"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],wa.prototype,"_updateDataToLoad",null);E([Rt("run"),w("design:type",String),w("design:paramtypes",[])],wa.prototype,"_runColor",null);wa=E([yt("tf-distribution-loader")],wa);var Sl=class extends Gt(mt){constructor(){super(...arguments),this.reloadOnReady=!0,this._xType="step",this._requestManager=new Ae}ready(){super.ready(),this.reloadOnReady&&this.reload()}reload(){this._fetchTags().then(()=>{this._reloadDistributions()})}_fetchTags(){let t=_e().pluginRoute("distributions","/tags");return this._requestManager.request(t).then(r=>{if(DB.isEqual(r,this._runToTagInfo))return;let n=DB.mapValues(r,o=>Object.keys(o)),i=$i(n);this.set("_dataNotFound",i.length===0),this.set("_runToTag",n),this.set("_runToTagInfo",r),this.async(()=>{this.set("_categoriesDomReady",!0)})})}_reloadDistributions(){var t;(t=this.root)==null||t.querySelectorAll("tf-distribution-loader").forEach(r=>{r.reload()})}_shouldOpen(t){return t<=2}get _categories(){var t=this._runToTag,r=this._selectedRuns,n=this._tagFilter,i=this._categoriesDomReady;return Ql(t,r,n)}_tagMetadata(t,r,n){return t[r][n]}};Sl.template=Q`
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <div class="settings">
          <div class="sidebar-section">
            <tf-option-selector
              id="xTypeSelector"
              name="Horizontal axis"
              selected-id="{{_xType}}"
            >
              <paper-button id="step">step</paper-button>
              <paper-button id="relative">relative</paper-button>
              <paper-button id="wall_time">wall</paper-button>
            </tf-option-selector>
          </div>
        </div>
        <div class="sidebar-section runs-selector">
          <tf-runs-selector selected-runs="{{_selectedRuns}}">
          </tf-runs-selector>
        </div>
      </div>

      <div class="center" slot="center">
        <template is="dom-if" if="[[_dataNotFound]]">
          <div class="no-data-warning">
            <h3>No distribution data was found.</h3>
            <p>Probable causes:</p>
            <ul>
              <li>
                You haven’t written any histogram data to your event files.
                (Histograms and distributions both use the histogram summary
                operation.)
              </li>

              <li>TensorBoard can’t find your event files.</li>
            </ul>

            <p>
              If you’re new to using TensorBoard, and want to find out how to
              add data and set up your event files, check out the
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
                >README</a
              >
              and perhaps the
              <a
                href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
                >TensorBoard tutorial</a
              >.
            </p>

            <p>
              If you think TensorBoard is configured properly, please see
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"
                >the section of the README devoted to missing data problems</a
              >
              and consider filing an issue on GitHub.
            </p>
          </div>
        </template>
        <template is="dom-if" if="[[!_dataNotFound]]">
          <tf-tag-filterer tag-filter="{{_tagFilter}}"></tf-tag-filterer>
          <template is="dom-repeat" items="[[_categories]]" as="category">
            <tf-category-paginated-view
              category="[[category]]"
              initial-opened="[[_shouldOpen(index)]]"
            >
              <template>
                <tf-distribution-loader
                  active="[[active]]"
                  run="[[item.run]]"
                  tag="[[item.tag]]"
                  tag-metadata="[[_tagMetadata(_runToTagInfo, item.run, item.tag)]]"
                  x-type="[[_xType]]"
                  request-manager="[[_requestManager]]"
                ></tf-distribution-loader>
              </template>
            </tf-category-paginated-view>
          </template>
        </template>
      </div>
    </tf-dashboard-layout>

    <style include="dashboard-style"></style>
    <style>
      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }
    </style>
  `;E([A({type:Boolean}),w("design:type",Boolean)],Sl.prototype,"reloadOnReady",void 0);E([A({type:String}),w("design:type",String)],Sl.prototype,"_xType",void 0);E([A({type:Array}),w("design:type",Array)],Sl.prototype,"_selectedRuns",void 0);E([A({type:Object}),w("design:type",Object)],Sl.prototype,"_runToTag",void 0);E([A({type:Object}),w("design:type",Object)],Sl.prototype,"_runToTagInfo",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Sl.prototype,"_dataNotFound",void 0);E([A({type:String}),w("design:type",String)],Sl.prototype,"_tagFilter",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Sl.prototype,"_categoriesDomReady",void 0);E([A({type:Object}),w("design:type",Ae)],Sl.prototype,"_requestManager",void 0);E([Rt("_runToTag","_selectedRuns","_tagFilter","_categoriesDomReady"),w("design:type",Array),w("design:paramtypes",[])],Sl.prototype,"_categories",null);Sl=E([yt("tf-distribution-dashboard")],Sl);var OB={};Ks(OB,{DISAMBIGUATOR:()=>q0t,ListenKey:()=>mE,addHashListener:()=>gE,addStorageListener:()=>TW,disposeBooleanBinding:()=>t2e,disposeNumberBinding:()=>e2e,disposeObjectBinding:()=>i2e,disposeStringBinding:()=>Zbe,fireStorageChanged:()=>CW,getBoolean:()=>Jbe,getBooleanInitializer:()=>vp,getBooleanObserver:()=>xp,getNumber:()=>NW,getNumberInitializer:()=>_E,getNumberObserver:()=>yE,getObject:()=>r2e,getObjectInitializer:()=>OW,getObjectObserver:()=>zW,getString:()=>$be,getStringInitializer:()=>y_,getStringObserver:()=>v_,getUrlHashDict:()=>B0t,makeBindings:()=>vE,migrateLegacyURLScheme:()=>o2e,removeHashListenerByKey:()=>AW,removeStorageListenerByKey:()=>PW,setBoolean:()=>Qbe,setNumber:()=>DW,setObject:()=>n2e,setString:()=>Kbe});var ict=Ee(Oe(),1);var KKt="Graph dashboard actions",ZKt="Graph dashboard timings",sst;(function(e){e.FETCH_PBTXT_BYTES="FETCH_PBTXT_BYTES",e.FETCH_PBTXT_BYTES_FROM_FILESYSTEM="FETCH_PBTXT_BYTES_FROM_FILESYSTEM",e.FETCH_PBTXT_BYTES_FROM_SERVER="FETCH_PBTXT_BYTES_FROM_SERVER",e.PARSE_PBTXT_INTO_OBJECT="PARSE_PBTXT_INTO_OBJECT",e.FETCH_METADATA_PBTXT_BYTES="FETCH_METADATA_PBTXT_BYTES",e.PARSE_METADATA_PBTXT_INTO_OBJECT="PARSE_METADATA_PBTXT_INTO_OBJECT",e.NORMALIZING_NAMES="NORMALIZING_NAMES",e.BUILD_SLIM_GRAPH="BUILD_SLIM_GRAPH",e.HIERARCHY_ADD_NODES="HIERARCHY_ADD_NODES",e.HIERARCHY_DETECT_SERIES="HIERARCHY_DETECT_SERIES",e.HIERARCHY_ADD_EDGES="HIERARCHY_ADD_EDGES",e.HIERARCHY_FIND_SIMILAR_SUBGRAPHS="HIERARCHY_FIND_SIMILAR_SUBGRAPHS",e.RENDER_BUILD_HIERARCHY="RENDER_BUILD_HIERARCHY",e.RENDER_SCENE_LAYOUT="RENDER_SCENE_LAYOUT",e.RENDER_SCENE_BUILD_SCENE="RENDER_SCENE_BUILD_SCENE",e.GRAPH_LOAD_SUCCEEDED="GRAPH_LOAD_SUCCEEDED",e.GRAPH_LOAD_FAILED="GRAPH_LOAD_FAILED"})(sst||(sst={}));var lst;(function(e){e.NODE_EXPANSION_TOGGLED="NODE_EXPANSION_TOGGLED",e.NODE_SEARCH_RESULT_FOCUSED="NODE_SEARCH_RESULT_FOCUSED",e.NODE_AUXILIARY_EXTRACTION_CHANGED="NODE_AUXILIARY_EXTRACTION_CHANGED",e.GRAPH_TYPE_CHANGED="GRAPH_TYPE_CHANGED",e.TRACE_INPUT_MODE_TOGGLED="TRACE_INPUT_MODE_TOGGLED",e.NODE_COLOR_MODE_CHANGED="NODE_COLOR_MODE_CHANGED",e.UPLOADED_GRAPH_FROM_FILESYSTEM="UPLOADED_GRAPH_FROM_FILESYSTEM"})(lst||(lst={}));var jr=Kl(Kl({},sst),lst);var nle=Ee(Olt(),1),pn=Ee(Oe(),1);var Fs;(function(e){e.OP_GRAPH="op_graph",e.CONCEPTUAL_GRAPH="conceptual_graph",e.PROFILE="profile"})(Fs||(Fs={}));var ve={Node:{CONTAINER:"nodes",GROUP:"node",SHAPE:"nodeshape",COLOR_TARGET:"nodecolortarget",LABEL:"nodelabel",BUTTON_CONTAINER:"buttoncontainer",BUTTON_CIRCLE:"buttoncircle",EXPAND_BUTTON:"expandbutton",COLLAPSE_BUTTON:"collapsebutton"},Edge:{CONTAINER:"edges",GROUP:"edge",LINE:"edgeline",REFERENCE_EDGE:"referenceedge",REF_LINE:"refline",SELECTABLE:"selectableedge",SELECTED:"selectededge",STRUCTURAL:"structural"},Annotation:{OUTBOX:"out-annotations",INBOX:"in-annotations",GROUP:"annotation",NODE:"annotation-node",EDGE:"annotation-edge",CONTROL_EDGE:"annotation-control-edge",LABEL:"annotation-label",ELLIPSIS:"annotation-ellipsis"},Scene:{GROUP:"scene",CORE:"core",FUNCTION_LIBRARY:"function-library",INEXTRACT:"in-extract",OUTEXTRACT:"out-extract"},Subscene:{GROUP:"subscene"},OPNODE:"op",METANODE:"meta",SERIESNODE:"series",BRIDGENODE:"bridge",ELLIPSISNODE:"ellipsis"},J4={Edge:{LABEL:3.5},Annotation:{LABEL:5},Node:{EXPANDED_LABEL:9,SERIES_LABEL:8,OP_LABEL:6,HEALTH_PILL_STAT_LABEL:4}},ju="http://www.w3.org/2000/svg";function m0(e,t,r){let n=e.node().childNodes;for(let i=0;i<n.length;i++){let o=n[i];if(o.tagName===t){if(r instanceof Array){let a=!0;for(let s=0;s<r.length;s++)a=a&&o.classList.contains(r[s]);if(a)return Ht(o)}else if(!r||o.classList.contains(r))return Ht(o)}}return Ht(null)}function An(e,t,r,n){let i=m0(e,t,r);if(!i.empty())return i;let o=document.createElementNS("http://www.w3.org/2000/svg",t);if(r instanceof Array)for(let a=0;a<r.length;a++)o.classList.add(r[a]);else o.classList.add(r);return n?e.node().insertBefore(o,n):e.node().appendChild(o),Ht(o).datum(e.datum())}var KS=class{constructor(t){this.totalBytes=0,this.outputSize=t}addExecutionTime(t,r){this.startTime!=null?this.startTime=Math.min(this.startTime,t):this.startTime=t,this.endTime!=null?this.endTime=Math.max(this.endTime,r):this.endTime=r}addBytesAllocation(t){this.totalBytes!=null?this.totalBytes=Math.max(this.totalBytes,t):this.totalBytes=t}combine(t){t.totalBytes!=null&&(this.totalBytes+=t.totalBytes),t.getTotalMicros()!=null&&this.addExecutionTime(t.startTime,t.endTime)}getTotalMicros(){return this.startTime==null||this.endTime==null?null:this.endTime-this.startTime}},Q4=.75,tP=12,tcr=.3,ecr=[1,5e6],Xse=K_().exponent(tcr).domain(ecr).range([Q4,tP]).clamp(!0);var ZS=Ee(Oe(),1);var Kse=20;function rcr(e){return e.hasOwnProperty("timingId")}function Po(e){rcr(e)?(ZKt,e.timingId,e.eventValue,void 0):(KKt,e.actionId,e.eventLabel,void 0)}function Rd(e,t,r){let n=Date.now(),i=t(),o=Date.now()-n;return console.log(e,":",o,"ms"),r&&Po({timingId:r,eventValue:o}),i}function nP(e){return{setMessage:function(t){e.set("progress",{value:e.progress.value,msg:t})},updateProgress:function(t){e.set("progress",{value:e.progress.value+t,msg:e.progress.msg})},reportError:function(t,r){console.error(r.stack),e.set("progress",{value:e.progress.value,msg:t,error:!0})}}}function JS(e,t,r){return{setMessage:function(n){e.setMessage(r+": "+n)},updateProgress:function(n){e.updateProgress(n*t/100)},reportError:function(n,i){e.reportError(r+": "+n,i)}}}function Zse(e,t,r,n,i){n.setMessage(e);try{let o=Rd(e,r,i);return n.updateProgress(t),o}catch(o){return n.reportError("Failed "+e,o),null}}function e1(e,t,r,n,i){return new Promise((o,a)=>{n.setMessage(e),setTimeout(function(){try{let s=Rd(e,r,i);n.updateProgress(t),o(s)}catch(s){n.reportError("Failed "+e,s)}},Kse)})}function mH(e,t,r,n,i){return new Promise((o,a)=>{let s=function(l){n.reportError("Failed "+e,l),a(l)};n.setMessage(e),setTimeout(function(){try{let l=Date.now();r().then(function(c){let u=Date.now()-l;console.log(e,":",u,"ms"),n.updateProgress(t),Po({timingId:i,eventValue:u}),o(c)}).catch(s)}catch(l){s(l)}},Kse)})}function Jse(e){return e.replace(/([:.\[\],/\\\(\)])/g,"\\$1")}var iP=[{symbol:"B"},{symbol:"KB",numUnits:1024},{symbol:"MB",numUnits:1024},{symbol:"GB",numUnits:1024},{symbol:"TB",numUnits:1024},{symbol:"PB",numUnits:1024}],oP=[{symbol:"\xB5s"},{symbol:"ms",numUnits:1e3},{symbol:"s",numUnits:1e3},{symbol:"min",numUnits:60},{symbol:"hr",numUnits:60},{symbol:"days",numUnits:24}];function Nd(e,t,r=0){return r+1<t.length&&e>=t[r+1].numUnits?Nd(e/t[r+1].numUnits,t,r+1):Number(e.toPrecision(3))+" "+t[r].symbol}function gH(e){return!!(e&&(e.totalBytes>0||e.getTotalMicros()>0||e.outputSize))}function zlt(e){if(e.length<2)return e;let t=0,r=0,n=ZS.min(ZS.map(e,i=>i.length));for(;;){t++;let i=ZS.map(e,a=>a.substring(0,t));if(i.every((a,s)=>s===0?!0:a===i[s-1])){if(t>=n)return e;r=t}else break}return ZS.map(e,i=>i.substring(r))}function Qse(e){var t=+new Date-+new Date(e/1e3);return t<3e4?"just now":t<6e4?Math.floor(t/1e3)+" seconds ago":t<12e4?"a minute ago":t<36e5?Math.floor(t/6e4)+" minutes ago":Math.floor(t/36e5)==1?"an hour ago":t<864e5?Math.floor(t/36e5)+" hours ago":t<1728e5?"yesterday":Math.floor(t/864e5)+" days ago"}var ncr=document.createElement("canvas"),rP=ncr.getContext("2d");function $se(e,t){return rP&&(rP.font=`${t}px Roboto, sans-serif`),rP==null?void 0:rP.measureText(e).width}function tle(e,t,r){if(!e)return"";if($se(e,t)<=r)return e;let n=0,i=e.length;for(;n<i;){let o=n+Math.round((i-n)/2),a=e.slice(0,o)+"\u2026";$se(a,t)<=r?n=o:i=o-1}return n===0?e[0]:e.slice(0,n)+"\u2026"}var dH=class{constructor(){this.eventTypeToListeners=new Map}getListeners(t){return this.eventTypeToListeners.has(t)||this.eventTypeToListeners.set(t,[]),this.eventTypeToListeners.get(t)}addListener(t,r){var n;(n=this.getListeners(t))==null||n.push(r)}removeListener(t,r){var i;let n=(i=this.getListeners(t))==null?void 0:i.filter(o=>o!==r);this.eventTypeToListeners.set(t,n)}dispatchEvent(t,r){for(let n of this.getListeners(t))n(r)}};var Al="/",qc="__root__",Sa="__function_library__",ile="_too_large_attrs";var ole="--",g0;(function(e){e[e.FULL=0]="FULL",e[e.EMBEDDED=1]="EMBEDDED",e[e.META=2]="META",e[e.SERIES=3]="SERIES",e[e.CORE=4]="CORE",e[e.SHADOW=5]="SHADOW",e[e.BRIDGE=6]="BRIDGE",e[e.EDGE=7]="EDGE"})(g0||(g0={}));var jt;(function(e){e[e.META=0]="META",e[e.OP=1]="OP",e[e.SERIES=2]="SERIES",e[e.BRIDGE=3]="BRIDGE",e[e.ELLIPSIS=4]="ELLIPSIS"})(jt||(jt={}));var ur;(function(e){e[e.INCLUDE=0]="INCLUDE",e[e.EXCLUDE=1]="EXCLUDE",e[e.UNSPECIFIED=2]="UNSPECIFIED"})(ur||(ur={}));var is;(function(e){e[e.GROUP=0]="GROUP",e[e.UNGROUP=1]="UNGROUP"})(is||(is={}));var icr="_output_shapes",ocr="_XlaCluster",Xu=class{constructor(){this.nodes={},this.edges=[]}},_H=class{constructor(t){this.type=jt.ELLIPSIS,this.isGroupNode=!1,this.cardinality=1,this.parentNode=null,this.stats=null,this.setNumMoreNodes(t),this.include=ur.UNSPECIFIED}setNumMoreNodes(t){this.numMoreNodes=t,this.name="... "+t+" more"}},_0=class{constructor(t){this.op=t.op,this.name=t.name,this.device=t.device,this.attr=t.attr,this.inputs=ccr(t.input),this.outputShapes=acr(t.attr),this.xlaCluster=scr(t.attr),this.compatible=!1,this.type=jt.OP,this.isGroupNode=!1,this.cardinality=1,this.inEmbeddings=[],this.outEmbeddings=[],this.parentNode=null,this.include=ur.UNSPECIFIED,this.owningSeries=null}};function lP(e,t={}){return new aP(e,t)}function ale(e,t,r){pn.each(e.nodes,n=>{n.stats=null}),pn.each(t.dev_stats,n=>{r&&!r[n.device]||pn.each(n.node_stats,i=>{let o=i.node_name in e.nodes?i.node_name:sP(i.node_name);if(!(o in e.nodes))return;let a=0;i.memory&&pn.each(i.memory,l=>{l.total_bytes&&(l.total_bytes>0?a+=Number(l.total_bytes):console.log("ignoring negative memory allocation for "+o))});let s=null;i.output&&(s=pn.map(i.output,l=>pn.map(l.tensor_description.shape.dim,c=>Number(c.size)))),e.nodes[o].device=n.device,e.nodes[o].stats==null&&(e.nodes[o].stats=new KS(s)),e.nodes[o].stats.addBytesAllocation(a),i.all_end_rel_micros&&(i.all_end_rel_micros>0?e.nodes[o].stats.addExecutionTime(i.all_start_micros,i.all_start_micros+i.all_end_rel_micros):console.log("ignoring negative runtime for "+o))})})}var aP=class{constructor(t,r={}){this.name=t,this.type=jt.META,this.depth=1,this.isGroupNode=!0,this.cardinality=0,this.metagraph=e3(t,g0.META,r),this.bridgegraph=null,this.opHistogram={},this.deviceHistogram={},this.xlaClusterHistogram={},this.compatibilityHistogram={compatible:0,incompatible:0},this.templateId=null,this.parentNode=null,this.hasNonControlEdges=!1,this.include=ur.UNSPECIFIED,this.associatedFunction=""}getFirstChild(){return this.metagraph.node(this.metagraph.nodes()[0])}getRootOp(){let t=this.name.split("/"),r=this.name+"/("+t[t.length-1]+")";return this.metagraph.node(r)}leaves(){let t=[],r=[this],n;for(;r.length;){let i=r.shift();i!=null&&i.isGroupNode?(n=i.metagraph,pn.each(n.nodes(),o=>r.push(n.node(o)))):t.push(i==null?void 0:i.name)}return t}};function Hlt(e,t){return new qf(e,t)}var qf=class{constructor(t,r){this.v=t,this.w=r,this.baseEdgeList=[],this.inbound=null,this.numRegularEdges=0,this.numControlEdges=0,this.numRefEdges=0,this.totalSize=0}addBaseEdge(t,r){this.baseEdgeList.push(t),t.isControlDependency?this.numControlEdges+=1:this.numRegularEdges+=1,t.isReferenceEdge&&(this.numRefEdges+=1),this.totalSize+=qf.computeSizeOfEdge(t,r),r.maxMetaEdgeSize=Math.max(r.maxMetaEdgeSize,this.totalSize)}static computeSizeOfEdge(t,r){let n=r.node(t.v);if(!n.outputShapes)return 1;r.hasShapeInfo=!0;let i=Object.keys(n.outputShapes).map(o=>n.outputShapes[o]).map(o=>o==null?1:o.reduce((a,s)=>(s===-1&&(s=1),a*s),1));return pn.sum(i)}};function QS(e,t,r,n,i,o){return new Blt(e,t,r,n,i,o)}function t3(e,t,r,n,i){let o=typeof n!="undefined"&&typeof i!="undefined"?"["+n+"-"+i+"]":"#",a=e+o+t;return(r?r+"/":"")+a}var Blt=class{constructor(t,r,n,i,o,a){this.name=o||t3(t,r,n),this.type=jt.SERIES,this.hasLoop=!1,this.prefix=t,this.suffix=r,this.clusterId=i,this.ids=[],this.parent=n,this.isGroupNode=!0,this.cardinality=0,this.metagraph=e3(o,g0.SERIES,a),this.bridgegraph=null,this.parentNode=null,this.deviceHistogram={},this.xlaClusterHistogram={},this.compatibilityHistogram={compatible:0,incompatible:0},this.hasNonControlEdges=!1,this.include=ur.UNSPECIFIED}};function acr(e){let t=null;if(!e)return null;for(let r=0;r<e.length;r++){let{key:n,value:i}=e[r];if(n===icr){if(!i.list||!i.list.shape)return null;let o=i.list.shape.map(a=>a.unknown_rank?null:a.dim==null||a.dim.length===1&&a.dim[0].size==null?[]:a.dim.map(s=>s.size||0));return e.splice(r,1),o}}return null}function scr(e){if(!e)return null;for(let t=0;t<e.length;t++)if(e[t].key===ocr)return e[t].value.s||null;return null}var lcr=/^([^:]+):((\w+:|)\d+)$/;function ccr(e){let t=[],r=null;for(let n of e||[]){let i=n.startsWith("^");i&&(n=n.substring(1));let o=n,a="0",s=n.includes(":")&&n.match(lcr);s&&(o=s[1],a=s[2]),r!==o&&(r=o,t.push({name:o,outputTensorKey:a,isControlDependency:i}))}return t}function Flt(e,t,r,n,i,o){if(t===r.name)return;let a=i.refEdges[r.op+" "+o]===!0;e.edges.push({v:t,w:r.name,outputTensorKey:n.outputTensorKey,isControlDependency:n.isControlDependency,isReferenceEdge:a})}var sle={enableEmbedding:!0,inEmbeddingTypes:["Const"],outEmbeddingTypes:["^[a-zA-Z]+Summary$"],refEdges:{"Assign 0":!0,"AssignAdd 0":!0,"AssignSub 0":!0,"assign 0":!0,"assign_add 0":!0,"assign_sub 0":!0,"count_up_to 0":!0,"ScatterAdd 0":!0,"ScatterSub 0":!0,"ScatterUpdate 0":!0,"scatter_add 0":!0,"scatter_sub 0":!0,"scatter_update 0":!0}};function lle(e,t,r){let n={},i={},o={},a=ele(t.inEmbeddingTypes),s=ele(t.outEmbeddingTypes),l=[],c=e.node,u=new Array(c.length);return e1("Normalizing names",30,()=>{let h=new Array(c.length),f=0,p=g=>{let _=new _0(g);return a(_)?(l.push(_.name),n[_.name]=_,_):s(_)?(l.push(_.name),i[_.name]=_,pn.each(_.inputs,y=>{let x=y.name;o[x]=o[x]||[],o[x].push(_)}),_):(h[f]=_,u[f]=_.name,f++,_)};pn.each(c,p);let d=g=>{let _=Sa+g.signature.name;if(p({name:_,input:[],device:"",op:"",attr:[]}),g.signature.input_arg){let b=0,S=C=>{let P=p({name:_+Al+C.name,input:[],device:"",op:"input_arg",attr:[{key:"T",value:{type:C.type}}]});P.functionInputIndex=b,b++};g.signature.input_arg.name?S(g.signature.input_arg):pn.each(g.signature.input_arg,S)}let y=0,x={};if(g.signature.output_arg){let b=S=>{x[_+Al+S.name]=y,y++};g.signature.output_arg.name?b(g.signature.output_arg):pn.each(g.signature.output_arg,b)}pn.each(g.node_def,b=>{b.name=_+"/"+b.name,typeof b.input=="string"&&(b.input=[b.input]);let S=p(b);pn.isNumber(x[b.name])&&(S.functionOutputIndex=x[b.name]),pn.each(S.inputs,C=>{C.name=_+Al+C.name})})};return e.library&&e.library.function&&pn.each(e.library.function,d),h.splice(f),u.splice(f),h},r,jr.NORMALIZING_NAMES).then(h=>e1("Building the data structure",70,()=>{let f=ucr(u,l),p=new Xu;return pn.each(h,d=>{let g=f[d.name]||d.name;p.nodes[g]=d,d.name in o&&(d.outEmbeddings=o[d.name],pn.each(d.outEmbeddings,_=>{_.name=f[_.name]||_.name})),d.name=g}),pn.each(h,d=>{pn.each(d.inputs,(g,_)=>{let y=g.name;if(y in n){let x=n[y];d.inEmbeddings.push(x);for(let b of x.inputs)Flt(p,f[b.name]||b.name,d,b,t,_)}else if(y in i){let x=i[y];for(let b of x.inputs)Flt(p,f[b.name]||b.name,d,g,t,_)}else Flt(p,f[y]||y,d,g,t,_)})}),pn.each(n,(d,g)=>{d.name=f[d.name]||d.name}),p},r,jr.BUILD_SLIM_GRAPH))}function e3(e,t,r={}){let n=new nle.graphlib.Graph(r);return n.setGraph({name:e,rankdir:r.rankdir||"BT",type:t}),n}function ele(e){return function(t){for(let r=0;r<e.length;r++){let n=new RegExp(e[r]);if(typeof t.op=="string"&&t.op.match(n))return!0}return!1}}function sP(e){let t=e.split(Al);return e+Al+"("+t[t.length-1]+")"}function ucr(e,t){let r={},n={};e.sort();for(let i=0;i<e.length-1;++i){let o=e[i];pn.each(cP(o).slice(0,-1),a=>{n[a]=!0});for(let a=i+1;a<e.length;++a){let s=e[a];if(pn.startsWith(s,o)){if(s.length>o.length&&s.charAt(o.length)===Al){r[o]=sP(o);break}}else break}}return pn.each(t,i=>{i in n&&(r[i]=sP(i))}),r}function rle(e){let t=e.nodes().map(function(r){var n;return(n=e.neighbors(r))==null?void 0:n.length});return t.sort(),t}function cle(e,t){let r=rle(e),n=rle(t);for(let i=0;i<r.length;i++)if(r[i]!==n[i])return!1;return!0}function cP(e,t){let r=[],n=e.indexOf(Al);for(;n>=0;)r.push(e.substring(0,n)),n=e.indexOf(Al,n+1);if(t){let i=t[e];i&&r.push(i)}return r.push(e),r}function yH(e){return e===ur.EXCLUDE?"Add to main graph":"Remove from main graph"}function ule(e){return e===is.GROUP?"Ungroup this series of nodes":"Group this series of nodes"}var He=Ee(Oe(),1);var r1=Ee(Oe(),1);function hle(e,t){let r=fcr(e),n=pcr(r,t);return Object.keys(n).sort(i=>n[i].level).reduce((i,o)=>(i[o]=n[o],i),{})}function hcr(e){let t=r1.map({depth:e.depth,"|V|":e.metagraph.nodes().length,"|E|":e.metagraph.edges().length},function(n,i){return i+"="+n}).join(" "),r=r1.map(e.opHistogram,function(n,i){return i+"="+n}).join(",");return t+" [ops] "+r}function fcr(e){let t=e.getNodeMap(),r=Object.keys(t).reduce((n,i)=>{let o=t[i];if(o.type!==jt.META)return n;let a=i.split("/").length-1,s=hcr(o),l=n[s]||{nodes:[],level:a};return n[s]=l,l.nodes.push(o),l.level>a&&(l.level=a),n},{});return Object.keys(r).map(n=>[n,r[n]]).filter(([n,i])=>{let{nodes:o}=i;if(o.length>1)return!0;let a=o[0];return a.type===jt.META&&a.associatedFunction}).sort(([n,i])=>i.nodes[0].depth)}function pcr(e,t){return r1.reduce(e,function(n,i){let o=i[0],a=i[1].nodes,s=[];return a.forEach(function(l){for(let c=0;c<s.length;c++)if(!t||dcr(s[c].metanode.metagraph,l.metagraph)){l.templateId=s[c].metanode.templateId,s[c].members.push(l.name);return}l.templateId=o+"["+s.length+"]",s.push({metanode:l,members:[l.name]})}),s.forEach(function(l){n[l.metanode.templateId]={level:i[1].level,nodes:l.members}}),n},{})}function vH(e,t,r){return r1.sortBy(e,[n=>t.node(n).op,n=>t.node(n).templateId,n=>{var i;return(i=t.neighbors(n))==null?void 0:i.length},n=>{var i;return(i=t.predecessors(n))==null?void 0:i.length},n=>{var i;return(i=t.successors(n))==null?void 0:i.length},n=>n.substr(r.length)])}function dcr(e,t){if(!cle(e,t))return!1;let r=e.graph().name,n=t.graph().name,i={},o={},a=[];function s(u,h){let f=u.substr(r.length),p=h.substr(n.length);return i[f]^o[p]?(console.warn("different visit pattern","["+r+"]",f,"["+n+"]",p),!0):(i[f]||(i[f]=o[p]=!0,a.push({n1:u,n2:h})),!1)}let l=e.sources(),c=t.sources();if(l.length!==c.length)return console.log("different source length"),!1;l=vH(l,e,r),c=vH(c,t,n);for(let u=0;u<l.length;u++)if(s(l[u],c[u]))return!1;for(;a.length>0;){let u=a.pop();if(!mcr(e.node(u==null?void 0:u.n1),t.node(u==null?void 0:u.n2)))return!1;let f=e.successors(u==null?void 0:u.n1),p=t.successors(u==null?void 0:u.n2);if((f==null?void 0:f.length)!==(p==null?void 0:p.length))return console.log("# of successors mismatch",f,p),!1;f=vH(f,e,r),p=vH(p,t,n);for(let d=0;d<(f==null?void 0:f.length);d++)if(s(f==null?void 0:f[d],p==null?void 0:p[d]))return!1}return!0}function mcr(e,t){if(e.type===jt.META){let r=e,n=t;return!!r.templateId&&!!n.templateId&&r.templateId===n.templateId}else{if(e.type===jt.OP&&t.type===jt.OP)return e.op===t.op;if(e.type===jt.SERIES&&t.type===jt.SERIES){let r=e,n=t,i=r.metagraph.nodeCount();return i===n.metagraph.nodeCount()&&(i===0||r.metagraph.node(r.metagraph.nodes()[0]).op===n.metagraph.node(n.metagraph.nodes()[0]).op)}}return!1}var Dd;(function(e){e[e.TEMPLATES_UPDATED=0]="TEMPLATES_UPDATED"})(Dd||(Dd={}));var os=class extends dH{constructor(t){super(),this.hasShapeInfo=!1,this.maxMetaEdgeSize=1,this.graphOptions={},this.templates=null,this.graphOptions.compound=!0,this.graphOptions.rankdir=t.rankDirection,this.root=lP(qc,this.graphOptions),this.libraryFunctions={},this.seriesGroupMap=new Map(t.seriesMap),this.devices=null,this.xlaClusters=null,this.verifyTemplate=t.verifyTemplate,this.index={},this.index[qc]=this.root,this.orderings={}}getSeriesGroupType(t){var r;return(r=this.seriesGroupMap.get(t))!=null?r:is.GROUP}setSeriesGroupType(t,r){return this.seriesGroupMap.set(t,r)}buildSeriesGroupMapToggled(t){let r=this.getSeriesGroupType(t)===is.GROUP?is.UNGROUP:is.GROUP;return new Map([...this.seriesGroupMap,[t,r]])}getNodeMap(){return this.index}node(t){return this.index[t]}setNode(t,r){this.index[t]=r}getBridgegraph(t){let r=this.index[t];if(!r)throw Error("Could not find node in hierarchy: "+t);if(!("metagraph"in r))return null;let n=r;if(n.bridgegraph)return n.bridgegraph;let i=n.bridgegraph=e3("BRIDGEGRAPH",g0.BRIDGE,this.graphOptions);if(!r.parentNode||!("metagraph"in r.parentNode))return i;let o=r.parentNode,a=o.metagraph,s=this.getBridgegraph(o.name);return He.each([a,s],l=>{l.edges().filter(c=>c.v===t||c.w===t).forEach(c=>{let u=c.w===t,h=l.edge(c);He.each(h.baseEdgeList,f=>{let[p,d]=u?[f.w,c.v]:[f.v,c.w],g=this.getChildName(t,p),_={v:u?d:g,w:u?g:d},y=i.edge(_);y||(y=Hlt(_.v,_.w),y.inbound=u,i.setEdge(_.v,_.w,y)),y.addBaseEdge(f,this)})})}),i}getChildName(t,r){let n=this.index[r];for(;n;){if(n.parentNode&&n.parentNode.name===t)return n.name;n=n.parentNode}throw Error("Could not find immediate child for descendant: "+r)}getPredecessors(t){let r=this.index[t];if(!r)throw Error("Could not find node with name: "+t);let n=this.getOneWayEdges(r,!0);return r.isGroupNode||He.each(r.inEmbeddings,i=>{He.each(r.inputs,o=>{if(o.name===i.name){let a=new qf(i.name,t);a.addBaseEdge({isControlDependency:o.isControlDependency,outputTensorKey:o.outputTensorKey,isReferenceEdge:!1,v:i.name,w:t},this),n.regular.push(a)}})}),n}getSuccessors(t){let r=this.index[t];if(!r)throw Error("Could not find node with name: "+t);let n=this.getOneWayEdges(r,!1);return r.isGroupNode||He.each(r.outEmbeddings,i=>{He.each(i.inputs,o=>{if(o.name===t){let a=new qf(t,i.name);a.addBaseEdge({isControlDependency:o.isControlDependency,outputTensorKey:o.outputTensorKey,isReferenceEdge:!1,v:t,w:i.name},this),n.regular.push(a)}})}),n}getOneWayEdges(t,r){let n={control:[],regular:[]};if(!t.parentNode||!t.parentNode.isGroupNode)return n;let i=t.parentNode,o=i.metagraph,a=this.getBridgegraph(i.name);return fle(o,t,r,n),fle(a,t,r,n),n}getTopologicalOrdering(t){let r=this.index[t];if(!r)throw Error("Could not find node with name: "+t);if(!r.isGroupNode)return null;if(t in this.orderings)return this.orderings[t];let n={},i={},o=r.metagraph;He.each(o.edges(),c=>{!o.edge(c).numRegularEdges||(c.v in n||(n[c.v]=[]),n[c.v].push(c.w),i[c.w]=!0)});let a=He.difference(He.keys(n),He.keys(i)),s=this.orderings[t]={},l=0;for(;a.length;){let c=a.shift();s[c]=l++,He.each(n[c],u=>a.push(u)),delete n[c]}return s}getTemplateIndex(){if(!this.templates)return null;let t=$L(this.templates);if(!t.length)return null;let r=gu().domain(t).range(Ir(0,t.length));return n=>r(n)}updateTemplates(){Rd("Finding similar subgraphs",()=>{this.templates=hle(this,this.verifyTemplate),this.dispatchEvent(Dd.TEMPLATES_UPDATED)},jr.HIERARCHY_FIND_SIMILAR_SUBGRAPHS)}};function fle(e,t,r,n){let i=r?e.inEdges(t.name):e.outEdges(t.name);He.each(i,o=>{let a=e.edge(o);(a.numRegularEdges?n.regular:n.control).push(a)})}var r3={verifyTemplate:!0,seriesNodeMinSize:5,seriesMap:new Map,rankDirection:"BT",useGeneralizedSeriesPatterns:!1};function bH(e,t,r){let n=new os(t),i={};return e1("Adding nodes",30,()=>{let o={},a={};He.each(e.nodes,(s,l)=>{s.device&&(o[s.device]=!0),s.xlaCluster&&(a[s.xlaCluster]=!0)}),n.devices=He.keys(o),n.xlaClusters=He.keys(a),_cr(n,e)},r,jr.HIERARCHY_ADD_NODES).then(()=>e1("Detect series",30,()=>{t.seriesNodeMinSize>0&&mle(n.root,n,i,t.seriesNodeMinSize,t.seriesMap,t.useGeneralizedSeriesPatterns)},r,jr.HIERARCHY_DETECT_SERIES)).then(()=>e1("Adding edges",40,()=>{ycr(n,e,i)},r,jr.HIERARCHY_ADD_EDGES)).then(()=>n)}function ple(e,t){let r={},n={};He.each(e.root.leaves(),i=>{let o=e.node(i);o.device!=null&&(r[o.device]=!0),o.xlaCluster!=null&&(n[o.xlaCluster]=!0)}),e.devices=He.keys(r),e.xlaClusters=He.keys(n),He.each(e.getNodeMap(),(i,o)=>{i.isGroupNode&&(i.stats=new KS(null),i.deviceHistogram={})}),He.each(e.root.leaves(),i=>{let o=e.node(i),a=o;for(;a.parentNode!=null;){if(o.device!=null){let s=a.parentNode.deviceHistogram;s[o.device]=(s[o.device]||0)+1}if(o.xlaCluster!=null){let s=a.parentNode.xlaClusterHistogram;s[o.xlaCluster]=(s[o.xlaCluster]||0)+1}o.stats!=null&&a.parentNode.stats.combine(o.stats),a=a.parentNode}})}function dle(e){let t=[],r={};return He.each(e.root.leaves(),n=>{let i=e.node(n);if(i.type==jt.OP){let o=i;if(!o.compatible)if(o.owningSeries){if(e.getSeriesGroupType(o.owningSeries)===is.UNGROUP)t.push(o);else if(!r[o.owningSeries]){let a=e.node(o.owningSeries);a&&(r[o.owningSeries]=a,t.push(a))}}else t.push(o);He.each(o.inEmbeddings,a=>{a.compatible||t.push(a)}),He.each(o.outEmbeddings,a=>{a.compatible||t.push(a)})}}),t}function _cr(e,t){let r={};He.each(t.nodes,(n,i)=>{let o=cP(n.name),a=e.root;a.depth=Math.max(o.length,a.depth),r[n.op]||(r[n.op]=[]),r[n.op].push(n);for(let s=0;s<o.length&&(a.depth=Math.max(a.depth,o.length-s),a.cardinality+=n.cardinality,a.opHistogram[n.op]=(a.opHistogram[n.op]||0)+1,n.device!=null&&(a.deviceHistogram[n.device]=(a.deviceHistogram[n.device]||0)+1),n.xlaCluster!=null&&(a.xlaClusterHistogram[n.xlaCluster]=(a.xlaClusterHistogram[n.xlaCluster]||0)+1),n.compatible?a.compatibilityHistogram.compatible=(a.compatibilityHistogram.compatible||0)+1:a.compatibilityHistogram.incompatible=(a.compatibilityHistogram.incompatible||0)+1,He.each(n.inEmbeddings,u=>{u.compatible?a.compatibilityHistogram.compatible=(a.compatibilityHistogram.compatible||0)+1:a.compatibilityHistogram.incompatible=(a.compatibilityHistogram.incompatible||0)+1}),He.each(n.outEmbeddings,u=>{u.compatible?a.compatibilityHistogram.compatible=(a.compatibilityHistogram.compatible||0)+1:a.compatibilityHistogram.incompatible=(a.compatibilityHistogram.incompatible||0)+1}),s!==o.length-1);s++){let l=o[s],c=e.node(l);if(!c&&(c=lP(l,e.graphOptions),c.parentNode=a,e.setNode(l,c),a.metagraph.setNode(l,c),l.indexOf(Sa)===0&&a.name===qc)){let u=l.substring(Sa.length);r[u]||(r[u]=[]),e.libraryFunctions[u]={node:c,usages:r[u]},c.associatedFunction=u}a=c}e.setNode(n.name,n),n.parentNode=a,a.metagraph.setNode(n.name,n),He.each(n.inEmbeddings,function(s){e.setNode(s.name,s),s.parentNode=n}),He.each(n.outEmbeddings,function(s){e.setNode(s.name,s),s.parentNode=n})})}function ycr(e,t,r){let n=e.getNodeMap(),i=[],o=[],a=(s,l)=>{let c=0;for(;s;)l[c++]=s.name,s=s.parentNode;return c-1};He.each(t.edges,s=>{let l=a(t.nodes[s.v],i),c=a(t.nodes[s.w],o);if(l===-1||c===-1)return;for(;i[l]===o[c];)if(l--,c--,l<0||c<0)throw Error("No difference found between ancestor paths.");let u=n[i[l+1]],h=i[l],f=o[c],p=u.metagraph.edge(h,f);p||(p=Hlt(h,f),u.metagraph.setEdge(h,f,p)),!u.hasNonControlEdges&&!s.isControlDependency&&(u.hasNonControlEdges=!0),p.addBaseEdge(s,e)})}function mle(e,t,r,n,i,o){let a=e.metagraph;He.each(a.nodes(),u=>{let h=a.node(u);h.type===jt.META&&mle(h,t,r,n,i,o)});let s=vcr(a),c=(o?bcr:xcr)(s,a,t.graphOptions);He.each(c,function(u,h){let f=u.metagraph.nodes();He.each(f,p=>{let d=a.node(p);d.owningSeries||(d.owningSeries=h)}),f.length<n&&t.getSeriesGroupType(u.name)===is.GROUP&&t.setSeriesGroupType(u.name,is.UNGROUP),t.getSeriesGroupType(u.name)!==is.UNGROUP&&(t.setNode(h,u),a.setNode(h,u),He.each(f,p=>{let d=a.node(p);u.metagraph.setNode(p,d),u.parentNode=d.parentNode,u.cardinality++,d.device!=null&&(u.deviceHistogram[d.device]=(u.deviceHistogram[d.device]||0)+1),d.xlaCluster!=null&&(u.xlaClusterHistogram[d.xlaCluster]=(u.xlaClusterHistogram[d.xlaCluster]||0)+1),d.compatible?u.compatibilityHistogram.compatible=(u.compatibilityHistogram.compatible||0)+1:u.compatibilityHistogram.incompatible=(u.compatibilityHistogram.incompatible||0)+1,He.each(d.inEmbeddings,g=>{g.compatible?u.compatibilityHistogram.compatible=(u.compatibilityHistogram.compatible||0)+1:u.compatibilityHistogram.incompatible=(u.compatibilityHistogram.incompatible||0)+1}),He.each(d.outEmbeddings,g=>{g.compatible?u.compatibilityHistogram.compatible=(u.compatibilityHistogram.compatible||0)+1:u.compatibilityHistogram.incompatible=(u.compatibilityHistogram.incompatible||0)+1}),d.parentNode=u,r[p]=h,a.removeNode(p)}))})}function vcr(e){let t={};return He.reduce(e.nodes(),(r,n)=>{let i=e.node(n);if(i.type===jt.META)return r;let o=i.op;return o&&(r[o]=r[o]||[],r[o].push(i.name)),r},t)}function xcr(e,t,r){let n={};return He.each(e,function(i,o){if(i.length<=1)return;let a={};He.each(i,function(s){let l=s.charAt(s.length-1)==="*",c=s.split("/"),u=c[c.length-1],h=c.slice(0,c.length-1).join("/"),f=u.match(/^(\D*)(\d+)$/),p,d,g="";f?(p=f[1],d=f[2]):(p=l?u.substr(0,u.length-1):u,d=0,g=l?"*":"");let _=t3(p,g,h);a[_]=a[_]||[];let y=QS(p,g,h,+d,s,r);a[_].push(y)}),He.each(a,function(s,l){if(s.length<2)return;s.sort(function(u,h){return+u.clusterId-+h.clusterId});let c=[s[0]];for(let u=1;u<s.length;u++){let h=s[u];if(h.clusterId===c[c.length-1].clusterId+1){c.push(h);continue}xH(c,n,+o,t,r),c=[h]}xH(c,n,+o,t,r)})}),n}function bcr(e,t,r){let n={};return He.each(e,function(i,o){if(i.length<=1)return;let a={},s={};He.each(i,function(c){let u=c.charAt(c.length-1)==="*",h=c.split("/"),f=h[h.length-1],p=h.slice(0,h.length-1).join("/"),d=/(\d+)/g,g=[],_,y,x,b,S,C=0;for(;_=d.exec(f);)++C,y=f.slice(0,_.index),x=_[0],b=f.slice(_.index+_[0].length),S=t3(y,b,p),a[S]=a[S],a[S]||(a[S]=QS(y,b,p,+x,c,r)),a[S].ids.push(x),s[c]=s[c]||[],s[c].push([S,x]);C<1&&(y=u?f.substr(0,f.length-1):f,x=0,b=u?"*":"",S=t3(y,b,p),a[S]=a[S],a[S]||(a[S]=QS(y,b,p,+x,c,r)),a[S].ids.push(x),s[c]=s[c]||[],s[c].push([S,x]))});var l={};He.each(s,function(c,u){c.sort(function(y,x){return a[x[0]].ids.length-a[y[0]].ids.length});var h=c[0][0],f=c[0][1];l[h]=l[h]||[];let p=u.split("/"),d=p[p.length-1],g=p.slice(0,p.length-1).join("/");var _=QS(a[h].prefix,a[h].suffix,g,+f,u,r);l[h].push(_)}),He.each(l,function(c,u){if(c.length<2)return;c.sort(function(f,p){return+f.clusterId-+p.clusterId});let h=[c[0]];for(let f=1;f<c.length;f++){let p=c[f];if(p.clusterId===h[h.length-1].clusterId+1){h.push(p);continue}xH(h,n,+o,t,r),h=[p]}xH(h,n,+o,t,r)})}),n}function xH(e,t,r,n,i){if(e.length>1){let o=t3(e[0].prefix,e[0].suffix,e[0].parent,e[0].clusterId,e[e.length-1].clusterId),a=QS(e[0].prefix,e[0].suffix,e[0].parent,r,o,i);He.each(e,function(s){a.ids.push(s.clusterId),a.metagraph.setNode(s.name,n.node(s.name))}),t[o]=a}}var me=Ee(Oe(),1);var y0={DEFAULT_FILL:"#ffffff",DEFAULT_STROKE:"#b2b2b2",COMPATIBLE:"#0f9d58",INCOMPATIBLE:"#db4437"},Ku={DEFAULT_FILL:"#d9d9d9",DEFAULT_STROKE:"#a6a6a6",SATURATION:.6,LIGHTNESS:.85,EXPANDED_COLOR:"#f0f0f0",HUES:[220,100,180,40,20,340,260,300,140,60],STRUCTURE_PALETTE(e,t){let r=Ku.HUES,n=r.length,i=r[e%n],o=Math.sin(i*Math.PI/360),a=t?30:90-60*o,s=t?95:80;return Vm(i,.01*a,.01*s).toString()},DEVICE_PALETTE(e){return Ku.STRUCTURE_PALETTE(e)},XLA_CLUSTER_PALETTE(e){return Ku.STRUCTURE_PALETTE(e)},UNKNOWN:"#eee",GRADIENT_OUTLINE:"#888"},Vlt={DEFAULT_FILL:"white",DEFAULT_STROKE:"#b2b2b2"},Xo={minNodeCountForExtraction:15,minDegreeForExtraction:5,maxControlDegree:4,maxBridgePathDegree:4,outExtractTypes:["NoOp"],inExtractTypes:[],detachAllEdgesForHighDegree:!0,extractIsolatedNodesWithAnnotationsOnOneSide:!0,enableBridgegraph:!0,minMaxColors:["#fff5f0","#fb6a4a"],maxAnnotations:5},wcr=new RegExp("^(?:"+Sa+")?(\\w+)_[a-z0-9]{8}(?:_\\d+)?$"),lo=class{constructor(t,r,n){this.hierarchy=t,this.displayingStats=r,this.autoExtractNodes=n,this.index={},this.renderedOpNames=[],this.computeScales(),this.hasSubhierarchy={},this.root=new SH(t.root,t.graphOptions),this.index[t.root.name]=this.root,this.renderedOpNames.push(t.root.name),this.buildSubhierarchy(t.root.name),this.root.expanded=!0,this.traceInputs=!1}computeScales(){this.deviceColorMap=gu().domain(this.hierarchy.devices).range(me.map(Ir(this.hierarchy.devices.length),Ku.DEVICE_PALETTE)),this.xlaClusterColorMap=gu().domain(this.hierarchy.xlaClusters).range(me.map(Ir(this.hierarchy.xlaClusters.length),Ku.XLA_CLUSTER_PALETTE));let t=this.hierarchy.root.metagraph,r=lu(t.nodes(),(i,o)=>{let a=t.node(i);if(a.stats!=null)return a.stats.totalBytes});this.memoryUsageScale=On().domain([0,r]).range(Xo.minMaxColors);let n=lu(t.nodes(),(i,o)=>{let a=t.node(i);if(a.stats!=null)return a.stats.getTotalMicros()});this.computeTimeScale=On().domain([0,n]).range(Xo.minMaxColors),this.edgeWidthSizedBasedScale=this.hierarchy.hasShapeInfo?Xse:On().domain([1,this.hierarchy.maxMetaEdgeSize]).range([Q4,tP])}getRenderNodeByName(t){return this.index[t]}getNodeByName(t){return this.hierarchy.node(t)}colorHistogram(t,r){if(Object.keys(t).length>0){let n=me.sum(Object.keys(t).map(i=>t[i]));return Object.keys(t).map(i=>({color:r(i),proportion:t[i]/n}))}return null}getOrCreateRenderNodeByName(t){if(!t)return null;if(t in this.index)return this.index[t];let r=this.hierarchy.node(t);if(!r)return null;let n=r.isGroupNode?new SH(r,this.hierarchy.graphOptions):new Gf(r);this.index[t]=n,this.renderedOpNames.push(t),r.stats&&(n.memoryColor=this.memoryUsageScale(r.stats.totalBytes),n.computeTimeColor=this.computeTimeScale(r.stats.getTotalMicros())),n.isFadedOut=this.displayingStats&&!gH(r.stats);var i=null,o=null,a=null;if(r.isGroupNode){i=r.deviceHistogram,o=r.xlaClusterHistogram;let s=r.compatibilityHistogram.compatible,l=r.compatibilityHistogram.incompatible;(s!=0||l!=0)&&(a=s/(s+l))}else{let s=n.node.device;s&&(i={[s]:1});let l=n.node.xlaCluster;l&&(o={[l]:1}),n.node.type===jt.OP&&(a=n.node.compatible?1:0)}return i&&(n.deviceColors=this.colorHistogram(i,this.deviceColorMap)),o&&(n.xlaClusterColors=this.colorHistogram(o,this.xlaClusterColorMap)),a!=null&&(n.compatibilityColors=[{color:y0.COMPATIBLE,proportion:a},{color:y0.INCOMPATIBLE,proportion:1-a}]),this.index[t]}getNearestVisibleAncestor(t){let r=cP(t),n=0,i=null,o=t;for(;n<r.length&&(o=r[n],i=this.getRenderNodeByName(o),!!i.expanded);n++);if(n==r.length-2){let a=r[n+1];if(i!=null&&i.inAnnotations.nodeNames[a]||i!=null&&i.outAnnotations.nodeNames[a])return a}return o}setDepth(t){yle(this.root,+t)}isNodeAuxiliary(t){let r=this.getRenderNodeByName(t.node.parentNode.name),n=me.find(r.isolatedInExtract,i=>i.node.name===t.node.name);return n?!0:(n=me.find(r.isolatedOutExtract,i=>i.node.name===t.node.name),!!n)}getNamesOfRenderedOps(){return this.renderedOpNames}cloneAndAddFunctionOpNode(t,r,n,i){let o=n.name.replace(r,i),a=t.metagraph.node(o);if(a)return a;a=new _0({name:o,input:[],device:n.device,op:n.op,attr:me.cloneDeep(n.attr)}),a.cardinality=n.cardinality,a.include=n.include,a.outputShapes=me.cloneDeep(n.outputShapes),a.xlaCluster=n.xlaCluster,a.functionInputIndex=n.functionInputIndex,a.functionOutputIndex=n.functionOutputIndex,a.inputs=n.inputs.map(l=>{let c=me.clone(l);return c.name=l.name.replace(r,i),c}),a.parentNode=t,t.metagraph.setNode(a.name,a),this.hierarchy.setNode(a.name,a);let s=l=>this.cloneAndAddFunctionOpNode(t,r,l,i);return a.inEmbeddings=n.inEmbeddings.map(s),a.outEmbeddings=n.outEmbeddings.map(s),a}cloneFunctionLibraryMetanode(t,r,n,i,o){let a={},s=this.cloneFunctionLibraryMetanodeHelper(t,r,n,i,o,a);return me.isEmpty(a)||this.patchEdgesFromFunctionOutputs(r,a),s}cloneFunctionLibraryMetanodeHelper(t,r,n,i,o,a){let s=lP(n.name.replace(i,o));return s.depth=n.depth,s.cardinality=n.cardinality,s.templateId=n.templateId,s.opHistogram=me.clone(n.opHistogram),s.deviceHistogram=me.clone(n.deviceHistogram),s.xlaClusterHistogram=me.clone(n.xlaClusterHistogram),s.hasNonControlEdges=n.hasNonControlEdges,s.include=n.include,s.nodeAttributes=me.clone(n.nodeAttributes),s.associatedFunction=n.associatedFunction,me.each(n.metagraph.nodes(),l=>{let c=n.metagraph.node(l);switch(c.type){case jt.META:let u=this.cloneFunctionLibraryMetanodeHelper(t,r,c,i,o,a);u.parentNode=s,s.metagraph.setNode(u.name,u),this.hierarchy.setNode(u.name,u);break;case jt.OP:let h=this.cloneAndAddFunctionOpNode(s,i,c,o);me.isNumber(h.functionInputIndex)&&this.patchEdgesIntoFunctionInputs(r,h),me.isNumber(h.functionOutputIndex)&&(a[h.functionOutputIndex]=h);break;default:console.warn(c.name+" is oddly neither a metanode nor an opnode.")}}),this.cloneLibraryMetanodeEdges(n,s,i,o),s}cloneLibraryMetanodeEdges(t,r,n,i){me.each(t.metagraph.edges(),o=>{let a=t.metagraph.edge(o),s=a.v.replace(n,i),l=a.w.replace(n,i),c=new qf(s,l);c.inbound=a.inbound,c.numRegularEdges=a.numRegularEdges,c.numControlEdges=a.numControlEdges,c.numRefEdges=a.numRefEdges,c.totalSize=a.totalSize,a.baseEdgeList&&(c.baseEdgeList=a.baseEdgeList.map(u=>{let h=me.clone(u);return h.v=u.v.replace(n,i),h.w=u.w.replace(n,i),h})),r.metagraph.node(l)?r.metagraph.setEdge(s,l,c):r.metagraph.setEdge(l,s,c)})}patchEdgesIntoFunctionInputs(t,r){let n=Math.min(r.functionInputIndex,t.inputs.length-1),i=me.clone(t.inputs[n]);for(;i.isControlDependency;)n++,i=t.inputs[n];r.inputs.push(i);let o=this.hierarchy.getPredecessors(t.name),a,s=0;me.each(o.regular,l=>{if(s+=l.numRegularEdges,s>n)return a=l,!1}),me.each(a.baseEdgeList,l=>{l.w===t.name&&(l.w=r.name),l.v===t.name&&(l.v=r.name)})}patchEdgesFromFunctionOutputs(t,r){let n=this.hierarchy.getSuccessors(t.name);me.each(n.regular,i=>{me.each(i.baseEdgeList,o=>{let a=this.hierarchy.node(o.w);me.each(a.inputs,s=>{if(s.name===t.name){let l=r[s.outputTensorKey];s.name=l.name,s.outputTensorKey=o.outputTensorKey}})}),me.each(i.baseEdgeList,o=>{o.v=r[o.outputTensorKey].name,o.outputTensorKey="0"})})}buildSubhierarchy(t){if(t in this.hasSubhierarchy)return;this.hasSubhierarchy[t]=!0;let r=this.index[t];if(r.node.type!==jt.META&&r.node.type!==jt.SERIES)return;let n=r,i=n.node.metagraph,o=n.coreGraph,a=[],s=[];me.isEmpty(this.hierarchy.libraryFunctions)||(me.each(i.nodes(),d=>{let g=i.node(d),_=this.hierarchy.libraryFunctions[g.op];if(!_||d.indexOf(Sa)===0)return;let y=this.cloneFunctionLibraryMetanode(i,g,_.node,_.node.name,g.name);a.push(g),s.push(y)}),me.each(s,(d,g)=>{let _=a[g];d.parentNode=_.parentNode,i.setNode(_.name,d),this.hierarchy.setNode(_.name,d)})),me.each(i.nodes(),d=>{let g=this.getOrCreateRenderNodeByName(d),_=g.node;o.setNode(d,g),_.isGroupNode||(me.each(_.inEmbeddings,y=>{let x=new Od(null),b=new Gf(y);gle(g,y,b,x,gi.CONSTANT),this.index[y.name]=b}),me.each(_.outEmbeddings,y=>{let x=new Od(null),b=new Gf(y);_le(g,y,b,x,gi.SUMMARY),this.index[y.name]=b}))}),me.each(i.edges(),d=>{let g=i.edge(d),_=new Od(g);_.isFadedOut=this.index[d.v].isFadedOut||this.index[d.w].isFadedOut,o.setEdge(d.v,d.w,_)}),n.node.type===jt.META&&Pcr(n,this.autoExtractNodes),me.isEmpty(this.hierarchy.libraryFunctions)||this.buildSubhierarchiesForNeededFunctions(i),t===qc&&me.forOwn(this.hierarchy.libraryFunctions,(d,g)=>{let _=d.node,y=this.getOrCreateRenderNodeByName(_.name);n.libraryFunctionsExtract.push(y),y.node.include=ur.EXCLUDE,o.removeNode(_.name)});let l=n.node.parentNode;if(!l)return;let c=this.index[l.name],u=(d,...g)=>g.concat([d?"IN":"OUT"]).join("~~"),h=this.hierarchy.getBridgegraph(t),f={in:{},out:{},control:{}};me.each(h.edges(),d=>{let g=!!i.node(d.w),_=g?d.v:d.w;h.edge(d).numRegularEdges?g?f.out[_]=(f.out[_]||0)+1:f.in[_]=(f.in[_]||0)+1:f.control[_]=(f.control[_]||0)+1});let p=this.hierarchy.getNodeMap();me.each(h.edges(),d=>{let g=h.edge(d),_=!!i.node(d.w),[y,x]=_?[d.w,d.v]:[d.v,d.w],b=this.index[y],S=this.index[x],C=S?S.node:p[x],P=!g.numRegularEdges&&f.control[x]>Xo.maxControlDegree,[,k]=_?[r.inAnnotations,b.inAnnotations]:[r.outAnnotations,b.outAnnotations],D=(_?f.out:f.in)[x]>Xo.maxBridgePathDegree,B=null,I=!1;if(Xo.enableBridgegraph&&!D&&!P&&b.isInCore()){let W=Z=>{let rt=_?{v:Z,w:t}:{v:t,w:Z};return c.coreGraph.edge(rt)};B=W(x),B||(B=W(u(_,x,l.name))),I=!!B}let L=!1;if(B&&!g.numRegularEdges){let W=B,Z=c.node;for(;W.adjoiningMetaedge;)W=W.adjoiningMetaedge,Z=Z.parentNode;let rt=this.hierarchy.getTopologicalOrdering(Z.name),ot=W.metaedge;L=rt[ot.v]>rt[ot.w]}if(I=I&&!L,!I){k.push(new i3(C,S,new Od(g),gi.SHORTCUT,_));return}let R=u(_,t),F=u(_,x,t),z=o.node(F);if(!z){let W=o.node(R);if(!W){let rt={name:R,type:jt.BRIDGE,isGroupNode:!1,cardinality:0,parentNode:null,stats:null,include:ur.UNSPECIFIED,inbound:_,nodeAttributes:{}};W=new Gf(rt),this.index[R]=W,o.setNode(R,W)}let Z={name:F,type:jt.BRIDGE,isGroupNode:!1,cardinality:1,parentNode:null,stats:null,include:ur.UNSPECIFIED,inbound:_,nodeAttributes:{}};z=new Gf(Z),this.index[F]=z,o.setNode(F,z),o.setParent(F,R),W.node.cardinality++}let U=new Od(g);U.adjoiningMetaedge=B,_?o.setEdge(F,y,U):o.setEdge(y,F,U)}),me.each([!0,!1],d=>{let g=u(d,t),_=o.node(g);!_||me.each(o.nodes(),y=>{var k,O;if(o.node(y).node.type===jt.BRIDGE||!(d?!((k=o.predecessors(y))!=null&&k.length):!((O=o.successors(y))!=null&&O.length)))return;let S=u(d,t,"STRUCTURAL_TARGET"),C=o.node(S);if(!C){let D={name:S,type:jt.BRIDGE,isGroupNode:!1,cardinality:1,parentNode:null,stats:null,include:ur.UNSPECIFIED,inbound:d,nodeAttributes:{}};C=new Gf(D),C.structural=!0,this.index[S]=C,o.setNode(S,C),_.node.cardinality++,o.setParent(S,g)}let P=new Od(null);P.structural=!0,P.weight--,d?o.setEdge(S,y,P):o.setEdge(y,S,P)})})}buildSubhierarchiesForNeededFunctions(t){me.each(t.edges(),r=>{let n=t.edge(r),i=new Od(n);me.forEach(i.metaedge.baseEdgeList,o=>{let a=o.v.split(Al);for(let s=a.length;s>=0;s--){let l=a.slice(0,s),c=this.hierarchy.node(l.join(Al));if(c){if(c.type===jt.OP&&this.hierarchy.libraryFunctions[c.op])for(let u=1;u<l.length;u++){let h=l.slice(0,u).join(Al);!h||this.buildSubhierarchy(h)}break}}})})}},i3=class{constructor(t,r,n,i,o){this.node=t,this.renderNodeInfo=r,this.renderMetaedgeInfo=n,this.annotationType=i,this.dx=0,this.dy=0,this.width=0,this.height=0,n&&n.metaedge&&(this.v=n.metaedge.v,this.w=n.metaedge.w),this.isIn=o,this.points=[]}},gi;(function(e){e[e.SHORTCUT=0]="SHORTCUT",e[e.CONSTANT=1]="CONSTANT",e[e.SUMMARY=2]="SUMMARY",e[e.ELLIPSIS=3]="ELLIPSIS"})(gi||(gi={}));var wH=class{constructor(){this.list=[],this.nodeNames={}}push(t){if(t.node.name in this.nodeNames)return;if(this.nodeNames[t.node.name]=!0,this.list.length<Xo.maxAnnotations){this.list.push(t);return}let r=this.list[this.list.length-1];if(r.annotationType===gi.ELLIPSIS){let i=r.node;i.setNumMoreNodes(++i.numMoreNodes);return}let n=new _H(1);this.list.push(new i3(n,new Gf(n),null,gi.ELLIPSIS,t.isIn))}},Gf=class{constructor(t){if(this.node=t,this.expanded=!1,this.inAnnotations=new wH,this.outAnnotations=new wH,this.x=0,this.y=0,this.width=0,this.height=0,this.inboxWidth=0,this.outboxWidth=0,this.excluded=!1,this.structural=!1,this.labelOffset=0,this.radius=0,this.labelHeight=0,this.paddingTop=0,this.paddingLeft=0,this.paddingRight=0,this.paddingBottom=0,this.isInExtract=!1,this.isOutExtract=!1,this.coreBox={width:0,height:0},this.isFadedOut=!1,this.displayName=t.name.substring(t.name.lastIndexOf(Al)+1),t.type===jt.META&&t.associatedFunction){let r=this.displayName.match(wcr);r?this.displayName=r[1]:me.startsWith(this.displayName,Sa)&&(this.displayName=this.displayName.substring(Sa.length))}}isInCore(){return!this.isInExtract&&!this.isOutExtract&&!this.isLibraryFunction}},Od=class{constructor(t){this.metaedge=t,this.adjoiningMetaedge=null,this.structural=!1,this.weight=1,this.isFadedOut=!1}};function gle(e,t,r,n,i){let o=new i3(t,r,n,i,!0);e.inAnnotations.push(o)}function _le(e,t,r,n,i){let o=new i3(t,r,n,i,!1);e.outAnnotations.push(o)}function Scr(e,t){me.each(e.nodes(),r=>{let n=e.node(r);if(n.expanded=t>1,t>0)switch(n.node.type){case jt.META:case jt.SERIES:yle(n,t-1);break}})}var SH=class extends Gf{constructor(t,r){super(t);let i=t.metagraph.graph();this.coreGraph=e3(i.name,g0.CORE,r),this.inExtractBox={width:0,height:0},this.outExtractBox={width:0,height:0},this.libraryFunctionsBox={width:0,height:0},this.isolatedInExtract=[],this.isolatedOutExtract=[],this.libraryFunctionsExtract=[]}};function yle(e,t){e.coreGraph&&Scr(e.coreGraph,t)}function uP(e,t,r){let n=e.node(t),i=e.node(r),o=e.edge(t,r);(n.node.include===ur.INCLUDE||i.node.include===ur.INCLUDE)&&n.node.include!==ur.EXCLUDE&&i.node.include!==ur.EXCLUDE||(_le(n,i.node,i,o,gi.SHORTCUT),gle(i,n.node,n,o,gi.SHORTCUT),e.removeEdge(t,r))}function Ult(e,t,r){var o;let n=e.coreGraph,i=n.node(t);i.isOutExtract=!0,me.each(n.predecessors(t),(a,s)=>{uP(n,a,t)}),(Xo.detachAllEdgesForHighDegree||r)&&me.each(n.successors(t),(a,s)=>{uP(n,t,a)}),((o=n.neighbors(t))==null?void 0:o.length)===0&&(i.node.include=ur.EXCLUDE,e.isolatedOutExtract.push(i),n.removeNode(t))}function qlt(e,t,r){var o;let n=e.coreGraph,i=n.node(t);i.isInExtract=!0,me.each(n.successors(t),(a,s)=>{uP(n,t,a)}),(Xo.detachAllEdgesForHighDegree||r)&&me.each(n.predecessors(t),(a,s)=>{uP(n,a,t)}),((o=n.neighbors(t))==null?void 0:o.length)===0&&(i.node.include=ur.EXCLUDE,e.isolatedInExtract.push(i),n.removeNode(t))}function vle(e,t){if(e.type===jt.OP){for(let r=0;r<t.length;r++)if(e.op===t[r])return!0}else if(e.type===jt.META){let r=e.getRootOp();if(r){for(let n=0;n<t.length;n++)if(r.op===t[n])return!0}}return!1}function Mcr(e){let t=e.coreGraph;me.each(t.nodes(),r=>{var i,o;t.node(r).node.include===ur.EXCLUDE&&!r.startsWith(Sa)&&(((i=e.coreGraph.outEdges(r))==null?void 0:i.length)>((o=e.coreGraph.inEdges(r))==null?void 0:o.length)?Ult(e,r,!0):qlt(e,r,!0))})}function Ecr(e){let t=e.coreGraph;me.each(t.nodes(),r=>{let n=t.node(r);n.node.include===ur.UNSPECIFIED&&vle(n.node,Xo.outExtractTypes)&&Ult(e,r)})}function Tcr(e){let t=e.coreGraph;me.each(t.nodes(),r=>{let n=t.node(r);n.node.include===ur.UNSPECIFIED&&vle(n.node,Xo.inExtractTypes)&&qlt(e,r)})}function Ccr(e){let t=e.coreGraph,r={},n={},i=0;if(me.each(t.nodes(),_=>{var b,S,C,P;if(t.node(_).node.include!==ur.UNSPECIFIED)return;let y=me.reduce(t.predecessors(_),(k,O)=>{let D=t.edge(O,_).metaedge;return k+(D.numRegularEdges?1:0)},0);y===0&&((b=t.predecessors(_))==null?void 0:b.length)>0&&(y=(S=t.predecessors(_))==null?void 0:S.length);let x=me.reduce(t.successors(_),(k,O)=>{let D=t.edge(_,O).metaedge;return k+(D.numRegularEdges?1:0)},0);x===0&&((C=t.successors(_))==null?void 0:C.length)>0&&(x=(P=t.successors(_))==null?void 0:P.length),r[_]=y,n[_]=x,i++}),i<Xo.minNodeCountForExtraction)return;let o=Xo.minDegreeForExtraction-1,a=Math.round(i*.75),s=Math.round(i*.25),l=Object.keys(r).sort((_,y)=>r[_]-r[y]),c=r[l[a]],u=r[l[s]],h=c+c-u;h=Math.max(h,o);for(let _=i-1;r[l[_]]>h;_--)qlt(e,l[_]);let f=Object.keys(n).sort((_,y)=>n[_]-n[y]),p=n[f[a]],d=n[f[s]],g=p+(p-d)*4;g=Math.max(g,o);for(let _=i-1;n[f[_]]>g;_--){let y=t.node(f[_]);!y||y.isInExtract||Ult(e,f[_])}}function Acr(e){let t=e.coreGraph,r={};me.each(t.edges(),n=>{t.edge(n).metaedge.numRegularEdges||((r[n.v]=r[n.v]||[]).push(n),(r[n.w]=r[n.w]||[]).push(n))}),me.each(r,(n,i)=>{n.length>Xo.maxControlDegree&&me.each(n,o=>uP(t,o.v,o.w))})}function Pcr(e,t){Mcr(e),Xo.outExtractTypes.length&&Ecr(e),Xo.inExtractTypes.length&&Tcr(e),t&&Ccr(e),Xo.maxControlDegree&&Acr(e);let r=e.coreGraph;me.each(r.nodes(),n=>{var a;let i=r.node(n),o=(a=r.neighbors(n))==null?void 0:a.length;if(i.node.include===ur.UNSPECIFIED&&o===0){let s=i.outAnnotations.list.length>0,l=i.inAnnotations.list.length>0;i.isInExtract?(e.isolatedInExtract.push(i),i.node.include=ur.EXCLUDE,r.removeNode(n)):i.isOutExtract?(e.isolatedOutExtract.push(i),i.node.include=ur.EXCLUDE,r.removeNode(n)):Xo.extractIsolatedNodesWithAnnotationsOnOneSide&&(s&&!l?(i.isInExtract=!0,e.isolatedInExtract.push(i),i.node.include=ur.EXCLUDE,r.removeNode(n)):l&&!s&&(i.isOutExtract=!0,e.isolatedOutExtract.push(i),i.node.include=ur.EXCLUDE,r.removeNode(n)))}})}function xle(e,t,r){let n=r.split("/"),i=n[n.length-1].match(/(.*):\w+/);(i==null?void 0:i.length)===2&&(n[n.length-1]=i==null?void 0:i[1]);let o=n[0],a=t.getRenderNodeByName(o);for(let s=1;s<n.length&&a.node.type!==jt.OP;s++)t.buildSubhierarchy(o),a.expanded=!0,e.setNodeExpanded(a),o+="/"+n[s],a=t.getRenderNodeByName(o);return a.node.name}var Mle=Ee(Olt(),1),Ze=Ee(Oe(),1);var Tr={animation:{duration:250},graph:{meta:{nodeSep:5,rankSep:25,edgeSep:5},series:{nodeSep:5,rankSep:25,edgeSep:5},padding:{paddingTop:40,paddingLeft:20}},subscene:{meta:{paddingTop:10,paddingBottom:10,paddingLeft:10,paddingRight:10,labelHeight:20,extractXOffset:15,extractYOffset:20},series:{paddingTop:10,paddingBottom:10,paddingLeft:10,paddingRight:10,labelHeight:10}},nodeSize:{meta:{radius:5,width:60,maxLabelWidth:52,height:On().domain([1,200]).range([15,60]).clamp(!0),expandButtonRadius:3},op:{width:15,height:6,radius:3,labelOffset:-8,maxLabelWidth:30},series:{expanded:{radius:10,labelOffset:0},vertical:{width:16,height:13,labelOffset:-13},horizontal:{width:24,height:8,radius:10,labelOffset:-10}},bridge:{width:20,height:20,radius:2,labelOffset:0}},shortcutSize:{op:{width:10,height:4},meta:{width:12,height:4,radius:1},series:{width:14,height:4}},annotations:{inboxWidth:50,outboxWidth:50,xOffset:10,yOffset:3,labelOffset:2,maxLabelWidth:40},constant:{size:{width:4,height:4}},series:{maxStackCount:3,parallelStackOffsetRatio:.2,towerStackOffsetRatio:.5},minimap:{size:150}},o3=140;function MH(e){e.node.isGroupNode&&Lcr(e),e.node.type===jt.META?kcr(e):e.node.type===jt.SERIES&&Rcr(e)}function Icr(e){e.inboxWidth=e.inAnnotations.list.length>0?Tr.annotations.inboxWidth:0,e.outboxWidth=e.outAnnotations.list.length>0?Tr.annotations.outboxWidth:0,e.coreBox.width=e.width,e.coreBox.height=e.height;let t=e.displayName.length,r=3;e.width=Math.max(e.coreBox.width+e.inboxWidth+e.outboxWidth,t*r)}function Lcr(e){let t=e.coreGraph.nodes().map(r=>e.coreGraph.node(r)).concat(e.isolatedInExtract,e.isolatedOutExtract,e.libraryFunctionsExtract);Ze.each(t,r=>{switch(r.node.type){case jt.OP:Ze.extend(r,Tr.nodeSize.op);break;case jt.BRIDGE:Ze.extend(r,Tr.nodeSize.bridge);break;case jt.META:r.expanded?MH(r):(Ze.extend(r,Tr.nodeSize.meta),r.height=Tr.nodeSize.meta.height(r.node.cardinality));break;case jt.SERIES:if(r.expanded)Ze.extend(r,Tr.nodeSize.series.expanded),MH(r);else{let i=r.node.hasNonControlEdges?Tr.nodeSize.series.vertical:Tr.nodeSize.series.horizontal;Ze.extend(r,i)}break;default:throw Error("Unrecognized node type: "+r.node.type)}r.expanded||Icr(r),Ncr(r)})}function Ele(e,t){Ze.extend(e.graph(),{nodesep:t.nodeSep,ranksep:t.rankSep,edgesep:t.edgeSep});let r=[],n=[];if(Ze.each(e.nodes(),l=>{e.node(l).node.type===jt.BRIDGE?r.push(l):n.push(l)}),!n.length)return{width:0,height:0};Mle.layout(e);let i=1/0,o=1/0,a=-1/0,s=-1/0;return Ze.each(n,l=>{let c=e.node(l),u=.5*c.width,h=c.x-u,f=c.x+u;i=h<i?h:i,a=f>a?f:a;let p=.5*c.height,d=c.y-p,g=c.y+p;o=d<o?d:o,s=g>s?g:s}),Ze.each(e.edges(),l=>{let c=e.edge(l);if(c.structural)return;let u=e.node(c.metaedge.v),h=e.node(c.metaedge.w);if(c.points.length===3&&Dcr(c.points)){if(u!=null){let d=u.expanded?u.x:v0(u);c.points[0].x=d}if(h!=null){let d=h.expanded?h.x:v0(h);c.points[2].x=d}c.points=[c.points[0],c.points[1]]}let f=c.points[c.points.length-2];h!=null&&(c.points[c.points.length-1]=Sle(f,h));let p=c.points[1];u!=null&&(c.points[0]=Sle(p,u)),Ze.each(c.points,d=>{i=d.x<i?d.x:i,a=d.x>a?d.x:a,o=d.y<o?d.y:o,s=d.y>s?d.y:s})}),Ze.each(e.nodes(),l=>{let c=e.node(l);c.x-=i,c.y-=o}),Ze.each(e.edges(),l=>{Ze.each(e.edge(l).points,c=>{c.x-=i,c.y-=o})}),{width:a-i,height:s-o}}function kcr(e){let t=Tr.subscene.meta;Ze.extend(e,t),Ze.extend(e.coreBox,Ele(e.coreGraph,Tr.graph.meta));let r=e.isolatedInExtract.length?Ze.maxBy(e.isolatedInExtract,c=>c.width).width:null;e.inExtractBox.width=r!=null?r:0,e.inExtractBox.height=Ze.reduce(e.isolatedInExtract,(c,u,h)=>{let f=h>0?t.extractYOffset:0;return u.x=0,u.y=c+f+u.height/2,c+f+u.height},0);let n=e.isolatedOutExtract.length?Ze.maxBy(e.isolatedOutExtract,c=>c.width).width:null;e.outExtractBox.width=n!=null?n:0,e.outExtractBox.height=Ze.reduce(e.isolatedOutExtract,(c,u,h)=>{let f=h>0?t.extractYOffset:0;return u.x=0,u.y=c+f+u.height/2,c+f+u.height},0);let i=e.libraryFunctionsExtract.length?Ze.maxBy(e.libraryFunctionsExtract,c=>c.width).width:null;e.libraryFunctionsBox.width=i!=null?i:0,e.libraryFunctionsBox.height=Ze.reduce(e.libraryFunctionsExtract,(c,u,h)=>{let f=h>0?t.extractYOffset:0;return u.x=0,u.y=c+f+u.height/2,c+f+u.height},0);let o=0;e.isolatedInExtract.length>0&&o++,e.isolatedOutExtract.length>0&&o++,e.libraryFunctionsExtract.length>0&&o++,e.coreGraph.nodeCount()>0&&o++;let a=Tr.subscene.meta.extractXOffset,s=o<=1?0:o*a,l=Math.max(o3,e.inExtractBox.width+e.outExtractBox.width);e.coreBox.width+=l+s+e.libraryFunctionsBox.width+s,e.coreBox.height=t.labelHeight+Math.max(e.inExtractBox.height,e.coreBox.height,e.libraryFunctionsBox.height,e.outExtractBox.height),e.width=e.coreBox.width+t.paddingLeft+t.paddingRight,e.height=e.paddingTop+e.coreBox.height+e.paddingBottom}function Rcr(e){let t=e.coreGraph,r=Tr.subscene.series;Ze.extend(e,r),Ze.extend(e.coreBox,Ele(e.coreGraph,Tr.graph.series)),Ze.each(t.nodes(),n=>{t.node(n).excluded=!1}),e.width=e.coreBox.width+r.paddingLeft+r.paddingRight,e.height=e.coreBox.height+r.paddingTop+r.paddingBottom}function Ncr(e){if(e.expanded)return;let t=e.inAnnotations.list,r=e.outAnnotations.list;Ze.each(t,u=>ble(u)),Ze.each(r,u=>ble(u));let n=Tr.annotations,i=Ze.reduce(t,(u,h,f)=>{let p=f>0?n.yOffset:0;return h.dx=-(e.coreBox.width+h.width)/2-n.xOffset,h.dy=u+p+h.height/2,u+p+h.height},0);Ze.each(t,u=>{u.dy-=i/2,u.labelOffset=n.labelOffset});let o=Ze.reduce(r,(u,h,f)=>{let p=f>0?n.yOffset:0;return h.dx=(e.coreBox.width+h.width)/2+n.xOffset,h.dy=u+p+h.height/2,u+p+h.height},0);Ze.each(r,u=>{u.dy-=o/2,u.labelOffset=n.labelOffset});let a=Math.min(e.height/2-e.radius,i/2);a=a<0?0:a;let s=On().domain([0,t.length-1]).range([-a,a]);Ze.each(t,(u,h)=>{u.points=[{dx:u.dx+u.width/2,dy:u.dy},{dx:-e.coreBox.width/2,dy:t.length>1?s(h):0}]});let l=Math.min(e.height/2-e.radius,o/2);l=l<0?0:l;let c=On().domain([0,r.length-1]).range([-l,l]);Ze.each(r,(u,h)=>{u.points=[{dx:e.coreBox.width/2,dy:r.length>1?c(h):0},{dx:u.dx-u.width/2,dy:u.dy}]}),e.height=Math.max(e.height,i,o)}function ble(e){switch(e.annotationType){case gi.CONSTANT:Ze.extend(e,Tr.constant.size);break;case gi.SHORTCUT:if(e.node.type===jt.OP)Ze.extend(e,Tr.shortcutSize.op);else if(e.node.type===jt.META)Ze.extend(e,Tr.shortcutSize.meta);else if(e.node.type===jt.SERIES)Ze.extend(e,Tr.shortcutSize.series);else throw Error("Invalid node type: "+e.node.type);break;case gi.SUMMARY:Ze.extend(e,Tr.constant.size);break}}function v0(e){if(e.expanded)return e.x;let t=e.inAnnotations.list.length?e.inboxWidth:0;return e.x-e.width/2+t+e.coreBox.width/2}function wle(e,t){let r=t.x-e.x,n=t.y-e.y;return 180*Math.atan(n/r)/Math.PI}function Dcr(e){let t=wle(e[0],e[1]);for(let r=1;r<e.length-1;r++){let n=wle(e[r],e[r+1]);if(Math.abs(n-t)>1)return!1;t=n}return!0}function Sle(e,t){let r=t.expanded?t.x:v0(t),n=t.y,i=e.x-r,o=e.y-n,a=t.expanded?t.width:t.coreBox.width,s=t.expanded?t.height:t.coreBox.height,l,c;return Math.abs(o)*a/2>Math.abs(i)*s/2?(o<0&&(s=-s),l=o===0?0:s/2*i/o,c=s/2):(i<0&&(a=-a),l=a/2,c=i===0?0:a/2*o/i),{x:r+l,y:n+c}}var Pl=m0,Hi=ve,Ocr=320,zcr=150,fP=[{background_color:"#CC2F2C",label:"NaN"},{background_color:"#FF8D00",label:"-\u221E"},{background_color:"#EAEAEA",label:"-"},{background_color:"#A5A5A5",label:"0"},{background_color:"#262626",label:"+"},{background_color:"#003ED4",label:"+\u221E"}];function Cle(e,t,r,n){let i=e.getBoundingClientRect(),o=null;try{if(o=t.getBBox(),(o==null?void 0:o.width)===0)return}catch(c){return}let a=.9*Math.min(i.width/(o==null?void 0:o.width),i.height/(o==null?void 0:o.height),2),s=Tr.graph,l=Xh.scale(a).translate(s.padding.paddingLeft,s.padding.paddingTop);Ht(e).transition().duration(500).call(r.transform,l).on("end.fitted",()=>{r.on("end.fitted",null),n()})}function Ale(e,t,r,n){let i=Ht(t).select(`[data-name="${e}"]`).node();if(!i)return console.warn(`panToNode() failed for node name "${e}"`),!1;let o=i.getBBox(),a=i.getScreenCTM(),s=t.createSVGPoint(),l=t.createSVGPoint();s.x=o.x,s.y=o.y,l.x=o.x+o.width,l.y=o.y+o.height,s=s.matrixTransform(a),l=l.matrixTransform(a);let c=(p,d,g,_)=>!(p>g&&d<_),u=t.getBoundingClientRect(),h=u.left+u.width-Ocr,f=u.top+u.height-zcr;if(c(s.x,l.x,u.left,h)||c(s.y,l.y,u.top,f)){let p=(s.x+l.x)/2,d=(s.y+l.y)/2,g=u.left+u.width/2-p,_=u.top+u.height/2-d,y=i2(t);return Ht(t).transition().duration(500).call(n.translateBy,g/y.k,_/y.k),!0}return!1}function Ple(e,t){let r=t.node.type===jt.SERIES?0:Tr.subscene.meta.labelHeight;a3(Pl(e,"g",Hi.Scene.CORE),0,r);let n=t.isolatedInExtract.length>0,i=t.isolatedOutExtract.length>0,o=t.libraryFunctionsExtract.length>0,a=Tr.subscene.meta.extractXOffset,s=0;if(n&&(s+=t.outExtractBox.width),i&&(s+=t.outExtractBox.width),n){let l=t.coreBox.width;s<o3?l=l-o3+t.inExtractBox.width/2:l=l-t.inExtractBox.width/2-t.outExtractBox.width-(i?a:0),l=l-t.libraryFunctionsBox.width-(o?a:0),a3(Pl(e,"g",Hi.Scene.INEXTRACT),l,r)}if(i){let l=t.coreBox.width;s<o3?l=l-o3+t.outExtractBox.width/2:l-=t.outExtractBox.width/2,l=l-t.libraryFunctionsBox.width-(o?a:0),a3(Pl(e,"g",Hi.Scene.OUTEXTRACT),l,r)}if(o){let l=t.coreBox.width-t.libraryFunctionsBox.width/2;a3(Pl(e,"g",Hi.Scene.FUNCTION_LIBRARY),l,r)}}function Ile(e,t){Ht(e).on("click",()=>{t.fire("graph-select")})}function a3(e,t,r){e.attr("transform")!=null&&(e=e.transition("position")),e.attr("transform","translate("+t+","+r+")")}function zd(e,t,r,n,i){e.transition().attr("x",t-n/2).attr("y",r-i/2).attr("width",n).attr("height",i)}function Lle(e,t,r,n,i){let o=i/2,a=n/2,s=[[t,r-o],[t+a,r+o],[t-a,r+o]];e.transition().attr("points",s.map(l=>l.join(",")).join(" "))}function kle(e,t){let r=v0(t),n=t.expanded?t.width:t.coreBox.width,i=t.expanded?t.height:t.coreBox.height,o=r+n/2-6,a=t.y-i/2+6;t.node.type===jt.SERIES&&!t.expanded&&(o+=10,a-=2);let s="translate("+o+","+a+")";e.selectAll("path").transition().attr("transform",s),e.select("circle").transition().attr({cx:o,cy:a,r:Tr.nodeSize.meta.expandButtonRadius})}function EH(e,t,r,n,i){e.transition().attr("cx",t).attr("cy",r).attr("rx",n/2).attr("ry",i/2)}function Tle(e,t){return t?e.toFixed(0):Math.abs(e)>=1?e.toFixed(1):e.toExponential(1)}function Fcr(e,t,r,n){let i="Device: "+e.device_name+`
`;i+="dtype: "+e.dtype+`
`;let o="(scalar)";e.shape.length>0&&(o="("+e.shape.join(",")+")"),i+=`
shape: `+o+`

`,i+="#(elements): "+t+`
`;let a=[];for(let s=0;s<r.length;s++)r[s]>0&&a.push("#("+fP[s].label+"): "+r[s]);return i+=a.join(", ")+`

`,n.max>=n.min&&(i+="min: "+n.min+", max: "+n.max+`
`,i+="mean: "+n.mean+", stddev: "+n.stddev),i}function Bcr(e,t,r,n,i=60,o=10,a=0,s){if(Ht(e.parentNode).selectAll(".health-pill").remove(),!t)return;let l=t.value,c=l.slice(2,8),u=c[0],h=c[1],f=c[5],p=l[1],d={min:l[8],max:l[9],mean:l[10],stddev:Math.sqrt(l[11])};i==null&&(i=60),o==null&&(o=10),a==null&&(a=0),r!=null&&r.node.type===jt.OP&&(i/=2,o/=2);let g=document.createElementNS(ju,"g");g.classList.add("health-pill");let _=document.createElementNS(ju,"defs");g.appendChild(_);let y=document.createElementNS(ju,"linearGradient"),x="health-pill-gradient-"+n;y.setAttribute("id",x);let b=0,S="0%";for(let D=0;D<c.length;D++){if(!c[D])continue;b+=c[D];let B=document.createElementNS(ju,"stop");B.setAttribute("offset",S),B.setAttribute("stop-color",fP[D].background_color),y.appendChild(B);let I=document.createElementNS(ju,"stop"),L=b*100/p+"%";I.setAttribute("offset",L),I.setAttribute("stop-color",fP[D].background_color),y.appendChild(I),S=L}_.appendChild(y);let C=document.createElementNS(ju,"rect");C.setAttribute("fill","url(#"+x+")"),C.setAttribute("width",String(i)),C.setAttribute("height",String(o)),C.setAttribute("y",String(a)),g.appendChild(C);let P=document.createElementNS(ju,"title");P.textContent=Fcr(t,p,c,d),g.appendChild(P);let k=!1;if(r!=null){let D=r.x-i/2,B=r.y-o-r.height/2-2;if(r.labelOffset<0&&(B+=r.labelOffset),g.setAttribute("transform","translate("+D+", "+B+")"),c[2]||c[3]||c[4]){let L=r.node.attr;if(L&&L.length){for(let R=0;R<L.length;R++)if(L[R].key==="T"){let F=L[R].value.type;k=F&&/^DT_(BOOL|INT|UINT)/.test(F);break}}}}let O=document.createElementNS(ju,"text");if(Number.isFinite(d.min)&&Number.isFinite(d.max)){let D=Tle(d.min,k),B=Tle(d.max,k);if(p>1?O.textContent=D+" ~ "+B:O.textContent=D,u>0||h>0||f>0){O.textContent+=" (";let I=[];u>0&&I.push(`NaN\xD7${u}`),h>0&&I.push(`-\u221E\xD7${h}`),f>0&&I.push(`+\u221E\xD7${f}`),O.textContent+=I.join("; ")+")"}}else O.textContent="(No finite elements)";O.classList.add("health-pill-stats"),s==null&&(s=i/2),O.setAttribute("x",String(s)),O.setAttribute("y",String(a-2)),g.appendChild(O),zt(e.parentNode).appendChild(g)}function Rle(e,t,r){if(!t)return;let n=1;Ht(e).selectAll("g.nodeshape").each(function(o){let a=t[o.node.name],s=a?a[r]:null;Bcr(this,s,o,n++)})}var qn;(function(e){e.NONE="none",e.COMPUTE_TIME="compute_time",e.DEVICE="device",e.MEMORY="memory",e.OP_COMPATIBILITY="op_compatibility",e.STRUCTURE="structure",e.XLA_CLUSTER="xla_cluster"})(qn||(qn={}));var mP=Ee(Oe(),1);var Vi=Ee(Oe(),1);function Hcr(e){let t=0,r=0,n=e;for(;n&&n.offsetLeft>=0&&n.offsetTop>=0;)t+=n.offsetLeft-n.scrollLeft,r+=n.offsetTop-n.scrollTop,n=n.offsetParent;return{left:t,top:r}}function Wlt(e,t){let r=e.getContextMenu(),n=Ht(e.getContextMenu());return function(i,o){let a=qt,s=Hcr(e);n.style("display","block").style("left",a.clientX-s.left+1+"px").style("top",a.clientY-s.top+1+"px"),a.preventDefault(),a.stopPropagation();function l(u){u&&u.composedPath().includes(r)||(n.style("display","none"),document.body.removeEventListener("mousedown",l,{capture:!0}))}document.body.addEventListener("mousedown",l,{capture:!0}),n.text(""),n.append("ul").selectAll("li").data(t).enter().append("li").on("click",(u,h)=>{u.action(this,i,o),l()}).text(function(u){return u.title(i)})}}var AH=Ee(Oe(),1);var Ucr="\xD7",Nle=qb().domain([Q4,tP]).range(["small","medium","large","xlarge"]),qcr=2.5;function pP(e){return e.v+ole+e.w}function zle(e,t,r){let n=r,i=[];i=AH.reduce(t.edges(),(s,l)=>{let c=t.edge(l);return s.push({v:l.v,w:l.w,label:c}),s},i);let a=An(e,"g",ve.Edge.CONTAINER).selectAll(function(){return this.childNodes}).data(i,pP);return a.enter().append("g").attr("class",ve.Edge.GROUP).attr("data-edge",pP).each(function(s){let l=Ht(this);s.label.edgeGroup=l,n._edgeGroupIndex[pP(s)]=l,n.handleEdgeSelected&&l.on("click",c=>{qt.stopPropagation(),n.fire("edge-select",{edgeData:c,edgeGroup:l})}),Xlt(l,s,n)}).merge(a).each(function(){Wcr(r,this)}).each(function(s){Ycr(Ht(this),s,n)}),a.exit().each(s=>{delete n._edgeGroupIndex[pP(s)]}).remove(),a}function Ylt(e,t){let r=t.getNodeByName(e.v);if(r.outputShapes==null||AH.isEmpty(r.outputShapes))return null;let n=r.outputShapes[e.outputTensorKey];return n==null?null:n.length===0?"scalar":n.map(i=>i===-1?"?":i).join(Ucr)}function jlt(e,t){return t.edgeLabelFunction?t.edgeLabelFunction(e,t):e.baseEdgeList.length>1?e.baseEdgeList.length+" tensors":Ylt(e.baseEdgeList[0],t)}function Dle(e,t,r){let n=document.createElementNS(ju,"path");for(let i=1;i<e.length;i++)if(n.setAttribute("d",r(e.slice(0,i))),n.getTotalLength()>t)return i-1;return e.length-1}function Ole(e,t,r){let n=vu().x(u=>u.x).y(u=>u.y),i=Ht(document.createElementNS("http://www.w3.org/2000/svg","path")).attr("d",n(e)),o=+t.attr("markerWidth"),a=t.attr("viewBox").split(" ").map(Number),s=a[2]-a[0],l=+t.attr("refX"),c=i.node();if(r){let u=1-l/s,h=o*u,f=c.getPointAtLength(h),p=Dle(e,h,n);return e[p-1]={x:f.x,y:f.y},e.slice(p-1)}else{let u=1-l/s,h=c.getTotalLength()-o*u,f=c.getPointAtLength(h),p=Dle(e,h,n);return e[p]={x:f.x,y:f.y},e.slice(0,p+1)}}function Xlt(e,t,r,n){n=n||ve.Edge.LINE,t.label&&t.label.structural&&(n+=" "+ve.Edge.STRUCTURAL),t.label&&t.label.metaedge&&t.label.metaedge.numRefEdges&&(n+=" "+ve.Edge.REFERENCE_EDGE),r.handleEdgeSelected&&(n+=" "+ve.Edge.SELECTABLE);let i="path_"+pP(t),o;if(r.renderHierarchy.edgeWidthFunction)o=r.renderHierarchy.edgeWidthFunction(t,n);else{let c=1;t.label!=null&&t.label.metaedge!=null&&(c=t.label.metaedge.totalSize),o=r.renderHierarchy.edgeWidthSizedBasedScale(c)}let a=e.append("path").attr("id",i).attr("class",n).style("stroke-width",o+"px");if(t.label&&t.label.metaedge)if(t.label.metaedge.numRefEdges){let c=`reference-arrowhead-${Nle(o)}`;a.style("marker-start",`url(#${c})`),t.label.startMarkerId=c}else{let c=`dataflow-arrowhead-${Nle(o)}`;a.style("marker-end",`url(#${c})`),t.label.endMarkerId=c}if(t.label==null||t.label.metaedge==null)return;let s=jlt(t.label.metaedge,r.renderHierarchy);if(s==null)return;let l=o>qcr?"central":"text-after-edge";e.append("text").append("textPath").attr("xlink:href","#"+i).attr("startOffset","50%").attr("text-anchor","middle").attr("dominant-baseline","central").text(s)}var CH=vu().curve(W8).x(e=>e.x).y(e=>e.y);function Gcr(e,t,r,n,i){let o=r.label,a=o.adjoiningMetaedge,s=o.points,{shadowRoot:l}=e;if(r.label.startMarkerId&&(s=Ole(s,Ht(l==null?void 0:l.querySelector("#"+r.label.startMarkerId)),!0)),r.label.endMarkerId&&(s=Ole(s,Ht(l==null?void 0:l.querySelector("#"+r.label.endMarkerId)),!1)),!a)return nc(i,CH(s));let c=a.edgeGroup.node().firstChild,u=o.metaedge.inbound;return function(h){var g;let f=c.getPointAtLength(u?c.getTotalLength():0).matrixTransform(c.getCTM()).matrixTransform((g=t.getCTM())==null?void 0:g.inverse()),p=u?0:s.length-1;return s[p].x=f.x,s[p].y=f.y,CH(s)}}function Wcr(e,t){Ht(t).select("path."+ve.Edge.LINE).transition().attrTween("d",function(r,n,i){return Gcr(e,this,r,n,i)})}function Ycr(e,t,r){e.classed("faded",t.label.isFadedOut);let n=t.label.metaedge;e.select("path."+ve.Edge.LINE).classed("control-dep",n&&!n.numRegularEdges)}function PH(e,t,r){let i=An(e,"g",ve.Node.CONTAINER).selectAll(function(){return this.childNodes}).data(t,o=>o.node.name+":"+o.node.type);return i.enter().append("g").attr("data-name",o=>o.node.name).each(function(o){let a=Ht(this);r.addNodeGroup(o.node.name,a)}).merge(i).attr("class",o=>ve.Node.GROUP+" "+Wle(o)).each(function(o){let a=Ht(this),s=An(a,"g",ve.Annotation.INBOX);Vle(s,o.inAnnotations,o,r);let l=An(a,"g",ve.Annotation.OUTBOX);Vle(l,o.outAnnotations,o,r);let c=Gle(a,o,ve.Node.SHAPE);o.node.isGroupNode&&Xcr(c,o,r),Hle(c,o,r),jcr(a,o,r);let u=Kcr(a,o,r);Hle(u,o,r,o.node.type===jt.META),s3(a,o,r),Jcr(a,o)}),i.exit().each(function(o){r.removeNodeGroup(o.node.name);let a=Ht(this);o.inAnnotations.list.length>0&&a.select("."+ve.Annotation.INBOX).selectAll("."+ve.Annotation.GROUP).each(s=>{r.removeAnnotationGroup(s,o)}),o.outAnnotations.list.length>0&&a.select("."+ve.Annotation.OUTBOX).selectAll("."+ve.Annotation.GROUP).each(s=>{r.removeAnnotationGroup(s,o)})}).remove(),i}function jcr(e,t,r){if(t.node.isGroupNode){if(t.expanded)return ect(e,t,r,ve.Subscene.GROUP);Pl(e,"g",ve.Subscene.GROUP).remove()}return null}function Ble(e,t){let r=t.x-t.width/2+t.paddingLeft,n=t.y-t.height/2+t.paddingTop,i=Pl(e,"g",ve.Subscene.GROUP);a3(i,r,n)}function Xcr(e,t,r){let n=An(e,"g",ve.Node.BUTTON_CONTAINER);An(n,"circle",ve.Node.BUTTON_CIRCLE),An(n,"path",ve.Node.EXPAND_BUTTON).attr("d","M0,-2.2 V2.2 M-2.2,0 H2.2"),An(n,"path",ve.Node.COLLAPSE_BUTTON).attr("d","M-2.2,0 H2.2"),n.on("click",i=>{qt.stopPropagation(),r.fire("node-toggle-expand",{name:i.node.name})}),kle(n,t)}function Hle(e,t,r,n){if(n){e.attr("pointer-events","none");return}let i=Wlt(r,Ule(t.node,r));e.on("dblclick",o=>{r.fire("node-toggle-expand",{name:o.node.name})}).on("mouseover",o=>{r.isNodeExpanded(o)||r.fire("node-highlight",{name:o.node.name})}).on("mouseout",o=>{r.isNodeExpanded(o)||r.fire("node-unhighlight",{name:o.node.name})}).on("click",o=>{qt.stopPropagation(),r.fire("node-select",{name:o.node.name})}).on("contextmenu",(o,a)=>{r.fire("node-select",{name:o.node.name}),i.call(o,a)})}function Ule(e,t){let r=[{title:n=>yH(e.include),action:(n,i,o)=>{t.fire("node-toggle-extract",{name:e.name})}}];return t.nodeContextMenuItems&&(r=r.concat(t.nodeContextMenuItems)),Jlt(e)&&r.push({title:n=>Qlt(e),action:(n,i,o)=>{t.fire("node-toggle-seriesgroup",{name:IH(e)})}}),r}function Jlt(e){return IH(e)!==null}function IH(e){return e?e.type===jt.SERIES?e.name:e.type===jt.OP?e.owningSeries:null:null}function $cr(e){let t=null;if(e)e.type===jt.SERIES?t=e:e.parentNode&&e.parentNode.type===jt.SERIES&&(t=e.parentNode);else return null;return t}function Qlt(e){return ule($cr(e)!==null?is.GROUP:is.UNGROUP)}function Kcr(e,t,r){var c;let n=t.displayName,i=t.node.type===jt.META&&!t.expanded,o=An(e,"text",ve.Node.LABEL),a=o.node();(c=a.parentNode)==null||c.appendChild(a),o.attr("dy",".35em").attr("text-anchor","middle");let s=8;switch(t.node.type){case jt.META:s=t.expanded?J4.Node.EXPANDED_LABEL:J4.Node.SERIES_LABEL;break;case jt.OP:s=J4.Node.OP_LABEL;break}if(i){n.length>r.maxMetanodeLabelLength&&(n=n.substr(0,r.maxMetanodeLabelLength-2)+"\u2026");let u=Zcr(r);o.attr("font-size",u(n.length)+"px"),s=u(n.length)}let l=o.text(n);return qle(l,t.node.type,s,t),o}function qle(e,t,r,n){let i=e.node(),o=i.textContent,a=null;switch(t){case jt.META:n&&!n.expanded&&(a=Tr.nodeSize.meta.maxLabelWidth);break;case jt.OP:a=Tr.nodeSize.op.maxLabelWidth;break;case-1:a=Tr.annotations.maxLabelWidth;break;default:break}if(a!==null)return i.textContent=tle(i.textContent,r,a),e.append("title").text(o)}var $lt=null;function Zcr(e){return $lt||($lt=On().domain([e.maxMetanodeLabelLengthLargeFont,e.maxMetanodeLabelLength]).range([e.maxMetanodeLabelLengthFontSize,e.minMetanodeLabelLengthFontSize]).clamp(!0)),$lt}function dP(e,t,r,n){Pl(e,"text",ve.Node.LABEL).transition().attr("x",t).attr("y",r+n)}function Gle(e,t,r){let n=An(e,"g",r);switch(t.node.type){case jt.OP:let i=t.node;if(Vi.isNumber(i.functionInputIndex)||Vi.isNumber(i.functionOutputIndex)){An(n,"polygon",ve.Node.COLOR_TARGET);break}An(n,"ellipse",ve.Node.COLOR_TARGET);break;case jt.SERIES:let o="annotation",a=t;a.coreGraph&&(o=a.node.hasNonControlEdges?"vertical":"horizontal");let s=[ve.Node.COLOR_TARGET];a.isFadedOut&&s.push("faded-ellipse"),An(n,"use",s).attr("xlink:href","#op-series-"+o+"-stamp"),An(n,"rect",ve.Node.COLOR_TARGET).attr("rx",t.radius).attr("ry",t.radius);break;case jt.BRIDGE:An(n,"rect",ve.Node.COLOR_TARGET).attr("rx",t.radius).attr("ry",t.radius);break;case jt.META:An(n,"rect",ve.Node.COLOR_TARGET).attr("rx",t.radius).attr("ry",t.radius);break;default:throw Error("Unrecognized node type: "+t.node.type)}return n}function Wle(e){switch(e.node.type){case jt.OP:return ve.OPNODE;case jt.META:return ve.METANODE;case jt.SERIES:return ve.SERIESNODE;case jt.BRIDGE:return ve.BRIDGENODE;case jt.ELLIPSIS:return ve.ELLIPSISNODE}throw Error("Unrecognized node type: "+e.node.type)}function Jcr(e,t){let r=Pl(e,"g",ve.Node.SHAPE),n=v0(t);switch(t.node.type){case jt.OP:{let i=t.node;if(Vi.isNumber(i.functionInputIndex)||Vi.isNumber(i.functionOutputIndex)){let o=Pl(r,"polygon");Lle(o,t.x,t.y,t.coreBox.width,t.coreBox.height)}else{let o=Pl(r,"ellipse");EH(o,n,t.y,t.coreBox.width,t.coreBox.height)}dP(e,n,t.y,t.labelOffset);break}case jt.META:{let i=r.selectAll("rect");t.expanded?(zd(i,t.x,t.y,t.width,t.height),Ble(e,t),dP(e,n,t.y,-t.height/2+t.labelHeight/2)):(zd(i,n,t.y,t.coreBox.width,t.coreBox.height),dP(e,n,t.y,0));break}case jt.SERIES:{let i=Pl(r,"use");t.expanded?(zd(i,t.x,t.y,t.width,t.height),Ble(e,t),dP(e,n,t.y,-t.height/2+t.labelHeight/2)):(zd(i,n,t.y,t.coreBox.width,t.coreBox.height),dP(e,n,t.y,t.labelOffset));break}case jt.BRIDGE:{let i=Pl(r,"rect");zd(i,t.x,t.y,t.width,t.height);break}default:throw Error("Unrecognized node type: "+t.node.type)}}function Klt(e,t,r){let n=Jse(e);if(!r)return`url(#${n})`;let i=Ht(r),o=i.select("defs#_graph-gradients");o.empty()&&(o=i.append("defs").attr("id","_graph-gradients"));let a=o.select("linearGradient#"+n);if(a.empty()){a=o.append("linearGradient").attr("id",e),a.selectAll("*").remove();let s=0;Vi.each(t,l=>{let c=l.color;a.append("stop").attr("offset",s).attr("stop-color",c),a.append("stop").attr("offset",s+l.proportion).attr("stop-color",c),s+=l.proportion})}return`url(#${n})`}function LH(e){Ht(e).select("defs#_graph-gradients").remove()}function kH(e,t,r,n,i){let o=Ku;switch(e=e||(()=>0),t){case qn.NONE:case qn.STRUCTURE:if(r.node.type===jt.META){let a=r.node.templateId;return t===qn.STRUCTURE&&a!==null?o.STRUCTURE_PALETTE(e(a),n):o.UNKNOWN}else return r.node.type===jt.SERIES?n?o.EXPANDED_COLOR:"white":r.node.type===jt.BRIDGE?r.structural?"#f0e":r.node.inbound?"#0ef":"#fe0":Vi.isNumber(r.node.functionInputIndex)?"#795548":Vi.isNumber(r.node.functionOutputIndex)?"#009688":"white";case qn.DEVICE:return r.deviceColors==null?o.UNKNOWN:n?o.EXPANDED_COLOR:Klt("device-"+r.node.name,r.deviceColors,i);case qn.XLA_CLUSTER:return r.xlaClusterColors==null?o.UNKNOWN:n?o.EXPANDED_COLOR:Klt("xla-"+r.node.name,r.xlaClusterColors,i);case qn.COMPUTE_TIME:return n?o.EXPANDED_COLOR:r.computeTimeColor||o.UNKNOWN;case qn.MEMORY:return n?o.EXPANDED_COLOR:r.memoryColor||o.UNKNOWN;case qn.OP_COMPATIBILITY:return r.compatibilityColors==null?o.UNKNOWN:n?o.EXPANDED_COLOR:Klt("op-compat-"+r.node.name,r.compatibilityColors,i);default:throw new Error("Unknown case to color nodes by")}}function s3(e,t,r,n){n=n||ve.Node.SHAPE;let i=r.isNodeHighlighted(t.node.name),o=r.isNodeSelected(t.node.name),a=t.isInExtract||t.isOutExtract||t.isLibraryFunction,s=t.expanded&&n!==ve.Annotation.NODE,l=t.isFadedOut;e.classed("highlighted",i),e.classed("selected",o),e.classed("extract",a),e.classed("expanded",s),e.classed("faded",l);let c=e.select("."+n+" ."+ve.Node.COLOR_TARGET),u=kH(r.templateIndex,r.colorBy,t,s,r.getGraphSvgRoot());c.style("fill",u),c.style("stroke",o?null:tct(u))}function tct(e){return e.substring(0,3)==="url"?Ku.GRADIENT_OUTLINE:cu(e).darker().toString()}function Yle(e,t,r,n){let i=Ht(e);if(i.selectAll(".input-highlight").classed("input-highlight",!1),i.selectAll(".non-input").classed("non-input",!1),i.selectAll(".input-parent").classed("input-parent",!1),i.selectAll(".input-child").classed("input-child",!1),i.selectAll(".input-edge-highlight").classed("input-edge-highlight",!1),i.selectAll(".non-input-edge-highlight").classed("non-input-edge-highlight",!1),i.selectAll(".input-highlight-selected").classed("input-highlight-selected",!1),!t||!n||!r)return;let o=jle(r,t),a={};Vi.each(o,function(c){a=Xle(e,t,c,a)});let s=Object.keys(a),l=tur(t,s);eur(e,l),i.selectAll("g.node:not(.selected):not(.input-highlight):not(.input-parent):not(.input-children)").classed("non-input",!0).each(function(c){let u=c.node.name;i.selectAll(`[data-name="${u}"]`).classed("non-input",!0)}),i.selectAll("g.edge:not(.input-edge-highlight)").classed("non-input-edge-highlight",!0)}function jle(e,t){let r=[],n=t.getNodeByName(e);if(n instanceof _0)return[n].concat(n.inEmbeddings);let i=n.metagraph.nodes();return Vi.each(i,function(o){r=r.concat(jle(o,t))}),r}function Xle(e,t,r,n){if(n[r.name])return n;n[r.name]=!0;let i=r.inputs,o=Zlt(t,r);Ht(e).select(`.node[data-name="${o.name}"]`).classed("input-highlight",!0);let a={};Vi.each(i,function(u){let h=t.getNodeByName(u.name);if(h===void 0)return;if(h instanceof aP){let d=sP(h.name);h=t.getNodeByName(d)}let f=Zlt(t,h),p=a[f.name];p?p.opNodes.push(h):a[f.name]={visibleParent:f,opNodes:[h]}});let s={},l=[o];s[o.name]={traced:!1,index:0,connectionEndpoints:[]};let c=o;for(let u=1;c.name!==qc;u++)c=c.parentNode,s[c.name]={traced:!1,index:u,connectionEndpoints:[]},l[u]=c;return Vi.forOwn(a,function(u,h){let f=u.visibleParent;Vi.each(u.opNodes,function(p){n=Xle(e,t,p,n)}),f.name!==o.name&&Qcr(e,f,s,l)}),n}function Qcr(e,t,r,n){let i=t,o=t,a=[];for(;!r[i.name];)o.name!==i.name&&a.push([o,i]),o=i,i=i.parentNode;let s=r[i.name].index,l=n[Math.max(s-1,0)].name,c=l,u=o.name,h=o.name,f=Ht(e);f.selectAll(`[data-edge="${h}--${l}"]`).classed("input-edge-highlight",!0),Vi.each(a,function(p){let d=p[0],g=p[1],_=`[data-edge="${d.name}--${c}~~${g.name}~~OUT"]`;f.selectAll(_).classed("input-edge-highlight",!0)});for(let p=1;p<s;p++){let d=n[p-1],g=n[p],_=`[data-edge="${u}~~${g.name}~~IN--${d.name}"]`;f.selectAll(_).classed("input-edge-highlight",!0)}}function tur(e,t){let r={};return Vi.each(t,function(n){let i=e.getNodeByName(n),o=Zlt(e,i);r[o.name]=o}),r}function eur(e,t){Vi.forOwn(t,function(r){let n=r;for(;n.name!==qc;){let i=Ht(e).select(`.node[data-name="${n.name}"]`);i.nodes().length&&!i.classed("input-highlight")&&!i.classed("selected")&&!i.classed("op")&&i.classed("input-parent",!0),n=n.parentNode}})}function Zlt(e,t){let r=!1,n=t;for(;!r;)if(t=n,n=t.parentNode,n===void 0)r=!0;else{let i=e.getRenderNodeByName(n.name);i&&(i.expanded||n instanceof _0)&&(r=!0)}return t}function Vle(e,t,r,n){let i=e.selectAll(function(){return this.childNodes}).data(t.list,o=>o.node.name);return i.enter().append("g").attr("data-name",o=>o.node.name).each(function(o){let a=Ht(this);n.addAnnotationGroup(o,r,a);let s=ve.Annotation.EDGE,l=o.renderMetaedgeInfo&&o.renderMetaedgeInfo.metaedge;l&&!l.numRegularEdges&&(s+=" "+ve.Annotation.CONTROL_EDGE),l&&l.numRefEdges&&(s+=" "+ve.Edge.REF_LINE),Xlt(a,o,n,s),o.annotationType!==gi.ELLIPSIS?(iur(a,o),nur(a,o)):$le(a,o.node.name,o,ve.Annotation.ELLIPSIS)}).merge(i).attr("class",o=>ve.Annotation.GROUP+" "+rur(o.annotationType)+" "+Wle(o)).each(function(o){let a=Ht(this);aur(a,r,o,n),o.annotationType!==gi.ELLIPSIS&&our(a,r,o,n)}),i.exit().each(function(o){n.removeAnnotationGroup(o,r)}).remove(),i}function rur(e){return(gi[e]||"").toLowerCase()||null}function nur(e,t){if(t.annotationType===gi.SUMMARY)An(e,"use").attr("class","summary").attr("xlink:href","#summary-icon").attr("cursor","pointer");else{let r=Gle(e,t,ve.Annotation.NODE);An(r,"title").text(t.node.name)}}function iur(e,t){let r=t.node.name.split("/"),n=r[r.length-1];return $le(e,n,t,null)}function $le(e,t,r,n){let i=ve.Annotation.LABEL;n&&(i+=" "+n);let o=e.append("text").attr("class",i).attr("dy",".35em").attr("text-anchor",r.isIn?"end":"start").text(t);return qle(o,-1,J4.Annotation.LABEL)}function our(e,t,r,n){e.on("mouseover",i=>{n.fire("annotation-highlight",{name:i.node.name,hostName:t.node.name})}).on("mouseout",i=>{n.fire("annotation-unhighlight",{name:i.node.name,hostName:t.node.name})}).on("click",i=>{qt.stopPropagation(),n.fire("annotation-select",{name:i.node.name,hostName:t.node.name})}),r.annotationType!==gi.SUMMARY&&r.annotationType!==gi.CONSTANT&&e.on("contextmenu",Wlt(n,Ule(r.node,n)))}function aur(e,t,r,n){let i=v0(t);r.renderNodeInfo&&r.annotationType!==gi.ELLIPSIS&&s3(e,r.renderNodeInfo,n,ve.Annotation.NODE),r.annotationType===gi.SUMMARY&&(r.width+=10),e.select("text."+ve.Annotation.LABEL).transition().attr("x",i+r.dx+(r.isIn?-1:1)*(r.width/2+r.labelOffset)).attr("y",t.y+r.dy),e.select("use.summary").transition().attr("x",i+r.dx-3).attr("y",t.y+r.dy-6),EH(e.select("."+ve.Annotation.NODE+" ellipse"),i+r.dx,t.y+r.dy,r.width,r.height),zd(e.select("."+ve.Annotation.NODE+" rect"),i+r.dx,t.y+r.dy,r.width,r.height),zd(e.select("."+ve.Annotation.NODE+" use"),i+r.dx,t.y+r.dy,r.width,r.height),e.select("path."+ve.Annotation.EDGE).transition().attr("d",o=>{let a=o.points.map(s=>({x:s.dx+i,y:s.dy+t.y}));return CH(a)})}function ect(e,t,r,n){n=n||ve.Scene.GROUP;let i=m0(e,"g",n).empty(),o=An(e,"g",n),a=An(o,"g",ve.Scene.CORE),s=Vi.reduce(t.coreGraph.nodes(),(l,c)=>{let u=t.coreGraph.node(c);return u.excluded||l.push(u),l},Array());if(t.node.type===jt.SERIES&&s.reverse(),zle(a,t.coreGraph,r),PH(a,s,r),t.isolatedInExtract.length>0){let l=An(o,"g",ve.Scene.INEXTRACT);PH(l,t.isolatedInExtract,r)}else m0(o,"g",ve.Scene.INEXTRACT).remove();if(t.isolatedOutExtract.length>0){let l=An(o,"g",ve.Scene.OUTEXTRACT);PH(l,t.isolatedOutExtract,r)}else m0(o,"g",ve.Scene.OUTEXTRACT).remove();if(t.libraryFunctionsExtract.length>0){let l=An(o,"g",ve.Scene.FUNCTION_LIBRARY);PH(l,t.libraryFunctionsExtract,r)}else m0(o,"g",ve.Scene.FUNCTION_LIBRARY).remove();return Ple(o,t),i&&o.attr("opacity",0).transition().attr("opacity",1),o}var sur=.8,RH=class{constructor(t,r,n,i,o,a){this.svg=t,this.labelPadding=a,this.zoomG=r,this.mainZoom=n,this.maxWandH=o;let s=Ht(i.shadowRoot),l=s.select("svg"),c=l.select("rect"),u=f=>{this.viewpointCoord.x=qt.x,this.viewpointCoord.y=qt.y,this.updateViewpoint()};this.viewpointCoord={x:0,y:0};let h=pb().subject(Object).on("drag",u);c.datum(this.viewpointCoord).call(h),l.on("click",()=>{if(qt.defaultPrevented)return;let f=Number(c.attr("width")),p=Number(c.attr("height")),d=zo(l.node());this.viewpointCoord.x=d[0]-f/2,this.viewpointCoord.y=d[1]-p/2,this.updateViewpoint()}),this.viewpoint=c.node(),this.minimapSvg=l.node(),this.minimap=i,this.canvas=s.select("canvas.first").node(),this.canvasBuffer=s.select("canvas.second").node(),this.downloadCanvas=s.select("canvas.download").node(),Ht(this.downloadCanvas).style("display","none"),this.update()}updateViewpoint(){Ht(this.viewpoint).attr("x",this.viewpointCoord.x).attr("y",this.viewpointCoord.y);let t=-this.viewpointCoord.x*this.scaleMain/this.scaleMinimap,r=-this.viewpointCoord.y*this.scaleMain/this.scaleMinimap;Ht(this.svg).call(this.mainZoom.transform,Xh.translate(t,r).scale(this.scaleMain))}getImageBlob(){return new Promise(t=>{this.downloadCanvas.toBlob(r=>{t(r)},"image/png")})}update(){let t=null;try{if(t=this.zoomG.getBBox(),t.width===0)return}catch(p){return}let r=Ht(this.svg),n="",i=this.svg,a=(i.getRootNode?i.getRootNode():this.svg.parentNode).styleSheets;for(let p=0;p<a.length;p++)try{let d=a[p].cssRules||a[p].rules;if(d==null)continue;for(let g=0;g<d.length;g++)n+=d[g].cssText.replace(/ ?tf-[\w-]+ ?/g,"")+`
`}catch(d){if(d.name!=="SecurityError")throw d}let s=r.append("style");s.text(n);let l=Ht(this.zoomG),c=l.attr("transform");l.attr("transform",null),t.height+=t.y,t.width+=t.x,t.height+=this.labelPadding*2,t.width+=this.labelPadding*2,r.attr("width",t.width).attr("height",t.height),this.scaleMinimap=this.maxWandH/Math.max(t.width,t.height),this.minimapSize={width:t.width*this.scaleMinimap,height:t.height*this.scaleMinimap},Ht(this.minimapSvg).attr(this.minimapSize),Ht(this.canvasBuffer).attr(this.minimapSize);let u=Ht(this.downloadCanvas);u.style("width",t.width),u.style("height",t.height),u.attr("width",3*t.width),u.attr("height",3*t.height),this.translate!=null&&this.zoom!=null&&requestAnimationFrame(()=>this.zoom());let h=new XMLSerializer().serializeToString(this.svg);s.remove(),r.attr("width",null).attr("height",null),l.attr("transform",c);let f=new Image;f.onload=()=>{let p=this.canvasBuffer.getContext("2d");p==null||p.clearRect(0,0,this.canvasBuffer.width,this.canvasBuffer.height),p==null||p.drawImage(f,0,0,this.minimapSize.width,this.minimapSize.height),requestAnimationFrame(()=>{Ht(this.canvasBuffer).style("display",null),Ht(this.canvas).style("display","none"),[this.canvas,this.canvasBuffer]=[this.canvasBuffer,this.canvas]});let d=this.downloadCanvas.getContext("2d");d==null||d.clearRect(0,0,this.downloadCanvas.width,this.downloadCanvas.height),d==null||d.drawImage(f,0,0,this.downloadCanvas.width,this.downloadCanvas.height)},f.onerror=()=>{let p=new Blob([h],{type:"image/svg+xml;charset=utf-8"});f.src=URL.createObjectURL(p)},f.src="data:image/svg+xml;charset=utf-8,"+encodeURIComponent(h)}zoom(t){if(this.scaleMinimap==null)return;t&&(this.translate=[t.x,t.y],this.scaleMain=t.k);let r=this.svg.getBoundingClientRect(),n=Ht(this.viewpoint);this.viewpointCoord.x=-this.translate[0]*this.scaleMinimap/this.scaleMain,this.viewpointCoord.y=-this.translate[1]*this.scaleMinimap/this.scaleMain;let i=r.width*this.scaleMinimap/this.scaleMain,o=r.height*this.scaleMinimap/this.scaleMain;n.attr("x",this.viewpointCoord.x).attr("y",this.viewpointCoord.y).attr("width",i).attr("height",o);let a=this.minimapSize.width,s=this.minimapSize.height,l=this.viewpointCoord.x,c=this.viewpointCoord.y,u=Math.min(Math.max(0,l+i),a)-Math.min(Math.max(0,l),a),h=Math.min(Math.max(0,c+o),s)-Math.min(Math.max(0,c),s);u*h/(a*s)<sur?this.minimap.classList.remove("hidden"):this.minimap.classList.add("hidden")}};var nct=class extends mt{init(t,r,n,i,o){return new RH(t,r,n,this,i,o)}};nct.template=Q`
    <style>
      :host {
        background-color: white;
        transition: opacity 0.3s linear;
        pointer-events: auto;
      }

      :host(.hidden) {
        opacity: 0;
        pointer-events: none;
      }

      canvas {
        border: 1px solid #999;
      }

      rect {
        fill: white;
        stroke: #111111;
        stroke-width: 1px;
        fill-opacity: 0;
        filter: url(#minimapDropShadow);
        cursor: move;
      }

      svg {
        position: absolute;
      }
    </style>
    <svg>
      <defs>
        <filter
          id="minimapDropShadow"
          x="-20%"
          y="-20%"
          width="150%"
          height="150%"
        >
          <feOffset result="offOut" in="SourceGraphic" dx="1" dy="1"></feOffset>
          <feColorMatrix
            result="matrixOut"
            in="offOut"
            type="matrix"
            values="0.1 0 0 0 0 0 0.1 0 0 0 0 0 0.1 0 0 0 0 0 0.5 0"
          ></feColorMatrix>
          <feGaussianBlur
            result="blurOut"
            in="matrixOut"
            stdDeviation="2"
          ></feGaussianBlur>
          <feBlend in="SourceGraphic" in2="blurOut" mode="normal"></feBlend>
        </filter>
      </defs>
      <rect></rect>
    </svg>
    <canvas class="first"></canvas>
    <!-- Additional canvas to use as buffer to avoid flickering between updates -->
    <canvas class="second"></canvas>
    <canvas class="download"></canvas>
  `;nct=E([yt("tf-graph-minimap")],nct);var Kle=Q`
  <style>
    :host(.dark-mode) {
      filter: invert(1);
    }

    :host {
      display: flex;
      font-size: 20px;
      height: 100%;
      width: 100%;
    }

    #svg {
      flex: 1;
      font-family: Roboto, sans-serif;
      height: 100%;
      overflow: hidden;
      width: 100%;
    }

    #hidden {
      position: fixed;
      top: 0px;
      visibility: hidden;
    }

    text {
      user-select: none;
    }

    /* --- Node and annotation-node for Metanode --- */

    .meta > .nodeshape > rect,
    .meta > .annotation-node > rect {
      cursor: pointer;
      fill: hsl(0, 0%, 70%);
    }
    .node.meta.highlighted > .nodeshape > rect,
    .node.meta.highlighted > .annotation-node > rect {
      stroke-width: 2;
    }
    .annotation.meta.highlighted > .nodeshape > rect,
    .annotation.meta.highlighted > .annotation-node > rect {
      stroke-width: 1;
    }
    .meta.selected > .nodeshape > rect,
    .meta.selected > .annotation-node > rect {
      stroke: red;
      stroke-width: 2;
    }
    .node.meta.selected.expanded > .nodeshape > rect,
    .node.meta.selected.expanded > .annotation-node > rect {
      stroke: red;
      stroke-width: 3;
    }
    .annotation.meta.selected > .nodeshape > rect,
    .annotation.meta.selected > .annotation-node > rect {
      stroke: red;
      stroke-width: 2;
    }
    .node.meta.selected.expanded.highlighted > .nodeshape > rect,
    .node.meta.selected.expanded.highlighted > .annotation-node > rect {
      stroke: red;
      stroke-width: 4;
    }

    .faded,
    .faded rect,
    .faded ellipse,
    .faded path,
    .faded use,
    #rectHatch line,
    #ellipseHatch line {
      color: #e0d4b3 !important;
      fill: white;
      stroke: #e0d4b3 !important;
    }

    .faded path {
      stroke-width: 1px !important;
    }

    .faded rect {
      fill: url(#rectHatch) !important;
    }

    .faded ellipse,
    .faded use {
      fill: url(#ellipseHatch) !important;
    }

    .faded text {
      opacity: 0;
    }

    /* Rules used for input-tracing. */
    .input-highlight > * > rect,
    .input-highlight > * > ellipse,
    .input-highlight > * > use {
      fill: white;
      stroke: #ff9800 !important;
    }

    /*  - Faded non-input styling */
    .non-input > * > rect,
.non-input > * > ellipse,
.non-input > * > use,
/* For Const nodes. */
.non-input > * > .constant:not([class*="input-highlight"]) >
  .annotation-node > ellipse,
/* For styling of annotation nodes of non-input nodes. */
.non-input > g > .annotation > .annotation-node > rect {
      stroke: #e0d4b3 !important;
      stroke-width: inherit;
      stroke-dasharray: inherit;
    }

    .non-input path {
      visibility: hidden;
    }

    .non-input > .nodeshape > rect,
.non-input > .annotation-node > rect,
/* For styling of annotation nodes of non-input nodes. */
.non-input > g > .annotation > .annotation-node > rect {
      fill: url(#rectHatch) !important;
    }

    .non-input ellipse,
    .non-input use {
      fill: url(#ellipseHatch) !important;
    }

    .non-input > text {
      opacity: 0;
    }

    .non-input .annotation > .annotation-edge {
      marker-end: url(#annotation-arrowhead-faded);
    }

    .non-input .annotation > .annotation-edge.refline {
      marker-start: url(#ref-annotation-arrowhead-faded);
    }

    /* Input edges. */
    .input-edge-highlight > text {
      fill: black !important;
    }
    .input-highlight > .in-annotations > .annotation > .annotation-edge,
    .input-highlight-selected
      > .in-annotations
      > .annotation
      > .annotation-edge {
      stroke: #999 !important;
    }

    /* Non-input edges. */
    .non-input-edge-highlight,
.non-input > g > .annotation > path,
/* Annotation styles (label and edges respectively). */
.non-input > g >
.annotation:not(.input-highlight):not(.input-highlight-selected) >
.annotation-label
/*.annotation-edge*/ {
      visibility: hidden;
    }

    /* --- Op Node --- */

    .op > .nodeshape > .nodecolortarget,
    .op > .annotation-node > .nodecolortarget {
      cursor: pointer;
      fill: #fff;
      stroke: #ccc;
    }

    .op.selected > .nodeshape > .nodecolortarget,
    .op.selected > .annotation-node > .nodecolortarget {
      stroke: red;
      stroke-width: 2;
    }

    .op.highlighted > .nodeshape > .nodecolortarget,
    .op.highlighted > .annotation-node > .nodecolortarget {
      stroke-width: 2;
    }

    /* --- Series Node --- */

    /* By default, don't show the series background <rect>. */
    .series > .nodeshape > rect {
      fill: hsl(0, 0%, 70%);
      fill-opacity: 0;
      stroke-dasharray: 5, 5;
      stroke-opacity: 0;
      cursor: pointer;
    }

    /* Once expanded, show the series background <rect> and hide the <use>. */
    .series.expanded > .nodeshape > rect {
      fill-opacity: 0.15;
      stroke: hsl(0, 0%, 70%);
      stroke-opacity: 1;
    }
    .series.expanded > .nodeshape > use {
      visibility: hidden;
    }

    /**
 * TODO: Simplify this by applying a stable class name to all <g>
 * elements that currently have either the nodeshape or annotation-node classes.
 */
    .series > .nodeshape > use,
    .series > .annotation-node > use {
      stroke: #ccc;
    }
    .series.highlighted > .nodeshape > use,
    .series.highlighted > .annotation-node > use {
      stroke-width: 2;
    }
    .series.selected > .nodeshape > use,
    .series.selected > .annotation-node > use {
      stroke: red;
      stroke-width: 2;
    }

    .series.selected > .nodeshape > rect {
      stroke: red;
      stroke-width: 2;
    }

    .annotation.series.selected > .annotation-node > use {
      stroke: red;
      stroke-width: 2;
    }

    /* --- Bridge Node --- */
    .bridge > .nodeshape > rect {
      stroke: #f0f;
      opacity: 0.2;
      display: none;
    }

    /* --- Structural Elements --- */
    .edge > path.edgeline.structural {
      stroke: #f0f;
      opacity: 0.2;
      display: none;
    }

    /* Reference Edge */
    .edge > path.edgeline.referenceedge {
      stroke: #ffb74d;
      opacity: 1;
    }

    /* --- Series Nodes --- */

    /* Hide the rect for a series' annotation. */
    .series > .annotation-node > rect {
      display: none;
    }

    /* --- Node label --- */

    .node {
      /* Provide a hint to browsers to avoid using their static rasterization
      at initial scale, which looks very pixelated on Chromium when zoomed in.
      Note that we intentionally do *not* use 'will-change: transform' and
      'translateZ(0) here, which introduce blurriness on Firefox.
      See https://github.com/tensorflow/tensorboard/issues/4744 */
      transform: translateZ(1px);
    }

    .node > text.nodelabel {
      cursor: pointer;
      fill: #444;
    }

    .meta.expanded > text.nodelabel {
      font-size: 9px;
    }

    .series > text.nodelabel {
      font-size: 8px;
    }

    .op > text.nodelabel {
      font-size: 6px;
    }

    .bridge > text.nodelabel {
      display: none;
    }

    .node.meta.expanded > text.nodelabel {
      cursor: normal;
    }

    .annotation.meta.highlighted > text.annotation-label {
      fill: #50a3f7;
    }

    .annotation.meta.selected > text.annotation-label {
      fill: #4285f4;
    }

    /* --- Annotation --- */

    /* only applied for annotations that are not summary or constant.
(.summary, .constant gets overridden below) */
    .annotation > .annotation-node > * {
      stroke-width: 0.5;
      stroke-dasharray: 1, 1;
    }

    .annotation.summary > .annotation-node > *,
    .annotation.constant > .annotation-node > * {
      stroke-width: 1;
      stroke-dasharray: none;
    }

    .annotation > .annotation-edge {
      fill: none;
      stroke: #aaa;
      stroke-width: 0.5;
      marker-end: url(#annotation-arrowhead);
    }

    .faded .annotation > .annotation-edge {
      marker-end: url(#annotation-arrowhead-faded);
    }

    .annotation > .annotation-edge.refline {
      marker-start: url(#ref-annotation-arrowhead);
    }

    .faded .annotation > .annotation-edge.refline {
      marker-start: url(#ref-annotation-arrowhead-faded);
    }

    .annotation > .annotation-control-edge {
      stroke-dasharray: 1, 1;
    }

    #annotation-arrowhead {
      fill: #aaa;
    }

    #annotation-arrowhead-faded {
      fill: #e0d4b3;
    }

    #ref-annotation-arrowhead {
      fill: #aaa;
    }

    #ref-annotation-arrowhead-faded {
      fill: #e0d4b3;
    }

    .annotation > .annotation-label {
      font-size: 5px;
      cursor: pointer;
    }
    .annotation > .annotation-label.annotation-ellipsis {
      cursor: default;
    }

    /* Hide annotations on expanded meta nodes since they're redundant. */
    .expanded > .in-annotations,
    .expanded > .out-annotations {
      display: none;
    }

    /* --- Annotation: Constant --- */

    .constant > .annotation-node > ellipse {
      cursor: pointer;
      fill: white;
      stroke: #848484;
    }

    .constant.selected > .annotation-node > ellipse {
      fill: white;
      stroke: red;
    }

    .constant.highlighted > .annotation-node > ellipse {
      stroke-width: 1.5;
    }

    /* --- Annotation: Summary --- */

    .summary > .annotation-node > ellipse {
      cursor: pointer;
      fill: #db4437;
      stroke: #db4437;
    }

    .summary.selected > .annotation-node > ellipse {
      fill: #a52714;
      stroke: #a52714;
    }

    .summary.highlighted > .annotation-node > ellipse {
      stroke-width: 1.5;
    }

    /* --- Edge --- */

    .edge > path.edgeline {
      fill: none;
      stroke: #bbb;
      stroke-linecap: round;
      stroke-width: 0.75;
    }

    .edge .selectableedge {
      cursor: pointer;
    }

    .selectededge > path.edgeline {
      cursor: default;
      stroke: #f00;
    }

    .edge.selectededge text {
      fill: #000;
    }

    /* Labels showing tensor shapes on edges */
    .edge > text {
      font-size: 3.5px;
      fill: #666;
    }

    .dataflow-arrowhead {
      fill: #bbb;
    }

    .reference-arrowhead {
      fill: #ffb74d;
    }

    .selected-arrowhead {
      fill: #f00;
    }

    .edge .control-dep {
      stroke-dasharray: 2, 2;
    }

    /* --- Group node expand/collapse button --- */

    /* Hides expand/collapse buttons when a node isn't expanded or highlighted. Using
   incredibly small opacity so that the bounding box of the <g> parent still takes
   this container into account even when it isn't visible */
    .node:not(.highlighted):not(.expanded) > .nodeshape > .buttoncontainer {
      opacity: 0.01;
    }
    .node.highlighted > .nodeshape > .buttoncontainer {
      cursor: pointer;
    }
    .buttoncircle {
      fill: #e7811d;
    }
    .buttoncircle:hover {
      fill: #b96717;
    }
    .expandbutton,
    .collapsebutton {
      stroke: white;
    }
    /* Do not let the path elements in the button take pointer focus */
    .node > .nodeshape > .buttoncontainer > .expandbutton,
    .node > .nodeshape > .buttoncontainer > .collapsebutton {
      pointer-events: none;
    }
    /* Only show the expand button when a node is collapsed and only show the
   collapse button when a node is expanded. */
    .node.expanded > .nodeshape > .buttoncontainer > .expandbutton {
      display: none;
    }
    .node:not(.expanded) > .nodeshape > .buttoncontainer > .collapsebutton {
      display: none;
    }

    .health-pill-stats {
      font-size: 4px;
      text-anchor: middle;
    }

    .health-pill rect {
      filter: url(#health-pill-shadow);
      rx: 3;
      ry: 3;
    }

    .titleContainer {
      position: relative;
      top: 20px;
    }

    .title,
    .auxTitle,
    .functionLibraryTitle {
      position: absolute;
    }

    #minimap {
      position: absolute;
      right: 20px;
      bottom: 20px;
    }

    .context-menu {
      position: absolute;
      display: none;
      background-color: #e2e2e2;
      border-radius: 2px;
      font-size: 14px;
      min-width: 150px;
      border: 1px solid #d4d4d4;
    }

    .context-menu ul {
      list-style-type: none;
      margin: 0;
      padding: 0;
      cursor: default;
    }

    .context-menu ul li {
      padding: 4px 16px;
    }

    .context-menu ul li:hover {
      background-color: #f3913e;
      color: white;
    }
  </style>
  <div class="titleContainer">
    <div id="title" class="title">Main Graph</div>
    <div id="auxTitle" class="auxTitle">Auxiliary Nodes</div>
    <div id="functionLibraryTitle" class="functionLibraryTitle">Functions</div>
  </div>
  <svg id="svg">
    <defs>
      <!-- Arrow heads for reference edge paths of different predefined sizes per color. -->
      <path
        id="reference-arrowhead-path"
        d="M 0,0 L 10,5 L 0,10 C 3,7 3,3 0,0"
      ></path>
      <marker
        class="reference-arrowhead"
        id="reference-arrowhead-small"
        viewBox="0 0 10 10"
        markerWidth="5"
        markerHeight="5"
        refX="2"
        refY="5"
        orient="auto-start-reverse"
        markerUnits="userSpaceOnUse"
      >
        <use xlink:href="#reference-arrowhead-path"></use>
      </marker>
      <marker
        class="reference-arrowhead"
        id="reference-arrowhead-medium"
        viewBox="0 0 10 10"
        markerWidth="13"
        markerHeight="13"
        refX="2"
        refY="5"
        orient="auto-start-reverse"
        markerUnits="userSpaceOnUse"
      >
        <use xlink:href="#reference-arrowhead-path"></use>
      </marker>
      <marker
        class="reference-arrowhead"
        id="reference-arrowhead-large"
        viewBox="0 0 10 10"
        markerWidth="16"
        markerHeight="16"
        refX="2"
        refY="5"
        orient="auto-start-reverse"
        markerUnits="userSpaceOnUse"
      >
        <use xlink:href="#reference-arrowhead-path"></use>
      </marker>
      <marker
        class="reference-arrowhead"
        id="reference-arrowhead-xlarge"
        viewBox="0 0 10 10"
        markerWidth="20"
        markerHeight="20"
        refX="2"
        refY="5"
        orient="auto-start-reverse"
        markerUnits="userSpaceOnUse"
      >
        <use xlink:href="#reference-arrowhead-path"></use>
      </marker>

      <!-- Arrow heads for dataflow edge paths of different predefined sizes per color. -->
      <path
        id="dataflow-arrowhead-path"
        d="M 0,0 L 10,5 L 0,10 C 3,7 3,3 0,0"
      ></path>
      <marker
        class="dataflow-arrowhead"
        id="dataflow-arrowhead-small"
        viewBox="0 0 10 10"
        markerWidth="5"
        markerHeight="5"
        refX="2"
        refY="5"
        orient="auto-start-reverse"
        markerUnits="userSpaceOnUse"
      >
        <use xlink:href="#dataflow-arrowhead-path"></use>
      </marker>
      <marker
        class="dataflow-arrowhead"
        id="dataflow-arrowhead-medium"
        viewBox="0 0 10 10"
        markerWidth="13"
        markerHeight="13"
        refX="2"
        refY="5"
        orient="auto-start-reverse"
        markerUnits="userSpaceOnUse"
      >
        <use xlink:href="#dataflow-arrowhead-path"></use>
      </marker>
      <marker
        class="dataflow-arrowhead"
        id="dataflow-arrowhead-large"
        viewBox="0 0 10 10"
        markerWidth="16"
        markerHeight="16"
        refX="2"
        refY="5"
        orient="auto-start-reverse"
        markerUnits="userSpaceOnUse"
      >
        <use xlink:href="#dataflow-arrowhead-path"></use>
      </marker>
      <marker
        class="dataflow-arrowhead"
        id="dataflow-arrowhead-xlarge"
        viewBox="0 0 10 10"
        markerWidth="20"
        markerHeight="20"
        refX="2"
        refY="5"
        orient="auto-start-reverse"
        markerUnits="userSpaceOnUse"
      >
        <use xlink:href="#dataflow-arrowhead-path"></use>
      </marker>

      <!-- Arrow head for annotation edge paths. -->
      <marker
        id="annotation-arrowhead"
        markerWidth="5"
        markerHeight="5"
        refX="5"
        refY="2.5"
        orient="auto"
      >
        <path d="M 0,0 L 5,2.5 L 0,5 L 0,0"></path>
      </marker>
      <marker
        id="annotation-arrowhead-faded"
        markerWidth="5"
        markerHeight="5"
        refX="5"
        refY="2.5"
        orient="auto"
      >
        <path d="M 0,0 L 5,2.5 L 0,5 L 0,0"></path>
      </marker>
      <marker
        id="ref-annotation-arrowhead"
        markerWidth="5"
        markerHeight="5"
        refX="0"
        refY="2.5"
        orient="auto"
      >
        <path d="M 5,0 L 0,2.5 L 5,5 L 5,0"></path>
      </marker>
      <marker
        id="ref-annotation-arrowhead-faded"
        markerWidth="5"
        markerHeight="5"
        refX="0"
        refY="2.5"
        orient="auto"
      >
        <path d="M 5,0 L 0,2.5 L 5,5 L 5,0"></path>
      </marker>
      <!-- Template for an Op node ellipse. -->
      <ellipse
        id="op-node-stamp"
        rx="7.5"
        ry="3"
        stroke="inherit"
        fill="inherit"
      ></ellipse>
      <!-- Template for an Op node annotation ellipse (smaller). -->
      <ellipse
        id="op-node-annotation-stamp"
        rx="5"
        ry="2"
        stroke="inherit"
        fill="inherit"
      ></ellipse>
      <!-- Vertically stacked series of Op nodes when unexpanded. -->
      <g id="op-series-vertical-stamp">
        <use xlink:href="#op-node-stamp" x="8" y="9"></use>
        <use xlink:href="#op-node-stamp" x="8" y="6"></use>
        <use xlink:href="#op-node-stamp" x="8" y="3"></use>
      </g>
      <!-- Horizontally stacked series of Op nodes when unexpanded. -->
      <g id="op-series-horizontal-stamp">
        <use xlink:href="#op-node-stamp" x="16" y="4"></use>
        <use xlink:href="#op-node-stamp" x="12" y="4"></use>
        <use xlink:href="#op-node-stamp" x="8" y="4"></use>
      </g>
      <!-- Horizontally stacked series of Op nodes for annotation. -->
      <g id="op-series-annotation-stamp">
        <use xlink:href="#op-node-annotation-stamp" x="9" y="2"></use>
        <use xlink:href="#op-node-annotation-stamp" x="7" y="2"></use>
        <use xlink:href="#op-node-annotation-stamp" x="5" y="2"></use>
      </g>
      <svg
        id="summary-icon"
        fill="#848484"
        height="12"
        viewBox="0 0 24 24"
        width="12"
      >
        <path
          d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z"
        ></path>
      </svg>

      <!-- Hatch patterns for faded out nodes. -->
      <pattern
        id="rectHatch"
        patternTransform="rotate(45 0 0)"
        width="5"
        height="5"
        patternUnits="userSpaceOnUse"
      >
        <line x1="0" y1="0" x2="0" y2="5" style="stroke-width: 1"></line>
      </pattern>
      <pattern
        id="ellipseHatch"
        patternTransform="rotate(45 0 0)"
        width="2"
        height="2"
        patternUnits="userSpaceOnUse"
      >
        <line x1="0" y1="0" x2="0" y2="2" style="stroke-width: 1"></line>
      </pattern>

      <!-- A shadow for health pills. -->
      <filter
        id="health-pill-shadow"
        x="-40%"
        y="-40%"
        width="180%"
        height="180%"
      >
        <feGaussianBlur in="SourceAlpha" stdDeviation="0.8"></feGaussianBlur>
        <feOffset dx="0" dy="0" result="offsetblur"></feOffset>
        <feFlood flood-color="#000000"></feFlood>
        <feComposite in2="offsetblur" operator="in"></feComposite>
        <feMerge>
          <feMergeNode></feMergeNode>
          <feMergeNode in="SourceGraphic"></feMergeNode>
        </feMerge>
      </filter>
    </defs>
    <!-- Make a large rectangle that fills the svg space so that
  zoom events get captured on safari -->
    <rect fill="white" width="10000" height="10000"></rect>
    <g id="root"></g>
  </svg>
  <tf-graph-minimap id="minimap"></tf-graph-minimap>
  <div id="contextMenu" class="context-menu"></div>
`;var Lr=class extends Gt(_o(mt)){constructor(){super(...arguments),this._zoomed=!1,this._zoomStartCoords=null,this._zoomTransform=null,this._maxZoomDistanceForClick=20,this._nodeGroupIndex={},this._annotationGroupIndex={},this._edgeGroupIndex={},this.maxMetanodeLabelLengthFontSize=9,this.minMetanodeLabelLengthFontSize=6,this.maxMetanodeLabelLengthLargeFont=11,this.maxMetanodeLabelLength=18}getNode(t){return this.renderHierarchy.getRenderNodeByName(t)}isNodeExpanded(t){return t.expanded}setNodeExpanded(t){this._build(this.renderHierarchy),this._updateLabels(!this._zoomed)}panToNode(t){Ale(t,this.$.svg,this.$.root,this._zoom)&&(this._zoomed=!0)}getGraphSvgRoot(){return this.$.svg}getContextMenu(){return this.$.contextMenu}_resetState(){this._nodeGroupIndex={},this._annotationGroupIndex={},this._edgeGroupIndex={},this._updateLabels(!1),Ht(this.$.svg).select("#root").selectAll("*").remove(),LH(this.$.svg)}_build(t){this.templateIndex=t.hierarchy.getTemplateIndex(),Rd("tf-graph-scene (layout):",function(){MH(t.root)}.bind(this),jr.RENDER_SCENE_LAYOUT),Rd("tf-graph-scene (build scene):",function(){ect(Ht(this.$.root),t.root,this),Ile(this.$.svg,this),this._updateInputTrace()}.bind(this),jr.RENDER_SCENE_BUILD_SCENE),setTimeout(function(){this._updateHealthPills(this.nodeNamesToHealthPills,this.healthPillStepIndex),this.minimap.update()}.bind(this),Tr.animation.duration)}ready(){super.ready(),this._zoom=eR().on("end",function(){if(this._zoomStartCoords){var t=Math.sqrt(Math.pow(this._zoomStartCoords.x-this._zoomTransform.x,2)+Math.pow(this._zoomStartCoords.y-this._zoomTransform.y,2));t<this._maxZoomDistanceForClick?this._fireEnableClick():setTimeout(this._fireEnableClick.bind(this),50)}this._zoomStartCoords=null}.bind(this)).on("zoom",function(){this._zoomTransform=qt.transform,this._zoomStartCoords||(this._zoomStartCoords=this._zoomTransform,this.fire("disable-click")),this._zoomed=!0,Ht(this.$.root).attr("transform",qt.transform),this.minimap.zoom(qt.transform)}.bind(this)),Ht(this.$.svg).call(this._zoom).on("dblclick.zoom",null),Ht(window).on("resize",function(){this.minimap.zoom()}.bind(this)),this.minimap=this.$.minimap.init(this.$.svg,this.$.root,this._zoom,Tr.minimap.size,Tr.subscene.meta.labelHeight)}attached(){this.set("_isAttached",!0)}detached(){this.set("_isAttached",!1)}_renderHierarchyChanged(){var t=this.renderHierarchy;this._hasRenderHierarchyBeenFitOnce=!1,this._resetState(),this._build(t)}_animateAndFit(){var t=this._isAttached;this._hasRenderHierarchyBeenFitOnce||!t||setTimeout(this.fit.bind(this),Tr.animation.duration)}_updateLabels(t){var r=this.$$(".title"),n=r.style,i=this.$$(".auxTitle"),o=i.style,a=this.$$(".functionLibraryTitle").style;let s=Ht(this.$.svg);var l=s.select("."+Hi.Scene.GROUP+">."+Hi.Scene.CORE).node();if(t&&l&&this.progress&&this.progress.value===100){var c=s.select("."+Hi.Scene.GROUP+">."+Hi.Scene.INEXTRACT).node()||s.select("."+Hi.Scene.GROUP+">."+Hi.Scene.OUTEXTRACT).node(),u=l.getCTM().e,h=c?c.getCTM().e:null;n.display="inline",n.left=u+"px",h!==null&&h!==u?(o.display="inline",h=Math.max(u+r.getBoundingClientRect().width,h),o.left=h+"px"):o.display="none";let f=s.select("."+Hi.Scene.GROUP+">."+Hi.Scene.FUNCTION_LIBRARY).node(),p=f?f.getCTM().e:null;p!==null&&p!==h?(a.display="inline",p=Math.max(h+i.getBoundingClientRect().width,p),a.left=p+"px"):a.display="none"}else n.display="none",o.display="none",a.display="none"}nodeColorsChanged(){this.renderHierarchy!=null&&(this.templateIndex=this.renderHierarchy.hierarchy.getTemplateIndex(),mP.each(this._nodeGroupIndex,(t,r)=>{this._updateNodeState(r)}),this.minimap.update())}fit(){this._hasRenderHierarchyBeenFitOnce=!0,Cle(this.$.svg,this.$.root,this._zoom,function(){this._zoomed=!1}.bind(this))}getImageBlob(){return this.minimap.getImageBlob()}isNodeSelected(t){return t===this.selectedNode}isNodeHighlighted(t){return t===this.highlightedNode}addAnnotationGroup(t,r,n){var i=t.node.name;this._annotationGroupIndex[i]=this._annotationGroupIndex[i]||{},this._annotationGroupIndex[i][r.node.name]=n}getAnnotationGroupsIndex(t){return this._annotationGroupIndex[t]}removeAnnotationGroup(t,r){delete this._annotationGroupIndex[t.node.name][r.node.name]}addNodeGroup(t,r){this._nodeGroupIndex[t]=r}getNodeGroup(t){return this._nodeGroupIndex[t]}removeNodeGroup(t){delete this._nodeGroupIndex[t]}addEdgeGroup(t,r){this._edgeGroupIndex[t]=r}getEdgeGroup(t){return this._edgeGroupIndex[t]}_updateHealthPills(){var t=this.nodeNamesToHealthPills,r=this.healthPillStepIndex;Rle(this.$.svg,t,r)}_updateNodeState(t){var r=this.getNode(t),n=this.getNodeGroup(t);if(n&&s3(n,r,this),r.node.type===jt.META&&r.node.associatedFunction&&!r.isLibraryFunction){var i=Sa+r.node.associatedFunction,o=Ht("."+Hi.Scene.GROUP+">."+Hi.Scene.FUNCTION_LIBRARY+' g[data-name="'+i+'"]');s3(o,r,this)}var a=this.getAnnotationGroupsIndex(t);mP.each(a,(s,l)=>{s3(s,r,this,Hi.Annotation.NODE)})}_selectedNodeChanged(t,r){if(t!==r&&(r&&this._updateNodeState(r),!!t)){this.minimap.update();for(var n=this.renderHierarchy.hierarchy.node(t),i=[];n.parentNode!=null&&n.parentNode.name!=qc;)n=n.parentNode,i.push(n.name);var o;mP.forEachRight(i,a=>{this.renderHierarchy.buildSubhierarchy(a);var s=this.renderHierarchy.getRenderNodeByName(a);s.node.isGroupNode&&!s.expanded&&(s.expanded=!0,o||(o=s))}),o&&(this.setNodeExpanded(o),this._zoomed=!0),t&&this._updateNodeState(t),setTimeout(()=>{this.panToNode(t)},Tr.animation.duration)}}_highlightedNodeChanged(t,r){t!==r&&(t&&this._updateNodeState(t),r&&this._updateNodeState(r))}_onZoomChanged(){this._updateLabels(!this._zoomed)}_fireEnableClick(){this.fire("enable-click")}_updateInputTrace(){Yle(this.getGraphSvgRoot(),this.renderHierarchy,this.selectedNode,this.traceInputs)}};Lr.template=Kle;E([A({type:Object}),w("design:type",lo)],Lr.prototype,"renderHierarchy",void 0);E([A({type:String}),w("design:type",String)],Lr.prototype,"name",void 0);E([A({type:String}),w("design:type",String)],Lr.prototype,"colorBy",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Lr.prototype,"traceInputs",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Lr.prototype,"_hasRenderHierarchyBeenFitOnce",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Lr.prototype,"_isAttached",void 0);E([A({type:Object}),w("design:type",Object)],Lr.prototype,"_zoom",void 0);E([A({type:String,observer:"_highlightedNodeChanged"}),w("design:type",String)],Lr.prototype,"highlightedNode",void 0);E([A({type:String,observer:"_selectedNodeChanged"}),w("design:type",String)],Lr.prototype,"selectedNode",void 0);E([A({type:Object}),w("design:type",Object)],Lr.prototype,"handleEdgeSelected",void 0);E([A({type:Boolean,observer:"_onZoomChanged"}),w("design:type",Boolean)],Lr.prototype,"_zoomed",void 0);E([A({type:Object}),w("design:type",Object)],Lr.prototype,"_zoomStartCoords",void 0);E([A({type:Object}),w("design:type",Object)],Lr.prototype,"_zoomTransform",void 0);E([A({type:Number}),w("design:type",Number)],Lr.prototype,"_maxZoomDistanceForClick",void 0);E([A({type:Object}),w("design:type",Function)],Lr.prototype,"templateIndex",void 0);E([A({type:Object}),w("design:type",Object)],Lr.prototype,"_nodeGroupIndex",void 0);E([A({type:Object}),w("design:type",Object)],Lr.prototype,"_annotationGroupIndex",void 0);E([A({type:Object}),w("design:type",Object)],Lr.prototype,"_edgeGroupIndex",void 0);E([A({type:Number}),w("design:type",Number)],Lr.prototype,"maxMetanodeLabelLengthFontSize",void 0);E([A({type:Number}),w("design:type",Number)],Lr.prototype,"minMetanodeLabelLengthFontSize",void 0);E([A({type:Number}),w("design:type",Number)],Lr.prototype,"maxMetanodeLabelLengthLargeFont",void 0);E([A({type:Number}),w("design:type",Number)],Lr.prototype,"maxMetanodeLabelLength",void 0);E([A({type:Object}),w("design:type",Object)],Lr.prototype,"progress",void 0);E([A({type:Array}),w("design:type",Array)],Lr.prototype,"nodeContextMenuItems",void 0);E([A({type:Object}),w("design:type",Object)],Lr.prototype,"nodeNamesToHealthPills",void 0);E([A({type:Number}),w("design:type",Number)],Lr.prototype,"healthPillStepIndex",void 0);E([Bt("renderHierarchy"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Lr.prototype,"_renderHierarchyChanged",null);E([Bt("_isAttached","renderHierarchy"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Lr.prototype,"_animateAndFit",null);E([Bt("colorBy"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Lr.prototype,"nodeColorsChanged",null);E([Bt("nodeNamesToHealthPills","healthPillStepIndex"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Lr.prototype,"_updateHealthPills",null);E([Bt("traceInputs","selectedNode"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Lr.prototype,"_updateInputTrace",null);Lr=E([yt("tf-graph-scene")],Lr);var Dr=class extends Gt(mt){constructor(){super(...arguments),this._renderDepth=1,this._allowGraphSelect=!0,this.edgeWidthFunction="",this.handleNodeSelected="",this.edgeLabelFunction="",this.handleEdgeSelected=""}panToNode(t){this.$$("tf-graph-scene").panToNode(t)}_autoExtractNodesChanged(){var t=this.graphHierarchy;if(!!t){for(let r of Object.values(t.getNodeMap()))r.include=ur.UNSPECIFIED;this._buildRenderHierarchy(t)}}_buildNewRenderHierarchy(){var t=this.graphHierarchy;!t||this._buildRenderHierarchy(t)}_statsChanged(){var t=this.stats,r=this.devicesForStats;this.graphHierarchy&&(t&&r&&(ale(this.basicGraph,t,r),ple(this.graphHierarchy,t)),this._buildRenderHierarchy(this.graphHierarchy))}ready(){super.ready(),this.addEventListener("graph-select",this._graphSelected.bind(this)),this.addEventListener("disable-click",this._disableClick.bind(this)),this.addEventListener("enable-click",this._enableClick.bind(this)),this.addEventListener("node-toggle-expand",this._nodeToggleExpand.bind(this)),this.addEventListener("node-select",this._nodeSelected.bind(this)),this.addEventListener("node-highlight",this._nodeHighlighted.bind(this)),this.addEventListener("node-unhighlight",this._nodeUnhighlighted.bind(this)),this.addEventListener("node-toggle-extract",this._nodeToggleExtract.bind(this)),this.addEventListener("node-toggle-seriesgroup",this._nodeToggleSeriesGroup.bind(this)),this.addEventListener("edge-select",this._edgeSelected.bind(this)),this.addEventListener("annotation-select",this._nodeSelected.bind(this)),this.addEventListener("annotation-highlight",this._nodeHighlighted.bind(this)),this.addEventListener("annotation-unhighlight",this._nodeUnhighlighted.bind(this))}_buildRenderHierarchy(t){if(t.root.type!==jt.META)return;let r=this,n=Rd("new tf_graph_render.Hierarchy",()=>{let i=new lo(t,!!this.stats,this.autoExtractNodes);i.edgeLabelFunction=this.edgeLabelFunction,i.edgeWidthFunction=this.edgeWidthFunction;function o(a){return{minValue:a.domain()[0],maxValue:a.domain()[1],startColor:a.range()[0],endColor:a.range()[1]}}return r._setColorByParams({compute_time:o(i.computeTimeScale),memory:o(i.memoryUsageScale),device:ict.map(i.deviceColorMap.domain(),function(a){return{device:a,color:i.deviceColorMap(a)}}),xla_cluster:ict.map(i.xlaClusterColorMap.domain(),function(a){return{xla_cluster:a,color:i.xlaClusterColorMap(a)}})}),i},jr.RENDER_BUILD_HIERARCHY);r._setRenderHierarchy(n)}_getVisible(t){return t&&this.renderHierarchy.getNearestVisibleAncestor(t)}fit(){this.$.scene.fit()}getImageBlob(){return this.$.scene.getImageBlob()}_graphChanged(){!this.graphHierarchy||(this.graphHierarchy.addListener(Dd.TEMPLATES_UPDATED,()=>{this.$.scene.nodeColorsChanged()}),this.fire("graph-select"))}_graphSelected(t){this._allowGraphSelect&&(this.set("selectedNode",null),this.set("selectedEdge",null)),this._allowGraphSelect=!0}_disableClick(t){this._allowGraphSelect=!1}_enableClick(t){this._allowGraphSelect=!0}_selectedNodeChanged(){var t=this.selectedNode;this.handleNodeSelected&&this.handleNodeSelected(t)}_selectedEdgeChanged(){var t=this.selectedEdge;this._deselectPreviousEdge(),t&&(this._lastSelectedEdgeGroup.classed(Hi.Edge.SELECTED,!0),this._updateMarkerOfSelectedEdge(t)),this.handleEdgeSelected&&this.handleEdgeSelected(t)}_nodeSelected(t){this._allowGraphSelect&&this.set("selectedNode",t.detail.name),this._allowGraphSelect=!0}_edgeSelected(t){this._allowGraphSelect&&(this.set("_lastSelectedEdgeGroup",t.detail.edgeGroup),this.set("selectedEdge",t.detail.edgeData)),this._allowGraphSelect=!0}_nodeHighlighted(t){this.set("highlightedNode",t.detail.name)}_nodeUnhighlighted(t){this.set("highlightedNode",null)}_nodeToggleExpand(t){this._nodeSelected(t);var r=t.detail.name,n=this.renderHierarchy.getRenderNodeByName(r);n.node.type!==jt.OP&&(this.renderHierarchy.buildSubhierarchy(r),n.expanded=!n.expanded,this.async(function(){this.$.scene.setNodeExpanded(n)},75),Po({actionId:jr.NODE_EXPANSION_TOGGLED,eventLabel:n.expanded?"expanded":"collapsed"}))}_nodeToggleExtract(t){var r=t.detail.name;this.nodeToggleExtract(r)}nodeToggleExtract(t){let r=this.renderHierarchy.getRenderNodeByName(t);r.node.include==ur.INCLUDE?r.node.include=ur.EXCLUDE:r.node.include==ur.EXCLUDE?r.node.include=ur.INCLUDE:r.node.include=this.renderHierarchy.isNodeAuxiliary(r)?ur.INCLUDE:ur.EXCLUDE,this._buildRenderHierarchy(this.graphHierarchy),Po({actionId:jr.NODE_AUXILIARY_EXTRACTION_CHANGED,eventLabel:r.node.include===ur.INCLUDE?"Auxiliary to Main":"Main to Auxiliary"})}_nodeToggleSeriesGroup(t){var r=t.detail.name;this.nodeToggleSeriesGroup(r)}nodeToggleSeriesGroup(t){this.set("progress",{value:0,msg:""});var r=nP(this),n=JS(r,100,"Namespace hierarchy");let i=Mx(Kl({},this.hierarchyParams),{seriesMap:this.graphHierarchy.buildSeriesGroupMapToggled(t)});bH(this.basicGraph,i,n).then(function(o){this.set("graphHierarchy",o),this._buildRenderHierarchy(this.graphHierarchy)}.bind(this))}_deselectPreviousEdge(){let t="."+Hi.Edge.SELECTED;Ht(t).classed(Hi.Edge.SELECTED,!1).each((r,n)=>{if(r.label){let i=Ht(this).selectAll("path.edgeline");r.label.startMarkerId&&i.style("marker-start",`url(#${r.label.startMarkerId})`),r.label.endMarkerId&&i.style("marker-end",`url(#${r.label.endMarkerId})`)}})}_updateMarkerOfSelectedEdge(t){var r;if(t.label){let n=t.label.startMarkerId||t.label.endMarkerId;if(n){let i=n.replace("dataflow-","selected-"),o=this.$$("#"+i);if(!o){let s=this.$.scene.querySelector("#"+n);o=s==null?void 0:s.cloneNode(!0),o.setAttribute("id",i),o.classList.add("selected-arrowhead"),(r=s==null?void 0:s.parentNode)==null||r.appendChild(o)}let a=t.label.startMarkerId?"marker-start":"marker-end";this._lastSelectedEdgeGroup.selectAll("path.edgeline").style(a,`url(#${i})`)}}}not(t){return!t}};Dr.template=Q`
    <style>
      .container {
        width: 100%;
        height: 100%;
        background: white;
        box-shadow: 0 1px 5px rgba(0, 0, 0, 0.2);
      }

      .vertical {
        width: 100%;
        height: 100%;
        @apply --layout-vertical;
      }

      .auto {
        @apply --layout-flex-auto;
        @apply --layout-vertical;
      }

      h2 {
        text-align: center;
      }

      paper-button {
        text-transform: none;
      }
    </style>
    <div class="container">
      <div class="vertical">
        <template is="dom-if" if="[[title]]">
          <h2>[[title]]</h2>
        </template>
        <tf-graph-scene
          id="scene"
          class="auto"
          render-hierarchy="[[renderHierarchy]]"
          highlighted-node="[[_getVisible(highlightedNode)]]"
          selected-node="{{selectedNode}}"
          selected-edge="{{selectedEdge}}"
          color-by="[[colorBy]]"
          progress="[[progress]]"
          node-context-menu-items="[[nodeContextMenuItems]]"
          node-names-to-health-pills="[[nodeNamesToHealthPills]]"
          health-pill-step-index="{{healthPillStepIndex}}"
          handle-edge-selected="[[handleEdgeSelected]]"
          trace-inputs="[[traceInputs]]"
        ></tf-graph-scene>
      </div>
    </div>
  `;E([A({type:Object,notify:!0,observer:"_graphChanged"}),w("design:type",os)],Dr.prototype,"graphHierarchy",void 0);E([A({type:Object}),w("design:type",Xu)],Dr.prototype,"basicGraph",void 0);E([A({type:Object}),w("design:type",Object)],Dr.prototype,"stats",void 0);E([A({type:Object}),w("design:type",Object)],Dr.prototype,"devicesForStats",void 0);E([A({type:Object}),w("design:type",Object)],Dr.prototype,"hierarchyParams",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],Dr.prototype,"progress",void 0);E([A({type:String}),w("design:type",String)],Dr.prototype,"title",void 0);E([A({type:String,notify:!0}),w("design:type",String)],Dr.prototype,"selectedNode",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],Dr.prototype,"selectedEdge",void 0);E([A({type:Object}),w("design:type",Object)],Dr.prototype,"_lastSelectedEdgeGroup",void 0);E([A({type:String,notify:!0}),w("design:type",String)],Dr.prototype,"highlightedNode",void 0);E([A({type:String}),w("design:type",String)],Dr.prototype,"colorBy",void 0);E([A({type:Object,notify:!0,readOnly:!0}),w("design:type",Object)],Dr.prototype,"colorByParams",void 0);E([A({type:Object,readOnly:!0,notify:!0}),w("design:type",lo)],Dr.prototype,"renderHierarchy",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Dr.prototype,"traceInputs",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Dr.prototype,"autoExtractNodes",void 0);E([A({type:Array}),w("design:type",Array)],Dr.prototype,"nodeContextMenuItems",void 0);E([A({type:Number}),w("design:type",Number)],Dr.prototype,"_renderDepth",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Dr.prototype,"_allowGraphSelect",void 0);E([A({type:Object}),w("design:type",Object)],Dr.prototype,"nodeNamesToHealthPills",void 0);E([A({type:Number}),w("design:type",Number)],Dr.prototype,"healthPillStepIndex",void 0);E([A({type:Object}),w("design:type",Object)],Dr.prototype,"edgeWidthFunction",void 0);E([A({type:Object}),w("design:type",Object)],Dr.prototype,"handleNodeSelected",void 0);E([A({type:Object}),w("design:type",Object)],Dr.prototype,"edgeLabelFunction",void 0);E([A({type:Object}),w("design:type",Object)],Dr.prototype,"handleEdgeSelected",void 0);E([Bt("autoExtractNodes"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Dr.prototype,"_autoExtractNodesChanged",null);E([Bt("graphHierarchy","edgeWidthFunction","handleNodeSelected","edgeLabelFunction","handleEdgeSelected"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Dr.prototype,"_buildNewRenderHierarchy",null);E([Bt("stats","devicesForStats"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Dr.prototype,"_statsChanged",null);E([Bt("selectedNode"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Dr.prototype,"_selectedNodeChanged",null);E([Bt("selectedEdge"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Dr.prototype,"_selectedEdgeChanged",null);Dr=E([yt("tf-graph")],Dr);var co=class extends Gt(mt){constructor(){super(...arguments),this.specificHealthPillStep=0,this.healthPillEntries=fP}ready(){super.ready();var t=document.getElementById("mainContainer"),r=document.querySelector("tf-dashboard-layout .scrollbar");t&&r&&(t.style.overflow="hidden",r.style.overflow="hidden")}_healthPillsAvailable(t,r){return t&&r}_computeTensorCountString(t,r){return t?t[r].toFixed(0):""}get healthPillValuesForSelectedNode(){var t=this.nodeNamesToHealthPills,r=this.healthPillStepIndex,n=this.selectedNode,i=this.allStepsModeEnabled,o=this.areHealthPillsLoading;if(o||!n)return null;let a=t[n];if(!a)return null;let s=a[i?0:r];return s?s.value.slice(2,8):null}get _currentStepDisplayValue(){var t=this.nodeNamesToHealthPills,r=this.healthPillStepIndex,n=this.allStepsModeEnabled,i=this.specificHealthPillStep,o=this.areHealthPillsLoading;if(n)return i.toFixed(0);if(o)return 0;for(let a in t)return t[a][r].step.toFixed(0);return 0}get _biggestStepEverSeen(){var t=this.nodeNamesToHealthPills;for(let n in t){var r=t[n];return Math.max(this._biggestStepEverSeen,r[r.length-1].step)}return this._biggestStepEverSeen||0}get _maxStepIndex(){var t=this.nodeNamesToHealthPills;for(let r in t)return t[r].length-1;return 0}_hasDebuggerNumericAlerts(t){return t&&t.length}_updateAlertsList(){var t=this.debuggerNumericAlerts,r=this.$$("#numeric-alerts-body");if(!!r){r.innerText="";for(var n=0;n<t.length;n++){var i=t[n],o=document.createElement("tr"),a=document.createElement("td");a.innerText=Qse(i.first_timestamp),a.classList.add("first-offense-td"),o.appendChild(a);var s=document.createElement("td");s.classList.add("tensor-device-td");var l=document.createElement("div");l.classList.add("tensor-section-within-table"),l.innerText=i.tensor_name,this._addOpExpansionListener(l,i.tensor_name),s.appendChild(l);var c=document.createElement("div");c.classList.add("device-section-within-table"),c.innerText="("+i.device_name+")",s.appendChild(c),o.appendChild(s);var u=document.createElement("div");u.classList.add("mini-health-pill");var h=document.createElement("td");if(h.classList.add("mini-health-pill-td"),h.appendChild(u),o.appendChild(h),i.neg_inf_event_count){var f=document.createElement("div");f.classList.add("negative-inf-mini-health-pill-section"),f.innerText=i.neg_inf_event_count,f.setAttribute("title",i.neg_inf_event_count+" events with -\u221E"),u.appendChild(f)}if(i.pos_inf_event_count){var p=document.createElement("div");p.classList.add("positive-inf-mini-health-pill-section"),p.innerText=i.pos_inf_event_count,p.setAttribute("title",i.pos_inf_event_count+" events with +\u221E"),u.appendChild(p)}if(i.nan_event_count){var d=document.createElement("div");d.classList.add("nan-mini-health-pill-section"),d.innerText=i.nan_event_count,d.setAttribute("title",i.nan_event_count+" events with NaN"),u.appendChild(d)}zt(r).appendChild(o)}}}_addOpExpansionListener(t,r){t.addEventListener("click",()=>{var n=xle(document.getElementById("scene"),this.renderHierarchy,r),i,o=document.querySelector("tf-graph-info#graph-info");o&&(i=o.scrollHeight-o.scrollTop);var a=this.selectedNode;this.set("selectedNode",n);var s=()=>{o.scrollTop=o.scrollHeight-i};o&&(a?s():window.setTimeout(s,20))})}};co.template=Q`
    <style>
      :host {
        font-size: 12px;
        margin: 0;
        padding: 0;
        display: block;
      }

      h2 {
        padding: 0;
        text-align: center;
        margin: 0;
      }

      .health-pill-legend {
        padding: 15px;
      }

      .health-pill-legend h2 {
        text-align: left;
      }

      .health-pill-entry {
        margin: 10px 10px 10px 0;
      }

      .health-pill-entry .color-preview {
        width: 26px;
        height: 26px;
        border-radius: 3px;
        display: inline-block;
        margin: 0 10px 0 0;
      }

      .health-pill-entry .color-label,
      .health-pill-entry .tensor-count {
        color: #777;
        display: inline-block;
        height: 26px;
        font-size: 22px;
        line-height: 26px;
        vertical-align: top;
      }

      .health-pill-entry .tensor-count {
        float: right;
      }

      #health-pill-step-slider {
        width: 100%;
        margin: 0 0 0 -15px;
        /* 31 comes from adding a padding of 15px from both sides of the paper-slider, subtracting
   * 1px so that the slider width aligns with the image (the last slider marker takes up 1px),
   * and adding 2px to account for a border of 1px on both sides of the image. 30 - 1 + 2.
   * Apparently, the paper-slider lacks a mixin for those padding values. */
        width: calc(100% + 31px);
      }

      #health-pills-loading-spinner {
        width: 20px;
        height: 20px;
        vertical-align: top;
      }

      #health-pill-step-number-input {
        text-align: center;
        vertical-align: top;
      }

      #numeric-alerts-table-container {
        max-height: 400px;
        overflow-x: hidden;
        overflow-y: auto;
      }

      #numeric-alerts-table {
        text-align: left;
      }

      #numeric-alerts-table td {
        vertical-align: top;
      }

      #numeric-alerts-table .first-offense-td {
        display: inline-block;
      }

      .first-offense-td {
        width: 80px;
      }

      .tensor-device-td {
        max-width: 140px;
        word-wrap: break-word;
      }

      .tensor-section-within-table {
        color: #266236;
        cursor: pointer;
        opacity: 0.8;
        text-decoration: underline;
      }

      .tensor-section-within-table:hover {
        opacity: 1;
      }

      .device-section-within-table {
        color: #666;
      }

      .mini-health-pill {
        width: 130px;
      }

      .mini-health-pill > div {
        height: 100%;
        width: 60px;
        border-radius: 3px;
      }

      #event-counts-th {
        padding: 0 0 0 10px;
      }

      .negative-inf-mini-health-pill-section {
        background: rgb(255, 141, 0);
        width: 20px;
      }

      .positive-inf-mini-health-pill-section {
        background: rgb(0, 62, 212);
        width: 20px;
      }

      .nan-mini-health-pill-section {
        background: rgb(204, 47, 44);
        width: 20px;
      }

      .negative-inf-mini-health-pill-section,
      .positive-inf-mini-health-pill-section,
      .nan-mini-health-pill-section {
        color: #fff;
        display: inline-block;
        height: 100%;
        line-height: 20px;
        margin: 0 0 0 10px;
        text-align: center;
      }

      .no-numeric-alerts-notification {
        margin: 0;
      }
    </style>
    <paper-material elevation="1" class="card health-pill-legend">
      <div class="title">
        Enable all (not just sampled) steps. Requires slow disk read.
      </div>
      <paper-toggle-button
        id="enableAllStepsModeToggle"
        checked="{{allStepsModeEnabled}}"
      >
      </paper-toggle-button>
      <h2>
        Step of Health Pills:
        <template is="dom-if" if="[[allStepsModeEnabled]]">
          <input
            type="number"
            id="health-pill-step-number-input"
            min="0"
            max="[[_biggestStepEverSeen]]"
            value="{{specificHealthPillStep::input}}"
          />
        </template>
        <template is="dom-if" if="[[!allStepsModeEnabled]]">
          [[_currentStepDisplayValue]]
        </template>
        <paper-spinner-lite
          active
          hidden$="[[!areHealthPillsLoading]]"
          id="health-pills-loading-spinner"
        ></paper-spinner-lite>
      </h2>
      <template is="dom-if" if="[[allStepsModeEnabled]]">
        <paper-slider
          id="health-pill-step-slider"
          immediate-value="{{specificHealthPillStep}}"
          max="[[_biggestStepEverSeen]]"
          snaps
          step="1"
          value="{{specificHealthPillStep}}"
        ></paper-slider>
      </template>
      <template is="dom-if" if="[[!allStepsModeEnabled]]">
        <template is="dom-if" if="[[_maxStepIndex]]">
          <paper-slider
            id="health-pill-step-slider"
            immediate-value="{{healthPillStepIndex}}"
            max="[[_maxStepIndex]]"
            snaps
            step="1"
            value="{{healthPillStepIndex}}"
          ></paper-slider>
        </template>
      </template>
      <h2>
        Health Pill
        <template is="dom-if" if="[[healthPillValuesForSelectedNode]]">
          Counts for Selected Node
        </template>
        <template is="dom-if" if="[[!healthPillValuesForSelectedNode]]">
          Legend
        </template>
      </h2>
      <template is="dom-repeat" items="[[healthPillEntries]]">
        <div class="health-pill-entry">
          <div
            class="color-preview"
            style="background:[[item.background_color]]"
          ></div>
          <div class="color-label">[[item.label]]</div>
          <div class="tensor-count">
            [[_computeTensorCountString(healthPillValuesForSelectedNode,
            index)]]
          </div>
        </div>
      </template>
      <div hidden$="[[!_hasDebuggerNumericAlerts(debuggerNumericAlerts)]]">
        <h2 id="numeric-alerts-header">Numeric Alerts</h2>
        <p>Alerts are sorted from top to bottom by increasing timestamp.</p>
        <div id="numeric-alerts-table-container">
          <table id="numeric-alerts-table">
            <thead>
              <tr>
                <th>First Offense</th>
                <th>Tensor (Device)</th>
                <th id="event-counts-th">Event Counts</th>
              </tr>
            </thead>
            <tbody id="numeric-alerts-body"></tbody>
          </table>
        </div>
      </div>
      <template
        is="dom-if"
        if="[[!_hasDebuggerNumericAlerts(debuggerNumericAlerts)]]"
      >
        <p class="no-numeric-alerts-notification">
          No numeric alerts so far. That is likely good. Alerts indicate the
          presence of NaN or (+/-) Infinity values, which may be concerning.
        </p>
      </template>
    </paper-material>
  `;E([A({type:Object}),w("design:type",lo)],co.prototype,"renderHierarchy",void 0);E([A({type:Array,notify:!0}),w("design:type",Object)],co.prototype,"debuggerNumericAlerts",void 0);E([A({type:Object}),w("design:type",Object)],co.prototype,"nodeNamesToHealthPills",void 0);E([A({type:Number,notify:!0}),w("design:type",Object)],co.prototype,"healthPillStepIndex",void 0);E([A({type:Number,notify:!0}),w("design:type",Number)],co.prototype,"specificHealthPillStep",void 0);E([A({type:String,notify:!0}),w("design:type",Object)],co.prototype,"selectedNode",void 0);E([A({type:String,notify:!0}),w("design:type",Object)],co.prototype,"highlightedNode",void 0);E([A({type:Number,notify:!0}),w("design:type",Object)],co.prototype,"selectedNodeInclude",void 0);E([A({type:Boolean}),w("design:type",Object)],co.prototype,"areHealthPillsLoading",void 0);E([A({type:Array}),w("design:type",Array)],co.prototype,"healthPillEntries",void 0);E([A({type:Boolean,notify:!0}),w("design:type",Object)],co.prototype,"allStepsModeEnabled",void 0);E([Rt("nodeNamesToHealthPills","healthPillStepIndex","selectedNode","allStepsModeEnabled","areHealthPillsLoading"),w("design:type",Object),w("design:paramtypes",[])],co.prototype,"healthPillValuesForSelectedNode",null);E([Rt("nodeNamesToHealthPills","healthPillStepIndex","allStepsModeEnabled","specificHealthPillStep","areHealthPillsLoading"),w("design:type",Object),w("design:paramtypes",[])],co.prototype,"_currentStepDisplayValue",null);E([Rt("nodeNamesToHealthPills"),w("design:type",Number),w("design:paramtypes",[])],co.prototype,"_biggestStepEverSeen",null);E([Rt("nodeNamesToHealthPills"),w("design:type",Number),w("design:paramtypes",[])],co.prototype,"_maxStepIndex",null);E([Bt("debuggerNumericAlerts"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],co.prototype,"_updateAlertsList",null);co=E([yt("tf-graph-debugger-data-card")],co);var oct={};Ks(oct,{GraphIconType:()=>n1});var n1;(function(e){e.CONST="CONST",e.META="META",e.OP="OP",e.SERIES="SERIES",e.SUMMARY="SUMMARY"})(n1||(n1={}));var Zu=class extends Gt(_o(mt)){constructor(){super(...arguments),this.vertical=!1,this.fillOverride=null,this.strokeOverride=null,this.height=20,this.faded=!1}getSvgDefinableElement(){return this.$.svgDefs}get _fill(){var t=this.type,r=this.fillOverride;if(r!=null)return r;switch(t){case n1.META:return Ku.DEFAULT_FILL;case n1.SERIES:return Vlt.DEFAULT_FILL;default:return y0.DEFAULT_FILL}}get _stroke(){var t=this.type,r=this.strokeOverride;if(r!=null)return r;switch(t){case n1.META:return Ku.DEFAULT_STROKE;case n1.SERIES:return Vlt.DEFAULT_STROKE;default:return y0.DEFAULT_STROKE}}_isType(t,r){return t===r}_fadedClass(t,r){return t?"faded-"+r:""}};Zu.template=Q`
    <style>
      :host {
        font-size: 0;
      }

      :host(.dark-mode) svg {
        filter: invert(1);
      }

      .faded-rect {
        fill: url(#rectHatch);
      }

      .faded-ellipse {
        fill: url(#ellipseHatch);
      }

      .faded-rect,
      .faded-ellipse,
      .faded-series {
        stroke: var(--tb-graph-faded) !important;
      }
      #rectHatch line,
      #ellipseHatch line {
        color: #e0d4b3 !important;
        fill: white;
        stroke: #e0d4b3 !important;
      }
    </style>
    <!-- SVG for definitions -->
    <svg height="0" width="0" id="svgDefs">
      <defs>
        <!-- Hatch patterns for faded out nodes. -->
        <pattern
          id="rectHatch"
          patternTransform="rotate(45 0 0)"
          width="5"
          height="5"
          patternUnits="userSpaceOnUse"
        >
          <line x1="0" y1="0" x2="0" y2="5" style="stroke-width: 1"></line>
        </pattern>
        <pattern
          id="ellipseHatch"
          patternTransform="rotate(45 0 0)"
          width="2"
          height="2"
          patternUnits="userSpaceOnUse"
        >
          <line x1="0" y1="0" x2="0" y2="2" style="stroke-width: 1"></line>
        </pattern>
        <!-- Template for an Op node ellipse. -->
        <ellipse
          id="op-node-stamp"
          rx="7.5"
          ry="3"
          stroke="inherit"
          fill="inherit"
        ></ellipse>
        <!-- Template for an Op node annotation ellipse (smaller). -->
        <ellipse
          id="op-node-annotation-stamp"
          rx="5"
          ry="2"
          stroke="inherit"
          fill="inherit"
        ></ellipse>
        <!-- Vertically stacked series of Op nodes when unexpanded. -->
        <g id="op-series-vertical-stamp">
          <use xlink:href="#op-node-stamp" x="8" y="9"></use>
          <use xlink:href="#op-node-stamp" x="8" y="6"></use>
          <use xlink:href="#op-node-stamp" x="8" y="3"></use>
        </g>
        <g id="op-series-horizontal-stamp">
          <use xlink:href="#op-node-stamp" x="16" y="4"></use>
          <use xlink:href="#op-node-stamp" x="12" y="4"></use>
          <use xlink:href="#op-node-stamp" x="8" y="4"></use>
        </g>
        <g
          id="summary-icon"
          fill="#848484"
          height="12"
          viewBox="0 0 24 24"
          width="12"
        >
          <path
            d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z"
          ></path>
        </g>
      </defs>
    </svg>
    <template is="dom-if" if="[[_isType(type, 'CONST')]]">
      <svg
        height$="[[height]]"
        preserveAspectRatio="xMinYMid meet"
        viewBox="0 0 10 10"
      >
        <circle
          cx="5"
          cy="5"
          r="3"
          fill$="[[_fill]]"
          stroke$="[[_stroke]]"
        ></circle>
      </svg>
    </template>
    <template is="dom-if" if="[[_isType(type, 'SUMMARY')]]">
      <svg
        width$="[[height]]"
        height$="[[height]]"
        viewBox="0 0 24 24"
        fill="#848484"
      >
        <path
          d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z"
        ></path>
      </svg>
    </template>
    <template is="dom-if" if="[[_isType(type, 'OP')]]">
      <svg
        height$="[[height]]"
        preserveAspectRatio="xMinYMid meet"
        viewBox="0 0 16 8"
      >
        <use
          xmlns:xlink="http://www.w3.org/1999/xlink"
          xlink:href="#op-node-stamp"
          fill$="[[_fill]]"
          stroke$="[[_stroke]]"
          class$="{{_fadedClass(faded, 'ellipse')}}"
          x="8"
          y="4"
        ></use>
      </svg>
    </template>
    <template is="dom-if" if="[[_isType(type, 'META')]]">
      <svg
        height$="[[height]]"
        preserveAspectRatio="xMinYMid meet"
        viewBox="0 0 37 16"
      >
        <rect
          x="1"
          y="1"
          fill$="[[_fill]]"
          stroke$="[[_stroke]]"
          class$="{{_fadedClass(faded, 'rect')}}"
          stroke-width="2px"
          height="14"
          width="35"
          rx="5"
          ry="5"
        ></rect>
      </svg>
    </template>
    <template is="dom-if" if="[[_isType(type, 'SERIES')]]">
      <template is="dom-if" if="[[vertical]]">
        <svg
          height$="[[height]]"
          preserveAspectRatio="xMinYMid meet"
          viewBox="0 0 16 15"
        >
          <use
            xmlns:xlink="http://www.w3.org/1999/xlink"
            xlink:href="#op-series-vertical-stamp"
            fill$="[[_fill]]"
            stroke$="[[_stroke]]"
            class$="{{_fadedClass(faded, 'series')}}"
            x="0"
            y="2"
          ></use>
        </svg>
      </template>
      <template is="dom-if" if="[[!vertical]]">
        <svg
          height$="[[height]]"
          preserveAspectRatio="xMinYMid meet"
          viewBox="0 0 24 10"
        >
          <use
            xmlns:xlink="http://www.w3.org/1999/xlink"
            xlink:href="#op-series-horizontal-stamp"
            fill$="[[_fill]]"
            stroke$="[[_stroke]]"
            class$="{{_fadedClass(faded, 'series')}}"
            x="0"
            y="1"
          ></use>
        </svg>
      </template>
    </template>
  `;E([A({type:String}),w("design:type",String)],Zu.prototype,"type",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Zu.prototype,"vertical",void 0);E([A({type:String}),w("design:type",Object)],Zu.prototype,"fillOverride",void 0);E([A({type:String}),w("design:type",Object)],Zu.prototype,"strokeOverride",void 0);E([A({type:Number}),w("design:type",Number)],Zu.prototype,"height",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Zu.prototype,"faded",void 0);E([Rt("type","fillOverride"),w("design:type",String),w("design:paramtypes",[])],Zu.prototype,"_fill",null);E([Rt("type","strokeOverride"),w("design:type",String),w("design:paramtypes",[])],Zu.prototype,"_stroke",null);Zu=E([yt("tf-graph-icon")],Zu);var Bs=class extends Gt(mt){constructor(){super(...arguments),this.node=null,this.renderInfo=null,this.colorBy=qn.STRUCTURE,this.templateIndex=null,this.type=null,this.vertical=!1,this.const=!1,this.summary=!1,this.fill=null,this.height=20}_computeFillOverride(t,r,n,i,o){return t&&r&&i?kH(i,n,r,!1):o}_getStrokeOverride(t){return t?tct(t):null}_getType(t,r,n,i){let{GraphIconType:o}=oct;if(t)switch(t.type){case jt.OP:{let a=t.op;return typeof a!="string"?o.OP:a==="Const"||n?o.CONST:a.endsWith("Summary")||r?o.SUMMARY:o.OP}case jt.META:return o.META;case jt.SERIES:return o.SERIES}return i}_isVertical(t,r){return t?t.hasNonControlEdges:!!r}_getFaded(t){return t&&t.isFadedOut}_onFillOverrideChanged(t,r){let{node:n,renderInfo:i,colorBy:o,templateIndex:a}=this;t!==r&&LH(this.$.icon.getSvgDefinableElement()),n&&i&&a&&kH(a,o,i,!1,this.$.icon.getSvgDefinableElement())}};Bs.template=Q`
    <style>
      tf-graph-icon {
        --tb-graph-faded: var(--tb-graph-faded);
      }
    </style>
    <tf-graph-icon
      id="icon"
      type="[[_getType(node, summary, const, type)]]"
      height="[[height]]"
      fill-override="[[_fillOverride]]"
      stroke-override="[[_getStrokeOverride(_fillOverride)]]"
      faded="[[_getFaded(renderInfo)]]"
      vertical="[[_isVertical(node, vertical)]]"
    ></tf-graph-icon>
  `;E([A({type:Object}),w("design:type",Object)],Bs.prototype,"node",void 0);E([A({type:Object}),w("design:type",Object)],Bs.prototype,"renderInfo",void 0);E([A({type:Object}),w("design:type",String)],Bs.prototype,"colorBy",void 0);E([A({type:Object}),w("design:type",Object)],Bs.prototype,"templateIndex",void 0);E([A({type:String}),w("design:type",Object)],Bs.prototype,"type",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Bs.prototype,"vertical",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Bs.prototype,"const",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Bs.prototype,"summary",void 0);E([A({type:String}),w("design:type",Object)],Bs.prototype,"fill",void 0);E([A({type:Number}),w("design:type",Number)],Bs.prototype,"height",void 0);E([A({type:String,computed:"_computeFillOverride(node, renderInfo, colorBy, templateIndex, fill)",observer:"_onFillOverrideChanged"}),w("design:type",String)],Bs.prototype,"_fillOverride",void 0);Bs=E([yt("tf-node-icon")],Bs);var Gc=class extends Gt(mt){_itemTypeChanged(){this.itemType!=="subnode"?this.$["list-item"].classList.add("clickable"):this.$["list-item"].classList.remove("clickable")}_nodeListener(t){this.fire("node-list-item-"+t.type,{nodeName:this.name,type:this.itemType})}_fadedClass(t){return t&&t.isFadedOut?"faded":""}};Gc.template=Q`
    <style>
      #list-item {
        width: 100%;
        color: var(--secondary-text-color);
        font-size: 11pt;
        font-weight: 400;
        position: relative;
        display: inline-block;
      }

      #list-item:hover {
        background-color: var(--google-yellow-100);
      }

      .clickable {
        cursor: pointer;
      }

      #list-item span {
        margin-left: 40px;
      }

      #list-item.excluded span {
        color: #999;
      }

      #list-item span.edge-label {
        float: right;
        font-size: 10px;
        margin-left: 3px;
        margin-right: 5px;
      }

      .node-icon {
        position: absolute;
        top: 1px;
        left: 2px;
      }

      .faded span {
        color: var(--tb-graph-faded);
      }
    </style>

    <div
      id="list-item"
      on-mouseover="_nodeListener"
      on-mouseout="_nodeListener"
      on-click="_nodeListener"
    >
      <div class$="{{_fadedClass(itemRenderInfo)}}">
        <tf-node-icon
          class="node-icon"
          height="12"
          color-by="[[colorBy]]"
          color-by-params="[[colorByParams]]"
          node="[[itemNode]]"
          render-info="[[itemRenderInfo]]"
          template-index="[[templateIndex]]"
        >
        </tf-node-icon>
        <span title$="[[name]]">[[name]]</span>
      </div>
    </div>
  `;E([A({type:Object}),w("design:type",Object)],Gc.prototype,"cardNode",void 0);E([A({type:Object}),w("design:type",Object)],Gc.prototype,"itemNode",void 0);E([A({type:String}),w("design:type",String)],Gc.prototype,"edgeLabel",void 0);E([A({type:Object}),w("design:type",Object)],Gc.prototype,"itemRenderInfo",void 0);E([A({type:String}),w("design:type",String)],Gc.prototype,"name",void 0);E([A({type:String,observer:"_itemTypeChanged"}),w("design:type",String)],Gc.prototype,"itemType",void 0);E([A({type:String}),w("design:type",String)],Gc.prototype,"colorBy",void 0);E([A({type:Object}),w("design:type",Object)],Gc.prototype,"colorByParams",void 0);E([A({type:Object}),w("design:type",Function)],Gc.prototype,"templateIndex",void 0);Gc=E([yt("tf-graph-op-compat-list-item")],Gc);var as=class extends Gt(_o(mt)){constructor(){super(...arguments),this._expanded=!0,this._opCompatColor=y0.COMPATIBLE,this._opIncompatColor=y0.INCOMPATIBLE,this._templateIndex=null}_getNode(t,r){return r.node(t)}_getRenderInfo(t,r){return this.renderHierarchy.getOrCreateRenderNodeByName(t)}_toggleExpanded(){this._expanded=!this._expanded}_getToggleIcon(t){return t?"expand-less":"expand-more"}_resizeList(t){var r=document.querySelector(t);r&&r.fire("iron-resize")}get _incompatibleOpNodes(){let t=this.graphHierarchy;return!t||!t.root?[]:(this.async(this._resizeList.bind(this,"#incompatibleOpsList")),dle(t))}get _opCompatScore(){var t=this.graphHierarchy;if(t&&t.root){var r=t.root,n=r.compatibilityHistogram.compatible,i=r.compatibilityHistogram.incompatible;if(n==0&&i==0)return 0;var o=n+i;return Math.floor(100*n/o)/100}return 0}get _opCompatScoreLabel(){var t=this._opCompatScore;return xn(".0%")(t)}get _totalIncompatOps(){var t=this.graphHierarchy;return t&&t.root?t.root.compatibilityHistogram.incompatible:0}_graphHierarchyChanged(){this._templateIndex=this.graphHierarchy.getTemplateIndex(),this.graphHierarchy.addListener(Dd.TEMPLATES_UPDATED,()=>{this._templateIndex=this.graphHierarchy.getTemplateIndex()})}};as.template=Q`
    <style>
      :host {
        max-height: 500px;
      }

      .incompatible-ops-list {
        height: 350px;
        max-height: 400px;
        overflow-y: scroll;
        display: flex;
        flex-direction: column;
      }

      iron-list {
        flex: 1 1 auto;
      }

      paper-item {
        padding: 0;
        background: var(--secondary-background-color);
      }

      paper-item-body[two-line] {
        min-height: 0;
        padding: 8px 12px 4px;
      }

      .expandedInfo {
        padding: 8px 12px;
        font-weight: 500;
        font-size: 12pt;
        width: 100%;
      }

      .node-name {
        white-space: normal;
        word-wrap: break-word;
        font-size: 14pt;
        font-weight: 500;
      }

      .subtitle {
        color: var(--secondary-text-color);
        font-size: 12pt;
      }

      .toggle-button {
        float: right;
        max-height: 20px;
        max-width: 20px;
        padding: 0;
      }

      .non-control-list-item {
        padding-left: 10px;
      }

      div.op-compat-display {
        margin-top: 10px;
        display: inline-block;
      }

      /**
       * Sadly, because the whole body is inverted in color, legends also need
       * to be inverted.
       **/
      :host(.dark-mode) div.op-compat-display {
        filter: invert(1);
      }

      svg.op-compat {
        width: 250px;
        height: 25px;
        float: left;
      }

      div.op-compat-value {
        float: right;
        height: 100%;
        font-size: 14px;
        color: black;
        margin-left: 10px;
      }
    </style>

    <paper-item>
      <paper-item-body two-line>
        <div>
          <paper-icon-button
            icon="{{_getToggleIcon(_expanded)}}"
            on-click="_toggleExpanded"
            class="toggle-button"
          >
          </paper-icon-button>
          <div class="node-name" id="nodetitle">[[nodeTitle]]</div>
        </div>
        <div secondary>
          <div class="subtitle">
            <div class="op-compat-display">
              <svg
                class="op-compat"
                preserveAspectRatio="xMinYMid meet"
                viewBox="0 0 250 25"
              >
                <defs>
                  <linearGradient id="op-compat-fill">
                    <stop offset="0" stop-color$="[[_opCompatColor]]"></stop>
                    <stop
                      offset$="[[_opCompatScore]]"
                      stop-color$="[[_opCompatColor]]"
                    ></stop>
                    <stop
                      offset$="[[_opCompatScore]]"
                      stop-color$="[[_opIncompatColor]]"
                    ></stop>
                    <stop offset="1" stop-color$="[[_opIncompatColor ]]"></stop>
                  </linearGradient>
                </defs>
                <rect
                  height="25"
                  width="250"
                  rx="5"
                  ry="5"
                  style="fill: url('#op-compat-fill');"
                ></rect>
              </svg>
              <div class="op-compat-value">[[_opCompatScoreLabel]]</div>
            </div>
          </div>
        </div>
      </paper-item-body>
    </paper-item>

    <iron-collapse opened="{{_expanded}}">
      <template is="dom-if" if="{{_expanded}}" restamp="true">
        <div class="expandedInfo">
          Incompatible Operations: (<span>[[_totalIncompatOps]]</span>)
          <iron-list
            class="incompatible-ops-list"
            id="incompatibleOpsList"
            items="[[_incompatibleOpNodes]]"
          >
            <template>
              <tf-graph-op-compat-list-item
                class="non-control-list-item"
                item-node="[[item]]"
                item-render-info="[[_getRenderInfo(item.name, renderHierarchy)]]"
                name="[[item.name]]"
                template-index="[[_templateIndex]]"
                color-by="[[colorBy]]"
                item-type="incompatible-ops"
              >
              </tf-graph-op-compat-list-item>
            </template>
          </iron-list>
        </div>
      </template>
    </iron-collapse>
  `;E([A({type:Object}),w("design:type",os)],as.prototype,"graphHierarchy",void 0);E([A({type:Object}),w("design:type",lo)],as.prototype,"renderHierarchy",void 0);E([A({type:String}),w("design:type",String)],as.prototype,"nodeTitle",void 0);E([A({type:Boolean}),w("design:type",Boolean)],as.prototype,"_expanded",void 0);E([A({type:String}),w("design:type",String)],as.prototype,"_opCompatColor",void 0);E([A({type:String}),w("design:type",String)],as.prototype,"_opIncompatColor",void 0);E([A({type:Object}),w("design:type",Object)],as.prototype,"_templateIndex",void 0);E([Rt("graphHierarchy"),w("design:type",Array),w("design:paramtypes",[])],as.prototype,"_incompatibleOpNodes",null);E([Rt("graphHierarchy"),w("design:type",Number),w("design:paramtypes",[])],as.prototype,"_opCompatScore",null);E([Rt("_opCompatScore"),w("design:type",String),w("design:paramtypes",[])],as.prototype,"_opCompatScoreLabel",null);E([Rt("graphHierarchy"),w("design:type",Number),w("design:paramtypes",[])],as.prototype,"_totalIncompatOps",null);E([Bt("graphHierarchy"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],as.prototype,"_graphHierarchyChanged",null);as=E([yt("tf-graph-op-compat-card")],as);var l3=Ee(Oe(),1);var Wc=class extends Gt(_o(mt)){_itemTypeChanged(){this.itemType!=="subnode"?this.$["list-item"].classList.add("clickable"):this.$["list-item"].classList.remove("clickable")}_nodeListener(t){this.fire("node-list-item-"+t.type,{cardNode:this.cardNode.name,nodeName:this.name,type:this.itemType})}_fadedClass(t){return t&&t.isFadedOut?"faded":""}};Wc.template=Q`
    <style>
      #list-item {
        width: 100%;
        color: var(--secondary-text-color);
        font-size: 11pt;
        font-weight: 400;
        position: relative;
        display: inline-block;
      }

      #list-item:hover {
        background-color: var(--google-yellow-100);
      }

      :host(.dark-mode) #list-item:hover {
        background-color: var(--paper-yellow-900);
        color: #fff;
      }

      .clickable {
        cursor: pointer;
      }

      #list-item span {
        margin-left: 40px;
      }

      #list-item.excluded span {
        color: #999;
      }

      #list-item span.edge-label {
        float: right;
        font-size: 10px;
        margin-left: 3px;
        margin-right: 5px;
      }

      .node-icon {
        position: absolute;
        top: 1px;
        left: 2px;
      }

      .faded span {
        color: var(--tb-graph-faded);
      }
    </style>
    <div
      id="list-item"
      on-mouseover="_nodeListener"
      on-mouseout="_nodeListener"
      on-click="_nodeListener"
    >
      <div class$="{{_fadedClass(itemRenderInfo)}}">
        <tf-node-icon
          class="node-icon"
          height="12"
          color-by="[[colorBy]]"
          color-by-params="[[colorByParams]]"
          node="[[itemNode]]"
          render-info="[[itemRenderInfo]]"
          template-index="[[templateIndex]]"
        ></tf-node-icon>
        <span title$="[[name]]">[[name]]</span>
        <span class="edge-label">[[edgeLabel]]</span>
      </div>
    </div>
  `;E([A({type:Object}),w("design:type",Object)],Wc.prototype,"cardNode",void 0);E([A({type:Object}),w("design:type",Object)],Wc.prototype,"itemNode",void 0);E([A({type:String}),w("design:type",String)],Wc.prototype,"edgeLabel",void 0);E([A({type:Object}),w("design:type",Object)],Wc.prototype,"itemRenderInfo",void 0);E([A({type:String}),w("design:type",String)],Wc.prototype,"name",void 0);E([A({type:String,observer:"_itemTypeChanged"}),w("design:type",String)],Wc.prototype,"itemType",void 0);E([A({type:String}),w("design:type",String)],Wc.prototype,"colorBy",void 0);E([A({type:Object}),w("design:type",Object)],Wc.prototype,"colorByParams",void 0);E([A({type:Object}),w("design:type",Object)],Wc.prototype,"templateIndex",void 0);Wc=E([yt("tf-node-list-item")],Wc);var dn=class extends Gt(mt){constructor(){super(...arguments),this._expanded=!0,this._openedControlPred=!1,this._openedControlSucc=!1,this._templateIndex=null}expandNode(){this.fire("_node.expand",this.node)}_getNode(t,r){return r.node(t)}_getNodeStats(t,r){var n=this._getNode(t,r);return n?n.stats:null}_getTotalMicros(t){return t?t.getTotalMicros():0}get _hasDisplayableNodeStats(){var t=this._nodeStats;return gH(t)}get _nodeStatsFormattedBytes(){var t=this._nodeStats;if(!(!t||!t.totalBytes))return Nd(t.totalBytes,iP)}get _nodeStatsFormattedComputeTime(){var t=this._nodeStats;if(!(!t||!t.getTotalMicros()))return Nd(t.getTotalMicros(),oP)}get _nodeStatsFormattedOutputSizes(){var t=this._nodeStats;if(!(!t||!t.outputSize||!t.outputSize.length))return l3.map(t.outputSize,function(r){return r.length===0?"scalar":"["+r.join(", ")+"]"})}_getRenderInfo(t,r){return this.renderHierarchy.getOrCreateRenderNodeByName(t)}get _attributes(){var t=this._node;if(this.async(this._resizeList.bind(this,"#attributesList")),!t||!t.attr)return[];var r=[];return l3.each(t.attr,function(n){n.key===ile?r=r.concat(n.value.list.s.map(function(i){return{key:i,value:"Too large to show..."}})):r.push({key:n.key,value:JSON.stringify(n.value)})}),r}get _device(){var t=this._node;return t?t.device:null}get _successors(){var t=this._node,r=this.graphHierarchy;return this._refreshNodeItemList("inputsList"),t?this._convertEdgeListToEdgeInfoList(r.getSuccessors(t.name),!1,t.isGroupNode):{regular:[],control:[]}}get _predecessors(){var t=this._node,r=this.graphHierarchy;return this._refreshNodeItemList("outputsList"),t?this._convertEdgeListToEdgeInfoList(r.getPredecessors(t.name),!0,t.isGroupNode):{regular:[],control:[]}}get _functionUsages(){var t=this._node,r=this.graphHierarchy;if(this._refreshNodeItemList("functionUsagesList"),!t||t.type!==jt.META)return[];let n=r.libraryFunctions[t.associatedFunction];return n?n.usages:[]}_refreshNodeItemList(t){this.async(this._resizeList.bind(this,`#${t}`))}_convertEdgeListToEdgeInfoList(t,r,n){var i=a=>l3.map(a.baseEdgeList,s=>{var l=r?s.v:s.w;return{name:l,node:this._getNode(l,this.graphHierarchy),edgeLabel:Ylt(s,this.renderHierarchy),renderInfo:this._getRenderInfo(l,this.renderHierarchy)}}),o=function(a){var s=[];return l3.each(a,l=>{var c=r?l.v:l.w;!n||l.baseEdgeList.length==1?s=s.concat(i(l)):s.push({name:c,node:this._getNode(c,this.graphHierarchy),edgeLabel:jlt(l,this.renderHierarchy),renderInfo:this._getRenderInfo(c,this.renderHierarchy)})}),s}.bind(this);return{regular:o(t.regular),control:o(t.control)}}get _subnodes(){var t=this._node;return t&&t.metagraph?t.metagraph.nodes():null}get _totalPredecessors(){var t=this._predecessors;return t.regular.length+t.control.length}get _totalSuccessors(){var t=this._successors;return t.regular.length+t.control.length}_toggleControlPred(){this._openedControlPred=!this._openedControlPred}_toggleControlSucc(){this._openedControlSucc=!this._openedControlSucc}_toggleExpanded(){this._expanded=!this._expanded}_getToggleIcon(t){return t?"expand-less":"expand-more"}_resetState(){this._openedControlPred=!1,this._openedControlSucc=!1,this.set("_groupButtonText",Qlt(this._node))}_resizeList(t){var r=document.querySelector(t);r&&r.fire("iron-resize")}_toggleInclude(){this.fire("node-toggle-inclusion",{name:this.graphNodeName})}_nodeIncludeStateChanged(t,r){this.set("_auxButtonText",yH(t))}_toggleGroup(){var t=IH(this._node);this.fire("node-toggle-seriesgroup",{name:t})}_isLibraryFunction(t){return t&&t.name.startsWith(Sa)}_isInSeries(t){return Jlt(t)}_graphHierarchyChanged(){this._templateIndex=this.graphHierarchy.getTemplateIndex(),this.graphHierarchy.addListener(Dd.TEMPLATES_UPDATED,()=>{this._templateIndex=this.graphHierarchy.getTemplateIndex()})}};dn.template=Q`
    <style>
      .sub-list-group {
        font-weight: 500;
        font-size: 12pt;
        padding-bottom: 8px;
        width: 100%;
      }

      .sub-list {
        max-height: 300px;
        overflow-y: scroll;
      }

      .attr-left {
        float: left;
        width: 30%;
        word-wrap: break-word;
        color: var(--secondary-text-color);
        font-size: 11pt;
        font-weight: 400;
      }

      .attr-right {
        margin-left: 30%;
        word-wrap: break-word;
        color: var(--secondary-text-color);
        font-weight: 400;
      }

      .sub-list-table {
        display: table;
        width: 100%;
      }

      .sub-list-table-row {
        display: table-row;
      }

      .sub-list-table-row .sub-list-table-cell:last-child {
        text-align: right;
      }

      .sub-list-table-cell {
        color: var(--secondary-text-color);
        display: table-cell;
        font-size: 11pt;
        font-weight: 400;
        max-width: 200px;
        padding: 0 4px;
      }

      paper-item {
        padding: 0;
        background: var(--primary-background-color);
      }

      paper-item-body[two-line] {
        min-height: 0;
        padding: 8px 12px 4px;
      }

      .expandedInfo {
        padding: 8px 12px;
      }

      .controlDeps {
        padding: 0 0 0 8px;
      }

      .node-name {
        white-space: normal;
        word-wrap: break-word;
        font-size: 14pt;
        font-weight: 500;
      }

      .node-icon {
        float: right;
      }

      .subtitle {
        color: var(--secondary-text-color);
        font-size: 12pt;
      }

      .controlLine {
        font-size: 11pt;
        font-weight: 400;
      }

      .toggle-button {
        float: right;
        max-height: 20px;
        max-width: 20px;
        padding: 0;
      }

      .control-toggle-button {
        float: left;
        max-height: 20px;
        max-width: 20px;
        padding: 0;
      }

      .toggle-include-group {
        padding-top: 4px;
      }

      .toggle-include {
        margin: 5px 6px;
        text-transform: none;
        padding: 4px 6px;
        font-size: 10pt;
        background-color: #fafafa;
        color: #666;
      }

      .toggle-include:hover {
        background-color: var(--google-yellow-100);
      }

      .non-control-list-item {
        padding-left: 10px;
      }
    </style>
    <paper-item>
      <paper-item-body two-line>
        <div>
          <paper-icon-button
            icon="{{_getToggleIcon(_expanded)}}"
            on-click="_toggleExpanded"
            class="toggle-button"
          >
          </paper-icon-button>
          <div class="node-name">
            <tf-wbr-string value="[[_node.name]]" delimiter-pattern="/">
            </tf-wbr-string>
          </div>
        </div>
        <div secondary>
          <tf-node-icon
            class="node-icon"
            node="[[_node]]"
            render-info="[[_getRenderInfo(graphNodeName, renderHierarchy)]]"
            color-by="[[colorBy]]"
            template-index="[[_templateIndex]]"
          ></tf-node-icon>
          <template is="dom-if" if="{{_node.op}}">
            <div class="subtitle">
              Operation:
              <span>[[_node.op]]</span>
            </div>
          </template>
          <template is="dom-if" if="{{_node.metagraph}}">
            <div class="subtitle">
              Subgraph:
              <span>[[_node.cardinality]]</span> nodes
            </div>
          </template>
        </div>
      </paper-item-body>
    </paper-item>
    <iron-collapse opened="{{_expanded}}">
      <template is="dom-if" if="{{_expanded}}" restamp="true">
        <div class="expandedInfo">
          <div class="sub-list-group attributes">
            Attributes (<span>[[_attributes.length]]</span>)
            <iron-list
              class="sub-list"
              id="attributesList"
              items="[[_attributes]]"
            >
              <template>
                <div>
                  <div class="attr-left">[[item.key]]</div>
                  <div class="attr-right">[[item.value]]</div>
                </div>
              </template>
            </iron-list>
          </div>

          <template is="dom-if" if="{{_device}}">
            <div class="sub-list-group device">
              <div class="attr-left">Device</div>
              <div class="attr-right">[[_device]]</div>
            </div>
          </template>

          <div class="sub-list-group predecessors">
            Inputs (<span>[[_totalPredecessors]]</span>)
            <iron-list
              class="sub-list"
              id="inputsList"
              items="[[_predecessors.regular]]"
            >
              <template>
                <tf-node-list-item
                  class="non-control-list-item"
                  card-node="[[_node]]"
                  item-node="[[item.node]]"
                  edge-label="[[item.edgeLabel]]"
                  item-render-info="[[item.renderInfo]]"
                  name="[[item.name]]"
                  item-type="predecessors"
                  color-by="[[colorBy]]"
                  template-index="[[_templateIndex]]"
                >
                </tf-node-list-item>
              </template>
            </iron-list>
            <template is="dom-if" if="[[_predecessors.control.length]]">
              <div class="controlDeps">
                <div class="controlLine">
                  <paper-icon-button
                    icon="{{_getToggleIcon(_openedControlPred)}}"
                    on-click="_toggleControlPred"
                    class="control-toggle-button"
                  >
                  </paper-icon-button>
                  Control dependencies
                </div>
                <iron-collapse opened="{{_openedControlPred}}" no-animation>
                  <template
                    is="dom-if"
                    if="{{_openedControlPred}}"
                    restamp="true"
                  >
                    <iron-list
                      class="sub-list"
                      items="[[_predecessors.control]]"
                    >
                      <template>
                        <tf-node-list-item
                          card-node="[[_node]]"
                          item-node="[[item.node]]"
                          item-render-info="[[item.renderInfo]]"
                          name="[[item.name]]"
                          item-type="predecessors"
                          color-by="[[colorBy]]"
                          template-index="[[_templateIndex]]"
                        >
                        </tf-node-list-item>
                      </template>
                    </iron-list>
                  </template>
                </iron-collapse>
              </div>
            </template>
          </div>

          <div class="sub-list-group successors">
            Outputs (<span>[[_totalSuccessors]]</span>)
            <iron-list
              class="sub-list"
              id="outputsList"
              items="[[_successors.regular]]"
            >
              <template>
                <tf-node-list-item
                  class="non-control-list-item"
                  card-node="[[_node]]"
                  item-node="[[item.node]]"
                  edge-label="[[item.edgeLabel]]"
                  item-render-info="[[item.renderInfo]]"
                  name="[[item.name]]"
                  item-type="successor"
                  color-by="[[colorBy]]"
                  template-index="[[_templateIndex]]"
                >
                </tf-node-list-item>
              </template>
            </iron-list>
            <template is="dom-if" if="[[_successors.control.length]]">
              <div class="controlDeps">
                <div class="controlLine">
                  <paper-icon-button
                    icon="{{_getToggleIcon(_openedControlSucc)}}"
                    on-click="_toggleControlSucc"
                    class="control-toggle-button"
                  >
                  </paper-icon-button>
                  Control dependencies
                </div>
                <iron-collapse opened="{{_openedControlSucc}}" no-animation>
                  <template
                    is="dom-if"
                    if="{{_openedControlSucc}}"
                    restamp="true"
                  >
                    <iron-list class="sub-list" items="[[_successors.control]]">
                      <template>
                        <tf-node-list-item
                          card-node="[[_node]]"
                          item-node="[[item.node]]"
                          item-render-info="[[item.renderInfo]]"
                          name="[[item.name]]"
                          item-type="successors"
                          color-by="[[colorBy]]"
                          template-index="[[_templateIndex]]"
                        >
                        </tf-node-list-item>
                      </template>
                    </iron-list>
                  </template>
                </iron-collapse>
              </div>
            </template>
          </div>
          <template is="dom-if" if="{{_hasDisplayableNodeStats}}">
            <div class="sub-list-group node-stats">
              Node Stats
              <div class="sub-list-table">
                <template is="dom-if" if="{{_nodeStats.totalBytes}}">
                  <div class="sub-list-table-row">
                    <div class="sub-list-table-cell">Memory</div>
                    <div class="sub-list-table-cell">
                      [[_nodeStatsFormattedBytes]]
                    </div>
                  </div>
                </template>
                <template is="dom-if" if="{{_getTotalMicros(_nodeStats)}}">
                  <div class="sub-list-table-row">
                    <div class="sub-list-table-cell">Compute Time</div>
                    <div class="sub-list-table-cell">
                      [[_nodeStatsFormattedComputeTime]]
                    </div>
                  </div>
                </template>
                <template is="dom-if" if="{{_nodeStats.outputSize}}">
                  <div class="sub-list-table-row">
                    <div class="sub-list-table-cell">Tensor Output Sizes</div>
                    <div class="sub-list-table-cell">
                      <template
                        is="dom-repeat"
                        items="{{_nodeStatsFormattedOutputSizes}}"
                      >
                        [[item]] <br />
                      </template>
                    </div>
                  </div>
                </template>
              </div>
            </div>
          </template>

          <template is="dom-if" if="[[_functionUsages.length]]">
            <div class="sub-list-group predecessors">
              Usages of the Function (<span>[[_functionUsages.length]]</span>)
              <iron-list
                class="sub-list"
                id="functionUsagesList"
                items="[[_functionUsages]]"
              >
                <template>
                  <tf-node-list-item
                    class="non-control-list-item"
                    card-node="[[_node]]"
                    item-node="[[item]]"
                    name="[[item.name]]"
                    item-type="functionUsages"
                    color-by="[[colorBy]]"
                    template-index="[[_templateIndex]]"
                  >
                  </tf-node-list-item>
                </template>
              </iron-list>
            </div>
          </template>

          <template is="dom-if" if="[[!_isLibraryFunction(_node)]]">
            <div class="toggle-include-group">
              <paper-button
                raised
                class="toggle-include"
                on-click="_toggleInclude"
              >
                <span>[[_auxButtonText]]</span>
              </paper-button>
            </div>
          </template>

          <template is="dom-if" if="{{_isInSeries(_node)}}">
            <div class="toggle-include-group">
              <paper-button
                raised
                class="toggle-include"
                on-click="_toggleGroup"
              >
                <span>[[_groupButtonText]]</span>
              </paper-button>
            </div>
          </template>
        </div>
      </template>
    </iron-collapse>
  `;E([A({type:String}),w("design:type",String)],dn.prototype,"graphNodeName",void 0);E([A({type:Object}),w("design:type",os)],dn.prototype,"graphHierarchy",void 0);E([A({type:Object}),w("design:type",Object)],dn.prototype,"renderHierarchy",void 0);E([A({type:String}),w("design:type",String)],dn.prototype,"colorBy",void 0);E([A({type:Object,computed:"_getNode(graphNodeName, graphHierarchy)",observer:"_resetState"}),w("design:type",Object)],dn.prototype,"_node",void 0);E([A({type:Object,computed:"_getNodeStats(graphNodeName, graphHierarchy)",observer:"_resetState"}),w("design:type",Object)],dn.prototype,"_nodeStats",void 0);E([A({type:Number,observer:"_nodeIncludeStateChanged"}),w("design:type",Number)],dn.prototype,"nodeInclude",void 0);E([A({type:Boolean}),w("design:type",Boolean)],dn.prototype,"_expanded",void 0);E([A({type:Boolean}),w("design:type",Boolean)],dn.prototype,"_openedControlPred",void 0);E([A({type:Boolean}),w("design:type",Boolean)],dn.prototype,"_openedControlSucc",void 0);E([A({type:String}),w("design:type",String)],dn.prototype,"_auxButtonText",void 0);E([A({type:String}),w("design:type",String)],dn.prototype,"_groupButtonText",void 0);E([A({type:Object}),w("design:type",Function)],dn.prototype,"_templateIndex",void 0);E([Rt("_nodeStats"),w("design:type",Boolean),w("design:paramtypes",[])],dn.prototype,"_hasDisplayableNodeStats",null);E([Rt("_nodeStats"),w("design:type",Object),w("design:paramtypes",[])],dn.prototype,"_nodeStatsFormattedBytes",null);E([Rt("_nodeStats"),w("design:type",Object),w("design:paramtypes",[])],dn.prototype,"_nodeStatsFormattedComputeTime",null);E([Rt("_nodeStats"),w("design:type",Object),w("design:paramtypes",[])],dn.prototype,"_nodeStatsFormattedOutputSizes",null);E([Rt("_node"),w("design:type",Array),w("design:paramtypes",[])],dn.prototype,"_attributes",null);E([Rt("_node"),w("design:type",String),w("design:paramtypes",[])],dn.prototype,"_device",null);E([Rt("_node","graphHierarchy"),w("design:type",Object),w("design:paramtypes",[])],dn.prototype,"_successors",null);E([Rt("_node","graphHierarchy"),w("design:type",Object),w("design:paramtypes",[])],dn.prototype,"_predecessors",null);E([Rt("_node","graphHierarchy"),w("design:type",Array),w("design:paramtypes",[])],dn.prototype,"_functionUsages",null);E([Rt("_node"),w("design:type",Array),w("design:paramtypes",[])],dn.prototype,"_subnodes",null);E([Rt("_predecessors"),w("design:type",Number),w("design:paramtypes",[])],dn.prototype,"_totalPredecessors",null);E([Rt("_successors"),w("design:type",Number),w("design:paramtypes",[])],dn.prototype,"_totalSuccessors",null);E([Bt("graphHierarchy"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],dn.prototype,"_graphHierarchyChanged",null);dn=E([yt("tf-node-info")],dn);var ss=class extends Gt(mt){ready(){super.ready(),this.addEventListener("node-list-item-click",this._nodeListItemClicked.bind(this)),this.addEventListener("node-list-item-mouseover",this._nodeListItemMouseover.bind(this)),this.addEventListener("node-list-item-mouseout",this._nodeListItemMouseout.bind(this))}_nodeListItemClicked(t){this.selectedNode=t.detail.nodeName}_nodeListItemMouseover(t){this.highlightedNode=t.detail.nodeName}_nodeListItemMouseout(){this.highlightedNode=null}_healthPillsAvailable(t,r){return t&&r&&Object.keys(r).length>0}_equals(t,r){return t===r}};ss.template=Q`
    <style>
      :host {
        background: var(--secondary-background-color);
        font-size: 12px;
        margin: 0;
        padding: 0;
        display: block;
        max-height: 650px;
        overflow-x: hidden;
        overflow-y: auto;
      }

      h2 {
        padding: 0;
        text-align: center;
        margin: 0;
      }
    </style>
    <template is="dom-if" if="{{selectedNode}}">
      <paper-material elevation="1" class="card">
        <tf-node-info
          graph-hierarchy="[[graphHierarchy]]"
          render-hierarchy="[[renderHierarchy]]"
          flat-graph="[[graph]]"
          graph-node-name="[[selectedNode]]"
          node-include="[[selectedNodeInclude]]"
          highlighted-node="{{highlightedNode}}"
          color-by="[[colorBy]]"
        >
        </tf-node-info>
      </paper-material>
    </template>
    <template is="dom-if" if="[[_equals(colorBy, 'op_compatibility')]]">
      <tf-graph-op-compat-card
        graph-hierarchy="[[graphHierarchy]]"
        render-hierarchy="[[renderHierarchy]]"
        color-by="[[colorBy]]"
        node-title="[[compatNodeTitle]]"
      >
      </tf-graph-op-compat-card>
    </template>
    <template
      is="dom-if"
      if="[[_healthPillsAvailable(debuggerDataEnabled, nodeNamesToHealthPills)]]"
    >
      <tf-graph-debugger-data-card
        render-hierarchy="[[renderHierarchy]]"
        debugger-numeric-alerts="[[debuggerNumericAlerts]]"
        node-names-to-health-pills="[[nodeNamesToHealthPills]]"
        selected-node="{{selectedNode}}"
        highlighted-node="{{highlightedNode}}"
        are-health-pills-loading="[[areHealthPillsLoading]]"
        all-steps-mode-enabled="{{allStepsModeEnabled}}"
        specific-health-pill-step="{{specificHealthPillStep}}"
        health-pill-step-index="{{healthPillStepIndex}}"
      >
      </tf-graph-debugger-data-card>
    </template>
  `;E([A({type:String}),w("design:type",String)],ss.prototype,"title",void 0);E([A({type:Object}),w("design:type",os)],ss.prototype,"graphHierarchy",void 0);E([A({type:Object}),w("design:type",Xu)],ss.prototype,"graph",void 0);E([A({type:Object}),w("design:type",lo)],ss.prototype,"renderHierarchy",void 0);E([A({type:Object}),w("design:type",Object)],ss.prototype,"nodeNamesToHealthPills",void 0);E([A({type:Number,notify:!0}),w("design:type",Number)],ss.prototype,"healthPillStepIndex",void 0);E([A({type:String}),w("design:type",String)],ss.prototype,"colorBy",void 0);E([A({type:String}),w("design:type",String)],ss.prototype,"compatNodeTitle",void 0);E([A({type:String,notify:!0}),w("design:type",String)],ss.prototype,"selectedNode",void 0);E([A({type:String,notify:!0}),w("design:type",String)],ss.prototype,"highlightedNode",void 0);E([A({type:Number,notify:!0}),w("design:type",Number)],ss.prototype,"selectedNodeInclude",void 0);E([A({type:Boolean}),w("design:type",Boolean)],ss.prototype,"debuggerDataEnabled",void 0);ss=E([yt("tf-graph-info")],ss);var cur={MAX_NODE_COUNT:1e4,MAX_EDGE_COUNT:1e4},tn=class extends Gt(mt){constructor(){super(...arguments),this.hierarchyParams=r3,this.allStepsModeEnabled=!1,this.specificHealthPillStep=0,this.compatNodeTitle="TPU Compatibility"}fit(){this.$.graph.fit()}downloadAsImage(t){return Ri(this,null,function*(){let r=yield this.$.graph.getImageBlob(),n=document.createElement("a");n.href=URL.createObjectURL(r),n.download=t,n.click(),URL.revokeObjectURL(n.href)})}_isNotComplete(t){return t.value<100}_getContainerClass(t){var r="container";return t.error&&(r+=" error"),this._isNotComplete(t)&&(r+=" loading"),r}_onNodeInclusionToggled(t){this.$.graph.nodeToggleExtract(t.detail.name)}_onNodeSeriesGroupToggled(t){this.$.graph.nodeToggleSeriesGroup(t.detail.name)}_updateNodeInclude(){let t=this.renderHierarchy?this.renderHierarchy.getNodeByName(this.selectedNode):null;this._selectedNodeInclude=t?t.include:ur.UNSPECIFIED}_slimGraphChanged(){if(!this.graph)return;let{MAX_NODE_COUNT:t,MAX_EDGE_COUNT:r}=cur;Object.keys(this.graph.nodes).length>t&&this.graph.edges.length>r&&this.colorBy===qn.STRUCTURE&&(this.colorBy=qn.NONE)}_ensureTemplates(){!this.graphHierarchy||this.colorBy!==qn.STRUCTURE||this.graphHierarchy.getTemplateIndex()||this.graphHierarchy.updateTemplates()}};tn.template=Q`
    <style>
      ::host {
        display: block;
      }

      /deep/ .close {
        position: absolute;
        cursor: pointer;
        left: 15px;
        bottom: 15px;
      }

      .container {
        width: 100%;
        height: 100%;
        opacity: 1;
      }

      .container.loading {
        cursor: progress;
        opacity: 0.1;
      }

      .container.loading.error {
        cursor: auto;
      }

      #info {
        position: absolute;
        right: 5px;
        top: 5px;
        padding: 0px;
        max-width: 380px;
        min-width: 320px;
        background-color: rgba(255, 255, 255, 0.9);
        @apply --shadow-elevation-2dp;
      }

      #main {
        width: 100%;
        height: 100%;
      }

      #progress-bar {
        display: flex;
        flex-direction: column;
        align-items: center;
        justify-content: center;
        width: 100%;
        position: absolute;
        top: 40px;
        left: 0;
        font-size: 13px;
      }

      #progress-msg {
        margin-bottom: 5px;
        white-space: pre-wrap;
        width: 400px;
      }

      paper-progress {
        width: 400px;
        --paper-progress-height: 6px;
        --paper-progress-active-color: #f3913e;
      }

      .context-menu {
        position: absolute;
        display: none;
        background-color: #e2e2e2;
        border-radius: 2px;
        font-size: 14px;
        min-width: 150px;
        border: 1px solid #d4d4d4;
      }

      /deep/ .context-menu ul {
        list-style-type: none;
        margin: 0;
        padding: 0;
        cursor: default;
      }

      /deep/ .context-menu ul li {
        padding: 4px 16px;
      }

      /deep/ .context-menu ul li:hover {
        background-color: #f3913e;
        color: white;
      }
    </style>
    <template is="dom-if" if="[[_isNotComplete(progress)]]">
      <div id="progress-bar">
        <div id="progress-msg">[[progress.msg]]</div>
        <paper-progress value="[[progress.value]]"></paper-progress>
      </div>
    </template>
    <div class$="[[_getContainerClass(progress)]]">
      <div id="main">
        <tf-graph
          id="graph"
          graph-hierarchy="{{graphHierarchy}}"
          basic-graph="[[graph]]"
          hierarchy-params="[[hierarchyParams]]"
          render-hierarchy="{{renderHierarchy}}"
          devices-for-stats="[[devicesForStats]]"
          stats="[[stats]]"
          selected-node="{{selectedNode}}"
          highlighted-node="{{_highlightedNode}}"
          color-by="[[colorBy]]"
          color-by-params="{{colorByParams}}"
          progress="{{progress}}"
          edge-label-function="[[edgeLabelFunction]]"
          edge-width-function="[[edgeWidthFunction]]"
          node-names-to-health-pills="[[nodeNamesToHealthPills]]"
          health-pill-step-index="[[healthPillStepIndex]]"
          handle-node-selected="[[handleNodeSelected]]"
          handle-edge-selected="[[handleEdgeSelected]]"
          trace-inputs="[[traceInputs]]"
          auto-extract-nodes="[[autoExtractNodes]]"
        ></tf-graph>
      </div>
      <div id="info">
        <tf-graph-info
          id="graph-info"
          title="selected"
          graph-hierarchy="[[graphHierarchy]]"
          render-hierarchy="[[renderHierarchy]]"
          graph="[[graph]]"
          selected-node="{{selectedNode}}"
          selected-node-include="{{_selectedNodeInclude}}"
          highlighted-node="{{_highlightedNode}}"
          color-by="[[colorBy]]"
          color-by-params="[[colorByParams]]"
          debugger-data-enabled="[[debuggerDataEnabled]]"
          are-health-pills-loading="[[areHealthPillsLoading]]"
          debugger-numeric-alerts="[[debuggerNumericAlerts]]"
          node-names-to-health-pills="[[nodeNamesToHealthPills]]"
          all-steps-mode-enabled="{{allStepsModeEnabled}}"
          specific-health-pill-step="{{specificHealthPillStep}}"
          health-pill-step-index="{{healthPillStepIndex}}"
          compat-node-title="[[compatNodeTitle]]"
          on-node-toggle-inclusion="_onNodeInclusionToggled"
          on-node-toggle-seriesgroup="_onNodeSeriesGroupToggled"
        ></tf-graph-info>
      </div>
    </div>
  `;E([A({type:Object}),w("design:type",os)],tn.prototype,"graphHierarchy",void 0);E([A({type:Object}),w("design:type",Xu)],tn.prototype,"graph",void 0);E([A({type:Object}),w("design:type",Object)],tn.prototype,"hierarchyParams",void 0);E([A({type:Object}),w("design:type",Object)],tn.prototype,"stats",void 0);E([A({type:Object}),w("design:type",Object)],tn.prototype,"progress",void 0);E([A({type:Boolean}),w("design:type",Boolean)],tn.prototype,"traceInputs",void 0);E([A({type:Boolean}),w("design:type",Boolean)],tn.prototype,"autoExtractNodes",void 0);E([A({type:String,notify:!0}),w("design:type",String)],tn.prototype,"colorBy",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],tn.prototype,"colorByParams",void 0);E([A({type:Object,notify:!0}),w("design:type",lo)],tn.prototype,"renderHierarchy",void 0);E([A({type:Boolean}),w("design:type",Boolean)],tn.prototype,"debuggerDataEnabled",void 0);E([A({type:Boolean}),w("design:type",Boolean)],tn.prototype,"areHealthPillsLoading",void 0);E([A({type:Array,notify:!0}),w("design:type",Array)],tn.prototype,"debuggerNumericAlerts",void 0);E([A({type:Object}),w("design:type",Object)],tn.prototype,"nodeNamesToHealthPills",void 0);E([A({type:Boolean,notify:!0}),w("design:type",Boolean)],tn.prototype,"allStepsModeEnabled",void 0);E([A({type:Number,notify:!0}),w("design:type",Number)],tn.prototype,"specificHealthPillStep",void 0);E([A({type:Number}),w("design:type",Number)],tn.prototype,"healthPillStepIndex",void 0);E([A({type:String,notify:!0}),w("design:type",String)],tn.prototype,"selectedNode",void 0);E([A({type:String}),w("design:type",String)],tn.prototype,"compatNodeTitle",void 0);E([A({type:Object}),w("design:type",Object)],tn.prototype,"edgeWidthFunction",void 0);E([A({type:Number}),w("design:type",Number)],tn.prototype,"_selectedNodeInclude",void 0);E([A({type:String}),w("design:type",String)],tn.prototype,"_highlightedNode",void 0);E([A({type:Object}),w("design:type",Object)],tn.prototype,"handleNodeSelected",void 0);E([A({type:Object}),w("design:type",Object)],tn.prototype,"edgeLabelFunction",void 0);E([A({type:Object}),w("design:type",Object)],tn.prototype,"handleEdgeSelected",void 0);E([Bt("selectedNode","renderHierarchy"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],tn.prototype,"_updateNodeInclude",null);E([Bt("graph"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],tn.prototype,"_slimGraphChanged",null);E([Bt("colorBy","graphHierarchy"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],tn.prototype,"_ensureTemplates",null);tn=E([yt("tf-graph-board")],tn);var c3=Ee(Oe(),1);var Ju=class{isNotTpuOp(t){return t.toLowerCase().search("cpu:")!=-1||t.toLowerCase().search("gpu:")!=-1?!0:t.toLowerCase().search("tpu")==-1}opValid(t){return t.name.search(Sa)==0||!t.op||t.device&&this.isNotTpuOp(t.device)||t.device&&t.device.search("TPU_SYSTEM")!=-1?!0:c3.includes(Ju.WHITELIST,t.op)}};Ju.WHITELIST=["Abs","Acos","Acosh","Add","AddN","AddV2","AdjustContrastv2","AdjustHue","AdjustSaturation","All","AllToAll","Angle","Any","ApproximateEqual","ArgMax","ArgMin","Asin","Asinh","Assert","AssignAddVariableOp","AssignSubVariableOp","AssignVariableOp","Atan","Atan2","Atanh","AvgPool","AvgPool3D","AvgPool3DGrad","AvgPoolGrad","BatchMatMul","BatchMatMulV2","BatchToSpace","BatchToSpaceND","BesselI0e","BesselI1e","Betainc","BiasAdd","BiasAddGrad","BiasAddV1","Bitcast","BitwiseAnd","BitwiseOr","BitwiseXor","BroadcastArgs","BroadcastGradientArgs","BroadcastTo","Bucketize","Case","Cast","Ceil","CheckNumerics","Cholesky","ClipByValue","CollectivePermute","CollectiveReduceV2","Complex","ComplexAbs","Concat","ConcatOffset","ConcatV2","Conj","ConjugateTranspose","Const","ControlTrigger","Conv2D","Conv2DBackpropFilter","Conv2DBackpropInput","Conv3D","Conv3DBackpropFilterV2","Conv3DBackpropInputV2","Cos","Cosh","Cross","CrossReplicaSum","Cumprod","Cumsum","DataFormatDimMap","DataFormatVecPermute","DepthToSpace","DepthwiseConv2dNative","DepthwiseConv2dNativeBackpropFilter","DepthwiseConv2dNativeBackpropInput","Dequantize","DeviceIndex","Diag","DiagPart","Digamma","Div","DivNoNan","DynamicStitch","Einsum","Elu","EluGrad","Empty","EmptyTensorList","EnsureShape","Equal","Erf","Erfc","Erfinv","Exp","ExpandDims","Expm1","ExtractImagePatches","FFT","FFT2D","FFT3D","FakeParam","FakeQuantWithMinMaxArgs","FakeQuantWithMinMaxArgsGradient","FakeQuantWithMinMaxVars","FakeQuantWithMinMaxVarsGradient","Fill","Floor","FloorDiv","FloorMod","FusedBatchNorm","FusedBatchNormGrad","FusedBatchNormGradV2","FusedBatchNormGradV3","FusedBatchNormV2","FusedBatchNormV3","Gather","GatherNd","GatherV2","GetItem","Greater","GreaterEqual","HSVToRGB","IFFT","IFFT2D","IFFT3D","IRFFT","IRFFT2D","IRFFT3D","Identity","IdentityN","If","Igamma","IgammaGradA","Igammac","Imag","InTopKV2","InfeedDequeue","InfeedDequeueTuple","InplaceAdd","InplaceUpdate","Inv","Invert","InvertPermutation","IsFinite","IsInf","IsNan","KthOrderStatistic","L2Loss","LRN","LRNGrad","LeakyRelu","LeakyReluGrad","LeftShift","Less","LessEqual","Lgamma","LinSpace","ListDiff","Log","Log1p","LogSoftmax","LogicalAnd","LogicalNot","LogicalOr","LowerBound","MakeUnique","MatMul","MatrixBandPart","MatrixDiag","MatrixDiagPart","MatrixDiagPartV2","MatrixDiagPartV3","MatrixDiagV2","MatrixDiagV3","MatrixInverse","MatrixSetDiag","MatrixSetDiagV2","MatrixSetDiagV3","MatrixSolve","MatrixTriangularSolve","Max","MaxPool","MaxPool3D","MaxPool3DGrad","MaxPool3DGradGrad","MaxPoolGrad","MaxPoolGradGrad","MaxPoolGradGradV2","MaxPoolGradV2","MaxPoolV2","Maximum","Mean","Min","Minimum","MirrorPad","MirrorPadGrad","Mod","Mul","MulNoNan","Multinomial","Ndtri","Neg","NextAfter","NoOp","NonMaxSuppressionV4","NotEqual","OneHot","OnesLike","OutfeedEnqueue","OutfeedEnqueueTuple","Pack","Pad","PadV2","ParallelDynamicStitch","ParameterizedTruncatedNormal","PartitionedCall","PlaceholderWithDefault","Polygamma","PopulationCount","Pow","PreventGradient","Prod","Qr","QuantizeAndDequantizeV2","QuantizeAndDequantizeV3","RFFT","RFFT2D","RFFT3D","RGBToHSV","RandomGammaGrad","RandomShuffle","RandomStandardNormal","RandomUniform","RandomUniformInt","Range","Rank","ReadVariableOp","Real","RealDiv","Reciprocal","ReciprocalGrad","Relu","Relu6","Relu6Grad","ReluGrad","Reshape","ResizeBilinear","ResizeBilinearGrad","ResizeNearestNeighbor","ResizeNearestNeighborGrad","ResourceApplyAdaMax","ResourceApplyAdadelta","ResourceApplyAdagrad","ResourceApplyAdagradDA","ResourceApplyAdagradV2","ResourceApplyAdam","ResourceApplyAddSign","ResourceApplyCenteredRMSProp","ResourceApplyFtrl","ResourceApplyFtrlV2","ResourceApplyGradientDescent","ResourceApplyKerasMomentum","ResourceApplyMomentum","ResourceApplyPowerSign","ResourceApplyProximalAdagrad","ResourceApplyProximalGradientDescent","ResourceApplyRMSProp","ResourceGather","ResourceScatterAdd","ResourceScatterDiv","ResourceScatterMax","ResourceScatterMin","ResourceScatterMul","ResourceScatterNdAdd","ResourceScatterNdSub","ResourceScatterNdUpdate","ResourceScatterSub","ResourceScatterUpdate","ResourceStridedSliceAssign","Reverse","ReverseSequence","ReverseV2","RightShift","Rint","RngReadAndSkip","RngSkip","Roll","Round","Rsqrt","RsqrtGrad","ScatterNd","Select","SelectV2","SelfAdjointEigV2","Selu","SeluGrad","Shape","ShapeN","Sigmoid","SigmoidGrad","Sign","Sin","Sinh","Size","Slice","Snapshot","Softmax","SoftmaxCrossEntropyWithLogits","Softplus","SoftplusGrad","Softsign","SoftsignGrad","SpaceToBatch","SpaceToBatchND","SpaceToDepth","SparseMatMul","SparseSoftmaxCrossEntropyWithLogits","SparseToDense","Split","SplitV","Sqrt","SqrtGrad","Square","SquaredDifference","Squeeze","StackCloseV2","StackPopV2","StackPushV2","StackV2","StatefulPartitionedCall","StatefulStandardNormalV2","StatefulTruncatedNormal","StatefulUniform","StatefulUniformFullInt","StatefulUniformInt","StatelessCase","StatelessIf","StatelessMultinomial","StatelessRandomGetAlg","StatelessRandomGetKeyCounter","StatelessRandomGetKeyCounterAlg","StatelessRandomNormal","StatelessRandomNormalV2","StatelessRandomUniform","StatelessRandomUniformFullInt","StatelessRandomUniformFullIntV2","StatelessRandomUniformInt","StatelessRandomUniformIntV2","StatelessRandomUniformV2","StatelessTruncatedNormal","StatelessTruncatedNormalV2","StatelessWhile","StopGradient","StridedSlice","StridedSliceGrad","Sub","Sum","Svd","SymbolicGradient","TPUEmbeddingActivations","Tan","Tanh","TanhGrad","TensorArrayCloseV3","TensorArrayConcatV3","TensorArrayGatherV3","TensorArrayGradV3","TensorArrayReadV3","TensorArrayScatterV3","TensorArraySizeV3","TensorArraySplitV3","TensorArrayV3","TensorArrayWriteV3","TensorListConcatV2","TensorListElementShape","TensorListFromTensor","TensorListGather","TensorListGetItem","TensorListLength","TensorListPopBack","TensorListPushBack","TensorListReserve","TensorListSetItem","TensorListSplit","TensorListStack","TensorScatterAdd","TensorScatterMax","TensorScatterMin","TensorScatterSub","TensorScatterUpdate","TensorStridedSliceUpdate","Tile","TopKUnique","TopKV2","TopKWithUnique","Transpose","TridiagonalSolve","TruncateDiv","TruncateMod","TruncatedNormal","Unique","Unpack","UnsortedSegmentMax","UnsortedSegmentMin","UnsortedSegmentProd","UnsortedSegmentSum","UpperBound","VarIsInitializedOp","VariableShape","Where","While","Xdivy","XlaBroadcastHelper","XlaConv","XlaConvV2","XlaDequantize","XlaDot","XlaDotV2","XlaDynamicSlice","XlaDynamicUpdateSlice","XlaEinsum","XlaGather","XlaHostCompute","XlaIf","XlaKeyValueSort","XlaPad","XlaRecv","XlaRecvFromHost","XlaReduce","XlaReduceWindow","XlaReplicaId","XlaScatter","XlaSelectAndScatter","XlaSelfAdjointEig","XlaSend","XlaSendToHost","XlaSetBound","XlaSetDynamicDimensionSize","XlaSharding","XlaSort","XlaSpmdFullToShardShape","XlaSpmdShardToFullShape","XlaSvd","XlaVariadicReduce","XlaVariadicSort","XlaWhile","Xlog1py","Xlogy","ZerosLike","Zeta","Enter","Exit","LoopCond","Merge","NextIteration","Switch","_Arg","_ArrayToList","_FusedBatchNormEx","_ListToArray","_ParallelConcatUpdate","_RecvTPUEmbeddingActivations","_RecvTPUEmbeddingDeduplicationData","_Retval","_SendTPUEmbeddingGradients","_TPUCompile","_TPUExecute","_UnaryOpsComposition","TPUCompilationResult","TPUReplicatedInput","TPUReplicatedOutput","TPUReplicateMetadata","MergeV2Checkpoints","RestoreV2","SaveV2","Abort","Assert","Assign","Placeholder","PlaceholderV2","ShardedFilename","StringJoin","Variable","VariableV2","VarHandleOp","AudioSummary","AudioSummaryV2","DebugNumericSummary","HistogramSummary","ImageSummary","MergeSummary","ScalarSummary","StatsAggregatorSummary"];function Zle(e,t){if(t===null)throw new Error("Compatibility provider required, but got: "+t);c3.each(e.nodes,r=>{r.compatible=t.opValid(r),c3.each(r.inEmbeddings,n=>{n.compatible=t.opValid(n)}),c3.each(r.outEmbeddings,n=>{n.compatible=t.opValid(n)})})}var gP=Ee(Oe(),1);var Jle=Ee(Oe(),1);var Il=class extends Gt(mt){constructor(){super(...arguments),this._rawRegexInput="",this._previousRegexInput="",this._searchTimeoutDelay=150,this._maxRegexResults=42}get _regexInput(){var t=this.renderHierarchy,r=this._rawRegexInput;return r.trim()}_regexInputChanged(){var t=this._regexInput;this._requestSearch()}_clearSearchResults(){this.set("_regexMatches",[])}_requestSearch(){if(!this._searchPending){if(this._regexInput===this._previousRegexInput){this._searchPending=!1;return}this._searchPending=!0,this._executeSearch(),this.async(()=>{this._searchPending=!1,this._requestSearch()},this._searchTimeoutDelay)}}_executeSearch(){if(this._previousRegexInput=this._regexInput,!this._regexInput){this._clearSearchResults();return}try{var t=new RegExp(this._regexInput)}catch(i){this._clearSearchResults();return}let r=[],n=this.renderHierarchy.hierarchy.getNodeMap();Jle.each(n,(i,o)=>{if(r.length>=this._maxRegexResults)return!1;!t.test(o)||r.push(o)}),this.set("_regexMatches",r)}_matchClicked(t){let r=t.model.item;this.set("selectedNode",r),Po({actionId:jr.NODE_SEARCH_RESULT_FOCUSED})}};Il.template=Q`
    <div id="search-container">
      <paper-input
        id="runs-regex"
        label="Search nodes (regex)"
        value="{{_rawRegexInput}}"
      >
      </paper-input>
      <div id="search-results-anchor">
        <div id="search-results">
          <template is="dom-repeat" items="[[_regexMatches]]">
            <div id="search-match" on-click="_matchClicked">[[item]]</div>
          </template>
        </div>
      </div>
    </div>
    <style>
      #search-container {
        width: 100%;
        overflow: visible;
      }

      #runs-regex {
        width: 100%;
      }

      #search-results-anchor {
        position: relative;
      }

      #search-results {
        color: #fff;
        position: absolute;
        max-height: 200px;
        overflow-x: hidden;
        overflow-y: auto;
        text-align: right;
        max-width: 100%;
        box-sizing: border-box;
      }

      #search-match {
        background: var(--tb-orange-strong);
        padding: 3px;
        float: right;
        width: 100%;
        box-sizing: border-box;
        direction: rtl;
      }

      #search-match:hover {
        background: var(--tb-orange-weak);
        cursor: pointer;
      }
    </style>
  `;E([A({type:Object}),w("design:type",Object)],Il.prototype,"renderHierarchy",void 0);E([A({type:String,notify:!0}),w("design:type",String)],Il.prototype,"selectedNode",void 0);E([A({type:String}),w("design:type",String)],Il.prototype,"_rawRegexInput",void 0);E([A({type:String}),w("design:type",String)],Il.prototype,"_previousRegexInput",void 0);E([A({type:Number}),w("design:type",Number)],Il.prototype,"_searchTimeoutDelay",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Il.prototype,"_searchPending",void 0);E([A({type:Number}),w("design:type",Number)],Il.prototype,"_maxRegexResults",void 0);E([A({type:Array}),w("design:type",Array)],Il.prototype,"_regexMatches",void 0);E([Rt("renderHierarchy","_rawRegexInput"),w("design:type",String),w("design:paramtypes",[])],Il.prototype,"_regexInput",null);E([Bt("_regexInput"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Il.prototype,"_regexInputChanged",null);Il=E([yt("tf-graph-node-search")],Il);var lct=/device:([^:]+:[0-9]+)$/,sct=[{regex:lct}],Qle=[],uur=new Set([qn.COMPUTE_TIME,qn.MEMORY]),Pn=class extends Gt(_o(mt)){constructor(){super(...arguments),this.ColorBy=qn,this.stats=null,this.devicesForStats=null,this.colorBy=qn.STRUCTURE,this.datasets=[],this._selectedRunIndex=0,this.traceInputs=!1,this.autoExtractNodes=!0,this._selectedTagIndex=0,this._selectedGraphType=Fs.OP_GRAPH,this.showSessionRunsDropdown=!0,this.showUploadButton=!0,this._legendOpened=!0,this._downloadFilename="graph.png"}_onGraphTypeChangedByUserGesture(){Po({actionId:jr.GRAPH_TYPE_CHANGED,eventLabel:this._selectedGraphType})}_onColorByChangedByUserGesture(){Po({actionId:jr.NODE_COLOR_MODE_CHANGED,eventLabel:this.colorBy})}_onTraceInputsChangedByUserGesture(){Po({actionId:jr.TRACE_INPUT_MODE_TOGGLED})}_xlaClustersProvided(t){return t&&t.hierarchy&&t.hierarchy.xlaClusters.length>0}_statsChanged(t){if(t!=null){var r={},n=gP.each(t.dev_stats,function(i){var o=gP.some(sct,function(s){return s.regex.test(i.device)}),a=gP.some(Qle,function(s){return s.regex.test(i.device)});o&&!a&&(r[i.device]=!0)});this.set("devicesForStats",r)}}get _currentDevices(){var t=this.devicesForStats;let r=this.stats,o=(r?r.dev_stats:[]).map(s=>s.device).filter(s=>sct.some(l=>l.regex.test(s))),a=zlt(o);if(a.length==1){let s=a[0].match(lct);s&&(a[0]=s[1])}return o.map((s,l)=>{let c=null;return Qle.forEach(u=>{u.regex.test(s)&&(c=u.msg)}),{device:s,suffix:a[l],used:t==null?void 0:t[s],ignoredMsg:c}})}_deviceCheckboxClicked(t){let r=t.target,n=Object.assign({},this.devicesForStats),i=r.value;r.checked?n[i]=!0:delete n[i],this.set("devicesForStats",n)}_numTags(t,r){return this._getTags(t,r).length}_getTags(t,r){return!t||!t[r]?[]:t[r].tags}_fit(){this.fire("fit-tap")}_isGradientColoring(t,r){return uur.has(r)&&t!=null}_equals(t,r){return t===r}get _currentDeviceParams(){var t=this.colorByParams;let r=t.device.filter(o=>sct.some(a=>a.regex.test(o.device))),n=zlt(r.map(o=>o.device));if(n.length==1){var i=n[0].match(lct);i&&(n[0]=i[1])}return r.map((o,a)=>({device:n[a],color:o.color}))}get _currentXlaClusterParams(){var t=this.colorByParams;return t.xla_cluster}get _currentGradientParams(){var t=this.colorByParams,r=this.colorBy;if(!this._isGradientColoring(this.stats,r))return null;let n=t[r],i=n.minValue,o=n.maxValue;return r===qn.MEMORY?(i=Nd(i,iP),o=Nd(o,iP)):r===qn.COMPUTE_TIME&&(i=Nd(i,oP),o=Nd(o,oP)),{minValue:i,maxValue:o,startColor:n.startColor,endColor:n.endColor}}download(){this.fire("download-image-requested",this._downloadFilename)}_updateFileInput(t){var a;let r=(a=t.target.files)==null?void 0:a[0];if(!r)return;let n=r.name,i=n.lastIndexOf(".");i>=0&&(n=n.substring(0,i));let o=n.lastIndexOf("/");o>=0&&(n=n.substring(o+1)),this._setDownloadFilename(n),this.set("selectedFile",t),Po({actionId:jr.UPLOADED_GRAPH_FROM_FILESYSTEM})}_datasetsChanged(t,r){var n;r!=null&&(this._selectedRunIndex=0),this._setDownloadFilename((n=this.datasets[this._selectedRunIndex])==null?void 0:n.name)}_computeSelection(t,r,n,i){return!t[r]||!t[r].tags[n]?null:{run:t[r].name,tag:t[r].tags[n].tag,type:i}}_selectedRunIndexChanged(t){var r;!this.datasets||(this.colorBy=qn.STRUCTURE,this._selectedTagIndex=0,this._selectedGraphType=this._getDefaultSelectionType(),this.traceInputs=!1,this._setDownloadFilename((r=this.datasets[t])==null?void 0:r.name))}_selectedTagIndexChanged(){this._selectedGraphType=this._getDefaultSelectionType()}_getDefaultSelectionType(){let{datasets:t,_selectedRunIndex:r,_selectedTagIndex:n}=this;if(!t||!t[r]||!t[r].tags[n]||t[r].tags[n].opGraph)return Fs.OP_GRAPH;let i=t[r];return i.tags[n].profile?Fs.PROFILE:i.tags[n].conceptualGraph?Fs.CONCEPTUAL_GRAPH:Fs.OP_GRAPH}_getFile(){this.$$("#file").click()}_setDownloadFilename(t){this._downloadFilename=(t||"graph")+".png"}_statsNotNull(t){return t!==null}_toggleLegendOpen(){this.set("_legendOpened",!this._legendOpened)}_getToggleLegendIcon(t){return t?"expand-more":"expand-less"}_getSelectionOpGraphDisabled(t,r,n){return!t[r]||!t[r].tags[n]||!t[r].tags[n].opGraph}_getSelectionProfileDisabled(t,r,n){return!t[r]||!t[r].tags[n]||!t[r].tags[n].profile}_getSelectionConceptualGraphDisabled(t,r,n){return!t[r]||!t[r].tags[n]||!t[r].tags[n].conceptualGraph}};Pn.template=Q`
    <style>
      :host {
        color: #555;
        display: flex;
        flex-direction: column;
        font-size: 12px;
        width: 100%;
        --tb-graph-controls-title-color: #000;
        --tb-graph-controls-legend-text-color: #000;
        --tb-graph-controls-text-color: #555;
        --tb-graph-controls-title-font-size: 14px;
        --tb-graph-controls-subtitle-font-size: 14px;
        --paper-input-container-shared-input-style_-_font-size: 14px;
        --paper-font-subhead_-_font-size: 14px;
      }

      :host(.dark-mode) {
        --tb-graph-controls-title-color: #fff;
        --tb-graph-controls-legend-text-color: #f3f3f3;
        --tb-graph-controls-text-color: #eee;
      }

      paper-dropdown-menu {
        --paper-dropdown-menu-input: {
          padding: 0;
          color: gray;
        }
        --iron-icon-width: 15px;
        --iron-icon-height: 15px;
        --primary-text-color: gray;
        --paper-item-min-height: 30px;
      }

      paper-button[raised].keyboard-focus {
        font-weight: normal;
      }

      .run-dropdown {
        --paper-input-container: {
          padding: 5px 0 5px 5px;
        }
      }

      table {
        border-collapse: collapse;
        border-spacing: 0;
      }

      table tr {
        height: 20px;
      }

      table td {
        padding: 0;
        margin: 0;
      }

      .allcontrols {
        padding: 0 20px 20px;
        flex-grow: 1;
        overflow-y: auto;
      }

      .legend-holder {
        background: var(--secondary-background-color);
        box-sizing: border-box;
        color: var(--tb-graph-controls-text-color);
        width: 100%;
      }

      .legend-toolbar {
        appearance: none;
        background-color: inherit;
        border-top: 1px solid #ccc;
        border-bottom: 1px solid #ccc;
        border-right: none;
        border-left: none;
        cursor: pointer;
        color: var(--tb-graph-controls-legend-text-color);
        font: inherit;
        display: flex;
        align-items: center;
        justify-content: space-between;
        width: 100%;
      }

      .legend-toolbar,
      .legend-content {
        padding: 8px 20px;
      }

      .toggle-legend-button {
        max-height: 20px;
        max-width: 20px;
        padding: 0;
      }

      .toggle-legend-text {
        font-size: var(--tb-graph-controls-subtitle-font-size);
      }

      paper-radio-button {
        display: block;
        padding: 5px;
      }
      svg.icon,
      tf-graph-icon {
        width: 60px;
        height: 18px;
      }
      .domainValues {
        margin-bottom: 10px;
        width: 165px;
      }
      .domainStart {
        float: left;
      }
      .domainEnd {
        float: right;
      }
      .colorBox {
        width: 20px;
      }

      .image-icon {
        width: 24px;
        height: 24px;
      }

      .help-icon {
        height: 15px;
        margin: 0;
        padding: 0;
      }

      .gray {
        color: #666;
      }

      .title {
        font-size: var(--tb-graph-controls-title-font-size);
        margin: 8px 5px 8px 0;
        color: var(--tb-graph-controls-title-color);
      }
      .title small {
        font-weight: normal;
      }
      .deviceList,
      .xlaClusterList {
        max-height: 200px;
        overflow-y: auto;
      }

      #file {
        padding: 8px 0;
      }

      .color-legend-row {
        align-items: center;
        clear: both;
        display: flex;
        height: 20px;
        margin-top: 5px;
      }

      .color-legend-row .label,
      .color-legend-row svg,
      .color-legend-row tf-graph-icon {
        flex: 0 0 40px;
        margin-right: 20px;
      }

      .devices-checkbox input {
        text-align: left;
        vertical-align: middle;
      }

      .control-holder .icon-button {
        font-size: var(--tb-graph-controls-subtitle-font-size);
        margin: 0 -5px;
        padding: 5px;
        display: flex;
        justify-content: flex-start;
        color: var(--tb-graph-controls-text-color);
      }

      .button-text {
        padding-left: 20px;
        text-transform: none;
      }

      .upload-button {
        width: 165px;
        height: 25px;
        text-transform: none;
        margin-top: 4px;
      }

      .button-icon {
        width: 26px;
        height: 26px;
        color: var(--paper-orange-500);
      }

      .hidden-input {
        display: none;
      }

      .allcontrols .control-holder {
        clear: both;
        display: flex;
        justify-content: space-between;
      }

      .allcontrols .control-holder.control-options {
        padding: 0 0 15px 15px;
        flex-direction: column;
      }

      .allcontrols .control-holder paper-toggle-button {
        margin-bottom: 5px;
      }

      span.counter {
        font-size: var(--tb-graph-controls-subtitle-font-size);
        color: gray;
        margin-left: 4px;
      }

      .runs-row .title,
      .tags-row .title {
        display: flex;
        align-items: baseline;
      }

      .runs-row paper-item,
      .tags-row paper-item {
        --paper-item: {
          white-space: nowrap;
        }
      }

      table.control-holder {
        border: 0;
        border-collapse: collapse;
      }

      table.tf-graph-controls td.input-element-table-data {
        padding: 0 0 0 20px;
      }

      .spacer {
        flex-grow: 1;
      }

      .color-text {
        overflow: hidden;
      }

      .color-text.gradient-container {
        margin: 0 5px;
      }

      /** Override inline styles that suppress pointer events for disabled buttons. Otherwise, the */
      /*  tooltips do not appear. */
      paper-radio-group paper-radio-button {
        pointer-events: auto !important;
      }

      .legend-clarifier {
        color: #266236;
        cursor: help;
        display: inline-block;
        text-decoration: underline;
      }

      .legend-clarifier paper-tooltip {
        width: 150px;
      }

      /** Otherwise, polymer UI controls appear atop node search. */
      tf-graph-node-search {
        z-index: 1;
        width: 100%;
      }

      paper-dropdown-menu {
        flex-grow: 1;
      }
    </style>

    <div class="allcontrols">
      <div class="control-holder">
        <tf-graph-node-search
          selected-node="{{selectedNode}}"
          render-hierarchy="[[renderHierarchy]]"
        ></tf-graph-node-search>
      </div>
      <div class="control-holder">
        <paper-button class="icon-button" on-tap="_fit" alt="Fit to screen">
          <iron-icon icon="aspect-ratio" class="button-icon"></iron-icon>
          <span class="button-text">Fit to screen</span>
        </paper-button>
      </div>
      <div class="control-holder">
        <paper-button
          class="icon-button"
          on-click="download"
          alt="Download PNG"
        >
          <iron-icon icon="file-download" class="button-icon"></iron-icon>
          <span class="button-text">Download PNG</span>
        </paper-button>
      </div>
      <template is="dom-if" if="[[showUploadButton]]">
        <div class="control-holder">
          <paper-button
            class="icon-button"
            on-click="_getFile"
            alt="Upload file"
            title="Upload a pbtxt file to view a graph from the local filesystem"
          >
            <iron-icon icon="file-upload" class="button-icon"></iron-icon>
            <span class="button-text">Upload file</span>
          </paper-button>

          <div class="hidden-input">
            <input
              type="file"
              id="file"
              name="file"
              on-change="_updateFileInput"
              accept=".pbtxt"
            />
          </div>
        </div>
      </template>
      <div class="control-holder runs-row">
        <div class="title">
          Run <span class="counter">([[datasets.length]])</span>
        </div>
        <paper-dropdown-menu
          no-label-float
          no-animations
          noink
          horizontal-align="left"
          class="run-dropdown"
        >
          <paper-listbox
            class="dropdown-content"
            selected="{{_selectedRunIndex}}"
            slot="dropdown-content"
          >
            <template is="dom-repeat" items="[[datasets]]">
              <paper-item>[[item.name]]</paper-item>
            </template>
          </paper-listbox>
        </paper-dropdown-menu>
      </div>
      <template is="dom-if" if="[[showSessionRunsDropdown]]">
        <div class="control-holder tags-row">
          <div class="title">
            Tag
            <span class="counter"
              >([[_numTags(datasets, _selectedRunIndex)]])</span
            >
          </div>
          <paper-dropdown-menu
            no-label-float
            no-animations
            horizontal-align="left"
            noink
            class="run-dropdown"
          >
            <paper-listbox
              class="dropdown-content"
              selected="{{_selectedTagIndex}}"
              slot="dropdown-content"
            >
              <template
                is="dom-repeat"
                items="[[_getTags(datasets, _selectedRunIndex)]]"
              >
                <paper-item>[[item.displayName]]</paper-item>
              </template>
            </paper-listbox>
          </paper-dropdown-menu>
        </div>
      </template>
      <div class="title">Graph type</div>
      <div class="control-holder control-options">
        <paper-radio-group
          selected="{{_selectedGraphType}}"
          on-paper-radio-group-changed="_onGraphTypeChangedByUserGesture"
        >
          <!-- Note that the name has to match that of tf_graph_common.SelectionType. -->
          <paper-radio-button
            name="op_graph"
            disabled="[[_getSelectionOpGraphDisabled(datasets, _selectedRunIndex, _selectedTagIndex)]]"
            >Op graph</paper-radio-button
          >
          <paper-radio-button
            name="conceptual_graph"
            disabled="[[_getSelectionConceptualGraphDisabled(datasets, _selectedRunIndex, _selectedTagIndex)]]"
            >Conceptual graph</paper-radio-button
          >
          <paper-radio-button
            name="profile"
            disabled="[[_getSelectionProfileDisabled(datasets, _selectedRunIndex, _selectedTagIndex)]]"
            >Profile</paper-radio-button
          >
        </paper-radio-group>
      </div>
      <div class="title">Node options</div>
      <div class="control-holder control-options">
        <paper-toggle-button
          checked="{{traceInputs}}"
          on-change="_onTraceInputsChangedByUserGesture"
        >
          Trace inputs
        </paper-toggle-button>
        <paper-toggle-button checked="{{autoExtractNodes}}">
          Auto-extract high-degree nodes
        </paper-toggle-button>
      </div>
      <template is="dom-if" if="[[healthPillsFeatureEnabled]]">
        <div class="control-holder">
          <paper-toggle-button checked="{{healthPillsToggledOn}}"
            >Show health pills</paper-toggle-button
          >
        </div>
      </template>
      <div class="title">Color by</div>
      <div class="control-holder control-options">
        <paper-radio-group
          selected="{{colorBy}}"
          on-paper-radio-group-changed="_onColorByChangedByUserGesture"
        >
          <paper-radio-button name="[[ColorBy.NONE]]">None</paper-radio-button>

          <paper-radio-button name="[[ColorBy.STRUCTURE]]"
            >Structure</paper-radio-button
          >

          <paper-radio-button name="[[ColorBy.DEVICE]]"
            >Device</paper-radio-button
          >

          <paper-radio-button
            id="xla-cluster-radio-button"
            name="[[ColorBy.XLA_CLUSTER]]"
            disabled="[[!_xlaClustersProvided(renderHierarchy)]]"
          >
            XLA cluster
          </paper-radio-button>
          <paper-tooltip
            animation-delay="0"
            for="xla-cluster-radio-button"
            position="right"
            offset="0"
          >
            Coloring by XLA cluster is only enabled if at least 1 op specifies
            an XLA cluster.
          </paper-tooltip>

          <paper-radio-button
            id="compute-time-radio-button"
            name="[[ColorBy.COMPUTE_TIME]]"
            disabled="[[!stats]]"
          >
            Compute time
          </paper-radio-button>
          <paper-tooltip
            animation-delay="0"
            for="compute-time-radio-button"
            position="right"
            offset="0"
          >
            Coloring by compute time is only enabled if the RunMetadata proto is
            passed to the FileWriter when a specific session is run.
          </paper-tooltip>

          <paper-radio-button
            id="memory-radio-button"
            name="[[ColorBy.MEMORY]]"
            disabled="[[!stats]]"
          >
            Memory
          </paper-radio-button>
          <paper-tooltip
            animation-delay="0"
            for="memory-radio-button"
            position="right"
            offset="0"
          >
            Coloring by memory is only enabled if the RunMetadata proto is
            passed to the FileWriter when a specific session is run.
          </paper-tooltip>

          <paper-radio-button
            id="tpu-compatibility-radio-button"
            name="[[ColorBy.OP_COMPATIBILITY]]"
          >
            TPU compatibility
          </paper-radio-button>
          <paper-tooltip
            animation-delay="0"
            for="tpu-compatibility-radio-button"
            position="right"
            offset="0"
          >
            Coloring by whether an operation is compatible for the TPU device.
          </paper-tooltip>
        </paper-radio-group>
        <span class="spacer"></span>
      </div>
    </div>
    <div class="legend-holder">
      <button class="legend-toolbar" on-click="_toggleLegendOpen">
        <span class="toggle-legend-text">Legend</span>
        <iron-icon
          icon="[[_getToggleLegendIcon(_legendOpened)]]"
          class="toggle-legend-button"
        >
        </iron-icon>
      </button>
      <iron-collapse opened="[[_legendOpened]]" class="legend-content">
        <!-- Color-mode-specific legend items -->
        <div>
          <template is="dom-if" if="[[_isGradientColoring(stats, colorBy)]]">
            <svg width="140" height="20" class="color-text gradient-container">
              <defs>
                <linearGradient
                  id="linearGradient"
                  x1="0%"
                  y1="0%"
                  x2="100%"
                  y2="0%"
                >
                  <stop
                    class="start"
                    offset="0%"
                    stop-color$="[[_currentGradientParams.startColor]]"
                  ></stop>
                  <stop
                    class="end"
                    offset="100%"
                    stop-color$="[[_currentGradientParams.endColor]]"
                  ></stop>
                </linearGradient>
              </defs>
              <rect
                x="0"
                y="0"
                width="135"
                height="20"
                fill="url(#linearGradient)"
                stroke="black"
              ></rect>
            </svg>
            <div class="domainValues color-text">
              <div class="domainStart">[[_currentGradientParams.minValue]]</div>
              <div class="domainEnd">[[_currentGradientParams.maxValue]]</div>
            </div>
            <br style="clear: both" />
            <div>Devices included in stats:</div>
            <div class="deviceList">
              <template is="dom-repeat" items="[[_currentDevices]]">
                <div class="color-legend-row devices-checkbox">
                  <span
                    ><input
                      type="checkbox"
                      value$="[[item.device]]"
                      checked$="[[item.used]]"
                      on-click="_deviceCheckboxClicked"
                  /></span>
                  <span>[[item.suffix]]</span>
                  <template is="dom-if" if="[[item.ignoredMsg]]">
                    <paper-icon-button
                      icon="help"
                      class="help-icon"
                    ></paper-icon-button>
                    <paper-tooltip
                      position="right"
                      offset="0"
                      animation-delay="0"
                      >[[item.ignoredMsg]]</paper-tooltip
                    >
                  </template>
                </div>
              </template>
            </div>
          </template>
          <template is="dom-if" if="[[_equals(colorBy, 'structure')]]">
            <div class="color-text">
              <div class="color-legend-row">
                <span class="label"> colors </span>
                <span class="color-legend-value">same substructure</span>
              </div>
              <div class="color-legend-row">
                <tf-graph-icon
                  type="META"
                  height="16"
                  fill-override="#eee"
                  stroke-override="#a6a6a6"
                ></tf-graph-icon>
                <span class="color-legend-value">unique substructure</span>
              </div>
            </div>
          </template>
          <template is="dom-if" if="[[_equals(colorBy, 'device')]]">
            <div>
              <template is="dom-repeat" items="[[_currentDeviceParams]]">
                <div class="color-legend-row">
                  <tf-graph-icon
                    type="META"
                    height="16"
                    fill-override="[[item.color]]"
                    stroke-override="#a6a6a6"
                  ></tf-graph-icon>
                  <span class="color-legend-value">[[item.device]]</span>
                </div>
              </template>
              <div class="color-legend-row">
                <tf-graph-icon
                  type="META"
                  height="16"
                  fill-override="#eee"
                  stroke-override="#a6a6a6"
                ></tf-graph-icon>
                <span class="color-legend-value">unknown device</span>
              </div>
            </div>
          </template>
          <template is="dom-if" if="[[_equals(colorBy, 'xla_cluster')]]">
            <div>
              <template is="dom-repeat" items="[[_currentXlaClusterParams]]">
                <div class="color-legend-row">
                  <svg>
                    <use
                      xmlns:xlink="http://www.w3.org/1999/xlink"
                      xlink:href="#unfilled-rect"
                      x="0"
                      y="0"
                      style="fill:[[item.color]]"
                    ></use>
                  </svg>
                  <span class="color-legend-value">[[item.xla_cluster]]</span>
                </div>
              </template>
              <div class="color-legend-row">
                <svg>
                  <use
                    xmlns:xlink="http://www.w3.org/1999/xlink"
                    xlink:href="#grey-rect"
                    x="0"
                    y="0"
                  ></use>
                </svg>
                <span class="color-legend-value">unknown XLA cluster</span>
              </div>
            </div>
          </template>
          <template is="dom-if" if="[[_equals(colorBy, 'op_compatibility')]]">
            <div class="color-text">
              <div class="color-legend-row">
                <tf-graph-icon
                  type="OP"
                  height="16"
                  fill-override="#0f9d58"
                  stroke-override="#ccc"
                ></tf-graph-icon>
                <span class="color-legend-value">Valid Op</span>
              </div>
              <div class="color-legend-row">
                <tf-graph-icon
                  type="OP"
                  height="16"
                  fill-override="#db4437"
                  stroke-override="#ccc"
                ></tf-graph-icon>
                <span class="color-legend-value">Invalid Op</span>
              </div>
            </div>
          </template>
          <template is="dom-if" if="[[_statsNotNull(stats)]]">
            <div class="color-legend-row">
              <tf-graph-icon type="META" height="16" faded></tf-graph-icon>
              <span class="color-legend-value">unused substructure</span>
            </div>
          </template>
        </div>

        <!-- Common legend items -->
        <div>
          <table>
            <tbody>
              <tr>
                <td></td>
                <td>(* = expandable)</td>
              </tr>
              <tr>
                <td>
                  <tf-graph-icon
                    type="META"
                    height="16"
                    fill-override="#d9d9d9"
                    stroke-override="#ccc"
                  ></tf-graph-icon>
                </td>
                <td>
                  Namespace<span class="gray">*</span>
                  <div class="legend-clarifier">
                    <span>?</span>
                    <paper-tooltip
                      animation-delay="0"
                      position="right"
                      offset="0"
                    >
                      Encapsulates a set of nodes. Namespace is hierarchical and
                      based on scope.
                    </paper-tooltip>
                  </div>
                </td>
              </tr>
              <tr>
                <td>
                  <tf-graph-icon type="OP" height="16"></tf-graph-icon>
                </td>
                <td>
                  OpNode
                  <div class="legend-clarifier">
                    <span>?</span>
                    <paper-tooltip
                      animation-delay="0"
                      position="right"
                      offset="0"
                    >
                      Node that performs an operation. These nodes cannot
                      expand.
                    </paper-tooltip>
                  </div>
                </td>
              </tr>
              <tr>
                <td>
                  <tf-graph-icon type="SERIES" height="16"></tf-graph-icon>
                </td>
                <td>
                  Unconnected series<span class="gray">*</span>
                  <div class="legend-clarifier">
                    <span>?</span>
                    <paper-tooltip
                      animation-delay="0"
                      position="right"
                      offset="0"
                    >
                      Sequence of numbered nodes that are not connected to each
                      other.
                    </paper-tooltip>
                  </div>
                </td>
              </tr>
              <tr>
                <td>
                  <tf-graph-icon
                    type="SERIES"
                    height="16"
                    vertical
                  ></tf-graph-icon>
                </td>
                <td>
                  Connected series<span class="gray">*</span>
                  <div class="legend-clarifier">
                    <span>?</span>
                    <paper-tooltip
                      animation-delay="0"
                      position="right"
                      offset="0"
                    >
                      Sequence of numbered nodes that are connected to each
                      other.
                    </paper-tooltip>
                  </div>
                </td>
              </tr>
              <tr>
                <td>
                  <svg class="icon">
                    <circle
                      fill="white"
                      stroke="#848484"
                      cx="10"
                      cy="10"
                      r="5"
                    ></circle>
                  </svg>
                </td>
                <td>
                  Constant
                  <div class="legend-clarifier">
                    <span>?</span>
                    <paper-tooltip
                      animation-delay="0"
                      position="right"
                      offset="0"
                    >
                      Node that outputs a constant value.
                    </paper-tooltip>
                  </div>
                </td>
              </tr>
              <tr>
                <td>
                  <tf-graph-icon type="SUMMARY" height="20"></tf-graph-icon>
                </td>
                <td>
                  Summary
                  <div class="legend-clarifier">
                    <span>?</span>
                    <paper-tooltip
                      animation-delay="0"
                      position="right"
                      offset="0"
                    >
                      Node that collects data for visualization within
                      TensorBoard.
                    </paper-tooltip>
                  </div>
                </td>
              </tr>
              <tr>
                <td>
                  <svg
                    class="icon"
                    height="15px"
                    preserveAspectRatio="xMinYMid meet"
                    viewBox="0 0 15 15"
                  >
                    <defs>
                      <marker
                        id="dataflow-arrowhead-legend"
                        fill="#bbb"
                        markerWidth="10"
                        markerHeight="10"
                        refX="9"
                        refY="5"
                        orient="auto-start-reverse"
                      >
                        <path d="M 0,0 L 10,5 L 0,10 C 3,7 3,3 0,0"></path>
                      </marker>
                    </defs>
                    <path
                      marker-end="url(#dataflow-arrowhead-legend)"
                      stroke="#bbb"
                      d="M2 9 l 29 0"
                      stroke-linecap="round"
                    ></path>
                  </svg>
                </td>
                <td>
                  Dataflow edge
                  <div class="legend-clarifier">
                    <span>?</span>
                    <paper-tooltip
                      animation-delay="0"
                      position="right"
                      offset="0"
                    >
                      Edge showing the data flow between operations. Edges flow
                      upwards unless arrowheads specify otherwise.
                    </paper-tooltip>
                  </div>
                </td>
              </tr>
              <tr>
                <td>
                  <svg
                    class="icon"
                    height="15px"
                    preserveAspectRatio="xMinYMid meet"
                    viewBox="0 0 15 15"
                  >
                    <path
                      stroke="#bbb"
                      d="M2 9 l 29 0"
                      stroke-linecap="round"
                      stroke-dasharray="2, 2"
                    ></path>
                  </svg>
                </td>
                <td>
                  Control dependency edge
                  <div class="legend-clarifier">
                    <span>?</span>
                    <paper-tooltip
                      animation-delay="0"
                      position="right"
                      offset="0"
                    >
                      Edge showing the control dependency between operations.
                    </paper-tooltip>
                  </div>
                </td>
              </tr>
              <tr>
                <td>
                  <svg
                    class="icon"
                    height="15px"
                    preserveAspectRatio="xMinYMid meet"
                    viewBox="0 0 15 15"
                  >
                    <defs>
                      <marker
                        id="reference-arrowhead-legend"
                        fill="#FFB74D"
                        markerWidth="10"
                        markerHeight="10"
                        refX="9"
                        refY="5"
                        orient="auto-start-reverse"
                      >
                        <path d="M 0,0 L 10,5 L 0,10 C 3,7 3,3 0,0"></path>
                      </marker>
                    </defs>
                    <path
                      marker-end="url(#reference-arrowhead-legend)"
                      stroke="#FFB74D"
                      d="M2 9 l 29 0"
                      stroke-linecap="round"
                    ></path>
                  </svg>
                </td>
                <td>
                  Reference edge
                  <div class="legend-clarifier">
                    <span>?</span>
                    <paper-tooltip
                      animation-delay="0"
                      position="right"
                      offset="0"
                    >
                      Edge showing that the outgoing operation node can mutate
                      the incoming tensor.
                    </paper-tooltip>
                  </div>
                </td>
              </tr>
            </tbody>
          </table>
        </div>
      </iron-collapse>
    </div>
  `;E([A({type:Object,observer:"_statsChanged"}),w("design:type",Object)],Pn.prototype,"stats",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],Pn.prototype,"devicesForStats",void 0);E([A({type:String,notify:!0}),w("design:type",String)],Pn.prototype,"colorBy",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],Pn.prototype,"colorByParams",void 0);E([A({type:Array,observer:"_datasetsChanged"}),w("design:type",Object)],Pn.prototype,"datasets",void 0);E([A({type:Object}),w("design:type",lo)],Pn.prototype,"renderHierarchy",void 0);E([A({type:Object,notify:!0,readOnly:!0,computed:"_computeSelection(datasets, _selectedRunIndex, _selectedTagIndex, _selectedGraphType)"}),w("design:type",Object)],Pn.prototype,"selection",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],Pn.prototype,"selectedFile",void 0);E([A({type:Number,observer:"_selectedRunIndexChanged"}),w("design:type",Number)],Pn.prototype,"_selectedRunIndex",void 0);E([A({type:Boolean,notify:!0}),w("design:type",Boolean)],Pn.prototype,"traceInputs",void 0);E([A({type:Boolean,notify:!0}),w("design:type",Boolean)],Pn.prototype,"autoExtractNodes",void 0);E([A({type:Number,observer:"_selectedTagIndexChanged"}),w("design:type",Number)],Pn.prototype,"_selectedTagIndex",void 0);E([A({type:String}),w("design:type",String)],Pn.prototype,"_selectedGraphType",void 0);E([A({type:String,notify:!0}),w("design:type",String)],Pn.prototype,"selectedNode",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Pn.prototype,"showSessionRunsDropdown",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Pn.prototype,"showUploadButton",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Pn.prototype,"healthPillsFeatureEnabled",void 0);E([A({type:Boolean,notify:!0}),w("design:type",Boolean)],Pn.prototype,"healthPillsToggledOn",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Pn.prototype,"_legendOpened",void 0);E([Rt("devicesForStats"),w("design:type",Array),w("design:paramtypes",[])],Pn.prototype,"_currentDevices",null);E([Rt("colorByParams"),w("design:type",Array),w("design:paramtypes",[])],Pn.prototype,"_currentDeviceParams",null);E([Rt("colorByParams"),w("design:type",Array),w("design:paramtypes",[])],Pn.prototype,"_currentXlaClusterParams",null);E([Rt("colorByParams","colorBy"),w("design:type",Object),w("design:paramtypes",[])],Pn.prototype,"_currentGradientParams",null);Pn=E([yt("tf-graph-controls")],Pn);function hur(e){if(e==="true")return!0;if(e==="false")return!1;if(e[0]==='"')return e.substring(1,e.length-1);let r=parseFloat(e);return isNaN(r)?e:r}function tce(e){return new Promise((t,r)=>{fetch(e).then(n=>{n.ok?n.arrayBuffer().then(t,r):n.text().then(r,r)})})}function ece(e,t){return Zse("Reading metadata pbtxt",40,()=>e==null?Promise.resolve(null):tce(e),t,jr.FETCH_METADATA_PBTXT_BYTES).then(r=>mH("Parsing metadata.pbtxt",60,()=>r!=null?gur(r):Promise.resolve(null),t,jr.PARSE_METADATA_PBTXT_INTO_OBJECT))}function rce(e,t,r){return mH("Reading graph pbtxt",40,()=>Ri(this,null,function*(){let n=Date.now();if(t){let o=yield new Promise(function(a,s){let l=new FileReader;l.onload=()=>a(l.result),l.onerror=()=>s(l.error),l.readAsArrayBuffer(t)});return Po({timingId:jr.FETCH_PBTXT_BYTES_FROM_FILESYSTEM,eventValue:Date.now()-n}),o}let i=yield tce(e);return Po({timingId:jr.FETCH_PBTXT_BYTES_FROM_SERVER,eventValue:Date.now()-n}),i}),r,jr.FETCH_PBTXT_BYTES).then(n=>mH("Parsing graph.pbtxt",60,()=>mur(n),r,jr.PARSE_PBTXT_INTO_OBJECT))}function fur(e,t,r=1e6,n=`
`){return new Promise(function(i,o){function a(s,l,c){let u=c>=e.byteLength,h=l.split(n);h[0]=s+h[0];let f=u?"":h.pop();for(let g of h)try{t(g)}catch(_){o(_);return}if(u){i(!0);return}let p=new Blob([e.slice(c,c+r)]),d=new FileReader;d.onload=function(g){a(f,g.target.result,c+r)},d.readAsText(p)}a("","",0)})}var pur={"library.function":!0,"library.function.node_def":!0,"library.function.node_def.input":!0,"library.function.node_def.attr":!0,"library.function.node_def.attr.value.list.b":!0,"library.function.node_def.attr.value.list.f":!0,"library.function.node_def.attr.value.list.func":!0,"library.function.node_def.attr.value.list.i":!0,"library.function.node_def.attr.value.list.s":!0,"library.function.node_def.attr.value.list.shape":!0,"library.function.node_def.attr.value.list.shape.dim":!0,"library.function.node_def.attr.value.list.tensor":!0,"library.function.node_def.attr.value.list.type":!0,"library.function.node_def.attr.value.shape.dim":!0,"library.function.node_def.attr.value.tensor.string_val":!0,"library.function.node_def.attr.value.tensor.tensor_shape.dim":!0,"library.function.signature.input_arg":!0,"library.function.signature.output_arg":!0,"library.versions":!0,node:!0,"node.input":!0,"node.attr":!0,"node.attr.value.list.b":!0,"node.attr.value.list.f":!0,"node.attr.value.list.func":!0,"node.attr.value.list.i":!0,"node.attr.value.list.s":!0,"node.attr.value.list.shape":!0,"node.attr.value.list.shape.dim":!0,"node.attr.value.list.tensor":!0,"node.attr.value.list.type":!0,"node.attr.value.shape.dim":!0,"node.attr.value.tensor.string_val":!0,"node.attr.value.tensor.tensor_shape.dim":!0},dur={"step_stats.dev_stats":!0,"step_stats.dev_stats.node_stats":!0,"step_stats.dev_stats.node_stats.output":!0,"step_stats.dev_stats.node_stats.memory":!0,"step_stats.dev_stats.node_stats.output.tensor_description.shape.dim":!0};function mur(e){return nce(e,pur)}function gur(e){return nce(e,dur).then(t=>t.step_stats)}function nce(e,t){let r={},n=[],i=[],o=r;function a(l){let c=l.indexOf(":"),u=l.substring(0,c).trim(),h=hur(l.substring(c+2).trim());return{name:u,value:h}}function s(l,c,u,h){let f=l[c];f==null?l[c]=h.join(".")in t?[u]:u:Array.isArray(f)?f.push(u):l[c]=[f,u]}return fur(e,function(l){if(l=l.trim(),!!l)switch(l[l.length-1]){case"{":let c=l.substring(0,l.length-2).trim(),u={};n.push(o),i.push(c),s(o,c,u,i),o=u;break;case"}":o=n.pop(),i.pop();break;default:let h=a(l);s(o,h.name,h.value,i.concat(h.name));break}}).then(function(){return r})}function oce(e,t,r,n=new Ju,i=r3){let o=JS(e,30,"Data"),a=JS(e,20,"Graph"),s=JS(e,50,"Namespace hierarchy"),l=Date.now();return rce(t,r,o).then(function(c){if(!c.node)throw new Error("The graph is empty. This can happen when TensorFlow could not trace any graph. Please refer to https://github.com/tensorflow/tensorboard/issues/1961 for more information.");return lle(c,sle,a)},()=>{throw new Error("Malformed GraphDef. This can sometimes be caused by a bad network connection or difficulty reconciling multiple GraphDefs; for the latter case, please refer to https://github.com/tensorflow/tensorboard/issues/1929.")}).then(c=>Ri(this,null,function*(){Zle(c,n);let u=yield bH(c,i,s);return Po({timingId:jr.GRAPH_LOAD_SUCCEEDED,eventValue:Date.now()-l}),{graph:c,graphHierarchy:u}})).catch(c=>{let u=`Graph visualization failed.

${c}`;throw e.reportError(u,c),Po({timingId:jr.GRAPH_LOAD_FAILED,eventValue:Date.now()-l}),c})}var Hs=class extends Gt(mt){constructor(){super(...arguments),this.compatibilityProvider=new Ju,this.hierarchyParams=r3,this._template=null}_selectionChanged(){!this.selection||this.debounce("selectionchange",()=>{this._load(this.selection)})}_load(t){let{run:r,tag:n,type:i}=t;switch(i){case Fs.OP_GRAPH:case Fs.CONCEPTUAL_GRAPH:{(function(){this._setOutStats(null)}).bind(this)();let o=new URLSearchParams;o.set("run",r),o.set("conceptual",String(i===Fs.CONCEPTUAL_GRAPH)),n&&o.set("tag",n);let a=_e().pluginRouteForSrc("graphs","/graph",o);return this._fetchAndConstructHierarchicalGraph(a).then(()=>{this._graphRunTag={run:r,tag:n}})}case Fs.PROFILE:{let{tags:o}=this.datasets.find(({name:f})=>f===r),s=o.find(f=>f.tag===n).opGraph?n:null;console.assert(o.find(f=>f.tag===s),`Required tag (${s}) is missing.`);let c=!this._graphRunTag||this._graphRunTag.run!==r||this._graphRunTag.tag!==s?this._load({run:r,tag:s,type:Fs.OP_GRAPH}):Promise.resolve(),u=new URLSearchParams;u.set("tag",n),u.set("run",r);let h=_e().pluginRouteForSrc("graphs","/run_metadata",u);return c.then(()=>this._readAndParseMetadata(h))}default:return Promise.reject(new Error(`Unknown selection type: ${i}`))}}_readAndParseMetadata(t){this.set("progress",{value:0,msg:""});var r=nP(this);ece(t,r).then(function(n){this._setOutStats(n)}.bind(this))}_fetchAndConstructHierarchicalGraph(t,r){this.set("progress",{value:0,msg:""});let n=nP(this);return oce(n,t,r!==void 0?r:null,this.compatibilityProvider,this.hierarchyParams).then(function({graph:i,graphHierarchy:o}){this._setOutGraph(i),this._setOutGraphHierarchy(o)}.bind(this))}_selectedFileChanged(){var i;var t=this.selectedFile;if(!t)return;let r=t.target,n=(i=r.files)==null?void 0:i[0];!n||(r.value="",this._fetchAndConstructHierarchicalGraph(null,n))}};E([A({type:Array}),w("design:type",Array)],Hs.prototype,"datasets",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],Hs.prototype,"progress",void 0);E([A({type:Object}),w("design:type",Object)],Hs.prototype,"selection",void 0);E([A({type:Object}),w("design:type",Object)],Hs.prototype,"selectedFile",void 0);E([A({type:Object}),w("design:type",Object)],Hs.prototype,"compatibilityProvider",void 0);E([A({type:Object}),w("design:type",Object)],Hs.prototype,"hierarchyParams",void 0);E([A({type:Object,readOnly:!0,notify:!0}),w("design:type",os)],Hs.prototype,"outGraphHierarchy",void 0);E([A({type:Object,readOnly:!0,notify:!0}),w("design:type",Xu)],Hs.prototype,"outGraph",void 0);E([A({type:Object,readOnly:!0,notify:!0}),w("design:type",Object)],Hs.prototype,"outStats",void 0);E([A({type:Object}),w("design:type",Object)],Hs.prototype,"_graphRunTag",void 0);E([Bt("selection","compatibilityProvider"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Hs.prototype,"_selectionChanged",null);E([Bt("selectedFile","compatibilityProvider"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Hs.prototype,"_selectedFileChanged",null);Hs=E([yt("tf-graph-dashboard-loader")],Hs);var ace="run";var Or=class extends Gt(mt){constructor(){super(...arguments),this._datasets=[],this._datasetsFetched=!1,this._selectedDataset=0,this._requestManager=new Ae,this._canceller=new an,this.specificHealthPillStep=0,this.healthPillsToggledOn=!1,this._debuggerNumericAlerts=[],this._nodeNamesToHealthPills={},this._healthPillRequestId=1,this._healthPillStepRequestTimerDelay=500,this.run=y_(ace,{defaultValue:"",useLocalStorage:!1}).call(this),this._runObserver=v_(ace,{defaultValue:"",polymerProperty:"run",useLocalStorage:!1})}attached(){this.set("_isAttached",!0)}detached(){this.set("_isAttached",!1)}ready(){super.ready(),this.addEventListener("node-toggle-expand",this._handleNodeToggleExpand.bind(this))}reload(){this._debuggerDataEnabled||this._requestManager.request(_e().pluginsListing()).then(this._canceller.cancellable(t=>{t.cancelled||t.value.debugger&&this.set("_debuggerDataEnabled",!0)})),this._maybeFetchHealthPills()}_fit(){this.$$("#graphboard").fit()}_onDownloadImageRequested(t){this.$$("#graphboard").downloadAsImage(t.detail)}_getGraphDisplayClassName(t,r){return t||r.length?"":"no-graph"}_fetchDataset(){return this._requestManager.request(_e().pluginRoute("graphs","/info"))}_fetchHealthPills(t,r){let n={node_names:JSON.stringify(t),run:"__debugger_data__"};r!==void 0&&(n.step=r);let i=_e().pluginRoute("debugger","/health_pills");return this._requestManager.request(i,n)}_fetchDebuggerNumericsAlerts(){return this._requestManager.request(_e().pluginRoute("debugger","/numerics_alert_report"))}_graphUrl(t,r,n){return _e().pluginRouteForSrc("graphs","/graph",new URLSearchParams({run:t,limit_attr_size:r,large_attrs_key:n}))}_shouldRequestHealthPills(){return this._debuggerDataEnabled&&this.healthPillsToggledOn&&this._renderHierarchy&&this._datasetsState(this._datasetsFetched,this._datasets,"PRESENT")}_maybeInitializeDashboard(){var t=this._isAttached;this._initialized||!t||(this.set("_compatibilityProvider",new Ju),this._initialized=!0,this._fetchDataset().then(r=>{let n=Object.keys(r);this._datasets=n.sort(xh).map(i=>{let o=r[i],s=Object.keys(o.tags).sort(xh).map(c=>o.tags[c]).map(({tag:c,conceptual_graph:u,op_graph:h,profile:f})=>({tag:c,displayName:c,conceptualGraph:u,opGraph:h,profile:f})),l=o.run_graph?[{tag:null,displayName:"Default",conceptualGraph:!1,opGraph:!0,profile:!1},...s]:s;return{name:i,tags:l}}),this._datasetsFetched=!0}))}_determineSelectedDataset(){var t=this._datasetsFetched,r=this._datasets,n=this.run;if(!n){this.set("_selectedDataset",0);return}let i=r.findIndex(o=>o.name===n);if(i===-1){if(t){let o=this.$$("#error-dialog");o.textContent=`No dataset named "${n}" could be found.`,o.open()}return}this.set("_selectedDataset",i)}_updateSelectedDatasetName(){var t=this._datasetsFetched,r=this._datasets,n=this._selectedDataset;!t||r.length<=n||this.set("run",r[n].name)}_requestHealthPills(){this.set("_areHealthPillsLoading",!0);var t=++this._healthPillRequestId;this._healthPillStepRequestTimerId!==null&&(window.clearTimeout(this._healthPillStepRequestTimerId),this._healthPillStepRequestTimerId=null),this.allStepsModeEnabled?this._healthPillStepRequestTimerId=setTimeout(function(){this._healthPillStepRequestTimerId=null,this._initiateNetworkRequestForHealthPills(t)}.bind(this),this._healthPillStepRequestTimerDelay):this._initiateNetworkRequestForHealthPills(t)}_initiateNetworkRequestForHealthPills(t){if(this._healthPillRequestId!==t)return;let r=this.allStepsModeEnabled?this.specificHealthPillStep:void 0,n=this._fetchHealthPills(this._renderHierarchy.getNamesOfRenderedOps(),r),i=this._fetchDebuggerNumericsAlerts();Promise.all([n,i]).then(function(o){var a=o[0],s=o[1];if(!!this.healthPillsToggledOn&&t===this._healthPillRequestId){for(var l in a){this.set("_healthPillStepIndex",a[l].length-1);break}this.set("_debuggerNumericAlerts",s),this.set("_nodeNamesToHealthPills",a),this.set("_areHealthPillsLoading",!1),this.set("_healthPillStepRequestTimerId",null)}}.bind(this))}_datasetsState(t,r,n){return t?!r||!r.length?n==="EMPTY":n==="PRESENT":n==="NOT_LOADED"}_renderHierarchyChanged(t){this.reload()}_handleNodeToggleExpand(){this._maybeFetchHealthPills()}_healthPillsToggledOnChanged(t){t?this.reload():this.set("_nodeNamesToHealthPills",{})}_maybeFetchHealthPills(){!this._shouldRequestHealthPills()||this._requestHealthPills()}};Or.template=Q`
    <paper-dialog id="error-dialog" with-backdrop></paper-dialog>
    <tf-dashboard-layout>
      <tf-graph-controls
        id="controls"
        class="sidebar"
        slot="sidebar"
        devices-for-stats="{{_devicesForStats}}"
        color-by-params="[[_colorByParams]]"
        stats="[[_stats]]"
        color-by="{{_colorBy}}"
        datasets="[[_datasets]]"
        render-hierarchy="[[_renderHierarchy]]"
        selection="{{_selection}}"
        selected-file="{{_selectedFile}}"
        selected-node="{{_selectedNode}}"
        health-pills-feature-enabled="[[_debuggerDataEnabled]]"
        health-pills-toggled-on="{{healthPillsToggledOn}}"
        on-fit-tap="_fit"
        trace-inputs="{{_traceInputs}}"
        auto-extract-nodes="{{_autoExtractNodes}}"
        on-download-image-requested="_onDownloadImageRequested"
      ></tf-graph-controls>
      <div
        class$="center [[_getGraphDisplayClassName(_selectedFile, _datasets)]]"
        slot="center"
      >
        <tf-graph-dashboard-loader
          id="loader"
          datasets="[[_datasets]]"
          selection="[[_selection]]"
          selected-file="[[_selectedFile]]"
          out-graph-hierarchy="{{_graphHierarchy}}"
          out-graph="{{_graph}}"
          out-stats="{{_stats}}"
          progress="{{_progress}}"
          hierarchy-params="[[_hierarchyParams]]"
          compatibility-provider="[[_compatibilityProvider]]"
        ></tf-graph-dashboard-loader>
        <div class="no-data-message">
          <h3>No graph definition files were found.</h3>
          <p>
            To store a graph, create a
            <code>tf.summary.FileWriter</code>
            and pass the graph either via the constructor, or by calling its
            <code>add_graph()</code> method. You may want to check out the
            <a href="https://www.tensorflow.org/tensorboard/graphs"
              >examining the TensorFlow graph tutorial</a
            >.
          </p>

          <p>
            If you’re new to using TensorBoard, and want to find out how to add
            data and set up your event files, check out the
            <a
              href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
              >README</a
            >
            and perhaps the
            <a
              href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
              >TensorBoard tutorial</a
            >.
          </p>

          <p>
            If you think TensorBoard is configured properly, please see
            <a
              href="https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"
              >the section of the README devoted to missing data problems</a
            >
            and consider filing an issue on GitHub.
          </p>
        </div>
        <div class="graphboard">
          <tf-graph-board
            id="graphboard"
            devices-for-stats="[[_devicesForStats]]"
            color-by="{{_colorBy}}"
            color-by-params="{{_colorByParams}}"
            graph-hierarchy="[[_graphHierarchy]]"
            graph="[[_graph]]"
            hierarchy-params="[[_hierarchyParams]]"
            progress="[[_progress]]"
            debugger-data-enabled="[[_debuggerDataEnabled]]"
            are-health-pills-loading="[[_areHealthPillsLoading]]"
            debugger-numeric-alerts="[[_debuggerNumericAlerts]]"
            node-names-to-health-pills="[[_nodeNamesToHealthPills]]"
            all-steps-mode-enabled="{{allStepsModeEnabled}}"
            specific-health-pill-step="{{specificHealthPillStep}}"
            health-pill-step-index="[[_healthPillStepIndex]]"
            render-hierarchy="{{_renderHierarchy}}"
            selected-node="{{_selectedNode}}"
            stats="[[_stats]]"
            trace-inputs="[[_traceInputs]]"
            auto-extract-nodes="[[_autoExtractNodes]]"
          ></tf-graph-board>
        </div>
      </div>
    </tf-dashboard-layout>
    <style>
      :host /deep/ {
        font-family: 'Roboto', sans-serif;
      }

      .sidebar {
        display: flex;
        height: 100%;
      }

      .center {
        position: relative;
        height: 100%;
      }

      paper-dialog {
        padding: 20px;
      }

      .no-data-message {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }

      .graphboard {
        height: 100%;
      }

      .no-graph .graphboard {
        display: none;
      }

      .center:not(.no-graph) .no-data-message {
        display: none;
      }

      a {
        color: var(--tb-link);
      }

      a:visited {
        color: var(--tb-link-visited);
      }
    </style>
  `;E([A({type:Array}),w("design:type",Array)],Or.prototype,"_datasets",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Or.prototype,"_datasetsFetched",void 0);E([A({type:Number}),w("design:type",Number)],Or.prototype,"_selectedDataset",void 0);E([A({type:Object,observer:"_renderHierarchyChanged"}),w("design:type",lo)],Or.prototype,"_renderHierarchy",void 0);E([A({type:Object}),w("design:type",Ae)],Or.prototype,"_requestManager",void 0);E([A({type:Object}),w("design:type",an)],Or.prototype,"_canceller",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Or.prototype,"_debuggerDataEnabled",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Or.prototype,"allStepsModeEnabled",void 0);E([A({type:Number}),w("design:type",Number)],Or.prototype,"specificHealthPillStep",void 0);E([A({type:Boolean,observer:"_healthPillsToggledOnChanged"}),w("design:type",Boolean)],Or.prototype,"healthPillsToggledOn",void 0);E([A({type:String,notify:!0}),w("design:type",String)],Or.prototype,"selectedNode",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Or.prototype,"_isAttached",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Or.prototype,"_initialized",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Or.prototype,"_areHealthPillsLoading",void 0);E([A({type:Array,notify:!0}),w("design:type",Array)],Or.prototype,"_debuggerNumericAlerts",void 0);E([A({type:Object}),w("design:type",Object)],Or.prototype,"_nodeNamesToHealthPills",void 0);E([A({type:Number}),w("design:type",Number)],Or.prototype,"_healthPillStepIndex",void 0);E([A({type:Number}),w("design:type",Number)],Or.prototype,"_healthPillRequestId",void 0);E([A({type:Number}),w("design:type",Object)],Or.prototype,"_healthPillStepRequestTimerId",void 0);E([A({type:Number}),w("design:type",Number)],Or.prototype,"_healthPillStepRequestTimerDelay",void 0);E([A({type:Array}),w("design:type",Array)],Or.prototype,"runs",void 0);E([A({type:String,notify:!0,observer:"_runObserver"}),w("design:type",String)],Or.prototype,"run",void 0);E([A({type:Object}),w("design:type",Object)],Or.prototype,"_selection",void 0);E([A({type:Object}),w("design:type",Object)],Or.prototype,"_compatibilityProvider",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Or.prototype,"_traceInputs",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Or.prototype,"_autoExtractNodes",void 0);E([A({type:Object}),w("design:type",Object)],Or.prototype,"_selectedFile",void 0);E([Bt("_isAttached"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Or.prototype,"_maybeInitializeDashboard",null);E([Bt("_datasetsFetched","_datasets","run"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Or.prototype,"_determineSelectedDataset",null);E([Bt("_datasetsFetched","_datasets","_selectedDataset"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Or.prototype,"_updateSelectedDatasetName",null);Or=E([yt("tf-graph-dashboard")],Or);var NH=Ee(Oe(),1);var kr=Vr,Ma=class extends Gt(_o(mt)){constructor(){super(...arguments),this.mode="offset",this.timeProperty="step",this.bins="bins",this.x="x",this.dx="dx",this.y="y",this.colorScale=kr.scaleOrdinal(kr.schemeCategory10),this.modeTransitionDuration=500,this._name=null,this._data=null}ready(){super.ready(),this.scopeSubtree(this.$.svg,!0)}attached(){this._attached=!0}detached(){this._attached=!1}setSeriesData(t,r){this._name=t,this._data=r,this.redraw()}_redrawOnChange(){this.redraw()}redraw(){this._draw(0)}_modeRedraw(){this._draw(this.modeTransitionDuration)}_draw(t){if(!this._attached||!this._data)return;if(t===void 0)throw new Error("vz-histogram-timeseries _draw needs duration");if(this._data.length<=0)throw new Error("Not enough steps in the data");if(!this._data[0].hasOwnProperty(this.bins))throw new Error("No bins property of '"+this.bins+"' in data");if(this._data[0][this.bins].length<=0)throw new Error("Must have at least one bin in bins in data");if(!this._data[0][this.bins][0].hasOwnProperty(this.x))throw new Error("No x property '"+this.x+"' on bins data");if(!this._data[0][this.bins][0].hasOwnProperty(this.dx))throw new Error("No dx property '"+this.dx+"' on bins data");if(!this._data[0][this.bins][0].hasOwnProperty(this.y))throw new Error("No y property '"+this.y+"' on bins data");var r=this.timeProperty,n=this.x,i=this.bins,o=this.dx,a=this.y,s=this._data,l=this._name,c=this.mode,u=kr.hcl(this.colorScale(l)),h=kr.select(this.$.tooltip),f=function(Nt){return Nt[n]},p=function(Nt){return Nt[a]},d=function(Nt){return Nt[o]},g=function(Nt){return Nt[n]+Nt[o]},_=function(Nt){return Nt[r]};r==="relative"&&(_=function(Nt){return Nt.wall_time-s[0].wall_time});var y=this.$.svg.getBoundingClientRect(),x=y.width,b=y.height,S,C={top:5,right:60,bottom:20,left:24};c==="offset"?(S=b/2.5,C.top=S+5):S=b-C.top-C.bottom;var P=x-C.left-C.right,k=b-C.top-C.bottom,O=kr.min(s,f),D=kr.max(s,g),B=kr.format(".3n"),I=kr.format(".0f");r==="wall_time"?I=kr.timeFormat("%m/%d %X"):r==="relative"&&(I=function(Nt){return kr.format(".1r")(Nt/36e5)+"h"});var L=s.map(function(Nt,ze){return[kr.min(Nt[i],f),kr.max(Nt[i],g)]}),R=s.map(function(Nt){return kr.extent(Nt[i],p)}),F=500,z=kr.extent(s,_),U=(r==="wall_time"?kr.scaleTime():kr.scaleLinear()).domain(z).range([0,c==="offset"?k:0]),W=kr.scaleLinear().domain([0,kr.max(s,function(Nt,ze){return R[ze][1]})]).range([S,0]),Z=kr.scaleLinear().domain(W.domain()).range([F,0]),rt=kr.scaleLinear().domain([kr.min(s,function(Nt,ze){return L[ze][0]}),kr.max(s,function(Nt,ze){return L[ze][1]})]).nice().range([0,P]),ot=kr.scaleLinear().domain(rt.domain()).range([0,F]);let st=kr.scaleLinear().domain(kr.extent(s,_)).range([u.brighter(),u.darker()]).interpolate(kr.interpolateHcl);var St=kr.axisBottom(rt).ticks(Math.max(2,P/20)),bt=kr.axisRight(U).ticks(Math.max(2,k/15)).tickFormat(I),Mt=kr.axisRight(W).ticks(Math.max(2,k/15)).tickSize(P+5).tickFormat(B),lt=function(Nt){return Nt[n]+Nt[o]/2},Kt=kr.line().x(function(Nt){return ot(lt(Nt))}).y(function(Nt){return Z(Nt[a])}),_t=function(Nt){return"M"+ot(lt(Nt[0]))+","+Z(0)+"L"+Kt(Nt).slice(1)+"L"+ot(lt(Nt[Nt.length-1]))+","+Z(0)},ct=this.$.svg,X=kr.select(ct),et=X.transition().duration(t),dt=X.select("g").classed("small",function(){return P>0&&P<=150}).classed("medium",function(){return P>150&&P<=300}).classed("large",function(){return P>300}),q=et.select("g").attr("transform","translate("+C.left+","+C.top+")"),pt=kr.bisector(g).left,ht=dt.select(".stage").on("mouseover",function(){Tt.style("opacity",1),Ct.style("opacity",1),at.style("opacity",1),Ce.style("opacity",1),h.style("opacity",1)}).on("mouseout",function(){Tt.style("opacity",0),Ct.style("opacity",0),at.style("opacity",0),Ce.style("opacity",0),Tt.classed("hover-closest",!1),It.classed("outline-hover",!1),h.style("opacity",0)}).on("mousemove",Pt),wt=ht.select(".background").attr("transform","translate("+-C.left+","+-C.top+")").attr("width",x).attr("height",b),kt=ht.selectAll(".histogram").data(s),ie=kt.exit().remove(),ee=kt.enter().append("g").attr("class","histogram"),Le=ee.merge(kt).sort(function(Nt,ze){return _(Nt)-_(ze)}),ar=q.selectAll(".histogram").attr("transform",function(Nt){return"translate(0, "+(c==="offset"?U(_(Nt))-S:0)+")"}),fr=ee.append("line").attr("class","baseline"),tt=ar.select(".baseline").style("stroke-opacity",function(Nt){return c==="offset"?.1:0}).attr("y1",S).attr("y2",S).attr("x2",P),$=ee.append("path").attr("class","outline"),It=Le.select(".outline").attr("vector-effect","non-scaling-stroke").attr("d",function(Nt){return _t(Nt[i])}).style("stroke-width",1),$t=ar.select(".outline").attr("transform","scale("+P/F+", "+S/F+")").style("stroke",function(Nt){return c==="offset"?"":st(_(Nt))}).style("fill-opacity",function(Nt){return c==="offset"?1:0}).style("fill",function(Nt){return st(_(Nt))}),he=ee.append("g").attr("class","hover"),Tt=Le.select(".hover").style("fill",function(Nt){return st(_(Nt))});he.append("circle").attr("r",2),he.append("text").style("display","none").attr("dx",4);var be=dt.select(".x-axis-hover").selectAll(".label").data(["x"]),nt=be.enter().append("g").attr("class","label"),Ct=be.merge(nt);nt.append("rect").attr("x",-20).attr("y",6).attr("width",40).attr("height",14),nt.append("line").attr("x1",0).attr("x2",0).attr("y1",0).attr("y2",6),nt.append("text").attr("dy",18);var Wt=dt.select(".y-axis-hover").selectAll(".label").data(["y"]),fe=Wt.enter().append("g").attr("class","label"),at=Wt.merge(fe);fe.append("rect").attr("x",8).attr("y",-6).attr("width",40).attr("height",14),fe.append("line").attr("x1",0).attr("x2",6).attr("y1",0).attr("y2",0),fe.append("text").attr("dx",8).attr("dy",4);var se=dt.select(".y-slice-axis-hover").selectAll(".label").data(["y"]),Qt=se.enter().append("g").attr("class","label"),Ce=se.merge(Qt);Qt.append("rect").attr("x",8).attr("y",-6).attr("width",40).attr("height",14),Qt.append("line").attr("x1",0).attr("x2",6).attr("y1",0).attr("y2",0),Qt.append("text").attr("dx",8).attr("dy",4),q.select(".y.axis.slice").style("opacity",c==="offset"?0:1).attr("transform","translate(0, "+(c==="offset"?-S:0)+")").call(Mt),q.select(".x.axis").attr("transform","translate(0, "+k+")").call(St),q.select(".y.axis").style("opacity",c==="offset"?1:0).attr("transform","translate("+P+", "+(c==="offset"?0:k)+")").call(bt),q.selectAll(".tick text").attr("fill","#aaa"),q.selectAll(".axis path.domain").attr("stroke","none");function Pt(){var Nt=kr.mouse(this),ze=rt.invert(Nt[0]),yn=U.invert(Nt[1]);function Wi(cn){return Math.min(cn[i].length-1,pt(cn[i],ze))}var Ar,Pa=1/0,ho;Tt.attr("transform",function(cn,cx){var rp=Wi(cn);ho=cn;var K=rt(cn[i][rp][n]+cn[i][rp][o]/2),gt=W(cn[i][rp][a]),Et=c==="offset"?U(_(cn))-(S-gt):gt,xt=Math.abs(Nt[1]-Et);return xt<Pa&&(Pa=xt,Ar=cn),"translate("+K+","+gt+")"}),Tt.select("text").text(function(cn){var cx=Wi(cn);return cn[i][cx][a]}),Tt.classed("hover-closest",function(cn){return cn===Ar}),It.classed("outline-hover",function(cn){return cn===Ar});var Ia=Wi(ho);Ct.attr("transform",function(cn){return"translate("+rt(ho[i][Ia][n]+ho[i][Ia][o]/2)+", "+k+")"}).select("text").text(function(cn){return B(ho[i][Ia][n]+ho[i][Ia][o]/2)});var lx=bt.tickFormat();at.attr("transform",function(cn){return"translate("+P+", "+(c==="offset"?U(_(Ar)):0)+")"}).style("display",c==="offset"?"":"none").select("text").text(function(cn){return lx(_(Ar))});var cm=Mt.tickFormat();Ce.attr("transform",function(cn){return"translate("+P+", "+(c==="offset"?0:W(Ar[i][Ia][a]))+")"}).style("display",c==="offset"?"none":"").select("text").text(function(cn){return cm(Ar[i][Ia][a])});var J0=kr.mouse(ct);h.style("transform","translate("+(J0[0]+15)+"px,"+(J0[1]-15)+"px)").select("span").text(c==="offset"?cm(Ar[i][Ia][a]):(r==="step"?"step ":"")+lx(_(Ar)))}}};Ma.template=Q`
    <div id="tooltip"><span></span></div>
    <svg id="svg">
      <g>
        <g class="axis x"></g>
        <g class="axis y"></g>
        <g class="axis y slice"></g>
        <g class="stage">
          <rect class="background"></rect>
        </g>
        <g class="x-axis-hover"></g>
        <g class="y-axis-hover"></g>
        <g class="y-slice-axis-hover"></g>
      </g>
    </svg>

    <style>
      :host {
        color: #aaa;
        display: flex;
        flex-direction: column;
        flex-grow: 1;
        flex-shrink: 1;
        position: relative;
        --vz-histogram-timeseries-hover-bg-color: #fff;
        --vz-histogram-timeseries-outline-color: #fff;
        --vz-histogram-timeseries-hover-outline-color: #000;
      }

      :host(.dark-mode) {
        --vz-histogram-timeseries-hover-bg-color: var(
          --primary-background-color
        );
        --vz-histogram-timeseries-outline-color: var(--paper-grey-600);
        --vz-histogram-timeseries-hover-outline-color: #fff;
      }

      svg {
        font-family: roboto, sans-serif;
        overflow: visible;
        display: block;
        width: 100%;
        flex-grow: 1;
        flex-shrink: 1;
      }

      text {
        fill: currentColor;
      }

      #tooltip {
        position: absolute;
        display: block;
        opacity: 0;
        font-weight: bold;
        font-size: 11px;
      }

      .background {
        fill-opacity: 0;
        fill: red;
      }

      .histogram {
        pointer-events: none;
      }

      .hover {
        font-size: 9px;
        dominant-baseline: middle;
        opacity: 0;
      }

      .hover circle {
        stroke: white;
        stroke-opacity: 0.5;
        stroke-width: 1px;
      }

      .hover text {
        fill: black;
        opacity: 0;
      }

      .hover.hover-closest circle {
        fill: var(--vz-histogram-timeseries-hover-outline-color) !important;
      }

      .hover.hover-closest text {
        opacity: 1;
      }

      .baseline {
        stroke: black;
        stroke-opacity: 0.1;
      }

      .outline {
        fill: none;
        stroke: var(--vz-histogram-timeseries-outline-color);
        stroke-opacity: 0.5;
      }

      .outline.outline-hover {
        stroke: var(--vz-histogram-timeseries-hover-outline-color) !important;
        stroke-opacity: 1;
      }

      .x-axis-hover,
      .y-axis-hover,
      .y-slice-axis-hover {
        pointer-events: none;
      }

      .x-axis-hover .label,
      .y-axis-hover .label,
      .y-slice-axis-hover .label {
        opacity: 0;
        font-weight: bold;
        font-size: 11px;
        text-anchor: end;
      }

      .x-axis-hover text {
        text-anchor: middle;
      }

      .y-axis-hover text,
      .y-slice-axis-hover text {
        text-anchor: start;
      }

      .x-axis-hover line,
      .y-axis-hover line,
      .y-slice-axis-hover line {
        stroke: currentColor;
      }

      .x-axis-hover rect,
      .y-axis-hover rect,
      .y-slice-axis-hover rect {
        fill: var(--vz-histogram-timeseries-hover-bg-color);
      }

      #tooltip,
      .x-axis-hover text,
      .y-axis-hover text,
      .y-slice-axis-hover text {
        color: var(--vz-histogram-timeseries-hover-outline-color);
      }

      .axis {
        font-size: 11px;
      }

      .axis path.domain {
        fill: none;
      }

      .axis .tick line {
        stroke: #ddd;
      }

      .axis.slice {
        opacity: 0;
      }

      .axis.slice .tick line {
        stroke-dasharray: 2;
      }

      .small .axis text {
        display: none;
      }
      .small .axis .tick:first-of-type text {
        display: block;
      }
      .small .axis .tick:last-of-type text {
        display: block;
      }
      .medium .axis text {
        display: none;
      }
      .medium .axis .tick:nth-child(2n + 1) text {
        display: block;
      }
      .large .axis text {
        display: none;
      }
      .large .axis .tick:nth-child(2n + 1) text {
        display: block;
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],Ma.prototype,"mode",void 0);E([A({type:String}),w("design:type",String)],Ma.prototype,"timeProperty",void 0);E([A({type:String}),w("design:type",String)],Ma.prototype,"bins",void 0);E([A({type:String}),w("design:type",String)],Ma.prototype,"x",void 0);E([A({type:String}),w("design:type",String)],Ma.prototype,"dx",void 0);E([A({type:String}),w("design:type",String)],Ma.prototype,"y",void 0);E([A({type:Object}),w("design:type",Object)],Ma.prototype,"colorScale",void 0);E([A({type:Number}),w("design:type",Number)],Ma.prototype,"modeTransitionDuration",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Ma.prototype,"_attached",void 0);E([A({type:String}),w("design:type",Object)],Ma.prototype,"_name",void 0);E([A({type:Array}),w("design:type",Object)],Ma.prototype,"_data",void 0);E([Bt("timeProperty","colorScale","_attached"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Ma.prototype,"_redrawOnChange",null);E([Bt("mode"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Ma.prototype,"_modeRedraw",null);Ma=E([yt("vz-histogram-timeseries")],Ma);function yur(e){let[t,r,n]=e;return{wall_time:t,step:r,min:Lm(n.map(([i,,])=>i)),max:lu(n.map(([,i])=>i)),buckets:n.map(([i,o,a])=>({left:i,right:o,count:a}))}}function vur(e,t,r,n=30){(t===void 0||r==null)&&(t=0,r=0),r===t&&(r=t*1.1+1,t=t/1.1-1);let i=(r-t)/n,o=0,a=[];for(let s=0;s<n;s++){let l=t+s*i,c=l+i,u=0;for(;o<e.buckets.length;){let h=Math.min(r,e.buckets[o].right),f=Math.max(t,e.buckets[o].left);if(h-f>0){let d=Math.min(h,c)-Math.max(f,l),g=d/(h-f)*e.buckets[o].count;u+=d>0?g:0}else{let d=c>=r;u+=l<=f&&(d?h<=c:h<c)?e.buckets[o].count:0}if(h>c)break;o++}a.push({x:l,dx:i,y:u})}return a}function sce(e){let t=e.map(yur),r=Lm(t,i=>i.min),n=lu(t,i=>i.max);return t.map(i=>({wall_time:i.wall_time,step:i.step,bins:vur(i,r,n)}))}var Ea=class extends kS(Gt(mt)){constructor(){super(...arguments),this.getDataLoadName=({run:t})=>t,this.requestData=(t,r,n)=>{let o=_e().pluginRoute("histograms","/histograms");Promise.all(t.map(a=>{let s=Mi(o,{tag:a.tag,run:a.run});return this.requestManager.request(s).then(l=>void r({item:a,data:l}))})).finally(()=>void n())},this.loadDataCallback=(t,r,n)=>{let i=sce(n),o=this.getDataLoadName(r);this.$.chart.setSeriesData(o,i)},this._colorScaleFunction=fn,this._expanded=!1}_reloadOnRunTagRequestManagerChange(){this.reload()}_updateDataToLoad(){var t=this.run,r=this.tag;this.dataToLoad=[{run:t,tag:r}]}get _runColor(){var t=this.run;return this._colorScaleFunction(t)}redraw(){this.$.chart.redraw()}_toggleExpanded(t){this.set("_expanded",!this._expanded),this.redraw()}};Ea.template=Q`
    <tf-card-heading
      tag="[[tag]]"
      run="[[run]]"
      display-name="[[tagMetadata.displayName]]"
      description="[[tagMetadata.description]]"
      color="[[_runColor]]"
    ></tf-card-heading>
    <!--
      The main histogram that we render. Data is set directly with
      \`setSeriesData\`, not with a bound property.
    -->
    <vz-histogram-timeseries
      id="chart"
      time-property="[[timeProperty]]"
      mode="[[histogramMode]]"
      color-scale="[[_colorScaleFunction]]"
    ></vz-histogram-timeseries>
    <div style="display: flex; flex-direction: row;">
      <paper-icon-button
        selected$="[[_expanded]]"
        icon="fullscreen"
        on-tap="_toggleExpanded"
      ></paper-icon-button>
    </div>
    <style>
      :host {
        display: flex;
        flex-direction: column;
        width: 330px;
        height: 235px;
        margin-right: 10px;
        margin-bottom: 15px;
      }
      :host([_expanded]) {
        width: 700px;
        height: 500px;
      }

      vz-histogram-timeseries {
        -moz-user-select: none;
        -webkit-user-select: none;
        will-change: transform;
      }

      paper-icon-button {
        color: #2196f3;
        border-radius: 100%;
        width: 32px;
        height: 32px;
        padding: 4px;
      }

      paper-icon-button[selected] {
        background: var(--tb-ui-light-accent);
      }

      tf-card-heading {
        margin-bottom: 10px;
        width: 90%;
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],Ea.prototype,"run",void 0);E([A({type:String}),w("design:type",String)],Ea.prototype,"tag",void 0);E([A({type:Object}),w("design:type",Object)],Ea.prototype,"getDataLoadName",void 0);E([A({type:Object}),w("design:type",Ae)],Ea.prototype,"requestManager",void 0);E([A({type:Object}),w("design:type",Object)],Ea.prototype,"loadDataCallback",void 0);E([A({type:Object}),w("design:type",Object)],Ea.prototype,"tagMetadata",void 0);E([A({type:String}),w("design:type",String)],Ea.prototype,"timeProperty",void 0);E([A({type:String}),w("design:type",String)],Ea.prototype,"histogramMode",void 0);E([A({type:Object}),w("design:type",Function)],Ea.prototype,"_colorScaleFunction",void 0);E([A({type:Boolean,reflectToAttribute:!0}),w("design:type",Boolean)],Ea.prototype,"_expanded",void 0);E([Bt("run","tag","requestManager"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Ea.prototype,"_reloadOnRunTagRequestManagerChange",null);E([Bt("run","tag"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Ea.prototype,"_updateDataToLoad",null);E([Rt("run"),w("design:type",String),w("design:paramtypes",[])],Ea.prototype,"_runColor",null);Ea=E([yt("tf-histogram-loader")],Ea);var ls=class extends Gt(mt){constructor(){super(...arguments),this.reloadOnReady=!0,this._histogramMode="offset",this._timeProperty="step",this._restamp=!1,this._requestManager=new Ae}_redrawCategoryPane(t,r){!r||t.target.querySelectorAll("tf-histogram-loader").forEach(n=>n.redraw())}ready(){super.ready(),this.reloadOnReady&&this.reload()}reload(){this._fetchTags().then(()=>{this._reloadHistograms()})}_fetchTags(){let t=_e().pluginRoute("histograms","/tags");return this._requestManager.request(t).then(r=>{if(NH.isEqual(r,this._runToTagInfo))return;let n=NH.mapValues(r,o=>Object.keys(o)),i=$i(n);this.set("_dataNotFound",i.length===0),this.set("_runToTag",n),this.set("_runToTagInfo",r),this.async(()=>{this.set("_categoriesDomReady",!0)})})}_reloadHistograms(){var t;(t=this.root)==null||t.querySelectorAll("tf-histogram-loader").forEach(r=>{r.reload()})}_shouldOpen(t){return t<=2}get _categories(){var t=this._runToTag,r=this._selectedRuns,n=this._tagFilter,i=this._categoriesDomReady;return Ql(t,r,n)}_tagMetadata(t,r,n){return t[r][n]}};ls.template=Q`
    <tf-dashboard-layout>
      <div slot="sidebar">
        <div class="settings">
          <div class="sidebar-section">
            <tf-option-selector
              id="histogramModeSelector"
              name="Histogram mode"
              selected-id="{{_histogramMode}}"
            >
              <paper-button id="overlay">overlay</paper-button>
              <paper-button id="offset">offset</paper-button>
            </tf-option-selector>
          </div>
          <div class="sidebar-section">
            <tf-option-selector
              id="timePropertySelector"
              name="Offset time axis"
              selected-id="{{_timeProperty}}"
            >
              <paper-button id="step">step</paper-button>
              <paper-button id="relative">relative</paper-button>
              <paper-button id="wall_time">wall</paper-button>
            </tf-option-selector>
          </div>
        </div>
        <div class="sidebar-section runs-selector">
          <tf-runs-selector selected-runs="{{_selectedRuns}}">
          </tf-runs-selector>
        </div>
      </div>
      <div slot="center">
        <template is="dom-if" if="[[_dataNotFound]]">
          <div class="no-data-warning">
            <h3>No histogram data was found.</h3>
            <p>Probable causes:</p>
            <ul>
              <li>
                You haven’t written any histogram data to your event files.
              </li>
              <li>TensorBoard can’t find your event files.</li>
            </ul>

            <p>
              If you’re new to using TensorBoard, and want to find out how to
              add data and set up your event files, check out the
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
                >README</a
              >
              and perhaps the
              <a
                href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
                >TensorBoard tutorial</a
              >.
            </p>

            <p>
              If you think TensorBoard is configured properly, please see
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"
                >the section of the README devoted to missing data problems</a
              >
              and consider filing an issue on GitHub.
            </p>
          </div>
        </template>
        <template is="dom-if" if="[[!_dataNotFound]]">
          <tf-tag-filterer tag-filter="{{_tagFilter}}"></tf-tag-filterer>
          <template is="dom-repeat" items="[[_categories]]" as="category">
            <tf-category-paginated-view
              category="[[category]]"
              initial-opened="[[_shouldOpen(index)]]"
            >
              <template>
                <tf-histogram-loader
                  run="[[item.run]]"
                  tag="[[item.tag]]"
                  active="[[active]]"
                  tag-metadata="[[_tagMetadata(_runToTagInfo, item.run, item.tag)]]"
                  time-property="[[_timeProperty]]"
                  histogram-mode="[[_histogramMode]]"
                  request-manager="[[_requestManager]]"
                ></tf-histogram-loader>
              </template>
            </tf-category-paginated-view>
          </template>
        </template>
      </div>
    </tf-dashboard-layout>

    <style include="dashboard-style"></style>
    <style>
      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }
    </style>
  `;E([A({type:Boolean}),w("design:type",Boolean)],ls.prototype,"reloadOnReady",void 0);E([A({type:String}),w("design:type",String)],ls.prototype,"_histogramMode",void 0);E([A({type:String}),w("design:type",String)],ls.prototype,"_timeProperty",void 0);E([A({type:Array}),w("design:type",Array)],ls.prototype,"_selectedRuns",void 0);E([A({type:Object}),w("design:type",Object)],ls.prototype,"_runToTag",void 0);E([A({type:Object}),w("design:type",Object)],ls.prototype,"_runToTagInfo",void 0);E([A({type:Boolean}),w("design:type",Boolean)],ls.prototype,"_dataNotFound",void 0);E([A({type:String}),w("design:type",String)],ls.prototype,"_tagFilter",void 0);E([A({type:Boolean}),w("design:type",Boolean)],ls.prototype,"_restamp",void 0);E([A({type:Boolean}),w("design:type",Boolean)],ls.prototype,"_categoriesDomReady",void 0);E([A({type:Object}),w("design:type",Ae)],ls.prototype,"_requestManager",void 0);E([Rt("_runToTag","_selectedRuns","_tagFilter","_categoriesDomReady"),w("design:type",Array),w("design:paramtypes",[])],ls.prototype,"_categories",null);ls=E([yt("tf-histogram-dashboard")],ls);var u3=class{constructor(t,r=!0){this._requestManager=t,this._useHttpGet=r}getExperiment(t){return this._sendRequest("/experiment",t)}getDownloadUrl(t,r,n){return _e().pluginRouteForSrc("hparams","/download_data",new URLSearchParams({format:t,columnsVisibility:JSON.stringify(n),request:JSON.stringify(r)}))}listSessionGroups(t){return this._sendRequest("/session_groups",t)}listMetricEvals(t){return this._sendRequest("/metric_evals",t)}_sendRequest(t,r){if(this._useHttpGet){let o=_e().pluginRoute("hparams",t,new URLSearchParams({request:JSON.stringify(r)}));return this._requestManager.request(o)}let n=new Ux;n.withCredentials=!0,n.methodType=Am.POST,n.contentType="text/plain",n.body=JSON.stringify(r);let i=_e().pluginRoute("hparams",t);return this._requestManager.requestWithOptions(i,n)}};var _ce=Ee(Oe(),1);var DH=class extends mt{constructor(){super(...arguments),this.orientation="horizontal"}};DH.template=Q`
    <slot name="content"></slot>

    <style>
      :host {
        display: block;
      }

      :host slot {
        display: flex;
        height: 100%;
        width: 100%;
      }

      :host ::slotted(*) {
        flex: 0 0 auto;
      }

      :host([orientation='horizontal']) slot {
        flex-direction: row;
        overflow-x: auto;
      }

      :host([orientation='vertical']) slot {
        flex-direction: column;
        overflow-y: auto;
      }

      :host ::slotted(*:not(:last-child)) {
        border: 0 solid var(--divider-color, #ccc);
      }

      :host([orientation='vertical']) ::slotted(*:not(:last-child)) {
        border-bottom-width: 5px;
      }

      :host([orientation='horizontal']) ::slotted(*:not(:last-child)) {
        border-right-width: 5px;
      }
    </style>
  `;E([A({type:String,reflectToAttribute:!0}),w("design:type",String)],DH.prototype,"orientation",void 0);DH=E([yt("hparams-split-layout")],DH);var cs={};Ks(cs,{columnValueByIndex:()=>x0,columnValueByVisibleIndex:()=>BH,euclideanDist:()=>h3,filterSet:()=>Pur,getAbsoluteColumnIndex:()=>zH,hashOfString:()=>dct,hparamName:()=>Fd,hparamValueByIndex:()=>hce,hparamValueByName:()=>uce,hparamValueByVisibleIndex:()=>mce,isNullOrUndefined:()=>Tur,l2NormSquared:()=>p3,metricName:()=>Qu,metricValueByIndex:()=>fce,metricValueByName:()=>f3,metricValueByVisibleIndex:()=>FH,numColumns:()=>uct,numHParams:()=>lce,numMetrics:()=>cce,numVisibleColumns:()=>wur,numVisibleHParams:()=>pce,numVisibleMetrics:()=>dce,numericColumnExtent:()=>hct,pointToRectangleDist:()=>gce,prettyPrint:()=>b0,prettyPrintHParamValueByName:()=>Sur,prettyPrintMetricValueByName:()=>Mur,quadTreeVisitPointsInDisk:()=>Aur,quadTreeVisitPointsInRect:()=>Cur,rotateStr:()=>Eur,schemaColumnName:()=>cct,schemaVisibleColumnName:()=>bur,sessionGroupWithName:()=>fct,setArrayObservably:()=>pct,translateStr:()=>yP,visibleNumericColumnExtent:()=>_P});var OH=Ee(Oe(),1);function Fd(e){return e.displayName!==""&&e.displayName!==void 0?e.displayName:e.name}function Qu(e){if(e.displayName!==""&&e.displayName!==void 0)return e.displayName;let t=e.name.group,r=e.name.tag;return t===void 0&&(t=""),r===void 0&&(r=""),t===""?r:t+"."+r}function cct(e,t){if(t<e.hparamColumns.length)return Fd(e.hparamColumns[t].hparamInfo);let r=t-e.hparamColumns.length;return Qu(e.metricColumns[r].metricInfo)}function lce(e){return e.hparamColumns.length}function cce(e){return e.metricColumns.length}function uct(e){return lce(e)+cce(e)}function uce(e,t){return e[t]}function f3(e,t){return e.find(r=>OH.isEqual(r.name,t))}function hce(e,t,r){return t.hparams[e.hparamColumns[r].hparamInfo.name]}function fce(e,t,r){let n=e.metricColumns[r].metricInfo.name,i=f3(t.metricValues,n);return i===void 0||i.value==="NaN"?void 0:i.value}function x0(e,t,r){return r<e.hparamColumns.length?hce(e,t,r):fce(e,t,r-e.hparamColumns.length)}function hct(e,t,r){return aa(t,n=>x0(e,n,r))}function zH(e,t,r){let n;if(r<t.hparamInfos.length)n=e.hparamColumns.findIndex(i=>i.hparamInfo.name===t.hparamInfos[r].name);else{let i=r-t.hparamInfos.length,o=t.metricInfos[i].name;n=e.hparamColumns.length+e.metricColumns.findIndex(a=>a.metricInfo.name===o)}return console.assert(n!==-1),n}function bur(e,t){if(t<e.hparamInfos.length)return Fd(e.hparamInfos[t]);let r=t-e.hparamInfos.length;return Qu(e.metricInfos[r])}function pce(e){return e.hparamInfos.length}function dce(e){return e.metricInfos.length}function wur(e){return pce(e)+dce(e)}function _P(e,t,r){return aa(t,n=>BH(e,n,r))}function Sur(e,t){return b0(uce(e,t))}function Mur(e,t){return b0(f3(e,t))}function fct(e,t){return e.find(r=>r.name===t)}function mce(e,t,r){return t.hparams[e.hparamInfos[r].name]}function FH(e,t,r){let n=e.metricInfos[r].name,i=f3(t.metricValues,n);return i===void 0||i.value==="NaN"?void 0:i.value}function BH(e,t,r){return r<e.hparamInfos.length?mce(e,t,r):FH(e,t,r-e.hparamInfos.length)}function b0(e){return OH.isNumber(e)?e.toPrecision(5):e==null?"":e.toString()}function p3(e,t){return e*e+t*t}function h3(e,t,r,n){return Math.sqrt(p3(e-r,t-n))}function gce(e,t,r,n,i,o){if(e<r&&t<n)return h3(e,t,r,n);if(r<=e&&e<i&&t<n)return n-t;if(i<=e&&t<n)return h3(e,t,i,n);if(e<r&&n<=t&&t<o)return r-e;if(r<=e&&e<i&&n<=t&&t<o)return 0;if(i<=e&&n<=t&&t<o)return e-i;if(e<r&&o<=t)return h3(e,t,r,o);if(r<=e&&e<i&&o<=t)return t-o;if(i<=e&&o<=t)return h3(e,t,i,o);throw"Point (x,y) must be in one of the regions defined above."}function yP(e,t){return t===void 0?"translate("+e+")":"translate("+e+","+t+")"}function Eur(e,t,r){let n="rotate("+e;return t!==void 0&&r!==void 0&&(n=n+","+t+","+r),n=n+")",n}function Tur(e){return e==null}function Cur(e,t,r,n,i,o){e.visit((a,s,l,c,u)=>{if(a.length===void 0){do{let h=e.x()(a.data),f=e.y()(a.data);t<=h&&h<n&&r<=f&&f<i&&o(a.data)}while(a=a.next);return!0}return s>=n||c<=t||l>=i||u<=r})}function Aur(e,t,r,n,i){e.visit((o,a,s,l,c)=>{if(o.length===void 0){do{let u=e.x()(o.data),h=e.y()(o.data),f=h3(t,r,u,h);f<=n&&i(o.data,f)}while(o=o.next);return!0}return gce(t,r,a,s,l,c)>n})}function Pur(e,t){let r=new Set;return e.forEach(n=>{t(n)&&r.add(n)}),r}function pct(e,t,r){let n=e.get(t,e);if(!Array.isArray(n)){e.set(t,r);return}e.splice.apply(e,[t,0,n.length].concat(r))}function dct(e){let t=0;for(let r=0;r<e.length;++r)t=t*31+e.charCodeAt(r)&4294967295;return t+TI(2,31)}var Iur=10,Qn=class extends Gt(mt){constructor(){super(...arguments),this.configuration={schema:{hparamColumns:Array(),metricColumns:Array()},columnsVisibility:Array(),visibleSchema:{hparamInfos:Array(),metricInfos:Array()}},this.sessionGroups=[],this.dataLoadedWithNonEmptyHparams=!1,this.dataLoadedWithEmptyHparams=!1,this._statuses=[{value:"STATUS_UNKNOWN",displayName:"Unknown",allowed:!0},{value:"STATUS_SUCCESS",displayName:"Success",allowed:!0},{value:"STATUS_FAILURE",displayName:"Failure",allowed:!0},{value:"STATUS_RUNNING",displayName:"Running",allowed:!0}],this._getExperimentResolved=new Promise(t=>{this._resolveGetExperiment=t}),this._listSessionGroupsCanceller=new an,this._pageSizeInput={value:"100",invalid:!1},this._pageNumberInput={value:"1",invalid:!1},this._pageCountStr="?",this._hparamName=Fd,this._metricName=Qu,this._prettyPrint=b0}reload(){this._queryServer()}_csvUrl(t,r){return this._downloadDataUrl(t,r,"csv")}_jsonUrl(t,r){return this._downloadDataUrl(t,r,"json")}_latexUrl(t,r){return this._downloadDataUrl(t,r,"latex")}_downloadDataUrl(t,r,n){let i=r.columnsVisibility;return this.backend.getDownloadUrl(n,t,i)}_computeExperimentAndRelatedProps(){let t=cs;if(t.isNullOrUndefined(this.backend)||t.isNullOrUndefined(this.experimentName))return;let r={experimentName:this.experimentName};this.backend.getExperiment(r).then(n=>{_ce.isEqual(n,this._experiment)||(this.set("_experiment",n),this._computeHParams(),this._computeMetrics(),this._queryServer(),this._resolveGetExperiment())}).finally(()=>{this._computeDataFound()})}_computeDataFound(){let t=Boolean(this._experiment&&this._experiment.hparamInfos&&this._experiment.hparamInfos.length>0);this.set("dataLoadedWithNonEmptyHparams",t),this.set("dataLoadedWithEmptyHparams",!t)}_computeHParams(){let t=[];this._experiment.hparamInfos.forEach(i=>{let o={info:i,displayed:!1,filter:{}};o.info.hasOwnProperty("domainDiscrete")?o.info.domainDiscrete.length<Iur?(o.filter.domainDiscrete=[],o.info.domainDiscrete.forEach(a=>{o.filter.domainDiscrete.push({value:a,checked:!0})})):o.filter.regexp="":o.info.type==="DATA_TYPE_FLOAT64"?o.filter.interval={min:{value:"",invalid:!1},max:{value:"",invalid:!1}}:console.warn("cannot process domain type %s without discrete domain values",o.info.type),t.push(o)}),t.sort((i,o)=>i.info.differs===o.info.differs?0:i.info.differs?-1:1);let n=Math.min(5,t.length);for(let i=0;i<n;i++)t[i].displayed=!0;this.set("_hparams",t)}_computeMetrics(){let t=[];this._experiment.metricInfos.forEach((n,i)=>{let o={info:n,filter:{interval:{min:{value:"",invalid:!1},max:{value:"",invalid:!1}}},displayed:i<5};t.push(o)}),this.set("_metrics",t)}_computeSchema(){return!this._hparams||!this._metrics?{hparamColumns:[],metricColumns:[]}:{hparamColumns:this._hparams.map(t=>({hparamInfo:t.info})),metricColumns:this._metrics.map(t=>({metricInfo:t.info}))}}_updateConfiguration(){this.debounce("_updateConfiguration",()=>{this.configuration={schema:this._computeSchema(),columnsVisibility:this._computeColumnsVisibility(),visibleSchema:this._computeVisibleSchema()}})}_computeColumnsVisibility(){return!this._hparams||!this._metrics?[]:this._hparams.map(t=>t.displayed).concat(this._metrics.map(t=>t.displayed))}_computeVisibleSchema(){if(!this._hparams||!this._metrics)return{hparamInfos:[],metricInfos:[]};let t=this._hparams.filter(n=>n.displayed).map(n=>n.info),r=this._metrics.filter(n=>n.displayed).map(n=>n.info);return{hparamInfos:t,metricInfos:r}}_hasRegexpFilter(t){return t.filter.regexp!==void 0}_queryServer(){this.debounce("queryServer",()=>this._queryServerNoDebounce(),100)}_queryServerNoDebounce(){if(!(!this._hparams||!this._metrics))return this._sendListSessionGroupsRequest().then(this._listSessionGroupsCanceller.cancellable(({value:t,cancelled:r})=>{if(!r){if(t.totalSize>=0){let n=+this._pageSizeInput.value;this.set("_pageCountStr",String(Math.ceil(t.totalSize/n))),this.set("_totalSessionGroupsCountStr",t.totalSize)}else this.set("_pageCountStr","?"),this.set("_totalSessionGroupsCountStr","Unknown");pct(this,"sessionGroups",t.sessionGroups)}}))}_sendListSessionGroupsRequest(){let t=this._buildListSessionGroupsRequest();if(t!==null)return this.set("_sessionGroupsRequest",t),this._listSessionGroupsCanceller.cancelAll(),this.backend.listSessionGroups(t)}_buildListSessionGroupsRequest(){let t=this,r=!0;function n(h){return h.min.value!==""||h.max.value!==""}function i(h){let f=t.get(h+".min.value");console.assert(f!==void 0);let p=f===""?"-Infinity":+f,d=isNaN(p);t.set(h+".min.invalid",d),r=r&&!d;let g=t.get(h+".max.value");console.assert(g!==void 0);let _=g===""?"Infinity":+g,y=isNaN(_);return t.set(h+".max.invalid",y),r=r&&!y,d||y?null:{minValue:p,maxValue:_}}function o(h){let f=t.get(h+".value");console.assert(f!==void 0);let p=+f,d=Number.isInteger(p)&&p>0;return t.set(h+".invalid",!d),r=r&&d,d?p:null}let a=this._statuses.filter(h=>h.allowed).map(h=>h.value),s=[];if(this._hparams.forEach((h,f)=>{let p={hparam:h.info.name};h.filter.domainDiscrete?h.filter.domainDiscrete.every(g=>g.checked)||(p.filterDiscrete=[],h.filter.domainDiscrete.forEach(g=>{g.checked&&p.filterDiscrete.push(g.value)})):h.filter.interval?n(h.filter.interval)&&(p.filterInterval=i("_hparams."+f+".filter.interval")):h.filter.regexp&&(p.filterRegexp=h.filter.regexp),s.push(p)}),this._metrics.forEach((h,f)=>{let p={metric:h.info.name};n(h.filter.interval)&&(p.filterInterval=i("_metrics."+f+".filter.interval")),s.push(p)}),this._sortByIndex!==void 0&&this._sortDirection!==void 0){if(!(this._sortByIndex in s))return console.error("No column in colParams with index sortByIndex: %s",this._sortByIndex),null;s[this._sortByIndex].order=this._sortDirection===0?"ORDER_ASC":"ORDER_DESC"}let l=o("_pageNumberInput")||0,c=o("_pageSizeInput")||0;if(!r)return null;let u=c*(l-1);return{experimentName:this.experimentName,allowedStatuses:a,colParams:s,startIndex:u,sliceSize:c}}_metricSortByIndex(t){return t+this._hparams.length}};Qn.template=Q`
    <hparams-split-layout orientation="vertical">
      <div slot="content" class="section hyperparameters">
        <div class="section-title">Hyperparameters</div>
        <template is="dom-repeat" items="{{_hparams}}" as="hparam">
          <div class="hparam">
            <paper-checkbox
              checked="{{hparam.displayed}}"
              class="hparam-checkbox"
            >
              [[_hparamName(hparam.info)]]
            </paper-checkbox>
            <!-- Precisely one of the templates below will be stamped.-->
            <!-- 1. A list of checkboxes -->
            <template is="dom-if" if="[[hparam.filter.domainDiscrete]]">
              <template
                is="dom-repeat"
                items="[[hparam.filter.domainDiscrete]]"
              >
                <paper-checkbox
                  checked="{{item.checked}}"
                  class="discrete-value-checkbox"
                  on-change="_queryServer"
                >
                  [[_prettyPrint(item.value)]]
                </paper-checkbox>
              </template>
            </template>
            <!-- 2. A numeric interval -->
            <template is="dom-if" if="[[hparam.filter.interval]]">
              <paper-input
                label="Min"
                value="{{hparam.filter.interval.min.value}}"
                allowed_pattern="[0-9.e\\-]"
                on-value-changed="_queryServer"
                error-message="Invalid input"
                invalid="[[hparam.filter.interval.min.invalid]]"
                placeholder="-infinity"
              >
              </paper-input>
              <paper-input
                label="Max"
                value="{{hparam.filter.interval.max.value}}"
                allowed_pattern="[0-9.e\\-]"
                on-value-changed="_queryServer"
                error-message="Invalid input"
                invalid="[[hparam.filter.interval.max.invalid]]"
                placeholder="+infinity"
              >
              </paper-input>
            </template>
            <!-- 3. A regexp -->
            <template is="dom-if" if="[[_hasRegexpFilter(hparam)]]">
              <paper-input
                label="Regular expression"
                value="{{hparam.filter.regexp}}"
                on-value-changed="_queryServer"
              >
              </paper-input>
            </template>
          </div>
        </template>
      </div>
      <div slot="content" class="section metrics">
        <div class="section-title">Metrics</div>
        <template is="dom-repeat" items="{{_metrics}}" as="metric">
          <div class="metric">
            <!-- TODO(erez): Make it easier to handle a large number of
                  metrics:
                  1. Add an 'isolator' radio-button to select just one
                  metric and
                  hide all the rest
                  2. Add a 'toggle-all' button that will hide/unhide
                    all the
                  metrics.
                  Use similar logic/appearance to the run-selector of
                  scalars.-->
            <paper-checkbox
              checked="{{metric.displayed}}"
              class="metric-checkbox"
            >
              [[_metricName(metric.info)]]
            </paper-checkbox>
            <div class="inline-element">
              <paper-input
                label="Min"
                value="{{metric.filter.interval.min.value}}"
                allowed-pattern="[0-9.e\\-]"
                on-value-changed="_queryServer"
                error-message="Invalid input"
                invalid="{{metric.filter.interval.min.invalid}}"
                placeholder="-infinity"
              >
              </paper-input>
            </div>
            <div class="inline-element">
              <paper-input
                label="Max"
                allowed-pattern="[0-9.e\\-]"
                value="{{metric.filter.interval.max.value}}"
                on-value-changed="_queryServer"
                error-message="Invalid input"
                invalid="{{metric.filter.interval.max.invalid}}"
                placeholder="+infinity"
              >
              </paper-input>
            </div>
          </div>
        </template>
      </div>
      <div slot="content" class="section status">
        <div class="section-title">Status</div>
        <template is="dom-repeat" items="[[_statuses]]" as="status">
          <paper-checkbox checked="{{status.allowed}}" on-change="_queryServer">
            [[status.displayName]]
          </paper-checkbox>
        </template>
      </div>
      <div slot="content" class="section sorting">
        <div class="section-title">Sorting</div>
        <paper-dropdown-menu
          label="Sort by"
          on-selected-item-changed="_queryServer"
          horizontal-align="left"
        >
          <paper-listbox
            class="dropdown-content"
            slot="dropdown-content"
            selected="{{_sortByIndex}}"
            on-selected-item-changed="_queryServer"
          >
            <template is="dom-repeat" items="[[_hparams]]" as="hparam">
              <paper-item> [[_hparamName(hparam.info)]] </paper-item>
            </template>
            <template is="dom-repeat" items="[[_metrics]]" as="metric">
              <paper-item> [[_metricName(metric.info)]] </paper-item>
            </template>
          </paper-listbox>
        </paper-dropdown-menu>
        <paper-dropdown-menu
          label="Direction"
          on-selected-item-changed="_queryServer"
          horizontal-align="left"
        >
          <paper-listbox
            class="dropdown-content"
            slot="dropdown-content"
            selected="{{_sortDirection}}"
          >
            <paper-item>Ascending</paper-item>
            <paper-item>Descending</paper-item>
          </paper-listbox>
        </paper-dropdown-menu>
      </div>
      <div slot="content" class="section paging">
        <div class="section-title">Paging</div>
        <div>
          Number of matching session groups: [[_totalSessionGroupsCountStr]]
        </div>
        <div class="inline-element page-number-input">
          <paper-input
            label="Page #"
            value="{{_pageNumberInput.value}}"
            allowed-pattern="[0-9]"
            error-message="Invalid input"
            invalid="[[_pageNumberInput.invalid]]"
            on-value-changed="_queryServer"
          >
            <div slot="suffix" class="page-suffix">/ [[_pageCountStr]]</div>
          </paper-input>
        </div>
        <div class="inline-element page-size-input">
          <paper-input
            label="Max # of session groups per page:"
            value="{{_pageSizeInput.value}}"
            allowed-pattern="[0-9]"
            error-message="Invalid input"
            invalid="[[_pageSizeInput.invalid]]"
            on-value-changed="_queryServer"
          >
          </paper-input>
        </div>
      </div>
      <div slot="content" class="section download">
        <template is="dom-if" if="[[_sessionGroupsRequest]]">
          Download data as
          <span>
            <a
              id="csvLink"
              download="hparams_table.csv"
              href="[[_csvUrl(_sessionGroupsRequest, configuration)]]"
              >CSV</a
            >
            <a
              id="jsonLink"
              download="hparams_table.json"
              href="[[_jsonUrl(_sessionGroupsRequest, configuration)]]"
              >JSON</a
            >
            <a
              id="latexLink"
              download="hparams_table.tex"
              href="[[_latexUrl(_sessionGroupsRequest, configuration)]]"
              >LaTeX</a
            >
          </span>
        </template>
      </div>
    </hparams-split-layout>
    <style>
      .section {
        padding: 10px;
      }
      .section-title {
        display: block;
        font-weight: bold;
        text-decoration: underline;
        margin-bottom: 7px;
      }
      .discrete-value-checkbox,
      .metric-checkbox,
      .hparam-checkbox {
        display: block;
      }
      .discrete-value-checkbox {
        margin-left: 20px;
      }
      .hparam,
      .metric {
        display: block;
      }
      .inline-element {
        display: inline-block;
        width: 40%;
        margin-left: 10px;
      }
      .page-number-input {
        width: 20%;
      }
      .page-size-input {
        width: 60%;
      }
      vaadin-split-layout {
        height: 100%;
      }
      paper-listbox {
        max-height: 15em;
      }
      .page-suffix {
        white-space: nowrap;
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],Qn.prototype,"experimentName",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],Qn.prototype,"configuration",void 0);E([A({type:Array,notify:!0}),w("design:type",Object)],Qn.prototype,"sessionGroups",void 0);E([A({type:Boolean,notify:!0}),w("design:type",Boolean)],Qn.prototype,"dataLoadedWithNonEmptyHparams",void 0);E([A({type:Boolean,notify:!0}),w("design:type",Boolean)],Qn.prototype,"dataLoadedWithEmptyHparams",void 0);E([A({type:Object}),w("design:type",Object)],Qn.prototype,"_experiment",void 0);E([A({type:Array}),w("design:type",Array)],Qn.prototype,"_hparams",void 0);E([A({type:Array}),w("design:type",Array)],Qn.prototype,"_metrics",void 0);E([A({type:Array}),w("design:type",Object)],Qn.prototype,"_statuses",void 0);E([A({type:Object}),w("design:type",Object)],Qn.prototype,"_getExperimentResolved",void 0);E([A({type:Object}),w("design:type",Function)],Qn.prototype,"_resolveGetExperiment",void 0);E([A({type:Object}),w("design:type",Object)],Qn.prototype,"_listSessionGroupsCanceller",void 0);E([A({type:Number}),w("design:type",Number)],Qn.prototype,"_sortByIndex",void 0);E([A({type:Number}),w("design:type",Number)],Qn.prototype,"_sortDirection",void 0);E([A({type:Object}),w("design:type",Object)],Qn.prototype,"_pageSizeInput",void 0);E([A({type:Object}),w("design:type",Object)],Qn.prototype,"_pageNumberInput",void 0);E([A({type:String}),w("design:type",String)],Qn.prototype,"_pageCountStr",void 0);E([A({type:String}),w("design:type",String)],Qn.prototype,"_totalSessionGroupsCountStr",void 0);E([A({type:Object}),w("design:type",Object)],Qn.prototype,"_sessionGroupsRequest",void 0);E([Bt("backend","experimentName"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Qn.prototype,"_computeExperimentAndRelatedProps",null);E([Bt("_hparams.*","_metrics.*"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Qn.prototype,"_updateConfiguration",null);Qn=E([yt("tf-hparams-query-pane")],Qn);var Uct=Ee(Oe(),1);var mct=typeof window!="undefined"&&window.customElements!=null&&window.customElements.polyfillWrapFlushCallback!==void 0;var i1=(e,t,r=null)=>{for(;t!==r;){let n=t.nextSibling;e.removeChild(t),t=n}};var Yc=`{{lit-${String(Math.random()).slice(2)}}}`,gct=`<!--${Yc}-->`,yce=new RegExp(`${Yc}|${gct}`),d3="$lit$",o1=class{constructor(t,r){this.parts=[],this.element=r;let n=[],i=[],o=document.createTreeWalker(r.content,133,null,!1),a=0,s=-1,l=0,{strings:c,values:{length:u}}=t;for(;l<u;){let h=o.nextNode();if(h===null){o.currentNode=i.pop();continue}if(s++,h.nodeType===1){if(h.hasAttributes()){let f=h.attributes,{length:p}=f,d=0;for(let g=0;g<p;g++)vce(f[g].name,d3)&&d++;for(;d-- >0;){let g=c[l],_=HH.exec(g)[2],y=_.toLowerCase()+d3,x=h.getAttribute(y);h.removeAttribute(y);let b=x.split(yce);this.parts.push({type:"attribute",index:s,name:_,strings:b}),l+=b.length-1}}h.tagName==="TEMPLATE"&&(i.push(h),o.currentNode=h.content)}else if(h.nodeType===3){let f=h.data;if(f.indexOf(Yc)>=0){let p=h.parentNode,d=f.split(yce),g=d.length-1;for(let _=0;_<g;_++){let y,x=d[_];if(x==="")y=Yf();else{let b=HH.exec(x);b!==null&&vce(b[2],d3)&&(x=x.slice(0,b.index)+b[1]+b[2].slice(0,-d3.length)+b[3]),y=document.createTextNode(x)}p.insertBefore(y,h),this.parts.push({type:"node",index:++s})}d[g]===""?(p.insertBefore(Yf(),h),n.push(h)):h.data=d[g],l+=g}}else if(h.nodeType===8)if(h.data===Yc){let f=h.parentNode;(h.previousSibling===null||s===a)&&(s++,f.insertBefore(Yf(),h)),a=s,this.parts.push({type:"node",index:s}),h.nextSibling===null?h.data="":(n.push(h),s--),l++}else{let f=-1;for(;(f=h.data.indexOf(Yc,f+1))!==-1;)this.parts.push({type:"node",index:-1}),l++}}for(let h of n)h.parentNode.removeChild(h)}},vce=(e,t)=>{let r=e.length-t.length;return r>=0&&e.slice(r)===t},vP=e=>e.index!==-1,Yf=()=>document.createComment(""),HH=/([ \x09\x0a\x0c\x0d])([^\0-\x1F\x7F-\x9F "'>=/]+)([ \x09\x0a\x0c\x0d]*=[ \x09\x0a\x0c\x0d]*(?:[^ \x09\x0a\x0c\x0d"'`<>=]*|"[^"]*|'[^']*))$/;var _ct=133;function yct(e,t){let{element:{content:r},parts:n}=e,i=document.createTreeWalker(r,_ct,null,!1),o=xP(n),a=n[o],s=-1,l=0,c=[],u=null;for(;i.nextNode();){s++;let h=i.currentNode;for(h.previousSibling===u&&(u=null),t.has(h)&&(c.push(h),u===null&&(u=h)),u!==null&&l++;a!==void 0&&a.index===s;)a.index=u!==null?-1:a.index-l,o=xP(n,o),a=n[o]}c.forEach(h=>h.parentNode.removeChild(h))}var Lur=e=>{let t=e.nodeType===11?0:1,r=document.createTreeWalker(e,_ct,null,!1);for(;r.nextNode();)t++;return t},xP=(e,t=-1)=>{for(let r=t+1;r<e.length;r++){let n=e[r];if(vP(n))return r}return-1};function xce(e,t,r=null){let{element:{content:n},parts:i}=e;if(r==null){n.appendChild(t);return}let o=document.createTreeWalker(n,_ct,null,!1),a=xP(i),s=0,l=-1;for(;o.nextNode();)for(l++,o.currentNode===r&&(s=Lur(t),r.parentNode.insertBefore(t,r));a!==-1&&i[a].index===l;){if(s>0){for(;a!==-1;)i[a].index+=s,a=xP(i,a);return}a=xP(i,a)}}var kur=new WeakMap;var a1=e=>typeof e=="function"&&kur.has(e);var Ll={},VH={};var w0=class{constructor(t,r,n){this.__parts=[],this.template=t,this.processor=r,this.options=n}update(t){let r=0;for(let n of this.__parts)n!==void 0&&n.setValue(t[r]),r++;for(let n of this.__parts)n!==void 0&&n.commit()}_clone(){let t=mct?this.template.element.content.cloneNode(!0):document.importNode(this.template.element.content,!0),r=[],n=this.template.parts,i=document.createTreeWalker(t,133,null,!1),o=0,a=0,s,l=i.nextNode();for(;o<n.length;){if(s=n[o],!vP(s)){this.__parts.push(void 0),o++;continue}for(;a<s.index;)a++,l.nodeName==="TEMPLATE"&&(r.push(l),i.currentNode=l.content),(l=i.nextNode())===null&&(i.currentNode=r.pop(),l=i.nextNode());if(s.type==="node"){let c=this.processor.handleTextExpression(this.options);c.insertAfterNode(l.previousSibling),this.__parts.push(c)}else this.__parts.push(...this.processor.handleAttributeExpressions(l,s.name,s.strings,this.options));o++}return mct&&(document.adoptNode(t),customElements.upgrade(t)),t}};var bce=window.trustedTypes&&trustedTypes.createPolicy("lit-html",{createHTML:e=>e}),Nur=` ${Yc} `,S0=class{constructor(t,r,n,i){this.strings=t,this.values=r,this.type=n,this.processor=i}getHTML(){let t=this.strings.length-1,r="",n=!1;for(let i=0;i<t;i++){let o=this.strings[i],a=o.lastIndexOf("<!--");n=(a>-1||n)&&o.indexOf("-->",a+1)===-1;let s=HH.exec(o);s===null?r+=o+(n?Nur:gct):r+=o.substr(0,s.index)+s[1]+s[2]+d3+s[3]+Yc}return r+=this.strings[t],r}getTemplateElement(){let t=document.createElement("template"),r=this.getHTML();return bce!==void 0&&(r=bce.createHTML(r)),t.innerHTML=r,t}};var GH=e=>e===null||!(typeof e=="object"||typeof e=="function"),UH=e=>Array.isArray(e)||!!(e&&e[Symbol.iterator]),m3=class{constructor(t,r,n){this.dirty=!0,this.element=t,this.name=r,this.strings=n,this.parts=[];for(let i=0;i<n.length-1;i++)this.parts[i]=this._createPart()}_createPart(){return new bP(this)}_getValue(){let t=this.strings,r=t.length-1,n=this.parts;if(r===1&&t[0]===""&&t[1]===""){let o=n[0].value;if(typeof o=="symbol")return String(o);if(typeof o=="string"||!UH(o))return o}let i="";for(let o=0;o<r;o++){i+=t[o];let a=n[o];if(a!==void 0){let s=a.value;if(GH(s)||!UH(s))i+=typeof s=="string"?s:String(s);else for(let l of s)i+=typeof l=="string"?l:String(l)}}return i+=t[r],i}commit(){this.dirty&&(this.dirty=!1,this.element.setAttribute(this.name,this._getValue()))}},bP=class{constructor(t){this.value=void 0,this.committer=t}setValue(t){t!==Ll&&(!GH(t)||t!==this.value)&&(this.value=t,a1(t)||(this.committer.dirty=!0))}commit(){for(;a1(this.value);){let t=this.value;this.value=Ll,t(this)}this.value!==Ll&&this.committer.commit()}},Bd=class{constructor(t){this.value=void 0,this.__pendingValue=void 0,this.options=t}appendInto(t){this.startNode=t.appendChild(Yf()),this.endNode=t.appendChild(Yf())}insertAfterNode(t){this.startNode=t,this.endNode=t.nextSibling}appendIntoPart(t){t.__insert(this.startNode=Yf()),t.__insert(this.endNode=Yf())}insertAfterPart(t){t.__insert(this.startNode=Yf()),this.endNode=t.endNode,t.endNode=this.startNode}setValue(t){this.__pendingValue=t}commit(){if(this.startNode.parentNode===null)return;for(;a1(this.__pendingValue);){let r=this.__pendingValue;this.__pendingValue=Ll,r(this)}let t=this.__pendingValue;t!==Ll&&(GH(t)?t!==this.value&&this.__commitText(t):t instanceof S0?this.__commitTemplateResult(t):t instanceof Node?this.__commitNode(t):UH(t)?this.__commitIterable(t):t===VH?(this.value=VH,this.clear()):this.__commitText(t))}__insert(t){this.endNode.parentNode.insertBefore(t,this.endNode)}__commitNode(t){this.value!==t&&(this.clear(),this.__insert(t),this.value=t)}__commitText(t){let r=this.startNode.nextSibling;t=t==null?"":t;let n=typeof t=="string"?t:String(t);r===this.endNode.previousSibling&&r.nodeType===3?r.data=n:this.__commitNode(document.createTextNode(n)),this.value=t}__commitTemplateResult(t){let r=this.options.templateFactory(t);if(this.value instanceof w0&&this.value.template===r)this.value.update(t.values);else{let n=new w0(r,t.processor,this.options),i=n._clone();n.update(t.values),this.__commitNode(i),this.value=n}}__commitIterable(t){Array.isArray(this.value)||(this.value=[],this.clear());let r=this.value,n=0,i;for(let o of t)i=r[n],i===void 0&&(i=new Bd(this.options),r.push(i),n===0?i.appendIntoPart(this):i.insertAfterPart(r[n-1])),i.setValue(o),i.commit(),n++;n<r.length&&(r.length=n,this.clear(i&&i.endNode))}clear(t=this.startNode){i1(this.startNode.parentNode,t.nextSibling,this.endNode)}},wP=class{constructor(t,r,n){if(this.value=void 0,this.__pendingValue=void 0,n.length!==2||n[0]!==""||n[1]!=="")throw new Error("Boolean attributes can only contain a single expression");this.element=t,this.name=r,this.strings=n}setValue(t){this.__pendingValue=t}commit(){for(;a1(this.__pendingValue);){let r=this.__pendingValue;this.__pendingValue=Ll,r(this)}if(this.__pendingValue===Ll)return;let t=!!this.__pendingValue;this.value!==t&&(t?this.element.setAttribute(this.name,""):this.element.removeAttribute(this.name),this.value=t),this.__pendingValue=Ll}},SP=class extends m3{constructor(t,r,n){super(t,r,n),this.single=n.length===2&&n[0]===""&&n[1]===""}_createPart(){return new qH(this)}_getValue(){return this.single?this.parts[0].value:super._getValue()}commit(){this.dirty&&(this.dirty=!1,this.element[this.name]=this._getValue())}},qH=class extends bP{},wce=!1;(()=>{try{let e={get capture(){return wce=!0,!1}};window.addEventListener("test",e,e),window.removeEventListener("test",e,e)}catch(e){}})();var MP=class{constructor(t,r,n){this.value=void 0,this.__pendingValue=void 0,this.element=t,this.eventName=r,this.eventContext=n,this.__boundHandleEvent=i=>this.handleEvent(i)}setValue(t){this.__pendingValue=t}commit(){for(;a1(this.__pendingValue);){let o=this.__pendingValue;this.__pendingValue=Ll,o(this)}if(this.__pendingValue===Ll)return;let t=this.__pendingValue,r=this.value,n=t==null||r!=null&&(t.capture!==r.capture||t.once!==r.once||t.passive!==r.passive),i=t!=null&&(r==null||n);n&&this.element.removeEventListener(this.eventName,this.__boundHandleEvent,this.__options),i&&(this.__options=Dur(t),this.element.addEventListener(this.eventName,this.__boundHandleEvent,this.__options)),this.value=t,this.__pendingValue=Ll}handleEvent(t){typeof this.value=="function"?this.value.call(this.eventContext||this.element,t):this.value.handleEvent(t)}},Dur=e=>e&&(wce?{capture:e.capture,passive:e.passive,once:e.once}:e.capture);function vct(e){let t=s1.get(e.type);t===void 0&&(t={stringsArray:new WeakMap,keyString:new Map},s1.set(e.type,t));let r=t.stringsArray.get(e.strings);if(r!==void 0)return r;let n=e.strings.join(Yc);return r=t.keyString.get(n),r===void 0&&(r=new o1(e,e.getTemplateElement()),t.keyString.set(n,r)),t.stringsArray.set(e.strings,r),r}var s1=new Map;var M0=new WeakMap,xct=(e,t,r)=>{let n=M0.get(t);n===void 0&&(i1(t,t.firstChild),M0.set(t,n=new Bd(Object.assign({templateFactory:vct},r))),n.appendInto(t)),n.setValue(e),n.commit()};var WH=class{handleAttributeExpressions(t,r,n,i){let o=r[0];return o==="."?new SP(t,r.slice(1),n).parts:o==="@"?[new MP(t,r.slice(1),i.eventContext)]:o==="?"?[new wP(t,r.slice(1),n)]:new m3(t,r,n).parts}handleTextExpression(t){return new Bd(t)}},Sce=new WH;typeof window!="undefined"&&(window.litHtmlVersions||(window.litHtmlVersions=[])).push("1.4.1");var Ece=(e,t)=>`${e}--${t}`,YH=!0;typeof window.ShadyCSS=="undefined"?YH=!1:typeof window.ShadyCSS.prepareTemplateDom=="undefined"&&(console.warn("Incompatible ShadyCSS version detected. Please update to at least @webcomponents/webcomponentsjs@2.0.2 and @webcomponents/shadycss@1.3.1."),YH=!1);var Fur=e=>t=>{let r=Ece(t.type,e),n=s1.get(r);n===void 0&&(n={stringsArray:new WeakMap,keyString:new Map},s1.set(r,n));let i=n.stringsArray.get(t.strings);if(i!==void 0)return i;let o=t.strings.join(Yc);if(i=n.keyString.get(o),i===void 0){let a=t.getTemplateElement();YH&&window.ShadyCSS.prepareTemplateDom(a,e),i=new o1(t,a),n.keyString.set(o,i)}return n.stringsArray.set(t.strings,i),i},Bur=["html","svg"],Hur=e=>{Bur.forEach(t=>{let r=s1.get(Ece(t,e));r!==void 0&&r.keyString.forEach(n=>{let{element:{content:i}}=n,o=new Set;Array.from(i.querySelectorAll("style")).forEach(a=>{o.add(a)}),yct(n,o)})})},Tce=new Set,Vur=(e,t,r)=>{Tce.add(e);let n=r?r.element:document.createElement("template"),i=t.querySelectorAll("style"),{length:o}=i;if(o===0){window.ShadyCSS.prepareTemplateStyles(n,e);return}let a=document.createElement("style");for(let c=0;c<o;c++){let u=i[c];u.parentNode.removeChild(u),a.textContent+=u.textContent}Hur(e);let s=n.content;r?xce(r,a,s.firstChild):s.insertBefore(a,s.firstChild),window.ShadyCSS.prepareTemplateStyles(n,e);let l=s.querySelector("style");if(window.ShadyCSS.nativeShadow&&l!==null)t.insertBefore(l.cloneNode(!0),t.firstChild);else if(r){s.insertBefore(a,s.firstChild);let c=new Set;c.add(a),yct(r,c)}},Cce=(e,t,r)=>{if(!r||typeof r!="object"||!r.scopeName)throw new Error("The `scopeName` option is required.");let n=r.scopeName,i=M0.has(t),o=YH&&t.nodeType===11&&!!t.host,a=o&&!Tce.has(n),s=a?document.createDocumentFragment():t;if(xct(e,s,Object.assign({templateFactory:Fur(n)},r)),a){let l=M0.get(s);M0.delete(s);let c=l.value instanceof w0?l.value.template:void 0;Vur(n,s,c),i1(t,t.firstChild),t.appendChild(s),M0.set(t,l)}!i&&o&&window.ShadyCSS.styleElement(t.host)};var Ace;window.JSCompiler_renameProperty=(e,t)=>e;var Tct={toAttribute(e,t){switch(t){case Boolean:return e?"":null;case Object:case Array:return e==null?e:JSON.stringify(e)}return e},fromAttribute(e,t){switch(t){case Boolean:return e!==null;case Number:return e===null?null:Number(e);case Object:case Array:return JSON.parse(e)}return e}},Pce=(e,t)=>t!==e&&(t===t||e===e),bct={attribute:!0,type:String,converter:Tct,reflect:!1,hasChanged:Pce},wct=1,Sct=1<<2,Mct=1<<3,Ect=1<<4,Cct="finalized",g3=class extends HTMLElement{constructor(){super(),this.initialize()}static get observedAttributes(){this.finalize();let t=[];return this._classProperties.forEach((r,n)=>{let i=this._attributeNameForProperty(n,r);i!==void 0&&(this._attributeToPropertyMap.set(i,n),t.push(i))}),t}static _ensureClassProperties(){if(!this.hasOwnProperty(JSCompiler_renameProperty("_classProperties",this))){this._classProperties=new Map;let t=Object.getPrototypeOf(this)._classProperties;t!==void 0&&t.forEach((r,n)=>this._classProperties.set(n,r))}}static createProperty(t,r=bct){if(this._ensureClassProperties(),this._classProperties.set(t,r),r.noAccessor||this.prototype.hasOwnProperty(t))return;let n=typeof t=="symbol"?Symbol():`__${t}`,i=this.getPropertyDescriptor(t,n,r);i!==void 0&&Object.defineProperty(this.prototype,t,i)}static getPropertyDescriptor(t,r,n){return{get(){return this[r]},set(i){let o=this[t];this[r]=i,this.requestUpdateInternal(t,o,n)},configurable:!0,enumerable:!0}}static getPropertyOptions(t){return this._classProperties&&this._classProperties.get(t)||bct}static finalize(){let t=Object.getPrototypeOf(this);if(t.hasOwnProperty(Cct)||t.finalize(),this[Cct]=!0,this._ensureClassProperties(),this._attributeToPropertyMap=new Map,this.hasOwnProperty(JSCompiler_renameProperty("properties",this))){let r=this.properties,n=[...Object.getOwnPropertyNames(r),...typeof Object.getOwnPropertySymbols=="function"?Object.getOwnPropertySymbols(r):[]];for(let i of n)this.createProperty(i,r[i])}}static _attributeNameForProperty(t,r){let n=r.attribute;return n===!1?void 0:typeof n=="string"?n:typeof t=="string"?t.toLowerCase():void 0}static _valueHasChanged(t,r,n=Pce){return n(t,r)}static _propertyValueFromAttribute(t,r){let n=r.type,i=r.converter||Tct,o=typeof i=="function"?i:i.fromAttribute;return o?o(t,n):t}static _propertyValueToAttribute(t,r){if(r.reflect===void 0)return;let n=r.type,i=r.converter;return(i&&i.toAttribute||Tct.toAttribute)(t,n)}initialize(){this._updateState=0,this._updatePromise=new Promise(t=>this._enableUpdatingResolver=t),this._changedProperties=new Map,this._saveInstanceProperties(),this.requestUpdateInternal()}_saveInstanceProperties(){this.constructor._classProperties.forEach((t,r)=>{if(this.hasOwnProperty(r)){let n=this[r];delete this[r],this._instanceProperties||(this._instanceProperties=new Map),this._instanceProperties.set(r,n)}})}_applyInstanceProperties(){this._instanceProperties.forEach((t,r)=>this[r]=t),this._instanceProperties=void 0}connectedCallback(){this.enableUpdating()}enableUpdating(){this._enableUpdatingResolver!==void 0&&(this._enableUpdatingResolver(),this._enableUpdatingResolver=void 0)}disconnectedCallback(){}attributeChangedCallback(t,r,n){r!==n&&this._attributeToProperty(t,n)}_propertyToAttribute(t,r,n=bct){let i=this.constructor,o=i._attributeNameForProperty(t,n);if(o!==void 0){let a=i._propertyValueToAttribute(r,n);if(a===void 0)return;this._updateState=this._updateState|Mct,a==null?this.removeAttribute(o):this.setAttribute(o,a),this._updateState=this._updateState&~Mct}}_attributeToProperty(t,r){if(this._updateState&Mct)return;let n=this.constructor,i=n._attributeToPropertyMap.get(t);if(i!==void 0){let o=n.getPropertyOptions(i);this._updateState=this._updateState|Ect,this[i]=n._propertyValueFromAttribute(r,o),this._updateState=this._updateState&~Ect}}requestUpdateInternal(t,r,n){let i=!0;if(t!==void 0){let o=this.constructor;n=n||o.getPropertyOptions(t),o._valueHasChanged(this[t],r,n.hasChanged)?(this._changedProperties.has(t)||this._changedProperties.set(t,r),n.reflect===!0&&!(this._updateState&Ect)&&(this._reflectingProperties===void 0&&(this._reflectingProperties=new Map),this._reflectingProperties.set(t,n))):i=!1}!this._hasRequestedUpdate&&i&&(this._updatePromise=this._enqueueUpdate())}requestUpdate(t,r){return this.requestUpdateInternal(t,r),this.updateComplete}_enqueueUpdate(){return Ri(this,null,function*(){this._updateState=this._updateState|Sct;try{yield this._updatePromise}catch(r){}let t=this.performUpdate();return t!=null&&(yield t),!this._hasRequestedUpdate})}get _hasRequestedUpdate(){return this._updateState&Sct}get hasUpdated(){return this._updateState&wct}performUpdate(){if(!this._hasRequestedUpdate)return;this._instanceProperties&&this._applyInstanceProperties();let t=!1,r=this._changedProperties;try{t=this.shouldUpdate(r),t?this.update(r):this._markUpdated()}catch(n){throw t=!1,this._markUpdated(),n}t&&(this._updateState&wct||(this._updateState=this._updateState|wct,this.firstUpdated(r)),this.updated(r))}_markUpdated(){this._changedProperties=new Map,this._updateState=this._updateState&~Sct}get updateComplete(){return this._getUpdateComplete()}_getUpdateComplete(){return this.getUpdateComplete()}getUpdateComplete(){return this._updatePromise}shouldUpdate(t){return!0}update(t){this._reflectingProperties!==void 0&&this._reflectingProperties.size>0&&(this._reflectingProperties.forEach((r,n)=>this._propertyToAttribute(n,this[n],r)),this._reflectingProperties=void 0),this._markUpdated()}updated(t){}firstUpdated(t){}};Ace=Cct;g3[Ace]=!0;var Ice=Element.prototype,Iii=Ice.msMatchesSelector||Ice.webkitMatchesSelector;var jH=window.ShadowRoot&&(window.ShadyCSS===void 0||window.ShadyCSS.nativeShadow)&&"adoptedStyleSheets"in Document.prototype&&"replace"in CSSStyleSheet.prototype,Act=Symbol(),l1=class{constructor(t,r){if(r!==Act)throw new Error("CSSResult is not constructable. Use `unsafeCSS` or `css` instead.");this.cssText=t}get styleSheet(){return this._styleSheet===void 0&&(jH?(this._styleSheet=new CSSStyleSheet,this._styleSheet.replaceSync(this.cssText)):this._styleSheet=null),this._styleSheet}toString(){return this.cssText}},Pct=e=>new l1(String(e),Act),Uur=e=>{if(e instanceof l1)return e.cssText;if(typeof e=="number")return e;throw new Error(`Value passed to 'css' function must be a 'css' function result: ${e}. Use 'unsafeCSS' to pass non-literal values, but
            take care to ensure page security.`)},Ci=(e,...t)=>{let r=t.reduce((n,i,o)=>n+Uur(i)+e[o+1],e[0]);return new l1(r,Act)};(window.litElementVersions||(window.litElementVersions=[])).push("2.5.1");var Lce={},EP=class extends g3{static getStyles(){return this.styles}static _getUniqueStyles(){if(this.hasOwnProperty(JSCompiler_renameProperty("_styles",this)))return;let t=this.getStyles();if(Array.isArray(t)){let r=(o,a)=>o.reduceRight((s,l)=>Array.isArray(l)?r(l,s):(s.add(l),s),a),n=r(t,new Set),i=[];n.forEach(o=>i.unshift(o)),this._styles=i}else this._styles=t===void 0?[]:[t];this._styles=this._styles.map(r=>{if(r instanceof CSSStyleSheet&&!jH){let n=Array.prototype.slice.call(r.cssRules).reduce((i,o)=>i+o.cssText,"");return Pct(n)}return r})}initialize(){super.initialize(),this.constructor._getUniqueStyles(),this.renderRoot=this.createRenderRoot(),window.ShadowRoot&&this.renderRoot instanceof window.ShadowRoot&&this.adoptStyles()}createRenderRoot(){return this.attachShadow(this.constructor.shadowRootOptions)}adoptStyles(){let t=this.constructor._styles;t.length!==0&&(window.ShadyCSS!==void 0&&!window.ShadyCSS.nativeShadow?window.ShadyCSS.ScopingShim.prepareAdoptedCssText(t.map(r=>r.cssText),this.localName):jH?this.renderRoot.adoptedStyleSheets=t.map(r=>r instanceof CSSStyleSheet?r:r.styleSheet):this._needsShimAdoptedStyleSheets=!0)}connectedCallback(){super.connectedCallback(),this.hasUpdated&&window.ShadyCSS!==void 0&&window.ShadyCSS.styleElement(this)}update(t){let r=this.render();super.update(t),r!==Lce&&this.constructor.render(r,this.renderRoot,{scopeName:this.localName,eventContext:this}),this._needsShimAdoptedStyleSheets&&(this._needsShimAdoptedStyleSheets=!1,this.constructor._styles.forEach(n=>{let i=document.createElement("style");i.textContent=n.cssText,this.renderRoot.appendChild(i)}))}render(){return Lce}};EP.finalized=!0;EP.render=Cce;EP.shadowRootOptions={mode:"open"};var kce=0,Ict={},jc=(e,t,r)=>{let n=r&&r.moduleId||`custom-style-module-${kce++}`;Array.isArray(t)||(t=t?[t]:[]),t.forEach(a=>{if(!(a instanceof l1))throw new Error("An item in styles is not of type CSSResult. Use `unsafeCSS` or `css`.");if(!Ict[a]){let s=document.createElement("dom-module");s.innerHTML=`
        <template>
          <style>${a.toString()}</style>
        </template>
      `;let l=`custom-style-module-${kce++}`;s.register(l),Ict[a]=l}});let i=document.createElement("dom-module");if(e){let a=customElements.get(e);a&&Object.prototype.hasOwnProperty.call(a,"__finalized")&&console.warn(`The custom element definition for "${e}"
      was finalized before a style module was registered.
      Make sure to add component specific style modules before
      importing the corresponding custom element.`),i.setAttribute("theme-for",e)}let o=r&&r.include||[];i.innerHTML=`
    <template>
      ${o.map(a=>`<style include=${a}></style>`)}
      ${t.map(a=>`<style include=${Ict[a]}></style>`)}
    </template>
  `,i.register(n)};var Lct=class extends HTMLElement{static get version(){return"20.0.2"}};customElements.define("vaadin-lumo-styles",Lct);var qur=Ci`
  :host {
    /* Base (background) */
    --lumo-base-color: #fff;

    /* Tint */
    --lumo-tint-5pct: hsla(0, 0%, 100%, 0.3);
    --lumo-tint-10pct: hsla(0, 0%, 100%, 0.37);
    --lumo-tint-20pct: hsla(0, 0%, 100%, 0.44);
    --lumo-tint-30pct: hsla(0, 0%, 100%, 0.5);
    --lumo-tint-40pct: hsla(0, 0%, 100%, 0.57);
    --lumo-tint-50pct: hsla(0, 0%, 100%, 0.64);
    --lumo-tint-60pct: hsla(0, 0%, 100%, 0.7);
    --lumo-tint-70pct: hsla(0, 0%, 100%, 0.77);
    --lumo-tint-80pct: hsla(0, 0%, 100%, 0.84);
    --lumo-tint-90pct: hsla(0, 0%, 100%, 0.9);
    --lumo-tint: #fff;

    /* Shade */
    --lumo-shade-5pct: hsla(214, 61%, 25%, 0.05);
    --lumo-shade-10pct: hsla(214, 57%, 24%, 0.1);
    --lumo-shade-20pct: hsla(214, 53%, 23%, 0.16);
    --lumo-shade-30pct: hsla(214, 50%, 22%, 0.26);
    --lumo-shade-40pct: hsla(214, 47%, 21%, 0.38);
    --lumo-shade-50pct: hsla(214, 45%, 20%, 0.5);
    --lumo-shade-60pct: hsla(214, 43%, 19%, 0.61);
    --lumo-shade-70pct: hsla(214, 42%, 18%, 0.72);
    --lumo-shade-80pct: hsla(214, 41%, 17%, 0.83);
    --lumo-shade-90pct: hsla(214, 40%, 16%, 0.94);
    --lumo-shade: hsl(214, 35%, 15%);

    /* Contrast */
    --lumo-contrast-5pct: var(--lumo-shade-5pct);
    --lumo-contrast-10pct: var(--lumo-shade-10pct);
    --lumo-contrast-20pct: var(--lumo-shade-20pct);
    --lumo-contrast-30pct: var(--lumo-shade-30pct);
    --lumo-contrast-40pct: var(--lumo-shade-40pct);
    --lumo-contrast-50pct: var(--lumo-shade-50pct);
    --lumo-contrast-60pct: var(--lumo-shade-60pct);
    --lumo-contrast-70pct: var(--lumo-shade-70pct);
    --lumo-contrast-80pct: var(--lumo-shade-80pct);
    --lumo-contrast-90pct: var(--lumo-shade-90pct);
    --lumo-contrast: var(--lumo-shade);

    /* Text */
    --lumo-header-text-color: var(--lumo-contrast);
    --lumo-body-text-color: var(--lumo-contrast-90pct);
    --lumo-secondary-text-color: var(--lumo-contrast-70pct);
    --lumo-tertiary-text-color: var(--lumo-contrast-50pct);
    --lumo-disabled-text-color: var(--lumo-contrast-30pct);

    /* Primary */
    --lumo-primary-color: hsl(214, 90%, 52%);
    --lumo-primary-color-50pct: hsla(214, 90%, 52%, 0.5);
    --lumo-primary-color-10pct: hsla(214, 90%, 52%, 0.1);
    --lumo-primary-text-color: var(--lumo-primary-color);
    --lumo-primary-contrast-color: #fff;

    /* Error */
    --lumo-error-color: hsl(3, 100%, 61%);
    --lumo-error-color-50pct: hsla(3, 100%, 60%, 0.5);
    --lumo-error-color-10pct: hsla(3, 100%, 60%, 0.1);
    --lumo-error-text-color: hsl(3, 92%, 53%);
    --lumo-error-contrast-color: #fff;

    /* Success */
    --lumo-success-color: hsl(145, 80%, 42%); /* hsl(144,82%,37%); */
    --lumo-success-color-50pct: hsla(145, 76%, 44%, 0.55);
    --lumo-success-color-10pct: hsla(145, 76%, 44%, 0.12);
    --lumo-success-text-color: hsl(145, 100%, 32%);
    --lumo-success-contrast-color: #fff;
  }
`,Rce=document.createElement("template");Rce.innerHTML=`<style>${qur.toString().replace(":host","html")}</style>`;document.head.appendChild(Rce.content);var Gur=Ci`
  [theme~='dark'] {
    /* Base (background) */
    --lumo-base-color: hsl(214, 35%, 21%);

    /* Tint */
    --lumo-tint-5pct: hsla(214, 65%, 85%, 0.06);
    --lumo-tint-10pct: hsla(214, 60%, 80%, 0.14);
    --lumo-tint-20pct: hsla(214, 64%, 82%, 0.23);
    --lumo-tint-30pct: hsla(214, 69%, 84%, 0.32);
    --lumo-tint-40pct: hsla(214, 73%, 86%, 0.41);
    --lumo-tint-50pct: hsla(214, 78%, 88%, 0.5);
    --lumo-tint-60pct: hsla(214, 82%, 90%, 0.6);
    --lumo-tint-70pct: hsla(214, 87%, 92%, 0.7);
    --lumo-tint-80pct: hsla(214, 91%, 94%, 0.8);
    --lumo-tint-90pct: hsla(214, 96%, 96%, 0.9);
    --lumo-tint: hsl(214, 100%, 98%);

    /* Shade */
    --lumo-shade-5pct: hsla(214, 0%, 0%, 0.07);
    --lumo-shade-10pct: hsla(214, 4%, 2%, 0.15);
    --lumo-shade-20pct: hsla(214, 8%, 4%, 0.23);
    --lumo-shade-30pct: hsla(214, 12%, 6%, 0.32);
    --lumo-shade-40pct: hsla(214, 16%, 8%, 0.41);
    --lumo-shade-50pct: hsla(214, 20%, 10%, 0.5);
    --lumo-shade-60pct: hsla(214, 24%, 12%, 0.6);
    --lumo-shade-70pct: hsla(214, 28%, 13%, 0.7);
    --lumo-shade-80pct: hsla(214, 32%, 13%, 0.8);
    --lumo-shade-90pct: hsla(214, 33%, 13%, 0.9);
    --lumo-shade: hsl(214, 33%, 13%);

    /* Contrast */
    --lumo-contrast-5pct: var(--lumo-tint-5pct);
    --lumo-contrast-10pct: var(--lumo-tint-10pct);
    --lumo-contrast-20pct: var(--lumo-tint-20pct);
    --lumo-contrast-30pct: var(--lumo-tint-30pct);
    --lumo-contrast-40pct: var(--lumo-tint-40pct);
    --lumo-contrast-50pct: var(--lumo-tint-50pct);
    --lumo-contrast-60pct: var(--lumo-tint-60pct);
    --lumo-contrast-70pct: var(--lumo-tint-70pct);
    --lumo-contrast-80pct: var(--lumo-tint-80pct);
    --lumo-contrast-90pct: var(--lumo-tint-90pct);
    --lumo-contrast: var(--lumo-tint);

    /* Text */
    --lumo-header-text-color: var(--lumo-contrast);
    --lumo-body-text-color: var(--lumo-contrast-90pct);
    --lumo-secondary-text-color: var(--lumo-contrast-70pct);
    --lumo-tertiary-text-color: var(--lumo-contrast-50pct);
    --lumo-disabled-text-color: var(--lumo-contrast-30pct);

    /* Primary */
    --lumo-primary-color: hsl(214, 86%, 55%);
    --lumo-primary-color-50pct: hsla(214, 86%, 55%, 0.5);
    --lumo-primary-color-10pct: hsla(214, 90%, 63%, 0.1);
    --lumo-primary-text-color: hsl(214, 100%, 70%);
    --lumo-primary-contrast-color: #fff;

    /* Error */
    --lumo-error-color: hsl(3, 90%, 63%);
    --lumo-error-color-50pct: hsla(3, 90%, 63%, 0.5);
    --lumo-error-color-10pct: hsla(3, 90%, 63%, 0.1);
    --lumo-error-text-color: hsl(3, 100%, 67%);

    /* Success */
    --lumo-success-color: hsl(145, 65%, 42%);
    --lumo-success-color-50pct: hsla(145, 65%, 42%, 0.5);
    --lumo-success-color-10pct: hsla(145, 65%, 42%, 0.1);
    --lumo-success-text-color: hsl(145, 85%, 47%);
  }

  html {
    color: var(--lumo-body-text-color);
    background-color: var(--lumo-base-color);
  }

  [theme~='dark'] {
    color: var(--lumo-body-text-color);
    background-color: var(--lumo-base-color);
  }

  h1,
  h2,
  h3,
  h4,
  h5,
  h6 {
    color: var(--lumo-header-text-color);
  }

  a {
    color: var(--lumo-primary-text-color);
  }

  blockquote {
    color: var(--lumo-secondary-text-color);
  }

  code,
  pre {
    background-color: var(--lumo-contrast-10pct);
    border-radius: var(--lumo-border-radius-m);
  }
`;jc("",Gur,{moduleId:"lumo-color"});var Wur=Ci`
  :host {
    color: var(--lumo-body-text-color) !important;
    background-color: var(--lumo-base-color) !important;
  }
`;jc("",Wur,{moduleId:"lumo-color-legacy",include:["lumo-color"]});var Nce=document.createElement("template");Nce.innerHTML=`
  <style>
    @font-face {
      font-family: 'lumo-icons';
      src: url(data:application/font-woff;charset=utf-8;base64,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) format('woff');
      font-weight: normal;
      font-style: normal;
    }

    html {
      --lumo-icons-align-center: "\\ea01";
      --lumo-icons-align-left: "\\ea02";
      --lumo-icons-align-right: "\\ea03";
      --lumo-icons-angle-down: "\\ea04";
      --lumo-icons-angle-left: "\\ea05";
      --lumo-icons-angle-right: "\\ea06";
      --lumo-icons-angle-up: "\\ea07";
      --lumo-icons-arrow-down: "\\ea08";
      --lumo-icons-arrow-left: "\\ea09";
      --lumo-icons-arrow-right: "\\ea0a";
      --lumo-icons-arrow-up: "\\ea0b";
      --lumo-icons-bar-chart: "\\ea0c";
      --lumo-icons-bell: "\\ea0d";
      --lumo-icons-calendar: "\\ea0e";
      --lumo-icons-checkmark: "\\ea0f";
      --lumo-icons-chevron-down: "\\ea10";
      --lumo-icons-chevron-left: "\\ea11";
      --lumo-icons-chevron-right: "\\ea12";
      --lumo-icons-chevron-up: "\\ea13";
      --lumo-icons-clock: "\\ea14";
      --lumo-icons-cog: "\\ea15";
      --lumo-icons-cross: "\\ea16";
      --lumo-icons-download: "\\ea17";
      --lumo-icons-dropdown: "\\ea18";
      --lumo-icons-edit: "\\ea19";
      --lumo-icons-error: "\\ea1a";
      --lumo-icons-eye: "\\ea1b";
      --lumo-icons-eye-disabled: "\\ea1c";
      --lumo-icons-menu: "\\ea1d";
      --lumo-icons-minus: "\\ea1e";
      --lumo-icons-ordered-list: "\\ea1f";
      --lumo-icons-phone: "\\ea20";
      --lumo-icons-photo: "\\ea21";
      --lumo-icons-play: "\\ea22";
      --lumo-icons-plus: "\\ea23";
      --lumo-icons-redo: "\\ea24";
      --lumo-icons-reload: "\\ea25";
      --lumo-icons-search: "\\ea26";
      --lumo-icons-undo: "\\ea27";
      --lumo-icons-unordered-list: "\\ea28";
      --lumo-icons-upload: "\\ea29";
      --lumo-icons-user: "\\ea2a";
    }
  </style>
`;document.head.appendChild(Nce.content);var Yur=Ci`
  :host {
    --lumo-size-xs: 1.625rem;
    --lumo-size-s: 1.875rem;
    --lumo-size-m: 2.25rem;
    --lumo-size-l: 2.75rem;
    --lumo-size-xl: 3.5rem;

    /* Icons */
    --lumo-icon-size-s: 1.25em;
    --lumo-icon-size-m: 1.5em;
    --lumo-icon-size-l: 2.25em;
    /* For backwards compatibility */
    --lumo-icon-size: var(--lumo-icon-size-m);
  }
`,Dce=document.createElement("template");Dce.innerHTML=`<style>${Yur.toString().replace(":host","html")}</style>`;document.head.appendChild(Dce.content);var jur=Ci`
  :host {
    /* Square */
    --lumo-space-xs: 0.25rem;
    --lumo-space-s: 0.5rem;
    --lumo-space-m: 1rem;
    --lumo-space-l: 1.5rem;
    --lumo-space-xl: 2.5rem;

    /* Wide */
    --lumo-space-wide-xs: calc(var(--lumo-space-xs) / 2) var(--lumo-space-xs);
    --lumo-space-wide-s: calc(var(--lumo-space-s) / 2) var(--lumo-space-s);
    --lumo-space-wide-m: calc(var(--lumo-space-m) / 2) var(--lumo-space-m);
    --lumo-space-wide-l: calc(var(--lumo-space-l) / 2) var(--lumo-space-l);
    --lumo-space-wide-xl: calc(var(--lumo-space-xl) / 2) var(--lumo-space-xl);

    /* Tall */
    --lumo-space-tall-xs: var(--lumo-space-xs) calc(var(--lumo-space-xs) / 2);
    --lumo-space-tall-s: var(--lumo-space-s) calc(var(--lumo-space-s) / 2);
    --lumo-space-tall-m: var(--lumo-space-m) calc(var(--lumo-space-m) / 2);
    --lumo-space-tall-l: var(--lumo-space-l) calc(var(--lumo-space-l) / 2);
    --lumo-space-tall-xl: var(--lumo-space-xl) calc(var(--lumo-space-xl) / 2);
  }
`,Oce=document.createElement("template");Oce.innerHTML=`<style>${jur.toString().replace(":host","html")}</style>`;document.head.appendChild(Oce.content);var Xur=Ci`
  :host {
    /* Border radius */
    --lumo-border-radius-s: 0.25em; /* Checkbox, badge, date-picker year indicator, etc */
    --lumo-border-radius-m: var(--lumo-border-radius, 0.25em); /* Button, text field, menu overlay, etc */
    --lumo-border-radius-l: 0.5em; /* Dialog, notification, etc */
    --lumo-border-radius: 0.25em; /* Deprecated */

    /* Shadow */
    --lumo-box-shadow-xs: 0 1px 4px -1px var(--lumo-shade-50pct);
    --lumo-box-shadow-s: 0 2px 4px -1px var(--lumo-shade-20pct), 0 3px 12px -1px var(--lumo-shade-30pct);
    --lumo-box-shadow-m: 0 2px 6px -1px var(--lumo-shade-20pct), 0 8px 24px -4px var(--lumo-shade-40pct);
    --lumo-box-shadow-l: 0 3px 18px -2px var(--lumo-shade-20pct), 0 12px 48px -6px var(--lumo-shade-40pct);
    --lumo-box-shadow-xl: 0 4px 24px -3px var(--lumo-shade-20pct), 0 18px 64px -8px var(--lumo-shade-40pct);

    /* Clickable element cursor */
    --lumo-clickable-cursor: default;
  }
`,zce=document.createElement("template");zce.innerHTML=`<style>${Xur.toString().replace(":host","html")}</style>`;document.head.appendChild(zce.content);var $ur=Ci`
  :host {
    /* prettier-ignore */
    --lumo-font-family: -apple-system, BlinkMacSystemFont, 'Roboto', 'Segoe UI', Helvetica, Arial, sans-serif, 'Apple Color Emoji', 'Segoe UI Emoji', 'Segoe UI Symbol';

    /* Font sizes */
    --lumo-font-size-xxs: 0.75rem;
    --lumo-font-size-xs: 0.8125rem;
    --lumo-font-size-s: 0.875rem;
    --lumo-font-size-m: 1rem;
    --lumo-font-size-l: 1.125rem;
    --lumo-font-size-xl: 1.375rem;
    --lumo-font-size-xxl: 1.75rem;
    --lumo-font-size-xxxl: 2.5rem;

    /* Line heights */
    --lumo-line-height-xs: 1.25;
    --lumo-line-height-s: 1.375;
    --lumo-line-height-m: 1.625;
  }
`,Fce=document.createElement("template");Fce.innerHTML=`<style>${$ur.toString().replace(":host","html")}</style>`;document.head.appendChild(Fce.content);var Kur=Ci`
  html {
    font-family: var(--lumo-font-family);
    font-size: var(--lumo-font-size, var(--lumo-font-size-m));
    line-height: var(--lumo-line-height-m);
    -webkit-text-size-adjust: 100%;
    -webkit-font-smoothing: antialiased;
    -moz-osx-font-smoothing: grayscale;
  }

  /* Can’t combine with the above selector because that doesn’t work in browsers without native shadow dom */
  :host {
    font-family: var(--lumo-font-family);
    font-size: var(--lumo-font-size, var(--lumo-font-size-m));
    line-height: var(--lumo-line-height-m);
    -webkit-text-size-adjust: 100%;
    -webkit-font-smoothing: antialiased;
    -moz-osx-font-smoothing: grayscale;
  }

  small,
  [theme~='font-size-s'] {
    font-size: var(--lumo-font-size-s);
    line-height: var(--lumo-line-height-s);
  }

  [theme~='font-size-xs'] {
    font-size: var(--lumo-font-size-xs);
    line-height: var(--lumo-line-height-xs);
  }

  h1,
  h2,
  h3,
  h4,
  h5,
  h6 {
    font-weight: 600;
    line-height: var(--lumo-line-height-xs);
    margin-top: 1.25em;
  }

  h1 {
    font-size: var(--lumo-font-size-xxxl);
    margin-bottom: 0.75em;
  }

  h2 {
    font-size: var(--lumo-font-size-xxl);
    margin-bottom: 0.5em;
  }

  h3 {
    font-size: var(--lumo-font-size-xl);
    margin-bottom: 0.5em;
  }

  h4 {
    font-size: var(--lumo-font-size-l);
    margin-bottom: 0.5em;
  }

  h5 {
    font-size: var(--lumo-font-size-m);
    margin-bottom: 0.25em;
  }

  h6 {
    font-size: var(--lumo-font-size-xs);
    margin-bottom: 0;
    text-transform: uppercase;
    letter-spacing: 0.03em;
  }

  p,
  blockquote {
    margin-top: 0.5em;
    margin-bottom: 0.75em;
  }

  a {
    text-decoration: none;
  }

  a:hover {
    text-decoration: underline;
  }

  hr {
    display: block;
    align-self: stretch;
    height: 1px;
    border: 0;
    padding: 0;
    margin: var(--lumo-space-s) calc(var(--lumo-border-radius-m) / 2);
    background-color: var(--lumo-contrast-10pct);
  }

  blockquote {
    border-left: 2px solid var(--lumo-contrast-30pct);
  }

  b,
  strong {
    font-weight: 600;
  }

  /* RTL specific styles */

  blockquote[dir='rtl'] {
    border-left: none;
    border-right: 2px solid var(--lumo-contrast-30pct);
  }
`;jc("",Kur,{moduleId:"lumo-typography"});jc("vaadin-checkbox",Ci`
    :host {
      -webkit-tap-highlight-color: transparent;
      -webkit-user-select: none;
      -moz-user-select: none;
      user-select: none;
      cursor: default;
      outline: none;
    }

    [part='label']:not([empty]) {
      margin: 0.1875em 0.875em 0.1875em 0.375em;
    }

    [part='checkbox'] {
      width: calc(1em + 2px);
      height: calc(1em + 2px);
      margin: 0.1875em;
      position: relative;
      border-radius: var(--lumo-border-radius-s);
      background-color: var(--lumo-contrast-20pct);
      transition: transform 0.2s cubic-bezier(0.12, 0.32, 0.54, 2), background-color 0.15s;
      pointer-events: none;
      line-height: 1.2;
    }

    :host([indeterminate]) [part='checkbox'],
    :host([checked]) [part='checkbox'] {
      background-color: var(--lumo-primary-color);
    }

    /* Needed to align the checkbox nicely on the baseline */
    [part='checkbox']::before {
      content: '\\2003';
    }

    /* Checkmark */
    [part='checkbox']::after {
      content: '';
      display: inline-block;
      width: 0;
      height: 0;
      border: 0 solid var(--lumo-primary-contrast-color);
      border-width: 0.1875em 0 0 0.1875em;
      box-sizing: border-box;
      transform-origin: 0 0;
      position: absolute;
      top: 0.8125em;
      left: 0.5em;
      transform: scale(0.55) rotate(-135deg);
      opacity: 0;
    }

    :host([checked]) [part='checkbox']::after {
      opacity: 1;
      width: 0.625em;
      height: 1.0625em;
    }

    /* Indeterminate checkmark */
    :host([indeterminate]) [part='checkbox']::after {
      transform: none;
      opacity: 1;
      top: 45%;
      height: 10%;
      left: 22%;
      right: 22%;
      width: auto;
      border: 0;
      background-color: var(--lumo-primary-contrast-color);
      transition: opacity 0.25s;
    }

    /* Focus ring */
    :host([focus-ring]) [part='checkbox'] {
      box-shadow: 0 0 0 3px var(--lumo-primary-color-50pct);
    }

    /* Disabled */
    :host([disabled]) {
      pointer-events: none;
      color: var(--lumo-disabled-text-color);
    }

    :host([disabled]) [part='label'] ::slotted(*) {
      color: inherit;
    }

    :host([disabled]) [part='checkbox'] {
      background-color: var(--lumo-contrast-10pct);
    }

    :host([disabled]) [part='checkbox']::after {
      border-color: var(--lumo-contrast-30pct);
    }

    :host([indeterminate][disabled]) [part='checkbox']::after {
      background-color: var(--lumo-contrast-30pct);
    }

    /* RTL specific styles */
    :host([dir='rtl']) [part='label']:not([empty]) {
      margin: 0.1875em 0.375em 0.1875em 0.875em;
    }

    /* Transition the checkmark if activated with the mouse (disabled for grid select-all this way) */
    :host(:hover) [part='checkbox']::after {
      transition: width 0.1s, height 0.25s;
    }

    /* Used for activation "halo" */
    [part='checkbox']::before {
      color: transparent;
      display: inline-block;
      width: 100%;
      height: 100%;
      border-radius: inherit;
      background-color: inherit;
      transform: scale(1.4);
      opacity: 0;
      transition: transform 0.1s, opacity 0.8s;
    }

    /* Hover */
    :host(:not([checked]):not([indeterminate]):not([disabled]):hover) [part='checkbox'] {
      background-color: var(--lumo-contrast-30pct);
    }

    /* Disable hover for touch devices */
    @media (pointer: coarse) {
      :host(:not([checked]):not([indeterminate]):not([disabled]):hover) [part='checkbox'] {
        background-color: var(--lumo-contrast-20pct);
      }
    }

    /* Active */
    :host([active]) [part='checkbox'] {
      transform: scale(0.9);
      transition-duration: 0.05s;
    }

    :host([active][checked]) [part='checkbox'] {
      transform: scale(1.1);
    }

    :host([active]:not([checked])) [part='checkbox']::before {
      transition-duration: 0.01s, 0.01s;
      transform: scale(0);
      opacity: 0.4;
    }
  `,{moduleId:"lumo-checkbox"});var Bce=e=>class extends e{static get properties(){return{theme:{type:String,readOnly:!0}}}attributeChangedCallback(r,n,i){super.attributeChangedCallback(r,n,i),r==="theme"&&this._setTheme(i)}};var XH=e=>class extends Bce(e){static finalize(){super.finalize();let r=this.prototype._template,n=Object.getPrototypeOf(this.prototype)._template;n&&Array.from(n.content.querySelectorAll("style[include]")).forEach(i=>{this._includeStyle(i.getAttribute("include"),r)}),this._includeMatchingThemes(r)}static _includeMatchingThemes(r){let i=ou.prototype.modules,o=!1,a=this.is+"-default-theme";Object.keys(i).sort((s,l)=>{let c=s.indexOf("vaadin-")===0,u=l.indexOf("vaadin-")===0,h=["lumo-","material-"],f=h.filter(d=>s.indexOf(d)===0).length>0,p=h.filter(d=>l.indexOf(d)===0).length>0;return c!==u?c?-1:1:f!==p?f?-1:1:0}).forEach(s=>{if(s!==a){let l=i[s].getAttribute("theme-for");l&&l.split(" ").forEach(c=>{new RegExp("^"+c.split("*").join(".*")+"$").test(this.is)&&(o=!0,this._includeStyle(s,r))})}}),!o&&i[a]&&this._includeStyle(a,r)}static _includeStyle(r,n){if(n&&!n.content.querySelector(`style[include="${r}"]`)){let i=document.createElement("style");i.setAttribute("include",r),n.content.appendChild(i)}}};var kct=!1;window.addEventListener("keydown",()=>{kct=!0},{capture:!0});window.addEventListener("mousedown",()=>{kct=!1},{capture:!0});var Zur=e=>class extends e{static get properties(){return{tabindex:{type:Number,value:0,reflectToAttribute:!0,observer:"_tabindexChanged"}}}},Hce=e=>class extends Zur(e){static get properties(){return{autofocus:{type:Boolean},_previousTabIndex:{type:Number},disabled:{type:Boolean,observer:"_disabledChanged",reflectToAttribute:!0},_isShiftTabbing:{type:Boolean}}}ready(){this.addEventListener("focusin",r=>{r.composedPath()[0]===this?this.contains(r.relatedTarget)||this._focus():r.composedPath().indexOf(this.focusElement)!==-1&&!this.disabled&&this._setFocused(!0)}),this.addEventListener("focusout",()=>this._setFocused(!1)),super.ready(),this.addEventListener("keydown",r=>{!r.defaultPrevented&&r.keyCode===9&&r.shiftKey&&(this._isShiftTabbing=!0,HTMLElement.prototype.focus.apply(this),this._setFocused(!1),setTimeout(()=>this._isShiftTabbing=!1,0))}),this.autofocus&&!this.disabled&&window.requestAnimationFrame(()=>{this._focus(),this._setFocused(!0),this.setAttribute("focus-ring","")})}disconnectedCallback(){super.disconnectedCallback(),this.hasAttribute("focused")&&this._setFocused(!1)}_setFocused(r){r?this.setAttribute("focused",""):this.removeAttribute("focused"),r&&kct?this.setAttribute("focus-ring",""):this.removeAttribute("focus-ring")}get focusElement(){return window.console.warn(`Please implement the 'focusElement' property in <${this.localName}>`),this}_focus(){!this.focusElement||this._isShiftTabbing||(this.focusElement.focus(),this._setFocused(!0))}focus(){!this.focusElement||this.disabled||(this.focusElement.focus(),this._setFocused(!0))}blur(){!this.focusElement||(this.focusElement.blur(),this._setFocused(!1))}_disabledChanged(r){this.focusElement.disabled=r,r?(this.blur(),this._previousTabIndex=this.tabindex,this.tabindex=-1,this.setAttribute("aria-disabled","true")):(typeof this._previousTabIndex!="undefined"&&(this.tabindex=this._previousTabIndex),this.removeAttribute("aria-disabled"))}_tabindexChanged(r){r!==void 0&&(this.focusElement.tabIndex=r),this.disabled&&this.tabindex&&(this.tabindex!==-1&&(this._previousTabIndex=this.tabindex),this.tabindex=r=void 0)}click(){this.disabled||super.click()}};var Jur=/\/\*\*\s+vaadin-dev-mode:start([\s\S]*)vaadin-dev-mode:end\s+\*\*\//i,$H=window.Vaadin&&window.Vaadin.Flow&&window.Vaadin.Flow.clients;function Qur(){function e(){return!0}return Vce(e)}function thr(){try{return ehr()?!0:rhr()?$H?!nhr():!Qur():!1}catch(e){return!1}}function ehr(){return localStorage.getItem("vaadin.developmentmode.force")}function rhr(){return["localhost","127.0.0.1"].indexOf(window.location.hostname)>=0}function nhr(){return!!($H&&Object.keys($H).map(t=>$H[t]).filter(t=>t.productionMode).length>0)}function Vce(e,t){if(typeof e!="function")return;let r=Jur.exec(e.toString());if(r)try{e=new Function(r[1])}catch(n){console.log("vaadin-development-mode-detector: uncommentAndRun() failed",n)}return e(t)}window.Vaadin=window.Vaadin||{};var Rct=function(e,t){if(window.Vaadin.developmentMode)return Vce(e,t)};window.Vaadin.developmentMode===void 0&&(window.Vaadin.developmentMode=thr());function ihr(){}var Uce=function(){if(typeof Rct=="function")return Rct(ihr)};var _3=class{static detectScrollType(){let t=document.createElement("div");t.textContent="ABCD",t.dir="rtl",t.style.fontSize="14px",t.style.width="4px",t.style.height="1px",t.style.position="absolute",t.style.top="-1000px",t.style.overflow="scroll",document.body.appendChild(t);let r="reverse";return t.scrollLeft>0?r="default":(t.scrollLeft=2,t.scrollLeft<2&&(r="negative")),document.body.removeChild(t),r}static getNormalizedScrollLeft(t,r,n){let{scrollLeft:i}=n;if(r!=="rtl"||!t)return i;switch(t){case"negative":return n.scrollWidth-n.clientWidth+i;case"reverse":return n.scrollWidth-n.clientWidth-i}return i}static setNormalizedScrollLeft(t,r,n,i){if(r!=="rtl"||!t){n.scrollLeft=i;return}switch(t){case"negative":n.scrollLeft=n.clientWidth-n.scrollWidth+i;break;case"reverse":n.scrollLeft=n.scrollWidth-n.clientWidth-i;break;default:n.scrollLeft=i;break}}};var E0=[],ohr=function(){let e=Dct();E0.forEach(t=>{Nct(t,e)})},KH,ahr=new MutationObserver(ohr);ahr.observe(document.documentElement,{attributes:!0,attributeFilter:["dir"]});var Nct=function(e,t,r=e.getAttribute("dir")){t?e.setAttribute("dir",t):r!=null&&e.removeAttribute("dir")},Dct=function(){return document.documentElement.getAttribute("dir")},ZH=e=>class extends e{static get properties(){return{dir:{type:String,value:"",reflectToAttribute:!0}}}static finalize(){super.finalize(),KH||(KH=_3.detectScrollType())}connectedCallback(){super.connectedCallback(),this.hasAttribute("dir")||(this.__subscribe(),Nct(this,Dct(),null))}attributeChangedCallback(r,n,i){if(super.attributeChangedCallback(r,n,i),r!=="dir")return;let o=Dct(),a=i===o&&E0.indexOf(this)===-1,s=!i&&n&&E0.indexOf(this)===-1;a||s?(this.__subscribe(),Nct(this,o,i)):i!==o&&n===o&&this.__subscribe(!1)}disconnectedCallback(){super.disconnectedCallback(),this.__subscribe(!1),this.removeAttribute("dir")}_valueToNodeAttribute(r,n,i){i==="dir"&&n===""&&!r.hasAttribute("dir")||super._valueToNodeAttribute(r,n,i)}_attributeToProperty(r,n,i){r==="dir"&&!n?this.dir="":super._attributeToProperty(r,n,i)}__subscribe(r=!0){r?E0.indexOf(this)===-1&&E0.push(this):E0.indexOf(this)>-1&&E0.splice(E0.indexOf(this),1)}__getNormalizedScrollLeft(r){return _3.getNormalizedScrollLeft(KH,this.getAttribute("dir")||"ltr",r)}__setNormalizedScrollLeft(r,n){return _3.setNormalizedScrollLeft(KH,this.getAttribute("dir")||"ltr",r,n)}};window.Vaadin=window.Vaadin||{};window.Vaadin.registrations=window.Vaadin.registrations||[];window.Vaadin.developmentModeCallback=window.Vaadin.developmentModeCallback||{};window.Vaadin.developmentModeCallback["vaadin-usage-statistics"]=function(){Uce()};var Oct,qce=new Set,JH=e=>class extends ZH(e){static finalize(){super.finalize();let{is:r}=this;r&&!qce.has(r)&&(window.Vaadin.registrations.push(this),qce.add(r),window.Vaadin.developmentModeCallback&&(Oct=sr.debounce(Oct,kx,()=>{window.Vaadin.developmentModeCallback["vaadin-usage-statistics"]()}),Jl(Oct)))}constructor(){super(),document.doctype===null&&console.warn('Vaadin components require the "standards mode" declaration. Please add <!DOCTYPE html> to the HTML document.')}};var QH=class extends JH(Hce(XH(yh(mt)))){static get template(){return Q`
      <style>
        :host {
          display: inline-block;
        }

        :host([hidden]) {
          display: none !important;
        }

        label {
          display: inline-flex;
          align-items: baseline;
          outline: none;
        }

        [part='checkbox'] {
          position: relative;
          display: inline-block;
          flex: none;
        }

        input[type='checkbox'] {
          position: absolute;
          top: 0;
          left: 0;
          right: 0;
          width: 100%;
          height: 100%;
          opacity: 0;
          cursor: inherit;
          margin: 0;
        }

        :host([disabled]) {
          -webkit-tap-highlight-color: transparent;
        }
      </style>

      <label>
        <span part="checkbox">
          <input
            type="checkbox"
            checked="{{checked::change}}"
            disabled$="[[disabled]]"
            indeterminate="{{indeterminate::change}}"
            role="presentation"
            tabindex="-1"
          />
        </span>

        <span part="label">
          <slot></slot>
        </span>
      </label>
    `}static get is(){return"vaadin-checkbox"}static get version(){return"20.0.2"}static get properties(){return{checked:{type:Boolean,value:!1,notify:!0,observer:"_checkedChanged",reflectToAttribute:!0},indeterminate:{type:Boolean,notify:!0,observer:"_indeterminateChanged",reflectToAttribute:!0,value:!1},value:{type:String,value:"on"},_nativeCheckbox:{type:Object}}}constructor(){super(),this.name}get name(){return this.checked?this._storedName:""}set name(t){this._storedName=t}ready(){super.ready(),this.setAttribute("role","checkbox"),this._nativeCheckbox=this.shadowRoot.querySelector('input[type="checkbox"]'),this.addEventListener("click",this._handleClick.bind(this)),this._addActiveListeners();let t=this.getAttribute("name");t&&(this.name=t),this.shadowRoot.querySelector('[part~="label"]').querySelector("slot").addEventListener("slotchange",this._updateLabelAttribute.bind(this)),this._updateLabelAttribute()}_updateLabelAttribute(){let t=this.shadowRoot.querySelector('[part~="label"]'),r=t.firstElementChild.assignedNodes();this._isAssignedNodesEmpty(r)?t.setAttribute("empty",""):t.removeAttribute("empty")}_isAssignedNodesEmpty(t){return t.length===0||t.length==1&&t[0].nodeType==Node.TEXT_NODE&&t[0].textContent.trim()===""}_checkedChanged(t){this.indeterminate?this.setAttribute("aria-checked","mixed"):this.setAttribute("aria-checked",Boolean(t))}_indeterminateChanged(t){t?this.setAttribute("aria-checked","mixed"):this.setAttribute("aria-checked",this.checked)}_addActiveListeners(){this._addEventListenerToNode(this,"down",t=>{this.__interactionsAllowed(t)&&this.setAttribute("active","")}),this._addEventListenerToNode(this,"up",()=>this.removeAttribute("active")),this.addEventListener("keydown",t=>{this.__interactionsAllowed(t)&&t.keyCode===32&&(t.preventDefault(),this.setAttribute("active",""))}),this.addEventListener("keyup",t=>{this.__interactionsAllowed(t)&&t.keyCode===32&&(t.preventDefault(),this._toggleChecked(),this.removeAttribute("active"),this.indeterminate&&(this.indeterminate=!1))})}get focusElement(){return this.shadowRoot.querySelector("input")}__interactionsAllowed(t){return!(this.disabled||t.target.localName==="a")}_handleClick(t){this.__interactionsAllowed(t)&&(this.indeterminate?(this.indeterminate=!1,t.preventDefault(),this._toggleChecked()):t.composedPath()[0]!==this._nativeCheckbox&&(t.preventDefault(),this._toggleChecked()))}_toggleChecked(){this.checked=!this.checked,this.dispatchEvent(new CustomEvent("change",{composed:!1,bubbles:!0}))}};customElements.define(QH.is,QH);jc("vaadin-grid",Ci`
    :host {
      font-family: var(--lumo-font-family);
      font-size: var(--lumo-font-size-m);
      line-height: var(--lumo-line-height-s);
      color: var(--lumo-body-text-color);
      background-color: var(--lumo-base-color);
      box-sizing: border-box;
      -webkit-text-size-adjust: 100%;
      -webkit-tap-highlight-color: transparent;
      -webkit-font-smoothing: antialiased;
      -moz-osx-font-smoothing: grayscale;

      /* For internal use only */
      --_lumo-grid-border-color: var(--lumo-contrast-20pct);
      --_lumo-grid-secondary-border-color: var(--lumo-contrast-10pct);
      --_lumo-grid-border-width: 1px;
      --_lumo-grid-selected-row-color: var(--lumo-primary-color-10pct);
    }

    /* No (outer) border */

    :host(:not([theme~='no-border'])) {
      border: var(--_lumo-grid-border-width) solid var(--_lumo-grid-border-color);
    }

    /* Cell styles */

    [part~='cell'] {
      min-height: var(--lumo-size-m);
      background-color: var(--lumo-base-color);
    }

    [part~='cell'] ::slotted(vaadin-grid-cell-content) {
      cursor: default;
      padding: var(--lumo-space-xs) var(--lumo-space-m);
    }

    /* Apply row borders by default and introduce the "no-row-borders" variant */
    :host(:not([theme~='no-row-borders'])) [part~='cell']:not([part~='details-cell']) {
      border-top: var(--_lumo-grid-border-width) solid var(--_lumo-grid-secondary-border-color);
    }

    /* Hide first body row top border */
    :host(:not([theme~='no-row-borders'])) [part='row'][first] [part~='cell']:not([part~='details-cell']) {
      border-top: 0;
      min-height: calc(var(--lumo-size-m) - var(--_lumo-grid-border-width));
    }

    /* Focus-ring */

    [part~='cell']:focus {
      outline: none;
    }

    :host([navigating]) [part~='cell']:focus::before {
      content: '';
      position: absolute;
      top: 0;
      right: 0;
      bottom: 0;
      left: 0;
      pointer-events: none;
      box-shadow: inset 0 0 0 2px var(--lumo-primary-color-50pct);
    }

    /* Drag and Drop styles */
    :host([dragover])::after {
      content: '';
      position: absolute;
      z-index: 100;
      top: 0;
      right: 0;
      bottom: 0;
      left: 0;
      pointer-events: none;
      box-shadow: inset 0 0 0 2px var(--lumo-primary-color-50pct);
    }

    [part~='row'][dragover] {
      z-index: 100 !important;
    }

    [part~='row'][dragover] [part~='cell'] {
      overflow: visible;
    }

    [part~='row'][dragover] [part~='cell']::after {
      content: '';
      position: absolute;
      top: 0;
      right: 0;
      bottom: 0;
      left: 0;
      height: calc(var(--_lumo-grid-border-width) + 2px);
      pointer-events: none;
      background: var(--lumo-primary-color-50pct);
    }

    :host([theme~='no-row-borders']) [dragover] [part~='cell']::after {
      height: 2px;
    }

    [part~='row'][dragover='below'] [part~='cell']::after {
      top: 100%;
      bottom: auto;
      margin-top: -1px;
    }

    [part~='row'][dragover='above'] [part~='cell']::after {
      top: auto;
      bottom: 100%;
      margin-bottom: -1px;
    }

    [part~='row'][details-opened][dragover='below'] [part~='cell']:not([part~='details-cell'])::after,
    [part~='row'][details-opened][dragover='above'] [part~='details-cell']::after {
      display: none;
    }

    [part~='row'][dragover][dragover='on-top'] [part~='cell']::after {
      height: 100%;
    }

    [part~='row'][dragstart] {
      /* Add bottom-space to the row so the drag number doesn't get clipped. Needed for IE/Edge */
      border-bottom: 100px solid transparent;
      z-index: 100 !important;
      opacity: 0.9;
    }

    [part~='row'][dragstart] [part~='cell'] {
      border: none !important;
      box-shadow: none !important;
    }

    [part~='row'][dragstart] [part~='cell'][last-column] {
      border-radius: 0 var(--lumo-border-radius-s) var(--lumo-border-radius-s) 0;
    }

    [part~='row'][dragstart] [part~='cell'][first-column] {
      border-radius: var(--lumo-border-radius-s) 0 0 var(--lumo-border-radius-s);
    }

    [ios] [part~='row'][dragstart] [part~='cell'] {
      background: var(--lumo-primary-color-50pct);
    }

    #scroller:not([ios]) [part~='row'][dragstart]:not([dragstart=''])::after {
      display: block;
      position: absolute;
      left: var(--_grid-drag-start-x);
      top: var(--_grid-drag-start-y);
      z-index: 100;
      content: attr(dragstart);
      align-items: center;
      justify-content: center;
      box-sizing: border-box;
      padding: calc(var(--lumo-space-xs) * 0.8);
      color: var(--lumo-error-contrast-color);
      background-color: var(--lumo-error-color);
      border-radius: var(--lumo-border-radius-m);
      font-family: var(--lumo-font-family);
      font-size: var(--lumo-font-size-xxs);
      line-height: 1;
      font-weight: 500;
      text-transform: initial;
      letter-spacing: initial;
      min-width: calc(var(--lumo-size-s) * 0.7);
      text-align: center;
    }

    /* Headers and footers */

    [part~='header-cell'] ::slotted(vaadin-grid-cell-content),
    [part~='footer-cell'] ::slotted(vaadin-grid-cell-content),
    [part~='reorder-ghost'] {
      font-size: var(--lumo-font-size-s);
      font-weight: 500;
    }

    [part~='footer-cell'] ::slotted(vaadin-grid-cell-content) {
      font-weight: 400;
    }

    [part='row']:only-child [part~='header-cell'] {
      min-height: var(--lumo-size-xl);
    }

    /* Header borders */

    /* Hide first header row top border */
    :host(:not([theme~='no-row-borders'])) [part='row']:first-child [part~='header-cell'] {
      border-top: 0;
    }

    [part='row']:last-child [part~='header-cell'] {
      border-bottom: var(--_lumo-grid-border-width) solid transparent;
    }

    :host(:not([theme~='no-row-borders'])) [part='row']:last-child [part~='header-cell'] {
      border-bottom-color: var(--_lumo-grid-secondary-border-color);
    }

    /* Overflow uses a stronger border color */
    :host([overflow~='top']) [part='row']:last-child [part~='header-cell'] {
      border-bottom-color: var(--_lumo-grid-border-color);
    }

    /* Footer borders */

    [part='row']:first-child [part~='footer-cell'] {
      border-top: var(--_lumo-grid-border-width) solid transparent;
    }

    :host(:not([theme~='no-row-borders'])) [part='row']:first-child [part~='footer-cell'] {
      border-top-color: var(--_lumo-grid-secondary-border-color);
    }

    /* Overflow uses a stronger border color */
    :host([overflow~='bottom']) [part='row']:first-child [part~='footer-cell'] {
      border-top-color: var(--_lumo-grid-border-color);
    }

    /* Column reordering */

    :host([reordering]) [part~='cell'] {
      background: linear-gradient(var(--lumo-shade-20pct), var(--lumo-shade-20pct)) var(--lumo-base-color);
    }

    :host([reordering]) [part~='cell'][reorder-status='allowed'] {
      background: var(--lumo-base-color);
    }

    :host([reordering]) [part~='cell'][reorder-status='dragging'] {
      background: linear-gradient(var(--lumo-contrast-5pct), var(--lumo-contrast-5pct)) var(--lumo-base-color);
    }

    [part~='reorder-ghost'] {
      opacity: 0.85;
      box-shadow: var(--lumo-box-shadow-s);
      /* TODO Use the same styles as for the cell element (reorder-ghost copies styles from the cell element) */
      padding: var(--lumo-space-s) var(--lumo-space-m) !important;
    }

    /* Column resizing */

    [part='resize-handle'] {
      width: 3px;
      background-color: var(--lumo-primary-color-50pct);
      opacity: 0;
      transition: opacity 0.2s;
    }

    :host(:not([reordering])) *:not([column-resizing]) [part~='cell']:hover [part='resize-handle'],
    [part='resize-handle']:active {
      opacity: 1;
      transition-delay: 0.15s;
    }

    /* Column borders */

    :host([theme~='column-borders']) [part~='cell']:not([last-column]):not([part~='details-cell']) {
      border-right: var(--_lumo-grid-border-width) solid var(--_lumo-grid-secondary-border-color);
    }

    /* Frozen columns */

    [last-frozen] {
      border-right: var(--_lumo-grid-border-width) solid transparent;
      overflow: hidden;
    }

    :host([overflow~='left']) [part~='cell'][last-frozen]:not([part~='details-cell']) {
      border-right-color: var(--_lumo-grid-border-color);
    }

    /* Row stripes */

    :host([theme~='row-stripes']) [part~='row']:not([odd]) [part~='body-cell'],
    :host([theme~='row-stripes']) [part~='row']:not([odd]) [part~='details-cell'] {
      background-image: linear-gradient(var(--lumo-contrast-5pct), var(--lumo-contrast-5pct));
      background-repeat: repeat-x;
    }

    /* Selected row */

    /* Raise the selected rows above unselected rows (so that box-shadow can cover unselected rows) */
    :host(:not([reordering])) [part~='row'][selected] {
      z-index: 1;
    }

    :host(:not([reordering])) [part~='row'][selected] [part~='body-cell']:not([part~='details-cell']) {
      background-image: linear-gradient(var(--_lumo-grid-selected-row-color), var(--_lumo-grid-selected-row-color));
      background-repeat: repeat;
    }

    /* Cover the border of an unselected row */
    :host(:not([theme~='no-row-borders'])) [part~='row'][selected] [part~='cell']:not([part~='details-cell']) {
      box-shadow: 0 var(--_lumo-grid-border-width) 0 0 var(--_lumo-grid-selected-row-color);
    }

    /* Compact */

    :host([theme~='compact']) [part='row']:only-child [part~='header-cell'] {
      min-height: var(--lumo-size-m);
    }

    :host([theme~='compact']) [part~='cell'] {
      min-height: var(--lumo-size-s);
    }

    :host([theme~='compact']) [part='row'][first] [part~='cell']:not([part~='details-cell']) {
      min-height: calc(var(--lumo-size-s) - var(--_lumo-grid-border-width));
    }

    :host([theme~='compact']) [part~='cell'] ::slotted(vaadin-grid-cell-content) {
      padding: var(--lumo-space-xs) var(--lumo-space-s);
    }

    /* Wrap cell contents */

    :host([theme~='wrap-cell-content']) [part~='cell'] ::slotted(vaadin-grid-cell-content) {
      white-space: normal;
    }

    /* RTL specific styles */

    :host([dir='rtl']) [part~='row'][dragstart] [part~='cell'][last-column] {
      border-radius: var(--lumo-border-radius-s) 0 0 var(--lumo-border-radius-s);
    }

    :host([dir='rtl']) [part~='row'][dragstart] [part~='cell'][first-column] {
      border-radius: 0 var(--lumo-border-radius-s) var(--lumo-border-radius-s) 0;
    }

    :host([dir='rtl'][theme~='column-borders']) [part~='cell']:not([last-column]):not([part~='details-cell']) {
      border-right: none;
      border-left: var(--_lumo-grid-border-width) solid var(--_lumo-grid-secondary-border-color);
    }

    :host([dir='rtl']) [last-frozen] {
      border-right: none;
      border-left: var(--_lumo-grid-border-width) solid transparent;
    }

    :host([dir='rtl'][overflow~='right']) [part~='cell'][last-frozen]:not([part~='details-cell']) {
      border-left-color: var(--_lumo-grid-border-color);
    }
  `,{moduleId:"lumo-grid"});jc("vaadin-checkbox",Ci`
    :host(.vaadin-grid-select-all-checkbox) {
      font-size: var(--lumo-font-size-m);
    }
  `,{moduleId:"vaadin-grid-select-all-checkbox-lumo"});var Gce=navigator.userAgent.match(/iP(?:hone|ad;(?: U;)? CPU) OS (\d+)/),shr=Gce&&Gce[1]>=8,Wce=3,Yce=h9({behaviors:[Js,v9],_ratio:.5,_scrollerPaddingTop:0,_scrollPosition:0,_physicalSize:0,_physicalAverage:0,_physicalAverageCount:0,_physicalTop:0,_virtualCount:0,_estScrollHeight:0,_scrollHeight:0,_viewportHeight:0,_viewportWidth:0,_physicalItems:null,_physicalSizes:null,_firstVisibleIndexVal:null,_lastVisibleIndexVal:null,_maxPages:2,_focusedVirtualIndex:-1,_templateCost:0,get _physicalBottom(){return this._physicalTop+this._physicalSize},get _scrollBottom(){return this._scrollPosition+this._viewportHeight},get _virtualEnd(){return this._virtualStart+this._physicalCount-1},get _hiddenContentSize(){return this._physicalSize-this._viewportHeight},get _maxScrollTop(){return this._estScrollHeight-this._viewportHeight+this._scrollOffset},get _maxVirtualStart(){return Math.max(0,this._virtualCount-this._physicalCount)},set _virtualStart(e){e=this._clamp(e,0,this._maxVirtualStart),this._virtualStartVal=e},get _virtualStart(){return this._virtualStartVal||0},set _physicalStart(e){e=e%this._physicalCount,e<0&&(e=this._physicalCount+e),this._physicalStartVal=e},get _physicalStart(){return this._physicalStartVal||0},get _physicalEnd(){return(this._physicalStart+this._physicalCount-1)%this._physicalCount},set _physicalCount(e){this._physicalCountVal=e},get _physicalCount(){return this._physicalCountVal||0},get _optPhysicalSize(){return this._viewportHeight===0?1/0:this._viewportHeight*this._maxPages},get _isVisible(){return Boolean(this.offsetWidth||this.offsetHeight)},get firstVisibleIndex(){let e=this._firstVisibleIndexVal;if(e==null){let t=this._physicalTop+this._scrollOffset;e=this._iterateItems(function(r,n){if(t+=this._physicalSizes[r],t>this._scrollPosition)return n})||0,this._firstVisibleIndexVal=e}return e},get lastVisibleIndex(){let e=this._lastVisibleIndexVal;if(e==null){let t=this._physicalTop+this._scrollOffset;this._iterateItems(function(r,n){t<this._scrollBottom&&(e=n),t+=this._physicalSizes[r]}),this._lastVisibleIndexVal=e}return e},get _scrollOffset(){return this._scrollerPaddingTop},attached:function(){this._debounce("_render",this._render,Ni),this.listen(this,"iron-resize","_resizeHandler")},detached:function(){this.unlisten(this,"iron-resize","_resizeHandler")},updateViewportBoundaries:function(){let e=window.getComputedStyle(this);this._scrollerPaddingTop=this.scrollTarget===this?0:parseInt(e["padding-top"],10),this._isRTL=Boolean(e.direction==="rtl"),this._viewportWidth=this.$.items.offsetWidth,this._viewportHeight=this._scrollTargetHeight},_scrollHandler:function(){let e=Math.max(0,Math.min(this._maxScrollTop,this._scrollTop)),t=e-this._scrollPosition,r=t>=0;if(this._scrollPosition=e,this._firstVisibleIndexVal=null,this._lastVisibleIndexVal=null,Math.abs(t)>this._physicalSize&&this._physicalSize>0){t=t-this._scrollOffset;let n=Math.round(t/this._physicalAverage);this._virtualStart=this._virtualStart+n,this._physicalStart=this._physicalStart+n,this._physicalTop=Math.floor(this._virtualStart)*this._physicalAverage,this._update()}else if(this._physicalCount>0){let{physicalTop:n,indexes:i}=this._getReusables(r);r?(this._physicalTop=n,this._virtualStart=this._virtualStart+i.length,this._physicalStart=this._physicalStart+i.length):(this._virtualStart=this._virtualStart-i.length,this._physicalStart=this._physicalStart-i.length),this._update(i,r?null:i),this._debounce("_increasePoolIfNeeded",this._increasePoolIfNeeded.bind(this,0),li)}},_getReusables:function(e){let t,r,n,i=[],o=this._hiddenContentSize*this._ratio,a=this._virtualStart,s=this._virtualEnd,l=this._physicalCount,c=this._physicalTop+this._scrollOffset,u=this._physicalBottom+this._scrollOffset,h=this._scrollTop,f=this._scrollBottom;for(e?(t=this._physicalStart,r=h-c):(t=this._physicalEnd,r=u-f);n=this._physicalSizes[t],r=r-n,!(i.length>=l||r<=o);)if(e){if(s+i.length+1>=this._virtualCount||c+n>=h-this._scrollOffset)break;i.push(t),c=c+n,t=(t+1)%l}else{if(a-i.length<=0||c+this._physicalSize-n<=f)break;i.push(t),c=c-n,t=t===0?l-1:t-1}return{indexes:i,physicalTop:c-this._scrollOffset}},_update:function(e,t){if(!(e&&e.length===0||this._physicalCount===0)){if(this._assignModels(e),this._updateMetrics(e),t)for(;t.length;){let r=t.pop();this._physicalTop-=this._physicalSizes[r]}this._positionItems(),this._updateScrollerSize()}},_isClientFull:function(){return this._scrollBottom!=0&&this._physicalBottom-1>=this._scrollBottom&&this._physicalTop<=this._scrollPosition},_increasePoolIfNeeded:function(e){let r=this._clamp(this._physicalCount+e,Wce,this._virtualCount-this._virtualStart)-this._physicalCount,n=Math.round(this._physicalCount*.5);if(!(r<0)){if(r>0){let i=window.performance.now();[].push.apply(this._physicalItems,this._createPool(r));for(let o=0;o<r;o++)this._physicalSizes.push(0);this._physicalCount=this._physicalCount+r,this._physicalStart>this._physicalEnd&&this._isIndexRendered(this._focusedVirtualIndex)&&this._getPhysicalIndex(this._focusedVirtualIndex)<this._physicalEnd&&(this._physicalStart=this._physicalStart+r),this._update(),this._templateCost=(window.performance.now()-i)/r,n=Math.round(this._physicalCount*.5)}this._virtualEnd>=this._virtualCount-1||n===0||(this._isClientFull()?this._physicalSize<this._optPhysicalSize&&this._debounce("_increasePoolIfNeeded",this._increasePoolIfNeeded.bind(this,this._clamp(Math.round(50/this._templateCost),1,n)),kx):this._debounce("_increasePoolIfNeeded",this._increasePoolIfNeeded.bind(this,n),li))}},_render:function(){if(!(!this.isAttached||!this._isVisible))if(this._physicalCount!==0){let{physicalTop:e,indexes:t}=this._getReusables(!0);this._physicalTop=e,this._virtualStart=this._virtualStart+t.length,this._physicalStart=this._physicalStart+t.length,this._update(t),this._update(),this._increasePoolIfNeeded(0)}else this._virtualCount>0&&(this.updateViewportBoundaries(),this._increasePoolIfNeeded(Wce))},_itemsChanged:function(e){e.path==="items"&&(this._virtualStart=0,this._physicalTop=0,this._virtualCount=this.items?this.items.length:0,this._physicalIndexForKey={},this._firstVisibleIndexVal=null,this._lastVisibleIndexVal=null,this._physicalCount=this._physicalCount||0,this._physicalItems=this._physicalItems||[],this._physicalSizes=this._physicalSizes||[],this._physicalStart=0,this._scrollTop>this._scrollOffset&&this._resetScrollPosition(0),this._debounce("_render",this._render,Ni))},_iterateItems:function(e,t){let r,n,i,o;if(arguments.length===2&&t){for(o=0;o<t.length;o++)if(r=t[o],n=this._computeVidx(r),(i=e.call(this,r,n))!=null)return i}else{for(r=this._physicalStart,n=this._virtualStart;r<this._physicalCount;r++,n++)if((i=e.call(this,r,n))!=null)return i;for(r=0;r<this._physicalStart;r++,n++)if((i=e.call(this,r,n))!=null)return i}},_computeVidx:function(e){return e>=this._physicalStart?this._virtualStart+(e-this._physicalStart):this._virtualStart+(this._physicalCount-this._physicalStart)+e},_updateMetrics:function(e){if(!this._isVisible)return;ci();let t=0,r=0,n=this._physicalAverageCount,i=this._physicalAverage;this._iterateItems(function(o){r+=this._physicalSizes[o],this._physicalSizes[o]=this._physicalItems[o].offsetHeight,t+=this._physicalSizes[o],this._physicalAverageCount+=this._physicalSizes[o]?1:0},e),this._physicalSize=this._physicalSize+t-r,this._physicalAverageCount!==n&&(this._physicalAverage=Math.round((i*n+t)/this._physicalAverageCount))},_positionItems:function(){this._adjustScrollPosition();let e=this._physicalTop;this._iterateItems(function(t){this.translate3d(0,e+"px",0,this._physicalItems[t]),e+=this._physicalSizes[t]})},_adjustScrollPosition:function(){let e=this._virtualStart===0?this._physicalTop:Math.min(this._scrollPosition+this._physicalTop,0);if(e!==0){this._physicalTop=this._physicalTop-e;let t=this._scrollTop;!shr&&t>0&&this._resetScrollPosition(t-e)}},_resetScrollPosition:function(e){this.scrollTarget&&e>=0&&(this._scrollTop=e,this._scrollPosition=this._scrollTop)},_updateScrollerSize:function(e){this._estScrollHeight=this._physicalBottom+Math.max(this._virtualCount-this._physicalCount-this._virtualStart,0)*this._physicalAverage,e=e||this._scrollHeight===0,e=e||this._scrollPosition>=this._estScrollHeight-this._physicalSize,(e||Math.abs(this._estScrollHeight-this._scrollHeight)>=this._viewportHeight)&&(this.$.items.style.height=this._estScrollHeight+"px",this._scrollHeight=this._estScrollHeight)},scrollToIndex:function(e){if(typeof e!="number"||e<0||e>this.items.length-1||(ci(),this._physicalCount===0))return;e=this._clamp(e,0,this._virtualCount-1),(!this._isIndexRendered(e)||e>=this._maxVirtualStart)&&(this._virtualStart=e-1),this._assignModels(),this._updateMetrics(),this._physicalTop=Math.floor(this._virtualStart)*this._physicalAverage;let t=this._physicalStart,r=this._virtualStart,n=0,i=this._hiddenContentSize;for(;r<e&&n<=i;)n=n+this._physicalSizes[t],t=(t+1)%this._physicalCount,r++;this._updateScrollerSize(!0),this._positionItems(),this._resetScrollPosition(this._physicalTop+this._scrollOffset+n),this._increasePoolIfNeeded(0),this._firstVisibleIndexVal=null,this._lastVisibleIndexVal=null},_resetAverage:function(){this._physicalAverage=0,this._physicalAverageCount=0},_resizeHandler:function(){this._debounce("_render",function(){this._firstVisibleIndexVal=null,this._lastVisibleIndexVal=null,this.updateViewportBoundaries(),this._isVisible?(this.toggleScrollListener(!0),this._resetAverage(),this._render()):this.toggleScrollListener(!1)},Ni)},_isIndexRendered:function(e){return e>=this._virtualStart&&e<=this._virtualEnd},_getPhysicalIndex:function(e){return(this._physicalStart+(e-this._virtualStart))%this._physicalCount},_clamp:function(e,t,r){return Math.min(r,Math.max(t,e))},_debounce:function(e,t,r){this._debouncers=this._debouncers||{},this._debouncers[e]=sr.debounce(this._debouncers[e],r,t.bind(this)),Jl(this._debouncers[e])}});var tV=class extends Yce{static get properties(){return{size:{type:Number,notify:!0},_vidxOffset:{type:Number,value:0}}}static get observers(){return["_effectiveSizeChanged(_effectiveSize)"]}connectedCallback(){super.connectedCallback(),this._scrollHandler()}_updateScrollerItem(){}_afterScroll(){}_getRowTarget(){}_createScrollerRows(){}_canPopulate(){}scrollToIndex(t){this._warnPrivateAPIAccess("scrollToIndex"),this._scrollingToIndex=!0,t=Math.min(Math.max(t,0),this._effectiveSize-1),this.$.table.scrollTop=t/this._effectiveSize*(this.$.table.scrollHeight-this.$.table.offsetHeight),this._scrollHandler(),this._accessIronListAPI(()=>this._maxScrollTop)&&this._virtualCount<this._effectiveSize&&this._adjustVirtualIndexOffset(1e6),this._accessIronListAPI(()=>super.scrollToIndex(t-this._vidxOffset)),this._scrollHandler();let r=Array.from(this.$.items.children).filter(n=>n.index===t)[0];if(r){let n=r.getBoundingClientRect().top-this.$.header.getBoundingClientRect().bottom;Math.abs(n)>1&&(this.$.table.scrollTop+=n,this._scrollHandler())}this._scrollingToIndex=!1}_effectiveSizeChanged(t){let r,n=0;this._iterateItems((i,o)=>{if(o===this._firstVisibleIndex){let a=this._physicalItems[i];r=a.index,n=a.getBoundingClientRect().top}}),this.items&&t<this.items.length&&(this._scrollTop=0),Array.isArray(this.items)||(this.items={length:Math.min(t,1e5)}),this._accessIronListAPI(()=>super._itemsChanged({path:"items"})),this._virtualCount=Math.min(this.items.length,t)||0,this._scrollTop===0&&(this._accessIronListAPI(()=>this._scrollToIndex(Math.min(t-1,r))),this._iterateItems(i=>{let o=this._physicalItems[i];if(o.index===r&&(this.$.table.scrollTop+=Math.round(o.getBoundingClientRect().top-n)),o.index===this._focusedItemIndex&&this._itemsFocusable&&this.$.items.contains(this.shadowRoot.activeElement)){let a=Array.from(this._itemsFocusable.parentElement.children).indexOf(this._itemsFocusable);o.children[a].focus()}})),this._assignModels(),requestAnimationFrame(()=>this._update()),this.__updateFooterPositioning()}_positionItems(){this._adjustScrollPosition();let t;isNaN(this._physicalTop)&&(t=!0,this._physicalTop=0);let r=this._physicalTop;this._iterateItems(n=>{this._physicalItems[n].style.transform=`translateY(${r}px)`,r+=this._physicalSizes[n]}),t&&this._scrollToIndex(0)}_increasePoolIfNeeded(t){t===0&&this._scrollingToIndex||!this._canPopulate()||!this._effectiveSize||(this._initialPoolCreated?this._optPhysicalSize!==1/0&&(this._debounceIncreasePool=sr.debounce(this._debounceIncreasePool,Ni,()=>{this._updateMetrics();let r=this._optPhysicalSize-this._physicalSize,n=Math.ceil(r/this._physicalAverage);this._physicalCount+n>this._effectiveSize&&(n=Math.max(0,this._effectiveSize-this._physicalCount)),this._physicalSize&&n>0&&this._optPhysicalSize!==1/0&&(super._increasePoolIfNeeded(n),this.__reorderChildNodes())})):(this._initialPoolCreated=!0,super._increasePoolIfNeeded(25)))}__reorderChildNodes(){let t=Array.from(this.$.items.childNodes);!!t.reduce((n,i,o,a)=>{if(o===0||a[o-1].index===i.index-1)return n},!0)||t.sort((n,i)=>n.index-i.index).forEach(n=>this.$.items.appendChild(n))}_createPool(t){let r=document.createDocumentFragment(),n=this._createScrollerRows(t);n.forEach(o=>r.appendChild(o)),this._getRowTarget().appendChild(r);let i=this.querySelector("[slot]");if(i){let o=i.getAttribute("slot");i.setAttribute("slot","foo-bar"),i.setAttribute("slot",o)}return Tm(this,()=>this.notifyResize()),n}_assignModels(t){this._iterateItems((r,n)=>{let i=this._physicalItems[r];this._toggleAttribute("hidden",n>=this._effectiveSize,i),this._updateScrollerItem(i,n+(this._vidxOffset||0))},t)}_scrollHandler(){let t=this.$.table.scrollTop-this._scrollPosition;this._accessIronListAPI(super._scrollHandler);let r=this._vidxOffset;this._accessIronListAPI(()=>this._maxScrollTop)&&this._virtualCount<this._effectiveSize?this._adjustVirtualIndexOffset(t):this._vidxOffset=0,this._vidxOffset!==r&&this._update(),this._afterScroll()}_adjustVirtualIndexOffset(t){if(Math.abs(t)>1e4){if(this._noScale){this._noScale=!1;return}let r=this.$.table.scrollTop/(this.$.table.scrollHeight-this.$.table.offsetHeight),n=r*this._effectiveSize;this._vidxOffset=Math.round(n-r*this._virtualCount)}else{let r=this._vidxOffset||0,n=1e3,i=100;this._scrollTop===0?(this._vidxOffset=0,r!==this._vidxOffset&&super.scrollToIndex(0)):this.firstVisibleIndex<n&&this._vidxOffset>0&&(this._vidxOffset-=Math.min(this._vidxOffset,i),r!==this._vidxOffset&&super.scrollToIndex(this.firstVisibleIndex+(r-this._vidxOffset)),this._noScale=!0);let o=this._effectiveSize-this._virtualCount;this._scrollTop>=this._maxScrollTop&&this._maxScrollTop>0?(this._vidxOffset=o,r!==this._vidxOffset&&super.scrollToIndex(this._virtualCount)):this.firstVisibleIndex>this._virtualCount-n&&this._vidxOffset<o&&(this._vidxOffset+=Math.min(o-this._vidxOffset,i),r!==this._vidxOffset&&super.scrollToIndex(this.firstVisibleIndex-(this._vidxOffset-r)),this._noScale=!0)}}_accessIronListAPI(t){this._warnPrivateAPIAccessAsyncEnabled=!1;let r=t.apply(this);return this._debouncerWarnPrivateAPIAccess=sr.debounce(this._debouncerWarnPrivateAPIAccess,Ni,()=>this._warnPrivateAPIAccessAsyncEnabled=!0),r}_debounceRender(t,r){super._debounceRender(()=>this._accessIronListAPI(t),r)}_warnPrivateAPIAccess(t){this._warnPrivateAPIAccessAsyncEnabled&&console.warn(`Accessing private API (${t})!`)}_render(){this._accessIronListAPI(super._render)}_itemsChanged(){}get _firstVisibleIndex(){return this._accessIronListAPI(()=>super.firstVisibleIndex)}get _lastVisibleIndex(){return this._accessIronListAPI(()=>super.lastVisibleIndex)}_scrollToIndex(t){this._accessIronListAPI(()=>this.scrollToIndex(t))}get firstVisibleIndex(){return this._warnPrivateAPIAccess("firstVisibleIndex"),super.firstVisibleIndex}set firstVisibleIndex(t){this._warnPrivateAPIAccess("firstVisibleIndex"),super.firstVisibleIndex=t}get lastVisibleIndex(){return this._warnPrivateAPIAccess("lastVisibleIndex"),super.lastVisibleIndex}set lastVisibleIndex(t){this._warnPrivateAPIAccess("lastVisibleIndex"),super.lastVisibleIndex=t}updateViewportBoundaries(){this._warnPrivateAPIAccess("updateViewportBoundaries"),super.updateViewportBoundaries.apply(this,arguments)}_resizeHandler(){super._resizeHandler(),ci()}};var jce=e=>class extends e{static get observers(){return["_a11yUpdateGridSize(size, _columnTree, _columnTree.*)"]}_a11yGetHeaderRowCount(r){return r.filter(n=>n.some(i=>i._headerTemplate||i.headerRenderer||i.path||i.header)).length}_a11yGetFooterRowCount(r){return r.filter(n=>n.some(i=>i._headerTemplate||i.headerRenderer)).length}_a11yUpdateGridSize(r,n){if(r===void 0||n===void 0)return;let i=n[n.length-1];this.$.table.setAttribute("aria-rowcount",r+this._a11yGetHeaderRowCount(n)+this._a11yGetFooterRowCount(n)),this.$.table.setAttribute("aria-colcount",i&&i.length||0),this._a11yUpdateHeaderRows(),this._a11yUpdateFooterRows()}_a11yUpdateHeaderRows(){Array.from(this.$.header.children).forEach((r,n)=>r.setAttribute("aria-rowindex",n+1))}_a11yUpdateFooterRows(){Array.from(this.$.footer.children).forEach((r,n)=>r.setAttribute("aria-rowindex",this._a11yGetHeaderRowCount(this._columnTree)+this.size+n+1))}_a11yUpdateRowRowindex(r,n){r.setAttribute("aria-rowindex",n+this._a11yGetHeaderRowCount(this._columnTree)+1)}_a11yUpdateRowSelected(r,n){r.setAttribute("aria-selected",Boolean(n)),Array.from(r.children).forEach(i=>i.setAttribute("aria-selected",Boolean(n)))}_a11yUpdateRowLevel(r,n){r.setAttribute("aria-level",n+1)}_a11yUpdateRowDetailsOpened(r,n){Array.from(r.children).forEach(i=>{typeof n=="boolean"?i.setAttribute("aria-expanded",n):i.hasAttribute("aria-expanded")&&i.removeAttribute("aria-expanded")})}_a11ySetRowDetailsCell(r,n){Array.from(r.children).forEach(i=>{i!==n&&i.setAttribute("aria-controls",n.id)})}_a11yUpdateCellColspan(r,n){r.setAttribute("aria-colspan",Number(n))}_a11yUpdateSorters(){Array.from(this.querySelectorAll("vaadin-grid-sorter")).forEach(r=>{let n=r.parentNode;for(;n&&n.localName!=="vaadin-grid-cell-content";)n=n.parentNode;n&&n.assignedSlot&&n.assignedSlot.parentNode.setAttribute("aria-sort",{asc:"ascending",desc:"descending"}[String(r.direction)]||"none")})}};var Xce=e=>class extends e{static get properties(){return{activeItem:{type:Object,notify:!0,value:null}}}ready(){super.ready(),this.$.scroller.addEventListener("click",this._onClick.bind(this)),this.addEventListener("cell-activate",this._activateItem.bind(this))}_activateItem(r){let n=r.detail.model,i=n?n.item:null;i&&(this.activeItem=this._itemsEqual(this.activeItem,i)?null:i)}_onClick(r){if(r.defaultPrevented)return;let n=r.composedPath(),i=n[n.indexOf(this.$.table)-3];if(!i||i.getAttribute("part").indexOf("details-cell")>-1)return;let o=i._content,a=this.getRootNode().activeElement;!o.contains(a)&&!this._isFocusable(r.target)&&this.dispatchEvent(new CustomEvent("cell-activate",{detail:{model:this.__getRowModel(i.parentElement)}}))}_isFocusable(r){return lhr(r)}},lhr=e=>{if(!e.parentNode)return!1;let r=Array.from(e.parentNode.querySelectorAll("[tabindex], button, input, select, textarea, object, iframe, label, a[href], area[href]")).filter(n=>n.getAttribute("part")!=="cell body-cell").indexOf(e)!==-1;return!e.disabled&&r};var $ce=e=>class extends e{static get properties(){return{items:Array}}static get observers(){return["_itemsChanged(items, items.*, isAttached)"]}_itemsChanged(r,n,i){if(!!i){if(!Array.isArray(r)){r==null&&(this.size=0),this.dataProvider===this._arrayDataProvider&&(this.dataProvider=void 0);return}this.size=r.length,this.dataProvider=this.dataProvider||this._arrayDataProvider,this.clearCache(),this._ensureFirstPageLoaded()}}_arrayDataProvider(r,n){let i=(Array.isArray(this.items)?this.items:[]).slice(0);this._filters&&this._checkPaths(this._filters,"filtering",i)&&(i=this._filter(i)),this.size=i.length,r.sortOrders.length&&this._checkPaths(this._sorters,"sorting",i)&&(i=i.sort(this._multiSort.bind(this)));let o=r.page*r.pageSize,a=o+r.pageSize,s=i.slice(o,a);n(s,i.length)}_checkPaths(r,n,i){if(!i.length)return!1;let o=!0;for(let a in r){let s=r[a].path;if(!s||s.indexOf(".")===-1)continue;let l=s.replace(/\.[^.]*$/,"");Da.get(l,i[0])===void 0&&(console.warn(`Path "${s}" used for ${n} does not exist in all of the items, ${n} is disabled.`),o=!1)}return o}_multiSort(r,n){return this._sorters.map(i=>i.direction==="asc"?this._compare(Da.get(i.path,r),Da.get(i.path,n)):i.direction==="desc"?this._compare(Da.get(i.path,n),Da.get(i.path,r)):0).reduce((i,o)=>i||o,0)}_normalizeEmptyValue(r){return[void 0,null].indexOf(r)>=0?"":isNaN(r)?r.toString():r}_compare(r,n){return r=this._normalizeEmptyValue(r),n=this._normalizeEmptyValue(n),r<n?-1:r>n?1:0}_filter(r){return r.filter(n=>this._filters.filter(i=>{let o=this._normalizeEmptyValue(Da.get(i.path,n)),a=this._normalizeEmptyValue(i.value).toString().toLowerCase();return o.toString().toLowerCase().indexOf(a)===-1}).length===0)}};var Kce=e=>class extends yh(e){ready(){super.ready();let r=this.$.scroller;Em(r,"track",this._onHeaderTrack.bind(this)),r.addEventListener("touchmove",n=>r.hasAttribute("column-resizing")&&n.preventDefault()),r.addEventListener("contextmenu",n=>n.target.getAttribute("part")=="resize-handle"&&n.preventDefault()),r.addEventListener("mousedown",n=>n.target.getAttribute("part")==="resize-handle"&&n.preventDefault())}_onHeaderTrack(r){let n=r.target;if(n.getAttribute("part")==="resize-handle"){let o=n.parentElement._column;for(this._toggleAttribute("column-resizing",!0,this.$.scroller);o.localName==="vaadin-grid-column-group";)o=Array.prototype.slice.call(o._childColumns,0).sort(function(l,c){return l._order-c._order}).filter(function(l){return!l.hidden}).pop();let a=Array.from(this.$.header.querySelectorAll('[part~="row"]:last-child [part~="cell"]')),s=a.filter(l=>l._column===o)[0];if(s.offsetWidth){let l=window.getComputedStyle(s),c=10+parseInt(l.paddingLeft)+parseInt(l.paddingRight)+parseInt(l.borderLeftWidth)+parseInt(l.borderRightWidth)+parseInt(l.marginLeft)+parseInt(l.marginRight),u=s.offsetWidth+(this.__isRTL?s.getBoundingClientRect().left-r.detail.x:r.detail.x-s.getBoundingClientRect().right);o.width=Math.max(c,u)+"px",o.flexGrow=0}a.sort(function(l,c){return l._column._order-c._column._order}).forEach(function(l,c,u){c<u.indexOf(s)&&(l._column.width=l.offsetWidth+"px",l._column.flexGrow=0)}),r.detail.state==="end"&&(this._toggleAttribute("column-resizing",!1,this.$.scroller),this.dispatchEvent(new CustomEvent("column-resize",{detail:{resizedColumn:o}}))),this._resizeHandler()}}};var Zce=class Jce{constructor(t,r,n){this.grid=t,this.parentCache=r,this.parentItem=n,this.itemCaches={},this.items={},this.effectiveSize=0,this.size=0,this.pendingRequests={}}isLoading(){return Boolean(Object.keys(this.pendingRequests).length||Object.keys(this.itemCaches).filter(t=>this.itemCaches[t].isLoading())[0])}getItemForIndex(t){let{cache:r,scaledIndex:n}=this.getCacheAndIndex(t);return r.items[n]}updateSize(){this.effectiveSize=!this.parentItem||this.grid._isExpanded(this.parentItem)?this.size+Object.keys(this.itemCaches).reduce((t,r)=>{let n=this.itemCaches[r];return n.updateSize(),t+n.effectiveSize},0):0}ensureSubCacheForScaledIndex(t){if(!this.itemCaches[t]){let r=new Jce(this.grid,this,this.items[t]);this.itemCaches[t]=r,this.grid._loadPage(0,r)}}getCacheAndIndex(t){let r=t,n=Object.keys(this.itemCaches);for(let i=0;i<n.length;i++){let o=Number(n[i]),a=this.itemCaches[o];if(r<=o)return{cache:this,scaledIndex:r};if(r<=o+a.effectiveSize)return a.getCacheAndIndex(r-o-1);r-=a.effectiveSize}return{cache:this,scaledIndex:r}}},Qce=e=>class extends e{static get properties(){return{pageSize:{type:Number,value:50,observer:"_pageSizeChanged"},dataProvider:{type:Object,notify:!0,observer:"_dataProviderChanged"},loading:{type:Boolean,notify:!0,readOnly:!0,reflectToAttribute:!0},_cache:{type:Object,value:function(){return new Zce(this)}},itemIdPath:{type:String,value:null},expandedItems:{type:Object,notify:!0,value:()=>[]}}}static get observers(){return["_sizeChanged(size)","_itemIdPathChanged(itemIdPath)","_expandedItemsChanged(expandedItems.*)"]}_sizeChanged(r){let n=r-this._cache.size;this._cache.size+=n,this._cache.effectiveSize+=n,this._effectiveSize=this._cache.effectiveSize,this._increasePoolIfNeeded(0),this._debounceIncreasePool&&this._debounceIncreasePool.flush()}_getItem(r,n){if(r>=this._effectiveSize)return;n.index=r;let{cache:i,scaledIndex:o}=this._cache.getCacheAndIndex(r),a=i.items[o];a?(this._toggleAttribute("loading",!1,n),this._updateItem(n,a),this._isExpanded(a)&&i.ensureSubCacheForScaledIndex(o)):(this._toggleAttribute("loading",!0,n),this._loadPage(this._getPageForIndex(o),i))}_expandedInstanceChangedCallback(r,n){r.item!==void 0&&(n?this.expandItem(r.item):this.collapseItem(r.item))}getItemId(r){return this.itemIdPath?this.get(this.itemIdPath,r):r}_isExpanded(r){return this.__expandedKeys.has(this.getItemId(r))}_expandedItemsChanged(){this.__cacheExpandedKeys(),this._cache.updateSize(),this._effectiveSize=this._cache.effectiveSize,this._assignModels()}_itemIdPathChanged(){this.__cacheExpandedKeys()}__cacheExpandedKeys(){this.expandedItems&&(this.__expandedKeys=new Set,this.expandedItems.forEach(r=>{this.__expandedKeys.add(this.getItemId(r))}))}expandItem(r){this._isExpanded(r)||(this.expandedItems=[...this.expandedItems,r])}collapseItem(r){this._isExpanded(r)&&(this.expandedItems=this.expandedItems.filter(n=>!this._itemsEqual(n,r)))}_getIndexLevel(r){let{cache:n}=this._cache.getCacheAndIndex(r),i=0;for(;n.parentCache;)n=n.parentCache,i++;return i}_canPopulate(){return Boolean(this._hasData&&this._columnTree)}_loadPage(r,n){if(!n.pendingRequests[r]&&this.dataProvider){this._setLoading(!0),n.pendingRequests[r]=!0;let i={page:r,pageSize:this.pageSize,sortOrders:this._mapSorters(),filters:this._mapFilters(),parentItem:n.parentItem};this._debounceIncreasePool&&this._debounceIncreasePool.flush(),this.dataProvider(i,(o,a)=>{a!==void 0?n.size=a:i.parentItem&&(n.size=o.length);let s=Array.from(this.$.items.children).map(l=>l._item);o.forEach((l,c)=>{let u=r*this.pageSize+c;n.items[u]=l,this._isExpanded(l)&&s.indexOf(l)>-1&&n.ensureSubCacheForScaledIndex(u)}),this._hasData=!0,delete n.pendingRequests[r],this._debouncerApplyCachedData=sr.debounce(this._debouncerApplyCachedData,mo.after(0),()=>{this._setLoading(!1),this._cache.updateSize(),this._effectiveSize=this._cache.effectiveSize,Array.from(this.$.items.children).filter(l=>!l.hidden).forEach(l=>{this._cache.getItemForIndex(l.index)&&this._getItem(l.index,l)}),this._increasePoolIfNeeded(0),this.__scrollToPendingIndex()}),this._cache.isLoading()||this._debouncerApplyCachedData.flush(),this.__itemsReceived()})}}_getPageForIndex(r){return Math.floor(r/this.pageSize)}clearCache(){this._cache=new Zce(this),Array.from(this.$.items.children).forEach(r=>{Array.from(r.children).forEach(n=>{n._instance&&n._instance._setPendingProperty("item",{},!1)})}),this._cache.size=this.size||0,this._cache.updateSize(),this._hasData=!1,this._assignModels(),(!this._effectiveSize||!this._initialPoolCreated)&&this._loadPage(0,this._cache)}_pageSizeChanged(r,n){n!==void 0&&r!==n&&this.clearCache()}_checkSize(){this.size===void 0&&this._effectiveSize===0&&console.warn("The <vaadin-grid> needs the total number of items in order to display rows. Set the total number of items to the `size` property, or provide the total number of items in the second argument of the `dataProvider`\u2019s `callback` call.")}_dataProviderChanged(r,n){n!==void 0&&this.clearCache(),r&&this.items&&this.items.length&&this._scrollToIndex(this._firstVisibleIndex),this._ensureFirstPageLoaded(),this._debouncerCheckSize=sr.debounce(this._debouncerCheckSize,mo.after(2e3),this._checkSize.bind(this)),this._scrollHandler()}_ensureFirstPageLoaded(){this._hasData||this._loadPage(0,this._cache)}_itemsEqual(r,n){return this.getItemId(r)===this.getItemId(n)}_getItemIndexInArray(r,n){let i=-1;return n.forEach((o,a)=>{this._itemsEqual(o,r)&&(i=a)}),i}scrollToIndex(r){super.scrollToIndex(r),!isNaN(r)&&(this._cache.isLoading()||!this.clientHeight)&&(this.__pendingScrollToIndex=r)}__scrollToPendingIndex(){if(this.__pendingScrollToIndex&&this.$.items.children.length){let r=this.__pendingScrollToIndex;delete this.__pendingScrollToIndex,this._debounceIncreasePool&&this._debounceIncreasePool.flush(),this.scrollToIndex(r)}}};var tue=e=>class extends e{ready(){super.ready(),this._addNodeObserver()}_hasColumnGroups(r){for(let n=0;n<r.length;n++)if(r[n].localName==="vaadin-grid-column-group")return!0;return!1}_getChildColumns(r){return vh.getFlattenedNodes(r).filter(this._isColumnElement)}_flattenColumnGroups(r){return r.map(n=>n.localName==="vaadin-grid-column-group"?this._getChildColumns(n):[n]).reduce((n,i)=>n.concat(i),[])}_getColumnTree(){let r=vh.getFlattenedNodes(this).filter(this._isColumnElement),n=[];for(let i=r;n.push(i),!!this._hasColumnGroups(i);)i=this._flattenColumnGroups(i);return n}_updateColumnTree(){let r=this._getColumnTree();this._arrayEquals(r,this._columnTree)||(this._columnTree=r)}_addNodeObserver(){this._observer=new vh(this,r=>{let n=r.addedNodes.filter(o=>o.localName==="template"&&o.classList.contains("row-details"))[0];n&&this._rowDetailsTemplate!==n&&(this._rowDetailsTemplate=n);let i=o=>o.filter(this._isColumnElement).length>0;if(i(r.addedNodes)||i(r.removedNodes)){let o=r.removedNodes.flatMap(s=>s._allCells),a=s=>o.filter(l=>l._content.contains(s)).length;this.__removeSorters(this._sorters.filter(a)),this.__removeFilters(this._filters.filter(a)),this._updateColumnTree()}this._debouncerCheckImports=sr.debounce(this._debouncerCheckImports,mo.after(2e3),this._checkImports.bind(this)),this._ensureFirstPageLoaded()})}_arrayEquals(r,n){if(!r||!n||r.length!=n.length)return!1;for(let i=0,o=r.length;i<o;i++)if(r[i]instanceof Array&&n[i]instanceof Array){if(!this._arrayEquals(r[i],n[i]))return!1}else if(r[i]!=n[i])return!1;return!0}_checkImports(){["vaadin-grid-column-group","vaadin-grid-filter","vaadin-grid-filter-column","vaadin-grid-tree-toggle","vaadin-grid-selection-column","vaadin-grid-sort-column","vaadin-grid-sorter"].forEach(r=>{let n=this.querySelector(r);n&&!(n instanceof mt)&&console.warn(`Make sure you have imported the required module for <${r}> element.`)})}_updateFirstAndLastColumn(){Array.from(this.shadowRoot.querySelectorAll("tr")).forEach(r=>this._updateFirstAndLastColumnForRow(r))}_updateFirstAndLastColumnForRow(r){Array.from(r.querySelectorAll('[part~="cell"]:not([part~="details-cell"])')).sort((n,i)=>n._column._order-i._column._order).forEach((n,i,o)=>{this._toggleAttribute("first-column",i===0,n),this._toggleAttribute("last-column",i===o.length-1,n)})}_isColumnElement(r){return r.nodeType===Node.ELEMENT_NODE&&/\bcolumn\b/.test(r.localName)}};var eue=e=>class extends e{getEventContext(r){let n={},i=r.composedPath(),o=i[i.indexOf(this.$.table)-3];return o&&(n.section=["body","header","footer","details"].filter(a=>o.getAttribute("part").indexOf(a)>-1)[0],o._column&&(n.column=o._column),(n.section==="body"||n.section==="details")&&Object.assign(n,this.__getRowModel(o.parentElement))),n}};var rue=e=>class extends e{static get properties(){return{_filters:{type:Array,value:function(){return[]}}}}ready(){super.ready(),this.addEventListener("filter-changed",this._filterChanged.bind(this))}_filterChanged(r){r.stopPropagation(),this.__addFilter(r.target),this.__applyFilters()}__removeFilters(r){r.length!=0&&(this._filters=this._filters.filter(n=>r.indexOf(n)<0),this.__applyFilters())}__addFilter(r){this._filters.indexOf(r)===-1&&this._filters.push(r)}__applyFilters(){this.dataProvider&&this.isAttached&&this.clearCache()}_mapFilters(){return this._filters.map(r=>({path:r.path,value:r.value}))}};var T0=class extends mt{static get is(){return"vaadin-grid-templatizer"}static get properties(){return{dataHost:Object,template:Object,_templateInstances:{type:Array,value:function(){return[]}},_parentPathValues:{value:function(){return{}}},_grid:Object}}static get observers(){return["_templateInstancesChanged(_templateInstances.*, _parentPathValues.*)"]}constructor(){super(),this._instanceProps={detailsOpened:!0,index:!0,item:!0,selected:!0,expanded:!0,level:!0}}createInstance(){this._ensureTemplatized();let t=new this._TemplateClass({});return this.addInstance(t),t}addInstance(t){this._templateInstances.indexOf(t)===-1&&(this._templateInstances.push(t),requestAnimationFrame(()=>this.notifyPath("_templateInstances.*",this._templateInstances)))}removeInstance(t){let r=this._templateInstances.indexOf(t);this.splice("_templateInstances",r,1)}_ensureTemplatized(){this._TemplateClass||(this._TemplateClass=tc(this.template,this,{instanceProps:this._instanceProps,parentModel:!0,forwardHostProp:function(t,r){this._forwardParentProp(t,r),this._templateInstances&&this._templateInstances.forEach(n=>n.notifyPath(t,r))},notifyInstanceProp:function(t,r,n){if(r==="index"||r==="item")return;let i=`__${r}__`;if(t[i]===n)return;t[i]=n;let o=Array.from(this._grid.$.items.children).filter(l=>this._grid._itemsEqual(l._item,t.item))[0];o&&Array.from(o.children).forEach(l=>{l._instance&&(l._instance[i]=n,l._instance.notifyPath(r,n))});let a="item.";if(Array.isArray(this._grid.items)&&r.indexOf(a)===0){let l=this._grid.items.indexOf(t.item),c=r.slice(a.length);this._grid.notifyPath(`items.${l}.${c}`,n)}let s=`_${r}InstanceChangedCallback`;this._grid&&this._grid[s]&&this._grid[s](t,n)}}))}_forwardParentProp(t,r){this._parentPathValues[t]=r,this._templateInstances.forEach(n=>n.notifyPath(t,r))}_templateInstancesChanged(t){let r,n;if(t.path==="_templateInstances")r=0,n=this._templateInstances.length;else if(t.path==="_templateInstances.splices")r=t.value.index,n=t.value.addedCount;else return;Object.keys(this._parentPathValues||{}).forEach(i=>{for(let o=r;o<r+n;o++)this._templateInstances[o].set(i,this._parentPathValues[i])})}};customElements.define(T0.is,T0);var nue=e=>class extends e{static get properties(){return{detailsOpenedItems:{type:Array,value:function(){return[]}},_rowDetailsTemplate:Object,rowDetailsRenderer:Function,_detailsCells:{type:Array}}}static get observers(){return["_detailsOpenedItemsChanged(detailsOpenedItems.*, _rowDetailsTemplate, rowDetailsRenderer)","_rowDetailsTemplateOrRendererChanged(_rowDetailsTemplate, rowDetailsRenderer)"]}_rowDetailsTemplateOrRendererChanged(r,n){if(r&&n)throw new Error("You should only use either a renderer or a template for row details");if(r||n){if(r&&!r.templatizer){let i=new T0;i._grid=this,i.dataHost=this.dataHost,i.template=r,r.templatizer=i}this._columnTree&&Array.from(this.$.items.children).forEach(i=>{i.querySelector("[part~=details-cell]")||(this._updateRow(i,this._columnTree[this._columnTree.length-1]),this._a11yUpdateRowDetailsOpened(i,!1)),delete i.querySelector("[part~=details-cell]")._instance}),this.detailsOpenedItems.length&&(Array.from(this.$.items.children).forEach(this._toggleDetailsCell,this),this._update())}}_detailsOpenedItemsChanged(r){r.path==="detailsOpenedItems.length"||!r.value||Array.from(this.$.items.children).forEach(n=>{this._toggleDetailsCell(n,n._item),this._a11yUpdateRowDetailsOpened(n,this._isDetailsOpened(n._item)),this._toggleAttribute("details-opened",this._isDetailsOpened(n._item),n)})}_configureDetailsCell(r){r.setAttribute("part","cell details-cell"),this._toggleAttribute("frozen",!0,r)}_toggleDetailsCell(r,n){let i=r.querySelector('[part~="details-cell"]');if(!i)return;let o=!this._isDetailsOpened(n),a=!!i.hidden!==o;(!i._instance&&!i._renderer||i.hidden!==o)&&(i.hidden=o,o?r.style.removeProperty("padding-bottom"):(this.rowDetailsRenderer?(i._renderer=this.rowDetailsRenderer,i._renderer.call(this,i._content,this,{index:r.index,item:n})):this._rowDetailsTemplate&&!i._instance&&(i._instance=this._rowDetailsTemplate.templatizer.createInstance(),i._content.innerHTML="",i._content.appendChild(i._instance.root),this._updateItem(r,n)),ci(),r.style.setProperty("padding-bottom",`${i.offsetHeight}px`),requestAnimationFrame(()=>this.notifyResize()))),a&&(this._updateMetrics(),this._positionItems())}_updateDetailsCellHeights(){Array.from(this.$.items.querySelectorAll('[part~="details-cell"]:not([hidden])')).forEach(r=>{r.parentElement.style.setProperty("padding-bottom",`${r.offsetHeight}px`)})}_isDetailsOpened(r){return this.detailsOpenedItems&&this._getItemIndexInArray(r,this.detailsOpenedItems)!==-1}openItemDetails(r){this._isDetailsOpened(r)||(this.detailsOpenedItems=[...this.detailsOpenedItems,r])}closeItemDetails(r){this._isDetailsOpened(r)&&(this.detailsOpenedItems=this.detailsOpenedItems.filter(n=>!this._itemsEqual(n,r)))}_detailsOpenedInstanceChangedCallback(r,n){n?this.openItemDetails(r.item):this.closeItemDetails(r.item)}};var zct={SCROLLING:500,IGNORE_WHEEL:500},iue=e=>class extends e{static get properties(){return{_frozenCells:{type:Array,value:()=>[]},_rowWithFocusedElement:Element,_deltaYAcc:{type:Number,value:0},_useSticky:{type:Boolean,value:window.CSS&&window.CSS.supports&&(window.CSS.supports("position","sticky")||window.CSS.supports("position","-webkit-sticky"))}}}static get observers(){return["_scrollViewportHeightUpdated(_viewportHeight)"]}set _scrollTop(r){this.$.table.scrollTop=r}get _scrollTop(){return this.$.table.scrollTop}constructor(){super(),this._scrollLineHeight=this._getScrollLineHeight()}_getScrollLineHeight(){let r=document.createElement("div");r.style.fontSize="initial",r.style.display="none",document.body.appendChild(r);let n=window.getComputedStyle(r).fontSize;return document.body.removeChild(r),n?window.parseInt(n):void 0}_scrollViewportHeightUpdated(r){this._scrollPageHeight=r-this.$.header.clientHeight-this.$.footer.clientHeight-this._scrollLineHeight}ready(){super.ready(),this.$.outerscroller=document.createElement("div"),this.scrollTarget=this.$.table,this.addEventListener("wheel",this._onWheel),this.$.items.addEventListener("focusin",r=>{let n=r.composedPath().indexOf(this.$.items);this._rowWithFocusedElement=r.composedPath()[n-1]}),this.$.items.addEventListener("focusout",()=>this._rowWithFocusedElement=void 0),this.scrollTarget.addEventListener("mousedown",()=>this.__mouseDown=!0),this.scrollTarget.addEventListener("mouseup",()=>{this.__mouseDown=!1,this.__pendingReorder&&(this.__pendingReorder=!1,setTimeout(()=>this._reorderRows(),zct.SCROLLING))})}scrollToIndex(r){this._accessIronListAPI(()=>super.scrollToIndex(r))}_onWheel(r){if(r.ctrlKey||this._hasScrolledAncestor(r.target,r.deltaX,r.deltaY))return;let n=this.$.table,i=r.deltaY;if(r.deltaMode===WheelEvent.DOM_DELTA_LINE?i*=this._scrollLineHeight:r.deltaMode===WheelEvent.DOM_DELTA_PAGE&&(i*=this._scrollPageHeight),this._wheelAnimationFrame){this._deltaYAcc+=i,r.preventDefault();return}i+=this._deltaYAcc,this._deltaYAcc=0,this._wheelAnimationFrame=!0,this._debouncerWheelAnimationFrame=sr.debounce(this._debouncerWheelAnimationFrame,Ni,()=>this._wheelAnimationFrame=!1);let o=Math.abs(r.deltaX)+Math.abs(i);this._canScroll(n,r.deltaX,i)?(r.preventDefault(),n.scrollTop+=i,n.scrollLeft+=r.deltaX,this._scrollHandler(),this._hasResidualMomentum=!0,this._ignoreNewWheel=!0,this._debouncerIgnoreNewWheel=sr.debounce(this._debouncerIgnoreNewWheel,mo.after(zct.IGNORE_WHEEL),()=>this._ignoreNewWheel=!1)):this._hasResidualMomentum&&o<=this._previousMomentum||this._ignoreNewWheel?r.preventDefault():o>this._previousMomentum&&(this._hasResidualMomentum=!1),this._previousMomentum=o}_hasScrolledAncestor(r,n,i){if(r.localName==="vaadin-grid-cell-content")return!1;if(this._canScroll(r,n,i)&&["auto","scroll"].indexOf(getComputedStyle(r).overflow)!==-1)return!0;if(r!==this&&r.parentElement)return this._hasScrolledAncestor(r.parentElement,n,i)}_canScroll(r,n,i){return i>0&&r.scrollTop<r.scrollHeight-r.offsetHeight||i<0&&r.scrollTop>0||n>0&&r.scrollLeft<r.scrollWidth-r.offsetWidth||n<0&&r.scrollLeft>0}_scheduleScrolling(){this._scrollingFrame||(this._scrollingFrame=requestAnimationFrame(()=>this._toggleAttribute("scrolling",!0,this.$.scroller))),this._debounceScrolling=sr.debounce(this._debounceScrolling,mo.after(zct.SCROLLING),()=>{cancelAnimationFrame(this._scrollingFrame),delete this._scrollingFrame,this._toggleAttribute("scrolling",!1,this.$.scroller),this._reorderRows()})}_afterScroll(){this._translateStationaryElements(),this.hasAttribute("reordering")||this._scheduleScrolling(),this._updateOverflow()}_updateOverflow(){let r="",n=this.$.table;n.scrollTop<n.scrollHeight-n.clientHeight&&(r+=" bottom"),n.scrollTop>0&&(r+=" top"),n.scrollLeft<n.scrollWidth-n.clientWidth&&(r+=" right"),n.scrollLeft>0&&(r+=" left"),this._debounceOverflow=sr.debounce(this._debounceOverflow,Ni,()=>{let i=r.trim();i.length>0&&this.getAttribute("overflow")!==i?this.setAttribute("overflow",i):i.length==0&&this.hasAttribute("overflow")&&this.removeAttribute("overflow")})}_reorderRows(){if(this.__mouseDown){this.__pendingReorder=!0;return}let r=this.$.items,n=r.querySelectorAll("tr");if(!n.length)return;let i=this._virtualStart+this._vidxOffset,o=this._rowWithFocusedElement||Array.from(n).filter(l=>!l.hidden)[0];if(!o)return;let a=o.index-i,s=Array.from(n).indexOf(o)-a;if(s>0)for(let l=0;l<s;l++)r.appendChild(n[l]);else if(s<0)for(let l=n.length+s;l<n.length;l++)r.insertBefore(n[l],n[0]);if(this._safari){let{transform:l}=this.$.header.style;this.$.header.style.transform="",setTimeout(()=>this.$.header.style.transform=l)}}_frozenCellsChanged(){this._debouncerCacheElements=sr.debounce(this._debouncerCacheElements,li,()=>{Array.from(this.shadowRoot.querySelectorAll('[part~="cell"]')).forEach(function(r){r.style.transform=""}),this._frozenCells=Array.prototype.slice.call(this.$.table.querySelectorAll("[frozen]")),this._updateScrollerMeasurements(),this._translateStationaryElements()}),this._updateLastFrozen()}_updateScrollerMeasurements(){this._frozenCells.length>0&&this.__isRTL&&(this.__scrollerMetrics={scrollWidth:this.$.table.scrollWidth,clientWidth:this.$.table.clientWidth})}_updateLastFrozen(){if(!this._columnTree)return;let r=this._columnTree[this._columnTree.length-1].slice(0);r.sort((i,o)=>i._order-o._order);let n=r.reduce((i,o,a)=>(o._lastFrozen=!1,o.frozen&&!o.hidden?a:i),void 0);n!==void 0&&(r[n]._lastFrozen=!0)}_translateStationaryElements(){let r=Math.max(0,this._scrollLeft),n=Math.max(0,this._scrollTop),i=0,o=0,a=0;if(this._useSticky||(i=r,o=n,a=this.$.table.clientHeight-this.$.footer.offsetHeight-this.$.footer.offsetTop),this.$.header.style.transform=this._getTranslate(-r+i,o),this.$.footer.style.transform=this._getTranslate(-r+i,o+a),this.$.items.style.transform=this._getTranslate(-r+i,0),this._frozenCells.length>0){let s=this.__isRTL?this.__getNormalizedScrollLeft(this.$.table)+this.__scrollerMetrics.clientWidth-this.__scrollerMetrics.scrollWidth:this._scrollLeft,l=this._getTranslate(s,0);for(let c=0;c<this._frozenCells.length;c++)this._frozenCells[c].style.transform=l}}_getTranslate(r,n){return`translate(${r}px, ${n}px)`}};var oue=e=>class extends e{static get properties(){return{selectedItems:{type:Object,notify:!0,value:()=>[]}}}static get observers(){return["_selectedItemsChanged(selectedItems.*)"]}_isSelected(r){return this.selectedItems&&this._getItemIndexInArray(r,this.selectedItems)>-1}selectItem(r){this._isSelected(r)||(this.selectedItems=[...this.selectedItems,r])}deselectItem(r){this._isSelected(r)&&(this.selectedItems=this.selectedItems.filter(n=>!this._itemsEqual(n,r)))}_toggleItem(r){this._getItemIndexInArray(r,this.selectedItems)===-1?this.selectItem(r):this.deselectItem(r)}_selectedItemsChanged(r){this.$.items.children.length&&(r.path==="selectedItems"||r.path==="selectedItems.splices")&&Array.from(this.$.items.children).forEach(n=>{this._updateItem(n,n._item)})}_selectedInstanceChangedCallback(r,n){n?this.selectItem(r.item):this.deselectItem(r.item)}};var aue=e=>class extends e{static get properties(){return{multiSort:{type:Boolean,value:!1},_sorters:{type:Array,value:function(){return[]}},_previousSorters:{type:Array,value:function(){return[]}}}}ready(){super.ready(),this.addEventListener("sorter-changed",this._onSorterChanged)}_onSorterChanged(r){let n=r.target;r.stopPropagation(),this.__updateSorter(n),this.__applySorters()}__removeSorters(r){r.length!=0&&(this._sorters=this._sorters.filter(n=>r.indexOf(n)<0),this.multiSort&&this.__updateSortOrders(),this.__applySorters())}__updateSortOrders(){this._sorters.forEach((r,n)=>r._order=this._sorters.length>1?n:null,this)}__updateSorter(r){if(!(!r.direction&&this._sorters.indexOf(r)===-1)){if(r._order=null,this.multiSort)this._removeArrayItem(this._sorters,r),r.direction&&this._sorters.unshift(r),this.__updateSortOrders();else if(r.direction){let n=this._sorters.filter(i=>i!=r);this._sorters=[r],n.forEach(i=>{i._order=null,i.direction=null})}}}__applySorters(){this.dataProvider&&this.isAttached&&JSON.stringify(this._previousSorters)!==JSON.stringify(this._mapSorters())&&this.clearCache(),this._a11yUpdateSorters(),this._previousSorters=this._mapSorters()}_mapSorters(){return this._sorters.map(r=>({path:r.path,direction:r.direction}))}_removeArrayItem(r,n){let i=r.indexOf(n);i>-1&&r.splice(i,1)}};var sue=e=>class extends e{static get properties(){return{cellClassNameGenerator:Function}}static get observers(){return["__cellClassNameGeneratorChanged(cellClassNameGenerator)"]}__cellClassNameGeneratorChanged(){this.generateCellClassNames()}generateCellClassNames(){Array.from(this.$.items.children).filter(r=>!r.hidden).forEach(r=>this._generateCellClassNames(r,this.__getRowModel(r)))}_generateCellClassNames(r,n){Array.from(r.children).forEach(i=>{if(i.__generatedClasses&&i.__generatedClasses.forEach(o=>i.classList.remove(o)),this.cellClassNameGenerator){let o=this.cellClassNameGenerator(i._column,n);i.__generatedClasses=o&&o.split(" ").filter(a=>a.length>0),i.__generatedClasses&&i.__generatedClasses.forEach(a=>i.classList.add(a))}})}};var TP={BETWEEN:"between",ON_TOP:"on-top",ON_TOP_OR_BETWEEN:"on-top-or-between",ON_GRID:"on-grid"},C0={ON_TOP:"on-top",ABOVE:"above",BELOW:"below",EMPTY:"empty"},lue=e=>class extends e{static get properties(){return{dropMode:String,rowsDraggable:Boolean,dragFilter:Function,dropFilter:Function,__dndAutoScrollThreshold:{value:50}}}static get observers(){return["_dragDropAccessChanged(rowsDraggable, dropMode, dragFilter, dropFilter)"]}ready(){super.ready(),this.$.table.addEventListener("dragstart",this._onDragStart.bind(this)),this.$.table.addEventListener("dragend",this._onDragEnd.bind(this)),this.$.table.addEventListener("dragover",this._onDragOver.bind(this)),this.$.table.addEventListener("dragleave",this._onDragLeave.bind(this)),this.$.table.addEventListener("drop",this._onDrop.bind(this)),this.$.table.addEventListener("dragenter",r=>{this.dropMode&&(r.preventDefault(),r.stopPropagation())})}_onDragStart(r){if(this.rowsDraggable){let n=r.target;if(n.localName==="vaadin-grid-cell-content"&&(n=n.assignedSlot.parentNode.parentNode),n.parentNode!==this.$.items)return;if(r.stopPropagation(),this._toggleAttribute("dragging-rows",!0,this),this._safari){let s=n.style.transform;n.style.top=/translateY\((.*)\)/.exec(s)[1],n.style.transform="none",requestAnimationFrame(()=>{n.style.top="",n.style.transform=s})}let i=n.getBoundingClientRect();this._ios?r.dataTransfer.setDragImage(n):r.dataTransfer.setDragImage(n,r.clientX-i.left,r.clientY-i.top);let o=[n];this._isSelected(n._item)&&(o=this.__getViewportRows().filter(s=>this._isSelected(s._item)).filter(s=>!this.dragFilter||this.dragFilter(this.__getRowModel(s)))),r.dataTransfer.setData("text",this.__formatDefaultTransferData(o)),n.setAttribute("dragstart",o.length>1?o.length:""),this.updateStyles({"--_grid-drag-start-x":`${r.clientX-i.left+20}px`,"--_grid-drag-start-y":`${r.clientY-i.top+10}px`}),requestAnimationFrame(()=>{n.removeAttribute("dragstart"),this.updateStyles({"--_grid-drag-start-x":"","--_grid-drag-start-y":""})});let a=new CustomEvent("grid-dragstart",{detail:{draggedItems:o.map(s=>s._item),setDragData:(s,l)=>r.dataTransfer.setData(s,l),setDraggedItemsCount:s=>n.setAttribute("dragstart",s)}});a.originalEvent=r,this.dispatchEvent(a)}}_onDragEnd(r){this._toggleAttribute("dragging-rows",!1,this),r.stopPropagation();let n=new CustomEvent("grid-dragend");n.originalEvent=r,this.dispatchEvent(n)}_onDragLeave(r){r.stopPropagation(),this._clearDragStyles()}_onDragOver(r){if(this.dropMode){if(this._dropLocation=void 0,this._dragOverItem=void 0,this.__dndAutoScroll(r.clientY)){this._clearDragStyles();return}let n=r.composedPath().filter(i=>i.localName==="tr")[0];if(!this._effectiveSize||this.dropMode===TP.ON_GRID)this._dropLocation=C0.EMPTY;else if(!n||n.parentNode!==this.$.items){if(n)return;if(this.dropMode===TP.BETWEEN||this.dropMode===TP.ON_TOP_OR_BETWEEN)n=Array.from(this.$.items.children).filter(i=>!i.hidden).pop(),this._dropLocation=C0.BELOW;else return}else{let i=n.getBoundingClientRect();if(this._dropLocation=C0.ON_TOP,this.dropMode===TP.BETWEEN){let o=r.clientY-i.top<i.bottom-r.clientY;this._dropLocation=o?C0.ABOVE:C0.BELOW}else this.dropMode===TP.ON_TOP_OR_BETWEEN&&(r.clientY-i.top<i.height/3?this._dropLocation=C0.ABOVE:r.clientY-i.top>i.height/3*2&&(this._dropLocation=C0.BELOW))}if(n&&n.hasAttribute("drop-disabled")){this._dropLocation=void 0;return}r.stopPropagation(),r.preventDefault(),this._dropLocation===C0.EMPTY?this._toggleAttribute("dragover",!0,this):n?(this._dragOverItem=n._item,n.getAttribute("dragover")!==this._dropLocation&&n.setAttribute("dragover",this._dropLocation)):this._clearDragStyles()}}__dndAutoScroll(r){if(this.__dndAutoScrolling)return!0;let n=this.$.header.getBoundingClientRect().bottom,i=this.$.footer.getBoundingClientRect().top,o=n-r+this.__dndAutoScrollThreshold,a=r-i+this.__dndAutoScrollThreshold,s=0;if(a>0?s=a*2:o>0&&(s=-o*2),s){let l=this.$.table.scrollTop;if(this.$.table.scrollTop+=s,l!==this.$.table.scrollTop)return this.__dndAutoScrolling=!0,setTimeout(()=>this.__dndAutoScrolling=!1,20),this._scrollHandler(),!0}}__getViewportRows(){let r=this.$.header.getBoundingClientRect().bottom,n=this.$.footer.getBoundingClientRect().top;return Array.from(this.$.items.children).filter(i=>{let o=i.getBoundingClientRect();return o.bottom>r&&o.top<n})}_clearDragStyles(){this.removeAttribute("dragover"),Array.from(this.$.items.children).forEach(r=>r.removeAttribute("dragover"))}_onDrop(r){if(this.dropMode){r.stopPropagation(),r.preventDefault();let n=r.dataTransfer.types&&Array.from(r.dataTransfer.types).map(o=>({type:o,data:r.dataTransfer.getData(o)}));this._clearDragStyles();let i=new CustomEvent("grid-drop",{bubbles:r.bubbles,cancelable:r.cancelable,detail:{dropTargetItem:this._dragOverItem,dropLocation:this._dropLocation,dragData:n}});i.originalEvent=r,this.dispatchEvent(i)}}__formatDefaultTransferData(r){return r.map(n=>Array.from(n.children).filter(i=>!i.hidden&&i.getAttribute("part").indexOf("details-cell")===-1).sort((i,o)=>i._column._order>o._column._order?1:-1).map(i=>i._content.textContent.trim()).filter(i=>i).join("	")).join(`
`)}_dragDropAccessChanged(){this.filterDragAndDrop()}filterDragAndDrop(){Array.from(this.$.items.children).filter(r=>!r.hidden).forEach(r=>{this._filterDragAndDrop(r,this.__getRowModel(r))})}_filterDragAndDrop(r,n){let i=!this.rowsDraggable||this.dragFilter&&!this.dragFilter(n),o=!this.dropMode||this.dropFilter&&!this.dropFilter(n);Array.from(r.children).map(s=>s._content).forEach(s=>{i?s.removeAttribute("draggable"):s.setAttribute("draggable",!0)}),this._toggleAttribute("drag-disabled",i,r),this._toggleAttribute("drop-disabled",o,r)}};var cue=e=>class extends e{static get properties(){return{_headerFocusable:{type:Object,observer:"_focusableChanged"},_itemsFocusable:{type:Object,observer:"_focusableChanged"},_footerFocusable:{type:Object,observer:"_focusableChanged"},_navigatingIsHidden:Boolean,_focusedItemIndex:{type:Number,value:0},_focusedColumnOrder:Number,interacting:{type:Boolean,value:!1,reflectToAttribute:!0,readOnly:!0,observer:"_interactingChanged"}}}ready(){super.ready(),!(this._ios||this._android)&&(this.addEventListener("keydown",this._onKeyDown),this.addEventListener("keyup",this._onKeyUp),this.addEventListener("focusin",this._onFocusIn),this.addEventListener("focusout",this._onFocusOut),this.$.table.addEventListener("focusin",this._onCellFocusIn.bind(this)),this.$.table.addEventListener("focusout",this._onCellFocusOut.bind(this)),this.addEventListener("mousedown",()=>{this._toggleAttribute("navigating",!1,this),this._isMousedown=!0}),this.addEventListener("mouseup",()=>this._isMousedown=!1))}_focusableChanged(r,n){n&&n.setAttribute("tabindex","-1"),r&&this._updateGridSectionFocusTarget(r)}_interactingChanged(){this._updateGridSectionFocusTarget(this._headerFocusable),this._updateGridSectionFocusTarget(this._itemsFocusable),this._updateGridSectionFocusTarget(this._footerFocusable)}_onKeyDown(r){let n=r.key,i;switch(n){case"ArrowUp":case"ArrowDown":case"ArrowLeft":case"ArrowRight":case"PageUp":case"PageDown":case"Home":case"End":i="Navigation";break;case"Enter":case"Escape":case"F2":i="Interaction";break;case"Tab":i="Tab";break;case" ":i="Space";break}this._detectInteracting(r),this.interacting&&i!=="Interaction"&&(i=void 0),i&&this[`_on${i}KeyDown`](r,n)}_ensureScrolledToIndex(r){Array.from(this.$.items.children).filter(i=>i.index===r)[0]||this._scrollToIndex(r)}_onNavigationKeyDown(r,n){this._scrollHandler(),r.preventDefault();function i(B){return Array.prototype.indexOf.call(B.parentNode.children,B)}let o=this._lastVisibleIndex-this._firstVisibleIndex-1,a=0,s=0;switch(n){case"ArrowRight":a=this.__isRTL?-1:1;break;case"ArrowLeft":a=this.__isRTL?1:-1;break;case"Home":a=-1/0,r.ctrlKey&&(s=-1/0);break;case"End":a=1/0,r.ctrlKey&&(s=1/0);break;case"ArrowDown":s=1;break;case"ArrowUp":s=-1;break;case"PageDown":s=o;break;case"PageUp":s=-o;break}let l=r.composedPath()[0],c=i(l),u=this._elementMatches(l,'[part~="details-cell"]'),h=l.parentNode,f=h.parentNode,p=(f===this.$.items?this._effectiveSize:f.children.length)-1,d=f===this.$.items?this._focusedItemIndex!==void 0?this._focusedItemIndex:h.index:i(h),g=Math.max(0,Math.min(d+s,p)),_=!1;if(f===this.$.items){let B=h._item,I=this._cache.getItemForIndex(g);u?_=s===0:_=s===1&&this._isDetailsOpened(B)||s===-1&&g!==d&&this._isDetailsOpened(I),_!==u&&(s===1&&_||s===-1&&!_)&&(g=d)}if(f!==this.$.items){if(g>d)for(;g<p&&f.children[g].hidden;)g++;else if(g<d)for(;g>0&&f.children[g].hidden;)g--}this._focusedColumnOrder===void 0&&(u?this._focusedColumnOrder=0:this._focusedColumnOrder=this._getColumns(f,d).filter(B=>!B.hidden)[c]._order);let y=this._getColumns(f,g).filter(B=>!B.hidden),x=y.map(B=>B._order).sort((B,I)=>B-I),b=x.length-1,S=x.indexOf(x.slice(0).sort((B,I)=>Math.abs(B-this._focusedColumnOrder)-Math.abs(I-this._focusedColumnOrder))[0]),C=s===0&&u?S:Math.max(0,Math.min(S+a,b));C!==S&&(this._focusedColumnOrder=void 0),f===this.$.items&&this._ensureScrolledToIndex(g),this._toggleAttribute("navigating",!0,this);let k=y.reduce((B,I,L)=>(B[I._order]=L,B),{})[x[C]],O=f===this.$.items?Array.from(f.children).filter(B=>B.index===g)[0]:f.children[g];if(!O)return;let D=_?Array.from(O.children).filter(B=>this._elementMatches(B,'[part~="details-cell"]'))[0]:O.children[k];if(this._scrollHorizontallyToCell(D),f===this.$.items&&(this._focusedItemIndex=g),f===this.$.items){let B=D.getBoundingClientRect(),I=this.$.footer.getBoundingClientRect().top,L=this.$.header.getBoundingClientRect().bottom;B.bottom>I?(this.$.table.scrollTop+=B.bottom-I,this._scrollHandler()):B.top<L&&(this.$.table.scrollTop-=L-B.top,this._scrollHandler())}D.focus()}_onInteractionKeyDown(r,n){let i=r.composedPath()[0],o=i.localName==="input"&&!/^(button|checkbox|color|file|image|radio|range|reset|submit)$/i.test(i.type),a;switch(n){case"Enter":a=this.interacting?!o:!0;break;case"Escape":a=!1;break;case"F2":a=!this.interacting;break}let{cell:s}=this._getGridEventLocation(r);if(this.interacting!==a&&s!==null)if(a){let l=s._content.querySelector("[focus-target]")||s._content.firstElementChild;l&&(r.preventDefault(),l.focus(),this._setInteracting(!0),this._toggleAttribute("navigating",!1,this))}else r.preventDefault(),this._focusedColumnOrder=void 0,s.focus(),this._setInteracting(!1),this._toggleAttribute("navigating",!0,this)}_predictFocusStepTarget(r,n){let i=[this.$.table,this._headerFocusable,this._itemsFocusable,this._footerFocusable,this.$.focusexit],o=i.indexOf(r);for(o+=n;o>=0&&o<=i.length-1&&(!i[o]||i[o].parentNode.hidden);)o+=n;return i[o]}_onTabKeyDown(r){let n=this._predictFocusStepTarget(r.composedPath()[0],r.shiftKey?-1:1);if(n===this.$.table)this.$.table.focus();else if(n===this.$.focusexit)this.$.focusexit.focus();else if(n===this._itemsFocusable){let i=n,o=this._itemsFocusable.parentNode;if(this._ensureScrolledToIndex(this._focusedItemIndex),o.index!==this._focusedItemIndex){let a=Array.from(o.children).indexOf(this._itemsFocusable),s=Array.from(this.$.items.children).filter(l=>l.index===this._focusedItemIndex)[0];s&&(i=s.children[a])}r.preventDefault(),i.focus()}else r.preventDefault(),n.focus();this._toggleAttribute("navigating",!0,this)}_onSpaceKeyDown(r){r.preventDefault();let n=r.composedPath()[0];(!n._content||!n._content.firstElementChild)&&this.dispatchEvent(new CustomEvent("cell-activate",{detail:{model:this.__getRowModel(n.parentElement)}}))}_onKeyUp(r){if(!/^( |SpaceBar)$/.test(r.key))return;r.preventDefault();let n=r.composedPath()[0];if(n._content&&n._content.firstElementChild){let i=this.hasAttribute("navigating");n._content.firstElementChild.click(),this._toggleAttribute("navigating",i,this)}}_onFocusIn(r){this._isMousedown||this._toggleAttribute("navigating",!0,this);let n=r.composedPath()[0];n===this.$.table||n===this.$.focusexit?(this._predictFocusStepTarget(n,n===this.$.table?1:-1).focus(),this._setInteracting(!1)):this._detectInteracting(r)}_onFocusOut(r){this._toggleAttribute("navigating",!1,this),this._detectInteracting(r)}_onCellFocusIn(r){let{section:n,cell:i}=this._getGridEventLocation(r);this._detectInteracting(r),n&&i&&(this._activeRowGroup=n,this.$.header===n?this._headerFocusable=i:this.$.items===n?this._itemsFocusable=i:this.$.footer===n&&(this._footerFocusable=i),i._content.dispatchEvent(new CustomEvent("cell-focusin",{bubbles:!1})),i.dispatchEvent(new CustomEvent("cell-focus",{bubbles:!0,composed:!0}))),this._detectFocusedItemIndex(r)}_onCellFocusOut(r){r.composedPath().indexOf(this.$.table)===3&&r.composedPath()[0]._content.dispatchEvent(new CustomEvent("cell-focusout",{bubbles:!1}))}_detectInteracting(r){let n=r.composedPath().some(i=>i.localName==="vaadin-grid-cell-content");this._setInteracting(n)}_detectFocusedItemIndex(r){let{section:n,row:i}=this._getGridEventLocation(r);n===this.$.items&&(this._focusedItemIndex=i.index)}_updateGridSectionFocusTarget(r){if(!r)return;let n=this._getGridSectionFromFocusTarget(r),i=this.interacting&&n===this._activeRowGroup;r.tabIndex=i?-1:0}_preventScrollerRotatingCellFocus(r,n){r.index===this._focusedItemIndex&&this.hasAttribute("navigating")&&this._activeRowGroup===this.$.items&&(this._navigatingIsHidden=!0,this._toggleAttribute("navigating",!1,this)),n===this._focusedItemIndex&&this._navigatingIsHidden&&(this._navigatingIsHidden=!1,this._toggleAttribute("navigating",!0,this))}_getColumns(r,n){let i=this._columnTree.length-1;return r===this.$.header?i=n:r===this.$.footer&&(i=this._columnTree.length-1-n),this._columnTree[i]}_resetKeyboardNavigation(){if(this.$.header.firstElementChild&&(this._headerFocusable=Array.from(this.$.header.firstElementChild.children).filter(r=>!r.hidden)[0]),this.$.items.firstElementChild){let r=this._iterateItems((n,i)=>{if(this._firstVisibleIndex===i)return this.$.items.children[n]});r&&(this._itemsFocusable=Array.from(r.children).filter(n=>!n.hidden)[0])}this.$.footer.firstElementChild&&(this._footerFocusable=Array.from(this.$.footer.firstElementChild.children).filter(r=>!r.hidden)[0])}_scrollHorizontallyToCell(r){if(r.hasAttribute("frozen")||this._elementMatches(r,'[part~="details-cell"]'))return;let n=r.getBoundingClientRect(),i=r.parentNode,o=Array.from(i.children).indexOf(r),a=this.$.table.getBoundingClientRect(),s=a.left,l=a.right;for(let c=o-1;c>=0;c--){let u=i.children[c];if(!(u.hasAttribute("hidden")||this._elementMatches(u,'[part~="details-cell"]'))&&u.hasAttribute("frozen")){s=u.getBoundingClientRect().right;break}}for(let c=o+1;c<i.children.length;c++){let u=i.children[c];if(!(u.hasAttribute("hidden")||this._elementMatches(u,'[part~="details-cell"]'))&&u.hasAttribute("frozen")){l=u.getBoundingClientRect().left;break}}n.left<s&&(this.$.table.scrollLeft+=Math.round(n.left-s)),n.right>l&&(this.$.table.scrollLeft+=Math.round(n.right-l))}_elementMatches(r,n){return r.matches?r.matches(n):Array.from(r.parentNode.querySelectorAll(n)).indexOf(r)!==-1}_getGridEventLocation(r){let n=r.composedPath(),i=n.indexOf(this.$.table),o=i>=1?n[i-1]:null,a=i>=2?n[i-2]:null,s=i>=3?n[i-3]:null;return{section:o,row:a,cell:s}}_getGridSectionFromFocusTarget(r){return r===this._headerFocusable?this.$.header:r===this._itemsFocusable?this.$.items:r===this._footerFocusable?this.$.footer:null}};function uue(e,t,r){let n=1;e.forEach(i=>{n%10===0&&n++,i._order=r+n*t,n++})}var hue=e=>class extends yh(e){static get properties(){return{columnReorderingAllowed:{type:Boolean,value:!1},_orderBaseScope:{type:Number,value:1e7}}}static get observers(){return["_updateOrders(_columnTree, _columnTree.*)"]}ready(){super.ready(),Em(this,"track",this._onTrackEvent),this._reorderGhost=this.shadowRoot.querySelector('[part="reorder-ghost"]'),this.addEventListener("touchstart",this._onTouchStart.bind(this)),this.addEventListener("touchmove",this._onTouchMove.bind(this)),this.addEventListener("touchend",this._onTouchEnd.bind(this)),this.addEventListener("contextmenu",this._onContextMenu.bind(this))}_onContextMenu(r){this.hasAttribute("reordering")&&r.preventDefault()}_onTouchStart(r){this._startTouchReorderTimeout=setTimeout(()=>{this._onTrackStart({detail:{x:r.touches[0].clientX,y:r.touches[0].clientY}})},100)}_onTouchMove(r){this._draggedColumn&&r.preventDefault(),clearTimeout(this._startTouchReorderTimeout)}_onTouchEnd(){clearTimeout(this._startTouchReorderTimeout),this._onTrackEnd()}_onTrackEvent(r){if(r.detail.state==="start"){let n=r.composedPath(),i=n[n.indexOf(this.$.header)-2];if(!i||!i._content||i._content.contains(this.getRootNode().activeElement)||this.$.scroller.hasAttribute("column-resizing"))return;this._touchDevice||this._onTrackStart(r)}else r.detail.state==="track"?this._onTrack(r):r.detail.state==="end"&&this._onTrackEnd(r)}_onTrackStart(r){if(!this.columnReorderingAllowed)return;let n=r.composedPath&&r.composedPath();if(n&&n.filter(o=>o.hasAttribute&&o.hasAttribute("draggable"))[0])return;let i=this._cellFromPoint(r.detail.x,r.detail.y);if(!(!i||i.getAttribute("part").indexOf("header-cell")===-1)){for(this._toggleAttribute("reordering",!0,this),this._draggedColumn=i._column;this._draggedColumn.parentElement.childElementCount===1;)this._draggedColumn=this._draggedColumn.parentElement;this._setSiblingsReorderStatus(this._draggedColumn,"allowed"),this._draggedColumn._reorderStatus="dragging",this._updateGhost(i),this._reorderGhost.style.visibility="visible",this._updateGhostPosition(r.detail.x,this._touchDevice?r.detail.y-50:r.detail.y),this._autoScroller()}}_onTrack(r){if(!this._draggedColumn)return;let n=this._cellFromPoint(r.detail.x,r.detail.y);if(!n)return;let i=this._getTargetColumn(n,this._draggedColumn);this._isSwapAllowed(this._draggedColumn,i)&&this._isSwappableByPosition(i,r.detail.x)&&this._swapColumnOrders(this._draggedColumn,i),this._updateGhostPosition(r.detail.x,this._touchDevice?r.detail.y-50:r.detail.y),this._lastDragClientX=r.detail.x}_onTrackEnd(){!this._draggedColumn||(this._toggleAttribute("reordering",!1,this),this._draggedColumn._reorderStatus="",this._setSiblingsReorderStatus(this._draggedColumn,""),this._draggedColumn=null,this._lastDragClientX=null,this._reorderGhost.style.visibility="hidden",this.dispatchEvent(new CustomEvent("column-reorder",{detail:{columns:this._getColumnsInOrder()}})))}_getColumnsInOrder(){return this._columnTree.slice(0).pop().filter(r=>!r.hidden).sort((r,n)=>r._order-n._order)}_cellFromPoint(r,n){r=r||0,n=n||0,this._draggedColumn||this._toggleAttribute("no-content-pointer-events",!0,this.$.scroller);let i=this.shadowRoot.elementFromPoint(r,n);if(this._toggleAttribute("no-content-pointer-events",!1,this.$.scroller),i&&i._column)return i}_updateGhostPosition(r,n){let i=this._reorderGhost.getBoundingClientRect(),o=r-i.width/2,a=n-i.height/2,s=parseInt(this._reorderGhost._left||0),l=parseInt(this._reorderGhost._top||0);this._reorderGhost._left=s-(i.left-o),this._reorderGhost._top=l-(i.top-a),this._reorderGhost.style.transform=`translate(${this._reorderGhost._left}px, ${this._reorderGhost._top}px)`}_updateGhost(r){let n=this._reorderGhost;n.textContent=r._content.innerText;let i=window.getComputedStyle(r);return["boxSizing","display","width","height","background","alignItems","padding","border","flex-direction","overflow"].forEach(o=>n.style[o]=i[o]),n}_updateOrders(r,n){r===void 0||n===void 0||(r[0].forEach(i=>i._order=0),uue(r[0],this._orderBaseScope,0))}_setSiblingsReorderStatus(r,n){Array.from(r.parentNode.children).filter(i=>/column/.test(i.localName)&&this._isSwapAllowed(i,r)).forEach(i=>i._reorderStatus=n)}_autoScroller(){if(this._lastDragClientX){let r=this._lastDragClientX-this.getBoundingClientRect().right+50,n=this.getBoundingClientRect().left-this._lastDragClientX+50;r>0?this.$.table.scrollLeft+=r/10:n>0&&(this.$.table.scrollLeft-=n/10),this._scrollHandler()}this._draggedColumn&&this.async(this._autoScroller,10)}_isSwapAllowed(r,n){if(r&&n){let i=r!==n,o=r.parentElement===n.parentElement,a=r.frozen===n.frozen;return i&&o&&a}}_isSwappableByPosition(r,n){let i=Array.from(this.$.header.querySelectorAll('tr:not([hidden]) [part~="cell"]')).filter(s=>r.contains(s._column))[0],o=this.$.header.querySelector("tr:not([hidden]) [reorder-status=dragging]").getBoundingClientRect(),a=i.getBoundingClientRect();return a.left>o.left?n>a.right-o.width:n<a.left+o.width}_swapColumnOrders(r,n){let i=r._order;r._order=n._order,n._order=i,this._updateLastFrozen(),this._updateFirstAndLastColumn()}_getTargetColumn(r,n){if(r&&n){let i=r._column;for(;i.parentElement!==n.parentElement&&i!==this;)i=i.parentElement;return i.parentElement===n.parentElement?i:r._column}}};var chr=e=>class extends e{static get properties(){return{resizable:{type:Boolean,value:function(){if(this.localName==="vaadin-grid-column-group")return;let r=this.parentNode;return r&&r.localName==="vaadin-grid-column-group"&&r.resizable||!1}},_headerTemplate:{type:Object},_footerTemplate:{type:Object},frozen:{type:Boolean,value:!1},hidden:{type:Boolean},header:{type:String},textAlign:{type:String},_lastFrozen:{type:Boolean,value:!1},_order:Number,_reorderStatus:Boolean,_emptyCells:Array,_headerCell:Object,_footerCell:Object,_grid:Object,headerRenderer:Function,footerRenderer:Function}}static get observers(){return["_widthChanged(width, _headerCell, _footerCell, _cells.*)","_frozenChanged(frozen, _headerCell, _footerCell, _cells.*)","_flexGrowChanged(flexGrow, _headerCell, _footerCell, _cells.*)","_pathOrHeaderChanged(path, header, _headerCell, _footerCell, _cells.*, renderer, headerRenderer, _bodyTemplate, _headerTemplate)","_textAlignChanged(textAlign, _cells.*, _headerCell, _footerCell)","_orderChanged(_order, _headerCell, _footerCell, _cells.*)","_lastFrozenChanged(_lastFrozen)","_setBodyTemplateOrRenderer(_bodyTemplate, renderer, _cells, _cells.*)","_setHeaderTemplateOrRenderer(_headerTemplate, headerRenderer, _headerCell)","_setFooterTemplateOrRenderer(_footerTemplate, footerRenderer, _footerCell)","_resizableChanged(resizable, _headerCell)","_reorderStatusChanged(_reorderStatus, _headerCell, _footerCell, _cells.*)","_hiddenChanged(hidden, _headerCell, _footerCell, _cells.*)"]}connectedCallback(){super.connectedCallback(),this._bodyTemplate&&(this._bodyTemplate.templatizer._grid=this._grid),this._headerTemplate&&(this._headerTemplate.templatizer._grid=this._grid),this._footerTemplate&&(this._footerTemplate.templatizer._grid=this._grid),this._templateObserver.flush(),this._bodyTemplate||this._templateObserver.callback(),requestAnimationFrame(()=>{this._allCells.forEach(r=>{r._content.parentNode||this._grid&&this._grid.appendChild(r._content)})})}disconnectedCallback(){super.disconnectedCallback(),requestAnimationFrame(()=>{this._findHostGrid()||this._allCells.forEach(r=>{r._content.parentNode&&r._content.parentNode.removeChild(r._content)})}),this._gridValue=void 0}_findHostGrid(){let r=this;for(;r&&!/^vaadin.*grid(-pro)?$/.test(r.localName);)r=r.assignedSlot?r.assignedSlot.parentNode:r.parentNode;return r||void 0}get _grid(){return this._gridValue||(this._gridValue=this._findHostGrid()),this._gridValue}get _allCells(){return[].concat(this._cells||[]).concat(this._emptyCells||[]).concat(this._headerCell).concat(this._footerCell).filter(r=>r)}constructor(){super(),this._templateObserver=new vh(this,()=>{this._headerTemplate=this._prepareHeaderTemplate(),this._footerTemplate=this._prepareFooterTemplate(),this._bodyTemplate=this._prepareBodyTemplate()})}_prepareHeaderTemplate(){return this._prepareTemplatizer(this._findTemplate(!0)||null,{})}_prepareFooterTemplate(){return this._prepareTemplatizer(this._findTemplate(!1,!0)||null,{})}_prepareBodyTemplate(){return this._prepareTemplatizer(this._findTemplate()||null)}_prepareTemplatizer(r,n){if(r&&!r.templatizer){let i=new T0;i._grid=this._grid,i.dataHost=this.dataHost,i._instanceProps=n||i._instanceProps,i.template=r,r.templatizer=i}return r}_renderHeaderAndFooter(){this.headerRenderer&&this._headerCell&&this.__runRenderer(this.headerRenderer,this._headerCell),this.footerRenderer&&this._footerCell&&this.__runRenderer(this.footerRenderer,this._footerCell)}__runRenderer(r,n,i){let o=[n._content,this];i&&i.item&&o.push(i),r.apply(this,o)}__setColumnTemplateOrRenderer(r,n,i){if(!this.hidden){if(r&&n)throw new Error("You should only use either a renderer or a template");i.forEach(o=>{let a=this._grid.__getRowModel(o.parentElement);if(n)o._renderer=n,(a.item||n===this.headerRenderer||n===this.footerRenderer)&&this.__runRenderer(n,o,a);else if(o._template!==r){o._template=r,o._content.innerHTML="",r.templatizer._grid=r.templatizer._grid||this._grid;let s=r.templatizer.createInstance();o._content.appendChild(s.root),o._instance=s,a.item&&o._instance.setProperties(a)}})}}_setBodyTemplateOrRenderer(r,n,i){(r||n)&&i&&this.__setColumnTemplateOrRenderer(r,n,i)}_setHeaderTemplateOrRenderer(r,n,i){(r||n)&&i&&this.__setColumnTemplateOrRenderer(r,n,[i])}_setFooterTemplateOrRenderer(r,n,i){(r||n)&&i&&(this.__setColumnTemplateOrRenderer(r,n,[i]),this._grid.__updateHeaderFooterRowVisibility(i.parentElement))}_selectFirstTemplate(r=!1,n=!1){return vh.getFlattenedNodes(this).filter(i=>i.localName==="template"&&i.classList.contains("header")===r&&i.classList.contains("footer")===n)[0]}_findTemplate(r,n){let i=this._selectFirstTemplate(r,n);return i&&this.dataHost&&(i._rootDataHost=this.dataHost._rootDataHost||this.dataHost),i}_flexGrowChanged(r){this.parentElement&&this.parentElement._columnPropChanged&&this.parentElement._columnPropChanged("flexGrow"),this._allCells.forEach(n=>n.style.flexGrow=r)}_orderChanged(r){this._allCells.forEach(n=>n.style.order=r)}_widthChanged(r){this.parentElement&&this.parentElement._columnPropChanged&&this.parentElement._columnPropChanged("width"),this._allCells.forEach(n=>n.style.width=r),this._grid&&this._grid.__forceReflow&&this._grid.__forceReflow()}_frozenChanged(r){this.parentElement&&this.parentElement._columnPropChanged&&this.parentElement._columnPropChanged("frozen",r),this._allCells.forEach(n=>this._toggleAttribute("frozen",r,n)),this._grid&&this._grid._frozenCellsChanged&&this._grid._frozenCellsChanged()}_lastFrozenChanged(r){this._allCells.forEach(n=>this._toggleAttribute("last-frozen",r,n)),this.parentElement&&this.parentElement._columnPropChanged&&(this.parentElement._lastFrozen=r)}_pathOrHeaderChanged(r,n,i,o,a,s,l,c,u){let h=n!==void 0;if(!l&&!u&&h&&i&&this.__setTextContent(i._content,n),r&&a.value){if(!s&&!c){let f=(p,d,{item:g})=>this.__setTextContent(p,this.get(r,g));this.__setColumnTemplateOrRenderer(void 0,f,a.value)}!l&&!u&&!h&&i&&n!==null&&this.__setTextContent(i._content,this._generateHeader(r))}i&&this._grid.__updateHeaderFooterRowVisibility(i.parentElement)}__setTextContent(r,n){r.textContent!==n&&(r.textContent=n)}_generateHeader(r){return r.substr(r.lastIndexOf(".")+1).replace(/([A-Z])/g,"-$1").toLowerCase().replace(/-/g," ").replace(/^./,n=>n.toUpperCase())}_toggleAttribute(r,n,i){i.hasAttribute(r)===!n&&(n?i.setAttribute(r,""):i.removeAttribute(r))}_reorderStatusChanged(r){this._allCells.forEach(n=>n.setAttribute("reorder-status",r))}_resizableChanged(r,n){r===void 0||n===void 0||n&&[n].concat(this._emptyCells).forEach(i=>{if(i){let o=i.querySelector('[part~="resize-handle"]');if(o&&i.removeChild(o),r){let a=document.createElement("div");a.setAttribute("part","resize-handle"),i.appendChild(a)}}})}_textAlignChanged(r){if(r===void 0)return;if(["start","end","center"].indexOf(r)===-1){console.warn('textAlign can only be set as "start", "end" or "center"');return}let n;getComputedStyle(this._grid).direction==="ltr"?r==="start"?n="left":r==="end"&&(n="right"):r==="start"?n="right":r==="end"&&(n="left"),this._allCells.forEach(i=>{i._content.style.textAlign=r,getComputedStyle(i._content).textAlign!==r&&(i._content.style.textAlign=n)})}_hiddenChanged(r){this.parentElement&&this.parentElement._columnPropChanged&&this.parentElement._columnPropChanged("hidden",r),!!r!=!!this._previousHidden&&this._grid&&(r===!0&&this._allCells.forEach(n=>{n._content.parentNode&&n._content.parentNode.removeChild(n._content)}),this._grid._debouncerHiddenChanged=sr.debounce(this._grid._debouncerHiddenChanged,Ni,()=>{this._grid&&this._grid._renderColumnTree&&this._grid._renderColumnTree(this._grid._columnTree)}),this._grid._updateLastFrozen&&this._grid._updateLastFrozen(),this._grid.notifyResize&&this._grid.notifyResize(),this._grid._resetKeyboardNavigation&&this._grid._resetKeyboardNavigation()),this._previousHidden=r}},eV=class extends chr(ZH(mt)){static get is(){return"vaadin-grid-column"}static get properties(){return{width:{type:String,value:"100px"},flexGrow:{type:Number,value:1},renderer:Function,path:{type:String},autoWidth:{type:Boolean,value:!1},_bodyTemplate:{type:Object},_cells:Array}}};customElements.define(eV.is,eV);jc("vaadin-grid",Ci`
    @keyframes vaadin-grid-appear {
      to {
        opacity: 1;
      }
    }

    :host {
      display: block;
      animation: 1ms vaadin-grid-appear;
      height: 400px;
      flex: 1 1 auto;
      align-self: stretch;
      position: relative;
    }

    :host([hidden]) {
      display: none !important;
    }

    #scroller {
      display: block;
      transform: translateY(0);
      width: auto;
      height: auto;
      position: absolute;
      top: 0;
      right: 0;
      bottom: 0;
      left: 0;
    }

    :host([height-by-rows]) {
      height: auto;
      align-self: flex-start;
      flex-grow: 0;
      width: 100%;
    }

    :host([height-by-rows]) #scroller {
      width: 100%;
      height: 100%;
      position: relative;
    }

    #table {
      display: flex;
      flex-direction: column;
      width: 100%;
      height: 100%;
      overflow: auto;
      position: relative;
      outline: none;
      /* Workaround for a Desktop Safari bug: new stacking context here prevents the scrollbar from getting hidden */
      z-index: 0;
    }

    #header,
    #footer {
      display: block;
      position: -webkit-sticky;
      position: sticky;
      left: 0;
      overflow: visible;
      width: 100%;
      z-index: 1;
    }

    #header {
      top: 0;
    }

    th {
      text-align: inherit;
    }

    /* Safari doesn't work with "inherit" */
    [safari] th {
      text-align: initial;
    }

    #footer {
      bottom: 0;
    }

    #items {
      flex-grow: 1;
      flex-shrink: 0;
      display: block;
      position: -webkit-sticky;
      position: sticky;
      width: 100%;
      left: 0;
      overflow: visible;
    }

    [part~='row'] {
      display: flex;
      width: 100%;
      box-sizing: border-box;
      margin: 0;
    }

    [part~='row'][loading] [part~='body-cell'] ::slotted(vaadin-grid-cell-content) {
      opacity: 0;
    }

    #items [part~='row'] {
      position: absolute;
    }

    #items [part~='row']:empty {
      height: 1em;
    }

    [part~='cell']:not([part~='details-cell']) {
      flex-shrink: 0;
      flex-grow: 1;
      box-sizing: border-box;
      display: flex;
      width: 100%;
      position: relative;
      align-items: center;
      padding: 0;
      white-space: nowrap;
    }

    [part~='details-cell'] {
      position: absolute;
      bottom: 0;
      width: 100%;
      box-sizing: border-box;
      padding: 0;
    }

    [part~='cell'] ::slotted(vaadin-grid-cell-content) {
      display: block;
      width: 100%;
      box-sizing: border-box;
      overflow: hidden;
      text-overflow: ellipsis;
    }

    [hidden] {
      display: none !important;
    }

    [frozen] {
      z-index: 2;
      will-change: transform;
    }

    [no-scrollbars][safari] #table,
    [no-scrollbars][firefox] #table {
      overflow: hidden;
    }

    /* Reordering styles */
    :host([reordering]) [part~='cell'] ::slotted(vaadin-grid-cell-content),
    :host([reordering]) [part~='resize-handle'],
    #scroller[no-content-pointer-events] [part~='cell'] ::slotted(vaadin-grid-cell-content) {
      pointer-events: none;
    }

    [part~='reorder-ghost'] {
      visibility: hidden;
      position: fixed;
      pointer-events: none;
      opacity: 0.5;

      /* Prevent overflowing the grid in Firefox */
      top: 0;
      left: 0;
    }

    :host([reordering]) {
      -moz-user-select: none;
      -webkit-user-select: none;
      user-select: none;
    }

    /* Resizing styles */
    [part~='resize-handle'] {
      position: absolute;
      top: 0;
      right: 0;
      height: 100%;
      cursor: col-resize;
      z-index: 1;
    }

    [part~='resize-handle']::before {
      position: absolute;
      content: '';
      height: 100%;
      width: 35px;
      transform: translateX(-50%);
    }

    [last-column] [part~='resize-handle']::before,
    [last-frozen] [part~='resize-handle']::before {
      width: 18px;
      transform: none;
      right: 0;
    }

    #scroller[column-resizing] {
      -ms-user-select: none;
      -moz-user-select: none;
      -webkit-user-select: none;
      user-select: none;
    }

    /* Sizer styles */
    #sizer {
      display: flex;
      position: absolute;
      visibility: hidden;
    }

    #sizer [part~='details-cell'] {
      display: none !important;
    }

    #sizer [part~='cell'][hidden] {
      display: none !important;
    }

    #sizer [part~='cell'] {
      display: block;
      flex-shrink: 0;
      line-height: 0;
      height: 0 !important;
      min-height: 0 !important;
      max-height: 0 !important;
      padding: 0 !important;
      border: none !important;
    }

    #sizer [part~='cell']::before {
      content: '-';
    }

    #sizer [part~='cell'] ::slotted(vaadin-grid-cell-content) {
      display: none !important;
    }

    /* RTL specific styles */

    :host([dir='rtl']) #items,
    :host([dir='rtl']) #header,
    :host([dir='rtl']) #footer {
      left: auto;
    }

    :host([dir='rtl']) [part~='reorder-ghost'] {
      left: auto;
      right: 0;
    }

    :host([dir='rtl']) [part~='resize-handle'] {
      left: 0;
      right: auto;
    }

    :host([dir='rtl']) [part~='resize-handle']::before {
      transform: translateX(50%);
    }

    :host([dir='rtl']) [last-column] [part~='resize-handle']::before,
    :host([dir='rtl']) [last-frozen] [part~='resize-handle']::before {
      left: 0;
      right: auto;
    }
  `,{moduleId:"vaadin-grid-styles"});var uhr=(()=>{try{return document.createEvent("TouchEvent"),!0}catch(e){return!1}})(),rV=class extends JH(XH(Qce($ce(tue(Xce(iue(oue(aue(nue(cue(jce(rue(hue(Kce(eue(lue(sue(tV)))))))))))))))))){static get template(){return Q`
      <div
        id="scroller"
        safari$="[[_safari]]"
        ios$="[[_ios]]"
        loading$="[[loading]]"
        column-reordering-allowed$="[[columnReorderingAllowed]]"
      >
        <table id="table" role="grid" aria-multiselectable="true" tabindex="0">
          <caption id="sizer" part="row"></caption>
          <thead id="header" role="rowgroup"></thead>
          <tbody id="items" role="rowgroup"></tbody>
          <tfoot id="footer" role="rowgroup"></tfoot>
        </table>

        <div part="reorder-ghost"></div>
      </div>

      <div id="focusexit" tabindex="0"></div>
    `}static get is(){return"vaadin-grid"}static get version(){return"20.0.2"}static get observers(){return["_columnTreeChanged(_columnTree, _columnTree.*)"]}static get properties(){return{_safari:{type:Boolean,value:/^((?!chrome|android).)*safari/i.test(navigator.userAgent)},_ios:{type:Boolean,value:/iPad|iPhone|iPod/.test(navigator.userAgent)&&!window.MSStream||navigator.platform==="MacIntel"&&navigator.maxTouchPoints>1},_firefox:{type:Boolean,value:navigator.userAgent.toLowerCase().indexOf("firefox")>-1},_android:{type:Boolean,value:/android/i.test(navigator.userAgent)},_touchDevice:{type:Boolean,value:uhr},heightByRows:{type:Boolean,value:!1,reflectToAttribute:!0,observer:"_heightByRowsChanged"},_recalculateColumnWidthOnceLoadingFinished:{type:Boolean,value:!0}}}constructor(){super(),this.addEventListener("animationend",this._onAnimationEnd)}connectedCallback(){super.connectedCallback(),this.recalculateColumnWidths()}attributeChangedCallback(t,r,n){super.attributeChangedCallback(t,r,n),t==="dir"&&(this.__isRTL=n==="rtl",this._updateScrollerMeasurements())}__hasRowsWithClientHeight(){return!!Array.from(this.$.items.children).filter(t=>t.clientHeight).length}__itemsReceived(){this._recalculateColumnWidthOnceLoadingFinished&&!this._cache.isLoading()&&this.__hasRowsWithClientHeight()&&(this._recalculateColumnWidthOnceLoadingFinished=!1,this.recalculateColumnWidths())}_recalculateColumnWidths(t){t.forEach(r=>{r.width="auto",r._origFlexGrow=r.flexGrow,r.flexGrow=0}),t.forEach(r=>{r._currentWidth=0,r._allCells.forEach(n=>{let i=n.offsetWidth+1;r._currentWidth=Math.max(r._currentWidth,i)})}),t.forEach(r=>{r.width=`${r._currentWidth}px`,r.flexGrow=r._origFlexGrow,r._currentWidth=void 0,r._origFlexGrow=void 0})}recalculateColumnWidths(){if(!!this._columnTree)if(this._cache.isLoading())this._recalculateColumnWidthOnceLoadingFinished=!0;else{let t=this._getColumns().filter(r=>!r.hidden&&r.autoWidth);this._recalculateColumnWidths(t)}}_createScrollerRows(t){let r=[];for(let n=0;n<t;n++){let i=document.createElement("tr");i.setAttribute("part","row"),i.setAttribute("role","row"),this._columnTree&&this._updateRow(i,this._columnTree[this._columnTree.length-1],"body",!1,!0),r.push(i)}return this._columnTree&&this._columnTree[this._columnTree.length-1].forEach(n=>n.isConnected&&n.notifyPath&&n.notifyPath("_cells.*",n._cells)),vgt(this,()=>{this._updateFirstAndLastColumn(),this._resetKeyboardNavigation()}),r}_getRowTarget(){return this.$.items}_createCell(t){let r=this._contentIndex=this._contentIndex+1||0,n="vaadin-grid-cell-content-"+r,i=document.createElement("vaadin-grid-cell-content");i.setAttribute("slot",n);let o=document.createElement(t);o.id=n.replace("-content-","-"),o.setAttribute("tabindex","-1"),o.setAttribute("role",t==="td"?"gridcell":"columnheader");let a=document.createElement("slot");return a.setAttribute("name",n),o.appendChild(a),o._content=i,i.addEventListener("mousedown",()=>{if(window.chrome){let s=()=>{i.contains(this.getRootNode().activeElement)||o.focus(),document.removeEventListener("mouseup",s,!0)};document.addEventListener("mouseup",s,!0)}else setTimeout(()=>{i.contains(this.getRootNode().activeElement)||o.focus()})}),o}_updateRow(t,r,n,i,o){n=n||"body";let a=document.createDocumentFragment();Array.from(t.children).forEach(s=>s._vacant=!0),t.innerHTML="",t.id!=="sizer"&&(t.hidden=!0),r.filter(s=>!s.hidden).forEach((s,l,c)=>{let u;if(n==="body"){if(s._cells=s._cells||[],u=s._cells.filter(h=>h._vacant)[0],u||(u=this._createCell("td"),s._cells.push(u)),u.setAttribute("part","cell body-cell"),t.appendChild(u),l===c.length-1&&(this._rowDetailsTemplate||this.rowDetailsRenderer)){this._detailsCells=this._detailsCells||[];let h=this._detailsCells.filter(f=>f._vacant)[0]||this._createCell("td");this._detailsCells.indexOf(h)===-1&&this._detailsCells.push(h),h._content.parentElement||a.appendChild(h._content),this._configureDetailsCell(h),t.appendChild(h),this._a11ySetRowDetailsCell(t,h),h._vacant=!1}s.notifyPath&&!o&&s.notifyPath("_cells.*",s._cells)}else{let h=n==="header"?"th":"td";i||s.localName==="vaadin-grid-column-group"?(u=s[`_${n}Cell`]||this._createCell(h),u._column=s,t.appendChild(u),s[`_${n}Cell`]=u):(s._emptyCells=s._emptyCells||[],u=s._emptyCells.filter(f=>f._vacant)[0]||this._createCell(h),u._column=s,t.appendChild(u),s._emptyCells.indexOf(u)===-1&&s._emptyCells.push(u)),u.setAttribute("part",`cell ${n}-cell`),this.__updateHeaderFooterRowVisibility(t)}u._content.parentElement||a.appendChild(u._content),u._vacant=!1,u._column=s}),this.appendChild(a),this._frozenCellsChanged(),this._updateFirstAndLastColumnForRow(t)}__updateHeaderFooterRowVisibility(t){if(!t)return;let r=Array.from(t.children).filter(n=>{let i=n._column;if(i._emptyCells&&i._emptyCells.indexOf(n)>-1)return!1;if(t.parentElement===this.$.header){if(i.headerRenderer||i._headerTemplate)return!0;if(i.header===null)return!1;if(i.path||i.header!==void 0)return!0}else if(i.footerRenderer||i._footerTemplate)return!0});t.hidden!==!r.length&&(t.hidden=!r.length,this.notifyResize())}_updateScrollerItem(t,r){this._preventScrollerRotatingCellFocus(t,r),this._columnTree&&(this._toggleAttribute("first",r===0,t),this._toggleAttribute("odd",r%2,t),this._a11yUpdateRowRowindex(t,r),this._getItem(r,t))}_columnTreeChanged(t){this._renderColumnTree(t),this.recalculateColumnWidths()}_renderColumnTree(t){for(Array.from(this.$.items.children).forEach(r=>this._updateRow(r,t[t.length-1],null,!1,!0));this.$.header.children.length<t.length;){let r=document.createElement("tr");r.setAttribute("part","row"),r.setAttribute("role","row"),this.$.header.appendChild(r);let n=document.createElement("tr");n.setAttribute("part","row"),n.setAttribute("role","row"),this.$.footer.appendChild(n)}for(;this.$.header.children.length>t.length;)this.$.header.removeChild(this.$.header.firstElementChild),this.$.footer.removeChild(this.$.footer.firstElementChild);Array.from(this.$.header.children).forEach((r,n)=>this._updateRow(r,t[n],"header",n===t.length-1)),Array.from(this.$.footer.children).forEach((r,n)=>this._updateRow(r,t[t.length-1-n],"footer",n===0)),this._updateRow(this.$.sizer,t[t.length-1]),this._resizeHandler(),this._frozenCellsChanged(),this._updateFirstAndLastColumn(),this._resetKeyboardNavigation(),this._a11yUpdateHeaderRows(),this._a11yUpdateFooterRows(),this.__updateFooterPositioning()}__updateFooterPositioning(){this._firefox&&(this.$.items.style.paddingBottom=0,this.heightByRows||(this.$.items.style.paddingBottom=`${this.$.footer.offsetHeight}px`)),this._ios&&!window.CSS.supports("position","sticky")&&(this.$.table.style.height="",this.$.table.style.minHeight="100%",this.$.table.style.maxHeight="100%",setTimeout(()=>this.$.table.style.height=`${this.$.scroller.offsetHeight}px`))}_updateItem(t,r){t._item=r;let n=this.__getRowModel(t);this._toggleAttribute("selected",n.selected,t),this._a11yUpdateRowSelected(t,n.selected),this._a11yUpdateRowLevel(t,n.level),this._toggleAttribute("expanded",n.expanded,t),this._toggleAttribute("details-opened",this._isDetailsOpened(r),t),(this._rowDetailsTemplate||this.rowDetailsRenderer)&&this._toggleDetailsCell(t,r),this._generateCellClassNames(t,n),this._filterDragAndDrop(t,n),Array.from(t.children).forEach(i=>{if(i._renderer){let o=i._column||this;i._renderer.call(o,i._content,o,n)}else i._instance&&(i._instance.__detailsOpened__=n.detailsOpened,i._instance.__selected__=n.selected,i._instance.__level__=n.level,i._instance.__expanded__=n.expanded,i._instance.setProperties(n))}),this._debouncerUpdateHeights=sr.debounce(this._debouncerUpdateHeights,mo.after(1),()=>{this._updateMetrics(),this._positionItems(),this._updateScrollerSize()})}_resizeHandler(){this._updateDetailsCellHeights(),this._accessIronListAPI(super._resizeHandler,!0),this._updateScrollerMeasurements(),this.__updateFooterPositioning()}_onAnimationEnd(t){t.animationName.indexOf("vaadin-grid-appear")===0&&(this._render(),t.stopPropagation(),this.notifyResize(),this.__itemsReceived(),requestAnimationFrame(()=>{this.__scrollToPendingIndex(),this.$.table.style.webkitOverflowScrolling="touch"}))}_toggleAttribute(t,r,n){n.hasAttribute(t)===!r&&(r?n.setAttribute(t,""):n.removeAttribute(t))}__getRowModel(t){return{index:t.index,item:t._item,level:this._getIndexLevel(t.index),expanded:this._isExpanded(t._item),selected:this._isSelected(t._item),detailsOpened:!!(this._rowDetailsTemplate||this.rowDetailsRenderer)&&this._isDetailsOpened(t._item)}}render(){this._columnTree&&(this._columnTree.forEach(t=>{t.forEach(r=>r._renderHeaderAndFooter())}),this._update())}notifyResize(){super.notifyResize()}_heightByRowsChanged(t,r){(t||r)&&this.notifyResize()}__forceReflow(){this._debouncerForceReflow=sr.debounce(this._debouncerForceReflow,Ni,()=>{this.$.scroller.style.overflow="hidden",setTimeout(()=>this.$.scroller.style.overflow="")})}};customElements.define(rV.is,rV);function fue(e,t){return Bgt(e,t)}var c1=class extends mt{constructor(){super(...arguments),this._run=""}_csvUrl(t,r,n){return r?Mi(n(t,r),{format:"csv"}):""}_jsonUrl(t,r,n){return r?n(t,r):""}_csvName(t,r){return r?`run-${r}-tag-${t}.csv`:""}_jsonName(t,r){return r?`run-${r}-tag-${t}.json`:""}};c1.template=Q`
    <paper-dropdown-menu
      no-label-float="true"
      label="run to download"
      selected-item-label="{{_run}}"
    >
      <paper-listbox slot="dropdown-content">
        <template is="dom-repeat" items="[[runs]]">
          <paper-item no-label-float="true">[[item]]</paper-item>
        </template>
      </paper-listbox>
    </paper-dropdown-menu>
    <template is="dom-if" if="[[_run]]">
      <a download="[[_csvName(tag, _run)]]" href="[[_csvUrl(tag, _run, urlFn)]]"
        >CSV</a
      ><!--
      --><a
        download="[[_jsonName(tag, _run)]]"
        href="[[_jsonUrl(tag, _run, urlFn)]]"
        >JSON</a
      >
    </template>
    <style>
      :host {
        display: flex;
        align-items: center;
        height: 32px;
      }
      paper-dropdown-menu {
        width: 100px;
        --paper-input-container-label: {
          font-size: 10px;
        }
        --paper-input-container-input: {
          font-size: 10px;
        }
      }
      a {
        font-size: 10px;
        margin: 0 0.2em;
      }
      paper-input {
        font-size: 22px;
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],c1.prototype,"_run",void 0);E([A({type:Array}),w("design:type",Array)],c1.prototype,"runs",void 0);E([A({type:String}),w("design:type",String)],c1.prototype,"tag",void 0);E([A({type:Object}),w("design:type",Object)],c1.prototype,"urlFn",void 0);c1=E([yt("tf-downloader")],c1);var hhr=64,Eli=new URLSearchParams(window.location.search),Gn=class extends mt{constructor(){super(...arguments),this.colorScale=null,this._loadDataCallback=(t,r,n)=>{if(n==null){console.error("Failed to load data for:",r);return}let i=n.map(a=>({wall_time:new Date(a[0]*1e3),step:a[1],scalar:a[2]})),o=this._getSeriesNameFromDatum(r);t.setSeriesMetadata(o,r),t.setSeriesData(o,i)},this.getDataLoadUrl=({tag:t,run:r})=>_e().pluginRouteForSrc("scalars","/scalars",new URLSearchParams({tag:t,run:r})),this._downloadUrlFn=(t,r)=>this.getDataLoadUrl({tag:t,run:r}),this.requestData=(t,r,n)=>this.inColab?this._requestDataGet(t,r,n):this._requestDataPost(t,r,n),this._requestDataGet=(t,r,n)=>{let o=_e().pluginRoute("scalars","/scalars");Promise.all(t.map(a=>{let s=Mi(o,{tag:a.tag,run:a.run});return this.requestManager.request(s).then(l=>void r({item:a,data:l}))})).finally(()=>void n())},this._requestDataPost=(t,r,n)=>{var c;let o=_e().pluginRoute("scalars","/scalars_multirun"),a=new Map;for(let{tag:u,run:h}of t){let f=a.get(u);f==null&&a.set(u,f=[]),f.push(h)}let s=(c=this.batchSize)!=null?c:hhr,l=[];for(let[u,h]of a)for(let f=0;f<h.length;f+=s)l.push({tag:u,runs:h.slice(f,f+s)});Promise.all(l.map(({tag:u,runs:h})=>this.requestManager.request(o,{tag:u,runs:h}).then(f=>{for(let p of h){let d={tag:u,run:p};Object.prototype.hasOwnProperty.call(f,p)?r({item:d,data:f[p]}):r({item:d,data:null})}}))).finally(()=>void n())},this._getDataLoadName=t=>this._getSeriesNameFromDatum(t),this._expanded=!1,this._tooltipColumns=(()=>{let t=ist.slice(),r=t.findIndex(n=>n.title=="Name");return t.splice(r,1,{title:"Name",evaluate:n=>{let i=n.dataset.metadata().meta;return this._getSeriesDisplayNameFromDatum(i)}}),t})()}_getChartDataLoader(){var t;return(t=this.shadowRoot)==null?void 0:t.querySelector("tf-line-chart-data-loader")}reload(){this._getChartDataLoader().reload()}redraw(){this._getChartDataLoader().redraw()}_toggleExpanded(t){this.set("_expanded",!this._expanded),this.redraw()}_toggleLogScale(){this.set("_logScaleActive",!this._logScaleActive)}_resetDomain(){let t=this._getChartDataLoader();t&&t.resetDomain()}_updateDownloadLink(){var n;let t=this._getChartDataLoader().exportAsSvgString(),r=(n=this.shadowRoot)==null?void 0:n.querySelector("#svgLink");r.href=`data:image/svg+xml;base64,${btoa(t)}`}_runsFromData(t){return t.map(r=>r.run)}_getDataSeries(){return this.dataToLoad.map(t=>this._getSeriesNameFromDatum(t))}_getSeriesNameFromDatum({run:t,experiment:r={name:"_default"}}){return JSON.stringify([r.name,t])}_getSeriesDisplayNameFromDatum(t){return t.run}_getColorScale(){return this.colorScale!==null?this.colorScale:{scale:t=>{let[,r]=JSON.parse(t);return fn(r)}}}};Gn.template=Q`
    <tf-card-heading
      tag="[[tag]]"
      display-name="[[tagMetadata.displayName]]"
      description="[[tagMetadata.description]]"
    ></tf-card-heading>
    <div id="tf-line-chart-data-loader-container">
      <tf-line-chart-data-loader
        active="[[active]]"
        color-scale="[[_getColorScale(colorScale)]]"
        data-series="[[_getDataSeries(dataToLoad.*)]]"
        data-to-load="[[dataToLoad]]"
        get-data-load-name="[[_getDataLoadName]]"
        get-data-load-url="[[getDataLoadUrl]]"
        request-data="[[requestData]]"
        ignore-y-outliers="[[ignoreYOutliers]]"
        load-data-callback="[[_loadDataCallback]]"
        load-key="[[tag]]"
        log-scale-active="[[_logScaleActive]]"
        request-manager="[[requestManager]]"
        smoothing-enabled="[[smoothingEnabled]]"
        smoothing-weight="[[smoothingWeight]]"
        tag-metadata="[[tagMetadata]]"
        tooltip-columns="[[_tooltipColumns]]"
        tooltip-position="auto"
        tooltip-sorting-method="[[tooltipSortingMethod]]"
        x-type="[[xType]]"
      >
      </tf-line-chart-data-loader>
    </div>
    <div id="buttons">
      <paper-icon-button
        selected$="[[_expanded]]"
        icon="fullscreen"
        on-tap="_toggleExpanded"
      ></paper-icon-button>
      <paper-icon-button
        selected$="[[_logScaleActive]]"
        icon="line-weight"
        on-tap="_toggleLogScale"
        title="Toggle y-axis log scale"
      ></paper-icon-button>
      <paper-icon-button
        icon="settings-overscan"
        on-tap="_resetDomain"
        title="Fit domain to data"
      ></paper-icon-button>
      <template is="dom-if" if="[[showDownloadLinks]]">
        <paper-menu-button on-paper-dropdown-open="_updateDownloadLink">
          <paper-icon-button
            class="dropdown-trigger"
            slot="dropdown-trigger"
            icon="file-download"
          ></paper-icon-button>
          <paper-listbox class="dropdown-content" slot="dropdown-content">
            <paper-item>
              <a id="svgLink" download="[[tag]].svg">
                Download Current Chart as SVG
              </a>
            </paper-item>
          </paper-listbox>
        </paper-menu-button>
      </template>
      <span style="flex-grow: 1"></span>
      <template is="dom-if" if="[[showDownloadLinks]]">
        <div class="download-links">
          <tf-downloader
            runs="[[_runsFromData(dataToLoad)]]"
            tag="[[tag]]"
            url-fn="[[_downloadUrlFn]]"
          ></tf-downloader>
        </div>
      </template>
    </div>
    <style>
      :host {
        margin: 5px;
        display: block;
        width: 330px;
      }

      :host([_expanded]) {
        width: 100%;
      }

      :host([_expanded]) #tf-line-chart-data-loader-container {
        height: 400px;
      }

      #tf-line-chart-data-loader-container {
        height: 200px;
        width: 100%;
      }

      tf-card-heading {
        display: block;
        margin-bottom: 10px;
      }

      #buttons {
        display: flex;
        flex-direction: row;
      }

      paper-icon-button {
        color: #2196f3;
        border-radius: 100%;
        width: 32px;
        height: 32px;
        padding: 4px;
      }

      paper-icon-button[selected] {
        background: var(--tb-ui-light-accent);
      }

      .download-links {
        display: flex;
        height: 32px;
      }

      .download-links a {
        align-self: center;
        font-size: 10px;
        margin: 2px;
      }

      .download-links paper-dropdown-menu {
        width: 100px;
        --paper-input-container-label: {
          font-size: 10px;
        }
        --paper-input-container-input: {
          font-size: 10px;
        }
      }

      paper-menu-button {
        padding: 0;
      }
      paper-item a {
        color: inherit;
        text-decoration: none;
        white-space: nowrap;
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],Gn.prototype,"tag",void 0);E([A({type:Array}),w("design:type",Array)],Gn.prototype,"dataToLoad",void 0);E([A({type:String}),w("design:type",String)],Gn.prototype,"xType",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Gn.prototype,"active",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Gn.prototype,"ignoreYOutliers",void 0);E([A({type:Object}),w("design:type",Ae)],Gn.prototype,"requestManager",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Gn.prototype,"showDownLinks",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Gn.prototype,"smoothingEnabled",void 0);E([A({type:Number}),w("design:type",Number)],Gn.prototype,"smoothingWeight",void 0);E([A({type:Object}),w("design:type",Object)],Gn.prototype,"tagMetadata",void 0);E([A({type:Object}),w("design:type",Object)],Gn.prototype,"colorScale",void 0);E([A({type:String}),w("design:type",String)],Gn.prototype,"tooltipSortingMethod",void 0);E([A({type:Number}),w("design:type",Number)],Gn.prototype,"batchSize",void 0);E([A({type:Boolean}),w("design:type",Number)],Gn.prototype,"inColab",void 0);E([A({type:Object}),w("design:type",Object)],Gn.prototype,"_loadDataCallback",void 0);E([A({type:Object}),w("design:type",Function)],Gn.prototype,"getDataLoadUrl",void 0);E([A({type:Object}),w("design:type",Object)],Gn.prototype,"_downloadUrlFn",void 0);E([A({type:Object}),w("design:type",Function)],Gn.prototype,"requestData",void 0);E([A({type:Object}),w("design:type",Object)],Gn.prototype,"_getDataLoadName",void 0);E([A({type:Boolean,reflectToAttribute:!0}),w("design:type",Boolean)],Gn.prototype,"_expanded",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Gn.prototype,"_logScaleActive",void 0);E([A({type:Array}),w("design:type",Array)],Gn.prototype,"_tooltipColumns",void 0);Gn=E([yt("tf-scalar-card")],Gn);var Vs=class extends fue([cW],mt){constructor(){super(...arguments),this.sessionGroup=null,this._xType=Ed.STEP,this._noMultiExperiments=!1,this._requestData=(t,r,n)=>{Promise.all(t.map(i=>{let o={experimentName:this.experimentName,sessionName:i.run,metricName:i.tag};return this.backend.listMetricEvals(o).then(a=>void r({item:i,data:a}))})).finally(()=>void n())},this._colorScale={scale:t=>{let r=JSON.parse(t)[1],n=this._indexOfSession.get(r),i=iR;return i[(this._sessionGroupNameHash+n)%i.length]}}}connectedCallback(){super.connectedCallback(),this.addEventListener("iron-resize",this.redraw.bind(this))}redraw(){var t;(t=this.shadowRoot)==null||t.querySelectorAll("tf-scalar-card").forEach(r=>{r.redraw()})}_sessionGroupChanged(){var t;!this.sessionGroup||Object.keys(this.sessionGroup).length==0?(this._indexOfSession=new Map,this._sessionGroupNameHash=0):(this._indexOfSession=new Map(this.sessionGroup.sessions.map((r,n)=>[r.name,n])),this._sessionGroupNameHash=dct(this.sessionGroup.name)),(t=this.shadowRoot)==null||t.querySelectorAll("tf-scalar-card").forEach(r=>{let n=r,i=n.get("tag");n.set("tag",""),n.set("tag",i)})}_haveMetrics(){return this.visibleSchema&&Array.isArray(this.visibleSchema.metricInfos)&&this.visibleSchema.metricInfos.length>0}_haveMetricsAndSessionGroup(){return this.sessionGroup&&this._haveMetrics()}_computeSeriesForSessionGroupMetric(t,r){return t===null||Object.keys(t).length==0||r===null?[]:t.sessions.filter(n=>f3(n.metricValues,r.name)!==void 0).map(n=>({tag:r.name,run:n.name}))}_computeTagMetadata(t){return{displayName:Qu(t),description:t.description||""}}};Vs.template=Q`
    <template is="dom-if" if="[[!sessionGroup]]">
      <div>
        <h3>No session group selected</h3>
        <p>Please select a session group to see its metric-graphs here.</p>
      </div>
    </template>
    <template is="dom-if" if="[[!_haveMetrics(visibleSchema.*)]]">
      <div>
        <h3>No metrics are enabled</h3>
        <p>Please enable some metrics to see content here.</p>
      </div>
    </template>
    <div class="layout horizontal wrap session-group-details">
      <template
        is="dom-if"
        if="[[_haveMetricsAndSessionGroup(visibleSchema.*, sessionGroup)]]"
      >
        <template
          is="dom-repeat"
          items="[[visibleSchema.metricInfos]]"
          as="metricInfo"
        >
          <!-- Note that we do not provide a request-manager attribute since
               we provide a function in request-data for calling the backend
               to get the metrics data.
            -->
          <tf-scalar-card
            class="scalar-card"
            color-scale="[[_colorScale]]"
            data-to-load="[[_computeSeriesForSessionGroupMetric(sessionGroup, metricInfo)]]"
            tag="[[metricInfo.name.tag]]"
            tag-metadata="[[_computeTagMetadata(metricInfo)]]"
            x-type="[[_xType]]"
            multi-experiments="[[_noMultiExperiments]]"
            request-data="[[_requestData]]"
            active
          >
          </tf-scalar-card>
        </template>
      </template>
    </div>
    <!-- "iron-flex" is needed to use the layout classes in the div above -->
    <style include="iron-flex">
      :host {
        display: block;
      }
    </style>
  `;E([A({type:Object}),w("design:type",Object)],Vs.prototype,"backend",void 0);E([A({type:String}),w("design:type",String)],Vs.prototype,"experimentName",void 0);E([A({type:Object}),w("design:type",Object)],Vs.prototype,"visibleSchema",void 0);E([A({type:Object}),w("design:type",Object)],Vs.prototype,"sessionGroup",void 0);E([A({type:String}),w("design:type",String)],Vs.prototype,"_xType",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Vs.prototype,"_noMultiExperiments",void 0);E([A({type:Object}),w("design:type",Object)],Vs.prototype,"_indexOfSession",void 0);E([A({type:Number}),w("design:type",Number)],Vs.prototype,"_sessionGroupNameHash",void 0);E([A({type:Object}),w("design:type",Function)],Vs.prototype,"_requestData",void 0);E([A({type:Object}),w("design:type",Object)],Vs.prototype,"_colorScale",void 0);E([Bt("sessionGroup.*"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Vs.prototype,"_sessionGroupChanged",null);Vs=E([yt("tf-hparams-session-group-details")],Vs);var Hd=class extends Gt(_o(mt)){constructor(){super(...arguments),this._hparamName=Fd,this._metricName=Qu}_visibleSchemaOrSessionGroupsChanged(){let t=this.$.sessionGroupsTable.get("detailsOpenedItems");this.$.sessionGroupsTable.set("detailsOpenedItems",[]),ci();let r=new Map;this.sessionGroups.forEach(n=>{r.set(n.name,n)}),this.$.sessionGroupsTable.set("detailsOpenedItems",t.map(n=>r.get(n.name)).filter(Boolean))}_sessionGroupHParam(t,r){return t==null||Object.keys(t).length==0||!Object.prototype.hasOwnProperty.call(t.hparams,r)?"":b0(t.hparams[r])}_sessionGroupMetric(t,r){if(t==null||Object.keys(t).length==0)return"";for(let n=0;n<t.metricValues.length;++n){let i=t.metricValues[n];if(i.name.group===r.group&&i.name.tag==r.tag)return b0(i.value)}return""}_rowNumber(t){return t+1}};Hd.template=Q`
    <vaadin-grid
      class="session-group-table"
      id="sessionGroupsTable"
      column-reordering-allowed=""
      items="[[sessionGroups]]"
    >
      <vaadin-grid-column flex-grow="0" width="10em" resizable="">
        <template class="header">
          <div class="table-header table-cell">Trial ID</div>
        </template>
        <template>
          <div class="table-cell">[[item.name]]</div>
        </template>
      </vaadin-grid-column>
      <template is="dom-if" if="[[enableShowMetrics]]">
        <vaadin-grid-column flex-grow="0" autoWidth="" resizable="">
          <template class="header">
            <div class="table-header table-cell">Show Metrics</div>
          </template>
          <template>
            <paper-checkbox class="table-cell" checked="{{detailsOpened}}">
            </paper-checkbox>
          </template>
        </vaadin-grid-column>
      </template>
      <template
        is="dom-repeat"
        items="[[visibleSchema.hparamInfos]]"
        as="hparamInfo"
        index-as="hparamIndex"
      >
        <vaadin-grid-column flex-grow="2" width="10em" resizable="">
          <template class="header">
            <div class="table-header table-cell">
              [[_hparamName(hparamInfo)]]
            </div>
          </template>
          <template>
            <div class="table-cell">
              [[_sessionGroupHParam(item, hparamInfo.name)]]
            </div>
          </template>
        </vaadin-grid-column>
      </template>
      <template
        is="dom-repeat"
        items="{{visibleSchema.metricInfos}}"
        as="metricInfo"
        index-as="metricIndex"
      >
        <vaadin-grid-column flex-grow="2" width="10em" resizable="">
          <template class="header">
            <div class="table-header table-cell">
              [[_metricName(metricInfo)]]
            </div>
          </template>
          <template>
            <div class="table-cell">
              [[_sessionGroupMetric(item, metricInfo.name)]]
            </div>
          </template>
        </vaadin-grid-column>
      </template>
      <template class="row-details">
        <tf-hparams-session-group-details
          backend="[[backend]]"
          experiment-name="[[experimentName]]"
          session-group="[[item]]"
          visible-schema="[[visibleSchema]]"
          class="session-group-details"
        >
        </tf-hparams-session-group-details>
      </template>
    </vaadin-grid>

    <style>
      :host {
        display: inline;
      }

      :host(.dark-mode) {
        --lumo-base-color: #303030;
        --lumo-body-text-color: #fff;
      }

      :host(.dark-mode) vaadin-grid {
        --_lumo-grid-secondary-border-color: #505050;
      }

      .table-cell {
        white-space: nowrap;
        text-overflow: ellipsis;
        overflow: hidden;
      }
      .table-header {
        /* line-break overflowing column headers */
        white-space: normal;
        overflow-wrap: break-word;
      }
      .session-group-table {
        height: 100%;
      }
      .session-group-details {
        height: 360px;
        overflow-y: auto;
      }
    </style>
  `;E([A({type:Object}),w("design:type",Object)],Hd.prototype,"visibleSchema",void 0);E([A({type:Array}),w("design:type",Array)],Hd.prototype,"sessionGroups",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Hd.prototype,"enableShowMetrics",void 0);E([A({type:Object}),w("design:type",Object)],Hd.prototype,"backend",void 0);E([A({type:String}),w("design:type",String)],Hd.prototype,"experimentName",void 0);E([Bt("visibleSchema.*","sessionGroups.*"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Hd.prototype,"_visibleSchemaOrSessionGroupsChanged",null);Hd=E([yt("tf-hparams-table-view")],Hd);var CP=class extends mt{constructor(){super(...arguments),this.sessionGroup=null,this.visibleSchema=null}_propertiesArePopulated(t,r){return t!=null&&r!==void 0&&r!==null}_singletonSessionGroups(t){return t==null?[]:[t]}};CP.template=Q`
    <!-- If sessionGroup or visibleSchema are not populated, do not display
         anything.
      -->
    <template
      is="dom-if"
      if="[[_propertiesArePopulated(visibleSchema, sessionGroup)]]"
    >
      <!-- Display one row without a "show-metrics" column -->
      <tf-hparams-table-view
        visible-schema="[[visibleSchema]]"
        session-groups="[[_singletonSessionGroups(sessionGroup)]]"
      >
      </tf-hparams-table-view>
    </template>
    <template
      is="dom-if"
      if="[[!_propertiesArePopulated(visibleSchema, sessionGroup)]]"
    >
      <div>Click or hover over a session group to display its values here.</div>
    </template>

    <style>
      :host {
        display: block;
      }
    </style>
  `;E([A({type:Object}),w("design:type",Object)],CP.prototype,"sessionGroup",void 0);E([A({type:Object}),w("design:type",Object)],CP.prototype,"visibleSchema",void 0);CP=E([yt("tf-hparams-session-group-values")],CP);var AP=Ee(Oe(),1);function pue(e,t,r,n){if(t.length<2)return console.error("Less than two axes in parallel coordinates plot."),null;let i=r[0],o=r[1];if(i<=t[0]||i>=t[t.length-1])return null;let a=AP.sortedIndex(t,i);console.assert(a>0),console.assert(a<t.length);let s=a-1;function l(h,f,p,d){let g=h-p,_=f-d,y=i-p,x=o-d,b=(g*y+_*x)/(g*g+_*_);if(b<=0)return p3(y,x);if(b>=1){let S=h-i,C=f-o;return p3(S,C)}return p3(y-b*g,x-b*_)}let c=null,u=null;return e.forEach(h=>{let f=l(h.controlPoints[s][0],h.controlPoints[s][1],h.controlPoints[a][0],h.controlPoints[a][1]);f>n||(c===null||f<c)&&(c=f,u=h)}),u}function due(e,t,r){return e.domain().filter(n=>{let i=e(n);return t<=i&&i<=r})}function mue(e,t,r){let n=e.range(),i=n.filter(o=>t<=o&&o<=r).map(o=>{let a=e.invertExtent(o);return o===n[n.length-1]?[a[0],a[1]+1]:a});return i.length==0?[0,0]:aa(Im(i))}function gue(e,t,r){return[e.invert(t),e.invert(r)].sort((n,i)=>n-i)}function Fct(e,t,r){function n(){if(e.length===0)return[1,2];let[i,o]=aa(e);return i!==o?[i,o]:i>0?[i*.5,i*1.5]:i<0?[i*1.5,i*.5]:[-1,1]}if(r==="LINEAR")return On().domain(n()).range([t,0]);if(r==="LOG"){let i=n();return i[0]<=0&&i[1]>=0?Fct(e,t,"LINEAR"):cc().domain(i).range([t,0])}else if(r==="QUANTILE"){let o=Ir(20).map(a=>t-a*t/19);return e.length===0&&(e=[1]),eg().domain(AP.uniq(e)).range(o)}else{if(r==="NON_NUMERIC")return tg().domain(AP.uniq(e.sort())).range([t,0]).padding(.1);throw RangeError("Unknown scale: "+r)}}var u1;(function(e){e.LINEAR="LINEAR",e.LOG="LOG",e.QUANTILE="QUANTILE",e.NON_NUMERIC="NON_NUMERIC"})(u1||(u1={}));var PP=class{isPassing(t){return!0}},nV=class{constructor(t,r,n,i){this._lower=t,this._upper=r,this._lowerOpen=n,this._upperOpen=i}isPassing(t){let r=t;return this._before(this._lower,r,!this._lowerOpen)&&this._before(r,this._upper,!this._upperOpen)}_before(t,r,n){return n?t<=r:t<r}},Hct=class{constructor(t){this._domainSet=t}isPassing(t){return this._domainSet.findIndex(r=>r===t)!==-1}},Vct=class{constructor(t,r,n,i){this._svgProps=t,this._schema=r,this._interactionManager=n,this._colIndex=i,this._isDisplayed=!1,this._yScale=null,this._scaleType=null,this.setBrushSelection(null)}colIndex(){return this._colIndex}yScale(){return this._yScale}scaleType(){return this._scaleType}brushSelection(){return this._brushSelection}isDisplayed(){return this._isDisplayed}setBrushSelection(t){this._brushSelection=t,this._brushFilter=this._buildBrushFilter(this.brushSelection(),this.scaleType(),this.yScale())}setDomainAndScale(t,r){this._scaleType=r,this._yScale=Fct(t.slice(),this._svgProps.height,this.scaleType()),this._brushFilter=this._buildBrushFilter(this.brushSelection(),this.scaleType(),this.yScale())}brushFilter(){return this._brushFilter}updateDOM(t){let r=lb(this.yScale());this.scaleType()===u1.QUANTILE&&(r=r.tickValues(this.yScale().quantiles()).tickFormat(xn("-.6g")));let n=Ht(t);n.selectAll("g").remove(),n.append("g").classed("axis",!0).call(r).append("text").classed("axis-title",!0).style("cursor","move").style("text-anchor","middle").attr("y",-9).text(a=>cct(this._schema,a)),n.call(pb().on("start",()=>{t.setAttribute("is-dragging",""),this._interactionManager.onDragStart(this.colIndex())}).on("drag",()=>this._interactionManager.onDrag(qt.x)).on("end",()=>{this._interactionManager.onDragEnd(),t.removeAttribute("is-dragging")}));let i=qL().extent([[-8,0],[8,this._svgProps.height+1]]).on("start",()=>{!Bct(qt)||(t.setAttribute("is-brushing",""),this._interactionManager.onBrushChanged(this.colIndex(),qt.selection))}).on("brush",()=>{!Bct(qt)||this._interactionManager.onBrushChanged(this.colIndex(),qt.selection)}).on("end",()=>{!Bct(qt)||(this._interactionManager.onBrushChanged(this.colIndex(),qt.selection),t.removeAttribute("is-brushing"))}),o=Ht(t).append("g").classed("brush",!0);o.call(i),i.move(o,this.brushSelection())}setDisplayed(t){this._isDisplayed=t}_buildBrushFilter(t,r,n){if(t===null)return new PP;if(r===null)return console.error("Scale type is null, but brushSelection isn't: ",t),new PP;switch(r){case u1.LINEAR:case u1.LOG:{let[i,o]=gue(n,t[0],t[1]);return new nV(i,o,!1,!1)}case u1.QUANTILE:{let[i,o]=mue(n,t[0],t[1]);return new nV(i,o,!1,!0)}case u1.NON_NUMERIC:return new Hct(due(n,t[0],t[1]))}return console.error("Unknown scale type: ",r),new PP}},iV=class{constructor(t,r,n){this._svgProps=t,this._schema=r,this._axes=this._createAxes(n),this._stationaryAxesPositions=tg().range([1,this._svgProps.width-1]).padding(.5),this._draggedAxis=null,this._svgProps.svgG.selectAll("g.axis-parent").remove(),this._parentsSel=this._svgProps.svgG.selectAll(".axis-parent")}updateAxes(t,r){console.assert(!this.isAxisDragging());let n=new Set;t.columns.forEach(o=>{let a=o.absoluteIndex,s=this._axes[a];s.setDisplayed(!0);let l=r.map(c=>x0(this._schema,c,a));s.setDomainAndScale(l,o.scale),n.add(a)}),this._axes.forEach(o=>{n.has(o.colIndex())||o.setDisplayed(!1)}),this._updateStationaryAxesPositions(n),this._parentsSel=this._parentsSel.data(Array.from(n),o=>o),this._parentsSel.exit().remove(),this._parentsSel=this._parentsSel.enter().append("g").classed("axis-parent",!0).merge(this._parentsSel);let i=this;this._parentsSel.call(o=>this._updateAxesPositionsInDOM(o)).each(function(o){i._axes[o].updateDOM(this)})}mapVisibleAxes(t){return this._stationaryAxesPositions.domain().map(r=>t(this.getAxisPosition(r),this._axes[r]))}allVisibleAxesSatisfy(t){return this._stationaryAxesPositions.domain().every(r=>t(this.getAxisPosition(r),this._axes[r]))}getAxisForColIndex(t){return this._axes[t]}dragStart(t){console.assert(!this.isAxisDragging()),console.assert(this._axes[t].isDisplayed()),this._draggedAxis=this._axes[t],this._draggedAxisPosition=this._stationaryAxesPositions(t)}drag(t){t=Math.min(Math.max(t,0),this._svgProps.width),this._draggedAxisPosition=t;let r=this._stationaryAxesPositions.domain();r.sort((n,i)=>this.getAxisPosition(n)-this.getAxisPosition(i)),this._stationaryAxesPositions.domain(r),this._updateAxesPositionsInDOM(this._parentsSel)}dragEnd(t){console.assert(this.isAxisDragging()),this._draggedAxisPosition=null,this._draggedAxis=null,this._updateAxesPositionsInDOM(this._parentsSel.transition().duration(t))}isAxisDragging(){return this._draggedAxis!==null}getAxisPosition(t){return this._draggedAxis!==null&&this._draggedAxis.colIndex()===t?this._draggedAxisPosition:this._stationaryAxesPositions(t)}_updateStationaryAxesPositions(t){let r=this._stationaryAxesPositions.domain().filter(i=>t.has(i)),n=Array.from(new Set([...r,...Array.from(t)]));this._stationaryAxesPositions.domain(n)}_updateAxesPositionsInDOM(t){t.attr("transform",r=>yP(this.getAxisPosition(r)))}_createAxes(t){return Ir(uct(this._schema)).map(r=>new Vct(this._svgProps,this._schema,t,r))}};function Bct(e){return e.sourceEvent!==null}var jf;(function(e){e[e.FOREGROUND=0]="FOREGROUND",e[e.BACKGROUND=1]="BACKGROUND"})(jf||(jf={}));var th=class{constructor(t){t===void 0&&(t=Ep(null)),console.assert(t.size()<=1),this._sessionGroupSel=t}sessionGroup(){return this._sessionGroupSel.size()===1?this._sessionGroupSel.datum():null}isNull(){return this.sessionGroup()===null}selection(){return this._sessionGroupSel}equalsTo(t){var r,n;return this.isNull()?t.isNull():t.isNull()?!1:((r=t.sessionGroup())==null?void 0:r.name)==((n=this.sessionGroup())==null?void 0:n.name)}},oV=class{constructor(t,r,n){this._svgProps=t,this._schema=r,this._axesCollection=n,this._sessionGroups=[],this._svgProps.svgG.selectAll("g.background").remove(),this._svgProps.svgG.selectAll("g.foreground").remove(),this._bgPathsSel=this._svgProps.svgG.append("g").classed("background",!0).selectAll("path"),this._fgPathsSel=this._svgProps.svgG.append("g").classed("foreground",!0).selectAll("path"),this._updateVisibleFgPathsSel(),this._peakedSessionGroupHandle=new th,this._selectedSessionGroupHandle=new th,this._d3line=vu().curve(Yh)}getSessionGroupHandle(t){return t==null?new th:new th(this._fgPathsSel.filter(r=>r.name===t.name))}hideBackgroundLines(){this._bgPathsSel.attr("visibility","hidden")}showBackgroundLines(){this._bgPathsSel.attr("visibility",null)}peakedSessionGroupHandle(){return this._peakedSessionGroupHandle}selectedSessionGroupHandle(){return this._selectedSessionGroupHandle}recomputeControlPoints(t,r=0){(t===jf.FOREGROUND?this._fgPathsSel:this._bgPathsSel).transition().duration(r).attr("d",i=>this._pathDAttribute(i)),t===jf.FOREGROUND&&window.setTimeout(()=>{let i=this;this._fgPathsSel.each(function(o){i._setControlPointsProperty(this,o)})})}recomputeForegroundLinesVisibility(){this._fgPathsSel.classed("invisible-path",t=>!this._axesCollection.allVisibleAxesSatisfy((r,n)=>n.brushFilter().isPassing(x0(this._schema,t,n.colIndex())))),this._updateVisibleFgPathsSel()}setForegroundLinesColor(t,r,n){let i=this._createLineColorFunction(t,r,n);this._fgPathsSel.attr("stroke",i)}redraw(t,r,n,i){let o=this._peakedSessionGroupHandle.sessionGroup(),a=this._selectedSessionGroupHandle.sessionGroup();this._sessionGroups=t,this._fgPathsSel=this._recomputePathSelection(this._fgPathsSel),this._bgPathsSel=this._recomputePathSelection(this._bgPathsSel),this._peakedSessionGroupHandle=this.getSessionGroupHandle(o),this._selectedSessionGroupHandle=this.getSessionGroupHandle(a),this.recomputeControlPoints(jf.FOREGROUND),this.recomputeControlPoints(jf.BACKGROUND),this.recomputeForegroundLinesVisibility(),this.setForegroundLinesColor(r,n,i)}updatePeakedSessionGroup(t){this._peakedSessionGroupHandle.selection().classed("peaked-path",!1),this._peakedSessionGroupHandle=t,this._peakedSessionGroupHandle.selection().classed("peaked-path",!0)}clearPeakedSessionGroup(){this.updatePeakedSessionGroup(new th)}updateSelectedSessionGroup(t){this._selectedSessionGroupHandle.selection().classed("selected-path",!1),this._selectedSessionGroupHandle=t,this._selectedSessionGroupHandle.selection().classed("selected-path",!0)}findClosestSessionGroup(t,r){let n=this._axesCollection.mapVisibleAxes((o,a)=>o),i=pue(this._visibleFgPathsSel.nodes(),n,[t,r],100);return i===null?new th:new th(Ht(i))}_createLineColorFunction(t,r,n){if(t===null)return()=>"red";let i=On().domain(hct(this._schema,this._sessionGroups,t)).range([r,n]).interpolate(M_);return o=>i(x0(this._schema,o,t))}_recomputePathSelection(t){return t=t.data(this._sessionGroups,r=>r.name),t.exit().remove(),t.enter().append("path").merge(t)}_setControlPointsProperty(t,r){t.controlPoints=this._computeControlPoints(r)}_computeControlPoints(t){return this._axesCollection.mapVisibleAxes((r,n)=>[r,n.yScale()(x0(this._schema,t,n.colIndex()))])}_pathDAttribute(t){return this._d3line(this._computeControlPoints(t))}_updateVisibleFgPathsSel(){this._visibleFgPathsSel=this._fgPathsSel.filter(":not(.invisible-path)")}};var aV=class{constructor(t,r){this.svg=Ht(t);let n={top:30,right:10,bottom:10,left:10},i=100,o=200,a=r*i+n.left+n.right,s=o+n.top+n.bottom;this.svg.attr("viewBox",`0 0 ${a} ${s}`),this.svg.attr("preserveAspectRatio","xMidYMid"),this.svg.style("min-width",a+"px"),this.svg.style("min-height",s+"px"),this.width=a-n.left-n.right,this.height=s-n.top-n.bottom,this.svgG=this.svg.append("g").attr("transform",yP(n.left,n.top))}},sV=class{constructor(t,r,n,i){this._svgProps=t,this._schema=r,this._peakedSessionGroupChangedCB=n,this._selectedSessionGroupChangedCB=i,this._axesCollection=new iV(t,r,this),this._linesCollection=new oV(t,r,this._axesCollection),this._svgProps.svg.on("click",()=>this.onClick()).on("mousemove mouseenter",()=>{let[o,a]=zo(this._svgProps.svgG.node());this.onMouseMoved(o,a)}).on("mouseleave",()=>this.onMouseLeave())}onDragStart(t){this._axesCollection.dragStart(t),this._linesCollection.hideBackgroundLines()}onDrag(t){this._axesCollection.drag(t),this._linesCollection.recomputeControlPoints(jf.FOREGROUND)}onDragEnd(){this._axesCollection.dragEnd(500),this._linesCollection.recomputeControlPoints(jf.FOREGROUND,500),window.setTimeout(()=>{this._linesCollection.recomputeControlPoints(jf.BACKGROUND),this._linesCollection.showBackgroundLines()},500)}onBrushChanged(t,r){this._axesCollection.getAxisForColIndex(t).setBrushSelection(r),this._linesCollection.recomputeForegroundLinesVisibility()}onMouseMoved(t,r){this._linesCollection.updatePeakedSessionGroup(this._linesCollection.findClosestSessionGroup(t,r)),this._peakedSessionGroupChangedCB(this._linesCollection.peakedSessionGroupHandle().sessionGroup())}onMouseLeave(){this._linesCollection.peakedSessionGroupHandle().isNull()||(this._linesCollection.clearPeakedSessionGroup(),this._peakedSessionGroupChangedCB(null))}onClick(){this._linesCollection.peakedSessionGroupHandle().sessionGroup()===this._linesCollection.selectedSessionGroupHandle().sessionGroup()?this._linesCollection.updateSelectedSessionGroup(new th):this._linesCollection.updateSelectedSessionGroup(this._linesCollection.peakedSessionGroupHandle()),this._selectedSessionGroupChangedCB(this._linesCollection.selectedSessionGroupHandle().sessionGroup())}onOptionsOrSessionGroupsChanged(t,r){this._axesCollection.updateAxes(t,r);let n=this._linesCollection.peakedSessionGroupHandle(),i=this._linesCollection.selectedSessionGroupHandle();this._linesCollection.redraw(r,t.colorByColumnIndex!==void 0?t.columns[t.colorByColumnIndex].absoluteIndex:null,t.minColor,t.maxColor),n.equalsTo(this._linesCollection.peakedSessionGroupHandle())||this._peakedSessionGroupChangedCB(this._linesCollection.peakedSessionGroupHandle().sessionGroup()),i.equalsTo(this._linesCollection.selectedSessionGroupHandle())||this._selectedSessionGroupChangedCB(this._linesCollection.selectedSessionGroupHandle().sessionGroup())}schema(){return this._schema}};var eh=class extends Gt(_o(mt)){constructor(){super(...arguments),this.selectedSessionGroup=null,this.closestSessionGroup=null,this.redrawCount=0}_optionsOrSessionGroupsChanged(){var n;if(!this.options)return;let{configuration:t}=(n=this._prevOptions)!=null?n:{},{configuration:r}=this.options;if(this._interactionManager===void 0||!Uct.isEqual(t==null?void 0:t.schema,r.schema)||!Uct.isEqual(t==null?void 0:t.columnsVisibility,r.columnsVisibility)){Ht(this.$.svg).selectAll("*").remove();let i=new aV(this.$.svg,r.columnsVisibility.filter(Boolean).length);this.scopeSubtree(this.$.svg,!0),this._interactionManager=new sV(i,r.schema,o=>this.closestSessionGroupChanged(o),o=>this.selectedSessionGroupChanged(o))}this._computeValidSessionGroups(),this._interactionManager.onOptionsOrSessionGroupsChanged(this.options,this._validSessionGroups),this.redrawCount++,this._prevOptions=this.options}closestSessionGroupChanged(t){this.closestSessionGroup=t}selectedSessionGroupChanged(t){this.selectedSessionGroup=t}_computeValidSessionGroups(){let t=cs;if(this.sessionGroups===void 0){this._validSessionGroups=void 0;return}let r=this.options.configuration.schema;this._validSessionGroups=this.sessionGroups.filter(n=>{for(let i=0;i<t.numColumns(r);++i){if(!this.options.configuration.columnsVisibility[i])continue;let o=t.columnValueByIndex(r,n,i);if(o===void 0||o==="NaN")return!1}return!0})}};eh.template=Q`
    <div id="container">
      <svg id="svg"></svg>
    </div>
    <style>
      :host {
        display: block;
        --tf-hparams-parallel-coords-plot-axis-shadow: 0 1px 0 #fff,
          1px 0 0 #fff, 0 -1px 0 #fff, -1px 0 0 #fff;
      }
      :host(.dark-mode) {
        --tf-hparams-parallel-coords-plot-axis-shadow: 0 1px 0 #000,
          1px 0 0 #000, 0 -1px 0 #000, -1px 0 0 #000;
      }
      svg {
        font: 10px sans-serif;
      }

      .background path {
        fill: none;
        stroke: #ddd;
        shape-rendering: crispEdges;
      }

      .foreground path {
        fill: none;
        stroke-opacity: 0.7;
        stroke-width: 1;
      }

      /* Will be set on foreground paths that are not "contained" in the current
         axes brushes. If no brushes are set, no path will have this class. */
      .foreground .invisible-path {
        display: none;
      }

      /* Style for the path closest to the mouse pointer (typically will become
      the selected path when the user clicks). */
      .foreground .peaked-path {
        stroke-width: 3;
      }

      /* The currently selected path class. We use !important to override the
         inline style that sets the regular color of a path. */
      .foreground .selected-path {
        stroke-width: 3 !important;
        stroke: #0f0 !important;
      }

      #container {
        height: 100%;
        width: 100%;
      }

      svg {
        width: 100%;
        height: 100%;
      }

      .axis text {
        text-shadow: var(--tf-hparams-parallel-coords-plot-axis-shadow);
        fill: currentColor;
        cursor: move;
      }
    </style>
  `;E([A({type:Array}),w("design:type",Array)],eh.prototype,"sessionGroups",void 0);E([A({type:Object}),w("design:type",Object)],eh.prototype,"options",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],eh.prototype,"selectedSessionGroup",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],eh.prototype,"closestSessionGroup",void 0);E([A({type:Number}),w("design:type",Number)],eh.prototype,"redrawCount",void 0);E([A({type:Array}),w("design:type",Object)],eh.prototype,"_validSessionGroups",void 0);E([A({type:Object}),w("design:type",Object)],eh.prototype,"_interactionManager",void 0);E([Bt("options.*","sessionGroups.*"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],eh.prototype,"_optionsOrSessionGroupsChanged",null);eh=E([yt("tf-hparams-parallel-coords-plot")],eh);var A0=class extends mt{constructor(){super(...arguments),this.options=null}_configurationChanged(){let t=this.configuration.visibleSchema,r=this.configuration.schema,n=(a,s)=>({name:Fd(a),index:s,absoluteIndex:zH(r,t,s),scale:this._isNumericColumn(s)?"LINEAR":"NON_NUMERIC"}),i=(a,s)=>{let l=s+t.hparamInfos.length;return{scale:"LINEAR",name:Qu(a),index:l,absoluteIndex:zH(r,t,l)}},o={columns:t.hparamInfos.map(n).concat(t.metricInfos.map(i)),minColor:"#0000FF",maxColor:"#FF0000",configuration:this.configuration};this.set("options",o),ci(),this.set("options.colorByColumnIndex",this._defaultColorByColumnIndex())}_unselectDisabledLogScales(){this.options!==null&&this.options.columns.forEach(t=>{let r="options.columns."+t.index;!this._allowLogScale(t)&&t.scale==="LOG"&&this.set(r+".scale","LINEAR")})}_allowLogScale(t){if(!this._isNumericColumn(t.index)||!this.sessionGroups)return!1;let[r,n]=_P(this.configuration.visibleSchema,this.sessionGroups,t.index);return r>0||n<0}_isNumericColumn(t){return t>=this.configuration.visibleSchema.hparamInfos.length||this.configuration.visibleSchema.hparamInfos[t].type==="DATA_TYPE_FLOAT64"}_defaultColorByColumnIndex(){if(this.configuration.visibleSchema.metricInfos.length>0)return this.configuration.visibleSchema.hparamInfos.length;let t=this.configuration.visibleSchema.hparamInfos.findIndex(r=>r.type==="DATA_TYPE_FLOAT64");if(t!==-1)return t}};A0.template=Q`
    <div class="control-panel">
      <!-- 'Color by' drop down menu -->
      <paper-dropdown-menu
        label="Color by"
        id="colorByDropDownMenu"
        horizontal-align="left"
      >
        <paper-listbox
          class="dropdown-content"
          slot="dropdown-content"
          selected="{{options.colorByColumnIndex}}"
          id="colorByListBox"
        >
          <template
            is="dom-repeat"
            items="[[options.columns]]"
            as="column"
            id="colorByColumnTemplate"
          >
            <paper-item disabled="[[!_isNumericColumn(column.index)]]">
              [[column.name]]
            </paper-item>
          </template>
        </paper-listbox>
      </paper-dropdown-menu>

      <!-- Columns scales -->
      <div class="columns-container">
        <!-- Scale options for each numeric feature -->
        <template is="dom-repeat" items="{{options.columns}}" as="column">
          <template is="dom-if" if="[[_isNumericColumn(column.index)]]">
            <div class="column">
              <div class="column-title">[[column.name]]</div>
              <div>
                <paper-radio-group
                  class="scale-radio-group"
                  selected="{{column.scale}}"
                >
                  <paper-radio-button name="LINEAR">
                    Linear
                  </paper-radio-button>
                  <!-- The id here is used to access this button in unit
                       tests.-->
                  <paper-radio-button
                    id="logScaleButton_[[column.name]]"
                    name="LOG"
                    disabled="[[!_allowLogScale(column, sessionGroups.*)]]"
                  >
                    Logarithmic
                  </paper-radio-button>
                  <paper-radio-button name="QUANTILE">
                    Quantile
                  </paper-radio-button>
                </paper-radio-group>
              </div>
            </div>
          </template>
        </template>
      </div>
    </div>

    <style>
      :host {
        display: block;
      }
      .control-panel {
        overflow: auto;
      }
      .column {
        flex-grow: 1;
        flex-shrink: 1;
        margin-right: 5px;
        border: solid 1px darkgray;
        padding: 3px;
      }
      .column-title {
        /* Fit every title in one line so the radio boxes align vertically. */
        white-space: nowrap;
        text-decoration: underline;
      }
      .columns-container {
        display: flex;
        flex-direction: row;
      }
      .scale-radio-group paper-radio-button {
        padding: 2px;
        display: block;
      }
      paper-listbox {
        max-height: 15em;
      }
    </style>
  `;E([A({type:Object}),w("design:type",Object)],A0.prototype,"configuration",void 0);E([A({type:Array}),w("design:type",Array)],A0.prototype,"sessionGroups",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],A0.prototype,"options",void 0);E([Bt("configuration.*"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],A0.prototype,"_configurationChanged",null);E([Bt("sessionGroups.*"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],A0.prototype,"_unselectDisabledLogScales",null);A0=E([yt("tf-hparams-scale-and-color-controls")],A0);var h1=class extends mt{_closestOrSelected(t,r){return t!==null?t:r}};h1.template=Q`
    <!-- Controls behavior of parallel coordinates plot
         outputs set options to the _options property.
      -->
    <hparams-split-layout orientation="vertical">
      <!-- The scale and color controls. -->
      <tf-hparams-scale-and-color-controls
        id="controls"
        slot="content"
        class="section"
        configuration="[[configuration]]"
        session-groups="[[sessionGroups]]"
        options="{{_options}}"
      >
      </tf-hparams-scale-and-color-controls>
      <!-- The actual parallel coordinates plot -->
      <tf-hparams-parallel-coords-plot
        id="plot"
        slot="content"
        class="section"
        session-groups="[[sessionGroups]]"
        selected-session-group="{{_selectedGroup}}"
        closest-session-group="{{_closestGroup}}"
        options="[[_options]]"
      >
      </tf-hparams-parallel-coords-plot>
      <tf-hparams-session-group-values
        id="values"
        slot="content"
        class="section"
        visible-schema="[[configuration.visibleSchema]]"
        session-group="[[_closestOrSelected(
                             _closestGroup, _selectedGroup)]]"
      >
      </tf-hparams-session-group-values>
      <tf-hparams-session-group-details
        id="details"
        slot="content"
        class="section"
        backend="[[backend]]"
        experiment-name="[[experimentName]]"
        session-group="[[_selectedGroup]]"
        visible-schema="[[configuration.visibleSchema]]"
      >
      </tf-hparams-session-group-details>
    </hparams-split-layout>

    <style>
      .section {
        padding: 10px;
      }
      #values {
        height: 115px;
      }
      #details {
        flex-grow: 1;
        max-height: fit-content;
      }
    </style>
  `;E([A({type:Object}),w("design:type",Object)],h1.prototype,"backend",void 0);E([A({type:String}),w("design:type",String)],h1.prototype,"experimentName",void 0);E([A({type:Object}),w("design:type",Object)],h1.prototype,"configuration",void 0);E([A({type:Array}),w("design:type",Array)],h1.prototype,"sessionGroups",void 0);h1=E([yt("tf-hparams-parallel-coords-view")],h1);var y3=Ee(Oe(),1);var $o=class extends Gt(mt){constructor(){super(...arguments),this.selectedSessionGroup=null,this.closestSessionGroup=null,this._container=null,this._svg=null,this.width=0,this.height=0,this._brushedCellIndex=null,this._brushSelection=null}ready(){super.ready(),this._container=this.$.container,this._svg=Ht(this.$.svg),this._redraw()}_sessionGroupsChanged(){this.selectedSessionGroup!==null&&(this.selectedSessionGroup=fct(this.sessionGroups,this.selectedSessionGroup.name)||null),this._redraw()}_visibleSchemaChanged(){this._brushedCellIndex=null,this._brushSelection=null,this._redraw()}_redraw(){this.debounce("_redraw",()=>{let t=cs,r=1200,n=.4*r,i=150,o=.75*i;this.width=Math.max(i*t.numVisibleColumns(this.visibleSchema),r),this.height=Math.max(o*t.numVisibleMetrics(this.visibleSchema),n),this._container.style.width=this.width+"px",this._container.style.height=this.height+"px",this._svg.attr("width",this.width).attr("height",this.height),this._svg.selectAll("g").remove(),this._draw()},100)}_draw(){let t=cs,r=this;if(!this.sessionGroups||this.sessionGroups.length==0||!this.visibleSchema||this.visibleSchema.metricInfos.length==0)return;let n=Ir(t.numVisibleColumns(r.visibleSchema)),i=Ir(t.numVisibleMetrics(r.visibleSchema)),o=80,a=50,s=5,l=Qm().domain(n).range([o+s,this.width-1-s]).paddingInner(.1),c=Qm().domain(i).range([this.height-1-s-a,s]).paddingInner(.1),u=l.bandwidth(),h=c.bandwidth(),f=n.map(ct=>r._cellScale(ct,[0,u-1])),p=i.map(ct=>r._cellScale(ct+t.numVisibleHParams(r.visibleSchema),[h-1,0])),d=this._svg.selectAll(".x-axis").data(n).enter().append("g").classed("x-axis",!0).attr("transform",ct=>t.translateStr(l(ct),0));function g(ct){return"x-axis-clip-path-"+ct}function _(ct){return"x-label-clip-path-"+ct}d.append("clipPath").attr("id",g).append("rect").attr("x",-s).attr("y",0).attr("width",u+2*s).attr("height",r.height-a/2),d.append("clipPath").attr("id",_).append("rect").attr("x",0).attr("y",r.height-a/2).attr("width",u).attr("height",a/2),d.append("g").attr("clip-path",ct=>"url(#"+g(ct)+")").each(function(ct){Ht(this).call(S,Z9(f[ct]).tickSize(r.height-a),u,40,r.options.columns[ct].scale)}),d.append("g").classed("x-axis-label",!0).attr("clip-path",ct=>"url(#"+_(ct)+")").append("text").attr("text-anchor","middle").attr("x",u/2).attr("y",r.height-1-a/4).text(ct=>t.schemaVisibleColumnName(r.visibleSchema,ct)).append("title").text(ct=>t.schemaVisibleColumnName(r.visibleSchema,ct));let y=this._svg.selectAll(".y-axis").data(i).enter().append("g").classed("y-axis",!0).attr("transform",ct=>t.translateStr(r.width-1,c(ct)));function x(ct){return"y-axis-clip-path-"+ct}function b(ct){return"y-label-clip-path-"+ct}y.append("clipPath").attr("id",x).append("rect").attr("x",-(r.width-o/2-1)).attr("y",-s).attr("width",r.width-o/2).attr("height",h+2*s),y.append("clipPath").attr("id",b).append("rect").attr("x",-(r.width-1)).attr("y",0).attr("width",o/2).attr("height",h),y.append("g").attr("clip-path",ct=>"url(#"+x(ct)+")").each(function(ct){Ht(this).call(S,lb(p[ct]).tickSize(r.width-o),h,20,r.options.columns[ct+t.numVisibleHParams(r.visibleSchema)].scale)}),y.append("g").classed("y-axis-label",!0).attr("clip-path",ct=>"url(#"+b(ct)+")").append("text").attr("text-anchor","middle").attr("x",-(r.width-o/4-1)).attr("y",h/2).attr("transform",t.rotateStr(90,-(r.width-o/4-1),h/2)).text(ct=>t.metricName(r.visibleSchema.metricInfos[ct])).append("title").text(ct=>t.metricName(r.visibleSchema.metricInfos[ct]));function S(ct,X,et,dt,q){let pt=Math.floor(et/dt),ht=X.scale();if(q==="QUANTILE"){let wt=ht.quantiles(),kt=Math.ceil(wt.length/pt);wt=Ir(0,wt.length,kt).map(ie=>wt[ie]),X.tickValues(wt).tickFormat(xn("-.2g"))}(q==="LINEAR"||q==="LOG")&&X.ticks(pt),ct.call(X),ct.selectAll(".domain").remove(),ct.selectAll(".tick line").attr("stroke","#ddd")}let C=this._svg.selectAll(".cell").data(q9(n,i)).enter().append("g").classed("cell",!0).attr("transform",([ct,X])=>t.translateStr(l(ct),c(X))),P=C.append("g").classed("frame",!0).append("rect").attr("x",-s).attr("y",-s).attr("width",u+2*s).attr("height",h+2*s).attr("stroke","#000").attr("fill","none").attr("shape-rendering","crispEdges"),k=null;r.options.colorByColumnIndex!==void 0&&(k=On().domain(this._colExtent(this.options.colorByColumnIndex)).range([this.options.minColor,this.options.maxColor]).interpolate(M_));let O=r.options.colorByColumnIndex===void 0?()=>"red":({sessionGroup:ct})=>k(this._colValue(ct,r.options.colorByColumnIndex));function D(ct,X){return f[X](r._colValue(ct,X))}function B(ct,X){return p[X](r._metricValue(ct,X))}function I(ct,X){let et=ct.selectAll(".data-marker").data(([pt,ht])=>r.sessionGroups.filter(wt=>r._colValue(wt,pt)!==void 0&&r._metricValue(wt,ht)!==void 0).map(wt=>({col:pt,metric:ht,sessionGroup:wt,x:D(wt,pt),y:B(wt,ht),sessionGroupMarkers:null}))).enter().append("circle").classed("data-marker",!0).attr("cx",({x:pt})=>pt).attr("cy",({y:pt})=>pt).attr("r",2).attr("fill",X),dt=new Map;r.sessionGroups.forEach(pt=>{dt.set(pt,[])}),et.each(function(pt){var ht;(ht=dt.get(pt.sessionGroup))==null||ht.push(this)}),et.each(pt=>{let ht=dt.get(pt.sessionGroup);pt.sessionGroupMarkers=new Set(ht)});let q=n.map(pt=>i.map(ht=>et.filter(wt=>wt.col==pt&&wt.metric==ht)));return[et,q,dt]}let[L,R,F]=I(C.append("g"),O);function z(ct,X){let et=[];return R[ct][X].each(function(){et.push(this)}),zh().x(dt=>Ht(dt).datum().x).y(dt=>Ht(dt).datum().y).addAll(et)}let U=n.map(ct=>i.map(X=>z(ct,X))),W=null;bt()&&(W=C.filter(ct=>y3.isEqual(ct,r._brushedCellIndex)),console.assert(W.size()==1,W));let Z=new Set(L.nodes());rt();function rt(){let ct=new Set(L.nodes());Mt()||(ct=ot(r._brushedCellIndex,r._brushSelection)),Ep(Array.from(t.filterSet(ct,X=>!Z.has(X)))).attr("fill",O),Ep(Array.from(t.filterSet(Z,X=>!ct.has(X)))).attr("fill","#ddd"),Z=ct}function ot(ct,X){console.assert(ct!==null),console.assert(X!==null);let[et,dt]=ct,q=new Set;return t.quadTreeVisitPointsInRect(U[et][dt],X[0][0],X[0][1],X[1][0],X[1][1],pt=>{Ht(pt).datum().sessionGroupMarkers.forEach(wt=>{q.add(wt)})}),q}let st=GL().extent([[-s+1,-s+1],[u-1+s-1,h-1+s-1]]).on("start",function(){bt()&&W.node()!=this&&st.move(W,null),St(this)}).on("brush",function(){St(this)}).on("end",function(){St(this)});function St(ct){let X=UL(ct);!bt()&&X===null||bt()&&ct===W.node()&&y3.isEqual(X,r._brushSelection)||(r._brushSelection=X,X!==null?(W=Ht(ct),r._brushedCellIndex=W.datum()):(W=null,r._brushedCellIndex=null),rt())}function bt(){return r._brushedCellIndex!==null&&r._brushSelection!==null}function Mt(){return!bt()||r._brushSelection[0][0]===r._brushSelection[1][0]||r._brushSelection[0][1]===r._brushSelection[1][1]}C.call(st),bt()&&st.move(W,r._brushSelection);let lt=null,Kt=null;this.selectedSessionGroup!==null&&(Kt=Ep(F.get(this.selectedSessionGroup)).classed("selected-marker",!0)),C.on("click",function(){let ct=lt===Kt?null:lt;if(ct===Kt)return;Kt!==null&&Kt.classed("selected-marker",!1),Kt=ct,Kt!==null&&Kt.classed("selected-marker",!0);let X=Kt===null?null:Kt.datum().sessionGroup;r.selectedSessionGroup=X}).on("mousemove mouseenter",function([ct,X]){let[et,dt]=zo(this),q=_t(ct,X,et,dt,20);lt!==q&&(lt!==null&&lt.classed("closest-marker",!1),lt=q,lt!==null?(lt.classed("closest-marker",!0),r.closestSessionGroup=lt.datum().sessionGroup):r.closestSessionGroup=null)}).on("mouseleave",function([ct,X]){lt!==null&&(lt.classed("closest-marker",!1),lt=null,r.closestSessionGroup=null)});function _t(ct,X,et,dt,q){let pt=1/0,ht=null;return t.quadTreeVisitPointsInDisk(U[ct][X],et,dt,q,(wt,kt)=>{if(Z.has(wt)&&kt<pt){let ie=Ht(wt).datum();pt=kt,ht=ie.sessionGroup}}),ht===null?null:Ep(F.get(ht))}this._svg.selectAll("*").classed("tf-hparams-scatter-plot-matrix-plot",!0)}_cellScale(t,r){let n=this._colExtent(t),i=On().domain(n).range(r);if(this.options.columns[t].scale==="LINEAR")return i;if(this.options.columns[t].scale==="LOG")return n[0]<=0&&n[1]>=0?i:cc().domain(n).range(r);if(this.options.columns[t].scale==="QUANTILE"){let o=(r[1]-r[0])/19,a=Ir(20).map(s=>r[0]+o*s);return eg().domain(y3.uniq(this.sessionGroups.map(s=>this._colValue(s,t)))).range(a)}else{if(this.options.columns[t].scale==="NON_NUMERIC")return tg().domain(y3.uniq(this.sessionGroups.map(o=>this._colValue(o,t)).sort())).range(r).padding(.1);throw"Unknown scale for column: "+t+". options: "+this.options}}_colValue(t,r){return BH(this.visibleSchema,t,r)}_metricValue(t,r){return FH(this.visibleSchema,t,r)}_colExtent(t){return _P(this.visibleSchema,this.sessionGroups,t)}};$o.template=Q`
    <div id="container">
      <svg id="svg"></svg>
    </div>

    <style>
      :host {
        display: block;
      }
      svg {
        font: 10px sans-serif;
      }

      text {
        fill: currentColor;
      }

      .frame rect {
        stroke: currentColor;
      }

      /* The closest data point marker to the mouse pointer. We use !important
         to override the inline style that sets the regular style of a marker.
      */
      .closest-marker {
        r: 6 !important;
      }

      /* The currently selected data point marker. We use !important to
         override the inline style that sets the regular style of a marker. */
      .selected-marker {
        r: 6 !important;
        fill: #0f0 !important;
      }
    </style>
  `;E([A({type:Object}),w("design:type",Object)],$o.prototype,"visibleSchema",void 0);E([A({type:Array}),w("design:type",Array)],$o.prototype,"sessionGroups",void 0);E([A({type:Object}),w("design:type",Object)],$o.prototype,"options",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],$o.prototype,"selectedSessionGroup",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],$o.prototype,"closestSessionGroup",void 0);E([A({type:Object}),w("design:type",HTMLElement)],$o.prototype,"_container",void 0);E([A({type:Object}),w("design:type",Object)],$o.prototype,"_svg",void 0);E([A({type:Number}),w("design:type",Number)],$o.prototype,"width",void 0);E([A({type:Number}),w("design:type",Number)],$o.prototype,"height",void 0);E([A({type:Object}),w("design:type",Object)],$o.prototype,"_brushedCellIndex",void 0);E([A({type:Object}),w("design:type",Object)],$o.prototype,"_brushSelection",void 0);E([Bt("sessionGroups.*"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],$o.prototype,"_sessionGroupsChanged",null);E([Bt("visibleSchema.*"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],$o.prototype,"_visibleSchemaChanged",null);E([Bt("options.*"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],$o.prototype,"_redraw",null);$o=E([yt("tf-hparams-scatter-plot-matrix-plot")],$o);var f1=class extends mt{_closestOrSelected(t,r){return t!==null?t:r}};f1.template=Q`
    <hparams-split-layout orientation="vertical">
      <!-- Controls behavior of the scatter plot matrix
             outputs the configured options to the _options property. -->
      <tf-hparams-scale-and-color-controls
        slot="content"
        class="section"
        id="controls"
        configuration="[[configuration]]"
        session-groups="[[sessionGroups]]"
        options="{{_options}}"
      >
      </tf-hparams-scale-and-color-controls>
      <!-- The actual scatter plot matrix -->
      <tf-hparams-scatter-plot-matrix-plot
        slot="content"
        class="section"
        id="plot"
        visible-schema="[[configuration.visibleSchema]]"
        session-groups="[[sessionGroups]]"
        selected-session-group="{{_selectedGroup}}"
        closest-session-group="{{_closestGroup}}"
        options="[[_options]]"
      >
      </tf-hparams-scatter-plot-matrix-plot>
      <tf-hparams-session-group-values
        slot="content"
        class="section"
        id="values"
        visible-schema="[[configuration.visibleSchema]]"
        session-group="[[_closestOrSelected(
                                 _closestGroup, _selectedGroup)]]"
      >
      </tf-hparams-session-group-values>
      <!-- Shows session group details for the clicked marker. -->
      <tf-hparams-session-group-details
        slot="content"
        class="section"
        id="details"
        backend="[[backend]]"
        experiment-name="[[experimentName]]"
        session-group="[[_selectedGroup]]"
        visible-schema="[[configuration.visibleSchema]]"
      >
      </tf-hparams-session-group-details>
    </hparams-split-layout>
    <style>
      .section {
        padding: 10px;
      }
      #controls {
        flex-grow: 0;
        flex-shrink: 0;
        flex-basis: auto;
        height: auto;
        overflow-y: auto;
        max-height: fit-content;
      }
      #plot {
        flex-grow: 1;
        flex-shrink: 1;
        flex-basis: auto;
        height: auto;
        overflow-y: auto;
        max-height: fit-content;
      }
      #values {
        flex-grow: 0;
        flex-shrink: 0;
        flex-basis: auto;
        height: 115px;
        overflow-y: auto;
        max-height: fit-content;
      }
      #details {
        flex-grow: 0;
        flex-shrink: 1;
        flex-basis: auto;
        height: auto;
        overflow-y: auto;
        max-height: fit-content;
      }
      vaadin-split-layout {
        height: 100%;
      }
    </style>
  `;E([A({type:Object}),w("design:type",Object)],f1.prototype,"backend",void 0);E([A({type:String}),w("design:type",String)],f1.prototype,"experimentName",void 0);E([A({type:Object}),w("design:type",Object)],f1.prototype,"configuration",void 0);E([A({type:Array}),w("design:type",Array)],f1.prototype,"sessionGroups",void 0);f1=E([yt("tf-hparams-scatter-plot-matrix-view")],f1);var Xf=class extends mt{constructor(){super(),this._selectedTab=0,this._tableTabClicked=()=>{this.logAction("Tab Clicked","Table")},this._parallelCoordsTabClicked=()=>{this.logAction("Tab Clicked","Parallel Coords")},this._scatterPlotMatrixTabClicked=()=>{this.logAction("Tab Clicked","Scatter Plot Matrix")},this.logAction=(t,r)=>{let n=window.dataLayer||[];function i(){n.push(arguments)}i("event",t,{event_category:"HParams",event_label:r})},this.logAction("Plugin Load")}};Xf.template=Q`
    <paper-header-panel>
      <paper-toolbar slot="header" class="tab-bar">
        <paper-tabs selected="{{_selectedTab}}" slot="top">
          <!-- view-id can be used by integration tests to locate a tab.
               It should be the name of the root element implementing the view
               without the 'tf-hparams-' prefix. -->
          <paper-tab on-click="_tableTabClicked" view-id="table-view">
            TABLE VIEW
          </paper-tab>
          <paper-tab
            on-click="_parallelCoordsTabClicked"
            view-id="parallel-coords-view"
          >
            PARALLEL COORDINATES VIEW
          </paper-tab>
          <paper-tab
            on-click="_scatterPlotMatrixTabClicked"
            view-id="scatter-plot-matrix-view"
          >
            SCATTER PLOT MATRIX VIEW
          </paper-tab>
          <div class="help-and-feedback">
            <template is="dom-if" if="[[bugReportUrl]]">
              <a
                href$="[[bugReportUrl]]"
                target="_blank"
                rel="noopener noreferrer"
              >
                <paper-button
                  id="bug-report"
                  raised
                  title="Send a bug report or feature request"
                >
                  Bug Report / Feature Request
                </paper-button>
              </a>
            </template>
            <template is="dom-if" if="[[helpUrl]]">
              <a href$="[[helpUrl]]" target="_blank" rel="noopener noreferrer">
                <paper-icon-button
                  icon="help-outline"
                  title="View documentation"
                >
                </paper-icon-button>
              </a>
            </template>
          </div>
        </paper-tabs>
      </paper-toolbar>
      <iron-pages selected="[[_selectedTab]]" class="fit tab-view">
        <div id="0" class="tab">
          <tf-hparams-table-view
            backend="[[backend]]"
            experiment-name="[[experimentName]]"
            visible-schema="[[configuration.visibleSchema]]"
            session-groups="[[sessionGroups]]"
            enable-show-metrics
          >
          </tf-hparams-table-view>
        </div>
        <div id="1" class="tab">
          <tf-hparams-parallel-coords-view
            backend="[[backend]]"
            experiment-name="[[experimentName]]"
            configuration="[[configuration]]"
            session-groups="[[sessionGroups]]"
          >
          </tf-hparams-parallel-coords-view>
        </div>
        <div id="2" class="tab">
          <tf-hparams-scatter-plot-matrix-view
            backend="[[backend]]"
            experiment-name="[[experimentName]]"
            configuration="[[configuration]]"
            session-groups="[[sessionGroups]]"
          >
          </tf-hparams-scatter-plot-matrix-view>
        </div>
      </iron-pages>
    </paper-header-panel>

    <style>
      .tab-view {
        height: 100%;
      }
      .tab-bar {
        overflow-y: auto;
        color: white;
        background-color: var(
          --tb-toolbar-background-color,
          var(--tb-orange-strong)
        );
      }
      .tab {
        height: 100%;
      }
      paper-tabs {
        flex-grow: 1;
        width: 100%;
        height: 100%;
        --paper-tabs-selection-bar-color: white;
        --paper-tabs-content: {
          -webkit-font-smoothing: antialiased;
        }
      }
      tf-hparams-table-view {
        width: 100%;
        height: 100%;
      }
      .help-and-feedback {
        display: inline-flex; /* Ensure that icons stay aligned */
        justify-content: flex-end;
        align-items: center;
        text-align: right;
        color: white;
      }
      #bug-report {
        border: solid black;
        background: red;
        white-space: normal;
        word-break: break-words;
        font-size: 12px;
        max-width: 150px;
        text-align: left;
      }
      .help-and-feedback a {
        color: white;
        text-decoration: none;
      }
    </style>
  `;E([A({type:Object}),w("design:type",Object)],Xf.prototype,"backend",void 0);E([A({type:String}),w("design:type",String)],Xf.prototype,"helpUrl",void 0);E([A({type:String}),w("design:type",String)],Xf.prototype,"bugReportUrl",void 0);E([A({type:String}),w("design:type",String)],Xf.prototype,"experimentName",void 0);E([A({type:Object}),w("design:type",Object)],Xf.prototype,"configuration",void 0);E([A({type:Array}),w("design:type",Array)],Xf.prototype,"sessionGroups",void 0);E([A({type:Number}),w("design:type",Number)],Xf.prototype,"_selectedTab",void 0);Xf=E([yt("tf-hparams-sessions-pane"),w("design:paramtypes",[])],Xf);var rh=class extends Gt(mt){reload(){this.$["query-pane"].reload()}};rh.template=Q`
    <hparams-split-layout>
      <div slot="content" class="sidebar">
        <tf-hparams-query-pane
          id="query-pane"
          backend="[[backend]]"
          experiment-name="[[experimentName]]"
          configuration="{{_configuration}}"
          session-groups="{{_sessionGroups}}"
          data-loaded-with-non-empty-hparams="{{_dataLoadedWithNonEmptyHparams}}"
          data-loaded-with-empty-hparams="{{_dataLoadedWithEmptyHparams}}"
        >
        </tf-hparams-query-pane>
      </div>
      <div slot="content" class="center">
        <template is="dom-if" if="[[_dataLoadedWithEmptyHparams]]">
          <div class="no-data-warning">
            <h3>No hparams data was found.</h3>
            <p>Probable causes:</p>
            <ul>
              <li>You haven’t written any hparams data to your event files.</li>
              <li>
                Event files are still being loaded (try reloading this page).
              </li>
              <li>TensorBoard can’t find your event files.</li>
            </ul>

            <p>
              If you’re new to using TensorBoard, and want to find out how to
              add data and set up your event files, check out the
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
                >README</a
              >
              and perhaps the
              <a
                href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
                >TensorBoard tutorial</a
              >.
            </p>

            <p>
              If you think TensorBoard is configured properly, please see
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"
                >the section of the README devoted to missing data problems</a
              >
              and consider filing an issue on GitHub.
            </p>
          </div>
        </template>

        <template is="dom-if" if="[[_dataLoadedWithNonEmptyHparams]]">
          <tf-hparams-sessions-pane
            id="sessions-pane"
            backend="[[backend]]"
            help-url="[[helpUrl]]"
            bug-report-url="[[bugReportUrl]]"
            experiment-name="[[experimentName]]"
            configuration="[[_configuration]]"
            session-groups="[[_sessionGroups]]"
          >
          </tf-hparams-sessions-pane>
        </template>
      </div>
    </hparams-split-layout>
    <style>
      hparams-split-layout {
        width: 100%;
      }

      .sidebar {
        width: 20%;
        height: 100%;
        overflow: auto;
        flex-grow: 0;
        flex-shrink: 0;
        min-width: 10%;
      }

      .center {
        height: 100%;
        overflow-y: auto;
        flex-grow: 1;
        flex-shrink: 1;
        width: 80%;
      }

      :host {
        display: flex;
        flex-direction: row;
        height: 100%;
        width: 100%;
      }

      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }

      a {
        color: var(--tb-link);
      }

      a:visited {
        color: var(--tb-link-visited);
      }
    </style>
  `;E([A({type:Object}),w("design:type",u3)],rh.prototype,"backend",void 0);E([A({type:String}),w("design:type",String)],rh.prototype,"experimentName",void 0);E([A({type:String}),w("design:type",String)],rh.prototype,"helpUrl",void 0);E([A({type:String}),w("design:type",String)],rh.prototype,"bugReportUrl",void 0);E([A({type:Object}),w("design:type",Object)],rh.prototype,"_configuration",void 0);E([A({type:Array}),w("design:type",Array)],rh.prototype,"_sessionGroups",void 0);E([A({type:Boolean}),w("design:type",Boolean)],rh.prototype,"_dataLoadedWithNonEmptyHparams",void 0);E([A({type:Boolean}),w("design:type",Boolean)],rh.prototype,"_dataLoadedWithEmptyHparams",void 0);rh=E([yt("tf-hparams-main")],rh);var phr=new URLSearchParams(window.location.search).get("tensorboardColab")==="true",lV=class extends Gt(mt){constructor(){super(...arguments),this._backend=new u3(new Ae,phr)}reload(){this.$["hparams-main"].reload()}};lV.template=Q`
    <!-- TensorBoard does not specify an experimentName. Currently it only
         supports one experiment per invocation. -->
    <tf-hparams-main
      id="hparams-main"
      backend="[[_backend]]"
      experiment-name=""
    >
    </tf-hparams-main>
  `;E([A({type:Object}),w("design:type",Object)],lV.prototype,"_backend",void 0);lV=E([yt("tf-hparams-dashboard")],lV);var p1=Ee(Oe(),1);var _n=class extends Gt(mt){constructor(){super(...arguments),this.actualSize=!1,this.brightnessAdjustment=.5,this.contrastPercentage=0,this._metadataCanceller=new an,this._imageCanceller=new an,this._steps=[],this._isImageLoading=!1}get _runColor(){var t=this.run;return fn(t)}get _hasAtLeastOneStep(){var t=this._steps;return!!t&&t.length>0}get _hasMultipleSteps(){var t=this._steps;return!!t&&t.length>1}get _currentStep(){var t=this._steps,r=this._stepIndex;return t[r]||null}get _stepValue(){var t=this._currentStep;return t?t.step:0}get _currentWallTime(){var t=this._currentStep;return t?s2(t.wall_time):""}get _maxStepIndex(){var t=this._steps;return t.length-1}get _sampleText(){var t=this.sample;return`${t+1}`}get _hasMultipleSamples(){var t=this.ofSamples;return t>1}_getAriaExpanded(){return this.actualSize?"true":"false"}attached(){this.reload()}reload(){if(!this.isAttached)return;this._metadataCanceller.cancelAll();let t=new URLSearchParams({tag:this.tag,run:this.run,sample:this.sample}),r=_e().pluginRoute("images","/images",t),n=this._metadataCanceller.cancellable(i=>{if(i.cancelled)return;let a=i.value.map(this._createStepDatum.bind(this));this.set("_steps",a),this.set("_stepIndex",a.length-1)});this.requestManager.request(r).then(n)}_createStepDatum(t){let r=new URLSearchParams(t.query);r.append("ts",t.wall_time);let n=_e().pluginRouteForSrc("images","/individualImage",r);return{wall_time:new Date(t.wall_time*1e3),step:t.step,url:n}}_updateImageUrl(){var t=this._currentStep,r=this.brightnessAdjustment,n=this.contrastPercentage;if(!t)return;let i=new Image;this._imageCanceller.cancelAll(),i.onload=i.onerror=this._imageCanceller.cancellable(o=>{if(o.cancelled)return;let a=this.$$("#main-image-container");a&&(a.textContent="",zt(a).appendChild(i)),this.set("_isImageLoading",!1)}).bind(this),i.style.filter=`contrast(${n}%) `,i.style.filter+=`brightness(${r})`,this.set("_isImageLoading",!0),i.src=t.url}_handleTap(t){this.set("actualSize",!this.actualSize)}_toLocaleString(t){return t.toLocaleString()}};_n.template=Q`
    <tf-card-heading
      tag="[[tag]]"
      run="[[run]]"
      display-name="[[tagMetadata.displayName]]"
      description="[[tagMetadata.description]]"
      color="[[_runColor]]"
    >
      <template is="dom-if" if="[[_hasMultipleSamples]]">
        <div>sample: [[_sampleText]] of [[ofSamples]]</div>
      </template>
      <template is="dom-if" if="[[_hasAtLeastOneStep]]">
        <div class="heading-row">
          <div class="heading-label">
            step
            <span style="font-weight: bold"
              >[[_toLocaleString(_stepValue)]]</span
            >
          </div>
          <div class="heading-label heading-right datetime">
            <template is="dom-if" if="[[_currentWallTime]]">
              [[_currentWallTime]]
            </template>
          </div>
          <div class="label right">
            <paper-spinner-lite active hidden$="[[!_isImageLoading]]">
            </paper-spinner-lite>
          </div>
        </div>
      </template>
      <template is="dom-if" if="[[_hasMultipleSteps]]">
        <div>
          <paper-slider
            id="steps"
            immediate-value="{{_stepIndex}}"
            max="[[_maxStepIndex]]"
            max-markers="[[_maxStepIndex]]"
            snaps
            step="1"
            value="{{_stepIndex}}"
          ></paper-slider>
        </div>
      </template>
    </tf-card-heading>

    <!-- Semantically a button but <img> inside a <button> disallows user to do
    an interesting operation like "Copy Image" in non-Chromium browsers. -->
    <a
      id="main-image-container"
      role="button"
      aria-label="Toggle actual size"
      aria-expanded$="[[_getAriaExpanded(actualSize)]]"
      on-tap="_handleTap"
    ></a>

    <style include="tf-card-heading-style">
      /** Make button a div. */
      button {
        width: 100%;
        display: block;
        background: none;
        border: 0;
        padding: 0;
      }

      /** Firefox: Get rid of dotted line inside button. */
      button::-moz-focus-inner {
        border: 0;
        padding: 0;
      }

      /** Firefox: Simulate Chrome's outer glow on button when focused. */
      button:-moz-focusring {
        outline: none;
        box-shadow: 0px 0px 1px 2px Highlight;
      }

      :host {
        display: block;
        width: 350px;
        height: auto;
        position: relative;
        margin: 0 15px 40px 0;
        overflow-x: auto;
      }

      /** When actual size shown is on, use the actual image width. */
      :host([actual-size]) {
        max-width: 100%;
        width: auto;
      }

      :host([actual-size]) #main-image-container {
        max-height: none;
        width: auto;
      }

      :host([actual-size]) #main-image-container img {
        width: auto;
      }

      paper-spinner-lite {
        width: 14px;
        height: 14px;
        vertical-align: text-bottom;
        --paper-spinner-color: var(--tb-orange-strong);
      }

      #steps {
        height: 15px;
        margin: 0 0 0 -15px;
        /*
         * 31 comes from adding a padding of 15px from both sides of the
         * paper-slider, subtracting 1px so that the slider width aligns
         * with the image (the last slider marker takes up 1px), and
         * adding 2px to account for a border of 1px on both sides of
         * the image. 30 - 1 + 2.
         */
        width: calc(100% + 31px);
        --paper-slider-active-color: var(--tb-orange-strong);
        --paper-slider-knob-color: var(--tb-orange-strong);
        --paper-slider-knob-start-border-color: var(--tb-orange-strong);
        --paper-slider-knob-start-color: var(--tb-orange-strong);
        --paper-slider-markers-color: var(--tb-orange-strong);
        --paper-slider-pin-color: var(--tb-orange-strong);
        --paper-slider-pin-start-color: var(--tb-orange-strong);
      }

      #main-image-container {
        max-height: 1024px;
        overflow: auto;
      }

      #main-image-container img {
        cursor: pointer;
        display: block;
        image-rendering: -moz-crisp-edges;
        image-rendering: pixelated;
        width: 100%;
        height: auto;
      }

      paper-icon-button {
        color: #2196f3;
        border-radius: 100%;
        width: 32px;
        height: 32px;
        padding: 4px;
      }
      paper-icon-button[selected] {
        background: var(--tb-ui-light-accent);
      }
      [hidden] {
        display: none;
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],_n.prototype,"run",void 0);E([A({type:String}),w("design:type",String)],_n.prototype,"tag",void 0);E([A({type:Number}),w("design:type",Number)],_n.prototype,"sample",void 0);E([A({type:Number}),w("design:type",Number)],_n.prototype,"ofSamples",void 0);E([A({type:Object}),w("design:type",Object)],_n.prototype,"tagMetadata",void 0);E([A({type:Boolean,reflectToAttribute:!0}),w("design:type",Boolean)],_n.prototype,"actualSize",void 0);E([A({type:Number}),w("design:type",Number)],_n.prototype,"brightnessAdjustment",void 0);E([A({type:Number}),w("design:type",Number)],_n.prototype,"contrastPercentage",void 0);E([A({type:Object}),w("design:type",Ae)],_n.prototype,"requestManager",void 0);E([A({type:Object}),w("design:type",Object)],_n.prototype,"_metadataCanceller",void 0);E([A({type:Object}),w("design:type",Object)],_n.prototype,"_imageCanceller",void 0);E([A({type:Array,notify:!0}),w("design:type",Array)],_n.prototype,"_steps",void 0);E([A({type:Number,notify:!0}),w("design:type",Number)],_n.prototype,"_stepIndex",void 0);E([A({type:Boolean}),w("design:type",Boolean)],_n.prototype,"_isImageLoading",void 0);E([Rt("run"),w("design:type",String),w("design:paramtypes",[])],_n.prototype,"_runColor",null);E([Rt("_steps"),w("design:type",Boolean),w("design:paramtypes",[])],_n.prototype,"_hasAtLeastOneStep",null);E([Rt("_steps"),w("design:type",Boolean),w("design:paramtypes",[])],_n.prototype,"_hasMultipleSteps",null);E([Rt("_steps","_stepIndex"),w("design:type",Object),w("design:paramtypes",[])],_n.prototype,"_currentStep",null);E([Rt("_currentStep"),w("design:type",Number),w("design:paramtypes",[])],_n.prototype,"_stepValue",null);E([Rt("_currentStep"),w("design:type",String),w("design:paramtypes",[])],_n.prototype,"_currentWallTime",null);E([Rt("_steps"),w("design:type",Number),w("design:paramtypes",[])],_n.prototype,"_maxStepIndex",null);E([Rt("sample"),w("design:type",String),w("design:paramtypes",[])],_n.prototype,"_sampleText",null);E([Rt("ofSamples"),w("design:type",Boolean),w("design:paramtypes",[])],_n.prototype,"_hasMultipleSamples",null);E([Bt("run","tag"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],_n.prototype,"reload",null);E([Bt("_currentStep","brightnessAdjustment","contrastPercentage"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],_n.prototype,"_updateImageUrl",null);_n=E([yt("tf-image-loader")],_n);var Io=class extends Gt(mt){constructor(){super(...arguments),this.reloadOnReady=!0,this._defaultBrightnessAdjustment=1,this._defaultContrastPercentage=100,this._brightnessAdjustment=1,this._contrastPercentage=100,this._requestManager=new Ae}ready(){super.ready(),this.reloadOnReady&&this.reload()}reload(){this._fetchTags().then(()=>{this._reloadImages()})}_fetchTags(){let t=_e().pluginRoute("images","/tags");return this._requestManager.request(t).then(r=>{if(p1.isEqual(r,this._runToTagInfo))return;let n=p1.mapValues(r,o=>Object.keys(o)),i=$i(n);this.set("_dataNotFound",i.length===0),this.set("_runToTagInfo",r),this.async(()=>{this.set("_categoriesDomReady",!0)})})}_reloadImages(){var t;(t=this.root)==null||t.querySelectorAll("tf-image-loader").forEach(r=>{r.reload()})}_shouldOpen(t){return t<=2}_resetBrightness(){this._brightnessAdjustment=this._defaultBrightnessAdjustment}_resetContrast(){this._contrastPercentage=this._defaultContrastPercentage}get _brightnessIsDefault(){var t=this._brightnessAdjustment;return t===this._defaultBrightnessAdjustment}get _contrastIsDefault(){var t=this._contrastPercentage;return t===this._defaultContrastPercentage}get _categories(){var t=this._runToTagInfo,r=this._selectedRuns,n=this._tagFilter,i=this._categoriesDomReady;let o=p1.mapValues(t,c=>Object.keys(c)),a=Ql(o,r,n);function s(c){let u=t[c.run][c.tag].samples;return p1.range(u).map(h=>Object.assign({},c,{sample:h,ofSamples:u}))}return a.map(c=>Object.assign({},c,{items:[].concat.apply([],c.items.map(s))}))}_tagMetadata(t,r,n){return t[r][n]}};Io.template=Q`
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <div class="settings">
          <div class="sidebar-section">
            <div class="line-item">
              <paper-checkbox checked="{{_actualSize}}"
                >Show actual image size</paper-checkbox
              >
            </div>
          </div>
          <div class="sidebar-section">
            <h3 class="tooltip-container">Brightness adjustment</h3>
            <div class="resettable-slider-container">
              <paper-slider
                min="0"
                max="2"
                snaps
                pin
                step="0.01"
                value="{{_brightnessAdjustment}}"
                immediate-value="{{_brightnessAdjustment}}"
              ></paper-slider>
              <paper-button
                class="x-button"
                on-tap="_resetBrightness"
                disabled="[[_brightnessIsDefault]]"
                >Reset</paper-button
              >
            </div>
          </div>
          <div class="sidebar-section">
            <h3 class="tooltip-container">Contrast adjustment</h3>
            <div class="resettable-slider-container">
              <paper-slider
                min="0"
                max="500"
                snaps
                pin
                step="1"
                value="{{_contrastPercentage}}"
                immediate-value="{{_contrastPercentage}}"
              ></paper-slider>
              <paper-button
                class="x-button"
                on-tap="_resetContrast"
                disabled="[[_contrastIsDefault]]"
                >Reset</paper-button
              >
            </div>
          </div>
        </div>
        <div class="sidebar-section runs-selector">
          <tf-runs-selector
            id="runs-selector"
            selected-runs="{{_selectedRuns}}"
          ></tf-runs-selector>
        </div>
      </div>
      <div class="center" slot="center">
        <template is="dom-if" if="[[_dataNotFound]]">
          <div class="no-data-warning">
            <h3>No image data was found.</h3>
            <p>Probable causes:</p>
            <ul>
              <li>You haven’t written any image data to your event files.</li>
              <li>TensorBoard can’t find your event files.</li>
            </ul>

            <p>
              If you’re new to using TensorBoard, and want to find out how to
              add data and set up your event files, check out the
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
                >README</a
              >
              and perhaps the
              <a
                href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
                >TensorBoard tutorial</a
              >.
            </p>

            <p>
              If you think TensorBoard is configured properly, please see
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"
                >the section of the README devoted to missing data problems</a
              >
              and consider filing an issue on GitHub.
            </p>
          </div>
        </template>
        <template is="dom-if" if="[[!_dataNotFound]]">
          <tf-tag-filterer tag-filter="{{_tagFilter}}"></tf-tag-filterer>
          <template is="dom-repeat" items="[[_categories]]" as="category">
            <tf-category-paginated-view
              category="[[category]]"
              initial-opened="[[_shouldOpen(index)]]"
            >
              <template>
                <tf-image-loader
                  active="[[active]]"
                  run="[[item.run]]"
                  tag="[[item.tag]]"
                  sample="[[item.sample]]"
                  of-samples="[[item.ofSamples]]"
                  tag-metadata="[[_tagMetadata(_runToTagInfo, item.run, item.tag)]]"
                  request-manager="[[_requestManager]]"
                  actual-size="[[_actualSize]]"
                  brightness-adjustment="[[_brightnessAdjustment]]"
                  contrast-percentage="[[_contrastPercentage]]"
                ></tf-image-loader>
              </template>
            </tf-category-paginated-view>
          </template>
        </template>
      </div>
    </tf-dashboard-layout>
    <style include="dashboard-style"></style>
    <style>
      .resettable-slider-container {
        display: flex;
      }
      .resettable-slider-container paper-slider {
        flex-grow: 1;
      }
      .resettable-slider-container paper-button {
        flex-grow: 0;
      }
      .resettable-slider-container paper-button[disabled] {
        background-color: unset;
      }
      .x-button {
        font-size: 13px;
        background-color: var(--tb-ui-light-accent);
        color: var(--tb-ui-dark-accent);
      }
      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }
      paper-slider {
        --paper-slider-active-color: var(--tb-orange-strong);
        --paper-slider-knob-color: var(--tb-orange-strong);
        --paper-slider-knob-start-border-color: var(--tb-orange-strong);
        --paper-slider-knob-start-color: var(--tb-orange-strong);
        --paper-slider-markers-color: var(--tb-orange-strong);
        --paper-slider-pin-color: var(--tb-orange-strong);
        --paper-slider-pin-start-color: var(--tb-orange-strong);
      }
    </style>
  `;E([A({type:Boolean}),w("design:type",Boolean)],Io.prototype,"reloadOnReady",void 0);E([A({type:Array}),w("design:type",Array)],Io.prototype,"_selectedRuns",void 0);E([A({type:Object}),w("design:type",Object)],Io.prototype,"_runToTagInfo",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Io.prototype,"_dataNotFound",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Io.prototype,"_actualSize",void 0);E([A({type:Number}),w("design:type",Number)],Io.prototype,"_defaultBrightnessAdjustment",void 0);E([A({type:Number}),w("design:type",Number)],Io.prototype,"_defaultContrastPercentage",void 0);E([A({type:Number}),w("design:type",Number)],Io.prototype,"_brightnessAdjustment",void 0);E([A({type:Number}),w("design:type",Number)],Io.prototype,"_contrastPercentage",void 0);E([A({type:String}),w("design:type",String)],Io.prototype,"_tagFilter",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Io.prototype,"_categoriesDomReady",void 0);E([A({type:Object}),w("design:type",Object)],Io.prototype,"_requestManager",void 0);E([Rt("_brightnessAdjustment"),w("design:type",Boolean),w("design:paramtypes",[])],Io.prototype,"_brightnessIsDefault",null);E([Rt("_contrastPercentage"),w("design:type",Boolean),w("design:paramtypes",[])],Io.prototype,"_contrastIsDefault",null);E([Rt("_runToTagInfo","_selectedRuns","_tagFilter","_categoriesDomReady"),w("design:type",Array),w("design:paramtypes",[])],Io.prototype,"_categories",null);Io=E([yt("tf-image-dashboard")],Io);var sx=Ee(Oe(),1);var d1;(function(e){e[e.CANCELLED=1]="CANCELLED"})(d1||(d1={}));var cV;(function(e){e[e.VERTEX=1]="VERTEX",e[e.FACE=2]="FACE",e[e.COLOR=3]="COLOR"})(cV||(cV={}));var qct;(function(e){e.VERTEX="float32",e.FACE="int32",e.COLOR="uint8"})(qct||(qct={}));var IP=class{constructor(t){this._canceller=new an,this._requestManager=t}reload(t,r,n){return this._canceller.cancelAll(),this._fetchMetadata(t,r,n)}_fetchDataByStep(t,r,n,i,o,a){let s=_e().pluginRoute("mesh","/data",new URLSearchParams({tag:r,run:t,content_type:n,sample:String(i),step:String(o)})),l=function(u){let f=[];for(let p=0;p<u.length/3;p++){let d=[];for(let g=0;g<3;g++)d.push(u[p*3+g]);f.push(d)}return f},c=this._canceller.cancellable(u=>{if(u.cancelled)return Promise.reject({code:d1.CANCELLED,message:"Response was invalidated."});let h=u.value;switch(n){case"VERTEX":a.vertices=l(new Float32Array(h));break;case"FACE":a.faces=l(new Int32Array(h));break;case"COLOR":a.colors=l(new Uint8Array(h));break}return a});return this._requestManager.fetch(s,{method:"GET",headers:{responseType:"arraybuffer",contentType:qct[n]}}).then(u=>u.arrayBuffer()).then(c)}fetchData(t,r,n,i){let o=[],a=new Map;return Object.keys(cV).forEach(s=>{let l=1<<cV[s];t.components&l&&o.push(this._fetchDataByStep(r,n,s,i,t.step,a))}),Promise.all(o)}_fetchMetadata(t,r,n){this._canceller.cancelAll();let i=_e().pluginRoute("mesh","/meshes",new URLSearchParams({tag:r,run:t,sample:n})),o=this._canceller.cancellable(a=>a.cancelled?Promise.reject({code:d1.CANCELLED,message:"Response was invalidated."}):a.value);return this._requestManager.fetch(i).then(a=>a.json()).then(o).then(this._processMetadata.bind(this))}_processMetadata(t){if(!t)return;let r=new Map;for(let i=0;i<t.length;i++){let o=t[i];r.has(o.step)||r.set(o.step,[]),r.get(o.step).push(o)}let n=[];return r.forEach(i=>{let o=this._createStepDatum(i[0]);n.push(o)}),n}_createStepDatum(t){return{wall_time:new Date(t.wall_time*1e3),step:t.step,config:t.config,content_type:t.content_type,components:t.components}}};var wM={};Ks(wM,{ACESFilmicToneMapping:()=>pfe,AddEquation:()=>M1,AddOperation:()=>cfe,AdditiveAnimationBlendMode:()=>kht,AdditiveBlending:()=>Mut,AlphaFormat:()=>xfe,AlwaysDepth:()=>rfe,AlwaysStencilFunc:()=>Ofe,AmbientLight:()=>L6,AmbientLightProbe:()=>zU,AnimationClip:()=>Q1,AnimationLoader:()=>oht,AnimationMixer:()=>VU,AnimationObjectGroup:()=>HU,AnimationUtils:()=>Yn,ArcCurve:()=>l6,ArrayCamera:()=>n6,ArrowHelper:()=>Mht,Audio:()=>D6,AudioAnalyser:()=>FU,AudioContext:()=>zht,AudioListener:()=>cht,AudioLoader:()=>DU,AxesHelper:()=>vM,AxisHelper:()=>K0r,BackSide:()=>Ii,BasicDepthPacking:()=>Rfe,BasicShadowMap:()=>mhr,BinaryTextureLoader:()=>e_r,Bone:()=>sM,BooleanKeyframeTrack:()=>am,BoundingBoxHelper:()=>Z0r,Box2:()=>$0,Box3:()=>ta,Box3Helper:()=>wht,BoxBufferGeometry:()=>Qf,BoxGeometry:()=>Qf,BoxHelper:()=>yM,BufferAttribute:()=>Je,BufferGeometry:()=>Pe,BufferGeometryLoader:()=>RU,ByteType:()=>mfe,Cache:()=>tx,Camera:()=>R1,CameraHelper:()=>bht,CanvasRenderer:()=>n_r,CanvasTexture:()=>xU,CatmullRomCurve3:()=>c6,CineonToneMapping:()=>ffe,CircleBufferGeometry:()=>F1,CircleGeometry:()=>F1,ClampToEdgeWrapping:()=>Jo,Clock:()=>mM,Color:()=>ne,ColorKeyframeTrack:()=>M6,CompressedTexture:()=>a6,CompressedTextureLoader:()=>aht,ConeBufferGeometry:()=>B1,ConeGeometry:()=>B1,CubeCamera:()=>J3,CubeReflectionMapping:()=>nx,CubeRefractionMapping:()=>ix,CubeTexture:()=>H0,CubeTextureLoader:()=>TU,CubeUVReflectionMapping:()=>xM,CubeUVRefractionMapping:()=>z6,CubicBezierCurve:()=>cM,CubicBezierCurve3:()=>u6,CubicInterpolant:()=>SU,CullFaceBack:()=>Sut,CullFaceFront:()=>Vhe,CullFaceFrontBack:()=>dhr,CullFaceNone:()=>Hhe,Curve:()=>fs,CurvePath:()=>wU,CustomBlending:()=>qhe,CustomToneMapping:()=>dfe,CylinderBufferGeometry:()=>om,CylinderGeometry:()=>om,Cylindrical:()=>mht,DataTexture:()=>Jd,DataTexture2DArray:()=>tM,DataTexture3D:()=>r6,DataTextureLoader:()=>CU,DataUtils:()=>Tht,DecrementStencilOp:()=>Thr,DecrementWrapStencilOp:()=>Ahr,DefaultLoadingManager:()=>ipe,DepthFormat:()=>z0,DepthStencilFormat:()=>k1,DepthTexture:()=>nM,DirectionalLight:()=>I6,DirectionalLightHelper:()=>xht,DiscreteInterpolant:()=>MU,DodecahedronBufferGeometry:()=>H1,DodecahedronGeometry:()=>H1,DoubleSide:()=>L1,DstAlphaFactor:()=>Khe,DstColorFactor:()=>Jhe,DynamicBufferAttribute:()=>H0r,DynamicCopyUsage:()=>Uhr,DynamicDrawUsage:()=>Y3,DynamicReadUsage:()=>Bhr,EdgesGeometry:()=>s6,EdgesHelper:()=>J0r,EllipseCurve:()=>V1,EqualDepth:()=>ife,EqualStencilFunc:()=>khr,EquirectangularReflectionMapping:()=>YP,EquirectangularRefractionMapping:()=>jP,Euler:()=>tm,EventDispatcher:()=>Us,ExtrudeBufferGeometry:()=>hh,ExtrudeGeometry:()=>hh,FaceColors:()=>P0r,FileLoader:()=>Jc,FlatShading:()=>Aht,Float16BufferAttribute:()=>dU,Float32Attribute:()=>X0r,Float32BufferAttribute:()=>xe,Float64Attribute:()=>$0r,Float64BufferAttribute:()=>mU,FloatType:()=>jd,Fog:()=>z1,FogExp2:()=>O1,Font:()=>u_r,FontLoader:()=>c_r,FramebufferTexture:()=>vU,FrontSide:()=>I1,Frustum:()=>N1,GLBufferAttribute:()=>qU,GLSL1:()=>Ghr,GLSL3:()=>Kut,GreaterDepth:()=>afe,GreaterEqualDepth:()=>ofe,GreaterEqualStencilFunc:()=>Ohr,GreaterStencilFunc:()=>Nhr,GridHelper:()=>YU,Group:()=>Xd,HalfFloatType:()=>C1,HemisphereLight:()=>T6,HemisphereLightHelper:()=>yht,HemisphereLightProbe:()=>OU,IcosahedronBufferGeometry:()=>G1,IcosahedronGeometry:()=>G1,ImageBitmapLoader:()=>NU,ImageLoader:()=>ex,ImageUtils:()=>Kf,ImmediateRenderObject:()=>h_r,IncrementStencilOp:()=>Ehr,IncrementWrapStencilOp:()=>Chr,InstancedBufferAttribute:()=>rm,InstancedBufferGeometry:()=>N6,InstancedInterleavedBuffer:()=>UU,InstancedMesh:()=>i6,Int16Attribute:()=>G0r,Int16BufferAttribute:()=>fU,Int32Attribute:()=>Y0r,Int32BufferAttribute:()=>pU,Int8Attribute:()=>V0r,Int8BufferAttribute:()=>cU,IntType:()=>_fe,InterleavedBuffer:()=>em,InterleavedBufferAttribute:()=>tp,Interpolant:()=>fh,InterpolateDiscrete:()=>KP,InterpolateLinear:()=>ZP,InterpolateSmooth:()=>rU,InvertStencilOp:()=>Phr,JSONLoader:()=>i_r,KeepStencilOp:()=>nU,KeyframeTrack:()=>Dl,LOD:()=>_U,LatheBufferGeometry:()=>W1,LatheGeometry:()=>W1,Layers:()=>X3,LensFlare:()=>a_r,LessDepth:()=>nfe,LessEqualDepth:()=>iU,LessEqualStencilFunc:()=>Rhr,LessStencilFunc:()=>Lhr,Light:()=>Ol,LightProbe:()=>rx,Line:()=>ch,Line3:()=>GU,LineBasicMaterial:()=>Gi,LineCurve:()=>U1,LineCurve3:()=>bU,LineDashedMaterial:()=>w6,LineLoop:()=>o6,LinePieces:()=>C0r,LineSegments:()=>Aa,LineStrip:()=>T0r,LinearEncoding:()=>Qd,LinearFilter:()=>ii,LinearInterpolant:()=>S6,LinearMipMapLinearFilter:()=>xhr,LinearMipMapNearestFilter:()=>vhr,LinearMipmapLinearFilter:()=>ox,LinearMipmapNearestFilter:()=>Lht,LinearToneMapping:()=>ufe,Loader:()=>ea,LoaderUtils:()=>dM,LoadingManager:()=>E6,LoopOnce:()=>Pfe,LoopPingPong:()=>Lfe,LoopRepeat:()=>Ife,LuminanceAlphaFormat:()=>wfe,LuminanceFormat:()=>bfe,MOUSE:()=>K0,Material:()=>qi,MaterialLoader:()=>kU,Math:()=>ifr,MathUtils:()=>ifr,Matrix3:()=>ki,Matrix4:()=>Me,MaxEquation:()=>Aut,Mesh:()=>ti,MeshBasicMaterial:()=>sh,MeshDepthMaterial:()=>eM,MeshDistanceMaterial:()=>rM,MeshFaceMaterial:()=>L0r,MeshLambertMaterial:()=>x6,MeshMatcapMaterial:()=>b6,MeshNormalMaterial:()=>v6,MeshPhongMaterial:()=>_6,MeshPhysicalMaterial:()=>g6,MeshStandardMaterial:()=>pM,MeshToonMaterial:()=>y6,MinEquation:()=>Cut,MirroredRepeatWrapping:()=>$P,MixOperation:()=>lfe,MultiMaterial:()=>k0r,MultiplyBlending:()=>Tut,MultiplyOperation:()=>O6,NearestFilter:()=>Li,NearestMipMapLinearFilter:()=>yhr,NearestMipMapNearestFilter:()=>_hr,NearestMipmapLinearFilter:()=>aU,NearestMipmapNearestFilter:()=>oU,NeverDepth:()=>efe,NeverStencilFunc:()=>Ihr,NoBlending:()=>$d,NoColors:()=>A0r,NoToneMapping:()=>Kd,NormalAnimationBlendMode:()=>$U,NormalBlending:()=>V3,NotEqualDepth:()=>sfe,NotEqualStencilFunc:()=>Dhr,NumberKeyframeTrack:()=>Z1,Object3D:()=>or,ObjectLoader:()=>sht,ObjectSpaceNormalMap:()=>Dfe,OctahedronBufferGeometry:()=>W0,OctahedronGeometry:()=>W0,OneFactor:()=>jhe,OneMinusDstAlphaFactor:()=>Zhe,OneMinusDstColorFactor:()=>Qhe,OneMinusSrcAlphaFactor:()=>Iht,OneMinusSrcColorFactor:()=>$he,OrthographicCamera:()=>D1,PCFShadowMap:()=>Cht,PCFSoftShadowMap:()=>Uhe,PMREMGenerator:()=>e6,ParametricGeometry:()=>s_r,Particle:()=>N0r,ParticleBasicMaterial:()=>z0r,ParticleSystem:()=>D0r,ParticleSystemMaterial:()=>F0r,Path:()=>q1,PerspectiveCamera:()=>Ui,Plane:()=>$c,PlaneBufferGeometry:()=>V0,PlaneGeometry:()=>V0,PlaneHelper:()=>Sht,PointCloud:()=>R0r,PointCloudMaterial:()=>O0r,PointLight:()=>P6,PointLightHelper:()=>_ht,Points:()=>im,PointsMaterial:()=>nm,PolarGridHelper:()=>vht,PolyhedronBufferGeometry:()=>uh,PolyhedronGeometry:()=>uh,PositionalAudio:()=>uht,PropertyBinding:()=>Cr,PropertyMixer:()=>BU,QuadraticBezierCurve:()=>uM,QuadraticBezierCurve3:()=>hM,Quaternion:()=>yi,QuaternionKeyframeTrack:()=>X0,QuaternionLinearInterpolant:()=>EU,REVISION:()=>jU,RGBADepthPacking:()=>Nfe,RGBAFormat:()=>Qo,RGBAIntegerFormat:()=>Cfe,RGBA_ASTC_10x10_Format:()=>Yut,RGBA_ASTC_10x5_Format:()=>qut,RGBA_ASTC_10x6_Format:()=>Gut,RGBA_ASTC_10x8_Format:()=>Wut,RGBA_ASTC_12x10_Format:()=>jut,RGBA_ASTC_12x12_Format:()=>Xut,RGBA_ASTC_4x4_Format:()=>Dut,RGBA_ASTC_5x4_Format:()=>Out,RGBA_ASTC_5x5_Format:()=>zut,RGBA_ASTC_6x5_Format:()=>Fut,RGBA_ASTC_6x6_Format:()=>But,RGBA_ASTC_8x5_Format:()=>Hut,RGBA_ASTC_8x6_Format:()=>Vut,RGBA_ASTC_8x8_Format:()=>Uut,RGBA_BPTC_Format:()=>$ut,RGBA_ETC2_EAC_Format:()=>Nut,RGBA_PVRTC_2BPPV1_Format:()=>kut,RGBA_PVRTC_4BPPV1_Format:()=>Lut,RGBA_S3TC_DXT1_Format:()=>QV,RGBA_S3TC_DXT3_Format:()=>tU,RGBA_S3TC_DXT5_Format:()=>eU,RGB_ETC1_Format:()=>Afe,RGB_ETC2_Format:()=>Rut,RGB_PVRTC_2BPPV1_Format:()=>Iut,RGB_PVRTC_4BPPV1_Format:()=>Put,RGB_S3TC_DXT1_Format:()=>JV,RGFormat:()=>Efe,RGIntegerFormat:()=>Tfe,RawShaderMaterial:()=>U0,Ray:()=>Jf,Raycaster:()=>pht,RectAreaLight:()=>k6,RedFormat:()=>Sfe,RedIntegerFormat:()=>Mfe,ReinhardToneMapping:()=>hfe,RepeatWrapping:()=>XP,ReplaceStencilOp:()=>Mhr,ReverseSubtractEquation:()=>Whe,RingBufferGeometry:()=>Y1,RingGeometry:()=>Y1,Scene:()=>q0,SceneUtils:()=>o_r,ShaderChunk:()=>hr,ShaderLib:()=>ah,ShaderMaterial:()=>lh,ShadowMaterial:()=>m6,Shape:()=>Kc,ShapeBufferGeometry:()=>Y0,ShapeGeometry:()=>Y0,ShapePath:()=>Eht,ShapeUtils:()=>Zc,ShortType:()=>gfe,Skeleton:()=>lM,SkeletonHelper:()=>WU,SkinnedMesh:()=>aM,SmoothShading:()=>ghr,Sphere:()=>Zf,SphereBufferGeometry:()=>j0,SphereGeometry:()=>j0,Spherical:()=>_M,SphericalHarmonics3:()=>R6,SplineCurve:()=>fM,SpotLight:()=>A6,SpotLightHelper:()=>ght,Sprite:()=>oM,SpriteMaterial:()=>iM,SrcAlphaFactor:()=>Pht,SrcAlphaSaturateFactor:()=>tfe,SrcColorFactor:()=>Xhe,StaticCopyUsage:()=>Vhr,StaticDrawUsage:()=>W3,StaticReadUsage:()=>Fhr,StereoCamera:()=>lht,StreamCopyUsage:()=>qhr,StreamDrawUsage:()=>zhr,StreamReadUsage:()=>Hhr,StringKeyframeTrack:()=>sm,SubtractEquation:()=>Ghe,SubtractiveBlending:()=>Eut,TOUCH:()=>Z0,TangentSpaceNormalMap:()=>ax,TetrahedronBufferGeometry:()=>j1,TetrahedronGeometry:()=>j1,TextGeometry:()=>l_r,Texture:()=>vi,TextureLoader:()=>AU,TorusBufferGeometry:()=>X1,TorusGeometry:()=>X1,TorusKnotBufferGeometry:()=>$1,TorusKnotGeometry:()=>$1,Triangle:()=>oi,TriangleFanDrawMode:()=>whr,TriangleStripDrawMode:()=>bhr,TrianglesDrawMode:()=>kfe,TubeBufferGeometry:()=>K1,TubeGeometry:()=>K1,UVMapping:()=>XU,Uint16Attribute:()=>W0r,Uint16BufferAttribute:()=>$3,Uint32Attribute:()=>j0r,Uint32BufferAttribute:()=>K3,Uint8Attribute:()=>U0r,Uint8BufferAttribute:()=>uU,Uint8ClampedAttribute:()=>q0r,Uint8ClampedBufferAttribute:()=>hU,Uniform:()=>gM,UniformsLib:()=>re,UniformsUtils:()=>Vfe,UnsignedByteType:()=>Zd,UnsignedInt248Type:()=>A1,UnsignedIntType:()=>VP,UnsignedShort4444Type:()=>yfe,UnsignedShort5551Type:()=>vfe,UnsignedShortType:()=>G3,VSMShadowMap:()=>F3,Vector2:()=>Lt,Vector3:()=>j,Vector4:()=>en,VectorKeyframeTrack:()=>J1,Vertex:()=>B0r,VertexColors:()=>I0r,VideoTexture:()=>yU,WebGL1Renderer:()=>gU,WebGLCubeRenderTarget:()=>Q3,WebGLMultipleRenderTargets:()=>lU,WebGLMultisampleRenderTarget:()=>j3,WebGLRenderTarget:()=>us,WebGLRenderTargetCube:()=>r_r,WebGLRenderer:()=>rn,WebGLUtils:()=>Qfe,WireframeGeometry:()=>d6,WireframeHelper:()=>Q0r,WrapAroundEnding:()=>JP,XHRLoader:()=>t_r,ZeroCurvatureEnding:()=>E1,ZeroFactor:()=>Yhe,ZeroSlopeEnding:()=>T1,ZeroStencilOp:()=>Shr,_SRGBAFormat:()=>sU,sRGBEncoding:()=>Wn});var jU="137",K0={LEFT:0,MIDDLE:1,RIGHT:2,ROTATE:0,DOLLY:1,PAN:2},Z0={ROTATE:0,PAN:1,DOLLY_PAN:2,DOLLY_ROTATE:3},Hhe=0,Sut=1,Vhe=2,dhr=3,mhr=0,Cht=1,Uhe=2,F3=3,I1=0,Ii=1,L1=2,Aht=1,ghr=2,$d=0,V3=1,Mut=2,Eut=3,Tut=4,qhe=5,M1=100,Ghe=101,Whe=102,Cut=103,Aut=104,Yhe=200,jhe=201,Xhe=202,$he=203,Pht=204,Iht=205,Khe=206,Zhe=207,Jhe=208,Qhe=209,tfe=210,efe=0,rfe=1,nfe=2,iU=3,ife=4,ofe=5,afe=6,sfe=7,O6=0,lfe=1,cfe=2,Kd=0,ufe=1,hfe=2,ffe=3,pfe=4,dfe=5,XU=300,nx=301,ix=302,YP=303,jP=304,xM=306,z6=307,XP=1e3,Jo=1001,$P=1002,Li=1003,oU=1004,_hr=1004,aU=1005,yhr=1005,ii=1006,Lht=1007,vhr=1007,ox=1008,xhr=1008,Zd=1009,mfe=1010,gfe=1011,G3=1012,_fe=1013,VP=1014,jd=1015,C1=1016,yfe=1017,vfe=1018,A1=1020,xfe=1021,Qo=1023,bfe=1024,wfe=1025,z0=1026,k1=1027,Sfe=1028,Mfe=1029,Efe=1030,Tfe=1031,Cfe=1033,JV=33776,QV=33777,tU=33778,eU=33779,Put=35840,Iut=35841,Lut=35842,kut=35843,Afe=36196,Rut=37492,Nut=37496,Dut=37808,Out=37809,zut=37810,Fut=37811,But=37812,Hut=37813,Vut=37814,Uut=37815,qut=37816,Gut=37817,Wut=37818,Yut=37819,jut=37820,Xut=37821,$ut=36492,Pfe=2200,Ife=2201,Lfe=2202,KP=2300,ZP=2301,rU=2302,E1=2400,T1=2401,JP=2402,$U=2500,kht=2501,kfe=0,bhr=1,whr=2,Qd=3e3,Wn=3001,Rfe=3200,Nfe=3201,ax=0,Dfe=1,Shr=0,nU=7680,Mhr=7681,Ehr=7682,Thr=7683,Chr=34055,Ahr=34056,Phr=5386,Ihr=512,Lhr=513,khr=514,Rhr=515,Nhr=516,Dhr=517,Ohr=518,Ofe=519,W3=35044,Y3=35048,zhr=35040,Fhr=35045,Bhr=35049,Hhr=35041,Vhr=35046,Uhr=35050,qhr=35042,Ghr="100",Kut="300 es",sU=1035,Us=class{addEventListener(t,r){this._listeners===void 0&&(this._listeners={});let n=this._listeners;n[t]===void 0&&(n[t]=[]),n[t].indexOf(r)===-1&&n[t].push(r)}hasEventListener(t,r){if(this._listeners===void 0)return!1;let n=this._listeners;return n[t]!==void 0&&n[t].indexOf(r)!==-1}removeEventListener(t,r){if(this._listeners===void 0)return;let i=this._listeners[t];if(i!==void 0){let o=i.indexOf(r);o!==-1&&i.splice(o,1)}}dispatchEvent(t){if(this._listeners===void 0)return;let n=this._listeners[t.type];if(n!==void 0){t.target=this;let i=n.slice(0);for(let o=0,a=i.length;o<a;o++)i[o].call(this,t);t.target=null}}},Ko=[];for(let e=0;e<256;e++)Ko[e]=(e<16?"0":"")+e.toString(16);var uV=1234567,P1=Math.PI/180,QP=180/Math.PI;function Nl(){let e=Math.random()*4294967295|0,t=Math.random()*4294967295|0,r=Math.random()*4294967295|0,n=Math.random()*4294967295|0;return(Ko[e&255]+Ko[e>>8&255]+Ko[e>>16&255]+Ko[e>>24&255]+"-"+Ko[t&255]+Ko[t>>8&255]+"-"+Ko[t>>16&15|64]+Ko[t>>24&255]+"-"+Ko[r&63|128]+Ko[r>>8&255]+"-"+Ko[r>>16&255]+Ko[r>>24&255]+Ko[n&255]+Ko[n>>8&255]+Ko[n>>16&255]+Ko[n>>24&255]).toUpperCase()}function Zo(e,t,r){return Math.max(t,Math.min(r,e))}function Rht(e,t){return(e%t+t)%t}function Whr(e,t,r,n,i){return n+(e-t)*(i-n)/(r-t)}function Yhr(e,t,r){return e!==t?(r-e)/(t-e):0}function UP(e,t,r){return(1-r)*e+r*t}function jhr(e,t,r,n){return UP(e,t,1-Math.exp(-r*n))}function Xhr(e,t=1){return t-Math.abs(Rht(e,t*2)-t)}function $hr(e,t,r){return e<=t?0:e>=r?1:(e=(e-t)/(r-t),e*e*(3-2*e))}function Khr(e,t,r){return e<=t?0:e>=r?1:(e=(e-t)/(r-t),e*e*e*(e*(e*6-15)+10))}function Zhr(e,t){return e+Math.floor(Math.random()*(t-e+1))}function Jhr(e,t){return e+Math.random()*(t-e)}function Qhr(e){return e*(.5-Math.random())}function tfr(e){return e!==void 0&&(uV=e%2147483647),uV=uV*16807%2147483647,(uV-1)/2147483646}function efr(e){return e*P1}function rfr(e){return e*QP}function Zut(e){return(e&e-1)===0&&e!==0}function zfe(e){return Math.pow(2,Math.ceil(Math.log(e)/Math.LN2))}function Ffe(e){return Math.pow(2,Math.floor(Math.log(e)/Math.LN2))}function nfr(e,t,r,n,i){let o=Math.cos,a=Math.sin,s=o(r/2),l=a(r/2),c=o((t+n)/2),u=a((t+n)/2),h=o((t-n)/2),f=a((t-n)/2),p=o((n-t)/2),d=a((n-t)/2);switch(i){case"XYX":e.set(s*u,l*h,l*f,s*c);break;case"YZY":e.set(l*f,s*u,l*h,s*c);break;case"ZXZ":e.set(l*h,l*f,s*u,s*c);break;case"XZX":e.set(s*u,l*d,l*p,s*c);break;case"YXY":e.set(l*p,s*u,l*d,s*c);break;case"ZYZ":e.set(l*d,l*p,s*u,s*c);break;default:console.warn("THREE.MathUtils: .setQuaternionFromProperEuler() encountered an unknown order: "+i)}}var ifr=Object.freeze({__proto__:null,DEG2RAD:P1,RAD2DEG:QP,generateUUID:Nl,clamp:Zo,euclideanModulo:Rht,mapLinear:Whr,inverseLerp:Yhr,lerp:UP,damp:jhr,pingpong:Xhr,smoothstep:$hr,smootherstep:Khr,randInt:Zhr,randFloat:Jhr,randFloatSpread:Qhr,seededRandom:tfr,degToRad:efr,radToDeg:rfr,isPowerOfTwo:Zut,ceilPowerOfTwo:zfe,floorPowerOfTwo:Ffe,setQuaternionFromProperEuler:nfr}),Lt=class{constructor(t=0,r=0){this.x=t,this.y=r}get width(){return this.x}set width(t){this.x=t}get height(){return this.y}set height(t){this.y=t}set(t,r){return this.x=t,this.y=r,this}setScalar(t){return this.x=t,this.y=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setComponent(t,r){switch(t){case 0:this.x=r;break;case 1:this.y=r;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y)}copy(t){return this.x=t.x,this.y=t.y,this}add(t,r){return r!==void 0?(console.warn("THREE.Vector2: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(t,r)):(this.x+=t.x,this.y+=t.y,this)}addScalar(t){return this.x+=t,this.y+=t,this}addVectors(t,r){return this.x=t.x+r.x,this.y=t.y+r.y,this}addScaledVector(t,r){return this.x+=t.x*r,this.y+=t.y*r,this}sub(t,r){return r!==void 0?(console.warn("THREE.Vector2: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),this.subVectors(t,r)):(this.x-=t.x,this.y-=t.y,this)}subScalar(t){return this.x-=t,this.y-=t,this}subVectors(t,r){return this.x=t.x-r.x,this.y=t.y-r.y,this}multiply(t){return this.x*=t.x,this.y*=t.y,this}multiplyScalar(t){return this.x*=t,this.y*=t,this}divide(t){return this.x/=t.x,this.y/=t.y,this}divideScalar(t){return this.multiplyScalar(1/t)}applyMatrix3(t){let r=this.x,n=this.y,i=t.elements;return this.x=i[0]*r+i[3]*n+i[6],this.y=i[1]*r+i[4]*n+i[7],this}min(t){return this.x=Math.min(this.x,t.x),this.y=Math.min(this.y,t.y),this}max(t){return this.x=Math.max(this.x,t.x),this.y=Math.max(this.y,t.y),this}clamp(t,r){return this.x=Math.max(t.x,Math.min(r.x,this.x)),this.y=Math.max(t.y,Math.min(r.y,this.y)),this}clampScalar(t,r){return this.x=Math.max(t,Math.min(r,this.x)),this.y=Math.max(t,Math.min(r,this.y)),this}clampLength(t,r){let n=this.length();return this.divideScalar(n||1).multiplyScalar(Math.max(t,Math.min(r,n)))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this}roundToZero(){return this.x=this.x<0?Math.ceil(this.x):Math.floor(this.x),this.y=this.y<0?Math.ceil(this.y):Math.floor(this.y),this}negate(){return this.x=-this.x,this.y=-this.y,this}dot(t){return this.x*t.x+this.y*t.y}cross(t){return this.x*t.y-this.y*t.x}lengthSq(){return this.x*this.x+this.y*this.y}length(){return Math.sqrt(this.x*this.x+this.y*this.y)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)}normalize(){return this.divideScalar(this.length()||1)}angle(){return Math.atan2(-this.y,-this.x)+Math.PI}distanceTo(t){return Math.sqrt(this.distanceToSquared(t))}distanceToSquared(t){let r=this.x-t.x,n=this.y-t.y;return r*r+n*n}manhattanDistanceTo(t){return Math.abs(this.x-t.x)+Math.abs(this.y-t.y)}setLength(t){return this.normalize().multiplyScalar(t)}lerp(t,r){return this.x+=(t.x-this.x)*r,this.y+=(t.y-this.y)*r,this}lerpVectors(t,r,n){return this.x=t.x+(r.x-t.x)*n,this.y=t.y+(r.y-t.y)*n,this}equals(t){return t.x===this.x&&t.y===this.y}fromArray(t,r=0){return this.x=t[r],this.y=t[r+1],this}toArray(t=[],r=0){return t[r]=this.x,t[r+1]=this.y,t}fromBufferAttribute(t,r,n){return n!==void 0&&console.warn("THREE.Vector2: offset has been removed from .fromBufferAttribute()."),this.x=t.getX(r),this.y=t.getY(r),this}rotateAround(t,r){let n=Math.cos(r),i=Math.sin(r),o=this.x-t.x,a=this.y-t.y;return this.x=o*n-a*i+t.x,this.y=o*i+a*n+t.y,this}random(){return this.x=Math.random(),this.y=Math.random(),this}*[Symbol.iterator](){yield this.x,yield this.y}};Lt.prototype.isVector2=!0;var ki=class{constructor(){this.elements=[1,0,0,0,1,0,0,0,1],arguments.length>0&&console.error("THREE.Matrix3: the constructor no longer reads arguments. use .set() instead.")}set(t,r,n,i,o,a,s,l,c){let u=this.elements;return u[0]=t,u[1]=i,u[2]=s,u[3]=r,u[4]=o,u[5]=l,u[6]=n,u[7]=a,u[8]=c,this}identity(){return this.set(1,0,0,0,1,0,0,0,1),this}copy(t){let r=this.elements,n=t.elements;return r[0]=n[0],r[1]=n[1],r[2]=n[2],r[3]=n[3],r[4]=n[4],r[5]=n[5],r[6]=n[6],r[7]=n[7],r[8]=n[8],this}extractBasis(t,r,n){return t.setFromMatrix3Column(this,0),r.setFromMatrix3Column(this,1),n.setFromMatrix3Column(this,2),this}setFromMatrix4(t){let r=t.elements;return this.set(r[0],r[4],r[8],r[1],r[5],r[9],r[2],r[6],r[10]),this}multiply(t){return this.multiplyMatrices(this,t)}premultiply(t){return this.multiplyMatrices(t,this)}multiplyMatrices(t,r){let n=t.elements,i=r.elements,o=this.elements,a=n[0],s=n[3],l=n[6],c=n[1],u=n[4],h=n[7],f=n[2],p=n[5],d=n[8],g=i[0],_=i[3],y=i[6],x=i[1],b=i[4],S=i[7],C=i[2],P=i[5],k=i[8];return o[0]=a*g+s*x+l*C,o[3]=a*_+s*b+l*P,o[6]=a*y+s*S+l*k,o[1]=c*g+u*x+h*C,o[4]=c*_+u*b+h*P,o[7]=c*y+u*S+h*k,o[2]=f*g+p*x+d*C,o[5]=f*_+p*b+d*P,o[8]=f*y+p*S+d*k,this}multiplyScalar(t){let r=this.elements;return r[0]*=t,r[3]*=t,r[6]*=t,r[1]*=t,r[4]*=t,r[7]*=t,r[2]*=t,r[5]*=t,r[8]*=t,this}determinant(){let t=this.elements,r=t[0],n=t[1],i=t[2],o=t[3],a=t[4],s=t[5],l=t[6],c=t[7],u=t[8];return r*a*u-r*s*c-n*o*u+n*s*l+i*o*c-i*a*l}invert(){let t=this.elements,r=t[0],n=t[1],i=t[2],o=t[3],a=t[4],s=t[5],l=t[6],c=t[7],u=t[8],h=u*a-s*c,f=s*l-u*o,p=c*o-a*l,d=r*h+n*f+i*p;if(d===0)return this.set(0,0,0,0,0,0,0,0,0);let g=1/d;return t[0]=h*g,t[1]=(i*c-u*n)*g,t[2]=(s*n-i*a)*g,t[3]=f*g,t[4]=(u*r-i*l)*g,t[5]=(i*o-s*r)*g,t[6]=p*g,t[7]=(n*l-c*r)*g,t[8]=(a*r-n*o)*g,this}transpose(){let t,r=this.elements;return t=r[1],r[1]=r[3],r[3]=t,t=r[2],r[2]=r[6],r[6]=t,t=r[5],r[5]=r[7],r[7]=t,this}getNormalMatrix(t){return this.setFromMatrix4(t).invert().transpose()}transposeIntoArray(t){let r=this.elements;return t[0]=r[0],t[1]=r[3],t[2]=r[6],t[3]=r[1],t[4]=r[4],t[5]=r[7],t[6]=r[2],t[7]=r[5],t[8]=r[8],this}setUvTransform(t,r,n,i,o,a,s){let l=Math.cos(o),c=Math.sin(o);return this.set(n*l,n*c,-n*(l*a+c*s)+a+t,-i*c,i*l,-i*(-c*a+l*s)+s+r,0,0,1),this}scale(t,r){let n=this.elements;return n[0]*=t,n[3]*=t,n[6]*=t,n[1]*=r,n[4]*=r,n[7]*=r,this}rotate(t){let r=Math.cos(t),n=Math.sin(t),i=this.elements,o=i[0],a=i[3],s=i[6],l=i[1],c=i[4],u=i[7];return i[0]=r*o+n*l,i[3]=r*a+n*c,i[6]=r*s+n*u,i[1]=-n*o+r*l,i[4]=-n*a+r*c,i[7]=-n*s+r*u,this}translate(t,r){let n=this.elements;return n[0]+=t*n[2],n[3]+=t*n[5],n[6]+=t*n[8],n[1]+=r*n[2],n[4]+=r*n[5],n[7]+=r*n[8],this}equals(t){let r=this.elements,n=t.elements;for(let i=0;i<9;i++)if(r[i]!==n[i])return!1;return!0}fromArray(t,r=0){for(let n=0;n<9;n++)this.elements[n]=t[n+r];return this}toArray(t=[],r=0){let n=this.elements;return t[r]=n[0],t[r+1]=n[1],t[r+2]=n[2],t[r+3]=n[3],t[r+4]=n[4],t[r+5]=n[5],t[r+6]=n[6],t[r+7]=n[7],t[r+8]=n[8],t}clone(){return new this.constructor().fromArray(this.elements)}};ki.prototype.isMatrix3=!0;function Bfe(e){for(let t=e.length-1;t>=0;--t)if(e[t]>65535)return!0;return!1}var ofr={Int8Array,Uint8Array,Uint8ClampedArray,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array};function B3(e,t){return new ofr[e](t)}function t6(e){return document.createElementNS("http://www.w3.org/1999/xhtml",e)}var Hfe={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074},nh={h:0,s:0,l:0},hV={h:0,s:0,l:0};function Gct(e,t,r){return r<0&&(r+=1),r>1&&(r-=1),r<1/6?e+(t-e)*6*r:r<1/2?t:r<2/3?e+(t-e)*6*(2/3-r):e}function U3(e){return e<.04045?e*.0773993808:Math.pow(e*.9478672986+.0521327014,2.4)}function Wct(e){return e<.0031308?e*12.92:1.055*Math.pow(e,.41666)-.055}var ne=class{constructor(t,r,n){return r===void 0&&n===void 0?this.set(t):this.setRGB(t,r,n)}set(t){return t&&t.isColor?this.copy(t):typeof t=="number"?this.setHex(t):typeof t=="string"&&this.setStyle(t),this}setScalar(t){return this.r=t,this.g=t,this.b=t,this}setHex(t){return t=Math.floor(t),this.r=(t>>16&255)/255,this.g=(t>>8&255)/255,this.b=(t&255)/255,this}setRGB(t,r,n){return this.r=t,this.g=r,this.b=n,this}setHSL(t,r,n){if(t=Rht(t,1),r=Zo(r,0,1),n=Zo(n,0,1),r===0)this.r=this.g=this.b=n;else{let i=n<=.5?n*(1+r):n+r-n*r,o=2*n-i;this.r=Gct(o,i,t+1/3),this.g=Gct(o,i,t),this.b=Gct(o,i,t-1/3)}return this}setStyle(t){function r(i){i!==void 0&&parseFloat(i)<1&&console.warn("THREE.Color: Alpha component of "+t+" will be ignored.")}let n;if(n=/^((?:rgb|hsl)a?)\(([^\)]*)\)/.exec(t)){let i,o=n[1],a=n[2];switch(o){case"rgb":case"rgba":if(i=/^\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(a))return this.r=Math.min(255,parseInt(i[1],10))/255,this.g=Math.min(255,parseInt(i[2],10))/255,this.b=Math.min(255,parseInt(i[3],10))/255,r(i[4]),this;if(i=/^\s*(\d+)\%\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(a))return this.r=Math.min(100,parseInt(i[1],10))/100,this.g=Math.min(100,parseInt(i[2],10))/100,this.b=Math.min(100,parseInt(i[3],10))/100,r(i[4]),this;break;case"hsl":case"hsla":if(i=/^\s*(\d*\.?\d+)\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(a)){let s=parseFloat(i[1])/360,l=parseInt(i[2],10)/100,c=parseInt(i[3],10)/100;return r(i[4]),this.setHSL(s,l,c)}break}}else if(n=/^\#([A-Fa-f\d]+)$/.exec(t)){let i=n[1],o=i.length;if(o===3)return this.r=parseInt(i.charAt(0)+i.charAt(0),16)/255,this.g=parseInt(i.charAt(1)+i.charAt(1),16)/255,this.b=parseInt(i.charAt(2)+i.charAt(2),16)/255,this;if(o===6)return this.r=parseInt(i.charAt(0)+i.charAt(1),16)/255,this.g=parseInt(i.charAt(2)+i.charAt(3),16)/255,this.b=parseInt(i.charAt(4)+i.charAt(5),16)/255,this}return t&&t.length>0?this.setColorName(t):this}setColorName(t){let r=Hfe[t.toLowerCase()];return r!==void 0?this.setHex(r):console.warn("THREE.Color: Unknown color "+t),this}clone(){return new this.constructor(this.r,this.g,this.b)}copy(t){return this.r=t.r,this.g=t.g,this.b=t.b,this}copySRGBToLinear(t){return this.r=U3(t.r),this.g=U3(t.g),this.b=U3(t.b),this}copyLinearToSRGB(t){return this.r=Wct(t.r),this.g=Wct(t.g),this.b=Wct(t.b),this}convertSRGBToLinear(){return this.copySRGBToLinear(this),this}convertLinearToSRGB(){return this.copyLinearToSRGB(this),this}getHex(){return this.r*255<<16^this.g*255<<8^this.b*255<<0}getHexString(){return("000000"+this.getHex().toString(16)).slice(-6)}getHSL(t){let r=this.r,n=this.g,i=this.b,o=Math.max(r,n,i),a=Math.min(r,n,i),s,l,c=(a+o)/2;if(a===o)s=0,l=0;else{let u=o-a;switch(l=c<=.5?u/(o+a):u/(2-o-a),o){case r:s=(n-i)/u+(n<i?6:0);break;case n:s=(i-r)/u+2;break;case i:s=(r-n)/u+4;break}s/=6}return t.h=s,t.s=l,t.l=c,t}getStyle(){return"rgb("+(this.r*255|0)+","+(this.g*255|0)+","+(this.b*255|0)+")"}offsetHSL(t,r,n){return this.getHSL(nh),nh.h+=t,nh.s+=r,nh.l+=n,this.setHSL(nh.h,nh.s,nh.l),this}add(t){return this.r+=t.r,this.g+=t.g,this.b+=t.b,this}addColors(t,r){return this.r=t.r+r.r,this.g=t.g+r.g,this.b=t.b+r.b,this}addScalar(t){return this.r+=t,this.g+=t,this.b+=t,this}sub(t){return this.r=Math.max(0,this.r-t.r),this.g=Math.max(0,this.g-t.g),this.b=Math.max(0,this.b-t.b),this}multiply(t){return this.r*=t.r,this.g*=t.g,this.b*=t.b,this}multiplyScalar(t){return this.r*=t,this.g*=t,this.b*=t,this}lerp(t,r){return this.r+=(t.r-this.r)*r,this.g+=(t.g-this.g)*r,this.b+=(t.b-this.b)*r,this}lerpColors(t,r,n){return this.r=t.r+(r.r-t.r)*n,this.g=t.g+(r.g-t.g)*n,this.b=t.b+(r.b-t.b)*n,this}lerpHSL(t,r){this.getHSL(nh),t.getHSL(hV);let n=UP(nh.h,hV.h,r),i=UP(nh.s,hV.s,r),o=UP(nh.l,hV.l,r);return this.setHSL(n,i,o),this}equals(t){return t.r===this.r&&t.g===this.g&&t.b===this.b}fromArray(t,r=0){return this.r=t[r],this.g=t[r+1],this.b=t[r+2],this}toArray(t=[],r=0){return t[r]=this.r,t[r+1]=this.g,t[r+2]=this.b,t}fromBufferAttribute(t,r){return this.r=t.getX(r),this.g=t.getY(r),this.b=t.getZ(r),t.normalized===!0&&(this.r/=255,this.g/=255,this.b/=255),this}toJSON(){return this.getHex()}};ne.NAMES=Hfe;ne.prototype.isColor=!0;ne.prototype.r=1;ne.prototype.g=1;ne.prototype.b=1;var v3,Kf=class{static getDataURL(t){if(/^data:/i.test(t.src)||typeof HTMLCanvasElement=="undefined")return t.src;let r;if(t instanceof HTMLCanvasElement)r=t;else{v3===void 0&&(v3=t6("canvas")),v3.width=t.width,v3.height=t.height;let n=v3.getContext("2d");t instanceof ImageData?n.putImageData(t,0,0):n.drawImage(t,0,0,t.width,t.height),r=v3}return r.width>2048||r.height>2048?(console.warn("THREE.ImageUtils.getDataURL: Image converted to jpg for performance reasons",t),r.toDataURL("image/jpeg",.6)):r.toDataURL("image/png")}static sRGBToLinear(t){if(typeof HTMLImageElement!="undefined"&&t instanceof HTMLImageElement||typeof HTMLCanvasElement!="undefined"&&t instanceof HTMLCanvasElement||typeof ImageBitmap!="undefined"&&t instanceof ImageBitmap){let r=t6("canvas");r.width=t.width,r.height=t.height;let n=r.getContext("2d");n.drawImage(t,0,0,t.width,t.height);let i=n.getImageData(0,0,t.width,t.height),o=i.data;for(let a=0;a<o.length;a++)o[a]=U3(o[a]/255)*255;return n.putImageData(i,0,0),r}else if(t.data){let r=t.data.slice(0);for(let n=0;n<r.length;n++)r instanceof Uint8Array||r instanceof Uint8ClampedArray?r[n]=Math.floor(U3(r[n]/255)*255):r[n]=U3(r[n]);return{data:r,width:t.width,height:t.height}}else return console.warn("THREE.ImageUtils.sRGBToLinear(): Unsupported image type. No color space conversion applied."),t}},afr=0,vi=class extends Us{constructor(t=vi.DEFAULT_IMAGE,r=vi.DEFAULT_MAPPING,n=Jo,i=Jo,o=ii,a=ox,s=Qo,l=Zd,c=1,u=Qd){super(),Object.defineProperty(this,"id",{value:afr++}),this.uuid=Nl(),this.name="",this.image=t,this.mipmaps=[],this.mapping=r,this.wrapS=n,this.wrapT=i,this.magFilter=o,this.minFilter=a,this.anisotropy=c,this.format=s,this.internalFormat=null,this.type=l,this.offset=new Lt(0,0),this.repeat=new Lt(1,1),this.center=new Lt(0,0),this.rotation=0,this.matrixAutoUpdate=!0,this.matrix=new ki,this.generateMipmaps=!0,this.premultiplyAlpha=!1,this.flipY=!0,this.unpackAlignment=4,this.encoding=u,this.userData={},this.version=0,this.onUpdate=null,this.isRenderTargetTexture=!1,this.needsPMREMUpdate=!1}updateMatrix(){this.matrix.setUvTransform(this.offset.x,this.offset.y,this.repeat.x,this.repeat.y,this.rotation,this.center.x,this.center.y)}clone(){return new this.constructor().copy(this)}copy(t){return this.name=t.name,this.image=t.image,this.mipmaps=t.mipmaps.slice(0),this.mapping=t.mapping,this.wrapS=t.wrapS,this.wrapT=t.wrapT,this.magFilter=t.magFilter,this.minFilter=t.minFilter,this.anisotropy=t.anisotropy,this.format=t.format,this.internalFormat=t.internalFormat,this.type=t.type,this.offset.copy(t.offset),this.repeat.copy(t.repeat),this.center.copy(t.center),this.rotation=t.rotation,this.matrixAutoUpdate=t.matrixAutoUpdate,this.matrix.copy(t.matrix),this.generateMipmaps=t.generateMipmaps,this.premultiplyAlpha=t.premultiplyAlpha,this.flipY=t.flipY,this.unpackAlignment=t.unpackAlignment,this.encoding=t.encoding,this.userData=JSON.parse(JSON.stringify(t.userData)),this}toJSON(t){let r=t===void 0||typeof t=="string";if(!r&&t.textures[this.uuid]!==void 0)return t.textures[this.uuid];let n={metadata:{version:4.5,type:"Texture",generator:"Texture.toJSON"},uuid:this.uuid,name:this.name,mapping:this.mapping,repeat:[this.repeat.x,this.repeat.y],offset:[this.offset.x,this.offset.y],center:[this.center.x,this.center.y],rotation:this.rotation,wrap:[this.wrapS,this.wrapT],format:this.format,type:this.type,encoding:this.encoding,minFilter:this.minFilter,magFilter:this.magFilter,anisotropy:this.anisotropy,flipY:this.flipY,premultiplyAlpha:this.premultiplyAlpha,unpackAlignment:this.unpackAlignment};if(this.image!==void 0){let i=this.image;if(i.uuid===void 0&&(i.uuid=Nl()),!r&&t.images[i.uuid]===void 0){let o;if(Array.isArray(i)){o=[];for(let a=0,s=i.length;a<s;a++)i[a].isDataTexture?o.push(Yct(i[a].image)):o.push(Yct(i[a]))}else o=Yct(i);t.images[i.uuid]={uuid:i.uuid,url:o}}n.image=i.uuid}return JSON.stringify(this.userData)!=="{}"&&(n.userData=this.userData),r||(t.textures[this.uuid]=n),n}dispose(){this.dispatchEvent({type:"dispose"})}transformUv(t){if(this.mapping!==XU)return t;if(t.applyMatrix3(this.matrix),t.x<0||t.x>1)switch(this.wrapS){case XP:t.x=t.x-Math.floor(t.x);break;case Jo:t.x=t.x<0?0:1;break;case $P:Math.abs(Math.floor(t.x)%2)===1?t.x=Math.ceil(t.x)-t.x:t.x=t.x-Math.floor(t.x);break}if(t.y<0||t.y>1)switch(this.wrapT){case XP:t.y=t.y-Math.floor(t.y);break;case Jo:t.y=t.y<0?0:1;break;case $P:Math.abs(Math.floor(t.y)%2)===1?t.y=Math.ceil(t.y)-t.y:t.y=t.y-Math.floor(t.y);break}return this.flipY&&(t.y=1-t.y),t}set needsUpdate(t){t===!0&&this.version++}};vi.DEFAULT_IMAGE=void 0;vi.DEFAULT_MAPPING=XU;vi.prototype.isTexture=!0;function Yct(e){return typeof HTMLImageElement!="undefined"&&e instanceof HTMLImageElement||typeof HTMLCanvasElement!="undefined"&&e instanceof HTMLCanvasElement||typeof ImageBitmap!="undefined"&&e instanceof ImageBitmap?Kf.getDataURL(e):e.data?{data:Array.prototype.slice.call(e.data),width:e.width,height:e.height,type:e.data.constructor.name}:(console.warn("THREE.Texture: Unable to serialize Texture."),{})}var en=class{constructor(t=0,r=0,n=0,i=1){this.x=t,this.y=r,this.z=n,this.w=i}get width(){return this.z}set width(t){this.z=t}get height(){return this.w}set height(t){this.w=t}set(t,r,n,i){return this.x=t,this.y=r,this.z=n,this.w=i,this}setScalar(t){return this.x=t,this.y=t,this.z=t,this.w=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setZ(t){return this.z=t,this}setW(t){return this.w=t,this}setComponent(t,r){switch(t){case 0:this.x=r;break;case 1:this.y=r;break;case 2:this.z=r;break;case 3:this.w=r;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;case 2:return this.z;case 3:return this.w;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y,this.z,this.w)}copy(t){return this.x=t.x,this.y=t.y,this.z=t.z,this.w=t.w!==void 0?t.w:1,this}add(t,r){return r!==void 0?(console.warn("THREE.Vector4: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(t,r)):(this.x+=t.x,this.y+=t.y,this.z+=t.z,this.w+=t.w,this)}addScalar(t){return this.x+=t,this.y+=t,this.z+=t,this.w+=t,this}addVectors(t,r){return this.x=t.x+r.x,this.y=t.y+r.y,this.z=t.z+r.z,this.w=t.w+r.w,this}addScaledVector(t,r){return this.x+=t.x*r,this.y+=t.y*r,this.z+=t.z*r,this.w+=t.w*r,this}sub(t,r){return r!==void 0?(console.warn("THREE.Vector4: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),this.subVectors(t,r)):(this.x-=t.x,this.y-=t.y,this.z-=t.z,this.w-=t.w,this)}subScalar(t){return this.x-=t,this.y-=t,this.z-=t,this.w-=t,this}subVectors(t,r){return this.x=t.x-r.x,this.y=t.y-r.y,this.z=t.z-r.z,this.w=t.w-r.w,this}multiply(t){return this.x*=t.x,this.y*=t.y,this.z*=t.z,this.w*=t.w,this}multiplyScalar(t){return this.x*=t,this.y*=t,this.z*=t,this.w*=t,this}applyMatrix4(t){let r=this.x,n=this.y,i=this.z,o=this.w,a=t.elements;return this.x=a[0]*r+a[4]*n+a[8]*i+a[12]*o,this.y=a[1]*r+a[5]*n+a[9]*i+a[13]*o,this.z=a[2]*r+a[6]*n+a[10]*i+a[14]*o,this.w=a[3]*r+a[7]*n+a[11]*i+a[15]*o,this}divideScalar(t){return this.multiplyScalar(1/t)}setAxisAngleFromQuaternion(t){this.w=2*Math.acos(t.w);let r=Math.sqrt(1-t.w*t.w);return r<1e-4?(this.x=1,this.y=0,this.z=0):(this.x=t.x/r,this.y=t.y/r,this.z=t.z/r),this}setAxisAngleFromRotationMatrix(t){let r,n,i,o,l=t.elements,c=l[0],u=l[4],h=l[8],f=l[1],p=l[5],d=l[9],g=l[2],_=l[6],y=l[10];if(Math.abs(u-f)<.01&&Math.abs(h-g)<.01&&Math.abs(d-_)<.01){if(Math.abs(u+f)<.1&&Math.abs(h+g)<.1&&Math.abs(d+_)<.1&&Math.abs(c+p+y-3)<.1)return this.set(1,0,0,0),this;r=Math.PI;let b=(c+1)/2,S=(p+1)/2,C=(y+1)/2,P=(u+f)/4,k=(h+g)/4,O=(d+_)/4;return b>S&&b>C?b<.01?(n=0,i=.707106781,o=.707106781):(n=Math.sqrt(b),i=P/n,o=k/n):S>C?S<.01?(n=.707106781,i=0,o=.707106781):(i=Math.sqrt(S),n=P/i,o=O/i):C<.01?(n=.707106781,i=.707106781,o=0):(o=Math.sqrt(C),n=k/o,i=O/o),this.set(n,i,o,r),this}let x=Math.sqrt((_-d)*(_-d)+(h-g)*(h-g)+(f-u)*(f-u));return Math.abs(x)<.001&&(x=1),this.x=(_-d)/x,this.y=(h-g)/x,this.z=(f-u)/x,this.w=Math.acos((c+p+y-1)/2),this}min(t){return this.x=Math.min(this.x,t.x),this.y=Math.min(this.y,t.y),this.z=Math.min(this.z,t.z),this.w=Math.min(this.w,t.w),this}max(t){return this.x=Math.max(this.x,t.x),this.y=Math.max(this.y,t.y),this.z=Math.max(this.z,t.z),this.w=Math.max(this.w,t.w),this}clamp(t,r){return this.x=Math.max(t.x,Math.min(r.x,this.x)),this.y=Math.max(t.y,Math.min(r.y,this.y)),this.z=Math.max(t.z,Math.min(r.z,this.z)),this.w=Math.max(t.w,Math.min(r.w,this.w)),this}clampScalar(t,r){return this.x=Math.max(t,Math.min(r,this.x)),this.y=Math.max(t,Math.min(r,this.y)),this.z=Math.max(t,Math.min(r,this.z)),this.w=Math.max(t,Math.min(r,this.w)),this}clampLength(t,r){let n=this.length();return this.divideScalar(n||1).multiplyScalar(Math.max(t,Math.min(r,n)))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this.z=Math.floor(this.z),this.w=Math.floor(this.w),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this.z=Math.ceil(this.z),this.w=Math.ceil(this.w),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this.z=Math.round(this.z),this.w=Math.round(this.w),this}roundToZero(){return this.x=this.x<0?Math.ceil(this.x):Math.floor(this.x),this.y=this.y<0?Math.ceil(this.y):Math.floor(this.y),this.z=this.z<0?Math.ceil(this.z):Math.floor(this.z),this.w=this.w<0?Math.ceil(this.w):Math.floor(this.w),this}negate(){return this.x=-this.x,this.y=-this.y,this.z=-this.z,this.w=-this.w,this}dot(t){return this.x*t.x+this.y*t.y+this.z*t.z+this.w*t.w}lengthSq(){return this.x*this.x+this.y*this.y+this.z*this.z+this.w*this.w}length(){return Math.sqrt(this.x*this.x+this.y*this.y+this.z*this.z+this.w*this.w)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)+Math.abs(this.z)+Math.abs(this.w)}normalize(){return this.divideScalar(this.length()||1)}setLength(t){return this.normalize().multiplyScalar(t)}lerp(t,r){return this.x+=(t.x-this.x)*r,this.y+=(t.y-this.y)*r,this.z+=(t.z-this.z)*r,this.w+=(t.w-this.w)*r,this}lerpVectors(t,r,n){return this.x=t.x+(r.x-t.x)*n,this.y=t.y+(r.y-t.y)*n,this.z=t.z+(r.z-t.z)*n,this.w=t.w+(r.w-t.w)*n,this}equals(t){return t.x===this.x&&t.y===this.y&&t.z===this.z&&t.w===this.w}fromArray(t,r=0){return this.x=t[r],this.y=t[r+1],this.z=t[r+2],this.w=t[r+3],this}toArray(t=[],r=0){return t[r]=this.x,t[r+1]=this.y,t[r+2]=this.z,t[r+3]=this.w,t}fromBufferAttribute(t,r,n){return n!==void 0&&console.warn("THREE.Vector4: offset has been removed from .fromBufferAttribute()."),this.x=t.getX(r),this.y=t.getY(r),this.z=t.getZ(r),this.w=t.getW(r),this}random(){return this.x=Math.random(),this.y=Math.random(),this.z=Math.random(),this.w=Math.random(),this}*[Symbol.iterator](){yield this.x,yield this.y,yield this.z,yield this.w}};en.prototype.isVector4=!0;var us=class extends Us{constructor(t,r,n={}){super(),this.width=t,this.height=r,this.depth=1,this.scissor=new en(0,0,t,r),this.scissorTest=!1,this.viewport=new en(0,0,t,r),this.texture=new vi(void 0,n.mapping,n.wrapS,n.wrapT,n.magFilter,n.minFilter,n.format,n.type,n.anisotropy,n.encoding),this.texture.isRenderTargetTexture=!0,this.texture.image={width:t,height:r,depth:1},this.texture.generateMipmaps=n.generateMipmaps!==void 0?n.generateMipmaps:!1,this.texture.internalFormat=n.internalFormat!==void 0?n.internalFormat:null,this.texture.minFilter=n.minFilter!==void 0?n.minFilter:ii,this.depthBuffer=n.depthBuffer!==void 0?n.depthBuffer:!0,this.stencilBuffer=n.stencilBuffer!==void 0?n.stencilBuffer:!1,this.depthTexture=n.depthTexture!==void 0?n.depthTexture:null}setTexture(t){t.image={width:this.width,height:this.height,depth:this.depth},this.texture=t}setSize(t,r,n=1){(this.width!==t||this.height!==r||this.depth!==n)&&(this.width=t,this.height=r,this.depth=n,this.texture.image.width=t,this.texture.image.height=r,this.texture.image.depth=n,this.dispose()),this.viewport.set(0,0,t,r),this.scissor.set(0,0,t,r)}clone(){return new this.constructor().copy(this)}copy(t){return this.width=t.width,this.height=t.height,this.depth=t.depth,this.viewport.copy(t.viewport),this.texture=t.texture.clone(),this.texture.image=Object.assign({},t.texture.image),this.depthBuffer=t.depthBuffer,this.stencilBuffer=t.stencilBuffer,this.depthTexture=t.depthTexture,this}dispose(){this.dispatchEvent({type:"dispose"})}};us.prototype.isWebGLRenderTarget=!0;var lU=class extends us{constructor(t,r,n){super(t,r);let i=this.texture;this.texture=[];for(let o=0;o<n;o++)this.texture[o]=i.clone()}setSize(t,r,n=1){if(this.width!==t||this.height!==r||this.depth!==n){this.width=t,this.height=r,this.depth=n;for(let i=0,o=this.texture.length;i<o;i++)this.texture[i].image.width=t,this.texture[i].image.height=r,this.texture[i].image.depth=n;this.dispose()}return this.viewport.set(0,0,t,r),this.scissor.set(0,0,t,r),this}copy(t){this.dispose(),this.width=t.width,this.height=t.height,this.depth=t.depth,this.viewport.set(0,0,this.width,this.height),this.scissor.set(0,0,this.width,this.height),this.depthBuffer=t.depthBuffer,this.stencilBuffer=t.stencilBuffer,this.depthTexture=t.depthTexture,this.texture.length=0;for(let r=0,n=t.texture.length;r<n;r++)this.texture[r]=t.texture[r].clone();return this}};lU.prototype.isWebGLMultipleRenderTargets=!0;var j3=class extends us{constructor(t,r,n={}){super(t,r,n),this.samples=4,this.ignoreDepthForMultisampleCopy=n.ignoreDepth!==void 0?n.ignoreDepth:!0,this.useRenderToTexture=n.useRenderToTexture!==void 0?n.useRenderToTexture:!1,this.useRenderbuffer=this.useRenderToTexture===!1}copy(t){return super.copy.call(this,t),this.samples=t.samples,this.useRenderToTexture=t.useRenderToTexture,this.useRenderbuffer=t.useRenderbuffer,this}};j3.prototype.isWebGLMultisampleRenderTarget=!0;var yi=class{constructor(t=0,r=0,n=0,i=1){this._x=t,this._y=r,this._z=n,this._w=i}static slerp(t,r,n,i){return console.warn("THREE.Quaternion: Static .slerp() has been deprecated. Use qm.slerpQuaternions( qa, qb, t ) instead."),n.slerpQuaternions(t,r,i)}static slerpFlat(t,r,n,i,o,a,s){let l=n[i+0],c=n[i+1],u=n[i+2],h=n[i+3],f=o[a+0],p=o[a+1],d=o[a+2],g=o[a+3];if(s===0){t[r+0]=l,t[r+1]=c,t[r+2]=u,t[r+3]=h;return}if(s===1){t[r+0]=f,t[r+1]=p,t[r+2]=d,t[r+3]=g;return}if(h!==g||l!==f||c!==p||u!==d){let _=1-s,y=l*f+c*p+u*d+h*g,x=y>=0?1:-1,b=1-y*y;if(b>Number.EPSILON){let C=Math.sqrt(b),P=Math.atan2(C,y*x);_=Math.sin(_*P)/C,s=Math.sin(s*P)/C}let S=s*x;if(l=l*_+f*S,c=c*_+p*S,u=u*_+d*S,h=h*_+g*S,_===1-s){let C=1/Math.sqrt(l*l+c*c+u*u+h*h);l*=C,c*=C,u*=C,h*=C}}t[r]=l,t[r+1]=c,t[r+2]=u,t[r+3]=h}static multiplyQuaternionsFlat(t,r,n,i,o,a){let s=n[i],l=n[i+1],c=n[i+2],u=n[i+3],h=o[a],f=o[a+1],p=o[a+2],d=o[a+3];return t[r]=s*d+u*h+l*p-c*f,t[r+1]=l*d+u*f+c*h-s*p,t[r+2]=c*d+u*p+s*f-l*h,t[r+3]=u*d-s*h-l*f-c*p,t}get x(){return this._x}set x(t){this._x=t,this._onChangeCallback()}get y(){return this._y}set y(t){this._y=t,this._onChangeCallback()}get z(){return this._z}set z(t){this._z=t,this._onChangeCallback()}get w(){return this._w}set w(t){this._w=t,this._onChangeCallback()}set(t,r,n,i){return this._x=t,this._y=r,this._z=n,this._w=i,this._onChangeCallback(),this}clone(){return new this.constructor(this._x,this._y,this._z,this._w)}copy(t){return this._x=t.x,this._y=t.y,this._z=t.z,this._w=t.w,this._onChangeCallback(),this}setFromEuler(t,r){if(!(t&&t.isEuler))throw new Error("THREE.Quaternion: .setFromEuler() now expects an Euler rotation rather than a Vector3 and order.");let n=t._x,i=t._y,o=t._z,a=t._order,s=Math.cos,l=Math.sin,c=s(n/2),u=s(i/2),h=s(o/2),f=l(n/2),p=l(i/2),d=l(o/2);switch(a){case"XYZ":this._x=f*u*h+c*p*d,this._y=c*p*h-f*u*d,this._z=c*u*d+f*p*h,this._w=c*u*h-f*p*d;break;case"YXZ":this._x=f*u*h+c*p*d,this._y=c*p*h-f*u*d,this._z=c*u*d-f*p*h,this._w=c*u*h+f*p*d;break;case"ZXY":this._x=f*u*h-c*p*d,this._y=c*p*h+f*u*d,this._z=c*u*d+f*p*h,this._w=c*u*h-f*p*d;break;case"ZYX":this._x=f*u*h-c*p*d,this._y=c*p*h+f*u*d,this._z=c*u*d-f*p*h,this._w=c*u*h+f*p*d;break;case"YZX":this._x=f*u*h+c*p*d,this._y=c*p*h+f*u*d,this._z=c*u*d-f*p*h,this._w=c*u*h-f*p*d;break;case"XZY":this._x=f*u*h-c*p*d,this._y=c*p*h-f*u*d,this._z=c*u*d+f*p*h,this._w=c*u*h+f*p*d;break;default:console.warn("THREE.Quaternion: .setFromEuler() encountered an unknown order: "+a)}return r!==!1&&this._onChangeCallback(),this}setFromAxisAngle(t,r){let n=r/2,i=Math.sin(n);return this._x=t.x*i,this._y=t.y*i,this._z=t.z*i,this._w=Math.cos(n),this._onChangeCallback(),this}setFromRotationMatrix(t){let r=t.elements,n=r[0],i=r[4],o=r[8],a=r[1],s=r[5],l=r[9],c=r[2],u=r[6],h=r[10],f=n+s+h;if(f>0){let p=.5/Math.sqrt(f+1);this._w=.25/p,this._x=(u-l)*p,this._y=(o-c)*p,this._z=(a-i)*p}else if(n>s&&n>h){let p=2*Math.sqrt(1+n-s-h);this._w=(u-l)/p,this._x=.25*p,this._y=(i+a)/p,this._z=(o+c)/p}else if(s>h){let p=2*Math.sqrt(1+s-n-h);this._w=(o-c)/p,this._x=(i+a)/p,this._y=.25*p,this._z=(l+u)/p}else{let p=2*Math.sqrt(1+h-n-s);this._w=(a-i)/p,this._x=(o+c)/p,this._y=(l+u)/p,this._z=.25*p}return this._onChangeCallback(),this}setFromUnitVectors(t,r){let n=t.dot(r)+1;return n<Number.EPSILON?(n=0,Math.abs(t.x)>Math.abs(t.z)?(this._x=-t.y,this._y=t.x,this._z=0,this._w=n):(this._x=0,this._y=-t.z,this._z=t.y,this._w=n)):(this._x=t.y*r.z-t.z*r.y,this._y=t.z*r.x-t.x*r.z,this._z=t.x*r.y-t.y*r.x,this._w=n),this.normalize()}angleTo(t){return 2*Math.acos(Math.abs(Zo(this.dot(t),-1,1)))}rotateTowards(t,r){let n=this.angleTo(t);if(n===0)return this;let i=Math.min(1,r/n);return this.slerp(t,i),this}identity(){return this.set(0,0,0,1)}invert(){return this.conjugate()}conjugate(){return this._x*=-1,this._y*=-1,this._z*=-1,this._onChangeCallback(),this}dot(t){return this._x*t._x+this._y*t._y+this._z*t._z+this._w*t._w}lengthSq(){return this._x*this._x+this._y*this._y+this._z*this._z+this._w*this._w}length(){return Math.sqrt(this._x*this._x+this._y*this._y+this._z*this._z+this._w*this._w)}normalize(){let t=this.length();return t===0?(this._x=0,this._y=0,this._z=0,this._w=1):(t=1/t,this._x=this._x*t,this._y=this._y*t,this._z=this._z*t,this._w=this._w*t),this._onChangeCallback(),this}multiply(t,r){return r!==void 0?(console.warn("THREE.Quaternion: .multiply() now only accepts one argument. Use .multiplyQuaternions( a, b ) instead."),this.multiplyQuaternions(t,r)):this.multiplyQuaternions(this,t)}premultiply(t){return this.multiplyQuaternions(t,this)}multiplyQuaternions(t,r){let n=t._x,i=t._y,o=t._z,a=t._w,s=r._x,l=r._y,c=r._z,u=r._w;return this._x=n*u+a*s+i*c-o*l,this._y=i*u+a*l+o*s-n*c,this._z=o*u+a*c+n*l-i*s,this._w=a*u-n*s-i*l-o*c,this._onChangeCallback(),this}slerp(t,r){if(r===0)return this;if(r===1)return this.copy(t);let n=this._x,i=this._y,o=this._z,a=this._w,s=a*t._w+n*t._x+i*t._y+o*t._z;if(s<0?(this._w=-t._w,this._x=-t._x,this._y=-t._y,this._z=-t._z,s=-s):this.copy(t),s>=1)return this._w=a,this._x=n,this._y=i,this._z=o,this;let l=1-s*s;if(l<=Number.EPSILON){let p=1-r;return this._w=p*a+r*this._w,this._x=p*n+r*this._x,this._y=p*i+r*this._y,this._z=p*o+r*this._z,this.normalize(),this._onChangeCallback(),this}let c=Math.sqrt(l),u=Math.atan2(c,s),h=Math.sin((1-r)*u)/c,f=Math.sin(r*u)/c;return this._w=a*h+this._w*f,this._x=n*h+this._x*f,this._y=i*h+this._y*f,this._z=o*h+this._z*f,this._onChangeCallback(),this}slerpQuaternions(t,r,n){return this.copy(t).slerp(r,n)}random(){let t=Math.random(),r=Math.sqrt(1-t),n=Math.sqrt(t),i=2*Math.PI*Math.random(),o=2*Math.PI*Math.random();return this.set(r*Math.cos(i),n*Math.sin(o),n*Math.cos(o),r*Math.sin(i))}equals(t){return t._x===this._x&&t._y===this._y&&t._z===this._z&&t._w===this._w}fromArray(t,r=0){return this._x=t[r],this._y=t[r+1],this._z=t[r+2],this._w=t[r+3],this._onChangeCallback(),this}toArray(t=[],r=0){return t[r]=this._x,t[r+1]=this._y,t[r+2]=this._z,t[r+3]=this._w,t}fromBufferAttribute(t,r){return this._x=t.getX(r),this._y=t.getY(r),this._z=t.getZ(r),this._w=t.getW(r),this}_onChange(t){return this._onChangeCallback=t,this}_onChangeCallback(){}};yi.prototype.isQuaternion=!0;var j=class{constructor(t=0,r=0,n=0){this.x=t,this.y=r,this.z=n}set(t,r,n){return n===void 0&&(n=this.z),this.x=t,this.y=r,this.z=n,this}setScalar(t){return this.x=t,this.y=t,this.z=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setZ(t){return this.z=t,this}setComponent(t,r){switch(t){case 0:this.x=r;break;case 1:this.y=r;break;case 2:this.z=r;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;case 2:return this.z;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y,this.z)}copy(t){return this.x=t.x,this.y=t.y,this.z=t.z,this}add(t,r){return r!==void 0?(console.warn("THREE.Vector3: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(t,r)):(this.x+=t.x,this.y+=t.y,this.z+=t.z,this)}addScalar(t){return this.x+=t,this.y+=t,this.z+=t,this}addVectors(t,r){return this.x=t.x+r.x,this.y=t.y+r.y,this.z=t.z+r.z,this}addScaledVector(t,r){return this.x+=t.x*r,this.y+=t.y*r,this.z+=t.z*r,this}sub(t,r){return r!==void 0?(console.warn("THREE.Vector3: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),this.subVectors(t,r)):(this.x-=t.x,this.y-=t.y,this.z-=t.z,this)}subScalar(t){return this.x-=t,this.y-=t,this.z-=t,this}subVectors(t,r){return this.x=t.x-r.x,this.y=t.y-r.y,this.z=t.z-r.z,this}multiply(t,r){return r!==void 0?(console.warn("THREE.Vector3: .multiply() now only accepts one argument. Use .multiplyVectors( a, b ) instead."),this.multiplyVectors(t,r)):(this.x*=t.x,this.y*=t.y,this.z*=t.z,this)}multiplyScalar(t){return this.x*=t,this.y*=t,this.z*=t,this}multiplyVectors(t,r){return this.x=t.x*r.x,this.y=t.y*r.y,this.z=t.z*r.z,this}applyEuler(t){return t&&t.isEuler||console.error("THREE.Vector3: .applyEuler() now expects an Euler rotation rather than a Vector3 and order."),this.applyQuaternion(yue.setFromEuler(t))}applyAxisAngle(t,r){return this.applyQuaternion(yue.setFromAxisAngle(t,r))}applyMatrix3(t){let r=this.x,n=this.y,i=this.z,o=t.elements;return this.x=o[0]*r+o[3]*n+o[6]*i,this.y=o[1]*r+o[4]*n+o[7]*i,this.z=o[2]*r+o[5]*n+o[8]*i,this}applyNormalMatrix(t){return this.applyMatrix3(t).normalize()}applyMatrix4(t){let r=this.x,n=this.y,i=this.z,o=t.elements,a=1/(o[3]*r+o[7]*n+o[11]*i+o[15]);return this.x=(o[0]*r+o[4]*n+o[8]*i+o[12])*a,this.y=(o[1]*r+o[5]*n+o[9]*i+o[13])*a,this.z=(o[2]*r+o[6]*n+o[10]*i+o[14])*a,this}applyQuaternion(t){let r=this.x,n=this.y,i=this.z,o=t.x,a=t.y,s=t.z,l=t.w,c=l*r+a*i-s*n,u=l*n+s*r-o*i,h=l*i+o*n-a*r,f=-o*r-a*n-s*i;return this.x=c*l+f*-o+u*-s-h*-a,this.y=u*l+f*-a+h*-o-c*-s,this.z=h*l+f*-s+c*-a-u*-o,this}project(t){return this.applyMatrix4(t.matrixWorldInverse).applyMatrix4(t.projectionMatrix)}unproject(t){return this.applyMatrix4(t.projectionMatrixInverse).applyMatrix4(t.matrixWorld)}transformDirection(t){let r=this.x,n=this.y,i=this.z,o=t.elements;return this.x=o[0]*r+o[4]*n+o[8]*i,this.y=o[1]*r+o[5]*n+o[9]*i,this.z=o[2]*r+o[6]*n+o[10]*i,this.normalize()}divide(t){return this.x/=t.x,this.y/=t.y,this.z/=t.z,this}divideScalar(t){return this.multiplyScalar(1/t)}min(t){return this.x=Math.min(this.x,t.x),this.y=Math.min(this.y,t.y),this.z=Math.min(this.z,t.z),this}max(t){return this.x=Math.max(this.x,t.x),this.y=Math.max(this.y,t.y),this.z=Math.max(this.z,t.z),this}clamp(t,r){return this.x=Math.max(t.x,Math.min(r.x,this.x)),this.y=Math.max(t.y,Math.min(r.y,this.y)),this.z=Math.max(t.z,Math.min(r.z,this.z)),this}clampScalar(t,r){return this.x=Math.max(t,Math.min(r,this.x)),this.y=Math.max(t,Math.min(r,this.y)),this.z=Math.max(t,Math.min(r,this.z)),this}clampLength(t,r){let n=this.length();return this.divideScalar(n||1).multiplyScalar(Math.max(t,Math.min(r,n)))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this.z=Math.floor(this.z),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this.z=Math.ceil(this.z),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this.z=Math.round(this.z),this}roundToZero(){return this.x=this.x<0?Math.ceil(this.x):Math.floor(this.x),this.y=this.y<0?Math.ceil(this.y):Math.floor(this.y),this.z=this.z<0?Math.ceil(this.z):Math.floor(this.z),this}negate(){return this.x=-this.x,this.y=-this.y,this.z=-this.z,this}dot(t){return this.x*t.x+this.y*t.y+this.z*t.z}lengthSq(){return this.x*this.x+this.y*this.y+this.z*this.z}length(){return Math.sqrt(this.x*this.x+this.y*this.y+this.z*this.z)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)+Math.abs(this.z)}normalize(){return this.divideScalar(this.length()||1)}setLength(t){return this.normalize().multiplyScalar(t)}lerp(t,r){return this.x+=(t.x-this.x)*r,this.y+=(t.y-this.y)*r,this.z+=(t.z-this.z)*r,this}lerpVectors(t,r,n){return this.x=t.x+(r.x-t.x)*n,this.y=t.y+(r.y-t.y)*n,this.z=t.z+(r.z-t.z)*n,this}cross(t,r){return r!==void 0?(console.warn("THREE.Vector3: .cross() now only accepts one argument. Use .crossVectors( a, b ) instead."),this.crossVectors(t,r)):this.crossVectors(this,t)}crossVectors(t,r){let n=t.x,i=t.y,o=t.z,a=r.x,s=r.y,l=r.z;return this.x=i*l-o*s,this.y=o*a-n*l,this.z=n*s-i*a,this}projectOnVector(t){let r=t.lengthSq();if(r===0)return this.set(0,0,0);let n=t.dot(this)/r;return this.copy(t).multiplyScalar(n)}projectOnPlane(t){return jct.copy(this).projectOnVector(t),this.sub(jct)}reflect(t){return this.sub(jct.copy(t).multiplyScalar(2*this.dot(t)))}angleTo(t){let r=Math.sqrt(this.lengthSq()*t.lengthSq());if(r===0)return Math.PI/2;let n=this.dot(t)/r;return Math.acos(Zo(n,-1,1))}distanceTo(t){return Math.sqrt(this.distanceToSquared(t))}distanceToSquared(t){let r=this.x-t.x,n=this.y-t.y,i=this.z-t.z;return r*r+n*n+i*i}manhattanDistanceTo(t){return Math.abs(this.x-t.x)+Math.abs(this.y-t.y)+Math.abs(this.z-t.z)}setFromSpherical(t){return this.setFromSphericalCoords(t.radius,t.phi,t.theta)}setFromSphericalCoords(t,r,n){let i=Math.sin(r)*t;return this.x=i*Math.sin(n),this.y=Math.cos(r)*t,this.z=i*Math.cos(n),this}setFromCylindrical(t){return this.setFromCylindricalCoords(t.radius,t.theta,t.y)}setFromCylindricalCoords(t,r,n){return this.x=t*Math.sin(r),this.y=n,this.z=t*Math.cos(r),this}setFromMatrixPosition(t){let r=t.elements;return this.x=r[12],this.y=r[13],this.z=r[14],this}setFromMatrixScale(t){let r=this.setFromMatrixColumn(t,0).length(),n=this.setFromMatrixColumn(t,1).length(),i=this.setFromMatrixColumn(t,2).length();return this.x=r,this.y=n,this.z=i,this}setFromMatrixColumn(t,r){return this.fromArray(t.elements,r*4)}setFromMatrix3Column(t,r){return this.fromArray(t.elements,r*3)}equals(t){return t.x===this.x&&t.y===this.y&&t.z===this.z}fromArray(t,r=0){return this.x=t[r],this.y=t[r+1],this.z=t[r+2],this}toArray(t=[],r=0){return t[r]=this.x,t[r+1]=this.y,t[r+2]=this.z,t}fromBufferAttribute(t,r,n){return n!==void 0&&console.warn("THREE.Vector3: offset has been removed from .fromBufferAttribute()."),this.x=t.getX(r),this.y=t.getY(r),this.z=t.getZ(r),this}random(){return this.x=Math.random(),this.y=Math.random(),this.z=Math.random(),this}randomDirection(){let t=(Math.random()-.5)*2,r=Math.random()*Math.PI*2,n=Math.sqrt(1-TI(t,2));return this.x=n*Math.cos(r),this.y=n*Math.sin(r),this.z=t,this}*[Symbol.iterator](){yield this.x,yield this.y,yield this.z}};j.prototype.isVector3=!0;var jct=new j,yue=new yi,ta=class{constructor(t=new j(1/0,1/0,1/0),r=new j(-1/0,-1/0,-1/0)){this.min=t,this.max=r}set(t,r){return this.min.copy(t),this.max.copy(r),this}setFromArray(t){let r=1/0,n=1/0,i=1/0,o=-1/0,a=-1/0,s=-1/0;for(let l=0,c=t.length;l<c;l+=3){let u=t[l],h=t[l+1],f=t[l+2];u<r&&(r=u),h<n&&(n=h),f<i&&(i=f),u>o&&(o=u),h>a&&(a=h),f>s&&(s=f)}return this.min.set(r,n,i),this.max.set(o,a,s),this}setFromBufferAttribute(t){let r=1/0,n=1/0,i=1/0,o=-1/0,a=-1/0,s=-1/0;for(let l=0,c=t.count;l<c;l++){let u=t.getX(l),h=t.getY(l),f=t.getZ(l);u<r&&(r=u),h<n&&(n=h),f<i&&(i=f),u>o&&(o=u),h>a&&(a=h),f>s&&(s=f)}return this.min.set(r,n,i),this.max.set(o,a,s),this}setFromPoints(t){this.makeEmpty();for(let r=0,n=t.length;r<n;r++)this.expandByPoint(t[r]);return this}setFromCenterAndSize(t,r){let n=m1.copy(r).multiplyScalar(.5);return this.min.copy(t).sub(n),this.max.copy(t).add(n),this}setFromObject(t,r=!1){return this.makeEmpty(),this.expandByObject(t,r)}clone(){return new this.constructor().copy(this)}copy(t){return this.min.copy(t.min),this.max.copy(t.max),this}makeEmpty(){return this.min.x=this.min.y=this.min.z=1/0,this.max.x=this.max.y=this.max.z=-1/0,this}isEmpty(){return this.max.x<this.min.x||this.max.y<this.min.y||this.max.z<this.min.z}getCenter(t){return this.isEmpty()?t.set(0,0,0):t.addVectors(this.min,this.max).multiplyScalar(.5)}getSize(t){return this.isEmpty()?t.set(0,0,0):t.subVectors(this.max,this.min)}expandByPoint(t){return this.min.min(t),this.max.max(t),this}expandByVector(t){return this.min.sub(t),this.max.add(t),this}expandByScalar(t){return this.min.addScalar(-t),this.max.addScalar(t),this}expandByObject(t,r=!1){t.updateWorldMatrix(!1,!1);let n=t.geometry;if(n!==void 0)if(r&&n.attributes!=null&&n.attributes.position!==void 0){let o=n.attributes.position;for(let a=0,s=o.count;a<s;a++)m1.fromBufferAttribute(o,a).applyMatrix4(t.matrixWorld),this.expandByPoint(m1)}else n.boundingBox===null&&n.computeBoundingBox(),Xct.copy(n.boundingBox),Xct.applyMatrix4(t.matrixWorld),this.union(Xct);let i=t.children;for(let o=0,a=i.length;o<a;o++)this.expandByObject(i[o],r);return this}containsPoint(t){return!(t.x<this.min.x||t.x>this.max.x||t.y<this.min.y||t.y>this.max.y||t.z<this.min.z||t.z>this.max.z)}containsBox(t){return this.min.x<=t.min.x&&t.max.x<=this.max.x&&this.min.y<=t.min.y&&t.max.y<=this.max.y&&this.min.z<=t.min.z&&t.max.z<=this.max.z}getParameter(t,r){return r.set((t.x-this.min.x)/(this.max.x-this.min.x),(t.y-this.min.y)/(this.max.y-this.min.y),(t.z-this.min.z)/(this.max.z-this.min.z))}intersectsBox(t){return!(t.max.x<this.min.x||t.min.x>this.max.x||t.max.y<this.min.y||t.min.y>this.max.y||t.max.z<this.min.z||t.min.z>this.max.z)}intersectsSphere(t){return this.clampPoint(t.center,m1),m1.distanceToSquared(t.center)<=t.radius*t.radius}intersectsPlane(t){let r,n;return t.normal.x>0?(r=t.normal.x*this.min.x,n=t.normal.x*this.max.x):(r=t.normal.x*this.max.x,n=t.normal.x*this.min.x),t.normal.y>0?(r+=t.normal.y*this.min.y,n+=t.normal.y*this.max.y):(r+=t.normal.y*this.max.y,n+=t.normal.y*this.min.y),t.normal.z>0?(r+=t.normal.z*this.min.z,n+=t.normal.z*this.max.z):(r+=t.normal.z*this.max.z,n+=t.normal.z*this.min.z),r<=-t.constant&&n>=-t.constant}intersectsTriangle(t){if(this.isEmpty())return!1;this.getCenter(LP),fV.subVectors(this.max,LP),x3.subVectors(t.a,LP),b3.subVectors(t.b,LP),w3.subVectors(t.c,LP),P0.subVectors(b3,x3),I0.subVectors(w3,b3),g1.subVectors(x3,w3);let r=[0,-P0.z,P0.y,0,-I0.z,I0.y,0,-g1.z,g1.y,P0.z,0,-P0.x,I0.z,0,-I0.x,g1.z,0,-g1.x,-P0.y,P0.x,0,-I0.y,I0.x,0,-g1.y,g1.x,0];return!$ct(r,x3,b3,w3,fV)||(r=[1,0,0,0,1,0,0,0,1],!$ct(r,x3,b3,w3,fV))?!1:(pV.crossVectors(P0,I0),r=[pV.x,pV.y,pV.z],$ct(r,x3,b3,w3,fV))}clampPoint(t,r){return r.copy(t).clamp(this.min,this.max)}distanceToPoint(t){return m1.copy(t).clamp(this.min,this.max).sub(t).length()}getBoundingSphere(t){return this.getCenter(t.center),t.radius=this.getSize(m1).length()*.5,t}intersect(t){return this.min.max(t.min),this.max.min(t.max),this.isEmpty()&&this.makeEmpty(),this}union(t){return this.min.min(t.min),this.max.max(t.max),this}applyMatrix4(t){return this.isEmpty()?this:(Vd[0].set(this.min.x,this.min.y,this.min.z).applyMatrix4(t),Vd[1].set(this.min.x,this.min.y,this.max.z).applyMatrix4(t),Vd[2].set(this.min.x,this.max.y,this.min.z).applyMatrix4(t),Vd[3].set(this.min.x,this.max.y,this.max.z).applyMatrix4(t),Vd[4].set(this.max.x,this.min.y,this.min.z).applyMatrix4(t),Vd[5].set(this.max.x,this.min.y,this.max.z).applyMatrix4(t),Vd[6].set(this.max.x,this.max.y,this.min.z).applyMatrix4(t),Vd[7].set(this.max.x,this.max.y,this.max.z).applyMatrix4(t),this.setFromPoints(Vd),this)}translate(t){return this.min.add(t),this.max.add(t),this}equals(t){return t.min.equals(this.min)&&t.max.equals(this.max)}};ta.prototype.isBox3=!0;var Vd=[new j,new j,new j,new j,new j,new j,new j,new j],m1=new j,Xct=new ta,x3=new j,b3=new j,w3=new j,P0=new j,I0=new j,g1=new j,LP=new j,fV=new j,pV=new j,_1=new j;function $ct(e,t,r,n,i){for(let o=0,a=e.length-3;o<=a;o+=3){_1.fromArray(e,o);let s=i.x*Math.abs(_1.x)+i.y*Math.abs(_1.y)+i.z*Math.abs(_1.z),l=t.dot(_1),c=r.dot(_1),u=n.dot(_1);if(Math.max(-Math.max(l,c,u),Math.min(l,c,u))>s)return!1}return!0}var sfr=new ta,vue=new j,dV=new j,Kct=new j,Zf=class{constructor(t=new j,r=-1){this.center=t,this.radius=r}set(t,r){return this.center.copy(t),this.radius=r,this}setFromPoints(t,r){let n=this.center;r!==void 0?n.copy(r):sfr.setFromPoints(t).getCenter(n);let i=0;for(let o=0,a=t.length;o<a;o++)i=Math.max(i,n.distanceToSquared(t[o]));return this.radius=Math.sqrt(i),this}copy(t){return this.center.copy(t.center),this.radius=t.radius,this}isEmpty(){return this.radius<0}makeEmpty(){return this.center.set(0,0,0),this.radius=-1,this}containsPoint(t){return t.distanceToSquared(this.center)<=this.radius*this.radius}distanceToPoint(t){return t.distanceTo(this.center)-this.radius}intersectsSphere(t){let r=this.radius+t.radius;return t.center.distanceToSquared(this.center)<=r*r}intersectsBox(t){return t.intersectsSphere(this)}intersectsPlane(t){return Math.abs(t.distanceToPoint(this.center))<=this.radius}clampPoint(t,r){let n=this.center.distanceToSquared(t);return r.copy(t),n>this.radius*this.radius&&(r.sub(this.center).normalize(),r.multiplyScalar(this.radius).add(this.center)),r}getBoundingBox(t){return this.isEmpty()?(t.makeEmpty(),t):(t.set(this.center,this.center),t.expandByScalar(this.radius),t)}applyMatrix4(t){return this.center.applyMatrix4(t),this.radius=this.radius*t.getMaxScaleOnAxis(),this}translate(t){return this.center.add(t),this}expandByPoint(t){Kct.subVectors(t,this.center);let r=Kct.lengthSq();if(r>this.radius*this.radius){let n=Math.sqrt(r),i=(n-this.radius)*.5;this.center.add(Kct.multiplyScalar(i/n)),this.radius+=i}return this}union(t){return this.center.equals(t.center)===!0?dV.set(0,0,1).multiplyScalar(t.radius):dV.subVectors(t.center,this.center).normalize().multiplyScalar(t.radius),this.expandByPoint(vue.copy(t.center).add(dV)),this.expandByPoint(vue.copy(t.center).sub(dV)),this}equals(t){return t.center.equals(this.center)&&t.radius===this.radius}clone(){return new this.constructor().copy(this)}},Ud=new j,Zct=new j,mV=new j,L0=new j,Jct=new j,gV=new j,Qct=new j,Jf=class{constructor(t=new j,r=new j(0,0,-1)){this.origin=t,this.direction=r}set(t,r){return this.origin.copy(t),this.direction.copy(r),this}copy(t){return this.origin.copy(t.origin),this.direction.copy(t.direction),this}at(t,r){return r.copy(this.direction).multiplyScalar(t).add(this.origin)}lookAt(t){return this.direction.copy(t).sub(this.origin).normalize(),this}recast(t){return this.origin.copy(this.at(t,Ud)),this}closestPointToPoint(t,r){r.subVectors(t,this.origin);let n=r.dot(this.direction);return n<0?r.copy(this.origin):r.copy(this.direction).multiplyScalar(n).add(this.origin)}distanceToPoint(t){return Math.sqrt(this.distanceSqToPoint(t))}distanceSqToPoint(t){let r=Ud.subVectors(t,this.origin).dot(this.direction);return r<0?this.origin.distanceToSquared(t):(Ud.copy(this.direction).multiplyScalar(r).add(this.origin),Ud.distanceToSquared(t))}distanceSqToSegment(t,r,n,i){Zct.copy(t).add(r).multiplyScalar(.5),mV.copy(r).sub(t).normalize(),L0.copy(this.origin).sub(Zct);let o=t.distanceTo(r)*.5,a=-this.direction.dot(mV),s=L0.dot(this.direction),l=-L0.dot(mV),c=L0.lengthSq(),u=Math.abs(1-a*a),h,f,p,d;if(u>0)if(h=a*l-s,f=a*s-l,d=o*u,h>=0)if(f>=-d)if(f<=d){let g=1/u;h*=g,f*=g,p=h*(h+a*f+2*s)+f*(a*h+f+2*l)+c}else f=o,h=Math.max(0,-(a*f+s)),p=-h*h+f*(f+2*l)+c;else f=-o,h=Math.max(0,-(a*f+s)),p=-h*h+f*(f+2*l)+c;else f<=-d?(h=Math.max(0,-(-a*o+s)),f=h>0?-o:Math.min(Math.max(-o,-l),o),p=-h*h+f*(f+2*l)+c):f<=d?(h=0,f=Math.min(Math.max(-o,-l),o),p=f*(f+2*l)+c):(h=Math.max(0,-(a*o+s)),f=h>0?o:Math.min(Math.max(-o,-l),o),p=-h*h+f*(f+2*l)+c);else f=a>0?-o:o,h=Math.max(0,-(a*f+s)),p=-h*h+f*(f+2*l)+c;return n&&n.copy(this.direction).multiplyScalar(h).add(this.origin),i&&i.copy(mV).multiplyScalar(f).add(Zct),p}intersectSphere(t,r){Ud.subVectors(t.center,this.origin);let n=Ud.dot(this.direction),i=Ud.dot(Ud)-n*n,o=t.radius*t.radius;if(i>o)return null;let a=Math.sqrt(o-i),s=n-a,l=n+a;return s<0&&l<0?null:s<0?this.at(l,r):this.at(s,r)}intersectsSphere(t){return this.distanceSqToPoint(t.center)<=t.radius*t.radius}distanceToPlane(t){let r=t.normal.dot(this.direction);if(r===0)return t.distanceToPoint(this.origin)===0?0:null;let n=-(this.origin.dot(t.normal)+t.constant)/r;return n>=0?n:null}intersectPlane(t,r){let n=this.distanceToPlane(t);return n===null?null:this.at(n,r)}intersectsPlane(t){let r=t.distanceToPoint(this.origin);return r===0||t.normal.dot(this.direction)*r<0}intersectBox(t,r){let n,i,o,a,s,l,c=1/this.direction.x,u=1/this.direction.y,h=1/this.direction.z,f=this.origin;return c>=0?(n=(t.min.x-f.x)*c,i=(t.max.x-f.x)*c):(n=(t.max.x-f.x)*c,i=(t.min.x-f.x)*c),u>=0?(o=(t.min.y-f.y)*u,a=(t.max.y-f.y)*u):(o=(t.max.y-f.y)*u,a=(t.min.y-f.y)*u),n>a||o>i||((o>n||n!==n)&&(n=o),(a<i||i!==i)&&(i=a),h>=0?(s=(t.min.z-f.z)*h,l=(t.max.z-f.z)*h):(s=(t.max.z-f.z)*h,l=(t.min.z-f.z)*h),n>l||s>i)||((s>n||n!==n)&&(n=s),(l<i||i!==i)&&(i=l),i<0)?null:this.at(n>=0?n:i,r)}intersectsBox(t){return this.intersectBox(t,Ud)!==null}intersectTriangle(t,r,n,i,o){Jct.subVectors(r,t),gV.subVectors(n,t),Qct.crossVectors(Jct,gV);let a=this.direction.dot(Qct),s;if(a>0){if(i)return null;s=1}else if(a<0)s=-1,a=-a;else return null;L0.subVectors(this.origin,t);let l=s*this.direction.dot(gV.crossVectors(L0,gV));if(l<0)return null;let c=s*this.direction.dot(Jct.cross(L0));if(c<0||l+c>a)return null;let u=-s*L0.dot(Qct);return u<0?null:this.at(u/a,o)}applyMatrix4(t){return this.origin.applyMatrix4(t),this.direction.transformDirection(t),this}equals(t){return t.origin.equals(this.origin)&&t.direction.equals(this.direction)}clone(){return new this.constructor().copy(this)}},Me=class{constructor(){this.elements=[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1],arguments.length>0&&console.error("THREE.Matrix4: the constructor no longer reads arguments. use .set() instead.")}set(t,r,n,i,o,a,s,l,c,u,h,f,p,d,g,_){let y=this.elements;return y[0]=t,y[4]=r,y[8]=n,y[12]=i,y[1]=o,y[5]=a,y[9]=s,y[13]=l,y[2]=c,y[6]=u,y[10]=h,y[14]=f,y[3]=p,y[7]=d,y[11]=g,y[15]=_,this}identity(){return this.set(1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1),this}clone(){return new Me().fromArray(this.elements)}copy(t){let r=this.elements,n=t.elements;return r[0]=n[0],r[1]=n[1],r[2]=n[2],r[3]=n[3],r[4]=n[4],r[5]=n[5],r[6]=n[6],r[7]=n[7],r[8]=n[8],r[9]=n[9],r[10]=n[10],r[11]=n[11],r[12]=n[12],r[13]=n[13],r[14]=n[14],r[15]=n[15],this}copyPosition(t){let r=this.elements,n=t.elements;return r[12]=n[12],r[13]=n[13],r[14]=n[14],this}setFromMatrix3(t){let r=t.elements;return this.set(r[0],r[3],r[6],0,r[1],r[4],r[7],0,r[2],r[5],r[8],0,0,0,0,1),this}extractBasis(t,r,n){return t.setFromMatrixColumn(this,0),r.setFromMatrixColumn(this,1),n.setFromMatrixColumn(this,2),this}makeBasis(t,r,n){return this.set(t.x,r.x,n.x,0,t.y,r.y,n.y,0,t.z,r.z,n.z,0,0,0,0,1),this}extractRotation(t){let r=this.elements,n=t.elements,i=1/S3.setFromMatrixColumn(t,0).length(),o=1/S3.setFromMatrixColumn(t,1).length(),a=1/S3.setFromMatrixColumn(t,2).length();return r[0]=n[0]*i,r[1]=n[1]*i,r[2]=n[2]*i,r[3]=0,r[4]=n[4]*o,r[5]=n[5]*o,r[6]=n[6]*o,r[7]=0,r[8]=n[8]*a,r[9]=n[9]*a,r[10]=n[10]*a,r[11]=0,r[12]=0,r[13]=0,r[14]=0,r[15]=1,this}makeRotationFromEuler(t){t&&t.isEuler||console.error("THREE.Matrix4: .makeRotationFromEuler() now expects a Euler rotation rather than a Vector3 and order.");let r=this.elements,n=t.x,i=t.y,o=t.z,a=Math.cos(n),s=Math.sin(n),l=Math.cos(i),c=Math.sin(i),u=Math.cos(o),h=Math.sin(o);if(t.order==="XYZ"){let f=a*u,p=a*h,d=s*u,g=s*h;r[0]=l*u,r[4]=-l*h,r[8]=c,r[1]=p+d*c,r[5]=f-g*c,r[9]=-s*l,r[2]=g-f*c,r[6]=d+p*c,r[10]=a*l}else if(t.order==="YXZ"){let f=l*u,p=l*h,d=c*u,g=c*h;r[0]=f+g*s,r[4]=d*s-p,r[8]=a*c,r[1]=a*h,r[5]=a*u,r[9]=-s,r[2]=p*s-d,r[6]=g+f*s,r[10]=a*l}else if(t.order==="ZXY"){let f=l*u,p=l*h,d=c*u,g=c*h;r[0]=f-g*s,r[4]=-a*h,r[8]=d+p*s,r[1]=p+d*s,r[5]=a*u,r[9]=g-f*s,r[2]=-a*c,r[6]=s,r[10]=a*l}else if(t.order==="ZYX"){let f=a*u,p=a*h,d=s*u,g=s*h;r[0]=l*u,r[4]=d*c-p,r[8]=f*c+g,r[1]=l*h,r[5]=g*c+f,r[9]=p*c-d,r[2]=-c,r[6]=s*l,r[10]=a*l}else if(t.order==="YZX"){let f=a*l,p=a*c,d=s*l,g=s*c;r[0]=l*u,r[4]=g-f*h,r[8]=d*h+p,r[1]=h,r[5]=a*u,r[9]=-s*u,r[2]=-c*u,r[6]=p*h+d,r[10]=f-g*h}else if(t.order==="XZY"){let f=a*l,p=a*c,d=s*l,g=s*c;r[0]=l*u,r[4]=-h,r[8]=c*u,r[1]=f*h+g,r[5]=a*u,r[9]=p*h-d,r[2]=d*h-p,r[6]=s*u,r[10]=g*h+f}return r[3]=0,r[7]=0,r[11]=0,r[12]=0,r[13]=0,r[14]=0,r[15]=1,this}makeRotationFromQuaternion(t){return this.compose(lfr,t,cfr)}lookAt(t,r,n){let i=this.elements;return kl.subVectors(t,r),kl.lengthSq()===0&&(kl.z=1),kl.normalize(),k0.crossVectors(n,kl),k0.lengthSq()===0&&(Math.abs(n.z)===1?kl.x+=1e-4:kl.z+=1e-4,kl.normalize(),k0.crossVectors(n,kl)),k0.normalize(),_V.crossVectors(kl,k0),i[0]=k0.x,i[4]=_V.x,i[8]=kl.x,i[1]=k0.y,i[5]=_V.y,i[9]=kl.y,i[2]=k0.z,i[6]=_V.z,i[10]=kl.z,this}multiply(t,r){return r!==void 0?(console.warn("THREE.Matrix4: .multiply() now only accepts one argument. Use .multiplyMatrices( a, b ) instead."),this.multiplyMatrices(t,r)):this.multiplyMatrices(this,t)}premultiply(t){return this.multiplyMatrices(t,this)}multiplyMatrices(t,r){let n=t.elements,i=r.elements,o=this.elements,a=n[0],s=n[4],l=n[8],c=n[12],u=n[1],h=n[5],f=n[9],p=n[13],d=n[2],g=n[6],_=n[10],y=n[14],x=n[3],b=n[7],S=n[11],C=n[15],P=i[0],k=i[4],O=i[8],D=i[12],B=i[1],I=i[5],L=i[9],R=i[13],F=i[2],z=i[6],U=i[10],W=i[14],Z=i[3],rt=i[7],ot=i[11],st=i[15];return o[0]=a*P+s*B+l*F+c*Z,o[4]=a*k+s*I+l*z+c*rt,o[8]=a*O+s*L+l*U+c*ot,o[12]=a*D+s*R+l*W+c*st,o[1]=u*P+h*B+f*F+p*Z,o[5]=u*k+h*I+f*z+p*rt,o[9]=u*O+h*L+f*U+p*ot,o[13]=u*D+h*R+f*W+p*st,o[2]=d*P+g*B+_*F+y*Z,o[6]=d*k+g*I+_*z+y*rt,o[10]=d*O+g*L+_*U+y*ot,o[14]=d*D+g*R+_*W+y*st,o[3]=x*P+b*B+S*F+C*Z,o[7]=x*k+b*I+S*z+C*rt,o[11]=x*O+b*L+S*U+C*ot,o[15]=x*D+b*R+S*W+C*st,this}multiplyScalar(t){let r=this.elements;return r[0]*=t,r[4]*=t,r[8]*=t,r[12]*=t,r[1]*=t,r[5]*=t,r[9]*=t,r[13]*=t,r[2]*=t,r[6]*=t,r[10]*=t,r[14]*=t,r[3]*=t,r[7]*=t,r[11]*=t,r[15]*=t,this}determinant(){let t=this.elements,r=t[0],n=t[4],i=t[8],o=t[12],a=t[1],s=t[5],l=t[9],c=t[13],u=t[2],h=t[6],f=t[10],p=t[14],d=t[3],g=t[7],_=t[11],y=t[15];return d*(+o*l*h-i*c*h-o*s*f+n*c*f+i*s*p-n*l*p)+g*(+r*l*p-r*c*f+o*a*f-i*a*p+i*c*u-o*l*u)+_*(+r*c*h-r*s*p-o*a*h+n*a*p+o*s*u-n*c*u)+y*(-i*s*u-r*l*h+r*s*f+i*a*h-n*a*f+n*l*u)}transpose(){let t=this.elements,r;return r=t[1],t[1]=t[4],t[4]=r,r=t[2],t[2]=t[8],t[8]=r,r=t[6],t[6]=t[9],t[9]=r,r=t[3],t[3]=t[12],t[12]=r,r=t[7],t[7]=t[13],t[13]=r,r=t[11],t[11]=t[14],t[14]=r,this}setPosition(t,r,n){let i=this.elements;return t.isVector3?(i[12]=t.x,i[13]=t.y,i[14]=t.z):(i[12]=t,i[13]=r,i[14]=n),this}invert(){let t=this.elements,r=t[0],n=t[1],i=t[2],o=t[3],a=t[4],s=t[5],l=t[6],c=t[7],u=t[8],h=t[9],f=t[10],p=t[11],d=t[12],g=t[13],_=t[14],y=t[15],x=h*_*c-g*f*c+g*l*p-s*_*p-h*l*y+s*f*y,b=d*f*c-u*_*c-d*l*p+a*_*p+u*l*y-a*f*y,S=u*g*c-d*h*c+d*s*p-a*g*p-u*s*y+a*h*y,C=d*h*l-u*g*l-d*s*f+a*g*f+u*s*_-a*h*_,P=r*x+n*b+i*S+o*C;if(P===0)return this.set(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0);let k=1/P;return t[0]=x*k,t[1]=(g*f*o-h*_*o-g*i*p+n*_*p+h*i*y-n*f*y)*k,t[2]=(s*_*o-g*l*o+g*i*c-n*_*c-s*i*y+n*l*y)*k,t[3]=(h*l*o-s*f*o-h*i*c+n*f*c+s*i*p-n*l*p)*k,t[4]=b*k,t[5]=(u*_*o-d*f*o+d*i*p-r*_*p-u*i*y+r*f*y)*k,t[6]=(d*l*o-a*_*o-d*i*c+r*_*c+a*i*y-r*l*y)*k,t[7]=(a*f*o-u*l*o+u*i*c-r*f*c-a*i*p+r*l*p)*k,t[8]=S*k,t[9]=(d*h*o-u*g*o-d*n*p+r*g*p+u*n*y-r*h*y)*k,t[10]=(a*g*o-d*s*o+d*n*c-r*g*c-a*n*y+r*s*y)*k,t[11]=(u*s*o-a*h*o-u*n*c+r*h*c+a*n*p-r*s*p)*k,t[12]=C*k,t[13]=(u*g*i-d*h*i+d*n*f-r*g*f-u*n*_+r*h*_)*k,t[14]=(d*s*i-a*g*i-d*n*l+r*g*l+a*n*_-r*s*_)*k,t[15]=(a*h*i-u*s*i+u*n*l-r*h*l-a*n*f+r*s*f)*k,this}scale(t){let r=this.elements,n=t.x,i=t.y,o=t.z;return r[0]*=n,r[4]*=i,r[8]*=o,r[1]*=n,r[5]*=i,r[9]*=o,r[2]*=n,r[6]*=i,r[10]*=o,r[3]*=n,r[7]*=i,r[11]*=o,this}getMaxScaleOnAxis(){let t=this.elements,r=t[0]*t[0]+t[1]*t[1]+t[2]*t[2],n=t[4]*t[4]+t[5]*t[5]+t[6]*t[6],i=t[8]*t[8]+t[9]*t[9]+t[10]*t[10];return Math.sqrt(Math.max(r,n,i))}makeTranslation(t,r,n){return this.set(1,0,0,t,0,1,0,r,0,0,1,n,0,0,0,1),this}makeRotationX(t){let r=Math.cos(t),n=Math.sin(t);return this.set(1,0,0,0,0,r,-n,0,0,n,r,0,0,0,0,1),this}makeRotationY(t){let r=Math.cos(t),n=Math.sin(t);return this.set(r,0,n,0,0,1,0,0,-n,0,r,0,0,0,0,1),this}makeRotationZ(t){let r=Math.cos(t),n=Math.sin(t);return this.set(r,-n,0,0,n,r,0,0,0,0,1,0,0,0,0,1),this}makeRotationAxis(t,r){let n=Math.cos(r),i=Math.sin(r),o=1-n,a=t.x,s=t.y,l=t.z,c=o*a,u=o*s;return this.set(c*a+n,c*s-i*l,c*l+i*s,0,c*s+i*l,u*s+n,u*l-i*a,0,c*l-i*s,u*l+i*a,o*l*l+n,0,0,0,0,1),this}makeScale(t,r,n){return this.set(t,0,0,0,0,r,0,0,0,0,n,0,0,0,0,1),this}makeShear(t,r,n,i,o,a){return this.set(1,n,o,0,t,1,a,0,r,i,1,0,0,0,0,1),this}compose(t,r,n){let i=this.elements,o=r._x,a=r._y,s=r._z,l=r._w,c=o+o,u=a+a,h=s+s,f=o*c,p=o*u,d=o*h,g=a*u,_=a*h,y=s*h,x=l*c,b=l*u,S=l*h,C=n.x,P=n.y,k=n.z;return i[0]=(1-(g+y))*C,i[1]=(p+S)*C,i[2]=(d-b)*C,i[3]=0,i[4]=(p-S)*P,i[5]=(1-(f+y))*P,i[6]=(_+x)*P,i[7]=0,i[8]=(d+b)*k,i[9]=(_-x)*k,i[10]=(1-(f+g))*k,i[11]=0,i[12]=t.x,i[13]=t.y,i[14]=t.z,i[15]=1,this}decompose(t,r,n){let i=this.elements,o=S3.set(i[0],i[1],i[2]).length(),a=S3.set(i[4],i[5],i[6]).length(),s=S3.set(i[8],i[9],i[10]).length();this.determinant()<0&&(o=-o),t.x=i[12],t.y=i[13],t.z=i[14],ih.copy(this);let c=1/o,u=1/a,h=1/s;return ih.elements[0]*=c,ih.elements[1]*=c,ih.elements[2]*=c,ih.elements[4]*=u,ih.elements[5]*=u,ih.elements[6]*=u,ih.elements[8]*=h,ih.elements[9]*=h,ih.elements[10]*=h,r.setFromRotationMatrix(ih),n.x=o,n.y=a,n.z=s,this}makePerspective(t,r,n,i,o,a){a===void 0&&console.warn("THREE.Matrix4: .makePerspective() has been redefined and has a new signature. Please check the docs.");let s=this.elements,l=2*o/(r-t),c=2*o/(n-i),u=(r+t)/(r-t),h=(n+i)/(n-i),f=-(a+o)/(a-o),p=-2*a*o/(a-o);return s[0]=l,s[4]=0,s[8]=u,s[12]=0,s[1]=0,s[5]=c,s[9]=h,s[13]=0,s[2]=0,s[6]=0,s[10]=f,s[14]=p,s[3]=0,s[7]=0,s[11]=-1,s[15]=0,this}makeOrthographic(t,r,n,i,o,a){let s=this.elements,l=1/(r-t),c=1/(n-i),u=1/(a-o),h=(r+t)*l,f=(n+i)*c,p=(a+o)*u;return s[0]=2*l,s[4]=0,s[8]=0,s[12]=-h,s[1]=0,s[5]=2*c,s[9]=0,s[13]=-f,s[2]=0,s[6]=0,s[10]=-2*u,s[14]=-p,s[3]=0,s[7]=0,s[11]=0,s[15]=1,this}equals(t){let r=this.elements,n=t.elements;for(let i=0;i<16;i++)if(r[i]!==n[i])return!1;return!0}fromArray(t,r=0){for(let n=0;n<16;n++)this.elements[n]=t[n+r];return this}toArray(t=[],r=0){let n=this.elements;return t[r]=n[0],t[r+1]=n[1],t[r+2]=n[2],t[r+3]=n[3],t[r+4]=n[4],t[r+5]=n[5],t[r+6]=n[6],t[r+7]=n[7],t[r+8]=n[8],t[r+9]=n[9],t[r+10]=n[10],t[r+11]=n[11],t[r+12]=n[12],t[r+13]=n[13],t[r+14]=n[14],t[r+15]=n[15],t}};Me.prototype.isMatrix4=!0;var S3=new j,ih=new Me,lfr=new j(0,0,0),cfr=new j(1,1,1),k0=new j,_V=new j,kl=new j,xue=new Me,bue=new yi,tm=class{constructor(t=0,r=0,n=0,i=tm.DefaultOrder){this._x=t,this._y=r,this._z=n,this._order=i}get x(){return this._x}set x(t){this._x=t,this._onChangeCallback()}get y(){return this._y}set y(t){this._y=t,this._onChangeCallback()}get z(){return this._z}set z(t){this._z=t,this._onChangeCallback()}get order(){return this._order}set order(t){this._order=t,this._onChangeCallback()}set(t,r,n,i=this._order){return this._x=t,this._y=r,this._z=n,this._order=i,this._onChangeCallback(),this}clone(){return new this.constructor(this._x,this._y,this._z,this._order)}copy(t){return this._x=t._x,this._y=t._y,this._z=t._z,this._order=t._order,this._onChangeCallback(),this}setFromRotationMatrix(t,r=this._order,n=!0){let i=t.elements,o=i[0],a=i[4],s=i[8],l=i[1],c=i[5],u=i[9],h=i[2],f=i[6],p=i[10];switch(r){case"XYZ":this._y=Math.asin(Zo(s,-1,1)),Math.abs(s)<.9999999?(this._x=Math.atan2(-u,p),this._z=Math.atan2(-a,o)):(this._x=Math.atan2(f,c),this._z=0);break;case"YXZ":this._x=Math.asin(-Zo(u,-1,1)),Math.abs(u)<.9999999?(this._y=Math.atan2(s,p),this._z=Math.atan2(l,c)):(this._y=Math.atan2(-h,o),this._z=0);break;case"ZXY":this._x=Math.asin(Zo(f,-1,1)),Math.abs(f)<.9999999?(this._y=Math.atan2(-h,p),this._z=Math.atan2(-a,c)):(this._y=0,this._z=Math.atan2(l,o));break;case"ZYX":this._y=Math.asin(-Zo(h,-1,1)),Math.abs(h)<.9999999?(this._x=Math.atan2(f,p),this._z=Math.atan2(l,o)):(this._x=0,this._z=Math.atan2(-a,c));break;case"YZX":this._z=Math.asin(Zo(l,-1,1)),Math.abs(l)<.9999999?(this._x=Math.atan2(-u,c),this._y=Math.atan2(-h,o)):(this._x=0,this._y=Math.atan2(s,p));break;case"XZY":this._z=Math.asin(-Zo(a,-1,1)),Math.abs(a)<.9999999?(this._x=Math.atan2(f,c),this._y=Math.atan2(s,o)):(this._x=Math.atan2(-u,p),this._y=0);break;default:console.warn("THREE.Euler: .setFromRotationMatrix() encountered an unknown order: "+r)}return this._order=r,n===!0&&this._onChangeCallback(),this}setFromQuaternion(t,r,n){return xue.makeRotationFromQuaternion(t),this.setFromRotationMatrix(xue,r,n)}setFromVector3(t,r=this._order){return this.set(t.x,t.y,t.z,r)}reorder(t){return bue.setFromEuler(this),this.setFromQuaternion(bue,t)}equals(t){return t._x===this._x&&t._y===this._y&&t._z===this._z&&t._order===this._order}fromArray(t){return this._x=t[0],this._y=t[1],this._z=t[2],t[3]!==void 0&&(this._order=t[3]),this._onChangeCallback(),this}toArray(t=[],r=0){return t[r]=this._x,t[r+1]=this._y,t[r+2]=this._z,t[r+3]=this._order,t}toVector3(t){return t?t.set(this._x,this._y,this._z):new j(this._x,this._y,this._z)}_onChange(t){return this._onChangeCallback=t,this}_onChangeCallback(){}};tm.prototype.isEuler=!0;tm.DefaultOrder="XYZ";tm.RotationOrders=["XYZ","YZX","ZXY","XZY","YXZ","ZYX"];var X3=class{constructor(){this.mask=1}set(t){this.mask=(1<<t|0)>>>0}enable(t){this.mask|=1<<t|0}enableAll(){this.mask=-1}toggle(t){this.mask^=1<<t|0}disable(t){this.mask&=~(1<<t|0)}disableAll(){this.mask=0}test(t){return(this.mask&t.mask)!==0}isEnabled(t){return(this.mask&(1<<t|0))!==0}},ufr=0,wue=new j,M3=new yi,qd=new Me,yV=new j,kP=new j,hfr=new j,ffr=new yi,Sue=new j(1,0,0),Mue=new j(0,1,0),Eue=new j(0,0,1),pfr={type:"added"},Tue={type:"removed"},or=class extends Us{constructor(){super(),Object.defineProperty(this,"id",{value:ufr++}),this.uuid=Nl(),this.name="",this.type="Object3D",this.parent=null,this.children=[],this.up=or.DefaultUp.clone();let t=new j,r=new tm,n=new yi,i=new j(1,1,1);function o(){n.setFromEuler(r,!1)}function a(){r.setFromQuaternion(n,void 0,!1)}r._onChange(o),n._onChange(a),Object.defineProperties(this,{position:{configurable:!0,enumerable:!0,value:t},rotation:{configurable:!0,enumerable:!0,value:r},quaternion:{configurable:!0,enumerable:!0,value:n},scale:{configurable:!0,enumerable:!0,value:i},modelViewMatrix:{value:new Me},normalMatrix:{value:new ki}}),this.matrix=new Me,this.matrixWorld=new Me,this.matrixAutoUpdate=or.DefaultMatrixAutoUpdate,this.matrixWorldNeedsUpdate=!1,this.layers=new X3,this.visible=!0,this.castShadow=!1,this.receiveShadow=!1,this.frustumCulled=!0,this.renderOrder=0,this.animations=[],this.userData={}}onBeforeRender(){}onAfterRender(){}applyMatrix4(t){this.matrixAutoUpdate&&this.updateMatrix(),this.matrix.premultiply(t),this.matrix.decompose(this.position,this.quaternion,this.scale)}applyQuaternion(t){return this.quaternion.premultiply(t),this}setRotationFromAxisAngle(t,r){this.quaternion.setFromAxisAngle(t,r)}setRotationFromEuler(t){this.quaternion.setFromEuler(t,!0)}setRotationFromMatrix(t){this.quaternion.setFromRotationMatrix(t)}setRotationFromQuaternion(t){this.quaternion.copy(t)}rotateOnAxis(t,r){return M3.setFromAxisAngle(t,r),this.quaternion.multiply(M3),this}rotateOnWorldAxis(t,r){return M3.setFromAxisAngle(t,r),this.quaternion.premultiply(M3),this}rotateX(t){return this.rotateOnAxis(Sue,t)}rotateY(t){return this.rotateOnAxis(Mue,t)}rotateZ(t){return this.rotateOnAxis(Eue,t)}translateOnAxis(t,r){return wue.copy(t).applyQuaternion(this.quaternion),this.position.add(wue.multiplyScalar(r)),this}translateX(t){return this.translateOnAxis(Sue,t)}translateY(t){return this.translateOnAxis(Mue,t)}translateZ(t){return this.translateOnAxis(Eue,t)}localToWorld(t){return t.applyMatrix4(this.matrixWorld)}worldToLocal(t){return t.applyMatrix4(qd.copy(this.matrixWorld).invert())}lookAt(t,r,n){t.isVector3?yV.copy(t):yV.set(t,r,n);let i=this.parent;this.updateWorldMatrix(!0,!1),kP.setFromMatrixPosition(this.matrixWorld),this.isCamera||this.isLight?qd.lookAt(kP,yV,this.up):qd.lookAt(yV,kP,this.up),this.quaternion.setFromRotationMatrix(qd),i&&(qd.extractRotation(i.matrixWorld),M3.setFromRotationMatrix(qd),this.quaternion.premultiply(M3.invert()))}add(t){if(arguments.length>1){for(let r=0;r<arguments.length;r++)this.add(arguments[r]);return this}return t===this?(console.error("THREE.Object3D.add: object can't be added as a child of itself.",t),this):(t&&t.isObject3D?(t.parent!==null&&t.parent.remove(t),t.parent=this,this.children.push(t),t.dispatchEvent(pfr)):console.error("THREE.Object3D.add: object not an instance of THREE.Object3D.",t),this)}remove(t){if(arguments.length>1){for(let n=0;n<arguments.length;n++)this.remove(arguments[n]);return this}let r=this.children.indexOf(t);return r!==-1&&(t.parent=null,this.children.splice(r,1),t.dispatchEvent(Tue)),this}removeFromParent(){let t=this.parent;return t!==null&&t.remove(this),this}clear(){for(let t=0;t<this.children.length;t++){let r=this.children[t];r.parent=null,r.dispatchEvent(Tue)}return this.children.length=0,this}attach(t){return this.updateWorldMatrix(!0,!1),qd.copy(this.matrixWorld).invert(),t.parent!==null&&(t.parent.updateWorldMatrix(!0,!1),qd.multiply(t.parent.matrixWorld)),t.applyMatrix4(qd),this.add(t),t.updateWorldMatrix(!1,!0),this}getObjectById(t){return this.getObjectByProperty("id",t)}getObjectByName(t){return this.getObjectByProperty("name",t)}getObjectByProperty(t,r){if(this[t]===r)return this;for(let n=0,i=this.children.length;n<i;n++){let a=this.children[n].getObjectByProperty(t,r);if(a!==void 0)return a}}getWorldPosition(t){return this.updateWorldMatrix(!0,!1),t.setFromMatrixPosition(this.matrixWorld)}getWorldQuaternion(t){return this.updateWorldMatrix(!0,!1),this.matrixWorld.decompose(kP,t,hfr),t}getWorldScale(t){return this.updateWorldMatrix(!0,!1),this.matrixWorld.decompose(kP,ffr,t),t}getWorldDirection(t){this.updateWorldMatrix(!0,!1);let r=this.matrixWorld.elements;return t.set(r[8],r[9],r[10]).normalize()}raycast(){}traverse(t){t(this);let r=this.children;for(let n=0,i=r.length;n<i;n++)r[n].traverse(t)}traverseVisible(t){if(this.visible===!1)return;t(this);let r=this.children;for(let n=0,i=r.length;n<i;n++)r[n].traverseVisible(t)}traverseAncestors(t){let r=this.parent;r!==null&&(t(r),r.traverseAncestors(t))}updateMatrix(){this.matrix.compose(this.position,this.quaternion,this.scale),this.matrixWorldNeedsUpdate=!0}updateMatrixWorld(t){this.matrixAutoUpdate&&this.updateMatrix(),(this.matrixWorldNeedsUpdate||t)&&(this.parent===null?this.matrixWorld.copy(this.matrix):this.matrixWorld.multiplyMatrices(this.parent.matrixWorld,this.matrix),this.matrixWorldNeedsUpdate=!1,t=!0);let r=this.children;for(let n=0,i=r.length;n<i;n++)r[n].updateMatrixWorld(t)}updateWorldMatrix(t,r){let n=this.parent;if(t===!0&&n!==null&&n.updateWorldMatrix(!0,!1),this.matrixAutoUpdate&&this.updateMatrix(),this.parent===null?this.matrixWorld.copy(this.matrix):this.matrixWorld.multiplyMatrices(this.parent.matrixWorld,this.matrix),r===!0){let i=this.children;for(let o=0,a=i.length;o<a;o++)i[o].updateWorldMatrix(!1,!0)}}toJSON(t){let r=t===void 0||typeof t=="string",n={};r&&(t={geometries:{},materials:{},textures:{},images:{},shapes:{},skeletons:{},animations:{}},n.metadata={version:4.5,type:"Object",generator:"Object3D.toJSON"});let i={};i.uuid=this.uuid,i.type=this.type,this.name!==""&&(i.name=this.name),this.castShadow===!0&&(i.castShadow=!0),this.receiveShadow===!0&&(i.receiveShadow=!0),this.visible===!1&&(i.visible=!1),this.frustumCulled===!1&&(i.frustumCulled=!1),this.renderOrder!==0&&(i.renderOrder=this.renderOrder),JSON.stringify(this.userData)!=="{}"&&(i.userData=this.userData),i.layers=this.layers.mask,i.matrix=this.matrix.toArray(),this.matrixAutoUpdate===!1&&(i.matrixAutoUpdate=!1),this.isInstancedMesh&&(i.type="InstancedMesh",i.count=this.count,i.instanceMatrix=this.instanceMatrix.toJSON(),this.instanceColor!==null&&(i.instanceColor=this.instanceColor.toJSON()));function o(s,l){return s[l.uuid]===void 0&&(s[l.uuid]=l.toJSON(t)),l.uuid}if(this.isScene)this.background&&(this.background.isColor?i.background=this.background.toJSON():this.background.isTexture&&(i.background=this.background.toJSON(t).uuid)),this.environment&&this.environment.isTexture&&(i.environment=this.environment.toJSON(t).uuid);else if(this.isMesh||this.isLine||this.isPoints){i.geometry=o(t.geometries,this.geometry);let s=this.geometry.parameters;if(s!==void 0&&s.shapes!==void 0){let l=s.shapes;if(Array.isArray(l))for(let c=0,u=l.length;c<u;c++){let h=l[c];o(t.shapes,h)}else o(t.shapes,l)}}if(this.isSkinnedMesh&&(i.bindMode=this.bindMode,i.bindMatrix=this.bindMatrix.toArray(),this.skeleton!==void 0&&(o(t.skeletons,this.skeleton),i.skeleton=this.skeleton.uuid)),this.material!==void 0)if(Array.isArray(this.material)){let s=[];for(let l=0,c=this.material.length;l<c;l++)s.push(o(t.materials,this.material[l]));i.material=s}else i.material=o(t.materials,this.material);if(this.children.length>0){i.children=[];for(let s=0;s<this.children.length;s++)i.children.push(this.children[s].toJSON(t).object)}if(this.animations.length>0){i.animations=[];for(let s=0;s<this.animations.length;s++){let l=this.animations[s];i.animations.push(o(t.animations,l))}}if(r){let s=a(t.geometries),l=a(t.materials),c=a(t.textures),u=a(t.images),h=a(t.shapes),f=a(t.skeletons),p=a(t.animations);s.length>0&&(n.geometries=s),l.length>0&&(n.materials=l),c.length>0&&(n.textures=c),u.length>0&&(n.images=u),h.length>0&&(n.shapes=h),f.length>0&&(n.skeletons=f),p.length>0&&(n.animations=p)}return n.object=i,n;function a(s){let l=[];for(let c in s){let u=s[c];delete u.metadata,l.push(u)}return l}}clone(t){return new this.constructor().copy(this,t)}copy(t,r=!0){if(this.name=t.name,this.up.copy(t.up),this.position.copy(t.position),this.rotation.order=t.rotation.order,this.quaternion.copy(t.quaternion),this.scale.copy(t.scale),this.matrix.copy(t.matrix),this.matrixWorld.copy(t.matrixWorld),this.matrixAutoUpdate=t.matrixAutoUpdate,this.matrixWorldNeedsUpdate=t.matrixWorldNeedsUpdate,this.layers.mask=t.layers.mask,this.visible=t.visible,this.castShadow=t.castShadow,this.receiveShadow=t.receiveShadow,this.frustumCulled=t.frustumCulled,this.renderOrder=t.renderOrder,this.userData=JSON.parse(JSON.stringify(t.userData)),r===!0)for(let n=0;n<t.children.length;n++){let i=t.children[n];this.add(i.clone())}return this}};or.DefaultUp=new j(0,1,0);or.DefaultMatrixAutoUpdate=!0;or.prototype.isObject3D=!0;var oh=new j,Gd=new j,tut=new j,Wd=new j,E3=new j,T3=new j,Cue=new j,eut=new j,rut=new j,nut=new j,oi=class{constructor(t=new j,r=new j,n=new j){this.a=t,this.b=r,this.c=n}static getNormal(t,r,n,i){i.subVectors(n,r),oh.subVectors(t,r),i.cross(oh);let o=i.lengthSq();return o>0?i.multiplyScalar(1/Math.sqrt(o)):i.set(0,0,0)}static getBarycoord(t,r,n,i,o){oh.subVectors(i,r),Gd.subVectors(n,r),tut.subVectors(t,r);let a=oh.dot(oh),s=oh.dot(Gd),l=oh.dot(tut),c=Gd.dot(Gd),u=Gd.dot(tut),h=a*c-s*s;if(h===0)return o.set(-2,-1,-1);let f=1/h,p=(c*l-s*u)*f,d=(a*u-s*l)*f;return o.set(1-p-d,d,p)}static containsPoint(t,r,n,i){return this.getBarycoord(t,r,n,i,Wd),Wd.x>=0&&Wd.y>=0&&Wd.x+Wd.y<=1}static getUV(t,r,n,i,o,a,s,l){return this.getBarycoord(t,r,n,i,Wd),l.set(0,0),l.addScaledVector(o,Wd.x),l.addScaledVector(a,Wd.y),l.addScaledVector(s,Wd.z),l}static isFrontFacing(t,r,n,i){return oh.subVectors(n,r),Gd.subVectors(t,r),oh.cross(Gd).dot(i)<0}set(t,r,n){return this.a.copy(t),this.b.copy(r),this.c.copy(n),this}setFromPointsAndIndices(t,r,n,i){return this.a.copy(t[r]),this.b.copy(t[n]),this.c.copy(t[i]),this}setFromAttributeAndIndices(t,r,n,i){return this.a.fromBufferAttribute(t,r),this.b.fromBufferAttribute(t,n),this.c.fromBufferAttribute(t,i),this}clone(){return new this.constructor().copy(this)}copy(t){return this.a.copy(t.a),this.b.copy(t.b),this.c.copy(t.c),this}getArea(){return oh.subVectors(this.c,this.b),Gd.subVectors(this.a,this.b),oh.cross(Gd).length()*.5}getMidpoint(t){return t.addVectors(this.a,this.b).add(this.c).multiplyScalar(1/3)}getNormal(t){return oi.getNormal(this.a,this.b,this.c,t)}getPlane(t){return t.setFromCoplanarPoints(this.a,this.b,this.c)}getBarycoord(t,r){return oi.getBarycoord(t,this.a,this.b,this.c,r)}getUV(t,r,n,i,o){return oi.getUV(t,this.a,this.b,this.c,r,n,i,o)}containsPoint(t){return oi.containsPoint(t,this.a,this.b,this.c)}isFrontFacing(t){return oi.isFrontFacing(this.a,this.b,this.c,t)}intersectsBox(t){return t.intersectsTriangle(this)}closestPointToPoint(t,r){let n=this.a,i=this.b,o=this.c,a,s;E3.subVectors(i,n),T3.subVectors(o,n),eut.subVectors(t,n);let l=E3.dot(eut),c=T3.dot(eut);if(l<=0&&c<=0)return r.copy(n);rut.subVectors(t,i);let u=E3.dot(rut),h=T3.dot(rut);if(u>=0&&h<=u)return r.copy(i);let f=l*h-u*c;if(f<=0&&l>=0&&u<=0)return a=l/(l-u),r.copy(n).addScaledVector(E3,a);nut.subVectors(t,o);let p=E3.dot(nut),d=T3.dot(nut);if(d>=0&&p<=d)return r.copy(o);let g=p*c-l*d;if(g<=0&&c>=0&&d<=0)return s=c/(c-d),r.copy(n).addScaledVector(T3,s);let _=u*d-p*h;if(_<=0&&h-u>=0&&p-d>=0)return Cue.subVectors(o,i),s=(h-u)/(h-u+(p-d)),r.copy(i).addScaledVector(Cue,s);let y=1/(_+g+f);return a=g*y,s=f*y,r.copy(n).addScaledVector(E3,a).addScaledVector(T3,s)}equals(t){return t.a.equals(this.a)&&t.b.equals(this.b)&&t.c.equals(this.c)}},dfr=0,qi=class extends Us{constructor(){super(),Object.defineProperty(this,"id",{value:dfr++}),this.uuid=Nl(),this.name="",this.type="Material",this.fog=!0,this.blending=V3,this.side=I1,this.vertexColors=!1,this.opacity=1,this.transparent=!1,this.blendSrc=Pht,this.blendDst=Iht,this.blendEquation=M1,this.blendSrcAlpha=null,this.blendDstAlpha=null,this.blendEquationAlpha=null,this.depthFunc=iU,this.depthTest=!0,this.depthWrite=!0,this.stencilWriteMask=255,this.stencilFunc=Ofe,this.stencilRef=0,this.stencilFuncMask=255,this.stencilFail=nU,this.stencilZFail=nU,this.stencilZPass=nU,this.stencilWrite=!1,this.clippingPlanes=null,this.clipIntersection=!1,this.clipShadows=!1,this.shadowSide=null,this.colorWrite=!0,this.alphaWrite=!0,this.precision=null,this.polygonOffset=!1,this.polygonOffsetFactor=0,this.polygonOffsetUnits=0,this.dithering=!1,this.alphaToCoverage=!1,this.premultipliedAlpha=!1,this.visible=!0,this.toneMapped=!0,this.userData={},this.version=0,this._alphaTest=0}get alphaTest(){return this._alphaTest}set alphaTest(t){this._alphaTest>0!=t>0&&this.version++,this._alphaTest=t}onBuild(){}onBeforeRender(){}onBeforeCompile(){}customProgramCacheKey(){return this.onBeforeCompile.toString()}setValues(t){if(t!==void 0)for(let r in t){let n=t[r];if(n===void 0){console.warn("THREE.Material: '"+r+"' parameter is undefined.");continue}if(r==="shading"){console.warn("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead."),this.flatShading=n===Aht;continue}let i=this[r];if(i===void 0){console.warn("THREE."+this.type+": '"+r+"' is not a property of this material.");continue}i&&i.isColor?i.set(n):i&&i.isVector3&&n&&n.isVector3?i.copy(n):this[r]=n}}toJSON(t){let r=t===void 0||typeof t=="string";r&&(t={textures:{},images:{}});let n={metadata:{version:4.5,type:"Material",generator:"Material.toJSON"}};n.uuid=this.uuid,n.type=this.type,this.name!==""&&(n.name=this.name),this.color&&this.color.isColor&&(n.color=this.color.getHex()),this.roughness!==void 0&&(n.roughness=this.roughness),this.metalness!==void 0&&(n.metalness=this.metalness),this.sheen!==void 0&&(n.sheen=this.sheen),this.sheenColor&&this.sheenColor.isColor&&(n.sheenColor=this.sheenColor.getHex()),this.sheenRoughness!==void 0&&(n.sheenRoughness=this.sheenRoughness),this.emissive&&this.emissive.isColor&&(n.emissive=this.emissive.getHex()),this.emissiveIntensity&&this.emissiveIntensity!==1&&(n.emissiveIntensity=this.emissiveIntensity),this.specular&&this.specular.isColor&&(n.specular=this.specular.getHex()),this.specularIntensity!==void 0&&(n.specularIntensity=this.specularIntensity),this.specularColor&&this.specularColor.isColor&&(n.specularColor=this.specularColor.getHex()),this.shininess!==void 0&&(n.shininess=this.shininess),this.clearcoat!==void 0&&(n.clearcoat=this.clearcoat),this.clearcoatRoughness!==void 0&&(n.clearcoatRoughness=this.clearcoatRoughness),this.clearcoatMap&&this.clearcoatMap.isTexture&&(n.clearcoatMap=this.clearcoatMap.toJSON(t).uuid),this.clearcoatRoughnessMap&&this.clearcoatRoughnessMap.isTexture&&(n.clearcoatRoughnessMap=this.clearcoatRoughnessMap.toJSON(t).uuid),this.clearcoatNormalMap&&this.clearcoatNormalMap.isTexture&&(n.clearcoatNormalMap=this.clearcoatNormalMap.toJSON(t).uuid,n.clearcoatNormalScale=this.clearcoatNormalScale.toArray()),this.map&&this.map.isTexture&&(n.map=this.map.toJSON(t).uuid),this.matcap&&this.matcap.isTexture&&(n.matcap=this.matcap.toJSON(t).uuid),this.alphaMap&&this.alphaMap.isTexture&&(n.alphaMap=this.alphaMap.toJSON(t).uuid),this.lightMap&&this.lightMap.isTexture&&(n.lightMap=this.lightMap.toJSON(t).uuid,n.lightMapIntensity=this.lightMapIntensity),this.aoMap&&this.aoMap.isTexture&&(n.aoMap=this.aoMap.toJSON(t).uuid,n.aoMapIntensity=this.aoMapIntensity),this.bumpMap&&this.bumpMap.isTexture&&(n.bumpMap=this.bumpMap.toJSON(t).uuid,n.bumpScale=this.bumpScale),this.normalMap&&this.normalMap.isTexture&&(n.normalMap=this.normalMap.toJSON(t).uuid,n.normalMapType=this.normalMapType,n.normalScale=this.normalScale.toArray()),this.displacementMap&&this.displacementMap.isTexture&&(n.displacementMap=this.displacementMap.toJSON(t).uuid,n.displacementScale=this.displacementScale,n.displacementBias=this.displacementBias),this.roughnessMap&&this.roughnessMap.isTexture&&(n.roughnessMap=this.roughnessMap.toJSON(t).uuid),this.metalnessMap&&this.metalnessMap.isTexture&&(n.metalnessMap=this.metalnessMap.toJSON(t).uuid),this.emissiveMap&&this.emissiveMap.isTexture&&(n.emissiveMap=this.emissiveMap.toJSON(t).uuid),this.specularMap&&this.specularMap.isTexture&&(n.specularMap=this.specularMap.toJSON(t).uuid),this.specularIntensityMap&&this.specularIntensityMap.isTexture&&(n.specularIntensityMap=this.specularIntensityMap.toJSON(t).uuid),this.specularColorMap&&this.specularColorMap.isTexture&&(n.specularColorMap=this.specularColorMap.toJSON(t).uuid),this.envMap&&this.envMap.isTexture&&(n.envMap=this.envMap.toJSON(t).uuid,this.combine!==void 0&&(n.combine=this.combine)),this.envMapIntensity!==void 0&&(n.envMapIntensity=this.envMapIntensity),this.reflectivity!==void 0&&(n.reflectivity=this.reflectivity),this.refractionRatio!==void 0&&(n.refractionRatio=this.refractionRatio),this.gradientMap&&this.gradientMap.isTexture&&(n.gradientMap=this.gradientMap.toJSON(t).uuid),this.transmission!==void 0&&(n.transmission=this.transmission),this.transmissionMap&&this.transmissionMap.isTexture&&(n.transmissionMap=this.transmissionMap.toJSON(t).uuid),this.thickness!==void 0&&(n.thickness=this.thickness),this.thicknessMap&&this.thicknessMap.isTexture&&(n.thicknessMap=this.thicknessMap.toJSON(t).uuid),this.attenuationDistance!==void 0&&(n.attenuationDistance=this.attenuationDistance),this.attenuationColor!==void 0&&(n.attenuationColor=this.attenuationColor.getHex()),this.size!==void 0&&(n.size=this.size),this.shadowSide!==null&&(n.shadowSide=this.shadowSide),this.sizeAttenuation!==void 0&&(n.sizeAttenuation=this.sizeAttenuation),this.blending!==V3&&(n.blending=this.blending),this.side!==I1&&(n.side=this.side),this.vertexColors&&(n.vertexColors=!0),this.opacity<1&&(n.opacity=this.opacity),this.transparent===!0&&(n.transparent=this.transparent),n.depthFunc=this.depthFunc,n.depthTest=this.depthTest,n.depthWrite=this.depthWrite,n.colorWrite=this.colorWrite,n.alphaWrite=this.alphaWrite,n.stencilWrite=this.stencilWrite,n.stencilWriteMask=this.stencilWriteMask,n.stencilFunc=this.stencilFunc,n.stencilRef=this.stencilRef,n.stencilFuncMask=this.stencilFuncMask,n.stencilFail=this.stencilFail,n.stencilZFail=this.stencilZFail,n.stencilZPass=this.stencilZPass,this.rotation&&this.rotation!==0&&(n.rotation=this.rotation),this.polygonOffset===!0&&(n.polygonOffset=!0),this.polygonOffsetFactor!==0&&(n.polygonOffsetFactor=this.polygonOffsetFactor),this.polygonOffsetUnits!==0&&(n.polygonOffsetUnits=this.polygonOffsetUnits),this.linewidth&&this.linewidth!==1&&(n.linewidth=this.linewidth),this.dashSize!==void 0&&(n.dashSize=this.dashSize),this.gapSize!==void 0&&(n.gapSize=this.gapSize),this.scale!==void 0&&(n.scale=this.scale),this.dithering===!0&&(n.dithering=!0),this.alphaTest>0&&(n.alphaTest=this.alphaTest),this.alphaToCoverage===!0&&(n.alphaToCoverage=this.alphaToCoverage),this.premultipliedAlpha===!0&&(n.premultipliedAlpha=this.premultipliedAlpha),this.wireframe===!0&&(n.wireframe=this.wireframe),this.wireframeLinewidth>1&&(n.wireframeLinewidth=this.wireframeLinewidth),this.wireframeLinecap!=="round"&&(n.wireframeLinecap=this.wireframeLinecap),this.wireframeLinejoin!=="round"&&(n.wireframeLinejoin=this.wireframeLinejoin),this.flatShading===!0&&(n.flatShading=this.flatShading),this.visible===!1&&(n.visible=!1),this.toneMapped===!1&&(n.toneMapped=!1),JSON.stringify(this.userData)!=="{}"&&(n.userData=this.userData);function i(o){let a=[];for(let s in o){let l=o[s];delete l.metadata,a.push(l)}return a}if(r){let o=i(t.textures),a=i(t.images);o.length>0&&(n.textures=o),a.length>0&&(n.images=a)}return n}clone(){return new this.constructor().copy(this)}copy(t){this.name=t.name,this.fog=t.fog,this.blending=t.blending,this.side=t.side,this.vertexColors=t.vertexColors,this.opacity=t.opacity,this.transparent=t.transparent,this.blendSrc=t.blendSrc,this.blendDst=t.blendDst,this.blendEquation=t.blendEquation,this.blendSrcAlpha=t.blendSrcAlpha,this.blendDstAlpha=t.blendDstAlpha,this.blendEquationAlpha=t.blendEquationAlpha,this.depthFunc=t.depthFunc,this.depthTest=t.depthTest,this.depthWrite=t.depthWrite,this.stencilWriteMask=t.stencilWriteMask,this.stencilFunc=t.stencilFunc,this.stencilRef=t.stencilRef,this.stencilFuncMask=t.stencilFuncMask,this.stencilFail=t.stencilFail,this.stencilZFail=t.stencilZFail,this.stencilZPass=t.stencilZPass,this.stencilWrite=t.stencilWrite;let r=t.clippingPlanes,n=null;if(r!==null){let i=r.length;n=new Array(i);for(let o=0;o!==i;++o)n[o]=r[o].clone()}return this.clippingPlanes=n,this.clipIntersection=t.clipIntersection,this.clipShadows=t.clipShadows,this.shadowSide=t.shadowSide,this.colorWrite=t.colorWrite,this.alphaWrite=t.alphaWrite,this.precision=t.precision,this.polygonOffset=t.polygonOffset,this.polygonOffsetFactor=t.polygonOffsetFactor,this.polygonOffsetUnits=t.polygonOffsetUnits,this.dithering=t.dithering,this.alphaTest=t.alphaTest,this.alphaToCoverage=t.alphaToCoverage,this.premultipliedAlpha=t.premultipliedAlpha,this.visible=t.visible,this.toneMapped=t.toneMapped,this.userData=JSON.parse(JSON.stringify(t.userData)),this}dispose(){this.dispatchEvent({type:"dispose"})}set needsUpdate(t){t===!0&&this.version++}};qi.prototype.isMaterial=!0;var sh=class extends qi{constructor(t){super(),this.type="MeshBasicMaterial",this.color=new ne(16777215),this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.specularMap=null,this.alphaMap=null,this.envMap=null,this.combine=O6,this.reflectivity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.specularMap=t.specularMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.combine=t.combine,this.reflectivity=t.reflectivity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this}};sh.prototype.isMeshBasicMaterial=!0;var In=new j,vV=new Lt,Je=class{constructor(t,r,n){if(Array.isArray(t))throw new TypeError("THREE.BufferAttribute: array should be a Typed Array.");this.name="",this.array=t,this.itemSize=r,this.count=t!==void 0?t.length/r:0,this.normalized=n===!0,this.usage=W3,this.updateRange={offset:0,count:-1},this.version=0}onUploadCallback(){}set needsUpdate(t){t===!0&&this.version++}setUsage(t){return this.usage=t,this}copy(t){return this.name=t.name,this.array=new t.array.constructor(t.array),this.itemSize=t.itemSize,this.count=t.count,this.normalized=t.normalized,this.usage=t.usage,this}copyAt(t,r,n){t*=this.itemSize,n*=r.itemSize;for(let i=0,o=this.itemSize;i<o;i++)this.array[t+i]=r.array[n+i];return this}copyArray(t){return this.array.set(t),this}copyColorsArray(t){let r=this.array,n=0;for(let i=0,o=t.length;i<o;i++){let a=t[i];a===void 0&&(console.warn("THREE.BufferAttribute.copyColorsArray(): color is undefined",i),a=new ne),r[n++]=a.r,r[n++]=a.g,r[n++]=a.b}return this}copyVector2sArray(t){let r=this.array,n=0;for(let i=0,o=t.length;i<o;i++){let a=t[i];a===void 0&&(console.warn("THREE.BufferAttribute.copyVector2sArray(): vector is undefined",i),a=new Lt),r[n++]=a.x,r[n++]=a.y}return this}copyVector3sArray(t){let r=this.array,n=0;for(let i=0,o=t.length;i<o;i++){let a=t[i];a===void 0&&(console.warn("THREE.BufferAttribute.copyVector3sArray(): vector is undefined",i),a=new j),r[n++]=a.x,r[n++]=a.y,r[n++]=a.z}return this}copyVector4sArray(t){let r=this.array,n=0;for(let i=0,o=t.length;i<o;i++){let a=t[i];a===void 0&&(console.warn("THREE.BufferAttribute.copyVector4sArray(): vector is undefined",i),a=new en),r[n++]=a.x,r[n++]=a.y,r[n++]=a.z,r[n++]=a.w}return this}applyMatrix3(t){if(this.itemSize===2)for(let r=0,n=this.count;r<n;r++)vV.fromBufferAttribute(this,r),vV.applyMatrix3(t),this.setXY(r,vV.x,vV.y);else if(this.itemSize===3)for(let r=0,n=this.count;r<n;r++)In.fromBufferAttribute(this,r),In.applyMatrix3(t),this.setXYZ(r,In.x,In.y,In.z);return this}applyMatrix4(t){for(let r=0,n=this.count;r<n;r++)In.x=this.getX(r),In.y=this.getY(r),In.z=this.getZ(r),In.applyMatrix4(t),this.setXYZ(r,In.x,In.y,In.z);return this}applyNormalMatrix(t){for(let r=0,n=this.count;r<n;r++)In.x=this.getX(r),In.y=this.getY(r),In.z=this.getZ(r),In.applyNormalMatrix(t),this.setXYZ(r,In.x,In.y,In.z);return this}transformDirection(t){for(let r=0,n=this.count;r<n;r++)In.x=this.getX(r),In.y=this.getY(r),In.z=this.getZ(r),In.transformDirection(t),this.setXYZ(r,In.x,In.y,In.z);return this}set(t,r=0){return this.array.set(t,r),this}getX(t){return this.array[t*this.itemSize]}setX(t,r){return this.array[t*this.itemSize]=r,this}getY(t){return this.array[t*this.itemSize+1]}setY(t,r){return this.array[t*this.itemSize+1]=r,this}getZ(t){return this.array[t*this.itemSize+2]}setZ(t,r){return this.array[t*this.itemSize+2]=r,this}getW(t){return this.array[t*this.itemSize+3]}setW(t,r){return this.array[t*this.itemSize+3]=r,this}setXY(t,r,n){return t*=this.itemSize,this.array[t+0]=r,this.array[t+1]=n,this}setXYZ(t,r,n,i){return t*=this.itemSize,this.array[t+0]=r,this.array[t+1]=n,this.array[t+2]=i,this}setXYZW(t,r,n,i,o){return t*=this.itemSize,this.array[t+0]=r,this.array[t+1]=n,this.array[t+2]=i,this.array[t+3]=o,this}onUpload(t){return this.onUploadCallback=t,this}clone(){return new this.constructor(this.array,this.itemSize).copy(this)}toJSON(){let t={itemSize:this.itemSize,type:this.array.constructor.name,array:Array.prototype.slice.call(this.array),normalized:this.normalized};return this.name!==""&&(t.name=this.name),this.usage!==W3&&(t.usage=this.usage),(this.updateRange.offset!==0||this.updateRange.count!==-1)&&(t.updateRange=this.updateRange),t}};Je.prototype.isBufferAttribute=!0;var cU=class extends Je{constructor(t,r,n){super(new Int8Array(t),r,n)}},uU=class extends Je{constructor(t,r,n){super(new Uint8Array(t),r,n)}},hU=class extends Je{constructor(t,r,n){super(new Uint8ClampedArray(t),r,n)}},fU=class extends Je{constructor(t,r,n){super(new Int16Array(t),r,n)}},$3=class extends Je{constructor(t,r,n){super(new Uint16Array(t),r,n)}},pU=class extends Je{constructor(t,r,n){super(new Int32Array(t),r,n)}},K3=class extends Je{constructor(t,r,n){super(new Uint32Array(t),r,n)}},dU=class extends Je{constructor(t,r,n){super(new Uint16Array(t),r,n)}};dU.prototype.isFloat16BufferAttribute=!0;var xe=class extends Je{constructor(t,r,n){super(new Float32Array(t),r,n)}},mU=class extends Je{constructor(t,r,n){super(new Float64Array(t),r,n)}},mfr=0,Xc=new Me,iut=new or,C3=new j,Rl=new ta,RP=new ta,Lo=new j,Pe=class extends Us{constructor(){super(),Object.defineProperty(this,"id",{value:mfr++}),this.uuid=Nl(),this.name="",this.type="BufferGeometry",this.index=null,this.attributes={},this.morphAttributes={},this.morphTargetsRelative=!1,this.groups=[],this.boundingBox=null,this.boundingSphere=null,this.drawRange={start:0,count:1/0},this.userData={}}getIndex(){return this.index}setIndex(t){return Array.isArray(t)?this.index=new(Bfe(t)?K3:$3)(t,1):this.index=t,this}getAttribute(t){return this.attributes[t]}setAttribute(t,r){return this.attributes[t]=r,this}deleteAttribute(t){return delete this.attributes[t],this}hasAttribute(t){return this.attributes[t]!==void 0}addGroup(t,r,n=0){this.groups.push({start:t,count:r,materialIndex:n})}clearGroups(){this.groups=[]}setDrawRange(t,r){this.drawRange.start=t,this.drawRange.count=r}applyMatrix4(t){let r=this.attributes.position;r!==void 0&&(r.applyMatrix4(t),r.needsUpdate=!0);let n=this.attributes.normal;if(n!==void 0){let o=new ki().getNormalMatrix(t);n.applyNormalMatrix(o),n.needsUpdate=!0}let i=this.attributes.tangent;return i!==void 0&&(i.transformDirection(t),i.needsUpdate=!0),this.boundingBox!==null&&this.computeBoundingBox(),this.boundingSphere!==null&&this.computeBoundingSphere(),this}applyQuaternion(t){return Xc.makeRotationFromQuaternion(t),this.applyMatrix4(Xc),this}rotateX(t){return Xc.makeRotationX(t),this.applyMatrix4(Xc),this}rotateY(t){return Xc.makeRotationY(t),this.applyMatrix4(Xc),this}rotateZ(t){return Xc.makeRotationZ(t),this.applyMatrix4(Xc),this}translate(t,r,n){return Xc.makeTranslation(t,r,n),this.applyMatrix4(Xc),this}scale(t,r,n){return Xc.makeScale(t,r,n),this.applyMatrix4(Xc),this}lookAt(t){return iut.lookAt(t),iut.updateMatrix(),this.applyMatrix4(iut.matrix),this}center(){return this.computeBoundingBox(),this.boundingBox.getCenter(C3).negate(),this.translate(C3.x,C3.y,C3.z),this}setFromPoints(t){let r=[];for(let n=0,i=t.length;n<i;n++){let o=t[n];r.push(o.x,o.y,o.z||0)}return this.setAttribute("position",new xe(r,3)),this}computeBoundingBox(){this.boundingBox===null&&(this.boundingBox=new ta);let t=this.attributes.position,r=this.morphAttributes.position;if(t&&t.isGLBufferAttribute){console.error('THREE.BufferGeometry.computeBoundingBox(): GLBufferAttribute requires a manual bounding box. Alternatively set "mesh.frustumCulled" to "false".',this),this.boundingBox.set(new j(-1/0,-1/0,-1/0),new j(1/0,1/0,1/0));return}if(t!==void 0){if(this.boundingBox.setFromBufferAttribute(t),r)for(let n=0,i=r.length;n<i;n++){let o=r[n];Rl.setFromBufferAttribute(o),this.morphTargetsRelative?(Lo.addVectors(this.boundingBox.min,Rl.min),this.boundingBox.expandByPoint(Lo),Lo.addVectors(this.boundingBox.max,Rl.max),this.boundingBox.expandByPoint(Lo)):(this.boundingBox.expandByPoint(Rl.min),this.boundingBox.expandByPoint(Rl.max))}}else this.boundingBox.makeEmpty();(isNaN(this.boundingBox.min.x)||isNaN(this.boundingBox.min.y)||isNaN(this.boundingBox.min.z))&&console.error('THREE.BufferGeometry.computeBoundingBox(): Computed min/max have NaN values. The "position" attribute is likely to have NaN values.',this)}computeBoundingSphere(){this.boundingSphere===null&&(this.boundingSphere=new Zf);let t=this.attributes.position,r=this.morphAttributes.position;if(t&&t.isGLBufferAttribute){console.error('THREE.BufferGeometry.computeBoundingSphere(): GLBufferAttribute requires a manual bounding sphere. Alternatively set "mesh.frustumCulled" to "false".',this),this.boundingSphere.set(new j,1/0);return}if(t){let n=this.boundingSphere.center;if(Rl.setFromBufferAttribute(t),r)for(let o=0,a=r.length;o<a;o++){let s=r[o];RP.setFromBufferAttribute(s),this.morphTargetsRelative?(Lo.addVectors(Rl.min,RP.min),Rl.expandByPoint(Lo),Lo.addVectors(Rl.max,RP.max),Rl.expandByPoint(Lo)):(Rl.expandByPoint(RP.min),Rl.expandByPoint(RP.max))}Rl.getCenter(n);let i=0;for(let o=0,a=t.count;o<a;o++)Lo.fromBufferAttribute(t,o),i=Math.max(i,n.distanceToSquared(Lo));if(r)for(let o=0,a=r.length;o<a;o++){let s=r[o],l=this.morphTargetsRelative;for(let c=0,u=s.count;c<u;c++)Lo.fromBufferAttribute(s,c),l&&(C3.fromBufferAttribute(t,c),Lo.add(C3)),i=Math.max(i,n.distanceToSquared(Lo))}this.boundingSphere.radius=Math.sqrt(i),isNaN(this.boundingSphere.radius)&&console.error('THREE.BufferGeometry.computeBoundingSphere(): Computed radius is NaN. The "position" attribute is likely to have NaN values.',this)}}computeTangents(){let t=this.index,r=this.attributes;if(t===null||r.position===void 0||r.normal===void 0||r.uv===void 0){console.error("THREE.BufferGeometry: .computeTangents() failed. Missing required attributes (index, position, normal or uv)");return}let n=t.array,i=r.position.array,o=r.normal.array,a=r.uv.array,s=i.length/3;r.tangent===void 0&&this.setAttribute("tangent",new Je(new Float32Array(4*s),4));let l=r.tangent.array,c=[],u=[];for(let B=0;B<s;B++)c[B]=new j,u[B]=new j;let h=new j,f=new j,p=new j,d=new Lt,g=new Lt,_=new Lt,y=new j,x=new j;function b(B,I,L){h.fromArray(i,B*3),f.fromArray(i,I*3),p.fromArray(i,L*3),d.fromArray(a,B*2),g.fromArray(a,I*2),_.fromArray(a,L*2),f.sub(h),p.sub(h),g.sub(d),_.sub(d);let R=1/(g.x*_.y-_.x*g.y);!isFinite(R)||(y.copy(f).multiplyScalar(_.y).addScaledVector(p,-g.y).multiplyScalar(R),x.copy(p).multiplyScalar(g.x).addScaledVector(f,-_.x).multiplyScalar(R),c[B].add(y),c[I].add(y),c[L].add(y),u[B].add(x),u[I].add(x),u[L].add(x))}let S=this.groups;S.length===0&&(S=[{start:0,count:n.length}]);for(let B=0,I=S.length;B<I;++B){let L=S[B],R=L.start,F=L.count;for(let z=R,U=R+F;z<U;z+=3)b(n[z+0],n[z+1],n[z+2])}let C=new j,P=new j,k=new j,O=new j;function D(B){k.fromArray(o,B*3),O.copy(k);let I=c[B];C.copy(I),C.sub(k.multiplyScalar(k.dot(I))).normalize(),P.crossVectors(O,I);let R=P.dot(u[B])<0?-1:1;l[B*4]=C.x,l[B*4+1]=C.y,l[B*4+2]=C.z,l[B*4+3]=R}for(let B=0,I=S.length;B<I;++B){let L=S[B],R=L.start,F=L.count;for(let z=R,U=R+F;z<U;z+=3)D(n[z+0]),D(n[z+1]),D(n[z+2])}}computeVertexNormals(){let t=this.index,r=this.getAttribute("position");if(r!==void 0){let n=this.getAttribute("normal");if(n===void 0)n=new Je(new Float32Array(r.count*3),3),this.setAttribute("normal",n);else for(let f=0,p=n.count;f<p;f++)n.setXYZ(f,0,0,0);let i=new j,o=new j,a=new j,s=new j,l=new j,c=new j,u=new j,h=new j;if(t)for(let f=0,p=t.count;f<p;f+=3){let d=t.getX(f+0),g=t.getX(f+1),_=t.getX(f+2);i.fromBufferAttribute(r,d),o.fromBufferAttribute(r,g),a.fromBufferAttribute(r,_),u.subVectors(a,o),h.subVectors(i,o),u.cross(h),s.fromBufferAttribute(n,d),l.fromBufferAttribute(n,g),c.fromBufferAttribute(n,_),s.add(u),l.add(u),c.add(u),n.setXYZ(d,s.x,s.y,s.z),n.setXYZ(g,l.x,l.y,l.z),n.setXYZ(_,c.x,c.y,c.z)}else for(let f=0,p=r.count;f<p;f+=3)i.fromBufferAttribute(r,f+0),o.fromBufferAttribute(r,f+1),a.fromBufferAttribute(r,f+2),u.subVectors(a,o),h.subVectors(i,o),u.cross(h),n.setXYZ(f+0,u.x,u.y,u.z),n.setXYZ(f+1,u.x,u.y,u.z),n.setXYZ(f+2,u.x,u.y,u.z);this.normalizeNormals(),n.needsUpdate=!0}}merge(t,r){if(!(t&&t.isBufferGeometry)){console.error("THREE.BufferGeometry.merge(): geometry not an instance of THREE.BufferGeometry.",t);return}r===void 0&&(r=0,console.warn("THREE.BufferGeometry.merge(): Overwriting original geometry, starting at offset=0. Use BufferGeometryUtils.mergeBufferGeometries() for lossless merge."));let n=this.attributes;for(let i in n){if(t.attributes[i]===void 0)continue;let a=n[i].array,s=t.attributes[i],l=s.array,c=s.itemSize*r,u=Math.min(l.length,a.length-c);for(let h=0,f=c;h<u;h++,f++)a[f]=l[h]}return this}normalizeNormals(){let t=this.attributes.normal;for(let r=0,n=t.count;r<n;r++)Lo.fromBufferAttribute(t,r),Lo.normalize(),t.setXYZ(r,Lo.x,Lo.y,Lo.z)}toNonIndexed(){function t(s,l){let c=s.array,u=s.itemSize,h=s.normalized,f=new c.constructor(l.length*u),p=0,d=0;for(let g=0,_=l.length;g<_;g++){s.isInterleavedBufferAttribute?p=l[g]*s.data.stride+s.offset:p=l[g]*u;for(let y=0;y<u;y++)f[d++]=c[p++]}return new Je(f,u,h)}if(this.index===null)return console.warn("THREE.BufferGeometry.toNonIndexed(): BufferGeometry is already non-indexed."),this;let r=new Pe,n=this.index.array,i=this.attributes;for(let s in i){let l=i[s],c=t(l,n);r.setAttribute(s,c)}let o=this.morphAttributes;for(let s in o){let l=[],c=o[s];for(let u=0,h=c.length;u<h;u++){let f=c[u],p=t(f,n);l.push(p)}r.morphAttributes[s]=l}r.morphTargetsRelative=this.morphTargetsRelative;let a=this.groups;for(let s=0,l=a.length;s<l;s++){let c=a[s];r.addGroup(c.start,c.count,c.materialIndex)}return r}toJSON(){let t={metadata:{version:4.5,type:"BufferGeometry",generator:"BufferGeometry.toJSON"}};if(t.uuid=this.uuid,t.type=this.type,this.name!==""&&(t.name=this.name),Object.keys(this.userData).length>0&&(t.userData=this.userData),this.parameters!==void 0){let l=this.parameters;for(let c in l)l[c]!==void 0&&(t[c]=l[c]);return t}t.data={attributes:{}};let r=this.index;r!==null&&(t.data.index={type:r.array.constructor.name,array:Array.prototype.slice.call(r.array)});let n=this.attributes;for(let l in n){let c=n[l];t.data.attributes[l]=c.toJSON(t.data)}let i={},o=!1;for(let l in this.morphAttributes){let c=this.morphAttributes[l],u=[];for(let h=0,f=c.length;h<f;h++){let p=c[h];u.push(p.toJSON(t.data))}u.length>0&&(i[l]=u,o=!0)}o&&(t.data.morphAttributes=i,t.data.morphTargetsRelative=this.morphTargetsRelative);let a=this.groups;a.length>0&&(t.data.groups=JSON.parse(JSON.stringify(a)));let s=this.boundingSphere;return s!==null&&(t.data.boundingSphere={center:s.center.toArray(),radius:s.radius}),t}clone(){return new this.constructor().copy(this)}copy(t){this.index=null,this.attributes={},this.morphAttributes={},this.groups=[],this.boundingBox=null,this.boundingSphere=null;let r={};this.name=t.name;let n=t.index;n!==null&&this.setIndex(n.clone(r));let i=t.attributes;for(let c in i){let u=i[c];this.setAttribute(c,u.clone(r))}let o=t.morphAttributes;for(let c in o){let u=[],h=o[c];for(let f=0,p=h.length;f<p;f++)u.push(h[f].clone(r));this.morphAttributes[c]=u}this.morphTargetsRelative=t.morphTargetsRelative;let a=t.groups;for(let c=0,u=a.length;c<u;c++){let h=a[c];this.addGroup(h.start,h.count,h.materialIndex)}let s=t.boundingBox;s!==null&&(this.boundingBox=s.clone());let l=t.boundingSphere;return l!==null&&(this.boundingSphere=l.clone()),this.drawRange.start=t.drawRange.start,this.drawRange.count=t.drawRange.count,this.userData=t.userData,t.parameters!==void 0&&(this.parameters=Object.assign({},t.parameters)),this}dispose(){this.dispatchEvent({type:"dispose"})}};Pe.prototype.isBufferGeometry=!0;var Aue=new Me,A3=new Jf,out=new Zf,R0=new j,N0=new j,D0=new j,aut=new j,sut=new j,lut=new j,xV=new j,bV=new j,wV=new j,SV=new Lt,MV=new Lt,EV=new Lt,cut=new j,TV=new j,ti=class extends or{constructor(t=new Pe,r=new sh){super(),this.type="Mesh",this.geometry=t,this.material=r,this.updateMorphTargets()}copy(t){return super.copy(t),t.morphTargetInfluences!==void 0&&(this.morphTargetInfluences=t.morphTargetInfluences.slice()),t.morphTargetDictionary!==void 0&&(this.morphTargetDictionary=Object.assign({},t.morphTargetDictionary)),this.material=t.material,this.geometry=t.geometry,this}updateMorphTargets(){let t=this.geometry;if(t.isBufferGeometry){let r=t.morphAttributes,n=Object.keys(r);if(n.length>0){let i=r[n[0]];if(i!==void 0){this.morphTargetInfluences=[],this.morphTargetDictionary={};for(let o=0,a=i.length;o<a;o++){let s=i[o].name||String(o);this.morphTargetInfluences.push(0),this.morphTargetDictionary[s]=o}}}}else{let r=t.morphTargets;r!==void 0&&r.length>0&&console.error("THREE.Mesh.updateMorphTargets() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}}raycast(t,r){let n=this.geometry,i=this.material,o=this.matrixWorld;if(i===void 0||(n.boundingSphere===null&&n.computeBoundingSphere(),out.copy(n.boundingSphere),out.applyMatrix4(o),t.ray.intersectsSphere(out)===!1)||(Aue.copy(o).invert(),A3.copy(t.ray).applyMatrix4(Aue),n.boundingBox!==null&&A3.intersectsBox(n.boundingBox)===!1))return;let a;if(n.isBufferGeometry){let s=n.index,l=n.attributes.position,c=n.morphAttributes.position,u=n.morphTargetsRelative,h=n.attributes.uv,f=n.attributes.uv2,p=n.groups,d=n.drawRange;if(s!==null)if(Array.isArray(i))for(let g=0,_=p.length;g<_;g++){let y=p[g],x=i[y.materialIndex],b=Math.max(y.start,d.start),S=Math.min(s.count,Math.min(y.start+y.count,d.start+d.count));for(let C=b,P=S;C<P;C+=3){let k=s.getX(C),O=s.getX(C+1),D=s.getX(C+2);a=CV(this,x,t,A3,l,c,u,h,f,k,O,D),a&&(a.faceIndex=Math.floor(C/3),a.face.materialIndex=y.materialIndex,r.push(a))}}else{let g=Math.max(0,d.start),_=Math.min(s.count,d.start+d.count);for(let y=g,x=_;y<x;y+=3){let b=s.getX(y),S=s.getX(y+1),C=s.getX(y+2);a=CV(this,i,t,A3,l,c,u,h,f,b,S,C),a&&(a.faceIndex=Math.floor(y/3),r.push(a))}}else if(l!==void 0)if(Array.isArray(i))for(let g=0,_=p.length;g<_;g++){let y=p[g],x=i[y.materialIndex],b=Math.max(y.start,d.start),S=Math.min(l.count,Math.min(y.start+y.count,d.start+d.count));for(let C=b,P=S;C<P;C+=3){let k=C,O=C+1,D=C+2;a=CV(this,x,t,A3,l,c,u,h,f,k,O,D),a&&(a.faceIndex=Math.floor(C/3),a.face.materialIndex=y.materialIndex,r.push(a))}}else{let g=Math.max(0,d.start),_=Math.min(l.count,d.start+d.count);for(let y=g,x=_;y<x;y+=3){let b=y,S=y+1,C=y+2;a=CV(this,i,t,A3,l,c,u,h,f,b,S,C),a&&(a.faceIndex=Math.floor(y/3),r.push(a))}}}else n.isGeometry&&console.error("THREE.Mesh.raycast() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}};ti.prototype.isMesh=!0;function gfr(e,t,r,n,i,o,a,s){let l;if(t.side===Ii?l=n.intersectTriangle(a,o,i,!0,s):l=n.intersectTriangle(i,o,a,t.side!==L1,s),l===null)return null;TV.copy(s),TV.applyMatrix4(e.matrixWorld);let c=r.ray.origin.distanceTo(TV);return c<r.near||c>r.far?null:{distance:c,point:TV.clone(),object:e}}function CV(e,t,r,n,i,o,a,s,l,c,u,h){R0.fromBufferAttribute(i,c),N0.fromBufferAttribute(i,u),D0.fromBufferAttribute(i,h);let f=e.morphTargetInfluences;if(o&&f){xV.set(0,0,0),bV.set(0,0,0),wV.set(0,0,0);for(let d=0,g=o.length;d<g;d++){let _=f[d],y=o[d];_!==0&&(aut.fromBufferAttribute(y,c),sut.fromBufferAttribute(y,u),lut.fromBufferAttribute(y,h),a?(xV.addScaledVector(aut,_),bV.addScaledVector(sut,_),wV.addScaledVector(lut,_)):(xV.addScaledVector(aut.sub(R0),_),bV.addScaledVector(sut.sub(N0),_),wV.addScaledVector(lut.sub(D0),_)))}R0.add(xV),N0.add(bV),D0.add(wV)}e.isSkinnedMesh&&(e.boneTransform(c,R0),e.boneTransform(u,N0),e.boneTransform(h,D0));let p=gfr(e,t,r,n,R0,N0,D0,cut);if(p){s&&(SV.fromBufferAttribute(s,c),MV.fromBufferAttribute(s,u),EV.fromBufferAttribute(s,h),p.uv=oi.getUV(cut,R0,N0,D0,SV,MV,EV,new Lt)),l&&(SV.fromBufferAttribute(l,c),MV.fromBufferAttribute(l,u),EV.fromBufferAttribute(l,h),p.uv2=oi.getUV(cut,R0,N0,D0,SV,MV,EV,new Lt));let d={a:c,b:u,c:h,normal:new j,materialIndex:0};oi.getNormal(R0,N0,D0,d.normal),p.face=d}return p}var Qf=class extends Pe{constructor(t=1,r=1,n=1,i=1,o=1,a=1){super(),this.type="BoxGeometry",this.parameters={width:t,height:r,depth:n,widthSegments:i,heightSegments:o,depthSegments:a};let s=this;i=Math.floor(i),o=Math.floor(o),a=Math.floor(a);let l=[],c=[],u=[],h=[],f=0,p=0;d("z","y","x",-1,-1,n,r,t,a,o,0),d("z","y","x",1,-1,n,r,-t,a,o,1),d("x","z","y",1,1,t,n,r,i,a,2),d("x","z","y",1,-1,t,n,-r,i,a,3),d("x","y","z",1,-1,t,r,n,i,o,4),d("x","y","z",-1,-1,t,r,-n,i,o,5),this.setIndex(l),this.setAttribute("position",new xe(c,3)),this.setAttribute("normal",new xe(u,3)),this.setAttribute("uv",new xe(h,2));function d(g,_,y,x,b,S,C,P,k,O,D){let B=S/k,I=C/O,L=S/2,R=C/2,F=P/2,z=k+1,U=O+1,W=0,Z=0,rt=new j;for(let ot=0;ot<U;ot++){let st=ot*I-R;for(let St=0;St<z;St++){let bt=St*B-L;rt[g]=bt*x,rt[_]=st*b,rt[y]=F,c.push(rt.x,rt.y,rt.z),rt[g]=0,rt[_]=0,rt[y]=P>0?1:-1,u.push(rt.x,rt.y,rt.z),h.push(St/k),h.push(1-ot/O),W+=1}}for(let ot=0;ot<O;ot++)for(let st=0;st<k;st++){let St=f+st+z*ot,bt=f+st+z*(ot+1),Mt=f+(st+1)+z*(ot+1),lt=f+(st+1)+z*ot;l.push(St,bt,lt),l.push(bt,Mt,lt),Z+=6}s.addGroup(p,Z,D),p+=Z,f+=W}}static fromJSON(t){return new Qf(t.width,t.height,t.depth,t.widthSegments,t.heightSegments,t.depthSegments)}};function Z3(e){let t={};for(let r in e){t[r]={};for(let n in e[r]){let i=e[r][n];i&&(i.isColor||i.isMatrix3||i.isMatrix4||i.isVector2||i.isVector3||i.isVector4||i.isTexture||i.isQuaternion)?t[r][n]=i.clone():Array.isArray(i)?t[r][n]=i.slice():t[r][n]=i}}return t}function Ta(e){let t={};for(let r=0;r<e.length;r++){let n=Z3(e[r]);for(let i in n)t[i]=n[i]}return t}var Vfe={clone:Z3,merge:Ta},_fr=`void main() {
	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
}`,yfr=`void main() {
	gl_FragColor = vec4( 1.0, 0.0, 0.0, 1.0 );
}`,lh=class extends qi{constructor(t){super(),this.type="ShaderMaterial",this.defines={},this.uniforms={},this.vertexShader=_fr,this.fragmentShader=yfr,this.linewidth=1,this.wireframe=!1,this.wireframeLinewidth=1,this.fog=!1,this.lights=!1,this.clipping=!1,this.extensions={derivatives:!1,fragDepth:!1,drawBuffers:!1,shaderTextureLOD:!1},this.defaultAttributeValues={color:[1,1,1],uv:[0,0],uv2:[0,0]},this.index0AttributeName=void 0,this.uniformsNeedUpdate=!1,this.glslVersion=null,t!==void 0&&(t.attributes!==void 0&&console.error("THREE.ShaderMaterial: attributes should now be defined in THREE.BufferGeometry instead."),this.setValues(t))}copy(t){return super.copy(t),this.fragmentShader=t.fragmentShader,this.vertexShader=t.vertexShader,this.uniforms=Z3(t.uniforms),this.defines=Object.assign({},t.defines),this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.lights=t.lights,this.clipping=t.clipping,this.extensions=Object.assign({},t.extensions),this.glslVersion=t.glslVersion,this}toJSON(t){let r=super.toJSON(t);r.glslVersion=this.glslVersion,r.uniforms={};for(let i in this.uniforms){let a=this.uniforms[i].value;a&&a.isTexture?r.uniforms[i]={type:"t",value:a.toJSON(t).uuid}:a&&a.isColor?r.uniforms[i]={type:"c",value:a.getHex()}:a&&a.isVector2?r.uniforms[i]={type:"v2",value:a.toArray()}:a&&a.isVector3?r.uniforms[i]={type:"v3",value:a.toArray()}:a&&a.isVector4?r.uniforms[i]={type:"v4",value:a.toArray()}:a&&a.isMatrix3?r.uniforms[i]={type:"m3",value:a.toArray()}:a&&a.isMatrix4?r.uniforms[i]={type:"m4",value:a.toArray()}:r.uniforms[i]={value:a}}Object.keys(this.defines).length>0&&(r.defines=this.defines),r.vertexShader=this.vertexShader,r.fragmentShader=this.fragmentShader;let n={};for(let i in this.extensions)this.extensions[i]===!0&&(n[i]=!0);return Object.keys(n).length>0&&(r.extensions=n),r}};lh.prototype.isShaderMaterial=!0;var R1=class extends or{constructor(){super(),this.type="Camera",this.matrixWorldInverse=new Me,this.projectionMatrix=new Me,this.projectionMatrixInverse=new Me}copy(t,r){return super.copy(t,r),this.matrixWorldInverse.copy(t.matrixWorldInverse),this.projectionMatrix.copy(t.projectionMatrix),this.projectionMatrixInverse.copy(t.projectionMatrixInverse),this}getWorldDirection(t){this.updateWorldMatrix(!0,!1);let r=this.matrixWorld.elements;return t.set(-r[8],-r[9],-r[10]).normalize()}updateMatrixWorld(t){super.updateMatrixWorld(t),this.matrixWorldInverse.copy(this.matrixWorld).invert()}updateWorldMatrix(t,r){super.updateWorldMatrix(t,r),this.matrixWorldInverse.copy(this.matrixWorld).invert()}clone(){return new this.constructor().copy(this)}};R1.prototype.isCamera=!0;var Ui=class extends R1{constructor(t=50,r=1,n=.1,i=2e3){super(),this.type="PerspectiveCamera",this.fov=t,this.zoom=1,this.near=n,this.far=i,this.focus=10,this.aspect=r,this.view=null,this.filmGauge=35,this.filmOffset=0,this.updateProjectionMatrix()}copy(t,r){return super.copy(t,r),this.fov=t.fov,this.zoom=t.zoom,this.near=t.near,this.far=t.far,this.focus=t.focus,this.aspect=t.aspect,this.view=t.view===null?null:Object.assign({},t.view),this.filmGauge=t.filmGauge,this.filmOffset=t.filmOffset,this}setFocalLength(t){let r=.5*this.getFilmHeight()/t;this.fov=QP*2*Math.atan(r),this.updateProjectionMatrix()}getFocalLength(){let t=Math.tan(P1*.5*this.fov);return .5*this.getFilmHeight()/t}getEffectiveFOV(){return QP*2*Math.atan(Math.tan(P1*.5*this.fov)/this.zoom)}getFilmWidth(){return this.filmGauge*Math.min(this.aspect,1)}getFilmHeight(){return this.filmGauge/Math.max(this.aspect,1)}setViewOffset(t,r,n,i,o,a){this.aspect=t/r,this.view===null&&(this.view={enabled:!0,fullWidth:1,fullHeight:1,offsetX:0,offsetY:0,width:1,height:1}),this.view.enabled=!0,this.view.fullWidth=t,this.view.fullHeight=r,this.view.offsetX=n,this.view.offsetY=i,this.view.width=o,this.view.height=a,this.updateProjectionMatrix()}clearViewOffset(){this.view!==null&&(this.view.enabled=!1),this.updateProjectionMatrix()}updateProjectionMatrix(){let t=this.near,r=t*Math.tan(P1*.5*this.fov)/this.zoom,n=2*r,i=this.aspect*n,o=-.5*i,a=this.view;if(this.view!==null&&this.view.enabled){let l=a.fullWidth,c=a.fullHeight;o+=a.offsetX*i/l,r-=a.offsetY*n/c,i*=a.width/l,n*=a.height/c}let s=this.filmOffset;s!==0&&(o+=t*s/this.getFilmWidth()),this.projectionMatrix.makePerspective(o,o+i,r,r-n,t,this.far),this.projectionMatrixInverse.copy(this.projectionMatrix).invert()}toJSON(t){let r=super.toJSON(t);return r.object.fov=this.fov,r.object.zoom=this.zoom,r.object.near=this.near,r.object.far=this.far,r.object.focus=this.focus,r.object.aspect=this.aspect,this.view!==null&&(r.object.view=Object.assign({},this.view)),r.object.filmGauge=this.filmGauge,r.object.filmOffset=this.filmOffset,r}};Ui.prototype.isPerspectiveCamera=!0;var P3=90,I3=1,J3=class extends or{constructor(t,r,n){if(super(),this.type="CubeCamera",n.isWebGLCubeRenderTarget!==!0){console.error("THREE.CubeCamera: The constructor now expects an instance of WebGLCubeRenderTarget as third parameter.");return}this.renderTarget=n;let i=new Ui(P3,I3,t,r);i.layers=this.layers,i.up.set(0,-1,0),i.lookAt(new j(1,0,0)),this.add(i);let o=new Ui(P3,I3,t,r);o.layers=this.layers,o.up.set(0,-1,0),o.lookAt(new j(-1,0,0)),this.add(o);let a=new Ui(P3,I3,t,r);a.layers=this.layers,a.up.set(0,0,1),a.lookAt(new j(0,1,0)),this.add(a);let s=new Ui(P3,I3,t,r);s.layers=this.layers,s.up.set(0,0,-1),s.lookAt(new j(0,-1,0)),this.add(s);let l=new Ui(P3,I3,t,r);l.layers=this.layers,l.up.set(0,-1,0),l.lookAt(new j(0,0,1)),this.add(l);let c=new Ui(P3,I3,t,r);c.layers=this.layers,c.up.set(0,-1,0),c.lookAt(new j(0,0,-1)),this.add(c)}update(t,r){this.parent===null&&this.updateMatrixWorld();let n=this.renderTarget,[i,o,a,s,l,c]=this.children,u=t.xr.enabled,h=t.getRenderTarget();t.xr.enabled=!1;let f=n.texture.generateMipmaps;n.texture.generateMipmaps=!1,t.setRenderTarget(n,0),t.render(r,i),t.setRenderTarget(n,1),t.render(r,o),t.setRenderTarget(n,2),t.render(r,a),t.setRenderTarget(n,3),t.render(r,s),t.setRenderTarget(n,4),t.render(r,l),n.texture.generateMipmaps=f,t.setRenderTarget(n,5),t.render(r,c),t.setRenderTarget(h),t.xr.enabled=u,n.texture.needsPMREMUpdate=!0}},H0=class extends vi{constructor(t,r,n,i,o,a,s,l,c,u){t=t!==void 0?t:[],r=r!==void 0?r:nx,super(t,r,n,i,o,a,s,l,c,u),this.flipY=!1}get images(){return this.image}set images(t){this.image=t}};H0.prototype.isCubeTexture=!0;var Q3=class extends us{constructor(t,r,n){Number.isInteger(r)&&(console.warn("THREE.WebGLCubeRenderTarget: constructor signature is now WebGLCubeRenderTarget( size, options )"),r=n),super(t,t,r),r=r||{},this.texture=new H0(void 0,r.mapping,r.wrapS,r.wrapT,r.magFilter,r.minFilter,r.format,r.type,r.anisotropy,r.encoding),this.texture.isRenderTargetTexture=!0,this.texture.generateMipmaps=r.generateMipmaps!==void 0?r.generateMipmaps:!1,this.texture.minFilter=r.minFilter!==void 0?r.minFilter:ii}fromEquirectangularTexture(t,r){this.texture.type=r.type,this.texture.format=Qo,this.texture.encoding=r.encoding,this.texture.generateMipmaps=r.generateMipmaps,this.texture.minFilter=r.minFilter,this.texture.magFilter=r.magFilter;let n={uniforms:{tEquirect:{value:null}},vertexShader:`

				varying vec3 vWorldDirection;

				vec3 transformDirection( in vec3 dir, in mat4 matrix ) {

					return normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );

				}

				void main() {

					vWorldDirection = transformDirection( position, modelMatrix );

					#include <begin_vertex>
					#include <project_vertex>

				}
			`,fragmentShader:`

				uniform sampler2D tEquirect;

				varying vec3 vWorldDirection;

				#include <common>

				void main() {

					vec3 direction = normalize( vWorldDirection );

					vec2 sampleUV = equirectUv( direction );

					gl_FragColor = texture2D( tEquirect, sampleUV );

				}
			`},i=new Qf(5,5,5),o=new lh({name:"CubemapFromEquirect",uniforms:Z3(n.uniforms),vertexShader:n.vertexShader,fragmentShader:n.fragmentShader,side:Ii,blending:$d});o.uniforms.tEquirect.value=r;let a=new ti(i,o),s=r.minFilter;return r.minFilter===ox&&(r.minFilter=ii),new J3(1,10,this).update(t,a),r.minFilter=s,a.geometry.dispose(),a.material.dispose(),this}clear(t,r,n,i){let o=t.getRenderTarget();for(let a=0;a<6;a++)t.setRenderTarget(this,a),t.clear(r,n,i);t.setRenderTarget(o)}};Q3.prototype.isWebGLCubeRenderTarget=!0;var uut=new j,vfr=new j,xfr=new ki,$c=class{constructor(t=new j(1,0,0),r=0){this.normal=t,this.constant=r}set(t,r){return this.normal.copy(t),this.constant=r,this}setComponents(t,r,n,i){return this.normal.set(t,r,n),this.constant=i,this}setFromNormalAndCoplanarPoint(t,r){return this.normal.copy(t),this.constant=-r.dot(this.normal),this}setFromCoplanarPoints(t,r,n){let i=uut.subVectors(n,r).cross(vfr.subVectors(t,r)).normalize();return this.setFromNormalAndCoplanarPoint(i,t),this}copy(t){return this.normal.copy(t.normal),this.constant=t.constant,this}normalize(){let t=1/this.normal.length();return this.normal.multiplyScalar(t),this.constant*=t,this}negate(){return this.constant*=-1,this.normal.negate(),this}distanceToPoint(t){return this.normal.dot(t)+this.constant}distanceToSphere(t){return this.distanceToPoint(t.center)-t.radius}projectPoint(t,r){return r.copy(this.normal).multiplyScalar(-this.distanceToPoint(t)).add(t)}intersectLine(t,r){let n=t.delta(uut),i=this.normal.dot(n);if(i===0)return this.distanceToPoint(t.start)===0?r.copy(t.start):null;let o=-(t.start.dot(this.normal)+this.constant)/i;return o<0||o>1?null:r.copy(n).multiplyScalar(o).add(t.start)}intersectsLine(t){let r=this.distanceToPoint(t.start),n=this.distanceToPoint(t.end);return r<0&&n>0||n<0&&r>0}intersectsBox(t){return t.intersectsPlane(this)}intersectsSphere(t){return t.intersectsPlane(this)}coplanarPoint(t){return t.copy(this.normal).multiplyScalar(-this.constant)}applyMatrix4(t,r){let n=r||xfr.getNormalMatrix(t),i=this.coplanarPoint(uut).applyMatrix4(t),o=this.normal.applyMatrix3(n).normalize();return this.constant=-i.dot(o),this}translate(t){return this.constant-=t.dot(this.normal),this}equals(t){return t.normal.equals(this.normal)&&t.constant===this.constant}clone(){return new this.constructor().copy(this)}};$c.prototype.isPlane=!0;var L3=new Zf,AV=new j,N1=class{constructor(t=new $c,r=new $c,n=new $c,i=new $c,o=new $c,a=new $c){this.planes=[t,r,n,i,o,a]}set(t,r,n,i,o,a){let s=this.planes;return s[0].copy(t),s[1].copy(r),s[2].copy(n),s[3].copy(i),s[4].copy(o),s[5].copy(a),this}copy(t){let r=this.planes;for(let n=0;n<6;n++)r[n].copy(t.planes[n]);return this}setFromProjectionMatrix(t){let r=this.planes,n=t.elements,i=n[0],o=n[1],a=n[2],s=n[3],l=n[4],c=n[5],u=n[6],h=n[7],f=n[8],p=n[9],d=n[10],g=n[11],_=n[12],y=n[13],x=n[14],b=n[15];return r[0].setComponents(s-i,h-l,g-f,b-_).normalize(),r[1].setComponents(s+i,h+l,g+f,b+_).normalize(),r[2].setComponents(s+o,h+c,g+p,b+y).normalize(),r[3].setComponents(s-o,h-c,g-p,b-y).normalize(),r[4].setComponents(s-a,h-u,g-d,b-x).normalize(),r[5].setComponents(s+a,h+u,g+d,b+x).normalize(),this}intersectsObject(t){let r=t.geometry;return r.boundingSphere===null&&r.computeBoundingSphere(),L3.copy(r.boundingSphere).applyMatrix4(t.matrixWorld),this.intersectsSphere(L3)}intersectsSprite(t){return L3.center.set(0,0,0),L3.radius=.7071067811865476,L3.applyMatrix4(t.matrixWorld),this.intersectsSphere(L3)}intersectsSphere(t){let r=this.planes,n=t.center,i=-t.radius;for(let o=0;o<6;o++)if(r[o].distanceToPoint(n)<i)return!1;return!0}intersectsBox(t){let r=this.planes;for(let n=0;n<6;n++){let i=r[n];if(AV.x=i.normal.x>0?t.max.x:t.min.x,AV.y=i.normal.y>0?t.max.y:t.min.y,AV.z=i.normal.z>0?t.max.z:t.min.z,i.distanceToPoint(AV)<0)return!1}return!0}containsPoint(t){let r=this.planes;for(let n=0;n<6;n++)if(r[n].distanceToPoint(t)<0)return!1;return!0}clone(){return new this.constructor().copy(this)}};function Ufe(){let e=null,t=!1,r=null,n=null;function i(o,a){r(o,a),n=e.requestAnimationFrame(i)}return{start:function(){t!==!0&&r!==null&&(n=e.requestAnimationFrame(i),t=!0)},stop:function(){e.cancelAnimationFrame(n),t=!1},setAnimationLoop:function(o){r=o},setContext:function(o){e=o}}}function bfr(e,t){let r=t.isWebGL2,n=new WeakMap;function i(c,u){let h=c.array,f=c.usage,p=e.createBuffer();e.bindBuffer(u,p),e.bufferData(u,h,f),c.onUploadCallback();let d=5126;return h instanceof Float32Array?d=5126:h instanceof Float64Array?console.warn("THREE.WebGLAttributes: Unsupported data buffer format: Float64Array."):h instanceof Uint16Array?c.isFloat16BufferAttribute?r?d=5131:console.warn("THREE.WebGLAttributes: Usage of Float16BufferAttribute requires WebGL2."):d=5123:h instanceof Int16Array?d=5122:h instanceof Uint32Array?d=5125:h instanceof Int32Array?d=5124:h instanceof Int8Array?d=5120:(h instanceof Uint8Array||h instanceof Uint8ClampedArray)&&(d=5121),{buffer:p,type:d,bytesPerElement:h.BYTES_PER_ELEMENT,version:c.version}}function o(c,u,h){let f=u.array,p=u.updateRange;e.bindBuffer(h,c),p.count===-1?e.bufferSubData(h,0,f):(r?e.bufferSubData(h,p.offset*f.BYTES_PER_ELEMENT,f,p.offset,p.count):e.bufferSubData(h,p.offset*f.BYTES_PER_ELEMENT,f.subarray(p.offset,p.offset+p.count)),p.count=-1)}function a(c){return c.isInterleavedBufferAttribute&&(c=c.data),n.get(c)}function s(c){c.isInterleavedBufferAttribute&&(c=c.data);let u=n.get(c);u&&(e.deleteBuffer(u.buffer),n.delete(c))}function l(c,u){if(c.isGLBufferAttribute){let f=n.get(c);(!f||f.version<c.version)&&n.set(c,{buffer:c.buffer,type:c.type,bytesPerElement:c.elementSize,version:c.version});return}c.isInterleavedBufferAttribute&&(c=c.data);let h=n.get(c);h===void 0?n.set(c,i(c,u)):h.version<c.version&&(o(h.buffer,c,u),h.version=c.version)}return{get:a,remove:s,update:l}}var V0=class extends Pe{constructor(t=1,r=1,n=1,i=1){super(),this.type="PlaneGeometry",this.parameters={width:t,height:r,widthSegments:n,heightSegments:i};let o=t/2,a=r/2,s=Math.floor(n),l=Math.floor(i),c=s+1,u=l+1,h=t/s,f=r/l,p=[],d=[],g=[],_=[];for(let y=0;y<u;y++){let x=y*f-a;for(let b=0;b<c;b++){let S=b*h-o;d.push(S,-x,0),g.push(0,0,1),_.push(b/s),_.push(1-y/l)}}for(let y=0;y<l;y++)for(let x=0;x<s;x++){let b=x+c*y,S=x+c*(y+1),C=x+1+c*(y+1),P=x+1+c*y;p.push(b,S,P),p.push(S,C,P)}this.setIndex(p),this.setAttribute("position",new xe(d,3)),this.setAttribute("normal",new xe(g,3)),this.setAttribute("uv",new xe(_,2))}static fromJSON(t){return new V0(t.width,t.height,t.widthSegments,t.heightSegments)}},wfr=`#ifdef USE_ALPHAMAP
	diffuseColor.a *= texture2D( alphaMap, vUv ).g;
#endif`,Sfr=`#ifdef USE_ALPHAMAP
	uniform sampler2D alphaMap;
#endif`,Mfr=`#ifdef USE_ALPHATEST
	if ( diffuseColor.a < alphaTest ) discard;
#endif`,Efr=`#ifdef USE_ALPHATEST
	uniform float alphaTest;
#endif`,Tfr=`#ifdef USE_AOMAP
	float ambientOcclusion = ( texture2D( aoMap, vUv2 ).r - 1.0 ) * aoMapIntensity + 1.0;
	reflectedLight.indirectDiffuse *= ambientOcclusion;
	#if defined( USE_ENVMAP ) && defined( STANDARD )
		float dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );
		reflectedLight.indirectSpecular *= computeSpecularOcclusion( dotNV, ambientOcclusion, material.roughness );
	#endif
#endif`,Cfr=`#ifdef USE_AOMAP
	uniform sampler2D aoMap;
	uniform float aoMapIntensity;
#endif`,Afr="vec3 transformed = vec3( position );",Pfr=`vec3 objectNormal = vec3( normal );
#ifdef USE_TANGENT
	vec3 objectTangent = vec3( tangent.xyz );
#endif`,Ifr=`vec3 BRDF_Lambert( const in vec3 diffuseColor ) {
	return RECIPROCAL_PI * diffuseColor;
}
vec3 F_Schlick( const in vec3 f0, const in float f90, const in float dotVH ) {
	float fresnel = exp2( ( - 5.55473 * dotVH - 6.98316 ) * dotVH );
	return f0 * ( 1.0 - fresnel ) + ( f90 * fresnel );
}
float V_GGX_SmithCorrelated( const in float alpha, const in float dotNL, const in float dotNV ) {
	float a2 = pow2( alpha );
	float gv = dotNL * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );
	float gl = dotNV * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );
	return 0.5 / max( gv + gl, EPSILON );
}
float D_GGX( const in float alpha, const in float dotNH ) {
	float a2 = pow2( alpha );
	float denom = pow2( dotNH ) * ( a2 - 1.0 ) + 1.0;
	return RECIPROCAL_PI * a2 / pow2( denom );
}
vec3 BRDF_GGX( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in vec3 f0, const in float f90, const in float roughness ) {
	float alpha = pow2( roughness );
	vec3 halfDir = normalize( lightDir + viewDir );
	float dotNL = saturate( dot( normal, lightDir ) );
	float dotNV = saturate( dot( normal, viewDir ) );
	float dotNH = saturate( dot( normal, halfDir ) );
	float dotVH = saturate( dot( viewDir, halfDir ) );
	vec3 F = F_Schlick( f0, f90, dotVH );
	float V = V_GGX_SmithCorrelated( alpha, dotNL, dotNV );
	float D = D_GGX( alpha, dotNH );
	return F * ( V * D );
}
vec2 LTC_Uv( const in vec3 N, const in vec3 V, const in float roughness ) {
	const float LUT_SIZE = 64.0;
	const float LUT_SCALE = ( LUT_SIZE - 1.0 ) / LUT_SIZE;
	const float LUT_BIAS = 0.5 / LUT_SIZE;
	float dotNV = saturate( dot( N, V ) );
	vec2 uv = vec2( roughness, sqrt( 1.0 - dotNV ) );
	uv = uv * LUT_SCALE + LUT_BIAS;
	return uv;
}
float LTC_ClippedSphereFormFactor( const in vec3 f ) {
	float l = length( f );
	return max( ( l * l + f.z ) / ( l + 1.0 ), 0.0 );
}
vec3 LTC_EdgeVectorFormFactor( const in vec3 v1, const in vec3 v2 ) {
	float x = dot( v1, v2 );
	float y = abs( x );
	float a = 0.8543985 + ( 0.4965155 + 0.0145206 * y ) * y;
	float b = 3.4175940 + ( 4.1616724 + y ) * y;
	float v = a / b;
	float theta_sintheta = ( x > 0.0 ) ? v : 0.5 * inversesqrt( max( 1.0 - x * x, 1e-7 ) ) - v;
	return cross( v1, v2 ) * theta_sintheta;
}
vec3 LTC_Evaluate( const in vec3 N, const in vec3 V, const in vec3 P, const in mat3 mInv, const in vec3 rectCoords[ 4 ] ) {
	vec3 v1 = rectCoords[ 1 ] - rectCoords[ 0 ];
	vec3 v2 = rectCoords[ 3 ] - rectCoords[ 0 ];
	vec3 lightNormal = cross( v1, v2 );
	if( dot( lightNormal, P - rectCoords[ 0 ] ) < 0.0 ) return vec3( 0.0 );
	vec3 T1, T2;
	T1 = normalize( V - N * dot( V, N ) );
	T2 = - cross( N, T1 );
	mat3 mat = mInv * transposeMat3( mat3( T1, T2, N ) );
	vec3 coords[ 4 ];
	coords[ 0 ] = mat * ( rectCoords[ 0 ] - P );
	coords[ 1 ] = mat * ( rectCoords[ 1 ] - P );
	coords[ 2 ] = mat * ( rectCoords[ 2 ] - P );
	coords[ 3 ] = mat * ( rectCoords[ 3 ] - P );
	coords[ 0 ] = normalize( coords[ 0 ] );
	coords[ 1 ] = normalize( coords[ 1 ] );
	coords[ 2 ] = normalize( coords[ 2 ] );
	coords[ 3 ] = normalize( coords[ 3 ] );
	vec3 vectorFormFactor = vec3( 0.0 );
	vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 0 ], coords[ 1 ] );
	vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 1 ], coords[ 2 ] );
	vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 2 ], coords[ 3 ] );
	vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 3 ], coords[ 0 ] );
	float result = LTC_ClippedSphereFormFactor( vectorFormFactor );
	return vec3( result );
}
float G_BlinnPhong_Implicit( ) {
	return 0.25;
}
float D_BlinnPhong( const in float shininess, const in float dotNH ) {
	return RECIPROCAL_PI * ( shininess * 0.5 + 1.0 ) * pow( dotNH, shininess );
}
vec3 BRDF_BlinnPhong( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in vec3 specularColor, const in float shininess ) {
	vec3 halfDir = normalize( lightDir + viewDir );
	float dotNH = saturate( dot( normal, halfDir ) );
	float dotVH = saturate( dot( viewDir, halfDir ) );
	vec3 F = F_Schlick( specularColor, 1.0, dotVH );
	float G = G_BlinnPhong_Implicit( );
	float D = D_BlinnPhong( shininess, dotNH );
	return F * ( G * D );
}
#if defined( USE_SHEEN )
float D_Charlie( float roughness, float dotNH ) {
	float alpha = pow2( roughness );
	float invAlpha = 1.0 / alpha;
	float cos2h = dotNH * dotNH;
	float sin2h = max( 1.0 - cos2h, 0.0078125 );
	return ( 2.0 + invAlpha ) * pow( sin2h, invAlpha * 0.5 ) / ( 2.0 * PI );
}
float V_Neubelt( float dotNV, float dotNL ) {
	return saturate( 1.0 / ( 4.0 * ( dotNL + dotNV - dotNL * dotNV ) ) );
}
vec3 BRDF_Sheen( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, vec3 sheenColor, const in float sheenRoughness ) {
	vec3 halfDir = normalize( lightDir + viewDir );
	float dotNL = saturate( dot( normal, lightDir ) );
	float dotNV = saturate( dot( normal, viewDir ) );
	float dotNH = saturate( dot( normal, halfDir ) );
	float D = D_Charlie( sheenRoughness, dotNH );
	float V = V_Neubelt( dotNV, dotNL );
	return sheenColor * ( D * V );
}
#endif`,Lfr=`#ifdef USE_BUMPMAP
	uniform sampler2D bumpMap;
	uniform float bumpScale;
	vec2 dHdxy_fwd() {
		vec2 dSTdx = dFdx( vUv );
		vec2 dSTdy = dFdy( vUv );
		float Hll = bumpScale * texture2D( bumpMap, vUv ).x;
		float dBx = bumpScale * texture2D( bumpMap, vUv + dSTdx ).x - Hll;
		float dBy = bumpScale * texture2D( bumpMap, vUv + dSTdy ).x - Hll;
		return vec2( dBx, dBy );
	}
	vec3 perturbNormalArb( vec3 surf_pos, vec3 surf_norm, vec2 dHdxy, float faceDirection ) {
		vec3 vSigmaX = vec3( dFdx( surf_pos.x ), dFdx( surf_pos.y ), dFdx( surf_pos.z ) );
		vec3 vSigmaY = vec3( dFdy( surf_pos.x ), dFdy( surf_pos.y ), dFdy( surf_pos.z ) );
		vec3 vN = surf_norm;
		vec3 R1 = cross( vSigmaY, vN );
		vec3 R2 = cross( vN, vSigmaX );
		float fDet = dot( vSigmaX, R1 ) * faceDirection;
		vec3 vGrad = sign( fDet ) * ( dHdxy.x * R1 + dHdxy.y * R2 );
		return normalize( abs( fDet ) * surf_norm - vGrad );
	}
#endif`,kfr=`#if NUM_CLIPPING_PLANES > 0
	vec4 plane;
	#pragma unroll_loop_start
	for ( int i = 0; i < UNION_CLIPPING_PLANES; i ++ ) {
		plane = clippingPlanes[ i ];
		if ( dot( vClipPosition, plane.xyz ) > plane.w ) discard;
	}
	#pragma unroll_loop_end
	#if UNION_CLIPPING_PLANES < NUM_CLIPPING_PLANES
		bool clipped = true;
		#pragma unroll_loop_start
		for ( int i = UNION_CLIPPING_PLANES; i < NUM_CLIPPING_PLANES; i ++ ) {
			plane = clippingPlanes[ i ];
			clipped = ( dot( vClipPosition, plane.xyz ) > plane.w ) && clipped;
		}
		#pragma unroll_loop_end
		if ( clipped ) discard;
	#endif
#endif`,Rfr=`#if NUM_CLIPPING_PLANES > 0
	varying vec3 vClipPosition;
	uniform vec4 clippingPlanes[ NUM_CLIPPING_PLANES ];
#endif`,Nfr=`#if NUM_CLIPPING_PLANES > 0
	varying vec3 vClipPosition;
#endif`,Dfr=`#if NUM_CLIPPING_PLANES > 0
	vClipPosition = - mvPosition.xyz;
#endif`,Ofr=`#if defined( USE_COLOR_ALPHA )
	diffuseColor *= vColor;
#elif defined( USE_COLOR )
	diffuseColor.rgb *= vColor;
#endif`,zfr=`#if defined( USE_COLOR_ALPHA )
	varying vec4 vColor;
#elif defined( USE_COLOR )
	varying vec3 vColor;
#endif`,Ffr=`#if defined( USE_COLOR_ALPHA )
	varying vec4 vColor;
#elif defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR )
	varying vec3 vColor;
#endif`,Bfr=`#if defined( USE_COLOR_ALPHA )
	vColor = vec4( 1.0 );
#elif defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR )
	vColor = vec3( 1.0 );
#endif
#ifdef USE_COLOR
	vColor *= color;
#endif
#ifdef USE_INSTANCING_COLOR
	vColor.xyz *= instanceColor.xyz;
#endif`,Hfr=`#define PI 3.141592653589793
#define PI2 6.283185307179586
#define PI_HALF 1.5707963267948966
#define RECIPROCAL_PI 0.3183098861837907
#define RECIPROCAL_PI2 0.15915494309189535
#define EPSILON 1e-6
#ifndef saturate
#define saturate( a ) clamp( a, 0.0, 1.0 )
#endif
#define whiteComplement( a ) ( 1.0 - saturate( a ) )
float pow2( const in float x ) { return x*x; }
float pow3( const in float x ) { return x*x*x; }
float pow4( const in float x ) { float x2 = x*x; return x2*x2; }
float max3( const in vec3 v ) { return max( max( v.x, v.y ), v.z ); }
float average( const in vec3 color ) { return dot( color, vec3( 0.3333 ) ); }
highp float rand( const in vec2 uv ) {
	const highp float a = 12.9898, b = 78.233, c = 43758.5453;
	highp float dt = dot( uv.xy, vec2( a,b ) ), sn = mod( dt, PI );
	return fract( sin( sn ) * c );
}
#ifdef HIGH_PRECISION
	float precisionSafeLength( vec3 v ) { return length( v ); }
#else
	float precisionSafeLength( vec3 v ) {
		float maxComponent = max3( abs( v ) );
		return length( v / maxComponent ) * maxComponent;
	}
#endif
struct IncidentLight {
	vec3 color;
	vec3 direction;
	bool visible;
};
struct ReflectedLight {
	vec3 directDiffuse;
	vec3 directSpecular;
	vec3 indirectDiffuse;
	vec3 indirectSpecular;
};
struct GeometricContext {
	vec3 position;
	vec3 normal;
	vec3 viewDir;
#ifdef USE_CLEARCOAT
	vec3 clearcoatNormal;
#endif
};
vec3 transformDirection( in vec3 dir, in mat4 matrix ) {
	return normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );
}
vec3 inverseTransformDirection( in vec3 dir, in mat4 matrix ) {
	return normalize( ( vec4( dir, 0.0 ) * matrix ).xyz );
}
mat3 transposeMat3( const in mat3 m ) {
	mat3 tmp;
	tmp[ 0 ] = vec3( m[ 0 ].x, m[ 1 ].x, m[ 2 ].x );
	tmp[ 1 ] = vec3( m[ 0 ].y, m[ 1 ].y, m[ 2 ].y );
	tmp[ 2 ] = vec3( m[ 0 ].z, m[ 1 ].z, m[ 2 ].z );
	return tmp;
}
float linearToRelativeLuminance( const in vec3 color ) {
	vec3 weights = vec3( 0.2126, 0.7152, 0.0722 );
	return dot( weights, color.rgb );
}
bool isPerspectiveMatrix( mat4 m ) {
	return m[ 2 ][ 3 ] == - 1.0;
}
vec2 equirectUv( in vec3 dir ) {
	float u = atan( dir.z, dir.x ) * RECIPROCAL_PI2 + 0.5;
	float v = asin( clamp( dir.y, - 1.0, 1.0 ) ) * RECIPROCAL_PI + 0.5;
	return vec2( u, v );
}`,Vfr=`#ifdef ENVMAP_TYPE_CUBE_UV
	#define cubeUV_maxMipLevel 8.0
	#define cubeUV_minMipLevel 4.0
	#define cubeUV_maxTileSize 256.0
	#define cubeUV_minTileSize 16.0
	float getFace( vec3 direction ) {
		vec3 absDirection = abs( direction );
		float face = - 1.0;
		if ( absDirection.x > absDirection.z ) {
			if ( absDirection.x > absDirection.y )
				face = direction.x > 0.0 ? 0.0 : 3.0;
			else
				face = direction.y > 0.0 ? 1.0 : 4.0;
		} else {
			if ( absDirection.z > absDirection.y )
				face = direction.z > 0.0 ? 2.0 : 5.0;
			else
				face = direction.y > 0.0 ? 1.0 : 4.0;
		}
		return face;
	}
	vec2 getUV( vec3 direction, float face ) {
		vec2 uv;
		if ( face == 0.0 ) {
			uv = vec2( direction.z, direction.y ) / abs( direction.x );
		} else if ( face == 1.0 ) {
			uv = vec2( - direction.x, - direction.z ) / abs( direction.y );
		} else if ( face == 2.0 ) {
			uv = vec2( - direction.x, direction.y ) / abs( direction.z );
		} else if ( face == 3.0 ) {
			uv = vec2( - direction.z, direction.y ) / abs( direction.x );
		} else if ( face == 4.0 ) {
			uv = vec2( - direction.x, direction.z ) / abs( direction.y );
		} else {
			uv = vec2( direction.x, direction.y ) / abs( direction.z );
		}
		return 0.5 * ( uv + 1.0 );
	}
	vec3 bilinearCubeUV( sampler2D envMap, vec3 direction, float mipInt ) {
		float face = getFace( direction );
		float filterInt = max( cubeUV_minMipLevel - mipInt, 0.0 );
		mipInt = max( mipInt, cubeUV_minMipLevel );
		float faceSize = exp2( mipInt );
		float texelSize = 1.0 / ( 3.0 * cubeUV_maxTileSize );
		vec2 uv = getUV( direction, face ) * ( faceSize - 1.0 ) + 0.5;
		if ( face > 2.0 ) {
			uv.y += faceSize;
			face -= 3.0;
		}
		uv.x += face * faceSize;
		if ( mipInt < cubeUV_maxMipLevel ) {
			uv.y += 2.0 * cubeUV_maxTileSize;
		}
		uv.y += filterInt * 2.0 * cubeUV_minTileSize;
		uv.x += 3.0 * max( 0.0, cubeUV_maxTileSize - 2.0 * faceSize );
		uv *= texelSize;
		return texture2D( envMap, uv ).rgb;
	}
	#define r0 1.0
	#define v0 0.339
	#define m0 - 2.0
	#define r1 0.8
	#define v1 0.276
	#define m1 - 1.0
	#define r4 0.4
	#define v4 0.046
	#define m4 2.0
	#define r5 0.305
	#define v5 0.016
	#define m5 3.0
	#define r6 0.21
	#define v6 0.0038
	#define m6 4.0
	float roughnessToMip( float roughness ) {
		float mip = 0.0;
		if ( roughness >= r1 ) {
			mip = ( r0 - roughness ) * ( m1 - m0 ) / ( r0 - r1 ) + m0;
		} else if ( roughness >= r4 ) {
			mip = ( r1 - roughness ) * ( m4 - m1 ) / ( r1 - r4 ) + m1;
		} else if ( roughness >= r5 ) {
			mip = ( r4 - roughness ) * ( m5 - m4 ) / ( r4 - r5 ) + m4;
		} else if ( roughness >= r6 ) {
			mip = ( r5 - roughness ) * ( m6 - m5 ) / ( r5 - r6 ) + m5;
		} else {
			mip = - 2.0 * log2( 1.16 * roughness );		}
		return mip;
	}
	vec4 textureCubeUV( sampler2D envMap, vec3 sampleDir, float roughness ) {
		float mip = clamp( roughnessToMip( roughness ), m0, cubeUV_maxMipLevel );
		float mipF = fract( mip );
		float mipInt = floor( mip );
		vec3 color0 = bilinearCubeUV( envMap, sampleDir, mipInt );
		if ( mipF == 0.0 ) {
			return vec4( color0, 1.0 );
		} else {
			vec3 color1 = bilinearCubeUV( envMap, sampleDir, mipInt + 1.0 );
			return vec4( mix( color0, color1, mipF ), 1.0 );
		}
	}
#endif`,Ufr=`vec3 transformedNormal = objectNormal;
#ifdef USE_INSTANCING
	mat3 m = mat3( instanceMatrix );
	transformedNormal /= vec3( dot( m[ 0 ], m[ 0 ] ), dot( m[ 1 ], m[ 1 ] ), dot( m[ 2 ], m[ 2 ] ) );
	transformedNormal = m * transformedNormal;
#endif
transformedNormal = normalMatrix * transformedNormal;
#ifdef FLIP_SIDED
	transformedNormal = - transformedNormal;
#endif
#ifdef USE_TANGENT
	vec3 transformedTangent = ( modelViewMatrix * vec4( objectTangent, 0.0 ) ).xyz;
	#ifdef FLIP_SIDED
		transformedTangent = - transformedTangent;
	#endif
#endif`,qfr=`#ifdef USE_DISPLACEMENTMAP
	uniform sampler2D displacementMap;
	uniform float displacementScale;
	uniform float displacementBias;
#endif`,Gfr=`#ifdef USE_DISPLACEMENTMAP
	transformed += normalize( objectNormal ) * ( texture2D( displacementMap, vUv ).x * displacementScale + displacementBias );
#endif`,Wfr=`#ifdef USE_EMISSIVEMAP
	vec4 emissiveColor = texture2D( emissiveMap, vUv );
	totalEmissiveRadiance *= emissiveColor.rgb;
#endif`,Yfr=`#ifdef USE_EMISSIVEMAP
	uniform sampler2D emissiveMap;
#endif`,jfr="gl_FragColor = linearToOutputTexel( gl_FragColor );",Xfr=`vec4 LinearToLinear( in vec4 value ) {
	return value;
}
vec4 LinearTosRGB( in vec4 value ) {
	return vec4( mix( pow( value.rgb, vec3( 0.41666 ) ) * 1.055 - vec3( 0.055 ), value.rgb * 12.92, vec3( lessThanEqual( value.rgb, vec3( 0.0031308 ) ) ) ), value.a );
}`,$fr=`#ifdef USE_ENVMAP
	#ifdef ENV_WORLDPOS
		vec3 cameraToFrag;
		if ( isOrthographic ) {
			cameraToFrag = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );
		} else {
			cameraToFrag = normalize( vWorldPosition - cameraPosition );
		}
		vec3 worldNormal = inverseTransformDirection( normal, viewMatrix );
		#ifdef ENVMAP_MODE_REFLECTION
			vec3 reflectVec = reflect( cameraToFrag, worldNormal );
		#else
			vec3 reflectVec = refract( cameraToFrag, worldNormal, refractionRatio );
		#endif
	#else
		vec3 reflectVec = vReflect;
	#endif
	#ifdef ENVMAP_TYPE_CUBE
		vec4 envColor = textureCube( envMap, vec3( flipEnvMap * reflectVec.x, reflectVec.yz ) );
	#elif defined( ENVMAP_TYPE_CUBE_UV )
		vec4 envColor = textureCubeUV( envMap, reflectVec, 0.0 );
	#else
		vec4 envColor = vec4( 0.0 );
	#endif
	#ifdef ENVMAP_BLENDING_MULTIPLY
		outgoingLight = mix( outgoingLight, outgoingLight * envColor.xyz, specularStrength * reflectivity );
	#elif defined( ENVMAP_BLENDING_MIX )
		outgoingLight = mix( outgoingLight, envColor.xyz, specularStrength * reflectivity );
	#elif defined( ENVMAP_BLENDING_ADD )
		outgoingLight += envColor.xyz * specularStrength * reflectivity;
	#endif
#endif`,Kfr=`#ifdef USE_ENVMAP
	uniform float envMapIntensity;
	uniform float flipEnvMap;
	#ifdef ENVMAP_TYPE_CUBE
		uniform samplerCube envMap;
	#else
		uniform sampler2D envMap;
	#endif
	
#endif`,Zfr=`#ifdef USE_ENVMAP
	uniform float reflectivity;
	#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG )
		#define ENV_WORLDPOS
	#endif
	#ifdef ENV_WORLDPOS
		varying vec3 vWorldPosition;
		uniform float refractionRatio;
	#else
		varying vec3 vReflect;
	#endif
#endif`,Jfr=`#ifdef USE_ENVMAP
	#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) ||defined( PHONG )
		#define ENV_WORLDPOS
	#endif
	#ifdef ENV_WORLDPOS
		
		varying vec3 vWorldPosition;
	#else
		varying vec3 vReflect;
		uniform float refractionRatio;
	#endif
#endif`,Qfr=`#ifdef USE_ENVMAP
	#ifdef ENV_WORLDPOS
		vWorldPosition = worldPosition.xyz;
	#else
		vec3 cameraToVertex;
		if ( isOrthographic ) {
			cameraToVertex = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );
		} else {
			cameraToVertex = normalize( worldPosition.xyz - cameraPosition );
		}
		vec3 worldNormal = inverseTransformDirection( transformedNormal, viewMatrix );
		#ifdef ENVMAP_MODE_REFLECTION
			vReflect = reflect( cameraToVertex, worldNormal );
		#else
			vReflect = refract( cameraToVertex, worldNormal, refractionRatio );
		#endif
	#endif
#endif`,tpr=`#ifdef USE_FOG
	vFogDepth = - mvPosition.z;
#endif`,epr=`#ifdef USE_FOG
	varying float vFogDepth;
#endif`,rpr=`#ifdef USE_FOG
	#ifdef FOG_EXP2
		float fogFactor = 1.0 - exp( - fogDensity * fogDensity * vFogDepth * vFogDepth );
	#else
		float fogFactor = smoothstep( fogNear, fogFar, vFogDepth );
	#endif
	gl_FragColor.rgb = mix( gl_FragColor.rgb, fogColor, fogFactor );
#endif`,npr=`#ifdef USE_FOG
	uniform vec3 fogColor;
	varying float vFogDepth;
	#ifdef FOG_EXP2
		uniform float fogDensity;
	#else
		uniform float fogNear;
		uniform float fogFar;
	#endif
#endif`,ipr=`#ifdef USE_GRADIENTMAP
	uniform sampler2D gradientMap;
#endif
vec3 getGradientIrradiance( vec3 normal, vec3 lightDirection ) {
	float dotNL = dot( normal, lightDirection );
	vec2 coord = vec2( dotNL * 0.5 + 0.5, 0.0 );
	#ifdef USE_GRADIENTMAP
		return vec3( texture2D( gradientMap, coord ).r );
	#else
		return ( coord.x < 0.7 ) ? vec3( 0.7 ) : vec3( 1.0 );
	#endif
}`,opr=`#ifdef USE_LIGHTMAP
	vec4 lightMapTexel = texture2D( lightMap, vUv2 );
	vec3 lightMapIrradiance = lightMapTexel.rgb * lightMapIntensity;
	#ifndef PHYSICALLY_CORRECT_LIGHTS
		lightMapIrradiance *= PI;
	#endif
	reflectedLight.indirectDiffuse += lightMapIrradiance;
#endif`,apr=`#ifdef USE_LIGHTMAP
	uniform sampler2D lightMap;
	uniform float lightMapIntensity;
#endif`,spr=`vec3 diffuse = vec3( 1.0 );
GeometricContext geometry;
geometry.position = mvPosition.xyz;
geometry.normal = normalize( transformedNormal );
geometry.viewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( -mvPosition.xyz );
GeometricContext backGeometry;
backGeometry.position = geometry.position;
backGeometry.normal = -geometry.normal;
backGeometry.viewDir = geometry.viewDir;
vLightFront = vec3( 0.0 );
vIndirectFront = vec3( 0.0 );
#ifdef DOUBLE_SIDED
	vLightBack = vec3( 0.0 );
	vIndirectBack = vec3( 0.0 );
#endif
IncidentLight directLight;
float dotNL;
vec3 directLightColor_Diffuse;
vIndirectFront += getAmbientLightIrradiance( ambientLightColor );
vIndirectFront += getLightProbeIrradiance( lightProbe, geometry.normal );
#ifdef DOUBLE_SIDED
	vIndirectBack += getAmbientLightIrradiance( ambientLightColor );
	vIndirectBack += getLightProbeIrradiance( lightProbe, backGeometry.normal );
#endif
#if NUM_POINT_LIGHTS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {
		getPointLightInfo( pointLights[ i ], geometry, directLight );
		dotNL = dot( geometry.normal, directLight.direction );
		directLightColor_Diffuse = directLight.color;
		vLightFront += saturate( dotNL ) * directLightColor_Diffuse;
		#ifdef DOUBLE_SIDED
			vLightBack += saturate( - dotNL ) * directLightColor_Diffuse;
		#endif
	}
	#pragma unroll_loop_end
#endif
#if NUM_SPOT_LIGHTS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {
		getSpotLightInfo( spotLights[ i ], geometry, directLight );
		dotNL = dot( geometry.normal, directLight.direction );
		directLightColor_Diffuse = directLight.color;
		vLightFront += saturate( dotNL ) * directLightColor_Diffuse;
		#ifdef DOUBLE_SIDED
			vLightBack += saturate( - dotNL ) * directLightColor_Diffuse;
		#endif
	}
	#pragma unroll_loop_end
#endif
#if NUM_DIR_LIGHTS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {
		getDirectionalLightInfo( directionalLights[ i ], geometry, directLight );
		dotNL = dot( geometry.normal, directLight.direction );
		directLightColor_Diffuse = directLight.color;
		vLightFront += saturate( dotNL ) * directLightColor_Diffuse;
		#ifdef DOUBLE_SIDED
			vLightBack += saturate( - dotNL ) * directLightColor_Diffuse;
		#endif
	}
	#pragma unroll_loop_end
#endif
#if NUM_HEMI_LIGHTS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {
		vIndirectFront += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry.normal );
		#ifdef DOUBLE_SIDED
			vIndirectBack += getHemisphereLightIrradiance( hemisphereLights[ i ], backGeometry.normal );
		#endif
	}
	#pragma unroll_loop_end
#endif`,lpr=`uniform bool receiveShadow;
uniform vec3 ambientLightColor;
uniform vec3 lightProbe[ 9 ];
vec3 shGetIrradianceAt( in vec3 normal, in vec3 shCoefficients[ 9 ] ) {
	float x = normal.x, y = normal.y, z = normal.z;
	vec3 result = shCoefficients[ 0 ] * 0.886227;
	result += shCoefficients[ 1 ] * 2.0 * 0.511664 * y;
	result += shCoefficients[ 2 ] * 2.0 * 0.511664 * z;
	result += shCoefficients[ 3 ] * 2.0 * 0.511664 * x;
	result += shCoefficients[ 4 ] * 2.0 * 0.429043 * x * y;
	result += shCoefficients[ 5 ] * 2.0 * 0.429043 * y * z;
	result += shCoefficients[ 6 ] * ( 0.743125 * z * z - 0.247708 );
	result += shCoefficients[ 7 ] * 2.0 * 0.429043 * x * z;
	result += shCoefficients[ 8 ] * 0.429043 * ( x * x - y * y );
	return result;
}
vec3 getLightProbeIrradiance( const in vec3 lightProbe[ 9 ], const in vec3 normal ) {
	vec3 worldNormal = inverseTransformDirection( normal, viewMatrix );
	vec3 irradiance = shGetIrradianceAt( worldNormal, lightProbe );
	return irradiance;
}
vec3 getAmbientLightIrradiance( const in vec3 ambientLightColor ) {
	vec3 irradiance = ambientLightColor;
	return irradiance;
}
float getDistanceAttenuation( const in float lightDistance, const in float cutoffDistance, const in float decayExponent ) {
	#if defined ( PHYSICALLY_CORRECT_LIGHTS )
		float distanceFalloff = 1.0 / max( pow( lightDistance, decayExponent ), 0.01 );
		if ( cutoffDistance > 0.0 ) {
			distanceFalloff *= pow2( saturate( 1.0 - pow4( lightDistance / cutoffDistance ) ) );
		}
		return distanceFalloff;
	#else
		if ( cutoffDistance > 0.0 && decayExponent > 0.0 ) {
			return pow( saturate( - lightDistance / cutoffDistance + 1.0 ), decayExponent );
		}
		return 1.0;
	#endif
}
float getSpotAttenuation( const in float coneCosine, const in float penumbraCosine, const in float angleCosine ) {
	return smoothstep( coneCosine, penumbraCosine, angleCosine );
}
#if NUM_DIR_LIGHTS > 0
	struct DirectionalLight {
		vec3 direction;
		vec3 color;
	};
	uniform DirectionalLight directionalLights[ NUM_DIR_LIGHTS ];
	void getDirectionalLightInfo( const in DirectionalLight directionalLight, const in GeometricContext geometry, out IncidentLight light ) {
		light.color = directionalLight.color;
		light.direction = directionalLight.direction;
		light.visible = true;
	}
#endif
#if NUM_POINT_LIGHTS > 0
	struct PointLight {
		vec3 position;
		vec3 color;
		float distance;
		float decay;
	};
	uniform PointLight pointLights[ NUM_POINT_LIGHTS ];
	void getPointLightInfo( const in PointLight pointLight, const in GeometricContext geometry, out IncidentLight light ) {
		vec3 lVector = pointLight.position - geometry.position;
		light.direction = normalize( lVector );
		float lightDistance = length( lVector );
		light.color = pointLight.color;
		light.color *= getDistanceAttenuation( lightDistance, pointLight.distance, pointLight.decay );
		light.visible = ( light.color != vec3( 0.0 ) );
	}
#endif
#if NUM_SPOT_LIGHTS > 0
	struct SpotLight {
		vec3 position;
		vec3 direction;
		vec3 color;
		float distance;
		float decay;
		float coneCos;
		float penumbraCos;
	};
	uniform SpotLight spotLights[ NUM_SPOT_LIGHTS ];
	void getSpotLightInfo( const in SpotLight spotLight, const in GeometricContext geometry, out IncidentLight light ) {
		vec3 lVector = spotLight.position - geometry.position;
		light.direction = normalize( lVector );
		float angleCos = dot( light.direction, spotLight.direction );
		float spotAttenuation = getSpotAttenuation( spotLight.coneCos, spotLight.penumbraCos, angleCos );
		if ( spotAttenuation > 0.0 ) {
			float lightDistance = length( lVector );
			light.color = spotLight.color * spotAttenuation;
			light.color *= getDistanceAttenuation( lightDistance, spotLight.distance, spotLight.decay );
			light.visible = ( light.color != vec3( 0.0 ) );
		} else {
			light.color = vec3( 0.0 );
			light.visible = false;
		}
	}
#endif
#if NUM_RECT_AREA_LIGHTS > 0
	struct RectAreaLight {
		vec3 color;
		vec3 position;
		vec3 halfWidth;
		vec3 halfHeight;
	};
	uniform sampler2D ltc_1;	uniform sampler2D ltc_2;
	uniform RectAreaLight rectAreaLights[ NUM_RECT_AREA_LIGHTS ];
#endif
#if NUM_HEMI_LIGHTS > 0
	struct HemisphereLight {
		vec3 direction;
		vec3 skyColor;
		vec3 groundColor;
	};
	uniform HemisphereLight hemisphereLights[ NUM_HEMI_LIGHTS ];
	vec3 getHemisphereLightIrradiance( const in HemisphereLight hemiLight, const in vec3 normal ) {
		float dotNL = dot( normal, hemiLight.direction );
		float hemiDiffuseWeight = 0.5 * dotNL + 0.5;
		vec3 irradiance = mix( hemiLight.groundColor, hemiLight.skyColor, hemiDiffuseWeight );
		return irradiance;
	}
#endif`,cpr=`#if defined( USE_ENVMAP )
	#ifdef ENVMAP_MODE_REFRACTION
		uniform float refractionRatio;
	#endif
	vec3 getIBLIrradiance( const in vec3 normal ) {
		#if defined( ENVMAP_TYPE_CUBE_UV )
			vec3 worldNormal = inverseTransformDirection( normal, viewMatrix );
			vec4 envMapColor = textureCubeUV( envMap, worldNormal, 1.0 );
			return PI * envMapColor.rgb * envMapIntensity;
		#else
			return vec3( 0.0 );
		#endif
	}
	vec3 getIBLRadiance( const in vec3 viewDir, const in vec3 normal, const in float roughness ) {
		#if defined( ENVMAP_TYPE_CUBE_UV )
			vec3 reflectVec;
			#ifdef ENVMAP_MODE_REFLECTION
				reflectVec = reflect( - viewDir, normal );
				reflectVec = normalize( mix( reflectVec, normal, roughness * roughness) );
			#else
				reflectVec = refract( - viewDir, normal, refractionRatio );
			#endif
			reflectVec = inverseTransformDirection( reflectVec, viewMatrix );
			vec4 envMapColor = textureCubeUV( envMap, reflectVec, roughness );
			return envMapColor.rgb * envMapIntensity;
		#else
			return vec3( 0.0 );
		#endif
	}
#endif`,upr=`ToonMaterial material;
material.diffuseColor = diffuseColor.rgb;`,hpr=`varying vec3 vViewPosition;
struct ToonMaterial {
	vec3 diffuseColor;
};
void RE_Direct_Toon( const in IncidentLight directLight, const in GeometricContext geometry, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {
	vec3 irradiance = getGradientIrradiance( geometry.normal, directLight.direction ) * directLight.color;
	reflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
}
void RE_IndirectDiffuse_Toon( const in vec3 irradiance, const in GeometricContext geometry, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {
	reflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
}
#define RE_Direct				RE_Direct_Toon
#define RE_IndirectDiffuse		RE_IndirectDiffuse_Toon
#define Material_LightProbeLOD( material )	(0)`,fpr=`BlinnPhongMaterial material;
material.diffuseColor = diffuseColor.rgb;
material.specularColor = specular;
material.specularShininess = shininess;
material.specularStrength = specularStrength;`,ppr=`varying vec3 vViewPosition;
struct BlinnPhongMaterial {
	vec3 diffuseColor;
	vec3 specularColor;
	float specularShininess;
	float specularStrength;
};
void RE_Direct_BlinnPhong( const in IncidentLight directLight, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {
	float dotNL = saturate( dot( geometry.normal, directLight.direction ) );
	vec3 irradiance = dotNL * directLight.color;
	reflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
	reflectedLight.directSpecular += irradiance * BRDF_BlinnPhong( directLight.direction, geometry.viewDir, geometry.normal, material.specularColor, material.specularShininess ) * material.specularStrength;
}
void RE_IndirectDiffuse_BlinnPhong( const in vec3 irradiance, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {
	reflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
}
#define RE_Direct				RE_Direct_BlinnPhong
#define RE_IndirectDiffuse		RE_IndirectDiffuse_BlinnPhong
#define Material_LightProbeLOD( material )	(0)`,dpr=`PhysicalMaterial material;
material.diffuseColor = diffuseColor.rgb * ( 1.0 - metalnessFactor );
vec3 dxy = max( abs( dFdx( geometryNormal ) ), abs( dFdy( geometryNormal ) ) );
float geometryRoughness = max( max( dxy.x, dxy.y ), dxy.z );
material.roughness = max( roughnessFactor, 0.0525 );material.roughness += geometryRoughness;
material.roughness = min( material.roughness, 1.0 );
#ifdef IOR
	#ifdef SPECULAR
		float specularIntensityFactor = specularIntensity;
		vec3 specularColorFactor = specularColor;
		#ifdef USE_SPECULARINTENSITYMAP
			specularIntensityFactor *= texture2D( specularIntensityMap, vUv ).a;
		#endif
		#ifdef USE_SPECULARCOLORMAP
			specularColorFactor *= texture2D( specularColorMap, vUv ).rgb;
		#endif
		material.specularF90 = mix( specularIntensityFactor, 1.0, metalnessFactor );
	#else
		float specularIntensityFactor = 1.0;
		vec3 specularColorFactor = vec3( 1.0 );
		material.specularF90 = 1.0;
	#endif
	material.specularColor = mix( min( pow2( ( ior - 1.0 ) / ( ior + 1.0 ) ) * specularColorFactor, vec3( 1.0 ) ) * specularIntensityFactor, diffuseColor.rgb, metalnessFactor );
#else
	material.specularColor = mix( vec3( 0.04 ), diffuseColor.rgb, metalnessFactor );
	material.specularF90 = 1.0;
#endif
#ifdef USE_CLEARCOAT
	material.clearcoat = clearcoat;
	material.clearcoatRoughness = clearcoatRoughness;
	material.clearcoatF0 = vec3( 0.04 );
	material.clearcoatF90 = 1.0;
	#ifdef USE_CLEARCOATMAP
		material.clearcoat *= texture2D( clearcoatMap, vUv ).x;
	#endif
	#ifdef USE_CLEARCOAT_ROUGHNESSMAP
		material.clearcoatRoughness *= texture2D( clearcoatRoughnessMap, vUv ).y;
	#endif
	material.clearcoat = saturate( material.clearcoat );	material.clearcoatRoughness = max( material.clearcoatRoughness, 0.0525 );
	material.clearcoatRoughness += geometryRoughness;
	material.clearcoatRoughness = min( material.clearcoatRoughness, 1.0 );
#endif
#ifdef USE_SHEEN
	material.sheenColor = sheenColor;
	#ifdef USE_SHEENCOLORMAP
		material.sheenColor *= texture2D( sheenColorMap, vUv ).rgb;
	#endif
	material.sheenRoughness = clamp( sheenRoughness, 0.07, 1.0 );
	#ifdef USE_SHEENROUGHNESSMAP
		material.sheenRoughness *= texture2D( sheenRoughnessMap, vUv ).a;
	#endif
#endif`,mpr=`struct PhysicalMaterial {
	vec3 diffuseColor;
	float roughness;
	vec3 specularColor;
	float specularF90;
	#ifdef USE_CLEARCOAT
		float clearcoat;
		float clearcoatRoughness;
		vec3 clearcoatF0;
		float clearcoatF90;
	#endif
	#ifdef USE_SHEEN
		vec3 sheenColor;
		float sheenRoughness;
	#endif
};
vec3 clearcoatSpecular = vec3( 0.0 );
vec3 sheenSpecular = vec3( 0.0 );
float IBLSheenBRDF( const in vec3 normal, const in vec3 viewDir, const in float roughness) {
	float dotNV = saturate( dot( normal, viewDir ) );
	float r2 = roughness * roughness;
	float a = roughness < 0.25 ? -339.2 * r2 + 161.4 * roughness - 25.9 : -8.48 * r2 + 14.3 * roughness - 9.95;
	float b = roughness < 0.25 ? 44.0 * r2 - 23.7 * roughness + 3.26 : 1.97 * r2 - 3.27 * roughness + 0.72;
	float DG = exp( a * dotNV + b ) + ( roughness < 0.25 ? 0.0 : 0.1 * ( roughness - 0.25 ) );
	return saturate( DG * RECIPROCAL_PI );
}
vec2 DFGApprox( const in vec3 normal, const in vec3 viewDir, const in float roughness ) {
	float dotNV = saturate( dot( normal, viewDir ) );
	const vec4 c0 = vec4( - 1, - 0.0275, - 0.572, 0.022 );
	const vec4 c1 = vec4( 1, 0.0425, 1.04, - 0.04 );
	vec4 r = roughness * c0 + c1;
	float a004 = min( r.x * r.x, exp2( - 9.28 * dotNV ) ) * r.x + r.y;
	vec2 fab = vec2( - 1.04, 1.04 ) * a004 + r.zw;
	return fab;
}
vec3 EnvironmentBRDF( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float roughness ) {
	vec2 fab = DFGApprox( normal, viewDir, roughness );
	return specularColor * fab.x + specularF90 * fab.y;
}
void computeMultiscattering( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float roughness, inout vec3 singleScatter, inout vec3 multiScatter ) {
	vec2 fab = DFGApprox( normal, viewDir, roughness );
	vec3 FssEss = specularColor * fab.x + specularF90 * fab.y;
	float Ess = fab.x + fab.y;
	float Ems = 1.0 - Ess;
	vec3 Favg = specularColor + ( 1.0 - specularColor ) * 0.047619;	vec3 Fms = FssEss * Favg / ( 1.0 - Ems * Favg );
	singleScatter += FssEss;
	multiScatter += Fms * Ems;
}
#if NUM_RECT_AREA_LIGHTS > 0
	void RE_Direct_RectArea_Physical( const in RectAreaLight rectAreaLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {
		vec3 normal = geometry.normal;
		vec3 viewDir = geometry.viewDir;
		vec3 position = geometry.position;
		vec3 lightPos = rectAreaLight.position;
		vec3 halfWidth = rectAreaLight.halfWidth;
		vec3 halfHeight = rectAreaLight.halfHeight;
		vec3 lightColor = rectAreaLight.color;
		float roughness = material.roughness;
		vec3 rectCoords[ 4 ];
		rectCoords[ 0 ] = lightPos + halfWidth - halfHeight;		rectCoords[ 1 ] = lightPos - halfWidth - halfHeight;
		rectCoords[ 2 ] = lightPos - halfWidth + halfHeight;
		rectCoords[ 3 ] = lightPos + halfWidth + halfHeight;
		vec2 uv = LTC_Uv( normal, viewDir, roughness );
		vec4 t1 = texture2D( ltc_1, uv );
		vec4 t2 = texture2D( ltc_2, uv );
		mat3 mInv = mat3(
			vec3( t1.x, 0, t1.y ),
			vec3(    0, 1,    0 ),
			vec3( t1.z, 0, t1.w )
		);
		vec3 fresnel = ( material.specularColor * t2.x + ( vec3( 1.0 ) - material.specularColor ) * t2.y );
		reflectedLight.directSpecular += lightColor * fresnel * LTC_Evaluate( normal, viewDir, position, mInv, rectCoords );
		reflectedLight.directDiffuse += lightColor * material.diffuseColor * LTC_Evaluate( normal, viewDir, position, mat3( 1.0 ), rectCoords );
	}
#endif
void RE_Direct_Physical( const in IncidentLight directLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {
	float dotNL = saturate( dot( geometry.normal, directLight.direction ) );
	vec3 irradiance = dotNL * directLight.color;
	#ifdef USE_CLEARCOAT
		float dotNLcc = saturate( dot( geometry.clearcoatNormal, directLight.direction ) );
		vec3 ccIrradiance = dotNLcc * directLight.color;
		clearcoatSpecular += ccIrradiance * BRDF_GGX( directLight.direction, geometry.viewDir, geometry.clearcoatNormal, material.clearcoatF0, material.clearcoatF90, material.clearcoatRoughness );
	#endif
	#ifdef USE_SHEEN
		sheenSpecular += irradiance * BRDF_Sheen( directLight.direction, geometry.viewDir, geometry.normal, material.sheenColor, material.sheenRoughness );
	#endif
	reflectedLight.directSpecular += irradiance * BRDF_GGX( directLight.direction, geometry.viewDir, geometry.normal, material.specularColor, material.specularF90, material.roughness );
	reflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
}
void RE_IndirectDiffuse_Physical( const in vec3 irradiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {
	reflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
}
void RE_IndirectSpecular_Physical( const in vec3 radiance, const in vec3 irradiance, const in vec3 clearcoatRadiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight) {
	#ifdef USE_CLEARCOAT
		clearcoatSpecular += clearcoatRadiance * EnvironmentBRDF( geometry.clearcoatNormal, geometry.viewDir, material.clearcoatF0, material.clearcoatF90, material.clearcoatRoughness );
	#endif
	#ifdef USE_SHEEN
		sheenSpecular += irradiance * material.sheenColor * IBLSheenBRDF( geometry.normal, geometry.viewDir, material.sheenRoughness );
	#endif
	vec3 singleScattering = vec3( 0.0 );
	vec3 multiScattering = vec3( 0.0 );
	vec3 cosineWeightedIrradiance = irradiance * RECIPROCAL_PI;
	computeMultiscattering( geometry.normal, geometry.viewDir, material.specularColor, material.specularF90, material.roughness, singleScattering, multiScattering );
	vec3 diffuse = material.diffuseColor * ( 1.0 - ( singleScattering + multiScattering ) );
	reflectedLight.indirectSpecular += radiance * singleScattering;
	reflectedLight.indirectSpecular += multiScattering * cosineWeightedIrradiance;
	reflectedLight.indirectDiffuse += diffuse * cosineWeightedIrradiance;
}
#define RE_Direct				RE_Direct_Physical
#define RE_Direct_RectArea		RE_Direct_RectArea_Physical
#define RE_IndirectDiffuse		RE_IndirectDiffuse_Physical
#define RE_IndirectSpecular		RE_IndirectSpecular_Physical
float computeSpecularOcclusion( const in float dotNV, const in float ambientOcclusion, const in float roughness ) {
	return saturate( pow( dotNV + ambientOcclusion, exp2( - 16.0 * roughness - 1.0 ) ) - 1.0 + ambientOcclusion );
}`,gpr=`
GeometricContext geometry;
geometry.position = - vViewPosition;
geometry.normal = normal;
geometry.viewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( vViewPosition );
#ifdef USE_CLEARCOAT
	geometry.clearcoatNormal = clearcoatNormal;
#endif
IncidentLight directLight;
#if ( NUM_POINT_LIGHTS > 0 ) && defined( RE_Direct )
	PointLight pointLight;
	#if defined( USE_SHADOWMAP ) && NUM_POINT_LIGHT_SHADOWS > 0
	PointLightShadow pointLightShadow;
	#endif
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {
		pointLight = pointLights[ i ];
		getPointLightInfo( pointLight, geometry, directLight );
		#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_POINT_LIGHT_SHADOWS )
		pointLightShadow = pointLightShadows[ i ];
		directLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getPointShadow( pointShadowMap[ i ], pointLightShadow.shadowMapSize, pointLightShadow.shadowBias, pointLightShadow.shadowRadius, vPointShadowCoord[ i ], pointLightShadow.shadowCameraNear, pointLightShadow.shadowCameraFar ) : 1.0;
		#endif
		RE_Direct( directLight, geometry, material, reflectedLight );
	}
	#pragma unroll_loop_end
#endif
#if ( NUM_SPOT_LIGHTS > 0 ) && defined( RE_Direct )
	SpotLight spotLight;
	#if defined( USE_SHADOWMAP ) && NUM_SPOT_LIGHT_SHADOWS > 0
	SpotLightShadow spotLightShadow;
	#endif
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {
		spotLight = spotLights[ i ];
		getSpotLightInfo( spotLight, geometry, directLight );
		#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )
		spotLightShadow = spotLightShadows[ i ];
		directLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getShadow( spotShadowMap[ i ], spotLightShadow.shadowMapSize, spotLightShadow.shadowBias, spotLightShadow.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;
		#endif
		RE_Direct( directLight, geometry, material, reflectedLight );
	}
	#pragma unroll_loop_end
#endif
#if ( NUM_DIR_LIGHTS > 0 ) && defined( RE_Direct )
	DirectionalLight directionalLight;
	#if defined( USE_SHADOWMAP ) && NUM_DIR_LIGHT_SHADOWS > 0
	DirectionalLightShadow directionalLightShadow;
	#endif
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {
		directionalLight = directionalLights[ i ];
		getDirectionalLightInfo( directionalLight, geometry, directLight );
		#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS )
		directionalLightShadow = directionalLightShadows[ i ];
		directLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getShadow( directionalShadowMap[ i ], directionalLightShadow.shadowMapSize, directionalLightShadow.shadowBias, directionalLightShadow.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;
		#endif
		RE_Direct( directLight, geometry, material, reflectedLight );
	}
	#pragma unroll_loop_end
#endif
#if ( NUM_RECT_AREA_LIGHTS > 0 ) && defined( RE_Direct_RectArea )
	RectAreaLight rectAreaLight;
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_RECT_AREA_LIGHTS; i ++ ) {
		rectAreaLight = rectAreaLights[ i ];
		RE_Direct_RectArea( rectAreaLight, geometry, material, reflectedLight );
	}
	#pragma unroll_loop_end
#endif
#if defined( RE_IndirectDiffuse )
	vec3 iblIrradiance = vec3( 0.0 );
	vec3 irradiance = getAmbientLightIrradiance( ambientLightColor );
	irradiance += getLightProbeIrradiance( lightProbe, geometry.normal );
	#if ( NUM_HEMI_LIGHTS > 0 )
		#pragma unroll_loop_start
		for ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {
			irradiance += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry.normal );
		}
		#pragma unroll_loop_end
	#endif
#endif
#if defined( RE_IndirectSpecular )
	vec3 radiance = vec3( 0.0 );
	vec3 clearcoatRadiance = vec3( 0.0 );
#endif`,_pr=`#if defined( RE_IndirectDiffuse )
	#ifdef USE_LIGHTMAP
		vec4 lightMapTexel = texture2D( lightMap, vUv2 );
		vec3 lightMapIrradiance = lightMapTexel.rgb * lightMapIntensity;
		#ifndef PHYSICALLY_CORRECT_LIGHTS
			lightMapIrradiance *= PI;
		#endif
		irradiance += lightMapIrradiance;
	#endif
	#if defined( USE_ENVMAP ) && defined( STANDARD ) && defined( ENVMAP_TYPE_CUBE_UV )
		iblIrradiance += getIBLIrradiance( geometry.normal );
	#endif
#endif
#if defined( USE_ENVMAP ) && defined( RE_IndirectSpecular )
	radiance += getIBLRadiance( geometry.viewDir, geometry.normal, material.roughness );
	#ifdef USE_CLEARCOAT
		clearcoatRadiance += getIBLRadiance( geometry.viewDir, geometry.clearcoatNormal, material.clearcoatRoughness );
	#endif
#endif`,ypr=`#if defined( RE_IndirectDiffuse )
	RE_IndirectDiffuse( irradiance, geometry, material, reflectedLight );
#endif
#if defined( RE_IndirectSpecular )
	RE_IndirectSpecular( radiance, iblIrradiance, clearcoatRadiance, geometry, material, reflectedLight );
#endif`,vpr=`#if defined( USE_LOGDEPTHBUF ) && defined( USE_LOGDEPTHBUF_EXT )
	gl_FragDepthEXT = vIsPerspective == 0.0 ? gl_FragCoord.z : log2( vFragDepth ) * logDepthBufFC * 0.5;
#endif`,xpr=`#if defined( USE_LOGDEPTHBUF ) && defined( USE_LOGDEPTHBUF_EXT )
	uniform float logDepthBufFC;
	varying float vFragDepth;
	varying float vIsPerspective;
#endif`,bpr=`#ifdef USE_LOGDEPTHBUF
	#ifdef USE_LOGDEPTHBUF_EXT
		varying float vFragDepth;
		varying float vIsPerspective;
	#else
		uniform float logDepthBufFC;
	#endif
#endif`,wpr=`#ifdef USE_LOGDEPTHBUF
	#ifdef USE_LOGDEPTHBUF_EXT
		vFragDepth = 1.0 + gl_Position.w;
		vIsPerspective = float( isPerspectiveMatrix( projectionMatrix ) );
	#else
		if ( isPerspectiveMatrix( projectionMatrix ) ) {
			gl_Position.z = log2( max( EPSILON, gl_Position.w + 1.0 ) ) * logDepthBufFC - 1.0;
			gl_Position.z *= gl_Position.w;
		}
	#endif
#endif`,Spr=`#ifdef USE_MAP
	vec4 sampledDiffuseColor = texture2D( map, vUv );
	#ifdef DECODE_VIDEO_TEXTURE
		sampledDiffuseColor = vec4( mix( pow( sampledDiffuseColor.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), sampledDiffuseColor.rgb * 0.0773993808, vec3( lessThanEqual( sampledDiffuseColor.rgb, vec3( 0.04045 ) ) ) ), sampledDiffuseColor.w );
	#endif
	diffuseColor *= sampledDiffuseColor;
#endif`,Mpr=`#ifdef USE_MAP
	uniform sampler2D map;
#endif`,Epr=`#if defined( USE_MAP ) || defined( USE_ALPHAMAP )
	vec2 uv = ( uvTransform * vec3( gl_PointCoord.x, 1.0 - gl_PointCoord.y, 1 ) ).xy;
#endif
#ifdef USE_MAP
	diffuseColor *= texture2D( map, uv );
#endif
#ifdef USE_ALPHAMAP
	diffuseColor.a *= texture2D( alphaMap, uv ).g;
#endif`,Tpr=`#if defined( USE_MAP ) || defined( USE_ALPHAMAP )
	uniform mat3 uvTransform;
#endif
#ifdef USE_MAP
	uniform sampler2D map;
#endif
#ifdef USE_ALPHAMAP
	uniform sampler2D alphaMap;
#endif`,Cpr=`float metalnessFactor = metalness;
#ifdef USE_METALNESSMAP
	vec4 texelMetalness = texture2D( metalnessMap, vUv );
	metalnessFactor *= texelMetalness.b;
#endif`,Apr=`#ifdef USE_METALNESSMAP
	uniform sampler2D metalnessMap;
#endif`,Ppr=`#ifdef USE_MORPHNORMALS
	objectNormal *= morphTargetBaseInfluence;
	#ifdef MORPHTARGETS_TEXTURE
		for ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {
			if ( morphTargetInfluences[ i ] != 0.0 ) objectNormal += getMorph( gl_VertexID, i, 1, 2 ) * morphTargetInfluences[ i ];
		}
	#else
		objectNormal += morphNormal0 * morphTargetInfluences[ 0 ];
		objectNormal += morphNormal1 * morphTargetInfluences[ 1 ];
		objectNormal += morphNormal2 * morphTargetInfluences[ 2 ];
		objectNormal += morphNormal3 * morphTargetInfluences[ 3 ];
	#endif
#endif`,Ipr=`#ifdef USE_MORPHTARGETS
	uniform float morphTargetBaseInfluence;
	#ifdef MORPHTARGETS_TEXTURE
		uniform float morphTargetInfluences[ MORPHTARGETS_COUNT ];
		uniform sampler2DArray morphTargetsTexture;
		uniform vec2 morphTargetsTextureSize;
		vec3 getMorph( const in int vertexIndex, const in int morphTargetIndex, const in int offset, const in int stride ) {
			float texelIndex = float( vertexIndex * stride + offset );
			float y = floor( texelIndex / morphTargetsTextureSize.x );
			float x = texelIndex - y * morphTargetsTextureSize.x;
			vec3 morphUV = vec3( ( x + 0.5 ) / morphTargetsTextureSize.x, y / morphTargetsTextureSize.y, morphTargetIndex );
			return texture( morphTargetsTexture, morphUV ).xyz;
		}
	#else
		#ifndef USE_MORPHNORMALS
			uniform float morphTargetInfluences[ 8 ];
		#else
			uniform float morphTargetInfluences[ 4 ];
		#endif
	#endif
#endif`,Lpr=`#ifdef USE_MORPHTARGETS
	transformed *= morphTargetBaseInfluence;
	#ifdef MORPHTARGETS_TEXTURE
		for ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {
			#ifndef USE_MORPHNORMALS
				if ( morphTargetInfluences[ i ] != 0.0 ) transformed += getMorph( gl_VertexID, i, 0, 1 ) * morphTargetInfluences[ i ];
			#else
				if ( morphTargetInfluences[ i ] != 0.0 ) transformed += getMorph( gl_VertexID, i, 0, 2 ) * morphTargetInfluences[ i ];
			#endif
		}
	#else
		transformed += morphTarget0 * morphTargetInfluences[ 0 ];
		transformed += morphTarget1 * morphTargetInfluences[ 1 ];
		transformed += morphTarget2 * morphTargetInfluences[ 2 ];
		transformed += morphTarget3 * morphTargetInfluences[ 3 ];
		#ifndef USE_MORPHNORMALS
			transformed += morphTarget4 * morphTargetInfluences[ 4 ];
			transformed += morphTarget5 * morphTargetInfluences[ 5 ];
			transformed += morphTarget6 * morphTargetInfluences[ 6 ];
			transformed += morphTarget7 * morphTargetInfluences[ 7 ];
		#endif
	#endif
#endif`,kpr=`float faceDirection = gl_FrontFacing ? 1.0 : - 1.0;
#ifdef FLAT_SHADED
	vec3 fdx = vec3( dFdx( vViewPosition.x ), dFdx( vViewPosition.y ), dFdx( vViewPosition.z ) );
	vec3 fdy = vec3( dFdy( vViewPosition.x ), dFdy( vViewPosition.y ), dFdy( vViewPosition.z ) );
	vec3 normal = normalize( cross( fdx, fdy ) );
#else
	vec3 normal = normalize( vNormal );
	#ifdef DOUBLE_SIDED
		normal = normal * faceDirection;
	#endif
	#ifdef USE_TANGENT
		vec3 tangent = normalize( vTangent );
		vec3 bitangent = normalize( vBitangent );
		#ifdef DOUBLE_SIDED
			tangent = tangent * faceDirection;
			bitangent = bitangent * faceDirection;
		#endif
		#if defined( TANGENTSPACE_NORMALMAP ) || defined( USE_CLEARCOAT_NORMALMAP )
			mat3 vTBN = mat3( tangent, bitangent, normal );
		#endif
	#endif
#endif
vec3 geometryNormal = normal;`,Rpr=`#ifdef OBJECTSPACE_NORMALMAP
	normal = texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;
	#ifdef FLIP_SIDED
		normal = - normal;
	#endif
	#ifdef DOUBLE_SIDED
		normal = normal * faceDirection;
	#endif
	normal = normalize( normalMatrix * normal );
#elif defined( TANGENTSPACE_NORMALMAP )
	vec3 mapN = texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;
	mapN.xy *= normalScale;
	#ifdef USE_TANGENT
		normal = normalize( vTBN * mapN );
	#else
		normal = perturbNormal2Arb( - vViewPosition, normal, mapN, faceDirection );
	#endif
#elif defined( USE_BUMPMAP )
	normal = perturbNormalArb( - vViewPosition, normal, dHdxy_fwd(), faceDirection );
#endif`,Npr=`#ifndef FLAT_SHADED
	varying vec3 vNormal;
	#ifdef USE_TANGENT
		varying vec3 vTangent;
		varying vec3 vBitangent;
	#endif
#endif`,Dpr=`#ifndef FLAT_SHADED
	varying vec3 vNormal;
	#ifdef USE_TANGENT
		varying vec3 vTangent;
		varying vec3 vBitangent;
	#endif
#endif`,Opr=`#ifndef FLAT_SHADED
	vNormal = normalize( transformedNormal );
	#ifdef USE_TANGENT
		vTangent = normalize( transformedTangent );
		vBitangent = normalize( cross( vNormal, vTangent ) * tangent.w );
	#endif
#endif`,zpr=`#ifdef USE_NORMALMAP
	uniform sampler2D normalMap;
	uniform vec2 normalScale;
#endif
#ifdef OBJECTSPACE_NORMALMAP
	uniform mat3 normalMatrix;
#endif
#if ! defined ( USE_TANGENT ) && ( defined ( TANGENTSPACE_NORMALMAP ) || defined ( USE_CLEARCOAT_NORMALMAP ) )
	vec3 perturbNormal2Arb( vec3 eye_pos, vec3 surf_norm, vec3 mapN, float faceDirection ) {
		vec3 q0 = vec3( dFdx( eye_pos.x ), dFdx( eye_pos.y ), dFdx( eye_pos.z ) );
		vec3 q1 = vec3( dFdy( eye_pos.x ), dFdy( eye_pos.y ), dFdy( eye_pos.z ) );
		vec2 st0 = dFdx( vUv.st );
		vec2 st1 = dFdy( vUv.st );
		vec3 N = surf_norm;
		vec3 q1perp = cross( q1, N );
		vec3 q0perp = cross( N, q0 );
		vec3 T = q1perp * st0.x + q0perp * st1.x;
		vec3 B = q1perp * st0.y + q0perp * st1.y;
		float det = max( dot( T, T ), dot( B, B ) );
		float scale = ( det == 0.0 ) ? 0.0 : faceDirection * inversesqrt( det );
		return normalize( T * ( mapN.x * scale ) + B * ( mapN.y * scale ) + N * mapN.z );
	}
#endif`,Fpr=`#ifdef USE_CLEARCOAT
	vec3 clearcoatNormal = geometryNormal;
#endif`,Bpr=`#ifdef USE_CLEARCOAT_NORMALMAP
	vec3 clearcoatMapN = texture2D( clearcoatNormalMap, vUv ).xyz * 2.0 - 1.0;
	clearcoatMapN.xy *= clearcoatNormalScale;
	#ifdef USE_TANGENT
		clearcoatNormal = normalize( vTBN * clearcoatMapN );
	#else
		clearcoatNormal = perturbNormal2Arb( - vViewPosition, clearcoatNormal, clearcoatMapN, faceDirection );
	#endif
#endif`,Hpr=`#ifdef USE_CLEARCOATMAP
	uniform sampler2D clearcoatMap;
#endif
#ifdef USE_CLEARCOAT_ROUGHNESSMAP
	uniform sampler2D clearcoatRoughnessMap;
#endif
#ifdef USE_CLEARCOAT_NORMALMAP
	uniform sampler2D clearcoatNormalMap;
	uniform vec2 clearcoatNormalScale;
#endif`,Vpr=`#ifdef OPAQUE
diffuseColor.a = 1.0;
#endif
#ifdef USE_TRANSMISSION
diffuseColor.a *= transmissionAlpha + 0.1;
#endif
gl_FragColor = vec4( outgoingLight, diffuseColor.a );`,Upr=`vec3 packNormalToRGB( const in vec3 normal ) {
	return normalize( normal ) * 0.5 + 0.5;
}
vec3 unpackRGBToNormal( const in vec3 rgb ) {
	return 2.0 * rgb.xyz - 1.0;
}
const float PackUpscale = 256. / 255.;const float UnpackDownscale = 255. / 256.;
const vec3 PackFactors = vec3( 256. * 256. * 256., 256. * 256., 256. );
const vec4 UnpackFactors = UnpackDownscale / vec4( PackFactors, 1. );
const float ShiftRight8 = 1. / 256.;
vec4 packDepthToRGBA( const in float v ) {
	vec4 r = vec4( fract( v * PackFactors ), v );
	r.yzw -= r.xyz * ShiftRight8;	return r * PackUpscale;
}
float unpackRGBAToDepth( const in vec4 v ) {
	return dot( v, UnpackFactors );
}
vec4 pack2HalfToRGBA( vec2 v ) {
	vec4 r = vec4( v.x, fract( v.x * 255.0 ), v.y, fract( v.y * 255.0 ) );
	return vec4( r.x - r.y / 255.0, r.y, r.z - r.w / 255.0, r.w );
}
vec2 unpackRGBATo2Half( vec4 v ) {
	return vec2( v.x + ( v.y / 255.0 ), v.z + ( v.w / 255.0 ) );
}
float viewZToOrthographicDepth( const in float viewZ, const in float near, const in float far ) {
	return ( viewZ + near ) / ( near - far );
}
float orthographicDepthToViewZ( const in float linearClipZ, const in float near, const in float far ) {
	return linearClipZ * ( near - far ) - near;
}
float viewZToPerspectiveDepth( const in float viewZ, const in float near, const in float far ) {
	return ( ( near + viewZ ) * far ) / ( ( far - near ) * viewZ );
}
float perspectiveDepthToViewZ( const in float invClipZ, const in float near, const in float far ) {
	return ( near * far ) / ( ( far - near ) * invClipZ - far );
}`,qpr=`#ifdef PREMULTIPLIED_ALPHA
	gl_FragColor.rgb *= gl_FragColor.a;
#endif`,Gpr=`vec4 mvPosition = vec4( transformed, 1.0 );
#ifdef USE_INSTANCING
	mvPosition = instanceMatrix * mvPosition;
#endif
mvPosition = modelViewMatrix * mvPosition;
gl_Position = projectionMatrix * mvPosition;`,Wpr=`#ifdef DITHERING
	gl_FragColor.rgb = dithering( gl_FragColor.rgb );
#endif`,Ypr=`#ifdef DITHERING
	vec3 dithering( vec3 color ) {
		float grid_position = rand( gl_FragCoord.xy );
		vec3 dither_shift_RGB = vec3( 0.25 / 255.0, -0.25 / 255.0, 0.25 / 255.0 );
		dither_shift_RGB = mix( 2.0 * dither_shift_RGB, -2.0 * dither_shift_RGB, grid_position );
		return color + dither_shift_RGB;
	}
#endif`,jpr=`float roughnessFactor = roughness;
#ifdef USE_ROUGHNESSMAP
	vec4 texelRoughness = texture2D( roughnessMap, vUv );
	roughnessFactor *= texelRoughness.g;
#endif`,Xpr=`#ifdef USE_ROUGHNESSMAP
	uniform sampler2D roughnessMap;
#endif`,$pr=`#ifdef USE_SHADOWMAP
	#if NUM_DIR_LIGHT_SHADOWS > 0
		uniform sampler2D directionalShadowMap[ NUM_DIR_LIGHT_SHADOWS ];
		varying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];
		struct DirectionalLightShadow {
			float shadowBias;
			float shadowNormalBias;
			float shadowRadius;
			vec2 shadowMapSize;
		};
		uniform DirectionalLightShadow directionalLightShadows[ NUM_DIR_LIGHT_SHADOWS ];
	#endif
	#if NUM_SPOT_LIGHT_SHADOWS > 0
		uniform sampler2D spotShadowMap[ NUM_SPOT_LIGHT_SHADOWS ];
		varying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHT_SHADOWS ];
		struct SpotLightShadow {
			float shadowBias;
			float shadowNormalBias;
			float shadowRadius;
			vec2 shadowMapSize;
		};
		uniform SpotLightShadow spotLightShadows[ NUM_SPOT_LIGHT_SHADOWS ];
	#endif
	#if NUM_POINT_LIGHT_SHADOWS > 0
		uniform sampler2D pointShadowMap[ NUM_POINT_LIGHT_SHADOWS ];
		varying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];
		struct PointLightShadow {
			float shadowBias;
			float shadowNormalBias;
			float shadowRadius;
			vec2 shadowMapSize;
			float shadowCameraNear;
			float shadowCameraFar;
		};
		uniform PointLightShadow pointLightShadows[ NUM_POINT_LIGHT_SHADOWS ];
	#endif
	float texture2DCompare( sampler2D depths, vec2 uv, float compare ) {
		return step( compare, unpackRGBAToDepth( texture2D( depths, uv ) ) );
	}
	vec2 texture2DDistribution( sampler2D shadow, vec2 uv ) {
		return unpackRGBATo2Half( texture2D( shadow, uv ) );
	}
	float VSMShadow (sampler2D shadow, vec2 uv, float compare ){
		float occlusion = 1.0;
		vec2 distribution = texture2DDistribution( shadow, uv );
		float hard_shadow = step( compare , distribution.x );
		if (hard_shadow != 1.0 ) {
			float distance = compare - distribution.x ;
			float variance = max( 0.00000, distribution.y * distribution.y );
			float softness_probability = variance / (variance + distance * distance );			softness_probability = clamp( ( softness_probability - 0.3 ) / ( 0.95 - 0.3 ), 0.0, 1.0 );			occlusion = clamp( max( hard_shadow, softness_probability ), 0.0, 1.0 );
		}
		return occlusion;
	}
	float getShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord ) {
		float shadow = 1.0;
		shadowCoord.xyz /= shadowCoord.w;
		shadowCoord.z += shadowBias;
		bvec4 inFrustumVec = bvec4 ( shadowCoord.x >= 0.0, shadowCoord.x <= 1.0, shadowCoord.y >= 0.0, shadowCoord.y <= 1.0 );
		bool inFrustum = all( inFrustumVec );
		bvec2 frustumTestVec = bvec2( inFrustum, shadowCoord.z <= 1.0 );
		bool frustumTest = all( frustumTestVec );
		if ( frustumTest ) {
		#if defined( SHADOWMAP_TYPE_PCF )
			vec2 texelSize = vec2( 1.0 ) / shadowMapSize;
			float dx0 = - texelSize.x * shadowRadius;
			float dy0 = - texelSize.y * shadowRadius;
			float dx1 = + texelSize.x * shadowRadius;
			float dy1 = + texelSize.y * shadowRadius;
			float dx2 = dx0 / 2.0;
			float dy2 = dy0 / 2.0;
			float dx3 = dx1 / 2.0;
			float dy3 = dy1 / 2.0;
			shadow = (
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, dy2 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy2 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, dy2 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, 0.0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, 0.0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, 0.0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, 0.0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, dy3 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy3 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, dy3 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy1 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy1 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy1 ), shadowCoord.z )
			) * ( 1.0 / 17.0 );
		#elif defined( SHADOWMAP_TYPE_PCF_SOFT )
			vec2 texelSize = vec2( 1.0 ) / shadowMapSize;
			float dx = texelSize.x;
			float dy = texelSize.y;
			vec2 uv = shadowCoord.xy;
			vec2 f = fract( uv * shadowMapSize + 0.5 );
			uv -= f * texelSize;
			shadow = (
				texture2DCompare( shadowMap, uv, shadowCoord.z ) +
				texture2DCompare( shadowMap, uv + vec2( dx, 0.0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, uv + vec2( 0.0, dy ), shadowCoord.z ) +
				texture2DCompare( shadowMap, uv + texelSize, shadowCoord.z ) +
				mix( texture2DCompare( shadowMap, uv + vec2( -dx, 0.0 ), shadowCoord.z ), 
					 texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, 0.0 ), shadowCoord.z ),
					 f.x ) +
				mix( texture2DCompare( shadowMap, uv + vec2( -dx, dy ), shadowCoord.z ), 
					 texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, dy ), shadowCoord.z ),
					 f.x ) +
				mix( texture2DCompare( shadowMap, uv + vec2( 0.0, -dy ), shadowCoord.z ), 
					 texture2DCompare( shadowMap, uv + vec2( 0.0, 2.0 * dy ), shadowCoord.z ),
					 f.y ) +
				mix( texture2DCompare( shadowMap, uv + vec2( dx, -dy ), shadowCoord.z ), 
					 texture2DCompare( shadowMap, uv + vec2( dx, 2.0 * dy ), shadowCoord.z ),
					 f.y ) +
				mix( mix( texture2DCompare( shadowMap, uv + vec2( -dx, -dy ), shadowCoord.z ), 
						  texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, -dy ), shadowCoord.z ),
						  f.x ),
					 mix( texture2DCompare( shadowMap, uv + vec2( -dx, 2.0 * dy ), shadowCoord.z ), 
						  texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, 2.0 * dy ), shadowCoord.z ),
						  f.x ),
					 f.y )
			) * ( 1.0 / 9.0 );
		#elif defined( SHADOWMAP_TYPE_VSM )
			shadow = VSMShadow( shadowMap, shadowCoord.xy, shadowCoord.z );
		#else
			shadow = texture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z );
		#endif
		}
		return shadow;
	}
	vec2 cubeToUV( vec3 v, float texelSizeY ) {
		vec3 absV = abs( v );
		float scaleToCube = 1.0 / max( absV.x, max( absV.y, absV.z ) );
		absV *= scaleToCube;
		v *= scaleToCube * ( 1.0 - 2.0 * texelSizeY );
		vec2 planar = v.xy;
		float almostATexel = 1.5 * texelSizeY;
		float almostOne = 1.0 - almostATexel;
		if ( absV.z >= almostOne ) {
			if ( v.z > 0.0 )
				planar.x = 4.0 - v.x;
		} else if ( absV.x >= almostOne ) {
			float signX = sign( v.x );
			planar.x = v.z * signX + 2.0 * signX;
		} else if ( absV.y >= almostOne ) {
			float signY = sign( v.y );
			planar.x = v.x + 2.0 * signY + 2.0;
			planar.y = v.z * signY - 2.0;
		}
		return vec2( 0.125, 0.25 ) * planar + vec2( 0.375, 0.75 );
	}
	float getPointShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord, float shadowCameraNear, float shadowCameraFar ) {
		vec2 texelSize = vec2( 1.0 ) / ( shadowMapSize * vec2( 4.0, 2.0 ) );
		vec3 lightToPosition = shadowCoord.xyz;
		float dp = ( length( lightToPosition ) - shadowCameraNear ) / ( shadowCameraFar - shadowCameraNear );		dp += shadowBias;
		vec3 bd3D = normalize( lightToPosition );
		#if defined( SHADOWMAP_TYPE_PCF ) || defined( SHADOWMAP_TYPE_PCF_SOFT ) || defined( SHADOWMAP_TYPE_VSM )
			vec2 offset = vec2( - 1, 1 ) * shadowRadius * texelSize.y;
			return (
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyy, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyy, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyx, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyx, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxy, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxy, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxx, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxx, texelSize.y ), dp )
			) * ( 1.0 / 9.0 );
		#else
			return texture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp );
		#endif
	}
#endif`,Kpr=`#ifdef USE_SHADOWMAP
	#if NUM_DIR_LIGHT_SHADOWS > 0
		uniform mat4 directionalShadowMatrix[ NUM_DIR_LIGHT_SHADOWS ];
		varying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];
		struct DirectionalLightShadow {
			float shadowBias;
			float shadowNormalBias;
			float shadowRadius;
			vec2 shadowMapSize;
		};
		uniform DirectionalLightShadow directionalLightShadows[ NUM_DIR_LIGHT_SHADOWS ];
	#endif
	#if NUM_SPOT_LIGHT_SHADOWS > 0
		uniform mat4 spotShadowMatrix[ NUM_SPOT_LIGHT_SHADOWS ];
		varying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHT_SHADOWS ];
		struct SpotLightShadow {
			float shadowBias;
			float shadowNormalBias;
			float shadowRadius;
			vec2 shadowMapSize;
		};
		uniform SpotLightShadow spotLightShadows[ NUM_SPOT_LIGHT_SHADOWS ];
	#endif
	#if NUM_POINT_LIGHT_SHADOWS > 0
		uniform mat4 pointShadowMatrix[ NUM_POINT_LIGHT_SHADOWS ];
		varying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];
		struct PointLightShadow {
			float shadowBias;
			float shadowNormalBias;
			float shadowRadius;
			vec2 shadowMapSize;
			float shadowCameraNear;
			float shadowCameraFar;
		};
		uniform PointLightShadow pointLightShadows[ NUM_POINT_LIGHT_SHADOWS ];
	#endif
#endif`,Zpr=`#ifdef USE_SHADOWMAP
	#if NUM_DIR_LIGHT_SHADOWS > 0 || NUM_SPOT_LIGHT_SHADOWS > 0 || NUM_POINT_LIGHT_SHADOWS > 0
		vec3 shadowWorldNormal = inverseTransformDirection( transformedNormal, viewMatrix );
		vec4 shadowWorldPosition;
	#endif
	#if NUM_DIR_LIGHT_SHADOWS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {
		shadowWorldPosition = worldPosition + vec4( shadowWorldNormal * directionalLightShadows[ i ].shadowNormalBias, 0 );
		vDirectionalShadowCoord[ i ] = directionalShadowMatrix[ i ] * shadowWorldPosition;
	}
	#pragma unroll_loop_end
	#endif
	#if NUM_SPOT_LIGHT_SHADOWS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_SPOT_LIGHT_SHADOWS; i ++ ) {
		shadowWorldPosition = worldPosition + vec4( shadowWorldNormal * spotLightShadows[ i ].shadowNormalBias, 0 );
		vSpotShadowCoord[ i ] = spotShadowMatrix[ i ] * shadowWorldPosition;
	}
	#pragma unroll_loop_end
	#endif
	#if NUM_POINT_LIGHT_SHADOWS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {
		shadowWorldPosition = worldPosition + vec4( shadowWorldNormal * pointLightShadows[ i ].shadowNormalBias, 0 );
		vPointShadowCoord[ i ] = pointShadowMatrix[ i ] * shadowWorldPosition;
	}
	#pragma unroll_loop_end
	#endif
#endif`,Jpr=`float getShadowMask() {
	float shadow = 1.0;
	#ifdef USE_SHADOWMAP
	#if NUM_DIR_LIGHT_SHADOWS > 0
	DirectionalLightShadow directionalLight;
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {
		directionalLight = directionalLightShadows[ i ];
		shadow *= receiveShadow ? getShadow( directionalShadowMap[ i ], directionalLight.shadowMapSize, directionalLight.shadowBias, directionalLight.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;
	}
	#pragma unroll_loop_end
	#endif
	#if NUM_SPOT_LIGHT_SHADOWS > 0
	SpotLightShadow spotLight;
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_SPOT_LIGHT_SHADOWS; i ++ ) {
		spotLight = spotLightShadows[ i ];
		shadow *= receiveShadow ? getShadow( spotShadowMap[ i ], spotLight.shadowMapSize, spotLight.shadowBias, spotLight.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;
	}
	#pragma unroll_loop_end
	#endif
	#if NUM_POINT_LIGHT_SHADOWS > 0
	PointLightShadow pointLight;
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {
		pointLight = pointLightShadows[ i ];
		shadow *= receiveShadow ? getPointShadow( pointShadowMap[ i ], pointLight.shadowMapSize, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ i ], pointLight.shadowCameraNear, pointLight.shadowCameraFar ) : 1.0;
	}
	#pragma unroll_loop_end
	#endif
	#endif
	return shadow;
}`,Qpr=`#ifdef USE_SKINNING
	mat4 boneMatX = getBoneMatrix( skinIndex.x );
	mat4 boneMatY = getBoneMatrix( skinIndex.y );
	mat4 boneMatZ = getBoneMatrix( skinIndex.z );
	mat4 boneMatW = getBoneMatrix( skinIndex.w );
#endif`,tdr=`#ifdef USE_SKINNING
	uniform mat4 bindMatrix;
	uniform mat4 bindMatrixInverse;
	#ifdef BONE_TEXTURE
		uniform highp sampler2D boneTexture;
		uniform int boneTextureSize;
		mat4 getBoneMatrix( const in float i ) {
			float j = i * 4.0;
			float x = mod( j, float( boneTextureSize ) );
			float y = floor( j / float( boneTextureSize ) );
			float dx = 1.0 / float( boneTextureSize );
			float dy = 1.0 / float( boneTextureSize );
			y = dy * ( y + 0.5 );
			vec4 v1 = texture2D( boneTexture, vec2( dx * ( x + 0.5 ), y ) );
			vec4 v2 = texture2D( boneTexture, vec2( dx * ( x + 1.5 ), y ) );
			vec4 v3 = texture2D( boneTexture, vec2( dx * ( x + 2.5 ), y ) );
			vec4 v4 = texture2D( boneTexture, vec2( dx * ( x + 3.5 ), y ) );
			mat4 bone = mat4( v1, v2, v3, v4 );
			return bone;
		}
	#else
		uniform mat4 boneMatrices[ MAX_BONES ];
		mat4 getBoneMatrix( const in float i ) {
			mat4 bone = boneMatrices[ int(i) ];
			return bone;
		}
	#endif
#endif`,edr=`#ifdef USE_SKINNING
	vec4 skinVertex = bindMatrix * vec4( transformed, 1.0 );
	vec4 skinned = vec4( 0.0 );
	skinned += boneMatX * skinVertex * skinWeight.x;
	skinned += boneMatY * skinVertex * skinWeight.y;
	skinned += boneMatZ * skinVertex * skinWeight.z;
	skinned += boneMatW * skinVertex * skinWeight.w;
	transformed = ( bindMatrixInverse * skinned ).xyz;
#endif`,rdr=`#ifdef USE_SKINNING
	mat4 skinMatrix = mat4( 0.0 );
	skinMatrix += skinWeight.x * boneMatX;
	skinMatrix += skinWeight.y * boneMatY;
	skinMatrix += skinWeight.z * boneMatZ;
	skinMatrix += skinWeight.w * boneMatW;
	skinMatrix = bindMatrixInverse * skinMatrix * bindMatrix;
	objectNormal = vec4( skinMatrix * vec4( objectNormal, 0.0 ) ).xyz;
	#ifdef USE_TANGENT
		objectTangent = vec4( skinMatrix * vec4( objectTangent, 0.0 ) ).xyz;
	#endif
#endif`,ndr=`float specularStrength;
#ifdef USE_SPECULARMAP
	vec4 texelSpecular = texture2D( specularMap, vUv );
	specularStrength = texelSpecular.r;
#else
	specularStrength = 1.0;
#endif`,idr=`#ifdef USE_SPECULARMAP
	uniform sampler2D specularMap;
#endif`,odr=`#if defined( TONE_MAPPING )
	gl_FragColor.rgb = toneMapping( gl_FragColor.rgb );
#endif`,adr=`#ifndef saturate
#define saturate( a ) clamp( a, 0.0, 1.0 )
#endif
uniform float toneMappingExposure;
vec3 LinearToneMapping( vec3 color ) {
	return toneMappingExposure * color;
}
vec3 ReinhardToneMapping( vec3 color ) {
	color *= toneMappingExposure;
	return saturate( color / ( vec3( 1.0 ) + color ) );
}
vec3 OptimizedCineonToneMapping( vec3 color ) {
	color *= toneMappingExposure;
	color = max( vec3( 0.0 ), color - 0.004 );
	return pow( ( color * ( 6.2 * color + 0.5 ) ) / ( color * ( 6.2 * color + 1.7 ) + 0.06 ), vec3( 2.2 ) );
}
vec3 RRTAndODTFit( vec3 v ) {
	vec3 a = v * ( v + 0.0245786 ) - 0.000090537;
	vec3 b = v * ( 0.983729 * v + 0.4329510 ) + 0.238081;
	return a / b;
}
vec3 ACESFilmicToneMapping( vec3 color ) {
	const mat3 ACESInputMat = mat3(
		vec3( 0.59719, 0.07600, 0.02840 ),		vec3( 0.35458, 0.90834, 0.13383 ),
		vec3( 0.04823, 0.01566, 0.83777 )
	);
	const mat3 ACESOutputMat = mat3(
		vec3(  1.60475, -0.10208, -0.00327 ),		vec3( -0.53108,  1.10813, -0.07276 ),
		vec3( -0.07367, -0.00605,  1.07602 )
	);
	color *= toneMappingExposure / 0.6;
	color = ACESInputMat * color;
	color = RRTAndODTFit( color );
	color = ACESOutputMat * color;
	return saturate( color );
}
vec3 CustomToneMapping( vec3 color ) { return color; }`,sdr=`#ifdef USE_TRANSMISSION
	float transmissionAlpha = 1.0;
	float transmissionFactor = transmission;
	float thicknessFactor = thickness;
	#ifdef USE_TRANSMISSIONMAP
		transmissionFactor *= texture2D( transmissionMap, vUv ).r;
	#endif
	#ifdef USE_THICKNESSMAP
		thicknessFactor *= texture2D( thicknessMap, vUv ).g;
	#endif
	vec3 pos = vWorldPosition;
	vec3 v = normalize( cameraPosition - pos );
	vec3 n = inverseTransformDirection( normal, viewMatrix );
	vec4 transmission = getIBLVolumeRefraction(
		n, v, roughnessFactor, material.diffuseColor, material.specularColor, material.specularF90,
		pos, modelMatrix, viewMatrix, projectionMatrix, ior, thicknessFactor,
		attenuationColor, attenuationDistance );
	totalDiffuse = mix( totalDiffuse, transmission.rgb, transmissionFactor );
	transmissionAlpha = mix( transmissionAlpha, transmission.a, transmissionFactor );
#endif`,ldr=`#ifdef USE_TRANSMISSION
	uniform float transmission;
	uniform float thickness;
	uniform float attenuationDistance;
	uniform vec3 attenuationColor;
	#ifdef USE_TRANSMISSIONMAP
		uniform sampler2D transmissionMap;
	#endif
	#ifdef USE_THICKNESSMAP
		uniform sampler2D thicknessMap;
	#endif
	uniform vec2 transmissionSamplerSize;
	uniform sampler2D transmissionSamplerMap;
	uniform mat4 modelMatrix;
	uniform mat4 projectionMatrix;
	varying vec3 vWorldPosition;
	vec3 getVolumeTransmissionRay( const in vec3 n, const in vec3 v, const in float thickness, const in float ior, const in mat4 modelMatrix ) {
		vec3 refractionVector = refract( - v, normalize( n ), 1.0 / ior );
		vec3 modelScale;
		modelScale.x = length( vec3( modelMatrix[ 0 ].xyz ) );
		modelScale.y = length( vec3( modelMatrix[ 1 ].xyz ) );
		modelScale.z = length( vec3( modelMatrix[ 2 ].xyz ) );
		return normalize( refractionVector ) * thickness * modelScale;
	}
	float applyIorToRoughness( const in float roughness, const in float ior ) {
		return roughness * clamp( ior * 2.0 - 2.0, 0.0, 1.0 );
	}
	vec4 getTransmissionSample( const in vec2 fragCoord, const in float roughness, const in float ior ) {
		float framebufferLod = log2( transmissionSamplerSize.x ) * applyIorToRoughness( roughness, ior );
		#ifdef TEXTURE_LOD_EXT
			return texture2DLodEXT( transmissionSamplerMap, fragCoord.xy, framebufferLod );
		#else
			return texture2D( transmissionSamplerMap, fragCoord.xy, framebufferLod );
		#endif
	}
	vec3 applyVolumeAttenuation( const in vec3 radiance, const in float transmissionDistance, const in vec3 attenuationColor, const in float attenuationDistance ) {
		if ( attenuationDistance == 0.0 ) {
			return radiance;
		} else {
			vec3 attenuationCoefficient = -log( attenuationColor ) / attenuationDistance;
			vec3 transmittance = exp( - attenuationCoefficient * transmissionDistance );			return transmittance * radiance;
		}
	}
	vec4 getIBLVolumeRefraction( const in vec3 n, const in vec3 v, const in float roughness, const in vec3 diffuseColor,
		const in vec3 specularColor, const in float specularF90, const in vec3 position, const in mat4 modelMatrix,
		const in mat4 viewMatrix, const in mat4 projMatrix, const in float ior, const in float thickness,
		const in vec3 attenuationColor, const in float attenuationDistance ) {
		vec3 transmissionRay = getVolumeTransmissionRay( n, v, thickness, ior, modelMatrix );
		vec3 refractedRayExit = position + transmissionRay;
		vec4 ndcPos = projMatrix * viewMatrix * vec4( refractedRayExit, 1.0 );
		vec2 refractionCoords = ndcPos.xy / ndcPos.w;
		refractionCoords += 1.0;
		refractionCoords /= 2.0;
		vec4 transmittedLight = getTransmissionSample( refractionCoords, roughness, ior );
		vec3 attenuatedColor = applyVolumeAttenuation( transmittedLight.rgb, length( transmissionRay ), attenuationColor, attenuationDistance );
		vec3 F = EnvironmentBRDF( n, v, specularColor, specularF90, roughness );
		return vec4( ( 1.0 - F ) * attenuatedColor * diffuseColor, transmittedLight.a );
	}
#endif`,cdr=`#if ( defined( USE_UV ) && ! defined( UVS_VERTEX_ONLY ) )
	varying vec2 vUv;
#endif`,udr=`#ifdef USE_UV
	#ifdef UVS_VERTEX_ONLY
		vec2 vUv;
	#else
		varying vec2 vUv;
	#endif
	uniform mat3 uvTransform;
#endif`,hdr=`#ifdef USE_UV
	vUv = ( uvTransform * vec3( uv, 1 ) ).xy;
#endif`,fdr=`#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )
	varying vec2 vUv2;
#endif`,pdr=`#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )
	attribute vec2 uv2;
	varying vec2 vUv2;
	uniform mat3 uv2Transform;
#endif`,ddr=`#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )
	vUv2 = ( uv2Transform * vec3( uv2, 1 ) ).xy;
#endif`,mdr=`#if defined( USE_ENVMAP ) || defined( DISTANCE ) || defined ( USE_SHADOWMAP ) || defined ( USE_TRANSMISSION )
	vec4 worldPosition = vec4( transformed, 1.0 );
	#ifdef USE_INSTANCING
		worldPosition = instanceMatrix * worldPosition;
	#endif
	worldPosition = modelMatrix * worldPosition;
#endif`,gdr=`varying vec2 vUv;
uniform mat3 uvTransform;
void main() {
	vUv = ( uvTransform * vec3( uv, 1 ) ).xy;
	gl_Position = vec4( position.xy, 1.0, 1.0 );
}`,_dr=`uniform sampler2D t2D;
varying vec2 vUv;
void main() {
	gl_FragColor = texture2D( t2D, vUv );
	#include <tonemapping_fragment>
	#include <encodings_fragment>
}`,ydr=`varying vec3 vWorldDirection;
#include <common>
void main() {
	vWorldDirection = transformDirection( position, modelMatrix );
	#include <begin_vertex>
	#include <project_vertex>
	gl_Position.z = gl_Position.w;
}`,vdr=`#include <envmap_common_pars_fragment>
uniform float opacity;
varying vec3 vWorldDirection;
#include <cube_uv_reflection_fragment>
void main() {
	vec3 vReflect = vWorldDirection;
	#include <envmap_fragment>
	gl_FragColor = envColor;
	gl_FragColor.a *= opacity;
	#include <tonemapping_fragment>
	#include <encodings_fragment>
}`,xdr=`#include <common>
#include <uv_pars_vertex>
#include <displacementmap_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
varying vec2 vHighPrecisionZW;
void main() {
	#include <uv_vertex>
	#include <skinbase_vertex>
	#ifdef USE_DISPLACEMENTMAP
		#include <beginnormal_vertex>
		#include <morphnormal_vertex>
		#include <skinnormal_vertex>
	#endif
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	vHighPrecisionZW = gl_Position.zw;
}`,bdr=`#if DEPTH_PACKING == 3200
	uniform float opacity;
#endif
#include <common>
#include <packing>
#include <uv_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
varying vec2 vHighPrecisionZW;
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( 1.0 );
	#if DEPTH_PACKING == 3200
		diffuseColor.a = opacity;
	#endif
	#include <map_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <logdepthbuf_fragment>
	float fragCoordZ = 0.5 * vHighPrecisionZW[0] / vHighPrecisionZW[1] + 0.5;
	#if DEPTH_PACKING == 3200
		gl_FragColor = vec4( vec3( 1.0 - fragCoordZ ), opacity );
	#elif DEPTH_PACKING == 3201
		gl_FragColor = packDepthToRGBA( fragCoordZ );
	#endif
}`,wdr=`#define DISTANCE
varying vec3 vWorldPosition;
#include <common>
#include <uv_pars_vertex>
#include <displacementmap_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <skinbase_vertex>
	#ifdef USE_DISPLACEMENTMAP
		#include <beginnormal_vertex>
		#include <morphnormal_vertex>
		#include <skinnormal_vertex>
	#endif
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <worldpos_vertex>
	#include <clipping_planes_vertex>
	vWorldPosition = worldPosition.xyz;
}`,Sdr=`#define DISTANCE
uniform vec3 referencePosition;
uniform float nearDistance;
uniform float farDistance;
varying vec3 vWorldPosition;
#include <common>
#include <packing>
#include <uv_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <clipping_planes_pars_fragment>
void main () {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( 1.0 );
	#include <map_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	float dist = length( vWorldPosition - referencePosition );
	dist = ( dist - nearDistance ) / ( farDistance - nearDistance );
	dist = saturate( dist );
	gl_FragColor = packDepthToRGBA( dist );
}`,Mdr=`varying vec3 vWorldDirection;
#include <common>
void main() {
	vWorldDirection = transformDirection( position, modelMatrix );
	#include <begin_vertex>
	#include <project_vertex>
}`,Edr=`uniform sampler2D tEquirect;
varying vec3 vWorldDirection;
#include <common>
void main() {
	vec3 direction = normalize( vWorldDirection );
	vec2 sampleUV = equirectUv( direction );
	gl_FragColor = texture2D( tEquirect, sampleUV );
	#include <tonemapping_fragment>
	#include <encodings_fragment>
}`,Tdr=`uniform float scale;
attribute float lineDistance;
varying float vLineDistance;
#include <common>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <morphtarget_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	vLineDistance = scale * lineDistance;
	#include <color_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	#include <fog_vertex>
}`,Cdr=`uniform vec3 diffuse;
uniform float opacity;
uniform float dashSize;
uniform float totalSize;
varying float vLineDistance;
#include <common>
#include <color_pars_fragment>
#include <fog_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	if ( mod( vLineDistance, totalSize ) > dashSize ) {
		discard;
	}
	vec3 outgoingLight = vec3( 0.0 );
	vec4 diffuseColor = vec4( diffuse, opacity );
	#include <logdepthbuf_fragment>
	#include <color_fragment>
	outgoingLight = diffuseColor.rgb;
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
}`,Adr=`#include <common>
#include <uv_pars_vertex>
#include <uv2_pars_vertex>
#include <envmap_pars_vertex>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <uv2_vertex>
	#include <color_vertex>
	#if defined ( USE_ENVMAP ) || defined ( USE_SKINNING )
		#include <beginnormal_vertex>
		#include <morphnormal_vertex>
		#include <skinbase_vertex>
		#include <skinnormal_vertex>
		#include <defaultnormal_vertex>
	#endif
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	#include <worldpos_vertex>
	#include <envmap_vertex>
	#include <fog_vertex>
}`,Pdr=`uniform vec3 diffuse;
uniform float opacity;
#ifndef FLAT_SHADED
	varying vec3 vNormal;
#endif
#include <common>
#include <dithering_pars_fragment>
#include <color_pars_fragment>
#include <uv_pars_fragment>
#include <uv2_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <aomap_pars_fragment>
#include <lightmap_pars_fragment>
#include <envmap_common_pars_fragment>
#include <envmap_pars_fragment>
#include <cube_uv_reflection_fragment>
#include <fog_pars_fragment>
#include <specularmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( diffuse, opacity );
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <color_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <specularmap_fragment>
	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
	#ifdef USE_LIGHTMAP
		vec4 lightMapTexel= texture2D( lightMap, vUv2 );
		reflectedLight.indirectDiffuse += lightMapTexel.rgb * lightMapIntensity;
	#else
		reflectedLight.indirectDiffuse += vec3( 1.0 );
	#endif
	#include <aomap_fragment>
	reflectedLight.indirectDiffuse *= diffuseColor.rgb;
	vec3 outgoingLight = reflectedLight.indirectDiffuse;
	#include <envmap_fragment>
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
	#include <dithering_fragment>
}`,Idr=`#define LAMBERT
varying vec3 vLightFront;
varying vec3 vIndirectFront;
#ifdef DOUBLE_SIDED
	varying vec3 vLightBack;
	varying vec3 vIndirectBack;
#endif
#include <common>
#include <uv_pars_vertex>
#include <uv2_pars_vertex>
#include <envmap_pars_vertex>
#include <bsdfs>
#include <lights_pars_begin>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <shadowmap_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <uv2_vertex>
	#include <color_vertex>
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	#include <worldpos_vertex>
	#include <envmap_vertex>
	#include <lights_lambert_vertex>
	#include <shadowmap_vertex>
	#include <fog_vertex>
}`,Ldr=`uniform vec3 diffuse;
uniform vec3 emissive;
uniform float opacity;
varying vec3 vLightFront;
varying vec3 vIndirectFront;
#ifdef DOUBLE_SIDED
	varying vec3 vLightBack;
	varying vec3 vIndirectBack;
#endif
#include <common>
#include <packing>
#include <dithering_pars_fragment>
#include <color_pars_fragment>
#include <uv_pars_fragment>
#include <uv2_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <aomap_pars_fragment>
#include <lightmap_pars_fragment>
#include <emissivemap_pars_fragment>
#include <envmap_common_pars_fragment>
#include <envmap_pars_fragment>
#include <cube_uv_reflection_fragment>
#include <bsdfs>
#include <lights_pars_begin>
#include <fog_pars_fragment>
#include <shadowmap_pars_fragment>
#include <shadowmask_pars_fragment>
#include <specularmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( diffuse, opacity );
	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
	vec3 totalEmissiveRadiance = emissive;
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <color_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <specularmap_fragment>
	#include <emissivemap_fragment>
	#ifdef DOUBLE_SIDED
		reflectedLight.indirectDiffuse += ( gl_FrontFacing ) ? vIndirectFront : vIndirectBack;
	#else
		reflectedLight.indirectDiffuse += vIndirectFront;
	#endif
	#include <lightmap_fragment>
	reflectedLight.indirectDiffuse *= BRDF_Lambert( diffuseColor.rgb );
	#ifdef DOUBLE_SIDED
		reflectedLight.directDiffuse = ( gl_FrontFacing ) ? vLightFront : vLightBack;
	#else
		reflectedLight.directDiffuse = vLightFront;
	#endif
	reflectedLight.directDiffuse *= BRDF_Lambert( diffuseColor.rgb ) * getShadowMask();
	#include <aomap_fragment>
	vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;
	#include <envmap_fragment>
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
	#include <dithering_fragment>
}`,kdr=`#define MATCAP
varying vec3 vViewPosition;
#include <common>
#include <uv_pars_vertex>
#include <color_pars_vertex>
#include <displacementmap_pars_vertex>
#include <fog_pars_vertex>
#include <normal_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <color_vertex>
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <normal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	#include <fog_vertex>
	vViewPosition = - mvPosition.xyz;
}`,Rdr=`#define MATCAP
uniform vec3 diffuse;
uniform float opacity;
uniform sampler2D matcap;
varying vec3 vViewPosition;
#include <common>
#include <dithering_pars_fragment>
#include <color_pars_fragment>
#include <uv_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <fog_pars_fragment>
#include <normal_pars_fragment>
#include <bumpmap_pars_fragment>
#include <normalmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( diffuse, opacity );
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <color_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <normal_fragment_begin>
	#include <normal_fragment_maps>
	vec3 viewDir = normalize( vViewPosition );
	vec3 x = normalize( vec3( viewDir.z, 0.0, - viewDir.x ) );
	vec3 y = cross( viewDir, x );
	vec2 uv = vec2( dot( x, normal ), dot( y, normal ) ) * 0.495 + 0.5;
	#ifdef USE_MATCAP
		vec4 matcapColor = texture2D( matcap, uv );
	#else
		vec4 matcapColor = vec4( vec3( mix( 0.2, 0.8, uv.y ) ), 1.0 );
	#endif
	vec3 outgoingLight = diffuseColor.rgb * matcapColor.rgb;
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
	#include <dithering_fragment>
}`,Ndr=`#define NORMAL
#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )
	varying vec3 vViewPosition;
#endif
#include <common>
#include <uv_pars_vertex>
#include <displacementmap_pars_vertex>
#include <normal_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <normal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )
	vViewPosition = - mvPosition.xyz;
#endif
}`,Ddr=`#define NORMAL
uniform float opacity;
#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )
	varying vec3 vViewPosition;
#endif
#include <packing>
#include <uv_pars_fragment>
#include <normal_pars_fragment>
#include <bumpmap_pars_fragment>
#include <normalmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	#include <logdepthbuf_fragment>
	#include <normal_fragment_begin>
	#include <normal_fragment_maps>
	gl_FragColor = vec4( packNormalToRGB( normal ), opacity );
}`,Odr=`#define PHONG
varying vec3 vViewPosition;
#include <common>
#include <uv_pars_vertex>
#include <uv2_pars_vertex>
#include <displacementmap_pars_vertex>
#include <envmap_pars_vertex>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <normal_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <shadowmap_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <uv2_vertex>
	#include <color_vertex>
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <normal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	vViewPosition = - mvPosition.xyz;
	#include <worldpos_vertex>
	#include <envmap_vertex>
	#include <shadowmap_vertex>
	#include <fog_vertex>
}`,zdr=`#define PHONG
uniform vec3 diffuse;
uniform vec3 emissive;
uniform vec3 specular;
uniform float shininess;
uniform float opacity;
#include <common>
#include <packing>
#include <dithering_pars_fragment>
#include <color_pars_fragment>
#include <uv_pars_fragment>
#include <uv2_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <aomap_pars_fragment>
#include <lightmap_pars_fragment>
#include <emissivemap_pars_fragment>
#include <envmap_common_pars_fragment>
#include <envmap_pars_fragment>
#include <cube_uv_reflection_fragment>
#include <fog_pars_fragment>
#include <bsdfs>
#include <lights_pars_begin>
#include <normal_pars_fragment>
#include <lights_phong_pars_fragment>
#include <shadowmap_pars_fragment>
#include <bumpmap_pars_fragment>
#include <normalmap_pars_fragment>
#include <specularmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( diffuse, opacity );
	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
	vec3 totalEmissiveRadiance = emissive;
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <color_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <specularmap_fragment>
	#include <normal_fragment_begin>
	#include <normal_fragment_maps>
	#include <emissivemap_fragment>
	#include <lights_phong_fragment>
	#include <lights_fragment_begin>
	#include <lights_fragment_maps>
	#include <lights_fragment_end>
	#include <aomap_fragment>
	vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance;
	#include <envmap_fragment>
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
	#include <dithering_fragment>
}`,Fdr=`#define STANDARD
varying vec3 vViewPosition;
#ifdef USE_TRANSMISSION
	varying vec3 vWorldPosition;
#endif
#include <common>
#include <uv_pars_vertex>
#include <uv2_pars_vertex>
#include <displacementmap_pars_vertex>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <normal_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <shadowmap_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <uv2_vertex>
	#include <color_vertex>
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <normal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	vViewPosition = - mvPosition.xyz;
	#include <worldpos_vertex>
	#include <shadowmap_vertex>
	#include <fog_vertex>
#ifdef USE_TRANSMISSION
	vWorldPosition = worldPosition.xyz;
#endif
}`,Bdr=`#define STANDARD
#ifdef PHYSICAL
	#define IOR
	#define SPECULAR
#endif
uniform vec3 diffuse;
uniform vec3 emissive;
uniform float roughness;
uniform float metalness;
uniform float opacity;
#ifdef IOR
	uniform float ior;
#endif
#ifdef SPECULAR
	uniform float specularIntensity;
	uniform vec3 specularColor;
	#ifdef USE_SPECULARINTENSITYMAP
		uniform sampler2D specularIntensityMap;
	#endif
	#ifdef USE_SPECULARCOLORMAP
		uniform sampler2D specularColorMap;
	#endif
#endif
#ifdef USE_CLEARCOAT
	uniform float clearcoat;
	uniform float clearcoatRoughness;
#endif
#ifdef USE_SHEEN
	uniform vec3 sheenColor;
	uniform float sheenRoughness;
	#ifdef USE_SHEENCOLORMAP
		uniform sampler2D sheenColorMap;
	#endif
	#ifdef USE_SHEENROUGHNESSMAP
		uniform sampler2D sheenRoughnessMap;
	#endif
#endif
varying vec3 vViewPosition;
#include <common>
#include <packing>
#include <dithering_pars_fragment>
#include <color_pars_fragment>
#include <uv_pars_fragment>
#include <uv2_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <aomap_pars_fragment>
#include <lightmap_pars_fragment>
#include <emissivemap_pars_fragment>
#include <bsdfs>
#include <cube_uv_reflection_fragment>
#include <envmap_common_pars_fragment>
#include <envmap_physical_pars_fragment>
#include <fog_pars_fragment>
#include <lights_pars_begin>
#include <normal_pars_fragment>
#include <lights_physical_pars_fragment>
#include <transmission_pars_fragment>
#include <shadowmap_pars_fragment>
#include <bumpmap_pars_fragment>
#include <normalmap_pars_fragment>
#include <clearcoat_pars_fragment>
#include <roughnessmap_pars_fragment>
#include <metalnessmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( diffuse, opacity );
	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
	vec3 totalEmissiveRadiance = emissive;
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <color_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <roughnessmap_fragment>
	#include <metalnessmap_fragment>
	#include <normal_fragment_begin>
	#include <normal_fragment_maps>
	#include <clearcoat_normal_fragment_begin>
	#include <clearcoat_normal_fragment_maps>
	#include <emissivemap_fragment>
	#include <lights_physical_fragment>
	#include <lights_fragment_begin>
	#include <lights_fragment_maps>
	#include <lights_fragment_end>
	#include <aomap_fragment>
	vec3 totalDiffuse = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse;
	vec3 totalSpecular = reflectedLight.directSpecular + reflectedLight.indirectSpecular;
	#include <transmission_fragment>
	vec3 outgoingLight = totalDiffuse + totalSpecular + totalEmissiveRadiance;
	#ifdef USE_SHEEN
		float sheenEnergyComp = 1.0 - 0.157 * max3( material.sheenColor );
		outgoingLight = outgoingLight * sheenEnergyComp + sheenSpecular;
	#endif
	#ifdef USE_CLEARCOAT
		float dotNVcc = saturate( dot( geometry.clearcoatNormal, geometry.viewDir ) );
		vec3 Fcc = F_Schlick( material.clearcoatF0, material.clearcoatF90, dotNVcc );
		outgoingLight = outgoingLight * ( 1.0 - material.clearcoat * Fcc ) + clearcoatSpecular * material.clearcoat;
	#endif
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
	#include <dithering_fragment>
}`,Hdr=`#define TOON
varying vec3 vViewPosition;
#include <common>
#include <uv_pars_vertex>
#include <uv2_pars_vertex>
#include <displacementmap_pars_vertex>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <normal_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <shadowmap_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <uv2_vertex>
	#include <color_vertex>
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <normal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	vViewPosition = - mvPosition.xyz;
	#include <worldpos_vertex>
	#include <shadowmap_vertex>
	#include <fog_vertex>
}`,Vdr=`#define TOON
uniform vec3 diffuse;
uniform vec3 emissive;
uniform float opacity;
#include <common>
#include <packing>
#include <dithering_pars_fragment>
#include <color_pars_fragment>
#include <uv_pars_fragment>
#include <uv2_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <aomap_pars_fragment>
#include <lightmap_pars_fragment>
#include <emissivemap_pars_fragment>
#include <gradientmap_pars_fragment>
#include <fog_pars_fragment>
#include <bsdfs>
#include <lights_pars_begin>
#include <normal_pars_fragment>
#include <lights_toon_pars_fragment>
#include <shadowmap_pars_fragment>
#include <bumpmap_pars_fragment>
#include <normalmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( diffuse, opacity );
	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
	vec3 totalEmissiveRadiance = emissive;
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <color_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <normal_fragment_begin>
	#include <normal_fragment_maps>
	#include <emissivemap_fragment>
	#include <lights_toon_fragment>
	#include <lights_fragment_begin>
	#include <lights_fragment_maps>
	#include <lights_fragment_end>
	#include <aomap_fragment>
	vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
	#include <dithering_fragment>
}`,Udr=`uniform float size;
uniform float scale;
#include <common>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <morphtarget_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <color_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <project_vertex>
	gl_PointSize = size;
	#ifdef USE_SIZEATTENUATION
		bool isPerspective = isPerspectiveMatrix( projectionMatrix );
		if ( isPerspective ) gl_PointSize *= ( scale / - mvPosition.z );
	#endif
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	#include <worldpos_vertex>
	#include <fog_vertex>
}`,qdr=`uniform vec3 diffuse;
uniform float opacity;
#include <common>
#include <color_pars_fragment>
#include <map_particle_pars_fragment>
#include <alphatest_pars_fragment>
#include <fog_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec3 outgoingLight = vec3( 0.0 );
	vec4 diffuseColor = vec4( diffuse, opacity );
	#include <logdepthbuf_fragment>
	#include <map_particle_fragment>
	#include <color_fragment>
	#include <alphatest_fragment>
	outgoingLight = diffuseColor.rgb;
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
}`,Gdr=`#include <common>
#include <fog_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <shadowmap_pars_vertex>
void main() {
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <project_vertex>
	#include <worldpos_vertex>
	#include <shadowmap_vertex>
	#include <fog_vertex>
}`,Wdr=`uniform vec3 color;
uniform float opacity;
#include <common>
#include <packing>
#include <fog_pars_fragment>
#include <bsdfs>
#include <lights_pars_begin>
#include <shadowmap_pars_fragment>
#include <shadowmask_pars_fragment>
void main() {
	gl_FragColor = vec4( color, opacity * ( 1.0 - getShadowMask() ) );
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
}`,Ydr=`uniform float rotation;
uniform vec2 center;
#include <common>
#include <uv_pars_vertex>
#include <fog_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	vec4 mvPosition = modelViewMatrix * vec4( 0.0, 0.0, 0.0, 1.0 );
	vec2 scale;
	scale.x = length( vec3( modelMatrix[ 0 ].x, modelMatrix[ 0 ].y, modelMatrix[ 0 ].z ) );
	scale.y = length( vec3( modelMatrix[ 1 ].x, modelMatrix[ 1 ].y, modelMatrix[ 1 ].z ) );
	#ifndef USE_SIZEATTENUATION
		bool isPerspective = isPerspectiveMatrix( projectionMatrix );
		if ( isPerspective ) scale *= - mvPosition.z;
	#endif
	vec2 alignedPosition = ( position.xy - ( center - vec2( 0.5 ) ) ) * scale;
	vec2 rotatedPosition;
	rotatedPosition.x = cos( rotation ) * alignedPosition.x - sin( rotation ) * alignedPosition.y;
	rotatedPosition.y = sin( rotation ) * alignedPosition.x + cos( rotation ) * alignedPosition.y;
	mvPosition.xy += rotatedPosition;
	gl_Position = projectionMatrix * mvPosition;
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	#include <fog_vertex>
}`,jdr=`uniform vec3 diffuse;
uniform float opacity;
#include <common>
#include <uv_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <fog_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec3 outgoingLight = vec3( 0.0 );
	vec4 diffuseColor = vec4( diffuse, opacity );
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	outgoingLight = diffuseColor.rgb;
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
}`,hr={alphamap_fragment:wfr,alphamap_pars_fragment:Sfr,alphatest_fragment:Mfr,alphatest_pars_fragment:Efr,aomap_fragment:Tfr,aomap_pars_fragment:Cfr,begin_vertex:Afr,beginnormal_vertex:Pfr,bsdfs:Ifr,bumpmap_pars_fragment:Lfr,clipping_planes_fragment:kfr,clipping_planes_pars_fragment:Rfr,clipping_planes_pars_vertex:Nfr,clipping_planes_vertex:Dfr,color_fragment:Ofr,color_pars_fragment:zfr,color_pars_vertex:Ffr,color_vertex:Bfr,common:Hfr,cube_uv_reflection_fragment:Vfr,defaultnormal_vertex:Ufr,displacementmap_pars_vertex:qfr,displacementmap_vertex:Gfr,emissivemap_fragment:Wfr,emissivemap_pars_fragment:Yfr,encodings_fragment:jfr,encodings_pars_fragment:Xfr,envmap_fragment:$fr,envmap_common_pars_fragment:Kfr,envmap_pars_fragment:Zfr,envmap_pars_vertex:Jfr,envmap_physical_pars_fragment:cpr,envmap_vertex:Qfr,fog_vertex:tpr,fog_pars_vertex:epr,fog_fragment:rpr,fog_pars_fragment:npr,gradientmap_pars_fragment:ipr,lightmap_fragment:opr,lightmap_pars_fragment:apr,lights_lambert_vertex:spr,lights_pars_begin:lpr,lights_toon_fragment:upr,lights_toon_pars_fragment:hpr,lights_phong_fragment:fpr,lights_phong_pars_fragment:ppr,lights_physical_fragment:dpr,lights_physical_pars_fragment:mpr,lights_fragment_begin:gpr,lights_fragment_maps:_pr,lights_fragment_end:ypr,logdepthbuf_fragment:vpr,logdepthbuf_pars_fragment:xpr,logdepthbuf_pars_vertex:bpr,logdepthbuf_vertex:wpr,map_fragment:Spr,map_pars_fragment:Mpr,map_particle_fragment:Epr,map_particle_pars_fragment:Tpr,metalnessmap_fragment:Cpr,metalnessmap_pars_fragment:Apr,morphnormal_vertex:Ppr,morphtarget_pars_vertex:Ipr,morphtarget_vertex:Lpr,normal_fragment_begin:kpr,normal_fragment_maps:Rpr,normal_pars_fragment:Npr,normal_pars_vertex:Dpr,normal_vertex:Opr,normalmap_pars_fragment:zpr,clearcoat_normal_fragment_begin:Fpr,clearcoat_normal_fragment_maps:Bpr,clearcoat_pars_fragment:Hpr,output_fragment:Vpr,packing:Upr,premultiplied_alpha_fragment:qpr,project_vertex:Gpr,dithering_fragment:Wpr,dithering_pars_fragment:Ypr,roughnessmap_fragment:jpr,roughnessmap_pars_fragment:Xpr,shadowmap_pars_fragment:$pr,shadowmap_pars_vertex:Kpr,shadowmap_vertex:Zpr,shadowmask_pars_fragment:Jpr,skinbase_vertex:Qpr,skinning_pars_vertex:tdr,skinning_vertex:edr,skinnormal_vertex:rdr,specularmap_fragment:ndr,specularmap_pars_fragment:idr,tonemapping_fragment:odr,tonemapping_pars_fragment:adr,transmission_fragment:sdr,transmission_pars_fragment:ldr,uv_pars_fragment:cdr,uv_pars_vertex:udr,uv_vertex:hdr,uv2_pars_fragment:fdr,uv2_pars_vertex:pdr,uv2_vertex:ddr,worldpos_vertex:mdr,background_vert:gdr,background_frag:_dr,cube_vert:ydr,cube_frag:vdr,depth_vert:xdr,depth_frag:bdr,distanceRGBA_vert:wdr,distanceRGBA_frag:Sdr,equirect_vert:Mdr,equirect_frag:Edr,linedashed_vert:Tdr,linedashed_frag:Cdr,meshbasic_vert:Adr,meshbasic_frag:Pdr,meshlambert_vert:Idr,meshlambert_frag:Ldr,meshmatcap_vert:kdr,meshmatcap_frag:Rdr,meshnormal_vert:Ndr,meshnormal_frag:Ddr,meshphong_vert:Odr,meshphong_frag:zdr,meshphysical_vert:Fdr,meshphysical_frag:Bdr,meshtoon_vert:Hdr,meshtoon_frag:Vdr,points_vert:Udr,points_frag:qdr,shadow_vert:Gdr,shadow_frag:Wdr,sprite_vert:Ydr,sprite_frag:jdr},re={common:{diffuse:{value:new ne(16777215)},opacity:{value:1},map:{value:null},uvTransform:{value:new ki},uv2Transform:{value:new ki},alphaMap:{value:null},alphaTest:{value:0}},specularmap:{specularMap:{value:null}},envmap:{envMap:{value:null},flipEnvMap:{value:-1},reflectivity:{value:1},ior:{value:1.5},refractionRatio:{value:.98}},aomap:{aoMap:{value:null},aoMapIntensity:{value:1}},lightmap:{lightMap:{value:null},lightMapIntensity:{value:1}},emissivemap:{emissiveMap:{value:null}},bumpmap:{bumpMap:{value:null},bumpScale:{value:1}},normalmap:{normalMap:{value:null},normalScale:{value:new Lt(1,1)}},displacementmap:{displacementMap:{value:null},displacementScale:{value:1},displacementBias:{value:0}},roughnessmap:{roughnessMap:{value:null}},metalnessmap:{metalnessMap:{value:null}},gradientmap:{gradientMap:{value:null}},fog:{fogDensity:{value:25e-5},fogNear:{value:1},fogFar:{value:2e3},fogColor:{value:new ne(16777215)}},lights:{ambientLightColor:{value:[]},lightProbe:{value:[]},directionalLights:{value:[],properties:{direction:{},color:{}}},directionalLightShadows:{value:[],properties:{shadowBias:{},shadowNormalBias:{},shadowRadius:{},shadowMapSize:{}}},directionalShadowMap:{value:[]},directionalShadowMatrix:{value:[]},spotLights:{value:[],properties:{color:{},position:{},direction:{},distance:{},coneCos:{},penumbraCos:{},decay:{}}},spotLightShadows:{value:[],properties:{shadowBias:{},shadowNormalBias:{},shadowRadius:{},shadowMapSize:{}}},spotShadowMap:{value:[]},spotShadowMatrix:{value:[]},pointLights:{value:[],properties:{color:{},position:{},decay:{},distance:{}}},pointLightShadows:{value:[],properties:{shadowBias:{},shadowNormalBias:{},shadowRadius:{},shadowMapSize:{},shadowCameraNear:{},shadowCameraFar:{}}},pointShadowMap:{value:[]},pointShadowMatrix:{value:[]},hemisphereLights:{value:[],properties:{direction:{},skyColor:{},groundColor:{}}},rectAreaLights:{value:[],properties:{color:{},position:{},width:{},height:{}}},ltc_1:{value:null},ltc_2:{value:null}},points:{diffuse:{value:new ne(16777215)},opacity:{value:1},size:{value:1},scale:{value:1},map:{value:null},alphaMap:{value:null},alphaTest:{value:0},uvTransform:{value:new ki}},sprite:{diffuse:{value:new ne(16777215)},opacity:{value:1},center:{value:new Lt(.5,.5)},rotation:{value:0},map:{value:null},alphaMap:{value:null},alphaTest:{value:0},uvTransform:{value:new ki}}},ah={basic:{uniforms:Ta([re.common,re.specularmap,re.envmap,re.aomap,re.lightmap,re.fog]),vertexShader:hr.meshbasic_vert,fragmentShader:hr.meshbasic_frag},lambert:{uniforms:Ta([re.common,re.specularmap,re.envmap,re.aomap,re.lightmap,re.emissivemap,re.fog,re.lights,{emissive:{value:new ne(0)}}]),vertexShader:hr.meshlambert_vert,fragmentShader:hr.meshlambert_frag},phong:{uniforms:Ta([re.common,re.specularmap,re.envmap,re.aomap,re.lightmap,re.emissivemap,re.bumpmap,re.normalmap,re.displacementmap,re.fog,re.lights,{emissive:{value:new ne(0)},specular:{value:new ne(1118481)},shininess:{value:30}}]),vertexShader:hr.meshphong_vert,fragmentShader:hr.meshphong_frag},standard:{uniforms:Ta([re.common,re.envmap,re.aomap,re.lightmap,re.emissivemap,re.bumpmap,re.normalmap,re.displacementmap,re.roughnessmap,re.metalnessmap,re.fog,re.lights,{emissive:{value:new ne(0)},roughness:{value:1},metalness:{value:0},envMapIntensity:{value:1}}]),vertexShader:hr.meshphysical_vert,fragmentShader:hr.meshphysical_frag},toon:{uniforms:Ta([re.common,re.aomap,re.lightmap,re.emissivemap,re.bumpmap,re.normalmap,re.displacementmap,re.gradientmap,re.fog,re.lights,{emissive:{value:new ne(0)}}]),vertexShader:hr.meshtoon_vert,fragmentShader:hr.meshtoon_frag},matcap:{uniforms:Ta([re.common,re.bumpmap,re.normalmap,re.displacementmap,re.fog,{matcap:{value:null}}]),vertexShader:hr.meshmatcap_vert,fragmentShader:hr.meshmatcap_frag},points:{uniforms:Ta([re.points,re.fog]),vertexShader:hr.points_vert,fragmentShader:hr.points_frag},dashed:{uniforms:Ta([re.common,re.fog,{scale:{value:1},dashSize:{value:1},totalSize:{value:2}}]),vertexShader:hr.linedashed_vert,fragmentShader:hr.linedashed_frag},depth:{uniforms:Ta([re.common,re.displacementmap]),vertexShader:hr.depth_vert,fragmentShader:hr.depth_frag},normal:{uniforms:Ta([re.common,re.bumpmap,re.normalmap,re.displacementmap,{opacity:{value:1}}]),vertexShader:hr.meshnormal_vert,fragmentShader:hr.meshnormal_frag},sprite:{uniforms:Ta([re.sprite,re.fog]),vertexShader:hr.sprite_vert,fragmentShader:hr.sprite_frag},background:{uniforms:{uvTransform:{value:new ki},t2D:{value:null}},vertexShader:hr.background_vert,fragmentShader:hr.background_frag},cube:{uniforms:Ta([re.envmap,{opacity:{value:1}}]),vertexShader:hr.cube_vert,fragmentShader:hr.cube_frag},equirect:{uniforms:{tEquirect:{value:null}},vertexShader:hr.equirect_vert,fragmentShader:hr.equirect_frag},distanceRGBA:{uniforms:Ta([re.common,re.displacementmap,{referencePosition:{value:new j},nearDistance:{value:1},farDistance:{value:1e3}}]),vertexShader:hr.distanceRGBA_vert,fragmentShader:hr.distanceRGBA_frag},shadow:{uniforms:Ta([re.lights,re.fog,{color:{value:new ne(0)},opacity:{value:1}}]),vertexShader:hr.shadow_vert,fragmentShader:hr.shadow_frag}};ah.physical={uniforms:Ta([ah.standard.uniforms,{clearcoat:{value:0},clearcoatMap:{value:null},clearcoatRoughness:{value:0},clearcoatRoughnessMap:{value:null},clearcoatNormalScale:{value:new Lt(1,1)},clearcoatNormalMap:{value:null},sheen:{value:0},sheenColor:{value:new ne(0)},sheenColorMap:{value:null},sheenRoughness:{value:1},sheenRoughnessMap:{value:null},transmission:{value:0},transmissionMap:{value:null},transmissionSamplerSize:{value:new Lt},transmissionSamplerMap:{value:null},thickness:{value:0},thicknessMap:{value:null},attenuationDistance:{value:0},attenuationColor:{value:new ne(0)},specularIntensity:{value:1},specularIntensityMap:{value:null},specularColor:{value:new ne(1,1,1)},specularColorMap:{value:null}}]),vertexShader:hr.meshphysical_vert,fragmentShader:hr.meshphysical_frag};function Xdr(e,t,r,n,i,o){let a=new ne(0),s=i===!0?0:1,l,c,u=null,h=0,f=null;function p(g,_){let y=!1,x=_.isScene===!0?_.background:null;x&&x.isTexture&&(x=t.get(x));let b=e.xr,S=b.getSession&&b.getSession();S&&S.environmentBlendMode==="additive"&&(x=null),x===null?d(a,s):x&&x.isColor&&(d(x,1),y=!0),(e.autoClear||y)&&e.clear(e.autoClearColor,e.autoClearDepth,e.autoClearStencil),x&&(x.isCubeTexture||x.mapping===xM)?(c===void 0&&(c=new ti(new Qf(1,1,1),new lh({name:"BackgroundCubeMaterial",uniforms:Z3(ah.cube.uniforms),vertexShader:ah.cube.vertexShader,fragmentShader:ah.cube.fragmentShader,side:Ii,depthTest:!1,depthWrite:!1,fog:!1})),c.geometry.deleteAttribute("normal"),c.geometry.deleteAttribute("uv"),c.onBeforeRender=function(C,P,k){this.matrixWorld.copyPosition(k.matrixWorld)},Object.defineProperty(c.material,"envMap",{get:function(){return this.uniforms.envMap.value}}),n.update(c)),c.material.uniforms.envMap.value=x,c.material.uniforms.flipEnvMap.value=x.isCubeTexture&&x.isRenderTargetTexture===!1?-1:1,(u!==x||h!==x.version||f!==e.toneMapping)&&(c.material.needsUpdate=!0,u=x,h=x.version,f=e.toneMapping),g.unshift(c,c.geometry,c.material,0,0,null)):x&&x.isTexture&&(l===void 0&&(l=new ti(new V0(2,2),new lh({name:"BackgroundMaterial",uniforms:Z3(ah.background.uniforms),vertexShader:ah.background.vertexShader,fragmentShader:ah.background.fragmentShader,side:I1,depthTest:!1,depthWrite:!1,fog:!1})),l.geometry.deleteAttribute("normal"),Object.defineProperty(l.material,"map",{get:function(){return this.uniforms.t2D.value}}),n.update(l)),l.material.uniforms.t2D.value=x,x.matrixAutoUpdate===!0&&x.updateMatrix(),l.material.uniforms.uvTransform.value.copy(x.matrix),(u!==x||h!==x.version||f!==e.toneMapping)&&(l.material.needsUpdate=!0,u=x,h=x.version,f=e.toneMapping),g.unshift(l,l.geometry,l.material,0,0,null))}function d(g,_){r.buffers.color.setClear(g.r,g.g,g.b,_,o)}return{getClearColor:function(){return a},setClearColor:function(g,_=1){a.set(g),s=_,d(a,s)},getClearAlpha:function(){return s},setClearAlpha:function(g){s=g,d(a,s)},render:p}}function $dr(e,t,r,n){let i=e.getParameter(34921),o=n.isWebGL2?null:t.get("OES_vertex_array_object"),a=n.isWebGL2||o!==null,s={},l=g(null),c=l;function u(R,F,z,U,W){let Z=!1;if(a){let rt=d(U,z,F);c!==rt&&(c=rt,f(c.object)),Z=_(U,W),Z&&y(U,W)}else{let rt=F.wireframe===!0;(c.geometry!==U.id||c.program!==z.id||c.wireframe!==rt)&&(c.geometry=U.id,c.program=z.id,c.wireframe=rt,Z=!0)}R.isInstancedMesh===!0&&(Z=!0),W!==null&&r.update(W,34963),Z&&(k(R,F,z,U),W!==null&&e.bindBuffer(34963,r.get(W).buffer))}function h(){return n.isWebGL2?e.createVertexArray():o.createVertexArrayOES()}function f(R){return n.isWebGL2?e.bindVertexArray(R):o.bindVertexArrayOES(R)}function p(R){return n.isWebGL2?e.deleteVertexArray(R):o.deleteVertexArrayOES(R)}function d(R,F,z){let U=z.wireframe===!0,W=s[R.id];W===void 0&&(W={},s[R.id]=W);let Z=W[F.id];Z===void 0&&(Z={},W[F.id]=Z);let rt=Z[U];return rt===void 0&&(rt=g(h()),Z[U]=rt),rt}function g(R){let F=[],z=[],U=[];for(let W=0;W<i;W++)F[W]=0,z[W]=0,U[W]=0;return{geometry:null,program:null,wireframe:!1,newAttributes:F,enabledAttributes:z,attributeDivisors:U,object:R,attributes:{},index:null}}function _(R,F){let z=c.attributes,U=R.attributes,W=0;for(let Z in U){let rt=z[Z],ot=U[Z];if(rt===void 0||rt.attribute!==ot||rt.data!==ot.data)return!0;W++}return c.attributesNum!==W||c.index!==F}function y(R,F){let z={},U=R.attributes,W=0;for(let Z in U){let rt=U[Z],ot={};ot.attribute=rt,rt.data&&(ot.data=rt.data),z[Z]=ot,W++}c.attributes=z,c.attributesNum=W,c.index=F}function x(){let R=c.newAttributes;for(let F=0,z=R.length;F<z;F++)R[F]=0}function b(R){S(R,0)}function S(R,F){let z=c.newAttributes,U=c.enabledAttributes,W=c.attributeDivisors;z[R]=1,U[R]===0&&(e.enableVertexAttribArray(R),U[R]=1),W[R]!==F&&((n.isWebGL2?e:t.get("ANGLE_instanced_arrays"))[n.isWebGL2?"vertexAttribDivisor":"vertexAttribDivisorANGLE"](R,F),W[R]=F)}function C(){let R=c.newAttributes,F=c.enabledAttributes;for(let z=0,U=F.length;z<U;z++)F[z]!==R[z]&&(e.disableVertexAttribArray(z),F[z]=0)}function P(R,F,z,U,W,Z){n.isWebGL2===!0&&(z===5124||z===5125)?e.vertexAttribIPointer(R,F,z,W,Z):e.vertexAttribPointer(R,F,z,U,W,Z)}function k(R,F,z,U){if(n.isWebGL2===!1&&(R.isInstancedMesh||U.isInstancedBufferGeometry)&&t.get("ANGLE_instanced_arrays")===null)return;x();let W=U.attributes,Z=z.getAttributes(),rt=F.defaultAttributeValues;for(let ot in Z){let st=Z[ot];if(st.location>=0){let St=W[ot];if(St===void 0&&(ot==="instanceMatrix"&&R.instanceMatrix&&(St=R.instanceMatrix),ot==="instanceColor"&&R.instanceColor&&(St=R.instanceColor)),St!==void 0){let bt=St.normalized,Mt=St.itemSize,lt=r.get(St);if(lt===void 0)continue;let Kt=lt.buffer,_t=lt.type,ct=lt.bytesPerElement;if(St.isInterleavedBufferAttribute){let X=St.data,et=X.stride,dt=St.offset;if(X&&X.isInstancedInterleavedBuffer){for(let q=0;q<st.locationSize;q++)S(st.location+q,X.meshPerAttribute);R.isInstancedMesh!==!0&&U._maxInstanceCount===void 0&&(U._maxInstanceCount=X.meshPerAttribute*X.count)}else for(let q=0;q<st.locationSize;q++)b(st.location+q);e.bindBuffer(34962,Kt);for(let q=0;q<st.locationSize;q++)P(st.location+q,Mt/st.locationSize,_t,bt,et*ct,(dt+Mt/st.locationSize*q)*ct)}else{if(St.isInstancedBufferAttribute){for(let X=0;X<st.locationSize;X++)S(st.location+X,St.meshPerAttribute);R.isInstancedMesh!==!0&&U._maxInstanceCount===void 0&&(U._maxInstanceCount=St.meshPerAttribute*St.count)}else for(let X=0;X<st.locationSize;X++)b(st.location+X);e.bindBuffer(34962,Kt);for(let X=0;X<st.locationSize;X++)P(st.location+X,Mt/st.locationSize,_t,bt,Mt*ct,Mt/st.locationSize*X*ct)}}else if(rt!==void 0){let bt=rt[ot];if(bt!==void 0)switch(bt.length){case 2:e.vertexAttrib2fv(st.location,bt);break;case 3:e.vertexAttrib3fv(st.location,bt);break;case 4:e.vertexAttrib4fv(st.location,bt);break;default:e.vertexAttrib1fv(st.location,bt)}}}}C()}function O(){I();for(let R in s){let F=s[R];for(let z in F){let U=F[z];for(let W in U)p(U[W].object),delete U[W];delete F[z]}delete s[R]}}function D(R){if(s[R.id]===void 0)return;let F=s[R.id];for(let z in F){let U=F[z];for(let W in U)p(U[W].object),delete U[W];delete F[z]}delete s[R.id]}function B(R){for(let F in s){let z=s[F];if(z[R.id]===void 0)continue;let U=z[R.id];for(let W in U)p(U[W].object),delete U[W];delete z[R.id]}}function I(){L(),c!==l&&(c=l,f(c.object))}function L(){l.geometry=null,l.program=null,l.wireframe=!1}return{setup:u,reset:I,resetDefaultState:L,dispose:O,releaseStatesOfGeometry:D,releaseStatesOfProgram:B,initAttributes:x,enableAttribute:b,disableUnusedAttributes:C}}function Kdr(e,t,r,n){let i=n.isWebGL2,o;function a(c){o=c}function s(c,u){e.drawArrays(o,c,u),r.update(u,o,1)}function l(c,u,h){if(h===0)return;let f,p;if(i)f=e,p="drawArraysInstanced";else if(f=t.get("ANGLE_instanced_arrays"),p="drawArraysInstancedANGLE",f===null){console.error("THREE.WebGLBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.");return}f[p](o,c,u,h),r.update(u,o,h)}this.setMode=a,this.render=s,this.renderInstances=l}function Zdr(e,t,r){let n;function i(){if(n!==void 0)return n;if(t.has("EXT_texture_filter_anisotropic")===!0){let k=t.get("EXT_texture_filter_anisotropic");n=e.getParameter(k.MAX_TEXTURE_MAX_ANISOTROPY_EXT)}else n=0;return n}function o(k){if(k==="highp"){if(e.getShaderPrecisionFormat(35633,36338).precision>0&&e.getShaderPrecisionFormat(35632,36338).precision>0)return"highp";k="mediump"}return k==="mediump"&&e.getShaderPrecisionFormat(35633,36337).precision>0&&e.getShaderPrecisionFormat(35632,36337).precision>0?"mediump":"lowp"}let a=typeof WebGL2RenderingContext!="undefined"&&e instanceof WebGL2RenderingContext||typeof WebGL2ComputeRenderingContext!="undefined"&&e instanceof WebGL2ComputeRenderingContext,s=r.precision!==void 0?r.precision:"highp",l=o(s);l!==s&&(console.warn("THREE.WebGLRenderer:",s,"not supported, using",l,"instead."),s=l);let c=a||t.has("WEBGL_draw_buffers"),u=r.logarithmicDepthBuffer===!0,h=e.getParameter(34930),f=e.getParameter(35660),p=e.getParameter(3379),d=e.getParameter(34076),g=e.getParameter(34921),_=e.getParameter(36347),y=e.getParameter(36348),x=e.getParameter(36349),b=f>0,S=a||t.has("OES_texture_float"),C=b&&S,P=a?e.getParameter(36183):0;return{isWebGL2:a,drawBuffers:c,getMaxAnisotropy:i,getMaxPrecision:o,precision:s,logarithmicDepthBuffer:u,maxTextures:h,maxVertexTextures:f,maxTextureSize:p,maxCubemapSize:d,maxAttributes:g,maxVertexUniforms:_,maxVaryings:y,maxFragmentUniforms:x,vertexTextures:b,floatFragmentTextures:S,floatVertexTextures:C,maxSamples:P}}function Jdr(e){let t=this,r=null,n=0,i=!1,o=!1,a=new $c,s=new ki,l={value:null,needsUpdate:!1};this.uniform=l,this.numPlanes=0,this.numIntersection=0,this.init=function(h,f,p){let d=h.length!==0||f||n!==0||i;return i=f,r=u(h,p,0),n=h.length,d},this.beginShadows=function(){o=!0,u(null)},this.endShadows=function(){o=!1,c()},this.setState=function(h,f,p){let d=h.clippingPlanes,g=h.clipIntersection,_=h.clipShadows,y=e.get(h);if(!i||d===null||d.length===0||o&&!_)o?u(null):c();else{let x=o?0:n,b=x*4,S=y.clippingState||null;l.value=S,S=u(d,f,b,p);for(let C=0;C!==b;++C)S[C]=r[C];y.clippingState=S,this.numIntersection=g?this.numPlanes:0,this.numPlanes+=x}};function c(){l.value!==r&&(l.value=r,l.needsUpdate=n>0),t.numPlanes=n,t.numIntersection=0}function u(h,f,p,d){let g=h!==null?h.length:0,_=null;if(g!==0){if(_=l.value,d!==!0||_===null){let y=p+g*4,x=f.matrixWorldInverse;s.getNormalMatrix(x),(_===null||_.length<y)&&(_=new Float32Array(y));for(let b=0,S=p;b!==g;++b,S+=4)a.copy(h[b]).applyMatrix4(x,s),a.normal.toArray(_,S),_[S+3]=a.constant}l.value=_,l.needsUpdate=!0}return t.numPlanes=g,t.numIntersection=0,_}}function Qdr(e){let t=new WeakMap;function r(a,s){return s===YP?a.mapping=nx:s===jP&&(a.mapping=ix),a}function n(a){if(a&&a.isTexture&&a.isRenderTargetTexture===!1){let s=a.mapping;if(s===YP||s===jP)if(t.has(a)){let l=t.get(a).texture;return r(l,a.mapping)}else{let l=a.image;if(l&&l.height>0){let c=new Q3(l.height/2);return c.fromEquirectangularTexture(e,a),t.set(a,c),a.addEventListener("dispose",i),r(c.texture,a.mapping)}else return null}}return a}function i(a){let s=a.target;s.removeEventListener("dispose",i);let l=t.get(s);l!==void 0&&(t.delete(s),l.dispose())}function o(){t=new WeakMap}return{get:n,dispose:o}}var D1=class extends R1{constructor(t=-1,r=1,n=1,i=-1,o=.1,a=2e3){super(),this.type="OrthographicCamera",this.zoom=1,this.view=null,this.left=t,this.right=r,this.top=n,this.bottom=i,this.near=o,this.far=a,this.updateProjectionMatrix()}copy(t,r){return super.copy(t,r),this.left=t.left,this.right=t.right,this.top=t.top,this.bottom=t.bottom,this.near=t.near,this.far=t.far,this.zoom=t.zoom,this.view=t.view===null?null:Object.assign({},t.view),this}setViewOffset(t,r,n,i,o,a){this.view===null&&(this.view={enabled:!0,fullWidth:1,fullHeight:1,offsetX:0,offsetY:0,width:1,height:1}),this.view.enabled=!0,this.view.fullWidth=t,this.view.fullHeight=r,this.view.offsetX=n,this.view.offsetY=i,this.view.width=o,this.view.height=a,this.updateProjectionMatrix()}clearViewOffset(){this.view!==null&&(this.view.enabled=!1),this.updateProjectionMatrix()}updateProjectionMatrix(){let t=(this.right-this.left)/(2*this.zoom),r=(this.top-this.bottom)/(2*this.zoom),n=(this.right+this.left)/2,i=(this.top+this.bottom)/2,o=n-t,a=n+t,s=i+r,l=i-r;if(this.view!==null&&this.view.enabled){let c=(this.right-this.left)/this.view.fullWidth/this.zoom,u=(this.top-this.bottom)/this.view.fullHeight/this.zoom;o+=c*this.view.offsetX,a=o+c*this.view.width,s-=u*this.view.offsetY,l=s-u*this.view.height}this.projectionMatrix.makeOrthographic(o,a,s,l,this.near,this.far),this.projectionMatrixInverse.copy(this.projectionMatrix).invert()}toJSON(t){let r=super.toJSON(t);return r.object.zoom=this.zoom,r.object.left=this.left,r.object.right=this.right,r.object.top=this.top,r.object.bottom=this.bottom,r.object.near=this.near,r.object.far=this.far,this.view!==null&&(r.object.view=Object.assign({},this.view)),r}};D1.prototype.isOrthographicCamera=!0;var U0=class extends lh{constructor(t){super(t),this.type="RawShaderMaterial"}};U0.prototype.isRawShaderMaterial=!0;var q3=4,F0=8,$f=Math.pow(2,F0),qfe=[.125,.215,.35,.446,.526,.582],Gfe=F0-q3+1+qfe.length,k3=20,hut=new D1,{_lodPlanes:NP,_sizeLods:Pue,_sigmas:PV}=tmr(),Iue=new ne,fut=null,S1=(1+Math.sqrt(5))/2,R3=1/S1,Lue=[new j(1,1,1),new j(-1,1,1),new j(1,1,-1),new j(-1,1,-1),new j(0,S1,R3),new j(0,S1,-R3),new j(R3,0,S1),new j(-R3,0,S1),new j(S1,R3,0),new j(-S1,R3,0)],e6=class{constructor(t){this._renderer=t,this._pingPongRenderTarget=null,this._blurMaterial=emr(k3),this._equirectShader=null,this._cubemapShader=null,this._compileMaterial(this._blurMaterial)}fromScene(t,r=0,n=.1,i=100){fut=this._renderer.getRenderTarget();let o=this._allocateTargets();return this._sceneToCubeUV(t,n,i,o),r>0&&this._blur(o,0,0,r),this._applyPMREM(o),this._cleanup(o),o}fromEquirectangular(t,r=null){return this._fromTexture(t,r)}fromCubemap(t,r=null){return this._fromTexture(t,r)}compileCubemapShader(){this._cubemapShader===null&&(this._cubemapShader=Nue(),this._compileMaterial(this._cubemapShader))}compileEquirectangularShader(){this._equirectShader===null&&(this._equirectShader=Rue(),this._compileMaterial(this._equirectShader))}dispose(){this._blurMaterial.dispose(),this._pingPongRenderTarget!==null&&this._pingPongRenderTarget.dispose(),this._cubemapShader!==null&&this._cubemapShader.dispose(),this._equirectShader!==null&&this._equirectShader.dispose();for(let t=0;t<NP.length;t++)NP[t].dispose()}_cleanup(t){this._renderer.setRenderTarget(fut),t.scissorTest=!1,IV(t,0,0,t.width,t.height)}_fromTexture(t,r){fut=this._renderer.getRenderTarget();let n=r||this._allocateTargets(t);return this._textureToCubeUV(t,n),this._applyPMREM(n),this._cleanup(n),n}_allocateTargets(t){let r={magFilter:ii,minFilter:ii,generateMipmaps:!1,type:C1,format:Qo,encoding:Qd,depthBuffer:!1},n=kue(r);return n.depthBuffer=!t,this._pingPongRenderTarget===null&&(this._pingPongRenderTarget=kue(r)),n}_compileMaterial(t){let r=new ti(NP[0],t);this._renderer.compile(r,hut)}_sceneToCubeUV(t,r,n,i){let s=new Ui(90,1,r,n),l=[1,-1,1,1,1,1],c=[1,1,1,-1,-1,-1],u=this._renderer,h=u.autoClear,f=u.toneMapping;u.getClearColor(Iue),u.toneMapping=Kd,u.autoClear=!1;let p=new sh({name:"PMREM.Background",side:Ii,depthWrite:!1,depthTest:!1}),d=new ti(new Qf,p),g=!1,_=t.background;_?_.isColor&&(p.color.copy(_),t.background=null,g=!0):(p.color.copy(Iue),g=!0);for(let y=0;y<6;y++){let x=y%3;x===0?(s.up.set(0,l[y],0),s.lookAt(c[y],0,0)):x===1?(s.up.set(0,0,l[y]),s.lookAt(0,c[y],0)):(s.up.set(0,l[y],0),s.lookAt(0,0,c[y])),IV(i,x*$f,y>2?$f:0,$f,$f),u.setRenderTarget(i),g&&u.render(d,s),u.render(t,s)}d.geometry.dispose(),d.material.dispose(),u.toneMapping=f,u.autoClear=h,t.background=_}_textureToCubeUV(t,r){let n=this._renderer,i=t.mapping===nx||t.mapping===ix;i?(this._cubemapShader===null&&(this._cubemapShader=Nue()),this._cubemapShader.uniforms.flipEnvMap.value=t.isRenderTargetTexture===!1?-1:1):this._equirectShader===null&&(this._equirectShader=Rue());let o=i?this._cubemapShader:this._equirectShader,a=new ti(NP[0],o),s=o.uniforms;s.envMap.value=t,i||s.texelSize.value.set(1/t.image.width,1/t.image.height),IV(r,0,0,3*$f,2*$f),n.setRenderTarget(r),n.render(a,hut)}_applyPMREM(t){let r=this._renderer,n=r.autoClear;r.autoClear=!1;for(let i=1;i<Gfe;i++){let o=Math.sqrt(PV[i]*PV[i]-PV[i-1]*PV[i-1]),a=Lue[(i-1)%Lue.length];this._blur(t,i-1,i,o,a)}r.autoClear=n}_blur(t,r,n,i,o){let a=this._pingPongRenderTarget;this._halfBlur(t,a,r,n,i,"latitudinal",o),this._halfBlur(a,t,n,n,i,"longitudinal",o)}_halfBlur(t,r,n,i,o,a,s){let l=this._renderer,c=this._blurMaterial;a!=="latitudinal"&&a!=="longitudinal"&&console.error("blur direction must be either latitudinal or longitudinal!");let u=3,h=new ti(NP[i],c),f=c.uniforms,p=Pue[n]-1,d=isFinite(o)?Math.PI/(2*p):2*Math.PI/(2*k3-1),g=o/d,_=isFinite(o)?1+Math.floor(u*g):k3;_>k3&&console.warn(`sigmaRadians, ${o}, is too large and will clip, as it requested ${_} samples when the maximum is set to ${k3}`);let y=[],x=0;for(let P=0;P<k3;++P){let k=P/g,O=Math.exp(-k*k/2);y.push(O),P===0?x+=O:P<_&&(x+=2*O)}for(let P=0;P<y.length;P++)y[P]=y[P]/x;f.envMap.value=t.texture,f.samples.value=_,f.weights.value=y,f.latitudinal.value=a==="latitudinal",s&&(f.poleAxis.value=s),f.dTheta.value=d,f.mipInt.value=F0-n;let b=Pue[i],S=3*Math.max(0,$f-2*b),C=(i===0?0:2*$f)+2*b*(i>F0-q3?i-F0+q3:0);IV(r,S,C,3*b,2*b),l.setRenderTarget(r),l.render(h,hut)}};function tmr(){let e=[],t=[],r=[],n=F0;for(let i=0;i<Gfe;i++){let o=Math.pow(2,n);t.push(o);let a=1/o;i>F0-q3?a=qfe[i-F0+q3-1]:i===0&&(a=0),r.push(a);let s=1/(o-1),l=-s/2,c=1+s/2,u=[l,l,c,l,c,c,l,l,c,c,l,c],h=6,f=6,p=3,d=2,g=1,_=new Float32Array(p*f*h),y=new Float32Array(d*f*h),x=new Float32Array(g*f*h);for(let S=0;S<h;S++){let C=S%3*2/3-1,P=S>2?0:-1,k=[C,P,0,C+2/3,P,0,C+2/3,P+1,0,C,P,0,C+2/3,P+1,0,C,P+1,0];_.set(k,p*f*S),y.set(u,d*f*S);let O=[S,S,S,S,S,S];x.set(O,g*f*S)}let b=new Pe;b.setAttribute("position",new Je(_,p)),b.setAttribute("uv",new Je(y,d)),b.setAttribute("faceIndex",new Je(x,g)),e.push(b),n>q3&&n--}return{_lodPlanes:e,_sizeLods:t,_sigmas:r}}function kue(e){let t=new us(3*$f,3*$f,e);return t.texture.mapping=xM,t.texture.name="PMREM.cubeUv",t.scissorTest=!0,t}function IV(e,t,r,n,i){e.viewport.set(t,r,n,i),e.scissor.set(t,r,n,i)}function emr(e){let t=new Float32Array(e),r=new j(0,1,0);return new U0({name:"SphericalGaussianBlur",defines:{n:e},uniforms:{envMap:{value:null},samples:{value:1},weights:{value:t},latitudinal:{value:!1},dTheta:{value:0},mipInt:{value:0},poleAxis:{value:r}},vertexShader:Nht(),fragmentShader:`

			precision mediump float;
			precision mediump int;

			varying vec3 vOutputDirection;

			uniform sampler2D envMap;
			uniform int samples;
			uniform float weights[ n ];
			uniform bool latitudinal;
			uniform float dTheta;
			uniform float mipInt;
			uniform vec3 poleAxis;

			#define ENVMAP_TYPE_CUBE_UV
			#include <cube_uv_reflection_fragment>

			vec3 getSample( float theta, vec3 axis ) {

				float cosTheta = cos( theta );
				// Rodrigues' axis-angle rotation
				vec3 sampleDirection = vOutputDirection * cosTheta
					+ cross( axis, vOutputDirection ) * sin( theta )
					+ axis * dot( axis, vOutputDirection ) * ( 1.0 - cosTheta );

				return bilinearCubeUV( envMap, sampleDirection, mipInt );

			}

			void main() {

				vec3 axis = latitudinal ? poleAxis : cross( poleAxis, vOutputDirection );

				if ( all( equal( axis, vec3( 0.0 ) ) ) ) {

					axis = vec3( vOutputDirection.z, 0.0, - vOutputDirection.x );

				}

				axis = normalize( axis );

				gl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 );
				gl_FragColor.rgb += weights[ 0 ] * getSample( 0.0, axis );

				for ( int i = 1; i < n; i++ ) {

					if ( i >= samples ) {

						break;

					}

					float theta = dTheta * float( i );
					gl_FragColor.rgb += weights[ i ] * getSample( -1.0 * theta, axis );
					gl_FragColor.rgb += weights[ i ] * getSample( theta, axis );

				}

			}
		`,blending:$d,depthTest:!1,depthWrite:!1})}function Rue(){let e=new Lt(1,1);return new U0({name:"EquirectangularToCubeUV",uniforms:{envMap:{value:null},texelSize:{value:e}},vertexShader:Nht(),fragmentShader:`

			precision mediump float;
			precision mediump int;

			varying vec3 vOutputDirection;

			uniform sampler2D envMap;
			uniform vec2 texelSize;

			#include <common>

			void main() {

				gl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 );

				vec3 outputDirection = normalize( vOutputDirection );
				vec2 uv = equirectUv( outputDirection );

				vec2 f = fract( uv / texelSize - 0.5 );
				uv -= f * texelSize;
				vec3 tl = texture2D ( envMap, uv ).rgb;
				uv.x += texelSize.x;
				vec3 tr = texture2D ( envMap, uv ).rgb;
				uv.y += texelSize.y;
				vec3 br = texture2D ( envMap, uv ).rgb;
				uv.x -= texelSize.x;
				vec3 bl = texture2D ( envMap, uv ).rgb;

				vec3 tm = mix( tl, tr, f.x );
				vec3 bm = mix( bl, br, f.x );
				gl_FragColor.rgb = mix( tm, bm, f.y );

			}
		`,blending:$d,depthTest:!1,depthWrite:!1})}function Nue(){return new U0({name:"CubemapToCubeUV",uniforms:{envMap:{value:null},flipEnvMap:{value:-1}},vertexShader:Nht(),fragmentShader:`

			precision mediump float;
			precision mediump int;

			uniform float flipEnvMap;

			varying vec3 vOutputDirection;

			uniform samplerCube envMap;

			void main() {

				gl_FragColor = textureCube( envMap, vec3( flipEnvMap * vOutputDirection.x, vOutputDirection.yz ) );

			}
		`,blending:$d,depthTest:!1,depthWrite:!1})}function Nht(){return`

		precision mediump float;
		precision mediump int;

		attribute vec3 position;
		attribute vec2 uv;
		attribute float faceIndex;

		varying vec3 vOutputDirection;

		// RH coordinate system; PMREM face-indexing convention
		vec3 getDirection( vec2 uv, float face ) {

			uv = 2.0 * uv - 1.0;

			vec3 direction = vec3( uv, 1.0 );

			if ( face == 0.0 ) {

				direction = direction.zyx; // ( 1, v, u ) pos x

			} else if ( face == 1.0 ) {

				direction = direction.xzy;
				direction.xz *= -1.0; // ( -u, 1, -v ) pos y

			} else if ( face == 2.0 ) {

				direction.x *= -1.0; // ( -u, v, 1 ) pos z

			} else if ( face == 3.0 ) {

				direction = direction.zyx;
				direction.xz *= -1.0; // ( -1, v, -u ) neg x

			} else if ( face == 4.0 ) {

				direction = direction.xzy;
				direction.xy *= -1.0; // ( -u, -1, v ) neg y

			} else if ( face == 5.0 ) {

				direction.z *= -1.0; // ( u, v, -1 ) neg z

			}

			return direction;

		}

		void main() {

			vOutputDirection = getDirection( uv, faceIndex );
			gl_Position = vec4( position, 1.0 );

		}
	`}function rmr(e){let t=new WeakMap,r=null;function n(s){if(s&&s.isTexture){let l=s.mapping,c=l===YP||l===jP,u=l===nx||l===ix;if(c||u)if(s.isRenderTargetTexture&&s.needsPMREMUpdate===!0){s.needsPMREMUpdate=!1;let h=t.get(s);return r===null&&(r=new e6(e)),h=c?r.fromEquirectangular(s,h):r.fromCubemap(s,h),t.set(s,h),h.texture}else{if(t.has(s))return t.get(s).texture;{let h=s.image;if(c&&h&&h.height>0||u&&h&&i(h)){r===null&&(r=new e6(e));let f=c?r.fromEquirectangular(s):r.fromCubemap(s);return t.set(s,f),s.addEventListener("dispose",o),f.texture}else return null}}}return s}function i(s){let l=0,c=6;for(let u=0;u<c;u++)s[u]!==void 0&&l++;return l===c}function o(s){let l=s.target;l.removeEventListener("dispose",o);let c=t.get(l);c!==void 0&&(t.delete(l),c.dispose())}function a(){t=new WeakMap,r!==null&&(r.dispose(),r=null)}return{get:n,dispose:a}}function nmr(e){let t={};function r(n){if(t[n]!==void 0)return t[n];let i;switch(n){case"WEBGL_depth_texture":i=e.getExtension("WEBGL_depth_texture")||e.getExtension("MOZ_WEBGL_depth_texture")||e.getExtension("WEBKIT_WEBGL_depth_texture");break;case"EXT_texture_filter_anisotropic":i=e.getExtension("EXT_texture_filter_anisotropic")||e.getExtension("MOZ_EXT_texture_filter_anisotropic")||e.getExtension("WEBKIT_EXT_texture_filter_anisotropic");break;case"WEBGL_compressed_texture_s3tc":i=e.getExtension("WEBGL_compressed_texture_s3tc")||e.getExtension("MOZ_WEBGL_compressed_texture_s3tc")||e.getExtension("WEBKIT_WEBGL_compressed_texture_s3tc");break;case"WEBGL_compressed_texture_pvrtc":i=e.getExtension("WEBGL_compressed_texture_pvrtc")||e.getExtension("WEBKIT_WEBGL_compressed_texture_pvrtc");break;default:i=e.getExtension(n)}return t[n]=i,i}return{has:function(n){return r(n)!==null},init:function(n){n.isWebGL2?r("EXT_color_buffer_float"):(r("WEBGL_depth_texture"),r("OES_texture_float"),r("OES_texture_half_float"),r("OES_texture_half_float_linear"),r("OES_standard_derivatives"),r("OES_element_index_uint"),r("OES_vertex_array_object"),r("ANGLE_instanced_arrays")),r("OES_texture_float_linear"),r("EXT_color_buffer_half_float"),r("WEBGL_multisampled_render_to_texture")},get:function(n){let i=r(n);return i===null&&console.warn("THREE.WebGLRenderer: "+n+" extension not supported."),i}}}function imr(e,t,r,n){let i={},o=new WeakMap;function a(h){let f=h.target;f.index!==null&&t.remove(f.index);for(let d in f.attributes)t.remove(f.attributes[d]);f.removeEventListener("dispose",a),delete i[f.id];let p=o.get(f);p&&(t.remove(p),o.delete(f)),n.releaseStatesOfGeometry(f),f.isInstancedBufferGeometry===!0&&delete f._maxInstanceCount,r.memory.geometries--}function s(h,f){return i[f.id]===!0||(f.addEventListener("dispose",a),i[f.id]=!0,r.memory.geometries++),f}function l(h){let f=h.attributes;for(let d in f)t.update(f[d],34962);let p=h.morphAttributes;for(let d in p){let g=p[d];for(let _=0,y=g.length;_<y;_++)t.update(g[_],34962)}}function c(h){let f=[],p=h.index,d=h.attributes.position,g=0;if(p!==null){let x=p.array;g=p.version;for(let b=0,S=x.length;b<S;b+=3){let C=x[b+0],P=x[b+1],k=x[b+2];f.push(C,P,P,k,k,C)}}else{let x=d.array;g=d.version;for(let b=0,S=x.length/3-1;b<S;b+=3){let C=b+0,P=b+1,k=b+2;f.push(C,P,P,k,k,C)}}let _=new(Bfe(f)?K3:$3)(f,1);_.version=g;let y=o.get(h);y&&t.remove(y),o.set(h,_)}function u(h){let f=o.get(h);if(f){let p=h.index;p!==null&&f.version<p.version&&c(h)}else c(h);return o.get(h)}return{get:s,update:l,getWireframeAttribute:u}}function omr(e,t,r,n){let i=n.isWebGL2,o;function a(f){o=f}let s,l;function c(f){s=f.type,l=f.bytesPerElement}function u(f,p){e.drawElements(o,p,s,f*l),r.update(p,o,1)}function h(f,p,d){if(d===0)return;let g,_;if(i)g=e,_="drawElementsInstanced";else if(g=t.get("ANGLE_instanced_arrays"),_="drawElementsInstancedANGLE",g===null){console.error("THREE.WebGLIndexedBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.");return}g[_](o,p,s,f*l,d),r.update(p,o,d)}this.setMode=a,this.setIndex=c,this.render=u,this.renderInstances=h}function amr(e){let t={geometries:0,textures:0},r={frame:0,calls:0,triangles:0,points:0,lines:0};function n(o,a,s){switch(r.calls++,a){case 4:r.triangles+=s*(o/3);break;case 1:r.lines+=s*(o/2);break;case 3:r.lines+=s*(o-1);break;case 2:r.lines+=s*o;break;case 0:r.points+=s*o;break;default:console.error("THREE.WebGLInfo: Unknown draw mode:",a);break}}function i(){r.frame++,r.calls=0,r.triangles=0,r.points=0,r.lines=0}return{memory:t,render:r,programs:null,autoReset:!0,reset:i,update:n}}var tM=class extends vi{constructor(t=null,r=1,n=1,i=1){super(null),this.image={data:t,width:r,height:n,depth:i},this.magFilter=Li,this.minFilter=Li,this.wrapR=Jo,this.generateMipmaps=!1,this.flipY=!1,this.unpackAlignment=1}};tM.prototype.isDataTexture2DArray=!0;function smr(e,t){return e[0]-t[0]}function lmr(e,t){return Math.abs(t[1])-Math.abs(e[1])}function Due(e,t){let r=1,n=t.isInterleavedBufferAttribute?t.data.array:t.array;n instanceof Int8Array?r=127:n instanceof Int16Array?r=32767:n instanceof Int32Array?r=2147483647:console.error("THREE.WebGLMorphtargets: Unsupported morph attribute data type: ",n),e.divideScalar(r)}function cmr(e,t,r){let n={},i=new Float32Array(8),o=new WeakMap,a=new j,s=[];for(let c=0;c<8;c++)s[c]=[c,0];function l(c,u,h,f){let p=c.morphTargetInfluences;if(t.isWebGL2===!0){let d=u.morphAttributes.position.length,g=o.get(u);if(g===void 0||g.count!==d){let L=function(){B.dispose(),o.delete(u),u.removeEventListener("dispose",L)};g!==void 0&&g.texture.dispose();let x=u.morphAttributes.normal!==void 0,b=u.morphAttributes.position,S=u.morphAttributes.normal||[],C=u.attributes.position.count,P=x===!0?2:1,k=C*P,O=1;k>t.maxTextureSize&&(O=Math.ceil(k/t.maxTextureSize),k=t.maxTextureSize);let D=new Float32Array(k*O*4*d),B=new tM(D,k,O,d);B.format=Qo,B.type=jd,B.needsUpdate=!0;let I=P*4;for(let R=0;R<d;R++){let F=b[R],z=S[R],U=k*O*4*R;for(let W=0;W<F.count;W++){a.fromBufferAttribute(F,W),F.normalized===!0&&Due(a,F);let Z=W*I;D[U+Z+0]=a.x,D[U+Z+1]=a.y,D[U+Z+2]=a.z,D[U+Z+3]=0,x===!0&&(a.fromBufferAttribute(z,W),z.normalized===!0&&Due(a,z),D[U+Z+4]=a.x,D[U+Z+5]=a.y,D[U+Z+6]=a.z,D[U+Z+7]=0)}}g={count:d,texture:B,size:new Lt(k,O)},o.set(u,g),u.addEventListener("dispose",L)}let _=0;for(let x=0;x<p.length;x++)_+=p[x];let y=u.morphTargetsRelative?1:1-_;f.getUniforms().setValue(e,"morphTargetBaseInfluence",y),f.getUniforms().setValue(e,"morphTargetInfluences",p),f.getUniforms().setValue(e,"morphTargetsTexture",g.texture,r),f.getUniforms().setValue(e,"morphTargetsTextureSize",g.size)}else{let d=p===void 0?0:p.length,g=n[u.id];if(g===void 0||g.length!==d){g=[];for(let S=0;S<d;S++)g[S]=[S,0];n[u.id]=g}for(let S=0;S<d;S++){let C=g[S];C[0]=S,C[1]=p[S]}g.sort(lmr);for(let S=0;S<8;S++)S<d&&g[S][1]?(s[S][0]=g[S][0],s[S][1]=g[S][1]):(s[S][0]=Number.MAX_SAFE_INTEGER,s[S][1]=0);s.sort(smr);let _=u.morphAttributes.position,y=u.morphAttributes.normal,x=0;for(let S=0;S<8;S++){let C=s[S],P=C[0],k=C[1];P!==Number.MAX_SAFE_INTEGER&&k?(_&&u.getAttribute("morphTarget"+S)!==_[P]&&u.setAttribute("morphTarget"+S,_[P]),y&&u.getAttribute("morphNormal"+S)!==y[P]&&u.setAttribute("morphNormal"+S,y[P]),i[S]=k,x+=k):(_&&u.hasAttribute("morphTarget"+S)===!0&&u.deleteAttribute("morphTarget"+S),y&&u.hasAttribute("morphNormal"+S)===!0&&u.deleteAttribute("morphNormal"+S),i[S]=0)}let b=u.morphTargetsRelative?1:1-x;f.getUniforms().setValue(e,"morphTargetBaseInfluence",b),f.getUniforms().setValue(e,"morphTargetInfluences",i)}}return{update:l}}function umr(e,t,r,n){let i=new WeakMap;function o(l){let c=n.render.frame,u=l.geometry,h=t.get(l,u);return i.get(h)!==c&&(t.update(h),i.set(h,c)),l.isInstancedMesh&&(l.hasEventListener("dispose",s)===!1&&l.addEventListener("dispose",s),r.update(l.instanceMatrix,34962),l.instanceColor!==null&&r.update(l.instanceColor,34962)),h}function a(){i=new WeakMap}function s(l){let c=l.target;c.removeEventListener("dispose",s),r.remove(c.instanceMatrix),c.instanceColor!==null&&r.remove(c.instanceColor)}return{update:o,dispose:a}}var r6=class extends vi{constructor(t=null,r=1,n=1,i=1){super(null),this.image={data:t,width:r,height:n,depth:i},this.magFilter=Li,this.minFilter=Li,this.wrapR=Jo,this.generateMipmaps=!1,this.flipY=!1,this.unpackAlignment=1}};r6.prototype.isDataTexture3D=!0;var Wfe=new vi,Yfe=new tM,jfe=new r6,Xfe=new H0,Oue=[],zue=[],Fue=new Float32Array(16),Bue=new Float32Array(9),Hue=new Float32Array(4);function bM(e,t,r){let n=e[0];if(n<=0||n>0)return e;let i=t*r,o=Oue[i];if(o===void 0&&(o=new Float32Array(i),Oue[i]=o),t!==0){n.toArray(o,0);for(let a=1,s=0;a!==t;++a)s+=r,e[a].toArray(o,s)}return o}function hs(e,t){if(e.length!==t.length)return!1;for(let r=0,n=e.length;r<n;r++)if(e[r]!==t[r])return!1;return!0}function Ca(e,t){for(let r=0,n=t.length;r<n;r++)e[r]=t[r]}function KU(e,t){let r=zue[t];r===void 0&&(r=new Int32Array(t),zue[t]=r);for(let n=0;n!==t;++n)r[n]=e.allocateTextureUnit();return r}function hmr(e,t){let r=this.cache;r[0]!==t&&(e.uniform1f(this.addr,t),r[0]=t)}function fmr(e,t){let r=this.cache;if(t.x!==void 0)(r[0]!==t.x||r[1]!==t.y)&&(e.uniform2f(this.addr,t.x,t.y),r[0]=t.x,r[1]=t.y);else{if(hs(r,t))return;e.uniform2fv(this.addr,t),Ca(r,t)}}function pmr(e,t){let r=this.cache;if(t.x!==void 0)(r[0]!==t.x||r[1]!==t.y||r[2]!==t.z)&&(e.uniform3f(this.addr,t.x,t.y,t.z),r[0]=t.x,r[1]=t.y,r[2]=t.z);else if(t.r!==void 0)(r[0]!==t.r||r[1]!==t.g||r[2]!==t.b)&&(e.uniform3f(this.addr,t.r,t.g,t.b),r[0]=t.r,r[1]=t.g,r[2]=t.b);else{if(hs(r,t))return;e.uniform3fv(this.addr,t),Ca(r,t)}}function dmr(e,t){let r=this.cache;if(t.x!==void 0)(r[0]!==t.x||r[1]!==t.y||r[2]!==t.z||r[3]!==t.w)&&(e.uniform4f(this.addr,t.x,t.y,t.z,t.w),r[0]=t.x,r[1]=t.y,r[2]=t.z,r[3]=t.w);else{if(hs(r,t))return;e.uniform4fv(this.addr,t),Ca(r,t)}}function mmr(e,t){let r=this.cache,n=t.elements;if(n===void 0){if(hs(r,t))return;e.uniformMatrix2fv(this.addr,!1,t),Ca(r,t)}else{if(hs(r,n))return;Hue.set(n),e.uniformMatrix2fv(this.addr,!1,Hue),Ca(r,n)}}function gmr(e,t){let r=this.cache,n=t.elements;if(n===void 0){if(hs(r,t))return;e.uniformMatrix3fv(this.addr,!1,t),Ca(r,t)}else{if(hs(r,n))return;Bue.set(n),e.uniformMatrix3fv(this.addr,!1,Bue),Ca(r,n)}}function _mr(e,t){let r=this.cache,n=t.elements;if(n===void 0){if(hs(r,t))return;e.uniformMatrix4fv(this.addr,!1,t),Ca(r,t)}else{if(hs(r,n))return;Fue.set(n),e.uniformMatrix4fv(this.addr,!1,Fue),Ca(r,n)}}function ymr(e,t){let r=this.cache;r[0]!==t&&(e.uniform1i(this.addr,t),r[0]=t)}function vmr(e,t){let r=this.cache;hs(r,t)||(e.uniform2iv(this.addr,t),Ca(r,t))}function xmr(e,t){let r=this.cache;hs(r,t)||(e.uniform3iv(this.addr,t),Ca(r,t))}function bmr(e,t){let r=this.cache;hs(r,t)||(e.uniform4iv(this.addr,t),Ca(r,t))}function wmr(e,t){let r=this.cache;r[0]!==t&&(e.uniform1ui(this.addr,t),r[0]=t)}function Smr(e,t){let r=this.cache;hs(r,t)||(e.uniform2uiv(this.addr,t),Ca(r,t))}function Mmr(e,t){let r=this.cache;hs(r,t)||(e.uniform3uiv(this.addr,t),Ca(r,t))}function Emr(e,t){let r=this.cache;hs(r,t)||(e.uniform4uiv(this.addr,t),Ca(r,t))}function Tmr(e,t,r){let n=this.cache,i=r.allocateTextureUnit();n[0]!==i&&(e.uniform1i(this.addr,i),n[0]=i),r.safeSetTexture2D(t||Wfe,i)}function Cmr(e,t,r){let n=this.cache,i=r.allocateTextureUnit();n[0]!==i&&(e.uniform1i(this.addr,i),n[0]=i),r.setTexture3D(t||jfe,i)}function Amr(e,t,r){let n=this.cache,i=r.allocateTextureUnit();n[0]!==i&&(e.uniform1i(this.addr,i),n[0]=i),r.safeSetTextureCube(t||Xfe,i)}function Pmr(e,t,r){let n=this.cache,i=r.allocateTextureUnit();n[0]!==i&&(e.uniform1i(this.addr,i),n[0]=i),r.setTexture2DArray(t||Yfe,i)}function Imr(e){switch(e){case 5126:return hmr;case 35664:return fmr;case 35665:return pmr;case 35666:return dmr;case 35674:return mmr;case 35675:return gmr;case 35676:return _mr;case 5124:case 35670:return ymr;case 35667:case 35671:return vmr;case 35668:case 35672:return xmr;case 35669:case 35673:return bmr;case 5125:return wmr;case 36294:return Smr;case 36295:return Mmr;case 36296:return Emr;case 35678:case 36198:case 36298:case 36306:case 35682:return Tmr;case 35679:case 36299:case 36307:return Cmr;case 35680:case 36300:case 36308:case 36293:return Amr;case 36289:case 36303:case 36311:case 36292:return Pmr}}function Lmr(e,t){e.uniform1fv(this.addr,t)}function kmr(e,t){let r=bM(t,this.size,2);e.uniform2fv(this.addr,r)}function Rmr(e,t){let r=bM(t,this.size,3);e.uniform3fv(this.addr,r)}function Nmr(e,t){let r=bM(t,this.size,4);e.uniform4fv(this.addr,r)}function Dmr(e,t){let r=bM(t,this.size,4);e.uniformMatrix2fv(this.addr,!1,r)}function Omr(e,t){let r=bM(t,this.size,9);e.uniformMatrix3fv(this.addr,!1,r)}function zmr(e,t){let r=bM(t,this.size,16);e.uniformMatrix4fv(this.addr,!1,r)}function Fmr(e,t){e.uniform1iv(this.addr,t)}function Bmr(e,t){e.uniform2iv(this.addr,t)}function Hmr(e,t){e.uniform3iv(this.addr,t)}function Vmr(e,t){e.uniform4iv(this.addr,t)}function Umr(e,t){e.uniform1uiv(this.addr,t)}function qmr(e,t){e.uniform2uiv(this.addr,t)}function Gmr(e,t){e.uniform3uiv(this.addr,t)}function Wmr(e,t){e.uniform4uiv(this.addr,t)}function Ymr(e,t,r){let n=t.length,i=KU(r,n);e.uniform1iv(this.addr,i);for(let o=0;o!==n;++o)r.safeSetTexture2D(t[o]||Wfe,i[o])}function jmr(e,t,r){let n=t.length,i=KU(r,n);e.uniform1iv(this.addr,i);for(let o=0;o!==n;++o)r.setTexture3D(t[o]||jfe,i[o])}function Xmr(e,t,r){let n=t.length,i=KU(r,n);e.uniform1iv(this.addr,i);for(let o=0;o!==n;++o)r.safeSetTextureCube(t[o]||Xfe,i[o])}function $mr(e,t,r){let n=t.length,i=KU(r,n);e.uniform1iv(this.addr,i);for(let o=0;o!==n;++o)r.setTexture2DArray(t[o]||Yfe,i[o])}function Kmr(e){switch(e){case 5126:return Lmr;case 35664:return kmr;case 35665:return Rmr;case 35666:return Nmr;case 35674:return Dmr;case 35675:return Omr;case 35676:return zmr;case 5124:case 35670:return Fmr;case 35667:case 35671:return Bmr;case 35668:case 35672:return Hmr;case 35669:case 35673:return Vmr;case 5125:return Umr;case 36294:return qmr;case 36295:return Gmr;case 36296:return Wmr;case 35678:case 36198:case 36298:case 36306:case 35682:return Ymr;case 35679:case 36299:case 36307:return jmr;case 35680:case 36300:case 36308:case 36293:return Xmr;case 36289:case 36303:case 36311:case 36292:return $mr}}function Zmr(e,t,r){this.id=e,this.addr=r,this.cache=[],this.setValue=Imr(t.type)}function $fe(e,t,r){this.id=e,this.addr=r,this.cache=[],this.size=t.size,this.setValue=Kmr(t.type)}$fe.prototype.updateCache=function(e){let t=this.cache;e instanceof Float32Array&&t.length!==e.length&&(this.cache=new Float32Array(e.length)),Ca(t,e)};function Kfe(e){this.id=e,this.seq=[],this.map={}}Kfe.prototype.setValue=function(e,t,r){let n=this.seq;for(let i=0,o=n.length;i!==o;++i){let a=n[i];a.setValue(e,t[a.id],r)}};var put=/(\w+)(\])?(\[|\.)?/g;function Vue(e,t){e.seq.push(t),e.map[t.id]=t}function Jmr(e,t,r){let n=e.name,i=n.length;for(put.lastIndex=0;;){let o=put.exec(n),a=put.lastIndex,s=o[1],l=o[2]==="]",c=o[3];if(l&&(s=s|0),c===void 0||c==="["&&a+2===i){Vue(r,c===void 0?new Zmr(s,e,t):new $fe(s,e,t));break}else{let h=r.map[s];h===void 0&&(h=new Kfe(s),Vue(r,h)),r=h}}}function B0(e,t){this.seq=[],this.map={};let r=e.getProgramParameter(t,35718);for(let n=0;n<r;++n){let i=e.getActiveUniform(t,n),o=e.getUniformLocation(t,i.name);Jmr(i,o,this)}}B0.prototype.setValue=function(e,t,r,n){let i=this.map[t];i!==void 0&&i.setValue(e,r,n)};B0.prototype.setOptional=function(e,t,r){let n=t[r];n!==void 0&&this.setValue(e,r,n)};B0.upload=function(e,t,r,n){for(let i=0,o=t.length;i!==o;++i){let a=t[i],s=r[a.id];s.needsUpdate!==!1&&a.setValue(e,s.value,n)}};B0.seqWithValue=function(e,t){let r=[];for(let n=0,i=e.length;n!==i;++n){let o=e[n];o.id in t&&r.push(o)}return r};function Uue(e,t,r){let n=e.createShader(t);return e.shaderSource(n,r),e.compileShader(n),n}var Qmr=0;function tgr(e){let t=e.split(`
`);for(let r=0;r<t.length;r++)t[r]=r+1+": "+t[r];return t.join(`
`)}function egr(e){switch(e){case Qd:return["Linear","( value )"];case Wn:return["sRGB","( value )"];default:return console.warn("THREE.WebGLProgram: Unsupported encoding:",e),["Linear","( value )"]}}function que(e,t,r){let n=e.getShaderParameter(t,35713),i=e.getShaderInfoLog(t).trim();return n&&i===""?"":r.toUpperCase()+`

`+i+`

`+tgr(e.getShaderSource(t))}function rgr(e,t){let r=egr(t);return"vec4 "+e+"( vec4 value ) { return LinearTo"+r[0]+r[1]+"; }"}function ngr(e,t){let r;switch(t){case ufe:r="Linear";break;case hfe:r="Reinhard";break;case ffe:r="OptimizedCineon";break;case pfe:r="ACESFilmic";break;case dfe:r="Custom";break;default:console.warn("THREE.WebGLProgram: Unsupported toneMapping:",t),r="Linear"}return"vec3 "+e+"( vec3 color ) { return "+r+"ToneMapping( color ); }"}function igr(e){return[e.extensionDerivatives||e.envMapCubeUV||e.bumpMap||e.tangentSpaceNormalMap||e.clearcoatNormalMap||e.flatShading||e.shaderID==="physical"?"#extension GL_OES_standard_derivatives : enable":"",(e.extensionFragDepth||e.logarithmicDepthBuffer)&&e.rendererExtensionFragDepth?"#extension GL_EXT_frag_depth : enable":"",e.extensionDrawBuffers&&e.rendererExtensionDrawBuffers?"#extension GL_EXT_draw_buffers : require":"",(e.extensionShaderTextureLOD||e.envMap||e.transmission)&&e.rendererExtensionShaderTextureLod?"#extension GL_EXT_shader_texture_lod : enable":""].filter(HP).join(`
`)}function ogr(e){let t=[];for(let r in e){let n=e[r];n!==!1&&t.push("#define "+r+" "+n)}return t.join(`
`)}function agr(e,t){let r={},n=e.getProgramParameter(t,35721);for(let i=0;i<n;i++){let o=e.getActiveAttrib(t,i),a=o.name,s=1;o.type===35674&&(s=2),o.type===35675&&(s=3),o.type===35676&&(s=4),r[a]={type:o.type,location:e.getAttribLocation(t,a),locationSize:s}}return r}function HP(e){return e!==""}function Gue(e,t){return e.replace(/NUM_DIR_LIGHTS/g,t.numDirLights).replace(/NUM_SPOT_LIGHTS/g,t.numSpotLights).replace(/NUM_RECT_AREA_LIGHTS/g,t.numRectAreaLights).replace(/NUM_POINT_LIGHTS/g,t.numPointLights).replace(/NUM_HEMI_LIGHTS/g,t.numHemiLights).replace(/NUM_DIR_LIGHT_SHADOWS/g,t.numDirLightShadows).replace(/NUM_SPOT_LIGHT_SHADOWS/g,t.numSpotLightShadows).replace(/NUM_POINT_LIGHT_SHADOWS/g,t.numPointLightShadows)}function Wue(e,t){return e.replace(/NUM_CLIPPING_PLANES/g,t.numClippingPlanes).replace(/UNION_CLIPPING_PLANES/g,t.numClippingPlanes-t.numClipIntersection)}var sgr=/^[ \t]*#include +<([\w\d./]+)>/gm;function Jut(e){return e.replace(sgr,lgr)}function lgr(e,t){let r=hr[t];if(r===void 0)throw new Error("Can not resolve #include <"+t+">");return Jut(r)}var cgr=/#pragma unroll_loop[\s]+?for \( int i \= (\d+)\; i < (\d+)\; i \+\+ \) \{([\s\S]+?)(?=\})\}/g,ugr=/#pragma unroll_loop_start\s+for\s*\(\s*int\s+i\s*=\s*(\d+)\s*;\s*i\s*<\s*(\d+)\s*;\s*i\s*\+\+\s*\)\s*{([\s\S]+?)}\s+#pragma unroll_loop_end/g;function Yue(e){return e.replace(ugr,Zfe).replace(cgr,hgr)}function hgr(e,t,r,n){return console.warn("WebGLProgram: #pragma unroll_loop shader syntax is deprecated. Please use #pragma unroll_loop_start syntax instead."),Zfe(e,t,r,n)}function Zfe(e,t,r,n){let i="";for(let o=parseInt(t);o<parseInt(r);o++)i+=n.replace(/\[\s*i\s*\]/g,"[ "+o+" ]").replace(/UNROLLED_LOOP_INDEX/g,o);return i}function jue(e){let t="precision "+e.precision+` float;
precision `+e.precision+" int;";return e.precision==="highp"?t+=`
#define HIGH_PRECISION`:e.precision==="mediump"?t+=`
#define MEDIUM_PRECISION`:e.precision==="lowp"&&(t+=`
#define LOW_PRECISION`),t}function fgr(e){let t="SHADOWMAP_TYPE_BASIC";return e.shadowMapType===Cht?t="SHADOWMAP_TYPE_PCF":e.shadowMapType===Uhe?t="SHADOWMAP_TYPE_PCF_SOFT":e.shadowMapType===F3&&(t="SHADOWMAP_TYPE_VSM"),t}function pgr(e){let t="ENVMAP_TYPE_CUBE";if(e.envMap)switch(e.envMapMode){case nx:case ix:t="ENVMAP_TYPE_CUBE";break;case xM:case z6:t="ENVMAP_TYPE_CUBE_UV";break}return t}function dgr(e){let t="ENVMAP_MODE_REFLECTION";if(e.envMap)switch(e.envMapMode){case ix:case z6:t="ENVMAP_MODE_REFRACTION";break}return t}function mgr(e){let t="ENVMAP_BLENDING_NONE";if(e.envMap)switch(e.combine){case O6:t="ENVMAP_BLENDING_MULTIPLY";break;case lfe:t="ENVMAP_BLENDING_MIX";break;case cfe:t="ENVMAP_BLENDING_ADD";break}return t}function ggr(e,t,r,n){let i=e.getContext(),o=r.defines,a=r.vertexShader,s=r.fragmentShader,l=fgr(r),c=pgr(r),u=dgr(r),h=mgr(r),f=r.isWebGL2?"":igr(r),p=ogr(o),d=i.createProgram(),g,_,y=r.glslVersion?"#version "+r.glslVersion+`
`:"";r.isRawShaderMaterial?(g=[p].filter(HP).join(`
`),g.length>0&&(g+=`
`),_=[f,p].filter(HP).join(`
`),_.length>0&&(_+=`
`)):(g=[jue(r),"#define SHADER_NAME "+r.shaderName,p,r.instancing?"#define USE_INSTANCING":"",r.instancingColor?"#define USE_INSTANCING_COLOR":"",r.supportsVertexTextures?"#define VERTEX_TEXTURES":"","#define MAX_BONES "+r.maxBones,r.useFog&&r.fog?"#define USE_FOG":"",r.useFog&&r.fogExp2?"#define FOG_EXP2":"",r.map?"#define USE_MAP":"",r.envMap?"#define USE_ENVMAP":"",r.envMap?"#define "+u:"",r.lightMap?"#define USE_LIGHTMAP":"",r.aoMap?"#define USE_AOMAP":"",r.emissiveMap?"#define USE_EMISSIVEMAP":"",r.bumpMap?"#define USE_BUMPMAP":"",r.normalMap?"#define USE_NORMALMAP":"",r.normalMap&&r.objectSpaceNormalMap?"#define OBJECTSPACE_NORMALMAP":"",r.normalMap&&r.tangentSpaceNormalMap?"#define TANGENTSPACE_NORMALMAP":"",r.clearcoatMap?"#define USE_CLEARCOATMAP":"",r.clearcoatRoughnessMap?"#define USE_CLEARCOAT_ROUGHNESSMAP":"",r.clearcoatNormalMap?"#define USE_CLEARCOAT_NORMALMAP":"",r.displacementMap&&r.supportsVertexTextures?"#define USE_DISPLACEMENTMAP":"",r.specularMap?"#define USE_SPECULARMAP":"",r.specularIntensityMap?"#define USE_SPECULARINTENSITYMAP":"",r.specularColorMap?"#define USE_SPECULARCOLORMAP":"",r.roughnessMap?"#define USE_ROUGHNESSMAP":"",r.metalnessMap?"#define USE_METALNESSMAP":"",r.alphaMap?"#define USE_ALPHAMAP":"",r.transmission?"#define USE_TRANSMISSION":"",r.transmissionMap?"#define USE_TRANSMISSIONMAP":"",r.thicknessMap?"#define USE_THICKNESSMAP":"",r.sheenColorMap?"#define USE_SHEENCOLORMAP":"",r.sheenRoughnessMap?"#define USE_SHEENROUGHNESSMAP":"",r.vertexTangents?"#define USE_TANGENT":"",r.vertexColors?"#define USE_COLOR":"",r.vertexAlphas?"#define USE_COLOR_ALPHA":"",r.vertexUvs?"#define USE_UV":"",r.uvsVertexOnly?"#define UVS_VERTEX_ONLY":"",r.flatShading?"#define FLAT_SHADED":"",r.skinning?"#define USE_SKINNING":"",r.useVertexTexture?"#define BONE_TEXTURE":"",r.morphTargets?"#define USE_MORPHTARGETS":"",r.morphNormals&&r.flatShading===!1?"#define USE_MORPHNORMALS":"",r.morphTargets&&r.isWebGL2?"#define MORPHTARGETS_TEXTURE":"",r.morphTargets&&r.isWebGL2?"#define MORPHTARGETS_COUNT "+r.morphTargetsCount:"",r.doubleSided?"#define DOUBLE_SIDED":"",r.flipSided?"#define FLIP_SIDED":"",r.shadowMapEnabled?"#define USE_SHADOWMAP":"",r.shadowMapEnabled?"#define "+l:"",r.sizeAttenuation?"#define USE_SIZEATTENUATION":"",r.logarithmicDepthBuffer?"#define USE_LOGDEPTHBUF":"",r.logarithmicDepthBuffer&&r.rendererExtensionFragDepth?"#define USE_LOGDEPTHBUF_EXT":"","uniform mat4 modelMatrix;","uniform mat4 modelViewMatrix;","uniform mat4 projectionMatrix;","uniform mat4 viewMatrix;","uniform mat3 normalMatrix;","uniform vec3 cameraPosition;","uniform bool isOrthographic;","#ifdef USE_INSTANCING","	attribute mat4 instanceMatrix;","#endif","#ifdef USE_INSTANCING_COLOR","	attribute vec3 instanceColor;","#endif","attribute vec3 position;","attribute vec3 normal;","attribute vec2 uv;","#ifdef USE_TANGENT","	attribute vec4 tangent;","#endif","#if defined( USE_COLOR_ALPHA )","	attribute vec4 color;","#elif defined( USE_COLOR )","	attribute vec3 color;","#endif","#if ( defined( USE_MORPHTARGETS ) && ! defined( MORPHTARGETS_TEXTURE ) )","	attribute vec3 morphTarget0;","	attribute vec3 morphTarget1;","	attribute vec3 morphTarget2;","	attribute vec3 morphTarget3;","	#ifdef USE_MORPHNORMALS","		attribute vec3 morphNormal0;","		attribute vec3 morphNormal1;","		attribute vec3 morphNormal2;","		attribute vec3 morphNormal3;","	#else","		attribute vec3 morphTarget4;","		attribute vec3 morphTarget5;","		attribute vec3 morphTarget6;","		attribute vec3 morphTarget7;","	#endif","#endif","#ifdef USE_SKINNING","	attribute vec4 skinIndex;","	attribute vec4 skinWeight;","#endif",`
`].filter(HP).join(`
`),_=[f,jue(r),"#define SHADER_NAME "+r.shaderName,p,r.useFog&&r.fog?"#define USE_FOG":"",r.useFog&&r.fogExp2?"#define FOG_EXP2":"",r.map?"#define USE_MAP":"",r.matcap?"#define USE_MATCAP":"",r.envMap?"#define USE_ENVMAP":"",r.envMap?"#define "+c:"",r.envMap?"#define "+u:"",r.envMap?"#define "+h:"",r.lightMap?"#define USE_LIGHTMAP":"",r.aoMap?"#define USE_AOMAP":"",r.emissiveMap?"#define USE_EMISSIVEMAP":"",r.bumpMap?"#define USE_BUMPMAP":"",r.normalMap?"#define USE_NORMALMAP":"",r.normalMap&&r.objectSpaceNormalMap?"#define OBJECTSPACE_NORMALMAP":"",r.normalMap&&r.tangentSpaceNormalMap?"#define TANGENTSPACE_NORMALMAP":"",r.clearcoat?"#define USE_CLEARCOAT":"",r.clearcoatMap?"#define USE_CLEARCOATMAP":"",r.clearcoatRoughnessMap?"#define USE_CLEARCOAT_ROUGHNESSMAP":"",r.clearcoatNormalMap?"#define USE_CLEARCOAT_NORMALMAP":"",r.specularMap?"#define USE_SPECULARMAP":"",r.specularIntensityMap?"#define USE_SPECULARINTENSITYMAP":"",r.specularColorMap?"#define USE_SPECULARCOLORMAP":"",r.roughnessMap?"#define USE_ROUGHNESSMAP":"",r.metalnessMap?"#define USE_METALNESSMAP":"",r.alphaMap?"#define USE_ALPHAMAP":"",r.alphaTest?"#define USE_ALPHATEST":"",r.sheen?"#define USE_SHEEN":"",r.sheenColorMap?"#define USE_SHEENCOLORMAP":"",r.sheenRoughnessMap?"#define USE_SHEENROUGHNESSMAP":"",r.transmission?"#define USE_TRANSMISSION":"",r.transmissionMap?"#define USE_TRANSMISSIONMAP":"",r.thicknessMap?"#define USE_THICKNESSMAP":"",r.decodeVideoTexture?"#define DECODE_VIDEO_TEXTURE":"",r.vertexTangents?"#define USE_TANGENT":"",r.vertexColors||r.instancingColor?"#define USE_COLOR":"",r.vertexAlphas?"#define USE_COLOR_ALPHA":"",r.vertexUvs?"#define USE_UV":"",r.uvsVertexOnly?"#define UVS_VERTEX_ONLY":"",r.gradientMap?"#define USE_GRADIENTMAP":"",r.flatShading?"#define FLAT_SHADED":"",r.doubleSided?"#define DOUBLE_SIDED":"",r.flipSided?"#define FLIP_SIDED":"",r.shadowMapEnabled?"#define USE_SHADOWMAP":"",r.shadowMapEnabled?"#define "+l:"",r.premultipliedAlpha?"#define PREMULTIPLIED_ALPHA":"",r.physicallyCorrectLights?"#define PHYSICALLY_CORRECT_LIGHTS":"",r.logarithmicDepthBuffer?"#define USE_LOGDEPTHBUF":"",r.logarithmicDepthBuffer&&r.rendererExtensionFragDepth?"#define USE_LOGDEPTHBUF_EXT":"",(r.extensionShaderTextureLOD||r.envMap)&&r.rendererExtensionShaderTextureLod?"#define TEXTURE_LOD_EXT":"","uniform mat4 viewMatrix;","uniform vec3 cameraPosition;","uniform bool isOrthographic;",r.toneMapping!==Kd?"#define TONE_MAPPING":"",r.toneMapping!==Kd?hr.tonemapping_pars_fragment:"",r.toneMapping!==Kd?ngr("toneMapping",r.toneMapping):"",r.dithering?"#define DITHERING":"",r.alphaWrite?"":"#define OPAQUE",hr.encodings_pars_fragment,rgr("linearToOutputTexel",r.outputEncoding),r.depthPacking?"#define DEPTH_PACKING "+r.depthPacking:"",`
`].filter(HP).join(`
`)),a=Jut(a),a=Gue(a,r),a=Wue(a,r),s=Jut(s),s=Gue(s,r),s=Wue(s,r),a=Yue(a),s=Yue(s),r.isWebGL2&&r.isRawShaderMaterial!==!0&&(y=`#version 300 es
`,g=["precision mediump sampler2DArray;","#define attribute in","#define varying out","#define texture2D texture"].join(`
`)+`
`+g,_=["#define varying in",r.glslVersion===Kut?"":"layout(location = 0) out highp vec4 pc_fragColor;",r.glslVersion===Kut?"":"#define gl_FragColor pc_fragColor","#define gl_FragDepthEXT gl_FragDepth","#define texture2D texture","#define textureCube texture","#define texture2DProj textureProj","#define texture2DLodEXT textureLod","#define texture2DProjLodEXT textureProjLod","#define textureCubeLodEXT textureLod","#define texture2DGradEXT textureGrad","#define texture2DProjGradEXT textureProjGrad","#define textureCubeGradEXT textureGrad"].join(`
`)+`
`+_);let x=y+g+a,b=y+_+s,S=Uue(i,35633,x),C=Uue(i,35632,b);if(i.attachShader(d,S),i.attachShader(d,C),r.index0AttributeName!==void 0?i.bindAttribLocation(d,0,r.index0AttributeName):r.morphTargets===!0&&i.bindAttribLocation(d,0,"position"),i.linkProgram(d),e.debug.checkShaderErrors){let O=i.getProgramInfoLog(d).trim(),D=i.getShaderInfoLog(S).trim(),B=i.getShaderInfoLog(C).trim(),I=!0,L=!0;if(i.getProgramParameter(d,35714)===!1){I=!1;let R=que(i,S,"vertex"),F=que(i,C,"fragment");console.error("THREE.WebGLProgram: Shader Error "+i.getError()+" - VALIDATE_STATUS "+i.getProgramParameter(d,35715)+`

Program Info Log: `+O+`
`+R+`
`+F)}else O!==""?console.warn("THREE.WebGLProgram: Program Info Log:",O):(D===""||B==="")&&(L=!1);L&&(this.diagnostics={runnable:I,programLog:O,vertexShader:{log:D,prefix:g},fragmentShader:{log:B,prefix:_}})}i.deleteShader(S),i.deleteShader(C);let P;this.getUniforms=function(){return P===void 0&&(P=new B0(i,d)),P};let k;return this.getAttributes=function(){return k===void 0&&(k=agr(i,d)),k},this.destroy=function(){n.releaseStatesOfProgram(this),i.deleteProgram(d),this.program=void 0},this.name=r.shaderName,this.id=Qmr++,this.cacheKey=t,this.usedTimes=1,this.program=d,this.vertexShader=S,this.fragmentShader=C,this}var _gr=0,Qut=class{constructor(){this.shaderCache=new Map,this.materialCache=new Map}update(t){let r=t.vertexShader,n=t.fragmentShader,i=this._getShaderStage(r),o=this._getShaderStage(n),a=this._getShaderCacheForMaterial(t);return a.has(i)===!1&&(a.add(i),i.usedTimes++),a.has(o)===!1&&(a.add(o),o.usedTimes++),this}remove(t){let r=this.materialCache.get(t);for(let n of r)n.usedTimes--,n.usedTimes===0&&this.shaderCache.delete(n);return this.materialCache.delete(t),this}getVertexShaderID(t){return this._getShaderStage(t.vertexShader).id}getFragmentShaderID(t){return this._getShaderStage(t.fragmentShader).id}dispose(){this.shaderCache.clear(),this.materialCache.clear()}_getShaderCacheForMaterial(t){let r=this.materialCache;return r.has(t)===!1&&r.set(t,new Set),r.get(t)}_getShaderStage(t){let r=this.shaderCache;if(r.has(t)===!1){let n=new tht;r.set(t,n)}return r.get(t)}},tht=class{constructor(){this.id=_gr++,this.usedTimes=0}};function ygr(e,t,r,n,i,o,a){let s=new X3,l=new Qut,c=[],u=i.isWebGL2,h=i.logarithmicDepthBuffer,f=i.floatVertexTextures,p=i.maxVertexUniforms,d=i.vertexTextures,g=i.precision,_={MeshDepthMaterial:"depth",MeshDistanceMaterial:"distanceRGBA",MeshNormalMaterial:"normal",MeshBasicMaterial:"basic",MeshLambertMaterial:"lambert",MeshPhongMaterial:"phong",MeshToonMaterial:"toon",MeshStandardMaterial:"physical",MeshPhysicalMaterial:"physical",MeshMatcapMaterial:"matcap",LineBasicMaterial:"basic",LineDashedMaterial:"dashed",PointsMaterial:"points",ShadowMaterial:"shadow",SpriteMaterial:"sprite"};function y(I){let R=I.skeleton.bones;if(f)return 1024;{let z=Math.floor((p-20)/4),U=Math.min(z,R.length);return U<R.length?(console.warn("THREE.WebGLRenderer: Skeleton has "+R.length+" bones. This GPU supports "+U+"."),0):U}}function x(I,L,R,F,z){let U=F.fog,W=I.isMeshStandardMaterial?F.environment:null,Z=(I.isMeshStandardMaterial?r:t).get(I.envMap||W),rt=_[I.type],ot=z.isSkinnedMesh?y(z):0;I.precision!==null&&(g=i.getMaxPrecision(I.precision),g!==I.precision&&console.warn("THREE.WebGLProgram.getParameters:",I.precision,"not supported, using",g,"instead."));let st,St,bt,Mt;if(rt){let X=ah[rt];st=X.vertexShader,St=X.fragmentShader}else st=I.vertexShader,St=I.fragmentShader,l.update(I),bt=l.getVertexShaderID(I),Mt=l.getFragmentShaderID(I);let lt=e.getRenderTarget(),Kt=I.alphaTest>0,_t=I.clearcoat>0;return{isWebGL2:u,shaderID:rt,shaderName:I.type,vertexShader:st,fragmentShader:St,defines:I.defines,customVertexShaderID:bt,customFragmentShaderID:Mt,isRawShaderMaterial:I.isRawShaderMaterial===!0,glslVersion:I.glslVersion,precision:g,instancing:z.isInstancedMesh===!0,instancingColor:z.isInstancedMesh===!0&&z.instanceColor!==null,supportsVertexTextures:d,outputEncoding:lt===null?e.outputEncoding:lt.isXRRenderTarget===!0?lt.texture.encoding:Qd,map:!!I.map,matcap:!!I.matcap,envMap:!!Z,envMapMode:Z&&Z.mapping,envMapCubeUV:!!Z&&(Z.mapping===xM||Z.mapping===z6),lightMap:!!I.lightMap,aoMap:!!I.aoMap,emissiveMap:!!I.emissiveMap,bumpMap:!!I.bumpMap,normalMap:!!I.normalMap,objectSpaceNormalMap:I.normalMapType===Dfe,tangentSpaceNormalMap:I.normalMapType===ax,decodeVideoTexture:!!I.map&&I.map.isVideoTexture===!0&&I.map.encoding===Wn,clearcoat:_t,clearcoatMap:_t&&!!I.clearcoatMap,clearcoatRoughnessMap:_t&&!!I.clearcoatRoughnessMap,clearcoatNormalMap:_t&&!!I.clearcoatNormalMap,displacementMap:!!I.displacementMap,roughnessMap:!!I.roughnessMap,metalnessMap:!!I.metalnessMap,specularMap:!!I.specularMap,specularIntensityMap:!!I.specularIntensityMap,specularColorMap:!!I.specularColorMap,alphaMap:!!I.alphaMap,alphaTest:Kt,alphaWrite:I.alphaWrite||I.transparent,gradientMap:!!I.gradientMap,sheen:I.sheen>0,sheenColorMap:!!I.sheenColorMap,sheenRoughnessMap:!!I.sheenRoughnessMap,transmission:I.transmission>0,transmissionMap:!!I.transmissionMap,thicknessMap:!!I.thicknessMap,combine:I.combine,vertexTangents:!!I.normalMap&&!!z.geometry&&!!z.geometry.attributes.tangent,vertexColors:I.vertexColors,vertexAlphas:I.vertexColors===!0&&!!z.geometry&&!!z.geometry.attributes.color&&z.geometry.attributes.color.itemSize===4,vertexUvs:!!I.map||!!I.bumpMap||!!I.normalMap||!!I.specularMap||!!I.alphaMap||!!I.emissiveMap||!!I.roughnessMap||!!I.metalnessMap||!!I.clearcoatMap||!!I.clearcoatRoughnessMap||!!I.clearcoatNormalMap||!!I.displacementMap||!!I.transmissionMap||!!I.thicknessMap||!!I.specularIntensityMap||!!I.specularColorMap||!!I.sheenColorMap||!!I.sheenRoughnessMap,uvsVertexOnly:!(!!I.map||!!I.bumpMap||!!I.normalMap||!!I.specularMap||!!I.alphaMap||!!I.emissiveMap||!!I.roughnessMap||!!I.metalnessMap||!!I.clearcoatNormalMap||I.transmission>0||!!I.transmissionMap||!!I.thicknessMap||!!I.specularIntensityMap||!!I.specularColorMap||I.sheen>0||!!I.sheenColorMap||!!I.sheenRoughnessMap)&&!!I.displacementMap,fog:!!U,useFog:I.fog,fogExp2:U&&U.isFogExp2,flatShading:!!I.flatShading,sizeAttenuation:I.sizeAttenuation,logarithmicDepthBuffer:h,skinning:z.isSkinnedMesh===!0&&ot>0,maxBones:ot,useVertexTexture:f,morphTargets:!!z.geometry&&!!z.geometry.morphAttributes.position,morphNormals:!!z.geometry&&!!z.geometry.morphAttributes.normal,morphTargetsCount:!!z.geometry&&!!z.geometry.morphAttributes.position?z.geometry.morphAttributes.position.length:0,numDirLights:L.directional.length,numPointLights:L.point.length,numSpotLights:L.spot.length,numRectAreaLights:L.rectArea.length,numHemiLights:L.hemi.length,numDirLightShadows:L.directionalShadowMap.length,numPointLightShadows:L.pointShadowMap.length,numSpotLightShadows:L.spotShadowMap.length,numClippingPlanes:a.numPlanes,numClipIntersection:a.numIntersection,dithering:I.dithering,shadowMapEnabled:e.shadowMap.enabled&&R.length>0,shadowMapType:e.shadowMap.type,toneMapping:I.toneMapped?e.toneMapping:Kd,physicallyCorrectLights:e.physicallyCorrectLights,premultipliedAlpha:I.premultipliedAlpha,doubleSided:I.side===L1,flipSided:I.side===Ii,depthPacking:I.depthPacking!==void 0?I.depthPacking:!1,index0AttributeName:I.index0AttributeName,extensionDerivatives:I.extensions&&I.extensions.derivatives,extensionFragDepth:I.extensions&&I.extensions.fragDepth,extensionDrawBuffers:I.extensions&&I.extensions.drawBuffers,extensionShaderTextureLOD:I.extensions&&I.extensions.shaderTextureLOD,rendererExtensionFragDepth:u||n.has("EXT_frag_depth"),rendererExtensionDrawBuffers:u||n.has("WEBGL_draw_buffers"),rendererExtensionShaderTextureLod:u||n.has("EXT_shader_texture_lod"),customProgramCacheKey:I.customProgramCacheKey()}}function b(I){let L=[];if(I.shaderID?L.push(I.shaderID):(L.push(I.customVertexShaderID),L.push(I.customFragmentShaderID)),I.defines!==void 0)for(let R in I.defines)L.push(R),L.push(I.defines[R]);return I.isRawShaderMaterial===!1&&(S(L,I),C(L,I),L.push(e.outputEncoding)),L.push(I.customProgramCacheKey),L.join()}function S(I,L){I.push(L.precision),I.push(L.outputEncoding),I.push(L.envMapMode),I.push(L.combine),I.push(L.vertexUvs),I.push(L.fogExp2),I.push(L.sizeAttenuation),I.push(L.maxBones),I.push(L.morphTargetsCount),I.push(L.numDirLights),I.push(L.numPointLights),I.push(L.numSpotLights),I.push(L.numHemiLights),I.push(L.numRectAreaLights),I.push(L.numDirLightShadows),I.push(L.numPointLightShadows),I.push(L.numSpotLightShadows),I.push(L.shadowMapType),I.push(L.toneMapping),I.push(L.numClippingPlanes),I.push(L.numClipIntersection),I.push(L.alphaWrite)}function C(I,L){s.disableAll(),L.isWebGL2&&s.enable(0),L.supportsVertexTextures&&s.enable(1),L.instancing&&s.enable(2),L.instancingColor&&s.enable(3),L.map&&s.enable(4),L.matcap&&s.enable(5),L.envMap&&s.enable(6),L.envMapCubeUV&&s.enable(7),L.lightMap&&s.enable(8),L.aoMap&&s.enable(9),L.emissiveMap&&s.enable(10),L.bumpMap&&s.enable(11),L.normalMap&&s.enable(12),L.objectSpaceNormalMap&&s.enable(13),L.tangentSpaceNormalMap&&s.enable(14),L.clearcoat&&s.enable(15),L.clearcoatMap&&s.enable(16),L.clearcoatRoughnessMap&&s.enable(17),L.clearcoatNormalMap&&s.enable(18),L.displacementMap&&s.enable(19),L.specularMap&&s.enable(20),L.roughnessMap&&s.enable(21),L.metalnessMap&&s.enable(22),L.gradientMap&&s.enable(23),L.alphaMap&&s.enable(24),L.alphaTest&&s.enable(25),L.vertexColors&&s.enable(26),L.vertexAlphas&&s.enable(27),L.vertexUvs&&s.enable(28),L.vertexTangents&&s.enable(29),L.uvsVertexOnly&&s.enable(30),L.fog&&s.enable(31),I.push(s.mask),s.disableAll(),L.useFog&&s.enable(0),L.flatShading&&s.enable(1),L.logarithmicDepthBuffer&&s.enable(2),L.skinning&&s.enable(3),L.useVertexTexture&&s.enable(4),L.morphTargets&&s.enable(5),L.morphNormals&&s.enable(6),L.premultipliedAlpha&&s.enable(7),L.shadowMapEnabled&&s.enable(8),L.physicallyCorrectLights&&s.enable(9),L.doubleSided&&s.enable(10),L.flipSided&&s.enable(11),L.depthPacking&&s.enable(12),L.dithering&&s.enable(13),L.specularIntensityMap&&s.enable(14),L.specularColorMap&&s.enable(15),L.transmission&&s.enable(16),L.transmissionMap&&s.enable(17),L.thicknessMap&&s.enable(18),L.sheen&&s.enable(19),L.sheenColorMap&&s.enable(20),L.sheenRoughnessMap&&s.enable(21),L.decodeVideoTexture&&s.enable(22),I.push(s.mask)}function P(I){let L=_[I.type],R;if(L){let F=ah[L];R=Vfe.clone(F.uniforms)}else R=I.uniforms;return R}function k(I,L){let R;for(let F=0,z=c.length;F<z;F++){let U=c[F];if(U.cacheKey===L){R=U,++R.usedTimes;break}}return R===void 0&&(R=new ggr(e,L,I,o),c.push(R)),R}function O(I){if(--I.usedTimes===0){let L=c.indexOf(I);c[L]=c[c.length-1],c.pop(),I.destroy()}}function D(I){l.remove(I)}function B(){l.dispose()}return{getParameters:x,getProgramCacheKey:b,getUniforms:P,acquireProgram:k,releaseProgram:O,releaseShaderCache:D,programs:c,dispose:B}}function vgr(){let e=new WeakMap;function t(o){let a=e.get(o);return a===void 0&&(a={},e.set(o,a)),a}function r(o){e.delete(o)}function n(o,a,s){e.get(o)[a]=s}function i(){e=new WeakMap}return{get:t,remove:r,update:n,dispose:i}}function xgr(e,t){return e.groupOrder!==t.groupOrder?e.groupOrder-t.groupOrder:e.renderOrder!==t.renderOrder?e.renderOrder-t.renderOrder:e.material.id!==t.material.id?e.material.id-t.material.id:e.z!==t.z?e.z-t.z:e.id-t.id}function Xue(e,t){return e.groupOrder!==t.groupOrder?e.groupOrder-t.groupOrder:e.renderOrder!==t.renderOrder?e.renderOrder-t.renderOrder:e.z!==t.z?t.z-e.z:e.id-t.id}function $ue(){let e=[],t=0,r=[],n=[],i=[];function o(){t=0,r.length=0,n.length=0,i.length=0}function a(h,f,p,d,g,_){let y=e[t];return y===void 0?(y={id:h.id,object:h,geometry:f,material:p,groupOrder:d,renderOrder:h.renderOrder,z:g,group:_},e[t]=y):(y.id=h.id,y.object=h,y.geometry=f,y.material=p,y.groupOrder=d,y.renderOrder=h.renderOrder,y.z=g,y.group=_),t++,y}function s(h,f,p,d,g,_){let y=a(h,f,p,d,g,_);p.transmission>0?n.push(y):p.transparent===!0?i.push(y):r.push(y)}function l(h,f,p,d,g,_){let y=a(h,f,p,d,g,_);p.transmission>0?n.unshift(y):p.transparent===!0?i.unshift(y):r.unshift(y)}function c(h,f){r.length>1&&r.sort(h||xgr),n.length>1&&n.sort(f||Xue),i.length>1&&i.sort(f||Xue)}function u(){for(let h=t,f=e.length;h<f;h++){let p=e[h];if(p.id===null)break;p.id=null,p.object=null,p.geometry=null,p.material=null,p.group=null}}return{opaque:r,transmissive:n,transparent:i,init:o,push:s,unshift:l,finish:u,sort:c}}function bgr(){let e=new WeakMap;function t(n,i){let o;return e.has(n)===!1?(o=new $ue,e.set(n,[o])):i>=e.get(n).length?(o=new $ue,e.get(n).push(o)):o=e.get(n)[i],o}function r(){e=new WeakMap}return{get:t,dispose:r}}function wgr(){let e={};return{get:function(t){if(e[t.id]!==void 0)return e[t.id];let r;switch(t.type){case"DirectionalLight":r={direction:new j,color:new ne};break;case"SpotLight":r={position:new j,direction:new j,color:new ne,distance:0,coneCos:0,penumbraCos:0,decay:0};break;case"PointLight":r={position:new j,color:new ne,distance:0,decay:0};break;case"HemisphereLight":r={direction:new j,skyColor:new ne,groundColor:new ne};break;case"RectAreaLight":r={color:new ne,position:new j,halfWidth:new j,halfHeight:new j};break}return e[t.id]=r,r}}}function Sgr(){let e={};return{get:function(t){if(e[t.id]!==void 0)return e[t.id];let r;switch(t.type){case"DirectionalLight":r={shadowBias:0,shadowNormalBias:0,shadowRadius:1,shadowMapSize:new Lt};break;case"SpotLight":r={shadowBias:0,shadowNormalBias:0,shadowRadius:1,shadowMapSize:new Lt};break;case"PointLight":r={shadowBias:0,shadowNormalBias:0,shadowRadius:1,shadowMapSize:new Lt,shadowCameraNear:1,shadowCameraFar:1e3};break}return e[t.id]=r,r}}}var Mgr=0;function Egr(e,t){return(t.castShadow?1:0)-(e.castShadow?1:0)}function Tgr(e,t){let r=new wgr,n=Sgr(),i={version:0,hash:{directionalLength:-1,pointLength:-1,spotLength:-1,rectAreaLength:-1,hemiLength:-1,numDirectionalShadows:-1,numPointShadows:-1,numSpotShadows:-1},ambient:[0,0,0],probe:[],directional:[],directionalShadow:[],directionalShadowMap:[],directionalShadowMatrix:[],spot:[],spotShadow:[],spotShadowMap:[],spotShadowMatrix:[],rectArea:[],rectAreaLTC1:null,rectAreaLTC2:null,point:[],pointShadow:[],pointShadowMap:[],pointShadowMatrix:[],hemi:[]};for(let u=0;u<9;u++)i.probe.push(new j);let o=new j,a=new Me,s=new Me;function l(u,h){let f=0,p=0,d=0;for(let D=0;D<9;D++)i.probe[D].set(0,0,0);let g=0,_=0,y=0,x=0,b=0,S=0,C=0,P=0;u.sort(Egr);let k=h!==!0?Math.PI:1;for(let D=0,B=u.length;D<B;D++){let I=u[D],L=I.color,R=I.intensity,F=I.distance,z=I.shadow&&I.shadow.map?I.shadow.map.texture:null;if(I.isAmbientLight)f+=L.r*R*k,p+=L.g*R*k,d+=L.b*R*k;else if(I.isLightProbe)for(let U=0;U<9;U++)i.probe[U].addScaledVector(I.sh.coefficients[U],R);else if(I.isDirectionalLight){let U=r.get(I);if(U.color.copy(I.color).multiplyScalar(I.intensity*k),I.castShadow){let W=I.shadow,Z=n.get(I);Z.shadowBias=W.bias,Z.shadowNormalBias=W.normalBias,Z.shadowRadius=W.radius,Z.shadowMapSize=W.mapSize,i.directionalShadow[g]=Z,i.directionalShadowMap[g]=z,i.directionalShadowMatrix[g]=I.shadow.matrix,S++}i.directional[g]=U,g++}else if(I.isSpotLight){let U=r.get(I);if(U.position.setFromMatrixPosition(I.matrixWorld),U.color.copy(L).multiplyScalar(R*k),U.distance=F,U.coneCos=Math.cos(I.angle),U.penumbraCos=Math.cos(I.angle*(1-I.penumbra)),U.decay=I.decay,I.castShadow){let W=I.shadow,Z=n.get(I);Z.shadowBias=W.bias,Z.shadowNormalBias=W.normalBias,Z.shadowRadius=W.radius,Z.shadowMapSize=W.mapSize,i.spotShadow[y]=Z,i.spotShadowMap[y]=z,i.spotShadowMatrix[y]=I.shadow.matrix,P++}i.spot[y]=U,y++}else if(I.isRectAreaLight){let U=r.get(I);U.color.copy(L).multiplyScalar(R),U.halfWidth.set(I.width*.5,0,0),U.halfHeight.set(0,I.height*.5,0),i.rectArea[x]=U,x++}else if(I.isPointLight){let U=r.get(I);if(U.color.copy(I.color).multiplyScalar(I.intensity*k),U.distance=I.distance,U.decay=I.decay,I.castShadow){let W=I.shadow,Z=n.get(I);Z.shadowBias=W.bias,Z.shadowNormalBias=W.normalBias,Z.shadowRadius=W.radius,Z.shadowMapSize=W.mapSize,Z.shadowCameraNear=W.camera.near,Z.shadowCameraFar=W.camera.far,i.pointShadow[_]=Z,i.pointShadowMap[_]=z,i.pointShadowMatrix[_]=I.shadow.matrix,C++}i.point[_]=U,_++}else if(I.isHemisphereLight){let U=r.get(I);U.skyColor.copy(I.color).multiplyScalar(R*k),U.groundColor.copy(I.groundColor).multiplyScalar(R*k),i.hemi[b]=U,b++}}x>0&&(t.isWebGL2||e.has("OES_texture_float_linear")===!0?(i.rectAreaLTC1=re.LTC_FLOAT_1,i.rectAreaLTC2=re.LTC_FLOAT_2):e.has("OES_texture_half_float_linear")===!0?(i.rectAreaLTC1=re.LTC_HALF_1,i.rectAreaLTC2=re.LTC_HALF_2):console.error("THREE.WebGLRenderer: Unable to use RectAreaLight. Missing WebGL extensions.")),i.ambient[0]=f,i.ambient[1]=p,i.ambient[2]=d;let O=i.hash;(O.directionalLength!==g||O.pointLength!==_||O.spotLength!==y||O.rectAreaLength!==x||O.hemiLength!==b||O.numDirectionalShadows!==S||O.numPointShadows!==C||O.numSpotShadows!==P)&&(i.directional.length=g,i.spot.length=y,i.rectArea.length=x,i.point.length=_,i.hemi.length=b,i.directionalShadow.length=S,i.directionalShadowMap.length=S,i.pointShadow.length=C,i.pointShadowMap.length=C,i.spotShadow.length=P,i.spotShadowMap.length=P,i.directionalShadowMatrix.length=S,i.pointShadowMatrix.length=C,i.spotShadowMatrix.length=P,O.directionalLength=g,O.pointLength=_,O.spotLength=y,O.rectAreaLength=x,O.hemiLength=b,O.numDirectionalShadows=S,O.numPointShadows=C,O.numSpotShadows=P,i.version=Mgr++)}function c(u,h){let f=0,p=0,d=0,g=0,_=0,y=h.matrixWorldInverse;for(let x=0,b=u.length;x<b;x++){let S=u[x];if(S.isDirectionalLight){let C=i.directional[f];C.direction.setFromMatrixPosition(S.matrixWorld),o.setFromMatrixPosition(S.target.matrixWorld),C.direction.sub(o),C.direction.transformDirection(y),f++}else if(S.isSpotLight){let C=i.spot[d];C.position.setFromMatrixPosition(S.matrixWorld),C.position.applyMatrix4(y),C.direction.setFromMatrixPosition(S.matrixWorld),o.setFromMatrixPosition(S.target.matrixWorld),C.direction.sub(o),C.direction.transformDirection(y),d++}else if(S.isRectAreaLight){let C=i.rectArea[g];C.position.setFromMatrixPosition(S.matrixWorld),C.position.applyMatrix4(y),s.identity(),a.copy(S.matrixWorld),a.premultiply(y),s.extractRotation(a),C.halfWidth.set(S.width*.5,0,0),C.halfHeight.set(0,S.height*.5,0),C.halfWidth.applyMatrix4(s),C.halfHeight.applyMatrix4(s),g++}else if(S.isPointLight){let C=i.point[p];C.position.setFromMatrixPosition(S.matrixWorld),C.position.applyMatrix4(y),p++}else if(S.isHemisphereLight){let C=i.hemi[_];C.direction.setFromMatrixPosition(S.matrixWorld),C.direction.transformDirection(y),C.direction.normalize(),_++}}}return{setup:l,setupView:c,state:i}}function Kue(e,t){let r=new Tgr(e,t),n=[],i=[];function o(){n.length=0,i.length=0}function a(h){n.push(h)}function s(h){i.push(h)}function l(h){r.setup(n,h)}function c(h){r.setupView(n,h)}return{init:o,state:{lightsArray:n,shadowsArray:i,lights:r},setupLights:l,setupLightsView:c,pushLight:a,pushShadow:s}}function Cgr(e,t){let r=new WeakMap;function n(o,a=0){let s;return r.has(o)===!1?(s=new Kue(e,t),r.set(o,[s])):a>=r.get(o).length?(s=new Kue(e,t),r.get(o).push(s)):s=r.get(o)[a],s}function i(){r=new WeakMap}return{get:n,dispose:i}}var eM=class extends qi{constructor(t){super(),this.type="MeshDepthMaterial",this.depthPacking=Rfe,this.map=null,this.alphaMap=null,this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.wireframe=!1,this.wireframeLinewidth=1,this.fog=!1,this.setValues(t)}copy(t){return super.copy(t),this.depthPacking=t.depthPacking,this.map=t.map,this.alphaMap=t.alphaMap,this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this}};eM.prototype.isMeshDepthMaterial=!0;var rM=class extends qi{constructor(t){super(),this.type="MeshDistanceMaterial",this.referencePosition=new j,this.nearDistance=1,this.farDistance=1e3,this.map=null,this.alphaMap=null,this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.fog=!1,this.setValues(t)}copy(t){return super.copy(t),this.referencePosition.copy(t.referencePosition),this.nearDistance=t.nearDistance,this.farDistance=t.farDistance,this.map=t.map,this.alphaMap=t.alphaMap,this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this}};rM.prototype.isMeshDistanceMaterial=!0;var Agr=`void main() {
	gl_Position = vec4( position, 1.0 );
}`,Pgr=`uniform sampler2D shadow_pass;
uniform vec2 resolution;
uniform float radius;
#include <packing>
void main() {
	const float samples = float( VSM_SAMPLES );
	float mean = 0.0;
	float squared_mean = 0.0;
	float uvStride = samples <= 1.0 ? 0.0 : 2.0 / ( samples - 1.0 );
	float uvStart = samples <= 1.0 ? 0.0 : - 1.0;
	for ( float i = 0.0; i < samples; i ++ ) {
		float uvOffset = uvStart + i * uvStride;
		#ifdef HORIZONTAL_PASS
			vec2 distribution = unpackRGBATo2Half( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( uvOffset, 0.0 ) * radius ) / resolution ) );
			mean += distribution.x;
			squared_mean += distribution.y * distribution.y + distribution.x * distribution.x;
		#else
			float depth = unpackRGBAToDepth( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( 0.0, uvOffset ) * radius ) / resolution ) );
			mean += depth;
			squared_mean += depth * depth;
		#endif
	}
	mean = mean / samples;
	squared_mean = squared_mean / samples;
	float std_dev = sqrt( squared_mean - mean * mean );
	gl_FragColor = pack2HalfToRGBA( vec2( mean, std_dev ) );
}`;function Jfe(e,t,r){let n=new N1,i=new Lt,o=new Lt,a=new en,s=new eM({depthPacking:Nfe}),l=new rM,c={},u=r.maxTextureSize,h={0:Ii,1:I1,2:L1},f=new lh({defines:{VSM_SAMPLES:8},uniforms:{shadow_pass:{value:null},resolution:{value:new Lt},radius:{value:4}},vertexShader:Agr,fragmentShader:Pgr}),p=f.clone();p.defines.HORIZONTAL_PASS=1;let d=new Pe;d.setAttribute("position",new Je(new Float32Array([-1,-1,.5,3,-1,.5,-1,3,.5]),3));let g=new ti(d,f),_=this;this.enabled=!1,this.autoUpdate=!0,this.needsUpdate=!1,this.type=Cht,this.render=function(S,C,P){if(_.enabled===!1||_.autoUpdate===!1&&_.needsUpdate===!1||S.length===0)return;let k=e.getRenderTarget(),O=e.getActiveCubeFace(),D=e.getActiveMipmapLevel(),B=e.state;B.setBlending($d),B.buffers.color.setClear(1,1,1,1),B.buffers.depth.setTest(!0),B.setScissorTest(!1);for(let I=0,L=S.length;I<L;I++){let R=S[I],F=R.shadow;if(F===void 0){console.warn("THREE.WebGLShadowMap:",R,"has no shadow.");continue}if(F.autoUpdate===!1&&F.needsUpdate===!1)continue;i.copy(F.mapSize);let z=F.getFrameExtents();if(i.multiply(z),o.copy(F.mapSize),(i.x>u||i.y>u)&&(i.x>u&&(o.x=Math.floor(u/z.x),i.x=o.x*z.x,F.mapSize.x=o.x),i.y>u&&(o.y=Math.floor(u/z.y),i.y=o.y*z.y,F.mapSize.y=o.y)),F.map===null&&!F.isPointLightShadow&&this.type===F3){let W={minFilter:ii,magFilter:ii,format:Qo};F.map=new us(i.x,i.y,W),F.map.texture.name=R.name+".shadowMap",F.mapPass=new us(i.x,i.y,W),F.camera.updateProjectionMatrix()}if(F.map===null){let W={minFilter:Li,magFilter:Li,format:Qo};F.map=new us(i.x,i.y,W),F.map.texture.name=R.name+".shadowMap",F.camera.updateProjectionMatrix()}e.setRenderTarget(F.map),e.clear();let U=F.getViewportCount();for(let W=0;W<U;W++){let Z=F.getViewport(W);a.set(o.x*Z.x,o.y*Z.y,o.x*Z.z,o.y*Z.w),B.viewport(a),F.updateMatrices(R,W),n=F.getFrustum(),b(C,P,F.camera,R,this.type)}!F.isPointLightShadow&&this.type===F3&&y(F,P),F.needsUpdate=!1}_.needsUpdate=!1,e.setRenderTarget(k,O,D)};function y(S,C){let P=t.update(g);f.defines.VSM_SAMPLES!==S.blurSamples&&(f.defines.VSM_SAMPLES=S.blurSamples,p.defines.VSM_SAMPLES=S.blurSamples,f.needsUpdate=!0,p.needsUpdate=!0),f.uniforms.shadow_pass.value=S.map.texture,f.uniforms.resolution.value=S.mapSize,f.uniforms.radius.value=S.radius,e.setRenderTarget(S.mapPass),e.clear(),e.renderBufferDirect(C,null,P,f,g,null),p.uniforms.shadow_pass.value=S.mapPass.texture,p.uniforms.resolution.value=S.mapSize,p.uniforms.radius.value=S.radius,e.setRenderTarget(S.map),e.clear(),e.renderBufferDirect(C,null,P,p,g,null)}function x(S,C,P,k,O,D,B){let I=null,L=k.isPointLight===!0?S.customDistanceMaterial:S.customDepthMaterial;if(L!==void 0?I=L:I=k.isPointLight===!0?l:s,e.localClippingEnabled&&P.clipShadows===!0&&P.clippingPlanes.length!==0||P.displacementMap&&P.displacementScale!==0||P.alphaMap&&P.alphaTest>0){let R=I.uuid,F=P.uuid,z=c[R];z===void 0&&(z={},c[R]=z);let U=z[F];U===void 0&&(U=I.clone(),z[F]=U),I=U}return I.visible=P.visible,I.wireframe=P.wireframe,B===F3?I.side=P.shadowSide!==null?P.shadowSide:P.side:I.side=P.shadowSide!==null?P.shadowSide:h[P.side],I.alphaMap=P.alphaMap,I.alphaTest=P.alphaTest,I.clipShadows=P.clipShadows,I.clippingPlanes=P.clippingPlanes,I.clipIntersection=P.clipIntersection,I.displacementMap=P.displacementMap,I.displacementScale=P.displacementScale,I.displacementBias=P.displacementBias,I.wireframeLinewidth=P.wireframeLinewidth,I.linewidth=P.linewidth,k.isPointLight===!0&&I.isMeshDistanceMaterial===!0&&(I.referencePosition.setFromMatrixPosition(k.matrixWorld),I.nearDistance=O,I.farDistance=D),I}function b(S,C,P,k,O){if(S.visible===!1)return;if(S.layers.test(C.layers)&&(S.isMesh||S.isLine||S.isPoints)&&(S.castShadow||S.receiveShadow&&O===F3)&&(!S.frustumCulled||n.intersectsObject(S))){S.modelViewMatrix.multiplyMatrices(P.matrixWorldInverse,S.matrixWorld);let I=t.update(S),L=S.material;if(Array.isArray(L)){let R=I.groups;for(let F=0,z=R.length;F<z;F++){let U=R[F],W=L[U.materialIndex];if(W&&W.visible){let Z=x(S,I,W,k,P.near,P.far,O);e.renderBufferDirect(P,null,I,Z,S,U)}}}else if(L.visible){let R=x(S,I,L,k,P.near,P.far,O);e.renderBufferDirect(P,null,I,R,S,null)}}let B=S.children;for(let I=0,L=B.length;I<L;I++)b(B[I],C,P,k,O)}}function Igr(e,t,r){let n=r.isWebGL2;function i(){let at=!1,se=new en,Qt=null,Ce=new en(0,0,0,0);return{setMask:function(Pt){Qt!==Pt&&!at&&(e.colorMask(Pt,Pt,Pt,Pt),Qt=Pt)},setLocked:function(Pt){at=Pt},setClear:function(Pt,Nt,ze,yn,Wi){Wi===!0&&(Pt*=yn,Nt*=yn,ze*=yn),se.set(Pt,Nt,ze,yn),Ce.equals(se)===!1&&(e.clearColor(Pt,Nt,ze,yn),Ce.copy(se))},reset:function(){at=!1,Qt=null,Ce.set(-1,0,0,0)}}}function o(){let at=!1,se=null,Qt=null,Ce=null;return{setTest:function(Pt){Pt?lt(2929):Kt(2929)},setMask:function(Pt){se!==Pt&&!at&&(e.depthMask(Pt),se=Pt)},setFunc:function(Pt){if(Qt!==Pt){if(Pt)switch(Pt){case efe:e.depthFunc(512);break;case rfe:e.depthFunc(519);break;case nfe:e.depthFunc(513);break;case iU:e.depthFunc(515);break;case ife:e.depthFunc(514);break;case ofe:e.depthFunc(518);break;case afe:e.depthFunc(516);break;case sfe:e.depthFunc(517);break;default:e.depthFunc(515)}else e.depthFunc(515);Qt=Pt}},setLocked:function(Pt){at=Pt},setClear:function(Pt){Ce!==Pt&&(e.clearDepth(Pt),Ce=Pt)},reset:function(){at=!1,se=null,Qt=null,Ce=null}}}function a(){let at=!1,se=null,Qt=null,Ce=null,Pt=null,Nt=null,ze=null,yn=null,Wi=null;return{setTest:function(Ar){at||(Ar?lt(2960):Kt(2960))},setMask:function(Ar){se!==Ar&&!at&&(e.stencilMask(Ar),se=Ar)},setFunc:function(Ar,Pa,ho){(Qt!==Ar||Ce!==Pa||Pt!==ho)&&(e.stencilFunc(Ar,Pa,ho),Qt=Ar,Ce=Pa,Pt=ho)},setOp:function(Ar,Pa,ho){(Nt!==Ar||ze!==Pa||yn!==ho)&&(e.stencilOp(Ar,Pa,ho),Nt=Ar,ze=Pa,yn=ho)},setLocked:function(Ar){at=Ar},setClear:function(Ar){Wi!==Ar&&(e.clearStencil(Ar),Wi=Ar)},reset:function(){at=!1,se=null,Qt=null,Ce=null,Pt=null,Nt=null,ze=null,yn=null,Wi=null}}}let s=new i,l=new o,c=new a,u={},h={},f=new WeakMap,p=[],d=null,g=!1,_=null,y=null,x=null,b=null,S=null,C=null,P=null,k=!1,O=null,D=null,B=null,I=null,L=null,R=e.getParameter(35661),F=!1,z=0,U=e.getParameter(7938);U.indexOf("WebGL")!==-1?(z=parseFloat(/^WebGL (\d)/.exec(U)[1]),F=z>=1):U.indexOf("OpenGL ES")!==-1&&(z=parseFloat(/^OpenGL ES (\d)/.exec(U)[1]),F=z>=2);let W=null,Z={},rt=e.getParameter(3088),ot=e.getParameter(2978),st=new en().fromArray(rt),St=new en().fromArray(ot);function bt(at,se,Qt){let Ce=new Uint8Array(4),Pt=e.createTexture();e.bindTexture(at,Pt),e.texParameteri(at,10241,9728),e.texParameteri(at,10240,9728);for(let Nt=0;Nt<Qt;Nt++)e.texImage2D(se+Nt,0,6408,1,1,0,6408,5121,Ce);return Pt}let Mt={};Mt[3553]=bt(3553,3553,1),Mt[34067]=bt(34067,34069,6),s.setClear(0,0,0,1),l.setClear(1),c.setClear(0),lt(2929),l.setFunc(iU),ht(!1),wt(Sut),lt(2884),q($d);function lt(at){u[at]!==!0&&(e.enable(at),u[at]=!0)}function Kt(at){u[at]!==!1&&(e.disable(at),u[at]=!1)}function _t(at,se){return h[at]!==se?(e.bindFramebuffer(at,se),h[at]=se,n&&(at===36009&&(h[36160]=se),at===36160&&(h[36009]=se)),!0):!1}function ct(at,se){let Qt=p,Ce=!1;if(at)if(Qt=f.get(se),Qt===void 0&&(Qt=[],f.set(se,Qt)),at.isWebGLMultipleRenderTargets){let Pt=at.texture;if(Qt.length!==Pt.length||Qt[0]!==36064){for(let Nt=0,ze=Pt.length;Nt<ze;Nt++)Qt[Nt]=36064+Nt;Qt.length=Pt.length,Ce=!0}}else Qt[0]!==36064&&(Qt[0]=36064,Ce=!0);else Qt[0]!==1029&&(Qt[0]=1029,Ce=!0);Ce&&(r.isWebGL2?e.drawBuffers(Qt):t.get("WEBGL_draw_buffers").drawBuffersWEBGL(Qt))}function X(at){return d!==at?(e.useProgram(at),d=at,!0):!1}let et={[M1]:32774,[Ghe]:32778,[Whe]:32779};if(n)et[Cut]=32775,et[Aut]=32776;else{let at=t.get("EXT_blend_minmax");at!==null&&(et[Cut]=at.MIN_EXT,et[Aut]=at.MAX_EXT)}let dt={[Yhe]:0,[jhe]:1,[Xhe]:768,[Pht]:770,[tfe]:776,[Jhe]:774,[Khe]:772,[$he]:769,[Iht]:771,[Qhe]:775,[Zhe]:773};function q(at,se,Qt,Ce,Pt,Nt,ze,yn){if(at===$d){g===!0&&(Kt(3042),g=!1);return}if(g===!1&&(lt(3042),g=!0),at!==qhe){if(at!==_||yn!==k){if((y!==M1||S!==M1)&&(e.blendEquation(32774),y=M1,S=M1),yn)switch(at){case V3:e.blendFuncSeparate(1,771,1,771);break;case Mut:e.blendFunc(1,1);break;case Eut:e.blendFuncSeparate(0,769,0,1);break;case Tut:e.blendFuncSeparate(0,768,0,770);break;default:console.error("THREE.WebGLState: Invalid blending: ",at);break}else switch(at){case V3:e.blendFuncSeparate(770,771,1,771);break;case Mut:e.blendFunc(770,1);break;case Eut:e.blendFuncSeparate(0,769,0,1);break;case Tut:e.blendFunc(0,768);break;default:console.error("THREE.WebGLState: Invalid blending: ",at);break}x=null,b=null,C=null,P=null,_=at,k=yn}return}Pt=Pt||se,Nt=Nt||Qt,ze=ze||Ce,(se!==y||Pt!==S)&&(e.blendEquationSeparate(et[se],et[Pt]),y=se,S=Pt),(Qt!==x||Ce!==b||Nt!==C||ze!==P)&&(e.blendFuncSeparate(dt[Qt],dt[Ce],dt[Nt],dt[ze]),x=Qt,b=Ce,C=Nt,P=ze),_=at,k=null}function pt(at,se){at.side===L1?Kt(2884):lt(2884);let Qt=at.side===Ii;se&&(Qt=!Qt),ht(Qt),at.blending===V3&&at.transparent===!1?q($d):q(at.blending,at.blendEquation,at.blendSrc,at.blendDst,at.blendEquationAlpha,at.blendSrcAlpha,at.blendDstAlpha,at.premultipliedAlpha),l.setFunc(at.depthFunc),l.setTest(at.depthTest),l.setMask(at.depthWrite),s.setMask(at.colorWrite);let Ce=at.stencilWrite;c.setTest(Ce),Ce&&(c.setMask(at.stencilWriteMask),c.setFunc(at.stencilFunc,at.stencilRef,at.stencilFuncMask),c.setOp(at.stencilFail,at.stencilZFail,at.stencilZPass)),ie(at.polygonOffset,at.polygonOffsetFactor,at.polygonOffsetUnits),at.alphaToCoverage===!0?lt(32926):Kt(32926)}function ht(at){O!==at&&(at?e.frontFace(2304):e.frontFace(2305),O=at)}function wt(at){at!==Hhe?(lt(2884),at!==D&&(at===Sut?e.cullFace(1029):at===Vhe?e.cullFace(1028):e.cullFace(1032))):Kt(2884),D=at}function kt(at){at!==B&&(F&&e.lineWidth(at),B=at)}function ie(at,se,Qt){at?(lt(32823),(I!==se||L!==Qt)&&(e.polygonOffset(se,Qt),I=se,L=Qt)):Kt(32823)}function ee(at){at?lt(3089):Kt(3089)}function Le(at){at===void 0&&(at=33984+R-1),W!==at&&(e.activeTexture(at),W=at)}function ar(at,se){W===null&&Le();let Qt=Z[W];Qt===void 0&&(Qt={type:void 0,texture:void 0},Z[W]=Qt),(Qt.type!==at||Qt.texture!==se)&&(e.bindTexture(at,se||Mt[at]),Qt.type=at,Qt.texture=se)}function fr(){let at=Z[W];at!==void 0&&at.type!==void 0&&(e.bindTexture(at.type,null),at.type=void 0,at.texture=void 0)}function tt(){try{e.compressedTexImage2D.apply(e,arguments)}catch(at){console.error("THREE.WebGLState:",at)}}function $(){try{e.texSubImage2D.apply(e,arguments)}catch(at){console.error("THREE.WebGLState:",at)}}function It(){try{e.texSubImage3D.apply(e,arguments)}catch(at){console.error("THREE.WebGLState:",at)}}function $t(){try{e.compressedTexSubImage2D.apply(e,arguments)}catch(at){console.error("THREE.WebGLState:",at)}}function he(){try{e.texStorage2D.apply(e,arguments)}catch(at){console.error("THREE.WebGLState:",at)}}function Tt(){try{e.texStorage3D.apply(e,arguments)}catch(at){console.error("THREE.WebGLState:",at)}}function be(){try{e.texImage2D.apply(e,arguments)}catch(at){console.error("THREE.WebGLState:",at)}}function nt(){try{e.texImage3D.apply(e,arguments)}catch(at){console.error("THREE.WebGLState:",at)}}function Ct(at){st.equals(at)===!1&&(e.scissor(at.x,at.y,at.z,at.w),st.copy(at))}function Wt(at){St.equals(at)===!1&&(e.viewport(at.x,at.y,at.z,at.w),St.copy(at))}function fe(){e.disable(3042),e.disable(2884),e.disable(2929),e.disable(32823),e.disable(3089),e.disable(2960),e.disable(32926),e.blendEquation(32774),e.blendFunc(1,0),e.blendFuncSeparate(1,0,1,0),e.colorMask(!0,!0,!0,!0),e.clearColor(0,0,0,0),e.depthMask(!0),e.depthFunc(513),e.clearDepth(1),e.stencilMask(4294967295),e.stencilFunc(519,0,4294967295),e.stencilOp(7680,7680,7680),e.clearStencil(0),e.cullFace(1029),e.frontFace(2305),e.polygonOffset(0,0),e.activeTexture(33984),e.bindFramebuffer(36160,null),n===!0&&(e.bindFramebuffer(36009,null),e.bindFramebuffer(36008,null)),e.useProgram(null),e.lineWidth(1),e.scissor(0,0,e.canvas.width,e.canvas.height),e.viewport(0,0,e.canvas.width,e.canvas.height),u={},W=null,Z={},h={},f=new WeakMap,p=[],d=null,g=!1,_=null,y=null,x=null,b=null,S=null,C=null,P=null,k=!1,O=null,D=null,B=null,I=null,L=null,st.set(0,0,e.canvas.width,e.canvas.height),St.set(0,0,e.canvas.width,e.canvas.height),s.reset(),l.reset(),c.reset()}return{buffers:{color:s,depth:l,stencil:c},enable:lt,disable:Kt,bindFramebuffer:_t,drawBuffers:ct,useProgram:X,setBlending:q,setMaterial:pt,setFlipSided:ht,setCullFace:wt,setLineWidth:kt,setPolygonOffset:ie,setScissorTest:ee,activeTexture:Le,bindTexture:ar,unbindTexture:fr,compressedTexImage2D:tt,texImage2D:be,texImage3D:nt,texStorage2D:he,texStorage3D:Tt,texSubImage2D:$,texSubImage3D:It,compressedTexSubImage2D:$t,scissor:Ct,viewport:Wt,reset:fe}}function Lgr(e,t,r,n,i,o,a){let s=i.isWebGL2,l=i.maxTextures,c=i.maxCubemapSize,u=i.maxTextureSize,h=i.maxSamples,p=t.has("WEBGL_multisampled_render_to_texture")?t.get("WEBGL_multisampled_render_to_texture"):void 0,d=new WeakMap,g,_=!1;try{_=typeof OffscreenCanvas!="undefined"&&new OffscreenCanvas(1,1).getContext("2d")!==null}catch(tt){}function y(tt,$){return _?new OffscreenCanvas(tt,$):t6("canvas")}function x(tt,$,It,$t){let he=1;if((tt.width>$t||tt.height>$t)&&(he=$t/Math.max(tt.width,tt.height)),he<1||$===!0)if(typeof HTMLImageElement!="undefined"&&tt instanceof HTMLImageElement||typeof HTMLCanvasElement!="undefined"&&tt instanceof HTMLCanvasElement||typeof ImageBitmap!="undefined"&&tt instanceof ImageBitmap){let Tt=$?Ffe:Math.floor,be=Tt(he*tt.width),nt=Tt(he*tt.height);g===void 0&&(g=y(be,nt));let Ct=It?y(be,nt):g;return Ct.width=be,Ct.height=nt,Ct.getContext("2d").drawImage(tt,0,0,be,nt),console.warn("THREE.WebGLRenderer: Texture has been resized from ("+tt.width+"x"+tt.height+") to ("+be+"x"+nt+")."),Ct}else return"data"in tt&&console.warn("THREE.WebGLRenderer: Image in DataTexture is too big ("+tt.width+"x"+tt.height+")."),tt;return tt}function b(tt){return Zut(tt.width)&&Zut(tt.height)}function S(tt){return s?!1:tt.wrapS!==Jo||tt.wrapT!==Jo||tt.minFilter!==Li&&tt.minFilter!==ii}function C(tt,$){return tt.generateMipmaps&&$&&tt.minFilter!==Li&&tt.minFilter!==ii}function P(tt){e.generateMipmap(tt)}function k(tt,$,It,$t,he=!1){if(s===!1)return $;if(tt!==null){if(e[tt]!==void 0)return e[tt];console.warn("THREE.WebGLRenderer: Attempt to use non-existing WebGL internal format '"+tt+"'")}let Tt=$;return $===6403&&(It===5126&&(Tt=33326),It===5131&&(Tt=33325),It===5121&&(Tt=33321)),$===33319&&(It===5126&&(Tt=33328),It===5131&&(Tt=33327),It===5121&&(Tt=33323)),$===6408&&(It===5126&&(Tt=34836),It===5131&&(Tt=34842),It===5121&&(Tt=$t===Wn&&he===!1?35907:32856),It===32819&&(Tt=32854),It===32820&&(Tt=32855)),(Tt===33325||Tt===33326||Tt===33327||Tt===33328||Tt===34842||Tt===34836)&&t.get("EXT_color_buffer_float"),Tt}function O(tt,$,It){return C(tt,It)===!0||tt.isFramebufferTexture&&tt.minFilter!==Li&&tt.minFilter!==ii?Math.log2(Math.max($.width,$.height))+1:tt.mipmaps!==void 0&&tt.mipmaps.length>0?tt.mipmaps.length:tt.isCompressedTexture&&Array.isArray(tt.image)?$.mipmaps.length:1}function D(tt){return tt===Li||tt===oU||tt===aU?9728:9729}function B(tt){let $=tt.target;$.removeEventListener("dispose",B),L($),$.isVideoTexture&&d.delete($),a.memory.textures--}function I(tt){let $=tt.target;$.removeEventListener("dispose",I),R($)}function L(tt){let $=n.get(tt);$.__webglInit!==void 0&&(e.deleteTexture($.__webglTexture),n.remove(tt))}function R(tt){let $=tt.texture,It=n.get(tt),$t=n.get($);if(!!tt){if($t.__webglTexture!==void 0&&(e.deleteTexture($t.__webglTexture),a.memory.textures--),tt.depthTexture&&tt.depthTexture.dispose(),tt.isWebGLCubeRenderTarget)for(let he=0;he<6;he++)e.deleteFramebuffer(It.__webglFramebuffer[he]),It.__webglDepthbuffer&&e.deleteRenderbuffer(It.__webglDepthbuffer[he]);else e.deleteFramebuffer(It.__webglFramebuffer),It.__webglDepthbuffer&&e.deleteRenderbuffer(It.__webglDepthbuffer),It.__webglMultisampledFramebuffer&&e.deleteFramebuffer(It.__webglMultisampledFramebuffer),It.__webglColorRenderbuffer&&e.deleteRenderbuffer(It.__webglColorRenderbuffer),It.__webglDepthRenderbuffer&&e.deleteRenderbuffer(It.__webglDepthRenderbuffer);if(tt.isWebGLMultipleRenderTargets)for(let he=0,Tt=$.length;he<Tt;he++){let be=n.get($[he]);be.__webglTexture&&(e.deleteTexture(be.__webglTexture),a.memory.textures--),n.remove($[he])}n.remove($),n.remove(tt)}}let F=0;function z(){F=0}function U(){let tt=F;return tt>=l&&console.warn("THREE.WebGLTextures: Trying to use "+tt+" texture units while this GPU supports only "+l),F+=1,tt}function W(tt,$){let It=n.get(tt);if(tt.isVideoTexture&&kt(tt),tt.version>0&&It.__version!==tt.version){let $t=tt.image;if($t===void 0)console.warn("THREE.WebGLRenderer: Texture marked for update but image is undefined");else if($t.complete===!1)console.warn("THREE.WebGLRenderer: Texture marked for update but image is incomplete");else{lt(It,tt,$);return}}r.activeTexture(33984+$),r.bindTexture(3553,It.__webglTexture)}function Z(tt,$){let It=n.get(tt);if(tt.version>0&&It.__version!==tt.version){lt(It,tt,$);return}r.activeTexture(33984+$),r.bindTexture(35866,It.__webglTexture)}function rt(tt,$){let It=n.get(tt);if(tt.version>0&&It.__version!==tt.version){lt(It,tt,$);return}r.activeTexture(33984+$),r.bindTexture(32879,It.__webglTexture)}function ot(tt,$){let It=n.get(tt);if(tt.version>0&&It.__version!==tt.version){Kt(It,tt,$);return}r.activeTexture(33984+$),r.bindTexture(34067,It.__webglTexture)}let st={[XP]:10497,[Jo]:33071,[$P]:33648},St={[Li]:9728,[oU]:9984,[aU]:9986,[ii]:9729,[Lht]:9985,[ox]:9987};function bt(tt,$,It){if(It?(e.texParameteri(tt,10242,st[$.wrapS]),e.texParameteri(tt,10243,st[$.wrapT]),(tt===32879||tt===35866)&&e.texParameteri(tt,32882,st[$.wrapR]),e.texParameteri(tt,10240,St[$.magFilter]),e.texParameteri(tt,10241,St[$.minFilter])):(e.texParameteri(tt,10242,33071),e.texParameteri(tt,10243,33071),(tt===32879||tt===35866)&&e.texParameteri(tt,32882,33071),($.wrapS!==Jo||$.wrapT!==Jo)&&console.warn("THREE.WebGLRenderer: Texture is not power of two. Texture.wrapS and Texture.wrapT should be set to THREE.ClampToEdgeWrapping."),e.texParameteri(tt,10240,D($.magFilter)),e.texParameteri(tt,10241,D($.minFilter)),$.minFilter!==Li&&$.minFilter!==ii&&console.warn("THREE.WebGLRenderer: Texture is not power of two. Texture.minFilter should be set to THREE.NearestFilter or THREE.LinearFilter.")),t.has("EXT_texture_filter_anisotropic")===!0){let $t=t.get("EXT_texture_filter_anisotropic");if($.type===jd&&t.has("OES_texture_float_linear")===!1||s===!1&&$.type===C1&&t.has("OES_texture_half_float_linear")===!1)return;($.anisotropy>1||n.get($).__currentAnisotropy)&&(e.texParameterf(tt,$t.TEXTURE_MAX_ANISOTROPY_EXT,Math.min($.anisotropy,i.getMaxAnisotropy())),n.get($).__currentAnisotropy=$.anisotropy)}}function Mt(tt,$){tt.__webglInit===void 0&&(tt.__webglInit=!0,$.addEventListener("dispose",B),tt.__webglTexture=e.createTexture(),a.memory.textures++)}function lt(tt,$,It){let $t=3553;$.isDataTexture2DArray&&($t=35866),$.isDataTexture3D&&($t=32879),Mt(tt,$),r.activeTexture(33984+It),r.bindTexture($t,tt.__webglTexture),e.pixelStorei(37440,$.flipY),e.pixelStorei(37441,$.premultiplyAlpha),e.pixelStorei(3317,$.unpackAlignment),e.pixelStorei(37443,0);let he=S($)&&b($.image)===!1,Tt=x($.image,he,!1,u);Tt=ie($,Tt);let be=b(Tt)||s,nt=o.convert($.format,$.encoding),Ct=o.convert($.type),Wt=k($.internalFormat,nt,Ct,$.encoding,$.isVideoTexture);bt($t,$,be);let fe,at=$.mipmaps,se=s&&$.isVideoTexture!==!0,Qt=tt.__version===void 0,Ce=O($,Tt,be);if($.isDepthTexture)Wt=6402,s?$.type===jd?Wt=36012:$.type===VP?Wt=33190:$.type===A1?Wt=35056:Wt=33189:$.type===jd&&console.error("WebGLRenderer: Floating point depth texture requires WebGL2."),$.format===z0&&Wt===6402&&$.type!==G3&&$.type!==VP&&(console.warn("THREE.WebGLRenderer: Use UnsignedShortType or UnsignedIntType for DepthFormat DepthTexture."),$.type=G3,Ct=o.convert($.type)),$.format===k1&&Wt===6402&&(Wt=34041,$.type!==A1&&(console.warn("THREE.WebGLRenderer: Use UnsignedInt248Type for DepthStencilFormat DepthTexture."),$.type=A1,Ct=o.convert($.type))),se&&Qt?r.texStorage2D(3553,1,Wt,Tt.width,Tt.height):r.texImage2D(3553,0,Wt,Tt.width,Tt.height,0,nt,Ct,null);else if($.isDataTexture)if(at.length>0&&be){se&&Qt&&r.texStorage2D(3553,Ce,Wt,at[0].width,at[0].height);for(let Pt=0,Nt=at.length;Pt<Nt;Pt++)fe=at[Pt],se?r.texSubImage2D(3553,0,0,0,fe.width,fe.height,nt,Ct,fe.data):r.texImage2D(3553,Pt,Wt,fe.width,fe.height,0,nt,Ct,fe.data);$.generateMipmaps=!1}else se?(Qt&&r.texStorage2D(3553,Ce,Wt,Tt.width,Tt.height),r.texSubImage2D(3553,0,0,0,Tt.width,Tt.height,nt,Ct,Tt.data)):r.texImage2D(3553,0,Wt,Tt.width,Tt.height,0,nt,Ct,Tt.data);else if($.isCompressedTexture){se&&Qt&&r.texStorage2D(3553,Ce,Wt,at[0].width,at[0].height);for(let Pt=0,Nt=at.length;Pt<Nt;Pt++)fe=at[Pt],$.format!==Qo?nt!==null?se?r.compressedTexSubImage2D(3553,Pt,0,0,fe.width,fe.height,nt,fe.data):r.compressedTexImage2D(3553,Pt,Wt,fe.width,fe.height,0,fe.data):console.warn("THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .uploadTexture()"):se?r.texSubImage2D(3553,Pt,0,0,fe.width,fe.height,nt,Ct,fe.data):r.texImage2D(3553,Pt,Wt,fe.width,fe.height,0,nt,Ct,fe.data)}else if($.isDataTexture2DArray)se?(Qt&&r.texStorage3D(35866,Ce,Wt,Tt.width,Tt.height,Tt.depth),r.texSubImage3D(35866,0,0,0,0,Tt.width,Tt.height,Tt.depth,nt,Ct,Tt.data)):r.texImage3D(35866,0,Wt,Tt.width,Tt.height,Tt.depth,0,nt,Ct,Tt.data);else if($.isDataTexture3D)se?(Qt&&r.texStorage3D(32879,Ce,Wt,Tt.width,Tt.height,Tt.depth),r.texSubImage3D(32879,0,0,0,0,Tt.width,Tt.height,Tt.depth,nt,Ct,Tt.data)):r.texImage3D(32879,0,Wt,Tt.width,Tt.height,Tt.depth,0,nt,Ct,Tt.data);else if($.isFramebufferTexture)se&&Qt?r.texStorage2D(3553,Ce,Wt,Tt.width,Tt.height):r.texImage2D(3553,0,Wt,Tt.width,Tt.height,0,nt,Ct,null);else if(at.length>0&&be){se&&Qt&&r.texStorage2D(3553,Ce,Wt,at[0].width,at[0].height);for(let Pt=0,Nt=at.length;Pt<Nt;Pt++)fe=at[Pt],se?r.texSubImage2D(3553,Pt,0,0,nt,Ct,fe):r.texImage2D(3553,Pt,Wt,nt,Ct,fe);$.generateMipmaps=!1}else se?(Qt&&r.texStorage2D(3553,Ce,Wt,Tt.width,Tt.height),r.texSubImage2D(3553,0,0,0,nt,Ct,Tt)):r.texImage2D(3553,0,Wt,nt,Ct,Tt);C($,be)&&P($t),tt.__version=$.version,$.onUpdate&&$.onUpdate($)}function Kt(tt,$,It){if($.image.length!==6)return;Mt(tt,$),r.activeTexture(33984+It),r.bindTexture(34067,tt.__webglTexture),e.pixelStorei(37440,$.flipY),e.pixelStorei(37441,$.premultiplyAlpha),e.pixelStorei(3317,$.unpackAlignment),e.pixelStorei(37443,0);let $t=$&&($.isCompressedTexture||$.image[0].isCompressedTexture),he=$.image[0]&&$.image[0].isDataTexture,Tt=[];for(let Pt=0;Pt<6;Pt++)!$t&&!he?Tt[Pt]=x($.image[Pt],!1,!0,c):Tt[Pt]=he?$.image[Pt].image:$.image[Pt],Tt[Pt]=ie($,Tt[Pt]);let be=Tt[0],nt=b(be)||s,Ct=o.convert($.format,$.encoding),Wt=o.convert($.type),fe=k($.internalFormat,Ct,Wt,$.encoding),at=s&&$.isVideoTexture!==!0,se=tt.__version===void 0,Qt=O($,be,nt);bt(34067,$,nt);let Ce;if($t){at&&se&&r.texStorage2D(34067,Qt,fe,be.width,be.height);for(let Pt=0;Pt<6;Pt++){Ce=Tt[Pt].mipmaps;for(let Nt=0;Nt<Ce.length;Nt++){let ze=Ce[Nt];$.format!==Qo?Ct!==null?at?r.compressedTexSubImage2D(34069+Pt,Nt,0,0,ze.width,ze.height,Ct,ze.data):r.compressedTexImage2D(34069+Pt,Nt,fe,ze.width,ze.height,0,ze.data):console.warn("THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .setTextureCube()"):at?r.texSubImage2D(34069+Pt,Nt,0,0,ze.width,ze.height,Ct,Wt,ze.data):r.texImage2D(34069+Pt,Nt,fe,ze.width,ze.height,0,Ct,Wt,ze.data)}}}else{Ce=$.mipmaps,at&&se&&(Ce.length>0&&Qt++,r.texStorage2D(34067,Qt,fe,Tt[0].width,Tt[0].height));for(let Pt=0;Pt<6;Pt++)if(he){at?r.texSubImage2D(34069+Pt,0,0,0,Tt[Pt].width,Tt[Pt].height,Ct,Wt,Tt[Pt].data):r.texImage2D(34069+Pt,0,fe,Tt[Pt].width,Tt[Pt].height,0,Ct,Wt,Tt[Pt].data);for(let Nt=0;Nt<Ce.length;Nt++){let yn=Ce[Nt].image[Pt].image;at?r.texSubImage2D(34069+Pt,Nt+1,0,0,yn.width,yn.height,Ct,Wt,yn.data):r.texImage2D(34069+Pt,Nt+1,fe,yn.width,yn.height,0,Ct,Wt,yn.data)}}else{at?r.texSubImage2D(34069+Pt,0,0,0,Ct,Wt,Tt[Pt]):r.texImage2D(34069+Pt,0,fe,Ct,Wt,Tt[Pt]);for(let Nt=0;Nt<Ce.length;Nt++){let ze=Ce[Nt];at?r.texSubImage2D(34069+Pt,Nt+1,0,0,Ct,Wt,ze.image[Pt]):r.texImage2D(34069+Pt,Nt+1,fe,Ct,Wt,ze.image[Pt])}}}C($,nt)&&P(34067),tt.__version=$.version,$.onUpdate&&$.onUpdate($)}function _t(tt,$,It,$t,he){let Tt=o.convert(It.format,It.encoding),be=o.convert(It.type),nt=k(It.internalFormat,Tt,be,It.encoding);n.get($).__hasExternalTextures||(he===32879||he===35866?r.texImage3D(he,0,nt,$.width,$.height,$.depth,0,Tt,be,null):r.texImage2D(he,0,nt,$.width,$.height,0,Tt,be,null)),r.bindFramebuffer(36160,tt),$.useRenderToTexture?p.framebufferTexture2DMultisampleEXT(36160,$t,he,n.get(It).__webglTexture,0,wt($)):e.framebufferTexture2D(36160,$t,he,n.get(It).__webglTexture,0),r.bindFramebuffer(36160,null)}function ct(tt,$,It){if(e.bindRenderbuffer(36161,tt),$.depthBuffer&&!$.stencilBuffer){let $t=33189;if(It||$.useRenderToTexture){let he=$.depthTexture;he&&he.isDepthTexture&&(he.type===jd?$t=36012:he.type===VP&&($t=33190));let Tt=wt($);$.useRenderToTexture?p.renderbufferStorageMultisampleEXT(36161,Tt,$t,$.width,$.height):e.renderbufferStorageMultisample(36161,Tt,$t,$.width,$.height)}else e.renderbufferStorage(36161,$t,$.width,$.height);e.framebufferRenderbuffer(36160,36096,36161,tt)}else if($.depthBuffer&&$.stencilBuffer){let $t=wt($);It&&$.useRenderbuffer?e.renderbufferStorageMultisample(36161,$t,35056,$.width,$.height):$.useRenderToTexture?p.renderbufferStorageMultisampleEXT(36161,$t,35056,$.width,$.height):e.renderbufferStorage(36161,34041,$.width,$.height),e.framebufferRenderbuffer(36160,33306,36161,tt)}else{let $t=$.isWebGLMultipleRenderTargets===!0?$.texture[0]:$.texture,he=o.convert($t.format,$t.encoding),Tt=o.convert($t.type),be=k($t.internalFormat,he,Tt,$t.encoding),nt=wt($);It&&$.useRenderbuffer?e.renderbufferStorageMultisample(36161,nt,be,$.width,$.height):$.useRenderToTexture?p.renderbufferStorageMultisampleEXT(36161,nt,be,$.width,$.height):e.renderbufferStorage(36161,be,$.width,$.height)}e.bindRenderbuffer(36161,null)}function X(tt,$){if($&&$.isWebGLCubeRenderTarget)throw new Error("Depth Texture with cube render targets is not supported");if(r.bindFramebuffer(36160,tt),!($.depthTexture&&$.depthTexture.isDepthTexture))throw new Error("renderTarget.depthTexture must be an instance of THREE.DepthTexture");(!n.get($.depthTexture).__webglTexture||$.depthTexture.image.width!==$.width||$.depthTexture.image.height!==$.height)&&($.depthTexture.image.width=$.width,$.depthTexture.image.height=$.height,$.depthTexture.needsUpdate=!0),W($.depthTexture,0);let $t=n.get($.depthTexture).__webglTexture,he=wt($);if($.depthTexture.format===z0)$.useRenderToTexture?p.framebufferTexture2DMultisampleEXT(36160,36096,3553,$t,0,he):e.framebufferTexture2D(36160,36096,3553,$t,0);else if($.depthTexture.format===k1)$.useRenderToTexture?p.framebufferTexture2DMultisampleEXT(36160,33306,3553,$t,0,he):e.framebufferTexture2D(36160,33306,3553,$t,0);else throw new Error("Unknown depthTexture format")}function et(tt){let $=n.get(tt),It=tt.isWebGLCubeRenderTarget===!0;if(tt.depthTexture&&!$.__autoAllocateDepthBuffer){if(It)throw new Error("target.depthTexture not supported in Cube render targets");X($.__webglFramebuffer,tt)}else if(It){$.__webglDepthbuffer=[];for(let $t=0;$t<6;$t++)r.bindFramebuffer(36160,$.__webglFramebuffer[$t]),$.__webglDepthbuffer[$t]=e.createRenderbuffer(),ct($.__webglDepthbuffer[$t],tt,!1)}else r.bindFramebuffer(36160,$.__webglFramebuffer),$.__webglDepthbuffer=e.createRenderbuffer(),ct($.__webglDepthbuffer,tt,!1);r.bindFramebuffer(36160,null)}function dt(tt,$,It){let $t=n.get(tt);$!==void 0&&_t($t.__webglFramebuffer,tt,tt.texture,36064,3553),It!==void 0&&et(tt)}function q(tt){let $=tt.texture,It=n.get(tt),$t=n.get($);tt.addEventListener("dispose",I),tt.isWebGLMultipleRenderTargets!==!0&&($t.__webglTexture===void 0&&($t.__webglTexture=e.createTexture()),$t.__version=$.version,a.memory.textures++);let he=tt.isWebGLCubeRenderTarget===!0,Tt=tt.isWebGLMultipleRenderTargets===!0,be=$.isDataTexture3D||$.isDataTexture2DArray,nt=b(tt)||s;if(he){It.__webglFramebuffer=[];for(let Ct=0;Ct<6;Ct++)It.__webglFramebuffer[Ct]=e.createFramebuffer()}else if(It.__webglFramebuffer=e.createFramebuffer(),Tt)if(i.drawBuffers){let Ct=tt.texture;for(let Wt=0,fe=Ct.length;Wt<fe;Wt++){let at=n.get(Ct[Wt]);at.__webglTexture===void 0&&(at.__webglTexture=e.createTexture(),a.memory.textures++)}}else console.warn("THREE.WebGLRenderer: WebGLMultipleRenderTargets can only be used with WebGL2 or WEBGL_draw_buffers extension.");else if(tt.useRenderbuffer)if(s){It.__webglMultisampledFramebuffer=e.createFramebuffer(),It.__webglColorRenderbuffer=e.createRenderbuffer(),e.bindRenderbuffer(36161,It.__webglColorRenderbuffer);let Ct=o.convert($.format,$.encoding),Wt=o.convert($.type),fe=k($.internalFormat,Ct,Wt,$.encoding),at=wt(tt);e.renderbufferStorageMultisample(36161,at,fe,tt.width,tt.height),r.bindFramebuffer(36160,It.__webglMultisampledFramebuffer),e.framebufferRenderbuffer(36160,36064,36161,It.__webglColorRenderbuffer),e.bindRenderbuffer(36161,null),tt.depthBuffer&&(It.__webglDepthRenderbuffer=e.createRenderbuffer(),ct(It.__webglDepthRenderbuffer,tt,!0)),r.bindFramebuffer(36160,null)}else console.warn("THREE.WebGLRenderer: WebGLMultisampleRenderTarget can only be used with WebGL2.");if(he){r.bindTexture(34067,$t.__webglTexture),bt(34067,$,nt);for(let Ct=0;Ct<6;Ct++)_t(It.__webglFramebuffer[Ct],tt,$,36064,34069+Ct);C($,nt)&&P(34067),r.unbindTexture()}else if(Tt){let Ct=tt.texture;for(let Wt=0,fe=Ct.length;Wt<fe;Wt++){let at=Ct[Wt],se=n.get(at);r.bindTexture(3553,se.__webglTexture),bt(3553,at,nt),_t(It.__webglFramebuffer,tt,at,36064+Wt,3553),C(at,nt)&&P(3553)}r.unbindTexture()}else{let Ct=3553;be&&(s?Ct=$.isDataTexture3D?32879:35866:console.warn("THREE.DataTexture3D and THREE.DataTexture2DArray only supported with WebGL2.")),r.bindTexture(Ct,$t.__webglTexture),bt(Ct,$,nt),_t(It.__webglFramebuffer,tt,$,36064,Ct),C($,nt)&&P(Ct),r.unbindTexture()}tt.depthBuffer&&et(tt)}function pt(tt){let $=b(tt)||s,It=tt.isWebGLMultipleRenderTargets===!0?tt.texture:[tt.texture];for(let $t=0,he=It.length;$t<he;$t++){let Tt=It[$t];if(C(Tt,$)){let be=tt.isWebGLCubeRenderTarget?34067:3553,nt=n.get(Tt).__webglTexture;r.bindTexture(be,nt),P(be),r.unbindTexture()}}}function ht(tt){if(tt.useRenderbuffer)if(s){let $=tt.width,It=tt.height,$t=16384,he=[36064],Tt=tt.stencilBuffer?33306:36096;tt.depthBuffer&&he.push(Tt),tt.ignoreDepthForMultisampleCopy||(tt.depthBuffer&&($t|=256),tt.stencilBuffer&&($t|=1024));let be=n.get(tt);r.bindFramebuffer(36008,be.__webglMultisampledFramebuffer),r.bindFramebuffer(36009,be.__webglFramebuffer),tt.ignoreDepthForMultisampleCopy&&(e.invalidateFramebuffer(36008,[Tt]),e.invalidateFramebuffer(36009,[Tt])),e.blitFramebuffer(0,0,$,It,0,0,$,It,$t,9728),e.invalidateFramebuffer(36008,he),r.bindFramebuffer(36008,null),r.bindFramebuffer(36009,be.__webglMultisampledFramebuffer)}else console.warn("THREE.WebGLRenderer: WebGLMultisampleRenderTarget can only be used with WebGL2.")}function wt(tt){return s&&(tt.useRenderbuffer||tt.useRenderToTexture)?Math.min(h,tt.samples):0}function kt(tt){let $=a.render.frame;d.get(tt)!==$&&(d.set(tt,$),tt.update())}function ie(tt,$){let It=tt.encoding,$t=tt.format,he=tt.type;return tt.isCompressedTexture===!0||tt.isVideoTexture===!0||tt.format===sU||It!==Qd&&(It===Wn?s===!1?t.has("EXT_sRGB")===!0&&$t===Qo?(tt.format=sU,tt.minFilter=ii,tt.generateMipmaps=!1):$=Kf.sRGBToLinear($):($t!==Qo||he!==Zd)&&console.warn("THREE.WebGLTextures: sRGB encoded textures have to use RGBAFormat and UnsignedByteType."):console.error("THREE.WebGLTextures: Unsupported texture encoding:",It)),$}let ee=!1,Le=!1;function ar(tt,$){tt&&tt.isWebGLRenderTarget&&(ee===!1&&(console.warn("THREE.WebGLTextures.safeSetTexture2D: don't use render targets as textures. Use their .texture property instead."),ee=!0),tt=tt.texture),W(tt,$)}function fr(tt,$){tt&&tt.isWebGLCubeRenderTarget&&(Le===!1&&(console.warn("THREE.WebGLTextures.safeSetTextureCube: don't use cube render targets as textures. Use their .texture property instead."),Le=!0),tt=tt.texture),ot(tt,$)}this.allocateTextureUnit=U,this.resetTextureUnits=z,this.setTexture2D=W,this.setTexture2DArray=Z,this.setTexture3D=rt,this.setTextureCube=ot,this.rebindTextures=dt,this.setupRenderTarget=q,this.updateRenderTargetMipmap=pt,this.updateMultisampleRenderTarget=ht,this.setupDepthRenderbuffer=et,this.setupFrameBufferTexture=_t,this.safeSetTexture2D=ar,this.safeSetTextureCube=fr}function Qfe(e,t,r){let n=r.isWebGL2;function i(o,a=null){let s;if(o===Zd)return 5121;if(o===yfe)return 32819;if(o===vfe)return 32820;if(o===mfe)return 5120;if(o===gfe)return 5122;if(o===G3)return 5123;if(o===_fe)return 5124;if(o===VP)return 5125;if(o===jd)return 5126;if(o===C1)return n?5131:(s=t.get("OES_texture_half_float"),s!==null?s.HALF_FLOAT_OES:null);if(o===xfe)return 6406;if(o===Qo)return 6408;if(o===bfe)return 6409;if(o===wfe)return 6410;if(o===z0)return 6402;if(o===k1)return 34041;if(o===Sfe)return 6403;if(o===sU)return s=t.get("EXT_sRGB"),s!==null?s.SRGB_ALPHA_EXT:null;if(o===Mfe)return 36244;if(o===Efe)return 33319;if(o===Tfe)return 33320;if(o===Cfe)return 36249;if(o===JV||o===QV||o===tU||o===eU)if(a===Wn)if(s=t.get("WEBGL_compressed_texture_s3tc_srgb"),s!==null){if(o===JV)return s.COMPRESSED_SRGB_S3TC_DXT1_EXT;if(o===QV)return s.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT;if(o===tU)return s.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT;if(o===eU)return s.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT}else return null;else if(s=t.get("WEBGL_compressed_texture_s3tc"),s!==null){if(o===JV)return s.COMPRESSED_RGB_S3TC_DXT1_EXT;if(o===QV)return s.COMPRESSED_RGBA_S3TC_DXT1_EXT;if(o===tU)return s.COMPRESSED_RGBA_S3TC_DXT3_EXT;if(o===eU)return s.COMPRESSED_RGBA_S3TC_DXT5_EXT}else return null;if(o===Put||o===Iut||o===Lut||o===kut)if(s=t.get("WEBGL_compressed_texture_pvrtc"),s!==null){if(o===Put)return s.COMPRESSED_RGB_PVRTC_4BPPV1_IMG;if(o===Iut)return s.COMPRESSED_RGB_PVRTC_2BPPV1_IMG;if(o===Lut)return s.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG;if(o===kut)return s.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG}else return null;if(o===Afe)return s=t.get("WEBGL_compressed_texture_etc1"),s!==null?s.COMPRESSED_RGB_ETC1_WEBGL:null;if(o===Rut||o===Nut)if(s=t.get("WEBGL_compressed_texture_etc"),s!==null){if(o===Rut)return a===Wn?s.COMPRESSED_SRGB8_ETC2:s.COMPRESSED_RGB8_ETC2;if(o===Nut)return a===Wn?s.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:s.COMPRESSED_RGBA8_ETC2_EAC}else return null;if(o===Dut||o===Out||o===zut||o===Fut||o===But||o===Hut||o===Vut||o===Uut||o===qut||o===Gut||o===Wut||o===Yut||o===jut||o===Xut)if(s=t.get("WEBGL_compressed_texture_astc"),s!==null){if(o===Dut)return a===Wn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR:s.COMPRESSED_RGBA_ASTC_4x4_KHR;if(o===Out)return a===Wn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR:s.COMPRESSED_RGBA_ASTC_5x4_KHR;if(o===zut)return a===Wn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR:s.COMPRESSED_RGBA_ASTC_5x5_KHR;if(o===Fut)return a===Wn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR:s.COMPRESSED_RGBA_ASTC_6x5_KHR;if(o===But)return a===Wn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR:s.COMPRESSED_RGBA_ASTC_6x6_KHR;if(o===Hut)return a===Wn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR:s.COMPRESSED_RGBA_ASTC_8x5_KHR;if(o===Vut)return a===Wn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR:s.COMPRESSED_RGBA_ASTC_8x6_KHR;if(o===Uut)return a===Wn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR:s.COMPRESSED_RGBA_ASTC_8x8_KHR;if(o===qut)return a===Wn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR:s.COMPRESSED_RGBA_ASTC_10x5_KHR;if(o===Gut)return a===Wn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR:s.COMPRESSED_RGBA_ASTC_10x6_KHR;if(o===Wut)return a===Wn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR:s.COMPRESSED_RGBA_ASTC_10x8_KHR;if(o===Yut)return a===Wn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR:s.COMPRESSED_RGBA_ASTC_10x10_KHR;if(o===jut)return a===Wn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR:s.COMPRESSED_RGBA_ASTC_12x10_KHR;if(o===Xut)return a===Wn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR:s.COMPRESSED_RGBA_ASTC_12x12_KHR}else return null;if(o===$ut)if(s=t.get("EXT_texture_compression_bptc"),s!==null){if(o===$ut)return a===Wn?s.COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT:s.COMPRESSED_RGBA_BPTC_UNORM_EXT}else return null;if(o===A1)return n?34042:(s=t.get("WEBGL_depth_texture"),s!==null?s.UNSIGNED_INT_24_8_WEBGL:null)}return{convert:i}}var n6=class extends Ui{constructor(t=[]){super(),this.cameras=t}};n6.prototype.isArrayCamera=!0;var Xd=class extends or{constructor(){super(),this.type="Group"}};Xd.prototype.isGroup=!0;var kgr={type:"move"},qP=class{constructor(){this._targetRay=null,this._grip=null,this._hand=null}getHandSpace(){return this._hand===null&&(this._hand=new Xd,this._hand.matrixAutoUpdate=!1,this._hand.visible=!1,this._hand.joints={},this._hand.inputState={pinching:!1}),this._hand}getTargetRaySpace(){return this._targetRay===null&&(this._targetRay=new Xd,this._targetRay.matrixAutoUpdate=!1,this._targetRay.visible=!1,this._targetRay.hasLinearVelocity=!1,this._targetRay.linearVelocity=new j,this._targetRay.hasAngularVelocity=!1,this._targetRay.angularVelocity=new j),this._targetRay}getGripSpace(){return this._grip===null&&(this._grip=new Xd,this._grip.matrixAutoUpdate=!1,this._grip.visible=!1,this._grip.hasLinearVelocity=!1,this._grip.linearVelocity=new j,this._grip.hasAngularVelocity=!1,this._grip.angularVelocity=new j),this._grip}dispatchEvent(t){return this._targetRay!==null&&this._targetRay.dispatchEvent(t),this._grip!==null&&this._grip.dispatchEvent(t),this._hand!==null&&this._hand.dispatchEvent(t),this}disconnect(t){return this.dispatchEvent({type:"disconnected",data:t}),this._targetRay!==null&&(this._targetRay.visible=!1),this._grip!==null&&(this._grip.visible=!1),this._hand!==null&&(this._hand.visible=!1),this}update(t,r,n){let i=null,o=null,a=null,s=this._targetRay,l=this._grip,c=this._hand;if(t&&r.session.visibilityState!=="visible-blurred")if(s!==null&&(i=r.getPose(t.targetRaySpace,n),i!==null&&(s.matrix.fromArray(i.transform.matrix),s.matrix.decompose(s.position,s.rotation,s.scale),i.linearVelocity?(s.hasLinearVelocity=!0,s.linearVelocity.copy(i.linearVelocity)):s.hasLinearVelocity=!1,i.angularVelocity?(s.hasAngularVelocity=!0,s.angularVelocity.copy(i.angularVelocity)):s.hasAngularVelocity=!1,this.dispatchEvent(kgr))),c&&t.hand){a=!0;for(let g of t.hand.values()){let _=r.getJointPose(g,n);if(c.joints[g.jointName]===void 0){let x=new Xd;x.matrixAutoUpdate=!1,x.visible=!1,c.joints[g.jointName]=x,c.add(x)}let y=c.joints[g.jointName];_!==null&&(y.matrix.fromArray(_.transform.matrix),y.matrix.decompose(y.position,y.rotation,y.scale),y.jointRadius=_.radius),y.visible=_!==null}let u=c.joints["index-finger-tip"],h=c.joints["thumb-tip"],f=u.position.distanceTo(h.position),p=.02,d=.005;c.inputState.pinching&&f>p+d?(c.inputState.pinching=!1,this.dispatchEvent({type:"pinchend",handedness:t.handedness,target:this})):!c.inputState.pinching&&f<=p-d&&(c.inputState.pinching=!0,this.dispatchEvent({type:"pinchstart",handedness:t.handedness,target:this}))}else l!==null&&t.gripSpace&&(o=r.getPose(t.gripSpace,n),o!==null&&(l.matrix.fromArray(o.transform.matrix),l.matrix.decompose(l.position,l.rotation,l.scale),o.linearVelocity?(l.hasLinearVelocity=!0,l.linearVelocity.copy(o.linearVelocity)):l.hasLinearVelocity=!1,o.angularVelocity?(l.hasAngularVelocity=!0,l.angularVelocity.copy(o.angularVelocity)):l.hasAngularVelocity=!1));return s!==null&&(s.visible=i!==null),l!==null&&(l.visible=o!==null),c!==null&&(c.visible=a!==null),this}},nM=class extends vi{constructor(t,r,n,i,o,a,s,l,c,u){if(u=u!==void 0?u:z0,u!==z0&&u!==k1)throw new Error("DepthTexture format must be either THREE.DepthFormat or THREE.DepthStencilFormat");n===void 0&&u===z0&&(n=G3),n===void 0&&u===k1&&(n=A1),super(null,i,o,a,s,l,u,n,c),this.image={width:t,height:r},this.magFilter=s!==void 0?s:Li,this.minFilter=l!==void 0?l:Li,this.flipY=!1,this.generateMipmaps=!1}};nM.prototype.isDepthTexture=!0;var eht=class extends Us{constructor(t,r){super();let n=this,i=null,o=1,a=null,s="local-floor",l=t.extensions.has("WEBGL_multisampled_render_to_texture"),c=null,u=null,h=null,f=null,p=!1,d=null,g=r.getContextAttributes(),_=null,y=null,x=[],b=new Map,S=new Ui;S.layers.enable(1),S.viewport=new en;let C=new Ui;C.layers.enable(2),C.viewport=new en;let P=[S,C],k=new n6;k.layers.enable(1),k.layers.enable(2);let O=null,D=null;this.cameraAutoUpdate=!0,this.enabled=!1,this.isPresenting=!1,this.getController=function(ot){let st=x[ot];return st===void 0&&(st=new qP,x[ot]=st),st.getTargetRaySpace()},this.getControllerGrip=function(ot){let st=x[ot];return st===void 0&&(st=new qP,x[ot]=st),st.getGripSpace()},this.getHand=function(ot){let st=x[ot];return st===void 0&&(st=new qP,x[ot]=st),st.getHandSpace()};function B(ot){let st=b.get(ot.inputSource);st&&st.dispatchEvent({type:ot.type,data:ot.inputSource})}function I(){b.forEach(function(ot,st){ot.disconnect(st)}),b.clear(),O=null,D=null,t.setRenderTarget(_),f=null,h=null,u=null,i=null,y=null,rt.stop(),n.isPresenting=!1,n.dispatchEvent({type:"sessionend"})}this.setFramebufferScaleFactor=function(ot){o=ot,n.isPresenting===!0&&console.warn("THREE.WebXRManager: Cannot change framebuffer scale while presenting.")},this.setReferenceSpaceType=function(ot){s=ot,n.isPresenting===!0&&console.warn("THREE.WebXRManager: Cannot change reference space type while presenting.")},this.getReferenceSpace=function(){return a},this.getBaseLayer=function(){return h!==null?h:f},this.getBinding=function(){return u},this.getFrame=function(){return d},this.getSession=function(){return i},this.setSession=function(ot){return Ri(this,null,function*(){if(i=ot,i!==null){if(_=t.getRenderTarget(),i.addEventListener("select",B),i.addEventListener("selectstart",B),i.addEventListener("selectend",B),i.addEventListener("squeeze",B),i.addEventListener("squeezestart",B),i.addEventListener("squeezeend",B),i.addEventListener("end",I),i.addEventListener("inputsourceschange",L),g.xrCompatible!==!0&&(yield r.makeXRCompatible()),i.renderState.layers===void 0||t.capabilities.isWebGL2===!1){let st={antialias:i.renderState.layers===void 0?g.antialias:!0,alpha:g.alpha,depth:g.depth,stencil:g.stencil,framebufferScaleFactor:o};f=new XRWebGLLayer(i,r,st),i.updateRenderState({baseLayer:f}),y=new us(f.framebufferWidth,f.framebufferHeight,{format:Qo,type:Zd,encoding:t.outputEncoding})}else{p=g.antialias;let st=null,St=null,bt=null;g.depth&&(bt=g.stencil?35056:33190,st=g.stencil?k1:z0,St=g.stencil?A1:G3);let Mt={colorFormat:t.outputEncoding===Wn?35907:32856,depthFormat:bt,scaleFactor:o};u=new XRWebGLBinding(i,r),h=u.createProjectionLayer(Mt),i.updateRenderState({layers:[h]}),p?y=new j3(h.textureWidth,h.textureHeight,{format:Qo,type:Zd,depthTexture:new nM(h.textureWidth,h.textureHeight,St,void 0,void 0,void 0,void 0,void 0,void 0,st),stencilBuffer:g.stencil,ignoreDepth:h.ignoreDepthValues,useRenderToTexture:l,encoding:t.outputEncoding}):y=new us(h.textureWidth,h.textureHeight,{format:Qo,type:Zd,depthTexture:new nM(h.textureWidth,h.textureHeight,St,void 0,void 0,void 0,void 0,void 0,void 0,st),stencilBuffer:g.stencil,ignoreDepth:h.ignoreDepthValues,encoding:t.outputEncoding})}y.isXRRenderTarget=!0,this.setFoveation(1),a=yield i.requestReferenceSpace(s),rt.setContext(i),rt.start(),n.isPresenting=!0,n.dispatchEvent({type:"sessionstart"})}})};function L(ot){let st=i.inputSources;for(let St=0;St<x.length;St++)b.set(st[St],x[St]);for(let St=0;St<ot.removed.length;St++){let bt=ot.removed[St],Mt=b.get(bt);Mt&&(Mt.dispatchEvent({type:"disconnected",data:bt}),b.delete(bt))}for(let St=0;St<ot.added.length;St++){let bt=ot.added[St],Mt=b.get(bt);Mt&&Mt.dispatchEvent({type:"connected",data:bt})}}let R=new j,F=new j;function z(ot,st,St){R.setFromMatrixPosition(st.matrixWorld),F.setFromMatrixPosition(St.matrixWorld);let bt=R.distanceTo(F),Mt=st.projectionMatrix.elements,lt=St.projectionMatrix.elements,Kt=Mt[14]/(Mt[10]-1),_t=Mt[14]/(Mt[10]+1),ct=(Mt[9]+1)/Mt[5],X=(Mt[9]-1)/Mt[5],et=(Mt[8]-1)/Mt[0],dt=(lt[8]+1)/lt[0],q=Kt*et,pt=Kt*dt,ht=bt/(-et+dt),wt=ht*-et;st.matrixWorld.decompose(ot.position,ot.quaternion,ot.scale),ot.translateX(wt),ot.translateZ(ht),ot.matrixWorld.compose(ot.position,ot.quaternion,ot.scale),ot.matrixWorldInverse.copy(ot.matrixWorld).invert();let kt=Kt+ht,ie=_t+ht,ee=q-wt,Le=pt+(bt-wt),ar=ct*_t/ie*kt,fr=X*_t/ie*kt;ot.projectionMatrix.makePerspective(ee,Le,ar,fr,kt,ie)}function U(ot,st){st===null?ot.matrixWorld.copy(ot.matrix):ot.matrixWorld.multiplyMatrices(st.matrixWorld,ot.matrix),ot.matrixWorldInverse.copy(ot.matrixWorld).invert()}this.updateCamera=function(ot){if(i===null)return;k.near=C.near=S.near=ot.near,k.far=C.far=S.far=ot.far,(O!==k.near||D!==k.far)&&(i.updateRenderState({depthNear:k.near,depthFar:k.far}),O=k.near,D=k.far);let st=ot.parent,St=k.cameras;U(k,st);for(let Mt=0;Mt<St.length;Mt++)U(St[Mt],st);k.matrixWorld.decompose(k.position,k.quaternion,k.scale),ot.position.copy(k.position),ot.quaternion.copy(k.quaternion),ot.scale.copy(k.scale),ot.matrix.copy(k.matrix),ot.matrixWorld.copy(k.matrixWorld);let bt=ot.children;for(let Mt=0,lt=bt.length;Mt<lt;Mt++)bt[Mt].updateMatrixWorld(!0);St.length===2?z(k,S,C):k.projectionMatrix.copy(S.projectionMatrix)},this.getCamera=function(){return k},this.getFoveation=function(){if(h!==null)return h.fixedFoveation;if(f!==null)return f.fixedFoveation},this.setFoveation=function(ot){h!==null&&(h.fixedFoveation=ot),f!==null&&f.fixedFoveation!==void 0&&(f.fixedFoveation=ot)};let W=null;function Z(ot,st){if(c=st.getViewerPose(a),d=st,c!==null){let bt=c.views;f!==null&&(t.setRenderTargetFramebuffer(y,f.framebuffer),t.setRenderTarget(y));let Mt=!1;bt.length!==k.cameras.length&&(k.cameras.length=0,Mt=!0);for(let lt=0;lt<bt.length;lt++){let Kt=bt[lt],_t=null;if(f!==null)_t=f.getViewport(Kt);else{let X=u.getViewSubImage(h,Kt);_t=X.viewport,lt===0&&(t.setRenderTargetTextures(y,X.colorTexture,h.ignoreDepthValues?void 0:X.depthStencilTexture),t.setRenderTarget(y))}let ct=P[lt];ct.matrix.fromArray(Kt.transform.matrix),ct.projectionMatrix.fromArray(Kt.projectionMatrix),ct.viewport.set(_t.x,_t.y,_t.width,_t.height),lt===0&&k.matrix.copy(ct.matrix),Mt===!0&&k.cameras.push(ct)}}let St=i.inputSources;for(let bt=0;bt<x.length;bt++){let Mt=x[bt],lt=St[bt];Mt.update(lt,st,a)}W&&W(ot,st),d=null}let rt=new Ufe;rt.setAnimationLoop(Z),this.setAnimationLoop=function(ot){W=ot},this.dispose=function(){}}};function Rgr(e){function t(y,x){y.fogColor.value.copy(x.color),x.isFog?(y.fogNear.value=x.near,y.fogFar.value=x.far):x.isFogExp2&&(y.fogDensity.value=x.density)}function r(y,x,b,S,C){x.isMeshBasicMaterial?n(y,x):x.isMeshLambertMaterial?(n(y,x),l(y,x)):x.isMeshToonMaterial?(n(y,x),u(y,x)):x.isMeshPhongMaterial?(n(y,x),c(y,x)):x.isMeshStandardMaterial?(n(y,x),x.isMeshPhysicalMaterial?f(y,x,C):h(y,x)):x.isMeshMatcapMaterial?(n(y,x),p(y,x)):x.isMeshDepthMaterial?(n(y,x),d(y,x)):x.isMeshDistanceMaterial?(n(y,x),g(y,x)):x.isMeshNormalMaterial?(n(y,x),_(y,x)):x.isLineBasicMaterial?(i(y,x),x.isLineDashedMaterial&&o(y,x)):x.isPointsMaterial?a(y,x,b,S):x.isSpriteMaterial?s(y,x):x.isShadowMaterial?(y.color.value.copy(x.color),y.opacity.value=x.opacity):x.isShaderMaterial&&(x.uniformsNeedUpdate=!1)}function n(y,x){y.opacity.value=x.opacity,x.color&&y.diffuse.value.copy(x.color),x.emissive&&y.emissive.value.copy(x.emissive).multiplyScalar(x.emissiveIntensity),x.map&&(y.map.value=x.map),x.alphaMap&&(y.alphaMap.value=x.alphaMap),x.specularMap&&(y.specularMap.value=x.specularMap),x.alphaTest>0&&(y.alphaTest.value=x.alphaTest);let b=e.get(x).envMap;b&&(y.envMap.value=b,y.flipEnvMap.value=b.isCubeTexture&&b.isRenderTargetTexture===!1?-1:1,y.reflectivity.value=x.reflectivity,y.ior.value=x.ior,y.refractionRatio.value=x.refractionRatio),x.lightMap&&(y.lightMap.value=x.lightMap,y.lightMapIntensity.value=x.lightMapIntensity),x.aoMap&&(y.aoMap.value=x.aoMap,y.aoMapIntensity.value=x.aoMapIntensity);let S;x.map?S=x.map:x.specularMap?S=x.specularMap:x.displacementMap?S=x.displacementMap:x.normalMap?S=x.normalMap:x.bumpMap?S=x.bumpMap:x.roughnessMap?S=x.roughnessMap:x.metalnessMap?S=x.metalnessMap:x.alphaMap?S=x.alphaMap:x.emissiveMap?S=x.emissiveMap:x.clearcoatMap?S=x.clearcoatMap:x.clearcoatNormalMap?S=x.clearcoatNormalMap:x.clearcoatRoughnessMap?S=x.clearcoatRoughnessMap:x.specularIntensityMap?S=x.specularIntensityMap:x.specularColorMap?S=x.specularColorMap:x.transmissionMap?S=x.transmissionMap:x.thicknessMap?S=x.thicknessMap:x.sheenColorMap?S=x.sheenColorMap:x.sheenRoughnessMap&&(S=x.sheenRoughnessMap),S!==void 0&&(S.isWebGLRenderTarget&&(S=S.texture),S.matrixAutoUpdate===!0&&S.updateMatrix(),y.uvTransform.value.copy(S.matrix));let C;x.aoMap?C=x.aoMap:x.lightMap&&(C=x.lightMap),C!==void 0&&(C.isWebGLRenderTarget&&(C=C.texture),C.matrixAutoUpdate===!0&&C.updateMatrix(),y.uv2Transform.value.copy(C.matrix))}function i(y,x){y.diffuse.value.copy(x.color),y.opacity.value=x.opacity}function o(y,x){y.dashSize.value=x.dashSize,y.totalSize.value=x.dashSize+x.gapSize,y.scale.value=x.scale}function a(y,x,b,S){y.diffuse.value.copy(x.color),y.opacity.value=x.opacity,y.size.value=x.size*b,y.scale.value=S*.5,x.map&&(y.map.value=x.map),x.alphaMap&&(y.alphaMap.value=x.alphaMap),x.alphaTest>0&&(y.alphaTest.value=x.alphaTest);let C;x.map?C=x.map:x.alphaMap&&(C=x.alphaMap),C!==void 0&&(C.matrixAutoUpdate===!0&&C.updateMatrix(),y.uvTransform.value.copy(C.matrix))}function s(y,x){y.diffuse.value.copy(x.color),y.opacity.value=x.opacity,y.rotation.value=x.rotation,x.map&&(y.map.value=x.map),x.alphaMap&&(y.alphaMap.value=x.alphaMap),x.alphaTest>0&&(y.alphaTest.value=x.alphaTest);let b;x.map?b=x.map:x.alphaMap&&(b=x.alphaMap),b!==void 0&&(b.matrixAutoUpdate===!0&&b.updateMatrix(),y.uvTransform.value.copy(b.matrix))}function l(y,x){x.emissiveMap&&(y.emissiveMap.value=x.emissiveMap)}function c(y,x){y.specular.value.copy(x.specular),y.shininess.value=Math.max(x.shininess,1e-4),x.emissiveMap&&(y.emissiveMap.value=x.emissiveMap),x.bumpMap&&(y.bumpMap.value=x.bumpMap,y.bumpScale.value=x.bumpScale,x.side===Ii&&(y.bumpScale.value*=-1)),x.normalMap&&(y.normalMap.value=x.normalMap,y.normalScale.value.copy(x.normalScale),x.side===Ii&&y.normalScale.value.negate()),x.displacementMap&&(y.displacementMap.value=x.displacementMap,y.displacementScale.value=x.displacementScale,y.displacementBias.value=x.displacementBias)}function u(y,x){x.gradientMap&&(y.gradientMap.value=x.gradientMap),x.emissiveMap&&(y.emissiveMap.value=x.emissiveMap),x.bumpMap&&(y.bumpMap.value=x.bumpMap,y.bumpScale.value=x.bumpScale,x.side===Ii&&(y.bumpScale.value*=-1)),x.normalMap&&(y.normalMap.value=x.normalMap,y.normalScale.value.copy(x.normalScale),x.side===Ii&&y.normalScale.value.negate()),x.displacementMap&&(y.displacementMap.value=x.displacementMap,y.displacementScale.value=x.displacementScale,y.displacementBias.value=x.displacementBias)}function h(y,x){y.roughness.value=x.roughness,y.metalness.value=x.metalness,x.roughnessMap&&(y.roughnessMap.value=x.roughnessMap),x.metalnessMap&&(y.metalnessMap.value=x.metalnessMap),x.emissiveMap&&(y.emissiveMap.value=x.emissiveMap),x.bumpMap&&(y.bumpMap.value=x.bumpMap,y.bumpScale.value=x.bumpScale,x.side===Ii&&(y.bumpScale.value*=-1)),x.normalMap&&(y.normalMap.value=x.normalMap,y.normalScale.value.copy(x.normalScale),x.side===Ii&&y.normalScale.value.negate()),x.displacementMap&&(y.displacementMap.value=x.displacementMap,y.displacementScale.value=x.displacementScale,y.displacementBias.value=x.displacementBias),e.get(x).envMap&&(y.envMapIntensity.value=x.envMapIntensity)}function f(y,x,b){h(y,x),y.ior.value=x.ior,x.sheen>0&&(y.sheenColor.value.copy(x.sheenColor).multiplyScalar(x.sheen),y.sheenRoughness.value=x.sheenRoughness,x.sheenColorMap&&(y.sheenColorMap.value=x.sheenColorMap),x.sheenRoughnessMap&&(y.sheenRoughnessMap.value=x.sheenRoughnessMap)),x.clearcoat>0&&(y.clearcoat.value=x.clearcoat,y.clearcoatRoughness.value=x.clearcoatRoughness,x.clearcoatMap&&(y.clearcoatMap.value=x.clearcoatMap),x.clearcoatRoughnessMap&&(y.clearcoatRoughnessMap.value=x.clearcoatRoughnessMap),x.clearcoatNormalMap&&(y.clearcoatNormalScale.value.copy(x.clearcoatNormalScale),y.clearcoatNormalMap.value=x.clearcoatNormalMap,x.side===Ii&&y.clearcoatNormalScale.value.negate())),x.transmission>0&&(y.transmission.value=x.transmission,y.transmissionSamplerMap.value=b.texture,y.transmissionSamplerSize.value.set(b.width,b.height),x.transmissionMap&&(y.transmissionMap.value=x.transmissionMap),y.thickness.value=x.thickness,x.thicknessMap&&(y.thicknessMap.value=x.thicknessMap),y.attenuationDistance.value=x.attenuationDistance,y.attenuationColor.value.copy(x.attenuationColor)),y.specularIntensity.value=x.specularIntensity,y.specularColor.value.copy(x.specularColor),x.specularIntensityMap&&(y.specularIntensityMap.value=x.specularIntensityMap),x.specularColorMap&&(y.specularColorMap.value=x.specularColorMap)}function p(y,x){x.matcap&&(y.matcap.value=x.matcap),x.bumpMap&&(y.bumpMap.value=x.bumpMap,y.bumpScale.value=x.bumpScale,x.side===Ii&&(y.bumpScale.value*=-1)),x.normalMap&&(y.normalMap.value=x.normalMap,y.normalScale.value.copy(x.normalScale),x.side===Ii&&y.normalScale.value.negate()),x.displacementMap&&(y.displacementMap.value=x.displacementMap,y.displacementScale.value=x.displacementScale,y.displacementBias.value=x.displacementBias)}function d(y,x){x.displacementMap&&(y.displacementMap.value=x.displacementMap,y.displacementScale.value=x.displacementScale,y.displacementBias.value=x.displacementBias)}function g(y,x){x.displacementMap&&(y.displacementMap.value=x.displacementMap,y.displacementScale.value=x.displacementScale,y.displacementBias.value=x.displacementBias),y.referencePosition.value.copy(x.referencePosition),y.nearDistance.value=x.nearDistance,y.farDistance.value=x.farDistance}function _(y,x){x.bumpMap&&(y.bumpMap.value=x.bumpMap,y.bumpScale.value=x.bumpScale,x.side===Ii&&(y.bumpScale.value*=-1)),x.normalMap&&(y.normalMap.value=x.normalMap,y.normalScale.value.copy(x.normalScale),x.side===Ii&&y.normalScale.value.negate()),x.displacementMap&&(y.displacementMap.value=x.displacementMap,y.displacementScale.value=x.displacementScale,y.displacementBias.value=x.displacementBias)}return{refreshFogUniforms:t,refreshMaterialUniforms:r}}function Ngr(){let e=t6("canvas");return e.style.display="block",e}function rn(e={}){let t=e.canvas!==void 0?e.canvas:Ngr(),r=e.context!==void 0?e.context:null,n=e.alpha!==void 0?e.alpha:!1,i=e.depth!==void 0?e.depth:!0,o=e.stencil!==void 0?e.stencil:!0,a=e.antialias!==void 0?e.antialias:!1,s=e.premultipliedAlpha!==void 0?e.premultipliedAlpha:!0,l=e.preserveDrawingBuffer!==void 0?e.preserveDrawingBuffer:!1,c=e.powerPreference!==void 0?e.powerPreference:"default",u=e.failIfMajorPerformanceCaveat!==void 0?e.failIfMajorPerformanceCaveat:!1,h=null,f=null,p=[],d=[];this.domElement=t,this.debug={checkShaderErrors:!0},this.autoClear=!0,this.autoClearColor=!0,this.autoClearDepth=!0,this.autoClearStencil=!0,this.sortObjects=!0,this.clippingPlanes=[],this.localClippingEnabled=!1,this.outputEncoding=Qd,this.physicallyCorrectLights=!1,this.toneMapping=Kd,this.toneMappingExposure=1;let g=this,_=!1,y=0,x=0,b=null,S=-1,C=null,P=new en,k=new en,O=null,D=t.width,B=t.height,I=1,L=null,R=null,F=new en(0,0,D,B),z=new en(0,0,D,B),U=!1,W=new N1,Z=!1,rt=!1,ot=null,st=new Me,St=new j,bt={background:null,fog:null,environment:null,overrideMaterial:null,isScene:!0};function Mt(){return b===null?I:1}let lt=r;function Kt(K,gt){for(let Et=0;Et<K.length;Et++){let xt=K[Et],Ft=t.getContext(xt,gt);if(Ft!==null)return Ft}return null}try{let K={alpha:!0,depth:i,stencil:o,antialias:a,premultipliedAlpha:s,preserveDrawingBuffer:l,powerPreference:c,failIfMajorPerformanceCaveat:u};if("setAttribute"in t&&t.setAttribute("data-engine",`three.js r${jU}`),t.addEventListener("webglcontextlost",fe,!1),t.addEventListener("webglcontextrestored",at,!1),lt===null){let gt=["webgl2","webgl","experimental-webgl"];if(g.isWebGL1Renderer===!0&&gt.shift(),lt=Kt(gt,K),lt===null)throw Kt(gt)?new Error("Error creating WebGL context with your selected attributes."):new Error("Error creating WebGL context.")}lt.getShaderPrecisionFormat===void 0&&(lt.getShaderPrecisionFormat=function(){return{rangeMin:1,rangeMax:1,precision:1}})}catch(K){throw console.error("THREE.WebGLRenderer: "+K.message),K}let _t,ct,X,et,dt,q,pt,ht,wt,kt,ie,ee,Le,ar,fr,tt,$,It,$t,he,Tt,be,nt;function Ct(){_t=new nmr(lt),ct=new Zdr(lt,_t,e),_t.init(ct),be=new Qfe(lt,_t,ct),X=new Igr(lt,_t,ct),et=new amr(lt),dt=new vgr,q=new Lgr(lt,_t,X,dt,ct,be,et),pt=new Qdr(g),ht=new rmr(g),wt=new bfr(lt,ct),nt=new $dr(lt,_t,wt,ct),kt=new imr(lt,wt,et,nt),ie=new umr(lt,kt,wt,et),$t=new cmr(lt,ct,q),tt=new Jdr(dt),ee=new ygr(g,pt,ht,_t,ct,nt,tt),Le=new Rgr(dt),ar=new bgr,fr=new Cgr(_t,ct),It=new Xdr(g,pt,X,ie,n,s),$=new Jfe(g,ie,ct),he=new Kdr(lt,_t,et,ct),Tt=new omr(lt,_t,et,ct),et.programs=ee.programs,g.capabilities=ct,g.extensions=_t,g.properties=dt,g.renderLists=ar,g.shadowMap=$,g.state=X,g.info=et}Ct();let Wt=new eht(g,lt);this.xr=Wt,this.getContext=function(){return lt},this.getContextAttributes=function(){return lt.getContextAttributes()},this.forceContextLoss=function(){let K=_t.get("WEBGL_lose_context");K&&K.loseContext()},this.forceContextRestore=function(){let K=_t.get("WEBGL_lose_context");K&&K.restoreContext()},this.getPixelRatio=function(){return I},this.setPixelRatio=function(K){K!==void 0&&(I=K,this.setSize(D,B,!1))},this.getSize=function(K){return K.set(D,B)},this.setSize=function(K,gt,Et){if(Wt.isPresenting){console.warn("THREE.WebGLRenderer: Can't change size while VR device is presenting.");return}D=K,B=gt,t.width=Math.floor(K*I),t.height=Math.floor(gt*I),Et!==!1&&(t.style.width=K+"px",t.style.height=gt+"px"),this.setViewport(0,0,K,gt)},this.getDrawingBufferSize=function(K){return K.set(D*I,B*I).floor()},this.setDrawingBufferSize=function(K,gt,Et){D=K,B=gt,I=Et,t.width=Math.floor(K*Et),t.height=Math.floor(gt*Et),this.setViewport(0,0,K,gt)},this.getCurrentViewport=function(K){return K.copy(P)},this.getViewport=function(K){return K.copy(F)},this.setViewport=function(K,gt,Et,xt){K.isVector4?F.set(K.x,K.y,K.z,K.w):F.set(K,gt,Et,xt),X.viewport(P.copy(F).multiplyScalar(I).floor())},this.getScissor=function(K){return K.copy(z)},this.setScissor=function(K,gt,Et,xt){K.isVector4?z.set(K.x,K.y,K.z,K.w):z.set(K,gt,Et,xt),X.scissor(k.copy(z).multiplyScalar(I).floor())},this.getScissorTest=function(){return U},this.setScissorTest=function(K){X.setScissorTest(U=K)},this.setOpaqueSort=function(K){L=K},this.setTransparentSort=function(K){R=K},this.getClearColor=function(K){return K.copy(It.getClearColor())},this.setClearColor=function(){It.setClearColor.apply(It,arguments)},this.getClearAlpha=function(){return It.getClearAlpha()},this.setClearAlpha=function(){It.setClearAlpha.apply(It,arguments)},this.clear=function(K,gt,Et){let xt=0;(K===void 0||K)&&(xt|=16384),(gt===void 0||gt)&&(xt|=256),(Et===void 0||Et)&&(xt|=1024),lt.clear(xt)},this.clearColor=function(){this.clear(!0,!1,!1)},this.clearDepth=function(){this.clear(!1,!0,!1)},this.clearStencil=function(){this.clear(!1,!1,!0)},this.dispose=function(){t.removeEventListener("webglcontextlost",fe,!1),t.removeEventListener("webglcontextrestored",at,!1),ar.dispose(),fr.dispose(),dt.dispose(),pt.dispose(),ht.dispose(),ie.dispose(),nt.dispose(),ee.dispose(),Wt.dispose(),Wt.removeEventListener("sessionstart",ze),Wt.removeEventListener("sessionend",yn),ot&&(ot.dispose(),ot=null),Wi.stop()};function fe(K){K.preventDefault(),console.log("THREE.WebGLRenderer: Context Lost."),_=!0}function at(){console.log("THREE.WebGLRenderer: Context Restored."),_=!1;let K=et.autoReset,gt=$.enabled,Et=$.autoUpdate,xt=$.needsUpdate,Ft=$.type;Ct(),et.autoReset=K,$.enabled=gt,$.autoUpdate=Et,$.needsUpdate=xt,$.type=Ft}function se(K){let gt=K.target;gt.removeEventListener("dispose",se),Qt(gt)}function Qt(K){Ce(K),dt.remove(K)}function Ce(K){let gt=dt.get(K).programs;gt!==void 0&&(gt.forEach(function(Et){ee.releaseProgram(Et)}),K.isShaderMaterial&&ee.releaseShaderCache(K))}this.renderBufferDirect=function(K,gt,Et,xt,Ft,Ve){gt===null&&(gt=bt);let Ue=Ft.isMesh&&Ft.matrixWorld.determinant()<0,tr=cn(K,gt,Et,xt,Ft);X.setMaterial(xt,Ue);let Ke=Et.index,Xr=Et.attributes.position;if(Ke===null){if(Xr===void 0||Xr.count===0)return}else if(Ke.count===0)return;let _r=1;xt.wireframe===!0&&(Ke=kt.getWireframeAttribute(Et),_r=2),nt.setup(Ft,xt,tr,Et,Ke);let Pr,jn=he;Ke!==null&&(Pr=wt.get(Ke),jn=Tt,jn.setIndex(Pr));let np=Ke!==null?Ke.count:Xr.count,um=Et.drawRange.start*_r,mr=Et.drawRange.count*_r,Fl=Ve!==null?Ve.start*_r:0,Xn=Ve!==null?Ve.count*_r:1/0,Bl=Math.max(um,Fl),ux=Math.min(np,um+mr,Fl+Xn)-1,Hl=Math.max(0,ux-Bl+1);if(Hl!==0){if(Ft.isMesh)xt.wireframe===!0?(X.setLineWidth(xt.wireframeLinewidth*Mt()),jn.setMode(1)):jn.setMode(4);else if(Ft.isLine){let Vl=xt.linewidth;Vl===void 0&&(Vl=1),X.setLineWidth(Vl*Mt()),Ft.isLineSegments?jn.setMode(1):Ft.isLineLoop?jn.setMode(2):jn.setMode(3)}else Ft.isPoints?jn.setMode(0):Ft.isSprite&&jn.setMode(4);if(Ft.isInstancedMesh)jn.renderInstances(Bl,Hl,Ft.count);else if(Et.isInstancedBufferGeometry){let Vl=Math.min(Et.instanceCount,Et._maxInstanceCount);jn.renderInstances(Bl,Hl,Vl)}else jn.render(Bl,Hl)}},this.compile=function(K,gt){f=fr.get(K),f.init(),d.push(f),K.traverseVisible(function(Et){Et.isLight&&Et.layers.test(gt.layers)&&(f.pushLight(Et),Et.castShadow&&f.pushShadow(Et))}),f.setupLights(g.physicallyCorrectLights),K.traverse(function(Et){let xt=Et.material;if(xt)if(Array.isArray(xt))for(let Ft=0;Ft<xt.length;Ft++){let Ve=xt[Ft];cm(Ve,K,Et)}else cm(xt,K,Et)}),d.pop(),f=null};let Pt=null;function Nt(K){Pt&&Pt(K)}function ze(){Wi.stop()}function yn(){Wi.start()}let Wi=new Ufe;Wi.setAnimationLoop(Nt),typeof window!="undefined"&&Wi.setContext(window),this.setAnimationLoop=function(K){Pt=K,Wt.setAnimationLoop(K),K===null?Wi.stop():Wi.start()},Wt.addEventListener("sessionstart",ze),Wt.addEventListener("sessionend",yn),this.render=function(K,gt){if(gt!==void 0&&gt.isCamera!==!0){console.error("THREE.WebGLRenderer.render: camera is not an instance of THREE.Camera.");return}if(_===!0)return;K.autoUpdate===!0&&K.updateMatrixWorld(),gt.parent===null&&gt.updateMatrixWorld(),Wt.enabled===!0&&Wt.isPresenting===!0&&(Wt.cameraAutoUpdate===!0&&Wt.updateCamera(gt),gt=Wt.getCamera()),K.isScene===!0&&K.onBeforeRender(g,K,gt,b),f=fr.get(K,d.length),f.init(),d.push(f),st.multiplyMatrices(gt.projectionMatrix,gt.matrixWorldInverse),W.setFromProjectionMatrix(st),rt=this.localClippingEnabled,Z=tt.init(this.clippingPlanes,rt,gt),h=ar.get(K,p.length),h.init(),p.push(h),Ar(K,gt,0,g.sortObjects),h.finish(),g.sortObjects===!0&&h.sort(L,R),Z===!0&&tt.beginShadows();let Et=f.state.shadowsArray;if($.render(Et,K,gt),Z===!0&&tt.endShadows(),this.info.autoReset===!0&&this.info.reset(),It.render(h,K),f.setupLights(g.physicallyCorrectLights),gt.isArrayCamera){let xt=gt.cameras;for(let Ft=0,Ve=xt.length;Ft<Ve;Ft++){let Ue=xt[Ft];Pa(h,K,Ue,Ue.viewport)}}else Pa(h,K,gt);b!==null&&(q.updateMultisampleRenderTarget(b),q.updateRenderTargetMipmap(b)),K.isScene===!0&&K.onAfterRender(g,K,gt),X.buffers.depth.setTest(!0),X.buffers.depth.setMask(!0),X.buffers.color.setMask(!0),X.setPolygonOffset(!1),nt.resetDefaultState(),S=-1,C=null,d.pop(),d.length>0?f=d[d.length-1]:f=null,p.pop(),p.length>0?h=p[p.length-1]:h=null};function Ar(K,gt,Et,xt){if(K.visible===!1)return;if(K.layers.test(gt.layers)){if(K.isGroup)Et=K.renderOrder;else if(K.isLOD)K.autoUpdate===!0&&K.update(gt);else if(K.isLight)f.pushLight(K),K.castShadow&&f.pushShadow(K);else if(K.isSprite){if(!K.frustumCulled||W.intersectsSprite(K)){xt&&St.setFromMatrixPosition(K.matrixWorld).applyMatrix4(st);let Ue=ie.update(K),tr=K.material;tr.visible&&h.push(K,Ue,tr,Et,St.z,null)}}else if((K.isMesh||K.isLine||K.isPoints)&&(K.isSkinnedMesh&&K.skeleton.frame!==et.render.frame&&(K.skeleton.update(),K.skeleton.frame=et.render.frame),!K.frustumCulled||W.intersectsObject(K))){xt&&St.setFromMatrixPosition(K.matrixWorld).applyMatrix4(st);let Ue=ie.update(K),tr=K.material;if(Array.isArray(tr)){let Ke=Ue.groups;for(let Xr=0,_r=Ke.length;Xr<_r;Xr++){let Pr=Ke[Xr],jn=tr[Pr.materialIndex];jn&&jn.visible&&h.push(K,Ue,jn,Et,St.z,Pr)}}else tr.visible&&h.push(K,Ue,tr,Et,St.z,null)}}let Ve=K.children;for(let Ue=0,tr=Ve.length;Ue<tr;Ue++)Ar(Ve[Ue],gt,Et,xt)}function Pa(K,gt,Et,xt){let Ft=K.opaque,Ve=K.transmissive,Ue=K.transparent;f.setupLightsView(Et),Ve.length>0&&ho(Ft,gt,Et),xt&&X.viewport(P.copy(xt)),Ft.length>0&&Ia(Ft,gt,Et),Ve.length>0&&Ia(Ve,gt,Et),Ue.length>0&&Ia(Ue,gt,Et)}function ho(K,gt,Et){if(ot===null){let Ue=a===!0&&ct.isWebGL2===!0?j3:us;ot=new Ue(1024,1024,{generateMipmaps:!0,type:be.convert(C1)!==null?C1:Zd,minFilter:ox,magFilter:Li,wrapS:Jo,wrapT:Jo,useRenderToTexture:_t.has("WEBGL_multisampled_render_to_texture")})}let xt=g.getRenderTarget();g.setRenderTarget(ot),g.clear();let Ft=g.toneMapping;g.toneMapping=Kd,Ia(K,gt,Et),g.toneMapping=Ft,q.updateMultisampleRenderTarget(ot),q.updateRenderTargetMipmap(ot),g.setRenderTarget(xt)}function Ia(K,gt,Et){let xt=gt.isScene===!0?gt.overrideMaterial:null;for(let Ft=0,Ve=K.length;Ft<Ve;Ft++){let Ue=K[Ft],tr=Ue.object,Ke=Ue.geometry,Xr=xt===null?Ue.material:xt,_r=Ue.group;tr.layers.test(Et.layers)&&lx(tr,gt,Et,Ke,Xr,_r)}}function lx(K,gt,Et,xt,Ft,Ve){K.onBeforeRender(g,gt,Et,xt,Ft,Ve),K.modelViewMatrix.multiplyMatrices(Et.matrixWorldInverse,K.matrixWorld),K.normalMatrix.getNormalMatrix(K.modelViewMatrix),Ft.onBeforeRender(g,gt,Et,xt,K,Ve),Ft.transparent===!0&&Ft.side===L1?(Ft.side=Ii,Ft.needsUpdate=!0,g.renderBufferDirect(Et,gt,xt,Ft,K,Ve),Ft.side=I1,Ft.needsUpdate=!0,g.renderBufferDirect(Et,gt,xt,Ft,K,Ve),Ft.side=L1):g.renderBufferDirect(Et,gt,xt,Ft,K,Ve),K.onAfterRender(g,gt,Et,xt,Ft,Ve)}function cm(K,gt,Et){gt.isScene!==!0&&(gt=bt);let xt=dt.get(K),Ft=f.state.lights,Ve=f.state.shadowsArray,Ue=Ft.state.version,tr=ee.getParameters(K,Ft.state,Ve,gt,Et),Ke=ee.getProgramCacheKey(tr),Xr=xt.programs;xt.environment=K.isMeshStandardMaterial?gt.environment:null,xt.fog=gt.fog,xt.envMap=(K.isMeshStandardMaterial?ht:pt).get(K.envMap||xt.environment),Xr===void 0&&(K.addEventListener("dispose",se),Xr=new Map,xt.programs=Xr);let _r=Xr.get(Ke);if(_r!==void 0){if(xt.currentProgram===_r&&xt.lightsStateVersion===Ue)return J0(K,tr),_r}else tr.uniforms=ee.getUniforms(K),K.onBuild(Et,tr,g),K.onBeforeCompile(tr,g),_r=ee.acquireProgram(tr,Ke),Xr.set(Ke,_r),xt.uniforms=tr.uniforms;let Pr=xt.uniforms;(!K.isShaderMaterial&&!K.isRawShaderMaterial||K.clipping===!0)&&(Pr.clippingPlanes=tt.uniform),J0(K,tr),xt.needsLights=rp(K),xt.lightsStateVersion=Ue,xt.needsLights&&(Pr.ambientLightColor.value=Ft.state.ambient,Pr.lightProbe.value=Ft.state.probe,Pr.directionalLights.value=Ft.state.directional,Pr.directionalLightShadows.value=Ft.state.directionalShadow,Pr.spotLights.value=Ft.state.spot,Pr.spotLightShadows.value=Ft.state.spotShadow,Pr.rectAreaLights.value=Ft.state.rectArea,Pr.ltc_1.value=Ft.state.rectAreaLTC1,Pr.ltc_2.value=Ft.state.rectAreaLTC2,Pr.pointLights.value=Ft.state.point,Pr.pointLightShadows.value=Ft.state.pointShadow,Pr.hemisphereLights.value=Ft.state.hemi,Pr.directionalShadowMap.value=Ft.state.directionalShadowMap,Pr.directionalShadowMatrix.value=Ft.state.directionalShadowMatrix,Pr.spotShadowMap.value=Ft.state.spotShadowMap,Pr.spotShadowMatrix.value=Ft.state.spotShadowMatrix,Pr.pointShadowMap.value=Ft.state.pointShadowMap,Pr.pointShadowMatrix.value=Ft.state.pointShadowMatrix);let jn=_r.getUniforms(),np=B0.seqWithValue(jn.seq,Pr);return xt.currentProgram=_r,xt.uniformsList=np,_r}function J0(K,gt){let Et=dt.get(K);Et.outputEncoding=gt.outputEncoding,Et.instancing=gt.instancing,Et.skinning=gt.skinning,Et.morphTargets=gt.morphTargets,Et.morphNormals=gt.morphNormals,Et.morphTargetsCount=gt.morphTargetsCount,Et.numClippingPlanes=gt.numClippingPlanes,Et.numIntersection=gt.numClipIntersection,Et.vertexAlphas=gt.vertexAlphas,Et.vertexTangents=gt.vertexTangents,Et.toneMapping=gt.toneMapping}function cn(K,gt,Et,xt,Ft){gt.isScene!==!0&&(gt=bt),q.resetTextureUnits();let Ve=gt.fog,Ue=xt.isMeshStandardMaterial?gt.environment:null,tr=b===null?g.outputEncoding:b.isXRRenderTarget===!0?b.texture.encoding:Qd,Ke=(xt.isMeshStandardMaterial?ht:pt).get(xt.envMap||Ue),Xr=xt.vertexColors===!0&&!!Et.attributes.color&&Et.attributes.color.itemSize===4,_r=!!xt.normalMap&&!!Et.attributes.tangent,Pr=!!Et.morphAttributes.position,jn=!!Et.morphAttributes.normal,np=Et.morphAttributes.position?Et.morphAttributes.position.length:0,um=xt.toneMapped?g.toneMapping:Kd,mr=dt.get(xt),Fl=f.state.lights;if(Z===!0&&(rt===!0||K!==C)){let qs=K===C&&xt.id===S;tt.setState(xt,K,qs)}let Xn=!1;xt.version===mr.__version?(mr.needsLights&&mr.lightsStateVersion!==Fl.state.version||mr.outputEncoding!==tr||Ft.isInstancedMesh&&mr.instancing===!1||!Ft.isInstancedMesh&&mr.instancing===!0||Ft.isSkinnedMesh&&mr.skinning===!1||!Ft.isSkinnedMesh&&mr.skinning===!0||mr.envMap!==Ke||xt.fog&&mr.fog!==Ve||mr.numClippingPlanes!==void 0&&(mr.numClippingPlanes!==tt.numPlanes||mr.numIntersection!==tt.numIntersection)||mr.vertexAlphas!==Xr||mr.vertexTangents!==_r||mr.morphTargets!==Pr||mr.morphNormals!==jn||mr.toneMapping!==um||ct.isWebGL2===!0&&mr.morphTargetsCount!==np)&&(Xn=!0):(Xn=!0,mr.__version=xt.version);let Bl=mr.currentProgram;Xn===!0&&(Bl=cm(xt,gt,Ft));let ux=!1,Hl=!1,Vl=!1,Yi=Bl.getUniforms(),hm=mr.uniforms;if(X.useProgram(Bl.program)&&(ux=!0,Hl=!0,Vl=!0),xt.id!==S&&(S=xt.id,Hl=!0),ux||C!==K){if(Yi.setValue(lt,"projectionMatrix",K.projectionMatrix),ct.logarithmicDepthBuffer&&Yi.setValue(lt,"logDepthBufFC",2/(Math.log(K.far+1)/Math.LN2)),C!==K&&(C=K,Hl=!0,Vl=!0),xt.isShaderMaterial||xt.isMeshPhongMaterial||xt.isMeshToonMaterial||xt.isMeshStandardMaterial||xt.envMap){let qs=Yi.map.cameraPosition;qs!==void 0&&qs.setValue(lt,St.setFromMatrixPosition(K.matrixWorld))}(xt.isMeshPhongMaterial||xt.isMeshToonMaterial||xt.isMeshLambertMaterial||xt.isMeshBasicMaterial||xt.isMeshStandardMaterial||xt.isShaderMaterial)&&Yi.setValue(lt,"isOrthographic",K.isOrthographicCamera===!0),(xt.isMeshPhongMaterial||xt.isMeshToonMaterial||xt.isMeshLambertMaterial||xt.isMeshBasicMaterial||xt.isMeshStandardMaterial||xt.isShaderMaterial||xt.isShadowMaterial||Ft.isSkinnedMesh)&&Yi.setValue(lt,"viewMatrix",K.matrixWorldInverse)}if(Ft.isSkinnedMesh){Yi.setOptional(lt,Ft,"bindMatrix"),Yi.setOptional(lt,Ft,"bindMatrixInverse");let qs=Ft.skeleton;qs&&(ct.floatVertexTextures?(qs.boneTexture===null&&qs.computeBoneTexture(),Yi.setValue(lt,"boneTexture",qs.boneTexture,q),Yi.setValue(lt,"boneTextureSize",qs.boneTextureSize)):Yi.setOptional(lt,qs,"boneMatrices"))}return!!Et&&(Et.morphAttributes.position!==void 0||Et.morphAttributes.normal!==void 0)&&$t.update(Ft,Et,xt,Bl),(Hl||mr.receiveShadow!==Ft.receiveShadow)&&(mr.receiveShadow=Ft.receiveShadow,Yi.setValue(lt,"receiveShadow",Ft.receiveShadow)),Hl&&(Yi.setValue(lt,"toneMappingExposure",g.toneMappingExposure),mr.needsLights&&cx(hm,Vl),Ve&&xt.fog&&Le.refreshFogUniforms(hm,Ve),Le.refreshMaterialUniforms(hm,xt,I,B,ot),B0.upload(lt,mr.uniformsList,hm,q)),xt.isShaderMaterial&&xt.uniformsNeedUpdate===!0&&(B0.upload(lt,mr.uniformsList,hm,q),xt.uniformsNeedUpdate=!1),xt.isSpriteMaterial&&Yi.setValue(lt,"center",Ft.center),Yi.setValue(lt,"modelViewMatrix",Ft.modelViewMatrix),Yi.setValue(lt,"normalMatrix",Ft.normalMatrix),Yi.setValue(lt,"modelMatrix",Ft.matrixWorld),Bl}function cx(K,gt){K.ambientLightColor.needsUpdate=gt,K.lightProbe.needsUpdate=gt,K.directionalLights.needsUpdate=gt,K.directionalLightShadows.needsUpdate=gt,K.pointLights.needsUpdate=gt,K.pointLightShadows.needsUpdate=gt,K.spotLights.needsUpdate=gt,K.spotLightShadows.needsUpdate=gt,K.rectAreaLights.needsUpdate=gt,K.hemisphereLights.needsUpdate=gt}function rp(K){return K.isMeshLambertMaterial||K.isMeshToonMaterial||K.isMeshPhongMaterial||K.isMeshStandardMaterial||K.isShadowMaterial||K.isShaderMaterial&&K.lights===!0}this.getActiveCubeFace=function(){return y},this.getActiveMipmapLevel=function(){return x},this.getRenderTarget=function(){return b},this.setRenderTargetTextures=function(K,gt,Et){dt.get(K.texture).__webglTexture=gt,dt.get(K.depthTexture).__webglTexture=Et;let xt=dt.get(K);xt.__hasExternalTextures=!0,xt.__hasExternalTextures&&(xt.__autoAllocateDepthBuffer=Et===void 0,xt.__autoAllocateDepthBuffer||K.useRenderToTexture&&(console.warn("render-to-texture extension was disabled because an external texture was provided"),K.useRenderToTexture=!1,K.useRenderbuffer=!0))},this.setRenderTargetFramebuffer=function(K,gt){let Et=dt.get(K);Et.__webglFramebuffer=gt,Et.__useDefaultFramebuffer=gt===void 0},this.setRenderTarget=function(K,gt=0,Et=0){b=K,y=gt,x=Et;let xt=!0;if(K){let Ke=dt.get(K);Ke.__useDefaultFramebuffer!==void 0?(X.bindFramebuffer(36160,null),xt=!1):Ke.__webglFramebuffer===void 0?q.setupRenderTarget(K):Ke.__hasExternalTextures&&q.rebindTextures(K,dt.get(K.texture).__webglTexture,dt.get(K.depthTexture).__webglTexture)}let Ft=null,Ve=!1,Ue=!1;if(K){let Ke=K.texture;(Ke.isDataTexture3D||Ke.isDataTexture2DArray)&&(Ue=!0);let Xr=dt.get(K).__webglFramebuffer;K.isWebGLCubeRenderTarget?(Ft=Xr[gt],Ve=!0):K.useRenderbuffer?Ft=dt.get(K).__webglMultisampledFramebuffer:Ft=Xr,P.copy(K.viewport),k.copy(K.scissor),O=K.scissorTest}else P.copy(F).multiplyScalar(I).floor(),k.copy(z).multiplyScalar(I).floor(),O=U;if(X.bindFramebuffer(36160,Ft)&&ct.drawBuffers&&xt&&X.drawBuffers(K,Ft),X.viewport(P),X.scissor(k),X.setScissorTest(O),Ve){let Ke=dt.get(K.texture);lt.framebufferTexture2D(36160,36064,34069+gt,Ke.__webglTexture,Et)}else if(Ue){let Ke=dt.get(K.texture),Xr=gt||0;lt.framebufferTextureLayer(36160,36064,Ke.__webglTexture,Et||0,Xr)}S=-1},this.readRenderTargetPixels=function(K,gt,Et,xt,Ft,Ve,Ue){if(!(K&&K.isWebGLRenderTarget)){console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not THREE.WebGLRenderTarget.");return}let tr=dt.get(K).__webglFramebuffer;if(K.isWebGLCubeRenderTarget&&Ue!==void 0&&(tr=tr[Ue]),tr){X.bindFramebuffer(36160,tr);try{let Ke=K.texture,Xr=Ke.format,_r=Ke.type;if(Xr!==Qo&&be.convert(Xr)!==lt.getParameter(35739)){console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in RGBA or implementation defined format.");return}let Pr=_r===C1&&(_t.has("EXT_color_buffer_half_float")||ct.isWebGL2&&_t.has("EXT_color_buffer_float"));if(_r!==Zd&&be.convert(_r)!==lt.getParameter(35738)&&!(_r===jd&&(ct.isWebGL2||_t.has("OES_texture_float")||_t.has("WEBGL_color_buffer_float")))&&!Pr){console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in UnsignedByteType or implementation defined type.");return}lt.checkFramebufferStatus(36160)===36053?gt>=0&&gt<=K.width-xt&&Et>=0&&Et<=K.height-Ft&&lt.readPixels(gt,Et,xt,Ft,be.convert(Xr),be.convert(_r),Ve):console.error("THREE.WebGLRenderer.readRenderTargetPixels: readPixels from renderTarget failed. Framebuffer not complete.")}finally{let Ke=b!==null?dt.get(b).__webglFramebuffer:null;X.bindFramebuffer(36160,Ke)}}},this.copyFramebufferToTexture=function(K,gt,Et=0){if(gt.isFramebufferTexture!==!0){console.error("THREE.WebGLRenderer: copyFramebufferToTexture() can only be used with FramebufferTexture.");return}let xt=Math.pow(2,-Et),Ft=Math.floor(gt.image.width*xt),Ve=Math.floor(gt.image.height*xt);q.setTexture2D(gt,0),lt.copyTexSubImage2D(3553,Et,0,0,K.x,K.y,Ft,Ve),X.unbindTexture()},this.copyTextureToTexture=function(K,gt,Et,xt=0){let Ft=gt.image.width,Ve=gt.image.height,Ue=be.convert(Et.format),tr=be.convert(Et.type);q.setTexture2D(Et,0),lt.pixelStorei(37440,Et.flipY),lt.pixelStorei(37441,Et.premultiplyAlpha),lt.pixelStorei(3317,Et.unpackAlignment),gt.isDataTexture?lt.texSubImage2D(3553,xt,K.x,K.y,Ft,Ve,Ue,tr,gt.image.data):gt.isCompressedTexture?lt.compressedTexSubImage2D(3553,xt,K.x,K.y,gt.mipmaps[0].width,gt.mipmaps[0].height,Ue,gt.mipmaps[0].data):lt.texSubImage2D(3553,xt,K.x,K.y,Ue,tr,gt.image),xt===0&&Et.generateMipmaps&&lt.generateMipmap(3553),X.unbindTexture()},this.copyTextureToTexture3D=function(K,gt,Et,xt,Ft=0){if(g.isWebGL1Renderer){console.warn("THREE.WebGLRenderer.copyTextureToTexture3D: can only be used with WebGL2.");return}let Ve=K.max.x-K.min.x+1,Ue=K.max.y-K.min.y+1,tr=K.max.z-K.min.z+1,Ke=be.convert(xt.format),Xr=be.convert(xt.type),_r;if(xt.isDataTexture3D)q.setTexture3D(xt,0),_r=32879;else if(xt.isDataTexture2DArray)q.setTexture2DArray(xt,0),_r=35866;else{console.warn("THREE.WebGLRenderer.copyTextureToTexture3D: only supports THREE.DataTexture3D and THREE.DataTexture2DArray.");return}lt.pixelStorei(37440,xt.flipY),lt.pixelStorei(37441,xt.premultiplyAlpha),lt.pixelStorei(3317,xt.unpackAlignment);let Pr=lt.getParameter(3314),jn=lt.getParameter(32878),np=lt.getParameter(3316),um=lt.getParameter(3315),mr=lt.getParameter(32877),Fl=Et.isCompressedTexture?Et.mipmaps[0]:Et.image;lt.pixelStorei(3314,Fl.width),lt.pixelStorei(32878,Fl.height),lt.pixelStorei(3316,K.min.x),lt.pixelStorei(3315,K.min.y),lt.pixelStorei(32877,K.min.z),Et.isDataTexture||Et.isDataTexture3D?lt.texSubImage3D(_r,Ft,gt.x,gt.y,gt.z,Ve,Ue,tr,Ke,Xr,Fl.data):Et.isCompressedTexture?(console.warn("THREE.WebGLRenderer.copyTextureToTexture3D: untested support for compressed srcTexture."),lt.compressedTexSubImage3D(_r,Ft,gt.x,gt.y,gt.z,Ve,Ue,tr,Ke,Fl.data)):lt.texSubImage3D(_r,Ft,gt.x,gt.y,gt.z,Ve,Ue,tr,Ke,Xr,Fl),lt.pixelStorei(3314,Pr),lt.pixelStorei(32878,jn),lt.pixelStorei(3316,np),lt.pixelStorei(3315,um),lt.pixelStorei(32877,mr),Ft===0&&xt.generateMipmaps&&lt.generateMipmap(_r),X.unbindTexture()},this.initTexture=function(K){q.setTexture2D(K,0),X.unbindTexture()},this.resetState=function(){y=0,x=0,b=null,X.reset(),nt.reset()},typeof __THREE_DEVTOOLS__!="undefined"&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("observe",{detail:this}))}rn.prototype.isWebGLRenderer=!0;var gU=class extends rn{};gU.prototype.isWebGL1Renderer=!0;var O1=class{constructor(t,r=25e-5){this.name="",this.color=new ne(t),this.density=r}clone(){return new O1(this.color,this.density)}toJSON(){return{type:"FogExp2",color:this.color.getHex(),density:this.density}}};O1.prototype.isFogExp2=!0;var z1=class{constructor(t,r=1,n=1e3){this.name="",this.color=new ne(t),this.near=r,this.far=n}clone(){return new z1(this.color,this.near,this.far)}toJSON(){return{type:"Fog",color:this.color.getHex(),near:this.near,far:this.far}}};z1.prototype.isFog=!0;var q0=class extends or{constructor(){super(),this.type="Scene",this.background=null,this.environment=null,this.fog=null,this.overrideMaterial=null,this.autoUpdate=!0,typeof __THREE_DEVTOOLS__!="undefined"&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("observe",{detail:this}))}copy(t,r){return super.copy(t,r),t.background!==null&&(this.background=t.background.clone()),t.environment!==null&&(this.environment=t.environment.clone()),t.fog!==null&&(this.fog=t.fog.clone()),t.overrideMaterial!==null&&(this.overrideMaterial=t.overrideMaterial.clone()),this.autoUpdate=t.autoUpdate,this.matrixAutoUpdate=t.matrixAutoUpdate,this}toJSON(t){let r=super.toJSON(t);return this.fog!==null&&(r.object.fog=this.fog.toJSON()),r}};q0.prototype.isScene=!0;var em=class{constructor(t,r){this.array=t,this.stride=r,this.count=t!==void 0?t.length/r:0,this.usage=W3,this.updateRange={offset:0,count:-1},this.version=0,this.uuid=Nl()}onUploadCallback(){}set needsUpdate(t){t===!0&&this.version++}setUsage(t){return this.usage=t,this}copy(t){return this.array=new t.array.constructor(t.array),this.count=t.count,this.stride=t.stride,this.usage=t.usage,this}copyAt(t,r,n){t*=this.stride,n*=r.stride;for(let i=0,o=this.stride;i<o;i++)this.array[t+i]=r.array[n+i];return this}set(t,r=0){return this.array.set(t,r),this}clone(t){t.arrayBuffers===void 0&&(t.arrayBuffers={}),this.array.buffer._uuid===void 0&&(this.array.buffer._uuid=Nl()),t.arrayBuffers[this.array.buffer._uuid]===void 0&&(t.arrayBuffers[this.array.buffer._uuid]=this.array.slice(0).buffer);let r=new this.array.constructor(t.arrayBuffers[this.array.buffer._uuid]),n=new this.constructor(r,this.stride);return n.setUsage(this.usage),n}onUpload(t){return this.onUploadCallback=t,this}toJSON(t){return t.arrayBuffers===void 0&&(t.arrayBuffers={}),this.array.buffer._uuid===void 0&&(this.array.buffer._uuid=Nl()),t.arrayBuffers[this.array.buffer._uuid]===void 0&&(t.arrayBuffers[this.array.buffer._uuid]=Array.prototype.slice.call(new Uint32Array(this.array.buffer))),{uuid:this.uuid,buffer:this.array.buffer._uuid,type:this.array.constructor.name,stride:this.stride}}};em.prototype.isInterleavedBuffer=!0;var Ai=new j,tp=class{constructor(t,r,n,i=!1){this.name="",this.data=t,this.itemSize=r,this.offset=n,this.normalized=i===!0}get count(){return this.data.count}get array(){return this.data.array}set needsUpdate(t){this.data.needsUpdate=t}applyMatrix4(t){for(let r=0,n=this.data.count;r<n;r++)Ai.x=this.getX(r),Ai.y=this.getY(r),Ai.z=this.getZ(r),Ai.applyMatrix4(t),this.setXYZ(r,Ai.x,Ai.y,Ai.z);return this}applyNormalMatrix(t){for(let r=0,n=this.count;r<n;r++)Ai.x=this.getX(r),Ai.y=this.getY(r),Ai.z=this.getZ(r),Ai.applyNormalMatrix(t),this.setXYZ(r,Ai.x,Ai.y,Ai.z);return this}transformDirection(t){for(let r=0,n=this.count;r<n;r++)Ai.x=this.getX(r),Ai.y=this.getY(r),Ai.z=this.getZ(r),Ai.transformDirection(t),this.setXYZ(r,Ai.x,Ai.y,Ai.z);return this}setX(t,r){return this.data.array[t*this.data.stride+this.offset]=r,this}setY(t,r){return this.data.array[t*this.data.stride+this.offset+1]=r,this}setZ(t,r){return this.data.array[t*this.data.stride+this.offset+2]=r,this}setW(t,r){return this.data.array[t*this.data.stride+this.offset+3]=r,this}getX(t){return this.data.array[t*this.data.stride+this.offset]}getY(t){return this.data.array[t*this.data.stride+this.offset+1]}getZ(t){return this.data.array[t*this.data.stride+this.offset+2]}getW(t){return this.data.array[t*this.data.stride+this.offset+3]}setXY(t,r,n){return t=t*this.data.stride+this.offset,this.data.array[t+0]=r,this.data.array[t+1]=n,this}setXYZ(t,r,n,i){return t=t*this.data.stride+this.offset,this.data.array[t+0]=r,this.data.array[t+1]=n,this.data.array[t+2]=i,this}setXYZW(t,r,n,i,o){return t=t*this.data.stride+this.offset,this.data.array[t+0]=r,this.data.array[t+1]=n,this.data.array[t+2]=i,this.data.array[t+3]=o,this}clone(t){if(t===void 0){console.log("THREE.InterleavedBufferAttribute.clone(): Cloning an interlaved buffer attribute will deinterleave buffer data.");let r=[];for(let n=0;n<this.count;n++){let i=n*this.data.stride+this.offset;for(let o=0;o<this.itemSize;o++)r.push(this.data.array[i+o])}return new Je(new this.array.constructor(r),this.itemSize,this.normalized)}else return t.interleavedBuffers===void 0&&(t.interleavedBuffers={}),t.interleavedBuffers[this.data.uuid]===void 0&&(t.interleavedBuffers[this.data.uuid]=this.data.clone(t)),new tp(t.interleavedBuffers[this.data.uuid],this.itemSize,this.offset,this.normalized)}toJSON(t){if(t===void 0){console.log("THREE.InterleavedBufferAttribute.toJSON(): Serializing an interlaved buffer attribute will deinterleave buffer data.");let r=[];for(let n=0;n<this.count;n++){let i=n*this.data.stride+this.offset;for(let o=0;o<this.itemSize;o++)r.push(this.data.array[i+o])}return{itemSize:this.itemSize,type:this.array.constructor.name,array:r,normalized:this.normalized}}else return t.interleavedBuffers===void 0&&(t.interleavedBuffers={}),t.interleavedBuffers[this.data.uuid]===void 0&&(t.interleavedBuffers[this.data.uuid]=this.data.toJSON(t)),{isInterleavedBufferAttribute:!0,itemSize:this.itemSize,data:this.data.uuid,offset:this.offset,normalized:this.normalized}}};tp.prototype.isInterleavedBufferAttribute=!0;var iM=class extends qi{constructor(t){super(),this.type="SpriteMaterial",this.color=new ne(16777215),this.map=null,this.alphaMap=null,this.rotation=0,this.sizeAttenuation=!0,this.transparent=!0,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.alphaMap=t.alphaMap,this.rotation=t.rotation,this.sizeAttenuation=t.sizeAttenuation,this}};iM.prototype.isSpriteMaterial=!0;var N3,DP=new j,D3=new j,O3=new j,z3=new Lt,OP=new Lt,tpe=new Me,LV=new j,zP=new j,kV=new j,Zue=new Lt,dut=new Lt,Jue=new Lt,oM=class extends or{constructor(t){if(super(),this.type="Sprite",N3===void 0){N3=new Pe;let r=new Float32Array([-.5,-.5,0,0,0,.5,-.5,0,1,0,.5,.5,0,1,1,-.5,.5,0,0,1]),n=new em(r,5);N3.setIndex([0,1,2,0,2,3]),N3.setAttribute("position",new tp(n,3,0,!1)),N3.setAttribute("uv",new tp(n,2,3,!1))}this.geometry=N3,this.material=t!==void 0?t:new iM,this.center=new Lt(.5,.5)}raycast(t,r){t.camera===null&&console.error('THREE.Sprite: "Raycaster.camera" needs to be set in order to raycast against sprites.'),D3.setFromMatrixScale(this.matrixWorld),tpe.copy(t.camera.matrixWorld),this.modelViewMatrix.multiplyMatrices(t.camera.matrixWorldInverse,this.matrixWorld),O3.setFromMatrixPosition(this.modelViewMatrix),t.camera.isPerspectiveCamera&&this.material.sizeAttenuation===!1&&D3.multiplyScalar(-O3.z);let n=this.material.rotation,i,o;n!==0&&(o=Math.cos(n),i=Math.sin(n));let a=this.center;RV(LV.set(-.5,-.5,0),O3,a,D3,i,o),RV(zP.set(.5,-.5,0),O3,a,D3,i,o),RV(kV.set(.5,.5,0),O3,a,D3,i,o),Zue.set(0,0),dut.set(1,0),Jue.set(1,1);let s=t.ray.intersectTriangle(LV,zP,kV,!1,DP);if(s===null&&(RV(zP.set(-.5,.5,0),O3,a,D3,i,o),dut.set(0,1),s=t.ray.intersectTriangle(LV,kV,zP,!1,DP),s===null))return;let l=t.ray.origin.distanceTo(DP);l<t.near||l>t.far||r.push({distance:l,point:DP.clone(),uv:oi.getUV(DP,LV,zP,kV,Zue,dut,Jue,new Lt),face:null,object:this})}copy(t){return super.copy(t),t.center!==void 0&&this.center.copy(t.center),this.material=t.material,this}};oM.prototype.isSprite=!0;function RV(e,t,r,n,i,o){z3.subVectors(e,r).addScalar(.5).multiply(n),i!==void 0?(OP.x=o*z3.x-i*z3.y,OP.y=i*z3.x+o*z3.y):OP.copy(z3),e.copy(t),e.x+=OP.x,e.y+=OP.y,e.applyMatrix4(tpe)}var NV=new j,Que=new j,_U=class extends or{constructor(){super(),this._currentLevel=0,this.type="LOD",Object.defineProperties(this,{levels:{enumerable:!0,value:[]},isLOD:{value:!0}}),this.autoUpdate=!0}copy(t){super.copy(t,!1);let r=t.levels;for(let n=0,i=r.length;n<i;n++){let o=r[n];this.addLevel(o.object.clone(),o.distance)}return this.autoUpdate=t.autoUpdate,this}addLevel(t,r=0){r=Math.abs(r);let n=this.levels,i;for(i=0;i<n.length&&!(r<n[i].distance);i++);return n.splice(i,0,{distance:r,object:t}),this.add(t),this}getCurrentLevel(){return this._currentLevel}getObjectForDistance(t){let r=this.levels;if(r.length>0){let n,i;for(n=1,i=r.length;n<i&&!(t<r[n].distance);n++);return r[n-1].object}return null}raycast(t,r){if(this.levels.length>0){NV.setFromMatrixPosition(this.matrixWorld);let i=t.ray.origin.distanceTo(NV);this.getObjectForDistance(i).raycast(t,r)}}update(t){let r=this.levels;if(r.length>1){NV.setFromMatrixPosition(t.matrixWorld),Que.setFromMatrixPosition(this.matrixWorld);let n=NV.distanceTo(Que)/t.zoom;r[0].object.visible=!0;let i,o;for(i=1,o=r.length;i<o&&n>=r[i].distance;i++)r[i-1].object.visible=!1,r[i].object.visible=!0;for(this._currentLevel=i-1;i<o;i++)r[i].object.visible=!1}}toJSON(t){let r=super.toJSON(t);this.autoUpdate===!1&&(r.object.autoUpdate=!1),r.object.levels=[];let n=this.levels;for(let i=0,o=n.length;i<o;i++){let a=n[i];r.object.levels.push({object:a.object.uuid,distance:a.distance})}return r}},the=new j,ehe=new en,rhe=new en,Dgr=new j,nhe=new Me,aM=class extends ti{constructor(t,r){super(t,r),this.type="SkinnedMesh",this.bindMode="attached",this.bindMatrix=new Me,this.bindMatrixInverse=new Me}copy(t){return super.copy(t),this.bindMode=t.bindMode,this.bindMatrix.copy(t.bindMatrix),this.bindMatrixInverse.copy(t.bindMatrixInverse),this.skeleton=t.skeleton,this}bind(t,r){this.skeleton=t,r===void 0&&(this.updateMatrixWorld(!0),this.skeleton.calculateInverses(),r=this.matrixWorld),this.bindMatrix.copy(r),this.bindMatrixInverse.copy(r).invert()}pose(){this.skeleton.pose()}normalizeSkinWeights(){let t=new en,r=this.geometry.attributes.skinWeight;for(let n=0,i=r.count;n<i;n++){t.x=r.getX(n),t.y=r.getY(n),t.z=r.getZ(n),t.w=r.getW(n);let o=1/t.manhattanLength();o!==1/0?t.multiplyScalar(o):t.set(1,0,0,0),r.setXYZW(n,t.x,t.y,t.z,t.w)}}updateMatrixWorld(t){super.updateMatrixWorld(t),this.bindMode==="attached"?this.bindMatrixInverse.copy(this.matrixWorld).invert():this.bindMode==="detached"?this.bindMatrixInverse.copy(this.bindMatrix).invert():console.warn("THREE.SkinnedMesh: Unrecognized bindMode: "+this.bindMode)}boneTransform(t,r){let n=this.skeleton,i=this.geometry;ehe.fromBufferAttribute(i.attributes.skinIndex,t),rhe.fromBufferAttribute(i.attributes.skinWeight,t),the.copy(r).applyMatrix4(this.bindMatrix),r.set(0,0,0);for(let o=0;o<4;o++){let a=rhe.getComponent(o);if(a!==0){let s=ehe.getComponent(o);nhe.multiplyMatrices(n.bones[s].matrixWorld,n.boneInverses[s]),r.addScaledVector(Dgr.copy(the).applyMatrix4(nhe),a)}}return r.applyMatrix4(this.bindMatrixInverse)}};aM.prototype.isSkinnedMesh=!0;var sM=class extends or{constructor(){super(),this.type="Bone"}};sM.prototype.isBone=!0;var Jd=class extends vi{constructor(t=null,r=1,n=1,i,o,a,s,l,c=Li,u=Li,h,f){super(null,a,s,l,c,u,i,o,h,f),this.image={data:t,width:r,height:n},this.magFilter=c,this.minFilter=u,this.generateMipmaps=!1,this.flipY=!1,this.unpackAlignment=1}};Jd.prototype.isDataTexture=!0;var ihe=new Me,Ogr=new Me,lM=class{constructor(t=[],r=[]){this.uuid=Nl(),this.bones=t.slice(0),this.boneInverses=r,this.boneMatrices=null,this.boneTexture=null,this.boneTextureSize=0,this.frame=-1,this.init()}init(){let t=this.bones,r=this.boneInverses;if(this.boneMatrices=new Float32Array(t.length*16),r.length===0)this.calculateInverses();else if(t.length!==r.length){console.warn("THREE.Skeleton: Number of inverse bone matrices does not match amount of bones."),this.boneInverses=[];for(let n=0,i=this.bones.length;n<i;n++)this.boneInverses.push(new Me)}}calculateInverses(){this.boneInverses.length=0;for(let t=0,r=this.bones.length;t<r;t++){let n=new Me;this.bones[t]&&n.copy(this.bones[t].matrixWorld).invert(),this.boneInverses.push(n)}}pose(){for(let t=0,r=this.bones.length;t<r;t++){let n=this.bones[t];n&&n.matrixWorld.copy(this.boneInverses[t]).invert()}for(let t=0,r=this.bones.length;t<r;t++){let n=this.bones[t];n&&(n.parent&&n.parent.isBone?(n.matrix.copy(n.parent.matrixWorld).invert(),n.matrix.multiply(n.matrixWorld)):n.matrix.copy(n.matrixWorld),n.matrix.decompose(n.position,n.quaternion,n.scale))}}update(){let t=this.bones,r=this.boneInverses,n=this.boneMatrices,i=this.boneTexture;for(let o=0,a=t.length;o<a;o++){let s=t[o]?t[o].matrixWorld:Ogr;ihe.multiplyMatrices(s,r[o]),ihe.toArray(n,o*16)}i!==null&&(i.needsUpdate=!0)}clone(){return new lM(this.bones,this.boneInverses)}computeBoneTexture(){let t=Math.sqrt(this.bones.length*4);t=zfe(t),t=Math.max(t,4);let r=new Float32Array(t*t*4);r.set(this.boneMatrices);let n=new Jd(r,t,t,Qo,jd);return n.needsUpdate=!0,this.boneMatrices=r,this.boneTexture=n,this.boneTextureSize=t,this}getBoneByName(t){for(let r=0,n=this.bones.length;r<n;r++){let i=this.bones[r];if(i.name===t)return i}}dispose(){this.boneTexture!==null&&(this.boneTexture.dispose(),this.boneTexture=null)}fromJSON(t,r){this.uuid=t.uuid;for(let n=0,i=t.bones.length;n<i;n++){let o=t.bones[n],a=r[o];a===void 0&&(console.warn("THREE.Skeleton: No bone found with UUID:",o),a=new sM),this.bones.push(a),this.boneInverses.push(new Me().fromArray(t.boneInverses[n]))}return this.init(),this}toJSON(){let t={metadata:{version:4.5,type:"Skeleton",generator:"Skeleton.toJSON"},bones:[],boneInverses:[]};t.uuid=this.uuid;let r=this.bones,n=this.boneInverses;for(let i=0,o=r.length;i<o;i++){let a=r[i];t.bones.push(a.uuid);let s=n[i];t.boneInverses.push(s.toArray())}return t}},rm=class extends Je{constructor(t,r,n,i=1){typeof n=="number"&&(i=n,n=!1,console.error("THREE.InstancedBufferAttribute: The constructor now expects normalized as the third argument.")),super(t,r,n),this.meshPerAttribute=i}copy(t){return super.copy(t),this.meshPerAttribute=t.meshPerAttribute,this}toJSON(){let t=super.toJSON();return t.meshPerAttribute=this.meshPerAttribute,t.isInstancedBufferAttribute=!0,t}};rm.prototype.isInstancedBufferAttribute=!0;var ohe=new Me,ahe=new Me,DV=[],FP=new ti,i6=class extends ti{constructor(t,r,n){super(t,r),this.instanceMatrix=new rm(new Float32Array(n*16),16),this.instanceColor=null,this.count=n,this.frustumCulled=!1}copy(t){return super.copy(t),this.instanceMatrix.copy(t.instanceMatrix),t.instanceColor!==null&&(this.instanceColor=t.instanceColor.clone()),this.count=t.count,this}getColorAt(t,r){r.fromArray(this.instanceColor.array,t*3)}getMatrixAt(t,r){r.fromArray(this.instanceMatrix.array,t*16)}raycast(t,r){let n=this.matrixWorld,i=this.count;if(FP.geometry=this.geometry,FP.material=this.material,FP.material!==void 0)for(let o=0;o<i;o++){this.getMatrixAt(o,ohe),ahe.multiplyMatrices(n,ohe),FP.matrixWorld=ahe,FP.raycast(t,DV);for(let a=0,s=DV.length;a<s;a++){let l=DV[a];l.instanceId=o,l.object=this,r.push(l)}DV.length=0}}setColorAt(t,r){this.instanceColor===null&&(this.instanceColor=new rm(new Float32Array(this.instanceMatrix.count*3),3)),r.toArray(this.instanceColor.array,t*3)}setMatrixAt(t,r){r.toArray(this.instanceMatrix.array,t*16)}updateMorphTargets(){}dispose(){this.dispatchEvent({type:"dispose"})}};i6.prototype.isInstancedMesh=!0;var Gi=class extends qi{constructor(t){super(),this.type="LineBasicMaterial",this.color=new ne(16777215),this.linewidth=1,this.linecap="round",this.linejoin="round",this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.linewidth=t.linewidth,this.linecap=t.linecap,this.linejoin=t.linejoin,this}};Gi.prototype.isLineBasicMaterial=!0;var she=new j,lhe=new j,che=new Me,mut=new Jf,OV=new Zf,ch=class extends or{constructor(t=new Pe,r=new Gi){super(),this.type="Line",this.geometry=t,this.material=r,this.updateMorphTargets()}copy(t){return super.copy(t),this.material=t.material,this.geometry=t.geometry,this}computeLineDistances(){let t=this.geometry;if(t.isBufferGeometry)if(t.index===null){let r=t.attributes.position,n=[0];for(let i=1,o=r.count;i<o;i++)she.fromBufferAttribute(r,i-1),lhe.fromBufferAttribute(r,i),n[i]=n[i-1],n[i]+=she.distanceTo(lhe);t.setAttribute("lineDistance",new xe(n,1))}else console.warn("THREE.Line.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.");else t.isGeometry&&console.error("THREE.Line.computeLineDistances() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.");return this}raycast(t,r){let n=this.geometry,i=this.matrixWorld,o=t.params.Line.threshold,a=n.drawRange;if(n.boundingSphere===null&&n.computeBoundingSphere(),OV.copy(n.boundingSphere),OV.applyMatrix4(i),OV.radius+=o,t.ray.intersectsSphere(OV)===!1)return;che.copy(i).invert(),mut.copy(t.ray).applyMatrix4(che);let s=o/((this.scale.x+this.scale.y+this.scale.z)/3),l=s*s,c=new j,u=new j,h=new j,f=new j,p=this.isLineSegments?2:1;if(n.isBufferGeometry){let d=n.index,_=n.attributes.position;if(d!==null){let y=Math.max(0,a.start),x=Math.min(d.count,a.start+a.count);for(let b=y,S=x-1;b<S;b+=p){let C=d.getX(b),P=d.getX(b+1);if(c.fromBufferAttribute(_,C),u.fromBufferAttribute(_,P),mut.distanceSqToSegment(c,u,f,h)>l)continue;f.applyMatrix4(this.matrixWorld);let O=t.ray.origin.distanceTo(f);O<t.near||O>t.far||r.push({distance:O,point:h.clone().applyMatrix4(this.matrixWorld),index:b,face:null,faceIndex:null,object:this})}}else{let y=Math.max(0,a.start),x=Math.min(_.count,a.start+a.count);for(let b=y,S=x-1;b<S;b+=p){if(c.fromBufferAttribute(_,b),u.fromBufferAttribute(_,b+1),mut.distanceSqToSegment(c,u,f,h)>l)continue;f.applyMatrix4(this.matrixWorld);let P=t.ray.origin.distanceTo(f);P<t.near||P>t.far||r.push({distance:P,point:h.clone().applyMatrix4(this.matrixWorld),index:b,face:null,faceIndex:null,object:this})}}}else n.isGeometry&&console.error("THREE.Line.raycast() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}updateMorphTargets(){let t=this.geometry;if(t.isBufferGeometry){let r=t.morphAttributes,n=Object.keys(r);if(n.length>0){let i=r[n[0]];if(i!==void 0){this.morphTargetInfluences=[],this.morphTargetDictionary={};for(let o=0,a=i.length;o<a;o++){let s=i[o].name||String(o);this.morphTargetInfluences.push(0),this.morphTargetDictionary[s]=o}}}}else{let r=t.morphTargets;r!==void 0&&r.length>0&&console.error("THREE.Line.updateMorphTargets() does not support THREE.Geometry. Use THREE.BufferGeometry instead.")}}};ch.prototype.isLine=!0;var uhe=new j,hhe=new j,Aa=class extends ch{constructor(t,r){super(t,r),this.type="LineSegments"}computeLineDistances(){let t=this.geometry;if(t.isBufferGeometry)if(t.index===null){let r=t.attributes.position,n=[];for(let i=0,o=r.count;i<o;i+=2)uhe.fromBufferAttribute(r,i),hhe.fromBufferAttribute(r,i+1),n[i]=i===0?0:n[i-1],n[i+1]=n[i]+uhe.distanceTo(hhe);t.setAttribute("lineDistance",new xe(n,1))}else console.warn("THREE.LineSegments.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.");else t.isGeometry&&console.error("THREE.LineSegments.computeLineDistances() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.");return this}};Aa.prototype.isLineSegments=!0;var o6=class extends ch{constructor(t,r){super(t,r),this.type="LineLoop"}};o6.prototype.isLineLoop=!0;var nm=class extends qi{constructor(t){super(),this.type="PointsMaterial",this.color=new ne(16777215),this.map=null,this.alphaMap=null,this.size=1,this.sizeAttenuation=!0,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.alphaMap=t.alphaMap,this.size=t.size,this.sizeAttenuation=t.sizeAttenuation,this}};nm.prototype.isPointsMaterial=!0;var fhe=new Me,rht=new Jf,zV=new Zf,FV=new j,im=class extends or{constructor(t=new Pe,r=new nm){super(),this.type="Points",this.geometry=t,this.material=r,this.updateMorphTargets()}copy(t){return super.copy(t),this.material=t.material,this.geometry=t.geometry,this}raycast(t,r){let n=this.geometry,i=this.matrixWorld,o=t.params.Points.threshold,a=n.drawRange;if(n.boundingSphere===null&&n.computeBoundingSphere(),zV.copy(n.boundingSphere),zV.applyMatrix4(i),zV.radius+=o,t.ray.intersectsSphere(zV)===!1)return;fhe.copy(i).invert(),rht.copy(t.ray).applyMatrix4(fhe);let s=o/((this.scale.x+this.scale.y+this.scale.z)/3),l=s*s;if(n.isBufferGeometry){let c=n.index,h=n.attributes.position;if(c!==null){let f=Math.max(0,a.start),p=Math.min(c.count,a.start+a.count);for(let d=f,g=p;d<g;d++){let _=c.getX(d);FV.fromBufferAttribute(h,_),phe(FV,_,l,i,t,r,this)}}else{let f=Math.max(0,a.start),p=Math.min(h.count,a.start+a.count);for(let d=f,g=p;d<g;d++)FV.fromBufferAttribute(h,d),phe(FV,d,l,i,t,r,this)}}else console.error("THREE.Points.raycast() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}updateMorphTargets(){let t=this.geometry;if(t.isBufferGeometry){let r=t.morphAttributes,n=Object.keys(r);if(n.length>0){let i=r[n[0]];if(i!==void 0){this.morphTargetInfluences=[],this.morphTargetDictionary={};for(let o=0,a=i.length;o<a;o++){let s=i[o].name||String(o);this.morphTargetInfluences.push(0),this.morphTargetDictionary[s]=o}}}}else{let r=t.morphTargets;r!==void 0&&r.length>0&&console.error("THREE.Points.updateMorphTargets() does not support THREE.Geometry. Use THREE.BufferGeometry instead.")}}};im.prototype.isPoints=!0;function phe(e,t,r,n,i,o,a){let s=rht.distanceSqToPoint(e);if(s<r){let l=new j;rht.closestPointToPoint(e,l),l.applyMatrix4(n);let c=i.ray.origin.distanceTo(l);if(c<i.near||c>i.far)return;o.push({distance:c,distanceToRay:Math.sqrt(s),point:l,index:t,face:null,object:a})}}var yU=class extends vi{constructor(t,r,n,i,o,a,s,l,c){super(t,r,n,i,o,a,s,l,c),this.minFilter=a!==void 0?a:ii,this.magFilter=o!==void 0?o:ii,this.generateMipmaps=!1;let u=this;function h(){u.needsUpdate=!0,t.requestVideoFrameCallback(h)}"requestVideoFrameCallback"in t&&t.requestVideoFrameCallback(h)}clone(){return new this.constructor(this.image).copy(this)}update(){let t=this.image;"requestVideoFrameCallback"in t===!1&&t.readyState>=t.HAVE_CURRENT_DATA&&(this.needsUpdate=!0)}};yU.prototype.isVideoTexture=!0;var vU=class extends vi{constructor(t,r,n){super({width:t,height:r}),this.format=n,this.magFilter=Li,this.minFilter=Li,this.generateMipmaps=!1,this.needsUpdate=!0}};vU.prototype.isFramebufferTexture=!0;var a6=class extends vi{constructor(t,r,n,i,o,a,s,l,c,u,h,f){super(null,a,s,l,c,u,i,o,h,f),this.image={width:r,height:n},this.mipmaps=t,this.flipY=!1,this.generateMipmaps=!1}};a6.prototype.isCompressedTexture=!0;var xU=class extends vi{constructor(t,r,n,i,o,a,s,l,c){super(t,r,n,i,o,a,s,l,c),this.needsUpdate=!0}};xU.prototype.isCanvasTexture=!0;var F1=class extends Pe{constructor(t=1,r=8,n=0,i=Math.PI*2){super(),this.type="CircleGeometry",this.parameters={radius:t,segments:r,thetaStart:n,thetaLength:i},r=Math.max(3,r);let o=[],a=[],s=[],l=[],c=new j,u=new Lt;a.push(0,0,0),s.push(0,0,1),l.push(.5,.5);for(let h=0,f=3;h<=r;h++,f+=3){let p=n+h/r*i;c.x=t*Math.cos(p),c.y=t*Math.sin(p),a.push(c.x,c.y,c.z),s.push(0,0,1),u.x=(a[f]/t+1)/2,u.y=(a[f+1]/t+1)/2,l.push(u.x,u.y)}for(let h=1;h<=r;h++)o.push(h,h+1,0);this.setIndex(o),this.setAttribute("position",new xe(a,3)),this.setAttribute("normal",new xe(s,3)),this.setAttribute("uv",new xe(l,2))}static fromJSON(t){return new F1(t.radius,t.segments,t.thetaStart,t.thetaLength)}},om=class extends Pe{constructor(t=1,r=1,n=1,i=8,o=1,a=!1,s=0,l=Math.PI*2){super(),this.type="CylinderGeometry",this.parameters={radiusTop:t,radiusBottom:r,height:n,radialSegments:i,heightSegments:o,openEnded:a,thetaStart:s,thetaLength:l};let c=this;i=Math.floor(i),o=Math.floor(o);let u=[],h=[],f=[],p=[],d=0,g=[],_=n/2,y=0;x(),a===!1&&(t>0&&b(!0),r>0&&b(!1)),this.setIndex(u),this.setAttribute("position",new xe(h,3)),this.setAttribute("normal",new xe(f,3)),this.setAttribute("uv",new xe(p,2));function x(){let S=new j,C=new j,P=0,k=(r-t)/n;for(let O=0;O<=o;O++){let D=[],B=O/o,I=B*(r-t)+t;for(let L=0;L<=i;L++){let R=L/i,F=R*l+s,z=Math.sin(F),U=Math.cos(F);C.x=I*z,C.y=-B*n+_,C.z=I*U,h.push(C.x,C.y,C.z),S.set(z,k,U).normalize(),f.push(S.x,S.y,S.z),p.push(R,1-B),D.push(d++)}g.push(D)}for(let O=0;O<i;O++)for(let D=0;D<o;D++){let B=g[D][O],I=g[D+1][O],L=g[D+1][O+1],R=g[D][O+1];u.push(B,I,R),u.push(I,L,R),P+=6}c.addGroup(y,P,0),y+=P}function b(S){let C=d,P=new Lt,k=new j,O=0,D=S===!0?t:r,B=S===!0?1:-1;for(let L=1;L<=i;L++)h.push(0,_*B,0),f.push(0,B,0),p.push(.5,.5),d++;let I=d;for(let L=0;L<=i;L++){let F=L/i*l+s,z=Math.cos(F),U=Math.sin(F);k.x=D*U,k.y=_*B,k.z=D*z,h.push(k.x,k.y,k.z),f.push(0,B,0),P.x=z*.5+.5,P.y=U*.5*B+.5,p.push(P.x,P.y),d++}for(let L=0;L<i;L++){let R=C+L,F=I+L;S===!0?u.push(F,F+1,R):u.push(F+1,F,R),O+=3}c.addGroup(y,O,S===!0?1:2),y+=O}}static fromJSON(t){return new om(t.radiusTop,t.radiusBottom,t.height,t.radialSegments,t.heightSegments,t.openEnded,t.thetaStart,t.thetaLength)}},B1=class extends om{constructor(t=1,r=1,n=8,i=1,o=!1,a=0,s=Math.PI*2){super(0,t,r,n,i,o,a,s),this.type="ConeGeometry",this.parameters={radius:t,height:r,radialSegments:n,heightSegments:i,openEnded:o,thetaStart:a,thetaLength:s}}static fromJSON(t){return new B1(t.radius,t.height,t.radialSegments,t.heightSegments,t.openEnded,t.thetaStart,t.thetaLength)}},uh=class extends Pe{constructor(t=[],r=[],n=1,i=0){super(),this.type="PolyhedronGeometry",this.parameters={vertices:t,indices:r,radius:n,detail:i};let o=[],a=[];s(i),c(n),u(),this.setAttribute("position",new xe(o,3)),this.setAttribute("normal",new xe(o.slice(),3)),this.setAttribute("uv",new xe(a,2)),i===0?this.computeVertexNormals():this.normalizeNormals();function s(x){let b=new j,S=new j,C=new j;for(let P=0;P<r.length;P+=3)p(r[P+0],b),p(r[P+1],S),p(r[P+2],C),l(b,S,C,x)}function l(x,b,S,C){let P=C+1,k=[];for(let O=0;O<=P;O++){k[O]=[];let D=x.clone().lerp(S,O/P),B=b.clone().lerp(S,O/P),I=P-O;for(let L=0;L<=I;L++)L===0&&O===P?k[O][L]=D:k[O][L]=D.clone().lerp(B,L/I)}for(let O=0;O<P;O++)for(let D=0;D<2*(P-O)-1;D++){let B=Math.floor(D/2);D%2===0?(f(k[O][B+1]),f(k[O+1][B]),f(k[O][B])):(f(k[O][B+1]),f(k[O+1][B+1]),f(k[O+1][B]))}}function c(x){let b=new j;for(let S=0;S<o.length;S+=3)b.x=o[S+0],b.y=o[S+1],b.z=o[S+2],b.normalize().multiplyScalar(x),o[S+0]=b.x,o[S+1]=b.y,o[S+2]=b.z}function u(){let x=new j;for(let b=0;b<o.length;b+=3){x.x=o[b+0],x.y=o[b+1],x.z=o[b+2];let S=_(x)/2/Math.PI+.5,C=y(x)/Math.PI+.5;a.push(S,1-C)}d(),h()}function h(){for(let x=0;x<a.length;x+=6){let b=a[x+0],S=a[x+2],C=a[x+4],P=Math.max(b,S,C),k=Math.min(b,S,C);P>.9&&k<.1&&(b<.2&&(a[x+0]+=1),S<.2&&(a[x+2]+=1),C<.2&&(a[x+4]+=1))}}function f(x){o.push(x.x,x.y,x.z)}function p(x,b){let S=x*3;b.x=t[S+0],b.y=t[S+1],b.z=t[S+2]}function d(){let x=new j,b=new j,S=new j,C=new j,P=new Lt,k=new Lt,O=new Lt;for(let D=0,B=0;D<o.length;D+=9,B+=6){x.set(o[D+0],o[D+1],o[D+2]),b.set(o[D+3],o[D+4],o[D+5]),S.set(o[D+6],o[D+7],o[D+8]),P.set(a[B+0],a[B+1]),k.set(a[B+2],a[B+3]),O.set(a[B+4],a[B+5]),C.copy(x).add(b).add(S).divideScalar(3);let I=_(C);g(P,B+0,x,I),g(k,B+2,b,I),g(O,B+4,S,I)}}function g(x,b,S,C){C<0&&x.x===1&&(a[b]=x.x-1),S.x===0&&S.z===0&&(a[b]=C/2/Math.PI+.5)}function _(x){return Math.atan2(x.z,-x.x)}function y(x){return Math.atan2(-x.y,Math.sqrt(x.x*x.x+x.z*x.z))}}static fromJSON(t){return new uh(t.vertices,t.indices,t.radius,t.details)}},H1=class extends uh{constructor(t=1,r=0){let n=(1+Math.sqrt(5))/2,i=1/n,o=[-1,-1,-1,-1,-1,1,-1,1,-1,-1,1,1,1,-1,-1,1,-1,1,1,1,-1,1,1,1,0,-i,-n,0,-i,n,0,i,-n,0,i,n,-i,-n,0,-i,n,0,i,-n,0,i,n,0,-n,0,-i,n,0,-i,-n,0,i,n,0,i],a=[3,11,7,3,7,15,3,15,13,7,19,17,7,17,6,7,6,15,17,4,8,17,8,10,17,10,6,8,0,16,8,16,2,8,2,10,0,12,1,0,1,18,0,18,16,6,10,2,6,2,13,6,13,15,2,16,18,2,18,3,2,3,13,18,1,9,18,9,11,18,11,3,4,14,12,4,12,0,4,0,8,11,9,5,11,5,19,11,19,7,19,5,14,19,14,4,19,4,17,1,12,14,1,14,5,1,5,9];super(o,a,t,r),this.type="DodecahedronGeometry",this.parameters={radius:t,detail:r}}static fromJSON(t){return new H1(t.radius,t.detail)}},BV=new j,HV=new j,gut=new j,VV=new oi,s6=class extends Pe{constructor(t=null,r=1){if(super(),this.type="EdgesGeometry",this.parameters={geometry:t,thresholdAngle:r},t!==null){let i=Math.pow(10,4),o=Math.cos(P1*r),a=t.getIndex(),s=t.getAttribute("position"),l=a?a.count:s.count,c=[0,0,0],u=["a","b","c"],h=new Array(3),f={},p=[];for(let d=0;d<l;d+=3){a?(c[0]=a.getX(d),c[1]=a.getX(d+1),c[2]=a.getX(d+2)):(c[0]=d,c[1]=d+1,c[2]=d+2);let{a:g,b:_,c:y}=VV;if(g.fromBufferAttribute(s,c[0]),_.fromBufferAttribute(s,c[1]),y.fromBufferAttribute(s,c[2]),VV.getNormal(gut),h[0]=`${Math.round(g.x*i)},${Math.round(g.y*i)},${Math.round(g.z*i)}`,h[1]=`${Math.round(_.x*i)},${Math.round(_.y*i)},${Math.round(_.z*i)}`,h[2]=`${Math.round(y.x*i)},${Math.round(y.y*i)},${Math.round(y.z*i)}`,!(h[0]===h[1]||h[1]===h[2]||h[2]===h[0]))for(let x=0;x<3;x++){let b=(x+1)%3,S=h[x],C=h[b],P=VV[u[x]],k=VV[u[b]],O=`${S}_${C}`,D=`${C}_${S}`;D in f&&f[D]?(gut.dot(f[D].normal)<=o&&(p.push(P.x,P.y,P.z),p.push(k.x,k.y,k.z)),f[D]=null):O in f||(f[O]={index0:c[x],index1:c[b],normal:gut.clone()})}}for(let d in f)if(f[d]){let{index0:g,index1:_}=f[d];BV.fromBufferAttribute(s,g),HV.fromBufferAttribute(s,_),p.push(BV.x,BV.y,BV.z),p.push(HV.x,HV.y,HV.z)}this.setAttribute("position",new xe(p,3))}}},fs=class{constructor(){this.type="Curve",this.arcLengthDivisions=200}getPoint(){return console.warn("THREE.Curve: .getPoint() not implemented."),null}getPointAt(t,r){let n=this.getUtoTmapping(t);return this.getPoint(n,r)}getPoints(t=5){let r=[];for(let n=0;n<=t;n++)r.push(this.getPoint(n/t));return r}getSpacedPoints(t=5){let r=[];for(let n=0;n<=t;n++)r.push(this.getPointAt(n/t));return r}getLength(){let t=this.getLengths();return t[t.length-1]}getLengths(t=this.arcLengthDivisions){if(this.cacheArcLengths&&this.cacheArcLengths.length===t+1&&!this.needsUpdate)return this.cacheArcLengths;this.needsUpdate=!1;let r=[],n,i=this.getPoint(0),o=0;r.push(0);for(let a=1;a<=t;a++)n=this.getPoint(a/t),o+=n.distanceTo(i),r.push(o),i=n;return this.cacheArcLengths=r,r}updateArcLengths(){this.needsUpdate=!0,this.getLengths()}getUtoTmapping(t,r){let n=this.getLengths(),i=0,o=n.length,a;r?a=r:a=t*n[o-1];let s=0,l=o-1,c;for(;s<=l;)if(i=Math.floor(s+(l-s)/2),c=n[i]-a,c<0)s=i+1;else if(c>0)l=i-1;else{l=i;break}if(i=l,n[i]===a)return i/(o-1);let u=n[i],f=n[i+1]-u,p=(a-u)/f;return(i+p)/(o-1)}getTangent(t,r){let i=t-1e-4,o=t+1e-4;i<0&&(i=0),o>1&&(o=1);let a=this.getPoint(i),s=this.getPoint(o),l=r||(a.isVector2?new Lt:new j);return l.copy(s).sub(a).normalize(),l}getTangentAt(t,r){let n=this.getUtoTmapping(t);return this.getTangent(n,r)}computeFrenetFrames(t,r){let n=new j,i=[],o=[],a=[],s=new j,l=new Me;for(let p=0;p<=t;p++){let d=p/t;i[p]=this.getTangentAt(d,new j)}o[0]=new j,a[0]=new j;let c=Number.MAX_VALUE,u=Math.abs(i[0].x),h=Math.abs(i[0].y),f=Math.abs(i[0].z);u<=c&&(c=u,n.set(1,0,0)),h<=c&&(c=h,n.set(0,1,0)),f<=c&&n.set(0,0,1),s.crossVectors(i[0],n).normalize(),o[0].crossVectors(i[0],s),a[0].crossVectors(i[0],o[0]);for(let p=1;p<=t;p++){if(o[p]=o[p-1].clone(),a[p]=a[p-1].clone(),s.crossVectors(i[p-1],i[p]),s.length()>Number.EPSILON){s.normalize();let d=Math.acos(Zo(i[p-1].dot(i[p]),-1,1));o[p].applyMatrix4(l.makeRotationAxis(s,d))}a[p].crossVectors(i[p],o[p])}if(r===!0){let p=Math.acos(Zo(o[0].dot(o[t]),-1,1));p/=t,i[0].dot(s.crossVectors(o[0],o[t]))>0&&(p=-p);for(let d=1;d<=t;d++)o[d].applyMatrix4(l.makeRotationAxis(i[d],p*d)),a[d].crossVectors(i[d],o[d])}return{tangents:i,normals:o,binormals:a}}clone(){return new this.constructor().copy(this)}copy(t){return this.arcLengthDivisions=t.arcLengthDivisions,this}toJSON(){let t={metadata:{version:4.5,type:"Curve",generator:"Curve.toJSON"}};return t.arcLengthDivisions=this.arcLengthDivisions,t.type=this.type,t}fromJSON(t){return this.arcLengthDivisions=t.arcLengthDivisions,this}},V1=class extends fs{constructor(t=0,r=0,n=1,i=1,o=0,a=Math.PI*2,s=!1,l=0){super(),this.type="EllipseCurve",this.aX=t,this.aY=r,this.xRadius=n,this.yRadius=i,this.aStartAngle=o,this.aEndAngle=a,this.aClockwise=s,this.aRotation=l}getPoint(t,r){let n=r||new Lt,i=Math.PI*2,o=this.aEndAngle-this.aStartAngle,a=Math.abs(o)<Number.EPSILON;for(;o<0;)o+=i;for(;o>i;)o-=i;o<Number.EPSILON&&(a?o=0:o=i),this.aClockwise===!0&&!a&&(o===i?o=-i:o=o-i);let s=this.aStartAngle+t*o,l=this.aX+this.xRadius*Math.cos(s),c=this.aY+this.yRadius*Math.sin(s);if(this.aRotation!==0){let u=Math.cos(this.aRotation),h=Math.sin(this.aRotation),f=l-this.aX,p=c-this.aY;l=f*u-p*h+this.aX,c=f*h+p*u+this.aY}return n.set(l,c)}copy(t){return super.copy(t),this.aX=t.aX,this.aY=t.aY,this.xRadius=t.xRadius,this.yRadius=t.yRadius,this.aStartAngle=t.aStartAngle,this.aEndAngle=t.aEndAngle,this.aClockwise=t.aClockwise,this.aRotation=t.aRotation,this}toJSON(){let t=super.toJSON();return t.aX=this.aX,t.aY=this.aY,t.xRadius=this.xRadius,t.yRadius=this.yRadius,t.aStartAngle=this.aStartAngle,t.aEndAngle=this.aEndAngle,t.aClockwise=this.aClockwise,t.aRotation=this.aRotation,t}fromJSON(t){return super.fromJSON(t),this.aX=t.aX,this.aY=t.aY,this.xRadius=t.xRadius,this.yRadius=t.yRadius,this.aStartAngle=t.aStartAngle,this.aEndAngle=t.aEndAngle,this.aClockwise=t.aClockwise,this.aRotation=t.aRotation,this}};V1.prototype.isEllipseCurve=!0;var l6=class extends V1{constructor(t,r,n,i,o,a){super(t,r,n,n,i,o,a),this.type="ArcCurve"}};l6.prototype.isArcCurve=!0;function Dht(){let e=0,t=0,r=0,n=0;function i(o,a,s,l){e=o,t=s,r=-3*o+3*a-2*s-l,n=2*o-2*a+s+l}return{initCatmullRom:function(o,a,s,l,c){i(a,s,c*(s-o),c*(l-a))},initNonuniformCatmullRom:function(o,a,s,l,c,u,h){let f=(a-o)/c-(s-o)/(c+u)+(s-a)/u,p=(s-a)/u-(l-a)/(u+h)+(l-s)/h;f*=u,p*=u,i(a,s,f,p)},calc:function(o){let a=o*o,s=a*o;return e+t*o+r*a+n*s}}}var UV=new j,_ut=new Dht,yut=new Dht,vut=new Dht,c6=class extends fs{constructor(t=[],r=!1,n="centripetal",i=.5){super(),this.type="CatmullRomCurve3",this.points=t,this.closed=r,this.curveType=n,this.tension=i}getPoint(t,r=new j){let n=r,i=this.points,o=i.length,a=(o-(this.closed?0:1))*t,s=Math.floor(a),l=a-s;this.closed?s+=s>0?0:(Math.floor(Math.abs(s)/o)+1)*o:l===0&&s===o-1&&(s=o-2,l=1);let c,u;this.closed||s>0?c=i[(s-1)%o]:(UV.subVectors(i[0],i[1]).add(i[0]),c=UV);let h=i[s%o],f=i[(s+1)%o];if(this.closed||s+2<o?u=i[(s+2)%o]:(UV.subVectors(i[o-1],i[o-2]).add(i[o-1]),u=UV),this.curveType==="centripetal"||this.curveType==="chordal"){let p=this.curveType==="chordal"?.5:.25,d=Math.pow(c.distanceToSquared(h),p),g=Math.pow(h.distanceToSquared(f),p),_=Math.pow(f.distanceToSquared(u),p);g<1e-4&&(g=1),d<1e-4&&(d=g),_<1e-4&&(_=g),_ut.initNonuniformCatmullRom(c.x,h.x,f.x,u.x,d,g,_),yut.initNonuniformCatmullRom(c.y,h.y,f.y,u.y,d,g,_),vut.initNonuniformCatmullRom(c.z,h.z,f.z,u.z,d,g,_)}else this.curveType==="catmullrom"&&(_ut.initCatmullRom(c.x,h.x,f.x,u.x,this.tension),yut.initCatmullRom(c.y,h.y,f.y,u.y,this.tension),vut.initCatmullRom(c.z,h.z,f.z,u.z,this.tension));return n.set(_ut.calc(l),yut.calc(l),vut.calc(l)),n}copy(t){super.copy(t),this.points=[];for(let r=0,n=t.points.length;r<n;r++){let i=t.points[r];this.points.push(i.clone())}return this.closed=t.closed,this.curveType=t.curveType,this.tension=t.tension,this}toJSON(){let t=super.toJSON();t.points=[];for(let r=0,n=this.points.length;r<n;r++){let i=this.points[r];t.points.push(i.toArray())}return t.closed=this.closed,t.curveType=this.curveType,t.tension=this.tension,t}fromJSON(t){super.fromJSON(t),this.points=[];for(let r=0,n=t.points.length;r<n;r++){let i=t.points[r];this.points.push(new j().fromArray(i))}return this.closed=t.closed,this.curveType=t.curveType,this.tension=t.tension,this}};c6.prototype.isCatmullRomCurve3=!0;function dhe(e,t,r,n,i){let o=(n-t)*.5,a=(i-r)*.5,s=e*e,l=e*s;return(2*r-2*n+o+a)*l+(-3*r+3*n-2*o-a)*s+o*e+r}function zgr(e,t){let r=1-e;return r*r*t}function Fgr(e,t){return 2*(1-e)*e*t}function Bgr(e,t){return e*e*t}function GP(e,t,r,n){return zgr(e,t)+Fgr(e,r)+Bgr(e,n)}function Hgr(e,t){let r=1-e;return r*r*r*t}function Vgr(e,t){let r=1-e;return 3*r*r*e*t}function Ugr(e,t){return 3*(1-e)*e*e*t}function qgr(e,t){return e*e*e*t}function WP(e,t,r,n,i){return Hgr(e,t)+Vgr(e,r)+Ugr(e,n)+qgr(e,i)}var cM=class extends fs{constructor(t=new Lt,r=new Lt,n=new Lt,i=new Lt){super(),this.type="CubicBezierCurve",this.v0=t,this.v1=r,this.v2=n,this.v3=i}getPoint(t,r=new Lt){let n=r,i=this.v0,o=this.v1,a=this.v2,s=this.v3;return n.set(WP(t,i.x,o.x,a.x,s.x),WP(t,i.y,o.y,a.y,s.y)),n}copy(t){return super.copy(t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this.v3.copy(t.v3),this}toJSON(){let t=super.toJSON();return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t.v3=this.v3.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this.v3.fromArray(t.v3),this}};cM.prototype.isCubicBezierCurve=!0;var u6=class extends fs{constructor(t=new j,r=new j,n=new j,i=new j){super(),this.type="CubicBezierCurve3",this.v0=t,this.v1=r,this.v2=n,this.v3=i}getPoint(t,r=new j){let n=r,i=this.v0,o=this.v1,a=this.v2,s=this.v3;return n.set(WP(t,i.x,o.x,a.x,s.x),WP(t,i.y,o.y,a.y,s.y),WP(t,i.z,o.z,a.z,s.z)),n}copy(t){return super.copy(t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this.v3.copy(t.v3),this}toJSON(){let t=super.toJSON();return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t.v3=this.v3.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this.v3.fromArray(t.v3),this}};u6.prototype.isCubicBezierCurve3=!0;var U1=class extends fs{constructor(t=new Lt,r=new Lt){super(),this.type="LineCurve",this.v1=t,this.v2=r}getPoint(t,r=new Lt){let n=r;return t===1?n.copy(this.v2):(n.copy(this.v2).sub(this.v1),n.multiplyScalar(t).add(this.v1)),n}getPointAt(t,r){return this.getPoint(t,r)}getTangent(t,r){let n=r||new Lt;return n.copy(this.v2).sub(this.v1).normalize(),n}copy(t){return super.copy(t),this.v1.copy(t.v1),this.v2.copy(t.v2),this}toJSON(){let t=super.toJSON();return t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this}};U1.prototype.isLineCurve=!0;var bU=class extends fs{constructor(t=new j,r=new j){super(),this.type="LineCurve3",this.isLineCurve3=!0,this.v1=t,this.v2=r}getPoint(t,r=new j){let n=r;return t===1?n.copy(this.v2):(n.copy(this.v2).sub(this.v1),n.multiplyScalar(t).add(this.v1)),n}getPointAt(t,r){return this.getPoint(t,r)}copy(t){return super.copy(t),this.v1.copy(t.v1),this.v2.copy(t.v2),this}toJSON(){let t=super.toJSON();return t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this}},uM=class extends fs{constructor(t=new Lt,r=new Lt,n=new Lt){super(),this.type="QuadraticBezierCurve",this.v0=t,this.v1=r,this.v2=n}getPoint(t,r=new Lt){let n=r,i=this.v0,o=this.v1,a=this.v2;return n.set(GP(t,i.x,o.x,a.x),GP(t,i.y,o.y,a.y)),n}copy(t){return super.copy(t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this}toJSON(){let t=super.toJSON();return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this}};uM.prototype.isQuadraticBezierCurve=!0;var hM=class extends fs{constructor(t=new j,r=new j,n=new j){super(),this.type="QuadraticBezierCurve3",this.v0=t,this.v1=r,this.v2=n}getPoint(t,r=new j){let n=r,i=this.v0,o=this.v1,a=this.v2;return n.set(GP(t,i.x,o.x,a.x),GP(t,i.y,o.y,a.y),GP(t,i.z,o.z,a.z)),n}copy(t){return super.copy(t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this}toJSON(){let t=super.toJSON();return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this}};hM.prototype.isQuadraticBezierCurve3=!0;var fM=class extends fs{constructor(t=[]){super(),this.type="SplineCurve",this.points=t}getPoint(t,r=new Lt){let n=r,i=this.points,o=(i.length-1)*t,a=Math.floor(o),s=o-a,l=i[a===0?a:a-1],c=i[a],u=i[a>i.length-2?i.length-1:a+1],h=i[a>i.length-3?i.length-1:a+2];return n.set(dhe(s,l.x,c.x,u.x,h.x),dhe(s,l.y,c.y,u.y,h.y)),n}copy(t){super.copy(t),this.points=[];for(let r=0,n=t.points.length;r<n;r++){let i=t.points[r];this.points.push(i.clone())}return this}toJSON(){let t=super.toJSON();t.points=[];for(let r=0,n=this.points.length;r<n;r++){let i=this.points[r];t.points.push(i.toArray())}return t}fromJSON(t){super.fromJSON(t),this.points=[];for(let r=0,n=t.points.length;r<n;r++){let i=t.points[r];this.points.push(new Lt().fromArray(i))}return this}};fM.prototype.isSplineCurve=!0;var Oht=Object.freeze({__proto__:null,ArcCurve:l6,CatmullRomCurve3:c6,CubicBezierCurve:cM,CubicBezierCurve3:u6,EllipseCurve:V1,LineCurve:U1,LineCurve3:bU,QuadraticBezierCurve:uM,QuadraticBezierCurve3:hM,SplineCurve:fM}),wU=class extends fs{constructor(){super(),this.type="CurvePath",this.curves=[],this.autoClose=!1}add(t){this.curves.push(t)}closePath(){let t=this.curves[0].getPoint(0),r=this.curves[this.curves.length-1].getPoint(1);t.equals(r)||this.curves.push(new U1(r,t))}getPoint(t,r){let n=t*this.getLength(),i=this.getCurveLengths(),o=0;for(;o<i.length;){if(i[o]>=n){let a=i[o]-n,s=this.curves[o],l=s.getLength(),c=l===0?0:1-a/l;return s.getPointAt(c,r)}o++}return null}getLength(){let t=this.getCurveLengths();return t[t.length-1]}updateArcLengths(){this.needsUpdate=!0,this.cacheLengths=null,this.getCurveLengths()}getCurveLengths(){if(this.cacheLengths&&this.cacheLengths.length===this.curves.length)return this.cacheLengths;let t=[],r=0;for(let n=0,i=this.curves.length;n<i;n++)r+=this.curves[n].getLength(),t.push(r);return this.cacheLengths=t,t}getSpacedPoints(t=40){let r=[];for(let n=0;n<=t;n++)r.push(this.getPoint(n/t));return this.autoClose&&r.push(r[0]),r}getPoints(t=12){let r=[],n;for(let i=0,o=this.curves;i<o.length;i++){let a=o[i],s=a&&a.isEllipseCurve?t*2:a&&(a.isLineCurve||a.isLineCurve3)?1:a&&a.isSplineCurve?t*a.points.length:t,l=a.getPoints(s);for(let c=0;c<l.length;c++){let u=l[c];n&&n.equals(u)||(r.push(u),n=u)}}return this.autoClose&&r.length>1&&!r[r.length-1].equals(r[0])&&r.push(r[0]),r}copy(t){super.copy(t),this.curves=[];for(let r=0,n=t.curves.length;r<n;r++){let i=t.curves[r];this.curves.push(i.clone())}return this.autoClose=t.autoClose,this}toJSON(){let t=super.toJSON();t.autoClose=this.autoClose,t.curves=[];for(let r=0,n=this.curves.length;r<n;r++){let i=this.curves[r];t.curves.push(i.toJSON())}return t}fromJSON(t){super.fromJSON(t),this.autoClose=t.autoClose,this.curves=[];for(let r=0,n=t.curves.length;r<n;r++){let i=t.curves[r];this.curves.push(new Oht[i.type]().fromJSON(i))}return this}},q1=class extends wU{constructor(t){super(),this.type="Path",this.currentPoint=new Lt,t&&this.setFromPoints(t)}setFromPoints(t){this.moveTo(t[0].x,t[0].y);for(let r=1,n=t.length;r<n;r++)this.lineTo(t[r].x,t[r].y);return this}moveTo(t,r){return this.currentPoint.set(t,r),this}lineTo(t,r){let n=new U1(this.currentPoint.clone(),new Lt(t,r));return this.curves.push(n),this.currentPoint.set(t,r),this}quadraticCurveTo(t,r,n,i){let o=new uM(this.currentPoint.clone(),new Lt(t,r),new Lt(n,i));return this.curves.push(o),this.currentPoint.set(n,i),this}bezierCurveTo(t,r,n,i,o,a){let s=new cM(this.currentPoint.clone(),new Lt(t,r),new Lt(n,i),new Lt(o,a));return this.curves.push(s),this.currentPoint.set(o,a),this}splineThru(t){let r=[this.currentPoint.clone()].concat(t),n=new fM(r);return this.curves.push(n),this.currentPoint.copy(t[t.length-1]),this}arc(t,r,n,i,o,a){let s=this.currentPoint.x,l=this.currentPoint.y;return this.absarc(t+s,r+l,n,i,o,a),this}absarc(t,r,n,i,o,a){return this.absellipse(t,r,n,n,i,o,a),this}ellipse(t,r,n,i,o,a,s,l){let c=this.currentPoint.x,u=this.currentPoint.y;return this.absellipse(t+c,r+u,n,i,o,a,s,l),this}absellipse(t,r,n,i,o,a,s,l){let c=new V1(t,r,n,i,o,a,s,l);if(this.curves.length>0){let h=c.getPoint(0);h.equals(this.currentPoint)||this.lineTo(h.x,h.y)}this.curves.push(c);let u=c.getPoint(1);return this.currentPoint.copy(u),this}copy(t){return super.copy(t),this.currentPoint.copy(t.currentPoint),this}toJSON(){let t=super.toJSON();return t.currentPoint=this.currentPoint.toArray(),t}fromJSON(t){return super.fromJSON(t),this.currentPoint.fromArray(t.currentPoint),this}},Kc=class extends q1{constructor(t){super(t),this.uuid=Nl(),this.type="Shape",this.holes=[]}getPointsHoles(t){let r=[];for(let n=0,i=this.holes.length;n<i;n++)r[n]=this.holes[n].getPoints(t);return r}extractPoints(t){return{shape:this.getPoints(t),holes:this.getPointsHoles(t)}}copy(t){super.copy(t),this.holes=[];for(let r=0,n=t.holes.length;r<n;r++){let i=t.holes[r];this.holes.push(i.clone())}return this}toJSON(){let t=super.toJSON();t.uuid=this.uuid,t.holes=[];for(let r=0,n=this.holes.length;r<n;r++){let i=this.holes[r];t.holes.push(i.toJSON())}return t}fromJSON(t){super.fromJSON(t),this.uuid=t.uuid,this.holes=[];for(let r=0,n=t.holes.length;r<n;r++){let i=t.holes[r];this.holes.push(new q1().fromJSON(i))}return this}},Ggr={triangulate:function(e,t,r=2){let n=t&&t.length,i=n?t[0]*r:e.length,o=epe(e,0,i,r,!0),a=[];if(!o||o.next===o.prev)return a;let s,l,c,u,h,f,p;if(n&&(o=$gr(e,t,o,r)),e.length>80*r){s=c=e[0],l=u=e[1];for(let d=r;d<i;d+=r)h=e[d],f=e[d+1],h<s&&(s=h),f<l&&(l=f),h>c&&(c=h),f>u&&(u=f);p=Math.max(c-s,u-l),p=p!==0?1/p:0}return h6(o,a,r,s,l,p),a}};function epe(e,t,r,n,i){let o,a;if(i===a0r(e,t,r,n)>0)for(o=t;o<r;o+=n)a=mhe(o,e[o],e[o+1],a);else for(o=r-n;o>=t;o-=n)a=mhe(o,e[o],e[o+1],a);return a&&ZU(a,a.next)&&(p6(a),a=a.next),a}function G0(e,t){if(!e)return e;t||(t=e);let r=e,n;do if(n=!1,!r.steiner&&(ZU(r,r.next)||ai(r.prev,r,r.next)===0)){if(p6(r),r=t=r.prev,r===r.next)break;n=!0}else r=r.next;while(n||r!==t);return t}function h6(e,t,r,n,i,o,a){if(!e)return;!a&&o&&t0r(e,n,i,o);let s=e,l,c;for(;e.prev!==e.next;){if(l=e.prev,c=e.next,o?Ygr(e,n,i,o):Wgr(e)){t.push(l.i/r),t.push(e.i/r),t.push(c.i/r),p6(e),e=c.next,s=c.next;continue}if(e=c,e===s){a?a===1?(e=jgr(G0(e),t,r),h6(e,t,r,n,i,o,2)):a===2&&Xgr(e,t,r,n,i,o):h6(G0(e),t,r,n,i,o,1);break}}}function Wgr(e){let t=e.prev,r=e,n=e.next;if(ai(t,r,n)>=0)return!1;let i=e.next.next;for(;i!==e.prev;){if(H3(t.x,t.y,r.x,r.y,n.x,n.y,i.x,i.y)&&ai(i.prev,i,i.next)>=0)return!1;i=i.next}return!0}function Ygr(e,t,r,n){let i=e.prev,o=e,a=e.next;if(ai(i,o,a)>=0)return!1;let s=i.x<o.x?i.x<a.x?i.x:a.x:o.x<a.x?o.x:a.x,l=i.y<o.y?i.y<a.y?i.y:a.y:o.y<a.y?o.y:a.y,c=i.x>o.x?i.x>a.x?i.x:a.x:o.x>a.x?o.x:a.x,u=i.y>o.y?i.y>a.y?i.y:a.y:o.y>a.y?o.y:a.y,h=nht(s,l,t,r,n),f=nht(c,u,t,r,n),p=e.prevZ,d=e.nextZ;for(;p&&p.z>=h&&d&&d.z<=f;){if(p!==e.prev&&p!==e.next&&H3(i.x,i.y,o.x,o.y,a.x,a.y,p.x,p.y)&&ai(p.prev,p,p.next)>=0||(p=p.prevZ,d!==e.prev&&d!==e.next&&H3(i.x,i.y,o.x,o.y,a.x,a.y,d.x,d.y)&&ai(d.prev,d,d.next)>=0))return!1;d=d.nextZ}for(;p&&p.z>=h;){if(p!==e.prev&&p!==e.next&&H3(i.x,i.y,o.x,o.y,a.x,a.y,p.x,p.y)&&ai(p.prev,p,p.next)>=0)return!1;p=p.prevZ}for(;d&&d.z<=f;){if(d!==e.prev&&d!==e.next&&H3(i.x,i.y,o.x,o.y,a.x,a.y,d.x,d.y)&&ai(d.prev,d,d.next)>=0)return!1;d=d.nextZ}return!0}function jgr(e,t,r){let n=e;do{let i=n.prev,o=n.next.next;!ZU(i,o)&&rpe(i,n,n.next,o)&&f6(i,o)&&f6(o,i)&&(t.push(i.i/r),t.push(n.i/r),t.push(o.i/r),p6(n),p6(n.next),n=e=o),n=n.next}while(n!==e);return G0(n)}function Xgr(e,t,r,n,i,o){let a=e;do{let s=a.next.next;for(;s!==a.prev;){if(a.i!==s.i&&n0r(a,s)){let l=npe(a,s);a=G0(a,a.next),l=G0(l,l.next),h6(a,t,r,n,i,o),h6(l,t,r,n,i,o);return}s=s.next}a=a.next}while(a!==e)}function $gr(e,t,r,n){let i=[],o,a,s,l,c;for(o=0,a=t.length;o<a;o++)s=t[o]*n,l=o<a-1?t[o+1]*n:e.length,c=epe(e,s,l,n,!1),c===c.next&&(c.steiner=!0),i.push(r0r(c));for(i.sort(Kgr),o=0;o<i.length;o++)Zgr(i[o],r),r=G0(r,r.next);return r}function Kgr(e,t){return e.x-t.x}function Zgr(e,t){if(t=Jgr(e,t),t){let r=npe(t,e);G0(t,t.next),G0(r,r.next)}}function Jgr(e,t){let r=t,n=e.x,i=e.y,o=-1/0,a;do{if(i<=r.y&&i>=r.next.y&&r.next.y!==r.y){let f=r.x+(i-r.y)*(r.next.x-r.x)/(r.next.y-r.y);if(f<=n&&f>o){if(o=f,f===n){if(i===r.y)return r;if(i===r.next.y)return r.next}a=r.x<r.next.x?r:r.next}}r=r.next}while(r!==t);if(!a)return null;if(n===o)return a;let s=a,l=a.x,c=a.y,u=1/0,h;r=a;do n>=r.x&&r.x>=l&&n!==r.x&&H3(i<c?n:o,i,l,c,i<c?o:n,i,r.x,r.y)&&(h=Math.abs(i-r.y)/(n-r.x),f6(r,e)&&(h<u||h===u&&(r.x>a.x||r.x===a.x&&Qgr(a,r)))&&(a=r,u=h)),r=r.next;while(r!==s);return a}function Qgr(e,t){return ai(e.prev,e,t.prev)<0&&ai(t.next,e,e.next)<0}function t0r(e,t,r,n){let i=e;do i.z===null&&(i.z=nht(i.x,i.y,t,r,n)),i.prevZ=i.prev,i.nextZ=i.next,i=i.next;while(i!==e);i.prevZ.nextZ=null,i.prevZ=null,e0r(i)}function e0r(e){let t,r,n,i,o,a,s,l,c=1;do{for(r=e,e=null,o=null,a=0;r;){for(a++,n=r,s=0,t=0;t<c&&(s++,n=n.nextZ,!!n);t++);for(l=c;s>0||l>0&&n;)s!==0&&(l===0||!n||r.z<=n.z)?(i=r,r=r.nextZ,s--):(i=n,n=n.nextZ,l--),o?o.nextZ=i:e=i,i.prevZ=o,o=i;r=n}o.nextZ=null,c*=2}while(a>1);return e}function nht(e,t,r,n,i){return e=32767*(e-r)*i,t=32767*(t-n)*i,e=(e|e<<8)&16711935,e=(e|e<<4)&252645135,e=(e|e<<2)&858993459,e=(e|e<<1)&1431655765,t=(t|t<<8)&16711935,t=(t|t<<4)&252645135,t=(t|t<<2)&858993459,t=(t|t<<1)&1431655765,e|t<<1}function r0r(e){let t=e,r=e;do(t.x<r.x||t.x===r.x&&t.y<r.y)&&(r=t),t=t.next;while(t!==e);return r}function H3(e,t,r,n,i,o,a,s){return(i-a)*(t-s)-(e-a)*(o-s)>=0&&(e-a)*(n-s)-(r-a)*(t-s)>=0&&(r-a)*(o-s)-(i-a)*(n-s)>=0}function n0r(e,t){return e.next.i!==t.i&&e.prev.i!==t.i&&!i0r(e,t)&&(f6(e,t)&&f6(t,e)&&o0r(e,t)&&(ai(e.prev,e,t.prev)||ai(e,t.prev,t))||ZU(e,t)&&ai(e.prev,e,e.next)>0&&ai(t.prev,t,t.next)>0)}function ai(e,t,r){return(t.y-e.y)*(r.x-t.x)-(t.x-e.x)*(r.y-t.y)}function ZU(e,t){return e.x===t.x&&e.y===t.y}function rpe(e,t,r,n){let i=GV(ai(e,t,r)),o=GV(ai(e,t,n)),a=GV(ai(r,n,e)),s=GV(ai(r,n,t));return!!(i!==o&&a!==s||i===0&&qV(e,r,t)||o===0&&qV(e,n,t)||a===0&&qV(r,e,n)||s===0&&qV(r,t,n))}function qV(e,t,r){return t.x<=Math.max(e.x,r.x)&&t.x>=Math.min(e.x,r.x)&&t.y<=Math.max(e.y,r.y)&&t.y>=Math.min(e.y,r.y)}function GV(e){return e>0?1:e<0?-1:0}function i0r(e,t){let r=e;do{if(r.i!==e.i&&r.next.i!==e.i&&r.i!==t.i&&r.next.i!==t.i&&rpe(r,r.next,e,t))return!0;r=r.next}while(r!==e);return!1}function f6(e,t){return ai(e.prev,e,e.next)<0?ai(e,t,e.next)>=0&&ai(e,e.prev,t)>=0:ai(e,t,e.prev)<0||ai(e,e.next,t)<0}function o0r(e,t){let r=e,n=!1,i=(e.x+t.x)/2,o=(e.y+t.y)/2;do r.y>o!=r.next.y>o&&r.next.y!==r.y&&i<(r.next.x-r.x)*(o-r.y)/(r.next.y-r.y)+r.x&&(n=!n),r=r.next;while(r!==e);return n}function npe(e,t){let r=new iht(e.i,e.x,e.y),n=new iht(t.i,t.x,t.y),i=e.next,o=t.prev;return e.next=t,t.prev=e,r.next=i,i.prev=r,n.next=r,r.prev=n,o.next=n,n.prev=o,n}function mhe(e,t,r,n){let i=new iht(e,t,r);return n?(i.next=n.next,i.prev=n,n.next.prev=i,n.next=i):(i.prev=i,i.next=i),i}function p6(e){e.next.prev=e.prev,e.prev.next=e.next,e.prevZ&&(e.prevZ.nextZ=e.nextZ),e.nextZ&&(e.nextZ.prevZ=e.prevZ)}function iht(e,t,r){this.i=e,this.x=t,this.y=r,this.prev=null,this.next=null,this.z=null,this.prevZ=null,this.nextZ=null,this.steiner=!1}function a0r(e,t,r,n){let i=0;for(let o=t,a=r-n;o<r;o+=n)i+=(e[a]-e[o])*(e[o+1]+e[a+1]),a=o;return i}var Zc=class{static area(t){let r=t.length,n=0;for(let i=r-1,o=0;o<r;i=o++)n+=t[i].x*t[o].y-t[o].x*t[i].y;return n*.5}static isClockWise(t){return Zc.area(t)<0}static triangulateShape(t,r){let n=[],i=[],o=[];ghe(t),_he(n,t);let a=t.length;r.forEach(ghe);for(let l=0;l<r.length;l++)i.push(a),a+=r[l].length,_he(n,r[l]);let s=Ggr.triangulate(n,i);for(let l=0;l<s.length;l+=3)o.push(s.slice(l,l+3));return o}};function ghe(e){let t=e.length;t>2&&e[t-1].equals(e[0])&&e.pop()}function _he(e,t){for(let r=0;r<t.length;r++)e.push(t[r].x),e.push(t[r].y)}var hh=class extends Pe{constructor(t=new Kc([new Lt(.5,.5),new Lt(-.5,.5),new Lt(-.5,-.5),new Lt(.5,-.5)]),r={}){super(),this.type="ExtrudeGeometry",this.parameters={shapes:t,options:r},t=Array.isArray(t)?t:[t];let n=this,i=[],o=[];for(let s=0,l=t.length;s<l;s++){let c=t[s];a(c)}this.setAttribute("position",new xe(i,3)),this.setAttribute("uv",new xe(o,2)),this.computeVertexNormals();function a(s){let l=[],c=r.curveSegments!==void 0?r.curveSegments:12,u=r.steps!==void 0?r.steps:1,h=r.depth!==void 0?r.depth:1,f=r.bevelEnabled!==void 0?r.bevelEnabled:!0,p=r.bevelThickness!==void 0?r.bevelThickness:.2,d=r.bevelSize!==void 0?r.bevelSize:p-.1,g=r.bevelOffset!==void 0?r.bevelOffset:0,_=r.bevelSegments!==void 0?r.bevelSegments:3,y=r.extrudePath,x=r.UVGenerator!==void 0?r.UVGenerator:s0r;r.amount!==void 0&&(console.warn("THREE.ExtrudeBufferGeometry: amount has been renamed to depth."),h=r.amount);let b,S=!1,C,P,k,O;y&&(b=y.getSpacedPoints(u),S=!0,f=!1,C=y.computeFrenetFrames(u,!1),P=new j,k=new j,O=new j),f||(_=0,p=0,d=0,g=0);let D=s.extractPoints(c),B=D.shape,I=D.holes;if(!Zc.isClockWise(B)){B=B.reverse();for(let q=0,pt=I.length;q<pt;q++){let ht=I[q];Zc.isClockWise(ht)&&(I[q]=ht.reverse())}}let R=Zc.triangulateShape(B,I),F=B;for(let q=0,pt=I.length;q<pt;q++){let ht=I[q];B=B.concat(ht)}function z(q,pt,ht){return pt||console.error("THREE.ExtrudeGeometry: vec does not exist"),pt.clone().multiplyScalar(ht).add(q)}let U=B.length,W=R.length;function Z(q,pt,ht){let wt,kt,ie,ee=q.x-pt.x,Le=q.y-pt.y,ar=ht.x-q.x,fr=ht.y-q.y,tt=ee*ee+Le*Le,$=ee*fr-Le*ar;if(Math.abs($)>Number.EPSILON){let It=Math.sqrt(tt),$t=Math.sqrt(ar*ar+fr*fr),he=pt.x-Le/It,Tt=pt.y+ee/It,be=ht.x-fr/$t,nt=ht.y+ar/$t,Ct=((be-he)*fr-(nt-Tt)*ar)/(ee*fr-Le*ar);wt=he+ee*Ct-q.x,kt=Tt+Le*Ct-q.y;let Wt=wt*wt+kt*kt;if(Wt<=2)return new Lt(wt,kt);ie=Math.sqrt(Wt/2)}else{let It=!1;ee>Number.EPSILON?ar>Number.EPSILON&&(It=!0):ee<-Number.EPSILON?ar<-Number.EPSILON&&(It=!0):Math.sign(Le)===Math.sign(fr)&&(It=!0),It?(wt=-Le,kt=ee,ie=Math.sqrt(tt)):(wt=ee,kt=Le,ie=Math.sqrt(tt/2))}return new Lt(wt/ie,kt/ie)}let rt=[];for(let q=0,pt=F.length,ht=pt-1,wt=q+1;q<pt;q++,ht++,wt++)ht===pt&&(ht=0),wt===pt&&(wt=0),rt[q]=Z(F[q],F[ht],F[wt]);let ot=[],st,St=rt.concat();for(let q=0,pt=I.length;q<pt;q++){let ht=I[q];st=[];for(let wt=0,kt=ht.length,ie=kt-1,ee=wt+1;wt<kt;wt++,ie++,ee++)ie===kt&&(ie=0),ee===kt&&(ee=0),st[wt]=Z(ht[wt],ht[ie],ht[ee]);ot.push(st),St=St.concat(st)}for(let q=0;q<_;q++){let pt=q/_,ht=p*Math.cos(pt*Math.PI/2),wt=d*Math.sin(pt*Math.PI/2)+g;for(let kt=0,ie=F.length;kt<ie;kt++){let ee=z(F[kt],rt[kt],wt);_t(ee.x,ee.y,-ht)}for(let kt=0,ie=I.length;kt<ie;kt++){let ee=I[kt];st=ot[kt];for(let Le=0,ar=ee.length;Le<ar;Le++){let fr=z(ee[Le],st[Le],wt);_t(fr.x,fr.y,-ht)}}}let bt=d+g;for(let q=0;q<U;q++){let pt=f?z(B[q],St[q],bt):B[q];S?(k.copy(C.normals[0]).multiplyScalar(pt.x),P.copy(C.binormals[0]).multiplyScalar(pt.y),O.copy(b[0]).add(k).add(P),_t(O.x,O.y,O.z)):_t(pt.x,pt.y,0)}for(let q=1;q<=u;q++)for(let pt=0;pt<U;pt++){let ht=f?z(B[pt],St[pt],bt):B[pt];S?(k.copy(C.normals[q]).multiplyScalar(ht.x),P.copy(C.binormals[q]).multiplyScalar(ht.y),O.copy(b[q]).add(k).add(P),_t(O.x,O.y,O.z)):_t(ht.x,ht.y,h/u*q)}for(let q=_-1;q>=0;q--){let pt=q/_,ht=p*Math.cos(pt*Math.PI/2),wt=d*Math.sin(pt*Math.PI/2)+g;for(let kt=0,ie=F.length;kt<ie;kt++){let ee=z(F[kt],rt[kt],wt);_t(ee.x,ee.y,h+ht)}for(let kt=0,ie=I.length;kt<ie;kt++){let ee=I[kt];st=ot[kt];for(let Le=0,ar=ee.length;Le<ar;Le++){let fr=z(ee[Le],st[Le],wt);S?_t(fr.x,fr.y+b[u-1].y,b[u-1].x+ht):_t(fr.x,fr.y,h+ht)}}}Mt(),lt();function Mt(){let q=i.length/3;if(f){let pt=0,ht=U*pt;for(let wt=0;wt<W;wt++){let kt=R[wt];ct(kt[2]+ht,kt[1]+ht,kt[0]+ht)}pt=u+_*2,ht=U*pt;for(let wt=0;wt<W;wt++){let kt=R[wt];ct(kt[0]+ht,kt[1]+ht,kt[2]+ht)}}else{for(let pt=0;pt<W;pt++){let ht=R[pt];ct(ht[2],ht[1],ht[0])}for(let pt=0;pt<W;pt++){let ht=R[pt];ct(ht[0]+U*u,ht[1]+U*u,ht[2]+U*u)}}n.addGroup(q,i.length/3-q,0)}function lt(){let q=i.length/3,pt=0;Kt(F,pt),pt+=F.length;for(let ht=0,wt=I.length;ht<wt;ht++){let kt=I[ht];Kt(kt,pt),pt+=kt.length}n.addGroup(q,i.length/3-q,1)}function Kt(q,pt){let ht=q.length;for(;--ht>=0;){let wt=ht,kt=ht-1;kt<0&&(kt=q.length-1);for(let ie=0,ee=u+_*2;ie<ee;ie++){let Le=U*ie,ar=U*(ie+1),fr=pt+wt+Le,tt=pt+kt+Le,$=pt+kt+ar,It=pt+wt+ar;X(fr,tt,$,It)}}}function _t(q,pt,ht){l.push(q),l.push(pt),l.push(ht)}function ct(q,pt,ht){et(q),et(pt),et(ht);let wt=i.length/3,kt=x.generateTopUV(n,i,wt-3,wt-2,wt-1);dt(kt[0]),dt(kt[1]),dt(kt[2])}function X(q,pt,ht,wt){et(q),et(pt),et(wt),et(pt),et(ht),et(wt);let kt=i.length/3,ie=x.generateSideWallUV(n,i,kt-6,kt-3,kt-2,kt-1);dt(ie[0]),dt(ie[1]),dt(ie[3]),dt(ie[1]),dt(ie[2]),dt(ie[3])}function et(q){i.push(l[q*3+0]),i.push(l[q*3+1]),i.push(l[q*3+2])}function dt(q){o.push(q.x),o.push(q.y)}}}toJSON(){let t=super.toJSON(),r=this.parameters.shapes,n=this.parameters.options;return l0r(r,n,t)}static fromJSON(t,r){let n=[];for(let o=0,a=t.shapes.length;o<a;o++){let s=r[t.shapes[o]];n.push(s)}let i=t.options.extrudePath;return i!==void 0&&(t.options.extrudePath=new Oht[i.type]().fromJSON(i)),new hh(n,t.options)}},s0r={generateTopUV:function(e,t,r,n,i){let o=t[r*3],a=t[r*3+1],s=t[n*3],l=t[n*3+1],c=t[i*3],u=t[i*3+1];return[new Lt(o,a),new Lt(s,l),new Lt(c,u)]},generateSideWallUV:function(e,t,r,n,i,o){let a=t[r*3],s=t[r*3+1],l=t[r*3+2],c=t[n*3],u=t[n*3+1],h=t[n*3+2],f=t[i*3],p=t[i*3+1],d=t[i*3+2],g=t[o*3],_=t[o*3+1],y=t[o*3+2];return Math.abs(s-u)<Math.abs(a-c)?[new Lt(a,1-l),new Lt(c,1-h),new Lt(f,1-d),new Lt(g,1-y)]:[new Lt(s,1-l),new Lt(u,1-h),new Lt(p,1-d),new Lt(_,1-y)]}};function l0r(e,t,r){if(r.shapes=[],Array.isArray(e))for(let n=0,i=e.length;n<i;n++){let o=e[n];r.shapes.push(o.uuid)}else r.shapes.push(e.uuid);return t.extrudePath!==void 0&&(r.options.extrudePath=t.extrudePath.toJSON()),r}var G1=class extends uh{constructor(t=1,r=0){let n=(1+Math.sqrt(5))/2,i=[-1,n,0,1,n,0,-1,-n,0,1,-n,0,0,-1,n,0,1,n,0,-1,-n,0,1,-n,n,0,-1,n,0,1,-n,0,-1,-n,0,1],o=[0,11,5,0,5,1,0,1,7,0,7,10,0,10,11,1,5,9,5,11,4,11,10,2,10,7,6,7,1,8,3,9,4,3,4,2,3,2,6,3,6,8,3,8,9,4,9,5,2,4,11,6,2,10,8,6,7,9,8,1];super(i,o,t,r),this.type="IcosahedronGeometry",this.parameters={radius:t,detail:r}}static fromJSON(t){return new G1(t.radius,t.detail)}},W1=class extends Pe{constructor(t=[new Lt(0,.5),new Lt(.5,0),new Lt(0,-.5)],r=12,n=0,i=Math.PI*2){super(),this.type="LatheGeometry",this.parameters={points:t,segments:r,phiStart:n,phiLength:i},r=Math.floor(r),i=Zo(i,0,Math.PI*2);let o=[],a=[],s=[],l=[],c=[],u=1/r,h=new j,f=new Lt,p=new j,d=new j,g=new j,_=0,y=0;for(let x=0;x<=t.length-1;x++)switch(x){case 0:_=t[x+1].x-t[x].x,y=t[x+1].y-t[x].y,p.x=y*1,p.y=-_,p.z=y*0,g.copy(p),p.normalize(),l.push(p.x,p.y,p.z);break;case t.length-1:l.push(g.x,g.y,g.z);break;default:_=t[x+1].x-t[x].x,y=t[x+1].y-t[x].y,p.x=y*1,p.y=-_,p.z=y*0,d.copy(p),p.x+=g.x,p.y+=g.y,p.z+=g.z,p.normalize(),l.push(p.x,p.y,p.z),g.copy(d)}for(let x=0;x<=r;x++){let b=n+x*u*i,S=Math.sin(b),C=Math.cos(b);for(let P=0;P<=t.length-1;P++){h.x=t[P].x*S,h.y=t[P].y,h.z=t[P].x*C,a.push(h.x,h.y,h.z),f.x=x/r,f.y=P/(t.length-1),s.push(f.x,f.y);let k=l[3*P+0]*S,O=l[3*P+1],D=l[3*P+0]*C;c.push(k,O,D)}}for(let x=0;x<r;x++)for(let b=0;b<t.length-1;b++){let S=b+x*t.length,C=S,P=S+t.length,k=S+t.length+1,O=S+1;o.push(C,P,O),o.push(k,O,P)}this.setIndex(o),this.setAttribute("position",new xe(a,3)),this.setAttribute("uv",new xe(s,2)),this.setAttribute("normal",new xe(c,3))}static fromJSON(t){return new W1(t.points,t.segments,t.phiStart,t.phiLength)}},W0=class extends uh{constructor(t=1,r=0){let n=[1,0,0,-1,0,0,0,1,0,0,-1,0,0,0,1,0,0,-1],i=[0,2,4,0,4,3,0,3,5,0,5,2,1,2,5,1,5,3,1,3,4,1,4,2];super(n,i,t,r),this.type="OctahedronGeometry",this.parameters={radius:t,detail:r}}static fromJSON(t){return new W0(t.radius,t.detail)}},Y1=class extends Pe{constructor(t=.5,r=1,n=8,i=1,o=0,a=Math.PI*2){super(),this.type="RingGeometry",this.parameters={innerRadius:t,outerRadius:r,thetaSegments:n,phiSegments:i,thetaStart:o,thetaLength:a},n=Math.max(3,n),i=Math.max(1,i);let s=[],l=[],c=[],u=[],h=t,f=(r-t)/i,p=new j,d=new Lt;for(let g=0;g<=i;g++){for(let _=0;_<=n;_++){let y=o+_/n*a;p.x=h*Math.cos(y),p.y=h*Math.sin(y),l.push(p.x,p.y,p.z),c.push(0,0,1),d.x=(p.x/r+1)/2,d.y=(p.y/r+1)/2,u.push(d.x,d.y)}h+=f}for(let g=0;g<i;g++){let _=g*(n+1);for(let y=0;y<n;y++){let x=y+_,b=x,S=x+n+1,C=x+n+2,P=x+1;s.push(b,S,P),s.push(S,C,P)}}this.setIndex(s),this.setAttribute("position",new xe(l,3)),this.setAttribute("normal",new xe(c,3)),this.setAttribute("uv",new xe(u,2))}static fromJSON(t){return new Y1(t.innerRadius,t.outerRadius,t.thetaSegments,t.phiSegments,t.thetaStart,t.thetaLength)}},Y0=class extends Pe{constructor(t=new Kc([new Lt(0,.5),new Lt(-.5,-.5),new Lt(.5,-.5)]),r=12){super(),this.type="ShapeGeometry",this.parameters={shapes:t,curveSegments:r};let n=[],i=[],o=[],a=[],s=0,l=0;if(Array.isArray(t)===!1)c(t);else for(let u=0;u<t.length;u++)c(t[u]),this.addGroup(s,l,u),s+=l,l=0;this.setIndex(n),this.setAttribute("position",new xe(i,3)),this.setAttribute("normal",new xe(o,3)),this.setAttribute("uv",new xe(a,2));function c(u){let h=i.length/3,f=u.extractPoints(r),p=f.shape,d=f.holes;Zc.isClockWise(p)===!1&&(p=p.reverse());for(let _=0,y=d.length;_<y;_++){let x=d[_];Zc.isClockWise(x)===!0&&(d[_]=x.reverse())}let g=Zc.triangulateShape(p,d);for(let _=0,y=d.length;_<y;_++){let x=d[_];p=p.concat(x)}for(let _=0,y=p.length;_<y;_++){let x=p[_];i.push(x.x,x.y,0),o.push(0,0,1),a.push(x.x,x.y)}for(let _=0,y=g.length;_<y;_++){let x=g[_],b=x[0]+h,S=x[1]+h,C=x[2]+h;n.push(b,S,C),l+=3}}}toJSON(){let t=super.toJSON(),r=this.parameters.shapes;return c0r(r,t)}static fromJSON(t,r){let n=[];for(let i=0,o=t.shapes.length;i<o;i++){let a=r[t.shapes[i]];n.push(a)}return new Y0(n,t.curveSegments)}};function c0r(e,t){if(t.shapes=[],Array.isArray(e))for(let r=0,n=e.length;r<n;r++){let i=e[r];t.shapes.push(i.uuid)}else t.shapes.push(e.uuid);return t}var j0=class extends Pe{constructor(t=1,r=32,n=16,i=0,o=Math.PI*2,a=0,s=Math.PI){super(),this.type="SphereGeometry",this.parameters={radius:t,widthSegments:r,heightSegments:n,phiStart:i,phiLength:o,thetaStart:a,thetaLength:s},r=Math.max(3,Math.floor(r)),n=Math.max(2,Math.floor(n));let l=Math.min(a+s,Math.PI),c=0,u=[],h=new j,f=new j,p=[],d=[],g=[],_=[];for(let y=0;y<=n;y++){let x=[],b=y/n,S=0;y==0&&a==0?S=.5/r:y==n&&l==Math.PI&&(S=-.5/r);for(let C=0;C<=r;C++){let P=C/r;h.x=-t*Math.cos(i+P*o)*Math.sin(a+b*s),h.y=t*Math.cos(a+b*s),h.z=t*Math.sin(i+P*o)*Math.sin(a+b*s),d.push(h.x,h.y,h.z),f.copy(h).normalize(),g.push(f.x,f.y,f.z),_.push(P+S,1-b),x.push(c++)}u.push(x)}for(let y=0;y<n;y++)for(let x=0;x<r;x++){let b=u[y][x+1],S=u[y][x],C=u[y+1][x],P=u[y+1][x+1];(y!==0||a>0)&&p.push(b,S,P),(y!==n-1||l<Math.PI)&&p.push(S,C,P)}this.setIndex(p),this.setAttribute("position",new xe(d,3)),this.setAttribute("normal",new xe(g,3)),this.setAttribute("uv",new xe(_,2))}static fromJSON(t){return new j0(t.radius,t.widthSegments,t.heightSegments,t.phiStart,t.phiLength,t.thetaStart,t.thetaLength)}},j1=class extends uh{constructor(t=1,r=0){let n=[1,1,1,-1,-1,1,-1,1,-1,1,-1,-1],i=[2,1,0,0,3,2,1,3,0,2,3,1];super(n,i,t,r),this.type="TetrahedronGeometry",this.parameters={radius:t,detail:r}}static fromJSON(t){return new j1(t.radius,t.detail)}},X1=class extends Pe{constructor(t=1,r=.4,n=8,i=6,o=Math.PI*2){super(),this.type="TorusGeometry",this.parameters={radius:t,tube:r,radialSegments:n,tubularSegments:i,arc:o},n=Math.floor(n),i=Math.floor(i);let a=[],s=[],l=[],c=[],u=new j,h=new j,f=new j;for(let p=0;p<=n;p++)for(let d=0;d<=i;d++){let g=d/i*o,_=p/n*Math.PI*2;h.x=(t+r*Math.cos(_))*Math.cos(g),h.y=(t+r*Math.cos(_))*Math.sin(g),h.z=r*Math.sin(_),s.push(h.x,h.y,h.z),u.x=t*Math.cos(g),u.y=t*Math.sin(g),f.subVectors(h,u).normalize(),l.push(f.x,f.y,f.z),c.push(d/i),c.push(p/n)}for(let p=1;p<=n;p++)for(let d=1;d<=i;d++){let g=(i+1)*p+d-1,_=(i+1)*(p-1)+d-1,y=(i+1)*(p-1)+d,x=(i+1)*p+d;a.push(g,_,x),a.push(_,y,x)}this.setIndex(a),this.setAttribute("position",new xe(s,3)),this.setAttribute("normal",new xe(l,3)),this.setAttribute("uv",new xe(c,2))}static fromJSON(t){return new X1(t.radius,t.tube,t.radialSegments,t.tubularSegments,t.arc)}},$1=class extends Pe{constructor(t=1,r=.4,n=64,i=8,o=2,a=3){super(),this.type="TorusKnotGeometry",this.parameters={radius:t,tube:r,tubularSegments:n,radialSegments:i,p:o,q:a},n=Math.floor(n),i=Math.floor(i);let s=[],l=[],c=[],u=[],h=new j,f=new j,p=new j,d=new j,g=new j,_=new j,y=new j;for(let b=0;b<=n;++b){let S=b/n*o*Math.PI*2;x(S,o,a,t,p),x(S+.01,o,a,t,d),_.subVectors(d,p),y.addVectors(d,p),g.crossVectors(_,y),y.crossVectors(g,_),g.normalize(),y.normalize();for(let C=0;C<=i;++C){let P=C/i*Math.PI*2,k=-r*Math.cos(P),O=r*Math.sin(P);h.x=p.x+(k*y.x+O*g.x),h.y=p.y+(k*y.y+O*g.y),h.z=p.z+(k*y.z+O*g.z),l.push(h.x,h.y,h.z),f.subVectors(h,p).normalize(),c.push(f.x,f.y,f.z),u.push(b/n),u.push(C/i)}}for(let b=1;b<=n;b++)for(let S=1;S<=i;S++){let C=(i+1)*(b-1)+(S-1),P=(i+1)*b+(S-1),k=(i+1)*b+S,O=(i+1)*(b-1)+S;s.push(C,P,O),s.push(P,k,O)}this.setIndex(s),this.setAttribute("position",new xe(l,3)),this.setAttribute("normal",new xe(c,3)),this.setAttribute("uv",new xe(u,2));function x(b,S,C,P,k){let O=Math.cos(b),D=Math.sin(b),B=C/S*b,I=Math.cos(B);k.x=P*(2+I)*.5*O,k.y=P*(2+I)*D*.5,k.z=P*Math.sin(B)*.5}}static fromJSON(t){return new $1(t.radius,t.tube,t.tubularSegments,t.radialSegments,t.p,t.q)}},K1=class extends Pe{constructor(t=new hM(new j(-1,-1,0),new j(-1,1,0),new j(1,1,0)),r=64,n=1,i=8,o=!1){super(),this.type="TubeGeometry",this.parameters={path:t,tubularSegments:r,radius:n,radialSegments:i,closed:o};let a=t.computeFrenetFrames(r,o);this.tangents=a.tangents,this.normals=a.normals,this.binormals=a.binormals;let s=new j,l=new j,c=new Lt,u=new j,h=[],f=[],p=[],d=[];g(),this.setIndex(d),this.setAttribute("position",new xe(h,3)),this.setAttribute("normal",new xe(f,3)),this.setAttribute("uv",new xe(p,2));function g(){for(let b=0;b<r;b++)_(b);_(o===!1?r:0),x(),y()}function _(b){u=t.getPointAt(b/r,u);let S=a.normals[b],C=a.binormals[b];for(let P=0;P<=i;P++){let k=P/i*Math.PI*2,O=Math.sin(k),D=-Math.cos(k);l.x=D*S.x+O*C.x,l.y=D*S.y+O*C.y,l.z=D*S.z+O*C.z,l.normalize(),f.push(l.x,l.y,l.z),s.x=u.x+n*l.x,s.y=u.y+n*l.y,s.z=u.z+n*l.z,h.push(s.x,s.y,s.z)}}function y(){for(let b=1;b<=r;b++)for(let S=1;S<=i;S++){let C=(i+1)*(b-1)+(S-1),P=(i+1)*b+(S-1),k=(i+1)*b+S,O=(i+1)*(b-1)+S;d.push(C,P,O),d.push(P,k,O)}}function x(){for(let b=0;b<=r;b++)for(let S=0;S<=i;S++)c.x=b/r,c.y=S/i,p.push(c.x,c.y)}}toJSON(){let t=super.toJSON();return t.path=this.parameters.path.toJSON(),t}static fromJSON(t){return new K1(new Oht[t.path.type]().fromJSON(t.path),t.tubularSegments,t.radius,t.radialSegments,t.closed)}},d6=class extends Pe{constructor(t=null){if(super(),this.type="WireframeGeometry",this.parameters={geometry:t},t!==null){let r=[],n=new Set,i=new j,o=new j;if(t.index!==null){let a=t.attributes.position,s=t.index,l=t.groups;l.length===0&&(l=[{start:0,count:s.count,materialIndex:0}]);for(let c=0,u=l.length;c<u;++c){let h=l[c],f=h.start,p=h.count;for(let d=f,g=f+p;d<g;d+=3)for(let _=0;_<3;_++){let y=s.getX(d+_),x=s.getX(d+(_+1)%3);i.fromBufferAttribute(a,y),o.fromBufferAttribute(a,x),yhe(i,o,n)===!0&&(r.push(i.x,i.y,i.z),r.push(o.x,o.y,o.z))}}}else{let a=t.attributes.position;for(let s=0,l=a.count/3;s<l;s++)for(let c=0;c<3;c++){let u=3*s+c,h=3*s+(c+1)%3;i.fromBufferAttribute(a,u),o.fromBufferAttribute(a,h),yhe(i,o,n)===!0&&(r.push(i.x,i.y,i.z),r.push(o.x,o.y,o.z))}}this.setAttribute("position",new xe(r,3))}}};function yhe(e,t,r){let n=`${e.x},${e.y},${e.z}-${t.x},${t.y},${t.z}`,i=`${t.x},${t.y},${t.z}-${e.x},${e.y},${e.z}`;return r.has(n)===!0||r.has(i)===!0?!1:(r.add(n,i),!0)}var vhe=Object.freeze({__proto__:null,BoxGeometry:Qf,BoxBufferGeometry:Qf,CircleGeometry:F1,CircleBufferGeometry:F1,ConeGeometry:B1,ConeBufferGeometry:B1,CylinderGeometry:om,CylinderBufferGeometry:om,DodecahedronGeometry:H1,DodecahedronBufferGeometry:H1,EdgesGeometry:s6,ExtrudeGeometry:hh,ExtrudeBufferGeometry:hh,IcosahedronGeometry:G1,IcosahedronBufferGeometry:G1,LatheGeometry:W1,LatheBufferGeometry:W1,OctahedronGeometry:W0,OctahedronBufferGeometry:W0,PlaneGeometry:V0,PlaneBufferGeometry:V0,PolyhedronGeometry:uh,PolyhedronBufferGeometry:uh,RingGeometry:Y1,RingBufferGeometry:Y1,ShapeGeometry:Y0,ShapeBufferGeometry:Y0,SphereGeometry:j0,SphereBufferGeometry:j0,TetrahedronGeometry:j1,TetrahedronBufferGeometry:j1,TorusGeometry:X1,TorusBufferGeometry:X1,TorusKnotGeometry:$1,TorusKnotBufferGeometry:$1,TubeGeometry:K1,TubeBufferGeometry:K1,WireframeGeometry:d6}),m6=class extends qi{constructor(t){super(),this.type="ShadowMaterial",this.color=new ne(0),this.transparent=!0,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this}};m6.prototype.isShadowMaterial=!0;var pM=class extends qi{constructor(t){super(),this.defines={STANDARD:""},this.type="MeshStandardMaterial",this.color=new ne(16777215),this.roughness=1,this.metalness=0,this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new ne(0),this.emissiveIntensity=1,this.emissiveMap=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=ax,this.normalScale=new Lt(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.roughnessMap=null,this.metalnessMap=null,this.alphaMap=null,this.envMap=null,this.envMapIntensity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.flatShading=!1,this.setValues(t)}copy(t){return super.copy(t),this.defines={STANDARD:""},this.color.copy(t.color),this.roughness=t.roughness,this.metalness=t.metalness,this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.roughnessMap=t.roughnessMap,this.metalnessMap=t.metalnessMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.envMapIntensity=t.envMapIntensity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this.flatShading=t.flatShading,this}};pM.prototype.isMeshStandardMaterial=!0;var g6=class extends pM{constructor(t){super(),this.defines={STANDARD:"",PHYSICAL:""},this.type="MeshPhysicalMaterial",this.clearcoatMap=null,this.clearcoatRoughness=0,this.clearcoatRoughnessMap=null,this.clearcoatNormalScale=new Lt(1,1),this.clearcoatNormalMap=null,this.ior=1.5,Object.defineProperty(this,"reflectivity",{get:function(){return Zo(2.5*(this.ior-1)/(this.ior+1),0,1)},set:function(r){this.ior=(1+.4*r)/(1-.4*r)}}),this.sheenColor=new ne(0),this.sheenColorMap=null,this.sheenRoughness=1,this.sheenRoughnessMap=null,this.transmissionMap=null,this.thickness=0,this.thicknessMap=null,this.attenuationDistance=0,this.attenuationColor=new ne(1,1,1),this.specularIntensity=1,this.specularIntensityMap=null,this.specularColor=new ne(1,1,1),this.specularColorMap=null,this._sheen=0,this._clearcoat=0,this._transmission=0,this.setValues(t)}get sheen(){return this._sheen}set sheen(t){this._sheen>0!=t>0&&this.version++,this._sheen=t}get clearcoat(){return this._clearcoat}set clearcoat(t){this._clearcoat>0!=t>0&&this.version++,this._clearcoat=t}get transmission(){return this._transmission}set transmission(t){this._transmission>0!=t>0&&this.version++,this._transmission=t}copy(t){return super.copy(t),this.defines={STANDARD:"",PHYSICAL:""},this.clearcoat=t.clearcoat,this.clearcoatMap=t.clearcoatMap,this.clearcoatRoughness=t.clearcoatRoughness,this.clearcoatRoughnessMap=t.clearcoatRoughnessMap,this.clearcoatNormalMap=t.clearcoatNormalMap,this.clearcoatNormalScale.copy(t.clearcoatNormalScale),this.ior=t.ior,this.sheen=t.sheen,this.sheenColor.copy(t.sheenColor),this.sheenColorMap=t.sheenColorMap,this.sheenRoughness=t.sheenRoughness,this.sheenRoughnessMap=t.sheenRoughnessMap,this.transmission=t.transmission,this.transmissionMap=t.transmissionMap,this.thickness=t.thickness,this.thicknessMap=t.thicknessMap,this.attenuationDistance=t.attenuationDistance,this.attenuationColor.copy(t.attenuationColor),this.specularIntensity=t.specularIntensity,this.specularIntensityMap=t.specularIntensityMap,this.specularColor.copy(t.specularColor),this.specularColorMap=t.specularColorMap,this}};g6.prototype.isMeshPhysicalMaterial=!0;var _6=class extends qi{constructor(t){super(),this.type="MeshPhongMaterial",this.color=new ne(16777215),this.specular=new ne(1118481),this.shininess=30,this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new ne(0),this.emissiveIntensity=1,this.emissiveMap=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=ax,this.normalScale=new Lt(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.specularMap=null,this.alphaMap=null,this.envMap=null,this.combine=O6,this.reflectivity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.flatShading=!1,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.specular.copy(t.specular),this.shininess=t.shininess,this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.specularMap=t.specularMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.combine=t.combine,this.reflectivity=t.reflectivity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this.flatShading=t.flatShading,this}};_6.prototype.isMeshPhongMaterial=!0;var y6=class extends qi{constructor(t){super(),this.defines={TOON:""},this.type="MeshToonMaterial",this.color=new ne(16777215),this.map=null,this.gradientMap=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new ne(0),this.emissiveIntensity=1,this.emissiveMap=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=ax,this.normalScale=new Lt(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.alphaMap=null,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.gradientMap=t.gradientMap,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.alphaMap=t.alphaMap,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this}};y6.prototype.isMeshToonMaterial=!0;var v6=class extends qi{constructor(t){super(),this.type="MeshNormalMaterial",this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=ax,this.normalScale=new Lt(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.wireframe=!1,this.wireframeLinewidth=1,this.fog=!1,this.flatShading=!1,this.setValues(t)}copy(t){return super.copy(t),this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.flatShading=t.flatShading,this}};v6.prototype.isMeshNormalMaterial=!0;var x6=class extends qi{constructor(t){super(),this.type="MeshLambertMaterial",this.color=new ne(16777215),this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new ne(0),this.emissiveIntensity=1,this.emissiveMap=null,this.specularMap=null,this.alphaMap=null,this.envMap=null,this.combine=O6,this.reflectivity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.specularMap=t.specularMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.combine=t.combine,this.reflectivity=t.reflectivity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this}};x6.prototype.isMeshLambertMaterial=!0;var b6=class extends qi{constructor(t){super(),this.defines={MATCAP:""},this.type="MeshMatcapMaterial",this.color=new ne(16777215),this.matcap=null,this.map=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=ax,this.normalScale=new Lt(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.alphaMap=null,this.flatShading=!1,this.setValues(t)}copy(t){return super.copy(t),this.defines={MATCAP:""},this.color.copy(t.color),this.matcap=t.matcap,this.map=t.map,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.alphaMap=t.alphaMap,this.flatShading=t.flatShading,this}};b6.prototype.isMeshMatcapMaterial=!0;var w6=class extends Gi{constructor(t){super(),this.type="LineDashedMaterial",this.scale=1,this.dashSize=3,this.gapSize=1,this.setValues(t)}copy(t){return super.copy(t),this.scale=t.scale,this.dashSize=t.dashSize,this.gapSize=t.gapSize,this}};w6.prototype.isLineDashedMaterial=!0;var u0r=Object.freeze({__proto__:null,ShadowMaterial:m6,SpriteMaterial:iM,RawShaderMaterial:U0,ShaderMaterial:lh,PointsMaterial:nm,MeshPhysicalMaterial:g6,MeshStandardMaterial:pM,MeshPhongMaterial:_6,MeshToonMaterial:y6,MeshNormalMaterial:v6,MeshLambertMaterial:x6,MeshDepthMaterial:eM,MeshDistanceMaterial:rM,MeshBasicMaterial:sh,MeshMatcapMaterial:b6,LineDashedMaterial:w6,LineBasicMaterial:Gi,Material:qi}),Yn={arraySlice:function(e,t,r){return Yn.isTypedArray(e)?new e.constructor(e.subarray(t,r!==void 0?r:e.length)):e.slice(t,r)},convertArray:function(e,t,r){return!e||!r&&e.constructor===t?e:typeof t.BYTES_PER_ELEMENT=="number"?new t(e):Array.prototype.slice.call(e)},isTypedArray:function(e){return ArrayBuffer.isView(e)&&!(e instanceof DataView)},getKeyframeOrder:function(e){function t(i,o){return e[i]-e[o]}let r=e.length,n=new Array(r);for(let i=0;i!==r;++i)n[i]=i;return n.sort(t),n},sortedArray:function(e,t,r){let n=e.length,i=new e.constructor(n);for(let o=0,a=0;a!==n;++o){let s=r[o]*t;for(let l=0;l!==t;++l)i[a++]=e[s+l]}return i},flattenJSON:function(e,t,r,n){let i=1,o=e[0];for(;o!==void 0&&o[n]===void 0;)o=e[i++];if(o===void 0)return;let a=o[n];if(a!==void 0)if(Array.isArray(a))do a=o[n],a!==void 0&&(t.push(o.time),r.push.apply(r,a)),o=e[i++];while(o!==void 0);else if(a.toArray!==void 0)do a=o[n],a!==void 0&&(t.push(o.time),a.toArray(r,r.length)),o=e[i++];while(o!==void 0);else do a=o[n],a!==void 0&&(t.push(o.time),r.push(a)),o=e[i++];while(o!==void 0)},subclip:function(e,t,r,n,i=30){let o=e.clone();o.name=t;let a=[];for(let l=0;l<o.tracks.length;++l){let c=o.tracks[l],u=c.getValueSize(),h=[],f=[];for(let p=0;p<c.times.length;++p){let d=c.times[p]*i;if(!(d<r||d>=n)){h.push(c.times[p]);for(let g=0;g<u;++g)f.push(c.values[p*u+g])}}h.length!==0&&(c.times=Yn.convertArray(h,c.times.constructor),c.values=Yn.convertArray(f,c.values.constructor),a.push(c))}o.tracks=a;let s=1/0;for(let l=0;l<o.tracks.length;++l)s>o.tracks[l].times[0]&&(s=o.tracks[l].times[0]);for(let l=0;l<o.tracks.length;++l)o.tracks[l].shift(-1*s);return o.resetDuration(),o},makeClipAdditive:function(e,t=0,r=e,n=30){n<=0&&(n=30);let i=r.tracks.length,o=t/n;for(let a=0;a<i;++a){let s=r.tracks[a],l=s.ValueTypeName;if(l==="bool"||l==="string")continue;let c=e.tracks.find(function(y){return y.name===s.name&&y.ValueTypeName===l});if(c===void 0)continue;let u=0,h=s.getValueSize();s.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline&&(u=h/3);let f=0,p=c.getValueSize();c.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline&&(f=p/3);let d=s.times.length-1,g;if(o<=s.times[0]){let y=u,x=h-u;g=Yn.arraySlice(s.values,y,x)}else if(o>=s.times[d]){let y=d*h+u,x=y+h-u;g=Yn.arraySlice(s.values,y,x)}else{let y=s.createInterpolant(),x=u,b=h-u;y.evaluate(o),g=Yn.arraySlice(y.resultBuffer,x,b)}l==="quaternion"&&new yi().fromArray(g).normalize().conjugate().toArray(g);let _=c.times.length;for(let y=0;y<_;++y){let x=y*p+f;if(l==="quaternion")yi.multiplyQuaternionsFlat(c.values,x,g,0,c.values,x);else{let b=p-f*2;for(let S=0;S<b;++S)c.values[x+S]-=g[S]}}}return e.blendMode=kht,e}},fh=class{constructor(t,r,n,i){this.parameterPositions=t,this._cachedIndex=0,this.resultBuffer=i!==void 0?i:new r.constructor(n),this.sampleValues=r,this.valueSize=n,this.settings=null,this.DefaultSettings_={}}evaluate(t){let r=this.parameterPositions,n=this._cachedIndex,i=r[n],o=r[n-1];t:{e:{let a;r:{n:if(!(t<i)){for(let s=n+2;;){if(i===void 0){if(t<o)break n;return n=r.length,this._cachedIndex=n,this.afterEnd_(n-1,t,o)}if(n===s)break;if(o=i,i=r[++n],t<i)break e}a=r.length;break r}if(!(t>=o)){let s=r[1];t<s&&(n=2,o=s);for(let l=n-2;;){if(o===void 0)return this._cachedIndex=0,this.beforeStart_(0,t,i);if(n===l)break;if(i=o,o=r[--n-1],t>=o)break e}a=n,n=0;break r}break t}for(;n<a;){let s=n+a>>>1;t<r[s]?a=s:n=s+1}if(i=r[n],o=r[n-1],o===void 0)return this._cachedIndex=0,this.beforeStart_(0,t,i);if(i===void 0)return n=r.length,this._cachedIndex=n,this.afterEnd_(n-1,o,t)}this._cachedIndex=n,this.intervalChanged_(n,o,i)}return this.interpolate_(n,o,t,i)}getSettings_(){return this.settings||this.DefaultSettings_}copySampleValue_(t){let r=this.resultBuffer,n=this.sampleValues,i=this.valueSize,o=t*i;for(let a=0;a!==i;++a)r[a]=n[o+a];return r}interpolate_(){throw new Error("call to abstract method")}intervalChanged_(){}};fh.prototype.beforeStart_=fh.prototype.copySampleValue_;fh.prototype.afterEnd_=fh.prototype.copySampleValue_;var SU=class extends fh{constructor(t,r,n,i){super(t,r,n,i),this._weightPrev=-0,this._offsetPrev=-0,this._weightNext=-0,this._offsetNext=-0,this.DefaultSettings_={endingStart:E1,endingEnd:E1}}intervalChanged_(t,r,n){let i=this.parameterPositions,o=t-2,a=t+1,s=i[o],l=i[a];if(s===void 0)switch(this.getSettings_().endingStart){case T1:o=t,s=2*r-n;break;case JP:o=i.length-2,s=r+i[o]-i[o+1];break;default:o=t,s=n}if(l===void 0)switch(this.getSettings_().endingEnd){case T1:a=t,l=2*n-r;break;case JP:a=1,l=n+i[1]-i[0];break;default:a=t-1,l=r}let c=(n-r)*.5,u=this.valueSize;this._weightPrev=c/(r-s),this._weightNext=c/(l-n),this._offsetPrev=o*u,this._offsetNext=a*u}interpolate_(t,r,n,i){let o=this.resultBuffer,a=this.sampleValues,s=this.valueSize,l=t*s,c=l-s,u=this._offsetPrev,h=this._offsetNext,f=this._weightPrev,p=this._weightNext,d=(n-r)/(i-r),g=d*d,_=g*d,y=-f*_+2*f*g-f*d,x=(1+f)*_+(-1.5-2*f)*g+(-.5+f)*d+1,b=(-1-p)*_+(1.5+p)*g+.5*d,S=p*_-p*g;for(let C=0;C!==s;++C)o[C]=y*a[u+C]+x*a[c+C]+b*a[l+C]+S*a[h+C];return o}},S6=class extends fh{constructor(t,r,n,i){super(t,r,n,i)}interpolate_(t,r,n,i){let o=this.resultBuffer,a=this.sampleValues,s=this.valueSize,l=t*s,c=l-s,u=(n-r)/(i-r),h=1-u;for(let f=0;f!==s;++f)o[f]=a[c+f]*h+a[l+f]*u;return o}},MU=class extends fh{constructor(t,r,n,i){super(t,r,n,i)}interpolate_(t){return this.copySampleValue_(t-1)}},Dl=class{constructor(t,r,n,i){if(t===void 0)throw new Error("THREE.KeyframeTrack: track name is undefined");if(r===void 0||r.length===0)throw new Error("THREE.KeyframeTrack: no keyframes in track named "+t);this.name=t,this.times=Yn.convertArray(r,this.TimeBufferType),this.values=Yn.convertArray(n,this.ValueBufferType),this.setInterpolation(i||this.DefaultInterpolation)}static toJSON(t){let r=t.constructor,n;if(r.toJSON!==this.toJSON)n=r.toJSON(t);else{n={name:t.name,times:Yn.convertArray(t.times,Array),values:Yn.convertArray(t.values,Array)};let i=t.getInterpolation();i!==t.DefaultInterpolation&&(n.interpolation=i)}return n.type=t.ValueTypeName,n}InterpolantFactoryMethodDiscrete(t){return new MU(this.times,this.values,this.getValueSize(),t)}InterpolantFactoryMethodLinear(t){return new S6(this.times,this.values,this.getValueSize(),t)}InterpolantFactoryMethodSmooth(t){return new SU(this.times,this.values,this.getValueSize(),t)}setInterpolation(t){let r;switch(t){case KP:r=this.InterpolantFactoryMethodDiscrete;break;case ZP:r=this.InterpolantFactoryMethodLinear;break;case rU:r=this.InterpolantFactoryMethodSmooth;break}if(r===void 0){let n="unsupported interpolation for "+this.ValueTypeName+" keyframe track named "+this.name;if(this.createInterpolant===void 0)if(t!==this.DefaultInterpolation)this.setInterpolation(this.DefaultInterpolation);else throw new Error(n);return console.warn("THREE.KeyframeTrack:",n),this}return this.createInterpolant=r,this}getInterpolation(){switch(this.createInterpolant){case this.InterpolantFactoryMethodDiscrete:return KP;case this.InterpolantFactoryMethodLinear:return ZP;case this.InterpolantFactoryMethodSmooth:return rU}}getValueSize(){return this.values.length/this.times.length}shift(t){if(t!==0){let r=this.times;for(let n=0,i=r.length;n!==i;++n)r[n]+=t}return this}scale(t){if(t!==1){let r=this.times;for(let n=0,i=r.length;n!==i;++n)r[n]*=t}return this}trim(t,r){let n=this.times,i=n.length,o=0,a=i-1;for(;o!==i&&n[o]<t;)++o;for(;a!==-1&&n[a]>r;)--a;if(++a,o!==0||a!==i){o>=a&&(a=Math.max(a,1),o=a-1);let s=this.getValueSize();this.times=Yn.arraySlice(n,o,a),this.values=Yn.arraySlice(this.values,o*s,a*s)}return this}validate(){let t=!0,r=this.getValueSize();r-Math.floor(r)!==0&&(console.error("THREE.KeyframeTrack: Invalid value size in track.",this),t=!1);let n=this.times,i=this.values,o=n.length;o===0&&(console.error("THREE.KeyframeTrack: Track is empty.",this),t=!1);let a=null;for(let s=0;s!==o;s++){let l=n[s];if(typeof l=="number"&&isNaN(l)){console.error("THREE.KeyframeTrack: Time is not a valid number.",this,s,l),t=!1;break}if(a!==null&&a>l){console.error("THREE.KeyframeTrack: Out of order keys.",this,s,l,a),t=!1;break}a=l}if(i!==void 0&&Yn.isTypedArray(i))for(let s=0,l=i.length;s!==l;++s){let c=i[s];if(isNaN(c)){console.error("THREE.KeyframeTrack: Value is not a valid number.",this,s,c),t=!1;break}}return t}optimize(){let t=Yn.arraySlice(this.times),r=Yn.arraySlice(this.values),n=this.getValueSize(),i=this.getInterpolation()===rU,o=t.length-1,a=1;for(let s=1;s<o;++s){let l=!1,c=t[s],u=t[s+1];if(c!==u&&(s!==1||c!==t[0]))if(i)l=!0;else{let h=s*n,f=h-n,p=h+n;for(let d=0;d!==n;++d){let g=r[h+d];if(g!==r[f+d]||g!==r[p+d]){l=!0;break}}}if(l){if(s!==a){t[a]=t[s];let h=s*n,f=a*n;for(let p=0;p!==n;++p)r[f+p]=r[h+p]}++a}}if(o>0){t[a]=t[o];for(let s=o*n,l=a*n,c=0;c!==n;++c)r[l+c]=r[s+c];++a}return a!==t.length?(this.times=Yn.arraySlice(t,0,a),this.values=Yn.arraySlice(r,0,a*n)):(this.times=t,this.values=r),this}clone(){let t=Yn.arraySlice(this.times,0),r=Yn.arraySlice(this.values,0),n=this.constructor,i=new n(this.name,t,r);return i.createInterpolant=this.createInterpolant,i}};Dl.prototype.TimeBufferType=Float32Array;Dl.prototype.ValueBufferType=Float32Array;Dl.prototype.DefaultInterpolation=ZP;var am=class extends Dl{};am.prototype.ValueTypeName="bool";am.prototype.ValueBufferType=Array;am.prototype.DefaultInterpolation=KP;am.prototype.InterpolantFactoryMethodLinear=void 0;am.prototype.InterpolantFactoryMethodSmooth=void 0;var M6=class extends Dl{};M6.prototype.ValueTypeName="color";var Z1=class extends Dl{};Z1.prototype.ValueTypeName="number";var EU=class extends fh{constructor(t,r,n,i){super(t,r,n,i)}interpolate_(t,r,n,i){let o=this.resultBuffer,a=this.sampleValues,s=this.valueSize,l=(n-r)/(i-r),c=t*s;for(let u=c+s;c!==u;c+=4)yi.slerpFlat(o,0,a,c-s,a,c,l);return o}},X0=class extends Dl{InterpolantFactoryMethodLinear(t){return new EU(this.times,this.values,this.getValueSize(),t)}};X0.prototype.ValueTypeName="quaternion";X0.prototype.DefaultInterpolation=ZP;X0.prototype.InterpolantFactoryMethodSmooth=void 0;var sm=class extends Dl{};sm.prototype.ValueTypeName="string";sm.prototype.ValueBufferType=Array;sm.prototype.DefaultInterpolation=KP;sm.prototype.InterpolantFactoryMethodLinear=void 0;sm.prototype.InterpolantFactoryMethodSmooth=void 0;var J1=class extends Dl{};J1.prototype.ValueTypeName="vector";var Q1=class{constructor(t,r=-1,n,i=$U){this.name=t,this.tracks=n,this.duration=r,this.blendMode=i,this.uuid=Nl(),this.duration<0&&this.resetDuration()}static parse(t){let r=[],n=t.tracks,i=1/(t.fps||1);for(let a=0,s=n.length;a!==s;++a)r.push(f0r(n[a]).scale(i));let o=new this(t.name,t.duration,r,t.blendMode);return o.uuid=t.uuid,o}static toJSON(t){let r=[],n=t.tracks,i={name:t.name,duration:t.duration,tracks:r,uuid:t.uuid,blendMode:t.blendMode};for(let o=0,a=n.length;o!==a;++o)r.push(Dl.toJSON(n[o]));return i}static CreateFromMorphTargetSequence(t,r,n,i){let o=r.length,a=[];for(let s=0;s<o;s++){let l=[],c=[];l.push((s+o-1)%o,s,(s+1)%o),c.push(0,1,0);let u=Yn.getKeyframeOrder(l);l=Yn.sortedArray(l,1,u),c=Yn.sortedArray(c,1,u),!i&&l[0]===0&&(l.push(o),c.push(c[0])),a.push(new Z1(".morphTargetInfluences["+r[s].name+"]",l,c).scale(1/n))}return new this(t,-1,a)}static findByName(t,r){let n=t;if(!Array.isArray(t)){let i=t;n=i.geometry&&i.geometry.animations||i.animations}for(let i=0;i<n.length;i++)if(n[i].name===r)return n[i];return null}static CreateClipsFromMorphTargetSequences(t,r,n){let i={},o=/^([\w-]*?)([\d]+)$/;for(let s=0,l=t.length;s<l;s++){let c=t[s],u=c.name.match(o);if(u&&u.length>1){let h=u[1],f=i[h];f||(i[h]=f=[]),f.push(c)}}let a=[];for(let s in i)a.push(this.CreateFromMorphTargetSequence(s,i[s],r,n));return a}static parseAnimation(t,r){if(!t)return console.error("THREE.AnimationClip: No animation in JSONLoader data."),null;let n=function(h,f,p,d,g){if(p.length!==0){let _=[],y=[];Yn.flattenJSON(p,_,y,d),_.length!==0&&g.push(new h(f,_,y))}},i=[],o=t.name||"default",a=t.fps||30,s=t.blendMode,l=t.length||-1,c=t.hierarchy||[];for(let h=0;h<c.length;h++){let f=c[h].keys;if(!(!f||f.length===0))if(f[0].morphTargets){let p={},d;for(d=0;d<f.length;d++)if(f[d].morphTargets)for(let g=0;g<f[d].morphTargets.length;g++)p[f[d].morphTargets[g]]=-1;for(let g in p){let _=[],y=[];for(let x=0;x!==f[d].morphTargets.length;++x){let b=f[d];_.push(b.time),y.push(b.morphTarget===g?1:0)}i.push(new Z1(".morphTargetInfluence["+g+"]",_,y))}l=p.length*(a||1)}else{let p=".bones["+r[h].name+"]";n(J1,p+".position",f,"pos",i),n(X0,p+".quaternion",f,"rot",i),n(J1,p+".scale",f,"scl",i)}}return i.length===0?null:new this(o,l,i,s)}resetDuration(){let t=this.tracks,r=0;for(let n=0,i=t.length;n!==i;++n){let o=this.tracks[n];r=Math.max(r,o.times[o.times.length-1])}return this.duration=r,this}trim(){for(let t=0;t<this.tracks.length;t++)this.tracks[t].trim(0,this.duration);return this}validate(){let t=!0;for(let r=0;r<this.tracks.length;r++)t=t&&this.tracks[r].validate();return t}optimize(){for(let t=0;t<this.tracks.length;t++)this.tracks[t].optimize();return this}clone(){let t=[];for(let r=0;r<this.tracks.length;r++)t.push(this.tracks[r].clone());return new this.constructor(this.name,this.duration,t,this.blendMode)}toJSON(){return this.constructor.toJSON(this)}};function h0r(e){switch(e.toLowerCase()){case"scalar":case"double":case"float":case"number":case"integer":return Z1;case"vector":case"vector2":case"vector3":case"vector4":return J1;case"color":return M6;case"quaternion":return X0;case"bool":case"boolean":return am;case"string":return sm}throw new Error("THREE.KeyframeTrack: Unsupported typeName: "+e)}function f0r(e){if(e.type===void 0)throw new Error("THREE.KeyframeTrack: track type undefined, can not parse");let t=h0r(e.type);if(e.times===void 0){let r=[],n=[];Yn.flattenJSON(e.keys,r,n,"value"),e.times=r,e.values=n}return t.parse!==void 0?t.parse(e):new t(e.name,e.times,e.values,e.interpolation)}var tx={enabled:!1,files:{},add:function(e,t){this.enabled!==!1&&(this.files[e]=t)},get:function(e){if(this.enabled!==!1)return this.files[e]},remove:function(e){delete this.files[e]},clear:function(){this.files={}}},E6=class{constructor(t,r,n){let i=this,o=!1,a=0,s=0,l,c=[];this.onStart=void 0,this.onLoad=t,this.onProgress=r,this.onError=n,this.itemStart=function(u){s++,o===!1&&i.onStart!==void 0&&i.onStart(u,a,s),o=!0},this.itemEnd=function(u){a++,i.onProgress!==void 0&&i.onProgress(u,a,s),a===s&&(o=!1,i.onLoad!==void 0&&i.onLoad())},this.itemError=function(u){i.onError!==void 0&&i.onError(u)},this.resolveURL=function(u){return l?l(u):u},this.setURLModifier=function(u){return l=u,this},this.addHandler=function(u,h){return c.push(u,h),this},this.removeHandler=function(u){let h=c.indexOf(u);return h!==-1&&c.splice(h,2),this},this.getHandler=function(u){for(let h=0,f=c.length;h<f;h+=2){let p=c[h],d=c[h+1];if(p.global&&(p.lastIndex=0),p.test(u))return d}return null}}},ipe=new E6,ea=class{constructor(t){this.manager=t!==void 0?t:ipe,this.crossOrigin="anonymous",this.withCredentials=!1,this.path="",this.resourcePath="",this.requestHeader={}}load(){}loadAsync(t,r){let n=this;return new Promise(function(i,o){n.load(t,i,r,o)})}parse(){}setCrossOrigin(t){return this.crossOrigin=t,this}setWithCredentials(t){return this.withCredentials=t,this}setPath(t){return this.path=t,this}setResourcePath(t){return this.resourcePath=t,this}setRequestHeader(t){return this.requestHeader=t,this}},Yd={},Jc=class extends ea{constructor(t){super(t)}load(t,r,n,i){t===void 0&&(t=""),this.path!==void 0&&(t=this.path+t),t=this.manager.resolveURL(t);let o=tx.get(t);if(o!==void 0)return this.manager.itemStart(t),setTimeout(()=>{r&&r(o),this.manager.itemEnd(t)},0),o;if(Yd[t]!==void 0){Yd[t].push({onLoad:r,onProgress:n,onError:i});return}Yd[t]=[],Yd[t].push({onLoad:r,onProgress:n,onError:i});let a=new Request(t,{headers:new Headers(this.requestHeader),credentials:this.withCredentials?"include":"same-origin"}),s=this.mimeType,l=this.responseType;fetch(a).then(c=>{if(c.status===200||c.status===0){if(c.status===0&&console.warn("THREE.FileLoader: HTTP Status 0 received."),typeof ReadableStream=="undefined"||c.body.getReader===void 0)return c;let u=Yd[t],h=c.body.getReader(),f=c.headers.get("Content-Length"),p=f?parseInt(f):0,d=p!==0,g=0,_=new ReadableStream({start(y){x();function x(){h.read().then(({done:b,value:S})=>{if(b)y.close();else{g+=S.byteLength;let C=new ProgressEvent("progress",{lengthComputable:d,loaded:g,total:p});for(let P=0,k=u.length;P<k;P++){let O=u[P];O.onProgress&&O.onProgress(C)}y.enqueue(S),x()}})}}});return new Response(_)}else throw Error(`fetch for "${c.url}" responded with ${c.status}: ${c.statusText}`)}).then(c=>{switch(l){case"arraybuffer":return c.arrayBuffer();case"blob":return c.blob();case"document":return c.text().then(u=>new DOMParser().parseFromString(u,s));case"json":return c.json();default:if(s===void 0)return c.text();{let h=/charset="?([^;"\s]*)"?/i.exec(s),f=h&&h[1]?h[1].toLowerCase():void 0,p=new TextDecoder(f);return c.arrayBuffer().then(d=>p.decode(d))}}}).then(c=>{tx.add(t,c);let u=Yd[t];delete Yd[t];for(let h=0,f=u.length;h<f;h++){let p=u[h];p.onLoad&&p.onLoad(c)}}).catch(c=>{let u=Yd[t];if(u===void 0)throw this.manager.itemError(t),c;delete Yd[t];for(let h=0,f=u.length;h<f;h++){let p=u[h];p.onError&&p.onError(c)}this.manager.itemError(t)}).finally(()=>{this.manager.itemEnd(t)}),this.manager.itemStart(t)}setResponseType(t){return this.responseType=t,this}setMimeType(t){return this.mimeType=t,this}},oht=class extends ea{constructor(t){super(t)}load(t,r,n,i){let o=this,a=new Jc(this.manager);a.setPath(this.path),a.setRequestHeader(this.requestHeader),a.setWithCredentials(this.withCredentials),a.load(t,function(s){try{r(o.parse(JSON.parse(s)))}catch(l){i?i(l):console.error(l),o.manager.itemError(t)}},n,i)}parse(t){let r=[];for(let n=0;n<t.length;n++){let i=Q1.parse(t[n]);r.push(i)}return r}},aht=class extends ea{constructor(t){super(t)}load(t,r,n,i){let o=this,a=[],s=new a6,l=new Jc(this.manager);l.setPath(this.path),l.setResponseType("arraybuffer"),l.setRequestHeader(this.requestHeader),l.setWithCredentials(o.withCredentials);let c=0;function u(h){l.load(t[h],function(f){let p=o.parse(f,!0);a[h]={width:p.width,height:p.height,format:p.format,mipmaps:p.mipmaps},c+=1,c===6&&(p.mipmapCount===1&&(s.minFilter=ii),s.image=a,s.format=p.format,s.needsUpdate=!0,r&&r(s))},n,i)}if(Array.isArray(t))for(let h=0,f=t.length;h<f;++h)u(h);else l.load(t,function(h){let f=o.parse(h,!0);if(f.isCubemap){let p=f.mipmaps.length/f.mipmapCount;for(let d=0;d<p;d++){a[d]={mipmaps:[]};for(let g=0;g<f.mipmapCount;g++)a[d].mipmaps.push(f.mipmaps[d*f.mipmapCount+g]),a[d].format=f.format,a[d].width=f.width,a[d].height=f.height}s.image=a}else s.image.width=f.width,s.image.height=f.height,s.mipmaps=f.mipmaps;f.mipmapCount===1&&(s.minFilter=ii),s.format=f.format,s.needsUpdate=!0,r&&r(s)},n,i);return s}},ex=class extends ea{constructor(t){super(t)}load(t,r,n,i){this.path!==void 0&&(t=this.path+t),t=this.manager.resolveURL(t);let o=this,a=tx.get(t);if(a!==void 0)return o.manager.itemStart(t),setTimeout(function(){r&&r(a),o.manager.itemEnd(t)},0),a;let s=t6("img");function l(){u(),tx.add(t,this),r&&r(this),o.manager.itemEnd(t)}function c(h){u(),i&&i(h),o.manager.itemError(t),o.manager.itemEnd(t)}function u(){s.removeEventListener("load",l,!1),s.removeEventListener("error",c,!1)}return s.addEventListener("load",l,!1),s.addEventListener("error",c,!1),t.substr(0,5)!=="data:"&&this.crossOrigin!==void 0&&(s.crossOrigin=this.crossOrigin),o.manager.itemStart(t),s.src=t,s}},TU=class extends ea{constructor(t){super(t)}load(t,r,n,i){let o=new H0,a=new ex(this.manager);a.setCrossOrigin(this.crossOrigin),a.setPath(this.path);let s=0;function l(c){a.load(t[c],function(u){o.images[c]=u,s++,s===6&&(o.needsUpdate=!0,r&&r(o))},void 0,i)}for(let c=0;c<t.length;++c)l(c);return o}},CU=class extends ea{constructor(t){super(t)}load(t,r,n,i){let o=this,a=new Jd,s=new Jc(this.manager);return s.setResponseType("arraybuffer"),s.setRequestHeader(this.requestHeader),s.setPath(this.path),s.setWithCredentials(o.withCredentials),s.load(t,function(l){let c=o.parse(l);!c||(c.image!==void 0?a.image=c.image:c.data!==void 0&&(a.image.width=c.width,a.image.height=c.height,a.image.data=c.data),a.wrapS=c.wrapS!==void 0?c.wrapS:Jo,a.wrapT=c.wrapT!==void 0?c.wrapT:Jo,a.magFilter=c.magFilter!==void 0?c.magFilter:ii,a.minFilter=c.minFilter!==void 0?c.minFilter:ii,a.anisotropy=c.anisotropy!==void 0?c.anisotropy:1,c.encoding!==void 0&&(a.encoding=c.encoding),c.flipY!==void 0&&(a.flipY=c.flipY),c.format!==void 0&&(a.format=c.format),c.type!==void 0&&(a.type=c.type),c.mipmaps!==void 0&&(a.mipmaps=c.mipmaps,a.minFilter=ox),c.mipmapCount===1&&(a.minFilter=ii),c.generateMipmaps!==void 0&&(a.generateMipmaps=c.generateMipmaps),a.needsUpdate=!0,r&&r(a,c))},n,i),a}},AU=class extends ea{constructor(t){super(t)}load(t,r,n,i){let o=new vi,a=new ex(this.manager);return a.setCrossOrigin(this.crossOrigin),a.setPath(this.path),a.load(t,function(s){o.image=s,o.needsUpdate=!0,r!==void 0&&r(o)},n,i),o}},Ol=class extends or{constructor(t,r=1){super(),this.type="Light",this.color=new ne(t),this.intensity=r}dispose(){}copy(t){return super.copy(t),this.color.copy(t.color),this.intensity=t.intensity,this}toJSON(t){let r=super.toJSON(t);return r.object.color=this.color.getHex(),r.object.intensity=this.intensity,this.groundColor!==void 0&&(r.object.groundColor=this.groundColor.getHex()),this.distance!==void 0&&(r.object.distance=this.distance),this.angle!==void 0&&(r.object.angle=this.angle),this.decay!==void 0&&(r.object.decay=this.decay),this.penumbra!==void 0&&(r.object.penumbra=this.penumbra),this.shadow!==void 0&&(r.object.shadow=this.shadow.toJSON()),r}};Ol.prototype.isLight=!0;var T6=class extends Ol{constructor(t,r,n){super(t,n),this.type="HemisphereLight",this.position.copy(or.DefaultUp),this.updateMatrix(),this.groundColor=new ne(r)}copy(t){return Ol.prototype.copy.call(this,t),this.groundColor.copy(t.groundColor),this}};T6.prototype.isHemisphereLight=!0;var xhe=new Me,bhe=new j,whe=new j,C6=class{constructor(t){this.camera=t,this.bias=0,this.normalBias=0,this.radius=1,this.blurSamples=8,this.mapSize=new Lt(512,512),this.map=null,this.mapPass=null,this.matrix=new Me,this.autoUpdate=!0,this.needsUpdate=!1,this._frustum=new N1,this._frameExtents=new Lt(1,1),this._viewportCount=1,this._viewports=[new en(0,0,1,1)]}getViewportCount(){return this._viewportCount}getFrustum(){return this._frustum}updateMatrices(t){let r=this.camera,n=this.matrix;bhe.setFromMatrixPosition(t.matrixWorld),r.position.copy(bhe),whe.setFromMatrixPosition(t.target.matrixWorld),r.lookAt(whe),r.updateMatrixWorld(),xhe.multiplyMatrices(r.projectionMatrix,r.matrixWorldInverse),this._frustum.setFromProjectionMatrix(xhe),n.set(.5,0,0,.5,0,.5,0,.5,0,0,.5,.5,0,0,0,1),n.multiply(r.projectionMatrix),n.multiply(r.matrixWorldInverse)}getViewport(t){return this._viewports[t]}getFrameExtents(){return this._frameExtents}dispose(){this.map&&this.map.dispose(),this.mapPass&&this.mapPass.dispose()}copy(t){return this.camera=t.camera.clone(),this.bias=t.bias,this.radius=t.radius,this.mapSize.copy(t.mapSize),this}clone(){return new this.constructor().copy(this)}toJSON(){let t={};return this.bias!==0&&(t.bias=this.bias),this.normalBias!==0&&(t.normalBias=this.normalBias),this.radius!==1&&(t.radius=this.radius),(this.mapSize.x!==512||this.mapSize.y!==512)&&(t.mapSize=this.mapSize.toArray()),t.camera=this.camera.toJSON(!1).object,delete t.camera.matrix,t}},PU=class extends C6{constructor(){super(new Ui(50,1,.5,500)),this.focus=1}updateMatrices(t){let r=this.camera,n=QP*2*t.angle*this.focus,i=this.mapSize.width/this.mapSize.height,o=t.distance||r.far;(n!==r.fov||i!==r.aspect||o!==r.far)&&(r.fov=n,r.aspect=i,r.far=o,r.updateProjectionMatrix()),super.updateMatrices(t)}copy(t){return super.copy(t),this.focus=t.focus,this}};PU.prototype.isSpotLightShadow=!0;var A6=class extends Ol{constructor(t,r,n=0,i=Math.PI/3,o=0,a=1){super(t,r),this.type="SpotLight",this.position.copy(or.DefaultUp),this.updateMatrix(),this.target=new or,this.distance=n,this.angle=i,this.penumbra=o,this.decay=a,this.shadow=new PU}get power(){return this.intensity*Math.PI}set power(t){this.intensity=t/Math.PI}dispose(){this.shadow.dispose()}copy(t){return super.copy(t),this.distance=t.distance,this.angle=t.angle,this.penumbra=t.penumbra,this.decay=t.decay,this.target=t.target.clone(),this.shadow=t.shadow.clone(),this}};A6.prototype.isSpotLight=!0;var She=new Me,BP=new j,xut=new j,IU=class extends C6{constructor(){super(new Ui(90,1,.5,500)),this._frameExtents=new Lt(4,2),this._viewportCount=6,this._viewports=[new en(2,1,1,1),new en(0,1,1,1),new en(3,1,1,1),new en(1,1,1,1),new en(3,0,1,1),new en(1,0,1,1)],this._cubeDirections=[new j(1,0,0),new j(-1,0,0),new j(0,0,1),new j(0,0,-1),new j(0,1,0),new j(0,-1,0)],this._cubeUps=[new j(0,1,0),new j(0,1,0),new j(0,1,0),new j(0,1,0),new j(0,0,1),new j(0,0,-1)]}updateMatrices(t,r=0){let n=this.camera,i=this.matrix,o=t.distance||n.far;o!==n.far&&(n.far=o,n.updateProjectionMatrix()),BP.setFromMatrixPosition(t.matrixWorld),n.position.copy(BP),xut.copy(n.position),xut.add(this._cubeDirections[r]),n.up.copy(this._cubeUps[r]),n.lookAt(xut),n.updateMatrixWorld(),i.makeTranslation(-BP.x,-BP.y,-BP.z),She.multiplyMatrices(n.projectionMatrix,n.matrixWorldInverse),this._frustum.setFromProjectionMatrix(She)}};IU.prototype.isPointLightShadow=!0;var P6=class extends Ol{constructor(t,r,n=0,i=1){super(t,r),this.type="PointLight",this.distance=n,this.decay=i,this.shadow=new IU}get power(){return this.intensity*4*Math.PI}set power(t){this.intensity=t/(4*Math.PI)}dispose(){this.shadow.dispose()}copy(t){return super.copy(t),this.distance=t.distance,this.decay=t.decay,this.shadow=t.shadow.clone(),this}};P6.prototype.isPointLight=!0;var LU=class extends C6{constructor(){super(new D1(-5,5,5,-5,.5,500))}};LU.prototype.isDirectionalLightShadow=!0;var I6=class extends Ol{constructor(t,r){super(t,r),this.type="DirectionalLight",this.position.copy(or.DefaultUp),this.updateMatrix(),this.target=new or,this.shadow=new LU}dispose(){this.shadow.dispose()}copy(t){return super.copy(t),this.target=t.target.clone(),this.shadow=t.shadow.clone(),this}};I6.prototype.isDirectionalLight=!0;var L6=class extends Ol{constructor(t,r){super(t,r),this.type="AmbientLight"}};L6.prototype.isAmbientLight=!0;var k6=class extends Ol{constructor(t,r,n=10,i=10){super(t,r),this.type="RectAreaLight",this.width=n,this.height=i}get power(){return this.intensity*this.width*this.height*Math.PI}set power(t){this.intensity=t/(this.width*this.height*Math.PI)}copy(t){return super.copy(t),this.width=t.width,this.height=t.height,this}toJSON(t){let r=super.toJSON(t);return r.object.width=this.width,r.object.height=this.height,r}};k6.prototype.isRectAreaLight=!0;var R6=class{constructor(){this.coefficients=[];for(let t=0;t<9;t++)this.coefficients.push(new j)}set(t){for(let r=0;r<9;r++)this.coefficients[r].copy(t[r]);return this}zero(){for(let t=0;t<9;t++)this.coefficients[t].set(0,0,0);return this}getAt(t,r){let n=t.x,i=t.y,o=t.z,a=this.coefficients;return r.copy(a[0]).multiplyScalar(.282095),r.addScaledVector(a[1],.488603*i),r.addScaledVector(a[2],.488603*o),r.addScaledVector(a[3],.488603*n),r.addScaledVector(a[4],1.092548*(n*i)),r.addScaledVector(a[5],1.092548*(i*o)),r.addScaledVector(a[6],.315392*(3*o*o-1)),r.addScaledVector(a[7],1.092548*(n*o)),r.addScaledVector(a[8],.546274*(n*n-i*i)),r}getIrradianceAt(t,r){let n=t.x,i=t.y,o=t.z,a=this.coefficients;return r.copy(a[0]).multiplyScalar(.886227),r.addScaledVector(a[1],2*.511664*i),r.addScaledVector(a[2],2*.511664*o),r.addScaledVector(a[3],2*.511664*n),r.addScaledVector(a[4],2*.429043*n*i),r.addScaledVector(a[5],2*.429043*i*o),r.addScaledVector(a[6],.743125*o*o-.247708),r.addScaledVector(a[7],2*.429043*n*o),r.addScaledVector(a[8],.429043*(n*n-i*i)),r}add(t){for(let r=0;r<9;r++)this.coefficients[r].add(t.coefficients[r]);return this}addScaledSH(t,r){for(let n=0;n<9;n++)this.coefficients[n].addScaledVector(t.coefficients[n],r);return this}scale(t){for(let r=0;r<9;r++)this.coefficients[r].multiplyScalar(t);return this}lerp(t,r){for(let n=0;n<9;n++)this.coefficients[n].lerp(t.coefficients[n],r);return this}equals(t){for(let r=0;r<9;r++)if(!this.coefficients[r].equals(t.coefficients[r]))return!1;return!0}copy(t){return this.set(t.coefficients)}clone(){return new this.constructor().copy(this)}fromArray(t,r=0){let n=this.coefficients;for(let i=0;i<9;i++)n[i].fromArray(t,r+i*3);return this}toArray(t=[],r=0){let n=this.coefficients;for(let i=0;i<9;i++)n[i].toArray(t,r+i*3);return t}static getBasisAt(t,r){let n=t.x,i=t.y,o=t.z;r[0]=.282095,r[1]=.488603*i,r[2]=.488603*o,r[3]=.488603*n,r[4]=1.092548*n*i,r[5]=1.092548*i*o,r[6]=.315392*(3*o*o-1),r[7]=1.092548*n*o,r[8]=.546274*(n*n-i*i)}};R6.prototype.isSphericalHarmonics3=!0;var rx=class extends Ol{constructor(t=new R6,r=1){super(void 0,r),this.sh=t}copy(t){return super.copy(t),this.sh.copy(t.sh),this}fromJSON(t){return this.intensity=t.intensity,this.sh.fromArray(t.sh),this}toJSON(t){let r=super.toJSON(t);return r.object.sh=this.sh.toArray(),r}};rx.prototype.isLightProbe=!0;var kU=class extends ea{constructor(t){super(t),this.textures={}}load(t,r,n,i){let o=this,a=new Jc(o.manager);a.setPath(o.path),a.setRequestHeader(o.requestHeader),a.setWithCredentials(o.withCredentials),a.load(t,function(s){try{r(o.parse(JSON.parse(s)))}catch(l){i?i(l):console.error(l),o.manager.itemError(t)}},n,i)}parse(t){let r=this.textures;function n(o){return r[o]===void 0&&console.warn("THREE.MaterialLoader: Undefined texture",o),r[o]}let i=new u0r[t.type];if(t.uuid!==void 0&&(i.uuid=t.uuid),t.name!==void 0&&(i.name=t.name),t.color!==void 0&&i.color!==void 0&&i.color.setHex(t.color),t.roughness!==void 0&&(i.roughness=t.roughness),t.metalness!==void 0&&(i.metalness=t.metalness),t.sheen!==void 0&&(i.sheen=t.sheen),t.sheenColor!==void 0&&(i.sheenColor=new ne().setHex(t.sheenColor)),t.sheenRoughness!==void 0&&(i.sheenRoughness=t.sheenRoughness),t.emissive!==void 0&&i.emissive!==void 0&&i.emissive.setHex(t.emissive),t.specular!==void 0&&i.specular!==void 0&&i.specular.setHex(t.specular),t.specularIntensity!==void 0&&(i.specularIntensity=t.specularIntensity),t.specularColor!==void 0&&i.specularColor!==void 0&&i.specularColor.setHex(t.specularColor),t.shininess!==void 0&&(i.shininess=t.shininess),t.clearcoat!==void 0&&(i.clearcoat=t.clearcoat),t.clearcoatRoughness!==void 0&&(i.clearcoatRoughness=t.clearcoatRoughness),t.transmission!==void 0&&(i.transmission=t.transmission),t.thickness!==void 0&&(i.thickness=t.thickness),t.attenuationDistance!==void 0&&(i.attenuationDistance=t.attenuationDistance),t.attenuationColor!==void 0&&i.attenuationColor!==void 0&&i.attenuationColor.setHex(t.attenuationColor),t.fog!==void 0&&(i.fog=t.fog),t.flatShading!==void 0&&(i.flatShading=t.flatShading),t.blending!==void 0&&(i.blending=t.blending),t.combine!==void 0&&(i.combine=t.combine),t.side!==void 0&&(i.side=t.side),t.shadowSide!==void 0&&(i.shadowSide=t.shadowSide),t.opacity!==void 0&&(i.opacity=t.opacity),t.transparent!==void 0&&(i.transparent=t.transparent),t.alphaTest!==void 0&&(i.alphaTest=t.alphaTest),t.depthTest!==void 0&&(i.depthTest=t.depthTest),t.depthWrite!==void 0&&(i.depthWrite=t.depthWrite),t.colorWrite!==void 0&&(i.colorWrite=t.colorWrite),t.alphaWrite!==void 0&&(i.alphaWrite=t.alphaWrite),t.stencilWrite!==void 0&&(i.stencilWrite=t.stencilWrite),t.stencilWriteMask!==void 0&&(i.stencilWriteMask=t.stencilWriteMask),t.stencilFunc!==void 0&&(i.stencilFunc=t.stencilFunc),t.stencilRef!==void 0&&(i.stencilRef=t.stencilRef),t.stencilFuncMask!==void 0&&(i.stencilFuncMask=t.stencilFuncMask),t.stencilFail!==void 0&&(i.stencilFail=t.stencilFail),t.stencilZFail!==void 0&&(i.stencilZFail=t.stencilZFail),t.stencilZPass!==void 0&&(i.stencilZPass=t.stencilZPass),t.wireframe!==void 0&&(i.wireframe=t.wireframe),t.wireframeLinewidth!==void 0&&(i.wireframeLinewidth=t.wireframeLinewidth),t.wireframeLinecap!==void 0&&(i.wireframeLinecap=t.wireframeLinecap),t.wireframeLinejoin!==void 0&&(i.wireframeLinejoin=t.wireframeLinejoin),t.rotation!==void 0&&(i.rotation=t.rotation),t.linewidth!==1&&(i.linewidth=t.linewidth),t.dashSize!==void 0&&(i.dashSize=t.dashSize),t.gapSize!==void 0&&(i.gapSize=t.gapSize),t.scale!==void 0&&(i.scale=t.scale),t.polygonOffset!==void 0&&(i.polygonOffset=t.polygonOffset),t.polygonOffsetFactor!==void 0&&(i.polygonOffsetFactor=t.polygonOffsetFactor),t.polygonOffsetUnits!==void 0&&(i.polygonOffsetUnits=t.polygonOffsetUnits),t.dithering!==void 0&&(i.dithering=t.dithering),t.alphaToCoverage!==void 0&&(i.alphaToCoverage=t.alphaToCoverage),t.premultipliedAlpha!==void 0&&(i.premultipliedAlpha=t.premultipliedAlpha),t.visible!==void 0&&(i.visible=t.visible),t.toneMapped!==void 0&&(i.toneMapped=t.toneMapped),t.userData!==void 0&&(i.userData=t.userData),t.vertexColors!==void 0&&(typeof t.vertexColors=="number"?i.vertexColors=t.vertexColors>0:i.vertexColors=t.vertexColors),t.uniforms!==void 0)for(let o in t.uniforms){let a=t.uniforms[o];switch(i.uniforms[o]={},a.type){case"t":i.uniforms[o].value=n(a.value);break;case"c":i.uniforms[o].value=new ne().setHex(a.value);break;case"v2":i.uniforms[o].value=new Lt().fromArray(a.value);break;case"v3":i.uniforms[o].value=new j().fromArray(a.value);break;case"v4":i.uniforms[o].value=new en().fromArray(a.value);break;case"m3":i.uniforms[o].value=new ki().fromArray(a.value);break;case"m4":i.uniforms[o].value=new Me().fromArray(a.value);break;default:i.uniforms[o].value=a.value}}if(t.defines!==void 0&&(i.defines=t.defines),t.vertexShader!==void 0&&(i.vertexShader=t.vertexShader),t.fragmentShader!==void 0&&(i.fragmentShader=t.fragmentShader),t.extensions!==void 0)for(let o in t.extensions)i.extensions[o]=t.extensions[o];if(t.shading!==void 0&&(i.flatShading=t.shading===1),t.size!==void 0&&(i.size=t.size),t.sizeAttenuation!==void 0&&(i.sizeAttenuation=t.sizeAttenuation),t.map!==void 0&&(i.map=n(t.map)),t.matcap!==void 0&&(i.matcap=n(t.matcap)),t.alphaMap!==void 0&&(i.alphaMap=n(t.alphaMap)),t.bumpMap!==void 0&&(i.bumpMap=n(t.bumpMap)),t.bumpScale!==void 0&&(i.bumpScale=t.bumpScale),t.normalMap!==void 0&&(i.normalMap=n(t.normalMap)),t.normalMapType!==void 0&&(i.normalMapType=t.normalMapType),t.normalScale!==void 0){let o=t.normalScale;Array.isArray(o)===!1&&(o=[o,o]),i.normalScale=new Lt().fromArray(o)}return t.displacementMap!==void 0&&(i.displacementMap=n(t.displacementMap)),t.displacementScale!==void 0&&(i.displacementScale=t.displacementScale),t.displacementBias!==void 0&&(i.displacementBias=t.displacementBias),t.roughnessMap!==void 0&&(i.roughnessMap=n(t.roughnessMap)),t.metalnessMap!==void 0&&(i.metalnessMap=n(t.metalnessMap)),t.emissiveMap!==void 0&&(i.emissiveMap=n(t.emissiveMap)),t.emissiveIntensity!==void 0&&(i.emissiveIntensity=t.emissiveIntensity),t.specularMap!==void 0&&(i.specularMap=n(t.specularMap)),t.specularIntensityMap!==void 0&&(i.specularIntensityMap=n(t.specularIntensityMap)),t.specularColorMap!==void 0&&(i.specularColorMap=n(t.specularColorMap)),t.envMap!==void 0&&(i.envMap=n(t.envMap)),t.envMapIntensity!==void 0&&(i.envMapIntensity=t.envMapIntensity),t.reflectivity!==void 0&&(i.reflectivity=t.reflectivity),t.refractionRatio!==void 0&&(i.refractionRatio=t.refractionRatio),t.lightMap!==void 0&&(i.lightMap=n(t.lightMap)),t.lightMapIntensity!==void 0&&(i.lightMapIntensity=t.lightMapIntensity),t.aoMap!==void 0&&(i.aoMap=n(t.aoMap)),t.aoMapIntensity!==void 0&&(i.aoMapIntensity=t.aoMapIntensity),t.gradientMap!==void 0&&(i.gradientMap=n(t.gradientMap)),t.clearcoatMap!==void 0&&(i.clearcoatMap=n(t.clearcoatMap)),t.clearcoatRoughnessMap!==void 0&&(i.clearcoatRoughnessMap=n(t.clearcoatRoughnessMap)),t.clearcoatNormalMap!==void 0&&(i.clearcoatNormalMap=n(t.clearcoatNormalMap)),t.clearcoatNormalScale!==void 0&&(i.clearcoatNormalScale=new Lt().fromArray(t.clearcoatNormalScale)),t.transmissionMap!==void 0&&(i.transmissionMap=n(t.transmissionMap)),t.thicknessMap!==void 0&&(i.thicknessMap=n(t.thicknessMap)),t.sheenColorMap!==void 0&&(i.sheenColorMap=n(t.sheenColorMap)),t.sheenRoughnessMap!==void 0&&(i.sheenRoughnessMap=n(t.sheenRoughnessMap)),i}setTextures(t){return this.textures=t,this}},dM=class{static decodeText(t){if(typeof TextDecoder!="undefined")return new TextDecoder().decode(t);let r="";for(let n=0,i=t.length;n<i;n++)r+=String.fromCharCode(t[n]);try{return decodeURIComponent(escape(r))}catch(n){return r}}static extractUrlBase(t){let r=t.lastIndexOf("/");return r===-1?"./":t.substr(0,r+1)}static resolveURL(t,r){return typeof t!="string"||t===""?"":(/^https?:\/\//i.test(r)&&/^\//.test(t)&&(r=r.replace(/(^https?:\/\/[^\/]+).*/i,"$1")),/^(https?:)?\/\//i.test(t)||/^data:.*,.*$/i.test(t)||/^blob:.*$/i.test(t)?t:r+t)}},N6=class extends Pe{constructor(){super(),this.type="InstancedBufferGeometry",this.instanceCount=1/0}copy(t){return super.copy(t),this.instanceCount=t.instanceCount,this}clone(){return new this.constructor().copy(this)}toJSON(){let t=super.toJSON(this);return t.instanceCount=this.instanceCount,t.isInstancedBufferGeometry=!0,t}};N6.prototype.isInstancedBufferGeometry=!0;var RU=class extends ea{constructor(t){super(t)}load(t,r,n,i){let o=this,a=new Jc(o.manager);a.setPath(o.path),a.setRequestHeader(o.requestHeader),a.setWithCredentials(o.withCredentials),a.load(t,function(s){try{r(o.parse(JSON.parse(s)))}catch(l){i?i(l):console.error(l),o.manager.itemError(t)}},n,i)}parse(t){let r={},n={};function i(p,d){if(r[d]!==void 0)return r[d];let _=p.interleavedBuffers[d],y=o(p,_.buffer),x=B3(_.type,y),b=new em(x,_.stride);return b.uuid=_.uuid,r[d]=b,b}function o(p,d){if(n[d]!==void 0)return n[d];let _=p.arrayBuffers[d],y=new Uint32Array(_).buffer;return n[d]=y,y}let a=t.isInstancedBufferGeometry?new N6:new Pe,s=t.data.index;if(s!==void 0){let p=B3(s.type,s.array);a.setIndex(new Je(p,1))}let l=t.data.attributes;for(let p in l){let d=l[p],g;if(d.isInterleavedBufferAttribute){let _=i(t.data,d.data);g=new tp(_,d.itemSize,d.offset,d.normalized)}else{let _=B3(d.type,d.array),y=d.isInstancedBufferAttribute?rm:Je;g=new y(_,d.itemSize,d.normalized)}d.name!==void 0&&(g.name=d.name),d.usage!==void 0&&g.setUsage(d.usage),d.updateRange!==void 0&&(g.updateRange.offset=d.updateRange.offset,g.updateRange.count=d.updateRange.count),a.setAttribute(p,g)}let c=t.data.morphAttributes;if(c)for(let p in c){let d=c[p],g=[];for(let _=0,y=d.length;_<y;_++){let x=d[_],b;if(x.isInterleavedBufferAttribute){let S=i(t.data,x.data);b=new tp(S,x.itemSize,x.offset,x.normalized)}else{let S=B3(x.type,x.array);b=new Je(S,x.itemSize,x.normalized)}x.name!==void 0&&(b.name=x.name),g.push(b)}a.morphAttributes[p]=g}t.data.morphTargetsRelative&&(a.morphTargetsRelative=!0);let h=t.data.groups||t.data.drawcalls||t.data.offsets;if(h!==void 0)for(let p=0,d=h.length;p!==d;++p){let g=h[p];a.addGroup(g.start,g.count,g.materialIndex)}let f=t.data.boundingSphere;if(f!==void 0){let p=new j;f.center!==void 0&&p.fromArray(f.center),a.boundingSphere=new Zf(p,f.radius)}return t.name&&(a.name=t.name),t.userData&&(a.userData=t.userData),a}},sht=class extends ea{constructor(t){super(t)}load(t,r,n,i){let o=this,a=this.path===""?dM.extractUrlBase(t):this.path;this.resourcePath=this.resourcePath||a;let s=new Jc(this.manager);s.setPath(this.path),s.setRequestHeader(this.requestHeader),s.setWithCredentials(this.withCredentials),s.load(t,function(l){let c=null;try{c=JSON.parse(l)}catch(h){i!==void 0&&i(h),console.error("THREE:ObjectLoader: Can't parse "+t+".",h.message);return}let u=c.metadata;if(u===void 0||u.type===void 0||u.type.toLowerCase()==="geometry"){console.error("THREE.ObjectLoader: Can't load "+t);return}o.parse(c,r)},n,i)}loadAsync(t,r){return Ri(this,null,function*(){let n=this,i=this.path===""?dM.extractUrlBase(t):this.path;this.resourcePath=this.resourcePath||i;let o=new Jc(this.manager);o.setPath(this.path),o.setRequestHeader(this.requestHeader),o.setWithCredentials(this.withCredentials);let a=yield o.loadAsync(t,r),s=JSON.parse(a),l=s.metadata;if(l===void 0||l.type===void 0||l.type.toLowerCase()==="geometry")throw new Error("THREE.ObjectLoader: Can't load "+t);return yield n.parseAsync(s)})}parse(t,r){let n=this.parseAnimations(t.animations),i=this.parseShapes(t.shapes),o=this.parseGeometries(t.geometries,i),a=this.parseImages(t.images,function(){r!==void 0&&r(c)}),s=this.parseTextures(t.textures,a),l=this.parseMaterials(t.materials,s),c=this.parseObject(t.object,o,l,s,n),u=this.parseSkeletons(t.skeletons,c);if(this.bindSkeletons(c,u),r!==void 0){let h=!1;for(let f in a)if(a[f]instanceof HTMLImageElement){h=!0;break}h===!1&&r(c)}return c}parseAsync(t){return Ri(this,null,function*(){let r=this.parseAnimations(t.animations),n=this.parseShapes(t.shapes),i=this.parseGeometries(t.geometries,n),o=yield this.parseImagesAsync(t.images),a=this.parseTextures(t.textures,o),s=this.parseMaterials(t.materials,a),l=this.parseObject(t.object,i,s,a,r),c=this.parseSkeletons(t.skeletons,l);return this.bindSkeletons(l,c),l})}parseShapes(t){let r={};if(t!==void 0)for(let n=0,i=t.length;n<i;n++){let o=new Kc().fromJSON(t[n]);r[o.uuid]=o}return r}parseSkeletons(t,r){let n={},i={};if(r.traverse(function(o){o.isBone&&(i[o.uuid]=o)}),t!==void 0)for(let o=0,a=t.length;o<a;o++){let s=new lM().fromJSON(t[o],i);n[s.uuid]=s}return n}parseGeometries(t,r){let n={};if(t!==void 0){let i=new RU;for(let o=0,a=t.length;o<a;o++){let s,l=t[o];switch(l.type){case"BufferGeometry":case"InstancedBufferGeometry":s=i.parse(l);break;case"Geometry":console.error("THREE.ObjectLoader: The legacy Geometry type is no longer supported.");break;default:l.type in vhe?s=vhe[l.type].fromJSON(l,r):console.warn(`THREE.ObjectLoader: Unsupported geometry type "${l.type}"`)}s.uuid=l.uuid,l.name!==void 0&&(s.name=l.name),s.isBufferGeometry===!0&&l.userData!==void 0&&(s.userData=l.userData),n[l.uuid]=s}}return n}parseMaterials(t,r){let n={},i={};if(t!==void 0){let o=new kU;o.setTextures(r);for(let a=0,s=t.length;a<s;a++){let l=t[a];if(l.type==="MultiMaterial"){let c=[];for(let u=0;u<l.materials.length;u++){let h=l.materials[u];n[h.uuid]===void 0&&(n[h.uuid]=o.parse(h)),c.push(n[h.uuid])}i[l.uuid]=c}else n[l.uuid]===void 0&&(n[l.uuid]=o.parse(l)),i[l.uuid]=n[l.uuid]}}return i}parseAnimations(t){let r={};if(t!==void 0)for(let n=0;n<t.length;n++){let i=t[n],o=Q1.parse(i);r[o.uuid]=o}return r}parseImages(t,r){let n=this,i={},o;function a(l){return n.manager.itemStart(l),o.load(l,function(){n.manager.itemEnd(l)},void 0,function(){n.manager.itemError(l),n.manager.itemEnd(l)})}function s(l){if(typeof l=="string"){let c=l,u=/^(\/\/)|([a-z]+:(\/\/)?)/i.test(c)?c:n.resourcePath+c;return a(u)}else return l.data?{data:B3(l.type,l.data),width:l.width,height:l.height}:null}if(t!==void 0&&t.length>0){let l=new E6(r);o=new ex(l),o.setCrossOrigin(this.crossOrigin);for(let c=0,u=t.length;c<u;c++){let h=t[c],f=h.url;if(Array.isArray(f)){i[h.uuid]=[];for(let p=0,d=f.length;p<d;p++){let g=f[p],_=s(g);_!==null&&(_ instanceof HTMLImageElement?i[h.uuid].push(_):i[h.uuid].push(new Jd(_.data,_.width,_.height)))}}else{let p=s(h.url);p!==null&&(i[h.uuid]=p)}}}return i}parseImagesAsync(t){return Ri(this,null,function*(){let r=this,n={},i;function o(a){return Ri(this,null,function*(){if(typeof a=="string"){let s=a,l=/^(\/\/)|([a-z]+:(\/\/)?)/i.test(s)?s:r.resourcePath+s;return yield i.loadAsync(l)}else return a.data?{data:B3(a.type,a.data),width:a.width,height:a.height}:null})}if(t!==void 0&&t.length>0){i=new ex(this.manager),i.setCrossOrigin(this.crossOrigin);for(let a=0,s=t.length;a<s;a++){let l=t[a],c=l.url;if(Array.isArray(c)){n[l.uuid]=[];for(let u=0,h=c.length;u<h;u++){let f=c[u],p=yield o(f);p!==null&&(p instanceof HTMLImageElement?n[l.uuid].push(p):n[l.uuid].push(new Jd(p.data,p.width,p.height)))}}else{let u=yield o(l.url);u!==null&&(n[l.uuid]=u)}}}return n})}parseTextures(t,r){function n(o,a){return typeof o=="number"?o:(console.warn("THREE.ObjectLoader.parseTexture: Constant should be in numeric form.",o),a[o])}let i={};if(t!==void 0)for(let o=0,a=t.length;o<a;o++){let s=t[o];s.image===void 0&&console.warn('THREE.ObjectLoader: No "image" specified for',s.uuid),r[s.image]===void 0&&console.warn("THREE.ObjectLoader: Undefined image",s.image);let l,c=r[s.image];Array.isArray(c)?(l=new H0(c),c.length===6&&(l.needsUpdate=!0)):(c&&c.data?l=new Jd(c.data,c.width,c.height):l=new vi(c),c&&(l.needsUpdate=!0)),l.uuid=s.uuid,s.name!==void 0&&(l.name=s.name),s.mapping!==void 0&&(l.mapping=n(s.mapping,p0r)),s.offset!==void 0&&l.offset.fromArray(s.offset),s.repeat!==void 0&&l.repeat.fromArray(s.repeat),s.center!==void 0&&l.center.fromArray(s.center),s.rotation!==void 0&&(l.rotation=s.rotation),s.wrap!==void 0&&(l.wrapS=n(s.wrap[0],Mhe),l.wrapT=n(s.wrap[1],Mhe)),s.format!==void 0&&(l.format=s.format),s.type!==void 0&&(l.type=s.type),s.encoding!==void 0&&(l.encoding=s.encoding),s.minFilter!==void 0&&(l.minFilter=n(s.minFilter,Ehe)),s.magFilter!==void 0&&(l.magFilter=n(s.magFilter,Ehe)),s.anisotropy!==void 0&&(l.anisotropy=s.anisotropy),s.flipY!==void 0&&(l.flipY=s.flipY),s.premultiplyAlpha!==void 0&&(l.premultiplyAlpha=s.premultiplyAlpha),s.unpackAlignment!==void 0&&(l.unpackAlignment=s.unpackAlignment),s.userData!==void 0&&(l.userData=s.userData),i[s.uuid]=l}return i}parseObject(t,r,n,i,o){let a;function s(f){return r[f]===void 0&&console.warn("THREE.ObjectLoader: Undefined geometry",f),r[f]}function l(f){if(f!==void 0){if(Array.isArray(f)){let p=[];for(let d=0,g=f.length;d<g;d++){let _=f[d];n[_]===void 0&&console.warn("THREE.ObjectLoader: Undefined material",_),p.push(n[_])}return p}return n[f]===void 0&&console.warn("THREE.ObjectLoader: Undefined material",f),n[f]}}function c(f){return i[f]===void 0&&console.warn("THREE.ObjectLoader: Undefined texture",f),i[f]}let u,h;switch(t.type){case"Scene":a=new q0,t.background!==void 0&&(Number.isInteger(t.background)?a.background=new ne(t.background):a.background=c(t.background)),t.environment!==void 0&&(a.environment=c(t.environment)),t.fog!==void 0&&(t.fog.type==="Fog"?a.fog=new z1(t.fog.color,t.fog.near,t.fog.far):t.fog.type==="FogExp2"&&(a.fog=new O1(t.fog.color,t.fog.density)));break;case"PerspectiveCamera":a=new Ui(t.fov,t.aspect,t.near,t.far),t.focus!==void 0&&(a.focus=t.focus),t.zoom!==void 0&&(a.zoom=t.zoom),t.filmGauge!==void 0&&(a.filmGauge=t.filmGauge),t.filmOffset!==void 0&&(a.filmOffset=t.filmOffset),t.view!==void 0&&(a.view=Object.assign({},t.view));break;case"OrthographicCamera":a=new D1(t.left,t.right,t.top,t.bottom,t.near,t.far),t.zoom!==void 0&&(a.zoom=t.zoom),t.view!==void 0&&(a.view=Object.assign({},t.view));break;case"AmbientLight":a=new L6(t.color,t.intensity);break;case"DirectionalLight":a=new I6(t.color,t.intensity);break;case"PointLight":a=new P6(t.color,t.intensity,t.distance,t.decay);break;case"RectAreaLight":a=new k6(t.color,t.intensity,t.width,t.height);break;case"SpotLight":a=new A6(t.color,t.intensity,t.distance,t.angle,t.penumbra,t.decay);break;case"HemisphereLight":a=new T6(t.color,t.groundColor,t.intensity);break;case"LightProbe":a=new rx().fromJSON(t);break;case"SkinnedMesh":u=s(t.geometry),h=l(t.material),a=new aM(u,h),t.bindMode!==void 0&&(a.bindMode=t.bindMode),t.bindMatrix!==void 0&&a.bindMatrix.fromArray(t.bindMatrix),t.skeleton!==void 0&&(a.skeleton=t.skeleton);break;case"Mesh":u=s(t.geometry),h=l(t.material),a=new ti(u,h);break;case"InstancedMesh":u=s(t.geometry),h=l(t.material);let f=t.count,p=t.instanceMatrix,d=t.instanceColor;a=new i6(u,h,f),a.instanceMatrix=new rm(new Float32Array(p.array),16),d!==void 0&&(a.instanceColor=new rm(new Float32Array(d.array),d.itemSize));break;case"LOD":a=new _U;break;case"Line":a=new ch(s(t.geometry),l(t.material));break;case"LineLoop":a=new o6(s(t.geometry),l(t.material));break;case"LineSegments":a=new Aa(s(t.geometry),l(t.material));break;case"PointCloud":case"Points":a=new im(s(t.geometry),l(t.material));break;case"Sprite":a=new oM(l(t.material));break;case"Group":a=new Xd;break;case"Bone":a=new sM;break;default:a=new or}if(a.uuid=t.uuid,t.name!==void 0&&(a.name=t.name),t.matrix!==void 0?(a.matrix.fromArray(t.matrix),t.matrixAutoUpdate!==void 0&&(a.matrixAutoUpdate=t.matrixAutoUpdate),a.matrixAutoUpdate&&a.matrix.decompose(a.position,a.quaternion,a.scale)):(t.position!==void 0&&a.position.fromArray(t.position),t.rotation!==void 0&&a.rotation.fromArray(t.rotation),t.quaternion!==void 0&&a.quaternion.fromArray(t.quaternion),t.scale!==void 0&&a.scale.fromArray(t.scale)),t.castShadow!==void 0&&(a.castShadow=t.castShadow),t.receiveShadow!==void 0&&(a.receiveShadow=t.receiveShadow),t.shadow&&(t.shadow.bias!==void 0&&(a.shadow.bias=t.shadow.bias),t.shadow.normalBias!==void 0&&(a.shadow.normalBias=t.shadow.normalBias),t.shadow.radius!==void 0&&(a.shadow.radius=t.shadow.radius),t.shadow.mapSize!==void 0&&a.shadow.mapSize.fromArray(t.shadow.mapSize),t.shadow.camera!==void 0&&(a.shadow.camera=this.parseObject(t.shadow.camera))),t.visible!==void 0&&(a.visible=t.visible),t.frustumCulled!==void 0&&(a.frustumCulled=t.frustumCulled),t.renderOrder!==void 0&&(a.renderOrder=t.renderOrder),t.userData!==void 0&&(a.userData=t.userData),t.layers!==void 0&&(a.layers.mask=t.layers),t.children!==void 0){let f=t.children;for(let p=0;p<f.length;p++)a.add(this.parseObject(f[p],r,n,i,o))}if(t.animations!==void 0){let f=t.animations;for(let p=0;p<f.length;p++){let d=f[p];a.animations.push(o[d])}}if(t.type==="LOD"){t.autoUpdate!==void 0&&(a.autoUpdate=t.autoUpdate);let f=t.levels;for(let p=0;p<f.length;p++){let d=f[p],g=a.getObjectByProperty("uuid",d.object);g!==void 0&&a.addLevel(g,d.distance)}}return a}bindSkeletons(t,r){Object.keys(r).length!==0&&t.traverse(function(n){if(n.isSkinnedMesh===!0&&n.skeleton!==void 0){let i=r[n.skeleton];i===void 0?console.warn("THREE.ObjectLoader: No skeleton found with UUID:",n.skeleton):n.bind(i,n.bindMatrix)}})}setTexturePath(t){return console.warn("THREE.ObjectLoader: .setTexturePath() has been renamed to .setResourcePath()."),this.setResourcePath(t)}},p0r={UVMapping:XU,CubeReflectionMapping:nx,CubeRefractionMapping:ix,EquirectangularReflectionMapping:YP,EquirectangularRefractionMapping:jP,CubeUVReflectionMapping:xM,CubeUVRefractionMapping:z6},Mhe={RepeatWrapping:XP,ClampToEdgeWrapping:Jo,MirroredRepeatWrapping:$P},Ehe={NearestFilter:Li,NearestMipmapNearestFilter:oU,NearestMipmapLinearFilter:aU,LinearFilter:ii,LinearMipmapNearestFilter:Lht,LinearMipmapLinearFilter:ox},NU=class extends ea{constructor(t){super(t),typeof createImageBitmap=="undefined"&&console.warn("THREE.ImageBitmapLoader: createImageBitmap() not supported."),typeof fetch=="undefined"&&console.warn("THREE.ImageBitmapLoader: fetch() not supported."),this.options={premultiplyAlpha:"none"}}setOptions(t){return this.options=t,this}load(t,r,n,i){t===void 0&&(t=""),this.path!==void 0&&(t=this.path+t),t=this.manager.resolveURL(t);let o=this,a=tx.get(t);if(a!==void 0)return o.manager.itemStart(t),setTimeout(function(){r&&r(a),o.manager.itemEnd(t)},0),a;let s={};s.credentials=this.crossOrigin==="anonymous"?"same-origin":"include",s.headers=this.requestHeader,fetch(t,s).then(function(l){return l.blob()}).then(function(l){return createImageBitmap(l,Object.assign(o.options,{colorSpaceConversion:"none"}))}).then(function(l){tx.add(t,l),r&&r(l),o.manager.itemEnd(t)}).catch(function(l){i&&i(l),o.manager.itemError(t),o.manager.itemEnd(t)}),o.manager.itemStart(t)}};NU.prototype.isImageBitmapLoader=!0;var WV,zht={getContext:function(){return WV===void 0&&(WV=new(window.AudioContext||window.webkitAudioContext)),WV},setContext:function(e){WV=e}},DU=class extends ea{constructor(t){super(t)}load(t,r,n,i){let o=this,a=new Jc(this.manager);a.setResponseType("arraybuffer"),a.setPath(this.path),a.setRequestHeader(this.requestHeader),a.setWithCredentials(this.withCredentials),a.load(t,function(s){try{let l=s.slice(0);zht.getContext().decodeAudioData(l,function(u){r(u)})}catch(l){i?i(l):console.error(l),o.manager.itemError(t)}},n,i)}},OU=class extends rx{constructor(t,r,n=1){super(void 0,n);let i=new ne().set(t),o=new ne().set(r),a=new j(i.r,i.g,i.b),s=new j(o.r,o.g,o.b),l=Math.sqrt(Math.PI),c=l*Math.sqrt(.75);this.sh.coefficients[0].copy(a).add(s).multiplyScalar(l),this.sh.coefficients[1].copy(a).sub(s).multiplyScalar(c)}};OU.prototype.isHemisphereLightProbe=!0;var zU=class extends rx{constructor(t,r=1){super(void 0,r);let n=new ne().set(t);this.sh.coefficients[0].set(n.r,n.g,n.b).multiplyScalar(2*Math.sqrt(Math.PI))}};zU.prototype.isAmbientLightProbe=!0;var The=new Me,Che=new Me,y1=new Me,lht=class{constructor(){this.type="StereoCamera",this.aspect=1,this.eyeSep=.064,this.cameraL=new Ui,this.cameraL.layers.enable(1),this.cameraL.matrixAutoUpdate=!1,this.cameraR=new Ui,this.cameraR.layers.enable(2),this.cameraR.matrixAutoUpdate=!1,this._cache={focus:null,fov:null,aspect:null,near:null,far:null,zoom:null,eyeSep:null}}update(t){let r=this._cache;if(r.focus!==t.focus||r.fov!==t.fov||r.aspect!==t.aspect*this.aspect||r.near!==t.near||r.far!==t.far||r.zoom!==t.zoom||r.eyeSep!==this.eyeSep){r.focus=t.focus,r.fov=t.fov,r.aspect=t.aspect*this.aspect,r.near=t.near,r.far=t.far,r.zoom=t.zoom,r.eyeSep=this.eyeSep,y1.copy(t.projectionMatrix);let i=r.eyeSep/2,o=i*r.near/r.focus,a=r.near*Math.tan(P1*r.fov*.5)/r.zoom,s,l;Che.elements[12]=-i,The.elements[12]=i,s=-a*r.aspect+o,l=a*r.aspect+o,y1.elements[0]=2*r.near/(l-s),y1.elements[8]=(l+s)/(l-s),this.cameraL.projectionMatrix.copy(y1),s=-a*r.aspect-o,l=a*r.aspect-o,y1.elements[0]=2*r.near/(l-s),y1.elements[8]=(l+s)/(l-s),this.cameraR.projectionMatrix.copy(y1)}this.cameraL.matrixWorld.copy(t.matrixWorld).multiply(Che),this.cameraR.matrixWorld.copy(t.matrixWorld).multiply(The)}},mM=class{constructor(t=!0){this.autoStart=t,this.startTime=0,this.oldTime=0,this.elapsedTime=0,this.running=!1}start(){this.startTime=Ahe(),this.oldTime=this.startTime,this.elapsedTime=0,this.running=!0}stop(){this.getElapsedTime(),this.running=!1,this.autoStart=!1}getElapsedTime(){return this.getDelta(),this.elapsedTime}getDelta(){let t=0;if(this.autoStart&&!this.running)return this.start(),0;if(this.running){let r=Ahe();t=(r-this.oldTime)/1e3,this.oldTime=r,this.elapsedTime+=t}return t}};function Ahe(){return(typeof performance=="undefined"?Date:performance).now()}var v1=new j,Phe=new yi,d0r=new j,x1=new j,cht=class extends or{constructor(){super(),this.type="AudioListener",this.context=zht.getContext(),this.gain=this.context.createGain(),this.gain.connect(this.context.destination),this.filter=null,this.timeDelta=0,this._clock=new mM}getInput(){return this.gain}removeFilter(){return this.filter!==null&&(this.gain.disconnect(this.filter),this.filter.disconnect(this.context.destination),this.gain.connect(this.context.destination),this.filter=null),this}getFilter(){return this.filter}setFilter(t){return this.filter!==null?(this.gain.disconnect(this.filter),this.filter.disconnect(this.context.destination)):this.gain.disconnect(this.context.destination),this.filter=t,this.gain.connect(this.filter),this.filter.connect(this.context.destination),this}getMasterVolume(){return this.gain.gain.value}setMasterVolume(t){return this.gain.gain.setTargetAtTime(t,this.context.currentTime,.01),this}updateMatrixWorld(t){super.updateMatrixWorld(t);let r=this.context.listener,n=this.up;if(this.timeDelta=this._clock.getDelta(),this.matrixWorld.decompose(v1,Phe,d0r),x1.set(0,0,-1).applyQuaternion(Phe),r.positionX){let i=this.context.currentTime+this.timeDelta;r.positionX.linearRampToValueAtTime(v1.x,i),r.positionY.linearRampToValueAtTime(v1.y,i),r.positionZ.linearRampToValueAtTime(v1.z,i),r.forwardX.linearRampToValueAtTime(x1.x,i),r.forwardY.linearRampToValueAtTime(x1.y,i),r.forwardZ.linearRampToValueAtTime(x1.z,i),r.upX.linearRampToValueAtTime(n.x,i),r.upY.linearRampToValueAtTime(n.y,i),r.upZ.linearRampToValueAtTime(n.z,i)}else r.setPosition(v1.x,v1.y,v1.z),r.setOrientation(x1.x,x1.y,x1.z,n.x,n.y,n.z)}},D6=class extends or{constructor(t){super(),this.type="Audio",this.listener=t,this.context=t.context,this.gain=this.context.createGain(),this.gain.connect(t.getInput()),this.autoplay=!1,this.buffer=null,this.detune=0,this.loop=!1,this.loopStart=0,this.loopEnd=0,this.offset=0,this.duration=void 0,this.playbackRate=1,this.isPlaying=!1,this.hasPlaybackControl=!0,this.source=null,this.sourceType="empty",this._startedAt=0,this._progress=0,this._connected=!1,this.filters=[]}getOutput(){return this.gain}setNodeSource(t){return this.hasPlaybackControl=!1,this.sourceType="audioNode",this.source=t,this.connect(),this}setMediaElementSource(t){return this.hasPlaybackControl=!1,this.sourceType="mediaNode",this.source=this.context.createMediaElementSource(t),this.connect(),this}setMediaStreamSource(t){return this.hasPlaybackControl=!1,this.sourceType="mediaStreamNode",this.source=this.context.createMediaStreamSource(t),this.connect(),this}setBuffer(t){return this.buffer=t,this.sourceType="buffer",this.autoplay&&this.play(),this}play(t=0){if(this.isPlaying===!0){console.warn("THREE.Audio: Audio is already playing.");return}if(this.hasPlaybackControl===!1){console.warn("THREE.Audio: this Audio has no playback control.");return}this._startedAt=this.context.currentTime+t;let r=this.context.createBufferSource();return r.buffer=this.buffer,r.loop=this.loop,r.loopStart=this.loopStart,r.loopEnd=this.loopEnd,r.onended=this.onEnded.bind(this),r.start(this._startedAt,this._progress+this.offset,this.duration),this.isPlaying=!0,this.source=r,this.setDetune(this.detune),this.setPlaybackRate(this.playbackRate),this.connect()}pause(){if(this.hasPlaybackControl===!1){console.warn("THREE.Audio: this Audio has no playback control.");return}return this.isPlaying===!0&&(this._progress+=Math.max(this.context.currentTime-this._startedAt,0)*this.playbackRate,this.loop===!0&&(this._progress=this._progress%(this.duration||this.buffer.duration)),this.source.stop(),this.source.onended=null,this.isPlaying=!1),this}stop(){if(this.hasPlaybackControl===!1){console.warn("THREE.Audio: this Audio has no playback control.");return}return this._progress=0,this.source.stop(),this.source.onended=null,this.isPlaying=!1,this}connect(){if(this.filters.length>0){this.source.connect(this.filters[0]);for(let t=1,r=this.filters.length;t<r;t++)this.filters[t-1].connect(this.filters[t]);this.filters[this.filters.length-1].connect(this.getOutput())}else this.source.connect(this.getOutput());return this._connected=!0,this}disconnect(){if(this.filters.length>0){this.source.disconnect(this.filters[0]);for(let t=1,r=this.filters.length;t<r;t++)this.filters[t-1].disconnect(this.filters[t]);this.filters[this.filters.length-1].disconnect(this.getOutput())}else this.source.disconnect(this.getOutput());return this._connected=!1,this}getFilters(){return this.filters}setFilters(t){return t||(t=[]),this._connected===!0?(this.disconnect(),this.filters=t.slice(),this.connect()):this.filters=t.slice(),this}setDetune(t){if(this.detune=t,this.source.detune!==void 0)return this.isPlaying===!0&&this.source.detune.setTargetAtTime(this.detune,this.context.currentTime,.01),this}getDetune(){return this.detune}getFilter(){return this.getFilters()[0]}setFilter(t){return this.setFilters(t?[t]:[])}setPlaybackRate(t){if(this.hasPlaybackControl===!1){console.warn("THREE.Audio: this Audio has no playback control.");return}return this.playbackRate=t,this.isPlaying===!0&&this.source.playbackRate.setTargetAtTime(this.playbackRate,this.context.currentTime,.01),this}getPlaybackRate(){return this.playbackRate}onEnded(){this.isPlaying=!1}getLoop(){return this.hasPlaybackControl===!1?(console.warn("THREE.Audio: this Audio has no playback control."),!1):this.loop}setLoop(t){if(this.hasPlaybackControl===!1){console.warn("THREE.Audio: this Audio has no playback control.");return}return this.loop=t,this.isPlaying===!0&&(this.source.loop=this.loop),this}setLoopStart(t){return this.loopStart=t,this}setLoopEnd(t){return this.loopEnd=t,this}getVolume(){return this.gain.gain.value}setVolume(t){return this.gain.gain.setTargetAtTime(t,this.context.currentTime,.01),this}},b1=new j,Ihe=new yi,m0r=new j,w1=new j,uht=class extends D6{constructor(t){super(t),this.panner=this.context.createPanner(),this.panner.panningModel="HRTF",this.panner.connect(this.gain)}getOutput(){return this.panner}getRefDistance(){return this.panner.refDistance}setRefDistance(t){return this.panner.refDistance=t,this}getRolloffFactor(){return this.panner.rolloffFactor}setRolloffFactor(t){return this.panner.rolloffFactor=t,this}getDistanceModel(){return this.panner.distanceModel}setDistanceModel(t){return this.panner.distanceModel=t,this}getMaxDistance(){return this.panner.maxDistance}setMaxDistance(t){return this.panner.maxDistance=t,this}setDirectionalCone(t,r,n){return this.panner.coneInnerAngle=t,this.panner.coneOuterAngle=r,this.panner.coneOuterGain=n,this}updateMatrixWorld(t){if(super.updateMatrixWorld(t),this.hasPlaybackControl===!0&&this.isPlaying===!1)return;this.matrixWorld.decompose(b1,Ihe,m0r),w1.set(0,0,1).applyQuaternion(Ihe);let r=this.panner;if(r.positionX){let n=this.context.currentTime+this.listener.timeDelta;r.positionX.linearRampToValueAtTime(b1.x,n),r.positionY.linearRampToValueAtTime(b1.y,n),r.positionZ.linearRampToValueAtTime(b1.z,n),r.orientationX.linearRampToValueAtTime(w1.x,n),r.orientationY.linearRampToValueAtTime(w1.y,n),r.orientationZ.linearRampToValueAtTime(w1.z,n)}else r.setPosition(b1.x,b1.y,b1.z),r.setOrientation(w1.x,w1.y,w1.z)}},FU=class{constructor(t,r=2048){this.analyser=t.context.createAnalyser(),this.analyser.fftSize=r,this.data=new Uint8Array(this.analyser.frequencyBinCount),t.getOutput().connect(this.analyser)}getFrequencyData(){return this.analyser.getByteFrequencyData(this.data),this.data}getAverageFrequency(){let t=0,r=this.getFrequencyData();for(let n=0;n<r.length;n++)t+=r[n];return t/r.length}},BU=class{constructor(t,r,n){this.binding=t,this.valueSize=n;let i,o,a;switch(r){case"quaternion":i=this._slerp,o=this._slerpAdditive,a=this._setAdditiveIdentityQuaternion,this.buffer=new Float64Array(n*6),this._workIndex=5;break;case"string":case"bool":i=this._select,o=this._select,a=this._setAdditiveIdentityOther,this.buffer=new Array(n*5);break;default:i=this._lerp,o=this._lerpAdditive,a=this._setAdditiveIdentityNumeric,this.buffer=new Float64Array(n*5)}this._mixBufferRegion=i,this._mixBufferRegionAdditive=o,this._setIdentity=a,this._origIndex=3,this._addIndex=4,this.cumulativeWeight=0,this.cumulativeWeightAdditive=0,this.useCount=0,this.referenceCount=0}accumulate(t,r){let n=this.buffer,i=this.valueSize,o=t*i+i,a=this.cumulativeWeight;if(a===0){for(let s=0;s!==i;++s)n[o+s]=n[s];a=r}else{a+=r;let s=r/a;this._mixBufferRegion(n,o,0,s,i)}this.cumulativeWeight=a}accumulateAdditive(t){let r=this.buffer,n=this.valueSize,i=n*this._addIndex;this.cumulativeWeightAdditive===0&&this._setIdentity(),this._mixBufferRegionAdditive(r,i,0,t,n),this.cumulativeWeightAdditive+=t}apply(t){let r=this.valueSize,n=this.buffer,i=t*r+r,o=this.cumulativeWeight,a=this.cumulativeWeightAdditive,s=this.binding;if(this.cumulativeWeight=0,this.cumulativeWeightAdditive=0,o<1){let l=r*this._origIndex;this._mixBufferRegion(n,i,l,1-o,r)}a>0&&this._mixBufferRegionAdditive(n,i,this._addIndex*r,1,r);for(let l=r,c=r+r;l!==c;++l)if(n[l]!==n[l+r]){s.setValue(n,i);break}}saveOriginalState(){let t=this.binding,r=this.buffer,n=this.valueSize,i=n*this._origIndex;t.getValue(r,i);for(let o=n,a=i;o!==a;++o)r[o]=r[i+o%n];this._setIdentity(),this.cumulativeWeight=0,this.cumulativeWeightAdditive=0}restoreOriginalState(){let t=this.valueSize*3;this.binding.setValue(this.buffer,t)}_setAdditiveIdentityNumeric(){let t=this._addIndex*this.valueSize,r=t+this.valueSize;for(let n=t;n<r;n++)this.buffer[n]=0}_setAdditiveIdentityQuaternion(){this._setAdditiveIdentityNumeric(),this.buffer[this._addIndex*this.valueSize+3]=1}_setAdditiveIdentityOther(){let t=this._origIndex*this.valueSize,r=this._addIndex*this.valueSize;for(let n=0;n<this.valueSize;n++)this.buffer[r+n]=this.buffer[t+n]}_select(t,r,n,i,o){if(i>=.5)for(let a=0;a!==o;++a)t[r+a]=t[n+a]}_slerp(t,r,n,i){yi.slerpFlat(t,r,t,r,t,n,i)}_slerpAdditive(t,r,n,i,o){let a=this._workIndex*o;yi.multiplyQuaternionsFlat(t,a,t,r,t,n),yi.slerpFlat(t,r,t,r,t,a,i)}_lerp(t,r,n,i,o){let a=1-i;for(let s=0;s!==o;++s){let l=r+s;t[l]=t[l]*a+t[n+s]*i}}_lerpAdditive(t,r,n,i,o){for(let a=0;a!==o;++a){let s=r+a;t[s]=t[s]+t[n+a]*i}}},Fht="\\[\\]\\.:\\/",g0r=new RegExp("["+Fht+"]","g"),Bht="[^"+Fht+"]",_0r="[^"+Fht.replace("\\.","")+"]",y0r=/((?:WC+[\/:])*)/.source.replace("WC",Bht),v0r=/(WCOD+)?/.source.replace("WCOD",_0r),x0r=/(?:\.(WC+)(?:\[(.+)\])?)?/.source.replace("WC",Bht),b0r=/\.(WC+)(?:\[(.+)\])?/.source.replace("WC",Bht),w0r=new RegExp("^"+y0r+v0r+x0r+b0r+"$"),S0r=["material","materials","bones"],hht=class{constructor(t,r,n){let i=n||Cr.parseTrackName(r);this._targetGroup=t,this._bindings=t.subscribe_(r,i)}getValue(t,r){this.bind();let n=this._targetGroup.nCachedObjects_,i=this._bindings[n];i!==void 0&&i.getValue(t,r)}setValue(t,r){let n=this._bindings;for(let i=this._targetGroup.nCachedObjects_,o=n.length;i!==o;++i)n[i].setValue(t,r)}bind(){let t=this._bindings;for(let r=this._targetGroup.nCachedObjects_,n=t.length;r!==n;++r)t[r].bind()}unbind(){let t=this._bindings;for(let r=this._targetGroup.nCachedObjects_,n=t.length;r!==n;++r)t[r].unbind()}},Cr=class{constructor(t,r,n){this.path=r,this.parsedPath=n||Cr.parseTrackName(r),this.node=Cr.findNode(t,this.parsedPath.nodeName)||t,this.rootNode=t,this.getValue=this._getValue_unbound,this.setValue=this._setValue_unbound}static create(t,r,n){return t&&t.isAnimationObjectGroup?new Cr.Composite(t,r,n):new Cr(t,r,n)}static sanitizeNodeName(t){return t.replace(/\s/g,"_").replace(g0r,"")}static parseTrackName(t){let r=w0r.exec(t);if(!r)throw new Error("PropertyBinding: Cannot parse trackName: "+t);let n={nodeName:r[2],objectName:r[3],objectIndex:r[4],propertyName:r[5],propertyIndex:r[6]},i=n.nodeName&&n.nodeName.lastIndexOf(".");if(i!==void 0&&i!==-1){let o=n.nodeName.substring(i+1);S0r.indexOf(o)!==-1&&(n.nodeName=n.nodeName.substring(0,i),n.objectName=o)}if(n.propertyName===null||n.propertyName.length===0)throw new Error("PropertyBinding: can not parse propertyName from trackName: "+t);return n}static findNode(t,r){if(!r||r===""||r==="."||r===-1||r===t.name||r===t.uuid)return t;if(t.skeleton){let n=t.skeleton.getBoneByName(r);if(n!==void 0)return n}if(t.children){let n=function(o){for(let a=0;a<o.length;a++){let s=o[a];if(s.name===r||s.uuid===r)return s;let l=n(s.children);if(l)return l}return null},i=n(t.children);if(i)return i}return null}_getValue_unavailable(){}_setValue_unavailable(){}_getValue_direct(t,r){t[r]=this.targetObject[this.propertyName]}_getValue_array(t,r){let n=this.resolvedProperty;for(let i=0,o=n.length;i!==o;++i)t[r++]=n[i]}_getValue_arrayElement(t,r){t[r]=this.resolvedProperty[this.propertyIndex]}_getValue_toArray(t,r){this.resolvedProperty.toArray(t,r)}_setValue_direct(t,r){this.targetObject[this.propertyName]=t[r]}_setValue_direct_setNeedsUpdate(t,r){this.targetObject[this.propertyName]=t[r],this.targetObject.needsUpdate=!0}_setValue_direct_setMatrixWorldNeedsUpdate(t,r){this.targetObject[this.propertyName]=t[r],this.targetObject.matrixWorldNeedsUpdate=!0}_setValue_array(t,r){let n=this.resolvedProperty;for(let i=0,o=n.length;i!==o;++i)n[i]=t[r++]}_setValue_array_setNeedsUpdate(t,r){let n=this.resolvedProperty;for(let i=0,o=n.length;i!==o;++i)n[i]=t[r++];this.targetObject.needsUpdate=!0}_setValue_array_setMatrixWorldNeedsUpdate(t,r){let n=this.resolvedProperty;for(let i=0,o=n.length;i!==o;++i)n[i]=t[r++];this.targetObject.matrixWorldNeedsUpdate=!0}_setValue_arrayElement(t,r){this.resolvedProperty[this.propertyIndex]=t[r]}_setValue_arrayElement_setNeedsUpdate(t,r){this.resolvedProperty[this.propertyIndex]=t[r],this.targetObject.needsUpdate=!0}_setValue_arrayElement_setMatrixWorldNeedsUpdate(t,r){this.resolvedProperty[this.propertyIndex]=t[r],this.targetObject.matrixWorldNeedsUpdate=!0}_setValue_fromArray(t,r){this.resolvedProperty.fromArray(t,r)}_setValue_fromArray_setNeedsUpdate(t,r){this.resolvedProperty.fromArray(t,r),this.targetObject.needsUpdate=!0}_setValue_fromArray_setMatrixWorldNeedsUpdate(t,r){this.resolvedProperty.fromArray(t,r),this.targetObject.matrixWorldNeedsUpdate=!0}_getValue_unbound(t,r){this.bind(),this.getValue(t,r)}_setValue_unbound(t,r){this.bind(),this.setValue(t,r)}bind(){let t=this.node,r=this.parsedPath,n=r.objectName,i=r.propertyName,o=r.propertyIndex;if(t||(t=Cr.findNode(this.rootNode,r.nodeName)||this.rootNode,this.node=t),this.getValue=this._getValue_unavailable,this.setValue=this._setValue_unavailable,!t){console.error("THREE.PropertyBinding: Trying to update node for track: "+this.path+" but it wasn't found.");return}if(n){let c=r.objectIndex;switch(n){case"materials":if(!t.material){console.error("THREE.PropertyBinding: Can not bind to material as node does not have a material.",this);return}if(!t.material.materials){console.error("THREE.PropertyBinding: Can not bind to material.materials as node.material does not have a materials array.",this);return}t=t.material.materials;break;case"bones":if(!t.skeleton){console.error("THREE.PropertyBinding: Can not bind to bones as node does not have a skeleton.",this);return}t=t.skeleton.bones;for(let u=0;u<t.length;u++)if(t[u].name===c){c=u;break}break;default:if(t[n]===void 0){console.error("THREE.PropertyBinding: Can not bind to objectName of node undefined.",this);return}t=t[n]}if(c!==void 0){if(t[c]===void 0){console.error("THREE.PropertyBinding: Trying to bind to objectIndex of objectName, but is undefined.",this,t);return}t=t[c]}}let a=t[i];if(a===void 0){let c=r.nodeName;console.error("THREE.PropertyBinding: Trying to update property for track: "+c+"."+i+" but it wasn't found.",t);return}let s=this.Versioning.None;this.targetObject=t,t.needsUpdate!==void 0?s=this.Versioning.NeedsUpdate:t.matrixWorldNeedsUpdate!==void 0&&(s=this.Versioning.MatrixWorldNeedsUpdate);let l=this.BindingType.Direct;if(o!==void 0){if(i==="morphTargetInfluences"){if(!t.geometry){console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.",this);return}if(t.geometry.isBufferGeometry){if(!t.geometry.morphAttributes){console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.morphAttributes.",this);return}t.morphTargetDictionary[o]!==void 0&&(o=t.morphTargetDictionary[o])}else{console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences on THREE.Geometry. Use THREE.BufferGeometry instead.",this);return}}l=this.BindingType.ArrayElement,this.resolvedProperty=a,this.propertyIndex=o}else a.fromArray!==void 0&&a.toArray!==void 0?(l=this.BindingType.HasFromToArray,this.resolvedProperty=a):Array.isArray(a)?(l=this.BindingType.EntireArray,this.resolvedProperty=a):this.propertyName=i;this.getValue=this.GetterByBindingType[l],this.setValue=this.SetterByBindingTypeAndVersioning[l][s]}unbind(){this.node=null,this.getValue=this._getValue_unbound,this.setValue=this._setValue_unbound}};Cr.Composite=hht;Cr.prototype.BindingType={Direct:0,EntireArray:1,ArrayElement:2,HasFromToArray:3};Cr.prototype.Versioning={None:0,NeedsUpdate:1,MatrixWorldNeedsUpdate:2};Cr.prototype.GetterByBindingType=[Cr.prototype._getValue_direct,Cr.prototype._getValue_array,Cr.prototype._getValue_arrayElement,Cr.prototype._getValue_toArray];Cr.prototype.SetterByBindingTypeAndVersioning=[[Cr.prototype._setValue_direct,Cr.prototype._setValue_direct_setNeedsUpdate,Cr.prototype._setValue_direct_setMatrixWorldNeedsUpdate],[Cr.prototype._setValue_array,Cr.prototype._setValue_array_setNeedsUpdate,Cr.prototype._setValue_array_setMatrixWorldNeedsUpdate],[Cr.prototype._setValue_arrayElement,Cr.prototype._setValue_arrayElement_setNeedsUpdate,Cr.prototype._setValue_arrayElement_setMatrixWorldNeedsUpdate],[Cr.prototype._setValue_fromArray,Cr.prototype._setValue_fromArray_setNeedsUpdate,Cr.prototype._setValue_fromArray_setMatrixWorldNeedsUpdate]];var HU=class{constructor(){this.uuid=Nl(),this._objects=Array.prototype.slice.call(arguments),this.nCachedObjects_=0;let t={};this._indicesByUUID=t;for(let n=0,i=arguments.length;n!==i;++n)t[arguments[n].uuid]=n;this._paths=[],this._parsedPaths=[],this._bindings=[],this._bindingsIndicesByPath={};let r=this;this.stats={objects:{get total(){return r._objects.length},get inUse(){return this.total-r.nCachedObjects_}},get bindingsPerObject(){return r._bindings.length}}}add(){let t=this._objects,r=this._indicesByUUID,n=this._paths,i=this._parsedPaths,o=this._bindings,a=o.length,s,l=t.length,c=this.nCachedObjects_;for(let u=0,h=arguments.length;u!==h;++u){let f=arguments[u],p=f.uuid,d=r[p];if(d===void 0){d=l++,r[p]=d,t.push(f);for(let g=0,_=a;g!==_;++g)o[g].push(new Cr(f,n[g],i[g]))}else if(d<c){s=t[d];let g=--c,_=t[g];r[_.uuid]=d,t[d]=_,r[p]=g,t[g]=f;for(let y=0,x=a;y!==x;++y){let b=o[y],S=b[g],C=b[d];b[d]=S,C===void 0&&(C=new Cr(f,n[y],i[y])),b[g]=C}}else t[d]!==s&&console.error("THREE.AnimationObjectGroup: Different objects with the same UUID detected. Clean the caches or recreate your infrastructure when reloading scenes.")}this.nCachedObjects_=c}remove(){let t=this._objects,r=this._indicesByUUID,n=this._bindings,i=n.length,o=this.nCachedObjects_;for(let a=0,s=arguments.length;a!==s;++a){let l=arguments[a],c=l.uuid,u=r[c];if(u!==void 0&&u>=o){let h=o++,f=t[h];r[f.uuid]=u,t[u]=f,r[c]=h,t[h]=l;for(let p=0,d=i;p!==d;++p){let g=n[p],_=g[h],y=g[u];g[u]=_,g[h]=y}}}this.nCachedObjects_=o}uncache(){let t=this._objects,r=this._indicesByUUID,n=this._bindings,i=n.length,o=this.nCachedObjects_,a=t.length;for(let s=0,l=arguments.length;s!==l;++s){let c=arguments[s],u=c.uuid,h=r[u];if(h!==void 0)if(delete r[u],h<o){let f=--o,p=t[f],d=--a,g=t[d];r[p.uuid]=h,t[h]=p,r[g.uuid]=f,t[f]=g,t.pop();for(let _=0,y=i;_!==y;++_){let x=n[_],b=x[f],S=x[d];x[h]=b,x[f]=S,x.pop()}}else{let f=--a,p=t[f];f>0&&(r[p.uuid]=h),t[h]=p,t.pop();for(let d=0,g=i;d!==g;++d){let _=n[d];_[h]=_[f],_.pop()}}}this.nCachedObjects_=o}subscribe_(t,r){let n=this._bindingsIndicesByPath,i=n[t],o=this._bindings;if(i!==void 0)return o[i];let a=this._paths,s=this._parsedPaths,l=this._objects,c=l.length,u=this.nCachedObjects_,h=new Array(c);i=o.length,n[t]=i,a.push(t),s.push(r),o.push(h);for(let f=u,p=l.length;f!==p;++f){let d=l[f];h[f]=new Cr(d,t,r)}return h}unsubscribe_(t){let r=this._bindingsIndicesByPath,n=r[t];if(n!==void 0){let i=this._paths,o=this._parsedPaths,a=this._bindings,s=a.length-1,l=a[s],c=t[s];r[c]=n,a[n]=l,a.pop(),o[n]=o[s],o.pop(),i[n]=i[s],i.pop()}}};HU.prototype.isAnimationObjectGroup=!0;var fht=class{constructor(t,r,n=null,i=r.blendMode){this._mixer=t,this._clip=r,this._localRoot=n,this.blendMode=i;let o=r.tracks,a=o.length,s=new Array(a),l={endingStart:E1,endingEnd:E1};for(let c=0;c!==a;++c){let u=o[c].createInterpolant(null);s[c]=u,u.settings=l}this._interpolantSettings=l,this._interpolants=s,this._propertyBindings=new Array(a),this._cacheIndex=null,this._byClipCacheIndex=null,this._timeScaleInterpolant=null,this._weightInterpolant=null,this.loop=Ife,this._loopCount=-1,this._startTime=null,this.time=0,this.timeScale=1,this._effectiveTimeScale=1,this.weight=1,this._effectiveWeight=1,this.repetitions=1/0,this.paused=!1,this.enabled=!0,this.clampWhenFinished=!1,this.zeroSlopeAtStart=!0,this.zeroSlopeAtEnd=!0}play(){return this._mixer._activateAction(this),this}stop(){return this._mixer._deactivateAction(this),this.reset()}reset(){return this.paused=!1,this.enabled=!0,this.time=0,this._loopCount=-1,this._startTime=null,this.stopFading().stopWarping()}isRunning(){return this.enabled&&!this.paused&&this.timeScale!==0&&this._startTime===null&&this._mixer._isActiveAction(this)}isScheduled(){return this._mixer._isActiveAction(this)}startAt(t){return this._startTime=t,this}setLoop(t,r){return this.loop=t,this.repetitions=r,this}setEffectiveWeight(t){return this.weight=t,this._effectiveWeight=this.enabled?t:0,this.stopFading()}getEffectiveWeight(){return this._effectiveWeight}fadeIn(t){return this._scheduleFading(t,0,1)}fadeOut(t){return this._scheduleFading(t,1,0)}crossFadeFrom(t,r,n){if(t.fadeOut(r),this.fadeIn(r),n){let i=this._clip.duration,o=t._clip.duration,a=o/i,s=i/o;t.warp(1,a,r),this.warp(s,1,r)}return this}crossFadeTo(t,r,n){return t.crossFadeFrom(this,r,n)}stopFading(){let t=this._weightInterpolant;return t!==null&&(this._weightInterpolant=null,this._mixer._takeBackControlInterpolant(t)),this}setEffectiveTimeScale(t){return this.timeScale=t,this._effectiveTimeScale=this.paused?0:t,this.stopWarping()}getEffectiveTimeScale(){return this._effectiveTimeScale}setDuration(t){return this.timeScale=this._clip.duration/t,this.stopWarping()}syncWith(t){return this.time=t.time,this.timeScale=t.timeScale,this.stopWarping()}halt(t){return this.warp(this._effectiveTimeScale,0,t)}warp(t,r,n){let i=this._mixer,o=i.time,a=this.timeScale,s=this._timeScaleInterpolant;s===null&&(s=i._lendControlInterpolant(),this._timeScaleInterpolant=s);let l=s.parameterPositions,c=s.sampleValues;return l[0]=o,l[1]=o+n,c[0]=t/a,c[1]=r/a,this}stopWarping(){let t=this._timeScaleInterpolant;return t!==null&&(this._timeScaleInterpolant=null,this._mixer._takeBackControlInterpolant(t)),this}getMixer(){return this._mixer}getClip(){return this._clip}getRoot(){return this._localRoot||this._mixer._root}_update(t,r,n,i){if(!this.enabled){this._updateWeight(t);return}let o=this._startTime;if(o!==null){let l=(t-o)*n;if(l<0||n===0)return;this._startTime=null,r=n*l}r*=this._updateTimeScale(t);let a=this._updateTime(r),s=this._updateWeight(t);if(s>0){let l=this._interpolants,c=this._propertyBindings;switch(this.blendMode){case kht:for(let u=0,h=l.length;u!==h;++u)l[u].evaluate(a),c[u].accumulateAdditive(s);break;case $U:default:for(let u=0,h=l.length;u!==h;++u)l[u].evaluate(a),c[u].accumulate(i,s)}}}_updateWeight(t){let r=0;if(this.enabled){r=this.weight;let n=this._weightInterpolant;if(n!==null){let i=n.evaluate(t)[0];r*=i,t>n.parameterPositions[1]&&(this.stopFading(),i===0&&(this.enabled=!1))}}return this._effectiveWeight=r,r}_updateTimeScale(t){let r=0;if(!this.paused){r=this.timeScale;let n=this._timeScaleInterpolant;n!==null&&(r*=n.evaluate(t)[0],t>n.parameterPositions[1]&&(this.stopWarping(),r===0?this.paused=!0:this.timeScale=r))}return this._effectiveTimeScale=r,r}_updateTime(t){let r=this._clip.duration,n=this.loop,i=this.time+t,o=this._loopCount,a=n===Lfe;if(t===0)return o===-1?i:a&&(o&1)===1?r-i:i;if(n===Pfe){o===-1&&(this._loopCount=0,this._setEndings(!0,!0,!1));t:{if(i>=r)i=r;else if(i<0)i=0;else{this.time=i;break t}this.clampWhenFinished?this.paused=!0:this.enabled=!1,this.time=i,this._mixer.dispatchEvent({type:"finished",action:this,direction:t<0?-1:1})}}else{if(o===-1&&(t>=0?(o=0,this._setEndings(!0,this.repetitions===0,a)):this._setEndings(this.repetitions===0,!0,a)),i>=r||i<0){let s=Math.floor(i/r);i-=r*s,o+=Math.abs(s);let l=this.repetitions-o;if(l<=0)this.clampWhenFinished?this.paused=!0:this.enabled=!1,i=t>0?r:0,this.time=i,this._mixer.dispatchEvent({type:"finished",action:this,direction:t>0?1:-1});else{if(l===1){let c=t<0;this._setEndings(c,!c,a)}else this._setEndings(!1,!1,a);this._loopCount=o,this.time=i,this._mixer.dispatchEvent({type:"loop",action:this,loopDelta:s})}}else this.time=i;if(a&&(o&1)===1)return r-i}return i}_setEndings(t,r,n){let i=this._interpolantSettings;n?(i.endingStart=T1,i.endingEnd=T1):(t?i.endingStart=this.zeroSlopeAtStart?T1:E1:i.endingStart=JP,r?i.endingEnd=this.zeroSlopeAtEnd?T1:E1:i.endingEnd=JP)}_scheduleFading(t,r,n){let i=this._mixer,o=i.time,a=this._weightInterpolant;a===null&&(a=i._lendControlInterpolant(),this._weightInterpolant=a);let s=a.parameterPositions,l=a.sampleValues;return s[0]=o,l[0]=r,s[1]=o+t,l[1]=n,this}},VU=class extends Us{constructor(t){super(),this._root=t,this._initMemoryManager(),this._accuIndex=0,this.time=0,this.timeScale=1}_bindAction(t,r){let n=t._localRoot||this._root,i=t._clip.tracks,o=i.length,a=t._propertyBindings,s=t._interpolants,l=n.uuid,c=this._bindingsByRootAndName,u=c[l];u===void 0&&(u={},c[l]=u);for(let h=0;h!==o;++h){let f=i[h],p=f.name,d=u[p];if(d!==void 0)++d.referenceCount,a[h]=d;else{if(d=a[h],d!==void 0){d._cacheIndex===null&&(++d.referenceCount,this._addInactiveBinding(d,l,p));continue}let g=r&&r._propertyBindings[h].binding.parsedPath;d=new BU(Cr.create(n,p,g),f.ValueTypeName,f.getValueSize()),++d.referenceCount,this._addInactiveBinding(d,l,p),a[h]=d}s[h].resultBuffer=d.buffer}}_activateAction(t){if(!this._isActiveAction(t)){if(t._cacheIndex===null){let n=(t._localRoot||this._root).uuid,i=t._clip.uuid,o=this._actionsByClip[i];this._bindAction(t,o&&o.knownActions[0]),this._addInactiveAction(t,i,n)}let r=t._propertyBindings;for(let n=0,i=r.length;n!==i;++n){let o=r[n];o.useCount++===0&&(this._lendBinding(o),o.saveOriginalState())}this._lendAction(t)}}_deactivateAction(t){if(this._isActiveAction(t)){let r=t._propertyBindings;for(let n=0,i=r.length;n!==i;++n){let o=r[n];--o.useCount===0&&(o.restoreOriginalState(),this._takeBackBinding(o))}this._takeBackAction(t)}}_initMemoryManager(){this._actions=[],this._nActiveActions=0,this._actionsByClip={},this._bindings=[],this._nActiveBindings=0,this._bindingsByRootAndName={},this._controlInterpolants=[],this._nActiveControlInterpolants=0;let t=this;this.stats={actions:{get total(){return t._actions.length},get inUse(){return t._nActiveActions}},bindings:{get total(){return t._bindings.length},get inUse(){return t._nActiveBindings}},controlInterpolants:{get total(){return t._controlInterpolants.length},get inUse(){return t._nActiveControlInterpolants}}}}_isActiveAction(t){let r=t._cacheIndex;return r!==null&&r<this._nActiveActions}_addInactiveAction(t,r,n){let i=this._actions,o=this._actionsByClip,a=o[r];if(a===void 0)a={knownActions:[t],actionByRoot:{}},t._byClipCacheIndex=0,o[r]=a;else{let s=a.knownActions;t._byClipCacheIndex=s.length,s.push(t)}t._cacheIndex=i.length,i.push(t),a.actionByRoot[n]=t}_removeInactiveAction(t){let r=this._actions,n=r[r.length-1],i=t._cacheIndex;n._cacheIndex=i,r[i]=n,r.pop(),t._cacheIndex=null;let o=t._clip.uuid,a=this._actionsByClip,s=a[o],l=s.knownActions,c=l[l.length-1],u=t._byClipCacheIndex;c._byClipCacheIndex=u,l[u]=c,l.pop(),t._byClipCacheIndex=null;let h=s.actionByRoot,f=(t._localRoot||this._root).uuid;delete h[f],l.length===0&&delete a[o],this._removeInactiveBindingsForAction(t)}_removeInactiveBindingsForAction(t){let r=t._propertyBindings;for(let n=0,i=r.length;n!==i;++n){let o=r[n];--o.referenceCount===0&&this._removeInactiveBinding(o)}}_lendAction(t){let r=this._actions,n=t._cacheIndex,i=this._nActiveActions++,o=r[i];t._cacheIndex=i,r[i]=t,o._cacheIndex=n,r[n]=o}_takeBackAction(t){let r=this._actions,n=t._cacheIndex,i=--this._nActiveActions,o=r[i];t._cacheIndex=i,r[i]=t,o._cacheIndex=n,r[n]=o}_addInactiveBinding(t,r,n){let i=this._bindingsByRootAndName,o=this._bindings,a=i[r];a===void 0&&(a={},i[r]=a),a[n]=t,t._cacheIndex=o.length,o.push(t)}_removeInactiveBinding(t){let r=this._bindings,n=t.binding,i=n.rootNode.uuid,o=n.path,a=this._bindingsByRootAndName,s=a[i],l=r[r.length-1],c=t._cacheIndex;l._cacheIndex=c,r[c]=l,r.pop(),delete s[o],Object.keys(s).length===0&&delete a[i]}_lendBinding(t){let r=this._bindings,n=t._cacheIndex,i=this._nActiveBindings++,o=r[i];t._cacheIndex=i,r[i]=t,o._cacheIndex=n,r[n]=o}_takeBackBinding(t){let r=this._bindings,n=t._cacheIndex,i=--this._nActiveBindings,o=r[i];t._cacheIndex=i,r[i]=t,o._cacheIndex=n,r[n]=o}_lendControlInterpolant(){let t=this._controlInterpolants,r=this._nActiveControlInterpolants++,n=t[r];return n===void 0&&(n=new S6(new Float32Array(2),new Float32Array(2),1,this._controlInterpolantsResultBuffer),n.__cacheIndex=r,t[r]=n),n}_takeBackControlInterpolant(t){let r=this._controlInterpolants,n=t.__cacheIndex,i=--this._nActiveControlInterpolants,o=r[i];t.__cacheIndex=i,r[i]=t,o.__cacheIndex=n,r[n]=o}clipAction(t,r,n){let i=r||this._root,o=i.uuid,a=typeof t=="string"?Q1.findByName(i,t):t,s=a!==null?a.uuid:t,l=this._actionsByClip[s],c=null;if(n===void 0&&(a!==null?n=a.blendMode:n=$U),l!==void 0){let h=l.actionByRoot[o];if(h!==void 0&&h.blendMode===n)return h;c=l.knownActions[0],a===null&&(a=c._clip)}if(a===null)return null;let u=new fht(this,a,r,n);return this._bindAction(u,c),this._addInactiveAction(u,s,o),u}existingAction(t,r){let n=r||this._root,i=n.uuid,o=typeof t=="string"?Q1.findByName(n,t):t,a=o?o.uuid:t,s=this._actionsByClip[a];return s!==void 0&&s.actionByRoot[i]||null}stopAllAction(){let t=this._actions,r=this._nActiveActions;for(let n=r-1;n>=0;--n)t[n].stop();return this}update(t){t*=this.timeScale;let r=this._actions,n=this._nActiveActions,i=this.time+=t,o=Math.sign(t),a=this._accuIndex^=1;for(let c=0;c!==n;++c)r[c]._update(i,t,o,a);let s=this._bindings,l=this._nActiveBindings;for(let c=0;c!==l;++c)s[c].apply(a);return this}setTime(t){this.time=0;for(let r=0;r<this._actions.length;r++)this._actions[r].time=0;return this.update(t)}getRoot(){return this._root}uncacheClip(t){let r=this._actions,n=t.uuid,i=this._actionsByClip,o=i[n];if(o!==void 0){let a=o.knownActions;for(let s=0,l=a.length;s!==l;++s){let c=a[s];this._deactivateAction(c);let u=c._cacheIndex,h=r[r.length-1];c._cacheIndex=null,c._byClipCacheIndex=null,h._cacheIndex=u,r[u]=h,r.pop(),this._removeInactiveBindingsForAction(c)}delete i[n]}}uncacheRoot(t){let r=t.uuid,n=this._actionsByClip;for(let a in n){let s=n[a].actionByRoot,l=s[r];l!==void 0&&(this._deactivateAction(l),this._removeInactiveAction(l))}let i=this._bindingsByRootAndName,o=i[r];if(o!==void 0)for(let a in o){let s=o[a];s.restoreOriginalState(),this._removeInactiveBinding(s)}}uncacheAction(t,r){let n=this.existingAction(t,r);n!==null&&(this._deactivateAction(n),this._removeInactiveAction(n))}};VU.prototype._controlInterpolantsResultBuffer=new Float32Array(1);var gM=class{constructor(t){typeof t=="string"&&(console.warn("THREE.Uniform: Type parameter is no longer needed."),t=arguments[1]),this.value=t}clone(){return new gM(this.value.clone===void 0?this.value:this.value.clone())}},UU=class extends em{constructor(t,r,n=1){super(t,r),this.meshPerAttribute=n}copy(t){return super.copy(t),this.meshPerAttribute=t.meshPerAttribute,this}clone(t){let r=super.clone(t);return r.meshPerAttribute=this.meshPerAttribute,r}toJSON(t){let r=super.toJSON(t);return r.isInstancedInterleavedBuffer=!0,r.meshPerAttribute=this.meshPerAttribute,r}};UU.prototype.isInstancedInterleavedBuffer=!0;var qU=class{constructor(t,r,n,i,o){this.buffer=t,this.type=r,this.itemSize=n,this.elementSize=i,this.count=o,this.version=0}set needsUpdate(t){t===!0&&this.version++}setBuffer(t){return this.buffer=t,this}setType(t,r){return this.type=t,this.elementSize=r,this}setItemSize(t){return this.itemSize=t,this}setCount(t){return this.count=t,this}};qU.prototype.isGLBufferAttribute=!0;var pht=class{constructor(t,r,n=0,i=1/0){this.ray=new Jf(t,r),this.near=n,this.far=i,this.camera=null,this.layers=new X3,this.params={Mesh:{},Line:{threshold:1},LOD:{},Points:{threshold:1},Sprite:{}}}set(t,r){this.ray.set(t,r)}setFromCamera(t,r){r&&r.isPerspectiveCamera?(this.ray.origin.setFromMatrixPosition(r.matrixWorld),this.ray.direction.set(t.x,t.y,.5).unproject(r).sub(this.ray.origin).normalize(),this.camera=r):r&&r.isOrthographicCamera?(this.ray.origin.set(t.x,t.y,(r.near+r.far)/(r.near-r.far)).unproject(r),this.ray.direction.set(0,0,-1).transformDirection(r.matrixWorld),this.camera=r):console.error("THREE.Raycaster: Unsupported camera type: "+r.type)}intersectObject(t,r=!0,n=[]){return dht(t,this,n,r),n.sort(Lhe),n}intersectObjects(t,r=!0,n=[]){for(let i=0,o=t.length;i<o;i++)dht(t[i],this,n,r);return n.sort(Lhe),n}};function Lhe(e,t){return e.distance-t.distance}function dht(e,t,r,n){if(e.layers.test(t.layers)&&e.raycast(t,r),n===!0){let i=e.children;for(let o=0,a=i.length;o<a;o++)dht(i[o],t,r,!0)}}var _M=class{constructor(t=1,r=0,n=0){return this.radius=t,this.phi=r,this.theta=n,this}set(t,r,n){return this.radius=t,this.phi=r,this.theta=n,this}copy(t){return this.radius=t.radius,this.phi=t.phi,this.theta=t.theta,this}makeSafe(){return this.phi=Math.max(1e-6,Math.min(Math.PI-1e-6,this.phi)),this}setFromVector3(t){return this.setFromCartesianCoords(t.x,t.y,t.z)}setFromCartesianCoords(t,r,n){return this.radius=Math.sqrt(t*t+r*r+n*n),this.radius===0?(this.theta=0,this.phi=0):(this.theta=Math.atan2(t,n),this.phi=Math.acos(Zo(r/this.radius,-1,1))),this}clone(){return new this.constructor().copy(this)}},mht=class{constructor(t=1,r=0,n=0){return this.radius=t,this.theta=r,this.y=n,this}set(t,r,n){return this.radius=t,this.theta=r,this.y=n,this}copy(t){return this.radius=t.radius,this.theta=t.theta,this.y=t.y,this}setFromVector3(t){return this.setFromCartesianCoords(t.x,t.y,t.z)}setFromCartesianCoords(t,r,n){return this.radius=Math.sqrt(t*t+n*n),this.theta=Math.atan2(t,n),this.y=r,this}clone(){return new this.constructor().copy(this)}},khe=new Lt,$0=class{constructor(t=new Lt(1/0,1/0),r=new Lt(-1/0,-1/0)){this.min=t,this.max=r}set(t,r){return this.min.copy(t),this.max.copy(r),this}setFromPoints(t){this.makeEmpty();for(let r=0,n=t.length;r<n;r++)this.expandByPoint(t[r]);return this}setFromCenterAndSize(t,r){let n=khe.copy(r).multiplyScalar(.5);return this.min.copy(t).sub(n),this.max.copy(t).add(n),this}clone(){return new this.constructor().copy(this)}copy(t){return this.min.copy(t.min),this.max.copy(t.max),this}makeEmpty(){return this.min.x=this.min.y=1/0,this.max.x=this.max.y=-1/0,this}isEmpty(){return this.max.x<this.min.x||this.max.y<this.min.y}getCenter(t){return this.isEmpty()?t.set(0,0):t.addVectors(this.min,this.max).multiplyScalar(.5)}getSize(t){return this.isEmpty()?t.set(0,0):t.subVectors(this.max,this.min)}expandByPoint(t){return this.min.min(t),this.max.max(t),this}expandByVector(t){return this.min.sub(t),this.max.add(t),this}expandByScalar(t){return this.min.addScalar(-t),this.max.addScalar(t),this}containsPoint(t){return!(t.x<this.min.x||t.x>this.max.x||t.y<this.min.y||t.y>this.max.y)}containsBox(t){return this.min.x<=t.min.x&&t.max.x<=this.max.x&&this.min.y<=t.min.y&&t.max.y<=this.max.y}getParameter(t,r){return r.set((t.x-this.min.x)/(this.max.x-this.min.x),(t.y-this.min.y)/(this.max.y-this.min.y))}intersectsBox(t){return!(t.max.x<this.min.x||t.min.x>this.max.x||t.max.y<this.min.y||t.min.y>this.max.y)}clampPoint(t,r){return r.copy(t).clamp(this.min,this.max)}distanceToPoint(t){return khe.copy(t).clamp(this.min,this.max).sub(t).length()}intersect(t){return this.min.max(t.min),this.max.min(t.max),this}union(t){return this.min.min(t.min),this.max.max(t.max),this}translate(t){return this.min.add(t),this.max.add(t),this}equals(t){return t.min.equals(this.min)&&t.max.equals(this.max)}};$0.prototype.isBox2=!0;var Rhe=new j,YV=new j,GU=class{constructor(t=new j,r=new j){this.start=t,this.end=r}set(t,r){return this.start.copy(t),this.end.copy(r),this}copy(t){return this.start.copy(t.start),this.end.copy(t.end),this}getCenter(t){return t.addVectors(this.start,this.end).multiplyScalar(.5)}delta(t){return t.subVectors(this.end,this.start)}distanceSq(){return this.start.distanceToSquared(this.end)}distance(){return this.start.distanceTo(this.end)}at(t,r){return this.delta(r).multiplyScalar(t).add(this.start)}closestPointToPointParameter(t,r){Rhe.subVectors(t,this.start),YV.subVectors(this.end,this.start);let n=YV.dot(YV),o=YV.dot(Rhe)/n;return r&&(o=Zo(o,0,1)),o}closestPointToPoint(t,r,n){let i=this.closestPointToPointParameter(t,r);return this.delta(n).multiplyScalar(i).add(this.start)}applyMatrix4(t){return this.start.applyMatrix4(t),this.end.applyMatrix4(t),this}equals(t){return t.start.equals(this.start)&&t.end.equals(this.end)}clone(){return new this.constructor().copy(this)}},Nhe=new j,ght=class extends or{constructor(t,r){super(),this.light=t,this.light.updateMatrixWorld(),this.matrix=t.matrixWorld,this.matrixAutoUpdate=!1,this.color=r;let n=new Pe,i=[0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,-1,0,1,0,0,0,0,1,1,0,0,0,0,-1,1];for(let a=0,s=1,l=32;a<l;a++,s++){let c=a/l*Math.PI*2,u=s/l*Math.PI*2;i.push(Math.cos(c),Math.sin(c),1,Math.cos(u),Math.sin(u),1)}n.setAttribute("position",new xe(i,3));let o=new Gi({fog:!1,toneMapped:!1});this.cone=new Aa(n,o),this.add(this.cone),this.update()}dispose(){this.cone.geometry.dispose(),this.cone.material.dispose()}update(){this.light.updateMatrixWorld();let t=this.light.distance?this.light.distance:1e3,r=t*Math.tan(this.light.angle);this.cone.scale.set(r,r,t),Nhe.setFromMatrixPosition(this.light.target.matrixWorld),this.cone.lookAt(Nhe),this.color!==void 0?this.cone.material.color.set(this.color):this.cone.material.color.copy(this.light.color)}},O0=new j,jV=new Me,but=new Me,WU=class extends Aa{constructor(t){let r=ope(t),n=new Pe,i=[],o=[],a=new ne(0,0,1),s=new ne(0,1,0);for(let c=0;c<r.length;c++){let u=r[c];u.parent&&u.parent.isBone&&(i.push(0,0,0),i.push(0,0,0),o.push(a.r,a.g,a.b),o.push(s.r,s.g,s.b))}n.setAttribute("position",new xe(i,3)),n.setAttribute("color",new xe(o,3));let l=new Gi({vertexColors:!0,depthTest:!1,depthWrite:!1,toneMapped:!1,transparent:!0});super(n,l),this.type="SkeletonHelper",this.isSkeletonHelper=!0,this.root=t,this.bones=r,this.matrix=t.matrixWorld,this.matrixAutoUpdate=!1}updateMatrixWorld(t){let r=this.bones,n=this.geometry,i=n.getAttribute("position");but.copy(this.root.matrixWorld).invert();for(let o=0,a=0;o<r.length;o++){let s=r[o];s.parent&&s.parent.isBone&&(jV.multiplyMatrices(but,s.matrixWorld),O0.setFromMatrixPosition(jV),i.setXYZ(a,O0.x,O0.y,O0.z),jV.multiplyMatrices(but,s.parent.matrixWorld),O0.setFromMatrixPosition(jV),i.setXYZ(a+1,O0.x,O0.y,O0.z),a+=2)}n.getAttribute("position").needsUpdate=!0,super.updateMatrixWorld(t)}};function ope(e){let t=[];e&&e.isBone&&t.push(e);for(let r=0;r<e.children.length;r++)t.push.apply(t,ope(e.children[r]));return t}var _ht=class extends ti{constructor(t,r,n){let i=new j0(r,4,2),o=new sh({wireframe:!0,fog:!1,toneMapped:!1});super(i,o),this.light=t,this.light.updateMatrixWorld(),this.color=n,this.type="PointLightHelper",this.matrix=this.light.matrixWorld,this.matrixAutoUpdate=!1,this.update()}dispose(){this.geometry.dispose(),this.material.dispose()}update(){this.color!==void 0?this.material.color.set(this.color):this.material.color.copy(this.light.color)}},M0r=new j,Dhe=new ne,Ohe=new ne,yht=class extends or{constructor(t,r,n){super(),this.light=t,this.light.updateMatrixWorld(),this.matrix=t.matrixWorld,this.matrixAutoUpdate=!1,this.color=n;let i=new W0(r);i.rotateY(Math.PI*.5),this.material=new sh({wireframe:!0,fog:!1,toneMapped:!1}),this.color===void 0&&(this.material.vertexColors=!0);let o=i.getAttribute("position"),a=new Float32Array(o.count*3);i.setAttribute("color",new Je(a,3)),this.add(new ti(i,this.material)),this.update()}dispose(){this.children[0].geometry.dispose(),this.children[0].material.dispose()}update(){let t=this.children[0];if(this.color!==void 0)this.material.color.set(this.color);else{let r=t.geometry.getAttribute("color");Dhe.copy(this.light.color),Ohe.copy(this.light.groundColor);for(let n=0,i=r.count;n<i;n++){let o=n<i/2?Dhe:Ohe;r.setXYZ(n,o.r,o.g,o.b)}r.needsUpdate=!0}t.lookAt(M0r.setFromMatrixPosition(this.light.matrixWorld).negate())}},YU=class extends Aa{constructor(t=10,r=10,n=4473924,i=8947848){n=new ne(n),i=new ne(i);let o=r/2,a=t/r,s=t/2,l=[],c=[];for(let f=0,p=0,d=-s;f<=r;f++,d+=a){l.push(-s,0,d,s,0,d),l.push(d,0,-s,d,0,s);let g=f===o?n:i;g.toArray(c,p),p+=3,g.toArray(c,p),p+=3,g.toArray(c,p),p+=3,g.toArray(c,p),p+=3}let u=new Pe;u.setAttribute("position",new xe(l,3)),u.setAttribute("color",new xe(c,3));let h=new Gi({vertexColors:!0,toneMapped:!1});super(u,h),this.type="GridHelper"}},vht=class extends Aa{constructor(t=10,r=16,n=8,i=64,o=4473924,a=8947848){o=new ne(o),a=new ne(a);let s=[],l=[];for(let h=0;h<=r;h++){let f=h/r*(Math.PI*2),p=Math.sin(f)*t,d=Math.cos(f)*t;s.push(0,0,0),s.push(p,0,d);let g=h&1?o:a;l.push(g.r,g.g,g.b),l.push(g.r,g.g,g.b)}for(let h=0;h<=n;h++){let f=h&1?o:a,p=t-t/n*h;for(let d=0;d<i;d++){let g=d/i*(Math.PI*2),_=Math.sin(g)*p,y=Math.cos(g)*p;s.push(_,0,y),l.push(f.r,f.g,f.b),g=(d+1)/i*(Math.PI*2),_=Math.sin(g)*p,y=Math.cos(g)*p,s.push(_,0,y),l.push(f.r,f.g,f.b)}}let c=new Pe;c.setAttribute("position",new xe(s,3)),c.setAttribute("color",new xe(l,3));let u=new Gi({vertexColors:!0,toneMapped:!1});super(c,u),this.type="PolarGridHelper"}},zhe=new j,XV=new j,Fhe=new j,xht=class extends or{constructor(t,r,n){super(),this.light=t,this.light.updateMatrixWorld(),this.matrix=t.matrixWorld,this.matrixAutoUpdate=!1,this.color=n,r===void 0&&(r=1);let i=new Pe;i.setAttribute("position",new xe([-r,r,0,r,r,0,r,-r,0,-r,-r,0,-r,r,0],3));let o=new Gi({fog:!1,toneMapped:!1});this.lightPlane=new ch(i,o),this.add(this.lightPlane),i=new Pe,i.setAttribute("position",new xe([0,0,0,0,0,1],3)),this.targetLine=new ch(i,o),this.add(this.targetLine),this.update()}dispose(){this.lightPlane.geometry.dispose(),this.lightPlane.material.dispose(),this.targetLine.geometry.dispose(),this.targetLine.material.dispose()}update(){zhe.setFromMatrixPosition(this.light.matrixWorld),XV.setFromMatrixPosition(this.light.target.matrixWorld),Fhe.subVectors(XV,zhe),this.lightPlane.lookAt(XV),this.color!==void 0?(this.lightPlane.material.color.set(this.color),this.targetLine.material.color.set(this.color)):(this.lightPlane.material.color.copy(this.light.color),this.targetLine.material.color.copy(this.light.color)),this.targetLine.lookAt(XV),this.targetLine.scale.z=Fhe.length()}},$V=new j,_i=new R1,bht=class extends Aa{constructor(t){let r=new Pe,n=new Gi({color:16777215,vertexColors:!0,toneMapped:!1}),i=[],o=[],a={},s=new ne(16755200),l=new ne(16711680),c=new ne(43775),u=new ne(16777215),h=new ne(3355443);f("n1","n2",s),f("n2","n4",s),f("n4","n3",s),f("n3","n1",s),f("f1","f2",s),f("f2","f4",s),f("f4","f3",s),f("f3","f1",s),f("n1","f1",s),f("n2","f2",s),f("n3","f3",s),f("n4","f4",s),f("p","n1",l),f("p","n2",l),f("p","n3",l),f("p","n4",l),f("u1","u2",c),f("u2","u3",c),f("u3","u1",c),f("c","t",u),f("p","c",h),f("cn1","cn2",h),f("cn3","cn4",h),f("cf1","cf2",h),f("cf3","cf4",h);function f(d,g,_){p(d,_),p(g,_)}function p(d,g){i.push(0,0,0),o.push(g.r,g.g,g.b),a[d]===void 0&&(a[d]=[]),a[d].push(i.length/3-1)}r.setAttribute("position",new xe(i,3)),r.setAttribute("color",new xe(o,3)),super(r,n),this.type="CameraHelper",this.camera=t,this.camera.updateProjectionMatrix&&this.camera.updateProjectionMatrix(),this.matrix=t.matrixWorld,this.matrixAutoUpdate=!1,this.pointMap=a,this.update()}update(){let t=this.geometry,r=this.pointMap,n=1,i=1;_i.projectionMatrixInverse.copy(this.camera.projectionMatrixInverse),Pi("c",r,t,_i,0,0,-1),Pi("t",r,t,_i,0,0,1),Pi("n1",r,t,_i,-n,-i,-1),Pi("n2",r,t,_i,n,-i,-1),Pi("n3",r,t,_i,-n,i,-1),Pi("n4",r,t,_i,n,i,-1),Pi("f1",r,t,_i,-n,-i,1),Pi("f2",r,t,_i,n,-i,1),Pi("f3",r,t,_i,-n,i,1),Pi("f4",r,t,_i,n,i,1),Pi("u1",r,t,_i,n*.7,i*1.1,-1),Pi("u2",r,t,_i,-n*.7,i*1.1,-1),Pi("u3",r,t,_i,0,i*2,-1),Pi("cf1",r,t,_i,-n,0,1),Pi("cf2",r,t,_i,n,0,1),Pi("cf3",r,t,_i,0,-i,1),Pi("cf4",r,t,_i,0,i,1),Pi("cn1",r,t,_i,-n,0,-1),Pi("cn2",r,t,_i,n,0,-1),Pi("cn3",r,t,_i,0,-i,-1),Pi("cn4",r,t,_i,0,i,-1),t.getAttribute("position").needsUpdate=!0}dispose(){this.geometry.dispose(),this.material.dispose()}};function Pi(e,t,r,n,i,o,a){$V.set(i,o,a).unproject(n);let s=t[e];if(s!==void 0){let l=r.getAttribute("position");for(let c=0,u=s.length;c<u;c++)l.setXYZ(s[c],$V.x,$V.y,$V.z)}}var KV=new ta,yM=class extends Aa{constructor(t,r=16776960){let n=new Uint16Array([0,1,1,2,2,3,3,0,4,5,5,6,6,7,7,4,0,4,1,5,2,6,3,7]),i=new Float32Array(8*3),o=new Pe;o.setIndex(new Je(n,1)),o.setAttribute("position",new Je(i,3)),super(o,new Gi({color:r,toneMapped:!1})),this.object=t,this.type="BoxHelper",this.matrixAutoUpdate=!1,this.update()}update(t){if(t!==void 0&&console.warn("THREE.BoxHelper: .update() has no longer arguments."),this.object!==void 0&&KV.setFromObject(this.object),KV.isEmpty())return;let r=KV.min,n=KV.max,i=this.geometry.attributes.position,o=i.array;o[0]=n.x,o[1]=n.y,o[2]=n.z,o[3]=r.x,o[4]=n.y,o[5]=n.z,o[6]=r.x,o[7]=r.y,o[8]=n.z,o[9]=n.x,o[10]=r.y,o[11]=n.z,o[12]=n.x,o[13]=n.y,o[14]=r.z,o[15]=r.x,o[16]=n.y,o[17]=r.z,o[18]=r.x,o[19]=r.y,o[20]=r.z,o[21]=n.x,o[22]=r.y,o[23]=r.z,i.needsUpdate=!0,this.geometry.computeBoundingSphere()}setFromObject(t){return this.object=t,this.update(),this}copy(t){return Aa.prototype.copy.call(this,t),this.object=t.object,this}},wht=class extends Aa{constructor(t,r=16776960){let n=new Uint16Array([0,1,1,2,2,3,3,0,4,5,5,6,6,7,7,4,0,4,1,5,2,6,3,7]),i=[1,1,1,-1,1,1,-1,-1,1,1,-1,1,1,1,-1,-1,1,-1,-1,-1,-1,1,-1,-1],o=new Pe;o.setIndex(new Je(n,1)),o.setAttribute("position",new xe(i,3)),super(o,new Gi({color:r,toneMapped:!1})),this.box=t,this.type="Box3Helper",this.geometry.computeBoundingSphere()}updateMatrixWorld(t){let r=this.box;r.isEmpty()||(r.getCenter(this.position),r.getSize(this.scale),this.scale.multiplyScalar(.5),super.updateMatrixWorld(t))}},Sht=class extends ch{constructor(t,r=1,n=16776960){let i=n,o=[1,-1,1,-1,1,1,-1,-1,1,1,1,1,-1,1,1,-1,-1,1,1,-1,1,1,1,1,0,0,1,0,0,0],a=new Pe;a.setAttribute("position",new xe(o,3)),a.computeBoundingSphere(),super(a,new Gi({color:i,toneMapped:!1})),this.type="PlaneHelper",this.plane=t,this.size=r;let s=[1,1,1,-1,1,1,-1,-1,1,1,1,1,-1,-1,1,1,-1,1],l=new Pe;l.setAttribute("position",new xe(s,3)),l.computeBoundingSphere(),this.add(new ti(l,new sh({color:i,opacity:.2,transparent:!0,depthWrite:!1,toneMapped:!1})))}updateMatrixWorld(t){let r=-this.plane.constant;Math.abs(r)<1e-8&&(r=1e-8),this.scale.set(.5*this.size,.5*this.size,r),this.children[0].material.side=r<0?Ii:I1,this.lookAt(this.plane.normal),super.updateMatrixWorld(t)}},Bhe=new j,ZV,wut,Mht=class extends or{constructor(t=new j(0,0,1),r=new j(0,0,0),n=1,i=16776960,o=n*.2,a=o*.2){super(),this.type="ArrowHelper",ZV===void 0&&(ZV=new Pe,ZV.setAttribute("position",new xe([0,0,0,0,1,0],3)),wut=new om(0,.5,1,5,1),wut.translate(0,-.5,0)),this.position.copy(r),this.line=new ch(ZV,new Gi({color:i,toneMapped:!1})),this.line.matrixAutoUpdate=!1,this.add(this.line),this.cone=new ti(wut,new sh({color:i,toneMapped:!1})),this.cone.matrixAutoUpdate=!1,this.add(this.cone),this.setDirection(t),this.setLength(n,o,a)}setDirection(t){if(t.y>.99999)this.quaternion.set(0,0,0,1);else if(t.y<-.99999)this.quaternion.set(1,0,0,0);else{Bhe.set(t.z,0,-t.x).normalize();let r=Math.acos(t.y);this.quaternion.setFromAxisAngle(Bhe,r)}}setLength(t,r=t*.2,n=r*.2){this.line.scale.set(1,Math.max(1e-4,t-r),1),this.line.updateMatrix(),this.cone.scale.set(n,r,n),this.cone.position.y=t,this.cone.updateMatrix()}setColor(t){this.line.material.color.set(t),this.cone.material.color.set(t)}copy(t){return super.copy(t,!1),this.line.copy(t.line),this.cone.copy(t.cone),this}},vM=class extends Aa{constructor(t=1){let r=[0,0,0,t,0,0,0,0,0,0,t,0,0,0,0,0,0,t],n=[1,0,0,1,.6,0,0,1,0,.6,1,0,0,0,1,0,.6,1],i=new Pe;i.setAttribute("position",new xe(r,3)),i.setAttribute("color",new xe(n,3));let o=new Gi({vertexColors:!0,toneMapped:!1});super(i,o),this.type="AxesHelper"}setColors(t,r,n){let i=new ne,o=this.geometry.attributes.color.array;return i.set(t),i.toArray(o,0),i.toArray(o,3),i.set(r),i.toArray(o,6),i.toArray(o,9),i.set(n),i.toArray(o,12),i.toArray(o,15),this.geometry.attributes.color.needsUpdate=!0,this}dispose(){this.geometry.dispose(),this.material.dispose()}},Eht=class{constructor(){this.type="ShapePath",this.color=new ne,this.subPaths=[],this.currentPath=null}moveTo(t,r){return this.currentPath=new q1,this.subPaths.push(this.currentPath),this.currentPath.moveTo(t,r),this}lineTo(t,r){return this.currentPath.lineTo(t,r),this}quadraticCurveTo(t,r,n,i){return this.currentPath.quadraticCurveTo(t,r,n,i),this}bezierCurveTo(t,r,n,i,o,a){return this.currentPath.bezierCurveTo(t,r,n,i,o,a),this}splineThru(t){return this.currentPath.splineThru(t),this}toShapes(t,r){function n(x){let b=[];for(let S=0,C=x.length;S<C;S++){let P=x[S],k=new Kc;k.curves=P.curves,b.push(k)}return b}function i(x,b){let S=b.length,C=!1;for(let P=S-1,k=0;k<S;P=k++){let O=b[P],D=b[k],B=D.x-O.x,I=D.y-O.y;if(Math.abs(I)>Number.EPSILON){if(I<0&&(O=b[k],B=-B,D=b[P],I=-I),x.y<O.y||x.y>D.y)continue;if(x.y===O.y){if(x.x===O.x)return!0}else{let L=I*(x.x-O.x)-B*(x.y-O.y);if(L===0)return!0;if(L<0)continue;C=!C}}else{if(x.y!==O.y)continue;if(D.x<=x.x&&x.x<=O.x||O.x<=x.x&&x.x<=D.x)return!0}}return C}let o=Zc.isClockWise,a=this.subPaths;if(a.length===0)return[];if(r===!0)return n(a);let s,l,c,u=[];if(a.length===1)return l=a[0],c=new Kc,c.curves=l.curves,u.push(c),u;let h=!o(a[0].getPoints());h=t?!h:h;let f=[],p=[],d=[],g=0,_;p[g]=void 0,d[g]=[];for(let x=0,b=a.length;x<b;x++)l=a[x],_=l.getPoints(),s=o(_),s=t?!s:s,s?(!h&&p[g]&&g++,p[g]={s:new Kc,p:_},p[g].s.curves=l.curves,h&&g++,d[g]=[]):d[g].push({h:l,p:_[0]});if(!p[0])return n(a);if(p.length>1){let x=!1,b=[];for(let S=0,C=p.length;S<C;S++)f[S]=[];for(let S=0,C=p.length;S<C;S++){let P=d[S];for(let k=0;k<P.length;k++){let O=P[k],D=!0;for(let B=0;B<p.length;B++)i(O.p,p[B].p)&&(S!==B&&b.push({froms:S,tos:B,hole:k}),D?(D=!1,f[B].push(O)):x=!0);D&&f[S].push(O)}}b.length>0&&(x||(d=f))}let y;for(let x=0,b=p.length;x<b;x++){c=p[x].s,u.push(c),y=d[x];for(let S=0,C=y.length;S<C;S++)c.holes.push(y[S].h)}return u}},ape=new Float32Array(1),E0r=new Int32Array(ape.buffer),Tht=class{static toHalfFloat(t){t>65504&&(console.warn("THREE.DataUtils.toHalfFloat(): value exceeds 65504."),t=65504),ape[0]=t;let r=E0r[0],n=r>>16&32768,i=r>>12&2047,o=r>>23&255;return o<103?n:o>142?(n|=31744,n|=(o==255?0:1)&&r&8388607,n):o<113?(i|=2048,n|=(i>>114-o)+(i>>113-o&1),n):(n|=o-112<<10|i>>1,n+=i&1,n)}},T0r=0,C0r=1,A0r=0,P0r=1,I0r=2;function L0r(e){return console.warn("THREE.MeshFaceMaterial has been removed. Use an Array instead."),e}function k0r(e=[]){return console.warn("THREE.MultiMaterial has been removed. Use an Array instead."),e.isMultiMaterial=!0,e.materials=e,e.clone=function(){return e.slice()},e}function R0r(e,t){return console.warn("THREE.PointCloud has been renamed to THREE.Points."),new im(e,t)}function N0r(e){return console.warn("THREE.Particle has been renamed to THREE.Sprite."),new oM(e)}function D0r(e,t){return console.warn("THREE.ParticleSystem has been renamed to THREE.Points."),new im(e,t)}function O0r(e){return console.warn("THREE.PointCloudMaterial has been renamed to THREE.PointsMaterial."),new nm(e)}function z0r(e){return console.warn("THREE.ParticleBasicMaterial has been renamed to THREE.PointsMaterial."),new nm(e)}function F0r(e){return console.warn("THREE.ParticleSystemMaterial has been renamed to THREE.PointsMaterial."),new nm(e)}function B0r(e,t,r){return console.warn("THREE.Vertex has been removed. Use THREE.Vector3 instead."),new j(e,t,r)}function H0r(e,t){return console.warn("THREE.DynamicBufferAttribute has been removed. Use new THREE.BufferAttribute().setUsage( THREE.DynamicDrawUsage ) instead."),new Je(e,t).setUsage(Y3)}function V0r(e,t){return console.warn("THREE.Int8Attribute has been removed. Use new THREE.Int8BufferAttribute() instead."),new cU(e,t)}function U0r(e,t){return console.warn("THREE.Uint8Attribute has been removed. Use new THREE.Uint8BufferAttribute() instead."),new uU(e,t)}function q0r(e,t){return console.warn("THREE.Uint8ClampedAttribute has been removed. Use new THREE.Uint8ClampedBufferAttribute() instead."),new hU(e,t)}function G0r(e,t){return console.warn("THREE.Int16Attribute has been removed. Use new THREE.Int16BufferAttribute() instead."),new fU(e,t)}function W0r(e,t){return console.warn("THREE.Uint16Attribute has been removed. Use new THREE.Uint16BufferAttribute() instead."),new $3(e,t)}function Y0r(e,t){return console.warn("THREE.Int32Attribute has been removed. Use new THREE.Int32BufferAttribute() instead."),new pU(e,t)}function j0r(e,t){return console.warn("THREE.Uint32Attribute has been removed. Use new THREE.Uint32BufferAttribute() instead."),new K3(e,t)}function X0r(e,t){return console.warn("THREE.Float32Attribute has been removed. Use new THREE.Float32BufferAttribute() instead."),new xe(e,t)}function $0r(e,t){return console.warn("THREE.Float64Attribute has been removed. Use new THREE.Float64BufferAttribute() instead."),new mU(e,t)}fs.create=function(e,t){return console.log("THREE.Curve.create() has been deprecated"),e.prototype=Object.create(fs.prototype),e.prototype.constructor=e,e.prototype.getPoint=t,e};q1.prototype.fromPoints=function(e){return console.warn("THREE.Path: .fromPoints() has been renamed to .setFromPoints()."),this.setFromPoints(e)};function K0r(e){return console.warn("THREE.AxisHelper has been renamed to THREE.AxesHelper."),new vM(e)}function Z0r(e,t){return console.warn("THREE.BoundingBoxHelper has been deprecated. Creating a THREE.BoxHelper instead."),new yM(e,t)}function J0r(e,t){return console.warn("THREE.EdgesHelper has been removed. Use THREE.EdgesGeometry instead."),new Aa(new s6(e.geometry),new Gi({color:t!==void 0?t:16777215}))}YU.prototype.setColors=function(){console.error("THREE.GridHelper: setColors() has been deprecated, pass them in the constructor instead.")};WU.prototype.update=function(){console.error("THREE.SkeletonHelper: update() no longer needs to be called.")};function Q0r(e,t){return console.warn("THREE.WireframeHelper has been removed. Use THREE.WireframeGeometry instead."),new Aa(new d6(e.geometry),new Gi({color:t!==void 0?t:16777215}))}ea.prototype.extractUrlBase=function(e){return console.warn("THREE.Loader: .extractUrlBase() has been deprecated. Use THREE.LoaderUtils.extractUrlBase() instead."),dM.extractUrlBase(e)};ea.Handlers={add:function(){console.error("THREE.Loader: Handlers.add() has been removed. Use LoadingManager.addHandler() instead.")},get:function(){console.error("THREE.Loader: Handlers.get() has been removed. Use LoadingManager.getHandler() instead.")}};function t_r(e){return console.warn("THREE.XHRLoader has been renamed to THREE.FileLoader."),new Jc(e)}function e_r(e){return console.warn("THREE.BinaryTextureLoader has been renamed to THREE.DataTextureLoader."),new CU(e)}$0.prototype.center=function(e){return console.warn("THREE.Box2: .center() has been renamed to .getCenter()."),this.getCenter(e)};$0.prototype.empty=function(){return console.warn("THREE.Box2: .empty() has been renamed to .isEmpty()."),this.isEmpty()};$0.prototype.isIntersectionBox=function(e){return console.warn("THREE.Box2: .isIntersectionBox() has been renamed to .intersectsBox()."),this.intersectsBox(e)};$0.prototype.size=function(e){return console.warn("THREE.Box2: .size() has been renamed to .getSize()."),this.getSize(e)};ta.prototype.center=function(e){return console.warn("THREE.Box3: .center() has been renamed to .getCenter()."),this.getCenter(e)};ta.prototype.empty=function(){return console.warn("THREE.Box3: .empty() has been renamed to .isEmpty()."),this.isEmpty()};ta.prototype.isIntersectionBox=function(e){return console.warn("THREE.Box3: .isIntersectionBox() has been renamed to .intersectsBox()."),this.intersectsBox(e)};ta.prototype.isIntersectionSphere=function(e){return console.warn("THREE.Box3: .isIntersectionSphere() has been renamed to .intersectsSphere()."),this.intersectsSphere(e)};ta.prototype.size=function(e){return console.warn("THREE.Box3: .size() has been renamed to .getSize()."),this.getSize(e)};Zf.prototype.empty=function(){return console.warn("THREE.Sphere: .empty() has been renamed to .isEmpty()."),this.isEmpty()};N1.prototype.setFromMatrix=function(e){return console.warn("THREE.Frustum: .setFromMatrix() has been renamed to .setFromProjectionMatrix()."),this.setFromProjectionMatrix(e)};GU.prototype.center=function(e){return console.warn("THREE.Line3: .center() has been renamed to .getCenter()."),this.getCenter(e)};ki.prototype.flattenToArrayOffset=function(e,t){return console.warn("THREE.Matrix3: .flattenToArrayOffset() has been deprecated. Use .toArray() instead."),this.toArray(e,t)};ki.prototype.multiplyVector3=function(e){return console.warn("THREE.Matrix3: .multiplyVector3() has been removed. Use vector.applyMatrix3( matrix ) instead."),e.applyMatrix3(this)};ki.prototype.multiplyVector3Array=function(){console.error("THREE.Matrix3: .multiplyVector3Array() has been removed.")};ki.prototype.applyToBufferAttribute=function(e){return console.warn("THREE.Matrix3: .applyToBufferAttribute() has been removed. Use attribute.applyMatrix3( matrix ) instead."),e.applyMatrix3(this)};ki.prototype.applyToVector3Array=function(){console.error("THREE.Matrix3: .applyToVector3Array() has been removed.")};ki.prototype.getInverse=function(e){return console.warn("THREE.Matrix3: .getInverse() has been removed. Use matrixInv.copy( matrix ).invert(); instead."),this.copy(e).invert()};Me.prototype.extractPosition=function(e){return console.warn("THREE.Matrix4: .extractPosition() has been renamed to .copyPosition()."),this.copyPosition(e)};Me.prototype.flattenToArrayOffset=function(e,t){return console.warn("THREE.Matrix4: .flattenToArrayOffset() has been deprecated. Use .toArray() instead."),this.toArray(e,t)};Me.prototype.getPosition=function(){return console.warn("THREE.Matrix4: .getPosition() has been removed. Use Vector3.setFromMatrixPosition( matrix ) instead."),new j().setFromMatrixColumn(this,3)};Me.prototype.setRotationFromQuaternion=function(e){return console.warn("THREE.Matrix4: .setRotationFromQuaternion() has been renamed to .makeRotationFromQuaternion()."),this.makeRotationFromQuaternion(e)};Me.prototype.multiplyToArray=function(){console.warn("THREE.Matrix4: .multiplyToArray() has been removed.")};Me.prototype.multiplyVector3=function(e){return console.warn("THREE.Matrix4: .multiplyVector3() has been removed. Use vector.applyMatrix4( matrix ) instead."),e.applyMatrix4(this)};Me.prototype.multiplyVector4=function(e){return console.warn("THREE.Matrix4: .multiplyVector4() has been removed. Use vector.applyMatrix4( matrix ) instead."),e.applyMatrix4(this)};Me.prototype.multiplyVector3Array=function(){console.error("THREE.Matrix4: .multiplyVector3Array() has been removed.")};Me.prototype.rotateAxis=function(e){console.warn("THREE.Matrix4: .rotateAxis() has been removed. Use Vector3.transformDirection( matrix ) instead."),e.transformDirection(this)};Me.prototype.crossVector=function(e){return console.warn("THREE.Matrix4: .crossVector() has been removed. Use vector.applyMatrix4( matrix ) instead."),e.applyMatrix4(this)};Me.prototype.translate=function(){console.error("THREE.Matrix4: .translate() has been removed.")};Me.prototype.rotateX=function(){console.error("THREE.Matrix4: .rotateX() has been removed.")};Me.prototype.rotateY=function(){console.error("THREE.Matrix4: .rotateY() has been removed.")};Me.prototype.rotateZ=function(){console.error("THREE.Matrix4: .rotateZ() has been removed.")};Me.prototype.rotateByAxis=function(){console.error("THREE.Matrix4: .rotateByAxis() has been removed.")};Me.prototype.applyToBufferAttribute=function(e){return console.warn("THREE.Matrix4: .applyToBufferAttribute() has been removed. Use attribute.applyMatrix4( matrix ) instead."),e.applyMatrix4(this)};Me.prototype.applyToVector3Array=function(){console.error("THREE.Matrix4: .applyToVector3Array() has been removed.")};Me.prototype.makeFrustum=function(e,t,r,n,i,o){return console.warn("THREE.Matrix4: .makeFrustum() has been removed. Use .makePerspective( left, right, top, bottom, near, far ) instead."),this.makePerspective(e,t,n,r,i,o)};Me.prototype.getInverse=function(e){return console.warn("THREE.Matrix4: .getInverse() has been removed. Use matrixInv.copy( matrix ).invert(); instead."),this.copy(e).invert()};$c.prototype.isIntersectionLine=function(e){return console.warn("THREE.Plane: .isIntersectionLine() has been renamed to .intersectsLine()."),this.intersectsLine(e)};yi.prototype.multiplyVector3=function(e){return console.warn("THREE.Quaternion: .multiplyVector3() has been removed. Use is now vector.applyQuaternion( quaternion ) instead."),e.applyQuaternion(this)};yi.prototype.inverse=function(){return console.warn("THREE.Quaternion: .inverse() has been renamed to invert()."),this.invert()};Jf.prototype.isIntersectionBox=function(e){return console.warn("THREE.Ray: .isIntersectionBox() has been renamed to .intersectsBox()."),this.intersectsBox(e)};Jf.prototype.isIntersectionPlane=function(e){return console.warn("THREE.Ray: .isIntersectionPlane() has been renamed to .intersectsPlane()."),this.intersectsPlane(e)};Jf.prototype.isIntersectionSphere=function(e){return console.warn("THREE.Ray: .isIntersectionSphere() has been renamed to .intersectsSphere()."),this.intersectsSphere(e)};oi.prototype.area=function(){return console.warn("THREE.Triangle: .area() has been renamed to .getArea()."),this.getArea()};oi.prototype.barycoordFromPoint=function(e,t){return console.warn("THREE.Triangle: .barycoordFromPoint() has been renamed to .getBarycoord()."),this.getBarycoord(e,t)};oi.prototype.midpoint=function(e){return console.warn("THREE.Triangle: .midpoint() has been renamed to .getMidpoint()."),this.getMidpoint(e)};oi.prototypenormal=function(e){return console.warn("THREE.Triangle: .normal() has been renamed to .getNormal()."),this.getNormal(e)};oi.prototype.plane=function(e){return console.warn("THREE.Triangle: .plane() has been renamed to .getPlane()."),this.getPlane(e)};oi.barycoordFromPoint=function(e,t,r,n,i){return console.warn("THREE.Triangle: .barycoordFromPoint() has been renamed to .getBarycoord()."),oi.getBarycoord(e,t,r,n,i)};oi.normal=function(e,t,r,n){return console.warn("THREE.Triangle: .normal() has been renamed to .getNormal()."),oi.getNormal(e,t,r,n)};Kc.prototype.extractAllPoints=function(e){return console.warn("THREE.Shape: .extractAllPoints() has been removed. Use .extractPoints() instead."),this.extractPoints(e)};Kc.prototype.extrude=function(e){return console.warn("THREE.Shape: .extrude() has been removed. Use ExtrudeGeometry() instead."),new hh(this,e)};Kc.prototype.makeGeometry=function(e){return console.warn("THREE.Shape: .makeGeometry() has been removed. Use ShapeGeometry() instead."),new Y0(this,e)};Lt.prototype.fromAttribute=function(e,t,r){return console.warn("THREE.Vector2: .fromAttribute() has been renamed to .fromBufferAttribute()."),this.fromBufferAttribute(e,t,r)};Lt.prototype.distanceToManhattan=function(e){return console.warn("THREE.Vector2: .distanceToManhattan() has been renamed to .manhattanDistanceTo()."),this.manhattanDistanceTo(e)};Lt.prototype.lengthManhattan=function(){return console.warn("THREE.Vector2: .lengthManhattan() has been renamed to .manhattanLength()."),this.manhattanLength()};j.prototype.setEulerFromRotationMatrix=function(){console.error("THREE.Vector3: .setEulerFromRotationMatrix() has been removed. Use Euler.setFromRotationMatrix() instead.")};j.prototype.setEulerFromQuaternion=function(){console.error("THREE.Vector3: .setEulerFromQuaternion() has been removed. Use Euler.setFromQuaternion() instead.")};j.prototype.getPositionFromMatrix=function(e){return console.warn("THREE.Vector3: .getPositionFromMatrix() has been renamed to .setFromMatrixPosition()."),this.setFromMatrixPosition(e)};j.prototype.getScaleFromMatrix=function(e){return console.warn("THREE.Vector3: .getScaleFromMatrix() has been renamed to .setFromMatrixScale()."),this.setFromMatrixScale(e)};j.prototype.getColumnFromMatrix=function(e,t){return console.warn("THREE.Vector3: .getColumnFromMatrix() has been renamed to .setFromMatrixColumn()."),this.setFromMatrixColumn(t,e)};j.prototype.applyProjection=function(e){return console.warn("THREE.Vector3: .applyProjection() has been removed. Use .applyMatrix4( m ) instead."),this.applyMatrix4(e)};j.prototype.fromAttribute=function(e,t,r){return console.warn("THREE.Vector3: .fromAttribute() has been renamed to .fromBufferAttribute()."),this.fromBufferAttribute(e,t,r)};j.prototype.distanceToManhattan=function(e){return console.warn("THREE.Vector3: .distanceToManhattan() has been renamed to .manhattanDistanceTo()."),this.manhattanDistanceTo(e)};j.prototype.lengthManhattan=function(){return console.warn("THREE.Vector3: .lengthManhattan() has been renamed to .manhattanLength()."),this.manhattanLength()};en.prototype.fromAttribute=function(e,t,r){return console.warn("THREE.Vector4: .fromAttribute() has been renamed to .fromBufferAttribute()."),this.fromBufferAttribute(e,t,r)};en.prototype.lengthManhattan=function(){return console.warn("THREE.Vector4: .lengthManhattan() has been renamed to .manhattanLength()."),this.manhattanLength()};or.prototype.getChildByName=function(e){return console.warn("THREE.Object3D: .getChildByName() has been renamed to .getObjectByName()."),this.getObjectByName(e)};or.prototype.renderDepth=function(){console.warn("THREE.Object3D: .renderDepth has been removed. Use .renderOrder, instead.")};or.prototype.translate=function(e,t){return console.warn("THREE.Object3D: .translate() has been removed. Use .translateOnAxis( axis, distance ) instead."),this.translateOnAxis(t,e)};or.prototype.getWorldRotation=function(){console.error("THREE.Object3D: .getWorldRotation() has been removed. Use THREE.Object3D.getWorldQuaternion( target ) instead.")};or.prototype.applyMatrix=function(e){return console.warn("THREE.Object3D: .applyMatrix() has been renamed to .applyMatrix4()."),this.applyMatrix4(e)};Object.defineProperties(or.prototype,{eulerOrder:{get:function(){return console.warn("THREE.Object3D: .eulerOrder is now .rotation.order."),this.rotation.order},set:function(e){console.warn("THREE.Object3D: .eulerOrder is now .rotation.order."),this.rotation.order=e}},useQuaternion:{get:function(){console.warn("THREE.Object3D: .useQuaternion has been removed. The library now uses quaternions by default.")},set:function(){console.warn("THREE.Object3D: .useQuaternion has been removed. The library now uses quaternions by default.")}}});ti.prototype.setDrawMode=function(){console.error("THREE.Mesh: .setDrawMode() has been removed. The renderer now always assumes THREE.TrianglesDrawMode. Transform your geometry via BufferGeometryUtils.toTrianglesDrawMode() if necessary.")};Object.defineProperties(ti.prototype,{drawMode:{get:function(){return console.error("THREE.Mesh: .drawMode has been removed. The renderer now always assumes THREE.TrianglesDrawMode."),kfe},set:function(){console.error("THREE.Mesh: .drawMode has been removed. The renderer now always assumes THREE.TrianglesDrawMode. Transform your geometry via BufferGeometryUtils.toTrianglesDrawMode() if necessary.")}}});aM.prototype.initBones=function(){console.error("THREE.SkinnedMesh: initBones() has been removed.")};Ui.prototype.setLens=function(e,t){console.warn("THREE.PerspectiveCamera.setLens is deprecated. Use .setFocalLength and .filmGauge for a photographic setup."),t!==void 0&&(this.filmGauge=t),this.setFocalLength(e)};Object.defineProperties(Ol.prototype,{onlyShadow:{set:function(){console.warn("THREE.Light: .onlyShadow has been removed.")}},shadowCameraFov:{set:function(e){console.warn("THREE.Light: .shadowCameraFov is now .shadow.camera.fov."),this.shadow.camera.fov=e}},shadowCameraLeft:{set:function(e){console.warn("THREE.Light: .shadowCameraLeft is now .shadow.camera.left."),this.shadow.camera.left=e}},shadowCameraRight:{set:function(e){console.warn("THREE.Light: .shadowCameraRight is now .shadow.camera.right."),this.shadow.camera.right=e}},shadowCameraTop:{set:function(e){console.warn("THREE.Light: .shadowCameraTop is now .shadow.camera.top."),this.shadow.camera.top=e}},shadowCameraBottom:{set:function(e){console.warn("THREE.Light: .shadowCameraBottom is now .shadow.camera.bottom."),this.shadow.camera.bottom=e}},shadowCameraNear:{set:function(e){console.warn("THREE.Light: .shadowCameraNear is now .shadow.camera.near."),this.shadow.camera.near=e}},shadowCameraFar:{set:function(e){console.warn("THREE.Light: .shadowCameraFar is now .shadow.camera.far."),this.shadow.camera.far=e}},shadowCameraVisible:{set:function(){console.warn("THREE.Light: .shadowCameraVisible has been removed. Use new THREE.CameraHelper( light.shadow.camera ) instead.")}},shadowBias:{set:function(e){console.warn("THREE.Light: .shadowBias is now .shadow.bias."),this.shadow.bias=e}},shadowDarkness:{set:function(){console.warn("THREE.Light: .shadowDarkness has been removed.")}},shadowMapWidth:{set:function(e){console.warn("THREE.Light: .shadowMapWidth is now .shadow.mapSize.width."),this.shadow.mapSize.width=e}},shadowMapHeight:{set:function(e){console.warn("THREE.Light: .shadowMapHeight is now .shadow.mapSize.height."),this.shadow.mapSize.height=e}}});Object.defineProperties(Je.prototype,{length:{get:function(){return console.warn("THREE.BufferAttribute: .length has been deprecated. Use .count instead."),this.array.length}},dynamic:{get:function(){return console.warn("THREE.BufferAttribute: .dynamic has been deprecated. Use .usage instead."),this.usage===Y3},set:function(){console.warn("THREE.BufferAttribute: .dynamic has been deprecated. Use .usage instead."),this.setUsage(Y3)}}});Je.prototype.setDynamic=function(e){return console.warn("THREE.BufferAttribute: .setDynamic() has been deprecated. Use .setUsage() instead."),this.setUsage(e===!0?Y3:W3),this};Je.prototype.copyIndicesArray=function(){console.error("THREE.BufferAttribute: .copyIndicesArray() has been removed.")},Je.prototype.setArray=function(){console.error("THREE.BufferAttribute: .setArray has been removed. Use BufferGeometry .setAttribute to replace/resize attribute buffers")};Pe.prototype.addIndex=function(e){console.warn("THREE.BufferGeometry: .addIndex() has been renamed to .setIndex()."),this.setIndex(e)};Pe.prototype.addAttribute=function(e,t){return console.warn("THREE.BufferGeometry: .addAttribute() has been renamed to .setAttribute()."),!(t&&t.isBufferAttribute)&&!(t&&t.isInterleavedBufferAttribute)?(console.warn("THREE.BufferGeometry: .addAttribute() now expects ( name, attribute )."),this.setAttribute(e,new Je(arguments[1],arguments[2]))):e==="index"?(console.warn("THREE.BufferGeometry.addAttribute: Use .setIndex() for index attribute."),this.setIndex(t),this):this.setAttribute(e,t)};Pe.prototype.addDrawCall=function(e,t,r){r!==void 0&&console.warn("THREE.BufferGeometry: .addDrawCall() no longer supports indexOffset."),console.warn("THREE.BufferGeometry: .addDrawCall() is now .addGroup()."),this.addGroup(e,t)};Pe.prototype.clearDrawCalls=function(){console.warn("THREE.BufferGeometry: .clearDrawCalls() is now .clearGroups()."),this.clearGroups()};Pe.prototype.computeOffsets=function(){console.warn("THREE.BufferGeometry: .computeOffsets() has been removed.")};Pe.prototype.removeAttribute=function(e){return console.warn("THREE.BufferGeometry: .removeAttribute() has been renamed to .deleteAttribute()."),this.deleteAttribute(e)};Pe.prototype.applyMatrix=function(e){return console.warn("THREE.BufferGeometry: .applyMatrix() has been renamed to .applyMatrix4()."),this.applyMatrix4(e)};Object.defineProperties(Pe.prototype,{drawcalls:{get:function(){return console.error("THREE.BufferGeometry: .drawcalls has been renamed to .groups."),this.groups}},offsets:{get:function(){return console.warn("THREE.BufferGeometry: .offsets has been renamed to .groups."),this.groups}}});em.prototype.setDynamic=function(e){return console.warn("THREE.InterleavedBuffer: .setDynamic() has been deprecated. Use .setUsage() instead."),this.setUsage(e===!0?Y3:W3),this};em.prototype.setArray=function(){console.error("THREE.InterleavedBuffer: .setArray has been removed. Use BufferGeometry .setAttribute to replace/resize attribute buffers")};hh.prototype.getArrays=function(){console.error("THREE.ExtrudeGeometry: .getArrays() has been removed.")};hh.prototype.addShapeList=function(){console.error("THREE.ExtrudeGeometry: .addShapeList() has been removed.")};hh.prototype.addShape=function(){console.error("THREE.ExtrudeGeometry: .addShape() has been removed.")};q0.prototype.dispose=function(){console.error("THREE.Scene: .dispose() has been removed.")};gM.prototype.onUpdate=function(){return console.warn("THREE.Uniform: .onUpdate() has been removed. Use object.onBeforeRender() instead."),this};Object.defineProperties(qi.prototype,{wrapAround:{get:function(){console.warn("THREE.Material: .wrapAround has been removed.")},set:function(){console.warn("THREE.Material: .wrapAround has been removed.")}},overdraw:{get:function(){console.warn("THREE.Material: .overdraw has been removed.")},set:function(){console.warn("THREE.Material: .overdraw has been removed.")}},wrapRGB:{get:function(){return console.warn("THREE.Material: .wrapRGB has been removed."),new ne}},shading:{get:function(){console.error("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead.")},set:function(e){console.warn("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead."),this.flatShading=e===Aht}},stencilMask:{get:function(){return console.warn("THREE."+this.type+": .stencilMask has been removed. Use .stencilFuncMask instead."),this.stencilFuncMask},set:function(e){console.warn("THREE."+this.type+": .stencilMask has been removed. Use .stencilFuncMask instead."),this.stencilFuncMask=e}},vertexTangents:{get:function(){console.warn("THREE."+this.type+": .vertexTangents has been removed.")},set:function(){console.warn("THREE."+this.type+": .vertexTangents has been removed.")}}});Object.defineProperties(lh.prototype,{derivatives:{get:function(){return console.warn("THREE.ShaderMaterial: .derivatives has been moved to .extensions.derivatives."),this.extensions.derivatives},set:function(e){console.warn("THREE. ShaderMaterial: .derivatives has been moved to .extensions.derivatives."),this.extensions.derivatives=e}}});rn.prototype.clearTarget=function(e,t,r,n){console.warn("THREE.WebGLRenderer: .clearTarget() has been deprecated. Use .setRenderTarget() and .clear() instead."),this.setRenderTarget(e),this.clear(t,r,n)};rn.prototype.animate=function(e){console.warn("THREE.WebGLRenderer: .animate() is now .setAnimationLoop()."),this.setAnimationLoop(e)};rn.prototype.getCurrentRenderTarget=function(){return console.warn("THREE.WebGLRenderer: .getCurrentRenderTarget() is now .getRenderTarget()."),this.getRenderTarget()};rn.prototype.getMaxAnisotropy=function(){return console.warn("THREE.WebGLRenderer: .getMaxAnisotropy() is now .capabilities.getMaxAnisotropy()."),this.capabilities.getMaxAnisotropy()};rn.prototype.getPrecision=function(){return console.warn("THREE.WebGLRenderer: .getPrecision() is now .capabilities.precision."),this.capabilities.precision};rn.prototype.resetGLState=function(){return console.warn("THREE.WebGLRenderer: .resetGLState() is now .state.reset()."),this.state.reset()};rn.prototype.supportsFloatTextures=function(){return console.warn("THREE.WebGLRenderer: .supportsFloatTextures() is now .extensions.get( 'OES_texture_float' )."),this.extensions.get("OES_texture_float")};rn.prototype.supportsHalfFloatTextures=function(){return console.warn("THREE.WebGLRenderer: .supportsHalfFloatTextures() is now .extensions.get( 'OES_texture_half_float' )."),this.extensions.get("OES_texture_half_float")};rn.prototype.supportsStandardDerivatives=function(){return console.warn("THREE.WebGLRenderer: .supportsStandardDerivatives() is now .extensions.get( 'OES_standard_derivatives' )."),this.extensions.get("OES_standard_derivatives")};rn.prototype.supportsCompressedTextureS3TC=function(){return console.warn("THREE.WebGLRenderer: .supportsCompressedTextureS3TC() is now .extensions.get( 'WEBGL_compressed_texture_s3tc' )."),this.extensions.get("WEBGL_compressed_texture_s3tc")};rn.prototype.supportsCompressedTexturePVRTC=function(){return console.warn("THREE.WebGLRenderer: .supportsCompressedTexturePVRTC() is now .extensions.get( 'WEBGL_compressed_texture_pvrtc' )."),this.extensions.get("WEBGL_compressed_texture_pvrtc")};rn.prototype.supportsBlendMinMax=function(){return console.warn("THREE.WebGLRenderer: .supportsBlendMinMax() is now .extensions.get( 'EXT_blend_minmax' )."),this.extensions.get("EXT_blend_minmax")};rn.prototype.supportsVertexTextures=function(){return console.warn("THREE.WebGLRenderer: .supportsVertexTextures() is now .capabilities.vertexTextures."),this.capabilities.vertexTextures};rn.prototype.supportsInstancedArrays=function(){return console.warn("THREE.WebGLRenderer: .supportsInstancedArrays() is now .extensions.get( 'ANGLE_instanced_arrays' )."),this.extensions.get("ANGLE_instanced_arrays")};rn.prototype.enableScissorTest=function(e){console.warn("THREE.WebGLRenderer: .enableScissorTest() is now .setScissorTest()."),this.setScissorTest(e)};rn.prototype.initMaterial=function(){console.warn("THREE.WebGLRenderer: .initMaterial() has been removed.")};rn.prototype.addPrePlugin=function(){console.warn("THREE.WebGLRenderer: .addPrePlugin() has been removed.")};rn.prototype.addPostPlugin=function(){console.warn("THREE.WebGLRenderer: .addPostPlugin() has been removed.")};rn.prototype.updateShadowMap=function(){console.warn("THREE.WebGLRenderer: .updateShadowMap() has been removed.")};rn.prototype.setFaceCulling=function(){console.warn("THREE.WebGLRenderer: .setFaceCulling() has been removed.")};rn.prototype.allocTextureUnit=function(){console.warn("THREE.WebGLRenderer: .allocTextureUnit() has been removed.")};rn.prototype.setTexture=function(){console.warn("THREE.WebGLRenderer: .setTexture() has been removed.")};rn.prototype.setTexture2D=function(){console.warn("THREE.WebGLRenderer: .setTexture2D() has been removed.")};rn.prototype.setTextureCube=function(){console.warn("THREE.WebGLRenderer: .setTextureCube() has been removed.")};rn.prototype.getActiveMipMapLevel=function(){return console.warn("THREE.WebGLRenderer: .getActiveMipMapLevel() is now .getActiveMipmapLevel()."),this.getActiveMipmapLevel()};Object.defineProperties(rn.prototype,{shadowMapEnabled:{get:function(){return this.shadowMap.enabled},set:function(e){console.warn("THREE.WebGLRenderer: .shadowMapEnabled is now .shadowMap.enabled."),this.shadowMap.enabled=e}},shadowMapType:{get:function(){return this.shadowMap.type},set:function(e){console.warn("THREE.WebGLRenderer: .shadowMapType is now .shadowMap.type."),this.shadowMap.type=e}},shadowMapCullFace:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMapCullFace has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMapCullFace has been removed. Set Material.shadowSide instead.")}},context:{get:function(){return console.warn("THREE.WebGLRenderer: .context has been removed. Use .getContext() instead."),this.getContext()}},vr:{get:function(){return console.warn("THREE.WebGLRenderer: .vr has been renamed to .xr"),this.xr}},gammaInput:{get:function(){return console.warn("THREE.WebGLRenderer: .gammaInput has been removed. Set the encoding for textures via Texture.encoding instead."),!1},set:function(){console.warn("THREE.WebGLRenderer: .gammaInput has been removed. Set the encoding for textures via Texture.encoding instead.")}},gammaOutput:{get:function(){return console.warn("THREE.WebGLRenderer: .gammaOutput has been removed. Set WebGLRenderer.outputEncoding instead."),!1},set:function(e){console.warn("THREE.WebGLRenderer: .gammaOutput has been removed. Set WebGLRenderer.outputEncoding instead."),this.outputEncoding=e===!0?Wn:Qd}},toneMappingWhitePoint:{get:function(){return console.warn("THREE.WebGLRenderer: .toneMappingWhitePoint has been removed."),1},set:function(){console.warn("THREE.WebGLRenderer: .toneMappingWhitePoint has been removed.")}},gammaFactor:{get:function(){return console.warn("THREE.WebGLRenderer: .gammaFactor has been removed."),2},set:function(){console.warn("THREE.WebGLRenderer: .gammaFactor has been removed.")}}});Object.defineProperties(Jfe.prototype,{cullFace:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMap.cullFace has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMap.cullFace has been removed. Set Material.shadowSide instead.")}},renderReverseSided:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderReverseSided has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderReverseSided has been removed. Set Material.shadowSide instead.")}},renderSingleSided:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderSingleSided has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderSingleSided has been removed. Set Material.shadowSide instead.")}}});function r_r(e,t,r){return console.warn("THREE.WebGLRenderTargetCube( width, height, options ) is now WebGLCubeRenderTarget( size, options )."),new Q3(e,r)}Object.defineProperties(us.prototype,{wrapS:{get:function(){return console.warn("THREE.WebGLRenderTarget: .wrapS is now .texture.wrapS."),this.texture.wrapS},set:function(e){console.warn("THREE.WebGLRenderTarget: .wrapS is now .texture.wrapS."),this.texture.wrapS=e}},wrapT:{get:function(){return console.warn("THREE.WebGLRenderTarget: .wrapT is now .texture.wrapT."),this.texture.wrapT},set:function(e){console.warn("THREE.WebGLRenderTarget: .wrapT is now .texture.wrapT."),this.texture.wrapT=e}},magFilter:{get:function(){return console.warn("THREE.WebGLRenderTarget: .magFilter is now .texture.magFilter."),this.texture.magFilter},set:function(e){console.warn("THREE.WebGLRenderTarget: .magFilter is now .texture.magFilter."),this.texture.magFilter=e}},minFilter:{get:function(){return console.warn("THREE.WebGLRenderTarget: .minFilter is now .texture.minFilter."),this.texture.minFilter},set:function(e){console.warn("THREE.WebGLRenderTarget: .minFilter is now .texture.minFilter."),this.texture.minFilter=e}},anisotropy:{get:function(){return console.warn("THREE.WebGLRenderTarget: .anisotropy is now .texture.anisotropy."),this.texture.anisotropy},set:function(e){console.warn("THREE.WebGLRenderTarget: .anisotropy is now .texture.anisotropy."),this.texture.anisotropy=e}},offset:{get:function(){return console.warn("THREE.WebGLRenderTarget: .offset is now .texture.offset."),this.texture.offset},set:function(e){console.warn("THREE.WebGLRenderTarget: .offset is now .texture.offset."),this.texture.offset=e}},repeat:{get:function(){return console.warn("THREE.WebGLRenderTarget: .repeat is now .texture.repeat."),this.texture.repeat},set:function(e){console.warn("THREE.WebGLRenderTarget: .repeat is now .texture.repeat."),this.texture.repeat=e}},format:{get:function(){return console.warn("THREE.WebGLRenderTarget: .format is now .texture.format."),this.texture.format},set:function(e){console.warn("THREE.WebGLRenderTarget: .format is now .texture.format."),this.texture.format=e}},type:{get:function(){return console.warn("THREE.WebGLRenderTarget: .type is now .texture.type."),this.texture.type},set:function(e){console.warn("THREE.WebGLRenderTarget: .type is now .texture.type."),this.texture.type=e}},generateMipmaps:{get:function(){return console.warn("THREE.WebGLRenderTarget: .generateMipmaps is now .texture.generateMipmaps."),this.texture.generateMipmaps},set:function(e){console.warn("THREE.WebGLRenderTarget: .generateMipmaps is now .texture.generateMipmaps."),this.texture.generateMipmaps=e}}});D6.prototype.load=function(e){console.warn("THREE.Audio: .load has been deprecated. Use THREE.AudioLoader instead.");let t=this;return new DU().load(e,function(n){t.setBuffer(n)}),this};FU.prototype.getData=function(){return console.warn("THREE.AudioAnalyser: .getData() is now .getFrequencyData()."),this.getFrequencyData()};J3.prototype.updateCubeMap=function(e,t){return console.warn("THREE.CubeCamera: .updateCubeMap() is now .update()."),this.update(e,t)};J3.prototype.clear=function(e,t,r,n){return console.warn("THREE.CubeCamera: .clear() is now .renderTarget.clear()."),this.renderTarget.clear(e,t,r,n)};Kf.crossOrigin=void 0;Kf.loadTexture=function(e,t,r,n){console.warn("THREE.ImageUtils.loadTexture has been deprecated. Use THREE.TextureLoader() instead.");let i=new AU;i.setCrossOrigin(this.crossOrigin);let o=i.load(e,r,void 0,n);return t&&(o.mapping=t),o};Kf.loadTextureCube=function(e,t,r,n){console.warn("THREE.ImageUtils.loadTextureCube has been deprecated. Use THREE.CubeTextureLoader() instead.");let i=new TU;i.setCrossOrigin(this.crossOrigin);let o=i.load(e,r,void 0,n);return t&&(o.mapping=t),o};Kf.loadCompressedTexture=function(){console.error("THREE.ImageUtils.loadCompressedTexture has been removed. Use THREE.DDSLoader instead.")};Kf.loadCompressedTextureCube=function(){console.error("THREE.ImageUtils.loadCompressedTextureCube has been removed. Use THREE.DDSLoader instead.")};function n_r(){console.error("THREE.CanvasRenderer has been removed")}function i_r(){console.error("THREE.JSONLoader has been removed.")}var o_r={createMultiMaterialObject:function(){console.error("THREE.SceneUtils has been moved to /examples/jsm/utils/SceneUtils.js")},detach:function(){console.error("THREE.SceneUtils has been moved to /examples/jsm/utils/SceneUtils.js")},attach:function(){console.error("THREE.SceneUtils has been moved to /examples/jsm/utils/SceneUtils.js")}};function a_r(){console.error("THREE.LensFlare has been moved to /examples/jsm/objects/Lensflare.js")}function s_r(){return console.error("THREE.ParametricGeometry has been moved to /examples/jsm/geometries/ParametricGeometry.js"),new Pe}function l_r(){return console.error("THREE.TextGeometry has been moved to /examples/jsm/geometries/TextGeometry.js"),new Pe}function c_r(){console.error("THREE.FontLoader has been moved to /examples/jsm/loaders/FontLoader.js")}function u_r(){console.error("THREE.Font has been moved to /examples/jsm/loaders/FontLoader.js")}function h_r(){console.error("THREE.ImmediateRenderObject has been removed.")}typeof __THREE_DEVTOOLS__!="undefined"&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("register",{detail:{revision:jU}}));typeof window!="undefined"&&(window.__THREE__?console.warn("WARNING: Multiple instances of Three.js being imported."):window.__THREE__=jU);var spe={type:"change"},Hht={type:"start"},lpe={type:"end"},JU=class extends Us{constructor(t,r){super(),r===void 0&&console.warn('THREE.OrbitControls: The second parameter "domElement" is now mandatory.'),r===document&&console.error('THREE.OrbitControls: "document" should not be used as the target "domElement". Please use "renderer.domElement" instead.'),this.object=t,this.domElement=r,this.domElement.style.touchAction="none",this.enabled=!0,this.target=new j,this.minDistance=0,this.maxDistance=1/0,this.minZoom=0,this.maxZoom=1/0,this.minPolarAngle=0,this.maxPolarAngle=Math.PI,this.minAzimuthAngle=-1/0,this.maxAzimuthAngle=1/0,this.enableDamping=!1,this.dampingFactor=.05,this.enableZoom=!0,this.zoomSpeed=1,this.enableRotate=!0,this.rotateSpeed=1,this.enablePan=!0,this.panSpeed=1,this.screenSpacePanning=!0,this.keyPanSpeed=7,this.autoRotate=!1,this.autoRotateSpeed=2,this.keys={LEFT:"ArrowLeft",UP:"ArrowUp",RIGHT:"ArrowRight",BOTTOM:"ArrowDown"},this.mouseButtons={LEFT:K0.ROTATE,MIDDLE:K0.DOLLY,RIGHT:K0.PAN},this.touches={ONE:Z0.ROTATE,TWO:Z0.DOLLY_PAN},this.target0=this.target.clone(),this.position0=this.object.position.clone(),this.zoom0=this.object.zoom,this._domElementKeyEvents=null,this.getPolarAngle=function(){return s.phi},this.getAzimuthalAngle=function(){return s.theta},this.getDistance=function(){return this.object.position.distanceTo(this.target)},this.listenToKeyEvents=function(nt){nt.addEventListener("keydown",fr),this._domElementKeyEvents=nt},this.saveState=function(){n.target0.copy(n.target),n.position0.copy(n.object.position),n.zoom0=n.object.zoom},this.reset=function(){n.target.copy(n.target0),n.object.position.copy(n.position0),n.object.zoom=n.zoom0,n.object.updateProjectionMatrix(),n.dispatchEvent(spe),n.update(),o=i.NONE},this.update=function(){let nt=new j,Ct=new yi().setFromUnitVectors(t.up,new j(0,1,0)),Wt=Ct.clone().invert(),fe=new j,at=new yi,se=2*Math.PI;return function(){let Ce=n.object.position;nt.copy(Ce).sub(n.target),nt.applyQuaternion(Ct),s.setFromVector3(nt),n.autoRotate&&o===i.NONE&&D(k()),n.enableDamping?(s.theta+=l.theta*n.dampingFactor,s.phi+=l.phi*n.dampingFactor):(s.theta+=l.theta,s.phi+=l.phi);let Pt=n.minAzimuthAngle,Nt=n.maxAzimuthAngle;return isFinite(Pt)&&isFinite(Nt)&&(Pt<-Math.PI?Pt+=se:Pt>Math.PI&&(Pt-=se),Nt<-Math.PI?Nt+=se:Nt>Math.PI&&(Nt-=se),Pt<=Nt?s.theta=Math.max(Pt,Math.min(Nt,s.theta)):s.theta=s.theta>(Pt+Nt)/2?Math.max(Pt,s.theta):Math.min(Nt,s.theta)),s.phi=Math.max(n.minPolarAngle,Math.min(n.maxPolarAngle,s.phi)),s.makeSafe(),s.radius*=c,s.radius=Math.max(n.minDistance,Math.min(n.maxDistance,s.radius)),n.enableDamping===!0?n.target.addScaledVector(u,n.dampingFactor):n.target.add(u),nt.setFromSpherical(s),nt.applyQuaternion(Wt),Ce.copy(n.target).add(nt),n.object.lookAt(n.target),n.enableDamping===!0?(l.theta*=1-n.dampingFactor,l.phi*=1-n.dampingFactor,u.multiplyScalar(1-n.dampingFactor)):(l.set(0,0,0),u.set(0,0,0)),c=1,h||fe.distanceToSquared(n.object.position)>a||8*(1-at.dot(n.object.quaternion))>a?(n.dispatchEvent(spe),fe.copy(n.object.position),at.copy(n.object.quaternion),h=!1,!0):!1}}(),this.dispose=function(){n.domElement.removeEventListener("contextmenu",It),n.domElement.removeEventListener("pointerdown",ht),n.domElement.removeEventListener("pointercancel",ie),n.domElement.removeEventListener("wheel",ar),n.domElement.removeEventListener("pointermove",wt),n.domElement.removeEventListener("pointerup",kt),n._domElementKeyEvents!==null&&n._domElementKeyEvents.removeEventListener("keydown",fr)};let n=this,i={NONE:-1,ROTATE:0,DOLLY:1,PAN:2,TOUCH_ROTATE:3,TOUCH_PAN:4,TOUCH_DOLLY_PAN:5,TOUCH_DOLLY_ROTATE:6},o=i.NONE,a=1e-6,s=new _M,l=new _M,c=1,u=new j,h=!1,f=new Lt,p=new Lt,d=new Lt,g=new Lt,_=new Lt,y=new Lt,x=new Lt,b=new Lt,S=new Lt,C=[],P={};function k(){return 2*Math.PI/60/60*n.autoRotateSpeed}function O(){return Math.pow(.95,n.zoomSpeed)}function D(nt){l.theta-=nt}function B(nt){l.phi-=nt}let I=function(){let nt=new j;return function(Wt,fe){nt.setFromMatrixColumn(fe,0),nt.multiplyScalar(-Wt),u.add(nt)}}(),L=function(){let nt=new j;return function(Wt,fe){n.screenSpacePanning===!0?nt.setFromMatrixColumn(fe,1):(nt.setFromMatrixColumn(fe,0),nt.crossVectors(n.object.up,nt)),nt.multiplyScalar(Wt),u.add(nt)}}(),R=function(){let nt=new j;return function(Wt,fe){let at=n.domElement;if(n.object.isPerspectiveCamera){let se=n.object.position;nt.copy(se).sub(n.target);let Qt=nt.length();Qt*=Math.tan(n.object.fov/2*Math.PI/180),I(2*Wt*Qt/at.clientHeight,n.object.matrix),L(2*fe*Qt/at.clientHeight,n.object.matrix)}else n.object.isOrthographicCamera?(I(Wt*(n.object.right-n.object.left)/n.object.zoom/at.clientWidth,n.object.matrix),L(fe*(n.object.top-n.object.bottom)/n.object.zoom/at.clientHeight,n.object.matrix)):(console.warn("WARNING: OrbitControls.js encountered an unknown camera type - pan disabled."),n.enablePan=!1)}}();function F(nt){n.object.isPerspectiveCamera?c/=nt:n.object.isOrthographicCamera?(n.object.zoom=Math.max(n.minZoom,Math.min(n.maxZoom,n.object.zoom*nt)),n.object.updateProjectionMatrix(),h=!0):(console.warn("WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled."),n.enableZoom=!1)}function z(nt){n.object.isPerspectiveCamera?c*=nt:n.object.isOrthographicCamera?(n.object.zoom=Math.max(n.minZoom,Math.min(n.maxZoom,n.object.zoom/nt)),n.object.updateProjectionMatrix(),h=!0):(console.warn("WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled."),n.enableZoom=!1)}function U(nt){f.set(nt.clientX,nt.clientY)}function W(nt){x.set(nt.clientX,nt.clientY)}function Z(nt){g.set(nt.clientX,nt.clientY)}function rt(nt){p.set(nt.clientX,nt.clientY),d.subVectors(p,f).multiplyScalar(n.rotateSpeed);let Ct=n.domElement;D(2*Math.PI*d.x/Ct.clientHeight),B(2*Math.PI*d.y/Ct.clientHeight),f.copy(p),n.update()}function ot(nt){b.set(nt.clientX,nt.clientY),S.subVectors(b,x),S.y>0?F(O()):S.y<0&&z(O()),x.copy(b),n.update()}function st(nt){_.set(nt.clientX,nt.clientY),y.subVectors(_,g).multiplyScalar(n.panSpeed),R(y.x,y.y),g.copy(_),n.update()}function St(nt){nt.deltaY<0?z(O()):nt.deltaY>0&&F(O()),n.update()}function bt(nt){let Ct=!1;switch(nt.code){case n.keys.UP:R(0,n.keyPanSpeed),Ct=!0;break;case n.keys.BOTTOM:R(0,-n.keyPanSpeed),Ct=!0;break;case n.keys.LEFT:R(n.keyPanSpeed,0),Ct=!0;break;case n.keys.RIGHT:R(-n.keyPanSpeed,0),Ct=!0;break}Ct&&(nt.preventDefault(),n.update())}function Mt(){if(C.length===1)f.set(C[0].pageX,C[0].pageY);else{let nt=.5*(C[0].pageX+C[1].pageX),Ct=.5*(C[0].pageY+C[1].pageY);f.set(nt,Ct)}}function lt(){if(C.length===1)g.set(C[0].pageX,C[0].pageY);else{let nt=.5*(C[0].pageX+C[1].pageX),Ct=.5*(C[0].pageY+C[1].pageY);g.set(nt,Ct)}}function Kt(){let nt=C[0].pageX-C[1].pageX,Ct=C[0].pageY-C[1].pageY,Wt=Math.sqrt(nt*nt+Ct*Ct);x.set(0,Wt)}function _t(){n.enableZoom&&Kt(),n.enablePan&&lt()}function ct(){n.enableZoom&&Kt(),n.enableRotate&&Mt()}function X(nt){if(C.length==1)p.set(nt.pageX,nt.pageY);else{let Wt=be(nt),fe=.5*(nt.pageX+Wt.x),at=.5*(nt.pageY+Wt.y);p.set(fe,at)}d.subVectors(p,f).multiplyScalar(n.rotateSpeed);let Ct=n.domElement;D(2*Math.PI*d.x/Ct.clientHeight),B(2*Math.PI*d.y/Ct.clientHeight),f.copy(p)}function et(nt){if(C.length===1)_.set(nt.pageX,nt.pageY);else{let Ct=be(nt),Wt=.5*(nt.pageX+Ct.x),fe=.5*(nt.pageY+Ct.y);_.set(Wt,fe)}y.subVectors(_,g).multiplyScalar(n.panSpeed),R(y.x,y.y),g.copy(_)}function dt(nt){let Ct=be(nt),Wt=nt.pageX-Ct.x,fe=nt.pageY-Ct.y,at=Math.sqrt(Wt*Wt+fe*fe);b.set(0,at),S.set(0,Math.pow(b.y/x.y,n.zoomSpeed)),F(S.y),x.copy(b)}function q(nt){n.enableZoom&&dt(nt),n.enablePan&&et(nt)}function pt(nt){n.enableZoom&&dt(nt),n.enableRotate&&X(nt)}function ht(nt){n.enabled!==!1&&(C.length===0&&(n.domElement.setPointerCapture(nt.pointerId),n.domElement.addEventListener("pointermove",wt),n.domElement.addEventListener("pointerup",kt)),$t(nt),nt.pointerType==="touch"?tt(nt):ee(nt))}function wt(nt){n.enabled!==!1&&(nt.pointerType==="touch"?$(nt):Le(nt))}function kt(nt){he(nt),C.length===0&&(n.domElement.releasePointerCapture(nt.pointerId),n.domElement.removeEventListener("pointermove",wt),n.domElement.removeEventListener("pointerup",kt)),n.dispatchEvent(lpe),o=i.NONE}function ie(nt){he(nt)}function ee(nt){let Ct;switch(nt.button){case 0:Ct=n.mouseButtons.LEFT;break;case 1:Ct=n.mouseButtons.MIDDLE;break;case 2:Ct=n.mouseButtons.RIGHT;break;default:Ct=-1}switch(Ct){case K0.DOLLY:if(n.enableZoom===!1)return;W(nt),o=i.DOLLY;break;case K0.ROTATE:if(nt.ctrlKey||nt.metaKey||nt.shiftKey){if(n.enablePan===!1)return;Z(nt),o=i.PAN}else{if(n.enableRotate===!1)return;U(nt),o=i.ROTATE}break;case K0.PAN:if(nt.ctrlKey||nt.metaKey||nt.shiftKey){if(n.enableRotate===!1)return;U(nt),o=i.ROTATE}else{if(n.enablePan===!1)return;Z(nt),o=i.PAN}break;default:o=i.NONE}o!==i.NONE&&n.dispatchEvent(Hht)}function Le(nt){if(n.enabled!==!1)switch(o){case i.ROTATE:if(n.enableRotate===!1)return;rt(nt);break;case i.DOLLY:if(n.enableZoom===!1)return;ot(nt);break;case i.PAN:if(n.enablePan===!1)return;st(nt);break}}function ar(nt){n.enabled===!1||n.enableZoom===!1||o!==i.NONE||(nt.preventDefault(),n.dispatchEvent(Hht),St(nt),n.dispatchEvent(lpe))}function fr(nt){n.enabled===!1||n.enablePan===!1||bt(nt)}function tt(nt){switch(Tt(nt),C.length){case 1:switch(n.touches.ONE){case Z0.ROTATE:if(n.enableRotate===!1)return;Mt(),o=i.TOUCH_ROTATE;break;case Z0.PAN:if(n.enablePan===!1)return;lt(),o=i.TOUCH_PAN;break;default:o=i.NONE}break;case 2:switch(n.touches.TWO){case Z0.DOLLY_PAN:if(n.enableZoom===!1&&n.enablePan===!1)return;_t(),o=i.TOUCH_DOLLY_PAN;break;case Z0.DOLLY_ROTATE:if(n.enableZoom===!1&&n.enableRotate===!1)return;ct(),o=i.TOUCH_DOLLY_ROTATE;break;default:o=i.NONE}break;default:o=i.NONE}o!==i.NONE&&n.dispatchEvent(Hht)}function $(nt){switch(Tt(nt),o){case i.TOUCH_ROTATE:if(n.enableRotate===!1)return;X(nt),n.update();break;case i.TOUCH_PAN:if(n.enablePan===!1)return;et(nt),n.update();break;case i.TOUCH_DOLLY_PAN:if(n.enableZoom===!1&&n.enablePan===!1)return;q(nt),n.update();break;case i.TOUCH_DOLLY_ROTATE:if(n.enableZoom===!1&&n.enableRotate===!1)return;pt(nt),n.update();break;default:o=i.NONE}}function It(nt){n.enabled!==!1&&nt.preventDefault()}function $t(nt){C.push(nt)}function he(nt){delete P[nt.pointerId];for(let Ct=0;Ct<C.length;Ct++)if(C[Ct].pointerId==nt.pointerId){C.splice(Ct,1);return}}function Tt(nt){let Ct=P[nt.pointerId];Ct===void 0&&(Ct=new Lt,P[nt.pointerId]=Ct),Ct.set(nt.pageX,nt.pageY)}function be(nt){let Ct=nt.pointerId===C[0].pointerId?C[1]:C[0];return P[Ct.pointerId]}n.domElement.addEventListener("contextmenu",It),n.domElement.addEventListener("pointerdown",ht),n.domElement.addEventListener("pointercancel",ie),n.domElement.addEventListener("wheel",ar,{passive:!1}),this.update()}};var F6=class extends Us{constructor(t){super(),this._lastMesh=null,this._clock=new mM,this._canvasSize=null,this._layersConfig=null,this._runColor=t}_isObject(t){var r=typeof t;return r=="object"&&t!=null&&!Array.isArray(t)}_applyDefaults(t,r){let n={},i=[t,r];for(let o=0;o<i.length;o++){let a=i[o];for(let s in a){let l=s in n;this._isObject(a[s])?n[s]=this._applyDefaults(n[s]||{},a[s]):l||(n[s]=a[s])}}return n}_createLayers(){if(!(!this._layersConfig||!this._scene||!this._lastMesh)){if(this._layersConfig.showBoundingBox){var t=new yM(this._lastMesh,new ne("rgb(0, 0, 255)"));this._scene.add(t)}if(this._layersConfig.showAxes){var r=new vM(5);this._scene.add(r)}}}setLayersConfig(t){this._layersConfig=this._applyDefaults(t,this._layersConfig||{})}_createWorld(t,r){var a,s,l,c;if(this.isReady())return;this._scene=new q0;var n=new wM[t.camera.cls](t.camera.fov,((a=this._canvasSize)==null?void 0:a.width)/((s=this._canvasSize)==null?void 0:s.height),t.camera.near,t.camera.far);this._camera=n,this.initCameraPosition=void 0,t.camera.position&&(this.initCameraPosition=new j().fromArray(t.camera.position)),this.initCameraLookAt=void 0,t.camera.lookAt&&(this.initCameraLookAt=new j().fromArray(t.camera.lookAt));var i=new JU(n,r);let o=i;o.lookSpeed=.4,o.movementSpeed=20,o.noFly=!0,o.lookVertical=!0,o.constrainVertical=!0,o.verticalMin=1,o.verticalMax=2,o.addEventListener("change",this._onCameraPositionChange.bind(this)),this._cameraControls=i,this._renderer=new rn({antialias:!0}),this._renderer.setPixelRatio(window.devicePixelRatio),this._renderer.setSize((l=this._canvasSize)==null?void 0:l.width,(c=this._canvasSize)==null?void 0:c.height),this._renderer.setClearColor(16777215,1)}_clearScene(){var t;if(this._scene)for(;this._scene.children.length>0;)this._scene.remove((t=this._scene)==null?void 0:t.children[0])}getRenderer(){return this._renderer}getCameraControls(){return this._cameraControls}isReady(){return!!this._camera&&!!this._cameraControls}getCameraPosition(){var t,r,n;return{far:(t=this._camera)==null?void 0:t.far,position:(r=this._camera)==null?void 0:r.position.clone(),target:(n=this._cameraControls)==null?void 0:n.target.clone()}}setCanvasSize(t){this._canvasSize=t}draw(){var r,n,i,o;this._animationFrameIndex&&cancelAnimationFrame(this._animationFrameIndex),this._camera&&(this._camera.aspect=((r=this._canvasSize)==null?void 0:r.width)/((n=this._canvasSize)==null?void 0:n.height),this._camera.updateProjectionMatrix()),this._renderer.setSize((i=this._canvasSize)==null?void 0:i.width,(o=this._canvasSize)==null?void 0:o.height);let t=function(){var a=this._clock.getDelta();this._cameraControls.update(a),this._animationFrameIndex=requestAnimationFrame(t),this._renderer.render(this._scene,this._camera)}.bind(this);t()}updateScene(t,r){let n={};"config"in t&&t.config&&(n=JSON.parse(t.config)),this.dispatchEvent({type:"beforeUpdateScene"});let i={camera:{cls:"PerspectiveCamera",fov:75,near:.1,far:1e3},lights:[{cls:"AmbientLight",color:"#ffffff",intensity:.75},{cls:"DirectionalLight",color:"#ffffff",intensity:.75,position:[0,-1,2]}]};n=this._applyDefaults(n,i),this._createWorld(n,r),this._clearScene(),this._createLights(this._scene,n),this._createGeometry(t,n),this._createLayers(),this.draw()}resetView(t){var n,i;if(!this.isReady())return;(n=this._cameraControls)==null||n.reset();let r;!t&&this._lastMesh&&(r=this._lastMesh),r&&(this._fitObjectToViewport(r),this._lastMesh=r),(i=this._cameraControls)==null||i.update()}_createGeometry(t,r){let n=t.mesh;n.vertices&&n.faces&&n.faces.length?this._createMesh(n,r):this._createPointCloud(n,r)}_createPointCloud(t,r){var h;let n=t.vertices,i=t.colors,o={material:{cls:"PointsMaterial",size:.005}};i&&i.length==n.length?o.material.vertexColors=!0:o.material.color=this._runColor;let a=this._applyDefaults(r,o),s=new Pe,l=new Float32Array(n.flat());if(s.setAttribute("position",new Je(l,3)),i&&i.length==n.length){let f=new Float32Array(i.flat());for(let p=0;p<f.length;p++)f[p]=f[p]/255;s.setAttribute("color",new Je(f,3))}var c=new wM[a.material.cls](a.material),u=new im(s,c);(h=this._scene)==null||h.add(u),this._lastMesh=u}setCameraViewpoint(t,r,n){this._silent=!0,this._camera&&(this._camera.far=r,this._camera.position.set(t.x,t.y,t.z),this._camera.lookAt(n.clone()),this._camera.updateProjectionMatrix()),this._cameraControls&&(this._cameraControls.target=n.clone(),this._cameraControls.update()),this._silent=!1}_onCameraPositionChange(t){this._silent||this.dispatchEvent({type:"cameraPositionChange",event:t})}_fitObjectToViewport(t){var p,d,g;let n=new ta,i=new j,o=new j;n.setFromObject(t),n.getCenter(i),n.getSize(o);let a=Math.max(o.x,o.y,o.z),s=((p=this._camera)==null?void 0:p.fov)*(Math.PI/180),l=Math.abs(a/(2*Math.tan(s/2)))*1.25,c=n.min.z,u=c<0?-c+l:l-c,h=(d=this.initCameraPosition)!=null?d:new j(i.x,i.y,l),f=(g=this.initCameraLookAt)!=null?g:i;this.setCameraViewpoint(h,u*3,f)}_createMesh(t,r){var f;let n=t.vertices,i=t.faces,o=t.colors,a=this._applyDefaults(r,{material:{cls:"MeshStandardMaterial",color:"#a0a0a0",roughness:1,metalness:0}}),s=new Pe,l=new Float32Array(n.flat());s.setAttribute("position",new Je(l,3));let c=new Uint16Array(i.flat());if(o&&o.length){let p=o.flat();for(let d=0;d<p.length;d++)p[d]=p[d]/255;s.setAttribute("color",new Je(new Float32Array(p),3)),a.material=a.material||{},a.material.vertexColors=!0}s.center(),s.computeBoundingSphere(),s.setIndex(new Je(c,1)),s.computeVertexNormals();let u=new wM[a.material.cls](a.material),h=new ti(s,u);h.castShadow=!0,h.receiveShadow=!0,(f=this._scene)==null||f.add(h),this._lastMesh=h}_createLights(t,r){for(let n=0;n<r.lights.length;n++){let i=r.lights[n],o=new wM[i.cls](i.color,i.intensity);i.position&&o.position.set(i.position[0],i.position[1],i.position[2]),t.add(o)}}};var Ln=class extends Gt(mt){constructor(){super(...arguments),this.selectedView="all",this.active=!1,this._colorScaleFunction=fn,this._steps=[],this._meshViewerAttached=!1,this._cameraPositionInitialized=!1,this._isMeshLoading=!1}get _runColor(){var t=this.run;return this._colorScaleFunction(t)}connectedCallback(){super.connectedCallback(),this._dataProvider=new IP(this.requestManager);let t=new F6(this._runColor);t.addEventListener("beforeUpdateScene",this._updateCanvasSize.bind(this)),t.addEventListener("cameraPositionChange",this._onCameraPositionChange.bind(this)),this._meshViewer=t}reload(){!this.active||!this._dataProvider||(this._isMeshLoading=!0,this._dataProvider.reload(this.run,this.tag,this.sample).then(t=>{!t||(this._steps=t,this._stepIndex=t.length-1)}).catch(t=>{if(!t||!t.code||t.code!=d1.CANCELLED)throw t=t||"Response processing failed.",new Error(t)}))}_updateScene(){var r;let t=this._currentStep;!t||!t.mesh||(this._meshViewer.updateScene(t,this),this._cameraPositionInitialized||(this._meshViewer.resetView(),this._cameraPositionInitialized=!0),this._meshViewerAttached||((r=this.shadowRoot)==null||r.appendChild(this._meshViewer.getRenderer().domElement),this._meshViewerAttached=!0))}_debouncedFetchMesh(){this.debounce("fetchMesh",()=>this._maybeFetchMesh(),100)}_maybeFetchMesh(){return Ri(this,null,function*(){let t=this._currentStep;if(!(!t||t.mesh||t.meshFetching)){t.meshFetching=!0,this._isMeshLoading=!0;try{let r=yield this._dataProvider.fetchData(t,this.run,this.tag,this.sample);t.mesh=r[0],this.notifyPath("_currentStep.mesh")}catch(r){if(!r||!r.code||r.code!=d1.CANCELLED)throw r=r||"Response processing failed.",new Error(r)}finally{this._isMeshLoading=!1,t.meshFetching=!1}}})}_onCameraPositionChange(){if(!this._meshViewer.isReady())return;let t=new CustomEvent("camera-position-change",{detail:this._meshViewer.getCameraPosition()});this.dispatchEvent(t)}setCameraViewpoint(t,r,n){this._meshViewer.setCameraViewpoint(t,r,n)}_updateCanvasSize(){let t=this.offsetWidth,r=t,n=this.$$(".tf-mesh-loader-header").offsetHeight,i={width:t,height:r-n};this._meshViewer.setCanvasSize(i)}redraw(){this._updateCanvasSize(),this.isConnected&&this._meshViewer.draw()}_hasAtLeastOneStep(t){return!!t&&t.length>0}_hasMultipleSteps(t){return!!t&&t.length>1}get _currentStep(){var t=this._steps,r=this._stepIndex;return t[r]||null}get _stepValue(){let t=this._currentStep;return t?t.step:0}get _currentWallTime(){let t=this._currentStep;return t?s2(t.wall_time):""}_getMaxStepIndex(t){return t.length-1}_getSampleText(t){return String(t+1)}_hasMultipleSamples(t){return t>1}_updateView(){var t=this.selectedView;this._meshViewer&&t=="all"&&this._meshViewer.resetView()}toLocaleString_(t){return t.toLocaleString()}};Ln.template=Q`
    <tf-card-heading color="[[_runColor]]" class="tf-mesh-loader-header">
      <template is="dom-if" if="[[_hasMultipleSamples(ofSamples)]]">
        <div>sample: [[_getSampleText(sample)]] of [[ofSamples]]</div>
      </template>
      <template is="dom-if" if="[[_hasAtLeastOneStep(_steps)]]">
        <div class="heading-row">
          <div class="heading-label">
            step
            <span style="font-weight: bold"
              >[[toLocaleString_(_stepValue)]]</span
            >
          </div>
          <div class="heading-label heading-right">
            <template is="dom-if" if="[[_currentWallTime]]">
              [[_currentWallTime]]
            </template>
          </div>
          <div class="label right">
            <paper-spinner-lite active hidden$="[[!_isMeshLoading]]">
            </paper-spinner-lite>
          </div>
        </div>
      </template>
      <template is="dom-if" if="[[_hasMultipleSteps(_steps)]]">
        <div>
          <paper-slider
            id="steps"
            immediate-value="{{_stepIndex}}"
            max="[[_getMaxStepIndex(_steps)]]"
            max-markers="[[_getMaxStepIndex(_steps)]]"
            snaps
            step="1"
            value="{{_stepIndex}}"
          ></paper-slider>
        </div>
      </template>
    </tf-card-heading>
    <style>
      paper-slider {
        width: 100%;
        margin-left: 1px;
        margin-right: 1px;
      }
      .tf-mesh-loader-header {
        display: block;
        height: 105px;
      }
      [hidden] {
        display: none;
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],Ln.prototype,"run",void 0);E([A({type:String}),w("design:type",String)],Ln.prototype,"tag",void 0);E([A({type:Number}),w("design:type",Number)],Ln.prototype,"sample",void 0);E([A({type:Number}),w("design:type",Number)],Ln.prototype,"ofSamples",void 0);E([A({type:String}),w("design:type",String)],Ln.prototype,"selectedView",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Ln.prototype,"active",void 0);E([A({type:Object}),w("design:type",Ae)],Ln.prototype,"requestManager",void 0);E([A({type:Object}),w("design:type",F6)],Ln.prototype,"_meshViewer",void 0);E([A({type:Object}),w("design:type",IP)],Ln.prototype,"_dataProvider",void 0);E([A({type:Object}),w("design:type",Object)],Ln.prototype,"_colorScaleFunction",void 0);E([A({type:Array,notify:!0}),w("design:type",Array)],Ln.prototype,"_steps",void 0);E([A({type:Number,notify:!0}),w("design:type",Number)],Ln.prototype,"_stepIndex",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Ln.prototype,"_meshViewerAttached",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Ln.prototype,"_cameraPositionInitialized",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Ln.prototype,"_isMeshLoading",void 0);E([Rt("run"),w("design:type",String),w("design:paramtypes",[])],Ln.prototype,"_runColor",null);E([Bt("run","tag","active","_dataProvider","_meshViewer"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Ln.prototype,"reload",null);E([Bt("_currentStep.*","_meshViewer"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Ln.prototype,"_updateScene",null);E([Bt("_currentStep"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Ln.prototype,"_debouncedFetchMesh",null);E([Rt("_steps","_stepIndex"),w("design:type",Object),w("design:paramtypes",[])],Ln.prototype,"_currentStep",null);E([Rt("_currentStep"),w("design:type",Number),w("design:paramtypes",[])],Ln.prototype,"_stepValue",null);E([Rt("_currentStep"),w("design:type",String),w("design:paramtypes",[])],Ln.prototype,"_currentWallTime",null);E([Bt("selectedView"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Ln.prototype,"_updateView",null);Ln=E([yt("tf-mesh-loader")],Ln);var ph=class extends mt{constructor(){super(),this.reloadOnReady=!0,this._tagFilter=".*",this._selectedView="all",this._requestManager=new Ae,window.addEventListener("resize",()=>{this._handleWindowResize()},!1),this.reloadOnReady&&this.reload()}_getAllChildren(){var t;return Array.from((t=this.shadowRoot)==null?void 0:t.querySelectorAll("tf-mesh-loader"))}_onCameraPositionChanged(t){this._selectedView=="share"&&this._getAllChildren().forEach(r=>{t.target!=r&&r.setCameraViewpoint(t.detail.position,t.detail.far,t.detail.target)})}_shouldOpen(t){return t<=2}reload(){this._fetchTags().then(this._reloadMeshes.bind(this))}_handleWindowResize(){this._getAllChildren().forEach(t=>{t.redraw()})}_fetchTags(){let t=_e().pluginRoute("mesh","/tags");return this._requestManager.request(t).then(r=>{if(sx.isEqual(r,this._runToTagInfo))return;let n=sx.mapValues(r,o=>Object.keys(o)),i=$i(n);this._dataNotFound=i.length===0,this._runToTagInfo=r})}_reloadMeshes(){this._getAllChildren().forEach(t=>{t.reload()})}get _categories(){var t=this._runToTagInfo,r=this._selectedRuns,n=this._tagFilter;let i=sx.mapValues(t,l=>Object.keys(l)),o=Ql(i,r,n);function a(l){let c=t[l.run][l.tag].samples;return sx.range(c).map(u=>Object.assign({},l,{sample:u,ofSamples:c}))}return o.map(l=>Object.assign({},l,{items:[].concat.apply([],l.items.map(a))}))}};ph.template=Q`
    <tf-dashboard-layout>
      <div slot="sidebar" class="all-controls">
        <div class="settings">
          <div class="sidebar-section view-control">
            <h3 class="title">Point of view</h3>
            <div>
              <paper-radio-group
                id="view-radio-group"
                selected="{{_selectedView}}"
              >
                <paper-radio-button id="all-radio-button" name="all">
                  Display all points
                </paper-radio-button>
                <paper-tooltip
                  animation-delay="0"
                  for="all-radio-button"
                  position="right"
                  offset="0"
                >
                  Zoom and center camera to display all points at once. Note,
                  that some points could be too far (i.e. too small) to be
                  visible.
                </paper-tooltip>
                <paper-radio-button id="user-radio-button" name="user">
                  Current view
                </paper-radio-button>
                <paper-tooltip
                  animation-delay="0"
                  for="user-radio-button"
                  position="right"
                  offset="0"
                >
                  Keep current camera position and zoom level.
                </paper-tooltip>
                <paper-radio-button id="share-radio-button" name="share">
                  Share viewpoint
                </paper-radio-button>
                <paper-tooltip
                  animation-delay="0"
                  for="share-radio-button"
                  position="right"
                  offset="0"
                >
                  Share viewpoint among all cameras.
                </paper-tooltip>
              </paper-radio-group>
            </div>
          </div>
        </div>
        <div class="sidebar-section runs-selector">
          <tf-runs-selector selected-runs="{{_selectedRuns}}">
          </tf-runs-selector>
        </div>
      </div>
      <div slot="center">
        <template is="dom-if" if="[[_dataNotFound]]">
          <div class="no-data-warning">
            <h3>No point cloud data was found.</h3>
            <p>Probable causes:</p>
            <ul>
              <li>
                You haven’t written any point cloud data to your event files.
              </li>
              <li>TensorBoard can’t find your event files.</li>
            </ul>

            <p>
              If you’re new to using TensorBoard, and want to find out how to
              add data and set up your event files, check out the
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
                >README</a
              >
              and perhaps the
              <a
                href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
                >TensorBoard tutorial</a
              >.
            </p>

            <p>
              If you think TensorBoard is configured properly, please see
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"
                >the section of the README devoted to missing data problems</a
              >
              and consider filing an issue on GitHub.
            </p>
          </div>
        </template>
        <template is="dom-if" if="[[!_dataNotFound]]">
          <tf-tag-filterer tag-filter="{{_tagFilter}}"></tf-tag-filterer>
          <template is="dom-repeat" items="[[_categories]]" as="category">
            <tf-category-paginated-view
              category="[[category]]"
              initial-opened="[[_shouldOpen(index)]]"
            >
              <template>
                <tf-mesh-loader
                  active="[[active]]"
                  selected-view="[[_selectedView]]"
                  run="[[item.run]]"
                  tag="[[item.tag]]"
                  sample="[[item.sample]]"
                  of-samples="[[item.ofSamples]]"
                  request-manager="[[_requestManager]]"
                  class="tf-mesh-loader-container"
                  on-camera-position-change="_onCameraPositionChanged"
                >
                </tf-mesh-loader>
              </template>
            </tf-category-paginated-view>
          </template>
        </template>
      </div>
    </tf-dashboard-layout>

    <style include="dashboard-style"></style>
    <style>
      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }
      paper-radio-button {
        display: block;
        padding: 5px;
      }
      .sidebar-section h3 {
        margin: 0;
        font-weight: normal;
        font-size: 14px;
        margin-bottom: 5px;
      }

      .runs-selector {
        flex-grow: 1;
      }

      tf-runs-selector {
        display: flex;
      }

      .view-control {
        display: block !important;
      }

      .view-control h3.title {
        padding-top: 16px;
        padding-bottom: 16px;
      }

      .allcontrols .view-control paper-radio-group {
        margin-top: 5px;
      }
      /* Layout must be horizontal, i.e. items arranged in a row. If items cannot fit in a row,
       * they should be moved to next line. All items must be square at all times. Minimum size of
       * the item is 480px. This means that maximum size of the item must be 480px + 479px = 959px.
       * */
      .horizontal {
        display: flex;
        flex-direction: row;
        flex-wrap: wrap;
      }
      tf-mesh-loader {
        width: 480px;
        flex-basis: 480px;
        flex-grow: 1;
        display: block;
      }
    </style>
  `;E([A({type:Boolean}),w("design:type",Boolean)],ph.prototype,"reloadOnReady",void 0);E([A({type:Array}),w("design:type",Array)],ph.prototype,"_selectedRuns",void 0);E([A({type:Object}),w("design:type",Object)],ph.prototype,"_runToTagInfo",void 0);E([A({type:Boolean}),w("design:type",Boolean)],ph.prototype,"_dataNotFound",void 0);E([A({type:String}),w("design:type",String)],ph.prototype,"_tagFilter",void 0);E([A({type:String,notify:!0}),w("design:type",String)],ph.prototype,"_selectedView",void 0);E([A({type:Object}),w("design:type",Object)],ph.prototype,"_requestManager",void 0);E([Rt("_runToTagInfo","_selectedRuns","_tagFilter"),w("design:type",Array),w("design:paramtypes",[])],ph.prototype,"_categories",null);ph=E([yt("mesh-dashboard"),w("design:paramtypes",[])],ph);var QU=class extends Gt(mt){constructor(){super(...arguments),this._installCommand="pip install -U tensorboard-plugin-profile"}_copyInstallCommand(){return Ri(this,null,function*(){let t=()=>Ri(this,null,function*(){this.$.commandTextarea.select();try{yield navigator.clipboard.writeText(this._installCommand)}catch(i){if(!document.execCommand("copy"))return Promise.reject()}}),r=this.$.copiedMessage;try{yield t(),r.innerText="Copied."}catch(n){r.innerText="Failed to copy to clipboard."}})}_removeCopiedMessage(){let t=this.$.copiedMessage;t.innerText=""}};QU.template=Q`
    <div class="message">
      <h3>The profile plugin has moved.</h3>
      <p>
        Please install the new version of the profile plugin from PyPI by
        running the following command from the machine running TensorBoard:
      </p>
      <textarea
        id="commandTextarea"
        readonly=""
        rows="1"
        on-blur="_removeCopiedMessage"
      >
[[_installCommand]]</textarea
      >
      <div id="copyContainer">
        <span id="copiedMessage"></span>
        <paper-button raised="" on-tap="_copyInstallCommand"
          >Copy to clipboard</paper-button
        >
      </div>
    </div>

    <style>
      :host {
        display: flex;
      }

      .message {
        margin: 80px auto 0 auto;
        max-width: 540px;
      }
      #commandTextarea {
        margin-top: 1ex;
        padding: 1ex 1em;
        resize: vertical;
        width: 100%;
      }
      #copyContainer {
        display: flex;
      }
      #copiedMessage {
        align-self: center;
        flex-grow: 1;
        font-style: italic;
        padding-right: 1em;
        text-align: right;
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],QU.prototype,"_installCommand",void 0);QU=E([yt("tf-profile-redirect-dashboard")],QU);var lm=Ee(Oe(),1);var zl=Ee(Oe(),1),tq=Ee(wl(),1);var nn=class extends mt{constructor(){super(...arguments),this._expanded=!1,this._runToPrCurveEntry={},this._previousRunToPrCurveEntry={},this._colorScaleFunction={scale:fn},this._canceller=new an,this._xComponentsCreationMethod=()=>{let t=new tq.Scales.Linear;return{scale:t,axis:new tq.Axes.Numeric(t,"bottom"),accessor:r=>r.recall}},this._yValueAccessor=t=>t.precision,this._tooltipColumns=(()=>{let t=Wu(e0),r=n=>isNaN(n)?"NaN":t(n);return[{title:"Run",evaluate:n=>n.dataset.metadata().name},{title:"Threshold",evaluate:n=>r(n.datum.thresholds)},{title:"Precision",evaluate:n=>r(n.datum.precision)},{title:"Recall",evaluate:n=>r(n.datum.recall)},{title:"TP",evaluate:n=>n.datum.true_positives},{title:"FP",evaluate:n=>n.datum.false_positives},{title:"TN",evaluate:n=>n.datum.true_negatives},{title:"FN",evaluate:n=>n.datum.false_negatives}]})(),this._seriesDataFields=["thresholds","precision","recall","true_positives","false_positives","true_negatives","false_negatives"],this._defaultXRange=[-.05,1.05],this._defaultYRange=[-.05,1.05],this._requestData=(t,r,n)=>{let o=_e().pluginRoute("pr_curves","/pr_curves");Promise.all(t.map(a=>{let s=a,l=this.tag,c=Mi(o,{tag:l,run:s});return this.requestManager.request(c).then(u=>void r({item:a,data:u}))})).finally(()=>void n())},this._smoothingEnabled=!1}_createProcessDataFunction(){return(t,r,n)=>{this.set("_runToDataOverTime",Object.assign({},this._runToDataOverTime,n))}}_computeRunColor(t){return fn(t)}connectedCallback(){super.connectedCallback(),this._attached=!0,this.reload()}_getChartDataLoader(){var t;return(t=this.shadowRoot)==null?void 0:t.querySelector("tf-line-chart-data-loader")}reload(){if(!!this._attached){if(this.runs.length===0){this.set("_runToDataOverTime",{});return}this._getChartDataLoader().reload()}}_setChartData(){var t=this._runToPrCurveEntry,r=this._previousRunToPrCurveEntry,n=this._setOfRelevantRuns;zl.forOwn(t,(i,o)=>{let a=r[o];if(!(a&&t[o].step===a.step)){if(!n[o]){this._clearSeriesData(o);return}this._updateSeriesDataForRun(o,i)}})}_updateSeriesDataForRun(t,r){let n=zl.reduce(this._seriesDataFields,(a,s)=>(a[s]=r[s].slice().reverse(),a),{}),i=new Array(n[this._seriesDataFields[0]].length);for(let a=0;a<i.length;a++)i[a]=zl.mapValues(n,s=>s[a]);let o=this._getChartDataLoader();o.setSeriesData(t,i),o.commitChanges()}_clearSeriesData(t){let r=this._getChartDataLoader();r.setSeriesData(t,[]),r.commitChanges()}_updateRunToPrCurveEntry(){var t=this._runToDataOverTime,r=this.runToStepCap;let n={};zl.forOwn(t,(i,o)=>{!i||!i.length||(n[o]=this._computeEntryClosestOrEqualToStepCap(r[o],i))}),this.set("_previousRunToPrCurveEntry",this._runToPrCurveEntry),this.set("_runToPrCurveEntry",n)}_notifyDataChange(){var t=this._runToDataOverTime;this.onDataChange&&this.onDataChange(t)}_computeEntryClosestOrEqualToStepCap(t,r){let n=Math.min(zl.sortedIndex(r.map(i=>i.step),t),r.length-1);return r[n]}get _runsWithStepAvailable(){var t=this.runs,r=this._runToPrCurveEntry;return zl.filter(t,n=>r[n]).sort()}get _setOfRelevantRuns(){var t=this._runsWithStepAvailable;let r={};return zl.forEach(t,n=>{r[n]=!0}),r}_computeCurrentStepForRun(t,r){let n=t[r];return n?n.step:null}_computeCurrentWallTimeForRun(t,r){let n=t[r];return n?new Date(n.wall_time*1e3).toString():null}_toggleExpanded(t){this.set("_expanded",!this._expanded),this.redraw()}_resetDomain(){this._getChartDataLoader().resetDomain()}redraw(){this._getChartDataLoader().redraw()}};nn.template=Q`
    <tf-card-heading
      tag="[[tag]]"
      display-name="[[tagMetadata.displayName]]"
      description="[[tagMetadata.description]]"
    ></tf-card-heading>

    <tf-line-chart-data-loader
      x-components-creation-method="[[_xComponentsCreationMethod]]"
      y-value-accessor="[[_yValueAccessor]]"
      tooltip-columns="[[_tooltipColumns]]"
      color-scale="[[_colorScaleFunction]]"
      default-x-range="[[_defaultXRange]]"
      default-y-range="[[_defaultYRange]]"
      smoothing-enabled="[[_smoothingEnabled]]"
      request-manager="[[requestManager]]"
      data-to-load="[[runs]]"
      data-series="[[runs]]"
      load-key="[[tag]]"
      request-data="[[_requestData]]"
      load-data-callback="[[_createProcessDataFunction()]]"
      active="[[active]]"
    ></tf-line-chart-data-loader>

    <div id="buttons-row">
      <paper-icon-button
        selected$="[[_expanded]]"
        icon="fullscreen"
        on-tap="_toggleExpanded"
      ></paper-icon-button>
      <paper-icon-button
        icon="settings-overscan"
        on-tap="_resetDomain"
        title="Reset axes to [0, 1]."
      ></paper-icon-button>
    </div>

    <div id="step-legend">
      <template is="dom-repeat" items="[[_runsWithStepAvailable]]" as="run">
        <div class="legend-row">
          <div
            class="color-box"
            style="background: [[_computeRunColor(run)]];"
          ></div>
          [[run]] is at
          <span class="step-label-text">
            step [[_computeCurrentStepForRun(_runToPrCurveEntry, run)]] </span
          ><br />
          <span class="wall-time-label-text">
            ([[_computeCurrentWallTimeForRun(_runToPrCurveEntry, run)]])
          </span>
        </div>
      </template>
    </div>

    <style>
      :host {
        display: flex;
        flex-direction: column;
        width: 500px;
        margin-right: 10px;
        margin-bottom: 25px;
      }
      :host([_expanded]) {
        width: 100%;
      }
      tf-line-chart-data-loader {
        height: 300px;
        position: relative;
      }
      :host([_expanded]) tf-line-chart-data-loader {
        height: 600px;
      }
      #buttons-row {
        display: flex;
        flex-direction: row;
      }
      #buttons-row paper-icon-button {
        color: #2196f3;
        border-radius: 100%;
        width: 32px;
        height: 32px;
        padding: 4px;
      }
      #buttons-row paper-icon-button[selected] {
        background: var(--tb-ui-light-accent);
      }
      #step-legend {
        box-sizing: border-box;
        font-size: 0.8em;
        max-height: 200px;
        overflow-y: auto;
        padding: 0 0 0 10px;
        width: 100%;
      }
      .legend-row {
        margin: 5px 0 5px 0;
        width: 100%;
      }
      .color-box {
        display: inline-block;
        border-radius: 1px;
        width: 10px;
        height: 10px;
      }
      .step-label-text {
        font-weight: bold;
      }
      .wall-time-label-text {
        color: #888;
        font-size: 0.8em;
      }
    </style>
  `;E([A({type:Array}),w("design:type",Array)],nn.prototype,"runs",void 0);E([A({type:String}),w("design:type",String)],nn.prototype,"tag",void 0);E([A({type:Object}),w("design:type",Object)],nn.prototype,"tagMetadata",void 0);E([A({type:Object}),w("design:type",Object)],nn.prototype,"runToStepCap",void 0);E([A({type:Object}),w("design:type",Ae)],nn.prototype,"requestManager",void 0);E([A({type:Boolean}),w("design:type",Boolean)],nn.prototype,"active",void 0);E([A({type:Boolean,reflectToAttribute:!0}),w("design:type",Boolean)],nn.prototype,"_expanded",void 0);E([A({type:Object}),w("design:type",Object)],nn.prototype,"_runToPrCurveEntry",void 0);E([A({type:Object}),w("design:type",Object)],nn.prototype,"_previousRunToPrCurveEntry",void 0);E([A({type:Object}),w("design:type",Object)],nn.prototype,"_runToDataOverTime",void 0);E([A({type:Object}),w("design:type",Function)],nn.prototype,"onDataChange",void 0);E([A({type:Object}),w("design:type",Object)],nn.prototype,"_colorScaleFunction",void 0);E([A({type:Object}),w("design:type",an)],nn.prototype,"_canceller",void 0);E([A({type:Boolean}),w("design:type",Boolean)],nn.prototype,"_attached",void 0);E([A({type:Object}),w("design:type",Object)],nn.prototype,"_xComponentsCreationMethod",void 0);E([A({type:Object}),w("design:type",Object)],nn.prototype,"_yValueAccessor",void 0);E([A({type:Array}),w("design:type",Array)],nn.prototype,"_tooltipColumns",void 0);E([A({type:Array}),w("design:type",Array)],nn.prototype,"_seriesDataFields",void 0);E([A({type:Array}),w("design:type",Array)],nn.prototype,"_defaultXRange",void 0);E([A({type:Array}),w("design:type",Array)],nn.prototype,"_defaultYRange",void 0);E([A({type:Object}),w("design:type",Function)],nn.prototype,"_requestData",void 0);E([A({type:Boolean}),w("design:type",Boolean)],nn.prototype,"_smoothingEnabled",void 0);E([Bt("runs","tag"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],nn.prototype,"reload",null);E([Bt("_runToPrCurveEntry","_previousRunToPrCurveEntry","_setOfRelevantRuns"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],nn.prototype,"_setChartData",null);E([Bt("_runToDataOverTime","runToStepCap"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],nn.prototype,"_updateRunToPrCurveEntry",null);E([Bt("_runToDataOverTime"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],nn.prototype,"_notifyDataChange",null);E([Rt("runs","_runToPrCurveEntry"),w("design:type",Array),w("design:paramtypes",[])],nn.prototype,"_runsWithStepAvailable",null);E([Rt("_runsWithStepAvailable"),w("design:type",Object),w("design:paramtypes",[])],nn.prototype,"_setOfRelevantRuns",null);nn=E([yt("tf-pr-curve-card")],nn);var SM=Ee(Oe(),1);var ep=class extends mt{constructor(){super(...arguments),this._runToStepIndex={}}_computeColorForRun(t){return fn(t)}_computeTimeTextForRun(t,r,n,i){let o=r[n];if(!SM.isNumber(o))return"";let a=t[n];if(!a)return"";let s=a[o][i];if(i==="step")return`step ${s}`;if(i==="relative")return s<1?`${(s*1e3).toFixed(2)} ms`:`${s.toFixed(2)} s`;if(i==="wall_time")return new Date(s*1e3).toString();throw new Error(`The display type of ${i} is not recognized.`)}_sliderValueChanged(t){let r=t.target.dataset.run,n=t.target.immediateValue,i=Object.assign({},this._runToStepIndex);isNaN(n)?delete i[r]:i[r]=t.target.immediateValue,this._runToStepIndex=i}_computeMaxStepIndexForRun(t,r){let n=t[r];return n&&n.length?n.length-1:0}_updateStepsForNewRuns(){var t=this.runToAvailableTimeEntries;let r=Object.assign({},this._runToStepIndex);SM.forOwn(t,(n,i)=>{SM.isNumber(r[i])||(r[i]=n.length-1)}),this._runToStepIndex=r}_getStep(t,r){return this._runToStepIndex?this._runToStepIndex[r]:0}_computeRunToStep(t,r){let n={};return SM.forOwn(r,(i,o)=>{let a=t[o];!a||(n[o]=a[i].step)}),n}get _runsWithSliders(){var t=this.runs,r=this.runToAvailableTimeEntries;return t.filter(n=>r[n])}};ep.template=Q`
    <template is="dom-repeat" items="[[_runsWithSliders]]" as="run">
      <div class="run-widget">
        <div class="run-display-container">
          <div
            class="run-color-box"
            style="background:[[_computeColorForRun(run)]];"
          ></div>
          <div class="run-text">[[run]]</div>
        </div>
        <div class="step-display-container">
          [[_computeTimeTextForRun(runToAvailableTimeEntries, _runToStepIndex,
          run, timeDisplayType)]]
        </div>
        <paper-slider
          data-run$="[[run]]"
          step="1"
          type="number"
          min="0"
          max="[[_computeMaxStepIndexForRun(runToAvailableTimeEntries, run)]]"
          value="[[_getStep(_runToStepIndex, run)]]"
          on-immediate-value-changed="_sliderValueChanged"
        ></paper-slider>
      </div>
    </template>
    <style>
      .run-widget {
        margin: 10px 0 0 0;
      }
      paper-slider {
        margin: -8px 0 0 -15px;
        width: 100%;
      }
      .step-display-container {
        font-size: 0.9em;
        margin: 0 15px 0 0;
      }
      .run-text {
        display: inline-block;
      }
      .run-color-box {
        width: 12px;
        height: 12px;
        border-radius: 3px;
        display: inline-block;
      }
    </style>
  `;E([A({type:Array}),w("design:type",Array)],ep.prototype,"runs",void 0);E([A({type:Object}),w("design:type",Object)],ep.prototype,"runToAvailableTimeEntries",void 0);E([A({type:Object,notify:!0,computed:"_computeRunToStep(runToAvailableTimeEntries, _runToStepIndex)"}),w("design:type",Object)],ep.prototype,"runToStep",void 0);E([A({type:String}),w("design:type",String)],ep.prototype,"timeDisplayType",void 0);E([A({type:Object}),w("design:type",Object)],ep.prototype,"_runToStepIndex",void 0);E([Bt("runToAvailableTimeEntries"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],ep.prototype,"_updateStepsForNewRuns",null);E([Rt("runs","runToAvailableTimeEntries"),w("design:type",Array),w("design:paramtypes",[])],ep.prototype,"_runsWithSliders",null);ep=E([yt("tf-pr-curve-steps-selector")],ep);var ko=class extends Gt(mt){constructor(){super(...arguments),this.reloadOnReady=!0,this._timeDisplayType="step",this._selectedRuns=[],this._runToTagInfo={},this._tagToRunToData={},this._getCategoryItemKey=t=>t.tag,this._requestManager=new Ae,this._step=0}ready(){super.ready(),this.reloadOnReady&&this.reload()}reload(){Promise.all([this._fetchTags()]).then(()=>{this._reloadCards()})}_shouldOpen(t){return t<=2}_fetchTags(){let t=_e().pluginRoute("pr_curves","/tags");return this._requestManager.request(t).then(r=>{if(lm.isEqual(r,this._runToTagInfo))return;let n=lm.mapValues(r,o=>lm.keys(o)),i=$i(n);this.set("_dataNotFound",i.length===0),this.set("_runToTagInfo",r),this.async(()=>{this.set("_categoriesDomReady",!0)})})}_reloadCards(){var t;lm.forEach((t=this.root)==null?void 0:t.querySelectorAll("tf-pr-curve-card"),r=>{r.reload()})}get _categories(){var t=this._runToTagInfo,r=this._selectedRuns,n=this._tagFilter;let i=lm.mapValues(t,o=>Object.keys(o));return hE(i,r,n)}get _relevantSelectedRuns(){var t=this._selectedRuns,r=this._runToTagInfo;return t.filter(n=>r[n])}_tagMetadata(t,r,n){let i={};r.forEach(a=>{i[a]=t[a][n]});let o=n.replace(/\/pr_curves$/,"");return oR(i,o)}_createDataChangeCallback(t){return r=>{this.set("_tagToRunToData",Mx(Kl({},this._tagToRunToData),{[t]:r}))}}get _runToAvailableTimeEntries(){var t=this._tagToRunToData;let r={};for(let[i,o]of Object.entries(t))for(let[a]of Object.entries(o))(r[a]==null||i<r[a])&&(r[a]=i);let n={};for(let[i,o]of Object.entries(r)){let a=t[o][i];n[i]=a.map(s=>({step:s.step,wall_time:s.wall_time,relative:s.wall_time-a[0].wall_time}))}return n}};ko.template=Q`
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <div class="settings">
          <div class="sidebar-section">
            <tf-option-selector
              id="time-type-selector"
              name="Time Display Type"
              selected-id="{{_timeDisplayType}}"
            >
              <paper-button id="step">step</paper-button>
              <!--
            -->
              <paper-button id="relative">relative</paper-button>
              <!--
            -->
              <paper-button id="wall_time">wall</paper-button>
            </tf-option-selector>
          </div>
          <template is="dom-if" if="[[_runToAvailableTimeEntries]]">
            <div class="sidebar-section" id="steps-selector-container">
              <tf-pr-curve-steps-selector
                runs="[[_relevantSelectedRuns]]"
                run-to-step="{{_runToStep}}"
                run-to-available-time-entries="[[_runToAvailableTimeEntries]]"
                time-display-type="[[_timeDisplayType]]"
              >
              </tf-pr-curve-steps-selector>
            </div>
          </template>
        </div>
        <div class="sidebar-section runs-selector">
          <tf-runs-selector selected-runs="{{_selectedRuns}}">
          </tf-runs-selector>
        </div>
      </div>
      <div class="center" slot="center">
        <template is="dom-if" if="[[_dataNotFound]]">
          <div class="no-data-warning">
            <h3>No precision–recall curve data was found.</h3>
            <p>Probable causes:</p>
            <ul>
              <li>
                You haven’t written any precision–recall data to your event
                files.
              </li>
              <li>TensorBoard can’t find your event files.</li>
            </ul>
            <p>
              If you’re new to using TensorBoard, and want to find out how to
              add data and set up your event files, check out the
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
                >README</a
              >
              and perhaps the
              <a
                href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
                >TensorBoard tutorial</a
              >.
            </p>

            <p>
              If you think TensorBoard is configured properly, please see
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"
                >the section of the README devoted to missing data problems</a
              >
              and consider filing an issue on GitHub.
            </p>
          </div>
        </template>
        <template is="dom-if" if="[[!_dataNotFound]]">
          <tf-tag-filterer tag-filter="{{_tagFilter}}"></tf-tag-filterer>
          <template is="dom-repeat" items="[[_categories]]" as="category">
            <tf-category-paginated-view
              category="[[category]]"
              initial-opened="[[_shouldOpen(index)]]"
              get-category-item-key="[[_getCategoryItemKey]]"
            >
              <template>
                <tf-pr-curve-card
                  active="[[active]]"
                  runs="[[item.runs]]"
                  tag="[[item.tag]]"
                  tag-metadata="[[_tagMetadata(_runToTagInfo, item.runs, item.tag)]]"
                  request-manager="[[_requestManager]]"
                  run-to-step-cap="[[_runToStep]]"
                  on-data-change="[[_createDataChangeCallback(item.tag)]]"
                ></tf-pr-curve-card>
              </template>
            </tf-category-paginated-view>
          </template>
        </template>
      </div>
    </tf-dashboard-layout>

    <style include="dashboard-style"></style>
    <style>
      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }

      /** Do not let the steps selector occlude the run selector. */
      #steps-selector-container {
        max-height: 60%;
        overflow-y: auto;
      }
    </style>
  `;E([A({type:Boolean}),w("design:type",Boolean)],ko.prototype,"reloadOnReady",void 0);E([A({type:String}),w("design:type",String)],ko.prototype,"_timeDisplayType",void 0);E([A({type:Array}),w("design:type",Array)],ko.prototype,"_selectedRuns",void 0);E([A({type:Object}),w("design:type",Object)],ko.prototype,"_runToTagInfo",void 0);E([A({type:Object}),w("design:type",Object)],ko.prototype,"_tagToRunToData",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],ko.prototype,"_runToStep",void 0);E([A({type:Boolean}),w("design:type",Boolean)],ko.prototype,"_dataNotFound",void 0);E([A({type:String}),w("design:type",String)],ko.prototype,"_tagFilter",void 0);E([A({type:Boolean}),w("design:type",Boolean)],ko.prototype,"_categoriesDomReady",void 0);E([A({type:Object}),w("design:type",Object)],ko.prototype,"_getCategoryItemKey",void 0);E([A({type:Object}),w("design:type",Ae)],ko.prototype,"_requestManager",void 0);E([A({type:Number,notify:!0}),w("design:type",Number)],ko.prototype,"_step",void 0);E([Rt("_runToTagInfo","_selectedRuns","_tagFilter","_categoriesDomReady"),w("design:type",Array),w("design:paramtypes",[])],ko.prototype,"_categories",null);E([Rt("_selectedRuns","_runToTagInfo"),w("design:type",Array),w("design:paramtypes",[])],ko.prototype,"_relevantSelectedRuns",null);E([Rt("_tagToRunToData"),w("design:type",Object),w("design:paramtypes",[])],ko.prototype,"_runToAvailableTimeEntries",null);ko=E([yt("tf-pr-curve-dashboard")],ko);var B6=Ee(Oe(),1);var uo=class extends Gt(nb){constructor(){super(...arguments),this.reloadOnReady=!0,this._showDownloadLinks=vp("_showDownloadLinks",{defaultValue:!1,useLocalStorage:!0}).call(this),this._smoothingWeight=_E("_smoothingWeight",{defaultValue:.6}).call(this),this._ignoreYOutliers=vp("_ignoreYOutliers",{defaultValue:!0,useLocalStorage:!0}).call(this),this._xType=Ed.STEP,this._selectedRuns=[],this._tagFilter="",this._categories=[],this._getCategoryItemKey=t=>t.tag,this._requestManager=new Ae(50),this._showDownloadLinksObserver=xp("_showDownloadLinks",{defaultValue:!1,useLocalStorage:!0}),this._smoothingWeightObserver=yE("_smoothingWeight",{defaultValue:.6}),this._ignoreYOutliersObserver=xp("_ignoreYOutliers",{defaultValue:!0,useLocalStorage:!0})}get _smoothingEnabled(){var t=this._smoothingWeight;return t>0}_getCategoryKey(t){return t.metadata.type==Na.SEARCH_RESULTS?"":t.name}_shouldOpen(t){return t<=2}ready(){super.ready(),this.reloadOnReady&&this.reload()}reload(){this._fetchTags().then(()=>{this._reloadCharts()})}_fetchTags(){let t=_e().pluginRoute("scalars","/tags");return this._requestManager.request(t).then(r=>{if(B6.isEqual(r,this._runToTagInfo))return;let n=B6.mapValues(r,o=>Object.keys(o)),i=$i(n);this.set("_dataNotFound",i.length===0),this.set("_runToTagInfo",r),this.async(()=>{this.set("_categoriesDomReady",!0)})})}_reloadCharts(){var t;(t=this.root)==null||t.querySelectorAll("tf-scalar-card").forEach(r=>{r.reload()})}_updateCategories(){var t=this._runToTagInfo,r=this._selectedRuns,n=this._tagFilter;let i,o=n,a=B6.mapValues(t,s=>Object.keys(s));i=hE(a,r,o),i.forEach(s=>{s.items=s.items.map(l=>({tag:l.tag,series:l.runs.map(c=>({run:c,tag:l.tag}))}))}),this.updateArrayProp("_categories",i,this._getCategoryKey)}_tagMetadata(t,r,n){let i=t.name,o=n.tag,a={};n.series.forEach(({run:u})=>{a[u]=r[u][o]});let s=o.replace(/\/scalar_summary$/,""),{description:l,displayName:c}=oR(a,s);return t.metadata.type==Na.PREFIX_GROUP&&c.startsWith(i+"/")&&(c=c.slice(i.length+1)),{description:l,displayName:c}}};uo.template=Q`
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <div class="settings">
          <div class="sidebar-section">
            <div class="line-item">
              <paper-checkbox
                id="show-download-links"
                checked="{{_showDownloadLinks}}"
                >Show data download links</paper-checkbox
              >
            </div>
            <div class="line-item">
              <paper-checkbox
                id="ignore-y-outlier"
                checked="{{_ignoreYOutliers}}"
                >Ignore outliers in chart scaling</paper-checkbox
              >
            </div>
            <div id="tooltip-sorting">
              <div>Tooltip sorting method:</div>
              <paper-dropdown-menu
                no-label-float
                selected-item-label="{{_tooltipSortingMethod}}"
              >
                <paper-listbox
                  class="dropdown-content"
                  selected="0"
                  slot="dropdown-content"
                >
                  <paper-item>default</paper-item>
                  <paper-item>descending</paper-item>
                  <paper-item>ascending</paper-item>
                  <paper-item>nearest</paper-item>
                </paper-listbox>
              </paper-dropdown-menu>
            </div>
          </div>
          <div class="sidebar-section">
            <tf-smoothing-input
              weight="{{_smoothingWeight}}"
              step="0.001"
              min="0"
              max="0.999"
            ></tf-smoothing-input>
          </div>
          <div class="sidebar-section">
            <tf-option-selector
              id="x-type-selector"
              name="Horizontal Axis"
              selected-id="{{_xType}}"
            >
              <paper-button id="step">step</paper-button
              ><!--
            --><paper-button id="relative">relative</paper-button
              ><!--
            --><paper-button id="wall_time">wall</paper-button>
            </tf-option-selector>
          </div>
        </div>
        <div class="sidebar-section runs-selector">
          <tf-runs-selector selected-runs="{{_selectedRuns}}">
          </tf-runs-selector>
        </div>
      </div>
      <div class="center" slot="center">
        <template is="dom-if" if="[[_dataNotFound]]">
          <div class="no-data-warning">
            <h3>No scalar data was found.</h3>
            <p>Probable causes:</p>
            <ul>
              <li>You haven’t written any scalar data to your event files.</li>
              <li>TensorBoard can’t find your event files.</li>
            </ul>

            <p>
              If you’re new to using TensorBoard, and want to find out how to
              add data and set up your event files, check out the
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
                >README</a
              >
              and perhaps the
              <a
                href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
                >TensorBoard tutorial</a
              >.
            </p>

            <p>
              If you think TensorBoard is configured properly, please see
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"
                >the section of the README devoted to missing data problems</a
              >
              and consider filing an issue on GitHub.
            </p>
          </div>
        </template>
        <template is="dom-if" if="[[!_dataNotFound]]">
          <tf-tag-filterer tag-filter="{{_tagFilter}}"></tf-tag-filterer>
          <template is="dom-repeat" items="[[_categories]]" as="category">
            <tf-category-paginated-view
              category="[[category]]"
              initial-opened="[[_shouldOpen(index)]]"
              get-category-item-key="[[_getCategoryItemKey]]"
            >
              <template>
                <tf-scalar-card
                  active="[[active]]"
                  data-to-load="[[item.series]]"
                  ignore-y-outliers="[[_ignoreYOutliers]]"
                  multi-experiments="[[_getMultiExperiments(dataSelection)]]"
                  request-manager="[[_requestManager]]"
                  show-download-links="[[_showDownloadLinks]]"
                  smoothing-enabled="[[_smoothingEnabled]]"
                  smoothing-weight="[[_smoothingWeight]]"
                  tag-metadata="[[_tagMetadata(category, _runToTagInfo, item)]]"
                  tag="[[item.tag]]"
                  tooltip-sorting-method="[[_tooltipSortingMethod]]"
                  x-type="[[_xType]]"
                  batch-size="[[featureFlags.scalarsBatchSize]]"
                  in-colab="[[featureFlags.inColab]]"
                ></tf-scalar-card>
              </template>
            </tf-category-paginated-view>
          </template>
        </template>
      </div>
    </tf-dashboard-layout>

    <style include="dashboard-style"></style>
    <style>
      #tooltip-sorting {
        align-items: center;
        display: flex;
        font-size: 14px;
        margin-top: 15px;
      }

      #tooltip-sorting paper-dropdown-menu {
        margin-left: 10px;
        --paper-input-container-focus-color: var(--tb-orange-strong);
        width: 105px;
      }

      .line-item {
        display: block;
        padding-top: 5px;
      }
      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }
      .center {
        overflow-x: hidden;
      }
    </style>
  `;E([A({type:Boolean}),w("design:type",Boolean)],uo.prototype,"reloadOnReady",void 0);E([A({type:Object}),w("design:type",Object)],uo.prototype,"featureFlags",void 0);E([A({type:Boolean,notify:!0,observer:"_showDownloadLinksObserver"}),w("design:type",Boolean)],uo.prototype,"_showDownloadLinks",void 0);E([A({type:Number,notify:!0,observer:"_smoothingWeightObserver"}),w("design:type",Number)],uo.prototype,"_smoothingWeight",void 0);E([A({type:Boolean,observer:"_ignoreYOutliersObserver"}),w("design:type",Boolean)],uo.prototype,"_ignoreYOutliers",void 0);E([A({type:String}),w("design:type",String)],uo.prototype,"_xType",void 0);E([A({type:Array}),w("design:type",Array)],uo.prototype,"_selectedRuns",void 0);E([A({type:Object}),w("design:type",Object)],uo.prototype,"_runToTagInfo",void 0);E([A({type:Boolean}),w("design:type",Boolean)],uo.prototype,"_dataNotFound",void 0);E([A({type:String}),w("design:type",String)],uo.prototype,"_tagFilter",void 0);E([A({type:Boolean}),w("design:type",Boolean)],uo.prototype,"_categoriesDomReady",void 0);E([A({type:Array}),w("design:type",Array)],uo.prototype,"_categories",void 0);E([A({type:Object}),w("design:type",Object)],uo.prototype,"_getCategoryItemKey",void 0);E([A({type:Object}),w("design:type",Ae)],uo.prototype,"_requestManager",void 0);E([Rt("_smoothingWeight"),w("design:type",Boolean),w("design:paramtypes",[])],uo.prototype,"_smoothingEnabled",null);E([Bt("_runToTagInfo","_selectedRuns","_tagFilter","_categoriesDomReady"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],uo.prototype,"_updateCategories",null);uo=E([yt("tf-scalar-dashboard")],uo);var cpe=Ee(Oe(),1);var dh=class extends Gt(mt){constructor(){super(...arguments),this._texts=[],this._canceller=new an}get _runColor(){var t=this.run;return fn(t)}_changeRunColor(){var t=this._runColor;this.updateStyles({"--tb-text-loader-outline":t})}attached(){this.reload()}reload(){if(!this.isAttached)return;this._canceller.cancelAll();let t=_e(),r=Mi(t.pluginRoute("text","/text"),{tag:this.tag,run:this.run,markdown:this.markdownEnabled?"true":"false"}),n=this._canceller.cancellable(i=>{if(i.cancelled)return;let o=i.value.map(a=>({wall_time:new Date(a.wall_time*1e3),step:a.step,text:a.text}));this.set("_texts",o.slice().reverse())});this.requestManager.request(r).then(n)}_formatStep(t){return xn(",")(t)}};dh.template=Q`
    <tf-card-heading run="[[run]]" tag="[[tag]]" color="[[_runColor]]">
    </tf-card-heading>
    <paper-material
      elevation="1"
      id="steps-container"
      class="container scrollbar"
    >
      <template is="dom-repeat" items="[[_texts]]">
        <paper-material elevation="1" class="step-container">
          step <span class="step-value">[[_formatStep(item.step)]]</span>
        </paper-material>
        <paper-material elevation="1" class="text">
          <tf-markdown-view html="[[item.text]]"></tf-markdown-view>
        </paper-material>
      </template>
    </paper-material>
    <style include="scrollbar-style"></style>
    <style>
      :host {
        display: flex;
        flex-direction: column;
        width: 100%;
        height: auto;
        margin-right: 10px;
        margin-bottom: 15px;
      }
      .scrollbar {
        will-change: transform;
      }
      #steps-container {
        border-radius: 3px;
        border: 2px solid /* color computed and set as inline style */;
        display: block;
        max-height: 500px;
        overflow: auto;
        padding: 10px;
        border-color: var(--tb-text-loader-outline);
      }
      .text {
        background-color: inherit;
        border-radius: 0 3px 3px 3px;
        padding: 5px;
        word-break: break-word;
      }
      .step-container {
        background-color: var(--tb-ui-light-accent);
        border-bottom: none;
        border-radius: 3px 3px 0 0;
        border: 1px solid var(--tb-ui-border);
        display: inline-block;
        font-size: 12px;
        font-style: italic;
        margin-left: -1px; /* to correct for border */
        padding: 3px;
      }
      .step-container:not(:first-child) {
        margin-top: 15px;
      }

      tf-card-heading {
        margin-bottom: 10px;
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],dh.prototype,"run",void 0);E([A({type:String}),w("design:type",String)],dh.prototype,"tag",void 0);E([A({type:Boolean}),w("design:type",Boolean)],dh.prototype,"markdownEnabled",void 0);E([A({type:Array}),w("design:type",Array)],dh.prototype,"_texts",void 0);E([A({type:Object}),w("design:type",Ae)],dh.prototype,"requestManager",void 0);E([A({type:Object}),w("design:type",an)],dh.prototype,"_canceller",void 0);E([Rt("run"),w("design:type",String),w("design:paramtypes",[])],dh.prototype,"_runColor",null);E([Bt("_runColor"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],dh.prototype,"_changeRunColor",null);dh=E([yt("tf-text-loader")],dh);var Qc=class extends Gt(mt){constructor(){super(...arguments),this.reloadOnReady=!0,this._markdownEnabled=vp("_markdownEnabled",{defaultValue:!0,useLocalStorage:!0}).call(this),this._requestManager=new Ae,this._markdownEnabledStorageObserver=xp("_markdownEnabled",{defaultValue:!0,useLocalStorage:!0})}static get observers(){return["_markdownEnabledObserver(_markdownEnabled)"]}ready(){super.ready(),this.reloadOnReady&&this.reload()}reload(){this._fetchTags().then(()=>{this._reloadTexts()})}_shouldOpen(t){return t<=2}_fetchTags(){let t=_e().pluginRoute("text","/tags");return this._requestManager.request(t).then(r=>{if(cpe.isEqual(r,this._runToTag))return;let n=$i(r);this.set("_dataNotFound",n.length===0),this.set("_runToTag",r),this.async(()=>{this.set("_categoriesDomReady",!0)})})}_reloadTexts(){var t;(t=this.root)==null||t.querySelectorAll("tf-text-loader").forEach(r=>{r.reload()})}get _categories(){var t=this._runToTag,r=this._selectedRuns,n=this._tagFilter;return Ql(t,r,n)}_markdownEnabledObserver(){this._reloadTexts()}};Qc.template=Q`
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <div class="sidebar-section">
          <div class="line-item">
            <paper-checkbox checked="{{_markdownEnabled}}"
              >Enable Markdown</paper-checkbox
            >
          </div>
        </div>
        <div class="sidebar-section runs-selector">
          <tf-runs-selector selected-runs="{{_selectedRuns}}">
          </tf-runs-selector>
        </div>
      </div>
      <div class="center" slot="center">
        <template is="dom-if" if="[[_dataNotFound]]">
          <div class="no-data-warning">
            <h3>No text data was found.</h3>
            <p>Probable causes:</p>
            <ul>
              <li>You haven’t written any text data to your event files.</li>
              <li>TensorBoard can’t find your event files.</li>
            </ul>

            <p>
              If you’re new to using TensorBoard, and want to find out how to
              add data and set up your event files, check out the
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
                >README</a
              >
              and perhaps the
              <a
                href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
                >TensorBoard tutorial</a
              >.
            </p>

            <p>
              If you think TensorBoard is configured properly, please see
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"
                >the section of the README devoted to missing data problems</a
              >
              and consider filing an issue on GitHub.
            </p>
          </div>
        </template>
        <template is="dom-if" if="[[!_dataNotFound]]">
          <tf-tag-filterer tag-filter="{{_tagFilter}}"></tf-tag-filterer>
          <template is="dom-repeat" items="[[_categories]]" as="category">
            <tf-category-paginated-view
              category="[[category]]"
              initial-opened="[[_shouldOpen(index)]]"
            >
              <template>
                <tf-text-loader
                  active="[[active]]"
                  tag="[[item.tag]]"
                  run="[[item.run]]"
                  request-manager="[[_requestManager]]"
                  markdown-enabled="[[_markdownEnabled]]"
                ></tf-text-loader>
              </template>
            </tf-category-paginated-view>
          </template>
        </template>
      </div>
    </tf-dashboard-layout>
    <style include="dashboard-style"></style>
    <style>
      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }
    </style>
  `;E([A({type:Boolean}),w("design:type",Boolean)],Qc.prototype,"reloadOnReady",void 0);E([A({type:Boolean,notify:!0,observer:"_markdownEnabledStorageObserver"}),w("design:type",Boolean)],Qc.prototype,"_markdownEnabled",void 0);E([A({type:Array}),w("design:type",Array)],Qc.prototype,"_selectedRuns",void 0);E([A({type:Object}),w("design:type",Object)],Qc.prototype,"_runToTag",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Qc.prototype,"_dataNotFound",void 0);E([A({type:String}),w("design:type",String)],Qc.prototype,"_tagFilter",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Qc.prototype,"_categoriesDomReady",void 0);E([A({type:Object}),w("design:type",Object)],Qc.prototype,"_requestManager",void 0);E([Rt("_runToTag","_selectedRuns","_tagFilter","_categoriesDomReady"),w("design:type",Array),w("design:paramtypes",[])],Qc.prototype,"_categories",null);Qc=E([yt("tf-text-dashboard")],Qc);var Vht=class extends Gt(mt){};Vht.template=Q`
    <div class="message">
      <h3>The What-If Tool is no longer supported.</h3>
      <p>
        The
        <a href="https://pair-code.github.io/lit/"
          >Learning Interpretability Tool (LIT)</a
        >
        is an actively maintained alternative. Please follow the instructions
        <a href="https://pair-code.github.io/lit/setup/">here</a> to install and
        use this tool.
      </p>
      <style>
        :host {
          display: flex;
        }

        .message {
          margin: 80px auto 0 auto;
          max-width: 540px;
        }
        #commandTextarea {
          margin-top: 1ex;
          padding: 1ex 1em;
          resize: vertical;
          width: 100%;
        }
        #copyContainer {
          display: flex;
        }
        #copiedMessage {
          align-self: center;
          flex-grow: 1;
          font-style: italic;
          padding-right: 1em;
          text-align: right;
        }
      </style>
    </div>
  `;Vht=E([yt("tf-wit-redirect-dashboard")],Vht);var upe=class extends mt{constructor(){super(...arguments),this._template=null,this.tf_backend=RB}};upe=E([yt("tf-backend")],upe);var hpe=class extends mt{constructor(){super(...arguments),this._template=null,this.runsColorScale=fn}};hpe=E([yt("tf-color-scale")],hpe);var fpe=class extends mt{constructor(){super(...arguments),this._template=null,this.tf_feature_flags=tW}};fpe=E([yt("tf-feature-flags")],fpe);var ppe=class extends mt{constructor(){super(...arguments),this._template=null,this.tf_globals=kW}};ppe=E([yt("tf-globals")],ppe);var Uht={};Ks(Uht,{TfDomRepeat:()=>Oi,addLimitListener:()=>UW,getLimit:()=>GW,removeLimitListener:()=>qW,setLimit:()=>s2e});var dpe=class extends mt{constructor(){super(...arguments),this._template=null,this.tf_paginated_view=Uht}};dpe=E([yt("tf-paginated-view-store")],dpe);var mpe=class extends mt{constructor(){super(...arguments),this._template=null,this.tf_storage=OB}};mpe=E([yt("tf-storage")],mpe);})();
/*!
 * is-plain-object <https://github.com/jonschlinkert/is-plain-object>
 *
 * Copyright (c) 2014-2017, Jon Schlinkert.
 * Released under the MIT License.
 */
/*!
 * isobject <https://github.com/jonschlinkert/isobject>
 *
 * Copyright (c) 2014-2017, Jon Schlinkert.
 * Released under the MIT License.
 */
/*! *****************************************************************************
Copyright (c) Microsoft Corporation. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
this file except in compliance with the License. You may obtain a copy of the
License at http://www.apache.org/licenses/LICENSE-2.0

THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
MERCHANTABLITY OR NON-INFRINGEMENT.

See the Apache Version 2.0 License for specific language governing permissions
and limitations under the License.
***************************************************************************** */
/**
 * @fileoverview
 * @suppress {checkPrototypalTypes}
 * @license Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
 * This code may only be used under the BSD style license found at
 * http://polymer.github.io/LICENSE.txt The complete set of authors may be found
 * at http://polymer.github.io/AUTHORS.txt The complete set of contributors may
 * be found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by
 * Google as part of the polymer project is also subject to an additional IP
 * rights grant found at http://polymer.github.io/PATENTS.txt
 */
/**
 * @license
 * Copyright (c) 2016 The Polymer Project Authors. All rights reserved.
 * This code may only be used under the BSD style license found at
 * http://polymer.github.io/LICENSE.txt The complete set of authors may be found
 * at http://polymer.github.io/AUTHORS.txt The complete set of contributors may
 * be found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by
 * Google as part of the polymer project is also subject to an additional IP
 * rights grant found at http://polymer.github.io/PATENTS.txt
 */
/**
 * @license
 * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
 * This code may only be used under the BSD style license found at
 * http://polymer.github.io/LICENSE.txt
 * The complete set of authors may be found at
 * http://polymer.github.io/AUTHORS.txt
 * The complete set of contributors may be found at
 * http://polymer.github.io/CONTRIBUTORS.txt
 * Code distributed by Google as part of the polymer project is also
 * subject to an additional IP rights grant found at
 * http://polymer.github.io/PATENTS.txt
 */
/**
 * @license
 * Copyright (c) 2018 The Polymer Project Authors. All rights reserved.
 * This code may only be used under the BSD style license found at
 * http://polymer.github.io/LICENSE.txt
 * The complete set of authors may be found at
 * http://polymer.github.io/AUTHORS.txt
 * The complete set of contributors may be found at
 * http://polymer.github.io/CONTRIBUTORS.txt
 * Code distributed by Google as part of the polymer project is also
 * subject to an additional IP rights grant found at
 * http://polymer.github.io/PATENTS.txt
 */
/**
 * @license
 * Copyright (c) 2021 Vaadin Ltd.
 * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
 */
/**
 * @license
 * Copyright 2010-2022 Three.js Authors
 * SPDX-License-Identifier: MIT
 */
/**
 * @license
 * Lodash <https://lodash.com/>
 * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
 * Released under MIT license <https://lodash.com/license>
 * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
 * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
 */
/**
 * Copyright 2014-present Palantir Technologies
 * @license MIT
 *
 * @fileoverview manually add d3-selection-multi to d3 default bundle. Most of this code is
 * copied from d3-selection-multi@1.0.0.
 * See https://github.com/d3/d3-selection-multi/issues/11 for why we have to do this
 */
/**
 * Copyright 2014-present Palantir Technologies
 * @license MIT
 * @fileoverview Implements a convenient thunk function to handle the common case
 * of creating a memoized function that takes its inputs from mutable class properties.
 */
/**
 * Copyright 2014-present Palantir Technologies
 * @license MIT
 * @fileoverview Implements a function memoizer using the Signature API.
 */
/**
 * Copyright 2014-present Palantir Technologies
 * @license MIT
 * @fileoverview Implements the Signature API to help in comparing when two
 * Plottable objects have "changed".
 *
 * Memoization in Plottable is complicated by mutable scales and datasets. We cannot simply
 * reference compare two e.g. scales since it may have internally mutated. To resolve this,
 * we write a recursive Signature interface that holds an immutable snapshot of whatever
 * state the scale/data was in at the time. Then on memoized function invocation we sign the
 * new inputs and compare the signatures to decide if we should recompute.
 *
 * We must hand-write a signature for each custom class we wish to support.
 */
/**
 * Copyright 2014-present Palantir Technologies
 * @license MIT
 */
/**
 * Copyright 2017-present Palantir Technologies
 * @license MIT
 */
/**
@license
Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
This code may only be used under the BSD style license found at
http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
part of the polymer project is also subject to an additional IP rights grant
found at http://polymer.github.io/PATENTS.txt
*/
/**
@license
Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
This code may only be used under the BSD style license found at
http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
part of the polymer project is also subject to an additional IP rights grant
found at http://polymer.github.io/PATENTS.txt
*/
/**
@license
Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
Code distributed by Google as part of the polymer project is also
subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
*/
/**
@license
Copyright (c) 2016 The Polymer Project Authors. All rights reserved.
This code may only be used under the BSD style license found at
http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
part of the polymer project is also subject to an additional IP rights grant
found at http://polymer.github.io/PATENTS.txt
*/
/**
@license
Copyright (c) 2016 The Polymer Project Authors. All rights reserved.
This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
Code distributed by Google as part of the polymer project is also
subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
*/
/**
@license
Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
This code may only be used under the BSD style license found at
http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
part of the polymer project is also subject to an additional IP rights grant
found at http://polymer.github.io/PATENTS.txt
*/
/**
@license
Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
Code distributed by Google as part of the polymer project is also
subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
*/
/**
@license
Copyright (c) 2019 The Polymer Project Authors. All rights reserved.
This code may only be used under the BSD style license found at
http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
part of the polymer project is also subject to an additional IP rights grant
found at http://polymer.github.io/PATENTS.txt
*/
/**
@license
Copyright (c) 2019 The Polymer Project Authors. All rights reserved.
This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
Code distributed by Google as part of the polymer project is also
subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
*/

(()=>{var Iie=Object.create,kA=Object.defineProperty,Aie=Object.getOwnPropertyDescriptor,Rie=Object.getOwnPropertyNames,Pie=Object.getPrototypeOf,Oie=Object.prototype.hasOwnProperty,GV=(n,t)=>()=>(t||n((t={exports:{}}).exports,t),t.exports),FA=(n,t)=>{for(var e in t)kA(n,e,{get:t[e],enumerable:!0})},WV=(n,t,e)=>(e=null!=n?Iie(Pie(n)):{},((n,t,e,i)=>{if(t&&"object"==typeof t||"function"==typeof t)for(let r of Rie(t))!Oie.call(n,r)&&undefined!==r&&kA(n,r,{get:()=>t[r],enumerable:!(i=Aie(t,r))||i.enumerable});return n})(!t&&n&&n.__esModule?e:kA(e,"default",{value:n,enumerable:!0}),n)),I4=GV((JUe,_C)=>{var r4,o4,s4,a4,l4,c4,d4,u4,p4,f4,m4,h4,g4,hC,QA,_4,b4,v4,Rm,y4,x4,C4,M4,w4,S4,E4,T4,D4,gC;!function(n){var t="object"==typeof global?global:"object"==typeof self?self:"object"==typeof this?this:{};function e(i,r){return i!==t&&("function"==typeof Object.create?Object.defineProperty(i,"__esModule",{value:!0}):i.__esModule=!0),function(o,s){return i[o]=r?r(o,s):s}}"function"==typeof define&&define.amd?define("tslib",["exports"],function(i){n(e(t,e(i)))}):n("object"==typeof _C&&"object"==typeof _C.exports?e(t,e(_C.exports)):e(t))}(function(n){var t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(i,r){i.__proto__=r}||function(i,r){for(var o in r)Object.prototype.hasOwnProperty.call(r,o)&&(i[o]=r[o])};r4=function(i,r){if("function"!=typeof r&&null!==r)throw new TypeError("Class extends value "+String(r)+" is not a constructor or null");function o(){this.constructor=i}t(i,r),i.prototype=null===r?Object.create(r):(o.prototype=r.prototype,new o)},o4=Object.assign||function(i){for(var r,o=1,s=arguments.length;o<s;o++)for(var a in r=arguments[o])Object.prototype.hasOwnProperty.call(r,a)&&(i[a]=r[a]);return i},s4=function(i,r){var o={};for(var s in i)Object.prototype.hasOwnProperty.call(i,s)&&r.indexOf(s)<0&&(o[s]=i[s]);if(null!=i&&"function"==typeof Object.getOwnPropertySymbols){var a=0;for(s=Object.getOwnPropertySymbols(i);a<s.length;a++)r.indexOf(s[a])<0&&Object.prototype.propertyIsEnumerable.call(i,s[a])&&(o[s[a]]=i[s[a]])}return o},a4=function(i,r,o,s){var c,a=arguments.length,l=a<3?r:null===s?s=Object.getOwnPropertyDescriptor(r,o):s;if("object"==typeof Reflect&&"function"==typeof Reflect.decorate)l=Reflect.decorate(i,r,o,s);else for(var d=i.length-1;d>=0;d--)(c=i[d])&&(l=(a<3?c(l):a>3?c(r,o,l):c(r,o))||l);return a>3&&l&&Object.defineProperty(r,o,l),l},l4=function(i,r){return function(o,s){r(o,s,i)}},c4=function(i,r,o,s,a,l){function c(A){if(void 0!==A&&"function"!=typeof A)throw new TypeError("Function expected");return A}for(var m,d=s.kind,u="getter"===d?"get":"setter"===d?"set":"value",p=!r&&i?s.static?i:i.prototype:null,f=r||(p?Object.getOwnPropertyDescriptor(p,s.name):{}),b=!1,M=o.length-1;M>=0;M--){var y={};for(var x in s)y[x]="access"===x?{}:s[x];for(var x in s.access)y.access[x]=s.access[x];y.addInitializer=function(A){if(b)throw new TypeError("Cannot add initializers after decoration has completed");l.push(c(A||null))};var R=(0,o[M])("accessor"===d?{get:f.get,set:f.set}:f[u],y);if("accessor"===d){if(void 0===R)continue;if(null===R||"object"!=typeof R)throw new TypeError("Object expected");(m=c(R.get))&&(f.get=m),(m=c(R.set))&&(f.set=m),(m=c(R.init))&&a.push(m)}else(m=c(R))&&("field"===d?a.push(m):f[u]=m)}p&&Object.defineProperty(p,s.name,f),b=!0},d4=function(i,r,o){for(var s=arguments.length>2,a=0;a<r.length;a++)o=s?r[a].call(i,o):r[a].call(i);return s?o:void 0},u4=function(i){return"symbol"==typeof i?i:"".concat(i)},p4=function(i,r,o){return"symbol"==typeof r&&(r=r.description?"[".concat(r.description,"]"):""),Object.defineProperty(i,"name",{configurable:!0,value:o?"".concat(o," ",r):r})},f4=function(i,r){if("object"==typeof Reflect&&"function"==typeof Reflect.metadata)return Reflect.metadata(i,r)},m4=function(i,r,o,s){return new(o||(o=Promise))(function(l,c){function d(f){try{p(s.next(f))}catch(m){c(m)}}function u(f){try{p(s.throw(f))}catch(m){c(m)}}function p(f){f.done?l(f.value):function(l){return l instanceof o?l:new o(function(c){c(l)})}(f.value).then(d,u)}p((s=s.apply(i,r||[])).next())})},h4=function(i,r){var s,a,l,c,o={label:0,sent:function(){if(1&l[0])throw l[1];return l[1]},trys:[],ops:[]};return c={next:d(0),throw:d(1),return:d(2)},"function"==typeof Symbol&&(c[Symbol.iterator]=function(){return this}),c;function d(p){return function(f){return function(p){if(s)throw new TypeError("Generator is already executing.");for(;c&&(c=0,p[0]&&(o=0)),o;)try{if(s=1,a&&(l=2&p[0]?a.return:p[0]?a.throw||((l=a.return)&&l.call(a),0):a.next)&&!(l=l.call(a,p[1])).done)return l;switch(a=0,l&&(p=[2&p[0],l.value]),p[0]){case 0:case 1:l=p;break;case 4:return o.label++,{value:p[1],done:!1};case 5:o.label++,a=p[1],p=[0];continue;case 7:p=o.ops.pop(),o.trys.pop();continue;default:if(!(l=(l=o.trys).length>0&&l[l.length-1])&&(6===p[0]||2===p[0])){o=0;continue}if(3===p[0]&&(!l||p[1]>l[0]&&p[1]<l[3])){o.label=p[1];break}if(6===p[0]&&o.label<l[1]){o.label=l[1],l=p;break}if(l&&o.label<l[2]){o.label=l[2],o.ops.push(p);break}l[2]&&o.ops.pop(),o.trys.pop();continue}p=r.call(i,o)}catch(f){p=[6,f],a=0}finally{s=l=0}if(5&p[0])throw p[1];return{value:p[0]?p[1]:void 0,done:!0}}([p,f])}}},g4=function(i,r){for(var o in i)"default"!==o&&!Object.prototype.hasOwnProperty.call(r,o)&&gC(r,i,o)},gC=Object.create?function(i,r,o,s){void 0===s&&(s=o);var a=Object.getOwnPropertyDescriptor(r,o);(!a||("get"in a?!r.__esModule:a.writable||a.configurable))&&(a={enumerable:!0,get:function(){return r[o]}}),Object.defineProperty(i,s,a)}:function(i,r,o,s){void 0===s&&(s=o),i[s]=r[o]},hC=function(i){var r="function"==typeof Symbol&&Symbol.iterator,o=r&&i[r],s=0;if(o)return o.call(i);if(i&&"number"==typeof i.length)return{next:function(){return i&&s>=i.length&&(i=void 0),{value:i&&i[s++],done:!i}}};throw new TypeError(r?"Object is not iterable.":"Symbol.iterator is not defined.")},QA=function(i,r){var o="function"==typeof Symbol&&i[Symbol.iterator];if(!o)return i;var a,c,s=o.call(i),l=[];try{for(;(void 0===r||r-- >0)&&!(a=s.next()).done;)l.push(a.value)}catch(d){c={error:d}}finally{try{a&&!a.done&&(o=s.return)&&o.call(s)}finally{if(c)throw c.error}}return l},_4=function(){for(var i=[],r=0;r<arguments.length;r++)i=i.concat(QA(arguments[r]));return i},b4=function(){for(var i=0,r=0,o=arguments.length;r<o;r++)i+=arguments[r].length;var s=Array(i),a=0;for(r=0;r<o;r++)for(var l=arguments[r],c=0,d=l.length;c<d;c++,a++)s[a]=l[c];return s},v4=function(i,r,o){if(o||2===arguments.length)for(var l,s=0,a=r.length;s<a;s++)(l||!(s in r))&&(l||(l=Array.prototype.slice.call(r,0,s)),l[s]=r[s]);return i.concat(l||Array.prototype.slice.call(r))},Rm=function(i){return this instanceof Rm?(this.v=i,this):new Rm(i)},y4=function(i,r,o){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var a,s=o.apply(i,r||[]),l=[];return a={},c("next"),c("throw"),c("return"),a[Symbol.asyncIterator]=function(){return this},a;function c(b){s[b]&&(a[b]=function(M){return new Promise(function(y,x){l.push([b,M,y,x])>1||d(b,M)})})}function d(b,M){try{!function(b){b.value instanceof Rm?Promise.resolve(b.value.v).then(p,f):m(l[0][2],b)}(s[b](M))}catch(y){m(l[0][3],y)}}function p(b){d("next",b)}function f(b){d("throw",b)}function m(b,M){b(M),l.shift(),l.length&&d(l[0][0],l[0][1])}},x4=function(i){var r,o;return r={},s("next"),s("throw",function(a){throw a}),s("return"),r[Symbol.iterator]=function(){return this},r;function s(a,l){r[a]=i[a]?function(c){return(o=!o)?{value:Rm(i[a](c)),done:!1}:l?l(c):c}:l}},C4=function(i){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var o,r=i[Symbol.asyncIterator];return r?r.call(i):(i=hC(i),o={},s("next"),s("throw"),s("return"),o[Symbol.asyncIterator]=function(){return this},o);function s(l){o[l]=i[l]&&function(c){return new Promise(function(d,u){!function(l,c,d,u){Promise.resolve(u).then(function(p){l({value:p,done:d})},c)}(d,u,(c=i[l](c)).done,c.value)})}}},M4=function(i,r){return Object.defineProperty?Object.defineProperty(i,"raw",{value:r}):i.raw=r,i};var e=Object.create?function(i,r){Object.defineProperty(i,"default",{enumerable:!0,value:r})}:function(i,r){i.default=r};w4=function(i){if(i&&i.__esModule)return i;var r={};if(null!=i)for(var o in i)"default"!==o&&Object.prototype.hasOwnProperty.call(i,o)&&gC(r,i,o);return e(r,i),r},S4=function(i){return i&&i.__esModule?i:{default:i}},E4=function(i,r,o,s){if("a"===o&&!s)throw new TypeError("Private accessor was defined without a getter");if("function"==typeof r?i!==r||!s:!r.has(i))throw new TypeError("Cannot read private member from an object whose class did not declare it");return"m"===o?s:"a"===o?s.call(i):s?s.value:r.get(i)},T4=function(i,r,o,s,a){if("m"===s)throw new TypeError("Private method is not writable");if("a"===s&&!a)throw new TypeError("Private accessor was defined without a setter");if("function"==typeof r?i!==r||!a:!r.has(i))throw new TypeError("Cannot write private member to an object whose class did not declare it");return"a"===s?a.call(i,o):a?a.value=o:r.set(i,o),o},D4=function(i,r){if(null===r||"object"!=typeof r&&"function"!=typeof r)throw new TypeError("Cannot use 'in' operator on non-object");return"function"==typeof i?r===i:i.has(r)},n("__extends",r4),n("__assign",o4),n("__rest",s4),n("__decorate",a4),n("__param",l4),n("__esDecorate",c4),n("__runInitializers",d4),n("__propKey",u4),n("__setFunctionName",p4),n("__metadata",f4),n("__awaiter",m4),n("__generator",h4),n("__exportStar",g4),n("__createBinding",gC),n("__values",hC),n("__read",QA),n("__spread",_4),n("__spreadArrays",b4),n("__spreadArray",v4),n("__await",Rm),n("__asyncGenerator",y4),n("__asyncDelegator",x4),n("__asyncValues",C4),n("__makeTemplateObject",M4),n("__importStar",w4),n("__importDefault",S4),n("__classPrivateFieldGet",E4),n("__classPrivateFieldSet",T4),n("__classPrivateFieldIn",D4)})}),iG=GV(lk=>{"use strict";var n,fu=lk&&lk.__spreadArray||function(n,t,e){if(e||2===arguments.length)for(var o,i=0,r=t.length;i<r;i++)(o||!(i in t))&&(o||(o=Array.prototype.slice.call(t,0,i)),o[i]=t[i]);return n.concat(o||Array.prototype.slice.call(t))};n=function(){!function(z){var ee=z.performance;function le(gt){ee&&ee.mark&&ee.mark(gt)}function E(gt,me){ee&&ee.measure&&ee.measure(gt,me)}le("Zone");var H=z.__Zone_symbol_prefix||"__zone_symbol__";function Y(gt){return H+gt}var J=!0===z[Y("forceDuplicateZoneCheck")];if(z.Zone){if(J||"function"!=typeof z.Zone.__symbol__)throw new Error("Zone already loaded.");return z.Zone}var se=function(){function gt(me,he){this._parent=me,this._name=he?he.name||"unnamed":"<root>",this._properties=he&&he.properties||{},this._zoneDelegate=new et(this,this._parent&&this._parent._zoneDelegate,he)}return gt.assertZonePatched=function(){if(z.Promise!==kn.ZoneAwarePromise)throw new Error("Zone.js has detected that ZoneAwarePromise `(window|global).Promise` has been overwritten.\nMost likely cause is that a Promise polyfill has been loaded after Zone.js (Polyfilling Promise api is not necessary when zone.js is loaded. If you must load one, do so before loading zone.js.)")},Object.defineProperty(gt,"root",{get:function(){for(var me=gt.current;me.parent;)me=me.parent;return me},enumerable:!1,configurable:!0}),Object.defineProperty(gt,"current",{get:function(){return rr.zone},enumerable:!1,configurable:!0}),Object.defineProperty(gt,"currentTask",{get:function(){return ys},enumerable:!1,configurable:!0}),gt.__load_patch=function(me,he,Re){if(void 0===Re&&(Re=!1),kn.hasOwnProperty(me)){if(!Re&&J)throw Error("Already loaded patch: "+me)}else if(!z["__Zone_disable_"+me]){var Sn="Zone:"+me;le(Sn),kn[me]=he(z,gt,pr),E(Sn,Sn)}},Object.defineProperty(gt.prototype,"parent",{get:function(){return this._parent},enumerable:!1,configurable:!0}),Object.defineProperty(gt.prototype,"name",{get:function(){return this._name},enumerable:!1,configurable:!0}),gt.prototype.get=function(me){var he=this.getZoneWith(me);if(he)return he._properties[me]},gt.prototype.getZoneWith=function(me){for(var he=this;he;){if(he._properties.hasOwnProperty(me))return he;he=he._parent}return null},gt.prototype.fork=function(me){if(!me)throw new Error("ZoneSpec required!");return this._zoneDelegate.fork(this,me)},gt.prototype.wrap=function(me,he){if("function"!=typeof me)throw new Error("Expecting function got: "+me);var Re=this._zoneDelegate.intercept(this,me,he),Sn=this;return function(){return Sn.runGuarded(Re,this,arguments,he)}},gt.prototype.run=function(me,he,Re,Sn){rr={parent:rr,zone:this};try{return this._zoneDelegate.invoke(this,me,he,Re,Sn)}finally{rr=rr.parent}},gt.prototype.runGuarded=function(me,he,Re,Sn){void 0===he&&(he=null),rr={parent:rr,zone:this};try{try{return this._zoneDelegate.invoke(this,me,he,Re,Sn)}catch(mr){if(this._zoneDelegate.handleError(this,mr))throw mr}}finally{rr=rr.parent}},gt.prototype.runTask=function(me,he,Re){if(me.zone!=this)throw new Error("A task can only be run in the zone of creation! (Creation: "+(me.zone||Et).name+"; Execution: "+this.name+")");if(me.state!==pi||me.type!==fi&&me.type!==On){var Sn=me.state!=Wn;Sn&&me._transitionTo(Wn,Vn),me.runCount++;var mr=ys;ys=me,rr={parent:rr,zone:this};try{me.type==On&&me.data&&!me.data.isPeriodic&&(me.cancelFn=void 0);try{return this._zoneDelegate.invokeTask(this,me,he,Re)}catch(ul){if(this._zoneDelegate.handleError(this,ul))throw ul}}finally{me.state!==pi&&me.state!==Ni&&(me.type==fi||me.data&&me.data.isPeriodic?Sn&&me._transitionTo(Vn,Wn):(me.runCount=0,this._updateTaskCount(me,-1),Sn&&me._transitionTo(pi,Wn,pi))),rr=rr.parent,ys=mr}}},gt.prototype.scheduleTask=function(me){if(me.zone&&me.zone!==this)for(var he=this;he;){if(he===me.zone)throw Error("can not reschedule task to ".concat(this.name," which is descendants of the original zone ").concat(me.zone.name));he=he.parent}me._transitionTo(Qn,pi);var Re=[];me._zoneDelegates=Re,me._zone=this;try{me=this._zoneDelegate.scheduleTask(this,me)}catch(Sn){throw me._transitionTo(Ni,Qn,pi),this._zoneDelegate.handleError(this,Sn),Sn}return me._zoneDelegates===Re&&this._updateTaskCount(me,1),me.state==Qn&&me._transitionTo(Vn,Qn),me},gt.prototype.scheduleMicroTask=function(me,he,Re,Sn){return this.scheduleTask(new qe(vn,me,he,Re,Sn,void 0))},gt.prototype.scheduleMacroTask=function(me,he,Re,Sn,mr){return this.scheduleTask(new qe(On,me,he,Re,Sn,mr))},gt.prototype.scheduleEventTask=function(me,he,Re,Sn,mr){return this.scheduleTask(new qe(fi,me,he,Re,Sn,mr))},gt.prototype.cancelTask=function(me){if(me.zone!=this)throw new Error("A task can only be cancelled in the zone of creation! (Creation: "+(me.zone||Et).name+"; Execution: "+this.name+")");if(me.state===Vn||me.state===Wn){me._transitionTo(Ut,Vn,Wn);try{this._zoneDelegate.cancelTask(this,me)}catch(he){throw me._transitionTo(Ni,Ut),this._zoneDelegate.handleError(this,he),he}return this._updateTaskCount(me,-1),me._transitionTo(pi,Ut),me.runCount=0,me}},gt.prototype._updateTaskCount=function(me,he){var Re=me._zoneDelegates;-1==he&&(me._zoneDelegates=null);for(var Sn=0;Sn<Re.length;Sn++)Re[Sn]._updateTaskCount(me.type,he)},gt}();se.__symbol__=Y;var Gi,ze={name:"",onHasTask:function(gt,me,he,Re){return gt.hasTask(he,Re)},onScheduleTask:function(gt,me,he,Re){return gt.scheduleTask(he,Re)},onInvokeTask:function(gt,me,he,Re,Sn,mr){return gt.invokeTask(he,Re,Sn,mr)},onCancelTask:function(gt,me,he,Re){return gt.cancelTask(he,Re)}},et=function(){function gt(me,he,Re){this._taskCounts={microTask:0,macroTask:0,eventTask:0},this.zone=me,this._parentDelegate=he,this._forkZS=Re&&(Re&&Re.onFork?Re:he._forkZS),this._forkDlgt=Re&&(Re.onFork?he:he._forkDlgt),this._forkCurrZone=Re&&(Re.onFork?this.zone:he._forkCurrZone),this._interceptZS=Re&&(Re.onIntercept?Re:he._interceptZS),this._interceptDlgt=Re&&(Re.onIntercept?he:he._interceptDlgt),this._interceptCurrZone=Re&&(Re.onIntercept?this.zone:he._interceptCurrZone),this._invokeZS=Re&&(Re.onInvoke?Re:he._invokeZS),this._invokeDlgt=Re&&(Re.onInvoke?he:he._invokeDlgt),this._invokeCurrZone=Re&&(Re.onInvoke?this.zone:he._invokeCurrZone),this._handleErrorZS=Re&&(Re.onHandleError?Re:he._handleErrorZS),this._handleErrorDlgt=Re&&(Re.onHandleError?he:he._handleErrorDlgt),this._handleErrorCurrZone=Re&&(Re.onHandleError?this.zone:he._handleErrorCurrZone),this._scheduleTaskZS=Re&&(Re.onScheduleTask?Re:he._scheduleTaskZS),this._scheduleTaskDlgt=Re&&(Re.onScheduleTask?he:he._scheduleTaskDlgt),this._scheduleTaskCurrZone=Re&&(Re.onScheduleTask?this.zone:he._scheduleTaskCurrZone),this._invokeTaskZS=Re&&(Re.onInvokeTask?Re:he._invokeTaskZS),this._invokeTaskDlgt=Re&&(Re.onInvokeTask?he:he._invokeTaskDlgt),this._invokeTaskCurrZone=Re&&(Re.onInvokeTask?this.zone:he._invokeTaskCurrZone),this._cancelTaskZS=Re&&(Re.onCancelTask?Re:he._cancelTaskZS),this._cancelTaskDlgt=Re&&(Re.onCancelTask?he:he._cancelTaskDlgt),this._cancelTaskCurrZone=Re&&(Re.onCancelTask?this.zone:he._cancelTaskCurrZone),this._hasTaskZS=null,this._hasTaskDlgt=null,this._hasTaskDlgtOwner=null,this._hasTaskCurrZone=null;var Sn=Re&&Re.onHasTask;(Sn||he&&he._hasTaskZS)&&(this._hasTaskZS=Sn?Re:ze,this._hasTaskDlgt=he,this._hasTaskDlgtOwner=this,this._hasTaskCurrZone=me,Re.onScheduleTask||(this._scheduleTaskZS=ze,this._scheduleTaskDlgt=he,this._scheduleTaskCurrZone=this.zone),Re.onInvokeTask||(this._invokeTaskZS=ze,this._invokeTaskDlgt=he,this._invokeTaskCurrZone=this.zone),Re.onCancelTask||(this._cancelTaskZS=ze,this._cancelTaskDlgt=he,this._cancelTaskCurrZone=this.zone))}return gt.prototype.fork=function(me,he){return this._forkZS?this._forkZS.onFork(this._forkDlgt,this.zone,me,he):new se(me,he)},gt.prototype.intercept=function(me,he,Re){return this._interceptZS?this._interceptZS.onIntercept(this._interceptDlgt,this._interceptCurrZone,me,he,Re):he},gt.prototype.invoke=function(me,he,Re,Sn,mr){return this._invokeZS?this._invokeZS.onInvoke(this._invokeDlgt,this._invokeCurrZone,me,he,Re,Sn,mr):he.apply(Re,Sn)},gt.prototype.handleError=function(me,he){return!this._handleErrorZS||this._handleErrorZS.onHandleError(this._handleErrorDlgt,this._handleErrorCurrZone,me,he)},gt.prototype.scheduleTask=function(me,he){var Re=he;if(this._scheduleTaskZS)this._hasTaskZS&&Re._zoneDelegates.push(this._hasTaskDlgtOwner),(Re=this._scheduleTaskZS.onScheduleTask(this._scheduleTaskDlgt,this._scheduleTaskCurrZone,me,he))||(Re=he);else if(he.scheduleFn)he.scheduleFn(he);else{if(he.type!=vn)throw new Error("Task is missing scheduleFn.");pn(he)}return Re},gt.prototype.invokeTask=function(me,he,Re,Sn){return this._invokeTaskZS?this._invokeTaskZS.onInvokeTask(this._invokeTaskDlgt,this._invokeTaskCurrZone,me,he,Re,Sn):he.callback.apply(Re,Sn)},gt.prototype.cancelTask=function(me,he){var Re;if(this._cancelTaskZS)Re=this._cancelTaskZS.onCancelTask(this._cancelTaskDlgt,this._cancelTaskCurrZone,me,he);else{if(!he.cancelFn)throw Error("Task is not cancelable");Re=he.cancelFn(he)}return Re},gt.prototype.hasTask=function(me,he){try{this._hasTaskZS&&this._hasTaskZS.onHasTask(this._hasTaskDlgt,this._hasTaskCurrZone,me,he)}catch(Re){this.handleError(me,Re)}},gt.prototype._updateTaskCount=function(me,he){var Re=this._taskCounts,Sn=Re[me],mr=Re[me]=Sn+he;if(mr<0)throw new Error("More tasks executed then were scheduled.");0!=Sn&&0!=mr||this.hasTask(this.zone,{microTask:Re.microTask>0,macroTask:Re.macroTask>0,eventTask:Re.eventTask>0,change:me})},gt}(),qe=function(){function gt(me,he,Re,Sn,mr,ul){if(this._zone=null,this.runCount=0,this._zoneDelegates=null,this._state="notScheduled",this.type=me,this.source=he,this.data=Sn,this.scheduleFn=mr,this.cancelFn=ul,!Re)throw new Error("callback is not defined");this.callback=Re;var tt=this;this.invoke=me===fi&&Sn&&Sn.useG?gt.invokeTask:function(){return gt.invokeTask.call(z,tt,this,arguments)}}return gt.invokeTask=function(me,he,Re){me||(me=this),Mr++;try{return me.runCount++,me.zone.runTask(me,he,Re)}finally{1==Mr&&Pn(),Mr--}},Object.defineProperty(gt.prototype,"zone",{get:function(){return this._zone},enumerable:!1,configurable:!0}),Object.defineProperty(gt.prototype,"state",{get:function(){return this._state},enumerable:!1,configurable:!0}),gt.prototype.cancelScheduleRequest=function(){this._transitionTo(pi,Qn)},gt.prototype._transitionTo=function(me,he,Re){if(this._state!==he&&this._state!==Re)throw new Error("".concat(this.type," '").concat(this.source,"': can not transition to '").concat(me,"', expecting state '").concat(he,"'").concat(Re?" or '"+Re+"'":"",", was '").concat(this._state,"'."));this._state=me,me==pi&&(this._zoneDelegates=null)},gt.prototype.toString=function(){return this.data&&typeof this.data.handleId<"u"?this.data.handleId.toString():Object.prototype.toString.call(this)},gt.prototype.toJSON=function(){return{type:this.type,state:this.state,source:this.source,zone:this.zone.name,runCount:this.runCount}},gt}(),rt=Y("setTimeout"),dt=Y("Promise"),St=Y("then"),Dt=[],cn=!1;function vi(gt){if(Gi||z[dt]&&(Gi=z[dt].resolve(0)),Gi){var me=Gi[St];me||(me=Gi.then),me.call(Gi,gt)}else z[rt](gt,0)}function pn(gt){0===Mr&&0===Dt.length&&vi(Pn),gt&&Dt.push(gt)}function Pn(){if(!cn){for(cn=!0;Dt.length;){var gt=Dt;Dt=[];for(var me=0;me<gt.length;me++){var he=gt[me];try{he.zone.runTask(he,null,null)}catch(Re){pr.onUnhandledError(Re)}}}pr.microtaskDrainDone(),cn=!1}}var Et={name:"NO ZONE"},pi="notScheduled",Qn="scheduling",Vn="scheduled",Wn="running",Ut="canceling",Ni="unknown",vn="microTask",On="macroTask",fi="eventTask",kn={},pr={symbol:Y,currentZoneFrame:function(){return rr},onUnhandledError:fr,microtaskDrainDone:fr,scheduleMicroTask:pn,showUncaughtError:function(){return!se[Y("ignoreConsoleErrorUncaughtError")]},patchEventTarget:function(){return[]},patchOnProperties:fr,patchMethod:function(){return fr},bindArguments:function(){return[]},patchThen:function(){return fr},patchMacroTask:function(){return fr},patchEventPrototype:function(){return fr},isIEOrEdge:function(){return!1},getGlobalObjects:function(){},ObjectDefineProperty:function(){return fr},ObjectGetOwnPropertyDescriptor:function(){},ObjectCreate:function(){},ArraySlice:function(){return[]},patchClass:function(){return fr},wrapWithCurrentZone:function(){return fr},filterProperties:function(){return[]},attachOriginToPatched:function(){return fr},_redefineProperty:function(){return fr},patchCallbacks:function(){return fr},nativeScheduleMicroTask:vi},rr={parent:null,zone:new se(null,null)},ys=null,Mr=0;function fr(){}E("Zone","Zone"),z.Zone=se}(typeof window<"u"&&window||typeof self<"u"&&self||global);var n=Object.getOwnPropertyDescriptor,t=Object.defineProperty,e=Object.getPrototypeOf,i=Object.create,r=Array.prototype.slice,o="addEventListener",s="removeEventListener",a=Zone.__symbol__(o),l=Zone.__symbol__(s),c="true",d="false",u=Zone.__symbol__("");function p(z,ee){return Zone.current.wrap(z,ee)}function f(z,ee,le,E,H){return Zone.current.scheduleMacroTask(z,ee,le,E,H)}var m=Zone.__symbol__,b=typeof window<"u",M=b?window:void 0,y=b&&M||"object"==typeof self&&self||global,x="removeAttribute";function R(z,ee){for(var le=z.length-1;le>=0;le--)"function"==typeof z[le]&&(z[le]=p(z[le],ee+"_"+le));return z}function V(z){return!z||!1!==z.writable&&!("function"==typeof z.get&&typeof z.set>"u")}var te=typeof WorkerGlobalScope<"u"&&self instanceof WorkerGlobalScope,K=!("nw"in y)&&typeof y.process<"u"&&"[object process]"==={}.toString.call(y.process),xe=!K&&!te&&!(!b||!M.HTMLElement),Xe=typeof y.process<"u"&&"[object process]"==={}.toString.call(y.process)&&!te&&!(!b||!M.HTMLElement),De={},D=function(z){if(z=z||y.event){var ee=De[z.type];ee||(ee=De[z.type]=m("ON_PROPERTY"+z.type));var H,le=this||z.target||y,E=le[ee];return xe&&le===M&&"error"===z.type?!0===(H=E&&E.call(this,z.message,z.filename,z.lineno,z.colno,z.error))&&z.preventDefault():null!=(H=E&&E.apply(this,arguments))&&!H&&z.preventDefault(),H}};function re(z,ee,le){var E=n(z,ee);if(!E&&le&&n(le,ee)&&(E={enumerable:!0,configurable:!0}),E&&E.configurable){var Y=m("on"+ee+"patched");if(!z.hasOwnProperty(Y)||!z[Y]){delete E.writable,delete E.value;var J=E.get,se=E.set,ze=ee.slice(2),et=De[ze];et||(et=De[ze]=m("ON_PROPERTY"+ze)),E.set=function(qe){var rt=this;!rt&&z===y&&(rt=y),rt&&("function"==typeof rt[et]&&rt.removeEventListener(ze,D),se&&se.call(rt,null),rt[et]=qe,"function"==typeof qe&&rt.addEventListener(ze,D,!1))},E.get=function(){var qe=this;if(!qe&&z===y&&(qe=y),!qe)return null;var rt=qe[et];if(rt)return rt;if(J){var dt=J.call(this);if(dt)return E.set.call(this,dt),"function"==typeof qe[x]&&qe.removeAttribute(ee),dt}return null},t(z,ee,E),z[Y]=!0}}}function ce(z,ee,le){if(ee)for(var E=0;E<ee.length;E++)re(z,"on"+ee[E],le);else{var H=[];for(var Y in z)"on"==Y.slice(0,2)&&H.push(Y);for(var J=0;J<H.length;J++)re(z,H[J],le)}}var fe=m("originalInstance");function be(z){var ee=y[z];if(ee){y[m(z)]=ee,y[z]=function(){var H=R(arguments,z);switch(H.length){case 0:this[fe]=new ee;break;case 1:this[fe]=new ee(H[0]);break;case 2:this[fe]=new ee(H[0],H[1]);break;case 3:this[fe]=new ee(H[0],H[1],H[2]);break;case 4:this[fe]=new ee(H[0],H[1],H[2],H[3]);break;default:throw new Error("Arg list too long.")}},pe(y[z],ee);var E,le=new ee(function(){});for(E in le)"XMLHttpRequest"===z&&"responseBlob"===E||function(H){"function"==typeof le[H]?y[z].prototype[H]=function(){return this[fe][H].apply(this[fe],arguments)}:t(y[z].prototype,H,{set:function(Y){"function"==typeof Y?(this[fe][H]=p(Y,z+"."+H),pe(this[fe][H],Y)):this[fe][H]=Y},get:function(){return this[fe][H]}})}(E);for(E in ee)"prototype"!==E&&ee.hasOwnProperty(E)&&(y[z][E]=ee[E])}}function ne(z,ee,le){for(var E=z;E&&!E.hasOwnProperty(ee);)E=e(E);!E&&z[ee]&&(E=z);var H=m(ee),Y=null;if(E&&(!(Y=E[H])||!E.hasOwnProperty(H))&&(Y=E[H]=E[ee],V(E&&n(E,ee)))){var se=le(Y,H,ee);E[ee]=function(){return se(this,arguments)},pe(E[ee],Y)}return Y}function de(z,ee,le){var E=null;function H(Y){var J=Y.data;return J.args[J.cbIdx]=function(){Y.invoke.apply(this,arguments)},E.apply(J.target,J.args),Y}E=ne(z,ee,function(Y){return function(J,se){var ze=le(J,se);return ze.cbIdx>=0&&"function"==typeof se[ze.cbIdx]?f(ze.name,se[ze.cbIdx],ze,H):Y.apply(J,se)}})}function pe(z,ee){z[m("OriginalDelegate")]=ee}var je=!1,Ce=!1;function lt(){if(je)return Ce;je=!0;try{var z=M.navigator.userAgent;(-1!==z.indexOf("MSIE ")||-1!==z.indexOf("Trident/")||-1!==z.indexOf("Edge/"))&&(Ce=!0)}catch{}return Ce}Zone.__load_patch("ZoneAwarePromise",function(z,ee,le){var E=Object.getOwnPropertyDescriptor,H=Object.defineProperty,J=le.symbol,se=[],ze=!0===z[J("DISABLE_WRAPPING_UNCAUGHT_PROMISE_REJECTION")],et=J("Promise"),qe=J("then"),rt="__creationTrace__";le.onUnhandledError=function(tt){if(le.showUncaughtError()){var At=tt&&tt.rejection;At?console.error("Unhandled Promise rejection:",At instanceof Error?At.message:At,"; Zone:",tt.zone.name,"; Task:",tt.task&&tt.task.source,"; Value:",At,At instanceof Error?At.stack:void 0):console.error(tt)}},le.microtaskDrainDone=function(){for(var tt=function(){var At=se.shift();try{At.zone.runGuarded(function(){throw At.throwOriginal?At.rejection:At})}catch(Ct){!function(tt){le.onUnhandledError(tt);try{var At=ee[dt];"function"==typeof At&&At.call(this,tt)}catch{}}(Ct)}};se.length;)tt()};var dt=J("unhandledPromiseRejectionHandler");function Dt(tt){return tt&&tt.then}function cn(tt){return tt}function Gi(tt){return he.reject(tt)}var vi=J("state"),pn=J("value"),Pn=J("finally"),Et=J("parentPromiseValue"),pi=J("parentPromiseState"),Qn="Promise.then",Vn=null,Wn=!0,Ut=!1,Ni=0;function vn(tt,At){return function(Ct){try{pr(tt,At,Ct)}catch(Je){pr(tt,!1,Je)}}}var On=function(){var tt=!1;return function(Ct){return function(){tt||(tt=!0,Ct.apply(null,arguments))}}},fi="Promise resolved with itself",kn=J("currentTaskTrace");function pr(tt,At,Ct){var Je=On();if(tt===Ct)throw new TypeError(fi);if(tt[vi]===Vn){var Zt=null;try{("object"==typeof Ct||"function"==typeof Ct)&&(Zt=Ct&&Ct.then)}catch(ni){return Je(function(){pr(tt,!1,ni)})(),tt}if(At!==Ut&&Ct instanceof he&&Ct.hasOwnProperty(vi)&&Ct.hasOwnProperty(pn)&&Ct[vi]!==Vn)ys(Ct),pr(tt,Ct[vi],Ct[pn]);else if(At!==Ut&&"function"==typeof Zt)try{Zt.call(Ct,Je(vn(tt,At)),Je(vn(tt,!1)))}catch(ni){Je(function(){pr(tt,!1,ni)})()}else{tt[vi]=At;var Bn=tt[pn];if(tt[pn]=Ct,tt[Pn]===Pn&&At===Wn&&(tt[vi]=tt[pi],tt[pn]=tt[Et]),At===Ut&&Ct instanceof Error){var Rn=ee.currentTask&&ee.currentTask.data&&ee.currentTask.data[rt];Rn&&H(Ct,kn,{configurable:!0,enumerable:!1,writable:!0,value:Rn})}for(var Zn=0;Zn<Bn.length;)Mr(tt,Bn[Zn++],Bn[Zn++],Bn[Zn++],Bn[Zn++]);if(0==Bn.length&&At==Ut){tt[vi]=Ni;var Kn=Ct;try{throw new Error("Uncaught (in promise): "+function(tt){return tt&&tt.toString===Object.prototype.toString?(tt.constructor&&tt.constructor.name||"")+": "+JSON.stringify(tt):tt?tt.toString():Object.prototype.toString.call(tt)}(Ct)+(Ct&&Ct.stack?"\n"+Ct.stack:""))}catch(ni){Kn=ni}ze&&(Kn.throwOriginal=!0),Kn.rejection=Ct,Kn.promise=tt,Kn.zone=ee.current,Kn.task=ee.currentTask,se.push(Kn),le.scheduleMicroTask()}}}return tt}var rr=J("rejectionHandledHandler");function ys(tt){if(tt[vi]===Ni){try{var At=ee[rr];At&&"function"==typeof At&&At.call(this,{rejection:tt[pn],promise:tt})}catch{}tt[vi]=Ut;for(var Ct=0;Ct<se.length;Ct++)tt===se[Ct].promise&&se.splice(Ct,1)}}function Mr(tt,At,Ct,Je,Zt){ys(tt);var Bn=tt[vi],Rn=Bn?"function"==typeof Je?Je:cn:"function"==typeof Zt?Zt:Gi;At.scheduleMicroTask(Qn,function(){try{var Zn=tt[pn],Kn=!!Ct&&Pn===Ct[Pn];Kn&&(Ct[Et]=Zn,Ct[pi]=Bn);var ni=At.run(Rn,void 0,Kn&&Rn!==Gi&&Rn!==cn?[]:[Zn]);pr(Ct,!0,ni)}catch(yi){pr(Ct,!1,yi)}},Ct)}var gt=function(){},me=z.AggregateError,he=function(){function tt(At){var Ct=this;if(!(Ct instanceof tt))throw new Error("Must be an instanceof Promise.");Ct[vi]=Vn,Ct[pn]=[];try{var Je=On();At&&At(Je(vn(Ct,Wn)),Je(vn(Ct,Ut)))}catch(Zt){pr(Ct,!1,Zt)}}return tt.toString=function(){return"function ZoneAwarePromise() { [native code] }"},tt.resolve=function(At){return pr(new this(null),Wn,At)},tt.reject=function(At){return pr(new this(null),Ut,At)},tt.any=function(At){if(!At||"function"!=typeof At[Symbol.iterator])return Promise.reject(new me([],"All promises were rejected"));var Ct=[],Je=0;try{for(var Zt=0,Bn=At;Zt<Bn.length;Zt++)Je++,Ct.push(tt.resolve(Bn[Zt]))}catch{return Promise.reject(new me([],"All promises were rejected"))}if(0===Je)return Promise.reject(new me([],"All promises were rejected"));var Zn=!1,Kn=[];return new tt(function(ni,yi){for(var hr=0;hr<Ct.length;hr++)Ct[hr].then(function(Ro){Zn||(Zn=!0,ni(Ro))},function(Ro){Kn.push(Ro),0==--Je&&(Zn=!0,yi(new me(Kn,"All promises were rejected")))})})},tt.race=function(At){var Ct,Je,Zt=new this(function(yi,hr){Ct=yi,Je=hr});function Bn(yi){Ct(yi)}function Rn(yi){Je(yi)}for(var Zn=0,Kn=At;Zn<Kn.length;Zn++){var ni=Kn[Zn];Dt(ni)||(ni=this.resolve(ni)),ni.then(Bn,Rn)}return Zt},tt.all=function(At){return tt.allWithCallback(At)},tt.allSettled=function(At){return(this&&this.prototype instanceof tt?this:tt).allWithCallback(At,{thenCallback:function(Je){return{status:"fulfilled",value:Je}},errorCallback:function(Je){return{status:"rejected",reason:Je}}})},tt.allWithCallback=function(At,Ct){for(var Je,Zt,Bn=new this(function(Kr,vo){Je=Kr,Zt=vo}),Rn=2,Zn=0,Kn=[],ni=function(Kr){Dt(Kr)||(Kr=yi.resolve(Kr));var vo=Zn;try{Kr.then(function(Hr){Kn[vo]=Ct?Ct.thenCallback(Hr):Hr,0==--Rn&&Je(Kn)},function(Hr){Ct?(Kn[vo]=Ct.errorCallback(Hr),0==--Rn&&Je(Kn)):Zt(Hr)})}catch(Hr){Zt(Hr)}Rn++,Zn++},yi=this,hr=0,Ro=At;hr<Ro.length;hr++)ni(Ro[hr]);return 0==(Rn-=2)&&Je(Kn),Bn},Object.defineProperty(tt.prototype,Symbol.toStringTag,{get:function(){return"Promise"},enumerable:!1,configurable:!0}),Object.defineProperty(tt.prototype,Symbol.species,{get:function(){return tt},enumerable:!1,configurable:!0}),tt.prototype.then=function(At,Ct){var Je,Zt=null===(Je=this.constructor)||void 0===Je?void 0:Je[Symbol.species];(!Zt||"function"!=typeof Zt)&&(Zt=this.constructor||tt);var Bn=new Zt(gt),Rn=ee.current;return this[vi]==Vn?this[pn].push(Rn,Bn,At,Ct):Mr(this,Rn,Bn,At,Ct),Bn},tt.prototype.catch=function(At){return this.then(null,At)},tt.prototype.finally=function(At){var Ct,Je=null===(Ct=this.constructor)||void 0===Ct?void 0:Ct[Symbol.species];(!Je||"function"!=typeof Je)&&(Je=tt);var Zt=new Je(gt);Zt[Pn]=Pn;var Bn=ee.current;return this[vi]==Vn?this[pn].push(Bn,Zt,At,At):Mr(this,Bn,Zt,At,At),Zt},tt}();he.resolve=he.resolve,he.reject=he.reject,he.race=he.race,he.all=he.all;var Re=z[et]=z.Promise;z.Promise=he;var Sn=J("thenPatched");function mr(tt){var At=tt.prototype,Ct=E(At,"then");if(!Ct||!1!==Ct.writable&&Ct.configurable){var Je=At.then;At[qe]=Je,tt.prototype.then=function(Zt,Bn){var Rn=this;return new he(function(Kn,ni){Je.call(Rn,Kn,ni)}).then(Zt,Bn)},tt[Sn]=!0}}return le.patchThen=mr,Re&&(mr(Re),ne(z,"fetch",function(tt){return function(tt){return function(At,Ct){var Je=tt.apply(At,Ct);if(Je instanceof he)return Je;var Zt=Je.constructor;return Zt[Sn]||mr(Zt),Je}}(tt)})),Promise[ee.__symbol__("uncaughtPromiseErrors")]=se,he}),Zone.__load_patch("toString",function(z){var ee=Function.prototype.toString,le=m("OriginalDelegate"),E=m("Promise"),H=m("Error"),Y=function(){if("function"==typeof this){var et=this[le];if(et)return"function"==typeof et?ee.call(et):Object.prototype.toString.call(et);if(this===Promise){var qe=z[E];if(qe)return ee.call(qe)}if(this===Error){var rt=z[H];if(rt)return ee.call(rt)}}return ee.call(this)};Y[le]=ee,Function.prototype.toString=Y;var J=Object.prototype.toString;Object.prototype.toString=function(){return"function"==typeof Promise&&this instanceof Promise?"[object Promise]":J.call(this)}});var Mt=!1;if(typeof window<"u")try{var pt=Object.defineProperty({},"passive",{get:function(){Mt=!0}});window.addEventListener("test",pt,pt),window.removeEventListener("test",pt,pt)}catch{Mt=!1}var ti,ki,Fi,Z,L,Oe={useG:!0},An={},wt={},on=new RegExp("^"+u+"(\\w+)(true|false)$"),ve=m("propagationStopped");function mt(z,ee){var le=(ee?ee(z):z)+d,E=(ee?ee(z):z)+c,H=u+le,Y=u+E;An[z]={},An[z][d]=H,An[z][c]=Y}function ft(z,ee,le,E){var H=E&&E.add||o,Y=E&&E.rm||s,J=E&&E.listeners||"eventListeners",se=E&&E.rmAll||"removeAllListeners",ze=m(H),et="."+H+":",qe="prependListener",rt="."+qe+":",dt=function(Pn,Et,pi){if(!Pn.isRemoved){var Vn,Qn=Pn.callback;"object"==typeof Qn&&Qn.handleEvent&&(Pn.callback=function(Ni){return Qn.handleEvent(Ni)},Pn.originalDelegate=Qn);try{Pn.invoke(Pn,Et,[pi])}catch(Ni){Vn=Ni}var Wn=Pn.options;return Wn&&"object"==typeof Wn&&Wn.once&&Et[Y].call(Et,pi.type,Pn.originalDelegate?Pn.originalDelegate:Pn.callback,Wn),Vn}};function St(Pn,Et,pi){if(Et=Et||z.event){var Qn=Pn||Et.target||z,Vn=Qn[An[Et.type][pi?c:d]];if(Vn){var Wn=[];if(1===Vn.length)(Ut=dt(Vn[0],Qn,Et))&&Wn.push(Ut);else for(var Ni=Vn.slice(),vn=0;vn<Ni.length&&(!Et||!0!==Et[ve]);vn++){var Ut;(Ut=dt(Ni[vn],Qn,Et))&&Wn.push(Ut)}if(1===Wn.length)throw Wn[0];var On=function(fi){var kn=Wn[fi];ee.nativeScheduleMicroTask(function(){throw kn})};for(vn=0;vn<Wn.length;vn++)On(vn)}}}var Dt=function(Pn){return St(this,Pn,!1)},cn=function(Pn){return St(this,Pn,!0)};function Gi(Pn,Et){if(!Pn)return!1;var pi=!0;Et&&void 0!==Et.useG&&(pi=Et.useG);var Qn=Et&&Et.vh,Vn=!0;Et&&void 0!==Et.chkDup&&(Vn=Et.chkDup);var Wn=!1;Et&&void 0!==Et.rt&&(Wn=Et.rt);for(var Ut=Pn;Ut&&!Ut.hasOwnProperty(H);)Ut=e(Ut);if(!Ut&&Pn[H]&&(Ut=Pn),!Ut||Ut[ze])return!1;var rr,Ni=Et&&Et.eventNameToString,vn={},On=Ut[ze]=Ut[H],fi=Ut[m(Y)]=Ut[Y],kn=Ut[m(J)]=Ut[J],pr=Ut[m(se)]=Ut[se];Et&&Et.prepend&&(rr=Ut[m(Et.prepend)]=Ut[Et.prepend]);var Re=pi?function(Je){if(!vn.isExisting)return On.call(vn.target,vn.eventName,vn.capture?cn:Dt,vn.options)}:function(Je){return On.call(vn.target,vn.eventName,Je.invoke,vn.options)},Sn=pi?function(Je){if(!Je.isRemoved){var Zt=An[Je.eventName],Bn=void 0;Zt&&(Bn=Zt[Je.capture?c:d]);var Rn=Bn&&Je.target[Bn];if(Rn)for(var Zn=0;Zn<Rn.length;Zn++)if(Rn[Zn]===Je){Rn.splice(Zn,1),Je.isRemoved=!0,0===Rn.length&&(Je.allRemoved=!0,Je.target[Bn]=null);break}}if(Je.allRemoved)return fi.call(Je.target,Je.eventName,Je.capture?cn:Dt,Je.options)}:function(Je){return fi.call(Je.target,Je.eventName,Je.invoke,Je.options)},ul=Et&&Et.diff?Et.diff:function(Je,Zt){var Bn=typeof Zt;return"function"===Bn&&Je.callback===Zt||"object"===Bn&&Je.originalDelegate===Zt},tt=Zone[m("UNPATCHED_EVENTS")],At=z[m("PASSIVE_EVENTS")],Ct=function(Je,Zt,Bn,Rn,Zn,Kn){return void 0===Zn&&(Zn=!1),void 0===Kn&&(Kn=!1),function(){var ni=this||z,yi=arguments[0];Et&&Et.transferEventName&&(yi=Et.transferEventName(yi));var hr=arguments[1];if(!hr)return Je.apply(this,arguments);if(K&&"uncaughtException"===yi)return Je.apply(this,arguments);var Ro=!1;if("function"!=typeof hr){if(!hr.handleEvent)return Je.apply(this,arguments);Ro=!0}if(!Qn||Qn(Je,hr,ni,arguments)){var Kc=Mt&&!!At&&-1!==At.indexOf(yi),Kr=function(Je,Zt){return!Mt&&"object"==typeof Je&&Je?!!Je.capture:Mt&&Zt?"boolean"==typeof Je?{capture:Je,passive:!0}:Je?"object"==typeof Je&&!1!==Je.passive?Object.assign(Object.assign({},Je),{passive:!0}):Je:{passive:!0}:Je}(arguments[2],Kc);if(tt)for(var vo=0;vo<tt.length;vo++)if(yi===tt[vo])return Kc?Je.call(ni,yi,hr,Kr):Je.apply(this,arguments);var Hr=!!Kr&&("boolean"==typeof Kr||Kr.capture),Mm=!(!Kr||"object"!=typeof Kr)&&Kr.once,Die=Zone.current,OA=An[yi];OA||(mt(yi,Ni),OA=An[yi]);var HV=OA[Hr?c:d],wm=ni[HV],zV=!1;if(wm){if(zV=!0,Vn)for(vo=0;vo<wm.length;vo++)if(ul(wm[vo],hr))return}else wm=ni[HV]=[];var tC,UV=ni.constructor.name,jV=wt[UV];jV&&(tC=jV[yi]),tC||(tC=UV+Zt+(Ni?Ni(yi):yi)),vn.options=Kr,Mm&&(vn.options.once=!1),vn.target=ni,vn.capture=Hr,vn.eventName=yi,vn.isExisting=zV;var C_=pi?Oe:void 0;C_&&(C_.taskData=vn);var Qd=Die.scheduleEventTask(tC,hr,C_,Bn,Rn);if(vn.target=null,C_&&(C_.taskData=null),Mm&&(Kr.once=!0),!Mt&&"boolean"==typeof Qd.options||(Qd.options=Kr),Qd.target=ni,Qd.capture=Hr,Qd.eventName=yi,Ro&&(Qd.originalDelegate=hr),Kn?wm.unshift(Qd):wm.push(Qd),Zn)return ni}}};return Ut[H]=Ct(On,et,Re,Sn,Wn),rr&&(Ut[qe]=Ct(rr,rt,function(Je){return rr.call(vn.target,vn.eventName,Je.invoke,vn.options)},Sn,Wn,!0)),Ut[Y]=function(){var Je=this||z,Zt=arguments[0];Et&&Et.transferEventName&&(Zt=Et.transferEventName(Zt));var Bn=arguments[2],Rn=!!Bn&&("boolean"==typeof Bn||Bn.capture),Zn=arguments[1];if(!Zn)return fi.apply(this,arguments);if(!Qn||Qn(fi,Zn,Je,arguments)){var ni,Kn=An[Zt];Kn&&(ni=Kn[Rn?c:d]);var yi=ni&&Je[ni];if(yi)for(var hr=0;hr<yi.length;hr++){var Ro=yi[hr];if(ul(Ro,Zn))return yi.splice(hr,1),Ro.isRemoved=!0,0===yi.length&&(Ro.allRemoved=!0,Je[ni]=null,"string"==typeof Zt)&&(Je[u+"ON_PROPERTY"+Zt]=null),Ro.zone.cancelTask(Ro),Wn?Je:void 0}return fi.apply(this,arguments)}},Ut[J]=function(){var Je=this||z,Zt=arguments[0];Et&&Et.transferEventName&&(Zt=Et.transferEventName(Zt));for(var Bn=[],Rn=oe(Je,Ni?Ni(Zt):Zt),Zn=0;Zn<Rn.length;Zn++){var Kn=Rn[Zn];Bn.push(Kn.originalDelegate?Kn.originalDelegate:Kn.callback)}return Bn},Ut[se]=function(){var Je=this||z,Zt=arguments[0];if(Zt){Et&&Et.transferEventName&&(Zt=Et.transferEventName(Zt));var yi=An[Zt];if(yi){var Kc=Je[yi[d]],Kr=Je[yi[c]];if(Kc)for(var vo=Kc.slice(),Rn=0;Rn<vo.length;Rn++)this[Y].call(this,Zt,(Hr=vo[Rn]).originalDelegate?Hr.originalDelegate:Hr.callback,Hr.options);if(Kr)for(vo=Kr.slice(),Rn=0;Rn<vo.length;Rn++){var Hr;this[Y].call(this,Zt,(Hr=vo[Rn]).originalDelegate?Hr.originalDelegate:Hr.callback,Hr.options)}}}else{var Bn=Object.keys(Je);for(Rn=0;Rn<Bn.length;Rn++){var Kn=on.exec(Bn[Rn]),ni=Kn&&Kn[1];ni&&"removeListener"!==ni&&this[se].call(this,ni)}this[se].call(this,"removeListener")}if(Wn)return this},pe(Ut[H],On),pe(Ut[Y],fi),pr&&pe(Ut[se],pr),kn&&pe(Ut[J],kn),!0}for(var vi=[],pn=0;pn<le.length;pn++)vi[pn]=Gi(le[pn],E);return vi}function oe(z,ee){if(!ee){var le=[];for(var E in z){var H=on.exec(E),Y=H&&H[1];if(Y&&(!ee||Y===ee)){var J=z[E];if(J)for(var se=0;se<J.length;se++)le.push(J[se])}}return le}var ze=An[ee];ze||(mt(ee),ze=An[ee]);var et=z[ze[d]],qe=z[ze[c]];return et?qe?et.concat(qe):et.slice():qe?qe.slice():[]}function st(z,ee){var le=z.Event;le&&le.prototype&&ee.patchMethod(le.prototype,"stopImmediatePropagation",function(E){return function(H,Y){H[ve]=!0,E&&E.apply(H,Y)}})}function Ye(z,ee,le,E,H){var Y=Zone.__symbol__(E);if(!ee[Y]){var J=ee[Y]=ee[E];ee[E]=function(se,ze,et){return ze&&ze.prototype&&H.forEach(function(qe){var rt="".concat(le,".").concat(E,"::")+qe,dt=ze.prototype;try{if(dt.hasOwnProperty(qe)){var St=z.ObjectGetOwnPropertyDescriptor(dt,qe);St&&St.value?(St.value=z.wrapWithCurrentZone(St.value,rt),z._redefineProperty(ze.prototype,qe,St)):dt[qe]&&(dt[qe]=z.wrapWithCurrentZone(dt[qe],rt))}else dt[qe]&&(dt[qe]=z.wrapWithCurrentZone(dt[qe],rt))}catch{}}),J.call(ee,se,ze,et)},z.attachOriginToPatched(ee[E],J)}}function _t(z,ee,le){if(!le||0===le.length)return ee;var E=le.filter(function(Y){return Y.target===z});if(!E||0===E.length)return ee;var H=E[0].ignoreProperties;return ee.filter(function(Y){return-1===H.indexOf(Y)})}function ut(z,ee,le,E){z&&ce(z,_t(z,ee,le),E)}function sn(z){return Object.getOwnPropertyNames(z).filter(function(ee){return ee.startsWith("on")&&ee.length>2}).map(function(ee){return ee.substring(2)})}function vt(z,ee,le){var E=le.configurable;return mn(z,ee,le=Le(z,ee,le),E)}function en(z,ee){return z&&z[L]&&z[L][ee]}function Le(z,ee,le){return Object.isFrozen(le)||(le.configurable=!0),le.configurable||(!z[L]&&!Object.isFrozen(z)&&ki(z,L,{writable:!0,value:{}}),z[L]&&(z[L][ee]=!0)),le}function mn(z,ee,le,E){try{return ki(z,ee,le)}catch(J){if(!le.configurable)throw J;typeof E>"u"?delete le.configurable:le.configurable=E;try{return ki(z,ee,le)}catch(se){var H=!1;if(("createdCallback"===ee||"attachedCallback"===ee||"detachedCallback"===ee||"attributeChangedCallback"===ee)&&(H=!0),!H)throw se;var Y=null;try{Y=JSON.stringify(le)}catch{Y=le.toString()}console.log("Attempting to configure '".concat(ee,"' with descriptor '").concat(Y,"' on object '").concat(z,"' and got error, giving up: ").concat(se))}}}Zone.__load_patch("util",function(z,ee,le){var E=sn(z);le.patchOnProperties=ce,le.patchMethod=ne,le.bindArguments=R,le.patchMacroTask=de;var H=ee.__symbol__("BLACK_LISTED_EVENTS"),Y=ee.__symbol__("UNPATCHED_EVENTS");z[Y]&&(z[H]=z[Y]),z[H]&&(ee[H]=ee[Y]=z[H]),le.patchEventPrototype=st,le.patchEventTarget=ft,le.isIEOrEdge=lt,le.ObjectDefineProperty=t,le.ObjectGetOwnPropertyDescriptor=n,le.ObjectCreate=i,le.ArraySlice=r,le.patchClass=be,le.wrapWithCurrentZone=p,le.filterProperties=_t,le.attachOriginToPatched=pe,le._redefineProperty=Object.defineProperty,le.patchCallbacks=Ye,le.getGlobalObjects=function(){return{globalSources:wt,zoneSymbolEventNames:An,eventNames:E,isBrowser:xe,isMix:Xe,isNode:K,TRUE_STR:c,FALSE_STR:d,ZONE_SYMBOL_PREFIX:u,ADD_EVENT_LISTENER_STR:o,REMOVE_EVENT_LISTENER_STR:s}}});var z,zo=fu(fu(fu(fu(fu(fu(fu(fu([],["abort","animationcancel","animationend","animationiteration","auxclick","beforeinput","blur","cancel","canplay","canplaythrough","change","compositionstart","compositionupdate","compositionend","cuechange","click","close","contextmenu","curechange","dblclick","drag","dragend","dragenter","dragexit","dragleave","dragover","drop","durationchange","emptied","ended","error","focus","focusin","focusout","gotpointercapture","input","invalid","keydown","keypress","keyup","load","loadstart","loadeddata","loadedmetadata","lostpointercapture","mousedown","mouseenter","mouseleave","mousemove","mouseout","mouseover","mouseup","mousewheel","orientationchange","pause","play","playing","pointercancel","pointerdown","pointerenter","pointerleave","pointerlockchange","mozpointerlockchange","webkitpointerlockerchange","pointerlockerror","mozpointerlockerror","webkitpointerlockerror","pointermove","pointout","pointerover","pointerup","progress","ratechange","reset","resize","scroll","seeked","seeking","select","selectionchange","selectstart","show","sort","stalled","submit","suspend","timeupdate","volumechange","touchcancel","touchmove","touchstart","touchend","transitioncancel","transitionend","waiting","wheel"],!0),["webglcontextrestored","webglcontextlost","webglcontextcreationerror"],!0),["autocomplete","autocompleteerror"],!0),["toggle"],!0),["afterscriptexecute","beforescriptexecute","DOMContentLoaded","freeze","fullscreenchange","mozfullscreenchange","webkitfullscreenchange","msfullscreenchange","fullscreenerror","mozfullscreenerror","webkitfullscreenerror","msfullscreenerror","readystatechange","visibilitychange","resume"],!0),["absolutedeviceorientation","afterinput","afterprint","appinstalled","beforeinstallprompt","beforeprint","beforeunload","devicelight","devicemotion","deviceorientation","deviceorientationabsolute","deviceproximity","hashchange","languagechange","message","mozbeforepaint","offline","online","paint","pageshow","pagehide","popstate","rejectionhandled","storage","unhandledrejection","unload","userproximity","vrdisplayconnected","vrdisplaydisconnected","vrdisplaypresentchange"],!0),["beforecopy","beforecut","beforepaste","copy","cut","paste","dragstart","loadend","animationstart","search","transitionrun","transitionstart","webkitanimationend","webkitanimationiteration","webkitanimationstart","webkittransitionend"],!0),["activate","afterupdate","ariarequest","beforeactivate","beforedeactivate","beforeeditfocus","beforeupdate","cellchange","controlselect","dataavailable","datasetchanged","datasetcomplete","errorupdate","filterchange","layoutcomplete","losecapture","move","moveend","movestart","propertychange","resizeend","resizestart","rowenter","rowexit","rowsdelete","rowsinserted","command","compassneedscalibration","deactivate","help","mscontentzoom","msmanipulationstatechanged","msgesturechange","msgesturedoubletap","msgestureend","msgesturehold","msgesturestart","msgesturetap","msgotpointercapture","msinertiastart","mslostpointercapture","mspointercancel","mspointerdown","mspointerenter","mspointerhover","mspointerleave","mspointermove","mspointerout","mspointerover","mspointerup","pointerout","mssitemodejumplistitemremoved","msthumbnailclick","stop","storagecommit"],!0);(z=typeof window<"u"?window:typeof global<"u"?global:typeof self<"u"?self:{})[("legacyPatch",(z.__Zone_symbol_prefix||"__zone_symbol__")+"legacyPatch")]=function(){var E=z.Zone;E.__load_patch("defineProperty",function(H,Y,J){J._redefineProperty=vt,ti=Zone.__symbol__,ki=Object[ti("defineProperty")]=Object.defineProperty,Fi=Object[ti("getOwnPropertyDescriptor")]=Object.getOwnPropertyDescriptor,Z=Object.create,L=ti("unconfigurables"),Object.defineProperty=function(z,ee,le){if(en(z,ee))throw new TypeError("Cannot assign to read only property '"+ee+"' of "+z);var E=le.configurable;return"prototype"!==ee&&(le=Le(z,ee,le)),mn(z,ee,le,E)},Object.defineProperties=function(z,ee){Object.keys(ee).forEach(function(J){Object.defineProperty(z,J,ee[J])});for(var le=0,E=Object.getOwnPropertySymbols(ee);le<E.length;le++){var H=E[le];Object.getOwnPropertyDescriptor(ee,H)?.enumerable&&Object.defineProperty(z,H,ee[H])}return z},Object.create=function(z,ee){return"object"==typeof ee&&!Object.isFrozen(ee)&&Object.keys(ee).forEach(function(le){ee[le]=Le(z,le,ee[le])}),Z(z,ee)},Object.getOwnPropertyDescriptor=function(z,ee){var le=Fi(z,ee);return le&&en(z,ee)&&(le.configurable=!1),le}}),E.__load_patch("registerElement",function(H,Y,J){!function(z,ee){var le=ee.getGlobalObjects();(le.isBrowser||le.isMix)&&"registerElement"in z.document&&ee.patchCallbacks(ee,document,"Document","registerElement",["createdCallback","attachedCallback","detachedCallback","attributeChangedCallback"])}(H,J)}),E.__load_patch("EventTargetLegacy",function(H,Y,J){(function(z,ee){var le=ee.getGlobalObjects(),E=le.eventNames,H=le.globalSources,Y=le.zoneSymbolEventNames,J=le.TRUE_STR,se=le.FALSE_STR,ze=le.ZONE_SYMBOL_PREFIX,qe="ApplicationCache,EventSource,FileReader,InputMethodContext,MediaController,MessagePort,Node,Performance,SVGElementInstance,SharedWorker,TextTrack,TextTrackCue,TextTrackList,WebKitNamedFlow,Window,Worker,WorkerGlobalScope,XMLHttpRequest,XMLHttpRequestEventTarget,XMLHttpRequestUpload,IDBRequest,IDBOpenDBRequest,IDBDatabase,IDBTransaction,IDBCursor,DBIndex,WebSocket".split(","),rt="EventTarget",dt=[],St=z.wtf,Dt="Anchor,Area,Audio,BR,Base,BaseFont,Body,Button,Canvas,Content,DList,Directory,Div,Embed,FieldSet,Font,Form,Frame,FrameSet,HR,Head,Heading,Html,IFrame,Image,Input,Keygen,LI,Label,Legend,Link,Map,Marquee,Media,Menu,Meta,Meter,Mod,OList,Object,OptGroup,Option,Output,Paragraph,Pre,Progress,Quote,Script,Select,Source,Span,Style,TableCaption,TableCell,TableCol,Table,TableRow,TableSection,TextArea,Title,Track,UList,Unknown,Video".split(",");St?dt=Dt.map(function(Mr){return"HTML"+Mr+"Element"}).concat(qe):z[rt]?dt.push(rt):dt=qe;for(var cn=z.__Zone_disable_IE_check||!1,Gi=z.__Zone_enable_cross_context_check||!1,vi=ee.isIEOrEdge(),Pn="[object FunctionWrapper]",Et="function __BROWSERTOOLS_CONSOLE_SAFEFUNC() { [native code] }",pi={MSPointerCancel:"pointercancel",MSPointerDown:"pointerdown",MSPointerEnter:"pointerenter",MSPointerHover:"pointerhover",MSPointerLeave:"pointerleave",MSPointerMove:"pointermove",MSPointerOut:"pointerout",MSPointerOver:"pointerover",MSPointerUp:"pointerup"},Qn=0;Qn<E.length;Qn++){var Ni=ze+((Vn=E[Qn])+se),vn=ze+(Vn+J);Y[Vn]={},Y[Vn][se]=Ni,Y[Vn][J]=vn}for(Qn=0;Qn<Dt.length;Qn++)for(var On=Dt[Qn],fi=H[On]={},kn=0;kn<E.length;kn++){var Vn;fi[Vn=E[kn]]=On+".addEventListener:"+Vn}var rr=[];for(Qn=0;Qn<dt.length;Qn++){var ys=z[dt[Qn]];rr.push(ys&&ys.prototype)}ee.patchEventTarget(z,ee,rr,{vh:function(Mr,fr,gt,me){if(!cn&&vi)if(Gi)try{if((he=fr.toString())===Pn||he==Et)return Mr.apply(gt,me),!1}catch{return Mr.apply(gt,me),!1}else{var he;if((he=fr.toString())===Pn||he==Et)return Mr.apply(gt,me),!1}else if(Gi)try{fr.toString()}catch{return Mr.apply(gt,me),!1}return!0},transferEventName:function(Mr){return pi[Mr]||Mr}}),Zone[ee.symbol("patchEventTarget")]=!!z[rt]})(H,J),function(z,ee){var le=z.getGlobalObjects();if((!le.isNode||le.isMix)&&!function(z,ee){var le=z.getGlobalObjects();if((le.isBrowser||le.isMix)&&!z.ObjectGetOwnPropertyDescriptor(HTMLElement.prototype,"onclick")&&typeof Element<"u"){var Y=z.ObjectGetOwnPropertyDescriptor(Element.prototype,"onclick");if(Y&&!Y.configurable)return!1;if(Y){z.ObjectDefineProperty(Element.prototype,"onclick",{enumerable:!0,configurable:!0,get:function(){return!0}});var se=!!document.createElement("div").onclick;return z.ObjectDefineProperty(Element.prototype,"onclick",Y),se}}var ze=ee.XMLHttpRequest;if(!ze)return!1;var et="onreadystatechange",qe=ze.prototype,rt=z.ObjectGetOwnPropertyDescriptor(qe,et);if(rt)return z.ObjectDefineProperty(qe,et,{enumerable:!0,configurable:!0,get:function(){return!0}}),se=!!(dt=new ze).onreadystatechange,z.ObjectDefineProperty(qe,et,rt||{}),se;var St=z.symbol("fake");z.ObjectDefineProperty(qe,et,{enumerable:!0,configurable:!0,get:function(){return this[St]},set:function(vi){this[St]=vi}});var dt,Dt=function(){};return(dt=new ze).onreadystatechange=Dt,se=dt[St]===Dt,dt.onreadystatechange=null,se}(z,ee)){var Y=typeof WebSocket<"u";(function(z){for(var ee=z.symbol("unbound"),le=function(H){var Y=zo[H],J="on"+Y;self.addEventListener(Y,function(se){var et,qe,ze=se.target;for(qe=ze?ze.constructor.name+"."+J:"unknown."+J;ze;)ze[J]&&!ze[J][ee]&&((et=z.wrapWithCurrentZone(ze[J],qe))[ee]=ze[J],ze[J]=et),ze=ze.parentElement},!0)},E=0;E<zo.length;E++)le(E)})(z),z.patchClass("XMLHttpRequest"),Y&&function(z,ee){var le=z.getGlobalObjects(),E=le.ADD_EVENT_LISTENER_STR,H=le.REMOVE_EVENT_LISTENER_STR,Y=ee.WebSocket;ee.EventTarget||z.patchEventTarget(ee,z,[Y.prototype]),ee.WebSocket=function(ze,et){var rt,dt,qe=arguments.length>1?new Y(ze,et):new Y(ze),St=z.ObjectGetOwnPropertyDescriptor(qe,"onmessage");return St&&!1===St.configurable?(rt=z.ObjectCreate(qe),dt=qe,[E,H,"send","close"].forEach(function(Dt){rt[Dt]=function(){var cn=z.ArraySlice.call(arguments);if(Dt===E||Dt===H){var Gi=cn.length>0?cn[0]:void 0;if(Gi){var vi=Zone.__symbol__("ON_PROPERTY"+Gi);qe[vi]=rt[vi]}}return qe[Dt].apply(qe,cn)}})):rt=qe,z.patchOnProperties(rt,["close","error","message","open"],dt),rt};var J=ee.WebSocket;for(var se in Y)J[se]=Y[se]}(z,ee),Zone[z.symbol("patchEvents")]=!0}}(J,H)})};var vs=m("zoneTask");function dl(z,ee,le,E){var H=null,Y=null;le+=E;var J={};function se(et){var qe=et.data;return qe.args[0]=function(){return et.invoke.apply(this,arguments)},qe.handleId=H.apply(z,qe.args),et}function ze(et){return Y.call(z,et.data.handleId)}H=ne(z,ee+=E,function(et){return function(qe,rt){if("function"==typeof rt[0]){var dt={isPeriodic:"Interval"===E,delay:"Timeout"===E||"Interval"===E?rt[1]||0:void 0,args:rt},St=rt[0];rt[0]=function(){try{return St.apply(this,arguments)}finally{dt.isPeriodic||("number"==typeof dt.handleId?delete J[dt.handleId]:dt.handleId&&(dt.handleId[vs]=null))}};var Dt=f(ee,rt[0],dt,se,ze);if(!Dt)return Dt;var cn=Dt.data.handleId;return"number"==typeof cn?J[cn]=Dt:cn&&(cn[vs]=Dt),cn&&cn.ref&&cn.unref&&"function"==typeof cn.ref&&"function"==typeof cn.unref&&(Dt.ref=cn.ref.bind(cn),Dt.unref=cn.unref.bind(cn)),"number"==typeof cn||cn?cn:Dt}return et.apply(z,rt)}}),Y=ne(z,le,function(et){return function(qe,rt){var St,dt=rt[0];"number"==typeof dt?St=J[dt]:(St=dt&&dt[vs])||(St=dt),St&&"string"==typeof St.type?"notScheduled"!==St.state&&(St.cancelFn&&St.data.isPeriodic||0===St.runCount)&&("number"==typeof dt?delete J[dt]:dt&&(dt[vs]=null),St.zone.cancelTask(St)):et.apply(z,rt)}})}Zone.__load_patch("legacy",function(z){var ee=z[Zone.__symbol__("legacyPatch")];ee&&ee()}),Zone.__load_patch("queueMicrotask",function(z,ee,le){le.patchMethod(z,"queueMicrotask",function(E){return function(H,Y){ee.current.scheduleMicroTask("queueMicrotask",Y[0])}})}),Zone.__load_patch("timers",function(z){var le="clear";dl(z,"set",le,"Timeout"),dl(z,"set",le,"Interval"),dl(z,"set",le,"Immediate")}),Zone.__load_patch("requestAnimationFrame",function(z){dl(z,"request","cancel","AnimationFrame"),dl(z,"mozRequest","mozCancel","AnimationFrame"),dl(z,"webkitRequest","webkitCancel","AnimationFrame")}),Zone.__load_patch("blocking",function(z,ee){for(var le=["alert","prompt","confirm"],E=0;E<le.length;E++)ne(z,le[E],function(Y,J,se){return function(ze,et){return ee.current.run(Y,z,et,se)}})}),Zone.__load_patch("EventTarget",function(z,ee,le){(function(z,ee){ee.patchEventPrototype(z,ee)})(z,le),function(z,ee){if(!Zone[ee.symbol("patchEventTarget")]){for(var le=ee.getGlobalObjects(),E=le.eventNames,H=le.zoneSymbolEventNames,Y=le.TRUE_STR,J=le.FALSE_STR,se=le.ZONE_SYMBOL_PREFIX,ze=0;ze<E.length;ze++){var et=E[ze],dt=se+(et+J),St=se+(et+Y);H[et]={},H[et][J]=dt,H[et][Y]=St}var Dt=z.EventTarget;Dt&&Dt.prototype&&ee.patchEventTarget(z,ee,[Dt&&Dt.prototype])}}(z,le);var E=z.XMLHttpRequestEventTarget;E&&E.prototype&&le.patchEventTarget(z,le,[E.prototype])}),Zone.__load_patch("MutationObserver",function(z,ee,le){be("MutationObserver"),be("WebKitMutationObserver")}),Zone.__load_patch("IntersectionObserver",function(z,ee,le){be("IntersectionObserver")}),Zone.__load_patch("FileReader",function(z,ee,le){be("FileReader")}),Zone.__load_patch("on_property",function(z,ee,le){!function(z,ee){if((!K||Xe)&&!Zone[z.symbol("patchEvents")]){var le=ee.__Zone_ignore_on_properties,E=[];if(xe){var H=window;E=E.concat(["Document","SVGElement","Element","HTMLElement","HTMLBodyElement","HTMLMediaElement","HTMLFrameSetElement","HTMLFrameElement","HTMLIFrameElement","HTMLMarqueeElement","Worker"]);var Y=function(){try{var z=M.navigator.userAgent;if(-1!==z.indexOf("MSIE ")||-1!==z.indexOf("Trident/"))return!0}catch{}return!1}()?[{target:H,ignoreProperties:["error"]}]:[];ut(H,sn(H),le&&le.concat(Y),e(H))}E=E.concat(["XMLHttpRequest","XMLHttpRequestEventTarget","IDBIndex","IDBRequest","IDBOpenDBRequest","IDBDatabase","IDBTransaction","IDBCursor","WebSocket"]);for(var J=0;J<E.length;J++){var se=ee[E[J]];se&&se.prototype&&ut(se.prototype,sn(se.prototype),le)}}}(le,z)}),Zone.__load_patch("customElements",function(z,ee,le){!function(z,ee){var le=ee.getGlobalObjects();(le.isBrowser||le.isMix)&&z.customElements&&"customElements"in z&&ee.patchCallbacks(ee,z.customElements,"customElements","define",["connectedCallback","disconnectedCallback","adoptedCallback","attributeChangedCallback"])}(z,le)}),Zone.__load_patch("XHR",function(z,ee){!function(et){var qe=et.XMLHttpRequest;if(qe){var rt=qe.prototype,St=rt[a],Dt=rt[l];if(!St){var cn=et.XMLHttpRequestEventTarget;if(cn){var Gi=cn.prototype;St=Gi[a],Dt=Gi[l]}}var vi="readystatechange",pn="scheduled",Qn=ne(rt,"open",function(){return function(On,fi){return On[E]=0==fi[2],On[J]=fi[1],Qn.apply(On,fi)}}),Wn=m("fetchTaskAborting"),Ut=m("fetchTaskScheduling"),Ni=ne(rt,"send",function(){return function(On,fi){if(!0===ee.current[Ut]||On[E])return Ni.apply(On,fi);var kn={target:On,url:On[J],isPeriodic:!1,args:fi,aborted:!1},pr=f("XMLHttpRequest.send",Et,kn,Pn,pi);On&&!0===On[se]&&!kn.aborted&&pr.state===pn&&pr.invoke()}}),vn=ne(rt,"abort",function(){return function(On,fi){var kn=function(On){return On[le]}(On);if(kn&&"string"==typeof kn.type){if(null==kn.cancelFn||kn.data&&kn.data.aborted)return;kn.zone.cancelTask(kn)}else if(!0===ee.current[Wn])return vn.apply(On,fi)}})}function Pn(On){var fi=On.data,kn=fi.target;kn[Y]=!1,kn[se]=!1;var pr=kn[H];St||(St=kn[a],Dt=kn[l]),pr&&Dt.call(kn,vi,pr);var rr=kn[H]=function(){if(kn.readyState===kn.DONE)if(!fi.aborted&&kn[Y]&&On.state===pn){var Mr=kn[ee.__symbol__("loadfalse")];if(0!==kn.status&&Mr&&Mr.length>0){var fr=On.invoke;On.invoke=function(){for(var gt=kn[ee.__symbol__("loadfalse")],me=0;me<gt.length;me++)gt[me]===On&&gt.splice(me,1);!fi.aborted&&On.state===pn&&fr.call(On)},Mr.push(On)}else On.invoke()}else!fi.aborted&&!1===kn[Y]&&(kn[se]=!0)};return St.call(kn,vi,rr),kn[le]||(kn[le]=On),Ni.apply(kn,fi.args),kn[Y]=!0,On}function Et(){}function pi(On){var fi=On.data;return fi.aborted=!0,vn.apply(fi.target,fi.args)}}(z);var le=m("xhrTask"),E=m("xhrSync"),H=m("xhrListener"),Y=m("xhrScheduled"),J=m("xhrURL"),se=m("xhrErrorBeforeScheduled")}),Zone.__load_patch("geolocation",function(z){z.navigator&&z.navigator.geolocation&&function(z,ee){for(var le=z.constructor.name,E=function(Y){var et,qe,J=ee[Y],se=z[J];if(se){if(!V(n(z,J)))return"continue";z[J]=(qe=function(){return et.apply(this,R(arguments,le+"."+J))},pe(qe,et=se),qe)}},H=0;H<ee.length;H++)E(H)}(z.navigator.geolocation,["getCurrentPosition","watchPosition"])}),Zone.__load_patch("PromiseRejectionEvent",function(z,ee){function le(E){return function(H){oe(z,E).forEach(function(J){var se=z.PromiseRejectionEvent;if(se){var ze=new se(E,{promise:H.promise,reason:H.rejection});J.invoke(ze)}})}}z.PromiseRejectionEvent&&(ee[m("unhandledPromiseRejectionHandler")]=le("unhandledrejection"),ee[m("rejectionHandledHandler")]=le("rejectionhandled"))})},"function"==typeof define&&define.amd?define(n):n()});function _n(n){return"function"==typeof n}function Sm(n){let e=n(i=>{Error.call(i),i.stack=(new Error).stack});return e.prototype=Object.create(Error.prototype),e.prototype.constructor=e,e}var nC=Sm(n=>function(e){n(this),this.message=e?`${e.length} errors occurred during unsubscription:\n${e.map((i,r)=>`${r+1}) ${i.toString()}`).join("\n  ")}`:"",this.name="UnsubscriptionError",this.errors=e});function Dp(n,t){if(n){let e=n.indexOf(t);0<=e&&n.splice(e,1)}}var Mn=class{constructor(t){this.initialTeardown=t,this.closed=!1,this._parentage=null,this._finalizers=null}unsubscribe(){let t;if(!this.closed){this.closed=!0;let{_parentage:e}=this;if(e)if(this._parentage=null,Array.isArray(e))for(let o of e)o.remove(this);else e.remove(this);let{initialTeardown:i}=this;if(_n(i))try{i()}catch(o){t=o instanceof nC?o.errors:[o]}let{_finalizers:r}=this;if(r){this._finalizers=null;for(let o of r)try{qV(o)}catch(s){t=t??[],s instanceof nC?t=[...t,...s.errors]:t.push(s)}}if(t)throw new nC(t)}}add(t){var e;if(t&&t!==this)if(this.closed)qV(t);else{if(t instanceof Mn){if(t.closed||t._hasParent(this))return;t._addParent(this)}(this._finalizers=null!==(e=this._finalizers)&&void 0!==e?e:[]).push(t)}}_hasParent(t){let{_parentage:e}=this;return e===t||Array.isArray(e)&&e.includes(t)}_addParent(t){let{_parentage:e}=this;this._parentage=Array.isArray(e)?(e.push(t),e):e?[e,t]:t}_removeParent(t){let{_parentage:e}=this;e===t?this._parentage=null:Array.isArray(e)&&Dp(e,t)}remove(t){let{_finalizers:e}=this;e&&Dp(e,t),t instanceof Mn&&t._removeParent(this)}};Mn.EMPTY=(()=>{let n=new Mn;return n.closed=!0,n})();var NA=Mn.EMPTY;function iC(n){return n instanceof Mn||n&&"closed"in n&&_n(n.remove)&&_n(n.add)&&_n(n.unsubscribe)}function qV(n){_n(n)?n():n.unsubscribe()}var pl={onUnhandledError:null,onStoppedNotification:null,Promise:void 0,useDeprecatedSynchronousErrorHandling:!1,useDeprecatedNextContext:!1},Em={setTimeout(n,t,...e){let{delegate:i}=Em;return i?.setTimeout?i.setTimeout(n,t,...e):setTimeout(n,t,...e)},clearTimeout(n){let{delegate:t}=Em;return(t?.clearTimeout||clearTimeout)(n)},delegate:void 0};function rC(n){Em.setTimeout(()=>{let{onUnhandledError:t}=pl;if(!t)throw n;t(n)})}function fl(){}var YV=LA("C",void 0,void 0);function LA(n,t,e){return{kind:n,value:t,error:e}}var Ip=null;function Tm(n){if(pl.useDeprecatedSynchronousErrorHandling){let t=!Ip;if(t&&(Ip={errorThrown:!1,error:null}),n(),t){let{errorThrown:e,error:i}=Ip;if(Ip=null,e)throw i}}else n()}var Ap=class extends Mn{constructor(t){super(),this.isStopped=!1,t?(this.destination=t,iC(t)&&t.add(this)):this.destination=Lie}static create(t,e,i){return new ml(t,e,i)}next(t){this.isStopped?VA(LA("N",t,void 0),this):this._next(t)}error(t){this.isStopped?VA(LA("E",void 0,t),this):(this.isStopped=!0,this._error(t))}complete(){this.isStopped?VA(YV,this):(this.isStopped=!0,this._complete())}unsubscribe(){this.closed||(this.isStopped=!0,super.unsubscribe(),this.destination=null)}_next(t){this.destination.next(t)}_error(t){try{this.destination.error(t)}finally{this.unsubscribe()}}_complete(){try{this.destination.complete()}finally{this.unsubscribe()}}},Fie=Function.prototype.bind;function BA(n,t){return Fie.call(n,t)}var ml=class extends Ap{constructor(t,e,i){let r;if(super(),_n(t)||!t)r={next:t??void 0,error:e??void 0,complete:i??void 0};else{let o;this&&pl.useDeprecatedNextContext?(o=Object.create(t),o.unsubscribe=()=>this.unsubscribe(),r={next:t.next&&BA(t.next,o),error:t.error&&BA(t.error,o),complete:t.complete&&BA(t.complete,o)}):r=t}this.destination=new class{constructor(t){this.partialObserver=t}next(t){let{partialObserver:e}=this;if(e.next)try{e.next(t)}catch(i){oC(i)}}error(t){let{partialObserver:e}=this;if(e.error)try{e.error(t)}catch(i){oC(i)}else oC(t)}complete(){let{partialObserver:t}=this;if(t.complete)try{t.complete()}catch(e){oC(e)}}}(r)}};function oC(n){pl.useDeprecatedSynchronousErrorHandling?function(n){pl.useDeprecatedSynchronousErrorHandling&&Ip&&(Ip.errorThrown=!0,Ip.error=n)}(n):rC(n)}function VA(n,t){let{onStoppedNotification:e}=pl;e&&Em.setTimeout(()=>e(n,t))}var Lie={closed:!0,next:fl,error:function(n){throw n},complete:fl},Dm="function"==typeof Symbol&&Symbol.observable||"@@observable";function is(n){return n}function UA(n){return 0===n.length?is:1===n.length?n[0]:function(e){return n.reduce((i,r)=>r(i),e)}}var Kt=(()=>{class n{constructor(e){e&&(this._subscribe=e)}lift(e){let i=new n;return i.source=this,i.operator=e,i}subscribe(e,i,r){let o=function(n){return n&&n instanceof Ap||function(n){return n&&_n(n.next)&&_n(n.error)&&_n(n.complete)}(n)&&iC(n)}(e)?e:new ml(e,i,r);return Tm(()=>{let{operator:s,source:a}=this;o.add(s?s.call(o,a):a?this._subscribe(o):this._trySubscribe(o))}),o}_trySubscribe(e){try{return this._subscribe(e)}catch(i){e.error(i)}}forEach(e,i){return new(i=KV(i))((r,o)=>{let s=new ml({next:a=>{try{e(a)}catch(l){o(l),s.unsubscribe()}},error:o,complete:r});this.subscribe(s)})}_subscribe(e){var i;return null===(i=this.source)||void 0===i?void 0:i.subscribe(e)}[Dm](){return this}pipe(...e){return UA(e)(this)}toPromise(e){return new(e=KV(e))((i,r)=>{let o;this.subscribe(s=>o=s,s=>r(s),()=>i(o))})}}return n.create=t=>new n(t),n})();function KV(n){var t;return null!==(t=n??pl.Promise)&&void 0!==t?t:Promise}function jA(n){return _n(n?.lift)}function qt(n){return t=>{if(jA(t))return t.lift(function(e){try{return n(e,this)}catch(i){this.error(i)}});throw new TypeError("Unable to lift unknown Observable type")}}function Vt(n,t,e,i,r){return new M_(n,t,e,i,r)}var GA,M_=class extends Ap{constructor(t,e,i,r,o,s){super(t),this.onFinalize=o,this.shouldUnsubscribe=s,this._next=e?function(a){try{e(a)}catch(l){t.error(l)}}:super._next,this._error=r?function(a){try{r(a)}catch(l){t.error(l)}finally{this.unsubscribe()}}:super._error,this._complete=i?function(){try{i()}catch(a){t.error(a)}finally{this.unsubscribe()}}:super._complete}unsubscribe(){var t;if(!this.shouldUnsubscribe||this.shouldUnsubscribe()){let{closed:e}=this;super.unsubscribe(),!e&&(null===(t=this.onFinalize)||void 0===t||t.call(this))}}},w_=class extends Kt{constructor(t,e){super(),this.source=t,this.subjectFactory=e,this._subject=null,this._refCount=0,this._connection=null,jA(t)&&(this.lift=t.lift)}_subscribe(t){return this.getSubject().subscribe(t)}getSubject(){let t=this._subject;return(!t||t.isStopped)&&(this._subject=this.subjectFactory()),this._subject}_teardown(){this._refCount=0;let{_connection:t}=this;this._subject=this._connection=null,t?.unsubscribe()}connect(){let t=this._connection;if(!t){t=this._connection=new Mn;let e=this.getSubject();t.add(this.source.subscribe(Vt(e,void 0,()=>{this._teardown(),e.complete()},i=>{this._teardown(),e.error(i)},()=>this._teardown()))),t.closed&&(this._connection=null,t=Mn.EMPTY)}return t}refCount(){return qt((n,t)=>{let e=null;n._refCount++;let i=Vt(t,void 0,void 0,void 0,()=>{if(!n||n._refCount<=0||0<--n._refCount)return void(e=null);let r=n._connection,o=e;e=null,r&&(!o||r===o)&&r.unsubscribe(),t.unsubscribe()});n.subscribe(i),i.closed||(e=n.connect())})(this)}},Im={schedule(n){let t=requestAnimationFrame,e=cancelAnimationFrame,{delegate:i}=Im;i&&(t=i.requestAnimationFrame,e=i.cancelAnimationFrame);let r=t(o=>{e=void 0,n(o)});return new Mn(()=>e?.(r))},requestAnimationFrame(...n){let{delegate:t}=Im;return(t?.requestAnimationFrame||requestAnimationFrame)(...n)},cancelAnimationFrame(...n){let{delegate:t}=Im;return(t?.cancelAnimationFrame||cancelAnimationFrame)(...n)},delegate:void 0},$V=Sm(n=>function(){n(this),this.name="ObjectUnsubscribedError",this.message="object unsubscribed"}),Ie=(()=>{class n extends Kt{constructor(){super(),this.closed=!1,this.currentObservers=null,this.observers=[],this.isStopped=!1,this.hasError=!1,this.thrownError=null}lift(e){let i=new sC(this,this);return i.operator=e,i}_throwIfClosed(){if(this.closed)throw new $V}next(e){Tm(()=>{if(this._throwIfClosed(),!this.isStopped){this.currentObservers||(this.currentObservers=Array.from(this.observers));for(let i of this.currentObservers)i.next(e)}})}error(e){Tm(()=>{if(this._throwIfClosed(),!this.isStopped){this.hasError=this.isStopped=!0,this.thrownError=e;let{observers:i}=this;for(;i.length;)i.shift().error(e)}})}complete(){Tm(()=>{if(this._throwIfClosed(),!this.isStopped){this.isStopped=!0;let{observers:e}=this;for(;e.length;)e.shift().complete()}})}unsubscribe(){this.isStopped=this.closed=!0,this.observers=this.currentObservers=null}get observed(){var e;return(null===(e=this.observers)||void 0===e?void 0:e.length)>0}_trySubscribe(e){return this._throwIfClosed(),super._trySubscribe(e)}_subscribe(e){return this._throwIfClosed(),this._checkFinalizedStatuses(e),this._innerSubscribe(e)}_innerSubscribe(e){let{hasError:i,isStopped:r,observers:o}=this;return i||r?NA:(this.currentObservers=null,o.push(e),new Mn(()=>{this.currentObservers=null,Dp(o,e)}))}_checkFinalizedStatuses(e){let{hasError:i,thrownError:r,isStopped:o}=this;i?e.error(r):o&&e.complete()}asObservable(){let e=new Kt;return e.source=this,e}}return n.create=(t,e)=>new sC(t,e),n})(),sC=class extends Ie{constructor(t,e){super(),this.destination=t,this.source=e}next(t){var e,i;null===(i=null===(e=this.destination)||void 0===e?void 0:e.next)||void 0===i||i.call(e,t)}error(t){var e,i;null===(i=null===(e=this.destination)||void 0===e?void 0:e.error)||void 0===i||i.call(e,t)}complete(){var t,e;null===(e=null===(t=this.destination)||void 0===t?void 0:t.complete)||void 0===e||e.call(t)}_subscribe(t){var e,i;return null!==(i=null===(e=this.source)||void 0===e?void 0:e.subscribe(t))&&void 0!==i?i:NA}},Ai=class extends Ie{constructor(t){super(),this._value=t}get value(){return this.getValue()}_subscribe(t){let e=super._subscribe(t);return!e.closed&&t.next(this._value),e}getValue(){let{hasError:t,thrownError:e,_value:i}=this;if(t)throw e;return this._throwIfClosed(),i}next(t){super.next(this._value=t)}},S_={now:()=>(S_.delegate||Date).now(),delegate:void 0},Rp=class extends Ie{constructor(t=1/0,e=1/0,i=S_){super(),this._bufferSize=t,this._windowTime=e,this._timestampProvider=i,this._buffer=[],this._infiniteTimeWindow=!0,this._infiniteTimeWindow=e===1/0,this._bufferSize=Math.max(1,t),this._windowTime=Math.max(1,e)}next(t){let{isStopped:e,_buffer:i,_infiniteTimeWindow:r,_timestampProvider:o,_windowTime:s}=this;e||(i.push(t),!r&&i.push(o.now()+s)),this._trimBuffer(),super.next(t)}_subscribe(t){this._throwIfClosed(),this._trimBuffer();let e=this._innerSubscribe(t),{_infiniteTimeWindow:i,_buffer:r}=this,o=r.slice();for(let s=0;s<o.length&&!t.closed;s+=i?1:2)t.next(o[s]);return this._checkFinalizedStatuses(t),e}_trimBuffer(){let{_bufferSize:t,_timestampProvider:e,_buffer:i,_infiniteTimeWindow:r}=this,o=(r?1:2)*t;if(t<1/0&&o<i.length&&i.splice(0,i.length-o),!r){let s=e.now(),a=0;for(let l=1;l<i.length&&i[l]<=s;l+=2)a=l;a&&i.splice(0,a+1)}}},aC=class extends Mn{constructor(t,e){super()}schedule(t,e=0){return this}},E_={setInterval(n,t,...e){let{delegate:i}=E_;return i?.setInterval?i.setInterval(n,t,...e):setInterval(n,t,...e)},clearInterval(n){let{delegate:t}=E_;return(t?.clearInterval||clearInterval)(n)},delegate:void 0},nc=class extends aC{constructor(t,e){super(t,e),this.scheduler=t,this.work=e,this.pending=!1}schedule(t,e=0){var i;if(this.closed)return this;this.state=t;let r=this.id,o=this.scheduler;return null!=r&&(this.id=this.recycleAsyncId(o,r,e)),this.pending=!0,this.delay=e,this.id=null!==(i=this.id)&&void 0!==i?i:this.requestAsyncId(o,this.id,e),this}requestAsyncId(t,e,i=0){return E_.setInterval(t.flush.bind(t,this),i)}recycleAsyncId(t,e,i=0){if(null!=i&&this.delay===i&&!1===this.pending)return e;null!=e&&E_.clearInterval(e)}execute(t,e){if(this.closed)return new Error("executing a cancelled action");this.pending=!1;let i=this._execute(t,e);if(i)return i;!1===this.pending&&null!=this.id&&(this.id=this.recycleAsyncId(this.scheduler,this.id,null))}_execute(t,e){let r,i=!1;try{this.work(t)}catch(o){i=!0,r=o||new Error("Scheduled action threw falsy error")}if(i)return this.unsubscribe(),r}unsubscribe(){if(!this.closed){let{id:t,scheduler:e}=this,{actions:i}=e;this.work=this.state=this.scheduler=null,this.pending=!1,Dp(i,this),null!=t&&(this.id=this.recycleAsyncId(e,t,null)),this.delay=null,super.unsubscribe()}}},Hie=1,WA={};function e4(n){return n in WA&&(delete WA[n],!0)}var t4={setImmediate(n){let t=Hie++;return WA[t]=!0,GA||(GA=Promise.resolve()),GA.then(()=>e4(t)&&n()),t},clearImmediate(n){e4(n)}},{setImmediate:zie,clearImmediate:Uie}=t4,T_={setImmediate(...n){let{delegate:t}=T_;return(t?.setImmediate||zie)(...n)},clearImmediate(n){let{delegate:t}=T_;return(t?.clearImmediate||Uie)(n)},delegate:void 0},Zd=class{constructor(t,e=Zd.now){this.schedulerActionCtor=t,this.now=e}schedule(t,e=0,i){return new this.schedulerActionCtor(this,t).schedule(i,e)}};Zd.now=S_.now;var ic=class extends Zd{constructor(t,e=Zd.now){super(t,e),this.actions=[],this._active=!1}flush(t){let i,{actions:e}=this;if(this._active)e.push(t);else{this._active=!0;do{if(i=t.execute(t.state,t.delay))break}while(t=e.shift());if(this._active=!1,i){for(;t=e.shift();)t.unsubscribe();throw i}}}},Am=new class extends ic{flush(t){this._active=!0;let e=this._scheduled;this._scheduled=void 0;let r,{actions:i}=this;t=t||i.shift();do{if(r=t.execute(t.state,t.delay))break}while((t=i[0])&&t.id===e&&i.shift());if(this._active=!1,r){for(;(t=i[0])&&t.id===e&&i.shift();)t.unsubscribe();throw r}}}(class extends nc{constructor(t,e){super(t,e),this.scheduler=t,this.work=e}requestAsyncId(t,e,i=0){return null!==i&&i>0?super.requestAsyncId(t,e,i):(t.actions.push(this),t._scheduled||(t._scheduled=T_.setImmediate(t.flush.bind(t,void 0))))}recycleAsyncId(t,e,i=0){var r;if(null!=i?i>0:this.delay>0)return super.recycleAsyncId(t,e,i);let{actions:o}=t;null!=e&&(null===(r=o[o.length-1])||void 0===r?void 0:r.id)!==e&&(T_.clearImmediate(e),t._scheduled=void 0)}}),Jc=new ic(nc),n4=Jc,qA=new class extends ic{}(class extends nc{constructor(t,e){super(t,e),this.scheduler=t,this.work=e}schedule(t,e=0){return e>0?super.schedule(t,e):(this.delay=e,this.state=t,this.scheduler.flush(this),this)}execute(t,e){return e>0||this.closed?super.execute(t,e):this._execute(t,e)}requestAsyncId(t,e,i=0){return null!=i&&i>0||null==i&&this.delay>0?super.requestAsyncId(t,e,i):(t.flush(this),0)}}),YA=new class extends ic{flush(t){this._active=!0;let e=this._scheduled;this._scheduled=void 0;let r,{actions:i}=this;t=t||i.shift();do{if(r=t.execute(t.state,t.delay))break}while((t=i[0])&&t.id===e&&i.shift());if(this._active=!1,r){for(;(t=i[0])&&t.id===e&&i.shift();)t.unsubscribe();throw r}}}(class extends nc{constructor(t,e){super(t,e),this.scheduler=t,this.work=e}requestAsyncId(t,e,i=0){return null!==i&&i>0?super.requestAsyncId(t,e,i):(t.actions.push(this),t._scheduled||(t._scheduled=Im.requestAnimationFrame(()=>t.flush(void 0))))}recycleAsyncId(t,e,i=0){var r;if(null!=i?i>0:this.delay>0)return super.recycleAsyncId(t,e,i);let{actions:o}=t;null!=e&&(null===(r=o[o.length-1])||void 0===r?void 0:r.id)!==e&&(Im.cancelAnimationFrame(e),t._scheduled=void 0)}}),Jr=new Kt(n=>n.complete());function mC(n){return n&&_n(n.schedule)}function XA(n){return n[n.length-1]}function rc(n){return _n(XA(n))?n.pop():void 0}function oc(n){return mC(XA(n))?n.pop():void 0}var A4=WV(I4(),1),{__decorate:R4,__awaiter:P4,__await:bC,__asyncGenerator:O4,__asyncValues:k4}=A4.default,Pm=n=>n&&"number"==typeof n.length&&"function"!=typeof n;function vC(n){return _n(n?.then)}function yC(n){return _n(n[Dm])}function xC(n){return Symbol.asyncIterator&&_n(n?.[Symbol.asyncIterator])}function CC(n){return new TypeError(`You provided ${null!==n&&"object"==typeof n?"an invalid object":`'${n}'`} where a stream was expected. You can provide an Observable, Promise, ReadableStream, Array, AsyncIterable, or Iterable.`)}var MC="function"==typeof Symbol&&Symbol.iterator?Symbol.iterator:"@@iterator";function wC(n){return _n(n?.[MC])}function SC(n){return O4(this,arguments,function*(){let e=n.getReader();try{for(;;){let{value:i,done:r}=yield bC(e.read());if(r)return yield bC(void 0);yield yield bC(i)}}finally{e.releaseLock()}})}function EC(n){return _n(n?.getReader)}function ii(n){if(n instanceof Kt)return n;if(null!=n){if(yC(n))return function(n){return new Kt(t=>{let e=n[Dm]();if(_n(e.subscribe))return e.subscribe(t);throw new TypeError("Provided object does not correctly implement Symbol.observable")})}(n);if(Pm(n))return function(n){return new Kt(t=>{for(let e=0;e<n.length&&!t.closed;e++)t.next(n[e]);t.complete()})}(n);if(vC(n))return function(n){return new Kt(t=>{n.then(e=>{t.closed||(t.next(e),t.complete())},e=>t.error(e)).then(null,rC)})}(n);if(xC(n))return F4(n);if(wC(n))return function(n){return new Kt(t=>{for(let e of n)if(t.next(e),t.closed)return;t.complete()})}(n);if(EC(n))return function(n){return F4(SC(n))}(n)}throw CC(n)}function F4(n){return new Kt(t=>{(function(n,t){var e,i,r,o;return P4(this,void 0,void 0,function*(){try{for(e=k4(n);!(i=yield e.next()).done;)if(t.next(i.value),t.closed)return}catch(s){r={error:s}}finally{try{i&&!i.done&&(o=e.return)&&(yield o.call(e))}finally{if(r)throw r.error}}t.complete()})})(n,t).catch(e=>t.error(e))})}function xs(n,t,e,i=0,r=!1){let o=t.schedule(function(){e(),r?n.add(this.schedule(null,i)):this.unsubscribe()},i);if(n.add(o),!r)return o}function Pp(n,t=0){return qt((e,i)=>{e.subscribe(Vt(i,r=>xs(i,n,()=>i.next(r),t),()=>xs(i,n,()=>i.complete(),t),r=>xs(i,n,()=>i.error(r),t)))})}function TC(n,t=0){return qt((e,i)=>{i.add(n.schedule(()=>e.subscribe(i),t))})}function DC(n,t){if(!n)throw new Error("Iterable cannot be null");return new Kt(e=>{xs(e,t,()=>{let i=n[Symbol.asyncIterator]();xs(e,t,()=>{i.next().then(r=>{r.done?e.complete():e.next(r.value)})},0,!0)})})}function $r(n,t){return t?function(n,t){if(null!=n){if(yC(n))return function(n,t){return ii(n).pipe(TC(t),Pp(t))}(n,t);if(Pm(n))return function(n,t){return new Kt(e=>{let i=0;return t.schedule(function(){i===n.length?e.complete():(e.next(n[i++]),e.closed||this.schedule())})})}(n,t);if(vC(n))return function(n,t){return ii(n).pipe(TC(t),Pp(t))}(n,t);if(xC(n))return DC(n,t);if(wC(n))return function(n,t){return new Kt(e=>{let i;return xs(e,t,()=>{i=n[MC](),xs(e,t,()=>{let r,o;try{({value:r,done:o}=i.next())}catch(s){return void e.error(s)}o?e.complete():e.next(r)},0,!0)}),()=>_n(i?.return)&&i.return()})}(n,t);if(EC(n))return function(n,t){return DC(SC(n),t)}(n,t)}throw CC(n)}(n,t):ii(n)}function Ht(...n){return $r(n,oc(n))}function ea(n,t){let e=_n(n)?n:()=>n,i=r=>r.error(e());return new Kt(t?r=>t.schedule(i,0,r):i)}var wa=class{constructor(t,e,i){this.kind=t,this.value=e,this.error=i,this.hasValue="N"===t}observe(t){return ZA(this,t)}do(t,e,i){let{kind:r,value:o,error:s}=this;return"N"===r?t?.(o):"E"===r?e?.(s):i?.()}accept(t,e,i){var r;return _n(null===(r=t)||void 0===r?void 0:r.next)?this.observe(t):this.do(t,e,i)}toObservable(){let{kind:t,value:e,error:i}=this,r="N"===t?Ht(e):"E"===t?ea(()=>i):"C"===t?Jr:0;if(!r)throw new TypeError(`Unexpected notification kind ${t}`);return r}static createNext(t){return new wa("N",t)}static createError(t){return new wa("E",void 0,t)}static createComplete(){return wa.completeNotification}};function ZA(n,t){var e,i,r;let{kind:o,value:s,error:a}=n;if("string"!=typeof o)throw new TypeError('Invalid notification, missing "kind"');"N"===o?null===(e=t.next)||void 0===e||e.call(t,s):"E"===o?null===(i=t.error)||void 0===i||i.call(t,a):null===(r=t.complete)||void 0===r||r.call(t)}function D_(n){return!!n&&(n instanceof Kt||_n(n.lift)&&_n(n.subscribe))}wa.completeNotification=new wa("C");var Om=Sm(n=>function(){n(this),this.name="EmptyError",this.message="no elements in sequence"});function IC(n,t){let e="object"==typeof t;return new Promise((i,r)=>{let o=new ml({next:s=>{i(s),o.unsubscribe()},error:r,complete:()=>{e?i(t.defaultValue):r(new Om)}});n.subscribe(o)})}function N(n,t){return qt((e,i)=>{let r=0;e.subscribe(Vt(i,o=>{i.next(n.call(t,o,r++))}))})}var{isArray:Zie}=Array;function Kd(n){return N(t=>function(n,t){return Zie(t)?n(...t):n(t)}(n,t))}var{isArray:Jie}=Array,{getPrototypeOf:$ie,prototype:ere,keys:tre}=Object;function AC(n){if(1===n.length){let t=n[0];if(Jie(t))return{args:t,keys:null};if(function(n){return n&&"object"==typeof n&&$ie(n)===ere}(t)){let e=tre(t);return{args:e.map(i=>t[i]),keys:e}}}return{args:n,keys:null}}function RC(n,t){return n.reduce((e,i,r)=>(e[i]=t[r],e),{})}function dn(...n){let t=oc(n),e=rc(n),{args:i,keys:r}=AC(n);if(0===i.length)return $r([],t);let o=new Kt(KA(i,t,r?s=>RC(r,s):is));return e?o.pipe(Kd(e)):o}function KA(n,t,e=is){return i=>{j4(t,()=>{let{length:r}=n,o=new Array(r),s=r,a=r;for(let l=0;l<r;l++)j4(t,()=>{let c=$r(n[l],t),d=!1;c.subscribe(Vt(i,u=>{o[l]=u,d||(d=!0,a--),a||i.next(e(o.slice()))},()=>{--s||i.complete()}))},i)},i)}}function j4(n,t,e){n?xs(e,n,t):t()}function hn(n,t,e=1/0){return _n(t)?hn((i,r)=>N((o,s)=>t(i,o,r,s))(ii(n(i,r))),e):("number"==typeof t&&(e=t),qt((i,r)=>function(n,t,e,i,r,o,s,a){let l=[],c=0,d=0,u=!1,p=()=>{u&&!l.length&&!c&&t.complete()},f=b=>c<i?m(b):l.push(b),m=b=>{c++;let M=!1;ii(e(b,d++)).subscribe(Vt(t,y=>{t.next(y)},()=>{M=!0},void 0,()=>{if(M)try{for(c--;l.length&&c<i;){let y=l.shift();m(y)}p()}catch(y){t.error(y)}}))};return n.subscribe(Vt(t,f,()=>{u=!0,p()})),()=>{}}(i,r,n,e)))}function PC(n=1/0){return hn(is,n)}function Jd(...n){return PC(1)($r(n,oc(n)))}function ta(n){return new Kt(t=>{ii(n()).subscribe(t)})}function co(...n){let t=rc(n),{args:e,keys:i}=AC(n),r=new Kt(o=>{let{length:s}=e;if(!s)return void o.complete();let a=new Array(s),l=s,c=s;for(let d=0;d<s;d++){let u=!1;ii(e[d]).subscribe(Vt(o,p=>{u||(u=!0,c--),a[d]=p},()=>l--,void 0,()=>{(!l||!u)&&(c||o.next(i?RC(i,a):a),o.complete())}))}});return t?r.pipe(Kd(t)):r}var ire=["addListener","removeListener"],rre=["addEventListener","removeEventListener"],ore=["on","off"];function mi(n,t,e,i){if(_n(e)&&(i=e,e=void 0),i)return mi(n,t,e).pipe(Kd(i));let[r,o]=function(n){return _n(n.addEventListener)&&_n(n.removeEventListener)}(n)?rre.map(s=>a=>n[s](t,a,e)):function(n){return _n(n.addListener)&&_n(n.removeListener)}(n)?ire.map(q4(n,t)):function(n){return _n(n.on)&&_n(n.off)}(n)?ore.map(q4(n,t)):[];if(!r&&Pm(n))return hn(s=>mi(s,t,e))(ii(n));if(!r)throw new TypeError("Invalid event target");return new Kt(s=>{let a=(...l)=>s.next(1<l.length?l:l[0]);return r(a),()=>o(a)})}function q4(n,t){return e=>i=>n[e](t,i)}function na(n=0,t,e=n4){let i=-1;return null!=t&&(mC(t)?e=t:i=t),new Kt(r=>{let o=function(n){return n instanceof Date&&!isNaN(n)}(n)?+n-e.now():n;o<0&&(o=0);let s=0;return e.schedule(function(){r.closed||(r.next(s++),0<=i?this.schedule(void 0,i):r.complete())},o)})}function tn(...n){let t=oc(n),e=function(n,t){return"number"==typeof XA(n)?n.pop():1/0}(n),i=n;return i.length?1===i.length?ii(i[0]):PC(e)($r(i,t)):Jr}var{isArray:cre}=Array;function OC(n){return 1===n.length&&cre(n[0])?n[0]:n}function ke(n,t){return qt((e,i)=>{let r=0;e.subscribe(Vt(i,o=>n.call(t,o,r++)&&i.next(o)))})}function sc(n,t=Jc){return function(n){return qt((t,e)=>{let i=!1,r=null,o=null,s=!1,a=()=>{if(o?.unsubscribe(),o=null,i){i=!1;let c=r;r=null,e.next(c)}s&&e.complete()},l=()=>{o=null,s&&e.complete()};t.subscribe(Vt(e,c=>{i=!0,r=c,o||ii(n()).subscribe(o=Vt(e,a,l))},()=>{s=!0,(!i||!o||o.closed)&&e.complete()}))})}(()=>na(n,t))}function zr(n){return qt((t,e)=>{let o,i=null,r=!1;i=t.subscribe(Vt(e,void 0,void 0,s=>{o=ii(n(s,zr(n)(t))),i?(i.unsubscribe(),i=null,o.subscribe(e)):r=!0})),r&&(i.unsubscribe(),i=null,o.subscribe(e))})}function eR(...n){let t=rc(n);return t?function(...n){return UA(n)}(eR(...n),Kd(t)):qt((e,i)=>{KA([e,...OC(n)])(i)})}function Li(...n){return eR(...n)}function wr(n,t=Jc){return qt((e,i)=>{let r=null,o=null,s=null,a=()=>{if(r){r.unsubscribe(),r=null;let c=o;o=null,i.next(c)}};function l(){let c=s+n,d=t.now();if(d<c)return r=this.schedule(void 0,c-d),void i.add(r);a()}e.subscribe(Vt(i,c=>{o=c,s=t.now(),r||(r=t.schedule(l,n),i.add(r))},()=>{a(),i.complete()},void 0,()=>{o=r=null}))})}function Yt(n){return n<=0?()=>Jr:qt((t,e)=>{let i=0;t.subscribe(Vt(e,r=>{++i<=n&&(e.next(r),n<=i&&e.complete())}))})}function I_(){return qt((n,t)=>{n.subscribe(Vt(t,fl))})}function km(n,t){return t?e=>Jd(t.pipe(Yt(1),I_()),e.pipe(km(n))):hn((e,i)=>n(e,i).pipe(Yt(1),function(n){return N(()=>n)}(e)))}function Sa(n,t=Jc){let e=na(n,t);return km(()=>e)}function Yn(n,t=is){return n=n??dre,qt((e,i)=>{let r,o=!0;e.subscribe(Vt(i,s=>{let a=t(s);(o||!n(r,a))&&(o=!1,r=a,i.next(s))}))})}function dre(n,t){return n===t}function K4(n=ure){return qt((t,e)=>{let i=!1;t.subscribe(Vt(e,r=>{i=!0,e.next(r)},()=>i?e.complete():e.error(n())))})}function ure(){return new Om}function FC(n,t){return t?e=>e.pipe(FC((i,r)=>ii(n(i,r)).pipe(N((o,s)=>t(i,o,r,s))))):qt((e,i)=>{let r=0,o=null,s=!1;e.subscribe(Vt(i,a=>{o||(o=Vt(i,void 0,()=>{o=null,s&&i.complete()}),ii(n(a,r++)).subscribe(o))},()=>{s=!0,!o&&i.complete()}))})}function LC(n,t,e,i){return qt((r,o)=>{let s;t&&"function"!=typeof t?({duration:e,element:s,connector:i}=t):s=t;let a=new Map,l=m=>{a.forEach(m),m(o)},c=m=>l(b=>b.error(m)),d=0,u=!1,p=new M_(o,m=>{try{let b=n(m),M=a.get(b);if(!M){a.set(b,M=i?i():new Ie);let y=function(m,b){let M=new Kt(y=>{d++;let x=b.subscribe(y);return()=>{x.unsubscribe(),0==--d&&u&&p.unsubscribe()}});return M.key=m,M}(b,M);if(o.next(y),e){let x=Vt(M,()=>{M.complete(),x?.unsubscribe()},void 0,void 0,()=>a.delete(b));p.add(ii(e(y)).subscribe(x))}}M.next(s?s(m):m)}catch(b){c(b)}},()=>l(m=>m.complete()),c,()=>a.clear(),()=>(u=!0,0===d));r.subscribe(p)})}function Fm(){return qt((n,t)=>{let e,i=!1;n.subscribe(Vt(t,r=>{let o=e;e=r,i&&t.next([o,r]),i=!0}))})}function Cs(n={}){let{connector:t=(()=>new Ie),resetOnError:e=!0,resetOnComplete:i=!0,resetOnRefCountZero:r=!0}=n;return o=>{let s,a,l,c=0,d=!1,u=!1,p=()=>{a?.unsubscribe(),a=void 0},f=()=>{p(),s=l=void 0,d=u=!1},m=()=>{let b=s;f(),b?.unsubscribe()};return qt((b,M)=>{c++,!u&&!d&&p();let y=l=l??t();M.add(()=>{c--,0===c&&!u&&!d&&(a=aR(m,r))}),y.subscribe(M),!s&&c>0&&(s=new ml({next:x=>y.next(x),error:x=>{u=!0,p(),a=aR(f,e,x),y.error(x)},complete:()=>{d=!0,p(),a=aR(f,i),y.complete()}}),ii(b).subscribe(s))})(o)}}function aR(n,t,...e){if(!0===t)return void n();if(!1===t)return;let i=new ml({next:()=>{i.unsubscribe(),n()}});return t(...e).subscribe(i)}function Ms(n,t,e){let i,r=!1;return n&&"object"==typeof n?({bufferSize:i=1/0,windowTime:t=1/0,refCount:r=!1,scheduler:e}=n):i=n??1/0,Cs({connector:()=>new Rp(i,t,e),resetOnError:!0,resetOnComplete:!1,resetOnRefCountZero:r})}function ia(n){return ke((t,e)=>n<=e)}function qn(...n){let t=oc(n);return qt((e,i)=>{(t?Jd(n,e,t):Jd(n,e)).subscribe(i)})}function Jn(n,t){return qt((e,i)=>{let r=null,o=0,s=!1,a=()=>s&&!r&&i.complete();e.subscribe(Vt(i,l=>{r?.unsubscribe();let c=0,d=o++;ii(n(l,d)).subscribe(r=Vt(i,u=>i.next(t?t(l,u,d,c++):u),()=>{r=null,a()}))},()=>{s=!0,a()}))})}function ot(n){return qt((t,e)=>{ii(n).subscribe(Vt(e,()=>e.complete(),fl)),!e.closed&&t.subscribe(e)})}function A_(n,t=!1){return qt((e,i)=>{let r=0;e.subscribe(Vt(i,o=>{let s=n(o,r++);(s||t)&&i.next(o),!s&&i.complete()}))})}function Nt(n,t,e){let i=_n(n)||t||e?{next:n,error:t,complete:e}:n;return i?qt((r,o)=>{var s;null===(s=i.subscribe)||void 0===s||s.call(i);let a=!0;r.subscribe(Vt(o,l=>{var c;null===(c=i.next)||void 0===c||c.call(i,l),o.next(l)},()=>{var l;a=!1,null===(l=i.complete)||void 0===l||l.call(i),o.complete()},l=>{var c;a=!1,null===(c=i.error)||void 0===c||c.call(i,l),o.error(l)},()=>{var l,c;a&&(null===(l=i.unsubscribe)||void 0===l||l.call(i)),null===(c=i.finalize)||void 0===c||c.call(i)}))}):is}var lR={leading:!0,trailing:!1};function ac(n,t=Jc,e=lR){let i=na(n,t);return function(n,t=lR){return qt((e,i)=>{let{leading:r,trailing:o}=t,s=!1,a=null,l=null,c=!1,d=()=>{l?.unsubscribe(),l=null,o&&(f(),c&&i.complete())},u=()=>{l=null,c&&i.complete()},p=m=>l=ii(n(m)).subscribe(Vt(i,d,u)),f=()=>{if(s){s=!1;let m=a;a=null,i.next(m),!c&&p(m)}};e.subscribe(Vt(i,m=>{s=!0,a=m,(!l||l.closed)&&(r?f():p(m))},()=>{c=!0,(!(o&&s&&l)||l.closed)&&i.complete()}))})}(()=>i,e)}function Bt(...n){let t=rc(n);return qt((e,i)=>{let r=n.length,o=new Array(r),s=n.map(()=>!1),a=!1;for(let l=0;l<r;l++)ii(n[l]).subscribe(Vt(i,c=>{o[l]=c,!a&&!s[l]&&(s[l]=!0,(a=s.every(is))&&(s=null))},fl));e.subscribe(Vt(i,l=>{if(a){let c=[l,...o];i.next(t?t(...c):c)}}))})}function tr(n){for(let t in n)if(n[t]===tr)return t;throw Error("Could not find renamed property on target object.")}function cR(n,t){for(let e in t)t.hasOwnProperty(e)&&!n.hasOwnProperty(e)&&(n[e]=t[e])}function po(n){if("string"==typeof n)return n;if(Array.isArray(n))return"["+n.map(po).join(", ")+"]";if(null==n)return""+n;if(n.overriddenName)return`${n.overriddenName}`;if(n.name)return`${n.name}`;let t=n.toString();if(null==t)return""+t;let e=t.indexOf("\n");return-1===e?t:t.substring(0,e)}function AR(n,t){return null==n||""===n?null===t?"":t:null==t||""===t?n:n+" "+t}var pre=tr({__forward_ref__:tr});function $n(n){return n.__forward_ref__=$n,n.toString=function(){return po(this())},n}function Ri(n){return YH(n)?n():n}function YH(n){return"function"==typeof n&&n.hasOwnProperty(pre)&&n.__forward_ref__===$n}function XH(n){return n&&!!n.\u0275providers}var tb="https://g.co/ng/security#xss",yt=class extends Error{constructor(t,e){super(function(n,t){return`NG0${Math.abs(n)}${t?": "+t.trim():""}`}(t,e)),this.code=t}};function Un(n){return"string"==typeof n?n:null==n?"":String(n)}function LP(n){return"function"==typeof n?n.name||n.toString():"object"==typeof n&&null!=n&&"function"==typeof n.type?n.type.name||n.type.toString():Un(n)}function BP(n,t){throw new yt(-201,!1)}function QH(n,t,e,i){throw new Error(`ASSERTION ERROR: ${n}`+(null==i?"":` [Expected=> ${e} ${i} ${t} <=Actual]`))}function ue(n){return{token:n.token,providedIn:n.providedIn||null,factory:n.factory,value:void 0}}function U(n){return{providers:n.providers||[],imports:n.imports||[]}}function VP(n){return $4(n,JC)||$4(n,ZH)}function $4(n,t){return n.hasOwnProperty(t)?n[t]:null}function eH(n){return n&&(n.hasOwnProperty(RR)||n.hasOwnProperty(_re))?n[RR]:null}var PR,JC=tr({"\u0275prov":tr}),RR=tr({"\u0275inj":tr}),ZH=tr({ngInjectableDef:tr}),_re=tr({ngInjectorDef:tr}),xi=(()=>{return(n=xi||(xi={}))[n.Default=0]="Default",n[n.Host=1]="Host",n[n.Self=2]="Self",n[n.SkipSelf=4]="SkipSelf",n[n.Optional=8]="Optional",xi;var n})();function Ea(n){let t=PR;return PR=n,t}function KH(n,t,e){let i=VP(n);return i&&"root"==i.providedIn?void 0===i.value?i.value=i.factory():i.value:e&xi.Optional?null:void 0!==t?t:void BP(po(n))}var O_,Ur=(()=>typeof globalThis<"u"&&globalThis||typeof global<"u"&&global||typeof window<"u"&&window||typeof self<"u"&&typeof WorkerGlobalScope<"u"&&self instanceof WorkerGlobalScope&&self)(),j_={},OR="__NG_DI_FLAG__",$C="ngTempTokenPath",yre="ngTokenPath",xre=/\n/gm,Cre="\u0275",tH="__source";function Nm(n){let t=O_;return O_=n,t}function Mre(n,t=xi.Default){if(void 0===O_)throw new yt(-203,!1);return null===O_?KH(n,void 0,t):O_.get(n,t&xi.Optional?null:void 0,t)}function k(n,t=xi.Default){return(PR||Mre)(Ri(n),t)}function JH(n){throw new yt(202,!1)}function ai(n,t=xi.Default){return k(n,wM(t))}function wM(n){return typeof n>"u"||"number"==typeof n?n:0|(n.optional&&8)|(n.host&&1)|(n.self&&2)|(n.skipSelf&&4)}function kR(n){let t=[];for(let e=0;e<n.length;e++){let i=Ri(n[e]);if(Array.isArray(i)){if(0===i.length)throw new yt(900,!1);let r,o=xi.Default;for(let s=0;s<i.length;s++){let a=i[s],l=wre(a);"number"==typeof l?-1===l?r=a.token:o|=l:r=a}t.push(k(r,o))}else t.push(k(i))}return t}function nb(n,t){return n[OR]=t,n.prototype[OR]=t,n}function wre(n){return n[OR]}function ou(n){return{toString:n}.toString()}var k_=(()=>{return(n=k_||(k_={}))[n.OnPush=0]="OnPush",n[n.Default=1]="Default",k_;var n})(),ra=(()=>{return(n=ra||(ra={}))[n.Emulated=0]="Emulated",n[n.None=2]="None",n[n.ShadowDom=3]="ShadowDom",ra;var n})(),$c={},Vi=[],SM=tr({"\u0275cmp":tr}),HP=tr({"\u0275dir":tr}),zP=tr({"\u0275pipe":tr}),$H=tr({"\u0275mod":tr}),ed=tr({"\u0275fac":tr}),F_=tr({__NG_ELEMENT_ID__:tr}),Tre=0;function O(n){return ou(()=>{let t=t5(n),e={...t,decls:n.decls,vars:n.vars,template:n.template,consts:n.consts||null,ngContentSelectors:n.ngContentSelectors,onPush:n.changeDetection===k_.OnPush,directiveDefs:null,pipeDefs:null,dependencies:t.standalone&&n.dependencies||null,getStandaloneInjector:null,data:n.data||{},encapsulation:n.encapsulation||ra.Emulated,id:"c"+Tre++,styles:n.styles||Vi,_:null,schemas:n.schemas||null,tView:null};n5(e);let i=n.dependencies;return e.directiveDefs=eM(i,!1),e.pipeDefs=eM(i,!0),e})}function ib(n,t,e){let i=n.\u0275cmp;i.directiveDefs=eM(t,!1),i.pipeDefs=eM(e,!0)}function Dre(n){return Da(n)||tu(n)}function Ire(n){return null!==n}function G(n){return ou(()=>({type:n.type,bootstrap:n.bootstrap||Vi,declarations:n.declarations||Vi,imports:n.imports||Vi,exports:n.exports||Vi,transitiveCompileScopes:null,schemas:n.schemas||null,id:n.id||null}))}function nH(n,t){if(null==n)return $c;let e={};for(let i in n)if(n.hasOwnProperty(i)){let r=n[i],o=r;Array.isArray(r)&&(o=r[1],r=r[0]),e[r]=i,t&&(t[r]=o)}return e}function we(n){return ou(()=>{let t=t5(n);return n5(t),t})}function Km(n){return{type:n.type,name:n.name,factory:null,pure:!1!==n.pure,standalone:!0===n.standalone,onDestroy:n.type.prototype.ngOnDestroy||null}}function Da(n){return n[SM]||null}function tu(n){return n[HP]||null}function nu(n){return n[zP]||null}function e5(n){let t=Da(n)||tu(n)||nu(n);return null!==t&&t.standalone}function Gm(n,t){let e=n[$H]||null;if(!e&&!0===t)throw new Error(`Type ${po(n)} does not have '\u0275mod' property.`);return e}function t5(n){let t={};return{type:n.type,providersResolver:null,factory:null,hostBindings:n.hostBindings||null,hostVars:n.hostVars||0,hostAttrs:n.hostAttrs||null,contentQueries:n.contentQueries||null,declaredInputs:t,exportAs:n.exportAs||null,standalone:!0===n.standalone,selectors:n.selectors||Vi,viewQuery:n.viewQuery||null,features:n.features||null,setInput:null,findHostDirectiveDefs:null,hostDirectives:null,inputs:nH(n.inputs,t),outputs:nH(n.outputs)}}function n5(n){n.features?.forEach(t=>t(n))}function eM(n,t){if(!n)return null;let e=t?nu:Dre;return()=>("function"==typeof n?n():n).map(i=>e(i)).filter(Ire)}var su=0,Fn=1,ri=2,Gr=3,_l=4,Fp=5,Ss=6,G_=7,Es=8,tM=9,nM=10,oi=11,FR=12,W_=13,iH=14,Jm=15,bl=16,rb=17,Lm=18,cc=19,EM=20,i5=21,Wr=22,UP=1,r5=2,jP=7,iM=8,Wm=9,ws=10;function Np(n){return Array.isArray(n)&&"object"==typeof n[UP]}function nd(n){return Array.isArray(n)&&!0===n[UP]}function GP(n){return 0!=(4&n.flags)}function TM(n){return n.componentOffset>-1}function DM(n){return 1==(1&n.flags)}function vl(n){return!!n.template}function Are(n){return 0!=(256&n[ri])}function Bp(n,t){return n.hasOwnProperty(ed)?n[ed]:null}var NR=class{constructor(t,e,i){this.previousValue=t,this.currentValue=e,this.firstChange=i}isFirstChange(){return this.firstChange}};function Gt(){return o5}function o5(n){return n.type.prototype.ngOnChanges&&(n.setInput=Pre),Rre}function Rre(){let n=a5(this),t=n?.current;if(t){let e=n.previous;if(e===$c)n.previous=t;else for(let i in t)e[i]=t[i];n.current=null,this.ngOnChanges(t)}}function Pre(n,t,e,i){let r=this.declaredInputs[e],o=a5(n)||function(n,t){return n[s5]=t}(n,{previous:$c,current:null}),s=o.current||(o.current={}),a=o.previous,l=a[r];s[r]=new NR(l&&l.currentValue,t,a===$c),n[i]=t}Gt.ngInherit=!0;var s5="__ngSimpleChanges__";function a5(n){return n[s5]||null}var Ta=function(n,t,e){},l5="svg",c5="math";function Ra(n){for(;Array.isArray(n);)n=n[su];return n}function IM(n,t){return Ra(t[n])}function oa(n,t){return Ra(t[n.index])}function d5(n,t){return n.data[t]}function $m(n,t){return n[t]}function id(n,t){let e=t[n];return Np(e)?e:e[su]}function rM(n){return 64==(64&n[ri])}function iu(n,t){return null==t?null:n[t]}function u5(n){n[Lm]=0}function WP(n,t){n[Fp]+=t;let e=n,i=n[Gr];for(;null!==i&&(1===t&&1===e[Fp]||-1===t&&0===e[Fp]);)i[Fp]+=t,e=i,i=i[Gr]}var jn={lFrame:v5(null),bindingsEnabled:!0};function p5(){return jn.bindingsEnabled}function Ze(){return jn.lFrame.lView}function Ei(){return jn.lFrame.tView}function X(n){return jn.lFrame.contextLView=n,n[Es]}function Q(n){return jn.lFrame.contextLView=null,n}function Po(){let n=f5();for(;null!==n&&64===n.type;)n=n.parent;return n}function f5(){return jn.lFrame.currentTNode}function q_(){let n=jn.lFrame,t=n.currentTNode;return n.isParent?t:t.parent}function dc(n,t){let e=jn.lFrame;e.currentTNode=n,e.isParent=t}function qP(){return jn.lFrame.isParent}function YP(){jn.lFrame.isParent=!1}function os(){let n=jn.lFrame,t=n.bindingRootIndex;return-1===t&&(t=n.bindingRootIndex=n.tView.bindingStartIndex),t}function rd(){return jn.lFrame.bindingIndex}function m5(n){return jn.lFrame.bindingIndex=n}function eh(){return jn.lFrame.bindingIndex++}function od(n){let t=jn.lFrame,e=t.bindingIndex;return t.bindingIndex=t.bindingIndex+n,e}function h5(n){jn.lFrame.inI18n=n}function Gre(n,t){let e=jn.lFrame;e.bindingIndex=e.bindingRootIndex=n,LR(t)}function LR(n){jn.lFrame.currentDirectiveIndex=n}function XP(n){let t=jn.lFrame.currentDirectiveIndex;return-1===t?null:n[t]}function g5(){return jn.lFrame.currentQueryIndex}function QP(n){jn.lFrame.currentQueryIndex=n}function qre(n){let t=n[Fn];return 2===t.type?t.declTNode:1===t.type?n[Ss]:null}function _5(n,t,e){if(e&xi.SkipSelf){let r=t,o=n;for(;!(r=r.parent,null!==r||e&xi.Host||(r=qre(o),null===r||(o=o[Jm],10&r.type))););if(null===r)return!1;t=r,n=o}let i=jn.lFrame=b5();return i.currentTNode=t,i.lView=n,!0}function ZP(n){let t=b5(),e=n[Fn];jn.lFrame=t,t.currentTNode=e.firstChild,t.lView=n,t.tView=e,t.contextLView=n,t.bindingIndex=e.bindingStartIndex,t.inI18n=!1}function b5(){let n=jn.lFrame,t=null===n?null:n.child;return null===t?v5(n):t}function v5(n){let t={currentTNode:null,isParent:!0,lView:null,tView:null,selectedIndex:-1,contextLView:null,elementDepthCount:0,currentNamespace:null,currentDirectiveIndex:-1,bindingRootIndex:-1,bindingIndex:-1,currentQueryIndex:0,parent:n,child:null,inI18n:!1};return null!==n&&(n.child=t),t}function y5(){let n=jn.lFrame;return jn.lFrame=n.parent,n.currentTNode=null,n.lView=null,n}var x5=y5;function KP(){let n=y5();n.isParent=!0,n.tView=null,n.selectedIndex=-1,n.contextLView=null,n.elementDepthCount=0,n.currentDirectiveIndex=-1,n.currentNamespace=null,n.bindingRootIndex=-1,n.bindingIndex=-1,n.currentQueryIndex=0}function ss(){return jn.lFrame.selectedIndex}function Vp(n){jn.lFrame.selectedIndex=n}function kr(){let n=jn.lFrame;return d5(n.tView,n.selectedIndex)}function Nn(){jn.lFrame.currentNamespace=l5}function Oo(){jn.lFrame.currentNamespace=null}function AM(n,t){for(let e=t.directiveStart,i=t.directiveEnd;e<i;e++){let o=n.data[e].type.prototype,{ngAfterContentInit:s,ngAfterContentChecked:a,ngAfterViewInit:l,ngAfterViewChecked:c,ngOnDestroy:d}=o;s&&(n.contentHooks??(n.contentHooks=[])).push(-e,s),a&&((n.contentHooks??(n.contentHooks=[])).push(e,a),(n.contentCheckHooks??(n.contentCheckHooks=[])).push(e,a)),l&&(n.viewHooks??(n.viewHooks=[])).push(-e,l),c&&((n.viewHooks??(n.viewHooks=[])).push(e,c),(n.viewCheckHooks??(n.viewCheckHooks=[])).push(e,c)),null!=d&&(n.destroyHooks??(n.destroyHooks=[])).push(e,d)}}function jC(n,t,e){C5(n,t,3,e)}function GC(n,t,e,i){(3&n[ri])===e&&C5(n,t,e,i)}function dR(n,t){let e=n[ri];(3&e)===t&&(e&=2047,e+=1,n[ri]=e)}function C5(n,t,e,i){let o=i??-1,s=t.length-1,a=0;for(let l=void 0!==i?65535&n[Lm]:0;l<s;l++)if("number"==typeof t[l+1]){if(a=t[l],null!=i&&a>=i)break}else t[l]<0&&(n[Lm]+=65536),(a<o||-1==o)&&($re(n,e,t,l),n[Lm]=(4294901760&n[Lm])+l+2),l++}function $re(n,t,e,i){let r=e[i]<0,o=e[i+1],a=n[r?-e[i]:e[i]];if(r){if(n[ri]>>11<n[Lm]>>16&&(3&n[ri])===t){n[ri]+=2048,Ta(4,a,o);try{o.call(a)}finally{Ta(5,a,o)}}}else{Ta(4,a,o);try{o.call(a)}finally{Ta(5,a,o)}}}var jm=-1,Hp=class{constructor(t,e,i){this.factory=t,this.resolving=!1,this.canSeeViewProviders=e,this.injectImpl=i}};function BR(n,t,e){let i=0;for(;i<e.length;){let r=e[i];if("number"==typeof r){if(0!==r)break;i++;let o=e[i++],s=e[i++],a=e[i++];n.setAttribute(t,s,a,o)}else{let o=r,s=e[++i];ioe(o)?n.setProperty(t,o,s):n.setAttribute(t,o,s),i++}}return i}function M5(n){return 3===n||4===n||6===n}function ioe(n){return 64===n.charCodeAt(0)}function Y_(n,t){if(null!==t&&0!==t.length)if(null===n||0===n.length)n=t.slice();else{let e=-1;for(let i=0;i<t.length;i++){let r=t[i];"number"==typeof r?e=r:0===e||oH(n,e,r,null,-1===e||2===e?t[++i]:null)}}return n}function oH(n,t,e,i,r){let o=0,s=n.length;if(-1===t)s=-1;else for(;o<n.length;){let a=n[o++];if("number"==typeof a){if(a===t){s=-1;break}if(a>t){s=o-1;break}}}for(;o<n.length;){let a=n[o];if("number"==typeof a)break;if(a===e){if(null===i)return void(null!==r&&(n[o+1]=r));if(i===n[o+1])return void(n[o+2]=r)}o++,null!==i&&o++,null!==r&&o++}-1!==s&&(n.splice(s,0,t),o=s+1),n.splice(o++,0,e),null!==i&&n.splice(o++,0,i),null!==r&&n.splice(o++,0,r)}function w5(n){return n!==jm}function oM(n){return 32767&n}function sM(n,t){let e=function(n){return n>>16}(n),i=t;for(;e>0;)i=i[Jm],e--;return i}var VR=!0;function aM(n){let t=VR;return VR=n,t}var S5=255,E5=5,soe=0,lc={};function lM(n,t){let e=T5(n,t);if(-1!==e)return e;let i=t[Fn];i.firstCreatePass&&(n.injectorIndex=t.length,uR(i.data,n),uR(t,null),uR(i.blueprint,null));let r=JP(n,t),o=n.injectorIndex;if(w5(r)){let s=oM(r),a=sM(r,t),l=a[Fn].data;for(let c=0;c<8;c++)t[o+c]=a[s+c]|l[s+c]}return t[o+8]=r,o}function uR(n,t){n.push(0,0,0,0,0,0,0,0,t)}function T5(n,t){return-1===n.injectorIndex||n.parent&&n.parent.injectorIndex===n.injectorIndex||null===t[n.injectorIndex+8]?-1:n.injectorIndex}function JP(n,t){if(n.parent&&-1!==n.parent.injectorIndex)return n.parent.injectorIndex;let e=0,i=null,r=t;for(;null!==r;){if(i=P5(r),null===i)return jm;if(e++,r=r[Jm],-1!==i.injectorIndex)return i.injectorIndex|e<<16}return jm}function HR(n,t,e){!function(n,t,e){let i;"string"==typeof e?i=e.charCodeAt(0)||0:e.hasOwnProperty(F_)&&(i=e[F_]),null==i&&(i=e[F_]=soe++);let r=i&S5;t.data[n+(r>>E5)]|=1<<r}(n,t,e)}function D5(n,t,e){if(e&xi.Optional||void 0!==n)return n;BP()}function I5(n,t,e,i){if(e&xi.Optional&&void 0===i&&(i=null),0==(e&(xi.Self|xi.Host))){let r=n[tM],o=Ea(void 0);try{return r?r.get(t,i,e&xi.Optional):KH(t,i,e&xi.Optional)}finally{Ea(o)}}return D5(i,0,e)}function A5(n,t,e,i=xi.Default,r){if(null!==n){if(1024&t[ri]){let s=function(n,t,e,i,r){let o=n,s=t;for(;null!==o&&null!==s&&1024&s[ri]&&!(256&s[ri]);){let a=R5(o,s,e,i|xi.Self,lc);if(a!==lc)return a;let l=o.parent;if(!l){let c=s[i5];if(c){let d=c.get(e,lc,i);if(d!==lc)return d}l=P5(s),s=s[Jm]}o=l}return r}(n,t,e,i,lc);if(s!==lc)return s}let o=R5(n,t,e,i,lc);if(o!==lc)return o}return I5(t,e,i,r)}function R5(n,t,e,i,r){let o=function(n){if("string"==typeof n)return n.charCodeAt(0)||0;let t=n.hasOwnProperty(F_)?n[F_]:void 0;return"number"==typeof t?t>=0?t&S5:uoe:t}(e);if("function"==typeof o){if(!_5(t,n,i))return i&xi.Host?D5(r,0,i):I5(t,e,i,r);try{let s=o(i);if(null!=s||i&xi.Optional)return s;BP()}finally{x5()}}else if("number"==typeof o){let s=null,a=T5(n,t),l=jm,c=i&xi.Host?t[bl][Ss]:null;for((-1===a||i&xi.SkipSelf)&&(l=-1===a?JP(n,t):t[a+8],l!==jm&&aH(i,!1)?(s=t[Fn],a=oM(l),t=sM(l,t)):a=-1);-1!==a;){let d=t[Fn];if(sH(o,a,d.data)){let u=coe(a,t,e,s,i,c);if(u!==lc)return u}l=t[a+8],l!==jm&&aH(i,t[Fn].data[a+8]===c)&&sH(o,a,t)?(s=d,a=oM(l),t=sM(l,t)):a=-1}}return r}function coe(n,t,e,i,r,o){let s=t[Fn],a=s.data[n+8],d=WC(a,s,e,null==i?TM(a)&&VR:i!=s&&0!=(3&a.type),r&xi.Host&&o===a);return null!==d?zp(t,s,d,a):lc}function WC(n,t,e,i,r){let o=n.providerIndexes,s=t.data,a=1048575&o,l=n.directiveStart,d=o>>20,p=r?a+d:n.directiveEnd;for(let f=i?a:a+d;f<p;f++){let m=s[f];if(f<l&&e===m||f>=l&&m.type===e)return f}if(r){let f=s[l];if(f&&vl(f)&&f.type===e)return l}return null}function zp(n,t,e,i){let r=n[e],o=t.data;if(function(n){return n instanceof Hp}(r)){let s=r;s.resolving&&function(n,t){throw new yt(-200,`Circular dependency in DI detected for ${n}`)}(LP(o[e]));let a=aM(s.canSeeViewProviders);s.resolving=!0;let l=s.injectImpl?Ea(s.injectImpl):null;_5(n,i,xi.Default);try{r=n[e]=s.factory(void 0,o,n,i),t.firstCreatePass&&e>=i.directiveStart&&function(n,t,e){let{ngOnChanges:i,ngOnInit:r,ngDoCheck:o}=t.type.prototype;if(i){let s=o5(t);(e.preOrderHooks??(e.preOrderHooks=[])).push(n,s),(e.preOrderCheckHooks??(e.preOrderCheckHooks=[])).push(n,s)}r&&(e.preOrderHooks??(e.preOrderHooks=[])).push(0-n,r),o&&((e.preOrderHooks??(e.preOrderHooks=[])).push(n,o),(e.preOrderCheckHooks??(e.preOrderCheckHooks=[])).push(n,o))}(e,o[e],t)}finally{null!==l&&Ea(l),aM(a),s.resolving=!1,x5()}}return r}function sH(n,t,e){return!!(e[t+(n>>E5)]&1<<n)}function aH(n,t){return!(n&xi.Self||n&xi.Host&&t)}var Lp=class{constructor(t,e){this._tNode=t,this._lView=e}get(t,e,i){return A5(this._tNode,this._lView,t,wM(i),e)}};function uoe(){return new Lp(Po(),Ze())}function Xn(n){return ou(()=>{let t=n.prototype.constructor,e=t[ed]||zR(t),i=Object.prototype,r=Object.getPrototypeOf(n.prototype).constructor;for(;r&&r!==i;){let o=r[ed]||zR(r);if(o&&o!==e)return o;r=Object.getPrototypeOf(r)}return o=>new o})}function zR(n){return YH(n)?()=>{let t=zR(Ri(n));return t&&t()}:Bp(n)}function P5(n){let t=n[Fn],e=t.type;return 2===e?t.declTNode:1===e?n[Ss]:null}function yo(n){return function(n,t){if("class"===t)return n.classes;if("style"===t)return n.styles;let e=n.attrs;if(e){let i=e.length,r=0;for(;r<i;){let o=e[r];if(M5(o))break;if(0===o)r+=2;else if("number"==typeof o)for(r++;r<i&&"string"==typeof e[r];)r++;else{if(o===t)return e[r+1];r+=2}}}return null}(Po(),n)}var Bm="__annotations__",Vm="__parameters__",Hm="__prop__metadata__";function ob(n,t,e,i,r){return ou(()=>{let o=$P(t);function s(...a){if(this instanceof s)return o.call(this,...a),this;let l=new s(...a);return function(d){return r&&r(d,...a),(d.hasOwnProperty(Bm)?d[Bm]:Object.defineProperty(d,Bm,{value:[]})[Bm]).push(l),i&&i(d),d}}return e&&(s.prototype=Object.create(e.prototype)),s.prototype.ngMetadataName=n,s.annotationCls=s,s})}function $P(n){return function(...e){if(n){let i=n(...e);for(let r in i)this[r]=i[r]}}}function th(n,t,e){return ou(()=>{let i=$P(t);function r(...o){if(this instanceof r)return i.apply(this,o),this;let s=new r(...o);return a.annotation=s,a;function a(l,c,d){let u=l.hasOwnProperty(Vm)?l[Vm]:Object.defineProperty(l,Vm,{value:[]})[Vm];for(;u.length<=d;)u.push(null);return(u[d]=u[d]||[]).push(s),l}}return e&&(r.prototype=Object.create(e.prototype)),r.prototype.ngMetadataName=n,r.annotationCls=r,r})}function au(n,t,e,i){return ou(()=>{let r=$P(t);function o(...s){if(this instanceof o)return r.apply(this,s),this;let a=new o(...s);return function(c,d){let u=c.constructor,p=u.hasOwnProperty(Hm)?u[Hm]:Object.defineProperty(u,Hm,{value:{}})[Hm];p[d]=p.hasOwnProperty(d)&&p[d]||[],p[d].unshift(a),i&&i(c,d,...s)}}return e&&(o.prototype=Object.create(e.prototype)),o.prototype.ngMetadataName=n,o.annotationCls=o,o})}var foe=th("Attribute",n=>({attributeName:n,__NG_ELEMENT_ID__:()=>yo(n)})),ie=class{constructor(t,e){this._desc=t,this.ngMetadataName="InjectionToken",this.\u0275prov=void 0,"number"==typeof e?this.__NG_ELEMENT_ID__=e:void 0!==e&&(this.\u0275prov=ue({token:this,providedIn:e.providedIn||"root",factory:e.factory}))}get multi(){return this}toString(){return`InjectionToken ${this._desc}`}},qm=(new ie("AnalyzeForEntryComponents"),class{});function Ia(n){let t=Ur.ng;if(t&&t.\u0275compilerFacade)return t.\u0275compilerFacade;throw new Error("JIT compiler unavailable")}au("ContentChildren",(n,t={})=>({selector:n,first:!1,isViewQuery:!1,descendants:!1,emitDistinctChangesOnly:!0,...t}),qm),au("ContentChild",(n,t={})=>({selector:n,first:!0,isViewQuery:!1,descendants:!0,...t}),qm),au("ViewChildren",(n,t={})=>({selector:n,first:!1,isViewQuery:!0,descendants:!0,emitDistinctChangesOnly:!0,...t}),qm),au("ViewChild",(n,t)=>({selector:n,first:!0,isViewQuery:!0,descendants:!0,...t}),qm);var moe=Function;function R_(n){return"function"==typeof n}function $d(n){return n.flat(Number.POSITIVE_INFINITY)}function eO(n,t){n.forEach(e=>Array.isArray(e)?eO(e,t):t(e))}function k5(n,t,e){t>=n.length?n.push(e):n.splice(t,0,e)}function cM(n,t){return t>=n.length-1?n.pop():n.splice(t,1)[0]}function N_(n,t){let e=[];for(let i=0;i<n;i++)e.push(t);return e}function sa(n,t,e){let i=sb(n,t);return i>=0?n[1|i]=e:(i=~i,function(n,t,e,i){let r=n.length;if(r==t)n.push(e,i);else if(1===r)n.push(i,n[0]),n[0]=e;else{for(r--,n.push(n[r-1],n[r]);r>t;)n[r]=n[r-2],r--;n[t]=e,n[t+1]=i}}(n,i,t,e)),i}function pR(n,t){let e=sb(n,t);if(e>=0)return n[1|e]}function sb(n,t){return function(n,t,e){let i=0,r=n.length>>1;for(;r!==i;){let o=i+(r-i>>1),s=n[o<<1];if(t===s)return o<<1;s>t?r=o:i=o+1}return~(r<<1)}(n,t)}var boe=/^function\s+\S+\(\)\s*{[\s\S]+\.apply\(this,\s*(arguments|(?:[^()]+\(\[\],)?[^()]+\(arguments\).*)\)/,voe=/^class\s+[A-Za-z\d$_]*\s*extends\s+[^{]+{/,yoe=/^class\s+[A-Za-z\d$_]*\s*extends\s+[^{]+{[\s\S]*constructor\s*\(/,xoe=/^class\s+[A-Za-z\d$_]*\s*extends\s+[^{]+{[\s\S]*constructor\s*\(\)\s*{[^}]*super\(\.\.\.arguments\)/,UR=class{constructor(t){this._reflect=t||Ur.Reflect}factory(t){return(...e)=>new t(...e)}_zipTypesAndAnnotations(t,e){let i;i=N_(typeof t>"u"?e.length:t.length);for(let r=0;r<i.length;r++)i[r]=typeof t>"u"?[]:t[r]&&t[r]!=Object?[t[r]]:[],e&&null!=e[r]&&(i[r]=i[r].concat(e[r]));return i}_ownParameters(t,e){let i=t.toString();if(boe.test(n=i)||xoe.test(n)||voe.test(n)&&!yoe.test(n))return null;var n;if(t.parameters&&t.parameters!==e.parameters)return t.parameters;let r=t.ctorParameters;if(r&&r!==e.ctorParameters){let a="function"==typeof r?r():r,l=a.map(d=>d&&d.type),c=a.map(d=>d&&fR(d.decorators));return this._zipTypesAndAnnotations(l,c)}let o=t.hasOwnProperty(Vm)&&t[Vm],s=this._reflect&&this._reflect.getOwnMetadata&&this._reflect.getOwnMetadata("design:paramtypes",t);return s||o?this._zipTypesAndAnnotations(s,o):N_(t.length)}parameters(t){if(!R_(t))return[];let e=BC(t),i=this._ownParameters(t,e);return!i&&e!==Object&&(i=this.parameters(e)),i||[]}_ownAnnotations(t,e){if(t.annotations&&t.annotations!==e.annotations){let i=t.annotations;return"function"==typeof i&&i.annotations&&(i=i.annotations),i}return t.decorators&&t.decorators!==e.decorators?fR(t.decorators):t.hasOwnProperty(Bm)?t[Bm]:null}annotations(t){if(!R_(t))return[];let e=BC(t),i=this._ownAnnotations(t,e)||[];return(e!==Object?this.annotations(e):[]).concat(i)}_ownPropMetadata(t,e){if(t.propMetadata&&t.propMetadata!==e.propMetadata){let i=t.propMetadata;return"function"==typeof i&&i.propMetadata&&(i=i.propMetadata),i}if(t.propDecorators&&t.propDecorators!==e.propDecorators){let i=t.propDecorators,r={};return Object.keys(i).forEach(o=>{r[o]=fR(i[o])}),r}return t.hasOwnProperty(Hm)?t[Hm]:null}propMetadata(t){if(!R_(t))return{};let e=BC(t),i={};if(e!==Object){let o=this.propMetadata(e);Object.keys(o).forEach(s=>{i[s]=o[s]})}let r=this._ownPropMetadata(t,e);return r&&Object.keys(r).forEach(o=>{let s=[];i.hasOwnProperty(o)&&s.push(...i[o]),s.push(...r[o]),i[o]=s}),i}ownPropMetadata(t){return R_(t)&&this._ownPropMetadata(t,BC(t))||{}}hasLifecycleHook(t,e){return t instanceof moe&&e in t.prototype}};function fR(n){return n?n.map(t=>new(0,t.type.annotationCls)(...t.args?t.args:[])):[]}function BC(n){let t=n.prototype?Object.getPrototypeOf(n.prototype):null;return(t?t.constructor:null)||Object}var nh=nb(th("Inject",n=>({token:n})),-1),Ts=nb(th("Optional"),8),Moe=nb(th("Self"),2),sd=nb(th("SkipSelf"),4),woe=nb(th("Host"),1),lH=null;function tO(){return lH=lH||new UR}function RM(n){return F5(tO().parameters(n))}function F5(n){return n.map(t=>function(n){let t={token:null,attribute:null,host:!1,optional:!1,self:!1,skipSelf:!1};if(Array.isArray(n)&&n.length>0)for(let e=0;e<n.length;e++){let i=n[e];if(void 0===i)continue;let r=Object.getPrototypeOf(i);if(i instanceof Ts||"Optional"===r.ngMetadataName)t.optional=!0;else if(i instanceof sd||"SkipSelf"===r.ngMetadataName)t.skipSelf=!0;else if(i instanceof Moe||"Self"===r.ngMetadataName)t.self=!0;else if(i instanceof woe||"Host"===r.ngMetadataName)t.host=!0;else if(i instanceof nh)t.token=i.token;else if(i instanceof foe){if(void 0===i.attributeName)throw new yt(204,!1);t.attribute=i.attributeName}else t.token=i}else t.token=void 0===n||Array.isArray(n)&&0===n.length?null:n;return t}(t))}var X_=new Map,N5=new Set;function L5(n){return!!(n.templateUrl&&!n.hasOwnProperty("template")||n.styleUrls&&n.styleUrls.length)}var cH=new Map,Poe=!0;function B5(n,t){(function(n,t,e){if(t&&t!==e&&Poe)throw new Error(`Duplicate module registered for ${n} - ${po(t)} vs ${po(t.name)}`)})(t,cH.get(t)||null,n),cH.set(t,n)}var jR,Aa=(()=>{return(n=Aa||(Aa={}))[n.Important=1]="Important",n[n.DashCase=2]="DashCase",Aa;var n})(),koe=/^>|^->|<!--|-->|--!>|<!-$/g,Foe=/(<|>)/,Noe="\u200b$1\u200b",V5=new Map,Boe=0,dH="__ngContext__";function uc(n,t){Np(t)?(n[dH]=t[EM],function(n){V5.set(n[EM],n)}(t)):n[dH]=t}function nO(n,t){return jR(n,t)}function iO(n){let t=n[Gr];return nd(t)?t[Gr]:t}function rO(n){return H5(n[W_])}function oO(n){return H5(n[_l])}function H5(n){for(;null!==n&&!nd(n);)n=n[_l];return n}function zm(n,t,e,i,r){if(null!=i){let o,s=!1;nd(i)?o=i:Np(i)&&(s=!0,i=i[su]);let a=Ra(i);0===n&&null!==e?null==r?q5(t,e,a):Up(t,e,a,r||null,!0):1===n&&null!==e?Up(t,e,a,r||null,!0):2===n?lO(t,a,s):3===n&&t.destroyNode(a),null!=o&&function(n,t,e,i,r){let o=e[jP];o!==Ra(e)&&zm(t,n,i,o,r);for(let a=ws;a<e.length;a++){let l=e[a];ab(l[Fn],l,n,t,i,o)}}(t,n,o,e,r)}}function sO(n,t){return n.createText(t)}function z5(n,t,e){n.setValue(t,e)}function joe(n,t){return n.createComment(function(n){return n.replace(koe,t=>t.replace(Foe,Noe))}(t))}function aO(n,t,e){return n.createElement(t,e)}function U5(n,t){let e=n[Wm],i=e.indexOf(t),r=t[Gr];512&t[ri]&&(t[ri]&=-513,WP(r,-1)),e.splice(i,1)}function GR(n,t){if(n.length<=ws)return;let e=ws+t,i=n[e];if(i){let r=i[rb];null!==r&&r!==n&&U5(r,i),t>0&&(n[e-1][_l]=i[_l]);let o=cM(n,ws+t);!function(n,t){ab(n,t,t[oi],2,null,null),t[su]=null,t[Ss]=null}(i[Fn],i);let s=o[cc];null!==s&&s.detachView(o[Fn]),i[Gr]=null,i[_l]=null,i[ri]&=-65}return i}function j5(n,t){if(!(128&t[ri])){let e=t[oi];e.destroyNode&&ab(n,t,e,3,null,null),function(n){let t=n[W_];if(!t)return mR(n[Fn],n);for(;t;){let e=null;if(Np(t))e=t[W_];else{let i=t[ws];i&&(e=i)}if(!e){for(;t&&!t[_l]&&t!==n;)Np(t)&&mR(t[Fn],t),t=t[Gr];null===t&&(t=n),Np(t)&&mR(t[Fn],t),e=t&&t[_l]}t=e}}(t)}}function mR(n,t){if(!(128&t[ri])){t[ri]&=-65,t[ri]|=128,function(n,t){let e;if(null!=n&&null!=(e=n.destroyHooks))for(let i=0;i<e.length;i+=2){let r=t[e[i]];if(!(r instanceof Hp)){let o=e[i+1];if(Array.isArray(o))for(let s=0;s<o.length;s+=2){let a=r[o[s]],l=o[s+1];Ta(4,a,l);try{l.call(a)}finally{Ta(5,a,l)}}else{Ta(4,r,o);try{o.call(r)}finally{Ta(5,r,o)}}}}}(n,t),function(n,t){let e=n.cleanup,i=t[G_],r=-1;if(null!==e)for(let o=0;o<e.length-1;o+=2)if("string"==typeof e[o]){let s=e[o+3];s>=0?i[r=s]():i[r=-s].unsubscribe(),o+=2}else{let s=i[r=e[o+1]];e[o].call(s)}if(null!==i){for(let o=r+1;o<i.length;o++)(0,i[o])();t[G_]=null}}(n,t),1===t[Fn].type&&t[oi].destroy();let e=t[rb];if(null!==e&&nd(t[Gr])){e!==t[Gr]&&U5(e,t);let i=t[cc];null!==i&&i.detachView(n)}!function(n){V5.delete(n[EM])}(t)}}function G5(n,t,e){return W5(n,t.parent,e)}function W5(n,t,e){let i=t;for(;null!==i&&40&i.type;)i=(t=i).parent;if(null===i)return e[su];{let{componentOffset:r}=i;if(r>-1){let{encapsulation:o}=n.data[i.directiveStart+r];if(o===ra.None||o===ra.Emulated)return null}return oa(i,e)}}function Up(n,t,e,i,r){n.insertBefore(t,e,i,r)}function q5(n,t,e){n.appendChild(t,e)}function uH(n,t,e,i,r){null!==i?Up(n,t,e,i,r):q5(n,t,e)}function PM(n,t){return n.parentNode(t)}function Y5(n,t,e){return Q5(n,t,e)}function X5(n,t,e){return 40&n.type?oa(n,e):null}var WR,VC,YR,HC,Q5=X5;function Z5(n,t){Q5=n,WR=t}function OM(n,t,e,i){let r=G5(n,i,t),o=t[oi],a=Y5(i.parent||t[Ss],i,t);if(null!=r)if(Array.isArray(e))for(let l=0;l<e.length;l++)uH(o,r,e[l],a,!1);else uH(o,r,e,a,!1);void 0!==WR&&WR(o,i,t,e,r)}function qC(n,t){if(null!==t){let e=t.type;if(3&e)return oa(t,n);if(4&e)return qR(-1,n[t.index]);if(8&e){let i=t.child;if(null!==i)return qC(n,i);{let r=n[t.index];return nd(r)?qR(-1,r):Ra(r)}}if(32&e)return nO(t,n)()||Ra(n[t.index]);{let i=K5(n,t);return null!==i?Array.isArray(i)?i[0]:qC(iO(n[bl]),i):qC(n,t.next)}}return null}function K5(n,t){return null!==t?n[bl][Ss].projection[t.projection]:null}function qR(n,t){let e=ws+n+1;if(e<t.length){let i=t[e],r=i[Fn].firstChild;if(null!==r)return qC(i,r)}return t[jP]}function lO(n,t,e){let i=PM(n,t);i&&function(n,t,e,i){n.removeChild(t,e,i)}(n,i,t,e)}function cO(n,t,e,i,r,o,s){for(;null!=e;){let a=i[e.index],l=e.type;if(s&&0===t&&(a&&uc(Ra(a),i),e.flags|=2),32!=(32&e.flags))if(8&l)cO(n,t,e.child,i,r,o,!1),zm(t,n,r,a,o);else if(32&l){let d,c=nO(e,i);for(;d=c();)zm(t,n,r,d,o);zm(t,n,r,a,o)}else 16&l?J5(n,t,i,e,r,o):zm(t,n,r,a,o);e=s?e.projectionNext:e.next}}function ab(n,t,e,i,r,o){cO(e,i,n.firstChild,t,r,o,!1)}function J5(n,t,e,i,r,o){let s=e[bl],l=s[Ss].projection[i.projection];if(Array.isArray(l))for(let c=0;c<l.length;c++)zm(t,n,r,l[c],o);else cO(n,t,l,s[Gr],r,o,!0)}function $5(n,t,e){""===e?n.removeAttribute(t,"class"):n.setAttribute(t,"class",e)}function ez(n,t,e){let{mergedAttrs:i,classes:r,styles:o}=e;null!==i&&BR(n,t,i),null!==r&&$5(n,t,r),null!==o&&function(n,t,e){n.setAttribute(t,"style",e)}(n,t,o)}function tz(){if(void 0===VC&&(VC=null,Ur.trustedTypes))try{VC=Ur.trustedTypes.createPolicy("angular",{createHTML:n=>n,createScript:n=>n,createScriptURL:n=>n})}catch{}return VC}function ih(n){return tz()?.createHTML(n)||n}function iz(){return void 0!==YR?YR:typeof document<"u"?document:void 0}function dO(){if(void 0===HC&&(HC=null,Ur.trustedTypes))try{HC=Ur.trustedTypes.createPolicy("angular#unsafe-bypass",{createHTML:n=>n,createScript:n=>n,createScriptURL:n=>n})}catch{}return HC}function pH(n){return dO()?.createHTML(n)||n}function fH(n){return dO()?.createScript(n)||n}function mH(n){return dO()?.createScriptURL(n)||n}var td=class{constructor(t){this.changingThisBreaksApplicationSecurity=t}toString(){return`SafeValue must use [property]=binding: ${this.changingThisBreaksApplicationSecurity} (see ${tb})`}},XR=class extends td{getTypeName(){return"HTML"}},QR=class extends td{getTypeName(){return"Style"}},ZR=class extends td{getTypeName(){return"Script"}},KR=class extends td{getTypeName(){return"URL"}},JR=class extends td{getTypeName(){return"ResourceURL"}};function Ds(n){return n instanceof td?n.changingThisBreaksApplicationSecurity:n}function xl(n,t){let e=function(n){return n instanceof td&&n.getTypeName()||null}(n);if(null!=e&&e!==t){if("ResourceURL"===e&&"URL"===t)return!0;throw new Error(`Required a safe ${t}, got a ${e} (see ${tb})`)}return e===t}function cz(n){let t=new eP(n);return function(){try{return!!(new window.DOMParser).parseFromString(ih(""),"text/html")}catch{return!1}}()?new $R(t):t}var $R=class{constructor(t){this.inertDocumentHelper=t}getInertBodyElement(t){t="<body><remove></remove>"+t;try{let e=(new window.DOMParser).parseFromString(ih(t),"text/html").body;return null===e?this.inertDocumentHelper.getInertBodyElement(t):(e.removeChild(e.firstChild),e)}catch{return null}}},eP=class{constructor(t){this.defaultDoc=t,this.inertDocument=this.defaultDoc.implementation.createHTMLDocument("sanitization-inert")}getInertBodyElement(t){let e=this.inertDocument.createElement("template");return e.innerHTML=ih(t),e}},lse=/^(?!javascript:)(?:[a-z0-9+.-]+:|[^&:\/?#]*(?:[\/?#]|$))/i;function lb(n){return(n=String(n)).match(lse)?n:"unsafe:"+n}function ad(n){let t={};for(let e of n.split(","))t[e]=!0;return t}function cb(...n){let t={};for(let e of n)for(let i in e)e.hasOwnProperty(i)&&(t[i]=!0);return t}var zC,dz=ad("area,br,col,hr,img,wbr"),uz=ad("colgroup,dd,dt,li,p,tbody,td,tfoot,th,thead,tr"),pz=ad("rp,rt"),cse=cb(pz,uz),dse=cb(uz,ad("address,article,aside,blockquote,caption,center,del,details,dialog,dir,div,dl,figure,figcaption,footer,h1,h2,h3,h4,h5,h6,header,hgroup,hr,ins,main,map,menu,nav,ol,pre,section,summary,table,ul")),use=cb(pz,ad("a,abbr,acronym,audio,b,bdi,bdo,big,br,cite,code,del,dfn,em,font,i,img,ins,kbd,label,map,mark,picture,q,ruby,rp,rt,s,samp,small,source,span,strike,strong,sub,sup,time,track,tt,u,var,video")),tP=cb(dz,dse,use,cse),uO=ad("background,cite,href,itemtype,longdesc,poster,src,xlink:href"),pse=ad("abbr,accesskey,align,alt,autoplay,axis,bgcolor,border,cellpadding,cellspacing,class,clear,color,cols,colspan,compact,controls,coords,datetime,default,dir,download,face,headers,height,hidden,hreflang,hspace,ismap,itemscope,itemprop,kind,label,lang,language,loop,media,muted,nohref,nowrap,open,preload,rel,rev,role,rows,rowspan,rules,scope,scrolling,shape,size,sizes,span,srclang,srcset,start,summary,tabindex,target,title,translate,type,usemap,valign,value,vspace,width"),fse=ad("aria-activedescendant,aria-atomic,aria-autocomplete,aria-busy,aria-checked,aria-colcount,aria-colindex,aria-colspan,aria-controls,aria-current,aria-describedby,aria-details,aria-disabled,aria-dropeffect,aria-errormessage,aria-expanded,aria-flowto,aria-grabbed,aria-haspopup,aria-hidden,aria-invalid,aria-keyshortcuts,aria-label,aria-labelledby,aria-level,aria-live,aria-modal,aria-multiline,aria-multiselectable,aria-orientation,aria-owns,aria-placeholder,aria-posinset,aria-pressed,aria-readonly,aria-relevant,aria-required,aria-roledescription,aria-rowcount,aria-rowindex,aria-rowspan,aria-selected,aria-setsize,aria-sort,aria-valuemax,aria-valuemin,aria-valuenow,aria-valuetext"),fz=cb(uO,pse,fse),mse=ad("script,style,template"),nP=class{constructor(){this.sanitizedSomething=!1,this.buf=[]}sanitizeChildren(t){let e=t.firstChild,i=!0;for(;e;)if(e.nodeType===Node.ELEMENT_NODE?i=this.startElement(e):e.nodeType===Node.TEXT_NODE?this.chars(e.nodeValue):this.sanitizedSomething=!0,i&&e.firstChild)e=e.firstChild;else for(;e;){e.nodeType===Node.ELEMENT_NODE&&this.endElement(e);let r=this.checkClobberedElement(e,e.nextSibling);if(r){e=r;break}e=this.checkClobberedElement(e,e.parentNode)}return this.buf.join("")}startElement(t){let e=t.nodeName.toLowerCase();if(!tP.hasOwnProperty(e))return this.sanitizedSomething=!0,!mse.hasOwnProperty(e);this.buf.push("<"),this.buf.push(e);let i=t.attributes;for(let r=0;r<i.length;r++){let o=i.item(r),s=o.name,a=s.toLowerCase();if(!fz.hasOwnProperty(a)){this.sanitizedSomething=!0;continue}let l=o.value;uO[a]&&(l=lb(l)),this.buf.push(" ",s,'="',hH(l),'"')}return this.buf.push(">"),!0}endElement(t){let e=t.nodeName.toLowerCase();tP.hasOwnProperty(e)&&!dz.hasOwnProperty(e)&&(this.buf.push("</"),this.buf.push(e),this.buf.push(">"))}chars(t){this.buf.push(hH(t))}checkClobberedElement(t,e){if(e&&(t.compareDocumentPosition(e)&Node.DOCUMENT_POSITION_CONTAINED_BY)===Node.DOCUMENT_POSITION_CONTAINED_BY)throw new Error(`Failed to sanitize html because the element is clobbered: ${t.outerHTML}`);return e}},hse=/[\uD800-\uDBFF][\uDC00-\uDFFF]/g,gse=/([^\#-~ |!])/g;function hH(n){return n.replace(/&/g,"&amp;").replace(hse,function(t){return"&#"+(1024*(t.charCodeAt(0)-55296)+(t.charCodeAt(1)-56320)+65536)+";"}).replace(gse,function(t){return"&#"+t.charCodeAt(0)+";"}).replace(/</g,"&lt;").replace(/>/g,"&gt;")}function pO(n,t){let e=null;try{zC=zC||cz(n);let i=t?String(t):"";e=zC.getInertBodyElement(i);let r=5,o=i;do{if(0===r)throw new Error("Failed to sanitize html because the input is unstable");r--,i=o,o=e.innerHTML,e=zC.getInertBodyElement(i)}while(i!==o);return ih((new nP).sanitizeChildren(iP(e)||e))}finally{if(e){let i=iP(e)||e;for(;i.firstChild;)i.removeChild(i.firstChild)}}}function iP(n){return"content"in n&&function(n){return n.nodeType===Node.ELEMENT_NODE&&"TEMPLATE"===n.nodeName}(n)?n.content:null}var jr=(()=>{return(n=jr||(jr={}))[n.NONE=0]="NONE",n[n.HTML=1]="HTML",n[n.STYLE=2]="STYLE",n[n.SCRIPT=3]="SCRIPT",n[n.URL=4]="URL",n[n.RESOURCE_URL=5]="RESOURCE_URL",jr;var n})();function fO(n){let t=db();return t?pH(t.sanitize(jr.HTML,n)||""):xl(n,"HTML")?pH(Ds(n)):pO(iz(),Un(n))}function ka(n){let t=db();return t?t.sanitize(jr.URL,n)||"":xl(n,"URL")?Ds(n):lb(Un(n))}function mz(n){let t=db();if(t)return mH(t.sanitize(jr.RESOURCE_URL,n)||"");if(xl(n,"ResourceURL"))return mH(Ds(n));throw new yt(904,!1)}function db(){let n=Ze();return n&&n[FR]}var kM=new ie("ENVIRONMENT_INITIALIZER"),hz=new ie("INJECTOR",-1),gz=new ie("INJECTOR_DEF_TYPES"),dM=class{get(t,e=j_){if(e===j_){let i=new Error(`NullInjectorError: No provider for ${po(t)}!`);throw i.name="NullInjectorError",i}return e}};function wse(...n){return{"\u0275providers":_z(0,n),"\u0275fromNgModule":!0}}function _z(n,...t){let r,e=[],i=new Set;return eO(t,o=>{let s=o;rP(s,e,[],i)&&(r||(r=[]),r.push(s))}),void 0!==r&&bz(r,e),e}function bz(n,t){for(let e=0;e<n.length;e++){let{providers:r}=n[e];mO(r,o=>{t.push(o)})}}function rP(n,t,e,i){if(!(n=Ri(n)))return!1;let r=null,o=eH(n),s=!o&&Da(n);if(o||s){if(s&&!s.standalone)return!1;r=n}else{let l=n.ngModule;if(o=eH(l),!o)return!1;r=l}let a=i.has(r);if(s){if(a)return!1;if(i.add(r),s.dependencies){let l="function"==typeof s.dependencies?s.dependencies():s.dependencies;for(let c of l)rP(c,t,e,i)}}else{if(!o)return!1;{if(null!=o.imports&&!a){let c;i.add(r);try{eO(o.imports,d=>{rP(d,t,e,i)&&(c||(c=[]),c.push(d))})}finally{}void 0!==c&&bz(c,t)}if(!a){let c=Bp(r)||(()=>new r);t.push({provide:r,useFactory:c,deps:Vi},{provide:gz,useValue:r,multi:!0},{provide:kM,useValue:()=>k(r),multi:!0})}let l=o.providers;null==l||a||mO(l,d=>{t.push(d)})}}return r!==n&&void 0!==n.providers}function mO(n,t){for(let e of n)XH(e)&&(e=e.\u0275providers),Array.isArray(e)?mO(e,t):t(e)}var Sse=tr({provide:String,useValue:tr});function vz(n){return null!==n&&"object"==typeof n&&Sse in n}function Ym(n){return"function"==typeof n}var hR,NM=new ie("Set Injector scope."),YC={},Ise={};function hO(){return void 0===hR&&(hR=new dM),hR}var pc=class{},uM=class extends pc{get destroyed(){return this._destroyed}constructor(t,e,i,r){super(),this.parent=e,this.source=i,this.scopes=r,this.records=new Map,this._ngOnDestroyHooks=new Set,this._onDestroyHooks=[],this._destroyed=!1,sP(t,s=>this.processProvider(s)),this.records.set(hz,Um(void 0,this)),r.has("environment")&&this.records.set(pc,Um(void 0,this));let o=this.records.get(NM);null!=o&&"string"==typeof o.value&&this.scopes.add(o.value),this.injectorDefTypes=new Set(this.get(gz.multi,Vi,xi.Self))}destroy(){this.assertNotDestroyed(),this._destroyed=!0;try{for(let t of this._ngOnDestroyHooks)t.ngOnDestroy();for(let t of this._onDestroyHooks)t()}finally{this.records.clear(),this._ngOnDestroyHooks.clear(),this.injectorDefTypes.clear(),this._onDestroyHooks.length=0}}onDestroy(t){this._onDestroyHooks.push(t)}runInContext(t){this.assertNotDestroyed();let e=Nm(this),i=Ea(void 0);try{return t()}finally{Nm(e),Ea(i)}}get(t,e=j_,i=xi.Default){this.assertNotDestroyed(),i=wM(i);let r=Nm(this),o=Ea(void 0);try{if(!(i&xi.SkipSelf)){let a=this.records.get(t);if(void 0===a){let l=("function"==typeof(n=t)||"object"==typeof n&&n instanceof ie)&&VP(t);a=l&&this.injectableDefInScope(l)?Um(oP(t),YC):null,this.records.set(t,a)}if(null!=a)return this.hydrate(t,a)}return(i&xi.Self?hO():this.parent).get(t,e=i&xi.Optional&&e===j_?null:e)}catch(s){if("NullInjectorError"===s.name){if((s[$C]=s[$C]||[]).unshift(po(t)),r)throw s;return function(n,t,e,i){let r=n[$C];throw t[tH]&&r.unshift(t[tH]),n.message=function(n,t,e,i=null){n=n&&"\n"===n.charAt(0)&&n.charAt(1)==Cre?n.slice(2):n;let r=po(t);if(Array.isArray(t))r=t.map(po).join(" -> ");else if("object"==typeof t){let o=[];for(let s in t)if(t.hasOwnProperty(s)){let a=t[s];o.push(s+":"+("string"==typeof a?JSON.stringify(a):po(a)))}r=`{${o.join(", ")}}`}return`${e}${i?"("+i+")":""}[${r}]: ${n.replace(xre,"\n  ")}`}("\n"+n.message,r,e,i),n[yre]=r,n[$C]=null,n}(s,t,"R3InjectorError",this.source)}throw s}finally{Ea(o),Nm(r)}var n}resolveInjectorInitializers(){let t=Nm(this),e=Ea(void 0);try{let i=this.get(kM.multi,Vi,xi.Self);for(let r of i)r()}finally{Nm(t),Ea(e)}}toString(){let t=[],e=this.records;for(let i of e.keys())t.push(po(i));return`R3Injector[${t.join(", ")}]`}assertNotDestroyed(){if(this._destroyed)throw new yt(205,!1)}processProvider(t){let e=Ym(t=Ri(t))?t:Ri(t&&t.provide),i=function(n){return vz(n)?Um(void 0,n.useValue):Um(yz(n),YC)}(t);if(Ym(t)||!0!==t.multi)this.records.get(e);else{let r=this.records.get(e);r||(r=Um(void 0,YC,!0),r.factory=()=>kR(r.multi),this.records.set(e,r)),e=t,r.multi.push(t)}this.records.set(e,i)}hydrate(t,e){return e.value===YC&&(e.value=Ise,e.value=e.factory()),"object"==typeof e.value&&e.value&&null!==(n=e.value)&&"object"==typeof n&&"function"==typeof n.ngOnDestroy&&this._ngOnDestroyHooks.add(e.value),e.value;var n}injectableDefInScope(t){if(!t.providedIn)return!1;let e=Ri(t.providedIn);return"string"==typeof e?"any"===e||this.scopes.has(e):this.injectorDefTypes.has(e)}};function oP(n){let t=VP(n),e=null!==t?t.factory:Bp(n);if(null!==e)return e;if(n instanceof ie)throw new yt(204,!1);if(n instanceof Function)return function(n){let t=n.length;if(t>0)throw N_(t,"?"),new yt(204,!1);let e=function(n){return n&&(n[JC]||n[ZH])||null}(n);return null!==e?()=>e.factory(n):()=>new n}(n);throw new yt(204,!1)}function yz(n,t,e){let i;if(Ym(n)){let r=Ri(n);return Bp(r)||oP(r)}if(vz(n))i=()=>Ri(n.useValue);else if(function(n){return!(!n||!n.useFactory)}(n))i=()=>n.useFactory(...kR(n.deps||[]));else if(function(n){return!(!n||!n.useExisting)}(n))i=()=>k(Ri(n.useExisting));else{let r=Ri(n&&(n.useClass||n.provide));if(!function(n){return!!n.deps}(n))return Bp(r)||oP(r);i=()=>new r(...kR(n.deps))}return i}function Um(n,t,e=!1){return{factory:n,value:t,multi:e?[]:void 0}}function sP(n,t){for(let e of n)Array.isArray(e)?sP(e,t):e&&XH(e)?sP(e.\u0275providers,t):t(e)}var aP=class{},pM=class{},lP=class{resolveComponentFactory(t){throw function(n){let t=Error(`No component factory found for ${po(n)}. Did you add it to @NgModule.entryComponents?`);return t.ngComponent=n,t}(t)}},fo=(()=>{class n{}return n.NULL=new lP,n})();function Lse(){return rh(Po(),Ze())}function rh(n,t){return new Me(oa(n,t))}var Me=(()=>{class n{constructor(e){this.nativeElement=e}}return n.__NG_ELEMENT_ID__=Lse,n})();function Bse(n){return n instanceof Me?n.nativeElement:n}var fc=class{},mc=(()=>{class n{}return n.__NG_ELEMENT_ID__=()=>function(){let n=Ze(),e=id(Po().index,n);return(Np(e)?e:n)[oi]}(),n})(),Hse=(()=>{class n{}return n.\u0275prov=ue({token:n,providedIn:"root",factory:()=>null}),n})(),yl=class{constructor(t){this.full=t,this.major=t.split(".")[0],this.minor=t.split(".")[1],this.patch=t.split(".").slice(2).join(".")}},zse=new yl("15.2.9"),gR={},Use="ngOriginalError";function _R(n){return n[Use]}var rs=class{constructor(){this._console=console}handleError(t){let e=this._findOriginalError(t);this._console.error("ERROR",t),e&&this._console.error("ORIGINAL ERROR",e)}_findOriginalError(t){let e=t&&_R(t);for(;e&&_R(e);)e=_R(e);return e||null}};function hc(n){return n.ownerDocument}function XC(n){return n instanceof Function?n():n}function xz(n,t,e){let i=n.length;for(;;){let r=n.indexOf(t,e);if(-1===r)return r;if(0===r||n.charCodeAt(r-1)<=32){let o=t.length;if(r+o===i||n.charCodeAt(r+o)<=32)return r}e=r+1}}var Cz="ng-template";function Wse(n,t,e){let i=0,r=!0;for(;i<n.length;){let o=n[i++];if("string"==typeof o&&r){let s=n[i++];if(e&&"class"===o&&-1!==xz(s.toLowerCase(),t,0))return!0}else{if(1===o){for(;i<n.length&&"string"==typeof(o=n[i++]);)if(o.toLowerCase()===t)return!0;return!1}"number"==typeof o&&(r=!1)}}return!1}function Mz(n){return 4===n.type&&n.value!==Cz}function qse(n,t,e){return t===(4!==n.type||e?n.value:Cz)}function Yse(n,t,e){let i=4,r=n.attrs||[],o=function(n){for(let t=0;t<n.length;t++)if(M5(n[t]))return t;return n.length}(r),s=!1;for(let a=0;a<t.length;a++){let l=t[a];if("number"!=typeof l){if(!s)if(4&i){if(i=2|1&i,""!==l&&!qse(n,l,e)||""===l&&1===t.length){if(hl(i))return!1;s=!0}}else{let c=8&i?l:t[++a];if(8&i&&null!==n.attrs){if(!Wse(n.attrs,c,e)){if(hl(i))return!1;s=!0}continue}let u=Xse(8&i?"class":l,r,Mz(n),e);if(-1===u){if(hl(i))return!1;s=!0;continue}if(""!==c){let p;p=u>o?"":r[u+1].toLowerCase();let f=8&i?p:null;if(f&&-1!==xz(f,c,0)||2&i&&c!==p){if(hl(i))return!1;s=!0}}}}else{if(!s&&!hl(i)&&!hl(l))return!1;if(s&&hl(l))continue;s=!1,i=l|1&i}}return hl(i)||s}function hl(n){return 0==(1&n)}function Xse(n,t,e,i){if(null===t)return-1;let r=0;if(i||!e){let o=!1;for(;r<t.length;){let s=t[r];if(s===n)return r;if(3===s||6===s)o=!0;else{if(1===s||2===s){let a=t[++r];for(;"string"==typeof a;)a=t[++r];continue}if(4===s)break;if(0===s){r+=4;continue}}r+=o?1:2}return-1}return function(n,t){let e=n.indexOf(4);if(e>-1)for(e++;e<n.length;){let i=n[e];if("number"==typeof i)return-1;if(i===t)return e;e++}return-1}(t,n)}function wz(n,t,e=!1){for(let i=0;i<t.length;i++)if(Yse(n,t[i],e))return!0;return!1}function Jse(n,t){e:for(let e=0;e<t.length;e++){let i=t[e];if(n.length===i.length){for(let r=0;r<n.length;r++)if(n[r]!==i[r])continue e;return!0}}return!1}function gH(n,t){return n?":not("+t.trim()+")":t}function $se(n){let t=n[0],e=1,i=2,r="",o=!1;for(;e<n.length;){let s=n[e];if("string"==typeof s)if(2&i){let a=n[++e];r+="["+s+(a.length>0?'="'+a+'"':"")+"]"}else 8&i?r+="."+s:4&i&&(r+=" "+s);else""!==r&&!hl(s)&&(t+=gH(o,r),r=""),i=s,o=o||!hl(i);e++}return""!==r&&(t+=gH(o,r)),t}var Hn={};function v(n){Sz(Ei(),Ze(),ss()+n,!1)}function Sz(n,t,e,i){if(!i)if(3==(3&t[ri])){let o=n.preOrderCheckHooks;null!==o&&jC(t,o,e)}else{let o=n.preOrderHooks;null!==o&&GC(t,o,0,e)}Vp(e)}var _H={"\u0275\u0275defineInjectable":ue,"\u0275\u0275defineInjector":U,"\u0275\u0275inject":k,"\u0275\u0275invalidFactoryDep":JH,resolveForwardRef:Ri};var iae=tr({provide:String,useValue:tr});function bH(n){return void 0!==n.useClass}function vH(n){return void 0!==n.useFactory}var Ez=ob("Injectable",void 0,void 0,void 0,(n,t)=>function(n,t){let e=null,i=null;n.hasOwnProperty(JC)||Object.defineProperty(n,JC,{get:()=>(null===e&&(e=Ia().compileInjectable(_H,`ng:///${n.name}/\u0275prov.js`,function(n,t){let e=t||{providedIn:null},i={name:n.name,type:n,typeArgumentCount:0,providedIn:e.providedIn};return(bH(e)||vH(e))&&void 0!==e.deps&&(i.deps=F5(e.deps)),bH(e)?i.useClass=e.useClass:function(n){return iae in n}(e)?i.useValue=e.useValue:vH(e)?i.useFactory=e.useFactory:function(n){return void 0!==n.useExisting}(e)&&(i.useExisting=e.useExisting),i}(n,t))),e)}),n.hasOwnProperty(ed)||Object.defineProperty(n,ed,{get:()=>{if(null===i){let r=Ia();i=r.compileFactory(_H,`ng:///${n.name}/\u0275fac.js`,{name:n.name,type:n,typeArgumentCount:0,deps:RM(n),target:r.FactoryTarget.Injectable})}return i},configurable:!0})}(n,t));function yH(n,t=null,e=null,i){let r=Tz(n,t,e,i);return r.resolveInjectorInitializers(),r}function Tz(n,t=null,e=null,i,r=new Set){let o=[e||Vi,wse(n)];return i=i||("object"==typeof n?void 0:po(n)),new uM(o,t||hO(),i||null,r)}var Mi=(()=>{class n{static create(e,i){if(Array.isArray(e))return yH({name:""},i,e,"");{let r=e.name??"";return yH({name:r},e.parent,e.providers,r)}}}return n.THROW_IF_NOT_FOUND=j_,n.NULL=new dM,n.\u0275prov=ue({token:n,providedIn:"any",factory:()=>k(hz)}),n.__NG_ELEMENT_ID__=-1,n})(),L_=class{constructor(t,e){if(this.token=t,this.id=e,!t)throw new yt(208,!1);this.displayName=po(this.token)}static get(t){return xH.get(Ri(t))}static get numberOfKeys(){return xH.numberOfKeys}},xH=new class{constructor(){this._allKeys=new Map}get(t){if(t instanceof L_)return t;if(this._allKeys.has(t))return this._allKeys.get(t);let e=new L_(t,L_.numberOfKeys);return this._allKeys.set(t,e),e}get numberOfKeys(){return this._allKeys.size}};function C(n,t=xi.Default){let e=Ze();return null===e?k(n,t):A5(Po(),e,Ri(n),t)}function Is(){throw new Error("invalid")}function Dz(n,t){let e=n.contentQueries;if(null!==e)for(let i=0;i<e.length;i+=2){let o=e[i+1];if(-1!==o){let s=n.data[o];QP(e[i]),s.contentQueries(2,t[o],o)}}}function LM(n,t,e,i,r,o,s,a,l,c,d){let u=t.blueprint.slice();return u[su]=r,u[ri]=76|i,(null!==d||n&&1024&n[ri])&&(u[ri]|=1024),u5(u),u[Gr]=u[Jm]=n,u[Es]=e,u[nM]=s||n&&n[nM],u[oi]=a||n&&n[oi],u[FR]=l||n&&n[FR]||null,u[tM]=c||n&&n[tM]||null,u[Ss]=o,u[EM]=Boe++,u[i5]=d,u[bl]=2==t.type?n[bl]:u,u}function oh(n,t,e,i,r){let o=n.data[t];if(null===o)o=gO(n,t,e,i,r),jn.lFrame.inI18n&&(o.flags|=32);else if(64&o.type){o.type=e,o.value=i,o.attrs=r;let s=q_();o.injectorIndex=null===s?-1:s.injectorIndex}return dc(o,!0),o}function gO(n,t,e,i,r){let o=f5(),s=qP(),l=n.data[t]=function(n,t,e,i,r,o){return{type:e,index:i,insertBeforeIndex:null,injectorIndex:t?t.injectorIndex:-1,directiveStart:-1,directiveEnd:-1,directiveStylingLast:-1,componentOffset:-1,propertyBindings:null,flags:0,providerIndexes:0,value:r,attrs:o,mergedAttrs:null,localNames:null,initialInputs:void 0,inputs:null,outputs:null,tView:null,next:null,prev:null,projectionNext:null,child:null,parent:t,projection:null,styles:null,stylesWithoutHost:null,residualStyles:void 0,classes:null,classesWithoutHost:null,residualClasses:void 0,classBindings:0,styleBindings:0}}(0,s?o:o&&o.parent,e,t,i,r);return null===n.firstChild&&(n.firstChild=l),null!==o&&(s?null==o.child&&null!==l.parent&&(o.child=l):null===o.next&&(o.next=l,l.prev=o)),l}function ub(n,t,e,i){if(0===e)return-1;let r=t.length;for(let o=0;o<e;o++)t.push(i),n.blueprint.push(i),n.data.push(null);return r}function _O(n,t,e){ZP(t);try{let i=n.viewQuery;null!==i&&pP(1,i,e);let r=n.template;null!==r&&Iz(n,t,r,1,e),n.firstCreatePass&&(n.firstCreatePass=!1),n.staticContentQueries&&Dz(n,t),n.staticViewQueries&&pP(2,n.viewQuery,e);let o=n.components;null!==o&&function(n,t){for(let e=0;e<t.length;e++)Rae(n,t[e])}(t,o)}catch(i){throw n.firstCreatePass&&(n.incompleteFirstPass=!0,n.firstCreatePass=!1),i}finally{t[ri]&=-5,KP()}}function BM(n,t,e,i){let r=t[ri];if(128!=(128&r)){ZP(t);try{u5(t),m5(n.bindingStartIndex),null!==e&&Iz(n,t,e,2,i);let s=3==(3&r);if(s){let c=n.preOrderCheckHooks;null!==c&&jC(t,c,null)}else{let c=n.preOrderHooks;null!==c&&GC(t,c,0,null),dR(t,0)}if(function(n){for(let t=rO(n);null!==t;t=oO(t)){if(!t[r5])continue;let e=t[Wm];for(let i=0;i<e.length;i++){let r=e[i];0==(512&r[ri])&&WP(r[Gr],1),r[ri]|=512}}}(t),function(n){for(let t=rO(n);null!==t;t=oO(t))for(let e=ws;e<t.length;e++){let i=t[e],r=i[Fn];rM(i)&&BM(r,i,r.template,i[Es])}}(t),null!==n.contentQueries&&Dz(n,t),s){let c=n.contentCheckHooks;null!==c&&jC(t,c)}else{let c=n.contentHooks;null!==c&&GC(t,c,1),dR(t,1)}!function(n,t){let e=n.hostBindingOpCodes;if(null!==e)try{for(let i=0;i<e.length;i++){let r=e[i];if(r<0)Vp(~r);else{let o=r,s=e[++i],a=e[++i];Gre(s,o),a(2,t[o])}}}finally{Vp(-1)}}(n,t);let a=n.components;null!==a&&function(n,t){for(let e=0;e<t.length;e++)Aae(n,t[e])}(t,a);let l=n.viewQuery;if(null!==l&&pP(2,l,i),s){let c=n.viewCheckHooks;null!==c&&jC(t,c)}else{let c=n.viewHooks;null!==c&&GC(t,c,2),dR(t,2)}!0===n.firstUpdatePass&&(n.firstUpdatePass=!1),t[ri]&=-41,512&t[ri]&&(t[ri]&=-513,WP(t[Gr],-1))}finally{KP()}}}function Iz(n,t,e,i,r){let o=ss(),s=2&i;try{Vp(-1),s&&t.length>Wr&&Sz(n,t,Wr,!1),Ta(s?2:0,r),e(i,r)}finally{Vp(o),Ta(s?3:1,r)}}function bO(n,t,e){if(GP(t)){let r=t.directiveEnd;for(let o=t.directiveStart;o<r;o++){let s=n.data[o];s.contentQueries&&s.contentQueries(1,e[o],o)}}}function vO(n,t,e){!p5()||(function(n,t,e,i){let r=e.directiveStart,o=e.directiveEnd;TM(e)&&function(n,t,e){let i=oa(t,n),r=Az(e),o=n[nM],s=VM(n,LM(n,r,null,e.onPush?32:16,i,t,o,o.createRenderer(i,e),null,null,null));n[t.index]=s}(t,e,n.data[r+e.componentOffset]),n.firstCreatePass||lM(e,t),uc(i,t);let s=e.initialInputs;for(let a=r;a<o;a++){let l=n.data[a],c=zp(t,n,a,e);uc(c,t),null!==s&&Eae(0,a-r,c,l,0,s),vl(l)&&(id(e.index,t)[Es]=zp(t,n,a,e))}}(n,t,e,oa(e,t)),64==(64&e.flags)&&Oz(n,t,e))}function yO(n,t,e=oa){let i=t.localNames;if(null!==i){let r=t.index+1;for(let o=0;o<i.length;o+=2){let s=i[o+1],a=-1===s?e(t,n):n[s];n[r++]=a}}}function Az(n){let t=n.tView;return null===t||t.incompleteFirstPass?n.tView=xO(1,null,n.template,n.decls,n.vars,n.directiveDefs,n.pipeDefs,n.viewQuery,n.schemas,n.consts):t}function xO(n,t,e,i,r,o,s,a,l,c){let d=Wr+i,u=d+r,p=function(n,t){let e=[];for(let i=0;i<t;i++)e.push(i<n?null:Hn);return e}(d,u),f="function"==typeof c?c():c;return p[Fn]={type:n,blueprint:p,template:e,queries:null,viewQuery:a,declTNode:t,data:p.slice().fill(null,d),bindingStartIndex:d,expandoStartIndex:u,hostBindingOpCodes:null,firstCreatePass:!0,firstUpdatePass:!0,staticViewQueries:!1,staticContentQueries:!1,preOrderHooks:null,preOrderCheckHooks:null,contentHooks:null,contentCheckHooks:null,viewHooks:null,viewCheckHooks:null,destroyHooks:null,cleanup:null,contentQueries:null,components:null,directiveRegistry:"function"==typeof o?o():o,pipeRegistry:"function"==typeof s?s():s,firstChild:null,schemas:l,consts:f,incompleteFirstPass:!1}}function Rz(n,t,e,i){let r=Nz(t);null===e?r.push(i):(r.push(e),n.firstCreatePass&&Lz(n).push(i,r.length-1))}function CH(n,t,e,i){for(let r in n)if(n.hasOwnProperty(r)){e=null===e?{}:e;let o=n[r];null===i?MH(e,t,r,o):i.hasOwnProperty(r)&&MH(e,t,i[r],o)}return e}function MH(n,t,e,i){n.hasOwnProperty(e)?n[e].push(t,i):n[e]=[t,i]}function aa(n,t,e,i,r,o,s,a){let d,l=oa(t,e),c=t.inputs;!a&&null!=c&&(d=c[i])?(SO(n,e,d,i,r),TM(t)&&function(n,t){let e=id(t,n);16&e[ri]||(e[ri]|=32)}(e,t.index)):3&t.type&&(i=function(n){return"class"===n?"className":"for"===n?"htmlFor":"formaction"===n?"formAction":"innerHtml"===n?"innerHTML":"readonly"===n?"readOnly":"tabindex"===n?"tabIndex":n}(i),r=null!=s?s(r,t.value||"",i):r,o.setProperty(l,i,r))}function CO(n,t,e,i){if(p5()){let s,a,r=null===i?null:{"":-1},o=function(n,t){let e=n.directiveRegistry,i=null,r=null;if(e)for(let o=0;o<e.length;o++){let s=e[o];if(wz(t,s.selectors,!1))if(i||(i=[]),vl(s))if(null!==s.findHostDirectiveDefs){let a=[];r=r||new Map,s.findHostDirectiveDefs(s,a,r),i.unshift(...a,s),dP(n,t,a.length)}else i.unshift(s),dP(n,t,0);else r=r||new Map,s.findHostDirectiveDefs?.(s,i,r),i.push(s)}return null===i?null:[i,r]}(n,e);null===o?s=a=null:[s,a]=o,null!==s&&Pz(n,t,e,s,r,a),r&&function(n,t,e){if(t){let i=n.localNames=[];for(let r=0;r<t.length;r+=2){let o=e[t[r+1]];if(null==o)throw new yt(-301,!1);i.push(t[r],o)}}}(e,i,r)}e.mergedAttrs=Y_(e.mergedAttrs,e.attrs)}function Pz(n,t,e,i,r,o){for(let c=0;c<i.length;c++)HR(lM(e,t),n,i[c].type);!function(n,t,e){n.flags|=1,n.directiveStart=t,n.directiveEnd=t+e,n.providerIndexes=t}(e,n.data.length,i.length);for(let c=0;c<i.length;c++){let d=i[c];d.providersResolver&&d.providersResolver(d)}let s=!1,a=!1,l=ub(n,t,i.length,null);for(let c=0;c<i.length;c++){let d=i[c];e.mergedAttrs=Y_(e.mergedAttrs,d.hostAttrs),wae(n,e,t,l,d),Cae(l,d,r),null!==d.contentQueries&&(e.flags|=4),(null!==d.hostBindings||null!==d.hostAttrs||0!==d.hostVars)&&(e.flags|=64);let u=d.type.prototype;!s&&(u.ngOnChanges||u.ngOnInit||u.ngDoCheck)&&((n.preOrderHooks??(n.preOrderHooks=[])).push(e.index),s=!0),!a&&(u.ngOnChanges||u.ngDoCheck)&&((n.preOrderCheckHooks??(n.preOrderCheckHooks=[])).push(e.index),a=!0),l++}!function(n,t,e){let r=t.directiveEnd,o=n.data,s=t.attrs,a=[],l=null,c=null;for(let d=t.directiveStart;d<r;d++){let u=o[d],p=e?e.get(u):null,m=p?p.outputs:null;l=CH(u.inputs,d,l,p?p.inputs:null),c=CH(u.outputs,d,c,m);let b=null===l||null===s||Mz(t)?null:Tae(l,d,s);a.push(b)}null!==l&&(l.hasOwnProperty("class")&&(t.flags|=8),l.hasOwnProperty("style")&&(t.flags|=16)),t.initialInputs=a,t.inputs=l,t.outputs=c}(n,e,o)}function Oz(n,t,e){let i=e.directiveStart,r=e.directiveEnd,o=e.index,s=jn.lFrame.currentDirectiveIndex;try{Vp(o);for(let a=i;a<r;a++){let l=n.data[a],c=t[a];LR(a),(null!==l.hostBindings||0!==l.hostVars||null!==l.hostAttrs)&&vae(l,c)}}finally{Vp(-1),LR(s)}}function vae(n,t){null!==n.hostBindings&&n.hostBindings(1,t)}function dP(n,t,e){t.componentOffset=e,(n.components??(n.components=[])).push(t.index)}function Cae(n,t,e){if(e){if(t.exportAs)for(let i=0;i<t.exportAs.length;i++)e[t.exportAs[i]]=n;vl(t)&&(e[""]=n)}}function wae(n,t,e,i,r){n.data[i]=r;let o=r.factory||(r.factory=Bp(r.type)),s=new Hp(o,vl(r),C);n.blueprint[i]=s,e[i]=s,function(n,t,e,i,r){let o=r.hostBindings;if(o){let s=n.hostBindingOpCodes;null===s&&(s=n.hostBindingOpCodes=[]);let a=~t.index;(function(n){let t=n.length;for(;t>0;){let e=n[--t];if("number"==typeof e&&e<0)return e}return 0})(s)!=a&&s.push(a),s.push(e,i,o)}}(n,t,i,ub(n,e,r.hostVars,Hn),r)}function gc(n,t,e,i,r,o){let s=oa(n,t);MO(t[oi],s,o,n.value,e,i,r)}function MO(n,t,e,i,r,o,s){if(null==o)n.removeAttribute(t,r,e);else{let a=null==s?Un(o):s(o,i||"",r);n.setAttribute(t,r,a,e)}}function Eae(n,t,e,i,r,o){let s=o[t];if(null!==s){let a=i.setInput;for(let l=0;l<s.length;){let c=s[l++],d=s[l++],u=s[l++];null!==a?i.setInput(e,u,c,d):e[d]=u}}}function Tae(n,t,e){let i=null,r=0;for(;r<e.length;){let o=e[r];if(0!==o)if(5!==o){if("number"==typeof o)break;if(n.hasOwnProperty(o)){null===i&&(i=[]);let s=n[o];for(let a=0;a<s.length;a+=2)if(s[a]===t){i.push(o,s[a+1],e[r+1]);break}}r+=2}else r+=2;else r+=4}return i}function kz(n,t,e,i){return[n,!0,!1,t,null,0,i,e,null,null]}function Aae(n,t){let e=id(t,n);if(rM(e)){let i=e[Fn];48&e[ri]?BM(i,e,i.template,e[Es]):e[Fp]>0&&uP(e)}}function uP(n){for(let i=rO(n);null!==i;i=oO(i))for(let r=ws;r<i.length;r++){let o=i[r];if(rM(o))if(512&o[ri]){let s=o[Fn];BM(s,o,s.template,o[Es])}else o[Fp]>0&&uP(o)}let e=n[Fn].components;if(null!==e)for(let i=0;i<e.length;i++){let r=id(e[i],n);rM(r)&&r[Fp]>0&&uP(r)}}function Rae(n,t){let e=id(t,n),i=e[Fn];(function(n,t){for(let e=t.length;e<n.blueprint.length;e++)t.push(n.blueprint[e])})(i,e),_O(i,e,e[Es])}function VM(n,t){return n[W_]?n[iH][_l]=t:n[W_]=t,n[iH]=t,t}function wO(n){for(;n;){n[ri]|=32;let t=iO(n);if(Are(n)&&!t)return n;n=t}return null}function Fz(n,t,e,i=!0){let r=t[nM];r.begin&&r.begin();try{BM(n,t,n.template,e)}catch(s){throw i&&Vz(t,s),s}finally{r.end&&r.end()}}function pP(n,t,e){QP(0),t(n,e)}function Nz(n){return n[G_]||(n[G_]=[])}function Lz(n){return n.cleanup||(n.cleanup=[])}function Bz(n,t,e){return(null===n||vl(n))&&(e=function(n){for(;Array.isArray(n);){if("object"==typeof n[UP])return n;n=n[su]}return null}(e[t.index])),e[oi]}function Vz(n,t){let e=n[tM],i=e?e.get(rs,null):null;i&&i.handleError(t)}function SO(n,t,e,i,r){for(let o=0;o<e.length;){let s=e[o++],a=e[o++],l=t[s],c=n.data[s];null!==c.setInput?c.setInput(l,r,i,a):l[a]=r}}function ld(n,t,e){let i=IM(t,n);z5(n[oi],i,e)}function fM(n,t,e){let i=e?n.styles:null,r=e?n.classes:null,o=0;if(null!==t)for(let s=0;s<t.length;s++){let a=t[s];"number"==typeof a?o=a:1==o?r=AR(r,a):2==o&&(i=AR(i,a+": "+t[++s]+";"))}e?n.styles=i:n.stylesWithoutHost=i,e?n.classes=r:n.classesWithoutHost=r}function QC(n,t,e,i,r=!1){for(;null!==e;){let o=t[e.index];if(null!==o&&i.push(Ra(o)),nd(o))for(let a=ws;a<o.length;a++){let l=o[a],c=l[Fn].firstChild;null!==c&&QC(l[Fn],l,c,i)}let s=e.type;if(8&s)QC(n,t,e.child,i);else if(32&s){let l,a=nO(e,t);for(;l=a();)i.push(l)}else if(16&s){let a=K5(t,e);if(Array.isArray(a))i.push(...a);else{let l=iO(t[bl]);QC(l[Fn],l,a,i,!0)}}e=r?e.projectionNext:e.next}return i}var jp=class{get rootNodes(){let t=this._lView,e=t[Fn];return QC(e,t,e.firstChild,[])}constructor(t,e){this._lView=t,this._cdRefInjectingView=e,this._appRef=null,this._attachedToViewContainer=!1}get context(){return this._lView[Es]}set context(t){this._lView[Es]=t}get destroyed(){return 128==(128&this._lView[ri])}destroy(){if(this._appRef)this._appRef.detachView(this);else if(this._attachedToViewContainer){let t=this._lView[Gr];if(nd(t)){let e=t[iM],i=e?e.indexOf(this):-1;i>-1&&(GR(t,i),cM(e,i))}this._attachedToViewContainer=!1}j5(this._lView[Fn],this._lView)}onDestroy(t){Rz(this._lView[Fn],this._lView,null,t)}markForCheck(){wO(this._cdRefInjectingView||this._lView)}detach(){this._lView[ri]&=-65}reattach(){this._lView[ri]|=64}detectChanges(){Fz(this._lView[Fn],this._lView,this.context)}checkNoChanges(){}attachToViewContainerRef(){if(this._appRef)throw new yt(902,!1);this._attachedToViewContainer=!0}detachFromAppRef(){var t;this._appRef=null,ab(this._lView[Fn],t=this._lView,t[oi],2,null,null)}attachToAppRef(t){if(this._attachedToViewContainer)throw new yt(902,!1);this._appRef=t}},fP=class extends jp{constructor(t){super(t),this._view=t}detectChanges(){let t=this._view;Fz(t[Fn],t,t[Es],!1)}checkNoChanges(){}get context(){return null}},mM=class extends fo{constructor(t){super(),this.ngModule=t}resolveComponentFactory(t){let e=Da(t);return new hM(e,this.ngModule)}};function wH(n){let t=[];for(let e in n)n.hasOwnProperty(e)&&t.push({propName:n[e],templateName:e});return t}var hM=class extends pM{get inputs(){return wH(this.componentDef.inputs)}get outputs(){return wH(this.componentDef.outputs)}constructor(t,e){super(),this.componentDef=t,this.ngModule=e,this.componentType=t.type,this.selector=t.selectors.map($se).join(","),this.ngContentSelectors=t.ngContentSelectors?t.ngContentSelectors:[],this.isBoundToModule=!!e}create(t,e,i,r){let o=(r=r||this.ngModule)instanceof pc?r:r?.injector;o&&null!==this.componentDef.getStandaloneInjector&&(o=this.componentDef.getStandaloneInjector(o)||o);let s=o?new class{constructor(t,e){this.injector=t,this.parentInjector=e}get(t,e,i){i=wM(i);let r=this.injector.get(t,gR,i);return r!==gR||e===gR?r:this.parentInjector.get(t,e,i)}}(t,o):t,a=s.get(fc,null);if(null===a)throw new yt(407,!1);let b,M,l=s.get(Hse,null),c=a.createRenderer(null,this.componentDef),d=this.componentDef.selectors[0][0]||"div",u=i?function(n,t,e){return n.selectRootElement(t,e===ra.ShadowDom)}(c,i,this.componentDef.encapsulation):aO(c,d,function(n){let t=n.toLowerCase();return"svg"===t?l5:"math"===t?c5:null}(d)),p=this.componentDef.onPush?288:272,f=xO(0,null,null,1,0,null,null,null,null,null),m=LM(null,f,null,p,null,null,a,c,l,s,null);ZP(m);try{let x,y=this.componentDef,R=null;y.findHostDirectiveDefs?(x=[],R=new Map,y.findHostDirectiveDefs(y,x,R),x.push(y)):x=[y];let A=function(n,t){let e=n[Fn],i=Wr;return n[i]=t,oh(e,i,2,"#host",null)}(m,u),V=function(n,t,e,i,r,o,s,a){let l=r[Fn];!function(n,t,e,i){for(let r of n)t.mergedAttrs=Y_(t.mergedAttrs,r.hostAttrs);null!==t.mergedAttrs&&(fM(t,t.mergedAttrs,!0),null!==e&&ez(i,e,t))}(i,n,t,s);let c=o.createRenderer(t,e),d=LM(r,Az(e),null,e.onPush?32:16,r[n.index],n,o,c,null,null,null);return l.firstCreatePass&&dP(l,n,i.length-1),VM(r,d),r[n.index]=d}(A,u,y,x,m,a,c);M=d5(f,Wr),u&&function(n,t,e,i){if(i)BR(n,e,["ng-version",zse.full]);else{let{attrs:r,classes:o}=function(n){let t=[],e=[],i=1,r=2;for(;i<n.length;){let o=n[i];if("string"==typeof o)2===r?""!==o&&t.push(o,n[++i]):8===r&&e.push(o);else{if(!hl(r))break;r=o}i++}return{attrs:t,classes:e}}(t.selectors[0]);r&&BR(n,e,r),o&&o.length>0&&$5(n,e,o.join(" "))}}(c,y,u,i),void 0!==e&&function(n,t,e){let i=n.projection=[];for(let r=0;r<t.length;r++){let o=e[r];i.push(null!=o?Array.from(o):null)}}(M,this.ngContentSelectors,e),b=function(n,t,e,i,r,o){let s=Po(),a=r[Fn],l=oa(s,r);Pz(a,r,s,e,null,i);for(let d=0;d<e.length;d++)uc(zp(r,a,s.directiveStart+d,s),r);Oz(a,r,s),l&&uc(l,r);let c=zp(r,a,s.directiveStart+s.componentOffset,s);if(n[Es]=r[Es]=c,null!==o)for(let d of o)d(c,t);return bO(a,s,n),c}(V,y,x,R,m,[Hae]),_O(f,m,null)}finally{KP()}return new hP(this.componentType,b,rh(M,m),m,M)}},hP=class extends aP{constructor(t,e,i,r,o){super(),this.location=i,this._rootLView=r,this._tNode=o,this.instance=e,this.hostView=this.changeDetectorRef=new fP(r),this.componentType=t}setInput(t,e){let r,i=this._tNode.inputs;if(null!==i&&(r=i[t])){let o=this._rootLView;SO(o[Fn],o,r,t,e),wO(id(this._tNode.index,o))}}get injector(){return new Lp(this._tNode,this._rootLView)}destroy(){this.hostView.destroy()}onDestroy(t){this.hostView.onDestroy(t)}};function Hae(){let n=Po();AM(Ze()[Fn],n)}function Hz(n){return Object.getPrototypeOf(n.prototype).constructor}function Ke(n){let t=Hz(n.type),e=!0,i=[n];for(;t;){let r;if(vl(n))r=t.\u0275cmp||t.\u0275dir;else{if(t.\u0275cmp)throw new yt(903,!1);r=t.\u0275dir}if(r){if(e){i.push(r);let s=n;s.inputs=bR(n.inputs),s.declaredInputs=bR(n.declaredInputs),s.outputs=bR(n.outputs);let a=r.hostBindings;a&&Gae(n,a);let l=r.viewQuery,c=r.contentQueries;if(l&&Uae(n,l),c&&jae(n,c),cR(n.inputs,r.inputs),cR(n.declaredInputs,r.declaredInputs),cR(n.outputs,r.outputs),vl(r)&&r.data.animation){let d=n.data;d.animation=(d.animation||[]).concat(r.data.animation)}}let o=r.features;if(o)for(let s=0;s<o.length;s++){let a=o[s];a&&a.ngInherit&&a(n),a===Ke&&(e=!1)}}t=Object.getPrototypeOf(t)}!function(n){let t=0,e=null;for(let i=n.length-1;i>=0;i--){let r=n[i];r.hostVars=t+=r.hostVars,r.hostAttrs=Y_(r.hostAttrs,e=Y_(e,r.hostAttrs))}}(i)}function bR(n){return n===$c?{}:n===Vi?[]:n}function Uae(n,t){let e=n.viewQuery;n.viewQuery=e?(i,r)=>{t(i,r),e(i,r)}:t}function jae(n,t){let e=n.contentQueries;n.contentQueries=e?(i,r,o)=>{t(i,r,o),e(i,r,o)}:t}function Gae(n,t){let e=n.hostBindings;n.hostBindings=e?(i,r)=>{t(i,r),e(i,r)}:t}var Wae=["providersResolver"],qae=["template","decls","consts","vars","onPush","ngContentSelectors","styles","encapsulation","schemas"];function zz(n,t,e){if(null!==n.hostDirectives)for(let i of n.hostDirectives){let r=tu(i.directive);Qae(r.declaredInputs,i.inputs),zz(r,t,e),e.set(r,i),t.push(r)}}function SH(n){if(void 0===n||0===n.length)return $c;let t={};for(let e=0;e<n.length;e+=2)t[n[e]]=n[e+1];return t}function Qae(n,t){for(let e in t)t.hasOwnProperty(e)&&(n[t[e]]=n[e])}function Uz(n){return!!EO(n)&&(Array.isArray(n)||!(n instanceof Map)&&Symbol.iterator in n)}function EO(n){return null!==n&&("function"==typeof n||"object"==typeof n)}function _c(n,t,e){return n[t]=e}function pb(n,t){return n[t]}function Uo(n,t,e){return!Object.is(n[t],e)&&(n[t]=e,!0)}function Gp(n,t,e,i){let r=Uo(n,t,e);return Uo(n,t+1,i)||r}function HM(n,t,e,i,r){let o=Gp(n,t,e,i);return Uo(n,t+2,r)||o}function Pa(n,t,e,i,r,o){let s=Gp(n,t,e,i);return Gp(n,t+2,r,o)||s}function Be(n,t,e,i){let r=Ze();return Uo(r,eh(),t)&&(Ei(),gc(kr(),r,n,t,e,i)),Be}function sh(n,t){let e=!1,i=rd();for(let o=1;o<t.length;o+=2)e=Uo(n,i++,t[o])||e;if(m5(i),!e)return Hn;let r=t[0];for(let o=1;o<t.length;o+=2)r+=Un(t[o])+t[o+1];return r}function ah(n,t,e,i){return Uo(n,eh(),e)?t+Un(e)+i:Hn}function lh(n,t,e,i,r,o){let a=Gp(n,rd(),e,r);return od(2),a?t+Un(e)+i+Un(r)+o:Hn}function ch(n,t,e,i,r,o,s,a){let c=HM(n,rd(),e,r,s);return od(3),c?t+Un(e)+i+Un(r)+o+Un(s)+a:Hn}function dh(n,t,e,i,r,o,s,a,l,c){let u=Pa(n,rd(),e,r,s,l);return od(4),u?t+Un(e)+i+Un(r)+o+Un(s)+a+Un(l)+c:Hn}function uh(n,t,e,i,r,o,s,a,l,c,d,u){let p=rd(),f=Pa(n,p,e,r,s,l);return f=Uo(n,p+4,d)||f,od(5),f?t+Un(e)+i+Un(r)+o+Un(s)+a+Un(l)+c+Un(d)+u:Hn}function ph(n,t,e,i,r,o,s,a,l,c,d,u,p,f){let m=rd(),b=Pa(n,m,e,r,s,l);return b=Gp(n,m+4,d,p)||b,od(6),b?t+Un(e)+i+Un(r)+o+Un(s)+a+Un(l)+c+Un(d)+u+Un(p)+f:Hn}function fh(n,t,e,i,r,o,s,a,l,c,d,u,p,f,m,b){let M=rd(),y=Pa(n,M,e,r,s,l);return y=HM(n,M+4,d,p,m)||y,od(7),y?t+Un(e)+i+Un(r)+o+Un(s)+a+Un(l)+c+Un(d)+u+Un(p)+f+Un(m)+b:Hn}function mh(n,t,e,i,r,o,s,a,l,c,d,u,p,f,m,b,M,y){let x=rd(),R=Pa(n,x,e,r,s,l);return R=Pa(n,x+4,d,p,m,M)||R,od(8),R?t+Un(e)+i+Un(r)+o+Un(s)+a+Un(l)+c+Un(d)+u+Un(p)+f+Un(m)+b+Un(M)+y:Hn}function S(n,t,e,i,r,o,s,a){let l=Ze(),c=Ei(),d=n+Wr,u=c.firstCreatePass?function(n,t,e,i,r,o,s,a,l){let c=t.consts,d=oh(t,n,4,s||null,iu(c,a));CO(t,e,d,iu(c,l)),AM(t,d);let u=d.tView=xO(2,d,i,r,o,t.directiveRegistry,t.pipeRegistry,null,t.schemas,c);return null!==t.queries&&(t.queries.template(t,d),u.queries=t.queries.embeddedTView(d)),d}(d,c,l,t,e,i,r,o,s):c.data[d];dc(u,!1);let p=l[oi].createComment("");OM(c,l,p,u),uc(p,l),VM(l,l[d]=kz(p,l,p,u)),DM(u)&&vO(c,l,u),null!=s&&yO(l,u,a)}function it(n){return $m(jn.lFrame.contextLView,Wr+n)}function _(n,t,e){let i=Ze();return Uo(i,eh(),t)&&aa(Ei(),kr(),i,n,t,i[oi],e,!1),_}function gP(n,t,e,i,r){let s=r?"class":"style";SO(n,e,t.inputs[s],s,i)}function h(n,t,e,i){let r=Ze(),o=Ei(),s=Wr+n,a=r[oi],l=o.firstCreatePass?function(n,t,e,i,r,o){let s=t.consts,l=oh(t,n,2,i,iu(s,r));return CO(t,e,l,iu(s,o)),null!==l.attrs&&fM(l,l.attrs,!1),null!==l.mergedAttrs&&fM(l,l.mergedAttrs,!0),null!==t.queries&&t.queries.elementStart(t,l),l}(s,o,r,t,e,i):o.data[s],c=r[s]=aO(a,t,jn.lFrame.currentNamespace),d=DM(l);return dc(l,!0),ez(a,c,l),32!=(32&l.flags)&&OM(o,r,c,l),0===jn.lFrame.elementDepthCount&&uc(c,r),jn.lFrame.elementDepthCount++,d&&(vO(o,r,l),bO(o,l,r)),null!==i&&yO(r,l),h}function g(){let n=Po();qP()?YP():(n=n.parent,dc(n,!1));let t=n;jn.lFrame.elementDepthCount--;let e=Ei();return e.firstCreatePass&&(AM(e,n),GP(n)&&e.queries.elementEnd(n)),null!=t.classesWithoutHost&&function(n){return 0!=(8&n.flags)}(t)&&gP(e,t,Ze(),t.classesWithoutHost,!0),null!=t.stylesWithoutHost&&function(n){return 0!=(16&n.flags)}(t)&&gP(e,t,Ze(),t.stylesWithoutHost,!1),g}function P(n,t,e,i){return h(n,t,e,i),g(),P}function Ot(n,t,e){let i=Ze(),r=Ei(),o=n+Wr,s=r.firstCreatePass?function(n,t,e,i,r){let o=t.consts,s=iu(o,i),a=oh(t,n,8,"ng-container",s);return null!==s&&fM(a,s,!0),CO(t,e,a,iu(o,r)),null!==t.queries&&t.queries.elementStart(t,a),a}(o,r,i,t,e):r.data[o];dc(s,!0);let a=i[o]=i[oi].createComment("");return OM(r,i,a,s),uc(a,i),DM(s)&&(vO(r,i,s),bO(r,s,i)),null!=e&&yO(i,s),Ot}function kt(){let n=Po(),t=Ei();return qP()?YP():(n=n.parent,dc(n,!1)),t.firstCreatePass&&(AM(t,n),GP(n)&&t.queries.elementEnd(n)),kt}function li(n,t,e){return Ot(n,t,e),kt(),li}function ge(){return Ze()}function hh(n){return!!n&&"function"==typeof n.then}function TO(n){return!!n&&"function"==typeof n.subscribe}var DO=TO;function I(n,t,e,i){let r=Ze(),o=Ei(),s=Po();return Jz(o,r,r[oi],s,n,t,i),I}function zM(n,t){let e=Po(),i=Ze(),r=Ei();return Jz(r,i,Bz(XP(r.data),e,i),e,n,t),zM}function Jz(n,t,e,i,r,o,s){let a=DM(i),c=n.firstCreatePass&&Lz(n),d=t[Es],u=Nz(t),p=!0;if(3&i.type||s){let b=oa(i,t),M=s?s(b):b,y=u.length,x=s?A=>s(Ra(A[i.index])):i.index,R=null;if(!s&&a&&(R=function(n,t,e,i){let r=n.cleanup;if(null!=r)for(let o=0;o<r.length-1;o+=2){let s=r[o];if(s===e&&r[o+1]===i){let a=t[G_],l=r[o+2];return a.length>l?a[l]:null}"string"==typeof s&&(o+=2)}return null}(n,t,r,i.index)),null!==R)(R.__ngLastListenerFn__||R).__ngNextListenerFn__=o,R.__ngLastListenerFn__=o,p=!1;else{o=TH(i,t,d,o,!1);let A=e.listen(M,r,o);u.push(o,A),c&&c.push(r,x,y,y+1)}}else o=TH(i,t,d,o,!1);let m,f=i.outputs;if(p&&null!==f&&(m=f[r])){let b=m.length;if(b)for(let M=0;M<b;M+=2){let V=t[m[M]][m[M+1]].subscribe(o),te=u.length;u.push(o,V),c&&c.push(r,i.index,te,-(te+1))}}}function EH(n,t,e,i){try{return Ta(6,t,e),!1!==e(i)}catch(r){return Vz(n,r),!1}finally{Ta(7,t,e)}}function TH(n,t,e,i,r){return function o(s){if(s===Function)return i;wO(n.componentOffset>-1?id(n.index,t):t);let l=EH(t,e,i,s),c=o.__ngNextListenerFn__;for(;c;)l=EH(t,e,c,s)&&l,c=c.__ngNextListenerFn__;return r&&!1===l&&(s.preventDefault(),s.returnValue=!1),l}}function w(n=1){return function(n){return(jn.lFrame.contextLView=function(n,t){for(;n>0;)t=t[Jm],n--;return t}(n,jn.lFrame.contextLView))[Es]}(n)}function nle(n,t){let e=null,i=function(n){let t=n.attrs;if(null!=t){let e=t.indexOf(5);if(0==(1&e))return t[e+1]}return null}(n);for(let r=0;r<t.length;r++){let o=t[r];if("*"!==o){if(null===i?wz(n,o,!0):Jse(i,o))return r}else e=r}return e}function Dn(n){let t=Ze()[bl][Ss];if(!t.projection){let i=t.projection=N_(n?n.length:1,null),r=i.slice(),o=t.child;for(;null!==o;){let s=n?nle(o,n):0;null!==s&&(r[s]?r[s].projectionNext=o:i[s]=o,r[s]=o),o=o.next}}}function zt(n,t=0,e){let i=Ze(),r=Ei(),o=oh(r,Wr+n,16,null,e||null);null===o.projection&&(o.projection=t),YP(),32!=(32&o.flags)&&function(n,t,e){J5(t[oi],0,t,e,G5(n,e,t),Y5(e.parent||t[Ss],e,t))}(r,i,o)}function Wi(n,t,e){return fb(n,"",t,"",e),Wi}function fb(n,t,e,i,r){let o=Ze(),s=ah(o,t,e,i);return s!==Hn&&aa(Ei(),kr(),o,n,s,o[oi],r,!1),fb}function UM(n,t,e,i,r,o,s){let a=Ze(),l=lh(a,t,e,i,r,o);return l!==Hn&&aa(Ei(),kr(),a,n,l,a[oi],s,!1),UM}function UC(n,t){return n<<17|t<<2}function Wp(n){return n>>17&32767}function _P(n){return 2|n}function Xm(n){return(131068&n)>>2}function vR(n,t){return-131069&n|t<<2}function bP(n){return 1|n}function DH(n,t,e,i,r){let o=n[e+1],s=null===t,a=i?Wp(o):Xm(o),l=!1;for(;0!==a&&(!1===l||s);){let d=n[a+1];lle(n[a],t)&&(l=!0,n[a+1]=i?bP(d):_P(d)),a=i?Wp(d):Xm(d)}l&&(n[e+1]=i?_P(o):bP(o))}function lle(n,t){return null===n||null==t||(Array.isArray(n)?n[1]:n)===t||!(!Array.isArray(n)||"string"!=typeof t)&&sb(n,t)>=0}var uo={textEnd:0,key:0,keyEnd:0,value:0,valueEnd:0};function sU(n){return n.substring(uo.key,uo.keyEnd)}function cle(n){return n.substring(uo.value,uo.valueEnd)}function aU(n,t){let e=uo.textEnd;return e===t?-1:(t=uo.keyEnd=function(n,t,e){for(;t<e&&n.charCodeAt(t)>32;)t++;return t}(n,uo.key=t,e),Qm(n,t,e))}function lU(n,t){let e=uo.textEnd,i=uo.key=Qm(n,t,e);return e===i?-1:(i=uo.keyEnd=function(n,t,e){let i;for(;t<e&&(45===(i=n.charCodeAt(t))||95===i||(-33&i)>=65&&(-33&i)<=90||i>=48&&i<=57);)t++;return t}(n,i,e),i=IH(n,i,e),i=uo.value=Qm(n,i,e),i=uo.valueEnd=function(n,t,e){let i=-1,r=-1,o=-1,s=t,a=s;for(;s<e;){let l=n.charCodeAt(s++);if(59===l)return a;34===l||39===l?a=s=AH(n,l,s,e):t===s-4&&85===o&&82===r&&76===i&&40===l?a=s=AH(n,41,s,e):l>32&&(a=s),o=r,r=i,i=-33&l}return a}(n,i,e),IH(n,i,e))}function cU(n){uo.key=0,uo.keyEnd=0,uo.value=0,uo.valueEnd=0,uo.textEnd=n.length}function Qm(n,t,e){for(;t<e&&n.charCodeAt(t)<=32;)t++;return t}function IH(n,t,e,i){return(t=Qm(n,t,e))<e&&t++,t}function AH(n,t,e,i){let r=-1,o=e;for(;o<i;){let s=n.charCodeAt(o++);if(s==t&&92!==r)return o;r=92==s&&92===r?0:s}throw new Error}function Tt(n,t,e){return Cl(n,t,e,!1),Tt}function nt(n,t){return Cl(n,t,null,!0),nt}function Fa(n){Ml(pU,hle,n,!1)}function hle(n,t){for(let e=function(n){return cU(n),lU(n,Qm(n,0,uo.textEnd))}(t);e>=0;e=lU(t,e))pU(n,sU(t),cle(t))}function As(n){Ml(xle,bc,n,!0)}function bc(n,t){for(let e=function(n){return cU(n),aU(n,Qm(n,0,uo.textEnd))}(t);e>=0;e=aU(t,e))sa(n,sU(t),!0)}function Cl(n,t,e,i){let r=Ze(),o=Ei(),s=od(2);o.firstUpdatePass&&uU(o,n,s,i),t!==Hn&&Uo(r,s,t)&&fU(o,o.data[ss()],r,r[oi],n,r[s+1]=function(n,t){return null==n||""===n||("string"==typeof t?n+=t:"object"==typeof n&&(n=po(Ds(n)))),n}(t,e),i,s)}function Ml(n,t,e,i){let r=Ei(),o=od(2);r.firstUpdatePass&&uU(r,null,o,i);let s=Ze();if(e!==Hn&&Uo(s,o,e)){let a=r.data[ss()];if(mU(a,i)&&!dU(r,o)){let l=i?a.classesWithoutHost:a.stylesWithoutHost;null!==l&&(e=AR(l,e||"")),gP(r,a,s,e,i)}else!function(n,t,e,i,r,o,s,a){r===Hn&&(r=Vi);let l=0,c=0,d=0<r.length?r[0]:null,u=0<o.length?o[0]:null;for(;null!==d||null!==u;){let b,p=l<r.length?r[l+1]:void 0,f=c<o.length?o[c+1]:void 0,m=null;d===u?(l+=2,c+=2,p!==f&&(m=u,b=f)):null===u||null!==d&&d<u?(l+=2,m=d):(c+=2,m=u,b=f),null!==m&&fU(n,t,e,i,m,b,s,a),d=l<r.length?r[l]:null,u=c<o.length?o[c]:null}}(r,a,s,s[oi],s[o+1],s[o+1]=function(n,t,e){if(null==e||""===e)return Vi;let i=[],r=Ds(e);if(Array.isArray(r))for(let o=0;o<r.length;o++)n(i,r[o],!0);else if("object"==typeof r)for(let o in r)r.hasOwnProperty(o)&&n(i,o,r[o]);else"string"==typeof r&&t(i,r);return i}(n,t,e),i,o)}}function dU(n,t){return t>=n.expandoStartIndex}function uU(n,t,e,i){let r=n.data;if(null===r[e+1]){let o=r[ss()],s=dU(n,e);mU(o,i)&&null===t&&!s&&(t=!1),t=function(n,t,e,i){let r=XP(n),o=i?t.residualClasses:t.residualStyles;if(null===r)0===(i?t.classBindings:t.styleBindings)&&(e=Q_(e=yR(null,n,t,e,i),t.attrs,i),o=null);else{let s=t.directiveStylingLast;if(-1===s||n[s]!==r)if(e=yR(r,n,t,e,i),null===o){let l=function(n,t,e){let i=e?t.classBindings:t.styleBindings;if(0!==Xm(i))return n[Wp(i)]}(n,t,i);void 0!==l&&Array.isArray(l)&&(l=yR(null,n,t,l[1],i),l=Q_(l,t.attrs,i),function(n,t,e,i){n[Wp(e?t.classBindings:t.styleBindings)]=i}(n,t,i,l))}else o=function(n,t,e){let i,r=t.directiveEnd;for(let o=1+t.directiveStylingLast;o<r;o++)i=Q_(i,n[o].hostAttrs,e);return Q_(i,t.attrs,e)}(n,t,i)}return void 0!==o&&(i?t.residualClasses=o:t.residualStyles=o),e}(r,o,t,i),function(n,t,e,i,r,o){let s=o?t.classBindings:t.styleBindings,a=Wp(s),l=Xm(s);n[i]=e;let d,c=!1;if(Array.isArray(e)?(d=e[1],(null===d||sb(e,d)>0)&&(c=!0)):d=e,r)if(0!==l){let p=Wp(n[a+1]);n[i+1]=UC(p,a),0!==p&&(n[p+1]=vR(n[p+1],i)),n[a+1]=function(n,t){return 131071&n|t<<17}(n[a+1],i)}else n[i+1]=UC(a,0),0!==a&&(n[a+1]=vR(n[a+1],i)),a=i;else n[i+1]=UC(l,0),0===a?a=i:n[l+1]=vR(n[l+1],i),l=i;c&&(n[i+1]=_P(n[i+1])),DH(n,d,i,!0),DH(n,d,i,!1),function(n,t,e,i,r){let o=r?n.residualClasses:n.residualStyles;null!=o&&"string"==typeof t&&sb(o,t)>=0&&(e[i+1]=bP(e[i+1]))}(t,d,n,i,o),s=UC(a,l),o?t.classBindings=s:t.styleBindings=s}(r,o,t,e,s,i)}}function yR(n,t,e,i,r){let o=null,s=e.directiveEnd,a=e.directiveStylingLast;for(-1===a?a=e.directiveStart:a++;a<s&&(o=t[a],i=Q_(i,o.hostAttrs,r),o!==n);)a++;return null!==n&&(e.directiveStylingLast=a),i}function Q_(n,t,e){let i=e?1:2,r=-1;if(null!==t)for(let o=0;o<t.length;o++){let s=t[o];"number"==typeof s?r=s:r===i&&(Array.isArray(n)||(n=void 0===n?[]:["",n]),sa(n,s,!!e||t[++o]))}return void 0===n?null:n}function pU(n,t,e){sa(n,t,Ds(e))}function xle(n,t,e){let i=String(t);""!==i&&!i.includes(" ")&&sa(n,i,e)}function fU(n,t,e,i,r,o,s,a){if(!(3&t.type))return;let l=n.data,c=l[a+1],d=function(n){return 1==(1&n)}(c)?RH(l,t,e,r,Xm(c),s):void 0;gM(d)||(gM(o)||function(n){return 2==(2&n)}(c)&&(o=RH(l,null,e,r,a,s)),function(n,t,e,i,r){if(t)r?n.addClass(e,i):n.removeClass(e,i);else{let o=-1===i.indexOf("-")?void 0:Aa.DashCase;null==r?n.removeStyle(e,i,o):("string"==typeof r&&r.endsWith("!important")&&(r=r.slice(0,-10),o|=Aa.Important),n.setStyle(e,i,r,o))}}(i,s,IM(ss(),e),r,o))}function RH(n,t,e,i,r,o){let a,s=null===t;for(;r>0;){let l=n[r],c=Array.isArray(l),d=c?l[1]:l,u=null===d,p=e[r+1];p===Hn&&(p=u?Vi:void 0);let f=u?pR(p,i):d===i?p:void 0;if(c&&!gM(f)&&(f=pR(l,i)),gM(f)&&(a=f,s))return a;let m=n[r+1];r=s?Wp(m):Xm(m)}if(null!==t){let l=o?t.residualClasses:t.residualStyles;null!=l&&(a=pR(l,i))}return a}function gM(n){return void 0!==n}function mU(n,t){return 0!=(n.flags&(t?8:16))}function T(n,t=""){let e=Ze(),i=Ei(),r=n+Wr,o=i.firstCreatePass?oh(i,r,1,t,null):i.data[r],s=e[r]=sO(e[oi],t);OM(i,e,s,o),dc(o,!1)}function bt(n){return He("",n,""),bt}function He(n,t,e){let i=Ze(),r=ah(i,n,t,e);return r!==Hn&&ld(i,ss(),r),He}function lu(n,t,e,i,r){let o=Ze(),s=lh(o,n,t,e,i,r);return s!==Hn&&ld(o,ss(),s),lu}function jM(n,t,e,i,r,o,s){let a=Ze(),l=ch(a,n,t,e,i,r,o,s);return l!==Hn&&ld(a,ss(),l),jM}function mb(n,t,e){Ml(sa,bc,ah(Ze(),n,t,e),!0)}function jo(n,t,e){let i=Ze();return Uo(i,eh(),t)&&aa(Ei(),kr(),i,n,t,i[oi],e,!0),jo}function GM(n,t,e){let i=Ze();if(Uo(i,eh(),t)){let o=Ei(),s=kr();aa(o,s,i,n,t,Bz(XP(o.data),s,i),e,!0)}return GM}var Op=void 0,Ule=["en",[["a","p"],["AM","PM"],Op],[["AM","PM"],Op,Op],[["S","M","T","W","T","F","S"],["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],["Su","Mo","Tu","We","Th","Fr","Sa"]],Op,[["J","F","M","A","M","J","J","A","S","O","N","D"],["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"],["January","February","March","April","May","June","July","August","September","October","November","December"]],Op,[["B","A"],["BC","AD"],["Before Christ","Anno Domini"]],0,[6,0],["M/d/yy","MMM d, y","MMMM d, y","EEEE, MMMM d, y"],["h:mm a","h:mm:ss a","h:mm:ss a z","h:mm:ss a zzzz"],["{1}, {0}",Op,"{1} 'at' {0}",Op],[".",",",";","%","+","-","E","\xd7","\u2030","\u221e","NaN",":"],["#,##0.###","#,##0%","\xa4#,##0.00","#E0"],"USD","$","US Dollar",{},"ltr",function(n){let e=Math.floor(Math.abs(n)),i=n.toString().replace(/^[^.]*\.?/,"").length;return 1===e&&0===i?1:5}],xR={};function Rs(n){let t=function(n){return n.toLowerCase().replace(/_/g,"-")}(n),e=PH(t);if(e)return e;let i=t.split("-")[0];if(e=PH(i),e)return e;if("en"===i)return Ule;throw new yt(701,!1)}function PH(n){return n in xR||(xR[n]=Ur.ng&&Ur.ng.common&&Ur.ng.common.locales&&Ur.ng.common.locales[n]),xR[n]}var gr=(()=>{return(n=gr||(gr={}))[n.LocaleId=0]="LocaleId",n[n.DayPeriodsFormat=1]="DayPeriodsFormat",n[n.DayPeriodsStandalone=2]="DayPeriodsStandalone",n[n.DaysFormat=3]="DaysFormat",n[n.DaysStandalone=4]="DaysStandalone",n[n.MonthsFormat=5]="MonthsFormat",n[n.MonthsStandalone=6]="MonthsStandalone",n[n.Eras=7]="Eras",n[n.FirstDayOfWeek=8]="FirstDayOfWeek",n[n.WeekendRange=9]="WeekendRange",n[n.DateFormat=10]="DateFormat",n[n.TimeFormat=11]="TimeFormat",n[n.DateTimeFormat=12]="DateTimeFormat",n[n.NumberSymbols=13]="NumberSymbols",n[n.NumberFormats=14]="NumberFormats",n[n.CurrencyCode=15]="CurrencyCode",n[n.CurrencySymbol=16]="CurrencySymbol",n[n.CurrencyName=17]="CurrencyName",n[n.Currencies=18]="Currencies",n[n.Directionality=19]="Directionality",n[n.PluralCase=20]="PluralCase",n[n.ExtraData=21]="ExtraData",gr;var n})(),Gle=["zero","one","two","few","many"];var _M="en-US",RU={marker:"element"},PU={marker:"ICU"},gl=(()=>{return(n=gl||(gl={}))[n.SHIFT=2]="SHIFT",n[n.APPEND_EAGERLY=1]="APPEND_EAGERLY",n[n.COMMENT=2]="COMMENT",gl;var n})(),OU=_M;function kU(n,t,e){let i=t.insertBeforeIndex,r=Array.isArray(i)?i[0]:i;return null===r?X5(n,0,e):Ra(e[r])}function FU(n,t,e,i,r){let o=t.insertBeforeIndex;if(Array.isArray(o)){let s=i,a=null;if(3&t.type||(a=s,s=r),null!==s&&-1===t.componentOffset)for(let l=1;l<o.length;l++)Up(n,s,e[o[l]],a,!1)}}function NU(n,t){if(n.push(t),n.length>1)for(let e=n.length-2;e>=0;e--){let i=n[e];LU(i)||Qle(i,t)&&null===Zle(i)&&Kle(i,t.index)}}function LU(n){return!(64&n.type)}function Qle(n,t){return LU(t)||n.index>t.index}function Zle(n){let t=n.insertBeforeIndex;return Array.isArray(t)?t[0]:t}function Kle(n,t){let e=n.insertBeforeIndex;Array.isArray(e)?e[0]=t:(Z5(kU,FU),n.insertBeforeIndex=t)}function B_(n,t){let e=n.data[t];return null===e||"string"==typeof e?null:e.hasOwnProperty("currentCaseLViewIndex")?e:e.value}function ece(n,t,e){let i=gO(n,e,64,null,null);return NU(t,i),i}function WM(n,t){let e=t[n.currentCaseLViewIndex];return null===e?e:e<0?~e:e}function tce(n){return n>>>17}function nce(n){return(131070&n)>>>1}var Z_=0,V_=0;function BU(n,t,e,i){let s,r=e[oi],o=null;for(let a=0;a<t.length;a++){let l=t[a];if("string"==typeof l){let c=t[++a];null===e[c]&&(e[c]=sO(r,l))}else if("number"==typeof l)switch(1&l){case 0:let d,u,c=tce(l);if(null===o&&(o=c,s=PM(r,i)),c===o?(d=i,u=s):(d=null,u=Ra(e[c])),null!==u){let b=nce(l);Up(r,u,e[b],d,!1);let y=B_(n,b);if(null!==y&&"object"==typeof y){let x=WM(y,e);null!==x&&BU(n,y.create[x],e,e[y.anchorIdx])}}break;case 1:let f=t[++a],m=t[++a];MO(r,IM(l>>>1,e),null,null,f,m,null)}else switch(l){case PU:let c=t[++a],d=t[++a];null===e[d]&&uc(e[d]=joe(r,c),e);break;case RU:let u=t[++a],p=t[++a];null===e[p]&&uc(e[p]=aO(r,u,null),e)}}}function VU(n,t,e,i,r){for(let o=0;o<e.length;o++){let s=e[o],a=e[++o];if(s&r){let l="";for(let c=o+1;c<=o+a;c++){let d=e[c];if("string"==typeof d)l+=d;else if("number"==typeof d)if(d<0)l+=Un(t[i-d]);else{let u=d>>>2;switch(3&d){case 1:let p=e[++c],f=e[++c],m=n.data[u];"string"==typeof m?MO(t[oi],t[u],null,m,p,l,f):aa(n,m,t,p,l,t[oi],f,!1);break;case 0:let b=t[u];null!==b&&z5(t[oi],b,l);break;case 2:ace(n,B_(n,u),t,l);break;case 3:OH(n,B_(n,u),i,t)}}}}else{let l=e[o+1];if(l>0&&3==(3&l)){let d=B_(n,l>>>2);t[d.currentCaseLViewIndex]<0&&OH(n,d,i,t)}}o+=a}}function OH(n,t,e,i){let r=i[t.currentCaseLViewIndex];if(null!==r){let o=Z_;r<0&&(r=i[t.currentCaseLViewIndex]=~r,o=-1),VU(n,i,t.update[r],e,o)}}function ace(n,t,e,i){let r=function(n,t){let e=n.cases.indexOf(t);if(-1===e)switch(n.type){case 1:{let i=function(n,t){let e=function(n){return Rs(n)[gr.PluralCase]}(t)(parseInt(n,10)),i=Gle[e];return void 0!==i?i:"other"}(t,OU);e=n.cases.indexOf(i),-1===e&&"other"!==i&&(e=n.cases.indexOf("other"));break}case 0:e=n.cases.indexOf("other")}return-1===e?null:e}(t,i);if(WM(t,e)!==r&&(HU(n,t,e),e[t.currentCaseLViewIndex]=null===r?null:~r,null!==r)){let s=e[t.anchorIdx];s&&BU(n,t.create[r],e,s)}}function HU(n,t,e){let i=WM(t,e);if(null!==i){let r=t.remove[i];for(let o=0;o<r.length;o++){let s=r[o];if(s>0){let a=IM(s,e);null!==a&&lO(e[oi],a)}else HU(n,B_(n,~s),e)}}}function cce(){let e,i,n=[],t=-1;function o(a,l){t=0;let c=WM(a,l);i=null!==c?a.remove[c]:Vi}function s(){if(t<i.length){let a=i[t++];return a>0?e[a]:(n.push(t,i),o(e[Fn].data[~a],e),s())}return 0===n.length?null:(i=n.pop(),t=n.pop(),s())}return function(a,l){for(e=l;n.length;)n.pop();return o(a.value,l),s}}var bM=/\ufffd(\d+):?\d*\ufffd/gi,dce=/({\s*\ufffd\d+:?\d*\ufffd\s*,\s*\S{6}\s*,[\s\S]*})/gi,uce=/\ufffd(\d+)\ufffd/,zU=/^\s*(\ufffd\d+:?\d*\ufffd)\s*,\s*(select|plural)\s*,/,H_="\ufffd",pce=/\ufffd\/?\*(\d+:\d+)\ufffd/gi,fce=/\ufffd(\/?[#*]\d+):?\d*\ufffd/gi,mce=/\uE500/g;function UU(n,t,e,i,r,o,s){let a=ub(n,i,1,null),l=a<<gl.SHIFT,c=q_();t===c&&(c=null),null===c&&(l|=gl.APPEND_EAGERLY),s&&(l|=gl.COMMENT,function(n){void 0===jR&&(jR=n())}(cce)),r.push(l,null===o?"":o);let d=gO(n,a,s?32:1,null===o?"":o,null);NU(e,d);let u=d.index;return dc(d,!1),null!==c&&t!==c&&function(n,t){let e=n.insertBeforeIndex;null===e?(Z5(kU,FU),e=n.insertBeforeIndex=[null,t]):(function(n,t,e){1!=n&&QH("Expecting array here",n,!0,"==")}(Array.isArray(e)),e.push(t))}(c,u),d}function _ce(n,t,e,i,r,o,s){let a=s.match(bM),l=UU(n,t,e,o,i,a?null:s,!1);a&&z_(r,s,l.index,null,0,null)}function z_(n,t,e,i,r,o){let s=n.length,a=s+1;n.push(null,null);let l=s+2,c=t.split(bM),d=0;for(let u=0;u<c.length;u++){let p=c[u];if(1&u){let f=r+parseInt(p,10);n.push(-1-f),d|=jU(f)}else""!==p&&n.push(p)}return n.push(e<<2|(i?1:0)),i&&n.push(i,o),n[s]=d,n[a]=n.length-l,d}function vce(n){let t=0;for(let e=0;e<n.length;e++){let i=n[e];"number"==typeof i&&i<0&&t++}return t}function jU(n){return 1<<Math.min(n,31)}function kH(n){let t,o,e="",i=0,r=!1;for(;null!==(t=pce.exec(n));)r?t[0]===`${H_}/*${o}${H_}`&&(i=t.index,r=!1):(e+=n.substring(i,t.index+t[0].length),o=t[1],r=!0);return e+=n.slice(i),e}function GU(n,t,e,i,r,o){let s=0,a={type:r.type,currentCaseLViewIndex:ub(n,t,1,null),anchorIdx:o,cases:[],create:[],remove:[],update:[]};(function(n,t,e){n.push(jU(t.mainBinding),2,-1-t.mainBinding,e<<2|2)})(e,r,o),function(n,t,e){let i=n.data[t];null===i?n.data[t]=e:i.value=e}(n,o,a);let l=r.values;for(let c=0;c<l.length;c++){let d=l[c],u=[];for(let p=0;p<d.length;p++){let f=d[p];if("string"!=typeof f){let m=u.push(f)-1;d[p]=`\x3c!--\ufffd${m}\ufffd--\x3e`}}s=Mce(n,a,t,e,i,r.cases[c],d.join(""),u)|s}s&&function(n,t,e){n.push(t,1,e<<2|3)}(e,s,o)}function Cce(n){let t=[],e=[],i=1,r=0,o=vP(n=n.replace(zU,function(s,a,l){return i="select"===l?0:1,r=parseInt(a.slice(1),10),""}));for(let s=0;s<o.length;){let a=o[s++].trim();1===i&&(a=a.replace(/\s*(?:=)?(\w+)\s*/,"$1")),a.length&&t.push(a);let l=vP(o[s++]);t.length>e.length&&e.push(l)}return{type:i,mainBinding:r,cases:t,values:e}}function vP(n){if(!n)return[];let o,t=0,e=[],i=[],r=/[{}]/g;for(r.lastIndex=0;o=r.exec(n);){let a=o.index;if("}"==o[0]){if(e.pop(),0==e.length){let l=n.substring(t,a);zU.test(l)?i.push(Cce(l)):i.push(l),t=a+1}}else{if(0==e.length){let l=n.substring(t,a);i.push(l),t=a+1}e.push("{")}}let s=n.substring(t);return i.push(s),i}function Mce(n,t,e,i,r,o,s,a){let l=[],c=[],d=[];t.cases.push(o),t.create.push(l),t.remove.push(c),t.update.push(d);let p=cz(iz()).getInertBodyElement(s),f=iP(p)||p;return f?WU(n,t,e,i,l,c,d,f,r,a,0):0}function WU(n,t,e,i,r,o,s,a,l,c,d){let u=0,p=a.firstChild;for(;p;){let f=ub(n,e,1,null);switch(p.nodeType){case Node.ELEMENT_NODE:let m=p,b=m.tagName.toLowerCase();if(tP.hasOwnProperty(b)){CR(r,RU,b,l,f),n.data[f]=b;let R=m.attributes;for(let A=0;A<R.length;A++){let V=R.item(A),te=V.name.toLowerCase();V.value.match(bM)?fz.hasOwnProperty(te)&&z_(s,V.value,f,V.name,0,uO[te]?lb:null):Tce(r,f,V)}u=WU(n,t,e,i,r,o,s,p,f,c,d+1)|u,FH(o,f,d)}break;case Node.TEXT_NODE:let M=p.textContent||"",y=M.match(bM);CR(r,null,y?"":M,l,f),FH(o,f,d),y&&(u=z_(s,M,f,null,0,null)|u);break;case Node.COMMENT_NODE:let x=uce.exec(p.textContent||"");if(x){let A=c[parseInt(x[1],10)];CR(r,PU,"",l,f),GU(n,e,i,l,A,f),wce(o,f,d)}}p=p.nextSibling}return u}function FH(n,t,e){0===e&&n.push(t)}function wce(n,t,e){0===e&&(n.push(~t),n.push(t))}function CR(n,t,e,i,r){null!==t&&n.push(t),n.push(e,r,function(n,t,e){return 0|t<<17|e<<1}(0,i,r))}function Tce(n,t,e){n.push(t<<1|1,e.name,e.value)}var NH=0,Dce=/\[(\ufffd.+?\ufffd?)\]/,Ice=/\[(\ufffd.+?\ufffd?)\]|(\ufffd\/?\*\d+:\d+\ufffd)/g,Ace=/({\s*)(VAR_(PLURAL|SELECT)(_\d+)?)(\s*,)/g,Rce=/{([A-Z0-9_]+)}/g,Pce=/\ufffdI18N_EXP_(ICU(_\d+)?)\ufffd/g,Oce=/\/\*/,kce=/\d+\:(\d+)/;function qU(n,t,e=-1){let i=Ei(),r=Ze(),o=Wr+n,s=iu(i.consts,t),a=q_();i.firstCreatePass&&function(n,t,e,i,r,o){let s=q_(),a=[],l=[],c=[[]];r=function(n,t){if(function(n){return-1===n}(t))return kH(n);{let e=n.indexOf(`:${t}${H_}`)+2+t.toString().length,i=n.search(new RegExp(`${H_}\\/\\*\\d+:${t}${H_}`));return kH(n.substring(e,i))}}(r,o);let d=function(n){return n.replace(mce," ")}(r).split(fce);for(let u=0;u<d.length;u++){let p=d[u];if(0==(1&u)){let f=vP(p);for(let m=0;m<f.length;m++){let b=f[m];if(0==(1&m))""!==b&&_ce(n,s,c[0],a,l,e,b);else{let M=b;if("object"!=typeof M)throw new Error(`Unable to parse ICU expression in "${r}" message.`);GU(n,e,l,t,M,UU(n,s,c[0],e,a,"",!0).index)}}}else{let f=47===p.charCodeAt(0),b=(p.charCodeAt(f?1:0),Wr+Number.parseInt(p.substring(f?2:1)));if(f)c.shift(),dc(q_(),!1);else{let M=ece(n,c[0],b);c.unshift([]),dc(M,!0)}}}n.data[i]={create:a,update:l}}(i,null===a?0:a.index,r,o,s,e);let l=i.data[o],d=W5(i,a===r[Ss]?null:a,r);(function(n,t,e,i){let r=n[oi];for(let o=0;o<t.length;o++){let s=t[o++],a=t[o],c=(s&gl.APPEND_EAGERLY)===gl.APPEND_EAGERLY,d=s>>>gl.SHIFT,u=n[d];null===u&&(u=n[d]=(s&gl.COMMENT)===gl.COMMENT?r.createComment(a):sO(r,a)),c&&null!==e&&Up(r,e,u,i,!1)}})(r,l.create,d,a&&8&a.type?r[a.index]:null),h5(!0)}function YU(){h5(!1)}function qM(n,t,e){qU(n,t,e),YU()}function hb(n){return function(n){n&&(Z_|=1<<Math.min(V_,31)),V_++}(Uo(Ze(),eh(),n)),hb}function YM(n){!function(n,t,e){if(V_>0){let i=n.data[e];VU(n,t,Array.isArray(i)?i:i.update,rd()-V_-1,Z_)}Z_=0,V_=0}(Ei(),Ze(),n+Wr)}function XM(n,t={}){return function(n,t={}){let e=n;if(Dce.test(n)){let i={},r=[NH];e=e.replace(Ice,(o,s,a)=>{let l=s||a,c=i[l]||[];if(c.length||(l.split("|").forEach(b=>{let M=b.match(kce),y=M?parseInt(M[1],10):NH,x=Oce.test(b);c.push([y,x,b])}),i[l]=c),!c.length)throw new Error(`i18n postprocess: unmatched placeholder - ${l}`);let d=r[r.length-1],u=0;for(let b=0;b<c.length;b++)if(c[b][0]===d){u=b;break}let[p,f,m]=c[u];return f?r.pop():d!==p&&r.push(p),c.splice(u,1),m})}return Object.keys(t).length&&(e=e.replace(Ace,(i,r,o,s,a,l)=>t.hasOwnProperty(o)?`${r}${t[o]}${l}`:i),e=e.replace(Rce,(i,r)=>t.hasOwnProperty(r)?t[r]:i),e=e.replace(Pce,(i,r)=>{if(t.hasOwnProperty(r)){let o=t[r];if(!o.length)throw new Error(`i18n postprocess: unmatched ICU - ${i} with key: ${r}`);return o.shift()}return i})),e}(n,t)}function yP(n,t,e,i,r){if(n=Ri(n),Array.isArray(n))for(let o=0;o<n.length;o++)yP(n[o],t,e,i,r);else{let o=Ei(),s=Ze(),a=Ym(n)?n:Ri(n.provide),l=yz(n),c=Po(),d=1048575&c.providerIndexes,u=c.directiveStart,p=c.providerIndexes>>20;if(Ym(n)||!n.multi){let f=new Hp(l,r,C),m=wR(a,t,r?d:d+p,u);-1===m?(HR(lM(c,s),o,a),MR(o,n,t.length),t.push(a),c.directiveStart++,c.directiveEnd++,r&&(c.providerIndexes+=1048576),e.push(f),s.push(f)):(e[m]=f,s[m]=f)}else{let f=wR(a,t,d+p,u),m=wR(a,t,d,d+p),M=m>=0&&e[m];if(r&&!M||!r&&!(f>=0&&e[f])){HR(lM(c,s),o,a);let y=function(n,t,e,i,r){let o=new Hp(n,e,C);return o.multi=[],o.index=t,o.componentProviders=0,XU(o,r,i&&!e),o}(r?Vce:Bce,e.length,r,i,l);!r&&M&&(e[m].providerFactory=y),MR(o,n,t.length,0),t.push(a),c.directiveStart++,c.directiveEnd++,r&&(c.providerIndexes+=1048576),e.push(y),s.push(y)}else MR(o,n,f>-1?f:m,XU(e[r?m:f],l,!r&&i));!r&&i&&M&&e[m].componentProviders++}}}function MR(n,t,e,i){let r=Ym(t),o=function(n){return!!n.useClass}(t);if(r||o){let l=(o?Ri(t.useClass):t).prototype.ngOnDestroy;if(l){let c=n.destroyHooks||(n.destroyHooks=[]);if(!r&&t.multi){let d=c.indexOf(e);-1===d?c.push(e,[i,l]):c[d+1].push(i,l)}else c.push(e,l)}}}function XU(n,t,e){return e&&n.componentProviders++,n.multi.push(t)-1}function wR(n,t,e,i){for(let r=e;r<i;r++)if(t[r]===n)return r;return-1}function Bce(n,t,e,i){return xP(this.multi,[])}function Vce(n,t,e,i){let o,r=this.multi;if(this.providerFactory){let s=this.providerFactory.componentProviders,a=zp(e,e[Fn],this.providerFactory.index,i);o=a.slice(0,s),xP(r,o);for(let l=s;l<a.length;l++)o.push(a[l])}else o=[],xP(r,o);return o}function xP(n,t){for(let e=0;e<n.length;e++)t.push((0,n[e])());return t}function Qt(n,t=[]){return e=>{e.providersResolver=(i,r)=>function(n,t,e){let i=Ei();if(i.firstCreatePass){let r=vl(n);yP(e,i.data,i.blueprint,r,!0),yP(t,i.data,i.blueprint,r,!1)}}(i,r?r(n):n,t)}}var ru=class{},CP=class{},MP=class extends ru{constructor(t,e){super(),this._parent=e,this._bootstrapComponents=[],this.destroyCbs=[],this.componentFactoryResolver=new mM(this);let i=Gm(t);this._bootstrapComponents=XC(i.bootstrap),this._r3Injector=Tz(t,e,[{provide:ru,useValue:this},{provide:fo,useValue:this.componentFactoryResolver}],po(t),new Set(["environment"])),this._r3Injector.resolveInjectorInitializers(),this.instance=this._r3Injector.get(t)}get injector(){return this._r3Injector}destroy(){let t=this._r3Injector;!t.destroyed&&t.destroy(),this.destroyCbs.forEach(e=>e()),this.destroyCbs=null}onDestroy(t){this.destroyCbs.push(t)}},wP=class extends CP{constructor(t){super(),this.moduleType=t}create(t){return new MP(this.moduleType,t)}},SP=class extends ru{constructor(t,e,i){super(),this.componentFactoryResolver=new mM(this),this.instance=null;let r=new uM([...t,{provide:ru,useValue:this},{provide:fo,useValue:this.componentFactoryResolver}],e||hO(),i,new Set(["environment"]));this.injector=r,r.resolveInjectorInitializers()}destroy(){this.injector.destroy()}onDestroy(t){this.injector.onDestroy(t)}},Uce=(()=>{class n{constructor(e){this._injector=e,this.cachedInjectors=new Map}getOrCreateStandaloneInjector(e){if(!e.standalone)return null;if(!this.cachedInjectors.has(e.id)){let i=_z(0,e.type),r=i.length>0?function(n,t,e=null){return new SP(n,t,e).injector}([i],this._injector,`Standalone[${e.type.name}]`):null;this.cachedInjectors.set(e.id,r)}return this.cachedInjectors.get(e.id)}ngOnDestroy(){try{for(let e of this.cachedInjectors.values())null!==e&&e.destroy()}finally{this.cachedInjectors.clear()}}}return n.\u0275prov=ue({token:n,providedIn:"environment",factory:()=>new n(k(pc))}),n})();function IO(n){n.getStandaloneInjector=t=>t.get(Uce).getOrCreateStandaloneInjector(n)}function cu(n,t,e){let i=os()+n,r=Ze();return r[i]===Hn?_c(r,i,e?t.call(e):t()):pb(r,i)}function In(n,t,e,i){return QU(Ze(),os(),n,t,e,i)}function qr(n,t,e,i,r){return ZU(Ze(),os(),n,t,e,i,r)}function gb(n,t,e,i,r,o){return KU(Ze(),os(),n,t,e,i,r,o)}function AO(n,t,e,i,r,o,s){return JU(Ze(),os(),n,t,e,i,r,o,s)}function RO(n,t,e,i,r,o,s,a){let l=os()+n,c=Ze(),d=Pa(c,l,e,i,r,o);return Uo(c,l+4,s)||d?_c(c,l+5,a?t.call(a,e,i,r,o,s):t(e,i,r,o,s)):pb(c,l+5)}function _b(n,t){let e=n[t];return e===Hn?void 0:e}function QU(n,t,e,i,r,o){let s=t+e;return Uo(n,s,r)?_c(n,s+1,o?i.call(o,r):i(r)):_b(n,s+1)}function ZU(n,t,e,i,r,o,s){let a=t+e;return Gp(n,a,r,o)?_c(n,a+2,s?i.call(s,r,o):i(r,o)):_b(n,a+2)}function KU(n,t,e,i,r,o,s,a){let l=t+e;return HM(n,l,r,o,s)?_c(n,l+3,a?i.call(a,r,o,s):i(r,o,s)):_b(n,l+3)}function JU(n,t,e,i,r,o,s,a,l){let c=t+e;return Pa(n,c,r,o,s,a)?_c(n,c+4,l?i.call(l,r,o,s,a):i(r,o,s,a)):_b(n,c+4)}function $U(n,t,e,i,r,o){let s=t+e,a=!1;for(let l=0;l<r.length;l++)Uo(n,s++,r[l])&&(a=!0);return a?_c(n,s,i.apply(o,r)):_b(n,s)}function j(n,t){let i,e=Ei(),r=n+Wr;e.firstCreatePass?(i=function(n,t){if(t)for(let e=t.length-1;e>=0;e--){let i=t[e];if(n===i.name)return i}}(t,e.pipeRegistry),e.data[r]=i,i.onDestroy&&(e.destroyHooks??(e.destroyHooks=[])).push(r,i.onDestroy)):i=e.data[r];let o=i.factory||(i.factory=Bp(i.type)),s=Ea(C);try{let a=aM(!1),l=o();return aM(a),function(n,t,e,i){e>=n.data.length&&(n.data[e]=null,n.blueprint[e]=null),t[e]=i}(e,Ze(),r,l),l}finally{Ea(s)}}function W(n,t,e){let i=n+Wr,r=Ze(),o=$m(r,i);return bb(r,i)?QU(r,os(),t,o.transform,e,o):o.transform(e)}function qp(n,t,e,i){let r=n+Wr,o=Ze(),s=$m(o,r);return bb(o,r)?ZU(o,os(),t,s.transform,e,i,s):s.transform(e,i)}function PO(n,t,e,i,r){let o=n+Wr,s=Ze(),a=$m(s,o);return bb(s,o)?KU(s,os(),t,a.transform,e,i,r,a):a.transform(e,i,r)}function bb(n,t){return n[Fn].data[t].pure}function SR(n){return t=>{setTimeout(n,void 0,t)}}var F=class extends Ie{constructor(t=!1){super(),this.__isAsync=t}emit(t){super.next(t)}subscribe(t,e,i){let r=t,o=e||(()=>null),s=i;if(t&&"object"==typeof t){let l=t;r=l.next?.bind(l),o=l.error?.bind(l),s=l.complete?.bind(l)}this.__isAsync&&(o=SR(o),r&&(r=SR(r)),s&&(s=SR(s)));let a=super.subscribe({next:r,error:o,complete:s});return t instanceof Mn&&t.add(a),a}};function Zce(){return this._results[Symbol.iterator]()}var Oa=class{get changes(){return this._changes||(this._changes=new F)}constructor(t=!1){this._emitDistinctChangesOnly=t,this.dirty=!0,this._results=[],this._changesDetected=!1,this._changes=null,this.length=0,this.first=void 0,this.last=void 0;let e=Oa.prototype;e[Symbol.iterator]||(e[Symbol.iterator]=Zce)}get(t){return this._results[t]}map(t){return this._results.map(t)}filter(t){return this._results.filter(t)}find(t){return this._results.find(t)}reduce(t,e){return this._results.reduce(t,e)}forEach(t){this._results.forEach(t)}some(t){return this._results.some(t)}toArray(){return this._results.slice()}toString(){return this._results.toString()}reset(t,e){let i=this;i.dirty=!1;let r=$d(t);(this._changesDetected=!function(n,t,e){if(n.length!==t.length)return!1;for(let i=0;i<n.length;i++){let r=n[i],o=t[i];if(e&&(r=e(r),o=e(o)),o!==r)return!1}return!0}(i._results,r,e))&&(i._results=r,i.length=r.length,i.last=r[this.length-1],i.first=r[0])}notifyOnChanges(){this._changes&&(this._changesDetected||!this._emitDistinctChangesOnly)&&this._changes.emit(this)}setDirty(){this.dirty=!0}destroy(){this.changes.complete(),this.changes.unsubscribe()}},Si=(()=>{class n{}return n.__NG_ELEMENT_ID__=$ce,n})(),Kce=Si,Jce=class extends Kce{constructor(t,e,i){super(),this._declarationLView=t,this._declarationTContainer=e,this.elementRef=i}createEmbeddedView(t,e){let i=this._declarationTContainer.tView,r=LM(this._declarationLView,i,t,16,null,i.declTNode,null,null,null,null,e||null);r[rb]=this._declarationLView[this._declarationTContainer.index];let s=this._declarationLView[cc];return null!==s&&(r[cc]=s.createEmbeddedView(i)),_O(i,r,t),new jp(r)}};function $ce(){return QM(Po(),Ze())}function QM(n,t){return 4&n.type?new Jce(t,n,rh(n,t)):null}var si=(()=>{class n{}return n.__NG_ELEMENT_ID__=ede,n})();function ede(){return tj(Po(),Ze())}var tde=si,ej=class extends tde{constructor(t,e,i){super(),this._lContainer=t,this._hostTNode=e,this._hostLView=i}get element(){return rh(this._hostTNode,this._hostLView)}get injector(){return new Lp(this._hostTNode,this._hostLView)}get parentInjector(){let t=JP(this._hostTNode,this._hostLView);if(w5(t)){let e=sM(t,this._hostLView),i=oM(t);return new Lp(e[Fn].data[i+8],e)}return new Lp(null,this._hostLView)}clear(){for(;this.length>0;)this.remove(this.length-1)}get(t){let e=LH(this._lContainer);return null!==e&&e[t]||null}get length(){return this._lContainer.length-ws}createEmbeddedView(t,e,i){let r,o;"number"==typeof i?r=i:null!=i&&(r=i.index,o=i.injector);let s=t.createEmbeddedView(e||{},o);return this.insert(s,r),s}createComponent(t,e,i,r,o){let a,s=t&&!R_(t);if(s)a=e;else{let u=e||{};a=u.index,i=u.injector,r=u.projectableNodes,o=u.environmentInjector||u.ngModuleRef}let l=s?t:new hM(Da(t)),c=i||this.parentInjector;if(!o&&null==l.ngModule){let p=(s?c:this.parentInjector).get(pc,null);p&&(o=p)}let d=l.create(c,r,void 0,o);return this.insert(d.hostView,a),d}insert(t,e){let i=t._lView,r=i[Fn];if(nd(i[Gr])){let d=this.indexOf(t);if(-1!==d)this.detach(d);else{let u=i[Gr],p=new ej(u,u[Ss],u[Gr]);p.detach(p.indexOf(t))}}let o=this._adjustIndex(e),s=this._lContainer;!function(n,t,e,i){let r=ws+i,o=e.length;i>0&&(e[r-1][_l]=t),i<o-ws?(t[_l]=e[r],k5(e,ws+i,t)):(e.push(t),t[_l]=null),t[Gr]=e;let s=t[rb];null!==s&&e!==s&&function(n,t){let e=n[Wm];t[bl]!==t[Gr][Gr][bl]&&(n[r5]=!0),null===e?n[Wm]=[t]:e.push(t)}(s,t);let a=t[cc];null!==a&&a.insertView(n),t[ri]|=64}(r,i,s,o);let a=qR(o,s),l=i[oi],c=PM(l,s[jP]);return null!==c&&function(n,t,e,i,r,o){i[su]=r,i[Ss]=t,ab(n,i,e,1,r,o)}(r,s[Ss],l,i,c,a),t.attachToViewContainerRef(),k5(ER(s),o,t),t}move(t,e){return this.insert(t,e)}indexOf(t){let e=LH(this._lContainer);return null!==e?e.indexOf(t):-1}remove(t){let e=this._adjustIndex(t,-1),i=GR(this._lContainer,e);i&&(cM(ER(this._lContainer),e),j5(i[Fn],i))}detach(t){let e=this._adjustIndex(t,-1),i=GR(this._lContainer,e);return i&&null!=cM(ER(this._lContainer),e)?new jp(i):null}_adjustIndex(t,e=0){return t??this.length+e}};function LH(n){return n[iM]}function ER(n){return n[iM]||(n[iM]=[])}function tj(n,t){let e,i=t[n.index];if(nd(i))e=i;else{let r;if(8&n.type)r=Ra(i);else{let o=t[oi];r=o.createComment("");let s=oa(n,t);Up(o,PM(o,s),r,function(n,t){return n.nextSibling(t)}(o,s),!1)}t[n.index]=e=kz(i,t,r,n),VM(t,e)}return new ej(e,n,t)}var K_=class{constructor(t){this.queryList=t,this.matches=null}clone(){return new K_(this.queryList)}setDirty(){this.queryList.setDirty()}},J_=class{constructor(t=[]){this.queries=t}createEmbeddedView(t){let e=t.queries;if(null!==e){let i=null!==t.contentQueries?t.contentQueries[0]:e.length,r=[];for(let o=0;o<i;o++){let s=e.getByIndex(o);r.push(this.queries[s.indexInDeclarationView].clone())}return new J_(r)}return null}insertView(t){this.dirtyQueriesWithMatches(t)}detachView(t){this.dirtyQueriesWithMatches(t)}dirtyQueriesWithMatches(t){for(let e=0;e<this.queries.length;e++)null!==oj(t,e).matches&&this.queries[e].setDirty()}},vM=class{constructor(t,e,i=null){this.predicate=t,this.flags=e,this.read=i}},$_=class{constructor(t=[]){this.queries=t}elementStart(t,e){for(let i=0;i<this.queries.length;i++)this.queries[i].elementStart(t,e)}elementEnd(t){for(let e=0;e<this.queries.length;e++)this.queries[e].elementEnd(t)}embeddedTView(t){let e=null;for(let i=0;i<this.length;i++){let r=null!==e?e.length:0,o=this.getByIndex(i).embeddedTView(t,r);o&&(o.indexInDeclarationView=i,null!==e?e.push(o):e=[o])}return null!==e?new $_(e):null}template(t,e){for(let i=0;i<this.queries.length;i++)this.queries[i].template(t,e)}getByIndex(t){return this.queries[t]}get length(){return this.queries.length}track(t){this.queries.push(t)}},eb=class{constructor(t,e=-1){this.metadata=t,this.matches=null,this.indexInDeclarationView=-1,this.crossesNgTemplate=!1,this._appliesToNextNode=!0,this._declarationNodeIndex=e}elementStart(t,e){this.isApplyingToNode(e)&&this.matchTNode(t,e)}elementEnd(t){this._declarationNodeIndex===t.index&&(this._appliesToNextNode=!1)}template(t,e){this.elementStart(t,e)}embeddedTView(t,e){return this.isApplyingToNode(t)?(this.crossesNgTemplate=!0,this.addMatch(-t.index,e),new eb(this.metadata)):null}isApplyingToNode(t){if(this._appliesToNextNode&&1!=(1&this.metadata.flags)){let e=this._declarationNodeIndex,i=t.parent;for(;null!==i&&8&i.type&&i.index!==e;)i=i.parent;return e===(null!==i?i.index:-1)}return this._appliesToNextNode}matchTNode(t,e){let i=this.metadata.predicate;if(Array.isArray(i))for(let r=0;r<i.length;r++){let o=i[r];this.matchTNodeWithReadOption(t,e,nde(e,o)),this.matchTNodeWithReadOption(t,e,WC(e,t,o,!1,!1))}else i===Si?4&e.type&&this.matchTNodeWithReadOption(t,e,-1):this.matchTNodeWithReadOption(t,e,WC(e,t,i,!1,!1))}matchTNodeWithReadOption(t,e,i){if(null!==i){let r=this.metadata.read;if(null!==r)if(r===Me||r===si||r===Si&&4&e.type)this.addMatch(e.index,-2);else{let o=WC(e,t,r,!1,!1);null!==o&&this.addMatch(e.index,o)}else this.addMatch(e.index,i)}}addMatch(t,e){null===this.matches?this.matches=[t,e]:this.matches.push(t,e)}};function nde(n,t){let e=n.localNames;if(null!==e)for(let i=0;i<e.length;i+=2)if(e[i]===t)return e[i+1];return null}function rde(n,t,e,i){return-1===e?function(n,t){return 11&n.type?rh(n,t):4&n.type?QM(n,t):null}(t,n):-2===e?function(n,t,e){return e===Me?rh(t,n):e===Si?QM(t,n):e===si?tj(t,n):void 0}(n,t,i):zp(n,n[Fn],e,t)}function nj(n,t,e,i){let r=t[cc].queries[i];if(null===r.matches){let o=n.data,s=e.matches,a=[];for(let l=0;l<s.length;l+=2){let c=s[l];a.push(c<0?null:rde(t,o[c],s[l+1],e.metadata.read))}r.matches=a}return r.matches}function TP(n,t,e,i){let r=n.queries.getByIndex(e),o=r.matches;if(null!==o){let s=nj(n,t,r,e);for(let a=0;a<o.length;a+=2){let l=o[a];if(l>0)i.push(s[a/2]);else{let c=o[a+1],d=t[-l];for(let u=ws;u<d.length;u++){let p=d[u];p[rb]===p[Gr]&&TP(p[Fn],p,c,i)}if(null!==d[Wm]){let u=d[Wm];for(let p=0;p<u.length;p++){let f=u[p];TP(f[Fn],f,c,i)}}}}}return i}function Se(n){let t=Ze(),e=Ei(),i=g5();QP(i+1);let r=oj(e,i);if(n.dirty&&function(n){return 4==(4&n[ri])}(t)===(2==(2&r.metadata.flags))){if(null===r.matches)n.reset([]);else{let o=r.crossesNgTemplate?TP(e,t,i,[]):nj(e,t,r,i);n.reset(o,Bse),n.notifyOnChanges()}return!0}return!1}function Ge(n,t,e){let i=Ei();i.firstCreatePass&&(rj(i,new vM(n,t,e),-1),2==(2&t)&&(i.staticViewQueries=!0)),ij(i,Ze(),t)}function Ti(n,t,e,i){let r=Ei();if(r.firstCreatePass){let o=Po();rj(r,new vM(t,e,i),o.index),function(n,t){let e=n.contentQueries||(n.contentQueries=[]);t!==(e.length?e[e.length-1]:-1)&&e.push(n.queries.length-1,t)}(r,n),2==(2&e)&&(r.staticContentQueries=!0)}ij(r,Ze(),e)}function Ee(){return n=Ze(),t=g5(),n[cc].queries[t].queryList;var n,t}function ij(n,t,e){let i=new Oa(4==(4&e));Rz(n,t,i,i.destroy),null===t[cc]&&(t[cc]=new J_),t[cc].queries.push(new K_(i))}function rj(n,t,e){null===n.queries&&(n.queries=new $_),n.queries.track(new eb(t,e))}function oj(n,t){return n.queries.getByIndex(t)}function Wt(n,t){return QM(n,t)}var eu={"\u0275\u0275attribute":Be,"\u0275\u0275attributeInterpolate1":function jz(n,t,e,i,r,o){let s=Ze(),a=ah(s,t,e,i);return a!==Hn&&gc(kr(),s,n,a,r,o),jz},"\u0275\u0275attributeInterpolate2":function Gz(n,t,e,i,r,o,s,a){let l=Ze(),c=lh(l,t,e,i,r,o);return c!==Hn&&gc(kr(),l,n,c,s,a),Gz},"\u0275\u0275attributeInterpolate3":function Wz(n,t,e,i,r,o,s,a,l,c){let d=Ze(),u=ch(d,t,e,i,r,o,s,a);return u!==Hn&&gc(kr(),d,n,u,l,c),Wz},"\u0275\u0275attributeInterpolate4":function qz(n,t,e,i,r,o,s,a,l,c,d,u){let p=Ze(),f=dh(p,t,e,i,r,o,s,a,l,c);return f!==Hn&&gc(kr(),p,n,f,d,u),qz},"\u0275\u0275attributeInterpolate5":function Yz(n,t,e,i,r,o,s,a,l,c,d,u,p,f){let m=Ze(),b=uh(m,t,e,i,r,o,s,a,l,c,d,u);return b!==Hn&&gc(kr(),m,n,b,p,f),Yz},"\u0275\u0275attributeInterpolate6":function Xz(n,t,e,i,r,o,s,a,l,c,d,u,p,f,m,b){let M=Ze(),y=ph(M,t,e,i,r,o,s,a,l,c,d,u,p,f);return y!==Hn&&gc(kr(),M,n,y,m,b),Xz},"\u0275\u0275attributeInterpolate7":function Qz(n,t,e,i,r,o,s,a,l,c,d,u,p,f,m,b,M,y){let x=Ze(),R=fh(x,t,e,i,r,o,s,a,l,c,d,u,p,f,m,b);return R!==Hn&&gc(kr(),x,n,R,M,y),Qz},"\u0275\u0275attributeInterpolate8":function Zz(n,t,e,i,r,o,s,a,l,c,d,u,p,f,m,b,M,y,x,R){let A=Ze(),V=mh(A,t,e,i,r,o,s,a,l,c,d,u,p,f,m,b,M,y);return V!==Hn&&gc(kr(),A,n,V,x,R),Zz},"\u0275\u0275attributeInterpolateV":function Kz(n,t,e,i){let r=Ze(),o=sh(r,t);return o!==Hn&&gc(kr(),r,n,o,e,i),Kz},"\u0275\u0275defineComponent":O,"\u0275\u0275defineDirective":we,"\u0275\u0275defineInjectable":ue,"\u0275\u0275defineInjector":U,"\u0275\u0275defineNgModule":G,"\u0275\u0275definePipe":Km,"\u0275\u0275directiveInject":C,"\u0275\u0275getInheritedFactory":Xn,"\u0275\u0275inject":k,"\u0275\u0275injectAttribute":yo,"\u0275\u0275invalidFactory":Is,"\u0275\u0275invalidFactoryDep":JH,"\u0275\u0275templateRefExtractor":Wt,"\u0275\u0275resetView":Q,"\u0275\u0275HostDirectivesFeature":function(n){return t=>{t.findHostDirectiveDefs=zz,t.hostDirectives=(Array.isArray(n)?n:n()).map(e=>"function"==typeof e?{directive:Ri(e),inputs:$c,outputs:$c}:{directive:Ri(e.directive),inputs:SH(e.inputs),outputs:SH(e.outputs)})}},"\u0275\u0275NgOnChangesFeature":Gt,"\u0275\u0275ProvidersFeature":Qt,"\u0275\u0275CopyDefinitionFeature":function(n){let e,t=Hz(n.type);e=vl(n)?t.\u0275cmp:t.\u0275dir;let i=n;for(let r of Wae)i[r]=e[r];if(vl(e))for(let r of qae)i[r]=e[r]},"\u0275\u0275InheritDefinitionFeature":Ke,"\u0275\u0275StandaloneFeature":IO,"\u0275\u0275nextContext":w,"\u0275\u0275namespaceHTML":Oo,"\u0275\u0275namespaceMathML":function(){jn.lFrame.currentNamespace=c5},"\u0275\u0275namespaceSVG":Nn,"\u0275\u0275enableBindings":function(){jn.bindingsEnabled=!0},"\u0275\u0275disableBindings":function(){jn.bindingsEnabled=!1},"\u0275\u0275elementStart":h,"\u0275\u0275elementEnd":g,"\u0275\u0275element":P,"\u0275\u0275elementContainerStart":Ot,"\u0275\u0275elementContainerEnd":kt,"\u0275\u0275elementContainer":li,"\u0275\u0275pureFunction0":cu,"\u0275\u0275pureFunction1":In,"\u0275\u0275pureFunction2":qr,"\u0275\u0275pureFunction3":gb,"\u0275\u0275pureFunction4":AO,"\u0275\u0275pureFunction5":RO,"\u0275\u0275pureFunction6":function(n,t,e,i,r,o,s,a,l){let c=os()+n,d=Ze(),u=Pa(d,c,e,i,r,o);return Gp(d,c+4,s,a)||u?_c(d,c+6,l?t.call(l,e,i,r,o,s,a):t(e,i,r,o,s,a)):pb(d,c+6)},"\u0275\u0275pureFunction7":function(n,t,e,i,r,o,s,a,l,c){let d=os()+n,u=Ze(),p=Pa(u,d,e,i,r,o);return HM(u,d+4,s,a,l)||p?_c(u,d+7,c?t.call(c,e,i,r,o,s,a,l):t(e,i,r,o,s,a,l)):pb(u,d+7)},"\u0275\u0275pureFunction8":function(n,t,e,i,r,o,s,a,l,c,d){let u=os()+n,p=Ze(),f=Pa(p,u,e,i,r,o);return Pa(p,u+4,s,a,l,c)||f?_c(p,u+8,d?t.call(d,e,i,r,o,s,a,l,c):t(e,i,r,o,s,a,l,c)):pb(p,u+8)},"\u0275\u0275pureFunctionV":function(n,t,e,i){return $U(Ze(),os(),n,t,e,i)},"\u0275\u0275getCurrentView":ge,"\u0275\u0275restoreView":X,"\u0275\u0275listener":I,"\u0275\u0275projection":zt,"\u0275\u0275syntheticHostProperty":GM,"\u0275\u0275syntheticHostListener":zM,"\u0275\u0275pipeBind1":W,"\u0275\u0275pipeBind2":qp,"\u0275\u0275pipeBind3":PO,"\u0275\u0275pipeBind4":function(n,t,e,i,r,o){let s=n+Wr,a=Ze(),l=$m(a,s);return bb(a,s)?JU(a,os(),t,l.transform,e,i,r,o,l):l.transform(e,i,r,o)},"\u0275\u0275pipeBindV":function(n,t,e){let i=n+Wr,r=Ze(),o=$m(r,i);return bb(r,i)?$U(r,os(),t,o.transform,e,o):o.transform.apply(o,e)},"\u0275\u0275projectionDef":Dn,"\u0275\u0275hostProperty":jo,"\u0275\u0275property":_,"\u0275\u0275propertyInterpolate":Wi,"\u0275\u0275propertyInterpolate1":fb,"\u0275\u0275propertyInterpolate2":UM,"\u0275\u0275propertyInterpolate3":function $z(n,t,e,i,r,o,s,a,l){let c=Ze(),d=ch(c,t,e,i,r,o,s,a);return d!==Hn&&aa(Ei(),kr(),c,n,d,c[oi],l,!1),$z},"\u0275\u0275propertyInterpolate4":function eU(n,t,e,i,r,o,s,a,l,c,d){let u=Ze(),p=dh(u,t,e,i,r,o,s,a,l,c);return p!==Hn&&aa(Ei(),kr(),u,n,p,u[oi],d,!1),eU},"\u0275\u0275propertyInterpolate5":function tU(n,t,e,i,r,o,s,a,l,c,d,u,p){let f=Ze(),m=uh(f,t,e,i,r,o,s,a,l,c,d,u);return m!==Hn&&aa(Ei(),kr(),f,n,m,f[oi],p,!1),tU},"\u0275\u0275propertyInterpolate6":function nU(n,t,e,i,r,o,s,a,l,c,d,u,p,f,m){let b=Ze(),M=ph(b,t,e,i,r,o,s,a,l,c,d,u,p,f);return M!==Hn&&aa(Ei(),kr(),b,n,M,b[oi],m,!1),nU},"\u0275\u0275propertyInterpolate7":function iU(n,t,e,i,r,o,s,a,l,c,d,u,p,f,m,b,M){let y=Ze(),x=fh(y,t,e,i,r,o,s,a,l,c,d,u,p,f,m,b);return x!==Hn&&aa(Ei(),kr(),y,n,x,y[oi],M,!1),iU},"\u0275\u0275propertyInterpolate8":function rU(n,t,e,i,r,o,s,a,l,c,d,u,p,f,m,b,M,y,x){let R=Ze(),A=mh(R,t,e,i,r,o,s,a,l,c,d,u,p,f,m,b,M,y);return A!==Hn&&aa(Ei(),kr(),R,n,A,R[oi],x,!1),rU},"\u0275\u0275propertyInterpolateV":function oU(n,t,e){let i=Ze(),r=sh(i,t);return r!==Hn&&aa(Ei(),kr(),i,n,r,i[oi],e,!1),oU},"\u0275\u0275pipe":j,"\u0275\u0275queryRefresh":Se,"\u0275\u0275viewQuery":Ge,"\u0275\u0275loadQuery":Ee,"\u0275\u0275contentQuery":Ti,"\u0275\u0275reference":it,"\u0275\u0275classMap":As,"\u0275\u0275classMapInterpolate1":mb,"\u0275\u0275classMapInterpolate2":function(n,t,e,i,r){Ml(sa,bc,lh(Ze(),n,t,e,i,r),!0)},"\u0275\u0275classMapInterpolate3":function(n,t,e,i,r,o,s){Ml(sa,bc,ch(Ze(),n,t,e,i,r,o,s),!0)},"\u0275\u0275classMapInterpolate4":function(n,t,e,i,r,o,s,a,l){Ml(sa,bc,dh(Ze(),n,t,e,i,r,o,s,a,l),!0)},"\u0275\u0275classMapInterpolate5":function(n,t,e,i,r,o,s,a,l,c,d){Ml(sa,bc,uh(Ze(),n,t,e,i,r,o,s,a,l,c,d),!0)},"\u0275\u0275classMapInterpolate6":function(n,t,e,i,r,o,s,a,l,c,d,u,p){Ml(sa,bc,ph(Ze(),n,t,e,i,r,o,s,a,l,c,d,u,p),!0)},"\u0275\u0275classMapInterpolate7":function(n,t,e,i,r,o,s,a,l,c,d,u,p,f,m){Ml(sa,bc,fh(Ze(),n,t,e,i,r,o,s,a,l,c,d,u,p,f,m),!0)},"\u0275\u0275classMapInterpolate8":function(n,t,e,i,r,o,s,a,l,c,d,u,p,f,m,b,M){Ml(sa,bc,mh(Ze(),n,t,e,i,r,o,s,a,l,c,d,u,p,f,m,b,M),!0)},"\u0275\u0275classMapInterpolateV":function(n){Ml(sa,bc,sh(Ze(),n),!0)},"\u0275\u0275styleMap":Fa,"\u0275\u0275styleMapInterpolate1":function(n,t,e){Fa(ah(Ze(),n,t,e))},"\u0275\u0275styleMapInterpolate2":function(n,t,e,i,r){Fa(lh(Ze(),n,t,e,i,r))},"\u0275\u0275styleMapInterpolate3":function(n,t,e,i,r,o,s){Fa(ch(Ze(),n,t,e,i,r,o,s))},"\u0275\u0275styleMapInterpolate4":function(n,t,e,i,r,o,s,a,l){Fa(dh(Ze(),n,t,e,i,r,o,s,a,l))},"\u0275\u0275styleMapInterpolate5":function(n,t,e,i,r,o,s,a,l,c,d){Fa(uh(Ze(),n,t,e,i,r,o,s,a,l,c,d))},"\u0275\u0275styleMapInterpolate6":function(n,t,e,i,r,o,s,a,l,c,d,u,p){Fa(ph(Ze(),n,t,e,i,r,o,s,a,l,c,d,u,p))},"\u0275\u0275styleMapInterpolate7":function(n,t,e,i,r,o,s,a,l,c,d,u,p,f,m){Fa(fh(Ze(),n,t,e,i,r,o,s,a,l,c,d,u,p,f,m))},"\u0275\u0275styleMapInterpolate8":function(n,t,e,i,r,o,s,a,l,c,d,u,p,f,m,b,M){Fa(mh(Ze(),n,t,e,i,r,o,s,a,l,c,d,u,p,f,m,b,M))},"\u0275\u0275styleMapInterpolateV":function(n){Fa(sh(Ze(),n))},"\u0275\u0275styleProp":Tt,"\u0275\u0275stylePropInterpolate1":function xU(n,t,e,i,r){return Cl(n,ah(Ze(),t,e,i),r,!1),xU},"\u0275\u0275stylePropInterpolate2":function CU(n,t,e,i,r,o,s){return Cl(n,lh(Ze(),t,e,i,r,o),s,!1),CU},"\u0275\u0275stylePropInterpolate3":function MU(n,t,e,i,r,o,s,a,l){return Cl(n,ch(Ze(),t,e,i,r,o,s,a),l,!1),MU},"\u0275\u0275stylePropInterpolate4":function wU(n,t,e,i,r,o,s,a,l,c,d){return Cl(n,dh(Ze(),t,e,i,r,o,s,a,l,c),d,!1),wU},"\u0275\u0275stylePropInterpolate5":function SU(n,t,e,i,r,o,s,a,l,c,d,u,p){return Cl(n,uh(Ze(),t,e,i,r,o,s,a,l,c,d,u),p,!1),SU},"\u0275\u0275stylePropInterpolate6":function EU(n,t,e,i,r,o,s,a,l,c,d,u,p,f,m){return Cl(n,ph(Ze(),t,e,i,r,o,s,a,l,c,d,u,p,f),m,!1),EU},"\u0275\u0275stylePropInterpolate7":function TU(n,t,e,i,r,o,s,a,l,c,d,u,p,f,m,b,M){return Cl(n,fh(Ze(),t,e,i,r,o,s,a,l,c,d,u,p,f,m,b),M,!1),TU},"\u0275\u0275stylePropInterpolate8":function DU(n,t,e,i,r,o,s,a,l,c,d,u,p,f,m,b,M,y,x){return Cl(n,mh(Ze(),t,e,i,r,o,s,a,l,c,d,u,p,f,m,b,M,y),x,!1),DU},"\u0275\u0275stylePropInterpolateV":function IU(n,t,e){return Cl(n,sh(Ze(),t),e,!1),IU},"\u0275\u0275classProp":nt,"\u0275\u0275advance":v,"\u0275\u0275template":S,"\u0275\u0275text":T,"\u0275\u0275textInterpolate":bt,"\u0275\u0275textInterpolate1":He,"\u0275\u0275textInterpolate2":lu,"\u0275\u0275textInterpolate3":jM,"\u0275\u0275textInterpolate4":function hU(n,t,e,i,r,o,s,a,l){let c=Ze(),d=dh(c,n,t,e,i,r,o,s,a,l);return d!==Hn&&ld(c,ss(),d),hU},"\u0275\u0275textInterpolate5":function gU(n,t,e,i,r,o,s,a,l,c,d){let u=Ze(),p=uh(u,n,t,e,i,r,o,s,a,l,c,d);return p!==Hn&&ld(u,ss(),p),gU},"\u0275\u0275textInterpolate6":function _U(n,t,e,i,r,o,s,a,l,c,d,u,p){let f=Ze(),m=ph(f,n,t,e,i,r,o,s,a,l,c,d,u,p);return m!==Hn&&ld(f,ss(),m),_U},"\u0275\u0275textInterpolate7":function bU(n,t,e,i,r,o,s,a,l,c,d,u,p,f,m){let b=Ze(),M=fh(b,n,t,e,i,r,o,s,a,l,c,d,u,p,f,m);return M!==Hn&&ld(b,ss(),M),bU},"\u0275\u0275textInterpolate8":function vU(n,t,e,i,r,o,s,a,l,c,d,u,p,f,m,b,M){let y=Ze(),x=mh(y,n,t,e,i,r,o,s,a,l,c,d,u,p,f,m,b,M);return x!==Hn&&ld(y,ss(),x),vU},"\u0275\u0275textInterpolateV":function yU(n){let t=Ze(),e=sh(t,n);return e!==Hn&&ld(t,ss(),e),yU},"\u0275\u0275i18n":qM,"\u0275\u0275i18nAttributes":function(n,t){let e=Ei(),i=iu(e.consts,t);!function(n,t,e){let r=Po().index,o=[];if(n.firstCreatePass&&null===n.data[t]){for(let s=0;s<e.length;s+=2){let a=e[s],l=e[s+1];if(""!==l){if(dce.test(l))throw new Error(`ICU expressions are not supported in attributes. Message: "${l}".`);z_(o,l,r,a,vce(o),null)}}n.data[t]=o}}(e,n+Wr,i)},"\u0275\u0275i18nExp":hb,"\u0275\u0275i18nStart":qU,"\u0275\u0275i18nEnd":YU,"\u0275\u0275i18nApply":YM,"\u0275\u0275i18nPostprocess":XM,"\u0275\u0275resolveWindow":function(n){return n.ownerDocument.defaultView},"\u0275\u0275resolveDocument":hc,"\u0275\u0275resolveBody":function(n){return n.ownerDocument.body},"\u0275\u0275setComponentScope":ib,"\u0275\u0275setNgModuleScope":function(n,t){return ou(()=>{let e=Gm(n,!0);e.declarations=t.declarations||Vi,e.imports=t.imports||Vi,e.exports=t.exports||Vi})},"\u0275\u0275registerNgModuleType":B5,"\u0275\u0275sanitizeHtml":fO,"\u0275\u0275sanitizeStyle":function(n){let t=db();return t?t.sanitize(jr.STYLE,n)||"":xl(n,"Style")?Ds(n):Un(n)},"\u0275\u0275sanitizeResourceUrl":mz,"\u0275\u0275sanitizeScript":function(n){let t=db();if(t)return fH(t.sanitize(jr.SCRIPT,n)||"");if(xl(n,"Script"))return fH(Ds(n));throw new yt(905,!1)},"\u0275\u0275sanitizeUrl":ka,"\u0275\u0275sanitizeUrlOrResourceUrl":function(n,t,e){return function(n,t){return"src"===t&&("embed"===n||"frame"===n||"iframe"===n||"media"===n||"script"===n)||"href"===t&&("base"===n||"link"===n)?mz:ka}(t,e)(n)},"\u0275\u0275trustConstantHtml":function(n){return ih(n[0])},"\u0275\u0275trustConstantResourceUrl":function(n){return function(n){return tz()?.createScriptURL(n)||n}(n[0])},"\u0275\u0275validateIframeAttribute":function(n,t,e){let i=Ze(),r=kr(),o=oa(r,i);if(2===r.type&&"iframe"===t.toLowerCase()){let s=o;throw s.src="",s.srcdoc=ih(""),lO(i[oi],s),new yt(-910,!1)}return n},forwardRef:$n,resolveForwardRef:Ri},P_=null;function sj(n){return!!Gm(n)}var ZC=[],TR=!1;function aj(n){return Array.isArray(n)?n.every(aj):!!Ri(n)}function hde(n,t){let e=$d(t.declarations||Vi),i=Zm(n);e.forEach(r=>{(r=Ri(r)).hasOwnProperty(SM)?lj(Da(r),i):!r.hasOwnProperty(HP)&&!r.hasOwnProperty(zP)&&(r.ngSelectorScope=n)})}function lj(n,t){n.directiveDefs=()=>Array.from(t.compilation.directives).map(e=>e.hasOwnProperty(SM)?Da(e):tu(e)).filter(e=>!!e),n.pipeDefs=()=>Array.from(t.compilation.pipes).map(e=>nu(e)),n.schemas=t.schemas,n.tView=null}function Zm(n){if(sj(n))return function(n){let t=Gm(n,!0);if(null!==t.transitiveCompileScopes)return t.transitiveCompileScopes;let e={schemas:t.schemas||null,compilation:{directives:new Set,pipes:new Set},exported:{directives:new Set,pipes:new Set}};return XC(t.imports).forEach(i=>{let r=Zm(i);r.exported.directives.forEach(o=>e.compilation.directives.add(o)),r.exported.pipes.forEach(o=>e.compilation.pipes.add(o))}),XC(t.declarations).forEach(i=>{nu(i)?e.compilation.pipes.add(i):e.compilation.directives.add(i)}),XC(t.exports).forEach(i=>{let r=i;if(sj(r)){let o=Zm(r);o.exported.directives.forEach(s=>{e.compilation.directives.add(s),e.exported.directives.add(s)}),o.exported.pipes.forEach(s=>{e.compilation.pipes.add(s),e.exported.pipes.add(s)})}else nu(r)?e.exported.pipes.add(r):e.exported.directives.add(r)}),t.transitiveCompileScopes=e,e}(n);if(e5(n)){if(null!==(Da(n)||tu(n)))return{schemas:null,compilation:{directives:new Set,pipes:new Set},exported:{directives:new Set([n]),pipes:new Set}};if(null!==nu(n))return{schemas:null,compilation:{directives:new Set,pipes:new Set},exported:{directives:new Set,pipes:new Set([n])}}}throw new Error(`${n.name} does not have a module def (\u0275mod property)`)}function BH(n){return function(n){return void 0!==n.ngModule}(n)?n.ngModule:n}var DR=0;function cj(n,t){let e=null;uj(n,t||{}),Object.defineProperty(n,HP,{get:()=>{if(null===e){let i=dj(n,t||{});e=Ia().compileDirective(eu,i.sourceMapUrl,i.metadata)}return e},configurable:!1})}function dj(n,t){let e=n&&n.name,i=`ng:///${e}/\u0275dir.js`,r=Ia(),o=pj(n,t);return o.typeSourceSpan=r.createParseSourceSpan("Directive",e,i),o.usesInheritance&&fj(n),{metadata:o,sourceMapUrl:i}}function uj(n,t){let e=null;Object.defineProperty(n,ed,{get:()=>{if(null===e){let i=dj(n,t),r=Ia();e=r.compileFactory(eu,`ng:///${n.name}/\u0275fac.js`,{name:i.metadata.name,type:i.metadata.type,typeArgumentCount:0,deps:RM(n),target:r.FactoryTarget.Directive})}return e},configurable:!1})}function yde(n){return Object.getPrototypeOf(n.prototype)===Object.prototype}function pj(n,t){let e=tO(),i=e.ownPropMetadata(n);return{name:n.name,type:n,selector:void 0!==t.selector?t.selector:null,host:t.host||$c,propMetadata:i,inputs:t.inputs||Vi,outputs:t.outputs||Vi,queries:VH(n,i,mj),lifecycle:{usesOnChanges:e.hasLifecycleHook(n,"ngOnChanges")},typeSourceSpan:null,usesInheritance:!yde(n),exportAs:Mde(t.exportAs),providers:t.providers||null,viewQueries:VH(n,i,hj),isStandalone:!!t.standalone,hostDirectives:t.hostDirectives?.map(r=>"function"==typeof r?{directive:r}:r)||null}}function fj(n){let t=Object.prototype,e=Object.getPrototypeOf(n.prototype).constructor;for(;e&&e!==t;)!tu(e)&&!Da(e)&&Sde(e)&&cj(e,null),e=Object.getPrototypeOf(e)}function xde(n){return"string"==typeof n?_j(n):Ri(n)}function Cde(n,t){return{propertyName:n,predicate:xde(t.selector),descendants:t.descendants,first:t.first,read:t.read?t.read:null,static:!!t.static,emitDistinctChangesOnly:!!t.emitDistinctChangesOnly}}function VH(n,t,e){let i=[];for(let r in t)if(t.hasOwnProperty(r)){let o=t[r];o.forEach(s=>{if(e(s)){if(!s.selector)throw new Error(`Can't construct a query for the property "${r}" of "${LP(n)}" since the query selector wasn't defined.`);if(o.some(gj))throw new Error("Cannot combine @Input decorators with query decorators");i.push(Cde(r,s))}})}return i}function Mde(n){return void 0===n?null:_j(n)}function mj(n){let t=n.ngMetadataName;return"ContentChild"===t||"ContentChildren"===t}function hj(n){let t=n.ngMetadataName;return"ViewChild"===t||"ViewChildren"===t}function gj(n){return"Input"===n.ngMetadataName}function _j(n){return n.split(",").map(t=>t.trim())}var wde=["ngOnChanges","ngOnInit","ngOnDestroy","ngDoCheck","ngAfterViewInit","ngAfterViewChecked","ngAfterContentInit","ngAfterContentChecked"];function Sde(n){let t=tO();if(wde.some(i=>t.hasLifecycleHook(n,i)))return!0;let e=t.propMetadata(n);for(let i in e){let r=e[i];for(let o=0;o<r.length;o++){let s=r[o],a=s.ngMetadataName;if(gj(s)||mj(s)||hj(s)||"Output"===a||"HostBinding"===a||"HostListener"===a)return!0}}return!1}function HH(n,t){return{type:n,name:n.name,pipeName:t.name,pure:void 0===t.pure||t.pure,isStandalone:!!t.standalone}}var Tde=ob("Directive",(n={})=>n,void 0,void 0,(n,t)=>cj(n,t));function yM(...n){}ob("Component",(n={})=>({changeDetection:k_.Default,...n}),Tde,void 0,(n,t)=>function(n,t){let e=null;(function(n,t){L5(t)&&(X_.set(n,t),N5.add(n))})(n,t),uj(n,t),Object.defineProperty(n,SM,{get:()=>{if(null===e){let i=Ia();if(L5(t)){let c=[`Component '${n.name}' is not resolved:`];throw t.templateUrl&&c.push(` - templateUrl: ${t.templateUrl}`),t.styleUrls&&t.styleUrls.length&&c.push(` - styleUrls: ${JSON.stringify(t.styleUrls)}`),c.push("Did you run and wait for 'resolveComponentResources()'?"),new Error(c.join("\n"))}let o=t.preserveWhitespaces;void 0===o&&(o=null!==P_&&void 0!==P_.preserveWhitespaces&&P_.preserveWhitespaces);let s=t.encapsulation;void 0===s&&(s=null!==P_&&void 0!==P_.defaultEncapsulation?P_.defaultEncapsulation:ra.Emulated);let a=t.templateUrl||`ng:///${n.name}/template.html`,l={...pj(n,t),typeSourceSpan:i.createParseSourceSpan("Component",n.name,a),template:t.template||"",preserveWhitespaces:o,styles:t.styles||Vi,animations:t.animations,declarations:[],changeDetection:t.changeDetection,encapsulation:s,interpolation:t.interpolation,viewProviders:t.viewProviders||null};DR++;try{if(l.usesInheritance&&fj(n),e=i.compileComponent(eu,a,l),t.standalone){let c=$d(t.imports||Vi),{directiveDefs:d,pipeDefs:u}=function(n,t){let e=null,i=null;return{directiveDefs:()=>{if(null===e){e=[Da(n)];let s=new Set;for(let a of t){let l=Ri(a);if(!s.has(l))if(s.add(l),Gm(l)){let c=Zm(l);for(let d of c.exported.directives){let u=Da(d)||tu(d);u&&!s.has(d)&&(s.add(d),e.push(u))}}else{let c=Da(l)||tu(l);c&&e.push(c)}}}return e},pipeDefs:()=>{if(null===i){i=[];let s=new Set;for(let a of t){let l=Ri(a);if(!s.has(l))if(s.add(l),Gm(l)){let c=Zm(l);for(let d of c.exported.pipes){let u=nu(d);u&&!s.has(d)&&(s.add(d),i.push(u))}}else{let c=nu(l);c&&i.push(c)}}}return i}}}(n,c);e.directiveDefs=d,e.pipeDefs=u,e.dependencies=()=>c.map(Ri)}}finally{DR--}if(0===DR&&function(){if(!TR){TR=!0;try{for(let n=ZC.length-1;n>=0;n--){let{moduleType:t,ngModule:e}=ZC[n];e.declarations&&e.declarations.every(aj)&&(ZC.splice(n,1),hde(t,e))}}finally{TR=!1}}}(),function(n){return void 0!==n.ngSelectorScope}(n)){let c=Zm(n.ngSelectorScope);lj(e,c)}if(t.schemas){if(!t.standalone)throw new Error(`The 'schemas' was specified for the ${LP(n)} but is only valid on a component that is standalone.`);e.schemas=t.schemas}else t.standalone&&(e.schemas=[])}return e},configurable:!1})}(n,t)),ob("Pipe",n=>({pure:!0,...n}),void 0,void 0,(n,t)=>function(n,t){let e=null,i=null;Object.defineProperty(n,ed,{get:()=>{if(null===i){let r=HH(n,t),o=Ia();i=o.compileFactory(eu,`ng:///${r.name}/\u0275fac.js`,{name:r.name,type:r.type,typeArgumentCount:0,deps:RM(n),target:o.FactoryTarget.Pipe})}return i},configurable:!1}),Object.defineProperty(n,zP,{get:()=>{if(null===e){let r=HH(n,t);e=Ia().compilePipe(eu,`ng:///${r.name}/\u0275pipe.js`,r)}return e},configurable:!1})}(n,t)),au("Input",n=>({bindingPropertyName:n})),au("Output",n=>({bindingPropertyName:n})),au("HostBinding",n=>({hostPropertyName:n})),au("HostListener",(n,t)=>({eventName:n,args:t})),ob("NgModule",n=>n,void 0,void 0,(n,t)=>function(n,t={}){(function(n,t,e=!1){let i=$d(t.declarations||Vi),r=null;Object.defineProperty(n,$H,{configurable:!0,get:()=>(null===r&&(r=Ia().compileNgModule(eu,`ng:///${n.name}/\u0275mod.js`,{type:n,bootstrap:$d(t.bootstrap||Vi).map(Ri),declarations:i.map(Ri),imports:$d(t.imports||Vi).map(Ri).map(BH),exports:$d(t.exports||Vi).map(Ri).map(BH),schemas:t.schemas?$d(t.schemas):null,id:t.id||null}),r.schemas||(r.schemas=[])),r)});let o=null;Object.defineProperty(n,ed,{get:()=>{if(null===o){let a=Ia();o=a.compileFactory(eu,`ng:///${n.name}/\u0275fac.js`,{name:n.name,type:n,deps:RM(n),target:a.FactoryTarget.NgModule,typeArgumentCount:0})}return o},configurable:!1});let s=null;Object.defineProperty(n,RR,{get:()=>{if(null===s){let a={name:n.name,type:n,providers:t.providers||Vi,imports:[(t.imports||Vi).map(Ri),(t.exports||Vi).map(Ri)]};s=Ia().compileInjector(eu,`ng:///${n.name}/\u0275inj.js`,a)}return s},configurable:!1})})(n,t),void 0!==t.id&&B5(n,t.id),function(n,t){ZC.push({moduleType:n,ngModule:t})}(n,t)}(n,t));var OO=new ie("Application Initializer"),ZM=(()=>{class n{constructor(e){this.appInits=e,this.resolve=yM,this.reject=yM,this.initialized=!1,this.done=!1,this.donePromise=new Promise((i,r)=>{this.resolve=i,this.reject=r})}runInitializers(){if(this.initialized)return;let e=[],i=()=>{this.done=!0,this.resolve()};if(this.appInits)for(let r=0;r<this.appInits.length;r++){let o=this.appInits[r]();if(hh(o))e.push(o);else if(DO(o)){let s=new Promise((a,l)=>{o.subscribe({complete:a,error:l})});e.push(s)}}Promise.all(e).then(()=>{i()}).catch(r=>{this.reject(r)}),0===e.length&&i(),this.initialized=!0}}return n.\u0275fac=function(e){return new(e||n)(k(OO,8))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),Yp=new ie("AppId",{providedIn:"root",factory:function(){return`${IR()}${IR()}${IR()}`}});function IR(){return String.fromCharCode(97+Math.floor(25*Math.random()))}var kO=new ie("Platform Initializer"),vc=new ie("Platform ID",{providedIn:"platform",factory:()=>"unknown"}),hi=(new ie("Application Packages Root URL"),new ie("AnimationModuleType")),cd=new ie("LocaleId",{providedIn:"root",factory:()=>ai(cd,xi.Optional|xi.SkipSelf)||typeof $localize<"u"&&$localize.locale||_M}),Pde=(new ie("DefaultCurrencyCode",{providedIn:"root",factory:()=>"USD"}),new ie("Translations"),new ie("TranslationsFormat"),new ie("compilerOptions"),Promise.resolve(0));function DP(n){typeof Zone>"u"?Pde.then(()=>{n&&n.apply(null,null)}):Zone.current.scheduleMicroTask("scheduleMicrotask",n)}var at=class{constructor({enableLongStackTrace:t=!1,shouldCoalesceEventChangeDetection:e=!1,shouldCoalesceRunChangeDetection:i=!1}){if(this.hasPendingMacrotasks=!1,this.hasPendingMicrotasks=!1,this.isStable=!0,this.onUnstable=new F(!1),this.onMicrotaskEmpty=new F(!1),this.onStable=new F(!1),this.onError=new F(!1),typeof Zone>"u")throw new yt(908,!1);Zone.assertZonePatched();let r=this;r._nesting=0,r._outer=r._inner=Zone.current,Zone.TaskTrackingZoneSpec&&(r._inner=r._inner.fork(new Zone.TaskTrackingZoneSpec)),t&&Zone.longStackTraceZoneSpec&&(r._inner=r._inner.fork(Zone.longStackTraceZoneSpec)),r.shouldCoalesceEventChangeDetection=!i&&e,r.shouldCoalesceRunChangeDetection=i,r.lastRequestAnimationFrameId=-1,r.nativeRequestAnimationFrame=function(){let n=Ur.requestAnimationFrame,t=Ur.cancelAnimationFrame;if(typeof Zone<"u"&&n&&t){let e=n[Zone.__symbol__("OriginalDelegate")];e&&(n=e);let i=t[Zone.__symbol__("OriginalDelegate")];i&&(t=i)}return{nativeRequestAnimationFrame:n,nativeCancelAnimationFrame:t}}().nativeRequestAnimationFrame,function(n){let t=()=>{!function(n){n.isCheckStableRunning||-1!==n.lastRequestAnimationFrameId||(n.lastRequestAnimationFrameId=n.nativeRequestAnimationFrame.call(Ur,()=>{n.fakeTopEventTask||(n.fakeTopEventTask=Zone.root.scheduleEventTask("fakeTopEventTask",()=>{n.lastRequestAnimationFrameId=-1,IP(n),n.isCheckStableRunning=!0,FO(n),n.isCheckStableRunning=!1},void 0,()=>{},()=>{})),n.fakeTopEventTask.invoke()}),IP(n))}(n)};n._inner=n._inner.fork({name:"angular",properties:{isAngularZone:!0},onInvokeTask:(e,i,r,o,s,a)=>{try{return zH(n),e.invokeTask(r,o,s,a)}finally{(n.shouldCoalesceEventChangeDetection&&"eventTask"===o.type||n.shouldCoalesceRunChangeDetection)&&t(),UH(n)}},onInvoke:(e,i,r,o,s,a,l)=>{try{return zH(n),e.invoke(r,o,s,a,l)}finally{n.shouldCoalesceRunChangeDetection&&t(),UH(n)}},onHasTask:(e,i,r,o)=>{e.hasTask(r,o),i===r&&("microTask"==o.change?(n._hasPendingMicrotasks=o.microTask,IP(n),FO(n)):"macroTask"==o.change&&(n.hasPendingMacrotasks=o.macroTask))},onHandleError:(e,i,r,o)=>(e.handleError(r,o),n.runOutsideAngular(()=>n.onError.emit(o)),!1)})}(r)}static isInAngularZone(){return typeof Zone<"u"&&!0===Zone.current.get("isAngularZone")}static assertInAngularZone(){if(!at.isInAngularZone())throw new yt(909,!1)}static assertNotInAngularZone(){if(at.isInAngularZone())throw new yt(909,!1)}run(t,e,i){return this._inner.run(t,e,i)}runTask(t,e,i,r){let o=this._inner,s=o.scheduleEventTask("NgZoneEvent: "+r,t,kde,yM,yM);try{return o.runTask(s,e,i)}finally{o.cancelTask(s)}}runGuarded(t,e,i){return this._inner.runGuarded(t,e,i)}runOutsideAngular(t){return this._outer.run(t)}},kde={};function FO(n){if(0==n._nesting&&!n.hasPendingMicrotasks&&!n.isStable)try{n._nesting++,n.onMicrotaskEmpty.emit(null)}finally{if(n._nesting--,!n.hasPendingMicrotasks)try{n.runOutsideAngular(()=>n.onStable.emit(null))}finally{n.isStable=!0}}}function IP(n){n.hasPendingMicrotasks=!!(n._hasPendingMicrotasks||(n.shouldCoalesceEventChangeDetection||n.shouldCoalesceRunChangeDetection)&&-1!==n.lastRequestAnimationFrameId)}function zH(n){n._nesting++,n.isStable&&(n.isStable=!1,n.onUnstable.emit(null))}function UH(n){n._nesting--,FO(n)}var LO,NO=new ie(""),vb=new ie(""),KM=(()=>{class n{constructor(e,i,r){this._ngZone=e,this.registry=i,this._pendingCount=0,this._isZoneStable=!0,this._didWork=!1,this._callbacks=[],this.taskTrackingZone=null,LO||(function(n){LO=n}(r),r.addToWindow(i)),this._watchAngularEvents(),e.run(()=>{this.taskTrackingZone=typeof Zone>"u"?null:Zone.current.get("TaskTrackingZone")})}_watchAngularEvents(){this._ngZone.onUnstable.subscribe({next:()=>{this._didWork=!0,this._isZoneStable=!1}}),this._ngZone.runOutsideAngular(()=>{this._ngZone.onStable.subscribe({next:()=>{at.assertNotInAngularZone(),DP(()=>{this._isZoneStable=!0,this._runCallbacksIfReady()})}})})}increasePendingRequestCount(){return this._pendingCount+=1,this._didWork=!0,this._pendingCount}decreasePendingRequestCount(){if(this._pendingCount-=1,this._pendingCount<0)throw new Error("pending async requests below zero");return this._runCallbacksIfReady(),this._pendingCount}isStable(){return this._isZoneStable&&0===this._pendingCount&&!this._ngZone.hasPendingMacrotasks}_runCallbacksIfReady(){if(this.isStable())DP(()=>{for(;0!==this._callbacks.length;){let e=this._callbacks.pop();clearTimeout(e.timeoutId),e.doneCb(this._didWork)}this._didWork=!1});else{let e=this.getPendingTasks();this._callbacks=this._callbacks.filter(i=>!i.updateCb||!i.updateCb(e)||(clearTimeout(i.timeoutId),!1)),this._didWork=!0}}getPendingTasks(){return this.taskTrackingZone?this.taskTrackingZone.macroTasks.map(e=>({source:e.source,creationLocation:e.creationLocation,data:e.data})):[]}addCallback(e,i,r){let o=-1;i&&i>0&&(o=setTimeout(()=>{this._callbacks=this._callbacks.filter(s=>s.timeoutId!==o),e(this._didWork,this.getPendingTasks())},i)),this._callbacks.push({doneCb:e,timeoutId:o,updateCb:r})}whenStable(e,i,r){if(r&&!this.taskTrackingZone)throw new Error('Task tracking zone is required when passing an update callback to whenStable(). Is "zone.js/plugins/task-tracking" loaded?');this.addCallback(e,i,r),this._runCallbacksIfReady()}getPendingRequestCount(){return this._pendingCount}registerApplication(e){this.registry.registerApplication(e,this)}unregisterApplication(e){this.registry.unregisterApplication(e)}findProviders(e,i,r){return[]}}return n.\u0275fac=function(e){return new(e||n)(k(at),k(JM),k(vb))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),JM=(()=>{class n{constructor(){this._applications=new Map}registerApplication(e,i){this._applications.set(e,i)}unregisterApplication(e){this._applications.delete(e)}unregisterAllApplications(){this._applications.clear()}getTestability(e){return this._applications.get(e)||null}getAllTestabilities(){return Array.from(this._applications.values())}getAllRootElements(){return Array.from(this._applications.keys())}findTestabilityInTree(e,i=!0){return LO?.findTestabilityInTree(this,e,i)??null}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"platform"}),n})(),U_=null,bj=new ie("AllowMultipleToken"),vj=new ie("PlatformDestroyListeners"),Bde=new ie("appBootstrapListener");function BO(n,t,e=[]){let i=`Platform: ${t}`,r=new ie(i);return(o=[])=>{let s=yj();if(!s||s.injector.get(bj,!1)){let a=[...e,...o,{provide:r,useValue:!0}];n?n(a):function(n){if(U_&&!U_.get(bj,!1))throw new yt(400,!1);U_=n;let t=n.get(xj);(function(n){let t=n.get(kO,null);t&&t.forEach(e=>e())})(n)}(function(n=[],t){return Mi.create({name:t,providers:[{provide:NM,useValue:"platform"},{provide:vj,useValue:new Set([()=>U_=null])},...n]})}(a,i))}return function(n){let t=yj();if(!t)throw new yt(401,!1);return t}()}}function yj(){return U_?.get(xj)??null}var xj=(()=>{class n{constructor(e){this._injector=e,this._modules=[],this._destroyListeners=[],this._destroyed=!1}bootstrapModuleFactory(e,i){let r=function(n,t){let e;return e="noop"===n?new class{constructor(){this.hasPendingMicrotasks=!1,this.hasPendingMacrotasks=!1,this.isStable=!0,this.onUnstable=new F,this.onMicrotaskEmpty=new F,this.onStable=new F,this.onError=new F}run(t,e,i){return t.apply(e,i)}runGuarded(t,e,i){return t.apply(e,i)}runOutsideAngular(t){return t()}runTask(t,e,i,r){return t.apply(e,i)}}:("zone.js"===n?void 0:n)||new at(t),e}(i?.ngZone,function(n){return{enableLongStackTrace:!1,shouldCoalesceEventChangeDetection:!(!n||!n.ngZoneEventCoalescing)||!1,shouldCoalesceRunChangeDetection:!(!n||!n.ngZoneRunCoalescing)||!1}}(i)),o=[{provide:at,useValue:r}];return r.run(()=>{let s=Mi.create({providers:o,parent:this.injector,name:e.moduleType.name}),a=e.create(s),l=a.injector.get(rs,null);if(!l)throw new yt(402,!1);return r.runOutsideAngular(()=>{let c=r.onError.subscribe({next:d=>{l.handleError(d)}});a.onDestroy(()=>{KC(this._modules,a),c.unsubscribe()})}),function(n,t,e){try{let i=e();return hh(i)?i.catch(r=>{throw t.runOutsideAngular(()=>n.handleError(r)),r}):i}catch(i){throw t.runOutsideAngular(()=>n.handleError(i)),i}}(l,r,()=>{let c=a.injector.get(ZM);return c.runInitializers(),c.donePromise.then(()=>(function(n){(function(n,t){null==n&&QH("Expected localeId to be defined",n,null,"!=")})(n),"string"==typeof n&&(OU=n.toLowerCase().replace(/_/g,"-"))}(a.injector.get(cd,_M)||_M),this._moduleDoBootstrap(a),a))})})}bootstrapModule(e,i=[]){let r=Cj({},i);return function(n,t,e){let i=new wP(e);return Promise.resolve(i)}(0,0,e).then(o=>this.bootstrapModuleFactory(o,r))}_moduleDoBootstrap(e){let i=e.injector.get(yc);if(e._bootstrapComponents.length>0)e._bootstrapComponents.forEach(r=>i.bootstrap(r));else{if(!e.instance.ngDoBootstrap)throw new yt(-403,!1);e.instance.ngDoBootstrap(i)}this._modules.push(e)}onDestroy(e){this._destroyListeners.push(e)}get injector(){return this._injector}destroy(){if(this._destroyed)throw new yt(404,!1);this._modules.slice().forEach(i=>i.destroy()),this._destroyListeners.forEach(i=>i());let e=this._injector.get(vj,null);e&&(e.forEach(i=>i()),e.clear()),this._destroyed=!0}get destroyed(){return this._destroyed}}return n.\u0275fac=function(e){return new(e||n)(k(Mi))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"platform"}),n})();function Cj(n,t){return Array.isArray(t)?t.reduce(Cj,n):{...n,...t}}var yc=(()=>{class n{get destroyed(){return this._destroyed}get injector(){return this._injector}constructor(e,i,r){this._zone=e,this._injector=i,this._exceptionHandler=r,this._bootstrapListeners=[],this._views=[],this._runningTick=!1,this._stable=!0,this._destroyed=!1,this._destroyListeners=[],this.componentTypes=[],this.components=[],this._onMicrotaskEmptySubscription=this._zone.onMicrotaskEmpty.subscribe({next:()=>{this._zone.run(()=>{this.tick()})}});let o=new Kt(a=>{this._stable=this._zone.isStable&&!this._zone.hasPendingMacrotasks&&!this._zone.hasPendingMicrotasks,this._zone.runOutsideAngular(()=>{a.next(this._stable),a.complete()})}),s=new Kt(a=>{let l;this._zone.runOutsideAngular(()=>{l=this._zone.onStable.subscribe(()=>{at.assertNotInAngularZone(),DP(()=>{!this._stable&&!this._zone.hasPendingMacrotasks&&!this._zone.hasPendingMicrotasks&&(this._stable=!0,a.next(!0))})})});let c=this._zone.onUnstable.subscribe(()=>{at.assertInAngularZone(),this._stable&&(this._stable=!1,this._zone.runOutsideAngular(()=>{a.next(!1)}))});return()=>{l.unsubscribe(),c.unsubscribe()}});this.isStable=tn(o,s.pipe(Cs()))}bootstrap(e,i){let s,r=e instanceof pM;if(!this._injector.get(ZM).done)throw!r&&e5(e),new yt(405,false);s=r?e:this._injector.get(fo).resolveComponentFactory(e),this.componentTypes.push(s.componentType);let a=function(n){return n.isBoundToModule}(s)?void 0:this._injector.get(ru),c=s.create(Mi.NULL,[],i||s.selector,a),d=c.location.nativeElement,u=c.injector.get(NO,null);return u?.registerApplication(d),c.onDestroy(()=>{this.detachView(c.hostView),KC(this.components,c),u?.unregisterApplication(d)}),this._loadComponent(c),c}tick(){if(this._runningTick)throw new yt(101,!1);try{this._runningTick=!0;for(let e of this._views)e.detectChanges()}catch(e){this._zone.runOutsideAngular(()=>this._exceptionHandler.handleError(e))}finally{this._runningTick=!1}}attachView(e){let i=e;this._views.push(i),i.attachToAppRef(this)}detachView(e){let i=e;KC(this._views,i),i.detachFromAppRef()}_loadComponent(e){this.attachView(e.hostView),this.tick(),this.components.push(e);let i=this._injector.get(Bde,[]);i.push(...this._bootstrapListeners),i.forEach(r=>r(e))}ngOnDestroy(){if(!this._destroyed)try{this._destroyListeners.forEach(e=>e()),this._views.slice().forEach(e=>e.destroy()),this._onMicrotaskEmptySubscription.unsubscribe()}finally{this._destroyed=!0,this._views=[],this._bootstrapListeners=[],this._destroyListeners=[]}}onDestroy(e){return this._destroyListeners.push(e),()=>KC(this._destroyListeners,e)}destroy(){if(this._destroyed)throw new yt(406,!1);let e=this._injector;e.destroy&&!e.destroyed&&e.destroy()}get viewCount(){return this._views.length}warnIfDestroyed(){}}return n.\u0275fac=function(e){return new(e||n)(k(at),k(pc),k(rs))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})();function KC(n,t){let e=n.indexOf(t);e>-1&&n.splice(e,1)}var $t=(()=>{class n{}return n.__NG_ELEMENT_ID__=Qde,n})();function Qde(n){return function(n,t,e){if(TM(n)&&!e){let i=id(n.index,t);return new jp(i,i)}return 47&n.type?new jp(t[bl],t):null}(Po(),Ze(),16==(16&n))}var xM=class{constructor(){}supports(t){return Uz(t)}create(t){return new RP(t)}},Kde=(n,t)=>t,RP=class{constructor(t){this.length=0,this._linkedRecords=null,this._unlinkedRecords=null,this._previousItHead=null,this._itHead=null,this._itTail=null,this._additionsHead=null,this._additionsTail=null,this._movesHead=null,this._movesTail=null,this._removalsHead=null,this._removalsTail=null,this._identityChangesHead=null,this._identityChangesTail=null,this._trackByFn=t||Kde}forEachItem(t){let e;for(e=this._itHead;null!==e;e=e._next)t(e)}forEachOperation(t){let e=this._itHead,i=this._removalsHead,r=0,o=null;for(;e||i;){let s=!i||e&&e.currentIndex<GH(i,r,o)?e:i,a=GH(s,r,o),l=s.currentIndex;if(s===i)r--,i=i._nextRemoved;else if(e=e._next,null==s.previousIndex)r++;else{o||(o=[]);let c=a-r,d=l-r;if(c!=d){for(let p=0;p<c;p++){let f=p<o.length?o[p]:o[p]=0,m=f+p;d<=m&&m<c&&(o[p]=f+1)}o[s.previousIndex]=d-c}}a!==l&&t(s,a,l)}}forEachPreviousItem(t){let e;for(e=this._previousItHead;null!==e;e=e._nextPrevious)t(e)}forEachAddedItem(t){let e;for(e=this._additionsHead;null!==e;e=e._nextAdded)t(e)}forEachMovedItem(t){let e;for(e=this._movesHead;null!==e;e=e._nextMoved)t(e)}forEachRemovedItem(t){let e;for(e=this._removalsHead;null!==e;e=e._nextRemoved)t(e)}forEachIdentityChange(t){let e;for(e=this._identityChangesHead;null!==e;e=e._nextIdentityChange)t(e)}diff(t){if(null==t&&(t=[]),!Uz(t))throw new yt(900,!1);return this.check(t)?this:null}onDestroy(){}check(t){this._reset();let r,o,s,e=this._itHead,i=!1;if(Array.isArray(t)){this.length=t.length;for(let a=0;a<this.length;a++)o=t[a],s=this._trackByFn(a,o),null!==e&&Object.is(e.trackById,s)?(i&&(e=this._verifyReinsertion(e,o,s,a)),Object.is(e.item,o)||this._addIdentityChange(e,o)):(e=this._mismatch(e,o,s,a),i=!0),e=e._next}else r=0,function(n,t){if(Array.isArray(n))for(let e=0;e<n.length;e++)t(n[e]);else{let i,e=n[Symbol.iterator]();for(;!(i=e.next()).done;)t(i.value)}}(t,a=>{s=this._trackByFn(r,a),null!==e&&Object.is(e.trackById,s)?(i&&(e=this._verifyReinsertion(e,a,s,r)),Object.is(e.item,a)||this._addIdentityChange(e,a)):(e=this._mismatch(e,a,s,r),i=!0),e=e._next,r++}),this.length=r;return this._truncate(e),this.collection=t,this.isDirty}get isDirty(){return null!==this._additionsHead||null!==this._movesHead||null!==this._removalsHead||null!==this._identityChangesHead}_reset(){if(this.isDirty){let t;for(t=this._previousItHead=this._itHead;null!==t;t=t._next)t._nextPrevious=t._next;for(t=this._additionsHead;null!==t;t=t._nextAdded)t.previousIndex=t.currentIndex;for(this._additionsHead=this._additionsTail=null,t=this._movesHead;null!==t;t=t._nextMoved)t.previousIndex=t.currentIndex;this._movesHead=this._movesTail=null,this._removalsHead=this._removalsTail=null,this._identityChangesHead=this._identityChangesTail=null}}_mismatch(t,e,i,r){let o;return null===t?o=this._itTail:(o=t._prev,this._remove(t)),null!==(t=null===this._unlinkedRecords?null:this._unlinkedRecords.get(i,null))?(Object.is(t.item,e)||this._addIdentityChange(t,e),this._reinsertAfter(t,o,r)):null!==(t=null===this._linkedRecords?null:this._linkedRecords.get(i,r))?(Object.is(t.item,e)||this._addIdentityChange(t,e),this._moveAfter(t,o,r)):t=this._addAfter(new PP(e,i),o,r),t}_verifyReinsertion(t,e,i,r){let o=null===this._unlinkedRecords?null:this._unlinkedRecords.get(i,null);return null!==o?t=this._reinsertAfter(o,t._prev,r):t.currentIndex!=r&&(t.currentIndex=r,this._addToMoves(t,r)),t}_truncate(t){for(;null!==t;){let e=t._next;this._addToRemovals(this._unlink(t)),t=e}null!==this._unlinkedRecords&&this._unlinkedRecords.clear(),null!==this._additionsTail&&(this._additionsTail._nextAdded=null),null!==this._movesTail&&(this._movesTail._nextMoved=null),null!==this._itTail&&(this._itTail._next=null),null!==this._removalsTail&&(this._removalsTail._nextRemoved=null),null!==this._identityChangesTail&&(this._identityChangesTail._nextIdentityChange=null)}_reinsertAfter(t,e,i){null!==this._unlinkedRecords&&this._unlinkedRecords.remove(t);let r=t._prevRemoved,o=t._nextRemoved;return null===r?this._removalsHead=o:r._nextRemoved=o,null===o?this._removalsTail=r:o._prevRemoved=r,this._insertAfter(t,e,i),this._addToMoves(t,i),t}_moveAfter(t,e,i){return this._unlink(t),this._insertAfter(t,e,i),this._addToMoves(t,i),t}_addAfter(t,e,i){return this._insertAfter(t,e,i),this._additionsTail=null===this._additionsTail?this._additionsHead=t:this._additionsTail._nextAdded=t,t}_insertAfter(t,e,i){let r=null===e?this._itHead:e._next;return t._next=r,t._prev=e,null===r?this._itTail=t:r._prev=t,null===e?this._itHead=t:e._next=t,null===this._linkedRecords&&(this._linkedRecords=new CM),this._linkedRecords.put(t),t.currentIndex=i,t}_remove(t){return this._addToRemovals(this._unlink(t))}_unlink(t){null!==this._linkedRecords&&this._linkedRecords.remove(t);let e=t._prev,i=t._next;return null===e?this._itHead=i:e._next=i,null===i?this._itTail=e:i._prev=e,t}_addToMoves(t,e){return t.previousIndex===e||(this._movesTail=null===this._movesTail?this._movesHead=t:this._movesTail._nextMoved=t),t}_addToRemovals(t){return null===this._unlinkedRecords&&(this._unlinkedRecords=new CM),this._unlinkedRecords.put(t),t.currentIndex=null,t._nextRemoved=null,null===this._removalsTail?(this._removalsTail=this._removalsHead=t,t._prevRemoved=null):(t._prevRemoved=this._removalsTail,this._removalsTail=this._removalsTail._nextRemoved=t),t}_addIdentityChange(t,e){return t.item=e,this._identityChangesTail=null===this._identityChangesTail?this._identityChangesHead=t:this._identityChangesTail._nextIdentityChange=t,t}},PP=class{constructor(t,e){this.item=t,this.trackById=e,this.currentIndex=null,this.previousIndex=null,this._nextPrevious=null,this._prev=null,this._next=null,this._prevDup=null,this._nextDup=null,this._prevRemoved=null,this._nextRemoved=null,this._nextAdded=null,this._nextMoved=null,this._nextIdentityChange=null}},CM=class{constructor(){this.map=new Map}put(t){let e=t.trackById,i=this.map.get(e);i||(i=new class{constructor(){this._head=null,this._tail=null}add(t){null===this._head?(this._head=this._tail=t,t._nextDup=null,t._prevDup=null):(this._tail._nextDup=t,t._prevDup=this._tail,t._nextDup=null,this._tail=t)}get(t,e){let i;for(i=this._head;null!==i;i=i._nextDup)if((null===e||e<=i.currentIndex)&&Object.is(i.trackById,t))return i;return null}remove(t){let e=t._prevDup,i=t._nextDup;return null===e?this._head=i:e._nextDup=i,null===i?this._tail=e:i._prevDup=e,null===this._head}},this.map.set(e,i)),i.add(t)}get(t,e){let r=this.map.get(t);return r?r.get(t,e):null}remove(t){let e=t.trackById;return this.map.get(e).remove(t)&&this.map.delete(e),t}get isEmpty(){return 0===this.map.size}clear(){this.map.clear()}};function GH(n,t,e){let i=n.previousIndex;if(null===i)return i;let r=0;return e&&i<e.length&&(r=e[i]),i+t+r}var MM=class{constructor(){}supports(t){return t instanceof Map||EO(t)}create(){return new kP}},kP=class{constructor(){this._records=new Map,this._mapHead=null,this._appendAfter=null,this._previousMapHead=null,this._changesHead=null,this._changesTail=null,this._additionsHead=null,this._additionsTail=null,this._removalsHead=null,this._removalsTail=null}get isDirty(){return null!==this._additionsHead||null!==this._changesHead||null!==this._removalsHead}forEachItem(t){let e;for(e=this._mapHead;null!==e;e=e._next)t(e)}forEachPreviousItem(t){let e;for(e=this._previousMapHead;null!==e;e=e._nextPrevious)t(e)}forEachChangedItem(t){let e;for(e=this._changesHead;null!==e;e=e._nextChanged)t(e)}forEachAddedItem(t){let e;for(e=this._additionsHead;null!==e;e=e._nextAdded)t(e)}forEachRemovedItem(t){let e;for(e=this._removalsHead;null!==e;e=e._nextRemoved)t(e)}diff(t){if(t){if(!(t instanceof Map||EO(t)))throw new yt(900,!1)}else t=new Map;return this.check(t)?this:null}onDestroy(){}check(t){this._reset();let e=this._mapHead;if(this._appendAfter=null,this._forEach(t,(i,r)=>{if(e&&e.key===r)this._maybeAddToChanges(e,i),this._appendAfter=e,e=e._next;else{let o=this._getOrCreateRecordForKey(r,i);e=this._insertBeforeOrAppend(e,o)}}),e){e._prev&&(e._prev._next=null),this._removalsHead=e;for(let i=e;null!==i;i=i._nextRemoved)i===this._mapHead&&(this._mapHead=null),this._records.delete(i.key),i._nextRemoved=i._next,i.previousValue=i.currentValue,i.currentValue=null,i._prev=null,i._next=null}return this._changesTail&&(this._changesTail._nextChanged=null),this._additionsTail&&(this._additionsTail._nextAdded=null),this.isDirty}_insertBeforeOrAppend(t,e){if(t){let i=t._prev;return e._next=t,e._prev=i,t._prev=e,i&&(i._next=e),t===this._mapHead&&(this._mapHead=e),this._appendAfter=t,t}return this._appendAfter?(this._appendAfter._next=e,e._prev=this._appendAfter):this._mapHead=e,this._appendAfter=e,null}_getOrCreateRecordForKey(t,e){if(this._records.has(t)){let r=this._records.get(t);this._maybeAddToChanges(r,e);let o=r._prev,s=r._next;return o&&(o._next=s),s&&(s._prev=o),r._next=null,r._prev=null,r}let i=new FP(t);return this._records.set(t,i),i.currentValue=e,this._addToAdditions(i),i}_reset(){if(this.isDirty){let t;for(this._previousMapHead=this._mapHead,t=this._previousMapHead;null!==t;t=t._next)t._nextPrevious=t._next;for(t=this._changesHead;null!==t;t=t._nextChanged)t.previousValue=t.currentValue;for(t=this._additionsHead;null!=t;t=t._nextAdded)t.previousValue=t.currentValue;this._changesHead=this._changesTail=null,this._additionsHead=this._additionsTail=null,this._removalsHead=null}}_maybeAddToChanges(t,e){Object.is(e,t.currentValue)||(t.previousValue=t.currentValue,t.currentValue=e,this._addToChanges(t))}_addToAdditions(t){null===this._additionsHead?this._additionsHead=this._additionsTail=t:(this._additionsTail._nextAdded=t,this._additionsTail=t)}_addToChanges(t){null===this._changesHead?this._changesHead=this._changesTail=t:(this._changesTail._nextChanged=t,this._changesTail=t)}_forEach(t,e){t instanceof Map?t.forEach(e):Object.keys(t).forEach(i=>e(t[i],i))}},FP=class{constructor(t){this.key=t,this.previousValue=null,this.currentValue=null,this._nextPrevious=null,this._next=null,this._prev=null,this._nextAdded=null,this._nextRemoved=null,this._nextChanged=null}};function WH(){return new wl([new xM])}var wl=(()=>{class n{constructor(e){this.factories=e}static create(e,i){if(null!=i){let r=i.factories.slice();e=e.concat(r)}return new n(e)}static extend(e){return{provide:n,useFactory:i=>n.create(e,i||WH()),deps:[[n,new sd,new Ts]]}}find(e){let i=this.factories.find(r=>r.supports(e));if(null!=i)return i;throw new yt(901,!1)}}return n.\u0275prov=ue({token:n,providedIn:"root",factory:WH}),n})();function qH(){return new xb([new MM])}var xb=(()=>{class n{constructor(e){this.factories=e}static create(e,i){if(i){let r=i.factories.slice();e=e.concat(r)}return new n(e)}static extend(e){return{provide:n,useFactory:i=>n.create(e,i||qH()),deps:[[n,new sd,new Ts]]}}find(e){let i=this.factories.find(r=>r.supports(e));if(i)return i;throw new yt(901,!1)}}return n.\u0275prov=ue({token:n,providedIn:"root",factory:qH}),n})(),Jde=[new MM],$de=[new xM],Mj=(new wl($de),new xb(Jde),BO(null,"core",[])),wj=(()=>{class n{constructor(e){}}return n.\u0275fac=function(e){return new(e||n)(k(yc))},n.\u0275mod=G({type:n}),n.\u0275inj=U({}),n})();function $M(n){return"boolean"==typeof n?n:null!=n&&"false"!==n}var eue=":",du=class{static zero(){return new du([0])}static one(){return new du([1])}constructor(t){this.digits=t}clone(){return new du(this.digits.slice())}add(t){let e=this.clone();return e.addToSelf(t),e}addToSelf(t){let e=Math.max(this.digits.length,t.digits.length),i=0;for(let r=0;r<e;r++){let o=i;r<this.digits.length&&(o+=this.digits[r]),r<t.digits.length&&(o+=t.digits[r]),o>=10?(this.digits[r]=o-10,i=1):(this.digits[r]=o,i=0)}i>0&&(this.digits[e]=1)}toString(){let t="";for(let e=this.digits.length-1;e>=0;e--)t+=this.digits[e];return t}},ew=class{constructor(t){this.powerOfTwos=[t]}getValue(){return this.powerOfTwos[0]}multiplyBy(t){let e=du.zero();return this.multiplyByAndAddTo(t,e),e}multiplyByAndAddTo(t,e){for(let i=0;0!==t;t>>>=1,i++)if(1&t){let r=this.getMultipliedByPowerOfTwo(i);e.addToSelf(r)}}getMultipliedByPowerOfTwo(t){for(let e=this.powerOfTwos.length;e<=t;e++){let i=this.powerOfTwos[e-1];this.powerOfTwos[e]=i.add(i)}return this.powerOfTwos[t]}};new class{visitText(t,e){return t.value}visitContainer(t,e){return`[${t.children.map(i=>i.visit(this)).join(", ")}]`}visitIcu(t,e){let i=Object.keys(t.cases).map(r=>`${r} {${t.cases[r].visit(this)}}`);return`{${t.expression}, ${t.type}, ${i.join(", ")}}`}visitTagPlaceholder(t,e){return t.isVoid?`<ph tag name="${t.startName}"/>`:`<ph tag name="${t.startName}">${t.children.map(i=>i.visit(this)).join(", ")}</ph name="${t.closeName}">`}visitPlaceholder(t,e){return t.value?`<ph name="${t.name}">${t.value}</ph>`:`<ph name="${t.name}"/>`}visitIcuPlaceholder(t,e){return`<ph icu name="${t.name}">${t.value.visit(this)}</ph>`}},new class{constructor(t){this.base=t,this.exponents=[new ew(du.one())]}toThePowerOf(t){for(let e=this.exponents.length;e<=t;e++){let i=this.exponents[e-1].multiplyBy(this.base);this.exponents[e]=new ew(i)}return this.exponents[t]}}(256);var tw=function(n,...t){if(tw.translate){let i=tw.translate(n,t);n=i[0],t=i[1]}let e=Sj(n[0],n.raw[0]);for(let i=1;i<n.length;i++)e+=t[i-1]+Sj(n[i],n.raw[i]);return e},nue=":";function Sj(n,t){return t.charAt(0)===nue?n.substring(function(n,t){for(let e=1,i=1;e<n.length;e++,i++)if("\\"===t[i])i++;else if(n[e]===eue)return e;throw new Error(`Unterminated $localize metadata block in "${t}".`)}(n,t)+1):n}(()=>typeof globalThis<"u"&&globalThis||typeof global<"u"&&global||typeof window<"u"&&window||typeof self<"u"&&typeof WorkerGlobalScope<"u"&&self instanceof WorkerGlobalScope&&self)().$localize=tw;var YO=null;function Tl(){return YO}var dw=class{},Lt=new ie("DocumentToken"),Lj=(()=>{class n{historyGo(e){throw new Error("Not implemented")}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ue({token:n,factory:function(){return k(Bj)},providedIn:"platform"}),n})();new ie("Location Initialized");var Bj=(()=>{class n extends Lj{constructor(e){super(),this._doc=e,this._location=window.location,this._history=window.history}getBaseHrefFromDOM(){return Tl().getBaseHref(this._doc)}onPopState(e){let i=Tl().getGlobalEventTarget(this._doc,"window");return i.addEventListener("popstate",e,!1),()=>i.removeEventListener("popstate",e)}onHashChange(e){let i=Tl().getGlobalEventTarget(this._doc,"window");return i.addEventListener("hashchange",e,!1),()=>i.removeEventListener("hashchange",e)}get href(){return this._location.href}get protocol(){return this._location.protocol}get hostname(){return this._location.hostname}get port(){return this._location.port}get pathname(){return this._location.pathname}get search(){return this._location.search}get hash(){return this._location.hash}set pathname(e){this._location.pathname=e}pushState(e,i,r){Tj()?this._history.pushState(e,i,r):this._location.hash=r}replaceState(e,i,r){Tj()?this._history.replaceState(e,i,r):this._location.hash=r}forward(){this._history.forward()}back(){this._history.back()}historyGo(e=0){this._history.go(e)}getState(){return this._history.state}}return n.\u0275fac=function(e){return new(e||n)(k(Lt))},n.\u0275prov=ue({token:n,factory:function(){return new Bj(k(Lt))},providedIn:"platform"}),n})();function Tj(){return!!window.history.pushState}function Vj(n,t){if(0==n.length)return t;if(0==t.length)return n;let e=0;return n.endsWith("/")&&e++,t.startsWith("/")&&e++,2==e?n+t.substring(1):1==e?n+t:n+"/"+t}function Dj(n){let t=n.match(/#|\?|$/),e=t&&t.index||n.length;return n.slice(0,e-("/"===n[e-1]?1:0))+n.slice(e)}function Xp(n){return n&&"?"!==n[0]?"?"+n:n}var JO=(()=>{class n{historyGo(e){throw new Error("Not implemented")}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ue({token:n,factory:function(){return ai(sue)},providedIn:"root"}),n})(),oue=new ie("appBaseHref"),sue=(()=>{class n extends JO{constructor(e,i){super(),this._platformLocation=e,this._removeListenerFns=[],this._baseHref=i??this._platformLocation.getBaseHrefFromDOM()??ai(Lt).location?.origin??""}ngOnDestroy(){for(;this._removeListenerFns.length;)this._removeListenerFns.pop()()}onPopState(e){this._removeListenerFns.push(this._platformLocation.onPopState(e),this._platformLocation.onHashChange(e))}getBaseHref(){return this._baseHref}prepareExternalUrl(e){return Vj(this._baseHref,e)}path(e=!1){let i=this._platformLocation.pathname+Xp(this._platformLocation.search),r=this._platformLocation.hash;return r&&e?`${i}${r}`:i}pushState(e,i,r,o){let s=this.prepareExternalUrl(r+Xp(o));this._platformLocation.pushState(e,i,s)}replaceState(e,i,r,o){let s=this.prepareExternalUrl(r+Xp(o));this._platformLocation.replaceState(e,i,s)}forward(){this._platformLocation.forward()}back(){this._platformLocation.back()}getState(){return this._platformLocation.getState()}historyGo(e=0){this._platformLocation.historyGo?.(e)}}return n.\u0275fac=function(e){return new(e||n)(k(Lj),k(oue,8))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),wb=(()=>{class n{constructor(e){this._subject=new F,this._urlChangeListeners=[],this._urlChangeSubscription=null,this._locationStrategy=e;let i=this._locationStrategy.getBaseHref();this._basePath=function(n){if(new RegExp("^(https?:)?//").test(n)){let[,e]=n.split(/\/\/[^\/]+/);return e}return n}(Dj(Ij(i))),this._locationStrategy.onPopState(r=>{this._subject.emit({url:this.path(!0),pop:!0,state:r.state,type:r.type})})}ngOnDestroy(){this._urlChangeSubscription?.unsubscribe(),this._urlChangeListeners=[]}path(e=!1){return this.normalize(this._locationStrategy.path(e))}getState(){return this._locationStrategy.getState()}isCurrentPathEqualTo(e,i=""){return this.path()==this.normalize(e+Xp(i))}normalize(e){return n.stripTrailingSlash(function(n,t){if(!n||!t.startsWith(n))return t;let e=t.substring(n.length);return""===e||["/",";","?","#"].includes(e[0])?e:t}(this._basePath,Ij(e)))}prepareExternalUrl(e){return e&&"/"!==e[0]&&(e="/"+e),this._locationStrategy.prepareExternalUrl(e)}go(e,i="",r=null){this._locationStrategy.pushState(r,"",e,i),this._notifyUrlChangeListeners(this.prepareExternalUrl(e+Xp(i)),r)}replaceState(e,i="",r=null){this._locationStrategy.replaceState(r,"",e,i),this._notifyUrlChangeListeners(this.prepareExternalUrl(e+Xp(i)),r)}forward(){this._locationStrategy.forward()}back(){this._locationStrategy.back()}historyGo(e=0){this._locationStrategy.historyGo?.(e)}onUrlChange(e){return this._urlChangeListeners.push(e),this._urlChangeSubscription||(this._urlChangeSubscription=this.subscribe(i=>{this._notifyUrlChangeListeners(i.url,i.state)})),()=>{let i=this._urlChangeListeners.indexOf(e);this._urlChangeListeners.splice(i,1),0===this._urlChangeListeners.length&&(this._urlChangeSubscription?.unsubscribe(),this._urlChangeSubscription=null)}}_notifyUrlChangeListeners(e="",i){this._urlChangeListeners.forEach(r=>r(e,i))}subscribe(e,i,r){return this._subject.subscribe({next:e,error:i,complete:r})}}return n.normalizeQueryParams=Xp,n.joinWithSlash=Vj,n.stripTrailingSlash=Dj,n.\u0275fac=function(e){return new(e||n)(k(JO))},n.\u0275prov=ue({token:n,factory:function(){return new wb(k(JO))},providedIn:"root"}),n})();function Ij(n){return n.replace(/\/index.html$/,"")}var lw=(()=>{return(n=lw||(lw={}))[n.Decimal=0]="Decimal",n[n.Percent=1]="Percent",n[n.Currency=2]="Currency",n[n.Scientific=3]="Scientific",lw;var n})(),ko=(()=>{return(n=ko||(ko={}))[n.Format=0]="Format",n[n.Standalone=1]="Standalone",ko;var n})(),qi=(()=>{return(n=qi||(qi={}))[n.Narrow=0]="Narrow",n[n.Abbreviated=1]="Abbreviated",n[n.Wide=2]="Wide",n[n.Short=3]="Short",qi;var n})(),as=(()=>{return(n=as||(as={}))[n.Short=0]="Short",n[n.Medium=1]="Medium",n[n.Long=2]="Long",n[n.Full=3]="Full",as;var n})(),Go=(()=>{return(n=Go||(Go={}))[n.Decimal=0]="Decimal",n[n.Group=1]="Group",n[n.List=2]="List",n[n.PercentSign=3]="PercentSign",n[n.PlusSign=4]="PlusSign",n[n.MinusSign=5]="MinusSign",n[n.Exponential=6]="Exponential",n[n.SuperscriptingExponent=7]="SuperscriptingExponent",n[n.PerMille=8]="PerMille",n[n.Infinity=9]="Infinity",n[n.NaN=10]="NaN",n[n.TimeSeparator=11]="TimeSeparator",n[n.CurrencyDecimal=12]="CurrencyDecimal",n[n.CurrencyGroup=13]="CurrencyGroup",Go;var n})();function nw(n,t){return Na(Rs(n)[gr.DateFormat],t)}function iw(n,t){return Na(Rs(n)[gr.TimeFormat],t)}function rw(n,t){return Na(Rs(n)[gr.DateTimeFormat],t)}function ud(n,t){let e=Rs(n),i=e[gr.NumberSymbols][t];if(typeof i>"u"){if(t===Go.CurrencyDecimal)return e[gr.NumberSymbols][Go.Decimal];if(t===Go.CurrencyGroup)return e[gr.NumberSymbols][Go.Group]}return i}function Hj(n){if(!n[gr.ExtraData])throw new Error(`Missing extra locale data for the locale "${n[gr.LocaleId]}". Use "registerLocaleData" to load new data. See the "I18n guide" on angular.io to know more.`)}function Na(n,t){for(let e=t;e>-1;e--)if(typeof n[e]<"u")return n[e];throw new Error("Locale data API: locale data undefined")}function zO(n){let[t,e]=n.split(":");return{hours:+t,minutes:+e}}var bue=/^(\d{4,})-?(\d\d)-?(\d\d)(?:T(\d\d)(?::?(\d\d)(?::?(\d\d)(?:\.(\d+))?)?)?(Z|([+-])(\d\d):?(\d\d))?)?$/,Cb={},vue=/((?:[^BEGHLMOSWYZabcdhmswyz']+)|(?:'(?:[^']|'')*')|(?:G{1,5}|y{1,4}|Y{1,4}|M{1,5}|L{1,5}|w{1,2}|W{1}|d{1,2}|E{1,6}|c{1,6}|a{1,5}|b{1,5}|B{1,5}|h{1,2}|H{1,2}|m{1,2}|s{1,2}|S{1,3}|z{1,4}|Z{1,5}|O{1,4}))([\s\S]*)/,El=(()=>{return(n=El||(El={}))[n.Short=0]="Short",n[n.ShortGMT=1]="ShortGMT",n[n.Long=2]="Long",n[n.Extended=3]="Extended",El;var n})(),Ii=(()=>{return(n=Ii||(Ii={}))[n.FullYear=0]="FullYear",n[n.Month=1]="Month",n[n.Date=2]="Date",n[n.Hours=3]="Hours",n[n.Minutes=4]="Minutes",n[n.Seconds=5]="Seconds",n[n.FractionalSeconds=6]="FractionalSeconds",n[n.Day=7]="Day",Ii;var n})(),Di=(()=>{return(n=Di||(Di={}))[n.DayPeriods=0]="DayPeriods",n[n.Days=1]="Days",n[n.Months=2]="Months",n[n.Eras=3]="Eras",Di;var n})();function yue(n,t,e,i){let r=function(n){if(Aj(n))return n;if("number"==typeof n&&!isNaN(n))return new Date(n);if("string"==typeof n){if(n=n.trim(),/^(\d{4}(-\d{1,2}(-\d{1,2})?)?)$/.test(n)){let[r,o=1,s=1]=n.split("-").map(a=>+a);return uw(r,o-1,s)}let i,e=parseFloat(n);if(!isNaN(n-e))return new Date(e);if(i=n.match(bue))return function(n){let t=new Date(0),e=0,i=0,r=n[8]?t.setUTCFullYear:t.setFullYear,o=n[8]?t.setUTCHours:t.setHours;n[9]&&(e=Number(n[9]+n[10]),i=Number(n[9]+n[11])),r.call(t,Number(n[1]),Number(n[2])-1,Number(n[3]));let s=Number(n[4]||0)-e,a=Number(n[5]||0)-i,l=Number(n[6]||0),c=Math.floor(1e3*parseFloat("0."+(n[7]||0)));return o.call(t,s,a,l,c),t}(i)}let t=new Date(n);if(!Aj(t))throw new Error(`Unable to convert "${n}" into a date`);return t}(n);t=dd(e,t)||t;let a,s=[];for(;t;){if(a=vue.exec(t),!a){s.push(t);break}{s=s.concat(a.slice(1));let d=s.pop();if(!d)break;t=d}}let l=r.getTimezoneOffset();i&&(l=Uj(i,l),r=function(n,t,e){let r=n.getTimezoneOffset();return function(n,t){return(n=new Date(n.getTime())).setMinutes(n.getMinutes()+t),n}(n,-1*(Uj(t,r)-r))}(r,i));let c="";return s.forEach(d=>{let u=function(n){if(jO[n])return jO[n];let t;switch(n){case"G":case"GG":case"GGG":t=or(Di.Eras,qi.Abbreviated);break;case"GGGG":t=or(Di.Eras,qi.Wide);break;case"GGGGG":t=or(Di.Eras,qi.Narrow);break;case"y":t=eo(Ii.FullYear,1,0,!1,!0);break;case"yy":t=eo(Ii.FullYear,2,0,!0,!0);break;case"yyy":t=eo(Ii.FullYear,3,0,!1,!0);break;case"yyyy":t=eo(Ii.FullYear,4,0,!1,!0);break;case"Y":t=aw(1);break;case"YY":t=aw(2,!0);break;case"YYY":t=aw(3);break;case"YYYY":t=aw(4);break;case"M":case"L":t=eo(Ii.Month,1,1);break;case"MM":case"LL":t=eo(Ii.Month,2,1);break;case"MMM":t=or(Di.Months,qi.Abbreviated);break;case"MMMM":t=or(Di.Months,qi.Wide);break;case"MMMMM":t=or(Di.Months,qi.Narrow);break;case"LLL":t=or(Di.Months,qi.Abbreviated,ko.Standalone);break;case"LLLL":t=or(Di.Months,qi.Wide,ko.Standalone);break;case"LLLLL":t=or(Di.Months,qi.Narrow,ko.Standalone);break;case"w":t=UO(1);break;case"ww":t=UO(2);break;case"W":t=UO(1,!0);break;case"d":t=eo(Ii.Date,1);break;case"dd":t=eo(Ii.Date,2);break;case"c":case"cc":t=eo(Ii.Day,1);break;case"ccc":t=or(Di.Days,qi.Abbreviated,ko.Standalone);break;case"cccc":t=or(Di.Days,qi.Wide,ko.Standalone);break;case"ccccc":t=or(Di.Days,qi.Narrow,ko.Standalone);break;case"cccccc":t=or(Di.Days,qi.Short,ko.Standalone);break;case"E":case"EE":case"EEE":t=or(Di.Days,qi.Abbreviated);break;case"EEEE":t=or(Di.Days,qi.Wide);break;case"EEEEE":t=or(Di.Days,qi.Narrow);break;case"EEEEEE":t=or(Di.Days,qi.Short);break;case"a":case"aa":case"aaa":t=or(Di.DayPeriods,qi.Abbreviated);break;case"aaaa":t=or(Di.DayPeriods,qi.Wide);break;case"aaaaa":t=or(Di.DayPeriods,qi.Narrow);break;case"b":case"bb":case"bbb":t=or(Di.DayPeriods,qi.Abbreviated,ko.Standalone,!0);break;case"bbbb":t=or(Di.DayPeriods,qi.Wide,ko.Standalone,!0);break;case"bbbbb":t=or(Di.DayPeriods,qi.Narrow,ko.Standalone,!0);break;case"B":case"BB":case"BBB":t=or(Di.DayPeriods,qi.Abbreviated,ko.Format,!0);break;case"BBBB":t=or(Di.DayPeriods,qi.Wide,ko.Format,!0);break;case"BBBBB":t=or(Di.DayPeriods,qi.Narrow,ko.Format,!0);break;case"h":t=eo(Ii.Hours,1,-12);break;case"hh":t=eo(Ii.Hours,2,-12);break;case"H":t=eo(Ii.Hours,1);break;case"HH":t=eo(Ii.Hours,2);break;case"m":t=eo(Ii.Minutes,1);break;case"mm":t=eo(Ii.Minutes,2);break;case"s":t=eo(Ii.Seconds,1);break;case"ss":t=eo(Ii.Seconds,2);break;case"S":t=eo(Ii.FractionalSeconds,1);break;case"SS":t=eo(Ii.FractionalSeconds,2);break;case"SSS":t=eo(Ii.FractionalSeconds,3);break;case"Z":case"ZZ":case"ZZZ":t=sw(El.Short);break;case"ZZZZZ":t=sw(El.Extended);break;case"O":case"OO":case"OOO":case"z":case"zz":case"zzz":t=sw(El.ShortGMT);break;case"OOOO":case"ZZZZ":case"zzzz":t=sw(El.Long);break;default:return null}return jO[n]=t,t}(d);c+=u?u(r,e,l):"''"===d?"'":d.replace(/(^'|'$)/g,"").replace(/''/g,"'")}),c}function uw(n,t,e){let i=new Date(0);return i.setFullYear(n,t,e),i.setHours(0,0,0),i}function dd(n,t){let e=function(n){return Rs(n)[gr.LocaleId]}(n);if(Cb[e]=Cb[e]||{},Cb[e][t])return Cb[e][t];let i="";switch(t){case"shortDate":i=nw(n,as.Short);break;case"mediumDate":i=nw(n,as.Medium);break;case"longDate":i=nw(n,as.Long);break;case"fullDate":i=nw(n,as.Full);break;case"shortTime":i=iw(n,as.Short);break;case"mediumTime":i=iw(n,as.Medium);break;case"longTime":i=iw(n,as.Long);break;case"fullTime":i=iw(n,as.Full);break;case"short":let r=dd(n,"shortTime"),o=dd(n,"shortDate");i=ow(rw(n,as.Short),[r,o]);break;case"medium":let s=dd(n,"mediumTime"),a=dd(n,"mediumDate");i=ow(rw(n,as.Medium),[s,a]);break;case"long":let l=dd(n,"longTime"),c=dd(n,"longDate");i=ow(rw(n,as.Long),[l,c]);break;case"full":let d=dd(n,"fullTime"),u=dd(n,"fullDate");i=ow(rw(n,as.Full),[d,u])}return i&&(Cb[e][t]=i),i}function ow(n,t){return t&&(n=n.replace(/\{([^}]+)}/g,function(e,i){return null!=t&&i in t?t[i]:e})),n}function Sl(n,t,e="-",i,r){let o="";(n<0||r&&n<=0)&&(r?n=1-n:(n=-n,o=e));let s=String(n);for(;s.length<t;)s="0"+s;return i&&(s=s.slice(s.length-t)),o+s}function eo(n,t,e=0,i=!1,r=!1){return function(o,s){let a=function(n,t){switch(n){case Ii.FullYear:return t.getFullYear();case Ii.Month:return t.getMonth();case Ii.Date:return t.getDate();case Ii.Hours:return t.getHours();case Ii.Minutes:return t.getMinutes();case Ii.Seconds:return t.getSeconds();case Ii.FractionalSeconds:return t.getMilliseconds();case Ii.Day:return t.getDay();default:throw new Error(`Unknown DateType value "${n}".`)}}(n,o);if((e>0||a>-e)&&(a+=e),n===Ii.Hours)0===a&&-12===e&&(a=12);else if(n===Ii.FractionalSeconds)return function(n,t){return Sl(n,3).substring(0,t)}(a,t);let l=ud(s,Go.MinusSign);return Sl(a,t,l,i,r)}}function or(n,t,e=ko.Format,i=!1){return function(r,o){return function(n,t,e,i,r,o){switch(e){case Di.Months:return function(n,t,e){let i=Rs(n),o=Na([i[gr.MonthsFormat],i[gr.MonthsStandalone]],t);return Na(o,e)}(t,r,i)[n.getMonth()];case Di.Days:return function(n,t,e){let i=Rs(n),o=Na([i[gr.DaysFormat],i[gr.DaysStandalone]],t);return Na(o,e)}(t,r,i)[n.getDay()];case Di.DayPeriods:let s=n.getHours(),a=n.getMinutes();if(o){let c=function(n){let t=Rs(n);return Hj(t),(t[gr.ExtraData][2]||[]).map(i=>"string"==typeof i?zO(i):[zO(i[0]),zO(i[1])])}(t),d=function(n,t,e){let i=Rs(n);Hj(i);let o=Na([i[gr.ExtraData][0],i[gr.ExtraData][1]],t)||[];return Na(o,e)||[]}(t,r,i),u=c.findIndex(p=>{if(Array.isArray(p)){let[f,m]=p,b=s>=f.hours&&a>=f.minutes,M=s<m.hours||s===m.hours&&a<m.minutes;if(f.hours<m.hours){if(b&&M)return!0}else if(b||M)return!0}else if(p.hours===s&&p.minutes===a)return!0;return!1});if(-1!==u)return d[u]}return function(n,t,e){let i=Rs(n),o=Na([i[gr.DayPeriodsFormat],i[gr.DayPeriodsStandalone]],t);return Na(o,e)}(t,r,i)[s<12?0:1];case Di.Eras:return function(n,t){return Na(Rs(n)[gr.Eras],t)}(t,i)[n.getFullYear()<=0?0:1];default:throw new Error(`unexpected translation type ${e}`)}}(r,o,n,t,e,i)}}function sw(n){return function(t,e,i){let r=-1*i,o=ud(e,Go.MinusSign),s=r>0?Math.floor(r/60):Math.ceil(r/60);switch(n){case El.Short:return(r>=0?"+":"")+Sl(s,2,o)+Sl(Math.abs(r%60),2,o);case El.ShortGMT:return"GMT"+(r>=0?"+":"")+Sl(s,1,o);case El.Long:return"GMT"+(r>=0?"+":"")+Sl(s,2,o)+":"+Sl(Math.abs(r%60),2,o);case El.Extended:return 0===i?"Z":(r>=0?"+":"")+Sl(s,2,o)+":"+Sl(Math.abs(r%60),2,o);default:throw new Error(`Unknown zone width "${n}"`)}}}var wue=0,cw=4;function zj(n){return uw(n.getFullYear(),n.getMonth(),n.getDate()+(cw-n.getDay()))}function UO(n,t=!1){return function(e,i){let r;if(t){let o=new Date(e.getFullYear(),e.getMonth(),1).getDay()-1,s=e.getDate();r=1+Math.floor((s+o)/7)}else{let o=zj(e),s=function(n){let t=uw(n,wue,1).getDay();return uw(n,0,1+(t<=cw?cw:cw+7)-t)}(o.getFullYear()),a=o.getTime()-s.getTime();r=1+Math.round(a/6048e5)}return Sl(r,n,ud(i,Go.MinusSign))}}function aw(n,t=!1){return function(e,i){return Sl(zj(e).getFullYear(),n,ud(i,Go.MinusSign),t)}}var jO={};function Uj(n,t){n=n.replace(/:/g,"");let e=Date.parse("Jan 01, 1970 00:00:00 "+n)/6e4;return isNaN(e)?t:e}function Aj(n){return n instanceof Date&&!isNaN(n.valueOf())}var Rue=/^(\d+)?\.((\d+)(-(\d+))?)?$/,Rj=22,pw=".",Mb="0",Pue=";",Oue=",",GO="#";function $O(n,t,e){let i=function(n,t){return Rs(n)[gr.NumberFormats][t]}(t,lw.Decimal),r=function(n,t="-"){let e={minInt:1,minFrac:0,maxFrac:0,posPre:"",posSuf:"",negPre:"",negSuf:"",gSize:0,lgSize:0},i=n.split(Pue),r=i[0],o=i[1],s=-1!==r.indexOf(pw)?r.split(pw):[r.substring(0,r.lastIndexOf(Mb)+1),r.substring(r.lastIndexOf(Mb)+1)],a=s[0],l=s[1]||"";e.posPre=a.substring(0,a.indexOf(GO));for(let d=0;d<l.length;d++){let u=l.charAt(d);u===Mb?e.minFrac=e.maxFrac=d+1:u===GO?e.maxFrac=d+1:e.posSuf+=u}let c=a.split(Oue);if(e.gSize=c[1]?c[1].length:0,e.lgSize=c[2]||c[1]?(c[2]||c[1]).length:0,o){let d=r.length-e.posPre.length-e.posSuf.length,u=o.indexOf(GO);e.negPre=o.substring(0,u).replace(/'/g,""),e.negSuf=o.slice(u+d).replace(/'/g,"")}else e.negPre=t+e.posPre,e.negSuf=e.posSuf;return e}(i,ud(t,Go.MinusSign));return function(n,t,e,i,r,o,s=!1){let a="",l=!1;if(isFinite(n)){let c=function(n){let i,r,o,s,a,t=Math.abs(n)+"",e=0;for((r=t.indexOf(pw))>-1&&(t=t.replace(pw,"")),(o=t.search(/e/i))>0?(r<0&&(r=o),r+=+t.slice(o+1),t=t.substring(0,o)):r<0&&(r=t.length),o=0;t.charAt(o)===Mb;o++);if(o===(a=t.length))i=[0],r=1;else{for(a--;t.charAt(a)===Mb;)a--;for(r-=o,i=[],s=0;o<=a;o++,s++)i[s]=Number(t.charAt(o))}return r>Rj&&(i=i.splice(0,Rj-1),e=r-1,r=1),{digits:i,exponent:e,integerLen:r}}(n);s&&(c=function(n){if(0===n.digits[0])return n;let t=n.digits.length-n.integerLen;return n.exponent?n.exponent+=2:(0===t?n.digits.push(0,0):1===t&&n.digits.push(0),n.integerLen+=2),n}(c));let d=t.minInt,u=t.minFrac,p=t.maxFrac;if(o){let x=o.match(Rue);if(null===x)throw new Error(`${o} is not a valid digit info`);let R=x[1],A=x[3],V=x[5];null!=R&&(d=WO(R)),null!=A&&(u=WO(A)),null!=V?p=WO(V):null!=A&&u>p&&(p=u)}!function(n,t,e){if(t>e)throw new Error(`The minimum number of digits after fraction (${t}) is higher than the maximum (${e}).`);let i=n.digits,r=i.length-n.integerLen,o=Math.min(Math.max(t,r),e),s=o+n.integerLen,a=i[s];if(s>0){i.splice(Math.max(n.integerLen,s));for(let u=s;u<i.length;u++)i[u]=0}else{r=Math.max(0,r),n.integerLen=1,i.length=Math.max(1,s=o+1),i[0]=0;for(let u=1;u<s;u++)i[u]=0}if(a>=5)if(s-1<0){for(let u=0;u>s;u--)i.unshift(0),n.integerLen++;i.unshift(1),n.integerLen++}else i[s-1]++;for(;r<Math.max(0,o);r++)i.push(0);let l=0!==o,c=t+n.integerLen,d=i.reduceRight(function(u,p,f,m){return m[f]=(p+=u)<10?p:p-10,l&&(0===m[f]&&f>=c?m.pop():l=!1),p>=10?1:0},0);d&&(i.unshift(d),n.integerLen++)}(c,u,p);let f=c.digits,m=c.integerLen,b=c.exponent,M=[];for(l=f.every(x=>!x);m<d;m++)f.unshift(0);for(;m<0;m++)f.unshift(0);m>0?M=f.splice(m,f.length):(M=f,f=[0]);let y=[];for(f.length>=t.lgSize&&y.unshift(f.splice(-t.lgSize,f.length).join(""));f.length>t.gSize;)y.unshift(f.splice(-t.gSize,f.length).join(""));f.length&&y.unshift(f.join("")),a=y.join(ud(e,i)),M.length&&(a+=ud(e,r)+M.join("")),b&&(a+=ud(e,Go.Exponential)+"+"+b)}else a=ud(e,Go.Infinity);return a=n<0&&!l?t.negPre+a+t.negSuf:t.posPre+a+t.posSuf,a}(n,r,t,Go.Group,Go.Decimal,e)}function WO(n){let t=parseInt(n);if(isNaN(t))throw new Error("Invalid integer literal when parsing "+n);return t}function mw(n,t){t=encodeURIComponent(t);for(let e of n.split(";")){let i=e.indexOf("="),[r,o]=-1==i?[e,""]:[e.slice(0,i),e.slice(i+1)];if(r.trim()===t)return decodeURIComponent(o)}return null}var qO=/\s+/,Pj=[],yn=(()=>{class n{constructor(e,i,r,o){this._iterableDiffers=e,this._keyValueDiffers=i,this._ngEl=r,this._renderer=o,this.initialClasses=Pj,this.stateMap=new Map}set klass(e){this.initialClasses=null!=e?e.trim().split(qO):Pj}set ngClass(e){this.rawClass="string"==typeof e?e.trim().split(qO):e}ngDoCheck(){for(let i of this.initialClasses)this._updateState(i,!0);let e=this.rawClass;if(Array.isArray(e)||e instanceof Set)for(let i of e)this._updateState(i,!0);else if(null!=e)for(let i of Object.keys(e))this._updateState(i,Boolean(e[i]));this._applyStateDiff()}_updateState(e,i){let r=this.stateMap.get(e);void 0!==r?(r.enabled!==i&&(r.changed=!0,r.enabled=i),r.touched=!0):this.stateMap.set(e,{enabled:i,changed:!0,touched:!0})}_applyStateDiff(){for(let e of this.stateMap){let i=e[0],r=e[1];r.changed?(this._toggleClass(i,r.enabled),r.changed=!1):r.touched||(r.enabled&&this._toggleClass(i,!1),this.stateMap.delete(i)),r.touched=!1}}_toggleClass(e,i){(e=e.trim()).length>0&&e.split(qO).forEach(r=>{i?this._renderer.addClass(this._ngEl.nativeElement,r):this._renderer.removeClass(this._ngEl.nativeElement,r)})}}return n.\u0275fac=function(e){return new(e||n)(C(wl),C(xb),C(Me),C(mc))},n.\u0275dir=we({type:n,selectors:[["","ngClass",""]],inputs:{klass:["class","klass"],ngClass:"ngClass"},standalone:!0}),n})(),nn=(()=>{class n{set ngForOf(e){this._ngForOf=e,this._ngForOfDirty=!0}set ngForTrackBy(e){this._trackByFn=e}get ngForTrackBy(){return this._trackByFn}constructor(e,i,r){this._viewContainer=e,this._template=i,this._differs=r,this._ngForOf=null,this._ngForOfDirty=!0,this._differ=null}set ngForTemplate(e){e&&(this._template=e)}ngDoCheck(){if(this._ngForOfDirty){this._ngForOfDirty=!1;let e=this._ngForOf;!this._differ&&e&&(this._differ=this._differs.find(e).create(this.ngForTrackBy))}if(this._differ){let e=this._differ.diff(this._ngForOf);e&&this._applyChanges(e)}}_applyChanges(e){let i=this._viewContainer;e.forEachOperation((r,o,s)=>{if(null==r.previousIndex)i.createEmbeddedView(this._template,new class{constructor(t,e,i,r){this.$implicit=t,this.ngForOf=e,this.index=i,this.count=r}get first(){return 0===this.index}get last(){return this.index===this.count-1}get even(){return this.index%2==0}get odd(){return!this.even}}(r.item,this._ngForOf,-1,-1),null===s?void 0:s);else if(null==s)i.remove(null===o?void 0:o);else if(null!==o){let a=i.get(o);i.move(a,s),kj(a,r)}});for(let r=0,o=i.length;r<o;r++){let a=i.get(r).context;a.index=r,a.count=o,a.ngForOf=this._ngForOf}e.forEachIdentityChange(r=>{kj(i.get(r.currentIndex),r)})}static ngTemplateContextGuard(e,i){return!0}}return n.\u0275fac=function(e){return new(e||n)(C(si),C(Si),C(wl))},n.\u0275dir=we({type:n,selectors:[["","ngFor","","ngForOf",""]],inputs:{ngForOf:"ngForOf",ngForTrackBy:"ngForTrackBy",ngForTemplate:"ngForTemplate"},standalone:!0}),n})();function kj(n,t){n.context.$implicit=t.item}var Fe=(()=>{class n{constructor(e,i){this._viewContainer=e,this._context=new QO,this._thenTemplateRef=null,this._elseTemplateRef=null,this._thenViewRef=null,this._elseViewRef=null,this._thenTemplateRef=i}set ngIf(e){this._context.$implicit=this._context.ngIf=e,this._updateView()}set ngIfThen(e){Fj("ngIfThen",e),this._thenTemplateRef=e,this._thenViewRef=null,this._updateView()}set ngIfElse(e){Fj("ngIfElse",e),this._elseTemplateRef=e,this._elseViewRef=null,this._updateView()}_updateView(){this._context.$implicit?this._thenViewRef||(this._viewContainer.clear(),this._elseViewRef=null,this._thenTemplateRef&&(this._thenViewRef=this._viewContainer.createEmbeddedView(this._thenTemplateRef,this._context))):this._elseViewRef||(this._viewContainer.clear(),this._thenViewRef=null,this._elseTemplateRef&&(this._elseViewRef=this._viewContainer.createEmbeddedView(this._elseTemplateRef,this._context)))}static ngTemplateContextGuard(e,i){return!0}}return n.\u0275fac=function(e){return new(e||n)(C(si),C(Si))},n.\u0275dir=we({type:n,selectors:[["","ngIf",""]],inputs:{ngIf:"ngIf",ngIfThen:"ngIfThen",ngIfElse:"ngIfElse"},standalone:!0}),n})(),QO=class{constructor(){this.$implicit=null,this.ngIf=null}};function Fj(n,t){if(t&&!t.createEmbeddedView)throw new Error(`${n} must be a TemplateRef, but received '${po(t)}'.`)}var fw=class{constructor(t,e){this._viewContainerRef=t,this._templateRef=e,this._created=!1}create(){this._created=!0,this._viewContainerRef.createEmbeddedView(this._templateRef)}destroy(){this._created=!1,this._viewContainerRef.clear()}enforceState(t){t&&!this._created?this.create():!t&&this._created&&this.destroy()}},sr=(()=>{class n{constructor(){this._defaultViews=[],this._defaultUsed=!1,this._caseCount=0,this._lastCaseCheckIndex=0,this._lastCasesMatched=!1}set ngSwitch(e){this._ngSwitch=e,0===this._caseCount&&this._updateDefaultCases(!0)}_addCase(){return this._caseCount++}_addDefault(e){this._defaultViews.push(e)}_matchCase(e){let i=e==this._ngSwitch;return this._lastCasesMatched=this._lastCasesMatched||i,this._lastCaseCheckIndex++,this._lastCaseCheckIndex===this._caseCount&&(this._updateDefaultCases(!this._lastCasesMatched),this._lastCaseCheckIndex=0,this._lastCasesMatched=!1),i}_updateDefaultCases(e){if(this._defaultViews.length>0&&e!==this._defaultUsed){this._defaultUsed=e;for(let i of this._defaultViews)i.enforceState(e)}}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275dir=we({type:n,selectors:[["","ngSwitch",""]],inputs:{ngSwitch:"ngSwitch"},standalone:!0}),n})(),Sr=(()=>{class n{constructor(e,i,r){this.ngSwitch=r,r._addCase(),this._view=new fw(e,i)}ngDoCheck(){this._view.enforceState(this.ngSwitch._matchCase(this.ngSwitchCase))}}return n.\u0275fac=function(e){return new(e||n)(C(si),C(Si),C(sr,9))},n.\u0275dir=we({type:n,selectors:[["","ngSwitchCase",""]],inputs:{ngSwitchCase:"ngSwitchCase"},standalone:!0}),n})(),uu=(()=>{class n{constructor(e,i,r){r._addDefault(new fw(e,i))}}return n.\u0275fac=function(e){return new(e||n)(C(si),C(Si),C(sr,9))},n.\u0275dir=we({type:n,selectors:[["","ngSwitchDefault",""]],standalone:!0}),n})(),pu=(()=>{class n{constructor(e,i,r){this._ngEl=e,this._differs=i,this._renderer=r,this._ngStyle=null,this._differ=null}set ngStyle(e){this._ngStyle=e,!this._differ&&e&&(this._differ=this._differs.find(e).create())}ngDoCheck(){if(this._differ){let e=this._differ.diff(this._ngStyle);e&&this._applyChanges(e)}}_setStyle(e,i){let[r,o]=e.split("."),s=-1===r.indexOf("-")?void 0:Aa.DashCase;null!=i?this._renderer.setStyle(this._ngEl.nativeElement,r,o?`${i}${o}`:i,s):this._renderer.removeStyle(this._ngEl.nativeElement,r,s)}_applyChanges(e){e.forEachRemovedItem(i=>this._setStyle(i.key,null)),e.forEachAddedItem(i=>this._setStyle(i.key,i.currentValue)),e.forEachChangedItem(i=>this._setStyle(i.key,i.currentValue))}}return n.\u0275fac=function(e){return new(e||n)(C(Me),C(xb),C(mc))},n.\u0275dir=we({type:n,selectors:[["","ngStyle",""]],inputs:{ngStyle:"ngStyle"},standalone:!0}),n})(),Lr=(()=>{class n{constructor(e){this._viewContainerRef=e,this._viewRef=null,this.ngTemplateOutletContext=null,this.ngTemplateOutlet=null,this.ngTemplateOutletInjector=null}ngOnChanges(e){if(e.ngTemplateOutlet||e.ngTemplateOutletInjector){let i=this._viewContainerRef;if(this._viewRef&&i.remove(i.indexOf(this._viewRef)),this.ngTemplateOutlet){let{ngTemplateOutlet:r,ngTemplateOutletContext:o,ngTemplateOutletInjector:s}=this;this._viewRef=i.createEmbeddedView(r,o,s?{injector:s}:void 0)}else this._viewRef=null}else this._viewRef&&e.ngTemplateOutletContext&&this.ngTemplateOutletContext&&(this._viewRef.context=this.ngTemplateOutletContext)}}return n.\u0275fac=function(e){return new(e||n)(C(si))},n.\u0275dir=we({type:n,selectors:[["","ngTemplateOutlet",""]],inputs:{ngTemplateOutletContext:"ngTemplateOutletContext",ngTemplateOutlet:"ngTemplateOutlet",ngTemplateOutletInjector:"ngTemplateOutletInjector"},standalone:!0,features:[Gt]}),n})();function hw(n,t){return new yt(2100,!1)}var Hue=new class{createSubscription(t,e){return t.then(e,i=>{throw i})}dispose(t){}},zue=new class{createSubscription(t,e){return t.subscribe({next:e,error:i=>{throw i}})}dispose(t){t.unsubscribe()}},ct=(()=>{class n{constructor(e){this._latestValue=null,this._subscription=null,this._obj=null,this._strategy=null,this._ref=e}ngOnDestroy(){this._subscription&&this._dispose(),this._ref=null}transform(e){return this._obj?e!==this._obj?(this._dispose(),this.transform(e)):this._latestValue:(e&&this._subscribe(e),this._latestValue)}_subscribe(e){this._obj=e,this._strategy=this._selectStrategy(e),this._subscription=this._strategy.createSubscription(e,i=>this._updateLatestValue(e,i))}_selectStrategy(e){if(hh(e))return Hue;if(TO(e))return zue;throw hw()}_dispose(){this._strategy.dispose(this._subscription),this._latestValue=null,this._subscription=null,this._obj=null}_updateLatestValue(e,i){e===this._obj&&(this._latestValue=i,this._ref.markForCheck())}}return n.\u0275fac=function(e){return new(e||n)(C($t,16))},n.\u0275pipe=Km({name:"async",type:n,pure:!1,standalone:!0}),n})(),jue=new ie("DATE_PIPE_DEFAULT_TIMEZONE"),Gue=new ie("DATE_PIPE_DEFAULT_OPTIONS"),gh=(()=>{class n{constructor(e,i,r){this.locale=e,this.defaultTimezone=i,this.defaultOptions=r}transform(e,i,r,o){if(null==e||""===e||e!=e)return null;try{return yue(e,i??this.defaultOptions?.dateFormat??"mediumDate",o||this.locale,r??this.defaultOptions?.timezone??this.defaultTimezone??void 0)}catch(s){throw hw()}}}return n.\u0275fac=function(e){return new(e||n)(C(cd,16),C(jue,24),C(Gue,24))},n.\u0275pipe=Km({name:"date",type:n,pure:!0,standalone:!0}),n})(),La=(()=>{class n{constructor(e){this._locale=e}transform(e,i,r){if(!function(n){return!(null==n||""===n||n!=n)}(e))return null;r=r||this._locale;try{let o=function(n){if("string"==typeof n&&!isNaN(Number(n)-parseFloat(n)))return Number(n);if("number"!=typeof n)throw new Error(`${n} is not a number`);return n}(e);return $O(o,r,i)}catch(o){throw hw()}}}return n.\u0275fac=function(e){return new(e||n)(C(cd,16))},n.\u0275pipe=Km({name:"number",type:n,pure:!0,standalone:!0}),n})(),jj=(()=>{class n{transform(e,i,r){if(null==e)return null;if(!this.supports(e))throw hw();return e.slice(i,r)}supports(e){return"string"==typeof e||Array.isArray(e)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275pipe=Km({name:"slice",type:n,pure:!1,standalone:!0}),n})(),Pe=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({}),n})(),ek="browser";function gw(n){return n===ek}new yl("15.2.9");var Qp=class{};function Zue(n){return n.startsWith("/")?n.slice(1):n}var Kue=n=>n.src,Jue=new ie("ImageLoader",{providedIn:"root",factory:()=>Kue});function _w(n,t){return function(i){return function(n){if("string"!=typeof n||""===n.trim())return!1;try{return new URL(n),!0}catch{return!1}}(i)||function(n,t){throw new yt(2959,!1)}(),i=function(n){return n.endsWith("/")?n.slice(0,-1):n}(i),[{provide:Jue,useValue:s=>(function(n){return/^https?:\/\//.test(n)}(s.src)&&function(n,t){throw new yt(2959,!1)}(),n(i,{...s,src:Zue(s.src)}))}]}}_w(function(n,t){let e="format=auto";return t.width&&(e+=`,width=${t.width}`),`${n}/cdn-cgi/image/${e}/${t.src}`}),_w(function(n,t){let e="f_auto,q_auto";return t.width&&(e+=`,w_${t.width}`),`${n}/image/upload/${e}/${t.src}`}),_w(function(n,t){let r,{src:e,width:i}=t;return r=i?[n,`tr:w-${i}`,e]:[n,e],r.join("/")}),_w(function(n,t){let e=new URL(`${n}/${t.src}`);return e.searchParams.set("auto","format"),t.width&&e.searchParams.set("w",t.width.toString()),e.href}),new ie("PRECONNECT_CHECK_BLOCKLIST"),new ie("NG_OPTIMIZED_PRELOADED_IMAGES",{providedIn:"root",factory:()=>new Set});var bw,ope={breakpoints:[16,32,48,64,96,128,256,384,640,750,828,1080,1200,1920,2048,3840]},nk=(new ie("ImageConfig",{providedIn:"root",factory:()=>ope}),class extends dw{constructor(){super(...arguments),this.supportsDOMEvents=!0}}),Db=class extends nk{static makeCurrent(){var n;n=new Db,YO||(YO=n)}onAndCancel(t,e,i){return t.addEventListener(e,i,!1),()=>{t.removeEventListener(e,i,!1)}}dispatchEvent(t,e){t.dispatchEvent(e)}remove(t){t.parentNode&&t.parentNode.removeChild(t)}createElement(t,e){return(e=e||this.getDefaultDocument()).createElement(t)}createHtmlDocument(){return document.implementation.createHTMLDocument("fakeTitle")}getDefaultDocument(){return document}isElementNode(t){return t.nodeType===Node.ELEMENT_NODE}isShadowRoot(t){return t instanceof DocumentFragment}getGlobalEventTarget(t,e){return"window"===e?window:"document"===e?t:"body"===e?t.body:null}getBaseHref(t){let e=(Sb=Sb||document.querySelector("base"))?Sb.getAttribute("href"):null;return null==e?null:function(n){(bw=bw||document.createElement("a")).setAttribute("href",n);let t=bw.pathname;return"/"===t.charAt(0)?t:`/${t}`}(e)}resetBaseElement(){Sb=null}getUserAgent(){return window.navigator.userAgent}getCookie(t){return mw(document.cookie,t)}},Sb=null,Qj=new ie("TRANSITION_ID"),dpe=[{provide:OO,useFactory:function(n,t,e){return()=>{e.get(ZM).donePromise.then(()=>{let i=Tl(),r=t.querySelectorAll(`style[ng-transition="${n}"]`);for(let o=0;o<r.length;o++)i.remove(r[o])})}},deps:[Qj,Lt,Mi],multi:!0}],upe=(()=>{class n{build(){return new XMLHttpRequest}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),vw=new ie("EventManagerPlugins"),yw=(()=>{class n{constructor(e,i){this._zone=i,this._eventNameToPlugin=new Map,e.forEach(r=>{r.manager=this}),this._plugins=e.slice().reverse()}addEventListener(e,i,r){return this._findPluginFor(i).addEventListener(e,i,r)}addGlobalEventListener(e,i,r){return this._findPluginFor(i).addGlobalEventListener(e,i,r)}getZone(){return this._zone}_findPluginFor(e){let i=this._eventNameToPlugin.get(e);if(i)return i;let r=this._plugins;for(let o=0;o<r.length;o++){let s=r[o];if(s.supports(e))return this._eventNameToPlugin.set(e,s),s}throw new Error(`No event manager plugin found for event ${e}`)}}return n.\u0275fac=function(e){return new(e||n)(k(vw),k(at))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),xw=class{constructor(t){this._doc=t}addGlobalEventListener(t,e,i){let r=Tl().getGlobalEventTarget(this._doc,t);if(!r)throw new Error(`Unsupported event target ${r} for event ${e}`);return this.addEventListener(r,e,i)}},Zj=(()=>{class n{constructor(){this.usageCount=new Map}addStyles(e){for(let i of e)1===this.changeUsageCount(i,1)&&this.onStyleAdded(i)}removeStyles(e){for(let i of e)0===this.changeUsageCount(i,-1)&&this.onStyleRemoved(i)}onStyleRemoved(e){}onStyleAdded(e){}getAllStyles(){return this.usageCount.keys()}changeUsageCount(e,i){let r=this.usageCount,o=r.get(e)??0;return o+=i,o>0?r.set(e,o):r.delete(e),o}ngOnDestroy(){for(let e of this.getAllStyles())this.onStyleRemoved(e);this.usageCount.clear()}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),Eb=(()=>{class n extends Zj{constructor(e){super(),this.doc=e,this.styleRef=new Map,this.hostNodes=new Set,this.resetHostNodes()}onStyleAdded(e){for(let i of this.hostNodes)this.addStyleToHost(i,e)}onStyleRemoved(e){let i=this.styleRef;i.get(e)?.forEach(o=>o.remove()),i.delete(e)}ngOnDestroy(){super.ngOnDestroy(),this.styleRef.clear(),this.resetHostNodes()}addHost(e){this.hostNodes.add(e);for(let i of this.getAllStyles())this.addStyleToHost(e,i)}removeHost(e){this.hostNodes.delete(e)}addStyleToHost(e,i){let r=this.doc.createElement("style");r.textContent=i,e.appendChild(r);let o=this.styleRef.get(i);o?o.push(r):this.styleRef.set(i,[r])}resetHostNodes(){let e=this.hostNodes;e.clear(),e.add(this.doc.head)}}return n.\u0275fac=function(e){return new(e||n)(k(Lt))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),tk={svg:"http://www.w3.org/2000/svg",xhtml:"http://www.w3.org/1999/xhtml",xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/",math:"http://www.w3.org/1998/MathML/"},ok=/%COMP%/g,Jj=new ie("RemoveStylesOnCompDestory",{providedIn:"root",factory:()=>!1});function $j(n,t){return t.flat(100).map(e=>e.replace(ok,n))}function Wj(n){return t=>{if("__ngUnwrap__"===t)return n;!1===n(t)&&(t.preventDefault(),t.returnValue=!1)}}var Tb=(()=>{class n{constructor(e,i,r,o){this.eventManager=e,this.sharedStylesHost=i,this.appId=r,this.removeStylesOnCompDestory=o,this.rendererByCompId=new Map,this.defaultRenderer=new Ib(e)}createRenderer(e,i){if(!e||!i)return this.defaultRenderer;let r=this.getOrCreateRenderer(e,i);return r instanceof Cw?r.applyToHost(e):r instanceof Ab&&r.applyStyles(),r}getOrCreateRenderer(e,i){let r=this.rendererByCompId,o=r.get(i.id);if(!o){let s=this.eventManager,a=this.sharedStylesHost,l=this.removeStylesOnCompDestory;switch(i.encapsulation){case ra.Emulated:o=new Cw(s,a,i,this.appId,l);break;case ra.ShadowDom:return new rk(s,a,e,i);default:o=new Ab(s,a,i,l)}o.onDestroy=()=>r.delete(i.id),r.set(i.id,o)}return o}ngOnDestroy(){this.rendererByCompId.clear()}begin(){}end(){}}return n.\u0275fac=function(e){return new(e||n)(k(yw),k(Eb),k(Yp),k(Jj))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),Ib=class{constructor(t){this.eventManager=t,this.data=Object.create(null),this.destroyNode=null}destroy(){}createElement(t,e){return e?document.createElementNS(tk[e]||e,t):document.createElement(t)}createComment(t){return document.createComment(t)}createText(t){return document.createTextNode(t)}appendChild(t,e){(Yj(t)?t.content:t).appendChild(e)}insertBefore(t,e,i){t&&(Yj(t)?t.content:t).insertBefore(e,i)}removeChild(t,e){t&&t.removeChild(e)}selectRootElement(t,e){let i="string"==typeof t?document.querySelector(t):t;if(!i)throw new Error(`The selector "${t}" did not match any elements`);return e||(i.textContent=""),i}parentNode(t){return t.parentNode}nextSibling(t){return t.nextSibling}setAttribute(t,e,i,r){if(r){e=r+":"+e;let o=tk[r];o?t.setAttributeNS(o,e,i):t.setAttribute(e,i)}else t.setAttribute(e,i)}removeAttribute(t,e,i){if(i){let r=tk[i];r?t.removeAttributeNS(r,e):t.removeAttribute(`${i}:${e}`)}else t.removeAttribute(e)}addClass(t,e){t.classList.add(e)}removeClass(t,e){t.classList.remove(e)}setStyle(t,e,i,r){r&(Aa.DashCase|Aa.Important)?t.style.setProperty(e,i,r&Aa.Important?"important":""):t.style[e]=i}removeStyle(t,e,i){i&Aa.DashCase?t.style.removeProperty(e):t.style[e]=""}setProperty(t,e,i){t[e]=i}setValue(t,e){t.nodeValue=e}listen(t,e,i){return"string"==typeof t?this.eventManager.addGlobalEventListener(t,e,Wj(i)):this.eventManager.addEventListener(t,e,Wj(i))}};function Yj(n){return"TEMPLATE"===n.tagName&&void 0!==n.content}"@".charCodeAt(0);var rk=class extends Ib{constructor(t,e,i,r){super(t),this.sharedStylesHost=e,this.hostEl=i,this.shadowRoot=i.attachShadow({mode:"open"}),this.sharedStylesHost.addHost(this.shadowRoot);let o=$j(r.id,r.styles);for(let s of o){let a=document.createElement("style");a.textContent=s,this.shadowRoot.appendChild(a)}}nodeOrShadowRoot(t){return t===this.hostEl?this.shadowRoot:t}appendChild(t,e){return super.appendChild(this.nodeOrShadowRoot(t),e)}insertBefore(t,e,i){return super.insertBefore(this.nodeOrShadowRoot(t),e,i)}removeChild(t,e){return super.removeChild(this.nodeOrShadowRoot(t),e)}parentNode(t){return this.nodeOrShadowRoot(super.parentNode(this.nodeOrShadowRoot(t)))}destroy(){this.sharedStylesHost.removeHost(this.shadowRoot)}},Ab=class extends Ib{constructor(t,e,i,r,o=i.id){super(t),this.sharedStylesHost=e,this.removeStylesOnCompDestory=r,this.rendererUsageCount=0,this.styles=$j(o,i.styles)}applyStyles(){this.sharedStylesHost.addStyles(this.styles),this.rendererUsageCount++}destroy(){!this.removeStylesOnCompDestory||(this.sharedStylesHost.removeStyles(this.styles),this.rendererUsageCount--,0===this.rendererUsageCount&&this.onDestroy?.())}},Cw=class extends Ab{constructor(t,e,i,r,o){let s=r+"-"+i.id;super(t,e,i,o,s),this.contentAttr="_ngcontent-%COMP%".replace(ok,s),this.hostAttr=function(n){return"_nghost-%COMP%".replace(ok,n)}(s)}applyToHost(t){this.applyStyles(),this.setAttribute(t,this.hostAttr,"")}createElement(t,e){let i=super.createElement(t,e);return super.setAttribute(i,this.contentAttr,""),i}},bpe=(()=>{class n extends xw{constructor(e){super(e)}supports(e){return!0}addEventListener(e,i,r){return e.addEventListener(i,r,!1),()=>this.removeEventListener(e,i,r)}removeEventListener(e,i,r){return e.removeEventListener(i,r)}}return n.\u0275fac=function(e){return new(e||n)(k(Lt))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),Xj=["alt","control","meta","shift"],vpe={"\b":"Backspace","\t":"Tab","\x7f":"Delete","\x1b":"Escape",Del:"Delete",Esc:"Escape",Left:"ArrowLeft",Right:"ArrowRight",Up:"ArrowUp",Down:"ArrowDown",Menu:"ContextMenu",Scroll:"ScrollLock",Win:"OS"},ype={alt:n=>n.altKey,control:n=>n.ctrlKey,meta:n=>n.metaKey,shift:n=>n.shiftKey},xpe=(()=>{class n extends xw{constructor(e){super(e)}supports(e){return null!=n.parseEventName(e)}addEventListener(e,i,r){let o=n.parseEventName(i),s=n.eventCallback(o.fullKey,r,this.manager.getZone());return this.manager.getZone().runOutsideAngular(()=>Tl().onAndCancel(e,o.domEventName,s))}static parseEventName(e){let i=e.toLowerCase().split("."),r=i.shift();if(0===i.length||"keydown"!==r&&"keyup"!==r)return null;let o=n._normalizeKey(i.pop()),s="",a=i.indexOf("code");if(a>-1&&(i.splice(a,1),s="code."),Xj.forEach(c=>{let d=i.indexOf(c);d>-1&&(i.splice(d,1),s+=c+".")}),s+=o,0!=i.length||0===o.length)return null;let l={};return l.domEventName=r,l.fullKey=s,l}static matchEventFullKeyCode(e,i){let r=vpe[e.key]||e.key,o="";return i.indexOf("code.")>-1&&(r=e.code,o="code."),!(null==r||!r)&&(r=r.toLowerCase()," "===r?r="space":"."===r&&(r="dot"),Xj.forEach(s=>{s!==r&&(0,ype[s])(e)&&(o+=s+".")}),o+=r,o===i)}static eventCallback(e,i,r){return o=>{n.matchEventFullKeyCode(o,e)&&r.runGuarded(()=>i(o))}}static _normalizeKey(e){return"esc"===e?"escape":e}}return n.\u0275fac=function(e){return new(e||n)(k(Lt))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),Spe=[{provide:vc,useValue:ek},{provide:kO,useValue:function(){Db.makeCurrent()},multi:!0},{provide:Lt,useFactory:function(){return n=document,YR=n,document;var n},deps:[]}],ak=BO(Mj,"browser",Spe),eG=new ie(""),Epe=[{provide:vb,useClass:class{addToWindow(t){Ur.getAngularTestability=(i,r=!0)=>{let o=t.findTestabilityInTree(i,r);if(null==o)throw new Error("Could not find testability for element.");return o},Ur.getAllAngularTestabilities=()=>t.getAllTestabilities(),Ur.getAllAngularRootElements=()=>t.getAllRootElements(),Ur.frameworkStabilizers||(Ur.frameworkStabilizers=[]),Ur.frameworkStabilizers.push(i=>{let r=Ur.getAllAngularTestabilities(),o=r.length,s=!1,a=function(l){s=s||l,o--,0==o&&i(s)};r.forEach(function(l){l.whenStable(a)})})}findTestabilityInTree(t,e,i){return null==e?null:t.getTestability(e)??(i?Tl().isShadowRoot(e)?this.findTestabilityInTree(t,e.host,!0):this.findTestabilityInTree(t,e.parentElement,!0):null)}},deps:[]},{provide:NO,useClass:KM,deps:[at,JM,vb]},{provide:KM,useClass:KM,deps:[at,JM,vb]}],Tpe=[{provide:NM,useValue:"root"},{provide:rs,useFactory:function(){return new rs},deps:[]},{provide:vw,useClass:bpe,multi:!0,deps:[Lt,at,vc]},{provide:vw,useClass:xpe,multi:!0,deps:[Lt]},{provide:Tb,useClass:Tb,deps:[yw,Eb,Yp,Jj]},{provide:fc,useExisting:Tb},{provide:Zj,useExisting:Eb},{provide:Eb,useClass:Eb,deps:[Lt]},{provide:yw,useClass:yw,deps:[vw,at]},{provide:Qp,useClass:upe,deps:[]},[]],Mw=(()=>{class n{constructor(e){}static withServerTransition(e){return{ngModule:n,providers:[{provide:Yp,useValue:e.appId},{provide:Qj,useExisting:Yp},dpe]}}}return n.\u0275fac=function(e){return new(e||n)(k(eG,12))},n.\u0275mod=G({type:n}),n.\u0275inj=U({providers:[...Tpe,...Epe],imports:[Pe,wj]}),n})(),Zp=(new ie("HammerGestureConfig"),new ie("HammerLoader"),(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ue({token:n,factory:function(e){let i=null;return i=e?new(e||n):k(tG),i},providedIn:"root"}),n})()),tG=(()=>{class n extends Zp{constructor(e){super(),this._doc=e}sanitize(e,i){if(null==i)return null;switch(e){case jr.NONE:return i;case jr.HTML:return xl(i,"HTML")?Ds(i):pO(this._doc,String(i)).toString();case jr.STYLE:return xl(i,"Style")?Ds(i):i;case jr.SCRIPT:if(xl(i,"Script"))return Ds(i);throw new Error("unsafe value used in a script context");case jr.URL:return xl(i,"URL")?Ds(i):lb(String(i));case jr.RESOURCE_URL:if(xl(i,"ResourceURL"))return Ds(i);throw new Error(`unsafe value used in a resource URL context (see ${tb})`);default:throw new Error(`Unexpected SecurityContext ${e} (see ${tb})`)}}bypassSecurityTrustHtml(e){return function(n){return new XR(n)}(e)}bypassSecurityTrustStyle(e){return function(n){return new QR(n)}(e)}bypassSecurityTrustScript(e){return function(n){return new ZR(n)}(e)}bypassSecurityTrustUrl(e){return function(n){return new KR(n)}(e)}bypassSecurityTrustResourceUrl(e){return function(n){return new JR(n)}(e)}}return n.\u0275fac=function(e){return new(e||n)(k(Lt))},n.\u0275prov=ue({token:n,factory:function(e){let i=null;return i=e?new e:function(n){return new tG(n.get(Lt))}(k(Mi)),i},providedIn:"root"}),n})(),Rb=(new yl("15.2.9"),WV(iG(),1),class{}),ww=class{},xc="*";function _r(n,t){return{type:7,name:n,definitions:t,options:{}}}function Ci(n,t=null){return{type:4,styles:t,timings:n}}function Ob(n,t=null){return{type:3,steps:n,options:t}}function Sw(n,t=null){return{type:2,steps:n,options:t}}function rn(n){return{type:6,styles:n,offset:null}}function wi(n,t,e){return{type:0,name:n,styles:t,options:e}}function kb(n){return{type:5,steps:n}}function gi(n,t,e=null){return{type:1,expr:n,animation:t,options:e}}function Kp(n=null){return{type:9,options:n}}function Jp(n,t,e=null){return{type:11,selector:n,animation:t,options:e}}function rG(n){Promise.resolve().then(n)}var mu=class{constructor(t=0,e=0){this._onDoneFns=[],this._onStartFns=[],this._onDestroyFns=[],this._originalOnDoneFns=[],this._originalOnStartFns=[],this._started=!1,this._destroyed=!1,this._finished=!1,this._position=0,this.parentPlayer=null,this.totalTime=t+e}_onFinish(){this._finished||(this._finished=!0,this._onDoneFns.forEach(t=>t()),this._onDoneFns=[])}onStart(t){this._originalOnStartFns.push(t),this._onStartFns.push(t)}onDone(t){this._originalOnDoneFns.push(t),this._onDoneFns.push(t)}onDestroy(t){this._onDestroyFns.push(t)}hasStarted(){return this._started}init(){}play(){this.hasStarted()||(this._onStart(),this.triggerMicrotask()),this._started=!0}triggerMicrotask(){rG(()=>this._onFinish())}_onStart(){this._onStartFns.forEach(t=>t()),this._onStartFns=[]}pause(){}restart(){}finish(){this._onFinish()}destroy(){this._destroyed||(this._destroyed=!0,this.hasStarted()||this._onStart(),this.finish(),this._onDestroyFns.forEach(t=>t()),this._onDestroyFns=[])}reset(){this._started=!1,this._finished=!1,this._onStartFns=this._originalOnStartFns,this._onDoneFns=this._originalOnDoneFns}setPosition(t){this._position=this.totalTime?t*this.totalTime:1}getPosition(){return this.totalTime?this._position/this.totalTime:1}triggerCallback(t){let e="start"==t?this._onStartFns:this._onDoneFns;e.forEach(i=>i()),e.length=0}},Pb=class{constructor(t){this._onDoneFns=[],this._onStartFns=[],this._finished=!1,this._started=!1,this._destroyed=!1,this._onDestroyFns=[],this.parentPlayer=null,this.totalTime=0,this.players=t;let e=0,i=0,r=0,o=this.players.length;0==o?rG(()=>this._onFinish()):this.players.forEach(s=>{s.onDone(()=>{++e==o&&this._onFinish()}),s.onDestroy(()=>{++i==o&&this._onDestroy()}),s.onStart(()=>{++r==o&&this._onStart()})}),this.totalTime=this.players.reduce((s,a)=>Math.max(s,a.totalTime),0)}_onFinish(){this._finished||(this._finished=!0,this._onDoneFns.forEach(t=>t()),this._onDoneFns=[])}init(){this.players.forEach(t=>t.init())}onStart(t){this._onStartFns.push(t)}_onStart(){this.hasStarted()||(this._started=!0,this._onStartFns.forEach(t=>t()),this._onStartFns=[])}onDone(t){this._onDoneFns.push(t)}onDestroy(t){this._onDestroyFns.push(t)}hasStarted(){return this._started}play(){this.parentPlayer||this.init(),this._onStart(),this.players.forEach(t=>t.play())}pause(){this.players.forEach(t=>t.pause())}restart(){this.players.forEach(t=>t.restart())}finish(){this._onFinish(),this.players.forEach(t=>t.finish())}destroy(){this._onDestroy()}_onDestroy(){this._destroyed||(this._destroyed=!0,this._onFinish(),this.players.forEach(t=>t.destroy()),this._onDestroyFns.forEach(t=>t()),this._onDestroyFns=[])}reset(){this.players.forEach(t=>t.reset()),this._destroyed=!1,this._finished=!1,this._started=!1}setPosition(t){let e=t*this.totalTime;this.players.forEach(i=>{let r=i.totalTime?Math.min(1,e/i.totalTime):1;i.setPosition(r)})}getPosition(){let t=this.players.reduce((e,i)=>null===e||i.totalTime>e.totalTime?i:e,null);return null!=t?t.getPosition():0}beforeDestroy(){this.players.forEach(t=>{t.beforeDestroy&&t.beforeDestroy()})}triggerCallback(t){let e="start"==t?this._onStartFns:this._onDoneFns;e.forEach(i=>i()),e.length=0}},Ew="!";function oG(n){return new yt(3e3,!1)}function Ik(){return typeof process<"u"&&"[object process]"==={}.toString.call(process)}function hu(n){switch(n.length){case 0:return new mu;case 1:return n[0];default:return new Pb(n)}}function yG(n,t,e,i,r=new Map,o=new Map){let s=[],a=[],l=-1,c=null;if(i.forEach(d=>{let u=d.get("offset"),p=u==l,f=p&&c||new Map;d.forEach((m,b)=>{let M=b,y=m;if("offset"!==b)switch(M=t.normalizePropertyName(M,s),y){case Ew:y=r.get(b);break;case xc:y=o.get(b);break;default:y=t.normalizeStyleValue(b,M,y,s)}f.set(M,y)}),p||a.push(f),c=f,l=u}),s.length)throw new yt(3502,!1);return a}function Ak(n,t,e,i){switch(t){case"start":n.onStart(()=>i(e&&ck(e,"start",n)));break;case"done":n.onDone(()=>i(e&&ck(e,"done",n)));break;case"destroy":n.onDestroy(()=>i(e&&ck(e,"destroy",n)))}}function ck(n,t,e){let o=Rk(n.element,n.triggerName,n.fromState,n.toState,t||n.phaseName,e.totalTime??n.totalTime,!!e.disabled),s=n._data;return null!=s&&(o._data=s),o}function Rk(n,t,e,i,r="",o=0,s){return{element:n,triggerName:t,fromState:e,toState:i,phaseName:r,totalTime:o,disabled:!!s}}function ca(n,t,e){let i=n.get(t);return i||n.set(t,i=e),i}function sG(n){let t=n.indexOf(":");return[n.substring(1,t),n.slice(t+1)]}var hk=(n,t)=>!1,xG=(n,t,e)=>[],CG=null;function Pk(n){let t=n.parentNode||n.host;return t===CG?null:t}(Ik()||typeof Element<"u")&&(typeof window<"u"&&typeof window.document<"u"?(CG=(()=>document.documentElement)(),hk=(n,t)=>{for(;t;){if(t===n)return!0;t=Pk(t)}return!1}):hk=(n,t)=>n.contains(t),xG=(n,t,e)=>{if(e)return Array.from(n.querySelectorAll(t));let i=n.querySelector(t);return i?[i]:[]});var $p=null,aG=!1;var MG=hk,wG=xG,Ok=(()=>{class n{validateStyleProperty(e){return function(n){$p||($p=(typeof document<"u"?document.body:null)||{},aG=!!$p.style&&"WebkitAppearance"in $p.style);let t=!0;return $p.style&&!function(n){return"ebkit"==n.substring(1,6)}(n)&&(t=n in $p.style,!t&&aG&&(t="Webkit"+n.charAt(0).toUpperCase()+n.slice(1)in $p.style)),t}(e)}matchesElement(e,i){return!1}containsElement(e,i){return MG(e,i)}getParentElement(e){return Pk(e)}query(e,i,r){return wG(e,i,r)}computeStyle(e,i,r){return r||""}animate(e,i,r,o,s,a=[],l){return new mu(r,o)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),Ub=(()=>{class n{}return n.NOOP=new Ok,n})(),ufe=1e3,EG="ng-enter",gk="ng-leave",Tw="ng-trigger",Rw=".ng-trigger",lG="ng-animating",_k=".ng-animating";function pd(n){if("number"==typeof n)return n;let t=n.match(/^(-?[\.\d]+)(m?s)/);return!t||t.length<2?0:bk(parseFloat(t[1]),t[2])}function bk(n,t){return"s"===t?n*ufe:n}function Pw(n,t,e){return n.hasOwnProperty("duration")?n:function(n,t,e){let r,o=0,s="";if("string"==typeof n){let a=n.match(/^(-?[\.\d]+)(m?s)(?:\s+(-?[\.\d]+)(m?s))?(?:\s+([-a-z]+(?:\(.+?\))?))?$/i);if(null===a)return t.push(oG()),{duration:0,delay:0,easing:""};r=bk(parseFloat(a[1]),a[2]);let l=a[3];null!=l&&(o=bk(parseFloat(l),a[4]));let c=a[5];c&&(s=c)}else r=n;if(!e){let a=!1,l=t.length;r<0&&(t.push(new yt(3100,!1)),a=!0),o<0&&(t.push(new yt(3101,!1)),a=!0),a&&t.splice(l,0,oG())}return{duration:r,delay:o,easing:s}}(n,t,e)}function jb(n,t={}){return Object.keys(n).forEach(e=>{t[e]=n[e]}),t}function TG(n){let t=new Map;return Object.keys(n).forEach(e=>{t.set(e,n[e])}),t}function bh(n,t=new Map,e){if(e)for(let[i,r]of e)t.set(i,r);for(let[i,r]of n)t.set(i,r);return t}function cG(n,t,e){return e?t+":"+e+";":""}function DG(n){let t="";for(let e=0;e<n.style.length;e++){let i=n.style.item(e);t+=cG(0,i,n.style.getPropertyValue(i))}for(let e in n.style)n.style.hasOwnProperty(e)&&!e.startsWith("_")&&(t+=cG(0,_fe(e),n.style[e]));n.setAttribute("style",t)}function Cc(n,t,e){n.style&&(t.forEach((i,r)=>{let o=kk(r);e&&!e.has(r)&&e.set(r,n.style[o]),n.style[o]=i}),Ik()&&DG(n))}function tf(n,t){n.style&&(t.forEach((e,i)=>{let r=kk(i);n.style[r]=""}),Ik()&&DG(n))}function Fb(n){return Array.isArray(n)?1==n.length?n[0]:Sw(n):n}var vk=new RegExp("{{\\s*(.+?)\\s*}}","g");function IG(n){let t=[];if("string"==typeof n){let e;for(;e=vk.exec(n);)t.push(e[1]);vk.lastIndex=0}return t}function Lb(n,t,e){let i=n.toString(),r=i.replace(vk,(o,s)=>{let a=t[s];return null==a&&(e.push(new yt(3003,!1)),a=""),a.toString()});return r==i?n:r}function Ow(n){let t=[],e=n.next();for(;!e.done;)t.push(e.value),e=n.next();return t}var gfe=/-+([a-z0-9])/g;function kk(n){return n.replace(gfe,(...t)=>t[1].toUpperCase())}function _fe(n){return n.replace(/([a-z])([A-Z])/g,"$1-$2").toLowerCase()}function la(n,t,e){switch(t.type){case 7:return n.visitTrigger(t,e);case 0:return n.visitState(t,e);case 1:return n.visitTransition(t,e);case 2:return n.visitSequence(t,e);case 3:return n.visitGroup(t,e);case 4:return n.visitAnimate(t,e);case 5:return n.visitKeyframes(t,e);case 6:return n.visitStyle(t,e);case 8:return n.visitReference(t,e);case 9:return n.visitAnimateChild(t,e);case 10:return n.visitAnimateRef(t,e);case 11:return n.visitQuery(t,e);case 12:return n.visitStagger(t,e);default:throw new yt(3004,!1)}}function AG(n,t){return window.getComputedStyle(n)[t]}var kw="*";function Cfe(n,t){let e=[];return"string"==typeof n?n.split(/\s*,\s*/).forEach(i=>function(n,t,e){if(":"==n[0]){let l=function(n,t){switch(n){case":enter":return"void => *";case":leave":return"* => void";case":increment":return(e,i)=>parseFloat(i)>parseFloat(e);case":decrement":return(e,i)=>parseFloat(i)<parseFloat(e);default:return t.push(new yt(3016,!1)),"* => *"}}(n,e);if("function"==typeof l)return void t.push(l);n=l}let i=n.match(/^(\*|[-\w]+)\s*(<?[=-]>)\s*(\*|[-\w]+)$/);if(null==i||i.length<4)return e.push(new yt(3015,!1)),t;let r=i[1],o=i[2],s=i[3];t.push(dG(r,s)),"<"==o[0]&&!(r==kw&&s==kw)&&t.push(dG(s,r))}(i,e,t)):e.push(n),e}var Dw=new Set(["true","1"]),Iw=new Set(["false","0"]);function dG(n,t){let e=Dw.has(n)||Iw.has(n),i=Dw.has(t)||Iw.has(t);return(r,o)=>{let s=n==kw||n==r,a=t==kw||t==o;return!s&&e&&"boolean"==typeof r&&(s=r?Dw.has(n):Iw.has(n)),!a&&i&&"boolean"==typeof o&&(a=o?Dw.has(t):Iw.has(t)),s&&a}}var Sfe=new RegExp("s*:selfs*,?","g");function kG(n,t,e,i){return new yk(n).build(t,e,i)}var yk=class{constructor(t){this._driver=t}build(t,e,i){let r=new xk(e);return this._resetContextStyleTimingState(r),la(this,Fb(t),r)}_resetContextStyleTimingState(t){t.currentQuerySelector="",t.collectedStyles=new Map,t.collectedStyles.set("",new Map),t.currentTime=0}visitTrigger(t,e){let i=e.queryCount=0,r=e.depCount=0,o=[],s=[];return"@"==t.name.charAt(0)&&e.errors.push(new yt(3006,!1)),t.definitions.forEach(a=>{if(this._resetContextStyleTimingState(e),0==a.type){let l=a,c=l.name;c.toString().split(/\s*,\s*/).forEach(d=>{l.name=d,o.push(this.visitState(l,e))}),l.name=c}else if(1==a.type){let l=this.visitTransition(a,e);i+=l.queryCount,r+=l.depCount,s.push(l)}else e.errors.push(new yt(3007,!1))}),{type:7,name:t.name,states:o,transitions:s,queryCount:i,depCount:r,options:null}}visitState(t,e){let i=this.visitStyle(t.styles,e),r=t.options&&t.options.params||null;if(i.containsDynamicStyles){let o=new Set,s=r||{};i.styles.forEach(a=>{a instanceof Map&&a.forEach(l=>{IG(l).forEach(c=>{s.hasOwnProperty(c)||o.add(c)})})}),o.size&&(Ow(o.values()),e.errors.push(new yt(3008,!1)))}return{type:0,name:t.name,style:i,options:r?{params:r}:null}}visitTransition(t,e){e.queryCount=0,e.depCount=0;let i=la(this,Fb(t.animation),e);return{type:1,matchers:Cfe(t.expr,e.errors),animation:i,queryCount:e.queryCount,depCount:e.depCount,options:ef(t.options)}}visitSequence(t,e){return{type:2,steps:t.steps.map(i=>la(this,i,e)),options:ef(t.options)}}visitGroup(t,e){let i=e.currentTime,r=0,o=t.steps.map(s=>{e.currentTime=i;let a=la(this,s,e);return r=Math.max(r,e.currentTime),a});return e.currentTime=r,{type:3,steps:o,options:ef(t.options)}}visitAnimate(t,e){let i=function(n,t){if(n.hasOwnProperty("duration"))return n;if("number"==typeof n)return dk(Pw(n,t).duration,0,"");let e=n;if(e.split(/\s+/).some(o=>"{"==o.charAt(0)&&"{"==o.charAt(1))){let o=dk(0,0,"");return o.dynamic=!0,o.strValue=e,o}let r=Pw(e,t);return dk(r.duration,r.delay,r.easing)}(t.timings,e.errors);e.currentAnimateTimings=i;let r,o=t.styles?t.styles:rn({});if(5==o.type)r=this.visitKeyframes(o,e);else{let s=t.styles,a=!1;if(!s){a=!0;let c={};i.easing&&(c.easing=i.easing),s=rn(c)}e.currentTime+=i.duration+i.delay;let l=this.visitStyle(s,e);l.isEmptyStep=a,r=l}return e.currentAnimateTimings=null,{type:4,timings:i,style:r,options:null}}visitStyle(t,e){let i=this._makeStyleAst(t,e);return this._validateStyleAst(i,e),i}_makeStyleAst(t,e){let i=[],r=Array.isArray(t.styles)?t.styles:[t.styles];for(let a of r)"string"==typeof a?a===xc?i.push(a):e.errors.push(new yt(3002,!1)):i.push(TG(a));let o=!1,s=null;return i.forEach(a=>{if(a instanceof Map&&(a.has("easing")&&(s=a.get("easing"),a.delete("easing")),!o))for(let l of a.values())if(l.toString().indexOf("{{")>=0){o=!0;break}}),{type:6,styles:i,easing:s,offset:t.offset,containsDynamicStyles:o,options:null}}_validateStyleAst(t,e){let i=e.currentAnimateTimings,r=e.currentTime,o=e.currentTime;i&&o>0&&(o-=i.duration+i.delay),t.styles.forEach(s=>{"string"!=typeof s&&s.forEach((a,l)=>{let c=e.collectedStyles.get(e.currentQuerySelector),d=c.get(l),u=!0;d&&(o!=r&&o>=d.startTime&&r<=d.endTime&&(e.errors.push(new yt(3010,!1)),u=!1),o=d.startTime),u&&c.set(l,{startTime:o,endTime:r}),e.options&&function(n,t,e){let i=t.params||{},r=IG(n);r.length&&r.forEach(o=>{i.hasOwnProperty(o)||e.push(new yt(3001,!1))})}(a,e.options,e.errors)})})}visitKeyframes(t,e){let i={type:5,styles:[],options:null};if(!e.currentAnimateTimings)return e.errors.push(new yt(3011,!1)),i;let o=0,s=[],a=!1,l=!1,c=0,d=t.steps.map(y=>{let x=this._makeStyleAst(y,e),R=null!=x.offset?x.offset:function(n){if("string"==typeof n)return null;let t=null;if(Array.isArray(n))n.forEach(e=>{if(e instanceof Map&&e.has("offset")){let i=e;t=parseFloat(i.get("offset")),i.delete("offset")}});else if(n instanceof Map&&n.has("offset")){let e=n;t=parseFloat(e.get("offset")),e.delete("offset")}return t}(x.styles),A=0;return null!=R&&(o++,A=x.offset=R),l=l||A<0||A>1,a=a||A<c,c=A,s.push(A),x});l&&e.errors.push(new yt(3012,!1)),a&&e.errors.push(new yt(3200,!1));let u=t.steps.length,p=0;o>0&&o<u?e.errors.push(new yt(3202,!1)):0==o&&(p=1/(u-1));let f=u-1,m=e.currentTime,b=e.currentAnimateTimings,M=b.duration;return d.forEach((y,x)=>{let R=p>0?x==f?1:p*x:s[x],A=R*M;e.currentTime=m+b.delay+A,b.duration=A,this._validateStyleAst(y,e),y.offset=R,i.styles.push(y)}),i}visitReference(t,e){return{type:8,animation:la(this,Fb(t.animation),e),options:ef(t.options)}}visitAnimateChild(t,e){return e.depCount++,{type:9,options:ef(t.options)}}visitAnimateRef(t,e){return{type:10,animation:this.visitReference(t.animation,e),options:ef(t.options)}}visitQuery(t,e){let i=e.currentQuerySelector,r=t.options||{};e.queryCount++,e.currentQuery=t;let[o,s]=function(n){let t=!!n.split(/\s*,\s*/).find(e=>":self"==e);return t&&(n=n.replace(Sfe,"")),n=n.replace(/@\*/g,Rw).replace(/@\w+/g,e=>Rw+"-"+e.slice(1)).replace(/:animating/g,_k),[n,t]}(t.selector);e.currentQuerySelector=i.length?i+" "+o:o,ca(e.collectedStyles,e.currentQuerySelector,new Map);let a=la(this,Fb(t.animation),e);return e.currentQuery=null,e.currentQuerySelector=i,{type:11,selector:o,limit:r.limit||0,optional:!!r.optional,includeSelf:s,animation:a,originalSelector:t.selector,options:ef(t.options)}}visitStagger(t,e){e.currentQuery||e.errors.push(new yt(3013,!1));let i="full"===t.timings?{duration:0,delay:0,easing:"full"}:Pw(t.timings,e.errors,!0);return{type:12,animation:la(this,Fb(t.animation),e),timings:i,options:null}}},xk=class{constructor(t){this.errors=t,this.queryCount=0,this.depCount=0,this.currentTransition=null,this.currentQuery=null,this.currentQuerySelector=null,this.currentAnimateTimings=null,this.currentTime=0,this.collectedStyles=new Map,this.options=null,this.unsupportedCSSPropertiesFound=new Set}};function ef(n){return n?(n=jb(n)).params&&(n.params=function(n){return n?jb(n):null}(n.params)):n={},n}function dk(n,t,e){return{duration:n,delay:t,easing:e}}function Fk(n,t,e,i,r,o,s=null,a=!1){return{type:1,element:n,keyframes:t,preStyleProps:e,postStyleProps:i,duration:r,delay:o,totalTime:r+o,easing:s,subTimeline:a}}var Bb=class{constructor(){this._map=new Map}get(t){return this._map.get(t)||[]}append(t,e){let i=this._map.get(t);i||this._map.set(t,i=[]),i.push(...e)}has(t){return this._map.has(t)}clear(){this._map.clear()}},Pfe=new RegExp(":enter","g"),kfe=new RegExp(":leave","g");function FG(n,t,e,i,r,o=new Map,s=new Map,a,l,c=[]){return(new Ck).buildKeyframes(n,t,e,i,r,o,s,a,l,c)}var Ck=class{buildKeyframes(t,e,i,r,o,s,a,l,c,d=[]){c=c||new Bb;let u=new Vb(t,e,c,r,o,d,[]);u.options=l;let p=l.delay?pd(l.delay):0;u.currentTimeline.delayNextStep(p),u.currentTimeline.setStyles([s],null,u.errors,l),la(this,i,u);let f=u.timelines.filter(m=>m.containsAnimation());if(f.length&&a.size){let m;for(let b=f.length-1;b>=0;b--){let M=f[b];if(M.element===e){m=M;break}}m&&!m.allowOnlyTimelineStyles()&&m.setStyles([a],null,u.errors,l)}return f.length?f.map(m=>m.buildKeyframes()):[Fk(e,[],[],[],0,p,"",!1)]}visitTrigger(t,e){}visitState(t,e){}visitTransition(t,e){}visitAnimateChild(t,e){let i=e.subInstructions.get(e.element);if(i){let r=e.createSubContext(t.options),o=e.currentTimeline.currentTime,s=this._visitSubInstructions(i,r,r.options);o!=s&&e.transformIntoNewTimeline(s)}e.previousNode=t}visitAnimateRef(t,e){let i=e.createSubContext(t.options);i.transformIntoNewTimeline(),this._applyAnimationRefDelays([t.options,t.animation.options],e,i),this.visitReference(t.animation,i),e.transformIntoNewTimeline(i.currentTimeline.currentTime),e.previousNode=t}_applyAnimationRefDelays(t,e,i){for(let r of t){let o=r?.delay;if(o){let s="number"==typeof o?o:pd(Lb(o,r?.params??{},e.errors));i.delayNextStep(s)}}}_visitSubInstructions(t,e,i){let o=e.currentTimeline.currentTime,s=null!=i.duration?pd(i.duration):null,a=null!=i.delay?pd(i.delay):null;return 0!==s&&t.forEach(l=>{let c=e.appendInstructionToTimeline(l,s,a);o=Math.max(o,c.duration+c.delay)}),o}visitReference(t,e){e.updateOptions(t.options,!0),la(this,t.animation,e),e.previousNode=t}visitSequence(t,e){let i=e.subContextCount,r=e,o=t.options;if(o&&(o.params||o.delay)&&(r=e.createSubContext(o),r.transformIntoNewTimeline(),null!=o.delay)){6==r.previousNode.type&&(r.currentTimeline.snapshotCurrentStyles(),r.previousNode=Fw);let s=pd(o.delay);r.delayNextStep(s)}t.steps.length&&(t.steps.forEach(s=>la(this,s,r)),r.currentTimeline.applyStylesToKeyframe(),r.subContextCount>i&&r.transformIntoNewTimeline()),e.previousNode=t}visitGroup(t,e){let i=[],r=e.currentTimeline.currentTime,o=t.options&&t.options.delay?pd(t.options.delay):0;t.steps.forEach(s=>{let a=e.createSubContext(t.options);o&&a.delayNextStep(o),la(this,s,a),r=Math.max(r,a.currentTimeline.currentTime),i.push(a.currentTimeline)}),i.forEach(s=>e.currentTimeline.mergeTimelineCollectedStyles(s)),e.transformIntoNewTimeline(r),e.previousNode=t}_visitTiming(t,e){if(t.dynamic){let i=t.strValue;return Pw(e.params?Lb(i,e.params,e.errors):i,e.errors)}return{duration:t.duration,delay:t.delay,easing:t.easing}}visitAnimate(t,e){let i=e.currentAnimateTimings=this._visitTiming(t.timings,e),r=e.currentTimeline;i.delay&&(e.incrementTime(i.delay),r.snapshotCurrentStyles());let o=t.style;5==o.type?this.visitKeyframes(o,e):(e.incrementTime(i.duration),this.visitStyle(o,e),r.applyStylesToKeyframe()),e.currentAnimateTimings=null,e.previousNode=t}visitStyle(t,e){let i=e.currentTimeline,r=e.currentAnimateTimings;!r&&i.hasCurrentStyleProperties()&&i.forwardFrame();let o=r&&r.easing||t.easing;t.isEmptyStep?i.applyEmptyStep(o):i.setStyles(t.styles,o,e.errors,e.options),e.previousNode=t}visitKeyframes(t,e){let i=e.currentAnimateTimings,r=e.currentTimeline.duration,o=i.duration,a=e.createSubContext().currentTimeline;a.easing=i.easing,t.styles.forEach(l=>{a.forwardTime((l.offset||0)*o),a.setStyles(l.styles,l.easing,e.errors,e.options),a.applyStylesToKeyframe()}),e.currentTimeline.mergeTimelineCollectedStyles(a),e.transformIntoNewTimeline(r+o),e.previousNode=t}visitQuery(t,e){let i=e.currentTimeline.currentTime,r=t.options||{},o=r.delay?pd(r.delay):0;o&&(6===e.previousNode.type||0==i&&e.currentTimeline.hasCurrentStyleProperties())&&(e.currentTimeline.snapshotCurrentStyles(),e.previousNode=Fw);let s=i,a=e.invokeQuery(t.selector,t.originalSelector,t.limit,t.includeSelf,!!r.optional,e.errors);e.currentQueryTotal=a.length;let l=null;a.forEach((c,d)=>{e.currentQueryIndex=d;let u=e.createSubContext(t.options,c);o&&u.delayNextStep(o),c===e.element&&(l=u.currentTimeline),la(this,t.animation,u),u.currentTimeline.applyStylesToKeyframe(),s=Math.max(s,u.currentTimeline.currentTime)}),e.currentQueryIndex=0,e.currentQueryTotal=0,e.transformIntoNewTimeline(s),l&&(e.currentTimeline.mergeTimelineCollectedStyles(l),e.currentTimeline.snapshotCurrentStyles()),e.previousNode=t}visitStagger(t,e){let i=e.parentContext,r=e.currentTimeline,o=t.timings,s=Math.abs(o.duration),a=s*(e.currentQueryTotal-1),l=s*e.currentQueryIndex;switch(o.duration<0?"reverse":o.easing){case"reverse":l=a-l;break;case"full":l=i.currentStaggerTime}let d=e.currentTimeline;l&&d.delayNextStep(l);let u=d.currentTime;la(this,t.animation,e),e.previousNode=t,i.currentStaggerTime=r.currentTime-u+(r.startTime-i.currentTimeline.startTime)}},Fw={},Vb=class{constructor(t,e,i,r,o,s,a,l){this._driver=t,this.element=e,this.subInstructions=i,this._enterClassName=r,this._leaveClassName=o,this.errors=s,this.timelines=a,this.parentContext=null,this.currentAnimateTimings=null,this.previousNode=Fw,this.subContextCount=0,this.options={},this.currentQueryIndex=0,this.currentQueryTotal=0,this.currentStaggerTime=0,this.currentTimeline=l||new vh(this._driver,e,0),a.push(this.currentTimeline)}get params(){return this.options.params}updateOptions(t,e){if(!t)return;let i=t,r=this.options;null!=i.duration&&(r.duration=pd(i.duration)),null!=i.delay&&(r.delay=pd(i.delay));let o=i.params;if(o){let s=r.params;s||(s=this.options.params={}),Object.keys(o).forEach(a=>{(!e||!s.hasOwnProperty(a))&&(s[a]=Lb(o[a],s,this.errors))})}}_copyOptions(){let t={};if(this.options){let e=this.options.params;if(e){let i=t.params={};Object.keys(e).forEach(r=>{i[r]=e[r]})}}return t}createSubContext(t=null,e,i){let r=e||this.element,o=new Vb(this._driver,r,this.subInstructions,this._enterClassName,this._leaveClassName,this.errors,this.timelines,this.currentTimeline.fork(r,i||0));return o.previousNode=this.previousNode,o.currentAnimateTimings=this.currentAnimateTimings,o.options=this._copyOptions(),o.updateOptions(t),o.currentQueryIndex=this.currentQueryIndex,o.currentQueryTotal=this.currentQueryTotal,o.parentContext=this,this.subContextCount++,o}transformIntoNewTimeline(t){return this.previousNode=Fw,this.currentTimeline=this.currentTimeline.fork(this.element,t),this.timelines.push(this.currentTimeline),this.currentTimeline}appendInstructionToTimeline(t,e,i){let r={duration:e??t.duration,delay:this.currentTimeline.currentTime+(i??0)+t.delay,easing:""},o=new Mk(this._driver,t.element,t.keyframes,t.preStyleProps,t.postStyleProps,r,t.stretchStartingKeyframe);return this.timelines.push(o),r}incrementTime(t){this.currentTimeline.forwardTime(this.currentTimeline.duration+t)}delayNextStep(t){t>0&&this.currentTimeline.delayNextStep(t)}invokeQuery(t,e,i,r,o,s){let a=[];if(r&&a.push(this.element),t.length>0){t=(t=t.replace(Pfe,"."+this._enterClassName)).replace(kfe,"."+this._leaveClassName);let c=this._driver.query(this.element,t,1!=i);0!==i&&(c=i<0?c.slice(c.length+i,c.length):c.slice(0,i)),a.push(...c)}return!o&&0==a.length&&s.push(new yt(3014,!1)),a}},vh=class{constructor(t,e,i,r){this._driver=t,this.element=e,this.startTime=i,this._elementTimelineStylesLookup=r,this.duration=0,this.easing=null,this._previousKeyframe=new Map,this._currentKeyframe=new Map,this._keyframes=new Map,this._styleSummary=new Map,this._localTimelineStyles=new Map,this._pendingStyles=new Map,this._backFill=new Map,this._currentEmptyStepKeyframe=null,this._elementTimelineStylesLookup||(this._elementTimelineStylesLookup=new Map),this._globalTimelineStyles=this._elementTimelineStylesLookup.get(e),this._globalTimelineStyles||(this._globalTimelineStyles=this._localTimelineStyles,this._elementTimelineStylesLookup.set(e,this._localTimelineStyles)),this._loadKeyframe()}containsAnimation(){switch(this._keyframes.size){case 0:return!1;case 1:return this.hasCurrentStyleProperties();default:return!0}}hasCurrentStyleProperties(){return this._currentKeyframe.size>0}get currentTime(){return this.startTime+this.duration}delayNextStep(t){let e=1===this._keyframes.size&&this._pendingStyles.size;this.duration||e?(this.forwardTime(this.currentTime+t),e&&this.snapshotCurrentStyles()):this.startTime+=t}fork(t,e){return this.applyStylesToKeyframe(),new vh(this._driver,t,e||this.currentTime,this._elementTimelineStylesLookup)}_loadKeyframe(){this._currentKeyframe&&(this._previousKeyframe=this._currentKeyframe),this._currentKeyframe=this._keyframes.get(this.duration),this._currentKeyframe||(this._currentKeyframe=new Map,this._keyframes.set(this.duration,this._currentKeyframe))}forwardFrame(){this.duration+=1,this._loadKeyframe()}forwardTime(t){this.applyStylesToKeyframe(),this.duration=t,this._loadKeyframe()}_updateStyle(t,e){this._localTimelineStyles.set(t,e),this._globalTimelineStyles.set(t,e),this._styleSummary.set(t,{time:this.currentTime,value:e})}allowOnlyTimelineStyles(){return this._currentEmptyStepKeyframe!==this._currentKeyframe}applyEmptyStep(t){t&&this._previousKeyframe.set("easing",t);for(let[e,i]of this._globalTimelineStyles)this._backFill.set(e,i||xc),this._currentKeyframe.set(e,xc);this._currentEmptyStepKeyframe=this._currentKeyframe}setStyles(t,e,i,r){e&&this._previousKeyframe.set("easing",e);let o=r&&r.params||{},s=function(n,t){let i,e=new Map;return n.forEach(r=>{if("*"===r){i=i||t.keys();for(let o of i)e.set(o,xc)}else bh(r,e)}),e}(t,this._globalTimelineStyles);for(let[a,l]of s){let c=Lb(l,o,i);this._pendingStyles.set(a,c),this._localTimelineStyles.has(a)||this._backFill.set(a,this._globalTimelineStyles.get(a)??xc),this._updateStyle(a,c)}}applyStylesToKeyframe(){0!=this._pendingStyles.size&&(this._pendingStyles.forEach((t,e)=>{this._currentKeyframe.set(e,t)}),this._pendingStyles.clear(),this._localTimelineStyles.forEach((t,e)=>{this._currentKeyframe.has(e)||this._currentKeyframe.set(e,t)}))}snapshotCurrentStyles(){for(let[t,e]of this._localTimelineStyles)this._pendingStyles.set(t,e),this._updateStyle(t,e)}getFinalKeyframe(){return this._keyframes.get(this.duration)}get properties(){let t=[];for(let e in this._currentKeyframe)t.push(e);return t}mergeTimelineCollectedStyles(t){t._styleSummary.forEach((e,i)=>{let r=this._styleSummary.get(i);(!r||e.time>r.time)&&this._updateStyle(i,e.value)})}buildKeyframes(){this.applyStylesToKeyframe();let t=new Set,e=new Set,i=1===this._keyframes.size&&0===this.duration,r=[];this._keyframes.forEach((a,l)=>{let c=bh(a,new Map,this._backFill);c.forEach((d,u)=>{d===Ew?t.add(u):d===xc&&e.add(u)}),i||c.set("offset",l/this.duration),r.push(c)});let o=t.size?Ow(t.values()):[],s=e.size?Ow(e.values()):[];if(i){let a=r[0],l=new Map(a);a.set("offset",0),l.set("offset",1),r=[a,l]}return Fk(this.element,r,o,s,this.duration,this.startTime,this.easing,!1)}},Mk=class extends vh{constructor(t,e,i,r,o,s,a=!1){super(t,e,s.delay),this.keyframes=i,this.preStyleProps=r,this.postStyleProps=o,this._stretchStartingKeyframe=a,this.timings={duration:s.duration,delay:s.delay,easing:s.easing}}containsAnimation(){return this.keyframes.length>1}buildKeyframes(){let t=this.keyframes,{delay:e,duration:i,easing:r}=this.timings;if(this._stretchStartingKeyframe&&e){let o=[],s=i+e,a=e/s,l=bh(t[0]);l.set("offset",0),o.push(l);let c=bh(t[0]);c.set("offset",pG(a)),o.push(c);let d=t.length-1;for(let u=1;u<=d;u++){let p=bh(t[u]),f=p.get("offset");p.set("offset",pG((e+f*i)/s)),o.push(p)}i=s,e=0,r="",t=o}return Fk(this.element,t,this.preStyleProps,this.postStyleProps,i,e,r,!0)}};function pG(n,t=3){let e=Math.pow(10,t-1);return Math.round(n*e)/e}var nf=class{},Nfe=new Set(["width","height","minWidth","minHeight","maxWidth","maxHeight","left","top","bottom","right","fontSize","outlineWidth","outlineOffset","paddingTop","paddingLeft","paddingBottom","paddingRight","marginTop","marginLeft","marginBottom","marginRight","borderRadius","borderWidth","borderTopWidth","borderLeftWidth","borderRightWidth","borderBottomWidth","textIndent","perspective"]),Nw=class extends nf{normalizePropertyName(t,e){return kk(t)}normalizeStyleValue(t,e,i,r){let o="",s=i.toString().trim();if(Nfe.has(e)&&0!==i&&"0"!==i)if("number"==typeof i)o="px";else{let a=i.match(/^[+-]?[\d\.]+([a-z]*)$/);a&&0==a[1].length&&r.push(new yt(3005,!1))}return s+o}};function fG(n,t,e,i,r,o,s,a,l,c,d,u,p){return{type:0,element:n,triggerName:t,isRemovalTransition:r,fromState:e,fromStyles:o,toState:i,toStyles:s,timelines:a,queriedElements:l,preStyleProps:c,postStyleProps:d,totalTime:u,errors:p}}var uk={},Lw=class{constructor(t,e,i){this._triggerName=t,this.ast=e,this._stateStyles=i}match(t,e,i,r){return function(n,t,e,i,r){return n.some(o=>o(t,e,i,r))}(this.ast.matchers,t,e,i,r)}buildStyles(t,e,i){let r=this._stateStyles.get("*");return void 0!==t&&(r=this._stateStyles.get(t?.toString())||r),r?r.buildStyles(e,i):new Map}build(t,e,i,r,o,s,a,l,c,d){let u=[],p=this.ast.options&&this.ast.options.params||uk,m=this.buildStyles(i,a&&a.params||uk,u),b=l&&l.params||uk,M=this.buildStyles(r,b,u),y=new Set,x=new Map,R=new Map,A="void"===r,V={params:Bfe(b,p),delay:this.ast.options?.delay},te=d?[]:FG(t,e,this.ast.animation,o,s,m,M,V,c,u),K=0;if(te.forEach(Xe=>{K=Math.max(Xe.duration+Xe.delay,K)}),u.length)return fG(e,this._triggerName,i,r,A,m,M,[],[],x,R,K,u);te.forEach(Xe=>{let De=Xe.element,D=ca(x,De,new Set);Xe.preStyleProps.forEach(ce=>D.add(ce));let re=ca(R,De,new Set);Xe.postStyleProps.forEach(ce=>re.add(ce)),De!==e&&y.add(De)});let xe=Ow(y.values());return fG(e,this._triggerName,i,r,A,m,M,te,xe,x,R,K)}};function Bfe(n,t){let e=jb(t);for(let i in n)n.hasOwnProperty(i)&&null!=n[i]&&(e[i]=n[i]);return e}function mG(n,t,e){n.has(t)?n.has(e)||n.set(e,n.get(t)):n.has(e)&&n.set(t,n.get(e))}var zfe=new Bb,hG="ng-animate-queued",pk="ng-animate-disabled",qfe=[],NG={namespaceId:"",setForRemoval:!1,setForMove:!1,hasAnimation:!1,removedBeforeQueried:!1},Yfe={namespaceId:"",setForMove:!1,setForRemoval:!1,hasAnimation:!1,removedBeforeQueried:!0},Ba="__ng_removed",Hb=class{get params(){return this.options.params}constructor(t,e=""){this.namespaceId=e;let i=t&&t.hasOwnProperty("value");if(this.value=(i?t.value:t)??null,i){let o=jb(t);delete o.value,this.options=o}else this.options={};this.options.params||(this.options.params={})}absorbOptions(t){let e=t.params;if(e){let i=this.options.params;Object.keys(e).forEach(r=>{null==i[r]&&(i[r]=e[r])})}}},Nb="void",fk=new Hb(Nb),zb=class{constructor(t,e,i){this.namespaceId=t,this.triggerName=e,this.element=i,this._player=new mu,this._containsRealPlayer=!1,this._queuedCallbacks=new Map,this.destroyed=!1,this.parentPlayer=null,this.markedForDestroy=!1,this.disabled=!1,this.queued=!0,this.totalTime=0}setRealPlayer(t){this._containsRealPlayer||(this._player=t,this._queuedCallbacks.forEach((e,i)=>{e.forEach(r=>Ak(t,i,void 0,r))}),this._queuedCallbacks.clear(),this._containsRealPlayer=!0,this.overrideTotalTime(t.totalTime),this.queued=!1)}getRealPlayer(){return this._player}overrideTotalTime(t){this.totalTime=t}syncPlayerEvents(t){let e=this._player;e.triggerCallback&&t.onStart(()=>e.triggerCallback("start")),t.onDone(()=>this.finish()),t.onDestroy(()=>this.destroy())}_queueEvent(t,e){ca(this._queuedCallbacks,t,[]).push(e)}onDone(t){this.queued&&this._queueEvent("done",t),this._player.onDone(t)}onStart(t){this.queued&&this._queueEvent("start",t),this._player.onStart(t)}onDestroy(t){this.queued&&this._queueEvent("destroy",t),this._player.onDestroy(t)}init(){this._player.init()}hasStarted(){return!this.queued&&this._player.hasStarted()}play(){!this.queued&&this._player.play()}pause(){!this.queued&&this._player.pause()}restart(){!this.queued&&this._player.restart()}finish(){this._player.finish()}destroy(){this.destroyed=!0,this._player.destroy()}reset(){!this.queued&&this._player.reset()}setPosition(t){this.queued||this._player.setPosition(t)}getPosition(){return this.queued?0:this._player.getPosition()}triggerCallback(t){let e=this._player;e.triggerCallback&&e.triggerCallback(t)}};function Aw(n){return n&&1===n.nodeType}function gG(n,t){let e=n.style.display;return n.style.display=t??"none",e}function _G(n,t,e,i,r){let o=[];e.forEach(l=>o.push(gG(l)));let s=[];i.forEach((l,c)=>{let d=new Map;l.forEach(u=>{let p=t.computeStyle(c,u,r);d.set(u,p),(!p||0==p.length)&&(c[Ba]=Yfe,s.push(c))}),n.set(c,d)});let a=0;return e.forEach(l=>gG(l,o[a++])),s}function bG(n,t){let e=new Map;if(n.forEach(a=>e.set(a,[])),0==t.length)return e;let i=1,r=new Set(t),o=new Map;function s(a){if(!a)return i;let l=o.get(a);if(l)return l;let c=a.parentNode;return l=e.has(c)?c:r.has(c)?i:s(c),o.set(a,l),l}return t.forEach(a=>{let l=s(a);l!==i&&e.get(l).push(a)}),e}function Va(n,t){n.classList?.add(t)}function _h(n,t){n.classList?.remove(t)}function Kfe(n,t,e){hu(e).onDone(()=>n.processLeaveNode(t))}function LG(n,t){for(let e=0;e<n.length;e++){let i=n[e];i instanceof Pb?LG(i.players,t):t.push(i)}}function vG(n,t,e){let i=e.get(n);if(!i)return!1;let r=t.get(n);return r?i.forEach(o=>r.add(o)):t.set(n,i),e.delete(n),!0}var gu=class{constructor(t,e,i){this.bodyNode=t,this._driver=e,this._normalizer=i,this._triggerCache={},this.onRemovalComplete=(r,o)=>{},this._transitionEngine=new class{_onRemovalComplete(t,e){this.onRemovalComplete(t,e)}constructor(t,e,i){this.bodyNode=t,this.driver=e,this._normalizer=i,this.players=[],this.newHostElements=new Map,this.playersByElement=new Map,this.playersByQueriedElement=new Map,this.statesByElement=new Map,this.disabledNodes=new Set,this.totalAnimations=0,this.totalQueuedPlayers=0,this._namespaceLookup={},this._namespaceList=[],this._flushFns=[],this._whenQuietFns=[],this.namespacesByHostElement=new Map,this.collectedEnterElements=[],this.collectedLeaveElements=[],this.onRemovalComplete=(r,o)=>{}}get queuedPlayers(){let t=[];return this._namespaceList.forEach(e=>{e.players.forEach(i=>{i.queued&&t.push(i)})}),t}createNamespace(t,e){let i=new class{constructor(t,e,i){this.id=t,this.hostElement=e,this._engine=i,this.players=[],this._triggers=new Map,this._queue=[],this._elementListeners=new Map,this._hostClassName="ng-tns-"+t,Va(e,this._hostClassName)}listen(t,e,i,r){if(!this._triggers.has(e))throw new yt(3302,!1);if(null==i||0==i.length)throw new yt(3303,!1);if("start"!=(n=i)&&"done"!=n)throw new yt(3400,!1);var n;let o=ca(this._elementListeners,t,[]),s={name:e,phase:i,callback:r};o.push(s);let a=ca(this._engine.statesByElement,t,new Map);return a.has(e)||(Va(t,Tw),Va(t,Tw+"-"+e),a.set(e,fk)),()=>{this._engine.afterFlush(()=>{let l=o.indexOf(s);l>=0&&o.splice(l,1),this._triggers.has(e)||a.delete(e)})}}register(t,e){return!this._triggers.has(t)&&(this._triggers.set(t,e),!0)}_getTrigger(t){let e=this._triggers.get(t);if(!e)throw new yt(3401,!1);return e}trigger(t,e,i,r=!0){let o=this._getTrigger(e),s=new zb(this.id,e,t),a=this._engine.statesByElement.get(t);a||(Va(t,Tw),Va(t,Tw+"-"+e),this._engine.statesByElement.set(t,a=new Map));let l=a.get(e),c=new Hb(i,this.id);if(!(i&&i.hasOwnProperty("value"))&&l&&c.absorbOptions(l.options),a.set(e,c),l||(l=fk),c.value!==Nb&&l.value===c.value){if(!function(n,t){let e=Object.keys(n),i=Object.keys(t);if(e.length!=i.length)return!1;for(let r=0;r<e.length;r++){let o=e[r];if(!t.hasOwnProperty(o)||n[o]!==t[o])return!1}return!0}(l.params,c.params)){let b=[],M=o.matchStyles(l.value,l.params,b),y=o.matchStyles(c.value,c.params,b);b.length?this._engine.reportError(b):this._engine.afterFlush(()=>{tf(t,M),Cc(t,y)})}return}let p=ca(this._engine.playersByElement,t,[]);p.forEach(b=>{b.namespaceId==this.id&&b.triggerName==e&&b.queued&&b.destroy()});let f=o.matchTransition(l.value,c.value,t,c.params),m=!1;if(!f){if(!r)return;f=o.fallbackTransition,m=!0}return this._engine.totalQueuedPlayers++,this._queue.push({element:t,triggerName:e,transition:f,fromState:l,toState:c,player:s,isFallbackTransition:m}),m||(Va(t,hG),s.onStart(()=>{_h(t,hG)})),s.onDone(()=>{let b=this.players.indexOf(s);b>=0&&this.players.splice(b,1);let M=this._engine.playersByElement.get(t);if(M){let y=M.indexOf(s);y>=0&&M.splice(y,1)}}),this.players.push(s),p.push(s),s}deregister(t){this._triggers.delete(t),this._engine.statesByElement.forEach(e=>e.delete(t)),this._elementListeners.forEach((e,i)=>{this._elementListeners.set(i,e.filter(r=>r.name!=t))})}clearElementCache(t){this._engine.statesByElement.delete(t),this._elementListeners.delete(t);let e=this._engine.playersByElement.get(t);e&&(e.forEach(i=>i.destroy()),this._engine.playersByElement.delete(t))}_signalRemovalForInnerTriggers(t,e){let i=this._engine.driver.query(t,Rw,!0);i.forEach(r=>{if(r[Ba])return;let o=this._engine.fetchNamespacesByElement(r);o.size?o.forEach(s=>s.triggerLeaveAnimation(r,e,!1,!0)):this.clearElementCache(r)}),this._engine.afterFlushAnimationsDone(()=>i.forEach(r=>this.clearElementCache(r)))}triggerLeaveAnimation(t,e,i,r){let o=this._engine.statesByElement.get(t),s=new Map;if(o){let a=[];if(o.forEach((l,c)=>{if(s.set(c,l.value),this._triggers.has(c)){let d=this.trigger(t,c,Nb,r);d&&a.push(d)}}),a.length)return this._engine.markElementAsRemoved(this.id,t,!0,e,s),i&&hu(a).onDone(()=>this._engine.processLeaveNode(t)),!0}return!1}prepareLeaveAnimationListeners(t){let e=this._elementListeners.get(t),i=this._engine.statesByElement.get(t);if(e&&i){let r=new Set;e.forEach(o=>{let s=o.name;if(r.has(s))return;r.add(s);let l=this._triggers.get(s).fallbackTransition,c=i.get(s)||fk,d=new Hb(Nb),u=new zb(this.id,s,t);this._engine.totalQueuedPlayers++,this._queue.push({element:t,triggerName:s,transition:l,fromState:c,toState:d,player:u,isFallbackTransition:!0})})}}removeNode(t,e){let i=this._engine;if(t.childElementCount&&this._signalRemovalForInnerTriggers(t,e),this.triggerLeaveAnimation(t,e,!0))return;let r=!1;if(i.totalAnimations){let o=i.players.length?i.playersByQueriedElement.get(t):[];if(o&&o.length)r=!0;else{let s=t;for(;s=s.parentNode;)if(i.statesByElement.get(s)){r=!0;break}}}if(this.prepareLeaveAnimationListeners(t),r)i.markElementAsRemoved(this.id,t,!1,e);else{let o=t[Ba];(!o||o===NG)&&(i.afterFlush(()=>this.clearElementCache(t)),i.destroyInnerAnimations(t),i._onRemovalComplete(t,e))}}insertNode(t,e){Va(t,this._hostClassName)}drainQueuedTransitions(t){let e=[];return this._queue.forEach(i=>{let r=i.player;if(r.destroyed)return;let o=i.element,s=this._elementListeners.get(o);s&&s.forEach(a=>{if(a.name==i.triggerName){let l=Rk(o,i.triggerName,i.fromState.value,i.toState.value);l._data=t,Ak(i.player,a.phase,l,a.callback)}}),r.markedForDestroy?this._engine.afterFlush(()=>{r.destroy()}):e.push(i)}),this._queue=[],e.sort((i,r)=>{let o=i.transition.ast.depCount,s=r.transition.ast.depCount;return 0==o||0==s?o-s:this._engine.driver.containsElement(i.element,r.element)?1:-1})}destroy(t){this.players.forEach(e=>e.destroy()),this._signalRemovalForInnerTriggers(this.hostElement,t)}elementContainsData(t){let e=!1;return this._elementListeners.has(t)&&(e=!0),e=!!this._queue.find(i=>i.element===t)||e,e}}(t,e,this);return this.bodyNode&&this.driver.containsElement(this.bodyNode,e)?this._balanceNamespaceList(i,e):(this.newHostElements.set(e,i),this.collectEnterElement(e)),this._namespaceLookup[t]=i}_balanceNamespaceList(t,e){let i=this._namespaceList,r=this.namespacesByHostElement;if(i.length-1>=0){let s=!1,a=this.driver.getParentElement(e);for(;a;){let l=r.get(a);if(l){let c=i.indexOf(l);i.splice(c+1,0,t),s=!0;break}a=this.driver.getParentElement(a)}s||i.unshift(t)}else i.push(t);return r.set(e,t),t}register(t,e){let i=this._namespaceLookup[t];return i||(i=this.createNamespace(t,e)),i}registerTrigger(t,e,i){let r=this._namespaceLookup[t];r&&r.register(e,i)&&this.totalAnimations++}destroy(t,e){if(!t)return;let i=this._fetchNamespace(t);this.afterFlush(()=>{this.namespacesByHostElement.delete(i.hostElement),delete this._namespaceLookup[t];let r=this._namespaceList.indexOf(i);r>=0&&this._namespaceList.splice(r,1)}),this.afterFlushAnimationsDone(()=>i.destroy(e))}_fetchNamespace(t){return this._namespaceLookup[t]}fetchNamespacesByElement(t){let e=new Set,i=this.statesByElement.get(t);if(i)for(let r of i.values())if(r.namespaceId){let o=this._fetchNamespace(r.namespaceId);o&&e.add(o)}return e}trigger(t,e,i,r){if(Aw(e)){let o=this._fetchNamespace(t);if(o)return o.trigger(e,i,r),!0}return!1}insertNode(t,e,i,r){if(!Aw(e))return;let o=e[Ba];if(o&&o.setForRemoval){o.setForRemoval=!1,o.setForMove=!0;let s=this.collectedLeaveElements.indexOf(e);s>=0&&this.collectedLeaveElements.splice(s,1)}if(t){let s=this._fetchNamespace(t);s&&s.insertNode(e,i)}r&&this.collectEnterElement(e)}collectEnterElement(t){this.collectedEnterElements.push(t)}markElementAsDisabled(t,e){e?this.disabledNodes.has(t)||(this.disabledNodes.add(t),Va(t,pk)):this.disabledNodes.has(t)&&(this.disabledNodes.delete(t),_h(t,pk))}removeNode(t,e,i,r){if(Aw(e)){let o=t?this._fetchNamespace(t):null;if(o?o.removeNode(e,r):this.markElementAsRemoved(t,e,!1,r),i){let s=this.namespacesByHostElement.get(e);s&&s.id!==t&&s.removeNode(e,r)}}else this._onRemovalComplete(e,r)}markElementAsRemoved(t,e,i,r,o){this.collectedLeaveElements.push(e),e[Ba]={namespaceId:t,setForRemoval:r,hasAnimation:i,removedBeforeQueried:!1,previousTriggersValues:o}}listen(t,e,i,r,o){return Aw(e)?this._fetchNamespace(t).listen(e,i,r,o):()=>{}}_buildInstruction(t,e,i,r,o){return t.transition.build(this.driver,t.element,t.fromState.value,t.toState.value,i,r,t.fromState.options,t.toState.options,e,o)}destroyInnerAnimations(t){let e=this.driver.query(t,Rw,!0);e.forEach(i=>this.destroyActiveAnimationsForElement(i)),0!=this.playersByQueriedElement.size&&(e=this.driver.query(t,_k,!0),e.forEach(i=>this.finishActiveQueriedAnimationOnElement(i)))}destroyActiveAnimationsForElement(t){let e=this.playersByElement.get(t);e&&e.forEach(i=>{i.queued?i.markedForDestroy=!0:i.destroy()})}finishActiveQueriedAnimationOnElement(t){let e=this.playersByQueriedElement.get(t);e&&e.forEach(i=>i.finish())}whenRenderingDone(){return new Promise(t=>{if(this.players.length)return hu(this.players).onDone(()=>t());t()})}processLeaveNode(t){let e=t[Ba];if(e&&e.setForRemoval){if(t[Ba]=NG,e.namespaceId){this.destroyInnerAnimations(t);let i=this._fetchNamespace(e.namespaceId);i&&i.clearElementCache(t)}this._onRemovalComplete(t,e.setForRemoval)}t.classList?.contains(pk)&&this.markElementAsDisabled(t,!1),this.driver.query(t,".ng-animate-disabled",!0).forEach(i=>{this.markElementAsDisabled(i,!1)})}flush(t=-1){let e=[];if(this.newHostElements.size&&(this.newHostElements.forEach((i,r)=>this._balanceNamespaceList(i,r)),this.newHostElements.clear()),this.totalAnimations&&this.collectedEnterElements.length)for(let i=0;i<this.collectedEnterElements.length;i++)Va(this.collectedEnterElements[i],"ng-star-inserted");if(this._namespaceList.length&&(this.totalQueuedPlayers||this.collectedLeaveElements.length)){let i=[];try{e=this._flushAnimations(i,t)}finally{for(let r=0;r<i.length;r++)i[r]()}}else for(let i=0;i<this.collectedLeaveElements.length;i++)this.processLeaveNode(this.collectedLeaveElements[i]);if(this.totalQueuedPlayers=0,this.collectedEnterElements.length=0,this.collectedLeaveElements.length=0,this._flushFns.forEach(i=>i()),this._flushFns=[],this._whenQuietFns.length){let i=this._whenQuietFns;this._whenQuietFns=[],e.length?hu(e).onDone(()=>{i.forEach(r=>r())}):i.forEach(r=>r())}}reportError(t){throw new yt(3402,!1)}_flushAnimations(t,e){let i=new Bb,r=[],o=new Map,s=[],a=new Map,l=new Map,c=new Map,d=new Set;this.disabledNodes.forEach(ne=>{d.add(ne);let de=this.driver.query(ne,".ng-animate-queued",!0);for(let pe=0;pe<de.length;pe++)d.add(de[pe])});let u=this.bodyNode,p=Array.from(this.statesByElement.keys()),f=bG(p,this.collectedEnterElements),m=new Map,b=0;f.forEach((ne,de)=>{let pe=EG+b++;m.set(de,pe),ne.forEach(je=>Va(je,pe))});let M=[],y=new Set,x=new Set;for(let ne=0;ne<this.collectedLeaveElements.length;ne++){let de=this.collectedLeaveElements[ne],pe=de[Ba];pe&&pe.setForRemoval&&(M.push(de),y.add(de),pe.hasAnimation?this.driver.query(de,".ng-star-inserted",!0).forEach(je=>y.add(je)):x.add(de))}let R=new Map,A=bG(p,Array.from(y));A.forEach((ne,de)=>{let pe=gk+b++;R.set(de,pe),ne.forEach(je=>Va(je,pe))}),t.push(()=>{f.forEach((ne,de)=>{let pe=m.get(de);ne.forEach(je=>_h(je,pe))}),A.forEach((ne,de)=>{let pe=R.get(de);ne.forEach(je=>_h(je,pe))}),M.forEach(ne=>{this.processLeaveNode(ne)})});let V=[],te=[];for(let ne=this._namespaceList.length-1;ne>=0;ne--)this._namespaceList[ne].drainQueuedTransitions(e).forEach(pe=>{let je=pe.player,Ce=pe.element;if(V.push(je),this.collectedEnterElements.length){let wt=Ce[Ba];if(wt&&wt.setForMove){if(wt.previousTriggersValues&&wt.previousTriggersValues.has(pe.triggerName)){let on=wt.previousTriggersValues.get(pe.triggerName),ve=this.statesByElement.get(pe.element);if(ve&&ve.has(pe.triggerName)){let mt=ve.get(pe.triggerName);mt.value=on,ve.set(pe.triggerName,mt)}}return void je.destroy()}}let Ne=!u||!this.driver.containsElement(u,Ce),lt=R.get(Ce),Mt=m.get(Ce),pt=this._buildInstruction(pe,i,Mt,lt,Ne);if(pt.errors&&pt.errors.length)return void te.push(pt);if(Ne)return je.onStart(()=>tf(Ce,pt.fromStyles)),je.onDestroy(()=>Cc(Ce,pt.toStyles)),void r.push(je);if(pe.isFallbackTransition)return je.onStart(()=>tf(Ce,pt.fromStyles)),je.onDestroy(()=>Cc(Ce,pt.toStyles)),void r.push(je);let Oe=[];pt.timelines.forEach(wt=>{wt.stretchStartingKeyframe=!0,this.disabledNodes.has(wt.element)||Oe.push(wt)}),pt.timelines=Oe,i.append(Ce,pt.timelines),s.push({instruction:pt,player:je,element:Ce}),pt.queriedElements.forEach(wt=>ca(a,wt,[]).push(je)),pt.preStyleProps.forEach((wt,on)=>{if(wt.size){let ve=l.get(on);ve||l.set(on,ve=new Set),wt.forEach((mt,ft)=>ve.add(ft))}}),pt.postStyleProps.forEach((wt,on)=>{let ve=c.get(on);ve||c.set(on,ve=new Set),wt.forEach((mt,ft)=>ve.add(ft))})});if(te.length){let ne=[];te.forEach(de=>{ne.push(new yt(3505,!1))}),V.forEach(de=>de.destroy()),this.reportError(ne)}let K=new Map,xe=new Map;s.forEach(ne=>{let de=ne.element;i.has(de)&&(xe.set(de,de),this._beforeAnimationBuild(ne.player.namespaceId,ne.instruction,K))}),r.forEach(ne=>{let de=ne.element;this._getPreviousPlayers(de,!1,ne.namespaceId,ne.triggerName,null).forEach(je=>{ca(K,de,[]).push(je),je.destroy()})});let Xe=M.filter(ne=>vG(ne,l,c)),De=new Map;_G(De,this.driver,x,c,xc).forEach(ne=>{vG(ne,l,c)&&Xe.push(ne)});let re=new Map;f.forEach((ne,de)=>{_G(re,this.driver,new Set(ne),l,Ew)}),Xe.forEach(ne=>{let de=De.get(ne),pe=re.get(ne);De.set(ne,new Map([...Array.from(de?.entries()??[]),...Array.from(pe?.entries()??[])]))});let ce=[],fe=[],be={};s.forEach(ne=>{let{element:de,player:pe,instruction:je}=ne;if(i.has(de)){if(d.has(de))return pe.onDestroy(()=>Cc(de,je.toStyles)),pe.disabled=!0,pe.overrideTotalTime(je.totalTime),void r.push(pe);let Ce=be;if(xe.size>1){let lt=de,Mt=[];for(;lt=lt.parentNode;){let pt=xe.get(lt);if(pt){Ce=pt;break}Mt.push(lt)}Mt.forEach(pt=>xe.set(pt,Ce))}let Ne=this._buildAnimation(pe.namespaceId,je,K,o,re,De);if(pe.setRealPlayer(Ne),Ce===be)ce.push(pe);else{let lt=this.playersByElement.get(Ce);lt&&lt.length&&(pe.parentPlayer=hu(lt)),r.push(pe)}}else tf(de,je.fromStyles),pe.onDestroy(()=>Cc(de,je.toStyles)),fe.push(pe),d.has(de)&&r.push(pe)}),fe.forEach(ne=>{let de=o.get(ne.element);if(de&&de.length){let pe=hu(de);ne.setRealPlayer(pe)}}),r.forEach(ne=>{ne.parentPlayer?ne.syncPlayerEvents(ne.parentPlayer):ne.destroy()});for(let ne=0;ne<M.length;ne++){let de=M[ne],pe=de[Ba];if(_h(de,gk),pe&&pe.hasAnimation)continue;let je=[];if(a.size){let Ne=a.get(de);Ne&&Ne.length&&je.push(...Ne);let lt=this.driver.query(de,_k,!0);for(let Mt=0;Mt<lt.length;Mt++){let pt=a.get(lt[Mt]);pt&&pt.length&&je.push(...pt)}}let Ce=je.filter(Ne=>!Ne.destroyed);Ce.length?Kfe(this,de,Ce):this.processLeaveNode(de)}return M.length=0,ce.forEach(ne=>{this.players.push(ne),ne.onDone(()=>{ne.destroy();let de=this.players.indexOf(ne);this.players.splice(de,1)}),ne.play()}),ce}elementContainsData(t,e){let i=!1,r=e[Ba];return r&&r.setForRemoval&&(i=!0),this.playersByElement.has(e)&&(i=!0),this.playersByQueriedElement.has(e)&&(i=!0),this.statesByElement.has(e)&&(i=!0),this._fetchNamespace(t).elementContainsData(e)||i}afterFlush(t){this._flushFns.push(t)}afterFlushAnimationsDone(t){this._whenQuietFns.push(t)}_getPreviousPlayers(t,e,i,r,o){let s=[];if(e){let a=this.playersByQueriedElement.get(t);a&&(s=a)}else{let a=this.playersByElement.get(t);if(a){let l=!o||o==Nb;a.forEach(c=>{c.queued||!l&&c.triggerName!=r||s.push(c)})}}return(i||r)&&(s=s.filter(a=>!(i&&i!=a.namespaceId||r&&r!=a.triggerName))),s}_beforeAnimationBuild(t,e,i){let o=e.element,s=e.isRemovalTransition?void 0:t,a=e.isRemovalTransition?void 0:e.triggerName;for(let l of e.timelines){let c=l.element,d=c!==o,u=ca(i,c,[]);this._getPreviousPlayers(c,d,s,a,e.toState).forEach(f=>{let m=f.getRealPlayer();m.beforeDestroy&&m.beforeDestroy(),f.destroy(),u.push(f)})}tf(o,e.fromStyles)}_buildAnimation(t,e,i,r,o,s){let a=e.triggerName,l=e.element,c=[],d=new Set,u=new Set,p=e.timelines.map(m=>{let b=m.element;d.add(b);let M=b[Ba];if(M&&M.removedBeforeQueried)return new mu(m.duration,m.delay);let y=b!==l,x=function(n){let t=[];return LG(n,t),t}((i.get(b)||qfe).map(K=>K.getRealPlayer())).filter(K=>!!K.element&&K.element===b),R=o.get(b),A=s.get(b),V=yG(0,this._normalizer,0,m.keyframes,R,A),te=this._buildPlayer(m,V,x);if(m.subTimeline&&r&&u.add(b),y){let K=new zb(t,a,b);K.setRealPlayer(te),c.push(K)}return te});c.forEach(m=>{ca(this.playersByQueriedElement,m.element,[]).push(m),m.onDone(()=>function(n,t,e){let i=n.get(t);if(i){if(i.length){let r=i.indexOf(e);i.splice(r,1)}0==i.length&&n.delete(t)}return i}(this.playersByQueriedElement,m.element,m))}),d.forEach(m=>Va(m,lG));let f=hu(p);return f.onDestroy(()=>{d.forEach(m=>_h(m,lG)),Cc(l,e.toStyles)}),u.forEach(m=>{ca(r,m,[]).push(f)}),f}_buildPlayer(t,e,i){return e.length>0?this.driver.animate(t.element,e,t.duration,t.delay,t.easing,i):new mu(t.duration,t.delay)}}(t,e,i),this._timelineEngine=new class{constructor(t,e,i){this.bodyNode=t,this._driver=e,this._normalizer=i,this._animations=new Map,this._playersById=new Map,this.players=[]}register(t,e){let i=[],r=[],o=kG(this._driver,e,i,r);if(i.length)throw new yt(3503,!1);this._animations.set(t,o)}_buildPlayer(t,e,i){let r=t.element,o=yG(0,this._normalizer,0,t.keyframes,e,i);return this._driver.animate(r,o,t.duration,t.delay,t.easing,[],!0)}create(t,e,i={}){let s,r=[],o=this._animations.get(t),a=new Map;if(o?(s=FG(this._driver,e,o,EG,gk,new Map,new Map,i,zfe,r),s.forEach(d=>{let u=ca(a,d.element,new Map);d.postStyleProps.forEach(p=>u.set(p,null))})):(r.push(new yt(3300,!1)),s=[]),r.length)throw new yt(3504,!1);a.forEach((d,u)=>{d.forEach((p,f)=>{d.set(f,this._driver.computeStyle(u,f,xc))})});let c=hu(s.map(d=>{let u=a.get(d.element);return this._buildPlayer(d,new Map,u)}));return this._playersById.set(t,c),c.onDestroy(()=>this.destroy(t)),this.players.push(c),c}destroy(t){let e=this._getPlayer(t);e.destroy(),this._playersById.delete(t);let i=this.players.indexOf(e);i>=0&&this.players.splice(i,1)}_getPlayer(t){let e=this._playersById.get(t);if(!e)throw new yt(3301,!1);return e}listen(t,e,i,r){let o=Rk(e,"","","");return Ak(this._getPlayer(t),i,o,r),()=>{}}command(t,e,i,r){if("register"==i)return void this.register(t,r[0]);if("create"==i)return void this.create(t,e,r[0]||{});let o=this._getPlayer(t);switch(i){case"play":o.play();break;case"pause":o.pause();break;case"reset":o.reset();break;case"restart":o.restart();break;case"finish":o.finish();break;case"init":o.init();break;case"setPosition":o.setPosition(parseFloat(r[0]));break;case"destroy":this.destroy(t)}}}(t,e,i),this._transitionEngine.onRemovalComplete=(r,o)=>this.onRemovalComplete(r,o)}registerTrigger(t,e,i,r,o){let s=t+"-"+r,a=this._triggerCache[s];if(!a){let l=[],c=[],d=kG(this._driver,o,l,c);if(l.length)throw new yt(3404,!1);a=function(n,t,e){return new class{constructor(t,e,i){this.name=t,this.ast=e,this._normalizer=i,this.transitionFactories=[],this.states=new Map,e.states.forEach(r=>{let o=r.options&&r.options.params||{};this.states.set(r.name,new class{constructor(t,e,i){this.styles=t,this.defaultParams=e,this.normalizer=i}buildStyles(t,e){let i=new Map,r=jb(this.defaultParams);return Object.keys(t).forEach(o=>{let s=t[o];null!==s&&(r[o]=s)}),this.styles.styles.forEach(o=>{"string"!=typeof o&&o.forEach((s,a)=>{s&&(s=Lb(s,r,e));let l=this.normalizer.normalizePropertyName(a,e);s=this.normalizer.normalizeStyleValue(a,l,s,e),i.set(a,s)})}),i}}(r.style,o,i))}),mG(this.states,"true","1"),mG(this.states,"false","0"),e.transitions.forEach(r=>{this.transitionFactories.push(new Lw(t,r,this.states))}),this.fallbackTransition=function(n,t,e){return new Lw(n,{type:1,animation:{type:2,steps:[],options:null},matchers:[(s,a)=>!0],options:null,queryCount:0,depCount:0},t)}(t,this.states)}get containsQueries(){return this.ast.queryCount>0}matchTransition(t,e,i,r){return this.transitionFactories.find(s=>s.match(t,e,i,r))||null}matchStyles(t,e,i){return this.fallbackTransition.buildStyles(t,e,i)}}(n,t,e)}(r,d,this._normalizer),this._triggerCache[s]=a}this._transitionEngine.registerTrigger(e,r,a)}register(t,e){this._transitionEngine.register(t,e)}destroy(t,e){this._transitionEngine.destroy(t,e)}onInsert(t,e,i,r){this._transitionEngine.insertNode(t,e,i,r)}onRemove(t,e,i,r){this._transitionEngine.removeNode(t,e,r||!1,i)}disableAnimations(t,e){this._transitionEngine.markElementAsDisabled(t,e)}process(t,e,i,r){if("@"==i.charAt(0)){let[o,s]=sG(i);this._timelineEngine.command(o,e,s,r)}else this._transitionEngine.trigger(t,e,i,r)}listen(t,e,i,r,o){if("@"==i.charAt(0)){let[s,a]=sG(i);return this._timelineEngine.listen(s,e,a,o)}return this._transitionEngine.listen(t,e,i,r,o)}flush(t=-1){this._transitionEngine.flush(t)}get players(){return this._transitionEngine.players.concat(this._timelineEngine.players)}whenRenderingDone(){return this._transitionEngine.whenRenderingDone()}},tme=(()=>{class n{constructor(e,i,r){this._element=e,this._startStyles=i,this._endStyles=r,this._state=0;let o=n.initialStylesByElement.get(e);o||n.initialStylesByElement.set(e,o=new Map),this._initialStyles=o}start(){this._state<1&&(this._startStyles&&Cc(this._element,this._startStyles,this._initialStyles),this._state=1)}finish(){this.start(),this._state<2&&(Cc(this._element,this._initialStyles),this._endStyles&&(Cc(this._element,this._endStyles),this._endStyles=null),this._state=1)}destroy(){this.finish(),this._state<3&&(n.initialStylesByElement.delete(this._element),this._startStyles&&(tf(this._element,this._startStyles),this._endStyles=null),this._endStyles&&(tf(this._element,this._endStyles),this._endStyles=null),Cc(this._element,this._initialStyles),this._state=3)}}return n.initialStylesByElement=new WeakMap,n})();function mk(n){let t=null;return n.forEach((e,i)=>{(function(n){return"display"===n||"position"===n})(i)&&(t=t||new Map,t.set(i,e))}),t}var Bw=class{constructor(t,e,i,r){this.element=t,this.keyframes=e,this.options=i,this._specialStyles=r,this._onDoneFns=[],this._onStartFns=[],this._onDestroyFns=[],this._initialized=!1,this._finished=!1,this._started=!1,this._destroyed=!1,this._originalOnDoneFns=[],this._originalOnStartFns=[],this.time=0,this.parentPlayer=null,this.currentSnapshot=new Map,this._duration=i.duration,this._delay=i.delay||0,this.time=this._duration+this._delay}_onFinish(){this._finished||(this._finished=!0,this._onDoneFns.forEach(t=>t()),this._onDoneFns=[])}init(){this._buildPlayer(),this._preparePlayerBeforeStart()}_buildPlayer(){if(this._initialized)return;this._initialized=!0;let t=this.keyframes;this.domPlayer=this._triggerWebAnimation(this.element,t,this.options),this._finalKeyframe=t.length?t[t.length-1]:new Map,this.domPlayer.addEventListener("finish",()=>this._onFinish())}_preparePlayerBeforeStart(){this._delay?this._resetDomPlayerState():this.domPlayer.pause()}_convertKeyframesToObject(t){let e=[];return t.forEach(i=>{e.push(Object.fromEntries(i))}),e}_triggerWebAnimation(t,e,i){return t.animate(this._convertKeyframesToObject(e),i)}onStart(t){this._originalOnStartFns.push(t),this._onStartFns.push(t)}onDone(t){this._originalOnDoneFns.push(t),this._onDoneFns.push(t)}onDestroy(t){this._onDestroyFns.push(t)}play(){this._buildPlayer(),this.hasStarted()||(this._onStartFns.forEach(t=>t()),this._onStartFns=[],this._started=!0,this._specialStyles&&this._specialStyles.start()),this.domPlayer.play()}pause(){this.init(),this.domPlayer.pause()}finish(){this.init(),this._specialStyles&&this._specialStyles.finish(),this._onFinish(),this.domPlayer.finish()}reset(){this._resetDomPlayerState(),this._destroyed=!1,this._finished=!1,this._started=!1,this._onStartFns=this._originalOnStartFns,this._onDoneFns=this._originalOnDoneFns}_resetDomPlayerState(){this.domPlayer&&this.domPlayer.cancel()}restart(){this.reset(),this.play()}hasStarted(){return this._started}destroy(){this._destroyed||(this._destroyed=!0,this._resetDomPlayerState(),this._onFinish(),this._specialStyles&&this._specialStyles.destroy(),this._onDestroyFns.forEach(t=>t()),this._onDestroyFns=[])}setPosition(t){void 0===this.domPlayer&&this.init(),this.domPlayer.currentTime=t*this.time}getPosition(){return this.domPlayer.currentTime/this.time}get totalTime(){return this._delay+this._duration}beforeDestroy(){let t=new Map;this.hasStarted()&&this._finalKeyframe.forEach((i,r)=>{"offset"!==r&&t.set(r,this._finished?i:AG(this.element,r))}),this.currentSnapshot=t}triggerCallback(t){let e="start"===t?this._onStartFns:this._onDoneFns;e.forEach(i=>i()),e.length=0}},rme=(()=>{class n extends Rb{constructor(e,i){super(),this._nextAnimationId=0,this._renderer=e.createRenderer(i.body,{id:"0",encapsulation:ra.None,styles:[],data:{animation:[]}})}build(e){let i=this._nextAnimationId.toString();this._nextAnimationId++;let r=Array.isArray(e)?Sw(e):e;return VG(this._renderer,null,i,"register",[r]),new Nk(i,this._renderer)}}return n.\u0275fac=function(e){return new(e||n)(k(fc),k(Lt))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),Nk=class extends ww{constructor(t,e){super(),this._id=t,this._renderer=e}create(t,e){return new Lk(this._id,t,e||{},this._renderer)}},Lk=class{constructor(t,e,i,r){this.id=t,this.element=e,this._renderer=r,this.parentPlayer=null,this._started=!1,this.totalTime=0,this._command("create",i)}_listen(t,e){return this._renderer.listen(this.element,`@@${this.id}:${t}`,e)}_command(t,...e){return VG(this._renderer,this.element,this.id,t,e)}onDone(t){this._listen("done",t)}onStart(t){this._listen("start",t)}onDestroy(t){this._listen("destroy",t)}init(){this._command("init")}hasStarted(){return this._started}play(){this._command("play"),this._started=!0}pause(){this._command("pause")}restart(){this._command("restart")}finish(){this._command("finish")}destroy(){this._command("destroy")}reset(){this._command("reset"),this._started=!1}setPosition(t){this._command("setPosition",t)}getPosition(){return this._renderer.engine.players[+this.id]?.getPosition()??0}};function VG(n,t,e,i,r){return n.setProperty(t,`@@${e}:${i}`,r)}var HG="@.disabled",ome=(()=>{class n{constructor(e,i,r){this.delegate=e,this.engine=i,this._zone=r,this._currentId=0,this._microtaskId=1,this._animationCallbacksBuffer=[],this._rendererCache=new Map,this._cdRecurDepth=0,this.promise=Promise.resolve(0),i.onRemovalComplete=(o,s)=>{let a=s?.parentNode(o);a&&s.removeChild(a,o)}}createRenderer(e,i){let o=this.delegate.createRenderer(e,i);if(!(e&&i&&i.data&&i.data.animation)){let d=this._rendererCache.get(o);return d||(d=new zw("",o,this.engine,()=>this._rendererCache.delete(o)),this._rendererCache.set(o,d)),d}let s=i.id,a=i.id+"-"+this._currentId;this._currentId++,this.engine.register(a,e);let l=d=>{Array.isArray(d)?d.forEach(l):this.engine.registerTrigger(s,a,e,d.name,d)};return i.data.animation.forEach(l),new Bk(this,a,o,this.engine)}begin(){this._cdRecurDepth++,this.delegate.begin&&this.delegate.begin()}_scheduleCountTask(){this.promise.then(()=>{this._microtaskId++})}scheduleListenerCallback(e,i,r){e>=0&&e<this._microtaskId?this._zone.run(()=>i(r)):(0==this._animationCallbacksBuffer.length&&Promise.resolve(null).then(()=>{this._zone.run(()=>{this._animationCallbacksBuffer.forEach(o=>{let[s,a]=o;s(a)}),this._animationCallbacksBuffer=[]})}),this._animationCallbacksBuffer.push([i,r]))}end(){this._cdRecurDepth--,0==this._cdRecurDepth&&this._zone.runOutsideAngular(()=>{this._scheduleCountTask(),this.engine.flush(this._microtaskId)}),this.delegate.end&&this.delegate.end()}whenRenderingDone(){return this.engine.whenRenderingDone()}}return n.\u0275fac=function(e){return new(e||n)(k(fc),k(gu),k(at))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),zw=class{constructor(t,e,i,r){this.namespaceId=t,this.delegate=e,this.engine=i,this._onDestroy=r,this.destroyNode=this.delegate.destroyNode?o=>e.destroyNode(o):null}get data(){return this.delegate.data}destroy(){this.engine.destroy(this.namespaceId,this.delegate),this.delegate.destroy(),this._onDestroy?.()}createElement(t,e){return this.delegate.createElement(t,e)}createComment(t){return this.delegate.createComment(t)}createText(t){return this.delegate.createText(t)}appendChild(t,e){this.delegate.appendChild(t,e),this.engine.onInsert(this.namespaceId,e,t,!1)}insertBefore(t,e,i,r=!0){this.delegate.insertBefore(t,e,i),this.engine.onInsert(this.namespaceId,e,t,r)}removeChild(t,e,i){this.engine.onRemove(this.namespaceId,e,this.delegate,i)}selectRootElement(t,e){return this.delegate.selectRootElement(t,e)}parentNode(t){return this.delegate.parentNode(t)}nextSibling(t){return this.delegate.nextSibling(t)}setAttribute(t,e,i,r){this.delegate.setAttribute(t,e,i,r)}removeAttribute(t,e,i){this.delegate.removeAttribute(t,e,i)}addClass(t,e){this.delegate.addClass(t,e)}removeClass(t,e){this.delegate.removeClass(t,e)}setStyle(t,e,i,r){this.delegate.setStyle(t,e,i,r)}removeStyle(t,e,i){this.delegate.removeStyle(t,e,i)}setProperty(t,e,i){"@"==e.charAt(0)&&e==HG?this.disableAnimations(t,!!i):this.delegate.setProperty(t,e,i)}setValue(t,e){this.delegate.setValue(t,e)}listen(t,e,i){return this.delegate.listen(t,e,i)}disableAnimations(t,e){this.engine.disableAnimations(t,e)}},Bk=class extends zw{constructor(t,e,i,r,o){super(e,i,r,o),this.factory=t,this.namespaceId=e}setProperty(t,e,i){"@"==e.charAt(0)?"."==e.charAt(1)&&e==HG?this.disableAnimations(t,i=void 0===i||!!i):this.engine.process(this.namespaceId,t,e.slice(1),i):this.delegate.setProperty(t,e,i)}listen(t,e,i){if("@"==e.charAt(0)){let r=function(n){switch(n){case"body":return document.body;case"document":return document;case"window":return window;default:return n}}(t),o=e.slice(1),s="";return"@"!=o.charAt(0)&&([o,s]=function(n){let t=n.indexOf(".");return[n.substring(0,t),n.slice(t+1)]}(o)),this.engine.listen(this.namespaceId,r,o,s,a=>{this.factory.scheduleListenerCallback(a._data||-1,i,a)})}return this.delegate.listen(t,e,i)}},lme=(()=>{class n extends gu{constructor(e,i,r,o){super(e.body,i,r)}ngOnDestroy(){this.flush()}}return n.\u0275fac=function(e){return new(e||n)(k(Lt),k(Ub),k(nf),k(yc))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),zG=[{provide:Rb,useClass:rme},{provide:nf,useFactory:function(){return new Nw}},{provide:gu,useClass:lme},{provide:fc,useFactory:function(n,t,e){return new ome(n,t,e)},deps:[Tb,gu,at]}],BG=[{provide:Ub,useFactory:()=>new class{validateStyleProperty(t){return!0}validateAnimatableStyleProperty(t){return!0}matchesElement(t,e){return!1}containsElement(t,e){return MG(t,e)}getParentElement(t){return Pk(t)}query(t,e,i){return wG(t,e,i)}computeStyle(t,e,i){return window.getComputedStyle(t)[e]}animate(t,e,i,r,o,s=[]){let l={duration:i,delay:r,fill:0==r?"both":"forwards"};o&&(l.easing=o);let c=new Map,d=s.filter(f=>f instanceof Bw);(function(n,t){return 0===n||0===t})(i,r)&&d.forEach(f=>{f.currentSnapshot.forEach((m,b)=>c.set(b,m))});let u=(n=e,n.length?n[0]instanceof Map?n:n.map(t=>TG(t)):[]).map(f=>bh(f));var n;u=function(n,t,e){if(e.size&&t.length){let i=t[0],r=[];if(e.forEach((o,s)=>{i.has(s)||r.push(s),i.set(s,o)}),r.length)for(let o=1;o<t.length;o++){let s=t[o];r.forEach(a=>s.set(a,AG(n,a)))}}return t}(t,u,c);let p=function(n,t){let e=null,i=null;return Array.isArray(t)&&t.length?(e=mk(t[0]),t.length>1&&(i=mk(t[t.length-1]))):t instanceof Map&&(e=mk(t)),e||i?new tme(n,e,i):null}(t,u);return new Bw(t,u,l,p)}}},{provide:hi,useValue:"BrowserAnimations"},...zG],ume=[{provide:Ub,useClass:Ok},{provide:hi,useValue:"NoopAnimations"},...zG],UG=(()=>{class n{static withConfig(e){return{ngModule:n,providers:e.disableAnimations?ume:BG}}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({providers:BG,imports:[Mw]}),n})(),Uk={};function _e(n,t){if(Uk[n]=(Uk[n]||0)+1,"function"==typeof t)return Vk(n,(...i)=>({...t(...i),type:n}));switch(t?t._as:"empty"){case"empty":return Vk(n,()=>({type:n}));case"props":return Vk(n,i=>({...i,type:n}));default:throw new Error("Unexpected config.")}}function Vk(n,t){return Object.defineProperty(t,"type",{value:n,writable:!1})}var r8="@ngrx/store/init",xh=(()=>{class n extends Ai{constructor(){super({type:r8})}next(e){if("function"==typeof e)throw new TypeError("\n        Dispatch expected an object, instead it received a function.\n        If you're using the createAction function, make sure to invoke the function\n        before dispatching the action. For example, someAction should be someAction().");if(typeof e>"u")throw new TypeError("Actions must be objects");if(typeof e.type>"u")throw new TypeError("Actions must have a type property");super.next(e)}complete(){}ngOnDestroy(){super.complete()}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),pme=[xh],o8=new ie("@ngrx/store Internal Root Guard"),jG=new ie("@ngrx/store Internal Initial State"),qk=new ie("@ngrx/store Initial State"),s8=new ie("@ngrx/store Reducer Factory"),GG=new ie("@ngrx/store Internal Reducer Factory Provider"),a8=new ie("@ngrx/store Initial Reducers"),Hk=new ie("@ngrx/store Internal Initial Reducers"),WG=new ie("@ngrx/store Store Features"),qG=new ie("@ngrx/store Internal Store Reducers"),zk=new ie("@ngrx/store Internal Feature Reducers"),YG=new ie("@ngrx/store Internal Feature Configs"),l8=new ie("@ngrx/store Internal Store Features"),XG=new ie("@ngrx/store Internal Feature Reducers Token"),c8=new ie("@ngrx/store Feature Reducers"),QG=new ie("@ngrx/store User Provided Meta Reducers"),yh=new ie("@ngrx/store Meta Reducers"),ZG=new ie("@ngrx/store Internal Resolved Meta Reducers"),KG=new ie("@ngrx/store User Runtime Checks Config"),JG=new ie("@ngrx/store Internal User Runtime Checks Config"),Gb=new ie("@ngrx/store Internal Runtime Checks"),Yk=new ie("@ngrx/store Check if Action types are unique");function rf(n,t={}){let e=Object.keys(n),i={};for(let o=0;o<e.length;o++){let s=e[o];"function"==typeof n[s]&&(i[s]=n[s])}let r=Object.keys(i);return function(s,a){s=void 0===s?t:s;let l=!1,c={};for(let d=0;d<r.length;d++){let u=r[d],f=s[u],m=(0,i[u])(f,a);c[u]=m,l=l||m!==f}return l?c:s}}function d8(...n){return function(t){if(0===n.length)return t;let e=n[n.length-1];return n.slice(0,-1).reduceRight((r,o)=>o(r),e(t))}}function u8(n,t){return Array.isArray(t)&&t.length>0&&(n=d8.apply(null,[...t,n])),(e,i)=>{let r=n(e);return(o,s)=>r(o=void 0===o?i:o,s)}}new ie("@ngrx/store Root Store Provider"),new ie("@ngrx/store Feature State Provider");var Wb=class extends Kt{},Uw=class extends xh{},jw=(()=>{class n extends Ai{constructor(e,i,r,o){super(o(r,i)),this.dispatcher=e,this.initialState=i,this.reducers=r,this.reducerFactory=o}get currentReducers(){return this.reducers}addFeature(e){this.addFeatures([e])}addFeatures(e){let i=e.reduce((r,{reducers:o,reducerFactory:s,metaReducers:a,initialState:l,key:c})=>{let d="function"==typeof o?function(n){let t=Array.isArray(n)&&n.length>0?d8(...n):e=>e;return(e,i)=>(e=t(e),(r,o)=>e(r=void 0===r?i:r,o))}(a)(o,l):u8(s,a)(o,l);return r[c]=d,r},{});this.addReducers(i)}removeFeature(e){this.removeFeatures([e])}removeFeatures(e){this.removeReducers(e.map(i=>i.key))}addReducer(e,i){this.addReducers({[e]:i})}addReducers(e){this.reducers={...this.reducers,...e},this.updateReducers(Object.keys(e))}removeReducer(e){this.removeReducers([e])}removeReducers(e){e.forEach(i=>{this.reducers=function(n,t){return Object.keys(n).filter(e=>e!==t).reduce((e,i)=>Object.assign(e,{[i]:n[i]}),{})}(this.reducers,i)}),this.updateReducers(e)}updateReducers(e){this.next(this.reducerFactory(this.reducers,this.initialState)),this.dispatcher.next({type:"@ngrx/store/update-reducers",features:e})}ngOnDestroy(){this.complete()}}return n.\u0275fac=function(e){return new(e||n)(k(Uw),k(qk),k(a8),k(s8))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),bme=[jw,{provide:Wb,useExisting:jw},{provide:Uw,useExisting:xh}],qb=(()=>{class n extends Ie{ngOnDestroy(){this.complete()}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),vme=[qb],Gw=class extends Kt{},$G=(()=>{class n extends Ai{constructor(e,i,r,o){super(o);let c=e.pipe(Pp(qA)).pipe(Bt(i)).pipe(function(n,t){return qt(function(n,t,e,i,r){return(o,s)=>{let a=e,l=t,c=0;o.subscribe(Vt(s,d=>{let u=c++;l=a?n(l,d,u):(a=!0,d),s.next(l)},void 0))}}(n,t,arguments.length>=2))}(yme,{state:o}));this.stateSubscription=c.subscribe(({state:d,action:u})=>{this.next(d),r.next(u)})}ngOnDestroy(){this.stateSubscription.unsubscribe(),this.complete()}}return n.INIT=r8,n.\u0275fac=function(e){return new(e||n)(k(xh),k(Wb),k(qb),k(qk))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})();function yme(n={state:void 0},[t,e]){let{state:i}=n;return{state:e(i,t),action:t}}var xme=[$G,{provide:Gw,useExisting:$G}],Ae=(()=>{class n extends Kt{constructor(e,i,r){super(),this.actionsObserver=i,this.reducerManager=r,this.source=e}select(e,...i){return un.call(null,e,...i)(this)}lift(e){let i=new n(this,this.actionsObserver,this.reducerManager);return i.operator=e,i}dispatch(e){this.actionsObserver.next(e)}next(e){this.actionsObserver.next(e)}error(e){this.actionsObserver.error(e)}complete(){this.actionsObserver.complete()}addReducer(e,i){this.reducerManager.addReducer(e,i)}removeReducer(e){this.reducerManager.removeReducer(e)}}return n.\u0275fac=function(e){return new(e||n)(k(Gw),k(xh),k(jw))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),Cme=[Ae];function un(n,t,...e){return function(r){let o;if("string"==typeof n){let s=[t,...e].filter(Boolean);o=r.pipe(function(...n){let t=n.length;if(0===t)throw new Error("list of properties cannot be empty.");return N(e=>{let i=e;for(let r=0;r<t;r++){let o=i?.[n[r]];if(!(typeof o<"u"))return;i=o}return i})}(n,...s))}else{if("function"!=typeof n)throw new TypeError(`Unexpected type '${typeof n}' in select operator, expected 'string' or 'function'`);o=r.pipe(N(s=>n(s,t)))}return o.pipe(Yn())}}var Xk="https://ngrx.io/guide/store/configuration/runtime-checks";function e8(n){return void 0===n}function t8(n){return null===n}function p8(n){return Array.isArray(n)}function f8(n){return"object"==typeof n&&null!==n}function jk(n){return"function"==typeof n}function n8(n,t){return n===t}function m8(n,t=n8,e=n8){let o,i=null,r=null;return{memoized:function(){if(void 0!==o)return o.result;if(!i)return r=n.apply(null,arguments),i=arguments,r;if(!function(n,t,e){for(let i=0;i<n.length;i++)if(!e(n[i],t[i]))return!0;return!1}(arguments,i,t))return r;let d=n.apply(null,arguments);return i=arguments,e(r,d)?r:(r=d,d)},reset:function(){i=null,r=null},setResult:function(d){o={result:d}},clearResult:function(){o=void 0}}}function q(...n){return function(n,t={stateFn:Ome}){return function(...e){let i=e;if(Array.isArray(i[0])){let[d,...u]=i;i=[...d,...u]}else 1===i.length&&function(n){return!!n&&"object"==typeof n&&Object.values(n).every(t=>"function"==typeof t)}(i[0])&&(i=function(n){let t=Object.values(n),e=Object.keys(n);return[...t,(...r)=>e.reduce((o,s,a)=>({...o,[s]:r[a]}),{})]}(i[0]));let r=i.slice(0,i.length-1),o=i[i.length-1],s=r.filter(d=>d.release&&"function"==typeof d.release),a=n(function(...d){return o.apply(null,d)}),l=m8(function(d,u){return t.stateFn.apply(null,[d,r,u,a])});return Object.assign(l.memoized,{release:function(){l.reset(),a.reset(),s.forEach(d=>d.release())},projector:a.memoized,setResult:l.setResult,clearResult:l.clearResult})}}(m8)(...n)}function Ome(n,t,e,i){if(void 0===e){let o=t.map(s=>s(n));return i.memoized.apply(null,o)}let r=t.map(o=>o(n,e));return i.memoized.apply(null,[...r,e])}function Er(n){return q(t=>t[n],t=>t)}function Lme(n){return n instanceof ie?ai(n):n}function Bme(n,t){return t.map((e,i)=>{if(n[i]instanceof ie){let r=ai(n[i]);return{key:e.key,reducerFactory:r.reducerFactory?r.reducerFactory:rf,metaReducers:r.metaReducers?r.metaReducers:[],initialState:r.initialState}}return e})}function Vme(n){return n.map(t=>t instanceof ie?ai(t):t)}function h8(n){return"function"==typeof n?n():n}function Hme(n,t){return n.concat(t)}function zme(){if(ai(Ae,{optional:!0,skipSelf:!0}))throw new TypeError("The root Store has been provided more than once. Feature modules should provide feature states instead.");return"guarded"}function Gk(n){Object.freeze(n);let t=jk(n);return Object.getOwnPropertyNames(n).forEach(e=>{if(!e.startsWith("\u0275")&&function(n,t){return Object.prototype.hasOwnProperty.call(n,t)}(n,e)&&(!t||"caller"!==e&&"callee"!==e&&"arguments"!==e)){let i=n[e];(f8(i)||jk(i))&&!Object.isFrozen(i)&&Gk(i)}}),n}function Wk(n,t=[]){return(e8(n)||t8(n))&&0===t.length?{path:["root"],value:n}:Object.keys(n).reduce((i,r)=>{if(i)return i;let o=n[r];return function(n){return jk(n)&&n.hasOwnProperty("\u0275cmp")}(o)?i:!(e8(o)||t8(o)||function(n){return"number"==typeof n}(o)||function(n){return"boolean"==typeof n}(o)||function(n){return"string"==typeof n}(o)||p8(o))&&(function(n){if(!function(n){return f8(n)&&!p8(n)}(n))return!1;let t=Object.getPrototypeOf(n);return t===Object.prototype||null===t}(o)?Wk(o,[...t,r]):{path:[...t,r],value:o})},!1)}function i8(n,t){if(!1===n)return;let e=n.path.join("."),i=new Error(`Detected unserializable ${t} at "${e}". ${Xk}#strict${t}serializability`);throw i.value=n.value,i.unserializablePath=e,i}function Wme(n){return{strictStateSerializability:!1,strictActionSerializability:!1,strictStateImmutability:!1,strictActionImmutability:!1,strictActionWithinNgZone:!1,strictActionTypeUniqueness:!1}}function qme({strictActionSerializability:n,strictStateSerializability:t}){return e=>n||t?function(n,t){return function(e,i){t.action(i)&&i8(Wk(i),"action");let r=n(e,i);return t.state()&&i8(Wk(r),"state"),r}}(e,{action:i=>n&&!Qk(i),state:()=>t}):e}function Yme({strictActionImmutability:n,strictStateImmutability:t}){return e=>n||t?function(n,t){return function(e,i){let r=t.action(i)?Gk(i):i,o=n(e,r);return t.state()?Gk(o):o}}(e,{action:i=>n&&!Qk(i),state:()=>t}):e}function Qk(n){return n.type.startsWith("@ngrx")}function Xme({strictActionWithinNgZone:n}){return t=>n?function(n,t){return function(e,i){if(t.action(i)&&!at.isInAngularZone())throw new Error(`Action '${i.type}' running outside NgZone. ${Xk}#strictactionwithinngzone`);return n(e,i)}}(t,{action:e=>n&&!Qk(e)}):t}function Qme(n){return[{provide:JG,useValue:n},{provide:KG,useFactory:Zme,deps:[JG]},{provide:Gb,deps:[KG],useFactory:Wme},{provide:yh,multi:!0,deps:[Gb],useFactory:Yme},{provide:yh,multi:!0,deps:[Gb],useFactory:qme},{provide:yh,multi:!0,deps:[Gb],useFactory:Xme}]}function g8(){return[{provide:Yk,multi:!0,deps:[Gb],useFactory:Kme}]}function Zme(n){return n}function Kme(n){if(!n.strictActionTypeUniqueness)return;let t=Object.entries(Uk).filter(([,e])=>e>1).map(([e])=>e);if(t.length)throw new Error(`Action types are registered more than once, ${t.map(e=>`"${e}"`).join(", ")}. ${Xk}#strictactiontypeuniqueness`)}function Jme(n={},t={}){return[{provide:o8,useFactory:zme},{provide:jG,useValue:t.initialState},{provide:qk,useFactory:h8,deps:[jG]},{provide:Hk,useValue:n},{provide:qG,useExisting:n instanceof ie?n:Hk},{provide:a8,deps:[Hk,[new nh(qG)]],useFactory:Lme},{provide:QG,useValue:t.metaReducers?t.metaReducers:[]},{provide:ZG,deps:[yh,QG],useFactory:Hme},{provide:GG,useValue:t.reducerFactory?t.reducerFactory:rf},{provide:s8,deps:[GG,ZG],useFactory:u8},pme,bme,vme,xme,Cme,Qme(t.runtimeChecks),g8()]}function $me(n,t,e={}){return[{provide:YG,multi:!0,useValue:n instanceof Object?{}:e},{provide:WG,multi:!0,useValue:{key:n instanceof Object?n.name:n,reducerFactory:e instanceof ie||!e.reducerFactory?rf:e.reducerFactory,metaReducers:e instanceof ie||!e.metaReducers?[]:e.metaReducers,initialState:e instanceof ie||!e.initialState?void 0:e.initialState}},{provide:l8,deps:[YG,WG],useFactory:Bme},{provide:zk,multi:!0,useValue:n instanceof Object?n.reducer:t},{provide:XG,multi:!0,useExisting:t instanceof ie?t:zk},{provide:c8,multi:!0,deps:[zk,[new nh(XG)]],useFactory:Vme},g8()]}var Yb=(()=>{class n{constructor(e,i,r,o,s,a){}}return n.\u0275fac=function(e){return new(e||n)(k(xh),k(Wb),k(qb),k(Ae),k(o8,8),k(Yk,8))},n.\u0275mod=G({type:n}),n.\u0275inj=U({}),n})(),Ww=(()=>{class n{constructor(e,i,r,o,s){this.features=e,this.featureReducers=i,this.reducerManager=r;let a=e.map((l,c)=>{let u=i.shift()[c];return{...l,reducers:u,initialState:h8(l.initialState)}});r.addFeatures(a)}ngOnDestroy(){this.reducerManager.removeFeatures(this.features)}}return n.\u0275fac=function(e){return new(e||n)(k(l8),k(c8),k(jw),k(Yb),k(Yk,8))},n.\u0275mod=G({type:n}),n.\u0275inj=U({}),n})(),Tr=(()=>{class n{static forRoot(e,i){return{ngModule:Yb,providers:[...Jme(e,i)]}}static forFeature(e,i,r={}){return{ngModule:Ww,providers:[...$me(e,i,r)]}}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({}),n})();function ye(...n){return{reducer:n.pop(),types:n.map(i=>i.type)}}function br(n,...t){let e=new Map;for(let i of t)for(let r of i.types){let o=e.get(r);e.set(r,o?(a,l)=>i.reducer(o(a,l),l):i.reducer)}return function(i=n,r){let o=e.get(r.type);return o?o(i,r):i}}var ehe={dispatch:!0,functional:!1,useEffectsErrorHandler:!0},Yw="__@ngrx/effects_create__";function ar(n,t={}){let e=t.functional?n:n(),i={...ehe,...t};return Object.defineProperty(e,Yw,{value:i}),e}function y8(n){return Object.getPrototypeOf(n)}function x8(n){return"function"==typeof n}function _8(n){return n.filter(x8)}function rhe(n,t,e){let i=y8(n).constructor.name,r=function(n){return function(n){return Object.getOwnPropertyNames(n).filter(i=>!(!n[i]||!n[i].hasOwnProperty(Yw))&&n[i][Yw].hasOwnProperty("dispatch")).map(i=>({propertyName:i,...n[i][Yw]}))}(n)}(n).map(({propertyName:o,dispatch:s,useEffectsErrorHandler:a})=>{let l="function"==typeof n[o]?n[o]():n[o],c=a?e(l,t):l;return!1===s?c.pipe(I_()):c.pipe(qt((n,t)=>{n.subscribe(Vt(t,e=>{t.next(wa.createNext(e))},()=>{t.next(wa.createComplete()),t.complete()},e=>{t.next(wa.createError(e)),t.complete()}))})).pipe(N(u=>({effect:n[o],notification:u,propertyName:o,sourceName:i,sourceInstance:n})))});return tn(...r)}var ohe=10;function C8(n,t,e=ohe){return n.pipe(zr(i=>(t&&t.handleError(i),e<=1?n:C8(n,t,e-1))))}var xo=(()=>{class n extends Kt{constructor(e){super(),e&&(this.source=e)}lift(e){let i=new n;return i.source=this,i.operator=e,i}}return n.\u0275fac=function(e){return new(e||n)(k(qb))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})();function ei(...n){return ke(t=>n.some(e=>"string"==typeof e?e===t.type:e.type===t.type))}var M8=new ie("@ngrx/effects Internal Root Guard"),qw=new ie("@ngrx/effects User Provided Effects"),Zk=new ie("@ngrx/effects Internal Root Effects"),w8=new ie("@ngrx/effects Internal Root Effects Instances"),b8=new ie("@ngrx/effects Internal Feature Effects"),S8=new ie("@ngrx/effects Internal Feature Effects Instance Groups"),she=new ie("@ngrx/effects Effects Error Handler",{providedIn:"root",factory:()=>C8}),E8="@ngrx/effects/init";_e(E8);var uhe="ngrxOnIdentifyEffects",hhe="ngrxOnInitEffects";function ghe(n){return Kk(n,hhe)}function Kk(n,t){return n&&t in n&&"function"==typeof n[t]}var T8=(()=>{class n extends Ie{constructor(e,i){super(),this.errorHandler=e,this.effectsErrorHandler=i}addEffects(e){this.next(e)}toActions(){return this.pipe(LC(e=>function(n){return"Object"!==n.constructor.name&&"Function"!==n.constructor.name}(e)?y8(e):e),hn(e=>e.pipe(LC(_he))),hn(e=>{let i=e.pipe(FC(o=>function(n,t){return e=>{let i=rhe(e,n,t);return function(n){return Kk(n,"ngrxOnRunEffects")}(e)?e.ngrxOnRunEffects(i):i}}(this.errorHandler,this.effectsErrorHandler)(o)),N(o=>(function(n,t){if("N"===n.notification.kind){let e=n.notification.value;!function(n){return"function"!=typeof n&&n&&n.type&&"string"==typeof n.type}(e)&&t.handleError(new Error(`Effect ${function({propertyName:n,sourceInstance:t,sourceName:e}){let i="function"==typeof t[n];return`"${e}.${String(n)}${i?"()":""}"`}(n)} dispatched an invalid action: ${function(n){try{return JSON.stringify(n)}catch{return n}}(e)}`))}}(o,this.errorHandler),o.notification)),ke(o=>"N"===o.kind&&null!=o.value),qt((n,t)=>{n.subscribe(Vt(t,e=>ZA(e,t)))}));return tn(i,e.pipe(Yt(1),ke(ghe),N(o=>o.ngrxOnInitEffects())))}))}}return n.\u0275fac=function(e){return new(e||n)(k(rs),k(she))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})();function _he(n){return function(n){return Kk(n,uhe)}(n)?n.ngrxOnIdentifyEffects():""}var D8=(()=>{class n{constructor(e,i){this.effectSources=e,this.store=i,this.effectsSubscription=null}get isStarted(){return!!this.effectsSubscription}start(){this.effectsSubscription||(this.effectsSubscription=this.effectSources.toActions().subscribe(this.store))}ngOnDestroy(){this.effectsSubscription&&(this.effectsSubscription.unsubscribe(),this.effectsSubscription=null)}}return n.\u0275fac=function(e){return new(e||n)(k(T8),k(Ae))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),I8=(()=>{class n{constructor(e,i,r,o,s,a,l){this.sources=e,i.start();for(let c of o)e.addEffects(c);r.dispatch({type:E8})}addEffects(e){this.sources.addEffects(e)}}return n.\u0275fac=function(e){return new(e||n)(k(T8),k(D8),k(Ae),k(w8),k(Yb,8),k(Ww,8),k(M8,8))},n.\u0275mod=G({type:n}),n.\u0275inj=U({}),n})(),vhe=(()=>{class n{constructor(e,i,r,o){let s=i.flat();for(let a of s)e.addEffects(a)}}return n.\u0275fac=function(e){return new(e||n)(k(I8),k(S8),k(Yb,8),k(Ww,8))},n.\u0275mod=G({type:n}),n.\u0275inj=U({}),n})(),to=(()=>{class n{static forFeature(...e){let i=e.flat(),r=_8(i);return{ngModule:vhe,providers:[r,{provide:b8,multi:!0,useValue:i},{provide:qw,multi:!0,useValue:[]},{provide:S8,multi:!0,useFactory:v8,deps:[b8,qw]}]}}static forRoot(...e){let i=e.flat(),r=_8(i);return{ngModule:I8,providers:[r,{provide:Zk,useValue:[i]},{provide:M8,useFactory:yhe},{provide:qw,multi:!0,useValue:[]},{provide:w8,useFactory:v8,deps:[Zk,qw]}]}}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({}),n})();function v8(n,t){let e=[];for(let i of n)e.push(...i);for(let i of t)e.push(...i);return e.map(i=>x8(i)?ai(i):i)}function yhe(){let n=ai(D8,{optional:!0,skipSelf:!0}),t=ai(Zk,{self:!0});if((1!==t.length||0!==t[0].length)&&n)throw new TypeError("EffectsModule.forRoot() called twice. Feature modules should use EffectsModule.forFeature() instead.");return"guarded"}var wn=(()=>{return(n=wn||(wn={}))[n.UNKNOWN=0]="UNKNOWN",n[n.EXPERIMENTS=1]="EXPERIMENTS",n[n.EXPERIMENT=2]="EXPERIMENT",n[n.COMPARE_EXPERIMENT=3]="COMPARE_EXPERIMENT",n[n.CARD=4]="CARD",n[n.NOT_SET=5]="NOT_SET",wn;var n})(),Xw="defaultExperimentId",Ch=(()=>{return(n=Ch||(Ch={}))[n.EXPERIMENTS=0]="EXPERIMENTS",n[n.DASHBOARD=1]="DASHBOARD",Ch;var n})();function Mh(n){return n.split(",").map(t=>{let e=t.indexOf(":");if(e<0)throw new Error(`Expect colon delimiting name and ID: ${t}`);let i=t.slice(0,e),r=t.slice(e+1);if(!r)throw new Error(`Expect id to be non-falsy: ${t}`);return{name:i,id:r}})}function A8(n){return n.map(({alias:t,id:e})=>`${t}:${e}`).join(",")}function Xb(n,t){switch(n){case wn.EXPERIMENT:return Object.prototype.hasOwnProperty.call(t,"experimentId")?[t.experimentId]:[Xw];case wn.CARD:{let e=t.experimentIds;return e.indexOf(",")<0?[e]:Mh(e).map(({id:i})=>i)}case wn.COMPARE_EXPERIMENT:return Mh(t.experimentIds).map(({id:i})=>i);default:return null}}function Fo(n,t){if(!n||!t)return n===t;if(n.routeKind!==t.routeKind)return!1;let e=Xb(n.routeKind,n.params),i=Xb(t.routeKind,t.params);if(null===e||null===i)return e===i;if(e.length!==i.length)return!1;let r=i.sort();return e.sort().every((o,s)=>r[s]===o)}function Jk(n){switch(n){case wn.EXPERIMENTS:return Ch.EXPERIMENTS;case wn.EXPERIMENT:case wn.CARD:case wn.COMPARE_EXPERIMENT:return Ch.DASHBOARD;case wn.UNKNOWN:case wn.NOT_SET:return null}}function Qw(n,t,e){let i=Jk(n);return null!==i&&!e.some(r=>r.deepLinkGroup===i&&r.namespaceId===t)}var k8_getHref=()=>window.location.href,of=(()=>{class n{getHref(){return k8_getHref()}getSearch(){let e=new URLSearchParams(window.location.search),i=[];return e.forEach((r,o)=>{i.push({key:o,value:r})}),i}getHash(){return window.location.hash}getPath(){return window.location.pathname}getHistoryState(){return window.history.state}replaceStateUrl(e){window.history.replaceState(window.history.state,"",e)}pushStateUrl(e){window.history.pushState(null,"",e)}replaceStateData(e){window.history.replaceState(e,"")}onPopState(){return mi(window,"popstate").pipe(N(e=>({pathname:this.getPath(),state:e.state})))}getResolvedPath(e){return new URL(e,k8_getHref()).pathname}getFullPath(e,i,r){let o=this.getResolvedPath(e),s="";return i.length&&(s="?"+function(n){let t=new URLSearchParams;for(let{key:e,value:i}of n)t.append(e,i);return t}(i).toString()),`${o}${s}${r?this.getHash():""}`}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),sf=(()=>{class n{constructor(e){this.appRoot=this.getAppRootFromMetaElement(e)}getAppRootFromMetaElement(e){let i=document.querySelector('head meta[name="tb-relative-root"]');if(!i)return"/";let{pathname:r}=new URL(i.content,e.getHref());return r.replace(/\/*$/,"/")}getAbsPathnameWithAppRoot(e){return this.appRoot.slice(0,-1)+e}getAppRootlessPathname(e){return e.startsWith(this.appRoot)?"/"+e.slice(this.appRoot.length):e}}return n.\u0275fac=function(e){return new(e||n)(k(of))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),wh=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({providers:[of]}),n})(),Sh=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({providers:[sf],imports:[wh]}),n})(),tF=new ie("[App Routing] Dirty Updates"),Zw=(()=>{class n{constructor(e){this.dirtyUpdatesSelectorFactories=e}getDirtyUpdatesSelectors(){return this.dirtyUpdatesSelectorFactories??[]}static registerDirtyUpdates(e){return{ngModule:n,providers:[{provide:tF,multi:!0,useFactory:e}]}}}return n.\u0275fac=function(e){return new(e||n)(k(tF,8))},n.\u0275mod=G({type:n}),n.\u0275inj=U({}),n})(),F8=_e("[App Routing] Discarding Unsaved Updates"),Eh=_e("[App Routing] State Rehydrated From Url",{_as:"props",_p:void 0}),Kw=_e("[App Routing] Route Config Loaded",{_as:"props",_p:void 0}),nF=_e("[App Routing] In App Navigation Requested",{_as:"props",_p:void 0}),Th=_e("[App Routing] In App Navigating",{_as:"props",_p:void 0}),Ps=_e("[App Routing] In App Navigated",{_as:"props",_p:void 0}),rF=new ie("[App Routing] Programmatical Navigation Provider"),Jw=(()=>{class n{constructor(e){this.providers=new Map;for(let i of e||[]){if(this.providers.has(i.actionCreator.type))throw new RangeError(`"${i.actionCreator.type}" is already registered for nav. Multiple navigations on same kick is not allowed.`);this.providers.set(i.actionCreator.type,i.lambda)}}getNavigation(e){let i=this.providers.get(e.type);return i?i(e):null}static registerProgrammaticalNavigation(e){return{ngModule:n,providers:[{provide:rF,multi:!0,useFactory:e}]}}}return n.\u0275fac=function(e){return new(e||n)(k(rF,8))},n.\u0275mod=G({type:n}),n.\u0275inj=U({}),n})();function Qb(n){return null!=n.routeKind}function aF(n){return B8(n).map(e=>{let i=e.startsWith(":");return i?{pathPart:e,isParam:!0,paramName:e.slice(1)}:{pathPart:e,isParam:i}})}var Dh=class{static getMatcher(t){return Qb(t)?new Zb(t):void 0!==t.redirectionPath?new oF(t):new sF(t)}constructor(t){this.validateConfig(t),this.pathFragments=aF(t.path),this.pathMatchers=this.getPathMatchers(this.pathFragments)}validateConfig({path:t}){if(!t.startsWith("/"))throw new RangeError(`config.path should start with '/'. ${t}`);let e=0;for(;(e=t.indexOf(":",e+1))>=0;){if("/"!==t[e-1])throw new RangeError(`config.path parameter should come after '/'. ${t}`);if(void 0===t[e+1]||"/"===t[e+1])throw new RangeError(`config.path parameter should have non-empty name. ${t}`)}}getPathMatchers(t){return t.map(e=>{let{pathPart:i}=e;return e.isParam?r=>({isParamPathPart:!0,partMatched:!0,paramName:e.paramName,paramValue:r}):r=>({isParamPathPart:!1,partMatched:r===i})})}match(t){let e={};if(this.pathMatchers.length!==t.length)return{result:!1};let i=0;for(let r of this.pathMatchers){let s=r(t[i++]);if(!s.partMatched)return{result:!1};s.isParamPathPart&&(e={...e,[s.paramName]:s.paramValue})}return{result:!0,params:e,pathParts:t,isRedirection:!1,redirectionQueryParams:void 0}}matchByParams(t){return{result:!0,params:t,pathParts:this.reprojectPathByParams(this.pathFragments,t),isRedirection:!1,redirectionQueryParams:void 0}}reprojectPathByParams(t,e){let i=[];for(let r of t)if(r.isParam){let{paramName:o}=r;if(!e.hasOwnProperty(o))throw new RangeError(`Failed to reproject parameter. "${o}" parameter should be present.`);i.push(e[o])}else i.push(r.pathPart);return i}},Zb=class extends Dh{constructor(t){super(t),this.definition=t}},oF=class extends Dh{constructor(t){super(t),this.definition=t,this.redirectionFragments=aF(t.redirectionPath)}match(t){let e=super.match(t);if(!e.result)return e;let i=this.reprojectPathByParams(this.redirectionFragments,e.params);return{result:!0,params:e.params,pathParts:i,isRedirection:!0,redirectionQueryParams:void 0}}},sF=class extends Dh{constructor(t){super(t),this.definition=t}match(t){let e=super.match(t);if(!e.result)return e;let{pathParts:i,queryParams:r}=this.definition.redirector(t);return{result:!0,params:e.params,pathParts:i,isRedirection:!0,redirectionQueryParams:r}}},Kb=class{constructor(t,e=3){if(this.maxRedirection=e,e<0)throw new RangeError("maxRedirection has to be non-negative number");this.validateRouteConfigs(t),this.defaultRouteConfig=null,this.routeKindToConcreteConfigMatchers=new Map,this.configMatchers=[];for(let i of t){let r=Dh.getMatcher(i);this.configMatchers.push(r),r instanceof Zb&&(this.routeKindToConcreteConfigMatchers.set(r.definition.routeKind,r),r.definition.defaultRoute&&(this.defaultRouteConfig=r))}}validateRouteConfigs(t){let e=t.filter(Qb),i=e.filter(o=>o.defaultRoute);if(i.length>1){let o=i.map(({path:s})=>s).join(", ");throw new RangeError(`There are more than one defaultRoutes. ${o}`)}if(1===i.length){let{path:o}=i[0];if(Boolean(aF(o).find(({isParam:a})=>a)))throw new RangeError(`A defaultRoute cannot have any params. ${o}`)}let r=new Set;for(let{routeKind:o}of e){if(r.has(o))throw new RangeError(`Multiple route configuration for kind: ${o}. Configurations should have unique routeKinds`);r.add(o)}}generateAction(t,e){return t.actionGenerator?t.actionGenerator(e):null}match(t){if(!t.pathname.startsWith("/"))throw new RangeError('Navigation has to made with pathname that starts with "/"');let o,e=B8(t.pathname),i=0,r=!1;for(;;){let s=!1;for(let a of this.configMatchers){let l=a.match(e);if(l.result){s=!0;let{params:c,pathParts:d,isRedirection:u}=l;if(u){e=d,r=!0,o=l.redirectionQueryParams;break}if(!(a instanceof Zb))throw new RangeError("No concrete route definition `match` return redirection");let{definition:p}=a,f={routeKind:p.routeKind,params:c,pathname:L8(d),deepLinkProvider:p.deepLinkProvider||null,action:this.generateAction(p,d)};return r?{...f,originateFromRedirection:!0,redirectionOnlyQueryParams:o}:{...f,originateFromRedirection:!1}}}if(r&&i++,!s||i>this.maxRedirection)break}if(i>this.maxRedirection)throw new Error(`Potential redirection loop (redirecting more than ${this.maxRedirection} times. Please do not have cycles in the routes.`);if(this.defaultRouteConfig){let{definition:s}=this.defaultRouteConfig;return{routeKind:s.routeKind,deepLinkProvider:s.deepLinkProvider??null,pathname:s.path,params:{},originateFromRedirection:!0,redirectionOnlyQueryParams:void 0,action:this.generateAction(s,e)}}return null}matchByRouteKind(t,e){let i=this.routeKindToConcreteConfigMatchers.get(t);if(!i)throw new RangeError(`Requires configuration for routeKind: ${t}`);let r=i.matchByParams(e);return{routeKind:t,params:e,pathname:L8(r.pathParts),deepLinkProvider:i.definition.deepLinkProvider||null,originateFromRedirection:!1,action:this.generateAction(i.definition,r.pathParts)}}};function B8(n){return n.split("/").slice(1)}function L8(n){return"/"+n.join("/")}var lF=new ie("[App Routing] Route Config"),Dl=(()=>{class n{constructor(e){if(this.routeKindToNgComponent=new Map,!e)return void(this.routeConfigs=new Kb([]));let i=[];for(let r of e)for(let o of r)i.push(o);this.routeConfigs=new Kb(i),i.forEach(r=>{Qb(r)&&this.routeKindToNgComponent.set(r.routeKind,r.ngComponent)})}getRegisteredRouteKinds(){return this.routeKindToNgComponent.keys()}getRouteConfigs(){return this.routeConfigs}getNgComponentByRouteKind(e){return this.routeKindToNgComponent.get(e)||null}static registerRoutes(e){return{ngModule:n,providers:[{provide:lF,multi:!0,useFactory:e}]}}}return n.\u0275fac=function(e){return new(e||n)(k(lF,8))},n.\u0275mod=G({type:n}),n.\u0275inj=U({}),n})(),$w="app_routing",Jb=Er($w),No=q(Jb,n=>n.activeRoute),z8=q(Jb,n=>n.nextRoute),U8=q(Jb,n=>n.activeNamespaceId),j8=q(Jb,n=>n.rehydratedDeepLinks),G8=q(Jb,n=>n.registeredRouteKeys),Ha=q(No,n=>n?n.routeKind:wn.NOT_SET),dF=q(No,n=>n?n.params:{}),lr=q(Ha,dF,(n,t)=>Xb(n,t)),za=(q(Ha,dF,(n,t)=>{if(n!==wn.COMPARE_EXPERIMENT)return{};let i=function(n){let t=new Map,e=Mh(n.experimentIds);for(let{id:i,name:r}of e)r&&t.set(i,r);return t}(t);return Object.fromEntries(i.entries())}),q(Ha,dF,(n,t)=>{let e=t;if(n!==wn.COMPARE_EXPERIMENT&&(n!==wn.CARD||-1===e.experimentIds.indexOf(",")))return{};let i=function(n){let t=new Map,e=Mh(n.experimentIds),i=0;for(let{id:r,name:o}of e)i++,!t.has(r)&&t.set(r,{aliasText:o,aliasNumber:i});return t}(e);return Object.fromEntries(i.entries())})),uF=_e("[App Routing] Effects Init"),ls=(()=>{return(n=ls||(ls={}))[n.UNCHANGED=0]="UNCHANGED",n[n.NEW=1]="NEW",n[n.FROM_HISTORY=2]="FROM_HISTORY",ls;var n})(),W8=(()=>{class n{constructor(e,i,r,o,s,a,l){this.actions$=e,this.store=i,this.location=r,this.dirtyUpdatesRegistry=o,this.registry=s,this.programmaticalNavModule=a,this.appRootProvider=l,this.onNavigationRequested$=this.actions$.pipe(ei(nF),N(c=>({pathname:c.pathname.startsWith("/")?this.appRootProvider.getAbsPathnameWithAppRoot(c.pathname):this.location.getResolvedPath(c.pathname),options:{browserInitiated:!1,replaceState:c.replaceState??!1,namespaceUpdate:{option:c.resetNamespacedState?ls.NEW:ls.UNCHANGED}}}))),this.bootstrapReducers$=ar(()=>this.actions$.pipe(ei(uF),N(()=>Kw({routeKinds:new Set(this.registry.getRegisteredRouteKinds())})))),this.onInit$=this.actions$.pipe(ei(uF)).pipe(Sa(0),N(()=>{let c=this.location.getHistoryState()?.namespaceId,d=void 0===c?{option:ls.NEW}:{option:ls.FROM_HISTORY,namespaceId:c};return{pathname:this.location.getPath(),options:{browserInitiated:!0,replaceState:!0,namespaceUpdate:d}}})),this.onPopState$=this.location.onPopState().pipe(N(c=>({pathname:c.pathname,options:{browserInitiated:!0,replaceState:!0,namespaceUpdate:void 0===c.state?.namespaceId?{option:ls.UNCHANGED}:{option:ls.FROM_HISTORY,namespaceId:c.state.namespaceId}}}))),this.userInitNavRoute$=tn(this.onNavigationRequested$,this.onInit$,this.onPopState$).pipe(N(c=>{if(!c.pathname.startsWith("/"))throw new Error(`[App routing] pathname must start with '/'. Got: ${c.pathname}`);return{...c,pathname:this.appRootProvider.getAppRootlessPathname(c.pathname)}}),N(c=>({routeMatch:this.routeConfigs.match(c),options:c.options}))),this.programmaticalNavRoute$=this.actions$.pipe(N(c=>this.programmaticalNavModule.getNavigation(c)),ke(c=>null!==c),N(c=>{let m,d=c,{replaceState:u=!1,resetNamespacedState:p,routeKind:f}=d;return m=d.routeKind===wn.COMPARE_EXPERIMENT?{experimentIds:A8(d.routeParams.aliasAndExperimentIds)}:d.routeParams,{replaceState:u,routeKind:f,routeParams:m,resetNamespacedState:p}}),N(({replaceState:c,routeKind:d,routeParams:u,resetNamespacedState:p})=>({routeMatch:this.routeConfigs?this.routeConfigs.matchByRouteKind(d,u):null,options:{replaceState:c,browserInitiated:!1,namespaceUpdate:{option:p?ls.NEW:ls.UNCHANGED}}}))),this.validatedRouteMatch$=tn(this.userInitNavRoute$,this.programmaticalNavRoute$).pipe(ke(({routeMatch:c})=>Boolean(c)),N(({routeMatch:c,options:d})=>({routeMatch:c,options:d}))),this.navigate$=ar(()=>this.validatedRouteMatch$.pipe(Bt(this.store.select(No)),hn(([u,p])=>{let f=null!==p&&Fo(p,u.routeMatch),m=this.dirtyUpdatesRegistry.getDirtyUpdatesSelectors();return f||!m.length?Ht(u):co(this.dirtyUpdatesRegistry.getDirtyUpdatesSelectors().map(b=>this.store.select(b).pipe(Yt(1)))).pipe(N(b=>void 0!==b[0].experimentIds&&b[0].experimentIds.length>0),ke(b=>{if(b){let M=window.confirm("You have unsaved edits, are you sure you want to discard them?");return M&&this.store.dispatch(F8()),M}return!0}),N(()=>u))}),Bt(this.store.select(j8)),Nt(([{routeMatch:u,options:p},f])=>{if(!p.browserInitiated||!u.deepLinkProvider||p.namespaceUpdate.option===ls.FROM_HISTORY&&!Qw(u.routeKind,p.namespaceUpdate.namespaceId,f))return;let m=u.originateFromRedirection&&u.redirectionOnlyQueryParams?u.redirectionOnlyQueryParams:this.location.getSearch(),b=u.deepLinkProvider.deserializeQueryParams(m);this.store.dispatch(Eh({routeKind:u.routeKind,partialState:b}))}),Nt(([{routeMatch:u}])=>{u.action&&this.store.dispatch(u.action)}),Jn(([{routeMatch:u,options:p}])=>null===u.deepLinkProvider?Ht({route:{routeKind:u.routeKind,params:u.params},pathname:u.pathname,queryParams:[],options:p}):u.deepLinkProvider.serializeStateToQueryParams(this.store).pipe(N((f,m)=>({route:{routeKind:u.routeKind,params:u.params},pathname:u.pathname,queryParams:f,options:0===m?p:{...p,namespaceUpdate:{option:ls.UNCHANGED},replaceState:!0}})))),Nt(({route:u})=>{this.store.dispatch(Th({after:u}))}),wr(0)).pipe(Bt(this.store.select(No)),N(([u,p])=>{let f=null===p||null===u.route||Fo(p,u.route);return{...u,preserveHash:f}}),Nt(({preserveHash:u,pathname:p,queryParams:f,options:m})=>{(function(n,t){return n.pathname===t.pathname&&n.queryParams.length===t.queryParams.length&&n.queryParams.every((e,i)=>{let r=t.queryParams[i];return e.key===r.key&&e.value===r.value})})({pathname:p,queryParams:f},{pathname:this.appRootProvider.getAppRootlessPathname(this.location.getPath()),queryParams:this.location.getSearch()})||(m.replaceState?this.location.replaceStateUrl(this.appRootProvider.getAbsPathnameWithAppRoot(this.location.getFullPath(p,f,u))):this.location.pushStateUrl(this.appRootProvider.getAbsPathnameWithAppRoot(this.location.getFullPath(p,f,u))))})).pipe(Bt(this.store.select(No),this.store.select(U8)),N(([{route:u,options:p},f,m])=>{let b=function(n,t,e){return t.namespaceUpdate.option===ls.FROM_HISTORY?t.namespaceUpdate.namespaceId:null==e||t.namespaceUpdate.option===ls.NEW?`${Date.now().toString()}:${function(){let n=new Uint8Array(32);crypto.getRandomValues(n);let t="";for(let e of n)t+=(e>>4).toString(16);return t}()}`:e}(0,p,m);return this.location.replaceStateData({...this.location.getHistoryState(),namespaceId:b}),Ps({before:f,after:u,beforeNamespaceId:m,afterNamespaceId:b})}))),this.routeConfigs=s.getRouteConfigs()}ngrxOnInitEffects(){return uF()}}return n.\u0275fac=function(e){return new(e||n)(k(xo),k(Ae),k(of),k(Zw),k(Dl),k(Jw),k(sf))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),She=br({activeRoute:null,nextRoute:null,activeNamespaceId:null,rehydratedDeepLinks:[],registeredRouteKeys:new Set},ye(Th,(n,{after:t})=>({...n,nextRoute:t})),ye(Ps,(n,{after:t,afterNamespaceId:e})=>{let i=n.rehydratedDeepLinks;return Qw(t.routeKind,e,i)&&(i=[...i],i.push({deepLinkGroup:Jk(t.routeKind),namespaceId:e})),{...n,activeRoute:t,nextRoute:null,activeNamespaceId:e,rehydratedDeepLinks:i}}),ye(Kw,(n,{routeKinds:t})=>({...n,registeredRouteKeys:t})));function q8(n,t){return She(n,t)}var Ih=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({providers:[Zw,Jw],imports:[Dl,Tr.forFeature($w,q8),to.forFeature([W8]),Sh,wh]}),n})(),Y8="__tab__",X8=(()=>{class n{constructor(){this.tfStorage=document.createElement("tf-storage"),document.createElement("tf-globals").tf_globals.setUseHash(!0),this.tfStorage.tf_storage.migrateLegacyURLScheme()}getString(e){return this.tfStorage.tf_storage.getString(e)}setString(e,i,r){this.tfStorage.tf_storage.setString(e,i,r)}getPluginId(){return this.getString(Y8)}setPluginId(e,i){this.setString(Y8,e,i)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),_u=class{},Os=(()=>{return(n=Os||(Os={})).BROWSER_DEFAULT="browser_default",n.LIGHT="light",n.DARK="dark",Os;var n})(),Il=_e("[Persistent Settings] Global Settings Loaded",{_as:"props",_p:void 0}),pF=new ie("[Persistent Settings] Global Settings"),Ki=(()=>{class n{constructor(e){this.globalSettingSelectors=[],e&&(this.globalSettingSelectors=e.map(i=>i()))}getGlobalSettingSelectors(){return this.globalSettingSelectors??[]}static defineGlobalSetting(e){return{ngModule:n,providers:[{provide:pF,multi:!0,useValue:e}]}}}return n.\u0275fac=function(e){return new(e||n)(k(pF,8))},n.\u0275mod=G({type:n}),n.\u0275inj=U({}),n})(),Q8="_tb_global_settings.timeseries",Z8="_tb_global_settings",K8="notificationLastReadTimestamp",eS=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),tS=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),fF=(()=>{class n extends tS{uiToBackend(e){let i={};return void 0!==e.ignoreOutliers&&(i.ignoreOutliers=e.ignoreOutliers),void 0!==e.scalarSmoothing&&(i.scalarSmoothing=e.scalarSmoothing),void 0!==e.tooltipSort&&(i.tooltipSort=e.tooltipSort),void 0!==e.autoReload&&(i.autoReload=e.autoReload),void 0!==e.autoReloadPeriodInMs&&(i.autoReloadPeriodInMs=e.autoReloadPeriodInMs),void 0!==e.pageSize&&(i.paginationSize=e.pageSize),void 0!==e.themeOverride&&(i.theme=e.themeOverride),void 0!==e.notificationLastReadTimeInMs&&(i.notificationLastReadTimeInMs=e.notificationLastReadTimeInMs),void 0!==e.sideBarWidthInPercent&&(i.sideBarWidthInPercent=e.sideBarWidthInPercent),void 0!==e.timeSeriesSettingsPaneOpened&&(i.timeSeriesSettingsPaneOpened=e.timeSeriesSettingsPaneOpened),void 0!==e.timeSeriesCardMinWidth&&(i.timeSeriesCardMinWidth=e.timeSeriesCardMinWidth),void 0!==e.stepSelectorEnabled&&(i.stepSelectorEnabled=e.stepSelectorEnabled),void 0!==e.rangeSelectionEnabled&&(i.rangeSelectionEnabled=e.rangeSelectionEnabled),void 0!==e.linkedTimeEnabled&&(i.linkedTimeEnabled=e.linkedTimeEnabled),void 0!==e.singleSelectionHeaders&&(i.singleSelectionHeaders=e.singleSelectionHeaders),void 0!==e.rangeSelectionHeaders&&(i.rangeSelectionHeaders=e.rangeSelectionHeaders),i}backendToUi(e){let i={};return e.hasOwnProperty("scalarSmoothing")&&"number"==typeof e.scalarSmoothing&&(i.scalarSmoothing=e.scalarSmoothing),e.hasOwnProperty("ignoreOutliers")&&"boolean"==typeof e.ignoreOutliers&&(i.ignoreOutliers=e.ignoreOutliers),e.hasOwnProperty("tooltipSort")&&"string"==typeof e.tooltipSort&&(i.tooltipSort=e.tooltipSort),e.hasOwnProperty("autoReload")&&"boolean"==typeof e.autoReload&&(i.autoReload=e.autoReload),e.hasOwnProperty("autoReloadPeriodInMs")&&"number"==typeof e.autoReloadPeriodInMs&&(i.autoReloadPeriodInMs=e.autoReloadPeriodInMs),e.hasOwnProperty("paginationSize")&&"number"==typeof e.paginationSize&&(i.pageSize=e.paginationSize),e.hasOwnProperty("theme")&&"string"==typeof e.theme&&new Set(Object.values(Os)).has(e.theme)&&(i.themeOverride=e.theme),e.hasOwnProperty("notificationLastReadTimeInMs")&&"number"==typeof e.notificationLastReadTimeInMs&&(i.notificationLastReadTimeInMs=e.notificationLastReadTimeInMs),e.hasOwnProperty("sideBarWidthInPercent")&&"number"==typeof e.sideBarWidthInPercent&&(i.sideBarWidthInPercent=e.sideBarWidthInPercent),e.hasOwnProperty("timeSeriesSettingsPaneOpened")&&"boolean"==typeof e.timeSeriesSettingsPaneOpened&&(i.timeSeriesSettingsPaneOpened=e.timeSeriesSettingsPaneOpened),e.hasOwnProperty("timeSeriesCardMinWidth")&&"number"==typeof e.timeSeriesCardMinWidth&&(i.timeSeriesCardMinWidth=e.timeSeriesCardMinWidth),e.hasOwnProperty("stepSelectorEnabled")&&"boolean"==typeof e.stepSelectorEnabled&&(i.stepSelectorEnabled=e.stepSelectorEnabled),e.hasOwnProperty("rangeSelectionEnabled")&&"boolean"==typeof e.rangeSelectionEnabled&&(i.rangeSelectionEnabled=e.rangeSelectionEnabled),e.hasOwnProperty("linkedTimeEnabled")&&"boolean"==typeof e.linkedTimeEnabled&&(i.linkedTimeEnabled=e.linkedTimeEnabled),Array.isArray(e.singleSelectionHeaders)&&void 0!==e.singleSelectionHeaders[0].name&&(e.singleSelectionHeaders.forEach(r=>{r.movable=r.movable??!0,r.sortable=r.sortable??!0,r.removable=r.removable??!0}),i.singleSelectionHeaders=e.singleSelectionHeaders),Array.isArray(e.rangeSelectionHeaders)&&void 0!==e.rangeSelectionHeaders[0].name&&(e.rangeSelectionHeaders.forEach(r=>{r.movable=r.movable??!0,r.sortable=r.sortable??!0,r.removable=r.removable??!0}),i.rangeSelectionHeaders=e.rangeSelectionHeaders),i}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),J8=(()=>{class n{constructor(e){this.converter=e}setSettings(e){return Object.keys(e)?this.getSettings().pipe(Nt(i=>{window.localStorage.setItem(Z8,JSON.stringify(this.converter.uiToBackend({...i,...e}))),window.localStorage.removeItem(Q8),window.localStorage.removeItem(K8)}),N(()=>{})):Jr}deserialize(e){try{return JSON.parse(e)}catch{return{}}}getSettings(){let e=window.localStorage.getItem(K8);return Ht({...this.converter.backendToUi(this.deserialize(e?JSON.stringify({notificationLastReadTimeInMs:Number(e)}):"{}")),...this.converter.backendToUi(this.deserialize(window.localStorage.getItem(Q8)??"{}")),...this.converter.backendToUi(this.deserialize(window.localStorage.getItem(Z8)??"{}"))})}}return n.\u0275fac=function(e){return new(e||n)(k(tS))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),$8=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({providers:[{provide:eS,useClass:J8},fF,{provide:tS,useExisting:fF}]}),n})(),nS="persistent_settings",e6=q(Er(nS),n=>n.shouldPersistSettings),t6=(()=>{class n{constructor(e,i,r,o){this.actions$=e,this.store=i,this.configModule=r,this.dataSource=o,this.initializeAndUpdateSettings$=ar(()=>{let s=this.actions$.pipe(ei(Th),Yt(1),Bt(this.store.select(e6)),ke(([,a])=>a),hn(()=>this.dataSource.getSettings()),Nt(a=>{this.store.dispatch(Il({partialSettings:a}))}),Sa(0),hn(()=>tn(...this.configModule.getGlobalSettingSelectors().map(l=>this.store.select(l).pipe(Yn((c,d)=>{let u=Object.values(c),p=Object.values(d);return u.length===p.length&&u.every((f,m)=>f===p[m])}),ia(1))))),Cs());return s.pipe(function(n){return qt((t,e)=>{let i=[];return t.subscribe(Vt(e,r=>i.push(r),()=>{e.next(i),e.complete()})),n.subscribe(Vt(e,()=>{let r=i;i=[],e.next(r)},fl)),()=>{i=null}})}(s.pipe(wr(500))),hn(a=>{if(0===a.length)return Jr;let l={};for(let c of a)Object.assign(l,c);return this.dataSource.setSettings(l)}))},{dispatch:!1})}}return n.\u0275fac=function(e){return new(e||n)(k(xo),k(Ae),k(Ki),k(eS))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),Rhe=br({shouldPersistSettings:!0});function n6(n,t){return Rhe(n,t)}var mF=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({providers:[Ki],imports:[Tr.forFeature(nS,n6),to.forFeature([t6]),$8]}),n})(),ev=class{},oS=class{},da=class{constructor(t){this.normalizedNames=new Map,this.lazyUpdate=null,t?this.lazyInit="string"==typeof t?()=>{this.headers=new Map,t.split("\n").forEach(e=>{let i=e.indexOf(":");if(i>0){let r=e.slice(0,i),o=r.toLowerCase(),s=e.slice(i+1).trim();this.maybeSetNormalizedName(r,o),this.headers.has(o)?this.headers.get(o).push(s):this.headers.set(o,[s])}})}:()=>{this.headers=new Map,Object.entries(t).forEach(([e,i])=>{let r;if(r="string"==typeof i?[i]:"number"==typeof i?[i.toString()]:i.map(o=>o.toString()),r.length>0){let o=e.toLowerCase();this.headers.set(o,r),this.maybeSetNormalizedName(e,o)}})}:this.headers=new Map}has(t){return this.init(),this.headers.has(t.toLowerCase())}get(t){this.init();let e=this.headers.get(t.toLowerCase());return e&&e.length>0?e[0]:null}keys(){return this.init(),Array.from(this.normalizedNames.values())}getAll(t){return this.init(),this.headers.get(t.toLowerCase())||null}append(t,e){return this.clone({name:t,value:e,op:"a"})}set(t,e){return this.clone({name:t,value:e,op:"s"})}delete(t,e){return this.clone({name:t,value:e,op:"d"})}maybeSetNormalizedName(t,e){this.normalizedNames.has(e)||this.normalizedNames.set(e,t)}init(){this.lazyInit&&(this.lazyInit instanceof da?this.copyFrom(this.lazyInit):this.lazyInit(),this.lazyInit=null,this.lazyUpdate&&(this.lazyUpdate.forEach(t=>this.applyUpdate(t)),this.lazyUpdate=null))}copyFrom(t){t.init(),Array.from(t.headers.keys()).forEach(e=>{this.headers.set(e,t.headers.get(e)),this.normalizedNames.set(e,t.normalizedNames.get(e))})}clone(t){let e=new da;return e.lazyInit=this.lazyInit&&this.lazyInit instanceof da?this.lazyInit:this,e.lazyUpdate=(this.lazyUpdate||[]).concat([t]),e}applyUpdate(t){let e=t.name.toLowerCase();switch(t.op){case"a":case"s":let i=t.value;if("string"==typeof i&&(i=[i]),0===i.length)return;this.maybeSetNormalizedName(t.name,e);let r=("a"===t.op?this.headers.get(e):void 0)||[];r.push(...i),this.headers.set(e,r);break;case"d":let o=t.value;if(o){let s=this.headers.get(e);if(!s)return;s=s.filter(a=>-1===o.indexOf(a)),0===s.length?(this.headers.delete(e),this.normalizedNames.delete(e)):this.headers.set(e,s)}else this.headers.delete(e),this.normalizedNames.delete(e)}}forEach(t){this.init(),Array.from(this.normalizedNames.keys()).forEach(e=>t(this.normalizedNames.get(e),this.headers.get(e)))}},Ohe=/%(\d[a-f0-9])/gi,khe={40:"@","3A":":",24:"$","2C":",","3B":";","3D":"=","3F":"?","2F":"/"};function i6(n){return encodeURIComponent(n).replace(Ohe,(t,e)=>khe[e]??t)}function iS(n){return`${n}`}var Mc=class{constructor(t={}){if(this.updates=null,this.cloneFrom=null,this.encoder=t.encoder||new class{encodeKey(t){return i6(t)}encodeValue(t){return i6(t)}decodeKey(t){return decodeURIComponent(t)}decodeValue(t){return decodeURIComponent(t)}},t.fromString){if(t.fromObject)throw new Error("Cannot specify both fromString and fromObject.");this.map=function(n,t){let e=new Map;return n.length>0&&n.replace(/^\?/,"").split("&").forEach(r=>{let o=r.indexOf("="),[s,a]=-1==o?[t.decodeKey(r),""]:[t.decodeKey(r.slice(0,o)),t.decodeValue(r.slice(o+1))],l=e.get(s)||[];l.push(a),e.set(s,l)}),e}(t.fromString,this.encoder)}else t.fromObject?(this.map=new Map,Object.keys(t.fromObject).forEach(e=>{let i=t.fromObject[e],r=Array.isArray(i)?i.map(iS):[iS(i)];this.map.set(e,r)})):this.map=null}has(t){return this.init(),this.map.has(t)}get(t){this.init();let e=this.map.get(t);return e?e[0]:null}getAll(t){return this.init(),this.map.get(t)||null}keys(){return this.init(),Array.from(this.map.keys())}append(t,e){return this.clone({param:t,value:e,op:"a"})}appendAll(t){let e=[];return Object.keys(t).forEach(i=>{let r=t[i];Array.isArray(r)?r.forEach(o=>{e.push({param:i,value:o,op:"a"})}):e.push({param:i,value:r,op:"a"})}),this.clone(e)}set(t,e){return this.clone({param:t,value:e,op:"s"})}delete(t,e){return this.clone({param:t,value:e,op:"d"})}toString(){return this.init(),this.keys().map(t=>{let e=this.encoder.encodeKey(t);return this.map.get(t).map(i=>e+"="+this.encoder.encodeValue(i)).join("&")}).filter(t=>""!==t).join("&")}clone(t){let e=new Mc({encoder:this.encoder});return e.cloneFrom=this.cloneFrom||this,e.updates=(this.updates||[]).concat(t),e}init(){null===this.map&&(this.map=new Map),null!==this.cloneFrom&&(this.cloneFrom.init(),this.cloneFrom.keys().forEach(t=>this.map.set(t,this.cloneFrom.map.get(t))),this.updates.forEach(t=>{switch(t.op){case"a":case"s":let e=("a"===t.op?this.map.get(t.param):void 0)||[];e.push(iS(t.value)),this.map.set(t.param,e);break;case"d":if(void 0===t.value){this.map.delete(t.param);break}{let i=this.map.get(t.param)||[],r=i.indexOf(iS(t.value));-1!==r&&i.splice(r,1),i.length>0?this.map.set(t.param,i):this.map.delete(t.param)}}}),this.cloneFrom=this.updates=null)}};function r6(n){return typeof ArrayBuffer<"u"&&n instanceof ArrayBuffer}function o6(n){return typeof Blob<"u"&&n instanceof Blob}function s6(n){return typeof FormData<"u"&&n instanceof FormData}var af=class{constructor(t,e,i,r){let o;if(this.url=e,this.body=null,this.reportProgress=!1,this.withCredentials=!1,this.responseType="json",this.method=t.toUpperCase(),function(n){switch(n){case"DELETE":case"GET":case"HEAD":case"OPTIONS":case"JSONP":return!1;default:return!0}}(this.method)||r?(this.body=void 0!==i?i:null,o=r):o=i,o&&(this.reportProgress=!!o.reportProgress,this.withCredentials=!!o.withCredentials,o.responseType&&(this.responseType=o.responseType),o.headers&&(this.headers=o.headers),o.context&&(this.context=o.context),o.params&&(this.params=o.params)),this.headers||(this.headers=new da),this.context||(this.context=new class{constructor(){this.map=new Map}set(t,e){return this.map.set(t,e),this}get(t){return this.map.has(t)||this.map.set(t,t.defaultValue()),this.map.get(t)}delete(t){return this.map.delete(t),this}has(t){return this.map.has(t)}keys(){return this.map.keys()}}),this.params){let s=this.params.toString();if(0===s.length)this.urlWithParams=e;else{let a=e.indexOf("?");this.urlWithParams=e+(-1===a?"?":a<e.length-1?"&":"")+s}}else this.params=new Mc,this.urlWithParams=e}serializeBody(){return null===this.body?null:r6(this.body)||o6(this.body)||s6(this.body)||typeof URLSearchParams<"u"&&this.body instanceof URLSearchParams||"string"==typeof this.body?this.body:this.body instanceof Mc?this.body.toString():"object"==typeof this.body||"boolean"==typeof this.body||Array.isArray(this.body)?JSON.stringify(this.body):this.body.toString()}detectContentTypeHeader(){return null===this.body||s6(this.body)?null:o6(this.body)?this.body.type||null:r6(this.body)?null:"string"==typeof this.body?"text/plain":this.body instanceof Mc?"application/x-www-form-urlencoded;charset=UTF-8":"object"==typeof this.body||"number"==typeof this.body||"boolean"==typeof this.body?"application/json":null}clone(t={}){let e=t.method||this.method,i=t.url||this.url,r=t.responseType||this.responseType,o=void 0!==t.body?t.body:this.body,s=void 0!==t.withCredentials?t.withCredentials:this.withCredentials,a=void 0!==t.reportProgress?t.reportProgress:this.reportProgress,l=t.headers||this.headers,c=t.params||this.params,d=t.context??this.context;return void 0!==t.setHeaders&&(l=Object.keys(t.setHeaders).reduce((u,p)=>u.set(p,t.setHeaders[p]),l)),t.setParams&&(c=Object.keys(t.setParams).reduce((u,p)=>u.set(p,t.setParams[p]),c)),new af(e,i,o,{params:c,headers:l,context:d,reportProgress:a,responseType:r,withCredentials:s})}},bu=(()=>{return(n=bu||(bu={}))[n.Sent=0]="Sent",n[n.UploadProgress=1]="UploadProgress",n[n.ResponseHeader=2]="ResponseHeader",n[n.DownloadProgress=3]="DownloadProgress",n[n.Response=4]="Response",n[n.User=5]="User",bu;var n})(),tv=class{constructor(t,e=200,i="OK"){this.headers=t.headers||new da,this.status=void 0!==t.status?t.status:e,this.statusText=t.statusText||i,this.url=t.url||null,this.ok=this.status>=200&&this.status<300}},nv=class extends tv{constructor(t={}){super(t),this.type=bu.ResponseHeader}clone(t={}){return new nv({headers:t.headers||this.headers,status:void 0!==t.status?t.status:this.status,statusText:t.statusText||this.statusText,url:t.url||this.url||void 0})}},Ah=class extends tv{constructor(t={}){super(t),this.type=bu.Response,this.body=void 0!==t.body?t.body:null}clone(t={}){return new Ah({body:void 0!==t.body?t.body:this.body,headers:t.headers||this.headers,status:void 0!==t.status?t.status:this.status,statusText:t.statusText||this.statusText,url:t.url||this.url||void 0})}},Al=class extends tv{constructor(t){super(t,0,"Unknown Error"),this.name="HttpErrorResponse",this.ok=!1,this.message=this.status>=200&&this.status<300?`Http failure during parsing for ${t.url||"(unknown url)"}`:`Http failure response for ${t.url||"(unknown url)"}: ${t.status} ${t.statusText}`,this.error=t.error||null}};function hF(n,t){return{body:t,headers:n.headers,context:n.context,observe:n.observe,params:n.params,reportProgress:n.reportProgress,responseType:n.responseType,withCredentials:n.withCredentials}}var lf=(()=>{class n{constructor(e){this.handler=e}request(e,i,r={}){let o;if(e instanceof af)o=e;else{let l,c;l=r.headers instanceof da?r.headers:new da(r.headers),r.params&&(c=r.params instanceof Mc?r.params:new Mc({fromObject:r.params})),o=new af(e,i,void 0!==r.body?r.body:null,{headers:l,context:r.context,params:c,reportProgress:r.reportProgress,responseType:r.responseType||"json",withCredentials:r.withCredentials})}let s=Ht(o).pipe(function(n,t){return _n(t)?hn(n,t,1):hn(n,1)}(l=>this.handler.handle(l)));if(e instanceof af||"events"===r.observe)return s;let a=s.pipe(ke(l=>l instanceof Ah));switch(r.observe||"body"){case"body":switch(o.responseType){case"arraybuffer":return a.pipe(N(l=>{if(null!==l.body&&!(l.body instanceof ArrayBuffer))throw new Error("Response is not an ArrayBuffer.");return l.body}));case"blob":return a.pipe(N(l=>{if(null!==l.body&&!(l.body instanceof Blob))throw new Error("Response is not a Blob.");return l.body}));case"text":return a.pipe(N(l=>{if(null!==l.body&&"string"!=typeof l.body)throw new Error("Response is not a string.");return l.body}));default:return a.pipe(N(l=>l.body))}case"response":return a;default:throw new Error(`Unreachable: unhandled observe type ${r.observe}}`)}}delete(e,i={}){return this.request("DELETE",e,i)}get(e,i={}){return this.request("GET",e,i)}head(e,i={}){return this.request("HEAD",e,i)}jsonp(e,i){return this.request("JSONP",e,{params:(new Mc).append(i,"JSONP_CALLBACK"),observe:"body",responseType:"json"})}options(e,i={}){return this.request("OPTIONS",e,i)}patch(e,i,r={}){return this.request("PATCH",e,hF(r,i))}post(e,i,r={}){return this.request("POST",e,hF(r,i))}put(e,i,r={}){return this.request("PUT",e,hF(r,i))}}return n.\u0275fac=function(e){return new(e||n)(k(ev))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})();function d6(n,t){return t(n)}function Lhe(n,t){return(e,i)=>t.intercept(e,{handle:r=>n(r,i)})}var bF=new ie("HTTP_INTERCEPTORS"),vF=new ie("HTTP_INTERCEPTOR_FNS");function Vhe(){let n=null;return(t,e)=>(null===n&&(n=(ai(bF,{optional:!0})??[]).reduceRight(Lhe,d6)),n(t,e))}var a6=(()=>{class n extends ev{constructor(e,i){super(),this.backend=e,this.injector=i,this.chain=null}handle(e){if(null===this.chain){let i=Array.from(new Set(this.injector.get(vF)));this.chain=i.reduceRight((r,o)=>function(n,t,e){return(i,r)=>e.runInContext(()=>t(i,o=>n(o,r)))}(r,o,this.injector),d6)}return this.chain(e,i=>this.backend.handle(i))}}return n.\u0275fac=function(e){return new(e||n)(k(oS),k(pc))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),Hhe=/^\)\]\}',?\n/,l6=(()=>{class n{constructor(e){this.xhrFactory=e}handle(e){if("JSONP"===e.method)throw new Error("Attempted to construct Jsonp request without HttpClientJsonpModule installed.");return new Kt(i=>{let r=this.xhrFactory.build();if(r.open(e.method,e.urlWithParams),e.withCredentials&&(r.withCredentials=!0),e.headers.forEach((f,m)=>r.setRequestHeader(f,m.join(","))),e.headers.has("Accept")||r.setRequestHeader("Accept","application/json, text/plain, */*"),!e.headers.has("Content-Type")){let f=e.detectContentTypeHeader();null!==f&&r.setRequestHeader("Content-Type",f)}if(e.responseType){let f=e.responseType.toLowerCase();r.responseType="json"!==f?f:"text"}let o=e.serializeBody(),s=null,a=()=>{if(null!==s)return s;let f=r.statusText||"OK",m=new da(r.getAllResponseHeaders()),b=function(n){return"responseURL"in n&&n.responseURL?n.responseURL:/^X-Request-URL:/m.test(n.getAllResponseHeaders())?n.getResponseHeader("X-Request-URL"):null}(r)||e.url;return s=new nv({headers:m,status:r.status,statusText:f,url:b}),s},l=()=>{let{headers:f,status:m,statusText:b,url:M}=a(),y=null;204!==m&&(y=typeof r.response>"u"?r.responseText:r.response),0===m&&(m=y?200:0);let x=m>=200&&m<300;if("json"===e.responseType&&"string"==typeof y){let R=y;y=y.replace(Hhe,"");try{y=""!==y?JSON.parse(y):null}catch(A){y=R,x&&(x=!1,y={error:A,text:y})}}x?(i.next(new Ah({body:y,headers:f,status:m,statusText:b,url:M||void 0})),i.complete()):i.error(new Al({error:y,headers:f,status:m,statusText:b,url:M||void 0}))},c=f=>{let{url:m}=a(),b=new Al({error:f,status:r.status||0,statusText:r.statusText||"Unknown Error",url:m||void 0});i.error(b)},d=!1,u=f=>{d||(i.next(a()),d=!0);let m={type:bu.DownloadProgress,loaded:f.loaded};f.lengthComputable&&(m.total=f.total),"text"===e.responseType&&!!r.responseText&&(m.partialText=r.responseText),i.next(m)},p=f=>{let m={type:bu.UploadProgress,loaded:f.loaded};f.lengthComputable&&(m.total=f.total),i.next(m)};return r.addEventListener("load",l),r.addEventListener("error",c),r.addEventListener("timeout",c),r.addEventListener("abort",c),e.reportProgress&&(r.addEventListener("progress",u),null!==o&&r.upload&&r.upload.addEventListener("progress",p)),r.send(o),i.next({type:bu.Sent}),()=>{r.removeEventListener("error",c),r.removeEventListener("abort",c),r.removeEventListener("load",l),r.removeEventListener("timeout",c),e.reportProgress&&(r.removeEventListener("progress",u),null!==o&&r.upload&&r.upload.removeEventListener("progress",p)),r.readyState!==r.DONE&&r.abort()}})}}return n.\u0275fac=function(e){return new(e||n)(k(Qp))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),u6=new ie("XSRF_ENABLED"),jhe=new ie("XSRF_COOKIE_NAME",{providedIn:"root",factory:()=>"XSRF-TOKEN"}),Whe=new ie("XSRF_HEADER_NAME",{providedIn:"root",factory:()=>"X-XSRF-TOKEN"}),sS=class{},qhe=(()=>{class n{constructor(e,i,r){this.doc=e,this.platform=i,this.cookieName=r,this.lastCookieString="",this.lastToken=null,this.parseCount=0}getToken(){if("server"===this.platform)return null;let e=this.doc.cookie||"";return e!==this.lastCookieString&&(this.parseCount++,this.lastToken=mw(e,this.cookieName),this.lastCookieString=e),this.lastToken}}return n.\u0275fac=function(e){return new(e||n)(k(Lt),k(vc),k(jhe))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})();function Yhe(n,t){let e=n.url.toLowerCase();if(!ai(u6)||"GET"===n.method||"HEAD"===n.method||e.startsWith("http://")||e.startsWith("https://"))return t(n);let i=ai(sS).getToken(),r=ai(Whe);return null!=i&&!n.headers.has(r)&&(n=n.clone({headers:n.headers.set(r,i)})),t(n)}var rS=(()=>{return(n=rS||(rS={}))[n.Interceptors=0]="Interceptors",n[n.LegacyInterceptors=1]="LegacyInterceptors",n[n.CustomXsrfConfiguration=2]="CustomXsrfConfiguration",n[n.NoXsrfProtection=3]="NoXsrfProtection",n[n.JsonpSupport=4]="JsonpSupport",n[n.RequestsMadeViaParent=5]="RequestsMadeViaParent",rS;var n})();function Qhe(...n){let t=[lf,l6,a6,{provide:ev,useExisting:a6},{provide:oS,useExisting:l6},{provide:vF,useValue:Yhe,multi:!0},{provide:u6,useValue:!0},{provide:sS,useClass:qhe}];for(let e of n)t.push(...e.\u0275providers);return function(n){return{"\u0275providers":n}}(t)}var c6=new ie("LEGACY_INTERCEPTOR_FN"),p6=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({providers:[Qhe({"\u0275kind":rS.LegacyInterceptors,"\u0275providers":[{provide:c6,useFactory:Vhe},{provide:vF,useExisting:c6,multi:!0}]})]}),n})(),aS="feature",Rh=Er(aS),vu=q(Rh,n=>n.isFeatureFlagsLoaded),ks=q(Rh,n=>({...n.defaultFlags,...n.flagOverrides})),m6=q(Rh,n=>n.defaultFlags),iv=q(Rh,n=>n.flagOverrides||{}),cf=q(Rh,n=>n.metadata),Ph=q(Rh,n=>{let t={};for(let e in n.flagOverrides){let i=n.metadata[e];i&&i.queryParamOverride&&i.sendToServerWhenOverridden&&(t[e]=n.flagOverrides[e])}return t}),h6=q(ks,n=>n.isAutoDarkModeAllowed),Rl=q(ks,n=>null!==n.enableDarkModeOverride?n.enableDarkModeOverride:n.defaultEnableDarkMode),lS=q(ks,n=>n.enableDarkModeOverride),g6=q(ks,n=>n.enabledExperimentalPlugins),_6=q(ks,n=>n.inColab),cS=q(ks,n=>n.metricsImageSupportEnabled),yF=q(ks,n=>n.forceSvg),b6=q(ks,n=>void 0!==n.showFlags),dS=q(ks,n=>n.enableScalarColumnCustomization),md=q(ks,n=>n.enableHparamsInTimeSeries);function Jhe(n,t){if(!n)return;let e=n instanceof FormData?function(n){let t={};for(let[e,i]of n.entries())t[e]=i;return t}(n):n;return t?{[t]:JSON.stringify(e)}:e}var $he="X-XSRF-Protected";function xF(n){let t=n.headers||new da;return t=t.append($he,"1"),{...n,headers:t}}var Ua=(()=>{class n{constructor(e,i,r){this.appRootProvider=e,this.http=i,this.store=r}resolveAppRoot(e){return e.startsWith("/")?this.appRootProvider.getAbsPathnameWithAppRoot(e):e}get(e,i={}){return this.http.get(this.resolveAppRoot(e),i)}post(e,i,r={},o){return r=xF(r),this.store.select(vu).pipe(ke(s=>Boolean(s)),Yt(1),Bt(this.store.select(_6)),hn(([,s])=>{let a=this.resolveAppRoot(e);return s?this.http.get(a,{headers:r.headers??{},params:Jhe(i,o)}):this.http.post(a,i,r)}))}put(e,i,r={}){return this.http.put(this.resolveAppRoot(e),i,xF(r))}delete(e,i={}){return this.http.delete(this.resolveAppRoot(e),xF(i))}}return n.\u0275fac=function(e){return new(e||n)(k(sf),k(lf),k(Ae))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),Oh=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({providers:[Ua],imports:[p6,Sh]}),n})(),ja=(()=>{return(n=ja||(ja={})).UNKNOWN="UNKNOWN",n.NOT_FOUND="NOT_FOUND",n.PERMISSION_DENIED="PERMISSION_DENIED",ja;var n})(),v6=new ie("TensorBoard brand name"),no=(()=>{return(n=no||(no={})).STEP="step",n.WALL_TIME="wall_time",n.RELATIVE="relative",no;var n})(),Dr=(()=>{return(n=Dr||(Dr={})).OFFSET="offset",n.OVERLAY="overlay",Dr;var n})();function y6(n){let t=ja.UNKNOWN;return n instanceof Al&&(404===n.status&&(t=ja.NOT_FOUND),403===n.status&&(t=ja.PERMISSION_DENIED)),ea(new ov(t))}var ov=class{constructor(t){this.failureCode=t}},uS=(()=>{class n{constructor(e){this.http=e,this.tfBackend=document.createElement("tf-backend").tf_backend}fetchPluginsListing(e){let i=function(n){if(!n.length)return null;let t=new URLSearchParams;for(let e of n)t.append("experimentalPlugin",e);return t}(e),r=i?`data/plugins_listing?${i.toString()}`:"data/plugins_listing";return this.http.get(r).pipe(zr(y6))}fetchEnvironment(){return co([this.http.get("data/environment"),$r(this.tfBackend.environmentStore.refresh())]).pipe(N(([r])=>r),zr(y6))}}return n.\u0275fac=function(e){return new(e||n)(k(Ua))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),x6=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({providers:[uS],imports:[Oh]}),n})(),Te=(()=>{return(n=Te||(Te={}))[n.NOT_LOADED=0]="NOT_LOADED",n[n.LOADED=1]="LOADED",n[n.LOADING=2]="LOADING",n[n.FAILED=3]="FAILED",Te;var n})(),wc=_e("[Core] Plugin Changed",{_as:"props",_p:void 0}),pS=_e("[Core] Plugin Url Hash Changed",{_as:"props",_p:void 0}),C6=_e("[Core] Loaded"),Fs=_e("[Core] User Triggered Reload"),cs=_e("[Core] Auto Reload"),fS=_e("[Core] PluginListing Fetch Requested"),df=_e("[Core] PluginListing Fetch Successful",{_as:"props",_p:void 0}),sv=_e("[Core] PluginListing Fetch Failed",{_as:"props",_p:void 0}),mS=_e("[Core] Polymer Component Runs Fetch Requested"),hS=_e("[Core] Polymer Component Runs Fetch Successful"),gS=_e("[Core] Polymer Component Runs Fetch Failed"),_S=_e("[Core] Environment Fetch Successful",{_as:"props",_p:void 0}),M6=_e("[Core] Run Selection Changed",{_as:"props",_p:void 0}),w6=_e("[Core] Run Fetch Successful",{_as:"props",_p:void 0}),kh=_e("[Core] Side Bar Width Changed",{_as:"props",_p:void 0}),bS=_e("[Core] Runs Table Full Screen Toggled");function uf(n,t,e){let i=Object.keys(n),r={...n,...t,privateNamespacedState:{}};return{initialState:r,reducers:br(r,ye(Ps,(a,{before:l,after:c,beforeNamespaceId:d,afterNamespaceId:u})=>{let p=a;return d!==u&&(p=function(a,l,c){let d={...a.privateNamespacedState};if(l){let p={};for(let f of i)p[f]=a[f];d={...d,[l]:p}}let u={};return a.privateNamespacedState?.[c]?u=a.privateNamespacedState[c]:l&&(u=n),{...a,...u,privateNamespacedState:d}}(a,d,u)),e&&(p=e(p,l,c)),p}))}}function pf(...n){return(t,e)=>{let i=t;for(let r of n)i=r(i,e);return i}}var lv={activePlugin:null,plugins:{},coreDataLoadState:{state:Te.NOT_LOADED,lastLoadedTimeInMs:null},pluginsListLoaded:{state:Te.NOT_LOADED,lastLoadedTimeInMs:null,failureCode:null},environment:{data_location:"",window_title:""},polymerRunsLoadState:{state:Te.NOT_LOADED,lastLoadedTimeInMs:null},polymerInteropRuns:[],polymerInteropRunSelection:new Set,sideBarWidthInPercent:20,runsTableFullScreen:!1},nge=br(lv,ye(wc,pS,(n,{plugin:t})=>({...n,activePlugin:t})),ye(fS,n=>({...n,coreDataLoadState:{...n.coreDataLoadState,state:Te.LOADING},pluginsListLoaded:{...n.pluginsListLoaded,state:Te.LOADING}})),ye(sv,(n,{failureCode:t})=>({...n,coreDataLoadState:{...n.coreDataLoadState,state:Te.FAILED},pluginsListLoaded:{...n.pluginsListLoaded,state:Te.FAILED,failureCode:t}})),ye(df,(n,{plugins:t})=>{let e=Object.keys(t).find(s=>t[s].enabled)||null,i=n.activePlugin||e,r=Date.now(),o=n.coreDataLoadState;return n.polymerRunsLoadState.state===Te.LOADED&&(o={state:Te.LOADED,lastLoadedTimeInMs:r}),{...n,activePlugin:i,coreDataLoadState:o,plugins:t,pluginsListLoaded:{state:Te.LOADED,lastLoadedTimeInMs:r,failureCode:null}}}),ye(mS,n=>({...n,coreDataLoadState:{...n.coreDataLoadState,state:Te.LOADING},polymerRunsLoadState:{...n.polymerRunsLoadState,state:Te.LOADING}})),ye(hS,n=>{let t=Date.now(),e=n.coreDataLoadState;return n.pluginsListLoaded.state===Te.LOADED&&(e={state:Te.LOADED,lastLoadedTimeInMs:t}),{...n,coreDataLoadState:e,polymerRunsLoadState:{...n.polymerRunsLoadState,state:Te.LOADED,lastLoadedTimeInMs:t}}}),ye(gS,n=>({...n,coreDataLoadState:{...n.coreDataLoadState,state:Te.FAILED},polymerRunsLoadState:{...n.polymerRunsLoadState,state:Te.FAILED}})),ye(_S,(n,{environment:t})=>({...n,environment:t})),ye(w6,(n,{runs:t})=>({...n,polymerInteropRuns:t})),ye(M6,(n,{nextSelection:t})=>({...n,polymerInteropRunSelection:new Set(t)})),ye(kh,(n,{widthInPercent:t})=>({...n,sideBarWidthInPercent:Math.min(Math.max(0,t),100)})),ye(Il,(n,{partialSettings:t})=>{let e={...n},i=t.sideBarWidthInPercent;return"number"==typeof i&&i>=0&&i<=100&&(e.sideBarWidthInPercent=i),e}),ye(bS,n=>({...n,runsTableFullScreen:!n.runsTableFullScreen}))),{reducers:ige}=uf(lv,{});function S6(n,t){return pf(nge,ige)(n,t)}var hd=Er("core"),yS=q(hd,n=>n.pluginsListLoaded),E6=q(hd,n=>n.polymerRunsLoadState),T6=q(hd,n=>n.coreDataLoadState.state),Fh=q(hd,n=>n.coreDataLoadState.lastLoadedTimeInMs),Wo=q(hd,n=>n.activePlugin),Nh=q(hd,n=>n.plugins),xS=q(hd,n=>n.environment),CS=q(hd,n=>n.sideBarWidthInPercent),Lh=q(hd,n=>n.runsTableFullScreen),D6=new Set([wn.COMPARE_EXPERIMENT,wn.EXPERIMENT,wn.NOT_SET]),I6=(()=>{class n{refreshPolymerRuns(){return $r(this.tfBackend.ref.runsStore.refresh())}fetchEnvironment(){return this.webappDataSource.fetchEnvironment().pipe(Nt(e=>{this.store.dispatch(_S({environment:e}))}))}constructor(e,i,r){this.actions$=e,this.store=i,this.webappDataSource=r,this.tfBackend={ref:document.createElement("tf-backend").tf_backend},this.onDashboardLoad$=tn(this.actions$.pipe(ei(C6,Ps),Bt(this.store.select(No)),Yn(([,o],[,s])=>Fo(o,s))),this.actions$.pipe(ei(cs,Fs))).pipe(Bt(this.store.select(Ha)),ke(([,o])=>D6.has(o)),ac(1,void 0,{leading:!0})),this.fetchWebAppData$=ar(()=>{let o=this.onDashboardLoad$.pipe(Bt(this.store.select(yS),this.store.select(g6)),ke(([,{state:a}])=>a!==Te.LOADING),Nt(()=>this.store.dispatch(fS())),hn(([,,a])=>function(...n){let t=rc(n),e=OC(n);return e.length?new Kt(i=>{let r=e.map(()=>[]),o=e.map(()=>!1);i.add(()=>{r=o=null});for(let s=0;!i.closed&&s<e.length;s++)ii(e[s]).subscribe(Vt(i,a=>{if(r[s].push(a),r.every(l=>l.length)){let l=r.map(c=>c.shift());i.next(t?t(...l):l),r.some((c,d)=>!c.length&&o[d])&&i.complete()}},()=>{o[s]=!0,!r[s].length&&i.complete()}));return()=>{r=o=null}}):Jr}(this.webappDataSource.fetchPluginsListing(a),this.fetchEnvironment()).pipe(N(([l])=>{this.store.dispatch(df({plugins:l}))}),zr(l=>(this.store.dispatch(sv(l instanceof ov?{failureCode:l.failureCode}:{failureCode:ja.UNKNOWN})),Jr)))));return tn(o,this.onDashboardLoad$.pipe(N(([,a])=>a),Jn(a=>a!==wn.COMPARE_EXPERIMENT?Ht([]):this.store.select(za).pipe(Yn((l,c)=>{let d=Object.entries(l),u=new Map(Object.entries(c));if(d.length!==u.size)return!1;for(let[p,f]of d)if(!u.get(p)||u.get(p).aliasText!==f.aliasText||u.get(p).aliasNumber!==f.aliasNumber)return!1;return!0}),Sa(0),ac(500,void 0,{leading:!0,trailing:!0}))),Bt(this.store.select(Ha),this.store.select(E6)),ke(([,a,l])=>D6.has(a)&&l.state!==Te.LOADING),Nt(()=>{this.store.dispatch(mS())}),Jn(()=>this.refreshPolymerRuns()),Nt(()=>{this.store.dispatch(hS())}),zr(()=>(this.store.dispatch(gS()),Jr))))},{dispatch:!1}),this.dispatchChangePlugin$=ar(()=>tn(this.onDashboardLoad$,this.actions$.pipe(ei(df))).pipe(Bt(this.store.select(Wo)),N(([,o])=>o),Yn(),ke(o=>null!==o),Yt(1),Nt(o=>{this.store.dispatch(wc({plugin:o}))})),{dispatch:!1})}}return n.\u0275fac=function(e){return new(e||n)(k(xo),k(Ae),k(uS))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),CF=new ie("Core Feature Config");function A6(n){return{initialState:{...lv,activePlugin:n.getPluginId()||null}}}function sge(){return q(CS,n=>({sideBarWidthInPercent:n}))}var Ga=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({providers:[{provide:CF,deps:[_u],useFactory:A6}],imports:[to.forFeature([I6]),Tr.forFeature("core",S6,CF),x6,Ki.defineGlobalSetting(sge)]}),n})(),R6=new ie("[Alert] Action-To-Alert Provider"),Sc=(()=>{class n{constructor(e){this.providers=new Map;for(let i of e||[])for(let r of i){if(this.providers.has(r.actionCreator.type))throw new RangeError(`"${r.actionCreator.type}" is already registered for alerts. Multiple alerts for the same action is not allowed.`);this.providers.set(r.actionCreator.type,r.alertFromAction)}}getAlertFromAction(e){let i=this.providers.get(e.type);return i?i(e):null}static registerAlertActions(e){return{ngModule:n,providers:[{provide:R6,multi:!0,useFactory:e}]}}}return n.\u0275fac=function(e){return new(e||n)(k(R6,8))},n.\u0275mod=G({type:n}),n.\u0275inj=U({}),n})(),MS=_e("[Runs] Fetch Runs Requested",{_as:"props",_p:void 0}),yu=_e("[Runs] Fetch Runs Succeeded",{_as:"props",_p:void 0}),Bh=_e("[Runs] Fetch Runs Failed",{_as:"props",_p:void 0}),cv=_e("[Runs] Run Selection Toggled",{_as:"props",_p:void 0}),wS=_e("[Runs] Single Run Selected",{_as:"props",_p:void 0}),dv=_e("[Runs] Run Page Selection Toggled",{_as:"props",_p:void 0}),SS=_e("[Runs] Run Selector Pagination Option Changed",{_as:"props",_p:void 0}),ES=_e("[Runs] Run Selector Sort Changed",{_as:"props",_p:void 0}),uv=_e("[Runs] Run Selector Regex Filter Changed",{_as:"props",_p:void 0}),TS=_e("[Runs] Run Color Changed",{_as:"props",_p:void 0}),Vh=_e("[Runs] Run Table Shown",{_as:"props",_p:void 0}),Hh=_e("[Runs] Run Group By Changed",{_as:"props",_p:void 0}),DS=_e("[Runs] Runs Table Header Added",{_as:"props",_p:void 0}),zh=_e("[Runs] Runs Table Header Removed",{_as:"props",_p:void 0}),IS=_e("[Runs] Runs Table Header Order Changed",{_as:"props",_p:void 0}),AS=_e("[Runs] Runs Table Sorting Info Changed",{_as:"props",_p:void 0}),ht=(()=>{return(n=ht||(ht={})).COLOR="COLOR",n.RELATIVE_TIME="RELATIVE_TIME",n.RUN="RUN",n.STEP="STEP",n.EXPERIMENT="EXPERIMENT",n.TIME="TIME",n.VALUE="VALUE",n.SMOOTHED="SMOOTHED",n.VALUE_CHANGE="VALUE_CHANGE",n.START_STEP="START_STEP",n.END_STEP="END_STEP",n.START_VALUE="START_VALUE",n.END_VALUE="END_VALUE",n.MIN_VALUE="MIN_VALUE",n.MAX_VALUE="MAX_VALUE",n.PERCENTAGE_CHANGE="PERCENTAGE_CHANGE",n.STEP_AT_MAX="STEP_AT_MAX",n.STEP_AT_MIN="STEP_AT_MIN",n.MEAN="MEAN",n.RAW_CHANGE="RAW_CHANGE",n.HPARAM="HPARAM",n.METRIC="METRIC",n.CUSTOM="CUSTOM",ht;var n})(),gn=(()=>{return(n=gn||(gn={}))[n.DISCRETE=0]="DISCRETE",n[n.INTERVAL=1]="INTERVAL",gn;var n})(),io=(()=>{return(n=io||(io={}))[n.ASCENDING=0]="ASCENDING",n[n.DESCENDING=1]="DESCENDING",io;var n})(),ro=(()=>{return(n=ro||(ro={}))[n.SINGLE=0]="SINGLE",n[n.RANGE=1]="RANGE",ro;var n})(),Ns=(()=>{return(n=Ns||(Ns={})).STATUS_UNKNOWN="STATUS_UNKNOWN",n.STATUS_SUCCESS="STATUS_SUCCESS",n.STATUS_FAILURE="STATUS_FAILURE",n.STATUS_RUNNING="STATUS_RUNNING",Ns;var n})(),RS=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),Ec={};FA(Ec,{dashboardHparamFilterAdded:()=>DF,dashboardHparamFilterRemoved:()=>fv,dashboardMetricFilterAdded:()=>IF,dashboardMetricFilterRemoved:()=>mv,hparamsDiscreteHparamFilterChanged:()=>SF,hparamsFetchSessionGroupsSucceeded:()=>pv,hparamsIntervalHparamFilterChanged:()=>EF,hparamsMetricFilterChanged:()=>TF});var SF=_e("[Hparams] Hparams Discrete Hparam Filter Changed",{_as:"props",_p:void 0}),EF=_e("[Hparams] Hparams Interval Hparam Filter Changed",{_as:"props",_p:void 0}),TF=_e("[Hparams] Hparams Metric Filter Changed",{_as:"props",_p:void 0}),pv=_e("[Hparams] Hparams Fetch Session Groups Succeeded",{_as:"props",_p:void 0}),DF=_e("[Hparams] Dashboard Hparam Filter Added",{_as:"props",_p:void 0}),IF=_e("[Hparams] Dashboard Metric Filter Added",{_as:"props",_p:void 0}),fv=_e("[Hparams] Dashboard Hparam Filter Removed",{_as:"props",_p:void 0}),mv=_e("[Hparams] Dashboard Metric Filter Removed",{_as:"props",_p:void 0});function ff(n){return JSON.stringify([...n].sort())}function hv(n){let t=new Map,e=new Map,i=new Map;for(let r of n)for(let[o,s]of r)if(s.type===gn.DISCRETE){let{possibleValues:a,values:l}=e.get(o)||{possibleValues:new Set,values:new Set};for(let c of s.filterValues)l.add(c);for(let c of s.possibleValues)a.add(c);e.set(o,{possibleValues:a,values:l})}else{let a=i.get(o);i.set(o,{filterLowerValue:Math.min(s.filterLowerValue,a?.filterLowerValue??1/0),filterUpperValue:Math.max(s.filterUpperValue,a?.filterUpperValue??-1/0),minValue:Math.min(s.minValue,a?.minValue??1/0),maxValue:Math.max(s.maxValue,a?.maxValue??-1/0)})}for(let[r,{values:o,possibleValues:s}]of e)t.set(r,{type:gn.DISCRETE,includeUndefined:!0,possibleValues:[...s],filterValues:[...o]});for(let[r,{minValue:o,maxValue:s,filterLowerValue:a,filterUpperValue:l}]of i){if(t.has(r)){let c=t.get(r);if(c.type===gn.DISCRETE&&c.possibleValues.some(d=>d))throw new RangeError(`Cannot combine hparam, ${r}, as it is of mixed types.`)}t.set(r,{type:gn.INTERVAL,includeUndefined:!0,minValue:o,maxValue:s,filterLowerValue:a,filterUpperValue:l})}return t}function PS(n){let t=new Map;for(let e of n)for(let[i,r]of e){let o=t.get(i);t.set(i,{type:gn.INTERVAL,includeUndefined:!0,...o,minValue:Math.min(r.minValue,o?.minValue??1/0),maxValue:Math.max(r.maxValue,o?.maxValue??-1/0),filterLowerValue:Math.min(r.filterLowerValue,o?.filterLowerValue??1/0),filterUpperValue:Math.max(r.filterUpperValue,o?.filterUpperValue??-1/0)})}return t}function F6(n){return n.domain.type===gn.DISCRETE?{type:gn.DISCRETE,includeUndefined:!0,possibleValues:n.domain.values,filterValues:n.domain.values}:{type:gn.INTERVAL,includeUndefined:!0,minValue:n.domain.minValue,maxValue:n.domain.maxValue,filterLowerValue:n.domain.minValue,filterUpperValue:n.domain.maxValue}}var pge=br({specs:{},filters:{},dashboardSpecs:{hparams:[],metrics:[]},dashboardSessionGroups:[],dashboardFilters:{hparams:new Map,metrics:new Map}},ye(SF,(n,t)=>{let{experimentIds:e,hparamName:i,filterValues:r,includeUndefined:o}=t,s=ff(e),a=n.filters[s]??{hparams:new Map},l=a.hparams.get(i);if(l&&l.type!==gn.DISCRETE)throw new RangeError(`New discrete filter of ${i} conflicts existing filter of `+gn[l.type]);let c=hv(e.filter(f=>Boolean(n.specs[f])).map(f=>n.specs[f].hparam.defaultFilters)).get(i);if(!c)throw new Error(`Cannot set hparam, ${i}, when it is not known for experimentIds: ${e.join(", ")}`);if(c.type!==gn.DISCRETE)throw new Error(`Cannot set ${i} when default filter is not of discrete type.`);let d=new Set(c.possibleValues),u=[...r].filter(f=>!d.has(f));if(u.length)throw new Error(`New filter for ${i} has more than one value that is not present in the spec. Bad values: ${u.join(", ")}`);let p=new Map(a.hparams);return p.set(i,{...l,type:gn.DISCRETE,includeUndefined:o,possibleValues:[...d],filterValues:r}),{...n,filters:{...n.filters,[s]:{...a,hparams:p}}}}),ye(EF,(n,t)=>{let{experimentIds:e,hparamName:i,filterLowerValue:r,filterUpperValue:o,includeUndefined:s}=t,a=ff(e),l=n.filters[a]??{metrics:new Map,hparams:new Map},c=l.hparams.get(i);if(c&&c.type!==gn.INTERVAL)throw new RangeError(`New interval filter of ${i} conflicts existing filter of `+gn[c.type]);let d=hv(e.filter(p=>Boolean(n.specs[p])).map(p=>n.specs[p].hparam.defaultFilters)).get(i);if(!d)throw new Error(`Cannot set hpara, ${i}, when it is not known for experimentIds: ${e.join(", ")}`);if(d.type!==gn.INTERVAL)throw new Error(`Cannot set ${i} when default filter is not of interval type.`);let u=new Map(l.hparams);return u.set(i,{...c,type:gn.INTERVAL,includeUndefined:s,minValue:d.minValue,maxValue:d.maxValue,filterLowerValue:r,filterUpperValue:o}),{...n,filters:{...n.filters,[a]:{...l,hparams:u}}}}),ye(TF,(n,t)=>{let{experimentIds:e,metricTag:i,filterLowerValue:r,filterUpperValue:o,includeUndefined:s}=t,a=ff(e),l=n.filters[a]??{metrics:new Map,hparams:new Map},c=PS(e.filter(p=>Boolean(n.specs[p])).map(p=>n.specs[p].metric.defaultFilters)).get(i);if(!c)throw new Error(`Cannot set metric, ${i}, when it is not known for experimentIds: ${e.join(", ")}`);let d=l.metrics.get(i),u=new Map(l.metrics);return u.set(i,{...d,type:gn.INTERVAL,includeUndefined:s,minValue:c.minValue,maxValue:c.maxValue,filterLowerValue:r,filterUpperValue:o}),{...n,filters:{...n.filters,[a]:{...l,metrics:u}}}}),ye(yu,(n,t)=>{if(0===Object.keys(t.newRunsAndMetadata).length)return n;let e={...n.specs},i=new Map,r=new Set;for(let o of Object.keys(t.newRunsAndMetadata)){let s=new Map,a=new Map,l=new Map,c=new Map,{runs:d,metadata:u}=t.newRunsAndMetadata[o];for(let p of d){let f=u.runToHparamsAndMetrics[p.id];if(f)for(let m of f.metrics){let b=i.get(m.tag);i.set(m.tag,{min:b?Math.min(b.min,m.value):m.value,max:b?Math.max(b.max,m.value):m.value})}}for(let{name:p,domain:f}of u.hparamSpecs)if(f.type===gn.DISCRETE){let m=l.get(p)||new Set;for(let b of f.values)m.add(b);l.set(p,m)}else{let m=c.get(p);c.set(p,{minValue:m?Math.min(f.minValue,m.minValue):f.minValue,maxValue:m?Math.max(f.maxValue,m.maxValue):f.maxValue})}for(let p of u.metricSpecs)r.add(p.tag);for(let[p,f]of l)s.set(p,{type:gn.DISCRETE,includeUndefined:!0,possibleValues:[...f],filterValues:[...f]});for(let[p,{minValue:f,maxValue:m}]of c)s.set(p,{type:gn.INTERVAL,includeUndefined:!0,minValue:f,maxValue:m,filterLowerValue:f,filterUpperValue:m});for(let p of r){let f=i.get(p),m=f?.min??0,b=f?.max??0;a.set(p,{type:gn.INTERVAL,includeUndefined:!0,minValue:m,maxValue:b,filterLowerValue:m,filterUpperValue:b})}e[o]={hparam:{...e[o]?.hparam,specs:u.hparamSpecs,defaultFilters:s},metric:{...e[o]?.metric,specs:u.metricSpecs,defaultFilters:a}}}return{...n,specs:e}}),ye(pv,(n,t)=>({...n,dashboardSpecs:t.hparamsAndMetricsSpecs,dashboardSessionGroups:t.sessionGroups})),ye(DF,(n,t)=>{let e=new Map(n.dashboardFilters.hparams);return e.set(t.name,t.filter),{...n,dashboardFilters:{...n.dashboardFilters,hparams:e}}}),ye(IF,(n,t)=>{let e=new Map(n.dashboardFilters.metrics);return e.set(t.name,t.filter),{...n,dashboardFilters:{...n.dashboardFilters,metrics:e}}}),ye(fv,(n,t)=>{let e=new Map(n.dashboardFilters.hparams);return e.delete(t.name),{...n,dashboardFilters:{...n.dashboardFilters,hparams:e}}}),ye(mv,(n,t)=>{let e=new Map(n.dashboardFilters.metrics);return e.delete(t.name),{...n,dashboardFilters:{...n.dashboardFilters,metrics:e}}}));function N6(n,t){return pge(n,t)}var OS="hparams",L6="data/plugin/hparams";function hge(n){return function(n){return Boolean(n.domainDiscrete)}(n)?{type:gn.DISCRETE,values:n.domainDiscrete}:function(n){return Boolean(n.domainInterval)}(n)?{...n.domainInterval,type:gn.INTERVAL}:{values:[],type:gn.DISCRETE}}var kS=(()=>{class n{constructor(e){this.http=e}getPrefix(e){return e.length>1?"compare":"experiment"}formatExperimentIds(e){return 1===e.length?e[0]:e.map((i,r)=>`${r}:${i}`).join(",")}fetchExperimentInfo(e){let i=this.formatExperimentIds(e);return this.http.post(`/${this.getPrefix(e)}/${i}/${L6}/experiment`,{experimentName:i},{},"request").pipe(N(r=>({hparams:r.hparamInfos.map(o=>{let s={...o,domain:hge(o)};return delete s.domainInterval,delete s.domainDiscrete,s}),metrics:r.metricInfos.map(o=>({...o,tag:o.name.tag}))})))}fetchSessionGroups(e,i){let r=this.formatExperimentIds(e),o=[];for(let a of i.hparams)o.push({hparam:a.name});for(let a of i.metrics)o.push({metric:a.name});let s={experimentName:r,allowedStatuses:[Ns.STATUS_FAILURE,Ns.STATUS_RUNNING,Ns.STATUS_SUCCESS,Ns.STATUS_UNKNOWN],colParams:o,startIndex:0,sliceSize:1e6};return this.http.post(`/${this.getPrefix(e)}/${r}/${L6}/session_groups`,s,{},"request").pipe(N(a=>a.sessionGroups.map(l=>(l.sessions=l.sessions.map(c=>{if(e.length>1){let[,...d]=c.name.split(" "),[u,...p]=d.join(" ").split("/");c.name=[e[parseInt(u)],...p].join("/")}else c.name=[e[0],c.name].join("/");return c}),l))))}}return n.\u0275fac=function(e){return new(e||n)(k(Ua))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),B6=(()=>{class n{constructor(e,i,r){this.actions$=e,this.store=i,this.dataSource=r,this.runTableShown$=this.actions$.pipe(ei(Vh),N(({experimentIds:o})=>o),Yn((o,s)=>o.join("")===s.join(""))),this.navigated$=this.actions$.pipe(ei(Ps),Bt(this.store.select(lr)),ke(([,o])=>Boolean(o)),N(([,o])=>o),Yn((o,s)=>o.join("")===s.join(""))),this.loadHparamsOnReload$=this.actions$.pipe(ei(cs,Fs),Bt(this.store.select(lr)),ke(([,o])=>Boolean(o)),N(([,o])=>o)),this.loadHparamsData$=ar(()=>tn(this.navigated$,this.runTableShown$,this.loadHparamsOnReload$).pipe(Bt(this.store.select(md),this.store.select(No)),ke(([,o])=>o),ke(([,,o])=>o?.routeKind===wn.EXPERIMENT||o?.routeKind===wn.COMPARE_EXPERIMENT),ac(10),Jn(([o])=>this.loadHparamsForExperiments(o)),N(o=>pv(o))))}loadHparamsForExperiments(e){return this.dataSource.fetchExperimentInfo(e).pipe(Jn(i=>this.dataSource.fetchSessionGroups(e,i).pipe(zr(r=>r instanceof Al&&400===r.status?Ht([]):ea(()=>r)),N(r=>({hparamsAndMetricsSpecs:i,sessionGroups:r})))))}}return n.\u0275fac=function(e){return new(e||n)(k(xo),k(Ae),k(kS))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),V6=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({providers:[kS],imports:[Tr.forFeature(OS,N6),to.forFeature([B6])]}),n})(),FS=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[V6]}),n})(),H6="data/plugin/hparams";function _ge(n,t){return`${t}/${n}`}function bge(n){let t;return t=function(n){return n.hasOwnProperty("domainDiscrete")}(n)?{type:gn.DISCRETE,values:n.domainDiscrete}:function(n){return n.hasOwnProperty("domainInterval")}(n)?{...n.domainInterval,type:gn.INTERVAL}:{type:gn.INTERVAL,minValue:-1/0,maxValue:1/0},{description:n.description,displayName:n.displayName,name:n.name,type:n.type,domain:t}}function vge(n){return{...n,tag:n.name.tag}}var z6=(()=>{class n{constructor(e){this.http=e}fetchRuns(e){return this.http.get(`/experiment/${e}/data/runs`).pipe(N(i=>i.map(r=>({id:_ge(r,e),name:r,startTime:0}))))}fetchHparamsMetadata(e){return this.http.post(`/experiment/${e}/${H6}/experiment`,{experimentName:e},{},"request").pipe(N(r=>{let o=[];for(let a of r.hparamInfos)o.push({hparam:a.name});for(let a of r.metricInfos)o.push({metric:a.name});return{experimentHparamsInfo:r,listSessionRequestParams:{experimentName:e,allowedStatuses:[Ns.STATUS_FAILURE,Ns.STATUS_RUNNING,Ns.STATUS_SUCCESS,Ns.STATUS_UNKNOWN],colParams:o,startIndex:0,sliceSize:1e6}}}),hn(({experimentHparamsInfo:r,listSessionRequestParams:o})=>this.http.post(`/experiment/${e}/${H6}/session_groups`,o,{},"request").pipe(N(s=>({experimentHparamsInfo:r,sessionGroupsList:s})))),N(({experimentHparamsInfo:r,sessionGroupsList:o})=>{let s={};for(let a of o.sessionGroups){let l=Object.entries(a.hparams).map(c=>{let[d,u]=c;return{name:d,value:u}});for(let c of a.sessions)for(let d of c.metricValues){let p=`${e}/${d.name.group?`${c.name}/${d.name.group}`:c.name}`,f=s[p]||{metrics:[],hparams:l};f.metrics.push({tag:d.name.tag,trainingStep:d.trainingStep,value:d.value}),s[p]=f}}return{hparamSpecs:r.hparamInfos.map(bge),metricSpecs:r.metricInfos.map(vge),runToHparamsAndMetrics:s}}),zr(r=>r instanceof Al&&400===r.status?Ht({hparamSpecs:[],metricSpecs:[],runToHparamsAndMetrics:{}}):ea(r)))}}return n.\u0275fac=function(e){return new(e||n)(k(Ua))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),U6=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({providers:[{provide:RS,useClass:z6}]}),n})(),j6=q(Er("alerts"),n=>n.latestAlert),LS="experiments",G6=q(Er(LS),n=>n.data),BS=q(G6,(n,t)=>{let{experimentId:e}=t;return n.experimentMap[e]||null}),W6=q(G6,lr,(n,t)=>(t??[]).map(e=>n.experimentMap[e]).filter(Boolean).reduce((e,i)=>(e[i.id]=i.name,e),{}));function VS(n,t,e){return n<t?t:n>e?e:n}function Uh(n,t,e){let i=VS(n.start.step,t,e),r=n.end?VS(n.end.step,t,e):null;return{startStep:i,endStep:r,clipped:i!==n.start.step||r!==(n.end?.step??null)}}function HS(n,t){let e=t[n.id];return e&&e.visible&&!Boolean(e.aux)}function AF(n,t){return t?n:{start:n.start,end:null}}function RF(n,t,e){return AF(function(n,{minStep:t,maxStep:e}){return{start:{step:VS(n.start.step,t,e)},end:n.end?{step:VS(n.end.step,t,e)}:null}}(n,t),e)}var zn=(()=>{return(n=zn||(zn={})).SCALARS="scalars",n.HISTOGRAMS="histograms",n.IMAGES="images",zn;var n})(),Pi=(()=>{return(n=Pi||(Pi={})).STEP="step",n.RELATIVE="relative",n.WALL_TIME="walltime",Pi;var n})(),gv="timeseries";function Z6(n){return n===zn.SCALARS||n===zn.HISTOGRAMS||n===zn.IMAGES}var wge=[zn.IMAGES];function ua(n){return wge.includes(n)}var Sge=[zn.HISTOGRAMS,zn.IMAGES];function pa(n){return Sge.includes(n)}function PF(n){return pa(n.plugin)}var Tc=class{};function US(n){return n.hasOwnProperty("error")}var OF="data/plugin/timeseries";function K6(n){let t=n.indexOf("/");return{run:n.substring(t+1),experimentId:n.substring(0,t)}}function $6(n,t){return`${t}/${n}`}function J6(n,t){let{runToSeries:e,run:i,...r}=n,o={...r};return e&&(o.runToSeries=kF(e,t)),i&&(o.runId=$6(i,t)),o}function kF(n,t){let e={};for(let i in n)n.hasOwnProperty(i)&&(e[$6(i,t)]=n[i]);return e}var eW=(()=>{class n{constructor(e,i){this.http=e,this.store=i}fetchTagMetadata(e){let i=e.map(o=>this.http.get(`/experiment/${o}/${OF}/tags`).pipe(N(a=>function(n,t){let e={};for(let i of Object.keys(n)){let r=i;if(ua(r)){let{tagRunSampledInfo:o,...s}=n[r],a={};for(let l in o)o.hasOwnProperty(l)&&(a[l]=kF(o[l],t));e[r]={...s,tagRunSampledInfo:a}}else{let{runTagInfo:o,...s}=n[r];e[r]={...s,runTagInfo:kF(o,t)}}}return e}(a,o)))),r=this.store.select(vu).pipe(ke(Boolean),Yt(1),Bt(this.store.select(cS)),N(([,o])=>o));return co(i).pipe(Bt(r),N(([o,s])=>{let a=function(n){let t={};for(let e of n)for(let i of Object.values(zn))if(ua(i)){t[i]=t[i]||{tagDescriptions:{},tagRunSampledInfo:{}};let{tagDescriptions:r,tagRunSampledInfo:o}=e[i];t[i].tagDescriptions={...t[i].tagDescriptions,...r};let s=t[i].tagRunSampledInfo;for(let a of Object.keys(o)){s[a]=s[a]||{};for(let l of Object.keys(o[a]))s[a][l]=o[a][l]}}else{t[i]=t[i]||{tagDescriptions:{},runTagInfo:{}};let{tagDescriptions:r,runTagInfo:o}=e[i];t[i].tagDescriptions={...t[i].tagDescriptions,...r},t[i].runTagInfo={...t[i].runTagInfo,...o}}return t}(o);return s||(a[zn.IMAGES]={tagDescriptions:{},tagRunSampledInfo:{}}),a}))}fetchTimeSeries(e){let i=e.map(r=>{if(pa(r.plugin)){let{runId:l,...c}=r,{run:d,experimentId:u}=K6(l),p={...c,run:d};return this.fetchTimeSeriesBackendRequest(p,u).pipe(N(({response:f,experimentId:m})=>J6(f,m)))}let{experimentIds:o,...s}=r;return co(o.map(l=>this.fetchTimeSeriesBackendRequest(s,l))).pipe(N(l=>{let{runToSeries:c,error:d,...u}=l[0].response,p=u;for(let{response:f,experimentId:m}of l){let b=J6(f,m);if(p.error)continue;let{runToSeries:M,error:y}=b;if(y)p.error=y,p.runToSeries=void 0;else{p.runToSeries=p.runToSeries||{};for(let x of Object.keys(M))p.runToSeries[x]=M[x]}}return p}))});return co(i)}fetchTimeSeriesBackendRequest(e,i){let r=new FormData;return r.append("requests",JSON.stringify([e])),this.http.post(`/experiment/${i}/${OF}/timeSeries`,r).pipe(N(o=>({response:o[0],experimentId:i})))}imageUrl(e){return`${OF}/imageData?imageId=${e}`}downloadUrl(e,i,r,o){let l,{run:s,experimentId:a}=K6(r);if(e!==zn.SCALARS)throw new Error(`Not implemented: downloadUrl for ${e} is not implemented yet`);if(l="scalars/scalars",!a)throw new Error("experimentId is empty; it is required to form downloadUrl.");return`/experiment/${a}/data/plugin/scalars/scalars?${new URLSearchParams({tag:i,run:s,format:o})}`}}return n.\u0275fac=function(e){return new(e||n)(k(Ua),k(Ae))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),Ige=new URLSearchParams(window.location.search),jS=(()=>{class n{getParams(){return Ige}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),_v="tb_feature_flag_storage_key",FF=(()=>{class n{constructor(e){this.queryParams=e}getFeatures(e,i){let r=e?this.getPartialFeaturesFromMediaQuery():{},o=function(n,t){return Object.entries(n).reduce((e,[i,r])=>{let o=function(n,t){let e=n.queryParamOverride;if(!e||!t.has(e))return null;let i=t.get(e);return null==i?null:n.parseValue(i)}(r,t);return null!==o&&(e[i]=o),e},{})}(i,this.queryParams.getParams());return{...r,...Object.fromEntries(Object.entries(this.getPersistentFeatureFlags()).filter(([a])=>i[a])),...o}}persistFeatureFlags(e){let r={...this.getPersistentFeatureFlags(),...e};window.localStorage.setItem(_v,JSON.stringify(r))}resetPersistedFeatureFlag(e){let i=this.getPersistentFeatureFlags();if(null!=i[e]){if(delete i[e],0===Object.keys(i).length)return void window.localStorage.removeItem(_v);window.localStorage.setItem(_v,JSON.stringify(i))}}resetAllPersistedFeatureFlags(){window.localStorage.removeItem(_v)}getPersistentFeatureFlags(){let e=window.localStorage.getItem(_v);return null==e?{}:JSON.parse(e)}getPartialFeaturesFromMediaQuery(){let e={};return window.matchMedia("(prefers-color-scheme: dark)").matches&&(e.defaultEnableDarkMode=!0),e}}return n.\u0275fac=function(e){return new(e||n)(k(jS))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),GS=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),iW=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({providers:[FF,jS,{provide:GS,useClass:FF}]}),n})(),bv=_e("[FEATURE FLAG] Partial Feature Flags Loaded",{_as:"props",_p:void 0}),WS=_e("[FEATURE FLAG] Enable Dark Mode Override Changed",{_as:"props",_p:void 0}),mf=_e("[FEATURE FLAG] Store the feature flags in persistent localStorage",{_as:"props",_p:void 0}),xu=_e("[FEATURE FLAG] Reset feature flag overrides",{_as:"props",_p:void 0}),jh=_e("[FEATURE FLAG] Reset all feature flag overrides"),rW=_e("[FEATURE FLAG] Effects Init"),oW=(()=>{class n{constructor(e,i,r){this.actions$=e,this.store=i,this.dataSource=r,this.tfFeatureFlags={ref:document.createElement("tf-feature-flags").tf_feature_flags},this.getFeatureFlags$=ar(()=>this.actions$.pipe(ei(rW),Li(this.store.select(h6),this.store.select(cf)),N(([,o,s])=>{let a=this.dataSource.getFeatures(o,s);return bv({features:a})}))),this.updatePolymerFeatureFlags$=ar(()=>this.actions$.pipe(ei(bv),Bt(this.store.select(ks),this.store.select(Ph)),Nt(([,o,s])=>{this.tfFeatureFlags.ref.setFeatureFlags(o,s)})),{dispatch:!1}),this.storeFeatureFlag$=ar(()=>this.actions$.pipe(ei(mf),Nt(({flags:o})=>{this.dataSource.persistFeatureFlags(o)})),{dispatch:!1}),this.resetFeatureFlagOverrides$=ar(()=>this.actions$.pipe(ei(xu),Nt(({flags:o})=>{o.forEach(s=>{this.dataSource.resetPersistedFeatureFlag(s)})})),{dispatch:!1}),this.resetAllFeatureFlagOverrides$=ar(()=>this.actions$.pipe(ei(jh),Nt(()=>{this.dataSource.resetAllPersistedFeatureFlags()})),{dispatch:!1})}ngrxOnInitEffects(){return rW()}}return n.\u0275fac=function(e){return new(e||n)(k(xo),k(Ae),k(GS))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),lW=(()=>{class n{constructor(e){this.store=e}intercept(e,i){return this.store.pipe(un(Ph),function(n,t){let e=arguments.length>=2;return i=>i.pipe(n?ke((r,o)=>n(r,o,i)):is,Yt(1),e?function(n){return qt((t,e)=>{let i=!1;t.subscribe(Vt(e,r=>{i=!0,e.next(r)},()=>{i||e.next(n),e.complete()}))})}(t):K4(()=>new Om))}(),Jn(r=>(e=e.clone({headers:e.headers.set("X-TensorBoard-Feature-Flags",JSON.stringify(r))}),i.handle(e))))}}return n.\u0275fac=function(e){return new(e||n)(k(Ae))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})();function Gh(n){return"false"!==n}var n,NF={scalarsBatchSize:{defaultValue:void 0,queryParamOverride:"scalarsBatchSize",parseValue:parseInt},enabledExperimentalPlugins:{defaultValue:[],queryParamOverride:"experimentalPlugin",parseValue:function(n){return n?n.split(","):[]}},forceSvg:{defaultValue:!1,queryParamOverride:"forceSVG",parseValue:Gh},enableDarkModeOverride:{defaultValue:null,queryParamOverride:null},defaultEnableDarkMode:{defaultValue:!1,queryParamOverride:"darkMode",parseValue:Gh},isAutoDarkModeAllowed:{defaultValue:!0,queryParamOverride:null},inColab:{defaultValue:!1,queryParamOverride:"tensorboardColab",parseValue:Gh},metricsImageSupportEnabled:{defaultValue:!0,queryParamOverride:null},showFlags:{defaultValue:void 0,queryParamOverride:"showFlags",parseValue:n=>n},enableScalarColumnCustomization:{defaultValue:!1,queryParamOverride:"enableScalarColumnCustomization",parseValue:Gh},enableHparamsInTimeSeries:{defaultValue:!0,queryParamOverride:"enableHparamsInTimeSeries",parseValue:Gh},enableSuggestedCards:{defaultValue:!1,queryParamOverride:"enableSuggestedCards",parseValue:Gh}},LF={isFeatureFlagsLoaded:!1,defaultFlags:(n=NF,Object.entries(n).reduce((t,[e,i])=>(t[e]=i.defaultValue,t),{})),metadata:NF,flagOverrides:{}},BF=new ie("[Feature Flag] Store Config");function dW(){return{initialState:LF}}var Nge=br(LF,ye(bv,(n,{features:t})=>({...n,isFeatureFlagsLoaded:!0,flagOverrides:{...n.flagOverrides,...t}})),ye(WS,(n,{enableDarkMode:t})=>({...n,flagOverrides:{...n.flagOverrides,enableDarkModeOverride:t}})),ye(mf,(n,t)=>({...n,flagOverrides:{...n.flagOverrides,...t.flags}})),ye(xu,(n,t)=>{if(!t||!t.flags||!t.flags.length)return n;let e={...n.flagOverrides};return t.flags.forEach(i=>{delete e[i]}),{...n,flagOverrides:e}}),ye(jh,n=>({...n,flagOverrides:{}})),ye(Il,(n,{partialSettings:t})=>{if(!t.themeOverride)return n;let e;switch(t.themeOverride){case Os.BROWSER_DEFAULT:e=null;break;case Os.DARK:e=!0;break;case Os.LIGHT:e=!1}return{...n,flagOverrides:{...n.flagOverrides,enableDarkModeOverride:e}}}));function uW(n,t){return Nge(n,t)}function Lge(){return q(lS,n=>null===n?{themeOverride:Os.BROWSER_DEFAULT}:{themeOverride:n?Os.DARK:Os.LIGHT})}var Wh=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({providers:[{provide:BF,useFactory:dW},{provide:bF,useClass:lW,multi:!0}],imports:[iW,Tr.forFeature(aS,uW,BF),to.forFeature([oW]),Ki.defineGlobalSetting(Lge)]}),n})(),qS=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({providers:[{provide:Tc,useClass:eW}],imports:[Wh,Oh]}),n})(),oo=(()=>(function(n){n.DEFAULT="default",n.ALPHABETICAL="alphabetical",n.ASCENDING="ascending",n.DESCENDING="descending",n.NEAREST="nearest",n.NEAREST_Y="nearest_Y"}(oo||(oo={})),oo))(),YS="metrics",Ls=(()=>(function(n){n[n.NONE=0]="NONE",n[n.OVERRIDE_AS_ENABLED=1]="OVERRIDE_AS_ENABLED",n[n.OVERRIDE_AS_DISABLED=2]="OVERRIDE_AS_DISABLED"}(Ls||(Ls={})),Ls))(),XS={cardMinWidth:null,tooltipSort:oo.ALPHABETICAL,ignoreOutliers:!0,xAxisType:Pi.STEP,hideEmptyCards:!0,scalarSmoothing:.6,scalarPartitionNonMonotonicX:!1,imageBrightnessInMilli:1e3,imageContrastInMilli:1e3,imageShowActualSize:!1,histogramMode:Dr.OFFSET},Bge=.1;function gd(n,t,e,i){return n[t].hasOwnProperty(e)?ua(t)?n[t][e].hasOwnProperty(i)?n[t][e][i]:null:n[t][e]:null}function QS(n,t,e,i){if(ua(t)){let s={...n[t]},a=function(n,t,e){let r=n.hasOwnProperty(t)?{...n[t]}:{},o=r.hasOwnProperty(e);return r[e]=o?{...r[e]}:{runToSeries:{},runToLoadState:{}},r}(s,e,i);return s[e]=a,s}let r={...n[t]},o=r.hasOwnProperty(e);return r[e]=o?{...r[e]}:{runToSeries:{},runToLoadState:{}},r}function VF(n){return JSON.stringify(n)}function ZS(n,t,e){let i={...e};for(let r of t)i[r]=n;return i}function qh(n,t,e,i){if(ua(t)){let o=n[t].tagRunSampledInfo;return o.hasOwnProperty(e)?Object.keys(o[e]).filter(a=>i<o[e][a].maxSamplesPerStep):[]}let r=n[t].tagToRuns;return r.hasOwnProperty(e)?r[e]:[]}function zge(n,t){return n.plugin===t.plugin&&n.tag===t.tag&&n.sample===t.sample&&(n.runId===t.runId||!n.runId&&!t.runId)}function HF(n,t,e,i,r,o,s,a){let l=new Set(n),c=[];for(let u of n)for(let p of t)if(zge(e[p],u)){c.push(p),l.delete(u);break}if(!c.length)return{unresolvedImportedPinnedCards:n,cardMetadataMap:e,cardToPinnedCopy:i,cardToPinnedCopyCache:r,pinnedCardToOriginal:o,cardStepIndex:s,cardStateMap:a};let d={cardToPinnedCopy:i,cardToPinnedCopyCache:r,pinnedCardToOriginal:o,cardStepIndex:s,cardMetadataMap:e,cardStateMap:a};for(let u of c)d=zF(u,d.cardToPinnedCopy,d.cardToPinnedCopyCache,d.pinnedCardToOriginal,d.cardStepIndex,d.cardMetadataMap,a);return{...d,unresolvedImportedPinnedCards:[...l]}}function zF(n,t,e,i,r,o,s){if(t.has(n))return{cardToPinnedCopy:t,cardToPinnedCopyCache:e,pinnedCardToOriginal:i,cardStepIndex:r,cardMetadataMap:o,cardStateMap:s};let a=new Map(t),l=new Map(e),c=new Map(i),d={...r},u={...o},p={...s},f=function(n){return JSON.stringify({baseCardId:n})}(n);a.set(n,f),l.set(n,f),c.set(f,n),r.hasOwnProperty(n)&&(d[f]=r[n]);let m=o[n];if(!m)throw new Error("Cannot pin a card without metadata");return u[f]=m,p[n]&&(p[f]=p[n]),{cardToPinnedCopy:a,cardToPinnedCopyCache:l,pinnedCardToOriginal:c,cardStepIndex:d,cardMetadataMap:u,cardStateMap:p}}var Uge={MAX_PIN_COUNT:10};function KS(n){return n.pinnedCardToOriginal.size+n.unresolvedImportedPinnedCards.length<Uge.MAX_PIN_COUNT}function UF(n,t,e,i){let r={...n};return Object.keys(n).forEach(o=>{if(!o.includes('"plugin":"images"'))return;let s=jF(o,t,e),a=null;if(null===i.end)a=function(n,t){let e=t.indexOf(n);if(-1!==e)return{index:e,isClosest:!1};for(let i=0;i<t.length-1;i++){let r=t[i],o=t[i+1],s=(o-r)*Bge;if(n<r)return null;if(!(n>o)){if(n-r<=s)return{index:i,isClosest:!0};if(o-n<=s)return{index:i+1,isClosest:!0}}}return null}(i.start.step,s);else{let c=s[n[o].index],d=function(n,t){if(!n)return[];if(null===n.end)return-1!==t.indexOf(n.start.step)?[n.start.step]:[];let e=[];for(let i of t)i>=n.start.step&&i<=n.end.step&&e.push(i);return e}(i,s);a=function(n,t,e){if(0===n.length)return null;let i=n[0],r=n[n.length-1];return e>r?{index:t.indexOf(r),isClosest:!1}:e<i?{index:t.indexOf(i),isClosest:!1}:null}(d,s,c)}null!==a&&(r[o]=a)}),r}function jF(n,t,e){if(!t.hasOwnProperty(n))return[];let{plugin:i,tag:r,sample:o,runId:s}=t[n];if(null===s)return[];let a=gd(e,i,r,o);return null!==a&&a.runToSeries.hasOwnProperty(s)?a.runToSeries[s].map(l=>l.step):[]}function GF(n){let{dataMinMax:t,userViewBox:e}=n,i=e?.x;if(!i)return t;let r=i[0]<i[1]?i[0]:i[1],o=r===i[0]?i[1]:i[0];return{minStep:Math.ceil(r),maxStep:Math.floor(o)}}function JS(n,t){switch(n){case Ls.OVERRIDE_AS_ENABLED:return!0;case Ls.OVERRIDE_AS_DISABLED:return!1;default:return t}}function $S(n,t,e,i){return e?t:JS(n[i]?.rangeSelectionOverride,t)}function Yh(n){let t=new Map;return(...e)=>{let i=JSON.stringify(e);if(t.has(i))return t.get(i);{let r=n(...e);return t.set(i,r),r}}}var Hi=Er(YS),vv=q(Hi,n=>n.tagMetadataLoadState),_W=q(Hi,n=>n.tagMetadata),Yge=q(Hi,n=>n.cardList),_d=q(Hi,(n,t)=>{if(!n.cardMetadataMap.hasOwnProperty(t))return Te.NOT_LOADED;let{plugin:e,tag:i,runId:r,sample:o}=n.cardMetadataMap[t],s=gd(n.timeSeriesData,e,i,o);if(!s)return Te.NOT_LOADED;let a=s.runToLoadState;if(r)return a.hasOwnProperty(r)?a[r]:Te.NOT_LOADED;let l=qh(n.tagMetadata,e,i,o);if(!l.length)throw new Error("Cannot load a card whose tag has no runs");return l.every(c=>a[c]===Te.LOADED)?Te.LOADED:l.some(c=>a[c]===Te.LOADING)?Te.LOADING:Te.NOT_LOADED}),Xge=Yh(n=>q(t=>t,t=>{let{plugin:e,tag:i,sample:r}=n,o=gd(t.timeSeriesData,e,i,r);return o?o.runToSeries:null})),Cu=q(Hi,(n,t)=>n.cardMetadataMap.hasOwnProperty(t)?Xge(n.cardMetadataMap[t])(n):null),WF=q(Hi,n=>n.cardMetadataMap),Wa=q(WF,(n,t)=>n.hasOwnProperty(t)?n[t]:null),qa=q(Hi,n=>n.cardStateMap),Qge=q(Hi,n=>n.visibleCardMap),bW=q(Qge,n=>new Set(n.values())),e1=q(Yge,WF,(n,t)=>n.filter(e=>t.hasOwnProperty(e)).map(e=>({cardId:e,...t[e]}))),qF=q(Hi,(n,t)=>n.cardStepIndex.hasOwnProperty(t)?n.cardStepIndex[t]:null),vW=q(Hi,(n,t)=>jF(t,n.cardMetadataMap,n.timeSeriesData)),yW=q(Hi,n=>n.cardToPinnedCopy),Zge=q(Hi,n=>n.pinnedCardToOriginal),yv=q(yW,WF,(n,t)=>[...n.values()].filter(e=>t.hasOwnProperty(e)).map(e=>({cardId:e,...t[e]}))),Mu=q(yW,Zge,(n,t,e)=>n.has(e)||t.has(e)),xW=q(Hi,n=>n.unresolvedImportedPinnedCards),CW=q(Hi,n=>KS(n)),Pl=q(Hi,n=>({...n.settings,...n.settingOverrides})),MW=q(Hi,n=>n.settingOverrides),Xh=q(Pl,n=>n.cardMinWidth),hf=q(Pl,n=>n.tooltipSort),gf=q(Pl,n=>n.ignoreOutliers),Ol=q(Pl,n=>n.xAxisType),t1=q(Pl,n=>n.histogramMode),wW=q(Pl,n=>n.hideEmptyCards),bd=q(Pl,n=>n.scalarSmoothing),n1=q(Pl,n=>n.scalarPartitionNonMonotonicX),i1=q(Pl,n=>n.imageBrightnessInMilli),r1=q(Pl,n=>n.imageContrastInMilli),o1=q(Pl,n=>n.imageShowActualSize),kl=q(Hi,n=>n.tagFilter),s1=q(Hi,(n,t)=>Boolean(n.tagGroupExpanded.get(t))),wu=q(Hi,n=>n.linkedTimeEnabled),xv=q(Hi,n=>n.stepSelectorEnabled),Su=q(Hi,n=>n.rangeSelectionEnabled),YF=q(Hi,n=>{let{min:t,max:e}=n.stepMinMax;return{min:t===1/0?0:t,max:e===-1/0?1e3:e}}),XF=q(Hi,YF,(n,t)=>n.linkedTimeSelection?n.linkedTimeSelection:{start:{step:t.max},end:null}),Eu=q(Hi,XF,(n,t)=>n.linkedTimeEnabled?t:null),Dc=q(Hi,n=>n.filteredPluginTypes),a1=q(Hi,n=>n.isSettingsPaneOpen),l1=q(Hi,n=>n.isSlideoutMenuOpen),SW=q(Hi,n=>n.tableEditorSelectedTab),c1=Yh(n=>q(qa,Su,wu,(t,e,i)=>$S(t,e,i,n))),EW=q(qa,(n,t)=>{if(n[t])return GF(n[t])}),TW=q(qa,(n,t)=>n[t]?.dataMinMax),QF=q(qa,(n,t)=>n[t]?.userViewBox??null),DW=q(qa,xv,Su,wu,Eu,(n,t,e,i,r,o)=>{let s=n[o];if(!s)return;let a=GF(s);if(!a)return;if(i&&r)return RF(r,a,e);if(!JS(s.stepSelectionOverride,t))return;let l=JS(s.rangeSelectionOverride,e),c=s.timeSelection;return c||(c={start:{step:a.minStep},end:{step:a.maxStep}}),l?c.end||(c={start:{step:a.minStep},end:c.start}):c={start:c.end??c.start,end:null},RF(c,a,l)}),Cv=q(Hi,n=>n.singleSelectionHeaders),Mv=q(Hi,n=>n.rangeSelectionHeaders),d1=Yh(n=>q(c1(n),Cv,Mv,(t,e,i)=>t?i:e)),AW=Er("notification"),Ic=(q(AW,n=>n.notifications),q(AW,n=>n.lastReadTimestampInMs??-1),(()=>(function(n){n[n.EXPERIMENT_NAME=0]="EXPERIMENT_NAME",n[n.HPARAM=1]="HPARAM",n[n.METRIC=2]="METRIC",n[n.RUN_NAME=3]="RUN_NAME"}(Ic||(Ic={})),Ic))()),Yi=(()=>(function(n){n[n.RUN=0]="RUN",n[n.EXPERIMENT=1]="EXPERIMENT",n[n.REGEX=2]="REGEX"}(Yi||(Yi={})),Yi))();function Sv(n,t,e){let i={},r=[],o={matches:i,nonMatches:r};switch(n.key){case Yi.RUN:for(let a of t)i[a.id]=[a];break;case Yi.EXPERIMENT:for(let a of t){let l=e[a.id],c=i[l]||[];c.push(a),i[l]=c}break;case Yi.REGEX:if(!n.regexString)break;let s;try{s=new RegExp(n.regexString)}catch{break}for(let a of t){let l=a.name.match(s);if(l){let d=l.length>1?JSON.stringify(l.slice(1)):"pseudo_group",u=i[d]||[];u.push(a),i[d]=u}else r.push(a)}}return o}function p1(n,t){return n===Yi.REGEX?{key:n,regexString:t??""}:{key:n}}var Tu={};FA(Tu,{getDashboardDefaultHparamFilters:()=>KF,getDashboardHparamFilterMap:()=>m1,getDashboardHparamsAndMetricsSpecs:()=>f1,getDashboardMetricsFilterMap:()=>h1,getDashboardSessionGroups:()=>ZF,getExperimentsHparamsAndMetricsSpecs:()=>o0e,getHparamFilterMap:()=>$ge,getHparamFilterMapFromExperimentIds:()=>e0e,getMetricFilterMap:()=>i0e,getMetricFilterMapFromExperimentIds:()=>r0e});var fa=Er(OS);function PW(n,t){let e=[];for(let i of t)!n.specs[i]||e.push(n.specs[i].hparam.defaultFilters);return hv(e)}var Kge=q(fa,PW);function OW(n,t,e){let i=ff(e);return new Map([...t,...n.filters[i]?.hparams??[]])}var $ge=q(fa,Kge,OW);function e0e(n,t){return q(fa,function(n){return q(fa,t=>PW(t,n))}(n),(e,i)=>OW(e,t?i:new Map,n))}function kW(n,t){let e=[];for(let i of t)!n.specs[i]||e.push(n.specs[i].metric.defaultFilters);return PS(e)}var t0e=q(fa,kW);function FW(n,t,e){let i=ff(e);return new Map([...t,...n.filters[i]?.metrics??[]])}var i0e=q(fa,t0e,FW);function r0e(n,t){return q(fa,function(n){return q(fa,t=>kW(t,n))}(n),(e,i)=>FW(e,t?i:new Map,n))}var o0e=q(fa,(n,t)=>function(...n){let t=new Map,e=new Map,i=new Map,r=new Map,o=[];for(let s of n){for(let a of s.hparams)if(e.has(a.name)||e.set(a.name,new Set),e.get(a.name).add(a.displayName),t.has(a.name)){let l=t.get(a.name),c=a;if(l.type!==c.type&&o.push(`Hparam, ${c.name}, types have to match. Got: ${l.type} vs. ${c.type}`),l.domain.type===gn.INTERVAL&&c.domain.type===gn.INTERVAL)(l.domain.minValue!==c.domain.minValue||l.domain.maxValue!==c.domain.maxValue)&&o.push(`Hparam, ${c.name}, domains have to match. Got: ${l.domain} vs. ${c.domain}`);else if(l.domain.type===gn.DISCRETE&&c.domain.type===gn.DISCRETE){let d=new Set([...l.domain.values,...c.domain.values]);(l.domain.values.length!==c.domain.values.length||l.domain.values.length!==d.size)&&o.push(`Hparam, ${c.name}, domains have to match. Got: ${l.domain} vs. ${c.domain}`)}else o.push(`Hparam, ${c.name}, domains have to match. Got: ${l.domain} vs. ${c.domain}`)}else t.set(a.name,{...a});for(let a of s.metrics)if(r.has(a.tag)||r.set(a.tag,new Set),r.get(a.tag).add(a.displayName),i.has(a.tag)){let l=i.get(a.tag);l.datasetType!==a.datasetType&&o.push(`Metric, ${a.tag}, datasetTypes have to match. Got: ${l.datasetType} vs. ${a.datasetType}`)}else i.set(a.tag,{...a})}if(o.length)throw new Error(`Validation error:\n${o.join("\n")}`);return{hparams:[...t].map(([s,a])=>({...a,displayName:[...e.get(s)].join(" or ")})),metrics:[...i].map(([s,a])=>({...a,displayName:[...r.get(s)].join(" or ")}))}}(...t.experimentIds.map(e=>{let i=n.specs[e];return i?{hparams:i.hparam.specs,metrics:i.metric.specs}:null}).filter(Boolean))),f1=q(fa,n=>n.dashboardSpecs),ZF=q(fa,n=>n.dashboardSessionGroups),KF=q(f1,n=>new Map(n.hparams.map(e=>[e.name,F6(e)]))),m1=q(fa,n=>n.dashboardFilters.hparams),h1=q(fa,n=>n.dashboardFilters.metrics),NW=Er("runs"),ds=q(NW,n=>n.data),LW=q(ds,n=>n.runIdToExpId),g1=q(ds,(n,t)=>n.runIdToExpId[t.runId]??null),_1=q(ds,(n,t)=>n.runMetadata[t.runId]??null),Du=q(ds,(n,t)=>(n.runIds[t.experimentId]||[]).filter(i=>Boolean(n.runMetadata[i])).map(i=>n.runMetadata[i])),s0e=q(ZF,lr,ds,(n,t,e)=>{if(!t)return{};let i=[];for(let a of t)i.push(...e.runIds[a]||[]);let r={};for(let a of n){let l=Object.entries(a.hparams).map(c=>{let[d,u]=c;return{name:d,value:u}});for(let c of a.sessions)r[c.name]=l}let o=Object.keys(r).sort((a,l)=>l.length-a.length),s={};for(let a of i)for(let l of o)if(a.startsWith(l)){s[a]={hparams:r[l],metrics:[]};break}return s}),b1=q(ds,lr,s0e,(n,t,e)=>t?t.map(i=>(n.runIds[i]||[]).filter(r=>Boolean(n.runMetadata[r])).map(r=>{let o={...n.runMetadata[r],experimentId:i};return o.hparams=e[r]?.hparams??null,o.metrics=e[r]?.metrics??null,o})).flat():[]),BW=q(ds,(n,t)=>n.runIds[t.experimentId]??[]),VW=q(ds,n=>new Map(Object.entries(n.runMetadata))),Ev=q(ds,(n,t)=>n.runsLoadState[t.experimentId]||{lastLoadedTimeInMs:null,state:Te.NOT_LOADED}),JF=q(ds,n=>null!==n.userSetGroupByKey?p1(n.userSetGroupByKey,n.colorGroupRegexString):null),HW=q(JF,ds,(n,t)=>n??t.initialGroupBy),vd=q(ds,n=>n.regexFilter),Tv=q(NW,n=>n.ui),$F=q(Tv,n=>n.paginationOption),e2=q(Tv,n=>n.sort),zW=q(Tv,n=>n.selectionState),UW=q(ds,n=>n.runColorOverrideForGroupBy),jW=q(ds,n=>n.defaultRunColorIdForGroupBy),v1=q(ds,n=>n.colorGroupRegexString),GW=q(Tv,n=>n.runsTableHeaders),WW=q(Tv,n=>n.sortingInfo),y1=_e("[Settings] Reload Enable Toggled"),x1=_e("[Settings] Reload Period Change",{_as:"props",_p:void 0}),C1=_e("[Settings] Page Size Change",{_as:"props",_p:void 0}),Bs={};FA(Bs,{getColorPalette:()=>a0e,getPageSize:()=>_f,getReloadEnabled:()=>Iv,getReloadPeriodInMs:()=>Av,getSettingsLoadState:()=>t2});var M1="settings",XW={state:Te.LOADED,lastLoadedTimeInMs:Date.now(),settings:{reloadPeriodInMs:3e4,reloadEnabled:!1,pageSize:12,colorPalette:{id:"default",name:"Defalt",colors:[{name:"Slate",lightHex:"#425066",darkHex:"#8e98a3"},{name:"Cyan",lightHex:"#12b5cb",darkHex:"#12b5cb"},{name:"Pink",lightHex:"#e52592",darkHex:"#e52592"},{name:"Yellow",lightHex:"#f9ab00",darkHex:"#f9ab00"},{name:"Purple",lightHex:"#9334e6",darkHex:"#9334e6"},{name:"Light Green",lightHex:"#7cb342",darkHex:"#7cb342"},{name:"Orange",lightHex:"#e8710a",darkHex:"#e8710a"}],inactive:{name:"Gray",lightHex:"#e0e0e0",darkHex:"#3b3b3b"}}}},Dv=Er(M1),t2=q(Dv,n=>n.state),Iv=q(Dv,n=>n.settings.reloadEnabled),Av=q(Dv,n=>n.settings.reloadPeriodInMs),_f=q(Dv,n=>n.settings.pageSize),a0e=q(Dv,n=>n.settings.colorPalette);function Qh(n,t,e){if(!t)return!0;let i;try{i=new RegExp(t,"i")}catch{return!1}let r=[n.runName];return e&&r.push(n.experimentAlias.aliasText,`${n.experimentAlias.aliasText}/${n.runName}`),r.some(o=>i.test(o))}var l0e=q(lr,zW,LW,(n,t,e)=>{if(!n)return new Map;let i=new Map;for(let[r,o]of t.entries()){let s=e[r];s&&n.indexOf(s)>=0&&i.set(r,o)}return i}),c0e=q(za,b1,(n,t)=>{let e=new Map;for(let i of t)e.set(i.id,{runName:i.name,experimentAlias:n[i.experimentId]});return e}),Iu=q(lr,l0e,vd,c0e,Ha,(n,t,e,i,r)=>{if(!n)return null;let o=r===wn.COMPARE_EXPERIMENT,s=new Map;for(let[a,l]of t.entries()){let c=i.get(a);s.set(a,Qh(c,e,o)&&l)}return s}),Au=q(Bs.getColorPalette,jW,UW,Rl,(n,t,e,i)=>{let r={};return t.forEach((o,s)=>{let a=i?n.inactive.darkHex:n.inactive.lightHex;if(e.has(s))a=e.get(s);else if(o>=0){let l=n.colors[o%n.colors.length];a=i?l.darkHex:l.lightHex}r[s]=a}),r}),QW=(()=>{class n{constructor(e,i,r){this.actions$=e,this.store=i,this.runsDataSource=r,this.loadRunsOnRunTableShown$=ar(()=>this.actions$.pipe(ei(Vh),hn(({experimentIds:o})=>this.getExperimentsWithLoadState(o,a=>a===Te.FAILED||a===Te.NOT_LOADED).pipe(ke(a=>!!a.length),hn(a=>this.fetchAllRunsList(o,a))))),{dispatch:!1}),this.experimentsWithStaleRunsOnRouteChange$=this.actions$.pipe(ei(Ps),Bt(this.store.select(No)),Yn(([,o],[,s])=>Fo(o,s)),Bt(this.store.select(lr)),ke(([,o])=>!!o),N(([,o])=>o),hn(o=>this.getExperimentsWithLoadState(o,s=>s===Te.FAILED||s===Te.NOT_LOADED).pipe(N(s=>({experimentIds:o,experimentIdsToBeFetched:s}))))),this.experimentsWithStaleRunsOnReload$=this.actions$.pipe(ei(cs,Fs),Bt(this.store.select(lr)),ke(([,o])=>!!o),N(([,o])=>o),hn(o=>this.getExperimentsWithLoadState(o,s=>s!==Te.LOADING).pipe(N(s=>({experimentIds:o,experimentIdsToBeFetched:s}))))),this.loadRunsOnNavigationOrReload$=ar(()=>tn(this.experimentsWithStaleRunsOnRouteChange$,this.experimentsWithStaleRunsOnReload$).pipe(Bt(this.store.select(No)),ke(([,o])=>null!==o&&o.routeKind!==wn.CARD),hn(([{experimentIds:o,experimentIdsToBeFetched:s}])=>this.fetchAllRunsList(o,s))),{dispatch:!1}),this.removeHparamFilterWhenColumnIsRemoved$=ar(()=>this.actions$.pipe(ei(zh),Nt(({header:o})=>{o.type!==ht.HPARAM?o.type===ht.METRIC&&this.store.dispatch(mv({name:o.name})):this.store.dispatch(fv({name:o.name}))})),{dispatch:!1})}getRunsListLoadState(e){return this.store.select(Ev,{experimentId:e}).pipe(Yt(1))}getExperimentsWithLoadState(e,i){return co(e.map(r=>this.getRunsListLoadState(r))).pipe(N(r=>e.filter((o,s)=>i(r[s].state))))}fetchAllRunsList(e,i){return Ht({experimentIds:e,experimentIdsToBeFetched:i}).pipe(Nt(()=>{this.store.dispatch(MS({experimentIds:e,requestedExperimentIds:i}))}),hn(()=>{let r=new Set(i);return co(e.map(s=>r.has(s)?this.fetchRunsForExperiment(s):this.maybeWaitForRunsAndGetRuns(s)))}),N(r=>{let o={},s=[];for(let a of r)s.push(...a.runs),a.fromRemote&&(o[a.experimentId]={runs:a.runs,metadata:a.metadata});return{newRunsAndMetadata:o,runsForAllExperiments:s}}),Nt(({newRunsAndMetadata:r,runsForAllExperiments:o})=>{this.store.dispatch(yu({experimentIds:e,newRunsAndMetadata:r,runsForAllExperiments:o}))}),zr(r=>(this.store.dispatch(Bh({experimentIds:e,requestedExperimentIds:i})),Ht(null))),N(()=>null))}maybeWaitForRunsAndGetRuns(e){return this.store.select(Ev,{experimentId:e}).pipe(ke(i=>i.state!==Te.LOADING),Yt(1),hn(i=>i.state===Te.FAILED?ea(new Error("Pending request failed")):Ht(i)),Bt(this.store.select(Du,{experimentId:e})),N(([,i])=>({fromRemote:!1,experimentId:e,runs:i})))}fetchRunsForExperiment(e){return co([this.runsDataSource.fetchRuns(e),this.runsDataSource.fetchHparamsMetadata(e)]).pipe(N(([i,r])=>({fromRemote:!0,experimentId:e,runs:i,metadata:r})))}}return n.\u0275fac=function(e){return new(e||n)(k(xo),k(Ae),k(RS))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),Ya=(()=>(function(n){n.ASC="asc",n.DESC="desc",n.UNSET=""}(Ya||(Ya={})),Ya))(),{initialState:d0e,reducers:u0e}=uf({runColorOverrideForGroupBy:new Map,defaultRunColorIdForGroupBy:new Map,groupKeyToColorId:new Map,initialGroupBy:{key:Yi.RUN},userSetGroupByKey:null,colorGroupRegexString:"",regexFilter:""},{runIds:{},runIdToExpId:{},runMetadata:{},runsLoadState:{}},(n,t,e)=>Fo(t,e)?n:{...n,initialGroupBy:{key:e.routeKind===wn.COMPARE_EXPERIMENT?Yi.EXPERIMENT:Yi.RUN}}),p0e=br(d0e,ye(Eh,(n,{routeKind:t,partialState:e})=>{if(t!==wn.COMPARE_EXPERIMENT&&t!==wn.EXPERIMENT)return n;let r=e.runs.groupBy,o=e.runs.regexFilter??"";if(!r&&!o)return n;let{colorGroupRegexString:s,userSetGroupByKey:a}=n;return r&&(s=r.key===Yi.REGEX?r.regexString:n.colorGroupRegexString,a=r.key??null),{...n,colorGroupRegexString:s,regexFilter:o,userSetGroupByKey:a}}),ye(MS,(n,t)=>{let e={...n.runsLoadState};for(let i of t.requestedExperimentIds)e[i]=e[i]?{...e[i],state:Te.LOADING}:{lastLoadedTimeInMs:null,state:Te.LOADING};return{...n,runsLoadState:e}}),ye(yu,(n,t)=>{let e={...n.runIds},i={...n.runMetadata},r={...n.runIdToExpId},o={...n.runsLoadState};for(let s of Object.keys(t.newRunsAndMetadata)){let{runs:a,metadata:l}=t.newRunsAndMetadata[s];e[s]=a.map(({id:c})=>c),o[s]={...o[s],lastLoadedTimeInMs:Date.now(),state:Te.LOADED};for(let c of a){let d=l.runToHparamsAndMetrics[c.id];i[c.id]={...c,hparams:d?d.hparams:null,metrics:d?d.metrics:null},r[c.id]=s}}return{...n,runIds:e,runIdToExpId:r,runMetadata:i,runsLoadState:o}}),ye(Bh,(n,t)=>{let e={...n.runsLoadState};for(let i of t.requestedExperimentIds)e[i]=e[i]?{...e[i],state:Te.FAILED}:{lastLoadedTimeInMs:null,state:Te.FAILED};return{...n,runsLoadState:e}}),ye(yu,(n,{runsForAllExperiments:t})=>{let e=new Map(n.groupKeyToColorId),i=new Map(n.defaultRunColorIdForGroupBy),r=n.initialGroupBy;null!==n.userSetGroupByKey&&(r=p1(n.userSetGroupByKey,n.colorGroupRegexString));let o=Sv(r,t,n.runIdToExpId);Object.entries(o.matches).forEach(([s,a])=>{let l=e.get(s)??e.size;e.set(s,l);for(let c of a)i.set(c.id,l)});for(let s of o.nonMatches)i.set(s.id,-1);return{...n,defaultRunColorIdForGroupBy:i,groupKeyToColorId:e}}),ye(Hh,(n,{experimentIds:t,groupBy:e})=>{let i=new Map,r=new Map(n.defaultRunColorIdForGroupBy),s=Sv(e,t.flatMap(l=>n.runIds[l]).map(l=>n.runMetadata[l]),n.runIdToExpId);Object.entries(s.matches).forEach(([l,c])=>{let d=i.get(l)??i.size;i.set(l,d);for(let u of c)r.set(u.id,d)});for(let l of s.nonMatches)r.set(l.id,-1);let a=e.key===Yi.REGEX?e.regexString:n.colorGroupRegexString;return{...n,colorGroupRegexString:a,userSetGroupByKey:e.key,defaultRunColorIdForGroupBy:r,groupKeyToColorId:i,runColorOverrideForGroupBy:new Map}}),ye(TS,(n,{runId:t,newColor:e})=>{let i=new Map(n.runColorOverrideForGroupBy);return i.set(t,e),{...n,runColorOverrideForGroupBy:i}}),ye(uv,(n,t)=>({...n,regexFilter:t.regexString}))),f0e=pf(p0e,u0e),m0e={key:null,direction:Ya.UNSET},{initialState:h0e,reducers:g0e}=uf({paginationOption:{pageIndex:0,pageSize:10},sort:m0e,selectionState:new Map,runsTableHeaders:[{type:ht.RUN,name:"run",displayName:"Run",enabled:!0,sortable:!0,movable:!0,filterable:!1}],sortingInfo:{name:"run",order:io.ASCENDING}},{},(n,t,e)=>{if(!Fo(t,e)){if(e.routeKind===wn.COMPARE_EXPERIMENT&&!n.runsTableHeaders.find(i=>"experimentAlias"===i.name)){let i=[...n.runsTableHeaders,{type:ht.CUSTOM,name:"experimentAlias",displayName:"Experiment",enabled:!0,movable:!0,sortable:!0}];return{...n,runsTableHeaders:i}}if(t?.routeKind===wn.COMPARE_EXPERIMENT&&e.routeKind!==wn.COMPARE_EXPERIMENT){let i=n.runsTableHeaders.filter(r=>"experimentAlias"!==r.name);return{...n,runsTableHeaders:i}}}return n}),_0e=br(h0e,ye(SS,(n,{pageSize:t,pageIndex:e})=>({...n,paginationOption:{pageSize:t,pageIndex:e}})),ye(uv,(n,t)=>({...n,paginationOption:{...n.paginationOption,pageIndex:0}})),ye(ES,(n,t)=>({...n,sort:{key:t.key,direction:t.direction}})),ye(yu,(n,t)=>{let e=new Map(n.selectionState),i=t.runsForAllExperiments.length<=500;for(let r of t.runsForAllExperiments)e.has(r.id)||e.set(r.id,i);return{...n,selectionState:e}}),ye(cv,(n,{runId:t})=>{let e=new Map(n.selectionState);return e.set(t,!Boolean(e.get(t))),{...n,selectionState:e}}),ye(wS,(n,{runId:t})=>{let e=new Map;for(let i of n.selectionState.keys())e.set(i,t===i);return{...n,selectionState:e}}),ye(dv,(n,{runIds:t})=>{let e=new Map(n.selectionState),i=!t.every(r=>Boolean(e.get(r)));for(let r of t)e.set(r,i);return{...n,selectionState:e}}),ye(DS,(n,{header:t,index:e})=>{let i=[...n.runsTableHeaders];return void 0===e?i.push(t):i.splice(e,0,t),{...n,runsTableHeaders:i}}),ye(zh,(n,{header:t})=>{let e=n.runsTableHeaders.filter(({name:i})=>i!==t.name);return{...n,runsTableHeaders:e}}),ye(IS,(n,{newHeaderOrder:t})=>({...n,runsTableHeaders:t})),ye(AS,(n,{sortingInfo:t})=>({...n,sortingInfo:t}))),b0e=pf(_0e,g0e);function ZW(n,t){return rf({data:f0e,ui:b0e})(n,t)}function v0e(){return[{actionCreator:Bh,alertFromAction:()=>({localizedMessage:"Failed to fetch runs"})}]}var w1=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Tr.forFeature("runs",ZW),to.forFeature([QW]),U6,Sc.registerAlertActions(v0e),FS]}),n})(),yd=(()=>(function(n){n.RUNS_CHANGED="experimental.RunsChanged",n.GET_RUNS="experimental.GetRuns",n.GET_URL_DATA="experimental.GetURLPluginData",n.DATA_RELOADED="experimental.DataReloaded"}(yd||(yd={})),yd))(),JW=new WeakMap,Zh=new Set,n2=new Map,E1=new Map;function $W(n,t){return e=>{let i=E1.get(t),r=JW.get(i)||null;return n(r,e)}}window.addEventListener("message",n=>{if("experimental.bootstrap"!==n.data)return;let t=n.ports[0];if(!t)return;let e=n.source?n.source.frameElement:null;!e||function(n,t){let e=new class{constructor(t){this.port=t,this.id=0,this.responseWaits=new Map,this.listeners=new Map,this.port.addEventListener("message",e=>this.onMessage(e))}listen(t,e){this.listeners.set(t,e)}unlisten(t){this.listeners.delete(t)}async onMessage(t){let e=JSON.parse(t.data),i=e.type,r=e.id,o=e.payload,s=e.error;if(e.isReply){if(!this.responseWaits.has(r))return;let{resolve:u,reject:p}=this.responseWaits.get(r);return this.responseWaits.delete(r),void(s?p(new Error(s)):u(o))}let l=null,c=null;if(this.listeners.has(i)){let u=this.listeners.get(i);try{l=await u(o)}catch(p){c=p}}this.postMessage({type:i,id:r,payload:l,error:c,isReply:!0})}postMessage(t){this.port.postMessage(JSON.stringify(t))}sendMessage(t,e){let i=this.id++;return this.postMessage({type:t,id:i,payload:e,error:null,isReply:!1}),new Promise((o,s)=>{this.responseWaits.set(i,{resolve:o,reject:s})})}}(n);Zh.add(e),E1.set(e,t),n.start();for(let[i,r]of n2){let o=$W(r,e);e.listen(i,o)}}(t,e)});var r2,Kh=(()=>{class n{broadcast(e,i){return function(n,t){for(let i of Zh)E1.get(i).isConnected||(Zh.delete(i),E1.delete(i));let e=[...Zh].map(i=>i.sendMessage(n,t));return Promise.all(e)}(e,i)}listen(e,i){!function(n,t){n2.set(n,t);for(let e of Zh){let i=$W(t,e);e.listen(n,i)}}(e,i)}unlisten(e){!function(n){n2.delete(n);for(let t of Zh)t.unlisten(n)}(e)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),T1=(()=>{class n{constructor(e,i){this.ipc=e,this.store=i}init(){let e=document.createElement("tf-storage");this.ipc.listen(yd.GET_URL_DATA,i=>{if(!i)return;let r=`p.${i.pluginName}.`,o={},s=e.tf_storage.getUrlHashDict();for(let a in s)a.startsWith(r)&&(o[a.substring(r.length)]=s[a]);return o}),this.store.select(Fh).pipe(ke(i=>null!==i),Yn()).subscribe(()=>{this.ipc.broadcast(yd.DATA_RELOADED,void 0)})}}return n.\u0275fac=function(e){return new(e||n)(k(Kh),k(Ae))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),D1=(()=>{class n{constructor(e,i){this.ipc=e,this.store=i}init(){let e=this.store.select(lr).pipe(hn(i=>i?dn(i.map(o=>this.store.select(Du,{experimentId:o}))).pipe(N(o=>o.flat()),Yn((o,s)=>o.length===s.length&&o.every((a,l)=>s[l].id===a.id)),N(o=>o.map(({name:s})=>s))):Ht([])));e.subscribe(i=>{this.ipc.broadcast(yd.RUNS_CHANGED,i)}),this.ipc.listen(yd.GET_RUNS,()=>e.pipe(Yt(1)).toPromise())}}return n.\u0275fac=function(e){return new(e||n)(k(Kh),k(Ae))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),I1=(()=>{class n{constructor(e,i){i.init(),e.init()}registerPluginIframe(e,i){!function(n,t){JW.set(n,{pluginName:t})}(e,i)}}return n.\u0275fac=function(e){return new(e||n)(k(D1),k(T1))},n.\u0275mod=G({type:n}),n.\u0275inj=U({providers:[Kh,T1,D1],imports:[Ih,Ga,w1]}),n})(),Jh=_e("[Alert] Alert Reported",{_as:"props",_p:void 0}),n7=(()=>{class n{constructor(e,i,r){this.actions$=e,this.store=i,this.alertActionModule=r,this.reportRegisteredActionAlerts$=ar(()=>this.actions$.pipe(Nt(o=>{let s=this.alertActionModule.getAlertFromAction(o);s&&this.store.dispatch(Jh(s))})),{dispatch:!1})}}return n.\u0275fac=function(e){return new(e||n)(k(xo),k(Ae),k(Sc))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),I0e=br({latestAlert:null},ye(Jh,(n,{localizedMessage:t,followupAction:e})=>{let i={localizedMessage:t,created:Date.now()};return e&&(i.followupAction=e),{...n,latestAlert:i}}));function i7(n,t){return I0e(n,t)}try{r2=typeof Intl<"u"&&Intl.v8BreakIterator}catch{r2=!1}var $h,Pv,A1,bf,i2,Gn=(()=>{class n{constructor(e){this._platformId=e,this.isBrowser=this._platformId?gw(this._platformId):"object"==typeof document&&!!document,this.EDGE=this.isBrowser&&/(edge)/i.test(navigator.userAgent),this.TRIDENT=this.isBrowser&&/(msie|trident)/i.test(navigator.userAgent),this.BLINK=this.isBrowser&&!(!window.chrome&&!r2)&&typeof CSS<"u"&&!this.EDGE&&!this.TRIDENT,this.WEBKIT=this.isBrowser&&/AppleWebKit/i.test(navigator.userAgent)&&!this.BLINK&&!this.EDGE&&!this.TRIDENT,this.IOS=this.isBrowser&&/iPad|iPhone|iPod/.test(navigator.userAgent)&&!("MSStream"in window),this.FIREFOX=this.isBrowser&&/(firefox|minefield)/i.test(navigator.userAgent),this.ANDROID=this.isBrowser&&/android/i.test(navigator.userAgent)&&!this.TRIDENT,this.SAFARI=this.isBrowser&&/safari/i.test(navigator.userAgent)&&this.WEBKIT}}return n.\u0275fac=function(e){return new(e||n)(k(vc))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),r7=["color","button","checkbox","date","datetime-local","email","file","hidden","image","month","number","password","radio","range","reset","search","submit","tel","text","time","url","week"];function o2(){if($h)return $h;if("object"!=typeof document||!document)return $h=new Set(r7);let n=document.createElement("input");return $h=new Set(r7.filter(t=>(n.setAttribute("type",t),n.type===t)))}function qo(n){return function(){if(null==Pv&&typeof window<"u")try{window.addEventListener("test",null,Object.defineProperty({},"passive",{get:()=>Pv=!0}))}finally{Pv=Pv||!1}return Pv}()?n:!!n.capture}function R1(){if(null==bf){if("object"!=typeof document||!document||"function"!=typeof Element||!Element)return bf=!1;if("scrollBehavior"in document.documentElement.style)bf=!0;else{let n=Element.prototype.scrollTo;bf=!!n&&!/\{\s*\[native code\]\s*\}/.test(n.toString())}}return bf}function eg(){if("object"!=typeof document||!document)return 0;if(null==A1){let n=document.createElement("div"),t=n.style;n.dir="rtl",t.width="1px",t.overflow="auto",t.visibility="hidden",t.pointerEvents="none",t.position="absolute";let e=document.createElement("div"),i=e.style;i.width="2px",i.height="1px",n.appendChild(e),document.body.appendChild(n),A1=0,0===n.scrollLeft&&(n.scrollLeft=1,A1=0===n.scrollLeft?1:2),n.remove()}return A1}function Ov(){let n=typeof document<"u"&&document?document.activeElement:null;for(;n&&n.shadowRoot;){let t=n.shadowRoot.activeElement;if(t===n)break;n=t}return n}function ma(n){return n.composedPath?n.composedPath()[0]:n.target}function kv(){return typeof __karma__<"u"&&!!__karma__||typeof jasmine<"u"&&!!jasmine||typeof jest<"u"&&!!jest||typeof Mocha<"u"&&!!Mocha}function vr(n,...t){return t.length?t.some(e=>n[e]):n.altKey||n.shiftKey||n.ctrlKey||n.metaKey}function Rt(n){return null!=n&&"false"!=`${n}`}function _i(n,t=0){return s2(n)?Number(n):t}function s2(n){return!isNaN(parseFloat(n))&&!isNaN(Number(n))}function tg(n){return Array.isArray(n)?n:[n]}function Yr(n){return null==n?"":"string"==typeof n?n:`${n}px`}function Hs(n){return n instanceof Me?n.nativeElement:n}var ig,a7=(()=>{class n{create(e){return typeof MutationObserver>"u"?null:new MutationObserver(e)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),P0e=(()=>{class n{constructor(e){this._mutationObserverFactory=e,this._observedElements=new Map}ngOnDestroy(){this._observedElements.forEach((e,i)=>this._cleanupObserver(i))}observe(e){let i=Hs(e);return new Kt(r=>{let s=this._observeElement(i).subscribe(r);return()=>{s.unsubscribe(),this._unobserveElement(i)}})}_observeElement(e){if(this._observedElements.has(e))this._observedElements.get(e).count++;else{let i=new Ie,r=this._mutationObserverFactory.create(o=>i.next(o));r&&r.observe(e,{characterData:!0,childList:!0,subtree:!0}),this._observedElements.set(e,{observer:r,stream:i,count:1})}return this._observedElements.get(e).stream}_unobserveElement(e){this._observedElements.has(e)&&(this._observedElements.get(e).count--,this._observedElements.get(e).count||this._cleanupObserver(e))}_cleanupObserver(e){if(this._observedElements.has(e)){let{observer:i,stream:r}=this._observedElements.get(e);i&&i.disconnect(),r.complete(),this._observedElements.delete(e)}}}return n.\u0275fac=function(e){return new(e||n)(k(a7))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),P1=(()=>{class n{get disabled(){return this._disabled}set disabled(e){this._disabled=Rt(e),this._disabled?this._unsubscribe():this._subscribe()}get debounce(){return this._debounce}set debounce(e){this._debounce=_i(e),this._subscribe()}constructor(e,i,r){this._contentObserver=e,this._elementRef=i,this._ngZone=r,this.event=new F,this._disabled=!1,this._currentSubscription=null}ngAfterContentInit(){!this._currentSubscription&&!this.disabled&&this._subscribe()}ngOnDestroy(){this._unsubscribe()}_subscribe(){this._unsubscribe();let e=this._contentObserver.observe(this._elementRef);this._ngZone.runOutsideAngular(()=>{this._currentSubscription=(this.debounce?e.pipe(wr(this.debounce)):e).subscribe(this.event)})}_unsubscribe(){this._currentSubscription?.unsubscribe()}}return n.\u0275fac=function(e){return new(e||n)(C(P0e),C(Me),C(at))},n.\u0275dir=we({type:n,selectors:[["","cdkObserveContent",""]],inputs:{disabled:["cdkObserveContentDisabled","disabled"],debounce:"debounce"},outputs:{event:"cdkObserveContent"},exportAs:["cdkObserveContent"]}),n})(),ng=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({providers:[a7]}),n})(),c7=new Set,O0e=(()=>{class n{constructor(e){this._platform=e,this._matchMedia=this._platform.isBrowser&&window.matchMedia?window.matchMedia.bind(window):F0e}matchMedia(e){return(this._platform.WEBKIT||this._platform.BLINK)&&function(n){if(!c7.has(n))try{ig||((ig=document.createElement("style")).setAttribute("type","text/css"),document.head.appendChild(ig)),ig.sheet&&(ig.sheet.insertRule(`@media ${n} {body{ }}`,0),c7.add(n))}catch(t){console.error(t)}}(e),this._matchMedia(e)}}return n.\u0275fac=function(e){return new(e||n)(k(Gn))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})();function F0e(n){return{matches:"all"===n||""===n,media:n,addListener:()=>{},removeListener:()=>{}}}var Fv=(()=>{class n{constructor(e,i){this._mediaMatcher=e,this._zone=i,this._queries=new Map,this._destroySubject=new Ie}ngOnDestroy(){this._destroySubject.next(),this._destroySubject.complete()}isMatched(e){return d7(tg(e)).some(r=>this._registerQuery(r).mql.matches)}observe(e){let o=dn(d7(tg(e)).map(s=>this._registerQuery(s).observable));return o=Jd(o.pipe(Yt(1)),o.pipe(ia(1),wr(0))),o.pipe(N(s=>{let a={matches:!1,breakpoints:{}};return s.forEach(({matches:l,query:c})=>{a.matches=a.matches||l,a.breakpoints[c]=l}),a}))}_registerQuery(e){if(this._queries.has(e))return this._queries.get(e);let i=this._mediaMatcher.matchMedia(e),o={observable:new Kt(s=>{let a=l=>this._zone.run(()=>s.next(l));return i.addListener(a),()=>{i.removeListener(a)}}).pipe(qn(i),N(({matches:s})=>({query:e,matches:s})),ot(this._destroySubject)),mql:i};return this._queries.set(e,o),o}}return n.\u0275fac=function(e){return new(e||n)(k(O0e),k(at))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})();function d7(n){return n.map(t=>t.split(",")).reduce((t,e)=>t.concat(e)).map(t=>t.trim())}function F1(n,t){return(n.getAttribute(t)||"").match(/\S+/g)||[]}var _7="cdk-describedby-message",O1="cdk-describedby-host",c2=0,L1=(()=>{class n{constructor(e,i){this._platform=i,this._messageRegistry=new Map,this._messagesContainer=null,this._id=""+c2++,this._document=e,this._id=ai(Yp)+"-"+c2++}describe(e,i,r){if(!this._canBeDescribed(e,i))return;let o=a2(i,r);"string"!=typeof i?(p7(i,this._id),this._messageRegistry.set(o,{messageElement:i,referenceCount:0})):this._messageRegistry.has(o)||this._createMessageElement(i,r),this._isElementDescribedByMessage(e,o)||this._addMessageReference(e,o)}removeDescription(e,i,r){if(!i||!this._isElementNode(e))return;let o=a2(i,r);if(this._isElementDescribedByMessage(e,o)&&this._removeMessageReference(e,o),"string"==typeof i){let s=this._messageRegistry.get(o);s&&0===s.referenceCount&&this._deleteMessageElement(o)}0===this._messagesContainer?.childNodes.length&&(this._messagesContainer.remove(),this._messagesContainer=null)}ngOnDestroy(){let e=this._document.querySelectorAll(`[${O1}="${this._id}"]`);for(let i=0;i<e.length;i++)this._removeCdkDescribedByReferenceIds(e[i]),e[i].removeAttribute(O1);this._messagesContainer?.remove(),this._messagesContainer=null,this._messageRegistry.clear()}_createMessageElement(e,i){let r=this._document.createElement("div");p7(r,this._id),r.textContent=e,i&&r.setAttribute("role",i),this._createMessagesContainer(),this._messagesContainer.appendChild(r),this._messageRegistry.set(a2(e,i),{messageElement:r,referenceCount:0})}_deleteMessageElement(e){this._messageRegistry.get(e)?.messageElement?.remove(),this._messageRegistry.delete(e)}_createMessagesContainer(){if(this._messagesContainer)return;let e="cdk-describedby-message-container",i=this._document.querySelectorAll(`.${e}[platform="server"]`);for(let o=0;o<i.length;o++)i[o].remove();let r=this._document.createElement("div");r.style.visibility="hidden",r.classList.add(e),r.classList.add("cdk-visually-hidden"),this._platform&&!this._platform.isBrowser&&r.setAttribute("platform","server"),this._document.body.appendChild(r),this._messagesContainer=r}_removeCdkDescribedByReferenceIds(e){let i=F1(e,"aria-describedby").filter(r=>0!=r.indexOf(_7));e.setAttribute("aria-describedby",i.join(" "))}_addMessageReference(e,i){let r=this._messageRegistry.get(i);(function(n,t,e){let i=F1(n,t);i.some(r=>r.trim()==e.trim())||(i.push(e.trim()),n.setAttribute(t,i.join(" ")))})(e,"aria-describedby",r.messageElement.id),e.setAttribute(O1,this._id),r.referenceCount++}_removeMessageReference(e,i){let r=this._messageRegistry.get(i);r.referenceCount--,function(n,t,e){let r=F1(n,t).filter(o=>o!=e.trim());r.length?n.setAttribute(t,r.join(" ")):n.removeAttribute(t)}(e,"aria-describedby",r.messageElement.id),e.removeAttribute(O1)}_isElementDescribedByMessage(e,i){let r=F1(e,"aria-describedby"),o=this._messageRegistry.get(i),s=o&&o.messageElement.id;return!!s&&-1!=r.indexOf(s)}_canBeDescribed(e,i){if(!this._isElementNode(e))return!1;if(i&&"object"==typeof i)return!0;let r=null==i?"":`${i}`.trim(),o=e.getAttribute("aria-label");return!(!r||o&&o.trim()===r)}_isElementNode(e){return e.nodeType===this._document.ELEMENT_NODE}}return n.\u0275fac=function(e){return new(e||n)(k(Lt),k(Gn))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})();function a2(n,t){return"string"==typeof n?`${t||""}/${n}`:n}function p7(n,t){n.id||(n.id=`${_7}-${t}-${c2++}`)}var N1=class{constructor(t){this._items=t,this._activeItemIndex=-1,this._activeItem=null,this._wrap=!1,this._letterKeyStream=new Ie,this._typeaheadSubscription=Mn.EMPTY,this._vertical=!0,this._allowedModifierKeys=[],this._homeAndEnd=!1,this._pageUpAndDown={enabled:!1,delta:10},this._skipPredicateFn=e=>e.disabled,this._pressedLetters=[],this.tabOut=new Ie,this.change=new Ie,t instanceof Oa&&(this._itemChangesSubscription=t.changes.subscribe(e=>{if(this._activeItem){let r=e.toArray().indexOf(this._activeItem);r>-1&&r!==this._activeItemIndex&&(this._activeItemIndex=r)}}))}skipPredicate(t){return this._skipPredicateFn=t,this}withWrap(t=!0){return this._wrap=t,this}withVerticalOrientation(t=!0){return this._vertical=t,this}withHorizontalOrientation(t){return this._horizontal=t,this}withAllowedModifierKeys(t){return this._allowedModifierKeys=t,this}withTypeAhead(t=200){return this._typeaheadSubscription.unsubscribe(),this._typeaheadSubscription=this._letterKeyStream.pipe(Nt(e=>this._pressedLetters.push(e)),wr(t),ke(()=>this._pressedLetters.length>0),N(()=>this._pressedLetters.join(""))).subscribe(e=>{let i=this._getItemsArray();for(let r=1;r<i.length+1;r++){let o=(this._activeItemIndex+r)%i.length,s=i[o];if(!this._skipPredicateFn(s)&&0===s.getLabel().toUpperCase().trim().indexOf(e)){this.setActiveItem(o);break}}this._pressedLetters=[]}),this}cancelTypeahead(){return this._pressedLetters=[],this}withHomeAndEnd(t=!0){return this._homeAndEnd=t,this}withPageUpDown(t=!0,e=10){return this._pageUpAndDown={enabled:t,delta:e},this}setActiveItem(t){let e=this._activeItem;this.updateActiveItem(t),this._activeItem!==e&&this.change.next(this._activeItemIndex)}onKeydown(t){let e=t.keyCode,r=["altKey","ctrlKey","metaKey","shiftKey"].every(o=>!t[o]||this._allowedModifierKeys.indexOf(o)>-1);switch(e){case 9:return void this.tabOut.next();case 40:if(this._vertical&&r){this.setNextItemActive();break}return;case 38:if(this._vertical&&r){this.setPreviousItemActive();break}return;case 39:if(this._horizontal&&r){"rtl"===this._horizontal?this.setPreviousItemActive():this.setNextItemActive();break}return;case 37:if(this._horizontal&&r){"rtl"===this._horizontal?this.setNextItemActive():this.setPreviousItemActive();break}return;case 36:if(this._homeAndEnd&&r){this.setFirstItemActive();break}return;case 35:if(this._homeAndEnd&&r){this.setLastItemActive();break}return;case 33:if(this._pageUpAndDown.enabled&&r){let o=this._activeItemIndex-this._pageUpAndDown.delta;this._setActiveItemByIndex(o>0?o:0,1);break}return;case 34:if(this._pageUpAndDown.enabled&&r){let o=this._activeItemIndex+this._pageUpAndDown.delta,s=this._getItemsArray().length;this._setActiveItemByIndex(o<s?o:s-1,-1);break}return;default:return void((r||vr(t,"shiftKey"))&&(t.key&&1===t.key.length?this._letterKeyStream.next(t.key.toLocaleUpperCase()):(e>=65&&e<=90||e>=48&&e<=57)&&this._letterKeyStream.next(String.fromCharCode(e))))}this._pressedLetters=[],t.preventDefault()}get activeItemIndex(){return this._activeItemIndex}get activeItem(){return this._activeItem}isTyping(){return this._pressedLetters.length>0}setFirstItemActive(){this._setActiveItemByIndex(0,1)}setLastItemActive(){this._setActiveItemByIndex(this._items.length-1,-1)}setNextItemActive(){this._activeItemIndex<0?this.setFirstItemActive():this._setActiveItemByDelta(1)}setPreviousItemActive(){this._activeItemIndex<0&&this._wrap?this.setLastItemActive():this._setActiveItemByDelta(-1)}updateActiveItem(t){let e=this._getItemsArray(),i="number"==typeof t?t:e.indexOf(t);this._activeItem=e[i]??null,this._activeItemIndex=i}destroy(){this._typeaheadSubscription.unsubscribe(),this._itemChangesSubscription?.unsubscribe(),this._letterKeyStream.complete(),this.tabOut.complete(),this.change.complete(),this._pressedLetters=[]}_setActiveItemByDelta(t){this._wrap?this._setActiveInWrapMode(t):this._setActiveInDefaultMode(t)}_setActiveInWrapMode(t){let e=this._getItemsArray();for(let i=1;i<=e.length;i++){let r=(this._activeItemIndex+t*i+e.length)%e.length;if(!this._skipPredicateFn(e[r]))return void this.setActiveItem(r)}}_setActiveInDefaultMode(t){this._setActiveItemByIndex(this._activeItemIndex+t,t)}_setActiveItemByIndex(t,e){let i=this._getItemsArray();if(i[t]){for(;this._skipPredicateFn(i[t]);)if(!i[t+=e])return;this.setActiveItem(t)}}_getItemsArray(){return this._items instanceof Oa?this._items.toArray():this._items}},og=class extends N1{setActiveItem(t){this.activeItem&&this.activeItem.setInactiveStyles(),super.setActiveItem(t),this.activeItem&&this.activeItem.setActiveStyles()}},sg=class extends N1{constructor(){super(...arguments),this._origin="program"}setFocusOrigin(t){return this._origin=t,this}setActiveItem(t){super.setActiveItem(t),this.activeItem&&this.activeItem.focus(this._origin)}},ag=(()=>{class n{constructor(e){this._platform=e}isDisabled(e){return e.hasAttribute("disabled")}isVisible(e){return function(n){return!!(n.offsetWidth||n.offsetHeight||"function"==typeof n.getClientRects&&n.getClientRects().length)}(e)&&"visible"===getComputedStyle(e).visibility}isTabbable(e){if(!this._platform.isBrowser)return!1;let i=function(n){try{return n.frameElement}catch{return null}}(function(n){return n.ownerDocument&&n.ownerDocument.defaultView||window}(e));if(i&&(-1===f7(i)||!this.isVisible(i)))return!1;let r=e.nodeName.toLowerCase(),o=f7(e);return e.hasAttribute("contenteditable")?-1!==o:!("iframe"===r||"object"===r||this._platform.WEBKIT&&this._platform.IOS&&!function(n){let t=n.nodeName.toLowerCase(),e="input"===t&&n.type;return"text"===e||"password"===e||"select"===t||"textarea"===t}(e))&&("audio"===r?!!e.hasAttribute("controls")&&-1!==o:"video"===r?-1!==o&&(null!==o||this._platform.FIREFOX||e.hasAttribute("controls")):e.tabIndex>=0)}isFocusable(e,i){return function(n){return!function(n){return function(n){return"input"==n.nodeName.toLowerCase()}(n)&&"hidden"==n.type}(n)&&(function(n){let t=n.nodeName.toLowerCase();return"input"===t||"select"===t||"button"===t||"textarea"===t}(n)||function(n){return function(n){return"a"==n.nodeName.toLowerCase()}(n)&&n.hasAttribute("href")}(n)||n.hasAttribute("contenteditable")||b7(n))}(e)&&!this.isDisabled(e)&&(i?.ignoreVisibility||this.isVisible(e))}}return n.\u0275fac=function(e){return new(e||n)(k(Gn))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})();function b7(n){if(!n.hasAttribute("tabindex")||void 0===n.tabIndex)return!1;let t=n.getAttribute("tabindex");return!(!t||isNaN(parseInt(t,10)))}function f7(n){if(!b7(n))return null;let t=parseInt(n.getAttribute("tabindex")||"",10);return isNaN(t)?-1:t}var Nv=(()=>{class n{constructor(e,i,r){this._checker=e,this._ngZone=i,this._document=r}create(e,i=!1){return new class{get enabled(){return this._enabled}set enabled(t){this._enabled=t,this._startAnchor&&this._endAnchor&&(this._toggleAnchorTabIndex(t,this._startAnchor),this._toggleAnchorTabIndex(t,this._endAnchor))}constructor(t,e,i,r,o=!1){this._element=t,this._checker=e,this._ngZone=i,this._document=r,this._hasAttached=!1,this.startAnchorListener=()=>this.focusLastTabbableElement(),this.endAnchorListener=()=>this.focusFirstTabbableElement(),this._enabled=!0,o||this.attachAnchors()}destroy(){let t=this._startAnchor,e=this._endAnchor;t&&(t.removeEventListener("focus",this.startAnchorListener),t.remove()),e&&(e.removeEventListener("focus",this.endAnchorListener),e.remove()),this._startAnchor=this._endAnchor=null,this._hasAttached=!1}attachAnchors(){return!!this._hasAttached||(this._ngZone.runOutsideAngular(()=>{this._startAnchor||(this._startAnchor=this._createAnchor(),this._startAnchor.addEventListener("focus",this.startAnchorListener)),this._endAnchor||(this._endAnchor=this._createAnchor(),this._endAnchor.addEventListener("focus",this.endAnchorListener))}),this._element.parentNode&&(this._element.parentNode.insertBefore(this._startAnchor,this._element),this._element.parentNode.insertBefore(this._endAnchor,this._element.nextSibling),this._hasAttached=!0),this._hasAttached)}focusInitialElementWhenReady(t){return new Promise(e=>{this._executeOnStable(()=>e(this.focusInitialElement(t)))})}focusFirstTabbableElementWhenReady(t){return new Promise(e=>{this._executeOnStable(()=>e(this.focusFirstTabbableElement(t)))})}focusLastTabbableElementWhenReady(t){return new Promise(e=>{this._executeOnStable(()=>e(this.focusLastTabbableElement(t)))})}_getRegionBoundary(t){let e=this._element.querySelectorAll(`[cdk-focus-region-${t}], [cdkFocusRegion${t}], [cdk-focus-${t}]`);return"start"==t?e.length?e[0]:this._getFirstTabbableElement(this._element):e.length?e[e.length-1]:this._getLastTabbableElement(this._element)}focusInitialElement(t){let e=this._element.querySelector("[cdk-focus-initial], [cdkFocusInitial]");if(e){if(!this._checker.isFocusable(e)){let i=this._getFirstTabbableElement(e);return i?.focus(t),!!i}return e.focus(t),!0}return this.focusFirstTabbableElement(t)}focusFirstTabbableElement(t){let e=this._getRegionBoundary("start");return e&&e.focus(t),!!e}focusLastTabbableElement(t){let e=this._getRegionBoundary("end");return e&&e.focus(t),!!e}hasAttached(){return this._hasAttached}_getFirstTabbableElement(t){if(this._checker.isFocusable(t)&&this._checker.isTabbable(t))return t;let e=t.children;for(let i=0;i<e.length;i++){let r=e[i].nodeType===this._document.ELEMENT_NODE?this._getFirstTabbableElement(e[i]):null;if(r)return r}return null}_getLastTabbableElement(t){if(this._checker.isFocusable(t)&&this._checker.isTabbable(t))return t;let e=t.children;for(let i=e.length-1;i>=0;i--){let r=e[i].nodeType===this._document.ELEMENT_NODE?this._getLastTabbableElement(e[i]):null;if(r)return r}return null}_createAnchor(){let t=this._document.createElement("div");return this._toggleAnchorTabIndex(this._enabled,t),t.classList.add("cdk-visually-hidden"),t.classList.add("cdk-focus-trap-anchor"),t.setAttribute("aria-hidden","true"),t}_toggleAnchorTabIndex(t,e){t?e.setAttribute("tabindex","0"):e.removeAttribute("tabindex")}toggleAnchors(t){this._startAnchor&&this._endAnchor&&(this._toggleAnchorTabIndex(t,this._startAnchor),this._toggleAnchorTabIndex(t,this._endAnchor))}_executeOnStable(t){this._ngZone.isStable?t():this._ngZone.onStable.pipe(Yt(1)).subscribe(t)}}(e,this._checker,this._ngZone,this._document,i)}}return n.\u0275fac=function(e){return new(e||n)(k(ag),k(at),k(Lt))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})();function Lv(n){return 0===n.buttons||0===n.offsetX&&0===n.offsetY}function Bv(n){let t=n.touches&&n.touches[0]||n.changedTouches&&n.changedTouches[0];return!(!t||-1!==t.identifier||null!=t.radiusX&&1!==t.radiusX||null!=t.radiusY&&1!==t.radiusY)}new ie("FOCUS_TRAP_INERT_STRATEGY");var i_e=new ie("cdk-input-modality-detector-options"),r_e={ignoreKeys:[18,17,224,91,16]},rg=qo({passive:!0,capture:!0}),o_e=(()=>{class n{get mostRecentModality(){return this._modality.value}constructor(e,i,r,o){this._platform=e,this._mostRecentTarget=null,this._modality=new Ai(null),this._lastTouchMs=0,this._onKeydown=s=>{this._options?.ignoreKeys?.some(a=>a===s.keyCode)||(this._modality.next("keyboard"),this._mostRecentTarget=ma(s))},this._onMousedown=s=>{Date.now()-this._lastTouchMs<650||(this._modality.next(Lv(s)?"keyboard":"mouse"),this._mostRecentTarget=ma(s))},this._onTouchstart=s=>{Bv(s)?this._modality.next("keyboard"):(this._lastTouchMs=Date.now(),this._modality.next("touch"),this._mostRecentTarget=ma(s))},this._options={...r_e,...o},this.modalityDetected=this._modality.pipe(ia(1)),this.modalityChanged=this.modalityDetected.pipe(Yn()),e.isBrowser&&i.runOutsideAngular(()=>{r.addEventListener("keydown",this._onKeydown,rg),r.addEventListener("mousedown",this._onMousedown,rg),r.addEventListener("touchstart",this._onTouchstart,rg)})}ngOnDestroy(){this._modality.complete(),this._platform.isBrowser&&(document.removeEventListener("keydown",this._onKeydown,rg),document.removeEventListener("mousedown",this._onMousedown,rg),document.removeEventListener("touchstart",this._onTouchstart,rg))}}return n.\u0275fac=function(e){return new(e||n)(k(Gn),k(at),k(Lt),k(i_e,8))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),s_e=new ie("liveAnnouncerElement",{providedIn:"root",factory:function(){return null}}),l_e=new ie("LIVE_ANNOUNCER_DEFAULT_OPTIONS"),c_e=0,Vv=(()=>{class n{constructor(e,i,r,o){this._ngZone=i,this._defaultOptions=o,this._document=r,this._liveElement=e||this._createLiveElement()}announce(e,...i){let o,s,r=this._defaultOptions;return 1===i.length&&"number"==typeof i[0]?s=i[0]:[o,s]=i,this.clear(),clearTimeout(this._previousTimeout),o||(o=r&&r.politeness?r.politeness:"polite"),null==s&&r&&(s=r.duration),this._liveElement.setAttribute("aria-live",o),this._liveElement.id&&this._exposeAnnouncerToModals(this._liveElement.id),this._ngZone.runOutsideAngular(()=>(this._currentPromise||(this._currentPromise=new Promise(a=>this._currentResolve=a)),clearTimeout(this._previousTimeout),this._previousTimeout=setTimeout(()=>{this._liveElement.textContent=e,"number"==typeof s&&(this._previousTimeout=setTimeout(()=>this.clear(),s)),this._currentResolve(),this._currentPromise=this._currentResolve=void 0},100),this._currentPromise))}clear(){this._liveElement&&(this._liveElement.textContent="")}ngOnDestroy(){clearTimeout(this._previousTimeout),this._liveElement?.remove(),this._liveElement=null,this._currentResolve?.(),this._currentPromise=this._currentResolve=void 0}_createLiveElement(){let e="cdk-live-announcer-element",i=this._document.getElementsByClassName(e),r=this._document.createElement("div");for(let o=0;o<i.length;o++)i[o].remove();return r.classList.add(e),r.classList.add("cdk-visually-hidden"),r.setAttribute("aria-atomic","true"),r.setAttribute("aria-live","polite"),r.id="cdk-live-announcer-"+c_e++,this._document.body.appendChild(r),r}_exposeAnnouncerToModals(e){let i=this._document.querySelectorAll('body > .cdk-overlay-container [aria-modal="true"]');for(let r=0;r<i.length;r++){let o=i[r],s=o.getAttribute("aria-owns");s?-1===s.indexOf(e)&&o.setAttribute("aria-owns",s+" "+e):o.setAttribute("aria-owns",e)}}}return n.\u0275fac=function(e){return new(e||n)(k(s_e,8),k(at),k(Lt),k(l_e,8))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),d_e=new ie("cdk-focus-monitor-default-options"),k1=qo({passive:!0,capture:!0}),Xr=(()=>{class n{constructor(e,i,r,o,s){this._ngZone=e,this._platform=i,this._inputModalityDetector=r,this._origin=null,this._windowFocused=!1,this._originFromTouchInteraction=!1,this._elementInfo=new Map,this._monitoredElementCount=0,this._rootNodeFocusListenerCount=new Map,this._windowFocusListener=()=>{this._windowFocused=!0,this._windowFocusTimeoutId=window.setTimeout(()=>this._windowFocused=!1)},this._stopInputModalityDetector=new Ie,this._rootNodeFocusAndBlurListener=a=>{for(let c=ma(a);c;c=c.parentElement)"focus"===a.type?this._onFocus(a,c):this._onBlur(a,c)},this._document=o,this._detectionMode=s?.detectionMode||0}monitor(e,i=!1){let r=Hs(e);if(!this._platform.isBrowser||1!==r.nodeType)return Ht(null);let o=function(n){if(function(){if(null==i2){let n=typeof document<"u"?document.head:null;i2=!(!n||!n.createShadowRoot&&!n.attachShadow)}return i2}()){let t=n.getRootNode?n.getRootNode():null;if(typeof ShadowRoot<"u"&&ShadowRoot&&t instanceof ShadowRoot)return t}return null}(r)||this._getDocument(),s=this._elementInfo.get(r);if(s)return i&&(s.checkChildren=!0),s.subject;let a={checkChildren:i,subject:new Ie,rootNode:o};return this._elementInfo.set(r,a),this._registerGlobalListeners(a),a.subject}stopMonitoring(e){let i=Hs(e),r=this._elementInfo.get(i);r&&(r.subject.complete(),this._setClasses(i),this._elementInfo.delete(i),this._removeGlobalListeners(r))}focusVia(e,i,r){let o=Hs(e);o===this._getDocument().activeElement?this._getClosestElementsInfo(o).forEach(([a,l])=>this._originChanged(a,i,l)):(this._setOrigin(i),"function"==typeof o.focus&&o.focus(r))}ngOnDestroy(){this._elementInfo.forEach((e,i)=>this.stopMonitoring(i))}_getDocument(){return this._document||document}_getWindow(){return this._getDocument().defaultView||window}_getFocusOrigin(e){return this._origin?this._originFromTouchInteraction?this._shouldBeAttributedToTouch(e)?"touch":"program":this._origin:this._windowFocused&&this._lastFocusOrigin?this._lastFocusOrigin:e&&this._isLastInteractionFromInputLabel(e)?"mouse":"program"}_shouldBeAttributedToTouch(e){return 1===this._detectionMode||!!e?.contains(this._inputModalityDetector._mostRecentTarget)}_setClasses(e,i){e.classList.toggle("cdk-focused",!!i),e.classList.toggle("cdk-touch-focused","touch"===i),e.classList.toggle("cdk-keyboard-focused","keyboard"===i),e.classList.toggle("cdk-mouse-focused","mouse"===i),e.classList.toggle("cdk-program-focused","program"===i)}_setOrigin(e,i=!1){this._ngZone.runOutsideAngular(()=>{this._origin=e,this._originFromTouchInteraction="touch"===e&&i,0===this._detectionMode&&(clearTimeout(this._originTimeoutId),this._originTimeoutId=setTimeout(()=>this._origin=null,this._originFromTouchInteraction?650:1))})}_onFocus(e,i){let r=this._elementInfo.get(i),o=ma(e);!r||!r.checkChildren&&i!==o||this._originChanged(i,this._getFocusOrigin(o),r)}_onBlur(e,i){let r=this._elementInfo.get(i);!r||r.checkChildren&&e.relatedTarget instanceof Node&&i.contains(e.relatedTarget)||(this._setClasses(i),this._emitOrigin(r,null))}_emitOrigin(e,i){e.subject.observers.length&&this._ngZone.run(()=>e.subject.next(i))}_registerGlobalListeners(e){if(!this._platform.isBrowser)return;let i=e.rootNode,r=this._rootNodeFocusListenerCount.get(i)||0;r||this._ngZone.runOutsideAngular(()=>{i.addEventListener("focus",this._rootNodeFocusAndBlurListener,k1),i.addEventListener("blur",this._rootNodeFocusAndBlurListener,k1)}),this._rootNodeFocusListenerCount.set(i,r+1),1==++this._monitoredElementCount&&(this._ngZone.runOutsideAngular(()=>{this._getWindow().addEventListener("focus",this._windowFocusListener)}),this._inputModalityDetector.modalityDetected.pipe(ot(this._stopInputModalityDetector)).subscribe(o=>{this._setOrigin(o,!0)}))}_removeGlobalListeners(e){let i=e.rootNode;if(this._rootNodeFocusListenerCount.has(i)){let r=this._rootNodeFocusListenerCount.get(i);r>1?this._rootNodeFocusListenerCount.set(i,r-1):(i.removeEventListener("focus",this._rootNodeFocusAndBlurListener,k1),i.removeEventListener("blur",this._rootNodeFocusAndBlurListener,k1),this._rootNodeFocusListenerCount.delete(i))}--this._monitoredElementCount||(this._getWindow().removeEventListener("focus",this._windowFocusListener),this._stopInputModalityDetector.next(),clearTimeout(this._windowFocusTimeoutId),clearTimeout(this._originTimeoutId))}_originChanged(e,i,r){this._setClasses(e,i),this._emitOrigin(r,i),this._lastFocusOrigin=i}_getClosestElementsInfo(e){let i=[];return this._elementInfo.forEach((r,o)=>{(o===e||r.checkChildren&&o.contains(e))&&i.push([o,r])}),i}_isLastInteractionFromInputLabel(e){let{_mostRecentTarget:i,mostRecentModality:r}=this._inputModalityDetector;if("mouse"!==r||!i||i===e||"INPUT"!==e.nodeName&&"TEXTAREA"!==e.nodeName||e.disabled)return!1;let o=e.labels;if(o)for(let s=0;s<o.length;s++)if(o[s].contains(i))return!0;return!1}}return n.\u0275fac=function(e){return new(e||n)(k(at),k(Gn),k(o_e),k(Lt,8),k(d_e,8))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),y7=(()=>{class n{constructor(e,i){this._elementRef=e,this._focusMonitor=i,this._focusOrigin=null,this.cdkFocusChange=new F}get focusOrigin(){return this._focusOrigin}ngAfterViewInit(){let e=this._elementRef.nativeElement;this._monitorSubscription=this._focusMonitor.monitor(e,1===e.nodeType&&e.hasAttribute("cdkMonitorSubtreeFocus")).subscribe(i=>{this._focusOrigin=i,this.cdkFocusChange.emit(i)})}ngOnDestroy(){this._focusMonitor.stopMonitoring(this._elementRef),this._monitorSubscription&&this._monitorSubscription.unsubscribe()}}return n.\u0275fac=function(e){return new(e||n)(C(Me),C(Xr))},n.\u0275dir=we({type:n,selectors:[["","cdkMonitorElementFocus",""],["","cdkMonitorSubtreeFocus",""]],outputs:{cdkFocusChange:"cdkFocusChange"},exportAs:["cdkMonitorFocus"]}),n})(),m7="cdk-high-contrast-black-on-white",h7="cdk-high-contrast-white-on-black",l2="cdk-high-contrast-active",_2=(()=>{class n{constructor(e,i){this._platform=e,this._document=i,this._breakpointSubscription=ai(Fv).observe("(forced-colors: active)").subscribe(()=>{this._hasCheckedHighContrastMode&&(this._hasCheckedHighContrastMode=!1,this._applyBodyHighContrastModeCssClasses())})}getHighContrastMode(){if(!this._platform.isBrowser)return 0;let e=this._document.createElement("div");e.style.backgroundColor="rgb(1,2,3)",e.style.position="absolute",this._document.body.appendChild(e);let i=this._document.defaultView||window,r=i&&i.getComputedStyle?i.getComputedStyle(e):null,o=(r&&r.backgroundColor||"").replace(/ /g,"");switch(e.remove(),o){case"rgb(0,0,0)":case"rgb(45,50,54)":case"rgb(32,32,32)":return 2;case"rgb(255,255,255)":case"rgb(255,250,239)":return 1}return 0}ngOnDestroy(){this._breakpointSubscription.unsubscribe()}_applyBodyHighContrastModeCssClasses(){if(!this._hasCheckedHighContrastMode&&this._platform.isBrowser&&this._document.body){let e=this._document.body.classList;e.remove(l2,m7,h7),this._hasCheckedHighContrastMode=!0;let i=this.getHighContrastMode();1===i?e.add(l2,m7):2===i&&e.add(l2,h7)}}}return n.\u0275fac=function(e){return new(e||n)(k(Gn),k(Lt))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),lg=(()=>{class n{constructor(e){e._applyBodyHighContrastModeCssClasses()}}return n.\u0275fac=function(e){return new(e||n)(k(_2))},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[ng]}),n})(),u_e=new ie("cdk-dir-doc",{providedIn:"root",factory:function(){return ai(Lt)}}),f_e=/^(ar|ckb|dv|he|iw|fa|nqo|ps|sd|ug|ur|yi|.*[-_](Adlm|Arab|Hebr|Nkoo|Rohg|Thaa))(?!.*[-_](Latn|Cyrl)($|-|_))($|-|_)/i,Xi=(()=>{class n{constructor(e){this.value="ltr",this.change=new F,e&&(this.value=function(n){let t=n?.toLowerCase()||"";return"auto"===t&&typeof navigator<"u"&&navigator?.language?f_e.test(navigator.language)?"rtl":"ltr":"rtl"===t?"rtl":"ltr"}((e.body?e.body.dir:null)||(e.documentElement?e.documentElement.dir:null)||"ltr"))}ngOnDestroy(){this.change.complete()}}return n.\u0275fac=function(e){return new(e||n)(k(u_e,8))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),Ou=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({}),n})(),h_e=["text"];function g_e(n,t){if(1&n&&P(0,"mat-pseudo-checkbox",6),2&n){let e=w();_("state",e.selected?"checked":"unchecked")("disabled",e.disabled)}}function __e(n,t){1&n&&P(0,"mat-pseudo-checkbox",7),2&n&&_("disabled",w().disabled)}function b_e(n,t){if(1&n&&(h(0,"span",8),T(1),g()),2&n){let e=w();v(1),He("(",e.group.label,")")}}var v_e=[[["mat-icon"]],"*"],y_e=["mat-icon","*"],E7=(new yl("15.2.9"),(()=>{class n{}return n.STANDARD_CURVE="cubic-bezier(0.4,0.0,0.2,1)",n.DECELERATION_CURVE="cubic-bezier(0.0,0.0,0.2,1)",n.ACCELERATION_CURVE="cubic-bezier(0.4,0.0,1,1)",n.SHARP_CURVE="cubic-bezier(0.4,0.0,0.6,1)",n})()),T7=(()=>{class n{}return n.COMPLEX="375ms",n.ENTERING="225ms",n.EXITING="195ms",n})(),C_e=new ie("mat-sanity-checks",{providedIn:"root",factory:function(){return!0}}),fn=(()=>{class n{constructor(e,i,r){this._sanityChecks=i,this._document=r,this._hasDoneGlobalChecks=!1,e._applyBodyHighContrastModeCssClasses(),this._hasDoneGlobalChecks||(this._hasDoneGlobalChecks=!0)}_checkIsEnabled(e){return!kv()&&("boolean"==typeof this._sanityChecks?this._sanityChecks:!!this._sanityChecks[e])}}return n.\u0275fac=function(e){return new(e||n)(k(_2),k(C_e,8),k(Lt))},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Ou,Ou]}),n})();function so(n){return class extends n{get disabled(){return this._disabled}set disabled(t){this._disabled=Rt(t)}constructor(...t){super(...t),this._disabled=!1}}}function zs(n,t){return class extends n{get color(){return this._color}set color(e){let i=e||this.defaultColor;i!==this._color&&(this._color&&this._elementRef.nativeElement.classList.remove(`mat-${this._color}`),i&&this._elementRef.nativeElement.classList.add(`mat-${i}`),this._color=i)}constructor(...e){super(...e),this.defaultColor=t,this.color=t}}}function us(n){return class extends n{get disableRipple(){return this._disableRipple}set disableRipple(t){this._disableRipple=Rt(t)}constructor(...t){super(...t),this._disableRipple=!1}}}function ku(n,t=0){return class extends n{get tabIndex(){return this.disabled?-1:this._tabIndex}set tabIndex(e){this._tabIndex=null!=e?_i(e):this.defaultTabIndex}constructor(...e){super(...e),this._tabIndex=t,this.defaultTabIndex=t}}}function B1(n){return class extends n{updateErrorState(){let t=this.errorState,o=(this.errorStateMatcher||this._defaultErrorStateMatcher).isErrorState(this.ngControl?this.ngControl.control:null,this._parentFormGroup||this._parentForm);o!==t&&(this.errorState=o,this.stateChanges.next())}constructor(...t){super(...t),this.errorState=!1}}}function V1(n){return class extends n{constructor(...t){super(...t),this._isInitialized=!1,this._pendingSubscribers=[],this.initialized=new Kt(e=>{this._isInitialized?this._notifySubscriber(e):this._pendingSubscribers.push(e)})}_markInitialized(){this._isInitialized=!0,this._pendingSubscribers.forEach(this._notifySubscriber),this._pendingSubscribers=null}_notifySubscriber(t){t.next(),t.complete()}}}new ie("MAT_DATE_LOCALE",{providedIn:"root",factory:function(){return ai(cd)}}),new ie("mat-date-formats");var H1=(()=>{class n{isErrorState(e,i){return!!(e&&e.invalid&&(e.touched||i&&i.submitted))}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),x7=qo({passive:!0,capture:!0}),C7={enterDuration:225,exitDuration:150},M7=qo({passive:!0,capture:!0}),w7=["mousedown","touchstart"],S7=["mouseup","mouseleave","touchend","touchcancel"],vf=class{constructor(t,e,i,r){this._target=t,this._ngZone=e,this._platform=r,this._isPointerDown=!1,this._activeRipples=new Map,this._pointerUpEventsRegistered=!1,r.isBrowser&&(this._containerElement=Hs(i))}fadeInRipple(t,e,i={}){let r=this._containerRect=this._containerRect||this._containerElement.getBoundingClientRect(),o={...C7,...i.animation};i.centered&&(t=r.left+r.width/2,e=r.top+r.height/2);let s=i.radius||function(n,t,e){let i=Math.max(Math.abs(n-e.left),Math.abs(n-e.right)),r=Math.max(Math.abs(t-e.top),Math.abs(t-e.bottom));return Math.sqrt(i*i+r*r)}(t,e,r),a=t-r.left,l=e-r.top,c=o.enterDuration,d=document.createElement("div");d.classList.add("mat-ripple-element"),d.style.left=a-s+"px",d.style.top=l-s+"px",d.style.height=2*s+"px",d.style.width=2*s+"px",null!=i.color&&(d.style.backgroundColor=i.color),d.style.transitionDuration=`${c}ms`,this._containerElement.appendChild(d);let u=window.getComputedStyle(d),f=u.transitionDuration,m="none"===u.transitionProperty||"0s"===f||"0s, 0s"===f||0===r.width&&0===r.height,b=new class{constructor(t,e,i,r=!1){this._renderer=t,this.element=e,this.config=i,this._animationForciblyDisabledThroughCss=r,this.state=3}fadeOut(){this._renderer.fadeOutRipple(this)}}(this,d,i,m);d.style.transform="scale3d(1, 1, 1)",b.state=0,i.persistent||(this._mostRecentTransientRipple=b);let M=null;return!m&&(c||o.exitDuration)&&this._ngZone.runOutsideAngular(()=>{let y=()=>this._finishRippleTransition(b),x=()=>this._destroyRipple(b);d.addEventListener("transitionend",y),d.addEventListener("transitioncancel",x),M={onTransitionEnd:y,onTransitionCancel:x}}),this._activeRipples.set(b,M),(m||!c)&&this._finishRippleTransition(b),b}fadeOutRipple(t){if(2===t.state||3===t.state)return;let e=t.element,i={...C7,...t.config.animation};e.style.transitionDuration=`${i.exitDuration}ms`,e.style.opacity="0",t.state=2,(t._animationForciblyDisabledThroughCss||!i.exitDuration)&&this._finishRippleTransition(t)}fadeOutAll(){this._getActiveRipples().forEach(t=>t.fadeOut())}fadeOutAllNonPersistent(){this._getActiveRipples().forEach(t=>{t.config.persistent||t.fadeOut()})}setupTriggerEvents(t){let e=Hs(t);!this._platform.isBrowser||!e||e===this._triggerElement||(this._removeTriggerEvents(),this._triggerElement=e,w7.forEach(i=>{vf._eventManager.addHandler(this._ngZone,i,e,this)}))}handleEvent(t){"mousedown"===t.type?this._onMousedown(t):"touchstart"===t.type?this._onTouchStart(t):this._onPointerUp(),this._pointerUpEventsRegistered||(this._ngZone.runOutsideAngular(()=>{S7.forEach(e=>{this._triggerElement.addEventListener(e,this,M7)})}),this._pointerUpEventsRegistered=!0)}_finishRippleTransition(t){0===t.state?this._startFadeOutTransition(t):2===t.state&&this._destroyRipple(t)}_startFadeOutTransition(t){let e=t===this._mostRecentTransientRipple,{persistent:i}=t.config;t.state=1,!i&&(!e||!this._isPointerDown)&&t.fadeOut()}_destroyRipple(t){let e=this._activeRipples.get(t)??null;this._activeRipples.delete(t),this._activeRipples.size||(this._containerRect=null),t===this._mostRecentTransientRipple&&(this._mostRecentTransientRipple=null),t.state=3,null!==e&&(t.element.removeEventListener("transitionend",e.onTransitionEnd),t.element.removeEventListener("transitioncancel",e.onTransitionCancel)),t.element.remove()}_onMousedown(t){let e=Lv(t),i=this._lastTouchStartEvent&&Date.now()<this._lastTouchStartEvent+800;!this._target.rippleDisabled&&!e&&!i&&(this._isPointerDown=!0,this.fadeInRipple(t.clientX,t.clientY,this._target.rippleConfig))}_onTouchStart(t){if(!this._target.rippleDisabled&&!Bv(t)){this._lastTouchStartEvent=Date.now(),this._isPointerDown=!0;let e=t.changedTouches;for(let i=0;i<e.length;i++)this.fadeInRipple(e[i].clientX,e[i].clientY,this._target.rippleConfig)}}_onPointerUp(){!this._isPointerDown||(this._isPointerDown=!1,this._getActiveRipples().forEach(t=>{!t.config.persistent&&(1===t.state||t.config.terminateOnPointerUp&&0===t.state)&&t.fadeOut()}))}_getActiveRipples(){return Array.from(this._activeRipples.keys())}_removeTriggerEvents(){let t=this._triggerElement;t&&(w7.forEach(e=>vf._eventManager.removeHandler(e,t,this)),this._pointerUpEventsRegistered&&S7.forEach(e=>t.removeEventListener(e,this,M7)))}};vf._eventManager=new class{constructor(){this._events=new Map,this._delegateEventHandler=t=>{let e=ma(t);e&&this._events.get(t.type)?.forEach((i,r)=>{(r===e||r.contains(e))&&i.forEach(o=>o.handleEvent(t))})}}addHandler(t,e,i,r){let o=this._events.get(e);if(o){let s=o.get(i);s?s.add(r):o.set(i,new Set([r]))}else this._events.set(e,new Map([[i,new Set([r])]])),t.runOutsideAngular(()=>{document.addEventListener(e,this._delegateEventHandler,x7)})}removeHandler(t,e,i){let r=this._events.get(t);if(!r)return;let o=r.get(e);!o||(o.delete(i),0===o.size&&r.delete(e),0===r.size&&(this._events.delete(t),document.removeEventListener(t,this._delegateEventHandler,x7)))}};var y2=new ie("mat-ripple-global-options"),mo=(()=>{class n{get disabled(){return this._disabled}set disabled(e){e&&this.fadeOutAllNonPersistent(),this._disabled=e,this._setupTriggerEventsIfEnabled()}get trigger(){return this._trigger||this._elementRef.nativeElement}set trigger(e){this._trigger=e,this._setupTriggerEventsIfEnabled()}constructor(e,i,r,o,s){this._elementRef=e,this._animationMode=s,this.radius=0,this._disabled=!1,this._isInitialized=!1,this._globalOptions=o||{},this._rippleRenderer=new vf(this,i,e,r)}ngOnInit(){this._isInitialized=!0,this._setupTriggerEventsIfEnabled()}ngOnDestroy(){this._rippleRenderer._removeTriggerEvents()}fadeOutAll(){this._rippleRenderer.fadeOutAll()}fadeOutAllNonPersistent(){this._rippleRenderer.fadeOutAllNonPersistent()}get rippleConfig(){return{centered:this.centered,radius:this.radius,color:this.color,animation:{...this._globalOptions.animation,..."NoopAnimations"===this._animationMode?{enterDuration:0,exitDuration:0}:{},...this.animation},terminateOnPointerUp:this._globalOptions.terminateOnPointerUp}}get rippleDisabled(){return this.disabled||!!this._globalOptions.disabled}_setupTriggerEventsIfEnabled(){!this.disabled&&this._isInitialized&&this._rippleRenderer.setupTriggerEvents(this.trigger)}launch(e,i=0,r){return"number"==typeof e?this._rippleRenderer.fadeInRipple(e,i,{...this.rippleConfig,...r}):this._rippleRenderer.fadeInRipple(0,0,{...this.rippleConfig,...e})}}return n.\u0275fac=function(e){return new(e||n)(C(Me),C(at),C(Gn),C(y2,8),C(hi,8))},n.\u0275dir=we({type:n,selectors:[["","mat-ripple",""],["","matRipple",""]],hostAttrs:[1,"mat-ripple"],hostVars:2,hostBindings:function(e,i){2&e&&nt("mat-ripple-unbounded",i.unbounded)},inputs:{color:["matRippleColor","color"],unbounded:["matRippleUnbounded","unbounded"],centered:["matRippleCentered","centered"],radius:["matRippleRadius","radius"],animation:["matRippleAnimation","animation"],disabled:["matRippleDisabled","disabled"],trigger:["matRippleTrigger","trigger"]},exportAs:["matRipple"]}),n})(),Bl=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[fn,fn]}),n})(),E_e=(()=>{class n{constructor(e){this._animationMode=e,this.state="unchecked",this.disabled=!1,this.appearance="full"}}return n.\u0275fac=function(e){return new(e||n)(C(hi,8))},n.\u0275cmp=O({type:n,selectors:[["mat-pseudo-checkbox"]],hostAttrs:[1,"mat-pseudo-checkbox"],hostVars:12,hostBindings:function(e,i){2&e&&nt("mat-pseudo-checkbox-indeterminate","indeterminate"===i.state)("mat-pseudo-checkbox-checked","checked"===i.state)("mat-pseudo-checkbox-disabled",i.disabled)("mat-pseudo-checkbox-minimal","minimal"===i.appearance)("mat-pseudo-checkbox-full","full"===i.appearance)("_mat-animation-noopable","NoopAnimations"===i._animationMode)},inputs:{state:"state",disabled:"disabled",appearance:"appearance"},decls:0,vars:0,template:function(e,i){},styles:['.mat-pseudo-checkbox{border-radius:2px;cursor:pointer;display:inline-block;vertical-align:middle;box-sizing:border-box;position:relative;flex-shrink:0;transition:border-color 90ms cubic-bezier(0, 0, 0.2, 0.1),background-color 90ms cubic-bezier(0, 0, 0.2, 0.1)}.mat-pseudo-checkbox::after{position:absolute;opacity:0;content:"";border-bottom:2px solid currentColor;transition:opacity 90ms cubic-bezier(0, 0, 0.2, 0.1)}.mat-pseudo-checkbox._mat-animation-noopable{transition:none !important;animation:none !important}.mat-pseudo-checkbox._mat-animation-noopable::after{transition:none}.mat-pseudo-checkbox-disabled{cursor:default}.mat-pseudo-checkbox-indeterminate::after{left:1px;opacity:1;border-radius:2px}.mat-pseudo-checkbox-checked::after{left:1px;border-left:2px solid currentColor;transform:rotate(-45deg);opacity:1;box-sizing:content-box}.mat-pseudo-checkbox-full{border:2px solid}.mat-pseudo-checkbox-full.mat-pseudo-checkbox-checked,.mat-pseudo-checkbox-full.mat-pseudo-checkbox-indeterminate{border-color:rgba(0,0,0,0)}.mat-pseudo-checkbox{width:18px;height:18px}.mat-pseudo-checkbox-minimal.mat-pseudo-checkbox-checked::after{width:14px;height:6px;transform-origin:center;top:-4.2426406871px;left:0;bottom:0;right:0;margin:auto}.mat-pseudo-checkbox-minimal.mat-pseudo-checkbox-indeterminate::after{top:8px;width:16px}.mat-pseudo-checkbox-full.mat-pseudo-checkbox-checked::after{width:10px;height:4px;transform-origin:center;top:-2.8284271247px;left:0;bottom:0;right:0;margin:auto}.mat-pseudo-checkbox-full.mat-pseudo-checkbox-indeterminate::after{top:6px;width:12px}'],encapsulation:2,changeDetection:0}),n})(),T_e=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[fn]}),n})(),zv=new ie("MAT_OPTION_PARENT_COMPONENT"),Uv=(so(class{}),new ie("MatOptgroup")),D_e=0,Hv=class{constructor(t,e=!1){this.source=t,this.isUserInput=e}},I_e=(()=>{class n{get multiple(){return this._parent&&this._parent.multiple}get selected(){return this._selected}get disabled(){return this.group&&this.group.disabled||this._disabled}set disabled(e){this._disabled=Rt(e)}get disableRipple(){return!(!this._parent||!this._parent.disableRipple)}get hideSingleSelectionIndicator(){return!(!this._parent||!this._parent.hideSingleSelectionIndicator)}constructor(e,i,r,o){this._element=e,this._changeDetectorRef=i,this._parent=r,this.group=o,this._selected=!1,this._active=!1,this._disabled=!1,this._mostRecentViewValue="",this.id="mat-option-"+D_e++,this.onSelectionChange=new F,this._stateChanges=new Ie}get active(){return this._active}get viewValue(){return(this._text?.nativeElement.textContent||"").trim()}select(){this._selected||(this._selected=!0,this._changeDetectorRef.markForCheck(),this._emitSelectionChangeEvent())}deselect(){this._selected&&(this._selected=!1,this._changeDetectorRef.markForCheck(),this._emitSelectionChangeEvent())}focus(e,i){let r=this._getHostElement();"function"==typeof r.focus&&r.focus(i)}setActiveStyles(){this._active||(this._active=!0,this._changeDetectorRef.markForCheck())}setInactiveStyles(){this._active&&(this._active=!1,this._changeDetectorRef.markForCheck())}getLabel(){return this.viewValue}_handleKeydown(e){(13===e.keyCode||32===e.keyCode)&&!vr(e)&&(this._selectViaInteraction(),e.preventDefault())}_selectViaInteraction(){this.disabled||(this._selected=!this.multiple||!this._selected,this._changeDetectorRef.markForCheck(),this._emitSelectionChangeEvent(!0))}_getTabIndex(){return this.disabled?"-1":"0"}_getHostElement(){return this._element.nativeElement}ngAfterViewChecked(){if(this._selected){let e=this.viewValue;e!==this._mostRecentViewValue&&(this._mostRecentViewValue&&this._stateChanges.next(),this._mostRecentViewValue=e)}}ngOnDestroy(){this._stateChanges.complete()}_emitSelectionChangeEvent(e=!1){this.onSelectionChange.emit(new Hv(this,e))}}return n.\u0275fac=function(e){Is()},n.\u0275dir=we({type:n,viewQuery:function(e,i){if(1&e&&Ge(h_e,7),2&e){let r;Se(r=Ee())&&(i._text=r.first)}},inputs:{value:"value",id:"id",disabled:"disabled"},outputs:{onSelectionChange:"onSelectionChange"}}),n})(),Us=(()=>{class n extends I_e{constructor(e,i,r,o){super(e,i,r,o)}}return n.\u0275fac=function(e){return new(e||n)(C(Me),C($t),C(zv,8),C(Uv,8))},n.\u0275cmp=O({type:n,selectors:[["mat-option"]],hostAttrs:["role","option",1,"mat-mdc-option","mdc-list-item"],hostVars:11,hostBindings:function(e,i){1&e&&I("click",function(){return i._selectViaInteraction()})("keydown",function(o){return i._handleKeydown(o)}),2&e&&(jo("id",i.id),Be("aria-selected",i.selected)("aria-disabled",i.disabled.toString()),nt("mdc-list-item--selected",i.selected)("mat-mdc-option-multiple",i.multiple)("mat-mdc-option-active",i.active)("mdc-list-item--disabled",i.disabled))},exportAs:["matOption"],features:[Ke],ngContentSelectors:y_e,decls:8,vars:5,consts:[["class","mat-mdc-option-pseudo-checkbox",3,"state","disabled",4,"ngIf"],[1,"mdc-list-item__primary-text"],["text",""],["class","mat-mdc-option-pseudo-checkbox","state","checked","appearance","minimal",3,"disabled",4,"ngIf"],["class","cdk-visually-hidden",4,"ngIf"],["mat-ripple","",1,"mat-mdc-option-ripple","mat-mdc-focus-indicator",3,"matRippleTrigger","matRippleDisabled"],[1,"mat-mdc-option-pseudo-checkbox",3,"state","disabled"],["state","checked","appearance","minimal",1,"mat-mdc-option-pseudo-checkbox",3,"disabled"],[1,"cdk-visually-hidden"]],template:function(e,i){1&e&&(Dn(v_e),S(0,g_e,1,2,"mat-pseudo-checkbox",0),zt(1),h(2,"span",1,2),zt(4,1),g(),S(5,__e,1,1,"mat-pseudo-checkbox",3),S(6,b_e,2,1,"span",4),P(7,"div",5)),2&e&&(_("ngIf",i.multiple),v(5),_("ngIf",!i.multiple&&i.selected&&!i.hideSingleSelectionIndicator),v(1),_("ngIf",i.group&&i.group._inert),v(1),_("matRippleTrigger",i._getHostElement())("matRippleDisabled",i.disabled||i.disableRipple))},dependencies:[mo,Fe,E_e],styles:['.mat-mdc-option{display:flex;position:relative;align-items:center;justify-content:flex-start;overflow:hidden;padding:0;padding-left:16px;padding-right:16px;-webkit-user-select:none;user-select:none;cursor:pointer;-webkit-tap-highlight-color:rgba(0,0,0,0);min-height:48px}.mat-mdc-option:focus{outline:none}[dir=rtl] .mat-mdc-option,.mat-mdc-option[dir=rtl]{padding-left:16px;padding-right:16px}.mat-mdc-option.mdc-list-item{align-items:center}.mat-mdc-option.mdc-list-item--disabled{opacity:.38;cursor:default}.mat-mdc-optgroup .mat-mdc-option:not(.mat-mdc-option-multiple){padding-left:32px}[dir=rtl] .mat-mdc-optgroup .mat-mdc-option:not(.mat-mdc-option-multiple){padding-left:16px;padding-right:32px}.mat-mdc-option .mat-icon,.mat-mdc-option .mat-pseudo-checkbox-full{margin-right:16px;flex-shrink:0}[dir=rtl] .mat-mdc-option .mat-icon,[dir=rtl] .mat-mdc-option .mat-pseudo-checkbox-full{margin-right:0;margin-left:16px}.mat-mdc-option .mat-pseudo-checkbox-minimal{margin-left:16px;flex-shrink:0}[dir=rtl] .mat-mdc-option .mat-pseudo-checkbox-minimal{margin-right:16px;margin-left:0}.mat-mdc-option .mat-mdc-option-ripple{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none}.mat-mdc-option .mdc-list-item__primary-text{white-space:normal;font-size:inherit;font-weight:inherit;letter-spacing:inherit;line-height:inherit;font-family:inherit;text-decoration:inherit;text-transform:inherit;margin-right:auto}[dir=rtl] .mat-mdc-option .mdc-list-item__primary-text{margin-right:0;margin-left:auto}.cdk-high-contrast-active .mat-mdc-option.mdc-list-item--selected:not(.mat-mdc-option-multiple)::after{content:"";position:absolute;top:50%;right:16px;transform:translateY(-50%);width:10px;height:0;border-bottom:solid 10px;border-radius:10px}[dir=rtl] .cdk-high-contrast-active .mat-mdc-option.mdc-list-item--selected:not(.mat-mdc-option-multiple)::after{right:auto;left:16px}.mat-mdc-option-active .mat-mdc-focus-indicator::before{content:""}'],encapsulation:2,changeDetection:0}),n})();function z1(n,t,e){if(e.length){let i=t.toArray(),r=e.toArray(),o=0;for(let s=0;s<n+1;s++)i[s].group&&i[s].group===r[o]&&o++;return o}return 0}function U1(n,t,e,i){return n<e?n:n+t>e+i?Math.max(0,n-i+t):e}var cg=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Bl,Pe,fn,T_e]}),n})(),D7=["mat-button",""],x2=[[["",8,"material-icons",3,"iconPositionEnd",""],["mat-icon",3,"iconPositionEnd",""],["","matButtonIcon","",3,"iconPositionEnd",""]],"*",[["","iconPositionEnd","",8,"material-icons"],["mat-icon","iconPositionEnd",""],["","matButtonIcon","","iconPositionEnd",""]]],C2=[".material-icons:not([iconPositionEnd]), mat-icon:not([iconPositionEnd]), [matButtonIcon]:not([iconPositionEnd])","*",".material-icons[iconPositionEnd], mat-icon[iconPositionEnd], [matButtonIcon][iconPositionEnd]"],M2=".cdk-high-contrast-active .mat-mdc-button:not(.mdc-button--outlined),.cdk-high-contrast-active .mat-mdc-unelevated-button:not(.mdc-button--outlined),.cdk-high-contrast-active .mat-mdc-raised-button:not(.mdc-button--outlined),.cdk-high-contrast-active .mat-mdc-outlined-button:not(.mdc-button--outlined),.cdk-high-contrast-active .mat-mdc-icon-button{outline:solid 1px}",I7=["mat-icon-button",""],R_e=["*"],O_e=[{selector:"mat-button",mdcClasses:["mdc-button","mat-mdc-button"]},{selector:"mat-flat-button",mdcClasses:["mdc-button","mdc-button--unelevated","mat-mdc-unelevated-button"]},{selector:"mat-raised-button",mdcClasses:["mdc-button","mdc-button--raised","mat-mdc-raised-button"]},{selector:"mat-stroked-button",mdcClasses:["mdc-button","mdc-button--outlined","mat-mdc-outlined-button"]},{selector:"mat-fab",mdcClasses:["mdc-fab","mat-mdc-fab"]},{selector:"mat-mini-fab",mdcClasses:["mdc-fab","mdc-fab--mini","mat-mdc-mini-fab"]},{selector:"mat-icon-button",mdcClasses:["mdc-icon-button","mat-mdc-icon-button"]}],k_e=zs(so(us(class{constructor(n){this._elementRef=n}}))),w2=(()=>{class n extends k_e{constructor(e,i,r,o){super(e),this._platform=i,this._ngZone=r,this._animationMode=o,this._focusMonitor=ai(Xr),this._isFab=!1;let s=e.nativeElement.classList;for(let a of O_e)this._hasHostAttributes(a.selector)&&a.mdcClasses.forEach(l=>{s.add(l)})}ngAfterViewInit(){this._focusMonitor.monitor(this._elementRef,!0)}ngOnDestroy(){this._focusMonitor.stopMonitoring(this._elementRef)}focus(e="program",i){e?this._focusMonitor.focusVia(this._elementRef.nativeElement,e,i):this._elementRef.nativeElement.focus(i)}_hasHostAttributes(...e){return e.some(i=>this._elementRef.nativeElement.hasAttribute(i))}_isRippleDisabled(){return this.disableRipple||this.disabled}}return n.\u0275fac=function(e){Is()},n.\u0275dir=we({type:n,viewQuery:function(e,i){if(1&e&&Ge(mo,5),2&e){let r;Se(r=Ee())&&(i.ripple=r.first)}},features:[Ke]}),n})(),A7=(()=>{class n extends w2{constructor(e,i,r,o){super(e,i,r,o),this._haltDisabledEvents=s=>{this.disabled&&(s.preventDefault(),s.stopImmediatePropagation())}}ngOnInit(){this._ngZone.runOutsideAngular(()=>{this._elementRef.nativeElement.addEventListener("click",this._haltDisabledEvents)})}ngOnDestroy(){super.ngOnDestroy(),this._elementRef.nativeElement.removeEventListener("click",this._haltDisabledEvents)}}return n.\u0275fac=function(e){Is()},n.\u0275dir=we({type:n,features:[Ke]}),n})(),Ji=(()=>{class n extends w2{constructor(e,i,r,o){super(e,i,r,o)}}return n.\u0275fac=function(e){return new(e||n)(C(Me),C(Gn),C(at),C(hi,8))},n.\u0275cmp=O({type:n,selectors:[["button","mat-button",""],["button","mat-raised-button",""],["button","mat-flat-button",""],["button","mat-stroked-button",""]],hostVars:7,hostBindings:function(e,i){2&e&&(Be("disabled",i.disabled||null),nt("_mat-animation-noopable","NoopAnimations"===i._animationMode)("mat-unthemed",!i.color)("mat-mdc-button-base",!0))},inputs:{disabled:"disabled",disableRipple:"disableRipple",color:"color"},exportAs:["matButton"],features:[Ke],attrs:D7,ngContentSelectors:C2,decls:8,vars:6,consts:[[1,"mat-mdc-button-persistent-ripple"],[1,"mdc-button__label"],[1,"mat-mdc-focus-indicator"],["matRipple","",1,"mat-mdc-button-ripple",3,"matRippleDisabled","matRippleTrigger"],[1,"mat-mdc-button-touch-target"]],template:function(e,i){1&e&&(Dn(x2),P(0,"span",0),zt(1),h(2,"span",1),zt(3,1),g(),zt(4,2),P(5,"span",2)(6,"span",3)(7,"span",4)),2&e&&(nt("mdc-button__ripple",!i._isFab)("mdc-fab__ripple",i._isFab),v(6),_("matRippleDisabled",i._isRippleDisabled())("matRippleTrigger",i._elementRef.nativeElement))},dependencies:[mo],styles:['.mdc-touch-target-wrapper{display:inline}.mdc-elevation-overlay{position:absolute;border-radius:inherit;pointer-events:none;opacity:var(--mdc-elevation-overlay-opacity, 0);transition:opacity 280ms cubic-bezier(0.4, 0, 0.2, 1)}.mdc-button{position:relative;display:inline-flex;align-items:center;justify-content:center;box-sizing:border-box;min-width:64px;border:none;outline:none;line-height:inherit;user-select:none;-webkit-appearance:none;overflow:visible;vertical-align:middle;background:rgba(0,0,0,0)}.mdc-button .mdc-elevation-overlay{width:100%;height:100%;top:0;left:0}.mdc-button::-moz-focus-inner{padding:0;border:0}.mdc-button:active{outline:none}.mdc-button:hover{cursor:pointer}.mdc-button:disabled{cursor:default;pointer-events:none}.mdc-button[hidden]{display:none}.mdc-button .mdc-button__icon{margin-left:0;margin-right:8px;display:inline-block;position:relative;vertical-align:top}[dir=rtl] .mdc-button .mdc-button__icon,.mdc-button .mdc-button__icon[dir=rtl]{margin-left:8px;margin-right:0}.mdc-button .mdc-button__progress-indicator{font-size:0;position:absolute;transform:translate(-50%, -50%);top:50%;left:50%;line-height:initial}.mdc-button .mdc-button__label{position:relative}.mdc-button .mdc-button__focus-ring{pointer-events:none;border:2px solid rgba(0,0,0,0);border-radius:6px;box-sizing:content-box;position:absolute;top:50%;left:50%;transform:translate(-50%, -50%);height:calc(\n      100% + 4px\n    );width:calc(\n      100% + 4px\n    );display:none}@media screen and (forced-colors: active){.mdc-button .mdc-button__focus-ring{border-color:CanvasText}}.mdc-button .mdc-button__focus-ring::after{content:"";border:2px solid rgba(0,0,0,0);border-radius:8px;display:block;position:absolute;top:50%;left:50%;transform:translate(-50%, -50%);height:calc(100% + 4px);width:calc(100% + 4px)}@media screen and (forced-colors: active){.mdc-button .mdc-button__focus-ring::after{border-color:CanvasText}}@media screen and (forced-colors: active){.mdc-button.mdc-ripple-upgraded--background-focused .mdc-button__focus-ring,.mdc-button:not(.mdc-ripple-upgraded):focus .mdc-button__focus-ring{display:block}}.mdc-button .mdc-button__touch{position:absolute;top:50%;height:48px;left:0;right:0;transform:translateY(-50%)}.mdc-button__label+.mdc-button__icon{margin-left:8px;margin-right:0}[dir=rtl] .mdc-button__label+.mdc-button__icon,.mdc-button__label+.mdc-button__icon[dir=rtl]{margin-left:0;margin-right:8px}svg.mdc-button__icon{fill:currentColor}.mdc-button--touch{margin-top:6px;margin-bottom:6px}.mdc-button{padding:0 8px 0 8px}.mdc-button--unelevated{transition:box-shadow 280ms cubic-bezier(0.4, 0, 0.2, 1);padding:0 16px 0 16px}.mdc-button--unelevated.mdc-button--icon-trailing{padding:0 12px 0 16px}.mdc-button--unelevated.mdc-button--icon-leading{padding:0 16px 0 12px}.mdc-button--raised{transition:box-shadow 280ms cubic-bezier(0.4, 0, 0.2, 1);padding:0 16px 0 16px}.mdc-button--raised.mdc-button--icon-trailing{padding:0 12px 0 16px}.mdc-button--raised.mdc-button--icon-leading{padding:0 16px 0 12px}.mdc-button--outlined{border-style:solid;transition:border 280ms cubic-bezier(0.4, 0, 0.2, 1)}.mdc-button--outlined .mdc-button__ripple{border-style:solid;border-color:rgba(0,0,0,0)}.mat-mdc-button{height:var(--mdc-text-button-container-height, 36px);border-radius:var(--mdc-text-button-container-shape, var(--mdc-shape-small, 4px))}.mat-mdc-button:not(:disabled){color:var(--mdc-text-button-label-text-color, inherit)}.mat-mdc-button:disabled{color:var(--mdc-text-button-disabled-label-text-color, rgba(0, 0, 0, 0.38))}.mat-mdc-button .mdc-button__ripple{border-radius:var(--mdc-text-button-container-shape, var(--mdc-shape-small, 4px))}.mat-mdc-unelevated-button{height:var(--mdc-filled-button-container-height, 36px);border-radius:var(--mdc-filled-button-container-shape, var(--mdc-shape-small, 4px))}.mat-mdc-unelevated-button:not(:disabled){background-color:var(--mdc-filled-button-container-color, transparent)}.mat-mdc-unelevated-button:disabled{background-color:var(--mdc-filled-button-disabled-container-color, rgba(0, 0, 0, 0.12))}.mat-mdc-unelevated-button:not(:disabled){color:var(--mdc-filled-button-label-text-color, inherit)}.mat-mdc-unelevated-button:disabled{color:var(--mdc-filled-button-disabled-label-text-color, rgba(0, 0, 0, 0.38))}.mat-mdc-unelevated-button .mdc-button__ripple{border-radius:var(--mdc-filled-button-container-shape, var(--mdc-shape-small, 4px))}.mat-mdc-raised-button{height:var(--mdc-protected-button-container-height, 36px);border-radius:var(--mdc-protected-button-container-shape, var(--mdc-shape-small, 4px));box-shadow:var(--mdc-protected-button-container-elevation, 0px 3px 1px -2px rgba(0, 0, 0, 0.2), 0px 2px 2px 0px rgba(0, 0, 0, 0.14), 0px 1px 5px 0px rgba(0, 0, 0, 0.12))}.mat-mdc-raised-button:not(:disabled){background-color:var(--mdc-protected-button-container-color, transparent)}.mat-mdc-raised-button:disabled{background-color:var(--mdc-protected-button-disabled-container-color, rgba(0, 0, 0, 0.12))}.mat-mdc-raised-button:not(:disabled){color:var(--mdc-protected-button-label-text-color, inherit)}.mat-mdc-raised-button:disabled{color:var(--mdc-protected-button-disabled-label-text-color, rgba(0, 0, 0, 0.38))}.mat-mdc-raised-button .mdc-button__ripple{border-radius:var(--mdc-protected-button-container-shape, var(--mdc-shape-small, 4px))}.mat-mdc-raised-button.mdc-ripple-upgraded--background-focused,.mat-mdc-raised-button:not(.mdc-ripple-upgraded):focus{box-shadow:var(--mdc-protected-button-focus-container-elevation, 0px 2px 4px -1px rgba(0, 0, 0, 0.2), 0px 4px 5px 0px rgba(0, 0, 0, 0.14), 0px 1px 10px 0px rgba(0, 0, 0, 0.12))}.mat-mdc-raised-button:hover{box-shadow:var(--mdc-protected-button-hover-container-elevation, 0px 2px 4px -1px rgba(0, 0, 0, 0.2), 0px 4px 5px 0px rgba(0, 0, 0, 0.14), 0px 1px 10px 0px rgba(0, 0, 0, 0.12))}.mat-mdc-raised-button:not(:disabled):active{box-shadow:var(--mdc-protected-button-pressed-container-elevation, 0px 5px 5px -3px rgba(0, 0, 0, 0.2), 0px 8px 10px 1px rgba(0, 0, 0, 0.14), 0px 3px 14px 2px rgba(0, 0, 0, 0.12))}.mat-mdc-raised-button:disabled{box-shadow:var(--mdc-protected-button-disabled-container-elevation, 0px 0px 0px 0px rgba(0, 0, 0, 0.2), 0px 0px 0px 0px rgba(0, 0, 0, 0.14), 0px 0px 0px 0px rgba(0, 0, 0, 0.12))}.mat-mdc-outlined-button{height:var(--mdc-outlined-button-container-height, 36px);border-radius:var(--mdc-outlined-button-container-shape, var(--mdc-shape-small, 4px));padding:0 15px 0 15px;border-width:var(--mdc-outlined-button-outline-width, 1px)}.mat-mdc-outlined-button:not(:disabled){color:var(--mdc-outlined-button-label-text-color, inherit)}.mat-mdc-outlined-button:disabled{color:var(--mdc-outlined-button-disabled-label-text-color, rgba(0, 0, 0, 0.38))}.mat-mdc-outlined-button .mdc-button__ripple{border-radius:var(--mdc-outlined-button-container-shape, var(--mdc-shape-small, 4px))}.mat-mdc-outlined-button:not(:disabled){border-color:var(--mdc-outlined-button-outline-color, rgba(0, 0, 0, 0.12))}.mat-mdc-outlined-button:disabled{border-color:var(--mdc-outlined-button-disabled-outline-color, rgba(0, 0, 0, 0.12))}.mat-mdc-outlined-button.mdc-button--icon-trailing{padding:0 11px 0 15px}.mat-mdc-outlined-button.mdc-button--icon-leading{padding:0 15px 0 11px}.mat-mdc-outlined-button .mdc-button__ripple{top:-1px;left:-1px;bottom:-1px;right:-1px;border-width:var(--mdc-outlined-button-outline-width, 1px)}.mat-mdc-outlined-button .mdc-button__touch{left:calc(-1 * var(--mdc-outlined-button-outline-width, 1px));width:calc(100% + 2 * var(--mdc-outlined-button-outline-width, 1px))}.mat-mdc-button,.mat-mdc-unelevated-button,.mat-mdc-raised-button,.mat-mdc-outlined-button{-webkit-tap-highlight-color:rgba(0,0,0,0)}.mat-mdc-button .mat-mdc-button-ripple,.mat-mdc-button .mat-mdc-button-persistent-ripple,.mat-mdc-button .mat-mdc-button-persistent-ripple::before,.mat-mdc-unelevated-button .mat-mdc-button-ripple,.mat-mdc-unelevated-button .mat-mdc-button-persistent-ripple,.mat-mdc-unelevated-button .mat-mdc-button-persistent-ripple::before,.mat-mdc-raised-button .mat-mdc-button-ripple,.mat-mdc-raised-button .mat-mdc-button-persistent-ripple,.mat-mdc-raised-button .mat-mdc-button-persistent-ripple::before,.mat-mdc-outlined-button .mat-mdc-button-ripple,.mat-mdc-outlined-button .mat-mdc-button-persistent-ripple,.mat-mdc-outlined-button .mat-mdc-button-persistent-ripple::before{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none;border-radius:inherit}.mat-mdc-button .mat-mdc-button-persistent-ripple::before,.mat-mdc-unelevated-button .mat-mdc-button-persistent-ripple::before,.mat-mdc-raised-button .mat-mdc-button-persistent-ripple::before,.mat-mdc-outlined-button .mat-mdc-button-persistent-ripple::before{content:"";opacity:0;background-color:var(--mat-mdc-button-persistent-ripple-color)}.mat-mdc-button .mat-ripple-element,.mat-mdc-unelevated-button .mat-ripple-element,.mat-mdc-raised-button .mat-ripple-element,.mat-mdc-outlined-button .mat-ripple-element{background-color:var(--mat-mdc-button-ripple-color)}.mat-mdc-button .mdc-button__label,.mat-mdc-unelevated-button .mdc-button__label,.mat-mdc-raised-button .mdc-button__label,.mat-mdc-outlined-button .mdc-button__label{z-index:1}.mat-mdc-button .mat-mdc-focus-indicator,.mat-mdc-unelevated-button .mat-mdc-focus-indicator,.mat-mdc-raised-button .mat-mdc-focus-indicator,.mat-mdc-outlined-button .mat-mdc-focus-indicator{top:0;left:0;right:0;bottom:0;position:absolute}.mat-mdc-button:focus .mat-mdc-focus-indicator::before,.mat-mdc-unelevated-button:focus .mat-mdc-focus-indicator::before,.mat-mdc-raised-button:focus .mat-mdc-focus-indicator::before,.mat-mdc-outlined-button:focus .mat-mdc-focus-indicator::before{content:""}.mat-mdc-button[disabled],.mat-mdc-unelevated-button[disabled],.mat-mdc-raised-button[disabled],.mat-mdc-outlined-button[disabled]{cursor:default;pointer-events:none}.mat-mdc-button .mat-mdc-button-touch-target,.mat-mdc-unelevated-button .mat-mdc-button-touch-target,.mat-mdc-raised-button .mat-mdc-button-touch-target,.mat-mdc-outlined-button .mat-mdc-button-touch-target{position:absolute;top:50%;height:48px;left:0;right:0;transform:translateY(-50%)}.mat-mdc-button._mat-animation-noopable,.mat-mdc-unelevated-button._mat-animation-noopable,.mat-mdc-raised-button._mat-animation-noopable,.mat-mdc-outlined-button._mat-animation-noopable{transition:none !important;animation:none !important}.mat-mdc-button>.mat-icon{margin-left:0;margin-right:8px;display:inline-block;position:relative;vertical-align:top;font-size:1.125rem;height:1.125rem;width:1.125rem}[dir=rtl] .mat-mdc-button>.mat-icon,.mat-mdc-button>.mat-icon[dir=rtl]{margin-left:8px;margin-right:0}.mat-mdc-button .mdc-button__label+.mat-icon{margin-left:8px;margin-right:0}[dir=rtl] .mat-mdc-button .mdc-button__label+.mat-icon,.mat-mdc-button .mdc-button__label+.mat-icon[dir=rtl]{margin-left:0;margin-right:8px}.mat-mdc-unelevated-button>.mat-icon,.mat-mdc-raised-button>.mat-icon,.mat-mdc-outlined-button>.mat-icon{margin-left:0;margin-right:8px;display:inline-block;position:relative;vertical-align:top;font-size:1.125rem;height:1.125rem;width:1.125rem;margin-left:-4px;margin-right:8px}[dir=rtl] .mat-mdc-unelevated-button>.mat-icon,[dir=rtl] .mat-mdc-raised-button>.mat-icon,[dir=rtl] .mat-mdc-outlined-button>.mat-icon,.mat-mdc-unelevated-button>.mat-icon[dir=rtl],.mat-mdc-raised-button>.mat-icon[dir=rtl],.mat-mdc-outlined-button>.mat-icon[dir=rtl]{margin-left:8px;margin-right:0}[dir=rtl] .mat-mdc-unelevated-button>.mat-icon,[dir=rtl] .mat-mdc-raised-button>.mat-icon,[dir=rtl] .mat-mdc-outlined-button>.mat-icon,.mat-mdc-unelevated-button>.mat-icon[dir=rtl],.mat-mdc-raised-button>.mat-icon[dir=rtl],.mat-mdc-outlined-button>.mat-icon[dir=rtl]{margin-left:8px;margin-right:-4px}.mat-mdc-unelevated-button .mdc-button__label+.mat-icon,.mat-mdc-raised-button .mdc-button__label+.mat-icon,.mat-mdc-outlined-button .mdc-button__label+.mat-icon{margin-left:8px;margin-right:-4px}[dir=rtl] .mat-mdc-unelevated-button .mdc-button__label+.mat-icon,[dir=rtl] .mat-mdc-raised-button .mdc-button__label+.mat-icon,[dir=rtl] .mat-mdc-outlined-button .mdc-button__label+.mat-icon,.mat-mdc-unelevated-button .mdc-button__label+.mat-icon[dir=rtl],.mat-mdc-raised-button .mdc-button__label+.mat-icon[dir=rtl],.mat-mdc-outlined-button .mdc-button__label+.mat-icon[dir=rtl]{margin-left:-4px;margin-right:8px}.mat-mdc-outlined-button .mat-mdc-button-ripple,.mat-mdc-outlined-button .mdc-button__ripple{top:-1px;left:-1px;bottom:-1px;right:-1px;border-width:-1px}.mat-mdc-unelevated-button .mat-mdc-focus-indicator::before,.mat-mdc-raised-button .mat-mdc-focus-indicator::before{margin:calc(calc(var(--mat-mdc-focus-indicator-border-width, 3px) + 2px) * -1)}.mat-mdc-outlined-button .mat-mdc-focus-indicator::before{margin:calc(calc(var(--mat-mdc-focus-indicator-border-width, 3px) + 3px) * -1)}',".cdk-high-contrast-active .mat-mdc-button:not(.mdc-button--outlined),.cdk-high-contrast-active .mat-mdc-unelevated-button:not(.mdc-button--outlined),.cdk-high-contrast-active .mat-mdc-raised-button:not(.mdc-button--outlined),.cdk-high-contrast-active .mat-mdc-outlined-button:not(.mdc-button--outlined),.cdk-high-contrast-active .mat-mdc-icon-button{outline:solid 1px}"],encapsulation:2,changeDetection:0}),n})(),R7=(()=>{class n extends A7{constructor(e,i,r,o){super(e,i,r,o)}}return n.\u0275fac=function(e){return new(e||n)(C(Me),C(Gn),C(at),C(hi,8))},n.\u0275cmp=O({type:n,selectors:[["a","mat-button",""],["a","mat-raised-button",""],["a","mat-flat-button",""],["a","mat-stroked-button",""]],hostVars:9,hostBindings:function(e,i){2&e&&(Be("disabled",i.disabled||null)("tabindex",i.disabled?-1:i.tabIndex)("aria-disabled",i.disabled.toString()),nt("_mat-animation-noopable","NoopAnimations"===i._animationMode)("mat-unthemed",!i.color)("mat-mdc-button-base",!0))},inputs:{disabled:"disabled",disableRipple:"disableRipple",color:"color",tabIndex:"tabIndex"},exportAs:["matButton","matAnchor"],features:[Ke],attrs:D7,ngContentSelectors:C2,decls:8,vars:6,consts:[[1,"mat-mdc-button-persistent-ripple"],[1,"mdc-button__label"],[1,"mat-mdc-focus-indicator"],["matRipple","",1,"mat-mdc-button-ripple",3,"matRippleDisabled","matRippleTrigger"],[1,"mat-mdc-button-touch-target"]],template:function(e,i){1&e&&(Dn(x2),P(0,"span",0),zt(1),h(2,"span",1),zt(3,1),g(),zt(4,2),P(5,"span",2)(6,"span",3)(7,"span",4)),2&e&&(nt("mdc-button__ripple",!i._isFab)("mdc-fab__ripple",i._isFab),v(6),_("matRippleDisabled",i._isRippleDisabled())("matRippleTrigger",i._elementRef.nativeElement))},dependencies:[mo],styles:['.mdc-touch-target-wrapper{display:inline}.mdc-elevation-overlay{position:absolute;border-radius:inherit;pointer-events:none;opacity:var(--mdc-elevation-overlay-opacity, 0);transition:opacity 280ms cubic-bezier(0.4, 0, 0.2, 1)}.mdc-button{position:relative;display:inline-flex;align-items:center;justify-content:center;box-sizing:border-box;min-width:64px;border:none;outline:none;line-height:inherit;user-select:none;-webkit-appearance:none;overflow:visible;vertical-align:middle;background:rgba(0,0,0,0)}.mdc-button .mdc-elevation-overlay{width:100%;height:100%;top:0;left:0}.mdc-button::-moz-focus-inner{padding:0;border:0}.mdc-button:active{outline:none}.mdc-button:hover{cursor:pointer}.mdc-button:disabled{cursor:default;pointer-events:none}.mdc-button[hidden]{display:none}.mdc-button .mdc-button__icon{margin-left:0;margin-right:8px;display:inline-block;position:relative;vertical-align:top}[dir=rtl] .mdc-button .mdc-button__icon,.mdc-button .mdc-button__icon[dir=rtl]{margin-left:8px;margin-right:0}.mdc-button .mdc-button__progress-indicator{font-size:0;position:absolute;transform:translate(-50%, -50%);top:50%;left:50%;line-height:initial}.mdc-button .mdc-button__label{position:relative}.mdc-button .mdc-button__focus-ring{pointer-events:none;border:2px solid rgba(0,0,0,0);border-radius:6px;box-sizing:content-box;position:absolute;top:50%;left:50%;transform:translate(-50%, -50%);height:calc(\n      100% + 4px\n    );width:calc(\n      100% + 4px\n    );display:none}@media screen and (forced-colors: active){.mdc-button .mdc-button__focus-ring{border-color:CanvasText}}.mdc-button .mdc-button__focus-ring::after{content:"";border:2px solid rgba(0,0,0,0);border-radius:8px;display:block;position:absolute;top:50%;left:50%;transform:translate(-50%, -50%);height:calc(100% + 4px);width:calc(100% + 4px)}@media screen and (forced-colors: active){.mdc-button .mdc-button__focus-ring::after{border-color:CanvasText}}@media screen and (forced-colors: active){.mdc-button.mdc-ripple-upgraded--background-focused .mdc-button__focus-ring,.mdc-button:not(.mdc-ripple-upgraded):focus .mdc-button__focus-ring{display:block}}.mdc-button .mdc-button__touch{position:absolute;top:50%;height:48px;left:0;right:0;transform:translateY(-50%)}.mdc-button__label+.mdc-button__icon{margin-left:8px;margin-right:0}[dir=rtl] .mdc-button__label+.mdc-button__icon,.mdc-button__label+.mdc-button__icon[dir=rtl]{margin-left:0;margin-right:8px}svg.mdc-button__icon{fill:currentColor}.mdc-button--touch{margin-top:6px;margin-bottom:6px}.mdc-button{padding:0 8px 0 8px}.mdc-button--unelevated{transition:box-shadow 280ms cubic-bezier(0.4, 0, 0.2, 1);padding:0 16px 0 16px}.mdc-button--unelevated.mdc-button--icon-trailing{padding:0 12px 0 16px}.mdc-button--unelevated.mdc-button--icon-leading{padding:0 16px 0 12px}.mdc-button--raised{transition:box-shadow 280ms cubic-bezier(0.4, 0, 0.2, 1);padding:0 16px 0 16px}.mdc-button--raised.mdc-button--icon-trailing{padding:0 12px 0 16px}.mdc-button--raised.mdc-button--icon-leading{padding:0 16px 0 12px}.mdc-button--outlined{border-style:solid;transition:border 280ms cubic-bezier(0.4, 0, 0.2, 1)}.mdc-button--outlined .mdc-button__ripple{border-style:solid;border-color:rgba(0,0,0,0)}.mat-mdc-button{height:var(--mdc-text-button-container-height, 36px);border-radius:var(--mdc-text-button-container-shape, var(--mdc-shape-small, 4px))}.mat-mdc-button:not(:disabled){color:var(--mdc-text-button-label-text-color, inherit)}.mat-mdc-button:disabled{color:var(--mdc-text-button-disabled-label-text-color, rgba(0, 0, 0, 0.38))}.mat-mdc-button .mdc-button__ripple{border-radius:var(--mdc-text-button-container-shape, var(--mdc-shape-small, 4px))}.mat-mdc-unelevated-button{height:var(--mdc-filled-button-container-height, 36px);border-radius:var(--mdc-filled-button-container-shape, var(--mdc-shape-small, 4px))}.mat-mdc-unelevated-button:not(:disabled){background-color:var(--mdc-filled-button-container-color, transparent)}.mat-mdc-unelevated-button:disabled{background-color:var(--mdc-filled-button-disabled-container-color, rgba(0, 0, 0, 0.12))}.mat-mdc-unelevated-button:not(:disabled){color:var(--mdc-filled-button-label-text-color, inherit)}.mat-mdc-unelevated-button:disabled{color:var(--mdc-filled-button-disabled-label-text-color, rgba(0, 0, 0, 0.38))}.mat-mdc-unelevated-button .mdc-button__ripple{border-radius:var(--mdc-filled-button-container-shape, var(--mdc-shape-small, 4px))}.mat-mdc-raised-button{height:var(--mdc-protected-button-container-height, 36px);border-radius:var(--mdc-protected-button-container-shape, var(--mdc-shape-small, 4px));box-shadow:var(--mdc-protected-button-container-elevation, 0px 3px 1px -2px rgba(0, 0, 0, 0.2), 0px 2px 2px 0px rgba(0, 0, 0, 0.14), 0px 1px 5px 0px rgba(0, 0, 0, 0.12))}.mat-mdc-raised-button:not(:disabled){background-color:var(--mdc-protected-button-container-color, transparent)}.mat-mdc-raised-button:disabled{background-color:var(--mdc-protected-button-disabled-container-color, rgba(0, 0, 0, 0.12))}.mat-mdc-raised-button:not(:disabled){color:var(--mdc-protected-button-label-text-color, inherit)}.mat-mdc-raised-button:disabled{color:var(--mdc-protected-button-disabled-label-text-color, rgba(0, 0, 0, 0.38))}.mat-mdc-raised-button .mdc-button__ripple{border-radius:var(--mdc-protected-button-container-shape, var(--mdc-shape-small, 4px))}.mat-mdc-raised-button.mdc-ripple-upgraded--background-focused,.mat-mdc-raised-button:not(.mdc-ripple-upgraded):focus{box-shadow:var(--mdc-protected-button-focus-container-elevation, 0px 2px 4px -1px rgba(0, 0, 0, 0.2), 0px 4px 5px 0px rgba(0, 0, 0, 0.14), 0px 1px 10px 0px rgba(0, 0, 0, 0.12))}.mat-mdc-raised-button:hover{box-shadow:var(--mdc-protected-button-hover-container-elevation, 0px 2px 4px -1px rgba(0, 0, 0, 0.2), 0px 4px 5px 0px rgba(0, 0, 0, 0.14), 0px 1px 10px 0px rgba(0, 0, 0, 0.12))}.mat-mdc-raised-button:not(:disabled):active{box-shadow:var(--mdc-protected-button-pressed-container-elevation, 0px 5px 5px -3px rgba(0, 0, 0, 0.2), 0px 8px 10px 1px rgba(0, 0, 0, 0.14), 0px 3px 14px 2px rgba(0, 0, 0, 0.12))}.mat-mdc-raised-button:disabled{box-shadow:var(--mdc-protected-button-disabled-container-elevation, 0px 0px 0px 0px rgba(0, 0, 0, 0.2), 0px 0px 0px 0px rgba(0, 0, 0, 0.14), 0px 0px 0px 0px rgba(0, 0, 0, 0.12))}.mat-mdc-outlined-button{height:var(--mdc-outlined-button-container-height, 36px);border-radius:var(--mdc-outlined-button-container-shape, var(--mdc-shape-small, 4px));padding:0 15px 0 15px;border-width:var(--mdc-outlined-button-outline-width, 1px)}.mat-mdc-outlined-button:not(:disabled){color:var(--mdc-outlined-button-label-text-color, inherit)}.mat-mdc-outlined-button:disabled{color:var(--mdc-outlined-button-disabled-label-text-color, rgba(0, 0, 0, 0.38))}.mat-mdc-outlined-button .mdc-button__ripple{border-radius:var(--mdc-outlined-button-container-shape, var(--mdc-shape-small, 4px))}.mat-mdc-outlined-button:not(:disabled){border-color:var(--mdc-outlined-button-outline-color, rgba(0, 0, 0, 0.12))}.mat-mdc-outlined-button:disabled{border-color:var(--mdc-outlined-button-disabled-outline-color, rgba(0, 0, 0, 0.12))}.mat-mdc-outlined-button.mdc-button--icon-trailing{padding:0 11px 0 15px}.mat-mdc-outlined-button.mdc-button--icon-leading{padding:0 15px 0 11px}.mat-mdc-outlined-button .mdc-button__ripple{top:-1px;left:-1px;bottom:-1px;right:-1px;border-width:var(--mdc-outlined-button-outline-width, 1px)}.mat-mdc-outlined-button .mdc-button__touch{left:calc(-1 * var(--mdc-outlined-button-outline-width, 1px));width:calc(100% + 2 * var(--mdc-outlined-button-outline-width, 1px))}.mat-mdc-button,.mat-mdc-unelevated-button,.mat-mdc-raised-button,.mat-mdc-outlined-button{-webkit-tap-highlight-color:rgba(0,0,0,0)}.mat-mdc-button .mat-mdc-button-ripple,.mat-mdc-button .mat-mdc-button-persistent-ripple,.mat-mdc-button .mat-mdc-button-persistent-ripple::before,.mat-mdc-unelevated-button .mat-mdc-button-ripple,.mat-mdc-unelevated-button .mat-mdc-button-persistent-ripple,.mat-mdc-unelevated-button .mat-mdc-button-persistent-ripple::before,.mat-mdc-raised-button .mat-mdc-button-ripple,.mat-mdc-raised-button .mat-mdc-button-persistent-ripple,.mat-mdc-raised-button .mat-mdc-button-persistent-ripple::before,.mat-mdc-outlined-button .mat-mdc-button-ripple,.mat-mdc-outlined-button .mat-mdc-button-persistent-ripple,.mat-mdc-outlined-button .mat-mdc-button-persistent-ripple::before{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none;border-radius:inherit}.mat-mdc-button .mat-mdc-button-persistent-ripple::before,.mat-mdc-unelevated-button .mat-mdc-button-persistent-ripple::before,.mat-mdc-raised-button .mat-mdc-button-persistent-ripple::before,.mat-mdc-outlined-button .mat-mdc-button-persistent-ripple::before{content:"";opacity:0;background-color:var(--mat-mdc-button-persistent-ripple-color)}.mat-mdc-button .mat-ripple-element,.mat-mdc-unelevated-button .mat-ripple-element,.mat-mdc-raised-button .mat-ripple-element,.mat-mdc-outlined-button .mat-ripple-element{background-color:var(--mat-mdc-button-ripple-color)}.mat-mdc-button .mdc-button__label,.mat-mdc-unelevated-button .mdc-button__label,.mat-mdc-raised-button .mdc-button__label,.mat-mdc-outlined-button .mdc-button__label{z-index:1}.mat-mdc-button .mat-mdc-focus-indicator,.mat-mdc-unelevated-button .mat-mdc-focus-indicator,.mat-mdc-raised-button .mat-mdc-focus-indicator,.mat-mdc-outlined-button .mat-mdc-focus-indicator{top:0;left:0;right:0;bottom:0;position:absolute}.mat-mdc-button:focus .mat-mdc-focus-indicator::before,.mat-mdc-unelevated-button:focus .mat-mdc-focus-indicator::before,.mat-mdc-raised-button:focus .mat-mdc-focus-indicator::before,.mat-mdc-outlined-button:focus .mat-mdc-focus-indicator::before{content:""}.mat-mdc-button[disabled],.mat-mdc-unelevated-button[disabled],.mat-mdc-raised-button[disabled],.mat-mdc-outlined-button[disabled]{cursor:default;pointer-events:none}.mat-mdc-button .mat-mdc-button-touch-target,.mat-mdc-unelevated-button .mat-mdc-button-touch-target,.mat-mdc-raised-button .mat-mdc-button-touch-target,.mat-mdc-outlined-button .mat-mdc-button-touch-target{position:absolute;top:50%;height:48px;left:0;right:0;transform:translateY(-50%)}.mat-mdc-button._mat-animation-noopable,.mat-mdc-unelevated-button._mat-animation-noopable,.mat-mdc-raised-button._mat-animation-noopable,.mat-mdc-outlined-button._mat-animation-noopable{transition:none !important;animation:none !important}.mat-mdc-button>.mat-icon{margin-left:0;margin-right:8px;display:inline-block;position:relative;vertical-align:top;font-size:1.125rem;height:1.125rem;width:1.125rem}[dir=rtl] .mat-mdc-button>.mat-icon,.mat-mdc-button>.mat-icon[dir=rtl]{margin-left:8px;margin-right:0}.mat-mdc-button .mdc-button__label+.mat-icon{margin-left:8px;margin-right:0}[dir=rtl] .mat-mdc-button .mdc-button__label+.mat-icon,.mat-mdc-button .mdc-button__label+.mat-icon[dir=rtl]{margin-left:0;margin-right:8px}.mat-mdc-unelevated-button>.mat-icon,.mat-mdc-raised-button>.mat-icon,.mat-mdc-outlined-button>.mat-icon{margin-left:0;margin-right:8px;display:inline-block;position:relative;vertical-align:top;font-size:1.125rem;height:1.125rem;width:1.125rem;margin-left:-4px;margin-right:8px}[dir=rtl] .mat-mdc-unelevated-button>.mat-icon,[dir=rtl] .mat-mdc-raised-button>.mat-icon,[dir=rtl] .mat-mdc-outlined-button>.mat-icon,.mat-mdc-unelevated-button>.mat-icon[dir=rtl],.mat-mdc-raised-button>.mat-icon[dir=rtl],.mat-mdc-outlined-button>.mat-icon[dir=rtl]{margin-left:8px;margin-right:0}[dir=rtl] .mat-mdc-unelevated-button>.mat-icon,[dir=rtl] .mat-mdc-raised-button>.mat-icon,[dir=rtl] .mat-mdc-outlined-button>.mat-icon,.mat-mdc-unelevated-button>.mat-icon[dir=rtl],.mat-mdc-raised-button>.mat-icon[dir=rtl],.mat-mdc-outlined-button>.mat-icon[dir=rtl]{margin-left:8px;margin-right:-4px}.mat-mdc-unelevated-button .mdc-button__label+.mat-icon,.mat-mdc-raised-button .mdc-button__label+.mat-icon,.mat-mdc-outlined-button .mdc-button__label+.mat-icon{margin-left:8px;margin-right:-4px}[dir=rtl] .mat-mdc-unelevated-button .mdc-button__label+.mat-icon,[dir=rtl] .mat-mdc-raised-button .mdc-button__label+.mat-icon,[dir=rtl] .mat-mdc-outlined-button .mdc-button__label+.mat-icon,.mat-mdc-unelevated-button .mdc-button__label+.mat-icon[dir=rtl],.mat-mdc-raised-button .mdc-button__label+.mat-icon[dir=rtl],.mat-mdc-outlined-button .mdc-button__label+.mat-icon[dir=rtl]{margin-left:-4px;margin-right:8px}.mat-mdc-outlined-button .mat-mdc-button-ripple,.mat-mdc-outlined-button .mdc-button__ripple{top:-1px;left:-1px;bottom:-1px;right:-1px;border-width:-1px}.mat-mdc-unelevated-button .mat-mdc-focus-indicator::before,.mat-mdc-raised-button .mat-mdc-focus-indicator::before{margin:calc(calc(var(--mat-mdc-focus-indicator-border-width, 3px) + 2px) * -1)}.mat-mdc-outlined-button .mat-mdc-focus-indicator::before{margin:calc(calc(var(--mat-mdc-focus-indicator-border-width, 3px) + 3px) * -1)}',M2],encapsulation:2,changeDetection:0}),n})();new ie("mat-mdc-fab-default-options",{providedIn:"root",factory:function(){return{color:"accent"}}});var $i=(()=>{class n extends w2{constructor(e,i,r,o){super(e,i,r,o)}}return n.\u0275fac=function(e){return new(e||n)(C(Me),C(Gn),C(at),C(hi,8))},n.\u0275cmp=O({type:n,selectors:[["button","mat-icon-button",""]],hostVars:7,hostBindings:function(e,i){2&e&&(Be("disabled",i.disabled||null),nt("_mat-animation-noopable","NoopAnimations"===i._animationMode)("mat-unthemed",!i.color)("mat-mdc-button-base",!0))},inputs:{disabled:"disabled",disableRipple:"disableRipple",color:"color"},exportAs:["matButton"],features:[Ke],attrs:I7,ngContentSelectors:R_e,decls:5,vars:3,consts:[[1,"mat-mdc-button-persistent-ripple","mdc-icon-button__ripple"],[1,"mat-mdc-focus-indicator"],["matRipple","",1,"mat-mdc-button-ripple",3,"matRippleDisabled","matRippleCentered","matRippleTrigger"],[1,"mat-mdc-button-touch-target"]],template:function(e,i){1&e&&(Dn(),P(0,"span",0),zt(1),P(2,"span",1)(3,"span",2)(4,"span",3)),2&e&&(v(3),_("matRippleDisabled",i._isRippleDisabled())("matRippleCentered",!0)("matRippleTrigger",i._elementRef.nativeElement))},dependencies:[mo],styles:['.mdc-icon-button{font-size:24px;width:48px;height:48px;padding:12px}.mdc-icon-button .mdc-icon-button__focus-ring{max-height:48px;max-width:48px}.mdc-icon-button.mdc-icon-button--reduced-size .mdc-icon-button__ripple{width:40px;height:40px;margin-top:4px;margin-bottom:4px;margin-right:4px;margin-left:4px}.mdc-icon-button.mdc-icon-button--reduced-size .mdc-icon-button__focus-ring{max-height:40px;max-width:40px}.mdc-icon-button .mdc-icon-button__touch{position:absolute;top:50%;height:48px;left:50%;width:48px;transform:translate(-50%, -50%)}.mdc-icon-button svg,.mdc-icon-button img{width:24px;height:24px}.mdc-icon-button{display:inline-block;position:relative;box-sizing:border-box;border:none;outline:none;background-color:rgba(0,0,0,0);fill:currentColor;color:inherit;text-decoration:none;cursor:pointer;user-select:none;z-index:0;overflow:visible}.mdc-icon-button .mdc-icon-button__touch{position:absolute;top:50%;height:48px;left:50%;width:48px;transform:translate(-50%, -50%)}@media screen and (forced-colors: active){.mdc-icon-button.mdc-ripple-upgraded--background-focused .mdc-icon-button__focus-ring,.mdc-icon-button:not(.mdc-ripple-upgraded):focus .mdc-icon-button__focus-ring{display:block}}.mdc-icon-button:disabled{cursor:default;pointer-events:none}.mdc-icon-button[hidden]{display:none}.mdc-icon-button--display-flex{align-items:center;display:inline-flex;justify-content:center}.mdc-icon-button__focus-ring{pointer-events:none;border:2px solid rgba(0,0,0,0);border-radius:6px;box-sizing:content-box;position:absolute;top:50%;left:50%;transform:translate(-50%, -50%);height:100%;width:100%;display:none}@media screen and (forced-colors: active){.mdc-icon-button__focus-ring{border-color:CanvasText}}.mdc-icon-button__focus-ring::after{content:"";border:2px solid rgba(0,0,0,0);border-radius:8px;display:block;position:absolute;top:50%;left:50%;transform:translate(-50%, -50%);height:calc(100% + 4px);width:calc(100% + 4px)}@media screen and (forced-colors: active){.mdc-icon-button__focus-ring::after{border-color:CanvasText}}.mdc-icon-button__icon{display:inline-block}.mdc-icon-button__icon.mdc-icon-button__icon--on{display:none}.mdc-icon-button--on .mdc-icon-button__icon{display:none}.mdc-icon-button--on .mdc-icon-button__icon.mdc-icon-button__icon--on{display:inline-block}.mdc-icon-button__link{height:100%;left:0;outline:none;position:absolute;top:0;width:100%}.mat-mdc-icon-button{height:var(--mdc-icon-button-state-layer-size, 48px);width:var(--mdc-icon-button-state-layer-size, 48px);color:var(--mdc-icon-button-icon-color, inherit);border-radius:50%;flex-shrink:0;text-align:center;-webkit-tap-highlight-color:rgba(0,0,0,0)}.mat-mdc-icon-button .mdc-button__icon{font-size:var(--mdc-icon-button-icon-size, 24px)}.mat-mdc-icon-button svg,.mat-mdc-icon-button img{width:var(--mdc-icon-button-icon-size, 24px);height:var(--mdc-icon-button-icon-size, 24px)}.mat-mdc-icon-button:disabled{opacity:var(--mdc-icon-button-disabled-icon-opacity, 0.38)}.mat-mdc-icon-button:disabled{color:var(--mdc-icon-button-disabled-icon-color, #000)}.mat-mdc-icon-button svg{vertical-align:baseline}.mat-mdc-icon-button[disabled]{cursor:default;pointer-events:none;opacity:1}.mat-mdc-icon-button .mat-mdc-button-ripple,.mat-mdc-icon-button .mat-mdc-button-persistent-ripple,.mat-mdc-icon-button .mat-mdc-button-persistent-ripple::before{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none;border-radius:inherit}.mat-mdc-icon-button .mat-mdc-button-persistent-ripple::before{content:"";opacity:0;background-color:var(--mat-mdc-button-persistent-ripple-color)}.mat-mdc-icon-button .mat-ripple-element{background-color:var(--mat-mdc-button-ripple-color)}.mat-mdc-icon-button .mdc-button__label{z-index:1}.mat-mdc-icon-button .mat-mdc-focus-indicator{top:0;left:0;right:0;bottom:0;position:absolute}.mat-mdc-icon-button:focus .mat-mdc-focus-indicator::before{content:""}.mat-mdc-icon-button .mat-mdc-button-touch-target{position:absolute;top:50%;height:48px;left:50%;width:48px;transform:translate(-50%, -50%)}.mat-mdc-icon-button._mat-animation-noopable{transition:none !important;animation:none !important}.mat-mdc-icon-button .mat-mdc-button-persistent-ripple{border-radius:50%}.mat-mdc-icon-button.mat-unthemed:not(.mdc-ripple-upgraded):focus::before,.mat-mdc-icon-button.mat-primary:not(.mdc-ripple-upgraded):focus::before,.mat-mdc-icon-button.mat-accent:not(.mdc-ripple-upgraded):focus::before,.mat-mdc-icon-button.mat-warn:not(.mdc-ripple-upgraded):focus::before{background:rgba(0,0,0,0);opacity:1}',M2],encapsulation:2,changeDetection:0}),n})(),O7=(()=>{class n extends A7{constructor(e,i,r,o){super(e,i,r,o)}}return n.\u0275fac=function(e){return new(e||n)(C(Me),C(Gn),C(at),C(hi,8))},n.\u0275cmp=O({type:n,selectors:[["a","mat-icon-button",""]],hostVars:9,hostBindings:function(e,i){2&e&&(Be("disabled",i.disabled||null)("tabindex",i.disabled?-1:i.tabIndex)("aria-disabled",i.disabled.toString()),nt("_mat-animation-noopable","NoopAnimations"===i._animationMode)("mat-unthemed",!i.color)("mat-mdc-button-base",!0))},inputs:{disabled:"disabled",disableRipple:"disableRipple",color:"color",tabIndex:"tabIndex"},exportAs:["matButton","matAnchor"],features:[Ke],attrs:I7,ngContentSelectors:C2,decls:8,vars:6,consts:[[1,"mat-mdc-button-persistent-ripple"],[1,"mdc-button__label"],[1,"mat-mdc-focus-indicator"],["matRipple","",1,"mat-mdc-button-ripple",3,"matRippleDisabled","matRippleTrigger"],[1,"mat-mdc-button-touch-target"]],template:function(e,i){1&e&&(Dn(x2),P(0,"span",0),zt(1),h(2,"span",1),zt(3,1),g(),zt(4,2),P(5,"span",2)(6,"span",3)(7,"span",4)),2&e&&(nt("mdc-button__ripple",!i._isFab)("mdc-fab__ripple",i._isFab),v(6),_("matRippleDisabled",i._isRippleDisabled())("matRippleTrigger",i._elementRef.nativeElement))},dependencies:[mo],styles:['.mdc-icon-button{font-size:24px;width:48px;height:48px;padding:12px}.mdc-icon-button .mdc-icon-button__focus-ring{max-height:48px;max-width:48px}.mdc-icon-button.mdc-icon-button--reduced-size .mdc-icon-button__ripple{width:40px;height:40px;margin-top:4px;margin-bottom:4px;margin-right:4px;margin-left:4px}.mdc-icon-button.mdc-icon-button--reduced-size .mdc-icon-button__focus-ring{max-height:40px;max-width:40px}.mdc-icon-button .mdc-icon-button__touch{position:absolute;top:50%;height:48px;left:50%;width:48px;transform:translate(-50%, -50%)}.mdc-icon-button svg,.mdc-icon-button img{width:24px;height:24px}.mdc-icon-button{display:inline-block;position:relative;box-sizing:border-box;border:none;outline:none;background-color:rgba(0,0,0,0);fill:currentColor;color:inherit;text-decoration:none;cursor:pointer;user-select:none;z-index:0;overflow:visible}.mdc-icon-button .mdc-icon-button__touch{position:absolute;top:50%;height:48px;left:50%;width:48px;transform:translate(-50%, -50%)}@media screen and (forced-colors: active){.mdc-icon-button.mdc-ripple-upgraded--background-focused .mdc-icon-button__focus-ring,.mdc-icon-button:not(.mdc-ripple-upgraded):focus .mdc-icon-button__focus-ring{display:block}}.mdc-icon-button:disabled{cursor:default;pointer-events:none}.mdc-icon-button[hidden]{display:none}.mdc-icon-button--display-flex{align-items:center;display:inline-flex;justify-content:center}.mdc-icon-button__focus-ring{pointer-events:none;border:2px solid rgba(0,0,0,0);border-radius:6px;box-sizing:content-box;position:absolute;top:50%;left:50%;transform:translate(-50%, -50%);height:100%;width:100%;display:none}@media screen and (forced-colors: active){.mdc-icon-button__focus-ring{border-color:CanvasText}}.mdc-icon-button__focus-ring::after{content:"";border:2px solid rgba(0,0,0,0);border-radius:8px;display:block;position:absolute;top:50%;left:50%;transform:translate(-50%, -50%);height:calc(100% + 4px);width:calc(100% + 4px)}@media screen and (forced-colors: active){.mdc-icon-button__focus-ring::after{border-color:CanvasText}}.mdc-icon-button__icon{display:inline-block}.mdc-icon-button__icon.mdc-icon-button__icon--on{display:none}.mdc-icon-button--on .mdc-icon-button__icon{display:none}.mdc-icon-button--on .mdc-icon-button__icon.mdc-icon-button__icon--on{display:inline-block}.mdc-icon-button__link{height:100%;left:0;outline:none;position:absolute;top:0;width:100%}.mat-mdc-icon-button{height:var(--mdc-icon-button-state-layer-size, 48px);width:var(--mdc-icon-button-state-layer-size, 48px);color:var(--mdc-icon-button-icon-color, inherit);border-radius:50%;flex-shrink:0;text-align:center;-webkit-tap-highlight-color:rgba(0,0,0,0)}.mat-mdc-icon-button .mdc-button__icon{font-size:var(--mdc-icon-button-icon-size, 24px)}.mat-mdc-icon-button svg,.mat-mdc-icon-button img{width:var(--mdc-icon-button-icon-size, 24px);height:var(--mdc-icon-button-icon-size, 24px)}.mat-mdc-icon-button:disabled{opacity:var(--mdc-icon-button-disabled-icon-opacity, 0.38)}.mat-mdc-icon-button:disabled{color:var(--mdc-icon-button-disabled-icon-color, #000)}.mat-mdc-icon-button svg{vertical-align:baseline}.mat-mdc-icon-button[disabled]{cursor:default;pointer-events:none;opacity:1}.mat-mdc-icon-button .mat-mdc-button-ripple,.mat-mdc-icon-button .mat-mdc-button-persistent-ripple,.mat-mdc-icon-button .mat-mdc-button-persistent-ripple::before{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none;border-radius:inherit}.mat-mdc-icon-button .mat-mdc-button-persistent-ripple::before{content:"";opacity:0;background-color:var(--mat-mdc-button-persistent-ripple-color)}.mat-mdc-icon-button .mat-ripple-element{background-color:var(--mat-mdc-button-ripple-color)}.mat-mdc-icon-button .mdc-button__label{z-index:1}.mat-mdc-icon-button .mat-mdc-focus-indicator{top:0;left:0;right:0;bottom:0;position:absolute}.mat-mdc-icon-button:focus .mat-mdc-focus-indicator::before{content:""}.mat-mdc-icon-button .mat-mdc-button-touch-target{position:absolute;top:50%;height:48px;left:50%;width:48px;transform:translate(-50%, -50%)}.mat-mdc-icon-button._mat-animation-noopable{transition:none !important;animation:none !important}.mat-mdc-icon-button .mat-mdc-button-persistent-ripple{border-radius:50%}.mat-mdc-icon-button.mat-unthemed:not(.mdc-ripple-upgraded):focus::before,.mat-mdc-icon-button.mat-primary:not(.mdc-ripple-upgraded):focus::before,.mat-mdc-icon-button.mat-accent:not(.mdc-ripple-upgraded):focus::before,.mat-mdc-icon-button.mat-warn:not(.mdc-ripple-upgraded):focus::before{background:rgba(0,0,0,0);opacity:1}',M2],encapsulation:2,changeDetection:0}),n})(),ci=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[fn,Bl,fn]}),n})(),jv=class{attach(t){return this._attachedHost=t,t.attach(this)}detach(){let t=this._attachedHost;null!=t&&(this._attachedHost=null,t.detach())}get isAttached(){return null!=this._attachedHost}setAttachedHost(t){this._attachedHost=t}},Vl=class extends jv{constructor(t,e,i,r,o){super(),this.component=t,this.viewContainerRef=e,this.injector=i,this.componentFactoryResolver=r,this.projectableNodes=o}},Yo=class extends jv{constructor(t,e,i,r){super(),this.templateRef=t,this.viewContainerRef=e,this.context=i,this.injector=r}get origin(){return this.templateRef.elementRef}attach(t,e=this.context){return this.context=e,super.attach(t)}detach(){return this.context=void 0,super.detach()}},S2=class extends jv{constructor(t){super(),this.element=t instanceof Me?t.nativeElement:t}},Fu=class{constructor(){this._isDisposed=!1,this.attachDomPortal=null}hasAttached(){return!!this._attachedPortal}attach(t){return t instanceof Vl?(this._attachedPortal=t,this.attachComponentPortal(t)):t instanceof Yo?(this._attachedPortal=t,this.attachTemplatePortal(t)):this.attachDomPortal&&t instanceof S2?(this._attachedPortal=t,this.attachDomPortal(t)):void 0}detach(){this._attachedPortal&&(this._attachedPortal.setAttachedHost(null),this._attachedPortal=null),this._invokeDisposeFn()}dispose(){this.hasAttached()&&this.detach(),this._invokeDisposeFn(),this._isDisposed=!0}setDisposeFn(t){this._disposeFn=t}_invokeDisposeFn(){this._disposeFn&&(this._disposeFn(),this._disposeFn=null)}},Gv=class extends Fu{constructor(t,e,i,r,o){super(),this.outletElement=t,this._componentFactoryResolver=e,this._appRef=i,this._defaultInjector=r,this.attachDomPortal=s=>{let a=s.element,l=this._document.createComment("dom-portal");a.parentNode.insertBefore(l,a),this.outletElement.appendChild(a),this._attachedPortal=s,super.setDisposeFn(()=>{l.parentNode&&l.parentNode.replaceChild(a,l)})},this._document=o}attachComponentPortal(t){let r,i=(t.componentFactoryResolver||this._componentFactoryResolver).resolveComponentFactory(t.component);return t.viewContainerRef?(r=t.viewContainerRef.createComponent(i,t.viewContainerRef.length,t.injector||t.viewContainerRef.injector,t.projectableNodes||void 0),this.setDisposeFn(()=>r.destroy())):(r=i.create(t.injector||this._defaultInjector||Mi.NULL),this._appRef.attachView(r.hostView),this.setDisposeFn(()=>{this._appRef.viewCount>0&&this._appRef.detachView(r.hostView),r.destroy()})),this.outletElement.appendChild(this._getComponentRootNode(r)),this._attachedPortal=t,r}attachTemplatePortal(t){let e=t.viewContainerRef,i=e.createEmbeddedView(t.templateRef,t.context,{injector:t.injector});return i.rootNodes.forEach(r=>this.outletElement.appendChild(r)),i.detectChanges(),this.setDisposeFn(()=>{let r=e.indexOf(i);-1!==r&&e.remove(r)}),this._attachedPortal=t,i}dispose(){super.dispose(),this.outletElement.remove()}_getComponentRootNode(t){return t.hostView.rootNodes[0]}},k7=(()=>{class n extends Yo{constructor(e,i){super(e,i)}}return n.\u0275fac=function(e){return new(e||n)(C(Si),C(si))},n.\u0275dir=we({type:n,selectors:[["","cdkPortal",""]],exportAs:["cdkPortal"],features:[Ke]}),n})(),ps=(()=>{class n extends Fu{constructor(e,i,r){super(),this._componentFactoryResolver=e,this._viewContainerRef=i,this._isInitialized=!1,this.attached=new F,this.attachDomPortal=o=>{let s=o.element,a=this._document.createComment("dom-portal");o.setAttachedHost(this),s.parentNode.insertBefore(a,s),this._getRootNode().appendChild(s),this._attachedPortal=o,super.setDisposeFn(()=>{a.parentNode&&a.parentNode.replaceChild(s,a)})},this._document=r}get portal(){return this._attachedPortal}set portal(e){this.hasAttached()&&!e&&!this._isInitialized||(this.hasAttached()&&super.detach(),e&&super.attach(e),this._attachedPortal=e||null)}get attachedRef(){return this._attachedRef}ngOnInit(){this._isInitialized=!0}ngOnDestroy(){super.dispose(),this._attachedRef=this._attachedPortal=null}attachComponentPortal(e){e.setAttachedHost(this);let i=null!=e.viewContainerRef?e.viewContainerRef:this._viewContainerRef,o=(e.componentFactoryResolver||this._componentFactoryResolver).resolveComponentFactory(e.component),s=i.createComponent(o,i.length,e.injector||i.injector,e.projectableNodes||void 0);return i!==this._viewContainerRef&&this._getRootNode().appendChild(s.hostView.rootNodes[0]),super.setDisposeFn(()=>s.destroy()),this._attachedPortal=e,this._attachedRef=s,this.attached.emit(s),s}attachTemplatePortal(e){e.setAttachedHost(this);let i=this._viewContainerRef.createEmbeddedView(e.templateRef,e.context,{injector:e.injector});return super.setDisposeFn(()=>this._viewContainerRef.clear()),this._attachedPortal=e,this._attachedRef=i,this.attached.emit(i),i}_getRootNode(){let e=this._viewContainerRef.element.nativeElement;return e.nodeType===e.ELEMENT_NODE?e:e.parentNode}}return n.\u0275fac=function(e){return new(e||n)(C(fo),C(si),C(Lt))},n.\u0275dir=we({type:n,selectors:[["","cdkPortalOutlet",""]],inputs:{portal:["cdkPortalOutlet","portal"]},outputs:{attached:"attached"},exportAs:["cdkPortalOutlet"],features:[Ke]}),n})(),Hl=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({}),n})(),Wv=class{},G1=class extends Wv{constructor(t){super(),this._data=t}connect(){return D_(this._data)?this._data:Ht(this._data)}disconnect(){}},qv=class{constructor(){this.viewCacheSize=20,this._viewCache=[]}applyChanges(t,e,i,r,o){t.forEachOperation((s,a,l)=>{let c,d;null==s.previousIndex?(c=this._insertView(()=>i(s,a,l),l,e,r(s)),d=c?1:0):null==l?(this._detachAndCacheView(a,e),d=3):(c=this._moveView(a,l,e,r(s)),d=2),o&&o({context:c?.context,operation:d,record:s})})}detach(){for(let t of this._viewCache)t.destroy();this._viewCache=[]}_insertView(t,e,i,r){let o=this._insertViewFromCache(e,i);if(o)return void(o.context.$implicit=r);let s=t();return i.createEmbeddedView(s.templateRef,s.context,s.index)}_detachAndCacheView(t,e){let i=e.detach(t);this._maybeCacheView(i,e)}_moveView(t,e,i,r){let o=i.get(t);return i.move(o,e),o.context.$implicit=r,o}_maybeCacheView(t,e){if(this._viewCache.length<this.viewCacheSize)this._viewCache.push(t);else{let i=e.indexOf(t);-1===i?t.destroy():e.remove(i)}}_insertViewFromCache(t,e){let i=this._viewCache.pop();return i&&e.insert(i,t),i||null}},dg=class{get selected(){return this._selected||(this._selected=Array.from(this._selection.values())),this._selected}constructor(t=!1,e,i=!0,r){this._multiple=t,this._emitChanges=i,this.compareWith=r,this._selection=new Set,this._deselectedToEmit=[],this._selectedToEmit=[],this.changed=new Ie,e&&e.length&&(t?e.forEach(o=>this._markSelected(o)):this._markSelected(e[0]),this._selectedToEmit.length=0)}select(...t){this._verifyValueAssignment(t),t.forEach(i=>this._markSelected(i));let e=this._hasQueuedChanges();return this._emitChangeEvent(),e}deselect(...t){this._verifyValueAssignment(t),t.forEach(i=>this._unmarkSelected(i));let e=this._hasQueuedChanges();return this._emitChangeEvent(),e}setSelection(...t){this._verifyValueAssignment(t);let e=this.selected,i=new Set(t);t.forEach(o=>this._markSelected(o)),e.filter(o=>!i.has(o)).forEach(o=>this._unmarkSelected(o));let r=this._hasQueuedChanges();return this._emitChangeEvent(),r}toggle(t){return this.isSelected(t)?this.deselect(t):this.select(t)}clear(t=!0){this._unmarkAll();let e=this._hasQueuedChanges();return t&&this._emitChangeEvent(),e}isSelected(t){return this._selection.has(this._getConcreteValue(t))}isEmpty(){return 0===this._selection.size}hasValue(){return!this.isEmpty()}sort(t){this._multiple&&this.selected&&this._selected.sort(t)}isMultipleSelection(){return this._multiple}_emitChangeEvent(){this._selected=null,(this._selectedToEmit.length||this._deselectedToEmit.length)&&(this.changed.next({source:this,added:this._selectedToEmit,removed:this._deselectedToEmit}),this._deselectedToEmit=[],this._selectedToEmit=[])}_markSelected(t){t=this._getConcreteValue(t),this.isSelected(t)||(this._multiple||this._unmarkAll(),this.isSelected(t)||this._selection.add(t),this._emitChanges&&this._selectedToEmit.push(t))}_unmarkSelected(t){t=this._getConcreteValue(t),this.isSelected(t)&&(this._selection.delete(t),this._emitChanges&&this._deselectedToEmit.push(t))}_unmarkAll(){this.isEmpty()||this._selection.forEach(t=>this._unmarkSelected(t))}_verifyValueAssignment(t){}_hasQueuedChanges(){return!(!this._deselectedToEmit.length&&!this._selectedToEmit.length)}_getConcreteValue(t){if(this.compareWith){for(let e of this._selection)if(this.compareWith(t,e))return e;return t}return t}},W1=new ie("_ViewRepeater"),N_e=["contentWrapper"],L_e=["*"],B7=new ie("VIRTUAL_SCROLL_STRATEGY");function B_e(n){return n._scrollStrategy}var V7=(()=>{class n{constructor(){this._itemSize=20,this._minBufferPx=100,this._maxBufferPx=200,this._scrollStrategy=new class{constructor(t,e,i){this._scrolledIndexChange=new Ie,this.scrolledIndexChange=this._scrolledIndexChange.pipe(Yn()),this._viewport=null,this._itemSize=t,this._minBufferPx=e,this._maxBufferPx=i}attach(t){this._viewport=t,this._updateTotalContentSize(),this._updateRenderedRange()}detach(){this._scrolledIndexChange.complete(),this._viewport=null}updateItemAndBufferSize(t,e,i){this._itemSize=t,this._minBufferPx=e,this._maxBufferPx=i,this._updateTotalContentSize(),this._updateRenderedRange()}onContentScrolled(){this._updateRenderedRange()}onDataLengthChanged(){this._updateTotalContentSize(),this._updateRenderedRange()}onContentRendered(){}onRenderedOffsetChanged(){}scrollToIndex(t,e){this._viewport&&this._viewport.scrollToOffset(t*this._itemSize,e)}_updateTotalContentSize(){!this._viewport||this._viewport.setTotalContentSize(this._viewport.getDataLength()*this._itemSize)}_updateRenderedRange(){if(!this._viewport)return;let t=this._viewport.getRenderedRange(),e={start:t.start,end:t.end},i=this._viewport.getViewportSize(),r=this._viewport.getDataLength(),o=this._viewport.measureScrollOffset(),s=this._itemSize>0?o/this._itemSize:0;if(e.end>r){let l=Math.ceil(i/this._itemSize),c=Math.max(0,Math.min(s,r-l));s!=c&&(s=c,o=c*this._itemSize,e.start=Math.floor(s)),e.end=Math.max(0,Math.min(r,e.start+l))}let a=o-e.start*this._itemSize;if(a<this._minBufferPx&&0!=e.start){let l=Math.ceil((this._maxBufferPx-a)/this._itemSize);e.start=Math.max(0,e.start-l),e.end=Math.min(r,Math.ceil(s+(i+this._minBufferPx)/this._itemSize))}else{let l=e.end*this._itemSize-(o+i);if(l<this._minBufferPx&&e.end!=r){let c=Math.ceil((this._maxBufferPx-l)/this._itemSize);c>0&&(e.end=Math.min(r,e.end+c),e.start=Math.max(0,Math.floor(s-this._minBufferPx/this._itemSize)))}}this._viewport.setRenderedRange(e),this._viewport.setRenderedContentOffset(this._itemSize*e.start),this._scrolledIndexChange.next(Math.floor(s))}}(this.itemSize,this.minBufferPx,this.maxBufferPx)}get itemSize(){return this._itemSize}set itemSize(e){this._itemSize=_i(e)}get minBufferPx(){return this._minBufferPx}set minBufferPx(e){this._minBufferPx=_i(e)}get maxBufferPx(){return this._maxBufferPx}set maxBufferPx(e){this._maxBufferPx=_i(e)}ngOnChanges(){this._scrollStrategy.updateItemAndBufferSize(this.itemSize,this.minBufferPx,this.maxBufferPx)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275dir=we({type:n,selectors:[["cdk-virtual-scroll-viewport","itemSize",""]],inputs:{itemSize:"itemSize",minBufferPx:"minBufferPx",maxBufferPx:"maxBufferPx"},standalone:!0,features:[Qt([{provide:B7,useFactory:B_e,deps:[$n(()=>n)]}]),Gt]}),n})(),Nu=(()=>{class n{constructor(e,i,r){this._ngZone=e,this._platform=i,this._scrolled=new Ie,this._globalSubscription=null,this._scrolledCount=0,this.scrollContainers=new Map,this._document=r}register(e){this.scrollContainers.has(e)||this.scrollContainers.set(e,e.elementScrolled().subscribe(()=>this._scrolled.next(e)))}deregister(e){let i=this.scrollContainers.get(e);i&&(i.unsubscribe(),this.scrollContainers.delete(e))}scrolled(e=20){return this._platform.isBrowser?new Kt(i=>{this._globalSubscription||this._addGlobalListener();let r=e>0?this._scrolled.pipe(sc(e)).subscribe(i):this._scrolled.subscribe(i);return this._scrolledCount++,()=>{r.unsubscribe(),this._scrolledCount--,this._scrolledCount||this._removeGlobalListener()}}):Ht()}ngOnDestroy(){this._removeGlobalListener(),this.scrollContainers.forEach((e,i)=>this.deregister(i)),this._scrolled.complete()}ancestorScrolled(e,i){let r=this.getAncestorScrollContainers(e);return this.scrolled(i).pipe(ke(o=>!o||r.indexOf(o)>-1))}getAncestorScrollContainers(e){let i=[];return this.scrollContainers.forEach((r,o)=>{this._scrollableContainsElement(o,e)&&i.push(o)}),i}_getWindow(){return this._document.defaultView||window}_scrollableContainsElement(e,i){let r=Hs(i),o=e.getElementRef().nativeElement;do{if(r==o)return!0}while(r=r.parentElement);return!1}_addGlobalListener(){this._globalSubscription=this._ngZone.runOutsideAngular(()=>mi(this._getWindow().document,"scroll").subscribe(()=>this._scrolled.next()))}_removeGlobalListener(){this._globalSubscription&&(this._globalSubscription.unsubscribe(),this._globalSubscription=null)}}return n.\u0275fac=function(e){return new(e||n)(k(at),k(Gn),k(Lt,8))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),Cd=(()=>{class n{constructor(e,i,r,o){this.elementRef=e,this.scrollDispatcher=i,this.ngZone=r,this.dir=o,this._destroyed=new Ie,this._elementScrolled=new Kt(s=>this.ngZone.runOutsideAngular(()=>mi(this.elementRef.nativeElement,"scroll").pipe(ot(this._destroyed)).subscribe(s)))}ngOnInit(){this.scrollDispatcher.register(this)}ngOnDestroy(){this.scrollDispatcher.deregister(this),this._destroyed.next(),this._destroyed.complete()}elementScrolled(){return this._elementScrolled}getElementRef(){return this.elementRef}scrollTo(e){let i=this.elementRef.nativeElement,r=this.dir&&"rtl"==this.dir.value;null==e.left&&(e.left=r?e.end:e.start),null==e.right&&(e.right=r?e.start:e.end),null!=e.bottom&&(e.top=i.scrollHeight-i.clientHeight-e.bottom),r&&0!=eg()?(null!=e.left&&(e.right=i.scrollWidth-i.clientWidth-e.left),2==eg()?e.left=e.right:1==eg()&&(e.left=e.right?-e.right:e.right)):null!=e.right&&(e.left=i.scrollWidth-i.clientWidth-e.right),this._applyScrollToOptions(e)}_applyScrollToOptions(e){let i=this.elementRef.nativeElement;R1()?i.scrollTo(e):(null!=e.top&&(i.scrollTop=e.top),null!=e.left&&(i.scrollLeft=e.left))}measureScrollOffset(e){let i="left",r="right",o=this.elementRef.nativeElement;if("top"==e)return o.scrollTop;if("bottom"==e)return o.scrollHeight-o.clientHeight-o.scrollTop;let s=this.dir&&"rtl"==this.dir.value;return"start"==e?e=s?r:i:"end"==e&&(e=s?i:r),s&&2==eg()?e==i?o.scrollWidth-o.clientWidth-o.scrollLeft:o.scrollLeft:s&&1==eg()?e==i?o.scrollLeft+o.scrollWidth-o.clientWidth:-o.scrollLeft:e==i?o.scrollLeft:o.scrollWidth-o.clientWidth-o.scrollLeft}}return n.\u0275fac=function(e){return new(e||n)(C(Me),C(Nu),C(at),C(Xi,8))},n.\u0275dir=we({type:n,selectors:[["","cdk-scrollable",""],["","cdkScrollable",""]],standalone:!0}),n})(),js=(()=>{class n{constructor(e,i,r){this._platform=e,this._change=new Ie,this._changeListener=o=>{this._change.next(o)},this._document=r,i.runOutsideAngular(()=>{if(e.isBrowser){let o=this._getWindow();o.addEventListener("resize",this._changeListener),o.addEventListener("orientationchange",this._changeListener)}this.change().subscribe(()=>this._viewportSize=null)})}ngOnDestroy(){if(this._platform.isBrowser){let e=this._getWindow();e.removeEventListener("resize",this._changeListener),e.removeEventListener("orientationchange",this._changeListener)}this._change.complete()}getViewportSize(){this._viewportSize||this._updateViewportSize();let e={width:this._viewportSize.width,height:this._viewportSize.height};return this._platform.isBrowser||(this._viewportSize=null),e}getViewportRect(){let e=this.getViewportScrollPosition(),{width:i,height:r}=this.getViewportSize();return{top:e.top,left:e.left,bottom:e.top+r,right:e.left+i,height:r,width:i}}getViewportScrollPosition(){if(!this._platform.isBrowser)return{top:0,left:0};let e=this._document,i=this._getWindow(),r=e.documentElement,o=r.getBoundingClientRect();return{top:-o.top||e.body.scrollTop||i.scrollY||r.scrollTop||0,left:-o.left||e.body.scrollLeft||i.scrollX||r.scrollLeft||0}}change(e=20){return e>0?this._change.pipe(sc(e)):this._change}_getWindow(){return this._document.defaultView||window}_updateViewportSize(){let e=this._getWindow();this._viewportSize=this._platform.isBrowser?{width:e.innerWidth,height:e.innerHeight}:{width:0,height:0}}}return n.\u0275fac=function(e){return new(e||n)(k(Gn),k(at),k(Lt,8))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),N7=new ie("VIRTUAL_SCROLLABLE"),z_e=(()=>{class n extends Cd{constructor(e,i,r,o){super(e,i,r,o)}measureViewportSize(e){let i=this.elementRef.nativeElement;return"horizontal"===e?i.clientWidth:i.clientHeight}}return n.\u0275fac=function(e){return new(e||n)(C(Me),C(Nu),C(at),C(Xi,8))},n.\u0275dir=we({type:n,features:[Ke]}),n})(),j_e=typeof requestAnimationFrame<"u"?YA:Am,ug=(()=>{class n extends z_e{get orientation(){return this._orientation}set orientation(e){this._orientation!==e&&(this._orientation=e,this._calculateSpacerSize())}get appendOnly(){return this._appendOnly}set appendOnly(e){this._appendOnly=Rt(e)}constructor(e,i,r,o,s,a,l,c){super(e,a,r,s),this.elementRef=e,this._changeDetectorRef=i,this._scrollStrategy=o,this.scrollable=c,this._platform=ai(Gn),this._detachedSubject=new Ie,this._renderedRangeSubject=new Ie,this._orientation="vertical",this._appendOnly=!1,this.scrolledIndexChange=new Kt(d=>this._scrollStrategy.scrolledIndexChange.subscribe(u=>Promise.resolve().then(()=>this.ngZone.run(()=>d.next(u))))),this.renderedRangeStream=this._renderedRangeSubject,this._totalContentSize=0,this._totalContentWidth="",this._totalContentHeight="",this._renderedRange={start:0,end:0},this._dataLength=0,this._viewportSize=0,this._renderedContentOffset=0,this._renderedContentOffsetNeedsRewrite=!1,this._isChangeDetectionPending=!1,this._runAfterChangeDetection=[],this._viewportChanges=Mn.EMPTY,this._viewportChanges=l.change().subscribe(()=>{this.checkViewportSize()}),this.scrollable||(this.elementRef.nativeElement.classList.add("cdk-virtual-scrollable"),this.scrollable=this)}ngOnInit(){!this._platform.isBrowser||(this.scrollable===this&&super.ngOnInit(),this.ngZone.runOutsideAngular(()=>Promise.resolve().then(()=>{this._measureViewportSize(),this._scrollStrategy.attach(this),this.scrollable.elementScrolled().pipe(qn(null),sc(0,j_e)).subscribe(()=>this._scrollStrategy.onContentScrolled()),this._markChangeDetectionNeeded()})))}ngOnDestroy(){this.detach(),this._scrollStrategy.detach(),this._renderedRangeSubject.complete(),this._detachedSubject.complete(),this._viewportChanges.unsubscribe(),super.ngOnDestroy()}attach(e){this.ngZone.runOutsideAngular(()=>{this._forOf=e,this._forOf.dataStream.pipe(ot(this._detachedSubject)).subscribe(i=>{let r=i.length;r!==this._dataLength&&(this._dataLength=r,this._scrollStrategy.onDataLengthChanged()),this._doChangeDetection()})})}detach(){this._forOf=null,this._detachedSubject.next()}getDataLength(){return this._dataLength}getViewportSize(){return this._viewportSize}getRenderedRange(){return this._renderedRange}measureBoundingClientRectWithScrollOffset(e){return this.getElementRef().nativeElement.getBoundingClientRect()[e]}setTotalContentSize(e){this._totalContentSize!==e&&(this._totalContentSize=e,this._calculateSpacerSize(),this._markChangeDetectionNeeded())}setRenderedRange(e){(function(n,t){return n.start==t.start&&n.end==t.end})(this._renderedRange,e)||(this.appendOnly&&(e={start:0,end:Math.max(this._renderedRange.end,e.end)}),this._renderedRangeSubject.next(this._renderedRange=e),this._markChangeDetectionNeeded(()=>this._scrollStrategy.onContentRendered()))}getOffsetToRenderedContentStart(){return this._renderedContentOffsetNeedsRewrite?null:this._renderedContentOffset}setRenderedContentOffset(e,i="to-start"){e=this.appendOnly&&"to-start"===i?0:e;let o="horizontal"==this.orientation,s=o?"X":"Y",l=`translate${s}(${Number((o&&this.dir&&"rtl"==this.dir.value?-1:1)*e)}px)`;this._renderedContentOffset=e,"to-end"===i&&(l+=` translate${s}(-100%)`,this._renderedContentOffsetNeedsRewrite=!0),this._renderedContentTransform!=l&&(this._renderedContentTransform=l,this._markChangeDetectionNeeded(()=>{this._renderedContentOffsetNeedsRewrite?(this._renderedContentOffset-=this.measureRenderedContentSize(),this._renderedContentOffsetNeedsRewrite=!1,this.setRenderedContentOffset(this._renderedContentOffset)):this._scrollStrategy.onRenderedOffsetChanged()}))}scrollToOffset(e,i="auto"){let r={behavior:i};"horizontal"===this.orientation?r.start=e:r.top=e,this.scrollable.scrollTo(r)}scrollToIndex(e,i="auto"){this._scrollStrategy.scrollToIndex(e,i)}measureScrollOffset(e){let i;return i=this.scrollable==this?r=>super.measureScrollOffset(r):r=>this.scrollable.measureScrollOffset(r),Math.max(0,i(e??("horizontal"===this.orientation?"start":"top"))-this.measureViewportOffset())}measureViewportOffset(e){let i,r="left",o="right",s="rtl"==this.dir?.value;i="start"==e?s?o:r:"end"==e?s?r:o:e||("horizontal"===this.orientation?"left":"top");let a=this.scrollable.measureBoundingClientRectWithScrollOffset(i);return this.elementRef.nativeElement.getBoundingClientRect()[i]-a}measureRenderedContentSize(){let e=this._contentWrapper.nativeElement;return"horizontal"===this.orientation?e.offsetWidth:e.offsetHeight}measureRangeSize(e){return this._forOf?this._forOf.measureRangeSize(e,this.orientation):0}checkViewportSize(){this._measureViewportSize(),this._scrollStrategy.onDataLengthChanged()}_measureViewportSize(){this._viewportSize=this.scrollable.measureViewportSize(this.orientation)}_markChangeDetectionNeeded(e){e&&this._runAfterChangeDetection.push(e),this._isChangeDetectionPending||(this._isChangeDetectionPending=!0,this.ngZone.runOutsideAngular(()=>Promise.resolve().then(()=>{this._doChangeDetection()})))}_doChangeDetection(){this._isChangeDetectionPending=!1,this._contentWrapper.nativeElement.style.transform=this._renderedContentTransform,this.ngZone.run(()=>this._changeDetectorRef.markForCheck());let e=this._runAfterChangeDetection;this._runAfterChangeDetection=[];for(let i of e)i()}_calculateSpacerSize(){this._totalContentHeight="horizontal"===this.orientation?"":`${this._totalContentSize}px`,this._totalContentWidth="horizontal"===this.orientation?`${this._totalContentSize}px`:""}}return n.\u0275fac=function(e){return new(e||n)(C(Me),C($t),C(at),C(B7,8),C(Xi,8),C(Nu),C(js),C(N7,8))},n.\u0275cmp=O({type:n,selectors:[["cdk-virtual-scroll-viewport"]],viewQuery:function(e,i){if(1&e&&Ge(N_e,7),2&e){let r;Se(r=Ee())&&(i._contentWrapper=r.first)}},hostAttrs:[1,"cdk-virtual-scroll-viewport"],hostVars:4,hostBindings:function(e,i){2&e&&nt("cdk-virtual-scroll-orientation-horizontal","horizontal"===i.orientation)("cdk-virtual-scroll-orientation-vertical","horizontal"!==i.orientation)},inputs:{orientation:"orientation",appendOnly:"appendOnly"},outputs:{scrolledIndexChange:"scrolledIndexChange"},standalone:!0,features:[Qt([{provide:Cd,useFactory:(t,e)=>t||e,deps:[[new Ts,new nh(N7)],n]}]),Ke,IO],ngContentSelectors:L_e,decls:4,vars:4,consts:[[1,"cdk-virtual-scroll-content-wrapper"],["contentWrapper",""],[1,"cdk-virtual-scroll-spacer"]],template:function(e,i){1&e&&(Dn(),h(0,"div",0,1),zt(2),g(),P(3,"div",2)),2&e&&(v(3),Tt("width",i._totalContentWidth)("height",i._totalContentHeight))},styles:["cdk-virtual-scroll-viewport{display:block;position:relative;transform:translateZ(0)}.cdk-virtual-scrollable{overflow:auto;will-change:scroll-position;contain:strict;-webkit-overflow-scrolling:touch}.cdk-virtual-scroll-content-wrapper{position:absolute;top:0;left:0;contain:content}[dir=rtl] .cdk-virtual-scroll-content-wrapper{right:0;left:auto}.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper{min-height:100%}.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>dl:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>ol:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>table:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>ul:not([cdkVirtualFor]){padding-left:0;padding-right:0;margin-left:0;margin-right:0;border-left-width:0;border-right-width:0;outline:none}.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper{min-width:100%}.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>dl:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>ol:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>table:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>ul:not([cdkVirtualFor]){padding-top:0;padding-bottom:0;margin-top:0;margin-bottom:0;border-top-width:0;border-bottom-width:0;outline:none}.cdk-virtual-scroll-spacer{height:1px;transform-origin:0 0;flex:0 0 auto}[dir=rtl] .cdk-virtual-scroll-spacer{transform-origin:100% 0}"],encapsulation:2,changeDetection:0}),n})();function L7(n,t,e){if(!e.getBoundingClientRect)return 0;let r=e.getBoundingClientRect();return"horizontal"===n?"start"===t?r.left:r.right:"start"===t?r.top:r.bottom}var H7=(()=>{class n{get cdkVirtualForOf(){return this._cdkVirtualForOf}set cdkVirtualForOf(e){this._cdkVirtualForOf=e,function(n){return n&&"function"==typeof n.connect&&!(n instanceof w_)}(e)?this._dataSourceChanges.next(e):this._dataSourceChanges.next(new G1(D_(e)?e:Array.from(e||[])))}get cdkVirtualForTrackBy(){return this._cdkVirtualForTrackBy}set cdkVirtualForTrackBy(e){this._needsUpdate=!0,this._cdkVirtualForTrackBy=e?(i,r)=>e(i+(this._renderedRange?this._renderedRange.start:0),r):void 0}set cdkVirtualForTemplate(e){e&&(this._needsUpdate=!0,this._template=e)}get cdkVirtualForTemplateCacheSize(){return this._viewRepeater.viewCacheSize}set cdkVirtualForTemplateCacheSize(e){this._viewRepeater.viewCacheSize=_i(e)}constructor(e,i,r,o,s,a){this._viewContainerRef=e,this._template=i,this._differs=r,this._viewRepeater=o,this._viewport=s,this.viewChange=new Ie,this._dataSourceChanges=new Ie,this.dataStream=this._dataSourceChanges.pipe(qn(null),Fm(),Jn(([l,c])=>this._changeDataSource(l,c)),Ms(1)),this._differ=null,this._needsUpdate=!1,this._destroyed=new Ie,this.dataStream.subscribe(l=>{this._data=l,this._onRenderedDataChange()}),this._viewport.renderedRangeStream.pipe(ot(this._destroyed)).subscribe(l=>{this._renderedRange=l,this.viewChange.observers.length&&a.run(()=>this.viewChange.next(this._renderedRange)),this._onRenderedDataChange()}),this._viewport.attach(this)}measureRangeSize(e,i){if(e.start>=e.end)return 0;let s,a,r=e.start-this._renderedRange.start,o=e.end-e.start;for(let l=0;l<o;l++){let c=this._viewContainerRef.get(l+r);if(c&&c.rootNodes.length){s=a=c.rootNodes[0];break}}for(let l=o-1;l>-1;l--){let c=this._viewContainerRef.get(l+r);if(c&&c.rootNodes.length){a=c.rootNodes[c.rootNodes.length-1];break}}return s&&a?L7(i,"end",a)-L7(i,"start",s):0}ngDoCheck(){if(this._differ&&this._needsUpdate){let e=this._differ.diff(this._renderedItems);e?this._applyChanges(e):this._updateContext(),this._needsUpdate=!1}}ngOnDestroy(){this._viewport.detach(),this._dataSourceChanges.next(void 0),this._dataSourceChanges.complete(),this.viewChange.complete(),this._destroyed.next(),this._destroyed.complete(),this._viewRepeater.detach()}_onRenderedDataChange(){!this._renderedRange||(this._renderedItems=this._data.slice(this._renderedRange.start,this._renderedRange.end),this._differ||(this._differ=this._differs.find(this._renderedItems).create((e,i)=>this.cdkVirtualForTrackBy?this.cdkVirtualForTrackBy(e,i):i)),this._needsUpdate=!0)}_changeDataSource(e,i){return e&&e.disconnect(this),this._needsUpdate=!0,i?i.connect(this):Ht()}_updateContext(){let e=this._data.length,i=this._viewContainerRef.length;for(;i--;){let r=this._viewContainerRef.get(i);r.context.index=this._renderedRange.start+i,r.context.count=e,this._updateComputedContextProperties(r.context),r.detectChanges()}}_applyChanges(e){this._viewRepeater.applyChanges(e,this._viewContainerRef,(o,s,a)=>this._getEmbeddedViewArgs(o,a),o=>o.item),e.forEachIdentityChange(o=>{this._viewContainerRef.get(o.currentIndex).context.$implicit=o.item});let i=this._data.length,r=this._viewContainerRef.length;for(;r--;){let o=this._viewContainerRef.get(r);o.context.index=this._renderedRange.start+r,o.context.count=i,this._updateComputedContextProperties(o.context)}}_updateComputedContextProperties(e){e.first=0===e.index,e.last=e.index===e.count-1,e.even=e.index%2==0,e.odd=!e.even}_getEmbeddedViewArgs(e,i){return{templateRef:this._template,context:{$implicit:e.item,cdkVirtualForOf:this._cdkVirtualForOf,index:-1,count:-1,first:!1,last:!1,odd:!1,even:!1},index:i}}}return n.\u0275fac=function(e){return new(e||n)(C(si),C(Si),C(wl),C(W1),C(ug,4),C(at))},n.\u0275dir=we({type:n,selectors:[["","cdkVirtualFor","","cdkVirtualForOf",""]],inputs:{cdkVirtualForOf:"cdkVirtualForOf",cdkVirtualForTrackBy:"cdkVirtualForTrackBy",cdkVirtualForTemplate:"cdkVirtualForTemplate",cdkVirtualForTemplateCacheSize:"cdkVirtualForTemplateCacheSize"},standalone:!0,features:[Qt([{provide:W1,useClass:qv}])]}),n})(),Pc=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({}),n})(),Md=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Ou,Pc,ug,Ou,Pc]}),n})(),z7=R1(),q1=class{enable(){}disable(){}attach(){}};function I2(n,t){return t.some(e=>n.bottom<e.top||n.top>e.bottom||n.right<e.left||n.left>e.right)}function U7(n,t){return t.some(e=>n.top<e.top||n.bottom>e.bottom||n.left<e.left||n.right>e.right)}var xf=class{constructor(t,e,i,r){this._scrollDispatcher=t,this._viewportRuler=e,this._ngZone=i,this._config=r,this._scrollSubscription=null}attach(t){this._overlayRef=t}enable(){this._scrollSubscription||(this._scrollSubscription=this._scrollDispatcher.scrolled(this._config?this._config.scrollThrottle:0).subscribe(()=>{if(this._overlayRef.updatePosition(),this._config&&this._config.autoClose){let e=this._overlayRef.overlayElement.getBoundingClientRect(),{width:i,height:r}=this._viewportRuler.getViewportSize();I2(e,[{width:i,height:r,bottom:r,right:i,top:0,left:0}])&&(this.disable(),this._ngZone.run(()=>this._overlayRef.detach()))}}))}disable(){this._scrollSubscription&&(this._scrollSubscription.unsubscribe(),this._scrollSubscription=null)}detach(){this.disable(),this._overlayRef=null}},G_e=(()=>{class n{constructor(e,i,r,o){this._scrollDispatcher=e,this._viewportRuler=i,this._ngZone=r,this.noop=()=>new q1,this.close=s=>new class{constructor(t,e,i,r){this._scrollDispatcher=t,this._ngZone=e,this._viewportRuler=i,this._config=r,this._scrollSubscription=null,this._detach=()=>{this.disable(),this._overlayRef.hasAttached()&&this._ngZone.run(()=>this._overlayRef.detach())}}attach(t){this._overlayRef=t}enable(){if(this._scrollSubscription)return;let t=this._scrollDispatcher.scrolled(0).pipe(ke(e=>!e||!this._overlayRef.overlayElement.contains(e.getElementRef().nativeElement)));this._config&&this._config.threshold&&this._config.threshold>1?(this._initialScrollPosition=this._viewportRuler.getViewportScrollPosition().top,this._scrollSubscription=t.subscribe(()=>{let e=this._viewportRuler.getViewportScrollPosition().top;Math.abs(e-this._initialScrollPosition)>this._config.threshold?this._detach():this._overlayRef.updatePosition()})):this._scrollSubscription=t.subscribe(this._detach)}disable(){this._scrollSubscription&&(this._scrollSubscription.unsubscribe(),this._scrollSubscription=null)}detach(){this.disable(),this._overlayRef=null}}(this._scrollDispatcher,this._ngZone,this._viewportRuler,s),this.block=()=>new class{constructor(t,e){this._viewportRuler=t,this._previousHTMLStyles={top:"",left:""},this._isEnabled=!1,this._document=e}attach(){}enable(){if(this._canBeEnabled()){let t=this._document.documentElement;this._previousScrollPosition=this._viewportRuler.getViewportScrollPosition(),this._previousHTMLStyles.left=t.style.left||"",this._previousHTMLStyles.top=t.style.top||"",t.style.left=Yr(-this._previousScrollPosition.left),t.style.top=Yr(-this._previousScrollPosition.top),t.classList.add("cdk-global-scrollblock"),this._isEnabled=!0}}disable(){if(this._isEnabled){let t=this._document.documentElement,i=t.style,r=this._document.body.style,o=i.scrollBehavior||"",s=r.scrollBehavior||"";this._isEnabled=!1,i.left=this._previousHTMLStyles.left,i.top=this._previousHTMLStyles.top,t.classList.remove("cdk-global-scrollblock"),z7&&(i.scrollBehavior=r.scrollBehavior="auto"),window.scroll(this._previousScrollPosition.left,this._previousScrollPosition.top),z7&&(i.scrollBehavior=o,r.scrollBehavior=s)}}_canBeEnabled(){if(this._document.documentElement.classList.contains("cdk-global-scrollblock")||this._isEnabled)return!1;let e=this._document.body,i=this._viewportRuler.getViewportSize();return e.scrollHeight>i.height||e.scrollWidth>i.width}}(this._viewportRuler,this._document),this.reposition=s=>new xf(this._scrollDispatcher,this._viewportRuler,this._ngZone,s),this._document=o}}return n.\u0275fac=function(e){return new(e||n)(k(Nu),k(js),k(at),k(Lt))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),Qa=class{constructor(t){if(this.scrollStrategy=new q1,this.panelClass="",this.hasBackdrop=!1,this.backdropClass="cdk-overlay-dark-backdrop",this.disposeOnNavigation=!1,t){let e=Object.keys(t);for(let i of e)void 0!==t[i]&&(this[i]=t[i])}}},Y7=(()=>{class n{constructor(e){this._attachedOverlays=[],this._document=e}ngOnDestroy(){this.detach()}add(e){this.remove(e),this._attachedOverlays.push(e)}remove(e){let i=this._attachedOverlays.indexOf(e);i>-1&&this._attachedOverlays.splice(i,1),0===this._attachedOverlays.length&&this.detach()}}return n.\u0275fac=function(e){return new(e||n)(k(Lt))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),W_e=(()=>{class n extends Y7{constructor(e,i){super(e),this._ngZone=i,this._keydownListener=r=>{let o=this._attachedOverlays;for(let s=o.length-1;s>-1;s--)if(o[s]._keydownEvents.observers.length>0){let a=o[s]._keydownEvents;this._ngZone?this._ngZone.run(()=>a.next(r)):a.next(r);break}}}add(e){super.add(e),this._isAttached||(this._ngZone?this._ngZone.runOutsideAngular(()=>this._document.body.addEventListener("keydown",this._keydownListener)):this._document.body.addEventListener("keydown",this._keydownListener),this._isAttached=!0)}detach(){this._isAttached&&(this._document.body.removeEventListener("keydown",this._keydownListener),this._isAttached=!1)}}return n.\u0275fac=function(e){return new(e||n)(k(Lt),k(at,8))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),q_e=(()=>{class n extends Y7{constructor(e,i,r){super(e),this._platform=i,this._ngZone=r,this._cursorStyleIsSet=!1,this._pointerDownListener=o=>{this._pointerDownEventTarget=ma(o)},this._clickListener=o=>{let s=ma(o),a="click"===o.type&&this._pointerDownEventTarget?this._pointerDownEventTarget:s;this._pointerDownEventTarget=null;let l=this._attachedOverlays.slice();for(let c=l.length-1;c>-1;c--){let d=l[c];if(d._outsidePointerEvents.observers.length<1||!d.hasAttached())continue;if(d.overlayElement.contains(s)||d.overlayElement.contains(a))break;let u=d._outsidePointerEvents;this._ngZone?this._ngZone.run(()=>u.next(o)):u.next(o)}}}add(e){if(super.add(e),!this._isAttached){let i=this._document.body;this._ngZone?this._ngZone.runOutsideAngular(()=>this._addEventListeners(i)):this._addEventListeners(i),this._platform.IOS&&!this._cursorStyleIsSet&&(this._cursorOriginalValue=i.style.cursor,i.style.cursor="pointer",this._cursorStyleIsSet=!0),this._isAttached=!0}}detach(){if(this._isAttached){let e=this._document.body;e.removeEventListener("pointerdown",this._pointerDownListener,!0),e.removeEventListener("click",this._clickListener,!0),e.removeEventListener("auxclick",this._clickListener,!0),e.removeEventListener("contextmenu",this._clickListener,!0),this._platform.IOS&&this._cursorStyleIsSet&&(e.style.cursor=this._cursorOriginalValue,this._cursorStyleIsSet=!1),this._isAttached=!1}}_addEventListeners(e){e.addEventListener("pointerdown",this._pointerDownListener,!0),e.addEventListener("click",this._clickListener,!0),e.addEventListener("auxclick",this._clickListener,!0),e.addEventListener("contextmenu",this._clickListener,!0)}}return n.\u0275fac=function(e){return new(e||n)(k(Lt),k(Gn),k(at,8))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),pg=(()=>{class n{constructor(e,i){this._platform=i,this._document=e}ngOnDestroy(){this._containerElement?.remove()}getContainerElement(){return this._containerElement||this._createContainer(),this._containerElement}_createContainer(){let e="cdk-overlay-container";if(this._platform.isBrowser||kv()){let r=this._document.querySelectorAll(`.${e}[platform="server"], .${e}[platform="test"]`);for(let o=0;o<r.length;o++)r[o].remove()}let i=this._document.createElement("div");i.classList.add(e),kv()?i.setAttribute("platform","test"):this._platform.isBrowser||i.setAttribute("platform","server"),this._document.body.appendChild(i),this._containerElement=i}}return n.\u0275fac=function(e){return new(e||n)(k(Lt),k(Gn))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),Oc=class{constructor(t,e,i,r,o,s,a,l,c,d=!1){this._portalOutlet=t,this._host=e,this._pane=i,this._config=r,this._ngZone=o,this._keyboardDispatcher=s,this._document=a,this._location=l,this._outsideClickDispatcher=c,this._animationsDisabled=d,this._backdropElement=null,this._backdropClick=new Ie,this._attachments=new Ie,this._detachments=new Ie,this._locationChanges=Mn.EMPTY,this._backdropClickHandler=u=>this._backdropClick.next(u),this._backdropTransitionendHandler=u=>{this._disposeBackdrop(u.target)},this._keydownEvents=new Ie,this._outsidePointerEvents=new Ie,r.scrollStrategy&&(this._scrollStrategy=r.scrollStrategy,this._scrollStrategy.attach(this)),this._positionStrategy=r.positionStrategy}get overlayElement(){return this._pane}get backdropElement(){return this._backdropElement}get hostElement(){return this._host}attach(t){!this._host.parentElement&&this._previousHostParent&&this._previousHostParent.appendChild(this._host);let e=this._portalOutlet.attach(t);return this._positionStrategy&&this._positionStrategy.attach(this),this._updateStackingOrder(),this._updateElementSize(),this._updateElementDirection(),this._scrollStrategy&&this._scrollStrategy.enable(),this._ngZone.onStable.pipe(Yt(1)).subscribe(()=>{this.hasAttached()&&this.updatePosition()}),this._togglePointerEvents(!0),this._config.hasBackdrop&&this._attachBackdrop(),this._config.panelClass&&this._toggleClasses(this._pane,this._config.panelClass,!0),this._attachments.next(),this._keyboardDispatcher.add(this),this._config.disposeOnNavigation&&(this._locationChanges=this._location.subscribe(()=>this.dispose())),this._outsideClickDispatcher.add(this),"function"==typeof e?.onDestroy&&e.onDestroy(()=>{this.hasAttached()&&this._ngZone.runOutsideAngular(()=>Promise.resolve().then(()=>this.detach()))}),e}detach(){if(!this.hasAttached())return;this.detachBackdrop(),this._togglePointerEvents(!1),this._positionStrategy&&this._positionStrategy.detach&&this._positionStrategy.detach(),this._scrollStrategy&&this._scrollStrategy.disable();let t=this._portalOutlet.detach();return this._detachments.next(),this._keyboardDispatcher.remove(this),this._detachContentWhenStable(),this._locationChanges.unsubscribe(),this._outsideClickDispatcher.remove(this),t}dispose(){let t=this.hasAttached();this._positionStrategy&&this._positionStrategy.dispose(),this._disposeScrollStrategy(),this._disposeBackdrop(this._backdropElement),this._locationChanges.unsubscribe(),this._keyboardDispatcher.remove(this),this._portalOutlet.dispose(),this._attachments.complete(),this._backdropClick.complete(),this._keydownEvents.complete(),this._outsidePointerEvents.complete(),this._outsideClickDispatcher.remove(this),this._host?.remove(),this._previousHostParent=this._pane=this._host=null,t&&this._detachments.next(),this._detachments.complete()}hasAttached(){return this._portalOutlet.hasAttached()}backdropClick(){return this._backdropClick}attachments(){return this._attachments}detachments(){return this._detachments}keydownEvents(){return this._keydownEvents}outsidePointerEvents(){return this._outsidePointerEvents}getConfig(){return this._config}updatePosition(){this._positionStrategy&&this._positionStrategy.apply()}updatePositionStrategy(t){t!==this._positionStrategy&&(this._positionStrategy&&this._positionStrategy.dispose(),this._positionStrategy=t,this.hasAttached()&&(t.attach(this),this.updatePosition()))}updateSize(t){this._config={...this._config,...t},this._updateElementSize()}setDirection(t){this._config={...this._config,direction:t},this._updateElementDirection()}addPanelClass(t){this._pane&&this._toggleClasses(this._pane,t,!0)}removePanelClass(t){this._pane&&this._toggleClasses(this._pane,t,!1)}getDirection(){let t=this._config.direction;return t?"string"==typeof t?t:t.value:"ltr"}updateScrollStrategy(t){t!==this._scrollStrategy&&(this._disposeScrollStrategy(),this._scrollStrategy=t,this.hasAttached()&&(t.attach(this),t.enable()))}_updateElementDirection(){this._host.setAttribute("dir",this.getDirection())}_updateElementSize(){if(!this._pane)return;let t=this._pane.style;t.width=Yr(this._config.width),t.height=Yr(this._config.height),t.minWidth=Yr(this._config.minWidth),t.minHeight=Yr(this._config.minHeight),t.maxWidth=Yr(this._config.maxWidth),t.maxHeight=Yr(this._config.maxHeight)}_togglePointerEvents(t){this._pane.style.pointerEvents=t?"":"none"}_attachBackdrop(){let t="cdk-overlay-backdrop-showing";this._backdropElement=this._document.createElement("div"),this._backdropElement.classList.add("cdk-overlay-backdrop"),this._animationsDisabled&&this._backdropElement.classList.add("cdk-overlay-backdrop-noop-animation"),this._config.backdropClass&&this._toggleClasses(this._backdropElement,this._config.backdropClass,!0),this._host.parentElement.insertBefore(this._backdropElement,this._host),this._backdropElement.addEventListener("click",this._backdropClickHandler),!this._animationsDisabled&&typeof requestAnimationFrame<"u"?this._ngZone.runOutsideAngular(()=>{requestAnimationFrame(()=>{this._backdropElement&&this._backdropElement.classList.add(t)})}):this._backdropElement.classList.add(t)}_updateStackingOrder(){this._host.nextSibling&&this._host.parentNode.appendChild(this._host)}detachBackdrop(){let t=this._backdropElement;if(t){if(this._animationsDisabled)return void this._disposeBackdrop(t);t.classList.remove("cdk-overlay-backdrop-showing"),this._ngZone.runOutsideAngular(()=>{t.addEventListener("transitionend",this._backdropTransitionendHandler)}),t.style.pointerEvents="none",this._backdropTimeout=this._ngZone.runOutsideAngular(()=>setTimeout(()=>{this._disposeBackdrop(t)},500))}}_toggleClasses(t,e,i){let r=tg(e||[]).filter(o=>!!o);r.length&&(i?t.classList.add(...r):t.classList.remove(...r))}_detachContentWhenStable(){this._ngZone.runOutsideAngular(()=>{let t=this._ngZone.onStable.pipe(ot(tn(this._attachments,this._detachments))).subscribe(()=>{(!this._pane||!this._host||0===this._pane.children.length)&&(this._pane&&this._config.panelClass&&this._toggleClasses(this._pane,this._config.panelClass,!1),this._host&&this._host.parentElement&&(this._previousHostParent=this._host.parentElement,this._host.remove()),t.unsubscribe())})})}_disposeScrollStrategy(){let t=this._scrollStrategy;t&&(t.disable(),t.detach&&t.detach())}_disposeBackdrop(t){t&&(t.removeEventListener("click",this._backdropClickHandler),t.removeEventListener("transitionend",this._backdropTransitionendHandler),t.remove(),this._backdropElement===t&&(this._backdropElement=null)),this._backdropTimeout&&(clearTimeout(this._backdropTimeout),this._backdropTimeout=void 0)}},j7="cdk-overlay-connected-position-bounding-box",Y_e=/([A-Za-z%]+)$/;function yf(n,t){for(let e in t)t.hasOwnProperty(e)&&(n[e]=t[e]);return n}function G7(n){if("number"!=typeof n&&null!=n){let[t,e]=n.split(Y_e);return e&&"px"!==e?null:parseFloat(t)}return n||null}function W7(n){return{top:Math.floor(n.top),right:Math.floor(n.right),bottom:Math.floor(n.bottom),left:Math.floor(n.left),width:Math.floor(n.width),height:Math.floor(n.height)}}var q7="cdk-global-overlay-wrapper",X_e=(()=>{class n{constructor(e,i,r,o){this._viewportRuler=e,this._document=i,this._platform=r,this._overlayContainer=o}global(){return new class{constructor(){this._cssPosition="static",this._topOffset="",this._bottomOffset="",this._alignItems="",this._xPosition="",this._xOffset="",this._width="",this._height="",this._isDisposed=!1}attach(t){let e=t.getConfig();this._overlayRef=t,this._width&&!e.width&&t.updateSize({width:this._width}),this._height&&!e.height&&t.updateSize({height:this._height}),t.hostElement.classList.add(q7),this._isDisposed=!1}top(t=""){return this._bottomOffset="",this._topOffset=t,this._alignItems="flex-start",this}left(t=""){return this._xOffset=t,this._xPosition="left",this}bottom(t=""){return this._topOffset="",this._bottomOffset=t,this._alignItems="flex-end",this}right(t=""){return this._xOffset=t,this._xPosition="right",this}start(t=""){return this._xOffset=t,this._xPosition="start",this}end(t=""){return this._xOffset=t,this._xPosition="end",this}width(t=""){return this._overlayRef?this._overlayRef.updateSize({width:t}):this._width=t,this}height(t=""){return this._overlayRef?this._overlayRef.updateSize({height:t}):this._height=t,this}centerHorizontally(t=""){return this.left(t),this._xPosition="center",this}centerVertically(t=""){return this.top(t),this._alignItems="center",this}apply(){if(!this._overlayRef||!this._overlayRef.hasAttached())return;let t=this._overlayRef.overlayElement.style,e=this._overlayRef.hostElement.style,i=this._overlayRef.getConfig(),{width:r,height:o,maxWidth:s,maxHeight:a}=i,l=!("100%"!==r&&"100vw"!==r||s&&"100%"!==s&&"100vw"!==s),c=!("100%"!==o&&"100vh"!==o||a&&"100%"!==a&&"100vh"!==a),d=this._xPosition,u=this._xOffset,p="rtl"===this._overlayRef.getConfig().direction,f="",m="",b="";l?b="flex-start":"center"===d?(b="center",p?m=u:f=u):p?"left"===d||"end"===d?(b="flex-end",f=u):("right"===d||"start"===d)&&(b="flex-start",m=u):"left"===d||"start"===d?(b="flex-start",f=u):("right"===d||"end"===d)&&(b="flex-end",m=u),t.position=this._cssPosition,t.marginLeft=l?"0":f,t.marginTop=c?"0":this._topOffset,t.marginBottom=this._bottomOffset,t.marginRight=l?"0":m,e.justifyContent=b,e.alignItems=c?"flex-start":this._alignItems}dispose(){if(this._isDisposed||!this._overlayRef)return;let t=this._overlayRef.overlayElement.style,e=this._overlayRef.hostElement,i=e.style;e.classList.remove(q7),i.justifyContent=i.alignItems=t.marginTop=t.marginBottom=t.marginLeft=t.marginRight=t.position="",this._overlayRef=null,this._isDisposed=!0}}}flexibleConnectedTo(e){return new class{get positions(){return this._preferredPositions}constructor(t,e,i,r,o){this._viewportRuler=e,this._document=i,this._platform=r,this._overlayContainer=o,this._lastBoundingBoxSize={width:0,height:0},this._isPushed=!1,this._canPush=!0,this._growAfterOpen=!1,this._hasFlexibleDimensions=!0,this._positionLocked=!1,this._viewportMargin=0,this._scrollables=[],this._preferredPositions=[],this._positionChanges=new Ie,this._resizeSubscription=Mn.EMPTY,this._offsetX=0,this._offsetY=0,this._appliedPanelClasses=[],this.positionChanges=this._positionChanges,this.setOrigin(t)}attach(t){this._validatePositions(),t.hostElement.classList.add(j7),this._overlayRef=t,this._boundingBox=t.hostElement,this._pane=t.overlayElement,this._isDisposed=!1,this._isInitialRender=!0,this._lastPosition=null,this._resizeSubscription.unsubscribe(),this._resizeSubscription=this._viewportRuler.change().subscribe(()=>{this._isInitialRender=!0,this.apply()})}apply(){if(this._isDisposed||!this._platform.isBrowser)return;if(!this._isInitialRender&&this._positionLocked&&this._lastPosition)return void this.reapplyLastPosition();this._clearPanelClasses(),this._resetOverlayElementStyles(),this._resetBoundingBoxStyles(),this._viewportRect=this._getNarrowedViewportRect(),this._originRect=this._getOriginRect(),this._overlayRect=this._pane.getBoundingClientRect(),this._containerRect=this._overlayContainer.getContainerElement().getBoundingClientRect();let s,t=this._originRect,e=this._overlayRect,i=this._viewportRect,r=this._containerRect,o=[];for(let a of this._preferredPositions){let l=this._getOriginPoint(t,r,a),c=this._getOverlayPoint(l,e,a),d=this._getOverlayFit(c,e,i,a);if(d.isCompletelyWithinViewport)return this._isPushed=!1,void this._applyPosition(a,l);this._canFitWithFlexibleDimensions(d,c,i)?o.push({position:a,origin:l,overlayRect:e,boundingBoxRect:this._calculateBoundingBoxRect(l,a)}):(!s||s.overlayFit.visibleArea<d.visibleArea)&&(s={overlayFit:d,overlayPoint:c,originPoint:l,position:a,overlayRect:e})}if(o.length){let a=null,l=-1;for(let c of o){let d=c.boundingBoxRect.width*c.boundingBoxRect.height*(c.position.weight||1);d>l&&(l=d,a=c)}return this._isPushed=!1,void this._applyPosition(a.position,a.origin)}if(this._canPush)return this._isPushed=!0,void this._applyPosition(s.position,s.originPoint);this._applyPosition(s.position,s.originPoint)}detach(){this._clearPanelClasses(),this._lastPosition=null,this._previousPushAmount=null,this._resizeSubscription.unsubscribe()}dispose(){this._isDisposed||(this._boundingBox&&yf(this._boundingBox.style,{top:"",left:"",right:"",bottom:"",height:"",width:"",alignItems:"",justifyContent:""}),this._pane&&this._resetOverlayElementStyles(),this._overlayRef&&this._overlayRef.hostElement.classList.remove(j7),this.detach(),this._positionChanges.complete(),this._overlayRef=this._boundingBox=null,this._isDisposed=!0)}reapplyLastPosition(){if(this._isDisposed||!this._platform.isBrowser)return;let t=this._lastPosition;if(t){this._originRect=this._getOriginRect(),this._overlayRect=this._pane.getBoundingClientRect(),this._viewportRect=this._getNarrowedViewportRect(),this._containerRect=this._overlayContainer.getContainerElement().getBoundingClientRect();let e=this._getOriginPoint(this._originRect,this._containerRect,t);this._applyPosition(t,e)}else this.apply()}withScrollableContainers(t){return this._scrollables=t,this}withPositions(t){return this._preferredPositions=t,-1===t.indexOf(this._lastPosition)&&(this._lastPosition=null),this._validatePositions(),this}withViewportMargin(t){return this._viewportMargin=t,this}withFlexibleDimensions(t=!0){return this._hasFlexibleDimensions=t,this}withGrowAfterOpen(t=!0){return this._growAfterOpen=t,this}withPush(t=!0){return this._canPush=t,this}withLockedPosition(t=!0){return this._positionLocked=t,this}setOrigin(t){return this._origin=t,this}withDefaultOffsetX(t){return this._offsetX=t,this}withDefaultOffsetY(t){return this._offsetY=t,this}withTransformOriginOn(t){return this._transformOriginSelector=t,this}_getOriginPoint(t,e,i){let r,o;if("center"==i.originX)r=t.left+t.width/2;else{let s=this._isRtl()?t.right:t.left,a=this._isRtl()?t.left:t.right;r="start"==i.originX?s:a}return e.left<0&&(r-=e.left),o="center"==i.originY?t.top+t.height/2:"top"==i.originY?t.top:t.bottom,e.top<0&&(o-=e.top),{x:r,y:o}}_getOverlayPoint(t,e,i){let r,o;return r="center"==i.overlayX?-e.width/2:"start"===i.overlayX?this._isRtl()?-e.width:0:this._isRtl()?0:-e.width,o="center"==i.overlayY?-e.height/2:"top"==i.overlayY?0:-e.height,{x:t.x+r,y:t.y+o}}_getOverlayFit(t,e,i,r){let o=W7(e),{x:s,y:a}=t,l=this._getOffset(r,"x"),c=this._getOffset(r,"y");l&&(s+=l),c&&(a+=c);let p=0-a,f=a+o.height-i.height,m=this._subtractOverflows(o.width,0-s,s+o.width-i.width),b=this._subtractOverflows(o.height,p,f),M=m*b;return{visibleArea:M,isCompletelyWithinViewport:o.width*o.height===M,fitsInViewportVertically:b===o.height,fitsInViewportHorizontally:m==o.width}}_canFitWithFlexibleDimensions(t,e,i){if(this._hasFlexibleDimensions){let r=i.bottom-e.y,o=i.right-e.x,s=G7(this._overlayRef.getConfig().minHeight),a=G7(this._overlayRef.getConfig().minWidth);return(t.fitsInViewportVertically||null!=s&&s<=r)&&(t.fitsInViewportHorizontally||null!=a&&a<=o)}return!1}_pushOverlayOnScreen(t,e,i){if(this._previousPushAmount&&this._positionLocked)return{x:t.x+this._previousPushAmount.x,y:t.y+this._previousPushAmount.y};let r=W7(e),o=this._viewportRect,s=Math.max(t.x+r.width-o.width,0),a=Math.max(t.y+r.height-o.height,0),l=Math.max(o.top-i.top-t.y,0),c=Math.max(o.left-i.left-t.x,0),d=0,u=0;return d=r.width<=o.width?c||-s:t.x<this._viewportMargin?o.left-i.left-t.x:0,u=r.height<=o.height?l||-a:t.y<this._viewportMargin?o.top-i.top-t.y:0,this._previousPushAmount={x:d,y:u},{x:t.x+d,y:t.y+u}}_applyPosition(t,e){if(this._setTransformOrigin(t),this._setOverlayElementStyles(e,t),this._setBoundingBoxStyles(e,t),t.panelClass&&this._addPanelClasses(t.panelClass),this._lastPosition=t,this._positionChanges.observers.length){let i=this._getScrollVisibility(),r=new class{constructor(t,e){this.connectionPair=t,this.scrollableViewProperties=e}}(t,i);this._positionChanges.next(r)}this._isInitialRender=!1}_setTransformOrigin(t){if(!this._transformOriginSelector)return;let i,e=this._boundingBox.querySelectorAll(this._transformOriginSelector),r=t.overlayY;i="center"===t.overlayX?"center":this._isRtl()?"start"===t.overlayX?"right":"left":"start"===t.overlayX?"left":"right";for(let o=0;o<e.length;o++)e[o].style.transformOrigin=`${i} ${r}`}_calculateBoundingBoxRect(t,e){let o,s,a,d,u,p,i=this._viewportRect,r=this._isRtl();if("top"===e.overlayY)s=t.y,o=i.height-s+this._viewportMargin;else if("bottom"===e.overlayY)a=i.height-t.y+2*this._viewportMargin,o=i.height-a+this._viewportMargin;else{let f=Math.min(i.bottom-t.y+i.top,t.y),m=this._lastBoundingBoxSize.height;o=2*f,s=t.y-f,o>m&&!this._isInitialRender&&!this._growAfterOpen&&(s=t.y-m/2)}if("end"===e.overlayX&&!r||"start"===e.overlayX&&r)p=i.width-t.x+this._viewportMargin,d=t.x-this._viewportMargin;else if("start"===e.overlayX&&!r||"end"===e.overlayX&&r)u=t.x,d=i.right-t.x;else{let f=Math.min(i.right-t.x+i.left,t.x),m=this._lastBoundingBoxSize.width;d=2*f,u=t.x-f,d>m&&!this._isInitialRender&&!this._growAfterOpen&&(u=t.x-m/2)}return{top:s,left:u,bottom:a,right:p,width:d,height:o}}_setBoundingBoxStyles(t,e){let i=this._calculateBoundingBoxRect(t,e);!this._isInitialRender&&!this._growAfterOpen&&(i.height=Math.min(i.height,this._lastBoundingBoxSize.height),i.width=Math.min(i.width,this._lastBoundingBoxSize.width));let r={};if(this._hasExactPosition())r.top=r.left="0",r.bottom=r.right=r.maxHeight=r.maxWidth="",r.width=r.height="100%";else{let o=this._overlayRef.getConfig().maxHeight,s=this._overlayRef.getConfig().maxWidth;r.height=Yr(i.height),r.top=Yr(i.top),r.bottom=Yr(i.bottom),r.width=Yr(i.width),r.left=Yr(i.left),r.right=Yr(i.right),r.alignItems="center"===e.overlayX?"center":"end"===e.overlayX?"flex-end":"flex-start",r.justifyContent="center"===e.overlayY?"center":"bottom"===e.overlayY?"flex-end":"flex-start",o&&(r.maxHeight=Yr(o)),s&&(r.maxWidth=Yr(s))}this._lastBoundingBoxSize=i,yf(this._boundingBox.style,r)}_resetBoundingBoxStyles(){yf(this._boundingBox.style,{top:"0",left:"0",right:"0",bottom:"0",height:"",width:"",alignItems:"",justifyContent:""})}_resetOverlayElementStyles(){yf(this._pane.style,{top:"",left:"",bottom:"",right:"",position:"",transform:""})}_setOverlayElementStyles(t,e){let i={},r=this._hasExactPosition(),o=this._hasFlexibleDimensions,s=this._overlayRef.getConfig();if(r){let d=this._viewportRuler.getViewportScrollPosition();yf(i,this._getExactOverlayY(e,t,d)),yf(i,this._getExactOverlayX(e,t,d))}else i.position="static";let a="",l=this._getOffset(e,"x"),c=this._getOffset(e,"y");l&&(a+=`translateX(${l}px) `),c&&(a+=`translateY(${c}px)`),i.transform=a.trim(),s.maxHeight&&(r?i.maxHeight=Yr(s.maxHeight):o&&(i.maxHeight="")),s.maxWidth&&(r?i.maxWidth=Yr(s.maxWidth):o&&(i.maxWidth="")),yf(this._pane.style,i)}_getExactOverlayY(t,e,i){let r={top:"",bottom:""},o=this._getOverlayPoint(e,this._overlayRect,t);return this._isPushed&&(o=this._pushOverlayOnScreen(o,this._overlayRect,i)),"bottom"===t.overlayY?r.bottom=this._document.documentElement.clientHeight-(o.y+this._overlayRect.height)+"px":r.top=Yr(o.y),r}_getExactOverlayX(t,e,i){let s,r={left:"",right:""},o=this._getOverlayPoint(e,this._overlayRect,t);return this._isPushed&&(o=this._pushOverlayOnScreen(o,this._overlayRect,i)),s=this._isRtl()?"end"===t.overlayX?"left":"right":"end"===t.overlayX?"right":"left","right"===s?r.right=this._document.documentElement.clientWidth-(o.x+this._overlayRect.width)+"px":r.left=Yr(o.x),r}_getScrollVisibility(){let t=this._getOriginRect(),e=this._pane.getBoundingClientRect(),i=this._scrollables.map(r=>r.getElementRef().nativeElement.getBoundingClientRect());return{isOriginClipped:U7(t,i),isOriginOutsideView:I2(t,i),isOverlayClipped:U7(e,i),isOverlayOutsideView:I2(e,i)}}_subtractOverflows(t,...e){return e.reduce((i,r)=>i-Math.max(r,0),t)}_getNarrowedViewportRect(){let t=this._document.documentElement.clientWidth,e=this._document.documentElement.clientHeight,i=this._viewportRuler.getViewportScrollPosition();return{top:i.top+this._viewportMargin,left:i.left+this._viewportMargin,right:i.left+t-this._viewportMargin,bottom:i.top+e-this._viewportMargin,width:t-2*this._viewportMargin,height:e-2*this._viewportMargin}}_isRtl(){return"rtl"===this._overlayRef.getDirection()}_hasExactPosition(){return!this._hasFlexibleDimensions||this._isPushed}_getOffset(t,e){return"x"===e?null==t.offsetX?this._offsetX:t.offsetX:null==t.offsetY?this._offsetY:t.offsetY}_validatePositions(){}_addPanelClasses(t){this._pane&&tg(t).forEach(e=>{""!==e&&-1===this._appliedPanelClasses.indexOf(e)&&(this._appliedPanelClasses.push(e),this._pane.classList.add(e))})}_clearPanelClasses(){this._pane&&(this._appliedPanelClasses.forEach(t=>{this._pane.classList.remove(t)}),this._appliedPanelClasses=[])}_getOriginRect(){let t=this._origin;if(t instanceof Me)return t.nativeElement.getBoundingClientRect();if(t instanceof Element)return t.getBoundingClientRect();let e=t.width||0,i=t.height||0;return{top:t.y,bottom:t.y+i,left:t.x,right:t.x+e,height:i,width:e}}}(e,this._viewportRuler,this._document,this._platform,this._overlayContainer)}}return n.\u0275fac=function(e){return new(e||n)(k(js),k(Lt),k(Gn),k(pg))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),Q_e=0,zi=(()=>{class n{constructor(e,i,r,o,s,a,l,c,d,u,p,f){this.scrollStrategies=e,this._overlayContainer=i,this._componentFactoryResolver=r,this._positionBuilder=o,this._keyboardDispatcher=s,this._injector=a,this._ngZone=l,this._document=c,this._directionality=d,this._location=u,this._outsideClickDispatcher=p,this._animationsModuleType=f}create(e){let i=this._createHostElement(),r=this._createPaneElement(i),o=this._createPortalOutlet(r),s=new Qa(e);return s.direction=s.direction||this._directionality.value,new Oc(o,i,r,s,this._ngZone,this._keyboardDispatcher,this._document,this._location,this._outsideClickDispatcher,"NoopAnimations"===this._animationsModuleType)}position(){return this._positionBuilder}_createPaneElement(e){let i=this._document.createElement("div");return i.id="cdk-overlay-"+Q_e++,i.classList.add("cdk-overlay-pane"),e.appendChild(i),i}_createHostElement(){let e=this._document.createElement("div");return this._overlayContainer.getContainerElement().appendChild(e),e}_createPortalOutlet(e){return this._appRef||(this._appRef=this._injector.get(yc)),new Gv(e,this._componentFactoryResolver,this._appRef,this._injector,this._document)}}return n.\u0275fac=function(e){return new(e||n)(k(G_e),k(pg),k(fo),k(X_e),k(W_e),k(Mi),k(at),k(Lt),k(Xi),k(wb),k(q_e),k(hi,8))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),Z_e=[{originX:"start",originY:"bottom",overlayX:"start",overlayY:"top"},{originX:"start",originY:"top",overlayX:"start",overlayY:"bottom"},{originX:"end",originY:"top",overlayX:"end",overlayY:"bottom"},{originX:"end",originY:"bottom",overlayX:"end",overlayY:"top"}],X7=new ie("cdk-connected-overlay-scroll-strategy"),wd=(()=>{class n{constructor(e){this.elementRef=e}}return n.\u0275fac=function(e){return new(e||n)(C(Me))},n.\u0275dir=we({type:n,selectors:[["","cdk-overlay-origin",""],["","overlay-origin",""],["","cdkOverlayOrigin",""]],exportAs:["cdkOverlayOrigin"],standalone:!0}),n})(),Bu=(()=>{class n{get offsetX(){return this._offsetX}set offsetX(e){this._offsetX=e,this._position&&this._updatePositionStrategy(this._position)}get offsetY(){return this._offsetY}set offsetY(e){this._offsetY=e,this._position&&this._updatePositionStrategy(this._position)}get hasBackdrop(){return this._hasBackdrop}set hasBackdrop(e){this._hasBackdrop=Rt(e)}get lockPosition(){return this._lockPosition}set lockPosition(e){this._lockPosition=Rt(e)}get flexibleDimensions(){return this._flexibleDimensions}set flexibleDimensions(e){this._flexibleDimensions=Rt(e)}get growAfterOpen(){return this._growAfterOpen}set growAfterOpen(e){this._growAfterOpen=Rt(e)}get push(){return this._push}set push(e){this._push=Rt(e)}constructor(e,i,r,o,s){this._overlay=e,this._dir=s,this._hasBackdrop=!1,this._lockPosition=!1,this._growAfterOpen=!1,this._flexibleDimensions=!1,this._push=!1,this._backdropSubscription=Mn.EMPTY,this._attachSubscription=Mn.EMPTY,this._detachSubscription=Mn.EMPTY,this._positionSubscription=Mn.EMPTY,this.viewportMargin=0,this.open=!1,this.disableClose=!1,this.backdropClick=new F,this.positionChange=new F,this.attach=new F,this.detach=new F,this.overlayKeydown=new F,this.overlayOutsideClick=new F,this._templatePortal=new Yo(i,r),this._scrollStrategyFactory=o,this.scrollStrategy=this._scrollStrategyFactory()}get overlayRef(){return this._overlayRef}get dir(){return this._dir?this._dir.value:"ltr"}ngOnDestroy(){this._attachSubscription.unsubscribe(),this._detachSubscription.unsubscribe(),this._backdropSubscription.unsubscribe(),this._positionSubscription.unsubscribe(),this._overlayRef&&this._overlayRef.dispose()}ngOnChanges(e){this._position&&(this._updatePositionStrategy(this._position),this._overlayRef.updateSize({width:this.width,minWidth:this.minWidth,height:this.height,minHeight:this.minHeight}),e.origin&&this.open&&this._position.apply()),e.open&&(this.open?this._attachOverlay():this._detachOverlay())}_createOverlay(){(!this.positions||!this.positions.length)&&(this.positions=Z_e);let e=this._overlayRef=this._overlay.create(this._buildConfig());this._attachSubscription=e.attachments().subscribe(()=>this.attach.emit()),this._detachSubscription=e.detachments().subscribe(()=>this.detach.emit()),e.keydownEvents().subscribe(i=>{this.overlayKeydown.next(i),27===i.keyCode&&!this.disableClose&&!vr(i)&&(i.preventDefault(),this._detachOverlay())}),this._overlayRef.outsidePointerEvents().subscribe(i=>{this.overlayOutsideClick.next(i)})}_buildConfig(){let e=this._position=this.positionStrategy||this._createPositionStrategy(),i=new Qa({direction:this._dir,positionStrategy:e,scrollStrategy:this.scrollStrategy,hasBackdrop:this.hasBackdrop});return(this.width||0===this.width)&&(i.width=this.width),(this.height||0===this.height)&&(i.height=this.height),(this.minWidth||0===this.minWidth)&&(i.minWidth=this.minWidth),(this.minHeight||0===this.minHeight)&&(i.minHeight=this.minHeight),this.backdropClass&&(i.backdropClass=this.backdropClass),this.panelClass&&(i.panelClass=this.panelClass),i}_updatePositionStrategy(e){let i=this.positions.map(r=>({originX:r.originX,originY:r.originY,overlayX:r.overlayX,overlayY:r.overlayY,offsetX:r.offsetX||this.offsetX,offsetY:r.offsetY||this.offsetY,panelClass:r.panelClass||void 0}));return e.setOrigin(this._getFlexibleConnectedPositionStrategyOrigin()).withPositions(i).withFlexibleDimensions(this.flexibleDimensions).withPush(this.push).withGrowAfterOpen(this.growAfterOpen).withViewportMargin(this.viewportMargin).withLockedPosition(this.lockPosition).withTransformOriginOn(this.transformOriginSelector)}_createPositionStrategy(){let e=this._overlay.position().flexibleConnectedTo(this._getFlexibleConnectedPositionStrategyOrigin());return this._updatePositionStrategy(e),e}_getFlexibleConnectedPositionStrategyOrigin(){return this.origin instanceof wd?this.origin.elementRef:this.origin}_attachOverlay(){this._overlayRef?this._overlayRef.getConfig().hasBackdrop=this.hasBackdrop:this._createOverlay(),this._overlayRef.hasAttached()||this._overlayRef.attach(this._templatePortal),this.hasBackdrop?this._backdropSubscription=this._overlayRef.backdropClick().subscribe(e=>{this.backdropClick.emit(e)}):this._backdropSubscription.unsubscribe(),this._positionSubscription.unsubscribe(),this.positionChange.observers.length>0&&(this._positionSubscription=this._position.positionChanges.pipe(A_(()=>this.positionChange.observers.length>0)).subscribe(e=>{this.positionChange.emit(e),0===this.positionChange.observers.length&&this._positionSubscription.unsubscribe()}))}_detachOverlay(){this._overlayRef&&this._overlayRef.detach(),this._backdropSubscription.unsubscribe(),this._positionSubscription.unsubscribe()}}return n.\u0275fac=function(e){return new(e||n)(C(zi),C(Si),C(si),C(X7),C(Xi,8))},n.\u0275dir=we({type:n,selectors:[["","cdk-connected-overlay",""],["","connected-overlay",""],["","cdkConnectedOverlay",""]],inputs:{origin:["cdkConnectedOverlayOrigin","origin"],positions:["cdkConnectedOverlayPositions","positions"],positionStrategy:["cdkConnectedOverlayPositionStrategy","positionStrategy"],offsetX:["cdkConnectedOverlayOffsetX","offsetX"],offsetY:["cdkConnectedOverlayOffsetY","offsetY"],width:["cdkConnectedOverlayWidth","width"],height:["cdkConnectedOverlayHeight","height"],minWidth:["cdkConnectedOverlayMinWidth","minWidth"],minHeight:["cdkConnectedOverlayMinHeight","minHeight"],backdropClass:["cdkConnectedOverlayBackdropClass","backdropClass"],panelClass:["cdkConnectedOverlayPanelClass","panelClass"],viewportMargin:["cdkConnectedOverlayViewportMargin","viewportMargin"],scrollStrategy:["cdkConnectedOverlayScrollStrategy","scrollStrategy"],open:["cdkConnectedOverlayOpen","open"],disableClose:["cdkConnectedOverlayDisableClose","disableClose"],transformOriginSelector:["cdkConnectedOverlayTransformOriginOn","transformOriginSelector"],hasBackdrop:["cdkConnectedOverlayHasBackdrop","hasBackdrop"],lockPosition:["cdkConnectedOverlayLockPosition","lockPosition"],flexibleDimensions:["cdkConnectedOverlayFlexibleDimensions","flexibleDimensions"],growAfterOpen:["cdkConnectedOverlayGrowAfterOpen","growAfterOpen"],push:["cdkConnectedOverlayPush","push"]},outputs:{backdropClick:"backdropClick",positionChange:"positionChange",attach:"attach",detach:"detach",overlayKeydown:"overlayKeydown",overlayOutsideClick:"overlayOutsideClick"},exportAs:["cdkConnectedOverlay"],standalone:!0,features:[Gt]}),n})(),J_e={provide:X7,deps:[zi],useFactory:function(n){return()=>n.scrollStrategies.reposition()}},Co=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({providers:[zi,J_e],imports:[Ou,Hl,Md,Md]}),n})();function $_e(n,t){if(1&n){let e=ge();h(0,"div",2)(1,"button",3),I("click",function(){return X(e),Q(w().action())}),T(2),g()()}if(2&n){let e=w();v(2),He(" ",e.data.action," ")}}var ebe=["label"];function tbe(n,t){}var nbe=Math.pow(2,31)-1,Cf=class{constructor(t,e){this._overlayRef=e,this._afterDismissed=new Ie,this._afterOpened=new Ie,this._onAction=new Ie,this._dismissedByAction=!1,this.containerInstance=t,t._onExit.subscribe(()=>this._finishDismiss())}dismiss(){this._afterDismissed.closed||this.containerInstance.exit(),clearTimeout(this._durationTimeoutId)}dismissWithAction(){this._onAction.closed||(this._dismissedByAction=!0,this._onAction.next(),this._onAction.complete(),this.dismiss()),clearTimeout(this._durationTimeoutId)}closeWithAction(){this.dismissWithAction()}_dismissAfter(t){this._durationTimeoutId=setTimeout(()=>this.dismiss(),Math.min(t,nbe))}_open(){this._afterOpened.closed||(this._afterOpened.next(),this._afterOpened.complete())}_finishDismiss(){this._overlayRef.dispose(),this._onAction.closed||this._onAction.complete(),this._afterDismissed.next({dismissedByAction:this._dismissedByAction}),this._afterDismissed.complete(),this._dismissedByAction=!1}afterDismissed(){return this._afterDismissed}afterOpened(){return this.containerInstance._onEnter}onAction(){return this._onAction}},Y1=new ie("MatSnackBarData"),fg=class{constructor(){this.politeness="assertive",this.announcementMessage="",this.duration=0,this.data=null,this.horizontalPosition="center",this.verticalPosition="bottom"}},ibe=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275dir=we({type:n,selectors:[["","matSnackBarLabel",""]],hostAttrs:[1,"mat-mdc-snack-bar-label","mdc-snackbar__label"]}),n})(),rbe=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275dir=we({type:n,selectors:[["","matSnackBarActions",""]],hostAttrs:[1,"mat-mdc-snack-bar-actions","mdc-snackbar__actions"]}),n})(),obe=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275dir=we({type:n,selectors:[["","matSnackBarAction",""]],hostAttrs:[1,"mat-mdc-snack-bar-action","mdc-snackbar__action"]}),n})(),sbe=(()=>{class n{constructor(e,i){this.snackBarRef=e,this.data=i}action(){this.snackBarRef.dismissWithAction()}get hasAction(){return!!this.data.action}}return n.\u0275fac=function(e){return new(e||n)(C(Cf),C(Y1))},n.\u0275cmp=O({type:n,selectors:[["simple-snack-bar"]],hostAttrs:[1,"mat-mdc-simple-snack-bar"],exportAs:["matSnackBar"],decls:3,vars:2,consts:[["matSnackBarLabel",""],["matSnackBarActions","",4,"ngIf"],["matSnackBarActions",""],["mat-button","","matSnackBarAction","",3,"click"]],template:function(e,i){1&e&&(h(0,"div",0),T(1),g(),S(2,$_e,3,1,"div",1)),2&e&&(v(1),He(" ",i.data.message,"\n"),v(1),_("ngIf",i.hasAction))},dependencies:[Fe,Ji,ibe,rbe,obe],styles:[".mat-mdc-simple-snack-bar{display:flex}"],encapsulation:2,changeDetection:0}),n})(),abe={snackBarState:_r("state",[wi("void, hidden",rn({transform:"scale(0.8)",opacity:0})),wi("visible",rn({transform:"scale(1)",opacity:1})),gi("* => visible",Ci("150ms cubic-bezier(0, 0, 0.2, 1)")),gi("* => void, * => hidden",Ci("75ms cubic-bezier(0.4, 0.0, 1, 1)",rn({opacity:0})))])},lbe=0,cbe=(()=>{class n extends Fu{constructor(e,i,r,o,s){super(),this._ngZone=e,this._elementRef=i,this._changeDetectorRef=r,this._platform=o,this.snackBarConfig=s,this._document=ai(Lt),this._trackedModals=new Set,this._announceDelay=150,this._destroyed=!1,this._onAnnounce=new Ie,this._onExit=new Ie,this._onEnter=new Ie,this._animationState="void",this._liveElementId="mat-snack-bar-container-live-"+lbe++,this.attachDomPortal=a=>{this._assertNotAttached();let l=this._portalOutlet.attachDomPortal(a);return this._afterPortalAttached(),l},this._live="assertive"!==s.politeness||s.announcementMessage?"off"===s.politeness?"off":"polite":"assertive",this._platform.FIREFOX&&("polite"===this._live&&(this._role="status"),"assertive"===this._live&&(this._role="alert"))}attachComponentPortal(e){this._assertNotAttached();let i=this._portalOutlet.attachComponentPortal(e);return this._afterPortalAttached(),i}attachTemplatePortal(e){this._assertNotAttached();let i=this._portalOutlet.attachTemplatePortal(e);return this._afterPortalAttached(),i}onAnimationEnd(e){let{fromState:i,toState:r}=e;if(("void"===r&&"void"!==i||"hidden"===r)&&this._completeExit(),"visible"===r){let o=this._onEnter;this._ngZone.run(()=>{o.next(),o.complete()})}}enter(){this._destroyed||(this._animationState="visible",this._changeDetectorRef.detectChanges(),this._screenReaderAnnounce())}exit(){return this._ngZone.run(()=>{this._animationState="hidden",this._elementRef.nativeElement.setAttribute("mat-exit",""),clearTimeout(this._announceTimeoutId)}),this._onExit}ngOnDestroy(){this._destroyed=!0,this._clearFromModals(),this._completeExit()}_completeExit(){this._ngZone.onMicrotaskEmpty.pipe(Yt(1)).subscribe(()=>{this._ngZone.run(()=>{this._onExit.next(),this._onExit.complete()})})}_afterPortalAttached(){let e=this._elementRef.nativeElement,i=this.snackBarConfig.panelClass;i&&(Array.isArray(i)?i.forEach(r=>e.classList.add(r)):e.classList.add(i)),this._exposeToModals()}_exposeToModals(){let e=this._liveElementId,i=this._document.querySelectorAll('body > .cdk-overlay-container [aria-modal="true"]');for(let r=0;r<i.length;r++){let o=i[r],s=o.getAttribute("aria-owns");this._trackedModals.add(o),s?-1===s.indexOf(e)&&o.setAttribute("aria-owns",s+" "+e):o.setAttribute("aria-owns",e)}}_clearFromModals(){this._trackedModals.forEach(e=>{let i=e.getAttribute("aria-owns");if(i){let r=i.replace(this._liveElementId,"").trim();r.length>0?e.setAttribute("aria-owns",r):e.removeAttribute("aria-owns")}}),this._trackedModals.clear()}_assertNotAttached(){this._portalOutlet.hasAttached()}_screenReaderAnnounce(){this._announceTimeoutId||this._ngZone.runOutsideAngular(()=>{this._announceTimeoutId=setTimeout(()=>{let e=this._elementRef.nativeElement.querySelector("[aria-hidden]"),i=this._elementRef.nativeElement.querySelector("[aria-live]");if(e&&i){let r=null;this._platform.isBrowser&&document.activeElement instanceof HTMLElement&&e.contains(document.activeElement)&&(r=document.activeElement),e.removeAttribute("aria-hidden"),i.appendChild(e),r?.focus(),this._onAnnounce.next(),this._onAnnounce.complete()}},this._announceDelay)})}}return n.\u0275fac=function(e){return new(e||n)(C(at),C(Me),C($t),C(Gn),C(fg))},n.\u0275dir=we({type:n,viewQuery:function(e,i){if(1&e&&Ge(ps,7),2&e){let r;Se(r=Ee())&&(i._portalOutlet=r.first)}},features:[Ke]}),n})(),dbe=(()=>{class n extends cbe{_afterPortalAttached(){super._afterPortalAttached();let e=this._label.nativeElement,i="mdc-snackbar__label";e.classList.toggle(i,!e.querySelector(`.${i}`))}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275cmp=O({type:n,selectors:[["mat-snack-bar-container"]],viewQuery:function(e,i){if(1&e&&Ge(ebe,7),2&e){let r;Se(r=Ee())&&(i._label=r.first)}},hostAttrs:[1,"mdc-snackbar","mat-mdc-snack-bar-container","mdc-snackbar--open"],hostVars:1,hostBindings:function(e,i){1&e&&zM("@state.done",function(o){return i.onAnimationEnd(o)}),2&e&&GM("@state",i._animationState)},features:[Ke],decls:6,vars:3,consts:[[1,"mdc-snackbar__surface"],[1,"mat-mdc-snack-bar-label"],["label",""],["aria-hidden","true"],["cdkPortalOutlet",""]],template:function(e,i){1&e&&(h(0,"div",0)(1,"div",1,2)(3,"div",3),S(4,tbe,0,0,"ng-template",4),g(),P(5,"div"),g()()),2&e&&(v(5),Be("aria-live",i._live)("role",i._role)("id",i._liveElementId))},dependencies:[ps],styles:['.mdc-snackbar{display:none;position:fixed;right:0;bottom:0;left:0;align-items:center;justify-content:center;box-sizing:border-box;pointer-events:none;-webkit-tap-highlight-color:rgba(0,0,0,0)}.mdc-snackbar--opening,.mdc-snackbar--open,.mdc-snackbar--closing{display:flex}.mdc-snackbar--open .mdc-snackbar__label,.mdc-snackbar--open .mdc-snackbar__actions{visibility:visible}.mdc-snackbar__surface{padding-left:0;padding-right:8px;display:flex;align-items:center;justify-content:flex-start;box-sizing:border-box;transform:scale(0.8);opacity:0}.mdc-snackbar__surface::before{position:absolute;box-sizing:border-box;width:100%;height:100%;top:0;left:0;border:1px solid rgba(0,0,0,0);border-radius:inherit;content:"";pointer-events:none}@media screen and (forced-colors: active){.mdc-snackbar__surface::before{border-color:CanvasText}}[dir=rtl] .mdc-snackbar__surface,.mdc-snackbar__surface[dir=rtl]{padding-left:8px;padding-right:0}.mdc-snackbar--open .mdc-snackbar__surface{transform:scale(1);opacity:1;pointer-events:auto}.mdc-snackbar--closing .mdc-snackbar__surface{transform:scale(1)}.mdc-snackbar__label{padding-left:16px;padding-right:8px;width:100%;flex-grow:1;box-sizing:border-box;margin:0;visibility:hidden;padding-top:14px;padding-bottom:14px}[dir=rtl] .mdc-snackbar__label,.mdc-snackbar__label[dir=rtl]{padding-left:8px;padding-right:16px}.mdc-snackbar__label::before{display:inline;content:attr(data-mdc-snackbar-label-text)}.mdc-snackbar__actions{display:flex;flex-shrink:0;align-items:center;box-sizing:border-box;visibility:hidden}.mdc-snackbar__action+.mdc-snackbar__dismiss{margin-left:8px;margin-right:0}[dir=rtl] .mdc-snackbar__action+.mdc-snackbar__dismiss,.mdc-snackbar__action+.mdc-snackbar__dismiss[dir=rtl]{margin-left:0;margin-right:8px}.mat-mdc-snack-bar-container{margin:8px;position:static}.mat-mdc-snack-bar-container .mdc-snackbar__surface{min-width:344px}@media(max-width: 480px),(max-width: 344px){.mat-mdc-snack-bar-container .mdc-snackbar__surface{min-width:100%}}@media(max-width: 480px),(max-width: 344px){.mat-mdc-snack-bar-container{width:100vw}}.mat-mdc-snack-bar-container .mdc-snackbar__surface{max-width:672px}.mat-mdc-snack-bar-container .mdc-snackbar__surface{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2), 0px 6px 10px 0px rgba(0, 0, 0, 0.14), 0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-mdc-snack-bar-container .mdc-snackbar__dismiss .mdc-button__icon{font-size:var(--mdc-icon-button-icon-size, var(--mdc-snackbar-icon-size, 24px))}.mat-mdc-snack-bar-container .mdc-snackbar__dismiss svg,.mat-mdc-snack-bar-container .mdc-snackbar__dismiss img{width:var(--mdc-icon-button-icon-size, var(--mdc-snackbar-icon-size, 24px));height:var(--mdc-icon-button-icon-size, var(--mdc-snackbar-icon-size, 24px))}.mat-mdc-snack-bar-container .mdc-snackbar__surface{background-color:var(--mdc-snackbar-container-color, inherit)}.mat-mdc-snack-bar-container .mdc-snackbar__surface{border-radius:var(--mdc-snackbar-container-shape, var(--mdc-shape-small, 4px))}.mat-mdc-snack-bar-container .mdc-snackbar__label{color:var(--mdc-snackbar-supporting-text-color, inherit)}.mat-mdc-snack-bar-container .mdc-snackbar__label{font-size:var(--mdc-snackbar-supporting-text-size, inherit);font-family:var(--mdc-snackbar-supporting-text-font, inherit);font-weight:var(--mdc-snackbar-supporting-text-weight, inherit);line-height:var(--mdc-snackbar-supporting-text-line-height, inherit)}.mat-mdc-snack-bar-container .mat-mdc-button.mat-mdc-snack-bar-action:not(:disabled){color:var(--mat-mdc-snack-bar-button-color, transparent);--mat-mdc-button-persistent-ripple-color: currentColor}.mat-mdc-snack-bar-container .mat-mdc-button.mat-mdc-snack-bar-action:not(:disabled) .mat-ripple-element{background-color:currentColor;opacity:.1}.mat-mdc-snack-bar-container .mdc-snackbar__label::before{display:none}.mat-mdc-snack-bar-handset,.mat-mdc-snack-bar-container,.mat-mdc-snack-bar-label{flex:1 1 auto}.mat-mdc-snack-bar-handset .mdc-snackbar__surface{width:100%}'],encapsulation:2,data:{animation:[abe.snackBarState]}}),n})(),O2=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Co,Hl,Pe,ci,fn,fn]}),n})(),Q7=new ie("mat-snack-bar-default-options",{providedIn:"root",factory:function(){return new fg}}),pbe=(()=>{class n{get _openedSnackBarRef(){let e=this._parentSnackBar;return e?e._openedSnackBarRef:this._snackBarRefAtThisLevel}set _openedSnackBarRef(e){this._parentSnackBar?this._parentSnackBar._openedSnackBarRef=e:this._snackBarRefAtThisLevel=e}constructor(e,i,r,o,s,a){this._overlay=e,this._live=i,this._injector=r,this._breakpointObserver=o,this._parentSnackBar=s,this._defaultConfig=a,this._snackBarRefAtThisLevel=null}openFromComponent(e,i){return this._attach(e,i)}openFromTemplate(e,i){return this._attach(e,i)}open(e,i="",r){let o={...this._defaultConfig,...r};return o.data={message:e,action:i},o.announcementMessage===e&&(o.announcementMessage=void 0),this.openFromComponent(this.simpleSnackBarComponent,o)}dismiss(){this._openedSnackBarRef&&this._openedSnackBarRef.dismiss()}ngOnDestroy(){this._snackBarRefAtThisLevel&&this._snackBarRefAtThisLevel.dismiss()}_attachSnackBarContainer(e,i){let o=Mi.create({parent:i&&i.viewContainerRef&&i.viewContainerRef.injector||this._injector,providers:[{provide:fg,useValue:i}]}),s=new Vl(this.snackBarContainerComponent,i.viewContainerRef,o),a=e.attach(s);return a.instance.snackBarConfig=i,a.instance}_attach(e,i){let r={...new fg,...this._defaultConfig,...i},o=this._createOverlay(r),s=this._attachSnackBarContainer(o,r),a=new Cf(s,o);if(e instanceof Si){let l=new Yo(e,null,{$implicit:r.data,snackBarRef:a});a.instance=s.attachTemplatePortal(l)}else{let l=this._createInjector(r,a),c=new Vl(e,void 0,l),d=s.attachComponentPortal(c);a.instance=d.instance}return this._breakpointObserver.observe("(max-width: 599.98px) and (orientation: portrait)").pipe(ot(o.detachments())).subscribe(l=>{o.overlayElement.classList.toggle(this.handsetCssClass,l.matches)}),r.announcementMessage&&s._onAnnounce.subscribe(()=>{this._live.announce(r.announcementMessage,r.politeness)}),this._animateSnackBar(a,r),this._openedSnackBarRef=a,this._openedSnackBarRef}_animateSnackBar(e,i){e.afterDismissed().subscribe(()=>{this._openedSnackBarRef==e&&(this._openedSnackBarRef=null),i.announcementMessage&&this._live.clear()}),this._openedSnackBarRef?(this._openedSnackBarRef.afterDismissed().subscribe(()=>{e.containerInstance.enter()}),this._openedSnackBarRef.dismiss()):e.containerInstance.enter(),i.duration&&i.duration>0&&e.afterOpened().subscribe(()=>e._dismissAfter(i.duration))}_createOverlay(e){let i=new Qa;i.direction=e.direction;let r=this._overlay.position().global(),o="rtl"===e.direction,s="left"===e.horizontalPosition||"start"===e.horizontalPosition&&!o||"end"===e.horizontalPosition&&o,a=!s&&"center"!==e.horizontalPosition;return s?r.left("0"):a?r.right("0"):r.centerHorizontally(),"top"===e.verticalPosition?r.top("0"):r.bottom("0"),i.positionStrategy=r,this._overlay.create(i)}_createInjector(e,i){return Mi.create({parent:e&&e.viewContainerRef&&e.viewContainerRef.injector||this._injector,providers:[{provide:Cf,useValue:i},{provide:Y1,useValue:e.data}]})}}return n.\u0275fac=function(e){return new(e||n)(k(zi),k(Vv),k(Mi),k(Fv),k(n,12),k(Q7))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),Z7=(()=>{class n extends pbe{constructor(e,i,r,o,s,a){super(e,i,r,o,s,a),this.simpleSnackBarComponent=sbe,this.snackBarContainerComponent=dbe,this.handsetCssClass="mat-mdc-snack-bar-handset"}}return n.\u0275fac=function(e){return new(e||n)(k(zi),k(Vv),k(Mi),k(Fv),k(n,12),k(Q7))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:O2}),n})(),fbe=/[\\^$.*+?()[\]{}|]/g,J7="\\u0000-\\u0020\\u007f-\\u009f",hbe=new RegExp("(?:[a-zA-Z][a-zA-Z0-9+.-]{2,}:\\/\\/|data:|www\\.)[^\\s"+J7+'"]{2,}[^\\s'+J7+"\"')}\\],:;.!?]","gu");function e9(n){return function(n,t){t.flags.includes("g")||(t=new RegExp(t,t.flags+"g"));let e=[],i=0;for(let r of n.matchAll(t)){let o=r.index,s=r[0];o>i&&e.push({index:i,text:n.substring(i,o),matchesRegex:!1}),e.push({index:o,text:s,matchesRegex:!0}),i=o+s.length}return n.length>i&&e.push({index:i,text:n.substring(i,n.length),matchesRegex:!1}),e}(n,hbe).map(({matchesRegex:t,text:e})=>({isURL:t,text:e}))}function gbe(n,t){if(1&n&&(Ot(0),T(1),kt()),2&n){let e=w().$implicit;v(1),He(" ",e.text," ")}}function _be(n,t){if(1&n&&(h(0,"a",7),T(1),g()),2&n){let e=w().$implicit;Wi("href",e.text,ka),v(1),bt(e.text)}}function bbe(n,t){if(1&n&&(Ot(0),S(1,gbe,2,1,"ng-container",5),S(2,_be,2,2,"ng-template",null,6,Wt),kt()),2&n){let e=t.$implicit,i=it(3);v(1),_("ngIf",!e.isURL)("ngIfElse",i)}}function vbe(n,t){if(1&n){let e=ge();h(0,"button",8),I("click",function(){return X(e),Q(w().onActionButtonClicked())}),T(1),g()}if(2&n){let e=w();v(1),He(" ",e.alert.followupAction.localizedLabel," ")}}var t9=(()=>{class n{constructor(e,i,r){this.snackBarRef=e,this.unknownData=i,this.store=r,this.splitByURL=e9,this.alert=i}async onActionButtonClicked(){this.snackBarRef.dismiss();let e=await this.alert.followupAction.getFollowupAction();this.store.dispatch(e)}onCloseButtonClicked(){this.snackBarRef.dismiss()}}return n.\u0275fac=function(e){return new(e||n)(C(Cf),C(Y1),C(Ae))},n.\u0275cmp=O({type:n,selectors:[["alert-display-snackbar"]],decls:6,vars:2,consts:function(){let t;return t=$localize`:A button to close the snackbar message␟ea4d9fe61420a3fce81cf54c4c615e3c19c646a6␟1536087519743707362:Dismiss`,[[1,"message"],[4,"ngFor","ngForOf"],[1,"controls"],["mat-button","","class","followup-button",3,"click",4,"ngIf"],["mat-button","","aria-label",t,1,"dismiss-button",3,"click"],[4,"ngIf","ngIfElse"],["linkPiece",""],["rel","noreferrer noopener","target","_blank",3,"href"],["mat-button","",1,"followup-button",3,"click"]]},template:function(e,i){1&e&&(h(0,"div",0),S(1,bbe,4,2,"ng-container",1),g(),h(2,"div",2),S(3,vbe,2,1,"button",3),h(4,"button",4),I("click",function(){return i.onCloseButtonClicked()}),T(5," Dismiss "),g()()),2&e&&(v(1),_("ngForOf",i.splitByURL(i.alert.localizedMessage)),v(2),_("ngIf",i.alert.followupAction))},dependencies:[nn,Fe,Ji],styles:["[_nghost-%COMP%]{display:flex;flex-wrap:wrap}.message[_ngcontent-%COMP%]{font-size:14px;align-self:center;margin:5px 0;word-break:break-word}.message[_ngcontent-%COMP%]   a[_ngcontent-%COMP%]{color:inherit}.controls[_ngcontent-%COMP%]{white-space:nowrap;margin-left:auto}button.mat-mdc-button[_ngcontent-%COMP%]{color:inherit;text-transform:uppercase}"],changeDetection:0}),n})(),n9=(()=>{class n{constructor(e,i){this.store=e,this.snackBar=i,this.ngUnsubscribe=new Ie}ngOnInit(){this.store.select(j6).pipe(ot(this.ngUnsubscribe),ke(e=>Boolean(e))).subscribe(e=>{this.showAlert(e)})}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}showAlert(e){this.snackBar.openFromComponent(t9,{duration:5e3,horizontalPosition:"start",verticalPosition:"bottom",data:e})}}return n.\u0275fac=function(e){return new(e||n)(C(Ae),C(Z7))},n.\u0275cmp=O({type:n,selectors:[["alert-snackbar"]],decls:0,vars:0,template:function(e,i){},encapsulation:2,changeDetection:0}),n})(),X1=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Pe,ci,O2]}),n})(),Q1=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Sc,X1,Tr.forFeature("alerts",i7),to.forFeature([n7])]}),n})();function xbe(n,t){}var Mf=class{constructor(){this.role="dialog",this.panelClass="",this.hasBackdrop=!0,this.backdropClass="",this.disableClose=!1,this.width="",this.height="",this.data=null,this.ariaDescribedBy=null,this.ariaLabelledBy=null,this.ariaLabel=null,this.ariaModal=!0,this.autoFocus="first-tabbable",this.restoreFocus=!0,this.closeOnNavigation=!0,this.closeOnDestroy=!0,this.closeOnOverlayDetachments=!0}},F2=(()=>{class n extends Fu{constructor(e,i,r,o,s,a,l,c){super(),this._elementRef=e,this._focusTrapFactory=i,this._config=o,this._interactivityChecker=s,this._ngZone=a,this._overlayRef=l,this._focusMonitor=c,this._elementFocusedBeforeDialogWasOpened=null,this._closeInteractionType=null,this.attachDomPortal=d=>{this._portalOutlet.hasAttached();let u=this._portalOutlet.attachDomPortal(d);return this._contentAttached(),u},this._ariaLabelledBy=this._config.ariaLabelledBy||null,this._document=r}_contentAttached(){this._initializeFocusTrap(),this._handleBackdropClicks(),this._captureInitialFocus()}_captureInitialFocus(){this._trapFocus()}ngOnDestroy(){this._restoreFocus()}attachComponentPortal(e){this._portalOutlet.hasAttached();let i=this._portalOutlet.attachComponentPortal(e);return this._contentAttached(),i}attachTemplatePortal(e){this._portalOutlet.hasAttached();let i=this._portalOutlet.attachTemplatePortal(e);return this._contentAttached(),i}_recaptureFocus(){this._containsFocus()||this._trapFocus()}_forceFocus(e,i){this._interactivityChecker.isFocusable(e)||(e.tabIndex=-1,this._ngZone.runOutsideAngular(()=>{let r=()=>{e.removeEventListener("blur",r),e.removeEventListener("mousedown",r),e.removeAttribute("tabindex")};e.addEventListener("blur",r),e.addEventListener("mousedown",r)})),e.focus(i)}_focusByCssSelector(e,i){let r=this._elementRef.nativeElement.querySelector(e);r&&this._forceFocus(r,i)}_trapFocus(){let e=this._elementRef.nativeElement;switch(this._config.autoFocus){case!1:case"dialog":this._containsFocus()||e.focus();break;case!0:case"first-tabbable":this._focusTrap.focusInitialElementWhenReady().then(i=>{i||this._focusDialogContainer()});break;case"first-heading":this._focusByCssSelector('h1, h2, h3, h4, h5, h6, [role="heading"]');break;default:this._focusByCssSelector(this._config.autoFocus)}}_restoreFocus(){let e=this._config.restoreFocus,i=null;if("string"==typeof e?i=this._document.querySelector(e):"boolean"==typeof e?i=e?this._elementFocusedBeforeDialogWasOpened:null:e&&(i=e),this._config.restoreFocus&&i&&"function"==typeof i.focus){let r=Ov(),o=this._elementRef.nativeElement;(!r||r===this._document.body||r===o||o.contains(r))&&(this._focusMonitor?(this._focusMonitor.focusVia(i,this._closeInteractionType),this._closeInteractionType=null):i.focus())}this._focusTrap&&this._focusTrap.destroy()}_focusDialogContainer(){this._elementRef.nativeElement.focus&&this._elementRef.nativeElement.focus()}_containsFocus(){let e=this._elementRef.nativeElement,i=Ov();return e===i||e.contains(i)}_initializeFocusTrap(){this._focusTrap=this._focusTrapFactory.create(this._elementRef.nativeElement),this._document&&(this._elementFocusedBeforeDialogWasOpened=Ov())}_handleBackdropClicks(){this._overlayRef.backdropClick().subscribe(()=>{this._config.disableClose&&this._recaptureFocus()})}}return n.\u0275fac=function(e){return new(e||n)(C(Me),C(Nv),C(Lt,8),C(Mf),C(ag),C(at),C(Oc),C(Xr))},n.\u0275cmp=O({type:n,selectors:[["cdk-dialog-container"]],viewQuery:function(e,i){if(1&e&&Ge(ps,7),2&e){let r;Se(r=Ee())&&(i._portalOutlet=r.first)}},hostAttrs:["tabindex","-1",1,"cdk-dialog-container"],hostVars:6,hostBindings:function(e,i){2&e&&Be("id",i._config.id||null)("role",i._config.role)("aria-modal",i._config.ariaModal)("aria-labelledby",i._config.ariaLabel?null:i._ariaLabelledBy)("aria-label",i._config.ariaLabel)("aria-describedby",i._config.ariaDescribedBy||null)},features:[Ke],decls:1,vars:0,consts:[["cdkPortalOutlet",""]],template:function(e,i){1&e&&S(0,xbe,0,0,"ng-template",0)},dependencies:[ps],styles:[".cdk-dialog-container{display:block;width:100%;height:100%;min-height:inherit;max-height:inherit}"],encapsulation:2}),n})(),Yv=class{constructor(t,e){this.overlayRef=t,this.config=e,this.closed=new Ie,this.disableClose=e.disableClose,this.backdropClick=t.backdropClick(),this.keydownEvents=t.keydownEvents(),this.outsidePointerEvents=t.outsidePointerEvents(),this.id=e.id,this.keydownEvents.subscribe(i=>{27===i.keyCode&&!this.disableClose&&!vr(i)&&(i.preventDefault(),this.close(void 0,{focusOrigin:"keyboard"}))}),this.backdropClick.subscribe(()=>{this.disableClose||this.close(void 0,{focusOrigin:"mouse"})}),this._detachSubscription=t.detachments().subscribe(()=>{!1!==e.closeOnOverlayDetachments&&this.close()})}close(t,e){if(this.containerInstance){let i=this.closed;this.containerInstance._closeInteractionType=e?.focusOrigin||"program",this._detachSubscription.unsubscribe(),this.overlayRef.dispose(),i.next(t),i.complete(),this.componentInstance=this.containerInstance=null}}updatePosition(){return this.overlayRef.updatePosition(),this}updateSize(t="",e=""){return this.overlayRef.updateSize({width:t,height:e}),this}addPanelClass(t){return this.overlayRef.addPanelClass(t),this}removePanelClass(t){return this.overlayRef.removePanelClass(t),this}},i9=new ie("DialogScrollStrategy"),Cbe=new ie("DialogData"),Mbe=new ie("DefaultDialogConfig"),Sbe={provide:i9,deps:[zi],useFactory:function(n){return()=>n.scrollStrategies.block()}},Ebe=0,N2=(()=>{class n{get openDialogs(){return this._parentDialog?this._parentDialog.openDialogs:this._openDialogsAtThisLevel}get afterOpened(){return this._parentDialog?this._parentDialog.afterOpened:this._afterOpenedAtThisLevel}constructor(e,i,r,o,s,a){this._overlay=e,this._injector=i,this._defaultOptions=r,this._parentDialog=o,this._overlayContainer=s,this._openDialogsAtThisLevel=[],this._afterAllClosedAtThisLevel=new Ie,this._afterOpenedAtThisLevel=new Ie,this._ariaHiddenElements=new Map,this.afterAllClosed=ta(()=>this.openDialogs.length?this._getAfterAllClosed():this._getAfterAllClosed().pipe(qn(void 0))),this._scrollStrategy=a}open(e,i){(i={...this._defaultOptions||new Mf,...i}).id=i.id||"cdk-dialog-"+Ebe++,i.id&&this.getDialogById(i.id);let o=this._getOverlayConfig(i),s=this._overlay.create(o),a=new Yv(s,i),l=this._attachContainer(s,a,i);return a.containerInstance=l,this._attachDialogContent(e,a,l,i),this.openDialogs.length||this._hideNonDialogContentFromAssistiveTechnology(),this.openDialogs.push(a),a.closed.subscribe(()=>this._removeOpenDialog(a,!0)),this.afterOpened.next(a),a}closeAll(){k2(this.openDialogs,e=>e.close())}getDialogById(e){return this.openDialogs.find(i=>i.id===e)}ngOnDestroy(){k2(this._openDialogsAtThisLevel,e=>{!1===e.config.closeOnDestroy&&this._removeOpenDialog(e,!1)}),k2(this._openDialogsAtThisLevel,e=>e.close()),this._afterAllClosedAtThisLevel.complete(),this._afterOpenedAtThisLevel.complete(),this._openDialogsAtThisLevel=[]}_getOverlayConfig(e){let i=new Qa({positionStrategy:e.positionStrategy||this._overlay.position().global().centerHorizontally().centerVertically(),scrollStrategy:e.scrollStrategy||this._scrollStrategy(),panelClass:e.panelClass,hasBackdrop:e.hasBackdrop,direction:e.direction,minWidth:e.minWidth,minHeight:e.minHeight,maxWidth:e.maxWidth,maxHeight:e.maxHeight,width:e.width,height:e.height,disposeOnNavigation:e.closeOnNavigation});return e.backdropClass&&(i.backdropClass=e.backdropClass),i}_attachContainer(e,i,r){let a,o=r.injector||r.viewContainerRef?.injector,s=[{provide:Mf,useValue:r},{provide:Yv,useValue:i},{provide:Oc,useValue:e}];r.container?"function"==typeof r.container?a=r.container:(a=r.container.type,s.push(...r.container.providers(r))):a=F2;let l=new Vl(a,r.viewContainerRef,Mi.create({parent:o||this._injector,providers:s}),r.componentFactoryResolver);return e.attach(l).instance}_attachDialogContent(e,i,r,o){if(e instanceof Si){let s=this._createInjector(o,i,r,void 0),a={$implicit:o.data,dialogRef:i};o.templateContext&&(a={...a,..."function"==typeof o.templateContext?o.templateContext():o.templateContext}),r.attachTemplatePortal(new Yo(e,null,a,s))}else{let s=this._createInjector(o,i,r,this._injector),a=r.attachComponentPortal(new Vl(e,o.viewContainerRef,s,o.componentFactoryResolver));i.componentInstance=a.instance}}_createInjector(e,i,r,o){let s=e.injector||e.viewContainerRef?.injector,a=[{provide:Cbe,useValue:e.data},{provide:Yv,useValue:i}];return e.providers&&("function"==typeof e.providers?a.push(...e.providers(i,e,r)):a.push(...e.providers)),e.direction&&(!s||!s.get(Xi,null,{optional:!0}))&&a.push({provide:Xi,useValue:{value:e.direction,change:Ht()}}),Mi.create({parent:s||o,providers:a})}_removeOpenDialog(e,i){let r=this.openDialogs.indexOf(e);r>-1&&(this.openDialogs.splice(r,1),this.openDialogs.length||(this._ariaHiddenElements.forEach((o,s)=>{o?s.setAttribute("aria-hidden",o):s.removeAttribute("aria-hidden")}),this._ariaHiddenElements.clear(),i&&this._getAfterAllClosed().next()))}_hideNonDialogContentFromAssistiveTechnology(){let e=this._overlayContainer.getContainerElement();if(e.parentElement){let i=e.parentElement.children;for(let r=i.length-1;r>-1;r--){let o=i[r];o!==e&&"SCRIPT"!==o.nodeName&&"STYLE"!==o.nodeName&&!o.hasAttribute("aria-live")&&(this._ariaHiddenElements.set(o,o.getAttribute("aria-hidden")),o.setAttribute("aria-hidden","true"))}}}_getAfterAllClosed(){let e=this._parentDialog;return e?e._getAfterAllClosed():this._afterAllClosedAtThisLevel}}return n.\u0275fac=function(e){return new(e||n)(k(zi),k(Mi),k(Mbe,8),k(n,12),k(pg),k(i9))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})();function k2(n,t){let e=n.length;for(;e--;)t(n[e])}var r9=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({providers:[N2,Sbe],imports:[Co,Hl,lg,Hl]}),n})();function Tbe(n,t){}var mg=class{constructor(){this.role="dialog",this.panelClass="",this.hasBackdrop=!0,this.backdropClass="",this.disableClose=!1,this.width="",this.height="",this.maxWidth="80vw",this.data=null,this.ariaDescribedBy=null,this.ariaLabelledBy=null,this.ariaLabel=null,this.ariaModal=!0,this.autoFocus="first-tabbable",this.restoreFocus=!0,this.delayFocusTrap=!0,this.closeOnNavigation=!0}},L2="mdc-dialog--open",o9="mdc-dialog--opening",s9="mdc-dialog--closing",Abe=(()=>{class n extends F2{constructor(e,i,r,o,s,a,l,c){super(e,i,r,o,s,a,l,c),this._animationStateChanged=new F}_captureInitialFocus(){this._config.delayFocusTrap||this._trapFocus()}_openAnimationDone(e){this._config.delayFocusTrap&&this._trapFocus(),this._animationStateChanged.next({state:"opened",totalTime:e})}}return n.\u0275fac=function(e){return new(e||n)(C(Me),C(Nv),C(Lt,8),C(mg),C(ag),C(at),C(Oc),C(Xr))},n.\u0275cmp=O({type:n,selectors:[["ng-component"]],features:[Ke],decls:0,vars:0,template:function(e,i){},encapsulation:2}),n})(),a9="--mat-dialog-transition-duration";function l9(n){return null==n?null:"number"==typeof n?n:n.endsWith("ms")?_i(n.substring(0,n.length-2)):n.endsWith("s")?1e3*_i(n.substring(0,n.length-1)):"0"===n?0:null}var Rbe=(()=>{class n extends Abe{constructor(e,i,r,o,s,a,l,c,d){super(e,i,r,o,s,a,l,d),this._animationMode=c,this._animationsEnabled="NoopAnimations"!==this._animationMode,this._hostElement=this._elementRef.nativeElement,this._openAnimationDuration=this._animationsEnabled?l9(this._config.enterAnimationDuration)??150:0,this._closeAnimationDuration=this._animationsEnabled?l9(this._config.exitAnimationDuration)??75:0,this._animationTimer=null,this._finishDialogOpen=()=>{this._clearAnimationClasses(),this._openAnimationDone(this._openAnimationDuration)},this._finishDialogClose=()=>{this._clearAnimationClasses(),this._animationStateChanged.emit({state:"closed",totalTime:this._closeAnimationDuration})}}_contentAttached(){super._contentAttached(),this._startOpenAnimation()}ngOnDestroy(){super.ngOnDestroy(),null!==this._animationTimer&&clearTimeout(this._animationTimer)}_startOpenAnimation(){this._animationStateChanged.emit({state:"opening",totalTime:this._openAnimationDuration}),this._animationsEnabled?(this._hostElement.style.setProperty(a9,`${this._openAnimationDuration}ms`),this._requestAnimationFrame(()=>this._hostElement.classList.add(o9,L2)),this._waitForAnimationToComplete(this._openAnimationDuration,this._finishDialogOpen)):(this._hostElement.classList.add(L2),Promise.resolve().then(()=>this._finishDialogOpen()))}_startExitAnimation(){this._animationStateChanged.emit({state:"closing",totalTime:this._closeAnimationDuration}),this._hostElement.classList.remove(L2),this._animationsEnabled?(this._hostElement.style.setProperty(a9,`${this._openAnimationDuration}ms`),this._requestAnimationFrame(()=>this._hostElement.classList.add(s9)),this._waitForAnimationToComplete(this._closeAnimationDuration,this._finishDialogClose)):Promise.resolve().then(()=>this._finishDialogClose())}_clearAnimationClasses(){this._hostElement.classList.remove(o9,s9)}_waitForAnimationToComplete(e,i){null!==this._animationTimer&&clearTimeout(this._animationTimer),this._animationTimer=setTimeout(i,e)}_requestAnimationFrame(e){this._ngZone.runOutsideAngular(()=>{"function"==typeof requestAnimationFrame?requestAnimationFrame(e):e()})}}return n.\u0275fac=function(e){return new(e||n)(C(Me),C(Nv),C(Lt,8),C(mg),C(ag),C(at),C(Oc),C(hi,8),C(Xr))},n.\u0275cmp=O({type:n,selectors:[["mat-dialog-container"]],hostAttrs:["tabindex","-1",1,"mat-mdc-dialog-container","mdc-dialog"],hostVars:8,hostBindings:function(e,i){2&e&&(jo("id",i._config.id),Be("aria-modal",i._config.ariaModal)("role",i._config.role)("aria-labelledby",i._config.ariaLabel?null:i._ariaLabelledBy)("aria-label",i._config.ariaLabel)("aria-describedby",i._config.ariaDescribedBy||null),nt("_mat-animation-noopable",!i._animationsEnabled))},features:[Ke],decls:3,vars:0,consts:[[1,"mdc-dialog__container"],[1,"mat-mdc-dialog-surface","mdc-dialog__surface"],["cdkPortalOutlet",""]],template:function(e,i){1&e&&(h(0,"div",0)(1,"div",1),S(2,Tbe,0,0,"ng-template",2),g()())},dependencies:[ps],styles:['.mdc-elevation-overlay{position:absolute;border-radius:inherit;pointer-events:none;opacity:var(--mdc-elevation-overlay-opacity, 0);transition:opacity 280ms cubic-bezier(0.4, 0, 0.2, 1)}.mdc-dialog,.mdc-dialog__scrim{position:fixed;top:0;left:0;align-items:center;justify-content:center;box-sizing:border-box;width:100%;height:100%}.mdc-dialog{display:none;z-index:var(--mdc-dialog-z-index, 7)}.mdc-dialog .mdc-dialog__content{padding:20px 24px 20px 24px}.mdc-dialog .mdc-dialog__surface{min-width:280px}@media(max-width: 592px){.mdc-dialog .mdc-dialog__surface{max-width:calc(100vw - 32px)}}@media(min-width: 592px){.mdc-dialog .mdc-dialog__surface{max-width:560px}}.mdc-dialog .mdc-dialog__surface{max-height:calc(100% - 32px)}.mdc-dialog.mdc-dialog--fullscreen .mdc-dialog__surface{max-width:none}@media(max-width: 960px){.mdc-dialog.mdc-dialog--fullscreen .mdc-dialog__surface{max-height:560px;width:560px}.mdc-dialog.mdc-dialog--fullscreen .mdc-dialog__surface .mdc-dialog__close{right:-12px}}@media(max-width: 720px)and (max-width: 672px){.mdc-dialog.mdc-dialog--fullscreen .mdc-dialog__surface{width:calc(100vw - 112px)}}@media(max-width: 720px)and (min-width: 672px){.mdc-dialog.mdc-dialog--fullscreen .mdc-dialog__surface{width:560px}}@media(max-width: 720px)and (max-height: 720px){.mdc-dialog.mdc-dialog--fullscreen .mdc-dialog__surface{max-height:calc(100vh - 160px)}}@media(max-width: 720px)and (min-height: 720px){.mdc-dialog.mdc-dialog--fullscreen .mdc-dialog__surface{max-height:560px}}@media(max-width: 720px){.mdc-dialog.mdc-dialog--fullscreen .mdc-dialog__surface .mdc-dialog__close{right:-12px}}@media(max-width: 720px)and (max-height: 400px),(max-width: 600px),(min-width: 720px)and (max-height: 400px){.mdc-dialog.mdc-dialog--fullscreen .mdc-dialog__surface{height:100%;max-height:100vh;max-width:100vw;width:100vw;border-radius:0}.mdc-dialog.mdc-dialog--fullscreen .mdc-dialog__surface .mdc-dialog__close{order:-1;left:-12px}.mdc-dialog.mdc-dialog--fullscreen .mdc-dialog__surface .mdc-dialog__header{padding:0 16px 9px;justify-content:flex-start}.mdc-dialog.mdc-dialog--fullscreen .mdc-dialog__surface .mdc-dialog__title{margin-left:calc(16px - 2 * 12px)}}@media(min-width: 960px){.mdc-dialog.mdc-dialog--fullscreen .mdc-dialog__surface{width:calc(100vw - 400px)}.mdc-dialog.mdc-dialog--fullscreen .mdc-dialog__surface .mdc-dialog__close{right:-12px}}.mdc-dialog.mdc-dialog__scrim--hidden .mdc-dialog__scrim{opacity:0}.mdc-dialog__scrim{opacity:0;z-index:-1}.mdc-dialog__container{display:flex;flex-direction:row;align-items:center;justify-content:space-around;box-sizing:border-box;height:100%;transform:scale(0.8);opacity:0;pointer-events:none}.mdc-dialog__surface{position:relative;display:flex;flex-direction:column;flex-grow:0;flex-shrink:0;box-sizing:border-box;max-width:100%;max-height:100%;pointer-events:auto;overflow-y:auto}.mdc-dialog__surface .mdc-elevation-overlay{width:100%;height:100%;top:0;left:0}[dir=rtl] .mdc-dialog__surface,.mdc-dialog__surface[dir=rtl]{text-align:right}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mdc-dialog__surface{outline:2px solid windowText}}.mdc-dialog__surface::before{position:absolute;box-sizing:border-box;width:100%;height:100%;top:0;left:0;border:2px solid rgba(0,0,0,0);border-radius:inherit;content:"";pointer-events:none}@media screen and (forced-colors: active){.mdc-dialog__surface::before{border-color:CanvasText}}@media screen and (-ms-high-contrast: active),screen and (-ms-high-contrast: none){.mdc-dialog__surface::before{content:none}}.mdc-dialog__title{display:block;margin-top:0;position:relative;flex-shrink:0;box-sizing:border-box;margin:0 0 1px;padding:0 24px 9px}.mdc-dialog__title::before{display:inline-block;width:0;height:40px;content:"";vertical-align:0}[dir=rtl] .mdc-dialog__title,.mdc-dialog__title[dir=rtl]{text-align:right}.mdc-dialog--scrollable .mdc-dialog__title{margin-bottom:1px;padding-bottom:15px}.mdc-dialog--fullscreen .mdc-dialog__header{align-items:baseline;border-bottom:1px solid rgba(0,0,0,0);display:inline-flex;justify-content:space-between;padding:0 24px 9px;z-index:1}@media screen and (forced-colors: active){.mdc-dialog--fullscreen .mdc-dialog__header{border-bottom-color:CanvasText}}.mdc-dialog--fullscreen .mdc-dialog__header .mdc-dialog__close{right:-12px}.mdc-dialog--fullscreen .mdc-dialog__title{margin-bottom:0;padding:0;border-bottom:0}.mdc-dialog--fullscreen.mdc-dialog--scrollable .mdc-dialog__title{border-bottom:0;margin-bottom:0}.mdc-dialog--fullscreen .mdc-dialog__close{top:5px}.mdc-dialog--fullscreen.mdc-dialog--scrollable .mdc-dialog__actions{border-top:1px solid rgba(0,0,0,0)}@media screen and (forced-colors: active){.mdc-dialog--fullscreen.mdc-dialog--scrollable .mdc-dialog__actions{border-top-color:CanvasText}}.mdc-dialog--fullscreen--titleless .mdc-dialog__close{margin-top:4px}.mdc-dialog--fullscreen--titleless.mdc-dialog--scrollable .mdc-dialog__close{margin-top:0}.mdc-dialog__content{flex-grow:1;box-sizing:border-box;margin:0;overflow:auto}.mdc-dialog__content>:first-child{margin-top:0}.mdc-dialog__content>:last-child{margin-bottom:0}.mdc-dialog__title+.mdc-dialog__content,.mdc-dialog__header+.mdc-dialog__content{padding-top:0}.mdc-dialog--scrollable .mdc-dialog__title+.mdc-dialog__content{padding-top:8px;padding-bottom:8px}.mdc-dialog__content .mdc-deprecated-list:first-child:last-child{padding:6px 0 0}.mdc-dialog--scrollable .mdc-dialog__content .mdc-deprecated-list:first-child:last-child{padding:0}.mdc-dialog__actions{display:flex;position:relative;flex-shrink:0;flex-wrap:wrap;align-items:center;justify-content:flex-end;box-sizing:border-box;min-height:52px;margin:0;padding:8px;border-top:1px solid rgba(0,0,0,0)}@media screen and (forced-colors: active){.mdc-dialog__actions{border-top-color:CanvasText}}.mdc-dialog--stacked .mdc-dialog__actions{flex-direction:column;align-items:flex-end}.mdc-dialog__button{margin-left:8px;margin-right:0;max-width:100%;text-align:right}[dir=rtl] .mdc-dialog__button,.mdc-dialog__button[dir=rtl]{margin-left:0;margin-right:8px}.mdc-dialog__button:first-child{margin-left:0;margin-right:0}[dir=rtl] .mdc-dialog__button:first-child,.mdc-dialog__button:first-child[dir=rtl]{margin-left:0;margin-right:0}[dir=rtl] .mdc-dialog__button,.mdc-dialog__button[dir=rtl]{text-align:left}.mdc-dialog--stacked .mdc-dialog__button:not(:first-child){margin-top:12px}.mdc-dialog--open,.mdc-dialog--opening,.mdc-dialog--closing{display:flex}.mdc-dialog--opening .mdc-dialog__scrim{transition:opacity 150ms linear}.mdc-dialog--opening .mdc-dialog__container{transition:opacity 75ms linear,transform 150ms 0ms cubic-bezier(0, 0, 0.2, 1)}.mdc-dialog--closing .mdc-dialog__scrim,.mdc-dialog--closing .mdc-dialog__container{transition:opacity 75ms linear}.mdc-dialog--closing .mdc-dialog__container{transform:none}.mdc-dialog--open .mdc-dialog__scrim{opacity:1}.mdc-dialog--open .mdc-dialog__container{transform:none;opacity:1}.mdc-dialog--open.mdc-dialog__surface-scrim--shown .mdc-dialog__surface-scrim{opacity:1}.mdc-dialog--open.mdc-dialog__surface-scrim--hiding .mdc-dialog__surface-scrim{transition:opacity 75ms linear}.mdc-dialog--open.mdc-dialog__surface-scrim--showing .mdc-dialog__surface-scrim{transition:opacity 150ms linear}.mdc-dialog__surface-scrim{display:none;opacity:0;position:absolute;width:100%;height:100%;z-index:1}.mdc-dialog__surface-scrim--shown .mdc-dialog__surface-scrim,.mdc-dialog__surface-scrim--showing .mdc-dialog__surface-scrim,.mdc-dialog__surface-scrim--hiding .mdc-dialog__surface-scrim{display:block}.mdc-dialog-scroll-lock{overflow:hidden}.mdc-dialog--no-content-padding .mdc-dialog__content{padding:0}.mdc-dialog--sheet .mdc-dialog__close{right:12px;top:9px;position:absolute;z-index:1}.mdc-dialog__scrim--removed{pointer-events:none}.mdc-dialog__scrim--removed .mdc-dialog__scrim,.mdc-dialog__scrim--removed .mdc-dialog__surface-scrim{display:none}.mat-mdc-dialog-content{max-height:65vh}.mat-mdc-dialog-container{position:static;display:block}.mat-mdc-dialog-container,.mat-mdc-dialog-container .mdc-dialog__container,.mat-mdc-dialog-container .mdc-dialog__surface{max-height:inherit;min-height:inherit;min-width:inherit;max-width:inherit}.mat-mdc-dialog-container .mdc-dialog__surface{display:block;width:100%;height:100%}.mat-mdc-dialog-container{outline:0}.mat-mdc-dialog-container .mdc-dialog__surface{background-color:var(--mdc-dialog-container-color, white)}.mat-mdc-dialog-container .mdc-dialog__surface{box-shadow:var(--mdc-dialog-container-elevation, 0px 11px 15px -7px rgba(0, 0, 0, 0.2), 0px 24px 38px 3px rgba(0, 0, 0, 0.14), 0px 9px 46px 8px rgba(0, 0, 0, 0.12))}.mat-mdc-dialog-container .mdc-dialog__surface{border-radius:var(--mdc-dialog-container-shape, var(--mdc-shape-medium, 4px))}.mat-mdc-dialog-container.mdc-dialog--scrollable .mdc-dialog__title,.mat-mdc-dialog-container.mdc-dialog--scrollable .mdc-dialog__actions,.mat-mdc-dialog-container.mdc-dialog--scrollable.mdc-dialog-scroll-divider-footer .mdc-dialog__actions{border-color:var(--mdc-dialog-with-divider-divider-color, black)}.mat-mdc-dialog-container.mdc-dialog--scrollable .mdc-dialog__title{border-bottom-color:var(--mdc-dialog-with-divider-divider-color, black)}.mat-mdc-dialog-container .mdc-dialog__title{font-family:var(--mdc-dialog-subhead-font, "Arial");line-height:var(--mdc-dialog-subhead-line-height, 14px);font-size:var(--mdc-dialog-subhead-size, 14px);font-weight:var(--mdc-dialog-subhead-weight, 500);letter-spacing:var(--mdc-dialog-subhead-tracking, 1px)}.mat-mdc-dialog-container .mdc-dialog__title{color:var(--mdc-dialog-subhead-color, black)}.mat-mdc-dialog-container .mdc-dialog__content{font-family:var(--mdc-dialog-supporting-text-font, "Arial");line-height:var(--mdc-dialog-supporting-text-line-height, 14px);font-size:var(--mdc-dialog-supporting-text-size, 14px);font-weight:var(--mdc-dialog-supporting-text-weight, 500);letter-spacing:var(--mdc-dialog-supporting-text-tracking, 1px)}.mat-mdc-dialog-container .mdc-dialog__content{color:var(--mdc-dialog-supporting-text-color, black)}.mat-mdc-dialog-container .mdc-dialog__container{transition-duration:var(--mat-dialog-transition-duration, 0ms)}.mat-mdc-dialog-container._mat-animation-noopable .mdc-dialog__container{transition:none}.mat-mdc-dialog-content{display:block}.mat-mdc-dialog-actions{justify-content:start}.mat-mdc-dialog-actions.mat-mdc-dialog-actions-align-center,.mat-mdc-dialog-actions[align=center]{justify-content:center}.mat-mdc-dialog-actions.mat-mdc-dialog-actions-align-end,.mat-mdc-dialog-actions[align=end]{justify-content:flex-end}.mat-mdc-dialog-actions .mat-button-base+.mat-button-base,.mat-mdc-dialog-actions .mat-mdc-button-base+.mat-mdc-button-base{margin-left:8px}[dir=rtl] .mat-mdc-dialog-actions .mat-button-base+.mat-button-base,[dir=rtl] .mat-mdc-dialog-actions .mat-mdc-button-base+.mat-mdc-button-base{margin-left:0;margin-right:8px}'],encapsulation:2}),n})(),Ed=class{constructor(t,e,i){this._ref=t,this._containerInstance=i,this._afterOpened=new Ie,this._beforeClosed=new Ie,this._state=0,this.disableClose=e.disableClose,this.id=t.id,i._animationStateChanged.pipe(ke(r=>"opened"===r.state),Yt(1)).subscribe(()=>{this._afterOpened.next(),this._afterOpened.complete()}),i._animationStateChanged.pipe(ke(r=>"closed"===r.state),Yt(1)).subscribe(()=>{clearTimeout(this._closeFallbackTimeout),this._finishDialogClose()}),t.overlayRef.detachments().subscribe(()=>{this._beforeClosed.next(this._result),this._beforeClosed.complete(),this._finishDialogClose()}),tn(this.backdropClick(),this.keydownEvents().pipe(ke(r=>27===r.keyCode&&!this.disableClose&&!vr(r)))).subscribe(r=>{this.disableClose||(r.preventDefault(),d9(this,"keydown"===r.type?"keyboard":"mouse"))})}close(t){this._result=t,this._containerInstance._animationStateChanged.pipe(ke(e=>"closing"===e.state),Yt(1)).subscribe(e=>{this._beforeClosed.next(t),this._beforeClosed.complete(),this._ref.overlayRef.detachBackdrop(),this._closeFallbackTimeout=setTimeout(()=>this._finishDialogClose(),e.totalTime+100)}),this._state=1,this._containerInstance._startExitAnimation()}afterOpened(){return this._afterOpened}afterClosed(){return this._ref.closed}beforeClosed(){return this._beforeClosed}backdropClick(){return this._ref.backdropClick}keydownEvents(){return this._ref.keydownEvents}updatePosition(t){let e=this._ref.config.positionStrategy;return t&&(t.left||t.right)?t.left?e.left(t.left):e.right(t.right):e.centerHorizontally(),t&&(t.top||t.bottom)?t.top?e.top(t.top):e.bottom(t.bottom):e.centerVertically(),this._ref.updatePosition(),this}updateSize(t="",e=""){return this._ref.updateSize(t,e),this}addPanelClass(t){return this._ref.addPanelClass(t),this}removePanelClass(t){return this._ref.removePanelClass(t),this}getState(){return this._state}_finishDialogClose(){this._state=2,this._ref.close(this._result,{focusOrigin:this._closeInteractionType}),this.componentInstance=null}};function d9(n,t,e){return n._closeInteractionType=t,n.close(e)}var Xv=new ie("MatMdcDialogData"),Pbe=new ie("mat-mdc-dialog-default-options"),u9=new ie("mat-mdc-dialog-scroll-strategy"),kbe={provide:u9,deps:[zi],useFactory:function(n){return()=>n.scrollStrategies.block()}},Fbe=0,Nbe=(()=>{class n{get openDialogs(){return this._parentDialog?this._parentDialog.openDialogs:this._openDialogsAtThisLevel}get afterOpened(){return this._parentDialog?this._parentDialog.afterOpened:this._afterOpenedAtThisLevel}_getAfterAllClosed(){let e=this._parentDialog;return e?e._getAfterAllClosed():this._afterAllClosedAtThisLevel}constructor(e,i,r,o,s,a,l,c,d,u){this._overlay=e,this._defaultOptions=r,this._parentDialog=o,this._dialogRefConstructor=l,this._dialogContainerType=c,this._dialogDataToken=d,this._openDialogsAtThisLevel=[],this._afterAllClosedAtThisLevel=new Ie,this._afterOpenedAtThisLevel=new Ie,this._idPrefix="mat-dialog-",this.dialogConfigClass=mg,this.afterAllClosed=ta(()=>this.openDialogs.length?this._getAfterAllClosed():this._getAfterAllClosed().pipe(qn(void 0))),this._scrollStrategy=a,this._dialog=i.get(N2)}open(e,i){let r;(i={...this._defaultOptions||new mg,...i}).id=i.id||`${this._idPrefix}${Fbe++}`,i.scrollStrategy=i.scrollStrategy||this._scrollStrategy();let o=this._dialog.open(e,{...i,positionStrategy:this._overlay.position().global().centerHorizontally().centerVertically(),disableClose:!0,closeOnDestroy:!1,closeOnOverlayDetachments:!1,container:{type:this._dialogContainerType,providers:()=>[{provide:this.dialogConfigClass,useValue:i},{provide:Mf,useValue:i}]},templateContext:()=>({dialogRef:r}),providers:(s,a,l)=>(r=new this._dialogRefConstructor(s,i,l),r.updatePosition(i?.position),[{provide:this._dialogContainerType,useValue:l},{provide:this._dialogDataToken,useValue:a.data},{provide:this._dialogRefConstructor,useValue:r}])});return r.componentInstance=o.componentInstance,this.openDialogs.push(r),this.afterOpened.next(r),r.afterClosed().subscribe(()=>{let s=this.openDialogs.indexOf(r);s>-1&&(this.openDialogs.splice(s,1),this.openDialogs.length||this._getAfterAllClosed().next())}),r}closeAll(){this._closeDialogs(this.openDialogs)}getDialogById(e){return this.openDialogs.find(i=>i.id===e)}ngOnDestroy(){this._closeDialogs(this._openDialogsAtThisLevel),this._afterAllClosedAtThisLevel.complete(),this._afterOpenedAtThisLevel.complete()}_closeDialogs(e){let i=e.length;for(;i--;)e[i].close()}}return n.\u0275fac=function(e){Is()},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),zl=(()=>{class n extends Nbe{constructor(e,i,r,o,s,a,l,c){super(e,i,o,a,l,s,Ed,Rbe,Xv,c),this._idPrefix="mat-mdc-dialog-"}}return n.\u0275fac=function(e){return new(e||n)(k(zi),k(Mi),k(wb,8),k(Pbe,8),k(u9),k(n,12),k(pg),k(hi,8))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),Lbe=0,Z1=(()=>{class n{constructor(e,i,r){this.dialogRef=e,this._elementRef=i,this._dialog=r,this.type="button"}ngOnInit(){this.dialogRef||(this.dialogRef=f9(this._elementRef,this._dialog.openDialogs))}ngOnChanges(e){let i=e._matDialogClose||e._matDialogCloseResult;i&&(this.dialogResult=i.currentValue)}_onButtonClick(e){d9(this.dialogRef,0===e.screenX&&0===e.screenY?"keyboard":"mouse",this.dialogResult)}}return n.\u0275fac=function(e){return new(e||n)(C(Ed,8),C(Me),C(zl))},n.\u0275dir=we({type:n,selectors:[["","mat-dialog-close",""],["","matDialogClose",""]],hostVars:2,hostBindings:function(e,i){1&e&&I("click",function(o){return i._onButtonClick(o)}),2&e&&Be("aria-label",i.ariaLabel||null)("type",i.type)},inputs:{ariaLabel:["aria-label","ariaLabel"],type:"type",dialogResult:["mat-dialog-close","dialogResult"],_matDialogClose:["matDialogClose","_matDialogClose"]},exportAs:["matDialogClose"],features:[Gt]}),n})(),p9=(()=>{class n{constructor(e,i,r){this._dialogRef=e,this._elementRef=i,this._dialog=r,this.id="mat-mdc-dialog-title-"+Lbe++}ngOnInit(){this._dialogRef||(this._dialogRef=f9(this._elementRef,this._dialog.openDialogs)),this._dialogRef&&Promise.resolve().then(()=>{let e=this._dialogRef._containerInstance;e&&!e._ariaLabelledBy&&(e._ariaLabelledBy=this.id)})}}return n.\u0275fac=function(e){return new(e||n)(C(Ed,8),C(Me),C(zl))},n.\u0275dir=we({type:n,selectors:[["","mat-dialog-title",""],["","matDialogTitle",""]],hostAttrs:[1,"mat-mdc-dialog-title","mdc-dialog__title"],hostVars:1,hostBindings:function(e,i){2&e&&jo("id",i.id)},inputs:{id:"id"},exportAs:["matDialogTitle"]}),n})(),K1=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275dir=we({type:n,selectors:[["","mat-dialog-content",""],["mat-dialog-content"],["","matDialogContent",""]],hostAttrs:[1,"mat-mdc-dialog-content","mdc-dialog__content"]}),n})(),J1=(()=>{class n{constructor(){this.align="start"}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275dir=we({type:n,selectors:[["","mat-dialog-actions",""],["mat-dialog-actions"],["","matDialogActions",""]],hostAttrs:[1,"mat-mdc-dialog-actions","mdc-dialog__actions"],hostVars:4,hostBindings:function(e,i){2&e&&nt("mat-mdc-dialog-actions-align-center","center"===i.align)("mat-mdc-dialog-actions-align-end","end"===i.align)},inputs:{align:"align"}}),n})();function f9(n,t){let e=n.nativeElement.parentElement;for(;e&&!e.classList.contains("mat-mdc-dialog-container");)e=e.parentElement;return e?t.find(i=>i.id===e.id):null}var hg=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({providers:[zl,kbe],imports:[r9,Co,Hl,fn,fn]}),n})(),c9={params:{enterAnimationDuration:"150ms",exitAnimationDuration:"75ms"}},Bbe=(_r("dialogContainer",[wi("void, exit",rn({opacity:0,transform:"scale(0.7)"})),wi("enter",rn({transform:"none"})),gi("* => enter",Ob([Ci("{{enterAnimationDuration}} cubic-bezier(0, 0, 0.2, 1)",rn({transform:"none",opacity:1})),Jp("@*",Kp(),{optional:!0})]),c9),gi("* => void, * => exit",Ob([Ci("{{exitAnimationDuration}} cubic-bezier(0.4, 0.0, 0.2, 1)",rn({opacity:0})),Jp("@*",Kp(),{optional:!0})]),c9)]),["matFormFieldNotchedOutline",""]),Vbe=["*"],Hbe=["textField"],zbe=["iconPrefixContainer"],Ube=["textPrefixContainer"];function jbe(n,t){1&n&&P(0,"span",19)}function Gbe(n,t){if(1&n){let e=ge();h(0,"label",17),I("cdkObserveContent",function(){return X(e),Q(w(2)._refreshOutlineNotchWidth())}),zt(1,1),S(2,jbe,1,0,"span",18),g()}if(2&n){let e=w(2);_("floating",e._shouldLabelFloat())("cdkObserveContentDisabled",!e._hasOutline())("id",e._labelId),Be("for",e._control.id)("aria-owns",e._control.id),v(2),_("ngIf",!e.hideRequiredMarker&&e._control.required)}}function Wbe(n,t){1&n&&S(0,Gbe,3,6,"label",16),2&n&&_("ngIf",w()._hasFloatingLabel())}function qbe(n,t){1&n&&P(0,"div",20)}function Ybe(n,t){}function Xbe(n,t){1&n&&S(0,Ybe,0,0,"ng-template",22),2&n&&(w(2),_("ngTemplateOutlet",it(1)))}function Qbe(n,t){if(1&n&&(h(0,"div",21),S(1,Xbe,1,1,"ng-template",9),g()),2&n){let e=w();_("matFormFieldNotchedOutlineOpen",e._shouldLabelFloat())("matFormFieldNotchedOutlineLabelWidth",e._labelWidth),v(1),_("ngIf",!e._forceDisplayInfixLabel())}}function Zbe(n,t){1&n&&(h(0,"div",23,24),zt(2,2),g())}function Kbe(n,t){1&n&&(h(0,"div",25,26),zt(2,3),g())}function Jbe(n,t){}function $be(n,t){1&n&&S(0,Jbe,0,0,"ng-template",22),2&n&&(w(),_("ngTemplateOutlet",it(1)))}function eve(n,t){1&n&&(h(0,"div",27),zt(1,4),g())}function tve(n,t){1&n&&(h(0,"div",28),zt(1,5),g())}function nve(n,t){1&n&&P(0,"div",29)}function ive(n,t){1&n&&(h(0,"div",30),zt(1,6),g()),2&n&&_("@transitionMessages",w()._subscriptAnimationState)}function rve(n,t){if(1&n&&(h(0,"mat-hint",34),T(1),g()),2&n){let e=w(2);_("id",e._hintLabelId),v(1),bt(e.hintLabel)}}function ove(n,t){if(1&n&&(h(0,"div",31),S(1,rve,2,2,"mat-hint",32),zt(2,7),P(3,"div",33),zt(4,8),g()),2&n){let e=w();_("@transitionMessages",e._subscriptAnimationState),v(1),_("ngIf",e.hintLabel)}}var sve=["*",[["mat-label"]],[["","matPrefix",""],["","matIconPrefix",""]],[["","matTextPrefix",""]],[["","matTextSuffix",""]],[["","matSuffix",""],["","matIconSuffix",""]],[["mat-error"],["","matError",""]],[["mat-hint",3,"align","end"]],[["mat-hint","align","end"]]],ave=["*","mat-label","[matPrefix], [matIconPrefix]","[matTextPrefix]","[matTextSuffix]","[matSuffix], [matIconSuffix]","mat-error, [matError]","mat-hint:not([align='end'])","mat-hint[align='end']"],kc=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275dir=we({type:n,selectors:[["mat-label"]]}),n})(),lve=0,C9=new ie("MatError"),M9=(()=>{class n{constructor(e,i){this.id="mat-mdc-error-"+lve++,e||i.nativeElement.setAttribute("aria-live","polite")}}return n.\u0275fac=function(e){return new(e||n)(yo("aria-live"),C(Me))},n.\u0275dir=we({type:n,selectors:[["mat-error"],["","matError",""]],hostAttrs:["aria-atomic","true",1,"mat-mdc-form-field-error","mat-mdc-form-field-bottom-align"],hostVars:1,hostBindings:function(e,i){2&e&&jo("id",i.id)},inputs:{id:"id"},features:[Qt([{provide:C9,useExisting:n}])]}),n})(),cve=0,m9=(()=>{class n{constructor(){this.align="start",this.id="mat-mdc-hint-"+cve++}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275dir=we({type:n,selectors:[["mat-hint"]],hostAttrs:[1,"mat-mdc-form-field-hint","mat-mdc-form-field-bottom-align"],hostVars:4,hostBindings:function(e,i){2&e&&(jo("id",i.id),Be("align",null),nt("mat-mdc-form-field-hint-end","end"===i.align))},inputs:{align:"align",id:"id"}}),n})(),w9=new ie("MatPrefix"),S9=(()=>{class n{constructor(){this._isText=!1}set _isTextSelector(e){this._isText=!0}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275dir=we({type:n,selectors:[["","matPrefix",""],["","matIconPrefix",""],["","matTextPrefix",""]],inputs:{_isTextSelector:["matTextPrefix","_isTextSelector"]},features:[Qt([{provide:w9,useExisting:n}])]}),n})(),dve=new ie("MatSuffix"),h9=(()=>{class n{constructor(e){this._elementRef=e,this.floating=!1}getWidth(){return function(n){if(null!==n.offsetParent)return n.scrollWidth;let e=n.cloneNode(!0);e.style.setProperty("position","absolute"),e.style.setProperty("transform","translate(-9999px, -9999px)"),document.documentElement.appendChild(e);let i=e.scrollWidth;return e.remove(),i}(this._elementRef.nativeElement)}get element(){return this._elementRef.nativeElement}}return n.\u0275fac=function(e){return new(e||n)(C(Me))},n.\u0275dir=we({type:n,selectors:[["label","matFormFieldFloatingLabel",""]],hostAttrs:[1,"mdc-floating-label","mat-mdc-floating-label"],hostVars:2,hostBindings:function(e,i){2&e&&nt("mdc-floating-label--float-above",i.floating)},inputs:{floating:"floating"}}),n})(),g9="mdc-line-ripple--active",$1="mdc-line-ripple--deactivating",_9=(()=>{class n{constructor(e,i){this._elementRef=e,this._handleTransitionEnd=r=>{let o=this._elementRef.nativeElement.classList,s=o.contains($1);"opacity"===r.propertyName&&s&&o.remove(g9,$1)},i.runOutsideAngular(()=>{e.nativeElement.addEventListener("transitionend",this._handleTransitionEnd)})}activate(){let e=this._elementRef.nativeElement.classList;e.remove($1),e.add(g9)}deactivate(){this._elementRef.nativeElement.classList.add($1)}ngOnDestroy(){this._elementRef.nativeElement.removeEventListener("transitionend",this._handleTransitionEnd)}}return n.\u0275fac=function(e){return new(e||n)(C(Me),C(at))},n.\u0275dir=we({type:n,selectors:[["div","matFormFieldLineRipple",""]],hostAttrs:[1,"mdc-line-ripple"]}),n})(),b9=(()=>{class n{constructor(e,i){this._elementRef=e,this._ngZone=i,this.labelWidth=0,this.open=!1}ngAfterViewInit(){let e=this._elementRef.nativeElement.querySelector(".mdc-floating-label");e?(this._elementRef.nativeElement.classList.add("mdc-notched-outline--upgraded"),"function"==typeof requestAnimationFrame&&(e.style.transitionDuration="0s",this._ngZone.runOutsideAngular(()=>{requestAnimationFrame(()=>e.style.transitionDuration="")}))):this._elementRef.nativeElement.classList.add("mdc-notched-outline--no-label")}_getNotchWidth(){return this.open?this.labelWidth>0?`calc(${this.labelWidth}px * var(--mat-mdc-form-field-floating-label-scale, 0.75) + 9px)`:"0px":null}}return n.\u0275fac=function(e){return new(e||n)(C(Me),C(at))},n.\u0275cmp=O({type:n,selectors:[["div","matFormFieldNotchedOutline",""]],hostAttrs:[1,"mdc-notched-outline"],hostVars:2,hostBindings:function(e,i){2&e&&nt("mdc-notched-outline--notched",i.open)},inputs:{labelWidth:["matFormFieldNotchedOutlineLabelWidth","labelWidth"],open:["matFormFieldNotchedOutlineOpen","open"]},attrs:Bbe,ngContentSelectors:Vbe,decls:4,vars:2,consts:[[1,"mdc-notched-outline__leading"],[1,"mdc-notched-outline__notch"],[1,"mdc-notched-outline__trailing"]],template:function(e,i){1&e&&(Dn(),P(0,"div",0),h(1,"div",1),zt(2),g(),P(3,"div",2)),2&e&&(v(1),Tt("width",i._getNotchWidth()))},encapsulation:2,changeDetection:0}),n})(),pve={transitionMessages:_r("transitionMessages",[wi("enter",rn({opacity:1,transform:"translateY(0%)"})),gi("void => enter",[rn({opacity:0,transform:"translateY(-5px)"}),Ci("300ms cubic-bezier(0.55, 0, 0.55, 0.2)")])])},Qv=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275dir=we({type:n}),n})(),Sf=new ie("MatFormField"),fve=new ie("MAT_FORM_FIELD_DEFAULT_OPTIONS"),v9=0,Ka=(()=>{class n{get hideRequiredMarker(){return this._hideRequiredMarker}set hideRequiredMarker(e){this._hideRequiredMarker=Rt(e)}get floatLabel(){return this._floatLabel||this._defaults?.floatLabel||"auto"}set floatLabel(e){e!==this._floatLabel&&(this._floatLabel=e,this._changeDetectorRef.markForCheck())}get appearance(){return this._appearance}set appearance(e){let i=this._appearance;this._appearance=e||this._defaults?.appearance||"fill","outline"===this._appearance&&this._appearance!==i&&(this._refreshOutlineNotchWidth(),this._needsOutlineLabelOffsetUpdateOnStable=!0)}get subscriptSizing(){return this._subscriptSizing||this._defaults?.subscriptSizing||"fixed"}set subscriptSizing(e){this._subscriptSizing=e||this._defaults?.subscriptSizing||"fixed"}get hintLabel(){return this._hintLabel}set hintLabel(e){this._hintLabel=e,this._processHints()}get _control(){return this._explicitFormFieldControl||this._formFieldControl}set _control(e){this._explicitFormFieldControl=e}constructor(e,i,r,o,s,a,l,c){this._elementRef=e,this._changeDetectorRef=i,this._ngZone=r,this._dir=o,this._platform=s,this._defaults=a,this._animationMode=l,this._document=c,this._hideRequiredMarker=!1,this.color="primary",this._appearance="fill",this._subscriptSizing=null,this._hintLabel="",this._hasIconPrefix=!1,this._hasTextPrefix=!1,this._hasIconSuffix=!1,this._hasTextSuffix=!1,this._labelId="mat-mdc-form-field-label-"+v9++,this._hintLabelId="mat-mdc-hint-"+v9++,this._subscriptAnimationState="",this._labelWidth=0,this._destroyed=new Ie,this._isFocused=null,this._needsOutlineLabelOffsetUpdateOnStable=!1,a&&(a.appearance&&(this.appearance=a.appearance),this._hideRequiredMarker=Boolean(a?.hideRequiredMarker),a.color&&(this.color=a.color))}ngAfterViewInit(){this._updateFocusState(),this._refreshOutlineNotchWidth(),this._document?.fonts?.ready?this._document.fonts.ready.then(()=>{this._refreshOutlineNotchWidth(),this._changeDetectorRef.markForCheck()}):setTimeout(()=>this._refreshOutlineNotchWidth(),100),this._subscriptAnimationState="enter",this._changeDetectorRef.detectChanges()}ngAfterContentInit(){this._assertFormFieldControl(),this._initializeControl(),this._initializeSubscript(),this._initializePrefixAndSuffix(),this._initializeOutlineLabelOffsetSubscriptions()}ngAfterContentChecked(){this._assertFormFieldControl()}ngOnDestroy(){this._destroyed.next(),this._destroyed.complete()}getLabelId(){return this._hasFloatingLabel()?this._labelId:null}getConnectedOverlayOrigin(){return this._textField||this._elementRef}_animateAndLockLabel(){this._hasFloatingLabel()&&(this.floatLabel="always")}_initializeControl(){let e=this._control;e.controlType&&this._elementRef.nativeElement.classList.add(`mat-mdc-form-field-type-${e.controlType}`),e.stateChanges.subscribe(()=>{this._updateFocusState(),this._syncDescribedByIds(),this._changeDetectorRef.markForCheck()}),e.ngControl&&e.ngControl.valueChanges&&e.ngControl.valueChanges.pipe(ot(this._destroyed)).subscribe(()=>this._changeDetectorRef.markForCheck())}_checkPrefixAndSuffixTypes(){this._hasIconPrefix=!!this._prefixChildren.find(e=>!e._isText),this._hasTextPrefix=!!this._prefixChildren.find(e=>e._isText),this._hasIconSuffix=!!this._suffixChildren.find(e=>!e._isText),this._hasTextSuffix=!!this._suffixChildren.find(e=>e._isText)}_initializePrefixAndSuffix(){this._checkPrefixAndSuffixTypes(),tn(this._prefixChildren.changes,this._suffixChildren.changes).subscribe(()=>{this._checkPrefixAndSuffixTypes(),this._changeDetectorRef.markForCheck()})}_initializeSubscript(){this._hintChildren.changes.subscribe(()=>{this._processHints(),this._changeDetectorRef.markForCheck()}),this._errorChildren.changes.subscribe(()=>{this._syncDescribedByIds(),this._changeDetectorRef.markForCheck()}),this._validateHints(),this._syncDescribedByIds()}_assertFormFieldControl(){}_updateFocusState(){this._control.focused&&!this._isFocused?(this._isFocused=!0,this._lineRipple?.activate()):!this._control.focused&&(this._isFocused||null===this._isFocused)&&(this._isFocused=!1,this._lineRipple?.deactivate()),this._textField?.nativeElement.classList.toggle("mdc-text-field--focused",this._control.focused)}_initializeOutlineLabelOffsetSubscriptions(){this._prefixChildren.changes.subscribe(()=>this._needsOutlineLabelOffsetUpdateOnStable=!0),this._ngZone.runOutsideAngular(()=>{this._ngZone.onStable.pipe(ot(this._destroyed)).subscribe(()=>{this._needsOutlineLabelOffsetUpdateOnStable&&(this._needsOutlineLabelOffsetUpdateOnStable=!1,this._updateOutlineLabelOffset())})}),this._dir.change.pipe(ot(this._destroyed)).subscribe(()=>this._needsOutlineLabelOffsetUpdateOnStable=!0)}_shouldAlwaysFloat(){return"always"===this.floatLabel}_hasOutline(){return"outline"===this.appearance}_forceDisplayInfixLabel(){return!this._platform.isBrowser&&this._prefixChildren.length&&!this._shouldLabelFloat()}_hasFloatingLabel(){return!!this._labelChildNonStatic||!!this._labelChildStatic}_shouldLabelFloat(){return this._control.shouldLabelFloat||this._shouldAlwaysFloat()}_shouldForward(e){let i=this._control?this._control.ngControl:null;return i&&i[e]}_getDisplayedMessages(){return this._errorChildren&&this._errorChildren.length>0&&this._control.errorState?"error":"hint"}_refreshOutlineNotchWidth(){!this._hasOutline()||!this._floatingLabel||(this._labelWidth=this._floatingLabel.getWidth())}_processHints(){this._validateHints(),this._syncDescribedByIds()}_validateHints(){}_syncDescribedByIds(){if(this._control){let e=[];if(this._control.userAriaDescribedBy&&"string"==typeof this._control.userAriaDescribedBy&&e.push(...this._control.userAriaDescribedBy.split(" ")),"hint"===this._getDisplayedMessages()){let i=this._hintChildren?this._hintChildren.find(o=>"start"===o.align):null,r=this._hintChildren?this._hintChildren.find(o=>"end"===o.align):null;i?e.push(i.id):this._hintLabel&&e.push(this._hintLabelId),r&&e.push(r.id)}else this._errorChildren&&e.push(...this._errorChildren.map(i=>i.id));this._control.setDescribedByIds(e)}}_updateOutlineLabelOffset(){if(!this._platform.isBrowser||!this._hasOutline()||!this._floatingLabel)return;let e=this._floatingLabel.element;if(!this._iconPrefixContainer&&!this._textPrefixContainer)return void(e.style.transform="");if(!this._isAttachedToDom())return void(this._needsOutlineLabelOffsetUpdateOnStable=!0);let i=this._iconPrefixContainer?.nativeElement,r=this._textPrefixContainer?.nativeElement,o=i?.getBoundingClientRect().width??0,s=r?.getBoundingClientRect().width??0;e.style.transform=`var(\n        --mat-mdc-form-field-label-transform,\n        translateY(-50%) translateX(calc(${"rtl"===this._dir.value?"-1":"1"} * (${o+s}px + var(--mat-mdc-form-field-label-offset-x, 0px))))\n    )`}_isAttachedToDom(){let e=this._elementRef.nativeElement;if(e.getRootNode){let i=e.getRootNode();return i&&i!==e}return document.documentElement.contains(e)}}return n.\u0275fac=function(e){return new(e||n)(C(Me),C($t),C(at),C(Xi),C(Gn),C(fve,8),C(hi,8),C(Lt))},n.\u0275cmp=O({type:n,selectors:[["mat-form-field"]],contentQueries:function(e,i,r){if(1&e&&(Ti(r,kc,5),Ti(r,kc,7),Ti(r,Qv,5),Ti(r,w9,5),Ti(r,dve,5),Ti(r,C9,5),Ti(r,m9,5)),2&e){let o;Se(o=Ee())&&(i._labelChildNonStatic=o.first),Se(o=Ee())&&(i._labelChildStatic=o.first),Se(o=Ee())&&(i._formFieldControl=o.first),Se(o=Ee())&&(i._prefixChildren=o),Se(o=Ee())&&(i._suffixChildren=o),Se(o=Ee())&&(i._errorChildren=o),Se(o=Ee())&&(i._hintChildren=o)}},viewQuery:function(e,i){if(1&e&&(Ge(Hbe,5),Ge(zbe,5),Ge(Ube,5),Ge(h9,5),Ge(b9,5),Ge(_9,5)),2&e){let r;Se(r=Ee())&&(i._textField=r.first),Se(r=Ee())&&(i._iconPrefixContainer=r.first),Se(r=Ee())&&(i._textPrefixContainer=r.first),Se(r=Ee())&&(i._floatingLabel=r.first),Se(r=Ee())&&(i._notchedOutline=r.first),Se(r=Ee())&&(i._lineRipple=r.first)}},hostAttrs:[1,"mat-mdc-form-field"],hostVars:42,hostBindings:function(e,i){2&e&&nt("mat-mdc-form-field-label-always-float",i._shouldAlwaysFloat())("mat-mdc-form-field-has-icon-prefix",i._hasIconPrefix)("mat-mdc-form-field-has-icon-suffix",i._hasIconSuffix)("mat-form-field-invalid",i._control.errorState)("mat-form-field-disabled",i._control.disabled)("mat-form-field-autofilled",i._control.autofilled)("mat-form-field-no-animations","NoopAnimations"===i._animationMode)("mat-form-field-appearance-fill","fill"==i.appearance)("mat-form-field-appearance-outline","outline"==i.appearance)("mat-form-field-hide-placeholder",i._hasFloatingLabel()&&!i._shouldLabelFloat())("mat-focused",i._control.focused)("mat-primary","accent"!==i.color&&"warn"!==i.color)("mat-accent","accent"===i.color)("mat-warn","warn"===i.color)("ng-untouched",i._shouldForward("untouched"))("ng-touched",i._shouldForward("touched"))("ng-pristine",i._shouldForward("pristine"))("ng-dirty",i._shouldForward("dirty"))("ng-valid",i._shouldForward("valid"))("ng-invalid",i._shouldForward("invalid"))("ng-pending",i._shouldForward("pending"))},inputs:{hideRequiredMarker:"hideRequiredMarker",color:"color",floatLabel:"floatLabel",appearance:"appearance",subscriptSizing:"subscriptSizing",hintLabel:"hintLabel"},exportAs:["matFormField"],features:[Qt([{provide:Sf,useExisting:n}])],ngContentSelectors:ave,decls:18,vars:23,consts:[["labelTemplate",""],[1,"mat-mdc-text-field-wrapper","mdc-text-field",3,"click"],["textField",""],["class","mat-mdc-form-field-focus-overlay",4,"ngIf"],[1,"mat-mdc-form-field-flex"],["matFormFieldNotchedOutline","",3,"matFormFieldNotchedOutlineOpen","matFormFieldNotchedOutlineLabelWidth",4,"ngIf"],["class","mat-mdc-form-field-icon-prefix",4,"ngIf"],["class","mat-mdc-form-field-text-prefix",4,"ngIf"],[1,"mat-mdc-form-field-infix"],[3,"ngIf"],["class","mat-mdc-form-field-text-suffix",4,"ngIf"],["class","mat-mdc-form-field-icon-suffix",4,"ngIf"],["matFormFieldLineRipple","",4,"ngIf"],[1,"mat-mdc-form-field-subscript-wrapper","mat-mdc-form-field-bottom-align",3,"ngSwitch"],["class","mat-mdc-form-field-error-wrapper",4,"ngSwitchCase"],["class","mat-mdc-form-field-hint-wrapper",4,"ngSwitchCase"],["matFormFieldFloatingLabel","",3,"floating","cdkObserveContentDisabled","id","cdkObserveContent",4,"ngIf"],["matFormFieldFloatingLabel","",3,"floating","cdkObserveContentDisabled","id","cdkObserveContent"],["aria-hidden","true","class","mat-mdc-form-field-required-marker mdc-floating-label--required",4,"ngIf"],["aria-hidden","true",1,"mat-mdc-form-field-required-marker","mdc-floating-label--required"],[1,"mat-mdc-form-field-focus-overlay"],["matFormFieldNotchedOutline","",3,"matFormFieldNotchedOutlineOpen","matFormFieldNotchedOutlineLabelWidth"],[3,"ngTemplateOutlet"],[1,"mat-mdc-form-field-icon-prefix"],["iconPrefixContainer",""],[1,"mat-mdc-form-field-text-prefix"],["textPrefixContainer",""],[1,"mat-mdc-form-field-text-suffix"],[1,"mat-mdc-form-field-icon-suffix"],["matFormFieldLineRipple",""],[1,"mat-mdc-form-field-error-wrapper"],[1,"mat-mdc-form-field-hint-wrapper"],[3,"id",4,"ngIf"],[1,"mat-mdc-form-field-hint-spacer"],[3,"id"]],template:function(e,i){1&e&&(Dn(sve),S(0,Wbe,1,1,"ng-template",null,0,Wt),h(2,"div",1,2),I("click",function(o){return i._control.onContainerClick&&i._control.onContainerClick(o)}),S(4,qbe,1,0,"div",3),h(5,"div",4),S(6,Qbe,2,3,"div",5),S(7,Zbe,3,0,"div",6),S(8,Kbe,3,0,"div",7),h(9,"div",8),S(10,$be,1,1,"ng-template",9),zt(11),g(),S(12,eve,2,0,"div",10),S(13,tve,2,0,"div",11),g(),S(14,nve,1,0,"div",12),g(),h(15,"div",13),S(16,ive,2,1,"div",14),S(17,ove,5,2,"div",15),g()),2&e&&(v(2),nt("mdc-text-field--filled",!i._hasOutline())("mdc-text-field--outlined",i._hasOutline())("mdc-text-field--no-label",!i._hasFloatingLabel())("mdc-text-field--disabled",i._control.disabled)("mdc-text-field--invalid",i._control.errorState),v(2),_("ngIf",!i._hasOutline()&&!i._control.disabled),v(2),_("ngIf",i._hasOutline()),v(1),_("ngIf",i._hasIconPrefix),v(1),_("ngIf",i._hasTextPrefix),v(2),_("ngIf",!i._hasOutline()||i._forceDisplayInfixLabel()),v(2),_("ngIf",i._hasTextSuffix),v(1),_("ngIf",i._hasIconSuffix),v(1),_("ngIf",!i._hasOutline()),v(1),nt("mat-mdc-form-field-subscript-dynamic-size","dynamic"===i.subscriptSizing),_("ngSwitch",i._getDisplayedMessages()),v(1),_("ngSwitchCase","error"),v(1),_("ngSwitchCase","hint"))},dependencies:[Fe,Lr,sr,Sr,P1,m9,h9,b9,_9],styles:['.mdc-text-field{border-top-left-radius:var(--mdc-shape-small, 4px);border-top-right-radius:var(--mdc-shape-small, 4px);border-bottom-right-radius:0;border-bottom-left-radius:0;display:inline-flex;align-items:baseline;padding:0 16px;position:relative;box-sizing:border-box;overflow:hidden;will-change:opacity,transform,color}.mdc-text-field .mdc-floating-label{top:50%;transform:translateY(-50%);pointer-events:none}.mdc-text-field__input{height:28px;width:100%;min-width:0;border:none;border-radius:0;background:none;appearance:none;padding:0}.mdc-text-field__input::-ms-clear{display:none}.mdc-text-field__input::-webkit-calendar-picker-indicator{display:none}.mdc-text-field__input:focus{outline:none}.mdc-text-field__input:invalid{box-shadow:none}@media all{.mdc-text-field__input::placeholder{opacity:0}}@media all{.mdc-text-field__input:-ms-input-placeholder{opacity:0}}@media all{.mdc-text-field--no-label .mdc-text-field__input::placeholder,.mdc-text-field--focused .mdc-text-field__input::placeholder{opacity:1}}@media all{.mdc-text-field--no-label .mdc-text-field__input:-ms-input-placeholder,.mdc-text-field--focused .mdc-text-field__input:-ms-input-placeholder{opacity:1}}.mdc-text-field__affix{height:28px;opacity:0;white-space:nowrap}.mdc-text-field--label-floating .mdc-text-field__affix,.mdc-text-field--no-label .mdc-text-field__affix{opacity:1}@supports(-webkit-hyphens: none){.mdc-text-field--outlined .mdc-text-field__affix{align-items:center;align-self:center;display:inline-flex;height:100%}}.mdc-text-field__affix--prefix{padding-left:0;padding-right:2px}[dir=rtl] .mdc-text-field__affix--prefix,.mdc-text-field__affix--prefix[dir=rtl]{padding-left:2px;padding-right:0}.mdc-text-field--end-aligned .mdc-text-field__affix--prefix{padding-left:0;padding-right:12px}[dir=rtl] .mdc-text-field--end-aligned .mdc-text-field__affix--prefix,.mdc-text-field--end-aligned .mdc-text-field__affix--prefix[dir=rtl]{padding-left:12px;padding-right:0}.mdc-text-field__affix--suffix{padding-left:12px;padding-right:0}[dir=rtl] .mdc-text-field__affix--suffix,.mdc-text-field__affix--suffix[dir=rtl]{padding-left:0;padding-right:12px}.mdc-text-field--end-aligned .mdc-text-field__affix--suffix{padding-left:2px;padding-right:0}[dir=rtl] .mdc-text-field--end-aligned .mdc-text-field__affix--suffix,.mdc-text-field--end-aligned .mdc-text-field__affix--suffix[dir=rtl]{padding-left:0;padding-right:2px}.mdc-text-field--filled{height:56px}.mdc-text-field--filled::before{display:inline-block;width:0;height:40px;content:"";vertical-align:0}.mdc-text-field--filled .mdc-floating-label{left:16px;right:initial}[dir=rtl] .mdc-text-field--filled .mdc-floating-label,.mdc-text-field--filled .mdc-floating-label[dir=rtl]{left:initial;right:16px}.mdc-text-field--filled .mdc-floating-label--float-above{transform:translateY(-106%) scale(0.75)}.mdc-text-field--filled.mdc-text-field--no-label .mdc-text-field__input{height:100%}.mdc-text-field--filled.mdc-text-field--no-label .mdc-floating-label{display:none}.mdc-text-field--filled.mdc-text-field--no-label::before{display:none}@supports(-webkit-hyphens: none){.mdc-text-field--filled.mdc-text-field--no-label .mdc-text-field__affix{align-items:center;align-self:center;display:inline-flex;height:100%}}.mdc-text-field--outlined{height:56px;overflow:visible}.mdc-text-field--outlined .mdc-floating-label--float-above{transform:translateY(-37.25px) scale(1)}.mdc-text-field--outlined .mdc-floating-label--float-above{font-size:.75rem}.mdc-text-field--outlined.mdc-notched-outline--upgraded .mdc-floating-label--float-above,.mdc-text-field--outlined .mdc-notched-outline--upgraded .mdc-floating-label--float-above{transform:translateY(-34.75px) scale(0.75)}.mdc-text-field--outlined.mdc-notched-outline--upgraded .mdc-floating-label--float-above,.mdc-text-field--outlined .mdc-notched-outline--upgraded .mdc-floating-label--float-above{font-size:1rem}.mdc-text-field--outlined .mdc-text-field__input{height:100%}.mdc-text-field--outlined .mdc-notched-outline .mdc-notched-outline__leading{border-top-left-radius:var(--mdc-shape-small, 4px);border-top-right-radius:0;border-bottom-right-radius:0;border-bottom-left-radius:var(--mdc-shape-small, 4px)}[dir=rtl] .mdc-text-field--outlined .mdc-notched-outline .mdc-notched-outline__leading,.mdc-text-field--outlined .mdc-notched-outline .mdc-notched-outline__leading[dir=rtl]{border-top-left-radius:0;border-top-right-radius:var(--mdc-shape-small, 4px);border-bottom-right-radius:var(--mdc-shape-small, 4px);border-bottom-left-radius:0}@supports(top: max(0%)){.mdc-text-field--outlined .mdc-notched-outline .mdc-notched-outline__leading{width:max(12px, var(--mdc-shape-small, 4px))}}@supports(top: max(0%)){.mdc-text-field--outlined .mdc-notched-outline .mdc-notched-outline__notch{max-width:calc(100% - max(12px, var(--mdc-shape-small, 4px))*2)}}.mdc-text-field--outlined .mdc-notched-outline .mdc-notched-outline__trailing{border-top-left-radius:0;border-top-right-radius:var(--mdc-shape-small, 4px);border-bottom-right-radius:var(--mdc-shape-small, 4px);border-bottom-left-radius:0}[dir=rtl] .mdc-text-field--outlined .mdc-notched-outline .mdc-notched-outline__trailing,.mdc-text-field--outlined .mdc-notched-outline .mdc-notched-outline__trailing[dir=rtl]{border-top-left-radius:var(--mdc-shape-small, 4px);border-top-right-radius:0;border-bottom-right-radius:0;border-bottom-left-radius:var(--mdc-shape-small, 4px)}@supports(top: max(0%)){.mdc-text-field--outlined{padding-left:max(16px, calc(var(--mdc-shape-small, 4px) + 4px))}}@supports(top: max(0%)){.mdc-text-field--outlined{padding-right:max(16px, var(--mdc-shape-small, 4px))}}@supports(top: max(0%)){.mdc-text-field--outlined+.mdc-text-field-helper-line{padding-left:max(16px, calc(var(--mdc-shape-small, 4px) + 4px))}}@supports(top: max(0%)){.mdc-text-field--outlined+.mdc-text-field-helper-line{padding-right:max(16px, var(--mdc-shape-small, 4px))}}.mdc-text-field--outlined.mdc-text-field--with-leading-icon{padding-left:0}@supports(top: max(0%)){.mdc-text-field--outlined.mdc-text-field--with-leading-icon{padding-right:max(16px, var(--mdc-shape-small, 4px))}}[dir=rtl] .mdc-text-field--outlined.mdc-text-field--with-leading-icon,.mdc-text-field--outlined.mdc-text-field--with-leading-icon[dir=rtl]{padding-right:0}@supports(top: max(0%)){[dir=rtl] .mdc-text-field--outlined.mdc-text-field--with-leading-icon,.mdc-text-field--outlined.mdc-text-field--with-leading-icon[dir=rtl]{padding-left:max(16px, var(--mdc-shape-small, 4px))}}.mdc-text-field--outlined.mdc-text-field--with-trailing-icon{padding-right:0}@supports(top: max(0%)){.mdc-text-field--outlined.mdc-text-field--with-trailing-icon{padding-left:max(16px, calc(var(--mdc-shape-small, 4px) + 4px))}}[dir=rtl] .mdc-text-field--outlined.mdc-text-field--with-trailing-icon,.mdc-text-field--outlined.mdc-text-field--with-trailing-icon[dir=rtl]{padding-left:0}@supports(top: max(0%)){[dir=rtl] .mdc-text-field--outlined.mdc-text-field--with-trailing-icon,.mdc-text-field--outlined.mdc-text-field--with-trailing-icon[dir=rtl]{padding-right:max(16px, calc(var(--mdc-shape-small, 4px) + 4px))}}.mdc-text-field--outlined.mdc-text-field--with-leading-icon.mdc-text-field--with-trailing-icon{padding-left:0;padding-right:0}.mdc-text-field--outlined .mdc-notched-outline--notched .mdc-notched-outline__notch{padding-top:1px}.mdc-text-field--outlined .mdc-floating-label{left:4px;right:initial}[dir=rtl] .mdc-text-field--outlined .mdc-floating-label,.mdc-text-field--outlined .mdc-floating-label[dir=rtl]{left:initial;right:4px}.mdc-text-field--outlined .mdc-text-field__input{display:flex;border:none !important;background-color:rgba(0,0,0,0)}.mdc-text-field--outlined .mdc-notched-outline{z-index:1}.mdc-text-field--textarea{flex-direction:column;align-items:center;width:auto;height:auto;padding:0}.mdc-text-field--textarea .mdc-floating-label{top:19px}.mdc-text-field--textarea .mdc-floating-label:not(.mdc-floating-label--float-above){transform:none}.mdc-text-field--textarea .mdc-text-field__input{flex-grow:1;height:auto;min-height:1.5rem;overflow-x:hidden;overflow-y:auto;box-sizing:border-box;resize:none;padding:0 16px}.mdc-text-field--textarea.mdc-text-field--filled::before{display:none}.mdc-text-field--textarea.mdc-text-field--filled .mdc-floating-label--float-above{transform:translateY(-10.25px) scale(0.75)}.mdc-text-field--textarea.mdc-text-field--filled .mdc-text-field__input{margin-top:23px;margin-bottom:9px}.mdc-text-field--textarea.mdc-text-field--filled.mdc-text-field--no-label .mdc-text-field__input{margin-top:16px;margin-bottom:16px}.mdc-text-field--textarea.mdc-text-field--outlined .mdc-notched-outline--notched .mdc-notched-outline__notch{padding-top:0}.mdc-text-field--textarea.mdc-text-field--outlined .mdc-floating-label--float-above{transform:translateY(-27.25px) scale(1)}.mdc-text-field--textarea.mdc-text-field--outlined .mdc-floating-label--float-above{font-size:.75rem}.mdc-text-field--textarea.mdc-text-field--outlined.mdc-notched-outline--upgraded .mdc-floating-label--float-above,.mdc-text-field--textarea.mdc-text-field--outlined .mdc-notched-outline--upgraded .mdc-floating-label--float-above{transform:translateY(-24.75px) scale(0.75)}.mdc-text-field--textarea.mdc-text-field--outlined.mdc-notched-outline--upgraded .mdc-floating-label--float-above,.mdc-text-field--textarea.mdc-text-field--outlined .mdc-notched-outline--upgraded .mdc-floating-label--float-above{font-size:1rem}.mdc-text-field--textarea.mdc-text-field--outlined .mdc-text-field__input{margin-top:16px;margin-bottom:16px}.mdc-text-field--textarea.mdc-text-field--outlined .mdc-floating-label{top:18px}.mdc-text-field--textarea.mdc-text-field--with-internal-counter .mdc-text-field__input{margin-bottom:2px}.mdc-text-field--textarea.mdc-text-field--with-internal-counter .mdc-text-field-character-counter{align-self:flex-end;padding:0 16px}.mdc-text-field--textarea.mdc-text-field--with-internal-counter .mdc-text-field-character-counter::after{display:inline-block;width:0;height:16px;content:"";vertical-align:-16px}.mdc-text-field--textarea.mdc-text-field--with-internal-counter .mdc-text-field-character-counter::before{display:none}.mdc-text-field__resizer{align-self:stretch;display:inline-flex;flex-direction:column;flex-grow:1;max-height:100%;max-width:100%;min-height:56px;min-width:fit-content;min-width:-moz-available;min-width:-webkit-fill-available;overflow:hidden;resize:both}.mdc-text-field--filled .mdc-text-field__resizer{transform:translateY(-1px)}.mdc-text-field--filled .mdc-text-field__resizer .mdc-text-field__input,.mdc-text-field--filled .mdc-text-field__resizer .mdc-text-field-character-counter{transform:translateY(1px)}.mdc-text-field--outlined .mdc-text-field__resizer{transform:translateX(-1px) translateY(-1px)}[dir=rtl] .mdc-text-field--outlined .mdc-text-field__resizer,.mdc-text-field--outlined .mdc-text-field__resizer[dir=rtl]{transform:translateX(1px) translateY(-1px)}.mdc-text-field--outlined .mdc-text-field__resizer .mdc-text-field__input,.mdc-text-field--outlined .mdc-text-field__resizer .mdc-text-field-character-counter{transform:translateX(1px) translateY(1px)}[dir=rtl] .mdc-text-field--outlined .mdc-text-field__resizer .mdc-text-field__input,[dir=rtl] .mdc-text-field--outlined .mdc-text-field__resizer .mdc-text-field-character-counter,.mdc-text-field--outlined .mdc-text-field__resizer .mdc-text-field__input[dir=rtl],.mdc-text-field--outlined .mdc-text-field__resizer .mdc-text-field-character-counter[dir=rtl]{transform:translateX(-1px) translateY(1px)}.mdc-text-field--with-leading-icon{padding-left:0;padding-right:16px}[dir=rtl] .mdc-text-field--with-leading-icon,.mdc-text-field--with-leading-icon[dir=rtl]{padding-left:16px;padding-right:0}.mdc-text-field--with-leading-icon.mdc-text-field--filled .mdc-floating-label{max-width:calc(100% - 48px);left:48px;right:initial}[dir=rtl] .mdc-text-field--with-leading-icon.mdc-text-field--filled .mdc-floating-label,.mdc-text-field--with-leading-icon.mdc-text-field--filled .mdc-floating-label[dir=rtl]{left:initial;right:48px}.mdc-text-field--with-leading-icon.mdc-text-field--filled .mdc-floating-label--float-above{max-width:calc(100% / 0.75 - 64px / 0.75)}.mdc-text-field--with-leading-icon.mdc-text-field--outlined .mdc-floating-label{left:36px;right:initial}[dir=rtl] .mdc-text-field--with-leading-icon.mdc-text-field--outlined .mdc-floating-label,.mdc-text-field--with-leading-icon.mdc-text-field--outlined .mdc-floating-label[dir=rtl]{left:initial;right:36px}.mdc-text-field--with-leading-icon.mdc-text-field--outlined :not(.mdc-notched-outline--notched) .mdc-notched-outline__notch{max-width:calc(100% - 60px)}.mdc-text-field--with-leading-icon.mdc-text-field--outlined .mdc-floating-label--float-above{transform:translateY(-37.25px) translateX(-32px) scale(1)}[dir=rtl] .mdc-text-field--with-leading-icon.mdc-text-field--outlined .mdc-floating-label--float-above,.mdc-text-field--with-leading-icon.mdc-text-field--outlined .mdc-floating-label--float-above[dir=rtl]{transform:translateY(-37.25px) translateX(32px) scale(1)}.mdc-text-field--with-leading-icon.mdc-text-field--outlined .mdc-floating-label--float-above{font-size:.75rem}.mdc-text-field--with-leading-icon.mdc-text-field--outlined.mdc-notched-outline--upgraded .mdc-floating-label--float-above,.mdc-text-field--with-leading-icon.mdc-text-field--outlined .mdc-notched-outline--upgraded .mdc-floating-label--float-above{transform:translateY(-34.75px) translateX(-32px) scale(0.75)}[dir=rtl] .mdc-text-field--with-leading-icon.mdc-text-field--outlined.mdc-notched-outline--upgraded .mdc-floating-label--float-above,[dir=rtl] .mdc-text-field--with-leading-icon.mdc-text-field--outlined .mdc-notched-outline--upgraded .mdc-floating-label--float-above,.mdc-text-field--with-leading-icon.mdc-text-field--outlined.mdc-notched-outline--upgraded .mdc-floating-label--float-above[dir=rtl],.mdc-text-field--with-leading-icon.mdc-text-field--outlined .mdc-notched-outline--upgraded .mdc-floating-label--float-above[dir=rtl]{transform:translateY(-34.75px) translateX(32px) scale(0.75)}.mdc-text-field--with-leading-icon.mdc-text-field--outlined.mdc-notched-outline--upgraded .mdc-floating-label--float-above,.mdc-text-field--with-leading-icon.mdc-text-field--outlined .mdc-notched-outline--upgraded .mdc-floating-label--float-above{font-size:1rem}.mdc-text-field--with-trailing-icon{padding-left:16px;padding-right:0}[dir=rtl] .mdc-text-field--with-trailing-icon,.mdc-text-field--with-trailing-icon[dir=rtl]{padding-left:0;padding-right:16px}.mdc-text-field--with-trailing-icon.mdc-text-field--filled .mdc-floating-label{max-width:calc(100% - 64px)}.mdc-text-field--with-trailing-icon.mdc-text-field--filled .mdc-floating-label--float-above{max-width:calc(100% / 0.75 - 64px / 0.75)}.mdc-text-field--with-trailing-icon.mdc-text-field--outlined :not(.mdc-notched-outline--notched) .mdc-notched-outline__notch{max-width:calc(100% - 60px)}.mdc-text-field--with-leading-icon.mdc-text-field--with-trailing-icon{padding-left:0;padding-right:0}.mdc-text-field--with-leading-icon.mdc-text-field--with-trailing-icon.mdc-text-field--filled .mdc-floating-label{max-width:calc(100% - 96px)}.mdc-text-field--with-leading-icon.mdc-text-field--with-trailing-icon.mdc-text-field--filled .mdc-floating-label--float-above{max-width:calc(100% / 0.75 - 96px / 0.75)}.mdc-text-field-helper-line{display:flex;justify-content:space-between;box-sizing:border-box}.mdc-text-field+.mdc-text-field-helper-line{padding-right:16px;padding-left:16px}.mdc-form-field>.mdc-text-field+label{align-self:flex-start}.mdc-text-field--focused .mdc-notched-outline__leading,.mdc-text-field--focused .mdc-notched-outline__notch,.mdc-text-field--focused .mdc-notched-outline__trailing{border-width:2px}.mdc-text-field--focused+.mdc-text-field-helper-line .mdc-text-field-helper-text:not(.mdc-text-field-helper-text--validation-msg){opacity:1}.mdc-text-field--focused.mdc-text-field--outlined .mdc-notched-outline--notched .mdc-notched-outline__notch{padding-top:2px}.mdc-text-field--focused.mdc-text-field--outlined.mdc-text-field--textarea .mdc-notched-outline--notched .mdc-notched-outline__notch{padding-top:0}.mdc-text-field--invalid+.mdc-text-field-helper-line .mdc-text-field-helper-text--validation-msg{opacity:1}.mdc-text-field--disabled{pointer-events:none}@media screen and (forced-colors: active){.mdc-text-field--disabled .mdc-text-field__input{background-color:Window}.mdc-text-field--disabled .mdc-floating-label{z-index:1}}.mdc-text-field--disabled .mdc-floating-label{cursor:default}.mdc-text-field--disabled.mdc-text-field--filled .mdc-text-field__ripple{display:none}.mdc-text-field--disabled .mdc-text-field__input{pointer-events:auto}.mdc-text-field--end-aligned .mdc-text-field__input{text-align:right}[dir=rtl] .mdc-text-field--end-aligned .mdc-text-field__input,.mdc-text-field--end-aligned .mdc-text-field__input[dir=rtl]{text-align:left}[dir=rtl] .mdc-text-field--ltr-text .mdc-text-field__input,[dir=rtl] .mdc-text-field--ltr-text .mdc-text-field__affix,.mdc-text-field--ltr-text[dir=rtl] .mdc-text-field__input,.mdc-text-field--ltr-text[dir=rtl] .mdc-text-field__affix{direction:ltr}[dir=rtl] .mdc-text-field--ltr-text .mdc-text-field__affix--prefix,.mdc-text-field--ltr-text[dir=rtl] .mdc-text-field__affix--prefix{padding-left:0;padding-right:2px}[dir=rtl] .mdc-text-field--ltr-text .mdc-text-field__affix--suffix,.mdc-text-field--ltr-text[dir=rtl] .mdc-text-field__affix--suffix{padding-left:12px;padding-right:0}[dir=rtl] .mdc-text-field--ltr-text .mdc-text-field__icon--leading,.mdc-text-field--ltr-text[dir=rtl] .mdc-text-field__icon--leading{order:1}[dir=rtl] .mdc-text-field--ltr-text .mdc-text-field__affix--suffix,.mdc-text-field--ltr-text[dir=rtl] .mdc-text-field__affix--suffix{order:2}[dir=rtl] .mdc-text-field--ltr-text .mdc-text-field__input,.mdc-text-field--ltr-text[dir=rtl] .mdc-text-field__input{order:3}[dir=rtl] .mdc-text-field--ltr-text .mdc-text-field__affix--prefix,.mdc-text-field--ltr-text[dir=rtl] .mdc-text-field__affix--prefix{order:4}[dir=rtl] .mdc-text-field--ltr-text .mdc-text-field__icon--trailing,.mdc-text-field--ltr-text[dir=rtl] .mdc-text-field__icon--trailing{order:5}[dir=rtl] .mdc-text-field--ltr-text.mdc-text-field--end-aligned .mdc-text-field__input,.mdc-text-field--ltr-text.mdc-text-field--end-aligned[dir=rtl] .mdc-text-field__input{text-align:right}[dir=rtl] .mdc-text-field--ltr-text.mdc-text-field--end-aligned .mdc-text-field__affix--prefix,.mdc-text-field--ltr-text.mdc-text-field--end-aligned[dir=rtl] .mdc-text-field__affix--prefix{padding-right:12px}[dir=rtl] .mdc-text-field--ltr-text.mdc-text-field--end-aligned .mdc-text-field__affix--suffix,.mdc-text-field--ltr-text.mdc-text-field--end-aligned[dir=rtl] .mdc-text-field__affix--suffix{padding-left:2px}.mdc-floating-label{position:absolute;left:0;-webkit-transform-origin:left top;transform-origin:left top;line-height:1.15rem;text-align:left;text-overflow:ellipsis;white-space:nowrap;cursor:text;overflow:hidden;will-change:transform}[dir=rtl] .mdc-floating-label,.mdc-floating-label[dir=rtl]{right:0;left:auto;-webkit-transform-origin:right top;transform-origin:right top;text-align:right}.mdc-floating-label--float-above{cursor:auto}.mdc-floating-label--required:not(.mdc-floating-label--hide-required-marker)::after{margin-left:1px;margin-right:0px;content:"*"}[dir=rtl] .mdc-floating-label--required:not(.mdc-floating-label--hide-required-marker)::after,.mdc-floating-label--required:not(.mdc-floating-label--hide-required-marker)[dir=rtl]::after{margin-left:0;margin-right:1px}.mdc-floating-label--float-above{transform:translateY(-106%) scale(0.75)}.mdc-notched-outline{display:flex;position:absolute;top:0;right:0;left:0;box-sizing:border-box;width:100%;max-width:100%;height:100%;text-align:left;pointer-events:none}[dir=rtl] .mdc-notched-outline,.mdc-notched-outline[dir=rtl]{text-align:right}.mdc-notched-outline__leading,.mdc-notched-outline__notch,.mdc-notched-outline__trailing{box-sizing:border-box;height:100%;border-top:1px solid;border-bottom:1px solid;pointer-events:none}.mdc-notched-outline__leading{border-left:1px solid;border-right:none;width:12px}[dir=rtl] .mdc-notched-outline__leading,.mdc-notched-outline__leading[dir=rtl]{border-left:none;border-right:1px solid}.mdc-notched-outline__trailing{border-left:none;border-right:1px solid;flex-grow:1}[dir=rtl] .mdc-notched-outline__trailing,.mdc-notched-outline__trailing[dir=rtl]{border-left:1px solid;border-right:none}.mdc-notched-outline__notch{flex:0 0 auto;width:auto;max-width:calc(100% - 12px * 2)}.mdc-notched-outline .mdc-floating-label{display:inline-block;position:relative;max-width:100%}.mdc-notched-outline .mdc-floating-label--float-above{text-overflow:clip}.mdc-notched-outline--upgraded .mdc-floating-label--float-above{max-width:133.3333333333%}.mdc-notched-outline--notched .mdc-notched-outline__notch{padding-left:0;padding-right:8px;border-top:none}[dir=rtl] .mdc-notched-outline--notched .mdc-notched-outline__notch,.mdc-notched-outline--notched .mdc-notched-outline__notch[dir=rtl]{padding-left:8px;padding-right:0}.mdc-notched-outline--no-label .mdc-notched-outline__notch{display:none}.mdc-line-ripple::before,.mdc-line-ripple::after{position:absolute;bottom:0;left:0;width:100%;border-bottom-style:solid;content:""}.mdc-line-ripple::before{border-bottom-width:1px}.mdc-line-ripple::after{border-bottom-width:2px}.mdc-line-ripple::before{z-index:1}.mdc-line-ripple::after{transform:scaleX(0);opacity:0;z-index:2}.mdc-line-ripple--active::after{transform:scaleX(1);opacity:1}.mdc-line-ripple--deactivating::after{opacity:0}.mat-mdc-form-field-textarea-control{vertical-align:middle;resize:vertical;box-sizing:border-box;height:auto;margin:0;padding:0;border:none;overflow:auto}.mat-mdc-form-field-input-control.mat-mdc-form-field-input-control{font:inherit;letter-spacing:inherit;text-decoration:inherit;text-transform:inherit;border:none}.mat-mdc-form-field .mat-mdc-floating-label.mdc-floating-label{line-height:normal;pointer-events:all}.mdc-text-field--no-label:not(.mdc-text-field--textarea) .mat-mdc-form-field-input-control.mdc-text-field__input,.mat-mdc-text-field-wrapper .mat-mdc-form-field-input-control{height:auto}.mat-mdc-text-field-wrapper .mat-mdc-form-field-input-control.mdc-text-field__input[type=color]{height:23px}.mat-mdc-text-field-wrapper{height:auto;flex:auto}.mat-mdc-form-field-has-icon-prefix .mat-mdc-text-field-wrapper{padding-left:0;--mat-mdc-form-field-label-offset-x: -16px}.mat-mdc-form-field-has-icon-suffix .mat-mdc-text-field-wrapper{padding-right:0}[dir=rtl] .mat-mdc-text-field-wrapper{padding-left:16px;padding-right:16px}[dir=rtl] .mat-mdc-form-field-has-icon-suffix .mat-mdc-text-field-wrapper{padding-left:0}[dir=rtl] .mat-mdc-form-field-has-icon-prefix .mat-mdc-text-field-wrapper{padding-right:0}.mat-mdc-form-field-label-always-float .mdc-text-field__input::placeholder{transition-delay:40ms;transition-duration:110ms;opacity:1}.mat-mdc-text-field-wrapper .mat-mdc-form-field-infix .mat-mdc-floating-label{left:auto;right:auto}.mat-mdc-text-field-wrapper.mdc-text-field--outlined .mdc-text-field__input{display:inline-block}.mat-mdc-form-field .mat-mdc-text-field-wrapper.mdc-text-field .mdc-notched-outline__notch{padding-top:0}.mat-mdc-text-field-wrapper::before{content:none}.mat-mdc-form-field-subscript-wrapper{box-sizing:border-box;width:100%;position:relative}.mat-mdc-form-field-hint-wrapper,.mat-mdc-form-field-error-wrapper{position:absolute;top:0;left:0;right:0;padding:0 16px}.mat-mdc-form-field-subscript-dynamic-size .mat-mdc-form-field-hint-wrapper,.mat-mdc-form-field-subscript-dynamic-size .mat-mdc-form-field-error-wrapper{position:static}.mat-mdc-form-field-bottom-align::before{content:"";display:inline-block;height:16px}.mat-mdc-form-field-bottom-align.mat-mdc-form-field-subscript-dynamic-size::before{content:unset}.mat-mdc-form-field-hint-end{order:1}.mat-mdc-form-field-hint-wrapper{display:flex}.mat-mdc-form-field-hint-spacer{flex:1 0 1em}.mat-mdc-form-field-error{display:block}.mat-mdc-form-field-focus-overlay{top:0;left:0;right:0;bottom:0;position:absolute;opacity:0;pointer-events:none}select.mat-mdc-form-field-input-control{-moz-appearance:none;-webkit-appearance:none;background-color:rgba(0,0,0,0);display:inline-flex;box-sizing:border-box}select.mat-mdc-form-field-input-control:not(:disabled){cursor:pointer}.mat-mdc-form-field-type-mat-native-select .mat-mdc-form-field-infix::after{content:"";width:0;height:0;border-left:5px solid rgba(0,0,0,0);border-right:5px solid rgba(0,0,0,0);border-top:5px solid;position:absolute;right:0;top:50%;margin-top:-2.5px;pointer-events:none}[dir=rtl] .mat-mdc-form-field-type-mat-native-select .mat-mdc-form-field-infix::after{right:auto;left:0}.mat-mdc-form-field-type-mat-native-select .mat-mdc-form-field-input-control{padding-right:15px}[dir=rtl] .mat-mdc-form-field-type-mat-native-select .mat-mdc-form-field-input-control{padding-right:0;padding-left:15px}.cdk-high-contrast-active .mat-form-field-appearance-fill .mat-mdc-text-field-wrapper{outline:solid 1px}.cdk-high-contrast-active .mat-form-field-appearance-fill.mat-form-field-disabled .mat-mdc-text-field-wrapper{outline-color:GrayText}.cdk-high-contrast-active .mat-form-field-appearance-fill.mat-focused .mat-mdc-text-field-wrapper{outline:dashed 3px}.cdk-high-contrast-active .mat-mdc-form-field.mat-focused .mdc-notched-outline{border:dashed 3px}.mat-mdc-form-field-input-control[type=date],.mat-mdc-form-field-input-control[type=datetime],.mat-mdc-form-field-input-control[type=datetime-local],.mat-mdc-form-field-input-control[type=month],.mat-mdc-form-field-input-control[type=week],.mat-mdc-form-field-input-control[type=time]{line-height:1}.mat-mdc-form-field-input-control::-webkit-datetime-edit{line-height:1;padding:0;margin-bottom:-2px}.mat-mdc-form-field{--mat-mdc-form-field-floating-label-scale: 0.75;display:inline-flex;flex-direction:column;min-width:0;text-align:left}[dir=rtl] .mat-mdc-form-field{text-align:right}.mat-mdc-form-field-flex{display:inline-flex;align-items:baseline;box-sizing:border-box;width:100%}.mat-mdc-text-field-wrapper{width:100%}.mat-mdc-form-field-icon-prefix,.mat-mdc-form-field-icon-suffix{align-self:center;line-height:0;pointer-events:auto}.mat-mdc-form-field-icon-prefix,[dir=rtl] .mat-mdc-form-field-icon-suffix{padding:0 4px 0 0}.mat-mdc-form-field-icon-suffix,[dir=rtl] .mat-mdc-form-field-icon-prefix{padding:0 0 0 4px}.mat-mdc-form-field-icon-prefix>.mat-icon,.mat-mdc-form-field-icon-suffix>.mat-icon{padding:12px;box-sizing:content-box}.mat-mdc-form-field-subscript-wrapper .mat-icon,.mat-mdc-form-field label .mat-icon{width:1em;height:1em;font-size:inherit}.mat-mdc-form-field-infix{flex:auto;min-width:0;width:180px;position:relative;box-sizing:border-box}.mat-mdc-form-field .mdc-notched-outline__notch{margin-left:-1px;-webkit-clip-path:inset(-9em -999em -9em 1px);clip-path:inset(-9em -999em -9em 1px)}[dir=rtl] .mat-mdc-form-field .mdc-notched-outline__notch{margin-left:0;margin-right:-1px;-webkit-clip-path:inset(-9em 1px -9em -999em);clip-path:inset(-9em 1px -9em -999em)}.mat-mdc-form-field:not(.mat-form-field-no-animations) .mdc-text-field__input{transition:opacity 150ms 0ms cubic-bezier(0.4, 0, 0.2, 1)}@media all{.mat-mdc-form-field:not(.mat-form-field-no-animations) .mdc-text-field__input::placeholder{transition:opacity 67ms 0ms cubic-bezier(0.4, 0, 0.2, 1)}}@media all{.mat-mdc-form-field:not(.mat-form-field-no-animations) .mdc-text-field__input:-ms-input-placeholder{transition:opacity 67ms 0ms cubic-bezier(0.4, 0, 0.2, 1)}}@media all{.mdc-text-field--no-label .mat-mdc-form-field:not(.mat-form-field-no-animations) .mdc-text-field__input::placeholder,.mdc-text-field--focused .mat-mdc-form-field:not(.mat-form-field-no-animations) .mdc-text-field__input::placeholder{transition-delay:40ms;transition-duration:110ms}}@media all{.mdc-text-field--no-label .mat-mdc-form-field:not(.mat-form-field-no-animations) .mdc-text-field__input:-ms-input-placeholder,.mdc-text-field--focused .mat-mdc-form-field:not(.mat-form-field-no-animations) .mdc-text-field__input:-ms-input-placeholder{transition-delay:40ms;transition-duration:110ms}}.mat-mdc-form-field:not(.mat-form-field-no-animations) .mdc-text-field__affix{transition:opacity 150ms 0ms cubic-bezier(0.4, 0, 0.2, 1)}.mat-mdc-form-field:not(.mat-form-field-no-animations) .mdc-text-field--filled.mdc-ripple-upgraded--background-focused .mdc-text-field__ripple::before,.mat-mdc-form-field:not(.mat-form-field-no-animations) .mdc-text-field--filled:not(.mdc-ripple-upgraded):focus .mdc-text-field__ripple::before{transition-duration:75ms}.mat-mdc-form-field:not(.mat-form-field-no-animations) .mdc-text-field--outlined .mdc-floating-label--shake{animation:mdc-floating-label-shake-float-above-text-field-outlined 250ms 1}@keyframes mdc-floating-label-shake-float-above-text-field-outlined{0%{transform:translateX(calc(0 - 0%)) translateY(-34.75px) scale(0.75)}33%{animation-timing-function:cubic-bezier(0.5, 0, 0.701732, 0.495819);transform:translateX(calc(4% - 0%)) translateY(-34.75px) scale(0.75)}66%{animation-timing-function:cubic-bezier(0.302435, 0.381352, 0.55, 0.956352);transform:translateX(calc(-4% - 0%)) translateY(-34.75px) scale(0.75)}100%{transform:translateX(calc(0 - 0%)) translateY(-34.75px) scale(0.75)}}.mat-mdc-form-field:not(.mat-form-field-no-animations) .mdc-text-field--textarea{transition:none}.mat-mdc-form-field:not(.mat-form-field-no-animations) .mdc-text-field--textarea.mdc-text-field--filled .mdc-floating-label--shake{animation:mdc-floating-label-shake-float-above-textarea-filled 250ms 1}@keyframes mdc-floating-label-shake-float-above-textarea-filled{0%{transform:translateX(calc(0 - 0%)) translateY(-10.25px) scale(0.75)}33%{animation-timing-function:cubic-bezier(0.5, 0, 0.701732, 0.495819);transform:translateX(calc(4% - 0%)) translateY(-10.25px) scale(0.75)}66%{animation-timing-function:cubic-bezier(0.302435, 0.381352, 0.55, 0.956352);transform:translateX(calc(-4% - 0%)) translateY(-10.25px) scale(0.75)}100%{transform:translateX(calc(0 - 0%)) translateY(-10.25px) scale(0.75)}}.mat-mdc-form-field:not(.mat-form-field-no-animations) .mdc-text-field--textarea.mdc-text-field--outlined .mdc-floating-label--shake{animation:mdc-floating-label-shake-float-above-textarea-outlined 250ms 1}@keyframes mdc-floating-label-shake-float-above-textarea-outlined{0%{transform:translateX(calc(0 - 0%)) translateY(-24.75px) scale(0.75)}33%{animation-timing-function:cubic-bezier(0.5, 0, 0.701732, 0.495819);transform:translateX(calc(4% - 0%)) translateY(-24.75px) scale(0.75)}66%{animation-timing-function:cubic-bezier(0.302435, 0.381352, 0.55, 0.956352);transform:translateX(calc(-4% - 0%)) translateY(-24.75px) scale(0.75)}100%{transform:translateX(calc(0 - 0%)) translateY(-24.75px) scale(0.75)}}.mat-mdc-form-field:not(.mat-form-field-no-animations) .mdc-text-field--with-leading-icon.mdc-text-field--outlined .mdc-floating-label--shake{animation:mdc-floating-label-shake-float-above-text-field-outlined-leading-icon 250ms 1}@keyframes mdc-floating-label-shake-float-above-text-field-outlined-leading-icon{0%{transform:translateX(calc(0 - 32px)) translateY(-34.75px) scale(0.75)}33%{animation-timing-function:cubic-bezier(0.5, 0, 0.701732, 0.495819);transform:translateX(calc(4% - 32px)) translateY(-34.75px) scale(0.75)}66%{animation-timing-function:cubic-bezier(0.302435, 0.381352, 0.55, 0.956352);transform:translateX(calc(-4% - 32px)) translateY(-34.75px) scale(0.75)}100%{transform:translateX(calc(0 - 32px)) translateY(-34.75px) scale(0.75)}}[dir=rtl] .mat-mdc-form-field:not(.mat-form-field-no-animations) .mdc-text-field--with-leading-icon.mdc-text-field--outlined .mdc-floating-label--shake,.mat-mdc-form-field:not(.mat-form-field-no-animations) .mdc-text-field--with-leading-icon.mdc-text-field--outlined[dir=rtl] .mdc-floating-label--shake{animation:mdc-floating-label-shake-float-above-text-field-outlined-leading-icon 250ms 1}@keyframes mdc-floating-label-shake-float-above-text-field-outlined-leading-icon-rtl{0%{transform:translateX(calc(0 - -32px)) translateY(-34.75px) scale(0.75)}33%{animation-timing-function:cubic-bezier(0.5, 0, 0.701732, 0.495819);transform:translateX(calc(4% - -32px)) translateY(-34.75px) scale(0.75)}66%{animation-timing-function:cubic-bezier(0.302435, 0.381352, 0.55, 0.956352);transform:translateX(calc(-4% - -32px)) translateY(-34.75px) scale(0.75)}100%{transform:translateX(calc(0 - -32px)) translateY(-34.75px) scale(0.75)}}.mat-mdc-form-field:not(.mat-form-field-no-animations) .mdc-floating-label{transition:transform 150ms cubic-bezier(0.4, 0, 0.2, 1),color 150ms cubic-bezier(0.4, 0, 0.2, 1)}.mdc-floating-label--shake{animation:mdc-floating-label-shake-float-above-standard 250ms 1}@keyframes mdc-floating-label-shake-float-above-standard{0%{transform:translateX(calc(0 - 0%)) translateY(-106%) scale(0.75)}33%{animation-timing-function:cubic-bezier(0.5, 0, 0.701732, 0.495819);transform:translateX(calc(4% - 0%)) translateY(-106%) scale(0.75)}66%{animation-timing-function:cubic-bezier(0.302435, 0.381352, 0.55, 0.956352);transform:translateX(calc(-4% - 0%)) translateY(-106%) scale(0.75)}100%{transform:translateX(calc(0 - 0%)) translateY(-106%) scale(0.75)}}.mat-mdc-form-field:not(.mat-form-field-no-animations) .mdc-line-ripple::after{transition:transform 180ms cubic-bezier(0.4, 0, 0.2, 1),opacity 180ms cubic-bezier(0.4, 0, 0.2, 1)}'],encapsulation:2,data:{animation:[pve.transitionMessages]},changeDetection:0}),n})(),Ef=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[fn,Pe,ng,fn]}),n})(),O9=(()=>{class n{constructor(e,i){this._renderer=e,this._elementRef=i,this.onChange=r=>{},this.onTouched=()=>{}}setProperty(e,i){this._renderer.setProperty(this._elementRef.nativeElement,e,i)}registerOnTouched(e){this.onTouched=e}registerOnChange(e){this.onChange=e}setDisabledState(e){this.setProperty("disabled",e)}}return n.\u0275fac=function(e){return new(e||n)(C(mc),C(Me))},n.\u0275dir=we({type:n}),n})(),Tf=(()=>{class n extends O9{}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275dir=we({type:n,features:[Ke]}),n})(),Mo=new ie("NgValueAccessor"),gve={provide:Mo,useExisting:$n(()=>_ve),multi:!0},_ve=(()=>{class n extends Tf{writeValue(e){this.setProperty("checked",e)}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275dir=we({type:n,selectors:[["input","type","checkbox","formControlName",""],["input","type","checkbox","formControl",""],["input","type","checkbox","ngModel",""]],hostBindings:function(e,i){1&e&&I("change",function(o){return i.onChange(o.target.checked)})("blur",function(){return i.onTouched()})},features:[Qt([gve]),Ke]}),n})(),bve={provide:Mo,useExisting:$n(()=>bg),multi:!0},yve=new ie("CompositionEventMode"),bg=(()=>{class n extends O9{constructor(e,i,r){super(e,i),this._compositionMode=r,this._composing=!1,null==this._compositionMode&&(this._compositionMode=!function(){let n=Tl()?Tl().getUserAgent():"";return/android (\d+)/.test(n.toLowerCase())}())}writeValue(e){this.setProperty("value",e??"")}_handleInput(e){(!this._compositionMode||this._compositionMode&&!this._composing)&&this.onChange(e)}_compositionStart(){this._composing=!0}_compositionEnd(e){this._composing=!1,this._compositionMode&&this.onChange(e)}}return n.\u0275fac=function(e){return new(e||n)(C(mc),C(Me),C(yve,8))},n.\u0275dir=we({type:n,selectors:[["input","formControlName","",3,"type","checkbox"],["textarea","formControlName",""],["input","formControl","",3,"type","checkbox"],["textarea","formControl",""],["input","ngModel","",3,"type","checkbox"],["textarea","ngModel",""],["","ngDefaultControl",""]],hostBindings:function(e,i){1&e&&I("input",function(o){return i._handleInput(o.target.value)})("blur",function(){return i.onTouched()})("compositionstart",function(){return i._compositionStart()})("compositionend",function(o){return i._compositionEnd(o.target.value)})},features:[Qt([bve]),Ke]}),n})(),xve=!1;function Vu(n){return null==n||("string"==typeof n||Array.isArray(n))&&0===n.length}function k9(n){return null!=n&&"number"==typeof n.length}var wo=new ie("NgValidators"),Hu=new ie("NgAsyncValidators"),Cve=/^(?=.{1,254}$)(?=.{1,64}@)[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)*@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/,Ul=class{static min(t){return F9(t)}static max(t){return N9(t)}static required(t){return L9(t)}static requiredTrue(t){return B9(t)}static email(t){return V9(t)}static minLength(t){return H9(t)}static maxLength(t){return z9(t)}static pattern(t){return U9(t)}static nullValidator(t){return null}static compose(t){return X9(t)}static composeAsync(t){return Q9(t)}};function F9(n){return t=>{if(Vu(t.value)||Vu(n))return null;let e=parseFloat(t.value);return!isNaN(e)&&e<n?{min:{min:n,actual:t.value}}:null}}function N9(n){return t=>{if(Vu(t.value)||Vu(n))return null;let e=parseFloat(t.value);return!isNaN(e)&&e>n?{max:{max:n,actual:t.value}}:null}}function L9(n){return Vu(n.value)?{required:!0}:null}function B9(n){return!0===n.value?null:{required:!0}}function V9(n){return Vu(n.value)||Cve.test(n.value)?null:{email:!0}}function H9(n){return t=>Vu(t.value)||!k9(t.value)?null:t.value.length<n?{minlength:{requiredLength:n,actualLength:t.value.length}}:null}function z9(n){return t=>k9(t.value)&&t.value.length>n?{maxlength:{requiredLength:n,actualLength:t.value.length}}:null}function U9(n){if(!n)return tE;let t,e;return"string"==typeof n?(e="","^"!==n.charAt(0)&&(e+="^"),e+=n,"$"!==n.charAt(n.length-1)&&(e+="$"),t=new RegExp(e)):(e=n.toString(),t=n),i=>{if(Vu(i.value))return null;let r=i.value;return t.test(r)?null:{pattern:{requiredPattern:e,actualValue:r}}}}function tE(n){return null}function j9(n){return null!=n}function G9(n){let t=hh(n)?$r(n):n;if(xve&&!DO(t)){let e="Expected async validator to return Promise or Observable.";throw"object"==typeof n&&(e+=" Are you using a synchronous validator where an async validator is expected?"),new yt(-1101,e)}return t}function W9(n){let t={};return n.forEach(e=>{t=null!=e?{...t,...e}:t}),0===Object.keys(t).length?null:t}function q9(n,t){return t.map(e=>e(n))}function Y9(n){return n.map(t=>function(n){return!n.validate}(t)?t:e=>t.validate(e))}function X9(n){if(!n)return null;let t=n.filter(j9);return 0==t.length?null:function(e){return W9(q9(e,t))}}function z2(n){return null!=n?X9(Y9(n)):null}function Q9(n){if(!n)return null;let t=n.filter(j9);return 0==t.length?null:function(e){return co(q9(e,t).map(G9)).pipe(N(W9))}}function U2(n){return null!=n?Q9(Y9(n)):null}function E9(n,t){return null===n?[t]:Array.isArray(n)?[...n,t]:[n,t]}function Z9(n){return n._rawValidators}function K9(n){return n._rawAsyncValidators}function B2(n){return n?Array.isArray(n)?n:[n]:[]}function nE(n,t){return Array.isArray(n)?n.includes(t):n===t}function T9(n,t){let e=B2(t);return B2(n).forEach(r=>{nE(e,r)||e.push(r)}),e}function D9(n,t){return B2(t).filter(e=>!nE(n,e))}var iE=class{constructor(){this._rawValidators=[],this._rawAsyncValidators=[],this._onDestroyCallbacks=[]}get value(){return this.control?this.control.value:null}get valid(){return this.control?this.control.valid:null}get invalid(){return this.control?this.control.invalid:null}get pending(){return this.control?this.control.pending:null}get disabled(){return this.control?this.control.disabled:null}get enabled(){return this.control?this.control.enabled:null}get errors(){return this.control?this.control.errors:null}get pristine(){return this.control?this.control.pristine:null}get dirty(){return this.control?this.control.dirty:null}get touched(){return this.control?this.control.touched:null}get status(){return this.control?this.control.status:null}get untouched(){return this.control?this.control.untouched:null}get statusChanges(){return this.control?this.control.statusChanges:null}get valueChanges(){return this.control?this.control.valueChanges:null}get path(){return null}_setValidators(t){this._rawValidators=t||[],this._composedValidatorFn=z2(this._rawValidators)}_setAsyncValidators(t){this._rawAsyncValidators=t||[],this._composedAsyncValidatorFn=U2(this._rawAsyncValidators)}get validator(){return this._composedValidatorFn||null}get asyncValidator(){return this._composedAsyncValidatorFn||null}_registerOnDestroy(t){this._onDestroyCallbacks.push(t)}_invokeOnDestroyCallbacks(){this._onDestroyCallbacks.forEach(t=>t()),this._onDestroyCallbacks=[]}reset(t){this.control&&this.control.reset(t)}hasError(t,e){return!!this.control&&this.control.hasError(t,e)}getError(t,e){return this.control?this.control.getError(t,e):null}},Xo=class extends iE{get formDirective(){return null}get path(){return null}},Gs=class extends iE{constructor(){super(...arguments),this._parent=null,this.name=null,this.valueAccessor=null}},V2=class{constructor(t){this._cd=t}get isTouched(){return!!this._cd?.control?.touched}get isUntouched(){return!!this._cd?.control?.untouched}get isPristine(){return!!this._cd?.control?.pristine}get isDirty(){return!!this._cd?.control?.dirty}get isValid(){return!!this._cd?.control?.valid}get isInvalid(){return!!this._cd?.control?.invalid}get isPending(){return!!this._cd?.control?.pending}get isSubmitted(){return!!this._cd?.submitted}},cE=(()=>{class n extends V2{constructor(e){super(e)}}return n.\u0275fac=function(e){return new(e||n)(C(Gs,2))},n.\u0275dir=we({type:n,selectors:[["","formControlName",""],["","ngModel",""],["","formControl",""]],hostVars:14,hostBindings:function(e,i){2&e&&nt("ng-untouched",i.isUntouched)("ng-touched",i.isTouched)("ng-pristine",i.isPristine)("ng-dirty",i.isDirty)("ng-valid",i.isValid)("ng-invalid",i.isInvalid)("ng-pending",i.isPending)},features:[Ke]}),n})();function J9(n,t){return n?`with name: '${t}'`:`at index: ${t}`}var H2=!1,Zv="VALID",eE="INVALID",_g="PENDING",Kv="DISABLED";function $9(n){return(dE(n)?n.validators:n)||null}function eq(n,t){return(dE(t)?t.asyncValidators:n)||null}function dE(n){return null!=n&&!Array.isArray(n)&&"object"==typeof n}var rE=class{constructor(t,e){this._pendingDirty=!1,this._hasOwnPendingAsyncValidator=!1,this._pendingTouched=!1,this._onCollectionChange=()=>{},this._parent=null,this.pristine=!0,this.touched=!1,this._onDisabledChange=[],this._assignValidators(t),this._assignAsyncValidators(e)}get validator(){return this._composedValidatorFn}set validator(t){this._rawValidators=this._composedValidatorFn=t}get asyncValidator(){return this._composedAsyncValidatorFn}set asyncValidator(t){this._rawAsyncValidators=this._composedAsyncValidatorFn=t}get parent(){return this._parent}get valid(){return this.status===Zv}get invalid(){return this.status===eE}get pending(){return this.status==_g}get disabled(){return this.status===Kv}get enabled(){return this.status!==Kv}get dirty(){return!this.pristine}get untouched(){return!this.touched}get updateOn(){return this._updateOn?this._updateOn:this.parent?this.parent.updateOn:"change"}setValidators(t){this._assignValidators(t)}setAsyncValidators(t){this._assignAsyncValidators(t)}addValidators(t){this.setValidators(T9(t,this._rawValidators))}addAsyncValidators(t){this.setAsyncValidators(T9(t,this._rawAsyncValidators))}removeValidators(t){this.setValidators(D9(t,this._rawValidators))}removeAsyncValidators(t){this.setAsyncValidators(D9(t,this._rawAsyncValidators))}hasValidator(t){return nE(this._rawValidators,t)}hasAsyncValidator(t){return nE(this._rawAsyncValidators,t)}clearValidators(){this.validator=null}clearAsyncValidators(){this.asyncValidator=null}markAsTouched(t={}){this.touched=!0,this._parent&&!t.onlySelf&&this._parent.markAsTouched(t)}markAllAsTouched(){this.markAsTouched({onlySelf:!0}),this._forEachChild(t=>t.markAllAsTouched())}markAsUntouched(t={}){this.touched=!1,this._pendingTouched=!1,this._forEachChild(e=>{e.markAsUntouched({onlySelf:!0})}),this._parent&&!t.onlySelf&&this._parent._updateTouched(t)}markAsDirty(t={}){this.pristine=!1,this._parent&&!t.onlySelf&&this._parent.markAsDirty(t)}markAsPristine(t={}){this.pristine=!0,this._pendingDirty=!1,this._forEachChild(e=>{e.markAsPristine({onlySelf:!0})}),this._parent&&!t.onlySelf&&this._parent._updatePristine(t)}markAsPending(t={}){this.status=_g,!1!==t.emitEvent&&this.statusChanges.emit(this.status),this._parent&&!t.onlySelf&&this._parent.markAsPending(t)}disable(t={}){let e=this._parentMarkedDirty(t.onlySelf);this.status=Kv,this.errors=null,this._forEachChild(i=>{i.disable({...t,onlySelf:!0})}),this._updateValue(),!1!==t.emitEvent&&(this.valueChanges.emit(this.value),this.statusChanges.emit(this.status)),this._updateAncestors({...t,skipPristineCheck:e}),this._onDisabledChange.forEach(i=>i(!0))}enable(t={}){let e=this._parentMarkedDirty(t.onlySelf);this.status=Zv,this._forEachChild(i=>{i.enable({...t,onlySelf:!0})}),this.updateValueAndValidity({onlySelf:!0,emitEvent:t.emitEvent}),this._updateAncestors({...t,skipPristineCheck:e}),this._onDisabledChange.forEach(i=>i(!1))}_updateAncestors(t){this._parent&&!t.onlySelf&&(this._parent.updateValueAndValidity(t),t.skipPristineCheck||this._parent._updatePristine(),this._parent._updateTouched())}setParent(t){this._parent=t}getRawValue(){return this.value}updateValueAndValidity(t={}){this._setInitialStatus(),this._updateValue(),this.enabled&&(this._cancelExistingSubscription(),this.errors=this._runValidator(),this.status=this._calculateStatus(),(this.status===Zv||this.status===_g)&&this._runAsyncValidator(t.emitEvent)),!1!==t.emitEvent&&(this.valueChanges.emit(this.value),this.statusChanges.emit(this.status)),this._parent&&!t.onlySelf&&this._parent.updateValueAndValidity(t)}_updateTreeValidity(t={emitEvent:!0}){this._forEachChild(e=>e._updateTreeValidity(t)),this.updateValueAndValidity({onlySelf:!0,emitEvent:t.emitEvent})}_setInitialStatus(){this.status=this._allControlsDisabled()?Kv:Zv}_runValidator(){return this.validator?this.validator(this):null}_runAsyncValidator(t){if(this.asyncValidator){this.status=_g,this._hasOwnPendingAsyncValidator=!0;let e=G9(this.asyncValidator(this));this._asyncValidationSubscription=e.subscribe(i=>{this._hasOwnPendingAsyncValidator=!1,this.setErrors(i,{emitEvent:t})})}}_cancelExistingSubscription(){this._asyncValidationSubscription&&(this._asyncValidationSubscription.unsubscribe(),this._hasOwnPendingAsyncValidator=!1)}setErrors(t,e={}){this.errors=t,this._updateControlsErrors(!1!==e.emitEvent)}get(t){let e=t;return null==e||(Array.isArray(e)||(e=e.split(".")),0===e.length)?null:e.reduce((i,r)=>i&&i._find(r),this)}getError(t,e){let i=e?this.get(e):this;return i&&i.errors?i.errors[t]:null}hasError(t,e){return!!this.getError(t,e)}get root(){let t=this;for(;t._parent;)t=t._parent;return t}_updateControlsErrors(t){this.status=this._calculateStatus(),t&&this.statusChanges.emit(this.status),this._parent&&this._parent._updateControlsErrors(t)}_initObservables(){this.valueChanges=new F,this.statusChanges=new F}_calculateStatus(){return this._allControlsDisabled()?Kv:this.errors?eE:this._hasOwnPendingAsyncValidator||this._anyControlsHaveStatus(_g)?_g:this._anyControlsHaveStatus(eE)?eE:Zv}_anyControlsHaveStatus(t){return this._anyControls(e=>e.status===t)}_anyControlsDirty(){return this._anyControls(t=>t.dirty)}_anyControlsTouched(){return this._anyControls(t=>t.touched)}_updatePristine(t={}){this.pristine=!this._anyControlsDirty(),this._parent&&!t.onlySelf&&this._parent._updatePristine(t)}_updateTouched(t={}){this.touched=this._anyControlsTouched(),this._parent&&!t.onlySelf&&this._parent._updateTouched(t)}_registerOnCollectionChange(t){this._onCollectionChange=t}_setUpdateStrategy(t){dE(t)&&null!=t.updateOn&&(this._updateOn=t.updateOn)}_parentMarkedDirty(t){return!t&&!(!this._parent||!this._parent.dirty)&&!this._parent._anyControlsDirty()}_find(t){return null}_assignValidators(t){this._rawValidators=Array.isArray(t)?t.slice():t,this._composedValidatorFn=function(n){return Array.isArray(n)?z2(n):n||null}(this._rawValidators)}_assignAsyncValidators(t){this._rawAsyncValidators=Array.isArray(t)?t.slice():t,this._composedAsyncValidatorFn=function(n){return Array.isArray(n)?U2(n):n||null}(this._rawAsyncValidators)}},oE=class extends rE{constructor(t,e,i){super($9(e),eq(i,e)),this.controls=t,this._initObservables(),this._setUpdateStrategy(e),this._setUpControls(),this.updateValueAndValidity({onlySelf:!0,emitEvent:!!this.asyncValidator})}registerControl(t,e){return this.controls[t]?this.controls[t]:(this.controls[t]=e,e.setParent(this),e._registerOnCollectionChange(this._onCollectionChange),e)}addControl(t,e,i={}){this.registerControl(t,e),this.updateValueAndValidity({emitEvent:i.emitEvent}),this._onCollectionChange()}removeControl(t,e={}){this.controls[t]&&this.controls[t]._registerOnCollectionChange(()=>{}),delete this.controls[t],this.updateValueAndValidity({emitEvent:e.emitEvent}),this._onCollectionChange()}setControl(t,e,i={}){this.controls[t]&&this.controls[t]._registerOnCollectionChange(()=>{}),delete this.controls[t],e&&this.registerControl(t,e),this.updateValueAndValidity({emitEvent:i.emitEvent}),this._onCollectionChange()}contains(t){return this.controls.hasOwnProperty(t)&&this.controls[t].enabled}setValue(t,e={}){(function(n,t,e){n._forEachChild((i,r)=>{if(void 0===e[r])throw new yt(1002,H2?function(n,t){return`Must supply a value for form control ${J9(n,t)}`}(t,r):"")})})(this,!0,t),Object.keys(t).forEach(i=>{(function(n,t,e){let i=n.controls;if(!(t?Object.keys(i):i).length)throw new yt(1e3,H2?function(n){return`\n    There are no form controls registered with this ${n?"group":"array"} yet. If you're using ngModel,\n    you may want to check next tick (e.g. use setTimeout).\n  `}(t):"");if(!i[e])throw new yt(1001,H2?function(n,t){return`Cannot find form control ${J9(n,t)}`}(t,e):"")})(this,!0,i),this.controls[i].setValue(t[i],{onlySelf:!0,emitEvent:e.emitEvent})}),this.updateValueAndValidity(e)}patchValue(t,e={}){null!=t&&(Object.keys(t).forEach(i=>{let r=this.controls[i];r&&r.patchValue(t[i],{onlySelf:!0,emitEvent:e.emitEvent})}),this.updateValueAndValidity(e))}reset(t={},e={}){this._forEachChild((i,r)=>{i.reset(t[r],{onlySelf:!0,emitEvent:e.emitEvent})}),this._updatePristine(e),this._updateTouched(e),this.updateValueAndValidity(e)}getRawValue(){return this._reduceChildren({},(t,e,i)=>(t[i]=e.getRawValue(),t))}_syncPendingControls(){let t=this._reduceChildren(!1,(e,i)=>!!i._syncPendingControls()||e);return t&&this.updateValueAndValidity({onlySelf:!0}),t}_forEachChild(t){Object.keys(this.controls).forEach(e=>{let i=this.controls[e];i&&t(i,e)})}_setUpControls(){this._forEachChild(t=>{t.setParent(this),t._registerOnCollectionChange(this._onCollectionChange)})}_updateValue(){this.value=this._reduceValue()}_anyControls(t){for(let[e,i]of Object.entries(this.controls))if(this.contains(e)&&t(i))return!0;return!1}_reduceValue(){return this._reduceChildren({},(e,i,r)=>((i.enabled||this.disabled)&&(e[r]=i.value),e))}_reduceChildren(t,e){let i=t;return this._forEachChild((r,o)=>{i=e(i,r,o)}),i}_allControlsDisabled(){for(let t of Object.keys(this.controls))if(this.controls[t].enabled)return!1;return Object.keys(this.controls).length>0||this.disabled}_find(t){return this.controls.hasOwnProperty(t)?this.controls[t]:null}},Df=new ie("CallSetDisabledState",{providedIn:"root",factory:()=>ey}),ey="always";function uE(n,t){return[...t.path,n]}function $v(n,t,e=ey){j2(n,t),t.valueAccessor.writeValue(n.value),(n.disabled||"always"===e)&&t.valueAccessor.setDisabledState?.(n.disabled),function(n,t){t.valueAccessor.registerOnChange(e=>{n._pendingValue=e,n._pendingChange=!0,n._pendingDirty=!0,"change"===n.updateOn&&tq(n,t)})}(n,t),function(n,t){let e=(i,r)=>{t.valueAccessor.writeValue(i),r&&t.viewToModelUpdate(i)};n.registerOnChange(e),t._registerOnDestroy(()=>{n._unregisterOnChange(e)})}(n,t),function(n,t){t.valueAccessor.registerOnTouched(()=>{n._pendingTouched=!0,"blur"===n.updateOn&&n._pendingChange&&tq(n,t),"submit"!==n.updateOn&&n.markAsTouched()})}(n,t),function(n,t){if(t.valueAccessor.setDisabledState){let e=i=>{t.valueAccessor.setDisabledState(i)};n.registerOnDisabledChange(e),t._registerOnDestroy(()=>{n._unregisterOnDisabledChange(e)})}}(n,t)}function sE(n,t,e=!0){let i=()=>{};t.valueAccessor&&(t.valueAccessor.registerOnChange(i),t.valueAccessor.registerOnTouched(i)),lE(n,t),n&&(t._invokeOnDestroyCallbacks(),n._registerOnCollectionChange(()=>{}))}function aE(n,t){n.forEach(e=>{e.registerOnValidatorChange&&e.registerOnValidatorChange(t)})}function j2(n,t){let e=Z9(n);null!==t.validator?n.setValidators(E9(e,t.validator)):"function"==typeof e&&n.setValidators([e]);let i=K9(n);null!==t.asyncValidator?n.setAsyncValidators(E9(i,t.asyncValidator)):"function"==typeof i&&n.setAsyncValidators([i]);let r=()=>n.updateValueAndValidity();aE(t._rawValidators,r),aE(t._rawAsyncValidators,r)}function lE(n,t){let e=!1;if(null!==n){if(null!==t.validator){let r=Z9(n);if(Array.isArray(r)&&r.length>0){let o=r.filter(s=>s!==t.validator);o.length!==r.length&&(e=!0,n.setValidators(o))}}if(null!==t.asyncValidator){let r=K9(n);if(Array.isArray(r)&&r.length>0){let o=r.filter(s=>s!==t.asyncValidator);o.length!==r.length&&(e=!0,n.setAsyncValidators(o))}}}let i=()=>{};return aE(t._rawValidators,i),aE(t._rawAsyncValidators,i),e}function tq(n,t){n._pendingDirty&&n.markAsDirty(),n.setValue(n._pendingValue,{emitModelToViewChange:!1}),t.viewToModelUpdate(n._pendingValue),n._pendingChange=!1}function nq(n,t){j2(n,t)}function G2(n,t){if(!n.hasOwnProperty("model"))return!1;let e=n.model;return!!e.isFirstChange()||!Object.is(t,e.currentValue)}function iq(n,t){n._syncPendingControls(),t.forEach(e=>{let i=e.control;"submit"===i.updateOn&&i._pendingChange&&(e.viewToModelUpdate(i._pendingValue),i._pendingChange=!1)})}function W2(n,t){if(!t)return null;let e,i,r;return Array.isArray(t),t.forEach(o=>{o.constructor===bg?e=o:function(n){return Object.getPrototypeOf(n.constructor)===Tf}(o)?i=o:r=o}),r||i||e||null}var Vve={provide:Xo,useExisting:$n(()=>vg)},Jv=Promise.resolve(),vg=(()=>{class n extends Xo{constructor(e,i,r){super(),this.callSetDisabledState=r,this.submitted=!1,this._directives=new Set,this.ngSubmit=new F,this.form=new oE({},z2(e),U2(i))}ngAfterViewInit(){this._setUpdateStrategy()}get formDirective(){return this}get control(){return this.form}get path(){return[]}get controls(){return this.form.controls}addControl(e){Jv.then(()=>{let i=this._findContainer(e.path);e.control=i.registerControl(e.name,e.control),$v(e.control,e,this.callSetDisabledState),e.control.updateValueAndValidity({emitEvent:!1}),this._directives.add(e)})}getControl(e){return this.form.get(e.path)}removeControl(e){Jv.then(()=>{let i=this._findContainer(e.path);i&&i.removeControl(e.name),this._directives.delete(e)})}addFormGroup(e){Jv.then(()=>{let i=this._findContainer(e.path),r=new oE({});nq(r,e),i.registerControl(e.name,r),r.updateValueAndValidity({emitEvent:!1})})}removeFormGroup(e){Jv.then(()=>{let i=this._findContainer(e.path);i&&i.removeControl(e.name)})}getFormGroup(e){return this.form.get(e.path)}updateModel(e,i){Jv.then(()=>{this.form.get(e.path).setValue(i)})}setValue(e){this.control.setValue(e)}onSubmit(e){return this.submitted=!0,iq(this.form,this._directives),this.ngSubmit.emit(e),"dialog"===e?.target?.method}onReset(){this.resetForm()}resetForm(e){this.form.reset(e),this.submitted=!1}_setUpdateStrategy(){this.options&&null!=this.options.updateOn&&(this.form._updateOn=this.options.updateOn)}_findContainer(e){return e.pop(),e.length?this.form.get(e):this.form}}return n.\u0275fac=function(e){return new(e||n)(C(wo,10),C(Hu,10),C(Df,8))},n.\u0275dir=we({type:n,selectors:[["form",3,"ngNoForm","",3,"formGroup",""],["ng-form"],["","ngForm",""]],hostBindings:function(e,i){1&e&&I("submit",function(o){return i.onSubmit(o)})("reset",function(){return i.onReset()})},inputs:{options:["ngFormOptions","options"]},outputs:{ngSubmit:"ngSubmit"},exportAs:["ngForm"],features:[Qt([Vve]),Ke]}),n})();function I9(n,t){let e=n.indexOf(t);e>-1&&n.splice(e,1)}function A9(n){return"object"==typeof n&&null!==n&&2===Object.keys(n).length&&"value"in n&&"disabled"in n}var ty=class extends rE{constructor(t=null,e,i){super($9(e),eq(i,e)),this.defaultValue=null,this._onChange=[],this._pendingChange=!1,this._applyFormState(t),this._setUpdateStrategy(e),this._initObservables(),this.updateValueAndValidity({onlySelf:!0,emitEvent:!!this.asyncValidator}),dE(e)&&(e.nonNullable||e.initialValueIsDefault)&&(this.defaultValue=A9(t)?t.value:t)}setValue(t,e={}){this.value=this._pendingValue=t,this._onChange.length&&!1!==e.emitModelToViewChange&&this._onChange.forEach(i=>i(this.value,!1!==e.emitViewToModelChange)),this.updateValueAndValidity(e)}patchValue(t,e={}){this.setValue(t,e)}reset(t=this.defaultValue,e={}){this._applyFormState(t),this.markAsPristine(e),this.markAsUntouched(e),this.setValue(this.value,e),this._pendingChange=!1}_updateValue(){}_anyControls(t){return!1}_allControlsDisabled(){return this.disabled}registerOnChange(t){this._onChange.push(t)}_unregisterOnChange(t){I9(this._onChange,t)}registerOnDisabledChange(t){this._onDisabledChange.push(t)}_unregisterOnDisabledChange(t){I9(this._onDisabledChange,t)}_forEachChild(t){}_syncPendingControls(){return!("submit"!==this.updateOn||(this._pendingDirty&&this.markAsDirty(),this._pendingTouched&&this.markAsTouched(),!this._pendingChange)||(this.setValue(this._pendingValue,{onlySelf:!0,emitModelToViewChange:!1}),0))}_applyFormState(t){A9(t)?(this.value=this._pendingValue=t.value,t.disabled?this.disable({onlySelf:!0,emitEvent:!1}):this.enable({onlySelf:!0,emitEvent:!1})):this.value=this._pendingValue=t}},rq=(()=>{class n extends Xo{ngOnInit(){this._checkParentType(),this.formDirective.addFormGroup(this)}ngOnDestroy(){this.formDirective&&this.formDirective.removeFormGroup(this)}get control(){return this.formDirective.getFormGroup(this)}get path(){return uE(null==this.name?this.name:this.name.toString(),this._parent)}get formDirective(){return this._parent?this._parent.formDirective:null}_checkParentType(){}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275dir=we({type:n,features:[Ke]}),n})(),zve={provide:Xo,useExisting:$n(()=>Uve)},Uve=(()=>{class n extends rq{constructor(e,i,r){super(),this._parent=e,this._setValidators(i),this._setAsyncValidators(r)}_checkParentType(){}}return n.\u0275fac=function(e){return new(e||n)(C(Xo,5),C(wo,10),C(Hu,10))},n.\u0275dir=we({type:n,selectors:[["","ngModelGroup",""]],inputs:{name:["ngModelGroup","name"]},exportAs:["ngModelGroup"],features:[Qt([zve]),Ke]}),n})(),jve={provide:Gs,useExisting:$n(()=>q2)},R9=Promise.resolve(),q2=(()=>{class n extends Gs{constructor(e,i,r,o,s,a){super(),this._changeDetectorRef=s,this.callSetDisabledState=a,this.control=new ty,this._registered=!1,this.update=new F,this._parent=e,this._setValidators(i),this._setAsyncValidators(r),this.valueAccessor=W2(0,o)}ngOnChanges(e){if(this._checkForErrors(),!this._registered||"name"in e){if(this._registered&&(this._checkName(),this.formDirective)){let i=e.name.previousValue;this.formDirective.removeControl({name:i,path:this._getPath(i)})}this._setUpControl()}"isDisabled"in e&&this._updateDisabled(e),G2(e,this.viewModel)&&(this._updateValue(this.model),this.viewModel=this.model)}ngOnDestroy(){this.formDirective&&this.formDirective.removeControl(this)}get path(){return this._getPath(this.name)}get formDirective(){return this._parent?this._parent.formDirective:null}viewToModelUpdate(e){this.viewModel=e,this.update.emit(e)}_setUpControl(){this._setUpdateStrategy(),this._isStandalone()?this._setUpStandalone():this.formDirective.addControl(this),this._registered=!0}_setUpdateStrategy(){this.options&&null!=this.options.updateOn&&(this.control._updateOn=this.options.updateOn)}_isStandalone(){return!this._parent||!(!this.options||!this.options.standalone)}_setUpStandalone(){$v(this.control,this,this.callSetDisabledState),this.control.updateValueAndValidity({emitEvent:!1})}_checkForErrors(){this._isStandalone()||this._checkParentType(),this._checkName()}_checkParentType(){}_checkName(){this.options&&this.options.name&&(this.name=this.options.name),this._isStandalone()}_updateValue(e){R9.then(()=>{this.control.setValue(e,{emitViewToModelChange:!1}),this._changeDetectorRef?.markForCheck()})}_updateDisabled(e){let i=e.isDisabled.currentValue,r=0!==i&&$M(i);R9.then(()=>{r&&!this.control.disabled?this.control.disable():!r&&this.control.disabled&&this.control.enable(),this._changeDetectorRef?.markForCheck()})}_getPath(e){return this._parent?uE(e,this._parent):[e]}}return n.\u0275fac=function(e){return new(e||n)(C(Xo,9),C(wo,10),C(Hu,10),C(Mo,10),C($t,8),C(Df,8))},n.\u0275dir=we({type:n,selectors:[["","ngModel","",3,"formControlName","",3,"formControl",""]],inputs:{name:"name",isDisabled:["disabled","isDisabled"],model:["ngModel","model"],options:["ngModelOptions","options"]},outputs:{update:"ngModelChange"},exportAs:["ngModel"],features:[Qt([jve]),Ke,Gt]}),n})(),Gve={provide:Mo,useExisting:$n(()=>Y2),multi:!0},Y2=(()=>{class n extends Tf{writeValue(e){this.setProperty("value",e??"")}registerOnChange(e){this.onChange=i=>{e(""==i?null:parseFloat(i))}}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275dir=we({type:n,selectors:[["input","type","number","formControlName",""],["input","type","number","formControl",""],["input","type","number","ngModel",""]],hostBindings:function(e,i){1&e&&I("input",function(o){return i.onChange(o.target.value)})("blur",function(){return i.onTouched()})},features:[Qt([Gve]),Ke]}),n})(),Wve={provide:Mo,useExisting:$n(()=>Yve),multi:!0},oq=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({}),n})(),qve=(()=>{class n{constructor(){this._accessors=[]}add(e,i){this._accessors.push([e,i])}remove(e){for(let i=this._accessors.length-1;i>=0;--i)if(this._accessors[i][1]===e)return void this._accessors.splice(i,1)}select(e){this._accessors.forEach(i=>{this._isSameGroup(i,e)&&i[1]!==e&&i[1].fireUncheck(e.value)})}_isSameGroup(e,i){return!!e[0].control&&e[0]._parent===i._control._parent&&e[1].name===i.name}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:oq}),n})(),Yve=(()=>{class n extends Tf{constructor(e,i,r,o){super(e,i),this._registry=r,this._injector=o,this.setDisabledStateFired=!1,this.onChange=()=>{},this.callSetDisabledState=ai(Df,{optional:!0})??ey}ngOnInit(){this._control=this._injector.get(Gs),this._checkName(),this._registry.add(this._control,this)}ngOnDestroy(){this._registry.remove(this)}writeValue(e){this._state=e===this.value,this.setProperty("checked",this._state)}registerOnChange(e){this._fn=e,this.onChange=()=>{e(this.value),this._registry.select(this)}}setDisabledState(e){(this.setDisabledStateFired||e||"whenDisabledForLegacyCode"===this.callSetDisabledState)&&this.setProperty("disabled",e),this.setDisabledStateFired=!0}fireUncheck(e){this.writeValue(e)}_checkName(){!this.name&&this.formControlName&&(this.name=this.formControlName)}}return n.\u0275fac=function(e){return new(e||n)(C(mc),C(Me),C(qve),C(Mi))},n.\u0275dir=we({type:n,selectors:[["input","type","radio","formControlName",""],["input","type","radio","formControl",""],["input","type","radio","ngModel",""]],hostBindings:function(e,i){1&e&&I("change",function(){return i.onChange()})("blur",function(){return i.onTouched()})},inputs:{name:"name",formControlName:"formControlName",value:"value"},features:[Qt([Wve]),Ke]}),n})(),Xve={provide:Mo,useExisting:$n(()=>Qve),multi:!0},Qve=(()=>{class n extends Tf{writeValue(e){this.setProperty("value",parseFloat(e))}registerOnChange(e){this.onChange=i=>{e(""==i?null:parseFloat(i))}}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275dir=we({type:n,selectors:[["input","type","range","formControlName",""],["input","type","range","formControl",""],["input","type","range","ngModel",""]],hostBindings:function(e,i){1&e&&I("change",function(o){return i.onChange(o.target.value)})("input",function(o){return i.onChange(o.target.value)})("blur",function(){return i.onTouched()})},features:[Qt([Xve]),Ke]}),n})(),X2=new ie("NgModelWithFormControlWarning"),Zve={provide:Gs,useExisting:$n(()=>Q2)},Q2=(()=>{class n extends Gs{set isDisabled(e){}constructor(e,i,r,o,s){super(),this._ngModelWarningConfig=o,this.callSetDisabledState=s,this.update=new F,this._ngModelWarningSent=!1,this._setValidators(e),this._setAsyncValidators(i),this.valueAccessor=W2(0,r)}ngOnChanges(e){if(this._isControlChanged(e)){let i=e.form.previousValue;i&&sE(i,this,!1),$v(this.form,this,this.callSetDisabledState),this.form.updateValueAndValidity({emitEvent:!1})}G2(e,this.viewModel)&&(this.form.setValue(this.model),this.viewModel=this.model)}ngOnDestroy(){this.form&&sE(this.form,this,!1)}get path(){return[]}get control(){return this.form}viewToModelUpdate(e){this.viewModel=e,this.update.emit(e)}_isControlChanged(e){return e.hasOwnProperty("form")}}return n._ngModelWarningSentOnce=!1,n.\u0275fac=function(e){return new(e||n)(C(wo,10),C(Hu,10),C(Mo,10),C(X2,8),C(Df,8))},n.\u0275dir=we({type:n,selectors:[["","formControl",""]],inputs:{form:["formControl","form"],isDisabled:["disabled","isDisabled"],model:["ngModel","model"]},outputs:{update:"ngModelChange"},exportAs:["ngForm"],features:[Qt([Zve]),Ke,Gt]}),n})(),Kve={provide:Xo,useExisting:$n(()=>yg)},yg=(()=>{class n extends Xo{constructor(e,i,r){super(),this.callSetDisabledState=r,this.submitted=!1,this._onCollectionChange=()=>this._updateDomValue(),this.directives=[],this.form=null,this.ngSubmit=new F,this._setValidators(e),this._setAsyncValidators(i)}ngOnChanges(e){this._checkFormPresent(),e.hasOwnProperty("form")&&(this._updateValidators(),this._updateDomValue(),this._updateRegistrations(),this._oldForm=this.form)}ngOnDestroy(){this.form&&(lE(this.form,this),this.form._onCollectionChange===this._onCollectionChange&&this.form._registerOnCollectionChange(()=>{}))}get formDirective(){return this}get control(){return this.form}get path(){return[]}addControl(e){let i=this.form.get(e.path);return $v(i,e,this.callSetDisabledState),i.updateValueAndValidity({emitEvent:!1}),this.directives.push(e),i}getControl(e){return this.form.get(e.path)}removeControl(e){sE(e.control||null,e,!1),function(n,t){let e=n.indexOf(t);e>-1&&n.splice(e,1)}(this.directives,e)}addFormGroup(e){this._setUpFormContainer(e)}removeFormGroup(e){this._cleanUpFormContainer(e)}getFormGroup(e){return this.form.get(e.path)}addFormArray(e){this._setUpFormContainer(e)}removeFormArray(e){this._cleanUpFormContainer(e)}getFormArray(e){return this.form.get(e.path)}updateModel(e,i){this.form.get(e.path).setValue(i)}onSubmit(e){return this.submitted=!0,iq(this.form,this.directives),this.ngSubmit.emit(e),"dialog"===e?.target?.method}onReset(){this.resetForm()}resetForm(e){this.form.reset(e),this.submitted=!1}_updateDomValue(){this.directives.forEach(e=>{let i=e.control,r=this.form.get(e.path);i!==r&&(sE(i||null,e),(n=>n instanceof ty)(r)&&($v(r,e,this.callSetDisabledState),e.control=r))}),this.form._updateTreeValidity({emitEvent:!1})}_setUpFormContainer(e){let i=this.form.get(e.path);nq(i,e),i.updateValueAndValidity({emitEvent:!1})}_cleanUpFormContainer(e){if(this.form){let i=this.form.get(e.path);i&&function(n,t){return lE(n,t)}(i,e)&&i.updateValueAndValidity({emitEvent:!1})}}_updateRegistrations(){this.form._registerOnCollectionChange(this._onCollectionChange),this._oldForm&&this._oldForm._registerOnCollectionChange(()=>{})}_updateValidators(){j2(this.form,this),this._oldForm&&lE(this._oldForm,this)}_checkFormPresent(){}}return n.\u0275fac=function(e){return new(e||n)(C(wo,10),C(Hu,10),C(Df,8))},n.\u0275dir=we({type:n,selectors:[["","formGroup",""]],hostBindings:function(e,i){1&e&&I("submit",function(o){return i.onSubmit(o)})("reset",function(){return i.onReset()})},inputs:{form:["formGroup","form"]},outputs:{ngSubmit:"ngSubmit"},exportAs:["ngForm"],features:[Qt([Kve]),Ke,Gt]}),n})(),Jve={provide:Xo,useExisting:$n(()=>sq)},sq=(()=>{class n extends rq{constructor(e,i,r){super(),this._parent=e,this._setValidators(i),this._setAsyncValidators(r)}_checkParentType(){lq(this._parent)}}return n.\u0275fac=function(e){return new(e||n)(C(Xo,13),C(wo,10),C(Hu,10))},n.\u0275dir=we({type:n,selectors:[["","formGroupName",""]],inputs:{name:["formGroupName","name"]},features:[Qt([Jve]),Ke]}),n})(),$ve={provide:Xo,useExisting:$n(()=>aq)},aq=(()=>{class n extends Xo{constructor(e,i,r){super(),this._parent=e,this._setValidators(i),this._setAsyncValidators(r)}ngOnInit(){this._checkParentType(),this.formDirective.addFormArray(this)}ngOnDestroy(){this.formDirective&&this.formDirective.removeFormArray(this)}get control(){return this.formDirective.getFormArray(this)}get formDirective(){return this._parent?this._parent.formDirective:null}get path(){return uE(null==this.name?this.name:this.name.toString(),this._parent)}_checkParentType(){lq(this._parent)}}return n.\u0275fac=function(e){return new(e||n)(C(Xo,13),C(wo,10),C(Hu,10))},n.\u0275dir=we({type:n,selectors:[["","formArrayName",""]],inputs:{name:["formArrayName","name"]},features:[Qt([$ve]),Ke]}),n})();function lq(n){return!(n instanceof sq||n instanceof yg||n instanceof aq)}var eye={provide:Gs,useExisting:$n(()=>tye)},tye=(()=>{class n extends Gs{set isDisabled(e){}constructor(e,i,r,o,s){super(),this._ngModelWarningConfig=s,this._added=!1,this.update=new F,this._ngModelWarningSent=!1,this._parent=e,this._setValidators(i),this._setAsyncValidators(r),this.valueAccessor=W2(0,o)}ngOnChanges(e){this._added||this._setUpControl(),G2(e,this.viewModel)&&(this.viewModel=this.model,this.formDirective.updateModel(this,this.model))}ngOnDestroy(){this.formDirective&&this.formDirective.removeControl(this)}viewToModelUpdate(e){this.viewModel=e,this.update.emit(e)}get path(){return uE(null==this.name?this.name:this.name.toString(),this._parent)}get formDirective(){return this._parent?this._parent.formDirective:null}_checkParentType(){}_setUpControl(){this._checkParentType(),this.control=this.formDirective.addControl(this),this._added=!0}}return n._ngModelWarningSentOnce=!1,n.\u0275fac=function(e){return new(e||n)(C(Xo,13),C(wo,10),C(Hu,10),C(Mo,10),C(X2,8))},n.\u0275dir=we({type:n,selectors:[["","formControlName",""]],inputs:{name:["formControlName","name"],isDisabled:["disabled","isDisabled"],model:["ngModel","model"]},outputs:{update:"ngModelChange"},features:[Qt([eye]),Ke,Gt]}),n})(),nye={provide:Mo,useExisting:$n(()=>dq),multi:!0};function cq(n,t){return null==n?`${t}`:(t&&"object"==typeof t&&(t="Object"),`${n}: ${t}`.slice(0,50))}var dq=(()=>{class n extends Tf{constructor(){super(...arguments),this._optionMap=new Map,this._idCounter=0,this._compareWith=Object.is}set compareWith(e){this._compareWith=e}writeValue(e){this.value=e;let r=cq(this._getOptionId(e),e);this.setProperty("value",r)}registerOnChange(e){this.onChange=i=>{this.value=this._getOptionValue(i),e(this.value)}}_registerOption(){return(this._idCounter++).toString()}_getOptionId(e){for(let i of Array.from(this._optionMap.keys()))if(this._compareWith(this._optionMap.get(i),e))return i;return null}_getOptionValue(e){let i=function(n){return n.split(":")[0]}(e);return this._optionMap.has(i)?this._optionMap.get(i):e}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275dir=we({type:n,selectors:[["select","formControlName","",3,"multiple",""],["select","formControl","",3,"multiple",""],["select","ngModel","",3,"multiple",""]],hostBindings:function(e,i){1&e&&I("change",function(o){return i.onChange(o.target.value)})("blur",function(){return i.onTouched()})},inputs:{compareWith:"compareWith"},features:[Qt([nye]),Ke]}),n})(),uq=(()=>{class n{constructor(e,i,r){this._element=e,this._renderer=i,this._select=r,this._select&&(this.id=this._select._registerOption())}set ngValue(e){null!=this._select&&(this._select._optionMap.set(this.id,e),this._setElementValue(cq(this.id,e)),this._select.writeValue(this._select.value))}set value(e){this._setElementValue(e),this._select&&this._select.writeValue(this._select.value)}_setElementValue(e){this._renderer.setProperty(this._element.nativeElement,"value",e)}ngOnDestroy(){this._select&&(this._select._optionMap.delete(this.id),this._select.writeValue(this._select.value))}}return n.\u0275fac=function(e){return new(e||n)(C(Me),C(mc),C(dq,9))},n.\u0275dir=we({type:n,selectors:[["option"]],inputs:{ngValue:"ngValue",value:"value"}}),n})(),rye={provide:Mo,useExisting:$n(()=>pq),multi:!0};function P9(n,t){return null==n?`${t}`:("string"==typeof t&&(t=`'${t}'`),t&&"object"==typeof t&&(t="Object"),`${n}: ${t}`.slice(0,50))}var pq=(()=>{class n extends Tf{constructor(){super(...arguments),this._optionMap=new Map,this._idCounter=0,this._compareWith=Object.is}set compareWith(e){this._compareWith=e}writeValue(e){let i;if(this.value=e,Array.isArray(e)){let r=e.map(o=>this._getOptionId(o));i=(o,s)=>{o._setSelected(r.indexOf(s.toString())>-1)}}else i=(r,o)=>{r._setSelected(!1)};this._optionMap.forEach(i)}registerOnChange(e){this.onChange=i=>{let r=[],o=i.selectedOptions;if(void 0!==o){let s=o;for(let a=0;a<s.length;a++){let c=this._getOptionValue(s[a].value);r.push(c)}}else{let s=i.options;for(let a=0;a<s.length;a++){let l=s[a];if(l.selected){let c=this._getOptionValue(l.value);r.push(c)}}}this.value=r,e(r)}}_registerOption(e){let i=(this._idCounter++).toString();return this._optionMap.set(i,e),i}_getOptionId(e){for(let i of Array.from(this._optionMap.keys()))if(this._compareWith(this._optionMap.get(i)._value,e))return i;return null}_getOptionValue(e){let i=function(n){return n.split(":")[0]}(e);return this._optionMap.has(i)?this._optionMap.get(i)._value:e}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275dir=we({type:n,selectors:[["select","multiple","","formControlName",""],["select","multiple","","formControl",""],["select","multiple","","ngModel",""]],hostBindings:function(e,i){1&e&&I("change",function(o){return i.onChange(o.target)})("blur",function(){return i.onTouched()})},inputs:{compareWith:"compareWith"},features:[Qt([rye]),Ke]}),n})(),fq=(()=>{class n{constructor(e,i,r){this._element=e,this._renderer=i,this._select=r,this._select&&(this.id=this._select._registerOption(this))}set ngValue(e){null!=this._select&&(this._value=e,this._setElementValue(P9(this.id,e)),this._select.writeValue(this._select.value))}set value(e){this._select?(this._value=e,this._setElementValue(P9(this.id,e)),this._select.writeValue(this._select.value)):this._setElementValue(e)}_setElementValue(e){this._renderer.setProperty(this._element.nativeElement,"value",e)}_setSelected(e){this._renderer.setProperty(this._element.nativeElement,"selected",e)}ngOnDestroy(){this._select&&(this._select._optionMap.delete(this.id),this._select.writeValue(this._select.value))}}return n.\u0275fac=function(e){return new(e||n)(C(Me),C(mc),C(pq,9))},n.\u0275dir=we({type:n,selectors:[["option"]],inputs:{ngValue:"ngValue",value:"value"}}),n})();function mq(n){return"number"==typeof n?n:parseInt(n,10)}function hq(n){return"number"==typeof n?n:parseFloat(n)}var If=(()=>{class n{constructor(){this._validator=tE}ngOnChanges(e){if(this.inputName in e){let i=this.normalizeInput(e[this.inputName].currentValue);this._enabled=this.enabled(i),this._validator=this._enabled?this.createValidator(i):tE,this._onChange&&this._onChange()}}validate(e){return this._validator(e)}registerOnValidatorChange(e){this._onChange=e}enabled(e){return null!=e}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275dir=we({type:n,features:[Gt]}),n})(),sye={provide:wo,useExisting:$n(()=>aye),multi:!0},aye=(()=>{class n extends If{constructor(){super(...arguments),this.inputName="max",this.normalizeInput=e=>hq(e),this.createValidator=e=>N9(e)}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275dir=we({type:n,selectors:[["input","type","number","max","","formControlName",""],["input","type","number","max","","formControl",""],["input","type","number","max","","ngModel",""]],hostVars:1,hostBindings:function(e,i){2&e&&Be("max",i._enabled?i.max:null)},inputs:{max:"max"},features:[Qt([sye]),Ke]}),n})(),lye={provide:wo,useExisting:$n(()=>cye),multi:!0},cye=(()=>{class n extends If{constructor(){super(...arguments),this.inputName="min",this.normalizeInput=e=>hq(e),this.createValidator=e=>F9(e)}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275dir=we({type:n,selectors:[["input","type","number","min","","formControlName",""],["input","type","number","min","","formControl",""],["input","type","number","min","","ngModel",""]],hostVars:1,hostBindings:function(e,i){2&e&&Be("min",i._enabled?i.min:null)},inputs:{min:"min"},features:[Qt([lye]),Ke]}),n})(),dye={provide:wo,useExisting:$n(()=>gq),multi:!0},uye={provide:wo,useExisting:$n(()=>Z2),multi:!0},gq=(()=>{class n extends If{constructor(){super(...arguments),this.inputName="required",this.normalizeInput=$M,this.createValidator=e=>L9}enabled(e){return e}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275dir=we({type:n,selectors:[["","required","","formControlName","",3,"type","checkbox"],["","required","","formControl","",3,"type","checkbox"],["","required","","ngModel","",3,"type","checkbox"]],hostVars:1,hostBindings:function(e,i){2&e&&Be("required",i._enabled?"":null)},inputs:{required:"required"},features:[Qt([dye]),Ke]}),n})(),Z2=(()=>{class n extends gq{constructor(){super(...arguments),this.createValidator=e=>B9}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275dir=we({type:n,selectors:[["input","type","checkbox","required","","formControlName",""],["input","type","checkbox","required","","formControl",""],["input","type","checkbox","required","","ngModel",""]],hostVars:1,hostBindings:function(e,i){2&e&&Be("required",i._enabled?"":null)},features:[Qt([uye]),Ke]}),n})(),pye={provide:wo,useExisting:$n(()=>fye),multi:!0},fye=(()=>{class n extends If{constructor(){super(...arguments),this.inputName="email",this.normalizeInput=$M,this.createValidator=e=>V9}enabled(e){return e}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275dir=we({type:n,selectors:[["","email","","formControlName",""],["","email","","formControl",""],["","email","","ngModel",""]],inputs:{email:"email"},features:[Qt([pye]),Ke]}),n})(),mye={provide:wo,useExisting:$n(()=>hye),multi:!0},hye=(()=>{class n extends If{constructor(){super(...arguments),this.inputName="minlength",this.normalizeInput=e=>mq(e),this.createValidator=e=>H9(e)}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275dir=we({type:n,selectors:[["","minlength","","formControlName",""],["","minlength","","formControl",""],["","minlength","","ngModel",""]],hostVars:1,hostBindings:function(e,i){2&e&&Be("minlength",i._enabled?i.minlength:null)},inputs:{minlength:"minlength"},features:[Qt([mye]),Ke]}),n})(),gye={provide:wo,useExisting:$n(()=>_ye),multi:!0},_ye=(()=>{class n extends If{constructor(){super(...arguments),this.inputName="maxlength",this.normalizeInput=e=>mq(e),this.createValidator=e=>z9(e)}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275dir=we({type:n,selectors:[["","maxlength","","formControlName",""],["","maxlength","","formControl",""],["","maxlength","","ngModel",""]],hostVars:1,hostBindings:function(e,i){2&e&&Be("maxlength",i._enabled?i.maxlength:null)},inputs:{maxlength:"maxlength"},features:[Qt([gye]),Ke]}),n})(),bye={provide:wo,useExisting:$n(()=>vye),multi:!0},vye=(()=>{class n extends If{constructor(){super(...arguments),this.inputName="pattern",this.normalizeInput=e=>e,this.createValidator=e=>U9(e)}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275dir=we({type:n,selectors:[["","pattern","","formControlName",""],["","pattern","","formControl",""],["","pattern","","ngModel",""]],hostVars:1,hostBindings:function(e,i){2&e&&Be("pattern",i._enabled?i.pattern:null)},inputs:{pattern:"pattern"},features:[Qt([bye]),Ke]}),n})(),_q=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[oq]}),n})(),xg=(new yl("15.2.9"),(()=>{class n{static withConfig(e){return{ngModule:n,providers:[{provide:Df,useValue:e.callSetDisabledState??ey}]}}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[_q]}),n})()),bq=(()=>{class n{static withConfig(e){return{ngModule:n,providers:[{provide:X2,useValue:e.warnOnNgModelWithFormControl??"always"},{provide:Df,useValue:e.callSetDisabledState??ey}]}}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[_q]}),n})(),yye=["trigger"],xye=["panel"];function Cye(n,t){if(1&n&&(h(0,"span",10),T(1),g()),2&n){let e=w();v(1),bt(e.placeholder)}}function Mye(n,t){if(1&n&&(h(0,"span",14),T(1),g()),2&n){let e=w(2);v(1),bt(e.triggerValue)}}function wye(n,t){1&n&&zt(0,0,["*ngSwitchCase","true"])}function Sye(n,t){1&n&&(h(0,"span",11),S(1,Mye,2,1,"span",12),S(2,wye,1,0,"ng-content",13),g()),2&n&&(_("ngSwitch",!!w().customTrigger),v(2),_("ngSwitchCase",!0))}function Eye(n,t){if(1&n){let e=ge();Nn(),Oo(),h(0,"div",15,16),I("@transformPanel.done",function(r){return X(e),Q(w()._panelDoneAnimatingStream.next(r.toState))})("keydown",function(r){return X(e),Q(w()._handleKeydown(r))}),zt(2,1),g()}if(2&n){let e=w();mb("mat-mdc-select-panel mdc-menu-surface mdc-menu-surface--open ",e._getPanelTheme(),""),_("ngClass",e.panelClass)("@transformPanel","showing"),Be("id",e.id+"-panel")("aria-multiselectable",e.multiple)("aria-label",e.ariaLabel||null)("aria-labelledby",e._getPanelAriaLabelledby())}}var Tye=[[["mat-select-trigger"]],"*"],Dye=["mat-select-trigger","*"],Iye={transformPanelWrap:_r("transformPanelWrap",[gi("* => void",Jp("@transformPanel",[Kp()],{optional:!0}))]),transformPanel:_r("transformPanel",[wi("void",rn({opacity:0,transform:"scale(1, 0.8)"})),gi("void => showing",Ci("120ms cubic-bezier(0, 0, 0.2, 1)",rn({opacity:1,transform:"scale(1, 1)"}))),gi("* => void",Ci("100ms linear",rn({opacity:0})))])},vq=0,yq=new ie("mat-select-scroll-strategy"),Rye=new ie("MAT_SELECT_CONFIG"),Pye={provide:yq,deps:[zi],useFactory:function(n){return()=>n.scrollStrategies.reposition()}},Oye=new ie("MatSelectTrigger"),kye=us(ku(so(B1(class{constructor(n,t,e,i,r){this._elementRef=n,this._defaultErrorStateMatcher=t,this._parentForm=e,this._parentFormGroup=i,this.ngControl=r,this.stateChanges=new Ie}})))),Fye=(()=>{class n extends kye{get focused(){return this._focused||this._panelOpen}get placeholder(){return this._placeholder}set placeholder(e){this._placeholder=e,this.stateChanges.next()}get required(){return this._required??this.ngControl?.control?.hasValidator(Ul.required)??!1}set required(e){this._required=Rt(e),this.stateChanges.next()}get multiple(){return this._multiple}set multiple(e){this._multiple=Rt(e)}get disableOptionCentering(){return this._disableOptionCentering}set disableOptionCentering(e){this._disableOptionCentering=Rt(e)}get compareWith(){return this._compareWith}set compareWith(e){this._compareWith=e,this._selectionModel&&this._initializeSelection()}get value(){return this._value}set value(e){this._assignValue(e)&&this._onChange(e)}get typeaheadDebounceInterval(){return this._typeaheadDebounceInterval}set typeaheadDebounceInterval(e){this._typeaheadDebounceInterval=_i(e)}get id(){return this._id}set id(e){this._id=e||this._uid,this.stateChanges.next()}constructor(e,i,r,o,s,a,l,c,d,u,p,f,m,b){super(s,o,l,c,u),this._viewportRuler=e,this._changeDetectorRef=i,this._ngZone=r,this._dir=a,this._parentFormField=d,this._liveAnnouncer=m,this._defaultOptions=b,this._panelOpen=!1,this._compareWith=(M,y)=>M===y,this._uid="mat-select-"+vq++,this._triggerAriaLabelledBy=null,this._destroy=new Ie,this._onChange=()=>{},this._onTouched=()=>{},this._valueId="mat-select-value-"+vq++,this._panelDoneAnimatingStream=new Ie,this._overlayPanelClass=this._defaultOptions?.overlayPanelClass||"",this._focused=!1,this.controlType="mat-select",this._multiple=!1,this._disableOptionCentering=this._defaultOptions?.disableOptionCentering??!1,this.ariaLabel="",this.optionSelectionChanges=ta(()=>{let M=this.options;return M?M.changes.pipe(qn(M),Jn(()=>tn(...M.map(y=>y.onSelectionChange)))):this._ngZone.onStable.pipe(Yt(1),Jn(()=>this.optionSelectionChanges))}),this.openedChange=new F,this._openedStream=this.openedChange.pipe(ke(M=>M),N(()=>{})),this._closedStream=this.openedChange.pipe(ke(M=>!M),N(()=>{})),this.selectionChange=new F,this.valueChange=new F,this.ngControl&&(this.ngControl.valueAccessor=this),null!=b?.typeaheadDebounceInterval&&(this._typeaheadDebounceInterval=b.typeaheadDebounceInterval),this._scrollStrategyFactory=f,this._scrollStrategy=this._scrollStrategyFactory(),this.tabIndex=parseInt(p)||0,this.id=this.id}ngOnInit(){this._selectionModel=new dg(this.multiple),this.stateChanges.next(),this._panelDoneAnimatingStream.pipe(Yn(),ot(this._destroy)).subscribe(()=>this._panelDoneAnimating(this.panelOpen))}ngAfterContentInit(){this._initKeyManager(),this._selectionModel.changed.pipe(ot(this._destroy)).subscribe(e=>{e.added.forEach(i=>i.select()),e.removed.forEach(i=>i.deselect())}),this.options.changes.pipe(qn(null),ot(this._destroy)).subscribe(()=>{this._resetOptions(),this._initializeSelection()})}ngDoCheck(){let e=this._getTriggerAriaLabelledby(),i=this.ngControl;if(e!==this._triggerAriaLabelledBy){let r=this._elementRef.nativeElement;this._triggerAriaLabelledBy=e,e?r.setAttribute("aria-labelledby",e):r.removeAttribute("aria-labelledby")}i&&(this._previousControl!==i.control&&(void 0!==this._previousControl&&null!==i.disabled&&i.disabled!==this.disabled&&(this.disabled=i.disabled),this._previousControl=i.control),this.updateErrorState())}ngOnChanges(e){(e.disabled||e.userAriaDescribedBy)&&this.stateChanges.next(),e.typeaheadDebounceInterval&&this._keyManager&&this._keyManager.withTypeAhead(this._typeaheadDebounceInterval)}ngOnDestroy(){this._keyManager?.destroy(),this._destroy.next(),this._destroy.complete(),this.stateChanges.complete()}toggle(){this.panelOpen?this.close():this.open()}open(){this._canOpen()&&(this._panelOpen=!0,this._keyManager.withHorizontalOrientation(null),this._highlightCorrectOption(),this._changeDetectorRef.markForCheck())}close(){this._panelOpen&&(this._panelOpen=!1,this._keyManager.withHorizontalOrientation(this._isRtl()?"rtl":"ltr"),this._changeDetectorRef.markForCheck(),this._onTouched())}writeValue(e){this._assignValue(e)}registerOnChange(e){this._onChange=e}registerOnTouched(e){this._onTouched=e}setDisabledState(e){this.disabled=e,this._changeDetectorRef.markForCheck(),this.stateChanges.next()}get panelOpen(){return this._panelOpen}get selected(){return this.multiple?this._selectionModel?.selected||[]:this._selectionModel?.selected[0]}get triggerValue(){if(this.empty)return"";if(this._multiple){let e=this._selectionModel.selected.map(i=>i.viewValue);return this._isRtl()&&e.reverse(),e.join(", ")}return this._selectionModel.selected[0].viewValue}_isRtl(){return!!this._dir&&"rtl"===this._dir.value}_handleKeydown(e){this.disabled||(this.panelOpen?this._handleOpenKeydown(e):this._handleClosedKeydown(e))}_handleClosedKeydown(e){let i=e.keyCode,r=40===i||38===i||37===i||39===i,o=13===i||32===i,s=this._keyManager;if(!s.isTyping()&&o&&!vr(e)||(this.multiple||e.altKey)&&r)e.preventDefault(),this.open();else if(!this.multiple){let a=this.selected;s.onKeydown(e);let l=this.selected;l&&a!==l&&this._liveAnnouncer.announce(l.viewValue,1e4)}}_handleOpenKeydown(e){let i=this._keyManager,r=e.keyCode,o=40===r||38===r,s=i.isTyping();if(o&&e.altKey)e.preventDefault(),this.close();else if(s||13!==r&&32!==r||!i.activeItem||vr(e))if(!s&&this._multiple&&65===r&&e.ctrlKey){e.preventDefault();let a=this.options.some(l=>!l.disabled&&!l.selected);this.options.forEach(l=>{l.disabled||(a?l.select():l.deselect())})}else{let a=i.activeItemIndex;i.onKeydown(e),this._multiple&&o&&e.shiftKey&&i.activeItem&&i.activeItemIndex!==a&&i.activeItem._selectViaInteraction()}else e.preventDefault(),i.activeItem._selectViaInteraction()}_onFocus(){this.disabled||(this._focused=!0,this.stateChanges.next())}_onBlur(){this._focused=!1,this._keyManager?.cancelTypeahead(),!this.disabled&&!this.panelOpen&&(this._onTouched(),this._changeDetectorRef.markForCheck(),this.stateChanges.next())}_onAttached(){this._overlayDir.positionChange.pipe(Yt(1)).subscribe(()=>{this._changeDetectorRef.detectChanges(),this._positioningSettled()})}_getPanelTheme(){return this._parentFormField?`mat-${this._parentFormField.color}`:""}get empty(){return!this._selectionModel||this._selectionModel.isEmpty()}_initializeSelection(){Promise.resolve().then(()=>{this.ngControl&&(this._value=this.ngControl.value),this._setSelectionByValue(this._value),this.stateChanges.next()})}_setSelectionByValue(e){if(this.options.forEach(i=>i.setInactiveStyles()),this._selectionModel.clear(),this.multiple&&e)Array.isArray(e),e.forEach(i=>this._selectOptionByValue(i)),this._sortValues();else{let i=this._selectOptionByValue(e);i?this._keyManager.updateActiveItem(i):this.panelOpen||this._keyManager.updateActiveItem(-1)}this._changeDetectorRef.markForCheck()}_selectOptionByValue(e){let i=this.options.find(r=>{if(this._selectionModel.isSelected(r))return!1;try{return null!=r.value&&this._compareWith(r.value,e)}catch{return!1}});return i&&this._selectionModel.select(i),i}_assignValue(e){return!!(e!==this._value||this._multiple&&Array.isArray(e))&&(this.options&&this._setSelectionByValue(e),this._value=e,!0)}_initKeyManager(){this._keyManager=new og(this.options).withTypeAhead(this._typeaheadDebounceInterval).withVerticalOrientation().withHorizontalOrientation(this._isRtl()?"rtl":"ltr").withHomeAndEnd().withPageUpDown().withAllowedModifierKeys(["shiftKey"]),this._keyManager.tabOut.subscribe(()=>{this.panelOpen&&(!this.multiple&&this._keyManager.activeItem&&this._keyManager.activeItem._selectViaInteraction(),this.focus(),this.close())}),this._keyManager.change.subscribe(()=>{this._panelOpen&&this.panel?this._scrollOptionIntoView(this._keyManager.activeItemIndex||0):!this._panelOpen&&!this.multiple&&this._keyManager.activeItem&&this._keyManager.activeItem._selectViaInteraction()})}_resetOptions(){let e=tn(this.options.changes,this._destroy);this.optionSelectionChanges.pipe(ot(e)).subscribe(i=>{this._onSelect(i.source,i.isUserInput),i.isUserInput&&!this.multiple&&this._panelOpen&&(this.close(),this.focus())}),tn(...this.options.map(i=>i._stateChanges)).pipe(ot(e)).subscribe(()=>{this._changeDetectorRef.detectChanges(),this.stateChanges.next()})}_onSelect(e,i){let r=this._selectionModel.isSelected(e);null!=e.value||this._multiple?(r!==e.selected&&(e.selected?this._selectionModel.select(e):this._selectionModel.deselect(e)),i&&this._keyManager.setActiveItem(e),this.multiple&&(this._sortValues(),i&&this.focus())):(e.deselect(),this._selectionModel.clear(),null!=this.value&&this._propagateChanges(e.value)),r!==this._selectionModel.isSelected(e)&&this._propagateChanges(),this.stateChanges.next()}_sortValues(){if(this.multiple){let e=this.options.toArray();this._selectionModel.sort((i,r)=>this.sortComparator?this.sortComparator(i,r,e):e.indexOf(i)-e.indexOf(r)),this.stateChanges.next()}}_propagateChanges(e){let i=null;i=this.multiple?this.selected.map(r=>r.value):this.selected?this.selected.value:e,this._value=i,this.valueChange.emit(i),this._onChange(i),this.selectionChange.emit(this._getChangeEvent(i)),this._changeDetectorRef.markForCheck()}_highlightCorrectOption(){this._keyManager&&(this.empty?this._keyManager.setFirstItemActive():this._keyManager.setActiveItem(this._selectionModel.selected[0]))}_canOpen(){return!this._panelOpen&&!this.disabled&&this.options?.length>0}focus(e){this._elementRef.nativeElement.focus(e)}_getPanelAriaLabelledby(){if(this.ariaLabel)return null;let e=this._parentFormField?.getLabelId();return this.ariaLabelledby?(e?e+" ":"")+this.ariaLabelledby:e}_getAriaActiveDescendant(){return this.panelOpen&&this._keyManager&&this._keyManager.activeItem?this._keyManager.activeItem.id:null}_getTriggerAriaLabelledby(){if(this.ariaLabel)return null;let e=this._parentFormField?.getLabelId(),i=(e?e+" ":"")+this._valueId;return this.ariaLabelledby&&(i+=" "+this.ariaLabelledby),i}_panelDoneAnimating(e){this.openedChange.emit(e)}setDescribedByIds(e){e.length?this._elementRef.nativeElement.setAttribute("aria-describedby",e.join(" ")):this._elementRef.nativeElement.removeAttribute("aria-describedby")}onContainerClick(){this.focus(),this.open()}get shouldLabelFloat(){return this._panelOpen||!this.empty||this._focused&&!!this._placeholder}}return n.\u0275fac=function(e){return new(e||n)(C(js),C($t),C(at),C(H1),C(Me),C(Xi,8),C(vg,8),C(yg,8),C(Sf,8),C(Gs,10),yo("tabindex"),C(yq),C(Vv),C(Rye,8))},n.\u0275dir=we({type:n,viewQuery:function(e,i){if(1&e&&(Ge(yye,5),Ge(xye,5),Ge(Bu,5)),2&e){let r;Se(r=Ee())&&(i.trigger=r.first),Se(r=Ee())&&(i.panel=r.first),Se(r=Ee())&&(i._overlayDir=r.first)}},inputs:{userAriaDescribedBy:["aria-describedby","userAriaDescribedBy"],panelClass:"panelClass",placeholder:"placeholder",required:"required",multiple:"multiple",disableOptionCentering:"disableOptionCentering",compareWith:"compareWith",value:"value",ariaLabel:["aria-label","ariaLabel"],ariaLabelledby:["aria-labelledby","ariaLabelledby"],errorStateMatcher:"errorStateMatcher",typeaheadDebounceInterval:"typeaheadDebounceInterval",sortComparator:"sortComparator",id:"id"},outputs:{openedChange:"openedChange",_openedStream:"opened",_closedStream:"closed",selectionChange:"selectionChange",valueChange:"valueChange"},features:[Ke,Gt]}),n})(),zu=(()=>{class n extends Fye{constructor(){super(...arguments),this._positions=[{originX:"start",originY:"bottom",overlayX:"start",overlayY:"top"},{originX:"start",originY:"top",overlayX:"start",overlayY:"bottom",panelClass:"mat-mdc-select-panel-above"}],this._hideSingleSelectionIndicator=this._defaultOptions?.hideSingleSelectionIndicator??!1}get shouldLabelFloat(){return this.panelOpen||!this.empty||this.focused&&!!this.placeholder}ngOnInit(){super.ngOnInit(),this._viewportRuler.change().pipe(ot(this._destroy)).subscribe(()=>{this.panelOpen&&(this._overlayWidth=this._getOverlayWidth(),this._changeDetectorRef.detectChanges())})}ngAfterViewInit(){this._parentFormField&&(this._preferredOverlayOrigin=this._parentFormField.getConnectedOverlayOrigin())}open(){this._overlayWidth=this._getOverlayWidth(),super.open(),this.stateChanges.next()}close(){super.close(),this.stateChanges.next()}_scrollOptionIntoView(e){let i=this.options.toArray()[e];if(i){let r=this.panel.nativeElement,o=z1(e,this.options,this.optionGroups),s=i._getHostElement();r.scrollTop=0===e&&1===o?0:U1(s.offsetTop,s.offsetHeight,r.scrollTop,r.offsetHeight)}}_positioningSettled(){this._scrollOptionIntoView(this._keyManager.activeItemIndex||0)}_getChangeEvent(e){return new class{constructor(t,e){this.source=t,this.value=e}}(this,e)}_getOverlayWidth(){return(this._preferredOverlayOrigin instanceof wd?this._preferredOverlayOrigin.elementRef:this._preferredOverlayOrigin||this._elementRef).nativeElement.getBoundingClientRect().width}get hideSingleSelectionIndicator(){return this._hideSingleSelectionIndicator}set hideSingleSelectionIndicator(e){this._hideSingleSelectionIndicator=Rt(e),this._syncParentProperties()}_syncParentProperties(){if(this.options)for(let e of this.options)e._changeDetectorRef.markForCheck()}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275cmp=O({type:n,selectors:[["mat-select"]],contentQueries:function(e,i,r){if(1&e&&(Ti(r,Oye,5),Ti(r,Us,5),Ti(r,Uv,5)),2&e){let o;Se(o=Ee())&&(i.customTrigger=o.first),Se(o=Ee())&&(i.options=o),Se(o=Ee())&&(i.optionGroups=o)}},hostAttrs:["role","combobox","aria-autocomplete","none","aria-haspopup","listbox",1,"mat-mdc-select"],hostVars:19,hostBindings:function(e,i){1&e&&I("keydown",function(o){return i._handleKeydown(o)})("focus",function(){return i._onFocus()})("blur",function(){return i._onBlur()}),2&e&&(Be("id",i.id)("tabindex",i.tabIndex)("aria-controls",i.panelOpen?i.id+"-panel":null)("aria-expanded",i.panelOpen)("aria-label",i.ariaLabel||null)("aria-required",i.required.toString())("aria-disabled",i.disabled.toString())("aria-invalid",i.errorState)("aria-activedescendant",i._getAriaActiveDescendant()),nt("mat-mdc-select-disabled",i.disabled)("mat-mdc-select-invalid",i.errorState)("mat-mdc-select-required",i.required)("mat-mdc-select-empty",i.empty)("mat-mdc-select-multiple",i.multiple))},inputs:{disabled:"disabled",disableRipple:"disableRipple",tabIndex:"tabIndex",hideSingleSelectionIndicator:"hideSingleSelectionIndicator"},exportAs:["matSelect"],features:[Qt([{provide:Qv,useExisting:n},{provide:zv,useExisting:n}]),Ke],ngContentSelectors:Dye,decls:11,vars:11,consts:[["cdk-overlay-origin","",1,"mat-mdc-select-trigger",3,"click"],["fallbackOverlayOrigin","cdkOverlayOrigin","trigger",""],[1,"mat-mdc-select-value",3,"ngSwitch"],["class","mat-mdc-select-placeholder mat-mdc-select-min-line",4,"ngSwitchCase"],["class","mat-mdc-select-value-text",3,"ngSwitch",4,"ngSwitchCase"],[1,"mat-mdc-select-arrow-wrapper"],[1,"mat-mdc-select-arrow"],["viewBox","0 0 24 24","width","24px","height","24px","focusable","false"],["d","M7 10l5 5 5-5z"],["cdk-connected-overlay","","cdkConnectedOverlayLockPosition","","cdkConnectedOverlayHasBackdrop","","cdkConnectedOverlayBackdropClass","cdk-overlay-transparent-backdrop",3,"cdkConnectedOverlayPanelClass","cdkConnectedOverlayScrollStrategy","cdkConnectedOverlayOrigin","cdkConnectedOverlayOpen","cdkConnectedOverlayPositions","cdkConnectedOverlayWidth","backdropClick","attach","detach"],[1,"mat-mdc-select-placeholder","mat-mdc-select-min-line"],[1,"mat-mdc-select-value-text",3,"ngSwitch"],["class","mat-mdc-select-min-line",4,"ngSwitchDefault"],[4,"ngSwitchCase"],[1,"mat-mdc-select-min-line"],["role","listbox","tabindex","-1",3,"ngClass","keydown"],["panel",""]],template:function(e,i){if(1&e&&(Dn(Tye),h(0,"div",0,1),I("click",function(){return i.toggle()}),h(3,"div",2),S(4,Cye,2,1,"span",3),S(5,Sye,3,2,"span",4),g(),h(6,"div",5)(7,"div",6),Nn(),h(8,"svg",7),P(9,"path",8),g()()()(),S(10,Eye,3,9,"ng-template",9),I("backdropClick",function(){return i.close()})("attach",function(){return i._onAttached()})("detach",function(){return i.close()})),2&e){let r=it(1);Be("aria-owns",i.panelOpen?i.id+"-panel":null),v(3),_("ngSwitch",i.empty),Be("id",i._valueId),v(1),_("ngSwitchCase",!0),v(1),_("ngSwitchCase",!1),v(5),_("cdkConnectedOverlayPanelClass",i._overlayPanelClass)("cdkConnectedOverlayScrollStrategy",i._scrollStrategy)("cdkConnectedOverlayOrigin",i._preferredOverlayOrigin||r)("cdkConnectedOverlayOpen",i.panelOpen)("cdkConnectedOverlayPositions",i._positions)("cdkConnectedOverlayWidth",i._overlayWidth)}},dependencies:[yn,sr,Sr,uu,Bu,wd],styles:['.mdc-menu-surface{display:none;position:absolute;box-sizing:border-box;max-width:calc(100vw - 32px);max-width:var(--mdc-menu-max-width, calc(100vw - 32px));max-height:calc(100vh - 32px);max-height:var(--mdc-menu-max-height, calc(100vh - 32px));margin:0;padding:0;transform:scale(1);transform-origin:top left;opacity:0;overflow:auto;will-change:transform,opacity;z-index:8;border-radius:4px;border-radius:var(--mdc-shape-medium, 4px);transform-origin-left:top left;transform-origin-right:top right}.mdc-menu-surface:focus{outline:none}.mdc-menu-surface--animating-open{display:inline-block;transform:scale(0.8);opacity:0}.mdc-menu-surface--open{display:inline-block;transform:scale(1);opacity:1}.mdc-menu-surface--animating-closed{display:inline-block;opacity:0}[dir=rtl] .mdc-menu-surface,.mdc-menu-surface[dir=rtl]{transform-origin-left:top right;transform-origin-right:top left}.mdc-menu-surface--anchor{position:relative;overflow:visible}.mdc-menu-surface--fixed{position:fixed}.mdc-menu-surface--fullwidth{width:100%}.mat-mdc-select{display:inline-block;width:100%;outline:none}.mat-mdc-select-trigger{display:inline-flex;align-items:center;cursor:pointer;position:relative;box-sizing:border-box;width:100%}.mat-mdc-select-disabled .mat-mdc-select-trigger{-webkit-user-select:none;user-select:none;cursor:default}.mat-mdc-select-value{width:100%;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.mat-mdc-select-value-text{white-space:nowrap;overflow:hidden;text-overflow:ellipsis}.mat-mdc-select-arrow-wrapper{height:24px;flex-shrink:0;display:inline-flex;align-items:center}.mat-form-field-appearance-fill .mat-mdc-select-arrow-wrapper{transform:translateY(-8px)}.mat-form-field-appearance-fill .mdc-text-field--no-label .mat-mdc-select-arrow-wrapper{transform:none}.mat-mdc-select-arrow{width:10px;height:5px;position:relative}.mat-mdc-select-arrow svg{fill:currentColor;position:absolute;top:50%;left:50%;transform:translate(-50%, -50%)}.cdk-high-contrast-active .mat-mdc-select-arrow svg{fill:CanvasText}.mat-mdc-select-disabled .cdk-high-contrast-active .mat-mdc-select-arrow svg{fill:GrayText}.mdc-menu-surface.mat-mdc-select-panel{width:100%;max-height:275px;position:static;outline:0;margin:0;padding:8px 0;list-style-type:none}.mdc-menu-surface.mat-mdc-select-panel:focus{outline:none}.cdk-high-contrast-active .mdc-menu-surface.mat-mdc-select-panel{outline:solid 1px}.cdk-overlay-pane:not(.mat-mdc-select-panel-above) .mdc-menu-surface.mat-mdc-select-panel{border-top-left-radius:0;border-top-right-radius:0;transform-origin:top center}.mat-mdc-select-panel-above .mdc-menu-surface.mat-mdc-select-panel{border-bottom-left-radius:0;border-bottom-right-radius:0;transform-origin:bottom center}.mat-mdc-select-placeholder{transition:color 400ms 133.3333333333ms cubic-bezier(0.25, 0.8, 0.25, 1)}._mat-animation-noopable .mat-mdc-select-placeholder{transition:none}.mat-form-field-hide-placeholder .mat-mdc-select-placeholder{color:rgba(0,0,0,0);-webkit-text-fill-color:rgba(0,0,0,0);transition:none;display:block}.mat-mdc-form-field-type-mat-select.mat-form-field-appearance-fill .mat-mdc-floating-label{max-width:calc(100% - 18px)}.mat-mdc-form-field-type-mat-select.mat-form-field-appearance-fill .mdc-floating-label--float-above{max-width:calc(100% / 0.75 - 24px)}.mat-mdc-form-field-type-mat-select.mat-form-field-appearance-outline .mdc-notched-outline__notch{max-width:calc(100% - 60px)}.mat-mdc-form-field-type-mat-select.mat-form-field-appearance-outline .mdc-text-field--label-floating .mdc-notched-outline__notch{max-width:calc(100% - 24px)}.mat-mdc-select-min-line:empty::before{content:" ";white-space:pre;width:1px;display:inline-block;visibility:hidden}'],encapsulation:2,data:{animation:[Iye.transformPanel]},changeDetection:0}),n})(),Ja=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({providers:[Pye],imports:[Pe,Co,cg,fn,Pc,Ef,cg,fn]}),n})();function Nye(n,t){1&n&&(Ot(0),h(1,"div",1),T(2," There is a difference between Default - (Enabled/Disabled) and (Enabled/Disabled) "),g(),h(3,"div",1),T(4," Only flags with non default values are sent to the backend. "),g(),kt())}function Lye(n,t){if(1&n&&(Ot(0),h(1,"div",1),T(2),g(),kt()),2&n){let e=w();v(2),He(' Feature Flags are filtered to only show features containing "',e.showFlagsFilter,'" ')}}function Bye(n,t){1&n&&(h(0,"sup",11),T(1,"1"),g())}function Vye(n,t){1&n&&li(0)}function Hye(n,t){if(1&n){let e=ge();h(0,"mat-select",12),I("selectionChange",function(r){X(e);let o=w().$implicit;return Q(w().flagChanged.emit({flag:o.flag,status:r.value}))}),h(1,"mat-option",13),T(2),g(),h(3,"mat-option",14),T(4,"Enabled"),g(),h(5,"mat-option",15),T(6,"Disabled"),g()()}if(2&n){let e=w().$implicit,i=w();_("value",e.status),v(2),He(" Default ",i.formatFlagValue(e.defaultValue)," ")}}function zye(n,t){if(1&n&&(h(0,"td"),T(1),g()),2&n){let e=w().$implicit,i=w();v(1),He("Unsupported By UI ",i.formatFlagValue(e.value),"")}}function Uye(n,t){if(1&n&&(Ot(0),h(1,"tr")(2,"td")(3,"div"),T(4),S(5,Bye,2,0,"sup",7),g()(),S(6,Vye,1,0,"ng-container",8),S(7,Hye,7,2,"ng-template",null,9,Wt),S(9,zye,2,1,"ng-template",null,10,Wt),g(),kt()),2&n){let e=t.$implicit,i=it(8),r=it(10),o=w();v(4),He(" ",e.flag," "),v(1),_("ngIf",e.sendToServerWhenOverridden),v(1),_("ngIf",o.isEditable(e))("ngIfThen",i)("ngIfElse",r)}}function jye(n,t){1&n&&(h(0,"div",11),T(1," 1. Sent to server when overridden "),g())}var fE,xq=(()=>{class n{constructor(){this.hasFlagsSentToServer=!1,this.flagChanged=new F,this.allFlagsReset=new F}serializeFlagValue(e){return!0===e?"Enabled":!1===e?"Disabled":null==e?"null":Array.isArray(e)?JSON.stringify(e):e.toString()}isEditable(e){return"boolean"==typeof e.defaultValue}formatFlagValue(e){let i=this.serializeFlagValue(e);return 0===i.length?"":`- ${i}`}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["feature-flag-dialog-component"]],inputs:{featureFlagStatuses:"featureFlagStatuses",hasFlagsSentToServer:"hasFlagsSentToServer",showFlagsFilter:"showFlagsFilter"},outputs:{flagChanged:"flagChanged",allFlagsReset:"allFlagsReset"},decls:12,vars:4,consts:[[1,"scrolling-page"],[1,"message"],[1,"warning"],[4,"ngIf"],[1,"feature-flag-table"],[4,"ngFor","ngForOf"],["mat-button","",3,"click"],["class","note-1",4,"ngIf"],[4,"ngIf","ngIfThen","ngIfElse"],["selectBlock",""],["unsupportedBlock",""],[1,"note-1"],[3,"value","selectionChange"],["value","default"],["value","enabled"],["value","disabled"]],template:function(e,i){1&e&&(h(0,"div",0)(1,"div",1)(2,"h2",2),T(3,"WARNING: EXPERIMENTAL FEATURES AHEAD!"),g(),T(4," By enabling these features, you could put the application in an unusable state or expose yourself to untested features or potential bugs. "),g(),S(5,Nye,5,0,"ng-container",3),S(6,Lye,3,1,"ng-container",3),h(7,"table",4),S(8,Uye,11,5,"ng-container",5),g(),h(9,"button",6),I("click",function(){return i.allFlagsReset.emit()}),T(10,"Reset All"),g(),S(11,jye,2,0,"div",7),g()),2&e&&(v(5),_("ngIf",i.hasFlagsSentToServer),v(1),_("ngIf",i.showFlagsFilter),v(2),_("ngForOf",i.featureFlagStatuses),v(3),_("ngIf",i.hasFlagsSentToServer))},dependencies:[nn,Fe,Ji,zu,Us],styles:[".message[_ngcontent-%COMP%]{margin-bottom:16px}.message[_ngcontent-%COMP%]   .warning[_ngcontent-%COMP%]{color:#f44336}.note-1[_ngcontent-%COMP%]{color:#ff9800}.scrolling-page[_ngcontent-%COMP%]{max-height:90vh}.feature-flag-table[_ngcontent-%COMP%]{width:100%}"]}),n})(),Cq=(()=>{class n{constructor(e){this.store=e,this.showFlagsFilter$=this.store.select(iv).pipe(N(i=>i.showFlags?.toLowerCase())),this.hasFlagsSentToServer$=this.store.select(cf).pipe(N(i=>Object.values(i).some(r=>r.sendToServerWhenOverridden))),this.featureFlags$=this.store.select(iv).pipe(Bt(this.store.select(m6),this.store.select(cf),this.showFlagsFilter$),N(([i,r,o,s])=>Object.entries(r).filter(([a])=>!s||a.toLowerCase().includes(s)).map(([a,l])=>{let c=function(n,t){return void 0===t[n]?"default":t[n]?"enabled":"disabled"}(a,i);return{flag:a,defaultValue:l,status:c,sendToServerWhenOverridden:o[a].sendToServerWhenOverridden}})))}onFlagChanged({flag:e,status:i}){switch(i){case"default":this.store.dispatch(xu({flags:[e]}));break;case"enabled":this.store.dispatch(mf({flags:{[e]:!0}}));break;case"disabled":this.store.dispatch(mf({flags:{[e]:!1}}));break;default:throw new Error("Flag changed to invalid status")}}onAllFlagsReset(){this.store.dispatch(jh())}}return n.\u0275fac=function(e){return new(e||n)(C(Ae))},n.\u0275cmp=O({type:n,selectors:[["feature-flag-dialog"]],decls:4,vars:9,consts:[[3,"featureFlagStatuses","hasFlagsSentToServer","showFlagsFilter","flagChanged","allFlagsReset"]],template:function(e,i){1&e&&(h(0,"feature-flag-dialog-component",0),I("flagChanged",function(o){return i.onFlagChanged(o)})("allFlagsReset",function(){return i.onAllFlagsReset()}),j(1,"async"),j(2,"async"),j(3,"async"),g()),2&e&&_("featureFlagStatuses",W(1,3,i.featureFlags$))("hasFlagsSentToServer",W(2,5,i.hasFlagsSentToServer$))("showFlagsFilter",W(3,7,i.showFlagsFilter$))},dependencies:[xq,ct],encapsulation:2}),n})(),Mq=(()=>{class n{constructor(e,i){this.store=e,this.dialog=i,this.featureFlagDialogType=Cq,this.showFeatureFlags$=this.store.select(b6),this.ngUnsubscribe=new Ie}ngOnInit(){this.showFeatureFlags$.pipe(ot(this.ngUnsubscribe)).subscribe(e=>{if(e)return this.featureFlagsDialog=this.dialog.open(this.featureFlagDialogType),void this.featureFlagsDialog.afterClosed().pipe(ot(this.ngUnsubscribe)).subscribe(()=>{this.store.dispatch(xu({flags:["showFlags"]})),setTimeout(()=>{window.location.reload()},1)})})}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}}return n.\u0275fac=function(e){return new(e||n)(C(Ae),C(zl))},n.\u0275cmp=O({type:n,selectors:[["feature-flag-modal-trigger"]],decls:0,vars:0,template:function(e,i){},encapsulation:2}),n})(),Xye=["routeContainer"],wq=(()=>{class n{constructor(e){this.componentFactoryResolver=e}ngOnChanges(e){let i=e.activeNgComponent;if(i&&(this.routeContainer.clear(),i.currentValue)){let r=this.componentFactoryResolver.resolveComponentFactory(i.currentValue);this.routeContainer.createComponent(r)}}}return n.\u0275fac=function(e){return new(e||n)(C(fo))},n.\u0275cmp=O({type:n,selectors:[["router-outlet-component"]],viewQuery:function(e,i){if(1&e&&Ge(Xye,7,si),2&e){let r;Se(r=Ee())&&(i.routeContainer=r.first)}},inputs:{activeNgComponent:"activeNgComponent"},features:[Gt],decls:2,vars:0,consts:[["routeContainer",""]],template:function(e,i){1&e&&li(0,null,0)},encapsulation:2,changeDetection:0}),n})(),Sq=(()=>{class n{constructor(e,i){this.store=e,this.registry=i,this.activeNgComponent$=dn([this.store.select(No),this.store.select(z8)]).pipe(N(([r,o])=>r&&(null===o||Fo(r,o))?this.registry.getNgComponentByRouteKind(r.routeKind):null))}}return n.\u0275fac=function(e){return new(e||n)(C(Ae),C(Dl))},n.\u0275cmp=O({type:n,selectors:[["router-outlet"]],decls:2,vars:3,consts:[[3,"activeNgComponent"]],template:function(e,i){1&e&&(P(0,"router-outlet-component",0),j(1,"async")),2&e&&_("activeNgComponent",W(1,1,i.activeNgComponent$))},dependencies:[wq,ct],encapsulation:2,changeDetection:0}),n})(),Eq=(()=>{class n{constructor(e){e.select(Rl).subscribe(i=>{document.body.classList.toggle("dark-mode",i)})}}return n.\u0275fac=function(e){return new(e||n)(C(Ae))},n.\u0275cmp=O({type:n,selectors:[["dark-mode-supporter"]],decls:0,vars:0,template:function(e,i){},styles:["[_nghost-%COMP%] {\n        display: none;\n      }"],changeDetection:0}),n})(),Cg=(()=>(function(n){n[n.ACTIVE_PLUGIN=0]="ACTIVE_PLUGIN"}(Cg||(Cg={})),Cg))(),Tq=(()=>{class n{constructor(e){this.deepLinker=e,this.onValueChange=new F,this.ngUnsubscribe=new Ie,this.onHashChange=mi(window,"popstate",{passive:!0}).pipe(ot(this.ngUnsubscribe))}ngOnInit(){this.onHashChange.subscribe(()=>{let e=this.deepLinker.getPluginId();e!==this.activePluginId&&this.onValueChange.emit({prop:Cg.ACTIVE_PLUGIN,value:e})})}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}ngOnChanges(e){if(e.activePluginId){let i=e.activePluginId;this.deepLinker.setPluginId(null===i.currentValue?"":i.currentValue,{defaultValue:"",useLocationReplace:null===i.previousValue||i.firstChange})}}}return n.\u0275fac=function(e){return new(e||n)(C(_u))},n.\u0275cmp=O({type:n,selectors:[["hash-storage-component"]],inputs:{activePluginId:"activePluginId"},outputs:{onValueChange:"onValueChange"},features:[Gt],decls:0,vars:0,template:function(e,i){},encapsulation:2,changeDetection:0}),n})(),Dq=(()=>{class n{constructor(e){this.store=e,this.activePluginId$=this.store.pipe(un(Wo))}onValueChanged(e){e.prop===Cg.ACTIVE_PLUGIN&&this.store.dispatch(pS({plugin:e.value}))}}return n.\u0275fac=function(e){return new(e||n)(C(Ae))},n.\u0275cmp=O({type:n,selectors:[["hash-storage"]],decls:2,vars:3,consts:[[3,"activePluginId","onValueChange"]],template:function(e,i){1&e&&(h(0,"hash-storage-component",0),I("onValueChange",function(o){return i.onValueChanged(o)}),j(1,"async"),g()),2&e&&_("activePluginId",W(1,1,i.activePluginId$))},dependencies:[Tq,ct],styles:["[_nghost-%COMP%] {\n        display: none;\n      }"],changeDetection:0}),n})(),exe=["*"];function iy(n){return function(){if(void 0===fE&&(fE=null,typeof window<"u")){let n=window;void 0!==n.trustedTypes&&(fE=n.trustedTypes.createPolicy("angular#components",{createHTML:t=>t}))}return fE}()?.createHTML(n)||n}function Iq(n){return Error(`Unable to find icon with the name "${n}"`)}function Aq(n){return Error(`The URL provided to MatIconRegistry was not trusted as a resource URL via Angular's DomSanitizer. Attempted URL was "${n}".`)}function Rq(n){return Error(`The literal provided to MatIconRegistry was not trusted as safe HTML by Angular's DomSanitizer. Attempted literal was "${n}".`)}var Td=class{constructor(t,e,i){this.url=t,this.svgText=e,this.options=i}},Mg=(()=>{class n{constructor(e,i,r,o){this._httpClient=e,this._sanitizer=i,this._errorHandler=o,this._svgIconConfigs=new Map,this._iconSetConfigs=new Map,this._cachedIconsByUrl=new Map,this._inProgressUrlFetches=new Map,this._fontCssClassesByAlias=new Map,this._resolvers=[],this._defaultFontSetClass=["material-icons","mat-ligature-font"],this._document=r}addSvgIcon(e,i,r){return this.addSvgIconInNamespace("",e,i,r)}addSvgIconLiteral(e,i,r){return this.addSvgIconLiteralInNamespace("",e,i,r)}addSvgIconInNamespace(e,i,r,o){return this._addSvgIconConfig(e,i,new Td(r,null,o))}addSvgIconResolver(e){return this._resolvers.push(e),this}addSvgIconLiteralInNamespace(e,i,r,o){let s=this._sanitizer.sanitize(jr.HTML,r);if(!s)throw Rq(r);let a=iy(s);return this._addSvgIconConfig(e,i,new Td("",a,o))}addSvgIconSet(e,i){return this.addSvgIconSetInNamespace("",e,i)}addSvgIconSetLiteral(e,i){return this.addSvgIconSetLiteralInNamespace("",e,i)}addSvgIconSetInNamespace(e,i,r){return this._addSvgIconSetConfig(e,new Td(i,null,r))}addSvgIconSetLiteralInNamespace(e,i,r){let o=this._sanitizer.sanitize(jr.HTML,i);if(!o)throw Rq(i);let s=iy(o);return this._addSvgIconSetConfig(e,new Td("",s,r))}registerFontClassAlias(e,i=e){return this._fontCssClassesByAlias.set(e,i),this}classNameForFontAlias(e){return this._fontCssClassesByAlias.get(e)||e}setDefaultFontSetClass(...e){return this._defaultFontSetClass=e,this}getDefaultFontSetClass(){return this._defaultFontSetClass}getSvgIconFromUrl(e){let i=this._sanitizer.sanitize(jr.RESOURCE_URL,e);if(!i)throw Aq(e);let r=this._cachedIconsByUrl.get(i);return r?Ht(mE(r)):this._loadSvgIconFromConfig(new Td(e,null)).pipe(Nt(o=>this._cachedIconsByUrl.set(i,o)),N(o=>mE(o)))}getNamedSvgIcon(e,i=""){let r=Pq(i,e),o=this._svgIconConfigs.get(r);if(o)return this._getSvgFromConfig(o);if(o=this._getIconConfigFromResolvers(i,e),o)return this._svgIconConfigs.set(r,o),this._getSvgFromConfig(o);let s=this._iconSetConfigs.get(i);return s?this._getSvgFromIconSetConfigs(e,s):ea(Iq(r))}ngOnDestroy(){this._resolvers=[],this._svgIconConfigs.clear(),this._iconSetConfigs.clear(),this._cachedIconsByUrl.clear()}_getSvgFromConfig(e){return e.svgText?Ht(mE(this._svgElementFromConfig(e))):this._loadSvgIconFromConfig(e).pipe(N(i=>mE(i)))}_getSvgFromIconSetConfigs(e,i){let r=this._extractIconWithNameFromAnySet(e,i);return r?Ht(r):co(i.filter(s=>!s.svgText).map(s=>this._loadSvgIconSetFromConfig(s).pipe(zr(a=>{let c=`Loading icon set URL: ${this._sanitizer.sanitize(jr.RESOURCE_URL,s.url)} failed: ${a.message}`;return this._errorHandler.handleError(new Error(c)),Ht(null)})))).pipe(N(()=>{let s=this._extractIconWithNameFromAnySet(e,i);if(!s)throw Iq(e);return s}))}_extractIconWithNameFromAnySet(e,i){for(let r=i.length-1;r>=0;r--){let o=i[r];if(o.svgText&&o.svgText.toString().indexOf(e)>-1){let s=this._svgElementFromConfig(o),a=this._extractSvgIconFromSet(s,e,o.options);if(a)return a}}return null}_loadSvgIconFromConfig(e){return this._fetchIcon(e).pipe(Nt(i=>e.svgText=i),N(()=>this._svgElementFromConfig(e)))}_loadSvgIconSetFromConfig(e){return e.svgText?Ht(null):this._fetchIcon(e).pipe(Nt(i=>e.svgText=i))}_extractSvgIconFromSet(e,i,r){let o=e.querySelector(`[id="${i}"]`);if(!o)return null;let s=o.cloneNode(!0);if(s.removeAttribute("id"),"svg"===s.nodeName.toLowerCase())return this._setSvgAttributes(s,r);if("symbol"===s.nodeName.toLowerCase())return this._setSvgAttributes(this._toSvgElement(s),r);let a=this._svgElementFromString(iy("<svg></svg>"));return a.appendChild(s),this._setSvgAttributes(a,r)}_svgElementFromString(e){let i=this._document.createElement("DIV");i.innerHTML=e;let r=i.querySelector("svg");if(!r)throw Error("<svg> tag not found");return r}_toSvgElement(e){let i=this._svgElementFromString(iy("<svg></svg>")),r=e.attributes;for(let o=0;o<r.length;o++){let{name:s,value:a}=r[o];"id"!==s&&i.setAttribute(s,a)}for(let o=0;o<e.childNodes.length;o++)e.childNodes[o].nodeType===this._document.ELEMENT_NODE&&i.appendChild(e.childNodes[o].cloneNode(!0));return i}_setSvgAttributes(e,i){return e.setAttribute("fit",""),e.setAttribute("height","100%"),e.setAttribute("width","100%"),e.setAttribute("preserveAspectRatio","xMidYMid meet"),e.setAttribute("focusable","false"),i&&i.viewBox&&e.setAttribute("viewBox",i.viewBox),e}_fetchIcon(e){let{url:i,options:r}=e,o=r?.withCredentials??!1;if(!this._httpClient)throw Error("Could not find HttpClient provider for use with Angular Material icons. Please include the HttpClientModule from @angular/common/http in your app imports.");if(null==i)throw Error(`Cannot fetch icon from URL "${i}".`);let s=this._sanitizer.sanitize(jr.RESOURCE_URL,i);if(!s)throw Aq(i);let a=this._inProgressUrlFetches.get(s);if(a)return a;let l=this._httpClient.get(s,{responseType:"text",withCredentials:o}).pipe(N(c=>iy(c)),function(n){return qt((t,e)=>{try{t.subscribe(e)}finally{e.add(n)}})}(()=>this._inProgressUrlFetches.delete(s)),Cs());return this._inProgressUrlFetches.set(s,l),l}_addSvgIconConfig(e,i,r){return this._svgIconConfigs.set(Pq(e,i),r),this}_addSvgIconSetConfig(e,i){let r=this._iconSetConfigs.get(e);return r?r.push(i):this._iconSetConfigs.set(e,[i]),this}_svgElementFromConfig(e){if(!e.svgElement){let i=this._svgElementFromString(e.svgText);this._setSvgAttributes(i,e.options),e.svgElement=i}return e.svgElement}_getIconConfigFromResolvers(e,i){for(let r=0;r<this._resolvers.length;r++){let o=this._resolvers[r](i,e);if(o)return rxe(o)?new Td(o.url,null,o.options):new Td(o,null)}}}return n.\u0275fac=function(e){return new(e||n)(k(lf,8),k(Zp),k(Lt,8),k(rs))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})();function mE(n){return n.cloneNode(!0)}function Pq(n,t){return n+":"+t}function rxe(n){return!(!n.url||!n.options)}new Ts,new sd,new Ts,new Ts;var oxe=zs(class{constructor(n){this._elementRef=n}}),sxe=new ie("MAT_ICON_DEFAULT_OPTIONS"),axe=new ie("mat-icon-location",{providedIn:"root",factory:function(){let n=ai(Lt),t=n?n.location:null;return{getPathname:()=>t?t.pathname+t.search:""}}}),Oq=["clip-path","color-profile","src","cursor","fill","filter","marker","marker-start","marker-mid","marker-end","mask","stroke"],cxe=Oq.map(n=>`[${n}]`).join(", "),dxe=/^url\(['"]?#(.*?)['"]?\)$/,En=(()=>{class n extends oxe{get inline(){return this._inline}set inline(e){this._inline=Rt(e)}get svgIcon(){return this._svgIcon}set svgIcon(e){e!==this._svgIcon&&(e?this._updateSvgIcon(e):this._svgIcon&&this._clearSvgElement(),this._svgIcon=e)}get fontSet(){return this._fontSet}set fontSet(e){let i=this._cleanupFontValue(e);i!==this._fontSet&&(this._fontSet=i,this._updateFontIconClasses())}get fontIcon(){return this._fontIcon}set fontIcon(e){let i=this._cleanupFontValue(e);i!==this._fontIcon&&(this._fontIcon=i,this._updateFontIconClasses())}constructor(e,i,r,o,s,a){super(e),this._iconRegistry=i,this._location=o,this._errorHandler=s,this._inline=!1,this._previousFontSetClass=[],this._currentIconFetch=Mn.EMPTY,a&&(a.color&&(this.color=this.defaultColor=a.color),a.fontSet&&(this.fontSet=a.fontSet)),r||e.nativeElement.setAttribute("aria-hidden","true")}_splitIconName(e){if(!e)return["",""];let i=e.split(":");switch(i.length){case 1:return["",i[0]];case 2:return i;default:throw Error(`Invalid icon name: "${e}"`)}}ngOnInit(){this._updateFontIconClasses()}ngAfterViewChecked(){let e=this._elementsWithExternalReferences;if(e&&e.size){let i=this._location.getPathname();i!==this._previousPath&&(this._previousPath=i,this._prependPathToReferences(i))}}ngOnDestroy(){this._currentIconFetch.unsubscribe(),this._elementsWithExternalReferences&&this._elementsWithExternalReferences.clear()}_usingFontIcon(){return!this.svgIcon}_setSvgElement(e){this._clearSvgElement();let i=this._location.getPathname();this._previousPath=i,this._cacheChildrenWithExternalReferences(e),this._prependPathToReferences(i),this._elementRef.nativeElement.appendChild(e)}_clearSvgElement(){let e=this._elementRef.nativeElement,i=e.childNodes.length;for(this._elementsWithExternalReferences&&this._elementsWithExternalReferences.clear();i--;){let r=e.childNodes[i];(1!==r.nodeType||"svg"===r.nodeName.toLowerCase())&&r.remove()}}_updateFontIconClasses(){if(!this._usingFontIcon())return;let e=this._elementRef.nativeElement,i=(this.fontSet?this._iconRegistry.classNameForFontAlias(this.fontSet).split(/ +/):this._iconRegistry.getDefaultFontSetClass()).filter(r=>r.length>0);this._previousFontSetClass.forEach(r=>e.classList.remove(r)),i.forEach(r=>e.classList.add(r)),this._previousFontSetClass=i,this.fontIcon!==this._previousFontIconClass&&!i.includes("mat-ligature-font")&&(this._previousFontIconClass&&e.classList.remove(this._previousFontIconClass),this.fontIcon&&e.classList.add(this.fontIcon),this._previousFontIconClass=this.fontIcon)}_cleanupFontValue(e){return"string"==typeof e?e.trim().split(" ")[0]:e}_prependPathToReferences(e){let i=this._elementsWithExternalReferences;i&&i.forEach((r,o)=>{r.forEach(s=>{o.setAttribute(s.name,`url('${e}#${s.value}')`)})})}_cacheChildrenWithExternalReferences(e){let i=e.querySelectorAll(cxe),r=this._elementsWithExternalReferences=this._elementsWithExternalReferences||new Map;for(let o=0;o<i.length;o++)Oq.forEach(s=>{let a=i[o],l=a.getAttribute(s),c=l?l.match(dxe):null;if(c){let d=r.get(a);d||(d=[],r.set(a,d)),d.push({name:s,value:c[1]})}})}_updateSvgIcon(e){if(this._svgNamespace=null,this._svgName=null,this._currentIconFetch.unsubscribe(),e){let[i,r]=this._splitIconName(e);i&&(this._svgNamespace=i),r&&(this._svgName=r),this._currentIconFetch=this._iconRegistry.getNamedSvgIcon(r,i).pipe(Yt(1)).subscribe(o=>this._setSvgElement(o),o=>{this._errorHandler.handleError(new Error(`Error retrieving icon ${i}:${r}! ${o.message}`))})}}}return n.\u0275fac=function(e){return new(e||n)(C(Me),C(Mg),yo("aria-hidden"),C(axe),C(rs),C(sxe,8))},n.\u0275cmp=O({type:n,selectors:[["mat-icon"]],hostAttrs:["role","img",1,"mat-icon","notranslate"],hostVars:8,hostBindings:function(e,i){2&e&&(Be("data-mat-icon-type",i._usingFontIcon()?"font":"svg")("data-mat-icon-name",i._svgName||i.fontIcon)("data-mat-icon-namespace",i._svgNamespace||i.fontSet)("fontIcon",i._usingFontIcon()?i.fontIcon:null),nt("mat-icon-inline",i.inline)("mat-icon-no-color","primary"!==i.color&&"accent"!==i.color&&"warn"!==i.color))},inputs:{color:"color",inline:"inline",svgIcon:"svgIcon",fontSet:"fontSet",fontIcon:"fontIcon"},exportAs:["matIcon"],features:[Ke],ngContentSelectors:exe,decls:1,vars:0,template:function(e,i){1&e&&(Dn(),zt(0))},styles:[".mat-icon{-webkit-user-select:none;user-select:none;background-repeat:no-repeat;display:inline-block;fill:currentColor;height:24px;width:24px;overflow:hidden}.mat-icon.mat-icon-inline{font-size:inherit;height:inherit;line-height:inherit;width:inherit}.mat-icon.mat-ligature-font[fontIcon]::before{content:attr(fontIcon)}[dir=rtl] .mat-icon-rtl-mirror{transform:scale(-1, 1)}.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-prefix .mat-icon,.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-suffix .mat-icon{display:block}.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-prefix .mat-icon-button .mat-icon,.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-suffix .mat-icon-button .mat-icon{margin:auto}"],encapsulation:2,changeDetection:0}),n})(),di=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[fn,fn]}),n})(),uxe=["*",[["mat-toolbar-row"]]],pxe=["*","mat-toolbar-row"],fxe=zs(class{constructor(n){this._elementRef=n}}),mxe=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275dir=we({type:n,selectors:[["mat-toolbar-row"]],hostAttrs:[1,"mat-toolbar-row"],exportAs:["matToolbarRow"]}),n})(),kq=(()=>{class n extends fxe{constructor(e,i,r){super(e),this._platform=i,this._document=r}ngAfterViewInit(){this._platform.isBrowser&&(this._checkToolbarMixedModes(),this._toolbarRows.changes.subscribe(()=>this._checkToolbarMixedModes()))}_checkToolbarMixedModes(){}}return n.\u0275fac=function(e){return new(e||n)(C(Me),C(Gn),C(Lt))},n.\u0275cmp=O({type:n,selectors:[["mat-toolbar"]],contentQueries:function(e,i,r){if(1&e&&Ti(r,mxe,5),2&e){let o;Se(o=Ee())&&(i._toolbarRows=o)}},hostAttrs:[1,"mat-toolbar"],hostVars:4,hostBindings:function(e,i){2&e&&nt("mat-toolbar-multiple-rows",i._toolbarRows.length>0)("mat-toolbar-single-row",0===i._toolbarRows.length)},inputs:{color:"color"},exportAs:["matToolbar"],features:[Ke],ngContentSelectors:pxe,decls:2,vars:0,template:function(e,i){1&e&&(Dn(uxe),zt(0),zt(1,1))},styles:[".cdk-high-contrast-active .mat-toolbar{outline:solid 1px}.mat-toolbar .mat-mdc-button-base.mat-unthemed{--mdc-text-button-label-text-color: inherit;--mdc-outlined-button-label-text-color: inherit}.mat-toolbar-row,.mat-toolbar-single-row{display:flex;box-sizing:border-box;padding:0 16px;width:100%;flex-direction:row;align-items:center;white-space:nowrap}.mat-toolbar-multiple-rows{display:flex;box-sizing:border-box;flex-direction:column;width:100%}"],encapsulation:2,changeDetection:0}),n})(),Fq=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[fn,fn]}),n})();function J2(n){return n.state!==Te.NOT_LOADED&&n.state!==Te.LOADING}var gxe=br(XW,ye(y1,n=>J2(n)?{...n,settings:{...n.settings,reloadEnabled:!n.settings.reloadEnabled}}:n),ye(x1,(n,{periodInMs:t})=>{if(!J2(n))return n;let e=t>=3e4?t:n.settings.reloadPeriodInMs;return{...n,settings:{...n.settings,reloadPeriodInMs:e}}}),ye(C1,(n,{size:t})=>{if(!J2(n))return n;let e=t>0?t:n.settings.pageSize;return{...n,settings:{...n.settings,pageSize:e}}}),ye(Il,(n,{partialSettings:t})=>{let e={};return Number.isFinite(t.pageSize)&&t.pageSize>0&&(e.pageSize=Number(t.pageSize)),"boolean"==typeof t.autoReload&&(e.reloadEnabled=t.autoReload),Number.isFinite(t.autoReloadPeriodInMs)&&t.autoReloadPeriodInMs>3e4&&(e.reloadPeriodInMs=Number(t.autoReloadPeriodInMs)),{...n,settings:{...n.settings,...e}}}));function Nq(n,t){return gxe(n,t)}var _xe=["input"],bxe=["label"],vxe=["*"],yxe=new ie("mat-checkbox-default-options",{providedIn:"root",factory:function(){return{color:"accent",clickAction:"check-indeterminate"}}});var xxe={provide:Mo,useExisting:$n(()=>ha),multi:!0},Cxe=0,Lq={color:"accent",clickAction:"check-indeterminate"},Mxe=ku(zs(us(so(class{constructor(n){this._elementRef=n}})))),wxe=(()=>{class n extends Mxe{get inputId(){return`${this.id||this._uniqueId}-input`}get required(){return this._required}set required(e){this._required=Rt(e)}constructor(e,i,r,o,s,a,l){super(i),this._changeDetectorRef=r,this._ngZone=o,this._animationMode=a,this._options=l,this.ariaLabel="",this.ariaLabelledby=null,this.labelPosition="after",this.name=null,this.change=new F,this.indeterminateChange=new F,this._onTouched=()=>{},this._currentAnimationClass="",this._currentCheckState=0,this._controlValueAccessorChangeFn=()=>{},this._checked=!1,this._disabled=!1,this._indeterminate=!1,this._options=this._options||Lq,this.color=this.defaultColor=this._options.color||Lq.color,this.tabIndex=parseInt(s)||0,this.id=this._uniqueId=`${e}${++Cxe}`}ngAfterViewInit(){this._syncIndeterminate(this._indeterminate)}get checked(){return this._checked}set checked(e){let i=Rt(e);i!=this.checked&&(this._checked=i,this._changeDetectorRef.markForCheck())}get disabled(){return this._disabled}set disabled(e){let i=Rt(e);i!==this.disabled&&(this._disabled=i,this._changeDetectorRef.markForCheck())}get indeterminate(){return this._indeterminate}set indeterminate(e){let i=e!=this._indeterminate;this._indeterminate=Rt(e),i&&(this._transitionCheckState(this._indeterminate?3:this.checked?1:2),this.indeterminateChange.emit(this._indeterminate)),this._syncIndeterminate(this._indeterminate)}_isRippleDisabled(){return this.disableRipple||this.disabled}_onLabelTextChange(){this._changeDetectorRef.detectChanges()}writeValue(e){this.checked=!!e}registerOnChange(e){this._controlValueAccessorChangeFn=e}registerOnTouched(e){this._onTouched=e}setDisabledState(e){this.disabled=e}_transitionCheckState(e){let i=this._currentCheckState,r=this._getAnimationTargetElement();if(i!==e&&r&&(this._currentAnimationClass&&r.classList.remove(this._currentAnimationClass),this._currentAnimationClass=this._getAnimationClassForCheckStateTransition(i,e),this._currentCheckState=e,this._currentAnimationClass.length>0)){r.classList.add(this._currentAnimationClass);let o=this._currentAnimationClass;this._ngZone.runOutsideAngular(()=>{setTimeout(()=>{r.classList.remove(o)},1e3)})}}_emitChangeEvent(){this._controlValueAccessorChangeFn(this.checked),this.change.emit(this._createChangeEvent(this.checked)),this._inputElement&&(this._inputElement.nativeElement.checked=this.checked)}toggle(){this.checked=!this.checked,this._controlValueAccessorChangeFn(this.checked)}_handleInputClick(){let e=this._options?.clickAction;this.disabled||"noop"===e?!this.disabled&&"noop"===e&&(this._inputElement.nativeElement.checked=this.checked,this._inputElement.nativeElement.indeterminate=this.indeterminate):(this.indeterminate&&"check"!==e&&Promise.resolve().then(()=>{this._indeterminate=!1,this.indeterminateChange.emit(this._indeterminate)}),this._checked=!this._checked,this._transitionCheckState(this._checked?1:2),this._emitChangeEvent())}_onInteractionEvent(e){e.stopPropagation()}_onBlur(){Promise.resolve().then(()=>{this._onTouched(),this._changeDetectorRef.markForCheck()})}_getAnimationClassForCheckStateTransition(e,i){if("NoopAnimations"===this._animationMode)return"";switch(e){case 0:if(1===i)return this._animationClasses.uncheckedToChecked;if(3==i)return this._checked?this._animationClasses.checkedToIndeterminate:this._animationClasses.uncheckedToIndeterminate;break;case 2:return 1===i?this._animationClasses.uncheckedToChecked:this._animationClasses.uncheckedToIndeterminate;case 1:return 2===i?this._animationClasses.checkedToUnchecked:this._animationClasses.checkedToIndeterminate;case 3:return 1===i?this._animationClasses.indeterminateToChecked:this._animationClasses.indeterminateToUnchecked}return""}_syncIndeterminate(e){let i=this._inputElement;i&&(i.nativeElement.indeterminate=e)}}return n.\u0275fac=function(e){Is()},n.\u0275dir=we({type:n,viewQuery:function(e,i){if(1&e&&(Ge(_xe,5),Ge(bxe,5),Ge(mo,5)),2&e){let r;Se(r=Ee())&&(i._inputElement=r.first),Se(r=Ee())&&(i._labelElement=r.first),Se(r=Ee())&&(i.ripple=r.first)}},inputs:{ariaLabel:["aria-label","ariaLabel"],ariaLabelledby:["aria-labelledby","ariaLabelledby"],ariaDescribedby:["aria-describedby","ariaDescribedby"],id:"id",required:"required",labelPosition:"labelPosition",name:"name",value:"value",checked:"checked",disabled:"disabled",indeterminate:"indeterminate"},outputs:{change:"change",indeterminateChange:"indeterminateChange"},features:[Ke]}),n})(),ha=(()=>{class n extends wxe{constructor(e,i,r,o,s,a){super("mat-mdc-checkbox-",e,i,r,o,s,a),this._animationClasses={uncheckedToChecked:"mdc-checkbox--anim-unchecked-checked",uncheckedToIndeterminate:"mdc-checkbox--anim-unchecked-indeterminate",checkedToUnchecked:"mdc-checkbox--anim-checked-unchecked",checkedToIndeterminate:"mdc-checkbox--anim-checked-indeterminate",indeterminateToChecked:"mdc-checkbox--anim-indeterminate-checked",indeterminateToUnchecked:"mdc-checkbox--anim-indeterminate-unchecked"}}focus(){this._inputElement.nativeElement.focus()}_createChangeEvent(e){let i=new class{};return i.source=this,i.checked=e,i}_getAnimationTargetElement(){return this._inputElement?.nativeElement}_onInputClick(){super._handleInputClick()}_onTouchTargetClick(){super._handleInputClick(),this.disabled||this._inputElement.nativeElement.focus()}_preventBubblingFromLabel(e){e.target&&this._labelElement.nativeElement.contains(e.target)&&e.stopPropagation()}}return n.\u0275fac=function(e){return new(e||n)(C(Me),C($t),C(at),yo("tabindex"),C(hi,8),C(yxe,8))},n.\u0275cmp=O({type:n,selectors:[["mat-checkbox"]],hostAttrs:[1,"mat-mdc-checkbox"],hostVars:12,hostBindings:function(e,i){2&e&&(jo("id",i.id),Be("tabindex",null)("aria-label",null)("aria-labelledby",null),nt("_mat-animation-noopable","NoopAnimations"===i._animationMode)("mdc-checkbox--disabled",i.disabled)("mat-mdc-checkbox-disabled",i.disabled)("mat-mdc-checkbox-checked",i.checked))},inputs:{disableRipple:"disableRipple",color:"color",tabIndex:"tabIndex"},exportAs:["matCheckbox"],features:[Qt([xxe]),Ke],ngContentSelectors:vxe,decls:15,vars:19,consts:[[1,"mdc-form-field",3,"click"],[1,"mdc-checkbox"],["checkbox",""],[1,"mat-mdc-checkbox-touch-target",3,"click"],["type","checkbox",1,"mdc-checkbox__native-control",3,"checked","indeterminate","disabled","id","required","tabIndex","blur","click","change"],["input",""],[1,"mdc-checkbox__ripple"],[1,"mdc-checkbox__background"],["focusable","false","viewBox","0 0 24 24","aria-hidden","true",1,"mdc-checkbox__checkmark"],["fill","none","d","M1.73,12.91 8.1,19.28 22.79,4.59",1,"mdc-checkbox__checkmark-path"],[1,"mdc-checkbox__mixedmark"],["mat-ripple","",1,"mat-mdc-checkbox-ripple","mat-mdc-focus-indicator",3,"matRippleTrigger","matRippleDisabled","matRippleCentered"],[3,"for"],["label",""]],template:function(e,i){if(1&e&&(Dn(),h(0,"div",0),I("click",function(o){return i._preventBubblingFromLabel(o)}),h(1,"div",1,2)(3,"div",3),I("click",function(){return i._onTouchTargetClick()}),g(),h(4,"input",4,5),I("blur",function(){return i._onBlur()})("click",function(){return i._onInputClick()})("change",function(o){return i._onInteractionEvent(o)}),g(),P(6,"div",6),h(7,"div",7),Nn(),h(8,"svg",8),P(9,"path",9),g(),Oo(),P(10,"div",10),g(),P(11,"div",11),g(),h(12,"label",12,13),zt(14),g()()),2&e){let r=it(2);nt("mdc-form-field--align-end","before"==i.labelPosition),v(4),nt("mdc-checkbox--selected",i.checked),_("checked",i.checked)("indeterminate",i.indeterminate)("disabled",i.disabled)("id",i.inputId)("required",i.required)("tabIndex",i.tabIndex),Be("aria-label",i.ariaLabel||null)("aria-labelledby",i.ariaLabelledby)("aria-describedby",i.ariaDescribedby)("name",i.name)("value",i.value),v(7),_("matRippleTrigger",r)("matRippleDisabled",i.disableRipple||i.disabled)("matRippleCentered",!0),v(1),_("for",i.inputId)}},dependencies:[mo],styles:['.mdc-touch-target-wrapper{display:inline}@keyframes mdc-checkbox-unchecked-checked-checkmark-path{0%,50%{stroke-dashoffset:29.7833385}50%{animation-timing-function:cubic-bezier(0, 0, 0.2, 1)}100%{stroke-dashoffset:0}}@keyframes mdc-checkbox-unchecked-indeterminate-mixedmark{0%,68.2%{transform:scaleX(0)}68.2%{animation-timing-function:cubic-bezier(0, 0, 0, 1)}100%{transform:scaleX(1)}}@keyframes mdc-checkbox-checked-unchecked-checkmark-path{from{animation-timing-function:cubic-bezier(0.4, 0, 1, 1);opacity:1;stroke-dashoffset:0}to{opacity:0;stroke-dashoffset:-29.7833385}}@keyframes mdc-checkbox-checked-indeterminate-checkmark{from{animation-timing-function:cubic-bezier(0, 0, 0.2, 1);transform:rotate(0deg);opacity:1}to{transform:rotate(45deg);opacity:0}}@keyframes mdc-checkbox-indeterminate-checked-checkmark{from{animation-timing-function:cubic-bezier(0.14, 0, 0, 1);transform:rotate(45deg);opacity:0}to{transform:rotate(360deg);opacity:1}}@keyframes mdc-checkbox-checked-indeterminate-mixedmark{from{animation-timing-function:mdc-animation-deceleration-curve-timing-function;transform:rotate(-45deg);opacity:0}to{transform:rotate(0deg);opacity:1}}@keyframes mdc-checkbox-indeterminate-checked-mixedmark{from{animation-timing-function:cubic-bezier(0.14, 0, 0, 1);transform:rotate(0deg);opacity:1}to{transform:rotate(315deg);opacity:0}}@keyframes mdc-checkbox-indeterminate-unchecked-mixedmark{0%{animation-timing-function:linear;transform:scaleX(1);opacity:1}32.8%,100%{transform:scaleX(0);opacity:0}}.mdc-checkbox{display:inline-block;position:relative;flex:0 0 18px;box-sizing:content-box;width:18px;height:18px;line-height:0;white-space:nowrap;cursor:pointer;vertical-align:bottom}.mdc-checkbox[hidden]{display:none}.mdc-checkbox.mdc-ripple-upgraded--background-focused .mdc-checkbox__focus-ring,.mdc-checkbox:not(.mdc-ripple-upgraded):focus .mdc-checkbox__focus-ring{pointer-events:none;border:2px solid rgba(0,0,0,0);border-radius:6px;box-sizing:content-box;position:absolute;top:50%;left:50%;transform:translate(-50%, -50%);height:100%;width:100%}@media screen and (forced-colors: active){.mdc-checkbox.mdc-ripple-upgraded--background-focused .mdc-checkbox__focus-ring,.mdc-checkbox:not(.mdc-ripple-upgraded):focus .mdc-checkbox__focus-ring{border-color:CanvasText}}.mdc-checkbox.mdc-ripple-upgraded--background-focused .mdc-checkbox__focus-ring::after,.mdc-checkbox:not(.mdc-ripple-upgraded):focus .mdc-checkbox__focus-ring::after{content:"";border:2px solid rgba(0,0,0,0);border-radius:8px;display:block;position:absolute;top:50%;left:50%;transform:translate(-50%, -50%);height:calc(100% + 4px);width:calc(100% + 4px)}@media screen and (forced-colors: active){.mdc-checkbox.mdc-ripple-upgraded--background-focused .mdc-checkbox__focus-ring::after,.mdc-checkbox:not(.mdc-ripple-upgraded):focus .mdc-checkbox__focus-ring::after{border-color:CanvasText}}@media all and (-ms-high-contrast: none){.mdc-checkbox .mdc-checkbox__focus-ring{display:none}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mdc-checkbox__mixedmark{margin:0 1px}}.mdc-checkbox--disabled{cursor:default;pointer-events:none}.mdc-checkbox__background{display:inline-flex;position:absolute;align-items:center;justify-content:center;box-sizing:border-box;width:18px;height:18px;border:2px solid currentColor;border-radius:2px;background-color:rgba(0,0,0,0);pointer-events:none;will-change:background-color,border-color;transition:background-color 90ms 0ms cubic-bezier(0.4, 0, 0.6, 1),border-color 90ms 0ms cubic-bezier(0.4, 0, 0.6, 1)}.mdc-checkbox__checkmark{position:absolute;top:0;right:0;bottom:0;left:0;width:100%;opacity:0;transition:opacity 180ms 0ms cubic-bezier(0.4, 0, 0.6, 1)}.mdc-checkbox--upgraded .mdc-checkbox__checkmark{opacity:1}.mdc-checkbox__checkmark-path{transition:stroke-dashoffset 180ms 0ms cubic-bezier(0.4, 0, 0.6, 1);stroke:currentColor;stroke-width:3.12px;stroke-dashoffset:29.7833385;stroke-dasharray:29.7833385}.mdc-checkbox__mixedmark{width:100%;height:0;transform:scaleX(0) rotate(0deg);border-width:1px;border-style:solid;opacity:0;transition:opacity 90ms 0ms cubic-bezier(0.4, 0, 0.6, 1),transform 90ms 0ms cubic-bezier(0.4, 0, 0.6, 1)}.mdc-checkbox--anim-unchecked-checked .mdc-checkbox__background,.mdc-checkbox--anim-unchecked-indeterminate .mdc-checkbox__background,.mdc-checkbox--anim-checked-unchecked .mdc-checkbox__background,.mdc-checkbox--anim-indeterminate-unchecked .mdc-checkbox__background{animation-duration:180ms;animation-timing-function:linear}.mdc-checkbox--anim-unchecked-checked .mdc-checkbox__checkmark-path{animation:mdc-checkbox-unchecked-checked-checkmark-path 180ms linear 0s;transition:none}.mdc-checkbox--anim-unchecked-indeterminate .mdc-checkbox__mixedmark{animation:mdc-checkbox-unchecked-indeterminate-mixedmark 90ms linear 0s;transition:none}.mdc-checkbox--anim-checked-unchecked .mdc-checkbox__checkmark-path{animation:mdc-checkbox-checked-unchecked-checkmark-path 90ms linear 0s;transition:none}.mdc-checkbox--anim-checked-indeterminate .mdc-checkbox__checkmark{animation:mdc-checkbox-checked-indeterminate-checkmark 90ms linear 0s;transition:none}.mdc-checkbox--anim-checked-indeterminate .mdc-checkbox__mixedmark{animation:mdc-checkbox-checked-indeterminate-mixedmark 90ms linear 0s;transition:none}.mdc-checkbox--anim-indeterminate-checked .mdc-checkbox__checkmark{animation:mdc-checkbox-indeterminate-checked-checkmark 500ms linear 0s;transition:none}.mdc-checkbox--anim-indeterminate-checked .mdc-checkbox__mixedmark{animation:mdc-checkbox-indeterminate-checked-mixedmark 500ms linear 0s;transition:none}.mdc-checkbox--anim-indeterminate-unchecked .mdc-checkbox__mixedmark{animation:mdc-checkbox-indeterminate-unchecked-mixedmark 300ms linear 0s;transition:none}.mdc-checkbox__native-control:checked~.mdc-checkbox__background,.mdc-checkbox__native-control:indeterminate~.mdc-checkbox__background,.mdc-checkbox__native-control[data-indeterminate=true]~.mdc-checkbox__background{transition:border-color 90ms 0ms cubic-bezier(0, 0, 0.2, 1),background-color 90ms 0ms cubic-bezier(0, 0, 0.2, 1)}.mdc-checkbox__native-control:checked~.mdc-checkbox__background .mdc-checkbox__checkmark-path,.mdc-checkbox__native-control:indeterminate~.mdc-checkbox__background .mdc-checkbox__checkmark-path,.mdc-checkbox__native-control[data-indeterminate=true]~.mdc-checkbox__background .mdc-checkbox__checkmark-path{stroke-dashoffset:0}.mdc-checkbox__native-control{position:absolute;margin:0;padding:0;opacity:0;cursor:inherit}.mdc-checkbox__native-control:disabled{cursor:default;pointer-events:none}.mdc-checkbox--touch{margin:calc((var(--mdc-checkbox-state-layer-size, 48px) - var(--mdc-checkbox-state-layer-size, 40px)) / 2)}.mdc-checkbox--touch .mdc-checkbox__native-control{top:calc((var(--mdc-checkbox-state-layer-size, 40px) - var(--mdc-checkbox-state-layer-size, 48px)) / 2);right:calc((var(--mdc-checkbox-state-layer-size, 40px) - var(--mdc-checkbox-state-layer-size, 48px)) / 2);left:calc((var(--mdc-checkbox-state-layer-size, 40px) - var(--mdc-checkbox-state-layer-size, 48px)) / 2);width:var(--mdc-checkbox-state-layer-size, 48px);height:var(--mdc-checkbox-state-layer-size, 48px)}.mdc-checkbox__native-control:checked~.mdc-checkbox__background .mdc-checkbox__checkmark{transition:opacity 180ms 0ms cubic-bezier(0, 0, 0.2, 1),transform 180ms 0ms cubic-bezier(0, 0, 0.2, 1);opacity:1}.mdc-checkbox__native-control:checked~.mdc-checkbox__background .mdc-checkbox__mixedmark{transform:scaleX(1) rotate(-45deg)}.mdc-checkbox__native-control:indeterminate~.mdc-checkbox__background .mdc-checkbox__checkmark,.mdc-checkbox__native-control[data-indeterminate=true]~.mdc-checkbox__background .mdc-checkbox__checkmark{transform:rotate(45deg);opacity:0;transition:opacity 90ms 0ms cubic-bezier(0.4, 0, 0.6, 1),transform 90ms 0ms cubic-bezier(0.4, 0, 0.6, 1)}.mdc-checkbox__native-control:indeterminate~.mdc-checkbox__background .mdc-checkbox__mixedmark,.mdc-checkbox__native-control[data-indeterminate=true]~.mdc-checkbox__background .mdc-checkbox__mixedmark{transform:scaleX(1) rotate(0deg);opacity:1}.mdc-checkbox.mdc-checkbox--upgraded .mdc-checkbox__background,.mdc-checkbox.mdc-checkbox--upgraded .mdc-checkbox__checkmark,.mdc-checkbox.mdc-checkbox--upgraded .mdc-checkbox__checkmark-path,.mdc-checkbox.mdc-checkbox--upgraded .mdc-checkbox__mixedmark{transition:none}.mdc-form-field{display:inline-flex;align-items:center;vertical-align:middle}.mdc-form-field[hidden]{display:none}.mdc-form-field>label{margin-left:0;margin-right:auto;padding-left:4px;padding-right:0;order:0}[dir=rtl] .mdc-form-field>label,.mdc-form-field>label[dir=rtl]{margin-left:auto;margin-right:0}[dir=rtl] .mdc-form-field>label,.mdc-form-field>label[dir=rtl]{padding-left:0;padding-right:4px}.mdc-form-field--nowrap>label{text-overflow:ellipsis;overflow:hidden;white-space:nowrap}.mdc-form-field--align-end>label{margin-left:auto;margin-right:0;padding-left:0;padding-right:4px;order:-1}[dir=rtl] .mdc-form-field--align-end>label,.mdc-form-field--align-end>label[dir=rtl]{margin-left:0;margin-right:auto}[dir=rtl] .mdc-form-field--align-end>label,.mdc-form-field--align-end>label[dir=rtl]{padding-left:4px;padding-right:0}.mdc-form-field--space-between{justify-content:space-between}.mdc-form-field--space-between>label{margin:0}[dir=rtl] .mdc-form-field--space-between>label,.mdc-form-field--space-between>label[dir=rtl]{margin:0}.mat-mdc-checkbox{display:inline-block;position:relative;-webkit-tap-highlight-color:rgba(0,0,0,0)}.mat-mdc-checkbox .mdc-checkbox{padding:calc((var(--mdc-checkbox-state-layer-size, 40px) - 18px) / 2);margin:calc((var(--mdc-checkbox-state-layer-size, 40px) - var(--mdc-checkbox-state-layer-size, 40px)) / 2)}.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__native-control[disabled]:not(:checked):not(:indeterminate):not([data-indeterminate=true])~.mdc-checkbox__background{border-color:var(--mdc-checkbox-disabled-unselected-icon-color, rgba(0, 0, 0, 0.38));background-color:transparent}.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__native-control[disabled]:checked~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__native-control[disabled]:indeterminate~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__native-control[data-indeterminate=true][disabled]~.mdc-checkbox__background{border-color:transparent;background-color:var(--mdc-checkbox-disabled-selected-icon-color, rgba(0, 0, 0, 0.38))}.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__native-control:enabled~.mdc-checkbox__background .mdc-checkbox__checkmark{color:var(--mdc-checkbox-selected-checkmark-color, #fff)}.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__native-control:enabled~.mdc-checkbox__background .mdc-checkbox__mixedmark{border-color:var(--mdc-checkbox-selected-checkmark-color, #fff)}.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__native-control:disabled~.mdc-checkbox__background .mdc-checkbox__checkmark{color:var(--mdc-checkbox-disabled-selected-checkmark-color, #fff)}.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__native-control:disabled~.mdc-checkbox__background .mdc-checkbox__mixedmark{border-color:var(--mdc-checkbox-disabled-selected-checkmark-color, #fff)}.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__native-control:enabled:not(:checked):not(:indeterminate):not([data-indeterminate=true])~.mdc-checkbox__background{border-color:var(--mdc-checkbox-unselected-icon-color, rgba(0, 0, 0, 0.54));background-color:transparent}.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__native-control:enabled:checked~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__native-control:enabled:indeterminate~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__native-control[data-indeterminate=true]:enabled~.mdc-checkbox__background{border-color:var(--mdc-checkbox-selected-icon-color, var(--mdc-theme-secondary, #018786));background-color:var(--mdc-checkbox-selected-icon-color, var(--mdc-theme-secondary, #018786))}@keyframes mdc-checkbox-fade-in-background-8A000000FF01878600000000FF018786{0%{border-color:var(--mdc-checkbox-unselected-icon-color, rgba(0, 0, 0, 0.54));background-color:transparent}50%{border-color:var(--mdc-checkbox-selected-icon-color, var(--mdc-theme-secondary, #018786));background-color:var(--mdc-checkbox-selected-icon-color, var(--mdc-theme-secondary, #018786))}}@keyframes mdc-checkbox-fade-out-background-8A000000FF01878600000000FF018786{0%,80%{border-color:var(--mdc-checkbox-selected-icon-color, var(--mdc-theme-secondary, #018786));background-color:var(--mdc-checkbox-selected-icon-color, var(--mdc-theme-secondary, #018786))}100%{border-color:var(--mdc-checkbox-unselected-icon-color, rgba(0, 0, 0, 0.54));background-color:transparent}}.mat-mdc-checkbox .mdc-checkbox.mdc-checkbox--anim-unchecked-checked .mdc-checkbox__native-control:enabled~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox.mdc-checkbox--anim-unchecked-indeterminate .mdc-checkbox__native-control:enabled~.mdc-checkbox__background{animation-name:mdc-checkbox-fade-in-background-8A000000FF01878600000000FF018786}.mat-mdc-checkbox .mdc-checkbox.mdc-checkbox--anim-checked-unchecked .mdc-checkbox__native-control:enabled~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox.mdc-checkbox--anim-indeterminate-unchecked .mdc-checkbox__native-control:enabled~.mdc-checkbox__background{animation-name:mdc-checkbox-fade-out-background-8A000000FF01878600000000FF018786}.mat-mdc-checkbox .mdc-checkbox:hover .mdc-checkbox__native-control:enabled:not(:checked):not(:indeterminate):not([data-indeterminate=true])~.mdc-checkbox__background{border-color:var(--mdc-checkbox-unselected-hover-icon-color, var(--mdc-theme-secondary, #018786));background-color:transparent}.mat-mdc-checkbox .mdc-checkbox:hover .mdc-checkbox__native-control:enabled:checked~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox:hover .mdc-checkbox__native-control:enabled:indeterminate~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox:hover .mdc-checkbox__native-control[data-indeterminate=true]:enabled~.mdc-checkbox__background{border-color:var(--mdc-checkbox-selected-hover-icon-color, var(--mdc-theme-secondary, #018786));background-color:var(--mdc-checkbox-selected-hover-icon-color, var(--mdc-theme-secondary, #018786))}@keyframes mdc-checkbox-fade-in-background-FF018786FF01878600000000FF018786{0%{border-color:var(--mdc-checkbox-unselected-hover-icon-color, var(--mdc-theme-secondary, #018786));background-color:transparent}50%{border-color:var(--mdc-checkbox-selected-hover-icon-color, var(--mdc-theme-secondary, #018786));background-color:var(--mdc-checkbox-selected-hover-icon-color, var(--mdc-theme-secondary, #018786))}}@keyframes mdc-checkbox-fade-out-background-FF018786FF01878600000000FF018786{0%,80%{border-color:var(--mdc-checkbox-selected-hover-icon-color, var(--mdc-theme-secondary, #018786));background-color:var(--mdc-checkbox-selected-hover-icon-color, var(--mdc-theme-secondary, #018786))}100%{border-color:var(--mdc-checkbox-unselected-hover-icon-color, var(--mdc-theme-secondary, #018786));background-color:transparent}}.mat-mdc-checkbox .mdc-checkbox:hover.mdc-checkbox--anim-unchecked-checked .mdc-checkbox__native-control:enabled~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox:hover.mdc-checkbox--anim-unchecked-indeterminate .mdc-checkbox__native-control:enabled~.mdc-checkbox__background{animation-name:mdc-checkbox-fade-in-background-FF018786FF01878600000000FF018786}.mat-mdc-checkbox .mdc-checkbox:hover.mdc-checkbox--anim-checked-unchecked .mdc-checkbox__native-control:enabled~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox:hover.mdc-checkbox--anim-indeterminate-unchecked .mdc-checkbox__native-control:enabled~.mdc-checkbox__background{animation-name:mdc-checkbox-fade-out-background-FF018786FF01878600000000FF018786}.mat-mdc-checkbox .mdc-checkbox.mdc-ripple-upgraded--background-focused .mdc-checkbox__native-control:enabled:not(:checked):not(:indeterminate):not([data-indeterminate=true])~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox:not(.mdc-ripple-upgraded):focus .mdc-checkbox__native-control:enabled:not(:checked):not(:indeterminate):not([data-indeterminate=true])~.mdc-checkbox__background{border-color:var(--mdc-checkbox-unselected-focus-icon-color, var(--mdc-theme-secondary, #018786));background-color:transparent}.mat-mdc-checkbox .mdc-checkbox.mdc-ripple-upgraded--background-focused .mdc-checkbox__native-control:enabled:checked~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox.mdc-ripple-upgraded--background-focused .mdc-checkbox__native-control:enabled:indeterminate~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox.mdc-ripple-upgraded--background-focused .mdc-checkbox__native-control[data-indeterminate=true]:enabled~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox:not(.mdc-ripple-upgraded):focus .mdc-checkbox__native-control:enabled:checked~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox:not(.mdc-ripple-upgraded):focus .mdc-checkbox__native-control:enabled:indeterminate~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox:not(.mdc-ripple-upgraded):focus .mdc-checkbox__native-control[data-indeterminate=true]:enabled~.mdc-checkbox__background{border-color:var(--mdc-checkbox-selected-focus-icon-color, var(--mdc-theme-secondary, #018786));background-color:var(--mdc-checkbox-selected-focus-icon-color, var(--mdc-theme-secondary, #018786))}@keyframes mdc-checkbox-fade-in-background-FF018786FF01878600000000FF018786{0%{border-color:var(--mdc-checkbox-unselected-focus-icon-color, var(--mdc-theme-secondary, #018786));background-color:transparent}50%{border-color:var(--mdc-checkbox-selected-focus-icon-color, var(--mdc-theme-secondary, #018786));background-color:var(--mdc-checkbox-selected-focus-icon-color, var(--mdc-theme-secondary, #018786))}}@keyframes mdc-checkbox-fade-out-background-FF018786FF01878600000000FF018786{0%,80%{border-color:var(--mdc-checkbox-selected-focus-icon-color, var(--mdc-theme-secondary, #018786));background-color:var(--mdc-checkbox-selected-focus-icon-color, var(--mdc-theme-secondary, #018786))}100%{border-color:var(--mdc-checkbox-unselected-focus-icon-color, var(--mdc-theme-secondary, #018786));background-color:transparent}}.mat-mdc-checkbox .mdc-checkbox.mdc-ripple-upgraded--background-focused.mdc-checkbox--anim-unchecked-checked .mdc-checkbox__native-control:enabled~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox.mdc-ripple-upgraded--background-focused.mdc-checkbox--anim-unchecked-indeterminate .mdc-checkbox__native-control:enabled~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox:not(.mdc-ripple-upgraded):focus.mdc-checkbox--anim-unchecked-checked .mdc-checkbox__native-control:enabled~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox:not(.mdc-ripple-upgraded):focus.mdc-checkbox--anim-unchecked-indeterminate .mdc-checkbox__native-control:enabled~.mdc-checkbox__background{animation-name:mdc-checkbox-fade-in-background-FF018786FF01878600000000FF018786}.mat-mdc-checkbox .mdc-checkbox.mdc-ripple-upgraded--background-focused.mdc-checkbox--anim-checked-unchecked .mdc-checkbox__native-control:enabled~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox.mdc-ripple-upgraded--background-focused.mdc-checkbox--anim-indeterminate-unchecked .mdc-checkbox__native-control:enabled~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox:not(.mdc-ripple-upgraded):focus.mdc-checkbox--anim-checked-unchecked .mdc-checkbox__native-control:enabled~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox:not(.mdc-ripple-upgraded):focus.mdc-checkbox--anim-indeterminate-unchecked .mdc-checkbox__native-control:enabled~.mdc-checkbox__background{animation-name:mdc-checkbox-fade-out-background-FF018786FF01878600000000FF018786}.mat-mdc-checkbox .mdc-checkbox:not(:disabled):active .mdc-checkbox__native-control:enabled:not(:checked):not(:indeterminate):not([data-indeterminate=true])~.mdc-checkbox__background{border-color:var(--mdc-checkbox-unselected-pressed-icon-color, rgba(0, 0, 0, 0.54));background-color:transparent}.mat-mdc-checkbox .mdc-checkbox:not(:disabled):active .mdc-checkbox__native-control:enabled:checked~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox:not(:disabled):active .mdc-checkbox__native-control:enabled:indeterminate~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox:not(:disabled):active .mdc-checkbox__native-control[data-indeterminate=true]:enabled~.mdc-checkbox__background{border-color:var(--mdc-checkbox-selected-pressed-icon-color, var(--mdc-theme-secondary, #018786));background-color:var(--mdc-checkbox-selected-pressed-icon-color, var(--mdc-theme-secondary, #018786))}@keyframes mdc-checkbox-fade-in-background-8A000000FF01878600000000FF018786{0%{border-color:var(--mdc-checkbox-unselected-pressed-icon-color, rgba(0, 0, 0, 0.54));background-color:transparent}50%{border-color:var(--mdc-checkbox-selected-pressed-icon-color, var(--mdc-theme-secondary, #018786));background-color:var(--mdc-checkbox-selected-pressed-icon-color, var(--mdc-theme-secondary, #018786))}}@keyframes mdc-checkbox-fade-out-background-8A000000FF01878600000000FF018786{0%,80%{border-color:var(--mdc-checkbox-selected-pressed-icon-color, var(--mdc-theme-secondary, #018786));background-color:var(--mdc-checkbox-selected-pressed-icon-color, var(--mdc-theme-secondary, #018786))}100%{border-color:var(--mdc-checkbox-unselected-pressed-icon-color, rgba(0, 0, 0, 0.54));background-color:transparent}}.mat-mdc-checkbox .mdc-checkbox:not(:disabled):active.mdc-checkbox--anim-unchecked-checked .mdc-checkbox__native-control:enabled~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox:not(:disabled):active.mdc-checkbox--anim-unchecked-indeterminate .mdc-checkbox__native-control:enabled~.mdc-checkbox__background{animation-name:mdc-checkbox-fade-in-background-8A000000FF01878600000000FF018786}.mat-mdc-checkbox .mdc-checkbox:not(:disabled):active.mdc-checkbox--anim-checked-unchecked .mdc-checkbox__native-control:enabled~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox:not(:disabled):active.mdc-checkbox--anim-indeterminate-unchecked .mdc-checkbox__native-control:enabled~.mdc-checkbox__background{animation-name:mdc-checkbox-fade-out-background-8A000000FF01878600000000FF018786}.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__background{top:calc((var(--mdc-checkbox-state-layer-size, 40px) - 18px) / 2);left:calc((var(--mdc-checkbox-state-layer-size, 40px) - 18px) / 2)}.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__native-control{top:calc((var(--mdc-checkbox-state-layer-size, 40px) - var(--mdc-checkbox-state-layer-size, 40px)) / 2);right:calc((var(--mdc-checkbox-state-layer-size, 40px) - var(--mdc-checkbox-state-layer-size, 40px)) / 2);left:calc((var(--mdc-checkbox-state-layer-size, 40px) - var(--mdc-checkbox-state-layer-size, 40px)) / 2);width:var(--mdc-checkbox-state-layer-size, 40px);height:var(--mdc-checkbox-state-layer-size, 40px)}.mat-mdc-checkbox .mdc-checkbox:hover .mdc-checkbox__native-control:not([disabled])~.mdc-checkbox__ripple{opacity:.04;transform:scale(1);transition:opacity 80ms 0 cubic-bezier(0, 0, 0.2, 1),transform 80ms 0 cubic-bezier(0, 0, 0.2, 1)}.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__native-control:not([disabled]):focus~.mdc-checkbox__ripple{opacity:.16}.mat-mdc-checkbox .mdc-checkbox__background{-webkit-print-color-adjust:exact;color-adjust:exact}.mat-mdc-checkbox._mat-animation-noopable *,.mat-mdc-checkbox._mat-animation-noopable *::before{transition:none !important;animation:none !important}.mat-mdc-checkbox label{cursor:pointer}.mat-mdc-checkbox.mat-mdc-checkbox-disabled label{cursor:default}.mat-mdc-checkbox label:empty{display:none}.mat-mdc-checkbox .mdc-checkbox__native-control:focus:enabled:not(:checked):not(:indeterminate):not([data-indeterminate=true])~.mdc-checkbox__background{border-color:var(--mdc-checkbox-unselected-focus-icon-color, black)}.cdk-high-contrast-active .mat-mdc-checkbox.mat-mdc-checkbox-disabled{opacity:.5}.cdk-high-contrast-active .mat-mdc-checkbox .mdc-checkbox__checkmark{--mdc-checkbox-selected-checkmark-color: CanvasText;--mdc-checkbox-disabled-selected-checkmark-color: CanvasText}.mat-mdc-checkbox .mdc-checkbox__ripple{opacity:0}.mat-mdc-checkbox-ripple,.mdc-checkbox__ripple{top:0;left:0;right:0;bottom:0;position:absolute;border-radius:50%;pointer-events:none}.mat-mdc-checkbox-ripple:not(:empty),.mdc-checkbox__ripple:not(:empty){transform:translateZ(0)}.mat-mdc-checkbox-touch-target{position:absolute;top:50%;height:48px;left:50%;width:48px;transform:translate(-50%, -50%)}.mat-mdc-checkbox-ripple::before{border-radius:50%}.mdc-checkbox__native-control:focus~.mat-mdc-focus-indicator::before{content:""}'],encapsulation:2,changeDetection:0}),n})(),Sxe={provide:wo,useExisting:$n(()=>Exe),multi:!0},Exe=(()=>{class n extends Z2{}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275dir=we({type:n,selectors:[["mat-checkbox","required","","formControlName",""],["mat-checkbox","required","","formControl",""],["mat-checkbox","required","","ngModel",""]],features:[Qt([Sxe]),Ke]}),n})(),Bq=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({}),n})(),Fc=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[fn,Bl,Bq,fn,Bq]}),n})(),Hq=qo({passive:!0}),zq=(()=>{class n{constructor(e,i){this._platform=e,this._ngZone=i,this._monitoredElements=new Map}monitor(e){if(!this._platform.isBrowser)return Jr;let i=Hs(e),r=this._monitoredElements.get(i);if(r)return r.subject;let o=new Ie,s="cdk-text-field-autofilled",a=l=>{"cdk-text-field-autofill-start"!==l.animationName||i.classList.contains(s)?"cdk-text-field-autofill-end"===l.animationName&&i.classList.contains(s)&&(i.classList.remove(s),this._ngZone.run(()=>o.next({target:l.target,isAutofilled:!1}))):(i.classList.add(s),this._ngZone.run(()=>o.next({target:l.target,isAutofilled:!0})))};return this._ngZone.runOutsideAngular(()=>{i.addEventListener("animationstart",a,Hq),i.classList.add("cdk-text-field-autofill-monitored")}),this._monitoredElements.set(i,{subject:o,unlisten:()=>{i.removeEventListener("animationstart",a,Hq)}}),o}stopMonitoring(e){let i=Hs(e),r=this._monitoredElements.get(i);r&&(r.unlisten(),r.subject.complete(),i.classList.remove("cdk-text-field-autofill-monitored"),i.classList.remove("cdk-text-field-autofilled"),this._monitoredElements.delete(i))}ngOnDestroy(){this._monitoredElements.forEach((e,i)=>this.stopMonitoring(i))}}return n.\u0275fac=function(e){return new(e||n)(k(Gn),k(at))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),Uq=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({}),n})(),Dxe=new ie("MAT_INPUT_VALUE_ACCESSOR"),Ixe=["button","checkbox","file","hidden","image","radio","range","reset","submit"],Axe=0,Rxe=B1(class{constructor(n,t,e,i){this._defaultErrorStateMatcher=n,this._parentForm=t,this._parentFormGroup=e,this.ngControl=i,this.stateChanges=new Ie}}),Uu=(()=>{class n extends Rxe{get disabled(){return this._disabled}set disabled(e){this._disabled=Rt(e),this.focused&&(this.focused=!1,this.stateChanges.next())}get id(){return this._id}set id(e){this._id=e||this._uid}get required(){return this._required??this.ngControl?.control?.hasValidator(Ul.required)??!1}set required(e){this._required=Rt(e)}get type(){return this._type}set type(e){this._type=e||"text",this._validateType(),!this._isTextarea&&o2().has(this._type)&&(this._elementRef.nativeElement.type=this._type)}get value(){return this._inputValueAccessor.value}set value(e){e!==this.value&&(this._inputValueAccessor.value=e,this.stateChanges.next())}get readonly(){return this._readonly}set readonly(e){this._readonly=Rt(e)}constructor(e,i,r,o,s,a,l,c,d,u){super(a,o,s,r),this._elementRef=e,this._platform=i,this._autofillMonitor=c,this._formField=u,this._uid="mat-input-"+Axe++,this.focused=!1,this.stateChanges=new Ie,this.controlType="mat-input",this.autofilled=!1,this._disabled=!1,this._type="text",this._readonly=!1,this._neverEmptyInputTypes=["date","datetime","datetime-local","month","time","week"].filter(m=>o2().has(m)),this._iOSKeyupListener=m=>{let b=m.target;!b.value&&0===b.selectionStart&&0===b.selectionEnd&&(b.setSelectionRange(1,1),b.setSelectionRange(0,0))};let p=this._elementRef.nativeElement,f=p.nodeName.toLowerCase();this._inputValueAccessor=l||p,this._previousNativeValue=this.value,this.id=this.id,i.IOS&&d.runOutsideAngular(()=>{e.nativeElement.addEventListener("keyup",this._iOSKeyupListener)}),this._isServer=!this._platform.isBrowser,this._isNativeSelect="select"===f,this._isTextarea="textarea"===f,this._isInFormField=!!u,this._isNativeSelect&&(this.controlType=p.multiple?"mat-native-select-multiple":"mat-native-select")}ngAfterViewInit(){this._platform.isBrowser&&this._autofillMonitor.monitor(this._elementRef.nativeElement).subscribe(e=>{this.autofilled=e.isAutofilled,this.stateChanges.next()})}ngOnChanges(){this.stateChanges.next()}ngOnDestroy(){this.stateChanges.complete(),this._platform.isBrowser&&this._autofillMonitor.stopMonitoring(this._elementRef.nativeElement),this._platform.IOS&&this._elementRef.nativeElement.removeEventListener("keyup",this._iOSKeyupListener)}ngDoCheck(){this.ngControl&&(this.updateErrorState(),null!==this.ngControl.disabled&&this.ngControl.disabled!==this.disabled&&(this.disabled=this.ngControl.disabled,this.stateChanges.next())),this._dirtyCheckNativeValue(),this._dirtyCheckPlaceholder()}focus(e){this._elementRef.nativeElement.focus(e)}_focusChanged(e){e!==this.focused&&(this.focused=e,this.stateChanges.next())}_onInput(){}_dirtyCheckNativeValue(){let e=this._elementRef.nativeElement.value;this._previousNativeValue!==e&&(this._previousNativeValue=e,this.stateChanges.next())}_dirtyCheckPlaceholder(){let e=this._getPlaceholder();if(e!==this._previousPlaceholder){let i=this._elementRef.nativeElement;this._previousPlaceholder=e,e?i.setAttribute("placeholder",e):i.removeAttribute("placeholder")}}_getPlaceholder(){return this.placeholder||null}_validateType(){Ixe.indexOf(this._type)}_isNeverEmpty(){return this._neverEmptyInputTypes.indexOf(this._type)>-1}_isBadInput(){let e=this._elementRef.nativeElement.validity;return e&&e.badInput}get empty(){return!(this._isNeverEmpty()||this._elementRef.nativeElement.value||this._isBadInput()||this.autofilled)}get shouldLabelFloat(){if(this._isNativeSelect){let e=this._elementRef.nativeElement,i=e.options[0];return this.focused||e.multiple||!this.empty||!!(e.selectedIndex>-1&&i&&i.label)}return this.focused||!this.empty}setDescribedByIds(e){e.length?this._elementRef.nativeElement.setAttribute("aria-describedby",e.join(" ")):this._elementRef.nativeElement.removeAttribute("aria-describedby")}onContainerClick(){this.focused||this.focus()}_isInlineSelect(){let e=this._elementRef.nativeElement;return this._isNativeSelect&&(e.multiple||e.size>1)}}return n.\u0275fac=function(e){return new(e||n)(C(Me),C(Gn),C(Gs,10),C(vg,8),C(yg,8),C(H1),C(Dxe,10),C(zq),C(at),C(Sf,8))},n.\u0275dir=we({type:n,selectors:[["input","matInput",""],["textarea","matInput",""],["select","matNativeControl",""],["input","matNativeControl",""],["textarea","matNativeControl",""]],hostAttrs:[1,"mat-mdc-input-element"],hostVars:18,hostBindings:function(e,i){1&e&&I("focus",function(){return i._focusChanged(!0)})("blur",function(){return i._focusChanged(!1)})("input",function(){return i._onInput()}),2&e&&(jo("id",i.id)("disabled",i.disabled)("required",i.required),Be("name",i.name||null)("readonly",i.readonly&&!i._isNativeSelect||null)("aria-invalid",i.empty&&i.required?null:i.errorState)("aria-required",i.required)("id",i.id),nt("mat-input-server",i._isServer)("mat-mdc-form-field-textarea-control",i._isInFormField&&i._isTextarea)("mat-mdc-form-field-input-control",i._isInFormField)("mdc-text-field__input",i._isInFormField)("mat-mdc-native-select-inline",i._isInlineSelect()))},inputs:{disabled:"disabled",id:"id",placeholder:"placeholder",name:"name",required:"required",type:"type",errorStateMatcher:"errorStateMatcher",userAriaDescribedBy:["aria-describedby","userAriaDescribedBy"],value:"value",readonly:"readonly"},exportAs:["matInput"],features:[Qt([{provide:Qv,useExisting:n}]),Ke,Gt]}),n})(),$a=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[fn,Ef,Ef,Uq,fn]}),n})();function Pxe(n,t){if(1&n&&(h(0,"mat-error"),T(1),g()),2&n){let e=w();v(1),He(" Reload period has to be minimum of ",e.MIN_RELOAD_PERIOD_IN_S," seconds. ")}}function Oxe(n,t){1&n&&(h(0,"mat-error"),T(1," Page size has to be a positive integer. "),g())}var jq=(()=>{class n{constructor(){this.reloadToggled=new F,this.reloadPeriodInMsChanged=new F,this.pageSizeChanged=new F,this.MIN_RELOAD_PERIOD_IN_S=30,this.reloadPeriodControl=new ty(this.MIN_RELOAD_PERIOD_IN_S,[Ul.required,Ul.min(this.MIN_RELOAD_PERIOD_IN_S)]),this.paginationControl=new ty(1,[Ul.required,Ul.min(1),n=>{let t=Number(n.value);return Math.round(t)===n.value?null:{integer:{value:n.value}}}]),this.ngUnsubscribe=new Ie}ngOnInit(){this.reloadPeriodControl.valueChanges.pipe(ot(this.ngUnsubscribe),wr(500),ke(()=>this.reloadPeriodControl.valid)).subscribe(()=>{this.reloadPeriodControl.valid&&this.reloadPeriodInMsChanged.emit(1e3*this.reloadPeriodControl.value)}),this.paginationControl.valueChanges.pipe(ot(this.ngUnsubscribe),wr(500),ke(()=>this.paginationControl.valid)).subscribe(()=>{this.pageSizeChanged.emit(this.paginationControl.value)})}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}ngOnChanges(e){if(e.reloadPeriodInMs){let i=e.reloadPeriodInMs;i.previousValue!==i.currentValue&&this.reloadPeriodControl.setValue(i.currentValue/1e3)}if(e.reloadEnabled&&(e.reloadEnabled.currentValue?this.reloadPeriodControl.enable():this.reloadPeriodControl.disable()),e.pageSize){let i=e.pageSize;i.previousValue!==i.currentValue&&this.paginationControl.setValue(i.currentValue)}}onReloadToggle(){this.reloadToggled.emit()}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["settings-dialog-component"]],inputs:{reloadEnabled:"reloadEnabled",reloadPeriodInMs:"reloadPeriodInMs",pageSize:"pageSize"},outputs:{reloadToggled:"reloadToggled",reloadPeriodInMsChanged:"reloadPeriodInMsChanged",pageSizeChanged:"pageSizeChanged"},features:[Gt],decls:18,vars:5,consts:[[1,"reload-toggle"],[3,"checked","change"],["matInput","","type","number",1,"reload-period",3,"formControl"],[4,"ngIf"],["matInput","","type","number",1,"page-size",3,"formControl"]],template:function(e,i){1&e&&(h(0,"h3"),T(1,"Settings"),g(),h(2,"div")(3,"div",0)(4,"mat-checkbox",1),I("change",function(){return i.onReloadToggle()}),T(5,"Reload data"),g()(),h(6,"div")(7,"mat-form-field")(8,"mat-label"),T(9,"Reload Period (seconds)"),g(),P(10,"input",2),g(),S(11,Pxe,2,1,"mat-error",3),g()(),h(12,"div")(13,"mat-form-field")(14,"mat-label"),T(15,"Pagination Limit"),g(),P(16,"input",4),g(),S(17,Oxe,2,0,"mat-error",3),g()),2&e&&(v(4),_("checked",i.reloadEnabled),v(6),_("formControl",i.reloadPeriodControl),v(1),_("ngIf",i.reloadPeriodControl.hasError("min")||i.reloadPeriodControl.hasError("required")),v(5),_("formControl",i.paginationControl),v(1),_("ngIf",i.paginationControl.invalid))},dependencies:[Fe,bg,Y2,cE,Q2,ha,Uu,Ka,kc,M9],styles:["[_nghost-%COMP%] {\n  font-size: 15px;\n}\n\n[_nghost-%COMP%]    > div[_ngcontent-%COMP%] {\n  margin: 16px;\n}\n\nh3[_ngcontent-%COMP%] {\n  font-size: 20px;\n  margin: 16px;\n}\n\n.reload-toggle[_ngcontent-%COMP%] {\n  margin-bottom: 16px;\n}"]}),n})(),Gq=(()=>{class n{constructor(e){this.store=e,this.reloadEnabled$=this.store.select(Iv),this.reloadPeriodInMs$=this.store.select(Av),this.pageSize$=this.store.select(_f)}onReloadToggled(){this.store.dispatch(y1())}onReloadPeriodInMsChanged(e){this.store.dispatch(x1({periodInMs:e}))}onPageSizeChanged(e){this.store.dispatch(C1({size:e}))}}return n.\u0275fac=function(e){return new(e||n)(C(Ae))},n.\u0275cmp=O({type:n,selectors:[["settings-dialog"]],decls:4,vars:9,consts:[[3,"reloadEnabled","reloadPeriodInMs","pageSize","reloadToggled","reloadPeriodInMsChanged","pageSizeChanged"]],template:function(e,i){1&e&&(h(0,"settings-dialog-component",0),I("reloadToggled",function(){return i.onReloadToggled()})("reloadPeriodInMsChanged",function(o){return i.onReloadPeriodInMsChanged(o)})("pageSizeChanged",function(o){return i.onPageSizeChanged(o)}),j(1,"async"),j(2,"async"),j(3,"async"),g()),2&e&&_("reloadEnabled",W(1,3,i.reloadEnabled$))("reloadPeriodInMs",W(2,5,i.reloadPeriodInMs$))("pageSize",W(3,7,i.pageSize$))},dependencies:[jq,ct],encapsulation:2}),n})(),Wq=(()=>{class n{constructor(e){this.dialog=e}isButtonDisabled(){return this.settingsLoadState===Te.NOT_LOADED||this.settingsLoadState===Te.LOADING}openDialog(){this.dialog.open(Gq,{width:"400px"})}}return n.\u0275fac=function(e){return new(e||n)(C(zl))},n.\u0275cmp=O({type:n,selectors:[["settings-button-component"]],inputs:{settingsLoadState:"settingsLoadState"},decls:2,vars:1,consts:[["mat-icon-button","",3,"disabled","click"],["svgIcon","settings_24px"]],template:function(e,i){1&e&&(h(0,"button",0),I("click",function(){return i.openDialog()}),P(1,"mat-icon",1),g()),2&e&&_("disabled",i.isButtonDisabled())},dependencies:[$i,En],encapsulation:2}),n})(),qq=(()=>{class n{constructor(e){this.store=e,this.settingsLoadState$=this.store.select(t2)}}return n.\u0275fac=function(e){return new(e||n)(C(Ae))},n.\u0275cmp=O({type:n,selectors:[["settings-button"]],decls:2,vars:3,consts:[[3,"settingsLoadState"]],template:function(e,i){1&e&&(P(0,"settings-button-component",0),j(1,"async")),2&e&&_("settingsLoadState",W(1,1,i.settingsLoadState$))},dependencies:[Wq,ct],encapsulation:2}),n})(),Bxe=["mat-menu-item",""];function Vxe(n,t){1&n&&(Nn(),h(0,"svg",3),P(1,"polygon",4),g())}var Hxe=[[["mat-icon"],["","matMenuItemIcon",""]],"*"],zxe=["mat-icon, [matMenuItemIcon]","*"];function Uxe(n,t){if(1&n){let e=ge();h(0,"div",0),I("keydown",function(r){return X(e),Q(w()._handleKeydown(r))})("click",function(){return X(e),Q(w().closed.emit("click"))})("@transformMenu.start",function(r){return X(e),Q(w()._onAnimationStart(r))})("@transformMenu.done",function(r){return X(e),Q(w()._onAnimationDone(r))}),h(1,"div",1),zt(2),g()()}if(2&n){let e=w();_("id",e.panelId)("ngClass",e._classList)("@transformMenu",e._panelAnimationState),Be("aria-label",e.ariaLabel||null)("aria-labelledby",e.ariaLabelledby||null)("aria-describedby",e.ariaDescribedby||null)}}var jxe=["*"],eN=new ie("MAT_MENU_PANEL"),Gxe=us(so(class{})),jl=(()=>{class n extends Gxe{constructor(e,i,r,o,s){super(),this._elementRef=e,this._document=i,this._focusMonitor=r,this._parentMenu=o,this._changeDetectorRef=s,this.role="menuitem",this._hovered=new Ie,this._focused=new Ie,this._highlighted=!1,this._triggersSubmenu=!1,o?.addItem?.(this)}focus(e,i){this._focusMonitor&&e?this._focusMonitor.focusVia(this._getHostElement(),e,i):this._getHostElement().focus(i),this._focused.next(this)}ngAfterViewInit(){this._focusMonitor&&this._focusMonitor.monitor(this._elementRef,!1)}ngOnDestroy(){this._focusMonitor&&this._focusMonitor.stopMonitoring(this._elementRef),this._parentMenu&&this._parentMenu.removeItem&&this._parentMenu.removeItem(this),this._hovered.complete(),this._focused.complete()}_getTabIndex(){return this.disabled?"-1":"0"}_getHostElement(){return this._elementRef.nativeElement}_checkDisabled(e){this.disabled&&(e.preventDefault(),e.stopPropagation())}_handleMouseEnter(){this._hovered.next(this)}getLabel(){let e=this._elementRef.nativeElement.cloneNode(!0),i=e.querySelectorAll("mat-icon, .material-icons");for(let r=0;r<i.length;r++)i[r].remove();return e.textContent?.trim()||""}_setHighlighted(e){this._highlighted=e,this._changeDetectorRef?.markForCheck()}_setTriggersSubmenu(e){this._triggersSubmenu=e,this._changeDetectorRef?.markForCheck()}_hasFocus(){return this._document&&this._document.activeElement===this._getHostElement()}}return n.\u0275fac=function(e){return new(e||n)(C(Me),C(Lt),C(Xr),C(eN,8),C($t))},n.\u0275cmp=O({type:n,selectors:[["","mat-menu-item",""]],hostAttrs:[1,"mat-mdc-menu-item","mat-mdc-focus-indicator","mdc-list-item"],hostVars:8,hostBindings:function(e,i){1&e&&I("click",function(o){return i._checkDisabled(o)})("mouseenter",function(){return i._handleMouseEnter()}),2&e&&(Be("role",i.role)("tabindex",i._getTabIndex())("aria-disabled",i.disabled)("disabled",i.disabled||null),nt("mat-mdc-menu-item-highlighted",i._highlighted)("mat-mdc-menu-item-submenu-trigger",i._triggersSubmenu))},inputs:{disabled:"disabled",disableRipple:"disableRipple",role:"role"},exportAs:["matMenuItem"],features:[Ke],attrs:Bxe,ngContentSelectors:zxe,decls:5,vars:3,consts:[[1,"mdc-list-item__primary-text"],["matRipple","",1,"mat-mdc-menu-ripple",3,"matRippleDisabled","matRippleTrigger"],["class","mat-mdc-menu-submenu-icon","viewBox","0 0 5 10","focusable","false",4,"ngIf"],["viewBox","0 0 5 10","focusable","false",1,"mat-mdc-menu-submenu-icon"],["points","0,0 5,5 0,10"]],template:function(e,i){1&e&&(Dn(Hxe),zt(0),h(1,"span",0),zt(2,1),g(),P(3,"div",1),S(4,Vxe,2,0,"svg",2)),2&e&&(v(3),_("matRippleDisabled",i.disableRipple||i.disabled)("matRippleTrigger",i._getHostElement()),v(1),_("ngIf",i._triggersSubmenu))},dependencies:[Fe,mo],encapsulation:2,changeDetection:0}),n})(),Wxe=new ie("MatMenuContent"),_E={transformMenu:_r("transformMenu",[wi("void",rn({opacity:0,transform:"scale(0.8)"})),gi("void => enter",Ci("120ms cubic-bezier(0, 0, 0.2, 1)",rn({opacity:1,transform:"scale(1)"}))),gi("* => void",Ci("100ms 25ms linear",rn({opacity:0})))]),fadeInItems:_r("fadeInItems",[wi("showing",rn({opacity:1})),gi("void => *",[rn({opacity:0}),Ci("400ms 100ms cubic-bezier(0.55, 0, 0.55, 0.2)")])])},qxe=0,Xq=new ie("mat-menu-default-options",{providedIn:"root",factory:function(){return{overlapTrigger:!1,xPosition:"after",yPosition:"below",backdropClass:"cdk-overlay-transparent-backdrop"}}}),ry=(()=>{class n{get xPosition(){return this._xPosition}set xPosition(e){this._xPosition=e,this.setPositionClasses()}get yPosition(){return this._yPosition}set yPosition(e){this._yPosition=e,this.setPositionClasses()}get overlapTrigger(){return this._overlapTrigger}set overlapTrigger(e){this._overlapTrigger=Rt(e)}get hasBackdrop(){return this._hasBackdrop}set hasBackdrop(e){this._hasBackdrop=Rt(e)}set panelClass(e){let i=this._previousPanelClass;i&&i.length&&i.split(" ").forEach(r=>{this._classList[r]=!1}),this._previousPanelClass=e,e&&e.length&&(e.split(" ").forEach(r=>{this._classList[r]=!0}),this._elementRef.nativeElement.className="")}get classList(){return this.panelClass}set classList(e){this.panelClass=e}constructor(e,i,r,o){this._elementRef=e,this._ngZone=i,this._defaultOptions=r,this._changeDetectorRef=o,this._xPosition=this._defaultOptions.xPosition,this._yPosition=this._defaultOptions.yPosition,this._directDescendantItems=new Oa,this._classList={},this._panelAnimationState="void",this._animationDone=new Ie,this.overlayPanelClass=this._defaultOptions.overlayPanelClass||"",this.backdropClass=this._defaultOptions.backdropClass,this._overlapTrigger=this._defaultOptions.overlapTrigger,this._hasBackdrop=this._defaultOptions.hasBackdrop,this.closed=new F,this.close=this.closed,this.panelId="mat-menu-panel-"+qxe++}ngOnInit(){this.setPositionClasses()}ngAfterContentInit(){this._updateDirectDescendants(),this._keyManager=new sg(this._directDescendantItems).withWrap().withTypeAhead().withHomeAndEnd(),this._keyManager.tabOut.subscribe(()=>this.closed.emit("tab")),this._directDescendantItems.changes.pipe(qn(this._directDescendantItems),Jn(e=>tn(...e.map(i=>i._focused)))).subscribe(e=>this._keyManager.updateActiveItem(e)),this._directDescendantItems.changes.subscribe(e=>{let i=this._keyManager;if("enter"===this._panelAnimationState&&i.activeItem?._hasFocus()){let r=e.toArray(),o=Math.max(0,Math.min(r.length-1,i.activeItemIndex||0));r[o]&&!r[o].disabled?i.setActiveItem(o):i.setNextItemActive()}})}ngOnDestroy(){this._keyManager?.destroy(),this._directDescendantItems.destroy(),this.closed.complete(),this._firstItemFocusSubscription?.unsubscribe()}_hovered(){return this._directDescendantItems.changes.pipe(qn(this._directDescendantItems),Jn(i=>tn(...i.map(r=>r._hovered))))}addItem(e){}removeItem(e){}_handleKeydown(e){let i=e.keyCode,r=this._keyManager;switch(i){case 27:vr(e)||(e.preventDefault(),this.closed.emit("keydown"));break;case 37:this.parentMenu&&"ltr"===this.direction&&this.closed.emit("keydown");break;case 39:this.parentMenu&&"rtl"===this.direction&&this.closed.emit("keydown");break;default:return(38===i||40===i)&&r.setFocusOrigin("keyboard"),void r.onKeydown(e)}e.stopPropagation()}focusFirstItem(e="program"){this._firstItemFocusSubscription?.unsubscribe(),this._firstItemFocusSubscription=this._ngZone.onStable.pipe(Yt(1)).subscribe(()=>{let i=null;if(this._directDescendantItems.length&&(i=this._directDescendantItems.first._getHostElement().closest('[role="menu"]')),!i||!i.contains(document.activeElement)){let r=this._keyManager;r.setFocusOrigin(e).setFirstItemActive(),!r.activeItem&&i&&i.focus()}})}resetActiveItem(){this._keyManager.setActiveItem(-1)}setElevation(e){let i=Math.min(this._baseElevation+e,24),r=`${this._elevationPrefix}${i}`,o=Object.keys(this._classList).find(s=>s.startsWith(this._elevationPrefix));(!o||o===this._previousElevation)&&(this._previousElevation&&(this._classList[this._previousElevation]=!1),this._classList[r]=!0,this._previousElevation=r)}setPositionClasses(e=this.xPosition,i=this.yPosition){let r=this._classList;r["mat-menu-before"]="before"===e,r["mat-menu-after"]="after"===e,r["mat-menu-above"]="above"===i,r["mat-menu-below"]="below"===i,this._changeDetectorRef?.markForCheck()}_startAnimation(){this._panelAnimationState="enter"}_resetAnimation(){this._panelAnimationState="void"}_onAnimationDone(e){this._animationDone.next(e),this._isAnimating=!1}_onAnimationStart(e){this._isAnimating=!0,"enter"===e.toState&&0===this._keyManager.activeItemIndex&&(e.element.scrollTop=0)}_updateDirectDescendants(){this._allItems.changes.pipe(qn(this._allItems)).subscribe(e=>{this._directDescendantItems.reset(e.filter(i=>i._parentMenu===this)),this._directDescendantItems.notifyOnChanges()})}}return n.\u0275fac=function(e){return new(e||n)(C(Me),C(at),C(Xq),C($t))},n.\u0275dir=we({type:n,contentQueries:function(e,i,r){if(1&e&&(Ti(r,Wxe,5),Ti(r,jl,5),Ti(r,jl,4)),2&e){let o;Se(o=Ee())&&(i.lazyContent=o.first),Se(o=Ee())&&(i._allItems=o),Se(o=Ee())&&(i.items=o)}},viewQuery:function(e,i){if(1&e&&Ge(Si,5),2&e){let r;Se(r=Ee())&&(i.templateRef=r.first)}},inputs:{backdropClass:"backdropClass",ariaLabel:["aria-label","ariaLabel"],ariaLabelledby:["aria-labelledby","ariaLabelledby"],ariaDescribedby:["aria-describedby","ariaDescribedby"],xPosition:"xPosition",yPosition:"yPosition",overlapTrigger:"overlapTrigger",hasBackdrop:"hasBackdrop",panelClass:["class","panelClass"],classList:"classList"},outputs:{closed:"closed",close:"close"}}),n})(),Nc=(()=>{class n extends ry{constructor(e,i,r,o){super(e,i,r,o),this._elevationPrefix="mat-elevation-z",this._baseElevation=8}}return n.\u0275fac=function(e){return new(e||n)(C(Me),C(at),C(Xq),C($t))},n.\u0275cmp=O({type:n,selectors:[["mat-menu"]],hostVars:3,hostBindings:function(e,i){2&e&&Be("aria-label",null)("aria-labelledby",null)("aria-describedby",null)},exportAs:["matMenu"],features:[Qt([{provide:eN,useExisting:n}]),Ke],ngContentSelectors:jxe,decls:1,vars:0,consts:[["tabindex","-1","role","menu",1,"mat-mdc-menu-panel","mdc-menu-surface","mdc-menu-surface--open","mat-mdc-elevation-specific",3,"id","ngClass","keydown","click"],[1,"mat-mdc-menu-content","mdc-list"]],template:function(e,i){1&e&&(Dn(),S(0,Uxe,3,6,"ng-template"))},dependencies:[yn],styles:['.mdc-menu-surface{display:none;position:absolute;box-sizing:border-box;max-width:var(--mdc-menu-max-width, calc(100vw - 32px));max-height:var(--mdc-menu-max-height, calc(100vh - 32px));margin:0;padding:0;transform:scale(1);transform-origin:top left;opacity:0;overflow:auto;will-change:transform,opacity;z-index:8;border-radius:var(--mdc-shape-medium, 4px);transform-origin-left:top left;transform-origin-right:top right}.mdc-menu-surface:focus{outline:none}.mdc-menu-surface--animating-open{display:inline-block;transform:scale(0.8);opacity:0}.mdc-menu-surface--open{display:inline-block;transform:scale(1);opacity:1}.mdc-menu-surface--animating-closed{display:inline-block;opacity:0}[dir=rtl] .mdc-menu-surface,.mdc-menu-surface[dir=rtl]{transform-origin-left:top right;transform-origin-right:top left}.mdc-menu-surface--anchor{position:relative;overflow:visible}.mdc-menu-surface--fixed{position:fixed}.mdc-menu-surface--fullwidth{width:100%}mat-menu{display:none}.mat-mdc-menu-content{margin:0;padding:8px 0;list-style-type:none}.mat-mdc-menu-content:focus{outline:none}.mat-mdc-menu-panel.ng-animating{pointer-events:none}.cdk-high-contrast-active .mat-mdc-menu-panel{outline:solid 1px}.mat-mdc-menu-panel.mat-mdc-menu-panel{min-width:112px;max-width:280px;overflow:auto;-webkit-overflow-scrolling:touch;position:relative}.mat-mdc-menu-item{display:flex;position:relative;align-items:center;justify-content:flex-start;overflow:hidden;padding:0;padding-left:16px;padding-right:16px;-webkit-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:rgba(0,0,0,0);cursor:pointer;width:100%;text-align:left;box-sizing:border-box;color:inherit;font-size:inherit;background:none;text-decoration:none;margin:0;min-height:48px}.mat-mdc-menu-item:focus{outline:none}[dir=rtl] .mat-mdc-menu-item,.mat-mdc-menu-item[dir=rtl]{padding-left:16px;padding-right:16px}.mat-mdc-menu-item::-moz-focus-inner{border:0}.mat-mdc-menu-item.mdc-list-item{align-items:center}.mat-mdc-menu-item[disabled]{cursor:default;opacity:.38}.mat-mdc-menu-item[disabled]::after{display:block;position:absolute;content:"";top:0;left:0;bottom:0;right:0}.mat-mdc-menu-item .mat-icon{margin-right:16px}[dir=rtl] .mat-mdc-menu-item{text-align:right}[dir=rtl] .mat-mdc-menu-item .mat-icon{margin-right:0;margin-left:16px}.mat-mdc-menu-item .mdc-list-item__primary-text{white-space:normal}.mat-mdc-menu-item.mat-mdc-menu-item-submenu-trigger{padding-right:32px}[dir=rtl] .mat-mdc-menu-item.mat-mdc-menu-item-submenu-trigger{padding-right:16px;padding-left:32px}.cdk-high-contrast-active .mat-mdc-menu-item{margin-top:1px}.mat-mdc-menu-submenu-icon{position:absolute;top:50%;right:16px;transform:translateY(-50%);width:5px;height:10px;fill:currentColor}[dir=rtl] .mat-mdc-menu-submenu-icon{right:auto;left:16px;transform:translateY(-50%) scaleX(-1)}.cdk-high-contrast-active .mat-mdc-menu-submenu-icon{fill:CanvasText}.mat-mdc-menu-item .mat-mdc-menu-ripple{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none}'],encapsulation:2,data:{animation:[_E.transformMenu,_E.fadeInItems]},changeDetection:0}),n})(),Qq=new ie("mat-menu-scroll-strategy"),Qxe={provide:Qq,deps:[zi],useFactory:function(n){return()=>n.scrollStrategies.reposition()}},Yq=qo({passive:!0}),Zxe=(()=>{class n{get _deprecatedMatMenuTriggerFor(){return this.menu}set _deprecatedMatMenuTriggerFor(e){this.menu=e}get menu(){return this._menu}set menu(e){e!==this._menu&&(this._menu=e,this._menuCloseSubscription.unsubscribe(),e&&(this._menuCloseSubscription=e.close.subscribe(i=>{this._destroyMenu(i),("click"===i||"tab"===i)&&this._parentMaterialMenu&&this._parentMaterialMenu.closed.emit(i)})),this._menuItemInstance?._setTriggersSubmenu(this.triggersSubmenu()))}constructor(e,i,r,o,s,a,l,c,d){this._overlay=e,this._element=i,this._viewContainerRef=r,this._menuItemInstance=a,this._dir=l,this._focusMonitor=c,this._ngZone=d,this._overlayRef=null,this._menuOpen=!1,this._closingActionsSubscription=Mn.EMPTY,this._hoverSubscription=Mn.EMPTY,this._menuCloseSubscription=Mn.EMPTY,this._changeDetectorRef=ai($t),this._handleTouchStart=u=>{Bv(u)||(this._openedBy="touch")},this._openedBy=void 0,this.restoreFocus=!0,this.menuOpened=new F,this.onMenuOpen=this.menuOpened,this.menuClosed=new F,this.onMenuClose=this.menuClosed,this._scrollStrategy=o,this._parentMaterialMenu=s instanceof ry?s:void 0,i.nativeElement.addEventListener("touchstart",this._handleTouchStart,Yq)}ngAfterContentInit(){this._handleHover()}ngOnDestroy(){this._overlayRef&&(this._overlayRef.dispose(),this._overlayRef=null),this._element.nativeElement.removeEventListener("touchstart",this._handleTouchStart,Yq),this._menuCloseSubscription.unsubscribe(),this._closingActionsSubscription.unsubscribe(),this._hoverSubscription.unsubscribe()}get menuOpen(){return this._menuOpen}get dir(){return this._dir&&"rtl"===this._dir.value?"rtl":"ltr"}triggersSubmenu(){return!!(this._menuItemInstance&&this._parentMaterialMenu&&this.menu)}toggleMenu(){return this._menuOpen?this.closeMenu():this.openMenu()}openMenu(){let e=this.menu;if(this._menuOpen||!e)return;let i=this._createOverlay(e),r=i.getConfig(),o=r.positionStrategy;this._setPosition(e,o),r.hasBackdrop=null==e.hasBackdrop?!this.triggersSubmenu():e.hasBackdrop,i.attach(this._getPortal(e)),e.lazyContent&&e.lazyContent.attach(this.menuData),this._closingActionsSubscription=this._menuClosingActions().subscribe(()=>this.closeMenu()),this._initMenu(e),e instanceof ry&&(e._startAnimation(),e._directDescendantItems.changes.pipe(ot(e.close)).subscribe(()=>{o.withLockedPosition(!1).reapplyLastPosition(),o.withLockedPosition(!0)}))}closeMenu(){this.menu?.close.emit()}focus(e,i){this._focusMonitor&&e?this._focusMonitor.focusVia(this._element,e,i):this._element.nativeElement.focus(i)}updatePosition(){this._overlayRef?.updatePosition()}_destroyMenu(e){if(!this._overlayRef||!this.menuOpen)return;let i=this.menu;this._closingActionsSubscription.unsubscribe(),this._overlayRef.detach(),this.restoreFocus&&("keydown"===e||!this._openedBy||!this.triggersSubmenu())&&this.focus(this._openedBy),this._openedBy=void 0,i instanceof ry?(i._resetAnimation(),i.lazyContent?i._animationDone.pipe(ke(r=>"void"===r.toState),Yt(1),ot(i.lazyContent._attached)).subscribe({next:()=>i.lazyContent.detach(),complete:()=>this._setIsMenuOpen(!1)}):this._setIsMenuOpen(!1)):(this._setIsMenuOpen(!1),i?.lazyContent?.detach())}_initMenu(e){e.parentMenu=this.triggersSubmenu()?this._parentMaterialMenu:void 0,e.direction=this.dir,this._setMenuElevation(e),e.focusFirstItem(this._openedBy||"program"),this._setIsMenuOpen(!0)}_setMenuElevation(e){if(e.setElevation){let i=0,r=e.parentMenu;for(;r;)i++,r=r.parentMenu;e.setElevation(i)}}_setIsMenuOpen(e){e!==this._menuOpen&&(this._menuOpen=e,this._menuOpen?this.menuOpened.emit():this.menuClosed.emit(),this.triggersSubmenu()&&this._menuItemInstance._setHighlighted(e),this._changeDetectorRef.markForCheck())}_createOverlay(e){if(!this._overlayRef){let i=this._getOverlayConfig(e);this._subscribeToPositions(e,i.positionStrategy),this._overlayRef=this._overlay.create(i),this._overlayRef.keydownEvents().subscribe()}return this._overlayRef}_getOverlayConfig(e){return new Qa({positionStrategy:this._overlay.position().flexibleConnectedTo(this._element).withLockedPosition().withGrowAfterOpen().withTransformOriginOn(".mat-menu-panel, .mat-mdc-menu-panel"),backdropClass:e.backdropClass||"cdk-overlay-transparent-backdrop",panelClass:e.overlayPanelClass,scrollStrategy:this._scrollStrategy(),direction:this._dir})}_subscribeToPositions(e,i){e.setPositionClasses&&i.positionChanges.subscribe(r=>{let o="start"===r.connectionPair.overlayX?"after":"before",s="top"===r.connectionPair.overlayY?"below":"above";this._ngZone?this._ngZone.run(()=>e.setPositionClasses(o,s)):e.setPositionClasses(o,s)})}_setPosition(e,i){let[r,o]="before"===e.xPosition?["end","start"]:["start","end"],[s,a]="above"===e.yPosition?["bottom","top"]:["top","bottom"],[l,c]=[s,a],[d,u]=[r,o],p=0;if(this.triggersSubmenu()){if(u=r="before"===e.xPosition?"start":"end",o=d="end"===r?"start":"end",this._parentMaterialMenu){if(null==this._parentInnerPadding){let f=this._parentMaterialMenu.items.first;this._parentInnerPadding=f?f._getHostElement().offsetTop:0}p="bottom"===s?this._parentInnerPadding:-this._parentInnerPadding}}else e.overlapTrigger||(l="top"===s?"bottom":"top",c="top"===a?"bottom":"top");i.withPositions([{originX:r,originY:l,overlayX:d,overlayY:s,offsetY:p},{originX:o,originY:l,overlayX:u,overlayY:s,offsetY:p},{originX:r,originY:c,overlayX:d,overlayY:a,offsetY:-p},{originX:o,originY:c,overlayX:u,overlayY:a,offsetY:-p}])}_menuClosingActions(){let e=this._overlayRef.backdropClick(),i=this._overlayRef.detachments();return tn(e,this._parentMaterialMenu?this._parentMaterialMenu.closed:Ht(),this._parentMaterialMenu?this._parentMaterialMenu._hovered().pipe(ke(s=>s!==this._menuItemInstance),ke(()=>this._menuOpen)):Ht(),i)}_handleMousedown(e){Lv(e)||(this._openedBy=0===e.button?"mouse":void 0,this.triggersSubmenu()&&e.preventDefault())}_handleKeydown(e){let i=e.keyCode;(13===i||32===i)&&(this._openedBy="keyboard"),this.triggersSubmenu()&&(39===i&&"ltr"===this.dir||37===i&&"rtl"===this.dir)&&(this._openedBy="keyboard",this.openMenu())}_handleClick(e){this.triggersSubmenu()?(e.stopPropagation(),this.openMenu()):this.toggleMenu()}_handleHover(){!this.triggersSubmenu()||!this._parentMaterialMenu||(this._hoverSubscription=this._parentMaterialMenu._hovered().pipe(ke(e=>e===this._menuItemInstance&&!e.disabled),Sa(0,Am)).subscribe(()=>{this._openedBy="mouse",this.menu instanceof ry&&this.menu._isAnimating?this.menu._animationDone.pipe(Yt(1),Sa(0,Am),ot(this._parentMaterialMenu._hovered())).subscribe(()=>this.openMenu()):this.openMenu()}))}_getPortal(e){return(!this._portal||this._portal.templateRef!==e.templateRef)&&(this._portal=new Yo(e.templateRef,this._viewContainerRef)),this._portal}}return n.\u0275fac=function(e){return new(e||n)(C(zi),C(Me),C(si),C(Qq),C(eN,8),C(jl,10),C(Xi,8),C(Xr),C(at))},n.\u0275dir=we({type:n,hostVars:3,hostBindings:function(e,i){1&e&&I("click",function(o){return i._handleClick(o)})("mousedown",function(o){return i._handleMousedown(o)})("keydown",function(o){return i._handleKeydown(o)}),2&e&&Be("aria-haspopup",i.menu?"menu":null)("aria-expanded",i.menuOpen)("aria-controls",i.menuOpen?i.menu.panelId:null)},inputs:{_deprecatedMatMenuTriggerFor:["mat-menu-trigger-for","_deprecatedMatMenuTriggerFor"],menu:["matMenuTriggerFor","menu"],menuData:["matMenuTriggerData","menuData"],restoreFocus:["matMenuTriggerRestoreFocus","restoreFocus"]},outputs:{menuOpened:"menuOpened",onMenuOpen:"onMenuOpen",menuClosed:"menuClosed",onMenuClose:"onMenuClose"}}),n})(),Lc=(()=>{class n extends Zxe{}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275dir=we({type:n,selectors:[["","mat-menu-trigger-for",""],["","matMenuTriggerFor",""]],hostAttrs:[1,"mat-mdc-menu-trigger"],exportAs:["matMenuTrigger"],features:[Ke]}),n})(),ju=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({providers:[Qxe],imports:[Pe,Bl,fn,Co,Pc,fn]}),n})();function Kxe(n,t){1&n&&P(0,"mat-icon",8)}function Jxe(n,t){1&n&&P(0,"mat-icon",9)}function $xe(n,t){1&n&&P(0,"mat-icon",10)}var Ws=(()=>(function(n){n[n.DEFAULT=0]="DEFAULT",n[n.DARK_MODE_ON=1]="DARK_MODE_ON",n[n.DARK_MODE_OFF=2]="DARK_MODE_OFF"}(Ws||(Ws={})),Ws))(),Zq=(()=>{class n{constructor(){this.DarkModeOverride=Ws,this.onOverrideChanged=new F}getButtonTitle(){let e;switch(this.darkModeOverride){case Ws.DEFAULT:e="Browser default";break;case Ws.DARK_MODE_ON:e="Dark mode";break;case Ws.DARK_MODE_OFF:e="Light mode"}return`Current mode: [${e}]. Switch between browser default, light, or dark theme.`}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["app-header-dark-mode-toggle-component"]],inputs:{darkModeOverride:"darkModeOverride"},outputs:{onOverrideChanged:"onOverrideChanged"},decls:15,vars:6,consts:[["mat-icon-button","","aria-label","Menu for changing light or dark theme",3,"matMenuTriggerFor","ngSwitch","title"],["svgIcon","brightness_6_24px",4,"ngSwitchCase"],["svgIcon","light_mode_24px",4,"ngSwitchCase"],["svgIcon","dark_mode_24px",4,"ngSwitchCase"],["menu","matMenu"],["mat-menu-item","","title","Set the theme to match the default mode in the browser.",3,"click"],["mat-menu-item","","title","Force light TensorBoard theme.",3,"click"],["mat-menu-item","","title","Force dark TensorBoard theme.",3,"click"],["svgIcon","brightness_6_24px"],["svgIcon","light_mode_24px"],["svgIcon","dark_mode_24px"]],template:function(e,i){1&e&&(h(0,"button",0),S(1,Kxe,1,0,"mat-icon",1),S(2,Jxe,1,0,"mat-icon",2),S(3,$xe,1,0,"mat-icon",3),g(),h(4,"mat-menu",null,4)(6,"button",5),I("click",function(){return i.onOverrideChanged.emit(i.DarkModeOverride.DEFAULT)}),h(7,"label"),T(8,"Browser default"),g()(),h(9,"button",6),I("click",function(){return i.onOverrideChanged.emit(i.DarkModeOverride.DARK_MODE_OFF)}),h(10,"label"),T(11,"Light"),g()(),h(12,"button",7),I("click",function(){return i.onOverrideChanged.emit(i.DarkModeOverride.DARK_MODE_ON)}),h(13,"label"),T(14,"Dark"),g()()()),2&e&&(_("matMenuTriggerFor",it(5))("ngSwitch",i.darkModeOverride)("title",i.getButtonTitle()),v(1),_("ngSwitchCase",i.DarkModeOverride.DEFAULT),v(1),_("ngSwitchCase",i.DarkModeOverride.DARK_MODE_OFF),v(1),_("ngSwitchCase",i.DarkModeOverride.DARK_MODE_ON))},dependencies:[$i,En,Nc,jl,Lc,sr,Sr],encapsulation:2}),n})(),Kq=(()=>{class n{constructor(e){this.store=e,this.darkModeOverride$=this.store.select(lS).pipe(N(i=>null===i?Ws.DEFAULT:i?Ws.DARK_MODE_ON:Ws.DARK_MODE_OFF))}changeDarkMode(e){let i=null;switch(e){case Ws.DEFAULT:i=null;break;case Ws.DARK_MODE_OFF:i=!1;break;case Ws.DARK_MODE_ON:i=!0}this.store.dispatch(WS({enableDarkMode:i}))}}return n.\u0275fac=function(e){return new(e||n)(C(Ae))},n.\u0275cmp=O({type:n,selectors:[["app-header-dark-mode-toggle"]],decls:2,vars:3,consts:[[3,"darkModeOverride","onOverrideChanged"]],template:function(e,i){1&e&&(h(0,"app-header-dark-mode-toggle-component",0),I("onOverrideChanged",function(o){return i.changeDarkMode(o)}),j(1,"async"),g()),2&e&&_("darkModeOverride",W(1,1,i.darkModeOverride$))},dependencies:[Zq,ct],encapsulation:2}),n})();function nCe(n,t){}var iCe=function(n){return{animationDuration:n}},rCe=function(n,t){return{value:n,params:t}};function oCe(n,t){1&n&&zt(0)}var eY=["*"],sCe=["tabListContainer"],aCe=["tabList"],lCe=["tabListInner"],cCe=["nextPaginator"],dCe=["previousPaginator"],uCe=["tabBodyWrapper"],pCe=["tabHeader"];function fCe(n,t){}function mCe(n,t){1&n&&S(0,fCe,0,0,"ng-template",14),2&n&&_("cdkPortalOutlet",w().$implicit.templateLabel)}function hCe(n,t){1&n&&T(0),2&n&&bt(w().$implicit.textLabel)}function gCe(n,t){if(1&n){let e=ge();h(0,"div",6,7),I("click",function(){let r=X(e),o=r.$implicit,s=r.index,a=w(),l=it(1);return Q(a._handleClick(o,l,s))})("cdkFocusChange",function(r){let s=X(e).index;return Q(w()._tabFocusChanged(r,s))}),P(2,"span",8)(3,"div",9),h(4,"span",10)(5,"span",11),S(6,mCe,1,1,"ng-template",12),S(7,hCe,1,1,"ng-template",null,13,Wt),g()()()}if(2&n){let e=t.$implicit,i=t.index,r=it(1),o=it(8),s=w();nt("mdc-tab--active",s.selectedIndex===i),_("id",s._getTabLabelId(i))("ngClass",e.labelClass)("disabled",e.disabled)("fitInkBarToContent",s.fitInkBarToContent),Be("tabIndex",s._getTabIndex(i))("aria-posinset",i+1)("aria-setsize",s._tabs.length)("aria-controls",s._getTabContentId(i))("aria-selected",s.selectedIndex===i)("aria-label",e.ariaLabel||null)("aria-labelledby",!e.ariaLabel&&e.ariaLabelledby?e.ariaLabelledby:null),v(3),_("matRippleTrigger",r)("matRippleDisabled",e.disabled||s.disableRipple),v(3),_("ngIf",e.templateLabel)("ngIfElse",o)}}function _Ce(n,t){if(1&n){let e=ge();h(0,"mat-tab-body",15),I("_onCentered",function(){return X(e),Q(w()._removeTabBodyWrapperHeight())})("_onCentering",function(r){return X(e),Q(w()._setTabBodyWrapperHeight(r))}),g()}if(2&n){let e=t.$implicit,i=t.index,r=w();nt("mat-mdc-tab-body-active",r.selectedIndex===i),_("id",r._getTabContentId(i))("ngClass",e.bodyClass)("content",e.content)("position",e.position)("origin",e.origin)("animationDuration",r.animationDuration)("preserveContent",r.preserveContent),Be("tabindex",null!=r.contentTabIndex&&r.selectedIndex===i?r.contentTabIndex:null)("aria-labelledby",r._getTabLabelId(i))}}var bCe={translateTab:_r("translateTab",[wi("center, void, left-origin-center, right-origin-center",rn({transform:"none"})),wi("left",rn({transform:"translate3d(-100%, 0, 0)",minHeight:"1px",visibility:"hidden"})),wi("right",rn({transform:"translate3d(100%, 0, 0)",minHeight:"1px",visibility:"hidden"})),gi("* => left, * => right, left => center, right => center",Ci("{{animationDuration}} cubic-bezier(0.35, 0, 0.25, 1)")),gi("void => left-origin-center",[rn({transform:"translate3d(-100%, 0, 0)",visibility:"hidden"}),Ci("{{animationDuration}} cubic-bezier(0.35, 0, 0.25, 1)")]),gi("void => right-origin-center",[rn({transform:"translate3d(100%, 0, 0)",visibility:"hidden"}),Ci("{{animationDuration}} cubic-bezier(0.35, 0, 0.25, 1)")])])},vCe=(()=>{class n extends ps{constructor(e,i,r,o){super(e,i,o),this._host=r,this._centeringSub=Mn.EMPTY,this._leavingSub=Mn.EMPTY}ngOnInit(){super.ngOnInit(),this._centeringSub=this._host._beforeCentering.pipe(qn(this._host._isCenterPosition(this._host._position))).subscribe(e=>{e&&!this.hasAttached()&&this.attach(this._host._content)}),this._leavingSub=this._host._afterLeavingCenter.subscribe(()=>{this._host.preserveContent||this.detach()})}ngOnDestroy(){super.ngOnDestroy(),this._centeringSub.unsubscribe(),this._leavingSub.unsubscribe()}}return n.\u0275fac=function(e){return new(e||n)(C(fo),C(si),C($n(()=>tY)),C(Lt))},n.\u0275dir=we({type:n,selectors:[["","matTabBodyHost",""]],features:[Ke]}),n})(),yCe=(()=>{class n{set position(e){this._positionIndex=e,this._computePositionAnimationState()}constructor(e,i,r){this._elementRef=e,this._dir=i,this._dirChangeSubscription=Mn.EMPTY,this._translateTabComplete=new Ie,this._onCentering=new F,this._beforeCentering=new F,this._afterLeavingCenter=new F,this._onCentered=new F(!0),this.animationDuration="500ms",this.preserveContent=!1,i&&(this._dirChangeSubscription=i.change.subscribe(o=>{this._computePositionAnimationState(o),r.markForCheck()})),this._translateTabComplete.pipe(Yn((o,s)=>o.fromState===s.fromState&&o.toState===s.toState)).subscribe(o=>{this._isCenterPosition(o.toState)&&this._isCenterPosition(this._position)&&this._onCentered.emit(),this._isCenterPosition(o.fromState)&&!this._isCenterPosition(this._position)&&this._afterLeavingCenter.emit()})}ngOnInit(){"center"==this._position&&null!=this.origin&&(this._position=this._computePositionFromOrigin(this.origin))}ngOnDestroy(){this._dirChangeSubscription.unsubscribe(),this._translateTabComplete.complete()}_onTranslateTabStarted(e){let i=this._isCenterPosition(e.toState);this._beforeCentering.emit(i),i&&this._onCentering.emit(this._elementRef.nativeElement.clientHeight)}_getLayoutDirection(){return this._dir&&"rtl"===this._dir.value?"rtl":"ltr"}_isCenterPosition(e){return"center"==e||"left-origin-center"==e||"right-origin-center"==e}_computePositionAnimationState(e=this._getLayoutDirection()){this._position=this._positionIndex<0?"ltr"==e?"left":"right":this._positionIndex>0?"ltr"==e?"right":"left":"center"}_computePositionFromOrigin(e){let i=this._getLayoutDirection();return"ltr"==i&&e<=0||"rtl"==i&&e>0?"left-origin-center":"right-origin-center"}}return n.\u0275fac=function(e){return new(e||n)(C(Me),C(Xi,8),C($t))},n.\u0275dir=we({type:n,inputs:{_content:["content","_content"],origin:"origin",animationDuration:"animationDuration",preserveContent:"preserveContent",position:"position"},outputs:{_onCentering:"_onCentering",_beforeCentering:"_beforeCentering",_afterLeavingCenter:"_afterLeavingCenter",_onCentered:"_onCentered"}}),n})(),tY=(()=>{class n extends yCe{constructor(e,i,r){super(e,i,r)}}return n.\u0275fac=function(e){return new(e||n)(C(Me),C(Xi,8),C($t))},n.\u0275cmp=O({type:n,selectors:[["mat-tab-body"]],viewQuery:function(e,i){if(1&e&&Ge(ps,5),2&e){let r;Se(r=Ee())&&(i._portalHost=r.first)}},hostAttrs:[1,"mat-mdc-tab-body"],features:[Ke],decls:3,vars:6,consts:[["cdkScrollable","",1,"mat-mdc-tab-body-content"],["content",""],["matTabBodyHost",""]],template:function(e,i){1&e&&(h(0,"div",0,1),I("@translateTab.start",function(o){return i._onTranslateTabStarted(o)})("@translateTab.done",function(o){return i._translateTabComplete.next(o)}),S(2,nCe,0,0,"ng-template",2),g()),2&e&&_("@translateTab",qr(3,rCe,i._position,In(1,iCe,i.animationDuration)))},dependencies:[vCe],styles:['.mat-mdc-tab-body{top:0;left:0;right:0;bottom:0;position:absolute;display:block;overflow:hidden;outline:0;flex-basis:100%}.mat-mdc-tab-body.mat-mdc-tab-body-active{position:relative;overflow-x:hidden;overflow-y:auto;z-index:1;flex-grow:1}.mat-mdc-tab-group.mat-mdc-tab-group-dynamic-height .mat-mdc-tab-body.mat-mdc-tab-body-active{overflow-y:hidden}.mat-mdc-tab-body-content{height:100%;overflow:auto}.mat-mdc-tab-group-dynamic-height .mat-mdc-tab-body-content{overflow:hidden}.mat-mdc-tab-body-content[style*="visibility: hidden"]{display:none}'],encapsulation:2,data:{animation:[bCe.translateTab]}}),n})(),xCe=new ie("MatTabContent"),CCe=(()=>{class n{constructor(e){this.template=e}}return n.\u0275fac=function(e){return new(e||n)(C(Si))},n.\u0275dir=we({type:n,selectors:[["","matTabContent",""]],features:[Qt([{provide:xCe,useExisting:n}])]}),n})(),MCe=new ie("MatTabLabel"),nY=new ie("MAT_TAB"),rN=(()=>{class n extends k7{constructor(e,i,r){super(e,i),this._closestTab=r}}return n.\u0275fac=function(e){return new(e||n)(C(Si),C(si),C(nY,8))},n.\u0275dir=we({type:n,selectors:[["","mat-tab-label",""],["","matTabLabel",""]],features:[Qt([{provide:MCe,useExisting:n}]),Ke]}),n})(),tN="mdc-tab-indicator--active",Jq="mdc-tab-indicator--no-transition";function iY(n){return class extends n{constructor(...t){super(...t),this._fitToContent=!1}get fitInkBarToContent(){return this._fitToContent}set fitInkBarToContent(t){let e=Rt(t);this._fitToContent!==e&&(this._fitToContent=e,this._inkBarElement&&this._appendInkBarElement())}activateInkBar(t){let e=this.elementRef.nativeElement;if(!t||!e.getBoundingClientRect||!this._inkBarContentElement)return void e.classList.add(tN);let i=e.getBoundingClientRect(),r=t.width/i.width,o=t.left-i.left;e.classList.add(Jq),this._inkBarContentElement.style.setProperty("transform",`translateX(${o}px) scaleX(${r})`),e.getBoundingClientRect(),e.classList.remove(Jq),e.classList.add(tN),this._inkBarContentElement.style.setProperty("transform","")}deactivateInkBar(){this.elementRef.nativeElement.classList.remove(tN)}ngOnInit(){this._createInkBarElement()}ngOnDestroy(){this._inkBarElement?.remove(),this._inkBarElement=this._inkBarContentElement=null}_createInkBarElement(){let t=this.elementRef.nativeElement.ownerDocument||document;this._inkBarElement=t.createElement("span"),this._inkBarContentElement=t.createElement("span"),this._inkBarElement.className="mdc-tab-indicator",this._inkBarContentElement.className="mdc-tab-indicator__content mdc-tab-indicator__content--underline",this._inkBarElement.appendChild(this._inkBarContentElement),this._appendInkBarElement()}_appendInkBarElement(){(this._fitToContent?this.elementRef.nativeElement.querySelector(".mdc-tab__content"):this.elementRef.nativeElement).appendChild(this._inkBarElement)}}}new ie("MatInkBarPositioner",{providedIn:"root",factory:function(){return t=>({left:t?(t.offsetLeft||0)+"px":"0",width:t?(t.offsetWidth||0)+"px":"0"})}});var SCe=so(class{}),ECe=(()=>{class n extends SCe{constructor(e){super(),this.elementRef=e}focus(){this.elementRef.nativeElement.focus()}getOffsetLeft(){return this.elementRef.nativeElement.offsetLeft}getOffsetWidth(){return this.elementRef.nativeElement.offsetWidth}}return n.\u0275fac=function(e){return new(e||n)(C(Me))},n.\u0275dir=we({type:n,features:[Ke]}),n})(),TCe=iY(ECe),rY=(()=>{class n extends TCe{}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275dir=we({type:n,selectors:[["","matTabLabelWrapper",""]],hostVars:3,hostBindings:function(e,i){2&e&&(Be("aria-disabled",!!i.disabled),nt("mat-mdc-tab-disabled",i.disabled))},inputs:{disabled:"disabled",fitInkBarToContent:"fitInkBarToContent"},features:[Ke]}),n})(),DCe=so(class{}),oY=new ie("MAT_TAB_GROUP"),ICe=(()=>{class n extends DCe{get content(){return this._contentPortal}constructor(e,i){super(),this._viewContainerRef=e,this._closestTabGroup=i,this.textLabel="",this._contentPortal=null,this._stateChanges=new Ie,this.position=null,this.origin=null,this.isActive=!1}ngOnChanges(e){(e.hasOwnProperty("textLabel")||e.hasOwnProperty("disabled"))&&this._stateChanges.next()}ngOnDestroy(){this._stateChanges.complete()}ngOnInit(){this._contentPortal=new Yo(this._explicitContent||this._implicitContent,this._viewContainerRef)}_setTemplateLabelInput(e){e&&e._closestTab===this&&(this._templateLabel=e)}}return n.\u0275fac=function(e){return new(e||n)(C(si),C(oY,8))},n.\u0275dir=we({type:n,viewQuery:function(e,i){if(1&e&&Ge(Si,7),2&e){let r;Se(r=Ee())&&(i._implicitContent=r.first)}},inputs:{textLabel:["label","textLabel"],ariaLabel:["aria-label","ariaLabel"],ariaLabelledby:["aria-labelledby","ariaLabelledby"],labelClass:"labelClass",bodyClass:"bodyClass"},features:[Ke,Gt]}),n})(),sy=(()=>{class n extends ICe{get templateLabel(){return this._templateLabel}set templateLabel(e){this._setTemplateLabelInput(e)}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275cmp=O({type:n,selectors:[["mat-tab"]],contentQueries:function(e,i,r){if(1&e&&(Ti(r,CCe,7,Si),Ti(r,rN,5)),2&e){let o;Se(o=Ee())&&(i._explicitContent=o.first),Se(o=Ee())&&(i.templateLabel=o.first)}},inputs:{disabled:"disabled"},exportAs:["matTab"],features:[Qt([{provide:nY,useExisting:n}]),Ke],ngContentSelectors:eY,decls:1,vars:0,template:function(e,i){1&e&&(Dn(),S(0,oCe,1,0,"ng-template"))},encapsulation:2}),n})(),$q=qo({passive:!0}),sY=(()=>{class n{get disablePagination(){return this._disablePagination}set disablePagination(e){this._disablePagination=Rt(e)}get selectedIndex(){return this._selectedIndex}set selectedIndex(e){e=_i(e),this._selectedIndex!=e&&(this._selectedIndexChanged=!0,this._selectedIndex=e,this._keyManager&&this._keyManager.updateActiveItem(e))}constructor(e,i,r,o,s,a,l){this._elementRef=e,this._changeDetectorRef=i,this._viewportRuler=r,this._dir=o,this._ngZone=s,this._platform=a,this._animationMode=l,this._scrollDistance=0,this._selectedIndexChanged=!1,this._destroyed=new Ie,this._showPaginationControls=!1,this._disableScrollAfter=!0,this._disableScrollBefore=!0,this._stopScrolling=new Ie,this._disablePagination=!1,this._selectedIndex=0,this.selectFocusedIndex=new F,this.indexFocused=new F,s.runOutsideAngular(()=>{mi(e.nativeElement,"mouseleave").pipe(ot(this._destroyed)).subscribe(()=>{this._stopInterval()})})}ngAfterViewInit(){mi(this._previousPaginator.nativeElement,"touchstart",$q).pipe(ot(this._destroyed)).subscribe(()=>{this._handlePaginatorPress("before")}),mi(this._nextPaginator.nativeElement,"touchstart",$q).pipe(ot(this._destroyed)).subscribe(()=>{this._handlePaginatorPress("after")})}ngAfterContentInit(){let e=this._dir?this._dir.change:Ht("ltr"),i=this._viewportRuler.change(150),r=()=>{this.updatePagination(),this._alignInkBarToSelectedTab()};this._keyManager=new sg(this._items).withHorizontalOrientation(this._getLayoutDirection()).withHomeAndEnd().withWrap().skipPredicate(()=>!1),this._keyManager.updateActiveItem(this._selectedIndex),this._ngZone.onStable.pipe(Yt(1)).subscribe(r),tn(e,i,this._items.changes,this._itemsResized()).pipe(ot(this._destroyed)).subscribe(()=>{this._ngZone.run(()=>{Promise.resolve().then(()=>{this._scrollDistance=Math.max(0,Math.min(this._getMaxScrollDistance(),this._scrollDistance)),r()})}),this._keyManager.withHorizontalOrientation(this._getLayoutDirection())}),this._keyManager.change.subscribe(o=>{this.indexFocused.emit(o),this._setTabFocus(o)})}_itemsResized(){return"function"!=typeof ResizeObserver?Jr:this._items.changes.pipe(qn(this._items),Jn(e=>new Kt(i=>this._ngZone.runOutsideAngular(()=>{let r=new ResizeObserver(o=>i.next(o));return e.forEach(o=>r.observe(o.elementRef.nativeElement)),()=>{r.disconnect()}}))),ia(1),ke(e=>e.some(i=>i.contentRect.width>0&&i.contentRect.height>0)))}ngAfterContentChecked(){this._tabLabelCount!=this._items.length&&(this.updatePagination(),this._tabLabelCount=this._items.length,this._changeDetectorRef.markForCheck()),this._selectedIndexChanged&&(this._scrollToLabel(this._selectedIndex),this._checkScrollingControls(),this._alignInkBarToSelectedTab(),this._selectedIndexChanged=!1,this._changeDetectorRef.markForCheck()),this._scrollDistanceChanged&&(this._updateTabScrollPosition(),this._scrollDistanceChanged=!1,this._changeDetectorRef.markForCheck())}ngOnDestroy(){this._keyManager?.destroy(),this._destroyed.next(),this._destroyed.complete(),this._stopScrolling.complete()}_handleKeydown(e){if(!vr(e))switch(e.keyCode){case 13:case 32:if(this.focusIndex!==this.selectedIndex){let i=this._items.get(this.focusIndex);i&&!i.disabled&&(this.selectFocusedIndex.emit(this.focusIndex),this._itemSelected(e))}break;default:this._keyManager.onKeydown(e)}}_onContentChanges(){let e=this._elementRef.nativeElement.textContent;e!==this._currentTextContent&&(this._currentTextContent=e||"",this._ngZone.run(()=>{this.updatePagination(),this._alignInkBarToSelectedTab(),this._changeDetectorRef.markForCheck()}))}updatePagination(){this._checkPaginationEnabled(),this._checkScrollingControls(),this._updateTabScrollPosition()}get focusIndex(){return this._keyManager?this._keyManager.activeItemIndex:0}set focusIndex(e){!this._isValidIndex(e)||this.focusIndex===e||!this._keyManager||this._keyManager.setActiveItem(e)}_isValidIndex(e){return!this._items||!!this._items.toArray()[e]}_setTabFocus(e){if(this._showPaginationControls&&this._scrollToLabel(e),this._items&&this._items.length){this._items.toArray()[e].focus();let i=this._tabListContainer.nativeElement;i.scrollLeft="ltr"==this._getLayoutDirection()?0:i.scrollWidth-i.offsetWidth}}_getLayoutDirection(){return this._dir&&"rtl"===this._dir.value?"rtl":"ltr"}_updateTabScrollPosition(){if(this.disablePagination)return;let e=this.scrollDistance,i="ltr"===this._getLayoutDirection()?-e:e;this._tabList.nativeElement.style.transform=`translateX(${Math.round(i)}px)`,(this._platform.TRIDENT||this._platform.EDGE)&&(this._tabListContainer.nativeElement.scrollLeft=0)}get scrollDistance(){return this._scrollDistance}set scrollDistance(e){this._scrollTo(e)}_scrollHeader(e){return this._scrollTo(this._scrollDistance+("before"==e?-1:1)*this._tabListContainer.nativeElement.offsetWidth/3)}_handlePaginatorClick(e){this._stopInterval(),this._scrollHeader(e)}_scrollToLabel(e){if(this.disablePagination)return;let i=this._items?this._items.toArray()[e]:null;if(!i)return;let a,l,r=this._tabListContainer.nativeElement.offsetWidth,{offsetLeft:o,offsetWidth:s}=i.elementRef.nativeElement;"ltr"==this._getLayoutDirection()?(a=o,l=a+s):(l=this._tabListInner.nativeElement.offsetWidth-o,a=l-s);let c=this.scrollDistance,d=this.scrollDistance+r;a<c?this.scrollDistance-=c-a:l>d&&(this.scrollDistance+=Math.min(l-d,a-c))}_checkPaginationEnabled(){if(this.disablePagination)this._showPaginationControls=!1;else{let e=this._tabListInner.nativeElement.scrollWidth>this._elementRef.nativeElement.offsetWidth;e||(this.scrollDistance=0),e!==this._showPaginationControls&&this._changeDetectorRef.markForCheck(),this._showPaginationControls=e}}_checkScrollingControls(){this.disablePagination?this._disableScrollAfter=this._disableScrollBefore=!0:(this._disableScrollBefore=0==this.scrollDistance,this._disableScrollAfter=this.scrollDistance==this._getMaxScrollDistance(),this._changeDetectorRef.markForCheck())}_getMaxScrollDistance(){return this._tabListInner.nativeElement.scrollWidth-this._tabListContainer.nativeElement.offsetWidth||0}_alignInkBarToSelectedTab(){let e=this._items&&this._items.length?this._items.toArray()[this.selectedIndex]:null,i=e?e.elementRef.nativeElement:null;i?this._inkBar.alignToElement(i):this._inkBar.hide()}_stopInterval(){this._stopScrolling.next()}_handlePaginatorPress(e,i){i&&null!=i.button&&0!==i.button||(this._stopInterval(),na(650,100).pipe(ot(tn(this._stopScrolling,this._destroyed))).subscribe(()=>{let{maxScrollDistance:r,distance:o}=this._scrollHeader(e);(0===o||o>=r)&&this._stopInterval()}))}_scrollTo(e){if(this.disablePagination)return{maxScrollDistance:0,distance:0};let i=this._getMaxScrollDistance();return this._scrollDistance=Math.max(0,Math.min(i,e)),this._scrollDistanceChanged=!0,this._checkScrollingControls(),{maxScrollDistance:i,distance:this._scrollDistance}}}return n.\u0275fac=function(e){return new(e||n)(C(Me),C($t),C(js),C(Xi,8),C(at),C(Gn),C(hi,8))},n.\u0275dir=we({type:n,inputs:{disablePagination:"disablePagination"}}),n})(),PCe=(()=>{class n extends sY{get disableRipple(){return this._disableRipple}set disableRipple(e){this._disableRipple=Rt(e)}constructor(e,i,r,o,s,a,l){super(e,i,r,o,s,a,l),this._disableRipple=!1}_itemSelected(e){e.preventDefault()}}return n.\u0275fac=function(e){return new(e||n)(C(Me),C($t),C(js),C(Xi,8),C(at),C(Gn),C(hi,8))},n.\u0275dir=we({type:n,inputs:{disableRipple:"disableRipple"},features:[Ke]}),n})(),OCe=(()=>{class n extends PCe{constructor(e,i,r,o,s,a,l){super(e,i,r,o,s,a,l)}ngAfterContentInit(){this._inkBar=new class{constructor(t){this._items=t}hide(){this._items.forEach(t=>t.deactivateInkBar())}alignToElement(t){let e=this._items.find(r=>r.elementRef.nativeElement===t),i=this._currentItem;if(i?.deactivateInkBar(),e){let r=i?.elementRef.nativeElement.getBoundingClientRect?.();e.activateInkBar(r),this._currentItem=e}}}(this._items),super.ngAfterContentInit()}}return n.\u0275fac=function(e){return new(e||n)(C(Me),C($t),C(js),C(Xi,8),C(at),C(Gn),C(hi,8))},n.\u0275cmp=O({type:n,selectors:[["mat-tab-header"]],contentQueries:function(e,i,r){if(1&e&&Ti(r,rY,4),2&e){let o;Se(o=Ee())&&(i._items=o)}},viewQuery:function(e,i){if(1&e&&(Ge(sCe,7),Ge(aCe,7),Ge(lCe,7),Ge(cCe,5),Ge(dCe,5)),2&e){let r;Se(r=Ee())&&(i._tabListContainer=r.first),Se(r=Ee())&&(i._tabList=r.first),Se(r=Ee())&&(i._tabListInner=r.first),Se(r=Ee())&&(i._nextPaginator=r.first),Se(r=Ee())&&(i._previousPaginator=r.first)}},hostAttrs:[1,"mat-mdc-tab-header"],hostVars:4,hostBindings:function(e,i){2&e&&nt("mat-mdc-tab-header-pagination-controls-enabled",i._showPaginationControls)("mat-mdc-tab-header-rtl","rtl"==i._getLayoutDirection())},inputs:{selectedIndex:"selectedIndex"},outputs:{selectFocusedIndex:"selectFocusedIndex",indexFocused:"indexFocused"},features:[Ke],ngContentSelectors:eY,decls:13,vars:10,consts:[["aria-hidden","true","type","button","mat-ripple","","tabindex","-1",1,"mat-mdc-tab-header-pagination","mat-mdc-tab-header-pagination-before",3,"matRippleDisabled","disabled","click","mousedown","touchend"],["previousPaginator",""],[1,"mat-mdc-tab-header-pagination-chevron"],[1,"mat-mdc-tab-label-container",3,"keydown"],["tabListContainer",""],["role","tablist",1,"mat-mdc-tab-list",3,"cdkObserveContent"],["tabList",""],[1,"mat-mdc-tab-labels"],["tabListInner",""],["aria-hidden","true","type","button","mat-ripple","","tabindex","-1",1,"mat-mdc-tab-header-pagination","mat-mdc-tab-header-pagination-after",3,"matRippleDisabled","disabled","mousedown","click","touchend"],["nextPaginator",""]],template:function(e,i){1&e&&(Dn(),h(0,"button",0,1),I("click",function(){return i._handlePaginatorClick("before")})("mousedown",function(o){return i._handlePaginatorPress("before",o)})("touchend",function(){return i._stopInterval()}),P(2,"div",2),g(),h(3,"div",3,4),I("keydown",function(o){return i._handleKeydown(o)}),h(5,"div",5,6),I("cdkObserveContent",function(){return i._onContentChanges()}),h(7,"div",7,8),zt(9),g()()(),h(10,"button",9,10),I("mousedown",function(o){return i._handlePaginatorPress("after",o)})("click",function(){return i._handlePaginatorClick("after")})("touchend",function(){return i._stopInterval()}),P(12,"div",2),g()),2&e&&(nt("mat-mdc-tab-header-pagination-disabled",i._disableScrollBefore),_("matRippleDisabled",i._disableScrollBefore||i.disableRipple)("disabled",i._disableScrollBefore||null),v(3),nt("_mat-animation-noopable","NoopAnimations"===i._animationMode),v(7),nt("mat-mdc-tab-header-pagination-disabled",i._disableScrollAfter),_("matRippleDisabled",i._disableScrollAfter||i.disableRipple)("disabled",i._disableScrollAfter||null))},dependencies:[mo,P1],styles:[".mat-mdc-tab-header{display:flex;overflow:hidden;position:relative;flex-shrink:0}.mat-mdc-tab-header-pagination{-webkit-user-select:none;user-select:none;position:relative;display:none;justify-content:center;align-items:center;min-width:32px;cursor:pointer;z-index:2;-webkit-tap-highlight-color:rgba(0,0,0,0);touch-action:none;box-sizing:content-box;background:none;border:none;outline:0;padding:0}.mat-mdc-tab-header-pagination::-moz-focus-inner{border:0}.mat-mdc-tab-header-pagination .mat-ripple-element{opacity:.12}.mat-mdc-tab-header-pagination-controls-enabled .mat-mdc-tab-header-pagination{display:flex}.mat-mdc-tab-header-pagination-before,.mat-mdc-tab-header-rtl .mat-mdc-tab-header-pagination-after{padding-left:4px}.mat-mdc-tab-header-pagination-before .mat-mdc-tab-header-pagination-chevron,.mat-mdc-tab-header-rtl .mat-mdc-tab-header-pagination-after .mat-mdc-tab-header-pagination-chevron{transform:rotate(-135deg)}.mat-mdc-tab-header-rtl .mat-mdc-tab-header-pagination-before,.mat-mdc-tab-header-pagination-after{padding-right:4px}.mat-mdc-tab-header-rtl .mat-mdc-tab-header-pagination-before .mat-mdc-tab-header-pagination-chevron,.mat-mdc-tab-header-pagination-after .mat-mdc-tab-header-pagination-chevron{transform:rotate(45deg)}.mat-mdc-tab-header-pagination-chevron{border-style:solid;border-width:2px 2px 0 0;height:8px;width:8px}.mat-mdc-tab-header-pagination-disabled{box-shadow:none;cursor:default;pointer-events:none}.mat-mdc-tab-header-pagination-disabled .mat-mdc-tab-header-pagination-chevron{opacity:.4}.mat-mdc-tab-list{flex-grow:1;position:relative;transition:transform 500ms cubic-bezier(0.35, 0, 0.25, 1)}._mat-animation-noopable .mat-mdc-tab-list{transition:none}._mat-animation-noopable span.mdc-tab-indicator__content,._mat-animation-noopable span.mdc-tab__text-label{transition:none}.mat-mdc-tab-label-container{display:flex;flex-grow:1;overflow:hidden;z-index:1}.mat-mdc-tab-labels{display:flex;flex:1 0 auto}[mat-align-tabs=center]>.mat-mdc-tab-header .mat-mdc-tab-labels{justify-content:center}[mat-align-tabs=end]>.mat-mdc-tab-header .mat-mdc-tab-labels{justify-content:flex-end}.mat-mdc-tab::before{margin:5px}.cdk-high-contrast-active .mat-mdc-tab[aria-disabled=true]{color:GrayText}"],encapsulation:2}),n})(),aY=new ie("MAT_TABS_CONFIG"),kCe=0,FCe=zs(us(class{constructor(n){this._elementRef=n}}),"primary"),NCe=(()=>{class n extends FCe{get dynamicHeight(){return this._dynamicHeight}set dynamicHeight(e){this._dynamicHeight=Rt(e)}get selectedIndex(){return this._selectedIndex}set selectedIndex(e){this._indexToSelect=_i(e,null)}get animationDuration(){return this._animationDuration}set animationDuration(e){this._animationDuration=/^\d+$/.test(e+"")?e+"ms":e}get contentTabIndex(){return this._contentTabIndex}set contentTabIndex(e){this._contentTabIndex=_i(e,null)}get disablePagination(){return this._disablePagination}set disablePagination(e){this._disablePagination=Rt(e)}get preserveContent(){return this._preserveContent}set preserveContent(e){this._preserveContent=Rt(e)}get backgroundColor(){return this._backgroundColor}set backgroundColor(e){let i=this._elementRef.nativeElement.classList;i.remove("mat-tabs-with-background",`mat-background-${this.backgroundColor}`),e&&i.add("mat-tabs-with-background",`mat-background-${e}`),this._backgroundColor=e}constructor(e,i,r,o){super(e),this._changeDetectorRef=i,this._animationMode=o,this._tabs=new Oa,this._indexToSelect=0,this._lastFocusedTabIndex=null,this._tabBodyWrapperHeight=0,this._tabsSubscription=Mn.EMPTY,this._tabLabelSubscription=Mn.EMPTY,this._dynamicHeight=!1,this._selectedIndex=null,this.headerPosition="above",this._disablePagination=!1,this._preserveContent=!1,this.selectedIndexChange=new F,this.focusChange=new F,this.animationDone=new F,this.selectedTabChange=new F(!0),this._groupId=kCe++,this.animationDuration=r&&r.animationDuration?r.animationDuration:"500ms",this.disablePagination=!(!r||null==r.disablePagination)&&r.disablePagination,this.dynamicHeight=!(!r||null==r.dynamicHeight)&&r.dynamicHeight,this.contentTabIndex=r?.contentTabIndex??null,this.preserveContent=!!r?.preserveContent}ngAfterContentChecked(){let e=this._indexToSelect=this._clampTabIndex(this._indexToSelect);if(this._selectedIndex!=e){let i=null==this._selectedIndex;if(!i){this.selectedTabChange.emit(this._createChangeEvent(e));let r=this._tabBodyWrapper.nativeElement;r.style.minHeight=r.clientHeight+"px"}Promise.resolve().then(()=>{this._tabs.forEach((r,o)=>r.isActive=o===e),i||(this.selectedIndexChange.emit(e),this._tabBodyWrapper.nativeElement.style.minHeight="")})}this._tabs.forEach((i,r)=>{i.position=r-e,null!=this._selectedIndex&&0==i.position&&!i.origin&&(i.origin=e-this._selectedIndex)}),this._selectedIndex!==e&&(this._selectedIndex=e,this._lastFocusedTabIndex=null,this._changeDetectorRef.markForCheck())}ngAfterContentInit(){this._subscribeToAllTabChanges(),this._subscribeToTabLabels(),this._tabsSubscription=this._tabs.changes.subscribe(()=>{let e=this._clampTabIndex(this._indexToSelect);if(e===this._selectedIndex){let r,i=this._tabs.toArray();for(let o=0;o<i.length;o++)if(i[o].isActive){this._indexToSelect=this._selectedIndex=o,this._lastFocusedTabIndex=null,r=i[o];break}!r&&i[e]&&Promise.resolve().then(()=>{i[e].isActive=!0,this.selectedTabChange.emit(this._createChangeEvent(e))})}this._changeDetectorRef.markForCheck()})}_subscribeToAllTabChanges(){this._allTabs.changes.pipe(qn(this._allTabs)).subscribe(e=>{this._tabs.reset(e.filter(i=>i._closestTabGroup===this||!i._closestTabGroup)),this._tabs.notifyOnChanges()})}ngOnDestroy(){this._tabs.destroy(),this._tabsSubscription.unsubscribe(),this._tabLabelSubscription.unsubscribe()}realignInkBar(){this._tabHeader&&this._tabHeader._alignInkBarToSelectedTab()}updatePagination(){this._tabHeader&&this._tabHeader.updatePagination()}focusTab(e){let i=this._tabHeader;i&&(i.focusIndex=e)}_focusChanged(e){this._lastFocusedTabIndex=e,this.focusChange.emit(this._createChangeEvent(e))}_createChangeEvent(e){let i=new iN;return i.index=e,this._tabs&&this._tabs.length&&(i.tab=this._tabs.toArray()[e]),i}_subscribeToTabLabels(){this._tabLabelSubscription&&this._tabLabelSubscription.unsubscribe(),this._tabLabelSubscription=tn(...this._tabs.map(e=>e._stateChanges)).subscribe(()=>this._changeDetectorRef.markForCheck())}_clampTabIndex(e){return Math.min(this._tabs.length-1,Math.max(e||0,0))}_getTabLabelId(e){return`mat-tab-label-${this._groupId}-${e}`}_getTabContentId(e){return`mat-tab-content-${this._groupId}-${e}`}_setTabBodyWrapperHeight(e){if(!this._dynamicHeight||!this._tabBodyWrapperHeight)return;let i=this._tabBodyWrapper.nativeElement;i.style.height=this._tabBodyWrapperHeight+"px",this._tabBodyWrapper.nativeElement.offsetHeight&&(i.style.height=e+"px")}_removeTabBodyWrapperHeight(){let e=this._tabBodyWrapper.nativeElement;this._tabBodyWrapperHeight=e.clientHeight,e.style.height="",this.animationDone.emit()}_handleClick(e,i,r){i.focusIndex=r,e.disabled||(this.selectedIndex=r)}_getTabIndex(e){return e===(this._lastFocusedTabIndex??this.selectedIndex)?0:-1}_tabFocusChanged(e,i){e&&"mouse"!==e&&"touch"!==e&&(this._tabHeader.focusIndex=i)}}return n.\u0275fac=function(e){return new(e||n)(C(Me),C($t),C(aY,8),C(hi,8))},n.\u0275dir=we({type:n,inputs:{dynamicHeight:"dynamicHeight",selectedIndex:"selectedIndex",headerPosition:"headerPosition",animationDuration:"animationDuration",contentTabIndex:"contentTabIndex",disablePagination:"disablePagination",preserveContent:"preserveContent",backgroundColor:"backgroundColor"},outputs:{selectedIndexChange:"selectedIndexChange",focusChange:"focusChange",animationDone:"animationDone",selectedTabChange:"selectedTabChange"},features:[Ke]}),n})(),bE=(()=>{class n extends NCe{get fitInkBarToContent(){return this._fitInkBarToContent}set fitInkBarToContent(e){this._fitInkBarToContent=Rt(e),this._changeDetectorRef.markForCheck()}get stretchTabs(){return this._stretchTabs}set stretchTabs(e){this._stretchTabs=Rt(e)}constructor(e,i,r,o){super(e,i,r,o),this._fitInkBarToContent=!1,this._stretchTabs=!0,this.fitInkBarToContent=!(!r||null==r.fitInkBarToContent)&&r.fitInkBarToContent}}return n.\u0275fac=function(e){return new(e||n)(C(Me),C($t),C(aY,8),C(hi,8))},n.\u0275cmp=O({type:n,selectors:[["mat-tab-group"]],contentQueries:function(e,i,r){if(1&e&&Ti(r,sy,5),2&e){let o;Se(o=Ee())&&(i._allTabs=o)}},viewQuery:function(e,i){if(1&e&&(Ge(uCe,5),Ge(pCe,5)),2&e){let r;Se(r=Ee())&&(i._tabBodyWrapper=r.first),Se(r=Ee())&&(i._tabHeader=r.first)}},hostAttrs:[1,"mat-mdc-tab-group"],hostVars:6,hostBindings:function(e,i){2&e&&nt("mat-mdc-tab-group-dynamic-height",i.dynamicHeight)("mat-mdc-tab-group-inverted-header","below"===i.headerPosition)("mat-mdc-tab-group-stretch-tabs",i.stretchTabs)},inputs:{color:"color",disableRipple:"disableRipple",fitInkBarToContent:"fitInkBarToContent",stretchTabs:["mat-stretch-tabs","stretchTabs"]},exportAs:["matTabGroup"],features:[Qt([{provide:oY,useExisting:n}]),Ke],decls:6,vars:7,consts:[[3,"selectedIndex","disableRipple","disablePagination","indexFocused","selectFocusedIndex"],["tabHeader",""],["class","mdc-tab mat-mdc-tab mat-mdc-focus-indicator","role","tab","matTabLabelWrapper","","cdkMonitorElementFocus","",3,"id","mdc-tab--active","ngClass","disabled","fitInkBarToContent","click","cdkFocusChange",4,"ngFor","ngForOf"],[1,"mat-mdc-tab-body-wrapper"],["tabBodyWrapper",""],["role","tabpanel",3,"id","mat-mdc-tab-body-active","ngClass","content","position","origin","animationDuration","preserveContent","_onCentered","_onCentering",4,"ngFor","ngForOf"],["role","tab","matTabLabelWrapper","","cdkMonitorElementFocus","",1,"mdc-tab","mat-mdc-tab","mat-mdc-focus-indicator",3,"id","ngClass","disabled","fitInkBarToContent","click","cdkFocusChange"],["tabNode",""],[1,"mdc-tab__ripple"],["mat-ripple","",1,"mat-mdc-tab-ripple",3,"matRippleTrigger","matRippleDisabled"],[1,"mdc-tab__content"],[1,"mdc-tab__text-label"],[3,"ngIf","ngIfElse"],["tabTextLabel",""],[3,"cdkPortalOutlet"],["role","tabpanel",3,"id","ngClass","content","position","origin","animationDuration","preserveContent","_onCentered","_onCentering"]],template:function(e,i){1&e&&(h(0,"mat-tab-header",0,1),I("indexFocused",function(o){return i._focusChanged(o)})("selectFocusedIndex",function(o){return i.selectedIndex=o}),S(2,gCe,9,17,"div",2),g(),h(3,"div",3,4),S(5,_Ce,1,11,"mat-tab-body",5),g()),2&e&&(_("selectedIndex",i.selectedIndex||0)("disableRipple",i.disableRipple)("disablePagination",i.disablePagination),v(2),_("ngForOf",i._tabs),v(1),nt("_mat-animation-noopable","NoopAnimations"===i._animationMode),v(2),_("ngForOf",i._tabs))},dependencies:[yn,nn,Fe,ps,mo,y7,tY,rY,OCe],styles:['.mdc-tab{min-width:90px;padding-right:24px;padding-left:24px;display:flex;flex:1 0 auto;justify-content:center;box-sizing:border-box;margin:0;padding-top:0;padding-bottom:0;border:none;outline:none;text-align:center;white-space:nowrap;cursor:pointer;-webkit-appearance:none;z-index:1}.mdc-tab::-moz-focus-inner{padding:0;border:0}.mdc-tab[hidden]{display:none}.mdc-tab--min-width{flex:0 1 auto}.mdc-tab__content{display:flex;align-items:center;justify-content:center;height:inherit;pointer-events:none}.mdc-tab__text-label{transition:150ms color linear;display:inline-block;line-height:1;z-index:2}.mdc-tab__icon{transition:150ms color linear;z-index:2}.mdc-tab--stacked .mdc-tab__content{flex-direction:column;align-items:center;justify-content:center}.mdc-tab--stacked .mdc-tab__text-label{padding-top:6px;padding-bottom:4px}.mdc-tab--active .mdc-tab__text-label,.mdc-tab--active .mdc-tab__icon{transition-delay:100ms}.mdc-tab:not(.mdc-tab--stacked) .mdc-tab__icon+.mdc-tab__text-label{padding-left:8px;padding-right:0}[dir=rtl] .mdc-tab:not(.mdc-tab--stacked) .mdc-tab__icon+.mdc-tab__text-label,.mdc-tab:not(.mdc-tab--stacked) .mdc-tab__icon+.mdc-tab__text-label[dir=rtl]{padding-left:0;padding-right:8px}.mdc-tab-indicator .mdc-tab-indicator__content--underline{border-top-width:2px}.mdc-tab-indicator .mdc-tab-indicator__content--icon{height:34px;font-size:34px}.mdc-tab-indicator{display:flex;position:absolute;top:0;left:0;justify-content:center;width:100%;height:100%;pointer-events:none;z-index:1}.mdc-tab-indicator__content{transform-origin:left;opacity:0}.mdc-tab-indicator__content--underline{align-self:flex-end;box-sizing:border-box;width:100%;border-top-style:solid}.mdc-tab-indicator__content--icon{align-self:center;margin:0 auto}.mdc-tab-indicator--active .mdc-tab-indicator__content{opacity:1}.mdc-tab-indicator .mdc-tab-indicator__content{transition:250ms transform cubic-bezier(0.4, 0, 0.2, 1)}.mdc-tab-indicator--no-transition .mdc-tab-indicator__content{transition:none}.mdc-tab-indicator--fade .mdc-tab-indicator__content{transition:150ms opacity linear}.mdc-tab-indicator--active.mdc-tab-indicator--fade .mdc-tab-indicator__content{transition-delay:100ms}.mat-mdc-tab-ripple{position:absolute;top:0;left:0;bottom:0;right:0;pointer-events:none}.mat-mdc-tab{-webkit-tap-highlight-color:rgba(0,0,0,0)}.mat-mdc-tab.mdc-tab{height:48px;flex-grow:0}.mat-mdc-tab .mdc-tab__ripple::before{content:"";display:block;position:absolute;top:0;left:0;right:0;bottom:0;opacity:0;pointer-events:none}.mat-mdc-tab .mdc-tab__text-label{display:inline-flex;align-items:center}.mat-mdc-tab .mdc-tab__content{position:relative;pointer-events:auto}.mat-mdc-tab:hover .mdc-tab__ripple::before{opacity:.04}.mat-mdc-tab.cdk-program-focused .mdc-tab__ripple::before,.mat-mdc-tab.cdk-keyboard-focused .mdc-tab__ripple::before{opacity:.12}.mat-mdc-tab .mat-ripple-element{opacity:.12}.mat-mdc-tab-group.mat-mdc-tab-group-stretch-tabs>.mat-mdc-tab-header .mat-mdc-tab{flex-grow:1}.mat-mdc-tab-disabled{opacity:.4}.mat-mdc-tab-group{display:flex;flex-direction:column;max-width:100%}.mat-mdc-tab-group.mat-tabs-with-background>.mat-mdc-tab-header,.mat-mdc-tab-group.mat-tabs-with-background>.mat-mdc-tab-header-pagination{background-color:var(--mat-mdc-tab-header-with-background-background-color, transparent)}.mat-mdc-tab-group.mat-tabs-with-background>.mat-mdc-tab-header .mat-mdc-tab .mdc-tab__text-label,.mat-mdc-tab-group.mat-tabs-with-background>.mat-mdc-tab-header .mat-mdc-tab-link .mdc-tab__text-label{color:var(--mat-mdc-tab-header-with-background-foreground-color, inherit)}.mat-mdc-tab-group.mat-tabs-with-background>.mat-mdc-tab-header .mdc-tab-indicator__content--underline,.mat-mdc-tab-group.mat-tabs-with-background>.mat-mdc-tab-header .mat-mdc-tab-header-pagination-chevron,.mat-mdc-tab-group.mat-tabs-with-background>.mat-mdc-tab-header .mat-mdc-focus-indicator::before{border-color:var(--mat-mdc-tab-header-with-background-foreground-color, inherit)}.mat-mdc-tab-group.mat-tabs-with-background>.mat-mdc-tab-header .mat-ripple-element,.mat-mdc-tab-group.mat-tabs-with-background>.mat-mdc-tab-header .mdc-tab__ripple::before,.mat-mdc-tab-group.mat-tabs-with-background>.mat-mdc-tab-header-pagination .mat-ripple-element,.mat-mdc-tab-group.mat-tabs-with-background>.mat-mdc-tab-header-pagination .mdc-tab__ripple::before{background-color:var(--mat-mdc-tab-header-with-background-foreground-color, inherit)}.mat-mdc-tab-group.mat-tabs-with-background>.mat-mdc-tab-header .mat-mdc-tab-header-pagination-chevron,.mat-mdc-tab-group.mat-tabs-with-background>.mat-mdc-tab-header-pagination .mat-mdc-tab-header-pagination-chevron{border-color:var(--mat-mdc-tab-header-with-background-foreground-color, inherit)}.mat-mdc-tab-group.mat-mdc-tab-group-inverted-header{flex-direction:column-reverse}.mat-mdc-tab-group.mat-mdc-tab-group-inverted-header .mdc-tab-indicator__content--underline{align-self:flex-start}.mat-mdc-tab-body-wrapper{position:relative;overflow:hidden;display:flex;transition:height 500ms cubic-bezier(0.35, 0, 0.25, 1)}.mat-mdc-tab-body-wrapper._mat-animation-noopable{transition:none !important;animation:none !important}'],encapsulation:2}),n})(),iN=class{},LCe=0,BCe=(()=>{class n extends sY{get backgroundColor(){return this._backgroundColor}set backgroundColor(e){let i=this._elementRef.nativeElement.classList;i.remove("mat-tabs-with-background",`mat-background-${this.backgroundColor}`),e&&i.add("mat-tabs-with-background",`mat-background-${e}`),this._backgroundColor=e}get disableRipple(){return this._disableRipple}set disableRipple(e){this._disableRipple=Rt(e)}constructor(e,i,r,o,s,a,l){super(e,o,s,i,r,a,l),this._disableRipple=!1,this.color="primary"}_itemSelected(){}ngAfterContentInit(){this._items.changes.pipe(qn(null),ot(this._destroyed)).subscribe(()=>{this.updateActiveLink()}),super.ngAfterContentInit()}updateActiveLink(){if(!this._items)return;let e=this._items.toArray();for(let i=0;i<e.length;i++)if(e[i].active)return this.selectedIndex=i,this._changeDetectorRef.markForCheck(),void(this.tabPanel&&(this.tabPanel._activeTabId=e[i].id));this.selectedIndex=-1,this._inkBar.hide()}_getRole(){return this.tabPanel?"tablist":this._elementRef.nativeElement.getAttribute("role")}}return n.\u0275fac=function(e){return new(e||n)(C(Me),C(Xi,8),C(at),C($t),C(js),C(Gn),C(hi,8))},n.\u0275dir=we({type:n,inputs:{backgroundColor:"backgroundColor",disableRipple:"disableRipple",color:"color",tabPanel:"tabPanel"},features:[Ke]}),n})(),VCe=ku(us(so(class{}))),HCe=(()=>{class n extends VCe{get active(){return this._isActive}set active(e){let i=Rt(e);i!==this._isActive&&(this._isActive=i,this._tabNavBar.updateActiveLink())}get rippleDisabled(){return this.disabled||this.disableRipple||this._tabNavBar.disableRipple||!!this.rippleConfig.disabled}constructor(e,i,r,o,s,a){super(),this._tabNavBar=e,this.elementRef=i,this._focusMonitor=s,this._isActive=!1,this.id="mat-tab-link-"+LCe++,this.rippleConfig=r||{},this.tabIndex=parseInt(o)||0,"NoopAnimations"===a&&(this.rippleConfig.animation={enterDuration:0,exitDuration:0})}focus(){this.elementRef.nativeElement.focus()}ngAfterViewInit(){this._focusMonitor.monitor(this.elementRef)}ngOnDestroy(){this._focusMonitor.stopMonitoring(this.elementRef)}_handleFocus(){this._tabNavBar.focusIndex=this._tabNavBar._items.toArray().indexOf(this)}_handleKeydown(e){this._tabNavBar.tabPanel&&32===e.keyCode&&this.elementRef.nativeElement.click()}_getAriaControls(){return this._tabNavBar.tabPanel?this._tabNavBar.tabPanel?.id:this.elementRef.nativeElement.getAttribute("aria-controls")}_getAriaSelected(){return this._tabNavBar.tabPanel?this.active?"true":"false":this.elementRef.nativeElement.getAttribute("aria-selected")}_getAriaCurrent(){return this.active&&!this._tabNavBar.tabPanel?"page":null}_getRole(){return this._tabNavBar.tabPanel?"tab":this.elementRef.nativeElement.getAttribute("role")}_getTabIndex(){return this._tabNavBar.tabPanel?this._isActive&&!this.disabled?0:-1:this.tabIndex}}return n.\u0275fac=function(e){return new(e||n)(C(BCe),C(Me),C(y2,8),yo("tabindex"),C(Xr),C(hi,8))},n.\u0275dir=we({type:n,inputs:{active:"active",id:"id"},features:[Ke]}),n})(),vE=(iY(HCe),(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Pe,fn,Hl,Bl,ng,lg,fn]}),n})());function zCe(n,t){if(1&n){let e=ge();h(0,"span",5),I("click",function(r){X(e);let o=w().$implicit;return Q(w().onActivePluginSelection(r,o.id))}),T(1),g()}if(2&n){let e=w().$implicit;Be("data-plugin-id",e.id),v(1),He(" ",e.tab_name," ")}}function UCe(n,t){1&n&&(h(0,"mat-tab",3),S(1,zCe,2,2,"ng-template",4),g()),2&n&&_("disabled",!t.$implicit.enabled)}function jCe(n,t){if(1&n&&(h(0,"mat-option",9),T(1),g()),2&n){let e=t.$implicit;_("value",e.id),Be("data-plugin-id",e.id),v(1),He(" ",e.tab_name," ")}}function GCe(n,t){if(1&n){let e=ge();h(0,"mat-form-field",6)(1,"mat-label"),T(2,"Inactive"),g(),h(3,"mat-select",7),I("selectionChange",function(r){return X(e),Q(w().onDisabledPluginSelectionChanged(r))}),S(4,jCe,2,3,"mat-option",8),g()()}if(2&n){let e=w();v(3),_("value",e.selectedPlugin)("hideSingleSelectionIndicator",!0),v(1),_("ngForOf",e.disabledPlugins)}}var cY=(()=>{class n{constructor(){this.onPluginSelectionChanged=new F}getActivePluginIndex(){return this.activePlugins.findIndex(({id:e})=>e===this.selectedPlugin)}onActivePluginSelection(e,i){e.stopPropagation(),this.onPluginSelectionChanged.emit(i)}onDisabledPluginSelectionChanged(e){this.onPluginSelectionChanged.emit(e.value)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["plugin-selector-component"]],inputs:{activePlugins:"activePlugins",disabledPlugins:"disabledPlugins",selectedPlugin:"selectedPlugin"},outputs:{onPluginSelectionChanged:"onPluginSelectionChanged"},decls:3,vars:3,consts:[["mat-stretch-tabs","false","animationDuration","100ms",1,"active-plugin-list",3,"selectedIndex"],[3,"disabled",4,"ngFor","ngForOf"],["floatLabel","never","subscriptSizing","dynamic",4,"ngIf"],[3,"disabled"],["mat-tab-label",""],[1,"plugin-name",3,"click"],["floatLabel","never","subscriptSizing","dynamic"],[3,"value","hideSingleSelectionIndicator","selectionChange"],[3,"value",4,"ngFor","ngForOf"],[3,"value"]],template:function(e,i){1&e&&(h(0,"mat-tab-group",0),S(1,UCe,2,1,"mat-tab",1),g(),S(2,GCe,5,3,"mat-form-field",2)),2&e&&(_("selectedIndex",i.getActivePluginIndex()),v(1),_("ngForOf",i.activePlugins),v(1),_("ngIf",i.disabledPlugins.length>0))},dependencies:[rN,sy,bE,Ka,kc,zu,Us,nn,Fe],styles:["[_nghost-%COMP%]{align-items:center;display:flex;flex:1 1 auto;font-size:14px;height:100%;overflow:hidden}[_nghost-%COMP%]   mat-form-field[_ngcontent-%COMP%]    {width:144px}[_nghost-%COMP%]   mat-form-field[_ngcontent-%COMP%]     .mdc-text-field{background-color:#f57c00;padding:0 4px}body.dark-mode   [_nghost-%COMP%]   mat-form-field[_ngcontent-%COMP%]     .mdc-text-field{background-color:#ef6c00}[_nghost-%COMP%]   mat-form-field[_ngcontent-%COMP%]     label.mdc-floating-label.mat-mdc-floating-label, [_nghost-%COMP%]   mat-form-field[_ngcontent-%COMP%]     .mat-mdc-select, [_nghost-%COMP%]   mat-form-field[_ngcontent-%COMP%]     .mat-mdc-select-value, [_nghost-%COMP%]   mat-form-field[_ngcontent-%COMP%]     .mat-mdc-select-arrow{color:inherit}[_nghost-%COMP%]   mat-form-field[_ngcontent-%COMP%]     .mdc-text-field--filled:not(.mdc-text-field--disabled) .mdc-line-ripple::before{border-color:inherit}mat-label[_ngcontent-%COMP%], mat-select[_ngcontent-%COMP%], mat-option[_ngcontent-%COMP%]{font-size:14px;font-weight:500;text-transform:uppercase}.active-plugin-list[_ngcontent-%COMP%]{align-self:stretch;flex:1 1 auto;overflow:hidden}.plugin-name[_ngcontent-%COMP%]{align-items:center;display:inline-flex;height:100%;justify-content:center;padding:0 12px;width:100%}[_nghost-%COMP%]     .active-plugin-list .mat-mdc-tab:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline{border-color:currentColor}[_nghost-%COMP%]     .active-plugin-list .mat-mdc-tab:not(.mat-mdc-tab-disabled) .mdc-tab__text-label{color:inherit;opacity:.7}[_nghost-%COMP%]     .active-plugin-list .mat-mdc-tab:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label{color:inherit;opacity:1}[_nghost-%COMP%]     .active-plugin-list .mat-mdc-tab-header-pagination{color:inherit}[_nghost-%COMP%]     .active-plugin-list .mat-mdc-tab-header-pagination-chevron{border-color:currentColor}[_nghost-%COMP%]     .active-plugin-list .mat-mdc-tab-header-pagination-disabled{visibility:hidden}[_nghost-%COMP%]     .active-plugin-list .mat-mdc-tab-disabled{display:none}[_nghost-%COMP%]     .active-plugin-list mat-mdc-tab-list, [_nghost-%COMP%]     .active-plugin-list .mat-mdc-tab-header, [_nghost-%COMP%]     .active-plugin-list .mat-mdc-tab-labels, [_nghost-%COMP%]     .active-plugin-list .mat-mdc-tab-header .mat-mdc-tab, [_nghost-%COMP%]     .active-plugin-list .mdc-tab__text-label{height:100%}[_nghost-%COMP%]     .active-plugin-list .mat-mdc-tab{letter-spacing:.25px;min-width:48px;padding:0;text-transform:uppercase}[_nghost-%COMP%]     .active-plugin-list mat-tab-header .mat-mdc-tab-list{padding:0 36px}[_nghost-%COMP%]     .active-plugin-list mat-tab-header>:first-child, [_nghost-%COMP%]     .active-plugin-list mat-tab-header>.mat-mdc-tab-label-container, [_nghost-%COMP%]     .active-plugin-list mat-tab-header>:last-child{bottom:0;position:absolute;top:0}[_nghost-%COMP%]     .active-plugin-list mat-tab-header>:first-child, [_nghost-%COMP%]     .active-plugin-list mat-tab-header>.mat-mdc-tab-label-container{left:0}[_nghost-%COMP%]     .active-plugin-list mat-tab-header>:last-child, [_nghost-%COMP%]     .active-plugin-list mat-tab-header>.mat-mdc-tab-label-container{right:0}[_nghost-%COMP%]     .active-plugin-list mat-tab-header>.mat-mdc-tab-header-pagination{background-color:#f57c00}body.dark-mode   [_nghost-%COMP%]     .active-plugin-list mat-tab-header>.mat-mdc-tab-header-pagination{background-color:#ef6c00}"]}),n})(),dY=q(Nh,n=>Object.keys(n).map(t=>Object.assign({},{id:t},n[t]))),qCe=q(dY,n=>n.filter(t=>!t.enabled)),uY=(()=>{class n{constructor(e){this.store=e,this.activePlugin$=this.store.pipe(un(Wo)),this.plugins$=this.store.pipe(un(dY)),this.disabledPlugins$=this.store.pipe(un(qCe))}onPluginSelectionChange(e){this.store.dispatch(wc({plugin:e}))}}return n.\u0275fac=function(e){return new(e||n)(C(Ae))},n.\u0275cmp=O({type:n,selectors:[["plugin-selector"]],decls:4,vars:9,consts:[[3,"activePlugins","disabledPlugins","selectedPlugin","onPluginSelectionChanged"]],template:function(e,i){1&e&&(h(0,"plugin-selector-component",0),I("onPluginSelectionChanged",function(o){return i.onPluginSelectionChange(o)}),j(1,"async"),j(2,"async"),j(3,"async"),g()),2&e&&_("activePlugins",W(1,3,i.plugins$))("disabledPlugins",W(2,5,i.disabledPlugins$))("selectedPlugin",W(3,7,i.activePlugin$))},dependencies:[cY,ct],encapsulation:2}),n})(),XCe=q(Nh,Wo,(n,t)=>!(!t||!n[t])&&n[t].disable_reload),pY=(()=>{class n{constructor(e){this.store=e,this.reloadDisabled$=this.store.select(XCe),this.isReloading$=this.store.select(T6).pipe(Li(this.reloadDisabled$),N(([i,r])=>!r&&i===Te.LOADING)),this.lastLoadedTimeInMs$=this.store.select(Fh)}triggerReload(){this.store.dispatch(Fs())}getReloadTitle(e){return e?`Last Updated: ${e}`:"Loading..."}}return n.\u0275fac=function(e){return new(e||n)(C(Ae))},n.\u0275cmp=O({type:n,selectors:[["app-header-reload"]],decls:6,vars:13,consts:[["mat-icon-button","",1,"reload-button",3,"title","disabled","click"],["svgIcon","refresh_24px",1,"refresh-icon"]],template:function(e,i){1&e&&(h(0,"button",0),I("click",function(){return i.triggerReload()}),j(1,"async"),j(2,"date"),j(3,"async"),j(4,"async"),P(5,"mat-icon",1),g()),2&e&&(nt("loading",W(1,4,i.isReloading$)),_("title",i.getReloadTitle(qp(2,6,W(3,9,i.lastLoadedTimeInMs$),"medium")))("disabled",W(4,11,i.reloadDisabled$)))},dependencies:[$i,En,ct,gh],styles:[".reload-button[_ngcontent-%COMP%], .refresh-icon[_ngcontent-%COMP%] {\n        align-items: center;\n        display: flex;\n        justify-content: center;\n      }\n\n      .reload-button.loading[_ngcontent-%COMP%] {\n        animation: _ngcontent-%COMP%_rotate 2s linear infinite;\n      }\n\n      @keyframes _ngcontent-%COMP%_rotate {\n        0% {\n          transform: rotate(0deg);\n        }\n        50% {\n          transform: rotate(180deg);\n        }\n        100% {\n          transform: rotate(360deg);\n        }\n      }"]}),n})(),fY=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["app-header"]],decls:9,vars:0,consts:[[1,"brand"],[1,"plugins"],["mat-icon-button","","href","https://github.com/tensorflow/tensorboard/blob/master/README.md","rel","noopener noreferrer","target","_blank","aria-label","Help",1,"readme"],["svgIcon","help_outline_24px"]],template:function(e,i){1&e&&(h(0,"mat-toolbar")(1,"span",0),T(2,"TensorBoard"),g(),P(3,"plugin-selector",1)(4,"app-header-dark-mode-toggle")(5,"app-header-reload")(6,"settings-button"),h(7,"a",2),P(8,"mat-icon",3),g()())},dependencies:[O7,En,kq,qq,Kq,uY,pY],styles:["mat-toolbar[_ngcontent-%COMP%]{align-items:center;color:#fff;display:flex;height:64px;overflow:hidden;width:100%}.brand[_ngcontent-%COMP%], .readme[_ngcontent-%COMP%], app-header-reload[_ngcontent-%COMP%], settings-button[_ngcontent-%COMP%]{flex:0 0 auto}.brand[_ngcontent-%COMP%]{letter-spacing:-0.025em;margin-left:10px;text-rendering:optimizeLegibility}.plugins[_ngcontent-%COMP%]{align-items:center;display:flex;flex:1 1 auto;font-size:14px;height:100%;overflow:hidden}"]}),n})(),JCe_setDocumentTitle=function(n){document.title=n},mY=(()=>{class n{ngOnChanges(e){e.title&&JCe_setDocumentTitle(e.title.currentValue)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["page-title-component"]],inputs:{title:"title"},features:[Gt],decls:0,vars:0,template:function(e,i){},encapsulation:2,changeDetection:0}),n})(),hY="TensorBoard",gY=(()=>{class n{constructor(e,i){this.store=e,this.customBrandName=i,this.getExperimentId$=this.store.select(lr).pipe(N(r=>r?.[0])),this.experimentName$=this.getExperimentId$.pipe(ke(Boolean),hn(r=>this.store.select(BS,{experimentId:r})),N(r=>r?r.name:null)),this.title$=this.store.select(xS).pipe(Li(this.store.select(Ha),this.experimentName$),N(([r,o,s])=>{let a=this.customBrandName||hY;return r.window_title?r.window_title:o===wn.EXPERIMENT&&s?`${s} - ${a}`:a}),qn(this.customBrandName||hY),Yn())}}return n.\u0275fac=function(e){return new(e||n)(C(Ae),C(v6,8))},n.\u0275cmp=O({type:n,selectors:[["page-title"]],decls:2,vars:3,consts:[[3,"title"]],template:function(e,i){1&e&&(P(0,"page-title-component",0),j(1,"async")),2&e&&_("title",W(1,1,i.title$))},dependencies:[mY,ct],styles:["[_nghost-%COMP%] {\n        display: none;\n      }"],changeDetection:0}),n})(),_Y=(()=>{class n{constructor(e){this.store=e,this.ngUnsubscribe=new Ie,this.getPageSize$=this.store.pipe(un(_f)),this.paginatedViewStore=document.createElement("tf-paginated-view-store").tf_paginated_view}ngOnInit(){this.getPageSize$.pipe(ot(this.ngUnsubscribe),Yn()).subscribe(e=>{this.paginatedViewStore.setLimit(e)})}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}}return n.\u0275fac=function(e){return new(e||n)(C(Ae))},n.\u0275cmp=O({type:n,selectors:[["settings-polymer-interop"]],decls:0,vars:0,template:function(e,i){},encapsulation:2,changeDetection:0}),n})(),bY=(()=>{class n{constructor(e){this.vcRef=e}}return n.\u0275fac=function(e){return new(e||n)(C(si))},n.\u0275cmp=O({type:n,selectors:[["tb-webapp"]],decls:9,vars:0,template:function(e,i){1&e&&(P(0,"app-header"),h(1,"main"),P(2,"router-outlet"),g(),P(3,"alert-snackbar")(4,"hash-storage")(5,"page-title")(6,"settings-polymer-interop")(7,"dark-mode-supporter")(8,"feature-flag-modal-trigger"))},dependencies:[Mq,Sq,n9,Eq,Dq,fY,gY,_Y],styles:["html[_ngcontent-%COMP%], body[_ngcontent-%COMP%]{font-family:Roboto,sans-serif;height:100%;margin:0;padding:0}[_nghost-%COMP%]{background:#f5f5f5;display:flex;flex-direction:column;height:100%}app-header[_ngcontent-%COMP%]{box-shadow:0 1px 3px 3px rgba(0,0,0,.25);flex:0 0;z-index:1}body.dark-mode[_nghost-%COMP%]   app-header[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   app-header[_ngcontent-%COMP%]{box-shadow:0 1px 3px 3px rgba(255,255,255,.1)}main[_ngcontent-%COMP%]{flex-grow:1;overflow:auto}"]}),n})(),vY=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Pe,Sh,wh,Dl]}),n})(),yY=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({}),n})(),xY=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({providers:[{provide:_u,useClass:X8}]}),n})(),CY=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Pe,xY]}),n})(),MY=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Pe]}),n})(),wY={id:Xw,name:"",start_time:0},iMe=br({experimentMap:{[wY.id]:wY}});function SY(n,t){return rf({data:iMe})(n,t)}var EY=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Tr.forFeature(LS,SY)]}),n})(),TY=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Pe,ci,Ja]}),n})(),DY=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Pe,TY]}),n})(),IY=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Pe,xg,bq,ci,Fc,hg,di,$a]}),n})();function rMe(){return q(Iv,n=>({autoReload:n}))}function oMe(){return q(Av,n=>({autoReloadPeriodInMs:n}))}function sMe(){return q(_f,n=>({pageSize:n}))}var yE=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Tr.forFeature(M1,Nq),Ki.defineGlobalSetting(rMe),Ki.defineGlobalSetting(oMe),Ki.defineGlobalSetting(sMe),IY]}),n})(),AY=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[ci,di,vE,Fq,Ja,ju,Pe,Ga,yE]}),n})(),RY=(()=>{class n{constructor(e,i){let r=e.bypassSecurityTrustResourceUrl("./icon_bundle.svg");i.addSvgIconSet(r)}}return n.\u0275fac=function(e){return new(e||n)(k(Zp),k(Mg))},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[di]}),n})(),oN=new ie("[plugins] Plugin registry config"),PY=new Map,Bc=(()=>{class n{constructor(e){if(!e)return;let i=new Set(e.map(r=>r.pluginName));console.assert(i.size===e.length,"Cannot register the same plugin multiple times.");for(let r of e){let{pluginName:o,componentClass:s}=r;PY.set(o,s)}}static forPlugin(e,i){return{ngModule:n,providers:[{provide:oN,multi:!0,useValue:{pluginName:e,componentClass:i}}]}}getComponent(e){return PY.get(e)||null}}return n.\u0275fac=function(e){return new(e||n)(k(oN,8))},n.\u0275mod=G({type:n}),n.\u0275inj=U({}),n})(),xE=(()=>{class n{constructor(e){this.http=e,this.httpPathPrefix="data/plugin/debugger-v2"}fetchRuns(){return this.http.get(this.httpPathPrefix+"/runs")}fetchExecutionDigests(e,i,r){return this.http.get(this.httpPathPrefix+"/execution/digests",{params:{run:e,begin:String(i),end:String(r)}})}fetchExecutionData(e,i,r){return this.http.get(this.httpPathPrefix+"/execution/data",{params:{run:e,begin:String(i),end:String(r)}})}fetchGraphExecutionDigests(e,i,r,o){if(void 0!==o)throw new Error("trace_id is not implemented for fetchGraphExecutionDigests() yet");return this.http.get(this.httpPathPrefix+"/graph_execution/digests",{params:{run:e,begin:String(i),end:String(r)}})}fetchGraphExecutionData(e,i,r,o){if(void 0!==o)throw new Error("trace_id is not implemented for fetchGraphExecutionData() yet");return this.http.get(this.httpPathPrefix+"/graph_execution/data",{params:{run:e,begin:String(i),end:String(r)}})}fetchGraphOpInfo(e,i,r){return this.http.get(this.httpPathPrefix+"/graphs/op_info",{params:{run:e,graph_id:i,op_name:r}})}fetchSourceFileList(e){return this.http.get(this.httpPathPrefix+"/source_files/list",{params:{run:e}})}fetchSourceFile(e,i){return this.http.get(this.httpPathPrefix+"/source_files/file",{params:{run:e,index:String(i)}})}fetchStackFrames(e,i){return this.http.get(this.httpPathPrefix+"/stack_frames/stack_frames",{params:{run:e,stack_frame_ids:i.join(",")}}).pipe(N(r=>({stack_frames:r.stack_frames.map(o=>function(n){return{host_name:n[0],file_path:n[1],lineno:n[2],function_name:n[3]}}(o))})))}fetchAlerts(e,i,r,o){let s={run:e,begin:String(i),end:String(r)};return void 0!==o&&(s.alert_type=o),this.http.get(this.httpPathPrefix+"/alerts",{params:s})}}return n.\u0275fac=function(e){return new(e||n)(k(Ua))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),OY=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({providers:[xE],imports:[Oh]}),n})(),CE=_e("[Debugger] Debugger Loaded"),ME=_e("[Debugger] Debugger Unloaded"),ay=_e("[Debugger] A New Debugger Data Polling Event Begins"),wE=_e("[Debugger] Debugger Runs Requested"),SE=_e("[Debugger] Debugger Runs Loaded",{_as:"props",_p:void 0}),kY=_e("[Debugger] Debugger Runs Request Failed"),ly=_e("[Debugger] Number and Breakdown of Alerts Requested"),EE=_e("[Debugger] Number and Breakdown of Alerts Loaded",{_as:"props",_p:void 0}),TE=_e("[Debugger] Alerts Data of an AlertType Is Loaded",{_as:"props",_p:void 0}),Sg=_e("[Debugger] Alert Type Focus Toggled",{_as:"props",_p:void 0}),DE=_e("[Debugger] Number of Top-Level Executions Requested"),IE=_e("[Debugger] Number of Top-Level Executions Loaded",{_as:"props",_p:void 0}),AE=_e("[Debugger] ExecutionDigests Requested",{_as:"props",_p:void 0}),RE=_e("[Debugger] ExecutionDigests Loaded",{_as:"props",_p:void 0}),Eg=_e("[Debugger] Scroll Leftward on the Execution Timeline"),Tg=_e("[Debugger] Scroll Rightward on the Execution Timeline"),Dg=_e("[Debugger] Scroll the Execution Timeline to Given Index",{_as:"props",_p:void 0}),Ig=_e("[Debugger] Execution Data Objects Being Focused On",{_as:"props",_p:void 0}),PE=_e("[Debugger] Execution Data Objects Loaded",{_as:"props",_p:void 0}),OE=_e("[Debugger] Number of Intra-Graph Executions Requested"),kE=_e("[Debugger] Number of Intra-Graph Executions Loaded",{_as:"props",_p:void 0}),FE=_e("[Debugger] Intra-Graph Execution Data Requested",{_as:"props",_p:void 0}),NE=_e("[Debugger] Intra-Graph Execution Data Loaded",{_as:"props",_p:void 0}),Ag=_e("[Debugger] Scroll Intra-Graph Execution List to Given Index",{_as:"props",_p:void 0}),Rg=_e("[Debugger] Graph Execution is Focused On",{_as:"props",_p:void 0}),Pg=_e("[Debugger] Graph Op Is Focused On",{_as:"props",_p:void 0}),LE=_e("[Debugger] Graph Op Info Requested",{_as:"props",_p:void 0}),BE=_e("[Debugger] Graph Op Info Loaded",{_as:"props",_p:void 0}),VE=_e("[Debugger] Source File List Requested."),HE=_e("[Debugger] Source File List Loaded",{_as:"props",_p:void 0}),Og=_e("[Debugger] Source File Line Is Focused on",{_as:"props",_p:void 0}),zE=_e("[Debugger] Source File Requested",{_as:"props",_p:void 0}),UE=_e("[Debugger] Source File Loaded",{_as:"props",_p:void 0}),cy=_e("[Debugger] A Set of Stack Frames Have Been Loaded",{_as:"props",_p:void 0}),dy="debugger",So=(()=>(function(n){n[n.UNSPECIFIED=0]="UNSPECIFIED",n[n.NO_TENSOR=1]="NO_TENSOR",n[n.CURT_HEALTH=2]="CURT_HEALTH",n[n.CONCISE_HEALTH=3]="CONCISE_HEALTH",n[n.FULL_HEALTH=4]="FULL_HEALTH",n[n.SHAPE=5]="SHAPE",n[n.FULL_NUMERICS=6]="FULL_NUMERICS",n[n.FULL_TENSOR=7]="FULL_TENSOR",n[n.REDUCE_INF_NAN_THREE_SLOTS=8]="REDUCE_INF_NAN_THREE_SLOTS"}(So||(So={})),So))(),Vc=(()=>(function(n){n.FUNCTION_RECOMPILE_ALERT="FunctionRecompilesAlert",n.INF_NAN_ALERT="InfNanAlert",n.TENSOR_SHAPE_ALERT="TensorShapeAlert"}(Vc||(Vc={})),Vc))(),Lo=(()=>(function(n){n[n.EXECUTION=0]="EXECUTION",n[n.GRAPH_OP_CREATION=1]="GRAPH_OP_CREATION"}(Lo||(Lo={})),Lo))();function kg(n){if(null===n.codeLocationFocusType)return null;let t=[];if(n.codeLocationFocusType===Lo.EXECUTION){let{focusIndex:i,executionData:r}=n.executions;if(null===i||void 0===r[i])return null;t=r[i].stack_frame_ids}else{if(null===n.graphs.focusedOp)return null;let{graphId:i,opName:r}=n.graphs.focusedOp;if(void 0===n.graphs.ops[i]||!n.graphs.ops[i].has(r))return null;t=n.graphs.ops[i].get(r).stack_frame_ids}let e=[];for(let i of t){if(null==n.stackFrames[i])return null;e.push(n.stackFrames[i])}return e}function uy(n,t){return n.findIndex(e=>e.host_name===t.host_name&&e.file_path===t.file_path)}function aN(n,t,e){if(t>=e)throw new Error(`Expected begin to be less than end, but got begin=${t}, end=${e}`);return n.findIndex(i=>i.begin===t&&i.end===e)}function jE(n){let t=n.sourceCode.focusLineSpec;if(!n.stickToBottommostFrameInFocusedFile)return t;let e=kg(n);if(null===e)return t;let i=function(n,t){if(null===t)return null;for(let e=n.length-1;e>=0;--e){let i=n[e],{host_name:r,file_path:o}=i;if(r===t.host_name&&o===t.file_path)return i}return null}(e,t);return null===i?t:i}var bMe=br({runs:{},runsLoaded:{state:Te.NOT_LOADED,lastLoadedTimeInMs:null},activeRunId:null,lastDataPollOnsetTimeMs:-1,lastNonEmptyPollDataTimeMs:1,alerts:{alertsLoaded:{state:Te.NOT_LOADED,lastLoadedTimeInMs:null},numAlerts:0,alertsBreakdown:{},alerts:{},executionIndices:{},graphExecutionIndices:{},focusType:null},executions:{numExecutionsLoaded:{state:Te.NOT_LOADED,lastLoadedTimeInMs:null},executionDigestsLoaded:{loadingRanges:[],numExecutions:0,pageLoadedSizes:{}},displayCount:50,pageSize:100,scrollBeginIndex:0,focusIndex:null,executionDigests:{},executionData:{}},graphExecutions:{numExecutionsLoaded:{state:Te.NOT_LOADED,lastLoadedTimeInMs:null},executionDigestsLoaded:{loadingRanges:[],numExecutions:0,pageLoadedSizes:{}},displayCount:100,pageSize:200,scrollBeginIndex:0,focusIndex:null,graphExecutionDigests:{},graphExecutionDataLoadingPages:[],graphExecutionDataPageLoadedSizes:{},graphExecutionData:{}},graphs:{ops:{},loadingOps:{},focusedOp:null},stackFrames:{},codeLocationFocusType:null,stickToBottommostFrameInFocusedFile:!1,sourceCode:{sourceFileListLoaded:{state:Te.NOT_LOADED,lastLoadedTimeInMs:null},sourceFileList:[],fileContents:[],focusLineSpec:null}},ye(wE,n=>({...n,runsLoaded:{...n.runsLoaded,state:Te.LOADING}})),ye(kY,n=>({...n,runsLoaded:{...n.runsLoaded,state:Te.FAILED}})),ye(SE,(n,{runs:t})=>{let e=Object.keys(t),i=e.length>0&&null===n.activeRunId;return{...n,lastNonEmptyPollDataTimeMs:i?Date.now():n.lastNonEmptyPollDataTimeMs,runs:t,runsLoaded:{state:Te.LOADED,lastLoadedTimeInMs:Date.now()},activeRunId:e.length>0?e[0]:null}}),ye(ay,n=>({...n,lastDataPollOnsetTimeMs:Date.now()})),ye(ly,n=>null===n.activeRunId?n:{...n,alerts:{...n.alerts,alertsLoaded:{...n.alerts.alertsLoaded,state:Te.LOADING}}}),ye(EE,(n,{numAlerts:t,alertsBreakdown:e})=>{if(null===n.activeRunId)return n;let r=t>n.alerts.numAlerts;return{...n,lastNonEmptyPollDataTimeMs:r?Date.now():n.lastNonEmptyPollDataTimeMs,alerts:{...n.alerts,alertsLoaded:{...n.alerts.alertsLoaded,state:Te.LOADED,lastLoadedTimeInMs:Date.now()},numAlerts:t,alertsBreakdown:e}}}),ye(TE,(n,{numAlerts:t,alertsBreakdown:e,alertType:i,begin:r,alerts:o})=>{if(null===n.activeRunId)return n;let a={},l=n.alerts.executionIndices[i]?n.alerts.executionIndices[i].slice():[],c=n.alerts.graphExecutionIndices[i]?n.alerts.graphExecutionIndices[i].slice():[];for(let p=0;p<o.length;++p){let f=r+p,m=o[p];if(a[f]=m,m.alert_type===Vc.INF_NAN_ALERT){let b=m;l[f]=b.execution_index,null!==b.graph_execution_trace_index&&(c[f]=b.graph_execution_trace_index)}}void 0!==n.alerts.alerts[i]&&Object.assign(a,n.alerts.alerts[i]);let d=n.executions.scrollBeginIndex,u=n.graphExecutions.focusIndex;if(i===Vc.INF_NAN_ALERT&&0===r){let p=o[0];d=Math.max(0,p.execution_index-Math.floor(n.executions.displayCount/2)),null!==p.graph_execution_trace_index&&(u=p.graph_execution_trace_index)}return{...n,executions:{...n.executions,scrollBeginIndex:d},graphExecutions:{...n.graphExecutions,focusIndex:u},alerts:{...n.alerts,alertsLoaded:{...n.alerts.alertsLoaded,state:Te.LOADED,lastLoadedTimeInMs:Date.now()},numAlerts:t,alertsBreakdown:e,alerts:{...n.alerts.alerts,[i]:a},executionIndices:{...n.alerts.executionIndices,[i]:l},graphExecutionIndices:{...n.alerts.graphExecutionIndices,[i]:c}}}}),ye(Sg,(n,{alertType:t})=>{let e={...n,alerts:{...n.alerts,focusType:n.alerts.focusType===t?null:t}},i=e.alerts.focusType;if(null!==i){let r=e.alerts.executionIndices[i]||[];void 0!==r[0]&&(e.executions={...e.executions,scrollBeginIndex:Math.max(0,Number(r[0])-Math.floor(e.executions.displayCount/2))})}return e}),ye(DE,n=>null===n.activeRunId?n:{...n,executions:{...n.executions,numExecutionsLoaded:{...n.executions.numExecutionsLoaded,state:Te.LOADING}}}),ye(IE,(n,{numExecutions:t})=>{if(null===n.activeRunId)return n;let i=t>n.executions.executionDigestsLoaded.numExecutions,r={...n,lastNonEmptyPollDataTimeMs:i?Date.now():n.lastNonEmptyPollDataTimeMs,executions:{...n.executions,numExecutionsLoaded:{...n.executions.numExecutionsLoaded,state:Te.LOADED,lastLoadedTimeInMs:Date.now()},executionDigestsLoaded:{...n.executions.executionDigestsLoaded,numExecutions:t}}};return t>0&&null===n.executions.focusIndex&&(r.executions.focusIndex=0),r}),ye(AE,(n,t)=>{if(null===n.activeRunId)return n;let i=[...n.executions.executionDigestsLoaded.loadingRanges];return-1===aN(i,t.begin,t.end)&&i.push({begin:t.begin,end:t.end}),{...n,executions:{...n.executions,executionDigestsLoaded:{...n.executions.executionDigestsLoaded,loadingRanges:i}}}}),ye(RE,(n,t)=>{if(null===n.activeRunId)return n;let i=[...n.executions.executionDigestsLoaded.loadingRanges],r=aN(i,t.begin,t.end);-1!==r&&i.splice(r,1);let o={...n,executions:{...n.executions,executionDigestsLoaded:{...n.executions.executionDigestsLoaded,numExecutions:t.num_digests,loadingRanges:i},executionDigests:{...n.executions.executionDigests}}};for(let s=t.begin;s<t.end;++s)o.executions.executionDigests[s]=t.execution_digests[s-t.begin];return t.end>t.begin&&(o.executions.executionDigestsLoaded.pageLoadedSizes={...o.executions.executionDigestsLoaded.pageLoadedSizes,[t.begin/n.executions.pageSize]:t.end-t.begin}),o}),ye(Eg,n=>{if(null===n.activeRunId)return n;let e=n.executions.scrollBeginIndex;return e>0&&e--,{...n,executions:{...n.executions,scrollBeginIndex:e}}}),ye(Tg,n=>{if(null===n.activeRunId)return n;let e=n.executions.scrollBeginIndex;return e+n.executions.displayCount+1<=n.executions.executionDigestsLoaded.numExecutions&&e++,{...n,executions:{...n.executions,scrollBeginIndex:e}}}),ye(Dg,(n,t)=>{if(t.index<0||!Number.isInteger(t.index))throw new Error(`Attempt to scroll to negative or non-integer execution index (${t.index})`);let{displayCount:e}=n.executions,{numExecutions:i}=n.executions.executionDigestsLoaded;if(t.index>Math.max(0,i-e))throw new Error(`Attempt to scroll to execution index (${t.index}), which exceeds maximum allowed index (numExecutions=${i}; displayCount=${e})`);return{...n,executions:{...n.executions,scrollBeginIndex:t.index}}}),ye(Ig,(n,t)=>{let e={...n,executions:{...n.executions,focusIndex:n.executions.scrollBeginIndex+t.displayIndex},codeLocationFocusType:Lo.EXECUTION,sourceCode:{...n.sourceCode}};return e.sourceCode.focusLineSpec=jE(e),e}),ye(PE,(n,t)=>{if(null===n.activeRunId)return n;let i={...n,executions:{...n.executions,executionData:{...n.executions.executionData}}};for(let r=t.begin;r<t.end;++r)i.executions.executionData[r]=t.executions[r-t.begin];return i}),ye(OE,n=>null===n.activeRunId?n:{...n,graphExecutions:{...n.graphExecutions,numExecutionsLoaded:{...n.graphExecutions.numExecutionsLoaded,state:Te.LOADING}}}),ye(kE,(n,{numGraphExecutions:t})=>{if(null===n.activeRunId)return n;let e=t>n.graphExecutions.executionDigestsLoaded.numExecutions,i={...n,lastNonEmptyPollDataTimeMs:e?Date.now():n.lastNonEmptyPollDataTimeMs,graphExecutions:{...n.graphExecutions,numExecutionsLoaded:{...n.graphExecutions.numExecutionsLoaded,state:Te.LOADED,lastLoadedTimeInMs:Date.now()},executionDigestsLoaded:{...n.graphExecutions.executionDigestsLoaded,numExecutions:t}}};return t>0&&null===n.graphExecutions.focusIndex&&(i.graphExecutions.focusIndex=0),i}),ye(FE,(n,{pageIndex:t})=>{if(null===n.activeRunId)return n;let e=n.graphExecutions.graphExecutionDataLoadingPages.slice();return-1===e.indexOf(t)&&e.push(t),{...n,graphExecutions:{...n.graphExecutions,graphExecutionDataLoadingPages:e}}}),ye(NE,(n,t)=>{if(null===n.activeRunId)return n;let{pageSize:e}=n.graphExecutions,i=n.graphExecutions.graphExecutionDataLoadingPages.slice(),r={...n.graphExecutions.graphExecutionDataPageLoadedSizes},o={...n.graphExecutions.graphExecutionData};for(let s=t.begin;s<t.end;++s){let a=Math.floor(s/e);-1!==i.indexOf(a)&&i.splice(i.indexOf(a),1),void 0===r[a]&&(r[a]=0),void 0===o[s]&&r[a]++,o[s]=t.graph_executions[s-t.begin]}return{...n,graphExecutions:{...n.graphExecutions,graphExecutionDataLoadingPages:i,graphExecutionDataPageLoadedSizes:r,graphExecutionData:o}}}),ye(Ag,(n,t)=>{if(t.index<0||!Number.isInteger(t.index))throw new Error(`Attempt to scroll to negative or non-integer graph-execution index (${t.index})`);return{...n,graphExecutions:{...n.graphExecutions,scrollBeginIndex:t.index}}}),ye(Rg,(n,t)=>LY(n,t.graph_id,t.op_name,t.index)),ye(Pg,(n,t)=>LY(n,t.graph_id,t.op_name)),ye(LE,(n,t)=>{let{graph_id:e,op_name:i}=t,r={...n,graphs:{...n.graphs,loadingOps:{...n.graphs.loadingOps}}};return void 0===r.graphs.loadingOps[e]&&(r.graphs.loadingOps[e]=new Map),r.graphs.loadingOps[e].has(i)||r.graphs.loadingOps[e].set(i,Te.LOADING),r}),ye(BE,(n,t)=>{let{graphOpInfoResponse:e}=t,{graph_ids:i}=e,r=i[i.length-1],o={...n,graphs:{...n.graphs,ops:{...n.graphs.ops,[r]:new Map(n.graphs.ops[r])},loadingOps:{...n.graphs.loadingOps,[r]:new Map(n.graphs.loadingOps[r])}}};for(let s of e.inputs)!s.data||o.graphs.ops[r].set(s.op_name,s.data);for(let s=0;s<e.consumers.length;++s)for(let a of e.consumers[s])!a.data||o.graphs.ops[r].set(a.op_name,a.data);return o.graphs.ops[r].set(e.op_name,{...e,inputs:e.inputs.map(s=>({op_name:s.op_name,output_slot:s.output_slot})),consumers:e.consumers.map(s=>s.map(a=>({op_name:a.op_name,input_slot:a.input_slot})))}),o.graphs.loadingOps[r].set(e.op_name,Te.LOADED),o}),ye(VE,n=>({...n,sourceCode:{...n.sourceCode,sourceFileListLoaded:{...n.sourceCode.sourceFileListLoaded,state:Te.LOADING}}})),ye(HE,(n,t)=>{let e={...n,sourceCode:{...n.sourceCode,sourceFileListLoaded:{...n.sourceCode.sourceFileListLoaded,state:Te.LOADED,lastLoadedTimeInMs:Date.now()},sourceFileList:t.sourceFiles,fileContents:n.sourceCode.fileContents.slice()}},i=t.sourceFiles.length,{fileContents:r}=e.sourceCode;for(let o=0;o<i;++o)r[o]=n.sourceCode.fileContents[o]??{loadState:Te.NOT_LOADED,lines:null};return e}),ye(Og,(n,t)=>{let e=kg(n),i={...n,sourceCode:{...n.sourceCode,focusLineSpec:t.stackFrame}};return null!==e&&(i.stickToBottommostFrameInFocusedFile=function(n,t){let e=-1,i=-1;if(n.forEach(({file_path:r,lineno:o},s)=>{r===t.file_path&&(i=s,o===t.lineno&&(e=s))}),-1===e)throw new Error(`Stack frame ${JSON.stringify(t)} is not found.`);return e===i}(e,t.stackFrame)),i}),ye(zE,(n,t)=>{let e={...n,sourceCode:{...n.sourceCode,fileContents:n.sourceCode.fileContents.slice()}},i=uy(e.sourceCode.sourceFileList,t);if(!(i>=0))throw new Error(`Cannot find the following file in file list: host_name="${t.host_name}", file_path="${t.file_path}"`);return e.sourceCode.fileContents.splice(i,1,{...e.sourceCode.fileContents[i],loadState:Te.LOADING}),e}),ye(UE,(n,t)=>{let e={...n,sourceCode:{...n.sourceCode,fileContents:n.sourceCode.fileContents.slice()}},i=uy(e.sourceCode.sourceFileList,t);if(!(i>=0))throw new Error(`Cannot find the following file in file list: host_name="${t.host_name}", file_path="${t.file_path}"`);return e.sourceCode.fileContents.splice(i,1,{loadState:Te.LOADED,lines:t.lines}),e}),ye(cy,(n,t)=>{if(null===n.activeRunId)return n;let i={...n,stackFrames:{...n.stackFrames,...t.stackFrames},sourceCode:{...n.sourceCode}};return i.sourceCode.focusLineSpec=jE(i),i}));function LY(n,t,e,i){let r={...n,graphs:{...n.graphs,focusedOp:{graphId:t,opName:e}},codeLocationFocusType:Lo.GRAPH_OP_CREATION,sourceCode:{...n.sourceCode}};return r.sourceCode.focusLineSpec=jE(r),void 0!==i&&(r.graphExecutions={...n.graphExecutions,focusIndex:i}),r}function BY(n,t){return bMe(n,t)}var Eo=Er(dy),Af=q(Eo,n=>n.runs),lN=q(Eo,n=>n.runsLoaded),Qo=q(Eo,n=>n.activeRunId),VY=q(Eo,n=>n.lastDataPollOnsetTimeMs-n.lastNonEmptyPollDataTimeMs),Fg=q(Eo,n=>n.alerts),cN=q(Fg,n=>n.alertsLoaded),HY=q(Fg,n=>n.numAlerts),GE=q(Fg,n=>n.focusType),zY=q(Fg,n=>null===n.focusType?0:n.alertsBreakdown[n.focusType]||0),UY=q(Fg,n=>null===n.focusType||void 0===n.alerts[n.focusType]?null:n.alerts[n.focusType]),jY=q(Fg,n=>n.alertsBreakdown),Rf=q(Eo,n=>n.executions),WE=q(Rf,n=>n.numExecutionsLoaded),py=q(Rf,n=>n.executionDigestsLoaded),Gu=q(Rf,n=>n.executionDigestsLoaded.numExecutions),fy=q(Rf,n=>n.scrollBeginIndex),Ng=q(Rf,n=>n.pageSize),Lg=q(Rf,n=>n.displayCount),GY=q(Rf,n=>{let t=[];for(let e=n.scrollBeginIndex;e<n.scrollBeginIndex+n.displayCount;++e)t.push(e in n.executionDigests?n.executionDigests[e]:null);return t}),Wu=q(Eo,n=>n.graphExecutions),WY=q(Wu,n=>n.numExecutionsLoaded),my=q(Eo,n=>n.graphExecutions.executionDigestsLoaded.numExecutions),qY=q(Wu,n=>n.scrollBeginIndex),YY=q(Wu,n=>n.displayCount),XY=q(Wu,n=>n.pageSize),QY=q(Wu,n=>n.graphExecutionDataLoadingPages),ZY=q(Wu,n=>n.graphExecutionDataPageLoadedSizes),dN=q(Wu,n=>n.graphExecutionData),uN=q(Wu,n=>n.focusIndex),pN=q(Eo,n=>n.graphs),fN=q(pN,n=>{let{focusedOp:t,ops:e}=n;return null===t||void 0===e[t.graphId]?null:e[t.graphId].get(t.opName)||null}),mN=q(pN,n=>{let{focusedOp:t,ops:e}=n;if(null===t||void 0===e[t.graphId]||!e[t.graphId].has(t.opName))return null;{let i=e[t.graphId],{inputs:r}=i.get(t.opName);return r.map(o=>{let s={...o};return i.has(o.op_name)&&(s.data=i.get(o.op_name)),s})}}),KY=q(uN,dN,mN,(n,t,e)=>{if(null===n||null===e)return null;let i=e.map(a=>!1),r=[];if(0===e.length)return r;let o=t[n].graph_id,s=Math.max(0,n-200);for(let a=n-1;a>=s;--a)if(void 0!==t[a])for(let l=0;l<e.length&&(i[l]||t[a].graph_id!==o||t[a].op_name!==e[l].op_name||t[a].output_slot!==e[l].output_slot||(r.push(a),i[l]=!0,r.length!==e.length));++l);return r}),JY=q(pN,n=>{let{focusedOp:t,ops:e}=n;if(null===t||void 0===e[t.graphId]||!e[t.graphId].has(t.opName))return null;{let i=e[t.graphId],{consumers:r}=i.get(t.opName);return r.map(o=>o.map(s=>{let a={...s};return i.has(s.op_name)&&(a.data=i.get(s.op_name)),a}))}}),$Y=q(Eo,n=>{let t=n.executions.scrollBeginIndex,e=n.executions.scrollBeginIndex+n.executions.displayCount,i=new Array(e-t).fill(null),r=n.alerts.focusType;if(null===r)return i;let o=n.alerts.executionIndices[r];if(void 0===o)return i;for(let s=t;s<e;++s)o.includes(s)&&(i[s-t]=n.alerts.focusType);return i}),qE=q(Eo,n=>n.executions),hN=q(qE,n=>n.focusIndex),eX=q(qE,n=>{if(null===n.focusIndex)return null;let{focusIndex:t,scrollBeginIndex:e,displayCount:i}=n;return t<e||t>=e+i?null:t-e}),gN=q(qE,n=>n.executionData),tX=q(Eo,n=>n.graphs.loadingOps),_N=q(Eo,n=>n.stackFrames),Pf=q(qE,n=>{let{focusIndex:t,executionData:e}=n;return null===t||void 0===e[t]?null:e[t]}),hy=q(Eo,hN,Pf,fN,(n,t,e,i)=>{let{codeLocationFocusType:r}=n;return null===r?null:r===Lo.EXECUTION?null===t||null===e?null:{codeLocationType:Lo.EXECUTION,opType:e.op_type,executionIndex:t}:null===i?null:{codeLocationType:Lo.GRAPH_OP_CREATION,opType:i.op_type,opName:i.op_name}}),nX=q(Eo,kg),YE=q(Eo,n=>n.sourceCode),iX=q(YE,n=>n.sourceFileListLoaded),bN=(q(YE,n=>n.sourceFileList),q(YE,n=>{let{sourceFileList:t,focusLineSpec:e}=n;return null===e?-1:uy(t,e)})),XE=q(YE,bN,(n,t)=>-1===t?null:n.fileContents[t]||null),QE=q(Eo,n=>n.sourceCode.focusLineSpec),rX=q(Eo,n=>n.stickToBottommostFrameInFocusedFile),oX=function(n){return[n]};function yMe(n,t){if(1&n){let e=ge();h(0,"div",7),I("click",function(){let o=X(e).$implicit;return Q(w().onToggleFocusType.emit(o.type))}),h(1,"div",8),T(2),g(),h(3,"div",9),T(4),g(),P(5,"div"),g()}if(2&n){let e=t.$implicit,i=w();_("ngClass",In(4,oX,e.type===i.focusType?"focus":"")),v(2),bt(e.displayName),v(2),lu(" ",e.displaySymbol,": ",e.count," ")}}var sX=(()=>{class n{constructor(){this.numAlerts=0,this.alertsBreakdown=[],this.focusType=null,this.onToggleFocusType=new F}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["alerts-component"]],inputs:{numAlerts:"numAlerts",alertsBreakdown:"alertsBreakdown",focusType:"focusType"},outputs:{onToggleFocusType:"onToggleFocusType"},decls:10,vars:5,consts:[[1,"alerts-container"],[1,"debugging-title"],[1,"num-alerts-container"],[1,"num-alerts-label"],[1,"num-alerts-value",3,"ngClass"],[1,"alerts-breakdown-container"],["class","alerts-breakdown-type",3,"ngClass","click",4,"ngFor","ngForOf"],[1,"alerts-breakdown-type",3,"ngClass","click"],[1,"alert-type-name"],[1,"alert-type-count"]],template:function(e,i){1&e&&(h(0,"div",0)(1,"div",1),T(2,"Debugging"),g(),h(3,"div",2)(4,"div",3),T(5,"Alerts"),g(),h(6,"div",4),T(7),g()(),h(8,"div",5),S(9,yMe,6,6,"div",6),g()()),2&e&&(v(6),_("ngClass",In(3,oX,i.numAlerts>0?"non-zero":"")),v(1),He(" ",i.numAlerts," "),v(2),_("ngForOf",i.alertsBreakdown))},dependencies:[yn,nn],styles:[".alerts-breakdown-container[_ngcontent-%COMP%] {\n  font-size: 13px;\n  padding: 10px 10px 10px;\n  position: relative;\n}\n\n.alerts-breakdown-type[_ngcontent-%COMP%] {\n  border-radius: 0 10px 10px 0;\n  cursor: pointer;\n  display: flex;\n  padding: 6px 0 6px 50px;\n  vertical-align: middle;\n}\n\n.alerts-breakdown-type.focus[_ngcontent-%COMP%] {\n  background-color: #ffeee0;\n}\n\n.alerts-container[_ngcontent-%COMP%] {\n  font-family: 'Roboto', Arial, Helvetica, sans-serif;\n}\n\n.alert-type-count[_ngcontent-%COMP%] {\n  \n  background-color: #e52592;\n  border-radius: 3px;\n  color: #fff;\n  display: inline-block;\n  padding: 3px;\n  position: absolute;\n  right: 20px;\n  vertical-align: middle;\n}\n\n.alert-type-name[_ngcontent-%COMP%] {\n  display: inline-block;\n  padding: 3px;\n  vertical-align: middle;\n}\n\n.debugging-title[_ngcontent-%COMP%] {\n  font-size: 18px;\n}\n\n.num-alerts-container[_ngcontent-%COMP%] {\n  font-weight: bold;\n  padding: 10px 10px 10px 30px;\n  position: relative;\n}\n\n.num-alerts-label[_ngcontent-%COMP%] {\n  display: inline-block;\n  font-size: 13px;\n}\n\n.num-alerts-value[_ngcontent-%COMP%] {\n  border-radius: 12px;\n  display: inline-block;\n  font-size: 13px;\n  font-weight: normal;\n  line-height: 24px;\n  position: absolute;\n  right: 20px;\n  text-align: center;\n  vertical-align: middle;\n  width: 24px;\n}\n\n.num-alerts-value.non-zero[_ngcontent-%COMP%] {\n  background-color: #ffb780;\n  font-weight: bold;\n}"]}),n})(),CMe={[Vc.FUNCTION_RECOMPILE_ALERT]:{displayName:"Function recompiles",displaySymbol:"C"},[Vc.INF_NAN_ALERT]:{displayName:"NaN/\u221e",displaySymbol:"\u221e"},[Vc.TENSOR_SHAPE_ALERT]:{displayName:"Tensor shape",displaySymbol:"\u25a0"}},aX=(()=>{class n{constructor(e){this.store=e,this.numAlerts$=this.store.pipe(un(HY)),this.alertsBreakdown$=this.store.pipe(un(q(jY,i=>{let r=Object.keys(i);return r.sort(),r.map(o=>({type:o,...CMe[o],count:i[o]}))}))),this.focusType$=this.store.pipe(un(GE))}onToggleFocusType(e){this.store.dispatch(Sg({alertType:e}))}}return n.\u0275fac=function(e){return new(e||n)(C(Ae))},n.\u0275cmp=O({type:n,selectors:[["tf-debugger-v2-alerts"]],decls:4,vars:9,consts:[[3,"numAlerts","alertsBreakdown","focusType","onToggleFocusType"]],template:function(e,i){1&e&&(h(0,"alerts-component",0),I("onToggleFocusType",function(o){return i.onToggleFocusType(o)}),j(1,"async"),j(2,"async"),j(3,"async"),g()),2&e&&_("numAlerts",W(1,3,i.numAlerts$))("alertsBreakdown",W(2,5,i.alertsBreakdown$))("focusType",W(3,7,i.focusType$))},dependencies:[sX,ct],encapsulation:2,changeDetection:0}),n})(),gy={19:"float16",1:"float32",2:"float64",3:"int32",4:"uint8",17:"uint16",22:"uint32",23:"uint64",5:"int16",6:"int8",7:"string",8:"complex64",18:"complex128",9:"int64",10:"bool",11:"qint8",12:"quint8",15:"qint16",16:"quint16",13:"qint32",14:"bfloat16",20:"resource",21:"variant",119:"float16_ref",101:"float32_ref",102:"float64_ref",103:"int32_ref",122:"uint32_ref",104:"uint8_ref",117:"uint16_ref",105:"int16_ref",106:"int8_ref",107:"string_ref",108:"complex64_ref",118:"complex128_ref",109:"int64_ref",123:"uint64_ref",110:"bool_ref",111:"qint8_ref",112:"quint8_ref",115:"qint16_ref",116:"quint16_ref",113:"qint32_ref",114:"bfloat16_ref",120:"resource_ref",121:"variant_ref"};function ZE(n){let{tensorDebugMode:t,array:e}=n;switch(t){case So.NO_TENSOR:if(null!==e)throw new Error("Unexpectedly received non-null debug-tensor-value array under NO_TENSOR mode");return{};case So.CURT_HEALTH:if(null===e||2!==e.length)throw new Error(`Under CURT_HEALTH mode, expected debug-tensor-value array to have length 2, but got ${JSON.stringify(e)}`);return{hasInfOrNaN:Boolean(e[1])};case So.CONCISE_HEALTH:{if(null===e||5!==e.length)throw new Error(`Under CONCISE_HEALTH mode, expected debug-tensor-value array to have length 5, but got ${JSON.stringify(e)}`);let i={size:e[1]};return e[2]>0&&(i.numNegativeInfs=e[2]),e[3]>0&&(i.numPositiveInfs=e[3]),e[4]>0&&(i.numNaNs=e[4]),i}case So.SHAPE:{if(null===e||10!==e.length)throw new Error(`Under SHAPE mode, expected debug-tensor-value array to have length 10, but got ${JSON.stringify(e)}`);let i=e[2],r=e.slice(4,Math.min(4+i,e.length));return r.length<i&&(r=new Array(i-r.length).concat(r)),{dtype:gy[e[1]],rank:i,size:e[3],shape:r}}case So.FULL_HEALTH:{if(null===e||11!==e.length)throw new Error(`Under FULL_HEALTH mode, expected debug-tensor-value array to have length 11, but got ${JSON.stringify(e)}`);let r={dtype:gy[e[2]],rank:e[3],size:e[4]};return e[5]>0&&(r.numNegativeInfs=e[5]),e[6]>0&&(r.numPositiveInfs=e[6]),e[7]>0&&(r.numNaNs=e[7]),e[8]>0&&(r.numNegativeFinites=e[8]),e[9]>0&&(r.numZeros=e[9]),e[10]>0&&(r.numPositiveFinites=e[10]),r}case So.FULL_TENSOR:if(null!==e)throw new Error("Unexpectedly received non-null debug-tensor-value array under FULL_TENSOR mode");return{};default:throw new Error(`Unrecognized tensorDebugMode: ${t}`)}}var vN="[_nghost-%COMP%] {\n    background-color: #e3e5e8;\n    border: 1px solid #c0c0c0;\n    border-radius: 4px;\n    font-family: 'Roboto Mono', monospace;\n    height: 14px;\n    line-height: 14px;\n    margin: 0 2px;\n    padding: 1px 3px;\n    width: max-content;\n  }";function wMe(n,t){1&n&&P(0,"div",4)}function SMe(n,t){if(1&n&&(h(0,"div",7)(1,"span",8),T(2,"NaN"),g(),h(3,"span",9),T(4),g()()),2&n){let e=w(2);v(4),He("\xd7",e.numNaNs,"")}}function EMe(n,t){if(1&n&&(h(0,"div",7)(1,"span",8),T(2,"-\u221e"),g(),h(3,"span",9),T(4),g()()),2&n){let e=w(2);v(4),He("\xd7",e.numNegativeInfs,"")}}function TMe(n,t){if(1&n&&(h(0,"div",7)(1,"span",8),T(2,"+\u221e"),g(),h(3,"span",9),T(4),g()()),2&n){let e=w(2);v(4),He("\xd7",e.numPositiveInfs,"")}}function DMe(n,t){if(1&n&&(h(0,"div",7)(1,"span",10),T(2,"-"),g(),h(3,"span",9),T(4),g()()),2&n){let e=w(2);v(4),He("\xd7",e.numNegativeFinites,"")}}function IMe(n,t){if(1&n&&(h(0,"div",7)(1,"span",10),T(2,"0"),g(),h(3,"span",9),T(4),g()()),2&n){let e=w(2);v(4),He("\xd7",e.numZeros,"")}}function AMe(n,t){if(1&n&&(h(0,"div",7)(1,"span",10),T(2,"+"),g(),h(3,"span",9),T(4),g()()),2&n){let e=w(2);v(4),He("\xd7",e.numPositiveFinites,"")}}function RMe(n,t){if(1&n&&(h(0,"div",5),S(1,SMe,5,1,"div",6),S(2,EMe,5,1,"div",6),S(3,TMe,5,1,"div",6),S(4,DMe,5,1,"div",6),S(5,IMe,5,1,"div",6),S(6,AMe,5,1,"div",6),g()),2&n){let e=w();v(1),_("ngIf",void 0!==e.numNaNs&&e.numNaNs>0),v(1),_("ngIf",void 0!==e.numNegativeInfs&&e.numNegativeInfs>0),v(1),_("ngIf",void 0!==e.numPositiveInfs&&e.numPositiveInfs>0),v(1),_("ngIf",void 0!==e.numNegativeFinites&&e.numNegativeFinites>0),v(1),_("ngIf",void 0!==e.numZeros&&e.numZeros>0),v(1),_("ngIf",void 0!==e.numPositiveFinites&&e.numPositiveFinites>0)}}var PMe=function(n){return["container",n]};function OMe(n,t){1&n&&P(0,"debug-tensor-dtype",5),2&n&&_("dtype",w().debugTensorValue.dtype)}function kMe(n,t){1&n&&P(0,"debug-tensor-rank",6),2&n&&_("rank",w().debugTensorValue.rank)}function FMe(n,t){1&n&&P(0,"debug-tensor-shape",7),2&n&&_("shape",w().debugTensorValue.shape)}function NMe(n,t){1&n&&P(0,"debug-tensor-has-inf-or-nan",8),2&n&&_("hasInfOrNaN",w().debugTensorValue.hasInfOrNaN)}function LMe(n,t){if(1&n&&P(0,"debug-tensor-numeric-breakdown",9),2&n){let e=w();Wi("size",e.debugTensorValue.size),_("numNegativeInfs",e.debugTensorValue.numNegativeInfs)("numPositiveInfs",e.debugTensorValue.numPositiveInfs)("numNaNs",e.debugTensorValue.numNaNs)("numNegativeFinites",e.debugTensorValue.numNegativeFinites)("numZeros",e.debugTensorValue.numZeros)("numPositiveFinites",e.debugTensorValue.numPositiveFinites)}}var BMe=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["debug-tensor-dtype"]],inputs:{dtype:"dtype"},decls:1,vars:1,template:function(e,i){1&e&&T(0),2&e&&He(" ",i.dtype," ")},styles:[vN]}),n})(),VMe=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["debug-tensor-rank"]],inputs:{rank:"rank"},decls:1,vars:1,template:function(e,i){1&e&&T(0),2&e&&He(" ",i.rank,"D ")},styles:[vN]}),n})(),HMe=(()=>{class n{get shapeString(){return"["+this.shape.map(e=>void 0===e?"?":String(e)).join(",")+"]"}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["debug-tensor-shape"]],inputs:{shape:"shape"},decls:1,vars:1,template:function(e,i){1&e&&T(0),2&e&&He(" shape:",i.shapeString," ")},styles:[vN]}),n})(),zMe=(()=>{class n{get breakdownExists(){return void 0!==this.numNaNs||void 0!==this.numNegativeInfs||void 0!==this.numPositiveInfs||void 0!==this.numNegativeFinites||void 0!==this.numZeros||void 0!==this.numPositiveFinites}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["debug-tensor-numeric-breakdown"]],inputs:{size:"size",numNaNs:"numNaNs",numNegativeInfs:"numNegativeInfs",numPositiveInfs:"numPositiveInfs",numNegativeFinites:"numNegativeFinites",numZeros:"numZeros",numPositiveFinites:"numPositiveFinites"},decls:7,vars:3,consts:[[1,"size"],[1,"size-value"],["class","break",4,"ngIf"],["class","breakdown",4,"ngIf"],[1,"break"],[1,"breakdown"],["class","category",4,"ngIf"],[1,"category"],[1,"category-tag","infinite"],[1,"category-count"],[1,"category-tag","finite"]],template:function(e,i){1&e&&(h(0,"div",0)(1,"span"),T(2,"size:"),g(),h(3,"span",1),T(4),g()(),S(5,wMe,1,0,"div",2),S(6,RMe,7,6,"div",3)),2&e&&(v(4),bt(i.size),v(1),_("ngIf",i.breakdownExists),v(1),_("ngIf",i.breakdownExists))},dependencies:[Fe],styles:["[_nghost-%COMP%] {\n        background-color: #e3e5e8;\n        border: 1px solid #c0c0c0;\n        border-radius: 4px;\n        font-family: 'Roboto Mono', monospace;\n        font-size: 10px;\n        margin: 0 2px;\n        padding: 1px;\n      }\n      .break[_ngcontent-%COMP%] {\n        flex-basis: 100%;\n        width: 0;\n      }\n      .size[_ngcontent-%COMP%] {\n        display: block;\n        height: 11px;\n        line-height: 11px;\n        margin: 0 3px;\n        vertical-align: middle;\n      }\n      .breakdown[_ngcontent-%COMP%] {\n        border-top: 1px solid rgba(0, 0, 0, 0.12);\n        display: flex;\n        height: 11px;\n        line-height: 11px;\n        padding: 2px;\n        vertical-align: middle;\n      }\n      .category[_ngcontent-%COMP%] {\n        margin-bottom: 2px;\n        margin-left: 4px;\n        margin-top: 2px;\n        heigth: 100%;\n        width: max-content;\n      }\n      .category-tag[_ngcontent-%COMP%] {\n        border-radius: 2px;\n        padding: 0 2px;\n      }\n      .finite[_ngcontent-%COMP%] {\n        background-color: #aaa;\n        color: #fefefe;\n      }\n      .infinite[_ngcontent-%COMP%] {\n        background-color: #e52592;\n        color: #fff;\n      }"]}),n})(),UMe=(()=>{class n{get infoString(){return this.hasInfOrNaN?"Has \u221e/NaN":"No \u221e/NaN"}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["debug-tensor-has-inf-or-nan"]],inputs:{hasInfOrNaN:"hasInfOrNaN"},decls:2,vars:4,consts:[[3,"ngClass"]],template:function(e,i){1&e&&(h(0,"div",0),T(1),g()),2&e&&(_("ngClass",In(2,PMe,i.hasInfOrNaN?"has-inf-or-nan":"")),v(1),He(" ",i.infoString," "))},dependencies:[yn],styles:[".container[_ngcontent-%COMP%] {\n        background-color: #e3e5e8;\n        border: 1px solid #c0c0c0;\n        border-radius: 4px;\n        color: #666666;\n        font-family: 'Roboto Mono', monospace;\n        height: 14px;\n        line-height: 14px;\n        margin: 0 2px;\n        padding: 1px 3px;\n        width: max-content;\n      }\n      .has-inf-or-nan[_ngcontent-%COMP%] {\n        background-color: #e52592;\n        color: #fff;\n      }"]}),n})(),KE=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["debug-tensor-value"]],inputs:{debugTensorValue:"debugTensorValue"},decls:5,vars:5,consts:[[3,"dtype",4,"ngIf"],[3,"rank",4,"ngIf"],[3,"shape",4,"ngIf"],[3,"hasInfOrNaN",4,"ngIf"],[3,"size","numNegativeInfs","numPositiveInfs","numNaNs","numNegativeFinites","numZeros","numPositiveFinites",4,"ngIf"],[3,"dtype"],[3,"rank"],[3,"shape"],[3,"hasInfOrNaN"],[3,"size","numNegativeInfs","numPositiveInfs","numNaNs","numNegativeFinites","numZeros","numPositiveFinites"]],template:function(e,i){1&e&&(S(0,OMe,1,1,"debug-tensor-dtype",0),S(1,kMe,1,1,"debug-tensor-rank",1),S(2,FMe,1,1,"debug-tensor-shape",2),S(3,NMe,1,1,"debug-tensor-has-inf-or-nan",3),S(4,LMe,1,7,"debug-tensor-numeric-breakdown",4)),2&e&&(_("ngIf",void 0!==i.debugTensorValue.dtype),v(1),_("ngIf",void 0!==i.debugTensorValue.rank),v(1),_("ngIf",void 0!==i.debugTensorValue.shape),v(1),_("ngIf",void 0!==i.debugTensorValue.hasInfOrNaN),v(1),_("ngIf",void 0!==i.debugTensorValue.size))},dependencies:[Fe,BMe,UMe,zMe,VMe,HMe],styles:["[_nghost-%COMP%] {\n        align-items: flex-start;\n        display: flex;\n        flex-wrap: nowrap;\n        overflow: hidden;\n        vertical-align: top;\n      }\n      debug-tensor-numeric-breakdown[_ngcontent-%COMP%] {\n        display: inline-block;\n      }"]}),n})();function jMe(n,t){1&n&&(h(0,"div",12),T(1,"\u25b6"),g())}var GMe=function(n,t){return{tensorDebugMode:n,array:t}};function WMe(n,t){if(1&n&&P(0,"debug-tensor-value",17),2&n){let e=w(2).$implicit,i=w(2);_("debugTensorValue",i.parseDebugTensorValue(qr(1,GMe,i.graphExecutionData[e].tensor_debug_mode,i.graphExecutionData[e].debug_tensor_value)))}}function qMe(n,t){if(1&n){let e=ge();h(0,"div")(1,"div",13)(2,"button",14),I("click",function(){X(e);let r=w().$implicit,o=w(2);return Q(o.onTensorNameClick.emit({index:r,graph_id:o.graphExecutionData[r].graph_id,op_name:o.graphExecutionData[r].op_name}))}),T(3),g(),h(4,"div",15),T(5),g()(),S(6,WMe,1,4,"debug-tensor-value",16),g()}if(2&n){let e=w().$implicit,i=w(2);v(2),Wi("title",i.getTensorName(e)),v(1),He(" ",i.getTensorName(e)," "),v(2),bt(i.graphExecutionData[e].op_type),v(1),_("ngIf",null!==i.graphExecutionData[e].debug_tensor_value)}}function YMe(n,t){1&n&&(h(0,"div",18),T(1," Loading... "),g())}var XMe=function(n){return{"input-of-focus":n}};function QMe(n,t){if(1&n&&(h(0,"div",5)(1,"div",6)(2,"div",7),S(3,jMe,2,0,"div",8),T(4),g(),S(5,qMe,7,4,"div",9),S(6,YMe,2,0,"ng-template",10,11,Wt),g()()),2&n){let e=t.$implicit,i=it(7),r=w(2);v(1),_("ngClass",In(5,XMe,r.isInputOfFocus(e))),v(2),_("ngIf",e===r.focusIndex),v(1),He(" ",e," "),v(1),_("ngIf",r.graphExecutionData[e])("ngIfElse",i)}}function ZMe(n,t){if(1&n){let e=ge();h(0,"cdk-virtual-scroll-viewport",3),I("scrolledIndexChange",function(r){return X(e),Q(w().onScrolledIndexChange.emit(r))}),S(1,QMe,8,7,"div",4),g()}if(2&n){let e=w();v(1),_("cdkVirtualForOf",e.graphExecutionIndices)}}var cX=(()=>{class n{constructor(){this.onScrolledIndexChange=new F,this.onTensorNameClick=new F,this.parseDebugTensorValue=ZE,this.TEST_ONLY={getViewPort:()=>this.viewPort}}ngOnChanges(e){if(this.viewPort&&e.focusIndex&&null!==e.focusIndex.currentValue){let i=this.viewPort.getRenderedRange(),r=e.focusIndex.currentValue,o=Math.round((i.end-i.start)/3),s=Math.max(r-o,0);this.viewPort.scrollToIndex(s,r>=i.start&&r<i.end?"smooth":void 0)}}getTensorName(e){return`${this.graphExecutionData[e].op_name}:${this.graphExecutionData[e].output_slot}`}isInputOfFocus(e){return null!==this.focusInputIndices&&this.focusInputIndices.includes(e)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["graph-executions-component"]],viewQuery:function(e,i){if(1&e&&Ge(ug,5),2&e){let r;Se(r=Ee())&&(i.viewPort=r.first)}},inputs:{numGraphExecutions:"numGraphExecutions",graphExecutionData:"graphExecutionData",graphExecutionIndices:"graphExecutionIndices",focusIndex:"focusIndex",focusInputIndices:"focusInputIndices"},outputs:{onScrolledIndexChange:"onScrolledIndexChange",onTensorNameClick:"onTensorNameClick"},features:[Gt],decls:4,vars:2,consts:[[1,"graph-executions-container"],[1,"graph-executions-title"],["itemSize","38","class","graph-executions-viewport",3,"scrolledIndexChange",4,"ngIf"],["itemSize","38",1,"graph-executions-viewport",3,"scrolledIndexChange"],["class","tensor-container",4,"cdkVirtualFor","cdkVirtualForOf"],[1,"tensor-container"],[1,"tensor-item",3,"ngClass"],[1,"graph-execution-index"],["class","graph-execution-focus",4,"ngIf"],[4,"ngIf","ngIfElse"],["class","tensor-item"],["dataLoading",""],[1,"graph-execution-focus"],[1,"tensor-name-and-op-type"],[1,"tensor-name",3,"title","click"],[1,"op-type"],[3,"debugTensorValue",4,"ngIf"],[3,"debugTensorValue"],[1,"loading-spinner"]],template:function(e,i){1&e&&(h(0,"div",0)(1,"div",1),T(2),g(),S(3,ZMe,2,1,"cdk-virtual-scroll-viewport",2),g()),2&e&&(v(2),He(" Graph Executions (",i.numGraphExecutions,") "),v(1),_("ngIf",null!==i.numGraphExecutions&&i.numGraphExecutions>0))},dependencies:[yn,Fe,KE,V7,H7,ug],styles:['.graph-executions-container[_ngcontent-%COMP%]{border-left:1px solid #ebebeb;display:flex;flex-direction:column;height:100%;margin-left:8px;padding-left:10px}body.dark-mode[_nghost-%COMP%]   .graph-executions-container[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .graph-executions-container[_ngcontent-%COMP%]{border-left:1px solid #555}.graph-execution-focus[_ngcontent-%COMP%]{display:inline-block}.graph-execution-index[_ngcontent-%COMP%]{color:#616161;display:inline-block;padding-right:4px;text-align:right;width:40px}body.dark-mode[_nghost-%COMP%]   .graph-execution-index[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .graph-execution-index[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}.graph-executions-title[_ngcontent-%COMP%]{box-shadow:0 5px 3px -3px #ccc;padding-bottom:5px}.graph-executions-viewport[_ngcontent-%COMP%]{flex-grow:1;font-size:12px;width:100%;overflow-x:hidden}.input-of-focus[_ngcontent-%COMP%]{background-color:#fff099}body.dark-mode[_nghost-%COMP%]   .input-of-focus[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .input-of-focus[_ngcontent-%COMP%]{background-color:#e65100}.loading-spinner[_ngcontent-%COMP%]{display:inline-block}.op-type[_ngcontent-%COMP%]{background-color:#eceff1;border:1px solid #ebebeb;border-radius:4px;font-family:"Roboto Mono",monospace;font-size:10px;height:14px;line-height:14px;padding:1px 3px;width:max-content;direction:rtl;display:block}body.dark-mode[_nghost-%COMP%]   .op-type[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .op-type[_ngcontent-%COMP%]{border:1px solid #555}body.dark-mode[_nghost-%COMP%]   .op-type[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .op-type[_ngcontent-%COMP%]{background-color:#455a64}.tensor-container[_ngcontent-%COMP%]{width:100%}.tensor-item[_ngcontent-%COMP%]{border-bottom:1px solid #ebebeb;display:flex;flex-wrap:nowrap;height:38px;line-height:38px;text-align:left;vertical-align:middle;white-space:nowrap;width:100%}body.dark-mode[_nghost-%COMP%]   .tensor-item[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .tensor-item[_ngcontent-%COMP%]{border-bottom:1px solid #555}.tensor-name[_ngcontent-%COMP%]{background-color:rgba(0,0,0,0);border:none;box-sizing:border-box;color:inherit;cursor:pointer;direction:rtl;display:block;height:16px;line-height:16px;margin:2px 0 1px;max-width:calc(100% - 2px);overflow:hidden;padding:0 2px;text-align:right;text-decoration:underline;text-overflow:ellipsis;white-space:nowrap}.tensor-name[_ngcontent-%COMP%]:focus{outline:1px solid #c6cad1}.tensor-name-and-op-type[_ngcontent-%COMP%]{direction:rtl;display:inline-block;overflow:hidden;padding-right:8px;text-align:right;width:240px}debug-tensor-value[_ngcontent-%COMP%]{display:inline-block;margin:2px 0}'],changeDetection:0}),n})(),dX=(()=>{class n{onScrolledIndexChange(e){this.store.dispatch(Ag({index:e}))}onTensorNameClick(e){this.store.dispatch(Rg(e))}constructor(e){this.store=e,this.numGraphExecutions$=this.store.pipe(un(my)),this.graphExecutionData$=this.store.pipe(un(dN)),this.graphExecutionIndices$=this.store.pipe(un(q(my,i=>0===i?null:Array.from({length:i}).map((r,o)=>o)))),this.focusIndex$=this.store.pipe(un(uN)),this.focusInputIndices$=this.store.pipe(un(KY))}}return n.\u0275fac=function(e){return new(e||n)(C(Ae))},n.\u0275cmp=O({type:n,selectors:[["tf-debugger-v2-graph-executions"]],decls:6,vars:15,consts:[[3,"numGraphExecutions","graphExecutionData","graphExecutionIndices","focusIndex","focusInputIndices","onScrolledIndexChange","onTensorNameClick"]],template:function(e,i){1&e&&(h(0,"graph-executions-component",0),I("onScrolledIndexChange",function(o){return i.onScrolledIndexChange(o)})("onTensorNameClick",function(o){return i.onTensorNameClick(o)}),j(1,"async"),j(2,"async"),j(3,"async"),j(4,"async"),j(5,"async"),g()),2&e&&_("numGraphExecutions",W(1,5,i.numGraphExecutions$))("graphExecutionData",W(2,7,i.graphExecutionData$))("graphExecutionIndices",W(3,9,i.graphExecutionIndices$))("focusIndex",W(4,11,i.focusIndex$))("focusInputIndices",W(5,13,i.focusInputIndices$))},dependencies:[cX,ct],encapsulation:2}),n})();function $Me(n,t){1&n&&(h(0,"span"),T(1," Output "),g())}function ewe(n,t){1&n&&(h(0,"span"),T(1," Input "),g())}function twe(n,t){if(1&n&&(h(0,"div",6)(1,"span",7),S(2,$Me,2,0,"span",8),S(3,ewe,2,0,"span",8),g(),T(4),g()),2&n){let e=w();v(1),_("ngSwitch",e.kind),v(1),_("ngSwitchCase","input"),v(1),_("ngSwitchCase","consumer"),v(1),He(" slot: ",e.slot," ")}}function nwe(n,t){if(1&n&&(h(0,"div",9),T(1),g()),2&n){let e=w();v(1),He(" ",e.opData.op_type," ")}}function iwe(n,t){1&n&&(h(0,"span",10),T(1," (Op info unavailable.) "),g())}var rwe=function(n){return[n]},uX=(()=>{class n{constructor(){this.onOpNameClick=new F}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["graph-op"]],inputs:{kind:"kind",opName:"opName",slot:"slot",opData:"opData"},outputs:{onOpNameClick:"onOpNameClick"},decls:9,vars:7,consts:[[1,"op-container"],[1,"input-tensor-name"],[1,"op-name",3,"ngClass","click"],["class","slot",4,"ngIf"],["class","op-type",4,"ngIf","ngIfElse"],["opInfoMissing",""],[1,"slot"],[3,"ngSwitch"],[4,"ngSwitchCase"],[1,"op-type"],[1,"op-info-missing"]],template:function(e,i){if(1&e&&(h(0,"button",0)(1,"div",1)(2,"button",2),I("click",function(){return i.onOpNameClick.emit({op_name:i.opName})}),h(3,"span"),T(4),g()(),S(5,twe,5,4,"div",3),g(),S(6,nwe,2,1,"div",4),S(7,iwe,2,0,"ng-template",null,5,Wt),g()),2&e){let r=it(8);v(2),_("ngClass",In(5,rwe,"self"===i.kind?"self-op-name":"")),v(2),bt(i.opName),v(1),_("ngIf","self"!==i.kind),v(1),_("ngIf",void 0!==i.opData)("ngIfElse",r)}},dependencies:[yn,Fe,sr,Sr],styles:['.op-container[_ngcontent-%COMP%], .op-name[_ngcontent-%COMP%]{color:inherit;background-color:inherit}.op-container[_ngcontent-%COMP%]{border:2px solid #ebebeb;border-radius:4px;box-shadow:1px 3px #eee;cursor:pointer;margin:0 5px 0 0;padding:2px 6px;text-align:right;width:200px}body.dark-mode[_nghost-%COMP%]   .op-container[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .op-container[_ngcontent-%COMP%]{border:2px solid #555}body.dark-mode[_nghost-%COMP%]   .op-container[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .op-container[_ngcontent-%COMP%]{box-shadow:1px 3px #757575}.op-container[_ngcontent-%COMP%]:focus{outline:0}.op-container[_ngcontent-%COMP%]:hover{border:2px solid #ffd3b2}.op-info-missing[_ngcontent-%COMP%]{color:gray}.op-name[_ngcontent-%COMP%]{border:none;cursor:pointer;display:inline-block;overflow-wrap:anywhere;padding:0;text-align:right;text-decoration:underline;white-space:pre-wrap}.op-name[_ngcontent-%COMP%]:focus{outline:0}.op-type[_ngcontent-%COMP%]{background-color:#eceff1;border:1px solid #ebebeb;border-radius:4px;font-family:"Roboto Mono",monospace;font-size:10px;height:14px;line-height:14px;padding:1px 3px;width:max-content;display:inline-block;margin-top:3px}body.dark-mode[_nghost-%COMP%]   .op-type[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .op-type[_ngcontent-%COMP%]{border:1px solid #555}body.dark-mode[_nghost-%COMP%]   .op-type[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .op-type[_ngcontent-%COMP%]{background-color:#455a64}.self-op-name[_ngcontent-%COMP%]{font-weight:bold;text-decoration:none}.slot[_ngcontent-%COMP%]{color:#616161}body.dark-mode[_nghost-%COMP%]   .slot[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .slot[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}']}),n})();function swe(n,t){if(1&n){let e=ge();h(0,"div",13)(1,"div",14),T(2),g(),h(3,"graph-op",15),I("onOpNameClick",function(r){X(e);let o=w(3);return Q(o.onGraphOpNavigate.emit({op_name:r.op_name,graph_id:o.graphId}))}),g()()}if(2&n){let e=t.$implicit,i=t.index;v(2),He("Input slot ",i,":"),v(1),_("kind","input")("opName",e.op_name)("slot",e.output_slot)("opData",e.data)}}function awe(n,t){if(1&n&&(h(0,"div",11)(1,"div"),S(2,swe,4,5,"div",12),g()()),2&n){let e=w(2);v(2),_("ngForOf",e.inputOps)}}function lwe(n,t){1&n&&(h(0,"div",16),T(1," (This op has no input tensor.) "),g())}function cwe(n,t){if(1&n){let e=ge();h(0,"div",23)(1,"graph-op",15),I("onOpNameClick",function(r){X(e);let o=w(4);return Q(o.onGraphOpNavigate.emit({op_name:r.op_name,graph_id:o.graphId}))}),g()()}if(2&n){let e=t.$implicit;v(1),_("kind","consumer")("opName",e.op_name)("slot",e.input_slot)("opData",e.data)}}function dwe(n,t){if(1&n&&(h(0,"div",19)(1,"div",20),T(2),h(3,"span"),qM(4,21),g(),T(5,") "),g(),S(6,cwe,2,4,"div",22),g()),2&n){let e=t.$implicit,i=t.index;v(2),lu(" Output slot ",i,": (",e.length," "),v(2),hb(e.length),YM(4),v(2),_("ngForOf",e)}}function uwe(n,t){if(1&n&&(h(0,"div",17)(1,"div"),S(2,dwe,7,4,"div",18),g()()),2&n){let e=w(2);v(2),_("ngForOf",e.consumerOps)}}function pwe(n,t){if(1&n&&(h(0,"div",24),T(1),h(2,"span"),qM(3,25),g(),T(4," and no consumer.) "),g()),2&n){let e=w(2);v(1),He(" (This op has ",e.opInfo.consumers.length," output "),v(2),hb(e.opInfo.consumers.length),YM(3)}}function fwe(n,t){if(1&n){let e=ge();h(0,"div"),S(1,awe,3,1,"div",4),S(2,lwe,2,0,"ng-template",null,5,Wt),h(4,"div",6)(5,"div",7),T(6,"Op:"),g(),h(7,"graph-op",8),I("onOpNameClick",function(r){X(e);let o=w();return Q(o.onGraphOpNavigate.emit({op_name:r.op_name,graph_id:o.graphId}))}),g()(),S(8,uwe,3,1,"div",9),S(9,pwe,5,2,"ng-template",null,10,Wt),g()}if(2&n){let e=it(3),i=it(10),r=w();v(1),_("ngIf",r.inputOps.length>0)("ngIfElse",e),v(6),_("kind","self")("opName",r.opInfo.op_name)("opData",r.opInfo),v(1),_("ngIf",r.totalNumConsumers>0)("ngIfElse",i)}}function mwe(n,t){1&n&&(h(0,"span",26),T(1," (Op info unavailable.) "),g())}function hwe(n,t){1&n&&(h(0,"div",27),T(1," No graph op selected. Click a tensor name in the Graph Executions table to view the neighborhood of the tensor's op in its graph. "),g())}var pX=(()=>{class n{constructor(){this.onGraphOpNavigate=new F}get graphId(){return this.opInfo.graph_ids[this.opInfo.graph_ids.length-1]}get totalNumConsumers(){return this.consumerOps.reduce((e,i)=>e+i.length,0)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["graph-component"]],inputs:{opInfo:"opInfo",inputOps:"inputOps",consumerOps:"consumerOps"},outputs:{onGraphOpNavigate:"onGraphOpNavigate"},decls:9,vars:2,consts:function(){let t,e,i,r;return t=$localize`:␟fe55f9b193ea20aae5b5635e68d9386503847746␟4955133740841299851:{VAR_PLURAL, plural, =0 {consumer} =1 {consumer} other {consumers}}`,t=XM(t,{VAR_PLURAL:"\ufffd0\ufffd"}),e=$localize`:␟baa460e2f2b857e26292b246fc18ae0ea9b5e537␟5556340343850165516: ${t}:ICU:`,i=$localize`:␟6aa75f627e0dc16150ef448464e0c857aaa0dc18␟5156712935150586878:{VAR_PLURAL, plural, =0 {tensor} =1 {tensor} other {tensors}}`,i=XM(i,{VAR_PLURAL:"\ufffd0\ufffd"}),r=$localize`:␟893476c2c421cee47663c9732fa41a750d3a73df␟246067053735162634: ${i}:ICU:`,[[1,"graph-structure-container"],[4,"ngIf","ngIfElse"],["opInfoMissing",""],["noOpFocused",""],["class","inputs-container",4,"ngIf","ngIfElse"],["noInputs",""],[1,"self-op-container"],[1,"self-op-header"],[3,"kind","opName","opData","onOpNameClick"],["class","consumers-container",4,"ngIf","ngIfElse"],["noConsumers",""],[1,"inputs-container"],["class","input-op-section",4,"ngFor","ngForOf"],[1,"input-op-section"],[1,"input-slot-header"],[3,"kind","opName","slot","opData","onOpNameClick"],[1,"inputs-container","no-inputs-indicator"],[1,"consumers-container"],["class","slot-consumers-container",4,"ngFor","ngForOf"],[1,"slot-consumers-container"],[1,"slot-consumers-header"],e,["class","consumer-section",4,"ngFor","ngForOf"],[1,"consumer-section"],[1,"op-consumers-container"],r,[1,"op-info-missing"],[1,"no-op-focused"]]},template:function(e,i){if(1&e&&(h(0,"div")(1,"div"),T(2,"Graph Structure"),g(),h(3,"div",0),S(4,fwe,11,7,"div",1),g(),S(5,mwe,2,0,"ng-template",null,2,Wt),S(7,hwe,2,0,"ng-template",null,3,Wt),g()),2&e){let r=it(8);v(4),_("ngIf",null!=i.opInfo)("ngIfElse",r)}},dependencies:[nn,Fe,uX],styles:['[_nghost-%COMP%]{overflow-y:auto}.consumers-container[_ngcontent-%COMP%]{padding-bottom:5px;overflow-x:auto;white-space:nowrap}.consumer-section[_ngcontent-%COMP%]{display:block;margin:5px 0}.graph-structure-container[_ngcontent-%COMP%]{font-size:12px;overflow-y:auto;white-space:nowrap}.inputs-container[_ngcontent-%COMP%]{border-bottom:1px solid rgba(0,0,0,.12);margin-top:5px;overflow-x:auto;padding-bottom:0;white-space:nowrap}.input-op-section[_ngcontent-%COMP%]{border-right:1px solid rgba(0,0,0,.12);display:inline-block;margin-right:5px;padding-bottom:5px}.input-slot-header[_ngcontent-%COMP%]{background-color:#fff099;margin-bottom:5px}body.dark-mode[_nghost-%COMP%]   .input-slot-header[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .input-slot-header[_ngcontent-%COMP%]{background-color:#e65100}.input-tensor-name[_ngcontent-%COMP%]{display:block;white-space:nowrap}.no-op-focused[_ngcontent-%COMP%]{color:gray;font-family:"Roboto",Arial,Helvetica,sans-serif;font-size:13px;white-space:normal}.self-op-header[_ngcontent-%COMP%]{font-weight:bold;margin-bottom:5px}.self-op-container[_ngcontent-%COMP%]{border-bottom:1px solid rgba(0,0,0,.12);padding-bottom:5px}.slot-consumers-container[_ngcontent-%COMP%]{border-right:1px solid rgba(0,0,0,.12);display:inline-block;margin-right:5px;padding-top:5px;vertical-align:top}.slot-consumers-header[_ngcontent-%COMP%]{white-space:nowrap}'],changeDetection:0}),n})(),fX=(()=>{class n{onGraphOpNavigate(e){this.store.dispatch(Pg(e))}constructor(e){this.store=e,this.opInfo$=this.store.pipe(un(fN)),this.inputOps$=this.store.pipe(un(mN)),this.consumerOps$=this.store.pipe(un(JY))}}return n.\u0275fac=function(e){return new(e||n)(C(Ae))},n.\u0275cmp=O({type:n,selectors:[["tf-debugger-v2-graph"]],decls:4,vars:9,consts:[[3,"opInfo","inputOps","consumerOps","onGraphOpNavigate"]],template:function(e,i){1&e&&(h(0,"graph-component",0),I("onGraphOpNavigate",function(o){return i.onGraphOpNavigate(o)}),j(1,"async"),j(2,"async"),j(3,"async"),g()),2&e&&_("opInfo",W(1,3,i.opInfo$))("inputOps",W(2,5,i.inputOps$))("consumerOps",W(3,7,i.consumerOps$))},dependencies:[pX,ct],encapsulation:2}),n})(),mX=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["inactive-component"]],decls:54,vars:0,consts:[[1,"container"],[1,"title"],[1,"code"],[1,"arg"],[1,"exhibits-container"],[1,"exhibit"],[1,"screenshot"],["src","data:image/png;base64,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"],[1,"description"],["src","data:image/png;base64,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"],["src","data:image/png;base64,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"],[1,"details-container"],[1,"details"],["href","https://www.tensorflow.org/api_docs/python/tf/debugging/experimental/enable_dump_debug_info","target","blank","rel","noreferrer noopener"],["href","https://www.tensorflow.org/api_docs/python/tf/debugging","target","blank","rel","noreferrer noopener"]],template:function(e,i){1&e&&(h(0,"div",0)(1,"div",1),T(2,"Debugger V2 is inactive because no data is available."),g(),h(3,"div"),T(4,"To use the debugger,"),g(),h(5,"div")(6,"ol")(7,"li"),T(8," Add the following line to the beginning of your program: "),h(9,"div",2)(10,"span"),T(11,"tf.debugging.experimental.enable_dump_debug_info("),g(),h(12,"span",3),T(13,"logdir"),g(),T(14,", "),h(15,"span",3),T(16,'tensor_debug_mode="FULL_HEALTH"'),g(),T(17,", "),h(18,"span",3),T(19,"circular_buffer_size=-1"),g(),h(20,"span"),T(21,")"),g()()(),h(22,"li"),T(23,"Re-run the program."),g()()(),h(24,"div",4)(25,"div",5)(26,"div",6),P(27,"img",7),g(),h(28,"div",8),T(29,"Auto-alerts for problems found"),g()(),h(30,"div",5)(31,"div",6),P(32,"img",9),g(),h(33,"div",8),T(34," Integrated debugging to trace problems to their causes "),g()(),h(35,"div",5)(36,"div",6),P(37,"img",10),g(),h(38,"div",8),T(39,"Link log to code"),g()()(),h(40,"div",11)(41,"div",12),T(42," The log directory must contain TensorFlow Debugger (V2) data. tf.debugging.experimental.enable_dump_debug_info() will collect tensor data, graph structures, the associated stack traces, and source code to the specificed directory logdir as the instrumented TensorFlow program executes. "),g(),h(43,"div",12)(44,"div"),T(45," See "),h(46,"a",13),T(47," documentation "),g(),T(48," of the Python API of Debugger V2. "),g(),h(49,"div"),T(50," See "),h(51,"a",14),T(52," here "),g(),T(53," for other TensorFlow debugging APIs. "),g()()()())},styles:[".arg[_ngcontent-%COMP%] {\n  color: lightblue;\n  font-style: italic;\n  margin: 2px;\n}\n\n.code[_ngcontent-%COMP%] {\n  font-family: 'Roboto Mono', monospace;\n  margin: 10px;\n}\n\n.container[_ngcontent-%COMP%] {\n  height: 100%;\n  font-family: Roboto;\n  font-size: 15px;\n  overflow-y: auto;\n  padding: 50px;\n}\n\n.details-container[_ngcontent-%COMP%] {\n  display: inline-flex;\n  vertical-align: middle;\n  width: 100%;\n}\n\n.details[_ngcontent-%COMP%] {\n  display: inline-block;\n  margin: 10px 60px;\n  width: 50%;\n}\n\n.exhibit-container[_ngcontent-%COMP%] {\n  white-space: nowrap;\n  width: 100%;\n}\n\n.exhibit[_ngcontent-%COMP%] {\n  align-content: center;\n  display: inline-block;\n  margin: 10px 60px;\n  vertical-align: top;\n  width: 310px;\n}\n\n.exhibit[_ngcontent-%COMP%]   .description[_ngcontent-%COMP%] {\n  font-weight: bold;\n  text-align: center;\n  width: 310px;\n}\n\n.exhibit[_ngcontent-%COMP%]   .screenshot[_ngcontent-%COMP%]   canvas[_ngcontent-%COMP%] {\n  height: 200px;\n  width: 100%;\n}\n\n.title[_ngcontent-%COMP%] {\n  font-size: 135%;\n  font-weight: bold;\n  margin-bottom: 25px;\n}"]}),n})(),hX=(()=>{class n{constructor(e){this.store=e}}return n.\u0275fac=function(e){return new(e||n)(C(Ae))},n.\u0275cmp=O({type:n,selectors:[["tf-debugger-v2-inactive"]],decls:1,vars:0,template:function(e,i){1&e&&P(0,"inactive-component")},dependencies:[mX],encapsulation:2}),n})(),_X={getWindow:function(){return window}};function gX(n){let t=_X.getWindow().require;return new Promise(e=>{t(n,e)})}var xN_loadMonaco=async function(){let n=_X.getWindow();if(void 0===n.monaco){if(!n.require)throw new Error("loadMonaco() failed because function require() is unavailable");n.require.config({paths:{vs:"/tf-imports/vs"}}),await gX(["vs/editor/editor.main"]),await gX(["vs/python/python.contribution"])}};function JE(n){return n?"vs-dark":"vs"}var Of=(()=>{class n{constructor(e){this.resizeEventDebouncePeriodInMs=100,this.onResize=new F,this.ngUnsubscribe$=new Ie,this.onResize$=new Ie;let i=new ResizeObserver(()=>{this.onResize$.next()});i.observe(e.nativeElement),this.ngUnsubscribe$.subscribe(()=>{i.unobserve(e.nativeElement)})}ngOnInit(){this.onResize$.pipe(ia(1),wr(this.resizeEventDebouncePeriodInMs),ot(this.ngUnsubscribe$)).subscribe(()=>{this.onResize.emit()})}ngOnDestroy(){this.ngUnsubscribe$.next(),this.ngUnsubscribe$.complete()}}return n.\u0275fac=function(e){return new(e||n)(C(Me))},n.\u0275dir=we({type:n,selectors:[["","detectResize",""]],inputs:{resizeEventDebouncePeriodInMs:"resizeEventDebouncePeriodInMs"},outputs:{onResize:"onResize"}}),n})(),Mwe=["codeViewerContainer"],xX=(()=>{class n{constructor(){this.lines=null,this.focusedLineno=null,this.monaco=null,this.editor=null,this.decorations=[],this.RESIZE_DEBOUNCE_INTERVAL_MS=50}onResize(){this.editor&&this.editor.layout()}ngOnChanges(e){if(null===this.monaco)return;let i=e.monaco&&null===this.editor;null===this.editor&&(this.editor=this.monaco.editor.create(this.codeViewerContainer.nativeElement,{value:(this.lines??[]).join("\n"),language:"python",readOnly:!0,fontSize:10,minimap:{enabled:!0},theme:JE(this.useDarkMode)})),e.lines&&this.lines&&this.editor.setValue(this.lines.join("\n"));let r=i||e.focusedLineno?this.focusedLineno:null;if(r&&this.lines){this.editor.revealLineInCenter(r,this.monaco.editor.ScrollType.Smooth);let o=this.lines[r-1].length;this.decorations=this.editor.deltaDecorations(this.decorations,[{range:new this.monaco.Range(r,1,r,1),options:{isWholeLine:!0,linesDecorationsClassName:"highlight-gutter"}},{range:new this.monaco.Range(r,1,r,o+1),options:{inlineClassName:"highlight-line"}}])}e.useDarkMode&&this.monaco.editor.setTheme(JE(this.useDarkMode))}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["source-code-component"]],viewQuery:function(e,i){if(1&e&&Ge(Mwe,7,Me),2&e){let r;Se(r=Ee())&&(i.codeViewerContainer=r.first)}},inputs:{lines:"lines",focusedLineno:"focusedLineno",monaco:"monaco",useDarkMode:"useDarkMode"},features:[Gt],decls:2,vars:1,consts:[["detectResize","",1,"code-viewer-container",3,"resizeEventDebouncePeriodInMs","onResize"],["codeViewerContainer",""]],template:function(e,i){1&e&&(h(0,"div",0,1),I("onResize",function(){return i.onResize()}),g()),2&e&&_("resizeEventDebouncePeriodInMs",i.RESIZE_DEBOUNCE_INTERVAL_MS)},dependencies:[Of],styles:[".code-viewer-container[_ngcontent-%COMP%] {\n  height: 100%;\n}\n\n[_nghost-%COMP%]     .highlight-gutter {\n  background: rgba(255, 111, 0, 0.7);\n  width: 5px !important;\n}\n\n[_nghost-%COMP%]     .highlight-line {\n  background: rgba(255, 111, 0, 0.3);\n}"],changeDetection:0}),n})(),CX=(()=>{class n{ngOnInit(){this.monaco$=$r(xN_loadMonaco()).pipe(N(()=>window.monaco))}constructor(){this.lines=null,this.focusedLineno=null,this.useDarkMode=!1,this.monaco$=null}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["source-code"]],inputs:{lines:"lines",focusedLineno:"focusedLineno",useDarkMode:"useDarkMode"},decls:2,vars:6,consts:[[3,"lines","focusedLineno","monaco","useDarkMode"]],template:function(e,i){1&e&&(P(0,"source-code-component",0),j(1,"async")),2&e&&_("lines",i.lines)("focusedLineno",i.focusedLineno)("monaco",W(1,4,i.monaco$))("useDarkMode",i.useDarkMode)},dependencies:[xX,ct],encapsulation:2}),n})();function Ewe(n,t){if(1&n&&(h(0,"div",6),T(1),g()),2&n){let e=w();v(1),He(" ",e.focusedSourceLineSpec.file_path," ")}}function Twe(n,t){1&n&&(h(0,"div",7),T(1," No file selected. Click a line number in the Stack Trace section to show the source code. "),g())}function Dwe(n,t){if(1&n&&P(0,"source-code",8),2&n){let e=w();_("lines",e.focusedSourceFileContent.lines)("focusedLineno",e.focusedSourceLineSpec.lineno)("useDarkMode",e.useDarkMode)}}var MX=(()=>{class n{constructor(){this.focusedSourceFileContent=null,this.focusedSourceLineSpec=null}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["source-files-component"]],inputs:{focusedSourceFileContent:"focusedSourceFileContent",focusedSourceLineSpec:"focusedSourceLineSpec",useDarkMode:"useDarkMode"},decls:8,vars:3,consts:[[1,"source-files-container"],[1,"header-section"],[1,"title-tag"],["class","file-label",4,"ngIf","ngIfElse"],["noFileSelected",""],[3,"lines","focusedLineno","useDarkMode",4,"ngIf"],[1,"file-label"],[1,"no-file-selected"],[3,"lines","focusedLineno","useDarkMode"]],template:function(e,i){if(1&e&&(h(0,"div",0)(1,"div",1)(2,"div",2),T(3,"Source Code"),g(),S(4,Ewe,2,1,"div",3),S(5,Twe,2,0,"ng-template",null,4,Wt),g(),S(7,Dwe,1,3,"source-code",5),g()),2&e){let r=it(6);v(4),_("ngIf",null!==i.focusedSourceLineSpec)("ngIfElse",r),v(3),_("ngIf",null!==i.focusedSourceFileContent&&null!==i.focusedSourceLineSpec&&null!==i.focusedSourceFileContent.lines)}},dependencies:[Fe,CX],styles:['.header-section[_ngcontent-%COMP%]{border-bottom:1px solid #ebebeb;display:flex;height:24px;padding-bottom:6px;vertical-align:middle;white-space:nowrap;width:100%}body.dark-mode[_nghost-%COMP%]   .header-section[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .header-section[_ngcontent-%COMP%]{border-bottom:1px solid #555}.file-label[_ngcontent-%COMP%]{display:inline-block;font-weight:normal;white-space:normal;overflow-wrap:anywhere;overflow-y:auto;padding:0 20px}.no-file-selected[_ngcontent-%COMP%]{display:inline-block;color:#666;padding:0 20px;white-space:normal}.source-files-container[_ngcontent-%COMP%]{display:flex;flex-direction:column;font-family:"Roboto Mono",monospace;font-size:10px;height:100%}.title-tag[_ngcontent-%COMP%]{display:inline-block;font-weight:bold;height:100%;padding-left:6px;vertical-align:top}source-code[_ngcontent-%COMP%]{flex-grow:1;width:100%}']}),n})(),wX=(()=>{class n{constructor(e){this.store=e,this.focusedSourceFileContent$=this.store.select(XE),this.focusedSourceLineSpec$=this.store.select(QE),this.useDarkMode$=this.store.select(Rl)}}return n.\u0275fac=function(e){return new(e||n)(C(Ae))},n.\u0275cmp=O({type:n,selectors:[["tf-debugger-v2-source-files"]],decls:4,vars:9,consts:[[3,"focusedSourceFileContent","focusedSourceLineSpec","useDarkMode"]],template:function(e,i){1&e&&(P(0,"source-files-component",0),j(1,"async"),j(2,"async"),j(3,"async")),2&e&&_("focusedSourceFileContent",W(1,3,i.focusedSourceFileContent$))("focusedSourceLineSpec",W(2,5,i.focusedSourceLineSpec$))("useDarkMode",W(3,7,i.useDarkMode$))},dependencies:[MX,ct],encapsulation:2}),n})(),Rwe=["stackFrameArray"];function Pwe(n,t){if(1&n&&(h(0,"span",13),T(1),g()),2&n){let e=w(3);v(1),He(" #",e.executionIndex,": ")}}function Owe(n,t){if(1&n&&(h(0,"span",14),T(1),g()),2&n){let e=w(3);v(1),He(" ",e.opType," ")}}function kwe(n,t){if(1&n&&(h(0,"div"),T(1," Eager execution "),S(2,Pwe,2,1,"span",11),S(3,Owe,2,1,"span",12),g()),2&n){let e=w(2);v(2),_("ngIf",null!==e.opType),v(1),_("ngIf",null!==e.opType)}}function Fwe(n,t){if(1&n&&(h(0,"span",16),T(1),g()),2&n){let e=w(3);v(1),He(' "',e.opName,'" ')}}function Nwe(n,t){if(1&n&&(h(0,"span",14),T(1),g()),2&n){let e=w(3);v(1),He(" ",e.opType," ")}}function Lwe(n,t){if(1&n&&(h(0,"div"),T(1," Creation of graph op "),S(2,Fwe,2,1,"span",15),S(3,Nwe,2,1,"span",12),g()),2&n){let e=w(2);v(2),_("ngIf",null!==e.opName),v(1),_("ngIf",null!==e.opType)}}function Bwe(n,t){if(1&n&&(h(0,"span",17),T(1),g()),2&n){let e=w(2);v(1),He(" (Host name: ",e.stackFramesForDisplay[0].host_name,") ")}}function Vwe(n,t){if(1&n&&(h(0,"div",7)(1,"span")(2,"span",8),S(3,kwe,4,2,"div",9),S(4,Lwe,4,2,"div",9),g()(),h(5,"div"),S(6,Bwe,2,1,"span",10),g()()),2&n){let e=w();v(2),_("ngSwitch",e.codeLocationType),v(1),_("ngSwitchCase",e.CodeLocationType.EXECUTION),v(1),_("ngSwitchCase",e.CodeLocationType.GRAPH_OP_CREATION),v(2),_("ngIf",null!==e.stackFramesForDisplay&&e.stackFramesForDisplay.length>0)}}function Hwe(n,t){1&n&&(h(0,"div",18),T(1," Click an eager execution or graph op to show its original stack trace. "),g())}function zwe(n,t){1&n&&(h(0,"div",28),T(1," \u2913 "),g())}var Uwe=function(n,t){return[n,t]};function jwe(n,t){if(1&n){let e=ge();h(0,"div",22)(1,"div",23),T(2),g(),h(3,"div",24),S(4,zwe,2,0,"div",25),h(5,"div",26),I("click",function(){let o=X(e).$implicit;return Q(w(2).onSourceLineClicked.emit(o))}),T(6),g(),h(7,"div",27),T(8),g()()()}if(2&n){let e=t.$implicit,i=w(2);_("ngClass",qr(6,Uwe,e.belongsToFocusedFile?"focused-file":"",e.focused?"focused-stack-frame":"")),v(1),Wi("title",e.file_path),v(1),He(" ",e.concise_file_path," "),v(2),_("ngIf",i.stickToBottommostFrameInFocusedFile&&e.focused),v(2),He(" Line ",e.lineno," "),v(2),He(" ",e.function_name," ")}}function Gwe(n,t){if(1&n&&(h(0,"div",19,20),S(2,jwe,9,9,"div",21),g()),2&n){let e=w();v(2),_("ngForOf",e.stackFramesForDisplay)}}function Wwe(n,t){}var SX=(()=>{class n{constructor(){this.stackFramesForDisplay=null,this.onSourceLineClicked=new F,this.CodeLocationType=Lo}ngAfterViewChecked(){if(void 0===this.stackFrameArray)return;let e=this.stackFrameArray.nativeElement,i=e.querySelector(".focused-stack-frame");if(null!==i)return void this.scrollToElement(e,i);let r=e.querySelector(".stack-frame-container:last-child");null!==r&&this.scrollToElement(e,r)}scrollToElement(e,i){e.scrollTop=i.offsetTop}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["stack-trace-component"]],viewQuery:function(e,i){if(1&e&&Ge(Rwe,5),2&e){let r;Se(r=Ee())&&(i.stackFrameArray=r.first)}},inputs:{codeLocationType:"codeLocationType",opType:"opType",opName:"opName",executionIndex:"executionIndex",stickToBottommostFrameInFocusedFile:"stickToBottommostFrameInFocusedFile",stackFramesForDisplay:"stackFramesForDisplay"},outputs:{onSourceLineClicked:"onSourceLineClicked"},decls:10,vars:4,consts:[[1,"stack-trace-container"],[1,"stack-trace-header"],[1,"stack-trace-title"],["class","stack-trace-aux-info",4,"ngIf","ngIfElse"],["noStackTrace",""],["class","stack-frame-array",4,"ngIf","ngIfElse"],["loadingSection",""],[1,"stack-trace-aux-info"],[1,"code-location-origin",3,"ngSwitch"],[4,"ngSwitchCase"],["class","stack-trace-host-name",4,"ngIf"],["class","eager-execution-index",4,"ngIf"],["class","op-type",4,"ngIf"],[1,"eager-execution-index"],[1,"op-type"],["class","op-name",4,"ngIf"],[1,"op-name"],[1,"stack-trace-host-name"],[1,"stack-trace-aux-info","no-stack-trace"],[1,"stack-frame-array"],["stackFrameArray",""],["class","stack-frame-container",3,"ngClass",4,"ngFor","ngForOf"],[1,"stack-frame-container",3,"ngClass"],[1,"stack-frame-file-path",3,"title"],[1,"stack-frame-lineno-function"],["class","stick-to-bottommost-indicator","title","Sticking to the bottommost frame in the current source file when navigating executions and graph ops. To remove this sticking, click any non-bottommost stack frame.",4,"ngIf"],[1,"stack-frame-lineno",3,"click"],[1,"stack-frame-function"],["title","Sticking to the bottommost frame in the current source file when navigating executions and graph ops. To remove this sticking, click any non-bottommost stack frame.",1,"stick-to-bottommost-indicator"]],template:function(e,i){if(1&e&&(h(0,"div",0)(1,"div",1)(2,"span",2),T(3," Stack Trace "),g(),S(4,Vwe,7,4,"div",3),S(5,Hwe,2,0,"ng-template",null,4,Wt),g(),S(7,Gwe,3,1,"div",5),S(8,Wwe,0,0,"ng-template",null,6,Wt),g()),2&e){let r=it(6),o=it(9);v(4),_("ngIf",null!==i.codeLocationType)("ngIfElse",r),v(3),_("ngIf",null!==i.stackFramesForDisplay)("ngIfElse",o)}},dependencies:[yn,nn,Fe,sr,Sr],styles:['.focused-file[_ngcontent-%COMP%]{font-weight:bold}.focused-stack-frame[_ngcontent-%COMP%]{background-color:rgba(255,111,0,.3)}.no-stack-trace[_ngcontent-%COMP%]{color:gray}.op-name[_ngcontent-%COMP%]{word-wrap:anywhere}.op-type[_ngcontent-%COMP%]{background-color:#eceff1;border:1px solid #ebebeb;border-radius:4px;font-family:"Roboto Mono",monospace;font-size:10px;height:14px;line-height:14px;padding:1px 3px;width:max-content}body.dark-mode[_nghost-%COMP%]   .op-type[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .op-type[_ngcontent-%COMP%]{border:1px solid #555}body.dark-mode[_nghost-%COMP%]   .op-type[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .op-type[_ngcontent-%COMP%]{background-color:#455a64}.stack-frame-array[_ngcontent-%COMP%]{overflow-x:hidden;overflow-y:auto;width:calc(100% - 8px)}.stack-frame-container[_ngcontent-%COMP%]{border-bottom:1px solid #a0a0a0}.stack-frame-file-path[_ngcontent-%COMP%]{max-width:180px;width:180px}.stack-frame-lineno-function[_ngcontent-%COMP%]{text-align:right;white-space:nowrap}.stack-frame-function[_ngcontent-%COMP%]{display:inline-block;max-width:200px;padding-left:10px;text-align:left;white-space:normal;width:200px;word-wrap:anywhere}.stack-frame-lineno[_ngcontent-%COMP%]{cursor:pointer;display:inline-block;max-width:80px;text-align:left;text-decoration:underline;width:80px}.stack-trace-aux-info[_ngcontent-%COMP%]{margin-top:15px;padding-left:24px}.stack-trace-container[_ngcontent-%COMP%]{border-left:1px solid #ebebeb;box-sizing:border-box;display:flex;flex-flow:column;font-size:10px;font-family:"Roboto Mono",monospace;height:100%;margin-left:8px;max-height:360px;overflow-x:hidden;overflow-y:hidden;padding-left:8px;width:100%}body.dark-mode[_nghost-%COMP%]   .stack-trace-container[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .stack-trace-container[_ngcontent-%COMP%]{border-left:1px solid #555}.stack-trace-header[_ngcontent-%COMP%]{box-shadow:0 5px 3px -3px #ccc;padding-bottom:3px}.stack-trace-host-name[_ngcontent-%COMP%]{color:gray}.stack-trace-title[_ngcontent-%COMP%]{font-weight:bold}.stick-to-bottommost-indicator[_ngcontent-%COMP%]{display:inline-block;font-weight:bold;font-size:12px;padding-right:3px}']}),n})(),EX=(()=>{class n{constructor(e){this.store=e,this.codeLocationType$=this.store.pipe(un(q(hy,i=>null===i?null:i.codeLocationType))),this.opType$=this.store.pipe(un(q(hy,i=>null===i?null:i.opType))),this.opName$=this.store.pipe(un(q(hy,i=>null===i||i.codeLocationType!==Lo.GRAPH_OP_CREATION?null:i.opName))),this.executionIndex$=this.store.pipe(un(q(hy,i=>null===i||i.codeLocationType!==Lo.EXECUTION?null:i.executionIndex))),this.stickToBottommostFrameInFocusedFile$=this.store.pipe(un(rX)),this.stackFramesForDisplay$=this.store.pipe(un(q(nX,QE,(i,r)=>{if(null===i)return null;let o=[];for(let s of i){let{host_name:a,file_path:l,lineno:c,function_name:d}=s,u=l.split("/"),f=null!==r&&a===r.host_name&&l===r.file_path;o.push({host_name:a,file_path:l,concise_file_path:u[u.length-1],lineno:c,function_name:d,belongsToFocusedFile:f,focused:f&&c===r.lineno})}return o})))}onSourceLineClicked(e){let{host_name:i,file_path:r,lineno:o,function_name:s}=e;this.store.dispatch(Og({stackFrame:{host_name:i,file_path:r,lineno:o,function_name:s}}))}}return n.\u0275fac=function(e){return new(e||n)(C(Ae))},n.\u0275cmp=O({type:n,selectors:[["tf-debugger-v2-stack-trace"]],decls:7,vars:18,consts:[[3,"codeLocationType","opType","opName","executionIndex","stickToBottommostFrameInFocusedFile","stackFramesForDisplay","onSourceLineClicked"]],template:function(e,i){1&e&&(h(0,"stack-trace-component",0),I("onSourceLineClicked",function(o){return i.onSourceLineClicked(o)}),j(1,"async"),j(2,"async"),j(3,"async"),j(4,"async"),j(5,"async"),j(6,"async"),g()),2&e&&_("codeLocationType",W(1,6,i.codeLocationType$))("opType",W(2,8,i.opType$))("opName",W(3,10,i.opName$))("executionIndex",W(4,12,i.executionIndex$))("stickToBottommostFrameInFocusedFile",W(5,14,i.stickToBottommostFrameInFocusedFile$))("stackFramesForDisplay",W(6,16,i.stackFramesForDisplay$))},dependencies:[SX,ct],encapsulation:2}),n})(),Xwe=function(n,t){return{tensorDebugMode:n,array:t}};function Qwe(n,t){if(1&n&&(h(0,"div",12)(1,"div",13),T(2),g(),h(3,"div",14),P(4,"debug-tensor-value",15),g()()),2&n){let e=t.$implicit,i=t.index,r=w(3);v(2),He("Output slot ",i,":"),v(2),_("debugTensorValue",r.parseDebugTensorValue(qr(2,Xwe,r.tensorDebugMode,e)))}}function Zwe(n,t){if(1&n&&(h(0,"div",10),S(1,Qwe,5,5,"div",11),g()),2&n){let e=w(2);v(1),_("ngForOf",e.debugTensorValues)}}function Kwe(n,t){if(1&n&&(h(0,"div")(1,"div")(2,"div",3)(3,"span",4),T(4," Op: "),g(),h(5,"span",5),T(6),g()(),h(7,"div",3)(8,"span",4),T(9," # of input tensors: "),g(),h(10,"span",6),T(11),g()(),h(12,"div",3)(13,"span",4),T(14," # of output tensors: "),g(),h(15,"span",7),T(16),g(),h(17,"span",8),T(18),g()(),S(19,Zwe,2,1,"div",9),g()()),2&n){let e=w();v(6),He(" ",e.focusedExecutionData.op_type," "),v(5),He(" ",null==e.focusedExecutionData.input_tensor_ids?0:e.focusedExecutionData.input_tensor_ids.length," "),v(5),He(" ",null==e.focusedExecutionData.output_tensor_ids?0:e.focusedExecutionData.output_tensor_ids.length," "),v(2),He(" (debug mode: ",e.TensorDebugMode[e.tensorDebugMode],") "),v(1),_("ngIf",e.hasDebugTensorValues)}}function Jwe(n,t){}var TX=(()=>{class n{constructor(){this.tensorDebugMode=So.UNSPECIFIED,this.hasDebugTensorValues=!1,this.debugTensorValues=null,this.debugTensorDtypes=null,this.TensorDebugMode=So,this.parseDebugTensorValue=ZE}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["execution-data-component"]],inputs:{focusedExecutionIndex:"focusedExecutionIndex",focusedExecutionData:"focusedExecutionData",tensorDebugMode:"tensorDebugMode",hasDebugTensorValues:"hasDebugTensorValues",debugTensorValues:"debugTensorValues",debugTensorDtypes:"debugTensorDtypes"},decls:7,vars:3,consts:[[1,"focus-execution-container"],[4,"ngIf","ngIfElse"],["loading_section",""],[1,"execution-data-field"],[1,"execution-data-key"],[1,"execution-data-value","op-type"],[1,"execution-data-value","input-tensors"],[1,"execution-data-value","output-tensors"],[1,"execution-data-value"],["class","output-slots",4,"ngIf"],[1,"output-slots"],["class","output-slot-container",4,"ngFor","ngForOf"],[1,"output-slot-container"],[1,"output-slot-number"],[1,"output-slot-debug-tensor-value"],[3,"debugTensorValue"]],template:function(e,i){if(1&e&&(h(0,"div",0)(1,"div")(2,"span"),T(3),g()(),S(4,Kwe,20,5,"div",1),S(5,Jwe,0,0,"ng-template",null,2,Wt),g()),2&e){let r=it(6);v(3),He(" Python Execution #",i.focusedExecutionIndex," "),v(1),_("ngIf",null!==i.focusedExecutionData)("ngIfElse",r)}},dependencies:[nn,Fe,KE],styles:['.debug-tensor-values-table[_ngcontent-%COMP%]{width:100%}.debug-tensor-values-table[_ngcontent-%COMP%]   td[_ngcontent-%COMP%]{border-top:1px solid #000;text-align:left}.debug-tensor-values-table[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]{text-align:left}.execution-data-field[_ngcontent-%COMP%]{white-space:nowrap}.execution-data-key[_ngcontent-%COMP%]{display:inline-block;max-width:120px;text-align:right;width:120px}.execution-data-value[_ngcontent-%COMP%]{display:inline-block;margin-left:10px}.focus-execution-container[_ngcontent-%COMP%]{background-color:#ffcc80;border-radius:4px;font-size:12px;height:120px;padding:5px;width:360px}body.dark-mode[_nghost-%COMP%]   .focus-execution-container[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .focus-execution-container[_ngcontent-%COMP%]{background-color:#e65100}.output-slots[_ngcontent-%COMP%]{height:60px;overflow-x:auto;overflow-y:auto}.output-slot-container[_ngcontent-%COMP%]{border-top:1px solid #ebebeb;margin-top:5px;padding:2px 0;vertical-align:top}body.dark-mode[_nghost-%COMP%]   .output-slot-container[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .output-slot-container[_ngcontent-%COMP%]{border-top:1px solid #555}.output-slot-number[_ngcontent-%COMP%]{display:block;font-family:"Roboto Mono",monospace}.output-slot-debug-tensor-value[_ngcontent-%COMP%]{display:block;margin:3px 0 3px 30px}.output-tensors[_ngcontent-%COMP%]{margin-top:5px}']}),n})(),DX="Unknown dtype",IX=(()=>{class n{constructor(e){this.store=e,this.focusedExecutionData$=this.store.pipe(un(Pf)),this.tensorDebugMode$=this.store.pipe(un(q(Pf,i=>null===i?So.UNSPECIFIED:i.tensor_debug_mode))),this.hasDebugTensorValues$=this.store.pipe(un(q(Pf,i=>{if(null===i||null===i.debug_tensor_values)return!1;for(let r of i.debug_tensor_values)if(null!==r&&r.length>0)return!0;return!1}))),this.debugTensorValues$=this.store.pipe(un(q(Pf,i=>null===i?null:i.debug_tensor_values))),this.debugTensorDtypes$=this.store.pipe(un(q(Pf,i=>{if(null===i||null===i.debug_tensor_values||i.tensor_debug_mode!==So.FULL_HEALTH&&i.tensor_debug_mode!==So.SHAPE)return null;let r=[];for(let o of i.debug_tensor_values)if(null===o)r.push(DX);else{let s=String(i.tensor_debug_mode===So.FULL_HEALTH?o[2]:o[1]);r.push(gy[s]||DX)}return r})))}}return n.\u0275fac=function(e){return new(e||n)(C(Ae))},n.\u0275cmp=O({type:n,selectors:[["tf-debugger-v2-execution-data"]],inputs:{focusedExecutionIndex:"focusedExecutionIndex"},decls:6,vars:16,consts:[[3,"focusedExecutionIndex","focusedExecutionData","tensorDebugMode","hasDebugTensorValues","debugTensorValues","debugTensorDtypes"]],template:function(e,i){1&e&&(P(0,"execution-data-component",0),j(1,"async"),j(2,"async"),j(3,"async"),j(4,"async"),j(5,"async")),2&e&&_("focusedExecutionIndex",i.focusedExecutionIndex)("focusedExecutionData",W(1,6,i.focusedExecutionData$))("tensorDebugMode",W(2,8,i.tensorDebugMode$))("hasDebugTensorValues",W(3,10,i.hasDebugTensorValues$))("debugTensorValues",W(4,12,i.debugTensorValues$))("debugTensorDtypes",W(5,14,i.debugTensorDtypes$))},dependencies:[TX,ct],encapsulation:2}),n})(),tSe=["sliderWrapper"],el=qo({passive:!1}),sSe={provide:Mo,useExisting:$n(()=>Dd),multi:!0},aSe=ku(zs(so(class{constructor(n){this._elementRef=n}}),"accent")),Dd=(()=>{class n extends aSe{get invert(){return this._invert}set invert(e){this._invert=Rt(e)}get max(){return this._max}set max(e){this._max=_i(e,this._max),this._percent=this._calculatePercentage(this._value),this._changeDetectorRef.markForCheck()}get min(){return this._min}set min(e){this._min=_i(e,this._min),this._percent=this._calculatePercentage(this._value),this._changeDetectorRef.markForCheck()}get step(){return this._step}set step(e){this._step=_i(e,this._step),this._step%1!=0&&(this._roundToDecimal=this._step.toString().split(".").pop().length),this._changeDetectorRef.markForCheck()}get thumbLabel(){return this._thumbLabel}set thumbLabel(e){this._thumbLabel=Rt(e)}get tickInterval(){return this._tickInterval}set tickInterval(e){this._tickInterval="auto"===e?"auto":"number"==typeof e||"string"==typeof e?_i(e,this._tickInterval):0}get value(){return null===this._value&&(this.value=this._min),this._value}set value(e){if(e!==this._value){let i=_i(e,0);this._roundToDecimal&&i!==this.min&&i!==this.max&&(i=parseFloat(i.toFixed(this._roundToDecimal))),this._value=i,this._percent=this._calculatePercentage(this._value),this._changeDetectorRef.markForCheck()}}get vertical(){return this._vertical}set vertical(e){this._vertical=Rt(e)}get displayValue(){return this.displayWith?this.displayWith(this.value):this._roundToDecimal&&this.value&&this.value%1!=0?this.value.toFixed(this._roundToDecimal):this.value||0}focus(e){this._focusHostElement(e)}blur(){this._blurHostElement()}get percent(){return this._clamp(this._percent)}_shouldInvertAxis(){return this.vertical?!this.invert:this.invert}_isMinValue(){return 0===this.percent}_getThumbGap(){return this.disabled?7:this._isMinValue()&&!this.thumbLabel?this._isActive?10:7:0}_getTrackBackgroundStyles(){let i=this.vertical?`1, ${1-this.percent}, 1`:1-this.percent+", 1, 1";return{transform:`translate${this.vertical?"Y":"X"}(${this._shouldInvertMouseCoords()?"-":""}${this._getThumbGap()}px) scale3d(${i})`}}_getTrackFillStyles(){let e=this.percent,r=this.vertical?`1, ${e}, 1`:`${e}, 1, 1`;return{transform:`translate${this.vertical?"Y":"X"}(${this._shouldInvertMouseCoords()?"":"-"}${this._getThumbGap()}px) scale3d(${r})`,display:0===e?"none":""}}_getTicksContainerStyles(){return{transform:`translate${this.vertical?"Y":"X"}(${this.vertical||"rtl"!=this._getDirection()?"-":""}${this._tickIntervalPercent/2*100}%)`}}_getTicksStyles(){let e=100*this._tickIntervalPercent,a={backgroundSize:this.vertical?`2px ${e}%`:`${e}% 2px`,transform:`translateZ(0) translate${this.vertical?"Y":"X"}(${this.vertical||"rtl"!=this._getDirection()?"":"-"}${e/2}%)${this.vertical||"rtl"!=this._getDirection()?"":" rotate(180deg)"}`};if(this._isMinValue()&&this._getThumbGap()){let c,l=this._shouldInvertAxis();c=this.vertical?l?"Bottom":"Top":l?"Right":"Left",a[`padding${c}`]=`${this._getThumbGap()}px`}return a}_getThumbContainerStyles(){let e=this._shouldInvertAxis();return{transform:`translate${this.vertical?"Y":"X"}(-${100*(("rtl"!=this._getDirection()||this.vertical?e:!e)?this.percent:1-this.percent)}%)`}}_shouldInvertMouseCoords(){let e=this._shouldInvertAxis();return"rtl"!=this._getDirection()||this.vertical?e:!e}_getDirection(){return this._dir&&"rtl"==this._dir.value?"rtl":"ltr"}constructor(e,i,r,o,s,a,l,c){super(e),this._focusMonitor=i,this._changeDetectorRef=r,this._dir=o,this._ngZone=a,this._animationMode=c,this._invert=!1,this._max=100,this._min=0,this._step=1,this._thumbLabel=!1,this._tickInterval=0,this._value=null,this._vertical=!1,this.change=new F,this.input=new F,this.valueChange=new F,this.onTouched=()=>{},this._percent=0,this._isSliding=null,this._isActive=!1,this._tickIntervalPercent=0,this._sliderDimensions=null,this._controlValueAccessorChangeFn=()=>{},this._dirChangeSubscription=Mn.EMPTY,this._pointerDown=d=>{this.disabled||this._isSliding||!_y(d)&&0!==d.button||this._ngZone.run(()=>{this._touchId=_y(d)?function(n,t){for(let e=0;e<n.touches.length;e++){let i=n.touches[e].target;if(t===i||t.contains(i))return n.touches[e].identifier}}(d,this._elementRef.nativeElement):void 0;let u=RX(d,this._touchId);if(u){let p=this.value;this._isSliding="pointer",this._lastPointerEvent=d,this._focusHostElement(),this._onMouseenter(),this._bindGlobalEvents(d),this._focusHostElement(),this._updateValueFromPosition(u),this._valueOnSlideStart=p,d.cancelable&&d.preventDefault(),p!=this.value&&this._emitInputEvent()}})},this._pointerMove=d=>{if("pointer"===this._isSliding){let u=RX(d,this._touchId);if(u){d.cancelable&&d.preventDefault();let p=this.value;this._lastPointerEvent=d,this._updateValueFromPosition(u),p!=this.value&&this._emitInputEvent()}}},this._pointerUp=d=>{"pointer"===this._isSliding&&(!_y(d)||"number"!=typeof this._touchId||MN(d.changedTouches,this._touchId))&&(d.cancelable&&d.preventDefault(),this._removeGlobalEvents(),this._isSliding=null,this._touchId=void 0,this._valueOnSlideStart!=this.value&&!this.disabled&&this._emitChangeEvent(),this._valueOnSlideStart=this._lastPointerEvent=null)},this._windowBlur=()=>{this._lastPointerEvent&&this._pointerUp(this._lastPointerEvent)},this._document=l,this.tabIndex=parseInt(s)||0,a.runOutsideAngular(()=>{let d=e.nativeElement;d.addEventListener("mousedown",this._pointerDown,el),d.addEventListener("touchstart",this._pointerDown,el)})}ngAfterViewInit(){this._focusMonitor.monitor(this._elementRef,!0).subscribe(e=>{this._isActive=!!e&&"keyboard"!==e,this._changeDetectorRef.detectChanges()}),this._dir&&(this._dirChangeSubscription=this._dir.change.subscribe(()=>{this._changeDetectorRef.markForCheck()}))}ngOnDestroy(){let e=this._elementRef.nativeElement;e.removeEventListener("mousedown",this._pointerDown,el),e.removeEventListener("touchstart",this._pointerDown,el),this._lastPointerEvent=null,this._removeGlobalEvents(),this._focusMonitor.stopMonitoring(this._elementRef),this._dirChangeSubscription.unsubscribe()}_onMouseenter(){this.disabled||(this._sliderDimensions=this._getSliderDimensions(),this._updateTickIntervalPercent())}_onFocus(){this._sliderDimensions=this._getSliderDimensions(),this._updateTickIntervalPercent()}_onBlur(){this.onTouched()}_onKeydown(e){if(this.disabled||vr(e)||this._isSliding&&"keyboard"!==this._isSliding)return;let i=this.value;switch(e.keyCode){case 33:this._increment(10);break;case 34:this._increment(-10);break;case 35:this.value=this.max;break;case 36:this.value=this.min;break;case 37:this._increment("rtl"==this._getDirection()?1:-1);break;case 38:this._increment(1);break;case 39:this._increment("rtl"==this._getDirection()?-1:1);break;case 40:this._increment(-1);break;default:return}i!=this.value&&(this._emitInputEvent(),this._emitChangeEvent()),this._isSliding="keyboard",e.preventDefault()}_onKeyup(){"keyboard"===this._isSliding&&(this._isSliding=null)}_getWindow(){return this._document.defaultView||window}_bindGlobalEvents(e){let i=this._document,r=_y(e),s=r?"touchend":"mouseup";i.addEventListener(r?"touchmove":"mousemove",this._pointerMove,el),i.addEventListener(s,this._pointerUp,el),r&&i.addEventListener("touchcancel",this._pointerUp,el);let a=this._getWindow();typeof a<"u"&&a&&a.addEventListener("blur",this._windowBlur)}_removeGlobalEvents(){let e=this._document;e.removeEventListener("mousemove",this._pointerMove,el),e.removeEventListener("mouseup",this._pointerUp,el),e.removeEventListener("touchmove",this._pointerMove,el),e.removeEventListener("touchend",this._pointerUp,el),e.removeEventListener("touchcancel",this._pointerUp,el);let i=this._getWindow();typeof i<"u"&&i&&i.removeEventListener("blur",this._windowBlur)}_increment(e){let i=this._clamp(this.value||0,this.min,this.max);this.value=this._clamp(i+this.step*e,this.min,this.max)}_updateValueFromPosition(e){if(!this._sliderDimensions)return;let s=this._clamp(((this.vertical?e.y:e.x)-(this.vertical?this._sliderDimensions.top:this._sliderDimensions.left))/(this.vertical?this._sliderDimensions.height:this._sliderDimensions.width));if(this._shouldInvertMouseCoords()&&(s=1-s),0===s)this.value=this.min;else if(1===s)this.value=this.max;else{let a=this._calculateValue(s),l=Math.round((a-this.min)/this.step)*this.step+this.min;this.value=this._clamp(l,this.min,this.max)}}_emitChangeEvent(){this._controlValueAccessorChangeFn(this.value),this.valueChange.emit(this.value),this.change.emit(this._createChangeEvent())}_emitInputEvent(){this.input.emit(this._createChangeEvent())}_updateTickIntervalPercent(){if(!this.tickInterval||!this._sliderDimensions)return;let e;if("auto"==this.tickInterval){let i=this.vertical?this._sliderDimensions.height:this._sliderDimensions.width;e=Math.ceil(30/(i*this.step/(this.max-this.min)))*this.step/i}else e=this.tickInterval*this.step/(this.max-this.min);this._tickIntervalPercent=AX(e)?e:0}_createChangeEvent(e=this.value){let i=new class{};return i.source=this,i.value=e,i}_calculatePercentage(e){let i=((e||0)-this.min)/(this.max-this.min);return AX(i)?i:0}_calculateValue(e){return this.min+e*(this.max-this.min)}_clamp(e,i=0,r=1){return Math.max(i,Math.min(e,r))}_getSliderDimensions(){return this._sliderWrapper?this._sliderWrapper.nativeElement.getBoundingClientRect():null}_focusHostElement(e){this._elementRef.nativeElement.focus(e)}_blurHostElement(){this._elementRef.nativeElement.blur()}writeValue(e){this.value=e}registerOnChange(e){this._controlValueAccessorChangeFn=e}registerOnTouched(e){this.onTouched=e}setDisabledState(e){this.disabled=e}}return n.\u0275fac=function(e){return new(e||n)(C(Me),C(Xr),C($t),C(Xi,8),yo("tabindex"),C(at),C(Lt),C(hi,8))},n.\u0275cmp=O({type:n,selectors:[["mat-slider"]],viewQuery:function(e,i){if(1&e&&Ge(tSe,5),2&e){let r;Se(r=Ee())&&(i._sliderWrapper=r.first)}},hostAttrs:["role","slider",1,"mat-slider","mat-focus-indicator"],hostVars:29,hostBindings:function(e,i){1&e&&I("focus",function(){return i._onFocus()})("blur",function(){return i._onBlur()})("keydown",function(o){return i._onKeydown(o)})("keyup",function(){return i._onKeyup()})("mouseenter",function(){return i._onMouseenter()})("selectstart",function(o){return o.preventDefault()}),2&e&&(jo("tabIndex",i.tabIndex),Be("aria-disabled",i.disabled)("aria-valuemax",i.max)("aria-valuemin",i.min)("aria-valuenow",i.value)("aria-valuetext",null==i.valueText?i.displayValue:i.valueText)("aria-orientation",i.vertical?"vertical":"horizontal"),nt("mat-slider-disabled",i.disabled)("mat-slider-has-ticks",i.tickInterval)("mat-slider-horizontal",!i.vertical)("mat-slider-axis-inverted",i._shouldInvertAxis())("mat-slider-invert-mouse-coords",i._shouldInvertMouseCoords())("mat-slider-sliding",i._isSliding)("mat-slider-thumb-label-showing",i.thumbLabel)("mat-slider-vertical",i.vertical)("mat-slider-min-value",i._isMinValue())("mat-slider-hide-last-tick",i.disabled||i._isMinValue()&&i._getThumbGap()&&i._shouldInvertAxis())("_mat-animation-noopable","NoopAnimations"===i._animationMode))},inputs:{disabled:"disabled",color:"color",tabIndex:"tabIndex",invert:"invert",max:"max",min:"min",step:"step",thumbLabel:"thumbLabel",tickInterval:"tickInterval",value:"value",displayWith:"displayWith",valueText:"valueText",vertical:"vertical"},outputs:{change:"change",input:"input",valueChange:"valueChange"},exportAs:["matSlider"],features:[Qt([sSe]),Ke],decls:13,vars:6,consts:[[1,"mat-slider-wrapper"],["sliderWrapper",""],[1,"mat-slider-track-wrapper"],[1,"mat-slider-track-background",3,"ngStyle"],[1,"mat-slider-track-fill",3,"ngStyle"],[1,"mat-slider-ticks-container",3,"ngStyle"],[1,"mat-slider-ticks",3,"ngStyle"],[1,"mat-slider-thumb-container",3,"ngStyle"],[1,"mat-slider-focus-ring"],[1,"mat-slider-thumb"],[1,"mat-slider-thumb-label"],[1,"mat-slider-thumb-label-text"]],template:function(e,i){1&e&&(h(0,"div",0,1)(2,"div",2),P(3,"div",3)(4,"div",4),g(),h(5,"div",5),P(6,"div",6),g(),h(7,"div",7),P(8,"div",8)(9,"div",9),h(10,"div",10)(11,"span",11),T(12),g()()()()),2&e&&(v(3),_("ngStyle",i._getTrackBackgroundStyles()),v(1),_("ngStyle",i._getTrackFillStyles()),v(1),_("ngStyle",i._getTicksContainerStyles()),v(1),_("ngStyle",i._getTicksStyles()),v(1),_("ngStyle",i._getThumbContainerStyles()),v(5),bt(i.displayValue))},dependencies:[pu],styles:['.mat-slider{display:inline-block;position:relative;box-sizing:border-box;padding:8px;outline:none;vertical-align:middle}.mat-slider:not(.mat-slider-disabled):active,.mat-slider.mat-slider-sliding:not(.mat-slider-disabled){cursor:grabbing}.mat-slider-wrapper{-webkit-print-color-adjust:exact;color-adjust:exact;position:absolute}.mat-slider-track-wrapper{position:absolute;top:0;left:0;overflow:hidden}.mat-slider-track-fill{position:absolute;transform-origin:0 0;transition:transform 400ms cubic-bezier(0.25, 0.8, 0.25, 1),background-color 400ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-slider-track-background{position:absolute;transform-origin:100% 100%;transition:transform 400ms cubic-bezier(0.25, 0.8, 0.25, 1),background-color 400ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-slider-ticks-container{position:absolute;left:0;top:0;overflow:hidden}.mat-slider-ticks{-webkit-background-clip:content-box;background-clip:content-box;background-repeat:repeat;box-sizing:border-box;opacity:0;transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-slider-thumb-container{position:absolute;z-index:1;transition:transform 400ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-slider-focus-ring{position:absolute;width:30px;height:30px;border-radius:50%;transform:scale(0);opacity:0;transition:transform 400ms cubic-bezier(0.25, 0.8, 0.25, 1),background-color 400ms cubic-bezier(0.25, 0.8, 0.25, 1),opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-slider.cdk-keyboard-focused .mat-slider-focus-ring,.mat-slider.cdk-program-focused .mat-slider-focus-ring{transform:scale(1);opacity:1}.mat-slider:not(.mat-slider-disabled):not(.mat-slider-sliding) .mat-slider-thumb-label,.mat-slider:not(.mat-slider-disabled):not(.mat-slider-sliding) .mat-slider-thumb{cursor:grab}.mat-slider-thumb{position:absolute;right:-10px;bottom:-10px;box-sizing:border-box;width:20px;height:20px;border:3px solid rgba(0,0,0,0);border-radius:50%;transform:scale(0.7);transition:transform 400ms cubic-bezier(0.25, 0.8, 0.25, 1),background-color 400ms cubic-bezier(0.25, 0.8, 0.25, 1),border-color 400ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-slider-thumb-label{display:none;align-items:center;justify-content:center;position:absolute;width:28px;height:28px;border-radius:50%;transition:transform 400ms cubic-bezier(0.25, 0.8, 0.25, 1),border-radius 400ms cubic-bezier(0.25, 0.8, 0.25, 1),background-color 400ms cubic-bezier(0.25, 0.8, 0.25, 1)}.cdk-high-contrast-active .mat-slider-thumb-label{outline:solid 1px}.mat-slider-thumb-label-text{z-index:1;opacity:0;transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-slider-sliding .mat-slider-track-fill,.mat-slider-sliding .mat-slider-track-background,.mat-slider-sliding .mat-slider-thumb-container{transition-duration:0ms}.mat-slider-has-ticks .mat-slider-wrapper::after{content:"";position:absolute;border-width:0;border-style:solid;opacity:0;transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-slider-has-ticks.cdk-focused:not(.mat-slider-hide-last-tick) .mat-slider-wrapper::after,.mat-slider-has-ticks:hover:not(.mat-slider-hide-last-tick) .mat-slider-wrapper::after{opacity:1}.mat-slider-has-ticks.cdk-focused:not(.mat-slider-disabled) .mat-slider-ticks,.mat-slider-has-ticks:hover:not(.mat-slider-disabled) .mat-slider-ticks{opacity:1}.mat-slider-thumb-label-showing .mat-slider-focus-ring{display:none}.mat-slider-thumb-label-showing .mat-slider-thumb-label{display:flex}.mat-slider-axis-inverted .mat-slider-track-fill{transform-origin:100% 100%}.mat-slider-axis-inverted .mat-slider-track-background{transform-origin:0 0}.mat-slider:not(.mat-slider-disabled).cdk-focused.mat-slider-thumb-label-showing .mat-slider-thumb{transform:scale(0)}.mat-slider:not(.mat-slider-disabled).cdk-focused .mat-slider-thumb-label{border-radius:50% 50% 0}.mat-slider:not(.mat-slider-disabled).cdk-focused .mat-slider-thumb-label-text{opacity:1}.mat-slider:not(.mat-slider-disabled).cdk-mouse-focused .mat-slider-thumb,.mat-slider:not(.mat-slider-disabled).cdk-touch-focused .mat-slider-thumb,.mat-slider:not(.mat-slider-disabled).cdk-program-focused .mat-slider-thumb{border-width:2px;transform:scale(1)}.mat-slider-disabled .mat-slider-focus-ring{transform:scale(0);opacity:0}.mat-slider-disabled .mat-slider-thumb{border-width:4px;transform:scale(0.5)}.mat-slider-disabled .mat-slider-thumb-label{display:none}.mat-slider-horizontal{height:48px;min-width:128px}.mat-slider-horizontal .mat-slider-wrapper{height:2px;top:23px;left:8px;right:8px}.mat-slider-horizontal .mat-slider-wrapper::after{height:2px;border-left-width:2px;right:0;top:0}.mat-slider-horizontal .mat-slider-track-wrapper{height:2px;width:100%}.mat-slider-horizontal .mat-slider-track-fill{height:2px;width:100%;transform:scaleX(0)}.mat-slider-horizontal .mat-slider-track-background{height:2px;width:100%;transform:scaleX(1)}.mat-slider-horizontal .mat-slider-ticks-container{height:2px;width:100%}.cdk-high-contrast-active .mat-slider-horizontal .mat-slider-ticks-container{height:0;outline:solid 2px;top:1px}.mat-slider-horizontal .mat-slider-ticks{height:2px;width:100%}.mat-slider-horizontal .mat-slider-thumb-container{width:100%;height:0;top:50%}.mat-slider-horizontal .mat-slider-focus-ring{top:-15px;right:-15px}.mat-slider-horizontal .mat-slider-thumb-label{right:-14px;top:-40px;transform:translateY(26px) scale(0.01) rotate(45deg)}.mat-slider-horizontal .mat-slider-thumb-label-text{transform:rotate(-45deg)}.mat-slider-horizontal.cdk-focused .mat-slider-thumb-label{transform:rotate(45deg)}.cdk-high-contrast-active .mat-slider-horizontal.cdk-focused .mat-slider-thumb-label,.cdk-high-contrast-active .mat-slider-horizontal.cdk-focused .mat-slider-thumb-label-text{transform:none}.mat-slider-vertical{width:48px;min-height:128px}.mat-slider-vertical .mat-slider-wrapper{width:2px;top:8px;bottom:8px;left:23px}.mat-slider-vertical .mat-slider-wrapper::after{width:2px;border-top-width:2px;bottom:0;left:0}.mat-slider-vertical .mat-slider-track-wrapper{height:100%;width:2px}.mat-slider-vertical .mat-slider-track-fill{height:100%;width:2px;transform:scaleY(0)}.mat-slider-vertical .mat-slider-track-background{height:100%;width:2px;transform:scaleY(1)}.mat-slider-vertical .mat-slider-ticks-container{width:2px;height:100%}.cdk-high-contrast-active .mat-slider-vertical .mat-slider-ticks-container{width:0;outline:solid 2px;left:1px}.mat-slider-vertical .mat-slider-focus-ring{bottom:-15px;left:-15px}.mat-slider-vertical .mat-slider-ticks{width:2px;height:100%}.mat-slider-vertical .mat-slider-thumb-container{height:100%;width:0;left:50%}.mat-slider-vertical .mat-slider-thumb{-webkit-backface-visibility:hidden;backface-visibility:hidden}.mat-slider-vertical .mat-slider-thumb-label{bottom:-14px;left:-40px;transform:translateX(26px) scale(0.01) rotate(-45deg)}.mat-slider-vertical .mat-slider-thumb-label-text{transform:rotate(45deg)}.mat-slider-vertical.cdk-focused .mat-slider-thumb-label{transform:rotate(-45deg)}[dir=rtl] .mat-slider-wrapper::after{left:0;right:auto}[dir=rtl] .mat-slider-horizontal .mat-slider-track-fill{transform-origin:100% 100%}[dir=rtl] .mat-slider-horizontal .mat-slider-track-background{transform-origin:0 0}[dir=rtl] .mat-slider-horizontal.mat-slider-axis-inverted .mat-slider-track-fill{transform-origin:0 0}[dir=rtl] .mat-slider-horizontal.mat-slider-axis-inverted .mat-slider-track-background{transform-origin:100% 100%}.mat-slider._mat-animation-noopable .mat-slider-track-fill,.mat-slider._mat-animation-noopable .mat-slider-track-background,.mat-slider._mat-animation-noopable .mat-slider-ticks,.mat-slider._mat-animation-noopable .mat-slider-thumb-container,.mat-slider._mat-animation-noopable .mat-slider-focus-ring,.mat-slider._mat-animation-noopable .mat-slider-thumb,.mat-slider._mat-animation-noopable .mat-slider-thumb-label,.mat-slider._mat-animation-noopable .mat-slider-thumb-label-text,.mat-slider._mat-animation-noopable .mat-slider-has-ticks .mat-slider-wrapper::after{transition:none}'],encapsulation:2,changeDetection:0}),n})();function AX(n){return!isNaN(n)&&isFinite(n)}function _y(n){return"t"===n.type[0]}function RX(n,t){let e;return e=_y(n)?"number"==typeof t?MN(n.touches,t)||MN(n.changedTouches,t):n.touches[0]||n.changedTouches[0]:n,e?{x:e.clientX,y:e.clientY}:void 0}function MN(n,t){for(let e=0;e<n.length;e++)if(n[e].identifier===t)return n[e]}var qu=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Pe,fn,fn]}),n})();function cSe(n,t){if(1&n){let e=ge();h(0,"mat-slider",11),I("input",function(r){return X(e),Q(w(2).onSliderChange.emit(r.value))}),g()}if(2&n){let e=w(2);_("min",0)("max",e.scrollBeginIndexUpperLimit)("value",e.scrollBeginIndex)}}function dSe(n,t){if(1&n){let e=ge();h(0,"div",6)(1,"button",7),I("click",function(){return X(e),Q(w().onNavigateLeft.emit())}),T(2," < "),g(),h(3,"div",8),T(4),g(),h(5,"button",9),I("click",function(){return X(e),Q(w().onNavigateRight.emit())}),T(6," > "),g(),S(7,cSe,1,3,"mat-slider",10),g()}if(2&n){let e=w();v(4),jM(" ",e.scrollBeginIndex," ~ ",e.scrollBeginIndex+e.displayCount-1," of ",e.numExecutions," "),v(3),_("ngIf",e.scrollBeginIndexUpperLimit>0)}}var uSe=function(n,t,e){return[n,t,e]};function pSe(n,t){if(1&n){let e=ge();h(0,"div",14),I("click",function(){let o=X(e).index;return Q(w(2).onExecutionDigestClicked.emit(o))}),h(1,"div",15),T(2),g()()}if(2&n){let e=t.$implicit,i=t.index,r=w(2);v(1),Wi("title",e.op_type),_("ngClass",gb(3,uSe,e.is_graph?"func-graph-execution":"",i===r.focusedExecutionDisplayIndex?"focused":"",r.displayFocusedAlertTypes[i]||"")),v(1),He(" ",e.short_op_type," ")}}function fSe(n,t){if(1&n&&(h(0,"div",12),S(1,pSe,3,7,"div",13),g()),2&n){let e=w();v(1),_("ngForOf",e.displayExecutionDigests)}}function mSe(n,t){if(1&n&&(Ot(0),P(1,"tf-debugger-v2-execution-data",16),kt()),2&n){let e=w();v(1),_("focusedExecutionIndex",e.focusedExecutionIndex)}}var PX=(()=>{class n{constructor(){this.activeRunId=null,this.loadingNumExecutions=!1,this.numExecutions=0,this.scrollBeginIndex=0,this.scrollBeginIndexUpperLimit=0,this.pageSize=0,this.displayCount=0,this.displayExecutionDigests=[],this.displayFocusedAlertTypes=[],this.focusedExecutionIndex=null,this.focusedExecutionDisplayIndex=null,this.focusedExecutionData=null,this.onNavigateLeft=new F,this.onNavigateRight=new F,this.onExecutionDigestClicked=new F,this.onSliderChange=new F}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["timeline-component"]],inputs:{activeRunId:"activeRunId",loadingNumExecutions:"loadingNumExecutions",numExecutions:"numExecutions",scrollBeginIndex:"scrollBeginIndex",scrollBeginIndexUpperLimit:"scrollBeginIndexUpperLimit",pageSize:"pageSize",displayCount:"displayCount",displayExecutionDigests:"displayExecutionDigests",displayFocusedAlertTypes:"displayFocusedAlertTypes",focusedExecutionIndex:"focusedExecutionIndex",focusedExecutionDisplayIndex:"focusedExecutionDisplayIndex",focusedExecutionData:"focusedExecutionData"},outputs:{onNavigateLeft:"onNavigateLeft",onNavigateRight:"onNavigateRight",onExecutionDigestClicked:"onExecutionDigestClicked",onSliderChange:"onSliderChange"},decls:9,vars:4,consts:[[1,"timeline-title"],[1,"execution-count"],[1,"top-level-executions"],["class","navigation-section",4,"ngIf"],["class","execution-timeline",4,"ngIf"],[4,"ngIf"],[1,"navigation-section"],["mat-button","",1,"navigation-button-left",3,"click"],[1,"navigation-position-info"],["mat-button","",1,"navigation-button-right",3,"click"],["class","timeline-slider","step","1",3,"min","max","value","input",4,"ngIf"],["step","1",1,"timeline-slider",3,"min","max","value","input"],[1,"execution-timeline"],[3,"click",4,"ngFor","ngForOf"],[3,"click"],[1,"execution-digest",3,"ngClass","title"],[3,"focusedExecutionIndex"]],template:function(e,i){1&e&&(h(0,"div")(1,"div",0),T(2," Python Execution Timeline "),h(3,"span",1),T(4),g()(),h(5,"div",2),S(6,dSe,8,4,"div",3),S(7,fSe,2,1,"div",4),S(8,mSe,2,1,"ng-container",5),g()()),2&e&&(v(4),He(" (",i.numExecutions,") "),v(2),_("ngIf",i.numExecutions),v(1),_("ngIf",i.numExecutions),v(1),_("ngIf",null!==i.activeRunId&&null!==i.focusedExecutionIndex))},dependencies:[yn,nn,Fe,IX,Ji,Dd],styles:[".execution-digest[_ngcontent-%COMP%] {\n  background-color: #e3e5e8;\n  border: 1px solid #c0c0c0;\n  color: #425066;\n  display: inline-block;\n  font-size: 10px;\n  height: 15px;\n  padding: 1px;\n  text-align: center;\n  vertical-align: middle;\n  width: 12px;\n}\n\n.execution-digest.func-graph-execution[_ngcontent-%COMP%] {\n  background-color: #c7dbf5;\n  color: #4e5664;\n  text-decoration: underline;\n}\n\n.execution-digest.focused[_ngcontent-%COMP%] {\n  background-color: #ffd4b3;\n  border: 1px solid #000;\n  font-weight: bold;\n}\n\n.execution-digest.InfNanAlert[_ngcontent-%COMP%] {\n  background-color: #e52592;\n  color: #fff;\n}\n\n\n.execution-digest[_ngcontent-%COMP%]:hover {\n  border: 1px solid #000;\n  font-weight: bold;\n}\n\n.execution-timeline[_ngcontent-%COMP%] {\n  display: flex;\n  overflow-x: hidden;\n  white-space: nowrap;\n  width: 100%;\n  margin-top: 5px;\n  margin-bottom: 5px;\n}\n\n.timeline-slider[_ngcontent-%COMP%] {\n  display: inline-block;\n  height: 48px;\n  left: 340px; \n  padding: 0;\n  position: absolute;\n  right: 40px;\n}\n\n  .timeline-slider .mat-slider-thumb {\n  border-radius: 5px;\n  right: -40px;\n  width: 80px;\n}\n\n\n.navigation-position-info[_ngcontent-%COMP%] {\n  display: inline-flex;\n  font-size: 14px;\n  line-height: normal;\n  max-width: 200px;\n  padding-left: 10px;\n  padding-right: 10px;\n  text-align: center;\n  vertical-align: middle;\n}\n\n.navigation-section[_ngcontent-%COMP%] {\n  height: 48px;\n  line-height: 48px;\n  position: relative;\n  vertical-align: middle;\n  width: 100%;\n}"],changeDetection:0}),n})(),gSe=["__forward_","__backward_","__inference_"],OX=(()=>{class n{constructor(e){this.store=e,this.activeRunId$=this.store.pipe(un(Qo)),this.loadingNumExecutions$=this.store.pipe(un(q(WE,i=>i.state==Te.LOADING))),this.scrollBeginIndex$=this.store.pipe(un(fy)),this.scrollBeginIndexUpperLimit$=this.store.pipe(un(q(Gu,Lg,(i,r)=>Math.max(0,i-r)))),this.pageSize$=this.store.pipe(un(Ng)),this.displayCount$=this.store.pipe(un(Lg)),this.displayExecutionDigests$=this.store.pipe(un(q(GY,i=>i.map(r=>function(n,t=1){if(!n)return{op_type:"(N/A)",short_op_type:"..",is_graph:!1};let e=gSe.filter(i=>n.op_type.startsWith(i));if(e.length){let i=n.op_type.slice(e[0].length);return{op_type:n.op_type,short_op_type:i.slice(0,t),is_graph:!0}}return{op_type:n.op_type,short_op_type:n.op_type.slice(0,t),is_graph:!1}}(r))))),this.displayFocusedAlertTypes$=this.store.pipe(un($Y)),this.focusedExecutionIndex$=this.store.pipe(un(hN)),this.focusedExecutionDisplayIndex$=this.store.pipe(un(eX)),this.numExecutions$=this.store.pipe(un(Gu))}onNavigateLeft(){this.store.dispatch(Eg())}onNavigateRight(){this.store.dispatch(Tg())}onExecutionDigestClicked(e){this.store.dispatch(Ig({displayIndex:e}))}onSliderChange(e){this.store.dispatch(Dg({index:e}))}}return n.\u0275fac=function(e){return new(e||n)(C(Ae))},n.\u0275cmp=O({type:n,selectors:[["tf-debugger-v2-timeline"]],decls:12,vars:33,consts:[[3,"activeRunId","loadingNumExecutions","numExecutions","scrollBeginIndex","scrollBeginIndexUpperLimit","pageSize","displayCount","displayExecutionDigests","displayFocusedAlertTypes","focusedExecutionIndex","focusedExecutionDisplayIndex","onNavigateLeft","onNavigateRight","onExecutionDigestClicked","onSliderChange"]],template:function(e,i){1&e&&(h(0,"timeline-component",0),I("onNavigateLeft",function(){return i.onNavigateLeft()})("onNavigateRight",function(){return i.onNavigateRight()})("onExecutionDigestClicked",function(o){return i.onExecutionDigestClicked(o)})("onSliderChange",function(o){return i.onSliderChange(o)}),j(1,"async"),j(2,"async"),j(3,"async"),j(4,"async"),j(5,"async"),j(6,"async"),j(7,"async"),j(8,"async"),j(9,"async"),j(10,"async"),j(11,"async"),g()),2&e&&_("activeRunId",W(1,11,i.activeRunId$))("loadingNumExecutions",W(2,13,i.loadingNumExecutions$))("numExecutions",W(3,15,i.numExecutions$))("scrollBeginIndex",W(4,17,i.scrollBeginIndex$))("scrollBeginIndexUpperLimit",W(5,19,i.scrollBeginIndexUpperLimit$))("pageSize",W(6,21,i.pageSize$))("displayCount",W(7,23,i.displayCount$))("displayExecutionDigests",W(8,25,i.displayExecutionDigests$))("displayFocusedAlertTypes",W(9,27,i.displayFocusedAlertTypes$))("focusedExecutionIndex",W(10,29,i.focusedExecutionIndex$))("focusedExecutionDisplayIndex",W(11,31,i.focusedExecutionDisplayIndex$))},dependencies:[PX,ct],encapsulation:2,changeDetection:0}),n})();function vSe(n,t){1&n&&P(0,"tf-debugger-v2-inactive")}function ySe(n,t){1&n&&(h(0,"div",3),P(1,"tf-debugger-v2-alerts"),h(2,"div",4),P(3,"tf-debugger-v2-timeline")(4,"tf-debugger-v2-graph"),g(),P(5,"tf-debugger-v2-graph-executions"),g(),h(6,"div",5),P(7,"tf-debugger-v2-source-files")(8,"tf-debugger-v2-stack-trace"),g())}var kX=(()=>{class n{constructor(){this.runs={},this.runIds=[],this.activeRunId=null}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["debugger-component"]],inputs:{runs:"runs",runIds:"runIds",activeRunId:"activeRunId"},decls:4,vars:2,consts:[[1,"debugger-container"],[4,"ngIf","ngIfElse"],["dataAvailable",""],[1,"top-section"],[1,"top-center-section"],[1,"bottom-section"]],template:function(e,i){if(1&e&&(h(0,"div",0),S(1,vSe,1,0,"tf-debugger-v2-inactive",1),S(2,ySe,9,0,"ng-template",null,2,Wt),g()),2&e){let r=it(3);v(1),_("ngIf",0===i.runIds.length)("ngIfElse",r)}},dependencies:[aX,Fe,dX,fX,hX,wX,EX,OX],styles:[".bottom-section[_ngcontent-%COMP%]{box-sizing:border-box;border-top:1px solid #ebebeb;display:flex;flex-grow:1;height:34%;padding-top:6px}body.dark-mode[_nghost-%COMP%]   .bottom-section[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .bottom-section[_ngcontent-%COMP%]{border-top:1px solid #555}.debugger-container[_ngcontent-%COMP%]{box-sizing:border-box;height:100%;overflow:hidden}.top-section[_ngcontent-%COMP%]{box-sizing:border-box;display:flex;flex-grow:1;height:66%;padding:6px 0}tf-debugger-v2-alerts[_ngcontent-%COMP%]{border-right:1px solid #ebebeb;display:inline-block;margin-right:10px;min-width:160px;width:calc(15% - 11px)}body.dark-mode[_nghost-%COMP%]   tf-debugger-v2-alerts[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   tf-debugger-v2-alerts[_ngcontent-%COMP%]{border-right:1px solid #555}tf-debugger-v2-graph-executions[_ngcontent-%COMP%]{display:inline-block;flex-grow:1;min-width:540px;width:540px}tf-debugger-v2-source-files[_ngcontent-%COMP%]{display:inline-block;height:100%;width:70%}tf-debugger-v2-stack-trace[_ngcontent-%COMP%]{display:inline-block;flex-grow:1;height:100%;min-width:540px;width:540px}.top-center-section[_ngcontent-%COMP%]{display:inline-block;overflow:auto;width:55%}tf-debugger-v2-timeline[_ngcontent-%COMP%]{display:block}tf-debugger-v2-graph[_ngcontent-%COMP%]{border-top:1px solid #ebebeb;display:block;margin-top:5px}body.dark-mode[_nghost-%COMP%]   tf-debugger-v2-graph[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   tf-debugger-v2-graph[_ngcontent-%COMP%]{border-top:1px solid #555}"],changeDetection:0}),n})(),FX=(()=>{class n{constructor(e){this.store=e,this.runs$=this.store.pipe(un(Af)),this.runsIds$=this.store.pipe(un(q(Af,i=>Object.keys(i)))),this.activeRunId$=this.store.pipe(un(Qo))}ngOnInit(){this.store.dispatch(CE())}ngOnDestroy(){this.store.dispatch(ME())}}return n.\u0275fac=function(e){return new(e||n)(C(Ae))},n.\u0275cmp=O({type:n,selectors:[["tf-debugger-v2"]],decls:4,vars:9,consts:[[3,"runs","runIds","activeRunId"]],template:function(e,i){1&e&&(P(0,"debugger-component",0),j(1,"async"),j(2,"async"),j(3,"async")),2&e&&_("runs",W(1,3,i.runs$))("runIds",W(2,5,i.runsIds$))("activeRunId",W(3,7,i.activeRunId$))},dependencies:[kX,ct],styles:["[_nghost-%COMP%] {\n        display: block;\n        height: 100%;\n      }"]}),n})(),tT="debugger-v2";function wN(n,t,e,i,r){if(e<=0||!Number.isInteger(e))throw new Error(`Invalid pageSize: ${e}`);if(t>i)throw new Error(`end index (${t}) exceeds total number of items (${i})`);if(t-n>e)throw new Error("begin-end span exceeds page size, which is not allowed");let o=[],s=Math.floor(n/e);(!(s in r)||r[s]<e&&s*e+r[s]<i)&&o.push(s);let a=Math.floor((t-1)/e);return a!==s&&(!(a in r)||a*e+r[a]<t&&t<i)&&o.push(a),o}var BX=(()=>{class n{onDebuggerDataPoll(){return this.actions$.pipe(ei(CE),Jn(e=>function(n,t,e){return n.pipe(function(n){return qt((t,e)=>{let i,o,r=!1,s=!1,a=!1,l=()=>a&&s&&(e.complete(),!0),d=()=>{a=!1,i=t.subscribe(Vt(e,void 0,()=>{a=!0,!l()&&(o||(o=new Ie,n(o).subscribe(Vt(e,()=>{i?d():r=!0},()=>{s=!0,l()}))),o).next()})),r&&(i.unsubscribe(),i=null,r=!1,d())};d()})}(i=>i.pipe(Bt(t),km(([,r])=>na(r)))),ot(e),N(()=>{}))}(Ht(e),this.store.select(VY).pipe(N(i=>function(n){return n>6e4?6e4:n>4e3?n:2e3}(i))),this.actions$.pipe(ei(ME)))),Nt(()=>this.store.dispatch(ay())),N(()=>{}))}onCoreReload(){return tn(this.actions$.pipe(ei(Fs,cs)),this.actions$.pipe(ei(wc)).pipe(Bt(this.store.select(lN)),ke(([,e])=>e.state===Te.NOT_LOADED||e.state===Te.FAILED&&null===e.lastLoadedTimeInMs))).pipe(Bt(this.store.select(Wo)),ke(([,e])=>e===tT),Nt(()=>this.store.dispatch(ay())),N(()=>{}))}loadDebuggerRuns(e){return e.pipe(Bt(this.store.select(lN)),ke(([,{state:i}])=>i!==Te.LOADING),Nt(()=>this.store.dispatch(wE())),hn(()=>this.dataSource.fetchRuns().pipe(Nt(i=>{this.store.dispatch(SE({runs:i}))}),N(()=>{}))))}createNumExecutionLoader(e){return e.pipe(Bt(this.store.select(Af),this.store.select(WE)),ke(([,i,r])=>Object.keys(i).length>0&&r.state!==Te.LOADING),Nt(()=>this.store.dispatch(DE())),hn(([,i])=>{let r=Object.keys(i)[0];return this.dataSource.fetchExecutionDigests(r,0,0).pipe(Nt(a=>{this.store.dispatch(IE({numExecutions:a.num_digests}))}),N(()=>{}))}))}createNumGraphExecutionLoader(e){return e.pipe(Bt(this.store.select(Af),this.store.select(WY)),ke(([,i,r])=>Object.keys(i).length>0&&r.state!==Te.LOADING),Nt(()=>this.store.dispatch(OE())),hn(([,i])=>{let r=Object.keys(i)[0];return this.dataSource.fetchGraphExecutionDigests(r,0,0).pipe(Nt(a=>{this.store.dispatch(kE({numGraphExecutions:a.num_digests}))}),N(()=>{}))}))}createNumAlertsAndBreakdownLoader(e){return e.pipe(Bt(this.store.select(Af),this.store.select(cN)),ke(([,i,r])=>Object.keys(i).length>0&&r.state!==Te.LOADING),Nt(()=>this.store.dispatch(ly())),hn(([,i])=>{let r=Object.keys(i)[0];return this.dataSource.fetchAlerts(r,0,0).pipe(Nt(a=>{this.store.dispatch(EE({numAlerts:a.num_alerts,alertsBreakdown:a.alerts_breakdown}))}),N(()=>{}))}))}createInitialExecutionDetector(e){return e.pipe(Bt(this.store.select(Gu),this.store.select(py)),ke(([,i,r])=>i>0&&0===Object.keys(r.pageLoadedSizes).length),N(()=>{}))}createInitialExecutionDigest(e){return e.pipe(Bt(this.store.select(Gu),this.store.select(Qo),this.store.select(Ng)),ke(([,,i])=>null!==i),N(([,i,r,o])=>({begin:0,end:Math.min(i,o),runId:r})))}onExecutionScroll(){return this.actions$.pipe(ei(Eg,Tg,Dg),Bt(this.store.select(Qo),this.store.select(fy),this.store.select(Gu),this.store.select(Lg),this.store.select(Ng)),ke(([e])=>null!==e),N(([,e,i,r,o,s])=>({runId:e,begin:i,end:Math.min(r,i+o),pageSize:s})),Bt(this.store.select(py)),N(([e,i])=>({props:e,loaded:i,missingPages:wN(e.begin,e.end,e.pageSize,i.numExecutions,i.pageLoadedSizes)})),ke(({missingPages:e})=>e.length>0),N(({props:e,loaded:i,missingPages:r})=>{let{runId:o,pageSize:s}=e;return{begin:r[0]*s,end:Math.min(i.numExecutions,(r[r.length-1]+1)*s),runId:o}}))}createExecutionDigestLoader(e){return e.pipe(Bt(this.store.select(py)),ke(([{begin:i,end:r},o])=>r>i&&!function(n,t,e){if(t>=e)throw new Error(`Expected begin to be less than end, but got begin=${t}, end=${e}`);return-1!==n.findIndex(i=>i.begin>=t&&i.end<=e)}(o.loadingRanges,i,r)),Nt(([{begin:i,end:r}])=>{this.store.dispatch(AE({begin:i,end:r}))}),hn(([{runId:i,begin:r,end:o}])=>this.dataSource.fetchExecutionDigests(i,r,o).pipe(Nt(s=>{this.store.dispatch(RE(s))}),N(()=>{}))))}onExecutionDigestFocused(){return this.actions$.pipe(ei(Ig),Bt(this.store.select(Qo),this.store.select(gN),this.store.select(fy)),N(([e,i,r,o])=>({activeRunId:i,loadedExecutionData:r,focusIndex:o+e.displayIndex})))}createExecutionDataAndStackFramesLoader(e){return e.pipe(ke(({activeRunId:i,loadedExecutionData:r,focusIndex:o})=>null!==i&&null!==o&&void 0===r[o]),hn(({activeRunId:i,focusIndex:r})=>{let o=r,s=o+1;return this.dataSource.fetchExecutionData(i,o,s).pipe(Nt(a=>{this.store.dispatch(PE(a))}),N(a=>({executionData:a,begin:o,end:s})))}),N(({executionData:i})=>i.executions[0]),Bt(this.store.select(Qo),this.store.select(_N)),ke(([i,r,o])=>{if(null===r)return!1;for(let s of i.stack_frame_ids)if(void 0===o[s])return!0;return!1}),hn(([i,r])=>{let o=i.stack_frame_ids;return this.dataSource.fetchStackFrames(r,o).pipe(Nt(s=>{let a={};for(let l=0;l<o.length;++l)a[o[l]]=s.stack_frames[l];this.store.dispatch(cy({stackFrames:a}))}),N(()=>{}))}))}onGraphExecutionScroll(){return this.actions$.pipe(ei(Ag),wr(100),Bt(this.store.select(Qo),this.store.select(my),this.store.select(qY)),ke(([,e,i])=>null!==e&&i>0),N(([,e,i,r])=>({runId:e,numGraphExecutions:i,scrollBeginIndex:r})),Bt(this.store.select(XY),this.store.select(YY),this.store.select(QY),this.store.select(ZY)),N(([{runId:e,numGraphExecutions:i,scrollBeginIndex:r},o,s,a,l])=>{let c=wN(r,Math.min(r+s,i),o,i,l);return c=c.filter(d=>-1===a.indexOf(d)),{runId:e,missingPages:c,pageSize:o,numGraphExecutions:i}}))}loadGraphExecutionPages(e){return e.pipe(ke(({missingPages:i})=>i.length>0),Nt(({missingPages:i})=>{i.forEach(r=>{this.store.dispatch(FE({pageIndex:r}))})}),hn(({runId:i,missingPages:r,pageSize:o,numGraphExecutions:s})=>{let a=r[0]*o,l=Math.min((r[r.length-1]+1)*o,s);return this.dataSource.fetchGraphExecutionData(i,a,l).pipe(Nt(c=>{this.store.dispatch(NE(c))}),N(()=>{}))}))}loadGraphOpInfo(){return this.actions$.pipe(ei(Pg,Rg),Bt(this.store.select(Qo),this.store.select(tX)),ke(([e,i,r])=>{let{graph_id:o,op_name:s}=e;return!(null===i||void 0!==r[o]&&r[o].has(s)&&(r[o].get(s)===Te.LOADING||r[o].get(s)===Te.LOADED))}),Nt(([{graph_id:e,op_name:i}])=>this.store.dispatch(LE({graph_id:e,op_name:i}))),hn(([e,i])=>{let{graph_id:r,op_name:o}=e;return this.dataSource.fetchGraphOpInfo(i,r,o).pipe(Nt(s=>this.store.dispatch(BE({graphOpInfoResponse:s}))),N(s=>({runId:i,stackFrameIds:s.stack_frame_ids})))}))}loadGraphOpStackFrames(e){return e.pipe(Bt(this.store.select(_N)),N(([{runId:i,stackFrameIds:r},o])=>({runId:i,missingStackFrameIds:r.filter(a=>void 0===o[a])})),ke(({runId:i,missingStackFrameIds:r})=>null!==i&&r.length>0),hn(({runId:i,missingStackFrameIds:r})=>this.dataSource.fetchStackFrames(i,r).pipe(Nt(o=>{let s={};for(let a=0;a<r.length;++a)s[r[a]]=o.stack_frames[a];this.store.dispatch(cy({stackFrames:s}))}),N(()=>{}))))}onAlertTypeFocused(){return this.actions$.pipe(ei(Sg),Bt(this.store.select(Qo),this.store.select(GE),this.store.select(zY),this.store.select(UY),this.store.select(cN)),ke(([,e,i,r,o,s])=>null!==e&&null!==i&&r>0&&(null===o||Object.keys(o).length<r)&&s.state!==Te.LOADING),Nt(()=>this.store.dispatch(ly())),hn(([,e,i])=>this.dataSource.fetchAlerts(e,0,-1,i)),Nt(({num_alerts:e,alerts_breakdown:i,alert_type:r,begin:o,end:s,alerts:a})=>{this.store.dispatch(TE({numAlerts:e,alertsBreakdown:i,alertType:r,begin:o,end:s,alerts:a}))}))}fetchExecutionDigestsForAlertTypeFocus(e){return e.pipe(Bt(this.store.select(Ng),this.store.select(Lg),this.store.select(Gu),this.store.select(py),this.store.select(Qo)),N(([i,r,o,s,a,l])=>{let d=i.alerts[0].execution_index,u=wN(Math.max(0,d-Math.floor(o/2)),Math.min(d+Math.floor(o/2),s),r,s,a.pageLoadedSizes);return 0===u.length?{runId:l,begin:0,end:0}:{runId:l,begin:u[0]*r,end:Math.min(a.numExecutions,(u[u.length-1]+1)*r)}}))}loadSourceFileList(e){return e.pipe(Bt(this.store.select(Qo),this.store.select(iX)),ke(([,i,r])=>null!==i&&r.state!==Te.LOADING),Nt(()=>this.store.dispatch(VE())),hn(([,i])=>this.dataSource.fetchSourceFileList(i).pipe(Nt(r=>{let o=[];r.forEach(([s,a])=>{o.push({host_name:s,file_path:a})}),this.store.dispatch(HE({sourceFiles:o}))}),N(()=>{}))))}onSourceFileFocused(){return this.actions$.pipe(ei(Og),Bt(this.store.select(Qo),this.store.select(bN),this.store.select(XE)),N(([e,i,r,o])=>({runId:i,stackFrame:e.stackFrame,fileIndex:r,fileContent:o})),ke(({runId:e,fileContent:i})=>null!==e&&null!==i&&i.loadState===Te.NOT_LOADED),Nt(({stackFrame:e})=>this.store.dispatch(zE({host_name:e.host_name,file_path:e.file_path}))),hn(({fileIndex:e,runId:i})=>this.dataSource.fetchSourceFile(i,e).pipe(Nt(r=>{this.store.dispatch(UE(r))}),N(()=>{}))))}constructor(e,i,r){this.actions$=e,this.store=i,this.dataSource=r,this.loadData$=ar(()=>{let o=this.loadDebuggerRuns(tn(this.onDebuggerDataPoll(),this.onCoreReload())).pipe(Cs()),s=this.loadSourceFileList(o),a=this.createNumExecutionLoader(o),l=this.createNumAlertsAndBreakdownLoader(o),c=this.onAlertTypeFocused(),d=this.fetchExecutionDigestsForAlertTypeFocus(c),u=this.createInitialExecutionDetector(a).pipe(Cs()),p=this.createExecutionDigestLoader(tn(this.onExecutionScroll(),this.createInitialExecutionDigest(u),d)),f=this.createExecutionDataAndStackFramesLoader(tn(this.onExecutionDigestFocused(),u.pipe(Bt(this.store.select(Qo),this.store.select(gN)),N(([,x,R])=>({activeRunId:x,loadedExecutionData:R,focusIndex:0})))));return tn(l,p,f,this.createNumGraphExecutionLoader(o),s,this.onSourceFileFocused(),this.loadGraphExecutionPages(this.onGraphExecutionScroll()),this.loadGraphOpStackFrames(this.loadGraphOpInfo())).pipe(N(()=>({})))},{dispatch:!1})}}return n.\u0275fac=function(e){return new(e||n)(k(xo),k(Ae),k(xE))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),VX=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Pe]}),n})(),HX=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Pe]}),n})(),nT=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Pe]}),n})(),zX=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Pe,nT,Md]}),n})(),UX=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({}),n})(),Yu=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({}),n})(),iT=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Pe,Yu]}),n})(),jX=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Pe,iT]}),n})(),GX=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Pe,iT]}),n})(),WX=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Pe,nT]}),n})(),qX=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Pe,WX,ci,qu]}),n})(),YX=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[VX,Pe,Ga,zX,HX,UX,jX,GX,OY,qX,Tr.forFeature(dy,BY),to.forFeature([BX]),Bc.forPlugin(tT,FX)]}),n})(),rT=_e("[Metrics] Metrics Settings Pane Closed"),oT=_e("[Metrics] Metrics Settings Pane Toggled"),sT=_e("[Metrics] Slide out settings menu toggled"),aT=_e("[Metrics] User requested to open the slide out menu",{_as:"props",_p:void 0}),lT=_e("[Metrics] User changed the tab in the table editor",{_as:"props",_p:void 0}),cT=_e("[Metrics] Slide out settings menu closed"),dT=_e("[Metrics] Metrics Tag Metadata Requested"),uT=_e("[Metrics] Metrics Tag Metadata Loaded",{_as:"props",_p:void 0}),pT=_e("[Metrics] Metrics Tag Metadata Failed"),fT=_e("[Metrics] Metrics Card State Updated",{_as:"props",_p:void 0}),Bg=_e("[Metrics] Metrics Card Full Size Toggled",{_as:"props",_p:void 0}),mT=_e("[Metrics] Metrics Settings Change Tooltip",{_as:"props",_p:void 0}),hT=(_e("[Metrics] Metrics Settings Toggle Show Data Download"),_e("[Metrics] Metrics Setting Toggle Ignore Outlier")),gT=_e("[Metrics] Metrics Setting Change X Axis Type",{_as:"props",_p:void 0}),_T=_e("[Metrics] Metrics Setting Change Card Width",{_as:"props",_p:void 0}),bT=_e("[Metrics] Metrics Setting Reset Card Width"),vT=_e("[Metrics] Metrics Setting Change Scalar Smoothing",{_as:"props",_p:void 0}),yT=_e("[Metrics] Metrics Setting Partition Non Monotonic X Toggled"),xT=_e("[Metrics] Metrics Setting Change Image Brightness",{_as:"props",_p:void 0}),CT=_e("[Metrics] Metrics Setting Change Image Contrast",{_as:"props",_p:void 0}),MT=_e("[Metrics] Image Brightness Setting Reset"),wT=_e("[Metrics] Image Contrast Setting Reset"),ST=_e("[Metrics] Metrics Setting Toggle Image Show Actual Size"),ET=_e("[Metrics] Metrics Setting Change Histogram Mode",{_as:"props",_p:void 0}),TT=_e("[Metrics] Multiple Time Series Requested",{_as:"props",_p:void 0}),DT=_e("[Metrics] Fetch Time Series Request Failed",{_as:"props",_p:void 0}),IT=_e("[Metrics] Fetch Time Series Response Loaded",{_as:"props",_p:void 0}),Vg=_e("[Metrics] Card Visibility Changed",{_as:"props",_p:void 0}),AT=_e("[Metrics] Card Step Slider Changed",{_as:"props",_p:void 0}),RT=_e("[Metrics] Tag Filter Changed",{_as:"props",_p:void 0}),PT=_e("[Metrics] Metrics Tag Group Expansion Changed",{_as:"props",_p:void 0}),Hg=_e("[Metrics] Card Pin State Toggled",{_as:"props",_p:void 0}),OT=_e("[Metrics] Toggle Visible Plugin",{_as:"props",_p:void 0}),kT=_e("[Metrics] Toggle Show All Plugins"),kf=_e("[Metrics] Time Selection Changed",{_as:"props",_p:void 0}),by=_e("[Metrics] Card User View Box Changed",{_as:"props",_p:void 0}),FT=_e("[Metrics] Linked Time Enable Toggle",{_as:"props",_p:void 0}),XX=_e("[Metrics] Sorting Data Table By Header",{_as:"props",_p:void 0}),zg=_e("[Metrics] Data table columns edited in edit menu",{_as:"props",_p:void 0}),Ug=_e("[Metrics] Data table column toggled in edit menu or delete button clicked",{_as:"props",_p:void 0}),Id=_e("[Metrics] Time Selector Enable Toggle",{_as:"props",_p:void 0}),NT=_e("[Metrics] Range Selection Toggled",{_as:"props",_p:void 0}),QX=_e("[Metrics] Hide Empty Cards Changed");function vy(n,t){let e={};for(let i of Object.keys(n))e[i]=t(n[i],i);return e}var qs=(()=>(function(n){n.NONE="no affordance",n.EXTENDED_LINE="extendedLine",n.FOB="fob",n.FOB_REMOVED="fobRemoved",n.FOB_TEXT="fobText",n.HISTOGRAM_CLICK_TO_RANGE="histogramClickToRange",n.FOB_ADDED="fobAdded"}(qs||(qs={})),qs))(),Ys=(()=>(function(n){n.NONE="no toggle affordance",n.FOB_DESELECT="fobDeselect",n.CHECK_BOX="checkBox"}(Ys||(Ys={})),Ys))(),fs=(()=>(function(n){n[n.HORIZONTAL=0]="HORIZONTAL",n[n.VERTICAL=1]="VERTICAL"}(fs||(fs={})),fs))();function LT(n){let t=new Map,e=n.slice().sort((i,r)=>yy(i.tag,r.tag));for(let i of e){let r=ESe(i.tag);t.has(r)||t.set(r,{groupName:r,items:[]}),t.get(r).items.push(i)}return[...t.values()]}function ESe(n){return n.split("/",1)[0]}function yy(n,t){let e=0,i=0;for(;;){if(e===n.length)return i===t.length?0:-1;if(i===t.length)return 1;if(Ff(n[e])&&Ff(t[i])){let r=e,o=i;e=ZX(n,e+1),i=ZX(t,i+1);let s=Number(n.slice(r,e)),a=Number(t.slice(o,i));if(s<a)return-1;if(s>a)return 1}else{if(SN(n[e])){if(!SN(t[i]))return-1}else{if(SN(t[i]))return 1;if(n[e]<t[i])return-1;if(n[e]>t[i])return 1}e++,i++}}}function ZX(n,t){let e;var o;(o=e||(e={}))[o.NATURAL=0]="NATURAL",o[o.REAL=1]="REAL",o[o.EXPONENT_SIGN=2]="EXPONENT_SIGN",o[o.EXPONENT=3]="EXPONENT";let i=e.NATURAL,r=t;for(;r<n.length;r++)if(i===e.NATURAL){if("."===n[r])i=e.REAL;else if("e"===n[r]||"E"===n[r])i=e.EXPONENT_SIGN;else if(!Ff(n[r]))break}else if(i===e.REAL){if("e"===n[r]||"E"===n[r])i=e.EXPONENT_SIGN;else if(!Ff(n[r]))break}else if(i===e.EXPONENT_SIGN){if(!Ff(n[r])&&"+"!==n[r]&&"-"!==n[r])break;i=e.EXPONENT}else if(i===e.EXPONENT&&!Ff(n[r]))break;return r}function Ff(n){return"0"<=n&&n<="9"}function SN(n){return"/"===n||Ff(n)}function EN(n,t,e){let{plugin:i,tag:r,runId:o,sample:s}=t[n],a=gd(e,i,r,s);if(a){if(null!==o&&a.runToSeries.hasOwnProperty(o)){let c=a.runToSeries[o].length;return c>0?c-1:null}let l=Object.values(a.runToSeries).map(c=>c.length);if(l.length)return Math.max(...l)-1}return null}function DSe(n,t,e,i){let r={...t};for(let o in n){if(!n.hasOwnProperty(o))continue;let s=EN(o,n,e);if(null===s)continue;let a=t.hasOwnProperty(o)?t[o].index:null,l=EN(o,n,i);(null!==a&&a>s||null===a||null!==a&&a===l)&&(r[o]={index:s,isClosest:!1})}return r}function KX(n){let t=vy(n.runToLoadState,e=>e===Te.LOADING?Te.LOADING:Te.NOT_LOADED);return{...n,runToLoadState:t}}function JX(n,t,e,i){return JSON.stringify([n,t,e||"",i])}var{initialState:eQ,reducers:ISe}=uf({tagMetadataLoadState:{state:Te.NOT_LOADED,lastLoadedTimeInMs:null},tagMetadata:{scalars:{tagDescriptions:{},tagToRuns:{}},histograms:{tagDescriptions:{},tagToRuns:{}},images:{tagDescriptions:{},tagRunSampledInfo:{}}},cardList:[],cardToPinnedCopy:new Map,cardToPinnedCopyCache:new Map,pinnedCardToOriginal:new Map,unresolvedImportedPinnedCards:[],cardMetadataMap:{},cardStateMap:{},cardStepIndex:{},tagFilter:"",tagGroupExpanded:new Map,linkedTimeSelection:null,linkedTimeEnabled:!1,stepSelectorEnabled:!0,rangeSelectionEnabled:!1,singleSelectionHeaders:[{type:ht.RUN,name:"run",displayName:"Run",enabled:!0,removable:!0,sortable:!0,movable:!0},{type:ht.SMOOTHED,name:"smoothed",displayName:"Smoothed",enabled:!0,removable:!0,sortable:!0,movable:!0},{type:ht.VALUE,name:"value",displayName:"Value",enabled:!0,removable:!0,sortable:!0,movable:!0},{type:ht.STEP,name:"step",displayName:"Step",enabled:!0,removable:!0,sortable:!0,movable:!0},{type:ht.RELATIVE_TIME,name:"relative",displayName:"Relative",enabled:!0,removable:!0,sortable:!0,movable:!0}],rangeSelectionHeaders:[{type:ht.RUN,name:"run",displayName:"Run",enabled:!0,removable:!0,sortable:!0,movable:!0},{type:ht.MIN_VALUE,name:"min",displayName:"Min",enabled:!0,removable:!0,sortable:!0,movable:!0},{type:ht.MAX_VALUE,name:"max",displayName:"Max",enabled:!0,removable:!0,sortable:!0,movable:!0},{type:ht.START_VALUE,name:"start",displayName:"Start Value",enabled:!0,removable:!0,sortable:!0,movable:!0},{type:ht.END_VALUE,name:"end",displayName:"End Value",enabled:!0,removable:!0,sortable:!0,movable:!0},{type:ht.VALUE_CHANGE,name:"valueChange",displayName:"Value",enabled:!0,removable:!0,sortable:!0,movable:!0},{type:ht.PERCENTAGE_CHANGE,name:"percentageChange",displayName:"%",enabled:!0,removable:!0,sortable:!0,movable:!0},{type:ht.START_STEP,name:"startStep",displayName:"Start Step",enabled:!0,removable:!0,sortable:!0,movable:!0},{type:ht.END_STEP,name:"endStep",displayName:"End Step",enabled:!0,removable:!0,sortable:!0,movable:!0},{type:ht.STEP_AT_MAX,name:"stepAtMax",displayName:"Step At Max",enabled:!1,removable:!0,sortable:!0,movable:!0},{type:ht.STEP_AT_MIN,name:"stepAtMin",displayName:"Step At Min",enabled:!1,removable:!0,sortable:!0,movable:!0},{type:ht.MEAN,name:"mean",displayName:"Mean",enabled:!1,removable:!0,sortable:!0,movable:!0},{type:ht.RAW_CHANGE,name:"rawChange",displayName:"Raw",enabled:!1,removable:!0,sortable:!0,movable:!0}],filteredPluginTypes:new Set,stepMinMax:{min:1/0,max:-1/0}},{isSettingsPaneOpen:!0,isSlideoutMenuOpen:!1,tableEditorSelectedTab:ro.SINGLE,timeSeriesData:{scalars:{},histograms:{},images:{}},settings:XS,settingOverrides:{},visibleCardMap:new Map,previousCardInteractions:{tagFilters:[],pins:[],clicks:[]},newCardInteractions:{tagFilters:[],pins:[],clicks:[]}},(n,t,e)=>Fo(t,e)?n:{...n,tagMetadataLoadState:{state:Te.NOT_LOADED,lastLoadedTimeInMs:null},tagMetadata:{scalars:{tagDescriptions:{},tagToRuns:{}},histograms:{tagDescriptions:{},tagToRuns:{}},images:{tagDescriptions:{},tagRunSampledInfo:{}}},cardList:[],cardMetadataMap:{},visibleCardMap:new Map}),TN=eQ,ASe=br(eQ,ye(Eh,(n,{routeKind:t,partialState:e})=>{if(t!==wn.EXPERIMENT&&t!==wn.COMPARE_EXPERIMENT)return n;let i=new Set;for(let d of n.pinnedCardToOriginal.keys()){let{plugin:u,tag:p,runId:f,sample:m}=n.cardMetadataMap[d];i.add(JX(u,p,f,m))}let r=e,o=[];for(let d of[...n.unresolvedImportedPinnedCards,...r.metrics.pinnedCards]){let u=JX(d.plugin,d.tag,d.runId,d.sample);i.has(u)||(i.add(u),o.push(d))}let s=HF(o,n.cardList,n.cardMetadataMap,n.cardToPinnedCopy,n.cardToPinnedCopyCache,n.pinnedCardToOriginal,n.cardStepIndex,n.cardStateMap),a=r.metrics.smoothing,l=n.settingOverrides;if(Number.isFinite(a)&&null!==a){let d=Math.max(0,Math.min(.999,Number(a.toPrecision(3))));l={...n.settingOverrides,scalarSmoothing:d}}let c={...n,...s,settingOverrides:l};return null!==r.metrics.tagFilter&&(c.tagFilter=r.metrics.tagFilter),c}),ye(Il,(n,{partialSettings:t})=>{let e={};t.tooltipSort&&Object.values(oo).includes(t.tooltipSort)&&(e.tooltipSort=t.tooltipSort),"number"==typeof t.timeSeriesCardMinWidth&&(e.cardMinWidth=t.timeSeriesCardMinWidth),"boolean"==typeof t.ignoreOutliers&&(e.ignoreOutliers=t.ignoreOutliers),"number"==typeof t.scalarSmoothing&&(e.scalarSmoothing=t.scalarSmoothing);let i=t.timeSeriesSettingsPaneOpened??n.isSettingsPaneOpen,r=t.stepSelectorEnabled??n.stepSelectorEnabled,o=t.rangeSelectionEnabled??n.rangeSelectionEnabled,s=t.linkedTimeEnabled??n.linkedTimeEnabled,a=t.singleSelectionHeaders??n.singleSelectionHeaders,l=t.rangeSelectionHeaders??n.rangeSelectionHeaders;return{...n,isSettingsPaneOpen:i,stepSelectorEnabled:r,rangeSelectionEnabled:o,linkedTimeEnabled:s,singleSelectionHeaders:a,rangeSelectionHeaders:l,settings:{...n.settings,...e}}}),ye(cs,Fs,n=>{let t=n.tagMetadataLoadState.state===Te.LOADING?Te.LOADING:Te.NOT_LOADED,e=vy(n.timeSeriesData,(i,r)=>vy(i,o=>ua(r)?vy(o,s=>KX(s)):KX(o)));return{...n,tagMetadataLoadState:{...n.tagMetadataLoadState,state:t},timeSeriesData:e}}),ye(dT,n=>({...n,tagMetadataLoadState:{...n.tagMetadataLoadState,state:Te.LOADING}})),ye(pT,n=>({...n,tagMetadataLoadState:{...n.tagMetadataLoadState,state:Te.FAILED}})),ye(uT,(n,{tagMetadata:t})=>{let e={scalars:$X(t,zn.SCALARS),histograms:$X(t,zn.HISTOGRAMS),images:t[zn.IMAGES]},i={},r=function(n){let t=[];for(let e of Object.keys(n)){let r,i=e;if(ua(i)){if(!pa(i))throw new Error("Multi-run, sampled plugin support not yet implemented");{let o=n[i].tagRunSampledInfo;for(let s of Object.keys(o))for(let a of Object.keys(o[s])){let{maxSamplesPerStep:l}=o[s][a];for(let c=0;c<l;c++)t.push({plugin:i,tag:s,runId:a,sample:c,numSample:l})}}}else if(pa(i)){r=n[i].tagToRuns;for(let o of Object.keys(r))for(let s of r[o])t.push({plugin:i,tag:o,runId:s})}else{r=n[i].tagToRuns;for(let o of Object.keys(r))t.push({plugin:i,tag:o,runId:null})}}return t}(e),o=[];for(let f of r){let m=VF(f);i[m]=f,o.push(m)}let s=n.tagGroupExpanded;if(0===n.tagGroupExpanded.size){let m=LT(o.map(b=>({...i[b],cardId:b})).filter(Boolean));s=new Map(n.tagGroupExpanded);for(let b of m.slice(0,2))s.set(b.groupName,!0)}let{nextCardToPinnedCopy:a,nextPinnedCardToOriginal:l,pinnedCardMetadataMap:c}=function(n,t,e){let i=new Map,r=new Map,o={};return n.forEach((s,a)=>{-1!==e.indexOf(a)&&(i.set(a,s),r.set(s,a),o[s]=t[a])}),{nextCardToPinnedCopy:i,nextPinnedCardToOriginal:r,pinnedCardMetadataMap:o}}(n.cardToPinnedCopyCache,i,o),d={...i,...c},u=function(n,t){let e={};return Object.entries(n).forEach(([i,r])=>{t[i]&&(e[i]=r)}),e}(n.cardStepIndex,d),p=HF(n.unresolvedImportedPinnedCards,o,d,a,n.cardToPinnedCopyCache,l,u,n.cardStateMap);return{...n,...p,tagGroupExpanded:s,tagMetadataLoadState:{state:Te.LOADED,lastLoadedTimeInMs:Date.now()},tagMetadata:e,cardList:o}}),ye(fT,(n,{cardId:t,settings:e})=>{let i={...n.cardStateMap};return i[t]={...i[t],...e},{...n,cardStateMap:i}}),ye(Bg,(n,{cardId:t})=>{let e={...n.cardStateMap};return e[t]={...e[t],fullWidth:!e[t]?.fullWidth,tableExpanded:!e[t]?.fullWidth},{...n,cardStateMap:e}}),ye(RT,(n,{tagFilter:t})=>({...n,tagFilter:t})),ye(mT,(n,{sort:t})=>({...n,settingOverrides:{...n.settingOverrides,tooltipSort:t}})),ye(hT,n=>{let t=!(n.settingOverrides.ignoreOutliers??n.settings.ignoreOutliers);return{...n,settingOverrides:{...n.settingOverrides,ignoreOutliers:t}}}),ye(gT,(n,{xAxisType:t})=>({...n,settingOverrides:{...n.settingOverrides,xAxisType:t}})),ye(vT,(n,{smoothing:t})=>({...n,settingOverrides:{...n.settingOverrides,scalarSmoothing:t}})),ye(yT,n=>{let t=!(n.settingOverrides.scalarPartitionNonMonotonicX??n.settings.scalarPartitionNonMonotonicX);return{...n,settingOverrides:{...n.settingOverrides,scalarPartitionNonMonotonicX:t}}}),ye(xT,(n,{brightnessInMilli:t})=>({...n,settingOverrides:{...n.settingOverrides,imageBrightnessInMilli:t}})),ye(CT,(n,{contrastInMilli:t})=>({...n,settingOverrides:{...n.settingOverrides,imageContrastInMilli:t}})),ye(MT,n=>{let{imageBrightnessInMilli:t,...e}=n.settingOverrides;return{...n,settingOverrides:e}}),ye(wT,n=>{let{imageContrastInMilli:t,...e}=n.settingOverrides;return{...n,settingOverrides:e}}),ye(ST,n=>{let t=!(n.settingOverrides.imageShowActualSize??n.settings.imageShowActualSize);return{...n,settingOverrides:{...n.settingOverrides,imageShowActualSize:t}}}),ye(ET,(n,{histogramMode:t})=>({...n,settingOverrides:{...n.settingOverrides,histogramMode:t}})),ye(_T,(n,{cardMinWidth:t})=>({...n,settingOverrides:{...n.settingOverrides,cardMinWidth:t}})),ye(bT,n=>({...n,settingOverrides:{...n.settingOverrides,cardMinWidth:null}})),ye(QX,n=>({...n,settingOverrides:{...n.settingOverrides,hideEmptyCards:!n.settingOverrides.hideEmptyCards}})),ye(TT,(n,{requests:t})=>{if(!t.length)return n;let e={...n.timeSeriesData};for(let i of t){let{plugin:r,tag:o,sample:s}=i;e[r]=QS(e,r,o,s);let a=gd(e,r,o,s),l=PF(i)?[i.runId]:qh(n.tagMetadata,r,o,s);a.runToLoadState=ZS(Te.LOADING,l,a.runToLoadState)}return{...n,timeSeriesData:e}}),ye(DT,(n,{request:t})=>{let e={...n.timeSeriesData},{plugin:i,tag:r,sample:o}=t;e[i]=QS(e,i,r,o);let s=gd(e,i,r,o),a=PF(t)?[t.runId]:qh(n.tagMetadata,i,r,o);return s.runToLoadState=ZS(Te.FAILED,a,s.runToLoadState),{...n,timeSeriesData:e}}),ye(IT,(n,{response:t})=>{let e={...n.stepMinMax},i={...n.cardStateMap},r={...n.timeSeriesData},{plugin:o,tag:s,runId:a,sample:l}=t;r[o]=QS(r,o,s,l);let c=gd(r,o,s,l);if(US(t)){let u=a?[a]:qh(n.tagMetadata,o,s,l);c.runToLoadState=ZS(Te.FAILED,u,c.runToLoadState)}else{let u=t.runToSeries;c.runToSeries={...c.runToSeries},c.runToLoadState={...c.runToLoadState};for(let p in u)if(u.hasOwnProperty(p)){c.runToSeries[p]=u[p],c.runToLoadState[p]=Te.LOADED;for(let f of u[p])e.min=Math.min(e.min,f.step),e.max=Math.max(e.max,f.step)}}if(t.runToSeries&&t.plugin===zn.SCALARS){let u=VF({plugin:o,tag:s,runId:null}),p=function(n){let t=1/0,e=-1/0;return Object.values(n).flat().forEach(i=>{t=Math.min(t,i.step),e=Math.max(e,i.step)}),{minStep:t,maxStep:e}}(c.runToSeries);i[u]={...i[u],dataMinMax:p};let f=n.cardToPinnedCopy.get(u);f&&(i[f]={...i[f],dataMinMax:p})}return{...n,timeSeriesData:r,cardStepIndex:DSe(n.cardMetadataMap,n.cardStepIndex,r,n.timeSeriesData),stepMinMax:e,cardStateMap:i}}),ye(AT,(n,{cardId:t,stepIndex:e})=>{let i=EN(t,n.cardMetadataMap,n.timeSeriesData),r=e;return null===i?r=null:e>i&&(r=i),{...n,cardStepIndex:{...n.cardStepIndex,[t]:{index:r,isClosest:!1}}}}),ye(PT,(n,{tagGroup:t})=>{let e=new Map(n.tagGroupExpanded);return e.set(t,!e.get(t)),{...n,tagGroupExpanded:e}}),ye(Vg,(n,{enteredCards:t,exitedCards:e})=>{if(!t.length&&!e.length)return n;let i=new Map(n.visibleCardMap);return t.forEach(({elementId:r,cardId:o})=>{let s=i.get(r)??null;if(null!==s&&s!==o)throw new Error("A DOM element cannot be reused for more than 1 unique card metadata");i.set(r,o)}),e.forEach(({elementId:r})=>{i.delete(r)}),{...n,visibleCardMap:i}}),ye(Hg,(n,{cardId:t})=>{let e=n.pinnedCardToOriginal.has(t),i=!e&&!n.cardToPinnedCopy.has(t);if(i&&!KS(n))return n;let r=new Map(n.cardToPinnedCopy),o=new Map(n.cardToPinnedCopyCache),s=new Map(n.pinnedCardToOriginal),a={...n.cardMetadataMap},l={...n.cardStepIndex},c={...n.cardStateMap};if(e){let d=n.pinnedCardToOriginal.get(t);r.delete(d),o.delete(d),s.delete(t),delete a[t],delete l[t],delete c[t]}else if(i){let d=zF(t,r,o,s,l,a,c);r=d.cardToPinnedCopy,o=d.cardToPinnedCopyCache,s=d.pinnedCardToOriginal,a=d.cardMetadataMap,l=d.cardStepIndex,c=d.cardStateMap}else{let d=n.cardToPinnedCopy.get(t);r.delete(t),o.delete(t),s.delete(d),delete a[d],delete l[d],delete c[t]}return{...n,cardMetadataMap:a,cardStateMap:c,cardStepIndex:l,cardToPinnedCopy:r,cardToPinnedCopyCache:o,pinnedCardToOriginal:s}}),ye(FT,n=>{let t=!n.linkedTimeEnabled,e={...n.cardStepIndex},i=n.linkedTimeSelection,r=n.stepSelectorEnabled,o=n.rangeSelectionEnabled;if(t){let{max:s}=n.stepMinMax;i=n.linkedTimeSelection??{start:{step:s===-1/0?0:s},end:null},e=UF(n.cardStepIndex,n.cardMetadataMap,n.timeSeriesData,i),r=t,o=Boolean(i.end)}return{...n,cardStepIndex:e,linkedTimeEnabled:t,linkedTimeSelection:i,stepSelectorEnabled:r,rangeSelectionEnabled:o}}),ye(NT,n=>{let t=!n.rangeSelectionEnabled,e=n.stepSelectorEnabled,i=n.linkedTimeSelection,r=Object.entries(n.cardStateMap).reduce((o,[s,a])=>(o[s]={...a,stepSelectionOverride:Ls.NONE,rangeSelectionOverride:Ls.NONE},o),{});return t?(e=t,i||(i={start:{step:n.stepMinMax.min},end:{step:n.stepMinMax.max}}),i.end||(i={start:{step:n.stepMinMax.min},end:i.start})):i&&(i={start:i.end??i.start,end:null}),{...n,stepSelectorEnabled:e,rangeSelectionEnabled:t,linkedTimeSelection:i,cardStateMap:r}}),ye(kf,(n,t)=>{let{cardId:e,timeSelection:i}=t,r=i.start.step,o=i.end?.step,a=n.rangeSelectionEnabled;n.linkedTimeEnabled&&(a=void 0!==o);let l={start:{step:r},end:void 0===o?null:{step:r>o?r:o}},c=UF(n.cardStepIndex,n.cardMetadataMap,n.timeSeriesData,l),d={...n.cardStateMap};return e&&(d[e]={...d[e],timeSelection:l,stepSelectionOverride:Ls.OVERRIDE_AS_ENABLED,rangeSelectionOverride:void 0===l.end?.step?Ls.OVERRIDE_AS_DISABLED:Ls.OVERRIDE_AS_ENABLED}),{...n,linkedTimeSelection:l,cardStepIndex:c,cardStateMap:d,rangeSelectionEnabled:a}}),ye(by,(n,{cardId:t,userViewBox:e})=>{let i={...n.cardStateMap};return i[t]={...i[t],userViewBox:e},{...n,cardStateMap:i}}),ye(Id,(n,{affordance:t,cardId:e})=>{let i={...n.cardStateMap};if(e){let{timeSelection:a,...l}=i[e]||{};i[e]={...l,stepSelectionOverride:Ls.OVERRIDE_AS_DISABLED}}else Object.keys(i).forEach(a=>{i[a]={...i[a],stepSelectionOverride:Ls.NONE}});if(!n.linkedTimeEnabled&&t!==Ys.CHECK_BOX)return{...n,cardStateMap:i};let r=!n.stepSelectorEnabled,o=r&&n.linkedTimeEnabled,s=r&&n.rangeSelectionEnabled;return{...n,linkedTimeEnabled:o,stepSelectorEnabled:r,rangeSelectionEnabled:s,cardStateMap:i}}),ye(lT,(n,{tab:t})=>({...n,tableEditorSelectedTab:t})),ye(zg,(n,{dataTableMode:t,headers:e})=>{let i=[],r=[];return e.forEach(o=>{o.enabled?i.push(o):r.push(o)}),t===ro.RANGE?{...n,rangeSelectionHeaders:i.concat(r)}:{...n,singleSelectionHeaders:i.concat(r)}}),ye(Ug,(n,{dataTableMode:t,header:e,cardId:i})=>{let{cardStateMap:r,rangeSelectionEnabled:o,linkedTimeEnabled:s}=n,a=i?$S(r,o,s,i):t===ro.RANGE,l=a?n.rangeSelectionHeaders:n.singleSelectionHeaders,c=l.findIndex(p=>p.name===e.name),d=function(n){let t=0;return n.forEach(e=>{e.enabled&&t++}),t}(l);l[c].enabled&&d--;let u=function(n,t,e){let i=[...e];return i.splice(n,1),i.splice(t,0,e[n]),i}(c,d,l);return u[d]={...u[d],enabled:!u[d].enabled},a?{...n,rangeSelectionHeaders:u}:{...n,singleSelectionHeaders:u}}),ye(OT,(n,{plugin:t})=>{let e=new Set(n.filteredPluginTypes);return e.has(t)?e.delete(t):e.add(t),Object.values(zn).every(i=>e.has(i))&&(e=new Set),{...n,filteredPluginTypes:e}}),ye(kT,n=>({...n,filteredPluginTypes:new Set})),ye(oT,n=>({...n,isSettingsPaneOpen:!n.isSettingsPaneOpen})),ye(rT,n=>({...n,isSettingsPaneOpen:!1})),ye(sT,n=>({...n,isSlideoutMenuOpen:!n.isSlideoutMenuOpen})),ye(aT,(n,{mode:t})=>({...n,isSlideoutMenuOpen:!0,isSettingsPaneOpen:!0,tableEditorSelectedTab:t})),ye(cT,n=>({...n,isSlideoutMenuOpen:!1})));function tQ(n,t){return pf(ASe,ISe)(n,t)}function $X(n,t){return{tagDescriptions:n[t].tagDescriptions,tagToRuns:RSe(n[t].runTagInfo)}}function RSe(n){let t={};for(let e in n)for(let i of n[e])t[i]=[...t[i]||[],e];return t}var kSe=q(_d,Wa,(n,t,e)=>t?{...t,loadState:n,id:e}:null),nQ=_e("[Metrics Effects] Init"),iQ=(()=>{class n{constructor(e,i,r){this.actions$=e,this.store=i,this.dataSource=r,this.dashboardShownWithoutData$=this.actions$.pipe(ei(nQ,wc,df,Ps),Bt(this.store.select(Wo),this.store.select(vv)),ke(([,o,s])=>o===gv&&s.state===Te.NOT_LOADED)),this.reloadRequestedWhileShown$=this.actions$.pipe(ei(cs,Fs),Bt(this.store.select(Wo)),ke(([,o])=>o===gv)),this.loadTagMetadata$=tn(this.dashboardShownWithoutData$,this.reloadRequestedWhileShown$).pipe(Bt(this.store.select(vv),this.store.select(lr)),ke(([,o,s])=>o.state!==Te.LOADING&&null!==s),ac(10),Nt(()=>{this.store.dispatch(dT())}),Jn(([,,o])=>this.dataSource.fetchTagMetadata(o).pipe(Nt(s=>{this.store.dispatch(uT({tagMetadata:s}))}),zr(()=>(this.store.dispatch(pT()),Ht(null)))))),this.visibleCardsWithoutDataChanged$=this.actions$.pipe(ei(Vg),Bt(this.getVisibleCardFetchInfos()),N(([,o])=>o.filter(s=>s.loadState===Te.NOT_LOADED))),this.visibleCardsReloaded$=this.reloadRequestedWhileShown$.pipe(Bt(this.getVisibleCardFetchInfos()),N(([,o])=>o.filter(s=>s.loadState!==Te.LOADING))),this.loadTimeSeries$=tn(this.visibleCardsWithoutDataChanged$,this.visibleCardsReloaded$).pipe(ke(o=>o.length>0),Bt(this.store.select(lr).pipe(ke(o=>null!==o))),hn(([o,s])=>this.fetchTimeSeriesForCards(o,s))),this.dataEffects$=ar(()=>tn(this.loadTagMetadata$,this.loadTimeSeries$),{dispatch:!1})}ngrxOnInitEffects(){return nQ()}getVisibleCardFetchInfos(){return this.store.select(bW).pipe(Jn(i=>i.size?co([...i].map(o=>this.store.select(kSe,o).pipe(Yt(1)))):Ht([])),N(i=>i.filter(Boolean)))}fetchTimeSeries(e){return this.dataSource.fetchTimeSeries([e]).pipe(Nt(i=>{let r=i.filter(US);r.length&&console.error("Time series response contained errors:",r),this.store.dispatch(IT({response:i[0]}))}),zr(()=>(this.store.dispatch(DT({request:e})),Ht(null))))}fetchTimeSeriesForCards(e,i){return Ht(e.map(o=>{let{plugin:s,tag:a,runId:l,sample:c}=o,d=pa(s)?{plugin:s,tag:a,runId:l}:{plugin:s,tag:a,experimentIds:i};return void 0!==c&&(d.sample=c),d})).pipe(Nt(o=>{this.store.dispatch(TT({requests:o}))}),hn(o=>tn(...o.map(a=>this.fetchTimeSeries(a)))))}}return n.\u0275fac=function(e){return new(e||n)(k(xo),k(Ae),k(Tc))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),DN=new ie("Metrics Store Config"),IN=new ie("Metrics Initial Settings Config");function rQ(n){return n?{initialState:{...TN,settings:n}}:{initialState:TN}}var ga=(()=>(function(n){n[n.LEFT=1]="LEFT",n[n.RIGHT=2]="RIGHT",n[n.MIDDLE=4]="MIDDLE",n[n.FOURTH=8]="FOURTH",n[n.FIFTH=32]="FIFTH"}(ga||(ga={})),ga))(),oQ=0;function FSe(n,t){if(1&n){let e=ge();h(0,"button",3),I("click",function(){return X(e),Q(w().expandSidebar())}),P(1,"mat-icon",4),g()}}function NSe(n,t){if(1&n&&(h(0,"nav",5),j(1,"async"),j(2,"async"),zt(3,1),g()),2&n){let e=w();Tt("width",W(1,6,e.width$),"%")("min-width",e.MINIMUM_SIDEBAR_WIDTH_IN_PX,"px")("max-width",W(2,8,e.runsTableFullScreen$)?100:"","%")}}function LSe(n,t){if(1&n){let e=ge();h(0,"div",6),I("mousedown",function(){return X(e),Q(w().resizeGrabbed())}),g()}}var BSe=[[["","main",""]],[["","sidebar",""]]],VSe=["[main]","[sidebar]"],aQ=(()=>{class n{constructor(e,i){this.store=e,this.runsTableFullScreen$=this.store.select(Lh),this.width$=this.store.select(CS).pipe(Li(this.runsTableFullScreen$),N(([r,o])=>o?100:r)),this.ngUnsubscribe=new Ie,this.resizing=!1,this.MINIMUM_SIDEBAR_WIDTH_IN_PX=75,mi(i.nativeElement,"mousemove").pipe(ot(this.ngUnsubscribe),ke(()=>this.resizing)).subscribe(r=>{if((r.buttons&ga.LEFT)!==ga.LEFT)return void(this.resizing=!1);r.preventDefault();let{width:o}=i.nativeElement.getBoundingClientRect();this.store.dispatch(kh({widthInPercent:r.clientX<=this.MINIMUM_SIDEBAR_WIDTH_IN_PX?0:r.clientX/o*100}))}),mi(i.nativeElement,"mouseup",{passive:!0}).pipe(ot(this.ngUnsubscribe)).subscribe(()=>{this.resizing=!1})}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}resizeGrabbed(){this.resizing=!0}expandSidebar(){this.store.dispatch(kh({widthInPercent:20}))}}return n.\u0275fac=function(e){return new(e||n)(C(Ae),C(Me))},n.\u0275cmp=O({type:n,selectors:[["tb-dashboard-layout"]],ngContentSelectors:VSe,decls:7,vars:9,consts:[["class","expand",3,"click",4,"ngIf"],["class","sidebar",3,"width","minWidth","maxWidth",4,"ngIf"],["class","resizer",3,"mousedown",4,"ngIf"],[1,"expand",3,"click"],["svgIcon","expand_more_24px"],[1,"sidebar"],[1,"resizer",3,"mousedown"]],template:function(e,i){1&e&&(Dn(BSe),S(0,FSe,2,0,"button",0),j(1,"async"),S(2,NSe,4,10,"nav",1),j(3,"async"),S(4,LSe,1,0,"div",2),j(5,"async"),zt(6)),2&e&&(_("ngIf",0===W(1,3,i.width$)),v(2),_("ngIf",W(3,5,i.width$)>0),v(2),_("ngIf",W(5,7,i.width$)>0))},dependencies:[Fe,En,ct],styles:["[_nghost-%COMP%]{display:flex;flex-direction:row;height:100%;width:100%;position:relative}.sidebar[_ngcontent-%COMP%]{max-width:80vw}.resizer[_ngcontent-%COMP%], .expand[_ngcontent-%COMP%]{border-color:#ebebeb;box-sizing:border-box;flex:0 0;justify-self:stretch}body.dark-mode[_nghost-%COMP%]   .resizer[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .resizer[_ngcontent-%COMP%]{border-color:#555}body.dark-mode[_nghost-%COMP%]   .expand[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .expand[_ngcontent-%COMP%]{border-color:#555}.expand[_ngcontent-%COMP%]{width:20px}.resizer[_ngcontent-%COMP%]{align-items:center;border-style:solid;border-width:0 2px;cursor:ew-resize;contain:strict;display:flex;justify-self:stretch}.resizer[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{width:100%}.resizer[_ngcontent-%COMP%]:hover{border-color:#ccc;outline:3px solid #ccc;z-index:1}body.dark-mode[_nghost-%COMP%]   .resizer[_ngcontent-%COMP%]:hover, body.dark-mode   [_nghost-%COMP%]   .resizer[_ngcontent-%COMP%]:hover{outline-color:#777;border-color:#777}.expand[_ngcontent-%COMP%]{align-items:center;background:rgba(0,0,0,0);border-style:solid;border-width:0 1px 0 0;color:inherit;contain:content;cursor:pointer;display:flex;justify-self:stretch;padding:0}.expand[_ngcontent-%COMP%]   mat-icon[_ngcontent-%COMP%]{transform:rotate(-90deg);transform-origin:center}"],changeDetection:0}),n})(),AN=new WeakMap,xy=class{constructor(t,e){this.root=t,this.buffer=e,this.destroyedTargets=new WeakSet}initialize(t){if(this.intersectionObserver)return;this.intersectionCallback=t;let e={threshold:0,root:this.root??null};this.buffer&&(e.rootMargin=this.buffer),this.intersectionObserver=new IntersectionObserver(this.onCardIntersection.bind(this),e)}add(t){this.ensureInitialized()&&this.intersectionObserver.observe(t)}willDestroy(t){this.ensureInitialized()&&this.destroyedTargets.add(t)}ensureInitialized(){if(!this.intersectionObserver)throw new Error("CardObserver must be initialized before use");return!0}onCardIntersection(t){t.sort((r,o)=>r.time-o.time);let e=new Set,i=new Set;for(let{isIntersecting:r,target:o}of t)r?(e.add(o),i.delete(o)):(e.delete(o),i.add(o)),this.destroyedTargets.has(o)&&!r&&(this.destroyedTargets.delete(o),this.intersectionObserver.unobserve(o));this.intersectionCallback(e,i)}onCardIntersectionForTest(t){this.onCardIntersection(t)}},lQ=(()=>{class n{constructor(e,i){this.host=e,this.store=i}onCardIntersection(e,i){let r=[...e].map(s=>{let a=AN.get(s);if(!a)throw new Error("A CardObserver element must have an associated element id and card id.");return{elementId:a.elementId,cardId:a.cardId}}),o=[...i].map(s=>{let a=AN.get(s);if(!a)throw new Error("A CardObserver element must have an associated element id and card id.");return{elementId:a.elementId,cardId:a.cardId}});this.store.dispatch(Vg({enteredCards:r,exitedCards:o}))}ngOnInit(){let e=this.host.nativeElement;AN.set(e,{elementId:(oQ++,Symbol(oQ)),cardId:this.cardId}),this.cardObserver||(this.cardObserver=new xy),this.cardObserver.initialize(this.onCardIntersection.bind(this)),this.cardObserver.add(e)}ngOnDestroy(){this.cardObserver&&this.cardObserver.willDestroy(this.host.nativeElement)}hostForTest(){return this.host}}return n.\u0275fac=function(e){return new(e||n)(C(Me),C(Ae))},n.\u0275dir=we({type:n,selectors:[["","cardLazyLoader",""]],inputs:{cardId:["cardLazyLoader","cardId"],cardObserver:"cardObserver"}}),n})();function USe(n,t){1&n&&(Ot(0),zt(1),kt())}var jSe=["*"],cQ=(()=>{class n{constructor(e,i){this.viewContainerRef=e,this.componentFactoryResolver=i}ngOnInit(){if(this.customizableComponent){let e=this.componentFactoryResolver.resolveComponentFactory(this.customizableComponent.constructor);this.viewContainerRef.createComponent(e)}}}return n.\u0275fac=function(e){return new(e||n)(C(si),C(fo))},n.\u0275cmp=O({type:n,selectors:[["tb-customization"]],inputs:{customizableComponent:"customizableComponent"},ngContentSelectors:jSe,decls:1,vars:1,consts:[[4,"ngIf"]],template:function(e,i){1&e&&(Dn(),S(0,USe,2,0,"ng-container",0)),2&e&&_("ngIf",!i.customizableComponent)},dependencies:[Fe],encapsulation:2}),n})(),WSe=["button"],qSe=["*"],dQ=new ie("MAT_BUTTON_TOGGLE_DEFAULT_OPTIONS"),uQ=new ie("MatButtonToggleGroup"),YSe={provide:Mo,useExisting:$n(()=>RN),multi:!0},pQ=0,BT=class{constructor(t,e){this.source=t,this.value=e}},RN=(()=>{class n{get name(){return this._name}set name(e){this._name=e,this._markButtonsForCheck()}get vertical(){return this._vertical}set vertical(e){this._vertical=Rt(e)}get value(){let e=this._selectionModel?this._selectionModel.selected:[];return this.multiple?e.map(i=>i.value):e[0]?e[0].value:void 0}set value(e){this._setSelectionByValue(e),this.valueChange.emit(this.value)}get selected(){let e=this._selectionModel?this._selectionModel.selected:[];return this.multiple?e:e[0]||null}get multiple(){return this._multiple}set multiple(e){this._multiple=Rt(e),this._markButtonsForCheck()}get disabled(){return this._disabled}set disabled(e){this._disabled=Rt(e),this._markButtonsForCheck()}constructor(e,i){this._changeDetector=e,this._vertical=!1,this._multiple=!1,this._disabled=!1,this._controlValueAccessorChangeFn=()=>{},this._onTouched=()=>{},this._name="mat-button-toggle-group-"+pQ++,this.valueChange=new F,this.change=new F,this.appearance=i&&i.appearance?i.appearance:"standard"}ngOnInit(){this._selectionModel=new dg(this.multiple,void 0,!1)}ngAfterContentInit(){this._selectionModel.select(...this._buttonToggles.filter(e=>e.checked))}writeValue(e){this.value=e,this._changeDetector.markForCheck()}registerOnChange(e){this._controlValueAccessorChangeFn=e}registerOnTouched(e){this._onTouched=e}setDisabledState(e){this.disabled=e}_emitChangeEvent(e){let i=new BT(e,this.value);this._controlValueAccessorChangeFn(i.value),this.change.emit(i)}_syncButtonToggle(e,i,r=!1,o=!1){!this.multiple&&this.selected&&!e.checked&&(this.selected.checked=!1),this._selectionModel?i?this._selectionModel.select(e):this._selectionModel.deselect(e):o=!0,o?Promise.resolve().then(()=>this._updateModelValue(e,r)):this._updateModelValue(e,r)}_isSelected(e){return this._selectionModel&&this._selectionModel.isSelected(e)}_isPrechecked(e){return!(typeof this._rawValue>"u")&&(this.multiple&&Array.isArray(this._rawValue)?this._rawValue.some(i=>null!=e.value&&i===e.value):e.value===this._rawValue)}_setSelectionByValue(e){this._rawValue=e,this._buttonToggles&&(this.multiple&&e?(Array.isArray(e),this._clearSelection(),e.forEach(i=>this._selectValue(i))):(this._clearSelection(),this._selectValue(e)))}_clearSelection(){this._selectionModel.clear(),this._buttonToggles.forEach(e=>e.checked=!1)}_selectValue(e){let i=this._buttonToggles.find(r=>null!=r.value&&r.value===e);i&&(i.checked=!0,this._selectionModel.select(i))}_updateModelValue(e,i){i&&this._emitChangeEvent(e),this.valueChange.emit(this.value)}_markButtonsForCheck(){this._buttonToggles?.forEach(e=>e._markForCheck())}}return n.\u0275fac=function(e){return new(e||n)(C($t),C(dQ,8))},n.\u0275dir=we({type:n,selectors:[["mat-button-toggle-group"]],contentQueries:function(e,i,r){if(1&e&&Ti(r,QSe,5),2&e){let o;Se(o=Ee())&&(i._buttonToggles=o)}},hostAttrs:["role","group",1,"mat-button-toggle-group"],hostVars:5,hostBindings:function(e,i){2&e&&(Be("aria-disabled",i.disabled),nt("mat-button-toggle-vertical",i.vertical)("mat-button-toggle-group-appearance-standard","standard"===i.appearance))},inputs:{appearance:"appearance",name:"name",vertical:"vertical",value:"value",multiple:"multiple",disabled:"disabled"},outputs:{valueChange:"valueChange",change:"change"},exportAs:["matButtonToggleGroup"],features:[Qt([YSe,{provide:uQ,useExisting:n}])]}),n})(),XSe=us(class{}),QSe=(()=>{class n extends XSe{get buttonId(){return`${this.id}-button`}get appearance(){return this.buttonToggleGroup?this.buttonToggleGroup.appearance:this._appearance}set appearance(e){this._appearance=e}get checked(){return this.buttonToggleGroup?this.buttonToggleGroup._isSelected(this):this._checked}set checked(e){let i=Rt(e);i!==this._checked&&(this._checked=i,this.buttonToggleGroup&&this.buttonToggleGroup._syncButtonToggle(this,this._checked),this._changeDetectorRef.markForCheck())}get disabled(){return this._disabled||this.buttonToggleGroup&&this.buttonToggleGroup.disabled}set disabled(e){this._disabled=Rt(e)}constructor(e,i,r,o,s,a){super(),this._changeDetectorRef=i,this._elementRef=r,this._focusMonitor=o,this._checked=!1,this.ariaLabelledby=null,this._disabled=!1,this.change=new F;let l=Number(s);this.tabIndex=l||0===l?l:null,this.buttonToggleGroup=e,this.appearance=a&&a.appearance?a.appearance:"standard"}ngOnInit(){let e=this.buttonToggleGroup;this.id=this.id||"mat-button-toggle-"+pQ++,e&&(e._isPrechecked(this)?this.checked=!0:e._isSelected(this)!==this._checked&&e._syncButtonToggle(this,this._checked))}ngAfterViewInit(){this._focusMonitor.monitor(this._elementRef,!0)}ngOnDestroy(){let e=this.buttonToggleGroup;this._focusMonitor.stopMonitoring(this._elementRef),e&&e._isSelected(this)&&e._syncButtonToggle(this,!1,!1,!0)}focus(e){this._buttonElement.nativeElement.focus(e)}_onButtonClick(){let e=!!this._isSingleSelector()||!this._checked;e!==this._checked&&(this._checked=e,this.buttonToggleGroup&&(this.buttonToggleGroup._syncButtonToggle(this,this._checked,!0),this.buttonToggleGroup._onTouched())),this.change.emit(new BT(this,this.value))}_markForCheck(){this._changeDetectorRef.markForCheck()}_getButtonName(){return this._isSingleSelector()?this.buttonToggleGroup.name:this.name||null}_isSingleSelector(){return this.buttonToggleGroup&&!this.buttonToggleGroup.multiple}}return n.\u0275fac=function(e){return new(e||n)(C(uQ,8),C($t),C(Me),C(Xr),yo("tabindex"),C(dQ,8))},n.\u0275cmp=O({type:n,selectors:[["mat-button-toggle"]],viewQuery:function(e,i){if(1&e&&Ge(WSe,5),2&e){let r;Se(r=Ee())&&(i._buttonElement=r.first)}},hostAttrs:["role","presentation",1,"mat-button-toggle"],hostVars:12,hostBindings:function(e,i){1&e&&I("focus",function(){return i.focus()}),2&e&&(Be("aria-label",null)("aria-labelledby",null)("id",i.id)("name",null),nt("mat-button-toggle-standalone",!i.buttonToggleGroup)("mat-button-toggle-checked",i.checked)("mat-button-toggle-disabled",i.disabled)("mat-button-toggle-appearance-standard","standard"===i.appearance))},inputs:{disableRipple:"disableRipple",ariaLabel:["aria-label","ariaLabel"],ariaLabelledby:["aria-labelledby","ariaLabelledby"],id:"id",name:"name",value:"value",tabIndex:"tabIndex",appearance:"appearance",checked:"checked",disabled:"disabled"},outputs:{change:"change"},exportAs:["matButtonToggle"],features:[Ke],ngContentSelectors:qSe,decls:6,vars:9,consts:[["type","button",1,"mat-button-toggle-button","mat-focus-indicator",3,"id","disabled","click"],["button",""],[1,"mat-button-toggle-label-content"],[1,"mat-button-toggle-focus-overlay"],["matRipple","",1,"mat-button-toggle-ripple",3,"matRippleTrigger","matRippleDisabled"]],template:function(e,i){if(1&e&&(Dn(),h(0,"button",0,1),I("click",function(){return i._onButtonClick()}),h(2,"span",2),zt(3),g()(),P(4,"span",3)(5,"span",4)),2&e){let r=it(1);_("id",i.buttonId)("disabled",i.disabled||null),Be("tabindex",i.disabled?-1:i.tabIndex)("aria-pressed",i.checked)("name",i._getButtonName())("aria-label",i.ariaLabel)("aria-labelledby",i.ariaLabelledby),v(5),_("matRippleTrigger",r)("matRippleDisabled",i.disableRipple||i.disabled)}},dependencies:[mo],styles:[".mat-button-toggle-standalone,.mat-button-toggle-group{position:relative;display:inline-flex;flex-direction:row;white-space:nowrap;overflow:hidden;border-radius:2px;-webkit-tap-highlight-color:rgba(0,0,0,0);transform:translateZ(0)}.cdk-high-contrast-active .mat-button-toggle-standalone,.cdk-high-contrast-active .mat-button-toggle-group{outline:solid 1px}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard,.mat-button-toggle-group-appearance-standard{border-radius:4px}.cdk-high-contrast-active .mat-button-toggle-standalone.mat-button-toggle-appearance-standard,.cdk-high-contrast-active .mat-button-toggle-group-appearance-standard{outline:0}.mat-button-toggle-vertical{flex-direction:column}.mat-button-toggle-vertical .mat-button-toggle-label-content{display:block}.mat-button-toggle{white-space:nowrap;position:relative}.mat-button-toggle .mat-icon svg{vertical-align:top}.mat-button-toggle.cdk-keyboard-focused .mat-button-toggle-focus-overlay{opacity:1}.mat-button-toggle-appearance-standard:not(.mat-button-toggle-disabled):hover .mat-button-toggle-focus-overlay{opacity:.04}.mat-button-toggle-appearance-standard.cdk-keyboard-focused:not(.mat-button-toggle-disabled) .mat-button-toggle-focus-overlay{opacity:.12}@media(hover: none){.mat-button-toggle-appearance-standard:not(.mat-button-toggle-disabled):hover .mat-button-toggle-focus-overlay{display:none}}.mat-button-toggle-label-content{-webkit-user-select:none;user-select:none;display:inline-block;line-height:36px;padding:0 16px;position:relative}.mat-button-toggle-appearance-standard .mat-button-toggle-label-content{padding:0 12px}.mat-button-toggle-label-content>*{vertical-align:middle}.mat-button-toggle-focus-overlay{top:0;left:0;right:0;bottom:0;position:absolute;border-radius:inherit;pointer-events:none;opacity:0}.cdk-high-contrast-active .mat-button-toggle-checked .mat-button-toggle-focus-overlay{border-bottom:solid 36px;opacity:.5;height:0}.cdk-high-contrast-active .mat-button-toggle-checked:hover .mat-button-toggle-focus-overlay{opacity:.6}.cdk-high-contrast-active .mat-button-toggle-checked.mat-button-toggle-appearance-standard .mat-button-toggle-focus-overlay{border-bottom:solid 500px}.mat-button-toggle .mat-button-toggle-ripple{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none}.mat-button-toggle-button{border:0;background:none;color:inherit;padding:0;margin:0;font:inherit;outline:none;width:100%;cursor:pointer}.mat-button-toggle-disabled .mat-button-toggle-button{cursor:default}.mat-button-toggle-button::-moz-focus-inner{border:0}"],encapsulation:2,changeDetection:0}),n})(),VT=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[fn,Bl,fn]}),n})(),KSe=["determinateSpinner"];function JSe(n,t){if(1&n&&(Nn(),h(0,"svg",11),P(1,"circle",12),g()),2&n){let e=w();Be("viewBox",e._viewBox()),v(1),Tt("stroke-dasharray",e._strokeCircumference(),"px")("stroke-dashoffset",e._strokeCircumference()/2,"px")("stroke-width",e._circleStrokeWidth(),"%"),Be("r",e._circleRadius())}}var $Se=zs(class{constructor(n){this._elementRef=n}},"primary"),e1e=new ie("mat-progress-spinner-default-options",{providedIn:"root",factory:function(){return{diameter:fQ}}}),fQ=100,tl=(()=>{class n extends $Se{constructor(e,i,r){super(e),this.mode="mat-spinner"===this._elementRef.nativeElement.nodeName.toLowerCase()?"indeterminate":"determinate",this._value=0,this._diameter=fQ,this._noopAnimations="NoopAnimations"===i&&!!r&&!r._forceAnimations,r&&(r.color&&(this.color=this.defaultColor=r.color),r.diameter&&(this.diameter=r.diameter),r.strokeWidth&&(this.strokeWidth=r.strokeWidth))}get value(){return"determinate"===this.mode?this._value:0}set value(e){this._value=Math.max(0,Math.min(100,_i(e)))}get diameter(){return this._diameter}set diameter(e){this._diameter=_i(e)}get strokeWidth(){return this._strokeWidth??this.diameter/10}set strokeWidth(e){this._strokeWidth=_i(e)}_circleRadius(){return(this.diameter-10)/2}_viewBox(){let e=2*this._circleRadius()+this.strokeWidth;return`0 0 ${e} ${e}`}_strokeCircumference(){return 2*Math.PI*this._circleRadius()}_strokeDashOffset(){return"determinate"===this.mode?this._strokeCircumference()*(100-this._value)/100:null}_circleStrokeWidth(){return this.strokeWidth/this.diameter*100}}return n.\u0275fac=function(e){return new(e||n)(C(Me),C(hi,8),C(e1e))},n.\u0275cmp=O({type:n,selectors:[["mat-progress-spinner"],["mat-spinner"]],viewQuery:function(e,i){if(1&e&&Ge(KSe,5),2&e){let r;Se(r=Ee())&&(i._determinateCircle=r.first)}},hostAttrs:["role","progressbar","tabindex","-1",1,"mat-mdc-progress-spinner","mdc-circular-progress"],hostVars:12,hostBindings:function(e,i){2&e&&(Be("aria-valuemin",0)("aria-valuemax",100)("aria-valuenow","determinate"===i.mode?i.value:null)("mode",i.mode),Tt("width",i.diameter,"px")("height",i.diameter,"px"),nt("_mat-animation-noopable",i._noopAnimations)("mdc-circular-progress--indeterminate","indeterminate"===i.mode))},inputs:{color:"color",mode:"mode",value:"value",diameter:"diameter",strokeWidth:"strokeWidth"},exportAs:["matProgressSpinner"],features:[Ke],decls:14,vars:11,consts:[["circle",""],["aria-hidden","true",1,"mdc-circular-progress__determinate-container"],["determinateSpinner",""],["xmlns","http://www.w3.org/2000/svg","focusable","false",1,"mdc-circular-progress__determinate-circle-graphic"],["cx","50%","cy","50%",1,"mdc-circular-progress__determinate-circle"],["aria-hidden","true",1,"mdc-circular-progress__indeterminate-container"],[1,"mdc-circular-progress__spinner-layer"],[1,"mdc-circular-progress__circle-clipper","mdc-circular-progress__circle-left"],[3,"ngTemplateOutlet"],[1,"mdc-circular-progress__gap-patch"],[1,"mdc-circular-progress__circle-clipper","mdc-circular-progress__circle-right"],["xmlns","http://www.w3.org/2000/svg","focusable","false",1,"mdc-circular-progress__indeterminate-circle-graphic"],["cx","50%","cy","50%"]],template:function(e,i){if(1&e&&(S(0,JSe,2,8,"ng-template",null,0,Wt),h(2,"div",1,2),Nn(),h(4,"svg",3),P(5,"circle",4),g()(),Oo(),h(6,"div",5)(7,"div",6)(8,"div",7),li(9,8),g(),h(10,"div",9),li(11,8),g(),h(12,"div",10),li(13,8),g()()()),2&e){let r=it(1);v(4),Be("viewBox",i._viewBox()),v(1),Tt("stroke-dasharray",i._strokeCircumference(),"px")("stroke-dashoffset",i._strokeDashOffset(),"px")("stroke-width",i._circleStrokeWidth(),"%"),Be("r",i._circleRadius()),v(4),_("ngTemplateOutlet",r),v(2),_("ngTemplateOutlet",r),v(2),_("ngTemplateOutlet",r)}},dependencies:[Lr],styles:["@keyframes mdc-circular-progress-container-rotate{to{transform:rotate(360deg)}}@keyframes mdc-circular-progress-spinner-layer-rotate{12.5%{transform:rotate(135deg)}25%{transform:rotate(270deg)}37.5%{transform:rotate(405deg)}50%{transform:rotate(540deg)}62.5%{transform:rotate(675deg)}75%{transform:rotate(810deg)}87.5%{transform:rotate(945deg)}100%{transform:rotate(1080deg)}}@keyframes mdc-circular-progress-color-1-fade-in-out{from{opacity:.99}25%{opacity:.99}26%{opacity:0}89%{opacity:0}90%{opacity:.99}to{opacity:.99}}@keyframes mdc-circular-progress-color-2-fade-in-out{from{opacity:0}15%{opacity:0}25%{opacity:.99}50%{opacity:.99}51%{opacity:0}to{opacity:0}}@keyframes mdc-circular-progress-color-3-fade-in-out{from{opacity:0}40%{opacity:0}50%{opacity:.99}75%{opacity:.99}76%{opacity:0}to{opacity:0}}@keyframes mdc-circular-progress-color-4-fade-in-out{from{opacity:0}65%{opacity:0}75%{opacity:.99}90%{opacity:.99}to{opacity:0}}@keyframes mdc-circular-progress-left-spin{from{transform:rotate(265deg)}50%{transform:rotate(130deg)}to{transform:rotate(265deg)}}@keyframes mdc-circular-progress-right-spin{from{transform:rotate(-265deg)}50%{transform:rotate(-130deg)}to{transform:rotate(-265deg)}}.mdc-circular-progress{display:inline-flex;position:relative;direction:ltr;line-height:0;transition:opacity 250ms 0ms cubic-bezier(0.4, 0, 0.6, 1)}.mdc-circular-progress__determinate-container,.mdc-circular-progress__indeterminate-circle-graphic,.mdc-circular-progress__indeterminate-container,.mdc-circular-progress__spinner-layer{position:absolute;width:100%;height:100%}.mdc-circular-progress__determinate-container{transform:rotate(-90deg)}.mdc-circular-progress__indeterminate-container{font-size:0;letter-spacing:0;white-space:nowrap;opacity:0}.mdc-circular-progress__determinate-circle-graphic,.mdc-circular-progress__indeterminate-circle-graphic{fill:rgba(0,0,0,0)}.mdc-circular-progress__determinate-circle{transition:stroke-dashoffset 500ms 0ms cubic-bezier(0, 0, 0.2, 1)}.mdc-circular-progress__gap-patch{position:absolute;top:0;left:47.5%;box-sizing:border-box;width:5%;height:100%;overflow:hidden}.mdc-circular-progress__gap-patch .mdc-circular-progress__indeterminate-circle-graphic{left:-900%;width:2000%;transform:rotate(180deg)}.mdc-circular-progress__circle-clipper{display:inline-flex;position:relative;width:50%;height:100%;overflow:hidden}.mdc-circular-progress__circle-clipper .mdc-circular-progress__indeterminate-circle-graphic{width:200%}.mdc-circular-progress__circle-right .mdc-circular-progress__indeterminate-circle-graphic{left:-100%}.mdc-circular-progress--indeterminate .mdc-circular-progress__determinate-container{opacity:0}.mdc-circular-progress--indeterminate .mdc-circular-progress__indeterminate-container{opacity:1}.mdc-circular-progress--indeterminate .mdc-circular-progress__indeterminate-container{animation:mdc-circular-progress-container-rotate 1568.2352941176ms linear infinite}.mdc-circular-progress--indeterminate .mdc-circular-progress__spinner-layer{animation:mdc-circular-progress-spinner-layer-rotate 5332ms cubic-bezier(0.4, 0, 0.2, 1) infinite both}.mdc-circular-progress--indeterminate .mdc-circular-progress__color-1{animation:mdc-circular-progress-spinner-layer-rotate 5332ms cubic-bezier(0.4, 0, 0.2, 1) infinite both,mdc-circular-progress-color-1-fade-in-out 5332ms cubic-bezier(0.4, 0, 0.2, 1) infinite both}.mdc-circular-progress--indeterminate .mdc-circular-progress__color-2{animation:mdc-circular-progress-spinner-layer-rotate 5332ms cubic-bezier(0.4, 0, 0.2, 1) infinite both,mdc-circular-progress-color-2-fade-in-out 5332ms cubic-bezier(0.4, 0, 0.2, 1) infinite both}.mdc-circular-progress--indeterminate .mdc-circular-progress__color-3{animation:mdc-circular-progress-spinner-layer-rotate 5332ms cubic-bezier(0.4, 0, 0.2, 1) infinite both,mdc-circular-progress-color-3-fade-in-out 5332ms cubic-bezier(0.4, 0, 0.2, 1) infinite both}.mdc-circular-progress--indeterminate .mdc-circular-progress__color-4{animation:mdc-circular-progress-spinner-layer-rotate 5332ms cubic-bezier(0.4, 0, 0.2, 1) infinite both,mdc-circular-progress-color-4-fade-in-out 5332ms cubic-bezier(0.4, 0, 0.2, 1) infinite both}.mdc-circular-progress--indeterminate .mdc-circular-progress__circle-left .mdc-circular-progress__indeterminate-circle-graphic{animation:mdc-circular-progress-left-spin 1333ms cubic-bezier(0.4, 0, 0.2, 1) infinite both}.mdc-circular-progress--indeterminate .mdc-circular-progress__circle-right .mdc-circular-progress__indeterminate-circle-graphic{animation:mdc-circular-progress-right-spin 1333ms cubic-bezier(0.4, 0, 0.2, 1) infinite both}.mdc-circular-progress--closed{opacity:0}.mat-mdc-progress-spinner{display:block;overflow:hidden;line-height:0}.mat-mdc-progress-spinner .mdc-circular-progress__determinate-circle,.mat-mdc-progress-spinner .mdc-circular-progress__indeterminate-circle-graphic{stroke:var(--mdc-circular-progress-active-indicator-color, transparent)}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mat-mdc-progress-spinner .mdc-circular-progress__determinate-circle,.mat-mdc-progress-spinner .mdc-circular-progress__indeterminate-circle-graphic{stroke:CanvasText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mat-mdc-progress-spinner .mdc-circular-progress--four-color .mdc-circular-progress__color-1 .mdc-circular-progress__indeterminate-circle-graphic{stroke:CanvasText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mat-mdc-progress-spinner .mdc-circular-progress--four-color .mdc-circular-progress__color-2 .mdc-circular-progress__indeterminate-circle-graphic{stroke:CanvasText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mat-mdc-progress-spinner .mdc-circular-progress--four-color .mdc-circular-progress__color-3 .mdc-circular-progress__indeterminate-circle-graphic{stroke:CanvasText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mat-mdc-progress-spinner .mdc-circular-progress--four-color .mdc-circular-progress__color-4 .mdc-circular-progress__indeterminate-circle-graphic{stroke:CanvasText}}.mat-mdc-progress-spinner._mat-animation-noopable,.mat-mdc-progress-spinner._mat-animation-noopable .mdc-circular-progress__determinate-circle{transition:none}.mat-mdc-progress-spinner._mat-animation-noopable .mdc-circular-progress__indeterminate-circle-graphic,.mat-mdc-progress-spinner._mat-animation-noopable .mdc-circular-progress__spinner-layer,.mat-mdc-progress-spinner._mat-animation-noopable .mdc-circular-progress__indeterminate-container{animation:none}.mat-mdc-progress-spinner._mat-animation-noopable .mdc-circular-progress__indeterminate-container circle{stroke-dasharray:0 !important}.cdk-high-contrast-active .mat-mdc-progress-spinner .mdc-circular-progress__indeterminate-circle-graphic,.cdk-high-contrast-active .mat-mdc-progress-spinner .mdc-circular-progress__determinate-circle{stroke:currentColor;stroke:CanvasText}"],encapsulation:2,changeDetection:0}),n})(),nl=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Pe,fn]}),n})();function i1e(n,t){if(1&n&&(h(0,"b"),T(1),g()),2&n){let e=w().$implicit;v(1),He("",e.displayAlias,":")}}function r1e(n,t){if(1&n&&(h(0,"mat-option",2)(1,"span",3),S(2,i1e,2,1,"b",4),T(3),g()()),2&n){let e=t.$implicit;_("value",e.value)("disabled",e.disabled),v(1),UM("title","",e.displayAlias,": ",e.displayText,""),v(1),_("ngIf",e.displayAlias),v(1),He(" ",e.displayText," ")}}var mQ=(()=>{class n{constructor(){this.value="",this.options=[],this.selectionChange=new F}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["tb-dropdown"]],inputs:{value:"value",options:"options"},outputs:{selectionChange:"selectionChange"},decls:2,vars:3,consts:[[3,"value","hideSingleSelectionIndicator","selectionChange"],[3,"value","disabled",4,"ngFor","ngForOf"],[3,"value","disabled"],[1,"option-content",3,"title"],[4,"ngIf"]],template:function(e,i){1&e&&(h(0,"mat-select",0),I("selectionChange",function(o){return i.selectionChange.emit(o.value)}),S(1,r1e,4,6,"mat-option",1),g()),2&e&&(_("value",i.value)("hideSingleSelectionIndicator",!0),v(1),_("ngForOf",i.options))},dependencies:[nn,Fe,zu,Us],styles:["mat-select[_ngcontent-%COMP%]{border:1px solid #8e98a3;border-radius:3px;box-sizing:border-box;padding:6px;font-size:12px;line-height:normal}mat-select[_ngcontent-%COMP%]     .mat-mdc-select-arrow-wrapper{height:12px}mat-select[_ngcontent-%COMP%]:focus{outline-color:-webkit-focus-ring-color;outline-style:auto}  .mat-mdc-select-panel{max-width:70vw}  mat-option.mat-mdc-option{min-height:32px;font-size:12px}"]}),n})(),s1e=function(n){return{"column-edit-menu-toggle":!0,"toggle-opened":n}};function a1e(n,t){if(1&n){let e=ge();h(0,"button",31),I("click",function(){return X(e),Q(w().onSlideOutToggled.emit())}),P(1,"mat-icon",32),T(2," Edit Table Columns "),g()}if(2&n){let e=w();_("ngClass",In(1,s1e,e.isSlideOutMenuOpen))}}function l1e(n,t){if(1&n){let e=ge();h(0,"section",33)(1,"h3",1),T(2,"Images"),g(),h(3,"div",34)(4,"div",35),T(5,"Brightness"),g(),h(6,"div",13)(7,"mat-slider",36),I("input",function(r){return X(e),Q(w().imageBrightnessSliderChanged$.emit(r.value))}),g(),h(8,"button",37),I("click",function(){return X(e),Q(w().imageBrightnessReset.emit())}),P(9,"mat-icon",16),g()()(),h(10,"div",38)(11,"div",39),T(12,"Contrast"),g(),h(13,"div",13)(14,"mat-slider",40),I("input",function(r){return X(e),Q(w().imageContrastSliderChanged$.emit(r.value))}),g(),h(15,"button",41),I("click",function(){return X(e),Q(w().imageContrastReset.emit())}),P(16,"mat-icon",16),g()()(),h(17,"div",42)(18,"mat-checkbox",25),I("change",function(r){return X(e),Q(w().imageShowActualSizeChanged.emit(r.checked))}),T(19,"Show actual image size"),g()()()}if(2&n){let e=w();v(7),_("max",2e3)("min",0)("step",10)("value",e.imageBrightnessInMilli)("thumbLabel",!0)("displayWith",e.formatMilliToZeroth),v(7),_("max",5e3)("min",0)("step",10)("value",e.imageContrastInMilli)("thumbLabel",!0)("displayWith",e.formatMilliToZeroth),v(4),_("checked",e.imageShowActualSize)}}var gQ=(()=>{class n{constructor(e){this.locale=e,this.linkedTimeToggled=new F,this.stepSelectorToggled=new F,this.rangeSelectionToggled=new F,this.onSlideOutToggled=new F,this.TooltipSortDropdownOptions=[{value:oo.ALPHABETICAL,displayText:"Alphabetical"},{value:oo.ASCENDING,displayText:"Ascending"},{value:oo.DESCENDING,displayText:"Descending"},{value:oo.NEAREST,displayText:"Nearest Pixel"},{value:oo.NEAREST_Y,displayText:"Nearest Y"}],this.tooltipSortChanged=new F,this.ignoreOutliersChanged=new F,this.XAxisType=Pi,this.XAxisTypeDropdownOptions=[{value:Pi.STEP,displayText:"Step"},{value:Pi.RELATIVE,displayText:"Relative"},{value:Pi.WALL_TIME,displayText:"Wall"}],this.xAxisTypeChanged=new F,this.MAX_CARD_WIDTH_SLIDER_VALUE=735,this.MIN_CARD_WIDTH_SLIDER_VALUE=335,this.cardWidthSliderChanged$=new F,this.cardWidthChanged=this.cardWidthSliderChanged$.pipe(sc(250)),this.cardWidthReset=new F,this.HistogramModeDropdownOptions=[{value:Dr.OFFSET,displayText:"Offset"},{value:Dr.OVERLAY,displayText:"Overlay"}],this.histogramModeChanged=new F,this.MAX_SMOOTHING_VALUE=.999,this.MAX_SMOOTHING_SLIDER_VALUE=.99,this.scalarSmoothingControlChanged$=new F,this.scalarSmoothingChanged=this.scalarSmoothingControlChanged$.pipe(sc(250)),this.scalarPartitionXToggled=new F,this.imageBrightnessSliderChanged$=new F,this.imageBrightnessInMilliChanged=this.imageBrightnessSliderChanged$.pipe(sc(250)),this.imageBrightnessReset=new F,this.imageContrastSliderChanged$=new F,this.imageContrastInMilliChanged=this.imageContrastSliderChanged$.pipe(sc(250)),this.imageContrastReset=new F,this.imageShowActualSizeChanged=new F}onScalarSmoothingInput(e){let i=e.target;if(!i.value)return;let r=Math.min(Math.max(0,parseFloat(i.value)),.999);r!==parseFloat(i.value)&&(i.value=String(r)),this.scalarSmoothingControlChanged$.emit(r)}formatMilliToZeroth(e){return $O(e/1e3,this.locale||"en-US","1.0-2")}getLinkedTimeSelectionStartStep(){return this.isLinkedTimeEnabled||null===this.linkedTimeSelection||null!==this.linkedTimeSelection.end?"":this.linkedTimeSelection.start.step}isAxisTypeStep(){return this.xAxisType===Pi.STEP}}return n.\u0275fac=function(e){return new(e||n)(C(cd))},n.\u0275cmp=O({type:n,selectors:[["metrics-dashboard-settings-component"]],inputs:{isLinkedTimeEnabled:"isLinkedTimeEnabled",isScalarStepSelectorEnabled:"isScalarStepSelectorEnabled",isScalarStepSelectorRangeEnabled:"isScalarStepSelectorRangeEnabled",isScalarColumnCustomizationEnabled:"isScalarColumnCustomizationEnabled",linkedTimeSelection:"linkedTimeSelection",stepMinMax:"stepMinMax",isSlideOutMenuOpen:"isSlideOutMenuOpen",isImageSupportEnabled:"isImageSupportEnabled",tooltipSort:"tooltipSort",ignoreOutliers:"ignoreOutliers",xAxisType:"xAxisType",cardMinWidth:"cardMinWidth",histogramMode:"histogramMode",scalarSmoothing:"scalarSmoothing",scalarPartitionX:"scalarPartitionX",imageBrightnessInMilli:"imageBrightnessInMilli",imageContrastInMilli:"imageContrastInMilli",imageShowActualSize:"imageShowActualSize"},outputs:{linkedTimeToggled:"linkedTimeToggled",stepSelectorToggled:"stepSelectorToggled",rangeSelectionToggled:"rangeSelectionToggled",onSlideOutToggled:"onSlideOutToggled",tooltipSortChanged:"tooltipSortChanged",ignoreOutliersChanged:"ignoreOutliersChanged",xAxisTypeChanged:"xAxisTypeChanged",cardWidthChanged:"cardWidthChanged",cardWidthReset:"cardWidthReset",histogramModeChanged:"histogramModeChanged",scalarSmoothingChanged:"scalarSmoothingChanged",scalarPartitionXToggled:"scalarPartitionXToggled",imageBrightnessInMilliChanged:"imageBrightnessInMilliChanged",imageBrightnessReset:"imageBrightnessReset",imageContrastInMilliChanged:"imageContrastInMilliChanged",imageContrastReset:"imageContrastReset",imageShowActualSizeChanged:"imageShowActualSizeChanged"},decls:54,vars:30,consts:function(){let t,e,i;return t=$localize`:A button to reset the card width setting␟ccdc96b003fbba90db7a6959b5b26e3cc58f7d80␟5223111047968102466:Reset card width`,e=$localize`:A button to reset the image brightness setting␟c482b3a47ea0975fa8be01afb3fbec9b76628bd7␟1189161857240378395:Reset brightness`,i=$localize`:A button to reset the image contrast setting␟ed712a8b927041be15252b29eb521ebb1374bad8␟5370703342923611955:Reset contrast`,[[1,"general"],[1,"section-title"],[1,"control-row","x-axis-type"],["id","x-axis-type-label",1,"control-name"],[3,"value","options","selectionChange"],[1,"control-row","scalars-step-selector",3,"title"],[3,"checked","disabled","change"],[1,"indent"],[1,"indent","range-selection"],[1,"control-row","linked-time","indent"],["mat-button","",3,"ngClass","click",4,"ngIf"],[1,"control-row","card-width"],["id","card-width-label",1,"control-name"],[1,"slider-row"],["aria-labelledby","card-width-label","color","primary",3,"max","min","step","value","thumbLabel","input"],["mat-icon-button","","aria-label",t,"title","Reset card width",1,"reset-button",3,"click"],["svgIcon","settings_backup_restore_24px"],[1,"scalars"],[1,"control-row","scalars-smoothing"],["id","scalars-smoothing-label",1,"control-name"],["aria-labelledby","scalars-smoothing-label","color","primary",3,"max","min","step","value","thumbLabel","input"],["aria-labelledby","scalars-smoothing-label","type","number","min","0","step","0.001",1,"slider-input",3,"max","value","input"],[1,"control-row","tooltip-sort"],[1,"control-name"],[1,"control-row","scalars-ignore-outliers"],[3,"checked","change"],[1,"control-row","scalars-partition-x"],["svgIcon","help_outline_24px","title","Non-monotonic steps can occur when reusing a logdir with multiple summary writers and overlapping steps. Line charts, without this option enabled, can appear zig zagged. This is common when restarting from a checkpoint.\n\nWhen enabled, a non-monotonic time series composed of N monotonic pieces will be shown as N monotonic lines.",1,"info"],[1,"Histograms"],[1,"control-row","histogram-mode"],["class","image",4,"ngIf"],["mat-button","",3,"ngClass","click"],["svgIcon","edit_24px"],[1,"image"],[1,"control-row","image-brightness"],["id","image-brightness-label",1,"control-name"],["aria-labelledby","image-brightness-label","color","primary",3,"max","min","step","value","thumbLabel","displayWith","input"],["mat-icon-button","","aria-label",e,"title","Reset brightness",1,"reset-button",3,"click"],[1,"control-row","image-contrast"],["id","image-constrast-label",1,"control-name"],["aria-labelledby","image-constrast-label","color","primary",3,"max","min","step","value","thumbLabel","displayWith","input"],["mat-icon-button","","aria-label",i,"title","Reset contrast",1,"reset-button",3,"click"],[1,"control-row","image-show-actual-size"]]},template:function(e,i){1&e&&(h(0,"section",0)(1,"h3",1),T(2,"General"),g(),h(3,"div",2)(4,"div",3),T(5,"Horizontal Axis"),g(),h(6,"tb-dropdown",4),I("selectionChange",function(o){return i.xAxisTypeChanged.emit(o)}),g()(),h(7,"div",5)(8,"mat-checkbox",6),I("change",function(){return i.stepSelectorToggled.emit()}),T(9,"Enable step selection and data table "),g(),h(10,"span",7),T(11,"(Scalars only)"),g(),h(12,"div",8)(13,"mat-checkbox",6),I("change",function(){return i.rangeSelectionToggled.emit()}),T(14,"Enable Range Selection "),g()(),h(15,"div",9)(16,"mat-checkbox",6),I("change",function(){return i.linkedTimeToggled.emit()}),T(17),g()(),S(18,a1e,3,3,"button",10),g(),h(19,"div",11)(20,"div",12),T(21,"Card Width"),g(),h(22,"div",13)(23,"mat-slider",14),I("input",function(o){return i.cardWidthSliderChanged$.emit(o.value)}),g(),h(24,"button",15),I("click",function(){return i.cardWidthReset.emit()}),P(25,"mat-icon",16),g()()()(),h(26,"section",17)(27,"h3",1),T(28,"Scalars"),g(),h(29,"div",18)(30,"div",19),T(31,"Smoothing"),g(),h(32,"div",13)(33,"mat-slider",20),I("input",function(o){return i.scalarSmoothingControlChanged$.emit(o.value)}),g(),h(34,"input",21),I("input",function(o){return i.onScalarSmoothingInput(o)}),g()()(),h(35,"div",22)(36,"div",23),T(37,"Tooltip sorting method"),g(),h(38,"tb-dropdown",4),I("selectionChange",function(o){return i.tooltipSortChanged.emit(o)}),g()(),h(39,"div",24)(40,"mat-checkbox",25),I("change",function(o){return i.ignoreOutliersChanged.emit(o.checked)}),T(41,"Ignore outliers in chart scaling"),g()(),h(42,"div",26)(43,"mat-checkbox",25),I("change",function(){return i.scalarPartitionXToggled.emit()}),T(44,"Partition non-monotonic X axis"),g(),P(45,"mat-icon",27),g()(),h(46,"section",28)(47,"h3",1),T(48,"Histograms"),g(),h(49,"div",29)(50,"div",23),T(51,"Mode"),g(),h(52,"tb-dropdown",4),I("selectionChange",function(o){return i.histogramModeChanged.emit(o)}),g()()(),S(53,l1e,20,13,"section",30)),2&e&&(v(6),_("value",i.xAxisType)("options",i.XAxisTypeDropdownOptions),v(1),_("title",i.isAxisTypeStep()?"":"Only available when Horizontal Axis is set to step"),v(1),_("checked",i.isScalarStepSelectorEnabled)("disabled",!i.isAxisTypeStep()),v(5),_("checked",i.isScalarStepSelectorRangeEnabled)("disabled",!i.isAxisTypeStep()),v(3),_("checked",i.isLinkedTimeEnabled)("disabled",!i.isAxisTypeStep()),v(1),He("Link by step ",i.getLinkedTimeSelectionStartStep()," "),v(1),_("ngIf",i.isScalarColumnCustomizationEnabled),v(5),_("max",i.MAX_CARD_WIDTH_SLIDER_VALUE)("min",i.MIN_CARD_WIDTH_SLIDER_VALUE)("step",50)("value",i.cardMinWidth)("thumbLabel",!1),v(10),_("max",i.MAX_SMOOTHING_SLIDER_VALUE)("min",0)("step",.01)("value",i.scalarSmoothing)("thumbLabel",!0),v(1),_("max",i.MAX_SMOOTHING_VALUE)("value",i.scalarSmoothing),v(4),_("value",i.tooltipSort)("options",i.TooltipSortDropdownOptions),v(2),_("checked",i.ignoreOutliers),v(3),_("checked",i.scalarPartitionX),v(9),_("value",i.histogramMode)("options",i.HistogramModeDropdownOptions),v(1),_("ngIf",i.isImageSupportEnabled))},dependencies:[yn,Fe,mQ,Ji,$i,ha,En,Dd],styles:["[_nghost-%COMP%]{color:#616161;font-size:12px}body.dark-mode   [_nghost-%COMP%]{color:rgba(255,255,255,.7)}section[_ngcontent-%COMP%]{border-bottom:1px solid #ebebeb;padding:16px}body.dark-mode[_nghost-%COMP%]   section[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   section[_ngcontent-%COMP%]{border-bottom:1px solid #555}.section-title[_ngcontent-%COMP%]{color:#212121;text-transform:uppercase;font-weight:500;font-size:13px;line-height:normal;margin:0 0 12px 0}body.dark-mode[_nghost-%COMP%]   .section-title[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .section-title[_ngcontent-%COMP%]{color:#fff}section[_ngcontent-%COMP%]   .control-row[_ngcontent-%COMP%]:not(:has( + .control-row[_ngcontent-%COMP%] > mat-checkbox))[_ngcontent-%COMP%]:not(:last-child){margin-bottom:12px}.control-name[_ngcontent-%COMP%]{margin-bottom:8px}.slider-row[_ngcontent-%COMP%]{display:flex;align-items:center;height:28px}.slider-row[_ngcontent-%COMP%]   .reset-button[_ngcontent-%COMP%]{margin-left:6px}.slider-row[_ngcontent-%COMP%]   .slider-input[_ngcontent-%COMP%]{background-color:inherit;border:1px solid #8e98a3;border-radius:2px;box-sizing:border-box;color:inherit;height:100%;margin-left:12px;padding:0 4px}body.dark-mode[_nghost-%COMP%]   .slider-row[_ngcontent-%COMP%]   .slider-input[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .slider-row[_ngcontent-%COMP%]   .slider-input[_ngcontent-%COMP%]{border-color:#425066}.scalars-smoothing[_ngcontent-%COMP%]   .slider-input[_ngcontent-%COMP%]{flex:none;width:5em}.scalars-partition-x[_ngcontent-%COMP%]{align-items:center;display:flex}.scalars-partition-x[_ngcontent-%COMP%]   .info[_ngcontent-%COMP%]{height:15px;margin-left:5px;width:15px;min-width:15px}mat-checkbox[_ngcontent-%COMP%]{margin-left:-11px}mat-checkbox[_ngcontent-%COMP%]     label{color:#616161;font-size:12px;letter-spacing:normal;padding-left:0px;white-space:nowrap}body.dark-mode[_nghost-%COMP%]   mat-checkbox[_ngcontent-%COMP%]     label, body.dark-mode   [_nghost-%COMP%]   mat-checkbox[_ngcontent-%COMP%]     label{color:rgba(255,255,255,.7)}mat-slider[_ngcontent-%COMP%]{flex:1;margin-left:-8px;margin-right:-8px}.column-edit-menu-toggle[_ngcontent-%COMP%]{align-items:center;display:flex;cursor:pointer;font-size:inherit;height:28px;padding-left:5px;padding-right:12px}.column-edit-menu-toggle.mat-button-wrapper[_ngcontent-%COMP%]{display:inline-flex;align-items:center}.column-edit-menu-toggle.toggle-opened[_ngcontent-%COMP%]{background-color:#eee}body.dark-mode[_nghost-%COMP%]   .column-edit-menu-toggle.toggle-opened[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .column-edit-menu-toggle.toggle-opened[_ngcontent-%COMP%]{background-color:#424242}.column-edit-menu-toggle[_ngcontent-%COMP%]   mat-icon[_ngcontent-%COMP%]{margin-right:6px}tb-dropdown[_ngcontent-%COMP%]{display:block}.control-row[_ngcontent-%COMP%]   .indent[_ngcontent-%COMP%]{margin-left:28px}"],changeDetection:0}),n})(),_Q=(()=>{class n{constructor(e){this.store=e,this.isScalarStepSelectorEnabled$=this.store.select(xv),this.isScalarStepSelectorRangeEnabled$=this.store.select(Su),this.isLinkedTimeEnabled$=this.store.select(wu),this.isScalarColumnCustomizationEnabled$=this.store.select(dS),this.linkedTimeSelection$=this.store.select(XF),this.stepMinMax$=this.store.select(YF),this.isSlideOutMenuOpen$=this.store.select(l1),this.isImageSupportEnabled$=this.store.select(vu).pipe(ke(Boolean),Yt(1),Bt(this.store.select(cS)),N(([,i])=>i)),this.tooltipSort$=this.store.select(hf),this.ignoreOutliers$=this.store.select(gf),this.xAxisType$=this.store.select(Ol),this.cardMinWidth$=this.store.select(Xh),this.histogramMode$=this.store.select(t1),this.scalarSmoothing$=this.store.select(bd),this.scalarPartitionX$=this.store.select(n1),this.imageBrightnessInMilli$=this.store.select(i1),this.imageContrastInMilli$=this.store.select(r1),this.imageShowActualSize$=this.store.select(o1)}onTooltipSortChanged(e){this.store.dispatch(mT({sort:e}))}onIgnoreOutliersChanged(){this.store.dispatch(hT())}onXAxisTypeChanged(e){this.store.dispatch(gT({xAxisType:e}))}onCardWidthChanged(e){this.store.dispatch(_T({cardMinWidth:e}))}onCardWidthReset(){this.store.dispatch(bT())}onHistogramModeChanged(e){this.store.dispatch(ET({histogramMode:e}))}onScalarSmoothingChanged(e){this.store.dispatch(vT({smoothing:e}))}onScalarPartitionXToggled(){this.store.dispatch(yT())}onImageBrightnessInMilliChanged(e){this.store.dispatch(xT({brightnessInMilli:e}))}onImageBrightnessReset(){this.store.dispatch(MT())}onImageContrastReset(){this.store.dispatch(wT())}onImageContrastInMilliChanged(e){this.store.dispatch(CT({contrastInMilli:e}))}onImageShowActualSizeChanged(){this.store.dispatch(ST())}onLinkedTimeToggled(){this.store.dispatch(FT({affordance:Ys.CHECK_BOX}))}onStepSelectorToggled(){this.store.dispatch(Id({affordance:Ys.CHECK_BOX}))}onRangeSelectionToggled(){this.store.dispatch(NT({affordance:Ys.CHECK_BOX}))}onSlideOutToggled(){this.store.dispatch(sT())}}return n.\u0275fac=function(e){return new(e||n)(C(Ae))},n.\u0275cmp=O({type:n,selectors:[["metrics-dashboard-settings"]],decls:19,vars:54,consts:[[3,"isImageSupportEnabled","tooltipSort","ignoreOutliers","xAxisType","cardMinWidth","histogramMode","scalarSmoothing","scalarPartitionX","imageBrightnessInMilli","imageContrastInMilli","imageShowActualSize","isScalarStepSelectorEnabled","isScalarStepSelectorRangeEnabled","isLinkedTimeEnabled","isScalarColumnCustomizationEnabled","linkedTimeSelection","stepMinMax","isSlideOutMenuOpen","tooltipSortChanged","ignoreOutliersChanged","xAxisTypeChanged","cardWidthChanged","cardWidthReset","histogramModeChanged","scalarSmoothingChanged","scalarPartitionXToggled","imageBrightnessInMilliChanged","imageBrightnessReset","imageContrastInMilliChanged","imageContrastReset","imageShowActualSizeChanged","linkedTimeToggled","stepSelectorToggled","rangeSelectionToggled","onSlideOutToggled"]],template:function(e,i){1&e&&(h(0,"metrics-dashboard-settings-component",0),I("tooltipSortChanged",function(o){return i.onTooltipSortChanged(o)})("ignoreOutliersChanged",function(){return i.onIgnoreOutliersChanged()})("xAxisTypeChanged",function(o){return i.onXAxisTypeChanged(o)})("cardWidthChanged",function(o){return i.onCardWidthChanged(o)})("cardWidthReset",function(){return i.onCardWidthReset()})("histogramModeChanged",function(o){return i.onHistogramModeChanged(o)})("scalarSmoothingChanged",function(o){return i.onScalarSmoothingChanged(o)})("scalarPartitionXToggled",function(){return i.onScalarPartitionXToggled()})("imageBrightnessInMilliChanged",function(o){return i.onImageBrightnessInMilliChanged(o)})("imageBrightnessReset",function(){return i.onImageBrightnessReset()})("imageContrastInMilliChanged",function(o){return i.onImageContrastInMilliChanged(o)})("imageContrastReset",function(){return i.onImageContrastReset()})("imageShowActualSizeChanged",function(){return i.onImageShowActualSizeChanged()})("linkedTimeToggled",function(){return i.onLinkedTimeToggled()})("stepSelectorToggled",function(){return i.onStepSelectorToggled()})("rangeSelectionToggled",function(){return i.onRangeSelectionToggled()})("onSlideOutToggled",function(){return i.onSlideOutToggled()}),j(1,"async"),j(2,"async"),j(3,"async"),j(4,"async"),j(5,"async"),j(6,"async"),j(7,"async"),j(8,"async"),j(9,"async"),j(10,"async"),j(11,"async"),j(12,"async"),j(13,"async"),j(14,"async"),j(15,"async"),j(16,"async"),j(17,"async"),j(18,"async"),g()),2&e&&_("isImageSupportEnabled",W(1,18,i.isImageSupportEnabled$))("tooltipSort",W(2,20,i.tooltipSort$))("ignoreOutliers",W(3,22,i.ignoreOutliers$))("xAxisType",W(4,24,i.xAxisType$))("cardMinWidth",W(5,26,i.cardMinWidth$))("histogramMode",W(6,28,i.histogramMode$))("scalarSmoothing",W(7,30,i.scalarSmoothing$))("scalarPartitionX",W(8,32,i.scalarPartitionX$))("imageBrightnessInMilli",W(9,34,i.imageBrightnessInMilli$))("imageContrastInMilli",W(10,36,i.imageContrastInMilli$))("imageShowActualSize",W(11,38,i.imageShowActualSize$))("isScalarStepSelectorEnabled",W(12,40,i.isScalarStepSelectorEnabled$))("isScalarStepSelectorRangeEnabled",W(13,42,i.isScalarStepSelectorRangeEnabled$))("isLinkedTimeEnabled",W(14,44,i.isLinkedTimeEnabled$))("isScalarColumnCustomizationEnabled",W(15,46,i.isScalarColumnCustomizationEnabled$))("linkedTimeSelection",W(16,48,i.linkedTimeSelection$))("stepMinMax",W(17,50,i.stepMinMax$))("isSlideOutMenuOpen",W(18,52,i.isSlideOutMenuOpen$))},dependencies:[gQ,ct],encapsulation:2,changeDetection:0}),n})(),bQ=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["metrics-dashboard-right-pane"]],decls:1,vars:0,template:function(e,i){1&e&&P(0,"metrics-dashboard-settings")},dependencies:[_Q],encapsulation:2,changeDetection:0}),n})();function h1e(n,t){1&n&&P(0,"mat-icon",4)}function g1e(n,t){1&n&&P(0,"mat-icon",4)}function _1e(n,t){1&n&&P(0,"mat-icon",4)}function b1e(n,t){1&n&&P(0,"div",5)}var zT=(()=>{class n{constructor(){this.ColumnHeaderType=ht}getSpecialTypeClasses(e){switch(e){case ht.STEP_AT_MIN:return"step-at-min";case ht.STEP_AT_MAX:return"step-at-max";default:return""}}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["tb-data-table-header"]],inputs:{header:"header"},decls:7,vars:6,consts:[[1,"header-container",3,"ngSwitch"],["svgIcon","change_history_24px",4,"ngSwitchCase"],["class","extra-right-padding",4,"ngSwitchDefault"],[3,"ngClass"],["svgIcon","change_history_24px"],[1,"extra-right-padding"]],template:function(e,i){1&e&&(h(0,"div",0),S(1,h1e,1,0,"mat-icon",1),S(2,g1e,1,0,"mat-icon",1),S(3,_1e,1,0,"mat-icon",1),S(4,b1e,1,0,"div",2),h(5,"span",3),T(6),g()()),2&e&&(_("ngSwitch",i.header.type),v(1),_("ngSwitchCase",i.ColumnHeaderType.VALUE_CHANGE),v(1),_("ngSwitchCase",i.ColumnHeaderType.PERCENTAGE_CHANGE),v(1),_("ngSwitchCase",i.ColumnHeaderType.RAW_CHANGE),v(2),_("ngClass",i.getSpecialTypeClasses(i.header.type)),v(1),bt(i.header.displayName))},dependencies:[yn,sr,Sr,uu,En],styles:[".header-container[_ngcontent-%COMP%]{align-items:center;display:flex}.extra-right-padding[_ngcontent-%COMP%]{padding-right:1px}mat-icon[_ngcontent-%COMP%]{height:12px;width:12px;min-width:12px;line-height:12px}.step-at-min[_ngcontent-%COMP%]{min-width:37px}.step-at-max[_ngcontent-%COMP%]{min-width:40px}"],changeDetection:0}),n})();function v1e(n,t){if(1&n){let e=ge();h(0,"div",8),I("dragstart",function(){let o=X(e).$implicit;return Q(w(2).dragStart(o))})("dragend",function(){X(e);let r=w().dataTableMode;return Q(w().dragEnd(r))})("dragenter",function(){let o=X(e).$implicit,s=w().dataTableMode;return Q(w().dragEnter(o,s))}),h(1,"mat-checkbox",9),I("change",function(){let o=X(e).$implicit,s=w().dataTableMode;return Q(w().toggleHeader(o,s))}),P(2,"tb-data-table-header",10),g()()}if(2&n){let e=t.$implicit;_("ngClass",w(2).getHighlightClasses(e)),v(1),_("checked",e.enabled),v(1),_("header",e)}}function y1e(n,t){1&n&&S(0,v1e,3,3,"div",7),2&n&&_("ngForOf",t.headers)}var yQ=function(n,t){return{headers:n,dataTableMode:t}},PN=n=>{n.preventDefault()},x1e=(n,t,e)=>{let i=[...e];return i.splice(n,1),i.splice(t,0,e[n]),i},UT=(n,t)=>t.findIndex(e=>e.name===n.name),Xu=(()=>(function(n){n[n.TOP=0]="TOP",n[n.BOTTOM=1]="BOTTOM"}(Xu||(Xu={})),Xu))(),xQ=(()=>{class n{constructor(e){this.hostElement=e,this.DataTableMode=ro,this.highlightEdge=Xu.TOP,this.onScalarTableColumnEdit=new F,this.onScalarTableColumnToggled=new F,this.onScalarTableColumnEditorClosed=new F,this.onTabChange=new F}ngOnDestroy(){this.hostElement.nativeElement.removeEventListener("dragover",PN)}tabChange(e){this.onTabChange.emit(0===e.index?ro.SINGLE:ro.RANGE)}dragStart(e){this.draggingHeader=e,this.hostElement.nativeElement.addEventListener("dragover",PN)}dragEnd(e){if(!this.draggingHeader||!this.highlightedHeader)return;let i=this.getHeadersForMode(e);this.onScalarTableColumnEdit.emit({dataTableMode:e,headers:x1e(UT(this.draggingHeader,i),UT(this.highlightedHeader,i),i)}),this.draggingHeader=void 0,this.highlightedHeader=void 0,this.hostElement.nativeElement.removeEventListener("dragover",PN)}dragEnter(e,i){if(!this.draggingHeader)return;let r=this.getHeadersForMode(i);this.highlightEdge=UT(e,r)<UT(this.draggingHeader,r)?Xu.TOP:Xu.BOTTOM,this.highlightedHeader=e}toggleHeader(e,i){this.onScalarTableColumnToggled.emit({dataTableMode:i,header:e})}getHighlightClasses(e){return e.name!==this.highlightedHeader?.name?{}:{highlighted:!0,"highlight-top":this.highlightEdge===Xu.TOP,"highlight-bottom":this.highlightEdge===Xu.BOTTOM}}getSelectedTabIndex(){return this.selectedTab===ro.SINGLE?0:1}getHeadersForMode(e){return e===ro.SINGLE?this.singleHeaders:this.rangeHeaders}}return n.\u0275fac=function(e){return new(e||n)(C(Me))},n.\u0275cmp=O({type:n,selectors:[["metrics-scalar-column-editor-component"]],inputs:{rangeHeaders:"rangeHeaders",singleHeaders:"singleHeaders",selectedTab:"selectedTab"},outputs:{onScalarTableColumnEdit:"onScalarTableColumnEdit",onScalarTableColumnToggled:"onScalarTableColumnToggled",onScalarTableColumnEditorClosed:"onScalarTableColumnEditorClosed",onTabChange:"onTabChange"},decls:11,vars:13,consts:function(){let t;return t=$localize`:Label on a button to close the column editor.␟cb616ce9b4327b41e6bdb9344669ba7c72e2c70e␟7205635764713034842:Close column editor`,[[1,"editor-controls"],[1,"tab-group",3,"selectedIndex","selectedTabChange"],[3,"label"],[3,"ngTemplateOutlet","ngTemplateOutletContext"],[1,"footer"],["mat-button","","aria-label",t,1,"close-button",3,"click"],["headerList",""],["class","header-list-item","draggable","true",3,"ngClass","dragstart","dragend","dragenter",4,"ngFor","ngForOf"],["draggable","true",1,"header-list-item",3,"ngClass","dragstart","dragend","dragenter"],[3,"checked","change"],[3,"header"]]},template:function(e,i){if(1&e&&(h(0,"div",0)(1,"mat-tab-group",1),I("selectedTabChange",function(o){return i.tabChange(o)}),h(2,"mat-tab",2),P(3,"ngContext",3),g(),h(4,"mat-tab",2),P(5,"ngContext",3),g()()(),h(6,"div",4)(7,"button",5),I("click",function(){return i.onScalarTableColumnEditorClosed.emit()}),T(8," Close "),g()(),S(9,y1e,1,1,"ng-template",null,6,Wt)),2&e){let r=it(10);v(1),_("selectedIndex",i.getSelectedTabIndex()),v(1),_("label","Single"),v(1),_("ngTemplateOutlet",r)("ngTemplateOutletContext",qr(7,yQ,i.singleHeaders,i.DataTableMode.SINGLE)),v(1),_("label","Range"),v(1),_("ngTemplateOutlet",r)("ngTemplateOutletContext",qr(10,yQ,i.rangeHeaders,i.DataTableMode.RANGE))}},dependencies:[yn,nn,Lr,zT,ha,sy,bE,Ji],styles:["[_nghost-%COMP%]     .mat-tab-label{min-width:0;padding:0 30px}.editor-controls[_ngcontent-%COMP%]{height:calc(100% - 45px)}.tab-group[_ngcontent-%COMP%]{position:relative;z-index:0;height:100%}.header-list-item[_ngcontent-%COMP%]{padding:3px;height:24px}.highlighted[_ngcontent-%COMP%]{background-color:#eee}.highlight-bottom[_ngcontent-%COMP%]{border-bottom:2px solid #ff9800}.highlight-top[_ngcontent-%COMP%]{border-top:2px solid #ff9800}.footer[_ngcontent-%COMP%]{display:flex;position:absolute;left:0;bottom:0;box-sizing:border-box;width:100%;align-items:center;justify-content:flex-end;padding:4px;border-top:1px solid #ebebeb}body.dark-mode[_nghost-%COMP%]   .footer[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .footer[_ngcontent-%COMP%]{border-color:#555}.close-button[_ngcontent-%COMP%]{color:#616161;width:84px}body.dark-mode[_nghost-%COMP%]   .close-button[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .close-button[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}  .mat-mdc-tab-body-wrapper{flex:1}"],changeDetection:0}),n})(),CQ=(()=>{class n{constructor(e){this.store=e,this.singleHeaders$=this.store.select(Cv),this.rangeHeaders$=this.store.select(Mv),this.selectedTab$=this.store.select(SW)}onScalarTableColumnToggled(e){this.store.dispatch(Ug(e))}onScalarTableColumnEdit(e){this.store.dispatch(zg(e))}onScalarTableColumnEditorClosed(){this.store.dispatch(cT())}onTabChange(e){this.store.dispatch(lT({tab:e}))}}return n.\u0275fac=function(e){return new(e||n)(C(Ae))},n.\u0275cmp=O({type:n,selectors:[["metrics-scalar-column-editor"]],decls:4,vars:9,consts:[[3,"singleHeaders","rangeHeaders","selectedTab","onScalarTableColumnToggled","onScalarTableColumnEdit","onScalarTableColumnEditorClosed","onTabChange"]],template:function(e,i){1&e&&(h(0,"metrics-scalar-column-editor-component",0),I("onScalarTableColumnToggled",function(o){return i.onScalarTableColumnToggled(o)})("onScalarTableColumnEdit",function(o){return i.onScalarTableColumnEdit(o)})("onScalarTableColumnEditorClosed",function(){return i.onScalarTableColumnEditorClosed()})("onTabChange",function(o){return i.onTabChange(o)}),j(1,"async"),j(2,"async"),j(3,"async"),g()),2&e&&_("singleHeaders",W(1,3,i.singleHeaders$))("rangeHeaders",W(2,5,i.rangeHeaders$))("selectedTab",W(3,7,i.selectedTab$))},dependencies:[xQ,ct],encapsulation:2,changeDetection:0}),n})(),Wg=(()=>(function(n){n[n.ORIGINAL=0]="ORIGINAL",n[n.DERIVED=1]="DERIVED"}(Wg||(Wg={})),Wg))(),w1e=q(_W,Iu,(n,t)=>new Set(Object.entries(n.scalars.tagToRuns).filter(([,e])=>!t||!t.size||e.some(i=>t?.get(i))).map(([e])=>e))),S1e=q(e1,Iu,wW,w1e,(n,t,e,i)=>{let r=Array.from(t?.values()||[]).some(Boolean);return n.filter(o=>pa(o.plugin)?Boolean(t&&t.get(o.runId)):!e||!r||o.plugin!==zn.SCALARS||i.has(o.tag))}),Nf=q(S1e,n=>n.sort((t,e)=>yy(t.tag,e.tag))),jT={filterRunItemsByRegex:(n,t,e)=>t?n.filter(i=>Qh({runName:i.run.name,experimentAlias:i.experimentAlias},t,e)):n,matchFilter:(n,t)=>void 0===t?n.includeUndefined:n.type===gn.DISCRETE?n.filterValues.includes(t):n.type===gn.INTERVAL&&"number"==typeof t&&n.filterLowerValue<=t&&t<=n.filterUpperValue,filterRunItemsByHparamAndMetricFilter:(n,t,e)=>n.filter(({hparams:i,metrics:r})=>{let o=[...t.entries()].every(([a,l])=>{let c=i.get(a);return jT.matchFilter(l,c)}),s=[...e.entries()].every(([a,l])=>{let c=r.get(a);return jT.matchFilter(l,c)});return o&&s})},MQ=q(KF,m1,h1,(n,t,e)=>new Map([...n,...t,...e])),E1e=q(b1,W6,Iu,Au,za,(n,t,e,i,r)=>n.map(o=>{let s=new Map;(o.hparams||[]).forEach(l=>{s.set(l.name,l.value)});let a=new Map;return(o.metrics||[]).forEach(l=>{a.set(l.tag,l.value)}),{run:o,experimentName:t[o.experimentId]||"",experimentAlias:r[o.experimentId],selected:Boolean(e&&e.get(o.id)),runColor:i[o.id],hparams:s,metrics:a}})),ON=q(vd,E1e,m1,h1,Ha,(n,t,e,i,r)=>{let o=jT.filterRunItemsByRegex(t,n,r===wn.COMPARE_EXPERIMENT);return jT.filterRunItemsByHparamAndMetricFilter(o,e,i)}),wQ=q(ON,n=>new Set(n.map(({run:{id:t}})=>t))),kN=q(f1,lr,({hparams:n},t)=>t?n.map(e=>({type:ht.HPARAM,name:e.name,displayName:e.displayName||e.name,enabled:!1,removable:!0,sortable:!0,movable:!0,filterable:!0})):[]),qg=(Yh(n=>q(d1(n),kN,(t,e)=>[...t,...e])),(()=>{class n{constructor(e,i){this.ref=e,this.cdkScrollable=i,this.onVisibilityChange=new F,this.ngUnsubscribe$=new Ie,this.onEvent$=new Ie}ngOnInit(){let e={root:this.cdkScrollable?this.cdkScrollable.getElementRef().nativeElement:null};this.intersectionObserverMargin&&(e.rootMargin=this.intersectionObserverMargin);let i=new IntersectionObserver(r=>{this.onEvent$.next(r)},e);i.observe(this.ref.nativeElement),this.ngUnsubscribe$.subscribe(()=>{i.unobserve(this.ref.nativeElement)}),this.onEvent$.pipe(ot(this.ngUnsubscribe$)).subscribe(r=>{let o=r.slice(-1)[0];this.onVisibilityChange.emit({visible:o.isIntersecting})})}ngOnDestroy(){this.ngUnsubscribe$.next(),this.ngUnsubscribe$.complete()}waitForEventForTestOnly(){return new Promise(e=>this.onEvent$.pipe(Yt(1)).subscribe(()=>{e()}))}}return n.\u0275fac=function(e){return new(e||n)(C(Me),C(Cd,8))},n.\u0275dir=we({type:n,selectors:[["","observeIntersection",""]],inputs:{intersectionObserverMargin:"intersectionObserverMargin"},outputs:{onVisibilityChange:"onVisibilityChange"}}),n})()),SQ="/scalar_summary";function Yg(n,t){let e=n;return t&&n.startsWith(t+"/")&&(e=n.slice(t.length+1)),e.endsWith(SQ)&&(e=e.slice(0,-SQ.length)),e||n}var GT=(()=>{class n{constructor(e,i){this.store=e,this.changeDetectorRef=i,this.hrefAttr=void 0,this.srcAttr=void 0,this.includeFeatureFlags=!0}getUrlWithFeatureFlags(e){return this.store.select(Ph).pipe(N(i=>{if(Object.keys(i).length>0){let r=new URLSearchParams([["tensorBoardFeatureFlags",JSON.stringify(i)]]),o=e.includes("?")?"&":"?";return e+o+String(r)}return e}))}set href(e){e&&IC(this.getUrlWithFeatureFlags(e)).then(i=>{this.hrefAttr=i,this.changeDetectorRef.detectChanges()})}set src(e){e&&IC(this.getUrlWithFeatureFlags(e)).then(i=>{this.srcAttr=i,this.changeDetectorRef.detectChanges()})}}return n.\u0275fac=function(e){return new(e||n)(C(Ae),C($t))},n.\u0275dir=we({type:n,selectors:[["a","includeFeatureFlags",""],["img","includeFeatureFlags",""]],hostVars:2,hostBindings:function(e,i){2&e&&Be("href",i.hrefAttr,ka)("src",i.srcAttr,ka)},inputs:{includeFeatureFlags:"includeFeatureFlags",href:"href",src:"src"}}),n})(),T1e=["measurer"],D1e=["input"],TQ=(()=>{class n{constructor(e){this.changeDetector=e,this.placeholder="",this.style="default",this.patternRegex=new RegExp(".*"),this.isValid=!0,this.onValueChange=new F,this.blur=new F,this.focus=new F,this.keydown=new F,this.keyup=new F,this.internalValue="",this.fontChangeListener=this.updateInputWidth.bind(this)}ngOnInit(){document.fonts&&document.fonts.addEventListener("loadingdone",this.fontChangeListener)}ngOnDestroy(){document.fonts&&document.fonts.removeEventListener("loadingdone",this.fontChangeListener)}ngOnChanges(e){e.pattern&&(this.patternRegex=new RegExp(this.pattern??"")),e.value&&(this.internalValue=this.value),this.isValid=this.patternRegex.test(this.internalValue)}ngAfterViewChecked(){this.updateInputWidth()}onInput(e){let i=this.internalValue;this.internalValue=this.inputElRef.nativeElement.value,this.internalValue!==i&&(this.isValid=this.patternRegex.test(this.internalValue),this.changeDetector.markForCheck()),this.onValueChange.emit({value:this.internalValue})}updateInputWidth(){let{width:e}=this.measurerElRef.nativeElement.getBoundingClientRect();this.inputElRef.nativeElement.style.width=`${e}px`}}return n.\u0275fac=function(e){return new(e||n)(C($t))},n.\u0275cmp=O({type:n,selectors:[["content-wrapping-input"]],viewQuery:function(e,i){if(1&e&&(Ge(T1e,7,Me),Ge(D1e,7,Me)),2&e){let r;Se(r=Ee())&&(i.measurerElRef=r.first),Se(r=Ee())&&(i.inputElRef=r.first)}},hostVars:2,hostBindings:function(e,i){2&e&&As(i.style)},inputs:{value:"value",placeholder:"placeholder",style:"style",pattern:"pattern"},outputs:{onValueChange:"onValueChange",blur:"blur",focus:"focus",keydown:"keydown",keyup:"keyup"},features:[Gt],decls:6,vars:7,consts:[["aria-hidden","true",1,"measurer"],["measurer",""],["autocomplete","off","spellcheck","false","type","text",3,"value","placeholder","blur","focus","input","keydown","keyup"],["input",""]],template:function(e,i){1&e&&(h(0,"span")(1,"span",0,1),T(3),g(),h(4,"input",2,3),I("blur",function(o){return i.blur.emit(o)})("focus",function(o){return i.focus.emit(o)})("input",function(o){return i.onInput(o)})("keydown",function(o){return i.keydown.emit(o)})("keyup",function(o){return i.keyup.emit(o)}),g()()),2&e&&(nt("container",!0)("is-valid",i.isValid),v(3),bt(i.internalValue||i.placeholder),v(1),_("value",i.value)("placeholder",i.placeholder))},styles:["[_nghost-%COMP%]{display:inline-flex;width:max-content}[_nghost-%COMP%]:focus-within   .container[_ngcontent-%COMP%]{border-color:#f57c00}.default[_nghost-%COMP%]:hover   .container[_ngcontent-%COMP%]{border-color:#ebebeb}.error[_nghost-%COMP%]   .container[_ngcontent-%COMP%], [_nghost-%COMP%]   .container[_ngcontent-%COMP%]:not(.is-valid){border-color:#ef9a9a}.error[_nghost-%COMP%]   .container[_ngcontent-%COMP%]:hover, .error[_nghost-%COMP%]   .container[_ngcontent-%COMP%]:focus-within, [_nghost-%COMP%]   .container[_ngcontent-%COMP%]:not(.is-valid):hover, [_nghost-%COMP%]   .container[_ngcontent-%COMP%]:not(.is-valid):focus-within{border-color:#ef9a9a}.high-contrast[_nghost-%COMP%]   .container[_ngcontent-%COMP%]{border-color:#bdbdbd}.high-contrast[_nghost-%COMP%]   .container[_ngcontent-%COMP%]:hover{border-color:#757575}.container[_ngcontent-%COMP%]{border-radius:4px;border:2px solid rgba(0,0,0,0);padding:1px 2px;position:relative}.measurer[_ngcontent-%COMP%]{pointer-events:none;position:absolute;visibility:hidden}.measurer[_ngcontent-%COMP%], input[_ngcontent-%COMP%]{font-family:inherit;font-size:inherit;line-height:1.4;padding:0;white-space:pre}.measurer[_ngcontent-%COMP%]:empty, input[_ngcontent-%COMP%]:empty{width:2ch}input[_ngcontent-%COMP%]{appearance:none;background-color:inherit;border:0;color:inherit;display:inline-block;font-family:inherit;outline:0}input[_ngcontent-%COMP%]:focus{padding-right:1ch}"],changeDetection:0}),n})();function A1e(n,t){if(1&n){let e=ge();h(0,"content-wrapping-input",3),I("onValueChange",function(r){return X(e),Q(w().aliasChanged.emit(r))}),g()}if(2&n){let e=w();Fa(e.isAliasNameLegal?"high-contrast":"error"),_("value",e.alias.aliasText)}}function R1e(n,t){if(1&n&&(h(0,"span",4),T(1),g()),2&n){let e=w();nt("illegal",!e.isAliasNameLegal),_("title",e.title),v(1),bt(e.alias.aliasText)}}var Qu=(()=>{class n{constructor(){this.isAliasNameLegal=!0,this.aliasChanged=new F}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["tb-experiment-alias"]],inputs:{alias:"alias",aliasEditable:"aliasEditable",title:"title",isAliasNameLegal:"isAliasNameLegal"},outputs:{aliasChanged:"aliasChanged"},decls:5,vars:3,consts:[[1,"alias-number"],["placeholder","Alias for experiment",3,"style","value","onValueChange",4,"ngIf","ngIfElse"],["noEditAliasName",""],["placeholder","Alias for experiment",3,"value","onValueChange"],[3,"title"]],template:function(e,i){if(1&e&&(h(0,"span",0),T(1),g(),S(2,A1e,1,3,"content-wrapping-input",1),S(3,R1e,2,4,"ng-template",null,2,Wt)),2&e){let r=it(4);v(1),bt(i.alias.aliasNumber),v(1),_("ngIf",i.aliasEditable)("ngIfElse",r)}},dependencies:[Fe,TQ],styles:[".alias-number[_ngcontent-%COMP%]{background-color:#e0e0e0;border:1px solid #ebebeb;color:#212121;border-radius:2px;margin-right:2px;padding:0 2px}body.dark-mode[_nghost-%COMP%]   .alias-number[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .alias-number[_ngcontent-%COMP%]{background-color:#616161}body.dark-mode[_nghost-%COMP%]   .alias-number[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .alias-number[_ngcontent-%COMP%]{border:1px solid #555}body.dark-mode[_nghost-%COMP%]   .alias-number[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .alias-number[_ngcontent-%COMP%]{color:#fff}[_nghost-%COMP%]{display:inline-flex;align-items:baseline}"]}),n})();function P1e(n,t){1&n&&P(0,"tb-experiment-alias",2),2&n&&_("alias",w().experimentAlias)}function O1e(n,t){1&n&&(h(0,"span"),T(1,"/"),g())}var DQ=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["card-run-name-component"]],inputs:{name:"name",experimentAlias:"experimentAlias"},decls:4,vars:3,consts:[[3,"alias",4,"ngIf"],[4,"ngIf"],[3,"alias"]],template:function(e,i){1&e&&(S(0,P1e,1,1,"tb-experiment-alias",0),S(1,O1e,2,0,"span",1),h(2,"span"),T(3),g()),2&e&&(_("ngIf",null!=i.experimentAlias),v(1),_("ngIf",null!=i.experimentAlias),v(2),bt(i.name))},dependencies:[Fe,Qu],styles:["[_nghost-%COMP%]{color:#616161}body.dark-mode   [_nghost-%COMP%]{color:rgba(255,255,255,.7)}"],changeDetection:0}),n})(),qT=(()=>{class n{constructor(e){this.store=e}ngOnInit(){this.name$=dn([this.store.select(_1,{runId:this.runId})]).pipe(N(([e])=>function(n,t,e){if(!t)return n;let i=t?.name??"...";return i}(this.runId,e))),this.experimentAlias$=dn([this.store.select(g1,{runId:this.runId}),this.store.select(za)]).pipe(N(([e,i])=>e?i[e]:null))}}return n.\u0275fac=function(e){return new(e||n)(C(Ae))},n.\u0275cmp=O({type:n,selectors:[["card-run-name"]],inputs:{runId:"runId"},decls:4,vars:9,consts:[[3,"name","experimentAlias"]],template:function(e,i){1&e&&(P(0,"card-run-name-component",0),j(1,"async"),j(2,"async"),j(3,"async")),2&e&&(_("name",W(1,3,i.name$))("experimentAlias",W(3,7,i.experimentAlias$)),Be("title",W(2,5,i.name$)))},dependencies:[DQ,ct],encapsulation:2,changeDetection:0}),n})();function F1e(n,t){if(1&n&&(h(0,"span",2),T(1),g()),2&n){let e=w();v(1),bt(e.firstTextPart())}}var Xg=(()=>{class n{parseValue(){let e=this.value.lastIndexOf("/");return-1===e?{first:"",second:this.value}:{first:this.value.slice(0,e),second:this.value.slice(e)}}firstTextPart(){return this.parseValue().first}secondTextPart(){return this.parseValue().second}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["tb-truncated-path"]],inputs:{value:"value"},decls:3,vars:2,consts:[["class","first-text-part",4,"ngIf"],[1,"second-text-part"],[1,"first-text-part"]],template:function(e,i){1&e&&(S(0,F1e,2,1,"span",0),h(1,"span",1),T(2),g()),2&e&&(_("ngIf",i.firstTextPart().length>0),v(2),bt(i.secondTextPart()))},dependencies:[Fe],styles:["[_nghost-%COMP%]{display:inline-flex;white-space:nowrap}.first-text-part[_ngcontent-%COMP%]{flex:1 1 4ch;max-width:max-content}.first-text-part[_ngcontent-%COMP%], .second-text-part[_ngcontent-%COMP%]{overflow:hidden;text-overflow:ellipsis}"]}),n})();function N1e(n,t){1&n&&P(0,"mat-icon",2)}function L1e(n,t){1&n&&P(0,"mat-icon",3)}var Qg=(()=>{class n{constructor(){this.isClipped=!1,this.isClosestStepHighlighted=!1}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["vis-linked-time-selection-warning"]],inputs:{isClipped:"isClipped",isClosestStepHighlighted:"isClosestStepHighlighted"},decls:2,vars:2,consts:[["data-value","clipped","svgIcon","info_outline_24px","title","Linked step is not found in this visualization. We highlighted the closest step for you.",4,"ngIf"],["data-value","closestStepHighlighted","svgIcon","info_outline_24px","title","Data is not found on selected step. We highlighted the closest step for you.",4,"ngIf"],["data-value","clipped","svgIcon","info_outline_24px","title","Linked step is not found in this visualization. We highlighted the closest step for you."],["data-value","closestStepHighlighted","svgIcon","info_outline_24px","title","Data is not found on selected step. We highlighted the closest step for you."]],template:function(e,i){1&e&&(S(0,N1e,1,0,"mat-icon",0),S(1,L1e,1,0,"mat-icon",1)),2&e&&(_("ngIf",i.isClipped),v(1),_("ngIf",i.isClosestStepHighlighted))},dependencies:[Fe,En],styles:["[_nghost-%COMP%]{color:#d32f2f;height:1em;line-height:0;display:inline-flex}body.dark-mode   [_nghost-%COMP%]{color:#d32f2f}[_nghost-%COMP%]   mat-icon[_ngcontent-%COMP%]{height:100%;width:100%}"],changeDetection:0}),n})();function B1e(n,t){if(1&n&&(h(0,"span",19),T(1),j(2,"number"),g()),2&n){let e=w();v(1),He("Step ",W(2,1,e.steps[e.stepIndex]),"")}}function V1e(n,t){if(1&n&&(h(0,"span",20),T(1),j(2,"number"),j(3,"number"),g()),2&n){let e=w();v(1),lu("Sample ",W(2,2,e.sample+1),"/",W(3,4,e.numSample),"")}}function H1e(n,t){1&n&&P(0,"mat-spinner",21)}function z1e(n,t){if(1&n&&(h(0,"span"),P(1,"span",30)(2,"span",31),g()),2&n){let e=w(3);v(2),Tt("left",e.sliderStartPosition)("width",e.sliderTrackWidth)}}function U1e(n,t){if(1&n&&P(0,"div",32),2&n){let e=t.$implicit,i=w(3);Tt("left",i.getLinkedTimeTickLeftStyle(e))("margin-left",i.getLinkedTimeTickMarginLeftStyle(e))}}function j1e(n,t){if(1&n&&(h(0,"div",27),S(1,z1e,3,4,"span",28),S(2,U1e,1,4,"div",29),g()),2&n){let e=w(2);v(1),_("ngIf",null!==e.linkedTimeSelection.endStep),v(1),_("ngForOf",e.selectedSteps)}}var G1e=function(n){return[n]},W1e=function(n){return{filter:n}};function q1e(n,t){if(1&n){let e=ge();Ot(0),h(1,"div",22)(2,"mat-slider",23),I("input",function(r){return X(e),Q(w().onSliderInput(r))}),g(),S(3,j1e,3,2,"div",24),g(),h(4,"div",25),P(5,"img",26),g(),kt()}if(2&n){let e=w();v(2),_("ngClass",In(11,G1e,e.linkedTimeSelection&&null!==e.linkedTimeSelection.endStep?"hide-slider":""))("disabled",e.steps.length<=1)("min",0)("max",e.steps.length-1)("step",1)("tickInterval",1)("value",e.stepIndex),v(1),_("ngIf",e.linkedTimeSelection),v(2),fb("alt","Image at step ",e.steps[e.stepIndex],""),Wi("src",e.imageUrl,ka),_("ngStyle",In(13,W1e,e.cssFilter()))}}function Y1e(n,t){1&n&&(h(0,"div",34),T(1," Data failed to load. "),g())}function X1e(n,t){if(1&n&&S(0,Y1e,2,0,"div",33),2&n){let e=w();_("ngIf",e.loadState===e.DataLoadState.FAILED)}}var Q1e=function(n){return{backgroundColor:n}},AQ=(()=>{class n{constructor(){this.DataLoadState=Te,this.sliderStartPosition="",this.sliderTrackWidth="",this.linkedTimeSelection=null,this.isClosestStepHighlighted=!1,this.onActualSizeToggle=new F,this.stepIndexChange=new F,this.onPinClicked=new F}cssFilter(){return`contrast(${this.contrastInMilli/10}%) brightness(${this.brightnessInMilli/1e3})`}onSliderInput(e){this.stepIndexChange.emit(e.value)}changeDistinct(e){return e.currentValue!==e.previousValue}ngOnChanges(e){(e.selectedSteps&&this.changeDistinct(e.selectedSteps)||e.linkedTimeSelection&&this.changeDistinct(e.linkedTimeSelection))&&this.renderRangeSlider()}renderRangeSlider(){if(!this.linkedTimeSelection||!this.linkedTimeSelection.endStep)return;let e=this.steps.length-1,i=this.linkedTimeSelection.startStep<this.steps[0]?this.steps[0]:this.linkedTimeSelection.startStep,r=this.linkedTimeSelection.endStep>this.steps[e]?this.steps[e]:this.linkedTimeSelection.endStep,{startPosition:o,width:s}=this.getTrackStartPositionAndWidth(i,r,e);this.sliderStartPosition=100*o+"%",this.sliderTrackWidth=100*s+"%"}getTrackStartPositionAndWidth(e,i,r){let o=1/r,s=0,a=0,l=0;for(;l<this.steps.length-1;l++){let c=this.steps[l],d=this.steps[l+1];if(c<=e&&e<=d){s+=(e-c)/(d-c);break}}for(s=(s+l)*o;l<this.steps.length-1;l++){let c=this.steps[l],d=this.steps[l+1];if(e>=c&&i<=d){a=(i-e)/(d-c);break}if(e>=c&&i>=d)a+=(d-e)/(d-c);else{if(!(i>=d)){a+=(i-c)/(d-c);break}a+=1}}return a*=o,(s>1||s<0)&&(s=0),{startPosition:s,width:a}}getLinkedTimeTickLeftStyle(e){if(-1==this.steps.indexOf(e))throw new Error("Invalid stepIndex: stepIndex value is not included in steps");return this.steps.indexOf(e)/(this.steps.length-1)*100+"%"}getLinkedTimeTickMarginLeftStyle(e){if(-1==this.steps.indexOf(e))throw new Error("Invalid stepIndex: stepIndex value is not included in steps");return`-${this.steps.indexOf(e)/(this.steps.length-1)*14}px`}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["image-card-component"]],hostVars:2,hostBindings:function(e,i){2&e&&nt("actual-size",i.showActualSize)},inputs:{loadState:"loadState",title:"title",tag:"tag",runId:"runId",sample:"sample",numSample:"numSample",imageUrl:"imageUrl",stepIndex:"stepIndex",steps:"steps",brightnessInMilli:"brightnessInMilli",contrastInMilli:"contrastInMilli",showActualSize:"showActualSize",runColorScale:"runColorScale",allowToggleActualSize:"allowToggleActualSize",isPinned:"isPinned",selectedSteps:"selectedSteps",linkedTimeSelection:"linkedTimeSelection",isClosestStepHighlighted:"isClosestStepHighlighted"},outputs:{onActualSizeToggle:"onActualSizeToggle",stepIndexChange:"stepIndexChange",onPinClicked:"onPinClicked"},features:[Gt],decls:21,vars:16,consts:function(){let t,e;return t=$localize`:A button to pin a card.␟e665dc712bd5f18d4dfa3a29e125d565cc51e2f6␟7284606426234375344:Pin card`,e=$localize`:A button on an image card that toggles actual image size.␟3ca05ef3a6e3a37065f5e0f69c5d5a2178d90791␟7635101936664789140:Toggle actual image size`,[[1,"heading"],[1,"line"],[1,"tag"],[1,"tag-path",3,"title","value"],[3,"isClipped","isClosestStepHighlighted"],[1,"controls"],["mat-icon-button","","aria-label",t,3,"click"],[3,"svgIcon"],["mat-icon-button","","aria-label",e,"title","Toggle actual image size",3,"disabled","click"],["svgIcon","image_search_24px"],[1,"run"],[1,"dot",3,"ngStyle"],[1,"run-text",3,"runId"],[1,"metadata"],["class","step",4,"ngIf"],["class","sample",4,"ngIf"],["class","loading","diameter","18",4,"ngIf"],[4,"ngIf","ngIfElse"],["noImageData",""],[1,"step"],[1,"sample"],["diameter","18",1,"loading"],[1,"slider-row"],["color","primary",1,"step-slider",3,"ngClass","disabled","min","max","step","tickInterval","value","input"],["class","linked-time-wrapper",4,"ngIf"],[1,"img-container"],[3,"alt","src","ngStyle","includeFeatureFlags"],[1,"linked-time-wrapper"],[4,"ngIf"],["class","linked-time-tick",3,"left","margin-left",4,"ngFor","ngForOf"],[1,"slider-track"],[1,"slider-track-fill"],[1,"linked-time-tick"],["class","empty-message",4,"ngIf"],[1,"empty-message"]]},template:function(e,i){if(1&e&&(h(0,"div",0)(1,"div",1)(2,"span",2),P(3,"tb-truncated-path",3)(4,"vis-linked-time-selection-warning",4),g(),h(5,"span",5)(6,"button",6),I("click",function(){return i.onPinClicked.emit(!i.isPinned)}),P(7,"mat-icon",7),g(),h(8,"button",8),I("click",function(){return i.onActualSizeToggle.emit()}),P(9,"mat-icon",9),g()()(),h(10,"div",1)(11,"span",10),P(12,"span",11)(13,"card-run-name",12),g(),h(14,"div",13),S(15,B1e,3,3,"span",14),S(16,V1e,4,6,"span",15),S(17,H1e,1,0,"mat-spinner",16),g()()(),S(18,q1e,6,15,"ng-container",17),S(19,X1e,1,1,"ng-template",null,18,Wt)),2&e){let r=it(20);v(3),Wi("title",i.tag),Wi("value",i.title),v(1),_("isClipped",i.linkedTimeSelection&&i.linkedTimeSelection.clipped)("isClosestStepHighlighted",i.isClosestStepHighlighted),v(2),Be("title",i.isPinned?"Unpin card":"Pin card"),v(1),_("svgIcon",i.isPinned?"keep_24px":"keep_outline_24px"),v(1),_("disabled",!i.allowToggleActualSize),v(4),_("ngStyle",In(14,Q1e,i.runColorScale(i.runId))),v(1),_("runId",i.runId),v(2),_("ngIf",null!==i.stepIndex&&i.stepIndex<i.steps.length),v(1),_("ngIf",i.numSample>1),v(1),_("ngIf",i.loadState===i.DataLoadState.LOADING),v(1),_("ngIf",null!==i.stepIndex&&i.stepIndex<i.steps.length)("ngIfElse",r)}},dependencies:[yn,nn,Fe,pu,GT,$i,En,tl,Dd,qT,Xg,Qg,La],styles:["[_nghost-%COMP%]{box-sizing:border-box;display:flex;flex-basis:318px;flex-direction:column;flex-grow:1;height:100%;overflow:auto;padding:16px;padding-top:4px}.actual-size[_nghost-%COMP%]{height:auto}.heading[_ngcontent-%COMP%]{align-items:center;font-size:14px;margin-bottom:4px;position:relative}.line[_ngcontent-%COMP%]{align-items:center;display:grid;grid-template-columns:1fr max-content}.tag[_ngcontent-%COMP%]{align-items:center;display:flex;gap:5px}.metadata[_ngcontent-%COMP%]{display:flex;flex-wrap:wrap;gap:5px;justify-content:flex-end;max-width:175px;text-align:end}.tag-path[_ngcontent-%COMP%]{overflow:hidden}.run[_ngcontent-%COMP%]{align-self:baseline;display:flex;overflow:hidden;white-space:nowrap}.run[_ngcontent-%COMP%]   .dot[_ngcontent-%COMP%]{flex:none;display:inline-block;width:13px;height:13px;border-radius:50%;margin-right:4px}.run[_ngcontent-%COMP%]   .run-text[_ngcontent-%COMP%]{overflow:hidden;text-overflow:ellipsis;max-width:120px}.run[_ngcontent-%COMP%], .sample[_ngcontent-%COMP%], .step[_ngcontent-%COMP%]{color:#616161;font-size:13px}body.dark-mode[_nghost-%COMP%]   .run[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .run[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}body.dark-mode[_nghost-%COMP%]   .sample[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .sample[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}body.dark-mode[_nghost-%COMP%]   .step[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .step[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}.controls[_ngcontent-%COMP%]{color:#616161;white-space:nowrap;justify-self:flex-end;flex-shrink:0;margin-right:-12px}body.dark-mode[_nghost-%COMP%]   .controls[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .controls[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}.img-container[_ngcontent-%COMP%]{flex-grow:1;overflow-y:auto;position:relative}.img-container[_ngcontent-%COMP%]   img[_ngcontent-%COMP%]{image-rendering:-moz-crisp-edges;image-rendering:pixelated}.actual-size[_nghost-%COMP%]   .img-container[_ngcontent-%COMP%]{overflow:auto;flex:none}[_nghost-%COMP%]:not(.actual-size)   img[_ngcontent-%COMP%]{position:absolute;max-height:100%;max-width:100%;width:auto;height:100%;object-fit:contain}.slider-row[_ngcontent-%COMP%]{display:flex;align-items:center;height:24px;position:relative}.step-slider[_ngcontent-%COMP%]{flex:1}[_nghost-%COMP%]     .mat-slider-min-value .mat-slider-thumb{background-color:#f57c00}[_nghost-%COMP%]     .hide-slider.mat-slider-horizontal .mat-slider-track-wrapper{height:0}.empty-message[_ngcontent-%COMP%]{margin-top:1em;font-size:13px}.linked-time-wrapper[_ngcontent-%COMP%]{position:absolute;top:5px;width:100%}.linked-time-tick[_ngcontent-%COMP%]{background-color:#e0e0e0;border-radius:50%;height:14px;position:absolute;width:14px}body.dark-mode[_nghost-%COMP%]   .linked-time-tick[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .linked-time-tick[_ngcontent-%COMP%]{background-color:#212121}.slider-track[_ngcontent-%COMP%], .slider-track-fill[_ngcontent-%COMP%]{height:2px;top:6px;position:absolute}.slider-track[_ngcontent-%COMP%]{background:rgba(0,0,0,.26);left:7px;width:calc(100% - 14px)}body.dark-mode[_nghost-%COMP%]   .slider-track[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .slider-track[_ngcontent-%COMP%]{background:rgba(255,255,255,.3)}.slider-track-fill[_ngcontent-%COMP%]{background:#f57c00}body.dark-mode[_nghost-%COMP%]   .slider-track-fill[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .slider-track-fill[_ngcontent-%COMP%]{background:#ef6c00}"],changeDetection:0}),n})(),RQ=(()=>{class n{constructor(e,i){this.store=e,this.dataSource=i,this.fullWidthChanged=new F,this.pinStateChanged=new F,this.brightnessInMilli$=this.store.select(i1),this.contrastInMilli$=this.store.select(r1),this.actualSizeGlobalSetting$=this.store.select(o1),this.showActualSize=!1,this.actualSizeUiToggled=!1,this.actualSizeUiToggleSubject=new Ai(this.actualSizeUiToggled),this.ngUnsubscribe=new Ie}onStepIndexChanged(e){this.store.dispatch(AT({cardId:this.cardId,stepIndex:e}))}isImageCardMetadata(e){let{plugin:i}=e;return i===zn.IMAGES}onActualSizeToggle(){this.actualSizeUiToggled=!this.actualSizeUiToggled,this.actualSizeUiToggleSubject.next(this.actualSizeUiToggled)}ngOnInit(){dn([this.actualSizeGlobalSetting$,this.actualSizeUiToggleSubject]).pipe(ot(this.ngUnsubscribe),Nt(([l,c])=>{this.showActualSize=l||c,this.fullWidthChanged.emit(this.showActualSize)})).subscribe(()=>{});let i=this.store.select(Wa,this.cardId).pipe(ot(this.ngUnsubscribe),ke(l=>!!l&&this.isImageCardMetadata(l)),N(l=>l),Ms(1)),o=dn([i,this.store.select(Cu,this.cardId)]).pipe(ot(this.ngUnsubscribe),N(([l,c])=>{let d=l.runId;return c&&c.hasOwnProperty(d)?c[d]:[]}),Yn((l,c)=>l.length===c.length&&0===l.length||l===c),Ms(1));this.stepIndex$=this.store.select(qF,this.cardId).pipe(N(l=>l?l.index:null)),this.isClosestStepHighlighted$=this.store.select(qF,this.cardId).pipe(N(l=>!!l&&l.isClosest)),this.loadState$=this.store.select(_d,this.cardId),this.tag$=i.pipe(N(l=>l.tag)),this.title$=this.tag$.pipe(N(l=>Yg(l,this.groupName))),this.runId$=i.pipe(N(l=>l.runId)),this.sample$=i.pipe(N(l=>l.sample)),this.numSample$=i.pipe(N(l=>l.numSample)),this.steps$=this.store.select(vW,this.cardId),this.isPinned$=this.store.select(Mu,this.cardId),this.linkedTimeSelection$=this.store.select(Eu).pipe(Li(this.steps$),N(([l,c])=>l?Uh(l,Math.min(...c),Math.max(...c)):null)),this.selectedSteps$=this.linkedTimeSelection$.pipe(Li(this.steps$),N(([l,c])=>l?null===l.endStep?-1!==c.indexOf(l.startStep)?[l.startStep]:[]:c.filter(d=>d>=l.startStep&&d<=l.endStep):[]));let a=dn([o,this.stepIndex$]).pipe(N(([l,c])=>null!==c&&l[c]?l[c]:null));this.imageUrl$=a.pipe(N(l=>l?this.dataSource.imageUrl(l.imageId):null))}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}}return n.\u0275fac=function(e){return new(e||n)(C(Ae),C(Tc))},n.\u0275cmp=O({type:n,selectors:[["image-card"]],inputs:{cardId:"cardId",groupName:"groupName",runColorScale:"runColorScale"},outputs:{fullWidthChanged:"fullWidthChanged",pinStateChanged:"pinStateChanged"},decls:17,vars:50,consts:[[3,"loadState","title","tag","runId","sample","numSample","imageUrl","stepIndex","steps","isClosestStepHighlighted","brightnessInMilli","contrastInMilli","runColorScale","showActualSize","allowToggleActualSize","isPinned","linkedTimeSelection","selectedSteps","stepIndexChange","onActualSizeToggle","onPinClicked"]],template:function(e,i){1&e&&(h(0,"image-card-component",0),I("stepIndexChange",function(o){return i.onStepIndexChanged(o)})("onActualSizeToggle",function(){return i.onActualSizeToggle()})("onPinClicked",function(o){return i.pinStateChanged.emit(o)}),j(1,"async"),j(2,"async"),j(3,"async"),j(4,"async"),j(5,"async"),j(6,"async"),j(7,"async"),j(8,"async"),j(9,"async"),j(10,"async"),j(11,"async"),j(12,"async"),j(13,"async"),j(14,"async"),j(15,"async"),j(16,"async"),g()),2&e&&_("loadState",W(1,18,i.loadState$))("title",W(2,20,i.title$))("tag",W(3,22,i.tag$))("runId",W(4,24,i.runId$))("sample",W(5,26,i.sample$))("numSample",W(6,28,i.numSample$))("imageUrl",W(7,30,i.imageUrl$))("stepIndex",W(8,32,i.stepIndex$))("steps",W(9,34,i.steps$))("isClosestStepHighlighted",W(10,36,i.isClosestStepHighlighted$))("brightnessInMilli",W(11,38,i.brightnessInMilli$))("contrastInMilli",W(12,40,i.contrastInMilli$))("runColorScale",i.runColorScale)("showActualSize",i.showActualSize)("allowToggleActualSize",!1===W(13,42,i.actualSizeGlobalSetting$))("isPinned",W(14,44,i.isPinned$))("linkedTimeSelection",W(15,46,i.linkedTimeSelection$))("selectedSteps",W(16,48,i.selectedSteps$))},dependencies:[AQ,ct],styles:["[_nghost-%COMP%] {\n        display: flex;\n        flex-direction: column;\n        height: 100%;\n      }"],changeDetection:0}),n})(),Qi=(()=>(function(n){n[n.SVG=0]="SVG",n[n.WEBGL=1]="WEBGL"}(Qi||(Qi={})),Qi))(),nr=(()=>(function(n){n[n.LINEAR=0]="LINEAR",n[n.LOG10=1]="LOG10",n[n.TIME=2]="TIME"}(nr||(nr={})),nr))(),Ir=(()=>(function(n){n.NONE="NONE",n.DRAG_ZOOMING="DRAG_ZOOMING",n.SCROLL_ZOOMING="SCROLL_ZOOMING",n.PANNING="PANNING"}(Ir||(Ir={})),Ir))();function $1e(n,t){1&n&&(h(0,"span"),T(1,"scalar"),g())}function eEe(n,t){1&n&&(h(0,"span"),T(1,"histogram"),g())}function tEe(n,t){1&n&&(h(0,"span"),T(1,"unknown"),g())}function nEe(n,t){if(1&n&&(Ot(0,13),S(1,$1e,2,0,"span",14),S(2,eEe,2,0,"span",14),S(3,tEe,2,0,"span",15),kt()),2&n){let e=w(2);_("ngSwitch",e.cardMetadata.plugin),v(1),_("ngSwitchCase",e.PluginType.SCALARS),v(1),_("ngSwitchCase",e.PluginType.HISTOGRAMS)}}function iEe(n,t){1&n&&li(0)}function rEe(n,t){if(1&n&&(h(0,"option",16),T(1),g()),2&n){let e=t.$implicit;_("value",e.id),v(1),bt(e.name)}}function oEe(n,t){if(1&n){let e=ge();Ot(0),h(1,"h2"),S(2,nEe,4,3,"ng-template",null,2,Wt),h(4,"span"),T(5,"Download\xa0"),g(),S(6,iEe,1,0,"ng-container",3),h(7,"span"),T(8,"\xa0data for\xa0"),g(),h(9,"code",4),T(10),g()(),h(11,"mat-dialog-content")(12,"mat-form-field",5)(13,"mat-label"),T(14,"Select a run to download a data for a series"),g(),h(15,"select",6),I("change",function(r){return X(e),Q(w().runSelected.emit(r.target.value))}),h(16,"option",7),T(17,"-"),g(),S(18,rEe,2,2,"option",8),g()(),h(19,"div",9)(20,"span"),T(21,"Download as\u2026"),g(),T(22,"\xa0"),h(23,"a",10),T(24,"JSON"),g(),h(25,"a",10),T(26,"CSV"),g()()(),h(27,"mat-dialog-actions",11)(28,"button",12),T(29,"Close"),g()(),kt()}if(2&n){let e=it(3),i=w();v(6),_("ngTemplateOutlet",e),v(3),_("title",i.cardMetadata.tag),v(1),bt(i.cardMetadata.tag),v(5),_("value",i.selectedRunId||""),v(1),_("value",""),v(2),_("ngForOf",i.runs),v(5),_("disabled",!i.downloadUrlJson)("download",i.getDownloadName("json"))("href",i.downloadUrlJson,ka),v(2),_("disabled",!i.downloadUrlCsv)("download",i.getDownloadName("csv"))("href",i.downloadUrlCsv,ka)}}function sEe(n,t){1&n&&T(0,"Loading...")}var OQ=(()=>{class n{constructor(){this.runSelected=new F,this.PluginType=zn}getDownloadName(e){let i=this.runs.find(r=>r.id===this.selectedRunId);return i?`${i.name}.${e}`:""}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["data_download_dialog_component"]],inputs:{cardMetadata:"cardMetadata",runs:"runs",selectedRunId:"selectedRunId",downloadUrlCsv:"downloadUrlCsv",downloadUrlJson:"downloadUrlJson"},outputs:{runSelected:"runSelected"},decls:3,vars:2,consts:[[4,"ngIf","ngIfElse"],["noCardMetadata",""],["dataName",""],[4,"ngTemplateOutlet"],[1,"tag-name",3,"title"],["appearance","fill",1,"run-selector"],["matNativeControl","","name","run","cdkFocusInitial","","required","",3,"value","change"],["selected","",3,"value"],[3,"value",4,"ngFor","ngForOf"],[1,"download-controls"],["mat-stroked-button","",3,"disabled","download","href","includeFeatureFlags"],["align","end"],["mat-button","","mat-dialog-close",""],[3,"ngSwitch"],[4,"ngSwitchCase"],[4,"NgSwitchDefault"],[3,"value"]],template:function(e,i){if(1&e&&(S(0,oEe,30,12,"ng-container",0),S(1,sEe,1,0,"ng-template",null,1,Wt)),2&e){let r=it(2);_("ngIf",i.cardMetadata)("ngIfElse",r)}},dependencies:[nn,Fe,Lr,sr,Sr,GT,uq,fq,R7,Ji,Z1,K1,J1,Uu,Ka,kc],styles:["h2[_ngcontent-%COMP%]{font-size:1.25em;overflow-wrap:break-word}.run-selector[_ngcontent-%COMP%]{font-size:.9em;width:100%}.download-controls[_ngcontent-%COMP%]{font-size:.9em}.download-controls[_ngcontent-%COMP%]   a[_ngcontent-%COMP%]{margin:3px 10px 3px 0}"],changeDetection:0}),n})(),kQ=(()=>{class n{constructor(e,i,r){this.selectedRunId$=new Ai(null),this.cardMetadata$=e.select(Wa,r.cardId).pipe(ke(o=>Boolean(o))),this.downloadUrlCsv$=dn([e.select(Wa,r.cardId),this.selectedRunId$]).pipe(N(([o,s])=>o&&s?i.downloadUrl(o.plugin,o.tag,s,"csv"):null),qn(null)),this.downloadUrlJson$=dn([e.select(Wa,r.cardId),this.selectedRunId$]).pipe(N(([o,s])=>o&&s?i.downloadUrl(o.plugin,o.tag,s,"json"):null),qn(null)),this.runs$=dn([e.select(VW),e.select(Cu,r.cardId)]).pipe(N(([o,s])=>s?Object.keys(s).map(a=>o.get(a)).filter(Boolean):[]))}}return n.\u0275fac=function(e){return new(e||n)(C(Ae),C(Tc),C(Xv))},n.\u0275cmp=O({type:n,selectors:[["data_download_dialog"]],decls:6,vars:15,consts:[[3,"cardMetadata","runs","selectedRunId","downloadUrlCsv","downloadUrlJson","runSelected"]],template:function(e,i){1&e&&(h(0,"data_download_dialog_component",0),I("runSelected",function(o){return i.selectedRunId$.next(o)}),j(1,"async"),j(2,"async"),j(3,"async"),j(4,"async"),j(5,"async"),g()),2&e&&_("cardMetadata",W(1,5,i.cardMetadata$))("runs",W(2,7,i.runs$))("selectedRunId",W(3,9,i.selectedRunId$))("downloadUrlCsv",W(4,11,i.downloadUrlCsv$))("downloadUrlJson",W(5,13,i.downloadUrlJson$))},dependencies:[OQ,ct],encapsulation:2,changeDetection:0}),n})();function il(n,t){return n<t?-1:n>t?1:n>=t?0:NaN}function Cy(n){return 1===n.length&&(n=function(n){return function(t,e){return il(n(t),e)}}(n)),{left:function(t,e,i,r){for(null==i&&(i=0),null==r&&(r=t.length);i<r;){var o=i+r>>>1;n(t[o],e)<0?i=o+1:r=o}return i},right:function(t,e,i,r){for(null==i&&(i=0),null==r&&(r=t.length);i<r;){var o=i+r>>>1;n(t[o],e)>0?r=o:i=o+1}return i}}}var Hc=Cy(il).right,BN=Math.sqrt(50),VN=Math.sqrt(10),HN=Math.sqrt(2);function My(n,t,e){var i,o,s,a,r=-1;if(e=+e,(n=+n)==(t=+t)&&e>0)return[n];if((i=t<n)&&(o=n,n=t,t=o),0===(a=Zg(n,t,e))||!isFinite(a))return[];if(a>0)for(n=Math.ceil(n/a),t=Math.floor(t/a),s=new Array(o=Math.ceil(t-n+1));++r<o;)s[r]=(n+r)*a;else for(n=Math.floor(n*a),t=Math.ceil(t*a),s=new Array(o=Math.ceil(n-t+1));++r<o;)s[r]=(n-r)/a;return i&&s.reverse(),s}function Zg(n,t,e){var i=(t-n)/Math.max(0,e),r=Math.floor(Math.log(i)/Math.LN10),o=i/Math.pow(10,r);return r>=0?(o>=BN?10:o>=VN?5:o>=HN?2:1)*Math.pow(10,r):-Math.pow(10,-r)/(o>=BN?10:o>=VN?5:o>=HN?2:1)}function Ad(n,t,e){var i=Math.abs(t-n)/Math.max(0,e),r=Math.pow(10,Math.floor(Math.log(i)/Math.LN10)),o=i/r;return o>=BN?r*=10:o>=VN?r*=5:o>=HN&&(r*=2),t<n?-r:r}var XT=Array.prototype.slice;function HQ(n){return n}var UN=1,ZT=2,jN=3,QT=4,zQ=1e-6;function _Ee(n){return"translate("+(n+.5)+",0)"}function bEe(n){return"translate(0,"+(n+.5)+")"}function vEe(n){return function(t){return+n(t)}}function yEe(n){var t=Math.max(0,n.bandwidth()-1)/2;return n.round()&&(t=Math.round(t)),function(e){return+n(e)+t}}function xEe(){return!this.__axis}function UQ(n,t){var e=[],i=null,r=null,o=6,s=6,a=3,l=n===UN||n===QT?-1:1,c=n===QT||n===ZT?"x":"y",d=n===UN||n===jN?_Ee:bEe;function u(p){var f=i??(t.ticks?t.ticks.apply(t,e):t.domain()),m=r??(t.tickFormat?t.tickFormat.apply(t,e):HQ),b=Math.max(o,0)+a,M=t.range(),y=+M[0]+.5,x=+M[M.length-1]+.5,R=(t.bandwidth?yEe:vEe)(t.copy()),A=p.selection?p.selection():p,V=A.selectAll(".domain").data([null]),te=A.selectAll(".tick").data(f,t).order(),K=te.exit(),xe=te.enter().append("g").attr("class","tick"),Xe=te.select("line"),De=te.select("text");V=V.merge(V.enter().insert("path",".tick").attr("class","domain").attr("stroke","currentColor")),te=te.merge(xe),Xe=Xe.merge(xe.append("line").attr("stroke","currentColor").attr(c+"2",l*o)),De=De.merge(xe.append("text").attr("fill","currentColor").attr(c,l*b).attr("dy",n===UN?"0em":n===jN?"0.71em":"0.32em")),p!==A&&(V=V.transition(p),te=te.transition(p),Xe=Xe.transition(p),De=De.transition(p),K=K.transition(p).attr("opacity",zQ).attr("transform",function(D){return isFinite(D=R(D))?d(D):this.getAttribute("transform")}),xe.attr("opacity",zQ).attr("transform",function(D){var re=this.parentNode.__axis;return d(re&&isFinite(re=re(D))?re:R(D))})),K.remove(),V.attr("d",n===QT||n==ZT?s?"M"+l*s+","+y+"H0.5V"+x+"H"+l*s:"M0.5,"+y+"V"+x:s?"M"+y+","+l*s+"V0.5H"+x+"V"+l*s:"M"+y+",0.5H"+x),te.attr("opacity",1).attr("transform",function(D){return d(R(D))}),Xe.attr(c+"2",l*o),De.attr(c,l*b).text(m),A.filter(xEe).attr("fill","none").attr("font-size",10).attr("font-family","sans-serif").attr("text-anchor",n===ZT?"start":n===QT?"end":"middle"),A.each(function(){this.__axis=R})}return u.scale=function(p){return arguments.length?(t=p,u):t},u.ticks=function(){return e=XT.call(arguments),u},u.tickArguments=function(p){return arguments.length?(e=null==p?[]:XT.call(p),u):e.slice()},u.tickValues=function(p){return arguments.length?(i=null==p?null:XT.call(p),u):i&&i.slice()},u.tickFormat=function(p){return arguments.length?(r=p,u):r},u.tickSize=function(p){return arguments.length?(o=s=+p,u):o},u.tickSizeInner=function(p){return arguments.length?(o=+p,u):o},u.tickSizeOuter=function(p){return arguments.length?(s=+p,u):s},u.tickPadding=function(p){return arguments.length?(a=+p,u):a},u}var CEe={value:function(){}};function GQ(){for(var i,n=0,t=arguments.length,e={};n<t;++n){if(!(i=arguments[n]+"")||i in e||/[\s.]/.test(i))throw new Error("illegal type: "+i);e[i]=[]}return new KT(e)}function KT(n){this._=n}function wEe(n,t){for(var r,e=0,i=n.length;e<i;++e)if((r=n[e]).name===t)return r.value}function jQ(n,t,e){for(var i=0,r=n.length;i<r;++i)if(n[i].name===t){n[i]=CEe,n=n.slice(0,i).concat(n.slice(i+1));break}return null!=e&&n.push({name:t,value:e}),n}KT.prototype=GQ.prototype={constructor:KT,on:function(n,t){var r,e=this._,i=function(n,t){return n.trim().split(/^|\s+/).map(function(e){var i="",r=e.indexOf(".");if(r>=0&&(i=e.slice(r+1),e=e.slice(0,r)),e&&!t.hasOwnProperty(e))throw new Error("unknown type: "+e);return{type:e,name:i}})}(n+"",e),o=-1,s=i.length;if(!(arguments.length<2)){if(null!=t&&"function"!=typeof t)throw new Error("invalid callback: "+t);for(;++o<s;)if(r=(n=i[o]).type)e[r]=jQ(e[r],n.name,t);else if(null==t)for(r in e)e[r]=jQ(e[r],n.name,null);return this}for(;++o<s;)if((r=(n=i[o]).type)&&(r=wEe(e[r],n.name)))return r},copy:function(){var n={},t=this._;for(var e in t)n[e]=t[e].slice();return new KT(n)},call:function(n,t){if((r=arguments.length-2)>0)for(var r,o,e=new Array(r),i=0;i<r;++i)e[i]=arguments[i+2];if(!this._.hasOwnProperty(n))throw new Error("unknown type: "+n);for(i=0,r=(o=this._[n]).length;i<r;++i)o[i].value.apply(t,e)},apply:function(n,t,e){if(!this._.hasOwnProperty(n))throw new Error("unknown type: "+n);for(var i=this._[n],r=0,o=i.length;r<o;++r)i[r].value.apply(t,e)}};var qN=GQ,JT="http://www.w3.org/1999/xhtml",YN={svg:"http://www.w3.org/2000/svg",xhtml:JT,xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/"};function Rd(n){var t=n+="",e=t.indexOf(":");return e>=0&&"xmlns"!==(t=n.slice(0,e))&&(n=n.slice(e+1)),YN.hasOwnProperty(t)?{space:YN[t],local:n}:n}function SEe(n){return function(){var t=this.ownerDocument,e=this.namespaceURI;return e===JT&&t.documentElement.namespaceURI===JT?t.createElement(n):t.createElementNS(e,n)}}function EEe(n){return function(){return this.ownerDocument.createElementNS(n.space,n.local)}}function $T(n){var t=Rd(n);return(t.local?EEe:SEe)(t)}function TEe(){}function Lf(n){return null==n?TEe:function(){return this.querySelector(n)}}function DEe(){return[]}function Sy(n){return null==n?DEe:function(){return this.querySelectorAll(n)}}function Ey(n){return function(){return this.matches(n)}}function eD(n){return new Array(n.length)}function Ty(n,t){this.ownerDocument=n.ownerDocument,this.namespaceURI=n.namespaceURI,this._next=null,this._parent=n,this.__data__=t}Ty.prototype={constructor:Ty,appendChild:function(n){return this._parent.insertBefore(n,this._next)},insertBefore:function(n,t){return this._parent.insertBefore(n,t)},querySelector:function(n){return this._parent.querySelector(n)},querySelectorAll:function(n){return this._parent.querySelectorAll(n)}};var ZQ="$";function IEe(n,t,e,i,r,o){for(var a,s=0,l=t.length,c=o.length;s<c;++s)(a=t[s])?(a.__data__=o[s],i[s]=a):e[s]=new Ty(n,o[s]);for(;s<l;++s)(a=t[s])&&(r[s]=a)}function AEe(n,t,e,i,r,o,s){var a,l,f,c={},d=t.length,u=o.length,p=new Array(d);for(a=0;a<d;++a)(l=t[a])&&(p[a]=f=ZQ+s.call(l,l.__data__,a,t),f in c?r[a]=l:c[f]=l);for(a=0;a<u;++a)(l=c[f=ZQ+s.call(n,o[a],a,o)])?(i[a]=l,l.__data__=o[a],c[f]=null):e[a]=new Ty(n,o[a]);for(a=0;a<d;++a)(l=t[a])&&c[p[a]]===l&&(r[a]=l)}function REe(n,t){return n<t?-1:n>t?1:n>=t?0:NaN}function PEe(n){return function(){this.removeAttribute(n)}}function OEe(n){return function(){this.removeAttributeNS(n.space,n.local)}}function kEe(n,t){return function(){this.setAttribute(n,t)}}function FEe(n,t){return function(){this.setAttributeNS(n.space,n.local,t)}}function NEe(n,t){return function(){var e=t.apply(this,arguments);null==e?this.removeAttribute(n):this.setAttribute(n,e)}}function LEe(n,t){return function(){var e=t.apply(this,arguments);null==e?this.removeAttributeNS(n.space,n.local):this.setAttributeNS(n.space,n.local,e)}}function tD(n){return n.ownerDocument&&n.ownerDocument.defaultView||n.document&&n||n.defaultView}function BEe(n){return function(){this.style.removeProperty(n)}}function VEe(n,t,e){return function(){this.style.setProperty(n,t,e)}}function HEe(n,t,e){return function(){var i=t.apply(this,arguments);null==i?this.style.removeProperty(n):this.style.setProperty(n,i,e)}}function Zu(n,t){return n.style.getPropertyValue(t)||tD(n).getComputedStyle(n,null).getPropertyValue(t)}function zEe(n){return function(){delete this[n]}}function UEe(n,t){return function(){this[n]=t}}function jEe(n,t){return function(){var e=t.apply(this,arguments);null==e?delete this[n]:this[n]=e}}function pZ(n){return n.trim().split(/^|\s+/)}function XN(n){return n.classList||new fZ(n)}function fZ(n){this._node=n,this._names=pZ(n.getAttribute("class")||"")}function mZ(n,t){for(var e=XN(n),i=-1,r=t.length;++i<r;)e.add(t[i])}function hZ(n,t){for(var e=XN(n),i=-1,r=t.length;++i<r;)e.remove(t[i])}function GEe(n){return function(){mZ(this,n)}}function WEe(n){return function(){hZ(this,n)}}function qEe(n,t){return function(){(t.apply(this,arguments)?mZ:hZ)(this,n)}}function YEe(){this.textContent=""}function XEe(n){return function(){this.textContent=n}}function QEe(n){return function(){var t=n.apply(this,arguments);this.textContent=t??""}}function ZEe(){this.innerHTML=""}function KEe(n){return function(){this.innerHTML=n}}function JEe(n){return function(){var t=n.apply(this,arguments);this.innerHTML=t??""}}function $Ee(){this.nextSibling&&this.parentNode.appendChild(this)}function eTe(){this.previousSibling&&this.parentNode.insertBefore(this,this.parentNode.firstChild)}function tTe(){return null}function nTe(){var n=this.parentNode;n&&n.removeChild(this)}function iTe(){var n=this.cloneNode(!1),t=this.parentNode;return t?t.insertBefore(n,this.nextSibling):n}function rTe(){var n=this.cloneNode(!0),t=this.parentNode;return t?t.insertBefore(n,this.nextSibling):n}fZ.prototype={add:function(n){this._names.indexOf(n)<0&&(this._names.push(n),this._node.setAttribute("class",this._names.join(" ")))},remove:function(n){var t=this._names.indexOf(n);t>=0&&(this._names.splice(t,1),this._node.setAttribute("class",this._names.join(" ")))},contains:function(n){return this._names.indexOf(n)>=0}};var TZ={},QN=null;function oTe(n,t,e){return n=DZ(n,t,e),function(i){var r=i.relatedTarget;(!r||r!==this&&!(8&r.compareDocumentPosition(this)))&&n.call(this,i)}}function DZ(n,t,e){return function(i){var r=QN;QN=i;try{n.call(this,this.__data__,t,e)}finally{QN=r}}}function aTe(n){return function(){var t=this.__on;if(t){for(var o,e=0,i=-1,r=t.length;e<r;++e)o=t[e],n.type&&o.type!==n.type||o.name!==n.name?t[++i]=o:this.removeEventListener(o.type,o.listener,o.capture);++i?t.length=i:delete this.__on}}}function lTe(n,t,e){var i=TZ.hasOwnProperty(n.type)?oTe:DZ;return function(r,o,s){var l,a=this.__on,c=i(t,o,s);if(a)for(var d=0,u=a.length;d<u;++d)if((l=a[d]).type===n.type&&l.name===n.name)return this.removeEventListener(l.type,l.listener,l.capture),this.addEventListener(l.type,l.listener=c,l.capture=e),void(l.value=t);this.addEventListener(n.type,c,e),l={type:n.type,name:n.name,value:t,listener:c,capture:e},a?a.push(l):this.__on=[l]}}function AZ(n,t,e){var i=tD(n),r=i.CustomEvent;"function"==typeof r?r=new r(t,e):(r=i.document.createEvent("Event"),e?(r.initEvent(t,e.bubbles,e.cancelable),r.detail=e.detail):r.initEvent(t,!1,!1)),n.dispatchEvent(r)}function cTe(n,t){return function(){return AZ(this,n,t)}}function dTe(n,t){return function(){return AZ(this,n,t.apply(this,arguments))}}typeof document<"u"&&("onmouseenter"in document.documentElement||(TZ={mouseenter:"mouseover",mouseleave:"mouseout"}));var ZN=[null];function Br(n,t){this._groups=n,this._parents=t}function PZ(){return new Br([[document.documentElement]],ZN)}Br.prototype=PZ.prototype={constructor:Br,select:function(n){"function"!=typeof n&&(n=Lf(n));for(var t=this._groups,e=t.length,i=new Array(e),r=0;r<e;++r)for(var l,c,o=t[r],s=o.length,a=i[r]=new Array(s),d=0;d<s;++d)(l=o[d])&&(c=n.call(l,l.__data__,d,o))&&("__data__"in l&&(c.__data__=l.__data__),a[d]=c);return new Br(i,this._parents)},selectAll:function(n){"function"!=typeof n&&(n=Sy(n));for(var t=this._groups,e=t.length,i=[],r=[],o=0;o<e;++o)for(var l,s=t[o],a=s.length,c=0;c<a;++c)(l=s[c])&&(i.push(n.call(l,l.__data__,c,s)),r.push(l));return new Br(i,r)},filter:function(n){"function"!=typeof n&&(n=Ey(n));for(var t=this._groups,e=t.length,i=new Array(e),r=0;r<e;++r)for(var l,o=t[r],s=o.length,a=i[r]=[],c=0;c<s;++c)(l=o[c])&&n.call(l,l.__data__,c,o)&&a.push(l);return new Br(i,this._parents)},data:function(n,t){if(!n)return f=new Array(this.size()),c=-1,this.each(function(te){f[++c]=te}),f;var e=t?AEe:IEe,i=this._parents,r=this._groups;"function"!=typeof n&&(n=function(n){return function(){return n}}(n));for(var o=r.length,s=new Array(o),a=new Array(o),l=new Array(o),c=0;c<o;++c){var d=i[c],u=r[c],p=u.length,f=n.call(d,d&&d.__data__,c,i),m=f.length,b=a[c]=new Array(m),M=s[c]=new Array(m);e(d,u,b,M,l[c]=new Array(p),f,t);for(var A,V,x=0,R=0;x<m;++x)if(A=b[x]){for(x>=R&&(R=x+1);!(V=M[R])&&++R<m;);A._next=V||null}}return(s=new Br(s,i))._enter=a,s._exit=l,s},enter:function(){return new Br(this._enter||this._groups.map(eD),this._parents)},exit:function(){return new Br(this._exit||this._groups.map(eD),this._parents)},join:function(n,t,e){var i=this.enter(),r=this,o=this.exit();return i="function"==typeof n?n(i):i.append(n+""),null!=t&&(r=t(r)),null==e?o.remove():e(o),i&&r?i.merge(r).order():r},merge:function(n){for(var t=this._groups,e=n._groups,i=t.length,o=Math.min(i,e.length),s=new Array(i),a=0;a<o;++a)for(var p,l=t[a],c=e[a],d=l.length,u=s[a]=new Array(d),f=0;f<d;++f)(p=l[f]||c[f])&&(u[f]=p);for(;a<i;++a)s[a]=t[a];return new Br(s,this._parents)},order:function(){for(var n=this._groups,t=-1,e=n.length;++t<e;)for(var s,i=n[t],r=i.length-1,o=i[r];--r>=0;)(s=i[r])&&(o&&4^s.compareDocumentPosition(o)&&o.parentNode.insertBefore(s,o),o=s);return this},sort:function(n){function t(u,p){return u&&p?n(u.__data__,p.__data__):!u-!p}n||(n=REe);for(var e=this._groups,i=e.length,r=new Array(i),o=0;o<i;++o){for(var c,s=e[o],a=s.length,l=r[o]=new Array(a),d=0;d<a;++d)(c=s[d])&&(l[d]=c);l.sort(t)}return new Br(r,this._parents).order()},call:function(){var n=arguments[0];return arguments[0]=this,n.apply(null,arguments),this},nodes:function(){var n=new Array(this.size()),t=-1;return this.each(function(){n[++t]=this}),n},node:function(){for(var n=this._groups,t=0,e=n.length;t<e;++t)for(var i=n[t],r=0,o=i.length;r<o;++r){var s=i[r];if(s)return s}return null},size:function(){var n=0;return this.each(function(){++n}),n},empty:function(){return!this.node()},each:function(n){for(var t=this._groups,e=0,i=t.length;e<i;++e)for(var a,r=t[e],o=0,s=r.length;o<s;++o)(a=r[o])&&n.call(a,a.__data__,o,r);return this},attr:function(n,t){var e=Rd(n);if(arguments.length<2){var i=this.node();return e.local?i.getAttributeNS(e.space,e.local):i.getAttribute(e)}return this.each((null==t?e.local?OEe:PEe:"function"==typeof t?e.local?LEe:NEe:e.local?FEe:kEe)(e,t))},style:function(n,t,e){return arguments.length>1?this.each((null==t?BEe:"function"==typeof t?HEe:VEe)(n,t,e??"")):Zu(this.node(),n)},property:function(n,t){return arguments.length>1?this.each((null==t?zEe:"function"==typeof t?jEe:UEe)(n,t)):this.node()[n]},classed:function(n,t){var e=pZ(n+"");if(arguments.length<2){for(var i=XN(this.node()),r=-1,o=e.length;++r<o;)if(!i.contains(e[r]))return!1;return!0}return this.each(("function"==typeof t?qEe:t?GEe:WEe)(e,t))},text:function(n){return arguments.length?this.each(null==n?YEe:("function"==typeof n?QEe:XEe)(n)):this.node().textContent},html:function(n){return arguments.length?this.each(null==n?ZEe:("function"==typeof n?JEe:KEe)(n)):this.node().innerHTML},raise:function(){return this.each($Ee)},lower:function(){return this.each(eTe)},append:function(n){var t="function"==typeof n?n:$T(n);return this.select(function(){return this.appendChild(t.apply(this,arguments))})},insert:function(n,t){var e="function"==typeof n?n:$T(n),i=null==t?tTe:"function"==typeof t?t:Lf(t);return this.select(function(){return this.insertBefore(e.apply(this,arguments),i.apply(this,arguments)||null)})},remove:function(){return this.each(nTe)},clone:function(n){return this.select(n?rTe:iTe)},datum:function(n){return arguments.length?this.property("__data__",n):this.node().__data__},on:function(n,t,e){var r,s,i=function(n){return n.trim().split(/^|\s+/).map(function(t){var e="",i=t.indexOf(".");return i>=0&&(e=t.slice(i+1),t=t.slice(0,i)),{type:t,name:e}})}(n+""),o=i.length;if(!(arguments.length<2)){for(a=t?lTe:aTe,null==e&&(e=!1),r=0;r<o;++r)this.each(a(i[r],t,e));return this}var a=this.node().__on;if(a)for(var d,l=0,c=a.length;l<c;++l)for(r=0,d=a[l];r<o;++r)if((s=i[r]).type===d.type&&s.name===d.name)return d.value},dispatch:function(n,t){return this.each(("function"==typeof t?dTe:cTe)(n,t))}};var Pd=PZ;function nD(n){return"string"==typeof n?new Br([[document.querySelector(n)]],[document.documentElement]):new Br([[n]],ZN)}function Bf(n,t,e){n.prototype=t.prototype=e,e.constructor=n}function Kg(n,t){var e=Object.create(n.prototype);for(var i in t)e[i]=t[i];return e}function Ku(){}var rD=1/.7,Jg="\\s*([+-]?\\d+)\\s*",Iy="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",Uc="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",uTe=/^#([0-9a-f]{3,8})$/,pTe=new RegExp("^rgb\\("+[Jg,Jg,Jg]+"\\)$"),fTe=new RegExp("^rgb\\("+[Uc,Uc,Uc]+"\\)$"),mTe=new RegExp("^rgba\\("+[Jg,Jg,Jg,Iy]+"\\)$"),hTe=new RegExp("^rgba\\("+[Uc,Uc,Uc,Iy]+"\\)$"),gTe=new RegExp("^hsl\\("+[Iy,Uc,Uc]+"\\)$"),_Te=new RegExp("^hsla\\("+[Iy,Uc,Uc,Iy]+"\\)$"),OZ={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};function kZ(){return this.rgb().formatHex()}function FZ(){return this.rgb().formatRgb()}function Gl(n){var t,e;return n=(n+"").trim().toLowerCase(),(t=uTe.exec(n))?(e=t[1].length,t=parseInt(t[1],16),6===e?NZ(t):3===e?new Zo(t>>8&15|t>>4&240,t>>4&15|240&t,(15&t)<<4|15&t,1):8===e?iD(t>>24&255,t>>16&255,t>>8&255,(255&t)/255):4===e?iD(t>>12&15|t>>8&240,t>>8&15|t>>4&240,t>>4&15|240&t,((15&t)<<4|15&t)/255):null):(t=pTe.exec(n))?new Zo(t[1],t[2],t[3],1):(t=fTe.exec(n))?new Zo(255*t[1]/100,255*t[2]/100,255*t[3]/100,1):(t=mTe.exec(n))?iD(t[1],t[2],t[3],t[4]):(t=hTe.exec(n))?iD(255*t[1]/100,255*t[2]/100,255*t[3]/100,t[4]):(t=gTe.exec(n))?VZ(t[1],t[2]/100,t[3]/100,1):(t=_Te.exec(n))?VZ(t[1],t[2]/100,t[3]/100,t[4]):OZ.hasOwnProperty(n)?NZ(OZ[n]):"transparent"===n?new Zo(NaN,NaN,NaN,0):null}function NZ(n){return new Zo(n>>16&255,n>>8&255,255&n,1)}function iD(n,t,e,i){return i<=0&&(n=t=e=NaN),new Zo(n,t,e,i)}function $N(n){return n instanceof Ku||(n=Gl(n)),n?new Zo((n=n.rgb()).r,n.g,n.b,n.opacity):new Zo}function $g(n,t,e,i){return 1===arguments.length?$N(n):new Zo(n,t,e,i??1)}function Zo(n,t,e,i){this.r=+n,this.g=+t,this.b=+e,this.opacity=+i}function LZ(){return"#"+KN(this.r)+KN(this.g)+KN(this.b)}function BZ(){var n=this.opacity;return(1===(n=isNaN(n)?1:Math.max(0,Math.min(1,n)))?"rgb(":"rgba(")+Math.max(0,Math.min(255,Math.round(this.r)||0))+", "+Math.max(0,Math.min(255,Math.round(this.g)||0))+", "+Math.max(0,Math.min(255,Math.round(this.b)||0))+(1===n?")":", "+n+")")}function KN(n){return((n=Math.max(0,Math.min(255,Math.round(n)||0)))<16?"0":"")+n.toString(16)}function VZ(n,t,e,i){return i<=0?n=t=e=NaN:e<=0||e>=1?n=t=NaN:t<=0&&(n=NaN),new zc(n,t,e,i)}function HZ(n){if(n instanceof zc)return new zc(n.h,n.s,n.l,n.opacity);if(n instanceof Ku||(n=Gl(n)),!n)return new zc;if(n instanceof zc)return n;var t=(n=n.rgb()).r/255,e=n.g/255,i=n.b/255,r=Math.min(t,e,i),o=Math.max(t,e,i),s=NaN,a=o-r,l=(o+r)/2;return a?(s=t===o?(e-i)/a+6*(e<i):e===o?(i-t)/a+2:(t-e)/a+4,a/=l<.5?o+r:2-o-r,s*=60):a=l>0&&l<1?0:s,new zc(s,a,l,n.opacity)}function Vf(n,t,e,i){return 1===arguments.length?HZ(n):new zc(n,t,e,i??1)}function zc(n,t,e,i){this.h=+n,this.s=+t,this.l=+e,this.opacity=+i}function JN(n,t,e){return 255*(n<60?t+(e-t)*n/60:n<180?e:n<240?t+(e-t)*(240-n)/60:t)}Bf(Ku,Gl,{copy:function(n){return Object.assign(new this.constructor,this,n)},displayable:function(){return this.rgb().displayable()},hex:kZ,formatHex:kZ,formatHsl:function(){return HZ(this).formatHsl()},formatRgb:FZ,toString:FZ}),Bf(Zo,$g,Kg(Ku,{brighter:function(n){return n=null==n?rD:Math.pow(rD,n),new Zo(this.r*n,this.g*n,this.b*n,this.opacity)},darker:function(n){return n=null==n?.7:Math.pow(.7,n),new Zo(this.r*n,this.g*n,this.b*n,this.opacity)},rgb:function(){return this},displayable:function(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:LZ,formatHex:LZ,formatRgb:BZ,toString:BZ})),Bf(zc,Vf,Kg(Ku,{brighter:function(n){return n=null==n?rD:Math.pow(rD,n),new zc(this.h,this.s,this.l*n,this.opacity)},darker:function(n){return n=null==n?.7:Math.pow(.7,n),new zc(this.h,this.s,this.l*n,this.opacity)},rgb:function(){var n=this.h%360+360*(this.h<0),t=isNaN(n)||isNaN(this.s)?0:this.s,e=this.l,i=e+(e<.5?e:1-e)*t,r=2*e-i;return new Zo(JN(n>=240?n-240:n+120,r,i),JN(n,r,i),JN(n<120?n+240:n-120,r,i),this.opacity)},displayable:function(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl:function(){var n=this.opacity;return(1===(n=isNaN(n)?1:Math.max(0,Math.min(1,n)))?"hsl(":"hsla(")+(this.h||0)+", "+100*(this.s||0)+"%, "+100*(this.l||0)+"%"+(1===n?")":", "+n+")")}}));var zZ=Math.PI/180,UZ=180/Math.PI,jZ=.96422,GZ=1,WZ=.82521,qZ=4/29,e0=6/29,YZ=3*e0*e0,vTe=e0*e0*e0;function XZ(n){if(n instanceof jc)return new jc(n.l,n.a,n.b,n.opacity);if(n instanceof Od)return QZ(n);n instanceof Zo||(n=$N(n));var o,s,t=iL(n.r),e=iL(n.g),i=iL(n.b),r=eL((.2225045*t+.7168786*e+.0606169*i)/GZ);return t===e&&e===i?o=s=r:(o=eL((.4360747*t+.3850649*e+.1430804*i)/jZ),s=eL((.0139322*t+.0971045*e+.7141733*i)/WZ)),new jc(116*r-16,500*(o-r),200*(r-s),n.opacity)}function jc(n,t,e,i){this.l=+n,this.a=+t,this.b=+e,this.opacity=+i}function eL(n){return n>vTe?Math.pow(n,1/3):n/YZ+qZ}function tL(n){return n>e0?n*n*n:YZ*(n-qZ)}function nL(n){return 255*(n<=.0031308?12.92*n:1.055*Math.pow(n,1/2.4)-.055)}function iL(n){return(n/=255)<=.04045?n/12.92:Math.pow((n+.055)/1.055,2.4)}function Hf(n,t,e,i){return 1===arguments.length?function(n){if(n instanceof Od)return new Od(n.h,n.c,n.l,n.opacity);if(n instanceof jc||(n=XZ(n)),0===n.a&&0===n.b)return new Od(NaN,0<n.l&&n.l<100?0:NaN,n.l,n.opacity);var t=Math.atan2(n.b,n.a)*UZ;return new Od(t<0?t+360:t,Math.sqrt(n.a*n.a+n.b*n.b),n.l,n.opacity)}(n):new Od(n,t,e,i??1)}function Od(n,t,e,i){this.h=+n,this.c=+t,this.l=+e,this.opacity=+i}function QZ(n){if(isNaN(n.h))return new jc(n.l,0,0,n.opacity);var t=n.h*zZ;return new jc(n.l,Math.cos(t)*n.c,Math.sin(t)*n.c,n.opacity)}function oL(n,t,e,i,r){var o=n*n,s=o*n;return((1-3*n+3*o-s)*t+(4-6*o+3*s)*e+(1+3*n+3*o-3*s)*i+s*r)/6}function t0(n){return function(){return n}}function JZ(n,t){return function(e){return n+e*t}}function sD(n,t){var e=t-n;return e?JZ(n,e>180||e<-180?e-360*Math.round(e/360):e):t0(isNaN(n)?t:n)}function Xs(n,t){var e=t-n;return e?JZ(n,e):t0(isNaN(n)?t:n)}Bf(jc,function(n,t,e,i){return 1===arguments.length?XZ(n):new jc(n,t,e,i??1)},Kg(Ku,{brighter:function(n){return new jc(this.l+18*(n??1),this.a,this.b,this.opacity)},darker:function(n){return new jc(this.l-18*(n??1),this.a,this.b,this.opacity)},rgb:function(){var n=(this.l+16)/116,t=isNaN(this.a)?n:n+this.a/500,e=isNaN(this.b)?n:n-this.b/200;return new Zo(nL(3.1338561*(t=jZ*tL(t))-1.6168667*(n=GZ*tL(n))-.4906146*(e=WZ*tL(e))),nL(-.9787684*t+1.9161415*n+.033454*e),nL(.0719453*t-.2289914*n+1.4052427*e),this.opacity)}})),Bf(Od,Hf,Kg(Ku,{brighter:function(n){return new Od(this.h,this.c,this.l+18*(n??1),this.opacity)},darker:function(n){return new Od(this.h,this.c,this.l-18*(n??1),this.opacity)},rgb:function(){return QZ(this).rgb()}}));var zf=function n(t){var e=function(n){return 1==(n=+n)?Xs:function(t,e){return e-t?function(n,t,e){return n=Math.pow(n,e),t=Math.pow(t,e)-n,e=1/e,function(i){return Math.pow(n+i*t,e)}}(t,e,n):t0(isNaN(t)?e:t)}}(t);function i(r,o){var s=e((r=$g(r)).r,(o=$g(o)).r),a=e(r.g,o.g),l=e(r.b,o.b),c=Xs(r.opacity,o.opacity);return function(d){return r.r=s(d),r.g=a(d),r.b=l(d),r.opacity=c(d),r+""}}return i.gamma=n,i}(1);function eK(n){return function(t){var s,a,e=t.length,i=new Array(e),r=new Array(e),o=new Array(e);for(s=0;s<e;++s)a=$g(t[s]),i[s]=a.r||0,r[s]=a.g||0,o[s]=a.b||0;return i=n(i),r=n(r),o=n(o),a.opacity=1,function(l){return a.r=i(l),a.g=r(l),a.b=o(l),a+""}}}function tK(n,t){t||(t=[]);var r,e=n?Math.min(t.length,n.length):0,i=t.slice();return function(o){for(r=0;r<e;++r)i[r]=n[r]*(1-o)+t[r]*o;return i}}function iK(n,t){var s,e=t?t.length:0,i=n?Math.min(e,n.length):0,r=new Array(i),o=new Array(e);for(s=0;s<i;++s)r[s]=Uf(n[s],t[s]);for(;s<e;++s)o[s]=t[s];return function(a){for(s=0;s<i;++s)o[s]=r[s](a);return o}}function rK(n,t){var e=new Date;return n=+n,t=+t,function(i){return e.setTime(n*(1-i)+t*i),e}}function Bo(n,t){return n=+n,t=+t,function(e){return n*(1-e)+t*e}}function oK(n,t){var r,e={},i={};for(r in(null===n||"object"!=typeof n)&&(n={}),(null===t||"object"!=typeof t)&&(t={}),t)r in n?e[r]=Uf(n[r],t[r]):i[r]=t[r];return function(o){for(r in e)i[r]=e[r](o);return i}}eK(function(n){var t=n.length-1;return function(e){var i=e<=0?e=0:e>=1?(e=1,t-1):Math.floor(e*t),r=n[i],o=n[i+1];return oL((e-i/t)*t,i>0?n[i-1]:2*r-o,r,o,i<t-1?n[i+2]:2*o-r)}}),eK(function(n){var t=n.length;return function(e){var i=Math.floor(((e%=1)<0?++e:e)*t);return oL((e-i/t)*t,n[(i+t-1)%t],n[i%t],n[(i+1)%t],n[(i+2)%t])}});var aL=/[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,sL=new RegExp(aL.source,"g");function Ay(n,t){var i,r,o,e=aL.lastIndex=sL.lastIndex=0,s=-1,a=[],l=[];for(n+="",t+="";(i=aL.exec(n))&&(r=sL.exec(t));)(o=r.index)>e&&(o=t.slice(e,o),a[s]?a[s]+=o:a[++s]=o),(i=i[0])===(r=r[0])?a[s]?a[s]+=r:a[++s]=r:(a[++s]=null,l.push({i:s,x:Bo(i,r)})),e=sL.lastIndex;return e<t.length&&(o=t.slice(e),a[s]?a[s]+=o:a[++s]=o),a.length<2?l[0]?function(n){return function(t){return n(t)+""}}(l[0].x):function(n){return function(){return n}}(t):(t=l.length,function(c){for(var u,d=0;d<t;++d)a[(u=l[d]).i]=u.x(c);return a.join("")})}function Uf(n,t){var i,e=typeof t;return null==t||"boolean"===e?t0(t):("number"===e?Bo:"string"===e?(i=Gl(t))?(t=i,zf):Ay:t instanceof Gl?zf:t instanceof Date?rK:function(n){return ArrayBuffer.isView(n)&&!(n instanceof DataView)}(t)?tK:Array.isArray(t)?iK:"function"!=typeof t.valueOf&&"function"!=typeof t.toString||isNaN(t)?oK:Bo)(n,t)}function lL(n,t){return n=+n,t=+t,function(e){return Math.round(n*(1-e)+t*e)}}var Ry,dL,aK,lD,sK=180/Math.PI,aD={translateX:0,translateY:0,rotate:0,skewX:0,scaleX:1,scaleY:1};function cL(n,t,e,i,r,o){var s,a,l;return(s=Math.sqrt(n*n+t*t))&&(n/=s,t/=s),(l=n*e+t*i)&&(e-=n*l,i-=t*l),(a=Math.sqrt(e*e+i*i))&&(e/=a,i/=a,l/=a),n*i<t*e&&(n=-n,t=-t,l=-l,s=-s),{translateX:r,translateY:o,rotate:Math.atan2(t,n)*sK,skewX:Math.atan(l)*sK,scaleX:s,scaleY:a}}function dK(n,t,e,i){function r(c){return c.length?c.pop()+" ":""}return function(c,d){var u=[],p=[];return c=n(c),d=n(d),function(c,d,u,p,f,m){if(c!==u||d!==p){var b=f.push("translate(",null,t,null,e);m.push({i:b-4,x:Bo(c,u)},{i:b-2,x:Bo(d,p)})}else(u||p)&&f.push("translate("+u+t+p+e)}(c.translateX,c.translateY,d.translateX,d.translateY,u,p),function(c,d,u,p){c!==d?(c-d>180?d+=360:d-c>180&&(c+=360),p.push({i:u.push(r(u)+"rotate(",null,i)-2,x:Bo(c,d)})):d&&u.push(r(u)+"rotate("+d+i)}(c.rotate,d.rotate,u,p),function(c,d,u,p){c!==d?p.push({i:u.push(r(u)+"skewX(",null,i)-2,x:Bo(c,d)}):d&&u.push(r(u)+"skewX("+d+i)}(c.skewX,d.skewX,u,p),function(c,d,u,p,f,m){if(c!==u||d!==p){var b=f.push(r(f)+"scale(",null,",",null,")");m.push({i:b-4,x:Bo(c,u)},{i:b-2,x:Bo(d,p)})}else(1!==u||1!==p)&&f.push(r(f)+"scale("+u+","+p+")")}(c.scaleX,c.scaleY,d.scaleX,d.scaleY,u,p),c=d=null,function(f){for(var M,m=-1,b=p.length;++m<b;)u[(M=p[m]).i]=M.x(f);return u.join("")}}}var uL=dK(function(n){return"none"===n?aD:(Ry||(Ry=document.createElement("DIV"),dL=document.documentElement,aK=document.defaultView),Ry.style.transform=n,n=aK.getComputedStyle(dL.appendChild(Ry),null).getPropertyValue("transform"),dL.removeChild(Ry),cL(+(n=n.slice(7,-1).split(","))[0],+n[1],+n[2],+n[3],+n[4],+n[5]))},"px, ","px)","deg)"),pL=dK(function(n){return null==n?aD:(lD||(lD=document.createElementNS("http://www.w3.org/2000/svg","g")),lD.setAttribute("transform",n),(n=lD.transform.baseVal.consolidate())?cL((n=n.matrix).a,n.b,n.c,n.d,n.e,n.f):aD)},", ",")",")");function uK(n){return function(t,e){var i=n((t=Vf(t)).h,(e=Vf(e)).h),r=Xs(t.s,e.s),o=Xs(t.l,e.l),s=Xs(t.opacity,e.opacity);return function(a){return t.h=i(a),t.s=r(a),t.l=o(a),t.opacity=s(a),t+""}}}var fL=uK(sD);function pK(n){return function(t,e){var i=n((t=Hf(t)).h,(e=Hf(e)).h),r=Xs(t.c,e.c),o=Xs(t.l,e.l),s=Xs(t.opacity,e.opacity);return function(a){return t.h=i(a),t.c=r(a),t.l=o(a),t.opacity=s(a),t+""}}}uK(Xs);var cD,ky,mL=pK(sD),n0=(pK(Xs),0),Oy=0,Py=0,mK=1e3,dD=0,jf=0,uD=0,Fy="object"==typeof performance&&performance.now?performance:Date,hK="object"==typeof window&&window.requestAnimationFrame?window.requestAnimationFrame.bind(window):function(n){setTimeout(n,17)};function i0(){return jf||(hK(DTe),jf=Fy.now()+uD)}function DTe(){jf=0}function Ny(){this._call=this._time=this._next=null}function pD(n,t,e){var i=new Ny;return i.restart(n,t,e),i}function fK(){jf=(dD=Fy.now())+uD,n0=Oy=0;try{!function(){i0(),++n0;for(var t,n=cD;n;)(t=jf-n._time)>=0&&n._call.call(null,t),n=n._next;--n0}()}finally{n0=0,function(){for(var n,e,t=cD,i=1/0;t;)t._call?(i>t._time&&(i=t._time),n=t,t=t._next):(e=t._next,t._next=null,t=n?n._next=e:cD=e);ky=n,hL(i)}(),jf=0}}function ITe(){var n=Fy.now(),t=n-dD;t>mK&&(uD-=t,dD=n)}function hL(n){n0||(Oy&&(Oy=clearTimeout(Oy)),n-jf>24?(n<1/0&&(Oy=setTimeout(fK,n-Fy.now()-uD)),Py&&(Py=clearInterval(Py))):(Py||(dD=Fy.now(),Py=setInterval(ITe,mK)),n0=1,hK(fK)))}function fD(n,t,e){var i=new Ny;return i.restart(function(r){i.stop(),n(r+t)},t=null==t?0:+t,e),i}Ny.prototype=pD.prototype={constructor:Ny,restart:function(n,t,e){if("function"!=typeof n)throw new TypeError("callback is not a function");e=(null==e?i0():+e)+(null==t?0:+t),!this._next&&ky!==this&&(ky?ky._next=this:cD=this,ky=this),this._call=n,this._time=e,hL()},stop:function(){this._call&&(this._call=null,this._time=1/0,hL())}};var RTe=qN("start","end","cancel","interrupt"),PTe=[],bK=0,gL=1,hD=2,mD=3,_K=4,gD=5,Ly=6;function Ju(n,t,e,i,r,o){var s=n.__transition;if(s){if(e in s)return}else n.__transition={};!function(n,t,e){var r,i=n.__transition;function s(c){var d,u,p,f;if(e.state!==gL)return l();for(d in i)if((f=i[d]).name===e.name){if(f.state===mD)return fD(s);f.state===_K?(f.state=Ly,f.timer.stop(),f.on.call("interrupt",n,n.__data__,f.index,f.group),delete i[d]):+d<t&&(f.state=Ly,f.timer.stop(),f.on.call("cancel",n,n.__data__,f.index,f.group),delete i[d])}if(fD(function(){e.state===mD&&(e.state=_K,e.timer.restart(a,e.delay,e.time),a(c))}),e.state=hD,e.on.call("start",n,n.__data__,e.index,e.group),e.state===hD){for(e.state=mD,r=new Array(p=e.tween.length),d=0,u=-1;d<p;++d)(f=e.tween[d].value.call(n,n.__data__,e.index,e.group))&&(r[++u]=f);r.length=u+1}}function a(c){for(var d=c<e.duration?e.ease.call(null,c/e.duration):(e.timer.restart(l),e.state=gD,1),u=-1,p=r.length;++u<p;)r[u].call(n,d);e.state===gD&&(e.on.call("end",n,n.__data__,e.index,e.group),l())}function l(){for(var c in e.state=Ly,e.timer.stop(),delete i[t],i)return;delete n.__transition}i[t]=e,e.timer=pD(function(c){e.state=gL,e.timer.restart(s,e.delay,e.time),e.delay<=c&&s(c-e.delay)},0,e.time)}(n,e,{name:t,index:i,group:r,on:RTe,tween:PTe,time:o.time,delay:o.delay,duration:o.duration,ease:o.ease,timer:null,state:bK})}function By(n,t){var e=ho(n,t);if(e.state>bK)throw new Error("too late; already scheduled");return e}function ms(n,t){var e=ho(n,t);if(e.state>mD)throw new Error("too late; already running");return e}function ho(n,t){var e=n.__transition;if(!e||!(e=e[t]))throw new Error("transition not found");return e}function kTe(n,t){var e,i;return function(){var r=ms(this,n),o=r.tween;if(o!==e)for(var s=0,a=(i=e=o).length;s<a;++s)if(i[s].name===t){(i=i.slice()).splice(s,1);break}r.tween=i}}function FTe(n,t,e){var i,r;if("function"!=typeof e)throw new Error;return function(){var o=ms(this,n),s=o.tween;if(s!==i){r=(i=s).slice();for(var a={name:t,value:e},l=0,c=r.length;l<c;++l)if(r[l].name===t){r[l]=a;break}l===c&&r.push(a)}o.tween=r}}function r0(n,t,e){var i=n._id;return n.each(function(){var r=ms(this,i);(r.value||(r.value={}))[t]=e.apply(this,arguments)}),function(r){return ho(r,i).value[t]}}function _D(n,t){var e;return("number"==typeof t?Bo:t instanceof Gl?zf:(e=Gl(t))?(t=e,zf):Ay)(n,t)}function NTe(n){return function(){this.removeAttribute(n)}}function LTe(n){return function(){this.removeAttributeNS(n.space,n.local)}}function BTe(n,t,e){var i,o,r=e+"";return function(){var s=this.getAttribute(n);return s===r?null:s===i?o:o=t(i=s,e)}}function VTe(n,t,e){var i,o,r=e+"";return function(){var s=this.getAttributeNS(n.space,n.local);return s===r?null:s===i?o:o=t(i=s,e)}}function HTe(n,t,e){var i,r,o;return function(){var s,l,a=e(this);return null==a?void this.removeAttribute(n):(s=this.getAttribute(n))===(l=a+"")?null:s===i&&l===r?o:(r=l,o=t(i=s,a))}}function zTe(n,t,e){var i,r,o;return function(){var s,l,a=e(this);return null==a?void this.removeAttributeNS(n.space,n.local):(s=this.getAttributeNS(n.space,n.local))===(l=a+"")?null:s===i&&l===r?o:(r=l,o=t(i=s,a))}}function GTe(n,t){var e,i;function r(){var o=t.apply(this,arguments);return o!==i&&(e=(i=o)&&function(n,t){return function(e){this.setAttributeNS(n.space,n.local,t.call(this,e))}}(n,o)),e}return r._value=t,r}function WTe(n,t){var e,i;function r(){var o=t.apply(this,arguments);return o!==i&&(e=(i=o)&&function(n,t){return function(e){this.setAttribute(n,t.call(this,e))}}(n,o)),e}return r._value=t,r}function qTe(n,t){return function(){By(this,n).delay=+t.apply(this,arguments)}}function YTe(n,t){return t=+t,function(){By(this,n).delay=t}}function XTe(n,t){return function(){ms(this,n).duration=+t.apply(this,arguments)}}function QTe(n,t){return t=+t,function(){ms(this,n).duration=t}}var eDe=Pd.prototype.constructor;function OK(n){return function(){this.style.removeProperty(n)}}var uDe=0;function Ko(n,t,e,i){this._groups=n,this._parents=t,this._name=e,this._id=i}function bD(){return++uDe}var o0=Pd.prototype;Ko.prototype=function(n){return Pd().transition(n)}.prototype={constructor:Ko,select:function(n){var t=this._name,e=this._id;"function"!=typeof n&&(n=Lf(n));for(var i=this._groups,r=i.length,o=new Array(r),s=0;s<r;++s)for(var d,u,a=i[s],l=a.length,c=o[s]=new Array(l),p=0;p<l;++p)(d=a[p])&&(u=n.call(d,d.__data__,p,a))&&("__data__"in d&&(u.__data__=d.__data__),c[p]=u,Ju(c[p],t,e,p,c,ho(d,e)));return new Ko(o,this._parents,t,e)},selectAll:function(n){var t=this._name,e=this._id;"function"!=typeof n&&(n=Sy(n));for(var i=this._groups,r=i.length,o=[],s=[],a=0;a<r;++a)for(var d,l=i[a],c=l.length,u=0;u<c;++u)if(d=l[u]){for(var f,p=n.call(d,d.__data__,u,l),m=ho(d,e),b=0,M=p.length;b<M;++b)(f=p[b])&&Ju(f,t,e,b,p,m);o.push(p),s.push(d)}return new Ko(o,s,t,e)},filter:function(n){"function"!=typeof n&&(n=Ey(n));for(var t=this._groups,e=t.length,i=new Array(e),r=0;r<e;++r)for(var l,o=t[r],s=o.length,a=i[r]=[],c=0;c<s;++c)(l=o[c])&&n.call(l,l.__data__,c,o)&&a.push(l);return new Ko(i,this._parents,this._name,this._id)},merge:function(n){if(n._id!==this._id)throw new Error;for(var t=this._groups,e=n._groups,i=t.length,o=Math.min(i,e.length),s=new Array(i),a=0;a<o;++a)for(var p,l=t[a],c=e[a],d=l.length,u=s[a]=new Array(d),f=0;f<d;++f)(p=l[f]||c[f])&&(u[f]=p);for(;a<i;++a)s[a]=t[a];return new Ko(s,this._parents,this._name,this._id)},selection:function(){return new eDe(this._groups,this._parents)},transition:function(){for(var n=this._name,t=this._id,e=bD(),i=this._groups,r=i.length,o=0;o<r;++o)for(var l,s=i[o],a=s.length,c=0;c<a;++c)if(l=s[c]){var d=ho(l,t);Ju(l,n,e,c,s,{time:d.time+d.delay+d.duration,delay:0,duration:d.duration,ease:d.ease})}return new Ko(i,this._parents,n,e)},call:o0.call,nodes:o0.nodes,node:o0.node,size:o0.size,empty:o0.empty,each:o0.each,on:function(n,t){var e=this._id;return arguments.length<2?ho(this.node(),e).on.on(n):this.each(function(n,t,e){var i,r,o=function(n){return(n+"").trim().split(/^|\s+/).every(function(t){var e=t.indexOf(".");return e>=0&&(t=t.slice(0,e)),!t||"start"===t})}(t)?By:ms;return function(){var s=o(this,n),a=s.on;a!==i&&(r=(i=a).copy()).on(t,e),s.on=r}}(e,n,t))},attr:function(n,t){var e=Rd(n),i="transform"===e?pL:_D;return this.attrTween(n,"function"==typeof t?(e.local?zTe:HTe)(e,i,r0(this,"attr."+n,t)):null==t?(e.local?LTe:NTe)(e):(e.local?VTe:BTe)(e,i,t))},attrTween:function(n,t){var e="attr."+n;if(arguments.length<2)return(e=this.tween(e))&&e._value;if(null==t)return this.tween(e,null);if("function"!=typeof t)throw new Error;var i=Rd(n);return this.tween(e,(i.local?GTe:WTe)(i,t))},style:function(n,t,e){var i="transform"==(n+="")?uL:_D;return null==t?this.styleTween(n,function(n,t){var e,i,r;return function(){var o=Zu(this,n),s=(this.style.removeProperty(n),Zu(this,n));return o===s?null:o===e&&s===i?r:r=t(e=o,i=s)}}(n,i)).on("end.style."+n,OK(n)):"function"==typeof t?this.styleTween(n,function(n,t,e){var i,r,o;return function(){var s=Zu(this,n),a=e(this),l=a+"";return null==a&&(this.style.removeProperty(n),l=a=Zu(this,n)),s===l?null:s===i&&l===r?o:(r=l,o=t(i=s,a))}}(n,i,r0(this,"style."+n,t))).each(function(n,t){var e,i,r,a,o="style."+t,s="end."+o;return function(){var l=ms(this,n),c=l.on,d=null==l.value[o]?a||(a=OK(t)):void 0;(c!==e||r!==d)&&(i=(e=c).copy()).on(s,r=d),l.on=i}}(this._id,n)):this.styleTween(n,function(n,t,e){var i,o,r=e+"";return function(){var s=Zu(this,n);return s===r?null:s===i?o:o=t(i=s,e)}}(n,i,t),e).on("end.style."+n,null)},styleTween:function(n,t,e){var i="style."+(n+="");if(arguments.length<2)return(i=this.tween(i))&&i._value;if(null==t)return this.tween(i,null);if("function"!=typeof t)throw new Error;return this.tween(i,function(n,t,e){var i,r;function o(){var s=t.apply(this,arguments);return s!==r&&(i=(r=s)&&function(n,t,e){return function(i){this.style.setProperty(n,t.call(this,i),e)}}(n,s,e)),i}return o._value=t,o}(n,t,e??""))},text:function(n){return this.tween("text","function"==typeof n?function(n){return function(){var t=n(this);this.textContent=t??""}}(r0(this,"text",n)):function(n){return function(){this.textContent=n}}(null==n?"":n+""))},textTween:function(n){var t="text";if(arguments.length<1)return(t=this.tween(t))&&t._value;if(null==n)return this.tween(t,null);if("function"!=typeof n)throw new Error;return this.tween(t,function(n){var t,e;function i(){var r=n.apply(this,arguments);return r!==e&&(t=(e=r)&&function(n){return function(t){this.textContent=n.call(this,t)}}(r)),t}return i._value=n,i}(n))},remove:function(){return this.on("end.remove",function(n){return function(){var t=this.parentNode;for(var e in this.__transition)if(+e!==n)return;t&&t.removeChild(this)}}(this._id))},tween:function(n,t){var e=this._id;if(n+="",arguments.length<2){for(var s,i=ho(this.node(),e).tween,r=0,o=i.length;r<o;++r)if((s=i[r]).name===n)return s.value;return null}return this.each((null==t?kTe:FTe)(e,n,t))},delay:function(n){var t=this._id;return arguments.length?this.each(("function"==typeof n?qTe:YTe)(t,n)):ho(this.node(),t).delay},duration:function(n){var t=this._id;return arguments.length?this.each(("function"==typeof n?XTe:QTe)(t,n)):ho(this.node(),t).duration},ease:function(n){var t=this._id;return arguments.length?this.each(function(n,t){if("function"!=typeof t)throw new Error;return function(){ms(this,n).ease=t}}(t,n)):ho(this.node(),t).ease},end:function(){var n,t,e=this,i=e._id,r=e.size();return new Promise(function(o,s){var a={value:s},l={value:function(){0==--r&&o()}};e.each(function(){var c=ms(this,i),d=c.on;d!==n&&((t=(n=d).copy())._.cancel.push(a),t._.interrupt.push(a),t._.end.push(l)),c.on=t})})}};var bL={time:null,delay:0,duration:250,ease:function(n){return((n*=2)<=1?n*n*n:(n-=2)*n*n+2)/2}};function pDe(n,t){for(var e;!(e=n.__transition)||!(e=e[t]);)if(!(n=n.parentNode))return bL.time=i0(),bL;return e}function vL(n){return{type:n}}Pd.prototype.interrupt=function(n){return this.each(function(){!function(n,t){var i,r,s,e=n.__transition,o=!0;if(e){for(s in t=null==t?null:t+"",e)(i=e[s]).name===t?(r=i.state>hD&&i.state<gD,i.state=Ly,i.timer.stop(),i.on.call(r?"interrupt":"cancel",n,n.__data__,i.index,i.group),delete e[s]):o=!1;o&&delete n.__transition}}(this,n)})},Pd.prototype.transition=function(n){var t,e;n instanceof Ko?(t=n._id,n=n._name):(t=bD(),(e=bL).time=i0(),n=null==n?null:n+"");for(var i=this._groups,r=i.length,o=0;o<r;++o)for(var l,s=i[o],a=s.length,c=0;c<a;++c)(l=s[c])&&Ju(l,n,t,c,s,e||pDe(l,t));return new Ko(i,this._parents,n,t)},["w","e"].map(vL),["n","s"].map(vL),["n","w","e","s","nw","ne","sw","se"].map(vL),Math;var _a="$";function yD(){}function jK(n,t){var e=new yD;if(n instanceof yD)n.each(function(a,l){e.set(l,a)});else if(Array.isArray(n)){var o,i=-1,r=n.length;if(null==t)for(;++i<r;)e.set(i,n[i]);else for(;++i<r;)e.set(t(o=n[i],i,n),o)}else if(n)for(var s in n)e.set(s,n[s]);return e}function xD(){}yD.prototype=jK.prototype={constructor:yD,has:function(n){return _a+n in this},get:function(n){return this[_a+n]},set:function(n,t){return this[_a+n]=t,this},remove:function(n){var t=_a+n;return t in this&&delete this[t]},clear:function(){for(var n in this)n[0]===_a&&delete this[n]},keys:function(){var n=[];for(var t in this)t[0]===_a&&n.push(t.slice(1));return n},values:function(){var n=[];for(var t in this)t[0]===_a&&n.push(this[t]);return n},entries:function(){var n=[];for(var t in this)t[0]===_a&&n.push({key:t.slice(1),value:this[t]});return n},size:function(){var n=0;for(var t in this)t[0]===_a&&++n;return n},empty:function(){for(var n in this)if(n[0]===_a)return!1;return!0},each:function(n){for(var t in this)t[0]===_a&&n(this[t],t.slice(1),this)}};var Wf=jK.prototype;function qf(n,t){if((e=(n=t?n.toExponential(t-1):n.toExponential()).indexOf("e"))<0)return null;var e,i=n.slice(0,e);return[i.length>1?i[0]+i.slice(2):i,+n.slice(e+1)]}function Gc(n){return(n=qf(Math.abs(n)))?n[1]:NaN}xD.prototype=function(n,t){var e=new xD;if(n instanceof xD)n.each(function(o){e.add(o)});else if(n){var i=-1,r=n.length;if(null==t)for(;++i<r;)e.add(n[i]);else for(;++i<r;)e.add(t(n[i],i,n))}return e}.prototype={constructor:xD,has:Wf.has,add:function(n){return this[_a+(n+="")]=n,this},remove:Wf.remove,clear:Wf.clear,values:Wf.keys,size:Wf.size,empty:Wf.empty,each:Wf.each},Math,Math.sqrt(5);var yL,xDe=/^(?:(.)?([<>=^]))?([+\-( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?(~)?([a-z%])?$/i;function $u(n){if(!(t=xDe.exec(n)))throw new Error("invalid format: "+n);var t;return new CD({fill:t[1],align:t[2],sign:t[3],symbol:t[4],zero:t[5],width:t[6],comma:t[7],precision:t[8]&&t[8].slice(1),trim:t[9],type:t[10]})}function CD(n){this.fill=void 0===n.fill?" ":n.fill+"",this.align=void 0===n.align?">":n.align+"",this.sign=void 0===n.sign?"-":n.sign+"",this.symbol=void 0===n.symbol?"":n.symbol+"",this.zero=!!n.zero,this.width=void 0===n.width?void 0:+n.width,this.comma=!!n.comma,this.precision=void 0===n.precision?void 0:+n.precision,this.trim=!!n.trim,this.type=void 0===n.type?"":n.type+""}function xL(n,t){var e=qf(n,t);if(!e)return n+"";var i=e[0],r=e[1];return r<0?"0."+new Array(-r).join("0")+i:i.length>r+1?i.slice(0,r+1)+"."+i.slice(r+1):i+new Array(r-i.length+2).join("0")}$u.prototype=CD.prototype,CD.prototype.toString=function(){return this.fill+this.align+this.sign+this.symbol+(this.zero?"0":"")+(void 0===this.width?"":Math.max(1,0|this.width))+(this.comma?",":"")+(void 0===this.precision?"":"."+Math.max(0,0|this.precision))+(this.trim?"~":"")+this.type};var CL={"%":function(n,t){return(100*n).toFixed(t)},b:function(n){return Math.round(n).toString(2)},c:function(n){return n+""},d:function(n){return Math.abs(n=Math.round(n))>=1e21?n.toLocaleString("en").replace(/,/g,""):n.toString(10)},e:function(n,t){return n.toExponential(t)},f:function(n,t){return n.toFixed(t)},g:function(n,t){return n.toPrecision(t)},o:function(n){return Math.round(n).toString(8)},p:function(n,t){return xL(100*n,t)},r:xL,s:function(n,t){var e=qf(n,t);if(!e)return n+"";var i=e[0],r=e[1],o=r-(yL=3*Math.max(-8,Math.min(8,Math.floor(r/3))))+1,s=i.length;return o===s?i:o>s?i+new Array(o-s+1).join("0"):o>0?i.slice(0,o)+"."+i.slice(o):"0."+new Array(1-o).join("0")+qf(n,Math.max(0,t+o-1))[0]},X:function(n){return Math.round(n).toString(16).toUpperCase()},x:function(n){return Math.round(n).toString(16)}};function ML(n){return n}var MD,Qr,wD,KK=Array.prototype.map,JK=["y","z","a","f","p","n","\xb5","m","","k","M","G","T","P","E","Z","Y"];function rl(){return Math.random()}MD=function(n){var t=void 0===n.grouping||void 0===n.thousands?ML:function(n,t){return function(e,i){for(var r=e.length,o=[],s=0,a=n[0],l=0;r>0&&a>0&&(l+a+1>i&&(a=Math.max(1,i-l)),o.push(e.substring(r-=a,r+a)),!((l+=a+1)>i));)a=n[s=(s+1)%n.length];return o.reverse().join(t)}}(KK.call(n.grouping,Number),n.thousands+""),e=void 0===n.currency?"":n.currency[0]+"",i=void 0===n.currency?"":n.currency[1]+"",r=void 0===n.decimal?".":n.decimal+"",o=void 0===n.numerals?ML:function(n){return function(t){return t.replace(/[0-9]/g,function(e){return n[+e]})}}(KK.call(n.numerals,String)),s=void 0===n.percent?"%":n.percent+"",a=void 0===n.minus?"-":n.minus+"",l=void 0===n.nan?"NaN":n.nan+"";function c(u){var p=(u=$u(u)).fill,f=u.align,m=u.sign,b=u.symbol,M=u.zero,y=u.width,x=u.comma,R=u.precision,A=u.trim,V=u.type;"n"===V?(x=!0,V="g"):CL[V]||(void 0===R&&(R=12),A=!0,V="g"),(M||"0"===p&&"="===f)&&(M=!0,p="0",f="=");var te="$"===b?e:"#"===b&&/[boxX]/.test(V)?"0"+V.toLowerCase():"",K="$"===b?i:/[%p]/.test(V)?s:"",xe=CL[V],Xe=/[defgprs%]/.test(V);function De(D){var fe,be,ne,re=te,ce=K;if("c"===V)ce=xe(D)+ce,D="";else{var de=(D=+D)<0||1/D<0;if(D=isNaN(D)?l:xe(Math.abs(D),R),A&&(D=function(n){e:for(var r,t=n.length,e=1,i=-1;e<t;++e)switch(n[e]){case".":i=r=e;break;case"0":0===i&&(i=e),r=e;break;default:if(!+n[e])break e;i>0&&(i=0)}return i>0?n.slice(0,i)+n.slice(r+1):n}(D)),de&&0==+D&&"+"!==m&&(de=!1),re=(de?"("===m?m:a:"-"===m||"("===m?"":m)+re,ce=("s"===V?JK[8+yL/3]:"")+ce+(de&&"("===m?")":""),Xe)for(fe=-1,be=D.length;++fe<be;)if(48>(ne=D.charCodeAt(fe))||ne>57){ce=(46===ne?r+D.slice(fe+1):D.slice(fe))+ce,D=D.slice(0,fe);break}}x&&!M&&(D=t(D,1/0));var pe=re.length+D.length+ce.length,je=pe<y?new Array(y-pe+1).join(p):"";switch(x&&M&&(D=t(je+D,je.length?y-ce.length:1/0),je=""),f){case"<":D=re+D+ce+je;break;case"=":D=re+je+D+ce;break;case"^":D=je.slice(0,pe=je.length>>1)+re+D+ce+je.slice(pe);break;default:D=je+re+D+ce}return o(D)}return R=void 0===R?6:/[gprs]/.test(V)?Math.max(1,Math.min(21,R)):Math.max(0,Math.min(20,R)),De.toString=function(){return u+""},De}return{format:c,formatPrefix:function(u,p){var f=c(((u=$u(u)).type="f",u)),m=3*Math.max(-8,Math.min(8,Math.floor(Gc(p)/3))),b=Math.pow(10,-m),M=JK[8+m/3];return function(y){return f(b*y)+M}}}}({decimal:".",thousands:",",grouping:[3],currency:["$",""],minus:"-"}),Qr=MD.format,wD=MD.formatPrefix,function n(t){function e(i,r){return i=null==i?0:+i,r=null==r?1:+r,1===arguments.length?(r=i,i=0):r-=i,function(){return t()*r+i}}return e.source=n,e}(rl);var DL=function n(t){function e(i,r){var o,s;return i=null==i?0:+i,r=null==r?1:+r,function(){var a;if(null!=o)a=o,o=null;else do{o=2*t()-1,a=2*t()-1,s=o*o+a*a}while(!s||s>1);return i+r*a*Math.sqrt(-2*Math.log(s)/s)}}return e.source=n,e}(rl),IL=(function n(t){function e(){var i=DL.source(t).apply(this,arguments);return function(){return Math.exp(i())}}return e.source=n,e}(rl),function n(t){function e(i){return function(){for(var r=0,o=0;o<i;++o)r+=t();return r}}return e.source=n,e}(rl));function Qs(n,t){switch(arguments.length){case 0:break;case 1:this.range(n);break;default:this.range(t).domain(n)}return this}(function n(t){function e(i){var r=IL.source(t)(i);return function(){return r()/i}}return e.source=n,e})(rl),function n(t){function e(i){return function(){return-Math.log(1-t())/i}}return e.source=n,e}(rl);var eJ=Array.prototype,zy=eJ.map,Yf=eJ.slice;function AL(n){return+n}var nJ=[0,1];function Zs(n){return n}function RL(n,t){return(t-=n=+n)?function(e){return(e-n)/t}:function(n){return function(){return n}}(isNaN(t)?NaN:.5)}function iJ(n){var i,t=n[0],e=n[n.length-1];return t>e&&(i=t,t=e,e=i),function(r){return Math.max(t,Math.min(e,r))}}function TDe(n,t,e){var i=n[0],r=n[1],o=t[0],s=t[1];return r<i?(i=RL(r,i),o=e(s,o)):(i=RL(i,r),o=e(o,s)),function(a){return o(i(a))}}function DDe(n,t,e){var i=Math.min(n.length,t.length)-1,r=new Array(i),o=new Array(i),s=-1;for(n[i]<n[0]&&(n=n.slice().reverse(),t=t.slice().reverse());++s<i;)r[s]=RL(n[s],n[s+1]),o[s]=e(t[s],t[s+1]);return function(a){var l=Hc(n,a,1,i)-1;return o[l](r[l](a))}}function ep(n,t){return t.domain(n.domain()).range(n.range()).interpolate(n.interpolate()).clamp(n.clamp()).unknown(n.unknown())}function Uy(){var i,r,o,a,l,c,n=nJ,t=nJ,e=Uf,s=Zs;function d(){return a=Math.min(n.length,t.length)>2?DDe:TDe,l=c=null,u}function u(p){return isNaN(p=+p)?o:(l||(l=a(n.map(i),t,e)))(i(s(p)))}return u.invert=function(p){return s(r((c||(c=a(t,n.map(i),Bo)))(p)))},u.domain=function(p){return arguments.length?(n=zy.call(p,AL),s===Zs||(s=iJ(n)),d()):n.slice()},u.range=function(p){return arguments.length?(t=Yf.call(p),d()):t.slice()},u.rangeRound=function(p){return t=Yf.call(p),e=lL,d()},u.clamp=function(p){return arguments.length?(s=p?iJ(n):Zs,u):s!==Zs},u.interpolate=function(p){return arguments.length?(e=p,d()):e},u.unknown=function(p){return arguments.length?(o=p,u):o},function(p,f){return i=p,r=f,d()}}function jy(n,t){return Uy()(n,t)}function Wl(){var n=jy(Zs,Zs);return n.copy=function(){return ep(n,Wl())},Qs.apply(n,arguments),function(n){var t=n.domain;return n.ticks=function(e){var i=t();return My(i[0],i[i.length-1],e??10)},n.tickFormat=function(e,i){var r=t();return function(n,t,e,i){var o,r=Ad(n,t,e);switch((i=$u(i??",f")).type){case"s":var s=Math.max(Math.abs(n),Math.abs(t));return null==i.precision&&!isNaN(o=function(n,t){return Math.max(0,3*Math.max(-8,Math.min(8,Math.floor(Gc(t)/3)))-Gc(Math.abs(n)))}(r,s))&&(i.precision=o),wD(i,s);case"":case"e":case"g":case"p":case"r":null==i.precision&&!isNaN(o=function(n,t){return n=Math.abs(n),t=Math.abs(t)-n,Math.max(0,Gc(t)-Gc(n))+1}(r,Math.max(Math.abs(n),Math.abs(t))))&&(i.precision=o-("e"===i.type));break;case"f":case"%":null==i.precision&&!isNaN(o=function(n){return Math.max(0,-Gc(Math.abs(n)))}(r))&&(i.precision=o-2*("%"===i.type))}return Qr(i)}(r[0],r[r.length-1],e??10,i)},n.nice=function(e){null==e&&(e=10);var l,i=t(),r=0,o=i.length-1,s=i[r],a=i[o];return a<s&&(l=s,s=a,a=l,l=r,r=o,o=l),(l=Zg(s,a,e))>0?l=Zg(s=Math.floor(s/l)*l,a=Math.ceil(a/l)*l,e):l<0&&(l=Zg(s=Math.ceil(s*l)/l,a=Math.floor(a*l)/l,e)),l>0?(i[r]=Math.floor(s/l)*l,i[o]=Math.ceil(a/l)*l,t(i)):l<0&&(i[r]=Math.ceil(s*l)/l,i[o]=Math.floor(a*l)/l,t(i)),n},n}(n)}function SD(n,t){var s,e=0,i=(n=n.slice()).length-1,r=n[e],o=n[i];return o<r&&(s=e,e=i,i=s,s=r,r=o,o=s),n[e]=t.floor(r),n[i]=t.ceil(o),n}function rJ(n){return Math.log(n)}function oJ(n){return Math.exp(n)}function IDe(n){return-Math.log(-n)}function ADe(n){return-Math.exp(-n)}function RDe(n){return isFinite(n)?+("1e"+n):n<0?0:n}function sJ(n){return function(t){return-n(-t)}}function Gy(){var n=function(n){var r,o,t=n(rJ,oJ),e=t.domain,i=10;function s(){return r=function(n){return n===Math.E?Math.log:10===n&&Math.log10||2===n&&Math.log2||(n=Math.log(n),function(t){return Math.log(t)/n})}(i),o=function(n){return 10===n?RDe:n===Math.E?Math.exp:function(t){return Math.pow(n,t)}}(i),e()[0]<0?(r=sJ(r),o=sJ(o),n(IDe,ADe)):n(rJ,oJ),t}return t.base=function(a){return arguments.length?(i=+a,s()):i},t.domain=function(a){return arguments.length?(e(a),s()):e()},t.ticks=function(a){var u,l=e(),c=l[0],d=l[l.length-1];(u=d<c)&&(p=c,c=d,d=p);var m,b,M,p=r(c),f=r(d),y=null==a?10:+a,x=[];if(!(i%1)&&f-p<y){if(p=Math.round(p)-1,f=Math.round(f)+1,c>0){for(;p<f;++p)for(b=1,m=o(p);b<i;++b)if(!((M=m*b)<c)){if(M>d)break;x.push(M)}}else for(;p<f;++p)for(b=i-1,m=o(p);b>=1;--b)if(!((M=m*b)<c)){if(M>d)break;x.push(M)}}else x=My(p,f,Math.min(f-p,y)).map(o);return u?x.reverse():x},t.tickFormat=function(a,l){if(null==l&&(l=10===i?".0e":","),"function"!=typeof l&&(l=Qr(l)),a===1/0)return l;null==a&&(a=10);var c=Math.max(1,i*a/t.ticks().length);return function(d){var u=d/o(Math.round(r(d)));return u*i<i-.5&&(u*=i),u<=c?l(d):""}},t.nice=function(){return e(SD(e(),{floor:function(a){return o(Math.floor(r(a)))},ceil:function(a){return o(Math.ceil(r(a)))}}))},t}(Uy()).domain([1,10]);return n.copy=function(){return ep(n,Gy()).base(n.base())},Qs.apply(n,arguments),n}var kL=new Date,FL=new Date;function ir(n,t,e,i){function r(o){return n(o=0===arguments.length?new Date:new Date(+o)),o}return r.floor=function(o){return n(o=new Date(+o)),o},r.ceil=function(o){return n(o=new Date(o-1)),t(o,1),n(o),o},r.round=function(o){var s=r(o),a=r.ceil(o);return o-s<a-o?s:a},r.offset=function(o,s){return t(o=new Date(+o),null==s?1:Math.floor(s)),o},r.range=function(o,s,a){var c,l=[];if(o=r.ceil(o),a=null==a?1:Math.floor(a),!(o<s&&a>0))return l;do{l.push(c=new Date(+o)),t(o,a),n(o)}while(c<o&&o<s);return l},r.filter=function(o){return ir(function(s){if(s>=s)for(;n(s),!o(s);)s.setTime(s-1)},function(s,a){if(s>=s)if(a<0)for(;++a<=0;)for(;t(s,-1),!o(s););else for(;--a>=0;)for(;t(s,1),!o(s););})},e&&(r.count=function(o,s){return kL.setTime(+o),FL.setTime(+s),n(kL),n(FL),Math.floor(e(kL,FL))},r.every=function(o){return o=Math.floor(o),isFinite(o)&&o>0?o>1?r.filter(i?function(s){return i(s)%o==0}:function(s){return r.count(0,s)%o==0}):r:null}),r}var ED=ir(function(){},function(n,t){n.setTime(+n+t)},function(n,t){return t-n});ED.every=function(n){return n=Math.floor(n),isFinite(n)&&n>0?n>1?ir(function(t){t.setTime(Math.floor(t/n)*n)},function(t,e){t.setTime(+t+e*n)},function(t,e){return(e-t)/n}):ED:null};var TD=ED,kd=6e4,ID=6048e5,lJ=ir(function(n){n.setTime(n-n.getMilliseconds())},function(n,t){n.setTime(+n+1e3*t)},function(n,t){return(t-n)/1e3},function(n){return n.getUTCSeconds()}),AD=lJ,dJ=ir(function(n){n.setTime(n-n.getMilliseconds()-1e3*n.getSeconds())},function(n,t){n.setTime(+n+t*kd)},function(n,t){return(t-n)/kd},function(n){return n.getMinutes()}),LL=dJ,uJ=ir(function(n){n.setTime(n-n.getMilliseconds()-1e3*n.getSeconds()-n.getMinutes()*kd)},function(n,t){n.setTime(+n+36e5*t)},function(n,t){return(t-n)/36e5},function(n){return n.getHours()}),BL=uJ,pJ=ir(function(n){n.setHours(0,0,0,0)},function(n,t){n.setDate(n.getDate()+t)},function(n,t){return(t-n-(t.getTimezoneOffset()-n.getTimezoneOffset())*kd)/864e5},function(n){return n.getDate()-1}),s0=pJ;function Zf(n){return ir(function(t){t.setDate(t.getDate()-(t.getDay()+7-n)%7),t.setHours(0,0,0,0)},function(t,e){t.setDate(t.getDate()+7*e)},function(t,e){return(e-t-(e.getTimezoneOffset()-t.getTimezoneOffset())*kd)/ID})}var Kf=Zf(0),a0=Zf(1),tp=(Zf(2),Zf(3),Zf(4)),bJ=(Zf(5),Zf(6),ir(function(n){n.setDate(1),n.setHours(0,0,0,0)},function(n,t){n.setMonth(n.getMonth()+t)},function(n,t){return t.getMonth()-n.getMonth()+12*(t.getFullYear()-n.getFullYear())},function(n){return n.getMonth()})),VL=bJ,HL=ir(function(n){n.setMonth(0,1),n.setHours(0,0,0,0)},function(n,t){n.setFullYear(n.getFullYear()+t)},function(n,t){return t.getFullYear()-n.getFullYear()},function(n){return n.getFullYear()});HL.every=function(n){return isFinite(n=Math.floor(n))&&n>0?ir(function(t){t.setFullYear(Math.floor(t.getFullYear()/n)*n),t.setMonth(0,1),t.setHours(0,0,0,0)},function(t,e){t.setFullYear(t.getFullYear()+e*n)}):null};var Fd=HL,vJ=ir(function(n){n.setUTCHours(0,0,0,0)},function(n,t){n.setUTCDate(n.getUTCDate()+t)},function(n,t){return(t-n)/864e5},function(n){return n.getUTCDate()-1}),RD=vJ;function Jf(n){return ir(function(t){t.setUTCDate(t.getUTCDate()-(t.getUTCDay()+7-n)%7),t.setUTCHours(0,0,0,0)},function(t,e){t.setUTCDate(t.getUTCDate()+7*e)},function(t,e){return(e-t)/ID})}var Wy=Jf(0),l0=Jf(1),np=(Jf(2),Jf(3),Jf(4)),zL=(Jf(5),Jf(6),ir(function(n){n.setUTCMonth(0,1),n.setUTCHours(0,0,0,0)},function(n,t){n.setUTCFullYear(n.getUTCFullYear()+t)},function(n,t){return t.getUTCFullYear()-n.getUTCFullYear()},function(n){return n.getUTCFullYear()}));zL.every=function(n){return isFinite(n=Math.floor(n))&&n>0?ir(function(t){t.setUTCFullYear(Math.floor(t.getUTCFullYear()/n)*n),t.setUTCMonth(0,1),t.setUTCHours(0,0,0,0)},function(t,e){t.setUTCFullYear(t.getUTCFullYear()+e*n)}):null};var $f=zL;function UL(n){if(0<=n.y&&n.y<100){var t=new Date(-1,n.m,n.d,n.H,n.M,n.S,n.L);return t.setFullYear(n.y),t}return new Date(n.y,n.m,n.d,n.H,n.M,n.S,n.L)}function jL(n){if(0<=n.y&&n.y<100){var t=new Date(Date.UTC(-1,n.m,n.d,n.H,n.M,n.S,n.L));return t.setUTCFullYear(n.y),t}return new Date(Date.UTC(n.y,n.m,n.d,n.H,n.M,n.S,n.L))}function qy(n,t,e){return{y:n,m:t,d:e,H:0,M:0,S:0,L:0}}var c0,d0,SJ={"-":"",_:" ",0:"0"},To=/^\s*\d+/,$De=/^%/,eIe=/[\\^$*+?|[\]().{}]/g;function Oi(n,t,e){var i=n<0?"-":"",r=(i?-n:n)+"",o=r.length;return i+(o<e?new Array(e-o+1).join(t)+r:r)}function tIe(n){return n.replace(eIe,"\\$&")}function Yy(n){return new RegExp("^(?:"+n.map(tIe).join("|")+")","i")}function Xy(n){for(var t={},e=-1,i=n.length;++e<i;)t[n[e].toLowerCase()]=e;return t}function nIe(n,t,e){var i=To.exec(t.slice(e,e+1));return i?(n.w=+i[0],e+i[0].length):-1}function iIe(n,t,e){var i=To.exec(t.slice(e,e+1));return i?(n.u=+i[0],e+i[0].length):-1}function rIe(n,t,e){var i=To.exec(t.slice(e,e+2));return i?(n.U=+i[0],e+i[0].length):-1}function oIe(n,t,e){var i=To.exec(t.slice(e,e+2));return i?(n.V=+i[0],e+i[0].length):-1}function sIe(n,t,e){var i=To.exec(t.slice(e,e+2));return i?(n.W=+i[0],e+i[0].length):-1}function EJ(n,t,e){var i=To.exec(t.slice(e,e+4));return i?(n.y=+i[0],e+i[0].length):-1}function TJ(n,t,e){var i=To.exec(t.slice(e,e+2));return i?(n.y=+i[0]+(+i[0]>68?1900:2e3),e+i[0].length):-1}function aIe(n,t,e){var i=/^(Z)|([+-]\d\d)(?::?(\d\d))?/.exec(t.slice(e,e+6));return i?(n.Z=i[1]?0:-(i[2]+(i[3]||"00")),e+i[0].length):-1}function lIe(n,t,e){var i=To.exec(t.slice(e,e+1));return i?(n.q=3*i[0]-3,e+i[0].length):-1}function cIe(n,t,e){var i=To.exec(t.slice(e,e+2));return i?(n.m=i[0]-1,e+i[0].length):-1}function DJ(n,t,e){var i=To.exec(t.slice(e,e+2));return i?(n.d=+i[0],e+i[0].length):-1}function dIe(n,t,e){var i=To.exec(t.slice(e,e+3));return i?(n.m=0,n.d=+i[0],e+i[0].length):-1}function IJ(n,t,e){var i=To.exec(t.slice(e,e+2));return i?(n.H=+i[0],e+i[0].length):-1}function uIe(n,t,e){var i=To.exec(t.slice(e,e+2));return i?(n.M=+i[0],e+i[0].length):-1}function pIe(n,t,e){var i=To.exec(t.slice(e,e+2));return i?(n.S=+i[0],e+i[0].length):-1}function fIe(n,t,e){var i=To.exec(t.slice(e,e+3));return i?(n.L=+i[0],e+i[0].length):-1}function mIe(n,t,e){var i=To.exec(t.slice(e,e+6));return i?(n.L=Math.floor(i[0]/1e3),e+i[0].length):-1}function hIe(n,t,e){var i=$De.exec(t.slice(e,e+1));return i?e+i[0].length:-1}function gIe(n,t,e){var i=To.exec(t.slice(e));return i?(n.Q=+i[0],e+i[0].length):-1}function _Ie(n,t,e){var i=To.exec(t.slice(e));return i?(n.s=+i[0],e+i[0].length):-1}function AJ(n,t){return Oi(n.getDate(),t,2)}function bIe(n,t){return Oi(n.getHours(),t,2)}function vIe(n,t){return Oi(n.getHours()%12||12,t,2)}function yIe(n,t){return Oi(1+s0.count(Fd(n),n),t,3)}function FJ(n,t){return Oi(n.getMilliseconds(),t,3)}function xIe(n,t){return FJ(n,t)+"000"}function CIe(n,t){return Oi(n.getMonth()+1,t,2)}function MIe(n,t){return Oi(n.getMinutes(),t,2)}function wIe(n,t){return Oi(n.getSeconds(),t,2)}function SIe(n){var t=n.getDay();return 0===t?7:t}function EIe(n,t){return Oi(Kf.count(Fd(n)-1,n),t,2)}function NJ(n){var t=n.getDay();return t>=4||0===t?tp(n):tp.ceil(n)}function TIe(n,t){return n=NJ(n),Oi(tp.count(Fd(n),n)+(4===Fd(n).getDay()),t,2)}function DIe(n){return n.getDay()}function IIe(n,t){return Oi(a0.count(Fd(n)-1,n),t,2)}function AIe(n,t){return Oi(n.getFullYear()%100,t,2)}function RIe(n,t){return Oi((n=NJ(n)).getFullYear()%100,t,2)}function PIe(n,t){return Oi(n.getFullYear()%1e4,t,4)}function OIe(n,t){var e=n.getDay();return Oi((n=e>=4||0===e?tp(n):tp.ceil(n)).getFullYear()%1e4,t,4)}function kIe(n){var t=n.getTimezoneOffset();return(t>0?"-":(t*=-1,"+"))+Oi(t/60|0,"0",2)+Oi(t%60,"0",2)}function RJ(n,t){return Oi(n.getUTCDate(),t,2)}function FIe(n,t){return Oi(n.getUTCHours(),t,2)}function NIe(n,t){return Oi(n.getUTCHours()%12||12,t,2)}function LIe(n,t){return Oi(1+RD.count($f(n),n),t,3)}function LJ(n,t){return Oi(n.getUTCMilliseconds(),t,3)}function BIe(n,t){return LJ(n,t)+"000"}function VIe(n,t){return Oi(n.getUTCMonth()+1,t,2)}function HIe(n,t){return Oi(n.getUTCMinutes(),t,2)}function zIe(n,t){return Oi(n.getUTCSeconds(),t,2)}function UIe(n){var t=n.getUTCDay();return 0===t?7:t}function jIe(n,t){return Oi(Wy.count($f(n)-1,n),t,2)}function BJ(n){var t=n.getUTCDay();return t>=4||0===t?np(n):np.ceil(n)}function GIe(n,t){return n=BJ(n),Oi(np.count($f(n),n)+(4===$f(n).getUTCDay()),t,2)}function WIe(n){return n.getUTCDay()}function qIe(n,t){return Oi(l0.count($f(n)-1,n),t,2)}function YIe(n,t){return Oi(n.getUTCFullYear()%100,t,2)}function XIe(n,t){return Oi((n=BJ(n)).getUTCFullYear()%100,t,2)}function QIe(n,t){return Oi(n.getUTCFullYear()%1e4,t,4)}function ZIe(n,t){var e=n.getUTCDay();return Oi((n=e>=4||0===e?np(n):np.ceil(n)).getUTCFullYear()%1e4,t,4)}function KIe(){return"+0000"}function PJ(){return"%"}function OJ(n){return+n}function kJ(n){return Math.floor(+n/1e3)}c0=function(n){var t=n.dateTime,e=n.date,i=n.time,r=n.periods,o=n.days,s=n.shortDays,a=n.months,l=n.shortMonths,c=Yy(r),d=Xy(r),u=Yy(o),p=Xy(o),f=Yy(s),m=Xy(s),b=Yy(a),M=Xy(a),y=Yy(l),x=Xy(l),R={a:function(ve){return s[ve.getDay()]},A:function(ve){return o[ve.getDay()]},b:function(ve){return l[ve.getMonth()]},B:function(ve){return a[ve.getMonth()]},c:null,d:AJ,e:AJ,f:xIe,g:RIe,G:OIe,H:bIe,I:vIe,j:yIe,L:FJ,m:CIe,M:MIe,p:function(ve){return r[+(ve.getHours()>=12)]},q:function(ve){return 1+~~(ve.getMonth()/3)},Q:OJ,s:kJ,S:wIe,u:SIe,U:EIe,V:TIe,w:DIe,W:IIe,x:null,X:null,y:AIe,Y:PIe,Z:kIe,"%":PJ},A={a:function(ve){return s[ve.getUTCDay()]},A:function(ve){return o[ve.getUTCDay()]},b:function(ve){return l[ve.getUTCMonth()]},B:function(ve){return a[ve.getUTCMonth()]},c:null,d:RJ,e:RJ,f:BIe,g:XIe,G:ZIe,H:FIe,I:NIe,j:LIe,L:LJ,m:VIe,M:HIe,p:function(ve){return r[+(ve.getUTCHours()>=12)]},q:function(ve){return 1+~~(ve.getUTCMonth()/3)},Q:OJ,s:kJ,S:zIe,u:UIe,U:jIe,V:GIe,w:WIe,W:qIe,x:null,X:null,y:YIe,Y:QIe,Z:KIe,"%":PJ},V={a:function(ve,mt,ft){var oe=f.exec(mt.slice(ft));return oe?(ve.w=m[oe[0].toLowerCase()],ft+oe[0].length):-1},A:function(ve,mt,ft){var oe=u.exec(mt.slice(ft));return oe?(ve.w=p[oe[0].toLowerCase()],ft+oe[0].length):-1},b:function(ve,mt,ft){var oe=y.exec(mt.slice(ft));return oe?(ve.m=x[oe[0].toLowerCase()],ft+oe[0].length):-1},B:function(ve,mt,ft){var oe=b.exec(mt.slice(ft));return oe?(ve.m=M[oe[0].toLowerCase()],ft+oe[0].length):-1},c:function(ve,mt,ft){return xe(ve,t,mt,ft)},d:DJ,e:DJ,f:mIe,g:TJ,G:EJ,H:IJ,I:IJ,j:dIe,L:fIe,m:cIe,M:uIe,p:function(ve,mt,ft){var oe=c.exec(mt.slice(ft));return oe?(ve.p=d[oe[0].toLowerCase()],ft+oe[0].length):-1},q:lIe,Q:gIe,s:_Ie,S:pIe,u:iIe,U:rIe,V:oIe,w:nIe,W:sIe,x:function(ve,mt,ft){return xe(ve,e,mt,ft)},X:function(ve,mt,ft){return xe(ve,i,mt,ft)},y:TJ,Y:EJ,Z:aIe,"%":hIe};function te(ve,mt){return function(ft){var ut,sn,Cn,oe=[],st=-1,Ye=0,_t=ve.length;for(ft instanceof Date||(ft=new Date(+ft));++st<_t;)37===ve.charCodeAt(st)&&(oe.push(ve.slice(Ye,st)),null!=(sn=SJ[ut=ve.charAt(++st)])?ut=ve.charAt(++st):sn="e"===ut?" ":"0",(Cn=mt[ut])&&(ut=Cn(ft,sn)),oe.push(ut),Ye=st+1);return oe.push(ve.slice(Ye,st)),oe.join("")}}function K(ve,mt){return function(ft){var Ye,_t,oe=qy(1900,void 0,1);if(xe(oe,ve,ft+="",0)!=ft.length)return null;if("Q"in oe)return new Date(oe.Q);if("s"in oe)return new Date(1e3*oe.s+("L"in oe?oe.L:0));if(mt&&!("Z"in oe)&&(oe.Z=0),"p"in oe&&(oe.H=oe.H%12+12*oe.p),void 0===oe.m&&(oe.m="q"in oe?oe.q:0),"V"in oe){if(oe.V<1||oe.V>53)return null;"w"in oe||(oe.w=1),"Z"in oe?(_t=(Ye=jL(qy(oe.y,0,1))).getUTCDay(),Ye=_t>4||0===_t?l0.ceil(Ye):l0(Ye),Ye=RD.offset(Ye,7*(oe.V-1)),oe.y=Ye.getUTCFullYear(),oe.m=Ye.getUTCMonth(),oe.d=Ye.getUTCDate()+(oe.w+6)%7):(_t=(Ye=UL(qy(oe.y,0,1))).getDay(),Ye=_t>4||0===_t?a0.ceil(Ye):a0(Ye),Ye=s0.offset(Ye,7*(oe.V-1)),oe.y=Ye.getFullYear(),oe.m=Ye.getMonth(),oe.d=Ye.getDate()+(oe.w+6)%7)}else("W"in oe||"U"in oe)&&("w"in oe||(oe.w="u"in oe?oe.u%7:"W"in oe?1:0),_t="Z"in oe?jL(qy(oe.y,0,1)).getUTCDay():UL(qy(oe.y,0,1)).getDay(),oe.m=0,oe.d="W"in oe?(oe.w+6)%7+7*oe.W-(_t+5)%7:oe.w+7*oe.U-(_t+6)%7);return"Z"in oe?(oe.H+=oe.Z/100|0,oe.M+=oe.Z%100,jL(oe)):UL(oe)}}function xe(ve,mt,ft,oe){for(var ut,sn,st=0,Ye=mt.length,_t=ft.length;st<Ye;){if(oe>=_t)return-1;if(37===(ut=mt.charCodeAt(st++))){if(ut=mt.charAt(st++),!(sn=V[ut in SJ?mt.charAt(st++):ut])||(oe=sn(ve,ft,oe))<0)return-1}else if(ut!=ft.charCodeAt(oe++))return-1}return oe}return R.x=te(e,R),R.X=te(i,R),R.c=te(t,R),A.x=te(e,A),A.X=te(i,A),A.c=te(t,A),{format:function(ve){var mt=te(ve+="",R);return mt.toString=function(){return ve},mt},parse:function(ve){var mt=K(ve+="",!1);return mt.toString=function(){return ve},mt},utcFormat:function(ve){var mt=te(ve+="",A);return mt.toString=function(){return ve},mt},utcParse:function(ve){var mt=K(ve+="",!0);return mt.toString=function(){return ve},mt}}}({dateTime:"%x, %X",date:"%-m/%-d/%Y",time:"%-I:%M:%S %p",periods:["AM","PM"],days:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],shortDays:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],months:["January","February","March","April","May","June","July","August","September","October","November","December"],shortMonths:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]}),d0=c0.format;var Qy=1e3,Zy=60*Qy,Ky=60*Zy,Jy=24*Ky,JIe=7*Jy,UJ=30*Jy,qL=365*Jy;function $Ie(n){return new Date(n)}function eAe(n){return n instanceof Date?+n:+new Date(+n)}function YL(n,t,e,i,r,o,s,a,l){var c=jy(Zs,Zs),d=c.invert,u=c.domain,p=l(".%L"),f=l(":%S"),m=l("%I:%M"),b=l("%I %p"),M=l("%a %d"),y=l("%b %d"),x=l("%B"),R=l("%Y"),A=[[s,1,Qy],[s,5,5*Qy],[s,15,15*Qy],[s,30,30*Qy],[o,1,Zy],[o,5,5*Zy],[o,15,15*Zy],[o,30,30*Zy],[r,1,Ky],[r,3,3*Ky],[r,6,6*Ky],[r,12,12*Ky],[i,1,Jy],[i,2,2*Jy],[e,1,JIe],[t,1,UJ],[t,3,3*UJ],[n,1,qL]];function V(K){return(s(K)<K?p:o(K)<K?f:r(K)<K?m:i(K)<K?b:t(K)<K?e(K)<K?M:y:n(K)<K?x:R)(K)}function te(K,xe,Xe,De){if(null==K&&(K=10),"number"==typeof K){var D=Math.abs(Xe-xe)/K,re=Cy(function(ce){return ce[2]}).right(A,D);re===A.length?(De=Ad(xe/qL,Xe/qL,K),K=n):re?(De=(re=A[D/A[re-1][2]<A[re][2]/D?re-1:re])[1],K=re[0]):(De=Math.max(Ad(xe,Xe,K),1),K=a)}return null==De?K:K.every(De)}return c.invert=function(K){return new Date(d(K))},c.domain=function(K){return arguments.length?u(zy.call(K,eAe)):u().map($Ie)},c.ticks=function(K,xe){var ce,Xe=u(),De=Xe[0],D=Xe[Xe.length-1],re=D<De;return re&&(ce=De,De=D,D=ce),ce=(ce=te(K,De,D,xe))?ce.range(De,D+1):[],re?ce.reverse():ce},c.tickFormat=function(K,xe){return null==xe?V:l(xe)},c.nice=function(K,xe){var Xe=u();return(K=te(K,Xe[0],Xe[Xe.length-1],xe))?u(SD(Xe,K)):c},c.copy=function(){return ep(c,YL(n,t,e,i,r,o,s,a,l))},c}function em(){return Qs.apply(YL(Fd,VL,Kf,s0,BL,LL,AD,TD,d0).domain([new Date(2e3,0,1),new Date(2e3,0,2)]),arguments)}function XL(){this._=null}function u0(n){n.U=n.C=n.L=n.R=n.P=n.N=null}function $y(n,t){var e=t,i=t.R,r=e.U;r?r.L===e?r.L=i:r.R=i:n._=i,i.U=r,e.U=i,e.R=i.L,e.R&&(e.R.U=e),i.L=e}function ex(n,t){var e=t,i=t.L,r=e.U;r?r.L===e?r.L=i:r.R=i:n._=i,i.U=r,e.U=i,e.L=i.R,e.L&&(e.L.U=e),i.R=e}function GJ(n){for(;n.L;)n=n.L;return n}XL.prototype={constructor:XL,insert:function(n,t){var e,i,r;if(n){if(t.P=n,t.N=n.N,n.N&&(n.N.P=t),n.N=t,n.R){for(n=n.R;n.L;)n=n.L;n.L=t}else n.R=t;e=n}else this._?(n=GJ(this._),t.P=null,t.N=n,n.P=n.L=t,e=n):(t.P=t.N=null,this._=t,e=null);for(t.L=t.R=null,t.U=e,t.C=!0,n=t;e&&e.C;)e===(i=e.U).L?(r=i.R)&&r.C?(e.C=r.C=!1,i.C=!0,n=i):(n===e.R&&($y(this,e),e=(n=e).U),e.C=!1,i.C=!0,ex(this,i)):(r=i.L)&&r.C?(e.C=r.C=!1,i.C=!0,n=i):(n===e.L&&(ex(this,e),e=(n=e).U),e.C=!1,i.C=!0,$y(this,i)),e=n.U;this._.C=!1},remove:function(n){n.N&&(n.N.P=n.P),n.P&&(n.P.N=n.N),n.N=n.P=null;var e,o,s,t=n.U,i=n.L,r=n.R;if(o=i?r?GJ(r):i:r,t?t.L===n?t.L=o:t.R=o:this._=o,i&&r?(s=o.C,o.C=n.C,o.L=i,i.U=o,o!==r?(t=o.U,o.U=n.U,t.L=n=o.R,o.R=r,r.U=o):(o.U=t,t=o,n=o.R)):(s=n.C,n=o),n&&(n.U=t),!s){if(n&&n.C)return void(n.C=!1);do{if(n===this._)break;if(n===t.L){if((e=t.R).C&&(e.C=!1,t.C=!0,$y(this,t),e=t.R),e.L&&e.L.C||e.R&&e.R.C){(!e.R||!e.R.C)&&(e.L.C=!1,e.C=!0,ex(this,e),e=t.R),e.C=t.C,t.C=e.R.C=!1,$y(this,t),n=this._;break}}else if((e=t.L).C&&(e.C=!1,t.C=!0,ex(this,t),e=t.L),e.L&&e.L.C||e.R&&e.R.C){(!e.L||!e.L.C)&&(e.R.C=!1,e.C=!0,$y(this,e),e=t.L),e.C=t.C,t.C=e.L.C=!1,ex(this,t),n=this._;break}e.C=!0,n=t,t=t.U}while(!n.C);n&&(n.C=!1)}}};var QL=XL;function p0(n,t,e,i){var r=[null,null],o=Do.push(r)-1;return r.left=n,r.right=t,e&&tx(r,n,t,e),i&&tx(r,t,n,i),hs[n.index].halfedges.push(o),hs[t.index].halfedges.push(o),r}function f0(n,t,e){var i=[t,e];return i.left=n,i}function tx(n,t,e,i){n[0]||n[1]?n.left===e?n[1]=i:n[0]=i:(n[0]=i,n.left=t,n.right=e)}function iAe(n,t,e,i,r){var b,o=n[0],s=n[1],a=o[0],l=o[1],u=0,p=1,f=s[0]-a,m=s[1]-l;if(b=t-a,f||!(b>0)){if(b/=f,f<0){if(b<u)return;b<p&&(p=b)}else if(f>0){if(b>p)return;b>u&&(u=b)}if(b=i-a,f||!(b<0)){if(b/=f,f<0){if(b>p)return;b>u&&(u=b)}else if(f>0){if(b<u)return;b<p&&(p=b)}if(b=e-l,m||!(b>0)){if(b/=m,m<0){if(b<u)return;b<p&&(p=b)}else if(m>0){if(b>p)return;b>u&&(u=b)}if(b=r-l,m||!(b<0)){if(b/=m,m<0){if(b>p)return;b>u&&(u=b)}else if(m>0){if(b<u)return;b<p&&(p=b)}return!(u>0)&&!(p<1)||(u>0&&(n[0]=[a+u*f,l+u*m]),p<1&&(n[1]=[a+p*f,l+p*m])),!0}}}}}function rAe(n,t,e,i,r){var o=n[1];if(o)return!0;var b,M,s=n[0],a=n.left,l=n.right,c=a[0],d=a[1],u=l[0],p=l[1],f=(c+u)/2;if(p===d){if(f<t||f>=i)return;if(c>u){if(s){if(s[1]>=r)return}else s=[f,e];o=[f,r]}else{if(s){if(s[1]<e)return}else s=[f,r];o=[f,e]}}else if(M=(d+p)/2-(b=(c-u)/(p-d))*f,b<-1||b>1)if(c>u){if(s){if(s[1]>=r)return}else s=[(e-M)/b,e];o=[(r-M)/b,r]}else{if(s){if(s[1]<e)return}else s=[(r-M)/b,r];o=[(e-M)/b,e]}else if(d<p){if(s){if(s[0]>=i)return}else s=[t,b*t+M];o=[i,b*i+M]}else{if(s){if(s[0]<t)return}else s=[i,b*i+M];o=[t,b*t+M]}return n[0]=s,n[1]=o,!0}function oAe(n,t){var e=n.site,i=t.left,r=t.right;return e===r&&(r=i,i=e),r?Math.atan2(r[1]-i[1],r[0]-i[0]):(e===i?(i=t[1],r=t[0]):(i=t[0],r=t[1]),Math.atan2(i[0]-r[0],r[1]-i[1]))}function ZL(n,t){return t[+(t.left!==n.site)]}function sAe(n,t){return t[+(t.left===n.site)]}var PD,QJ=[];function aAe(){u0(this),this.x=this.y=this.arc=this.site=this.cy=null}function tm(n){var t=n.P,e=n.N;if(t&&e){var i=t.site,r=n.site,o=e.site;if(i!==o){var s=r[0],a=r[1],l=i[0]-s,c=i[1]-a,d=o[0]-s,u=o[1]-a,p=2*(l*u-c*d);if(!(p>=-ZJ)){var f=l*l+c*c,m=d*d+u*u,b=(u*f-c*m)/p,M=(l*m-d*f)/p,y=QJ.pop()||new aAe;y.arc=n,y.site=r,y.x=b+s,y.y=(y.cy=M+a)+Math.sqrt(b*b+M*M),n.circle=y;for(var x=null,R=m0._;R;)if(y.y<R.y||y.y===R.y&&y.x<=R.x){if(!R.L){x=R.P;break}R=R.L}else{if(!R.R){x=R;break}R=R.R}m0.insert(x,y),x||(PD=y)}}}}function nm(n){var t=n.circle;t&&(t.P||(PD=t.N),m0.remove(t),QJ.push(t),u0(t),n.circle=null)}var JJ=[];function lAe(){u0(this),this.edge=this.site=this.circle=null}function KJ(n){var t=JJ.pop()||new lAe;return t.site=n,t}function KL(n){nm(n),im.remove(n),JJ.push(n),u0(n)}function $J(n){var t=n.circle,e=t.x,i=t.cy,r=[e,i],o=n.P,s=n.N,a=[n];KL(n);for(var l=o;l.circle&&Math.abs(e-l.circle.x)<er&&Math.abs(i-l.circle.cy)<er;)o=l.P,a.unshift(l),KL(l),l=o;a.unshift(l),nm(l);for(var c=s;c.circle&&Math.abs(e-c.circle.x)<er&&Math.abs(i-c.circle.cy)<er;)s=c.N,a.push(c),KL(c),c=s;a.push(c),nm(c);var u,d=a.length;for(u=1;u<d;++u)tx((c=a[u]).edge,(l=a[u-1]).site,c.site,r);(c=a[d-1]).edge=p0((l=a[0]).site,c.site,null,r),tm(l),tm(c)}function e$(n){for(var i,r,o,s,t=n[0],e=n[1],a=im._;a;)if((o=t$(a,e)-t)>er)a=a.L;else{if(!((s=t-cAe(a,e))>er)){o>-er?(i=a.P,r=a):s>-er?(i=a,r=a.N):i=r=a;break}if(!a.R){i=a;break}a=a.R}!function(n){hs[n.index]={site:n,halfedges:[]}}(n);var l=KJ(n);if(im.insert(i,l),i||r){if(i===r)return nm(i),r=KJ(i.site),im.insert(l,r),l.edge=r.edge=p0(i.site,l.site),tm(i),void tm(r);if(!r)return void(l.edge=p0(i.site,l.site));nm(i),nm(r);var c=i.site,d=c[0],u=c[1],p=n[0]-d,f=n[1]-u,m=r.site,b=m[0]-d,M=m[1]-u,y=2*(p*M-f*b),x=p*p+f*f,R=b*b+M*M,A=[(M*x-f*R)/y+d,(p*R-b*x)/y+u];tx(r.edge,c,m,A),l.edge=p0(c,n,null,A),r.edge=p0(n,m,null,A),tm(i),tm(r)}}function t$(n,t){var e=n.site,i=e[0],r=e[1],o=r-t;if(!o)return i;var s=n.P;if(!s)return-1/0;var a=(e=s.site)[0],l=e[1],c=l-t;if(!c)return a;var d=a-i,u=1/o-1/c,p=d/c;return u?(-p+Math.sqrt(p*p-2*u*(d*d/(-2*c)-l+c/2+r-o/2)))/u+i:(i+a)/2}function cAe(n,t){var e=n.N;if(e)return t$(e,t);var i=n.site;return i[1]===t?i[0]:1/0}var im,hs,m0,Do,er=1e-6,ZJ=1e-12;function dAe(n,t,e){return(n[0]-e[0])*(t[1]-n[1])-(n[0]-t[0])*(e[1]-n[1])}function uAe(n,t){return t[1]-n[1]||t[0]-n[0]}function OD(n,t){var i,r,o,e=n.sort(uAe).pop();for(Do=[],hs=new Array(n.length),im=new QL,m0=new QL;;)if(o=PD,e&&(!o||e[1]<o.y||e[1]===o.y&&e[0]<o.x))(e[0]!==i||e[1]!==r)&&(e$(e),i=e[0],r=e[1]),e=n.pop();else{if(!o)break;$J(o.arc)}if(function(){for(var e,i,r,o,n=0,t=hs.length;n<t;++n)if((e=hs[n])&&(o=(i=e.halfedges).length)){var s=new Array(o),a=new Array(o);for(r=0;r<o;++r)s[r]=r,a[r]=oAe(e,Do[i[r]]);for(s.sort(function(l,c){return a[c]-a[l]}),r=0;r<o;++r)a[r]=i[s[r]];for(r=0;r<o;++r)i[r]=a[r]}}(),t){var s=+t[0][0],a=+t[0][1],l=+t[1][0],c=+t[1][1];(function(n,t,e,i){for(var o,r=Do.length;r--;)rAe(o=Do[r],n,t,e,i)&&iAe(o,n,t,e,i)&&(Math.abs(o[0][0]-o[1][0])>er||Math.abs(o[0][1]-o[1][1])>er)||delete Do[r]})(s,a,l,c),function(n,t,e,i){var o,s,a,l,c,d,u,p,f,m,b,M,r=hs.length,y=!0;for(o=0;o<r;++o)if(s=hs[o]){for(a=s.site,l=(c=s.halfedges).length;l--;)Do[c[l]]||c.splice(l,1);for(l=0,d=c.length;l<d;)b=(m=sAe(s,Do[c[l]]))[0],M=m[1],p=(u=ZL(s,Do[c[++l%d]]))[0],f=u[1],(Math.abs(b-p)>er||Math.abs(M-f)>er)&&(c.splice(l,0,Do.push(f0(a,m,Math.abs(b-n)<er&&i-M>er?[n,Math.abs(p-n)<er?f:i]:Math.abs(M-i)<er&&e-b>er?[Math.abs(f-i)<er?p:e,i]:Math.abs(b-e)<er&&M-t>er?[e,Math.abs(p-e)<er?f:t]:Math.abs(M-t)<er&&b-n>er?[Math.abs(f-t)<er?p:n,t]:null))-1),++d);d&&(y=!1)}if(y){var x,R,A,V=1/0;for(o=0,y=null;o<r;++o)(s=hs[o])&&(A=(x=(a=s.site)[0]-n)*x+(R=a[1]-t)*R)<V&&(V=A,y=s);if(y){var te=[n,t],K=[n,i],xe=[e,i],Xe=[e,t];y.halfedges.push(Do.push(f0(a=y.site,te,K))-1,Do.push(f0(a,K,xe))-1,Do.push(f0(a,xe,Xe))-1,Do.push(f0(a,Xe,te))-1)}}for(o=0;o<r;++o)(s=hs[o])&&(s.halfedges.length||delete hs[o])}(s,a,l,c)}this.edges=Do,this.cells=hs,im=m0=Do=hs=null}function rm(n,t,e){this.k=n,this.x=t,this.y=e}OD.prototype={constructor:OD,polygons:function(){var n=this.edges;return this.cells.map(function(t){var e=t.halfedges.map(function(i){return ZL(t,n[i])});return e.data=t.site.data,e})},triangles:function(){var n=[],t=this.edges;return this.cells.forEach(function(e,i){if(a=(o=e.halfedges).length)for(var o,a,l,r=e.site,s=-1,c=t[o[a-1]],d=c.left===r?c.right:c.left;++s<a;)l=d,d=(c=t[o[s]]).left===r?c.right:c.left,l&&d&&i<l.index&&i<d.index&&dAe(r,l,d)<0&&n.push([r.data,l.data,d.data])}),n},links:function(){return this.edges.filter(function(n){return n.right}).map(function(n){return{source:n.left.data,target:n.right.data}})},find:function(n,t,e){for(var r,a,i=this,o=i._found||0,s=i.cells.length;!(a=i.cells[o]);)if(++o>=s)return null;var l=n-a.site[0],c=t-a.site[1],d=l*l+c*c;do{a=i.cells[r=o],o=null,a.halfedges.forEach(function(u){var p=i.edges[u],f=p.left;if(f!==a.site&&f||(f=p.right)){var m=n-f[0],b=t-f[1],M=m*m+b*b;M<d&&(d=M,o=f.index)}})}while(null!==o);return i._found=r,null==e||d<=e*e?a.site:null}},rm.prototype={constructor:rm,scale:function(n){return 1===n?this:new rm(this.k*n,this.x,this.y)},translate:function(n,t){return 0===n&0===t?this:new rm(this.k,this.x+this.k*n,this.y+this.k*t)},apply:function(n){return[n[0]*this.k+this.x,n[1]*this.k+this.y]},applyX:function(n){return n*this.k+this.x},applyY:function(n){return n*this.k+this.y},invert:function(n){return[(n[0]-this.x)/this.k,(n[1]-this.y)/this.k]},invertX:function(n){return(n-this.x)/this.k},invertY:function(n){return(n-this.y)/this.k},rescaleX:function(n){return n.copy().domain(n.range().map(this.invertX,this).map(n.invert,n))},rescaleY:function(n){return n.copy().domain(n.range().map(this.invertY,this).map(n.invert,n))},toString:function(){return"translate("+this.x+","+this.y+") scale("+this.k+")"}},new rm(1,0,0);var s3=1e4,a3=.001,o$=Qr(".2~e"),pAe=Qr(".4~r"),n$=Qr(",~");function i$(n){if(0===n)return"0";let t=Math.abs(n);return t>=s3||t<a3?o$(n):pAe(n)}var ip={formatTick:i$,formatShort:i$,formatReadable(n){let t=Math.abs(n);return t>=s3||t<a3?o$(n):n$(n)},formatLong:n$},fAe=new Intl.NumberFormat(void 0,{maximumFractionDigits:4});function kD(n){return fAe.format(n)}var g0={formatTick:kD,formatShort:kD,formatReadable:kD,formatLong:kD},mAe=Qr("0.3~s"),hAe=Qr(",.3~f");function FD(n){let t=Math.abs(n);return t>=s3||t<a3?mAe(n):hAe(n)}var l3={formatTick:FD,formatShort:FD,formatReadable:FD,formatLong:FD},n3=1e3,i3=60*n3,r3=60*i3,o3=24*r3,r$=365*o3,h0=Qr(".4~");function ND(n){if(0===n)return"0";let t=Math.sign(n)>0?"":"-",e=Math.abs(n);return t+=e<n3?`${h0(e)} ms`:e<i3?`${h0(e/n3)} sec`:e<r3?`${h0(e/i3)} min`:e<o3?`${h0(e/r3)} hr`:e<r$?`${h0(e/o3)} day`:`${h0(e/r$)} yr`,t}var t3,_0={formatTick:ND,formatShort:ND,formatReadable:ND,formatLong:ND},gAe=em().tickFormat(),s$={formatTick:n=>gAe(new Date(n)),formatShort:n=>new Date(n).toLocaleString(t3,{year:"numeric",month:"short",day:"numeric",hour:"numeric",minute:"numeric",second:"numeric"}),formatReadable:n=>new Date(n).toLocaleString(t3,{year:"numeric",month:"short",day:"numeric",hour:"numeric",minute:"numeric",second:"numeric",timeZoneName:"short"}),formatLong:n=>new Date(n).toLocaleString(t3,{year:"numeric",month:"long",day:"numeric",hour:"numeric",minute:"numeric",second:"numeric",timeZoneName:"short",fractionalSecondDigits:3})};function ql(n){switch(n){case nr.LINEAR:return new nx;case nr.LOG10:return new c3;case nr.TIME:return new ix;default:throw new RangeError(`ScaleType ${n} not supported.`)}}var nx=class{constructor(){this.defaultFormatter=ip}transform(t,e,i){let[r,o]=t,s=o-r,[a,l]=e;return 0===s?a:(l-a)/s*(i-r)+a}forward(t,e,i){return this.transform(t,e,i)}reverse(t,e,i){return this.transform(e,t,i)}niceDomain(t){let[e,i]=t;if(i<e)throw new Error("Unexpected input: min is larger than max");if(i===e)return 0===e?[-1,1]:e<0?[2*e,0]:[0,2*e];let r=Wl(),o=.05*(i-e+Number.EPSILON),[s,a]=r.domain([e-o,i+o]).nice().domain();return[s,a]}ticks(t,e){return Wl().domain(t).ticks(e)}isSafeNumber(t){return Number.isFinite(t)}},c3=class{constructor(){this.defaultFormatter=ip}transform(t){return Math.log10(t>0?t:Number.MIN_VALUE)}untransform(t){return Math.exp(t/Math.LOG10E)}forward(t,e,i){if(i<=0)return e[0];let[r,o]=t,[s,a]=e,l=this.transform(r),d=this.transform(o)-l,u=a-s;return i=this.transform(i),u/(d+Number.EPSILON)*(i-l)+s}reverse(t,e,i){let[r,o]=t,[s,a]=e,l=this.transform(r),d=this.transform(o)-l;return this.untransform(d/(a-s+Number.EPSILON)*(i-s)+l)}niceDomain(t){let[e,i]=t;if(e>i)throw new Error("Unexpected input: min is larger than max");let r=Math.max(e,Number.MIN_VALUE),o=Math.max(i,Number.MIN_VALUE);return i<=0?[Number.MIN_VALUE,1]:[Math.max(Number.MIN_VALUE,.5*r),2*o]}ticks(t,e){let i=t[0]<=0?Number.MIN_VALUE:t[0],r=t[1]<=0?Number.MIN_VALUE:t[1],o=Gy().domain([i,r]).ticks(e);return o.length?o:t}isSafeNumber(t){return Number.isFinite(t)&&t>0}},ix=class{constructor(){this.scale=em(),this.defaultFormatter=s$}forward(t,e,i){return this.scale.domain(t).range(e)(i)}reverse(t,e,i){return this.scale.domain(t).range(e).invert(i).getTime()}niceDomain(t){let[e,i]=this.scale.domain(t).nice().domain();return[e.getTime(),i.getTime()]}ticks(t,e){return this.scale.domain(t).ticks(e).map(i=>i.getTime())}isSafeNumber(t){return Number.isFinite(t)}},d3=!1;if(self.hasOwnProperty("WebGL2RenderingContext")&&self.hasOwnProperty("document")){let n=document.createElement("canvas");n.addEventListener("webglcontextcreationerror",()=>{d3=!1});let t=n.getContext("webgl2");d3=Boolean(t)}var Yl_convertRectToExtent=function(n){return{x:[n.x,n.x+n.width],y:[n.y,n.y+n.height]}},Yl_isWebGl2Supported=function(){return d3},Yl_isWebGl2OffscreenCanvasSupported=function(){if(!self.hasOwnProperty("OffscreenCanvas"))return!1;let n=new OffscreenCanvas(0,0).getContext("webgl2");return Boolean(n)},Yl_arePolylinesEqual=function(n,t){if(n.length!==t.length)return!1;for(let e=0;e<n.length;e++)if(n[e]!==t[e])return!1;return!0},b0=class{constructor(){this.xScale=ql(nr.LINEAR),this.yScale=ql(nr.LINEAR),this.domContainerRect={x:0,width:1,y:0,height:1},this.lastUpdated=0,this.currentViewBoxRect={x:0,width:1,y:0,height:1}}getUpdateIdentifier(){return this.lastUpdated}updateIdentifier(){this.lastUpdated++}isYAxisPointedDown(){return!0}setXScale(t){this.xScale=t,this.updateIdentifier()}setYScale(t){this.yScale=t,this.updateIdentifier()}getCurrentViewBoxRect(){return this.currentViewBoxRect}setViewBoxRect(t){this.currentViewBoxRect=t,this.updateIdentifier()}setDomContainerRect(t){this.domContainerRect=t,this.updateIdentifier()}transformDataToUiCoord(t,e){let i=t,r=Yl_convertRectToExtent(this.currentViewBoxRect);return[this.xScale.forward(r.x,[i.x,i.x+i.width],e[0]),this.yScale.forward(r.y,this.isYAxisPointedDown()?[i.y+i.height,i.y]:[i.y,i.y+i.height],e[1])]}};function LD(n,t,e,i){let{color:r,visible:o,opacity:s}=i,a=n;return a||o?(a=a??t(),a=e(a),a.style.display=o?"":"none",a.style.stroke=r,a.style.opacity=String(s??1),a):null}var dV="137",MAe=0,a$=1,wAe=2,jee=1,SAe=2,mx=3,yx=0,go=1,q0=2,pp=0,gx=1,l$=2,c$=3,d$=4,EAe=5,B0=100,TAe=101,DAe=102,u$=103,p$=104,IAe=200,AAe=201,RAe=202,PAe=203,Wee=204,qee=205,OAe=206,kAe=207,FAe=208,NAe=209,LAe=210,BAe=0,VAe=1,HAe=2,Z3=3,zAe=4,UAe=5,jAe=6,GAe=7,YI=0,WAe=1,qAe=2,fp=0,YAe=1,XAe=2,QAe=3,ZAe=4,KAe=5,Wx=301,qx=302,K3=303,J3=304,XI=306,uV=307,$3=1e3,ya=1001,eB=1002,_o=1003,f$=1004,m$=1005,$o=1006,JAe=1007,QI=1008,mp=1009,$Ae=1010,eRe=1011,xx=1012,tRe=1013,_I=1014,cm=1015,U0=1016,nRe=1017,iRe=1018,j0=1020,rRe=1021,gs=1023,oRe=1024,sRe=1025,um=1026,Y0=1027,aRe=1028,lRe=1029,cRe=1030,dRe=1031,uRe=1033,u3=33776,p3=33777,f3=33778,m3=33779,h$=35840,g$=35841,_$=35842,b$=35843,pRe=36196,v$=37492,y$=37496,x$=37808,C$=37809,M$=37810,w$=37811,S$=37812,E$=37813,T$=37814,D$=37815,I$=37816,A$=37817,R$=37818,P$=37819,O$=37820,k$=37821,F$=36492,V0=2400,H0=2401,_p=3e3,Ar=3001,bRe=3201,o_=0,vRe=1,Cx=35044,xI=35048,N$="300 es",tB=1035,Ud=class{addEventListener(t,e){void 0===this._listeners&&(this._listeners={});let i=this._listeners;void 0===i[t]&&(i[t]=[]),-1===i[t].indexOf(e)&&i[t].push(e)}hasEventListener(t,e){if(void 0===this._listeners)return!1;let i=this._listeners;return void 0!==i[t]&&-1!==i[t].indexOf(e)}removeEventListener(t,e){if(void 0===this._listeners)return;let r=this._listeners[t];if(void 0!==r){let o=r.indexOf(e);-1!==o&&r.splice(o,1)}}dispatchEvent(t){if(void 0===this._listeners)return;let i=this._listeners[t.type];if(void 0!==i){t.target=this;let r=i.slice(0);for(let o=0,s=r.length;o<s;o++)r[o].call(this,t);t.target=null}}},Vo=[];for(let n=0;n<256;n++)Vo[n]=(n<16?"0":"")+n.toString(16);var _3=Math.PI/180,nB=180/Math.PI;function Jl(){let n=4294967295*Math.random()|0,t=4294967295*Math.random()|0,e=4294967295*Math.random()|0,i=4294967295*Math.random()|0;return(Vo[255&n]+Vo[n>>8&255]+Vo[n>>16&255]+Vo[n>>24&255]+"-"+Vo[255&t]+Vo[t>>8&255]+"-"+Vo[t>>16&15|64]+Vo[t>>24&255]+"-"+Vo[63&e|128]+Vo[e>>8&255]+"-"+Vo[e>>16&255]+Vo[e>>24&255]+Vo[255&i]+Vo[i>>8&255]+Vo[i>>16&255]+Vo[i>>24&255]).toUpperCase()}function Ks(n,t,e){return Math.max(t,Math.min(e,n))}function b3(n,t,e){return(1-e)*n+e*t}function L$(n){return 0==(n&n-1)&&0!==n}function CRe(n){return Math.pow(2,Math.floor(Math.log(n)/Math.LN2))}var $e=class{constructor(t=0,e=0){this.x=t,this.y=e}get width(){return this.x}set width(t){this.x=t}get height(){return this.y}set height(t){this.y=t}set(t,e){return this.x=t,this.y=e,this}setScalar(t){return this.x=t,this.y=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setComponent(t,e){switch(t){case 0:this.x=e;break;case 1:this.y=e;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y)}copy(t){return this.x=t.x,this.y=t.y,this}add(t,e){return void 0!==e?(console.warn("THREE.Vector2: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(t,e)):(this.x+=t.x,this.y+=t.y,this)}addScalar(t){return this.x+=t,this.y+=t,this}addVectors(t,e){return this.x=t.x+e.x,this.y=t.y+e.y,this}addScaledVector(t,e){return this.x+=t.x*e,this.y+=t.y*e,this}sub(t,e){return void 0!==e?(console.warn("THREE.Vector2: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),this.subVectors(t,e)):(this.x-=t.x,this.y-=t.y,this)}subScalar(t){return this.x-=t,this.y-=t,this}subVectors(t,e){return this.x=t.x-e.x,this.y=t.y-e.y,this}multiply(t){return this.x*=t.x,this.y*=t.y,this}multiplyScalar(t){return this.x*=t,this.y*=t,this}divide(t){return this.x/=t.x,this.y/=t.y,this}divideScalar(t){return this.multiplyScalar(1/t)}applyMatrix3(t){let e=this.x,i=this.y,r=t.elements;return this.x=r[0]*e+r[3]*i+r[6],this.y=r[1]*e+r[4]*i+r[7],this}min(t){return this.x=Math.min(this.x,t.x),this.y=Math.min(this.y,t.y),this}max(t){return this.x=Math.max(this.x,t.x),this.y=Math.max(this.y,t.y),this}clamp(t,e){return this.x=Math.max(t.x,Math.min(e.x,this.x)),this.y=Math.max(t.y,Math.min(e.y,this.y)),this}clampScalar(t,e){return this.x=Math.max(t,Math.min(e,this.x)),this.y=Math.max(t,Math.min(e,this.y)),this}clampLength(t,e){let i=this.length();return this.divideScalar(i||1).multiplyScalar(Math.max(t,Math.min(e,i)))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this}roundToZero(){return this.x=this.x<0?Math.ceil(this.x):Math.floor(this.x),this.y=this.y<0?Math.ceil(this.y):Math.floor(this.y),this}negate(){return this.x=-this.x,this.y=-this.y,this}dot(t){return this.x*t.x+this.y*t.y}cross(t){return this.x*t.y-this.y*t.x}lengthSq(){return this.x*this.x+this.y*this.y}length(){return Math.sqrt(this.x*this.x+this.y*this.y)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)}normalize(){return this.divideScalar(this.length()||1)}angle(){return Math.atan2(-this.y,-this.x)+Math.PI}distanceTo(t){return Math.sqrt(this.distanceToSquared(t))}distanceToSquared(t){let e=this.x-t.x,i=this.y-t.y;return e*e+i*i}manhattanDistanceTo(t){return Math.abs(this.x-t.x)+Math.abs(this.y-t.y)}setLength(t){return this.normalize().multiplyScalar(t)}lerp(t,e){return this.x+=(t.x-this.x)*e,this.y+=(t.y-this.y)*e,this}lerpVectors(t,e,i){return this.x=t.x+(e.x-t.x)*i,this.y=t.y+(e.y-t.y)*i,this}equals(t){return t.x===this.x&&t.y===this.y}fromArray(t,e=0){return this.x=t[e],this.y=t[e+1],this}toArray(t=[],e=0){return t[e]=this.x,t[e+1]=this.y,t}fromBufferAttribute(t,e,i){return void 0!==i&&console.warn("THREE.Vector2: offset has been removed from .fromBufferAttribute()."),this.x=t.getX(e),this.y=t.getY(e),this}rotateAround(t,e){let i=Math.cos(e),r=Math.sin(e),o=this.x-t.x,s=this.y-t.y;return this.x=o*i-s*r+t.x,this.y=o*r+s*i+t.y,this}random(){return this.x=Math.random(),this.y=Math.random(),this}*[Symbol.iterator](){yield this.x,yield this.y}};$e.prototype.isVector2=!0;var bo=class{constructor(){this.elements=[1,0,0,0,1,0,0,0,1],arguments.length>0&&console.error("THREE.Matrix3: the constructor no longer reads arguments. use .set() instead.")}set(t,e,i,r,o,s,a,l,c){let d=this.elements;return d[0]=t,d[1]=r,d[2]=a,d[3]=e,d[4]=o,d[5]=l,d[6]=i,d[7]=s,d[8]=c,this}identity(){return this.set(1,0,0,0,1,0,0,0,1),this}copy(t){let e=this.elements,i=t.elements;return e[0]=i[0],e[1]=i[1],e[2]=i[2],e[3]=i[3],e[4]=i[4],e[5]=i[5],e[6]=i[6],e[7]=i[7],e[8]=i[8],this}extractBasis(t,e,i){return t.setFromMatrix3Column(this,0),e.setFromMatrix3Column(this,1),i.setFromMatrix3Column(this,2),this}setFromMatrix4(t){let e=t.elements;return this.set(e[0],e[4],e[8],e[1],e[5],e[9],e[2],e[6],e[10]),this}multiply(t){return this.multiplyMatrices(this,t)}premultiply(t){return this.multiplyMatrices(t,this)}multiplyMatrices(t,e){let i=t.elements,r=e.elements,o=this.elements,s=i[0],a=i[3],l=i[6],c=i[1],d=i[4],u=i[7],p=i[2],f=i[5],m=i[8],b=r[0],M=r[3],y=r[6],x=r[1],R=r[4],A=r[7],V=r[2],te=r[5],K=r[8];return o[0]=s*b+a*x+l*V,o[3]=s*M+a*R+l*te,o[6]=s*y+a*A+l*K,o[1]=c*b+d*x+u*V,o[4]=c*M+d*R+u*te,o[7]=c*y+d*A+u*K,o[2]=p*b+f*x+m*V,o[5]=p*M+f*R+m*te,o[8]=p*y+f*A+m*K,this}multiplyScalar(t){let e=this.elements;return e[0]*=t,e[3]*=t,e[6]*=t,e[1]*=t,e[4]*=t,e[7]*=t,e[2]*=t,e[5]*=t,e[8]*=t,this}determinant(){let t=this.elements,e=t[0],i=t[1],r=t[2],o=t[3],s=t[4],a=t[5],l=t[6],c=t[7],d=t[8];return e*s*d-e*a*c-i*o*d+i*a*l+r*o*c-r*s*l}invert(){let t=this.elements,e=t[0],i=t[1],r=t[2],o=t[3],s=t[4],a=t[5],l=t[6],c=t[7],d=t[8],u=d*s-a*c,p=a*l-d*o,f=c*o-s*l,m=e*u+i*p+r*f;if(0===m)return this.set(0,0,0,0,0,0,0,0,0);let b=1/m;return t[0]=u*b,t[1]=(r*c-d*i)*b,t[2]=(a*i-r*s)*b,t[3]=p*b,t[4]=(d*e-r*l)*b,t[5]=(r*o-a*e)*b,t[6]=f*b,t[7]=(i*l-c*e)*b,t[8]=(s*e-i*o)*b,this}transpose(){let t,e=this.elements;return t=e[1],e[1]=e[3],e[3]=t,t=e[2],e[2]=e[6],e[6]=t,t=e[5],e[5]=e[7],e[7]=t,this}getNormalMatrix(t){return this.setFromMatrix4(t).invert().transpose()}transposeIntoArray(t){let e=this.elements;return t[0]=e[0],t[1]=e[3],t[2]=e[6],t[3]=e[1],t[4]=e[4],t[5]=e[7],t[6]=e[2],t[7]=e[5],t[8]=e[8],this}setUvTransform(t,e,i,r,o,s,a){let l=Math.cos(o),c=Math.sin(o);return this.set(i*l,i*c,-i*(l*s+c*a)+s+t,-r*c,r*l,-r*(-c*s+l*a)+a+e,0,0,1),this}scale(t,e){let i=this.elements;return i[0]*=t,i[3]*=t,i[6]*=t,i[1]*=e,i[4]*=e,i[7]*=e,this}rotate(t){let e=Math.cos(t),i=Math.sin(t),r=this.elements,o=r[0],s=r[3],a=r[6],l=r[1],c=r[4],d=r[7];return r[0]=e*o+i*l,r[3]=e*s+i*c,r[6]=e*a+i*d,r[1]=-i*o+e*l,r[4]=-i*s+e*c,r[7]=-i*a+e*d,this}translate(t,e){let i=this.elements;return i[0]+=t*i[2],i[3]+=t*i[5],i[6]+=t*i[8],i[1]+=e*i[2],i[4]+=e*i[5],i[7]+=e*i[8],this}equals(t){let e=this.elements,i=t.elements;for(let r=0;r<9;r++)if(e[r]!==i[r])return!1;return!0}fromArray(t,e=0){for(let i=0;i<9;i++)this.elements[i]=t[i+e];return this}toArray(t=[],e=0){let i=this.elements;return t[e]=i[0],t[e+1]=i[1],t[e+2]=i[2],t[e+3]=i[3],t[e+4]=i[4],t[e+5]=i[5],t[e+6]=i[6],t[e+7]=i[7],t[e+8]=i[8],t}clone(){return(new this.constructor).fromArray(this.elements)}};function Qee(n){for(let t=n.length-1;t>=0;--t)if(n[t]>65535)return!0;return!1}function Mx(n){return document.createElementNS("http://www.w3.org/1999/xhtml",n)}bo.prototype.isMatrix3=!0;var B$={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074},Xl={h:0,s:0,l:0},BD={h:0,s:0,l:0};function v3(n,t,e){return e<0&&(e+=1),e>1&&(e-=1),e<1/6?n+6*(t-n)*e:e<.5?t:e<2/3?n+6*(t-n)*(2/3-e):n}function G0(n){return n<.04045?.0773993808*n:Math.pow(.9478672986*n+.0521327014,2.4)}function y3(n){return n<.0031308?12.92*n:1.055*Math.pow(n,.41666)-.055}var an=(()=>{class n{constructor(e,i,r){return void 0===i&&void 0===r?this.set(e):this.setRGB(e,i,r)}set(e){return e&&e.isColor?this.copy(e):"number"==typeof e?this.setHex(e):"string"==typeof e&&this.setStyle(e),this}setScalar(e){return this.r=e,this.g=e,this.b=e,this}setHex(e){return e=Math.floor(e),this.r=(e>>16&255)/255,this.g=(e>>8&255)/255,this.b=(255&e)/255,this}setRGB(e,i,r){return this.r=e,this.g=i,this.b=r,this}setHSL(e,i,r){if(e=function(n,t){return(n%1+1)%1}(e),i=Ks(i,0,1),r=Ks(r,0,1),0===i)this.r=this.g=this.b=r;else{let o=r<=.5?r*(1+i):r+i-r*i,s=2*r-o;this.r=v3(s,o,e+1/3),this.g=v3(s,o,e),this.b=v3(s,o,e-1/3)}return this}setStyle(e){function i(o){void 0!==o&&parseFloat(o)<1&&console.warn("THREE.Color: Alpha component of "+e+" will be ignored.")}let r;if(r=/^((?:rgb|hsl)a?)\(([^\)]*)\)/.exec(e)){let o,a=r[2];switch(r[1]){case"rgb":case"rgba":if(o=/^\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(a))return this.r=Math.min(255,parseInt(o[1],10))/255,this.g=Math.min(255,parseInt(o[2],10))/255,this.b=Math.min(255,parseInt(o[3],10))/255,i(o[4]),this;if(o=/^\s*(\d+)\%\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(a))return this.r=Math.min(100,parseInt(o[1],10))/100,this.g=Math.min(100,parseInt(o[2],10))/100,this.b=Math.min(100,parseInt(o[3],10))/100,i(o[4]),this;break;case"hsl":case"hsla":if(o=/^\s*(\d*\.?\d+)\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(a)){let l=parseFloat(o[1])/360,c=parseInt(o[2],10)/100,d=parseInt(o[3],10)/100;return i(o[4]),this.setHSL(l,c,d)}}}else if(r=/^\#([A-Fa-f\d]+)$/.exec(e)){let o=r[1],s=o.length;if(3===s)return this.r=parseInt(o.charAt(0)+o.charAt(0),16)/255,this.g=parseInt(o.charAt(1)+o.charAt(1),16)/255,this.b=parseInt(o.charAt(2)+o.charAt(2),16)/255,this;if(6===s)return this.r=parseInt(o.charAt(0)+o.charAt(1),16)/255,this.g=parseInt(o.charAt(2)+o.charAt(3),16)/255,this.b=parseInt(o.charAt(4)+o.charAt(5),16)/255,this}return e&&e.length>0?this.setColorName(e):this}setColorName(e){let i=B$[e.toLowerCase()];return void 0!==i?this.setHex(i):console.warn("THREE.Color: Unknown color "+e),this}clone(){return new this.constructor(this.r,this.g,this.b)}copy(e){return this.r=e.r,this.g=e.g,this.b=e.b,this}copySRGBToLinear(e){return this.r=G0(e.r),this.g=G0(e.g),this.b=G0(e.b),this}copyLinearToSRGB(e){return this.r=y3(e.r),this.g=y3(e.g),this.b=y3(e.b),this}convertSRGBToLinear(){return this.copySRGBToLinear(this),this}convertLinearToSRGB(){return this.copyLinearToSRGB(this),this}getHex(){return 255*this.r<<16^255*this.g<<8^255*this.b<<0}getHexString(){return("000000"+this.getHex().toString(16)).slice(-6)}getHSL(e){let l,c,i=this.r,r=this.g,o=this.b,s=Math.max(i,r,o),a=Math.min(i,r,o),d=(a+s)/2;if(a===s)l=0,c=0;else{let u=s-a;switch(c=d<=.5?u/(s+a):u/(2-s-a),s){case i:l=(r-o)/u+(r<o?6:0);break;case r:l=(o-i)/u+2;break;case o:l=(i-r)/u+4}l/=6}return e.h=l,e.s=c,e.l=d,e}getStyle(){return"rgb("+(255*this.r|0)+","+(255*this.g|0)+","+(255*this.b|0)+")"}offsetHSL(e,i,r){return this.getHSL(Xl),Xl.h+=e,Xl.s+=i,Xl.l+=r,this.setHSL(Xl.h,Xl.s,Xl.l),this}add(e){return this.r+=e.r,this.g+=e.g,this.b+=e.b,this}addColors(e,i){return this.r=e.r+i.r,this.g=e.g+i.g,this.b=e.b+i.b,this}addScalar(e){return this.r+=e,this.g+=e,this.b+=e,this}sub(e){return this.r=Math.max(0,this.r-e.r),this.g=Math.max(0,this.g-e.g),this.b=Math.max(0,this.b-e.b),this}multiply(e){return this.r*=e.r,this.g*=e.g,this.b*=e.b,this}multiplyScalar(e){return this.r*=e,this.g*=e,this.b*=e,this}lerp(e,i){return this.r+=(e.r-this.r)*i,this.g+=(e.g-this.g)*i,this.b+=(e.b-this.b)*i,this}lerpColors(e,i,r){return this.r=e.r+(i.r-e.r)*r,this.g=e.g+(i.g-e.g)*r,this.b=e.b+(i.b-e.b)*r,this}lerpHSL(e,i){this.getHSL(Xl),e.getHSL(BD);let r=b3(Xl.h,BD.h,i),o=b3(Xl.s,BD.s,i),s=b3(Xl.l,BD.l,i);return this.setHSL(r,o,s),this}equals(e){return e.r===this.r&&e.g===this.g&&e.b===this.b}fromArray(e,i=0){return this.r=e[i],this.g=e[i+1],this.b=e[i+2],this}toArray(e=[],i=0){return e[i]=this.r,e[i+1]=this.g,e[i+2]=this.b,e}fromBufferAttribute(e,i){return this.r=e.getX(i),this.g=e.getY(i),this.b=e.getZ(i),!0===e.normalized&&(this.r/=255,this.g/=255,this.b/=255),this}toJSON(){return this.getHex()}}return n.NAMES=B$,n})();an.prototype.isColor=!0,an.prototype.r=1,an.prototype.g=1,an.prototype.b=1;var v0,jd=class{static getDataURL(t){if(/^data:/i.test(t.src)||typeof HTMLCanvasElement>"u")return t.src;let e;if(t instanceof HTMLCanvasElement)e=t;else{void 0===v0&&(v0=Mx("canvas")),v0.width=t.width,v0.height=t.height;let i=v0.getContext("2d");t instanceof ImageData?i.putImageData(t,0,0):i.drawImage(t,0,0,t.width,t.height),e=v0}return e.width>2048||e.height>2048?(console.warn("THREE.ImageUtils.getDataURL: Image converted to jpg for performance reasons",t),e.toDataURL("image/jpeg",.6)):e.toDataURL("image/png")}static sRGBToLinear(t){if(typeof HTMLImageElement<"u"&&t instanceof HTMLImageElement||typeof HTMLCanvasElement<"u"&&t instanceof HTMLCanvasElement||typeof ImageBitmap<"u"&&t instanceof ImageBitmap){let e=Mx("canvas");e.width=t.width,e.height=t.height;let i=e.getContext("2d");i.drawImage(t,0,0,t.width,t.height);let r=i.getImageData(0,0,t.width,t.height),o=r.data;for(let s=0;s<o.length;s++)o[s]=255*G0(o[s]/255);return i.putImageData(r,0,0),e}if(t.data){let e=t.data.slice(0);for(let i=0;i<e.length;i++)e[i]=e instanceof Uint8Array||e instanceof Uint8ClampedArray?Math.floor(255*G0(e[i]/255)):G0(e[i]);return{data:e,width:t.width,height:t.height}}return console.warn("THREE.ImageUtils.sRGBToLinear(): Unsupported image type. No color space conversion applied."),t}},MRe=0,lo=class extends Ud{constructor(t=lo.DEFAULT_IMAGE,e=lo.DEFAULT_MAPPING,i=ya,r=ya,o=$o,s=QI,a=gs,l=mp,c=1,d=_p){super(),Object.defineProperty(this,"id",{value:MRe++}),this.uuid=Jl(),this.name="",this.image=t,this.mipmaps=[],this.mapping=e,this.wrapS=i,this.wrapT=r,this.magFilter=o,this.minFilter=s,this.anisotropy=c,this.format=a,this.internalFormat=null,this.type=l,this.offset=new $e(0,0),this.repeat=new $e(1,1),this.center=new $e(0,0),this.rotation=0,this.matrixAutoUpdate=!0,this.matrix=new bo,this.generateMipmaps=!0,this.premultiplyAlpha=!1,this.flipY=!0,this.unpackAlignment=4,this.encoding=d,this.userData={},this.version=0,this.onUpdate=null,this.isRenderTargetTexture=!1,this.needsPMREMUpdate=!1}updateMatrix(){this.matrix.setUvTransform(this.offset.x,this.offset.y,this.repeat.x,this.repeat.y,this.rotation,this.center.x,this.center.y)}clone(){return(new this.constructor).copy(this)}copy(t){return this.name=t.name,this.image=t.image,this.mipmaps=t.mipmaps.slice(0),this.mapping=t.mapping,this.wrapS=t.wrapS,this.wrapT=t.wrapT,this.magFilter=t.magFilter,this.minFilter=t.minFilter,this.anisotropy=t.anisotropy,this.format=t.format,this.internalFormat=t.internalFormat,this.type=t.type,this.offset.copy(t.offset),this.repeat.copy(t.repeat),this.center.copy(t.center),this.rotation=t.rotation,this.matrixAutoUpdate=t.matrixAutoUpdate,this.matrix.copy(t.matrix),this.generateMipmaps=t.generateMipmaps,this.premultiplyAlpha=t.premultiplyAlpha,this.flipY=t.flipY,this.unpackAlignment=t.unpackAlignment,this.encoding=t.encoding,this.userData=JSON.parse(JSON.stringify(t.userData)),this}toJSON(t){let e=void 0===t||"string"==typeof t;if(!e&&void 0!==t.textures[this.uuid])return t.textures[this.uuid];let i={metadata:{version:4.5,type:"Texture",generator:"Texture.toJSON"},uuid:this.uuid,name:this.name,mapping:this.mapping,repeat:[this.repeat.x,this.repeat.y],offset:[this.offset.x,this.offset.y],center:[this.center.x,this.center.y],rotation:this.rotation,wrap:[this.wrapS,this.wrapT],format:this.format,type:this.type,encoding:this.encoding,minFilter:this.minFilter,magFilter:this.magFilter,anisotropy:this.anisotropy,flipY:this.flipY,premultiplyAlpha:this.premultiplyAlpha,unpackAlignment:this.unpackAlignment};if(void 0!==this.image){let r=this.image;if(void 0===r.uuid&&(r.uuid=Jl()),!e&&void 0===t.images[r.uuid]){let o;if(Array.isArray(r)){o=[];for(let s=0,a=r.length;s<a;s++)o.push(x3(r[s].isDataTexture?r[s].image:r[s]))}else o=x3(r);t.images[r.uuid]={uuid:r.uuid,url:o}}i.image=r.uuid}return"{}"!==JSON.stringify(this.userData)&&(i.userData=this.userData),e||(t.textures[this.uuid]=i),i}dispose(){this.dispatchEvent({type:"dispose"})}transformUv(t){if(300!==this.mapping)return t;if(t.applyMatrix3(this.matrix),t.x<0||t.x>1)switch(this.wrapS){case $3:t.x=t.x-Math.floor(t.x);break;case ya:t.x=t.x<0?0:1;break;case eB:t.x=1===Math.abs(Math.floor(t.x)%2)?Math.ceil(t.x)-t.x:t.x-Math.floor(t.x)}if(t.y<0||t.y>1)switch(this.wrapT){case $3:t.y=t.y-Math.floor(t.y);break;case ya:t.y=t.y<0?0:1;break;case eB:t.y=1===Math.abs(Math.floor(t.y)%2)?Math.ceil(t.y)-t.y:t.y-Math.floor(t.y)}return this.flipY&&(t.y=1-t.y),t}set needsUpdate(t){!0===t&&this.version++}};function x3(n){return typeof HTMLImageElement<"u"&&n instanceof HTMLImageElement||typeof HTMLCanvasElement<"u"&&n instanceof HTMLCanvasElement||typeof ImageBitmap<"u"&&n instanceof ImageBitmap?jd.getDataURL(n):n.data?{data:Array.prototype.slice.call(n.data),width:n.width,height:n.height,type:n.data.constructor.name}:(console.warn("THREE.Texture: Unable to serialize Texture."),{})}lo.DEFAULT_IMAGE=void 0,lo.DEFAULT_MAPPING=300,lo.prototype.isTexture=!0;var Zi=class{constructor(t=0,e=0,i=0,r=1){this.x=t,this.y=e,this.z=i,this.w=r}get width(){return this.z}set width(t){this.z=t}get height(){return this.w}set height(t){this.w=t}set(t,e,i,r){return this.x=t,this.y=e,this.z=i,this.w=r,this}setScalar(t){return this.x=t,this.y=t,this.z=t,this.w=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setZ(t){return this.z=t,this}setW(t){return this.w=t,this}setComponent(t,e){switch(t){case 0:this.x=e;break;case 1:this.y=e;break;case 2:this.z=e;break;case 3:this.w=e;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;case 2:return this.z;case 3:return this.w;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y,this.z,this.w)}copy(t){return this.x=t.x,this.y=t.y,this.z=t.z,this.w=void 0!==t.w?t.w:1,this}add(t,e){return void 0!==e?(console.warn("THREE.Vector4: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(t,e)):(this.x+=t.x,this.y+=t.y,this.z+=t.z,this.w+=t.w,this)}addScalar(t){return this.x+=t,this.y+=t,this.z+=t,this.w+=t,this}addVectors(t,e){return this.x=t.x+e.x,this.y=t.y+e.y,this.z=t.z+e.z,this.w=t.w+e.w,this}addScaledVector(t,e){return this.x+=t.x*e,this.y+=t.y*e,this.z+=t.z*e,this.w+=t.w*e,this}sub(t,e){return void 0!==e?(console.warn("THREE.Vector4: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),this.subVectors(t,e)):(this.x-=t.x,this.y-=t.y,this.z-=t.z,this.w-=t.w,this)}subScalar(t){return this.x-=t,this.y-=t,this.z-=t,this.w-=t,this}subVectors(t,e){return this.x=t.x-e.x,this.y=t.y-e.y,this.z=t.z-e.z,this.w=t.w-e.w,this}multiply(t){return this.x*=t.x,this.y*=t.y,this.z*=t.z,this.w*=t.w,this}multiplyScalar(t){return this.x*=t,this.y*=t,this.z*=t,this.w*=t,this}applyMatrix4(t){let e=this.x,i=this.y,r=this.z,o=this.w,s=t.elements;return this.x=s[0]*e+s[4]*i+s[8]*r+s[12]*o,this.y=s[1]*e+s[5]*i+s[9]*r+s[13]*o,this.z=s[2]*e+s[6]*i+s[10]*r+s[14]*o,this.w=s[3]*e+s[7]*i+s[11]*r+s[15]*o,this}divideScalar(t){return this.multiplyScalar(1/t)}setAxisAngleFromQuaternion(t){this.w=2*Math.acos(t.w);let e=Math.sqrt(1-t.w*t.w);return e<1e-4?(this.x=1,this.y=0,this.z=0):(this.x=t.x/e,this.y=t.y/e,this.z=t.z/e),this}setAxisAngleFromRotationMatrix(t){let e,i,r,o,l=t.elements,c=l[0],d=l[4],u=l[8],p=l[1],f=l[5],m=l[9],b=l[2],M=l[6],y=l[10];if(Math.abs(d-p)<.01&&Math.abs(u-b)<.01&&Math.abs(m-M)<.01){if(Math.abs(d+p)<.1&&Math.abs(u+b)<.1&&Math.abs(m+M)<.1&&Math.abs(c+f+y-3)<.1)return this.set(1,0,0,0),this;e=Math.PI;let R=(c+1)/2,A=(f+1)/2,V=(y+1)/2,te=(d+p)/4,K=(u+b)/4,xe=(m+M)/4;return R>A&&R>V?R<.01?(i=0,r=.707106781,o=.707106781):(i=Math.sqrt(R),r=te/i,o=K/i):A>V?A<.01?(i=.707106781,r=0,o=.707106781):(r=Math.sqrt(A),i=te/r,o=xe/r):V<.01?(i=.707106781,r=.707106781,o=0):(o=Math.sqrt(V),i=K/o,r=xe/o),this.set(i,r,o,e),this}let x=Math.sqrt((M-m)*(M-m)+(u-b)*(u-b)+(p-d)*(p-d));return Math.abs(x)<.001&&(x=1),this.x=(M-m)/x,this.y=(u-b)/x,this.z=(p-d)/x,this.w=Math.acos((c+f+y-1)/2),this}min(t){return this.x=Math.min(this.x,t.x),this.y=Math.min(this.y,t.y),this.z=Math.min(this.z,t.z),this.w=Math.min(this.w,t.w),this}max(t){return this.x=Math.max(this.x,t.x),this.y=Math.max(this.y,t.y),this.z=Math.max(this.z,t.z),this.w=Math.max(this.w,t.w),this}clamp(t,e){return this.x=Math.max(t.x,Math.min(e.x,this.x)),this.y=Math.max(t.y,Math.min(e.y,this.y)),this.z=Math.max(t.z,Math.min(e.z,this.z)),this.w=Math.max(t.w,Math.min(e.w,this.w)),this}clampScalar(t,e){return this.x=Math.max(t,Math.min(e,this.x)),this.y=Math.max(t,Math.min(e,this.y)),this.z=Math.max(t,Math.min(e,this.z)),this.w=Math.max(t,Math.min(e,this.w)),this}clampLength(t,e){let i=this.length();return this.divideScalar(i||1).multiplyScalar(Math.max(t,Math.min(e,i)))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this.z=Math.floor(this.z),this.w=Math.floor(this.w),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this.z=Math.ceil(this.z),this.w=Math.ceil(this.w),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this.z=Math.round(this.z),this.w=Math.round(this.w),this}roundToZero(){return this.x=this.x<0?Math.ceil(this.x):Math.floor(this.x),this.y=this.y<0?Math.ceil(this.y):Math.floor(this.y),this.z=this.z<0?Math.ceil(this.z):Math.floor(this.z),this.w=this.w<0?Math.ceil(this.w):Math.floor(this.w),this}negate(){return this.x=-this.x,this.y=-this.y,this.z=-this.z,this.w=-this.w,this}dot(t){return this.x*t.x+this.y*t.y+this.z*t.z+this.w*t.w}lengthSq(){return this.x*this.x+this.y*this.y+this.z*this.z+this.w*this.w}length(){return Math.sqrt(this.x*this.x+this.y*this.y+this.z*this.z+this.w*this.w)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)+Math.abs(this.z)+Math.abs(this.w)}normalize(){return this.divideScalar(this.length()||1)}setLength(t){return this.normalize().multiplyScalar(t)}lerp(t,e){return this.x+=(t.x-this.x)*e,this.y+=(t.y-this.y)*e,this.z+=(t.z-this.z)*e,this.w+=(t.w-this.w)*e,this}lerpVectors(t,e,i){return this.x=t.x+(e.x-t.x)*i,this.y=t.y+(e.y-t.y)*i,this.z=t.z+(e.z-t.z)*i,this.w=t.w+(e.w-t.w)*i,this}equals(t){return t.x===this.x&&t.y===this.y&&t.z===this.z&&t.w===this.w}fromArray(t,e=0){return this.x=t[e],this.y=t[e+1],this.z=t[e+2],this.w=t[e+3],this}toArray(t=[],e=0){return t[e]=this.x,t[e+1]=this.y,t[e+2]=this.z,t[e+3]=this.w,t}fromBufferAttribute(t,e,i){return void 0!==i&&console.warn("THREE.Vector4: offset has been removed from .fromBufferAttribute()."),this.x=t.getX(e),this.y=t.getY(e),this.z=t.getZ(e),this.w=t.getW(e),this}random(){return this.x=Math.random(),this.y=Math.random(),this.z=Math.random(),this.w=Math.random(),this}*[Symbol.iterator](){yield this.x,yield this.y,yield this.z,yield this.w}};Zi.prototype.isVector4=!0;var Js=class extends Ud{constructor(t,e,i={}){super(),this.width=t,this.height=e,this.depth=1,this.scissor=new Zi(0,0,t,e),this.scissorTest=!1,this.viewport=new Zi(0,0,t,e),this.texture=new lo(void 0,i.mapping,i.wrapS,i.wrapT,i.magFilter,i.minFilter,i.format,i.type,i.anisotropy,i.encoding),this.texture.isRenderTargetTexture=!0,this.texture.image={width:t,height:e,depth:1},this.texture.generateMipmaps=void 0!==i.generateMipmaps&&i.generateMipmaps,this.texture.internalFormat=void 0!==i.internalFormat?i.internalFormat:null,this.texture.minFilter=void 0!==i.minFilter?i.minFilter:$o,this.depthBuffer=void 0===i.depthBuffer||i.depthBuffer,this.stencilBuffer=void 0!==i.stencilBuffer&&i.stencilBuffer,this.depthTexture=void 0!==i.depthTexture?i.depthTexture:null}setTexture(t){t.image={width:this.width,height:this.height,depth:this.depth},this.texture=t}setSize(t,e,i=1){(this.width!==t||this.height!==e||this.depth!==i)&&(this.width=t,this.height=e,this.depth=i,this.texture.image.width=t,this.texture.image.height=e,this.texture.image.depth=i,this.dispose()),this.viewport.set(0,0,t,e),this.scissor.set(0,0,t,e)}clone(){return(new this.constructor).copy(this)}copy(t){return this.width=t.width,this.height=t.height,this.depth=t.depth,this.viewport.copy(t.viewport),this.texture=t.texture.clone(),this.texture.image=Object.assign({},t.texture.image),this.depthBuffer=t.depthBuffer,this.stencilBuffer=t.stencilBuffer,this.depthTexture=t.depthTexture,this}dispose(){this.dispatchEvent({type:"dispose"})}};Js.prototype.isWebGLRenderTarget=!0,class extends Js{constructor(t,e,i){super(t,e);let r=this.texture;this.texture=[];for(let o=0;o<i;o++)this.texture[o]=r.clone()}setSize(t,e,i=1){if(this.width!==t||this.height!==e||this.depth!==i){this.width=t,this.height=e,this.depth=i;for(let r=0,o=this.texture.length;r<o;r++)this.texture[r].image.width=t,this.texture[r].image.height=e,this.texture[r].image.depth=i;this.dispose()}return this.viewport.set(0,0,t,e),this.scissor.set(0,0,t,e),this}copy(t){this.dispose(),this.width=t.width,this.height=t.height,this.depth=t.depth,this.viewport.set(0,0,this.width,this.height),this.scissor.set(0,0,this.width,this.height),this.depthBuffer=t.depthBuffer,this.stencilBuffer=t.stencilBuffer,this.depthTexture=t.depthTexture,this.texture.length=0;for(let e=0,i=t.texture.length;e<i;e++)this.texture[e]=t.texture[e].clone();return this}}.prototype.isWebGLMultipleRenderTargets=!0;var wx=class extends Js{constructor(t,e,i={}){super(t,e,i),this.samples=4,this.ignoreDepthForMultisampleCopy=void 0===i.ignoreDepth||i.ignoreDepth,this.useRenderToTexture=void 0!==i.useRenderToTexture&&i.useRenderToTexture,this.useRenderbuffer=!1===this.useRenderToTexture}copy(t){return super.copy.call(this,t),this.samples=t.samples,this.useRenderToTexture=t.useRenderToTexture,this.useRenderbuffer=t.useRenderbuffer,this}};wx.prototype.isWebGLMultisampleRenderTarget=!0;var ts=class{constructor(t=0,e=0,i=0,r=1){this._x=t,this._y=e,this._z=i,this._w=r}static slerp(t,e,i,r){return console.warn("THREE.Quaternion: Static .slerp() has been deprecated. Use qm.slerpQuaternions( qa, qb, t ) instead."),i.slerpQuaternions(t,e,r)}static slerpFlat(t,e,i,r,o,s,a){let l=i[r+0],c=i[r+1],d=i[r+2],u=i[r+3],p=o[s+0],f=o[s+1],m=o[s+2],b=o[s+3];if(0===a)return t[e+0]=l,t[e+1]=c,t[e+2]=d,void(t[e+3]=u);if(1===a)return t[e+0]=p,t[e+1]=f,t[e+2]=m,void(t[e+3]=b);if(u!==b||l!==p||c!==f||d!==m){let M=1-a,y=l*p+c*f+d*m+u*b,x=y>=0?1:-1,R=1-y*y;if(R>Number.EPSILON){let V=Math.sqrt(R),te=Math.atan2(V,y*x);M=Math.sin(M*te)/V,a=Math.sin(a*te)/V}let A=a*x;if(l=l*M+p*A,c=c*M+f*A,d=d*M+m*A,u=u*M+b*A,M===1-a){let V=1/Math.sqrt(l*l+c*c+d*d+u*u);l*=V,c*=V,d*=V,u*=V}}t[e]=l,t[e+1]=c,t[e+2]=d,t[e+3]=u}static multiplyQuaternionsFlat(t,e,i,r,o,s){let a=i[r],l=i[r+1],c=i[r+2],d=i[r+3],u=o[s],p=o[s+1],f=o[s+2],m=o[s+3];return t[e]=a*m+d*u+l*f-c*p,t[e+1]=l*m+d*p+c*u-a*f,t[e+2]=c*m+d*f+a*p-l*u,t[e+3]=d*m-a*u-l*p-c*f,t}get x(){return this._x}set x(t){this._x=t,this._onChangeCallback()}get y(){return this._y}set y(t){this._y=t,this._onChangeCallback()}get z(){return this._z}set z(t){this._z=t,this._onChangeCallback()}get w(){return this._w}set w(t){this._w=t,this._onChangeCallback()}set(t,e,i,r){return this._x=t,this._y=e,this._z=i,this._w=r,this._onChangeCallback(),this}clone(){return new this.constructor(this._x,this._y,this._z,this._w)}copy(t){return this._x=t.x,this._y=t.y,this._z=t.z,this._w=t.w,this._onChangeCallback(),this}setFromEuler(t,e){if(!t||!t.isEuler)throw new Error("THREE.Quaternion: .setFromEuler() now expects an Euler rotation rather than a Vector3 and order.");let i=t._x,r=t._y,o=t._z,s=t._order,a=Math.cos,l=Math.sin,c=a(i/2),d=a(r/2),u=a(o/2),p=l(i/2),f=l(r/2),m=l(o/2);switch(s){case"XYZ":this._x=p*d*u+c*f*m,this._y=c*f*u-p*d*m,this._z=c*d*m+p*f*u,this._w=c*d*u-p*f*m;break;case"YXZ":this._x=p*d*u+c*f*m,this._y=c*f*u-p*d*m,this._z=c*d*m-p*f*u,this._w=c*d*u+p*f*m;break;case"ZXY":this._x=p*d*u-c*f*m,this._y=c*f*u+p*d*m,this._z=c*d*m+p*f*u,this._w=c*d*u-p*f*m;break;case"ZYX":this._x=p*d*u-c*f*m,this._y=c*f*u+p*d*m,this._z=c*d*m-p*f*u,this._w=c*d*u+p*f*m;break;case"YZX":this._x=p*d*u+c*f*m,this._y=c*f*u+p*d*m,this._z=c*d*m-p*f*u,this._w=c*d*u-p*f*m;break;case"XZY":this._x=p*d*u-c*f*m,this._y=c*f*u-p*d*m,this._z=c*d*m+p*f*u,this._w=c*d*u+p*f*m;break;default:console.warn("THREE.Quaternion: .setFromEuler() encountered an unknown order: "+s)}return!1!==e&&this._onChangeCallback(),this}setFromAxisAngle(t,e){let i=e/2,r=Math.sin(i);return this._x=t.x*r,this._y=t.y*r,this._z=t.z*r,this._w=Math.cos(i),this._onChangeCallback(),this}setFromRotationMatrix(t){let e=t.elements,i=e[0],r=e[4],o=e[8],s=e[1],a=e[5],l=e[9],c=e[2],d=e[6],u=e[10],p=i+a+u;if(p>0){let f=.5/Math.sqrt(p+1);this._w=.25/f,this._x=(d-l)*f,this._y=(o-c)*f,this._z=(s-r)*f}else if(i>a&&i>u){let f=2*Math.sqrt(1+i-a-u);this._w=(d-l)/f,this._x=.25*f,this._y=(r+s)/f,this._z=(o+c)/f}else if(a>u){let f=2*Math.sqrt(1+a-i-u);this._w=(o-c)/f,this._x=(r+s)/f,this._y=.25*f,this._z=(l+d)/f}else{let f=2*Math.sqrt(1+u-i-a);this._w=(s-r)/f,this._x=(o+c)/f,this._y=(l+d)/f,this._z=.25*f}return this._onChangeCallback(),this}setFromUnitVectors(t,e){let i=t.dot(e)+1;return i<Number.EPSILON?(i=0,Math.abs(t.x)>Math.abs(t.z)?(this._x=-t.y,this._y=t.x,this._z=0,this._w=i):(this._x=0,this._y=-t.z,this._z=t.y,this._w=i)):(this._x=t.y*e.z-t.z*e.y,this._y=t.z*e.x-t.x*e.z,this._z=t.x*e.y-t.y*e.x,this._w=i),this.normalize()}angleTo(t){return 2*Math.acos(Math.abs(Ks(this.dot(t),-1,1)))}rotateTowards(t,e){let i=this.angleTo(t);if(0===i)return this;let r=Math.min(1,e/i);return this.slerp(t,r),this}identity(){return this.set(0,0,0,1)}invert(){return this.conjugate()}conjugate(){return this._x*=-1,this._y*=-1,this._z*=-1,this._onChangeCallback(),this}dot(t){return this._x*t._x+this._y*t._y+this._z*t._z+this._w*t._w}lengthSq(){return this._x*this._x+this._y*this._y+this._z*this._z+this._w*this._w}length(){return Math.sqrt(this._x*this._x+this._y*this._y+this._z*this._z+this._w*this._w)}normalize(){let t=this.length();return 0===t?(this._x=0,this._y=0,this._z=0,this._w=1):(t=1/t,this._x=this._x*t,this._y=this._y*t,this._z=this._z*t,this._w=this._w*t),this._onChangeCallback(),this}multiply(t,e){return void 0!==e?(console.warn("THREE.Quaternion: .multiply() now only accepts one argument. Use .multiplyQuaternions( a, b ) instead."),this.multiplyQuaternions(t,e)):this.multiplyQuaternions(this,t)}premultiply(t){return this.multiplyQuaternions(t,this)}multiplyQuaternions(t,e){let i=t._x,r=t._y,o=t._z,s=t._w,a=e._x,l=e._y,c=e._z,d=e._w;return this._x=i*d+s*a+r*c-o*l,this._y=r*d+s*l+o*a-i*c,this._z=o*d+s*c+i*l-r*a,this._w=s*d-i*a-r*l-o*c,this._onChangeCallback(),this}slerp(t,e){if(0===e)return this;if(1===e)return this.copy(t);let i=this._x,r=this._y,o=this._z,s=this._w,a=s*t._w+i*t._x+r*t._y+o*t._z;if(a<0?(this._w=-t._w,this._x=-t._x,this._y=-t._y,this._z=-t._z,a=-a):this.copy(t),a>=1)return this._w=s,this._x=i,this._y=r,this._z=o,this;let l=1-a*a;if(l<=Number.EPSILON){let f=1-e;return this._w=f*s+e*this._w,this._x=f*i+e*this._x,this._y=f*r+e*this._y,this._z=f*o+e*this._z,this.normalize(),this._onChangeCallback(),this}let c=Math.sqrt(l),d=Math.atan2(c,a),u=Math.sin((1-e)*d)/c,p=Math.sin(e*d)/c;return this._w=s*u+this._w*p,this._x=i*u+this._x*p,this._y=r*u+this._y*p,this._z=o*u+this._z*p,this._onChangeCallback(),this}slerpQuaternions(t,e,i){return this.copy(t).slerp(e,i)}random(){let t=Math.random(),e=Math.sqrt(1-t),i=Math.sqrt(t),r=2*Math.PI*Math.random(),o=2*Math.PI*Math.random();return this.set(e*Math.cos(r),i*Math.sin(o),i*Math.cos(o),e*Math.sin(r))}equals(t){return t._x===this._x&&t._y===this._y&&t._z===this._z&&t._w===this._w}fromArray(t,e=0){return this._x=t[e],this._y=t[e+1],this._z=t[e+2],this._w=t[e+3],this._onChangeCallback(),this}toArray(t=[],e=0){return t[e]=this._x,t[e+1]=this._y,t[e+2]=this._z,t[e+3]=this._w,t}fromBufferAttribute(t,e){return this._x=t.getX(e),this._y=t.getY(e),this._z=t.getZ(e),this._w=t.getW(e),this}_onChange(t){return this._onChangeCallback=t,this}_onChangeCallback(){}};ts.prototype.isQuaternion=!0;var $=class{constructor(t=0,e=0,i=0){this.x=t,this.y=e,this.z=i}set(t,e,i){return void 0===i&&(i=this.z),this.x=t,this.y=e,this.z=i,this}setScalar(t){return this.x=t,this.y=t,this.z=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setZ(t){return this.z=t,this}setComponent(t,e){switch(t){case 0:this.x=e;break;case 1:this.y=e;break;case 2:this.z=e;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;case 2:return this.z;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y,this.z)}copy(t){return this.x=t.x,this.y=t.y,this.z=t.z,this}add(t,e){return void 0!==e?(console.warn("THREE.Vector3: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(t,e)):(this.x+=t.x,this.y+=t.y,this.z+=t.z,this)}addScalar(t){return this.x+=t,this.y+=t,this.z+=t,this}addVectors(t,e){return this.x=t.x+e.x,this.y=t.y+e.y,this.z=t.z+e.z,this}addScaledVector(t,e){return this.x+=t.x*e,this.y+=t.y*e,this.z+=t.z*e,this}sub(t,e){return void 0!==e?(console.warn("THREE.Vector3: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),this.subVectors(t,e)):(this.x-=t.x,this.y-=t.y,this.z-=t.z,this)}subScalar(t){return this.x-=t,this.y-=t,this.z-=t,this}subVectors(t,e){return this.x=t.x-e.x,this.y=t.y-e.y,this.z=t.z-e.z,this}multiply(t,e){return void 0!==e?(console.warn("THREE.Vector3: .multiply() now only accepts one argument. Use .multiplyVectors( a, b ) instead."),this.multiplyVectors(t,e)):(this.x*=t.x,this.y*=t.y,this.z*=t.z,this)}multiplyScalar(t){return this.x*=t,this.y*=t,this.z*=t,this}multiplyVectors(t,e){return this.x=t.x*e.x,this.y=t.y*e.y,this.z=t.z*e.z,this}applyEuler(t){return t&&t.isEuler||console.error("THREE.Vector3: .applyEuler() now expects an Euler rotation rather than a Vector3 and order."),this.applyQuaternion(V$.setFromEuler(t))}applyAxisAngle(t,e){return this.applyQuaternion(V$.setFromAxisAngle(t,e))}applyMatrix3(t){let e=this.x,i=this.y,r=this.z,o=t.elements;return this.x=o[0]*e+o[3]*i+o[6]*r,this.y=o[1]*e+o[4]*i+o[7]*r,this.z=o[2]*e+o[5]*i+o[8]*r,this}applyNormalMatrix(t){return this.applyMatrix3(t).normalize()}applyMatrix4(t){let e=this.x,i=this.y,r=this.z,o=t.elements,s=1/(o[3]*e+o[7]*i+o[11]*r+o[15]);return this.x=(o[0]*e+o[4]*i+o[8]*r+o[12])*s,this.y=(o[1]*e+o[5]*i+o[9]*r+o[13])*s,this.z=(o[2]*e+o[6]*i+o[10]*r+o[14])*s,this}applyQuaternion(t){let e=this.x,i=this.y,r=this.z,o=t.x,s=t.y,a=t.z,l=t.w,c=l*e+s*r-a*i,d=l*i+a*e-o*r,u=l*r+o*i-s*e,p=-o*e-s*i-a*r;return this.x=c*l+p*-o+d*-a-u*-s,this.y=d*l+p*-s+u*-o-c*-a,this.z=u*l+p*-a+c*-s-d*-o,this}project(t){return this.applyMatrix4(t.matrixWorldInverse).applyMatrix4(t.projectionMatrix)}unproject(t){return this.applyMatrix4(t.projectionMatrixInverse).applyMatrix4(t.matrixWorld)}transformDirection(t){let e=this.x,i=this.y,r=this.z,o=t.elements;return this.x=o[0]*e+o[4]*i+o[8]*r,this.y=o[1]*e+o[5]*i+o[9]*r,this.z=o[2]*e+o[6]*i+o[10]*r,this.normalize()}divide(t){return this.x/=t.x,this.y/=t.y,this.z/=t.z,this}divideScalar(t){return this.multiplyScalar(1/t)}min(t){return this.x=Math.min(this.x,t.x),this.y=Math.min(this.y,t.y),this.z=Math.min(this.z,t.z),this}max(t){return this.x=Math.max(this.x,t.x),this.y=Math.max(this.y,t.y),this.z=Math.max(this.z,t.z),this}clamp(t,e){return this.x=Math.max(t.x,Math.min(e.x,this.x)),this.y=Math.max(t.y,Math.min(e.y,this.y)),this.z=Math.max(t.z,Math.min(e.z,this.z)),this}clampScalar(t,e){return this.x=Math.max(t,Math.min(e,this.x)),this.y=Math.max(t,Math.min(e,this.y)),this.z=Math.max(t,Math.min(e,this.z)),this}clampLength(t,e){let i=this.length();return this.divideScalar(i||1).multiplyScalar(Math.max(t,Math.min(e,i)))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this.z=Math.floor(this.z),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this.z=Math.ceil(this.z),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this.z=Math.round(this.z),this}roundToZero(){return this.x=this.x<0?Math.ceil(this.x):Math.floor(this.x),this.y=this.y<0?Math.ceil(this.y):Math.floor(this.y),this.z=this.z<0?Math.ceil(this.z):Math.floor(this.z),this}negate(){return this.x=-this.x,this.y=-this.y,this.z=-this.z,this}dot(t){return this.x*t.x+this.y*t.y+this.z*t.z}lengthSq(){return this.x*this.x+this.y*this.y+this.z*this.z}length(){return Math.sqrt(this.x*this.x+this.y*this.y+this.z*this.z)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)+Math.abs(this.z)}normalize(){return this.divideScalar(this.length()||1)}setLength(t){return this.normalize().multiplyScalar(t)}lerp(t,e){return this.x+=(t.x-this.x)*e,this.y+=(t.y-this.y)*e,this.z+=(t.z-this.z)*e,this}lerpVectors(t,e,i){return this.x=t.x+(e.x-t.x)*i,this.y=t.y+(e.y-t.y)*i,this.z=t.z+(e.z-t.z)*i,this}cross(t,e){return void 0!==e?(console.warn("THREE.Vector3: .cross() now only accepts one argument. Use .crossVectors( a, b ) instead."),this.crossVectors(t,e)):this.crossVectors(this,t)}crossVectors(t,e){let i=t.x,r=t.y,o=t.z,s=e.x,a=e.y,l=e.z;return this.x=r*l-o*a,this.y=o*s-i*l,this.z=i*a-r*s,this}projectOnVector(t){let e=t.lengthSq();if(0===e)return this.set(0,0,0);let i=t.dot(this)/e;return this.copy(t).multiplyScalar(i)}projectOnPlane(t){return C3.copy(this).projectOnVector(t),this.sub(C3)}reflect(t){return this.sub(C3.copy(t).multiplyScalar(2*this.dot(t)))}angleTo(t){let e=Math.sqrt(this.lengthSq()*t.lengthSq());if(0===e)return Math.PI/2;let i=this.dot(t)/e;return Math.acos(Ks(i,-1,1))}distanceTo(t){return Math.sqrt(this.distanceToSquared(t))}distanceToSquared(t){let e=this.x-t.x,i=this.y-t.y,r=this.z-t.z;return e*e+i*i+r*r}manhattanDistanceTo(t){return Math.abs(this.x-t.x)+Math.abs(this.y-t.y)+Math.abs(this.z-t.z)}setFromSpherical(t){return this.setFromSphericalCoords(t.radius,t.phi,t.theta)}setFromSphericalCoords(t,e,i){let r=Math.sin(e)*t;return this.x=r*Math.sin(i),this.y=Math.cos(e)*t,this.z=r*Math.cos(i),this}setFromCylindrical(t){return this.setFromCylindricalCoords(t.radius,t.theta,t.y)}setFromCylindricalCoords(t,e,i){return this.x=t*Math.sin(e),this.y=i,this.z=t*Math.cos(e),this}setFromMatrixPosition(t){let e=t.elements;return this.x=e[12],this.y=e[13],this.z=e[14],this}setFromMatrixScale(t){let e=this.setFromMatrixColumn(t,0).length(),i=this.setFromMatrixColumn(t,1).length(),r=this.setFromMatrixColumn(t,2).length();return this.x=e,this.y=i,this.z=r,this}setFromMatrixColumn(t,e){return this.fromArray(t.elements,4*e)}setFromMatrix3Column(t,e){return this.fromArray(t.elements,3*e)}equals(t){return t.x===this.x&&t.y===this.y&&t.z===this.z}fromArray(t,e=0){return this.x=t[e],this.y=t[e+1],this.z=t[e+2],this}toArray(t=[],e=0){return t[e]=this.x,t[e+1]=this.y,t[e+2]=this.z,t}fromBufferAttribute(t,e,i){return void 0!==i&&console.warn("THREE.Vector3: offset has been removed from .fromBufferAttribute()."),this.x=t.getX(e),this.y=t.getY(e),this.z=t.getZ(e),this}random(){return this.x=Math.random(),this.y=Math.random(),this.z=Math.random(),this}randomDirection(){let t=2*(Math.random()-.5),e=Math.random()*Math.PI*2,i=Math.sqrt(1-t**2);return this.x=i*Math.cos(e),this.y=i*Math.sin(e),this.z=t,this}*[Symbol.iterator](){yield this.x,yield this.y,yield this.z}};$.prototype.isVector3=!0;var C3=new $,V$=new ts,xa=class{constructor(t=new $(1/0,1/0,1/0),e=new $(-1/0,-1/0,-1/0)){this.min=t,this.max=e}set(t,e){return this.min.copy(t),this.max.copy(e),this}setFromArray(t){let e=1/0,i=1/0,r=1/0,o=-1/0,s=-1/0,a=-1/0;for(let l=0,c=t.length;l<c;l+=3){let d=t[l],u=t[l+1],p=t[l+2];d<e&&(e=d),u<i&&(i=u),p<r&&(r=p),d>o&&(o=d),u>s&&(s=u),p>a&&(a=p)}return this.min.set(e,i,r),this.max.set(o,s,a),this}setFromBufferAttribute(t){let e=1/0,i=1/0,r=1/0,o=-1/0,s=-1/0,a=-1/0;for(let l=0,c=t.count;l<c;l++){let d=t.getX(l),u=t.getY(l),p=t.getZ(l);d<e&&(e=d),u<i&&(i=u),p<r&&(r=p),d>o&&(o=d),u>s&&(s=u),p>a&&(a=p)}return this.min.set(e,i,r),this.max.set(o,s,a),this}setFromPoints(t){this.makeEmpty();for(let e=0,i=t.length;e<i;e++)this.expandByPoint(t[e]);return this}setFromCenterAndSize(t,e){let i=om.copy(e).multiplyScalar(.5);return this.min.copy(t).sub(i),this.max.copy(t).add(i),this}setFromObject(t,e=!1){return this.makeEmpty(),this.expandByObject(t,e)}clone(){return(new this.constructor).copy(this)}copy(t){return this.min.copy(t.min),this.max.copy(t.max),this}makeEmpty(){return this.min.x=this.min.y=this.min.z=1/0,this.max.x=this.max.y=this.max.z=-1/0,this}isEmpty(){return this.max.x<this.min.x||this.max.y<this.min.y||this.max.z<this.min.z}getCenter(t){return this.isEmpty()?t.set(0,0,0):t.addVectors(this.min,this.max).multiplyScalar(.5)}getSize(t){return this.isEmpty()?t.set(0,0,0):t.subVectors(this.max,this.min)}expandByPoint(t){return this.min.min(t),this.max.max(t),this}expandByVector(t){return this.min.sub(t),this.max.add(t),this}expandByScalar(t){return this.min.addScalar(-t),this.max.addScalar(t),this}expandByObject(t,e=!1){t.updateWorldMatrix(!1,!1);let i=t.geometry;if(void 0!==i)if(e&&null!=i.attributes&&void 0!==i.attributes.position){let o=i.attributes.position;for(let s=0,a=o.count;s<a;s++)om.fromBufferAttribute(o,s).applyMatrix4(t.matrixWorld),this.expandByPoint(om)}else null===i.boundingBox&&i.computeBoundingBox(),M3.copy(i.boundingBox),M3.applyMatrix4(t.matrixWorld),this.union(M3);let r=t.children;for(let o=0,s=r.length;o<s;o++)this.expandByObject(r[o],e);return this}containsPoint(t){return!(t.x<this.min.x||t.x>this.max.x||t.y<this.min.y||t.y>this.max.y||t.z<this.min.z||t.z>this.max.z)}containsBox(t){return this.min.x<=t.min.x&&t.max.x<=this.max.x&&this.min.y<=t.min.y&&t.max.y<=this.max.y&&this.min.z<=t.min.z&&t.max.z<=this.max.z}getParameter(t,e){return e.set((t.x-this.min.x)/(this.max.x-this.min.x),(t.y-this.min.y)/(this.max.y-this.min.y),(t.z-this.min.z)/(this.max.z-this.min.z))}intersectsBox(t){return!(t.max.x<this.min.x||t.min.x>this.max.x||t.max.y<this.min.y||t.min.y>this.max.y||t.max.z<this.min.z||t.min.z>this.max.z)}intersectsSphere(t){return this.clampPoint(t.center,om),om.distanceToSquared(t.center)<=t.radius*t.radius}intersectsPlane(t){let e,i;return t.normal.x>0?(e=t.normal.x*this.min.x,i=t.normal.x*this.max.x):(e=t.normal.x*this.max.x,i=t.normal.x*this.min.x),t.normal.y>0?(e+=t.normal.y*this.min.y,i+=t.normal.y*this.max.y):(e+=t.normal.y*this.max.y,i+=t.normal.y*this.min.y),t.normal.z>0?(e+=t.normal.z*this.min.z,i+=t.normal.z*this.max.z):(e+=t.normal.z*this.max.z,i+=t.normal.z*this.min.z),e<=-t.constant&&i>=-t.constant}intersectsTriangle(t){if(this.isEmpty())return!1;this.getCenter(ox),VD.subVectors(this.max,ox),y0.subVectors(t.a,ox),x0.subVectors(t.b,ox),C0.subVectors(t.c,ox),rp.subVectors(x0,y0),op.subVectors(C0,x0),sm.subVectors(y0,C0);let e=[0,-rp.z,rp.y,0,-op.z,op.y,0,-sm.z,sm.y,rp.z,0,-rp.x,op.z,0,-op.x,sm.z,0,-sm.x,-rp.y,rp.x,0,-op.y,op.x,0,-sm.y,sm.x,0];return!(!w3(e,y0,x0,C0,VD)||(e=[1,0,0,0,1,0,0,0,1],!w3(e,y0,x0,C0,VD)))&&(HD.crossVectors(rp,op),e=[HD.x,HD.y,HD.z],w3(e,y0,x0,C0,VD))}clampPoint(t,e){return e.copy(t).clamp(this.min,this.max)}distanceToPoint(t){return om.copy(t).clamp(this.min,this.max).sub(t).length()}getBoundingSphere(t){return this.getCenter(t.center),t.radius=.5*this.getSize(om).length(),t}intersect(t){return this.min.max(t.min),this.max.min(t.max),this.isEmpty()&&this.makeEmpty(),this}union(t){return this.min.min(t.min),this.max.max(t.max),this}applyMatrix4(t){return this.isEmpty()||(Nd[0].set(this.min.x,this.min.y,this.min.z).applyMatrix4(t),Nd[1].set(this.min.x,this.min.y,this.max.z).applyMatrix4(t),Nd[2].set(this.min.x,this.max.y,this.min.z).applyMatrix4(t),Nd[3].set(this.min.x,this.max.y,this.max.z).applyMatrix4(t),Nd[4].set(this.max.x,this.min.y,this.min.z).applyMatrix4(t),Nd[5].set(this.max.x,this.min.y,this.max.z).applyMatrix4(t),Nd[6].set(this.max.x,this.max.y,this.min.z).applyMatrix4(t),Nd[7].set(this.max.x,this.max.y,this.max.z).applyMatrix4(t),this.setFromPoints(Nd)),this}translate(t){return this.min.add(t),this.max.add(t),this}equals(t){return t.min.equals(this.min)&&t.max.equals(this.max)}};xa.prototype.isBox3=!0;var Nd=[new $,new $,new $,new $,new $,new $,new $,new $],om=new $,M3=new xa,y0=new $,x0=new $,C0=new $,rp=new $,op=new $,sm=new $,ox=new $,VD=new $,HD=new $,am=new $;function w3(n,t,e,i,r){for(let o=0,s=n.length-3;o<=s;o+=3){am.fromArray(n,o);let a=r.x*Math.abs(am.x)+r.y*Math.abs(am.y)+r.z*Math.abs(am.z),l=t.dot(am),c=e.dot(am),d=i.dot(am);if(Math.max(-Math.max(l,c,d),Math.min(l,c,d))>a)return!1}return!0}var wRe=new xa,H$=new $,zD=new $,S3=new $,bp=class{constructor(t=new $,e=-1){this.center=t,this.radius=e}set(t,e){return this.center.copy(t),this.radius=e,this}setFromPoints(t,e){let i=this.center;void 0!==e?i.copy(e):wRe.setFromPoints(t).getCenter(i);let r=0;for(let o=0,s=t.length;o<s;o++)r=Math.max(r,i.distanceToSquared(t[o]));return this.radius=Math.sqrt(r),this}copy(t){return this.center.copy(t.center),this.radius=t.radius,this}isEmpty(){return this.radius<0}makeEmpty(){return this.center.set(0,0,0),this.radius=-1,this}containsPoint(t){return t.distanceToSquared(this.center)<=this.radius*this.radius}distanceToPoint(t){return t.distanceTo(this.center)-this.radius}intersectsSphere(t){let e=this.radius+t.radius;return t.center.distanceToSquared(this.center)<=e*e}intersectsBox(t){return t.intersectsSphere(this)}intersectsPlane(t){return Math.abs(t.distanceToPoint(this.center))<=this.radius}clampPoint(t,e){let i=this.center.distanceToSquared(t);return e.copy(t),i>this.radius*this.radius&&(e.sub(this.center).normalize(),e.multiplyScalar(this.radius).add(this.center)),e}getBoundingBox(t){return this.isEmpty()?(t.makeEmpty(),t):(t.set(this.center,this.center),t.expandByScalar(this.radius),t)}applyMatrix4(t){return this.center.applyMatrix4(t),this.radius=this.radius*t.getMaxScaleOnAxis(),this}translate(t){return this.center.add(t),this}expandByPoint(t){S3.subVectors(t,this.center);let e=S3.lengthSq();if(e>this.radius*this.radius){let i=Math.sqrt(e),r=.5*(i-this.radius);this.center.add(S3.multiplyScalar(r/i)),this.radius+=r}return this}union(t){return!0===this.center.equals(t.center)?zD.set(0,0,1).multiplyScalar(t.radius):zD.subVectors(t.center,this.center).normalize().multiplyScalar(t.radius),this.expandByPoint(H$.copy(t.center).add(zD)),this.expandByPoint(H$.copy(t.center).sub(zD)),this}equals(t){return t.center.equals(this.center)&&t.radius===this.radius}clone(){return(new this.constructor).copy(this)}},Ld=new $,E3=new $,UD=new $,sp=new $,T3=new $,jD=new $,D3=new $,vp=class{constructor(t=new $,e=new $(0,0,-1)){this.origin=t,this.direction=e}set(t,e){return this.origin.copy(t),this.direction.copy(e),this}copy(t){return this.origin.copy(t.origin),this.direction.copy(t.direction),this}at(t,e){return e.copy(this.direction).multiplyScalar(t).add(this.origin)}lookAt(t){return this.direction.copy(t).sub(this.origin).normalize(),this}recast(t){return this.origin.copy(this.at(t,Ld)),this}closestPointToPoint(t,e){e.subVectors(t,this.origin);let i=e.dot(this.direction);return i<0?e.copy(this.origin):e.copy(this.direction).multiplyScalar(i).add(this.origin)}distanceToPoint(t){return Math.sqrt(this.distanceSqToPoint(t))}distanceSqToPoint(t){let e=Ld.subVectors(t,this.origin).dot(this.direction);return e<0?this.origin.distanceToSquared(t):(Ld.copy(this.direction).multiplyScalar(e).add(this.origin),Ld.distanceToSquared(t))}distanceSqToSegment(t,e,i,r){E3.copy(t).add(e).multiplyScalar(.5),UD.copy(e).sub(t).normalize(),sp.copy(this.origin).sub(E3);let u,p,f,m,o=.5*t.distanceTo(e),s=-this.direction.dot(UD),a=sp.dot(this.direction),l=-sp.dot(UD),c=sp.lengthSq(),d=Math.abs(1-s*s);if(d>0)if(u=s*l-a,p=s*a-l,m=o*d,u>=0)if(p>=-m)if(p<=m){let b=1/d;u*=b,p*=b,f=u*(u+s*p+2*a)+p*(s*u+p+2*l)+c}else p=o,u=Math.max(0,-(s*p+a)),f=-u*u+p*(p+2*l)+c;else p=-o,u=Math.max(0,-(s*p+a)),f=-u*u+p*(p+2*l)+c;else p<=-m?(u=Math.max(0,-(-s*o+a)),p=u>0?-o:Math.min(Math.max(-o,-l),o),f=-u*u+p*(p+2*l)+c):p<=m?(u=0,p=Math.min(Math.max(-o,-l),o),f=p*(p+2*l)+c):(u=Math.max(0,-(s*o+a)),p=u>0?o:Math.min(Math.max(-o,-l),o),f=-u*u+p*(p+2*l)+c);else p=s>0?-o:o,u=Math.max(0,-(s*p+a)),f=-u*u+p*(p+2*l)+c;return i&&i.copy(this.direction).multiplyScalar(u).add(this.origin),r&&r.copy(UD).multiplyScalar(p).add(E3),f}intersectSphere(t,e){Ld.subVectors(t.center,this.origin);let i=Ld.dot(this.direction),r=Ld.dot(Ld)-i*i,o=t.radius*t.radius;if(r>o)return null;let s=Math.sqrt(o-r),a=i-s,l=i+s;return a<0&&l<0?null:this.at(a<0?l:a,e)}intersectsSphere(t){return this.distanceSqToPoint(t.center)<=t.radius*t.radius}distanceToPlane(t){let e=t.normal.dot(this.direction);if(0===e)return 0===t.distanceToPoint(this.origin)?0:null;let i=-(this.origin.dot(t.normal)+t.constant)/e;return i>=0?i:null}intersectPlane(t,e){let i=this.distanceToPlane(t);return null===i?null:this.at(i,e)}intersectsPlane(t){let e=t.distanceToPoint(this.origin);return 0===e||t.normal.dot(this.direction)*e<0}intersectBox(t,e){let i,r,o,s,a,l,c=1/this.direction.x,d=1/this.direction.y,u=1/this.direction.z,p=this.origin;return c>=0?(i=(t.min.x-p.x)*c,r=(t.max.x-p.x)*c):(i=(t.max.x-p.x)*c,r=(t.min.x-p.x)*c),d>=0?(o=(t.min.y-p.y)*d,s=(t.max.y-p.y)*d):(o=(t.max.y-p.y)*d,s=(t.min.y-p.y)*d),i>s||o>r||((o>i||i!=i)&&(i=o),(s<r||r!=r)&&(r=s),u>=0?(a=(t.min.z-p.z)*u,l=(t.max.z-p.z)*u):(a=(t.max.z-p.z)*u,l=(t.min.z-p.z)*u),i>l||a>r)||((a>i||i!=i)&&(i=a),(l<r||r!=r)&&(r=l),r<0)?null:this.at(i>=0?i:r,e)}intersectsBox(t){return null!==this.intersectBox(t,Ld)}intersectTriangle(t,e,i,r,o){T3.subVectors(e,t),jD.subVectors(i,t),D3.crossVectors(T3,jD);let a,s=this.direction.dot(D3);if(s>0){if(r)return null;a=1}else{if(!(s<0))return null;a=-1,s=-s}sp.subVectors(this.origin,t);let l=a*this.direction.dot(jD.crossVectors(sp,jD));if(l<0)return null;let c=a*this.direction.dot(T3.cross(sp));if(c<0||l+c>s)return null;let d=-a*sp.dot(D3);return d<0?null:this.at(d/s,o)}applyMatrix4(t){return this.origin.applyMatrix4(t),this.direction.transformDirection(t),this}equals(t){return t.origin.equals(this.origin)&&t.direction.equals(this.direction)}clone(){return(new this.constructor).copy(this)}},xn=class{constructor(){this.elements=[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1],arguments.length>0&&console.error("THREE.Matrix4: the constructor no longer reads arguments. use .set() instead.")}set(t,e,i,r,o,s,a,l,c,d,u,p,f,m,b,M){let y=this.elements;return y[0]=t,y[4]=e,y[8]=i,y[12]=r,y[1]=o,y[5]=s,y[9]=a,y[13]=l,y[2]=c,y[6]=d,y[10]=u,y[14]=p,y[3]=f,y[7]=m,y[11]=b,y[15]=M,this}identity(){return this.set(1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1),this}clone(){return(new xn).fromArray(this.elements)}copy(t){let e=this.elements,i=t.elements;return e[0]=i[0],e[1]=i[1],e[2]=i[2],e[3]=i[3],e[4]=i[4],e[5]=i[5],e[6]=i[6],e[7]=i[7],e[8]=i[8],e[9]=i[9],e[10]=i[10],e[11]=i[11],e[12]=i[12],e[13]=i[13],e[14]=i[14],e[15]=i[15],this}copyPosition(t){let e=this.elements,i=t.elements;return e[12]=i[12],e[13]=i[13],e[14]=i[14],this}setFromMatrix3(t){let e=t.elements;return this.set(e[0],e[3],e[6],0,e[1],e[4],e[7],0,e[2],e[5],e[8],0,0,0,0,1),this}extractBasis(t,e,i){return t.setFromMatrixColumn(this,0),e.setFromMatrixColumn(this,1),i.setFromMatrixColumn(this,2),this}makeBasis(t,e,i){return this.set(t.x,e.x,i.x,0,t.y,e.y,i.y,0,t.z,e.z,i.z,0,0,0,0,1),this}extractRotation(t){let e=this.elements,i=t.elements,r=1/M0.setFromMatrixColumn(t,0).length(),o=1/M0.setFromMatrixColumn(t,1).length(),s=1/M0.setFromMatrixColumn(t,2).length();return e[0]=i[0]*r,e[1]=i[1]*r,e[2]=i[2]*r,e[3]=0,e[4]=i[4]*o,e[5]=i[5]*o,e[6]=i[6]*o,e[7]=0,e[8]=i[8]*s,e[9]=i[9]*s,e[10]=i[10]*s,e[11]=0,e[12]=0,e[13]=0,e[14]=0,e[15]=1,this}makeRotationFromEuler(t){t&&t.isEuler||console.error("THREE.Matrix4: .makeRotationFromEuler() now expects a Euler rotation rather than a Vector3 and order.");let e=this.elements,i=t.x,r=t.y,o=t.z,s=Math.cos(i),a=Math.sin(i),l=Math.cos(r),c=Math.sin(r),d=Math.cos(o),u=Math.sin(o);if("XYZ"===t.order){let p=s*d,f=s*u,m=a*d,b=a*u;e[0]=l*d,e[4]=-l*u,e[8]=c,e[1]=f+m*c,e[5]=p-b*c,e[9]=-a*l,e[2]=b-p*c,e[6]=m+f*c,e[10]=s*l}else if("YXZ"===t.order){let p=l*d,f=l*u,m=c*d,b=c*u;e[0]=p+b*a,e[4]=m*a-f,e[8]=s*c,e[1]=s*u,e[5]=s*d,e[9]=-a,e[2]=f*a-m,e[6]=b+p*a,e[10]=s*l}else if("ZXY"===t.order){let p=l*d,f=l*u,m=c*d,b=c*u;e[0]=p-b*a,e[4]=-s*u,e[8]=m+f*a,e[1]=f+m*a,e[5]=s*d,e[9]=b-p*a,e[2]=-s*c,e[6]=a,e[10]=s*l}else if("ZYX"===t.order){let p=s*d,f=s*u,m=a*d,b=a*u;e[0]=l*d,e[4]=m*c-f,e[8]=p*c+b,e[1]=l*u,e[5]=b*c+p,e[9]=f*c-m,e[2]=-c,e[6]=a*l,e[10]=s*l}else if("YZX"===t.order){let p=s*l,f=s*c,m=a*l,b=a*c;e[0]=l*d,e[4]=b-p*u,e[8]=m*u+f,e[1]=u,e[5]=s*d,e[9]=-a*d,e[2]=-c*d,e[6]=f*u+m,e[10]=p-b*u}else if("XZY"===t.order){let p=s*l,f=s*c,m=a*l,b=a*c;e[0]=l*d,e[4]=-u,e[8]=c*d,e[1]=p*u+b,e[5]=s*d,e[9]=f*u-m,e[2]=m*u-f,e[6]=a*d,e[10]=b*u+p}return e[3]=0,e[7]=0,e[11]=0,e[12]=0,e[13]=0,e[14]=0,e[15]=1,this}makeRotationFromQuaternion(t){return this.compose(SRe,t,ERe)}lookAt(t,e,i){let r=this.elements;return ba.subVectors(t,e),0===ba.lengthSq()&&(ba.z=1),ba.normalize(),ap.crossVectors(i,ba),0===ap.lengthSq()&&(1===Math.abs(i.z)?ba.x+=1e-4:ba.z+=1e-4,ba.normalize(),ap.crossVectors(i,ba)),ap.normalize(),GD.crossVectors(ba,ap),r[0]=ap.x,r[4]=GD.x,r[8]=ba.x,r[1]=ap.y,r[5]=GD.y,r[9]=ba.y,r[2]=ap.z,r[6]=GD.z,r[10]=ba.z,this}multiply(t,e){return void 0!==e?(console.warn("THREE.Matrix4: .multiply() now only accepts one argument. Use .multiplyMatrices( a, b ) instead."),this.multiplyMatrices(t,e)):this.multiplyMatrices(this,t)}premultiply(t){return this.multiplyMatrices(t,this)}multiplyMatrices(t,e){let i=t.elements,r=e.elements,o=this.elements,s=i[0],a=i[4],l=i[8],c=i[12],d=i[1],u=i[5],p=i[9],f=i[13],m=i[2],b=i[6],M=i[10],y=i[14],x=i[3],R=i[7],A=i[11],V=i[15],te=r[0],K=r[4],xe=r[8],Xe=r[12],De=r[1],D=r[5],re=r[9],ce=r[13],fe=r[2],be=r[6],ne=r[10],de=r[14],pe=r[3],je=r[7],Ce=r[11],Ne=r[15];return o[0]=s*te+a*De+l*fe+c*pe,o[4]=s*K+a*D+l*be+c*je,o[8]=s*xe+a*re+l*ne+c*Ce,o[12]=s*Xe+a*ce+l*de+c*Ne,o[1]=d*te+u*De+p*fe+f*pe,o[5]=d*K+u*D+p*be+f*je,o[9]=d*xe+u*re+p*ne+f*Ce,o[13]=d*Xe+u*ce+p*de+f*Ne,o[2]=m*te+b*De+M*fe+y*pe,o[6]=m*K+b*D+M*be+y*je,o[10]=m*xe+b*re+M*ne+y*Ce,o[14]=m*Xe+b*ce+M*de+y*Ne,o[3]=x*te+R*De+A*fe+V*pe,o[7]=x*K+R*D+A*be+V*je,o[11]=x*xe+R*re+A*ne+V*Ce,o[15]=x*Xe+R*ce+A*de+V*Ne,this}multiplyScalar(t){let e=this.elements;return e[0]*=t,e[4]*=t,e[8]*=t,e[12]*=t,e[1]*=t,e[5]*=t,e[9]*=t,e[13]*=t,e[2]*=t,e[6]*=t,e[10]*=t,e[14]*=t,e[3]*=t,e[7]*=t,e[11]*=t,e[15]*=t,this}determinant(){let t=this.elements,e=t[0],i=t[4],r=t[8],o=t[12],s=t[1],a=t[5],l=t[9],c=t[13],d=t[2],u=t[6],p=t[10],f=t[14];return t[3]*(+o*l*u-r*c*u-o*a*p+i*c*p+r*a*f-i*l*f)+t[7]*(+e*l*f-e*c*p+o*s*p-r*s*f+r*c*d-o*l*d)+t[11]*(+e*c*u-e*a*f-o*s*u+i*s*f+o*a*d-i*c*d)+t[15]*(-r*a*d-e*l*u+e*a*p+r*s*u-i*s*p+i*l*d)}transpose(){let e,t=this.elements;return e=t[1],t[1]=t[4],t[4]=e,e=t[2],t[2]=t[8],t[8]=e,e=t[6],t[6]=t[9],t[9]=e,e=t[3],t[3]=t[12],t[12]=e,e=t[7],t[7]=t[13],t[13]=e,e=t[11],t[11]=t[14],t[14]=e,this}setPosition(t,e,i){let r=this.elements;return t.isVector3?(r[12]=t.x,r[13]=t.y,r[14]=t.z):(r[12]=t,r[13]=e,r[14]=i),this}invert(){let t=this.elements,e=t[0],i=t[1],r=t[2],o=t[3],s=t[4],a=t[5],l=t[6],c=t[7],d=t[8],u=t[9],p=t[10],f=t[11],m=t[12],b=t[13],M=t[14],y=t[15],x=u*M*c-b*p*c+b*l*f-a*M*f-u*l*y+a*p*y,R=m*p*c-d*M*c-m*l*f+s*M*f+d*l*y-s*p*y,A=d*b*c-m*u*c+m*a*f-s*b*f-d*a*y+s*u*y,V=m*u*l-d*b*l-m*a*p+s*b*p+d*a*M-s*u*M,te=e*x+i*R+r*A+o*V;if(0===te)return this.set(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0);let K=1/te;return t[0]=x*K,t[1]=(b*p*o-u*M*o-b*r*f+i*M*f+u*r*y-i*p*y)*K,t[2]=(a*M*o-b*l*o+b*r*c-i*M*c-a*r*y+i*l*y)*K,t[3]=(u*l*o-a*p*o-u*r*c+i*p*c+a*r*f-i*l*f)*K,t[4]=R*K,t[5]=(d*M*o-m*p*o+m*r*f-e*M*f-d*r*y+e*p*y)*K,t[6]=(m*l*o-s*M*o-m*r*c+e*M*c+s*r*y-e*l*y)*K,t[7]=(s*p*o-d*l*o+d*r*c-e*p*c-s*r*f+e*l*f)*K,t[8]=A*K,t[9]=(m*u*o-d*b*o-m*i*f+e*b*f+d*i*y-e*u*y)*K,t[10]=(s*b*o-m*a*o+m*i*c-e*b*c-s*i*y+e*a*y)*K,t[11]=(d*a*o-s*u*o-d*i*c+e*u*c+s*i*f-e*a*f)*K,t[12]=V*K,t[13]=(d*b*r-m*u*r+m*i*p-e*b*p-d*i*M+e*u*M)*K,t[14]=(m*a*r-s*b*r-m*i*l+e*b*l+s*i*M-e*a*M)*K,t[15]=(s*u*r-d*a*r+d*i*l-e*u*l-s*i*p+e*a*p)*K,this}scale(t){let e=this.elements,i=t.x,r=t.y,o=t.z;return e[0]*=i,e[4]*=r,e[8]*=o,e[1]*=i,e[5]*=r,e[9]*=o,e[2]*=i,e[6]*=r,e[10]*=o,e[3]*=i,e[7]*=r,e[11]*=o,this}getMaxScaleOnAxis(){let t=this.elements;return Math.sqrt(Math.max(t[0]*t[0]+t[1]*t[1]+t[2]*t[2],t[4]*t[4]+t[5]*t[5]+t[6]*t[6],t[8]*t[8]+t[9]*t[9]+t[10]*t[10]))}makeTranslation(t,e,i){return this.set(1,0,0,t,0,1,0,e,0,0,1,i,0,0,0,1),this}makeRotationX(t){let e=Math.cos(t),i=Math.sin(t);return this.set(1,0,0,0,0,e,-i,0,0,i,e,0,0,0,0,1),this}makeRotationY(t){let e=Math.cos(t),i=Math.sin(t);return this.set(e,0,i,0,0,1,0,0,-i,0,e,0,0,0,0,1),this}makeRotationZ(t){let e=Math.cos(t),i=Math.sin(t);return this.set(e,-i,0,0,i,e,0,0,0,0,1,0,0,0,0,1),this}makeRotationAxis(t,e){let i=Math.cos(e),r=Math.sin(e),o=1-i,s=t.x,a=t.y,l=t.z,c=o*s,d=o*a;return this.set(c*s+i,c*a-r*l,c*l+r*a,0,c*a+r*l,d*a+i,d*l-r*s,0,c*l-r*a,d*l+r*s,o*l*l+i,0,0,0,0,1),this}makeScale(t,e,i){return this.set(t,0,0,0,0,e,0,0,0,0,i,0,0,0,0,1),this}makeShear(t,e,i,r,o,s){return this.set(1,i,o,0,t,1,s,0,e,r,1,0,0,0,0,1),this}compose(t,e,i){let r=this.elements,o=e._x,s=e._y,a=e._z,l=e._w,c=o+o,d=s+s,u=a+a,p=o*c,f=o*d,m=o*u,b=s*d,M=s*u,y=a*u,x=l*c,R=l*d,A=l*u,V=i.x,te=i.y,K=i.z;return r[0]=(1-(b+y))*V,r[1]=(f+A)*V,r[2]=(m-R)*V,r[3]=0,r[4]=(f-A)*te,r[5]=(1-(p+y))*te,r[6]=(M+x)*te,r[7]=0,r[8]=(m+R)*K,r[9]=(M-x)*K,r[10]=(1-(p+b))*K,r[11]=0,r[12]=t.x,r[13]=t.y,r[14]=t.z,r[15]=1,this}decompose(t,e,i){let r=this.elements,o=M0.set(r[0],r[1],r[2]).length(),s=M0.set(r[4],r[5],r[6]).length(),a=M0.set(r[8],r[9],r[10]).length();this.determinant()<0&&(o=-o),t.x=r[12],t.y=r[13],t.z=r[14],Ql.copy(this);let c=1/o,d=1/s,u=1/a;return Ql.elements[0]*=c,Ql.elements[1]*=c,Ql.elements[2]*=c,Ql.elements[4]*=d,Ql.elements[5]*=d,Ql.elements[6]*=d,Ql.elements[8]*=u,Ql.elements[9]*=u,Ql.elements[10]*=u,e.setFromRotationMatrix(Ql),i.x=o,i.y=s,i.z=a,this}makePerspective(t,e,i,r,o,s){void 0===s&&console.warn("THREE.Matrix4: .makePerspective() has been redefined and has a new signature. Please check the docs.");let a=this.elements,c=2*o/(i-r),d=(e+t)/(e-t),u=(i+r)/(i-r),p=-(s+o)/(s-o),f=-2*s*o/(s-o);return a[0]=2*o/(e-t),a[4]=0,a[8]=d,a[12]=0,a[1]=0,a[5]=c,a[9]=u,a[13]=0,a[2]=0,a[6]=0,a[10]=p,a[14]=f,a[3]=0,a[7]=0,a[11]=-1,a[15]=0,this}makeOrthographic(t,e,i,r,o,s){let a=this.elements,l=1/(e-t),c=1/(i-r),d=1/(s-o),u=(e+t)*l,p=(i+r)*c,f=(s+o)*d;return a[0]=2*l,a[4]=0,a[8]=0,a[12]=-u,a[1]=0,a[5]=2*c,a[9]=0,a[13]=-p,a[2]=0,a[6]=0,a[10]=-2*d,a[14]=-f,a[3]=0,a[7]=0,a[11]=0,a[15]=1,this}equals(t){let e=this.elements,i=t.elements;for(let r=0;r<16;r++)if(e[r]!==i[r])return!1;return!0}fromArray(t,e=0){for(let i=0;i<16;i++)this.elements[i]=t[i+e];return this}toArray(t=[],e=0){let i=this.elements;return t[e]=i[0],t[e+1]=i[1],t[e+2]=i[2],t[e+3]=i[3],t[e+4]=i[4],t[e+5]=i[5],t[e+6]=i[6],t[e+7]=i[7],t[e+8]=i[8],t[e+9]=i[9],t[e+10]=i[10],t[e+11]=i[11],t[e+12]=i[12],t[e+13]=i[13],t[e+14]=i[14],t[e+15]=i[15],t}};xn.prototype.isMatrix4=!0;var M0=new $,Ql=new xn,SRe=new $(0,0,0),ERe=new $(1,1,1),ap=new $,GD=new $,ba=new $,z$=new xn,U$=new ts,yp=class{constructor(t=0,e=0,i=0,r=yp.DefaultOrder){this._x=t,this._y=e,this._z=i,this._order=r}get x(){return this._x}set x(t){this._x=t,this._onChangeCallback()}get y(){return this._y}set y(t){this._y=t,this._onChangeCallback()}get z(){return this._z}set z(t){this._z=t,this._onChangeCallback()}get order(){return this._order}set order(t){this._order=t,this._onChangeCallback()}set(t,e,i,r=this._order){return this._x=t,this._y=e,this._z=i,this._order=r,this._onChangeCallback(),this}clone(){return new this.constructor(this._x,this._y,this._z,this._order)}copy(t){return this._x=t._x,this._y=t._y,this._z=t._z,this._order=t._order,this._onChangeCallback(),this}setFromRotationMatrix(t,e=this._order,i=!0){let r=t.elements,o=r[0],s=r[4],a=r[8],l=r[1],c=r[5],d=r[9],u=r[2],p=r[6],f=r[10];switch(e){case"XYZ":this._y=Math.asin(Ks(a,-1,1)),Math.abs(a)<.9999999?(this._x=Math.atan2(-d,f),this._z=Math.atan2(-s,o)):(this._x=Math.atan2(p,c),this._z=0);break;case"YXZ":this._x=Math.asin(-Ks(d,-1,1)),Math.abs(d)<.9999999?(this._y=Math.atan2(a,f),this._z=Math.atan2(l,c)):(this._y=Math.atan2(-u,o),this._z=0);break;case"ZXY":this._x=Math.asin(Ks(p,-1,1)),Math.abs(p)<.9999999?(this._y=Math.atan2(-u,f),this._z=Math.atan2(-s,c)):(this._y=0,this._z=Math.atan2(l,o));break;case"ZYX":this._y=Math.asin(-Ks(u,-1,1)),Math.abs(u)<.9999999?(this._x=Math.atan2(p,f),this._z=Math.atan2(l,o)):(this._x=0,this._z=Math.atan2(-s,c));break;case"YZX":this._z=Math.asin(Ks(l,-1,1)),Math.abs(l)<.9999999?(this._x=Math.atan2(-d,c),this._y=Math.atan2(-u,o)):(this._x=0,this._y=Math.atan2(a,f));break;case"XZY":this._z=Math.asin(-Ks(s,-1,1)),Math.abs(s)<.9999999?(this._x=Math.atan2(p,c),this._y=Math.atan2(a,o)):(this._x=Math.atan2(-d,f),this._y=0);break;default:console.warn("THREE.Euler: .setFromRotationMatrix() encountered an unknown order: "+e)}return this._order=e,!0===i&&this._onChangeCallback(),this}setFromQuaternion(t,e,i){return z$.makeRotationFromQuaternion(t),this.setFromRotationMatrix(z$,e,i)}setFromVector3(t,e=this._order){return this.set(t.x,t.y,t.z,e)}reorder(t){return U$.setFromEuler(this),this.setFromQuaternion(U$,t)}equals(t){return t._x===this._x&&t._y===this._y&&t._z===this._z&&t._order===this._order}fromArray(t){return this._x=t[0],this._y=t[1],this._z=t[2],void 0!==t[3]&&(this._order=t[3]),this._onChangeCallback(),this}toArray(t=[],e=0){return t[e]=this._x,t[e+1]=this._y,t[e+2]=this._z,t[e+3]=this._order,t}toVector3(t){return t?t.set(this._x,this._y,this._z):new $(this._x,this._y,this._z)}_onChange(t){return this._onChangeCallback=t,this}_onChangeCallback(){}};yp.prototype.isEuler=!0,yp.DefaultOrder="XYZ",yp.RotationOrders=["XYZ","YZX","ZXY","XZY","YXZ","ZYX"];var CI=class{constructor(){this.mask=1}set(t){this.mask=(1<<t|0)>>>0}enable(t){this.mask|=1<<t|0}enableAll(){this.mask=-1}toggle(t){this.mask^=1<<t|0}disable(t){this.mask&=~(1<<t|0)}disableAll(){this.mask=0}test(t){return 0!=(this.mask&t.mask)}isEnabled(t){return 0!=(this.mask&(1<<t|0))}},TRe=0,j$=new $,w0=new ts,Bd=new xn,WD=new $,sx=new $,DRe=new $,IRe=new ts,G$=new $(1,0,0),W$=new $(0,1,0),q$=new $(0,0,1),ARe={type:"added"},Y$={type:"removed"},Bi=class extends Ud{constructor(){super(),Object.defineProperty(this,"id",{value:TRe++}),this.uuid=Jl(),this.name="",this.type="Object3D",this.parent=null,this.children=[],this.up=Bi.DefaultUp.clone();let t=new $,e=new yp,i=new ts,r=new $(1,1,1);e._onChange(function(){i.setFromEuler(e,!1)}),i._onChange(function(){e.setFromQuaternion(i,void 0,!1)}),Object.defineProperties(this,{position:{configurable:!0,enumerable:!0,value:t},rotation:{configurable:!0,enumerable:!0,value:e},quaternion:{configurable:!0,enumerable:!0,value:i},scale:{configurable:!0,enumerable:!0,value:r},modelViewMatrix:{value:new xn},normalMatrix:{value:new bo}}),this.matrix=new xn,this.matrixWorld=new xn,this.matrixAutoUpdate=Bi.DefaultMatrixAutoUpdate,this.matrixWorldNeedsUpdate=!1,this.layers=new CI,this.visible=!0,this.castShadow=!1,this.receiveShadow=!1,this.frustumCulled=!0,this.renderOrder=0,this.animations=[],this.userData={}}onBeforeRender(){}onAfterRender(){}applyMatrix4(t){this.matrixAutoUpdate&&this.updateMatrix(),this.matrix.premultiply(t),this.matrix.decompose(this.position,this.quaternion,this.scale)}applyQuaternion(t){return this.quaternion.premultiply(t),this}setRotationFromAxisAngle(t,e){this.quaternion.setFromAxisAngle(t,e)}setRotationFromEuler(t){this.quaternion.setFromEuler(t,!0)}setRotationFromMatrix(t){this.quaternion.setFromRotationMatrix(t)}setRotationFromQuaternion(t){this.quaternion.copy(t)}rotateOnAxis(t,e){return w0.setFromAxisAngle(t,e),this.quaternion.multiply(w0),this}rotateOnWorldAxis(t,e){return w0.setFromAxisAngle(t,e),this.quaternion.premultiply(w0),this}rotateX(t){return this.rotateOnAxis(G$,t)}rotateY(t){return this.rotateOnAxis(W$,t)}rotateZ(t){return this.rotateOnAxis(q$,t)}translateOnAxis(t,e){return j$.copy(t).applyQuaternion(this.quaternion),this.position.add(j$.multiplyScalar(e)),this}translateX(t){return this.translateOnAxis(G$,t)}translateY(t){return this.translateOnAxis(W$,t)}translateZ(t){return this.translateOnAxis(q$,t)}localToWorld(t){return t.applyMatrix4(this.matrixWorld)}worldToLocal(t){return t.applyMatrix4(Bd.copy(this.matrixWorld).invert())}lookAt(t,e,i){t.isVector3?WD.copy(t):WD.set(t,e,i);let r=this.parent;this.updateWorldMatrix(!0,!1),sx.setFromMatrixPosition(this.matrixWorld),this.isCamera||this.isLight?Bd.lookAt(sx,WD,this.up):Bd.lookAt(WD,sx,this.up),this.quaternion.setFromRotationMatrix(Bd),r&&(Bd.extractRotation(r.matrixWorld),w0.setFromRotationMatrix(Bd),this.quaternion.premultiply(w0.invert()))}add(t){if(arguments.length>1){for(let e=0;e<arguments.length;e++)this.add(arguments[e]);return this}return t===this?(console.error("THREE.Object3D.add: object can't be added as a child of itself.",t),this):(t&&t.isObject3D?(null!==t.parent&&t.parent.remove(t),t.parent=this,this.children.push(t),t.dispatchEvent(ARe)):console.error("THREE.Object3D.add: object not an instance of THREE.Object3D.",t),this)}remove(t){if(arguments.length>1){for(let i=0;i<arguments.length;i++)this.remove(arguments[i]);return this}let e=this.children.indexOf(t);return-1!==e&&(t.parent=null,this.children.splice(e,1),t.dispatchEvent(Y$)),this}removeFromParent(){let t=this.parent;return null!==t&&t.remove(this),this}clear(){for(let t=0;t<this.children.length;t++){let e=this.children[t];e.parent=null,e.dispatchEvent(Y$)}return this.children.length=0,this}attach(t){return this.updateWorldMatrix(!0,!1),Bd.copy(this.matrixWorld).invert(),null!==t.parent&&(t.parent.updateWorldMatrix(!0,!1),Bd.multiply(t.parent.matrixWorld)),t.applyMatrix4(Bd),this.add(t),t.updateWorldMatrix(!1,!0),this}getObjectById(t){return this.getObjectByProperty("id",t)}getObjectByName(t){return this.getObjectByProperty("name",t)}getObjectByProperty(t,e){if(this[t]===e)return this;for(let i=0,r=this.children.length;i<r;i++){let s=this.children[i].getObjectByProperty(t,e);if(void 0!==s)return s}}getWorldPosition(t){return this.updateWorldMatrix(!0,!1),t.setFromMatrixPosition(this.matrixWorld)}getWorldQuaternion(t){return this.updateWorldMatrix(!0,!1),this.matrixWorld.decompose(sx,t,DRe),t}getWorldScale(t){return this.updateWorldMatrix(!0,!1),this.matrixWorld.decompose(sx,IRe,t),t}getWorldDirection(t){this.updateWorldMatrix(!0,!1);let e=this.matrixWorld.elements;return t.set(e[8],e[9],e[10]).normalize()}raycast(){}traverse(t){t(this);let e=this.children;for(let i=0,r=e.length;i<r;i++)e[i].traverse(t)}traverseVisible(t){if(!1===this.visible)return;t(this);let e=this.children;for(let i=0,r=e.length;i<r;i++)e[i].traverseVisible(t)}traverseAncestors(t){let e=this.parent;null!==e&&(t(e),e.traverseAncestors(t))}updateMatrix(){this.matrix.compose(this.position,this.quaternion,this.scale),this.matrixWorldNeedsUpdate=!0}updateMatrixWorld(t){this.matrixAutoUpdate&&this.updateMatrix(),(this.matrixWorldNeedsUpdate||t)&&(null===this.parent?this.matrixWorld.copy(this.matrix):this.matrixWorld.multiplyMatrices(this.parent.matrixWorld,this.matrix),this.matrixWorldNeedsUpdate=!1,t=!0);let e=this.children;for(let i=0,r=e.length;i<r;i++)e[i].updateMatrixWorld(t)}updateWorldMatrix(t,e){let i=this.parent;if(!0===t&&null!==i&&i.updateWorldMatrix(!0,!1),this.matrixAutoUpdate&&this.updateMatrix(),null===this.parent?this.matrixWorld.copy(this.matrix):this.matrixWorld.multiplyMatrices(this.parent.matrixWorld,this.matrix),!0===e){let r=this.children;for(let o=0,s=r.length;o<s;o++)r[o].updateWorldMatrix(!1,!0)}}toJSON(t){let e=void 0===t||"string"==typeof t,i={};e&&(t={geometries:{},materials:{},textures:{},images:{},shapes:{},skeletons:{},animations:{}},i.metadata={version:4.5,type:"Object",generator:"Object3D.toJSON"});let r={};function o(a,l){return void 0===a[l.uuid]&&(a[l.uuid]=l.toJSON(t)),l.uuid}if(r.uuid=this.uuid,r.type=this.type,""!==this.name&&(r.name=this.name),!0===this.castShadow&&(r.castShadow=!0),!0===this.receiveShadow&&(r.receiveShadow=!0),!1===this.visible&&(r.visible=!1),!1===this.frustumCulled&&(r.frustumCulled=!1),0!==this.renderOrder&&(r.renderOrder=this.renderOrder),"{}"!==JSON.stringify(this.userData)&&(r.userData=this.userData),r.layers=this.layers.mask,r.matrix=this.matrix.toArray(),!1===this.matrixAutoUpdate&&(r.matrixAutoUpdate=!1),this.isInstancedMesh&&(r.type="InstancedMesh",r.count=this.count,r.instanceMatrix=this.instanceMatrix.toJSON(),null!==this.instanceColor&&(r.instanceColor=this.instanceColor.toJSON())),this.isScene)this.background&&(this.background.isColor?r.background=this.background.toJSON():this.background.isTexture&&(r.background=this.background.toJSON(t).uuid)),this.environment&&this.environment.isTexture&&(r.environment=this.environment.toJSON(t).uuid);else if(this.isMesh||this.isLine||this.isPoints){r.geometry=o(t.geometries,this.geometry);let a=this.geometry.parameters;if(void 0!==a&&void 0!==a.shapes){let l=a.shapes;if(Array.isArray(l))for(let c=0,d=l.length;c<d;c++)o(t.shapes,l[c]);else o(t.shapes,l)}}if(this.isSkinnedMesh&&(r.bindMode=this.bindMode,r.bindMatrix=this.bindMatrix.toArray(),void 0!==this.skeleton&&(o(t.skeletons,this.skeleton),r.skeleton=this.skeleton.uuid)),void 0!==this.material)if(Array.isArray(this.material)){let a=[];for(let l=0,c=this.material.length;l<c;l++)a.push(o(t.materials,this.material[l]));r.material=a}else r.material=o(t.materials,this.material);if(this.children.length>0){r.children=[];for(let a=0;a<this.children.length;a++)r.children.push(this.children[a].toJSON(t).object)}if(this.animations.length>0){r.animations=[];for(let a=0;a<this.animations.length;a++)r.animations.push(o(t.animations,this.animations[a]))}if(e){let a=s(t.geometries),l=s(t.materials),c=s(t.textures),d=s(t.images),u=s(t.shapes),p=s(t.skeletons),f=s(t.animations);a.length>0&&(i.geometries=a),l.length>0&&(i.materials=l),c.length>0&&(i.textures=c),d.length>0&&(i.images=d),u.length>0&&(i.shapes=u),p.length>0&&(i.skeletons=p),f.length>0&&(i.animations=f)}return i.object=r,i;function s(a){let l=[];for(let c in a){let d=a[c];delete d.metadata,l.push(d)}return l}}clone(t){return(new this.constructor).copy(this,t)}copy(t,e=!0){if(this.name=t.name,this.up.copy(t.up),this.position.copy(t.position),this.rotation.order=t.rotation.order,this.quaternion.copy(t.quaternion),this.scale.copy(t.scale),this.matrix.copy(t.matrix),this.matrixWorld.copy(t.matrixWorld),this.matrixAutoUpdate=t.matrixAutoUpdate,this.matrixWorldNeedsUpdate=t.matrixWorldNeedsUpdate,this.layers.mask=t.layers.mask,this.visible=t.visible,this.castShadow=t.castShadow,this.receiveShadow=t.receiveShadow,this.frustumCulled=t.frustumCulled,this.renderOrder=t.renderOrder,this.userData=JSON.parse(JSON.stringify(t.userData)),!0===e)for(let i=0;i<t.children.length;i++)this.add(t.children[i].clone());return this}};Bi.DefaultUp=new $(0,1,0),Bi.DefaultMatrixAutoUpdate=!0,Bi.prototype.isObject3D=!0;var Zl=new $,Vd=new $,I3=new $,Hd=new $,S0=new $,E0=new $,X$=new $,A3=new $,R3=new $,P3=new $,Vr=class{constructor(t=new $,e=new $,i=new $){this.a=t,this.b=e,this.c=i}static getNormal(t,e,i,r){r.subVectors(i,e),Zl.subVectors(t,e),r.cross(Zl);let o=r.lengthSq();return o>0?r.multiplyScalar(1/Math.sqrt(o)):r.set(0,0,0)}static getBarycoord(t,e,i,r,o){Zl.subVectors(r,e),Vd.subVectors(i,e),I3.subVectors(t,e);let s=Zl.dot(Zl),a=Zl.dot(Vd),l=Zl.dot(I3),c=Vd.dot(Vd),d=Vd.dot(I3),u=s*c-a*a;if(0===u)return o.set(-2,-1,-1);let p=1/u,f=(c*l-a*d)*p,m=(s*d-a*l)*p;return o.set(1-f-m,m,f)}static containsPoint(t,e,i,r){return this.getBarycoord(t,e,i,r,Hd),Hd.x>=0&&Hd.y>=0&&Hd.x+Hd.y<=1}static getUV(t,e,i,r,o,s,a,l){return this.getBarycoord(t,e,i,r,Hd),l.set(0,0),l.addScaledVector(o,Hd.x),l.addScaledVector(s,Hd.y),l.addScaledVector(a,Hd.z),l}static isFrontFacing(t,e,i,r){return Zl.subVectors(i,e),Vd.subVectors(t,e),Zl.cross(Vd).dot(r)<0}set(t,e,i){return this.a.copy(t),this.b.copy(e),this.c.copy(i),this}setFromPointsAndIndices(t,e,i,r){return this.a.copy(t[e]),this.b.copy(t[i]),this.c.copy(t[r]),this}setFromAttributeAndIndices(t,e,i,r){return this.a.fromBufferAttribute(t,e),this.b.fromBufferAttribute(t,i),this.c.fromBufferAttribute(t,r),this}clone(){return(new this.constructor).copy(this)}copy(t){return this.a.copy(t.a),this.b.copy(t.b),this.c.copy(t.c),this}getArea(){return Zl.subVectors(this.c,this.b),Vd.subVectors(this.a,this.b),.5*Zl.cross(Vd).length()}getMidpoint(t){return t.addVectors(this.a,this.b).add(this.c).multiplyScalar(1/3)}getNormal(t){return Vr.getNormal(this.a,this.b,this.c,t)}getPlane(t){return t.setFromCoplanarPoints(this.a,this.b,this.c)}getBarycoord(t,e){return Vr.getBarycoord(t,this.a,this.b,this.c,e)}getUV(t,e,i,r,o){return Vr.getUV(t,this.a,this.b,this.c,e,i,r,o)}containsPoint(t){return Vr.containsPoint(t,this.a,this.b,this.c)}isFrontFacing(t){return Vr.isFrontFacing(this.a,this.b,this.c,t)}intersectsBox(t){return t.intersectsTriangle(this)}closestPointToPoint(t,e){let s,a,i=this.a,r=this.b,o=this.c;S0.subVectors(r,i),E0.subVectors(o,i),A3.subVectors(t,i);let l=S0.dot(A3),c=E0.dot(A3);if(l<=0&&c<=0)return e.copy(i);R3.subVectors(t,r);let d=S0.dot(R3),u=E0.dot(R3);if(d>=0&&u<=d)return e.copy(r);let p=l*u-d*c;if(p<=0&&l>=0&&d<=0)return s=l/(l-d),e.copy(i).addScaledVector(S0,s);P3.subVectors(t,o);let f=S0.dot(P3),m=E0.dot(P3);if(m>=0&&f<=m)return e.copy(o);let b=f*c-l*m;if(b<=0&&c>=0&&m<=0)return a=c/(c-m),e.copy(i).addScaledVector(E0,a);let M=d*m-f*u;if(M<=0&&u-d>=0&&f-m>=0)return X$.subVectors(o,r),a=(u-d)/(u-d+(f-m)),e.copy(r).addScaledVector(X$,a);let y=1/(M+b+p);return s=b*y,a=p*y,e.copy(i).addScaledVector(S0,s).addScaledVector(E0,a)}equals(t){return t.a.equals(this.a)&&t.b.equals(this.b)&&t.c.equals(this.c)}},RRe=0,Ao=class extends Ud{constructor(){super(),Object.defineProperty(this,"id",{value:RRe++}),this.uuid=Jl(),this.name="",this.type="Material",this.fog=!0,this.blending=gx,this.side=yx,this.vertexColors=!1,this.opacity=1,this.transparent=!1,this.blendSrc=Wee,this.blendDst=qee,this.blendEquation=B0,this.blendSrcAlpha=null,this.blendDstAlpha=null,this.blendEquationAlpha=null,this.depthFunc=Z3,this.depthTest=!0,this.depthWrite=!0,this.stencilWriteMask=255,this.stencilFunc=519,this.stencilRef=0,this.stencilFuncMask=255,this.stencilFail=7680,this.stencilZFail=7680,this.stencilZPass=7680,this.stencilWrite=!1,this.clippingPlanes=null,this.clipIntersection=!1,this.clipShadows=!1,this.shadowSide=null,this.colorWrite=!0,this.alphaWrite=!0,this.precision=null,this.polygonOffset=!1,this.polygonOffsetFactor=0,this.polygonOffsetUnits=0,this.dithering=!1,this.alphaToCoverage=!1,this.premultipliedAlpha=!1,this.visible=!0,this.toneMapped=!0,this.userData={},this.version=0,this._alphaTest=0}get alphaTest(){return this._alphaTest}set alphaTest(t){this._alphaTest>0!=t>0&&this.version++,this._alphaTest=t}onBuild(){}onBeforeRender(){}onBeforeCompile(){}customProgramCacheKey(){return this.onBeforeCompile.toString()}setValues(t){if(void 0!==t)for(let e in t){let i=t[e];if(void 0===i){console.warn("THREE.Material: '"+e+"' parameter is undefined.");continue}if("shading"===e){console.warn("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead."),this.flatShading=1===i;continue}let r=this[e];void 0!==r?r&&r.isColor?r.set(i):r&&r.isVector3&&i&&i.isVector3?r.copy(i):this[e]=i:console.warn("THREE."+this.type+": '"+e+"' is not a property of this material.")}}toJSON(t){let e=void 0===t||"string"==typeof t;e&&(t={textures:{},images:{}});let i={metadata:{version:4.5,type:"Material",generator:"Material.toJSON"}};function r(o){let s=[];for(let a in o){let l=o[a];delete l.metadata,s.push(l)}return s}if(i.uuid=this.uuid,i.type=this.type,""!==this.name&&(i.name=this.name),this.color&&this.color.isColor&&(i.color=this.color.getHex()),void 0!==this.roughness&&(i.roughness=this.roughness),void 0!==this.metalness&&(i.metalness=this.metalness),void 0!==this.sheen&&(i.sheen=this.sheen),this.sheenColor&&this.sheenColor.isColor&&(i.sheenColor=this.sheenColor.getHex()),void 0!==this.sheenRoughness&&(i.sheenRoughness=this.sheenRoughness),this.emissive&&this.emissive.isColor&&(i.emissive=this.emissive.getHex()),this.emissiveIntensity&&1!==this.emissiveIntensity&&(i.emissiveIntensity=this.emissiveIntensity),this.specular&&this.specular.isColor&&(i.specular=this.specular.getHex()),void 0!==this.specularIntensity&&(i.specularIntensity=this.specularIntensity),this.specularColor&&this.specularColor.isColor&&(i.specularColor=this.specularColor.getHex()),void 0!==this.shininess&&(i.shininess=this.shininess),void 0!==this.clearcoat&&(i.clearcoat=this.clearcoat),void 0!==this.clearcoatRoughness&&(i.clearcoatRoughness=this.clearcoatRoughness),this.clearcoatMap&&this.clearcoatMap.isTexture&&(i.clearcoatMap=this.clearcoatMap.toJSON(t).uuid),this.clearcoatRoughnessMap&&this.clearcoatRoughnessMap.isTexture&&(i.clearcoatRoughnessMap=this.clearcoatRoughnessMap.toJSON(t).uuid),this.clearcoatNormalMap&&this.clearcoatNormalMap.isTexture&&(i.clearcoatNormalMap=this.clearcoatNormalMap.toJSON(t).uuid,i.clearcoatNormalScale=this.clearcoatNormalScale.toArray()),this.map&&this.map.isTexture&&(i.map=this.map.toJSON(t).uuid),this.matcap&&this.matcap.isTexture&&(i.matcap=this.matcap.toJSON(t).uuid),this.alphaMap&&this.alphaMap.isTexture&&(i.alphaMap=this.alphaMap.toJSON(t).uuid),this.lightMap&&this.lightMap.isTexture&&(i.lightMap=this.lightMap.toJSON(t).uuid,i.lightMapIntensity=this.lightMapIntensity),this.aoMap&&this.aoMap.isTexture&&(i.aoMap=this.aoMap.toJSON(t).uuid,i.aoMapIntensity=this.aoMapIntensity),this.bumpMap&&this.bumpMap.isTexture&&(i.bumpMap=this.bumpMap.toJSON(t).uuid,i.bumpScale=this.bumpScale),this.normalMap&&this.normalMap.isTexture&&(i.normalMap=this.normalMap.toJSON(t).uuid,i.normalMapType=this.normalMapType,i.normalScale=this.normalScale.toArray()),this.displacementMap&&this.displacementMap.isTexture&&(i.displacementMap=this.displacementMap.toJSON(t).uuid,i.displacementScale=this.displacementScale,i.displacementBias=this.displacementBias),this.roughnessMap&&this.roughnessMap.isTexture&&(i.roughnessMap=this.roughnessMap.toJSON(t).uuid),this.metalnessMap&&this.metalnessMap.isTexture&&(i.metalnessMap=this.metalnessMap.toJSON(t).uuid),this.emissiveMap&&this.emissiveMap.isTexture&&(i.emissiveMap=this.emissiveMap.toJSON(t).uuid),this.specularMap&&this.specularMap.isTexture&&(i.specularMap=this.specularMap.toJSON(t).uuid),this.specularIntensityMap&&this.specularIntensityMap.isTexture&&(i.specularIntensityMap=this.specularIntensityMap.toJSON(t).uuid),this.specularColorMap&&this.specularColorMap.isTexture&&(i.specularColorMap=this.specularColorMap.toJSON(t).uuid),this.envMap&&this.envMap.isTexture&&(i.envMap=this.envMap.toJSON(t).uuid,void 0!==this.combine&&(i.combine=this.combine)),void 0!==this.envMapIntensity&&(i.envMapIntensity=this.envMapIntensity),void 0!==this.reflectivity&&(i.reflectivity=this.reflectivity),void 0!==this.refractionRatio&&(i.refractionRatio=this.refractionRatio),this.gradientMap&&this.gradientMap.isTexture&&(i.gradientMap=this.gradientMap.toJSON(t).uuid),void 0!==this.transmission&&(i.transmission=this.transmission),this.transmissionMap&&this.transmissionMap.isTexture&&(i.transmissionMap=this.transmissionMap.toJSON(t).uuid),void 0!==this.thickness&&(i.thickness=this.thickness),this.thicknessMap&&this.thicknessMap.isTexture&&(i.thicknessMap=this.thicknessMap.toJSON(t).uuid),void 0!==this.attenuationDistance&&(i.attenuationDistance=this.attenuationDistance),void 0!==this.attenuationColor&&(i.attenuationColor=this.attenuationColor.getHex()),void 0!==this.size&&(i.size=this.size),null!==this.shadowSide&&(i.shadowSide=this.shadowSide),void 0!==this.sizeAttenuation&&(i.sizeAttenuation=this.sizeAttenuation),this.blending!==gx&&(i.blending=this.blending),this.side!==yx&&(i.side=this.side),this.vertexColors&&(i.vertexColors=!0),this.opacity<1&&(i.opacity=this.opacity),!0===this.transparent&&(i.transparent=this.transparent),i.depthFunc=this.depthFunc,i.depthTest=this.depthTest,i.depthWrite=this.depthWrite,i.colorWrite=this.colorWrite,i.alphaWrite=this.alphaWrite,i.stencilWrite=this.stencilWrite,i.stencilWriteMask=this.stencilWriteMask,i.stencilFunc=this.stencilFunc,i.stencilRef=this.stencilRef,i.stencilFuncMask=this.stencilFuncMask,i.stencilFail=this.stencilFail,i.stencilZFail=this.stencilZFail,i.stencilZPass=this.stencilZPass,this.rotation&&0!==this.rotation&&(i.rotation=this.rotation),!0===this.polygonOffset&&(i.polygonOffset=!0),0!==this.polygonOffsetFactor&&(i.polygonOffsetFactor=this.polygonOffsetFactor),0!==this.polygonOffsetUnits&&(i.polygonOffsetUnits=this.polygonOffsetUnits),this.linewidth&&1!==this.linewidth&&(i.linewidth=this.linewidth),void 0!==this.dashSize&&(i.dashSize=this.dashSize),void 0!==this.gapSize&&(i.gapSize=this.gapSize),void 0!==this.scale&&(i.scale=this.scale),!0===this.dithering&&(i.dithering=!0),this.alphaTest>0&&(i.alphaTest=this.alphaTest),!0===this.alphaToCoverage&&(i.alphaToCoverage=this.alphaToCoverage),!0===this.premultipliedAlpha&&(i.premultipliedAlpha=this.premultipliedAlpha),!0===this.wireframe&&(i.wireframe=this.wireframe),this.wireframeLinewidth>1&&(i.wireframeLinewidth=this.wireframeLinewidth),"round"!==this.wireframeLinecap&&(i.wireframeLinecap=this.wireframeLinecap),"round"!==this.wireframeLinejoin&&(i.wireframeLinejoin=this.wireframeLinejoin),!0===this.flatShading&&(i.flatShading=this.flatShading),!1===this.visible&&(i.visible=!1),!1===this.toneMapped&&(i.toneMapped=!1),"{}"!==JSON.stringify(this.userData)&&(i.userData=this.userData),e){let o=r(t.textures),s=r(t.images);o.length>0&&(i.textures=o),s.length>0&&(i.images=s)}return i}clone(){return(new this.constructor).copy(this)}copy(t){this.name=t.name,this.fog=t.fog,this.blending=t.blending,this.side=t.side,this.vertexColors=t.vertexColors,this.opacity=t.opacity,this.transparent=t.transparent,this.blendSrc=t.blendSrc,this.blendDst=t.blendDst,this.blendEquation=t.blendEquation,this.blendSrcAlpha=t.blendSrcAlpha,this.blendDstAlpha=t.blendDstAlpha,this.blendEquationAlpha=t.blendEquationAlpha,this.depthFunc=t.depthFunc,this.depthTest=t.depthTest,this.depthWrite=t.depthWrite,this.stencilWriteMask=t.stencilWriteMask,this.stencilFunc=t.stencilFunc,this.stencilRef=t.stencilRef,this.stencilFuncMask=t.stencilFuncMask,this.stencilFail=t.stencilFail,this.stencilZFail=t.stencilZFail,this.stencilZPass=t.stencilZPass,this.stencilWrite=t.stencilWrite;let e=t.clippingPlanes,i=null;if(null!==e){let r=e.length;i=new Array(r);for(let o=0;o!==r;++o)i[o]=e[o].clone()}return this.clippingPlanes=i,this.clipIntersection=t.clipIntersection,this.clipShadows=t.clipShadows,this.shadowSide=t.shadowSide,this.colorWrite=t.colorWrite,this.alphaWrite=t.alphaWrite,this.precision=t.precision,this.polygonOffset=t.polygonOffset,this.polygonOffsetFactor=t.polygonOffsetFactor,this.polygonOffsetUnits=t.polygonOffsetUnits,this.dithering=t.dithering,this.alphaTest=t.alphaTest,this.alphaToCoverage=t.alphaToCoverage,this.premultipliedAlpha=t.premultipliedAlpha,this.visible=t.visible,this.toneMapped=t.toneMapped,this.userData=JSON.parse(JSON.stringify(t.userData)),this}dispose(){this.dispatchEvent({type:"dispose"})}set needsUpdate(t){!0===t&&this.version++}};Ao.prototype.isMaterial=!0;var pm=class extends Ao{constructor(t){super(),this.type="MeshBasicMaterial",this.color=new an(16777215),this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.specularMap=null,this.alphaMap=null,this.envMap=null,this.combine=YI,this.reflectivity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.specularMap=t.specularMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.combine=t.combine,this.reflectivity=t.reflectivity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this}};pm.prototype.isMeshBasicMaterial=!0;var dr=new $,qD=new $e,Pr=class{constructor(t,e,i){if(Array.isArray(t))throw new TypeError("THREE.BufferAttribute: array should be a Typed Array.");this.name="",this.array=t,this.itemSize=e,this.count=void 0!==t?t.length/e:0,this.normalized=!0===i,this.usage=Cx,this.updateRange={offset:0,count:-1},this.version=0}onUploadCallback(){}set needsUpdate(t){!0===t&&this.version++}setUsage(t){return this.usage=t,this}copy(t){return this.name=t.name,this.array=new t.array.constructor(t.array),this.itemSize=t.itemSize,this.count=t.count,this.normalized=t.normalized,this.usage=t.usage,this}copyAt(t,e,i){t*=this.itemSize,i*=e.itemSize;for(let r=0,o=this.itemSize;r<o;r++)this.array[t+r]=e.array[i+r];return this}copyArray(t){return this.array.set(t),this}copyColorsArray(t){let e=this.array,i=0;for(let r=0,o=t.length;r<o;r++){let s=t[r];void 0===s&&(console.warn("THREE.BufferAttribute.copyColorsArray(): color is undefined",r),s=new an),e[i++]=s.r,e[i++]=s.g,e[i++]=s.b}return this}copyVector2sArray(t){let e=this.array,i=0;for(let r=0,o=t.length;r<o;r++){let s=t[r];void 0===s&&(console.warn("THREE.BufferAttribute.copyVector2sArray(): vector is undefined",r),s=new $e),e[i++]=s.x,e[i++]=s.y}return this}copyVector3sArray(t){let e=this.array,i=0;for(let r=0,o=t.length;r<o;r++){let s=t[r];void 0===s&&(console.warn("THREE.BufferAttribute.copyVector3sArray(): vector is undefined",r),s=new $),e[i++]=s.x,e[i++]=s.y,e[i++]=s.z}return this}copyVector4sArray(t){let e=this.array,i=0;for(let r=0,o=t.length;r<o;r++){let s=t[r];void 0===s&&(console.warn("THREE.BufferAttribute.copyVector4sArray(): vector is undefined",r),s=new Zi),e[i++]=s.x,e[i++]=s.y,e[i++]=s.z,e[i++]=s.w}return this}applyMatrix3(t){if(2===this.itemSize)for(let e=0,i=this.count;e<i;e++)qD.fromBufferAttribute(this,e),qD.applyMatrix3(t),this.setXY(e,qD.x,qD.y);else if(3===this.itemSize)for(let e=0,i=this.count;e<i;e++)dr.fromBufferAttribute(this,e),dr.applyMatrix3(t),this.setXYZ(e,dr.x,dr.y,dr.z);return this}applyMatrix4(t){for(let e=0,i=this.count;e<i;e++)dr.x=this.getX(e),dr.y=this.getY(e),dr.z=this.getZ(e),dr.applyMatrix4(t),this.setXYZ(e,dr.x,dr.y,dr.z);return this}applyNormalMatrix(t){for(let e=0,i=this.count;e<i;e++)dr.x=this.getX(e),dr.y=this.getY(e),dr.z=this.getZ(e),dr.applyNormalMatrix(t),this.setXYZ(e,dr.x,dr.y,dr.z);return this}transformDirection(t){for(let e=0,i=this.count;e<i;e++)dr.x=this.getX(e),dr.y=this.getY(e),dr.z=this.getZ(e),dr.transformDirection(t),this.setXYZ(e,dr.x,dr.y,dr.z);return this}set(t,e=0){return this.array.set(t,e),this}getX(t){return this.array[t*this.itemSize]}setX(t,e){return this.array[t*this.itemSize]=e,this}getY(t){return this.array[t*this.itemSize+1]}setY(t,e){return this.array[t*this.itemSize+1]=e,this}getZ(t){return this.array[t*this.itemSize+2]}setZ(t,e){return this.array[t*this.itemSize+2]=e,this}getW(t){return this.array[t*this.itemSize+3]}setW(t,e){return this.array[t*this.itemSize+3]=e,this}setXY(t,e,i){return this.array[0+(t*=this.itemSize)]=e,this.array[t+1]=i,this}setXYZ(t,e,i,r){return this.array[0+(t*=this.itemSize)]=e,this.array[t+1]=i,this.array[t+2]=r,this}setXYZW(t,e,i,r,o){return this.array[0+(t*=this.itemSize)]=e,this.array[t+1]=i,this.array[t+2]=r,this.array[t+3]=o,this}onUpload(t){return this.onUploadCallback=t,this}clone(){return new this.constructor(this.array,this.itemSize).copy(this)}toJSON(){let t={itemSize:this.itemSize,type:this.array.constructor.name,array:Array.prototype.slice.call(this.array),normalized:this.normalized};return""!==this.name&&(t.name=this.name),this.usage!==Cx&&(t.usage=this.usage),(0!==this.updateRange.offset||-1!==this.updateRange.count)&&(t.updateRange=this.updateRange),t}};Pr.prototype.isBufferAttribute=!0;var MI=class extends Pr{constructor(t,e,i){super(new Uint16Array(t),e,i)}},wI=class extends Pr{constructor(t,e,i){super(new Uint32Array(t),e,i)}};(class extends Pr{constructor(t,e,i){super(new Uint16Array(t),e,i)}}).prototype.isFloat16BufferAttribute=!0;var Nr=class extends Pr{constructor(t,e,i){super(new Float32Array(t),e,i)}},PRe=0,ol=new xn,O3=new Bi,T0=new $,va=new xa,ax=new xa,Io=new $,Ui=class extends Ud{constructor(){super(),Object.defineProperty(this,"id",{value:PRe++}),this.uuid=Jl(),this.name="",this.type="BufferGeometry",this.index=null,this.attributes={},this.morphAttributes={},this.morphTargetsRelative=!1,this.groups=[],this.boundingBox=null,this.boundingSphere=null,this.drawRange={start:0,count:1/0},this.userData={}}getIndex(){return this.index}setIndex(t){return this.index=Array.isArray(t)?new(Qee(t)?wI:MI)(t,1):t,this}getAttribute(t){return this.attributes[t]}setAttribute(t,e){return this.attributes[t]=e,this}deleteAttribute(t){return delete this.attributes[t],this}hasAttribute(t){return void 0!==this.attributes[t]}addGroup(t,e,i=0){this.groups.push({start:t,count:e,materialIndex:i})}clearGroups(){this.groups=[]}setDrawRange(t,e){this.drawRange.start=t,this.drawRange.count=e}applyMatrix4(t){let e=this.attributes.position;void 0!==e&&(e.applyMatrix4(t),e.needsUpdate=!0);let i=this.attributes.normal;if(void 0!==i){let o=(new bo).getNormalMatrix(t);i.applyNormalMatrix(o),i.needsUpdate=!0}let r=this.attributes.tangent;return void 0!==r&&(r.transformDirection(t),r.needsUpdate=!0),null!==this.boundingBox&&this.computeBoundingBox(),null!==this.boundingSphere&&this.computeBoundingSphere(),this}applyQuaternion(t){return ol.makeRotationFromQuaternion(t),this.applyMatrix4(ol),this}rotateX(t){return ol.makeRotationX(t),this.applyMatrix4(ol),this}rotateY(t){return ol.makeRotationY(t),this.applyMatrix4(ol),this}rotateZ(t){return ol.makeRotationZ(t),this.applyMatrix4(ol),this}translate(t,e,i){return ol.makeTranslation(t,e,i),this.applyMatrix4(ol),this}scale(t,e,i){return ol.makeScale(t,e,i),this.applyMatrix4(ol),this}lookAt(t){return O3.lookAt(t),O3.updateMatrix(),this.applyMatrix4(O3.matrix),this}center(){return this.computeBoundingBox(),this.boundingBox.getCenter(T0).negate(),this.translate(T0.x,T0.y,T0.z),this}setFromPoints(t){let e=[];for(let i=0,r=t.length;i<r;i++){let o=t[i];e.push(o.x,o.y,o.z||0)}return this.setAttribute("position",new Nr(e,3)),this}computeBoundingBox(){null===this.boundingBox&&(this.boundingBox=new xa);let t=this.attributes.position,e=this.morphAttributes.position;if(t&&t.isGLBufferAttribute)return console.error('THREE.BufferGeometry.computeBoundingBox(): GLBufferAttribute requires a manual bounding box. Alternatively set "mesh.frustumCulled" to "false".',this),void this.boundingBox.set(new $(-1/0,-1/0,-1/0),new $(1/0,1/0,1/0));if(void 0!==t){if(this.boundingBox.setFromBufferAttribute(t),e)for(let i=0,r=e.length;i<r;i++)va.setFromBufferAttribute(e[i]),this.morphTargetsRelative?(Io.addVectors(this.boundingBox.min,va.min),this.boundingBox.expandByPoint(Io),Io.addVectors(this.boundingBox.max,va.max),this.boundingBox.expandByPoint(Io)):(this.boundingBox.expandByPoint(va.min),this.boundingBox.expandByPoint(va.max))}else this.boundingBox.makeEmpty();(isNaN(this.boundingBox.min.x)||isNaN(this.boundingBox.min.y)||isNaN(this.boundingBox.min.z))&&console.error('THREE.BufferGeometry.computeBoundingBox(): Computed min/max have NaN values. The "position" attribute is likely to have NaN values.',this)}computeBoundingSphere(){null===this.boundingSphere&&(this.boundingSphere=new bp);let t=this.attributes.position,e=this.morphAttributes.position;if(t&&t.isGLBufferAttribute)return console.error('THREE.BufferGeometry.computeBoundingSphere(): GLBufferAttribute requires a manual bounding sphere. Alternatively set "mesh.frustumCulled" to "false".',this),void this.boundingSphere.set(new $,1/0);if(t){let i=this.boundingSphere.center;if(va.setFromBufferAttribute(t),e)for(let o=0,s=e.length;o<s;o++)ax.setFromBufferAttribute(e[o]),this.morphTargetsRelative?(Io.addVectors(va.min,ax.min),va.expandByPoint(Io),Io.addVectors(va.max,ax.max),va.expandByPoint(Io)):(va.expandByPoint(ax.min),va.expandByPoint(ax.max));va.getCenter(i);let r=0;for(let o=0,s=t.count;o<s;o++)Io.fromBufferAttribute(t,o),r=Math.max(r,i.distanceToSquared(Io));if(e)for(let o=0,s=e.length;o<s;o++){let a=e[o],l=this.morphTargetsRelative;for(let c=0,d=a.count;c<d;c++)Io.fromBufferAttribute(a,c),l&&(T0.fromBufferAttribute(t,c),Io.add(T0)),r=Math.max(r,i.distanceToSquared(Io))}this.boundingSphere.radius=Math.sqrt(r),isNaN(this.boundingSphere.radius)&&console.error('THREE.BufferGeometry.computeBoundingSphere(): Computed radius is NaN. The "position" attribute is likely to have NaN values.',this)}}computeTangents(){let t=this.index,e=this.attributes;if(null===t||void 0===e.position||void 0===e.normal||void 0===e.uv)return void console.error("THREE.BufferGeometry: .computeTangents() failed. Missing required attributes (index, position, normal or uv)");let i=t.array,r=e.position.array,o=e.normal.array,s=e.uv.array,a=r.length/3;void 0===e.tangent&&this.setAttribute("tangent",new Pr(new Float32Array(4*a),4));let l=e.tangent.array,c=[],d=[];for(let De=0;De<a;De++)c[De]=new $,d[De]=new $;let u=new $,p=new $,f=new $,m=new $e,b=new $e,M=new $e,y=new $,x=new $;function R(De,D,re){u.fromArray(r,3*De),p.fromArray(r,3*D),f.fromArray(r,3*re),m.fromArray(s,2*De),b.fromArray(s,2*D),M.fromArray(s,2*re),p.sub(u),f.sub(u),b.sub(m),M.sub(m);let ce=1/(b.x*M.y-M.x*b.y);!isFinite(ce)||(y.copy(p).multiplyScalar(M.y).addScaledVector(f,-b.y).multiplyScalar(ce),x.copy(f).multiplyScalar(b.x).addScaledVector(p,-M.x).multiplyScalar(ce),c[De].add(y),c[D].add(y),c[re].add(y),d[De].add(x),d[D].add(x),d[re].add(x))}let A=this.groups;0===A.length&&(A=[{start:0,count:i.length}]);for(let De=0,D=A.length;De<D;++De){let re=A[De],ce=re.start;for(let be=ce,ne=ce+re.count;be<ne;be+=3)R(i[be+0],i[be+1],i[be+2])}let V=new $,te=new $,K=new $,xe=new $;function Xe(De){K.fromArray(o,3*De),xe.copy(K);let D=c[De];V.copy(D),V.sub(K.multiplyScalar(K.dot(D))).normalize(),te.crossVectors(xe,D);let ce=te.dot(d[De])<0?-1:1;l[4*De]=V.x,l[4*De+1]=V.y,l[4*De+2]=V.z,l[4*De+3]=ce}for(let De=0,D=A.length;De<D;++De){let re=A[De],ce=re.start;for(let be=ce,ne=ce+re.count;be<ne;be+=3)Xe(i[be+0]),Xe(i[be+1]),Xe(i[be+2])}}computeVertexNormals(){let t=this.index,e=this.getAttribute("position");if(void 0!==e){let i=this.getAttribute("normal");if(void 0===i)i=new Pr(new Float32Array(3*e.count),3),this.setAttribute("normal",i);else for(let p=0,f=i.count;p<f;p++)i.setXYZ(p,0,0,0);let r=new $,o=new $,s=new $,a=new $,l=new $,c=new $,d=new $,u=new $;if(t)for(let p=0,f=t.count;p<f;p+=3){let m=t.getX(p+0),b=t.getX(p+1),M=t.getX(p+2);r.fromBufferAttribute(e,m),o.fromBufferAttribute(e,b),s.fromBufferAttribute(e,M),d.subVectors(s,o),u.subVectors(r,o),d.cross(u),a.fromBufferAttribute(i,m),l.fromBufferAttribute(i,b),c.fromBufferAttribute(i,M),a.add(d),l.add(d),c.add(d),i.setXYZ(m,a.x,a.y,a.z),i.setXYZ(b,l.x,l.y,l.z),i.setXYZ(M,c.x,c.y,c.z)}else for(let p=0,f=e.count;p<f;p+=3)r.fromBufferAttribute(e,p+0),o.fromBufferAttribute(e,p+1),s.fromBufferAttribute(e,p+2),d.subVectors(s,o),u.subVectors(r,o),d.cross(u),i.setXYZ(p+0,d.x,d.y,d.z),i.setXYZ(p+1,d.x,d.y,d.z),i.setXYZ(p+2,d.x,d.y,d.z);this.normalizeNormals(),i.needsUpdate=!0}}merge(t,e){if(!t||!t.isBufferGeometry)return void console.error("THREE.BufferGeometry.merge(): geometry not an instance of THREE.BufferGeometry.",t);void 0===e&&(e=0,console.warn("THREE.BufferGeometry.merge(): Overwriting original geometry, starting at offset=0. Use BufferGeometryUtils.mergeBufferGeometries() for lossless merge."));let i=this.attributes;for(let r in i){if(void 0===t.attributes[r])continue;let s=i[r].array,a=t.attributes[r],l=a.array,c=a.itemSize*e,d=Math.min(l.length,s.length-c);for(let u=0,p=c;u<d;u++,p++)s[p]=l[u]}return this}normalizeNormals(){let t=this.attributes.normal;for(let e=0,i=t.count;e<i;e++)Io.fromBufferAttribute(t,e),Io.normalize(),t.setXYZ(e,Io.x,Io.y,Io.z)}toNonIndexed(){function t(a,l){let c=a.array,d=a.itemSize,u=a.normalized,p=new c.constructor(l.length*d),f=0,m=0;for(let b=0,M=l.length;b<M;b++){f=a.isInterleavedBufferAttribute?l[b]*a.data.stride+a.offset:l[b]*d;for(let y=0;y<d;y++)p[m++]=c[f++]}return new Pr(p,d,u)}if(null===this.index)return console.warn("THREE.BufferGeometry.toNonIndexed(): BufferGeometry is already non-indexed."),this;let e=new Ui,i=this.index.array,r=this.attributes;for(let a in r){let c=t(r[a],i);e.setAttribute(a,c)}let o=this.morphAttributes;for(let a in o){let l=[],c=o[a];for(let d=0,u=c.length;d<u;d++){let f=t(c[d],i);l.push(f)}e.morphAttributes[a]=l}e.morphTargetsRelative=this.morphTargetsRelative;let s=this.groups;for(let a=0,l=s.length;a<l;a++){let c=s[a];e.addGroup(c.start,c.count,c.materialIndex)}return e}toJSON(){let t={metadata:{version:4.5,type:"BufferGeometry",generator:"BufferGeometry.toJSON"}};if(t.uuid=this.uuid,t.type=this.type,""!==this.name&&(t.name=this.name),Object.keys(this.userData).length>0&&(t.userData=this.userData),void 0!==this.parameters){let l=this.parameters;for(let c in l)void 0!==l[c]&&(t[c]=l[c]);return t}t.data={attributes:{}};let e=this.index;null!==e&&(t.data.index={type:e.array.constructor.name,array:Array.prototype.slice.call(e.array)});let i=this.attributes;for(let l in i)t.data.attributes[l]=i[l].toJSON(t.data);let r={},o=!1;for(let l in this.morphAttributes){let c=this.morphAttributes[l],d=[];for(let u=0,p=c.length;u<p;u++)d.push(c[u].toJSON(t.data));d.length>0&&(r[l]=d,o=!0)}o&&(t.data.morphAttributes=r,t.data.morphTargetsRelative=this.morphTargetsRelative);let s=this.groups;s.length>0&&(t.data.groups=JSON.parse(JSON.stringify(s)));let a=this.boundingSphere;return null!==a&&(t.data.boundingSphere={center:a.center.toArray(),radius:a.radius}),t}clone(){return(new this.constructor).copy(this)}copy(t){this.index=null,this.attributes={},this.morphAttributes={},this.groups=[],this.boundingBox=null,this.boundingSphere=null;let e={};this.name=t.name;let i=t.index;null!==i&&this.setIndex(i.clone(e));let r=t.attributes;for(let c in r)this.setAttribute(c,r[c].clone(e));let o=t.morphAttributes;for(let c in o){let d=[],u=o[c];for(let p=0,f=u.length;p<f;p++)d.push(u[p].clone(e));this.morphAttributes[c]=d}this.morphTargetsRelative=t.morphTargetsRelative;let s=t.groups;for(let c=0,d=s.length;c<d;c++){let u=s[c];this.addGroup(u.start,u.count,u.materialIndex)}let a=t.boundingBox;null!==a&&(this.boundingBox=a.clone());let l=t.boundingSphere;return null!==l&&(this.boundingSphere=l.clone()),this.drawRange.start=t.drawRange.start,this.drawRange.count=t.drawRange.count,this.userData=t.userData,void 0!==t.parameters&&(this.parameters=Object.assign({},t.parameters)),this}dispose(){this.dispatchEvent({type:"dispose"})}};Ui.prototype.isBufferGeometry=!0;var Q$=new xn,D0=new vp,k3=new bp,lp=new $,cp=new $,dp=new $,F3=new $,N3=new $,L3=new $,YD=new $,XD=new $,QD=new $,ZD=new $e,KD=new $e,JD=new $e,B3=new $,$D=new $,ao=class extends Bi{constructor(t=new Ui,e=new pm){super(),this.type="Mesh",this.geometry=t,this.material=e,this.updateMorphTargets()}copy(t){return super.copy(t),void 0!==t.morphTargetInfluences&&(this.morphTargetInfluences=t.morphTargetInfluences.slice()),void 0!==t.morphTargetDictionary&&(this.morphTargetDictionary=Object.assign({},t.morphTargetDictionary)),this.material=t.material,this.geometry=t.geometry,this}updateMorphTargets(){let t=this.geometry;if(t.isBufferGeometry){let e=t.morphAttributes,i=Object.keys(e);if(i.length>0){let r=e[i[0]];if(void 0!==r){this.morphTargetInfluences=[],this.morphTargetDictionary={};for(let o=0,s=r.length;o<s;o++){let a=r[o].name||String(o);this.morphTargetInfluences.push(0),this.morphTargetDictionary[a]=o}}}}else{let e=t.morphTargets;void 0!==e&&e.length>0&&console.error("THREE.Mesh.updateMorphTargets() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}}raycast(t,e){let s,i=this.geometry,r=this.material,o=this.matrixWorld;if(void 0!==r&&(null===i.boundingSphere&&i.computeBoundingSphere(),k3.copy(i.boundingSphere),k3.applyMatrix4(o),!1!==t.ray.intersectsSphere(k3))&&(Q$.copy(o).invert(),D0.copy(t.ray).applyMatrix4(Q$),null===i.boundingBox||!1!==D0.intersectsBox(i.boundingBox)))if(i.isBufferGeometry){let a=i.index,l=i.attributes.position,c=i.morphAttributes.position,d=i.morphTargetsRelative,u=i.attributes.uv,p=i.attributes.uv2,f=i.groups,m=i.drawRange;if(null!==a)if(Array.isArray(r))for(let b=0,M=f.length;b<M;b++){let y=f[b],x=r[y.materialIndex];for(let V=Math.max(y.start,m.start),te=Math.min(a.count,Math.min(y.start+y.count,m.start+m.count));V<te;V+=3){let K=a.getX(V),xe=a.getX(V+1),Xe=a.getX(V+2);s=eI(this,x,t,D0,l,c,d,u,p,K,xe,Xe),s&&(s.faceIndex=Math.floor(V/3),s.face.materialIndex=y.materialIndex,e.push(s))}}else for(let y=Math.max(0,m.start),x=Math.min(a.count,m.start+m.count);y<x;y+=3){let R=a.getX(y),A=a.getX(y+1),V=a.getX(y+2);s=eI(this,r,t,D0,l,c,d,u,p,R,A,V),s&&(s.faceIndex=Math.floor(y/3),e.push(s))}else if(void 0!==l)if(Array.isArray(r))for(let b=0,M=f.length;b<M;b++){let y=f[b],x=r[y.materialIndex];for(let V=Math.max(y.start,m.start),te=Math.min(l.count,Math.min(y.start+y.count,m.start+m.count));V<te;V+=3)s=eI(this,x,t,D0,l,c,d,u,p,V,V+1,V+2),s&&(s.faceIndex=Math.floor(V/3),s.face.materialIndex=y.materialIndex,e.push(s))}else for(let y=Math.max(0,m.start),x=Math.min(l.count,m.start+m.count);y<x;y+=3)s=eI(this,r,t,D0,l,c,d,u,p,y,y+1,y+2),s&&(s.faceIndex=Math.floor(y/3),e.push(s))}else i.isGeometry&&console.error("THREE.Mesh.raycast() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}};function eI(n,t,e,i,r,o,s,a,l,c,d,u){lp.fromBufferAttribute(r,c),cp.fromBufferAttribute(r,d),dp.fromBufferAttribute(r,u);let p=n.morphTargetInfluences;if(o&&p){YD.set(0,0,0),XD.set(0,0,0),QD.set(0,0,0);for(let m=0,b=o.length;m<b;m++){let M=p[m],y=o[m];0!==M&&(F3.fromBufferAttribute(y,c),N3.fromBufferAttribute(y,d),L3.fromBufferAttribute(y,u),s?(YD.addScaledVector(F3,M),XD.addScaledVector(N3,M),QD.addScaledVector(L3,M)):(YD.addScaledVector(F3.sub(lp),M),XD.addScaledVector(N3.sub(cp),M),QD.addScaledVector(L3.sub(dp),M)))}lp.add(YD),cp.add(XD),dp.add(QD)}n.isSkinnedMesh&&(n.boneTransform(c,lp),n.boneTransform(d,cp),n.boneTransform(u,dp));let f=function(n,t,e,i,r,o,s,a){let l;if(l=t.side===go?i.intersectTriangle(s,o,r,!0,a):i.intersectTriangle(r,o,s,t.side!==q0,a),null===l)return null;$D.copy(a),$D.applyMatrix4(n.matrixWorld);let c=e.ray.origin.distanceTo($D);return c<e.near||c>e.far?null:{distance:c,point:$D.clone(),object:n}}(n,t,e,i,lp,cp,dp,B3);if(f){a&&(ZD.fromBufferAttribute(a,c),KD.fromBufferAttribute(a,d),JD.fromBufferAttribute(a,u),f.uv=Vr.getUV(B3,lp,cp,dp,ZD,KD,JD,new $e)),l&&(ZD.fromBufferAttribute(l,c),KD.fromBufferAttribute(l,d),JD.fromBufferAttribute(l,u),f.uv2=Vr.getUV(B3,lp,cp,dp,ZD,KD,JD,new $e));let m={a:c,b:d,c:u,normal:new $,materialIndex:0};Vr.getNormal(lp,cp,dp,m.normal),f.face=m}return f}ao.prototype.isMesh=!0;var fm=class extends Ui{constructor(t=1,e=1,i=1,r=1,o=1,s=1){super(),this.type="BoxGeometry",this.parameters={width:t,height:e,depth:i,widthSegments:r,heightSegments:o,depthSegments:s};let a=this;r=Math.floor(r),o=Math.floor(o),s=Math.floor(s);let l=[],c=[],d=[],u=[],p=0,f=0;function m(b,M,y,x,R,A,V,te,K,xe,Xe){let De=A/K,D=V/xe,re=A/2,ce=V/2,fe=te/2,be=K+1,ne=xe+1,de=0,pe=0,je=new $;for(let Ce=0;Ce<ne;Ce++){let Ne=Ce*D-ce;for(let lt=0;lt<be;lt++)je[b]=(lt*De-re)*x,je[M]=Ne*R,je[y]=fe,c.push(je.x,je.y,je.z),je[b]=0,je[M]=0,je[y]=te>0?1:-1,d.push(je.x,je.y,je.z),u.push(lt/K),u.push(1-Ce/xe),de+=1}for(let Ce=0;Ce<xe;Ce++)for(let Ne=0;Ne<K;Ne++){let Mt=p+Ne+be*(Ce+1),pt=p+(Ne+1)+be*(Ce+1),Oe=p+(Ne+1)+be*Ce;l.push(p+Ne+be*Ce,Mt,Oe),l.push(Mt,pt,Oe),pe+=6}a.addGroup(f,pe,Xe),f+=pe,p+=de}m("z","y","x",-1,-1,i,e,t,s,o,0),m("z","y","x",1,-1,i,e,-t,s,o,1),m("x","z","y",1,1,t,i,e,r,s,2),m("x","z","y",1,-1,t,i,-e,r,s,3),m("x","y","z",1,-1,t,e,i,r,o,4),m("x","y","z",-1,-1,t,e,-i,r,o,5),this.setIndex(l),this.setAttribute("position",new Nr(c,3)),this.setAttribute("normal",new Nr(d,3)),this.setAttribute("uv",new Nr(u,2))}static fromJSON(t){return new fm(t.width,t.height,t.depth,t.widthSegments,t.heightSegments,t.depthSegments)}};function X0(n){let t={};for(let e in n){t[e]={};for(let i in n[e]){let r=n[e][i];t[e][i]=r&&(r.isColor||r.isMatrix3||r.isMatrix4||r.isVector2||r.isVector3||r.isVector4||r.isTexture||r.isQuaternion)?r.clone():Array.isArray(r)?r.slice():r}}return t}function Jo(n){let t={};for(let e=0;e<n.length;e++){let i=X0(n[e]);for(let r in i)t[r]=i[r]}return t}var kRe={clone:X0,merge:Jo},Gd=class extends Ao{constructor(t){super(),this.type="ShaderMaterial",this.defines={},this.uniforms={},this.vertexShader="void main() {\n\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n}",this.fragmentShader="void main() {\n\tgl_FragColor = vec4( 1.0, 0.0, 0.0, 1.0 );\n}",this.linewidth=1,this.wireframe=!1,this.wireframeLinewidth=1,this.fog=!1,this.lights=!1,this.clipping=!1,this.extensions={derivatives:!1,fragDepth:!1,drawBuffers:!1,shaderTextureLOD:!1},this.defaultAttributeValues={color:[1,1,1],uv:[0,0],uv2:[0,0]},this.index0AttributeName=void 0,this.uniformsNeedUpdate=!1,this.glslVersion=null,void 0!==t&&(void 0!==t.attributes&&console.error("THREE.ShaderMaterial: attributes should now be defined in THREE.BufferGeometry instead."),this.setValues(t))}copy(t){return super.copy(t),this.fragmentShader=t.fragmentShader,this.vertexShader=t.vertexShader,this.uniforms=X0(t.uniforms),this.defines=Object.assign({},t.defines),this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.lights=t.lights,this.clipping=t.clipping,this.extensions=Object.assign({},t.extensions),this.glslVersion=t.glslVersion,this}toJSON(t){let e=super.toJSON(t);e.glslVersion=this.glslVersion,e.uniforms={};for(let r in this.uniforms){let s=this.uniforms[r].value;e.uniforms[r]=s&&s.isTexture?{type:"t",value:s.toJSON(t).uuid}:s&&s.isColor?{type:"c",value:s.getHex()}:s&&s.isVector2?{type:"v2",value:s.toArray()}:s&&s.isVector3?{type:"v3",value:s.toArray()}:s&&s.isVector4?{type:"v4",value:s.toArray()}:s&&s.isMatrix3?{type:"m3",value:s.toArray()}:s&&s.isMatrix4?{type:"m4",value:s.toArray()}:{value:s}}Object.keys(this.defines).length>0&&(e.defines=this.defines),e.vertexShader=this.vertexShader,e.fragmentShader=this.fragmentShader;let i={};for(let r in this.extensions)!0===this.extensions[r]&&(i[r]=!0);return Object.keys(i).length>0&&(e.extensions=i),e}};Gd.prototype.isShaderMaterial=!0;var Sx=class extends Bi{constructor(){super(),this.type="Camera",this.matrixWorldInverse=new xn,this.projectionMatrix=new xn,this.projectionMatrixInverse=new xn}copy(t,e){return super.copy(t,e),this.matrixWorldInverse.copy(t.matrixWorldInverse),this.projectionMatrix.copy(t.projectionMatrix),this.projectionMatrixInverse.copy(t.projectionMatrixInverse),this}getWorldDirection(t){this.updateWorldMatrix(!0,!1);let e=this.matrixWorld.elements;return t.set(-e[8],-e[9],-e[10]).normalize()}updateMatrixWorld(t){super.updateMatrixWorld(t),this.matrixWorldInverse.copy(this.matrixWorld).invert()}updateWorldMatrix(t,e){super.updateWorldMatrix(t,e),this.matrixWorldInverse.copy(this.matrixWorld).invert()}clone(){return(new this.constructor).copy(this)}};Sx.prototype.isCamera=!0;var es=class extends Sx{constructor(t=50,e=1,i=.1,r=2e3){super(),this.type="PerspectiveCamera",this.fov=t,this.zoom=1,this.near=i,this.far=r,this.focus=10,this.aspect=e,this.view=null,this.filmGauge=35,this.filmOffset=0,this.updateProjectionMatrix()}copy(t,e){return super.copy(t,e),this.fov=t.fov,this.zoom=t.zoom,this.near=t.near,this.far=t.far,this.focus=t.focus,this.aspect=t.aspect,this.view=null===t.view?null:Object.assign({},t.view),this.filmGauge=t.filmGauge,this.filmOffset=t.filmOffset,this}setFocalLength(t){let e=.5*this.getFilmHeight()/t;this.fov=2*nB*Math.atan(e),this.updateProjectionMatrix()}getFocalLength(){let t=Math.tan(.5*_3*this.fov);return.5*this.getFilmHeight()/t}getEffectiveFOV(){return 2*nB*Math.atan(Math.tan(.5*_3*this.fov)/this.zoom)}getFilmWidth(){return this.filmGauge*Math.min(this.aspect,1)}getFilmHeight(){return this.filmGauge/Math.max(this.aspect,1)}setViewOffset(t,e,i,r,o,s){this.aspect=t/e,null===this.view&&(this.view={enabled:!0,fullWidth:1,fullHeight:1,offsetX:0,offsetY:0,width:1,height:1}),this.view.enabled=!0,this.view.fullWidth=t,this.view.fullHeight=e,this.view.offsetX=i,this.view.offsetY=r,this.view.width=o,this.view.height=s,this.updateProjectionMatrix()}clearViewOffset(){null!==this.view&&(this.view.enabled=!1),this.updateProjectionMatrix()}updateProjectionMatrix(){let t=this.near,e=t*Math.tan(.5*_3*this.fov)/this.zoom,i=2*e,r=this.aspect*i,o=-.5*r,s=this.view;if(null!==this.view&&this.view.enabled){let l=s.fullWidth,c=s.fullHeight;o+=s.offsetX*r/l,e-=s.offsetY*i/c,r*=s.width/l,i*=s.height/c}let a=this.filmOffset;0!==a&&(o+=t*a/this.getFilmWidth()),this.projectionMatrix.makePerspective(o,o+r,e,e-i,t,this.far),this.projectionMatrixInverse.copy(this.projectionMatrix).invert()}toJSON(t){let e=super.toJSON(t);return e.object.fov=this.fov,e.object.zoom=this.zoom,e.object.near=this.near,e.object.far=this.far,e.object.focus=this.focus,e.object.aspect=this.aspect,null!==this.view&&(e.object.view=Object.assign({},this.view)),e.object.filmGauge=this.filmGauge,e.object.filmOffset=this.filmOffset,e}};es.prototype.isPerspectiveCamera=!0;var Ex=class extends Bi{constructor(t,e,i){if(super(),this.type="CubeCamera",!0!==i.isWebGLCubeRenderTarget)return void console.error("THREE.CubeCamera: The constructor now expects an instance of WebGLCubeRenderTarget as third parameter.");this.renderTarget=i;let r=new es(90,1,t,e);r.layers=this.layers,r.up.set(0,-1,0),r.lookAt(new $(1,0,0)),this.add(r);let o=new es(90,1,t,e);o.layers=this.layers,o.up.set(0,-1,0),o.lookAt(new $(-1,0,0)),this.add(o);let s=new es(90,1,t,e);s.layers=this.layers,s.up.set(0,0,1),s.lookAt(new $(0,1,0)),this.add(s);let a=new es(90,1,t,e);a.layers=this.layers,a.up.set(0,0,-1),a.lookAt(new $(0,-1,0)),this.add(a);let l=new es(90,1,t,e);l.layers=this.layers,l.up.set(0,-1,0),l.lookAt(new $(0,0,1)),this.add(l);let c=new es(90,1,t,e);c.layers=this.layers,c.up.set(0,-1,0),c.lookAt(new $(0,0,-1)),this.add(c)}update(t,e){null===this.parent&&this.updateMatrixWorld();let i=this.renderTarget,[r,o,s,a,l,c]=this.children,d=t.xr.enabled,u=t.getRenderTarget();t.xr.enabled=!1;let p=i.texture.generateMipmaps;i.texture.generateMipmaps=!1,t.setRenderTarget(i,0),t.render(e,r),t.setRenderTarget(i,1),t.render(e,o),t.setRenderTarget(i,2),t.render(e,s),t.setRenderTarget(i,3),t.render(e,a),t.setRenderTarget(i,4),t.render(e,l),i.texture.generateMipmaps=p,t.setRenderTarget(i,5),t.render(e,c),t.setRenderTarget(u),t.xr.enabled=d,i.texture.needsPMREMUpdate=!0}},Q0=class extends lo{constructor(t,e,i,r,o,s,a,l,c,d){super(t=void 0!==t?t:[],e=void 0!==e?e:Wx,i,r,o,s,a,l,c,d),this.flipY=!1}get images(){return this.image}set images(t){this.image=t}};Q0.prototype.isCubeTexture=!0;var SI=class extends Js{constructor(t,e,i){Number.isInteger(e)&&(console.warn("THREE.WebGLCubeRenderTarget: constructor signature is now WebGLCubeRenderTarget( size, options )"),e=i),super(t,t,e),this.texture=new Q0(void 0,(e=e||{}).mapping,e.wrapS,e.wrapT,e.magFilter,e.minFilter,e.format,e.type,e.anisotropy,e.encoding),this.texture.isRenderTargetTexture=!0,this.texture.generateMipmaps=void 0!==e.generateMipmaps&&e.generateMipmaps,this.texture.minFilter=void 0!==e.minFilter?e.minFilter:$o}fromEquirectangularTexture(t,e){this.texture.type=e.type,this.texture.format=gs,this.texture.encoding=e.encoding,this.texture.generateMipmaps=e.generateMipmaps,this.texture.minFilter=e.minFilter,this.texture.magFilter=e.magFilter;let i_uniforms={tEquirect:{value:null}},i_vertexShader="\n\n\t\t\t\tvarying vec3 vWorldDirection;\n\n\t\t\t\tvec3 transformDirection( in vec3 dir, in mat4 matrix ) {\n\n\t\t\t\t\treturn normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );\n\n\t\t\t\t}\n\n\t\t\t\tvoid main() {\n\n\t\t\t\t\tvWorldDirection = transformDirection( position, modelMatrix );\n\n\t\t\t\t\t#include <begin_vertex>\n\t\t\t\t\t#include <project_vertex>\n\n\t\t\t\t}\n\t\t\t",i_fragmentShader="\n\n\t\t\t\tuniform sampler2D tEquirect;\n\n\t\t\t\tvarying vec3 vWorldDirection;\n\n\t\t\t\t#include <common>\n\n\t\t\t\tvoid main() {\n\n\t\t\t\t\tvec3 direction = normalize( vWorldDirection );\n\n\t\t\t\t\tvec2 sampleUV = equirectUv( direction );\n\n\t\t\t\t\tgl_FragColor = texture2D( tEquirect, sampleUV );\n\n\t\t\t\t}\n\t\t\t",r=new fm(5,5,5),o=new Gd({name:"CubemapFromEquirect",uniforms:X0(i_uniforms),vertexShader:i_vertexShader,fragmentShader:i_fragmentShader,side:go,blending:pp});o.uniforms.tEquirect.value=e;let s=new ao(r,o),a=e.minFilter;return e.minFilter===QI&&(e.minFilter=$o),new Ex(1,10,this).update(t,s),e.minFilter=a,s.geometry.dispose(),s.material.dispose(),this}clear(t,e,i,r){let o=t.getRenderTarget();for(let s=0;s<6;s++)t.setRenderTarget(this,s),t.clear(e,i,r);t.setRenderTarget(o)}};SI.prototype.isWebGLCubeRenderTarget=!0;var V3=new $,LRe=new $,BRe=new bo,Kl=class{constructor(t=new $(1,0,0),e=0){this.normal=t,this.constant=e}set(t,e){return this.normal.copy(t),this.constant=e,this}setComponents(t,e,i,r){return this.normal.set(t,e,i),this.constant=r,this}setFromNormalAndCoplanarPoint(t,e){return this.normal.copy(t),this.constant=-e.dot(this.normal),this}setFromCoplanarPoints(t,e,i){let r=V3.subVectors(i,e).cross(LRe.subVectors(t,e)).normalize();return this.setFromNormalAndCoplanarPoint(r,t),this}copy(t){return this.normal.copy(t.normal),this.constant=t.constant,this}normalize(){let t=1/this.normal.length();return this.normal.multiplyScalar(t),this.constant*=t,this}negate(){return this.constant*=-1,this.normal.negate(),this}distanceToPoint(t){return this.normal.dot(t)+this.constant}distanceToSphere(t){return this.distanceToPoint(t.center)-t.radius}projectPoint(t,e){return e.copy(this.normal).multiplyScalar(-this.distanceToPoint(t)).add(t)}intersectLine(t,e){let i=t.delta(V3),r=this.normal.dot(i);if(0===r)return 0===this.distanceToPoint(t.start)?e.copy(t.start):null;let o=-(t.start.dot(this.normal)+this.constant)/r;return o<0||o>1?null:e.copy(i).multiplyScalar(o).add(t.start)}intersectsLine(t){let e=this.distanceToPoint(t.start),i=this.distanceToPoint(t.end);return e<0&&i>0||i<0&&e>0}intersectsBox(t){return t.intersectsPlane(this)}intersectsSphere(t){return t.intersectsPlane(this)}coplanarPoint(t){return t.copy(this.normal).multiplyScalar(-this.constant)}applyMatrix4(t,e){let i=e||BRe.getNormalMatrix(t),r=this.coplanarPoint(V3).applyMatrix4(t),o=this.normal.applyMatrix3(i).normalize();return this.constant=-r.dot(o),this}translate(t){return this.constant-=t.dot(this.normal),this}equals(t){return t.normal.equals(this.normal)&&t.constant===this.constant}clone(){return(new this.constructor).copy(this)}};Kl.prototype.isPlane=!0;var R0=new bp,tI=new $,Z0=class{constructor(t=new Kl,e=new Kl,i=new Kl,r=new Kl,o=new Kl,s=new Kl){this.planes=[t,e,i,r,o,s]}set(t,e,i,r,o,s){let a=this.planes;return a[0].copy(t),a[1].copy(e),a[2].copy(i),a[3].copy(r),a[4].copy(o),a[5].copy(s),this}copy(t){let e=this.planes;for(let i=0;i<6;i++)e[i].copy(t.planes[i]);return this}setFromProjectionMatrix(t){let e=this.planes,i=t.elements,r=i[0],o=i[1],s=i[2],a=i[3],l=i[4],c=i[5],d=i[6],u=i[7],p=i[8],f=i[9],m=i[10],b=i[11],M=i[12],y=i[13],x=i[14],R=i[15];return e[0].setComponents(a-r,u-l,b-p,R-M).normalize(),e[1].setComponents(a+r,u+l,b+p,R+M).normalize(),e[2].setComponents(a+o,u+c,b+f,R+y).normalize(),e[3].setComponents(a-o,u-c,b-f,R-y).normalize(),e[4].setComponents(a-s,u-d,b-m,R-x).normalize(),e[5].setComponents(a+s,u+d,b+m,R+x).normalize(),this}intersectsObject(t){let e=t.geometry;return null===e.boundingSphere&&e.computeBoundingSphere(),R0.copy(e.boundingSphere).applyMatrix4(t.matrixWorld),this.intersectsSphere(R0)}intersectsSprite(t){return R0.center.set(0,0,0),R0.radius=.7071067811865476,R0.applyMatrix4(t.matrixWorld),this.intersectsSphere(R0)}intersectsSphere(t){let e=this.planes,i=t.center,r=-t.radius;for(let o=0;o<6;o++)if(e[o].distanceToPoint(i)<r)return!1;return!0}intersectsBox(t){let e=this.planes;for(let i=0;i<6;i++){let r=e[i];if(tI.x=r.normal.x>0?t.max.x:t.min.x,tI.y=r.normal.y>0?t.max.y:t.min.y,tI.z=r.normal.z>0?t.max.z:t.min.z,r.distanceToPoint(tI)<0)return!1}return!0}containsPoint(t){let e=this.planes;for(let i=0;i<6;i++)if(e[i].distanceToPoint(t)<0)return!1;return!0}clone(){return(new this.constructor).copy(this)}};function Zee(){let n=null,t=!1,e=null,i=null;function r(o,s){e(o,s),i=n.requestAnimationFrame(r)}return{start:function(){!0!==t&&null!==e&&(i=n.requestAnimationFrame(r),t=!0)},stop:function(){n.cancelAnimationFrame(i),t=!1},setAnimationLoop:function(o){e=o},setContext:function(o){n=o}}}function VRe(n,t){let e=t.isWebGL2,i=new WeakMap;return{get:function(c){return c.isInterleavedBufferAttribute&&(c=c.data),i.get(c)},remove:function(c){c.isInterleavedBufferAttribute&&(c=c.data);let d=i.get(c);d&&(n.deleteBuffer(d.buffer),i.delete(c))},update:function(c,d){if(c.isGLBufferAttribute){let p=i.get(c);return void((!p||p.version<c.version)&&i.set(c,{buffer:c.buffer,type:c.type,bytesPerElement:c.elementSize,version:c.version}))}c.isInterleavedBufferAttribute&&(c=c.data);let u=i.get(c);void 0===u?i.set(c,function(c,d){let u=c.array,p=c.usage,f=n.createBuffer();n.bindBuffer(d,f),n.bufferData(d,u,p),c.onUploadCallback();let m=5126;return u instanceof Float32Array?m=5126:u instanceof Float64Array?console.warn("THREE.WebGLAttributes: Unsupported data buffer format: Float64Array."):u instanceof Uint16Array?c.isFloat16BufferAttribute?e?m=5131:console.warn("THREE.WebGLAttributes: Usage of Float16BufferAttribute requires WebGL2."):m=5123:u instanceof Int16Array?m=5122:u instanceof Uint32Array?m=5125:u instanceof Int32Array?m=5124:u instanceof Int8Array?m=5120:(u instanceof Uint8Array||u instanceof Uint8ClampedArray)&&(m=5121),{buffer:f,type:m,bytesPerElement:u.BYTES_PER_ELEMENT,version:c.version}}(c,d)):u.version<c.version&&(function(c,d,u){let p=d.array,f=d.updateRange;n.bindBuffer(u,c),-1===f.count?n.bufferSubData(u,0,p):(e?n.bufferSubData(u,f.offset*p.BYTES_PER_ELEMENT,p,f.offset,f.count):n.bufferSubData(u,f.offset*p.BYTES_PER_ELEMENT,p.subarray(f.offset,f.offset+f.count)),f.count=-1)}(u.buffer,c,d),u.version=c.version)}}}var Tx=class extends Ui{constructor(t=1,e=1,i=1,r=1){super(),this.type="PlaneGeometry",this.parameters={width:t,height:e,widthSegments:i,heightSegments:r};let o=t/2,s=e/2,a=Math.floor(i),l=Math.floor(r),c=a+1,d=l+1,u=t/a,p=e/l,f=[],m=[],b=[],M=[];for(let y=0;y<d;y++){let x=y*p-s;for(let R=0;R<c;R++)m.push(R*u-o,-x,0),b.push(0,0,1),M.push(R/a),M.push(1-y/l)}for(let y=0;y<l;y++)for(let x=0;x<a;x++){let A=x+c*(y+1),V=x+1+c*(y+1),te=x+1+c*y;f.push(x+c*y,A,te),f.push(A,V,te)}this.setIndex(f),this.setAttribute("position",new Nr(m,3)),this.setAttribute("normal",new Nr(b,3)),this.setAttribute("uv",new Nr(M,2))}static fromJSON(t){return new Tx(t.width,t.height,t.widthSegments,t.heightSegments)}},bi={alphamap_fragment:"#ifdef USE_ALPHAMAP\n\tdiffuseColor.a *= texture2D( alphaMap, vUv ).g;\n#endif",alphamap_pars_fragment:"#ifdef USE_ALPHAMAP\n\tuniform sampler2D alphaMap;\n#endif",alphatest_fragment:"#ifdef USE_ALPHATEST\n\tif ( diffuseColor.a < alphaTest ) discard;\n#endif",alphatest_pars_fragment:"#ifdef USE_ALPHATEST\n\tuniform float alphaTest;\n#endif",aomap_fragment:"#ifdef USE_AOMAP\n\tfloat ambientOcclusion = ( texture2D( aoMap, vUv2 ).r - 1.0 ) * aoMapIntensity + 1.0;\n\treflectedLight.indirectDiffuse *= ambientOcclusion;\n\t#if defined( USE_ENVMAP ) && defined( STANDARD )\n\t\tfloat dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );\n\t\treflectedLight.indirectSpecular *= computeSpecularOcclusion( dotNV, ambientOcclusion, material.roughness );\n\t#endif\n#endif",aomap_pars_fragment:"#ifdef USE_AOMAP\n\tuniform sampler2D aoMap;\n\tuniform float aoMapIntensity;\n#endif",begin_vertex:"vec3 transformed = vec3( position );",beginnormal_vertex:"vec3 objectNormal = vec3( normal );\n#ifdef USE_TANGENT\n\tvec3 objectTangent = vec3( tangent.xyz );\n#endif",bsdfs:"vec3 BRDF_Lambert( const in vec3 diffuseColor ) {\n\treturn RECIPROCAL_PI * diffuseColor;\n}\nvec3 F_Schlick( const in vec3 f0, const in float f90, const in float dotVH ) {\n\tfloat fresnel = exp2( ( - 5.55473 * dotVH - 6.98316 ) * dotVH );\n\treturn f0 * ( 1.0 - fresnel ) + ( f90 * fresnel );\n}\nfloat V_GGX_SmithCorrelated( const in float alpha, const in float dotNL, const in float dotNV ) {\n\tfloat a2 = pow2( alpha );\n\tfloat gv = dotNL * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );\n\tfloat gl = dotNV * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );\n\treturn 0.5 / max( gv + gl, EPSILON );\n}\nfloat D_GGX( const in float alpha, const in float dotNH ) {\n\tfloat a2 = pow2( alpha );\n\tfloat denom = pow2( dotNH ) * ( a2 - 1.0 ) + 1.0;\n\treturn RECIPROCAL_PI * a2 / pow2( denom );\n}\nvec3 BRDF_GGX( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in vec3 f0, const in float f90, const in float roughness ) {\n\tfloat alpha = pow2( roughness );\n\tvec3 halfDir = normalize( lightDir + viewDir );\n\tfloat dotNL = saturate( dot( normal, lightDir ) );\n\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\tfloat dotNH = saturate( dot( normal, halfDir ) );\n\tfloat dotVH = saturate( dot( viewDir, halfDir ) );\n\tvec3 F = F_Schlick( f0, f90, dotVH );\n\tfloat V = V_GGX_SmithCorrelated( alpha, dotNL, dotNV );\n\tfloat D = D_GGX( alpha, dotNH );\n\treturn F * ( V * D );\n}\nvec2 LTC_Uv( const in vec3 N, const in vec3 V, const in float roughness ) {\n\tconst float LUT_SIZE = 64.0;\n\tconst float LUT_SCALE = ( LUT_SIZE - 1.0 ) / LUT_SIZE;\n\tconst float LUT_BIAS = 0.5 / LUT_SIZE;\n\tfloat dotNV = saturate( dot( N, V ) );\n\tvec2 uv = vec2( roughness, sqrt( 1.0 - dotNV ) );\n\tuv = uv * LUT_SCALE + LUT_BIAS;\n\treturn uv;\n}\nfloat LTC_ClippedSphereFormFactor( const in vec3 f ) {\n\tfloat l = length( f );\n\treturn max( ( l * l + f.z ) / ( l + 1.0 ), 0.0 );\n}\nvec3 LTC_EdgeVectorFormFactor( const in vec3 v1, const in vec3 v2 ) {\n\tfloat x = dot( v1, v2 );\n\tfloat y = abs( x );\n\tfloat a = 0.8543985 + ( 0.4965155 + 0.0145206 * y ) * y;\n\tfloat b = 3.4175940 + ( 4.1616724 + y ) * y;\n\tfloat v = a / b;\n\tfloat theta_sintheta = ( x > 0.0 ) ? v : 0.5 * inversesqrt( max( 1.0 - x * x, 1e-7 ) ) - v;\n\treturn cross( v1, v2 ) * theta_sintheta;\n}\nvec3 LTC_Evaluate( const in vec3 N, const in vec3 V, const in vec3 P, const in mat3 mInv, const in vec3 rectCoords[ 4 ] ) {\n\tvec3 v1 = rectCoords[ 1 ] - rectCoords[ 0 ];\n\tvec3 v2 = rectCoords[ 3 ] - rectCoords[ 0 ];\n\tvec3 lightNormal = cross( v1, v2 );\n\tif( dot( lightNormal, P - rectCoords[ 0 ] ) < 0.0 ) return vec3( 0.0 );\n\tvec3 T1, T2;\n\tT1 = normalize( V - N * dot( V, N ) );\n\tT2 = - cross( N, T1 );\n\tmat3 mat = mInv * transposeMat3( mat3( T1, T2, N ) );\n\tvec3 coords[ 4 ];\n\tcoords[ 0 ] = mat * ( rectCoords[ 0 ] - P );\n\tcoords[ 1 ] = mat * ( rectCoords[ 1 ] - P );\n\tcoords[ 2 ] = mat * ( rectCoords[ 2 ] - P );\n\tcoords[ 3 ] = mat * ( rectCoords[ 3 ] - P );\n\tcoords[ 0 ] = normalize( coords[ 0 ] );\n\tcoords[ 1 ] = normalize( coords[ 1 ] );\n\tcoords[ 2 ] = normalize( coords[ 2 ] );\n\tcoords[ 3 ] = normalize( coords[ 3 ] );\n\tvec3 vectorFormFactor = vec3( 0.0 );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 0 ], coords[ 1 ] );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 1 ], coords[ 2 ] );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 2 ], coords[ 3 ] );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 3 ], coords[ 0 ] );\n\tfloat result = LTC_ClippedSphereFormFactor( vectorFormFactor );\n\treturn vec3( result );\n}\nfloat G_BlinnPhong_Implicit( ) {\n\treturn 0.25;\n}\nfloat D_BlinnPhong( const in float shininess, const in float dotNH ) {\n\treturn RECIPROCAL_PI * ( shininess * 0.5 + 1.0 ) * pow( dotNH, shininess );\n}\nvec3 BRDF_BlinnPhong( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in vec3 specularColor, const in float shininess ) {\n\tvec3 halfDir = normalize( lightDir + viewDir );\n\tfloat dotNH = saturate( dot( normal, halfDir ) );\n\tfloat dotVH = saturate( dot( viewDir, halfDir ) );\n\tvec3 F = F_Schlick( specularColor, 1.0, dotVH );\n\tfloat G = G_BlinnPhong_Implicit( );\n\tfloat D = D_BlinnPhong( shininess, dotNH );\n\treturn F * ( G * D );\n}\n#if defined( USE_SHEEN )\nfloat D_Charlie( float roughness, float dotNH ) {\n\tfloat alpha = pow2( roughness );\n\tfloat invAlpha = 1.0 / alpha;\n\tfloat cos2h = dotNH * dotNH;\n\tfloat sin2h = max( 1.0 - cos2h, 0.0078125 );\n\treturn ( 2.0 + invAlpha ) * pow( sin2h, invAlpha * 0.5 ) / ( 2.0 * PI );\n}\nfloat V_Neubelt( float dotNV, float dotNL ) {\n\treturn saturate( 1.0 / ( 4.0 * ( dotNL + dotNV - dotNL * dotNV ) ) );\n}\nvec3 BRDF_Sheen( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, vec3 sheenColor, const in float sheenRoughness ) {\n\tvec3 halfDir = normalize( lightDir + viewDir );\n\tfloat dotNL = saturate( dot( normal, lightDir ) );\n\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\tfloat dotNH = saturate( dot( normal, halfDir ) );\n\tfloat D = D_Charlie( sheenRoughness, dotNH );\n\tfloat V = V_Neubelt( dotNV, dotNL );\n\treturn sheenColor * ( D * V );\n}\n#endif",bumpmap_pars_fragment:"#ifdef USE_BUMPMAP\n\tuniform sampler2D bumpMap;\n\tuniform float bumpScale;\n\tvec2 dHdxy_fwd() {\n\t\tvec2 dSTdx = dFdx( vUv );\n\t\tvec2 dSTdy = dFdy( vUv );\n\t\tfloat Hll = bumpScale * texture2D( bumpMap, vUv ).x;\n\t\tfloat dBx = bumpScale * texture2D( bumpMap, vUv + dSTdx ).x - Hll;\n\t\tfloat dBy = bumpScale * texture2D( bumpMap, vUv + dSTdy ).x - Hll;\n\t\treturn vec2( dBx, dBy );\n\t}\n\tvec3 perturbNormalArb( vec3 surf_pos, vec3 surf_norm, vec2 dHdxy, float faceDirection ) {\n\t\tvec3 vSigmaX = vec3( dFdx( surf_pos.x ), dFdx( surf_pos.y ), dFdx( surf_pos.z ) );\n\t\tvec3 vSigmaY = vec3( dFdy( surf_pos.x ), dFdy( surf_pos.y ), dFdy( surf_pos.z ) );\n\t\tvec3 vN = surf_norm;\n\t\tvec3 R1 = cross( vSigmaY, vN );\n\t\tvec3 R2 = cross( vN, vSigmaX );\n\t\tfloat fDet = dot( vSigmaX, R1 ) * faceDirection;\n\t\tvec3 vGrad = sign( fDet ) * ( dHdxy.x * R1 + dHdxy.y * R2 );\n\t\treturn normalize( abs( fDet ) * surf_norm - vGrad );\n\t}\n#endif",clipping_planes_fragment:"#if NUM_CLIPPING_PLANES > 0\n\tvec4 plane;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < UNION_CLIPPING_PLANES; i ++ ) {\n\t\tplane = clippingPlanes[ i ];\n\t\tif ( dot( vClipPosition, plane.xyz ) > plane.w ) discard;\n\t}\n\t#pragma unroll_loop_end\n\t#if UNION_CLIPPING_PLANES < NUM_CLIPPING_PLANES\n\t\tbool clipped = true;\n\t\t#pragma unroll_loop_start\n\t\tfor ( int i = UNION_CLIPPING_PLANES; i < NUM_CLIPPING_PLANES; i ++ ) {\n\t\t\tplane = clippingPlanes[ i ];\n\t\t\tclipped = ( dot( vClipPosition, plane.xyz ) > plane.w ) && clipped;\n\t\t}\n\t\t#pragma unroll_loop_end\n\t\tif ( clipped ) discard;\n\t#endif\n#endif",clipping_planes_pars_fragment:"#if NUM_CLIPPING_PLANES > 0\n\tvarying vec3 vClipPosition;\n\tuniform vec4 clippingPlanes[ NUM_CLIPPING_PLANES ];\n#endif",clipping_planes_pars_vertex:"#if NUM_CLIPPING_PLANES > 0\n\tvarying vec3 vClipPosition;\n#endif",clipping_planes_vertex:"#if NUM_CLIPPING_PLANES > 0\n\tvClipPosition = - mvPosition.xyz;\n#endif",color_fragment:"#if defined( USE_COLOR_ALPHA )\n\tdiffuseColor *= vColor;\n#elif defined( USE_COLOR )\n\tdiffuseColor.rgb *= vColor;\n#endif",color_pars_fragment:"#if defined( USE_COLOR_ALPHA )\n\tvarying vec4 vColor;\n#elif defined( USE_COLOR )\n\tvarying vec3 vColor;\n#endif",color_pars_vertex:"#if defined( USE_COLOR_ALPHA )\n\tvarying vec4 vColor;\n#elif defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR )\n\tvarying vec3 vColor;\n#endif",color_vertex:"#if defined( USE_COLOR_ALPHA )\n\tvColor = vec4( 1.0 );\n#elif defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR )\n\tvColor = vec3( 1.0 );\n#endif\n#ifdef USE_COLOR\n\tvColor *= color;\n#endif\n#ifdef USE_INSTANCING_COLOR\n\tvColor.xyz *= instanceColor.xyz;\n#endif",common:"#define PI 3.141592653589793\n#define PI2 6.283185307179586\n#define PI_HALF 1.5707963267948966\n#define RECIPROCAL_PI 0.3183098861837907\n#define RECIPROCAL_PI2 0.15915494309189535\n#define EPSILON 1e-6\n#ifndef saturate\n#define saturate( a ) clamp( a, 0.0, 1.0 )\n#endif\n#define whiteComplement( a ) ( 1.0 - saturate( a ) )\nfloat pow2( const in float x ) { return x*x; }\nfloat pow3( const in float x ) { return x*x*x; }\nfloat pow4( const in float x ) { float x2 = x*x; return x2*x2; }\nfloat max3( const in vec3 v ) { return max( max( v.x, v.y ), v.z ); }\nfloat average( const in vec3 color ) { return dot( color, vec3( 0.3333 ) ); }\nhighp float rand( const in vec2 uv ) {\n\tconst highp float a = 12.9898, b = 78.233, c = 43758.5453;\n\thighp float dt = dot( uv.xy, vec2( a,b ) ), sn = mod( dt, PI );\n\treturn fract( sin( sn ) * c );\n}\n#ifdef HIGH_PRECISION\n\tfloat precisionSafeLength( vec3 v ) { return length( v ); }\n#else\n\tfloat precisionSafeLength( vec3 v ) {\n\t\tfloat maxComponent = max3( abs( v ) );\n\t\treturn length( v / maxComponent ) * maxComponent;\n\t}\n#endif\nstruct IncidentLight {\n\tvec3 color;\n\tvec3 direction;\n\tbool visible;\n};\nstruct ReflectedLight {\n\tvec3 directDiffuse;\n\tvec3 directSpecular;\n\tvec3 indirectDiffuse;\n\tvec3 indirectSpecular;\n};\nstruct GeometricContext {\n\tvec3 position;\n\tvec3 normal;\n\tvec3 viewDir;\n#ifdef USE_CLEARCOAT\n\tvec3 clearcoatNormal;\n#endif\n};\nvec3 transformDirection( in vec3 dir, in mat4 matrix ) {\n\treturn normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );\n}\nvec3 inverseTransformDirection( in vec3 dir, in mat4 matrix ) {\n\treturn normalize( ( vec4( dir, 0.0 ) * matrix ).xyz );\n}\nmat3 transposeMat3( const in mat3 m ) {\n\tmat3 tmp;\n\ttmp[ 0 ] = vec3( m[ 0 ].x, m[ 1 ].x, m[ 2 ].x );\n\ttmp[ 1 ] = vec3( m[ 0 ].y, m[ 1 ].y, m[ 2 ].y );\n\ttmp[ 2 ] = vec3( m[ 0 ].z, m[ 1 ].z, m[ 2 ].z );\n\treturn tmp;\n}\nfloat linearToRelativeLuminance( const in vec3 color ) {\n\tvec3 weights = vec3( 0.2126, 0.7152, 0.0722 );\n\treturn dot( weights, color.rgb );\n}\nbool isPerspectiveMatrix( mat4 m ) {\n\treturn m[ 2 ][ 3 ] == - 1.0;\n}\nvec2 equirectUv( in vec3 dir ) {\n\tfloat u = atan( dir.z, dir.x ) * RECIPROCAL_PI2 + 0.5;\n\tfloat v = asin( clamp( dir.y, - 1.0, 1.0 ) ) * RECIPROCAL_PI + 0.5;\n\treturn vec2( u, v );\n}",cube_uv_reflection_fragment:"#ifdef ENVMAP_TYPE_CUBE_UV\n\t#define cubeUV_maxMipLevel 8.0\n\t#define cubeUV_minMipLevel 4.0\n\t#define cubeUV_maxTileSize 256.0\n\t#define cubeUV_minTileSize 16.0\n\tfloat getFace( vec3 direction ) {\n\t\tvec3 absDirection = abs( direction );\n\t\tfloat face = - 1.0;\n\t\tif ( absDirection.x > absDirection.z ) {\n\t\t\tif ( absDirection.x > absDirection.y )\n\t\t\t\tface = direction.x > 0.0 ? 0.0 : 3.0;\n\t\t\telse\n\t\t\t\tface = direction.y > 0.0 ? 1.0 : 4.0;\n\t\t} else {\n\t\t\tif ( absDirection.z > absDirection.y )\n\t\t\t\tface = direction.z > 0.0 ? 2.0 : 5.0;\n\t\t\telse\n\t\t\t\tface = direction.y > 0.0 ? 1.0 : 4.0;\n\t\t}\n\t\treturn face;\n\t}\n\tvec2 getUV( vec3 direction, float face ) {\n\t\tvec2 uv;\n\t\tif ( face == 0.0 ) {\n\t\t\tuv = vec2( direction.z, direction.y ) / abs( direction.x );\n\t\t} else if ( face == 1.0 ) {\n\t\t\tuv = vec2( - direction.x, - direction.z ) / abs( direction.y );\n\t\t} else if ( face == 2.0 ) {\n\t\t\tuv = vec2( - direction.x, direction.y ) / abs( direction.z );\n\t\t} else if ( face == 3.0 ) {\n\t\t\tuv = vec2( - direction.z, direction.y ) / abs( direction.x );\n\t\t} else if ( face == 4.0 ) {\n\t\t\tuv = vec2( - direction.x, direction.z ) / abs( direction.y );\n\t\t} else {\n\t\t\tuv = vec2( direction.x, direction.y ) / abs( direction.z );\n\t\t}\n\t\treturn 0.5 * ( uv + 1.0 );\n\t}\n\tvec3 bilinearCubeUV( sampler2D envMap, vec3 direction, float mipInt ) {\n\t\tfloat face = getFace( direction );\n\t\tfloat filterInt = max( cubeUV_minMipLevel - mipInt, 0.0 );\n\t\tmipInt = max( mipInt, cubeUV_minMipLevel );\n\t\tfloat faceSize = exp2( mipInt );\n\t\tfloat texelSize = 1.0 / ( 3.0 * cubeUV_maxTileSize );\n\t\tvec2 uv = getUV( direction, face ) * ( faceSize - 1.0 ) + 0.5;\n\t\tif ( face > 2.0 ) {\n\t\t\tuv.y += faceSize;\n\t\t\tface -= 3.0;\n\t\t}\n\t\tuv.x += face * faceSize;\n\t\tif ( mipInt < cubeUV_maxMipLevel ) {\n\t\t\tuv.y += 2.0 * cubeUV_maxTileSize;\n\t\t}\n\t\tuv.y += filterInt * 2.0 * cubeUV_minTileSize;\n\t\tuv.x += 3.0 * max( 0.0, cubeUV_maxTileSize - 2.0 * faceSize );\n\t\tuv *= texelSize;\n\t\treturn texture2D( envMap, uv ).rgb;\n\t}\n\t#define r0 1.0\n\t#define v0 0.339\n\t#define m0 - 2.0\n\t#define r1 0.8\n\t#define v1 0.276\n\t#define m1 - 1.0\n\t#define r4 0.4\n\t#define v4 0.046\n\t#define m4 2.0\n\t#define r5 0.305\n\t#define v5 0.016\n\t#define m5 3.0\n\t#define r6 0.21\n\t#define v6 0.0038\n\t#define m6 4.0\n\tfloat roughnessToMip( float roughness ) {\n\t\tfloat mip = 0.0;\n\t\tif ( roughness >= r1 ) {\n\t\t\tmip = ( r0 - roughness ) * ( m1 - m0 ) / ( r0 - r1 ) + m0;\n\t\t} else if ( roughness >= r4 ) {\n\t\t\tmip = ( r1 - roughness ) * ( m4 - m1 ) / ( r1 - r4 ) + m1;\n\t\t} else if ( roughness >= r5 ) {\n\t\t\tmip = ( r4 - roughness ) * ( m5 - m4 ) / ( r4 - r5 ) + m4;\n\t\t} else if ( roughness >= r6 ) {\n\t\t\tmip = ( r5 - roughness ) * ( m6 - m5 ) / ( r5 - r6 ) + m5;\n\t\t} else {\n\t\t\tmip = - 2.0 * log2( 1.16 * roughness );\t\t}\n\t\treturn mip;\n\t}\n\tvec4 textureCubeUV( sampler2D envMap, vec3 sampleDir, float roughness ) {\n\t\tfloat mip = clamp( roughnessToMip( roughness ), m0, cubeUV_maxMipLevel );\n\t\tfloat mipF = fract( mip );\n\t\tfloat mipInt = floor( mip );\n\t\tvec3 color0 = bilinearCubeUV( envMap, sampleDir, mipInt );\n\t\tif ( mipF == 0.0 ) {\n\t\t\treturn vec4( color0, 1.0 );\n\t\t} else {\n\t\t\tvec3 color1 = bilinearCubeUV( envMap, sampleDir, mipInt + 1.0 );\n\t\t\treturn vec4( mix( color0, color1, mipF ), 1.0 );\n\t\t}\n\t}\n#endif",defaultnormal_vertex:"vec3 transformedNormal = objectNormal;\n#ifdef USE_INSTANCING\n\tmat3 m = mat3( instanceMatrix );\n\ttransformedNormal /= vec3( dot( m[ 0 ], m[ 0 ] ), dot( m[ 1 ], m[ 1 ] ), dot( m[ 2 ], m[ 2 ] ) );\n\ttransformedNormal = m * transformedNormal;\n#endif\ntransformedNormal = normalMatrix * transformedNormal;\n#ifdef FLIP_SIDED\n\ttransformedNormal = - transformedNormal;\n#endif\n#ifdef USE_TANGENT\n\tvec3 transformedTangent = ( modelViewMatrix * vec4( objectTangent, 0.0 ) ).xyz;\n\t#ifdef FLIP_SIDED\n\t\ttransformedTangent = - transformedTangent;\n\t#endif\n#endif",displacementmap_pars_vertex:"#ifdef USE_DISPLACEMENTMAP\n\tuniform sampler2D displacementMap;\n\tuniform float displacementScale;\n\tuniform float displacementBias;\n#endif",displacementmap_vertex:"#ifdef USE_DISPLACEMENTMAP\n\ttransformed += normalize( objectNormal ) * ( texture2D( displacementMap, vUv ).x * displacementScale + displacementBias );\n#endif",emissivemap_fragment:"#ifdef USE_EMISSIVEMAP\n\tvec4 emissiveColor = texture2D( emissiveMap, vUv );\n\ttotalEmissiveRadiance *= emissiveColor.rgb;\n#endif",emissivemap_pars_fragment:"#ifdef USE_EMISSIVEMAP\n\tuniform sampler2D emissiveMap;\n#endif",encodings_fragment:"gl_FragColor = linearToOutputTexel( gl_FragColor );",encodings_pars_fragment:"vec4 LinearToLinear( in vec4 value ) {\n\treturn value;\n}\nvec4 LinearTosRGB( in vec4 value ) {\n\treturn vec4( mix( pow( value.rgb, vec3( 0.41666 ) ) * 1.055 - vec3( 0.055 ), value.rgb * 12.92, vec3( lessThanEqual( value.rgb, vec3( 0.0031308 ) ) ) ), value.a );\n}",envmap_fragment:"#ifdef USE_ENVMAP\n\t#ifdef ENV_WORLDPOS\n\t\tvec3 cameraToFrag;\n\t\tif ( isOrthographic ) {\n\t\t\tcameraToFrag = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );\n\t\t} else {\n\t\t\tcameraToFrag = normalize( vWorldPosition - cameraPosition );\n\t\t}\n\t\tvec3 worldNormal = inverseTransformDirection( normal, viewMatrix );\n\t\t#ifdef ENVMAP_MODE_REFLECTION\n\t\t\tvec3 reflectVec = reflect( cameraToFrag, worldNormal );\n\t\t#else\n\t\t\tvec3 reflectVec = refract( cameraToFrag, worldNormal, refractionRatio );\n\t\t#endif\n\t#else\n\t\tvec3 reflectVec = vReflect;\n\t#endif\n\t#ifdef ENVMAP_TYPE_CUBE\n\t\tvec4 envColor = textureCube( envMap, vec3( flipEnvMap * reflectVec.x, reflectVec.yz ) );\n\t#elif defined( ENVMAP_TYPE_CUBE_UV )\n\t\tvec4 envColor = textureCubeUV( envMap, reflectVec, 0.0 );\n\t#else\n\t\tvec4 envColor = vec4( 0.0 );\n\t#endif\n\t#ifdef ENVMAP_BLENDING_MULTIPLY\n\t\toutgoingLight = mix( outgoingLight, outgoingLight * envColor.xyz, specularStrength * reflectivity );\n\t#elif defined( ENVMAP_BLENDING_MIX )\n\t\toutgoingLight = mix( outgoingLight, envColor.xyz, specularStrength * reflectivity );\n\t#elif defined( ENVMAP_BLENDING_ADD )\n\t\toutgoingLight += envColor.xyz * specularStrength * reflectivity;\n\t#endif\n#endif",envmap_common_pars_fragment:"#ifdef USE_ENVMAP\n\tuniform float envMapIntensity;\n\tuniform float flipEnvMap;\n\t#ifdef ENVMAP_TYPE_CUBE\n\t\tuniform samplerCube envMap;\n\t#else\n\t\tuniform sampler2D envMap;\n\t#endif\n\t\n#endif",envmap_pars_fragment:"#ifdef USE_ENVMAP\n\tuniform float reflectivity;\n\t#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG )\n\t\t#define ENV_WORLDPOS\n\t#endif\n\t#ifdef ENV_WORLDPOS\n\t\tvarying vec3 vWorldPosition;\n\t\tuniform float refractionRatio;\n\t#else\n\t\tvarying vec3 vReflect;\n\t#endif\n#endif",envmap_pars_vertex:"#ifdef USE_ENVMAP\n\t#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) ||defined( PHONG )\n\t\t#define ENV_WORLDPOS\n\t#endif\n\t#ifdef ENV_WORLDPOS\n\t\t\n\t\tvarying vec3 vWorldPosition;\n\t#else\n\t\tvarying vec3 vReflect;\n\t\tuniform float refractionRatio;\n\t#endif\n#endif",envmap_physical_pars_fragment:"#if defined( USE_ENVMAP )\n\t#ifdef ENVMAP_MODE_REFRACTION\n\t\tuniform float refractionRatio;\n\t#endif\n\tvec3 getIBLIrradiance( const in vec3 normal ) {\n\t\t#if defined( ENVMAP_TYPE_CUBE_UV )\n\t\t\tvec3 worldNormal = inverseTransformDirection( normal, viewMatrix );\n\t\t\tvec4 envMapColor = textureCubeUV( envMap, worldNormal, 1.0 );\n\t\t\treturn PI * envMapColor.rgb * envMapIntensity;\n\t\t#else\n\t\t\treturn vec3( 0.0 );\n\t\t#endif\n\t}\n\tvec3 getIBLRadiance( const in vec3 viewDir, const in vec3 normal, const in float roughness ) {\n\t\t#if defined( ENVMAP_TYPE_CUBE_UV )\n\t\t\tvec3 reflectVec;\n\t\t\t#ifdef ENVMAP_MODE_REFLECTION\n\t\t\t\treflectVec = reflect( - viewDir, normal );\n\t\t\t\treflectVec = normalize( mix( reflectVec, normal, roughness * roughness) );\n\t\t\t#else\n\t\t\t\treflectVec = refract( - viewDir, normal, refractionRatio );\n\t\t\t#endif\n\t\t\treflectVec = inverseTransformDirection( reflectVec, viewMatrix );\n\t\t\tvec4 envMapColor = textureCubeUV( envMap, reflectVec, roughness );\n\t\t\treturn envMapColor.rgb * envMapIntensity;\n\t\t#else\n\t\t\treturn vec3( 0.0 );\n\t\t#endif\n\t}\n#endif",envmap_vertex:"#ifdef USE_ENVMAP\n\t#ifdef ENV_WORLDPOS\n\t\tvWorldPosition = worldPosition.xyz;\n\t#else\n\t\tvec3 cameraToVertex;\n\t\tif ( isOrthographic ) {\n\t\t\tcameraToVertex = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );\n\t\t} else {\n\t\t\tcameraToVertex = normalize( worldPosition.xyz - cameraPosition );\n\t\t}\n\t\tvec3 worldNormal = inverseTransformDirection( transformedNormal, viewMatrix );\n\t\t#ifdef ENVMAP_MODE_REFLECTION\n\t\t\tvReflect = reflect( cameraToVertex, worldNormal );\n\t\t#else\n\t\t\tvReflect = refract( cameraToVertex, worldNormal, refractionRatio );\n\t\t#endif\n\t#endif\n#endif",fog_vertex:"#ifdef USE_FOG\n\tvFogDepth = - mvPosition.z;\n#endif",fog_pars_vertex:"#ifdef USE_FOG\n\tvarying float vFogDepth;\n#endif",fog_fragment:"#ifdef USE_FOG\n\t#ifdef FOG_EXP2\n\t\tfloat fogFactor = 1.0 - exp( - fogDensity * fogDensity * vFogDepth * vFogDepth );\n\t#else\n\t\tfloat fogFactor = smoothstep( fogNear, fogFar, vFogDepth );\n\t#endif\n\tgl_FragColor.rgb = mix( gl_FragColor.rgb, fogColor, fogFactor );\n#endif",fog_pars_fragment:"#ifdef USE_FOG\n\tuniform vec3 fogColor;\n\tvarying float vFogDepth;\n\t#ifdef FOG_EXP2\n\t\tuniform float fogDensity;\n\t#else\n\t\tuniform float fogNear;\n\t\tuniform float fogFar;\n\t#endif\n#endif",gradientmap_pars_fragment:"#ifdef USE_GRADIENTMAP\n\tuniform sampler2D gradientMap;\n#endif\nvec3 getGradientIrradiance( vec3 normal, vec3 lightDirection ) {\n\tfloat dotNL = dot( normal, lightDirection );\n\tvec2 coord = vec2( dotNL * 0.5 + 0.5, 0.0 );\n\t#ifdef USE_GRADIENTMAP\n\t\treturn vec3( texture2D( gradientMap, coord ).r );\n\t#else\n\t\treturn ( coord.x < 0.7 ) ? vec3( 0.7 ) : vec3( 1.0 );\n\t#endif\n}",lightmap_fragment:"#ifdef USE_LIGHTMAP\n\tvec4 lightMapTexel = texture2D( lightMap, vUv2 );\n\tvec3 lightMapIrradiance = lightMapTexel.rgb * lightMapIntensity;\n\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\tlightMapIrradiance *= PI;\n\t#endif\n\treflectedLight.indirectDiffuse += lightMapIrradiance;\n#endif",lightmap_pars_fragment:"#ifdef USE_LIGHTMAP\n\tuniform sampler2D lightMap;\n\tuniform float lightMapIntensity;\n#endif",lights_lambert_vertex:"vec3 diffuse = vec3( 1.0 );\nGeometricContext geometry;\ngeometry.position = mvPosition.xyz;\ngeometry.normal = normalize( transformedNormal );\ngeometry.viewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( -mvPosition.xyz );\nGeometricContext backGeometry;\nbackGeometry.position = geometry.position;\nbackGeometry.normal = -geometry.normal;\nbackGeometry.viewDir = geometry.viewDir;\nvLightFront = vec3( 0.0 );\nvIndirectFront = vec3( 0.0 );\n#ifdef DOUBLE_SIDED\n\tvLightBack = vec3( 0.0 );\n\tvIndirectBack = vec3( 0.0 );\n#endif\nIncidentLight directLight;\nfloat dotNL;\nvec3 directLightColor_Diffuse;\nvIndirectFront += getAmbientLightIrradiance( ambientLightColor );\nvIndirectFront += getLightProbeIrradiance( lightProbe, geometry.normal );\n#ifdef DOUBLE_SIDED\n\tvIndirectBack += getAmbientLightIrradiance( ambientLightColor );\n\tvIndirectBack += getLightProbeIrradiance( lightProbe, backGeometry.normal );\n#endif\n#if NUM_POINT_LIGHTS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\n\t\tgetPointLightInfo( pointLights[ i ], geometry, directLight );\n\t\tdotNL = dot( geometry.normal, directLight.direction );\n\t\tdirectLightColor_Diffuse = directLight.color;\n\t\tvLightFront += saturate( dotNL ) * directLightColor_Diffuse;\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvLightBack += saturate( - dotNL ) * directLightColor_Diffuse;\n\t\t#endif\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if NUM_SPOT_LIGHTS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\n\t\tgetSpotLightInfo( spotLights[ i ], geometry, directLight );\n\t\tdotNL = dot( geometry.normal, directLight.direction );\n\t\tdirectLightColor_Diffuse = directLight.color;\n\t\tvLightFront += saturate( dotNL ) * directLightColor_Diffuse;\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvLightBack += saturate( - dotNL ) * directLightColor_Diffuse;\n\t\t#endif\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if NUM_DIR_LIGHTS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n\t\tgetDirectionalLightInfo( directionalLights[ i ], geometry, directLight );\n\t\tdotNL = dot( geometry.normal, directLight.direction );\n\t\tdirectLightColor_Diffuse = directLight.color;\n\t\tvLightFront += saturate( dotNL ) * directLightColor_Diffuse;\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvLightBack += saturate( - dotNL ) * directLightColor_Diffuse;\n\t\t#endif\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if NUM_HEMI_LIGHTS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {\n\t\tvIndirectFront += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry.normal );\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvIndirectBack += getHemisphereLightIrradiance( hemisphereLights[ i ], backGeometry.normal );\n\t\t#endif\n\t}\n\t#pragma unroll_loop_end\n#endif",lights_pars_begin:"uniform bool receiveShadow;\nuniform vec3 ambientLightColor;\nuniform vec3 lightProbe[ 9 ];\nvec3 shGetIrradianceAt( in vec3 normal, in vec3 shCoefficients[ 9 ] ) {\n\tfloat x = normal.x, y = normal.y, z = normal.z;\n\tvec3 result = shCoefficients[ 0 ] * 0.886227;\n\tresult += shCoefficients[ 1 ] * 2.0 * 0.511664 * y;\n\tresult += shCoefficients[ 2 ] * 2.0 * 0.511664 * z;\n\tresult += shCoefficients[ 3 ] * 2.0 * 0.511664 * x;\n\tresult += shCoefficients[ 4 ] * 2.0 * 0.429043 * x * y;\n\tresult += shCoefficients[ 5 ] * 2.0 * 0.429043 * y * z;\n\tresult += shCoefficients[ 6 ] * ( 0.743125 * z * z - 0.247708 );\n\tresult += shCoefficients[ 7 ] * 2.0 * 0.429043 * x * z;\n\tresult += shCoefficients[ 8 ] * 0.429043 * ( x * x - y * y );\n\treturn result;\n}\nvec3 getLightProbeIrradiance( const in vec3 lightProbe[ 9 ], const in vec3 normal ) {\n\tvec3 worldNormal = inverseTransformDirection( normal, viewMatrix );\n\tvec3 irradiance = shGetIrradianceAt( worldNormal, lightProbe );\n\treturn irradiance;\n}\nvec3 getAmbientLightIrradiance( const in vec3 ambientLightColor ) {\n\tvec3 irradiance = ambientLightColor;\n\treturn irradiance;\n}\nfloat getDistanceAttenuation( const in float lightDistance, const in float cutoffDistance, const in float decayExponent ) {\n\t#if defined ( PHYSICALLY_CORRECT_LIGHTS )\n\t\tfloat distanceFalloff = 1.0 / max( pow( lightDistance, decayExponent ), 0.01 );\n\t\tif ( cutoffDistance > 0.0 ) {\n\t\t\tdistanceFalloff *= pow2( saturate( 1.0 - pow4( lightDistance / cutoffDistance ) ) );\n\t\t}\n\t\treturn distanceFalloff;\n\t#else\n\t\tif ( cutoffDistance > 0.0 && decayExponent > 0.0 ) {\n\t\t\treturn pow( saturate( - lightDistance / cutoffDistance + 1.0 ), decayExponent );\n\t\t}\n\t\treturn 1.0;\n\t#endif\n}\nfloat getSpotAttenuation( const in float coneCosine, const in float penumbraCosine, const in float angleCosine ) {\n\treturn smoothstep( coneCosine, penumbraCosine, angleCosine );\n}\n#if NUM_DIR_LIGHTS > 0\n\tstruct DirectionalLight {\n\t\tvec3 direction;\n\t\tvec3 color;\n\t};\n\tuniform DirectionalLight directionalLights[ NUM_DIR_LIGHTS ];\n\tvoid getDirectionalLightInfo( const in DirectionalLight directionalLight, const in GeometricContext geometry, out IncidentLight light ) {\n\t\tlight.color = directionalLight.color;\n\t\tlight.direction = directionalLight.direction;\n\t\tlight.visible = true;\n\t}\n#endif\n#if NUM_POINT_LIGHTS > 0\n\tstruct PointLight {\n\t\tvec3 position;\n\t\tvec3 color;\n\t\tfloat distance;\n\t\tfloat decay;\n\t};\n\tuniform PointLight pointLights[ NUM_POINT_LIGHTS ];\n\tvoid getPointLightInfo( const in PointLight pointLight, const in GeometricContext geometry, out IncidentLight light ) {\n\t\tvec3 lVector = pointLight.position - geometry.position;\n\t\tlight.direction = normalize( lVector );\n\t\tfloat lightDistance = length( lVector );\n\t\tlight.color = pointLight.color;\n\t\tlight.color *= getDistanceAttenuation( lightDistance, pointLight.distance, pointLight.decay );\n\t\tlight.visible = ( light.color != vec3( 0.0 ) );\n\t}\n#endif\n#if NUM_SPOT_LIGHTS > 0\n\tstruct SpotLight {\n\t\tvec3 position;\n\t\tvec3 direction;\n\t\tvec3 color;\n\t\tfloat distance;\n\t\tfloat decay;\n\t\tfloat coneCos;\n\t\tfloat penumbraCos;\n\t};\n\tuniform SpotLight spotLights[ NUM_SPOT_LIGHTS ];\n\tvoid getSpotLightInfo( const in SpotLight spotLight, const in GeometricContext geometry, out IncidentLight light ) {\n\t\tvec3 lVector = spotLight.position - geometry.position;\n\t\tlight.direction = normalize( lVector );\n\t\tfloat angleCos = dot( light.direction, spotLight.direction );\n\t\tfloat spotAttenuation = getSpotAttenuation( spotLight.coneCos, spotLight.penumbraCos, angleCos );\n\t\tif ( spotAttenuation > 0.0 ) {\n\t\t\tfloat lightDistance = length( lVector );\n\t\t\tlight.color = spotLight.color * spotAttenuation;\n\t\t\tlight.color *= getDistanceAttenuation( lightDistance, spotLight.distance, spotLight.decay );\n\t\t\tlight.visible = ( light.color != vec3( 0.0 ) );\n\t\t} else {\n\t\t\tlight.color = vec3( 0.0 );\n\t\t\tlight.visible = false;\n\t\t}\n\t}\n#endif\n#if NUM_RECT_AREA_LIGHTS > 0\n\tstruct RectAreaLight {\n\t\tvec3 color;\n\t\tvec3 position;\n\t\tvec3 halfWidth;\n\t\tvec3 halfHeight;\n\t};\n\tuniform sampler2D ltc_1;\tuniform sampler2D ltc_2;\n\tuniform RectAreaLight rectAreaLights[ NUM_RECT_AREA_LIGHTS ];\n#endif\n#if NUM_HEMI_LIGHTS > 0\n\tstruct HemisphereLight {\n\t\tvec3 direction;\n\t\tvec3 skyColor;\n\t\tvec3 groundColor;\n\t};\n\tuniform HemisphereLight hemisphereLights[ NUM_HEMI_LIGHTS ];\n\tvec3 getHemisphereLightIrradiance( const in HemisphereLight hemiLight, const in vec3 normal ) {\n\t\tfloat dotNL = dot( normal, hemiLight.direction );\n\t\tfloat hemiDiffuseWeight = 0.5 * dotNL + 0.5;\n\t\tvec3 irradiance = mix( hemiLight.groundColor, hemiLight.skyColor, hemiDiffuseWeight );\n\t\treturn irradiance;\n\t}\n#endif",lights_toon_fragment:"ToonMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb;",lights_toon_pars_fragment:"varying vec3 vViewPosition;\nstruct ToonMaterial {\n\tvec3 diffuseColor;\n};\nvoid RE_Direct_Toon( const in IncidentLight directLight, const in GeometricContext geometry, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {\n\tvec3 irradiance = getGradientIrradiance( geometry.normal, directLight.direction ) * directLight.color;\n\treflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectDiffuse_Toon( const in vec3 irradiance, const in GeometricContext geometry, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {\n\treflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\n#define RE_Direct\t\t\t\tRE_Direct_Toon\n#define RE_IndirectDiffuse\t\tRE_IndirectDiffuse_Toon\n#define Material_LightProbeLOD( material )\t(0)",lights_phong_fragment:"BlinnPhongMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb;\nmaterial.specularColor = specular;\nmaterial.specularShininess = shininess;\nmaterial.specularStrength = specularStrength;",lights_phong_pars_fragment:"varying vec3 vViewPosition;\nstruct BlinnPhongMaterial {\n\tvec3 diffuseColor;\n\tvec3 specularColor;\n\tfloat specularShininess;\n\tfloat specularStrength;\n};\nvoid RE_Direct_BlinnPhong( const in IncidentLight directLight, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {\n\tfloat dotNL = saturate( dot( geometry.normal, directLight.direction ) );\n\tvec3 irradiance = dotNL * directLight.color;\n\treflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n\treflectedLight.directSpecular += irradiance * BRDF_BlinnPhong( directLight.direction, geometry.viewDir, geometry.normal, material.specularColor, material.specularShininess ) * material.specularStrength;\n}\nvoid RE_IndirectDiffuse_BlinnPhong( const in vec3 irradiance, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {\n\treflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\n#define RE_Direct\t\t\t\tRE_Direct_BlinnPhong\n#define RE_IndirectDiffuse\t\tRE_IndirectDiffuse_BlinnPhong\n#define Material_LightProbeLOD( material )\t(0)",lights_physical_fragment:"PhysicalMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb * ( 1.0 - metalnessFactor );\nvec3 dxy = max( abs( dFdx( geometryNormal ) ), abs( dFdy( geometryNormal ) ) );\nfloat geometryRoughness = max( max( dxy.x, dxy.y ), dxy.z );\nmaterial.roughness = max( roughnessFactor, 0.0525 );material.roughness += geometryRoughness;\nmaterial.roughness = min( material.roughness, 1.0 );\n#ifdef IOR\n\t#ifdef SPECULAR\n\t\tfloat specularIntensityFactor = specularIntensity;\n\t\tvec3 specularColorFactor = specularColor;\n\t\t#ifdef USE_SPECULARINTENSITYMAP\n\t\t\tspecularIntensityFactor *= texture2D( specularIntensityMap, vUv ).a;\n\t\t#endif\n\t\t#ifdef USE_SPECULARCOLORMAP\n\t\t\tspecularColorFactor *= texture2D( specularColorMap, vUv ).rgb;\n\t\t#endif\n\t\tmaterial.specularF90 = mix( specularIntensityFactor, 1.0, metalnessFactor );\n\t#else\n\t\tfloat specularIntensityFactor = 1.0;\n\t\tvec3 specularColorFactor = vec3( 1.0 );\n\t\tmaterial.specularF90 = 1.0;\n\t#endif\n\tmaterial.specularColor = mix( min( pow2( ( ior - 1.0 ) / ( ior + 1.0 ) ) * specularColorFactor, vec3( 1.0 ) ) * specularIntensityFactor, diffuseColor.rgb, metalnessFactor );\n#else\n\tmaterial.specularColor = mix( vec3( 0.04 ), diffuseColor.rgb, metalnessFactor );\n\tmaterial.specularF90 = 1.0;\n#endif\n#ifdef USE_CLEARCOAT\n\tmaterial.clearcoat = clearcoat;\n\tmaterial.clearcoatRoughness = clearcoatRoughness;\n\tmaterial.clearcoatF0 = vec3( 0.04 );\n\tmaterial.clearcoatF90 = 1.0;\n\t#ifdef USE_CLEARCOATMAP\n\t\tmaterial.clearcoat *= texture2D( clearcoatMap, vUv ).x;\n\t#endif\n\t#ifdef USE_CLEARCOAT_ROUGHNESSMAP\n\t\tmaterial.clearcoatRoughness *= texture2D( clearcoatRoughnessMap, vUv ).y;\n\t#endif\n\tmaterial.clearcoat = saturate( material.clearcoat );\tmaterial.clearcoatRoughness = max( material.clearcoatRoughness, 0.0525 );\n\tmaterial.clearcoatRoughness += geometryRoughness;\n\tmaterial.clearcoatRoughness = min( material.clearcoatRoughness, 1.0 );\n#endif\n#ifdef USE_SHEEN\n\tmaterial.sheenColor = sheenColor;\n\t#ifdef USE_SHEENCOLORMAP\n\t\tmaterial.sheenColor *= texture2D( sheenColorMap, vUv ).rgb;\n\t#endif\n\tmaterial.sheenRoughness = clamp( sheenRoughness, 0.07, 1.0 );\n\t#ifdef USE_SHEENROUGHNESSMAP\n\t\tmaterial.sheenRoughness *= texture2D( sheenRoughnessMap, vUv ).a;\n\t#endif\n#endif",lights_physical_pars_fragment:"struct PhysicalMaterial {\n\tvec3 diffuseColor;\n\tfloat roughness;\n\tvec3 specularColor;\n\tfloat specularF90;\n\t#ifdef USE_CLEARCOAT\n\t\tfloat clearcoat;\n\t\tfloat clearcoatRoughness;\n\t\tvec3 clearcoatF0;\n\t\tfloat clearcoatF90;\n\t#endif\n\t#ifdef USE_SHEEN\n\t\tvec3 sheenColor;\n\t\tfloat sheenRoughness;\n\t#endif\n};\nvec3 clearcoatSpecular = vec3( 0.0 );\nvec3 sheenSpecular = vec3( 0.0 );\nfloat IBLSheenBRDF( const in vec3 normal, const in vec3 viewDir, const in float roughness) {\n\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\tfloat r2 = roughness * roughness;\n\tfloat a = roughness < 0.25 ? -339.2 * r2 + 161.4 * roughness - 25.9 : -8.48 * r2 + 14.3 * roughness - 9.95;\n\tfloat b = roughness < 0.25 ? 44.0 * r2 - 23.7 * roughness + 3.26 : 1.97 * r2 - 3.27 * roughness + 0.72;\n\tfloat DG = exp( a * dotNV + b ) + ( roughness < 0.25 ? 0.0 : 0.1 * ( roughness - 0.25 ) );\n\treturn saturate( DG * RECIPROCAL_PI );\n}\nvec2 DFGApprox( const in vec3 normal, const in vec3 viewDir, const in float roughness ) {\n\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\tconst vec4 c0 = vec4( - 1, - 0.0275, - 0.572, 0.022 );\n\tconst vec4 c1 = vec4( 1, 0.0425, 1.04, - 0.04 );\n\tvec4 r = roughness * c0 + c1;\n\tfloat a004 = min( r.x * r.x, exp2( - 9.28 * dotNV ) ) * r.x + r.y;\n\tvec2 fab = vec2( - 1.04, 1.04 ) * a004 + r.zw;\n\treturn fab;\n}\nvec3 EnvironmentBRDF( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float roughness ) {\n\tvec2 fab = DFGApprox( normal, viewDir, roughness );\n\treturn specularColor * fab.x + specularF90 * fab.y;\n}\nvoid computeMultiscattering( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float roughness, inout vec3 singleScatter, inout vec3 multiScatter ) {\n\tvec2 fab = DFGApprox( normal, viewDir, roughness );\n\tvec3 FssEss = specularColor * fab.x + specularF90 * fab.y;\n\tfloat Ess = fab.x + fab.y;\n\tfloat Ems = 1.0 - Ess;\n\tvec3 Favg = specularColor + ( 1.0 - specularColor ) * 0.047619;\tvec3 Fms = FssEss * Favg / ( 1.0 - Ems * Favg );\n\tsingleScatter += FssEss;\n\tmultiScatter += Fms * Ems;\n}\n#if NUM_RECT_AREA_LIGHTS > 0\n\tvoid RE_Direct_RectArea_Physical( const in RectAreaLight rectAreaLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n\t\tvec3 normal = geometry.normal;\n\t\tvec3 viewDir = geometry.viewDir;\n\t\tvec3 position = geometry.position;\n\t\tvec3 lightPos = rectAreaLight.position;\n\t\tvec3 halfWidth = rectAreaLight.halfWidth;\n\t\tvec3 halfHeight = rectAreaLight.halfHeight;\n\t\tvec3 lightColor = rectAreaLight.color;\n\t\tfloat roughness = material.roughness;\n\t\tvec3 rectCoords[ 4 ];\n\t\trectCoords[ 0 ] = lightPos + halfWidth - halfHeight;\t\trectCoords[ 1 ] = lightPos - halfWidth - halfHeight;\n\t\trectCoords[ 2 ] = lightPos - halfWidth + halfHeight;\n\t\trectCoords[ 3 ] = lightPos + halfWidth + halfHeight;\n\t\tvec2 uv = LTC_Uv( normal, viewDir, roughness );\n\t\tvec4 t1 = texture2D( ltc_1, uv );\n\t\tvec4 t2 = texture2D( ltc_2, uv );\n\t\tmat3 mInv = mat3(\n\t\t\tvec3( t1.x, 0, t1.y ),\n\t\t\tvec3(    0, 1,    0 ),\n\t\t\tvec3( t1.z, 0, t1.w )\n\t\t);\n\t\tvec3 fresnel = ( material.specularColor * t2.x + ( vec3( 1.0 ) - material.specularColor ) * t2.y );\n\t\treflectedLight.directSpecular += lightColor * fresnel * LTC_Evaluate( normal, viewDir, position, mInv, rectCoords );\n\t\treflectedLight.directDiffuse += lightColor * material.diffuseColor * LTC_Evaluate( normal, viewDir, position, mat3( 1.0 ), rectCoords );\n\t}\n#endif\nvoid RE_Direct_Physical( const in IncidentLight directLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n\tfloat dotNL = saturate( dot( geometry.normal, directLight.direction ) );\n\tvec3 irradiance = dotNL * directLight.color;\n\t#ifdef USE_CLEARCOAT\n\t\tfloat dotNLcc = saturate( dot( geometry.clearcoatNormal, directLight.direction ) );\n\t\tvec3 ccIrradiance = dotNLcc * directLight.color;\n\t\tclearcoatSpecular += ccIrradiance * BRDF_GGX( directLight.direction, geometry.viewDir, geometry.clearcoatNormal, material.clearcoatF0, material.clearcoatF90, material.clearcoatRoughness );\n\t#endif\n\t#ifdef USE_SHEEN\n\t\tsheenSpecular += irradiance * BRDF_Sheen( directLight.direction, geometry.viewDir, geometry.normal, material.sheenColor, material.sheenRoughness );\n\t#endif\n\treflectedLight.directSpecular += irradiance * BRDF_GGX( directLight.direction, geometry.viewDir, geometry.normal, material.specularColor, material.specularF90, material.roughness );\n\treflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectDiffuse_Physical( const in vec3 irradiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n\treflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectSpecular_Physical( const in vec3 radiance, const in vec3 irradiance, const in vec3 clearcoatRadiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight) {\n\t#ifdef USE_CLEARCOAT\n\t\tclearcoatSpecular += clearcoatRadiance * EnvironmentBRDF( geometry.clearcoatNormal, geometry.viewDir, material.clearcoatF0, material.clearcoatF90, material.clearcoatRoughness );\n\t#endif\n\t#ifdef USE_SHEEN\n\t\tsheenSpecular += irradiance * material.sheenColor * IBLSheenBRDF( geometry.normal, geometry.viewDir, material.sheenRoughness );\n\t#endif\n\tvec3 singleScattering = vec3( 0.0 );\n\tvec3 multiScattering = vec3( 0.0 );\n\tvec3 cosineWeightedIrradiance = irradiance * RECIPROCAL_PI;\n\tcomputeMultiscattering( geometry.normal, geometry.viewDir, material.specularColor, material.specularF90, material.roughness, singleScattering, multiScattering );\n\tvec3 diffuse = material.diffuseColor * ( 1.0 - ( singleScattering + multiScattering ) );\n\treflectedLight.indirectSpecular += radiance * singleScattering;\n\treflectedLight.indirectSpecular += multiScattering * cosineWeightedIrradiance;\n\treflectedLight.indirectDiffuse += diffuse * cosineWeightedIrradiance;\n}\n#define RE_Direct\t\t\t\tRE_Direct_Physical\n#define RE_Direct_RectArea\t\tRE_Direct_RectArea_Physical\n#define RE_IndirectDiffuse\t\tRE_IndirectDiffuse_Physical\n#define RE_IndirectSpecular\t\tRE_IndirectSpecular_Physical\nfloat computeSpecularOcclusion( const in float dotNV, const in float ambientOcclusion, const in float roughness ) {\n\treturn saturate( pow( dotNV + ambientOcclusion, exp2( - 16.0 * roughness - 1.0 ) ) - 1.0 + ambientOcclusion );\n}",lights_fragment_begin:"\nGeometricContext geometry;\ngeometry.position = - vViewPosition;\ngeometry.normal = normal;\ngeometry.viewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( vViewPosition );\n#ifdef USE_CLEARCOAT\n\tgeometry.clearcoatNormal = clearcoatNormal;\n#endif\nIncidentLight directLight;\n#if ( NUM_POINT_LIGHTS > 0 ) && defined( RE_Direct )\n\tPointLight pointLight;\n\t#if defined( USE_SHADOWMAP ) && NUM_POINT_LIGHT_SHADOWS > 0\n\tPointLightShadow pointLightShadow;\n\t#endif\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\n\t\tpointLight = pointLights[ i ];\n\t\tgetPointLightInfo( pointLight, geometry, directLight );\n\t\t#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_POINT_LIGHT_SHADOWS )\n\t\tpointLightShadow = pointLightShadows[ i ];\n\t\tdirectLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getPointShadow( pointShadowMap[ i ], pointLightShadow.shadowMapSize, pointLightShadow.shadowBias, pointLightShadow.shadowRadius, vPointShadowCoord[ i ], pointLightShadow.shadowCameraNear, pointLightShadow.shadowCameraFar ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometry, material, reflectedLight );\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if ( NUM_SPOT_LIGHTS > 0 ) && defined( RE_Direct )\n\tSpotLight spotLight;\n\t#if defined( USE_SHADOWMAP ) && NUM_SPOT_LIGHT_SHADOWS > 0\n\tSpotLightShadow spotLightShadow;\n\t#endif\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\n\t\tspotLight = spotLights[ i ];\n\t\tgetSpotLightInfo( spotLight, geometry, directLight );\n\t\t#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )\n\t\tspotLightShadow = spotLightShadows[ i ];\n\t\tdirectLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getShadow( spotShadowMap[ i ], spotLightShadow.shadowMapSize, spotLightShadow.shadowBias, spotLightShadow.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometry, material, reflectedLight );\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if ( NUM_DIR_LIGHTS > 0 ) && defined( RE_Direct )\n\tDirectionalLight directionalLight;\n\t#if defined( USE_SHADOWMAP ) && NUM_DIR_LIGHT_SHADOWS > 0\n\tDirectionalLightShadow directionalLightShadow;\n\t#endif\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n\t\tdirectionalLight = directionalLights[ i ];\n\t\tgetDirectionalLightInfo( directionalLight, geometry, directLight );\n\t\t#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS )\n\t\tdirectionalLightShadow = directionalLightShadows[ i ];\n\t\tdirectLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getShadow( directionalShadowMap[ i ], directionalLightShadow.shadowMapSize, directionalLightShadow.shadowBias, directionalLightShadow.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometry, material, reflectedLight );\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if ( NUM_RECT_AREA_LIGHTS > 0 ) && defined( RE_Direct_RectArea )\n\tRectAreaLight rectAreaLight;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_RECT_AREA_LIGHTS; i ++ ) {\n\t\trectAreaLight = rectAreaLights[ i ];\n\t\tRE_Direct_RectArea( rectAreaLight, geometry, material, reflectedLight );\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if defined( RE_IndirectDiffuse )\n\tvec3 iblIrradiance = vec3( 0.0 );\n\tvec3 irradiance = getAmbientLightIrradiance( ambientLightColor );\n\tirradiance += getLightProbeIrradiance( lightProbe, geometry.normal );\n\t#if ( NUM_HEMI_LIGHTS > 0 )\n\t\t#pragma unroll_loop_start\n\t\tfor ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {\n\t\t\tirradiance += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry.normal );\n\t\t}\n\t\t#pragma unroll_loop_end\n\t#endif\n#endif\n#if defined( RE_IndirectSpecular )\n\tvec3 radiance = vec3( 0.0 );\n\tvec3 clearcoatRadiance = vec3( 0.0 );\n#endif",lights_fragment_maps:"#if defined( RE_IndirectDiffuse )\n\t#ifdef USE_LIGHTMAP\n\t\tvec4 lightMapTexel = texture2D( lightMap, vUv2 );\n\t\tvec3 lightMapIrradiance = lightMapTexel.rgb * lightMapIntensity;\n\t\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\t\tlightMapIrradiance *= PI;\n\t\t#endif\n\t\tirradiance += lightMapIrradiance;\n\t#endif\n\t#if defined( USE_ENVMAP ) && defined( STANDARD ) && defined( ENVMAP_TYPE_CUBE_UV )\n\t\tiblIrradiance += getIBLIrradiance( geometry.normal );\n\t#endif\n#endif\n#if defined( USE_ENVMAP ) && defined( RE_IndirectSpecular )\n\tradiance += getIBLRadiance( geometry.viewDir, geometry.normal, material.roughness );\n\t#ifdef USE_CLEARCOAT\n\t\tclearcoatRadiance += getIBLRadiance( geometry.viewDir, geometry.clearcoatNormal, material.clearcoatRoughness );\n\t#endif\n#endif",lights_fragment_end:"#if defined( RE_IndirectDiffuse )\n\tRE_IndirectDiffuse( irradiance, geometry, material, reflectedLight );\n#endif\n#if defined( RE_IndirectSpecular )\n\tRE_IndirectSpecular( radiance, iblIrradiance, clearcoatRadiance, geometry, material, reflectedLight );\n#endif",logdepthbuf_fragment:"#if defined( USE_LOGDEPTHBUF ) && defined( USE_LOGDEPTHBUF_EXT )\n\tgl_FragDepthEXT = vIsPerspective == 0.0 ? gl_FragCoord.z : log2( vFragDepth ) * logDepthBufFC * 0.5;\n#endif",logdepthbuf_pars_fragment:"#if defined( USE_LOGDEPTHBUF ) && defined( USE_LOGDEPTHBUF_EXT )\n\tuniform float logDepthBufFC;\n\tvarying float vFragDepth;\n\tvarying float vIsPerspective;\n#endif",logdepthbuf_pars_vertex:"#ifdef USE_LOGDEPTHBUF\n\t#ifdef USE_LOGDEPTHBUF_EXT\n\t\tvarying float vFragDepth;\n\t\tvarying float vIsPerspective;\n\t#else\n\t\tuniform float logDepthBufFC;\n\t#endif\n#endif",logdepthbuf_vertex:"#ifdef USE_LOGDEPTHBUF\n\t#ifdef USE_LOGDEPTHBUF_EXT\n\t\tvFragDepth = 1.0 + gl_Position.w;\n\t\tvIsPerspective = float( isPerspectiveMatrix( projectionMatrix ) );\n\t#else\n\t\tif ( isPerspectiveMatrix( projectionMatrix ) ) {\n\t\t\tgl_Position.z = log2( max( EPSILON, gl_Position.w + 1.0 ) ) * logDepthBufFC - 1.0;\n\t\t\tgl_Position.z *= gl_Position.w;\n\t\t}\n\t#endif\n#endif",map_fragment:"#ifdef USE_MAP\n\tvec4 sampledDiffuseColor = texture2D( map, vUv );\n\t#ifdef DECODE_VIDEO_TEXTURE\n\t\tsampledDiffuseColor = vec4( mix( pow( sampledDiffuseColor.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), sampledDiffuseColor.rgb * 0.0773993808, vec3( lessThanEqual( sampledDiffuseColor.rgb, vec3( 0.04045 ) ) ) ), sampledDiffuseColor.w );\n\t#endif\n\tdiffuseColor *= sampledDiffuseColor;\n#endif",map_pars_fragment:"#ifdef USE_MAP\n\tuniform sampler2D map;\n#endif",map_particle_fragment:"#if defined( USE_MAP ) || defined( USE_ALPHAMAP )\n\tvec2 uv = ( uvTransform * vec3( gl_PointCoord.x, 1.0 - gl_PointCoord.y, 1 ) ).xy;\n#endif\n#ifdef USE_MAP\n\tdiffuseColor *= texture2D( map, uv );\n#endif\n#ifdef USE_ALPHAMAP\n\tdiffuseColor.a *= texture2D( alphaMap, uv ).g;\n#endif",map_particle_pars_fragment:"#if defined( USE_MAP ) || defined( USE_ALPHAMAP )\n\tuniform mat3 uvTransform;\n#endif\n#ifdef USE_MAP\n\tuniform sampler2D map;\n#endif\n#ifdef USE_ALPHAMAP\n\tuniform sampler2D alphaMap;\n#endif",metalnessmap_fragment:"float metalnessFactor = metalness;\n#ifdef USE_METALNESSMAP\n\tvec4 texelMetalness = texture2D( metalnessMap, vUv );\n\tmetalnessFactor *= texelMetalness.b;\n#endif",metalnessmap_pars_fragment:"#ifdef USE_METALNESSMAP\n\tuniform sampler2D metalnessMap;\n#endif",morphnormal_vertex:"#ifdef USE_MORPHNORMALS\n\tobjectNormal *= morphTargetBaseInfluence;\n\t#ifdef MORPHTARGETS_TEXTURE\n\t\tfor ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {\n\t\t\tif ( morphTargetInfluences[ i ] != 0.0 ) objectNormal += getMorph( gl_VertexID, i, 1, 2 ) * morphTargetInfluences[ i ];\n\t\t}\n\t#else\n\t\tobjectNormal += morphNormal0 * morphTargetInfluences[ 0 ];\n\t\tobjectNormal += morphNormal1 * morphTargetInfluences[ 1 ];\n\t\tobjectNormal += morphNormal2 * morphTargetInfluences[ 2 ];\n\t\tobjectNormal += morphNormal3 * morphTargetInfluences[ 3 ];\n\t#endif\n#endif",morphtarget_pars_vertex:"#ifdef USE_MORPHTARGETS\n\tuniform float morphTargetBaseInfluence;\n\t#ifdef MORPHTARGETS_TEXTURE\n\t\tuniform float morphTargetInfluences[ MORPHTARGETS_COUNT ];\n\t\tuniform sampler2DArray morphTargetsTexture;\n\t\tuniform vec2 morphTargetsTextureSize;\n\t\tvec3 getMorph( const in int vertexIndex, const in int morphTargetIndex, const in int offset, const in int stride ) {\n\t\t\tfloat texelIndex = float( vertexIndex * stride + offset );\n\t\t\tfloat y = floor( texelIndex / morphTargetsTextureSize.x );\n\t\t\tfloat x = texelIndex - y * morphTargetsTextureSize.x;\n\t\t\tvec3 morphUV = vec3( ( x + 0.5 ) / morphTargetsTextureSize.x, y / morphTargetsTextureSize.y, morphTargetIndex );\n\t\t\treturn texture( morphTargetsTexture, morphUV ).xyz;\n\t\t}\n\t#else\n\t\t#ifndef USE_MORPHNORMALS\n\t\t\tuniform float morphTargetInfluences[ 8 ];\n\t\t#else\n\t\t\tuniform float morphTargetInfluences[ 4 ];\n\t\t#endif\n\t#endif\n#endif",morphtarget_vertex:"#ifdef USE_MORPHTARGETS\n\ttransformed *= morphTargetBaseInfluence;\n\t#ifdef MORPHTARGETS_TEXTURE\n\t\tfor ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {\n\t\t\t#ifndef USE_MORPHNORMALS\n\t\t\t\tif ( morphTargetInfluences[ i ] != 0.0 ) transformed += getMorph( gl_VertexID, i, 0, 1 ) * morphTargetInfluences[ i ];\n\t\t\t#else\n\t\t\t\tif ( morphTargetInfluences[ i ] != 0.0 ) transformed += getMorph( gl_VertexID, i, 0, 2 ) * morphTargetInfluences[ i ];\n\t\t\t#endif\n\t\t}\n\t#else\n\t\ttransformed += morphTarget0 * morphTargetInfluences[ 0 ];\n\t\ttransformed += morphTarget1 * morphTargetInfluences[ 1 ];\n\t\ttransformed += morphTarget2 * morphTargetInfluences[ 2 ];\n\t\ttransformed += morphTarget3 * morphTargetInfluences[ 3 ];\n\t\t#ifndef USE_MORPHNORMALS\n\t\t\ttransformed += morphTarget4 * morphTargetInfluences[ 4 ];\n\t\t\ttransformed += morphTarget5 * morphTargetInfluences[ 5 ];\n\t\t\ttransformed += morphTarget6 * morphTargetInfluences[ 6 ];\n\t\t\ttransformed += morphTarget7 * morphTargetInfluences[ 7 ];\n\t\t#endif\n\t#endif\n#endif",normal_fragment_begin:"float faceDirection = gl_FrontFacing ? 1.0 : - 1.0;\n#ifdef FLAT_SHADED\n\tvec3 fdx = vec3( dFdx( vViewPosition.x ), dFdx( vViewPosition.y ), dFdx( vViewPosition.z ) );\n\tvec3 fdy = vec3( dFdy( vViewPosition.x ), dFdy( vViewPosition.y ), dFdy( vViewPosition.z ) );\n\tvec3 normal = normalize( cross( fdx, fdy ) );\n#else\n\tvec3 normal = normalize( vNormal );\n\t#ifdef DOUBLE_SIDED\n\t\tnormal = normal * faceDirection;\n\t#endif\n\t#ifdef USE_TANGENT\n\t\tvec3 tangent = normalize( vTangent );\n\t\tvec3 bitangent = normalize( vBitangent );\n\t\t#ifdef DOUBLE_SIDED\n\t\t\ttangent = tangent * faceDirection;\n\t\t\tbitangent = bitangent * faceDirection;\n\t\t#endif\n\t\t#if defined( TANGENTSPACE_NORMALMAP ) || defined( USE_CLEARCOAT_NORMALMAP )\n\t\t\tmat3 vTBN = mat3( tangent, bitangent, normal );\n\t\t#endif\n\t#endif\n#endif\nvec3 geometryNormal = normal;",normal_fragment_maps:"#ifdef OBJECTSPACE_NORMALMAP\n\tnormal = texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;\n\t#ifdef FLIP_SIDED\n\t\tnormal = - normal;\n\t#endif\n\t#ifdef DOUBLE_SIDED\n\t\tnormal = normal * faceDirection;\n\t#endif\n\tnormal = normalize( normalMatrix * normal );\n#elif defined( TANGENTSPACE_NORMALMAP )\n\tvec3 mapN = texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;\n\tmapN.xy *= normalScale;\n\t#ifdef USE_TANGENT\n\t\tnormal = normalize( vTBN * mapN );\n\t#else\n\t\tnormal = perturbNormal2Arb( - vViewPosition, normal, mapN, faceDirection );\n\t#endif\n#elif defined( USE_BUMPMAP )\n\tnormal = perturbNormalArb( - vViewPosition, normal, dHdxy_fwd(), faceDirection );\n#endif",normal_pars_fragment:"#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n\t#ifdef USE_TANGENT\n\t\tvarying vec3 vTangent;\n\t\tvarying vec3 vBitangent;\n\t#endif\n#endif",normal_pars_vertex:"#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n\t#ifdef USE_TANGENT\n\t\tvarying vec3 vTangent;\n\t\tvarying vec3 vBitangent;\n\t#endif\n#endif",normal_vertex:"#ifndef FLAT_SHADED\n\tvNormal = normalize( transformedNormal );\n\t#ifdef USE_TANGENT\n\t\tvTangent = normalize( transformedTangent );\n\t\tvBitangent = normalize( cross( vNormal, vTangent ) * tangent.w );\n\t#endif\n#endif",normalmap_pars_fragment:"#ifdef USE_NORMALMAP\n\tuniform sampler2D normalMap;\n\tuniform vec2 normalScale;\n#endif\n#ifdef OBJECTSPACE_NORMALMAP\n\tuniform mat3 normalMatrix;\n#endif\n#if ! defined ( USE_TANGENT ) && ( defined ( TANGENTSPACE_NORMALMAP ) || defined ( USE_CLEARCOAT_NORMALMAP ) )\n\tvec3 perturbNormal2Arb( vec3 eye_pos, vec3 surf_norm, vec3 mapN, float faceDirection ) {\n\t\tvec3 q0 = vec3( dFdx( eye_pos.x ), dFdx( eye_pos.y ), dFdx( eye_pos.z ) );\n\t\tvec3 q1 = vec3( dFdy( eye_pos.x ), dFdy( eye_pos.y ), dFdy( eye_pos.z ) );\n\t\tvec2 st0 = dFdx( vUv.st );\n\t\tvec2 st1 = dFdy( vUv.st );\n\t\tvec3 N = surf_norm;\n\t\tvec3 q1perp = cross( q1, N );\n\t\tvec3 q0perp = cross( N, q0 );\n\t\tvec3 T = q1perp * st0.x + q0perp * st1.x;\n\t\tvec3 B = q1perp * st0.y + q0perp * st1.y;\n\t\tfloat det = max( dot( T, T ), dot( B, B ) );\n\t\tfloat scale = ( det == 0.0 ) ? 0.0 : faceDirection * inversesqrt( det );\n\t\treturn normalize( T * ( mapN.x * scale ) + B * ( mapN.y * scale ) + N * mapN.z );\n\t}\n#endif",clearcoat_normal_fragment_begin:"#ifdef USE_CLEARCOAT\n\tvec3 clearcoatNormal = geometryNormal;\n#endif",clearcoat_normal_fragment_maps:"#ifdef USE_CLEARCOAT_NORMALMAP\n\tvec3 clearcoatMapN = texture2D( clearcoatNormalMap, vUv ).xyz * 2.0 - 1.0;\n\tclearcoatMapN.xy *= clearcoatNormalScale;\n\t#ifdef USE_TANGENT\n\t\tclearcoatNormal = normalize( vTBN * clearcoatMapN );\n\t#else\n\t\tclearcoatNormal = perturbNormal2Arb( - vViewPosition, clearcoatNormal, clearcoatMapN, faceDirection );\n\t#endif\n#endif",clearcoat_pars_fragment:"#ifdef USE_CLEARCOATMAP\n\tuniform sampler2D clearcoatMap;\n#endif\n#ifdef USE_CLEARCOAT_ROUGHNESSMAP\n\tuniform sampler2D clearcoatRoughnessMap;\n#endif\n#ifdef USE_CLEARCOAT_NORMALMAP\n\tuniform sampler2D clearcoatNormalMap;\n\tuniform vec2 clearcoatNormalScale;\n#endif",output_fragment:"#ifdef OPAQUE\ndiffuseColor.a = 1.0;\n#endif\n#ifdef USE_TRANSMISSION\ndiffuseColor.a *= transmissionAlpha + 0.1;\n#endif\ngl_FragColor = vec4( outgoingLight, diffuseColor.a );",packing:"vec3 packNormalToRGB( const in vec3 normal ) {\n\treturn normalize( normal ) * 0.5 + 0.5;\n}\nvec3 unpackRGBToNormal( const in vec3 rgb ) {\n\treturn 2.0 * rgb.xyz - 1.0;\n}\nconst float PackUpscale = 256. / 255.;const float UnpackDownscale = 255. / 256.;\nconst vec3 PackFactors = vec3( 256. * 256. * 256., 256. * 256., 256. );\nconst vec4 UnpackFactors = UnpackDownscale / vec4( PackFactors, 1. );\nconst float ShiftRight8 = 1. / 256.;\nvec4 packDepthToRGBA( const in float v ) {\n\tvec4 r = vec4( fract( v * PackFactors ), v );\n\tr.yzw -= r.xyz * ShiftRight8;\treturn r * PackUpscale;\n}\nfloat unpackRGBAToDepth( const in vec4 v ) {\n\treturn dot( v, UnpackFactors );\n}\nvec4 pack2HalfToRGBA( vec2 v ) {\n\tvec4 r = vec4( v.x, fract( v.x * 255.0 ), v.y, fract( v.y * 255.0 ) );\n\treturn vec4( r.x - r.y / 255.0, r.y, r.z - r.w / 255.0, r.w );\n}\nvec2 unpackRGBATo2Half( vec4 v ) {\n\treturn vec2( v.x + ( v.y / 255.0 ), v.z + ( v.w / 255.0 ) );\n}\nfloat viewZToOrthographicDepth( const in float viewZ, const in float near, const in float far ) {\n\treturn ( viewZ + near ) / ( near - far );\n}\nfloat orthographicDepthToViewZ( const in float linearClipZ, const in float near, const in float far ) {\n\treturn linearClipZ * ( near - far ) - near;\n}\nfloat viewZToPerspectiveDepth( const in float viewZ, const in float near, const in float far ) {\n\treturn ( ( near + viewZ ) * far ) / ( ( far - near ) * viewZ );\n}\nfloat perspectiveDepthToViewZ( const in float invClipZ, const in float near, const in float far ) {\n\treturn ( near * far ) / ( ( far - near ) * invClipZ - far );\n}",premultiplied_alpha_fragment:"#ifdef PREMULTIPLIED_ALPHA\n\tgl_FragColor.rgb *= gl_FragColor.a;\n#endif",project_vertex:"vec4 mvPosition = vec4( transformed, 1.0 );\n#ifdef USE_INSTANCING\n\tmvPosition = instanceMatrix * mvPosition;\n#endif\nmvPosition = modelViewMatrix * mvPosition;\ngl_Position = projectionMatrix * mvPosition;",dithering_fragment:"#ifdef DITHERING\n\tgl_FragColor.rgb = dithering( gl_FragColor.rgb );\n#endif",dithering_pars_fragment:"#ifdef DITHERING\n\tvec3 dithering( vec3 color ) {\n\t\tfloat grid_position = rand( gl_FragCoord.xy );\n\t\tvec3 dither_shift_RGB = vec3( 0.25 / 255.0, -0.25 / 255.0, 0.25 / 255.0 );\n\t\tdither_shift_RGB = mix( 2.0 * dither_shift_RGB, -2.0 * dither_shift_RGB, grid_position );\n\t\treturn color + dither_shift_RGB;\n\t}\n#endif",roughnessmap_fragment:"float roughnessFactor = roughness;\n#ifdef USE_ROUGHNESSMAP\n\tvec4 texelRoughness = texture2D( roughnessMap, vUv );\n\troughnessFactor *= texelRoughness.g;\n#endif",roughnessmap_pars_fragment:"#ifdef USE_ROUGHNESSMAP\n\tuniform sampler2D roughnessMap;\n#endif",shadowmap_pars_fragment:"#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\t\tuniform sampler2D directionalShadowMap[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tvarying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tstruct DirectionalLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t};\n\t\tuniform DirectionalLightShadow directionalLightShadows[ NUM_DIR_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS > 0\n\t\tuniform sampler2D spotShadowMap[ NUM_SPOT_LIGHT_SHADOWS ];\n\t\tvarying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHT_SHADOWS ];\n\t\tstruct SpotLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t};\n\t\tuniform SpotLightShadow spotLightShadows[ NUM_SPOT_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\t\tuniform sampler2D pointShadowMap[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tvarying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tstruct PointLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t\tfloat shadowCameraNear;\n\t\t\tfloat shadowCameraFar;\n\t\t};\n\t\tuniform PointLightShadow pointLightShadows[ NUM_POINT_LIGHT_SHADOWS ];\n\t#endif\n\tfloat texture2DCompare( sampler2D depths, vec2 uv, float compare ) {\n\t\treturn step( compare, unpackRGBAToDepth( texture2D( depths, uv ) ) );\n\t}\n\tvec2 texture2DDistribution( sampler2D shadow, vec2 uv ) {\n\t\treturn unpackRGBATo2Half( texture2D( shadow, uv ) );\n\t}\n\tfloat VSMShadow (sampler2D shadow, vec2 uv, float compare ){\n\t\tfloat occlusion = 1.0;\n\t\tvec2 distribution = texture2DDistribution( shadow, uv );\n\t\tfloat hard_shadow = step( compare , distribution.x );\n\t\tif (hard_shadow != 1.0 ) {\n\t\t\tfloat distance = compare - distribution.x ;\n\t\t\tfloat variance = max( 0.00000, distribution.y * distribution.y );\n\t\t\tfloat softness_probability = variance / (variance + distance * distance );\t\t\tsoftness_probability = clamp( ( softness_probability - 0.3 ) / ( 0.95 - 0.3 ), 0.0, 1.0 );\t\t\tocclusion = clamp( max( hard_shadow, softness_probability ), 0.0, 1.0 );\n\t\t}\n\t\treturn occlusion;\n\t}\n\tfloat getShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord ) {\n\t\tfloat shadow = 1.0;\n\t\tshadowCoord.xyz /= shadowCoord.w;\n\t\tshadowCoord.z += shadowBias;\n\t\tbvec4 inFrustumVec = bvec4 ( shadowCoord.x >= 0.0, shadowCoord.x <= 1.0, shadowCoord.y >= 0.0, shadowCoord.y <= 1.0 );\n\t\tbool inFrustum = all( inFrustumVec );\n\t\tbvec2 frustumTestVec = bvec2( inFrustum, shadowCoord.z <= 1.0 );\n\t\tbool frustumTest = all( frustumTestVec );\n\t\tif ( frustumTest ) {\n\t\t#if defined( SHADOWMAP_TYPE_PCF )\n\t\t\tvec2 texelSize = vec2( 1.0 ) / shadowMapSize;\n\t\t\tfloat dx0 = - texelSize.x * shadowRadius;\n\t\t\tfloat dy0 = - texelSize.y * shadowRadius;\n\t\t\tfloat dx1 = + texelSize.x * shadowRadius;\n\t\t\tfloat dy1 = + texelSize.y * shadowRadius;\n\t\t\tfloat dx2 = dx0 / 2.0;\n\t\t\tfloat dy2 = dy0 / 2.0;\n\t\t\tfloat dx3 = dx1 / 2.0;\n\t\t\tfloat dy3 = dy1 / 2.0;\n\t\t\tshadow = (\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, dy2 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy2 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, dy2 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, dy3 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy3 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, dy3 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy1 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy1 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy1 ), shadowCoord.z )\n\t\t\t) * ( 1.0 / 17.0 );\n\t\t#elif defined( SHADOWMAP_TYPE_PCF_SOFT )\n\t\t\tvec2 texelSize = vec2( 1.0 ) / shadowMapSize;\n\t\t\tfloat dx = texelSize.x;\n\t\t\tfloat dy = texelSize.y;\n\t\t\tvec2 uv = shadowCoord.xy;\n\t\t\tvec2 f = fract( uv * shadowMapSize + 0.5 );\n\t\t\tuv -= f * texelSize;\n\t\t\tshadow = (\n\t\t\t\ttexture2DCompare( shadowMap, uv, shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, uv + vec2( dx, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, uv + vec2( 0.0, dy ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, uv + texelSize, shadowCoord.z ) +\n\t\t\t\tmix( texture2DCompare( shadowMap, uv + vec2( -dx, 0.0 ), shadowCoord.z ), \n\t\t\t\t\t texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, 0.0 ), shadowCoord.z ),\n\t\t\t\t\t f.x ) +\n\t\t\t\tmix( texture2DCompare( shadowMap, uv + vec2( -dx, dy ), shadowCoord.z ), \n\t\t\t\t\t texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, dy ), shadowCoord.z ),\n\t\t\t\t\t f.x ) +\n\t\t\t\tmix( texture2DCompare( shadowMap, uv + vec2( 0.0, -dy ), shadowCoord.z ), \n\t\t\t\t\t texture2DCompare( shadowMap, uv + vec2( 0.0, 2.0 * dy ), shadowCoord.z ),\n\t\t\t\t\t f.y ) +\n\t\t\t\tmix( texture2DCompare( shadowMap, uv + vec2( dx, -dy ), shadowCoord.z ), \n\t\t\t\t\t texture2DCompare( shadowMap, uv + vec2( dx, 2.0 * dy ), shadowCoord.z ),\n\t\t\t\t\t f.y ) +\n\t\t\t\tmix( mix( texture2DCompare( shadowMap, uv + vec2( -dx, -dy ), shadowCoord.z ), \n\t\t\t\t\t\t  texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, -dy ), shadowCoord.z ),\n\t\t\t\t\t\t  f.x ),\n\t\t\t\t\t mix( texture2DCompare( shadowMap, uv + vec2( -dx, 2.0 * dy ), shadowCoord.z ), \n\t\t\t\t\t\t  texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, 2.0 * dy ), shadowCoord.z ),\n\t\t\t\t\t\t  f.x ),\n\t\t\t\t\t f.y )\n\t\t\t) * ( 1.0 / 9.0 );\n\t\t#elif defined( SHADOWMAP_TYPE_VSM )\n\t\t\tshadow = VSMShadow( shadowMap, shadowCoord.xy, shadowCoord.z );\n\t\t#else\n\t\t\tshadow = texture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z );\n\t\t#endif\n\t\t}\n\t\treturn shadow;\n\t}\n\tvec2 cubeToUV( vec3 v, float texelSizeY ) {\n\t\tvec3 absV = abs( v );\n\t\tfloat scaleToCube = 1.0 / max( absV.x, max( absV.y, absV.z ) );\n\t\tabsV *= scaleToCube;\n\t\tv *= scaleToCube * ( 1.0 - 2.0 * texelSizeY );\n\t\tvec2 planar = v.xy;\n\t\tfloat almostATexel = 1.5 * texelSizeY;\n\t\tfloat almostOne = 1.0 - almostATexel;\n\t\tif ( absV.z >= almostOne ) {\n\t\t\tif ( v.z > 0.0 )\n\t\t\t\tplanar.x = 4.0 - v.x;\n\t\t} else if ( absV.x >= almostOne ) {\n\t\t\tfloat signX = sign( v.x );\n\t\t\tplanar.x = v.z * signX + 2.0 * signX;\n\t\t} else if ( absV.y >= almostOne ) {\n\t\t\tfloat signY = sign( v.y );\n\t\t\tplanar.x = v.x + 2.0 * signY + 2.0;\n\t\t\tplanar.y = v.z * signY - 2.0;\n\t\t}\n\t\treturn vec2( 0.125, 0.25 ) * planar + vec2( 0.375, 0.75 );\n\t}\n\tfloat getPointShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord, float shadowCameraNear, float shadowCameraFar ) {\n\t\tvec2 texelSize = vec2( 1.0 ) / ( shadowMapSize * vec2( 4.0, 2.0 ) );\n\t\tvec3 lightToPosition = shadowCoord.xyz;\n\t\tfloat dp = ( length( lightToPosition ) - shadowCameraNear ) / ( shadowCameraFar - shadowCameraNear );\t\tdp += shadowBias;\n\t\tvec3 bd3D = normalize( lightToPosition );\n\t\t#if defined( SHADOWMAP_TYPE_PCF ) || defined( SHADOWMAP_TYPE_PCF_SOFT ) || defined( SHADOWMAP_TYPE_VSM )\n\t\t\tvec2 offset = vec2( - 1, 1 ) * shadowRadius * texelSize.y;\n\t\t\treturn (\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyy, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyy, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyx, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyx, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxy, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxy, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxx, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxx, texelSize.y ), dp )\n\t\t\t) * ( 1.0 / 9.0 );\n\t\t#else\n\t\t\treturn texture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp );\n\t\t#endif\n\t}\n#endif",shadowmap_pars_vertex:"#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\t\tuniform mat4 directionalShadowMatrix[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tvarying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tstruct DirectionalLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t};\n\t\tuniform DirectionalLightShadow directionalLightShadows[ NUM_DIR_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS > 0\n\t\tuniform mat4 spotShadowMatrix[ NUM_SPOT_LIGHT_SHADOWS ];\n\t\tvarying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHT_SHADOWS ];\n\t\tstruct SpotLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t};\n\t\tuniform SpotLightShadow spotLightShadows[ NUM_SPOT_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\t\tuniform mat4 pointShadowMatrix[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tvarying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tstruct PointLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t\tfloat shadowCameraNear;\n\t\t\tfloat shadowCameraFar;\n\t\t};\n\t\tuniform PointLightShadow pointLightShadows[ NUM_POINT_LIGHT_SHADOWS ];\n\t#endif\n#endif",shadowmap_vertex:"#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS > 0 || NUM_SPOT_LIGHT_SHADOWS > 0 || NUM_POINT_LIGHT_SHADOWS > 0\n\t\tvec3 shadowWorldNormal = inverseTransformDirection( transformedNormal, viewMatrix );\n\t\tvec4 shadowWorldPosition;\n\t#endif\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {\n\t\tshadowWorldPosition = worldPosition + vec4( shadowWorldNormal * directionalLightShadows[ i ].shadowNormalBias, 0 );\n\t\tvDirectionalShadowCoord[ i ] = directionalShadowMatrix[ i ] * shadowWorldPosition;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_SPOT_LIGHT_SHADOWS; i ++ ) {\n\t\tshadowWorldPosition = worldPosition + vec4( shadowWorldNormal * spotLightShadows[ i ].shadowNormalBias, 0 );\n\t\tvSpotShadowCoord[ i ] = spotShadowMatrix[ i ] * shadowWorldPosition;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {\n\t\tshadowWorldPosition = worldPosition + vec4( shadowWorldNormal * pointLightShadows[ i ].shadowNormalBias, 0 );\n\t\tvPointShadowCoord[ i ] = pointShadowMatrix[ i ] * shadowWorldPosition;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n#endif",shadowmask_pars_fragment:"float getShadowMask() {\n\tfloat shadow = 1.0;\n\t#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\tDirectionalLightShadow directionalLight;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {\n\t\tdirectionalLight = directionalLightShadows[ i ];\n\t\tshadow *= receiveShadow ? getShadow( directionalShadowMap[ i ], directionalLight.shadowMapSize, directionalLight.shadowBias, directionalLight.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS > 0\n\tSpotLightShadow spotLight;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_SPOT_LIGHT_SHADOWS; i ++ ) {\n\t\tspotLight = spotLightShadows[ i ];\n\t\tshadow *= receiveShadow ? getShadow( spotShadowMap[ i ], spotLight.shadowMapSize, spotLight.shadowBias, spotLight.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\tPointLightShadow pointLight;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {\n\t\tpointLight = pointLightShadows[ i ];\n\t\tshadow *= receiveShadow ? getPointShadow( pointShadowMap[ i ], pointLight.shadowMapSize, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ i ], pointLight.shadowCameraNear, pointLight.shadowCameraFar ) : 1.0;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#endif\n\treturn shadow;\n}",skinbase_vertex:"#ifdef USE_SKINNING\n\tmat4 boneMatX = getBoneMatrix( skinIndex.x );\n\tmat4 boneMatY = getBoneMatrix( skinIndex.y );\n\tmat4 boneMatZ = getBoneMatrix( skinIndex.z );\n\tmat4 boneMatW = getBoneMatrix( skinIndex.w );\n#endif",skinning_pars_vertex:"#ifdef USE_SKINNING\n\tuniform mat4 bindMatrix;\n\tuniform mat4 bindMatrixInverse;\n\t#ifdef BONE_TEXTURE\n\t\tuniform highp sampler2D boneTexture;\n\t\tuniform int boneTextureSize;\n\t\tmat4 getBoneMatrix( const in float i ) {\n\t\t\tfloat j = i * 4.0;\n\t\t\tfloat x = mod( j, float( boneTextureSize ) );\n\t\t\tfloat y = floor( j / float( boneTextureSize ) );\n\t\t\tfloat dx = 1.0 / float( boneTextureSize );\n\t\t\tfloat dy = 1.0 / float( boneTextureSize );\n\t\t\ty = dy * ( y + 0.5 );\n\t\t\tvec4 v1 = texture2D( boneTexture, vec2( dx * ( x + 0.5 ), y ) );\n\t\t\tvec4 v2 = texture2D( boneTexture, vec2( dx * ( x + 1.5 ), y ) );\n\t\t\tvec4 v3 = texture2D( boneTexture, vec2( dx * ( x + 2.5 ), y ) );\n\t\t\tvec4 v4 = texture2D( boneTexture, vec2( dx * ( x + 3.5 ), y ) );\n\t\t\tmat4 bone = mat4( v1, v2, v3, v4 );\n\t\t\treturn bone;\n\t\t}\n\t#else\n\t\tuniform mat4 boneMatrices[ MAX_BONES ];\n\t\tmat4 getBoneMatrix( const in float i ) {\n\t\t\tmat4 bone = boneMatrices[ int(i) ];\n\t\t\treturn bone;\n\t\t}\n\t#endif\n#endif",skinning_vertex:"#ifdef USE_SKINNING\n\tvec4 skinVertex = bindMatrix * vec4( transformed, 1.0 );\n\tvec4 skinned = vec4( 0.0 );\n\tskinned += boneMatX * skinVertex * skinWeight.x;\n\tskinned += boneMatY * skinVertex * skinWeight.y;\n\tskinned += boneMatZ * skinVertex * skinWeight.z;\n\tskinned += boneMatW * skinVertex * skinWeight.w;\n\ttransformed = ( bindMatrixInverse * skinned ).xyz;\n#endif",skinnormal_vertex:"#ifdef USE_SKINNING\n\tmat4 skinMatrix = mat4( 0.0 );\n\tskinMatrix += skinWeight.x * boneMatX;\n\tskinMatrix += skinWeight.y * boneMatY;\n\tskinMatrix += skinWeight.z * boneMatZ;\n\tskinMatrix += skinWeight.w * boneMatW;\n\tskinMatrix = bindMatrixInverse * skinMatrix * bindMatrix;\n\tobjectNormal = vec4( skinMatrix * vec4( objectNormal, 0.0 ) ).xyz;\n\t#ifdef USE_TANGENT\n\t\tobjectTangent = vec4( skinMatrix * vec4( objectTangent, 0.0 ) ).xyz;\n\t#endif\n#endif",specularmap_fragment:"float specularStrength;\n#ifdef USE_SPECULARMAP\n\tvec4 texelSpecular = texture2D( specularMap, vUv );\n\tspecularStrength = texelSpecular.r;\n#else\n\tspecularStrength = 1.0;\n#endif",specularmap_pars_fragment:"#ifdef USE_SPECULARMAP\n\tuniform sampler2D specularMap;\n#endif",tonemapping_fragment:"#if defined( TONE_MAPPING )\n\tgl_FragColor.rgb = toneMapping( gl_FragColor.rgb );\n#endif",tonemapping_pars_fragment:"#ifndef saturate\n#define saturate( a ) clamp( a, 0.0, 1.0 )\n#endif\nuniform float toneMappingExposure;\nvec3 LinearToneMapping( vec3 color ) {\n\treturn toneMappingExposure * color;\n}\nvec3 ReinhardToneMapping( vec3 color ) {\n\tcolor *= toneMappingExposure;\n\treturn saturate( color / ( vec3( 1.0 ) + color ) );\n}\nvec3 OptimizedCineonToneMapping( vec3 color ) {\n\tcolor *= toneMappingExposure;\n\tcolor = max( vec3( 0.0 ), color - 0.004 );\n\treturn pow( ( color * ( 6.2 * color + 0.5 ) ) / ( color * ( 6.2 * color + 1.7 ) + 0.06 ), vec3( 2.2 ) );\n}\nvec3 RRTAndODTFit( vec3 v ) {\n\tvec3 a = v * ( v + 0.0245786 ) - 0.000090537;\n\tvec3 b = v * ( 0.983729 * v + 0.4329510 ) + 0.238081;\n\treturn a / b;\n}\nvec3 ACESFilmicToneMapping( vec3 color ) {\n\tconst mat3 ACESInputMat = mat3(\n\t\tvec3( 0.59719, 0.07600, 0.02840 ),\t\tvec3( 0.35458, 0.90834, 0.13383 ),\n\t\tvec3( 0.04823, 0.01566, 0.83777 )\n\t);\n\tconst mat3 ACESOutputMat = mat3(\n\t\tvec3(  1.60475, -0.10208, -0.00327 ),\t\tvec3( -0.53108,  1.10813, -0.07276 ),\n\t\tvec3( -0.07367, -0.00605,  1.07602 )\n\t);\n\tcolor *= toneMappingExposure / 0.6;\n\tcolor = ACESInputMat * color;\n\tcolor = RRTAndODTFit( color );\n\tcolor = ACESOutputMat * color;\n\treturn saturate( color );\n}\nvec3 CustomToneMapping( vec3 color ) { return color; }",transmission_fragment:"#ifdef USE_TRANSMISSION\n\tfloat transmissionAlpha = 1.0;\n\tfloat transmissionFactor = transmission;\n\tfloat thicknessFactor = thickness;\n\t#ifdef USE_TRANSMISSIONMAP\n\t\ttransmissionFactor *= texture2D( transmissionMap, vUv ).r;\n\t#endif\n\t#ifdef USE_THICKNESSMAP\n\t\tthicknessFactor *= texture2D( thicknessMap, vUv ).g;\n\t#endif\n\tvec3 pos = vWorldPosition;\n\tvec3 v = normalize( cameraPosition - pos );\n\tvec3 n = inverseTransformDirection( normal, viewMatrix );\n\tvec4 transmission = getIBLVolumeRefraction(\n\t\tn, v, roughnessFactor, material.diffuseColor, material.specularColor, material.specularF90,\n\t\tpos, modelMatrix, viewMatrix, projectionMatrix, ior, thicknessFactor,\n\t\tattenuationColor, attenuationDistance );\n\ttotalDiffuse = mix( totalDiffuse, transmission.rgb, transmissionFactor );\n\ttransmissionAlpha = mix( transmissionAlpha, transmission.a, transmissionFactor );\n#endif",transmission_pars_fragment:"#ifdef USE_TRANSMISSION\n\tuniform float transmission;\n\tuniform float thickness;\n\tuniform float attenuationDistance;\n\tuniform vec3 attenuationColor;\n\t#ifdef USE_TRANSMISSIONMAP\n\t\tuniform sampler2D transmissionMap;\n\t#endif\n\t#ifdef USE_THICKNESSMAP\n\t\tuniform sampler2D thicknessMap;\n\t#endif\n\tuniform vec2 transmissionSamplerSize;\n\tuniform sampler2D transmissionSamplerMap;\n\tuniform mat4 modelMatrix;\n\tuniform mat4 projectionMatrix;\n\tvarying vec3 vWorldPosition;\n\tvec3 getVolumeTransmissionRay( const in vec3 n, const in vec3 v, const in float thickness, const in float ior, const in mat4 modelMatrix ) {\n\t\tvec3 refractionVector = refract( - v, normalize( n ), 1.0 / ior );\n\t\tvec3 modelScale;\n\t\tmodelScale.x = length( vec3( modelMatrix[ 0 ].xyz ) );\n\t\tmodelScale.y = length( vec3( modelMatrix[ 1 ].xyz ) );\n\t\tmodelScale.z = length( vec3( modelMatrix[ 2 ].xyz ) );\n\t\treturn normalize( refractionVector ) * thickness * modelScale;\n\t}\n\tfloat applyIorToRoughness( const in float roughness, const in float ior ) {\n\t\treturn roughness * clamp( ior * 2.0 - 2.0, 0.0, 1.0 );\n\t}\n\tvec4 getTransmissionSample( const in vec2 fragCoord, const in float roughness, const in float ior ) {\n\t\tfloat framebufferLod = log2( transmissionSamplerSize.x ) * applyIorToRoughness( roughness, ior );\n\t\t#ifdef TEXTURE_LOD_EXT\n\t\t\treturn texture2DLodEXT( transmissionSamplerMap, fragCoord.xy, framebufferLod );\n\t\t#else\n\t\t\treturn texture2D( transmissionSamplerMap, fragCoord.xy, framebufferLod );\n\t\t#endif\n\t}\n\tvec3 applyVolumeAttenuation( const in vec3 radiance, const in float transmissionDistance, const in vec3 attenuationColor, const in float attenuationDistance ) {\n\t\tif ( attenuationDistance == 0.0 ) {\n\t\t\treturn radiance;\n\t\t} else {\n\t\t\tvec3 attenuationCoefficient = -log( attenuationColor ) / attenuationDistance;\n\t\t\tvec3 transmittance = exp( - attenuationCoefficient * transmissionDistance );\t\t\treturn transmittance * radiance;\n\t\t}\n\t}\n\tvec4 getIBLVolumeRefraction( const in vec3 n, const in vec3 v, const in float roughness, const in vec3 diffuseColor,\n\t\tconst in vec3 specularColor, const in float specularF90, const in vec3 position, const in mat4 modelMatrix,\n\t\tconst in mat4 viewMatrix, const in mat4 projMatrix, const in float ior, const in float thickness,\n\t\tconst in vec3 attenuationColor, const in float attenuationDistance ) {\n\t\tvec3 transmissionRay = getVolumeTransmissionRay( n, v, thickness, ior, modelMatrix );\n\t\tvec3 refractedRayExit = position + transmissionRay;\n\t\tvec4 ndcPos = projMatrix * viewMatrix * vec4( refractedRayExit, 1.0 );\n\t\tvec2 refractionCoords = ndcPos.xy / ndcPos.w;\n\t\trefractionCoords += 1.0;\n\t\trefractionCoords /= 2.0;\n\t\tvec4 transmittedLight = getTransmissionSample( refractionCoords, roughness, ior );\n\t\tvec3 attenuatedColor = applyVolumeAttenuation( transmittedLight.rgb, length( transmissionRay ), attenuationColor, attenuationDistance );\n\t\tvec3 F = EnvironmentBRDF( n, v, specularColor, specularF90, roughness );\n\t\treturn vec4( ( 1.0 - F ) * attenuatedColor * diffuseColor, transmittedLight.a );\n\t}\n#endif",uv_pars_fragment:"#if ( defined( USE_UV ) && ! defined( UVS_VERTEX_ONLY ) )\n\tvarying vec2 vUv;\n#endif",uv_pars_vertex:"#ifdef USE_UV\n\t#ifdef UVS_VERTEX_ONLY\n\t\tvec2 vUv;\n\t#else\n\t\tvarying vec2 vUv;\n\t#endif\n\tuniform mat3 uvTransform;\n#endif",uv_vertex:"#ifdef USE_UV\n\tvUv = ( uvTransform * vec3( uv, 1 ) ).xy;\n#endif",uv2_pars_fragment:"#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\n\tvarying vec2 vUv2;\n#endif",uv2_pars_vertex:"#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\n\tattribute vec2 uv2;\n\tvarying vec2 vUv2;\n\tuniform mat3 uv2Transform;\n#endif",uv2_vertex:"#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\n\tvUv2 = ( uv2Transform * vec3( uv2, 1 ) ).xy;\n#endif",worldpos_vertex:"#if defined( USE_ENVMAP ) || defined( DISTANCE ) || defined ( USE_SHADOWMAP ) || defined ( USE_TRANSMISSION )\n\tvec4 worldPosition = vec4( transformed, 1.0 );\n\t#ifdef USE_INSTANCING\n\t\tworldPosition = instanceMatrix * worldPosition;\n\t#endif\n\tworldPosition = modelMatrix * worldPosition;\n#endif",background_vert:"varying vec2 vUv;\nuniform mat3 uvTransform;\nvoid main() {\n\tvUv = ( uvTransform * vec3( uv, 1 ) ).xy;\n\tgl_Position = vec4( position.xy, 1.0, 1.0 );\n}",background_frag:"uniform sampler2D t2D;\nvarying vec2 vUv;\nvoid main() {\n\tgl_FragColor = texture2D( t2D, vUv );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n}",cube_vert:"varying vec3 vWorldDirection;\n#include <common>\nvoid main() {\n\tvWorldDirection = transformDirection( position, modelMatrix );\n\t#include <begin_vertex>\n\t#include <project_vertex>\n\tgl_Position.z = gl_Position.w;\n}",cube_frag:"#include <envmap_common_pars_fragment>\nuniform float opacity;\nvarying vec3 vWorldDirection;\n#include <cube_uv_reflection_fragment>\nvoid main() {\n\tvec3 vReflect = vWorldDirection;\n\t#include <envmap_fragment>\n\tgl_FragColor = envColor;\n\tgl_FragColor.a *= opacity;\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n}",depth_vert:"#include <common>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvarying vec2 vHighPrecisionZW;\nvoid main() {\n\t#include <uv_vertex>\n\t#include <skinbase_vertex>\n\t#ifdef USE_DISPLACEMENTMAP\n\t\t#include <beginnormal_vertex>\n\t\t#include <morphnormal_vertex>\n\t\t#include <skinnormal_vertex>\n\t#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvHighPrecisionZW = gl_Position.zw;\n}",depth_frag:"#if DEPTH_PACKING == 3200\n\tuniform float opacity;\n#endif\n#include <common>\n#include <packing>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvarying vec2 vHighPrecisionZW;\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( 1.0 );\n\t#if DEPTH_PACKING == 3200\n\t\tdiffuseColor.a = opacity;\n\t#endif\n\t#include <map_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <logdepthbuf_fragment>\n\tfloat fragCoordZ = 0.5 * vHighPrecisionZW[0] / vHighPrecisionZW[1] + 0.5;\n\t#if DEPTH_PACKING == 3200\n\t\tgl_FragColor = vec4( vec3( 1.0 - fragCoordZ ), opacity );\n\t#elif DEPTH_PACKING == 3201\n\t\tgl_FragColor = packDepthToRGBA( fragCoordZ );\n\t#endif\n}",distanceRGBA_vert:"#define DISTANCE\nvarying vec3 vWorldPosition;\n#include <common>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <skinbase_vertex>\n\t#ifdef USE_DISPLACEMENTMAP\n\t\t#include <beginnormal_vertex>\n\t\t#include <morphnormal_vertex>\n\t\t#include <skinnormal_vertex>\n\t#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <worldpos_vertex>\n\t#include <clipping_planes_vertex>\n\tvWorldPosition = worldPosition.xyz;\n}",distanceRGBA_frag:"#define DISTANCE\nuniform vec3 referencePosition;\nuniform float nearDistance;\nuniform float farDistance;\nvarying vec3 vWorldPosition;\n#include <common>\n#include <packing>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main () {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( 1.0 );\n\t#include <map_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\tfloat dist = length( vWorldPosition - referencePosition );\n\tdist = ( dist - nearDistance ) / ( farDistance - nearDistance );\n\tdist = saturate( dist );\n\tgl_FragColor = packDepthToRGBA( dist );\n}",equirect_vert:"varying vec3 vWorldDirection;\n#include <common>\nvoid main() {\n\tvWorldDirection = transformDirection( position, modelMatrix );\n\t#include <begin_vertex>\n\t#include <project_vertex>\n}",equirect_frag:"uniform sampler2D tEquirect;\nvarying vec3 vWorldDirection;\n#include <common>\nvoid main() {\n\tvec3 direction = normalize( vWorldDirection );\n\tvec2 sampleUV = equirectUv( direction );\n\tgl_FragColor = texture2D( tEquirect, sampleUV );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n}",linedashed_vert:"uniform float scale;\nattribute float lineDistance;\nvarying float vLineDistance;\n#include <common>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\tvLineDistance = scale * lineDistance;\n\t#include <color_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <fog_vertex>\n}",linedashed_frag:"uniform vec3 diffuse;\nuniform float opacity;\nuniform float dashSize;\nuniform float totalSize;\nvarying float vLineDistance;\n#include <common>\n#include <color_pars_fragment>\n#include <fog_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tif ( mod( vLineDistance, totalSize ) > dashSize ) {\n\t\tdiscard;\n\t}\n\tvec3 outgoingLight = vec3( 0.0 );\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <color_fragment>\n\toutgoingLight = diffuseColor.rgb;\n\t#include <output_fragment>\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n}",meshbasic_vert:"#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <envmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#if defined ( USE_ENVMAP ) || defined ( USE_SKINNING )\n\t\t#include <beginnormal_vertex>\n\t\t#include <morphnormal_vertex>\n\t\t#include <skinbase_vertex>\n\t\t#include <skinnormal_vertex>\n\t\t#include <defaultnormal_vertex>\n\t#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <worldpos_vertex>\n\t#include <envmap_vertex>\n\t#include <fog_vertex>\n}",meshbasic_frag:"uniform vec3 diffuse;\nuniform float opacity;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include <common>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <envmap_common_pars_fragment>\n#include <envmap_pars_fragment>\n#include <cube_uv_reflection_fragment>\n#include <fog_pars_fragment>\n#include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <specularmap_fragment>\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\t#ifdef USE_LIGHTMAP\n\t\tvec4 lightMapTexel= texture2D( lightMap, vUv2 );\n\t\treflectedLight.indirectDiffuse += lightMapTexel.rgb * lightMapIntensity;\n\t#else\n\t\treflectedLight.indirectDiffuse += vec3( 1.0 );\n\t#endif\n\t#include <aomap_fragment>\n\treflectedLight.indirectDiffuse *= diffuseColor.rgb;\n\tvec3 outgoingLight = reflectedLight.indirectDiffuse;\n\t#include <envmap_fragment>\n\t#include <output_fragment>\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}",meshlambert_vert:"#define LAMBERT\nvarying vec3 vLightFront;\nvarying vec3 vIndirectFront;\n#ifdef DOUBLE_SIDED\n\tvarying vec3 vLightBack;\n\tvarying vec3 vIndirectBack;\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <envmap_pars_vertex>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <worldpos_vertex>\n\t#include <envmap_vertex>\n\t#include <lights_lambert_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}",meshlambert_frag:"uniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float opacity;\nvarying vec3 vLightFront;\nvarying vec3 vIndirectFront;\n#ifdef DOUBLE_SIDED\n\tvarying vec3 vLightBack;\n\tvarying vec3 vIndirectBack;\n#endif\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <envmap_common_pars_fragment>\n#include <envmap_pars_fragment>\n#include <cube_uv_reflection_fragment>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <fog_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <shadowmask_pars_fragment>\n#include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <specularmap_fragment>\n\t#include <emissivemap_fragment>\n\t#ifdef DOUBLE_SIDED\n\t\treflectedLight.indirectDiffuse += ( gl_FrontFacing ) ? vIndirectFront : vIndirectBack;\n\t#else\n\t\treflectedLight.indirectDiffuse += vIndirectFront;\n\t#endif\n\t#include <lightmap_fragment>\n\treflectedLight.indirectDiffuse *= BRDF_Lambert( diffuseColor.rgb );\n\t#ifdef DOUBLE_SIDED\n\t\treflectedLight.directDiffuse = ( gl_FrontFacing ) ? vLightFront : vLightBack;\n\t#else\n\t\treflectedLight.directDiffuse = vLightFront;\n\t#endif\n\treflectedLight.directDiffuse *= BRDF_Lambert( diffuseColor.rgb ) * getShadowMask();\n\t#include <aomap_fragment>\n\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;\n\t#include <envmap_fragment>\n\t#include <output_fragment>\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}",meshmatcap_vert:"#define MATCAP\nvarying vec3 vViewPosition;\n#include <common>\n#include <uv_pars_vertex>\n#include <color_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <fog_pars_vertex>\n#include <normal_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <color_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <normal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <fog_vertex>\n\tvViewPosition = - mvPosition.xyz;\n}",meshmatcap_frag:"#define MATCAP\nuniform vec3 diffuse;\nuniform float opacity;\nuniform sampler2D matcap;\nvarying vec3 vViewPosition;\n#include <common>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <fog_pars_fragment>\n#include <normal_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\tvec3 viewDir = normalize( vViewPosition );\n\tvec3 x = normalize( vec3( viewDir.z, 0.0, - viewDir.x ) );\n\tvec3 y = cross( viewDir, x );\n\tvec2 uv = vec2( dot( x, normal ), dot( y, normal ) ) * 0.495 + 0.5;\n\t#ifdef USE_MATCAP\n\t\tvec4 matcapColor = texture2D( matcap, uv );\n\t#else\n\t\tvec4 matcapColor = vec4( vec3( mix( 0.2, 0.8, uv.y ) ), 1.0 );\n\t#endif\n\tvec3 outgoingLight = diffuseColor.rgb * matcapColor.rgb;\n\t#include <output_fragment>\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}",meshnormal_vert:"#define NORMAL\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )\n\tvarying vec3 vViewPosition;\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <normal_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <normal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )\n\tvViewPosition = - mvPosition.xyz;\n#endif\n}",meshnormal_frag:"#define NORMAL\nuniform float opacity;\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )\n\tvarying vec3 vViewPosition;\n#endif\n#include <packing>\n#include <uv_pars_fragment>\n#include <normal_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\t#include <logdepthbuf_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\tgl_FragColor = vec4( packNormalToRGB( normal ), opacity );\n}",meshphong_vert:"#define PHONG\nvarying vec3 vViewPosition;\n#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <envmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <normal_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <normal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvViewPosition = - mvPosition.xyz;\n\t#include <worldpos_vertex>\n\t#include <envmap_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}",meshphong_frag:"#define PHONG\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform vec3 specular;\nuniform float shininess;\nuniform float opacity;\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <envmap_common_pars_fragment>\n#include <envmap_pars_fragment>\n#include <cube_uv_reflection_fragment>\n#include <fog_pars_fragment>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <normal_pars_fragment>\n#include <lights_phong_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <specularmap_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\t#include <emissivemap_fragment>\n\t#include <lights_phong_fragment>\n\t#include <lights_fragment_begin>\n\t#include <lights_fragment_maps>\n\t#include <lights_fragment_end>\n\t#include <aomap_fragment>\n\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance;\n\t#include <envmap_fragment>\n\t#include <output_fragment>\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}",meshphysical_vert:"#define STANDARD\nvarying vec3 vViewPosition;\n#ifdef USE_TRANSMISSION\n\tvarying vec3 vWorldPosition;\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <normal_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <normal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvViewPosition = - mvPosition.xyz;\n\t#include <worldpos_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n#ifdef USE_TRANSMISSION\n\tvWorldPosition = worldPosition.xyz;\n#endif\n}",meshphysical_frag:"#define STANDARD\n#ifdef PHYSICAL\n\t#define IOR\n\t#define SPECULAR\n#endif\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float roughness;\nuniform float metalness;\nuniform float opacity;\n#ifdef IOR\n\tuniform float ior;\n#endif\n#ifdef SPECULAR\n\tuniform float specularIntensity;\n\tuniform vec3 specularColor;\n\t#ifdef USE_SPECULARINTENSITYMAP\n\t\tuniform sampler2D specularIntensityMap;\n\t#endif\n\t#ifdef USE_SPECULARCOLORMAP\n\t\tuniform sampler2D specularColorMap;\n\t#endif\n#endif\n#ifdef USE_CLEARCOAT\n\tuniform float clearcoat;\n\tuniform float clearcoatRoughness;\n#endif\n#ifdef USE_SHEEN\n\tuniform vec3 sheenColor;\n\tuniform float sheenRoughness;\n\t#ifdef USE_SHEENCOLORMAP\n\t\tuniform sampler2D sheenColorMap;\n\t#endif\n\t#ifdef USE_SHEENROUGHNESSMAP\n\t\tuniform sampler2D sheenRoughnessMap;\n\t#endif\n#endif\nvarying vec3 vViewPosition;\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <bsdfs>\n#include <cube_uv_reflection_fragment>\n#include <envmap_common_pars_fragment>\n#include <envmap_physical_pars_fragment>\n#include <fog_pars_fragment>\n#include <lights_pars_begin>\n#include <normal_pars_fragment>\n#include <lights_physical_pars_fragment>\n#include <transmission_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <clearcoat_pars_fragment>\n#include <roughnessmap_pars_fragment>\n#include <metalnessmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <roughnessmap_fragment>\n\t#include <metalnessmap_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\t#include <clearcoat_normal_fragment_begin>\n\t#include <clearcoat_normal_fragment_maps>\n\t#include <emissivemap_fragment>\n\t#include <lights_physical_fragment>\n\t#include <lights_fragment_begin>\n\t#include <lights_fragment_maps>\n\t#include <lights_fragment_end>\n\t#include <aomap_fragment>\n\tvec3 totalDiffuse = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse;\n\tvec3 totalSpecular = reflectedLight.directSpecular + reflectedLight.indirectSpecular;\n\t#include <transmission_fragment>\n\tvec3 outgoingLight = totalDiffuse + totalSpecular + totalEmissiveRadiance;\n\t#ifdef USE_SHEEN\n\t\tfloat sheenEnergyComp = 1.0 - 0.157 * max3( material.sheenColor );\n\t\toutgoingLight = outgoingLight * sheenEnergyComp + sheenSpecular;\n\t#endif\n\t#ifdef USE_CLEARCOAT\n\t\tfloat dotNVcc = saturate( dot( geometry.clearcoatNormal, geometry.viewDir ) );\n\t\tvec3 Fcc = F_Schlick( material.clearcoatF0, material.clearcoatF90, dotNVcc );\n\t\toutgoingLight = outgoingLight * ( 1.0 - material.clearcoat * Fcc ) + clearcoatSpecular * material.clearcoat;\n\t#endif\n\t#include <output_fragment>\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}",meshtoon_vert:"#define TOON\nvarying vec3 vViewPosition;\n#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <normal_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <normal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvViewPosition = - mvPosition.xyz;\n\t#include <worldpos_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}",meshtoon_frag:"#define TOON\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float opacity;\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <gradientmap_pars_fragment>\n#include <fog_pars_fragment>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <normal_pars_fragment>\n#include <lights_toon_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\t#include <emissivemap_fragment>\n\t#include <lights_toon_fragment>\n\t#include <lights_fragment_begin>\n\t#include <lights_fragment_maps>\n\t#include <lights_fragment_end>\n\t#include <aomap_fragment>\n\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;\n\t#include <output_fragment>\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}",points_vert:"uniform float size;\nuniform float scale;\n#include <common>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <color_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <project_vertex>\n\tgl_PointSize = size;\n\t#ifdef USE_SIZEATTENUATION\n\t\tbool isPerspective = isPerspectiveMatrix( projectionMatrix );\n\t\tif ( isPerspective ) gl_PointSize *= ( scale / - mvPosition.z );\n\t#endif\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <worldpos_vertex>\n\t#include <fog_vertex>\n}",points_frag:"uniform vec3 diffuse;\nuniform float opacity;\n#include <common>\n#include <color_pars_fragment>\n#include <map_particle_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <fog_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec3 outgoingLight = vec3( 0.0 );\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <map_particle_fragment>\n\t#include <color_fragment>\n\t#include <alphatest_fragment>\n\toutgoingLight = diffuseColor.rgb;\n\t#include <output_fragment>\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n}",shadow_vert:"#include <common>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\nvoid main() {\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <project_vertex>\n\t#include <worldpos_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}",shadow_frag:"uniform vec3 color;\nuniform float opacity;\n#include <common>\n#include <packing>\n#include <fog_pars_fragment>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <shadowmap_pars_fragment>\n#include <shadowmask_pars_fragment>\nvoid main() {\n\tgl_FragColor = vec4( color, opacity * ( 1.0 - getShadowMask() ) );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n}",sprite_vert:"uniform float rotation;\nuniform vec2 center;\n#include <common>\n#include <uv_pars_vertex>\n#include <fog_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\tvec4 mvPosition = modelViewMatrix * vec4( 0.0, 0.0, 0.0, 1.0 );\n\tvec2 scale;\n\tscale.x = length( vec3( modelMatrix[ 0 ].x, modelMatrix[ 0 ].y, modelMatrix[ 0 ].z ) );\n\tscale.y = length( vec3( modelMatrix[ 1 ].x, modelMatrix[ 1 ].y, modelMatrix[ 1 ].z ) );\n\t#ifndef USE_SIZEATTENUATION\n\t\tbool isPerspective = isPerspectiveMatrix( projectionMatrix );\n\t\tif ( isPerspective ) scale *= - mvPosition.z;\n\t#endif\n\tvec2 alignedPosition = ( position.xy - ( center - vec2( 0.5 ) ) ) * scale;\n\tvec2 rotatedPosition;\n\trotatedPosition.x = cos( rotation ) * alignedPosition.x - sin( rotation ) * alignedPosition.y;\n\trotatedPosition.y = sin( rotation ) * alignedPosition.x + cos( rotation ) * alignedPosition.y;\n\tmvPosition.xy += rotatedPosition;\n\tgl_Position = projectionMatrix * mvPosition;\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <fog_vertex>\n}",sprite_frag:"uniform vec3 diffuse;\nuniform float opacity;\n#include <common>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <fog_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec3 outgoingLight = vec3( 0.0 );\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\toutgoingLight = diffuseColor.rgb;\n\t#include <output_fragment>\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n}"},It={common:{diffuse:{value:new an(16777215)},opacity:{value:1},map:{value:null},uvTransform:{value:new bo},uv2Transform:{value:new bo},alphaMap:{value:null},alphaTest:{value:0}},specularmap:{specularMap:{value:null}},envmap:{envMap:{value:null},flipEnvMap:{value:-1},reflectivity:{value:1},ior:{value:1.5},refractionRatio:{value:.98}},aomap:{aoMap:{value:null},aoMapIntensity:{value:1}},lightmap:{lightMap:{value:null},lightMapIntensity:{value:1}},emissivemap:{emissiveMap:{value:null}},bumpmap:{bumpMap:{value:null},bumpScale:{value:1}},normalmap:{normalMap:{value:null},normalScale:{value:new $e(1,1)}},displacementmap:{displacementMap:{value:null},displacementScale:{value:1},displacementBias:{value:0}},roughnessmap:{roughnessMap:{value:null}},metalnessmap:{metalnessMap:{value:null}},gradientmap:{gradientMap:{value:null}},fog:{fogDensity:{value:25e-5},fogNear:{value:1},fogFar:{value:2e3},fogColor:{value:new an(16777215)}},lights:{ambientLightColor:{value:[]},lightProbe:{value:[]},directionalLights:{value:[],properties:{direction:{},color:{}}},directionalLightShadows:{value:[],properties:{shadowBias:{},shadowNormalBias:{},shadowRadius:{},shadowMapSize:{}}},directionalShadowMap:{value:[]},directionalShadowMatrix:{value:[]},spotLights:{value:[],properties:{color:{},position:{},direction:{},distance:{},coneCos:{},penumbraCos:{},decay:{}}},spotLightShadows:{value:[],properties:{shadowBias:{},shadowNormalBias:{},shadowRadius:{},shadowMapSize:{}}},spotShadowMap:{value:[]},spotShadowMatrix:{value:[]},pointLights:{value:[],properties:{color:{},position:{},decay:{},distance:{}}},pointLightShadows:{value:[],properties:{shadowBias:{},shadowNormalBias:{},shadowRadius:{},shadowMapSize:{},shadowCameraNear:{},shadowCameraFar:{}}},pointShadowMap:{value:[]},pointShadowMatrix:{value:[]},hemisphereLights:{value:[],properties:{direction:{},skyColor:{},groundColor:{}}},rectAreaLights:{value:[],properties:{color:{},position:{},width:{},height:{}}},ltc_1:{value:null},ltc_2:{value:null}},points:{diffuse:{value:new an(16777215)},opacity:{value:1},size:{value:1},scale:{value:1},map:{value:null},alphaMap:{value:null},alphaTest:{value:0},uvTransform:{value:new bo}},sprite:{diffuse:{value:new an(16777215)},opacity:{value:1},center:{value:new $e(.5,.5)},rotation:{value:0},map:{value:null},alphaMap:{value:null},alphaTest:{value:0},uvTransform:{value:new bo}}},qc={basic:{uniforms:Jo([It.common,It.specularmap,It.envmap,It.aomap,It.lightmap,It.fog]),vertexShader:bi.meshbasic_vert,fragmentShader:bi.meshbasic_frag},lambert:{uniforms:Jo([It.common,It.specularmap,It.envmap,It.aomap,It.lightmap,It.emissivemap,It.fog,It.lights,{emissive:{value:new an(0)}}]),vertexShader:bi.meshlambert_vert,fragmentShader:bi.meshlambert_frag},phong:{uniforms:Jo([It.common,It.specularmap,It.envmap,It.aomap,It.lightmap,It.emissivemap,It.bumpmap,It.normalmap,It.displacementmap,It.fog,It.lights,{emissive:{value:new an(0)},specular:{value:new an(1118481)},shininess:{value:30}}]),vertexShader:bi.meshphong_vert,fragmentShader:bi.meshphong_frag},standard:{uniforms:Jo([It.common,It.envmap,It.aomap,It.lightmap,It.emissivemap,It.bumpmap,It.normalmap,It.displacementmap,It.roughnessmap,It.metalnessmap,It.fog,It.lights,{emissive:{value:new an(0)},roughness:{value:1},metalness:{value:0},envMapIntensity:{value:1}}]),vertexShader:bi.meshphysical_vert,fragmentShader:bi.meshphysical_frag},toon:{uniforms:Jo([It.common,It.aomap,It.lightmap,It.emissivemap,It.bumpmap,It.normalmap,It.displacementmap,It.gradientmap,It.fog,It.lights,{emissive:{value:new an(0)}}]),vertexShader:bi.meshtoon_vert,fragmentShader:bi.meshtoon_frag},matcap:{uniforms:Jo([It.common,It.bumpmap,It.normalmap,It.displacementmap,It.fog,{matcap:{value:null}}]),vertexShader:bi.meshmatcap_vert,fragmentShader:bi.meshmatcap_frag},points:{uniforms:Jo([It.points,It.fog]),vertexShader:bi.points_vert,fragmentShader:bi.points_frag},dashed:{uniforms:Jo([It.common,It.fog,{scale:{value:1},dashSize:{value:1},totalSize:{value:2}}]),vertexShader:bi.linedashed_vert,fragmentShader:bi.linedashed_frag},depth:{uniforms:Jo([It.common,It.displacementmap]),vertexShader:bi.depth_vert,fragmentShader:bi.depth_frag},normal:{uniforms:Jo([It.common,It.bumpmap,It.normalmap,It.displacementmap,{opacity:{value:1}}]),vertexShader:bi.meshnormal_vert,fragmentShader:bi.meshnormal_frag},sprite:{uniforms:Jo([It.sprite,It.fog]),vertexShader:bi.sprite_vert,fragmentShader:bi.sprite_frag},background:{uniforms:{uvTransform:{value:new bo},t2D:{value:null}},vertexShader:bi.background_vert,fragmentShader:bi.background_frag},cube:{uniforms:Jo([It.envmap,{opacity:{value:1}}]),vertexShader:bi.cube_vert,fragmentShader:bi.cube_frag},equirect:{uniforms:{tEquirect:{value:null}},vertexShader:bi.equirect_vert,fragmentShader:bi.equirect_frag},distanceRGBA:{uniforms:Jo([It.common,It.displacementmap,{referencePosition:{value:new $},nearDistance:{value:1},farDistance:{value:1e3}}]),vertexShader:bi.distanceRGBA_vert,fragmentShader:bi.distanceRGBA_frag},shadow:{uniforms:Jo([It.lights,It.fog,{color:{value:new an(0)},opacity:{value:1}}]),vertexShader:bi.shadow_vert,fragmentShader:bi.shadow_frag}};function pke(n,t,e,i,r,o){let l,c,s=new an(0),a=!0===r?0:1,d=null,u=0,p=null;function m(b,M){e.buffers.color.setClear(b.r,b.g,b.b,M,o)}return{getClearColor:function(){return s},setClearColor:function(b,M=1){s.set(b),a=M,m(s,a)},getClearAlpha:function(){return a},setClearAlpha:function(b){a=b,m(s,a)},render:function(b,M){let y=!1,x=!0===M.isScene?M.background:null;x&&x.isTexture&&(x=t.get(x));let R=n.xr,A=R.getSession&&R.getSession();A&&"additive"===A.environmentBlendMode&&(x=null),null===x?m(s,a):x&&x.isColor&&(m(x,1),y=!0),(n.autoClear||y)&&n.clear(n.autoClearColor,n.autoClearDepth,n.autoClearStencil),x&&(x.isCubeTexture||x.mapping===XI)?(void 0===c&&(c=new ao(new fm(1,1,1),new Gd({name:"BackgroundCubeMaterial",uniforms:X0(qc.cube.uniforms),vertexShader:qc.cube.vertexShader,fragmentShader:qc.cube.fragmentShader,side:go,depthTest:!1,depthWrite:!1,fog:!1})),c.geometry.deleteAttribute("normal"),c.geometry.deleteAttribute("uv"),c.onBeforeRender=function(V,te,K){this.matrixWorld.copyPosition(K.matrixWorld)},Object.defineProperty(c.material,"envMap",{get:function(){return this.uniforms.envMap.value}}),i.update(c)),c.material.uniforms.envMap.value=x,c.material.uniforms.flipEnvMap.value=x.isCubeTexture&&!1===x.isRenderTargetTexture?-1:1,(d!==x||u!==x.version||p!==n.toneMapping)&&(c.material.needsUpdate=!0,d=x,u=x.version,p=n.toneMapping),b.unshift(c,c.geometry,c.material,0,0,null)):x&&x.isTexture&&(void 0===l&&(l=new ao(new Tx(2,2),new Gd({name:"BackgroundMaterial",uniforms:X0(qc.background.uniforms),vertexShader:qc.background.vertexShader,fragmentShader:qc.background.fragmentShader,side:yx,depthTest:!1,depthWrite:!1,fog:!1})),l.geometry.deleteAttribute("normal"),Object.defineProperty(l.material,"map",{get:function(){return this.uniforms.t2D.value}}),i.update(l)),l.material.uniforms.t2D.value=x,!0===x.matrixAutoUpdate&&x.updateMatrix(),l.material.uniforms.uvTransform.value.copy(x.matrix),(d!==x||u!==x.version||p!==n.toneMapping)&&(l.material.needsUpdate=!0,d=x,u=x.version,p=n.toneMapping),b.unshift(l,l.geometry,l.material,0,0,null))}}}function fke(n,t,e,i){let r=n.getParameter(34921),o=i.isWebGL2?null:t.get("OES_vertex_array_object"),s=i.isWebGL2||null!==o,a={},l=b(null),c=l;function p(ce){return i.isWebGL2?n.bindVertexArray(ce):o.bindVertexArrayOES(ce)}function f(ce){return i.isWebGL2?n.deleteVertexArray(ce):o.deleteVertexArrayOES(ce)}function b(ce){let fe=[],be=[],ne=[];for(let de=0;de<r;de++)fe[de]=0,be[de]=0,ne[de]=0;return{geometry:null,program:null,wireframe:!1,newAttributes:fe,enabledAttributes:be,attributeDivisors:ne,object:ce,attributes:{},index:null}}function x(){let ce=c.newAttributes;for(let fe=0,be=ce.length;fe<be;fe++)ce[fe]=0}function R(ce){A(ce,0)}function A(ce,fe){let ne=c.enabledAttributes,de=c.attributeDivisors;c.newAttributes[ce]=1,0===ne[ce]&&(n.enableVertexAttribArray(ce),ne[ce]=1),de[ce]!==fe&&((i.isWebGL2?n:t.get("ANGLE_instanced_arrays"))[i.isWebGL2?"vertexAttribDivisor":"vertexAttribDivisorANGLE"](ce,fe),de[ce]=fe)}function V(){let ce=c.newAttributes,fe=c.enabledAttributes;for(let be=0,ne=fe.length;be<ne;be++)fe[be]!==ce[be]&&(n.disableVertexAttribArray(be),fe[be]=0)}function te(ce,fe,be,ne,de,pe){!0!==i.isWebGL2||5124!==be&&5125!==be?n.vertexAttribPointer(ce,fe,be,ne,de,pe):n.vertexAttribIPointer(ce,fe,be,de,pe)}function D(){re(),c!==l&&(c=l,p(c.object))}function re(){l.geometry=null,l.program=null,l.wireframe=!1}return{setup:function(ce,fe,be,ne,de){let pe=!1;if(s){let je=function(ce,fe,be){let ne=!0===be.wireframe,de=a[ce.id];void 0===de&&(de={},a[ce.id]=de);let pe=de[fe.id];void 0===pe&&(pe={},de[fe.id]=pe);let je=pe[ne];return void 0===je&&(je=b(i.isWebGL2?n.createVertexArray():o.createVertexArrayOES()),pe[ne]=je),je}(ne,be,fe);c!==je&&(c=je,p(c.object)),pe=function(ce,fe){let be=c.attributes,ne=ce.attributes,de=0;for(let pe in ne){let je=be[pe],Ce=ne[pe];if(void 0===je||je.attribute!==Ce||je.data!==Ce.data)return!0;de++}return c.attributesNum!==de||c.index!==fe}(ne,de),pe&&function(ce,fe){let be={},ne=ce.attributes,de=0;for(let pe in ne){let je=ne[pe],Ce={};Ce.attribute=je,je.data&&(Ce.data=je.data),be[pe]=Ce,de++}c.attributes=be,c.attributesNum=de,c.index=fe}(ne,de)}else{let je=!0===fe.wireframe;(c.geometry!==ne.id||c.program!==be.id||c.wireframe!==je)&&(c.geometry=ne.id,c.program=be.id,c.wireframe=je,pe=!0)}!0===ce.isInstancedMesh&&(pe=!0),null!==de&&e.update(de,34963),pe&&(function(ce,fe,be,ne){if(!1===i.isWebGL2&&(ce.isInstancedMesh||ne.isInstancedBufferGeometry)&&null===t.get("ANGLE_instanced_arrays"))return;x();let de=ne.attributes,pe=be.getAttributes(),je=fe.defaultAttributeValues;for(let Ce in pe){let Ne=pe[Ce];if(Ne.location>=0){let lt=de[Ce];if(void 0===lt&&("instanceMatrix"===Ce&&ce.instanceMatrix&&(lt=ce.instanceMatrix),"instanceColor"===Ce&&ce.instanceColor&&(lt=ce.instanceColor)),void 0!==lt){let Mt=lt.normalized,pt=lt.itemSize,Oe=e.get(lt);if(void 0===Oe)continue;let An=Oe.buffer,wt=Oe.type,on=Oe.bytesPerElement;if(lt.isInterleavedBufferAttribute){let ve=lt.data,mt=ve.stride,ft=lt.offset;if(ve&&ve.isInstancedInterleavedBuffer){for(let oe=0;oe<Ne.locationSize;oe++)A(Ne.location+oe,ve.meshPerAttribute);!0!==ce.isInstancedMesh&&void 0===ne._maxInstanceCount&&(ne._maxInstanceCount=ve.meshPerAttribute*ve.count)}else for(let oe=0;oe<Ne.locationSize;oe++)R(Ne.location+oe);n.bindBuffer(34962,An);for(let oe=0;oe<Ne.locationSize;oe++)te(Ne.location+oe,pt/Ne.locationSize,wt,Mt,mt*on,(ft+pt/Ne.locationSize*oe)*on)}else{if(lt.isInstancedBufferAttribute){for(let ve=0;ve<Ne.locationSize;ve++)A(Ne.location+ve,lt.meshPerAttribute);!0!==ce.isInstancedMesh&&void 0===ne._maxInstanceCount&&(ne._maxInstanceCount=lt.meshPerAttribute*lt.count)}else for(let ve=0;ve<Ne.locationSize;ve++)R(Ne.location+ve);n.bindBuffer(34962,An);for(let ve=0;ve<Ne.locationSize;ve++)te(Ne.location+ve,pt/Ne.locationSize,wt,Mt,pt*on,pt/Ne.locationSize*ve*on)}}else if(void 0!==je){let Mt=je[Ce];if(void 0!==Mt)switch(Mt.length){case 2:n.vertexAttrib2fv(Ne.location,Mt);break;case 3:n.vertexAttrib3fv(Ne.location,Mt);break;case 4:n.vertexAttrib4fv(Ne.location,Mt);break;default:n.vertexAttrib1fv(Ne.location,Mt)}}}}V()}(ce,fe,be,ne),null!==de&&n.bindBuffer(34963,e.get(de).buffer))},reset:D,resetDefaultState:re,dispose:function(){D();for(let ce in a){let fe=a[ce];for(let be in fe){let ne=fe[be];for(let de in ne)f(ne[de].object),delete ne[de];delete fe[be]}delete a[ce]}},releaseStatesOfGeometry:function(ce){if(void 0===a[ce.id])return;let fe=a[ce.id];for(let be in fe){let ne=fe[be];for(let de in ne)f(ne[de].object),delete ne[de];delete fe[be]}delete a[ce.id]},releaseStatesOfProgram:function(ce){for(let fe in a){let be=a[fe];if(void 0===be[ce.id])continue;let ne=be[ce.id];for(let de in ne)f(ne[de].object),delete ne[de];delete be[ce.id]}},initAttributes:x,enableAttribute:R,disableUnusedAttributes:V}}function mke(n,t,e,i){let o,r=i.isWebGL2;this.setMode=function(c){o=c},this.render=function(c,d){n.drawArrays(o,c,d),e.update(d,o,1)},this.renderInstances=function(c,d,u){if(0===u)return;let p,f;if(r)p=n,f="drawArraysInstanced";else if(p=t.get("ANGLE_instanced_arrays"),f="drawArraysInstancedANGLE",null===p)return void console.error("THREE.WebGLBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.");p[f](o,c,d,u),e.update(d,o,u)}}function hke(n,t,e){let i;function o(K){if("highp"===K){if(n.getShaderPrecisionFormat(35633,36338).precision>0&&n.getShaderPrecisionFormat(35632,36338).precision>0)return"highp";K="mediump"}return"mediump"===K&&n.getShaderPrecisionFormat(35633,36337).precision>0&&n.getShaderPrecisionFormat(35632,36337).precision>0?"mediump":"lowp"}let s=typeof WebGL2RenderingContext<"u"&&n instanceof WebGL2RenderingContext||typeof WebGL2ComputeRenderingContext<"u"&&n instanceof WebGL2ComputeRenderingContext,a=void 0!==e.precision?e.precision:"highp",l=o(a);l!==a&&(console.warn("THREE.WebGLRenderer:",a,"not supported, using",l,"instead."),a=l);let c=s||t.has("WEBGL_draw_buffers"),d=!0===e.logarithmicDepthBuffer,u=n.getParameter(34930),p=n.getParameter(35660),f=n.getParameter(3379),m=n.getParameter(34076),b=n.getParameter(34921),M=n.getParameter(36347),y=n.getParameter(36348),x=n.getParameter(36349),R=p>0,A=s||t.has("OES_texture_float");return{isWebGL2:s,drawBuffers:c,getMaxAnisotropy:function(){if(void 0!==i)return i;if(!0===t.has("EXT_texture_filter_anisotropic")){let K=t.get("EXT_texture_filter_anisotropic");i=n.getParameter(K.MAX_TEXTURE_MAX_ANISOTROPY_EXT)}else i=0;return i},getMaxPrecision:o,precision:a,logarithmicDepthBuffer:d,maxTextures:u,maxVertexTextures:p,maxTextureSize:f,maxCubemapSize:m,maxAttributes:b,maxVertexUniforms:M,maxVaryings:y,maxFragmentUniforms:x,vertexTextures:R,floatFragmentTextures:A,floatVertexTextures:R&&A,maxSamples:s?n.getParameter(36183):0}}function gke(n){let t=this,e=null,i=0,r=!1,o=!1,s=new Kl,a=new bo,l={value:null,needsUpdate:!1};function c(){l.value!==e&&(l.value=e,l.needsUpdate=i>0),t.numPlanes=i,t.numIntersection=0}function d(u,p,f,m){let b=null!==u?u.length:0,M=null;if(0!==b){if(M=l.value,!0!==m||null===M){let y=f+4*b,x=p.matrixWorldInverse;a.getNormalMatrix(x),(null===M||M.length<y)&&(M=new Float32Array(y));for(let R=0,A=f;R!==b;++R,A+=4)s.copy(u[R]).applyMatrix4(x,a),s.normal.toArray(M,A),M[A+3]=s.constant}l.value=M,l.needsUpdate=!0}return t.numPlanes=b,t.numIntersection=0,M}this.uniform=l,this.numPlanes=0,this.numIntersection=0,this.init=function(u,p,f){let m=0!==u.length||p||0!==i||r;return r=p,e=d(u,f,0),i=u.length,m},this.beginShadows=function(){o=!0,d(null)},this.endShadows=function(){o=!1,c()},this.setState=function(u,p,f){let m=u.clippingPlanes,b=u.clipIntersection,M=u.clipShadows,y=n.get(u);if(!r||null===m||0===m.length||o&&!M)o?d(null):c();else{let x=o?0:i,R=4*x,A=y.clippingState||null;l.value=A,A=d(m,p,R,f);for(let V=0;V!==R;++V)A[V]=e[V];y.clippingState=A,this.numIntersection=b?this.numPlanes:0,this.numPlanes+=x}}}function _ke(n){let t=new WeakMap;function e(s,a){return a===K3?s.mapping=Wx:a===J3&&(s.mapping=qx),s}function r(s){let a=s.target;a.removeEventListener("dispose",r);let l=t.get(a);void 0!==l&&(t.delete(a),l.dispose())}return{get:function(s){if(s&&s.isTexture&&!1===s.isRenderTargetTexture){let a=s.mapping;if(a===K3||a===J3){if(t.has(s))return e(t.get(s).texture,s.mapping);{let l=s.image;if(l&&l.height>0){let c=new SI(l.height/2);return c.fromEquirectangularTexture(n,s),t.set(s,c),s.addEventListener("dispose",r),e(c.texture,s.mapping)}return null}}}return s},dispose:function(){t=new WeakMap}}}qc.physical={uniforms:Jo([qc.standard.uniforms,{clearcoat:{value:0},clearcoatMap:{value:null},clearcoatRoughness:{value:0},clearcoatRoughnessMap:{value:null},clearcoatNormalScale:{value:new $e(1,1)},clearcoatNormalMap:{value:null},sheen:{value:0},sheenColor:{value:new an(0)},sheenColorMap:{value:null},sheenRoughness:{value:1},sheenRoughnessMap:{value:null},transmission:{value:0},transmissionMap:{value:null},transmissionSamplerSize:{value:new $e},transmissionSamplerMap:{value:null},thickness:{value:0},thicknessMap:{value:null},attenuationDistance:{value:0},attenuationColor:{value:new an(0)},specularIntensity:{value:1},specularIntensityMap:{value:null},specularColor:{value:new an(1,1,1)},specularColorMap:{value:null}}]),vertexShader:bi.meshphysical_vert,fragmentShader:bi.meshphysical_frag};var mm=class extends Sx{constructor(t=-1,e=1,i=1,r=-1,o=.1,s=2e3){super(),this.type="OrthographicCamera",this.zoom=1,this.view=null,this.left=t,this.right=e,this.top=i,this.bottom=r,this.near=o,this.far=s,this.updateProjectionMatrix()}copy(t,e){return super.copy(t,e),this.left=t.left,this.right=t.right,this.top=t.top,this.bottom=t.bottom,this.near=t.near,this.far=t.far,this.zoom=t.zoom,this.view=null===t.view?null:Object.assign({},t.view),this}setViewOffset(t,e,i,r,o,s){null===this.view&&(this.view={enabled:!0,fullWidth:1,fullHeight:1,offsetX:0,offsetY:0,width:1,height:1}),this.view.enabled=!0,this.view.fullWidth=t,this.view.fullHeight=e,this.view.offsetX=i,this.view.offsetY=r,this.view.width=o,this.view.height=s,this.updateProjectionMatrix()}clearViewOffset(){null!==this.view&&(this.view.enabled=!1),this.updateProjectionMatrix()}updateProjectionMatrix(){let t=(this.right-this.left)/(2*this.zoom),e=(this.top-this.bottom)/(2*this.zoom),i=(this.right+this.left)/2,r=(this.top+this.bottom)/2,o=i-t,s=i+t,a=r+e,l=r-e;if(null!==this.view&&this.view.enabled){let c=(this.right-this.left)/this.view.fullWidth/this.zoom,d=(this.top-this.bottom)/this.view.fullHeight/this.zoom;o+=c*this.view.offsetX,s=o+c*this.view.width,a-=d*this.view.offsetY,l=a-d*this.view.height}this.projectionMatrix.makeOrthographic(o,s,a,l,this.near,this.far),this.projectionMatrixInverse.copy(this.projectionMatrix).invert()}toJSON(t){let e=super.toJSON(t);return e.object.zoom=this.zoom,e.object.left=this.left,e.object.right=this.right,e.object.top=this.top,e.object.bottom=this.bottom,e.object.near=this.near,e.object.far=this.far,null!==this.view&&(e.object.view=Object.assign({},this.view)),e}};mm.prototype.isOrthographicCamera=!0;var K0=class extends Gd{constructor(t){super(t),this.type="RawShaderMaterial"}};K0.prototype.isRawShaderMaterial=!0;var W0=4,hp=8,Wc=Math.pow(2,hp),Kee=[.125,.215,.35,.446,.526,.582],Jee=hp-W0+1+Kee.length,H3=new mm,{_lodPlanes:lx,_sizeLods:Z$,_sigmas:nI}=bke(),K$=new an,z3=null,lm=(1+Math.sqrt(5))/2,O0=1/lm,J$=[new $(1,1,1),new $(-1,1,1),new $(1,1,-1),new $(-1,1,-1),new $(0,lm,O0),new $(0,lm,-O0),new $(O0,0,lm),new $(-O0,0,lm),new $(lm,O0,0),new $(-lm,O0,0)],EI=class{constructor(t){this._renderer=t,this._pingPongRenderTarget=null,this._blurMaterial=function(n){let t=new Float32Array(20),e=new $(0,1,0);return new K0({name:"SphericalGaussianBlur",defines:{n:20},uniforms:{envMap:{value:null},samples:{value:1},weights:{value:t},latitudinal:{value:!1},dTheta:{value:0},mipInt:{value:0},poleAxis:{value:e}},vertexShader:"\n\n\t\tprecision mediump float;\n\t\tprecision mediump int;\n\n\t\tattribute vec3 position;\n\t\tattribute vec2 uv;\n\t\tattribute float faceIndex;\n\n\t\tvarying vec3 vOutputDirection;\n\n\t\t// RH coordinate system; PMREM face-indexing convention\n\t\tvec3 getDirection( vec2 uv, float face ) {\n\n\t\t\tuv = 2.0 * uv - 1.0;\n\n\t\t\tvec3 direction = vec3( uv, 1.0 );\n\n\t\t\tif ( face == 0.0 ) {\n\n\t\t\t\tdirection = direction.zyx; // ( 1, v, u ) pos x\n\n\t\t\t} else if ( face == 1.0 ) {\n\n\t\t\t\tdirection = direction.xzy;\n\t\t\t\tdirection.xz *= -1.0; // ( -u, 1, -v ) pos y\n\n\t\t\t} else if ( face == 2.0 ) {\n\n\t\t\t\tdirection.x *= -1.0; // ( -u, v, 1 ) pos z\n\n\t\t\t} else if ( face == 3.0 ) {\n\n\t\t\t\tdirection = direction.zyx;\n\t\t\t\tdirection.xz *= -1.0; // ( -1, v, -u ) neg x\n\n\t\t\t} else if ( face == 4.0 ) {\n\n\t\t\t\tdirection = direction.xzy;\n\t\t\t\tdirection.xy *= -1.0; // ( -u, -1, v ) neg y\n\n\t\t\t} else if ( face == 5.0 ) {\n\n\t\t\t\tdirection.z *= -1.0; // ( u, v, -1 ) neg z\n\n\t\t\t}\n\n\t\t\treturn direction;\n\n\t\t}\n\n\t\tvoid main() {\n\n\t\t\tvOutputDirection = getDirection( uv, faceIndex );\n\t\t\tgl_Position = vec4( position, 1.0 );\n\n\t\t}\n\t",fragmentShader:"\n\n\t\t\tprecision mediump float;\n\t\t\tprecision mediump int;\n\n\t\t\tvarying vec3 vOutputDirection;\n\n\t\t\tuniform sampler2D envMap;\n\t\t\tuniform int samples;\n\t\t\tuniform float weights[ n ];\n\t\t\tuniform bool latitudinal;\n\t\t\tuniform float dTheta;\n\t\t\tuniform float mipInt;\n\t\t\tuniform vec3 poleAxis;\n\n\t\t\t#define ENVMAP_TYPE_CUBE_UV\n\t\t\t#include <cube_uv_reflection_fragment>\n\n\t\t\tvec3 getSample( float theta, vec3 axis ) {\n\n\t\t\t\tfloat cosTheta = cos( theta );\n\t\t\t\t// Rodrigues' axis-angle rotation\n\t\t\t\tvec3 sampleDirection = vOutputDirection * cosTheta\n\t\t\t\t\t+ cross( axis, vOutputDirection ) * sin( theta )\n\t\t\t\t\t+ axis * dot( axis, vOutputDirection ) * ( 1.0 - cosTheta );\n\n\t\t\t\treturn bilinearCubeUV( envMap, sampleDirection, mipInt );\n\n\t\t\t}\n\n\t\t\tvoid main() {\n\n\t\t\t\tvec3 axis = latitudinal ? poleAxis : cross( poleAxis, vOutputDirection );\n\n\t\t\t\tif ( all( equal( axis, vec3( 0.0 ) ) ) ) {\n\n\t\t\t\t\taxis = vec3( vOutputDirection.z, 0.0, - vOutputDirection.x );\n\n\t\t\t\t}\n\n\t\t\t\taxis = normalize( axis );\n\n\t\t\t\tgl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 );\n\t\t\t\tgl_FragColor.rgb += weights[ 0 ] * getSample( 0.0, axis );\n\n\t\t\t\tfor ( int i = 1; i < n; i++ ) {\n\n\t\t\t\t\tif ( i >= samples ) {\n\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t}\n\n\t\t\t\t\tfloat theta = dTheta * float( i );\n\t\t\t\t\tgl_FragColor.rgb += weights[ i ] * getSample( -1.0 * theta, axis );\n\t\t\t\t\tgl_FragColor.rgb += weights[ i ] * getSample( theta, axis );\n\n\t\t\t\t}\n\n\t\t\t}\n\t\t",blending:pp,depthTest:!1,depthWrite:!1})}(),this._equirectShader=null,this._cubemapShader=null,this._compileMaterial(this._blurMaterial)}fromScene(t,e=0,i=.1,r=100){z3=this._renderer.getRenderTarget();let o=this._allocateTargets();return this._sceneToCubeUV(t,i,r,o),e>0&&this._blur(o,0,0,e),this._applyPMREM(o),this._cleanup(o),o}fromEquirectangular(t,e=null){return this._fromTexture(t,e)}fromCubemap(t,e=null){return this._fromTexture(t,e)}compileCubemapShader(){null===this._cubemapShader&&(this._cubemapShader=tee(),this._compileMaterial(this._cubemapShader))}compileEquirectangularShader(){null===this._equirectShader&&(this._equirectShader=eee(),this._compileMaterial(this._equirectShader))}dispose(){this._blurMaterial.dispose(),null!==this._pingPongRenderTarget&&this._pingPongRenderTarget.dispose(),null!==this._cubemapShader&&this._cubemapShader.dispose(),null!==this._equirectShader&&this._equirectShader.dispose();for(let t=0;t<lx.length;t++)lx[t].dispose()}_cleanup(t){this._renderer.setRenderTarget(z3),t.scissorTest=!1,iI(t,0,0,t.width,t.height)}_fromTexture(t,e){z3=this._renderer.getRenderTarget();let i=e||this._allocateTargets(t);return this._textureToCubeUV(t,i),this._applyPMREM(i),this._cleanup(i),i}_allocateTargets(t){let e={magFilter:$o,minFilter:$o,generateMipmaps:!1,type:U0,format:gs,encoding:_p,depthBuffer:!1},i=$$(e);return i.depthBuffer=!t,null===this._pingPongRenderTarget&&(this._pingPongRenderTarget=$$(e)),i}_compileMaterial(t){let e=new ao(lx[0],t);this._renderer.compile(e,H3)}_sceneToCubeUV(t,e,i,r){let a=new es(90,1,e,i),l=[1,-1,1,1,1,1],c=[1,1,1,-1,-1,-1],d=this._renderer,u=d.autoClear,p=d.toneMapping;d.getClearColor(K$),d.toneMapping=fp,d.autoClear=!1;let f=new pm({name:"PMREM.Background",side:go,depthWrite:!1,depthTest:!1}),m=new ao(new fm,f),b=!1,M=t.background;M?M.isColor&&(f.color.copy(M),t.background=null,b=!0):(f.color.copy(K$),b=!0);for(let y=0;y<6;y++){let x=y%3;0===x?(a.up.set(0,l[y],0),a.lookAt(c[y],0,0)):1===x?(a.up.set(0,0,l[y]),a.lookAt(0,c[y],0)):(a.up.set(0,l[y],0),a.lookAt(0,0,c[y])),iI(r,x*Wc,y>2?Wc:0,Wc,Wc),d.setRenderTarget(r),b&&d.render(m,a),d.render(t,a)}m.geometry.dispose(),m.material.dispose(),d.toneMapping=p,d.autoClear=u,t.background=M}_textureToCubeUV(t,e){let i=this._renderer,r=t.mapping===Wx||t.mapping===qx;r?(null===this._cubemapShader&&(this._cubemapShader=tee()),this._cubemapShader.uniforms.flipEnvMap.value=!1===t.isRenderTargetTexture?-1:1):null===this._equirectShader&&(this._equirectShader=eee());let o=r?this._cubemapShader:this._equirectShader,s=new ao(lx[0],o),a=o.uniforms;a.envMap.value=t,r||a.texelSize.value.set(1/t.image.width,1/t.image.height),iI(e,0,0,3*Wc,2*Wc),i.setRenderTarget(e),i.render(s,H3)}_applyPMREM(t){let e=this._renderer,i=e.autoClear;e.autoClear=!1;for(let r=1;r<Jee;r++){let o=Math.sqrt(nI[r]*nI[r]-nI[r-1]*nI[r-1]);this._blur(t,r-1,r,o,J$[(r-1)%J$.length])}e.autoClear=i}_blur(t,e,i,r,o){let s=this._pingPongRenderTarget;this._halfBlur(t,s,e,i,r,"latitudinal",o),this._halfBlur(s,t,i,i,r,"longitudinal",o)}_halfBlur(t,e,i,r,o,s,a){let l=this._renderer,c=this._blurMaterial;"latitudinal"!==s&&"longitudinal"!==s&&console.error("blur direction must be either latitudinal or longitudinal!");let u=new ao(lx[r],c),p=c.uniforms,f=Z$[i]-1,m=isFinite(o)?Math.PI/(2*f):2*Math.PI/39,b=o/m,M=isFinite(o)?1+Math.floor(3*b):20;M>20&&console.warn(`sigmaRadians, ${o}, is too large and will clip, as it requested ${M} samples when the maximum is set to 20`);let y=[],x=0;for(let te=0;te<20;++te){let K=te/b,xe=Math.exp(-K*K/2);y.push(xe),0===te?x+=xe:te<M&&(x+=2*xe)}for(let te=0;te<y.length;te++)y[te]=y[te]/x;p.envMap.value=t.texture,p.samples.value=M,p.weights.value=y,p.latitudinal.value="latitudinal"===s,a&&(p.poleAxis.value=a),p.dTheta.value=m,p.mipInt.value=hp-i;let R=Z$[r];iI(e,3*Math.max(0,Wc-2*R),(0===r?0:2*Wc)+2*R*(r>hp-W0?r-hp+W0:0),3*R,2*R),l.setRenderTarget(e),l.render(u,H3)}};function bke(){let n=[],t=[],e=[],i=hp;for(let r=0;r<Jee;r++){let o=Math.pow(2,i);t.push(o);let s=1/o;r>hp-W0?s=Kee[r-hp+W0-1]:0===r&&(s=0),e.push(s);let a=1/(o-1),l=-a/2,c=1+a/2,d=[l,l,c,l,c,c,l,l,c,c,l,c],u=6,p=6,f=3,m=2,b=1,M=new Float32Array(f*p*u),y=new Float32Array(m*p*u),x=new Float32Array(b*p*u);for(let A=0;A<u;A++){let V=A%3*2/3-1,te=A>2?0:-1;M.set([V,te,0,V+2/3,te,0,V+2/3,te+1,0,V,te,0,V+2/3,te+1,0,V,te+1,0],f*p*A),y.set(d,m*p*A),x.set([A,A,A,A,A,A],b*p*A)}let R=new Ui;R.setAttribute("position",new Pr(M,f)),R.setAttribute("uv",new Pr(y,m)),R.setAttribute("faceIndex",new Pr(x,b)),n.push(R),i>W0&&i--}return{_lodPlanes:n,_sizeLods:t,_sigmas:e}}function $$(n){let t=new Js(3*Wc,3*Wc,n);return t.texture.mapping=XI,t.texture.name="PMREM.cubeUv",t.scissorTest=!0,t}function iI(n,t,e,i,r){n.viewport.set(t,e,i,r),n.scissor.set(t,e,i,r)}function eee(){let n=new $e(1,1);return new K0({name:"EquirectangularToCubeUV",uniforms:{envMap:{value:null},texelSize:{value:n}},vertexShader:"\n\n\t\tprecision mediump float;\n\t\tprecision mediump int;\n\n\t\tattribute vec3 position;\n\t\tattribute vec2 uv;\n\t\tattribute float faceIndex;\n\n\t\tvarying vec3 vOutputDirection;\n\n\t\t// RH coordinate system; PMREM face-indexing convention\n\t\tvec3 getDirection( vec2 uv, float face ) {\n\n\t\t\tuv = 2.0 * uv - 1.0;\n\n\t\t\tvec3 direction = vec3( uv, 1.0 );\n\n\t\t\tif ( face == 0.0 ) {\n\n\t\t\t\tdirection = direction.zyx; // ( 1, v, u ) pos x\n\n\t\t\t} else if ( face == 1.0 ) {\n\n\t\t\t\tdirection = direction.xzy;\n\t\t\t\tdirection.xz *= -1.0; // ( -u, 1, -v ) pos y\n\n\t\t\t} else if ( face == 2.0 ) {\n\n\t\t\t\tdirection.x *= -1.0; // ( -u, v, 1 ) pos z\n\n\t\t\t} else if ( face == 3.0 ) {\n\n\t\t\t\tdirection = direction.zyx;\n\t\t\t\tdirection.xz *= -1.0; // ( -1, v, -u ) neg x\n\n\t\t\t} else if ( face == 4.0 ) {\n\n\t\t\t\tdirection = direction.xzy;\n\t\t\t\tdirection.xy *= -1.0; // ( -u, -1, v ) neg y\n\n\t\t\t} else if ( face == 5.0 ) {\n\n\t\t\t\tdirection.z *= -1.0; // ( u, v, -1 ) neg z\n\n\t\t\t}\n\n\t\t\treturn direction;\n\n\t\t}\n\n\t\tvoid main() {\n\n\t\t\tvOutputDirection = getDirection( uv, faceIndex );\n\t\t\tgl_Position = vec4( position, 1.0 );\n\n\t\t}\n\t",fragmentShader:"\n\n\t\t\tprecision mediump float;\n\t\t\tprecision mediump int;\n\n\t\t\tvarying vec3 vOutputDirection;\n\n\t\t\tuniform sampler2D envMap;\n\t\t\tuniform vec2 texelSize;\n\n\t\t\t#include <common>\n\n\t\t\tvoid main() {\n\n\t\t\t\tgl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 );\n\n\t\t\t\tvec3 outputDirection = normalize( vOutputDirection );\n\t\t\t\tvec2 uv = equirectUv( outputDirection );\n\n\t\t\t\tvec2 f = fract( uv / texelSize - 0.5 );\n\t\t\t\tuv -= f * texelSize;\n\t\t\t\tvec3 tl = texture2D ( envMap, uv ).rgb;\n\t\t\t\tuv.x += texelSize.x;\n\t\t\t\tvec3 tr = texture2D ( envMap, uv ).rgb;\n\t\t\t\tuv.y += texelSize.y;\n\t\t\t\tvec3 br = texture2D ( envMap, uv ).rgb;\n\t\t\t\tuv.x -= texelSize.x;\n\t\t\t\tvec3 bl = texture2D ( envMap, uv ).rgb;\n\n\t\t\t\tvec3 tm = mix( tl, tr, f.x );\n\t\t\t\tvec3 bm = mix( bl, br, f.x );\n\t\t\t\tgl_FragColor.rgb = mix( tm, bm, f.y );\n\n\t\t\t}\n\t\t",blending:pp,depthTest:!1,depthWrite:!1})}function tee(){return new K0({name:"CubemapToCubeUV",uniforms:{envMap:{value:null},flipEnvMap:{value:-1}},vertexShader:"\n\n\t\tprecision mediump float;\n\t\tprecision mediump int;\n\n\t\tattribute vec3 position;\n\t\tattribute vec2 uv;\n\t\tattribute float faceIndex;\n\n\t\tvarying vec3 vOutputDirection;\n\n\t\t// RH coordinate system; PMREM face-indexing convention\n\t\tvec3 getDirection( vec2 uv, float face ) {\n\n\t\t\tuv = 2.0 * uv - 1.0;\n\n\t\t\tvec3 direction = vec3( uv, 1.0 );\n\n\t\t\tif ( face == 0.0 ) {\n\n\t\t\t\tdirection = direction.zyx; // ( 1, v, u ) pos x\n\n\t\t\t} else if ( face == 1.0 ) {\n\n\t\t\t\tdirection = direction.xzy;\n\t\t\t\tdirection.xz *= -1.0; // ( -u, 1, -v ) pos y\n\n\t\t\t} else if ( face == 2.0 ) {\n\n\t\t\t\tdirection.x *= -1.0; // ( -u, v, 1 ) pos z\n\n\t\t\t} else if ( face == 3.0 ) {\n\n\t\t\t\tdirection = direction.zyx;\n\t\t\t\tdirection.xz *= -1.0; // ( -1, v, -u ) neg x\n\n\t\t\t} else if ( face == 4.0 ) {\n\n\t\t\t\tdirection = direction.xzy;\n\t\t\t\tdirection.xy *= -1.0; // ( -u, -1, v ) neg y\n\n\t\t\t} else if ( face == 5.0 ) {\n\n\t\t\t\tdirection.z *= -1.0; // ( u, v, -1 ) neg z\n\n\t\t\t}\n\n\t\t\treturn direction;\n\n\t\t}\n\n\t\tvoid main() {\n\n\t\t\tvOutputDirection = getDirection( uv, faceIndex );\n\t\t\tgl_Position = vec4( position, 1.0 );\n\n\t\t}\n\t",fragmentShader:"\n\n\t\t\tprecision mediump float;\n\t\t\tprecision mediump int;\n\n\t\t\tuniform float flipEnvMap;\n\n\t\t\tvarying vec3 vOutputDirection;\n\n\t\t\tuniform samplerCube envMap;\n\n\t\t\tvoid main() {\n\n\t\t\t\tgl_FragColor = textureCube( envMap, vec3( flipEnvMap * vOutputDirection.x, vOutputDirection.yz ) );\n\n\t\t\t}\n\t\t",blending:pp,depthTest:!1,depthWrite:!1})}function yke(n){let t=new WeakMap,e=null;function o(a){let l=a.target;l.removeEventListener("dispose",o);let c=t.get(l);void 0!==c&&(t.delete(l),c.dispose())}return{get:function(a){if(a&&a.isTexture){let l=a.mapping,c=l===K3||l===J3,d=l===Wx||l===qx;if(c||d){if(a.isRenderTargetTexture&&!0===a.needsPMREMUpdate){a.needsPMREMUpdate=!1;let u=t.get(a);return null===e&&(e=new EI(n)),u=c?e.fromEquirectangular(a,u):e.fromCubemap(a,u),t.set(a,u),u.texture}if(t.has(a))return t.get(a).texture;{let u=a.image;if(c&&u&&u.height>0||d&&u&&function(a){let l=0;for(let d=0;d<6;d++)void 0!==a[d]&&l++;return 6===l}(u)){null===e&&(e=new EI(n));let p=c?e.fromEquirectangular(a):e.fromCubemap(a);return t.set(a,p),a.addEventListener("dispose",o),p.texture}return null}}}return a},dispose:function(){t=new WeakMap,null!==e&&(e.dispose(),e=null)}}}function xke(n){let t={};function e(i){if(void 0!==t[i])return t[i];let r;switch(i){case"WEBGL_depth_texture":r=n.getExtension("WEBGL_depth_texture")||n.getExtension("MOZ_WEBGL_depth_texture")||n.getExtension("WEBKIT_WEBGL_depth_texture");break;case"EXT_texture_filter_anisotropic":r=n.getExtension("EXT_texture_filter_anisotropic")||n.getExtension("MOZ_EXT_texture_filter_anisotropic")||n.getExtension("WEBKIT_EXT_texture_filter_anisotropic");break;case"WEBGL_compressed_texture_s3tc":r=n.getExtension("WEBGL_compressed_texture_s3tc")||n.getExtension("MOZ_WEBGL_compressed_texture_s3tc")||n.getExtension("WEBKIT_WEBGL_compressed_texture_s3tc");break;case"WEBGL_compressed_texture_pvrtc":r=n.getExtension("WEBGL_compressed_texture_pvrtc")||n.getExtension("WEBKIT_WEBGL_compressed_texture_pvrtc");break;default:r=n.getExtension(i)}return t[i]=r,r}return{has:function(i){return null!==e(i)},init:function(i){i.isWebGL2?e("EXT_color_buffer_float"):(e("WEBGL_depth_texture"),e("OES_texture_float"),e("OES_texture_half_float"),e("OES_texture_half_float_linear"),e("OES_standard_derivatives"),e("OES_element_index_uint"),e("OES_vertex_array_object"),e("ANGLE_instanced_arrays")),e("OES_texture_float_linear"),e("EXT_color_buffer_half_float"),e("WEBGL_multisampled_render_to_texture")},get:function(i){let r=e(i);return null===r&&console.warn("THREE.WebGLRenderer: "+i+" extension not supported."),r}}}function Cke(n,t,e,i){let r={},o=new WeakMap;function s(u){let p=u.target;null!==p.index&&t.remove(p.index);for(let m in p.attributes)t.remove(p.attributes[m]);p.removeEventListener("dispose",s),delete r[p.id];let f=o.get(p);f&&(t.remove(f),o.delete(p)),i.releaseStatesOfGeometry(p),!0===p.isInstancedBufferGeometry&&delete p._maxInstanceCount,e.memory.geometries--}function c(u){let p=[],f=u.index,m=u.attributes.position,b=0;if(null!==f){let x=f.array;b=f.version;for(let R=0,A=x.length;R<A;R+=3){let V=x[R+0],te=x[R+1],K=x[R+2];p.push(V,te,te,K,K,V)}}else{b=m.version;for(let R=0,A=m.array.length/3-1;R<A;R+=3){let V=R+0,te=R+1,K=R+2;p.push(V,te,te,K,K,V)}}let M=new(Qee(p)?wI:MI)(p,1);M.version=b;let y=o.get(u);y&&t.remove(y),o.set(u,M)}return{get:function(u,p){return!0===r[p.id]||(p.addEventListener("dispose",s),r[p.id]=!0,e.memory.geometries++),p},update:function(u){let p=u.attributes;for(let m in p)t.update(p[m],34962);let f=u.morphAttributes;for(let m in f){let b=f[m];for(let M=0,y=b.length;M<y;M++)t.update(b[M],34962)}},getWireframeAttribute:function(u){let p=o.get(u);if(p){let f=u.index;null!==f&&p.version<f.version&&c(u)}else c(u);return o.get(u)}}}function Mke(n,t,e,i){let o,a,l,r=i.isWebGL2;this.setMode=function(p){o=p},this.setIndex=function(p){a=p.type,l=p.bytesPerElement},this.render=function(p,f){n.drawElements(o,f,a,p*l),e.update(f,o,1)},this.renderInstances=function(p,f,m){if(0===m)return;let b,M;if(r)b=n,M="drawElementsInstanced";else if(b=t.get("ANGLE_instanced_arrays"),M="drawElementsInstancedANGLE",null===b)return void console.error("THREE.WebGLIndexedBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.");b[M](o,f,a,p*l,m),e.update(f,o,m)}}function wke(n){let e={frame:0,calls:0,triangles:0,points:0,lines:0};return{memory:{geometries:0,textures:0},render:e,programs:null,autoReset:!0,reset:function(){e.frame++,e.calls=0,e.triangles=0,e.points=0,e.lines=0},update:function(o,s,a){switch(e.calls++,s){case 4:e.triangles+=a*(o/3);break;case 1:e.lines+=a*(o/2);break;case 3:e.lines+=a*(o-1);break;case 2:e.lines+=a*o;break;case 0:e.points+=a*o;break;default:console.error("THREE.WebGLInfo: Unknown draw mode:",s)}}}}var Dx=class extends lo{constructor(t=null,e=1,i=1,r=1){super(null),this.image={data:t,width:e,height:i,depth:r},this.magFilter=_o,this.minFilter=_o,this.wrapR=ya,this.generateMipmaps=!1,this.flipY=!1,this.unpackAlignment=1}};function Ske(n,t){return n[0]-t[0]}function Eke(n,t){return Math.abs(t[1])-Math.abs(n[1])}function nee(n,t){let e=1,i=t.isInterleavedBufferAttribute?t.data.array:t.array;i instanceof Int8Array?e=127:i instanceof Int16Array?e=32767:i instanceof Int32Array?e=2147483647:console.error("THREE.WebGLMorphtargets: Unsupported morph attribute data type: ",i),n.divideScalar(e)}function Tke(n,t,e){let i={},r=new Float32Array(8),o=new WeakMap,s=new $,a=[];for(let c=0;c<8;c++)a[c]=[c,0];return{update:function(c,d,u,p){let f=c.morphTargetInfluences;if(!0===t.isWebGL2){let m=d.morphAttributes.position.length,b=o.get(d);if(void 0===b||b.count!==m){let re=function(){De.dispose(),o.delete(d),d.removeEventListener("dispose",re)};void 0!==b&&b.texture.dispose();let x=void 0!==d.morphAttributes.normal,R=d.morphAttributes.position,A=d.morphAttributes.normal||[],te=!0===x?2:1,K=d.attributes.position.count*te,xe=1;K>t.maxTextureSize&&(xe=Math.ceil(K/t.maxTextureSize),K=t.maxTextureSize);let Xe=new Float32Array(K*xe*4*m),De=new Dx(Xe,K,xe,m);De.format=gs,De.type=cm,De.needsUpdate=!0;let D=4*te;for(let ce=0;ce<m;ce++){let fe=R[ce],be=A[ce],ne=K*xe*4*ce;for(let de=0;de<fe.count;de++){s.fromBufferAttribute(fe,de),!0===fe.normalized&&nee(s,fe);let pe=de*D;Xe[ne+pe+0]=s.x,Xe[ne+pe+1]=s.y,Xe[ne+pe+2]=s.z,Xe[ne+pe+3]=0,!0===x&&(s.fromBufferAttribute(be,de),!0===be.normalized&&nee(s,be),Xe[ne+pe+4]=s.x,Xe[ne+pe+5]=s.y,Xe[ne+pe+6]=s.z,Xe[ne+pe+7]=0)}}b={count:m,texture:De,size:new $e(K,xe)},o.set(d,b),d.addEventListener("dispose",re)}let M=0;for(let x=0;x<f.length;x++)M+=f[x];let y=d.morphTargetsRelative?1:1-M;p.getUniforms().setValue(n,"morphTargetBaseInfluence",y),p.getUniforms().setValue(n,"morphTargetInfluences",f),p.getUniforms().setValue(n,"morphTargetsTexture",b.texture,e),p.getUniforms().setValue(n,"morphTargetsTextureSize",b.size)}else{let m=void 0===f?0:f.length,b=i[d.id];if(void 0===b||b.length!==m){b=[];for(let A=0;A<m;A++)b[A]=[A,0];i[d.id]=b}for(let A=0;A<m;A++){let V=b[A];V[0]=A,V[1]=f[A]}b.sort(Eke);for(let A=0;A<8;A++)A<m&&b[A][1]?(a[A][0]=b[A][0],a[A][1]=b[A][1]):(a[A][0]=Number.MAX_SAFE_INTEGER,a[A][1]=0);a.sort(Ske);let M=d.morphAttributes.position,y=d.morphAttributes.normal,x=0;for(let A=0;A<8;A++){let V=a[A],te=V[0],K=V[1];te!==Number.MAX_SAFE_INTEGER&&K?(M&&d.getAttribute("morphTarget"+A)!==M[te]&&d.setAttribute("morphTarget"+A,M[te]),y&&d.getAttribute("morphNormal"+A)!==y[te]&&d.setAttribute("morphNormal"+A,y[te]),r[A]=K,x+=K):(M&&!0===d.hasAttribute("morphTarget"+A)&&d.deleteAttribute("morphTarget"+A),y&&!0===d.hasAttribute("morphNormal"+A)&&d.deleteAttribute("morphNormal"+A),r[A]=0)}let R=d.morphTargetsRelative?1:1-x;p.getUniforms().setValue(n,"morphTargetBaseInfluence",R),p.getUniforms().setValue(n,"morphTargetInfluences",r)}}}}function Dke(n,t,e,i){let r=new WeakMap;function a(l){let c=l.target;c.removeEventListener("dispose",a),e.remove(c.instanceMatrix),null!==c.instanceColor&&e.remove(c.instanceColor)}return{update:function(l){let c=i.render.frame,u=t.get(l,l.geometry);return r.get(u)!==c&&(t.update(u),r.set(u,c)),l.isInstancedMesh&&(!1===l.hasEventListener("dispose",a)&&l.addEventListener("dispose",a),e.update(l.instanceMatrix,34962),null!==l.instanceColor&&e.update(l.instanceColor,34962)),u},dispose:function(){r=new WeakMap}}}Dx.prototype.isDataTexture2DArray=!0;var TI=class extends lo{constructor(t=null,e=1,i=1,r=1){super(null),this.image={data:t,width:e,height:i,depth:r},this.magFilter=_o,this.minFilter=_o,this.wrapR=ya,this.generateMipmaps=!1,this.flipY=!1,this.unpackAlignment=1}};TI.prototype.isDataTexture3D=!0;var $ee=new lo,ete=new Dx,tte=new TI,nte=new Q0,iee=[],ree=[],oee=new Float32Array(16),see=new Float32Array(9),aee=new Float32Array(4);function s_(n,t,e){let i=n[0];if(i<=0||i>0)return n;let r=t*e,o=iee[r];if(void 0===o&&(o=new Float32Array(r),iee[r]=o),0!==t){i.toArray(o,0);for(let s=1,a=0;s!==t;++s)a+=e,n[s].toArray(o,a)}return o}function _s(n,t){if(n.length!==t.length)return!1;for(let e=0,i=n.length;e<i;e++)if(n[e]!==t[e])return!1;return!0}function ns(n,t){for(let e=0,i=t.length;e<i;e++)n[e]=t[e]}function ZI(n,t){let e=ree[t];void 0===e&&(e=new Int32Array(t),ree[t]=e);for(let i=0;i!==t;++i)e[i]=n.allocateTextureUnit();return e}function Ike(n,t){let e=this.cache;e[0]!==t&&(n.uniform1f(this.addr,t),e[0]=t)}function Ake(n,t){let e=this.cache;if(void 0!==t.x)(e[0]!==t.x||e[1]!==t.y)&&(n.uniform2f(this.addr,t.x,t.y),e[0]=t.x,e[1]=t.y);else{if(_s(e,t))return;n.uniform2fv(this.addr,t),ns(e,t)}}function Rke(n,t){let e=this.cache;if(void 0!==t.x)(e[0]!==t.x||e[1]!==t.y||e[2]!==t.z)&&(n.uniform3f(this.addr,t.x,t.y,t.z),e[0]=t.x,e[1]=t.y,e[2]=t.z);else if(void 0!==t.r)(e[0]!==t.r||e[1]!==t.g||e[2]!==t.b)&&(n.uniform3f(this.addr,t.r,t.g,t.b),e[0]=t.r,e[1]=t.g,e[2]=t.b);else{if(_s(e,t))return;n.uniform3fv(this.addr,t),ns(e,t)}}function Pke(n,t){let e=this.cache;if(void 0!==t.x)(e[0]!==t.x||e[1]!==t.y||e[2]!==t.z||e[3]!==t.w)&&(n.uniform4f(this.addr,t.x,t.y,t.z,t.w),e[0]=t.x,e[1]=t.y,e[2]=t.z,e[3]=t.w);else{if(_s(e,t))return;n.uniform4fv(this.addr,t),ns(e,t)}}function Oke(n,t){let e=this.cache,i=t.elements;if(void 0===i){if(_s(e,t))return;n.uniformMatrix2fv(this.addr,!1,t),ns(e,t)}else{if(_s(e,i))return;aee.set(i),n.uniformMatrix2fv(this.addr,!1,aee),ns(e,i)}}function kke(n,t){let e=this.cache,i=t.elements;if(void 0===i){if(_s(e,t))return;n.uniformMatrix3fv(this.addr,!1,t),ns(e,t)}else{if(_s(e,i))return;see.set(i),n.uniformMatrix3fv(this.addr,!1,see),ns(e,i)}}function Fke(n,t){let e=this.cache,i=t.elements;if(void 0===i){if(_s(e,t))return;n.uniformMatrix4fv(this.addr,!1,t),ns(e,t)}else{if(_s(e,i))return;oee.set(i),n.uniformMatrix4fv(this.addr,!1,oee),ns(e,i)}}function Nke(n,t){let e=this.cache;e[0]!==t&&(n.uniform1i(this.addr,t),e[0]=t)}function Lke(n,t){let e=this.cache;_s(e,t)||(n.uniform2iv(this.addr,t),ns(e,t))}function Bke(n,t){let e=this.cache;_s(e,t)||(n.uniform3iv(this.addr,t),ns(e,t))}function Vke(n,t){let e=this.cache;_s(e,t)||(n.uniform4iv(this.addr,t),ns(e,t))}function Hke(n,t){let e=this.cache;e[0]!==t&&(n.uniform1ui(this.addr,t),e[0]=t)}function zke(n,t){let e=this.cache;_s(e,t)||(n.uniform2uiv(this.addr,t),ns(e,t))}function Uke(n,t){let e=this.cache;_s(e,t)||(n.uniform3uiv(this.addr,t),ns(e,t))}function jke(n,t){let e=this.cache;_s(e,t)||(n.uniform4uiv(this.addr,t),ns(e,t))}function Gke(n,t,e){let i=this.cache,r=e.allocateTextureUnit();i[0]!==r&&(n.uniform1i(this.addr,r),i[0]=r),e.safeSetTexture2D(t||$ee,r)}function Wke(n,t,e){let i=this.cache,r=e.allocateTextureUnit();i[0]!==r&&(n.uniform1i(this.addr,r),i[0]=r),e.setTexture3D(t||tte,r)}function qke(n,t,e){let i=this.cache,r=e.allocateTextureUnit();i[0]!==r&&(n.uniform1i(this.addr,r),i[0]=r),e.safeSetTextureCube(t||nte,r)}function Yke(n,t,e){let i=this.cache,r=e.allocateTextureUnit();i[0]!==r&&(n.uniform1i(this.addr,r),i[0]=r),e.setTexture2DArray(t||ete,r)}function Qke(n,t){n.uniform1fv(this.addr,t)}function Zke(n,t){let e=s_(t,this.size,2);n.uniform2fv(this.addr,e)}function Kke(n,t){let e=s_(t,this.size,3);n.uniform3fv(this.addr,e)}function Jke(n,t){let e=s_(t,this.size,4);n.uniform4fv(this.addr,e)}function $ke(n,t){let e=s_(t,this.size,4);n.uniformMatrix2fv(this.addr,!1,e)}function eFe(n,t){let e=s_(t,this.size,9);n.uniformMatrix3fv(this.addr,!1,e)}function tFe(n,t){let e=s_(t,this.size,16);n.uniformMatrix4fv(this.addr,!1,e)}function nFe(n,t){n.uniform1iv(this.addr,t)}function iFe(n,t){n.uniform2iv(this.addr,t)}function rFe(n,t){n.uniform3iv(this.addr,t)}function oFe(n,t){n.uniform4iv(this.addr,t)}function sFe(n,t){n.uniform1uiv(this.addr,t)}function aFe(n,t){n.uniform2uiv(this.addr,t)}function lFe(n,t){n.uniform3uiv(this.addr,t)}function cFe(n,t){n.uniform4uiv(this.addr,t)}function dFe(n,t,e){let i=t.length,r=ZI(e,i);n.uniform1iv(this.addr,r);for(let o=0;o!==i;++o)e.safeSetTexture2D(t[o]||$ee,r[o])}function uFe(n,t,e){let i=t.length,r=ZI(e,i);n.uniform1iv(this.addr,r);for(let o=0;o!==i;++o)e.setTexture3D(t[o]||tte,r[o])}function pFe(n,t,e){let i=t.length,r=ZI(e,i);n.uniform1iv(this.addr,r);for(let o=0;o!==i;++o)e.safeSetTextureCube(t[o]||nte,r[o])}function fFe(n,t,e){let i=t.length,r=ZI(e,i);n.uniform1iv(this.addr,r);for(let o=0;o!==i;++o)e.setTexture2DArray(t[o]||ete,r[o])}function hFe(n,t,e){this.id=n,this.addr=e,this.cache=[],this.setValue=function(n){switch(n){case 5126:return Ike;case 35664:return Ake;case 35665:return Rke;case 35666:return Pke;case 35674:return Oke;case 35675:return kke;case 35676:return Fke;case 5124:case 35670:return Nke;case 35667:case 35671:return Lke;case 35668:case 35672:return Bke;case 35669:case 35673:return Vke;case 5125:return Hke;case 36294:return zke;case 36295:return Uke;case 36296:return jke;case 35678:case 36198:case 36298:case 36306:case 35682:return Gke;case 35679:case 36299:case 36307:return Wke;case 35680:case 36300:case 36308:case 36293:return qke;case 36289:case 36303:case 36311:case 36292:return Yke}}(t.type)}function ite(n,t,e){this.id=n,this.addr=e,this.cache=[],this.size=t.size,this.setValue=function(n){switch(n){case 5126:return Qke;case 35664:return Zke;case 35665:return Kke;case 35666:return Jke;case 35674:return $ke;case 35675:return eFe;case 35676:return tFe;case 5124:case 35670:return nFe;case 35667:case 35671:return iFe;case 35668:case 35672:return rFe;case 35669:case 35673:return oFe;case 5125:return sFe;case 36294:return aFe;case 36295:return lFe;case 36296:return cFe;case 35678:case 36198:case 36298:case 36306:case 35682:return dFe;case 35679:case 36299:case 36307:return uFe;case 35680:case 36300:case 36308:case 36293:return pFe;case 36289:case 36303:case 36311:case 36292:return fFe}}(t.type)}function rte(n){this.id=n,this.seq=[],this.map={}}ite.prototype.updateCache=function(n){let t=this.cache;n instanceof Float32Array&&t.length!==n.length&&(this.cache=new Float32Array(n.length)),ns(t,n)},rte.prototype.setValue=function(n,t,e){let i=this.seq;for(let r=0,o=i.length;r!==o;++r){let s=i[r];s.setValue(n,t[s.id],e)}};var U3=/(\w+)(\])?(\[|\.)?/g;function lee(n,t){n.seq.push(t),n.map[t.id]=t}function gFe(n,t,e){let i=n.name,r=i.length;for(U3.lastIndex=0;;){let o=U3.exec(i),a=o[1],c=o[3];if("]"===o[2]&&(a|=0),void 0===c||"["===c&&U3.lastIndex+2===r){lee(e,void 0===c?new hFe(a,n,t):new ite(a,n,t));break}{let u=e.map[a];void 0===u&&(u=new rte(a),lee(e,u)),e=u}}}function gp(n,t){this.seq=[],this.map={};let e=n.getProgramParameter(t,35718);for(let i=0;i<e;++i){let r=n.getActiveUniform(t,i);gFe(r,n.getUniformLocation(t,r.name),this)}}function cee(n,t,e){let i=n.createShader(t);return n.shaderSource(i,e),n.compileShader(i),i}gp.prototype.setValue=function(n,t,e,i){let r=this.map[t];void 0!==r&&r.setValue(n,e,i)},gp.prototype.setOptional=function(n,t,e){let i=t[e];void 0!==i&&this.setValue(n,e,i)},gp.upload=function(n,t,e,i){for(let r=0,o=t.length;r!==o;++r){let s=t[r],a=e[s.id];!1!==a.needsUpdate&&s.setValue(n,a.value,i)}},gp.seqWithValue=function(n,t){let e=[];for(let i=0,r=n.length;i!==r;++i){let o=n[i];o.id in t&&e.push(o)}return e};var _Fe=0;function dee(n,t,e){let i=n.getShaderParameter(t,35713),r=n.getShaderInfoLog(t).trim();return i&&""===r?"":e.toUpperCase()+"\n\n"+r+"\n\n"+function(n){let t=n.split("\n");for(let e=0;e<t.length;e++)t[e]=e+1+": "+t[e];return t.join("\n")}(n.getShaderSource(t))}function yFe(n,t){let e=function(n){switch(n){case _p:return["Linear","( value )"];case Ar:return["sRGB","( value )"];default:return console.warn("THREE.WebGLProgram: Unsupported encoding:",n),["Linear","( value )"]}}(t);return"vec4 "+n+"( vec4 value ) { return LinearTo"+e[0]+e[1]+"; }"}function xFe(n,t){let e;switch(t){case YAe:e="Linear";break;case XAe:e="Reinhard";break;case QAe:e="OptimizedCineon";break;case ZAe:e="ACESFilmic";break;case KAe:e="Custom";break;default:console.warn("THREE.WebGLProgram: Unsupported toneMapping:",t),e="Linear"}return"vec3 "+n+"( vec3 color ) { return "+e+"ToneMapping( color ); }"}function hx(n){return""!==n}function uee(n,t){return n.replace(/NUM_DIR_LIGHTS/g,t.numDirLights).replace(/NUM_SPOT_LIGHTS/g,t.numSpotLights).replace(/NUM_RECT_AREA_LIGHTS/g,t.numRectAreaLights).replace(/NUM_POINT_LIGHTS/g,t.numPointLights).replace(/NUM_HEMI_LIGHTS/g,t.numHemiLights).replace(/NUM_DIR_LIGHT_SHADOWS/g,t.numDirLightShadows).replace(/NUM_SPOT_LIGHT_SHADOWS/g,t.numSpotLightShadows).replace(/NUM_POINT_LIGHT_SHADOWS/g,t.numPointLightShadows)}function pee(n,t){return n.replace(/NUM_CLIPPING_PLANES/g,t.numClippingPlanes).replace(/UNION_CLIPPING_PLANES/g,t.numClippingPlanes-t.numClipIntersection)}var SFe=/^[ \t]*#include +<([\w\d./]+)>/gm;function oB(n){return n.replace(SFe,EFe)}function EFe(n,t){let e=bi[t];if(void 0===e)throw new Error("Can not resolve #include <"+t+">");return oB(e)}var TFe=/#pragma unroll_loop[\s]+?for \( int i \= (\d+)\; i < (\d+)\; i \+\+ \) \{([\s\S]+?)(?=\})\}/g,DFe=/#pragma unroll_loop_start\s+for\s*\(\s*int\s+i\s*=\s*(\d+)\s*;\s*i\s*<\s*(\d+)\s*;\s*i\s*\+\+\s*\)\s*{([\s\S]+?)}\s+#pragma unroll_loop_end/g;function fee(n){return n.replace(DFe,ote).replace(TFe,IFe)}function IFe(n,t,e,i){return console.warn("WebGLProgram: #pragma unroll_loop shader syntax is deprecated. Please use #pragma unroll_loop_start syntax instead."),ote(0,t,e,i)}function ote(n,t,e,i){let r="";for(let o=parseInt(t);o<parseInt(e);o++)r+=i.replace(/\[\s*i\s*\]/g,"[ "+o+" ]").replace(/UNROLLED_LOOP_INDEX/g,o);return r}function mee(n){let t="precision "+n.precision+" float;\nprecision "+n.precision+" int;";return"highp"===n.precision?t+="\n#define HIGH_PRECISION":"mediump"===n.precision?t+="\n#define MEDIUM_PRECISION":"lowp"===n.precision&&(t+="\n#define LOW_PRECISION"),t}function kFe(n,t,e,i){let b,M,r=n.getContext(),o=e.defines,s=e.vertexShader,a=e.fragmentShader,l=function(n){let t="SHADOWMAP_TYPE_BASIC";return n.shadowMapType===jee?t="SHADOWMAP_TYPE_PCF":n.shadowMapType===SAe?t="SHADOWMAP_TYPE_PCF_SOFT":n.shadowMapType===mx&&(t="SHADOWMAP_TYPE_VSM"),t}(e),c=function(n){let t="ENVMAP_TYPE_CUBE";if(n.envMap)switch(n.envMapMode){case Wx:case qx:t="ENVMAP_TYPE_CUBE";break;case XI:case uV:t="ENVMAP_TYPE_CUBE_UV"}return t}(e),d=function(n){let t="ENVMAP_MODE_REFLECTION";if(n.envMap)switch(n.envMapMode){case qx:case uV:t="ENVMAP_MODE_REFRACTION"}return t}(e),u=function(n){let t="ENVMAP_BLENDING_NONE";if(n.envMap)switch(n.combine){case YI:t="ENVMAP_BLENDING_MULTIPLY";break;case WAe:t="ENVMAP_BLENDING_MIX";break;case qAe:t="ENVMAP_BLENDING_ADD"}return t}(e),p=e.isWebGL2?"":function(n){return[n.extensionDerivatives||n.envMapCubeUV||n.bumpMap||n.tangentSpaceNormalMap||n.clearcoatNormalMap||n.flatShading||"physical"===n.shaderID?"#extension GL_OES_standard_derivatives : enable":"",(n.extensionFragDepth||n.logarithmicDepthBuffer)&&n.rendererExtensionFragDepth?"#extension GL_EXT_frag_depth : enable":"",n.extensionDrawBuffers&&n.rendererExtensionDrawBuffers?"#extension GL_EXT_draw_buffers : require":"",(n.extensionShaderTextureLOD||n.envMap||n.transmission)&&n.rendererExtensionShaderTextureLod?"#extension GL_EXT_shader_texture_lod : enable":""].filter(hx).join("\n")}(e),f=function(n){let t=[];for(let e in n){let i=n[e];!1!==i&&t.push("#define "+e+" "+i)}return t.join("\n")}(o),m=r.createProgram(),y=e.glslVersion?"#version "+e.glslVersion+"\n":"";e.isRawShaderMaterial?(b=[f].filter(hx).join("\n"),b.length>0&&(b+="\n"),M=[p,f].filter(hx).join("\n"),M.length>0&&(M+="\n")):(b=[mee(e),"#define SHADER_NAME "+e.shaderName,f,e.instancing?"#define USE_INSTANCING":"",e.instancingColor?"#define USE_INSTANCING_COLOR":"",e.supportsVertexTextures?"#define VERTEX_TEXTURES":"","#define MAX_BONES "+e.maxBones,e.useFog&&e.fog?"#define USE_FOG":"",e.useFog&&e.fogExp2?"#define FOG_EXP2":"",e.map?"#define USE_MAP":"",e.envMap?"#define USE_ENVMAP":"",e.envMap?"#define "+d:"",e.lightMap?"#define USE_LIGHTMAP":"",e.aoMap?"#define USE_AOMAP":"",e.emissiveMap?"#define USE_EMISSIVEMAP":"",e.bumpMap?"#define USE_BUMPMAP":"",e.normalMap?"#define USE_NORMALMAP":"",e.normalMap&&e.objectSpaceNormalMap?"#define OBJECTSPACE_NORMALMAP":"",e.normalMap&&e.tangentSpaceNormalMap?"#define TANGENTSPACE_NORMALMAP":"",e.clearcoatMap?"#define USE_CLEARCOATMAP":"",e.clearcoatRoughnessMap?"#define USE_CLEARCOAT_ROUGHNESSMAP":"",e.clearcoatNormalMap?"#define USE_CLEARCOAT_NORMALMAP":"",e.displacementMap&&e.supportsVertexTextures?"#define USE_DISPLACEMENTMAP":"",e.specularMap?"#define USE_SPECULARMAP":"",e.specularIntensityMap?"#define USE_SPECULARINTENSITYMAP":"",e.specularColorMap?"#define USE_SPECULARCOLORMAP":"",e.roughnessMap?"#define USE_ROUGHNESSMAP":"",e.metalnessMap?"#define USE_METALNESSMAP":"",e.alphaMap?"#define USE_ALPHAMAP":"",e.transmission?"#define USE_TRANSMISSION":"",e.transmissionMap?"#define USE_TRANSMISSIONMAP":"",e.thicknessMap?"#define USE_THICKNESSMAP":"",e.sheenColorMap?"#define USE_SHEENCOLORMAP":"",e.sheenRoughnessMap?"#define USE_SHEENROUGHNESSMAP":"",e.vertexTangents?"#define USE_TANGENT":"",e.vertexColors?"#define USE_COLOR":"",e.vertexAlphas?"#define USE_COLOR_ALPHA":"",e.vertexUvs?"#define USE_UV":"",e.uvsVertexOnly?"#define UVS_VERTEX_ONLY":"",e.flatShading?"#define FLAT_SHADED":"",e.skinning?"#define USE_SKINNING":"",e.useVertexTexture?"#define BONE_TEXTURE":"",e.morphTargets?"#define USE_MORPHTARGETS":"",e.morphNormals&&!1===e.flatShading?"#define USE_MORPHNORMALS":"",e.morphTargets&&e.isWebGL2?"#define MORPHTARGETS_TEXTURE":"",e.morphTargets&&e.isWebGL2?"#define MORPHTARGETS_COUNT "+e.morphTargetsCount:"",e.doubleSided?"#define DOUBLE_SIDED":"",e.flipSided?"#define FLIP_SIDED":"",e.shadowMapEnabled?"#define USE_SHADOWMAP":"",e.shadowMapEnabled?"#define "+l:"",e.sizeAttenuation?"#define USE_SIZEATTENUATION":"",e.logarithmicDepthBuffer?"#define USE_LOGDEPTHBUF":"",e.logarithmicDepthBuffer&&e.rendererExtensionFragDepth?"#define USE_LOGDEPTHBUF_EXT":"","uniform mat4 modelMatrix;","uniform mat4 modelViewMatrix;","uniform mat4 projectionMatrix;","uniform mat4 viewMatrix;","uniform mat3 normalMatrix;","uniform vec3 cameraPosition;","uniform bool isOrthographic;","#ifdef USE_INSTANCING","\tattribute mat4 instanceMatrix;","#endif","#ifdef USE_INSTANCING_COLOR","\tattribute vec3 instanceColor;","#endif","attribute vec3 position;","attribute vec3 normal;","attribute vec2 uv;","#ifdef USE_TANGENT","\tattribute vec4 tangent;","#endif","#if defined( USE_COLOR_ALPHA )","\tattribute vec4 color;","#elif defined( USE_COLOR )","\tattribute vec3 color;","#endif","#if ( defined( USE_MORPHTARGETS ) && ! defined( MORPHTARGETS_TEXTURE ) )","\tattribute vec3 morphTarget0;","\tattribute vec3 morphTarget1;","\tattribute vec3 morphTarget2;","\tattribute vec3 morphTarget3;","\t#ifdef USE_MORPHNORMALS","\t\tattribute vec3 morphNormal0;","\t\tattribute vec3 morphNormal1;","\t\tattribute vec3 morphNormal2;","\t\tattribute vec3 morphNormal3;","\t#else","\t\tattribute vec3 morphTarget4;","\t\tattribute vec3 morphTarget5;","\t\tattribute vec3 morphTarget6;","\t\tattribute vec3 morphTarget7;","\t#endif","#endif","#ifdef USE_SKINNING","\tattribute vec4 skinIndex;","\tattribute vec4 skinWeight;","#endif","\n"].filter(hx).join("\n"),M=[p,mee(e),"#define SHADER_NAME "+e.shaderName,f,e.useFog&&e.fog?"#define USE_FOG":"",e.useFog&&e.fogExp2?"#define FOG_EXP2":"",e.map?"#define USE_MAP":"",e.matcap?"#define USE_MATCAP":"",e.envMap?"#define USE_ENVMAP":"",e.envMap?"#define "+c:"",e.envMap?"#define "+d:"",e.envMap?"#define "+u:"",e.lightMap?"#define USE_LIGHTMAP":"",e.aoMap?"#define USE_AOMAP":"",e.emissiveMap?"#define USE_EMISSIVEMAP":"",e.bumpMap?"#define USE_BUMPMAP":"",e.normalMap?"#define USE_NORMALMAP":"",e.normalMap&&e.objectSpaceNormalMap?"#define OBJECTSPACE_NORMALMAP":"",e.normalMap&&e.tangentSpaceNormalMap?"#define TANGENTSPACE_NORMALMAP":"",e.clearcoat?"#define USE_CLEARCOAT":"",e.clearcoatMap?"#define USE_CLEARCOATMAP":"",e.clearcoatRoughnessMap?"#define USE_CLEARCOAT_ROUGHNESSMAP":"",e.clearcoatNormalMap?"#define USE_CLEARCOAT_NORMALMAP":"",e.specularMap?"#define USE_SPECULARMAP":"",e.specularIntensityMap?"#define USE_SPECULARINTENSITYMAP":"",e.specularColorMap?"#define USE_SPECULARCOLORMAP":"",e.roughnessMap?"#define USE_ROUGHNESSMAP":"",e.metalnessMap?"#define USE_METALNESSMAP":"",e.alphaMap?"#define USE_ALPHAMAP":"",e.alphaTest?"#define USE_ALPHATEST":"",e.sheen?"#define USE_SHEEN":"",e.sheenColorMap?"#define USE_SHEENCOLORMAP":"",e.sheenRoughnessMap?"#define USE_SHEENROUGHNESSMAP":"",e.transmission?"#define USE_TRANSMISSION":"",e.transmissionMap?"#define USE_TRANSMISSIONMAP":"",e.thicknessMap?"#define USE_THICKNESSMAP":"",e.decodeVideoTexture?"#define DECODE_VIDEO_TEXTURE":"",e.vertexTangents?"#define USE_TANGENT":"",e.vertexColors||e.instancingColor?"#define USE_COLOR":"",e.vertexAlphas?"#define USE_COLOR_ALPHA":"",e.vertexUvs?"#define USE_UV":"",e.uvsVertexOnly?"#define UVS_VERTEX_ONLY":"",e.gradientMap?"#define USE_GRADIENTMAP":"",e.flatShading?"#define FLAT_SHADED":"",e.doubleSided?"#define DOUBLE_SIDED":"",e.flipSided?"#define FLIP_SIDED":"",e.shadowMapEnabled?"#define USE_SHADOWMAP":"",e.shadowMapEnabled?"#define "+l:"",e.premultipliedAlpha?"#define PREMULTIPLIED_ALPHA":"",e.physicallyCorrectLights?"#define PHYSICALLY_CORRECT_LIGHTS":"",e.logarithmicDepthBuffer?"#define USE_LOGDEPTHBUF":"",e.logarithmicDepthBuffer&&e.rendererExtensionFragDepth?"#define USE_LOGDEPTHBUF_EXT":"",(e.extensionShaderTextureLOD||e.envMap)&&e.rendererExtensionShaderTextureLod?"#define TEXTURE_LOD_EXT":"","uniform mat4 viewMatrix;","uniform vec3 cameraPosition;","uniform bool isOrthographic;",e.toneMapping!==fp?"#define TONE_MAPPING":"",e.toneMapping!==fp?bi.tonemapping_pars_fragment:"",e.toneMapping!==fp?xFe("toneMapping",e.toneMapping):"",e.dithering?"#define DITHERING":"",e.alphaWrite?"":"#define OPAQUE",bi.encodings_pars_fragment,yFe("linearToOutputTexel",e.outputEncoding),e.depthPacking?"#define DEPTH_PACKING "+e.depthPacking:"","\n"].filter(hx).join("\n")),s=oB(s),s=uee(s,e),s=pee(s,e),a=oB(a),a=uee(a,e),a=pee(a,e),s=fee(s),a=fee(a),e.isWebGL2&&!0!==e.isRawShaderMaterial&&(y="#version 300 es\n",b=["precision mediump sampler2DArray;","#define attribute in","#define varying out","#define texture2D texture"].join("\n")+"\n"+b,M=["#define varying in",e.glslVersion===N$?"":"layout(location = 0) out highp vec4 pc_fragColor;",e.glslVersion===N$?"":"#define gl_FragColor pc_fragColor","#define gl_FragDepthEXT gl_FragDepth","#define texture2D texture","#define textureCube texture","#define texture2DProj textureProj","#define texture2DLodEXT textureLod","#define texture2DProjLodEXT textureProjLod","#define textureCubeLodEXT textureLod","#define texture2DGradEXT textureGrad","#define texture2DProjGradEXT textureProjGrad","#define textureCubeGradEXT textureGrad"].join("\n")+"\n"+M);let te,K,R=y+M+a,A=cee(r,35633,y+b+s),V=cee(r,35632,R);if(r.attachShader(m,A),r.attachShader(m,V),void 0!==e.index0AttributeName?r.bindAttribLocation(m,0,e.index0AttributeName):!0===e.morphTargets&&r.bindAttribLocation(m,0,"position"),r.linkProgram(m),n.debug.checkShaderErrors){let xe=r.getProgramInfoLog(m).trim(),Xe=r.getShaderInfoLog(A).trim(),De=r.getShaderInfoLog(V).trim(),D=!0,re=!0;if(!1===r.getProgramParameter(m,35714)){D=!1;let ce=dee(r,A,"vertex"),fe=dee(r,V,"fragment");console.error("THREE.WebGLProgram: Shader Error "+r.getError()+" - VALIDATE_STATUS "+r.getProgramParameter(m,35715)+"\n\nProgram Info Log: "+xe+"\n"+ce+"\n"+fe)}else""!==xe?console.warn("THREE.WebGLProgram: Program Info Log:",xe):(""===Xe||""===De)&&(re=!1);re&&(this.diagnostics={runnable:D,programLog:xe,vertexShader:{log:Xe,prefix:b},fragmentShader:{log:De,prefix:M}})}return r.deleteShader(A),r.deleteShader(V),this.getUniforms=function(){return void 0===te&&(te=new gp(r,m)),te},this.getAttributes=function(){return void 0===K&&(K=function(n,t){let e={},i=n.getProgramParameter(t,35721);for(let r=0;r<i;r++){let o=n.getActiveAttrib(t,r),s=o.name,a=1;35674===o.type&&(a=2),35675===o.type&&(a=3),35676===o.type&&(a=4),e[s]={type:o.type,location:n.getAttribLocation(t,s),locationSize:a}}return e}(r,m)),K},this.destroy=function(){i.releaseStatesOfProgram(this),r.deleteProgram(m),this.program=void 0},this.name=e.shaderName,this.id=_Fe++,this.cacheKey=t,this.usedTimes=1,this.program=m,this.vertexShader=A,this.fragmentShader=V,this}var FFe=0,sB=class{constructor(){this.shaderCache=new Map,this.materialCache=new Map}update(t){let i=t.fragmentShader,r=this._getShaderStage(t.vertexShader),o=this._getShaderStage(i),s=this._getShaderCacheForMaterial(t);return!1===s.has(r)&&(s.add(r),r.usedTimes++),!1===s.has(o)&&(s.add(o),o.usedTimes++),this}remove(t){let e=this.materialCache.get(t);for(let i of e)i.usedTimes--,0===i.usedTimes&&this.shaderCache.delete(i);return this.materialCache.delete(t),this}getVertexShaderID(t){return this._getShaderStage(t.vertexShader).id}getFragmentShaderID(t){return this._getShaderStage(t.fragmentShader).id}dispose(){this.shaderCache.clear(),this.materialCache.clear()}_getShaderCacheForMaterial(t){let e=this.materialCache;return!1===e.has(t)&&e.set(t,new Set),e.get(t)}_getShaderStage(t){let e=this.shaderCache;if(!1===e.has(t)){let i=new aB;e.set(t,i)}return e.get(t)}},aB=class{constructor(){this.id=FFe++,this.usedTimes=0}};function NFe(n,t,e,i,r,o,s){let a=new CI,l=new sB,c=[],d=r.isWebGL2,u=r.logarithmicDepthBuffer,p=r.floatVertexTextures,f=r.maxVertexUniforms,m=r.vertexTextures,b=r.precision,M={MeshDepthMaterial:"depth",MeshDistanceMaterial:"distanceRGBA",MeshNormalMaterial:"normal",MeshBasicMaterial:"basic",MeshLambertMaterial:"lambert",MeshPhongMaterial:"phong",MeshToonMaterial:"toon",MeshStandardMaterial:"physical",MeshPhysicalMaterial:"physical",MeshMatcapMaterial:"matcap",LineBasicMaterial:"basic",LineDashedMaterial:"dashed",PointsMaterial:"points",ShadowMaterial:"shadow",SpriteMaterial:"sprite"};return{getParameters:function(D,re,ce,fe,be){let Ne,lt,Mt,pt,ne=fe.fog,pe=(D.isMeshStandardMaterial?e:t).get(D.envMap||(D.isMeshStandardMaterial?fe.environment:null)),je=M[D.type],Ce=be.isSkinnedMesh?function(D){let ce=D.skeleton.bones;if(p)return 1024;{let be=Math.floor((f-20)/4),ne=Math.min(be,ce.length);return ne<ce.length?(console.warn("THREE.WebGLRenderer: Skeleton has "+ce.length+" bones. This GPU supports "+ne+"."),0):ne}}(be):0;if(null!==D.precision&&(b=r.getMaxPrecision(D.precision),b!==D.precision&&console.warn("THREE.WebGLProgram.getParameters:",D.precision,"not supported, using",b,"instead.")),je){let ve=qc[je];Ne=ve.vertexShader,lt=ve.fragmentShader}else Ne=D.vertexShader,lt=D.fragmentShader,l.update(D),Mt=l.getVertexShaderID(D),pt=l.getFragmentShaderID(D);let Oe=n.getRenderTarget(),wt=D.clearcoat>0;return{isWebGL2:d,shaderID:je,shaderName:D.type,vertexShader:Ne,fragmentShader:lt,defines:D.defines,customVertexShaderID:Mt,customFragmentShaderID:pt,isRawShaderMaterial:!0===D.isRawShaderMaterial,glslVersion:D.glslVersion,precision:b,instancing:!0===be.isInstancedMesh,instancingColor:!0===be.isInstancedMesh&&null!==be.instanceColor,supportsVertexTextures:m,outputEncoding:null===Oe?n.outputEncoding:!0===Oe.isXRRenderTarget?Oe.texture.encoding:_p,map:!!D.map,matcap:!!D.matcap,envMap:!!pe,envMapMode:pe&&pe.mapping,envMapCubeUV:!!pe&&(pe.mapping===XI||pe.mapping===uV),lightMap:!!D.lightMap,aoMap:!!D.aoMap,emissiveMap:!!D.emissiveMap,bumpMap:!!D.bumpMap,normalMap:!!D.normalMap,objectSpaceNormalMap:D.normalMapType===vRe,tangentSpaceNormalMap:D.normalMapType===o_,decodeVideoTexture:!!D.map&&!0===D.map.isVideoTexture&&D.map.encoding===Ar,clearcoat:wt,clearcoatMap:wt&&!!D.clearcoatMap,clearcoatRoughnessMap:wt&&!!D.clearcoatRoughnessMap,clearcoatNormalMap:wt&&!!D.clearcoatNormalMap,displacementMap:!!D.displacementMap,roughnessMap:!!D.roughnessMap,metalnessMap:!!D.metalnessMap,specularMap:!!D.specularMap,specularIntensityMap:!!D.specularIntensityMap,specularColorMap:!!D.specularColorMap,alphaMap:!!D.alphaMap,alphaTest:D.alphaTest>0,alphaWrite:D.alphaWrite||D.transparent,gradientMap:!!D.gradientMap,sheen:D.sheen>0,sheenColorMap:!!D.sheenColorMap,sheenRoughnessMap:!!D.sheenRoughnessMap,transmission:D.transmission>0,transmissionMap:!!D.transmissionMap,thicknessMap:!!D.thicknessMap,combine:D.combine,vertexTangents:!!D.normalMap&&!!be.geometry&&!!be.geometry.attributes.tangent,vertexColors:D.vertexColors,vertexAlphas:!0===D.vertexColors&&!!be.geometry&&!!be.geometry.attributes.color&&4===be.geometry.attributes.color.itemSize,vertexUvs:!!(D.map||D.bumpMap||D.normalMap||D.specularMap||D.alphaMap||D.emissiveMap||D.roughnessMap||D.metalnessMap||D.clearcoatMap||D.clearcoatRoughnessMap||D.clearcoatNormalMap||D.displacementMap||D.transmissionMap||D.thicknessMap||D.specularIntensityMap||D.specularColorMap||D.sheenColorMap||D.sheenRoughnessMap),uvsVertexOnly:!(D.map||D.bumpMap||D.normalMap||D.specularMap||D.alphaMap||D.emissiveMap||D.roughnessMap||D.metalnessMap||D.clearcoatNormalMap||D.transmission>0||D.transmissionMap||D.thicknessMap||D.specularIntensityMap||D.specularColorMap||D.sheen>0||D.sheenColorMap||D.sheenRoughnessMap||!D.displacementMap),fog:!!ne,useFog:D.fog,fogExp2:ne&&ne.isFogExp2,flatShading:!!D.flatShading,sizeAttenuation:D.sizeAttenuation,logarithmicDepthBuffer:u,skinning:!0===be.isSkinnedMesh&&Ce>0,maxBones:Ce,useVertexTexture:p,morphTargets:!!be.geometry&&!!be.geometry.morphAttributes.position,morphNormals:!!be.geometry&&!!be.geometry.morphAttributes.normal,morphTargetsCount:be.geometry&&be.geometry.morphAttributes.position?be.geometry.morphAttributes.position.length:0,numDirLights:re.directional.length,numPointLights:re.point.length,numSpotLights:re.spot.length,numRectAreaLights:re.rectArea.length,numHemiLights:re.hemi.length,numDirLightShadows:re.directionalShadowMap.length,numPointLightShadows:re.pointShadowMap.length,numSpotLightShadows:re.spotShadowMap.length,numClippingPlanes:s.numPlanes,numClipIntersection:s.numIntersection,dithering:D.dithering,shadowMapEnabled:n.shadowMap.enabled&&ce.length>0,shadowMapType:n.shadowMap.type,toneMapping:D.toneMapped?n.toneMapping:fp,physicallyCorrectLights:n.physicallyCorrectLights,premultipliedAlpha:D.premultipliedAlpha,doubleSided:D.side===q0,flipSided:D.side===go,depthPacking:void 0!==D.depthPacking&&D.depthPacking,index0AttributeName:D.index0AttributeName,extensionDerivatives:D.extensions&&D.extensions.derivatives,extensionFragDepth:D.extensions&&D.extensions.fragDepth,extensionDrawBuffers:D.extensions&&D.extensions.drawBuffers,extensionShaderTextureLOD:D.extensions&&D.extensions.shaderTextureLOD,rendererExtensionFragDepth:d||i.has("EXT_frag_depth"),rendererExtensionDrawBuffers:d||i.has("WEBGL_draw_buffers"),rendererExtensionShaderTextureLod:d||i.has("EXT_shader_texture_lod"),customProgramCacheKey:D.customProgramCacheKey()}},getProgramCacheKey:function(D){let re=[];if(D.shaderID?re.push(D.shaderID):(re.push(D.customVertexShaderID),re.push(D.customFragmentShaderID)),void 0!==D.defines)for(let ce in D.defines)re.push(ce),re.push(D.defines[ce]);return!1===D.isRawShaderMaterial&&(function(D,re){D.push(re.precision),D.push(re.outputEncoding),D.push(re.envMapMode),D.push(re.combine),D.push(re.vertexUvs),D.push(re.fogExp2),D.push(re.sizeAttenuation),D.push(re.maxBones),D.push(re.morphTargetsCount),D.push(re.numDirLights),D.push(re.numPointLights),D.push(re.numSpotLights),D.push(re.numHemiLights),D.push(re.numRectAreaLights),D.push(re.numDirLightShadows),D.push(re.numPointLightShadows),D.push(re.numSpotLightShadows),D.push(re.shadowMapType),D.push(re.toneMapping),D.push(re.numClippingPlanes),D.push(re.numClipIntersection),D.push(re.alphaWrite)}(re,D),function(D,re){a.disableAll(),re.isWebGL2&&a.enable(0),re.supportsVertexTextures&&a.enable(1),re.instancing&&a.enable(2),re.instancingColor&&a.enable(3),re.map&&a.enable(4),re.matcap&&a.enable(5),re.envMap&&a.enable(6),re.envMapCubeUV&&a.enable(7),re.lightMap&&a.enable(8),re.aoMap&&a.enable(9),re.emissiveMap&&a.enable(10),re.bumpMap&&a.enable(11),re.normalMap&&a.enable(12),re.objectSpaceNormalMap&&a.enable(13),re.tangentSpaceNormalMap&&a.enable(14),re.clearcoat&&a.enable(15),re.clearcoatMap&&a.enable(16),re.clearcoatRoughnessMap&&a.enable(17),re.clearcoatNormalMap&&a.enable(18),re.displacementMap&&a.enable(19),re.specularMap&&a.enable(20),re.roughnessMap&&a.enable(21),re.metalnessMap&&a.enable(22),re.gradientMap&&a.enable(23),re.alphaMap&&a.enable(24),re.alphaTest&&a.enable(25),re.vertexColors&&a.enable(26),re.vertexAlphas&&a.enable(27),re.vertexUvs&&a.enable(28),re.vertexTangents&&a.enable(29),re.uvsVertexOnly&&a.enable(30),re.fog&&a.enable(31),D.push(a.mask),a.disableAll(),re.useFog&&a.enable(0),re.flatShading&&a.enable(1),re.logarithmicDepthBuffer&&a.enable(2),re.skinning&&a.enable(3),re.useVertexTexture&&a.enable(4),re.morphTargets&&a.enable(5),re.morphNormals&&a.enable(6),re.premultipliedAlpha&&a.enable(7),re.shadowMapEnabled&&a.enable(8),re.physicallyCorrectLights&&a.enable(9),re.doubleSided&&a.enable(10),re.flipSided&&a.enable(11),re.depthPacking&&a.enable(12),re.dithering&&a.enable(13),re.specularIntensityMap&&a.enable(14),re.specularColorMap&&a.enable(15),re.transmission&&a.enable(16),re.transmissionMap&&a.enable(17),re.thicknessMap&&a.enable(18),re.sheen&&a.enable(19),re.sheenColorMap&&a.enable(20),re.sheenRoughnessMap&&a.enable(21),re.decodeVideoTexture&&a.enable(22),D.push(a.mask)}(re,D),re.push(n.outputEncoding)),re.push(D.customProgramCacheKey),re.join()},getUniforms:function(D){let ce,re=M[D.type];return ce=re?kRe.clone(qc[re].uniforms):D.uniforms,ce},acquireProgram:function(D,re){let ce;for(let fe=0,be=c.length;fe<be;fe++){let ne=c[fe];if(ne.cacheKey===re){ce=ne,++ce.usedTimes;break}}return void 0===ce&&(ce=new kFe(n,re,D,o),c.push(ce)),ce},releaseProgram:function(D){if(0==--D.usedTimes){let re=c.indexOf(D);c[re]=c[c.length-1],c.pop(),D.destroy()}},releaseShaderCache:function(D){l.remove(D)},programs:c,dispose:function(){l.dispose()}}}function LFe(){let n=new WeakMap;return{get:function(o){let s=n.get(o);return void 0===s&&(s={},n.set(o,s)),s},remove:function(o){n.delete(o)},update:function(o,s,a){n.get(o)[s]=a},dispose:function(){n=new WeakMap}}}function BFe(n,t){return n.groupOrder!==t.groupOrder?n.groupOrder-t.groupOrder:n.renderOrder!==t.renderOrder?n.renderOrder-t.renderOrder:n.material.id!==t.material.id?n.material.id-t.material.id:n.z!==t.z?n.z-t.z:n.id-t.id}function hee(n,t){return n.groupOrder!==t.groupOrder?n.groupOrder-t.groupOrder:n.renderOrder!==t.renderOrder?n.renderOrder-t.renderOrder:n.z!==t.z?t.z-n.z:n.id-t.id}function gee(){let n=[],t=0,e=[],i=[],r=[];function s(u,p,f,m,b,M){let y=n[t];return void 0===y?(y={id:u.id,object:u,geometry:p,material:f,groupOrder:m,renderOrder:u.renderOrder,z:b,group:M},n[t]=y):(y.id=u.id,y.object=u,y.geometry=p,y.material=f,y.groupOrder=m,y.renderOrder=u.renderOrder,y.z=b,y.group=M),t++,y}return{opaque:e,transmissive:i,transparent:r,init:function(){t=0,e.length=0,i.length=0,r.length=0},push:function(u,p,f,m,b,M){let y=s(u,p,f,m,b,M);f.transmission>0?i.push(y):!0===f.transparent?r.push(y):e.push(y)},unshift:function(u,p,f,m,b,M){let y=s(u,p,f,m,b,M);f.transmission>0?i.unshift(y):!0===f.transparent?r.unshift(y):e.unshift(y)},finish:function(){for(let u=t,p=n.length;u<p;u++){let f=n[u];if(null===f.id)break;f.id=null,f.object=null,f.geometry=null,f.material=null,f.group=null}},sort:function(u,p){e.length>1&&e.sort(u||BFe),i.length>1&&i.sort(p||hee),r.length>1&&r.sort(p||hee)}}}function VFe(){let n=new WeakMap;return{get:function(i,r){let o;return!1===n.has(i)?(o=new gee,n.set(i,[o])):r>=n.get(i).length?(o=new gee,n.get(i).push(o)):o=n.get(i)[r],o},dispose:function(){n=new WeakMap}}}function HFe(){let n={};return{get:function(t){if(void 0!==n[t.id])return n[t.id];let e;switch(t.type){case"DirectionalLight":e={direction:new $,color:new an};break;case"SpotLight":e={position:new $,direction:new $,color:new an,distance:0,coneCos:0,penumbraCos:0,decay:0};break;case"PointLight":e={position:new $,color:new an,distance:0,decay:0};break;case"HemisphereLight":e={direction:new $,skyColor:new an,groundColor:new an};break;case"RectAreaLight":e={color:new an,position:new $,halfWidth:new $,halfHeight:new $}}return n[t.id]=e,e}}}var UFe=0;function jFe(n,t){return(t.castShadow?1:0)-(n.castShadow?1:0)}function GFe(n,t){let e=new HFe,i=function(){let n={};return{get:function(t){if(void 0!==n[t.id])return n[t.id];let e;switch(t.type){case"DirectionalLight":case"SpotLight":e={shadowBias:0,shadowNormalBias:0,shadowRadius:1,shadowMapSize:new $e};break;case"PointLight":e={shadowBias:0,shadowNormalBias:0,shadowRadius:1,shadowMapSize:new $e,shadowCameraNear:1,shadowCameraFar:1e3}}return n[t.id]=e,e}}}(),r={version:0,hash:{directionalLength:-1,pointLength:-1,spotLength:-1,rectAreaLength:-1,hemiLength:-1,numDirectionalShadows:-1,numPointShadows:-1,numSpotShadows:-1},ambient:[0,0,0],probe:[],directional:[],directionalShadow:[],directionalShadowMap:[],directionalShadowMatrix:[],spot:[],spotShadow:[],spotShadowMap:[],spotShadowMatrix:[],rectArea:[],rectAreaLTC1:null,rectAreaLTC2:null,point:[],pointShadow:[],pointShadowMap:[],pointShadowMatrix:[],hemi:[]};for(let d=0;d<9;d++)r.probe.push(new $);let o=new $,s=new xn,a=new xn;return{setup:function(d,u){let p=0,f=0,m=0;for(let Xe=0;Xe<9;Xe++)r.probe[Xe].set(0,0,0);let b=0,M=0,y=0,x=0,R=0,A=0,V=0,te=0;d.sort(jFe);let K=!0!==u?Math.PI:1;for(let Xe=0,De=d.length;Xe<De;Xe++){let D=d[Xe],re=D.color,ce=D.intensity,fe=D.distance,be=D.shadow&&D.shadow.map?D.shadow.map.texture:null;if(D.isAmbientLight)p+=re.r*ce*K,f+=re.g*ce*K,m+=re.b*ce*K;else if(D.isLightProbe)for(let ne=0;ne<9;ne++)r.probe[ne].addScaledVector(D.sh.coefficients[ne],ce);else if(D.isDirectionalLight){let ne=e.get(D);if(ne.color.copy(D.color).multiplyScalar(D.intensity*K),D.castShadow){let de=D.shadow,pe=i.get(D);pe.shadowBias=de.bias,pe.shadowNormalBias=de.normalBias,pe.shadowRadius=de.radius,pe.shadowMapSize=de.mapSize,r.directionalShadow[b]=pe,r.directionalShadowMap[b]=be,r.directionalShadowMatrix[b]=D.shadow.matrix,A++}r.directional[b]=ne,b++}else if(D.isSpotLight){let ne=e.get(D);if(ne.position.setFromMatrixPosition(D.matrixWorld),ne.color.copy(re).multiplyScalar(ce*K),ne.distance=fe,ne.coneCos=Math.cos(D.angle),ne.penumbraCos=Math.cos(D.angle*(1-D.penumbra)),ne.decay=D.decay,D.castShadow){let de=D.shadow,pe=i.get(D);pe.shadowBias=de.bias,pe.shadowNormalBias=de.normalBias,pe.shadowRadius=de.radius,pe.shadowMapSize=de.mapSize,r.spotShadow[y]=pe,r.spotShadowMap[y]=be,r.spotShadowMatrix[y]=D.shadow.matrix,te++}r.spot[y]=ne,y++}else if(D.isRectAreaLight){let ne=e.get(D);ne.color.copy(re).multiplyScalar(ce),ne.halfWidth.set(.5*D.width,0,0),ne.halfHeight.set(0,.5*D.height,0),r.rectArea[x]=ne,x++}else if(D.isPointLight){let ne=e.get(D);if(ne.color.copy(D.color).multiplyScalar(D.intensity*K),ne.distance=D.distance,ne.decay=D.decay,D.castShadow){let de=D.shadow,pe=i.get(D);pe.shadowBias=de.bias,pe.shadowNormalBias=de.normalBias,pe.shadowRadius=de.radius,pe.shadowMapSize=de.mapSize,pe.shadowCameraNear=de.camera.near,pe.shadowCameraFar=de.camera.far,r.pointShadow[M]=pe,r.pointShadowMap[M]=be,r.pointShadowMatrix[M]=D.shadow.matrix,V++}r.point[M]=ne,M++}else if(D.isHemisphereLight){let ne=e.get(D);ne.skyColor.copy(D.color).multiplyScalar(ce*K),ne.groundColor.copy(D.groundColor).multiplyScalar(ce*K),r.hemi[R]=ne,R++}}x>0&&(t.isWebGL2||!0===n.has("OES_texture_float_linear")?(r.rectAreaLTC1=It.LTC_FLOAT_1,r.rectAreaLTC2=It.LTC_FLOAT_2):!0===n.has("OES_texture_half_float_linear")?(r.rectAreaLTC1=It.LTC_HALF_1,r.rectAreaLTC2=It.LTC_HALF_2):console.error("THREE.WebGLRenderer: Unable to use RectAreaLight. Missing WebGL extensions.")),r.ambient[0]=p,r.ambient[1]=f,r.ambient[2]=m;let xe=r.hash;(xe.directionalLength!==b||xe.pointLength!==M||xe.spotLength!==y||xe.rectAreaLength!==x||xe.hemiLength!==R||xe.numDirectionalShadows!==A||xe.numPointShadows!==V||xe.numSpotShadows!==te)&&(r.directional.length=b,r.spot.length=y,r.rectArea.length=x,r.point.length=M,r.hemi.length=R,r.directionalShadow.length=A,r.directionalShadowMap.length=A,r.pointShadow.length=V,r.pointShadowMap.length=V,r.spotShadow.length=te,r.spotShadowMap.length=te,r.directionalShadowMatrix.length=A,r.pointShadowMatrix.length=V,r.spotShadowMatrix.length=te,xe.directionalLength=b,xe.pointLength=M,xe.spotLength=y,xe.rectAreaLength=x,xe.hemiLength=R,xe.numDirectionalShadows=A,xe.numPointShadows=V,xe.numSpotShadows=te,r.version=UFe++)},setupView:function(d,u){let p=0,f=0,m=0,b=0,M=0,y=u.matrixWorldInverse;for(let x=0,R=d.length;x<R;x++){let A=d[x];if(A.isDirectionalLight){let V=r.directional[p];V.direction.setFromMatrixPosition(A.matrixWorld),o.setFromMatrixPosition(A.target.matrixWorld),V.direction.sub(o),V.direction.transformDirection(y),p++}else if(A.isSpotLight){let V=r.spot[m];V.position.setFromMatrixPosition(A.matrixWorld),V.position.applyMatrix4(y),V.direction.setFromMatrixPosition(A.matrixWorld),o.setFromMatrixPosition(A.target.matrixWorld),V.direction.sub(o),V.direction.transformDirection(y),m++}else if(A.isRectAreaLight){let V=r.rectArea[b];V.position.setFromMatrixPosition(A.matrixWorld),V.position.applyMatrix4(y),a.identity(),s.copy(A.matrixWorld),s.premultiply(y),a.extractRotation(s),V.halfWidth.set(.5*A.width,0,0),V.halfHeight.set(0,.5*A.height,0),V.halfWidth.applyMatrix4(a),V.halfHeight.applyMatrix4(a),b++}else if(A.isPointLight){let V=r.point[f];V.position.setFromMatrixPosition(A.matrixWorld),V.position.applyMatrix4(y),f++}else if(A.isHemisphereLight){let V=r.hemi[M];V.direction.setFromMatrixPosition(A.matrixWorld),V.direction.transformDirection(y),V.direction.normalize(),M++}}},state:r}}function _ee(n,t){let e=new GFe(n,t),i=[],r=[];return{init:function(){i.length=0,r.length=0},state:{lightsArray:i,shadowsArray:r,lights:e},setupLights:function(u){e.setup(i,u)},setupLightsView:function(u){e.setupView(i,u)},pushLight:function(u){i.push(u)},pushShadow:function(u){r.push(u)}}}function WFe(n,t){let e=new WeakMap;return{get:function(o,s=0){let a;return!1===e.has(o)?(a=new _ee(n,t),e.set(o,[a])):s>=e.get(o).length?(a=new _ee(n,t),e.get(o).push(a)):a=e.get(o)[s],a},dispose:function(){e=new WeakMap}}}var DI=class extends Ao{constructor(t){super(),this.type="MeshDepthMaterial",this.depthPacking=3200,this.map=null,this.alphaMap=null,this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.wireframe=!1,this.wireframeLinewidth=1,this.fog=!1,this.setValues(t)}copy(t){return super.copy(t),this.depthPacking=t.depthPacking,this.map=t.map,this.alphaMap=t.alphaMap,this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this}};DI.prototype.isMeshDepthMaterial=!0;var II=class extends Ao{constructor(t){super(),this.type="MeshDistanceMaterial",this.referencePosition=new $,this.nearDistance=1,this.farDistance=1e3,this.map=null,this.alphaMap=null,this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.fog=!1,this.setValues(t)}copy(t){return super.copy(t),this.referencePosition.copy(t.referencePosition),this.nearDistance=t.nearDistance,this.farDistance=t.farDistance,this.map=t.map,this.alphaMap=t.alphaMap,this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this}};II.prototype.isMeshDistanceMaterial=!0;var qFe="void main() {\n\tgl_Position = vec4( position, 1.0 );\n}",YFe="uniform sampler2D shadow_pass;\nuniform vec2 resolution;\nuniform float radius;\n#include <packing>\nvoid main() {\n\tconst float samples = float( VSM_SAMPLES );\n\tfloat mean = 0.0;\n\tfloat squared_mean = 0.0;\n\tfloat uvStride = samples <= 1.0 ? 0.0 : 2.0 / ( samples - 1.0 );\n\tfloat uvStart = samples <= 1.0 ? 0.0 : - 1.0;\n\tfor ( float i = 0.0; i < samples; i ++ ) {\n\t\tfloat uvOffset = uvStart + i * uvStride;\n\t\t#ifdef HORIZONTAL_PASS\n\t\t\tvec2 distribution = unpackRGBATo2Half( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( uvOffset, 0.0 ) * radius ) / resolution ) );\n\t\t\tmean += distribution.x;\n\t\t\tsquared_mean += distribution.y * distribution.y + distribution.x * distribution.x;\n\t\t#else\n\t\t\tfloat depth = unpackRGBAToDepth( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( 0.0, uvOffset ) * radius ) / resolution ) );\n\t\t\tmean += depth;\n\t\t\tsquared_mean += depth * depth;\n\t\t#endif\n\t}\n\tmean = mean / samples;\n\tsquared_mean = squared_mean / samples;\n\tfloat std_dev = sqrt( squared_mean - mean * mean );\n\tgl_FragColor = pack2HalfToRGBA( vec2( mean, std_dev ) );\n}";function ste(n,t,e){let i=new Z0,r=new $e,o=new $e,s=new Zi,a=new DI({depthPacking:bRe}),l=new II,c={},d=e.maxTextureSize,u={0:go,1:yx,2:q0},p=new Gd({defines:{VSM_SAMPLES:8},uniforms:{shadow_pass:{value:null},resolution:{value:new $e},radius:{value:4}},vertexShader:qFe,fragmentShader:YFe}),f=p.clone();f.defines.HORIZONTAL_PASS=1;let m=new Ui;m.setAttribute("position",new Pr(new Float32Array([-1,-1,.5,3,-1,.5,-1,3,.5]),3));let b=new ao(m,p),M=this;function y(A,V){let te=t.update(b);p.defines.VSM_SAMPLES!==A.blurSamples&&(p.defines.VSM_SAMPLES=A.blurSamples,f.defines.VSM_SAMPLES=A.blurSamples,p.needsUpdate=!0,f.needsUpdate=!0),p.uniforms.shadow_pass.value=A.map.texture,p.uniforms.resolution.value=A.mapSize,p.uniforms.radius.value=A.radius,n.setRenderTarget(A.mapPass),n.clear(),n.renderBufferDirect(V,null,te,p,b,null),f.uniforms.shadow_pass.value=A.mapPass.texture,f.uniforms.resolution.value=A.mapSize,f.uniforms.radius.value=A.radius,n.setRenderTarget(A.map),n.clear(),n.renderBufferDirect(V,null,te,f,b,null)}function x(A,V,te,K,xe,Xe,De){let D=null,re=!0===K.isPointLight?A.customDistanceMaterial:A.customDepthMaterial;if(D=void 0!==re?re:!0===K.isPointLight?l:a,n.localClippingEnabled&&!0===te.clipShadows&&0!==te.clippingPlanes.length||te.displacementMap&&0!==te.displacementScale||te.alphaMap&&te.alphaTest>0){let ce=D.uuid,fe=te.uuid,be=c[ce];void 0===be&&(be={},c[ce]=be);let ne=be[fe];void 0===ne&&(ne=D.clone(),be[fe]=ne),D=ne}return D.visible=te.visible,D.wireframe=te.wireframe,D.side=De===mx?null!==te.shadowSide?te.shadowSide:te.side:null!==te.shadowSide?te.shadowSide:u[te.side],D.alphaMap=te.alphaMap,D.alphaTest=te.alphaTest,D.clipShadows=te.clipShadows,D.clippingPlanes=te.clippingPlanes,D.clipIntersection=te.clipIntersection,D.displacementMap=te.displacementMap,D.displacementScale=te.displacementScale,D.displacementBias=te.displacementBias,D.wireframeLinewidth=te.wireframeLinewidth,D.linewidth=te.linewidth,!0===K.isPointLight&&!0===D.isMeshDistanceMaterial&&(D.referencePosition.setFromMatrixPosition(K.matrixWorld),D.nearDistance=xe,D.farDistance=Xe),D}function R(A,V,te,K,xe){if(!1===A.visible)return;if(A.layers.test(V.layers)&&(A.isMesh||A.isLine||A.isPoints)&&(A.castShadow||A.receiveShadow&&xe===mx)&&(!A.frustumCulled||i.intersectsObject(A))){A.modelViewMatrix.multiplyMatrices(te.matrixWorldInverse,A.matrixWorld);let D=t.update(A),re=A.material;if(Array.isArray(re)){let ce=D.groups;for(let fe=0,be=ce.length;fe<be;fe++){let ne=ce[fe],de=re[ne.materialIndex];if(de&&de.visible){let pe=x(A,0,de,K,te.near,te.far,xe);n.renderBufferDirect(te,null,D,pe,A,ne)}}}else if(re.visible){let ce=x(A,0,re,K,te.near,te.far,xe);n.renderBufferDirect(te,null,D,ce,A,null)}}let De=A.children;for(let D=0,re=De.length;D<re;D++)R(De[D],V,te,K,xe)}this.enabled=!1,this.autoUpdate=!0,this.needsUpdate=!1,this.type=jee,this.render=function(A,V,te){if(!1===M.enabled||!1===M.autoUpdate&&!1===M.needsUpdate||0===A.length)return;let K=n.getRenderTarget(),xe=n.getActiveCubeFace(),Xe=n.getActiveMipmapLevel(),De=n.state;De.setBlending(pp),De.buffers.color.setClear(1,1,1,1),De.buffers.depth.setTest(!0),De.setScissorTest(!1);for(let D=0,re=A.length;D<re;D++){let ce=A[D],fe=ce.shadow;if(void 0===fe){console.warn("THREE.WebGLShadowMap:",ce,"has no shadow.");continue}if(!1===fe.autoUpdate&&!1===fe.needsUpdate)continue;r.copy(fe.mapSize);let be=fe.getFrameExtents();if(r.multiply(be),o.copy(fe.mapSize),(r.x>d||r.y>d)&&(r.x>d&&(o.x=Math.floor(d/be.x),r.x=o.x*be.x,fe.mapSize.x=o.x),r.y>d&&(o.y=Math.floor(d/be.y),r.y=o.y*be.y,fe.mapSize.y=o.y)),null===fe.map&&!fe.isPointLightShadow&&this.type===mx){let de={minFilter:$o,magFilter:$o,format:gs};fe.map=new Js(r.x,r.y,de),fe.map.texture.name=ce.name+".shadowMap",fe.mapPass=new Js(r.x,r.y,de),fe.camera.updateProjectionMatrix()}null===fe.map&&(fe.map=new Js(r.x,r.y,{minFilter:_o,magFilter:_o,format:gs}),fe.map.texture.name=ce.name+".shadowMap",fe.camera.updateProjectionMatrix()),n.setRenderTarget(fe.map),n.clear();let ne=fe.getViewportCount();for(let de=0;de<ne;de++){let pe=fe.getViewport(de);s.set(o.x*pe.x,o.y*pe.y,o.x*pe.z,o.y*pe.w),De.viewport(s),fe.updateMatrices(ce,de),i=fe.getFrustum(),R(V,te,fe.camera,ce,this.type)}!fe.isPointLightShadow&&this.type===mx&&y(fe,te),fe.needsUpdate=!1}M.needsUpdate=!1,n.setRenderTarget(K,xe,Xe)}}function XFe(n,t,e){let i=e.isWebGL2,a=new function(){let ae=!1,Jt=new Zi,jt=null,Tn=new Zi(0,0,0,0);return{setMask:function(We){jt!==We&&!ae&&(n.colorMask(We,We,We,We),jt=We)},setLocked:function(We){ae=We},setClear:function(We,bn,ui,ur,zo){!0===zo&&(We*=ur,bn*=ur,ui*=ur),Jt.set(We,bn,ui,ur),!1===Tn.equals(Jt)&&(n.clearColor(We,bn,ui,ur),Tn.copy(Jt))},reset:function(){ae=!1,jt=null,Tn.set(-1,0,0,0)}}},l=new function(){let ae=!1,Jt=null,jt=null,Tn=null;return{setTest:function(We){We?Oe(2929):An(2929)},setMask:function(We){Jt!==We&&!ae&&(n.depthMask(We),Jt=We)},setFunc:function(We){if(jt!==We){if(We)switch(We){case BAe:n.depthFunc(512);break;case VAe:n.depthFunc(519);break;case HAe:n.depthFunc(513);break;case Z3:n.depthFunc(515);break;case zAe:n.depthFunc(514);break;case UAe:n.depthFunc(518);break;case jAe:n.depthFunc(516);break;case GAe:n.depthFunc(517);break;default:n.depthFunc(515)}else n.depthFunc(515);jt=We}},setLocked:function(We){ae=We},setClear:function(We){Tn!==We&&(n.clearDepth(We),Tn=We)},reset:function(){ae=!1,Jt=null,jt=null,Tn=null}}},c=new function(){let ae=!1,Jt=null,jt=null,Tn=null,We=null,bn=null,ui=null,ur=null,zo=null;return{setTest:function(Cr){ae||(Cr?Oe(2960):An(2960))},setMask:function(Cr){Jt!==Cr&&!ae&&(n.stencilMask(Cr),Jt=Cr)},setFunc:function(Cr,Ma,vs){(jt!==Cr||Tn!==Ma||We!==vs)&&(n.stencilFunc(Cr,Ma,vs),jt=Cr,Tn=Ma,We=vs)},setOp:function(Cr,Ma,vs){(bn!==Cr||ui!==Ma||ur!==vs)&&(n.stencilOp(Cr,Ma,vs),bn=Cr,ui=Ma,ur=vs)},setLocked:function(Cr){ae=Cr},setClear:function(Cr){zo!==Cr&&(n.clearStencil(Cr),zo=Cr)},reset:function(){ae=!1,Jt=null,jt=null,Tn=null,We=null,bn=null,ui=null,ur=null,zo=null}}},d={},u={},p=new WeakMap,f=[],m=null,b=!1,M=null,y=null,x=null,R=null,A=null,V=null,te=null,K=!1,xe=null,Xe=null,De=null,D=null,re=null,ce=n.getParameter(35661),fe=!1,be=0,ne=n.getParameter(7938);-1!==ne.indexOf("WebGL")?(be=parseFloat(/^WebGL (\d)/.exec(ne)[1]),fe=be>=1):-1!==ne.indexOf("OpenGL ES")&&(be=parseFloat(/^OpenGL ES (\d)/.exec(ne)[1]),fe=be>=2);let de=null,pe={},je=n.getParameter(3088),Ce=n.getParameter(2978),Ne=(new Zi).fromArray(je),lt=(new Zi).fromArray(Ce);function Mt(ae,Jt,jt){let Tn=new Uint8Array(4),We=n.createTexture();n.bindTexture(ae,We),n.texParameteri(ae,10241,9728),n.texParameteri(ae,10240,9728);for(let bn=0;bn<jt;bn++)n.texImage2D(Jt+bn,0,6408,1,1,0,6408,5121,Tn);return We}let pt={};function Oe(ae){!0!==d[ae]&&(n.enable(ae),d[ae]=!0)}function An(ae){!1!==d[ae]&&(n.disable(ae),d[ae]=!1)}pt[3553]=Mt(3553,3553,1),pt[34067]=Mt(34067,34069,6),a.setClear(0,0,0,1),l.setClear(1),c.setClear(0),Oe(2929),l.setFunc(Z3),Ye(!1),_t(a$),Oe(2884),oe(pp);let mt={[B0]:32774,[TAe]:32778,[DAe]:32779};if(i)mt[u$]=32775,mt[p$]=32776;else{let ae=t.get("EXT_blend_minmax");null!==ae&&(mt[u$]=ae.MIN_EXT,mt[p$]=ae.MAX_EXT)}let ft={[IAe]:0,[AAe]:1,[RAe]:768,[Wee]:770,[LAe]:776,[FAe]:774,[OAe]:772,[PAe]:769,[qee]:771,[NAe]:775,[kAe]:773};function oe(ae,Jt,jt,Tn,We,bn,ui,ur){if(ae!==pp){if(!1===b&&(Oe(3042),b=!0),ae===EAe)We=We||Jt,bn=bn||jt,ui=ui||Tn,(Jt!==y||We!==A)&&(n.blendEquationSeparate(mt[Jt],mt[We]),y=Jt,A=We),(jt!==x||Tn!==R||bn!==V||ui!==te)&&(n.blendFuncSeparate(ft[jt],ft[Tn],ft[bn],ft[ui]),x=jt,R=Tn,V=bn,te=ui),M=ae,K=null;else if(ae!==M||ur!==K){if((y!==B0||A!==B0)&&(n.blendEquation(32774),y=B0,A=B0),ur)switch(ae){case gx:n.blendFuncSeparate(1,771,1,771);break;case l$:n.blendFunc(1,1);break;case c$:n.blendFuncSeparate(0,769,0,1);break;case d$:n.blendFuncSeparate(0,768,0,770);break;default:console.error("THREE.WebGLState: Invalid blending: ",ae)}else switch(ae){case gx:n.blendFuncSeparate(770,771,1,771);break;case l$:n.blendFunc(770,1);break;case c$:n.blendFuncSeparate(0,769,0,1);break;case d$:n.blendFunc(0,768);break;default:console.error("THREE.WebGLState: Invalid blending: ",ae)}x=null,R=null,V=null,te=null,M=ae,K=ur}}else!0===b&&(An(3042),b=!1)}function Ye(ae){xe!==ae&&(n.frontFace(ae?2304:2305),xe=ae)}function _t(ae){ae!==MAe?(Oe(2884),ae!==Xe&&n.cullFace(ae===a$?1029:ae===wAe?1028:1032)):An(2884),Xe=ae}function sn(ae,Jt,jt){ae?(Oe(32823),(D!==Jt||re!==jt)&&(n.polygonOffset(Jt,jt),D=Jt,re=jt)):An(32823)}function ti(ae){void 0===ae&&(ae=33984+ce-1),de!==ae&&(n.activeTexture(ae),de=ae)}return{buffers:{color:a,depth:l,stencil:c},enable:Oe,disable:An,bindFramebuffer:function(ae,Jt){return u[ae]!==Jt&&(n.bindFramebuffer(ae,Jt),u[ae]=Jt,i&&(36009===ae&&(u[36160]=Jt),36160===ae&&(u[36009]=Jt)),!0)},drawBuffers:function(ae,Jt){let jt=f,Tn=!1;if(ae)if(jt=p.get(Jt),void 0===jt&&(jt=[],p.set(Jt,jt)),ae.isWebGLMultipleRenderTargets){let We=ae.texture;if(jt.length!==We.length||36064!==jt[0]){for(let bn=0,ui=We.length;bn<ui;bn++)jt[bn]=36064+bn;jt.length=We.length,Tn=!0}}else 36064!==jt[0]&&(jt[0]=36064,Tn=!0);else 1029!==jt[0]&&(jt[0]=1029,Tn=!0);Tn&&(e.isWebGL2?n.drawBuffers(jt):t.get("WEBGL_draw_buffers").drawBuffersWEBGL(jt))},useProgram:function(ae){return m!==ae&&(n.useProgram(ae),m=ae,!0)},setBlending:oe,setMaterial:function(ae,Jt){ae.side===q0?An(2884):Oe(2884);let jt=ae.side===go;Jt&&(jt=!jt),Ye(jt),ae.blending===gx&&!1===ae.transparent?oe(pp):oe(ae.blending,ae.blendEquation,ae.blendSrc,ae.blendDst,ae.blendEquationAlpha,ae.blendSrcAlpha,ae.blendDstAlpha,ae.premultipliedAlpha),l.setFunc(ae.depthFunc),l.setTest(ae.depthTest),l.setMask(ae.depthWrite),a.setMask(ae.colorWrite);let Tn=ae.stencilWrite;c.setTest(Tn),Tn&&(c.setMask(ae.stencilWriteMask),c.setFunc(ae.stencilFunc,ae.stencilRef,ae.stencilFuncMask),c.setOp(ae.stencilFail,ae.stencilZFail,ae.stencilZPass)),sn(ae.polygonOffset,ae.polygonOffsetFactor,ae.polygonOffsetUnits),!0===ae.alphaToCoverage?Oe(32926):An(32926)},setFlipSided:Ye,setCullFace:_t,setLineWidth:function(ae){ae!==De&&(fe&&n.lineWidth(ae),De=ae)},setPolygonOffset:sn,setScissorTest:function(ae){ae?Oe(3089):An(3089)},activeTexture:ti,bindTexture:function(ae,Jt){null===de&&ti();let jt=pe[de];void 0===jt&&(jt={type:void 0,texture:void 0},pe[de]=jt),(jt.type!==ae||jt.texture!==Jt)&&(n.bindTexture(ae,Jt||pt[ae]),jt.type=ae,jt.texture=Jt)},unbindTexture:function(){let ae=pe[de];void 0!==ae&&void 0!==ae.type&&(n.bindTexture(ae.type,null),ae.type=void 0,ae.texture=void 0)},compressedTexImage2D:function(){try{n.compressedTexImage2D.apply(n,arguments)}catch(ae){console.error("THREE.WebGLState:",ae)}},texImage2D:function(){try{n.texImage2D.apply(n,arguments)}catch(ae){console.error("THREE.WebGLState:",ae)}},texImage3D:function(){try{n.texImage3D.apply(n,arguments)}catch(ae){console.error("THREE.WebGLState:",ae)}},texStorage2D:function(){try{n.texStorage2D.apply(n,arguments)}catch(ae){console.error("THREE.WebGLState:",ae)}},texStorage3D:function(){try{n.texStorage3D.apply(n,arguments)}catch(ae){console.error("THREE.WebGLState:",ae)}},texSubImage2D:function(){try{n.texSubImage2D.apply(n,arguments)}catch(ae){console.error("THREE.WebGLState:",ae)}},texSubImage3D:function(){try{n.texSubImage3D.apply(n,arguments)}catch(ae){console.error("THREE.WebGLState:",ae)}},compressedTexSubImage2D:function(){try{n.compressedTexSubImage2D.apply(n,arguments)}catch(ae){console.error("THREE.WebGLState:",ae)}},scissor:function(ae){!1===Ne.equals(ae)&&(n.scissor(ae.x,ae.y,ae.z,ae.w),Ne.copy(ae))},viewport:function(ae){!1===lt.equals(ae)&&(n.viewport(ae.x,ae.y,ae.z,ae.w),lt.copy(ae))},reset:function(){n.disable(3042),n.disable(2884),n.disable(2929),n.disable(32823),n.disable(3089),n.disable(2960),n.disable(32926),n.blendEquation(32774),n.blendFunc(1,0),n.blendFuncSeparate(1,0,1,0),n.colorMask(!0,!0,!0,!0),n.clearColor(0,0,0,0),n.depthMask(!0),n.depthFunc(513),n.clearDepth(1),n.stencilMask(4294967295),n.stencilFunc(519,0,4294967295),n.stencilOp(7680,7680,7680),n.clearStencil(0),n.cullFace(1029),n.frontFace(2305),n.polygonOffset(0,0),n.activeTexture(33984),n.bindFramebuffer(36160,null),!0===i&&(n.bindFramebuffer(36009,null),n.bindFramebuffer(36008,null)),n.useProgram(null),n.lineWidth(1),n.scissor(0,0,n.canvas.width,n.canvas.height),n.viewport(0,0,n.canvas.width,n.canvas.height),d={},de=null,pe={},u={},p=new WeakMap,f=[],m=null,b=!1,M=null,y=null,x=null,R=null,A=null,V=null,te=null,K=!1,xe=null,Xe=null,De=null,D=null,re=null,Ne.set(0,0,n.canvas.width,n.canvas.height),lt.set(0,0,n.canvas.width,n.canvas.height),a.reset(),l.reset(),c.reset()}}}function QFe(n,t,e,i,r,o,s){let b,a=r.isWebGL2,l=r.maxTextures,c=r.maxCubemapSize,d=r.maxTextureSize,u=r.maxSamples,f=t.has("WEBGL_multisampled_render_to_texture")?t.get("WEBGL_multisampled_render_to_texture"):void 0,m=new WeakMap,M=!1;try{M=typeof OffscreenCanvas<"u"&&null!==new OffscreenCanvas(1,1).getContext("2d")}catch{}function y(Z,L){return M?new OffscreenCanvas(Z,L):Mx("canvas")}function x(Z,L,Ve,vt){let en=1;if((Z.width>vt||Z.height>vt)&&(en=vt/Math.max(Z.width,Z.height)),en<1||!0===L){if(typeof HTMLImageElement<"u"&&Z instanceof HTMLImageElement||typeof HTMLCanvasElement<"u"&&Z instanceof HTMLCanvasElement||typeof ImageBitmap<"u"&&Z instanceof ImageBitmap){let Le=L?CRe:Math.floor,mn=Le(en*Z.width),ln=Le(en*Z.height);void 0===b&&(b=y(mn,ln));let Ft=Ve?y(mn,ln):b;return Ft.width=mn,Ft.height=ln,Ft.getContext("2d").drawImage(Z,0,0,mn,ln),console.warn("THREE.WebGLRenderer: Texture has been resized from ("+Z.width+"x"+Z.height+") to ("+mn+"x"+ln+")."),Ft}return"data"in Z&&console.warn("THREE.WebGLRenderer: Image in DataTexture is too big ("+Z.width+"x"+Z.height+")."),Z}return Z}function R(Z){return L$(Z.width)&&L$(Z.height)}function V(Z,L){return Z.generateMipmaps&&L&&Z.minFilter!==_o&&Z.minFilter!==$o}function te(Z){n.generateMipmap(Z)}function K(Z,L,Ve,vt,en=!1){if(!1===a)return L;if(null!==Z){if(void 0!==n[Z])return n[Z];console.warn("THREE.WebGLRenderer: Attempt to use non-existing WebGL internal format '"+Z+"'")}let Le=L;return 6403===L&&(5126===Ve&&(Le=33326),5131===Ve&&(Le=33325),5121===Ve&&(Le=33321)),33319===L&&(5126===Ve&&(Le=33328),5131===Ve&&(Le=33327),5121===Ve&&(Le=33323)),6408===L&&(5126===Ve&&(Le=34836),5131===Ve&&(Le=34842),5121===Ve&&(Le=vt===Ar&&!1===en?35907:32856),32819===Ve&&(Le=32854),32820===Ve&&(Le=32855)),(33325===Le||33326===Le||33327===Le||33328===Le||34842===Le||34836===Le)&&t.get("EXT_color_buffer_float"),Le}function xe(Z,L,Ve){return!0===V(Z,Ve)||Z.isFramebufferTexture&&Z.minFilter!==_o&&Z.minFilter!==$o?Math.log2(Math.max(L.width,L.height))+1:void 0!==Z.mipmaps&&Z.mipmaps.length>0?Z.mipmaps.length:Z.isCompressedTexture&&Array.isArray(Z.image)?L.mipmaps.length:1}function Xe(Z){return Z===_o||Z===f$||Z===m$?9728:9729}function De(Z){let L=Z.target;L.removeEventListener("dispose",De),function(Z){let L=i.get(Z);void 0!==L.__webglInit&&(n.deleteTexture(L.__webglTexture),i.remove(Z))}(L),L.isVideoTexture&&m.delete(L),s.memory.textures--}function D(Z){let L=Z.target;L.removeEventListener("dispose",D),function(Z){let L=Z.texture,Ve=i.get(Z),vt=i.get(L);if(Z){if(void 0!==vt.__webglTexture&&(n.deleteTexture(vt.__webglTexture),s.memory.textures--),Z.depthTexture&&Z.depthTexture.dispose(),Z.isWebGLCubeRenderTarget)for(let en=0;en<6;en++)n.deleteFramebuffer(Ve.__webglFramebuffer[en]),Ve.__webglDepthbuffer&&n.deleteRenderbuffer(Ve.__webglDepthbuffer[en]);else n.deleteFramebuffer(Ve.__webglFramebuffer),Ve.__webglDepthbuffer&&n.deleteRenderbuffer(Ve.__webglDepthbuffer),Ve.__webglMultisampledFramebuffer&&n.deleteFramebuffer(Ve.__webglMultisampledFramebuffer),Ve.__webglColorRenderbuffer&&n.deleteRenderbuffer(Ve.__webglColorRenderbuffer),Ve.__webglDepthRenderbuffer&&n.deleteRenderbuffer(Ve.__webglDepthRenderbuffer);if(Z.isWebGLMultipleRenderTargets)for(let en=0,Le=L.length;en<Le;en++){let mn=i.get(L[en]);mn.__webglTexture&&(n.deleteTexture(mn.__webglTexture),s.memory.textures--),i.remove(L[en])}i.remove(L),i.remove(Z)}}(L)}let fe=0;function de(Z,L){let Ve=i.get(Z);if(Z.isVideoTexture&&function(Z){let L=s.render.frame;m.get(Z)!==L&&(m.set(Z,L),Z.update())}(Z),Z.version>0&&Ve.__version!==Z.version){let vt=Z.image;if(void 0===vt)console.warn("THREE.WebGLRenderer: Texture marked for update but image is undefined");else{if(!1!==vt.complete)return void Oe(Ve,Z,L);console.warn("THREE.WebGLRenderer: Texture marked for update but image is incomplete")}}e.activeTexture(33984+L),e.bindTexture(3553,Ve.__webglTexture)}function Ce(Z,L){let Ve=i.get(Z);Z.version>0&&Ve.__version!==Z.version?function(Z,L,Ve){if(6!==L.image.length)return;pt(Z,L),e.activeTexture(33984+Ve),e.bindTexture(34067,Z.__webglTexture),n.pixelStorei(37440,L.flipY),n.pixelStorei(37441,L.premultiplyAlpha),n.pixelStorei(3317,L.unpackAlignment),n.pixelStorei(37443,0);let vt=L&&(L.isCompressedTexture||L.image[0].isCompressedTexture),en=L.image[0]&&L.image[0].isDataTexture,Le=[];for(let We=0;We<6;We++)Le[We]=vt||en?en?L.image[We].image:L.image[We]:x(L.image[We],!1,!0,c),Le[We]=sn(L,Le[We]);let Tn,mn=Le[0],ln=R(mn)||a,Ft=o.convert(L.format,L.encoding),Pt=o.convert(L.type),Ln=K(L.internalFormat,Ft,Pt,L.encoding),ae=a&&!0!==L.isVideoTexture,Jt=void 0===Z.__version,jt=xe(L,mn,ln);if(Mt(34067,L,ln),vt){ae&&Jt&&e.texStorage2D(34067,jt,Ln,mn.width,mn.height);for(let We=0;We<6;We++){Tn=Le[We].mipmaps;for(let bn=0;bn<Tn.length;bn++){let ui=Tn[bn];L.format!==gs?null!==Ft?ae?e.compressedTexSubImage2D(34069+We,bn,0,0,ui.width,ui.height,Ft,ui.data):e.compressedTexImage2D(34069+We,bn,Ln,ui.width,ui.height,0,ui.data):console.warn("THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .setTextureCube()"):ae?e.texSubImage2D(34069+We,bn,0,0,ui.width,ui.height,Ft,Pt,ui.data):e.texImage2D(34069+We,bn,Ln,ui.width,ui.height,0,Ft,Pt,ui.data)}}}else{Tn=L.mipmaps,ae&&Jt&&(Tn.length>0&&jt++,e.texStorage2D(34067,jt,Ln,Le[0].width,Le[0].height));for(let We=0;We<6;We++)if(en){ae?e.texSubImage2D(34069+We,0,0,0,Le[We].width,Le[We].height,Ft,Pt,Le[We].data):e.texImage2D(34069+We,0,Ln,Le[We].width,Le[We].height,0,Ft,Pt,Le[We].data);for(let bn=0;bn<Tn.length;bn++){let ur=Tn[bn].image[We].image;ae?e.texSubImage2D(34069+We,bn+1,0,0,ur.width,ur.height,Ft,Pt,ur.data):e.texImage2D(34069+We,bn+1,Ln,ur.width,ur.height,0,Ft,Pt,ur.data)}}else{ae?e.texSubImage2D(34069+We,0,0,0,Ft,Pt,Le[We]):e.texImage2D(34069+We,0,Ln,Ft,Pt,Le[We]);for(let bn=0;bn<Tn.length;bn++){let ui=Tn[bn];ae?e.texSubImage2D(34069+We,bn+1,0,0,Ft,Pt,ui.image[We]):e.texImage2D(34069+We,bn+1,Ln,Ft,Pt,ui.image[We])}}}V(L,ln)&&te(34067),Z.__version=L.version,L.onUpdate&&L.onUpdate(L)}(Ve,Z,L):(e.activeTexture(33984+L),e.bindTexture(34067,Ve.__webglTexture))}let Ne={[$3]:10497,[ya]:33071,[eB]:33648},lt={[_o]:9728,[f$]:9984,[m$]:9986,[$o]:9729,[JAe]:9985,[QI]:9987};function Mt(Z,L,Ve){if(Ve?(n.texParameteri(Z,10242,Ne[L.wrapS]),n.texParameteri(Z,10243,Ne[L.wrapT]),(32879===Z||35866===Z)&&n.texParameteri(Z,32882,Ne[L.wrapR]),n.texParameteri(Z,10240,lt[L.magFilter]),n.texParameteri(Z,10241,lt[L.minFilter])):(n.texParameteri(Z,10242,33071),n.texParameteri(Z,10243,33071),(32879===Z||35866===Z)&&n.texParameteri(Z,32882,33071),(L.wrapS!==ya||L.wrapT!==ya)&&console.warn("THREE.WebGLRenderer: Texture is not power of two. Texture.wrapS and Texture.wrapT should be set to THREE.ClampToEdgeWrapping."),n.texParameteri(Z,10240,Xe(L.magFilter)),n.texParameteri(Z,10241,Xe(L.minFilter)),L.minFilter!==_o&&L.minFilter!==$o&&console.warn("THREE.WebGLRenderer: Texture is not power of two. Texture.minFilter should be set to THREE.NearestFilter or THREE.LinearFilter.")),!0===t.has("EXT_texture_filter_anisotropic")){let vt=t.get("EXT_texture_filter_anisotropic");if(L.type===cm&&!1===t.has("OES_texture_float_linear")||!1===a&&L.type===U0&&!1===t.has("OES_texture_half_float_linear"))return;(L.anisotropy>1||i.get(L).__currentAnisotropy)&&(n.texParameterf(Z,vt.TEXTURE_MAX_ANISOTROPY_EXT,Math.min(L.anisotropy,r.getMaxAnisotropy())),i.get(L).__currentAnisotropy=L.anisotropy)}}function pt(Z,L){void 0===Z.__webglInit&&(Z.__webglInit=!0,L.addEventListener("dispose",De),Z.__webglTexture=n.createTexture(),s.memory.textures++)}function Oe(Z,L,Ve){let vt=3553;L.isDataTexture2DArray&&(vt=35866),L.isDataTexture3D&&(vt=32879),pt(Z,L),e.activeTexture(33984+Ve),e.bindTexture(vt,Z.__webglTexture),n.pixelStorei(37440,L.flipY),n.pixelStorei(37441,L.premultiplyAlpha),n.pixelStorei(3317,L.unpackAlignment),n.pixelStorei(37443,0);let en=function(Z){return!a&&(Z.wrapS!==ya||Z.wrapT!==ya||Z.minFilter!==_o&&Z.minFilter!==$o)}(L)&&!1===R(L.image),Le=x(L.image,en,!1,d);Le=sn(L,Le);let mn=R(Le)||a,ln=o.convert(L.format,L.encoding),Ft=o.convert(L.type),Pt=K(L.internalFormat,ln,Ft,L.encoding,L.isVideoTexture);Mt(vt,L,mn);let Ln,ae=L.mipmaps,Jt=a&&!0!==L.isVideoTexture,jt=void 0===Z.__version,Tn=xe(L,Le,mn);if(L.isDepthTexture)Pt=6402,a?Pt=L.type===cm?36012:L.type===_I?33190:L.type===j0?35056:33189:L.type===cm&&console.error("WebGLRenderer: Floating point depth texture requires WebGL2."),L.format===um&&6402===Pt&&L.type!==xx&&L.type!==_I&&(console.warn("THREE.WebGLRenderer: Use UnsignedShortType or UnsignedIntType for DepthFormat DepthTexture."),L.type=xx,Ft=o.convert(L.type)),L.format===Y0&&6402===Pt&&(Pt=34041,L.type!==j0&&(console.warn("THREE.WebGLRenderer: Use UnsignedInt248Type for DepthStencilFormat DepthTexture."),L.type=j0,Ft=o.convert(L.type))),Jt&&jt?e.texStorage2D(3553,1,Pt,Le.width,Le.height):e.texImage2D(3553,0,Pt,Le.width,Le.height,0,ln,Ft,null);else if(L.isDataTexture)if(ae.length>0&&mn){Jt&&jt&&e.texStorage2D(3553,Tn,Pt,ae[0].width,ae[0].height);for(let We=0,bn=ae.length;We<bn;We++)Ln=ae[We],Jt?e.texSubImage2D(3553,0,0,0,Ln.width,Ln.height,ln,Ft,Ln.data):e.texImage2D(3553,We,Pt,Ln.width,Ln.height,0,ln,Ft,Ln.data);L.generateMipmaps=!1}else Jt?(jt&&e.texStorage2D(3553,Tn,Pt,Le.width,Le.height),e.texSubImage2D(3553,0,0,0,Le.width,Le.height,ln,Ft,Le.data)):e.texImage2D(3553,0,Pt,Le.width,Le.height,0,ln,Ft,Le.data);else if(L.isCompressedTexture){Jt&&jt&&e.texStorage2D(3553,Tn,Pt,ae[0].width,ae[0].height);for(let We=0,bn=ae.length;We<bn;We++)Ln=ae[We],L.format!==gs?null!==ln?Jt?e.compressedTexSubImage2D(3553,We,0,0,Ln.width,Ln.height,ln,Ln.data):e.compressedTexImage2D(3553,We,Pt,Ln.width,Ln.height,0,Ln.data):console.warn("THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .uploadTexture()"):Jt?e.texSubImage2D(3553,We,0,0,Ln.width,Ln.height,ln,Ft,Ln.data):e.texImage2D(3553,We,Pt,Ln.width,Ln.height,0,ln,Ft,Ln.data)}else if(L.isDataTexture2DArray)Jt?(jt&&e.texStorage3D(35866,Tn,Pt,Le.width,Le.height,Le.depth),e.texSubImage3D(35866,0,0,0,0,Le.width,Le.height,Le.depth,ln,Ft,Le.data)):e.texImage3D(35866,0,Pt,Le.width,Le.height,Le.depth,0,ln,Ft,Le.data);else if(L.isDataTexture3D)Jt?(jt&&e.texStorage3D(32879,Tn,Pt,Le.width,Le.height,Le.depth),e.texSubImage3D(32879,0,0,0,0,Le.width,Le.height,Le.depth,ln,Ft,Le.data)):e.texImage3D(32879,0,Pt,Le.width,Le.height,Le.depth,0,ln,Ft,Le.data);else if(L.isFramebufferTexture)Jt&&jt?e.texStorage2D(3553,Tn,Pt,Le.width,Le.height):e.texImage2D(3553,0,Pt,Le.width,Le.height,0,ln,Ft,null);else if(ae.length>0&&mn){Jt&&jt&&e.texStorage2D(3553,Tn,Pt,ae[0].width,ae[0].height);for(let We=0,bn=ae.length;We<bn;We++)Ln=ae[We],Jt?e.texSubImage2D(3553,We,0,0,ln,Ft,Ln):e.texImage2D(3553,We,Pt,ln,Ft,Ln);L.generateMipmaps=!1}else Jt?(jt&&e.texStorage2D(3553,Tn,Pt,Le.width,Le.height),e.texSubImage2D(3553,0,0,0,ln,Ft,Le)):e.texImage2D(3553,0,Pt,ln,Ft,Le);V(L,mn)&&te(vt),Z.__version=L.version,L.onUpdate&&L.onUpdate(L)}function wt(Z,L,Ve,vt,en){let Le=o.convert(Ve.format,Ve.encoding),mn=o.convert(Ve.type),ln=K(Ve.internalFormat,Le,mn,Ve.encoding);i.get(L).__hasExternalTextures||(32879===en||35866===en?e.texImage3D(en,0,ln,L.width,L.height,L.depth,0,Le,mn,null):e.texImage2D(en,0,ln,L.width,L.height,0,Le,mn,null)),e.bindFramebuffer(36160,Z),L.useRenderToTexture?f.framebufferTexture2DMultisampleEXT(36160,vt,en,i.get(Ve).__webglTexture,0,_t(L)):n.framebufferTexture2D(36160,vt,en,i.get(Ve).__webglTexture,0),e.bindFramebuffer(36160,null)}function on(Z,L,Ve){if(n.bindRenderbuffer(36161,Z),L.depthBuffer&&!L.stencilBuffer){let vt=33189;if(Ve||L.useRenderToTexture){let en=L.depthTexture;en&&en.isDepthTexture&&(en.type===cm?vt=36012:en.type===_I&&(vt=33190));let Le=_t(L);L.useRenderToTexture?f.renderbufferStorageMultisampleEXT(36161,Le,vt,L.width,L.height):n.renderbufferStorageMultisample(36161,Le,vt,L.width,L.height)}else n.renderbufferStorage(36161,vt,L.width,L.height);n.framebufferRenderbuffer(36160,36096,36161,Z)}else if(L.depthBuffer&&L.stencilBuffer){let vt=_t(L);Ve&&L.useRenderbuffer?n.renderbufferStorageMultisample(36161,vt,35056,L.width,L.height):L.useRenderToTexture?f.renderbufferStorageMultisampleEXT(36161,vt,35056,L.width,L.height):n.renderbufferStorage(36161,34041,L.width,L.height),n.framebufferRenderbuffer(36160,33306,36161,Z)}else{let vt=!0===L.isWebGLMultipleRenderTargets?L.texture[0]:L.texture,en=o.convert(vt.format,vt.encoding),Le=o.convert(vt.type),mn=K(vt.internalFormat,en,Le,vt.encoding),ln=_t(L);Ve&&L.useRenderbuffer?n.renderbufferStorageMultisample(36161,ln,mn,L.width,L.height):L.useRenderToTexture?f.renderbufferStorageMultisampleEXT(36161,ln,mn,L.width,L.height):n.renderbufferStorage(36161,mn,L.width,L.height)}n.bindRenderbuffer(36161,null)}function mt(Z){let L=i.get(Z),Ve=!0===Z.isWebGLCubeRenderTarget;if(Z.depthTexture&&!L.__autoAllocateDepthBuffer){if(Ve)throw new Error("target.depthTexture not supported in Cube render targets");!function(Z,L){if(L&&L.isWebGLCubeRenderTarget)throw new Error("Depth Texture with cube render targets is not supported");if(e.bindFramebuffer(36160,Z),!L.depthTexture||!L.depthTexture.isDepthTexture)throw new Error("renderTarget.depthTexture must be an instance of THREE.DepthTexture");(!i.get(L.depthTexture).__webglTexture||L.depthTexture.image.width!==L.width||L.depthTexture.image.height!==L.height)&&(L.depthTexture.image.width=L.width,L.depthTexture.image.height=L.height,L.depthTexture.needsUpdate=!0),de(L.depthTexture,0);let vt=i.get(L.depthTexture).__webglTexture,en=_t(L);if(L.depthTexture.format===um)L.useRenderToTexture?f.framebufferTexture2DMultisampleEXT(36160,36096,3553,vt,0,en):n.framebufferTexture2D(36160,36096,3553,vt,0);else{if(L.depthTexture.format!==Y0)throw new Error("Unknown depthTexture format");L.useRenderToTexture?f.framebufferTexture2DMultisampleEXT(36160,33306,3553,vt,0,en):n.framebufferTexture2D(36160,33306,3553,vt,0)}}(L.__webglFramebuffer,Z)}else if(Ve){L.__webglDepthbuffer=[];for(let vt=0;vt<6;vt++)e.bindFramebuffer(36160,L.__webglFramebuffer[vt]),L.__webglDepthbuffer[vt]=n.createRenderbuffer(),on(L.__webglDepthbuffer[vt],Z,!1)}else e.bindFramebuffer(36160,L.__webglFramebuffer),L.__webglDepthbuffer=n.createRenderbuffer(),on(L.__webglDepthbuffer,Z,!1);e.bindFramebuffer(36160,null)}function _t(Z){return a&&(Z.useRenderbuffer||Z.useRenderToTexture)?Math.min(u,Z.samples):0}function sn(Z,L){let Ve=Z.encoding,vt=Z.format,en=Z.type;return!0===Z.isCompressedTexture||!0===Z.isVideoTexture||Z.format===tB||Ve!==_p&&(Ve===Ar?!1===a?!0===t.has("EXT_sRGB")&&vt===gs?(Z.format=tB,Z.minFilter=$o,Z.generateMipmaps=!1):L=jd.sRGBToLinear(L):(vt!==gs||en!==mp)&&console.warn("THREE.WebGLTextures: sRGB encoded textures have to use RGBAFormat and UnsignedByteType."):console.error("THREE.WebGLTextures: Unsupported texture encoding:",Ve)),L}let Cn=!1,ti=!1;this.allocateTextureUnit=function(){let Z=fe;return Z>=l&&console.warn("THREE.WebGLTextures: Trying to use "+Z+" texture units while this GPU supports only "+l),fe+=1,Z},this.resetTextureUnits=function(){fe=0},this.setTexture2D=de,this.setTexture2DArray=function(Z,L){let Ve=i.get(Z);Z.version>0&&Ve.__version!==Z.version?Oe(Ve,Z,L):(e.activeTexture(33984+L),e.bindTexture(35866,Ve.__webglTexture))},this.setTexture3D=function(Z,L){let Ve=i.get(Z);Z.version>0&&Ve.__version!==Z.version?Oe(Ve,Z,L):(e.activeTexture(33984+L),e.bindTexture(32879,Ve.__webglTexture))},this.setTextureCube=Ce,this.rebindTextures=function(Z,L,Ve){let vt=i.get(Z);void 0!==L&&wt(vt.__webglFramebuffer,Z,Z.texture,36064,3553),void 0!==Ve&&mt(Z)},this.setupRenderTarget=function(Z){let L=Z.texture,Ve=i.get(Z),vt=i.get(L);Z.addEventListener("dispose",D),!0!==Z.isWebGLMultipleRenderTargets&&(void 0===vt.__webglTexture&&(vt.__webglTexture=n.createTexture()),vt.__version=L.version,s.memory.textures++);let en=!0===Z.isWebGLCubeRenderTarget,Le=!0===Z.isWebGLMultipleRenderTargets,mn=L.isDataTexture3D||L.isDataTexture2DArray,ln=R(Z)||a;if(en){Ve.__webglFramebuffer=[];for(let Ft=0;Ft<6;Ft++)Ve.__webglFramebuffer[Ft]=n.createFramebuffer()}else if(Ve.__webglFramebuffer=n.createFramebuffer(),Le)if(r.drawBuffers){let Ft=Z.texture;for(let Pt=0,Ln=Ft.length;Pt<Ln;Pt++){let ae=i.get(Ft[Pt]);void 0===ae.__webglTexture&&(ae.__webglTexture=n.createTexture(),s.memory.textures++)}}else console.warn("THREE.WebGLRenderer: WebGLMultipleRenderTargets can only be used with WebGL2 or WEBGL_draw_buffers extension.");else if(Z.useRenderbuffer)if(a){Ve.__webglMultisampledFramebuffer=n.createFramebuffer(),Ve.__webglColorRenderbuffer=n.createRenderbuffer(),n.bindRenderbuffer(36161,Ve.__webglColorRenderbuffer);let Ft=o.convert(L.format,L.encoding),Pt=o.convert(L.type),Ln=K(L.internalFormat,Ft,Pt,L.encoding),ae=_t(Z);n.renderbufferStorageMultisample(36161,ae,Ln,Z.width,Z.height),e.bindFramebuffer(36160,Ve.__webglMultisampledFramebuffer),n.framebufferRenderbuffer(36160,36064,36161,Ve.__webglColorRenderbuffer),n.bindRenderbuffer(36161,null),Z.depthBuffer&&(Ve.__webglDepthRenderbuffer=n.createRenderbuffer(),on(Ve.__webglDepthRenderbuffer,Z,!0)),e.bindFramebuffer(36160,null)}else console.warn("THREE.WebGLRenderer: WebGLMultisampleRenderTarget can only be used with WebGL2.");if(en){e.bindTexture(34067,vt.__webglTexture),Mt(34067,L,ln);for(let Ft=0;Ft<6;Ft++)wt(Ve.__webglFramebuffer[Ft],Z,L,36064,34069+Ft);V(L,ln)&&te(34067),e.unbindTexture()}else if(Le){let Ft=Z.texture;for(let Pt=0,Ln=Ft.length;Pt<Ln;Pt++){let ae=Ft[Pt],Jt=i.get(ae);e.bindTexture(3553,Jt.__webglTexture),Mt(3553,ae,ln),wt(Ve.__webglFramebuffer,Z,ae,36064+Pt,3553),V(ae,ln)&&te(3553)}e.unbindTexture()}else{let Ft=3553;mn&&(a?Ft=L.isDataTexture3D?32879:35866:console.warn("THREE.DataTexture3D and THREE.DataTexture2DArray only supported with WebGL2.")),e.bindTexture(Ft,vt.__webglTexture),Mt(Ft,L,ln),wt(Ve.__webglFramebuffer,Z,L,36064,Ft),V(L,ln)&&te(Ft),e.unbindTexture()}Z.depthBuffer&&mt(Z)},this.updateRenderTargetMipmap=function(Z){let L=R(Z)||a,Ve=!0===Z.isWebGLMultipleRenderTargets?Z.texture:[Z.texture];for(let vt=0,en=Ve.length;vt<en;vt++){let Le=Ve[vt];if(V(Le,L)){let mn=Z.isWebGLCubeRenderTarget?34067:3553,ln=i.get(Le).__webglTexture;e.bindTexture(mn,ln),te(mn),e.unbindTexture()}}},this.updateMultisampleRenderTarget=function(Z){if(Z.useRenderbuffer)if(a){let L=Z.width,Ve=Z.height,vt=16384,en=[36064],Le=Z.stencilBuffer?33306:36096;Z.depthBuffer&&en.push(Le),Z.ignoreDepthForMultisampleCopy||(Z.depthBuffer&&(vt|=256),Z.stencilBuffer&&(vt|=1024));let mn=i.get(Z);e.bindFramebuffer(36008,mn.__webglMultisampledFramebuffer),e.bindFramebuffer(36009,mn.__webglFramebuffer),Z.ignoreDepthForMultisampleCopy&&(n.invalidateFramebuffer(36008,[Le]),n.invalidateFramebuffer(36009,[Le])),n.blitFramebuffer(0,0,L,Ve,0,0,L,Ve,vt,9728),n.invalidateFramebuffer(36008,en),e.bindFramebuffer(36008,null),e.bindFramebuffer(36009,mn.__webglMultisampledFramebuffer)}else console.warn("THREE.WebGLRenderer: WebGLMultisampleRenderTarget can only be used with WebGL2.")},this.setupDepthRenderbuffer=mt,this.setupFrameBufferTexture=wt,this.safeSetTexture2D=function(Z,L){Z&&Z.isWebGLRenderTarget&&(!1===Cn&&(console.warn("THREE.WebGLTextures.safeSetTexture2D: don't use render targets as textures. Use their .texture property instead."),Cn=!0),Z=Z.texture),de(Z,L)},this.safeSetTextureCube=function(Z,L){Z&&Z.isWebGLCubeRenderTarget&&(!1===ti&&(console.warn("THREE.WebGLTextures.safeSetTextureCube: don't use cube render targets as textures. Use their .texture property instead."),ti=!0),Z=Z.texture),Ce(Z,L)}}function ZFe(n,t,e){let i=e.isWebGL2;return{convert:function(o,s=null){let a;if(o===mp)return 5121;if(o===nRe)return 32819;if(o===iRe)return 32820;if(o===$Ae)return 5120;if(o===eRe)return 5122;if(o===xx)return 5123;if(o===tRe)return 5124;if(o===_I)return 5125;if(o===cm)return 5126;if(o===U0)return i?5131:(a=t.get("OES_texture_half_float"),null!==a?a.HALF_FLOAT_OES:null);if(o===rRe)return 6406;if(o===gs)return 6408;if(o===oRe)return 6409;if(o===sRe)return 6410;if(o===um)return 6402;if(o===Y0)return 34041;if(o===aRe)return 6403;if(o===tB)return a=t.get("EXT_sRGB"),null!==a?a.SRGB_ALPHA_EXT:null;if(o===lRe)return 36244;if(o===cRe)return 33319;if(o===dRe)return 33320;if(o===uRe)return 36249;if(o===u3||o===p3||o===f3||o===m3)if(s===Ar){if(a=t.get("WEBGL_compressed_texture_s3tc_srgb"),null===a)return null;if(o===u3)return a.COMPRESSED_SRGB_S3TC_DXT1_EXT;if(o===p3)return a.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT;if(o===f3)return a.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT;if(o===m3)return a.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT}else{if(a=t.get("WEBGL_compressed_texture_s3tc"),null===a)return null;if(o===u3)return a.COMPRESSED_RGB_S3TC_DXT1_EXT;if(o===p3)return a.COMPRESSED_RGBA_S3TC_DXT1_EXT;if(o===f3)return a.COMPRESSED_RGBA_S3TC_DXT3_EXT;if(o===m3)return a.COMPRESSED_RGBA_S3TC_DXT5_EXT}if(o===h$||o===g$||o===_$||o===b$){if(a=t.get("WEBGL_compressed_texture_pvrtc"),null===a)return null;if(o===h$)return a.COMPRESSED_RGB_PVRTC_4BPPV1_IMG;if(o===g$)return a.COMPRESSED_RGB_PVRTC_2BPPV1_IMG;if(o===_$)return a.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG;if(o===b$)return a.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG}if(o===pRe)return a=t.get("WEBGL_compressed_texture_etc1"),null!==a?a.COMPRESSED_RGB_ETC1_WEBGL:null;if(o===v$||o===y$){if(a=t.get("WEBGL_compressed_texture_etc"),null===a)return null;if(o===v$)return s===Ar?a.COMPRESSED_SRGB8_ETC2:a.COMPRESSED_RGB8_ETC2;if(o===y$)return s===Ar?a.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:a.COMPRESSED_RGBA8_ETC2_EAC}if(o===x$||o===C$||o===M$||o===w$||o===S$||o===E$||o===T$||o===D$||o===I$||o===A$||o===R$||o===P$||o===O$||o===k$){if(a=t.get("WEBGL_compressed_texture_astc"),null===a)return null;if(o===x$)return s===Ar?a.COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR:a.COMPRESSED_RGBA_ASTC_4x4_KHR;if(o===C$)return s===Ar?a.COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR:a.COMPRESSED_RGBA_ASTC_5x4_KHR;if(o===M$)return s===Ar?a.COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR:a.COMPRESSED_RGBA_ASTC_5x5_KHR;if(o===w$)return s===Ar?a.COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR:a.COMPRESSED_RGBA_ASTC_6x5_KHR;if(o===S$)return s===Ar?a.COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR:a.COMPRESSED_RGBA_ASTC_6x6_KHR;if(o===E$)return s===Ar?a.COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR:a.COMPRESSED_RGBA_ASTC_8x5_KHR;if(o===T$)return s===Ar?a.COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR:a.COMPRESSED_RGBA_ASTC_8x6_KHR;if(o===D$)return s===Ar?a.COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR:a.COMPRESSED_RGBA_ASTC_8x8_KHR;if(o===I$)return s===Ar?a.COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR:a.COMPRESSED_RGBA_ASTC_10x5_KHR;if(o===A$)return s===Ar?a.COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR:a.COMPRESSED_RGBA_ASTC_10x6_KHR;if(o===R$)return s===Ar?a.COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR:a.COMPRESSED_RGBA_ASTC_10x8_KHR;if(o===P$)return s===Ar?a.COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR:a.COMPRESSED_RGBA_ASTC_10x10_KHR;if(o===O$)return s===Ar?a.COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR:a.COMPRESSED_RGBA_ASTC_12x10_KHR;if(o===k$)return s===Ar?a.COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR:a.COMPRESSED_RGBA_ASTC_12x12_KHR}if(o===F$){if(a=t.get("EXT_texture_compression_bptc"),null===a)return null;if(o===F$)return s===Ar?a.COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT:a.COMPRESSED_RGBA_BPTC_UNORM_EXT}return o===j0?i?34042:(a=t.get("WEBGL_depth_texture"),null!==a?a.UNSIGNED_INT_24_8_WEBGL:null):void 0}}}var AI=class extends es{constructor(t=[]){super(),this.cameras=t}};AI.prototype.isArrayCamera=!0;var dm=class extends Bi{constructor(){super(),this.type="Group"}};dm.prototype.isGroup=!0;var KFe={type:"move"},_x=class{constructor(){this._targetRay=null,this._grip=null,this._hand=null}getHandSpace(){return null===this._hand&&(this._hand=new dm,this._hand.matrixAutoUpdate=!1,this._hand.visible=!1,this._hand.joints={},this._hand.inputState={pinching:!1}),this._hand}getTargetRaySpace(){return null===this._targetRay&&(this._targetRay=new dm,this._targetRay.matrixAutoUpdate=!1,this._targetRay.visible=!1,this._targetRay.hasLinearVelocity=!1,this._targetRay.linearVelocity=new $,this._targetRay.hasAngularVelocity=!1,this._targetRay.angularVelocity=new $),this._targetRay}getGripSpace(){return null===this._grip&&(this._grip=new dm,this._grip.matrixAutoUpdate=!1,this._grip.visible=!1,this._grip.hasLinearVelocity=!1,this._grip.linearVelocity=new $,this._grip.hasAngularVelocity=!1,this._grip.angularVelocity=new $),this._grip}dispatchEvent(t){return null!==this._targetRay&&this._targetRay.dispatchEvent(t),null!==this._grip&&this._grip.dispatchEvent(t),null!==this._hand&&this._hand.dispatchEvent(t),this}disconnect(t){return this.dispatchEvent({type:"disconnected",data:t}),null!==this._targetRay&&(this._targetRay.visible=!1),null!==this._grip&&(this._grip.visible=!1),null!==this._hand&&(this._hand.visible=!1),this}update(t,e,i){let r=null,o=null,s=null,a=this._targetRay,l=this._grip,c=this._hand;if(t&&"visible-blurred"!==e.session.visibilityState)if(null!==a&&(r=e.getPose(t.targetRaySpace,i),null!==r&&(a.matrix.fromArray(r.transform.matrix),a.matrix.decompose(a.position,a.rotation,a.scale),r.linearVelocity?(a.hasLinearVelocity=!0,a.linearVelocity.copy(r.linearVelocity)):a.hasLinearVelocity=!1,r.angularVelocity?(a.hasAngularVelocity=!0,a.angularVelocity.copy(r.angularVelocity)):a.hasAngularVelocity=!1,this.dispatchEvent(KFe))),c&&t.hand){s=!0;for(let b of t.hand.values()){let M=e.getJointPose(b,i);if(void 0===c.joints[b.jointName]){let x=new dm;x.matrixAutoUpdate=!1,x.visible=!1,c.joints[b.jointName]=x,c.add(x)}let y=c.joints[b.jointName];null!==M&&(y.matrix.fromArray(M.transform.matrix),y.matrix.decompose(y.position,y.rotation,y.scale),y.jointRadius=M.radius),y.visible=null!==M}let p=c.joints["index-finger-tip"].position.distanceTo(c.joints["thumb-tip"].position),f=.02,m=.005;c.inputState.pinching&&p>f+m?(c.inputState.pinching=!1,this.dispatchEvent({type:"pinchend",handedness:t.handedness,target:this})):!c.inputState.pinching&&p<=f-m&&(c.inputState.pinching=!0,this.dispatchEvent({type:"pinchstart",handedness:t.handedness,target:this}))}else null!==l&&t.gripSpace&&(o=e.getPose(t.gripSpace,i),null!==o&&(l.matrix.fromArray(o.transform.matrix),l.matrix.decompose(l.position,l.rotation,l.scale),o.linearVelocity?(l.hasLinearVelocity=!0,l.linearVelocity.copy(o.linearVelocity)):l.hasLinearVelocity=!1,o.angularVelocity?(l.hasAngularVelocity=!0,l.angularVelocity.copy(o.angularVelocity)):l.hasAngularVelocity=!1));return null!==a&&(a.visible=null!==r),null!==l&&(l.visible=null!==o),null!==c&&(c.visible=null!==s),this}},Ix=class extends lo{constructor(t,e,i,r,o,s,a,l,c,d){if((d=void 0!==d?d:um)!==um&&d!==Y0)throw new Error("DepthTexture format must be either THREE.DepthFormat or THREE.DepthStencilFormat");void 0===i&&d===um&&(i=xx),void 0===i&&d===Y0&&(i=j0),super(null,r,o,s,a,l,d,i,c),this.image={width:t,height:e},this.magFilter=void 0!==a?a:_o,this.minFilter=void 0!==l?l:_o,this.flipY=!1,this.generateMipmaps=!1}};Ix.prototype.isDepthTexture=!0;var lB=class extends Ud{constructor(t,e){super();let i=this,r=null,o=1,s=null,a="local-floor",l=t.extensions.has("WEBGL_multisampled_render_to_texture"),c=null,d=null,u=null,p=null,f=!1,m=null,b=e.getContextAttributes(),M=null,y=null,x=[],R=new Map,A=new es;A.layers.enable(1),A.viewport=new Zi;let V=new es;V.layers.enable(2),V.viewport=new Zi;let te=[A,V],K=new AI;K.layers.enable(1),K.layers.enable(2);let xe=null,Xe=null;function De(Ce){let Ne=R.get(Ce.inputSource);Ne&&Ne.dispatchEvent({type:Ce.type,data:Ce.inputSource})}function D(){R.forEach(function(Ce,Ne){Ce.disconnect(Ne)}),R.clear(),xe=null,Xe=null,t.setRenderTarget(M),p=null,u=null,d=null,r=null,y=null,je.stop(),i.isPresenting=!1,i.dispatchEvent({type:"sessionend"})}function re(Ce){let Ne=r.inputSources;for(let lt=0;lt<x.length;lt++)R.set(Ne[lt],x[lt]);for(let lt=0;lt<Ce.removed.length;lt++){let Mt=Ce.removed[lt],pt=R.get(Mt);pt&&(pt.dispatchEvent({type:"disconnected",data:Mt}),R.delete(Mt))}for(let lt=0;lt<Ce.added.length;lt++){let Mt=Ce.added[lt],pt=R.get(Mt);pt&&pt.dispatchEvent({type:"connected",data:Mt})}}this.cameraAutoUpdate=!0,this.enabled=!1,this.isPresenting=!1,this.getController=function(Ce){let Ne=x[Ce];return void 0===Ne&&(Ne=new _x,x[Ce]=Ne),Ne.getTargetRaySpace()},this.getControllerGrip=function(Ce){let Ne=x[Ce];return void 0===Ne&&(Ne=new _x,x[Ce]=Ne),Ne.getGripSpace()},this.getHand=function(Ce){let Ne=x[Ce];return void 0===Ne&&(Ne=new _x,x[Ce]=Ne),Ne.getHandSpace()},this.setFramebufferScaleFactor=function(Ce){o=Ce,!0===i.isPresenting&&console.warn("THREE.WebXRManager: Cannot change framebuffer scale while presenting.")},this.setReferenceSpaceType=function(Ce){a=Ce,!0===i.isPresenting&&console.warn("THREE.WebXRManager: Cannot change reference space type while presenting.")},this.getReferenceSpace=function(){return s},this.getBaseLayer=function(){return null!==u?u:p},this.getBinding=function(){return d},this.getFrame=function(){return m},this.getSession=function(){return r},this.setSession=async function(Ce){if(r=Ce,null!==r){if(M=t.getRenderTarget(),r.addEventListener("select",De),r.addEventListener("selectstart",De),r.addEventListener("selectend",De),r.addEventListener("squeeze",De),r.addEventListener("squeezestart",De),r.addEventListener("squeezeend",De),r.addEventListener("end",D),r.addEventListener("inputsourceschange",re),!0!==b.xrCompatible&&await e.makeXRCompatible(),void 0===r.renderState.layers||!1===t.capabilities.isWebGL2)p=new XRWebGLLayer(r,e,{antialias:void 0!==r.renderState.layers||b.antialias,alpha:b.alpha,depth:b.depth,stencil:b.stencil,framebufferScaleFactor:o}),r.updateRenderState({baseLayer:p}),y=new Js(p.framebufferWidth,p.framebufferHeight,{format:gs,type:mp,encoding:t.outputEncoding});else{f=b.antialias;let Ne=null,lt=null,Mt=null;b.depth&&(Mt=b.stencil?35056:33190,Ne=b.stencil?Y0:um,lt=b.stencil?j0:xx);let pt={colorFormat:t.outputEncoding===Ar?35907:32856,depthFormat:Mt,scaleFactor:o};d=new XRWebGLBinding(r,e),u=d.createProjectionLayer(pt),r.updateRenderState({layers:[u]}),y=f?new wx(u.textureWidth,u.textureHeight,{format:gs,type:mp,depthTexture:new Ix(u.textureWidth,u.textureHeight,lt,void 0,void 0,void 0,void 0,void 0,void 0,Ne),stencilBuffer:b.stencil,ignoreDepth:u.ignoreDepthValues,useRenderToTexture:l,encoding:t.outputEncoding}):new Js(u.textureWidth,u.textureHeight,{format:gs,type:mp,depthTexture:new Ix(u.textureWidth,u.textureHeight,lt,void 0,void 0,void 0,void 0,void 0,void 0,Ne),stencilBuffer:b.stencil,ignoreDepth:u.ignoreDepthValues,encoding:t.outputEncoding})}y.isXRRenderTarget=!0,this.setFoveation(1),s=await r.requestReferenceSpace(a),je.setContext(r),je.start(),i.isPresenting=!0,i.dispatchEvent({type:"sessionstart"})}};let ce=new $,fe=new $;function ne(Ce,Ne){null===Ne?Ce.matrixWorld.copy(Ce.matrix):Ce.matrixWorld.multiplyMatrices(Ne.matrixWorld,Ce.matrix),Ce.matrixWorldInverse.copy(Ce.matrixWorld).invert()}this.updateCamera=function(Ce){if(null===r)return;K.near=V.near=A.near=Ce.near,K.far=V.far=A.far=Ce.far,(xe!==K.near||Xe!==K.far)&&(r.updateRenderState({depthNear:K.near,depthFar:K.far}),xe=K.near,Xe=K.far);let Ne=Ce.parent,lt=K.cameras;ne(K,Ne);for(let pt=0;pt<lt.length;pt++)ne(lt[pt],Ne);K.matrixWorld.decompose(K.position,K.quaternion,K.scale),Ce.position.copy(K.position),Ce.quaternion.copy(K.quaternion),Ce.scale.copy(K.scale),Ce.matrix.copy(K.matrix),Ce.matrixWorld.copy(K.matrixWorld);let Mt=Ce.children;for(let pt=0,Oe=Mt.length;pt<Oe;pt++)Mt[pt].updateMatrixWorld(!0);2===lt.length?function(Ce,Ne,lt){ce.setFromMatrixPosition(Ne.matrixWorld),fe.setFromMatrixPosition(lt.matrixWorld);let Mt=ce.distanceTo(fe),pt=Ne.projectionMatrix.elements,Oe=lt.projectionMatrix.elements,An=pt[14]/(pt[10]-1),wt=pt[14]/(pt[10]+1),on=(pt[9]+1)/pt[5],ve=(pt[9]-1)/pt[5],mt=(pt[8]-1)/pt[0],ft=(Oe[8]+1)/Oe[0],oe=An*mt,st=An*ft,Ye=Mt/(-mt+ft),_t=Ye*-mt;Ne.matrixWorld.decompose(Ce.position,Ce.quaternion,Ce.scale),Ce.translateX(_t),Ce.translateZ(Ye),Ce.matrixWorld.compose(Ce.position,Ce.quaternion,Ce.scale),Ce.matrixWorldInverse.copy(Ce.matrixWorld).invert();let ut=An+Ye,sn=wt+Ye;Ce.projectionMatrix.makePerspective(oe-_t,st+(Mt-_t),on*wt/sn*ut,ve*wt/sn*ut,ut,sn)}(K,A,V):K.projectionMatrix.copy(A.projectionMatrix)},this.getCamera=function(){return K},this.getFoveation=function(){return null!==u?u.fixedFoveation:null!==p?p.fixedFoveation:void 0},this.setFoveation=function(Ce){null!==u&&(u.fixedFoveation=Ce),null!==p&&void 0!==p.fixedFoveation&&(p.fixedFoveation=Ce)};let de=null,je=new Zee;je.setAnimationLoop(function(Ce,Ne){if(c=Ne.getViewerPose(s),m=Ne,null!==c){let Mt=c.views;null!==p&&(t.setRenderTargetFramebuffer(y,p.framebuffer),t.setRenderTarget(y));let pt=!1;Mt.length!==K.cameras.length&&(K.cameras.length=0,pt=!0);for(let Oe=0;Oe<Mt.length;Oe++){let An=Mt[Oe],wt=null;if(null!==p)wt=p.getViewport(An);else{let ve=d.getViewSubImage(u,An);wt=ve.viewport,0===Oe&&(t.setRenderTargetTextures(y,ve.colorTexture,u.ignoreDepthValues?void 0:ve.depthStencilTexture),t.setRenderTarget(y))}let on=te[Oe];on.matrix.fromArray(An.transform.matrix),on.projectionMatrix.fromArray(An.projectionMatrix),on.viewport.set(wt.x,wt.y,wt.width,wt.height),0===Oe&&K.matrix.copy(on.matrix),!0===pt&&K.cameras.push(on)}}let lt=r.inputSources;for(let Mt=0;Mt<x.length;Mt++)x[Mt].update(lt[Mt],Ne,s);de&&de(Ce,Ne),m=null}),this.setAnimationLoop=function(Ce){de=Ce},this.dispose=function(){}}};function JFe(n){function i(y,x){y.opacity.value=x.opacity,x.color&&y.diffuse.value.copy(x.color),x.emissive&&y.emissive.value.copy(x.emissive).multiplyScalar(x.emissiveIntensity),x.map&&(y.map.value=x.map),x.alphaMap&&(y.alphaMap.value=x.alphaMap),x.specularMap&&(y.specularMap.value=x.specularMap),x.alphaTest>0&&(y.alphaTest.value=x.alphaTest);let A,V,R=n.get(x).envMap;R&&(y.envMap.value=R,y.flipEnvMap.value=R.isCubeTexture&&!1===R.isRenderTargetTexture?-1:1,y.reflectivity.value=x.reflectivity,y.ior.value=x.ior,y.refractionRatio.value=x.refractionRatio),x.lightMap&&(y.lightMap.value=x.lightMap,y.lightMapIntensity.value=x.lightMapIntensity),x.aoMap&&(y.aoMap.value=x.aoMap,y.aoMapIntensity.value=x.aoMapIntensity),x.map?A=x.map:x.specularMap?A=x.specularMap:x.displacementMap?A=x.displacementMap:x.normalMap?A=x.normalMap:x.bumpMap?A=x.bumpMap:x.roughnessMap?A=x.roughnessMap:x.metalnessMap?A=x.metalnessMap:x.alphaMap?A=x.alphaMap:x.emissiveMap?A=x.emissiveMap:x.clearcoatMap?A=x.clearcoatMap:x.clearcoatNormalMap?A=x.clearcoatNormalMap:x.clearcoatRoughnessMap?A=x.clearcoatRoughnessMap:x.specularIntensityMap?A=x.specularIntensityMap:x.specularColorMap?A=x.specularColorMap:x.transmissionMap?A=x.transmissionMap:x.thicknessMap?A=x.thicknessMap:x.sheenColorMap?A=x.sheenColorMap:x.sheenRoughnessMap&&(A=x.sheenRoughnessMap),void 0!==A&&(A.isWebGLRenderTarget&&(A=A.texture),!0===A.matrixAutoUpdate&&A.updateMatrix(),y.uvTransform.value.copy(A.matrix)),x.aoMap?V=x.aoMap:x.lightMap&&(V=x.lightMap),void 0!==V&&(V.isWebGLRenderTarget&&(V=V.texture),!0===V.matrixAutoUpdate&&V.updateMatrix(),y.uv2Transform.value.copy(V.matrix))}function u(y,x){y.roughness.value=x.roughness,y.metalness.value=x.metalness,x.roughnessMap&&(y.roughnessMap.value=x.roughnessMap),x.metalnessMap&&(y.metalnessMap.value=x.metalnessMap),x.emissiveMap&&(y.emissiveMap.value=x.emissiveMap),x.bumpMap&&(y.bumpMap.value=x.bumpMap,y.bumpScale.value=x.bumpScale,x.side===go&&(y.bumpScale.value*=-1)),x.normalMap&&(y.normalMap.value=x.normalMap,y.normalScale.value.copy(x.normalScale),x.side===go&&y.normalScale.value.negate()),x.displacementMap&&(y.displacementMap.value=x.displacementMap,y.displacementScale.value=x.displacementScale,y.displacementBias.value=x.displacementBias),n.get(x).envMap&&(y.envMapIntensity.value=x.envMapIntensity)}return{refreshFogUniforms:function(y,x){y.fogColor.value.copy(x.color),x.isFog?(y.fogNear.value=x.near,y.fogFar.value=x.far):x.isFogExp2&&(y.fogDensity.value=x.density)},refreshMaterialUniforms:function(y,x,R,A,V){x.isMeshBasicMaterial?i(y,x):x.isMeshLambertMaterial?(i(y,x),function(y,x){x.emissiveMap&&(y.emissiveMap.value=x.emissiveMap)}(y,x)):x.isMeshToonMaterial?(i(y,x),function(y,x){x.gradientMap&&(y.gradientMap.value=x.gradientMap),x.emissiveMap&&(y.emissiveMap.value=x.emissiveMap),x.bumpMap&&(y.bumpMap.value=x.bumpMap,y.bumpScale.value=x.bumpScale,x.side===go&&(y.bumpScale.value*=-1)),x.normalMap&&(y.normalMap.value=x.normalMap,y.normalScale.value.copy(x.normalScale),x.side===go&&y.normalScale.value.negate()),x.displacementMap&&(y.displacementMap.value=x.displacementMap,y.displacementScale.value=x.displacementScale,y.displacementBias.value=x.displacementBias)}(y,x)):x.isMeshPhongMaterial?(i(y,x),function(y,x){y.specular.value.copy(x.specular),y.shininess.value=Math.max(x.shininess,1e-4),x.emissiveMap&&(y.emissiveMap.value=x.emissiveMap),x.bumpMap&&(y.bumpMap.value=x.bumpMap,y.bumpScale.value=x.bumpScale,x.side===go&&(y.bumpScale.value*=-1)),x.normalMap&&(y.normalMap.value=x.normalMap,y.normalScale.value.copy(x.normalScale),x.side===go&&y.normalScale.value.negate()),x.displacementMap&&(y.displacementMap.value=x.displacementMap,y.displacementScale.value=x.displacementScale,y.displacementBias.value=x.displacementBias)}(y,x)):x.isMeshStandardMaterial?(i(y,x),x.isMeshPhysicalMaterial?function(y,x,R){u(y,x),y.ior.value=x.ior,x.sheen>0&&(y.sheenColor.value.copy(x.sheenColor).multiplyScalar(x.sheen),y.sheenRoughness.value=x.sheenRoughness,x.sheenColorMap&&(y.sheenColorMap.value=x.sheenColorMap),x.sheenRoughnessMap&&(y.sheenRoughnessMap.value=x.sheenRoughnessMap)),x.clearcoat>0&&(y.clearcoat.value=x.clearcoat,y.clearcoatRoughness.value=x.clearcoatRoughness,x.clearcoatMap&&(y.clearcoatMap.value=x.clearcoatMap),x.clearcoatRoughnessMap&&(y.clearcoatRoughnessMap.value=x.clearcoatRoughnessMap),x.clearcoatNormalMap&&(y.clearcoatNormalScale.value.copy(x.clearcoatNormalScale),y.clearcoatNormalMap.value=x.clearcoatNormalMap,x.side===go&&y.clearcoatNormalScale.value.negate())),x.transmission>0&&(y.transmission.value=x.transmission,y.transmissionSamplerMap.value=R.texture,y.transmissionSamplerSize.value.set(R.width,R.height),x.transmissionMap&&(y.transmissionMap.value=x.transmissionMap),y.thickness.value=x.thickness,x.thicknessMap&&(y.thicknessMap.value=x.thicknessMap),y.attenuationDistance.value=x.attenuationDistance,y.attenuationColor.value.copy(x.attenuationColor)),y.specularIntensity.value=x.specularIntensity,y.specularColor.value.copy(x.specularColor),x.specularIntensityMap&&(y.specularIntensityMap.value=x.specularIntensityMap),x.specularColorMap&&(y.specularColorMap.value=x.specularColorMap)}(y,x,V):u(y,x)):x.isMeshMatcapMaterial?(i(y,x),function(y,x){x.matcap&&(y.matcap.value=x.matcap),x.bumpMap&&(y.bumpMap.value=x.bumpMap,y.bumpScale.value=x.bumpScale,x.side===go&&(y.bumpScale.value*=-1)),x.normalMap&&(y.normalMap.value=x.normalMap,y.normalScale.value.copy(x.normalScale),x.side===go&&y.normalScale.value.negate()),x.displacementMap&&(y.displacementMap.value=x.displacementMap,y.displacementScale.value=x.displacementScale,y.displacementBias.value=x.displacementBias)}(y,x)):x.isMeshDepthMaterial?(i(y,x),function(y,x){x.displacementMap&&(y.displacementMap.value=x.displacementMap,y.displacementScale.value=x.displacementScale,y.displacementBias.value=x.displacementBias)}(y,x)):x.isMeshDistanceMaterial?(i(y,x),function(y,x){x.displacementMap&&(y.displacementMap.value=x.displacementMap,y.displacementScale.value=x.displacementScale,y.displacementBias.value=x.displacementBias),y.referencePosition.value.copy(x.referencePosition),y.nearDistance.value=x.nearDistance,y.farDistance.value=x.farDistance}(y,x)):x.isMeshNormalMaterial?(i(y,x),function(y,x){x.bumpMap&&(y.bumpMap.value=x.bumpMap,y.bumpScale.value=x.bumpScale,x.side===go&&(y.bumpScale.value*=-1)),x.normalMap&&(y.normalMap.value=x.normalMap,y.normalScale.value.copy(x.normalScale),x.side===go&&y.normalScale.value.negate()),x.displacementMap&&(y.displacementMap.value=x.displacementMap,y.displacementScale.value=x.displacementScale,y.displacementBias.value=x.displacementBias)}(y,x)):x.isLineBasicMaterial?(function(y,x){y.diffuse.value.copy(x.color),y.opacity.value=x.opacity}(y,x),x.isLineDashedMaterial&&function(y,x){y.dashSize.value=x.dashSize,y.totalSize.value=x.dashSize+x.gapSize,y.scale.value=x.scale}(y,x)):x.isPointsMaterial?function(y,x,R,A){let V;y.diffuse.value.copy(x.color),y.opacity.value=x.opacity,y.size.value=x.size*R,y.scale.value=.5*A,x.map&&(y.map.value=x.map),x.alphaMap&&(y.alphaMap.value=x.alphaMap),x.alphaTest>0&&(y.alphaTest.value=x.alphaTest),x.map?V=x.map:x.alphaMap&&(V=x.alphaMap),void 0!==V&&(!0===V.matrixAutoUpdate&&V.updateMatrix(),y.uvTransform.value.copy(V.matrix))}(y,x,R,A):x.isSpriteMaterial?function(y,x){let R;y.diffuse.value.copy(x.color),y.opacity.value=x.opacity,y.rotation.value=x.rotation,x.map&&(y.map.value=x.map),x.alphaMap&&(y.alphaMap.value=x.alphaMap),x.alphaTest>0&&(y.alphaTest.value=x.alphaTest),x.map?R=x.map:x.alphaMap&&(R=x.alphaMap),void 0!==R&&(!0===R.matrixAutoUpdate&&R.updateMatrix(),y.uvTransform.value.copy(R.matrix))}(y,x):x.isShadowMaterial?(y.color.value.copy(x.color),y.opacity.value=x.opacity):x.isShaderMaterial&&(x.uniformsNeedUpdate=!1)}}}function ji(n={}){let t=void 0!==n.canvas?n.canvas:function(){let n=Mx("canvas");return n.style.display="block",n}(),e=void 0!==n.context?n.context:null,i=void 0!==n.alpha&&n.alpha,r=void 0===n.depth||n.depth,o=void 0===n.stencil||n.stencil,s=void 0!==n.antialias&&n.antialias,a=void 0===n.premultipliedAlpha||n.premultipliedAlpha,l=void 0!==n.preserveDrawingBuffer&&n.preserveDrawingBuffer,c=void 0!==n.powerPreference?n.powerPreference:"default",d=void 0!==n.failIfMajorPerformanceCaveat&&n.failIfMajorPerformanceCaveat,u=null,p=null,f=[],m=[];this.domElement=t,this.debug={checkShaderErrors:!0},this.autoClear=!0,this.autoClearColor=!0,this.autoClearDepth=!0,this.autoClearStencil=!0,this.sortObjects=!0,this.clippingPlanes=[],this.localClippingEnabled=!1,this.outputEncoding=_p,this.physicallyCorrectLights=!1,this.toneMapping=fp,this.toneMappingExposure=1;let b=this,M=!1,y=0,x=0,R=null,A=-1,V=null,te=new Zi,K=new Zi,xe=null,Xe=t.width,De=t.height,D=1,re=null,ce=null,fe=new Zi(0,0,Xe,De),be=new Zi(0,0,Xe,De),ne=!1,de=new Z0,pe=!1,je=!1,Ce=null,Ne=new xn,lt=new $,Mt={background:null,fog:null,environment:null,overrideMaterial:null,isScene:!0};function pt(){return null===R?D:1}let wt,on,ve,mt,ft,oe,st,Ye,_t,ut,sn,Cn,ti,ki,Fi,Z,L,Ve,vt,en,Le,mn,ln,Oe=e;function An(E,H){for(let Y=0;Y<E.length;Y++){let se=t.getContext(E[Y],H);if(null!==se)return se}return null}try{let E={alpha:!0,depth:r,stencil:o,antialias:s,premultipliedAlpha:a,preserveDrawingBuffer:l,powerPreference:c,failIfMajorPerformanceCaveat:d};if("setAttribute"in t&&t.setAttribute("data-engine",`three.js r${dV}`),t.addEventListener("webglcontextlost",Ln,!1),t.addEventListener("webglcontextrestored",ae,!1),null===Oe){let H=["webgl2","webgl","experimental-webgl"];if(!0===b.isWebGL1Renderer&&H.shift(),Oe=An(H,E),null===Oe)throw An(H)?new Error("Error creating WebGL context with your selected attributes."):new Error("Error creating WebGL context.")}void 0===Oe.getShaderPrecisionFormat&&(Oe.getShaderPrecisionFormat=function(){return{rangeMin:1,rangeMax:1,precision:1}})}catch(E){throw console.error("THREE.WebGLRenderer: "+E.message),E}function Ft(){wt=new xke(Oe),on=new hke(Oe,wt,n),wt.init(on),mn=new ZFe(Oe,wt,on),ve=new XFe(Oe,wt,on),mt=new wke(Oe),ft=new LFe,oe=new QFe(Oe,wt,ve,ft,on,mn,mt),st=new _ke(b),Ye=new yke(b),_t=new VRe(Oe,on),ln=new fke(Oe,wt,_t,on),ut=new Cke(Oe,_t,mt,ln),sn=new Dke(Oe,ut,_t,mt),vt=new Tke(Oe,on,oe),Z=new gke(ft),Cn=new NFe(b,st,Ye,wt,on,ln,Z),ti=new JFe(ft),ki=new VFe,Fi=new WFe(wt,on),Ve=new pke(b,st,ve,sn,i,a),L=new ste(b,sn,on),en=new mke(Oe,wt,mt,on),Le=new Mke(Oe,wt,mt,on),mt.programs=Cn.programs,b.capabilities=on,b.extensions=wt,b.properties=ft,b.renderLists=ki,b.shadowMap=L,b.state=ve,b.info=mt}Ft();let Pt=new lB(b,Oe);function Ln(E){E.preventDefault(),console.log("THREE.WebGLRenderer: Context Lost."),M=!0}function ae(){console.log("THREE.WebGLRenderer: Context Restored."),M=!1;let E=mt.autoReset,H=L.enabled,Y=L.autoUpdate,J=L.needsUpdate,se=L.type;Ft(),mt.autoReset=E,L.enabled=H,L.autoUpdate=Y,L.needsUpdate=J,L.type=se}function Jt(E){let H=E.target;H.removeEventListener("dispose",Jt),function(E){(function(E){let H=ft.get(E).programs;void 0!==H&&(H.forEach(function(Y){Cn.releaseProgram(Y)}),E.isShaderMaterial&&Cn.releaseShaderCache(E))})(E),ft.remove(E)}(H)}this.xr=Pt,this.getContext=function(){return Oe},this.getContextAttributes=function(){return Oe.getContextAttributes()},this.forceContextLoss=function(){let E=wt.get("WEBGL_lose_context");E&&E.loseContext()},this.forceContextRestore=function(){let E=wt.get("WEBGL_lose_context");E&&E.restoreContext()},this.getPixelRatio=function(){return D},this.setPixelRatio=function(E){void 0!==E&&(D=E,this.setSize(Xe,De,!1))},this.getSize=function(E){return E.set(Xe,De)},this.setSize=function(E,H,Y){Pt.isPresenting?console.warn("THREE.WebGLRenderer: Can't change size while VR device is presenting."):(Xe=E,De=H,t.width=Math.floor(E*D),t.height=Math.floor(H*D),!1!==Y&&(t.style.width=E+"px",t.style.height=H+"px"),this.setViewport(0,0,E,H))},this.getDrawingBufferSize=function(E){return E.set(Xe*D,De*D).floor()},this.setDrawingBufferSize=function(E,H,Y){Xe=E,De=H,D=Y,t.width=Math.floor(E*Y),t.height=Math.floor(H*Y),this.setViewport(0,0,E,H)},this.getCurrentViewport=function(E){return E.copy(te)},this.getViewport=function(E){return E.copy(fe)},this.setViewport=function(E,H,Y,J){E.isVector4?fe.set(E.x,E.y,E.z,E.w):fe.set(E,H,Y,J),ve.viewport(te.copy(fe).multiplyScalar(D).floor())},this.getScissor=function(E){return E.copy(be)},this.setScissor=function(E,H,Y,J){E.isVector4?be.set(E.x,E.y,E.z,E.w):be.set(E,H,Y,J),ve.scissor(K.copy(be).multiplyScalar(D).floor())},this.getScissorTest=function(){return ne},this.setScissorTest=function(E){ve.setScissorTest(ne=E)},this.setOpaqueSort=function(E){re=E},this.setTransparentSort=function(E){ce=E},this.getClearColor=function(E){return E.copy(Ve.getClearColor())},this.setClearColor=function(){Ve.setClearColor.apply(Ve,arguments)},this.getClearAlpha=function(){return Ve.getClearAlpha()},this.setClearAlpha=function(){Ve.setClearAlpha.apply(Ve,arguments)},this.clear=function(E,H,Y){let J=0;(void 0===E||E)&&(J|=16384),(void 0===H||H)&&(J|=256),(void 0===Y||Y)&&(J|=1024),Oe.clear(J)},this.clearColor=function(){this.clear(!0,!1,!1)},this.clearDepth=function(){this.clear(!1,!0,!1)},this.clearStencil=function(){this.clear(!1,!1,!0)},this.dispose=function(){t.removeEventListener("webglcontextlost",Ln,!1),t.removeEventListener("webglcontextrestored",ae,!1),ki.dispose(),Fi.dispose(),ft.dispose(),st.dispose(),Ye.dispose(),sn.dispose(),ln.dispose(),Cn.dispose(),Pt.dispose(),Pt.removeEventListener("sessionstart",ui),Pt.removeEventListener("sessionend",ur),Ce&&(Ce.dispose(),Ce=null),zo.stop()},this.renderBufferDirect=function(E,H,Y,J,se,ze){null===H&&(H=Mt);let et=se.isMesh&&se.matrixWorld.determinant()<0,qe=function(E,H,Y,J,se){!0!==H.isScene&&(H=Mt),oe.resetTextureUnits();let ze=H.fog,qe=null===R?b.outputEncoding:!0===R.isXRRenderTarget?R.texture.encoding:_p,rt=(J.isMeshStandardMaterial?Ye:st).get(J.envMap||(J.isMeshStandardMaterial?H.environment:null)),dt=!0===J.vertexColors&&!!Y.attributes.color&&4===Y.attributes.color.itemSize,St=!!J.normalMap&&!!Y.attributes.tangent,Dt=!!Y.morphAttributes.position,cn=!!Y.morphAttributes.normal,Gi=Y.morphAttributes.position?Y.morphAttributes.position.length:0,vi=J.toneMapped?b.toneMapping:fp,pn=ft.get(J),Pn=p.state.lights;!0!==pe||!0!==je&&E===V||Z.setState(J,E,E===V&&J.id===A);let Et=!1;J.version===pn.__version?(pn.needsLights&&pn.lightsStateVersion!==Pn.state.version||pn.outputEncoding!==qe||se.isInstancedMesh&&!1===pn.instancing||!se.isInstancedMesh&&!0===pn.instancing||se.isSkinnedMesh&&!1===pn.skinning||!se.isSkinnedMesh&&!0===pn.skinning||pn.envMap!==rt||J.fog&&pn.fog!==ze||void 0!==pn.numClippingPlanes&&(pn.numClippingPlanes!==Z.numPlanes||pn.numIntersection!==Z.numIntersection)||pn.vertexAlphas!==dt||pn.vertexTangents!==St||pn.morphTargets!==Dt||pn.morphNormals!==cn||pn.toneMapping!==vi||!0===on.isWebGL2&&pn.morphTargetsCount!==Gi)&&(Et=!0):(Et=!0,pn.__version=J.version);let pi=pn.currentProgram;!0===Et&&(pi=x_(J,H,se));let Qn=!1,Vn=!1,Wn=!1,Ut=pi.getUniforms(),Ni=pn.uniforms;if(ve.useProgram(pi.program)&&(Qn=!0,Vn=!0,Wn=!0),J.id!==A&&(A=J.id,Vn=!0),Qn||V!==E){if(Ut.setValue(Oe,"projectionMatrix",E.projectionMatrix),on.logarithmicDepthBuffer&&Ut.setValue(Oe,"logDepthBufFC",2/(Math.log(E.far+1)/Math.LN2)),V!==E&&(V=E,Vn=!0,Wn=!0),J.isShaderMaterial||J.isMeshPhongMaterial||J.isMeshToonMaterial||J.isMeshStandardMaterial||J.envMap){let vn=Ut.map.cameraPosition;void 0!==vn&&vn.setValue(Oe,lt.setFromMatrixPosition(E.matrixWorld))}(J.isMeshPhongMaterial||J.isMeshToonMaterial||J.isMeshLambertMaterial||J.isMeshBasicMaterial||J.isMeshStandardMaterial||J.isShaderMaterial)&&Ut.setValue(Oe,"isOrthographic",!0===E.isOrthographicCamera),(J.isMeshPhongMaterial||J.isMeshToonMaterial||J.isMeshLambertMaterial||J.isMeshBasicMaterial||J.isMeshStandardMaterial||J.isShaderMaterial||J.isShadowMaterial||se.isSkinnedMesh)&&Ut.setValue(Oe,"viewMatrix",E.matrixWorldInverse)}if(se.isSkinnedMesh){Ut.setOptional(Oe,se,"bindMatrix"),Ut.setOptional(Oe,se,"bindMatrixInverse");let vn=se.skeleton;vn&&(on.floatVertexTextures?(null===vn.boneTexture&&vn.computeBoneTexture(),Ut.setValue(Oe,"boneTexture",vn.boneTexture,oe),Ut.setValue(Oe,"boneTextureSize",vn.boneTextureSize)):Ut.setOptional(Oe,vn,"boneMatrices"))}return!!Y&&(void 0!==Y.morphAttributes.position||void 0!==Y.morphAttributes.normal)&&vt.update(se,Y,J,pi),(Vn||pn.receiveShadow!==se.receiveShadow)&&(pn.receiveShadow=se.receiveShadow,Ut.setValue(Oe,"receiveShadow",se.receiveShadow)),Vn&&(Ut.setValue(Oe,"toneMappingExposure",b.toneMappingExposure),pn.needsLights&&function(E,H){E.ambientLightColor.needsUpdate=H,E.lightProbe.needsUpdate=H,E.directionalLights.needsUpdate=H,E.directionalLightShadows.needsUpdate=H,E.pointLights.needsUpdate=H,E.pointLightShadows.needsUpdate=H,E.spotLights.needsUpdate=H,E.spotLightShadows.needsUpdate=H,E.rectAreaLights.needsUpdate=H,E.hemisphereLights.needsUpdate=H}(Ni,Wn),ze&&J.fog&&ti.refreshFogUniforms(Ni,ze),ti.refreshMaterialUniforms(Ni,J,D,De,Ce),gp.upload(Oe,pn.uniformsList,Ni,oe)),J.isShaderMaterial&&!0===J.uniformsNeedUpdate&&(gp.upload(Oe,pn.uniformsList,Ni,oe),J.uniformsNeedUpdate=!1),J.isSpriteMaterial&&Ut.setValue(Oe,"center",se.center),Ut.setValue(Oe,"modelViewMatrix",se.modelViewMatrix),Ut.setValue(Oe,"normalMatrix",se.normalMatrix),Ut.setValue(Oe,"modelMatrix",se.matrixWorld),pi}(E,H,Y,J,se);ve.setMaterial(J,et);let rt=Y.index,dt=Y.attributes.position;if(null===rt){if(void 0===dt||0===dt.count)return}else if(0===rt.count)return;let St=1;!0===J.wireframe&&(rt=ut.getWireframeAttribute(Y),St=2),ln.setup(se,J,qe,Y,rt);let Dt,cn=en;null!==rt&&(Dt=_t.get(rt),cn=Le,cn.setIndex(Dt));let Gi=null!==rt?rt.count:dt.count,vi=Y.drawRange.start*St,pn=Y.drawRange.count*St,Pn=null!==ze?ze.start*St:0,Et=null!==ze?ze.count*St:1/0,pi=Math.max(vi,Pn),Qn=Math.min(Gi,vi+pn,Pn+Et)-1,Vn=Math.max(0,Qn-pi+1);if(0!==Vn){if(se.isMesh)!0===J.wireframe?(ve.setLineWidth(J.wireframeLinewidth*pt()),cn.setMode(1)):cn.setMode(4);else if(se.isLine){let Wn=J.linewidth;void 0===Wn&&(Wn=1),ve.setLineWidth(Wn*pt()),cn.setMode(se.isLineSegments?1:se.isLineLoop?2:3)}else se.isPoints?cn.setMode(0):se.isSprite&&cn.setMode(4);if(se.isInstancedMesh)cn.renderInstances(pi,Vn,se.count);else if(Y.isInstancedBufferGeometry){let Wn=Math.min(Y.instanceCount,Y._maxInstanceCount);cn.renderInstances(pi,Vn,Wn)}else cn.render(pi,Vn)}},this.compile=function(E,H){p=Fi.get(E),p.init(),m.push(p),E.traverseVisible(function(Y){Y.isLight&&Y.layers.test(H.layers)&&(p.pushLight(Y),Y.castShadow&&p.pushShadow(Y))}),p.setupLights(b.physicallyCorrectLights),E.traverse(function(Y){let J=Y.material;if(J)if(Array.isArray(J))for(let se=0;se<J.length;se++)x_(J[se],E,Y);else x_(J,E,Y)}),m.pop(),p=null};let We=null;function ui(){zo.stop()}function ur(){zo.start()}let zo=new Zee;function Cr(E,H,Y,J){if(!1===E.visible)return;if(E.layers.test(H.layers))if(E.isGroup)Y=E.renderOrder;else if(E.isLOD)!0===E.autoUpdate&&E.update(H);else if(E.isLight)p.pushLight(E),E.castShadow&&p.pushShadow(E);else if(E.isSprite){if(!E.frustumCulled||de.intersectsSprite(E)){J&&lt.setFromMatrixPosition(E.matrixWorld).applyMatrix4(Ne);let et=sn.update(E),qe=E.material;qe.visible&&u.push(E,et,qe,Y,lt.z,null)}}else if((E.isMesh||E.isLine||E.isPoints)&&(E.isSkinnedMesh&&E.skeleton.frame!==mt.render.frame&&(E.skeleton.update(),E.skeleton.frame=mt.render.frame),!E.frustumCulled||de.intersectsObject(E))){J&&lt.setFromMatrixPosition(E.matrixWorld).applyMatrix4(Ne);let et=sn.update(E),qe=E.material;if(Array.isArray(qe)){let rt=et.groups;for(let dt=0,St=rt.length;dt<St;dt++){let Dt=rt[dt],cn=qe[Dt.materialIndex];cn&&cn.visible&&u.push(E,et,cn,Y,lt.z,Dt)}}else qe.visible&&u.push(E,et,qe,Y,lt.z,null)}let ze=E.children;for(let et=0,qe=ze.length;et<qe;et++)Cr(ze[et],H,Y,J)}function Ma(E,H,Y,J){let se=E.opaque,ze=E.transmissive,et=E.transparent;p.setupLightsView(Y),ze.length>0&&function(E,H,Y){null===Ce&&(Ce=new(!0===s&&!0===on.isWebGL2?wx:Js)(1024,1024,{generateMipmaps:!0,type:null!==mn.convert(U0)?U0:mp,minFilter:QI,magFilter:_o,wrapS:ya,wrapT:ya,useRenderToTexture:wt.has("WEBGL_multisampled_render_to_texture")}));let J=b.getRenderTarget();b.setRenderTarget(Ce),b.clear();let se=b.toneMapping;b.toneMapping=fp,dl(E,H,Y),b.toneMapping=se,oe.updateMultisampleRenderTarget(Ce),oe.updateRenderTargetMipmap(Ce),b.setRenderTarget(J)}(se,H,Y),J&&ve.viewport(te.copy(J)),se.length>0&&dl(se,H,Y),ze.length>0&&dl(ze,H,Y),et.length>0&&dl(et,H,Y)}function dl(E,H,Y){let J=!0===H.isScene?H.overrideMaterial:null;for(let se=0,ze=E.length;se<ze;se++){let et=E[se],qe=et.object,rt=et.geometry,dt=null===J?et.material:J,St=et.group;qe.layers.test(Y.layers)&&PA(qe,H,Y,rt,dt,St)}}function PA(E,H,Y,J,se,ze){E.onBeforeRender(b,H,Y,J,se,ze),E.modelViewMatrix.multiplyMatrices(Y.matrixWorldInverse,E.matrixWorld),E.normalMatrix.getNormalMatrix(E.modelViewMatrix),se.onBeforeRender(b,H,Y,J,E,ze),!0===se.transparent&&se.side===q0?(se.side=go,se.needsUpdate=!0,b.renderBufferDirect(Y,H,J,se,E,ze),se.side=yx,se.needsUpdate=!0,b.renderBufferDirect(Y,H,J,se,E,ze),se.side=q0):b.renderBufferDirect(Y,H,J,se,E,ze),E.onAfterRender(b,H,Y,J,se,ze)}function x_(E,H,Y){!0!==H.isScene&&(H=Mt);let J=ft.get(E),se=p.state.lights,et=se.state.version,qe=Cn.getParameters(E,se.state,p.state.shadowsArray,H,Y),rt=Cn.getProgramCacheKey(qe),dt=J.programs;J.environment=E.isMeshStandardMaterial?H.environment:null,J.fog=H.fog,J.envMap=(E.isMeshStandardMaterial?Ye:st).get(E.envMap||J.environment),void 0===dt&&(E.addEventListener("dispose",Jt),dt=new Map,J.programs=dt);let St=dt.get(rt);if(void 0!==St){if(J.currentProgram===St&&J.lightsStateVersion===et)return eC(E,qe),St}else qe.uniforms=Cn.getUniforms(E),E.onBuild(Y,qe,b),E.onBeforeCompile(qe,b),St=Cn.acquireProgram(qe,rt),dt.set(rt,St),J.uniforms=qe.uniforms;let Dt=J.uniforms;(!E.isShaderMaterial&&!E.isRawShaderMaterial||!0===E.clipping)&&(Dt.clippingPlanes=Z.uniform),eC(E,qe),J.needsLights=function(E){return E.isMeshLambertMaterial||E.isMeshToonMaterial||E.isMeshPhongMaterial||E.isMeshStandardMaterial||E.isShadowMaterial||E.isShaderMaterial&&!0===E.lights}(E),J.lightsStateVersion=et,J.needsLights&&(Dt.ambientLightColor.value=se.state.ambient,Dt.lightProbe.value=se.state.probe,Dt.directionalLights.value=se.state.directional,Dt.directionalLightShadows.value=se.state.directionalShadow,Dt.spotLights.value=se.state.spot,Dt.spotLightShadows.value=se.state.spotShadow,Dt.rectAreaLights.value=se.state.rectArea,Dt.ltc_1.value=se.state.rectAreaLTC1,Dt.ltc_2.value=se.state.rectAreaLTC2,Dt.pointLights.value=se.state.point,Dt.pointLightShadows.value=se.state.pointShadow,Dt.hemisphereLights.value=se.state.hemi,Dt.directionalShadowMap.value=se.state.directionalShadowMap,Dt.directionalShadowMatrix.value=se.state.directionalShadowMatrix,Dt.spotShadowMap.value=se.state.spotShadowMap,Dt.spotShadowMatrix.value=se.state.spotShadowMatrix,Dt.pointShadowMap.value=se.state.pointShadowMap,Dt.pointShadowMatrix.value=se.state.pointShadowMatrix);let cn=St.getUniforms(),Gi=gp.seqWithValue(cn.seq,Dt);return J.currentProgram=St,J.uniformsList=Gi,St}function eC(E,H){let Y=ft.get(E);Y.outputEncoding=H.outputEncoding,Y.instancing=H.instancing,Y.skinning=H.skinning,Y.morphTargets=H.morphTargets,Y.morphNormals=H.morphNormals,Y.morphTargetsCount=H.morphTargetsCount,Y.numClippingPlanes=H.numClippingPlanes,Y.numIntersection=H.numClipIntersection,Y.vertexAlphas=H.vertexAlphas,Y.vertexTangents=H.vertexTangents,Y.toneMapping=H.toneMapping}zo.setAnimationLoop(function(E){We&&We(E)}),typeof window<"u"&&zo.setContext(window),this.setAnimationLoop=function(E){We=E,Pt.setAnimationLoop(E),null===E?zo.stop():zo.start()},Pt.addEventListener("sessionstart",ui),Pt.addEventListener("sessionend",ur),this.render=function(E,H){if(void 0===H||!0===H.isCamera){if(!0!==M){if(!0===E.autoUpdate&&E.updateMatrixWorld(),null===H.parent&&H.updateMatrixWorld(),!0===Pt.enabled&&!0===Pt.isPresenting&&(!0===Pt.cameraAutoUpdate&&Pt.updateCamera(H),H=Pt.getCamera()),!0===E.isScene&&E.onBeforeRender(b,E,H,R),p=Fi.get(E,m.length),p.init(),m.push(p),Ne.multiplyMatrices(H.projectionMatrix,H.matrixWorldInverse),de.setFromProjectionMatrix(Ne),je=this.localClippingEnabled,pe=Z.init(this.clippingPlanes,je,H),u=ki.get(E,f.length),u.init(),f.push(u),Cr(E,H,0,b.sortObjects),u.finish(),!0===b.sortObjects&&u.sort(re,ce),!0===pe&&Z.beginShadows(),L.render(p.state.shadowsArray,E,H),!0===pe&&Z.endShadows(),!0===this.info.autoReset&&this.info.reset(),Ve.render(u,E),p.setupLights(b.physicallyCorrectLights),H.isArrayCamera){let J=H.cameras;for(let se=0,ze=J.length;se<ze;se++){let et=J[se];Ma(u,E,et,et.viewport)}}else Ma(u,E,H);null!==R&&(oe.updateMultisampleRenderTarget(R),oe.updateRenderTargetMipmap(R)),!0===E.isScene&&E.onAfterRender(b,E,H),ve.buffers.depth.setTest(!0),ve.buffers.depth.setMask(!0),ve.buffers.color.setMask(!0),ve.setPolygonOffset(!1),ln.resetDefaultState(),A=-1,V=null,m.pop(),p=m.length>0?m[m.length-1]:null,f.pop(),u=f.length>0?f[f.length-1]:null}}else console.error("THREE.WebGLRenderer.render: camera is not an instance of THREE.Camera.")},this.getActiveCubeFace=function(){return y},this.getActiveMipmapLevel=function(){return x},this.getRenderTarget=function(){return R},this.setRenderTargetTextures=function(E,H,Y){ft.get(E.texture).__webglTexture=H,ft.get(E.depthTexture).__webglTexture=Y;let J=ft.get(E);J.__hasExternalTextures=!0,J.__hasExternalTextures&&(J.__autoAllocateDepthBuffer=void 0===Y,J.__autoAllocateDepthBuffer||E.useRenderToTexture&&(console.warn("render-to-texture extension was disabled because an external texture was provided"),E.useRenderToTexture=!1,E.useRenderbuffer=!0))},this.setRenderTargetFramebuffer=function(E,H){let Y=ft.get(E);Y.__webglFramebuffer=H,Y.__useDefaultFramebuffer=void 0===H},this.setRenderTarget=function(E,H=0,Y=0){R=E,y=H,x=Y;let J=!0;if(E){let rt=ft.get(E);void 0!==rt.__useDefaultFramebuffer?(ve.bindFramebuffer(36160,null),J=!1):void 0===rt.__webglFramebuffer?oe.setupRenderTarget(E):rt.__hasExternalTextures&&oe.rebindTextures(E,ft.get(E.texture).__webglTexture,ft.get(E.depthTexture).__webglTexture)}let se=null,ze=!1,et=!1;if(E){let rt=E.texture;(rt.isDataTexture3D||rt.isDataTexture2DArray)&&(et=!0);let dt=ft.get(E).__webglFramebuffer;E.isWebGLCubeRenderTarget?(se=dt[H],ze=!0):se=E.useRenderbuffer?ft.get(E).__webglMultisampledFramebuffer:dt,te.copy(E.viewport),K.copy(E.scissor),xe=E.scissorTest}else te.copy(fe).multiplyScalar(D).floor(),K.copy(be).multiplyScalar(D).floor(),xe=ne;if(ve.bindFramebuffer(36160,se)&&on.drawBuffers&&J&&ve.drawBuffers(E,se),ve.viewport(te),ve.scissor(K),ve.setScissorTest(xe),ze){let rt=ft.get(E.texture);Oe.framebufferTexture2D(36160,36064,34069+H,rt.__webglTexture,Y)}else if(et){let rt=ft.get(E.texture);Oe.framebufferTextureLayer(36160,36064,rt.__webglTexture,Y||0,H||0)}A=-1},this.readRenderTargetPixels=function(E,H,Y,J,se,ze,et){if(!E||!E.isWebGLRenderTarget)return void console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not THREE.WebGLRenderTarget.");let qe=ft.get(E).__webglFramebuffer;if(E.isWebGLCubeRenderTarget&&void 0!==et&&(qe=qe[et]),qe){ve.bindFramebuffer(36160,qe);try{let rt=E.texture,dt=rt.format,St=rt.type;if(dt!==gs&&mn.convert(dt)!==Oe.getParameter(35739))return void console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in RGBA or implementation defined format.");let Dt=St===U0&&(wt.has("EXT_color_buffer_half_float")||on.isWebGL2&&wt.has("EXT_color_buffer_float"));if(!(St===mp||mn.convert(St)===Oe.getParameter(35738)||St===cm&&(on.isWebGL2||wt.has("OES_texture_float")||wt.has("WEBGL_color_buffer_float"))||Dt))return void console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in UnsignedByteType or implementation defined type.");36053===Oe.checkFramebufferStatus(36160)?H>=0&&H<=E.width-J&&Y>=0&&Y<=E.height-se&&Oe.readPixels(H,Y,J,se,mn.convert(dt),mn.convert(St),ze):console.error("THREE.WebGLRenderer.readRenderTargetPixels: readPixels from renderTarget failed. Framebuffer not complete.")}finally{let rt=null!==R?ft.get(R).__webglFramebuffer:null;ve.bindFramebuffer(36160,rt)}}},this.copyFramebufferToTexture=function(E,H,Y=0){if(!0!==H.isFramebufferTexture)return void console.error("THREE.WebGLRenderer: copyFramebufferToTexture() can only be used with FramebufferTexture.");let J=Math.pow(2,-Y),se=Math.floor(H.image.width*J),ze=Math.floor(H.image.height*J);oe.setTexture2D(H,0),Oe.copyTexSubImage2D(3553,Y,0,0,E.x,E.y,se,ze),ve.unbindTexture()},this.copyTextureToTexture=function(E,H,Y,J=0){let se=H.image.width,ze=H.image.height,et=mn.convert(Y.format),qe=mn.convert(Y.type);oe.setTexture2D(Y,0),Oe.pixelStorei(37440,Y.flipY),Oe.pixelStorei(37441,Y.premultiplyAlpha),Oe.pixelStorei(3317,Y.unpackAlignment),H.isDataTexture?Oe.texSubImage2D(3553,J,E.x,E.y,se,ze,et,qe,H.image.data):H.isCompressedTexture?Oe.compressedTexSubImage2D(3553,J,E.x,E.y,H.mipmaps[0].width,H.mipmaps[0].height,et,H.mipmaps[0].data):Oe.texSubImage2D(3553,J,E.x,E.y,et,qe,H.image),0===J&&Y.generateMipmaps&&Oe.generateMipmap(3553),ve.unbindTexture()},this.copyTextureToTexture3D=function(E,H,Y,J,se=0){if(b.isWebGL1Renderer)return void console.warn("THREE.WebGLRenderer.copyTextureToTexture3D: can only be used with WebGL2.");let St,ze=E.max.x-E.min.x+1,et=E.max.y-E.min.y+1,qe=E.max.z-E.min.z+1,rt=mn.convert(J.format),dt=mn.convert(J.type);if(J.isDataTexture3D)oe.setTexture3D(J,0),St=32879;else{if(!J.isDataTexture2DArray)return void console.warn("THREE.WebGLRenderer.copyTextureToTexture3D: only supports THREE.DataTexture3D and THREE.DataTexture2DArray.");oe.setTexture2DArray(J,0),St=35866}Oe.pixelStorei(37440,J.flipY),Oe.pixelStorei(37441,J.premultiplyAlpha),Oe.pixelStorei(3317,J.unpackAlignment);let Dt=Oe.getParameter(3314),cn=Oe.getParameter(32878),Gi=Oe.getParameter(3316),vi=Oe.getParameter(3315),pn=Oe.getParameter(32877),Pn=Y.isCompressedTexture?Y.mipmaps[0]:Y.image;Oe.pixelStorei(3314,Pn.width),Oe.pixelStorei(32878,Pn.height),Oe.pixelStorei(3316,E.min.x),Oe.pixelStorei(3315,E.min.y),Oe.pixelStorei(32877,E.min.z),Y.isDataTexture||Y.isDataTexture3D?Oe.texSubImage3D(St,se,H.x,H.y,H.z,ze,et,qe,rt,dt,Pn.data):Y.isCompressedTexture?(console.warn("THREE.WebGLRenderer.copyTextureToTexture3D: untested support for compressed srcTexture."),Oe.compressedTexSubImage3D(St,se,H.x,H.y,H.z,ze,et,qe,rt,Pn.data)):Oe.texSubImage3D(St,se,H.x,H.y,H.z,ze,et,qe,rt,dt,Pn),Oe.pixelStorei(3314,Dt),Oe.pixelStorei(32878,cn),Oe.pixelStorei(3316,Gi),Oe.pixelStorei(3315,vi),Oe.pixelStorei(32877,pn),0===se&&J.generateMipmaps&&Oe.generateMipmap(St),ve.unbindTexture()},this.initTexture=function(E){oe.setTexture2D(E,0),ve.unbindTexture()},this.resetState=function(){y=0,x=0,R=null,ve.reset(),ln.reset()},typeof __THREE_DEVTOOLS__<"u"&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("observe",{detail:this}))}ji.prototype.isWebGLRenderer=!0,class extends ji{}.prototype.isWebGL1Renderer=!0;var Ax=class{constructor(t,e=25e-5){this.name="",this.color=new an(t),this.density=e}clone(){return new Ax(this.color,this.density)}toJSON(){return{type:"FogExp2",color:this.color.getHex(),density:this.density}}};Ax.prototype.isFogExp2=!0;var Rx=class{constructor(t,e=1,i=1e3){this.name="",this.color=new an(t),this.near=e,this.far=i}clone(){return new Rx(this.color,this.near,this.far)}toJSON(){return{type:"Fog",color:this.color.getHex(),near:this.near,far:this.far}}};Rx.prototype.isFog=!0;var J0=class extends Bi{constructor(){super(),this.type="Scene",this.background=null,this.environment=null,this.fog=null,this.overrideMaterial=null,this.autoUpdate=!0,typeof __THREE_DEVTOOLS__<"u"&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("observe",{detail:this}))}copy(t,e){return super.copy(t,e),null!==t.background&&(this.background=t.background.clone()),null!==t.environment&&(this.environment=t.environment.clone()),null!==t.fog&&(this.fog=t.fog.clone()),null!==t.overrideMaterial&&(this.overrideMaterial=t.overrideMaterial.clone()),this.autoUpdate=t.autoUpdate,this.matrixAutoUpdate=t.matrixAutoUpdate,this}toJSON(t){let e=super.toJSON(t);return null!==this.fog&&(e.object.fog=this.fog.toJSON()),e}};J0.prototype.isScene=!0;var hm=class{constructor(t,e){this.array=t,this.stride=e,this.count=void 0!==t?t.length/e:0,this.usage=Cx,this.updateRange={offset:0,count:-1},this.version=0,this.uuid=Jl()}onUploadCallback(){}set needsUpdate(t){!0===t&&this.version++}setUsage(t){return this.usage=t,this}copy(t){return this.array=new t.array.constructor(t.array),this.count=t.count,this.stride=t.stride,this.usage=t.usage,this}copyAt(t,e,i){t*=this.stride,i*=e.stride;for(let r=0,o=this.stride;r<o;r++)this.array[t+r]=e.array[i+r];return this}set(t,e=0){return this.array.set(t,e),this}clone(t){void 0===t.arrayBuffers&&(t.arrayBuffers={}),void 0===this.array.buffer._uuid&&(this.array.buffer._uuid=Jl()),void 0===t.arrayBuffers[this.array.buffer._uuid]&&(t.arrayBuffers[this.array.buffer._uuid]=this.array.slice(0).buffer);let e=new this.array.constructor(t.arrayBuffers[this.array.buffer._uuid]),i=new this.constructor(e,this.stride);return i.setUsage(this.usage),i}onUpload(t){return this.onUploadCallback=t,this}toJSON(t){return void 0===t.arrayBuffers&&(t.arrayBuffers={}),void 0===this.array.buffer._uuid&&(this.array.buffer._uuid=Jl()),void 0===t.arrayBuffers[this.array.buffer._uuid]&&(t.arrayBuffers[this.array.buffer._uuid]=Array.prototype.slice.call(new Uint32Array(this.array.buffer))),{uuid:this.uuid,buffer:this.array.buffer._uuid,type:this.array.constructor.name,stride:this.stride}}};hm.prototype.isInterleavedBuffer=!0;var Zr=new $,gm=class{constructor(t,e,i,r=!1){this.name="",this.data=t,this.itemSize=e,this.offset=i,this.normalized=!0===r}get count(){return this.data.count}get array(){return this.data.array}set needsUpdate(t){this.data.needsUpdate=t}applyMatrix4(t){for(let e=0,i=this.data.count;e<i;e++)Zr.x=this.getX(e),Zr.y=this.getY(e),Zr.z=this.getZ(e),Zr.applyMatrix4(t),this.setXYZ(e,Zr.x,Zr.y,Zr.z);return this}applyNormalMatrix(t){for(let e=0,i=this.count;e<i;e++)Zr.x=this.getX(e),Zr.y=this.getY(e),Zr.z=this.getZ(e),Zr.applyNormalMatrix(t),this.setXYZ(e,Zr.x,Zr.y,Zr.z);return this}transformDirection(t){for(let e=0,i=this.count;e<i;e++)Zr.x=this.getX(e),Zr.y=this.getY(e),Zr.z=this.getZ(e),Zr.transformDirection(t),this.setXYZ(e,Zr.x,Zr.y,Zr.z);return this}setX(t,e){return this.data.array[t*this.data.stride+this.offset]=e,this}setY(t,e){return this.data.array[t*this.data.stride+this.offset+1]=e,this}setZ(t,e){return this.data.array[t*this.data.stride+this.offset+2]=e,this}setW(t,e){return this.data.array[t*this.data.stride+this.offset+3]=e,this}getX(t){return this.data.array[t*this.data.stride+this.offset]}getY(t){return this.data.array[t*this.data.stride+this.offset+1]}getZ(t){return this.data.array[t*this.data.stride+this.offset+2]}getW(t){return this.data.array[t*this.data.stride+this.offset+3]}setXY(t,e,i){return this.data.array[(t=t*this.data.stride+this.offset)+0]=e,this.data.array[t+1]=i,this}setXYZ(t,e,i,r){return this.data.array[(t=t*this.data.stride+this.offset)+0]=e,this.data.array[t+1]=i,this.data.array[t+2]=r,this}setXYZW(t,e,i,r,o){return this.data.array[(t=t*this.data.stride+this.offset)+0]=e,this.data.array[t+1]=i,this.data.array[t+2]=r,this.data.array[t+3]=o,this}clone(t){if(void 0===t){console.log("THREE.InterleavedBufferAttribute.clone(): Cloning an interlaved buffer attribute will deinterleave buffer data.");let e=[];for(let i=0;i<this.count;i++){let r=i*this.data.stride+this.offset;for(let o=0;o<this.itemSize;o++)e.push(this.data.array[r+o])}return new Pr(new this.array.constructor(e),this.itemSize,this.normalized)}return void 0===t.interleavedBuffers&&(t.interleavedBuffers={}),void 0===t.interleavedBuffers[this.data.uuid]&&(t.interleavedBuffers[this.data.uuid]=this.data.clone(t)),new gm(t.interleavedBuffers[this.data.uuid],this.itemSize,this.offset,this.normalized)}toJSON(t){if(void 0===t){console.log("THREE.InterleavedBufferAttribute.toJSON(): Serializing an interlaved buffer attribute will deinterleave buffer data.");let e=[];for(let i=0;i<this.count;i++){let r=i*this.data.stride+this.offset;for(let o=0;o<this.itemSize;o++)e.push(this.data.array[r+o])}return{itemSize:this.itemSize,type:this.array.constructor.name,array:e,normalized:this.normalized}}return void 0===t.interleavedBuffers&&(t.interleavedBuffers={}),void 0===t.interleavedBuffers[this.data.uuid]&&(t.interleavedBuffers[this.data.uuid]=this.data.toJSON(t)),{isInterleavedBufferAttribute:!0,itemSize:this.itemSize,data:this.data.uuid,offset:this.offset,normalized:this.normalized}}};gm.prototype.isInterleavedBufferAttribute=!0;var RI=class extends Ao{constructor(t){super(),this.type="SpriteMaterial",this.color=new an(16777215),this.map=null,this.alphaMap=null,this.rotation=0,this.sizeAttenuation=!0,this.transparent=!0,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.alphaMap=t.alphaMap,this.rotation=t.rotation,this.sizeAttenuation=t.sizeAttenuation,this}};RI.prototype.isSpriteMaterial=!0;var k0,cx=new $,F0=new $,N0=new $,L0=new $e,dx=new $e,ate=new xn,rI=new $,ux=new $,oI=new $,bee=new $e,j3=new $e,vee=new $e;function sI(n,t,e,i,r,o){L0.subVectors(n,e).addScalar(.5).multiply(i),void 0!==r?(dx.x=o*L0.x-r*L0.y,dx.y=r*L0.x+o*L0.y):dx.copy(L0),n.copy(t),n.x+=dx.x,n.y+=dx.y,n.applyMatrix4(ate)}(class extends Bi{constructor(t){if(super(),this.type="Sprite",void 0===k0){k0=new Ui;let e=new Float32Array([-.5,-.5,0,0,0,.5,-.5,0,1,0,.5,.5,0,1,1,-.5,.5,0,0,1]),i=new hm(e,5);k0.setIndex([0,1,2,0,2,3]),k0.setAttribute("position",new gm(i,3,0,!1)),k0.setAttribute("uv",new gm(i,2,3,!1))}this.geometry=k0,this.material=void 0!==t?t:new RI,this.center=new $e(.5,.5)}raycast(t,e){null===t.camera&&console.error('THREE.Sprite: "Raycaster.camera" needs to be set in order to raycast against sprites.'),F0.setFromMatrixScale(this.matrixWorld),ate.copy(t.camera.matrixWorld),this.modelViewMatrix.multiplyMatrices(t.camera.matrixWorldInverse,this.matrixWorld),N0.setFromMatrixPosition(this.modelViewMatrix),t.camera.isPerspectiveCamera&&!1===this.material.sizeAttenuation&&F0.multiplyScalar(-N0.z);let r,o,i=this.material.rotation;0!==i&&(o=Math.cos(i),r=Math.sin(i));let s=this.center;sI(rI.set(-.5,-.5,0),N0,s,F0,r,o),sI(ux.set(.5,-.5,0),N0,s,F0,r,o),sI(oI.set(.5,.5,0),N0,s,F0,r,o),bee.set(0,0),j3.set(1,0),vee.set(1,1);let a=t.ray.intersectTriangle(rI,ux,oI,!1,cx);if(null===a&&(sI(ux.set(-.5,.5,0),N0,s,F0,r,o),j3.set(0,1),a=t.ray.intersectTriangle(rI,oI,ux,!1,cx),null===a))return;let l=t.ray.origin.distanceTo(cx);l<t.near||l>t.far||e.push({distance:l,point:cx.clone(),uv:Vr.getUV(cx,rI,ux,oI,bee,j3,vee,new $e),face:null,object:this})}copy(t){return super.copy(t),void 0!==t.center&&this.center.copy(t.center),this.material=t.material,this}}).prototype.isSprite=!0;var yee=new $,xee=new Zi,Cee=new Zi,e2e=new $,Mee=new xn,PI=class extends ao{constructor(t,e){super(t,e),this.type="SkinnedMesh",this.bindMode="attached",this.bindMatrix=new xn,this.bindMatrixInverse=new xn}copy(t){return super.copy(t),this.bindMode=t.bindMode,this.bindMatrix.copy(t.bindMatrix),this.bindMatrixInverse.copy(t.bindMatrixInverse),this.skeleton=t.skeleton,this}bind(t,e){this.skeleton=t,void 0===e&&(this.updateMatrixWorld(!0),this.skeleton.calculateInverses(),e=this.matrixWorld),this.bindMatrix.copy(e),this.bindMatrixInverse.copy(e).invert()}pose(){this.skeleton.pose()}normalizeSkinWeights(){let t=new Zi,e=this.geometry.attributes.skinWeight;for(let i=0,r=e.count;i<r;i++){t.x=e.getX(i),t.y=e.getY(i),t.z=e.getZ(i),t.w=e.getW(i);let o=1/t.manhattanLength();o!==1/0?t.multiplyScalar(o):t.set(1,0,0,0),e.setXYZW(i,t.x,t.y,t.z,t.w)}}updateMatrixWorld(t){super.updateMatrixWorld(t),"attached"===this.bindMode?this.bindMatrixInverse.copy(this.matrixWorld).invert():"detached"===this.bindMode?this.bindMatrixInverse.copy(this.bindMatrix).invert():console.warn("THREE.SkinnedMesh: Unrecognized bindMode: "+this.bindMode)}boneTransform(t,e){let i=this.skeleton,r=this.geometry;xee.fromBufferAttribute(r.attributes.skinIndex,t),Cee.fromBufferAttribute(r.attributes.skinWeight,t),yee.copy(e).applyMatrix4(this.bindMatrix),e.set(0,0,0);for(let o=0;o<4;o++){let s=Cee.getComponent(o);if(0!==s){let a=xee.getComponent(o);Mee.multiplyMatrices(i.bones[a].matrixWorld,i.boneInverses[a]),e.addScaledVector(e2e.copy(yee).applyMatrix4(Mee),s)}}return e.applyMatrix4(this.bindMatrixInverse)}};PI.prototype.isSkinnedMesh=!0,class extends Bi{constructor(){super(),this.type="Bone"}}.prototype.isBone=!0,class extends lo{constructor(t=null,e=1,i=1,r,o,s,a,l,c=_o,d=_o,u,p){super(null,s,a,l,c,d,r,o,u,p),this.image={data:t,width:e,height:i},this.magFilter=c,this.minFilter=d,this.generateMipmaps=!1,this.flipY=!1,this.unpackAlignment=1}}.prototype.isDataTexture=!0;var Px=class extends Pr{constructor(t,e,i,r=1){"number"==typeof i&&(r=i,i=!1,console.error("THREE.InstancedBufferAttribute: The constructor now expects normalized as the third argument.")),super(t,e,i),this.meshPerAttribute=r}copy(t){return super.copy(t),this.meshPerAttribute=t.meshPerAttribute,this}toJSON(){let t=super.toJSON();return t.meshPerAttribute=this.meshPerAttribute,t.isInstancedBufferAttribute=!0,t}};Px.prototype.isInstancedBufferAttribute=!0;var wee=new xn,See=new xn,aI=[],px=new ao;(class extends ao{constructor(t,e,i){super(t,e),this.instanceMatrix=new Px(new Float32Array(16*i),16),this.instanceColor=null,this.count=i,this.frustumCulled=!1}copy(t){return super.copy(t),this.instanceMatrix.copy(t.instanceMatrix),null!==t.instanceColor&&(this.instanceColor=t.instanceColor.clone()),this.count=t.count,this}getColorAt(t,e){e.fromArray(this.instanceColor.array,3*t)}getMatrixAt(t,e){e.fromArray(this.instanceMatrix.array,16*t)}raycast(t,e){let i=this.matrixWorld,r=this.count;if(px.geometry=this.geometry,px.material=this.material,void 0!==px.material)for(let o=0;o<r;o++){this.getMatrixAt(o,wee),See.multiplyMatrices(i,wee),px.matrixWorld=See,px.raycast(t,aI);for(let s=0,a=aI.length;s<a;s++){let l=aI[s];l.instanceId=o,l.object=this,e.push(l)}aI.length=0}}setColorAt(t,e){null===this.instanceColor&&(this.instanceColor=new Px(new Float32Array(3*this.instanceMatrix.count),3)),e.toArray(this.instanceColor.array,3*t)}setMatrixAt(t,e){e.toArray(this.instanceMatrix.array,16*t)}updateMorphTargets(){}dispose(){this.dispatchEvent({type:"dispose"})}}).prototype.isInstancedMesh=!0;var Wd=class extends Ao{constructor(t){super(),this.type="LineBasicMaterial",this.color=new an(16777215),this.linewidth=1,this.linecap="round",this.linejoin="round",this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.linewidth=t.linewidth,this.linecap=t.linecap,this.linejoin=t.linejoin,this}};Wd.prototype.isLineBasicMaterial=!0;var Eee=new $,Tee=new $,Dee=new xn,G3=new vp,lI=new bp,Ox=class extends Bi{constructor(t=new Ui,e=new Wd){super(),this.type="Line",this.geometry=t,this.material=e,this.updateMorphTargets()}copy(t){return super.copy(t),this.material=t.material,this.geometry=t.geometry,this}computeLineDistances(){let t=this.geometry;if(t.isBufferGeometry)if(null===t.index){let e=t.attributes.position,i=[0];for(let r=1,o=e.count;r<o;r++)Eee.fromBufferAttribute(e,r-1),Tee.fromBufferAttribute(e,r),i[r]=i[r-1],i[r]+=Eee.distanceTo(Tee);t.setAttribute("lineDistance",new Nr(i,1))}else console.warn("THREE.Line.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.");else t.isGeometry&&console.error("THREE.Line.computeLineDistances() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.");return this}raycast(t,e){let i=this.geometry,r=this.matrixWorld,o=t.params.Line.threshold,s=i.drawRange;if(null===i.boundingSphere&&i.computeBoundingSphere(),lI.copy(i.boundingSphere),lI.applyMatrix4(r),lI.radius+=o,!1===t.ray.intersectsSphere(lI))return;Dee.copy(r).invert(),G3.copy(t.ray).applyMatrix4(Dee);let a=o/((this.scale.x+this.scale.y+this.scale.z)/3),l=a*a,c=new $,d=new $,u=new $,p=new $,f=this.isLineSegments?2:1;if(i.isBufferGeometry){let m=i.index,M=i.attributes.position;if(null!==m)for(let R=Math.max(0,s.start),A=Math.min(m.count,s.start+s.count)-1;R<A;R+=f){let V=m.getX(R),te=m.getX(R+1);if(c.fromBufferAttribute(M,V),d.fromBufferAttribute(M,te),G3.distanceSqToSegment(c,d,p,u)>l)continue;p.applyMatrix4(this.matrixWorld);let xe=t.ray.origin.distanceTo(p);xe<t.near||xe>t.far||e.push({distance:xe,point:u.clone().applyMatrix4(this.matrixWorld),index:R,face:null,faceIndex:null,object:this})}else for(let R=Math.max(0,s.start),A=Math.min(M.count,s.start+s.count)-1;R<A;R+=f){if(c.fromBufferAttribute(M,R),d.fromBufferAttribute(M,R+1),G3.distanceSqToSegment(c,d,p,u)>l)continue;p.applyMatrix4(this.matrixWorld);let te=t.ray.origin.distanceTo(p);te<t.near||te>t.far||e.push({distance:te,point:u.clone().applyMatrix4(this.matrixWorld),index:R,face:null,faceIndex:null,object:this})}}else i.isGeometry&&console.error("THREE.Line.raycast() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}updateMorphTargets(){let t=this.geometry;if(t.isBufferGeometry){let e=t.morphAttributes,i=Object.keys(e);if(i.length>0){let r=e[i[0]];if(void 0!==r){this.morphTargetInfluences=[],this.morphTargetDictionary={};for(let o=0,s=r.length;o<s;o++){let a=r[o].name||String(o);this.morphTargetInfluences.push(0),this.morphTargetDictionary[a]=o}}}}else{let e=t.morphTargets;void 0!==e&&e.length>0&&console.error("THREE.Line.updateMorphTargets() does not support THREE.Geometry. Use THREE.BufferGeometry instead.")}}};Ox.prototype.isLine=!0;var Iee=new $,Aee=new $,kx=class extends Ox{constructor(t,e){super(t,e),this.type="LineSegments"}computeLineDistances(){let t=this.geometry;if(t.isBufferGeometry)if(null===t.index){let e=t.attributes.position,i=[];for(let r=0,o=e.count;r<o;r+=2)Iee.fromBufferAttribute(e,r),Aee.fromBufferAttribute(e,r+1),i[r]=0===r?0:i[r-1],i[r+1]=i[r]+Iee.distanceTo(Aee);t.setAttribute("lineDistance",new Nr(i,1))}else console.warn("THREE.LineSegments.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.");else t.isGeometry&&console.error("THREE.LineSegments.computeLineDistances() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.");return this}};kx.prototype.isLineSegments=!0,class extends Ox{constructor(t,e){super(t,e),this.type="LineLoop"}}.prototype.isLineLoop=!0;var OI=class extends Ao{constructor(t){super(),this.type="PointsMaterial",this.color=new an(16777215),this.map=null,this.alphaMap=null,this.size=1,this.sizeAttenuation=!0,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.alphaMap=t.alphaMap,this.size=t.size,this.sizeAttenuation=t.sizeAttenuation,this}};OI.prototype.isPointsMaterial=!0;var Ree=new xn,hB=new vp,cI=new bp,dI=new $;function Pee(n,t,e,i,r,o,s){let a=hB.distanceSqToPoint(n);if(a<e){let l=new $;hB.closestPointToPoint(n,l),l.applyMatrix4(i);let c=r.ray.origin.distanceTo(l);if(c<r.near||c>r.far)return;o.push({distance:c,distanceToRay:Math.sqrt(a),point:l,index:t,face:null,object:s})}}(class extends Bi{constructor(t=new Ui,e=new OI){super(),this.type="Points",this.geometry=t,this.material=e,this.updateMorphTargets()}copy(t){return super.copy(t),this.material=t.material,this.geometry=t.geometry,this}raycast(t,e){let i=this.geometry,r=this.matrixWorld,o=t.params.Points.threshold,s=i.drawRange;if(null===i.boundingSphere&&i.computeBoundingSphere(),cI.copy(i.boundingSphere),cI.applyMatrix4(r),cI.radius+=o,!1===t.ray.intersectsSphere(cI))return;Ree.copy(r).invert(),hB.copy(t.ray).applyMatrix4(Ree);let a=o/((this.scale.x+this.scale.y+this.scale.z)/3),l=a*a;if(i.isBufferGeometry){let c=i.index,u=i.attributes.position;if(null!==c)for(let m=Math.max(0,s.start),b=Math.min(c.count,s.start+s.count);m<b;m++){let M=c.getX(m);dI.fromBufferAttribute(u,M),Pee(dI,M,l,r,t,e,this)}else for(let m=Math.max(0,s.start),b=Math.min(u.count,s.start+s.count);m<b;m++)dI.fromBufferAttribute(u,m),Pee(dI,m,l,r,t,e,this)}else console.error("THREE.Points.raycast() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}updateMorphTargets(){let t=this.geometry;if(t.isBufferGeometry){let e=t.morphAttributes,i=Object.keys(e);if(i.length>0){let r=e[i[0]];if(void 0!==r){this.morphTargetInfluences=[],this.morphTargetDictionary={};for(let o=0,s=r.length;o<s;o++){let a=r[o].name||String(o);this.morphTargetInfluences.push(0),this.morphTargetDictionary[a]=o}}}}else{let e=t.morphTargets;void 0!==e&&e.length>0&&console.error("THREE.Points.updateMorphTargets() does not support THREE.Geometry. Use THREE.BufferGeometry instead.")}}}).prototype.isPoints=!0,class extends lo{constructor(t,e,i,r,o,s,a,l,c){super(t,e,i,r,o,s,a,l,c),this.minFilter=void 0!==s?s:$o,this.magFilter=void 0!==o?o:$o,this.generateMipmaps=!1;let d=this;"requestVideoFrameCallback"in t&&t.requestVideoFrameCallback(function u(){d.needsUpdate=!0,t.requestVideoFrameCallback(u)})}clone(){return new this.constructor(this.image).copy(this)}update(){let t=this.image;"requestVideoFrameCallback"in t==0&&t.readyState>=t.HAVE_CURRENT_DATA&&(this.needsUpdate=!0)}}.prototype.isVideoTexture=!0,class extends lo{constructor(t,e,i){super({width:t,height:e}),this.format=i,this.magFilter=_o,this.minFilter=_o,this.generateMipmaps=!1,this.needsUpdate=!0}}.prototype.isFramebufferTexture=!0,class extends lo{constructor(t,e,i,r,o,s,a,l,c,d,u,p){super(null,s,a,l,c,d,r,o,u,p),this.image={width:e,height:i},this.mipmaps=t,this.flipY=!1,this.generateMipmaps=!1}}.prototype.isCompressedTexture=!0,class extends lo{constructor(t,e,i,r,o,s,a,l,c){super(t,e,i,r,o,s,a,l,c),this.needsUpdate=!0}}.prototype.isCanvasTexture=!0;var $0=class extends Ui{constructor(t=1,e=8,i=0,r=2*Math.PI){super(),this.type="CircleGeometry",this.parameters={radius:t,segments:e,thetaStart:i,thetaLength:r},e=Math.max(3,e);let o=[],s=[],a=[],l=[],c=new $,d=new $e;s.push(0,0,0),a.push(0,0,1),l.push(.5,.5);for(let u=0,p=3;u<=e;u++,p+=3){let f=i+u/e*r;c.x=t*Math.cos(f),c.y=t*Math.sin(f),s.push(c.x,c.y,c.z),a.push(0,0,1),d.x=(s[p]/t+1)/2,d.y=(s[p+1]/t+1)/2,l.push(d.x,d.y)}for(let u=1;u<=e;u++)o.push(u,u+1,0);this.setIndex(o),this.setAttribute("position",new Nr(s,3)),this.setAttribute("normal",new Nr(a,3)),this.setAttribute("uv",new Nr(l,2))}static fromJSON(t){return new $0(t.radius,t.segments,t.thetaStart,t.thetaLength)}},$s=(new $,new $,new $,new Vr,class{constructor(){this.type="Curve",this.arcLengthDivisions=200}getPoint(){return console.warn("THREE.Curve: .getPoint() not implemented."),null}getPointAt(t,e){let i=this.getUtoTmapping(t);return this.getPoint(i,e)}getPoints(t=5){let e=[];for(let i=0;i<=t;i++)e.push(this.getPoint(i/t));return e}getSpacedPoints(t=5){let e=[];for(let i=0;i<=t;i++)e.push(this.getPointAt(i/t));return e}getLength(){let t=this.getLengths();return t[t.length-1]}getLengths(t=this.arcLengthDivisions){if(this.cacheArcLengths&&this.cacheArcLengths.length===t+1&&!this.needsUpdate)return this.cacheArcLengths;this.needsUpdate=!1;let i,e=[],r=this.getPoint(0),o=0;e.push(0);for(let s=1;s<=t;s++)i=this.getPoint(s/t),o+=i.distanceTo(r),e.push(o),r=i;return this.cacheArcLengths=e,e}updateArcLengths(){this.needsUpdate=!0,this.getLengths()}getUtoTmapping(t,e){let s,i=this.getLengths(),r=0,o=i.length;s=e||t*i[o-1];let c,a=0,l=o-1;for(;a<=l;)if(r=Math.floor(a+(l-a)/2),c=i[r]-s,c<0)a=r+1;else{if(!(c>0)){l=r;break}l=r-1}if(r=l,i[r]===s)return r/(o-1);let d=i[r];return(r+(s-d)/(i[r+1]-d))/(o-1)}getTangent(t,e){let r=t-1e-4,o=t+1e-4;r<0&&(r=0),o>1&&(o=1);let s=this.getPoint(r),a=this.getPoint(o),l=e||(s.isVector2?new $e:new $);return l.copy(a).sub(s).normalize(),l}getTangentAt(t,e){let i=this.getUtoTmapping(t);return this.getTangent(i,e)}computeFrenetFrames(t,e){let i=new $,r=[],o=[],s=[],a=new $,l=new xn;for(let f=0;f<=t;f++)r[f]=this.getTangentAt(f/t,new $);o[0]=new $,s[0]=new $;let c=Number.MAX_VALUE,d=Math.abs(r[0].x),u=Math.abs(r[0].y),p=Math.abs(r[0].z);d<=c&&(c=d,i.set(1,0,0)),u<=c&&(c=u,i.set(0,1,0)),p<=c&&i.set(0,0,1),a.crossVectors(r[0],i).normalize(),o[0].crossVectors(r[0],a),s[0].crossVectors(r[0],o[0]);for(let f=1;f<=t;f++){if(o[f]=o[f-1].clone(),s[f]=s[f-1].clone(),a.crossVectors(r[f-1],r[f]),a.length()>Number.EPSILON){a.normalize();let m=Math.acos(Ks(r[f-1].dot(r[f]),-1,1));o[f].applyMatrix4(l.makeRotationAxis(a,m))}s[f].crossVectors(r[f],o[f])}if(!0===e){let f=Math.acos(Ks(o[0].dot(o[t]),-1,1));f/=t,r[0].dot(a.crossVectors(o[0],o[t]))>0&&(f=-f);for(let m=1;m<=t;m++)o[m].applyMatrix4(l.makeRotationAxis(r[m],f*m)),s[m].crossVectors(r[m],o[m])}return{tangents:r,normals:o,binormals:s}}clone(){return(new this.constructor).copy(this)}copy(t){return this.arcLengthDivisions=t.arcLengthDivisions,this}toJSON(){let t={metadata:{version:4.5,type:"Curve",generator:"Curve.toJSON"}};return t.arcLengthDivisions=this.arcLengthDivisions,t.type=this.type,t}fromJSON(t){return this.arcLengthDivisions=t.arcLengthDivisions,this}}),e_=class extends $s{constructor(t=0,e=0,i=1,r=1,o=0,s=2*Math.PI,a=!1,l=0){super(),this.type="EllipseCurve",this.aX=t,this.aY=e,this.xRadius=i,this.yRadius=r,this.aStartAngle=o,this.aEndAngle=s,this.aClockwise=a,this.aRotation=l}getPoint(t,e){let i=e||new $e,r=2*Math.PI,o=this.aEndAngle-this.aStartAngle,s=Math.abs(o)<Number.EPSILON;for(;o<0;)o+=r;for(;o>r;)o-=r;o<Number.EPSILON&&(o=s?0:r),!0===this.aClockwise&&!s&&(o===r?o=-r:o-=r);let a=this.aStartAngle+t*o,l=this.aX+this.xRadius*Math.cos(a),c=this.aY+this.yRadius*Math.sin(a);if(0!==this.aRotation){let d=Math.cos(this.aRotation),u=Math.sin(this.aRotation),p=l-this.aX,f=c-this.aY;l=p*d-f*u+this.aX,c=p*u+f*d+this.aY}return i.set(l,c)}copy(t){return super.copy(t),this.aX=t.aX,this.aY=t.aY,this.xRadius=t.xRadius,this.yRadius=t.yRadius,this.aStartAngle=t.aStartAngle,this.aEndAngle=t.aEndAngle,this.aClockwise=t.aClockwise,this.aRotation=t.aRotation,this}toJSON(){let t=super.toJSON();return t.aX=this.aX,t.aY=this.aY,t.xRadius=this.xRadius,t.yRadius=this.yRadius,t.aStartAngle=this.aStartAngle,t.aEndAngle=this.aEndAngle,t.aClockwise=this.aClockwise,t.aRotation=this.aRotation,t}fromJSON(t){return super.fromJSON(t),this.aX=t.aX,this.aY=t.aY,this.xRadius=t.xRadius,this.yRadius=t.yRadius,this.aStartAngle=t.aStartAngle,this.aEndAngle=t.aEndAngle,this.aClockwise=t.aClockwise,this.aRotation=t.aRotation,this}};e_.prototype.isEllipseCurve=!0;var kI=class extends e_{constructor(t,e,i,r,o,s){super(t,e,i,i,r,o,s),this.type="ArcCurve"}};function mV(){let n=0,t=0,e=0,i=0;function r(o,s,a,l){n=o,t=a,e=-3*o+3*s-2*a-l,i=2*o-2*s+a+l}return{initCatmullRom:function(o,s,a,l,c){r(s,a,c*(a-o),c*(l-s))},initNonuniformCatmullRom:function(o,s,a,l,c,d,u){let p=(s-o)/c-(a-o)/(c+d)+(a-s)/d,f=(a-s)/d-(l-s)/(d+u)+(l-a)/u;p*=d,f*=d,r(s,a,p,f)},calc:function(o){let s=o*o;return n+t*o+e*s+i*(s*o)}}}kI.prototype.isArcCurve=!0;var uI=new $,W3=new mV,q3=new mV,Y3=new mV,FI=class extends $s{constructor(t=[],e=!1,i="centripetal",r=.5){super(),this.type="CatmullRomCurve3",this.points=t,this.closed=e,this.curveType=i,this.tension=r}getPoint(t,e=new $){let c,d,i=e,r=this.points,o=r.length,s=(o-(this.closed?0:1))*t,a=Math.floor(s),l=s-a;this.closed?a+=a>0?0:(Math.floor(Math.abs(a)/o)+1)*o:0===l&&a===o-1&&(a=o-2,l=1),this.closed||a>0?c=r[(a-1)%o]:(uI.subVectors(r[0],r[1]).add(r[0]),c=uI);let u=r[a%o],p=r[(a+1)%o];if(this.closed||a+2<o?d=r[(a+2)%o]:(uI.subVectors(r[o-1],r[o-2]).add(r[o-1]),d=uI),"centripetal"===this.curveType||"chordal"===this.curveType){let f="chordal"===this.curveType?.5:.25,m=Math.pow(c.distanceToSquared(u),f),b=Math.pow(u.distanceToSquared(p),f),M=Math.pow(p.distanceToSquared(d),f);b<1e-4&&(b=1),m<1e-4&&(m=b),M<1e-4&&(M=b),W3.initNonuniformCatmullRom(c.x,u.x,p.x,d.x,m,b,M),q3.initNonuniformCatmullRom(c.y,u.y,p.y,d.y,m,b,M),Y3.initNonuniformCatmullRom(c.z,u.z,p.z,d.z,m,b,M)}else"catmullrom"===this.curveType&&(W3.initCatmullRom(c.x,u.x,p.x,d.x,this.tension),q3.initCatmullRom(c.y,u.y,p.y,d.y,this.tension),Y3.initCatmullRom(c.z,u.z,p.z,d.z,this.tension));return i.set(W3.calc(l),q3.calc(l),Y3.calc(l)),i}copy(t){super.copy(t),this.points=[];for(let e=0,i=t.points.length;e<i;e++)this.points.push(t.points[e].clone());return this.closed=t.closed,this.curveType=t.curveType,this.tension=t.tension,this}toJSON(){let t=super.toJSON();t.points=[];for(let e=0,i=this.points.length;e<i;e++)t.points.push(this.points[e].toArray());return t.closed=this.closed,t.curveType=this.curveType,t.tension=this.tension,t}fromJSON(t){super.fromJSON(t),this.points=[];for(let e=0,i=t.points.length;e<i;e++){let r=t.points[e];this.points.push((new $).fromArray(r))}return this.closed=t.closed,this.curveType=t.curveType,this.tension=t.tension,this}};function Oee(n,t,e,i,r){let o=.5*(i-t),s=.5*(r-e),a=n*n;return(2*e-2*i+o+s)*(n*a)+(-3*e+3*i-2*o-s)*a+o*n+e}function bx(n,t,e,i){return function(n,t){let e=1-n;return e*e*t}(n,t)+function(n,t){return 2*(1-n)*n*t}(n,e)+function(n,t){return n*n*t}(n,i)}function vx(n,t,e,i,r){return function(n,t){let e=1-n;return e*e*e*t}(n,t)+function(n,t){let e=1-n;return 3*e*e*n*t}(n,e)+function(n,t){return 3*(1-n)*n*n*t}(n,i)+function(n,t){return n*n*n*t}(n,r)}FI.prototype.isCatmullRomCurve3=!0;var Fx=class extends $s{constructor(t=new $e,e=new $e,i=new $e,r=new $e){super(),this.type="CubicBezierCurve",this.v0=t,this.v1=e,this.v2=i,this.v3=r}getPoint(t,e=new $e){let i=e,r=this.v0,o=this.v1,s=this.v2,a=this.v3;return i.set(vx(t,r.x,o.x,s.x,a.x),vx(t,r.y,o.y,s.y,a.y)),i}copy(t){return super.copy(t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this.v3.copy(t.v3),this}toJSON(){let t=super.toJSON();return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t.v3=this.v3.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this.v3.fromArray(t.v3),this}};Fx.prototype.isCubicBezierCurve=!0;var NI=class extends $s{constructor(t=new $,e=new $,i=new $,r=new $){super(),this.type="CubicBezierCurve3",this.v0=t,this.v1=e,this.v2=i,this.v3=r}getPoint(t,e=new $){let i=e,r=this.v0,o=this.v1,s=this.v2,a=this.v3;return i.set(vx(t,r.x,o.x,s.x,a.x),vx(t,r.y,o.y,s.y,a.y),vx(t,r.z,o.z,s.z,a.z)),i}copy(t){return super.copy(t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this.v3.copy(t.v3),this}toJSON(){let t=super.toJSON();return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t.v3=this.v3.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this.v3.fromArray(t.v3),this}};NI.prototype.isCubicBezierCurve3=!0;var t_=class extends $s{constructor(t=new $e,e=new $e){super(),this.type="LineCurve",this.v1=t,this.v2=e}getPoint(t,e=new $e){let i=e;return 1===t?i.copy(this.v2):(i.copy(this.v2).sub(this.v1),i.multiplyScalar(t).add(this.v1)),i}getPointAt(t,e){return this.getPoint(t,e)}getTangent(t,e){let i=e||new $e;return i.copy(this.v2).sub(this.v1).normalize(),i}copy(t){return super.copy(t),this.v1.copy(t.v1),this.v2.copy(t.v2),this}toJSON(){let t=super.toJSON();return t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this}};t_.prototype.isLineCurve=!0;var Nx=class extends $s{constructor(t=new $e,e=new $e,i=new $e){super(),this.type="QuadraticBezierCurve",this.v0=t,this.v1=e,this.v2=i}getPoint(t,e=new $e){let i=e,r=this.v0,o=this.v1,s=this.v2;return i.set(bx(t,r.x,o.x,s.x),bx(t,r.y,o.y,s.y)),i}copy(t){return super.copy(t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this}toJSON(){let t=super.toJSON();return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this}};Nx.prototype.isQuadraticBezierCurve=!0;var LI=class extends $s{constructor(t=new $,e=new $,i=new $){super(),this.type="QuadraticBezierCurve3",this.v0=t,this.v1=e,this.v2=i}getPoint(t,e=new $){let i=e,r=this.v0,o=this.v1,s=this.v2;return i.set(bx(t,r.x,o.x,s.x),bx(t,r.y,o.y,s.y),bx(t,r.z,o.z,s.z)),i}copy(t){return super.copy(t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this}toJSON(){let t=super.toJSON();return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this}};LI.prototype.isQuadraticBezierCurve3=!0;var Lx=class extends $s{constructor(t=[]){super(),this.type="SplineCurve",this.points=t}getPoint(t,e=new $e){let i=e,r=this.points,o=(r.length-1)*t,s=Math.floor(o),a=o-s,l=r[0===s?s:s-1],c=r[s],d=r[s>r.length-2?r.length-1:s+1],u=r[s>r.length-3?r.length-1:s+2];return i.set(Oee(a,l.x,c.x,d.x,u.x),Oee(a,l.y,c.y,d.y,u.y)),i}copy(t){super.copy(t),this.points=[];for(let e=0,i=t.points.length;e<i;e++)this.points.push(t.points[e].clone());return this}toJSON(){let t=super.toJSON();t.points=[];for(let e=0,i=this.points.length;e<i;e++)t.points.push(this.points[e].toArray());return t}fromJSON(t){super.fromJSON(t),this.points=[];for(let e=0,i=t.points.length;e<i;e++){let r=t.points[e];this.points.push((new $e).fromArray(r))}return this}};Lx.prototype.isSplineCurve=!0;var lte=Object.freeze({__proto__:null,ArcCurve:kI,CatmullRomCurve3:FI,CubicBezierCurve:Fx,CubicBezierCurve3:NI,EllipseCurve:e_,LineCurve:t_,LineCurve3:class extends $s{constructor(t=new $,e=new $){super(),this.type="LineCurve3",this.isLineCurve3=!0,this.v1=t,this.v2=e}getPoint(t,e=new $){let i=e;return 1===t?i.copy(this.v2):(i.copy(this.v2).sub(this.v1),i.multiplyScalar(t).add(this.v1)),i}getPointAt(t,e){return this.getPoint(t,e)}copy(t){return super.copy(t),this.v1.copy(t.v1),this.v2.copy(t.v2),this}toJSON(){let t=super.toJSON();return t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this}},QuadraticBezierCurve:Nx,QuadraticBezierCurve3:LI,SplineCurve:Lx}),CB=class extends $s{constructor(){super(),this.type="CurvePath",this.curves=[],this.autoClose=!1}add(t){this.curves.push(t)}closePath(){let t=this.curves[0].getPoint(0),e=this.curves[this.curves.length-1].getPoint(1);t.equals(e)||this.curves.push(new t_(e,t))}getPoint(t,e){let i=t*this.getLength(),r=this.getCurveLengths(),o=0;for(;o<r.length;){if(r[o]>=i){let s=r[o]-i,a=this.curves[o],l=a.getLength();return a.getPointAt(0===l?0:1-s/l,e)}o++}return null}getLength(){let t=this.getCurveLengths();return t[t.length-1]}updateArcLengths(){this.needsUpdate=!0,this.cacheLengths=null,this.getCurveLengths()}getCurveLengths(){if(this.cacheLengths&&this.cacheLengths.length===this.curves.length)return this.cacheLengths;let t=[],e=0;for(let i=0,r=this.curves.length;i<r;i++)e+=this.curves[i].getLength(),t.push(e);return this.cacheLengths=t,t}getSpacedPoints(t=40){let e=[];for(let i=0;i<=t;i++)e.push(this.getPoint(i/t));return this.autoClose&&e.push(e[0]),e}getPoints(t=12){let i,e=[];for(let r=0,o=this.curves;r<o.length;r++){let s=o[r],l=s.getPoints(s&&s.isEllipseCurve?2*t:s&&(s.isLineCurve||s.isLineCurve3)?1:s&&s.isSplineCurve?t*s.points.length:t);for(let c=0;c<l.length;c++){let d=l[c];i&&i.equals(d)||(e.push(d),i=d)}}return this.autoClose&&e.length>1&&!e[e.length-1].equals(e[0])&&e.push(e[0]),e}copy(t){super.copy(t),this.curves=[];for(let e=0,i=t.curves.length;e<i;e++)this.curves.push(t.curves[e].clone());return this.autoClose=t.autoClose,this}toJSON(){let t=super.toJSON();t.autoClose=this.autoClose,t.curves=[];for(let e=0,i=this.curves.length;e<i;e++)t.curves.push(this.curves[e].toJSON());return t}fromJSON(t){super.fromJSON(t),this.autoClose=t.autoClose,this.curves=[];for(let e=0,i=t.curves.length;e<i;e++){let r=t.curves[e];this.curves.push((new lte[r.type]).fromJSON(r))}return this}},Bx=class extends CB{constructor(t){super(),this.type="Path",this.currentPoint=new $e,t&&this.setFromPoints(t)}setFromPoints(t){this.moveTo(t[0].x,t[0].y);for(let e=1,i=t.length;e<i;e++)this.lineTo(t[e].x,t[e].y);return this}moveTo(t,e){return this.currentPoint.set(t,e),this}lineTo(t,e){let i=new t_(this.currentPoint.clone(),new $e(t,e));return this.curves.push(i),this.currentPoint.set(t,e),this}quadraticCurveTo(t,e,i,r){let o=new Nx(this.currentPoint.clone(),new $e(t,e),new $e(i,r));return this.curves.push(o),this.currentPoint.set(i,r),this}bezierCurveTo(t,e,i,r,o,s){let a=new Fx(this.currentPoint.clone(),new $e(t,e),new $e(i,r),new $e(o,s));return this.curves.push(a),this.currentPoint.set(o,s),this}splineThru(t){let e=[this.currentPoint.clone()].concat(t),i=new Lx(e);return this.curves.push(i),this.currentPoint.copy(t[t.length-1]),this}arc(t,e,i,r,o,s){return this.absarc(t+this.currentPoint.x,e+this.currentPoint.y,i,r,o,s),this}absarc(t,e,i,r,o,s){return this.absellipse(t,e,i,i,r,o,s),this}ellipse(t,e,i,r,o,s,a,l){return this.absellipse(t+this.currentPoint.x,e+this.currentPoint.y,i,r,o,s,a,l),this}absellipse(t,e,i,r,o,s,a,l){let c=new e_(t,e,i,r,o,s,a,l);if(this.curves.length>0){let u=c.getPoint(0);u.equals(this.currentPoint)||this.lineTo(u.x,u.y)}this.curves.push(c);let d=c.getPoint(1);return this.currentPoint.copy(d),this}copy(t){return super.copy(t),this.currentPoint.copy(t.currentPoint),this}toJSON(){let t=super.toJSON();return t.currentPoint=this.currentPoint.toArray(),t}fromJSON(t){return super.fromJSON(t),this.currentPoint.fromArray(t.currentPoint),this}},qd=class extends Bx{constructor(t){super(t),this.uuid=Jl(),this.type="Shape",this.holes=[]}getPointsHoles(t){let e=[];for(let i=0,r=this.holes.length;i<r;i++)e[i]=this.holes[i].getPoints(t);return e}extractPoints(t){return{shape:this.getPoints(t),holes:this.getPointsHoles(t)}}copy(t){super.copy(t),this.holes=[];for(let e=0,i=t.holes.length;e<i;e++)this.holes.push(t.holes[e].clone());return this}toJSON(){let t=super.toJSON();t.uuid=this.uuid,t.holes=[];for(let e=0,i=this.holes.length;e<i;e++)t.holes.push(this.holes[e].toJSON());return t}fromJSON(t){super.fromJSON(t),this.uuid=t.uuid,this.holes=[];for(let e=0,i=t.holes.length;e<i;e++){let r=t.holes[e];this.holes.push((new Bx).fromJSON(r))}return this}};function cte(n,t,e,i,r){let o,s;if(r===function(n,t,e,i){let r=0;for(let o=t,s=e-i;o<e;o+=i)r+=(n[s]-n[o])*(n[o+1]+n[s+1]),s=o;return r}(n,t,e,i)>0)for(o=t;o<e;o+=i)s=kee(o,n[o],n[o+1],s);else for(o=e-i;o>=t;o-=i)s=kee(o,n[o],n[o+1],s);return s&&KI(s,s.next)&&(zx(s),s=s.next),s}function xp(n,t){if(!n)return n;t||(t=n);let i,e=n;do{if(i=!1,e.steiner||!KI(e,e.next)&&0!==Fr(e.prev,e,e.next))e=e.next;else{if(zx(e),e=t=e.prev,e===e.next)break;i=!0}}while(i||e!==t);return t}function Vx(n,t,e,i,r,o,s){if(!n)return;!s&&o&&function(n,t,e,i){let r=n;do{null===r.z&&(r.z=MB(r.x,r.y,t,e,i)),r.prevZ=r.prev,r.nextZ=r.next,r=r.next}while(r!==n);r.prevZ.nextZ=null,r.prevZ=null,function(n){let t,e,i,r,o,s,a,l,c=1;do{for(e=n,n=null,o=null,s=0;e;){for(s++,i=e,a=0,t=0;t<c&&(a++,i=i.nextZ,i);t++);for(l=c;a>0||l>0&&i;)0!==a&&(0===l||!i||e.z<=i.z)?(r=e,e=e.nextZ,a--):(r=i,i=i.nextZ,l--),o?o.nextZ=r:n=r,r.prevZ=o,o=r;e=i}o.nextZ=null,c*=2}while(s>1)}(r)}(n,i,r,o);let l,c,a=n;for(;n.prev!==n.next;)if(l=n.prev,c=n.next,o?d2e(n,i,r,o):c2e(n))t.push(l.i/e),t.push(n.i/e),t.push(c.i/e),zx(n),n=c.next,a=c.next;else if((n=c)===a){s?1===s?Vx(n=u2e(xp(n),t,e),t,e,i,r,o,2):2===s&&p2e(n,t,e,i,r,o):Vx(xp(n),t,e,i,r,o,1);break}}function c2e(n){let t=n.prev,e=n,i=n.next;if(Fr(t,e,i)>=0)return!1;let r=n.next.next;for(;r!==n.prev;){if(z0(t.x,t.y,e.x,e.y,i.x,i.y,r.x,r.y)&&Fr(r.prev,r,r.next)>=0)return!1;r=r.next}return!0}function d2e(n,t,e,i){let r=n.prev,o=n,s=n.next;if(Fr(r,o,s)>=0)return!1;let c=r.x>o.x?r.x>s.x?r.x:s.x:o.x>s.x?o.x:s.x,d=r.y>o.y?r.y>s.y?r.y:s.y:o.y>s.y?o.y:s.y,u=MB(r.x<o.x?r.x<s.x?r.x:s.x:o.x<s.x?o.x:s.x,r.y<o.y?r.y<s.y?r.y:s.y:o.y<s.y?o.y:s.y,t,e,i),p=MB(c,d,t,e,i),f=n.prevZ,m=n.nextZ;for(;f&&f.z>=u&&m&&m.z<=p;){if(f!==n.prev&&f!==n.next&&z0(r.x,r.y,o.x,o.y,s.x,s.y,f.x,f.y)&&Fr(f.prev,f,f.next)>=0||(f=f.prevZ,m!==n.prev&&m!==n.next&&z0(r.x,r.y,o.x,o.y,s.x,s.y,m.x,m.y)&&Fr(m.prev,m,m.next)>=0))return!1;m=m.nextZ}for(;f&&f.z>=u;){if(f!==n.prev&&f!==n.next&&z0(r.x,r.y,o.x,o.y,s.x,s.y,f.x,f.y)&&Fr(f.prev,f,f.next)>=0)return!1;f=f.prevZ}for(;m&&m.z<=p;){if(m!==n.prev&&m!==n.next&&z0(r.x,r.y,o.x,o.y,s.x,s.y,m.x,m.y)&&Fr(m.prev,m,m.next)>=0)return!1;m=m.nextZ}return!0}function u2e(n,t,e){let i=n;do{let r=i.prev,o=i.next.next;!KI(r,o)&&dte(r,i,i.next,o)&&Hx(r,o)&&Hx(o,r)&&(t.push(r.i/e),t.push(i.i/e),t.push(o.i/e),zx(i),zx(i.next),i=n=o),i=i.next}while(i!==n);return xp(i)}function p2e(n,t,e,i,r,o){let s=n;do{let a=s.next.next;for(;a!==s.prev;){if(s.i!==a.i&&x2e(s,a)){let l=ute(s,a);return s=xp(s,s.next),l=xp(l,l.next),Vx(s,t,e,i,r,o),void Vx(l,t,e,i,r,o)}a=a.next}s=s.next}while(s!==n)}function m2e(n,t){return n.x-t.x}function h2e(n,t){if(t=function(n,t){let s,e=t,i=n.x,r=n.y,o=-1/0;do{if(r<=e.y&&r>=e.next.y&&e.next.y!==e.y){let p=e.x+(r-e.y)*(e.next.x-e.x)/(e.next.y-e.y);if(p<=i&&p>o){if(o=p,p===i){if(r===e.y)return e;if(r===e.next.y)return e.next}s=e.x<e.next.x?e:e.next}}e=e.next}while(e!==t);if(!s)return null;if(i===o)return s;let u,a=s,l=s.x,c=s.y,d=1/0;e=s;do{i>=e.x&&e.x>=l&&i!==e.x&&z0(r<c?i:o,r,l,c,r<c?o:i,r,e.x,e.y)&&(u=Math.abs(r-e.y)/(i-e.x),Hx(e,n)&&(u<d||u===d&&(e.x>s.x||e.x===s.x&&_2e(s,e)))&&(s=e,d=u)),e=e.next}while(e!==a);return s}(n,t),t){let e=ute(t,n);xp(t,t.next),xp(e,e.next)}}function _2e(n,t){return Fr(n.prev,n,t.prev)<0&&Fr(t.next,n,n.next)<0}function MB(n,t,e,i,r){return(n=1431655765&((n=858993459&((n=252645135&((n=16711935&((n=32767*(n-e)*r)|n<<8))|n<<4))|n<<2))|n<<1))|(t=1431655765&((t=858993459&((t=252645135&((t=16711935&((t=32767*(t-i)*r)|t<<8))|t<<4))|t<<2))|t<<1))<<1}function y2e(n){let t=n,e=n;do{(t.x<e.x||t.x===e.x&&t.y<e.y)&&(e=t),t=t.next}while(t!==n);return e}function z0(n,t,e,i,r,o,s,a){return(r-s)*(t-a)-(n-s)*(o-a)>=0&&(n-s)*(i-a)-(e-s)*(t-a)>=0&&(e-s)*(o-a)-(r-s)*(i-a)>=0}function x2e(n,t){return n.next.i!==t.i&&n.prev.i!==t.i&&!function(n,t){let e=n;do{if(e.i!==n.i&&e.next.i!==n.i&&e.i!==t.i&&e.next.i!==t.i&&dte(e,e.next,n,t))return!0;e=e.next}while(e!==n);return!1}(n,t)&&(Hx(n,t)&&Hx(t,n)&&function(n,t){let e=n,i=!1,r=(n.x+t.x)/2,o=(n.y+t.y)/2;do{e.y>o!=e.next.y>o&&e.next.y!==e.y&&r<(e.next.x-e.x)*(o-e.y)/(e.next.y-e.y)+e.x&&(i=!i),e=e.next}while(e!==n);return i}(n,t)&&(Fr(n.prev,n,t.prev)||Fr(n,t.prev,t))||KI(n,t)&&Fr(n.prev,n,n.next)>0&&Fr(t.prev,t,t.next)>0)}function Fr(n,t,e){return(t.y-n.y)*(e.x-t.x)-(t.x-n.x)*(e.y-t.y)}function KI(n,t){return n.x===t.x&&n.y===t.y}function dte(n,t,e,i){let r=fI(Fr(n,t,e)),o=fI(Fr(n,t,i)),s=fI(Fr(e,i,n)),a=fI(Fr(e,i,t));return!!(r!==o&&s!==a||0===r&&pI(n,e,t)||0===o&&pI(n,i,t)||0===s&&pI(e,n,i)||0===a&&pI(e,t,i))}function pI(n,t,e){return t.x<=Math.max(n.x,e.x)&&t.x>=Math.min(n.x,e.x)&&t.y<=Math.max(n.y,e.y)&&t.y>=Math.min(n.y,e.y)}function fI(n){return n>0?1:n<0?-1:0}function Hx(n,t){return Fr(n.prev,n,n.next)<0?Fr(n,t,n.next)>=0&&Fr(n,n.prev,t)>=0:Fr(n,t,n.prev)<0||Fr(n,n.next,t)<0}function ute(n,t){let e=new wB(n.i,n.x,n.y),i=new wB(t.i,t.x,t.y),r=n.next,o=t.prev;return n.next=t,t.prev=n,e.next=r,r.prev=e,i.next=e,e.prev=i,o.next=i,i.prev=o,i}function kee(n,t,e,i){let r=new wB(n,t,e);return i?(r.next=i.next,r.prev=i,i.next.prev=r,i.next=r):(r.prev=r,r.next=r),r}function zx(n){n.next.prev=n.prev,n.prev.next=n.next,n.prevZ&&(n.prevZ.nextZ=n.nextZ),n.nextZ&&(n.nextZ.prevZ=n.prevZ)}function wB(n,t,e){this.i=n,this.x=t,this.y=e,this.prev=null,this.next=null,this.z=null,this.prevZ=null,this.nextZ=null,this.steiner=!1}var Yc=class{static area(t){let e=t.length,i=0;for(let r=e-1,o=0;o<e;r=o++)i+=t[r].x*t[o].y-t[o].x*t[r].y;return.5*i}static isClockWise(t){return Yc.area(t)<0}static triangulateShape(t,e){let i=[],r=[],o=[];Fee(t),Nee(i,t);let s=t.length;e.forEach(Fee);for(let l=0;l<e.length;l++)r.push(s),s+=e[l].length,Nee(i,e[l]);let a=function(n,t,e=2){let a,l,c,d,u,p,f,i=t&&t.length,r=i?t[0]*e:n.length,o=cte(n,0,r,e,!0),s=[];if(!o||o.next===o.prev)return s;if(i&&(o=function(n,t,e,i){let o,s,a,l,c,r=[];for(o=0,s=t.length;o<s;o++)a=t[o]*i,l=o<s-1?t[o+1]*i:n.length,c=cte(n,a,l,i,!1),c===c.next&&(c.steiner=!0),r.push(y2e(c));for(r.sort(m2e),o=0;o<r.length;o++)h2e(r[o],e),e=xp(e,e.next);return e}(n,t,o,e)),n.length>80*e){a=c=n[0],l=d=n[1];for(let m=e;m<r;m+=e)u=n[m],p=n[m+1],u<a&&(a=u),p<l&&(l=p),u>c&&(c=u),p>d&&(d=p);f=Math.max(c-a,d-l),f=0!==f?1/f:0}return Vx(o,s,e,a,l,f),s}(i,r);for(let l=0;l<a.length;l+=3)o.push(a.slice(l,l+3));return o}};function Fee(n){let t=n.length;t>2&&n[t-1].equals(n[0])&&n.pop()}function Nee(n,t){for(let e=0;e<t.length;e++)n.push(t[e].x),n.push(t[e].y)}var Cp=class extends Ui{constructor(t=new qd([new $e(.5,.5),new $e(-.5,.5),new $e(-.5,-.5),new $e(.5,-.5)]),e={}){super(),this.type="ExtrudeGeometry",this.parameters={shapes:t,options:e},t=Array.isArray(t)?t:[t];let i=this,r=[],o=[];for(let a=0,l=t.length;a<l;a++)s(t[a]);function s(a){let l=[],c=void 0!==e.curveSegments?e.curveSegments:12,d=void 0!==e.steps?e.steps:1,u=void 0!==e.depth?e.depth:1,p=void 0===e.bevelEnabled||e.bevelEnabled,f=void 0!==e.bevelThickness?e.bevelThickness:.2,m=void 0!==e.bevelSize?e.bevelSize:f-.1,b=void 0!==e.bevelOffset?e.bevelOffset:0,M=void 0!==e.bevelSegments?e.bevelSegments:3,y=e.extrudePath,x=void 0!==e.UVGenerator?e.UVGenerator:S2e;void 0!==e.amount&&(console.warn("THREE.ExtrudeBufferGeometry: amount has been renamed to depth."),u=e.amount);let R,V,te,K,xe,A=!1;y&&(R=y.getSpacedPoints(d),A=!0,p=!1,V=y.computeFrenetFrames(d,!1),te=new $,K=new $,xe=new $),p||(M=0,f=0,m=0,b=0);let Xe=a.extractPoints(c),De=Xe.shape,D=Xe.holes;if(!Yc.isClockWise(De)){De=De.reverse();for(let oe=0,st=D.length;oe<st;oe++){let Ye=D[oe];Yc.isClockWise(Ye)&&(D[oe]=Ye.reverse())}}let ce=Yc.triangulateShape(De,D),fe=De;for(let oe=0,st=D.length;oe<st;oe++)De=De.concat(D[oe]);function be(oe,st,Ye){return st||console.error("THREE.ExtrudeGeometry: vec does not exist"),st.clone().multiplyScalar(Ye).add(oe)}let ne=De.length,de=ce.length;function pe(oe,st,Ye){let _t,ut,sn,Cn=oe.x-st.x,ti=oe.y-st.y,ki=Ye.x-oe.x,Fi=Ye.y-oe.y,Z=Cn*Cn+ti*ti;if(Math.abs(Cn*Fi-ti*ki)>Number.EPSILON){let Ve=Math.sqrt(Z),vt=Math.sqrt(ki*ki+Fi*Fi),en=st.x-ti/Ve,Le=st.y+Cn/Ve,Ft=((Ye.x-Fi/vt-en)*Fi-(Ye.y+ki/vt-Le)*ki)/(Cn*Fi-ti*ki);_t=en+Cn*Ft-oe.x,ut=Le+ti*Ft-oe.y;let Pt=_t*_t+ut*ut;if(Pt<=2)return new $e(_t,ut);sn=Math.sqrt(Pt/2)}else{let Ve=!1;Cn>Number.EPSILON?ki>Number.EPSILON&&(Ve=!0):Cn<-Number.EPSILON?ki<-Number.EPSILON&&(Ve=!0):Math.sign(ti)===Math.sign(Fi)&&(Ve=!0),Ve?(_t=-ti,ut=Cn,sn=Math.sqrt(Z)):(_t=Cn,ut=ti,sn=Math.sqrt(Z/2))}return new $e(_t/sn,ut/sn)}let je=[];for(let oe=0,st=fe.length,Ye=st-1,_t=oe+1;oe<st;oe++,Ye++,_t++)Ye===st&&(Ye=0),_t===st&&(_t=0),je[oe]=pe(fe[oe],fe[Ye],fe[_t]);let Ne,Ce=[],lt=je.concat();for(let oe=0,st=D.length;oe<st;oe++){let Ye=D[oe];Ne=[];for(let _t=0,ut=Ye.length,sn=ut-1,Cn=_t+1;_t<ut;_t++,sn++,Cn++)sn===ut&&(sn=0),Cn===ut&&(Cn=0),Ne[_t]=pe(Ye[_t],Ye[sn],Ye[Cn]);Ce.push(Ne),lt=lt.concat(Ne)}for(let oe=0;oe<M;oe++){let st=oe/M,Ye=f*Math.cos(st*Math.PI/2),_t=m*Math.sin(st*Math.PI/2)+b;for(let ut=0,sn=fe.length;ut<sn;ut++){let Cn=be(fe[ut],je[ut],_t);wt(Cn.x,Cn.y,-Ye)}for(let ut=0,sn=D.length;ut<sn;ut++){let Cn=D[ut];Ne=Ce[ut];for(let ti=0,ki=Cn.length;ti<ki;ti++){let Fi=be(Cn[ti],Ne[ti],_t);wt(Fi.x,Fi.y,-Ye)}}}let Mt=m+b;for(let oe=0;oe<ne;oe++){let st=p?be(De[oe],lt[oe],Mt):De[oe];A?(K.copy(V.normals[0]).multiplyScalar(st.x),te.copy(V.binormals[0]).multiplyScalar(st.y),xe.copy(R[0]).add(K).add(te),wt(xe.x,xe.y,xe.z)):wt(st.x,st.y,0)}for(let oe=1;oe<=d;oe++)for(let st=0;st<ne;st++){let Ye=p?be(De[st],lt[st],Mt):De[st];A?(K.copy(V.normals[oe]).multiplyScalar(Ye.x),te.copy(V.binormals[oe]).multiplyScalar(Ye.y),xe.copy(R[oe]).add(K).add(te),wt(xe.x,xe.y,xe.z)):wt(Ye.x,Ye.y,u/d*oe)}for(let oe=M-1;oe>=0;oe--){let st=oe/M,Ye=f*Math.cos(st*Math.PI/2),_t=m*Math.sin(st*Math.PI/2)+b;for(let ut=0,sn=fe.length;ut<sn;ut++){let Cn=be(fe[ut],je[ut],_t);wt(Cn.x,Cn.y,u+Ye)}for(let ut=0,sn=D.length;ut<sn;ut++){let Cn=D[ut];Ne=Ce[ut];for(let ti=0,ki=Cn.length;ti<ki;ti++){let Fi=be(Cn[ti],Ne[ti],_t);A?wt(Fi.x,Fi.y+R[d-1].y,R[d-1].x+Ye):wt(Fi.x,Fi.y,u+Ye)}}}function An(oe,st){let Ye=oe.length;for(;--Ye>=0;){let _t=Ye,ut=Ye-1;ut<0&&(ut=oe.length-1);for(let sn=0,Cn=d+2*M;sn<Cn;sn++){let ti=ne*sn,ki=ne*(sn+1);ve(st+_t+ti,st+ut+ti,st+ut+ki,st+_t+ki)}}}function wt(oe,st,Ye){l.push(oe),l.push(st),l.push(Ye)}function on(oe,st,Ye){mt(oe),mt(st),mt(Ye);let _t=r.length/3,ut=x.generateTopUV(i,r,_t-3,_t-2,_t-1);ft(ut[0]),ft(ut[1]),ft(ut[2])}function ve(oe,st,Ye,_t){mt(oe),mt(st),mt(_t),mt(st),mt(Ye),mt(_t);let ut=r.length/3,sn=x.generateSideWallUV(i,r,ut-6,ut-3,ut-2,ut-1);ft(sn[0]),ft(sn[1]),ft(sn[3]),ft(sn[1]),ft(sn[2]),ft(sn[3])}function mt(oe){r.push(l[3*oe+0]),r.push(l[3*oe+1]),r.push(l[3*oe+2])}function ft(oe){o.push(oe.x),o.push(oe.y)}(function(){let oe=r.length/3;if(p){let st=0,Ye=ne*st;for(let _t=0;_t<de;_t++){let ut=ce[_t];on(ut[2]+Ye,ut[1]+Ye,ut[0]+Ye)}st=d+2*M,Ye=ne*st;for(let _t=0;_t<de;_t++){let ut=ce[_t];on(ut[0]+Ye,ut[1]+Ye,ut[2]+Ye)}}else{for(let st=0;st<de;st++){let Ye=ce[st];on(Ye[2],Ye[1],Ye[0])}for(let st=0;st<de;st++){let Ye=ce[st];on(Ye[0]+ne*d,Ye[1]+ne*d,Ye[2]+ne*d)}}i.addGroup(oe,r.length/3-oe,0)})(),function(){let oe=r.length/3,st=0;An(fe,st),st+=fe.length;for(let Ye=0,_t=D.length;Ye<_t;Ye++){let ut=D[Ye];An(ut,st),st+=ut.length}i.addGroup(oe,r.length/3-oe,1)}()}this.setAttribute("position",new Nr(r,3)),this.setAttribute("uv",new Nr(o,2)),this.computeVertexNormals()}toJSON(){let t=super.toJSON();return function(n,t,e){if(e.shapes=[],Array.isArray(n))for(let i=0,r=n.length;i<r;i++)e.shapes.push(n[i].uuid);else e.shapes.push(n.uuid);return void 0!==t.extrudePath&&(e.options.extrudePath=t.extrudePath.toJSON()),e}(this.parameters.shapes,this.parameters.options,t)}static fromJSON(t,e){let i=[];for(let o=0,s=t.shapes.length;o<s;o++)i.push(e[t.shapes[o]]);let r=t.options.extrudePath;return void 0!==r&&(t.options.extrudePath=(new lte[r.type]).fromJSON(r)),new Cp(i,t.options)}},S2e={generateTopUV:function(n,t,e,i,r){let a=t[3*i],l=t[3*i+1],c=t[3*r],d=t[3*r+1];return[new $e(t[3*e],t[3*e+1]),new $e(a,l),new $e(c,d)]},generateSideWallUV:function(n,t,e,i,r,o){let s=t[3*e],a=t[3*e+1],l=t[3*e+2],c=t[3*i],d=t[3*i+1],u=t[3*i+2],p=t[3*r],f=t[3*r+1],m=t[3*r+2],b=t[3*o],M=t[3*o+1],y=t[3*o+2];return Math.abs(a-d)<Math.abs(s-c)?[new $e(s,1-l),new $e(c,1-u),new $e(p,1-m),new $e(b,1-y)]:[new $e(a,1-l),new $e(d,1-u),new $e(f,1-m),new $e(M,1-y)]}},_m=class extends Ui{constructor(t=new qd([new $e(0,.5),new $e(-.5,-.5),new $e(.5,-.5)]),e=12){super(),this.type="ShapeGeometry",this.parameters={shapes:t,curveSegments:e};let i=[],r=[],o=[],s=[],a=0,l=0;if(!1===Array.isArray(t))c(t);else for(let d=0;d<t.length;d++)c(t[d]),this.addGroup(a,l,d),a+=l,l=0;function c(d){let u=r.length/3,p=d.extractPoints(e),f=p.shape,m=p.holes;!1===Yc.isClockWise(f)&&(f=f.reverse());for(let M=0,y=m.length;M<y;M++){let x=m[M];!0===Yc.isClockWise(x)&&(m[M]=x.reverse())}let b=Yc.triangulateShape(f,m);for(let M=0,y=m.length;M<y;M++)f=f.concat(m[M]);for(let M=0,y=f.length;M<y;M++){let x=f[M];r.push(x.x,x.y,0),o.push(0,0,1),s.push(x.x,x.y)}for(let M=0,y=b.length;M<y;M++){let x=b[M];i.push(x[0]+u,x[1]+u,x[2]+u),l+=3}}this.setIndex(i),this.setAttribute("position",new Nr(r,3)),this.setAttribute("normal",new Nr(o,3)),this.setAttribute("uv",new Nr(s,2))}toJSON(){let t=super.toJSON();return function(n,t){if(t.shapes=[],Array.isArray(n))for(let e=0,i=n.length;e<i;e++)t.shapes.push(n[e].uuid);else t.shapes.push(n.uuid);return t}(this.parameters.shapes,t)}static fromJSON(t,e){let i=[];for(let r=0,o=t.shapes.length;r<o;r++)i.push(e[t.shapes[r]]);return new _m(i,t.curveSegments)}};(class extends Ao{constructor(t){super(),this.type="ShadowMaterial",this.color=new an(0),this.transparent=!0,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this}}).prototype.isShadowMaterial=!0;var BI=class extends Ao{constructor(t){super(),this.defines={STANDARD:""},this.type="MeshStandardMaterial",this.color=new an(16777215),this.roughness=1,this.metalness=0,this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new an(0),this.emissiveIntensity=1,this.emissiveMap=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=o_,this.normalScale=new $e(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.roughnessMap=null,this.metalnessMap=null,this.alphaMap=null,this.envMap=null,this.envMapIntensity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.flatShading=!1,this.setValues(t)}copy(t){return super.copy(t),this.defines={STANDARD:""},this.color.copy(t.color),this.roughness=t.roughness,this.metalness=t.metalness,this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.roughnessMap=t.roughnessMap,this.metalnessMap=t.metalnessMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.envMapIntensity=t.envMapIntensity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this.flatShading=t.flatShading,this}};BI.prototype.isMeshStandardMaterial=!0,class extends BI{constructor(t){super(),this.defines={STANDARD:"",PHYSICAL:""},this.type="MeshPhysicalMaterial",this.clearcoatMap=null,this.clearcoatRoughness=0,this.clearcoatRoughnessMap=null,this.clearcoatNormalScale=new $e(1,1),this.clearcoatNormalMap=null,this.ior=1.5,Object.defineProperty(this,"reflectivity",{get:function(){return Ks(2.5*(this.ior-1)/(this.ior+1),0,1)},set:function(e){this.ior=(1+.4*e)/(1-.4*e)}}),this.sheenColor=new an(0),this.sheenColorMap=null,this.sheenRoughness=1,this.sheenRoughnessMap=null,this.transmissionMap=null,this.thickness=0,this.thicknessMap=null,this.attenuationDistance=0,this.attenuationColor=new an(1,1,1),this.specularIntensity=1,this.specularIntensityMap=null,this.specularColor=new an(1,1,1),this.specularColorMap=null,this._sheen=0,this._clearcoat=0,this._transmission=0,this.setValues(t)}get sheen(){return this._sheen}set sheen(t){this._sheen>0!=t>0&&this.version++,this._sheen=t}get clearcoat(){return this._clearcoat}set clearcoat(t){this._clearcoat>0!=t>0&&this.version++,this._clearcoat=t}get transmission(){return this._transmission}set transmission(t){this._transmission>0!=t>0&&this.version++,this._transmission=t}copy(t){return super.copy(t),this.defines={STANDARD:"",PHYSICAL:""},this.clearcoat=t.clearcoat,this.clearcoatMap=t.clearcoatMap,this.clearcoatRoughness=t.clearcoatRoughness,this.clearcoatRoughnessMap=t.clearcoatRoughnessMap,this.clearcoatNormalMap=t.clearcoatNormalMap,this.clearcoatNormalScale.copy(t.clearcoatNormalScale),this.ior=t.ior,this.sheen=t.sheen,this.sheenColor.copy(t.sheenColor),this.sheenColorMap=t.sheenColorMap,this.sheenRoughness=t.sheenRoughness,this.sheenRoughnessMap=t.sheenRoughnessMap,this.transmission=t.transmission,this.transmissionMap=t.transmissionMap,this.thickness=t.thickness,this.thicknessMap=t.thicknessMap,this.attenuationDistance=t.attenuationDistance,this.attenuationColor.copy(t.attenuationColor),this.specularIntensity=t.specularIntensity,this.specularIntensityMap=t.specularIntensityMap,this.specularColor.copy(t.specularColor),this.specularColorMap=t.specularColorMap,this}}.prototype.isMeshPhysicalMaterial=!0,class extends Ao{constructor(t){super(),this.type="MeshPhongMaterial",this.color=new an(16777215),this.specular=new an(1118481),this.shininess=30,this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new an(0),this.emissiveIntensity=1,this.emissiveMap=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=o_,this.normalScale=new $e(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.specularMap=null,this.alphaMap=null,this.envMap=null,this.combine=YI,this.reflectivity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.flatShading=!1,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.specular.copy(t.specular),this.shininess=t.shininess,this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.specularMap=t.specularMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.combine=t.combine,this.reflectivity=t.reflectivity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this.flatShading=t.flatShading,this}}.prototype.isMeshPhongMaterial=!0,class extends Ao{constructor(t){super(),this.defines={TOON:""},this.type="MeshToonMaterial",this.color=new an(16777215),this.map=null,this.gradientMap=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new an(0),this.emissiveIntensity=1,this.emissiveMap=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=o_,this.normalScale=new $e(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.alphaMap=null,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.gradientMap=t.gradientMap,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.alphaMap=t.alphaMap,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this}}.prototype.isMeshToonMaterial=!0,class extends Ao{constructor(t){super(),this.type="MeshNormalMaterial",this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=o_,this.normalScale=new $e(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.wireframe=!1,this.wireframeLinewidth=1,this.fog=!1,this.flatShading=!1,this.setValues(t)}copy(t){return super.copy(t),this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.flatShading=t.flatShading,this}}.prototype.isMeshNormalMaterial=!0,class extends Ao{constructor(t){super(),this.type="MeshLambertMaterial",this.color=new an(16777215),this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new an(0),this.emissiveIntensity=1,this.emissiveMap=null,this.specularMap=null,this.alphaMap=null,this.envMap=null,this.combine=YI,this.reflectivity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.specularMap=t.specularMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.combine=t.combine,this.reflectivity=t.reflectivity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this}}.prototype.isMeshLambertMaterial=!0,class extends Ao{constructor(t){super(),this.defines={MATCAP:""},this.type="MeshMatcapMaterial",this.color=new an(16777215),this.matcap=null,this.map=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=o_,this.normalScale=new $e(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.alphaMap=null,this.flatShading=!1,this.setValues(t)}copy(t){return super.copy(t),this.defines={MATCAP:""},this.color.copy(t.color),this.matcap=t.matcap,this.map=t.map,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.alphaMap=t.alphaMap,this.flatShading=t.flatShading,this}}.prototype.isMeshMatcapMaterial=!0,class extends Wd{constructor(t){super(),this.type="LineDashedMaterial",this.scale=1,this.dashSize=3,this.gapSize=1,this.setValues(t)}copy(t){return super.copy(t),this.scale=t.scale,this.dashSize=t.dashSize,this.gapSize=t.gapSize,this}}.prototype.isLineDashedMaterial=!0;var Rr={arraySlice:function(n,t,e){return Rr.isTypedArray(n)?new n.constructor(n.subarray(t,void 0!==e?e:n.length)):n.slice(t,e)},convertArray:function(n,t,e){return!n||!e&&n.constructor===t?n:"number"==typeof t.BYTES_PER_ELEMENT?new t(n):Array.prototype.slice.call(n)},isTypedArray:function(n){return ArrayBuffer.isView(n)&&!(n instanceof DataView)},getKeyframeOrder:function(n){let e=n.length,i=new Array(e);for(let r=0;r!==e;++r)i[r]=r;return i.sort(function(r,o){return n[r]-n[o]}),i},sortedArray:function(n,t,e){let i=n.length,r=new n.constructor(i);for(let o=0,s=0;s!==i;++o){let a=e[o]*t;for(let l=0;l!==t;++l)r[s++]=n[a+l]}return r},flattenJSON:function(n,t,e,i){let r=1,o=n[0];for(;void 0!==o&&void 0===o[i];)o=n[r++];if(void 0===o)return;let s=o[i];if(void 0!==s)if(Array.isArray(s))do{s=o[i],void 0!==s&&(t.push(o.time),e.push.apply(e,s)),o=n[r++]}while(void 0!==o);else if(void 0!==s.toArray)do{s=o[i],void 0!==s&&(t.push(o.time),s.toArray(e,e.length)),o=n[r++]}while(void 0!==o);else do{s=o[i],void 0!==s&&(t.push(o.time),e.push(s)),o=n[r++]}while(void 0!==o)},subclip:function(n,t,e,i,r=30){let o=n.clone();o.name=t;let s=[];for(let l=0;l<o.tracks.length;++l){let c=o.tracks[l],d=c.getValueSize(),u=[],p=[];for(let f=0;f<c.times.length;++f){let m=c.times[f]*r;if(!(m<e||m>=i)){u.push(c.times[f]);for(let b=0;b<d;++b)p.push(c.values[f*d+b])}}0!==u.length&&(c.times=Rr.convertArray(u,c.times.constructor),c.values=Rr.convertArray(p,c.values.constructor),s.push(c))}o.tracks=s;let a=1/0;for(let l=0;l<o.tracks.length;++l)a>o.tracks[l].times[0]&&(a=o.tracks[l].times[0]);for(let l=0;l<o.tracks.length;++l)o.tracks[l].shift(-1*a);return o.resetDuration(),o},makeClipAdditive:function(n,t=0,e=n,i=30){i<=0&&(i=30);let r=e.tracks.length,o=t/i;for(let s=0;s<r;++s){let a=e.tracks[s],l=a.ValueTypeName;if("bool"===l||"string"===l)continue;let c=n.tracks.find(function(y){return y.name===a.name&&y.ValueTypeName===l});if(void 0===c)continue;let d=0,u=a.getValueSize();a.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline&&(d=u/3);let p=0,f=c.getValueSize();c.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline&&(p=f/3);let b,m=a.times.length-1;if(o<=a.times[0])b=Rr.arraySlice(a.values,d,u-d);else if(o>=a.times[m]){let y=m*u+d;b=Rr.arraySlice(a.values,y,y+u-d)}else{let y=a.createInterpolant(),x=d,R=u-d;y.evaluate(o),b=Rr.arraySlice(y.resultBuffer,x,R)}"quaternion"===l&&(new ts).fromArray(b).normalize().conjugate().toArray(b);let M=c.times.length;for(let y=0;y<M;++y){let x=y*f+p;if("quaternion"===l)ts.multiplyQuaternionsFlat(c.values,x,b,0,c.values,x);else{let R=f-2*p;for(let A=0;A<R;++A)c.values[x+A]-=b[A]}}}return n.blendMode=2501,n}},Xc=class{constructor(t,e,i,r){this.parameterPositions=t,this._cachedIndex=0,this.resultBuffer=void 0!==r?r:new e.constructor(i),this.sampleValues=e,this.valueSize=i,this.settings=null,this.DefaultSettings_={}}evaluate(t){let e=this.parameterPositions,i=this._cachedIndex,r=e[i],o=e[i-1];e:{t:{let s;n:{i:if(!(t<r)){for(let a=i+2;;){if(void 0===r){if(t<o)break i;return i=e.length,this._cachedIndex=i,this.afterEnd_(i-1,t,o)}if(i===a)break;if(o=r,r=e[++i],t<r)break t}s=e.length;break n}if(t>=o)break e;{let a=e[1];t<a&&(i=2,o=a);for(let l=i-2;;){if(void 0===o)return this._cachedIndex=0,this.beforeStart_(0,t,r);if(i===l)break;if(r=o,o=e[--i-1],t>=o)break t}s=i,i=0}}for(;i<s;){let a=i+s>>>1;t<e[a]?s=a:i=a+1}if(r=e[i],o=e[i-1],void 0===o)return this._cachedIndex=0,this.beforeStart_(0,t,r);if(void 0===r)return i=e.length,this._cachedIndex=i,this.afterEnd_(i-1,o,t)}this._cachedIndex=i,this.intervalChanged_(i,o,r)}return this.interpolate_(i,o,t,r)}getSettings_(){return this.settings||this.DefaultSettings_}copySampleValue_(t){let e=this.resultBuffer,i=this.sampleValues,r=this.valueSize,o=t*r;for(let s=0;s!==r;++s)e[s]=i[o+s];return e}interpolate_(){throw new Error("call to abstract method")}intervalChanged_(){}};Xc.prototype.beforeStart_=Xc.prototype.copySampleValue_,Xc.prototype.afterEnd_=Xc.prototype.copySampleValue_;var OB=class extends Xc{constructor(t,e,i,r){super(t,e,i,r),this._weightPrev=-0,this._offsetPrev=-0,this._weightNext=-0,this._offsetNext=-0,this.DefaultSettings_={endingStart:V0,endingEnd:V0}}intervalChanged_(t,e,i){let r=this.parameterPositions,o=t-2,s=t+1,a=r[o],l=r[s];if(void 0===a)switch(this.getSettings_().endingStart){case H0:o=t,a=2*e-i;break;case 2402:o=r.length-2,a=e+r[o]-r[o+1];break;default:o=t,a=i}if(void 0===l)switch(this.getSettings_().endingEnd){case H0:s=t,l=2*i-e;break;case 2402:s=1,l=i+r[1]-r[0];break;default:s=t-1,l=e}let c=.5*(i-e),d=this.valueSize;this._weightPrev=c/(e-a),this._weightNext=c/(l-i),this._offsetPrev=o*d,this._offsetNext=s*d}interpolate_(t,e,i,r){let o=this.resultBuffer,s=this.sampleValues,a=this.valueSize,l=t*a,c=l-a,d=this._offsetPrev,u=this._offsetNext,p=this._weightPrev,f=this._weightNext,m=(i-e)/(r-e),b=m*m,M=b*m,y=-p*M+2*p*b-p*m,x=(1+p)*M+(-1.5-2*p)*b+(-.5+p)*m+1,R=(-1-f)*M+(1.5+f)*b+.5*m,A=f*M-f*b;for(let V=0;V!==a;++V)o[V]=y*s[d+V]+x*s[c+V]+R*s[l+V]+A*s[u+V];return o}},VI=class extends Xc{constructor(t,e,i,r){super(t,e,i,r)}interpolate_(t,e,i,r){let o=this.resultBuffer,s=this.sampleValues,a=this.valueSize,l=t*a,c=l-a,d=(i-e)/(r-e),u=1-d;for(let p=0;p!==a;++p)o[p]=s[c+p]*u+s[l+p]*d;return o}},kB=class extends Xc{constructor(t,e,i,r){super(t,e,i,r)}interpolate_(t){return this.copySampleValue_(t-1)}},sl=class{constructor(t,e,i,r){if(void 0===t)throw new Error("THREE.KeyframeTrack: track name is undefined");if(void 0===e||0===e.length)throw new Error("THREE.KeyframeTrack: no keyframes in track named "+t);this.name=t,this.times=Rr.convertArray(e,this.TimeBufferType),this.values=Rr.convertArray(i,this.ValueBufferType),this.setInterpolation(r||this.DefaultInterpolation)}static toJSON(t){let i,e=t.constructor;if(e.toJSON!==this.toJSON)i=e.toJSON(t);else{i={name:t.name,times:Rr.convertArray(t.times,Array),values:Rr.convertArray(t.values,Array)};let r=t.getInterpolation();r!==t.DefaultInterpolation&&(i.interpolation=r)}return i.type=t.ValueTypeName,i}InterpolantFactoryMethodDiscrete(t){return new kB(this.times,this.values,this.getValueSize(),t)}InterpolantFactoryMethodLinear(t){return new VI(this.times,this.values,this.getValueSize(),t)}InterpolantFactoryMethodSmooth(t){return new OB(this.times,this.values,this.getValueSize(),t)}setInterpolation(t){let e;switch(t){case 2300:e=this.InterpolantFactoryMethodDiscrete;break;case 2301:e=this.InterpolantFactoryMethodLinear;break;case 2302:e=this.InterpolantFactoryMethodSmooth}if(void 0===e){let i="unsupported interpolation for "+this.ValueTypeName+" keyframe track named "+this.name;if(void 0===this.createInterpolant){if(t===this.DefaultInterpolation)throw new Error(i);this.setInterpolation(this.DefaultInterpolation)}return console.warn("THREE.KeyframeTrack:",i),this}return this.createInterpolant=e,this}getInterpolation(){switch(this.createInterpolant){case this.InterpolantFactoryMethodDiscrete:return 2300;case this.InterpolantFactoryMethodLinear:return 2301;case this.InterpolantFactoryMethodSmooth:return 2302}}getValueSize(){return this.values.length/this.times.length}shift(t){if(0!==t){let e=this.times;for(let i=0,r=e.length;i!==r;++i)e[i]+=t}return this}scale(t){if(1!==t){let e=this.times;for(let i=0,r=e.length;i!==r;++i)e[i]*=t}return this}trim(t,e){let i=this.times,r=i.length,o=0,s=r-1;for(;o!==r&&i[o]<t;)++o;for(;-1!==s&&i[s]>e;)--s;if(++s,0!==o||s!==r){o>=s&&(s=Math.max(s,1),o=s-1);let a=this.getValueSize();this.times=Rr.arraySlice(i,o,s),this.values=Rr.arraySlice(this.values,o*a,s*a)}return this}validate(){let t=!0,e=this.getValueSize();e-Math.floor(e)!=0&&(console.error("THREE.KeyframeTrack: Invalid value size in track.",this),t=!1);let i=this.times,r=this.values,o=i.length;0===o&&(console.error("THREE.KeyframeTrack: Track is empty.",this),t=!1);let s=null;for(let a=0;a!==o;a++){let l=i[a];if("number"==typeof l&&isNaN(l)){console.error("THREE.KeyframeTrack: Time is not a valid number.",this,a,l),t=!1;break}if(null!==s&&s>l){console.error("THREE.KeyframeTrack: Out of order keys.",this,a,l,s),t=!1;break}s=l}if(void 0!==r&&Rr.isTypedArray(r))for(let a=0,l=r.length;a!==l;++a){let c=r[a];if(isNaN(c)){console.error("THREE.KeyframeTrack: Value is not a valid number.",this,a,c),t=!1;break}}return t}optimize(){let t=Rr.arraySlice(this.times),e=Rr.arraySlice(this.values),i=this.getValueSize(),r=2302===this.getInterpolation(),o=t.length-1,s=1;for(let a=1;a<o;++a){let l=!1,c=t[a];if(c!==t[a+1]&&(1!==a||c!==t[0]))if(r)l=!0;else{let u=a*i,p=u-i,f=u+i;for(let m=0;m!==i;++m){let b=e[u+m];if(b!==e[p+m]||b!==e[f+m]){l=!0;break}}}if(l){if(a!==s){t[s]=t[a];let u=a*i,p=s*i;for(let f=0;f!==i;++f)e[p+f]=e[u+f]}++s}}if(o>0){t[s]=t[o];for(let a=o*i,l=s*i,c=0;c!==i;++c)e[l+c]=e[a+c];++s}return s!==t.length?(this.times=Rr.arraySlice(t,0,s),this.values=Rr.arraySlice(e,0,s*i)):(this.times=t,this.values=e),this}clone(){let t=Rr.arraySlice(this.times,0),e=Rr.arraySlice(this.values,0),r=new(0,this.constructor)(this.name,t,e);return r.createInterpolant=this.createInterpolant,r}};sl.prototype.TimeBufferType=Float32Array,sl.prototype.ValueBufferType=Float32Array,sl.prototype.DefaultInterpolation=2301;var Mp=class extends sl{};Mp.prototype.ValueTypeName="bool",Mp.prototype.ValueBufferType=Array,Mp.prototype.DefaultInterpolation=2300,Mp.prototype.InterpolantFactoryMethodLinear=void 0,Mp.prototype.InterpolantFactoryMethodSmooth=void 0;var HI=class extends sl{};HI.prototype.ValueTypeName="color";var n_=class extends sl{};n_.prototype.ValueTypeName="number";var FB=class extends Xc{constructor(t,e,i,r){super(t,e,i,r)}interpolate_(t,e,i,r){let o=this.resultBuffer,s=this.sampleValues,a=this.valueSize,l=(i-e)/(r-e),c=t*a;for(let d=c+a;c!==d;c+=4)ts.slerpFlat(o,0,s,c-a,s,c,l);return o}},bm=class extends sl{InterpolantFactoryMethodLinear(t){return new FB(this.times,this.values,this.getValueSize(),t)}};bm.prototype.ValueTypeName="quaternion",bm.prototype.DefaultInterpolation=2301,bm.prototype.InterpolantFactoryMethodSmooth=void 0;var wp=class extends sl{};wp.prototype.ValueTypeName="string",wp.prototype.ValueBufferType=Array,wp.prototype.DefaultInterpolation=2300,wp.prototype.InterpolantFactoryMethodLinear=void 0,wp.prototype.InterpolantFactoryMethodSmooth=void 0;var i_=class extends sl{};i_.prototype.ValueTypeName="vector";var zI=class{constructor(t,e=-1,i,r=2500){this.name=t,this.tracks=i,this.duration=e,this.blendMode=r,this.uuid=Jl(),this.duration<0&&this.resetDuration()}static parse(t){let e=[],i=t.tracks,r=1/(t.fps||1);for(let s=0,a=i.length;s!==a;++s)e.push(I2e(i[s]).scale(r));let o=new this(t.name,t.duration,e,t.blendMode);return o.uuid=t.uuid,o}static toJSON(t){let e=[],i=t.tracks,r={name:t.name,duration:t.duration,tracks:e,uuid:t.uuid,blendMode:t.blendMode};for(let o=0,s=i.length;o!==s;++o)e.push(sl.toJSON(i[o]));return r}static CreateFromMorphTargetSequence(t,e,i,r){let o=e.length,s=[];for(let a=0;a<o;a++){let l=[],c=[];l.push((a+o-1)%o,a,(a+1)%o),c.push(0,1,0);let d=Rr.getKeyframeOrder(l);l=Rr.sortedArray(l,1,d),c=Rr.sortedArray(c,1,d),!r&&0===l[0]&&(l.push(o),c.push(c[0])),s.push(new n_(".morphTargetInfluences["+e[a].name+"]",l,c).scale(1/i))}return new this(t,-1,s)}static findByName(t,e){let i=t;Array.isArray(t)||(i=t.geometry&&t.geometry.animations||t.animations);for(let r=0;r<i.length;r++)if(i[r].name===e)return i[r];return null}static CreateClipsFromMorphTargetSequences(t,e,i){let r={},o=/^([\w-]*?)([\d]+)$/;for(let a=0,l=t.length;a<l;a++){let c=t[a],d=c.name.match(o);if(d&&d.length>1){let u=d[1],p=r[u];p||(r[u]=p=[]),p.push(c)}}let s=[];for(let a in r)s.push(this.CreateFromMorphTargetSequence(a,r[a],e,i));return s}static parseAnimation(t,e){if(!t)return console.error("THREE.AnimationClip: No animation in JSONLoader data."),null;let i=function(u,p,f,m,b){if(0!==f.length){let M=[],y=[];Rr.flattenJSON(f,M,y,m),0!==M.length&&b.push(new u(p,M,y))}},r=[],o=t.name||"default",s=t.fps||30,a=t.blendMode,l=t.length||-1,c=t.hierarchy||[];for(let u=0;u<c.length;u++){let p=c[u].keys;if(p&&0!==p.length)if(p[0].morphTargets){let m,f={};for(m=0;m<p.length;m++)if(p[m].morphTargets)for(let b=0;b<p[m].morphTargets.length;b++)f[p[m].morphTargets[b]]=-1;for(let b in f){let M=[],y=[];for(let x=0;x!==p[m].morphTargets.length;++x){let R=p[m];M.push(R.time),y.push(R.morphTarget===b?1:0)}r.push(new n_(".morphTargetInfluence["+b+"]",M,y))}l=f.length*(s||1)}else{let f=".bones["+e[u].name+"]";i(i_,f+".position",p,"pos",r),i(bm,f+".quaternion",p,"rot",r),i(i_,f+".scale",p,"scl",r)}}return 0===r.length?null:new this(o,l,r,a)}resetDuration(){let e=0;for(let i=0,r=this.tracks.length;i!==r;++i){let o=this.tracks[i];e=Math.max(e,o.times[o.times.length-1])}return this.duration=e,this}trim(){for(let t=0;t<this.tracks.length;t++)this.tracks[t].trim(0,this.duration);return this}validate(){let t=!0;for(let e=0;e<this.tracks.length;e++)t=t&&this.tracks[e].validate();return t}optimize(){for(let t=0;t<this.tracks.length;t++)this.tracks[t].optimize();return this}clone(){let t=[];for(let e=0;e<this.tracks.length;e++)t.push(this.tracks[e].clone());return new this.constructor(this.name,this.duration,t,this.blendMode)}toJSON(){return this.constructor.toJSON(this)}};function I2e(n){if(void 0===n.type)throw new Error("THREE.KeyframeTrack: track type undefined, can not parse");let t=function(n){switch(n.toLowerCase()){case"scalar":case"double":case"float":case"number":case"integer":return n_;case"vector":case"vector2":case"vector3":case"vector4":return i_;case"color":return HI;case"quaternion":return bm;case"bool":case"boolean":return Mp;case"string":return wp}throw new Error("THREE.KeyframeTrack: Unsupported typeName: "+n)}(n.type);if(void 0===n.times){let e=[],i=[];Rr.flattenJSON(n.keys,e,i,"value"),n.times=e,n.values=i}return void 0!==t.parse?t.parse(n):new t(n.name,n.times,n.values,n.interpolation)}var r_={enabled:!1,files:{},add:function(n,t){!1!==this.enabled&&(this.files[n]=t)},get:function(n){if(!1!==this.enabled)return this.files[n]},remove:function(n){delete this.files[n]},clear:function(){this.files={}}},A2e=new class{constructor(t,e,i){let l,r=this,o=!1,s=0,a=0,c=[];this.onStart=void 0,this.onLoad=t,this.onProgress=e,this.onError=i,this.itemStart=function(d){a++,!1===o&&void 0!==r.onStart&&r.onStart(d,s,a),o=!0},this.itemEnd=function(d){s++,void 0!==r.onProgress&&r.onProgress(d,s,a),s===a&&(o=!1,void 0!==r.onLoad&&r.onLoad())},this.itemError=function(d){void 0!==r.onError&&r.onError(d)},this.resolveURL=function(d){return l?l(d):d},this.setURLModifier=function(d){return l=d,this},this.addHandler=function(d,u){return c.push(d,u),this},this.removeHandler=function(d){let u=c.indexOf(d);return-1!==u&&c.splice(u,2),this},this.getHandler=function(d){for(let u=0,p=c.length;u<p;u+=2){let f=c[u],m=c[u+1];if(f.global&&(f.lastIndex=0),f.test(d))return m}return null}}},Qc=class{constructor(t){this.manager=void 0!==t?t:A2e,this.crossOrigin="anonymous",this.withCredentials=!1,this.path="",this.resourcePath="",this.requestHeader={}}load(){}loadAsync(t,e){let i=this;return new Promise(function(r,o){i.load(t,r,e,o)})}parse(){}setCrossOrigin(t){return this.crossOrigin=t,this}setWithCredentials(t){return this.withCredentials=t,this}setPath(t){return this.path=t,this}setResourcePath(t){return this.resourcePath=t,this}setRequestHeader(t){return this.requestHeader=t,this}},zd={},LB=class extends Qc{constructor(t){super(t)}load(t,e,i,r){void 0===t&&(t=""),void 0!==this.path&&(t=this.path+t),t=this.manager.resolveURL(t);let o=r_.get(t);if(void 0!==o)return this.manager.itemStart(t),setTimeout(()=>{e&&e(o),this.manager.itemEnd(t)},0),o;if(void 0!==zd[t])return void zd[t].push({onLoad:e,onProgress:i,onError:r});zd[t]=[],zd[t].push({onLoad:e,onProgress:i,onError:r});let s=new Request(t,{headers:new Headers(this.requestHeader),credentials:this.withCredentials?"include":"same-origin"}),a=this.mimeType,l=this.responseType;fetch(s).then(c=>{if(200===c.status||0===c.status){if(0===c.status&&console.warn("THREE.FileLoader: HTTP Status 0 received."),typeof ReadableStream>"u"||void 0===c.body.getReader)return c;let d=zd[t],u=c.body.getReader(),p=c.headers.get("Content-Length"),f=p?parseInt(p):0,m=0!==f,b=0,M=new ReadableStream({start(y){!function x(){u.read().then(({done:R,value:A})=>{if(R)y.close();else{b+=A.byteLength;let V=new ProgressEvent("progress",{lengthComputable:m,loaded:b,total:f});for(let te=0,K=d.length;te<K;te++){let xe=d[te];xe.onProgress&&xe.onProgress(V)}y.enqueue(A),x()}})}()}});return new Response(M)}throw Error(`fetch for "${c.url}" responded with ${c.status}: ${c.statusText}`)}).then(c=>{switch(l){case"arraybuffer":return c.arrayBuffer();case"blob":return c.blob();case"document":return c.text().then(d=>(new DOMParser).parseFromString(d,a));case"json":return c.json();default:if(void 0===a)return c.text();{let u=/charset="?([^;"\s]*)"?/i.exec(a),p=u&&u[1]?u[1].toLowerCase():void 0,f=new TextDecoder(p);return c.arrayBuffer().then(m=>f.decode(m))}}}).then(c=>{r_.add(t,c);let d=zd[t];delete zd[t];for(let u=0,p=d.length;u<p;u++){let f=d[u];f.onLoad&&f.onLoad(c)}}).catch(c=>{let d=zd[t];if(void 0===d)throw this.manager.itemError(t),c;delete zd[t];for(let u=0,p=d.length;u<p;u++){let f=d[u];f.onError&&f.onError(c)}this.manager.itemError(t)}).finally(()=>{this.manager.itemEnd(t)}),this.manager.itemStart(t)}setResponseType(t){return this.responseType=t,this}setMimeType(t){return this.mimeType=t,this}},UI=class extends Qc{constructor(t){super(t)}load(t,e,i,r){void 0!==this.path&&(t=this.path+t),t=this.manager.resolveURL(t);let o=this,s=r_.get(t);if(void 0!==s)return o.manager.itemStart(t),setTimeout(function(){e&&e(s),o.manager.itemEnd(t)},0),s;let a=Mx("img");function l(){d(),r_.add(t,this),e&&e(this),o.manager.itemEnd(t)}function c(u){d(),r&&r(u),o.manager.itemError(t),o.manager.itemEnd(t)}function d(){a.removeEventListener("load",l,!1),a.removeEventListener("error",c,!1)}return a.addEventListener("load",l,!1),a.addEventListener("error",c,!1),"data:"!==t.substr(0,5)&&void 0!==this.crossOrigin&&(a.crossOrigin=this.crossOrigin),o.manager.itemStart(t),a.src=t,a}},BB=class extends Qc{constructor(t){super(t)}load(t,e,i,r){let o=new Q0,s=new UI(this.manager);s.setCrossOrigin(this.crossOrigin),s.setPath(this.path);let a=0;function l(c){s.load(t[c],function(d){o.images[c]=d,a++,6===a&&(o.needsUpdate=!0,e&&e(o))},void 0,r)}for(let c=0;c<t.length;++c)l(c);return o}},VB=class extends Qc{constructor(t){super(t)}load(t,e,i,r){let o=new lo,s=new UI(this.manager);return s.setCrossOrigin(this.crossOrigin),s.setPath(this.path),s.load(t,function(a){o.image=a,o.needsUpdate=!0,void 0!==e&&e(o)},i,r),o}},al=class extends Bi{constructor(t,e=1){super(),this.type="Light",this.color=new an(t),this.intensity=e}dispose(){}copy(t){return super.copy(t),this.color.copy(t.color),this.intensity=t.intensity,this}toJSON(t){let e=super.toJSON(t);return e.object.color=this.color.getHex(),e.object.intensity=this.intensity,void 0!==this.groundColor&&(e.object.groundColor=this.groundColor.getHex()),void 0!==this.distance&&(e.object.distance=this.distance),void 0!==this.angle&&(e.object.angle=this.angle),void 0!==this.decay&&(e.object.decay=this.decay),void 0!==this.penumbra&&(e.object.penumbra=this.penumbra),void 0!==this.shadow&&(e.object.shadow=this.shadow.toJSON()),e}};al.prototype.isLight=!0,class extends al{constructor(t,e,i){super(t,i),this.type="HemisphereLight",this.position.copy(Bi.DefaultUp),this.updateMatrix(),this.groundColor=new an(e)}copy(t){return al.prototype.copy.call(this,t),this.groundColor.copy(t.groundColor),this}}.prototype.isHemisphereLight=!0;var Lee=new xn,Bee=new $,Vee=new $,Ux=class{constructor(t){this.camera=t,this.bias=0,this.normalBias=0,this.radius=1,this.blurSamples=8,this.mapSize=new $e(512,512),this.map=null,this.mapPass=null,this.matrix=new xn,this.autoUpdate=!0,this.needsUpdate=!1,this._frustum=new Z0,this._frameExtents=new $e(1,1),this._viewportCount=1,this._viewports=[new Zi(0,0,1,1)]}getViewportCount(){return this._viewportCount}getFrustum(){return this._frustum}updateMatrices(t){let e=this.camera,i=this.matrix;Bee.setFromMatrixPosition(t.matrixWorld),e.position.copy(Bee),Vee.setFromMatrixPosition(t.target.matrixWorld),e.lookAt(Vee),e.updateMatrixWorld(),Lee.multiplyMatrices(e.projectionMatrix,e.matrixWorldInverse),this._frustum.setFromProjectionMatrix(Lee),i.set(.5,0,0,.5,0,.5,0,.5,0,0,.5,.5,0,0,0,1),i.multiply(e.projectionMatrix),i.multiply(e.matrixWorldInverse)}getViewport(t){return this._viewports[t]}getFrameExtents(){return this._frameExtents}dispose(){this.map&&this.map.dispose(),this.mapPass&&this.mapPass.dispose()}copy(t){return this.camera=t.camera.clone(),this.bias=t.bias,this.radius=t.radius,this.mapSize.copy(t.mapSize),this}clone(){return(new this.constructor).copy(this)}toJSON(){let t={};return 0!==this.bias&&(t.bias=this.bias),0!==this.normalBias&&(t.normalBias=this.normalBias),1!==this.radius&&(t.radius=this.radius),(512!==this.mapSize.x||512!==this.mapSize.y)&&(t.mapSize=this.mapSize.toArray()),t.camera=this.camera.toJSON(!1).object,delete t.camera.matrix,t}},jI=class extends Ux{constructor(){super(new es(50,1,.5,500)),this.focus=1}updateMatrices(t){let e=this.camera,i=2*nB*t.angle*this.focus,r=this.mapSize.width/this.mapSize.height,o=t.distance||e.far;(i!==e.fov||r!==e.aspect||o!==e.far)&&(e.fov=i,e.aspect=r,e.far=o,e.updateProjectionMatrix()),super.updateMatrices(t)}copy(t){return super.copy(t),this.focus=t.focus,this}};jI.prototype.isSpotLightShadow=!0,class extends al{constructor(t,e,i=0,r=Math.PI/3,o=0,s=1){super(t,e),this.type="SpotLight",this.position.copy(Bi.DefaultUp),this.updateMatrix(),this.target=new Bi,this.distance=i,this.angle=r,this.penumbra=o,this.decay=s,this.shadow=new jI}get power(){return this.intensity*Math.PI}set power(t){this.intensity=t/Math.PI}dispose(){this.shadow.dispose()}copy(t){return super.copy(t),this.distance=t.distance,this.angle=t.angle,this.penumbra=t.penumbra,this.decay=t.decay,this.target=t.target.clone(),this.shadow=t.shadow.clone(),this}}.prototype.isSpotLight=!0;var Hee=new xn,fx=new $,X3=new $,GI=class extends Ux{constructor(){super(new es(90,1,.5,500)),this._frameExtents=new $e(4,2),this._viewportCount=6,this._viewports=[new Zi(2,1,1,1),new Zi(0,1,1,1),new Zi(3,1,1,1),new Zi(1,1,1,1),new Zi(3,0,1,1),new Zi(1,0,1,1)],this._cubeDirections=[new $(1,0,0),new $(-1,0,0),new $(0,0,1),new $(0,0,-1),new $(0,1,0),new $(0,-1,0)],this._cubeUps=[new $(0,1,0),new $(0,1,0),new $(0,1,0),new $(0,1,0),new $(0,0,1),new $(0,0,-1)]}updateMatrices(t,e=0){let i=this.camera,r=this.matrix,o=t.distance||i.far;o!==i.far&&(i.far=o,i.updateProjectionMatrix()),fx.setFromMatrixPosition(t.matrixWorld),i.position.copy(fx),X3.copy(i.position),X3.add(this._cubeDirections[e]),i.up.copy(this._cubeUps[e]),i.lookAt(X3),i.updateMatrixWorld(),r.makeTranslation(-fx.x,-fx.y,-fx.z),Hee.multiplyMatrices(i.projectionMatrix,i.matrixWorldInverse),this._frustum.setFromProjectionMatrix(Hee)}};GI.prototype.isPointLightShadow=!0,class extends al{constructor(t,e,i=0,r=1){super(t,e),this.type="PointLight",this.distance=i,this.decay=r,this.shadow=new GI}get power(){return 4*this.intensity*Math.PI}set power(t){this.intensity=t/(4*Math.PI)}dispose(){this.shadow.dispose()}copy(t){return super.copy(t),this.distance=t.distance,this.decay=t.decay,this.shadow=t.shadow.clone(),this}}.prototype.isPointLight=!0;var WI=class extends Ux{constructor(){super(new mm(-5,5,5,-5,.5,500))}};WI.prototype.isDirectionalLightShadow=!0,class extends al{constructor(t,e){super(t,e),this.type="DirectionalLight",this.position.copy(Bi.DefaultUp),this.updateMatrix(),this.target=new Bi,this.shadow=new WI}dispose(){this.shadow.dispose()}copy(t){return super.copy(t),this.target=t.target.clone(),this.shadow=t.shadow.clone(),this}}.prototype.isDirectionalLight=!0,class extends al{constructor(t,e){super(t,e),this.type="AmbientLight"}}.prototype.isAmbientLight=!0,class extends al{constructor(t,e,i=10,r=10){super(t,e),this.type="RectAreaLight",this.width=i,this.height=r}get power(){return this.intensity*this.width*this.height*Math.PI}set power(t){this.intensity=t/(this.width*this.height*Math.PI)}copy(t){return super.copy(t),this.width=t.width,this.height=t.height,this}toJSON(t){let e=super.toJSON(t);return e.object.width=this.width,e.object.height=this.height,e}}.prototype.isRectAreaLight=!0;var qI=class{constructor(){this.coefficients=[];for(let t=0;t<9;t++)this.coefficients.push(new $)}set(t){for(let e=0;e<9;e++)this.coefficients[e].copy(t[e]);return this}zero(){for(let t=0;t<9;t++)this.coefficients[t].set(0,0,0);return this}getAt(t,e){let i=t.x,r=t.y,o=t.z,s=this.coefficients;return e.copy(s[0]).multiplyScalar(.282095),e.addScaledVector(s[1],.488603*r),e.addScaledVector(s[2],.488603*o),e.addScaledVector(s[3],.488603*i),e.addScaledVector(s[4],i*r*1.092548),e.addScaledVector(s[5],r*o*1.092548),e.addScaledVector(s[6],.315392*(3*o*o-1)),e.addScaledVector(s[7],i*o*1.092548),e.addScaledVector(s[8],.546274*(i*i-r*r)),e}getIrradianceAt(t,e){let i=t.x,r=t.y,o=t.z,s=this.coefficients;return e.copy(s[0]).multiplyScalar(.886227),e.addScaledVector(s[1],1.023328*r),e.addScaledVector(s[2],1.023328*o),e.addScaledVector(s[3],1.023328*i),e.addScaledVector(s[4],.858086*i*r),e.addScaledVector(s[5],.858086*r*o),e.addScaledVector(s[6],.743125*o*o-.247708),e.addScaledVector(s[7],.858086*i*o),e.addScaledVector(s[8],.429043*(i*i-r*r)),e}add(t){for(let e=0;e<9;e++)this.coefficients[e].add(t.coefficients[e]);return this}addScaledSH(t,e){for(let i=0;i<9;i++)this.coefficients[i].addScaledVector(t.coefficients[i],e);return this}scale(t){for(let e=0;e<9;e++)this.coefficients[e].multiplyScalar(t);return this}lerp(t,e){for(let i=0;i<9;i++)this.coefficients[i].lerp(t.coefficients[i],e);return this}equals(t){for(let e=0;e<9;e++)if(!this.coefficients[e].equals(t.coefficients[e]))return!1;return!0}copy(t){return this.set(t.coefficients)}clone(){return(new this.constructor).copy(this)}fromArray(t,e=0){let i=this.coefficients;for(let r=0;r<9;r++)i[r].fromArray(t,e+3*r);return this}toArray(t=[],e=0){let i=this.coefficients;for(let r=0;r<9;r++)i[r].toArray(t,e+3*r);return t}static getBasisAt(t,e){let i=t.x,r=t.y,o=t.z;e[0]=.282095,e[1]=.488603*r,e[2]=.488603*o,e[3]=.488603*i,e[4]=1.092548*i*r,e[5]=1.092548*r*o,e[6]=.315392*(3*o*o-1),e[7]=1.092548*i*o,e[8]=.546274*(i*i-r*r)}};qI.prototype.isSphericalHarmonics3=!0;var jx=class extends al{constructor(t=new qI,e=1){super(void 0,e),this.sh=t}copy(t){return super.copy(t),this.sh.copy(t.sh),this}fromJSON(t){return this.intensity=t.intensity,this.sh.fromArray(t.sh),this}toJSON(t){let e=super.toJSON(t);return e.object.sh=this.sh.toArray(),e}};jx.prototype.isLightProbe=!0;var qB=class{static decodeText(t){if(typeof TextDecoder<"u")return(new TextDecoder).decode(t);let e="";for(let i=0,r=t.length;i<r;i++)e+=String.fromCharCode(t[i]);try{return decodeURIComponent(escape(e))}catch{return e}}static extractUrlBase(t){let e=t.lastIndexOf("/");return-1===e?"./":t.substr(0,e+1)}static resolveURL(t,e){return"string"!=typeof t||""===t?"":(/^https?:\/\//i.test(e)&&/^\//.test(t)&&(e=e.replace(/(^https?:\/\/[^\/]+).*/i,"$1")),/^(https?:)?\/\//i.test(t)||/^data:.*,.*$/i.test(t)||/^blob:.*$/i.test(t)?t:e+t)}};(class extends Ui{constructor(){super(),this.type="InstancedBufferGeometry",this.instanceCount=1/0}copy(t){return super.copy(t),this.instanceCount=t.instanceCount,this}clone(){return(new this.constructor).copy(this)}toJSON(){let t=super.toJSON(this);return t.instanceCount=this.instanceCount,t.isInstancedBufferGeometry=!0,t}}).prototype.isInstancedBufferGeometry=!0,class extends Qc{constructor(t){super(t),typeof createImageBitmap>"u"&&console.warn("THREE.ImageBitmapLoader: createImageBitmap() not supported."),typeof fetch>"u"&&console.warn("THREE.ImageBitmapLoader: fetch() not supported."),this.options={premultiplyAlpha:"none"}}setOptions(t){return this.options=t,this}load(t,e,i,r){void 0===t&&(t=""),void 0!==this.path&&(t=this.path+t),t=this.manager.resolveURL(t);let o=this,s=r_.get(t);if(void 0!==s)return o.manager.itemStart(t),setTimeout(function(){e&&e(s),o.manager.itemEnd(t)},0),s;let a={};a.credentials="anonymous"===this.crossOrigin?"same-origin":"include",a.headers=this.requestHeader,fetch(t,a).then(function(l){return l.blob()}).then(function(l){return createImageBitmap(l,Object.assign(o.options,{colorSpaceConversion:"none"}))}).then(function(l){r_.add(t,l),e&&e(l),o.manager.itemEnd(t)}).catch(function(l){r&&r(l),o.manager.itemError(t),o.manager.itemEnd(t)}),o.manager.itemStart(t)}}.prototype.isImageBitmapLoader=!0;var mI,QB=class extends Qc{constructor(t){super(t)}load(t,e,i,r){let o=this,s=new LB(this.manager);s.setResponseType("arraybuffer"),s.setPath(this.path),s.setRequestHeader(this.requestHeader),s.setWithCredentials(this.withCredentials),s.load(t,function(a){try{let l=a.slice(0);(void 0===mI&&(mI=new(window.AudioContext||window.webkitAudioContext)),mI).decodeAudioData(l,function(d){e(d)})}catch(l){r?r(l):console.error(l),o.manager.itemError(t)}},i,r)}};(class extends jx{constructor(t,e,i=1){super(void 0,i);let r=(new an).set(t),o=(new an).set(e),s=new $(r.r,r.g,r.b),a=new $(o.r,o.g,o.b),l=Math.sqrt(Math.PI),c=l*Math.sqrt(.75);this.sh.coefficients[0].copy(s).add(a).multiplyScalar(l),this.sh.coefficients[1].copy(s).sub(a).multiplyScalar(c)}}).prototype.isHemisphereLightProbe=!0,class extends jx{constructor(t,e=1){super(void 0,e);let i=(new an).set(t);this.sh.coefficients[0].set(i.r,i.g,i.b).multiplyScalar(2*Math.sqrt(Math.PI))}}.prototype.isAmbientLightProbe=!0;var eV=class{constructor(t,e,i){let r,o,s;switch(this.binding=t,this.valueSize=i,e){case"quaternion":r=this._slerp,o=this._slerpAdditive,s=this._setAdditiveIdentityQuaternion,this.buffer=new Float64Array(6*i),this._workIndex=5;break;case"string":case"bool":r=this._select,o=this._select,s=this._setAdditiveIdentityOther,this.buffer=new Array(5*i);break;default:r=this._lerp,o=this._lerpAdditive,s=this._setAdditiveIdentityNumeric,this.buffer=new Float64Array(5*i)}this._mixBufferRegion=r,this._mixBufferRegionAdditive=o,this._setIdentity=s,this._origIndex=3,this._addIndex=4,this.cumulativeWeight=0,this.cumulativeWeightAdditive=0,this.useCount=0,this.referenceCount=0}accumulate(t,e){let i=this.buffer,r=this.valueSize,o=t*r+r,s=this.cumulativeWeight;if(0===s){for(let a=0;a!==r;++a)i[o+a]=i[a];s=e}else s+=e,this._mixBufferRegion(i,o,0,e/s,r);this.cumulativeWeight=s}accumulateAdditive(t){let e=this.buffer,i=this.valueSize,r=i*this._addIndex;0===this.cumulativeWeightAdditive&&this._setIdentity(),this._mixBufferRegionAdditive(e,r,0,t,i),this.cumulativeWeightAdditive+=t}apply(t){let e=this.valueSize,i=this.buffer,r=t*e+e,o=this.cumulativeWeight,s=this.cumulativeWeightAdditive,a=this.binding;this.cumulativeWeight=0,this.cumulativeWeightAdditive=0,o<1&&this._mixBufferRegion(i,r,e*this._origIndex,1-o,e),s>0&&this._mixBufferRegionAdditive(i,r,this._addIndex*e,1,e);for(let l=e,c=e+e;l!==c;++l)if(i[l]!==i[l+e]){a.setValue(i,r);break}}saveOriginalState(){let e=this.buffer,i=this.valueSize,r=i*this._origIndex;this.binding.getValue(e,r);for(let o=i,s=r;o!==s;++o)e[o]=e[r+o%i];this._setIdentity(),this.cumulativeWeight=0,this.cumulativeWeightAdditive=0}restoreOriginalState(){this.binding.setValue(this.buffer,3*this.valueSize)}_setAdditiveIdentityNumeric(){let t=this._addIndex*this.valueSize,e=t+this.valueSize;for(let i=t;i<e;i++)this.buffer[i]=0}_setAdditiveIdentityQuaternion(){this._setAdditiveIdentityNumeric(),this.buffer[this._addIndex*this.valueSize+3]=1}_setAdditiveIdentityOther(){let t=this._origIndex*this.valueSize,e=this._addIndex*this.valueSize;for(let i=0;i<this.valueSize;i++)this.buffer[e+i]=this.buffer[t+i]}_select(t,e,i,r,o){if(r>=.5)for(let s=0;s!==o;++s)t[e+s]=t[i+s]}_slerp(t,e,i,r){ts.slerpFlat(t,e,t,e,t,i,r)}_slerpAdditive(t,e,i,r,o){let s=this._workIndex*o;ts.multiplyQuaternionsFlat(t,s,t,e,t,i),ts.slerpFlat(t,e,t,e,t,s,r)}_lerp(t,e,i,r,o){let s=1-r;for(let a=0;a!==o;++a){let l=e+a;t[l]=t[l]*s+t[i+a]*r}}_lerpAdditive(t,e,i,r,o){for(let s=0;s!==o;++s){let a=e+s;t[a]=t[a]+t[i+s]*r}}},hV="\\[\\]\\.:\\/",P2e=new RegExp("["+hV+"]","g"),gV="[^"+hV+"]",O2e="[^"+hV.replace("\\.","")+"]",k2e=/((?:WC+[\/:])*)/.source.replace("WC",gV),F2e=/(WCOD+)?/.source.replace("WCOD",O2e),N2e=/(?:\.(WC+)(?:\[(.+)\])?)?/.source.replace("WC",gV),L2e=/\.(WC+)(?:\[(.+)\])?/.source.replace("WC",gV),B2e=new RegExp("^"+k2e+F2e+N2e+L2e+"$"),V2e=["material","materials","bones"],tV=class{constructor(t,e,i){let r=i||xr.parseTrackName(e);this._targetGroup=t,this._bindings=t.subscribe_(e,r)}getValue(t,e){this.bind();let r=this._bindings[this._targetGroup.nCachedObjects_];void 0!==r&&r.getValue(t,e)}setValue(t,e){let i=this._bindings;for(let r=this._targetGroup.nCachedObjects_,o=i.length;r!==o;++r)i[r].setValue(t,e)}bind(){let t=this._bindings;for(let e=this._targetGroup.nCachedObjects_,i=t.length;e!==i;++e)t[e].bind()}unbind(){let t=this._bindings;for(let e=this._targetGroup.nCachedObjects_,i=t.length;e!==i;++e)t[e].unbind()}},xr=(()=>{class n{constructor(e,i,r){this.path=i,this.parsedPath=r||n.parseTrackName(i),this.node=n.findNode(e,this.parsedPath.nodeName)||e,this.rootNode=e,this.getValue=this._getValue_unbound,this.setValue=this._setValue_unbound}static create(e,i,r){return e&&e.isAnimationObjectGroup?new n.Composite(e,i,r):new n(e,i,r)}static sanitizeNodeName(e){return e.replace(/\s/g,"_").replace(P2e,"")}static parseTrackName(e){let i=B2e.exec(e);if(!i)throw new Error("PropertyBinding: Cannot parse trackName: "+e);let r={nodeName:i[2],objectName:i[3],objectIndex:i[4],propertyName:i[5],propertyIndex:i[6]},o=r.nodeName&&r.nodeName.lastIndexOf(".");if(void 0!==o&&-1!==o){let s=r.nodeName.substring(o+1);-1!==V2e.indexOf(s)&&(r.nodeName=r.nodeName.substring(0,o),r.objectName=s)}if(null===r.propertyName||0===r.propertyName.length)throw new Error("PropertyBinding: can not parse propertyName from trackName: "+e);return r}static findNode(e,i){if(!i||""===i||"."===i||-1===i||i===e.name||i===e.uuid)return e;if(e.skeleton){let r=e.skeleton.getBoneByName(i);if(void 0!==r)return r}if(e.children){let r=function(s){for(let a=0;a<s.length;a++){let l=s[a];if(l.name===i||l.uuid===i)return l;let c=r(l.children);if(c)return c}return null},o=r(e.children);if(o)return o}return null}_getValue_unavailable(){}_setValue_unavailable(){}_getValue_direct(e,i){e[i]=this.targetObject[this.propertyName]}_getValue_array(e,i){let r=this.resolvedProperty;for(let o=0,s=r.length;o!==s;++o)e[i++]=r[o]}_getValue_arrayElement(e,i){e[i]=this.resolvedProperty[this.propertyIndex]}_getValue_toArray(e,i){this.resolvedProperty.toArray(e,i)}_setValue_direct(e,i){this.targetObject[this.propertyName]=e[i]}_setValue_direct_setNeedsUpdate(e,i){this.targetObject[this.propertyName]=e[i],this.targetObject.needsUpdate=!0}_setValue_direct_setMatrixWorldNeedsUpdate(e,i){this.targetObject[this.propertyName]=e[i],this.targetObject.matrixWorldNeedsUpdate=!0}_setValue_array(e,i){let r=this.resolvedProperty;for(let o=0,s=r.length;o!==s;++o)r[o]=e[i++]}_setValue_array_setNeedsUpdate(e,i){let r=this.resolvedProperty;for(let o=0,s=r.length;o!==s;++o)r[o]=e[i++];this.targetObject.needsUpdate=!0}_setValue_array_setMatrixWorldNeedsUpdate(e,i){let r=this.resolvedProperty;for(let o=0,s=r.length;o!==s;++o)r[o]=e[i++];this.targetObject.matrixWorldNeedsUpdate=!0}_setValue_arrayElement(e,i){this.resolvedProperty[this.propertyIndex]=e[i]}_setValue_arrayElement_setNeedsUpdate(e,i){this.resolvedProperty[this.propertyIndex]=e[i],this.targetObject.needsUpdate=!0}_setValue_arrayElement_setMatrixWorldNeedsUpdate(e,i){this.resolvedProperty[this.propertyIndex]=e[i],this.targetObject.matrixWorldNeedsUpdate=!0}_setValue_fromArray(e,i){this.resolvedProperty.fromArray(e,i)}_setValue_fromArray_setNeedsUpdate(e,i){this.resolvedProperty.fromArray(e,i),this.targetObject.needsUpdate=!0}_setValue_fromArray_setMatrixWorldNeedsUpdate(e,i){this.resolvedProperty.fromArray(e,i),this.targetObject.matrixWorldNeedsUpdate=!0}_getValue_unbound(e,i){this.bind(),this.getValue(e,i)}_setValue_unbound(e,i){this.bind(),this.setValue(e,i)}bind(){let e=this.node,i=this.parsedPath,r=i.objectName,o=i.propertyName,s=i.propertyIndex;if(e||(e=n.findNode(this.rootNode,i.nodeName)||this.rootNode,this.node=e),this.getValue=this._getValue_unavailable,this.setValue=this._setValue_unavailable,!e)return void console.error("THREE.PropertyBinding: Trying to update node for track: "+this.path+" but it wasn't found.");if(r){let d=i.objectIndex;switch(r){case"materials":if(!e.material)return void console.error("THREE.PropertyBinding: Can not bind to material as node does not have a material.",this);if(!e.material.materials)return void console.error("THREE.PropertyBinding: Can not bind to material.materials as node.material does not have a materials array.",this);e=e.material.materials;break;case"bones":if(!e.skeleton)return void console.error("THREE.PropertyBinding: Can not bind to bones as node does not have a skeleton.",this);e=e.skeleton.bones;for(let u=0;u<e.length;u++)if(e[u].name===d){d=u;break}break;default:if(void 0===e[r])return void console.error("THREE.PropertyBinding: Can not bind to objectName of node undefined.",this);e=e[r]}if(void 0!==d){if(void 0===e[d])return void console.error("THREE.PropertyBinding: Trying to bind to objectIndex of objectName, but is undefined.",this,e);e=e[d]}}let a=e[o];if(void 0===a)return void console.error("THREE.PropertyBinding: Trying to update property for track: "+i.nodeName+"."+o+" but it wasn't found.",e);let l=this.Versioning.None;this.targetObject=e,void 0!==e.needsUpdate?l=this.Versioning.NeedsUpdate:void 0!==e.matrixWorldNeedsUpdate&&(l=this.Versioning.MatrixWorldNeedsUpdate);let c=this.BindingType.Direct;if(void 0!==s){if("morphTargetInfluences"===o){if(!e.geometry)return void console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.",this);if(!e.geometry.isBufferGeometry)return void console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences on THREE.Geometry. Use THREE.BufferGeometry instead.",this);if(!e.geometry.morphAttributes)return void console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.morphAttributes.",this);void 0!==e.morphTargetDictionary[s]&&(s=e.morphTargetDictionary[s])}c=this.BindingType.ArrayElement,this.resolvedProperty=a,this.propertyIndex=s}else void 0!==a.fromArray&&void 0!==a.toArray?(c=this.BindingType.HasFromToArray,this.resolvedProperty=a):Array.isArray(a)?(c=this.BindingType.EntireArray,this.resolvedProperty=a):this.propertyName=o;this.getValue=this.GetterByBindingType[c],this.setValue=this.SetterByBindingTypeAndVersioning[c][l]}unbind(){this.node=null,this.getValue=this._getValue_unbound,this.setValue=this._setValue_unbound}}return n.Composite=tV,n})();xr.prototype.BindingType={Direct:0,EntireArray:1,ArrayElement:2,HasFromToArray:3},xr.prototype.Versioning={None:0,NeedsUpdate:1,MatrixWorldNeedsUpdate:2},xr.prototype.GetterByBindingType=[xr.prototype._getValue_direct,xr.prototype._getValue_array,xr.prototype._getValue_arrayElement,xr.prototype._getValue_toArray],xr.prototype.SetterByBindingTypeAndVersioning=[[xr.prototype._setValue_direct,xr.prototype._setValue_direct_setNeedsUpdate,xr.prototype._setValue_direct_setMatrixWorldNeedsUpdate],[xr.prototype._setValue_array,xr.prototype._setValue_array_setNeedsUpdate,xr.prototype._setValue_array_setMatrixWorldNeedsUpdate],[xr.prototype._setValue_arrayElement,xr.prototype._setValue_arrayElement_setNeedsUpdate,xr.prototype._setValue_arrayElement_setMatrixWorldNeedsUpdate],[xr.prototype._setValue_fromArray,xr.prototype._setValue_fromArray_setNeedsUpdate,xr.prototype._setValue_fromArray_setMatrixWorldNeedsUpdate]],class extends Ud{constructor(t){super(),this._root=t,this._initMemoryManager(),this._accuIndex=0,this.time=0,this.timeScale=1}_bindAction(t,e){let i=t._localRoot||this._root,r=t._clip.tracks,o=r.length,s=t._propertyBindings,a=t._interpolants,l=i.uuid,c=this._bindingsByRootAndName,d=c[l];void 0===d&&(d={},c[l]=d);for(let u=0;u!==o;++u){let p=r[u],f=p.name,m=d[f];if(void 0!==m)++m.referenceCount,s[u]=m;else{if(m=s[u],void 0!==m){null===m._cacheIndex&&(++m.referenceCount,this._addInactiveBinding(m,l,f));continue}m=new eV(xr.create(i,f,e&&e._propertyBindings[u].binding.parsedPath),p.ValueTypeName,p.getValueSize()),++m.referenceCount,this._addInactiveBinding(m,l,f),s[u]=m}a[u].resultBuffer=m.buffer}}_activateAction(t){if(!this._isActiveAction(t)){if(null===t._cacheIndex){let i=(t._localRoot||this._root).uuid,r=t._clip.uuid,o=this._actionsByClip[r];this._bindAction(t,o&&o.knownActions[0]),this._addInactiveAction(t,r,i)}let e=t._propertyBindings;for(let i=0,r=e.length;i!==r;++i){let o=e[i];0==o.useCount++&&(this._lendBinding(o),o.saveOriginalState())}this._lendAction(t)}}_deactivateAction(t){if(this._isActiveAction(t)){let e=t._propertyBindings;for(let i=0,r=e.length;i!==r;++i){let o=e[i];0==--o.useCount&&(o.restoreOriginalState(),this._takeBackBinding(o))}this._takeBackAction(t)}}_initMemoryManager(){this._actions=[],this._nActiveActions=0,this._actionsByClip={},this._bindings=[],this._nActiveBindings=0,this._bindingsByRootAndName={},this._controlInterpolants=[],this._nActiveControlInterpolants=0;let t=this;this.stats={actions:{get total(){return t._actions.length},get inUse(){return t._nActiveActions}},bindings:{get total(){return t._bindings.length},get inUse(){return t._nActiveBindings}},controlInterpolants:{get total(){return t._controlInterpolants.length},get inUse(){return t._nActiveControlInterpolants}}}}_isActiveAction(t){let e=t._cacheIndex;return null!==e&&e<this._nActiveActions}_addInactiveAction(t,e,i){let r=this._actions,o=this._actionsByClip,s=o[e];if(void 0===s)s={knownActions:[t],actionByRoot:{}},t._byClipCacheIndex=0,o[e]=s;else{let a=s.knownActions;t._byClipCacheIndex=a.length,a.push(t)}t._cacheIndex=r.length,r.push(t),s.actionByRoot[i]=t}_removeInactiveAction(t){let e=this._actions,i=e[e.length-1],r=t._cacheIndex;i._cacheIndex=r,e[r]=i,e.pop(),t._cacheIndex=null;let o=t._clip.uuid,s=this._actionsByClip,a=s[o],l=a.knownActions,c=l[l.length-1],d=t._byClipCacheIndex;c._byClipCacheIndex=d,l[d]=c,l.pop(),t._byClipCacheIndex=null,delete a.actionByRoot[(t._localRoot||this._root).uuid],0===l.length&&delete s[o],this._removeInactiveBindingsForAction(t)}_removeInactiveBindingsForAction(t){let e=t._propertyBindings;for(let i=0,r=e.length;i!==r;++i){let o=e[i];0==--o.referenceCount&&this._removeInactiveBinding(o)}}_lendAction(t){let e=this._actions,i=t._cacheIndex,r=this._nActiveActions++,o=e[r];t._cacheIndex=r,e[r]=t,o._cacheIndex=i,e[i]=o}_takeBackAction(t){let e=this._actions,i=t._cacheIndex,r=--this._nActiveActions,o=e[r];t._cacheIndex=r,e[r]=t,o._cacheIndex=i,e[i]=o}_addInactiveBinding(t,e,i){let r=this._bindingsByRootAndName,o=this._bindings,s=r[e];void 0===s&&(s={},r[e]=s),s[i]=t,t._cacheIndex=o.length,o.push(t)}_removeInactiveBinding(t){let e=this._bindings,i=t.binding,r=i.rootNode.uuid,o=i.path,s=this._bindingsByRootAndName,a=s[r],l=e[e.length-1],c=t._cacheIndex;l._cacheIndex=c,e[c]=l,e.pop(),delete a[o],0===Object.keys(a).length&&delete s[r]}_lendBinding(t){let e=this._bindings,i=t._cacheIndex,r=this._nActiveBindings++,o=e[r];t._cacheIndex=r,e[r]=t,o._cacheIndex=i,e[i]=o}_takeBackBinding(t){let e=this._bindings,i=t._cacheIndex,r=--this._nActiveBindings,o=e[r];t._cacheIndex=r,e[r]=t,o._cacheIndex=i,e[i]=o}_lendControlInterpolant(){let t=this._controlInterpolants,e=this._nActiveControlInterpolants++,i=t[e];return void 0===i&&(i=new VI(new Float32Array(2),new Float32Array(2),1,this._controlInterpolantsResultBuffer),i.__cacheIndex=e,t[e]=i),i}_takeBackControlInterpolant(t){let e=this._controlInterpolants,i=t.__cacheIndex,r=--this._nActiveControlInterpolants,o=e[r];t.__cacheIndex=r,e[r]=t,o.__cacheIndex=i,e[i]=o}clipAction(t,e,i){let r=e||this._root,o=r.uuid,s="string"==typeof t?zI.findByName(r,t):t,a=null!==s?s.uuid:t,l=this._actionsByClip[a],c=null;if(void 0===i&&(i=null!==s?s.blendMode:2500),void 0!==l){let u=l.actionByRoot[o];if(void 0!==u&&u.blendMode===i)return u;c=l.knownActions[0],null===s&&(s=c._clip)}if(null===s)return null;let d=new class{constructor(t,e,i=null,r=e.blendMode){this._mixer=t,this._clip=e,this._localRoot=i,this.blendMode=r;let o=e.tracks,s=o.length,a=new Array(s),l={endingStart:V0,endingEnd:V0};for(let c=0;c!==s;++c){let d=o[c].createInterpolant(null);a[c]=d,d.settings=l}this._interpolantSettings=l,this._interpolants=a,this._propertyBindings=new Array(s),this._cacheIndex=null,this._byClipCacheIndex=null,this._timeScaleInterpolant=null,this._weightInterpolant=null,this.loop=2201,this._loopCount=-1,this._startTime=null,this.time=0,this.timeScale=1,this._effectiveTimeScale=1,this.weight=1,this._effectiveWeight=1,this.repetitions=1/0,this.paused=!1,this.enabled=!0,this.clampWhenFinished=!1,this.zeroSlopeAtStart=!0,this.zeroSlopeAtEnd=!0}play(){return this._mixer._activateAction(this),this}stop(){return this._mixer._deactivateAction(this),this.reset()}reset(){return this.paused=!1,this.enabled=!0,this.time=0,this._loopCount=-1,this._startTime=null,this.stopFading().stopWarping()}isRunning(){return this.enabled&&!this.paused&&0!==this.timeScale&&null===this._startTime&&this._mixer._isActiveAction(this)}isScheduled(){return this._mixer._isActiveAction(this)}startAt(t){return this._startTime=t,this}setLoop(t,e){return this.loop=t,this.repetitions=e,this}setEffectiveWeight(t){return this.weight=t,this._effectiveWeight=this.enabled?t:0,this.stopFading()}getEffectiveWeight(){return this._effectiveWeight}fadeIn(t){return this._scheduleFading(t,0,1)}fadeOut(t){return this._scheduleFading(t,1,0)}crossFadeFrom(t,e,i){if(t.fadeOut(e),this.fadeIn(e),i){let r=this._clip.duration,o=t._clip.duration,a=r/o;t.warp(1,o/r,e),this.warp(a,1,e)}return this}crossFadeTo(t,e,i){return t.crossFadeFrom(this,e,i)}stopFading(){let t=this._weightInterpolant;return null!==t&&(this._weightInterpolant=null,this._mixer._takeBackControlInterpolant(t)),this}setEffectiveTimeScale(t){return this.timeScale=t,this._effectiveTimeScale=this.paused?0:t,this.stopWarping()}getEffectiveTimeScale(){return this._effectiveTimeScale}setDuration(t){return this.timeScale=this._clip.duration/t,this.stopWarping()}syncWith(t){return this.time=t.time,this.timeScale=t.timeScale,this.stopWarping()}halt(t){return this.warp(this._effectiveTimeScale,0,t)}warp(t,e,i){let r=this._mixer,o=r.time,s=this.timeScale,a=this._timeScaleInterpolant;null===a&&(a=r._lendControlInterpolant(),this._timeScaleInterpolant=a);let l=a.parameterPositions,c=a.sampleValues;return l[0]=o,l[1]=o+i,c[0]=t/s,c[1]=e/s,this}stopWarping(){let t=this._timeScaleInterpolant;return null!==t&&(this._timeScaleInterpolant=null,this._mixer._takeBackControlInterpolant(t)),this}getMixer(){return this._mixer}getClip(){return this._clip}getRoot(){return this._localRoot||this._mixer._root}_update(t,e,i,r){if(!this.enabled)return void this._updateWeight(t);let o=this._startTime;if(null!==o){let l=(t-o)*i;if(l<0||0===i)return;this._startTime=null,e=i*l}e*=this._updateTimeScale(t);let s=this._updateTime(e),a=this._updateWeight(t);if(a>0){let l=this._interpolants,c=this._propertyBindings;if(2501===this.blendMode)for(let d=0,u=l.length;d!==u;++d)l[d].evaluate(s),c[d].accumulateAdditive(a);else for(let d=0,u=l.length;d!==u;++d)l[d].evaluate(s),c[d].accumulate(r,a)}}_updateWeight(t){let e=0;if(this.enabled){e=this.weight;let i=this._weightInterpolant;if(null!==i){let r=i.evaluate(t)[0];e*=r,t>i.parameterPositions[1]&&(this.stopFading(),0===r&&(this.enabled=!1))}}return this._effectiveWeight=e,e}_updateTimeScale(t){let e=0;if(!this.paused){e=this.timeScale;let i=this._timeScaleInterpolant;null!==i&&(e*=i.evaluate(t)[0],t>i.parameterPositions[1]&&(this.stopWarping(),0===e?this.paused=!0:this.timeScale=e))}return this._effectiveTimeScale=e,e}_updateTime(t){let e=this._clip.duration,i=this.loop,r=this.time+t,o=this._loopCount,s=2202===i;if(0===t)return-1===o?r:s&&1==(1&o)?e-r:r;if(2200===i){-1===o&&(this._loopCount=0,this._setEndings(!0,!0,!1));e:{if(r>=e)r=e;else{if(!(r<0)){this.time=r;break e}r=0}this.clampWhenFinished?this.paused=!0:this.enabled=!1,this.time=r,this._mixer.dispatchEvent({type:"finished",action:this,direction:t<0?-1:1})}}else{if(-1===o&&(t>=0?(o=0,this._setEndings(!0,0===this.repetitions,s)):this._setEndings(0===this.repetitions,!0,s)),r>=e||r<0){let a=Math.floor(r/e);r-=e*a,o+=Math.abs(a);let l=this.repetitions-o;if(l<=0)this.clampWhenFinished?this.paused=!0:this.enabled=!1,r=t>0?e:0,this.time=r,this._mixer.dispatchEvent({type:"finished",action:this,direction:t>0?1:-1});else{if(1===l){let c=t<0;this._setEndings(c,!c,s)}else this._setEndings(!1,!1,s);this._loopCount=o,this.time=r,this._mixer.dispatchEvent({type:"loop",action:this,loopDelta:a})}}else this.time=r;if(s&&1==(1&o))return e-r}return r}_setEndings(t,e,i){let r=this._interpolantSettings;i?(r.endingStart=H0,r.endingEnd=H0):(r.endingStart=t?this.zeroSlopeAtStart?H0:V0:2402,r.endingEnd=e?this.zeroSlopeAtEnd?H0:V0:2402)}_scheduleFading(t,e,i){let r=this._mixer,o=r.time,s=this._weightInterpolant;null===s&&(s=r._lendControlInterpolant(),this._weightInterpolant=s);let a=s.parameterPositions,l=s.sampleValues;return a[0]=o,l[0]=e,a[1]=o+t,l[1]=i,this}}(this,s,e,i);return this._bindAction(d,c),this._addInactiveAction(d,a,o),d}existingAction(t,e){let i=e||this._root,r=i.uuid,o="string"==typeof t?zI.findByName(i,t):t,a=this._actionsByClip[o?o.uuid:t];return void 0!==a&&a.actionByRoot[r]||null}stopAllAction(){let t=this._actions;for(let i=this._nActiveActions-1;i>=0;--i)t[i].stop();return this}update(t){let e=this._actions,i=this._nActiveActions,r=this.time+=t*=this.timeScale,o=Math.sign(t),s=this._accuIndex^=1;for(let c=0;c!==i;++c)e[c]._update(r,t,o,s);let a=this._bindings,l=this._nActiveBindings;for(let c=0;c!==l;++c)a[c].apply(s);return this}setTime(t){this.time=0;for(let e=0;e<this._actions.length;e++)this._actions[e].time=0;return this.update(t)}getRoot(){return this._root}uncacheClip(t){let e=this._actions,i=t.uuid,r=this._actionsByClip,o=r[i];if(void 0!==o){let s=o.knownActions;for(let a=0,l=s.length;a!==l;++a){let c=s[a];this._deactivateAction(c);let d=c._cacheIndex,u=e[e.length-1];c._cacheIndex=null,c._byClipCacheIndex=null,u._cacheIndex=d,e[d]=u,e.pop(),this._removeInactiveBindingsForAction(c)}delete r[i]}}uncacheRoot(t){let e=t.uuid,i=this._actionsByClip;for(let s in i){let l=i[s].actionByRoot[e];void 0!==l&&(this._deactivateAction(l),this._removeInactiveAction(l))}let o=this._bindingsByRootAndName[e];if(void 0!==o)for(let s in o){let a=o[s];a.restoreOriginalState(),this._removeInactiveBinding(a)}}uncacheAction(t,e){let i=this.existingAction(t,e);null!==i&&(this._deactivateAction(i),this._removeInactiveAction(i))}}.prototype._controlInterpolantsResultBuffer=new Float32Array(1);var Gx=class{constructor(t){"string"==typeof t&&(console.warn("THREE.Uniform: Type parameter is no longer needed."),t=arguments[1]),this.value=t}clone(){return new Gx(void 0===this.value.clone?this.value:this.value.clone())}};(class extends hm{constructor(t,e,i=1){super(t,e),this.meshPerAttribute=i}copy(t){return super.copy(t),this.meshPerAttribute=t.meshPerAttribute,this}clone(t){let e=super.clone(t);return e.meshPerAttribute=this.meshPerAttribute,e}toJSON(t){let e=super.toJSON(t);return e.isInstancedInterleavedBuffer=!0,e.meshPerAttribute=this.meshPerAttribute,e}}).prototype.isInstancedInterleavedBuffer=!0;var zee=new $e,vm=class{constructor(t=new $e(1/0,1/0),e=new $e(-1/0,-1/0)){this.min=t,this.max=e}set(t,e){return this.min.copy(t),this.max.copy(e),this}setFromPoints(t){this.makeEmpty();for(let e=0,i=t.length;e<i;e++)this.expandByPoint(t[e]);return this}setFromCenterAndSize(t,e){let i=zee.copy(e).multiplyScalar(.5);return this.min.copy(t).sub(i),this.max.copy(t).add(i),this}clone(){return(new this.constructor).copy(this)}copy(t){return this.min.copy(t.min),this.max.copy(t.max),this}makeEmpty(){return this.min.x=this.min.y=1/0,this.max.x=this.max.y=-1/0,this}isEmpty(){return this.max.x<this.min.x||this.max.y<this.min.y}getCenter(t){return this.isEmpty()?t.set(0,0):t.addVectors(this.min,this.max).multiplyScalar(.5)}getSize(t){return this.isEmpty()?t.set(0,0):t.subVectors(this.max,this.min)}expandByPoint(t){return this.min.min(t),this.max.max(t),this}expandByVector(t){return this.min.sub(t),this.max.add(t),this}expandByScalar(t){return this.min.addScalar(-t),this.max.addScalar(t),this}containsPoint(t){return!(t.x<this.min.x||t.x>this.max.x||t.y<this.min.y||t.y>this.max.y)}containsBox(t){return this.min.x<=t.min.x&&t.max.x<=this.max.x&&this.min.y<=t.min.y&&t.max.y<=this.max.y}getParameter(t,e){return e.set((t.x-this.min.x)/(this.max.x-this.min.x),(t.y-this.min.y)/(this.max.y-this.min.y))}intersectsBox(t){return!(t.max.x<this.min.x||t.min.x>this.max.x||t.max.y<this.min.y||t.min.y>this.max.y)}clampPoint(t,e){return e.copy(t).clamp(this.min,this.max)}distanceToPoint(t){return zee.copy(t).clamp(this.min,this.max).sub(t).length()}intersect(t){return this.min.max(t.min),this.max.min(t.max),this}union(t){return this.min.min(t.min),this.max.max(t.max),this}translate(t){return this.min.add(t),this.max.add(t),this}equals(t){return t.min.equals(this.min)&&t.max.equals(this.max)}};vm.prototype.isBox2=!0;var up=new $,gI=new xn,Q3=new xn;function pte(n){let t=[];n&&n.isBone&&t.push(n);for(let e=0;e<n.children.length;e++)t.push.apply(t,pte(n.children[e]));return t}var H2e=new Float32Array(1);function _V(n,t,e){if(1===e)return new an(t);let i=Vf(t);if(!i)throw new Error(`d3 failed to recognize the color: ${t}`);return new an(fL(i,n)(1-e))}new Int32Array(H2e.buffer),$s.create=function(n,t){return console.log("THREE.Curve.create() has been deprecated"),n.prototype=Object.create($s.prototype),n.prototype.constructor=n,n.prototype.getPoint=t,n},Bx.prototype.fromPoints=function(n){return console.warn("THREE.Path: .fromPoints() has been renamed to .setFromPoints()."),this.setFromPoints(n)},class extends kx{constructor(t=10,e=10,i=4473924,r=8947848){i=new an(i),r=new an(r);let o=e/2,s=t/e,a=t/2,l=[],c=[];for(let p=0,f=0,m=-a;p<=e;p++,m+=s){l.push(-a,0,m,a,0,m),l.push(m,0,-a,m,0,a);let b=p===o?i:r;b.toArray(c,f),f+=3,b.toArray(c,f),f+=3,b.toArray(c,f),f+=3,b.toArray(c,f),f+=3}let d=new Ui;d.setAttribute("position",new Nr(l,3)),d.setAttribute("color",new Nr(c,3)),super(d,new Wd({vertexColors:!0,toneMapped:!1})),this.type="GridHelper"}}.prototype.setColors=function(){console.error("THREE.GridHelper: setColors() has been deprecated, pass them in the constructor instead.")},class extends kx{constructor(t){let e=pte(t),i=new Ui,r=[],o=[],s=new an(0,0,1),a=new an(0,1,0);for(let c=0;c<e.length;c++){let d=e[c];d.parent&&d.parent.isBone&&(r.push(0,0,0),r.push(0,0,0),o.push(s.r,s.g,s.b),o.push(a.r,a.g,a.b))}i.setAttribute("position",new Nr(r,3)),i.setAttribute("color",new Nr(o,3)),super(i,new Wd({vertexColors:!0,depthTest:!1,depthWrite:!1,toneMapped:!1,transparent:!0})),this.type="SkeletonHelper",this.isSkeletonHelper=!0,this.root=t,this.bones=e,this.matrix=t.matrixWorld,this.matrixAutoUpdate=!1}updateMatrixWorld(t){let e=this.bones,i=this.geometry,r=i.getAttribute("position");Q3.copy(this.root.matrixWorld).invert();for(let o=0,s=0;o<e.length;o++){let a=e[o];a.parent&&a.parent.isBone&&(gI.multiplyMatrices(Q3,a.matrixWorld),up.setFromMatrixPosition(gI),r.setXYZ(s,up.x,up.y,up.z),gI.multiplyMatrices(Q3,a.parent.matrixWorld),up.setFromMatrixPosition(gI),r.setXYZ(s+1,up.x,up.y,up.z),s+=2)}i.getAttribute("position").needsUpdate=!0,super.updateMatrixWorld(t)}}.prototype.update=function(){console.error("THREE.SkeletonHelper: update() no longer needs to be called.")},Qc.prototype.extractUrlBase=function(n){return console.warn("THREE.Loader: .extractUrlBase() has been deprecated. Use THREE.LoaderUtils.extractUrlBase() instead."),qB.extractUrlBase(n)},Qc.Handlers={add:function(){console.error("THREE.Loader: Handlers.add() has been removed. Use LoadingManager.addHandler() instead.")},get:function(){console.error("THREE.Loader: Handlers.get() has been removed. Use LoadingManager.getHandler() instead.")}},vm.prototype.center=function(n){return console.warn("THREE.Box2: .center() has been renamed to .getCenter()."),this.getCenter(n)},vm.prototype.empty=function(){return console.warn("THREE.Box2: .empty() has been renamed to .isEmpty()."),this.isEmpty()},vm.prototype.isIntersectionBox=function(n){return console.warn("THREE.Box2: .isIntersectionBox() has been renamed to .intersectsBox()."),this.intersectsBox(n)},vm.prototype.size=function(n){return console.warn("THREE.Box2: .size() has been renamed to .getSize()."),this.getSize(n)},xa.prototype.center=function(n){return console.warn("THREE.Box3: .center() has been renamed to .getCenter()."),this.getCenter(n)},xa.prototype.empty=function(){return console.warn("THREE.Box3: .empty() has been renamed to .isEmpty()."),this.isEmpty()},xa.prototype.isIntersectionBox=function(n){return console.warn("THREE.Box3: .isIntersectionBox() has been renamed to .intersectsBox()."),this.intersectsBox(n)},xa.prototype.isIntersectionSphere=function(n){return console.warn("THREE.Box3: .isIntersectionSphere() has been renamed to .intersectsSphere()."),this.intersectsSphere(n)},xa.prototype.size=function(n){return console.warn("THREE.Box3: .size() has been renamed to .getSize()."),this.getSize(n)},bp.prototype.empty=function(){return console.warn("THREE.Sphere: .empty() has been renamed to .isEmpty()."),this.isEmpty()},Z0.prototype.setFromMatrix=function(n){return console.warn("THREE.Frustum: .setFromMatrix() has been renamed to .setFromProjectionMatrix()."),this.setFromProjectionMatrix(n)},bo.prototype.flattenToArrayOffset=function(n,t){return console.warn("THREE.Matrix3: .flattenToArrayOffset() has been deprecated. Use .toArray() instead."),this.toArray(n,t)},bo.prototype.multiplyVector3=function(n){return console.warn("THREE.Matrix3: .multiplyVector3() has been removed. Use vector.applyMatrix3( matrix ) instead."),n.applyMatrix3(this)},bo.prototype.multiplyVector3Array=function(){console.error("THREE.Matrix3: .multiplyVector3Array() has been removed.")},bo.prototype.applyToBufferAttribute=function(n){return console.warn("THREE.Matrix3: .applyToBufferAttribute() has been removed. Use attribute.applyMatrix3( matrix ) instead."),n.applyMatrix3(this)},bo.prototype.applyToVector3Array=function(){console.error("THREE.Matrix3: .applyToVector3Array() has been removed.")},bo.prototype.getInverse=function(n){return console.warn("THREE.Matrix3: .getInverse() has been removed. Use matrixInv.copy( matrix ).invert(); instead."),this.copy(n).invert()},xn.prototype.extractPosition=function(n){return console.warn("THREE.Matrix4: .extractPosition() has been renamed to .copyPosition()."),this.copyPosition(n)},xn.prototype.flattenToArrayOffset=function(n,t){return console.warn("THREE.Matrix4: .flattenToArrayOffset() has been deprecated. Use .toArray() instead."),this.toArray(n,t)},xn.prototype.getPosition=function(){return console.warn("THREE.Matrix4: .getPosition() has been removed. Use Vector3.setFromMatrixPosition( matrix ) instead."),(new $).setFromMatrixColumn(this,3)},xn.prototype.setRotationFromQuaternion=function(n){return console.warn("THREE.Matrix4: .setRotationFromQuaternion() has been renamed to .makeRotationFromQuaternion()."),this.makeRotationFromQuaternion(n)},xn.prototype.multiplyToArray=function(){console.warn("THREE.Matrix4: .multiplyToArray() has been removed.")},xn.prototype.multiplyVector3=function(n){return console.warn("THREE.Matrix4: .multiplyVector3() has been removed. Use vector.applyMatrix4( matrix ) instead."),n.applyMatrix4(this)},xn.prototype.multiplyVector4=function(n){return console.warn("THREE.Matrix4: .multiplyVector4() has been removed. Use vector.applyMatrix4( matrix ) instead."),n.applyMatrix4(this)},xn.prototype.multiplyVector3Array=function(){console.error("THREE.Matrix4: .multiplyVector3Array() has been removed.")},xn.prototype.rotateAxis=function(n){console.warn("THREE.Matrix4: .rotateAxis() has been removed. Use Vector3.transformDirection( matrix ) instead."),n.transformDirection(this)},xn.prototype.crossVector=function(n){return console.warn("THREE.Matrix4: .crossVector() has been removed. Use vector.applyMatrix4( matrix ) instead."),n.applyMatrix4(this)},xn.prototype.translate=function(){console.error("THREE.Matrix4: .translate() has been removed.")},xn.prototype.rotateX=function(){console.error("THREE.Matrix4: .rotateX() has been removed.")},xn.prototype.rotateY=function(){console.error("THREE.Matrix4: .rotateY() has been removed.")},xn.prototype.rotateZ=function(){console.error("THREE.Matrix4: .rotateZ() has been removed.")},xn.prototype.rotateByAxis=function(){console.error("THREE.Matrix4: .rotateByAxis() has been removed.")},xn.prototype.applyToBufferAttribute=function(n){return console.warn("THREE.Matrix4: .applyToBufferAttribute() has been removed. Use attribute.applyMatrix4( matrix ) instead."),n.applyMatrix4(this)},xn.prototype.applyToVector3Array=function(){console.error("THREE.Matrix4: .applyToVector3Array() has been removed.")},xn.prototype.makeFrustum=function(n,t,e,i,r,o){return console.warn("THREE.Matrix4: .makeFrustum() has been removed. Use .makePerspective( left, right, top, bottom, near, far ) instead."),this.makePerspective(n,t,i,e,r,o)},xn.prototype.getInverse=function(n){return console.warn("THREE.Matrix4: .getInverse() has been removed. Use matrixInv.copy( matrix ).invert(); instead."),this.copy(n).invert()},Kl.prototype.isIntersectionLine=function(n){return console.warn("THREE.Plane: .isIntersectionLine() has been renamed to .intersectsLine()."),this.intersectsLine(n)},ts.prototype.multiplyVector3=function(n){return console.warn("THREE.Quaternion: .multiplyVector3() has been removed. Use is now vector.applyQuaternion( quaternion ) instead."),n.applyQuaternion(this)},ts.prototype.inverse=function(){return console.warn("THREE.Quaternion: .inverse() has been renamed to invert()."),this.invert()},vp.prototype.isIntersectionBox=function(n){return console.warn("THREE.Ray: .isIntersectionBox() has been renamed to .intersectsBox()."),this.intersectsBox(n)},vp.prototype.isIntersectionPlane=function(n){return console.warn("THREE.Ray: .isIntersectionPlane() has been renamed to .intersectsPlane()."),this.intersectsPlane(n)},vp.prototype.isIntersectionSphere=function(n){return console.warn("THREE.Ray: .isIntersectionSphere() has been renamed to .intersectsSphere()."),this.intersectsSphere(n)},Vr.prototype.area=function(){return console.warn("THREE.Triangle: .area() has been renamed to .getArea()."),this.getArea()},Vr.prototype.barycoordFromPoint=function(n,t){return console.warn("THREE.Triangle: .barycoordFromPoint() has been renamed to .getBarycoord()."),this.getBarycoord(n,t)},Vr.prototype.midpoint=function(n){return console.warn("THREE.Triangle: .midpoint() has been renamed to .getMidpoint()."),this.getMidpoint(n)},Vr.prototypenormal=function(n){return console.warn("THREE.Triangle: .normal() has been renamed to .getNormal()."),this.getNormal(n)},Vr.prototype.plane=function(n){return console.warn("THREE.Triangle: .plane() has been renamed to .getPlane()."),this.getPlane(n)},Vr.barycoordFromPoint=function(n,t,e,i,r){return console.warn("THREE.Triangle: .barycoordFromPoint() has been renamed to .getBarycoord()."),Vr.getBarycoord(n,t,e,i,r)},Vr.normal=function(n,t,e,i){return console.warn("THREE.Triangle: .normal() has been renamed to .getNormal()."),Vr.getNormal(n,t,e,i)},qd.prototype.extractAllPoints=function(n){return console.warn("THREE.Shape: .extractAllPoints() has been removed. Use .extractPoints() instead."),this.extractPoints(n)},qd.prototype.extrude=function(n){return console.warn("THREE.Shape: .extrude() has been removed. Use ExtrudeGeometry() instead."),new Cp(this,n)},qd.prototype.makeGeometry=function(n){return console.warn("THREE.Shape: .makeGeometry() has been removed. Use ShapeGeometry() instead."),new _m(this,n)},$e.prototype.fromAttribute=function(n,t,e){return console.warn("THREE.Vector2: .fromAttribute() has been renamed to .fromBufferAttribute()."),this.fromBufferAttribute(n,t,e)},$e.prototype.distanceToManhattan=function(n){return console.warn("THREE.Vector2: .distanceToManhattan() has been renamed to .manhattanDistanceTo()."),this.manhattanDistanceTo(n)},$e.prototype.lengthManhattan=function(){return console.warn("THREE.Vector2: .lengthManhattan() has been renamed to .manhattanLength()."),this.manhattanLength()},$.prototype.setEulerFromRotationMatrix=function(){console.error("THREE.Vector3: .setEulerFromRotationMatrix() has been removed. Use Euler.setFromRotationMatrix() instead.")},$.prototype.setEulerFromQuaternion=function(){console.error("THREE.Vector3: .setEulerFromQuaternion() has been removed. Use Euler.setFromQuaternion() instead.")},$.prototype.getPositionFromMatrix=function(n){return console.warn("THREE.Vector3: .getPositionFromMatrix() has been renamed to .setFromMatrixPosition()."),this.setFromMatrixPosition(n)},$.prototype.getScaleFromMatrix=function(n){return console.warn("THREE.Vector3: .getScaleFromMatrix() has been renamed to .setFromMatrixScale()."),this.setFromMatrixScale(n)},$.prototype.getColumnFromMatrix=function(n,t){return console.warn("THREE.Vector3: .getColumnFromMatrix() has been renamed to .setFromMatrixColumn()."),this.setFromMatrixColumn(t,n)},$.prototype.applyProjection=function(n){return console.warn("THREE.Vector3: .applyProjection() has been removed. Use .applyMatrix4( m ) instead."),this.applyMatrix4(n)},$.prototype.fromAttribute=function(n,t,e){return console.warn("THREE.Vector3: .fromAttribute() has been renamed to .fromBufferAttribute()."),this.fromBufferAttribute(n,t,e)},$.prototype.distanceToManhattan=function(n){return console.warn("THREE.Vector3: .distanceToManhattan() has been renamed to .manhattanDistanceTo()."),this.manhattanDistanceTo(n)},$.prototype.lengthManhattan=function(){return console.warn("THREE.Vector3: .lengthManhattan() has been renamed to .manhattanLength()."),this.manhattanLength()},Zi.prototype.fromAttribute=function(n,t,e){return console.warn("THREE.Vector4: .fromAttribute() has been renamed to .fromBufferAttribute()."),this.fromBufferAttribute(n,t,e)},Zi.prototype.lengthManhattan=function(){return console.warn("THREE.Vector4: .lengthManhattan() has been renamed to .manhattanLength()."),this.manhattanLength()},Bi.prototype.getChildByName=function(n){return console.warn("THREE.Object3D: .getChildByName() has been renamed to .getObjectByName()."),this.getObjectByName(n)},Bi.prototype.renderDepth=function(){console.warn("THREE.Object3D: .renderDepth has been removed. Use .renderOrder, instead.")},Bi.prototype.translate=function(n,t){return console.warn("THREE.Object3D: .translate() has been removed. Use .translateOnAxis( axis, distance ) instead."),this.translateOnAxis(t,n)},Bi.prototype.getWorldRotation=function(){console.error("THREE.Object3D: .getWorldRotation() has been removed. Use THREE.Object3D.getWorldQuaternion( target ) instead.")},Bi.prototype.applyMatrix=function(n){return console.warn("THREE.Object3D: .applyMatrix() has been renamed to .applyMatrix4()."),this.applyMatrix4(n)},Object.defineProperties(Bi.prototype,{eulerOrder:{get:function(){return console.warn("THREE.Object3D: .eulerOrder is now .rotation.order."),this.rotation.order},set:function(n){console.warn("THREE.Object3D: .eulerOrder is now .rotation.order."),this.rotation.order=n}},useQuaternion:{get:function(){console.warn("THREE.Object3D: .useQuaternion has been removed. The library now uses quaternions by default.")},set:function(){console.warn("THREE.Object3D: .useQuaternion has been removed. The library now uses quaternions by default.")}}}),ao.prototype.setDrawMode=function(){console.error("THREE.Mesh: .setDrawMode() has been removed. The renderer now always assumes THREE.TrianglesDrawMode. Transform your geometry via BufferGeometryUtils.toTrianglesDrawMode() if necessary.")},Object.defineProperties(ao.prototype,{drawMode:{get:function(){return console.error("THREE.Mesh: .drawMode has been removed. The renderer now always assumes THREE.TrianglesDrawMode."),0},set:function(){console.error("THREE.Mesh: .drawMode has been removed. The renderer now always assumes THREE.TrianglesDrawMode. Transform your geometry via BufferGeometryUtils.toTrianglesDrawMode() if necessary.")}}}),PI.prototype.initBones=function(){console.error("THREE.SkinnedMesh: initBones() has been removed.")},es.prototype.setLens=function(n,t){console.warn("THREE.PerspectiveCamera.setLens is deprecated. Use .setFocalLength and .filmGauge for a photographic setup."),void 0!==t&&(this.filmGauge=t),this.setFocalLength(n)},Object.defineProperties(al.prototype,{onlyShadow:{set:function(){console.warn("THREE.Light: .onlyShadow has been removed.")}},shadowCameraFov:{set:function(n){console.warn("THREE.Light: .shadowCameraFov is now .shadow.camera.fov."),this.shadow.camera.fov=n}},shadowCameraLeft:{set:function(n){console.warn("THREE.Light: .shadowCameraLeft is now .shadow.camera.left."),this.shadow.camera.left=n}},shadowCameraRight:{set:function(n){console.warn("THREE.Light: .shadowCameraRight is now .shadow.camera.right."),this.shadow.camera.right=n}},shadowCameraTop:{set:function(n){console.warn("THREE.Light: .shadowCameraTop is now .shadow.camera.top."),this.shadow.camera.top=n}},shadowCameraBottom:{set:function(n){console.warn("THREE.Light: .shadowCameraBottom is now .shadow.camera.bottom."),this.shadow.camera.bottom=n}},shadowCameraNear:{set:function(n){console.warn("THREE.Light: .shadowCameraNear is now .shadow.camera.near."),this.shadow.camera.near=n}},shadowCameraFar:{set:function(n){console.warn("THREE.Light: .shadowCameraFar is now .shadow.camera.far."),this.shadow.camera.far=n}},shadowCameraVisible:{set:function(){console.warn("THREE.Light: .shadowCameraVisible has been removed. Use new THREE.CameraHelper( light.shadow.camera ) instead.")}},shadowBias:{set:function(n){console.warn("THREE.Light: .shadowBias is now .shadow.bias."),this.shadow.bias=n}},shadowDarkness:{set:function(){console.warn("THREE.Light: .shadowDarkness has been removed.")}},shadowMapWidth:{set:function(n){console.warn("THREE.Light: .shadowMapWidth is now .shadow.mapSize.width."),this.shadow.mapSize.width=n}},shadowMapHeight:{set:function(n){console.warn("THREE.Light: .shadowMapHeight is now .shadow.mapSize.height."),this.shadow.mapSize.height=n}}}),Object.defineProperties(Pr.prototype,{length:{get:function(){return console.warn("THREE.BufferAttribute: .length has been deprecated. Use .count instead."),this.array.length}},dynamic:{get:function(){return console.warn("THREE.BufferAttribute: .dynamic has been deprecated. Use .usage instead."),this.usage===xI},set:function(){console.warn("THREE.BufferAttribute: .dynamic has been deprecated. Use .usage instead."),this.setUsage(xI)}}}),Pr.prototype.setDynamic=function(n){return console.warn("THREE.BufferAttribute: .setDynamic() has been deprecated. Use .setUsage() instead."),this.setUsage(!0===n?xI:Cx),this},Pr.prototype.copyIndicesArray=function(){console.error("THREE.BufferAttribute: .copyIndicesArray() has been removed.")},Pr.prototype.setArray=function(){console.error("THREE.BufferAttribute: .setArray has been removed. Use BufferGeometry .setAttribute to replace/resize attribute buffers")},Ui.prototype.addIndex=function(n){console.warn("THREE.BufferGeometry: .addIndex() has been renamed to .setIndex()."),this.setIndex(n)},Ui.prototype.addAttribute=function(n,t){return console.warn("THREE.BufferGeometry: .addAttribute() has been renamed to .setAttribute()."),t&&t.isBufferAttribute||t&&t.isInterleavedBufferAttribute?"index"===n?(console.warn("THREE.BufferGeometry.addAttribute: Use .setIndex() for index attribute."),this.setIndex(t),this):this.setAttribute(n,t):(console.warn("THREE.BufferGeometry: .addAttribute() now expects ( name, attribute )."),this.setAttribute(n,new Pr(arguments[1],arguments[2])))},Ui.prototype.addDrawCall=function(n,t,e){void 0!==e&&console.warn("THREE.BufferGeometry: .addDrawCall() no longer supports indexOffset."),console.warn("THREE.BufferGeometry: .addDrawCall() is now .addGroup()."),this.addGroup(n,t)},Ui.prototype.clearDrawCalls=function(){console.warn("THREE.BufferGeometry: .clearDrawCalls() is now .clearGroups()."),this.clearGroups()},Ui.prototype.computeOffsets=function(){console.warn("THREE.BufferGeometry: .computeOffsets() has been removed.")},Ui.prototype.removeAttribute=function(n){return console.warn("THREE.BufferGeometry: .removeAttribute() has been renamed to .deleteAttribute()."),this.deleteAttribute(n)},Ui.prototype.applyMatrix=function(n){return console.warn("THREE.BufferGeometry: .applyMatrix() has been renamed to .applyMatrix4()."),this.applyMatrix4(n)},Object.defineProperties(Ui.prototype,{drawcalls:{get:function(){return console.error("THREE.BufferGeometry: .drawcalls has been renamed to .groups."),this.groups}},offsets:{get:function(){return console.warn("THREE.BufferGeometry: .offsets has been renamed to .groups."),this.groups}}}),hm.prototype.setDynamic=function(n){return console.warn("THREE.InterleavedBuffer: .setDynamic() has been deprecated. Use .setUsage() instead."),this.setUsage(!0===n?xI:Cx),this},hm.prototype.setArray=function(){console.error("THREE.InterleavedBuffer: .setArray has been removed. Use BufferGeometry .setAttribute to replace/resize attribute buffers")},Cp.prototype.getArrays=function(){console.error("THREE.ExtrudeGeometry: .getArrays() has been removed.")},Cp.prototype.addShapeList=function(){console.error("THREE.ExtrudeGeometry: .addShapeList() has been removed.")},Cp.prototype.addShape=function(){console.error("THREE.ExtrudeGeometry: .addShape() has been removed.")},J0.prototype.dispose=function(){console.error("THREE.Scene: .dispose() has been removed.")},Gx.prototype.onUpdate=function(){return console.warn("THREE.Uniform: .onUpdate() has been removed. Use object.onBeforeRender() instead."),this},Object.defineProperties(Ao.prototype,{wrapAround:{get:function(){console.warn("THREE.Material: .wrapAround has been removed.")},set:function(){console.warn("THREE.Material: .wrapAround has been removed.")}},overdraw:{get:function(){console.warn("THREE.Material: .overdraw has been removed.")},set:function(){console.warn("THREE.Material: .overdraw has been removed.")}},wrapRGB:{get:function(){return console.warn("THREE.Material: .wrapRGB has been removed."),new an}},shading:{get:function(){console.error("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead.")},set:function(n){console.warn("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead."),this.flatShading=1===n}},stencilMask:{get:function(){return console.warn("THREE."+this.type+": .stencilMask has been removed. Use .stencilFuncMask instead."),this.stencilFuncMask},set:function(n){console.warn("THREE."+this.type+": .stencilMask has been removed. Use .stencilFuncMask instead."),this.stencilFuncMask=n}},vertexTangents:{get:function(){console.warn("THREE."+this.type+": .vertexTangents has been removed.")},set:function(){console.warn("THREE."+this.type+": .vertexTangents has been removed.")}}}),Object.defineProperties(Gd.prototype,{derivatives:{get:function(){return console.warn("THREE.ShaderMaterial: .derivatives has been moved to .extensions.derivatives."),this.extensions.derivatives},set:function(n){console.warn("THREE. ShaderMaterial: .derivatives has been moved to .extensions.derivatives."),this.extensions.derivatives=n}}}),ji.prototype.clearTarget=function(n,t,e,i){console.warn("THREE.WebGLRenderer: .clearTarget() has been deprecated. Use .setRenderTarget() and .clear() instead."),this.setRenderTarget(n),this.clear(t,e,i)},ji.prototype.animate=function(n){console.warn("THREE.WebGLRenderer: .animate() is now .setAnimationLoop()."),this.setAnimationLoop(n)},ji.prototype.getCurrentRenderTarget=function(){return console.warn("THREE.WebGLRenderer: .getCurrentRenderTarget() is now .getRenderTarget()."),this.getRenderTarget()},ji.prototype.getMaxAnisotropy=function(){return console.warn("THREE.WebGLRenderer: .getMaxAnisotropy() is now .capabilities.getMaxAnisotropy()."),this.capabilities.getMaxAnisotropy()},ji.prototype.getPrecision=function(){return console.warn("THREE.WebGLRenderer: .getPrecision() is now .capabilities.precision."),this.capabilities.precision},ji.prototype.resetGLState=function(){return console.warn("THREE.WebGLRenderer: .resetGLState() is now .state.reset()."),this.state.reset()},ji.prototype.supportsFloatTextures=function(){return console.warn("THREE.WebGLRenderer: .supportsFloatTextures() is now .extensions.get( 'OES_texture_float' )."),this.extensions.get("OES_texture_float")},ji.prototype.supportsHalfFloatTextures=function(){return console.warn("THREE.WebGLRenderer: .supportsHalfFloatTextures() is now .extensions.get( 'OES_texture_half_float' )."),this.extensions.get("OES_texture_half_float")},ji.prototype.supportsStandardDerivatives=function(){return console.warn("THREE.WebGLRenderer: .supportsStandardDerivatives() is now .extensions.get( 'OES_standard_derivatives' )."),this.extensions.get("OES_standard_derivatives")},ji.prototype.supportsCompressedTextureS3TC=function(){return console.warn("THREE.WebGLRenderer: .supportsCompressedTextureS3TC() is now .extensions.get( 'WEBGL_compressed_texture_s3tc' )."),this.extensions.get("WEBGL_compressed_texture_s3tc")},ji.prototype.supportsCompressedTexturePVRTC=function(){return console.warn("THREE.WebGLRenderer: .supportsCompressedTexturePVRTC() is now .extensions.get( 'WEBGL_compressed_texture_pvrtc' )."),this.extensions.get("WEBGL_compressed_texture_pvrtc")},ji.prototype.supportsBlendMinMax=function(){return console.warn("THREE.WebGLRenderer: .supportsBlendMinMax() is now .extensions.get( 'EXT_blend_minmax' )."),this.extensions.get("EXT_blend_minmax")},ji.prototype.supportsVertexTextures=function(){return console.warn("THREE.WebGLRenderer: .supportsVertexTextures() is now .capabilities.vertexTextures."),this.capabilities.vertexTextures},ji.prototype.supportsInstancedArrays=function(){return console.warn("THREE.WebGLRenderer: .supportsInstancedArrays() is now .extensions.get( 'ANGLE_instanced_arrays' )."),this.extensions.get("ANGLE_instanced_arrays")},ji.prototype.enableScissorTest=function(n){console.warn("THREE.WebGLRenderer: .enableScissorTest() is now .setScissorTest()."),this.setScissorTest(n)},ji.prototype.initMaterial=function(){console.warn("THREE.WebGLRenderer: .initMaterial() has been removed.")},ji.prototype.addPrePlugin=function(){console.warn("THREE.WebGLRenderer: .addPrePlugin() has been removed.")},ji.prototype.addPostPlugin=function(){console.warn("THREE.WebGLRenderer: .addPostPlugin() has been removed.")},ji.prototype.updateShadowMap=function(){console.warn("THREE.WebGLRenderer: .updateShadowMap() has been removed.")},ji.prototype.setFaceCulling=function(){console.warn("THREE.WebGLRenderer: .setFaceCulling() has been removed.")},ji.prototype.allocTextureUnit=function(){console.warn("THREE.WebGLRenderer: .allocTextureUnit() has been removed.")},ji.prototype.setTexture=function(){console.warn("THREE.WebGLRenderer: .setTexture() has been removed.")},ji.prototype.setTexture2D=function(){console.warn("THREE.WebGLRenderer: .setTexture2D() has been removed.")},ji.prototype.setTextureCube=function(){console.warn("THREE.WebGLRenderer: .setTextureCube() has been removed.")},ji.prototype.getActiveMipMapLevel=function(){return console.warn("THREE.WebGLRenderer: .getActiveMipMapLevel() is now .getActiveMipmapLevel()."),this.getActiveMipmapLevel()},Object.defineProperties(ji.prototype,{shadowMapEnabled:{get:function(){return this.shadowMap.enabled},set:function(n){console.warn("THREE.WebGLRenderer: .shadowMapEnabled is now .shadowMap.enabled."),this.shadowMap.enabled=n}},shadowMapType:{get:function(){return this.shadowMap.type},set:function(n){console.warn("THREE.WebGLRenderer: .shadowMapType is now .shadowMap.type."),this.shadowMap.type=n}},shadowMapCullFace:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMapCullFace has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMapCullFace has been removed. Set Material.shadowSide instead.")}},context:{get:function(){return console.warn("THREE.WebGLRenderer: .context has been removed. Use .getContext() instead."),this.getContext()}},vr:{get:function(){return console.warn("THREE.WebGLRenderer: .vr has been renamed to .xr"),this.xr}},gammaInput:{get:function(){return console.warn("THREE.WebGLRenderer: .gammaInput has been removed. Set the encoding for textures via Texture.encoding instead."),!1},set:function(){console.warn("THREE.WebGLRenderer: .gammaInput has been removed. Set the encoding for textures via Texture.encoding instead.")}},gammaOutput:{get:function(){return console.warn("THREE.WebGLRenderer: .gammaOutput has been removed. Set WebGLRenderer.outputEncoding instead."),!1},set:function(n){console.warn("THREE.WebGLRenderer: .gammaOutput has been removed. Set WebGLRenderer.outputEncoding instead."),this.outputEncoding=!0===n?Ar:_p}},toneMappingWhitePoint:{get:function(){return console.warn("THREE.WebGLRenderer: .toneMappingWhitePoint has been removed."),1},set:function(){console.warn("THREE.WebGLRenderer: .toneMappingWhitePoint has been removed.")}},gammaFactor:{get:function(){return console.warn("THREE.WebGLRenderer: .gammaFactor has been removed."),2},set:function(){console.warn("THREE.WebGLRenderer: .gammaFactor has been removed.")}}}),Object.defineProperties(ste.prototype,{cullFace:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMap.cullFace has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMap.cullFace has been removed. Set Material.shadowSide instead.")}},renderReverseSided:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderReverseSided has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderReverseSided has been removed. Set Material.shadowSide instead.")}},renderSingleSided:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderSingleSided has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderSingleSided has been removed. Set Material.shadowSide instead.")}}}),Object.defineProperties(Js.prototype,{wrapS:{get:function(){return console.warn("THREE.WebGLRenderTarget: .wrapS is now .texture.wrapS."),this.texture.wrapS},set:function(n){console.warn("THREE.WebGLRenderTarget: .wrapS is now .texture.wrapS."),this.texture.wrapS=n}},wrapT:{get:function(){return console.warn("THREE.WebGLRenderTarget: .wrapT is now .texture.wrapT."),this.texture.wrapT},set:function(n){console.warn("THREE.WebGLRenderTarget: .wrapT is now .texture.wrapT."),this.texture.wrapT=n}},magFilter:{get:function(){return console.warn("THREE.WebGLRenderTarget: .magFilter is now .texture.magFilter."),this.texture.magFilter},set:function(n){console.warn("THREE.WebGLRenderTarget: .magFilter is now .texture.magFilter."),this.texture.magFilter=n}},minFilter:{get:function(){return console.warn("THREE.WebGLRenderTarget: .minFilter is now .texture.minFilter."),this.texture.minFilter},set:function(n){console.warn("THREE.WebGLRenderTarget: .minFilter is now .texture.minFilter."),this.texture.minFilter=n}},anisotropy:{get:function(){return console.warn("THREE.WebGLRenderTarget: .anisotropy is now .texture.anisotropy."),this.texture.anisotropy},set:function(n){console.warn("THREE.WebGLRenderTarget: .anisotropy is now .texture.anisotropy."),this.texture.anisotropy=n}},offset:{get:function(){return console.warn("THREE.WebGLRenderTarget: .offset is now .texture.offset."),this.texture.offset},set:function(n){console.warn("THREE.WebGLRenderTarget: .offset is now .texture.offset."),this.texture.offset=n}},repeat:{get:function(){return console.warn("THREE.WebGLRenderTarget: .repeat is now .texture.repeat."),this.texture.repeat},set:function(n){console.warn("THREE.WebGLRenderTarget: .repeat is now .texture.repeat."),this.texture.repeat=n}},format:{get:function(){return console.warn("THREE.WebGLRenderTarget: .format is now .texture.format."),this.texture.format},set:function(n){console.warn("THREE.WebGLRenderTarget: .format is now .texture.format."),this.texture.format=n}},type:{get:function(){return console.warn("THREE.WebGLRenderTarget: .type is now .texture.type."),this.texture.type},set:function(n){console.warn("THREE.WebGLRenderTarget: .type is now .texture.type."),this.texture.type=n}},generateMipmaps:{get:function(){return console.warn("THREE.WebGLRenderTarget: .generateMipmaps is now .texture.generateMipmaps."),this.texture.generateMipmaps},set:function(n){console.warn("THREE.WebGLRenderTarget: .generateMipmaps is now .texture.generateMipmaps."),this.texture.generateMipmaps=n}}}),class extends Bi{constructor(t){super(),this.type="Audio",this.listener=t,this.context=t.context,this.gain=this.context.createGain(),this.gain.connect(t.getInput()),this.autoplay=!1,this.buffer=null,this.detune=0,this.loop=!1,this.loopStart=0,this.loopEnd=0,this.offset=0,this.duration=void 0,this.playbackRate=1,this.isPlaying=!1,this.hasPlaybackControl=!0,this.source=null,this.sourceType="empty",this._startedAt=0,this._progress=0,this._connected=!1,this.filters=[]}getOutput(){return this.gain}setNodeSource(t){return this.hasPlaybackControl=!1,this.sourceType="audioNode",this.source=t,this.connect(),this}setMediaElementSource(t){return this.hasPlaybackControl=!1,this.sourceType="mediaNode",this.source=this.context.createMediaElementSource(t),this.connect(),this}setMediaStreamSource(t){return this.hasPlaybackControl=!1,this.sourceType="mediaStreamNode",this.source=this.context.createMediaStreamSource(t),this.connect(),this}setBuffer(t){return this.buffer=t,this.sourceType="buffer",this.autoplay&&this.play(),this}play(t=0){if(!0===this.isPlaying)return void console.warn("THREE.Audio: Audio is already playing.");if(!1===this.hasPlaybackControl)return void console.warn("THREE.Audio: this Audio has no playback control.");this._startedAt=this.context.currentTime+t;let e=this.context.createBufferSource();return e.buffer=this.buffer,e.loop=this.loop,e.loopStart=this.loopStart,e.loopEnd=this.loopEnd,e.onended=this.onEnded.bind(this),e.start(this._startedAt,this._progress+this.offset,this.duration),this.isPlaying=!0,this.source=e,this.setDetune(this.detune),this.setPlaybackRate(this.playbackRate),this.connect()}pause(){if(!1!==this.hasPlaybackControl)return!0===this.isPlaying&&(this._progress+=Math.max(this.context.currentTime-this._startedAt,0)*this.playbackRate,!0===this.loop&&(this._progress=this._progress%(this.duration||this.buffer.duration)),this.source.stop(),this.source.onended=null,this.isPlaying=!1),this;console.warn("THREE.Audio: this Audio has no playback control.")}stop(){if(!1!==this.hasPlaybackControl)return this._progress=0,this.source.stop(),this.source.onended=null,this.isPlaying=!1,this;console.warn("THREE.Audio: this Audio has no playback control.")}connect(){if(this.filters.length>0){this.source.connect(this.filters[0]);for(let t=1,e=this.filters.length;t<e;t++)this.filters[t-1].connect(this.filters[t]);this.filters[this.filters.length-1].connect(this.getOutput())}else this.source.connect(this.getOutput());return this._connected=!0,this}disconnect(){if(this.filters.length>0){this.source.disconnect(this.filters[0]);for(let t=1,e=this.filters.length;t<e;t++)this.filters[t-1].disconnect(this.filters[t]);this.filters[this.filters.length-1].disconnect(this.getOutput())}else this.source.disconnect(this.getOutput());return this._connected=!1,this}getFilters(){return this.filters}setFilters(t){return t||(t=[]),!0===this._connected?(this.disconnect(),this.filters=t.slice(),this.connect()):this.filters=t.slice(),this}setDetune(t){if(this.detune=t,void 0!==this.source.detune)return!0===this.isPlaying&&this.source.detune.setTargetAtTime(this.detune,this.context.currentTime,.01),this}getDetune(){return this.detune}getFilter(){return this.getFilters()[0]}setFilter(t){return this.setFilters(t?[t]:[])}setPlaybackRate(t){if(!1!==this.hasPlaybackControl)return this.playbackRate=t,!0===this.isPlaying&&this.source.playbackRate.setTargetAtTime(this.playbackRate,this.context.currentTime,.01),this;console.warn("THREE.Audio: this Audio has no playback control.")}getPlaybackRate(){return this.playbackRate}onEnded(){this.isPlaying=!1}getLoop(){return!1===this.hasPlaybackControl?(console.warn("THREE.Audio: this Audio has no playback control."),!1):this.loop}setLoop(t){if(!1!==this.hasPlaybackControl)return this.loop=t,!0===this.isPlaying&&(this.source.loop=this.loop),this;console.warn("THREE.Audio: this Audio has no playback control.")}setLoopStart(t){return this.loopStart=t,this}setLoopEnd(t){return this.loopEnd=t,this}getVolume(){return this.gain.gain.value}setVolume(t){return this.gain.gain.setTargetAtTime(t,this.context.currentTime,.01),this}}.prototype.load=function(n){console.warn("THREE.Audio: .load has been deprecated. Use THREE.AudioLoader instead.");let t=this;return(new QB).load(n,function(i){t.setBuffer(i)}),this},Ex.prototype.updateCubeMap=function(n,t){return console.warn("THREE.CubeCamera: .updateCubeMap() is now .update()."),this.update(n,t)},Ex.prototype.clear=function(n,t,e,i){return console.warn("THREE.CubeCamera: .clear() is now .renderTarget.clear()."),this.renderTarget.clear(n,t,e,i)},jd.crossOrigin=void 0,jd.loadTexture=function(n,t,e,i){console.warn("THREE.ImageUtils.loadTexture has been deprecated. Use THREE.TextureLoader() instead.");let r=new VB;r.setCrossOrigin(this.crossOrigin);let o=r.load(n,e,void 0,i);return t&&(o.mapping=t),o},jd.loadTextureCube=function(n,t,e,i){console.warn("THREE.ImageUtils.loadTextureCube has been deprecated. Use THREE.CubeTextureLoader() instead.");let r=new BB;r.setCrossOrigin(this.crossOrigin);let o=r.load(n,e,void 0,i);return t&&(o.mapping=t),o},jd.loadCompressedTexture=function(){console.error("THREE.ImageUtils.loadCompressedTexture has been removed. Use THREE.DDSLoader instead.")},jd.loadCompressedTextureCube=function(){console.error("THREE.ImageUtils.loadCompressedTextureCube has been removed. Use THREE.DDSLoader instead.")},typeof __THREE_DEVTOOLS__<"u"&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("register",{detail:{revision:dV}})),typeof window<"u"&&(window.__THREE__?console.warn("WARNING: Multiple instances of Three.js being imported."):window.__THREE__=dV);var $l=(()=>(function(n){n[n.CIRCLE=0]="CIRCLE",n[n.LINE=1]="LINE",n[n.TRIANGLE=2]="TRIANGLE",n[n.TRAPEZOID=3]="TRAPEZOID"}($l||($l={})),$l))();function mte(n,t){let e=t.length/2,i=n.attributes.position;(!i||i.count!==3*e)&&(i=new Pr(new Float32Array(3*e),3),n.setAttribute("position",i));let r=i.array;for(let o=0;o<e;o++)r[3*o]=t[2*o],r[3*o+1]=t[2*o+1];i.needsUpdate=!0,n.setDrawRange(0,3*e),n.computeBoundingSphere()}function hte(n,t,e){let i=Math.max(t.length/2-1,0),r=2*i*3,o=3*r,s=n.attributes.position;(!s||s.count!==r)&&(s=new Pr(new Float32Array(o),3),n.setAttribute("position",s));let a=s.array;for(let l=0;l<i;l++){let[c,d,u,p]=[t[2*l],t[2*l+1],t[2*l+2],t[2*l+3]],f=new $e(c,d),m=new $e(u,p),b=new $e(u-c,p-d),M=new $e(-b.y,b.x).setLength(e/2),y=f.clone().add(M),x=f.clone().sub(M),R=m.clone().add(M),A=m.clone().sub(M),V=[y.x,y.y,0,x.x,x.y,0,R.x,R.y,0,R.x,R.y,0,x.x,x.y,0,A.x,A.y,0];a.set(V,l*V.length)}s.needsUpdate=!0,n.setDrawRange(0,o),n.computeBoundingSphere()}function JI(n,t,e,i){let{visible:r,color:o,opacity:s}=i;if(Array.isArray(t.material))throw new Error("Invariant error: only expect one material on an object");let a=t.material;if(a.visible!==r&&(a.visible=r,a.needsUpdate=!0),!r)return!1;let l=_V(n,o,s??1),c=e(t.geometry);return t.geometry!==c&&(t.geometry=c),a.color.equals(l)||(a.color.set(l),a.needsUpdate=!0),!0}var eA=class{constructor(t){this.rawSeriesData=[],this.series=[],this.paintDirty=!0,this.renderCache=new class{constructor(){this.prevFrameCache=new Map,this.currFrameCache=new Map}getFromPreviousFrame(t){return this.prevFrameCache.get(t)??null}setToCurrentFrame(t,e){this.currFrameCache.set(t,e)}finalizeFrameAndGetRemoved(){let t=[];for(let[e,i]of this.prevFrameCache.entries())this.currFrameCache.has(e)||t.push(i);return this.prevFrameCache=this.currFrameCache,this.currFrameCache=new Map,t}},this.coordinateIdentifier=null,this.layout={x:0,width:1,y:0,height:1},this.getMetadataMapImpl=t.getMetadataMap,this.coordinator=t.coordinator,this.renderer=t.renderer,this.paintBrush=new class{constructor(t,e){this.renderCache=t,this.renderer=e}setLine(t,e,i){let r=this.renderer.createOrUpdateLineObject(this.renderCache.getFromPreviousFrame(t),e,i);r&&this.renderCache.setToCurrentFrame(t,r)}setTriangle(t,e,i){let r=this.renderer.createOrUpdateTriangleObject(this.renderCache.getFromPreviousFrame(t),e,i);r&&this.renderCache.setToCurrentFrame(t,r)}setCircle(t,e,i){let r=this.renderer.createOrUpdateCircleObject(this.renderCache.getFromPreviousFrame(t),e,i);r&&this.renderCache.setToCurrentFrame(t,r)}setTrapezoid(t,e,i,r){let o=this.renderer.createOrUpdateTrapezoidObject(this.renderCache.getFromPreviousFrame(t),e,i,r);o&&this.renderCache.setToCurrentFrame(t,o)}}(this.renderCache,this.renderer)}setLayoutRect(t){(this.layout.x!==t.x||this.layout.width!==t.width||this.layout.y!==t.y||this.layout.height!==t.height)&&(this.paintDirty=!0),this.layout=t}getLayoutRect(){return this.layout}getMetadataMap(){return this.getMetadataMapImpl()}markAsPaintDirty(){this.paintDirty=!0}render(){if(this.transformCoordinatesIfStale(),this.paintDirty){this.redraw();for(let t of this.renderCache.finalizeFrameAndGetRemoved())this.renderer.destroyObject(t);this.paintDirty=!1}}isCoordinateUpdated(){return this.coordinator.getUpdateIdentifier()!==this.coordinateIdentifier}clearCoordinateIdentifier(){this.coordinateIdentifier=null}setData(t){this.clearCoordinateIdentifier(),this.rawSeriesData=t}transformCoordinatesIfStale(){if(!this.isCoordinateUpdated())return;let t=this.getLayoutRect();this.series=new Array(this.rawSeriesData.length);for(let e=0;e<this.rawSeriesData.length;e++){let i=this.rawSeriesData[e];this.series[e]={id:i.id,polyline:new Float32Array(2*i.points.length)};for(let r=0;r<i.points.length;r++){let[o,s]=this.coordinator.transformDataToUiCoord(t,[i.points[r].x,i.points[r].y]);this.series[e].polyline[2*r]=o,this.series[e].polyline[2*r+1]=s}}this.coordinateIdentifier=this.coordinator.getUpdateIdentifier(),this.markAsPaintDirty()}},a_=(()=>(function(n){n[n.NUMBER=0]="NUMBER",n[n.NAN=1]="NAN"}(a_||(a_={})),a_))(),tA=class extends eA{recordPartition(t,e,i){return t?{type:a_.NUMBER,polyline:e}:{type:a_.NAN,polyline:e.map((r,o)=>isNaN(r)?o%2==0?i.x:i.y:r)}}partitionPolyline(t){let e=[],i=0,r=!1,o=this.coordinator.transformDataToUiCoord(this.getLayoutRect(),[0,0]),s={x:o[0],y:o[1]},a=null;for(let l=0;l<t.length;l+=2){let c=t[l],d=t[l+1],u=isNaN(c)||isNaN(d);u!==r&&i!==l&&(e.push(this.recordPartition(!r,t.slice(i,l),null===a?{x:c,y:d}:a)),i=l),u||(a={x:c,y:d}),r=u}return i!==t.length-1&&e.push(this.recordPartition(!r,t.slice(i,t.length),a??s)),e}redraw(){for(let t of this.series){let i=this.getMetadataMap()[t.id];if(!i)continue;if(t.polyline.length%2!=0)throw new Error(`Cannot have odd length-ed polyline: ${t.polyline.length}`);let r=this.partitionPolyline(t.polyline);for(let[o,{type:s,polyline:a}]of r.entries())if(s===a_.NUMBER)2===a.length?this.paintBrush.setCircle(JSON.stringify(["circle",t.id,o]),{x:a[0],y:a[1]},{color:i.color,visible:i.visible,opacity:i.opacity??1,radius:4}):this.paintBrush.setLine(JSON.stringify(["line",t.id,o]),a,{color:i.color,visible:i.visible,opacity:i.opacity??1,width:2});else if(!i.aux)for(let l=0;l<a.length;l+=2)this.paintBrush.setTriangle(JSON.stringify(["NaN",t.id,a[l],a[l+1]]),{x:a[l],y:a[l+1]},{color:i.color,visible:i.visible,opacity:i.opacity??1,size:12})}}},nA=class extends b0{constructor(){super(...arguments),this.camera=new mm(0,1e3,1e3,0,0,100)}isYAxisPointedDown(){return!1}setDomContainerRect(t){super.setDomContainerRect(t),this.camera.left=t.x,this.camera.right=t.x+t.width,this.camera.top=t.y+t.height,this.camera.bottom=t.y,this.camera.updateProjectionMatrix()}getCamera(){return this.camera}},iA=class{constructor(t){switch(this.metadataMap={},this.shouldRepaint=!1,this.callbacks=t.callbacks,t.type){case Qi.SVG:this.coordinator=new b0,this.renderer=new class{constructor(t){this.svg=t}flush(){}onResize(t){}destroyObject(t){this.svg.removeChild(t.dom)}setUseDarkMode(t){}createPathDString(t){if(!t.length)return"";let e=new Array(t.length/2);e[0]=`M${t[0]},${t[1]}`;for(let i=1;i<t.length/2;i++)e[i]=`L${t[2*i]},${t[2*i+1]}`;return e.join("")}createOrUpdateLineObject(t,e,i){let r=LD(t?.dom,()=>{let o=document.createElementNS("http://www.w3.org/2000/svg","path");o.style.fill="none";let s=this.createPathDString(e);return o.setAttribute("d",s),this.svg.appendChild(o),o},o=>{if(!t?.data||!Yl_arePolylinesEqual(e,t?.data)){let s=this.createPathDString(e);o.setAttribute("d",s)}return o},i);return null===r?null:(r.style.strokeWidth=String(i.width),{dom:r,data:e})}createOrUpdateTriangleObject(t,e,i){let{size:r,color:o}=i,s=r*Math.sqrt(3)/2,a=new Float32Array([e.x-r/2,e.y+s/3,e.x+r/2,e.y+s/3,e.x,e.y-2*s/3]),l=LD(t?.dom,()=>{let c=document.createElementNS("http://www.w3.org/2000/svg","path");c.classList.add("triangle"),c.style.fill="none";let d=this.createPathDString(a);return c.setAttribute("d",d+"Z"),this.svg.appendChild(c),c},c=>{let d=this.createPathDString(a);return c.setAttribute("d",d+"Z"),c},i);return null===l?null:(l.style.fill=o,{dom:l,data:a})}createOrUpdateCircleObject(t,e,i){let{color:r,radius:o}=i,s=LD(t?.dom,()=>{let a=document.createElementNS("http://www.w3.org/2000/svg","circle");return a.style.fill=r,a.setAttribute("cx",String(e.x)),a.setAttribute("cy",String(e.y)),a.setAttribute("r",String(o)),this.svg.appendChild(a),a},a=>(a.style.fill=r,a.setAttribute("cx",String(e.x)),a.setAttribute("cy",String(e.y)),a.setAttribute("r",String(o)),a),i);return null===s?null:{dom:s,data:e}}createOrUpdateTrapezoidObject(t,e,i,r){if(e.y!==i.y)throw new RangeError("Input error: start.y != end.y.");let{altitude:o,color:s}=r,a=2/Math.sqrt(3)*o,l=new Float32Array([e.x-a/2,e.y+o/2,e.x,e.y-o/2,i.x,i.y-o/2,i.x+a/2,i.y+o/2]),c=LD(t?.dom,()=>{let d=document.createElementNS("http://www.w3.org/2000/svg","path");d.classList.add("trapezoid"),d.style.fill="none";let u=this.createPathDString(l);return d.setAttribute("d",u+"Z"),this.svg.appendChild(d),d},d=>{let u=this.createPathDString(l);return d.setAttribute("d",u+"Z"),d},r);return null===c?null:(c.style.fill=s,{dom:c,data:l})}dispose(){}}(t.container);break;case Qi.WEBGL:{let e=new nA;this.coordinator=e,this.renderer=new class{constructor(t,e,i,r){this.coordinator=e,this.scene=new J0,this.backgroundColor="#fff",Yl_isWebGl2OffscreenCanvasSupported()&&t instanceof OffscreenCanvas&&(t.style=t.style||{}),r&&t.addEventListener("webglcontextlost",r),this.renderer=new ji({canvas:t,antialias:!0,alpha:!0}),this.renderer.setPixelRatio(i)}onResize(t){this.renderer.setSize(t.width,t.height)}destroyObject(t){let e=t.obj3d;if(this.scene.remove(e),e instanceof ao){e.geometry.dispose();let i=Array.isArray(e.material)?e.material:[e.material];for(let r of i)r.dispose()}}setUseDarkMode(t){this.backgroundColor=t?"#303030":"#fff"}createOrUpdateLineObject(t,e,i){if(!t&&!i.visible)return null;let{visible:r,width:o}=i;if(!t){let d=_V(this.backgroundColor,i.color,i.opacity??1),u=new Ui,p=new Wd({color:d}),f=new ao(u,p);return p.visible=r,hte(u,e,o),this.scene.add(f),{type:$l.LINE,data:e,obj3d:f,width:o}}let{data:s,obj3d:a,width:l}=t;return JI(this.backgroundColor,a,d=>((o!==l||!s||!Yl_arePolylinesEqual(s,e))&&hte(d,e,o),d),i)?{type:$l.LINE,data:e,obj3d:a,width:o}:t}createMesh(t,e){if(!e.visible)return null;let{visible:i,color:r,opacity:o}=e,s=_V(this.backgroundColor,r,o??1),a=new pm({color:s,visible:i});return new ao(t,a)}createOrUpdateTriangleObject(t,e,i){let{size:r}=i,o=r*Math.sqrt(3)/2,s=new Float32Array([e.x-r/2,e.y-o/3,e.x+r/2,e.y-o/3,e.x,e.y+2*o/3]);if(!t){let l=new Ui;mte(l,s);let c=this.createMesh(l,i);return null===c?null:(this.scene.add(c),{type:$l.TRIANGLE,data:e,obj3d:c})}return JI(this.backgroundColor,t.obj3d,l=>(mte(l,s),l),i)?{type:$l.TRIANGLE,data:e,obj3d:t.obj3d}:t}createOrUpdateCircleObject(t,e,i){let{radius:r}=i,o=new $0(i.radius);if(!t){let a=this.createMesh(o,i);return null===a?null:(a.position.set(e.x,e.y,0),this.scene.add(a),{type:$l.CIRCLE,data:{loc:e,radius:r},obj3d:a})}return JI(this.backgroundColor,t.obj3d,()=>o,i)?(t.obj3d.position.set(e.x,e.y,0),{type:$l.CIRCLE,data:{loc:e,radius:r},obj3d:t.obj3d}):t}createOrUpdateTrapezoidObject(t,e,i,r){if(e.y!==i.y)throw new RangeError("Input error: start.y != end.y.");let{altitude:o}=r,s=2/Math.sqrt(3)*o,a=new qd([new $e(e.x-s/2,e.y-o/2),new $e(e.x,e.y+o/2),new $e(i.x,i.y+o/2),new $e(i.x+s/2,i.y-o/2)]);a.autoClose=!0;let l=new _m(a);if(!t){let d=this.createMesh(l,r);return null===d?null:(this.scene.add(d),{type:$l.TRAPEZOID,data:[e,i],obj3d:d})}return JI(this.backgroundColor,t.obj3d,()=>l,r)?{type:$l.TRAPEZOID,data:[e,i],obj3d:t.obj3d}:t}flush(){this.renderer.render(this.scene,this.coordinator.getCamera())}dispose(){this.renderer.dispose()}}(t.container,e,t.devicePixelRatio,t.callbacks.onContextLost);break}}this.renderer.setUseDarkMode(t.useDarkMode),this.seriesLineView=new tA({renderer:this.renderer,coordinator:this.coordinator,getMetadataMap:()=>this.metadataMap}),this.resize(t.domDimension)}dispose(){}setXScaleType(t){this.coordinator.setXScale(ql(t)),this.scheduleRepaint()}setYScaleType(t){this.coordinator.setYScale(ql(t)),this.scheduleRepaint()}resize(t){this.coordinator.setDomContainerRect({x:0,y:0,...t}),this.renderer.onResize({x:0,y:0,...t}),this.seriesLineView.setLayoutRect({...t,x:0,y:0}),this.scheduleRepaint()}setMetadata(t){let e=!1;Object.entries(t).forEach(([i,r])=>{let o=this.metadataMap[i];(!o||r.color!==o.color||r.visible!==o.visible||r.opacity!==o.opacity)&&(e=!0),this.metadataMap[i]=r}),e&&this.seriesLineView.markAsPaintDirty(),this.scheduleRepaint()}setViewBox(t){this.coordinator.setViewBoxRect({x:t.x[0],width:t.x[1]-t.x[0],y:t.y[0],height:t.y[1]-t.y[0]}),this.scheduleRepaint()}setData(t){this.seriesLineView.setData(t),this.scheduleRepaint()}setUseDarkMode(t){this.renderer.setUseDarkMode(t),this.seriesLineView.markAsPaintDirty(),this.scheduleRepaint()}scheduleRepaint(){this.shouldRepaint||(this.shouldRepaint=!0,(n=>{self.requestAnimationFrame(n)})(()=>{this.repaint(),this.shouldRepaint=!1}))}repaint(){this.seriesLineView.render(),this.renderer.flush(),this.callbacks.onDrawEnd()}},Ca=(()=>(function(n){n[n.SERIES_DATA_UPDATED=0]="SERIES_DATA_UPDATED",n[n.SERIES_METADATA_CHANGED=1]="SERIES_METADATA_CHANGED",n[n.SCALE_UPDATED=2]="SCALE_UPDATED",n[n.VIEW_BOX_UPDATED=3]="VIEW_BOX_UPDATED",n[n.INIT=4]="INIT",n[n.DOM_RESIZED=5]="DOM_RESIZED",n[n.DARK_MODE_UPDATED=6]="DARK_MODE_UPDATED",n[n.DISPOSED=7]="DISPOSED"}(Ca||(Ca={})),Ca))(),l_=(()=>(function(n){n[n.ON_REDRAW_END=0]="ON_REDRAW_END",n[n.ON_CONTEXT_LOST=1]="ON_CONTEXT_LOST"}(l_||(l_={})),l_))();function _te(n){if(n.includes("/"))throw new RangeError("Worker factory only allows file name and no resource path.");return new Worker(n)}var ym=class{constructor(t){if(this.callbacks=t.callbacks,t.type!==Qi.WEBGL)throw new RangeError(`Cannot use non WEBGL renderer for the offscreen line chart. Received ${Qi[t.type]} `);let e=new MessageChannel;e.port1.onmessage=o=>{this.onMessageFromWorker(o.data)},this.txMessagePort=e.port1;let i=t.container.transferControlToOffscreen();this.workerInstance=ym.workerPool.getNext();let r={type:Ca.INIT,canvas:i,devicePixelRatio:window.devicePixelRatio,dim:t.domDimension,rendererType:t.type,useDarkMode:t.useDarkMode};this.workerInstance.postMessage(r,[i,e.port2])}dispose(){this.sendMessage({type:Ca.DISPOSED}),this.workerInstance.free(),this.txMessagePort.close()}setXScaleType(t){this.sendMessage({type:Ca.SCALE_UPDATED,axis:"x",scaleType:t})}setYScaleType(t){this.sendMessage({type:Ca.SCALE_UPDATED,axis:"y",scaleType:t})}resize(t){this.sendMessage({type:Ca.DOM_RESIZED,dim:t})}setMetadata(t){this.sendMessage({type:Ca.SERIES_METADATA_CHANGED,metadata:t})}setViewBox(t){this.sendMessage({type:Ca.VIEW_BOX_UPDATED,extent:t})}setData(t){let e=function(n){let t=n.reduce((o,s)=>o+s.points.length,0),e=0,i=new Float64Array(2*t),r=[];for(let o of n){r.push({id:o.id,length:o.points.length});for(let s=0;s<o.points.length;s++)i[e++]=o.points[s].x,i[e++]=o.points[s].y}return{idsAndLengths:r,flattenedSeries:i.buffer}}(t);this.sendMessage({type:Ca.SERIES_DATA_UPDATED,compactDataSeries:e},[e.flattenedSeries])}setUseDarkMode(t){this.sendMessage({type:Ca.DARK_MODE_UPDATED,useDarkMode:t})}sendMessage(t,e){e?this.txMessagePort.postMessage(t,e):this.txMessagePort.postMessage(t)}onMessageFromWorker(t){switch(t.type){case l_.ON_REDRAW_END:this.callbacks.onDrawEnd();break;case l_.ON_CONTEXT_LOST:this.callbacks.onContextLost()}}};function Zc(n,t){return"x"===t?[0,n.width]:[n.height,0]}function Xx(n,t){let e=Math.floor(n/50);return Math.min(e,t)}function oA(n,t,e,i){return{major:[],minor:n.ticks(i,e).map(o=>({value:o,tickFormattedString:t.formatTick(o)}))}}ym.workerPool=new class{constructor(t,e=10,i=_te){this.workerResourcePath=t,this.maxPoolSize=e,this.workerFactory=i,this.workers=[]}getNext(){let t;if(this.workers.every(({activeCount:i})=>i>0)&&this.workers.length<this.maxPoolSize){let i=this.workerFactory(this.workerResourcePath);t={activeCount:0,postMessage:(r,o)=>{i.postMessage(r,o)},free:()=>{t.activeCount=Math.max(t.activeCount-1,0)}},this.workers.push(t)}else{let i=this.workers.map(({activeCount:o})=>o),r=i.indexOf(Math.min(...i));t=this.workers[r]}return t.activeCount++,t}}("chart_worker.js?_file_hash=2c1e71c5");var vV=document.createElement("canvas").getContext("2d");function xte(n){for(let t of n)if(String(t).includes("e"))return!0;return!1}var Qx={getStandardTicks:oA,getTicksForTemporalScale:function(n,t,e,i){let[r,o]=i,s=n.ticks(i,2);if(o-r>=864e5||s.length>2)return oA(n,t,e,i);let a=n.ticks(i,e);return{major:s.map(l=>({start:l,tickFormattedString:t.formatShort(l)})),minor:a.map(l=>({value:l,tickFormattedString:t.formatTick(l)}))}},getTicksForLinearScale:function(n,t,e,i){let[r,o]=i,s=Math.abs(o-r);if(s>.001)return oA(n,t,e,i);let a=n.ticks([r,o],e),l=n.ticks([r,o],2);if(xte(a)||xte(l))return oA(n,t,e,i);let c=[],d=function(n){let t=n.toExponential().split("e-",2);return 2===t.length?Number(t[1])-1:0}(s);s<1&&l.every(f=>{let m=Math.abs(f);return m>=0&&m<1})&&(d+=1);let u=new Map;for(let f of l){let[m,b=""]=String(f).split(".",2),M=Number(m+"."+b.slice(0,d));u.set(M,{start:M,tickFormattedString:0===M?"\u2014":t.formatReadable(M)})}let p=10*Math.pow(10,-d);for(let f of a)for(let m of[...u.keys()].reverse()){let b=f-m;if(b>=0&&b<p){if(0===m)c.push({value:f,tickFormattedString:t.formatTick(f)});else{let M=String(f).slice(String(m).length);c.push({value:f,tickFormattedString:`\u2026${M||"0"}`})}break}}return{major:Array.from(u.values()),minor:c}},filterTicksByVisibility:function(n,t,e,i,r=5){if(!n.length||!vV)return n;let o="x"===e?1:-1,s=null;return n.filter(a=>{let l=t(a);vV.font=i;let c=vV.measureText(a.tickFormattedString),d="x"===e?c.width:c.actualBoundingBoxAscent-c.actualBoundingBoxDescent;return null===s?!(l+o*d<0||(s=l+o*d,0)):!(o*(s+o*r-l)>0||(s=l+o*d,0))})}};function Y2e(n,t){if(1&n&&(Nn(),h(0,"g",17)(1,"text"),T(2),g(),h(3,"title"),T(4),g()()),2&n){let e=t.$implicit,i=w();v(1),Tt("font",i.axisFont),Be("x",i.textXPosition(e.value))("y",i.textYPosition(e.value)),v(1),He(" ",e.tickFormattedString," "),v(2),bt(i.getFormatter().formatLong(e.value))}}function X2e(n,t){if(1&n&&(h(0,"span",20)(1,"span"),T(2),g()()),2&n){let e=t.$implicit,i=t.index,r=t.last,o=w(2);Tt("left",o.getMajorXPosition(e),"px")("width",o.getMajorWidthString(e,r,o.majorTicks[i+1]))("bottom",o.getMajorYPosition(e),"px")("height",o.getMajorHeightString(e,r,o.majorTicks[i+1]))("font",o.axisFont),nt("major-label",!0)("last",r),_("title",o.getFormatter().formatLong(e.start)),v(2),bt(e.tickFormattedString)}}function Q2e(n,t){if(1&n&&(h(0,"div",18),S(1,X2e,3,16,"span",19),g()),2&n){let e=w();v(1),_("ngForOf",e.majorTicks)("ngForTrackBy",e.trackByMajorTick)}}var Cte=(()=>{class n{constructor(){this.onViewExtentChange=new F,this.editMenuOpened=!1,this.majorTicks=[],this.minorTicks=[]}ngOnChanges(){let e=null,r=Xx("x"===this.axis?this.domDim.width:this.domDim.height,this.gridCount);e=this.scale instanceof nx?Qx.getTicksForLinearScale(this.scale,this.getFormatter(),r,this.axisExtent):this.scale instanceof ix?Qx.getTicksForTemporalScale(this.scale,this.getFormatter(),r,this.axisExtent):Qx.getStandardTicks(this.scale,this.getFormatter(),r,this.axisExtent),this.majorTicks=e.major,this.minorTicks=Qx.filterTicksByVisibility(e.minor,o=>this.getDomPos(o.value),this.axis,"11px Roboto, sans-serif")}getFormatter(){return this.customFormatter??this.scale.defaultFormatter}trackByMinorTick(e){return e.value}trackByMajorTick(e){return e.start}getDomPos(e){return this.scale.forward(this.axisExtent,Zc(this.domDim,this.axis),e)}textXPosition(e){return"x"===this.axis?String(this.getDomPos(e)):"100%"}textYPosition(e){return"x"===this.axis?"":String(this.getDomPos(e))}getMajorXPosition(e){return"y"===this.axis?0:Math.min(this.domDim.width,Math.max(0,this.getDomPos(e.start)))}getMajorWidthString(e,i,r){return"y"===this.axis?"":(i||!r?this.domDim.width:this.getMajorXPosition(r))-this.getMajorXPosition(e)+"px"}getMajorYPosition(e){return"x"===this.axis?0:this.domDim.height-Math.min(this.domDim.height,Math.max(0,this.getDomPos(e.start)))}getMajorHeightString(e,i,r){return"x"===this.axis?"":(i||!r?this.domDim.height:this.getMajorYPosition(r))-this.getMajorYPosition(e)+"px"}keydownPreventClose(e){"Escape"!==e.key&&e.stopPropagation()}extentChanged(e,i){let r=Number(e),o=Number(i);if(o<r){let s=r;r=o,o=s}!Number.isFinite(r)||!Number.isFinite(o)||this.onViewExtentChange.emit([r,o])}onAxisUpdateMenuOpen(e,i,r){e.value=String(r[0]),i.value=String(r[1]),e.focus()}setEditMenuOpened(e){this.editMenuOpened=e}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["line-chart-axis"]],inputs:{axisExtent:"axisExtent",axis:"axis",scale:"scale",gridCount:"gridCount",domDim:"domDim",customFormatter:"customFormatter"},outputs:{onViewExtentChange:"onViewExtentChange"},features:[Gt],decls:26,vars:11,consts:[[1,"line"],[1,"minor"],[1,"ticks"],["class","minor-tick-label",4,"ngFor","ngForOf","ngForTrackBy"],["mat-icon-button","","title","Click to manually set min & max values",1,"extent-edit-button",3,"matMenuTriggerFor","menuOpened","menuClosed"],["matMenuTrigger","matMenuTrigger"],["svgIcon","edit_24px"],["class","major ticks",4,"ngIf"],["xPosition","before",3,"yPosition"],["manualControl","matMenu"],[1,"extent-edit-input",3,"click","keydown"],["type","number",3,"value"],["minInput",""],["maxInput",""],[1,"extent-edit-control",3,"keydown"],["mat-raised-button","","color","primary",1,"extent-edit-change",3,"click"],["mat-stroked-button","",1,"extent-edit-cancel",3,"click"],[1,"minor-tick-label"],[1,"major","ticks"],[3,"major-label","last","left","width","bottom","height","font","title",4,"ngFor","ngForOf","ngForTrackBy"],[3,"title"]],template:function(e,i){if(1&e){let r=ge();h(0,"div"),P(1,"div",0),h(2,"div",1),Nn(),h(3,"svg",2),S(4,Y2e,5,6,"g",3),g(),Oo(),h(5,"button",4,5),I("menuOpened",function(){X(r);let s=it(15),a=it(20);return i.onAxisUpdateMenuOpen(s,a,i.axisExtent),Q(i.setEditMenuOpened(!0))})("menuClosed",function(){return i.setEditMenuOpened(!1)}),P(7,"mat-icon",6),g()(),S(8,Q2e,2,2,"div",7),g(),h(9,"mat-menu",8,9)(11,"div",10),I("click",function(s){return s.stopPropagation()})("keydown",function(s){return i.keydownPreventClose(s)}),h(12,"label"),T(13,"min"),g(),P(14,"input",11,12),g(),h(16,"div",10),I("click",function(s){return s.stopPropagation()})("keydown",function(s){return i.keydownPreventClose(s)}),h(17,"label"),T(18,"max"),g(),P(19,"input",11,13),g(),h(21,"div",14),I("keydown",function(s){return i.keydownPreventClose(s)}),h(22,"button",15),I("click",function(){X(r);let s=it(15),a=it(20),l=it(6);return i.extentChanged(s.value,a.value),Q(l.closeMenu())}),T(23," Change "),g(),h(24,"button",16),I("click",function(){return X(r),Q(it(6).closeMenu())}),T(25," Cancel "),g()()()}if(2&e){let r=it(10);As(i.axis+"-axis axis"),v(4),_("ngForOf",i.minorTicks)("ngForTrackBy",i.trackByMinorTick),v(1),nt("extent-edit-menu-opened",i.editMenuOpened),_("matMenuTriggerFor",r),v(3),_("ngIf",i.majorTicks.length),v(1),_("yPosition","y"===i.axis?"above":"below"),v(5),_("value",i.axisExtent[0]),v(5),_("value",i.axisExtent[1])}},dependencies:[nn,Fe,Ji,$i,En,Nc,Lc],styles:["[_nghost-%COMP%]{contain:strict;display:flex;overflow:hidden}.major-label[_ngcontent-%COMP%], text[_ngcontent-%COMP%]{fill:currentColor;font-size:11px;user-select:none}.axis[_ngcontent-%COMP%]{display:flex;height:100%;width:100%}.axis[_ngcontent-%COMP%]   .extent-edit-button[_ngcontent-%COMP%]{--tb-icon-size: 16px;height:24px;position:absolute;right:5px;top:5px;visibility:hidden;width:24px;padding:0}.major[_ngcontent-%COMP%], .minor[_ngcontent-%COMP%]{flex:1 0;overflow:hidden}.line[_ngcontent-%COMP%]{background-color:#aaa;flex:0 0 1px;justify-content:stretch}.ticks[_ngcontent-%COMP%]{height:100%;position:relative;width:100%}.x-axis[_ngcontent-%COMP%]{flex-direction:column}.x-axis[_ngcontent-%COMP%]   .line[_ngcontent-%COMP%]{margin-bottom:3px}.x-axis[_ngcontent-%COMP%]   text[_ngcontent-%COMP%]{dominant-baseline:text-before-edge;text-anchor:middle}.x-axis[_ngcontent-%COMP%]   .ticks[_ngcontent-%COMP%]{-webkit-mask-image:linear-gradient(to right, rgba(0, 0, 0, 0) 0%, #000 10%, #000 90%, rgba(0, 0, 0, 0) 100%);mask-image:linear-gradient(to right, rgba(0, 0, 0, 0) 0%, #000 10%, #000 90%, rgba(0, 0, 0, 0) 100%)}.y-axis[_ngcontent-%COMP%]{flex-direction:row-reverse}.y-axis[_ngcontent-%COMP%]   .line[_ngcontent-%COMP%]{margin-left:5px}.y-axis[_ngcontent-%COMP%]   text[_ngcontent-%COMP%]{dominant-baseline:central;text-anchor:end}.y-axis[_ngcontent-%COMP%]   .ticks[_ngcontent-%COMP%]{-webkit-mask-image:linear-gradient(to bottom, rgba(0, 0, 0, 0) 0%, #000 10%, #000 90%, rgba(0, 0, 0, 0) 100%);mask-image:linear-gradient(to bottom, rgba(0, 0, 0, 0) 0%, #000 10%, #000 90%, rgba(0, 0, 0, 0) 100%)}.extent-edit-input[_ngcontent-%COMP%]{align-items:center;column-gap:5px;display:grid;font-size:12px;grid-template-columns:30px minmax(auto, 100px);height:30px;margin:10px 20px}.extent-edit-input[_ngcontent-%COMP%]   input[_ngcontent-%COMP%]{background-color:inherit;border-radius:4px;border-style:solid;color:inherit}.extent-edit-control[_ngcontent-%COMP%]{align-items:center;display:flex;flex-direction:row-reverse;justify-content:flex-end;margin:10px 20px}.extent-edit-control[_ngcontent-%COMP%]   button[_ngcontent-%COMP%]{font-size:12px;height:30px;line-height:1.4;margin-left:5px;padding:0 10px}.axis[_ngcontent-%COMP%]:hover   .extent-edit-button[_ngcontent-%COMP%], .axis[_ngcontent-%COMP%]:focus-within   .extent-edit-button[_ngcontent-%COMP%], .extent-edit-menu-opened[_ngcontent-%COMP%]{visibility:visible}.major[_ngcontent-%COMP%]{position:relative;overflow:hidden;contain:strict}.major[_ngcontent-%COMP%]   .major-label[_ngcontent-%COMP%]{align-items:center;box-sizing:border-box;display:inline-flex;justify-content:center;overflow:hidden;position:absolute;white-space:nowrap}.major[_ngcontent-%COMP%]   .major-label[_ngcontent-%COMP%]   span[_ngcontent-%COMP%]{max-width:100%}.x-axis[_ngcontent-%COMP%]   .major-label[_ngcontent-%COMP%]{border-left:1px solid #9e9e9e;padding:0 5px}.x-axis[_ngcontent-%COMP%]   .major-label.last[_ngcontent-%COMP%]{border-right:1px solid #9e9e9e}.y-axis[_ngcontent-%COMP%]   .major-label[_ngcontent-%COMP%]{border-bottom:1px solid #9e9e9e;height:100%;padding:5px 0;width:100%}.y-axis[_ngcontent-%COMP%]   .major-label.last[_ngcontent-%COMP%]{border-top:1px solid #9e9e9e}.y-axis[_ngcontent-%COMP%]   .major-label[_ngcontent-%COMP%] > span[_ngcontent-%COMP%]{transform:rotate(-90deg);transform-origin:center}"],changeDetection:0}),n})();function Zx(n,t){let e=Math.min(Hc(n.map(({x:o})=>o),t),n.length-1),i=Math.max(0,e-1);return Math.abs(n[i].x-t)-Math.abs(n[e].x-t)<=0?i:e}function Mte(n,t,e,i,r,o){let s;switch(n.deltaMode){case WheelEvent.DOM_DELTA_PIXEL:s=1;break;case WheelEvent.DOM_DELTA_LINE:s=8;break;case WheelEvent.DOM_DELTA_PAGE:s=20;break;default:s=1,console.warn(`Unknown WheelEvent deltaMode: ${n.deltaMode}.`)}let a=n.deltaY*s,l=a<0?Math.max(a*i,-.95):a*i,{width:c,height:d}=e,u=[r.reverse(t.x,[0,c],-n.offsetX*l),r.reverse(t.x,[0,c],c+(c-n.offsetX)*l)],p=[o.reverse(t.y,[d,0],-n.offsetY*l),o.reverse(t.y,[d,0],d+(d-n.offsetY)*l)];return{x:u[1]<u[0]?[u[1],u[0]]:u,y:p[1]<p[0]?[p[1],p[0]]:p}}var J2e=["dots"];function $2e(n,t){if(1&n&&(Nn(),P(0,"circle",11)),2&n){let e=w().$implicit,i=w(2);Be("cx",i.getDomX(e.dataPoint.x))("cy",i.getDomY(e.dataPoint.y))("fill",e.metadata.color)}}function eNe(n,t){if(1&n&&(Nn(),Ot(0),S(1,$2e,1,3,"circle",10),kt()),2&n){let e=t.$implicit,i=w(2);v(1),_("ngIf",i.shouldRenderTooltipPoint(e.dataPoint))}}function tNe(n,t){if(1&n&&(Nn(),Ot(0),S(1,eNe,2,1,"ng-container",9),kt()),2&n){let e=w();v(1),_("ngForOf",e.cursoredData)("ngForTrackBy",e.trackBySeriesName)}}function nNe(n,t){if(1&n&&(Nn(),P(0,"rect",12)),2&n){let e=w();Be("x",e.zoomBoxInUiCoordinate.x)("width",e.zoomBoxInUiCoordinate.width)("y",e.zoomBoxInUiCoordinate.y)("height",e.zoomBoxInUiCoordinate.height)}}var iNe=function(n,t,e){return{data:n,cursorLocationInDataCoord:t,cursorLocation:e}};function rNe(n,t){if(1&n&&(h(0,"div",14),li(1,15),g()),2&n){let e=w(2),i=it(11);v(1),_("ngTemplateOutlet",e.tooltipTemplate?e.tooltipTemplate:i)("ngTemplateOutletContext",gb(2,iNe,e.cursoredData,e.cursorLocationInDataCoord,e.cursorLocation))}}function oNe(n,t){if(1&n){let e=ge();S(0,rNe,2,6,"ng-template",13),I("detach",function(){return X(e),Q(w().onTooltipDisplayDetached())})}if(2&n){let e=w();_("cdkConnectedOverlayOrigin",e.tooltipOriginEl)("cdkConnectedOverlayOpen",e.tooltipDisplayAttached&&e.state.getValue()===e.InteractionState.NONE)("cdkConnectedOverlayPositions",e.tooltipPositions)("cdkConnectedOverlayScrollStrategy",e.scrollStrategy)("cdkConnectedOverlayLockPosition",!1)("cdkConnectedOverlayFlexibleDimensions",!0)("cdkConnectedOverlayGrowAfterOpen",!0)}}function sNe(n,t){if(1&n&&(Ot(0),h(1,"tr",17)(2,"td",18),P(3,"span"),g(),h(4,"td",19),T(5),g(),h(6,"td"),T(7),g(),h(8,"td"),T(9),g()(),kt()),2&n){let e=t.$implicit;v(3),Tt("background-color",e.metadata.color),v(2),bt(e.metadata.displayName),v(2),bt(e.dataPoint.y),v(2),bt(e.dataPoint.x)}}function aNe(n,t){if(1&n&&(h(0,"table")(1,"thead")(2,"tr"),P(3,"th",16),h(4,"th"),T(5,"Name"),g(),h(6,"th"),T(7,"Y"),g(),h(8,"th"),T(9,"X"),g()()(),h(10,"tbody"),S(11,sNe,10,5,"ng-container",9),g()()),2&n){let e=t.data,i=w();v(11),_("ngForOf",e)("ngForTrackBy",i.trackBySeriesName)}}function cNe(n){return n.scrollStrategies.reposition()}var wte=(()=>{class n{constructor(e,i){this.changeDetector=e,this.scrollStrategy=i,this.onViewExtentChange=new F,this.onViewExtentReset=new F,this.onInteractionStateChange=new F,this.InteractionState=Ir,this.state=new Ai(Ir.NONE),this.specialKeyPressed=!1,this.zoomBoxInUiCoordinate={x:0,width:0,height:0,y:0},this.tooltipPositions=[{offsetY:5,originX:"start",overlayX:"start",originY:"bottom",overlayY:"top"},{offsetY:5,originX:"end",overlayX:"end",originY:"bottom",overlayY:"top"},{offsetY:-15,originX:"start",overlayX:"start",originY:"top",overlayY:"bottom"},{offsetY:-15,originX:"end",overlayX:"end",originY:"top",overlayY:"bottom"},{offsetX:5,originX:"end",overlayX:"start",originY:"top",overlayY:"top"},{offsetX:-5,originX:"start",overlayX:"end",originY:"top",overlayY:"top"}],this.cursorLocationInDataCoord=null,this.cursorLocation=null,this.cursoredData=[],this.tooltipDisplayAttached=!1,this.showZoomInstruction=!1,this.dragStartCoord=null,this.isCursorInside=!1,this.ngUnsubscribe=new Ie,this.subscriptions=[]}ngAfterViewInit(){this.subscriptions.push(this.state.subscribe(e=>{this.onInteractionStateChange.emit(e)})),this.ngUnsubscribe.pipe(N(()=>{this.subscriptions.forEach(e=>e.unsubscribe())})),mi(this.dotsContainer.nativeElement,"dblclick",{passive:!0}).pipe(ot(this.ngUnsubscribe)).subscribe(()=>{this.onViewExtentReset.emit(),this.state.next(Ir.NONE),this.changeDetector.markForCheck()}),mi(window,"keydown",{passive:!0}).pipe(ot(this.ngUnsubscribe)).subscribe(e=>{let i=this.shouldPan(e);i!==this.specialKeyPressed&&(this.specialKeyPressed=i,this.changeDetector.markForCheck())}),mi(window,"keyup",{passive:!0}).pipe(ot(this.ngUnsubscribe)).subscribe(e=>{let i=this.shouldPan(e);i!==this.specialKeyPressed&&(this.specialKeyPressed=i,this.changeDetector.markForCheck())}),mi(this.dotsContainer.nativeElement,"mousedown",{passive:!0}).pipe(ot(this.ngUnsubscribe)).subscribe(e=>{let i=this.state.getValue(),r=this.shouldPan(e)?Ir.PANNING:Ir.DRAG_ZOOMING;i===Ir.NONE&&r===Ir.DRAG_ZOOMING&&(this.dragStartCoord={x:e.offsetX,y:e.offsetY},this.zoomBoxInUiCoordinate={x:e.offsetX,width:0,y:e.offsetY,height:0}),i!==r&&(this.state.next(r),this.changeDetector.markForCheck())}),mi(this.dotsContainer.nativeElement,"mouseup",{passive:!0}).pipe(ot(this.ngUnsubscribe)).subscribe(e=>{let i=(e.buttons&ga.LEFT)===ga.LEFT;this.dragStartCoord=null;let r=this.zoomBoxInUiCoordinate;if(!i&&this.state.getValue()===Ir.DRAG_ZOOMING&&r.width>0&&r.height>0){let o=this.getDataX(r.x),s=this.getDataX(r.x+r.width),a=this.getDataY(r.y+r.height),l=this.getDataY(r.y);this.onViewExtentChange.emit({dataExtent:{x:[o,s],y:[a,l]}})}this.state.getValue()!==Ir.NONE&&(this.state.next(Ir.NONE),this.changeDetector.markForCheck())}),mi(this.dotsContainer.nativeElement,"mouseenter",{passive:!0}).pipe(ot(this.ngUnsubscribe)).subscribe(e=>{this.isCursorInside=!0,this.updateTooltip(e),this.changeDetector.markForCheck()}),mi(this.dotsContainer.nativeElement,"mouseleave",{passive:!0}).pipe(ot(this.ngUnsubscribe)).subscribe(e=>{this.dragStartCoord=null,this.isCursorInside=!1,this.updateTooltip(e),this.state.next(Ir.NONE),this.changeDetector.markForCheck()}),mi(this.dotsContainer.nativeElement,"mousemove",{passive:!0}).pipe(ot(this.ngUnsubscribe)).subscribe(e=>{switch(this.state.getValue()){case Ir.SCROLL_ZOOMING:this.state.next(Ir.NONE),this.updateTooltip(e),this.changeDetector.markForCheck();break;case Ir.NONE:this.updateTooltip(e),this.changeDetector.markForCheck();break;case Ir.PANNING:{let i=-e.movementX,r=-e.movementY,{width:o,height:s}=this.domDim,a=this.getDataX(i),l=this.getDataX(o+i),c=this.getDataY(s+r),d=this.getDataY(r);this.onViewExtentChange.emit({dataExtent:{x:[a,l],y:[c,d]}});break}case Ir.DRAG_ZOOMING:{if(!this.dragStartCoord)break;let i=[this.dragStartCoord.x,e.offsetX],r=[this.dragStartCoord.y,e.offsetY];this.zoomBoxInUiCoordinate={x:Math.min(...i),width:Math.max(...i)-Math.min(...i),y:Math.min(...r),height:Math.max(...r)-Math.min(...r)}}this.changeDetector.markForCheck()}}),mi(this.dotsContainer.nativeElement,"wheel",{passive:!1}).pipe(ot(this.ngUnsubscribe),Jn(e=>{let i=!e.ctrlKey&&!e.shiftKey&&e.altKey;return this.showZoomInstruction=!i,this.changeDetector.markForCheck(),i?(e.preventDefault(),Ht(e)):na(3e3).pipe(Nt(()=>{this.showZoomInstruction=!1,this.changeDetector.markForCheck()}),N(()=>null))}),ke(e=>Boolean(e))).subscribe(e=>{this.onViewExtentChange.emit({dataExtent:Mte(e,this.viewExtent,this.domDim,.01,this.xScale,this.yScale)}),this.state.getValue()!==Ir.SCROLL_ZOOMING&&(this.state.next(Ir.SCROLL_ZOOMING),this.changeDetector.markForCheck())})}ngOnChanges(){this.updateCursoredDataAndTooltipVisibility()}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}shouldPan(e){let i=e.shiftKey||e.altKey;if(e instanceof KeyboardEvent)return i;let r=(e.buttons&ga.LEFT)===ga.LEFT,o=(e.buttons&ga.MIDDLE)===ga.MIDDLE;return!(!r&&!o)&&(o&&!r||i)}trackBySeriesName(e,i){return i.id}getDomX(e){return this.xScale.forward(this.viewExtent.x,Zc(this.domDim,"x"),e)}getDataX(e){return this.xScale.reverse(this.viewExtent.x,Zc(this.domDim,"x"),e)}getDomY(e){return this.yScale.forward(this.viewExtent.y,Zc(this.domDim,"y"),e)}getDataY(e){return this.yScale.reverse(this.viewExtent.y,Zc(this.domDim,"y"),e)}shouldRenderTooltipPoint(e){return null!==e&&!isNaN(e.x)&&!isNaN(e.y)}updateTooltip(e){this.cursorLocationInDataCoord={x:this.getDataX(e.offsetX),y:this.getDataY(e.offsetY)},this.cursorLocation={x:e.offsetX,y:e.offsetY},this.updateCursoredDataAndTooltipVisibility()}onTooltipDisplayDetached(){this.tooltipDisplayAttached=!1}updateCursoredDataAndTooltipVisibility(){let e=this.cursorLocationInDataCoord;if(null===e)return this.cursoredData=[],void(this.tooltipDisplayAttached=!1);this.cursoredData=this.isCursorInside?this.seriesData.map(i=>({seriesDatum:i,metadata:this.seriesMetadataMap[i.id]})).filter(({metadata:i})=>i&&i.visible&&!Boolean(i.aux)).map(({seriesDatum:i,metadata:r})=>{let o=Zx(i.points,e.x),s=i.points[o];return{id:i.id,closestPointIndex:o,dataPoint:s,domPoint:{x:this.getDomX(s.x),y:this.getDomY(s.y)},metadata:r}}).filter(i=>i):[],this.tooltipDisplayAttached=Boolean(this.cursoredData.length)}}return n.\u0275fac=function(e){return new(e||n)(C($t),C(xf))},n.\u0275cmp=O({type:n,selectors:[["line-chart-interactive-view"]],viewQuery:function(e,i){if(1&e&&(Ge(J2e,7,Me),Ge(Bu,5)),2&e){let r;Se(r=Ee())&&(i.dotsContainer=r.first),Se(r=Ee())&&(i.overlay=r.first)}},hostVars:2,hostBindings:function(e,i){2&e&&nt("show-zoom-instruction",i.showZoomInstruction)},inputs:{seriesData:"seriesData",seriesMetadataMap:"seriesMetadataMap",viewExtent:"viewExtent",xScale:"xScale",yScale:"yScale",domDim:"domDim",tooltipOriginEl:"tooltipOriginEl",tooltipTemplate:"tooltipTemplate",disableTooltip:"disableTooltip"},outputs:{onViewExtentChange:"onViewExtentChange",onViewExtentReset:"onViewExtentReset",onInteractionStateChange:"onInteractionStateChange"},features:[Qt([{provide:xf,useFactory:cNe,deps:[zi]}]),Gt],decls:12,vars:9,consts:[[1,"dots"],["dots",""],[4,"ngIf"],["class","zoom-box",4,"ngIf"],[1,"zoom-instruction"],[1,"instruction-content"],["cdkOverlayOrigin","",1,"tooltip-origin"],["tooltipOrigin","cdkOverlayOrigin"],["defaultTooltip",""],[4,"ngFor","ngForOf","ngForTrackBy"],["r","4",4,"ngIf"],["r","4"],[1,"zoom-box"],["cdkConnectedOverlay","",3,"cdkConnectedOverlayOrigin","cdkConnectedOverlayOpen","cdkConnectedOverlayPositions","cdkConnectedOverlayScrollStrategy","cdkConnectedOverlayLockPosition","cdkConnectedOverlayFlexibleDimensions","cdkConnectedOverlayGrowAfterOpen","detach"],[1,"tooltip-container"],[3,"ngTemplateOutlet","ngTemplateOutletContext"],[1,"circle-header"],[1,"tooltip-row"],[1,"tooltip-row-circle"],[1,"name"]],template:function(e,i){1&e&&(Nn(),h(0,"svg",0,1),S(2,tNe,2,2,"ng-container",2),S(3,nNe,1,4,"rect",3),g(),Oo(),h(4,"div",4)(5,"span",5),T(6,"Alt + Scroll to Zoom"),g()(),P(7,"div",6,7),S(9,oNe,1,7,null,2),S(10,aNe,12,2,"ng-template",null,8,Wt)),2&e&&(nt("pannable",i.specialKeyPressed)("draggable",i.state.getValue()===i.InteractionState.NONE||i.state.getValue()===i.InteractionState.DRAG_ZOOMING)("panning",i.state.getValue()===i.InteractionState.PANNING),v(2),_("ngIf",i.state.getValue()===i.InteractionState.NONE),v(1),_("ngIf",i.state.getValue()===i.InteractionState.DRAG_ZOOMING),v(6),_("ngIf",!i.disableTooltip))},dependencies:[nn,Fe,Lr,Bu,wd],styles:["[_nghost-%COMP%]{display:flex;position:relative;user-select:none}.dots[_ngcontent-%COMP%]{height:100%;width:100%}.dots.draggable[_ngcontent-%COMP%]{cursor:crosshair}.dots.pannable[_ngcontent-%COMP%]{cursor:grab}.dots.panning[_ngcontent-%COMP%]{cursor:grabbing}.tooltip-row-circle[_ngcontent-%COMP%]{align-items:center;display:inline-flex;height:12px;width:12px}.tooltip-row-circle[_ngcontent-%COMP%] > span[_ngcontent-%COMP%]{border-radius:50%;border:1px solid rgba(255,255,255,.6);display:inline-block;height:10px;width:10px}.tooltip-origin[_ngcontent-%COMP%]{bottom:0;left:0;position:absolute;right:0}.tooltip-container[_ngcontent-%COMP%]{background:rgba(0,0,0,.85);border-radius:4px;color:#fff;contain:paint style layout;font-size:.9em;overflow:auto;padding:5px;pointer-events:none;width:100%}th[_ngcontent-%COMP%], td[_ngcontent-%COMP%]{padding:2px 5px;text-align:left}th[_ngcontent-%COMP%]{font-weight:500;padding-bottom:5px}.zoom-box[_ngcontent-%COMP%]{fill-opacity:.03;fill:#000;stroke:#ccc}.zoom-instruction[_ngcontent-%COMP%]{align-items:center;display:flex;justify-content:center;left:0;opacity:0;pointer-events:none;position:absolute;right:0;top:10px;transition:opacity .5s;z-index:1}.instruction-content[_ngcontent-%COMP%]{background:rgba(0,0,0,.6);border-radius:5px;color:#fff;padding:5px 10px;user-select:none}.show-zoom-instruction[_nghost-%COMP%]   .zoom-instruction[_ngcontent-%COMP%]{opacity:1}"],changeDetection:0}),n})();function uNe(n,t){if(1&n&&(Nn(),P(0,"line",2)),2&n){let e=t.$implicit,i=w();nt("zero",0===e),Be("x1",i.getDomX(e))("x2",i.getDomX(e))("y2",i.domDim.height)}}function pNe(n,t){if(1&n&&(Nn(),P(0,"line",3)),2&n){let e=t.$implicit,i=w();nt("zero",0===e),Be("y1",i.getDomY(e))("x2",i.domDim.width)("y2",i.getDomY(e))}}var Ste=(()=>{class n{getDomX(e){return this.xScale.forward(this.viewExtent.x,Zc(this.domDim,"x"),e)}getDomY(e){return this.yScale.forward(this.viewExtent.y,Zc(this.domDim,"y"),e)}getXTicks(){return this.xScale.ticks(this.viewExtent.x,Xx(this.domDim.width,this.xGridCount))}getYTicks(){return this.yScale.ticks(this.viewExtent.y,Xx(this.domDim.height,this.yGridCount))}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["line-chart-grid-view"]],inputs:{viewExtent:"viewExtent",xScale:"xScale",xGridCount:"xGridCount",yScale:"yScale",yGridCount:"yGridCount",domDim:"domDim"},decls:3,vars:2,consts:[["y1","0",3,"zero",4,"ngFor","ngForOf"],["x1","0",3,"zero",4,"ngFor","ngForOf"],["y1","0"],["x1","0"]],template:function(e,i){1&e&&(Nn(),h(0,"svg"),S(1,uNe,1,5,"line",0),S(2,pNe,1,5,"line",1),g()),2&e&&(v(1),_("ngForOf",i.getXTicks()),v(1),_("ngForOf",i.getYTicks()))},dependencies:[nn],styles:["[_nghost-%COMP%] {\n        display: flex;\n        overflow: hidden;\n      }\n\n      svg[_ngcontent-%COMP%] {\n        height: 100%;\n        width: 100%;\n      }\n\n      line[_ngcontent-%COMP%] {\n        stroke: #ccc;\n        stroke-width: 1px;\n      }\n\n      .zero[_ngcontent-%COMP%] {\n        stroke: #aaa;\n        stroke-width: 1.5px;\n      }"],changeDetection:0}),n})(),mNe=["seriesView"],hNe=["xAxis"],gNe=["yAxis"],_Ne=["chartEl"];function bNe(n,t){if(1&n&&P(0,"line-chart-grid-view",16),2&n){let e=w();_("viewExtent",e.viewBox)("xScale",e.xScale)("yScale",e.yScale)("xGridCount",e.X_GRID_COUNT)("yGridCount",e.Y_GRID_COUNT)("domDim",e.domDimensions.main)}}function vNe(n,t){1&n&&(Nn(),P(0,"svg",null,17))}function yNe(n,t){1&n&&P(0,"canvas",null,17)}function xNe(n,t){if(1&n&&(Ot(0),S(1,vNe,2,0,"svg",5),S(2,yNe,2,0,"canvas",5),kt()),2&n){let e=w();v(1),_("ngIf",e.getRendererType()===e.RendererType.SVG),v(1),_("ngIf",e.getRendererType()===e.RendererType.WEBGL)}}function CNe(n,t){if(1&n){let e=ge();h(0,"line-chart-interactive-view",18),I("onViewExtentChange",function(r){return X(e),Q(w().onViewBoxChanged(r))})("onViewExtentReset",function(){return X(e),Q(w().viewBoxReset())})("onInteractionStateChange",function(r){return X(e),Q(w().onInteractionStateChange(r))}),g()}if(2&n){let e=w(),i=it(1);_("seriesData",e.seriesData)("seriesMetadataMap",e.seriesMetadataMap)("viewExtent",e.viewBox)("xScale",e.xScale)("yScale",e.yScale)("tooltipOriginEl",i)("domDim",e.domDimensions.main)("tooltipTemplate",e.tooltipTemplate)("disableTooltip",e.disableTooltip)}}var MNe=function(n,t,e,i){return{xScale:n,yScale:t,domDimension:e,viewExtent:i}};function wNe(n,t){if(1&n&&(h(0,"div",19),li(1,20),g()),2&n){let e=w();v(1),_("ngTemplateOutlet",e.customVisTemplate)("ngTemplateOutletContext",AO(2,MNe,e.xScale,e.yScale,e.domDimensions.main,e.viewBox))}}function SNe(n,t){if(1&n){let e=ge();h(0,"line-chart-axis",21),I("onViewExtentChange",function(r){return X(e),Q(w().onViewBoxChangedFromAxis(r,"y"))}),g()}if(2&n){let e=w();_("axisExtent",e.viewBox.y)("customFormatter",e.customYFormatter)("domDim",e.domDimensions.yAxis)("gridCount",e.Y_GRID_COUNT)("scale",e.yScale)}}function ENe(n,t){if(1&n){let e=ge();h(0,"line-chart-axis",22),I("onViewExtentChange",function(r){return X(e),Q(w().onViewBoxChangedFromAxis(r,"x"))}),g()}if(2&n){let e=w();_("axisExtent",e.viewBox.x)("customFormatter",e.customXFormatter)("domDim",e.domDimensions.xAxis)("gridCount",e.X_GRID_COUNT)("scale",e.xScale)}}function TNe(n,t){1&n&&(h(0,"div",23),P(1,"span",24),g())}var DNe=function(n,t,e,i,r){return{xScale:n,yScale:t,domDimension:e,viewExtent:i,interactionState:r}};function INe(n,t){if(1&n&&(h(0,"div",25,26),li(2,20),g()),2&n){let e=w();v(2),_("ngTemplateOutlet",e.customChartOverlayTemplate)("ngTemplateOutletContext",RO(2,DNe,e.xScale,e.yScale,e.domDimensions.main,e.viewBox,e.interactionState))}}var ANe=function(n,t){return{container:!0,"dark-mode":n,"line-only-mode":t,"line-chart":!0}},yV={x:[0,1],y:[0,1]},c_=(()=>{class n{constructor(e){this.changeDetector=e,this.RendererType=Qi,this.useDarkMode=!1,this.preferredRendererType=Qi.WEBGL,this.xScaleType=nr.LINEAR,this.yScaleType=nr.LINEAR,this.userViewBox=null,this.lineOnly=!1,this.disableTooltip=!1,this.viewBoxChanged=new F,this.onViewBoxOverridden=new Rp(1),this.ignoreYOutliers=!1,this.Y_GRID_COUNT=6,this.X_GRID_COUNT=10,this.xScale=ql(this.xScaleType),this.yScale=ql(this.xScaleType),this.viewBox=yV,this.domDimensions={main:{width:0,height:0},xAxis:{width:0,height:0},yAxis:{width:0,height:0}},this.showChartRendererElement=!0,this.interactionState=Ir.NONE,this.lineChart=null,this.isDataUpdated=!1,this.isMetadataUpdated=!1,this.isFixedViewBoxUpdated=!1,this.isViewBoxOverridden=!1,this.useDarkModeUpdated=!1,this.userViewBoxUpdated=!1,this.isViewBoxChanged=!0,this.scaleUpdated=!0,this.isRenderingContextLost=!1}ngOnInit(){this.onViewBoxOverridden.next(this.isViewBoxOverridden)}ngOnChanges(e){e.xScaleType&&(this.xScale=ql(this.xScaleType),this.scaleUpdated=!0),e.yScaleType&&(this.yScale=ql(this.yScaleType),this.scaleUpdated=!0),e.seriesData&&(this.isDataUpdated=!0),e.fixedViewBox&&(this.isFixedViewBoxUpdated=!0),e.seriesMetadataMap&&(this.isMetadataUpdated=!0),e.useDarkMode&&(this.useDarkModeUpdated=!0),e.userViewBox&&(this.userViewBoxUpdated=!0),this.userViewBoxUpdated?this.setIsViewBoxOverridden(!!this.userViewBox):this.scaleUpdated&&this.setIsViewBoxOverridden(!1),this.isViewBoxChanged=this.isViewBoxChanged||this.userViewBoxUpdated||this.scaleUpdated||!this.isViewBoxOverridden&&this.shouldUpdateDefaultViewBox(e),this.updateLineChart()}ngAfterViewInit(){this.initializeChart(),this.updateLineChart(),this.changeDetector.detectChanges()}recoverRendererIfNeeded(){!this.isRenderingContextLost||this.disableUpdate||(this.showChartRendererElement=!1,this.changeDetector.detectChanges(),this.showChartRendererElement=!0,this.changeDetector.detectChanges(),this.initializeChart(),this.scaleUpdated=!0,this.isMetadataUpdated=!0,this.isDataUpdated=!0,this.useDarkModeUpdated=!0,this.isFixedViewBoxUpdated=!0,this.isViewBoxChanged=!0,this.isRenderingContextLost=!1)}onViewResize(){!this.lineChart||(this.readAndUpdateDomDimensions(),this.lineChart.resize(this.domDimensions.main),this.changeDetector.detectChanges())}shouldUpdateDefaultViewBox(e){if(e.xScaleType||e.yScaleType||e.ignoreYOutliers||e.seriesData)return!0;let r=e.seriesMetadataMap;if(r){let o=r.previousValue;if(Object.keys(this.seriesMetadataMap).length!==Object.keys(o??{}).length)return!0;for(let[s,a]of Object.entries(this.seriesMetadataMap)){let l=o&&o[s];if(!l||a.visible!==l.visible)return!0}}return!1}onContextLost(){this.isRenderingContextLost=!0,this.lineChart&&(this.lineChart.dispose(),this.lineChart=null)}triggerContextLostForTest(){this.onContextLost()}getLineChartForTest(){return this.lineChart}initializeChart(){this.lineChart&&this.lineChart.dispose();let e=this.getRendererType(),i={onDrawEnd:()=>{},onContextLost:this.onContextLost.bind(this)},r=null;switch(this.readAndUpdateDomDimensions(),e){case Qi.SVG:r={type:Qi.SVG,container:this.chartEl.nativeElement,callbacks:i,domDimension:this.domDimensions.main,useDarkMode:this.useDarkMode};break;case Qi.WEBGL:r={type:Qi.WEBGL,container:this.chartEl.nativeElement,devicePixelRatio:window.devicePixelRatio,callbacks:i,domDimension:this.domDimensions.main,useDarkMode:this.useDarkMode};break;default:throw new Error(`<line-chart> does not yet support rendererType: ${e}`)}let s=e!==Qi.SVG&&Yl_isWebGl2OffscreenCanvasSupported()?ym:iA;this.lineChart=new s(r)}ngOnDestroy(){this.lineChart&&this.lineChart.dispose()}getRendererType(){return function(n){switch(n){case Qi.SVG:return Qi.SVG;case Qi.WEBGL:return Yl_isWebGl2Supported()?Qi.WEBGL:Qi.SVG;default:throw new Error(`Unknown rendererType: ${n}`)}}(this.preferredRendererType)}readAndUpdateDomDimensions(){this.domDimensions={main:{width:this.seriesView.nativeElement.clientWidth,height:this.seriesView.nativeElement.clientHeight},xAxis:{width:this.xAxis.nativeElement.clientWidth,height:this.xAxis.nativeElement.clientHeight},yAxis:{width:this.yAxis.nativeElement.clientWidth,height:this.yAxis.nativeElement.clientHeight}}}updateLineChart(){if(this.recoverRendererIfNeeded(),this.lineChart&&!this.disableUpdate){if(this.scaleUpdated&&(this.scaleUpdated=!1,this.lineChart.setXScaleType(this.xScaleType),this.lineChart.setYScaleType(this.yScaleType)),this.isMetadataUpdated&&(this.isMetadataUpdated=!1,this.lineChart.setMetadata(this.seriesMetadataMap)),this.isDataUpdated&&(this.isDataUpdated=!1,this.lineChart.setData(this.seriesData)),this.useDarkModeUpdated&&(this.useDarkModeUpdated=!1,this.lineChart.setUseDarkMode(this.useDarkMode)),this.userViewBoxUpdated&&(this.userViewBoxUpdated=!1),this.isViewBoxOverridden&&this.userViewBox)this.viewBox=this.userViewBox;else if(!this.isViewBoxOverridden&&this.fixedViewBox)this.viewBox=this.fixedViewBox;else if(!this.isViewBoxOverridden&&this.isViewBoxChanged){let i=function(n,t,e,i,r){let o=null,s=null,a=[];for(let{id:u,points:p}of n){let f=t[u];if(f&&!f.aux&&f.visible)for(let m=0;m<p.length;m++){let{x:b,y:M}=p[m];i(b)&&(o=null===o||b<o?b:o,s=null===s||b>s?b:s),r(M)&&a.push(M)}}a.sort(il);let c=a[0],d=a[a.length-1];return e&&a.length>2&&(c=a[Math.ceil(.05*(a.length-1))],d=a[Math.floor(.95*(a.length-1))]),{x:null!==o&&null!==s?[o,s]:void 0,y:void 0!==c&&void 0!==d?[c,d]:void 0}}(this.seriesData,this.seriesMetadataMap,this.ignoreYOutliers,this.xScale.isSafeNumber,this.yScale.isSafeNumber);this.viewBox={x:this.xScale.niceDomain(i.x??yV.x),y:this.yScale.niceDomain(i.y??yV.y)}}(this.isFixedViewBoxUpdated||this.isViewBoxChanged)&&(this.isFixedViewBoxUpdated=!1,this.isViewBoxChanged=!1,this.lineChart.setViewBox(this.viewBox),this.changeDetector.detectChanges())}}onViewBoxChanged({dataExtent:e}){this.viewBoxChanged.emit(e)}viewBoxReset(){this.viewBoxChanged.emit(null)}setIsViewBoxOverridden(e){let i=this.isViewBoxOverridden;this.isViewBoxOverridden=e,i!==e&&this.onViewBoxOverridden.next(e)}onInteractionStateChange(e){this.interactionState=e}getIsViewBoxOverridden(){return this.onViewBoxOverridden}onViewBoxChangedFromAxis(e,i){let r={...this.viewBox,[i]:e};this.onViewBoxChanged({dataExtent:r})}}return n.\u0275fac=function(e){return new(e||n)(C($t))},n.\u0275cmp=O({type:n,selectors:[["line-chart"]],viewQuery:function(e,i){if(1&e&&(Ge(mNe,7,Me),Ge(hNe,7,Me),Ge(gNe,7,Me),Ge(_Ne,5,Me)),2&e){let r;Se(r=Ee())&&(i.seriesView=r.first),Se(r=Ee())&&(i.xAxis=r.first),Se(r=Ee())&&(i.yAxis=r.first),Se(r=Ee())&&(i.chartEl=r.first)}},inputs:{customVisTemplate:"customVisTemplate",customChartOverlayTemplate:"customChartOverlayTemplate",useDarkMode:"useDarkMode",preferredRendererType:"preferredRendererType",seriesData:"seriesData",fixedViewBox:"fixedViewBox",seriesMetadataMap:"seriesMetadataMap",xScaleType:"xScaleType",yScaleType:"yScaleType",customXFormatter:"customXFormatter",customYFormatter:"customYFormatter",tooltipTemplate:"tooltipTemplate",userViewBox:"userViewBox",lineOnly:"lineOnly",disableTooltip:"disableTooltip",disableUpdate:"disableUpdate",ignoreYOutliers:"ignoreYOutliers"},outputs:{viewBoxChanged:"viewBoxChanged"},features:[Gt],decls:16,vars:13,consts:[["detectResize","","cdkOverlayOrigin","",3,"ngClass","resizeEventDebouncePeriodInMs","onResize"],["overlayTarget","cdkOverlayOrigin"],[1,"series-view"],["seriesView",""],[3,"viewExtent","xScale","yScale","xGridCount","yGridCount","domDim",4,"ngIf"],[4,"ngIf"],[3,"seriesData","seriesMetadataMap","viewExtent","xScale","yScale","tooltipOriginEl","domDim","tooltipTemplate","disableTooltip","onViewExtentChange","onViewExtentReset","onInteractionStateChange",4,"ngIf"],["class","custom-vis",4,"ngIf"],[1,"y-axis"],["yAxis",""],["axis","y",3,"axisExtent","customFormatter","domDim","gridCount","scale","onViewExtentChange",4,"ngIf"],[1,"x-axis"],["xAxis",""],["axis","x",3,"axisExtent","customFormatter","domDim","gridCount","scale","onViewExtentChange",4,"ngIf"],["class","dot",4,"ngIf"],["class","custom-vis custom-chart-overlay-vis",4,"ngIf"],[3,"viewExtent","xScale","yScale","xGridCount","yGridCount","domDim"],["chartEl",""],[3,"seriesData","seriesMetadataMap","viewExtent","xScale","yScale","tooltipOriginEl","domDim","tooltipTemplate","disableTooltip","onViewExtentChange","onViewExtentReset","onInteractionStateChange"],[1,"custom-vis"],[3,"ngTemplateOutlet","ngTemplateOutletContext"],["axis","y",3,"axisExtent","customFormatter","domDim","gridCount","scale","onViewExtentChange"],["axis","x",3,"axisExtent","customFormatter","domDim","gridCount","scale","onViewExtentChange"],[1,"dot"],[1,"rect"],[1,"custom-vis","custom-chart-overlay-vis"],["customChartOverlay",""]],template:function(e,i){1&e&&(h(0,"div",0,1),I("onResize",function(){return i.onViewResize()}),h(2,"div",2,3),S(4,bNe,1,6,"line-chart-grid-view",4),S(5,xNe,3,2,"ng-container",5),S(6,CNe,1,9,"line-chart-interactive-view",6),S(7,wNe,2,7,"div",7),g(),h(8,"div",8,9),S(10,SNe,1,5,"line-chart-axis",10),g(),h(11,"div",11,12),S(13,ENe,1,5,"line-chart-axis",13),g(),S(14,TNe,2,0,"div",14),S(15,INe,3,8,"div",15),g()),2&e&&(_("ngClass",qr(10,ANe,i.useDarkMode,i.lineOnly))("resizeEventDebouncePeriodInMs",0),v(4),_("ngIf",!i.lineOnly),v(1),_("ngIf",i.showChartRendererElement),v(1),_("ngIf",!i.lineOnly),v(1),_("ngIf",i.customVisTemplate),v(3),_("ngIf",!i.lineOnly),v(3),_("ngIf",!i.lineOnly),v(1),_("ngIf",!i.lineOnly),v(1),_("ngIf",i.customChartOverlayTemplate))},dependencies:[yn,Fe,Lr,wd,Cte,wte,Ste,Of],styles:['[_nghost-%COMP%]{contain:strict;display:flex;flex-direction:column}[_nghost-%COMP%]     .line-chart:has(.horizontal-prospective-area:hover) .x-axis .extent-edit-button{visibility:visible}[_nghost-%COMP%]   .custom-vis[_ngcontent-%COMP%]{pointer-events:none}.container[_ngcontent-%COMP%]{background:inherit;display:grid;flex-grow:1;height:100%;overflow:hidden;width:100%;grid-template-areas:"yaxis series" "dot xaxis" ". customChartOverlay";grid-template-columns:50px 1fr;grid-auto-rows:1fr 30px 0px}.container.dark-mode[_ngcontent-%COMP%]{color:#fff}.container.line-only-mode[_ngcontent-%COMP%]{grid-template-columns:0 1fr;grid-auto-rows:1fr 0}.series-view[_ngcontent-%COMP%]{grid-area:series;position:relative;overflow:hidden}.series-view[_ngcontent-%COMP%]   .custom-vis[_ngcontent-%COMP%], .series-view[_ngcontent-%COMP%]   canvas[_ngcontent-%COMP%], .series-view[_ngcontent-%COMP%]   svg[_ngcontent-%COMP%], .series-view[_ngcontent-%COMP%]   line-chart-grid-view[_ngcontent-%COMP%], .series-view[_ngcontent-%COMP%]   line-chart-interactive-view[_ngcontent-%COMP%]{height:100%;left:0;position:absolute;top:0;width:100%}.x-axis[_ngcontent-%COMP%]   .custom-vis[_ngcontent-%COMP%], .y-axis[_ngcontent-%COMP%]   .custom-vis[_ngcontent-%COMP%]{height:100%;left:0;overflow:hidden;position:absolute;top:0;width:100%;-webkit-mask-image:linear-gradient(to right, rgba(0, 0, 0, 0) 0%, #000 10%, #000 90%, rgba(0, 0, 0, 0) 100%);mask-image:linear-gradient(to right, rgba(0, 0, 0, 0) 0%, #000 10%, #000 90%, rgba(0, 0, 0, 0) 100%)}.x-axis[_ngcontent-%COMP%]   line-chart-axis[_ngcontent-%COMP%], .y-axis[_ngcontent-%COMP%]   line-chart-axis[_ngcontent-%COMP%]{height:100%}.x-axis[_ngcontent-%COMP%]{grid-area:xaxis;position:relative}.y-axis[_ngcontent-%COMP%]{grid-area:yaxis}.dot[_ngcontent-%COMP%]{align-items:flex-start;display:flex;grid-area:dot;justify-content:flex-end}.dot[_ngcontent-%COMP%]   .rect[_ngcontent-%COMP%]{height:1px;width:1px;background-color:#aaa}.custom-chart-overlay-vis[_ngcontent-%COMP%]{grid-area:customChartOverlay;grid-row-end:2;grid-row-start:1}'],changeDetection:0}),n})();function RNe(n,t){1&n&&li(0)}var Tte=function(n){return{$implicit:n}};function PNe(n,t){if(1&n&&(h(0,"div",4),S(1,RNe,1,0,"ng-container",5),T(2),g()),2&n){let e=w(),i=it(6);v(1),_("ngTemplateOutlet",i)("ngTemplateOutletContext",In(3,Tte,e.datum)),v(1),He(" ",e.getFormattedDataForColumn()," ")}}function ONe(n,t){1&n&&li(0)}function kNe(n,t){if(1&n&&(h(0,"div",4),S(1,ONe,1,0,"ng-container",5),T(2),g()),2&n){let e=w(),i=it(6);v(1),_("ngTemplateOutlet",i)("ngTemplateOutletContext",In(3,Tte,e.datum)),v(1),He(" ",e.getFormattedDataForColumn()," ")}}function FNe(n,t){if(1&n&&(h(0,"div",6),T(1),g()),2&n){let e=w();v(1),He(" ",e.getFormattedDataForColumn()," ")}}function NNe(n,t){1&n&&P(0,"mat-icon",9)}function LNe(n,t){1&n&&P(0,"mat-icon",10)}function BNe(n,t){if(1&n&&(S(0,NNe,1,0,"mat-icon",7),S(1,LNe,1,0,"mat-icon",8)),2&n){let e=t.$implicit;_("ngIf",e>=0),v(1),_("ngIf",e<0)}}var VNe=["*"],d_=(()=>{class n{constructor(){this.contextMenuOpened=new F,this.ColumnHeaderType=ht}getFormattedDataForColumn(){if(void 0===this.datum)return"";switch(this.header.type){case ht.RUN:return this.datum;case ht.VALUE:case ht.STEP:case ht.SMOOTHED:case ht.START_STEP:case ht.END_STEP:case ht.START_VALUE:case ht.END_VALUE:case ht.MIN_VALUE:case ht.MAX_VALUE:case ht.STEP_AT_MAX:case ht.STEP_AT_MIN:case ht.MEAN:case ht.HPARAM:return"number"==typeof this.datum?g0.formatShort(this.datum):this.datum;case ht.TIME:return new Date(this.datum).toISOString();case ht.RELATIVE_TIME:return _0.formatReadable(this.datum);case ht.VALUE_CHANGE:return g0.formatShort(Math.abs(this.datum));case ht.PERCENTAGE_CHANGE:return Math.round(100*this.datum).toString()+"%";case ht.RAW_CHANGE:return ip.formatShort(Math.abs(this.datum));default:return""}}onContextMenuOpened(e){this.contextMenuOpened.emit(e)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["tb-data-table-content-cell"]],hostBindings:function(e,i){1&e&&I("contextmenu",function(o){return i.onContextMenuOpened(o)})},inputs:{header:"header",datum:"datum"},outputs:{contextMenuOpened:"contextMenuOpened"},ngContentSelectors:VNe,decls:7,vars:3,consts:[[3,"ngSwitch"],["class","cell",4,"ngSwitchCase"],["class","cell extra-right-padding",4,"ngSwitchDefault"],["arrow",""],[1,"cell"],[4,"ngTemplateOutlet","ngTemplateOutletContext"],[1,"cell","extra-right-padding"],["svgIcon","arrow_upward_24px",4,"ngIf"],["svgIcon","arrow_downward_24px",4,"ngIf"],["svgIcon","arrow_upward_24px"],["svgIcon","arrow_downward_24px"]],template:function(e,i){1&e&&(Dn(),Ot(0,0),S(1,PNe,3,5,"div",1),S(2,kNe,3,5,"div",1),S(3,FNe,2,1,"div",2),zt(4),kt(),S(5,BNe,2,2,"ng-template",null,3,Wt)),2&e&&(_("ngSwitch",i.header.type),v(1),_("ngSwitchCase",i.ColumnHeaderType.VALUE_CHANGE),v(1),_("ngSwitchCase",i.ColumnHeaderType.PERCENTAGE_CHANGE))},dependencies:[Fe,Lr,sr,Sr,uu,En],styles:["[_nghost-%COMP%]{display:table-cell}.cell[_ngcontent-%COMP%]{align-items:center;display:flex}.cell[_ngcontent-%COMP%]   mat-icon[_ngcontent-%COMP%]{height:12px;width:12px}.cell[_ngcontent-%COMP%]   mat-icon[_ngcontent-%COMP%]     path{fill:unset}.extra-right-padding[_ngcontent-%COMP%]{padding-right:1px}"],changeDetection:0}),n})(),HNe=["*"],sA=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["tb-data-table-content-row"]],ngContentSelectors:HNe,decls:1,vars:0,template:function(e,i){1&e&&(Dn(),zt(0))},styles:["[_nghost-%COMP%] {\n        display: table-row;\n      }"],changeDetection:0}),n})();function zNe(n,t){if(1&n&&P(0,"mat-icon",7),2&n){let e=w(2);_("ngClass",e.header.name===e.sortingInfo.name?"show":"show-on-hover")}}function UNe(n,t){if(1&n&&P(0,"mat-icon",8),2&n){let e=w(2);_("ngClass",e.header.name===e.sortingInfo.name?"show":"show-on-hover")}}function jNe(n,t){if(1&n){let e=ge();h(0,"button",4),I("click",function(r){X(e);let o=w();return r.stopPropagation(),Q(o.headerClickedHandler())}),S(1,zNe,1,1,"mat-icon",5),S(2,UNe,1,1,"mat-icon",6),g()}if(2&n){let e=w();v(1),_("ngIf",e.sortingInfo.order===e.SortingOrder.ASCENDING||e.header.name!==e.sortingInfo.name),v(1),_("ngIf",e.sortingInfo.order===e.SortingOrder.DESCENDING&&e.header.name===e.sortingInfo.name)}}function GNe(n,t){if(1&n){let e=ge();h(0,"button",9),I("click",function(r){return X(e),Q(w().onContextMenuOpened(r))}),P(1,"mat-icon",10),g()}}var WNe=["*"],u_=(()=>{class n{constructor(){this.hparamsEnabled=!1,this.disableContextMenu=!1,this.dragStart=new F,this.dragEnd=new F,this.dragEnter=new F,this.headerClicked=new F,this.contextMenuOpened=new F,this.highlightStyle$=new Ai({}),this.SortingOrder=io}onContextMenuOpened(e){this.disableContextMenu||this.contextMenuOpened.emit(e)}headerClickedHandler(){this.header.sortable&&this.headerClicked.emit(this.header.name)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["tb-data-table-header-cell"]],hostBindings:function(e,i){1&e&&I("contextmenu",function(o){return i.onContextMenuOpened(o)})},inputs:{header:"header",sortingInfo:"sortingInfo",hparamsEnabled:"hparamsEnabled",disableContextMenu:"disableContextMenu"},outputs:{dragStart:"dragStart",dragEnd:"dragEnd",dragEnter:"dragEnter",headerClicked:"headerClicked",contextMenuOpened:"contextMenuOpened"},ngContentSelectors:WNe,decls:6,vars:7,consts:[[1,"cell",3,"draggable","ngClass","dragstart","dragend","dragenter","click"],[3,"header"],["mat-icon-button","","class","sorting-icon-container",3,"click",4,"ngIf"],["mat-icon-button","","class","context-menu-container show-on-hover",3,"click",4,"ngIf"],["mat-icon-button","",1,"sorting-icon-container",3,"click"],["svgIcon","arrow_upward_24px",3,"ngClass",4,"ngIf"],["svgIcon","arrow_downward_24px",3,"ngClass",4,"ngIf"],["svgIcon","arrow_upward_24px",3,"ngClass"],["svgIcon","arrow_downward_24px",3,"ngClass"],["mat-icon-button","",1,"context-menu-container","show-on-hover",3,"click"],["svgIcon","more_vert_24px"]],template:function(e,i){1&e&&(Dn(),h(0,"div",0),I("dragstart",function(){return i.dragStart.emit(i.header)})("dragend",function(){return i.dragEnd.emit()})("dragenter",function(){return i.dragEnter.emit(i.header)})("click",function(){return i.headerClickedHandler()}),j(1,"async"),zt(2),P(3,"tb-data-table-header",1),S(4,jNe,3,2,"button",2),S(5,GNe,2,0,"button",3),g()),2&e&&(_("draggable",i.header.movable)("ngClass",W(1,5,i.highlightStyle$)),v(3),_("header",i.header),v(1),_("ngIf",i.header.sortable),v(1),_("ngIf",(i.header.removable||i.header.sortable)&&!i.disableContextMenu))},dependencies:[yn,Fe,En,$i,zT,ct],styles:["[_nghost-%COMP%]{display:table-cell;vertical-align:bottom}[_nghost-%COMP%]:hover   .show-on-hover[_ngcontent-%COMP%]{opacity:.3}[_nghost-%COMP%]   .show-on-hover[_ngcontent-%COMP%]:hover{opacity:1}[_nghost-%COMP%]   .show-on-hover[_ngcontent-%COMP%]:focus{opacity:1}.cell[_ngcontent-%COMP%]{align-items:center;display:flex}.cell[_ngcontent-%COMP%]   mat-icon[_ngcontent-%COMP%]{height:12px;width:12px;line-height:1}.cell[_ngcontent-%COMP%]   button[mat-icon-button].mat-mdc-icon-button.sorting-icon-container[_ngcontent-%COMP%], .cell[_ngcontent-%COMP%]   button[mat-icon-button].mat-mdc-icon-button.context-menu-container[_ngcontent-%COMP%]{width:16px;height:16px;--tb-icon-size: 12px;border-radius:5px;font-size:12px;padding:4px}.cell[_ngcontent-%COMP%]   .sorting-icon-container[_ngcontent-%COMP%]     path{fill:unset}.show[_ngcontent-%COMP%]{opacity:1}.show-on-hover[_ngcontent-%COMP%]{opacity:0}.highlight[_ngcontent-%COMP%]{background-color:#eee}.highlight-border-right[_ngcontent-%COMP%]{border-right:2px solid #ff9800}.highlight-border-left[_ngcontent-%COMP%]{border-left:2px solid #ff9800}"],changeDetection:0}),n})(),qNe=["content"];function YNe(n,t){1&n&&(Ot(0),zt(1),kt())}var XNe=["*"],Rte=(()=>{class n{constructor(e){this.viewRef=e,this.onOpen=new F,this.onClose=new F,this.visible$=new Ai(!1),this.canClose=!0,this.clickListener=this.maybeClose.bind(this)}ngOnInit(){this.visible$.subscribe(e=>{window.requestAnimationFrame(()=>{this.canClose=!0,e?(this.ensureContentIsWithinWindow(),this.onOpen.emit()):this.onClose.emit()})})}openAtPosition(e){let i=this.viewRef.element.nativeElement,r=i.getBoundingClientRect().top;0!==r&&(i.style.top=-1*r+i.offsetTop+"px"),this.content.nativeElement.style.left=e.x+"px",this.content.nativeElement.style.top=e.y+"px",this.canClose=!1,this.visible$.next(!0),document.addEventListener("click",this.clickListener)}ensureContentIsWithinWindow(){if(!this.content)return;let e=this.content.nativeElement.getBoundingClientRect();e.left<0&&(this.content.nativeElement.style.left=0),e.left+e.width>window.innerWidth&&(this.content.nativeElement.style.left=window.innerWidth-e.width+"px"),e.top<0&&(this.content.nativeElement.style.top=0),e.top+e.height>window.innerHeight&&(this.content.nativeElement.style.top=window.innerHeight-e.height+"px")}maybeClose(){!this.canClose||this.close()}close(){document.removeEventListener("click",this.clickListener),this.visible$.next(!1)}}return n.\u0275fac=function(e){return new(e||n)(C(si))},n.\u0275cmp=O({type:n,selectors:[["custom-modal"]],viewQuery:function(e,i){if(1&e&&Ge(qNe,5),2&e){let r;Se(r=Ee())&&(i.content=r.first)}},hostBindings:function(e,i){1&e&&I("keydown.escape",function(o){return i.maybeClose(o)},0,hc)},outputs:{onOpen:"onOpen",onClose:"onClose"},ngContentSelectors:XNe,decls:4,vars:3,consts:[[1,"content",3,"click"],["content",""],[4,"ngIf"]],template:function(e,i){1&e&&(Dn(),h(0,"div",0,1),I("click",function(o){return o.stopPropagation()}),S(2,YNe,2,0,"ng-container",2),j(3,"async"),g()),2&e&&(v(2),_("ngIf",W(3,1,i.visible$)))},dependencies:[Fe,ct],styles:["[_nghost-%COMP%] {\n        position: fixed;\n        left: 0;\n        z-index: 9001;\n      }\n\n      .content[_ngcontent-%COMP%] {\n        position: absolute;\n      }"]}),n})(),ZNe=["search"],KNe=["columnList"],JNe=function(n){return{selected:n}};function $Ne(n,t){if(1&n){let e=ge();h(0,"button",8),I("click",function(){let o=X(e).$implicit;return Q(w().selectColumn(o))}),j(1,"async"),T(2),g()}if(2&n){let e=t.$implicit,i=t.index,r=w();_("ngClass",In(4,JNe,i===W(1,2,r.selectedIndex$))),v(2),He(" ",e.displayName," ")}}var aA=(()=>{class n{constructor(){this.selectableColumns=[],this.columnSelected=new F,this.searchInput="",this.selectedIndex$=new Ai(0),this.isActive=!1}ngOnInit(){this.selectedIndex$.subscribe(()=>{if(!this.columnList)return;let e=this.columnList.nativeElement.querySelector("button.selected");if(!e)return;let i=this.columnList.nativeElement.getBoundingClientRect().height,r=e.getBoundingClientRect().height,o=this.columnList.nativeElement.scrollTop;this.selectedIndex$.getValue()*r<o&&(this.columnList.nativeElement.scrollTop=this.selectedIndex$.getValue()*r),(this.selectedIndex$.getValue()+1)*r>o+i&&(this.columnList.nativeElement.scrollTop=(this.selectedIndex$.getValue()+1)*r-i)})}ngAfterViewInit(){this.searchInput="",this.searchField.nativeElement.focus(),this.selectedIndex$.next(0)}focus(){this.searchField?.nativeElement.focus()}getFilteredColumns(){return this.selectableColumns.filter(e=>e.name.toLowerCase().match(this.searchInput.toLowerCase())||e.displayName.toLowerCase().match(this.searchInput.toLowerCase()))}searchInputChanged(){this.selectedIndex$.next(Math.min(this.selectedIndex$.getValue(),this.selectableColumns.length-1))}selectColumn(e){this.selectedIndex$.next(0),this.columnSelected.emit(e)}activate(){this.isActive=!0}deactivate(){this.isActive=!1}onUpArrow(){!this.isActive||this.selectedIndex$.next(Math.max(this.selectedIndex$.getValue()-1,0))}onDownArrow(){!this.isActive||this.selectedIndex$.next(Math.min(this.selectedIndex$.getValue()+1,this.getFilteredColumns().length-1))}onEnterPressed(){!this.isActive||this.selectColumn(this.getFilteredColumns()[this.selectedIndex$.getValue()])}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["tb-data-table-column-selector-component"]],viewQuery:function(e,i){if(1&e&&(Ge(ZNe,5),Ge(KNe,5)),2&e){let r;Se(r=Ee())&&(i.searchField=r.first),Se(r=Ee())&&(i.columnList=r.first)}},hostBindings:function(e,i){1&e&&I("keydown.arrowup",function(o){return i.onUpArrow(o)},0,hc)("keydown.arrowdown",function(o){return i.onDownArrow(o)},!1,hc)("keydown.enter",function(o){return i.onEnterPressed(o)},!1,hc)},inputs:{selectableColumns:"selectableColumns"},outputs:{columnSelected:"columnSelected"},decls:10,vars:2,consts:[[1,"contents"],[1,"search-area"],["matPrefix","","svgIcon","search_24px",1,"search-icon"],["matInput","",3,"ngModel","ngModelChange"],["search",""],[1,"column-list"],["columnList",""],["mat-button","","class","column-button",3,"ngClass","click",4,"ngFor","ngForOf"],["mat-button","",1,"column-button",3,"ngClass","click"]],template:function(e,i){1&e&&(h(0,"div",0)(1,"mat-form-field",1),P(2,"mat-icon",2),h(3,"mat-label"),T(4,"Search"),g(),h(5,"input",3,4),I("ngModelChange",function(o){return i.searchInput=o})("ngModelChange",function(){return i.searchInputChanged()}),g()(),h(7,"div",5,6),S(9,$Ne,3,6,"button",7),g()()),2&e&&(v(5),_("ngModel",i.searchInput),v(4),_("ngForOf",i.getFilteredColumns()))},dependencies:[yn,nn,En,Uu,Ka,kc,S9,Ji,bg,cE,q2,ct],styles:[".contents[_ngcontent-%COMP%]{display:flex;flex-direction:column;align-items:flex-start;padding:8px;border-radius:4px;border:1px solid;box-shadow:0px 4px 4px rgba(0,0,0,.25);border-color:#ebebeb;background-color:#fff}body.dark-mode[_nghost-%COMP%]   .contents[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .contents[_ngcontent-%COMP%]{border-color:#555;background-color:#303030}.contents[_ngcontent-%COMP%]   .search-area[_ngcontent-%COMP%]{margin-bottom:4px}.contents[_ngcontent-%COMP%]   .column-list[_ngcontent-%COMP%]{display:flex;flex-direction:column;width:100%;max-height:300px;overflow-y:auto}.contents[_ngcontent-%COMP%]   .column-button[_ngcontent-%COMP%]{flex-shrink:0;height:48px;justify-content:left;width:100%}.contents[_ngcontent-%COMP%]   .column-button.selected[_ngcontent-%COMP%]{background-color:#eee}body.dark-mode[_nghost-%COMP%]   .contents[_ngcontent-%COMP%]   .column-button.selected[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .contents[_ngcontent-%COMP%]   .column-button.selected[_ngcontent-%COMP%]{background-color:#bdbdbd}"],changeDetection:0}),n})(),tLe=["panel"];function nLe(n,t){if(1&n&&(h(0,"div",0,1),zt(2),g()),2&n){let e=t.id,i=w();_("id",i.id)("ngClass",i._classList)("@panelAnimation",i.isOpen?"visible":"hidden"),Be("aria-label",i.ariaLabel||null)("aria-labelledby",i._getPanelAriaLabelledby(e))}}var iLe=["*"],rLe=_r("panelAnimation",[wi("void, hidden",rn({opacity:0,transform:"scaleY(0.8)"})),gi(":enter, hidden => visible",[Ob([Ci("0.03s linear",rn({opacity:1})),Ci("0.12s cubic-bezier(0, 0, 0.2, 1)",rn({transform:"scaleY(1)"}))])]),gi(":leave, visible => hidden",[Ci("0.075s linear",rn({opacity:0}))])]),oLe=0,sLe=us(class{}),Pte=new ie("mat-autocomplete-default-options",{providedIn:"root",factory:function(){return{autoActiveFirstOption:!1,autoSelectActiveOption:!1,hideSingleSelectionIndicator:!1}}}),lLe=(()=>{class n extends sLe{get isOpen(){return this._isOpen&&this.showPanel}_setColor(e){this._color=e,this._setThemeClasses(this._classList)}get autoActiveFirstOption(){return this._autoActiveFirstOption}set autoActiveFirstOption(e){this._autoActiveFirstOption=Rt(e)}get autoSelectActiveOption(){return this._autoSelectActiveOption}set autoSelectActiveOption(e){this._autoSelectActiveOption=Rt(e)}set classList(e){this._classList=e&&e.length?function(n,t=/\s+/){let e=[];if(null!=n){let i=Array.isArray(n)?n:`${n}`.split(t);for(let r of i){let o=`${r}`.trim();o&&e.push(o)}}return e}(e).reduce((i,r)=>(i[r]=!0,i),{}):{},this._setVisibilityClasses(this._classList),this._setThemeClasses(this._classList),this._elementRef.nativeElement.className=""}constructor(e,i,r,o){super(),this._changeDetectorRef=e,this._elementRef=i,this._defaults=r,this._activeOptionChanges=Mn.EMPTY,this.showPanel=!1,this._isOpen=!1,this.displayWith=null,this._autoActiveFirstOption=!!this._defaults.autoActiveFirstOption,this._autoSelectActiveOption=!!this._defaults.autoSelectActiveOption,this.optionSelected=new F,this.opened=new F,this.closed=new F,this.optionActivated=new F,this._classList={},this.id="mat-autocomplete-"+oLe++,this.inertGroups=o?.SAFARI||!1}ngAfterContentInit(){this._keyManager=new og(this.options).withWrap(),this._activeOptionChanges=this._keyManager.change.subscribe(e=>{this.isOpen&&this.optionActivated.emit({source:this,option:this.options.toArray()[e]||null})}),this._setVisibility()}ngOnDestroy(){this._keyManager?.destroy(),this._activeOptionChanges.unsubscribe()}_setScrollTop(e){this.panel&&(this.panel.nativeElement.scrollTop=e)}_getScrollTop(){return this.panel?this.panel.nativeElement.scrollTop:0}_setVisibility(){this.showPanel=!!this.options.length,this._setVisibilityClasses(this._classList),this._changeDetectorRef.markForCheck()}_emitSelectEvent(e){let i=new class{constructor(t,e){this.source=t,this.option=e}}(this,e);this.optionSelected.emit(i)}_getPanelAriaLabelledby(e){return this.ariaLabel?null:this.ariaLabelledby?(e?e+" ":"")+this.ariaLabelledby:e}_setVisibilityClasses(e){e[this._visibleClass]=this.showPanel,e[this._hiddenClass]=!this.showPanel}_setThemeClasses(e){e["mat-primary"]="primary"===this._color,e["mat-warn"]="warn"===this._color,e["mat-accent"]="accent"===this._color}}return n.\u0275fac=function(e){return new(e||n)(C($t),C(Me),C(Pte),C(Gn))},n.\u0275dir=we({type:n,viewQuery:function(e,i){if(1&e&&(Ge(Si,7),Ge(tLe,5)),2&e){let r;Se(r=Ee())&&(i.template=r.first),Se(r=Ee())&&(i.panel=r.first)}},inputs:{ariaLabel:["aria-label","ariaLabel"],ariaLabelledby:["aria-labelledby","ariaLabelledby"],displayWith:"displayWith",autoActiveFirstOption:"autoActiveFirstOption",autoSelectActiveOption:"autoSelectActiveOption",panelWidth:"panelWidth",classList:["class","classList"]},outputs:{optionSelected:"optionSelected",opened:"opened",closed:"closed",optionActivated:"optionActivated"},features:[Ke]}),n})(),Ote=(()=>{class n extends lLe{constructor(){super(...arguments),this._visibleClass="mat-mdc-autocomplete-visible",this._hiddenClass="mat-mdc-autocomplete-hidden",this._hideSingleSelectionIndicator=this._defaults.hideSingleSelectionIndicator??!1}get hideSingleSelectionIndicator(){return this._hideSingleSelectionIndicator}set hideSingleSelectionIndicator(e){this._hideSingleSelectionIndicator=Rt(e),this._syncParentProperties()}_syncParentProperties(){if(this.options)for(let e of this.options)e._changeDetectorRef.markForCheck()}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275cmp=O({type:n,selectors:[["mat-autocomplete"]],contentQueries:function(e,i,r){if(1&e&&(Ti(r,Uv,5),Ti(r,Us,5)),2&e){let o;Se(o=Ee())&&(i.optionGroups=o),Se(o=Ee())&&(i.options=o)}},hostAttrs:[1,"mat-mdc-autocomplete"],inputs:{disableRipple:"disableRipple",hideSingleSelectionIndicator:"hideSingleSelectionIndicator"},exportAs:["matAutocomplete"],features:[Qt([{provide:zv,useExisting:n}]),Ke],ngContentSelectors:iLe,decls:1,vars:0,consts:[["role","listbox",1,"mat-mdc-autocomplete-panel","mdc-menu-surface","mdc-menu-surface--open",3,"id","ngClass"],["panel",""]],template:function(e,i){1&e&&(Dn(),S(0,nLe,3,5,"ng-template"))},dependencies:[yn],styles:[".mdc-menu-surface{display:none;position:absolute;box-sizing:border-box;max-width:calc(100vw - 32px);max-width:var(--mdc-menu-max-width, calc(100vw - 32px));max-height:calc(100vh - 32px);max-height:var(--mdc-menu-max-height, calc(100vh - 32px));margin:0;padding:0;transform:scale(1);transform-origin:top left;opacity:0;overflow:auto;will-change:transform,opacity;z-index:8;border-radius:4px;border-radius:var(--mdc-shape-medium, 4px);transform-origin-left:top left;transform-origin-right:top right}.mdc-menu-surface:focus{outline:none}.mdc-menu-surface--animating-open{display:inline-block;transform:scale(0.8);opacity:0}.mdc-menu-surface--open{display:inline-block;transform:scale(1);opacity:1}.mdc-menu-surface--animating-closed{display:inline-block;opacity:0}[dir=rtl] .mdc-menu-surface,.mdc-menu-surface[dir=rtl]{transform-origin-left:top right;transform-origin-right:top left}.mdc-menu-surface--anchor{position:relative;overflow:visible}.mdc-menu-surface--fixed{position:fixed}.mdc-menu-surface--fullwidth{width:100%}.mdc-menu-surface.mat-mdc-autocomplete-panel{width:100%;max-height:256px;position:static;visibility:hidden;transform-origin:center top;margin:0;padding:8px 0;list-style-type:none}.mdc-menu-surface.mat-mdc-autocomplete-panel:focus{outline:none}.cdk-high-contrast-active .mdc-menu-surface.mat-mdc-autocomplete-panel{outline:solid 1px}.cdk-overlay-pane:not(.mat-mdc-autocomplete-panel-above) .mdc-menu-surface.mat-mdc-autocomplete-panel{border-top-left-radius:0;border-top-right-radius:0}.mat-mdc-autocomplete-panel-above .mdc-menu-surface.mat-mdc-autocomplete-panel{border-bottom-left-radius:0;border-bottom-right-radius:0;transform-origin:center bottom}.mdc-menu-surface.mat-mdc-autocomplete-panel.mat-mdc-autocomplete-visible{visibility:visible}.mdc-menu-surface.mat-mdc-autocomplete-panel.mat-mdc-autocomplete-hidden{visibility:hidden}mat-autocomplete{display:none}"],encapsulation:2,data:{animation:[rLe]},changeDetection:0}),n})(),cLe={provide:Mo,useExisting:$n(()=>Kx),multi:!0},kte=new ie("mat-autocomplete-scroll-strategy"),uLe={provide:kte,deps:[zi],useFactory:function(n){return()=>n.scrollStrategies.reposition()}},pLe=(()=>{class n{get autocompleteDisabled(){return this._autocompleteDisabled}set autocompleteDisabled(e){this._autocompleteDisabled=Rt(e)}constructor(e,i,r,o,s,a,l,c,d,u,p){this._element=e,this._overlay=i,this._viewContainerRef=r,this._zone=o,this._changeDetectorRef=s,this._dir=l,this._formField=c,this._document=d,this._viewportRuler=u,this._defaults=p,this._componentDestroyed=!1,this._autocompleteDisabled=!1,this._manuallyFloatingLabel=!1,this._viewportSubscription=Mn.EMPTY,this._canOpenOnNextFocus=!0,this._closeKeyEventStream=new Ie,this._windowBlurHandler=()=>{this._canOpenOnNextFocus=this._document.activeElement!==this._element.nativeElement||this.panelOpen},this._onChange=()=>{},this._onTouched=()=>{},this.position="auto",this.autocompleteAttribute="off",this._overlayAttached=!1,this.optionSelections=ta(()=>{let f=this.autocomplete?this.autocomplete.options:null;return f?f.changes.pipe(qn(f),Jn(()=>tn(...f.map(m=>m.onSelectionChange)))):this._zone.onStable.pipe(Yt(1),Jn(()=>this.optionSelections))}),this._scrollStrategy=a}ngAfterViewInit(){let e=this._getWindow();typeof e<"u"&&this._zone.runOutsideAngular(()=>e.addEventListener("blur",this._windowBlurHandler))}ngOnChanges(e){e.position&&this._positionStrategy&&(this._setStrategyPositions(this._positionStrategy),this.panelOpen&&this._overlayRef.updatePosition())}ngOnDestroy(){let e=this._getWindow();typeof e<"u"&&e.removeEventListener("blur",this._windowBlurHandler),this._viewportSubscription.unsubscribe(),this._componentDestroyed=!0,this._destroyPanel(),this._closeKeyEventStream.complete()}get panelOpen(){return this._overlayAttached&&this.autocomplete.showPanel}openPanel(){this._attachOverlay(),this._floatLabel()}closePanel(){this._resetLabel(),this._overlayAttached&&(this.panelOpen&&this._zone.run(()=>{this.autocomplete.closed.emit()}),this.autocomplete._isOpen=this._overlayAttached=!1,this._pendingAutoselectedOption=null,this._overlayRef&&this._overlayRef.hasAttached()&&(this._overlayRef.detach(),this._closingActionsSubscription.unsubscribe()),this._componentDestroyed||this._changeDetectorRef.detectChanges())}updatePosition(){this._overlayAttached&&this._overlayRef.updatePosition()}get panelClosingActions(){return tn(this.optionSelections,this.autocomplete._keyManager.tabOut.pipe(ke(()=>this._overlayAttached)),this._closeKeyEventStream,this._getOutsideClickStream(),this._overlayRef?this._overlayRef.detachments().pipe(ke(()=>this._overlayAttached)):Ht()).pipe(N(e=>e instanceof Hv?e:null))}get activeOption(){return this.autocomplete&&this.autocomplete._keyManager?this.autocomplete._keyManager.activeItem:null}_getOutsideClickStream(){return tn(mi(this._document,"click"),mi(this._document,"auxclick"),mi(this._document,"touchend")).pipe(ke(e=>{let i=ma(e),r=this._formField?this._formField._elementRef.nativeElement:null,o=this.connectedTo?this.connectedTo.elementRef.nativeElement:null;return this._overlayAttached&&i!==this._element.nativeElement&&this._document.activeElement!==this._element.nativeElement&&(!r||!r.contains(i))&&(!o||!o.contains(i))&&!!this._overlayRef&&!this._overlayRef.overlayElement.contains(i)}))}writeValue(e){Promise.resolve(null).then(()=>this._assignOptionValue(e))}registerOnChange(e){this._onChange=e}registerOnTouched(e){this._onTouched=e}setDisabledState(e){this._element.nativeElement.disabled=e}_handleKeydown(e){let i=e.keyCode,r=vr(e);if(27===i&&!r&&e.preventDefault(),this.activeOption&&13===i&&this.panelOpen&&!r)this.activeOption._selectViaInteraction(),this._resetActiveItem(),e.preventDefault();else if(this.autocomplete){let o=this.autocomplete._keyManager.activeItem,s=38===i||40===i;9===i||s&&!r&&this.panelOpen?this.autocomplete._keyManager.onKeydown(e):s&&this._canOpen()&&this.openPanel(),(s||this.autocomplete._keyManager.activeItem!==o)&&(this._scrollToOption(this.autocomplete._keyManager.activeItemIndex||0),this.autocomplete.autoSelectActiveOption&&this.activeOption&&(this._pendingAutoselectedOption||(this._valueBeforeAutoSelection=this._element.nativeElement.value),this._pendingAutoselectedOption=this.activeOption,this._assignOptionValue(this.activeOption.value)))}}_handleInput(e){let i=e.target,r=i.value;"number"===i.type&&(r=""==r?null:parseFloat(r)),this._previousValue!==r&&(this._previousValue=r,this._pendingAutoselectedOption=null,this._onChange(r),this._canOpen()&&this._document.activeElement===e.target&&this.openPanel())}_handleFocus(){this._canOpenOnNextFocus?this._canOpen()&&(this._previousValue=this._element.nativeElement.value,this._attachOverlay(),this._floatLabel(!0)):this._canOpenOnNextFocus=!0}_handleClick(){this._canOpen()&&!this.panelOpen&&this.openPanel()}_floatLabel(e=!1){this._formField&&"auto"===this._formField.floatLabel&&(e?this._formField._animateAndLockLabel():this._formField.floatLabel="always",this._manuallyFloatingLabel=!0)}_resetLabel(){this._manuallyFloatingLabel&&(this._formField&&(this._formField.floatLabel="auto"),this._manuallyFloatingLabel=!1)}_subscribeToClosingActions(){return tn(this._zone.onStable.pipe(Yt(1)),this.autocomplete.options.changes.pipe(Nt(()=>this._positionStrategy.reapplyLastPosition()),Sa(0))).pipe(Jn(()=>(this._zone.run(()=>{let r=this.panelOpen;this._resetActiveItem(),this.autocomplete._setVisibility(),this._changeDetectorRef.detectChanges(),this.panelOpen&&this._overlayRef.updatePosition(),r!==this.panelOpen&&(this.panelOpen?this.autocomplete.opened.emit():this.autocomplete.closed.emit())}),this.panelClosingActions)),Yt(1)).subscribe(r=>this._setValueAndClose(r))}_destroyPanel(){this._overlayRef&&(this.closePanel(),this._overlayRef.dispose(),this._overlayRef=null)}_assignOptionValue(e){let i=this.autocomplete&&this.autocomplete.displayWith?this.autocomplete.displayWith(e):e;this._updateNativeInputValue(i??"")}_updateNativeInputValue(e){this._formField?this._formField._control.value=e:this._element.nativeElement.value=e,this._previousValue=e}_setValueAndClose(e){let i=e?e.source:this._pendingAutoselectedOption;i&&(this._clearPreviousSelectedOption(i),this._assignOptionValue(i.value),this._onChange(i.value),this.autocomplete._emitSelectEvent(i),this._element.nativeElement.focus()),this.closePanel()}_clearPreviousSelectedOption(e){this.autocomplete.options.forEach(i=>{i!==e&&i.selected&&i.deselect()})}_attachOverlay(){let e=this._overlayRef;e?(this._positionStrategy.setOrigin(this._getConnectedElement()),e.updateSize({width:this._getPanelWidth()})):(this._portal=new Yo(this.autocomplete.template,this._viewContainerRef,{id:this._formField?.getLabelId()}),e=this._overlay.create(this._getOverlayConfig()),this._overlayRef=e,this._handleOverlayEvents(e),this._viewportSubscription=this._viewportRuler.change().subscribe(()=>{this.panelOpen&&e&&e.updateSize({width:this._getPanelWidth()})})),e&&!e.hasAttached()&&(e.attach(this._portal),this._closingActionsSubscription=this._subscribeToClosingActions());let i=this.panelOpen;this.autocomplete._setVisibility(),this.autocomplete._isOpen=this._overlayAttached=!0,this.autocomplete._setColor(this._formField?.color),this.panelOpen&&i!==this.panelOpen&&this.autocomplete.opened.emit()}_getOverlayConfig(){return new Qa({positionStrategy:this._getOverlayPosition(),scrollStrategy:this._scrollStrategy(),width:this._getPanelWidth(),direction:this._dir??void 0,panelClass:this._defaults?.overlayPanelClass})}_getOverlayPosition(){let e=this._overlay.position().flexibleConnectedTo(this._getConnectedElement()).withFlexibleDimensions(!1).withPush(!1);return this._setStrategyPositions(e),this._positionStrategy=e,e}_setStrategyPositions(e){let s,i=[{originX:"start",originY:"bottom",overlayX:"start",overlayY:"top"},{originX:"end",originY:"bottom",overlayX:"end",overlayY:"top"}],r=this._aboveClass,o=[{originX:"start",originY:"top",overlayX:"start",overlayY:"bottom",panelClass:r},{originX:"end",originY:"top",overlayX:"end",overlayY:"bottom",panelClass:r}];s="above"===this.position?o:"below"===this.position?i:[...i,...o],e.withPositions(s)}_getConnectedElement(){return this.connectedTo?this.connectedTo.elementRef:this._formField?this._formField.getConnectedOverlayOrigin():this._element}_getPanelWidth(){return this.autocomplete.panelWidth||this._getHostWidth()}_getHostWidth(){return this._getConnectedElement().nativeElement.getBoundingClientRect().width}_resetActiveItem(){let e=this.autocomplete;e.autoActiveFirstOption?e._keyManager.setFirstItemActive():e._keyManager.setActiveItem(-1)}_canOpen(){let e=this._element.nativeElement;return!e.readOnly&&!e.disabled&&!this._autocompleteDisabled}_getWindow(){return this._document?.defaultView||window}_scrollToOption(e){let i=this.autocomplete,r=z1(e,i.options,i.optionGroups);if(0===e&&1===r)i._setScrollTop(0);else if(i.panel){let o=i.options.toArray()[e];if(o){let s=o._getHostElement(),a=U1(s.offsetTop,s.offsetHeight,i._getScrollTop(),i.panel.nativeElement.offsetHeight);i._setScrollTop(a)}}}_handleOverlayEvents(e){e.keydownEvents().subscribe(i=>{(27===i.keyCode&&!vr(i)||38===i.keyCode&&vr(i,"altKey"))&&(this._pendingAutoselectedOption&&(this._updateNativeInputValue(this._valueBeforeAutoSelection??""),this._pendingAutoselectedOption=null),this._closeKeyEventStream.next(),this._resetActiveItem(),i.stopPropagation(),i.preventDefault())}),e.outsidePointerEvents().subscribe()}}return n.\u0275fac=function(e){return new(e||n)(C(Me),C(zi),C(si),C(at),C($t),C(kte),C(Xi,8),C(Sf,9),C(Lt,8),C(js),C(Pte,8))},n.\u0275dir=we({type:n,inputs:{autocomplete:["matAutocomplete","autocomplete"],position:["matAutocompletePosition","position"],connectedTo:["matAutocompleteConnectedTo","connectedTo"],autocompleteAttribute:["autocomplete","autocompleteAttribute"],autocompleteDisabled:["matAutocompleteDisabled","autocompleteDisabled"]},features:[Gt]}),n})(),Kx=(()=>{class n extends pLe{constructor(){super(...arguments),this._aboveClass="mat-mdc-autocomplete-panel-above"}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275dir=we({type:n,selectors:[["input","matAutocomplete",""],["textarea","matAutocomplete",""]],hostAttrs:[1,"mat-mdc-autocomplete-trigger"],hostVars:7,hostBindings:function(e,i){1&e&&I("focusin",function(){return i._handleFocus()})("blur",function(){return i._onTouched()})("input",function(o){return i._handleInput(o)})("keydown",function(o){return i._handleKeydown(o)})("click",function(){return i._handleClick()}),2&e&&Be("autocomplete",i.autocompleteAttribute)("role",i.autocompleteDisabled?null:"combobox")("aria-autocomplete",i.autocompleteDisabled?null:"list")("aria-activedescendant",i.panelOpen&&i.activeOption?i.activeOption.id:null)("aria-expanded",i.autocompleteDisabled?null:i.panelOpen.toString())("aria-owns",i.autocompleteDisabled||!i.panelOpen||null==i.autocomplete?null:i.autocomplete.id)("aria-haspopup",i.autocompleteDisabled?null:"listbox")},exportAs:["matAutocompleteTrigger"],features:[Qt([cLe]),Ke]}),n})(),lA=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({providers:[uLe],imports:[Co,cg,fn,Pe,Pc,cg,fn]}),n})(),Sp=(()=>{class n{constructor(){this.value="",this.placeholder=""}onInputKeyUp(e){"Enter"===e.key&&this.autocompleteTrigger.closePanel()}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["tb-filter-input"]],viewQuery:function(e,i){if(1&e&&Ge(Kx,5),2&e){let r;Se(r=Ee())&&(i.autocompleteTrigger=r.first)}},inputs:{value:"value",matAutocomplete:"matAutocomplete",placeholder:"placeholder"},decls:2,vars:4,consts:[["svgIcon","search_24px"],["type","text","autocomplete","off",3,"placeholder","matAutocomplete","matAutocompleteDisabled","value","keyup"]],template:function(e,i){1&e&&(P(0,"mat-icon",0),h(1,"input",1),I("keyup",function(o){return i.onInputKeyUp(o)}),g()),2&e&&(v(1),_("placeholder",i.placeholder)("matAutocomplete",i.matAutocomplete)("matAutocompleteDisabled",!i.matAutocomplete)("value",i.value))},dependencies:[Kx,En],styles:["[_nghost-%COMP%]{display:flex;font-size:13px}mat-icon[_ngcontent-%COMP%]{color:#616161;flex:none;margin-right:5px}body.dark-mode[_nghost-%COMP%]   mat-icon[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   mat-icon[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}input[_ngcontent-%COMP%]{background-color:inherit;caret-color:currentColor;color:currentColor;font:inherit;border:none;outline:none;padding:0;flex-grow:1}"]}),n})(),fLe=["container"];function mLe(n,t){if(1&n){let e=ge();h(0,"mat-slider",4),I("input",function(r){return X(e),Q(w().handleSingleSliderChange(r.value))}),g()}if(2&n){let e=w();_("disabled",!e.enabled)("min",e.min)("max",e.max)("step",1)("value",e.lowerValue)}}function hLe(n,t){if(1&n){let e=ge();h(0,"span",6,7),P(2,"span",8)(3,"span",9),h(4,"span",10),I("mousedown",function(r){X(e);let o=w(2);return Q(o.handleMouseDown(r,o.Position.LEFT))}),g(),h(5,"span",10),I("mousedown",function(r){X(e);let o=w(2);return Q(o.handleMouseDown(r,o.Position.RIGHT))}),g()()}if(2&n){let e=w(2);v(3),Tt("left",e.getThumbPosition(e.lowerValue))("width",e.getTrackWidth()),v(1),Tt("left",e.getThumbPosition(e.lowerValue)),nt("active",e.isThumbActive(e.Position.LEFT)),v(1),Tt("left",e.getThumbPosition(e.upperValue)),nt("active",e.isThumbActive(e.Position.RIGHT))}}function gLe(n,t){if(1&n&&S(0,hLe,6,12,"span",5),2&n){let e=w();_("ngIf",e.min!==e.max)}}var ll=(()=>(function(n){n[n.NONE=0]="NONE",n[n.LEFT=1]="LEFT",n[n.RIGHT=2]="RIGHT"}(ll||(ll={})),ll))(),dA=(()=>{class n{constructor(e){this.changeDetector=e,this.tickCount=20,this.enabled=!0,this.returnIntegers=!1,this.rangeValuesChanged=new F,this.singleValueChanged=new F,this.Position=ll,this.activeThumb=ll.NONE,this.offsetXFromOriginOfActiveThumb=0,this.ngUnsubscribe=new Ie}getThumbPosition(e){let i=this.getClippedValue(e),r=this.max-this.min;return r<=0?"50%":(i-this.min)/r*100+"%"}getTrackWidth(){if(null===this.upperValue)return"0%";let e=this.max-this.min;return e<=0?"0%":(this.getClippedValue(this.upperValue)-this.getClippedValue(this.lowerValue))/e*100+"%"}getClippedValue(e){return Math.min(Math.max(e,this.min),this.max)}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}ngOnInit(){mi(document,"mousemove",{passive:!0}).pipe(ot(this.ngUnsubscribe)).subscribe(e=>{this.handleMouseMove(e)}),mi(document,"mouseup",{passive:!0}).pipe(ot(this.ngUnsubscribe)).subscribe(e=>{this.handleMouseOut(e)})}handleMouseDown(e,i){e.stopPropagation(),e.preventDefault(),this.activeThumb=i,this.offsetXFromOriginOfActiveThumb=6-e.offsetX}calculateValueFromMouseEvent(e){let a,{left:i,right:r}=this.container.nativeElement.getBoundingClientRect(),s=e.clientX-i+this.offsetXFromOriginOfActiveThumb;if(null!==this.tickCount&&this.tickCount>0){let c=(r-i)/this.tickCount;a=Math.round(s/c)*c/(r-i)}else a=s/(r-i);let l=this.getClippedValue(this.min+(this.max-this.min)*a);return this.returnIntegers?Math.round(l):Number(l.toFixed(10))}handleMouseMove(e){if(this.activeThumb===ll.NONE||null===this.upperValue)return;let i=this.calculateValueFromMouseEvent(e),r=[this.lowerValue,this.upperValue];this.activeThumb===ll.LEFT?(i>this.upperValue&&(this.activeThumb=ll.RIGHT),r=[i,this.upperValue]):(i<this.lowerValue&&(this.activeThumb=ll.LEFT),r=[this.lowerValue,i]),this.maybeNotifyNextRangeValues(r,"SLIDER"),this.changeDetector.markForCheck()}maybeNotifyNextRangeValues(e,i){let[r,o]=e.sort((s,a)=>s-a);(this.lowerValue!==r||this.upperValue!==o)&&this.rangeValuesChanged.emit({lowerValue:r,upperValue:o,source:i})}handleMouseOut(e){this.activeThumb!==ll.NONE&&(this.activeThumb=ll.NONE,this.changeDetector.markForCheck())}handleSingleSliderChange(e){this.singleValueChanged.emit({value:e,source:"SLIDER"})}handleInputChange(e,i){let r=e.target,o=this.getClippedValue(Number(r.value));isNaN(o)||(i===ll.LEFT?null===this.upperValue?this.singleValueChanged.emit({value:o,source:"TEXT"}):this.maybeNotifyNextRangeValues([o,this.upperValue],"TEXT"):""===r.value?this.singleValueChanged.emit({value:this.lowerValue,source:"TEXT_DELETED"}):this.maybeNotifyNextRangeValues([this.lowerValue,o],"TEXT"))}isThumbActive(e){return this.activeThumb===e}}return n.\u0275fac=function(e){return new(e||n)(C($t))},n.\u0275cmp=O({type:n,selectors:[["tb-range-input"]],viewQuery:function(e,i){if(1&e&&Ge(fLe,5,Me),2&e){let r;Se(r=Ee())&&(i.container=r.first)}},inputs:{min:"min",max:"max",lowerValue:"lowerValue",upperValue:"upperValue",tickCount:"tickCount",enabled:"enabled",returnIntegers:"returnIntegers"},outputs:{rangeValuesChanged:"rangeValuesChanged",singleValueChanged:"singleValueChanged"},decls:5,vars:6,consts:[["type","number",1,"lower-input",3,"disabled","value","change"],["type","number",1,"upper-input",3,"disabled","value","change"],["class","single-slider","color","primary",3,"disabled","min","max","step","value","input",4,"ngIf","ngIfElse"],["range",""],["color","primary",1,"single-slider",3,"disabled","min","max","step","value","input"],["class","container",4,"ngIf"],[1,"container"],["container",""],[1,"slider-track"],[1,"slider-track-fill"],[1,"thumb",3,"mousedown"]],template:function(e,i){if(1&e&&(h(0,"input",0),I("change",function(o){return i.handleInputChange(o,i.Position.LEFT)}),g(),h(1,"input",1),I("change",function(o){return i.handleInputChange(o,i.Position.RIGHT)}),g(),S(2,mLe,1,5,"mat-slider",2),S(3,gLe,1,1,"ng-template",null,3,Wt)),2&e){let r=it(4);_("disabled",!i.enabled)("value",i.lowerValue),v(1),_("disabled",!i.enabled)("value",null!==i.upperValue?i.upperValue:""),v(1),_("ngIf",null===i.upperValue)("ngIfElse",r)}},dependencies:[Fe,Dd],styles:['[_nghost-%COMP%]{box-sizing:border-box;display:inline-grid;grid-gap:10px;grid-template-areas:"lower-input upper-input" "slider slider";grid-template-columns:1fr 1fr;font-size:0;min-width:100px;padding:6px}input[_ngcontent-%COMP%]{background-color:inherit;border-style:solid;box-sizing:border-box;color:inherit;overflow:hidden;width:100%}.lower-input[_ngcontent-%COMP%]{grid-area:lower-input}.upper-input[_ngcontent-%COMP%]{grid-area:upper-input;justify-self:flex-end}.single-slider[_ngcontent-%COMP%]{grid-area:slider;padding:0px}.single-slider[_ngcontent-%COMP%]     .mat-slider-wrapper{top:5px;left:0px;right:0px}  .single-slider.mat-slider-horizontal{height:12px}.container[_ngcontent-%COMP%]{grid-area:slider;align-items:center;box-sizing:border-box;display:inline-flex;height:12px;justify-content:center;position:relative;width:100%}.slider-track[_ngcontent-%COMP%]{background:rgba(0,0,0,.26);height:2px;width:100%}body.dark-mode[_nghost-%COMP%]   .slider-track[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .slider-track[_ngcontent-%COMP%]{background:rgba(255,255,255,.3)}.slider-track-fill[_ngcontent-%COMP%]{position:absolute;height:2px}.thumb[_ngcontent-%COMP%]{box-sadhow:0 0 0 1px rgba(0,0,0,.26);border-radius:100%;display:inline-block;height:12px;margin-left:-6px;position:absolute;top:0;transform-origin:center;transition:transform .3s ease;width:12px;will-change:transform}body.dark-mode[_nghost-%COMP%]   .thumb[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .thumb[_ngcontent-%COMP%]{box-sadhow:0 0 0 1px rgba(255,255,255,.3)}.thumb[_ngcontent-%COMP%]:hover{cursor:grab}.thumb[_ngcontent-%COMP%]:active{cursor:grabbing}.thumb.active[_ngcontent-%COMP%]{transform:scale(1.2)}.slider-track-fill[_ngcontent-%COMP%], .thumb[_ngcontent-%COMP%]{background:#f57c00}body.dark-mode[_nghost-%COMP%]   .slider-track-fill[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .slider-track-fill[_ngcontent-%COMP%]{background:#ef6c00}body.dark-mode[_nghost-%COMP%]   .thumb[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .thumb[_ngcontent-%COMP%]{background:#ef6c00}'],changeDetection:0}),n})();function bLe(n,t){if(1&n){let e=ge();h(0,"tb-filter-input",9),I("keyup",function(r){return X(e),Q(w(2).discreteValueKeyUp(r))}),g()}2&n&&_("value",w(2).discreteValueFilter)}function vLe(n,t){1&n&&(h(0,"div",10),T(1," No Matching Values "),g())}function yLe(n,t){if(1&n){let e=ge();h(0,"div",13),I("click",function(r){return r.stopPropagation()}),h(1,"mat-checkbox",3),I("change",function(){let o=X(e).$implicit;return Q(w(3).discreteFilterChanged.emit(o))}),h(2,"span"),T(3),g()()()}if(2&n){let e=t.$implicit,i=w(3);v(1),_("checked",i.filter.filterValues.includes(e)),v(2),bt(e)}}function xLe(n,t){if(1&n&&(h(0,"div",11),S(1,yLe,4,2,"div",12),g()),2&n){let e=w(2);v(1),_("ngForOf",e.getPossibleValues())}}function CLe(n,t){if(1&n&&(h(0,"div",4)(1,"div",5),S(2,bLe,1,1,"tb-filter-input",6),g(),S(3,vLe,2,0,"div",7),S(4,xLe,2,1,"div",8),g()),2&n){let e=w();v(2),_("ngIf",e.filter.possibleValues),v(1),_("ngIf",!e.getPossibleValues().length),v(1),_("ngIf",e.getPossibleValues().length)}}function MLe(n,t){if(1&n){let e=ge();h(0,"div",14),I("click",function(r){return r.stopPropagation()}),h(1,"tb-range-input",15),I("rangeValuesChanged",function(r){return X(e),Q(w().intervalFilterChanged.emit(r))}),g()()}if(2&n){let e=w();v(1),_("min",e.filter.minValue)("max",e.filter.maxValue)("lowerValue",e.filter.filterLowerValue)("upperValue",e.filter.filterUpperValue)}}var Lte=(()=>{class n{constructor(){this.DomainType=gn,this.discreteValueFilter="",this.discreteFilterChanged=new F,this.intervalFilterChanged=new F,this.includeUndefinedToggled=new F}getPossibleValues(){let e=this.filter.possibleValues??[];return this.discreteValueFilter?e.filter(i=>i.toString().match(this.discreteValueFilter)):e}discreteValueKeyUp(e){this.discreteValueFilter=e.target.value}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["tb-data-table-filter"]],inputs:{filter:"filter"},outputs:{discreteFilterChanged:"discreteFilterChanged",intervalFilterChanged:"intervalFilterChanged",includeUndefinedToggled:"includeUndefinedToggled"},decls:5,vars:3,consts:[[1,"filter-dialog"],["class","filter-container",4,"ngIf"],["class","filter-container","disableRipple","",3,"click",4,"ngIf"],[3,"checked","change"],[1,"filter-container"],[1,"input-container"],["placeholder","Filter Discrete Values (regex)",3,"value","keyup",4,"ngIf"],["class","no-matches",4,"ngIf"],["class","discrete-filters-container",4,"ngIf"],["placeholder","Filter Discrete Values (regex)",3,"value","keyup"],[1,"no-matches"],[1,"discrete-filters-container"],["class","discrete-value",3,"click",4,"ngFor","ngForIndex","ngForOf"],[1,"discrete-value",3,"click"],["disableRipple","",1,"filter-container",3,"click"],[1,"range-input",3,"min","max","lowerValue","upperValue","rangeValuesChanged"]],template:function(e,i){1&e&&(h(0,"div",0),S(1,CLe,5,3,"div",1),S(2,MLe,2,4,"div",2),h(3,"mat-checkbox",3),I("change",function(){return i.includeUndefinedToggled.emit()}),T(4,"Include Undefined"),g()()),2&e&&(v(1),_("ngIf",i.filter.type===i.DomainType.DISCRETE),v(1),_("ngIf",i.filter.type===i.DomainType.INTERVAL),v(1),_("checked",i.filter.includeUndefined))},dependencies:[nn,Fe,ha,Sp,dA],styles:[".filter-dialog[_ngcontent-%COMP%]{padding:16px 8px;border-radius:4px;border:1px solid;box-shadow:0px 4px 4px rgba(0,0,0,.25);border-color:#ebebeb;background-color:#fff}body.dark-mode[_nghost-%COMP%]   .filter-dialog[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .filter-dialog[_ngcontent-%COMP%]{border-color:#555;background-color:#303030}.input-container[_ngcontent-%COMP%]{margin-bottom:8px}.discrete-filters-container[_ngcontent-%COMP%]{max-height:300px;overflow-y:auto}.no-matches[_ngcontent-%COMP%]{padding:8px 12px}.filter-container[_ngcontent-%COMP%]{padding-bottom:8px;margin-bottom:8px;border-bottom:1px solid #ebebeb}body.dark-mode[_nghost-%COMP%]   .filter-container[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .filter-container[_ngcontent-%COMP%]{border-bottom-color:#555}.range-input[_ngcontent-%COMP%]{padding:4px 8px;width:200px}.discrete-value[_ngcontent-%COMP%]{overflow:hidden}.discrete-value[_ngcontent-%COMP%]     mat-checkbox, .discrete-value[_ngcontent-%COMP%]     .mdc-form-field, .discrete-value[_ngcontent-%COMP%]     label{width:100%}"]}),n})(),SLe=["columnSelectorModal"],ELe=["contextMenu"],TLe=["filterModal"];function DLe(n,t){1&n&&(h(0,"div",14),T(1," No Actions Available "),g())}function ILe(n,t){if(1&n){let e=ge();h(0,"button",15),I("click",function(){return X(e),Q(w().contextMenuRemoveColumn())}),P(1,"mat-icon",16),T(2,"Remove "),g()}}function ALe(n,t){if(1&n){let e=ge();h(0,"button",17),I("click",function(){X(e);let r=w();return Q(r.sortByHeader(null==r.contextMenuHeader?null:r.contextMenuHeader.name))}),P(1,"mat-icon",18),T(2,"Sort Descending "),g()}}function RLe(n,t){if(1&n){let e=ge();h(0,"button",17),I("click",function(){X(e);let r=w();return Q(r.sortByHeader(null==r.contextMenuHeader?null:r.contextMenuHeader.name))}),P(1,"mat-icon",19),T(2,"Sort Ascending "),g()}}function PLe(n,t){if(1&n){let e=ge();h(0,"button",15),I("click",function(r){X(e);let o=w();return Q(o.openFilterMenu(r,o.contextMenuHeader))}),P(1,"mat-icon",20),T(2," Filter "),g()}}function OLe(n,t){if(1&n){let e=ge();h(0,"button",15),I("click",function(r){X(e);let o=w();return Q(o.openColumnSelector(r,{insertTo:o.Side.LEFT,isSubMenu:!0}))}),P(1,"mat-icon",21),T(2,"Insert Column Left "),g()}}function kLe(n,t){if(1&n){let e=ge();h(0,"button",15),I("click",function(r){X(e);let o=w();return Q(o.openColumnSelector(r,{insertTo:o.Side.RIGHT,isSubMenu:!0}))}),P(1,"mat-icon",21),T(2,"Insert Column Right "),g()}}function FLe(n,t){if(1&n){let e=ge();h(0,"custom-modal",22,23),I("onOpen",function(){return X(e),Q(w().focusColumnSelector())})("onClose",function(){return X(e),Q(w().onColumnSelectorClosed())}),h(2,"tb-data-table-column-selector-component",24),I("columnSelected",function(r){return X(e),Q(w().onColumnAdded(r))}),g()()}if(2&n){let e=w();v(2),_("selectableColumns",e.selectableColumns)}}function NLe(n,t){if(1&n){let e=ge();h(0,"tb-data-table-filter",25),I("intervalFilterChanged",function(r){return X(e),Q(w().intervalFilterChanged(r))})("discreteFilterChanged",function(r){return X(e),Q(w().discreteFilterChanged(r))})("includeUndefinedToggled",function(){return X(e),Q(w().includeUndefinedToggled())}),g()}2&n&&_("filter",w().getCurrentColumnFilter())}function LLe(n,t){if(1&n){let e=ge();h(0,"div",26)(1,"button",27),I("click",function(r){return X(e),Q(w().openColumnSelector(r))}),P(2,"mat-icon",21),g()()}}function BLe(n,t){1&n&&(h(0,"div",28),P(1,"mat-spinner",29),g())}var VLe=[[["","header",""]],[["","content",""]]],HLe=["[header]","[content]"],ec=(()=>(function(n){n[n.RIGHT=0]="RIGHT",n[n.LEFT=1]="LEFT"}(ec||(ec={})),ec))(),CV=function(n){n.preventDefault()},uA=(()=>{class n{constructor(){this.loading=!1,this.headerCellSubscriptions=[],this.contentCellSubscriptions=[],this.contextMenuHeader=void 0,this.insertColumnTo=void 0,this.filterColumn=void 0,this.sortDataBy=new F,this.orderColumns=new F,this.removeColumn=new F,this.addColumn=new F,this.addFilter=new F,this.ColumnHeaders=ht,this.SortingOrder=io,this.Side=ec,this.highlightSide=ec.RIGHT}ngOnDestroy(){document.removeEventListener("dragover",CV),this.headerCellSubscriptions.forEach(e=>{e.unsubscribe()})}ngAfterContentInit(){this.syncHeaders(),this.headerCells.changes.subscribe(this.syncHeaders.bind(this)),this.syncContent(),this.contentCells.changes.subscribe(this.syncContent.bind(this))}syncHeaders(){this.headerCellSubscriptions.forEach(e=>{e.unsubscribe()}),this.headerCellSubscriptions=[],this.headerCells.forEach(e=>{this.headerCellSubscriptions.push(e.dragStart.subscribe(this.dragStart.bind(this)),e.dragEnter.subscribe(this.dragEnter.bind(this)),e.dragEnd.subscribe(this.dragEnd.bind(this)),e.headerClicked.subscribe(this.sortByHeader.bind(this)),e.contextMenuOpened.subscribe(this.openContextMenu.bind(this,e.header)))})}syncContent(){this.contentCellSubscriptions.forEach(e=>{e.unsubscribe()}),this.contentCellSubscriptions=this.contentCells.map(e=>[e.contextMenuOpened.subscribe(this.openContextMenu.bind(this,e.header))]).flat()}sortByHeader(e){this.sortDataBy.emit(this.sortingInfo.name!==e||this.sortingInfo.order!==io.ASCENDING?{name:e,order:io.ASCENDING}:{name:e,order:io.DESCENDING})}dragStart(e){this.draggingHeaderName=e.name,document.addEventListener("dragover",CV)}dragEnd(){!this.draggingHeaderName||!this.highlightedColumnName||(this.orderColumns.emit(this.moveHeader(this.getIndexOfHeaderWithName(this.draggingHeaderName),this.getIndexOfHeaderWithName(this.highlightedColumnName))),this.draggingHeaderName=void 0,this.highlightedColumnName=void 0,document.removeEventListener("dragover",CV),this.headerCells.forEach(e=>{e.highlightStyle$.next({})}))}dragEnter(e){!this.draggingHeaderName||(this.highlightSide=this.getIndexOfHeaderWithName(e.name)<this.getIndexOfHeaderWithName(this.draggingHeaderName)?ec.LEFT:ec.RIGHT,this.highlightedColumnName=e.name,this.headerCells.forEach(i=>{i.highlightStyle$.next(this.getHeaderHighlightStyle(i.header.name))}))}moveHeader(e,i){let r=[...this.headers];return r.splice(e,1),r.splice(i,0,this.headers[e]),r}getHeaderHighlightStyle(e){return e!==this.highlightedColumnName?{}:{highlight:!0,"highlight-border-right":this.highlightSide===ec.RIGHT,"highlight-border-left":this.highlightSide===ec.LEFT}}getIndexOfHeaderWithName(e){return this.headers.findIndex(i=>e===i.name)}focusColumnSelector(){this.columnSelector.focus()}openContextMenu(e,i){i.stopPropagation(),i.preventDefault(),this.columnSelectorModal?.close(),this.filterModal?.close(),this.contextMenuHeader=e,this.contextMenu.openAtPosition({x:i.clientX,y:i.clientY})}onContextMenuClosed(){this.contextMenuHeader=void 0}openColumnSelector(e,i){i?.isSubMenu&&e.stopPropagation(),this.filterModal?.close(),this.insertColumnTo=i?.insertTo;let r=e.target.closest("button").getBoundingClientRect();this.columnSelectorModal.openAtPosition({x:r.x+r.width,y:r.y}),this.columnSelector.activate()}onColumnSelectorClosed(){this.insertColumnTo=void 0,this.columnSelector.deactivate()}canContextMenuRemoveColumn(){return this.contextMenuHeader?.removable}canContextMenuInsert(){return this.selectableColumns&&this.selectableColumns.length&&this.contextMenuHeader?.movable}isContextMenuEmpty(){return!(this.contextMenuHeader?.removable||this.contextMenuHeader?.sortable||this.canContextMenuInsert()||this.contextMenuHeader?.filterable)}contextMenuRemoveColumn(){void 0!==this.contextMenuHeader&&(this.removeColumn.emit(this.contextMenuHeader),this.contextMenu.close(),this.filterModal?.close())}getInsertIndex(){if(void 0===this.contextMenuHeader||void 0===this.insertColumnTo)return;let e=this.headers.indexOf(this.contextMenuHeader);return this.insertColumnTo===ec.LEFT?e:this.insertColumnTo===ec.RIGHT?Math.min(e+1,this.headers.length):e}onColumnAdded(e){this.addColumn.emit({header:e,index:this.getInsertIndex()})}openFilterMenu(e,i){this.filterColumn=i;let r=e.target.closest("button").getBoundingClientRect();e.stopPropagation(),this.columnSelectorModal?.close(),this.filterModal.openAtPosition({x:r.x+r.width,y:r.y})}getCurrentColumnFilter(){if(this.filterColumn)return this.columnFilters.get(this.filterColumn.name)}onFilterClosed(){this.filterColumn=void 0}intervalFilterChanged(e){if(!this.filterColumn)return;let i=this.getCurrentColumnFilter();!i||this.addFilter.emit({header:this.filterColumn,value:{...i,filterLowerValue:e.lowerValue,filterUpperValue:e.upperValue}})}discreteFilterChanged(e){if(!this.filterColumn)return;let i=this.getCurrentColumnFilter();if(!i)return;let r=new Set([...i.filterValues]);r.has(e)?r.delete(e):r.add(e),this.addFilter.emit({header:this.filterColumn,value:{...i,filterValues:Array.from(r)}})}includeUndefinedToggled(){if(!this.filterColumn)return;let e=this.getCurrentColumnFilter();!e||this.addFilter.emit({header:this.filterColumn,value:{...e,includeUndefined:!e.includeUndefined}})}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["tb-data-table"]],contentQueries:function(e,i,r){if(1&e&&(Ti(r,u_,4),Ti(r,d_,5)),2&e){let o;Se(o=Ee())&&(i.headerCells=o),Se(o=Ee())&&(i.contentCells=o)}},viewQuery:function(e,i){if(1&e&&(Ge(SLe,5),Ge(aA,5),Ge(ELe,5),Ge(TLe,5)),2&e){let r;Se(r=Ee())&&(i.columnSelectorModal=r.first),Se(r=Ee())&&(i.columnSelector=r.first),Se(r=Ee())&&(i.contextMenu=r.first),Se(r=Ee())&&(i.filterModal=r.first)}},inputs:{headers:"headers",sortingInfo:"sortingInfo",columnCustomizationEnabled:"columnCustomizationEnabled",selectableColumns:"selectableColumns",columnFilters:"columnFilters",loading:"loading"},outputs:{sortDataBy:"sortDataBy",orderColumns:"orderColumns",removeColumn:"removeColumn",addColumn:"addColumn",addFilter:"addFilter"},ngContentSelectors:HLe,decls:20,vars:11,consts:[[3,"onClose"],["contextMenu",""],[1,"context-menu"],["class","no-actions-message",4,"ngIf"],["class","context-menu-button","mat-button","",3,"click",4,"ngIf"],["class","context-menu-button sort-button","mat-button","",3,"click",4,"ngIf"],["mat-button","","class","context-menu-button",3,"click",4,"ngIf"],[3,"onOpen","onClose",4,"ngIf"],["filterModal",""],[3,"filter","intervalFilterChanged","discreteFilterChanged","includeUndefinedToggled",4,"ngIf"],[1,"data-table"],[1,"header"],["class","add-button-cell",4,"ngIf"],["class","loading",4,"ngIf"],[1,"no-actions-message"],["mat-button","",1,"context-menu-button",3,"click"],["svgIcon","close_24px"],["mat-button","",1,"context-menu-button","sort-button",3,"click"],["svgIcon","arrow_downward_24px"],["svgIcon","arrow_upward_24px"],["svgIcon","filter_alt_24px"],["svgIcon","add_24px"],[3,"onOpen","onClose"],["columnSelectorModal",""],[3,"selectableColumns","columnSelected"],[3,"filter","intervalFilterChanged","discreteFilterChanged","includeUndefinedToggled"],[1,"add-button-cell"],["mat-icon-button","","title","Add Column",1,"add-column-btn",3,"click"],[1,"loading"],["mode","indeterminate","diameter","28"]],template:function(e,i){1&e&&(Dn(VLe),h(0,"custom-modal",0,1),I("onClose",function(){return i.onContextMenuClosed()}),h(2,"div",2),S(3,DLe,2,0,"div",3),S(4,ILe,3,0,"button",4),S(5,ALe,3,0,"button",5),S(6,RLe,3,0,"button",5),S(7,PLe,3,0,"button",4),S(8,OLe,3,0,"button",6),S(9,kLe,3,0,"button",6),g()(),S(10,FLe,3,1,"custom-modal",7),h(11,"custom-modal",0,8),I("onClose",function(){return i.onFilterClosed()}),S(13,NLe,1,1,"tb-data-table-filter",9),g(),h(14,"div",10)(15,"div",11),zt(16),S(17,LLe,3,0,"div",12),g(),zt(18,1),g(),S(19,BLe,2,0,"div",13)),2&e&&(v(3),_("ngIf",i.isContextMenuEmpty()),v(1),_("ngIf",null==i.contextMenuHeader?null:i.contextMenuHeader.removable),v(1),_("ngIf",(null==i.contextMenuHeader?null:i.contextMenuHeader.sortable)&&i.sortingInfo.order===i.SortingOrder.ASCENDING&&i.sortingInfo.name===(null==i.contextMenuHeader?null:i.contextMenuHeader.name)),v(1),_("ngIf",(null==i.contextMenuHeader?null:i.contextMenuHeader.sortable)&&(i.sortingInfo.order!==i.SortingOrder.ASCENDING||i.sortingInfo.name!==(null==i.contextMenuHeader?null:i.contextMenuHeader.name))),v(1),_("ngIf",null==i.contextMenuHeader?null:i.contextMenuHeader.filterable),v(1),_("ngIf",i.canContextMenuInsert()),v(1),_("ngIf",i.canContextMenuInsert()),v(1),_("ngIf",i.selectableColumns&&i.selectableColumns.length),v(3),_("ngIf",i.getCurrentColumnFilter()),v(4),_("ngIf",i.selectableColumns&&i.selectableColumns.length),v(2),_("ngIf",i.loading))},dependencies:[Fe,En,Ji,$i,tl,Rte,aA,Lte],styles:[".data-table[_ngcontent-%COMP%]{font-size:13px;display:table;width:100%}.data-table[_ngcontent-%COMP%]   .header[_ngcontent-%COMP%]{display:table-row;z-index:1}.data-table[_ngcontent-%COMP%]   .header[_ngcontent-%COMP%]{background-color:#fff;position:sticky;text-align:left;top:0;font-weight:bold;vertical-align:bottom}.data-table[_ngcontent-%COMP%]   .header[_ngcontent-%COMP%]:hover{cursor:pointer}body.dark-mode[_nghost-%COMP%]   .data-table[_ngcontent-%COMP%]   .header[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .data-table[_ngcontent-%COMP%]   .header[_ngcontent-%COMP%]{background-color:#303030}.loading[_ngcontent-%COMP%]{align-items:center;border:0;border-bottom:1px solid #ebebeb;display:flex;height:48px;padding:0 24px;justify-content:center}body.dark-mode[_nghost-%COMP%]   .loading[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .loading[_ngcontent-%COMP%]{border-bottom:1px solid #555}.add-button-cell[_ngcontent-%COMP%]{display:table-cell;width:40px}.context-menu[_ngcontent-%COMP%]{border-radius:4px;border:1px solid;box-shadow:0px 4px 4px rgba(0,0,0,.25);border-color:#ebebeb;background-color:#fff}body.dark-mode[_nghost-%COMP%]   .context-menu[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .context-menu[_ngcontent-%COMP%]{border-color:#555;background-color:#303030}.context-menu[_ngcontent-%COMP%]   .context-menu-button[_ngcontent-%COMP%]{justify-content:left;width:100%;text-wrap:nowrap}.context-menu[_ngcontent-%COMP%]   .no-actions-message[_ngcontent-%COMP%]{padding:8px;text-wrap:nowrap}.context-menu[_ngcontent-%COMP%]   .sort-button[_ngcontent-%COMP%]     path{fill:unset}"],changeDetection:0}),n})();function zLe(n,t){if(1&n&&P(0,"tb-data-table-header-cell",5),2&n){let e=w().$implicit,i=w();_("header",e)("sortingInfo",i.sortingInfo)("hparamsEnabled",i.hparamsEnabled)}}function ULe(n,t){if(1&n&&(Ot(0),S(1,zLe,1,3,"tb-data-table-header-cell",4),kt()),2&n){let e=t.$implicit,i=w();v(1),_("ngIf",e.enabled&&(e.type!==i.ColumnHeaderType.SMOOTHED||i.smoothingEnabled))}}function jLe(n,t){if(1&n&&(h(0,"div",9),P(1,"span"),g()),2&n){let e=w(3).$implicit;v(1),Tt("background-color",e.color)}}function GLe(n,t){if(1&n&&(h(0,"tb-data-table-content-cell",7),S(1,jLe,2,2,"div",8),g()),2&n){let e=w().$implicit,i=w().$implicit,r=w();_("header",e)("datum",i[e.name]),v(1),_("ngIf",e.type===r.ColumnHeaderType.COLOR)}}function WLe(n,t){if(1&n&&(Ot(0),S(1,GLe,2,3,"tb-data-table-content-cell",6),kt()),2&n){let e=t.$implicit,i=w(2);v(1),_("ngIf",e.enabled&&(e.type!==i.ColumnHeaderType.SMOOTHED||i.smoothingEnabled))}}function qLe(n,t){if(1&n&&(Ot(0),h(1,"tb-data-table-content-row"),S(2,WLe,2,1,"ng-container",2),g(),kt()),2&n){let e=w();v(2),_("ngForOf",e.getHeaders())}}var Hte=(()=>{class n{constructor(){this.sortDataBy=new F,this.editColumnHeaders=new F,this.removeColumn=new F,this.ColumnHeaderType=ht}getHeaders(){return[{name:"color",displayName:"",type:ht.COLOR,enabled:!0}].concat(this.columnHeaders)}getMinPointInRange(e,i,r){let o=e[i].y,s=e[i];for(let a=i;a<=r;a++)o>e[a].y&&(o=e[a].y,s=e[a]);return s}getMaxPointInRange(e,i,r){let o=e[i].y,s=e[i];for(let a=i;a<=r;a++)o<e[a].y&&(o=e[a].y,s=e[a]);return s}getMean(e,i,r){let o=0;for(let s=i;s<=r;s++)o+=e[s].value;return o/(r-i+1)}getTimeSelectionTableData(){if(!this.stepOrLinkedTimeSelection)return[];let e=this.stepOrLinkedTimeSelection.start.step,i=this.stepOrLinkedTimeSelection.end?.step,r=this.dataSeries.filter(s=>HS(s,this.chartMetadataMap)).map(s=>{let a=this.chartMetadataMap[s.id],l=Zx(s.points,e),c=s.points[l],d=null,u=null;null!=i&&(u=Zx(s.points,i),d=s.points[u]);let p={id:s.id,color:a.color};for(let f of this.columnHeaders)switch(f.type){case ht.RUN:let m="";a.alias&&(m=`${a.alias.aliasNumber} ${a.alias.aliasText}/`),p[f.name]=`${m}${a.displayName}`;continue;case ht.STEP:p[f.name]=c.step;continue;case ht.VALUE:p[f.name]=c.value;continue;case ht.RELATIVE_TIME:p[f.name]=c.relativeTimeInMs;continue;case ht.SMOOTHED:p[f.name]=c.y;continue;case ht.VALUE_CHANGE:if(!d)continue;p[f.name]=d.y-c.y;continue;case ht.START_STEP:p[f.name]=c.step;continue;case ht.END_STEP:if(!d)continue;p[f.name]=d.step;continue;case ht.START_VALUE:p[f.name]=c.y;continue;case ht.END_VALUE:if(!d)continue;p[f.name]=d.y;continue;case ht.MIN_VALUE:if(!u)continue;p[f.name]=this.getMinPointInRange(s.points,l,u).y;continue;case ht.MAX_VALUE:if(!u)continue;p[f.name]=this.getMaxPointInRange(s.points,l,u).y;continue;case ht.PERCENTAGE_CHANGE:if(!d)continue;p[f.name]=(d.y-c.y)/c.y;continue;case ht.STEP_AT_MAX:if(!u)continue;p[f.name]=this.getMaxPointInRange(s.points,l,u).step;continue;case ht.STEP_AT_MIN:if(!u)continue;p[f.name]=this.getMinPointInRange(s.points,l,u).step;continue;case ht.MEAN:if(!u)continue;p[f.name]=this.getMean(s.points,l,u);continue;case ht.RAW_CHANGE:if(!d)continue;p[f.name]=d.value-c.value;continue;default:continue}return p}),o=this.columnHeaders.find(s=>s.name===this.sortingInfo.name);return void 0!==o&&r.sort((s,a)=>{if(!o)return 0;let l=this.getSortableValue(s,o),c=this.getSortableValue(a,o);return l<c?this.sortingInfo.order===io.ASCENDING?-1:1:l>c?this.sortingInfo.order===io.ASCENDING?1:-1:0}),r}getSortableValue(e,i){return function(n){return"object"==typeof n||Number.isNaN(n)||"NaN"===n||null==n?-1/0:n}(i.type===ht.RUN?this.chartMetadataMap[e.id].displayName:e[i.name])}orderColumns(e){this.editColumnHeaders.emit({headers:e,dataTableMode:this.stepOrLinkedTimeSelection.end?ro.RANGE:ro.SINGLE})}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["scalar-card-data-table"]],inputs:{chartMetadataMap:"chartMetadataMap",dataSeries:"dataSeries",stepOrLinkedTimeSelection:"stepOrLinkedTimeSelection",columnHeaders:"columnHeaders",sortingInfo:"sortingInfo",columnCustomizationEnabled:"columnCustomizationEnabled",smoothingEnabled:"smoothingEnabled",hparamsEnabled:"hparamsEnabled"},outputs:{sortDataBy:"sortDataBy",editColumnHeaders:"editColumnHeaders",removeColumn:"removeColumn"},decls:5,vars:5,consts:[[3,"headers","sortingInfo","columnCustomizationEnabled","sortDataBy","orderColumns","removeColumn"],["header",""],[4,"ngFor","ngForOf"],["content",""],["disableContextMenu","true",3,"header","sortingInfo","hparamsEnabled",4,"ngIf"],["disableContextMenu","true",3,"header","sortingInfo","hparamsEnabled"],[3,"header","datum",4,"ngIf"],[3,"header","datum"],["class","row-circle",4,"ngIf"],[1,"row-circle"]],template:function(e,i){1&e&&(h(0,"tb-data-table",0),I("sortDataBy",function(o){return i.sortDataBy.emit(o)})("orderColumns",function(o){return i.orderColumns(o)})("removeColumn",function(o){return i.removeColumn.emit(o)}),Ot(1,1),S(2,ULe,2,1,"ng-container",2),kt(),Ot(3,3),S(4,qLe,3,1,"ng-container",2),kt(),g()),2&e&&(_("headers",i.columnHeaders)("sortingInfo",i.sortingInfo)("columnCustomizationEnabled",i.columnCustomizationEnabled),v(2),_("ngForOf",i.getHeaders()),v(2),_("ngForOf",i.getTimeSelectionTableData()))},dependencies:[nn,Fe,d_,sA,uA,u_],styles:["tb-data-table-content-cell[_ngcontent-%COMP%], tb-data-table-header-cell[_ngcontent-%COMP%]{padding:4px}.row-circle[_ngcontent-%COMP%]{height:12px;width:12px}.row-circle[_ngcontent-%COMP%] > span[_ngcontent-%COMP%]{border-radius:50%;border:1px solid rgba(255,255,255,.4);display:inline-block;height:10px;width:10px;vertical-align:middle}"],changeDetection:0}),n})();var XLe=["stepSpan"];function QLe(n,t){if(1&n){let e=ge();h(0,"button",4),I("click",function(){return X(e),Q(w().fobRemoved.emit())}),P(1,"mat-icon",5),g()}}function ZLe(n,t){if(1&n){let e=ge();h(0,"button",4),I("click",function(){return X(e),Q(w().fobRemoved.emit())}),P(1,"mat-icon",6),g()}}var KLe=function(n,t){return{fob:!0,unremovable:n,prospective:t}},zte=(()=>{class n{constructor(){this.allowRemoval=!0,this.isProspective=!1,this.stepChanged=new F,this.fobRemoved=new F}ngOnChanges(e){e.step&&document.activeElement===this.stepSpan.nativeElement&&this.stepSpan.nativeElement.blur()}validateStep(e){let i=String.fromCharCode(e.which);(" "===e.key||isNaN(Number(i)))&&e.preventDefault()}stepTyped(e){e.preventDefault();let i=e.target.innerText;this.stepChanged.emit(""!==i?Number(i):null)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["card-fob"]],viewQuery:function(e,i){if(1&e&&Ge(XLe,7,Me),2&e){let r;Se(r=Ee())&&(i.stepSpan=r.first)}},inputs:{step:"step",allowRemoval:"allowRemoval",isProspective:"isProspective"},outputs:{stepChanged:"stepChanged",fobRemoved:"fobRemoved"},features:[Gt],decls:5,vars:7,consts:[[3,"ngClass"],["contenteditable","","role","textbox","aria-label","Edit step",3,"innerHTML","blur","keypress","keydown.enter","keydown.shift.enter"],["stepSpan",""],["aria-label","Deselect fob",3,"click",4,"ngIf"],["aria-label","Deselect fob",3,"click"],["svgIcon","close_24px"],["svgIcon","keep_24px"]],template:function(e,i){1&e&&(h(0,"div",0)(1,"span",1,2),I("blur",function(o){return i.stepTyped(o)})("keypress",function(o){return i.validateStep(o)})("keydown.enter",function(o){return i.stepTyped(o)})("keydown.shift.enter",function(o){return o.preventDefault()}),g(),S(3,QLe,2,0,"button",3),S(4,ZLe,2,0,"button",3),g()),2&e&&(_("ngClass",qr(4,KLe,!i.allowRemoval,i.isProspective)),v(1),_("innerHTML",i.step,fO),v(2),_("ngIf",i.allowRemoval),v(1),_("ngIf",i.isProspective))},dependencies:[yn,Fe,En],styles:["[_nghost-%COMP%]{display:inline-block}.fob[_ngcontent-%COMP%]{display:inline-flex;background-color:#e0e0e0;border-radius:25px;padding:2px 2px 2px 4px;font-size:11px;text-align:center;width:min-content}.fob[_ngcontent-%COMP%] > .prospective[_ngcontent-%COMP%]{padding-top:1px}.fob[_ngcontent-%COMP%]:hover{cursor:grab}.fob[_ngcontent-%COMP%]:hover.prospective{cursor:pointer}.fob[_ngcontent-%COMP%]:active{cursor:grabbing}.fob.unremovable[_ngcontent-%COMP%]{padding:2px 4px}.fob.prospective[_ngcontent-%COMP%]{align-items:center;box-sizing:border-box;border:1px dashed #9e9e9e;font-weight:bold;height:17px}span[_ngcontent-%COMP%]{color:inherit;display:inline-block}body.dark-mode[_nghost-%COMP%]   span[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   span[_ngcontent-%COMP%]{color:#616161}button[_ngcontent-%COMP%]{margin-left:2px;padding:0;border:0;border-radius:50%;font-size:11px;width:11px;height:11px;background-color:inherit;color:inherit}button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{width:100%;height:110%}body.dark-mode[_nghost-%COMP%]   button[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   button[_ngcontent-%COMP%]{color:#616161}button[_ngcontent-%COMP%]:hover{background-color:#9e9e9e;color:#eee;cursor:pointer}body.dark-mode[_nghost-%COMP%]   button[_ngcontent-%COMP%]:hover, body.dark-mode   [_nghost-%COMP%]   button[_ngcontent-%COMP%]:hover{background-color:#616161;color:#e0e0e0}"],changeDetection:0}),n})(),$Le=["startFobWrapper"],e3e=["endFobWrapper"],t3e=["prospectiveFobWrapper"];function n3e(n,t){1&n&&P(0,"div",6)}function i3e(n,t){if(1&n&&(h(0,"div",2,3),S(2,n3e,1,0,"div",4),P(3,"card-fob",5),g()),2&n){let e=w();Tt("transform",e.getCssTranslatePxForProspectiveFob()),v(2),_("ngIf",e.showExtendedLine),v(1),_("ngClass",e.isVertical()?"vertical-fob":"horizontal-fob")("allowRemoval",!1)("isProspective",!0)("step",e.prospectiveStep)}}function r3e(n,t){if(1&n){let e=ge();h(0,"div",10),I("mousedown",function(r){X(e);let o=w(2);return Q(o.startDrag(o.Fob.START,o.TimeSelectionAffordance.EXTENDED_LINE,r))}),g()}}function o3e(n,t){if(1&n){let e=ge();h(0,"div",2,7),S(2,r3e,1,0,"div",8),h(3,"card-fob",9),I("mousedown",function(r){X(e);let o=w();return Q(o.startDrag(o.Fob.START,o.TimeSelectionAffordance.FOB,r))})("stepChanged",function(r){X(e);let o=w();return Q(o.stepTyped(o.Fob.START,r))})("fobRemoved",function(){X(e);let r=w();return Q(r.onFobRemoved(r.Fob.START))}),g()()}if(2&n){let e=w();Tt("transform",e.getCssTranslatePxForStartFob()),v(2),_("ngIf",e.showExtendedLine),v(1),_("allowRemoval",!!e.allowFobRemoval||e.timeSelection.end)("ngClass",e.isVertical()?"vertical-fob":"horizontal-fob")("step",e.timeSelection.start.step)}}function s3e(n,t){if(1&n){let e=ge();h(0,"div",10),I("mousedown",function(r){X(e);let o=w(2);return Q(o.startDrag(o.Fob.END,o.TimeSelectionAffordance.EXTENDED_LINE,r))}),g()}}function a3e(n,t){if(1&n){let e=ge();h(0,"div",2,11),S(2,s3e,1,0,"div",8),h(3,"card-fob",12),I("mousedown",function(r){X(e);let o=w();return Q(o.startDrag(o.Fob.END,o.TimeSelectionAffordance.FOB,r))})("stepChanged",function(r){X(e);let o=w();return Q(o.stepTyped(o.Fob.END,r))})("fobRemoved",function(){X(e);let r=w();return Q(r.onFobRemoved(r.Fob.END))}),g()()}if(2&n){let e=w();Tt("transform",e.getCssTranslatePxForEndFob()),v(2),_("ngIf",e.showExtendedLine),v(1),_("ngClass",e.isVertical()?"vertical-fob":"horizontal-fob")("step",e.timeSelection.end.step)}}var Or=(()=>(function(n){n[n.NONE=0]="NONE",n[n.START=1]="START",n[n.END=2]="END"}(Or||(Or={})),Or))(),l3e={start:Or.START,end:Or.END},pA=(()=>{class n{constructor(e){this.root=e,this.showExtendedLine=!1,this.prospectiveStep=null,this.prospectiveStepAxisPosition=null,this.allowFobRemoval=!0,this.onTimeSelectionChanged=new F,this.onTimeSelectionToggled=new F,this.onProspectiveStepChanged=new F,this.hasFobMoved=!1,this.currentDraggingFob=Or.NONE,this.affordance=qs.NONE,this.mouseListener=this.mouseMove.bind(this),this.stopListener=this.stopDrag.bind(this),this.Fob=Or,this.TimeSelectionAffordance=qs}getCssTranslatePxForStartFob(){return this.axisDirection===fs.VERTICAL?`translate(0px, ${this.startStepAxisPosition}px)`:`translate(${this.startStepAxisPosition}px, 0px)`}getCssTranslatePxForEndFob(){return null===this.endStepAxisPosition?"":this.axisDirection===fs.VERTICAL?`translate(0px, ${this.endStepAxisPosition}px)`:`translate(${this.endStepAxisPosition}px, 0px)`}getCssTranslatePxForProspectiveFob(){return null===this.prospectiveStep?"":this.axisDirection===fs.VERTICAL?`translate(0px, ${this.prospectiveStepAxisPosition}px)`:`translate(${this.prospectiveStepAxisPosition}px, 0px)`}stopEventPropagation(e){e.stopPropagation(),e.preventDefault()}startDrag(e,i,r){i!==qs.FOB&&this.stopEventPropagation(r),document.addEventListener("mousemove",this.mouseListener),document.addEventListener("mouseup",this.stopListener),this.currentDraggingFob=e,this.affordance=i}stopDrag(){document.removeEventListener("mousemove",this.mouseListener),document.removeEventListener("mouseup",this.stopListener),this.currentDraggingFob=Or.NONE,this.hasFobMoved&&this.timeSelection&&this.onTimeSelectionChanged.emit({timeSelection:this.timeSelection,affordance:this.affordance}),this.affordance=qs.NONE,this.hasFobMoved=!1}isVertical(){return this.axisDirection===fs.VERTICAL}shouldSwapFobs(e){return!(!this.timeSelection||!this.timeSelection.end)&&(this.currentDraggingFob===Or.END?e<this.timeSelection.start.step:this.currentDraggingFob===Or.START&&e>this.timeSelection.end.step)}getNewTimeSelection(e,i){let r={...i};if(!this.timeSelection)return r;if(!this.timeSelection.end)return r.start={step:e},r;if(this.shouldSwapFobs(e)){let[o,s]=this.currentDraggingFob===Or.END?["end","start"]:["start","end"];return this.currentDraggingFob=l3e[s],r[o]=this.timeSelection[s],r[s]={step:e},r}return this.currentDraggingFob===Or.END?(r.end={step:e},r):(r.start={step:e},r)}getNewStepFromMouseEvent(e){let i=null,r=this.getMousePositionFromEvent(e),o=this.axisDirection===fs.VERTICAL?e.movementY:e.movementX;return this.isMovingHigher(r,o)?i=this.cardFobHelper.getStepHigherThanAxisPosition(r):this.isMovingLower(r,o)&&(i=this.cardFobHelper.getStepLowerThanAxisPosition(r)),null===i?null:i}mouseMove(e){if(this.currentDraggingFob===Or.NONE)return;let i=this.getNewStepFromMouseEvent(e);if(null===i||!this.timeSelection)return;let r=this.getNewTimeSelection(i,this.timeSelection);this.onTimeSelectionChanged.emit({timeSelection:r}),this.hasFobMoved=!0}mouseOverProspectiveFobArea(e){if(null!=this.timeSelection?.end)return;let i=this.getNewStepFromMouseEvent(e);null!==i&&this.onProspectiveStepChanged.emit(i)}isMovingLower(e,i){if(this.currentDraggingFob===Or.NONE&&null===this.prospectiveStep)return!0;let r=this.getCurrentFobStep();return void 0!==r&&e<this.getDraggingFobCenter()&&i<0&&r>this.lowestStep}isMovingHigher(e,i){if(this.currentDraggingFob===Or.NONE&&null===this.prospectiveStep)return!0;let r=this.getCurrentFobStep();return void 0!==r&&e>this.getDraggingFobCenter()&&i>0&&r<this.highestStep}getDraggingFobCenter(){let e=this.getCurrentFob()?.nativeElement;if(!e)return 0;let i=e.getBoundingClientRect().top,r=e.getBoundingClientRect().left;return this.axisDirection===fs.VERTICAL?i-this.root.nativeElement.getBoundingClientRect().top:r-this.root.nativeElement.getBoundingClientRect().left}getCurrentFob(){switch(this.currentDraggingFob){case Or.START:return this.startFobWrapper;case Or.END:return this.endFobWrapper;case Or.NONE:return this.prospectiveFobWrapper}}getCurrentFobStep(){switch(this.currentDraggingFob){case Or.START:return this.timeSelection?.start.step;case Or.END:return this.timeSelection?.end?.step;case Or.NONE:return this.prospectiveStep??void 0}}getMousePositionFromEvent(e){return this.axisDirection===fs.VERTICAL?e.clientY-this.root.nativeElement.getBoundingClientRect().top:e.clientX-this.root.nativeElement.getBoundingClientRect().left}stepTyped(e,i){if(null===i)return void(null!==this.timeSelection.end&&this.onFobRemoved(e));let r={...this.timeSelection};e===Or.START?r.start={step:i}:e===Or.END&&(r.end={step:i}),null!==r.end&&r.start.step>r.end.step&&(r={start:r.end,end:r.start}),this.onTimeSelectionChanged.emit({timeSelection:r,affordance:qs.FOB_TEXT})}prospectiveFobClicked(e){e.stopPropagation();let i=this.getProspectiveTimeSelection();!i||(this.onTimeSelectionChanged.emit({affordance:qs.FOB_ADDED,timeSelection:i}),this.onProspectiveStepChanged.emit(null))}getProspectiveTimeSelection(){if(this.prospectiveStep)return this.timeSelection?{start:{step:Math.min(this.timeSelection.start.step,this.prospectiveStep)},end:{step:Math.max(this.timeSelection.start.step,this.prospectiveStep)}}:{start:{step:this.prospectiveStep},end:null}}onFobRemoved(e){e!==Or.END?null===this.timeSelection.end?this.onTimeSelectionToggled.emit():this.onTimeSelectionChanged.emit({affordance:qs.FOB_REMOVED,timeSelection:{start:this.timeSelection.end,end:null}}):this.onTimeSelectionChanged.emit({affordance:qs.FOB_REMOVED,timeSelection:{...this.timeSelection,end:null}})}onProspectiveAreaMouseLeave(){this.onProspectiveStepChanged.emit(null)}}return n.\u0275fac=function(e){return new(e||n)(C(Me))},n.\u0275cmp=O({type:n,selectors:[["card-fob-controller"]],viewQuery:function(e,i){if(1&e&&(Ge($Le,5),Ge(e3e,5),Ge(t3e,5)),2&e){let r;Se(r=Ee())&&(i.startFobWrapper=r.first),Se(r=Ee())&&(i.endFobWrapper=r.first),Se(r=Ee())&&(i.prospectiveFobWrapper=r.first)}},inputs:{axisDirection:"axisDirection",timeSelection:"timeSelection",cardFobHelper:"cardFobHelper",startStepAxisPosition:"startStepAxisPosition",endStepAxisPosition:"endStepAxisPosition",highestStep:"highestStep",lowestStep:"lowestStep",showExtendedLine:"showExtendedLine",prospectiveStep:"prospectiveStep",prospectiveStepAxisPosition:"prospectiveStepAxisPosition",allowFobRemoval:"allowFobRemoval"},outputs:{onTimeSelectionChanged:"onTimeSelectionChanged",onTimeSelectionToggled:"onTimeSelectionToggled",onProspectiveStepChanged:"onProspectiveStepChanged"},decls:6,vars:4,consts:[["class","time-fob-wrapper",3,"transform",4,"ngIf"],[1,"prospective-fob-area",3,"ngClass","mousemove","click","mouseleave"],[1,"time-fob-wrapper"],["prospectiveFobWrapper",""],["class","extended-line",4,"ngIf"],[3,"ngClass","allowRemoval","isProspective","step"],[1,"extended-line"],["startFobWrapper",""],["class","extended-line",3,"mousedown",4,"ngIf"],[1,"startFob",3,"allowRemoval","ngClass","step","mousedown","stepChanged","fobRemoved"],[1,"extended-line",3,"mousedown"],["endFobWrapper",""],[1,"endFob",3,"ngClass","step","mousedown","stepChanged","fobRemoved"]],template:function(e,i){1&e&&(h(0,"div"),Ot(1),S(2,i3e,4,7,"div",0),h(3,"div",1),I("mousemove",function(o){return i.mouseOverProspectiveFobArea(o)})("click",function(o){return i.prospectiveFobClicked(o)})("mouseleave",function(){return i.onProspectiveAreaMouseLeave()}),g(),kt(),S(4,o3e,4,6,"div",0),S(5,a3e,4,5,"div",0),g()),2&e&&(v(2),_("ngIf",null!==i.prospectiveStep),v(1),_("ngClass",i.isVertical()?"vertical-prospective-area":"horizontal-prospective-area"),v(1),_("ngIf",i.timeSelection),v(1),_("ngIf",i.timeSelection&&i.timeSelection.end))},dependencies:[yn,Fe,zte],styles:["[_nghost-%COMP%]{pointer-events:all}.time-fob-wrapper[_ngcontent-%COMP%]{display:inline-block;position:absolute;top:0;width:0}.vertical-fob[_ngcontent-%COMP%]{transform:translateY(-50%)}.horizontal-fob[_ngcontent-%COMP%]{transform:translateX(-50%)}.extended-line[_ngcontent-%COMP%]{border-style:dashed;border-width:0 1px;height:calc(100% - 30px)}.extended-line[_ngcontent-%COMP%]:hover{background:linear-gradient(to right, transparent 18px, #ccc 19px, #ccc 21px, transparent 22px);border:0;cursor:ew-resize;margin-left:-20px;padding:0 20px}.horizontal-prospective-area[_ngcontent-%COMP%]{bottom:0;cursor:pointer;position:absolute;height:30px;width:calc(100% - 74px)}.prospective-area[_ngcontent-%COMP%]{display:block}"],changeDetection:0}),n})(),MV=(()=>{class n{constructor(){this.disableInteraction=!1,this.allowFobRemoval=!0,this.onTimeSelectionChanged=new F,this.onTimeSelectionToggled=new F,this.axisDirection=fs.HORIZONTAL,this.cardFobHelper={getStepHigherThanAxisPosition:this.getStepHigherThanAxisPosition.bind(this),getStepLowerThanAxisPosition:this.getStepLowerThanAxisPosition.bind(this)},this.prospectiveStep=null}getAxisPositionFromStartStep(){return this.timeSelection?this.scale.forward(this.minMaxHorizontalViewExtend,[0,this.axisSize],this.timeSelection.start.step):""}getAxisPositionFromEndStep(){return this.timeSelection?.end?this.scale.forward(this.minMaxHorizontalViewExtend,[0,this.axisSize],this.timeSelection?.end.step??this.minMaxStep.maxStep):null}getAxisPositionFromProspectiveStep(){return null===this.prospectiveStep?null:this.scale.forward(this.minMaxHorizontalViewExtend,[0,this.axisSize],this.prospectiveStep)}onProspectiveStepChanged(e){this.prospectiveStep=e}getHighestStep(){return this.minMaxStep.maxStep}getLowestStep(){return this.minMaxStep.minStep}getStepHigherThanAxisPosition(e){return this.getStepAtMousePostion(e)}getStepLowerThanAxisPosition(e){return this.getStepAtMousePostion(e)}getStepAtMousePostion(e){let i=Math.round(this.scale.reverse(this.minMaxHorizontalViewExtend,[0,this.axisSize],e));return i>this.getHighestStep()?this.getHighestStep():i<this.getLowestStep()?this.getLowestStep():i}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["scalar-card-fob-controller"]],inputs:{timeSelection:"timeSelection",scale:"scale",minMaxHorizontalViewExtend:"minMaxHorizontalViewExtend",minMaxStep:"minMaxStep",axisSize:"axisSize",disableInteraction:"disableInteraction",allowFobRemoval:"allowFobRemoval"},outputs:{onTimeSelectionChanged:"onTimeSelectionChanged",onTimeSelectionToggled:"onTimeSelectionToggled"},decls:1,vars:13,consts:[[3,"axisDirection","timeSelection","startStepAxisPosition","endStepAxisPosition","prospectiveStepAxisPosition","highestStep","lowestStep","prospectiveStep","cardFobHelper","showExtendedLine","allowFobRemoval","onProspectiveStepChanged","onTimeSelectionChanged","onTimeSelectionToggled"]],template:function(e,i){1&e&&(h(0,"card-fob-controller",0),I("onProspectiveStepChanged",function(o){return i.onProspectiveStepChanged(o)})("onTimeSelectionChanged",function(o){return i.onTimeSelectionChanged.emit(o)})("onTimeSelectionToggled",function(o){return i.onTimeSelectionToggled.emit(o)}),g()),2&e&&(Tt("pointer-events",i.disableInteraction?"none":"all"),_("axisDirection",i.axisDirection)("timeSelection",i.timeSelection)("startStepAxisPosition",i.getAxisPositionFromStartStep())("endStepAxisPosition",i.getAxisPositionFromEndStep())("prospectiveStepAxisPosition",i.getAxisPositionFromProspectiveStep())("highestStep",i.getHighestStep())("lowestStep",i.getLowestStep())("prospectiveStep",i.prospectiveStep)("cardFobHelper",i.cardFobHelper)("showExtendedLine",!0)("allowFobRemoval",i.allowFobRemoval))},dependencies:[pA],styles:["scalar-card-fob-controller .time-fob-wrapper{height:100%}"],changeDetection:0}),n})(),c3e=["dataTableContainer"];function d3e(n,t){if(1&n){let e=ge();h(0,"button",27),I("click",function(){return X(e),Q(w().openTableEditMenu())}),P(1,"mat-icon",28),h(2,"span"),T(3,"Edit Table Columns"),g()()}}function u3e(n,t){1&n&&P(0,"mat-spinner",29)}function p3e(n,t){1&n&&(h(0,"th"),T(1,"Smoothed"),g())}function f3e(n,t){if(1&n&&(Ot(0),P(1,"tb-experiment-alias",35),T(2,"/"),kt()),2&n){let e=w().$implicit;v(1),_("alias",e.metadata.alias)}}function m3e(n,t){if(1&n&&(h(0,"td"),T(1),g()),2&n){let e=w().$implicit,i=w(2);v(1),He(" ",i.valueFormatter.formatShort(e.dataPoint.y)," ")}}function h3e(n,t){if(1&n&&(Ot(0),h(1,"tr",33)(2,"td",34),P(3,"span"),g(),h(4,"td",2),S(5,f3e,3,1,"ng-container",24),T(6),g(),S(7,m3e,2,1,"td",24),h(8,"td"),T(9),g(),h(10,"td"),T(11),g(),h(12,"td"),T(13),j(14,"date"),g(),h(15,"td"),T(16),g()(),kt()),2&n){let e=t.$implicit,i=w(2);v(1),nt("closest",e.metadata.closest),v(2),Tt("background-color",e.metadata.color),v(2),_("ngIf",e.metadata.alias),v(1),He("",e.metadata.displayName," "),v(1),_("ngIf",i.smoothingEnabled),v(2),bt(i.valueFormatter.formatShort(e.dataPoint.value)),v(2),bt(i.stepFormatter.formatShort(e.dataPoint.step)),v(2),bt(qp(14,11,e.dataPoint.wallTime,"short")),v(3),He(" ",i.relativeXFormatter.formatReadable(e.dataPoint.relativeTimeInMs)," ")}}function g3e(n,t){if(1&n&&(h(0,"table",30)(1,"thead")(2,"tr"),P(3,"th",31),h(4,"th"),T(5,"Run"),g(),S(6,p3e,2,0,"th",24),h(7,"th"),T(8,"Value"),g(),h(9,"th"),T(10,"Step"),g(),h(11,"th"),T(12,"Time"),g(),h(13,"th"),T(14,"Relative"),g()()(),h(15,"tbody"),S(16,h3e,17,14,"ng-container",32),g()()),2&n){let e=t.data,i=t.cursorLocationInDataCoord,r=t.cursorLocation,o=w();v(6),_("ngIf",o.smoothingEnabled),v(10),_("ngForOf",o.getCursorAwareTooltipData(e,i,r))("ngForTrackBy",o.trackByTooltipDatum)}}function _3e(n,t){if(1&n){let e=ge();h(0,"button",41),I("click",function(){return X(e),Q(w(2).toggleTableExpanded())}),P(1,"mat-icon",9),g()}if(2&n){let e=w(2);_("title",e.shouldExpandTable()?"Expand Table":"Collapse Table"),v(1),_("svgIcon",e.shouldExpandTable()?"expand_more_24px":"expand_less_24px")}}var b3e=function(n){return{"data-table-container":!0,expanded:n}};function v3e(n,t){if(1&n){let e=ge();Ot(0),h(1,"div",36,37)(3,"scalar-card-data-table",38),I("sortDataBy",function(r){return X(e),Q(w().sortDataBy(r))})("editColumnHeaders",function(r){return X(e),Q(w().editColumnHeaders.emit(r))})("removeColumn",function(r){return X(e),Q(w().removeColumn.emit(r))}),g()(),h(4,"div",39),S(5,_3e,2,2,"button",40),g(),kt()}if(2&n){let e=w();v(1),_("ngClass",In(10,b3e,e.cardState.tableExpanded)),v(2),_("chartMetadataMap",e.chartMetadataMap)("dataSeries",e.dataSeries)("stepOrLinkedTimeSelection",e.stepOrLinkedTimeSelection)("columnHeaders",e.columnHeaders)("sortingInfo",e.sortingInfo)("columnCustomizationEnabled",e.columnCustomizationEnabled)("smoothingEnabled",e.smoothingEnabled)("hparamsEnabled",e.hparamsEnabled),v(2),_("ngIf",e.canExpandTable())}}var y3e=function(n){return[0,n]},x3e=function(){return{"out-of-selected-time":!0,end:!0,range:!0}};function C3e(n,t){if(1&n&&P(0,"div",36),2&n){let e=w(2),i=e.viewExtent,r=e.domDimension,o=e.xScale,s=w();Tt("left",o.forward(i.x,In(3,y3e,r.width),null==s.stepOrLinkedTimeSelection.end?null:s.stepOrLinkedTimeSelection.end.step)+"px"),_("ngClass",cu(5,x3e))}}var M3e=function(n){return[n,0]},w3e=function(n){return{"out-of-selected-time":!0,start:!0,range:n}};function S3e(n,t){if(1&n&&(Ot(0),P(1,"div",36),S(2,C3e,1,6,"div",42),kt()),2&n){let e=w(),i=e.viewExtent,r=e.domDimension,o=e.xScale,s=w();v(1),Tt("right",o.forward(i.x,In(4,M3e,r.width),s.stepOrLinkedTimeSelection.start.step)+"px"),_("ngClass",In(6,w3e,!(null==s.stepOrLinkedTimeSelection.end||!s.stepOrLinkedTimeSelection.end.step))),v(1),_("ngIf",null==s.stepOrLinkedTimeSelection.end?null:s.stepOrLinkedTimeSelection.end.step)}}function E3e(n,t){1&n&&S(0,S3e,3,8,"ng-container",24),2&n&&_("ngIf",w().stepOrLinkedTimeSelection)}function T3e(n,t){if(1&n){let e=ge();Ot(0),h(1,"scalar-card-fob-controller",43),I("onTimeSelectionChanged",function(r){return X(e),Q(w(2).onTimeSelectionChanged.emit(r))})("onTimeSelectionToggled",function(){return X(e),Q(w(2).onFobRemoved())}),g(),kt()}if(2&n){let e=w(),i=e.interactionState,r=e.xScale,o=e.viewExtent,s=e.domDimension,a=w();v(1),_("disableInteraction","NONE"!==i)("timeSelection",a.stepOrLinkedTimeSelection)("scale",r)("minMaxHorizontalViewExtend",o.x)("minMaxStep",a.minMaxStep)("axisSize",s.width)}}function D3e(n,t){1&n&&S(0,T3e,2,6,"ng-container",24),2&n&&_("ngIf",w().showFobController())}var Gte=(()=>{class n{constructor(e,i){this.ref=e,this.dialog=i,this.DataLoadState=Te,this.RendererType=Qi,this.ScaleType=nr,this.onFullSizeToggle=new F,this.onPinClicked=new F,this.onTimeSelectionChanged=new F,this.onStepSelectorToggled=new F,this.onDataTableSorting=new F,this.editColumnHeaders=new F,this.openTableEditMenuToMode=new F,this.removeColumn=new F,this.onLineChartZoom=new F,this.onCardStateChanged=new F,this.sortingInfo={name:"run",order:io.ASCENDING},this.yScaleType=nr.LINEAR,this.isViewBoxOverridden=!1,this.relativeXFormatter=_0,this.valueFormatter=ip,this.stepFormatter=g0}toggleYScaleType(){this.yScaleType=this.yScaleType===nr.LINEAR?nr.LOG10:nr.LINEAR}sortDataBy(e){this.sortingInfo=e,this.onDataTableSorting.emit(e)}resetDomain(){this.lineChart&&this.lineChart.viewBoxReset()}trackByTooltipDatum(e,i){return i.id}getCustomXFormatter(){switch(this.xAxisType){case Pi.RELATIVE:return _0;case Pi.STEP:return l3;default:return}}getCursorAwareTooltipData(e,i,r){let o=e.map(l=>({...l,metadata:{...l.metadata,closest:!1,distToCursorPixels:Math.hypot(l.domPoint.x-r.x,l.domPoint.y-r.y),distToCursorX:l.dataPoint.x-i.x,distToCursorY:l.dataPoint.y-i.y}})),s=1/0,a=0;for(let l=0;l<o.length;l++)s>o[l].metadata.distToCursorPixels&&(s=o[l].metadata.distToCursorPixels,a=l);switch(o.length&&(o[a].metadata.closest=!0),this.tooltipSort){case oo.ASCENDING:return o.sort((l,c)=>l.dataPoint.y-c.dataPoint.y);case oo.DESCENDING:return o.sort((l,c)=>c.dataPoint.y-l.dataPoint.y);case oo.NEAREST:return o.sort((l,c)=>l.metadata.distToCursorPixels-c.metadata.distToCursorPixels);case oo.NEAREST_Y:return o.sort((l,c)=>l.metadata.distToCursorY-c.metadata.distToCursorY);case oo.DEFAULT:case oo.ALPHABETICAL:return o.sort((l,c)=>l.metadata.displayName<c.metadata.displayName?-1:l.metadata.displayName>c.metadata.displayName?1:0)}}openDataDownloadDialog(){this.dialog.open(this.DataDownloadComponent,{data:{cardId:this.cardId}})}onFobRemoved(){this.onStepSelectorToggled.emit(Ys.FOB_DESELECT)}showDataTable(){return this.xAxisType===Pi.STEP&&this.stepOrLinkedTimeSelection}showFobController(){return this.xAxisType===Pi.STEP&&this.minMaxStep}canExpandTable(){return this.dataSeries.filter(i=>HS(i,this.chartMetadataMap)).length>3}shouldExpandTable(){return Boolean(this.dataTableContainer?.nativeElement.style.height||!this.cardState?.tableExpanded)}toggleTableExpanded(){this.onCardStateChanged.emit({...this.cardState,tableExpanded:this.shouldExpandTable()}),this.dataTableContainer&&(this.dataTableContainer.nativeElement.style.height="")}openTableEditMenu(){this.openTableEditMenuToMode.emit(this.rangeEnabled?ro.RANGE:ro.SINGLE)}}return n.\u0275fac=function(e){return new(e||n)(C(Me),C(zl))},n.\u0275cmp=O({type:n,selectors:[["scalar-card-component"]],viewQuery:function(e,i){if(1&e&&(Ge(c_,5),Ge(c3e,5)),2&e){let r;Se(r=Ee())&&(i.lineChart=r.first),Se(r=Ee())&&(i.dataTableContainer=r.first)}},inputs:{cardId:"cardId",chartMetadataMap:"chartMetadataMap",cardState:"cardState",DataDownloadComponent:"DataDownloadComponent",dataSeries:"dataSeries",ignoreOutliers:"ignoreOutliers",isCardVisible:"isCardVisible",isPinned:"isPinned",loadState:"loadState",showFullWidth:"showFullWidth",smoothingEnabled:"smoothingEnabled",tag:"tag",title:"title",tooltipSort:"tooltipSort",xAxisType:"xAxisType",xScaleType:"xScaleType",useDarkMode:"useDarkMode",forceSvg:"forceSvg",columnCustomizationEnabled:"columnCustomizationEnabled",linkedTimeSelection:"linkedTimeSelection",stepOrLinkedTimeSelection:"stepOrLinkedTimeSelection",minMaxStep:"minMaxStep",userViewBox:"userViewBox",columnHeaders:"columnHeaders",rangeEnabled:"rangeEnabled",hparamsEnabled:"hparamsEnabled"},outputs:{onFullSizeToggle:"onFullSizeToggle",onPinClicked:"onPinClicked",onTimeSelectionChanged:"onTimeSelectionChanged",onStepSelectorToggled:"onStepSelectorToggled",onDataTableSorting:"onDataTableSorting",editColumnHeaders:"editColumnHeaders",openTableEditMenuToMode:"openTableEditMenuToMode",removeColumn:"removeColumn",onLineChartZoom:"onLineChartZoom",onCardStateChanged:"onCardStateChanged"},decls:38,vars:29,consts:function(){let t,e,i,r,o,s;return t=$localize`:A button that resets line chart domain to the data␟e68a552941ab427a99e7437e08443f30ac71ccd6␟3830646521058268558:Fit line chart domains to data`,e=$localize`:A button to pin a card.␟e665dc712bd5f18d4dfa3a29e125d565cc51e2f6␟7284606426234375344:Pin card`,i=$localize`:A button on line chart that toggles full size mode.␟fc8f767d0b9f930187a1bae34477ad28736ece33␟915721563638926597:Toggle full size mode`,r=$localize`:An overflow menu button that opens more line chart options␟b260fab946a3077ce20fd28e336979f586720e8d␟878053740210336435:More line chart options`,o=$localize`:A button that toggles log scale on y-axis on a line chart␟fe91f96ab9b3baca5a48913f2b0fae84483d93e3␟3374645620638883926:Toggle Y-axis log scale on line chart`,s=$localize`:Expand Table␟9e59ff50bfcb479272e2b103e1e9b11518e2e4ce␟6374880341393020610:Expand Table`,[[1,"always-visible"],[1,"heading"],[1,"name"],[1,"tag",3,"title","value"],[3,"isClipped"],[1,"controls"],["mat-icon-button","","aria-label",t,3,"disabled","title","click"],["svgIcon","settings_overscan_24px"],["mat-icon-button","","aria-label",e,3,"click"],[3,"svgIcon"],["mat-icon-button","","aria-label",i,"title","Toggle full size mode",3,"click"],["mat-icon-button","","aria-label",r,"title","More line chart options",3,"matMenuTriggerFor"],["svgIcon","more_vert_24px"],["menu","matMenu"],["mat-menu-item","","aria-label",o,3,"click"],["svgIcon","line_weight_24px"],["mat-menu-item","","aria-label","Open dialog to download data",3,"click"],["svgIcon","get_app_24px"],["mat-menu-item","","aria-label","Open menu to edit data table columns",3,"click",4,"ngIf"],[1,"chart-container"],["chartContainer",""],["diameter","18",4,"ngIf"],[3,"disableUpdate","preferredRendererType","seriesData","seriesMetadataMap","xScaleType","yScaleType","customXFormatter","ignoreYOutliers","tooltipTemplate","useDarkMode","userViewBox","customVisTemplate","customChartOverlayTemplate","onViewBoxOverridden","viewBoxChanged"],["tooltip",""],[4,"ngIf"],["lineChartCustomVis",""],["lineChartCustomXAxisVis",""],["mat-menu-item","","aria-label","Open menu to edit data table columns",3,"click"],["svgIcon","edit_24px"],["diameter","18"],[1,"tooltip"],[1,"circle-header"],[4,"ngFor","ngForOf","ngForTrackBy"],[1,"tooltip-row"],[1,"tooltip-row-circle"],[3,"alias"],[3,"ngClass"],["dataTableContainer",""],[3,"chartMetadataMap","dataSeries","stepOrLinkedTimeSelection","columnHeaders","sortingInfo","columnCustomizationEnabled","smoothingEnabled","hparamsEnabled","sortDataBy","editColumnHeaders","removeColumn"],[1,"bottom-area"],["mat-icon-button","","class","expand-button","aria-label",s,3,"title","click",4,"ngIf"],["mat-icon-button","","aria-label",s,1,"expand-button",3,"title","click"],[3,"ngClass","left",4,"ngIf"],[3,"disableInteraction","timeSelection","scale","minMaxHorizontalViewExtend","minMaxStep","axisSize","onTimeSelectionChanged","onTimeSelectionToggled"]]},template:function(e,i){if(1&e&&(h(0,"div",0)(1,"div",1)(2,"span",2),P(3,"tb-truncated-path",3)(4,"vis-linked-time-selection-warning",4),g(),h(5,"span",5)(6,"button",6),I("click",function(){return i.resetDomain()}),j(7,"async"),j(8,"async"),P(9,"mat-icon",7),g(),h(10,"button",8),I("click",function(){return i.onPinClicked.emit(!i.isPinned)}),P(11,"mat-icon",9),g(),h(12,"button",10),I("click",function(){return i.onFullSizeToggle.emit()}),P(13,"mat-icon",9),g(),h(14,"button",11),P(15,"mat-icon",12),g(),h(16,"mat-menu",null,13)(18,"button",14),I("click",function(){return i.toggleYScaleType()}),P(19,"mat-icon",15),h(20,"span"),T(21,"Toggle Y-axis log scale"),g()(),h(22,"button",16),I("click",function(){return i.openDataDownloadDialog()}),P(23,"mat-icon",17),h(24,"span"),T(25,"Download data"),g()(),S(26,d3e,4,0,"button",18),g()()(),h(27,"div",19,20),S(29,u3e,1,0,"mat-spinner",21),h(30,"line-chart",22),I("onViewBoxOverridden",function(o){return i.isViewBoxOverridden=o})("viewBoxChanged",function(o){return i.onLineChartZoom.emit(o)}),g(),S(31,g3e,17,3,"ng-template",null,23,Wt),g()(),S(33,v3e,6,12,"ng-container",24),S(34,E3e,1,1,"ng-template",null,25,Wt),S(36,D3e,1,1,"ng-template",null,26,Wt)),2&e){let r=it(17),o=it(32),s=it(35),a=it(37);v(3),Wi("title",i.tag),Wi("value",i.title),v(1),_("isClipped",i.linkedTimeSelection&&i.linkedTimeSelection.clipped),v(2),_("disabled",!i.lineChart||!W(7,25,i.lineChart.getIsViewBoxOverridden()))("title",i.lineChart&&W(8,27,i.lineChart.getIsViewBoxOverridden())?"Line chart is already fitted to data. When data updates, the line chart will auto fit to its domain.":"Fit line chart domains to data"),v(4),Be("title",i.isPinned?"Unpin card":"Pin card"),v(1),_("svgIcon",i.isPinned?"keep_24px":"keep_outline_24px"),v(2),_("svgIcon",i.showFullWidth?"fullscreen_exit_24px":"fullscreen_24px"),v(1),_("matMenuTriggerFor",r),v(12),_("ngIf",i.columnCustomizationEnabled),v(3),_("ngIf",i.loadState===i.DataLoadState.LOADING),v(1),_("disableUpdate",!i.isCardVisible)("preferredRendererType",i.forceSvg?i.RendererType.SVG:i.RendererType.WEBGL)("seriesData",i.dataSeries)("seriesMetadataMap",i.chartMetadataMap)("xScaleType",i.xScaleType)("yScaleType",i.yScaleType)("customXFormatter",i.getCustomXFormatter())("ignoreYOutliers",i.ignoreOutliers)("tooltipTemplate",o)("useDarkMode",i.useDarkMode)("userViewBox",i.userViewBox)("customVisTemplate",s)("customChartOverlayTemplate",a),v(3),_("ngIf",i.showDataTable())}},dependencies:[yn,nn,Fe,Qu,c_,$i,En,Nc,jl,Lc,tl,Hte,MV,Xg,Qg,ct,gh],styles:["[_nghost-%COMP%]{display:flex;flex-direction:column;box-sizing:border-box;height:100%;padding:16px;padding-top:4px}[_nghost-%COMP%]:has(.expand-button){padding:4px 16px 0}.always-visible[_ngcontent-%COMP%]{display:flex;flex-direction:column;flex-basis:298px}.always-visible[_ngcontent-%COMP%]:not(:has(.expand-button)){flex-grow:1}.heading[_ngcontent-%COMP%]{align-items:center;display:flex;font-size:14px;justify-content:space-between;margin-bottom:4px;position:relative}.heading[_ngcontent-%COMP%]   .name[_ngcontent-%COMP%]{align-items:center;display:grid;gap:5px;grid-template-columns:auto auto}.heading[_ngcontent-%COMP%]   vis-selected-time-clipped[_ngcontent-%COMP%]{font-size:1.2em;line-height:0}.tag[_ngcontent-%COMP%]{overflow:hidden}.controls[_ngcontent-%COMP%]{color:#616161;white-space:nowrap;flex-shrink:0;margin-right:-12px}body.dark-mode[_nghost-%COMP%]   .controls[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .controls[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}.chart-container[_ngcontent-%COMP%]{display:flex;flex-direction:column;flex-grow:1;overflow:hidden;resize:vertical}.chart-container[_ngcontent-%COMP%]   mat-spinner[_ngcontent-%COMP%]{position:absolute;right:11px;top:11px}.chart-container[_ngcontent-%COMP%]   line-chart[_ngcontent-%COMP%]{flex-grow:1}.tooltip[_ngcontent-%COMP%]{border-spacing:4px;font-size:13px}.tooltip[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]{text-align:left}.tooltip[_ngcontent-%COMP%]   .tooltip-row[_ngcontent-%COMP%]{white-space:nowrap}.tooltip[_ngcontent-%COMP%]   .tooltip-row-circle[_ngcontent-%COMP%]{align-items:center;display:inline-flex;height:12px;width:12px}.tooltip[_ngcontent-%COMP%]   .tooltip-row-circle[_ngcontent-%COMP%] > span[_ngcontent-%COMP%]{border-radius:50%;border:1px solid rgba(255,255,255,.4);display:inline-block;height:10px;width:10px}.tooltip[_ngcontent-%COMP%]   .closest[_ngcontent-%COMP%]   .tooltip-row-circle[_ngcontent-%COMP%] > span[_ngcontent-%COMP%]{border-color:#fff;box-shadow:inset 0 0 0 1px #fff}.out-of-selected-time[_ngcontent-%COMP%]{height:100%;position:absolute}.out-of-selected-time.start[_ngcontent-%COMP%]{border-right-width:2px;margin-left:-1px}.out-of-selected-time.start.range[_ngcontent-%COMP%]{left:0}.out-of-selected-time.end[_ngcontent-%COMP%]{border-left-width:2px;margin-right:-1px;right:0}.out-of-selected-time.range[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.5)}body.dark-mode[_nghost-%COMP%]   .out-of-selected-time.range[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .out-of-selected-time.range[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.4)}.data-table-container[_ngcontent-%COMP%]{height:100px;min-height:100px;max-height:50em;overflow:auto;resize:vertical}.data-table-container.expanded[_ngcontent-%COMP%]{height:auto}.bottom-area[_ngcontent-%COMP%]{display:flex;flex-direction:column;align-items:center}.bottom-area[_ngcontent-%COMP%]   .expand-button[_ngcontent-%COMP%]{color:#616161}body.dark-mode[_nghost-%COMP%]   .bottom-area[_ngcontent-%COMP%]   .expand-button[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .bottom-area[_ngcontent-%COMP%]   .expand-button[_ngcontent-%COMP%]{color:rgba(255,255,255,.7);background-color:#303030}"],changeDetection:0}),n})();function A3e(n,t){return n.length===t.length&&n.every((e,i)=>{let r=t[i],o=e.points,s=r.points;return e.runId===r.runId&&o.length===s.length&&o.every((a,l)=>{let c=s[l];return a.x===c.x&&a.y===c.y})})}var Wte=(()=>{class n{constructor(e){this.store=e,this.DataDownloadComponent=kQ,this.pinStateChanged=new F,this.isVisible=!1,this.useDarkMode$=this.store.select(Rl),this.ignoreOutliers$=this.store.select(gf),this.tooltipSort$=this.store.select(hf),this.xAxisType$=this.store.select(Ol),this.forceSvg$=this.store.select(yF),this.columnCustomizationEnabled$=this.store.select(dS),this.xScaleType$=this.store.select(Ol).pipe(N(i=>{switch(i){case Pi.STEP:case Pi.RELATIVE:return nr.LINEAR;case Pi.WALL_TIME:return nr.TIME;default:throw new Error(`Invalid xAxisType for line chart. ${i}`)}})),this.scalarSmoothing$=this.store.select(bd),this.smoothingEnabled$=this.store.select(bd).pipe(N(i=>i>0)),this.showFullWidth$=this.store.select(qa).pipe(N(i=>i[this.cardId]?.fullWidth)),this.ngUnsubscribe=new Ie}onVisibilityChange({visible:e}){this.isVisible=e}isScalarCardMetadata(e){let{plugin:i}=e;return i===zn.SCALARS}onFullSizeToggle(){this.store.dispatch(Bg({cardId:this.cardId}))}ngOnInit(){let i=this.store.select(Wa,this.cardId).pipe(ke(l=>!!l&&this.isScalarCardMetadata(l)),N(l=>l));function s(l){return JSON.stringify(["smoothed",l])}let a=this.store.select(Cu,this.cardId).pipe(ot(this.ngUnsubscribe),ke(l=>Boolean(l)),N(l=>l),Ms(1)).pipe(Li(this.store.select(Ol)),N(([l,c])=>Object.keys(l).map(p=>({runId:p,points:this.stepSeriesToLineSeries(l[p],c)}))),Yn(A3e)).pipe(Li(this.store.select(n1)),ot(this.ngUnsubscribe),N(([l,c])=>c?function(n){let t=[];for(let e of n){let i=[],r=Number.isFinite(e.points[0]?.x)?e.points[0].x:-1/0,o=[];for(let s of e.points)Number.isFinite(s.x)?(s.x<r&&(i.push({seriesId:JSON.stringify([e.runId,i.length]),runId:e.runId,points:o}),o=[]),o.push(s),r=s.x):o.push(s);i.push({seriesId:JSON.stringify([e.runId,i.length]),runId:e.runId,points:o});for(let s=0;s<i.length;s++)t.push({...i[s],partitionIndex:s,partitionSize:i.length})}return t}(l):l.map(d=>({...d,seriesId:d.runId,partitionIndex:0,partitionSize:1}))),N(l=>l.map(c=>{let d=c.points[0]?.wallTime;return{...c,points:c.points.map(u=>({...u,relativeTimeInMs:u.wallTime-d}))}})),Li(this.store.select(Ol)),N(([l,c])=>l.map(d=>({...d,points:d.points.map(u=>{let p;switch(c){case Pi.RELATIVE:p=u.relativeTimeInMs;break;case Pi.WALL_TIME:p=u.wallTime;break;default:p=u.step}return{...u,x:p}})}))),Ms(1));this.userViewBox$=this.store.select(QF,this.cardId),this.minMaxSteps$=dn([this.store.select(EW,this.cardId),this.store.select(TW,this.cardId)]).pipe(N(([l,c])=>{if(l&&c)return{minStep:Math.max(l?.minStep,c?.minStep),maxStep:Math.min(l?.maxStep,c?.maxStep)}})),this.dataSeries$=a.pipe(Li(this.store.select(bd)),Jn(([l,c])=>{let d=l.map(({seriesId:u,points:p})=>({id:u,points:p}));return c<=0?Ht(d):$r(async function(n,t){Number.isFinite(t)||(t=0),t=Math.max(0,Math.min(t,1));let e=[];for(let i of n){let r=i.points[0]?.y;if(i.points.every(c=>c.y==r)){e.push(i);continue}let s=i.points.length>0?0:NaN,a=0,l=i.points.map(c=>{let d=c.y;if(Number.isFinite(d)){s=s*t+(1-t)*d,a++;let u=1===t?1:1-Math.pow(t,a);return{x:c.x,y:s/u}}return{x:c.x,y:d}});e.push({id:i.id,points:l})}return e}(d,c)).pipe(N(u=>{let p=d.map((f,m)=>({id:s(f.id),points:u[m].points.map(({y:b},M)=>({...f.points[M],y:b}))}));return[...d,...p]}))}),qn([])),this.linkedTimeSelection$=dn([this.minMaxSteps$,this.store.select(wu),this.store.select(Eu),this.store.select(Ol)]).pipe(N(([l,c,d,u])=>l&&c&&u===Pi.STEP&&d?Uh(d,l.minStep,l.maxStep):null)),this.stepOrLinkedTimeSelection$=this.store.select(DW,this.cardId),this.columnHeaders$=this.store.select(d1(this.cardId)),this.chartMetadataMap$=a.pipe(Jn(l=>dn(l.map(c=>this.getRunDisplayNameAndAlias(c.runId).pipe(N(d=>({...c,...d})))))),Li(this.store.select(Iu),this.store.select(md),this.store.select(wQ),this.store.select(Au),this.store.select(bd)),wr(0),N(([l,c,d,u,p,f])=>{let m={},b=f>0;for(let M of l){let{seriesId:y,runId:x,displayName:R,alias:A,partitionIndex:V,partitionSize:te}=M;m[y]={type:Wg.ORIGINAL,id:y,alias:A,displayName:te>1?`${R}: ${V}`:R,visible:Boolean(c&&c.get(x)&&(!d||u.has(x))),color:p[x]??"#fff",aux:!1,opacity:1}}if(!b)return m;for(let[M,y]of Object.entries(m)){let x=s(M);m[x]={...y,id:x,type:Wg.DERIVED,aux:!1,originalSeriesId:M},y.aux=!0,y.opacity=.25}return m}),qn({})),this.loadState$=this.store.select(_d,this.cardId),this.tag$=i.pipe(N(l=>l.tag)),this.cardState$=this.store.select(qa).pipe(N(l=>l[this.cardId]||{})),this.title$=this.tag$.pipe(N(l=>Yg(l,this.groupName))),this.isPinned$=this.store.select(Mu,this.cardId),this.rangeEnabled$=this.store.select(c1(this.cardId)),this.hparamsEnabled$=this.store.select(md)}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}getRunDisplayNameAndAlias(e){return dn([this.store.select(g1,{runId:e}),this.store.select(za),this.store.select(_1,{runId:e})]).pipe(N(([i,r,o])=>{let s=null!==i?r[i]??null:null;return{displayName:o||s?o?.name??"...":e,alias:s}}))}stepSeriesToLineSeries(e,i){let r=i===Pi.STEP;return e.map(o=>{let s=1e3*o.wallTime;return{...o,x:r?o.step:s,y:o.value,wallTime:s,relativeTimeInMs:0}})}onDataTableSorting(e){this.store.dispatch(XX(e))}onCardStateChanged(e){this.store.dispatch(fT({cardId:this.cardId,settings:e}))}onTimeSelectionChanged(e){this.store.dispatch(kf({...e,cardId:this.cardId}))}onStepSelectorToggled(e){this.store.dispatch(Id({affordance:e,cardId:this.cardId}))}onLineChartZoom(e){this.store.dispatch(by({userViewBox:e,cardId:this.cardId}))}editColumnHeaders(e){this.store.dispatch(zg(e))}openTableEditMenuToMode(e){this.store.dispatch(aT({mode:e}))}onRemoveColumn(e){this.store.dispatch(Ug({header:e,cardId:this.cardId}))}}return n.\u0275fac=function(e){return new(e||n)(C(Ae))},n.\u0275cmp=O({type:n,selectors:[["scalar-card"]],inputs:{DataDownloadComponent:"DataDownloadComponent",cardId:"cardId",groupName:"groupName"},outputs:{pinStateChanged:"pinStateChanged"},decls:24,vars:72,consts:[["observeIntersection","",3,"cardId","chartMetadataMap","DataDownloadComponent","dataSeries","ignoreOutliers","isCardVisible","isPinned","loadState","showFullWidth","smoothingEnabled","tag","title","cardState","tooltipSort","xAxisType","xScaleType","useDarkMode","linkedTimeSelection","stepOrLinkedTimeSelection","forceSvg","columnCustomizationEnabled","minMaxStep","userViewBox","columnHeaders","rangeEnabled","hparamsEnabled","onFullSizeToggle","onPinClicked","onVisibilityChange","onTimeSelectionChanged","onStepSelectorToggled","onDataTableSorting","onLineChartZoom","editColumnHeaders","onCardStateChanged","openTableEditMenuToMode","removeColumn"]],template:function(e,i){1&e&&(h(0,"scalar-card-component",0),I("onFullSizeToggle",function(){return i.onFullSizeToggle()})("onPinClicked",function(o){return i.pinStateChanged.emit(o)})("onVisibilityChange",function(o){return i.onVisibilityChange(o)})("onTimeSelectionChanged",function(o){return i.onTimeSelectionChanged(o)})("onStepSelectorToggled",function(o){return i.onStepSelectorToggled(o)})("onDataTableSorting",function(o){return i.onDataTableSorting(o)})("onLineChartZoom",function(o){return i.onLineChartZoom(o)})("editColumnHeaders",function(o){return i.editColumnHeaders(o)})("onCardStateChanged",function(o){return i.onCardStateChanged(o)})("openTableEditMenuToMode",function(o){return i.openTableEditMenuToMode(o)})("removeColumn",function(o){return i.onRemoveColumn(o)}),j(1,"async"),j(2,"async"),j(3,"async"),j(4,"async"),j(5,"async"),j(6,"async"),j(7,"async"),j(8,"async"),j(9,"async"),j(10,"async"),j(11,"async"),j(12,"async"),j(13,"async"),j(14,"async"),j(15,"async"),j(16,"async"),j(17,"async"),j(18,"async"),j(19,"async"),j(20,"async"),j(21,"async"),j(22,"async"),j(23,"async"),g()),2&e&&_("cardId",i.cardId)("chartMetadataMap",W(1,26,i.chartMetadataMap$))("DataDownloadComponent",i.DataDownloadComponent)("dataSeries",W(2,28,i.dataSeries$))("ignoreOutliers",W(3,30,i.ignoreOutliers$))("isCardVisible",i.isVisible)("isPinned",W(4,32,i.isPinned$))("loadState",W(5,34,i.loadState$))("showFullWidth",W(6,36,i.showFullWidth$))("smoothingEnabled",W(7,38,i.smoothingEnabled$))("tag",W(8,40,i.tag$))("title",W(9,42,i.title$))("cardState",W(10,44,i.cardState$))("tooltipSort",W(11,46,i.tooltipSort$))("xAxisType",W(12,48,i.xAxisType$))("xScaleType",W(13,50,i.xScaleType$))("useDarkMode",W(14,52,i.useDarkMode$))("linkedTimeSelection",W(15,54,i.linkedTimeSelection$))("stepOrLinkedTimeSelection",W(16,56,i.stepOrLinkedTimeSelection$))("forceSvg",W(17,58,i.forceSvg$))("columnCustomizationEnabled",W(18,60,i.columnCustomizationEnabled$))("minMaxStep",W(19,62,i.minMaxSteps$))("userViewBox",W(20,64,i.userViewBox$))("columnHeaders",W(21,66,i.columnHeaders$))("rangeEnabled",W(22,68,i.rangeEnabled$))("hparamsEnabled",W(23,70,i.hparamsEnabled$))},dependencies:[qg,Gte,ct],styles:["[_nghost-%COMP%] {\n        display: block;\n        height: 100%;\n      }"],changeDetection:0}),n})();function O3e(n,t,e){let i=[],{left:r,right:o}=t,s=(o-r)/e,a=0,l=0;for(let c=0;c<e;c++){let d=r+c*s,u=d+s,p=c===e-1,f=l;for(l=0;a<n.length;){let m=n[a],b=k3e(m,d,u,!p);if(f+=b.curr,l+=b.next,m.x+m.dx>u)break;a++}i.push({x:d,dx:s,y:f})}return i}function k3e(n,t,e,i){let r=n.x,o=n.x+n.dx;if(r>e||o<t)return{curr:0,next:0};if(0===n.dx)return i&&o>=e?{curr:0,next:n.y}:{curr:n.y,next:0};let s=Math.min(o,e)-Math.max(r,t);return{curr:n.y*s/n.dx,next:0}}var F3e=1e4,N3e=.001,L3e=Qr(".2~s"),B3e=Qr(".4~r"),V3e=Qr(".2~e");function Yte(n){if(0===n)return"0";let t=Math.abs(n);return t>=F3e?L3e(n):t<N3e?V3e(n):B3e(n)}var H3e=["main"],z3e=["xAxis"],U3e=["yAxis"],j3e=["content"],G3e=["histograms"];function W3e(n,t){if(1&n&&(Nn(),h(0,"g")(1,"text"),T(2),g()()),2&n){let e=w();Tt("transform",e.getCssTranslatePx(e.tooltipData.xAxis.position,9)),v(2),bt(e.tooltipData.xAxis.label)}}function q3e(n,t){if(1&n&&(Nn(),h(0,"g")(1,"text"),T(2),g()()),2&n){let e=w();Tt("transform",e.getGroupTransform(e.tooltipData.closestDatum)),v(1),Be("y",e.tooltipData.yAxis.position),v(1),He(" ",e.tooltipData.yAxis.label," ")}}function Y3e(n,t){if(1&n){let e=ge();Nn(),Oo(),Ot(0),h(1,"histogram-card-fob-controller",16),I("onTimeSelectionChanged",function(r){return X(e),Q(w().onLinkedTimeSelectionChanged.emit(r))})("onTimeSelectionToggled",function(){return X(e),Q(w().onLinkedTimeToggled.emit())}),g(),kt()}if(2&n){let e=w();v(1),_("timeSelection",e.timeSelection)("steps",e.getSteps())("temporalScale",e.scales.temporalScale)}}function X3e(n,t){if(1&n&&(Nn(),h(0,"g"),P(1,"line",17),g()),2&n){let e=t.$implicit;Tt("transform",w().getCssTranslatePx(0,e))}}function Q3e(n,t){1&n&&(Nn(),P(0,"line",21))}function Z3e(n,t){if(1&n&&(Nn(),P(0,"circle",22)),2&n){let e=w().$implicit,i=w();Tt("transform",i.getCssTranslatePx(i.getUiCoordFromBinForContent(i.getClosestBinFromBinCoordinate(e,i.tooltipData.xPositionInBinCoord)).x,i.getUiCoordFromBinForContent(i.getClosestBinFromBinCoordinate(e,i.tooltipData.xPositionInBinCoord)).y))}}function K3e(n,t){if(1&n){let e=ge();Nn(),h(0,"g",18),I("mouseenter",function(r){let s=X(e).$implicit;return Q(w().updateColorOnHover(r,s,!0))})("mouseleave",function(r){let s=X(e).$implicit;return Q(w().updateColorOnHover(r,s,!1))})("click",function(){let o=X(e).$implicit;return Q(w().onLinkedTimeRangeChanged(o))}),S(1,Q3e,1,0,"line",19),P(2,"path"),S(3,Z3e,1,2,"circle",20),g()}if(2&n){let e=t.$implicit,i=w();Tt("transform",i.getGroupTransform(e))("color",i.getHistogramFill(e)),nt("histogram",!0)("no-color",!i.isDatumInTimeSelectionRange(e)),v(1),_("ngIf",i.mode===i.HistogramMode.OFFSET),v(1),Be("d",i.getHistogramPath(e)),v(1),_("ngIf",i.tooltipData)}}function J3e(n,t){if(1&n&&(Nn(),P(0,"circle",22)),2&n){let e=w(2);Be("cx",e.getUiCoordFromBinForContent(e.tooltipData.closestBin).x)("cy",e.getUiCoordFromBinForContent(e.tooltipData.closestBin).y)}}function $3e(n,t){if(1&n&&(Nn(),h(0,"g",4)(1,"g"),P(2,"path"),S(3,J3e,1,2,"circle",23),g(),h(4,"g",24)(5,"text",25),T(6),g()()()),2&n){let e=w();v(1),Tt("transform",e.getGroupTransform(e.tooltipData.closestDatum)),v(1),Be("d",e.getHistogramPath(e.tooltipData.closestDatum)),v(1),_("ngIf",e.tooltipData.closestBin),v(1),Tt("transform",e.getCssTranslatePx(e.tooltipData.value.position.x,e.tooltipData.value.position.y)),v(2),bt(e.tooltipData.value.label)}}var fA=(()=>{class n{constructor(e){this.changeDetector=e,this.mode=Dr.OFFSET,this.timeProperty=no.STEP,this.timeSelection=null,this.onLinkedTimeSelectionChanged=new F,this.onLinkedTimeToggled=new F,this.HistogramMode=Dr,this.TimeProperty=no,this.tooltipData=null,this.ngUnsubscribe=new Ie,this.layout={histogramHeight:0,contentClientRect:{height:0,width:0}},this.scales=null,this.formatters={binNumber:Yte,count:Qr(".3n"),wallTime:d0("%m/%d %X"),step:Qr(".0f"),relative:i=>Qr(".1r")(i/36e5)+"h"},this.domVisible=!1}ngOnChanges(){this.updateChartIfVisible()}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}ngAfterViewInit(){mi(this.main.nativeElement,"mousemove",{passive:!0}).pipe(ot(this.ngUnsubscribe)).subscribe(e=>this.onMouseMove(e))}getCssTranslatePx(e,i){return`translate(${e}px, ${i}px)`}getClosestBinFromBinCoordinate(e,i){if(!e.bins.length)return{x:0,dx:0,y:0};let r=e.bins[0],o=e.bins.slice(-1)[0];return i<r.x?r:i>=o.x+o.dx?o:e.bins.find(a=>a.x<=i&&i<a.x+a.dx)}getUiCoordFromBinForContent(e){return this.scales?{x:this.scales.binScale(Jx(e)),y:this.scales.countScale(e.y)}:{x:0,y:0}}getHistogramPath(e){if(!this.scales||!e.bins.length)return"";let i=this.scales.binScale,r=this.scales.countScale,o=e.bins[0],s=e.bins.slice(-1)[0],a=[`M${i(Jx(o))},${r(0)}`];for(let l of e.bins)a.push(`L${i(Jx(l))},${r(l.y)}`);return a.push(`L${i(Jx(s))},${r(0)}`),a.join("")}trackByWallTime(e){return e.wallTime}getGroupTransform(e){return this.scales&&this.mode!==Dr.OVERLAY?this.getCssTranslatePx(0,this.scales.temporalScale(this.getTimeValue(e))):""}getSteps(){return this.data.map(e=>e.step)}isTimeSelectionEnabled(e){return Boolean(this.mode===Dr.OFFSET&&this.timeProperty===no.STEP&&this.scales&&e)}isDatumInTimeSelectionRange(e){return!this.isTimeSelectionEnabled(this.timeSelection)||(null===this.timeSelection.end?this.timeSelection.start.step===e.step:this.timeSelection.start.step<=e.step&&this.timeSelection.end.step>=e.step)}getHistogramFill(e){return this.scales?this.scales.d3ColorScale(this.getTimeValue(e)):""}updateColorOnHover(e,i,r){!this.isTimeSelectionEnabled(this.timeSelection)||this.isDatumInTimeSelectionRange(i)||(r?e.target.classList.remove("no-color"):e.target.classList.add("no-color"))}getGridTickYLocs(){if(!this.scales||this.mode===Dr.OFFSET)return[];let e=this.scales.countScale;return e.ticks().map(i=>e(i))}onResize(){this.updateClientRects(),this.updateChartIfVisible()}onVisibilityChange({visible:e}){this.domVisible=e,e&&(this.updateClientRects(),this.updateChartIfVisible())}onLinkedTimeRangeChanged(e){if(!this.isTimeSelectionEnabled(this.timeSelection))return;let i=this.timeSelection.start.step,r=this.timeSelection.end?.step,o=e.step<i?e.step:i,s=r;s=void 0===s?e.step>i?e.step:i:e.step>s?e.step:s,(o!==i||s!==r)&&o!==s&&this.onLinkedTimeSelectionChanged.emit({timeSelection:{start:{step:o},end:{step:s}},affordance:qs.HISTOGRAM_CLICK_TO_RANGE})}getTimeValue(e){switch(this.timeProperty){case no.WALL_TIME:return e.wallTime;case no.STEP:return e.step;case no.RELATIVE:return e.wallTime-this.data[0].wallTime}}updateClientRects(){this.content&&(this.layout.contentClientRect=this.content.nativeElement.getBoundingClientRect(),this.layout.histogramHeight=this.layout.contentClientRect.height/2.5)}updateChartIfVisible(){!this.domVisible||(this.scales=this.computeScales(this.data),this.renderXAxis(),this.renderYAxis(),this.changeDetector.detectChanges())}computeScales(e){let{width:i,height:r}=this.layout.contentClientRect,{min:o,max:s}=Xte(e,y=>function(n,t){return n.reduce((e,i)=>Math.min(e,i.x),1/0)}(y.bins),y=>wV(y.bins,({x:x,dx:R})=>x+R)),a=wV(e,y=>wV(y.bins,({y:x})=>x)),l=Wl().domain([o,s]).nice(),c=this.mode!==Dr.OVERLAY&&this.timeProperty==no.WALL_TIME?em():Wl(),d=e.map(y=>this.getTimeValue(y)),{min:u,max:p}=Xte(d,y=>y),f=[u,p];c.domain(f);let m=Wl();m.domain([0,a]);let b=Hf(this.color||"#000"),M=Wl();return M.domain(f),l.range([0,i]),M.range([b.brighter(),b.darker()]),M.interpolate(mL),this.mode===Dr.OVERLAY?(c.range([r,r]),m.range([r,0])):(c.range([r-(this.mode===Dr.OFFSET?r-this.layout.histogramHeight:0),r]),m.range([0,-this.layout.histogramHeight])),{binScale:l,d3ColorScale:M,countScale:m,temporalScale:c}}renderXAxis(){if(!this.scales)return;let{width:e}=this.layout.contentClientRect,i=function(n){return UQ(jN,n)}(this.scales.binScale).ticks(Math.max(2,e/20));i.tickFormat(this.formatters.binNumber),i(nD(this.xAxis.nativeElement))}getYAxisFormatter(){if(this.mode===Dr.OVERLAY)return this.formatters.count;switch(this.timeProperty){case no.WALL_TIME:return this.formatters.wallTime;case no.STEP:return this.formatters.step;case no.RELATIVE:return this.formatters.relative;default:throw RangeError(`Y axis formatter for ${this.timeProperty} must be implemented`)}}getMaxTicks(e){let{height:i}=this.layout.contentClientRect,r=i/15;if(this.timeProperty===no.STEP){let[o,s]=e.domain(),a=Math.max(s-o+1,1);return Math.min(a,r)}return r}renderYAxis(){if(!this.scales)return;let e=this.mode===Dr.OVERLAY?this.scales.countScale:this.scales.temporalScale,i=this.getMaxTicks(e),r=function(n){return UQ(ZT,n)}(e).ticks(Math.max(2,i));r.tickFormat(this.getYAxisFormatter()),r(nD(this.yAxis.nativeElement))}findClosestDatumIndex(e){let i=e.target,r=i;for(;i&&i!==this.histograms.nativeElement;)r=i,i=i.parentElement;return i?Array.from(i.children).indexOf(r):-1}onMouseMoveForTestOnly(e){return this.onMouseMove(e)}onMouseMove(e){if(!this.scales)return;let i=e.offsetX,r=e.offsetY,o=this.findClosestDatumIndex(e);if(o<0)return;let s=this.scales.binScale.invert(i),a=this.data[o],l=this.getClosestBinFromBinCoordinate(a,s);this.tooltipData={value:{position:{x:i,y:r},label:this.mode===Dr.OFFSET?this.formatters.count(l.y):`Step: ${this.formatters.step(a.step)}`},xAxis:{position:this.getUiCoordFromBinForContent(l).x,label:this.formatters.binNumber(Jx(l))},yAxis:{position:this.scales.countScale(this.mode===Dr.OFFSET?0:l.y),label:this.mode===Dr.OFFSET?this.getYAxisFormatter()(this.getTimeValue(a)):this.formatters.binNumber(l.y)},xPositionInBinCoord:s,closestDatum:a,closestBin:l},this.changeDetector.detectChanges()}}return n.\u0275fac=function(e){return new(e||n)(C($t))},n.\u0275cmp=O({type:n,selectors:[["tb-histogram"]],viewQuery:function(e,i){if(1&e&&(Ge(H3e,5),Ge(z3e,5),Ge(U3e,5),Ge(j3e,5),Ge(G3e,5)),2&e){let r;Se(r=Ee())&&(i.main=r.first),Se(r=Ee())&&(i.xAxis=r.first),Se(r=Ee())&&(i.yAxis=r.first),Se(r=Ee())&&(i.content=r.first),Se(r=Ee())&&(i.histograms=r.first)}},inputs:{mode:"mode",timeProperty:"timeProperty",color:"color",data:"data",timeSelection:"timeSelection"},outputs:{onLinkedTimeSelectionChanged:"onLinkedTimeSelectionChanged",onLinkedTimeToggled:"onLinkedTimeToggled"},features:[Gt],decls:22,vars:15,consts:[["detectResize","","observeIntersection","",3,"onResize","onVisibilityChange"],["main",""],[1,"axis","x-axis"],["xAxis",""],[1,"tooltip"],[3,"transform",4,"ngIf"],[1,"axis","y-axis"],["yAxis",""],[4,"ngIf"],[1,"content"],["content",""],[1,"grid"],[3,"transform",4,"ngFor","ngForOf"],["histograms",""],[3,"transform","histogram","no-color","color","mouseenter","mouseleave","click",4,"ngFor","ngForOf","ngForTrackBy"],["class","tooltip",4,"ngIf"],[1,"histogram-card-fob",3,"timeSelection","steps","temporalScale","onTimeSelectionChanged","onTimeSelectionToggled"],["x2","100%",1,"tick"],[3,"mouseenter","mouseleave","click"],["class","baseline","x2","100%",4,"ngIf"],["r","2",3,"transform",4,"ngIf"],["x2","100%",1,"baseline"],["r","2"],["r","2",4,"ngIf"],[1,"value-label"],["x","3","y","-3"]],template:function(e,i){1&e&&(h(0,"div",0,1),I("onResize",function(){return i.onResize()})("onVisibilityChange",function(o){return i.onVisibilityChange(o)}),Nn(),h(2,"svg",2),P(3,"g",null,3),h(5,"g",4),S(6,W3e,3,3,"g",5),g()(),Oo(),h(7,"div",6),Nn(),h(8,"svg"),P(9,"g",null,7),h(11,"g",4),S(12,q3e,3,4,"g",5),g()(),S(13,Y3e,2,3,"ng-container",8),g(),h(14,"svg",9,10)(16,"g",11),S(17,X3e,2,2,"g",12),g(),h(18,"g",null,13),S(20,K3e,4,11,"g",14),g(),S(21,$3e,7,7,"g",15),g()()),2&e&&(As("main "+i.mode+" "+i.timeProperty),v(6),_("ngIf",i.tooltipData),v(5),Tt("transform",i.getCssTranslatePx(9,0)),v(1),_("ngIf",i.tooltipData),v(1),_("ngIf",i.isTimeSelectionEnabled(i.timeSelection)),v(4),_("ngForOf",i.getGridTickYLocs()),v(1),nt("histograms",!0)("linked-time-single-step",i.timeSelection&&!i.timeSelection.end),v(2),_("ngForOf",i.data)("ngForTrackBy",i.trackByWallTime),v(1),_("ngIf",i.tooltipData))},styles:['[_nghost-%COMP%], .main[_ngcontent-%COMP%]{display:inline-block;height:100%;width:100%}[_nghost-%COMP%]{box-sizing:border-box;padding:10px}.main[_ngcontent-%COMP%]{display:grid;grid-template-areas:"content y-axis" "x-axis .";grid-template-columns:1fr 50px;grid-template-rows:1fr 30px}.main.wall_time[_ngcontent-%COMP%]{grid-template-columns:1fr 75px}.tooltip[_ngcontent-%COMP%], .baseline[_ngcontent-%COMP%]{color:#000}body.dark-mode[_nghost-%COMP%]   .tooltip[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .tooltip[_ngcontent-%COMP%]{color:#fff}body.dark-mode[_nghost-%COMP%]   .baseline[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .baseline[_ngcontent-%COMP%]{color:#fff}.linked-time-fob[_ngcontent-%COMP%]   text[_ngcontent-%COMP%], .tooltip[_ngcontent-%COMP%]   text[_ngcontent-%COMP%]{font-weight:bold;font-size:10px}.linked-time-fob[_ngcontent-%COMP%]   text[_ngcontent-%COMP%], .linked-time-fob[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .tooltip[_ngcontent-%COMP%]   text[_ngcontent-%COMP%], .tooltip[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{fill:currentColor}.linked-time-fob[_ngcontent-%COMP%]   .value-label[_ngcontent-%COMP%], .tooltip[_ngcontent-%COMP%]   .value-label[_ngcontent-%COMP%]{dominant-baseline:ideographic;text-anchor:start}.axis[_ngcontent-%COMP%]    {color:#616161;position:relative;overflow:hidden}body.dark-mode[_nghost-%COMP%]   .axis[_ngcontent-%COMP%]    , body.dark-mode   [_nghost-%COMP%]   .axis[_ngcontent-%COMP%]    {color:rgba(255,255,255,.7)}.axis[_ngcontent-%COMP%]     .domain, .axis[_ngcontent-%COMP%]     .tick text{display:none}.axis[_ngcontent-%COMP%]     .tick:nth-child(2n+1) text{display:initial}svg[_ngcontent-%COMP%]{height:100%;width:100%;pointer-events:visiblePainted}svg[_ngcontent-%COMP%]   line[_ngcontent-%COMP%], svg[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], svg[_ngcontent-%COMP%]   .tooltip[_ngcontent-%COMP%]{pointer-events:none}svg[_ngcontent-%COMP%]   g[_ngcontent-%COMP%]{will-change:transform}.x-axis[_ngcontent-%COMP%]{grid-area:x-axis}.x-axis[_ngcontent-%COMP%]   .tooltip[_ngcontent-%COMP%]{dominant-baseline:hanging;text-anchor:middle}.y-axis[_ngcontent-%COMP%]{grid-area:y-axis;overflow:clip visible}.y-axis[_ngcontent-%COMP%]   .tooltip[_ngcontent-%COMP%]{dominant-baseline:middle;text-anchor:start}.histogram-card-fob[_ngcontent-%COMP%]{left:9px;position:absolute}.content[_ngcontent-%COMP%]   .tick[_ngcontent-%COMP%], .axis[_ngcontent-%COMP%]     .tick line{stroke:#ddd}body.dark-mode[_nghost-%COMP%]   .content[_ngcontent-%COMP%]   .tick[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .content[_ngcontent-%COMP%]   .tick[_ngcontent-%COMP%]{stroke:#555}body.dark-mode[_nghost-%COMP%]   .axis[_ngcontent-%COMP%]     .tick line, body.dark-mode   [_nghost-%COMP%]   .axis[_ngcontent-%COMP%]     .tick line{stroke:#555}.content[_ngcontent-%COMP%]{grid-area:content;overflow:visible;z-index:1}.content[_ngcontent-%COMP%]   .tick[_ngcontent-%COMP%]{stroke-width:1px;stroke-dasharray:2}.content[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .content[_ngcontent-%COMP%]   path[_ngcontent-%COMP%]{fill:currentColor;stroke-opacity:.6;stroke-width:1px}.content[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{filter:drop-shadow(0 0 1px rgba(0, 0, 0, 0.6));stroke:#fff;will-change:transform}.content[_ngcontent-%COMP%]   .baseline[_ngcontent-%COMP%]{stroke-opacity:.1;stroke-width:1px;stroke:currentColor;width:100%}.content[_ngcontent-%COMP%]   .tooltip[_ngcontent-%COMP%]   path[_ngcontent-%COMP%]{stroke-opacity:1;stroke:currentColor;fill:rgba(0,0,0,0)}.content[_ngcontent-%COMP%]   .no-color[_ngcontent-%COMP%]{color:rgba(221,221,221,.4) !important}.content[_ngcontent-%COMP%]   .no-color[_ngcontent-%COMP%]   path[_ngcontent-%COMP%]{stroke-opacity:.2}body.dark-mode[_nghost-%COMP%]   .content[_ngcontent-%COMP%]   .no-color[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .content[_ngcontent-%COMP%]   .no-color[_ngcontent-%COMP%]{color:rgba(51,51,51,.4) !important}.offset[_ngcontent-%COMP%]   .content[_ngcontent-%COMP%]   .histograms[_ngcontent-%COMP%]   path[_ngcontent-%COMP%]{stroke:#fff}body.dark-mode[_nghost-%COMP%]   .offset[_ngcontent-%COMP%]   .content[_ngcontent-%COMP%]   .histograms[_ngcontent-%COMP%]   path[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .offset[_ngcontent-%COMP%]   .content[_ngcontent-%COMP%]   .histograms[_ngcontent-%COMP%]   path[_ngcontent-%COMP%]{stroke:#555}.offset[_ngcontent-%COMP%]   .content[_ngcontent-%COMP%]   .histograms.linked-time-single-step[_ngcontent-%COMP%]   [_ngcontent-%COMP%]:not(.no-color)   path[_ngcontent-%COMP%]{stroke:#000}body.dark-mode[_nghost-%COMP%]   .offset[_ngcontent-%COMP%]   .content[_ngcontent-%COMP%]   .histograms.linked-time-single-step[_ngcontent-%COMP%]   [_ngcontent-%COMP%]:not(.no-color)   path[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .offset[_ngcontent-%COMP%]   .content[_ngcontent-%COMP%]   .histograms.linked-time-single-step[_ngcontent-%COMP%]   [_ngcontent-%COMP%]:not(.no-color)   path[_ngcontent-%COMP%]{stroke:#fff}.overlay[_ngcontent-%COMP%]   .x-axis[_ngcontent-%COMP%]     .tick line{display:none}.overlay[_ngcontent-%COMP%]   .content[_ngcontent-%COMP%]   path[_ngcontent-%COMP%]{fill-opacity:0;stroke:currentColor}.tooltip[_ngcontent-%COMP%], .content[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{display:none}.main[_ngcontent-%COMP%]:hover   .content[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .main[_ngcontent-%COMP%]:hover   .tooltip[_ngcontent-%COMP%]{display:block}'],changeDetection:0}),n})();function wV(n,t){return n.reduce((e,i)=>Math.max(e,t(i)),-1/0)}function Xte(n,t,e){e||(e=t);let i=1/0,r=-1/0;for(let o of n)i=Math.min(i,t(o)),r=Math.max(r,e(o));return{min:i,max:r}}function Jx(n){return n.x+.5*n.dx}function nBe(n,t){1&n&&(h(0,"span",14),P(1,"mat-spinner",15),g())}function iBe(n,t){if(1&n){let e=ge();h(0,"tb-histogram",16),I("onLinkedTimeSelectionChanged",function(r){return X(e),Q(w().onLinkedTimeSelectionChanged.emit(r))})("onLinkedTimeToggled",function(){return X(e),Q(w().onLinkedTimeToggled.emit())}),g()}if(2&n){let e=w();_("data",e.data)("mode",e.mode)("timeProperty",e.timeProperty(e.xAxisType))("color",e.runColorScale(e.runId))("timeSelection",e.convertToTimeSelection(e.linkedTimeSelection))}}function rBe(n,t){1&n&&(h(0,"div",18),T(1," Data failed to load. "),g())}function oBe(n,t){if(1&n&&S(0,rBe,2,0,"div",17),2&n){let e=w();_("ngIf",e.loadState===e.DataLoadState.FAILED)}}var sBe=function(n){return{backgroundColor:n}},Qte=(()=>{class n{constructor(){this.DataLoadState=Te,this.onFullSizeToggle=new F,this.onPinClicked=new F,this.onLinkedTimeSelectionChanged=new F,this.onLinkedTimeToggled=new F}timeProperty(e){switch(e){case Pi.STEP:return no.STEP;case Pi.WALL_TIME:return no.WALL_TIME;case Pi.RELATIVE:return no.RELATIVE;default:throw new Error("Invalid xAxisType for histogram time property.")}}convertToTimeSelection(e){return null===e?null:{start:{step:e.startStep},end:e.endStep?{step:e.endStep}:null}}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["histogram-card-component"]],inputs:{loadState:"loadState",title:"title",tag:"tag",runId:"runId",data:"data",mode:"mode",xAxisType:"xAxisType",runColorScale:"runColorScale",showFullWidth:"showFullWidth",isPinned:"isPinned",linkedTimeSelection:"linkedTimeSelection",isClosestStepHighlighted:"isClosestStepHighlighted"},outputs:{onFullSizeToggle:"onFullSizeToggle",onPinClicked:"onPinClicked",onLinkedTimeSelectionChanged:"onLinkedTimeSelectionChanged",onLinkedTimeToggled:"onLinkedTimeToggled"},decls:16,vars:14,consts:function(){let t,e;return t=$localize`:A button to pin a card.␟e665dc712bd5f18d4dfa3a29e125d565cc51e2f6␟7284606426234375344:Pin card`,e=$localize`:A button on a histogram card that toggles full size mode.␟fc8f767d0b9f930187a1bae34477ad28736ece33␟915721563638926597:Toggle full size mode`,[[1,"heading"],[1,"tag"],[3,"title","value"],[3,"isClipped","isClosestStepHighlighted"],[1,"run"],[1,"dot",3,"ngStyle"],[1,"run-text",3,"runId"],[1,"controls"],["mat-icon-button","","aria-label",t,3,"click"],[3,"svgIcon"],["mat-icon-button","","aria-label",e,"title","Toggle full size mode",3,"click"],["class","spinner",4,"ngIf"],[3,"data","mode","timeProperty","color","timeSelection","onLinkedTimeSelectionChanged","onLinkedTimeToggled",4,"ngIf","ngIfElse"],["noData",""],[1,"spinner"],["diameter","18"],[3,"data","mode","timeProperty","color","timeSelection","onLinkedTimeSelectionChanged","onLinkedTimeToggled"],["class","empty-message",4,"ngIf"],[1,"empty-message"]]},template:function(e,i){if(1&e&&(h(0,"div",0)(1,"div",1),P(2,"tb-truncated-path",2)(3,"vis-linked-time-selection-warning",3),g(),h(4,"div",4),P(5,"span",5)(6,"card-run-name",6),g(),h(7,"span",7)(8,"button",8),I("click",function(){return i.onPinClicked.emit(!i.isPinned)}),P(9,"mat-icon",9),g(),h(10,"button",10),I("click",function(){return i.onFullSizeToggle.emit()}),P(11,"mat-icon",9),g()(),S(12,nBe,2,0,"span",11),g(),S(13,iBe,1,5,"tb-histogram",12),S(14,oBe,1,1,"ng-template",null,13,Wt)),2&e){let r=it(15);v(2),_("title",i.tag)("value",i.title),v(1),_("isClipped",i.linkedTimeSelection&&i.linkedTimeSelection.clipped)("isClosestStepHighlighted",i.isClosestStepHighlighted),v(2),_("ngStyle",In(12,sBe,i.runColorScale(i.runId))),v(1),_("runId",i.runId),v(2),Be("title",i.isPinned?"Unpin card":"Pin card"),v(1),_("svgIcon",i.isPinned?"keep_24px":"keep_outline_24px"),v(2),_("svgIcon",i.showFullWidth?"fullscreen_exit_24px":"fullscreen_24px"),v(1),_("ngIf",i.loadState===i.DataLoadState.LOADING),v(1),_("ngIf",i.data&&i.data.length)("ngIfElse",r)}},dependencies:[Fe,pu,fA,$i,En,tl,qT,Xg,Qg],styles:['[_nghost-%COMP%]{box-sizing:border-box;display:flex;flex-basis:318px;flex-direction:column;flex-grow:1;height:100%;overflow:auto;padding:16px;padding-top:4px}.heading[_ngcontent-%COMP%]{align-items:center;display:grid;grid-template-areas:"tag controls" "run spinner";grid-template-columns:1fr auto;font-size:14px;margin-bottom:4px}.tag[_ngcontent-%COMP%]{align-items:center;display:flex;gap:5px;grid-area:tag;overflow:hidden}.tag[_ngcontent-%COMP%]   vis-selected-time-clipped[_ngcontent-%COMP%]{line-height:0}.run[_ngcontent-%COMP%]{grid-area:run;display:flex;white-space:nowrap;font-size:13px}.run[_ngcontent-%COMP%]   .dot[_ngcontent-%COMP%]{flex:none;display:inline-block;width:13px;height:13px;border-radius:50%;margin-right:4px}.run[_ngcontent-%COMP%]   .run-text[_ngcontent-%COMP%]{overflow:hidden;text-overflow:ellipsis;max-width:120px}.controls[_ngcontent-%COMP%]{color:#616161;white-space:nowrap;grid-area:controls;justify-self:flex-end;flex-shrink:0;margin-right:-12px}body.dark-mode[_nghost-%COMP%]   .controls[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .controls[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}.spinner[_ngcontent-%COMP%]{display:flex;grid-area:spinner;height:100%;justify-content:center;position:relative}mat-spinner[_ngcontent-%COMP%]{top:0;right:0;position:absolute}tb-histogram[_ngcontent-%COMP%]{flex-grow:1}.empty-message[_ngcontent-%COMP%]{margin-top:1em;font-size:13px}'],changeDetection:0}),n})(),Zte=(()=>{class n{constructor(e){this.store=e,this.pinStateChanged=new F,this.mode$=this.store.select(t1),this.xAxisType$=this.store.select(Ol),this.showFullWidth$=this.store.select(qa).pipe(N(i=>i[this.cardId]?.fullWidth))}isHistogramCardMetadata(e){let{plugin:i}=e;return i===zn.HISTOGRAMS}onFullSizeToggle(){this.store.dispatch(Bg({cardId:this.cardId}))}ngOnInit(){let i=this.store.select(Wa,this.cardId).pipe(ke(o=>!!o&&this.isHistogramCardMetadata(o)),N(o=>o)),r=dn([i,this.store.select(Cu,this.cardId)]);this.data$=r.pipe(N(([o,s])=>{let a=o.runId;return s&&s.hasOwnProperty(a)?function(n,t=30){if(!n.length||t<1)return[];let e=function(n){let t=null,e=null;for(let{bins:i}of n){if(!i.length)continue;let r=i[i.length-1],o=i[0].x,s=r.x+r.dx;(null===t||o<t)&&(t=o),(null===e||s>e)&&(e=s)}return null===t||null===e?null:{left:t,right:e}}(n);return e&&e.left===e.right&&(e.right=1.1*e.right+1,e.left=e.left/1.1-1),n.map(i=>({step:i.step,wallTime:i.wallTime,bins:e?O3e(i.bins,e,t):[]}))}(s[a].map(d=>{let{wallTime:u,step:p}=d;return{wallTime:u,step:p,bins:d.bins.map(m=>({x:m.min,dx:m.max-m.min,y:m.count}))}})):[]})),this.steps$=this.data$.pipe(N(o=>o.map(s=>s.step))),this.linkedTimeSelection$=dn([this.store.select(Eu),this.steps$,this.store.select(Su)]).pipe(N(([o,s,a])=>{if(!o)return null;let l=1/0,c=-1/0;for(let p of s)l=Math.min(p,l),c=Math.max(p,c);return function(n,t){if(null!==n.endStep)return n;let e=function(n,t){let e=1/0,i=null;for(let r of t){let o=Math.abs(n-r);o<e&&(e=o,i=r)}return i}(n.startStep,t);return null!==e?{...n,startStep:e}:n}(Uh(AF(o,a),l,c),s)})),this.isClosestStepHighlighted$=dn([this.store.select(Eu),this.linkedTimeSelection$]).pipe(N(([o,s])=>o&&s&&!s.clipped&&null===o.end&&o.start.step!==s.startStep)),this.loadState$=this.store.select(_d,this.cardId),this.tag$=i.pipe(N(o=>o.tag)),this.title$=this.tag$.pipe(N(o=>Yg(o,this.groupName))),this.runId$=i.pipe(N(o=>o.runId)),this.isPinned$=this.store.select(Mu,this.cardId)}onLinkedTimeSelectionChanged(e){this.store.dispatch(kf(e))}onLinkedTimeToggled(){this.store.dispatch(Id({affordance:Ys.FOB_DESELECT}))}}return n.\u0275fac=function(e){return new(e||n)(C(Ae))},n.\u0275cmp=O({type:n,selectors:[["histogram-card"]],inputs:{cardId:"cardId",groupName:"groupName",runColorScale:"runColorScale"},outputs:{pinStateChanged:"pinStateChanged"},decls:12,vars:34,consts:[[3,"loadState","title","tag","runId","data","mode","xAxisType","runColorScale","showFullWidth","isPinned","isClosestStepHighlighted","linkedTimeSelection","onFullSizeToggle","onPinClicked","onLinkedTimeSelectionChanged","onLinkedTimeToggled"]],template:function(e,i){1&e&&(h(0,"histogram-card-component",0),I("onFullSizeToggle",function(){return i.onFullSizeToggle()})("onPinClicked",function(o){return i.pinStateChanged.emit(o)})("onLinkedTimeSelectionChanged",function(o){return i.onLinkedTimeSelectionChanged(o)})("onLinkedTimeToggled",function(){return i.onLinkedTimeToggled()}),j(1,"async"),j(2,"async"),j(3,"async"),j(4,"async"),j(5,"async"),j(6,"async"),j(7,"async"),j(8,"async"),j(9,"async"),j(10,"async"),j(11,"async"),g()),2&e&&_("loadState",W(1,12,i.loadState$))("title",W(2,14,i.title$))("tag",W(3,16,i.tag$))("runId",W(4,18,i.runId$))("data",W(5,20,i.data$))("mode",W(6,22,i.mode$))("xAxisType",W(7,24,i.xAxisType$))("runColorScale",i.runColorScale)("showFullWidth",W(8,26,i.showFullWidth$))("isPinned",W(9,28,i.isPinned$))("isClosestStepHighlighted",W(10,30,i.isClosestStepHighlighted$))("linkedTimeSelection",W(11,32,i.linkedTimeSelection$))},dependencies:[Qte,ct],styles:["[_nghost-%COMP%] {\n        display: flex;\n        flex-direction: column;\n        height: 100%;\n      }"],changeDetection:0}),n})();function cBe(n,t){if(1&n){let e=ge();h(0,"image-card",6),I("fullWidthChanged",function(r){return X(e),Q(w(2).onFullWidthChanged(r))})("pinStateChanged",function(){return X(e),Q(w(2).onPinStateChanged())}),g()}if(2&n){let e=w(2);_("cardId",e.cardId)("groupName",e.groupName)("runColorScale",e.runColorScale)}}function dBe(n,t){if(1&n){let e=ge();h(0,"scalar-card",7),I("pinStateChanged",function(){return X(e),Q(w(2).onPinStateChanged())}),g()}if(2&n){let e=w(2);_("cardId",e.cardId)("groupName",e.groupName)}}function uBe(n,t){if(1&n){let e=ge();h(0,"histogram-card",8),I("pinStateChanged",function(){return X(e),Q(w(2).onPinStateChanged())}),g()}if(2&n){let e=w(2);_("cardId",e.cardId)("groupName",e.groupName)("runColorScale",e.runColorScale)}}function pBe(n,t){if(1&n&&(h(0,"div"),T(1),g()),2&n){let e=w(2);v(1),He("Placeholder error for: ",e.cardId,"")}}function fBe(n,t){if(1&n&&(Ot(0,1),S(1,cBe,1,3,"image-card",2),S(2,dBe,1,2,"scalar-card",3),S(3,uBe,1,3,"histogram-card",4),S(4,pBe,2,1,"div",5),kt()),2&n){let e=w();_("ngSwitch",e.pluginType),v(1),_("ngSwitchCase",e.PluginType.IMAGES),v(1),_("ngSwitchCase",e.PluginType.SCALARS),v(1),_("ngSwitchCase",e.PluginType.HISTOGRAMS)}}var Kte=(()=>{class n{constructor(){this.PluginType=zn,this.fullWidthChanged=new F,this.fullHeightChanged=new F,this.pinStateChanged=new F}onFullWidthChanged(e){this.fullWidthChanged.emit(e)}onFullHeightChanged(e){this.fullHeightChanged.emit(e)}onPinStateChanged(){this.pinStateChanged.emit()}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["card-view-component"]],inputs:{isEverVisible:"isEverVisible",cardId:"cardId",groupName:"groupName",pluginType:"pluginType",runColorScale:"runColorScale"},outputs:{fullWidthChanged:"fullWidthChanged",fullHeightChanged:"fullHeightChanged",pinStateChanged:"pinStateChanged"},decls:1,vars:1,consts:[[3,"ngSwitch",4,"ngIf"],[3,"ngSwitch"],[3,"cardId","groupName","runColorScale","fullWidthChanged","pinStateChanged",4,"ngSwitchCase"],[3,"cardId","groupName","pinStateChanged",4,"ngSwitchCase"],[3,"cardId","groupName","runColorScale","pinStateChanged",4,"ngSwitchCase"],[4,"ngSwitchDefault"],[3,"cardId","groupName","runColorScale","fullWidthChanged","pinStateChanged"],[3,"cardId","groupName","pinStateChanged"],[3,"cardId","groupName","runColorScale","pinStateChanged"]],template:function(e,i){1&e&&S(0,fBe,5,4,"ng-container",0),2&e&&_("ngIf",i.isEverVisible)},dependencies:[Fe,sr,Sr,uu,RQ,Wte,Zte],encapsulation:2,changeDetection:0}),n})(),Jte=(()=>{class n{constructor(e){this.store=e,this.isEverVisible=!1,this.fullWidthChanged=new F,this.fullHeightChanged=new F,this.runColorScale$=this.store.select(Au).pipe(ac(350,void 0,{leading:!0,trailing:!0}),N(i=>r=>i.hasOwnProperty(r)?i[r]:"#fff"))}onVisibilityChange({visible:e}){this.isEverVisible=this.isEverVisible||e}onFullWidthChanged(e){this.fullWidthChanged.emit(e)}onFullHeightChanged(e){this.fullHeightChanged.emit(e)}onPinStateChanged(){this.store.select(Mu,this.cardId).pipe(Yt(1),Bt(this.store.select(CW))).subscribe(([e,i])=>{this.store.dispatch(Hg({cardId:this.cardId,canCreateNewPins:i,wasPinned:e}))})}}return n.\u0275fac=function(e){return new(e||n)(C(Ae))},n.\u0275cmp=O({type:n,selectors:[["card-view"]],inputs:{cardId:"cardId",groupName:"groupName",pluginType:"pluginType"},outputs:{fullWidthChanged:"fullWidthChanged",fullHeightChanged:"fullHeightChanged"},decls:2,vars:7,consts:[["observeIntersection","","intersectionObserverMargin","200px 200px 200px 200px",3,"isEverVisible","cardId","groupName","pluginType","runColorScale","fullWidthChanged","fullHeightChanged","pinStateChanged","onVisibilityChange"]],template:function(e,i){1&e&&(h(0,"card-view-component",0),I("fullWidthChanged",function(o){return i.onFullWidthChanged(o)})("fullHeightChanged",function(o){return i.onFullHeightChanged(o)})("pinStateChanged",function(){return i.onPinStateChanged()})("onVisibilityChange",function(o){return i.onVisibilityChange(o)}),j(1,"async"),g()),2&e&&_("isEverVisible",i.isEverVisible)("cardId",i.cardId)("groupName",i.groupName)("pluginType",i.pluginType)("runColorScale",W(1,5,i.runColorScale$))},dependencies:[qg,Kte,ct],styles:["[_nghost-%COMP%]{background-color:#fff}body.dark-mode   [_nghost-%COMP%]{background-color:#303030}"],changeDetection:0}),n})();function _Be(n,t){1&n&&li(0)}var bBe=function(n,t){return{"full-width":n,"full-height":t}};function vBe(n,t){if(1&n){let e=ge();h(0,"div",5)(1,"card-view",6),I("fullWidthChanged",function(r){let s=X(e).$implicit;return Q(w(2).onFullWidthChanged(s.cardId,r))})("fullHeightChanged",function(r){let s=X(e).$implicit;return Q(w(2).onFullHeightChanged(s.cardId,r))}),g()()}if(2&n){let e=t.$implicit,i=w(2);_("ngClass",qr(6,bBe,i.cardsAtFullWidth.has(e.cardId)||(null==i.cardStateMap[e.cardId]?null:i.cardStateMap[e.cardId].fullWidth),i.cardsAtFullHeight.has(e.cardId)||(null==i.cardStateMap[e.cardId]?null:i.cardStateMap[e.cardId].tableExpanded))),v(1),_("cardId",e.cardId)("groupName",i.groupName)("pluginType",e.plugin)("cardObserver",i.cardObserver)("cardLazyLoader",e.cardId)}}function yBe(n,t){1&n&&li(0)}var xBe=function(){return{isBottomControl:!1}},CBe=function(){return{isBottomControl:!0}};function MBe(n,t){if(1&n&&(h(0,"div"),S(1,_Be,1,0,"ng-container",2),h(2,"div",3),S(3,vBe,2,9,"div",4),g(),S(4,yBe,1,0,"ng-container",2),g()),2&n){let e=w(),i=it(2);v(1),_("ngTemplateOutlet",i)("ngTemplateOutletContext",cu(8,xBe)),v(1),Tt("grid-template-columns",e.gridTemplateColumn),v(1),_("ngForOf",e.cardIdsWithMetadata)("ngForTrackBy",e.trackByCards),v(1),_("ngTemplateOutlet",i)("ngTemplateOutletContext",cu(9,CBe))}}function wBe(n,t){if(1&n){let e=ge();h(0,"button",12),I("click",function(r){X(e);let o=w(3);return Q(o.handlePageChange(o.pageIndex-1,r.target))}),T(1," Previous "),g()}2&n&&_("disabled",0===w(3).pageIndex)}function SBe(n,t){if(1&n){let e=ge();h(0,"span",15)(1,"input",16),I("input",function(r){return X(e),Q(w(4).onPaginationInputChange(r))})("change",function(r){return X(e),Q(w(4).onPaginationInputChange(r))}),g(),T(2),g()}if(2&n){let e=w(4);v(1),_("value",e.pageIndex+1)("max",e.numPages),v(1),He(" of ",e.numPages,"")}}function EBe(n,t){if(1&n){let e=ge();h(0,"span"),S(1,SBe,3,3,"span",13),h(2,"button",14),I("click",function(r){X(e);let o=w(3);return Q(o.handlePageChange(o.pageIndex+1,r.target))}),T(3," Next "),g()()}if(2&n){let e=w(2).isBottomControl,i=w();v(1),_("ngIf",i.showPaginationInput(e)),v(1),_("disabled",i.pageIndex+1>=i.numPages)}}function TBe(n,t){if(1&n&&(h(0,"div",8)(1,"span",9),S(2,wBe,2,1,"button",10),g(),h(3,"span",11),S(4,EBe,4,2,"span",0),g()()),2&n){let e=w(2);v(2),_("ngIf",e.showPaginationControls),v(2),_("ngIf",e.showPaginationControls)}}function DBe(n,t){1&n&&S(0,TBe,5,2,"div",7),2&n&&_("ngIf",w().showPaginationControls)}var $te=(()=>{class n{constructor(e){this.cdkScrollable=e,this.PluginType=zn,this.gridTemplateColumn="",this.cardsAtFullWidth=new Set,this.cardsAtFullHeight=new Set,this.pageIndexChanged=new F}ngOnInit(){this.isCardWidthValid(this.cardMinWidth)&&(this.gridTemplateColumn=`repeat(auto-fill, minmax(${this.cardMinWidth}px, 1fr))`)}ngOnChanges(e){if(e.cardMinWidth){let i=e.cardMinWidth.currentValue;this.isCardWidthValid(i)?(this.cardMinWidth=i,this.gridTemplateColumn=`repeat(auto-fill, minmax(${this.cardMinWidth}px, 1fr))`):this.gridTemplateColumn=""}}isCardWidthValid(e){return e&&e>=335&&e<=735}showPaginationInput(e){return e}handlePageChange(e,i){let r=i.getBoundingClientRect().top;setTimeout(()=>{this.scrollToKeepTargetPosition(i,r)},0),this.pageIndexChanged.emit(e)}scrollToKeepTargetPosition(e,i){let r=this.cdkScrollable?.getElementRef().nativeElement;r&&r.scrollTo(0,e.getBoundingClientRect().top-i+r.scrollTop)}trackByCards(e,i){return i.cardId}onPaginationInputChange(e){let i=e.target;if("input"===e.type&&""===i.value)return;let r=Number(i.value)-1,o=Math.min(Math.max(0,r),this.numPages-1);i.value!==String(o+1)&&(i.value=String(o+1)),this.handlePageChange(o,i)}onFullWidthChanged(e,i){i?this.cardsAtFullWidth.add(e):this.cardsAtFullWidth.delete(e)}onFullHeightChanged(e,i){i?this.cardsAtFullHeight.add(e):this.cardsAtFullHeight.delete(e)}}return n.\u0275fac=function(e){return new(e||n)(C(Cd,8))},n.\u0275cmp=O({type:n,selectors:[["metrics-card-grid-component"]],inputs:{isGroupExpanded:"isGroupExpanded",pageIndex:"pageIndex",numPages:"numPages",cardIdsWithMetadata:"cardIdsWithMetadata",cardMinWidth:"cardMinWidth",cardObserver:"cardObserver",showPaginationControls:"showPaginationControls",cardStateMap:"cardStateMap"},outputs:{pageIndexChanged:"pageIndexChanged"},features:[Gt],decls:3,vars:1,consts:function(){let t,e;return t=$localize`:A button that sets a group to the previous page.␟575e782fd27f2ee70a034a775efe9ad162472250␟3629960544875360046:Previous page`,e=$localize`:A button that sets a group to the next page.␟ce3cefb1cd0099aa5003dda16ec9eb21fd8ba789␟3337301694210287595:Next page`,[[4,"ngIf"],["groupControls",""],[4,"ngTemplateOutlet","ngTemplateOutletContext"],[1,"card-grid"],["class","card-space",3,"ngClass",4,"ngFor","ngForOf","ngForTrackBy"],[1,"card-space",3,"ngClass"],[3,"cardId","groupName","pluginType","cardObserver","cardLazyLoader","fullWidthChanged","fullHeightChanged"],["class","group-controls",4,"ngIf"],[1,"group-controls"],[1,"prev-container"],["class","prev pagination-button","mat-button","","aria-label",t,3,"disabled","click",4,"ngIf"],[1,"input-and-next-container"],["mat-button","","aria-label",t,1,"prev","pagination-button",3,"disabled","click"],["class","pagination-input",4,"ngIf"],["mat-button","","aria-label",e,1,"next","pagination-button",3,"disabled","click"],[1,"pagination-input"],["type","number","min","1",3,"value","max","input","change"]]},template:function(e,i){1&e&&(S(0,MBe,5,10,"div",0),S(1,DBe,1,1,"ng-template",null,1,Wt)),2&e&&_("ngIf",i.isGroupExpanded)},dependencies:[lQ,Jte,yn,nn,Fe,Lr,Ji],styles:["[_nghost-%COMP%]{contain:content}.card-grid[_ngcontent-%COMP%]{display:grid;grid-template-columns:repeat(auto-fill, minmax(335px, 1fr));gap:16px;padding:16px}.card-space.full-width[_ngcontent-%COMP%]{grid-column-start:1;grid-column-end:-1}.card-space.full-height[_ngcontent-%COMP%]{min-height:480px}.card-space.full-height[_ngcontent-%COMP%]   card-view[_ngcontent-%COMP%]{height:100%}card-view[_ngcontent-%COMP%]{border:1px solid #ebebeb;border-radius:4px;box-sizing:border-box;contain:layout paint;display:block;min-height:320px}body.dark-mode[_nghost-%COMP%]   card-view[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   card-view[_ngcontent-%COMP%]{border:1px solid #555}.group-controls[_ngcontent-%COMP%]{color:#616161;display:grid;align-items:center;grid-template-columns:1fr 1fr;gap:16px;padding:0 16px}body.dark-mode[_nghost-%COMP%]   .group-controls[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .group-controls[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}.group-controls[_ngcontent-%COMP%]:first-of-type{padding-top:16px}.group-controls[_ngcontent-%COMP%]:last-of-type{padding-bottom:16px}.prev-container[_ngcontent-%COMP%]{justify-self:flex-start}.input-and-next-container[_ngcontent-%COMP%]{justify-self:flex-end}.pagination-input[_ngcontent-%COMP%]{margin-right:16px}.pagination-input[_ngcontent-%COMP%]   input[_ngcontent-%COMP%]{background:rgba(0,0,0,0);border:1px solid currentColor;color:inherit;font:inherit}.pagination-button[_ngcontent-%COMP%]{background-color:#fff}body.dark-mode[_nghost-%COMP%]   .pagination-button[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .pagination-button[_ngcontent-%COMP%]{background-color:rgba(0,0,0,0)}"],changeDetection:0}),n})(),p_=(()=>{class n{constructor(e){this.store=e,this.groupName=null,this.groupName$=new Ai(null),this.pageIndex$=new Ai(0),this.items$=new Ai([]),this.ngUnsubscribe=new Ie,this.cardStateMap$=this.store.select(qa),this.numPages$=dn([this.items$,this.store.select(Bs.getPageSize)]).pipe(N(([i,r])=>Math.ceil(i.length/r))),this.isGroupExpanded$=this.groupName$.pipe(Jn(i=>null!==i?this.store.select(s1,i):Ht(!0))),this.showPaginationControls$=this.numPages$.pipe(N(i=>i>1)),this.normalizedPageIndex$=dn([this.pageIndex$,this.numPages$]).pipe(ot(this.ngUnsubscribe),Nt(([i,r])=>{0!==r&&(i>=r?this.pageIndex$.next(r-1):i<0&&this.pageIndex$.next(0))}),N(([i,r])=>Math.min(Math.max(i,0),r-1)),Ms(1)),this.pagedItems$=dn([this.items$,this.store.select(Bs.getPageSize),this.normalizedPageIndex$,this.isGroupExpanded$]).pipe(N(([i,r,o,s])=>i.slice(r*o,r*o+(s?r:0)))),this.cardMinWidth$=this.store.select(Xh)}ngOnChanges(e){e.cardIdsWithMetadata&&this.items$.next(this.cardIdsWithMetadata),e.groupName&&this.groupName$.next(this.groupName)}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}onPageIndexChanged(e){this.pageIndex$.next(e)}}return n.\u0275fac=function(e){return new(e||n)(C(Ae))},n.\u0275cmp=O({type:n,selectors:[["metrics-card-grid"]],inputs:{groupName:"groupName",cardIdsWithMetadata:"cardIdsWithMetadata",cardObserver:"cardObserver"},features:[Gt],decls:8,vars:22,consts:[[3,"isGroupExpanded","pageIndex","numPages","showPaginationControls","cardIdsWithMetadata","cardMinWidth","cardObserver","cardStateMap","pageIndexChanged"]],template:function(e,i){1&e&&(h(0,"metrics-card-grid-component",0),I("pageIndexChanged",function(o){return i.onPageIndexChanged(o)}),j(1,"async"),j(2,"async"),j(3,"async"),j(4,"async"),j(5,"async"),j(6,"async"),j(7,"async"),g()),2&e&&_("isGroupExpanded",W(1,8,i.isGroupExpanded$))("pageIndex",W(2,10,i.normalizedPageIndex$))("numPages",W(3,12,i.numPages$))("showPaginationControls",W(4,14,i.showPaginationControls$))("cardIdsWithMetadata",W(5,16,i.pagedItems$))("cardMinWidth",W(6,18,i.cardMinWidth$))("cardObserver",i.cardObserver)("cardStateMap",W(7,20,i.cardStateMap$))},dependencies:[$te,ct],encapsulation:2,changeDetection:0}),n})();function PBe(n,t){if(1&n&&(h(0,"span",7),T(1),j(2,"number"),g()),2&n){let e=w();v(1),He("",W(2,1,e.numberOfCards)," cards")}}function OBe(n,t){1&n&&P(0,"mat-icon",8)}function kBe(n,t){1&n&&P(0,"mat-icon",9)}var ene=(()=>{class n{constructor(){this.groupExpansionToggled=new F}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["metrics-card-group-toolbar-component"]],inputs:{groupName:"groupName",numberOfCards:"numberOfCards",isGroupExpanded:"isGroupExpanded"},outputs:{groupExpansionToggled:"groupExpansionToggled"},decls:9,vars:5,consts:function(){let t;return t=$localize`:A button that allows user to expand a tag group.␟ffaa11471b878a6dffe2e68c6f37064a9e074853␟5386054325274779258:Expand group`,[["aria-label",t,1,"group-toolbar",3,"click"],[1,"group-title-wrapper"],["aria-role","heading","aria-level","3",1,"group-title",3,"title"],["class","group-card-count",4,"ngIf"],[1,"expand-group-icon"],["svgIcon","expand_less_24px",4,"ngIf","ngIfElse"],["expandMore",""],[1,"group-card-count"],["svgIcon","expand_less_24px"],["svgIcon","expand_more_24px"]]},template:function(e,i){if(1&e&&(h(0,"button",0),I("click",function(){return i.groupExpansionToggled.emit()}),h(1,"span",1)(2,"span",2),T(3),g(),S(4,PBe,3,3,"span",3),g(),h(5,"span",4),S(6,OBe,1,0,"mat-icon",5),S(7,kBe,1,0,"ng-template",null,6,Wt),g()()),2&e){let r=it(8);v(2),Wi("title",i.groupName),v(1),bt(i.groupName),v(1),_("ngIf",i.numberOfCards>1),v(2),_("ngIf",i.isGroupExpanded)("ngIfElse",r)}},dependencies:[Fe,En,La],styles:["[_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{background-color:#fff;border-bottom:1px solid #ebebeb;align-items:center;background-color:#fff;display:flex;flex:none;height:42px;margin-bottom:-1px;padding:0 16px;position:sticky;top:0;z-index:1;box-shadow:0px 2px 4px 0px rgba(0,0,0,.15)}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{background-color:#303030}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{border-bottom:1px solid #555}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{box-shadow:0px 2px 4px 0px rgba(255,255,255,.15)}[_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{border:0;border-top:1px solid #ebebeb;color:#212121;top:-1px;display:flex;width:100%;font:inherit}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{border-top:1px solid #555}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{color:#fff}.card-group:first-of-type   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{border-top:0}[_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]:hover{cursor:pointer}.expand-group-icon[_ngcontent-%COMP%]{color:#616161}body.dark-mode[_nghost-%COMP%]   .expand-group-icon[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .expand-group-icon[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}.expand-group-icon[_ngcontent-%COMP%]:disabled{color:#757575}body.dark-mode[_nghost-%COMP%]   .expand-group-icon[_ngcontent-%COMP%]:disabled, body.dark-mode   [_nghost-%COMP%]   .expand-group-icon[_ngcontent-%COMP%]:disabled{color:#616161}.group-title-wrapper[_ngcontent-%COMP%]{flex-grow:1;text-align:left}.group-title[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.group-card-count[_ngcontent-%COMP%]{font-size:12px;font-weight:400;color:#616161;margin-left:6px}body.dark-mode[_nghost-%COMP%]   .group-card-count[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .group-card-count[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}"],changeDetection:0}),n})(),tne=(()=>{class n{constructor(e){this.store=e,this.groupName=null,this.isGroupExpanded$=Ht(!1)}ngOnInit(){this.isGroupExpanded$=null!==this.groupName?this.store.select(s1,this.groupName):Ht(!1)}onGroupExpansionToggled(){if(null===this.groupName)throw new RangeError("Invariant error: expansion cannot be toggled when groupName is null");this.store.dispatch(PT({tagGroup:this.groupName}))}}return n.\u0275fac=function(e){return new(e||n)(C(Ae))},n.\u0275cmp=O({type:n,selectors:[["metrics-card-group-toolbar"]],inputs:{groupName:"groupName",numberOfCards:"numberOfCards"},decls:2,vars:5,consts:[[3,"numberOfCards","isGroupExpanded","groupName","groupExpansionToggled"]],template:function(e,i){1&e&&(h(0,"metrics-card-group-toolbar-component",0),I("groupExpansionToggled",function(){return i.onGroupExpansionToggled()}),j(1,"async"),g()),2&e&&_("numberOfCards",i.numberOfCards)("isGroupExpanded",W(1,3,i.isGroupExpanded$))("groupName",i.groupName)},dependencies:[ene,ct],encapsulation:2,changeDetection:0}),n})();function LBe(n,t){if(1&n&&(h(0,"div",1),P(1,"metrics-card-group-toolbar",2)(2,"metrics-card-grid",3),g()),2&n){let e=t.$implicit,i=w();v(1),_("numberOfCards",e.items.length)("groupName",e.groupName),v(1),_("cardIdsWithMetadata",e.items)("cardObserver",i.cardObserver)("groupName",e.groupName)}}var nne=(()=>{class n{constructor(){this.PluginType=zn}trackByGroup(e,i){return i.groupName}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["metrics-card-groups-component"]],inputs:{cardGroups:"cardGroups",cardObserver:"cardObserver"},decls:1,vars:2,consts:[["class","card-group",4,"ngFor","ngForOf","ngForTrackBy"],[1,"card-group"],[3,"numberOfCards","groupName"],[3,"cardIdsWithMetadata","cardObserver","groupName"]],template:function(e,i){1&e&&S(0,LBe,3,5,"div",0),2&e&&_("ngForOf",i.cardGroups)("ngForTrackBy",i.trackByGroup)},dependencies:[nn,p_,tne],styles:["[_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{background-color:#fff;border-bottom:1px solid #ebebeb;align-items:center;background-color:#fff;display:flex;flex:none;height:42px;margin-bottom:-1px;padding:0 16px;position:sticky;top:0;z-index:1;box-shadow:0px 2px 4px 0px rgba(0,0,0,.15)}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{background-color:#303030}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{border-bottom:1px solid #555}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{box-shadow:0px 2px 4px 0px rgba(255,255,255,.15)}"],changeDetection:0}),n})(),ine=(()=>{class n{constructor(e){this.store=e,this.cardGroups$=this.store.select(Nf).pipe(Li(this.store.select(Dc)),N(([i,r])=>r.size?i.filter(o=>r.has(o.plugin)):i),N(i=>LT(i)))}}return n.\u0275fac=function(e){return new(e||n)(C(Ae))},n.\u0275cmp=O({type:n,selectors:[["metrics-card-groups"]],inputs:{cardObserver:"cardObserver"},decls:2,vars:4,consts:[[3,"cardGroups","cardObserver"]],template:function(e,i){1&e&&(P(0,"metrics-card-groups-component",0),j(1,"async")),2&e&&_("cardGroups",W(1,2,i.cardGroups$))("cardObserver",i.cardObserver)},dependencies:[nne,ct],encapsulation:2,changeDetection:0}),n})();function HBe(n,t){if(1&n&&(h(0,"span"),T(1),g()),2&n){let e=w();v(1),He(" and ",e.getPluginTypeFilterString(e.pluginTypes)," visualization filter")}}var rne=(()=>{class n{constructor(){this.PluginType=zn,this.listFormatter=new Intl.ListFormat(void 0,{style:"long",type:"disjunction"})}getPluginTypeFilterString(e){let i=[...e].map(r=>{switch(r){case zn.SCALARS:return"scalar";case zn.IMAGES:return"image";case zn.HISTOGRAMS:return"histogram";default:throw new RangeError(`Please implement human readable name for plugin type: ${r}`)}});return this.listFormatter.format(i)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["metrics-empty-tag-match-component"]],inputs:{pluginTypes:"pluginTypes",tagFilterRegex:"tagFilterRegex",tagCounts:"tagCounts"},decls:6,vars:5,consts:[[4,"ngIf"]],template:function(e,i){1&e&&(T(0,"No matches for tag filter "),h(1,"code"),T(2),g(),S(3,HBe,2,1,"span",0),T(4),j(5,"number")),2&e&&(v(2),He("/",i.tagFilterRegex,"/"),v(1),_("ngIf",i.pluginTypes.size),v(1),He(" out of ",W(5,3,i.tagCounts)," tags."))},dependencies:[Fe,La],encapsulation:2,changeDetection:0}),n})(),one=(()=>{class n{constructor(e){this.store=e,this.pluginTypes$=this.store.select(Dc),this.tagFilterRegex$=this.store.select(kl),this.tagCounts$=this.store.select(Nf).pipe(N(i=>new Set(i.map(({tag:r})=>r)).size))}}return n.\u0275fac=function(e){return new(e||n)(C(Ae))},n.\u0275cmp=O({type:n,selectors:[["metrics-empty-tag-match"]],decls:4,vars:9,consts:[[3,"pluginTypes","tagFilterRegex","tagCounts"]],template:function(e,i){1&e&&(P(0,"metrics-empty-tag-match-component",0),j(1,"async"),j(2,"async"),j(3,"async")),2&e&&_("pluginTypes",W(1,3,i.pluginTypes$))("tagFilterRegex",W(2,5,i.tagFilterRegex$))("tagCounts",W(3,7,i.tagCounts$))},dependencies:[rne,ct],encapsulation:2,changeDetection:0}),n})();function jBe(n,t){if(1&n&&(h(0,"span",6),T(1),j(2,"number"),g()),2&n){let e=w();v(1),He("",W(2,1,e.cardIdsWithMetadata.length)," cards")}}function GBe(n,t){1&n&&P(0,"metrics-empty-tag-match",7)}var sne=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["metrics-filtered-view-component"]],inputs:{isEmptyMatch:"isEmptyMatch",cardObserver:"cardObserver",cardIdsWithMetadata:"cardIdsWithMetadata"},decls:7,vars:4,consts:[[1,"group-toolbar"],[1,"group-text"],["aria-role","heading","aria-level","3",1,"group-title"],["class","group-card-count",4,"ngIf"],["class","warn",4,"ngIf"],[3,"cardIdsWithMetadata","cardObserver"],[1,"group-card-count"],[1,"warn"]],template:function(e,i){1&e&&(h(0,"div",0)(1,"span",1)(2,"span",2),T(3,"Tags matching filter"),g(),S(4,jBe,3,3,"span",3),g()(),S(5,GBe,1,0,"metrics-empty-tag-match",4),P(6,"metrics-card-grid",5)),2&e&&(v(4),_("ngIf",i.cardIdsWithMetadata.length>1),v(1),_("ngIf",i.isEmptyMatch),v(1),_("cardIdsWithMetadata",i.cardIdsWithMetadata)("cardObserver",i.cardObserver))},dependencies:[Fe,p_,one,La],styles:["[_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{background-color:#fff;border-bottom:1px solid #ebebeb;align-items:center;background-color:#fff;display:flex;flex:none;height:42px;margin-bottom:-1px;padding:0 16px;position:sticky;top:0;z-index:1;box-shadow:0px 2px 4px 0px rgba(0,0,0,.15)}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{background-color:#303030}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{border-bottom:1px solid #555}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{box-shadow:0px 2px 4px 0px rgba(255,255,255,.15)}.group-text[_ngcontent-%COMP%]{display:flex;align-items:baseline}.group-title[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.group-card-count[_ngcontent-%COMP%]{font-size:12px;font-weight:400;color:#616161;margin-left:6px}body.dark-mode[_nghost-%COMP%]   .group-card-count[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .group-card-count[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}metrics-empty-tag-match[_ngcontent-%COMP%]{color:#616161;font-size:13px;font-style:italic;padding:16px;text-align:center;display:block}body.dark-mode[_nghost-%COMP%]   metrics-empty-tag-match[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   metrics-empty-tag-match[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}"],changeDetection:0}),n})(),ane=(()=>{class n{constructor(e){this.store=e,this.cardIdsWithMetadata$=this.store.select(Nf).pipe(Li(this.store.select(Dc)),N(([i,r])=>r.size?i.filter(o=>r.has(o.plugin)):i),Li(this.store.select(kl)),wr(200),N(([i,r])=>{try{return{cardList:i,regex:new RegExp(r,"i")}}catch{return{cardList:i,regex:null}}}),ke(({regex:i})=>null!==i),N(({cardList:i,regex:r})=>i.filter(({tag:o})=>r.test(o))),Yn((i,r)=>i.length===r.length&&i.every((o,s)=>o.cardId===r[s].cardId)),Cs(),qn([])),this.isEmptyMatch$=this.cardIdsWithMetadata$.pipe(Li(this.store.select(Nf)),N(([i,r])=>Boolean(r.length)&&0===i.length))}}return n.\u0275fac=function(e){return new(e||n)(C(Ae))},n.\u0275cmp=O({type:n,selectors:[["metrics-filtered-view"]],inputs:{cardObserver:"cardObserver"},decls:3,vars:7,consts:[[3,"isEmptyMatch","cardIdsWithMetadata","cardObserver"]],template:function(e,i){1&e&&(P(0,"metrics-filtered-view-component",0),j(1,"async"),j(2,"async")),2&e&&_("isEmptyMatch",W(1,3,i.isEmptyMatch$))("cardIdsWithMetadata",W(2,5,i.cardIdsWithMetadata$))("cardObserver",i.cardObserver)},dependencies:[sne,ct],encapsulation:2,changeDetection:0}),n})();function XBe(n,t){1&n&&P(0,"mat-icon",7)}function QBe(n,t){if(1&n&&(h(0,"mat-option",8),T(1),g()),2&n){let e=t.$implicit;_("value",e),Be("title",e),v(1),bt(e)}}function ZBe(n,t){if(1&n&&(h(0,"div",9)(1,"em"),T(2),j(3,"number"),g()()),2&n){let e=w();v(2),He("and ",W(3,1,e.completions.length-25)," more tags matched")}}var lne=(()=>{class n{constructor(){this.onRegexFilterValueChange=new F}onCompletionAccepted(e){this.onRegexFilterValueChange.emit(function(n){return n.replace(fbe,"\\$&")}(e))}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["metrics-tag-filter-component"]],hostVars:2,hostBindings:function(e,i){2&e&&nt("valid",i.isRegexFilterValid)},inputs:{regexFilterValue:"regexFilterValue",isRegexFilterValid:"isRegexFilterValid",completions:"completions"},outputs:{onRegexFilterValueChange:"onRegexFilterValueChange"},decls:7,vars:5,consts:[[1,"tag-filter"],["placeholder","Filter tags (regex)",3,"value","matAutocomplete","input"],["svgIcon","error_24px","class","error-icon","title","Invalid regex filter. The result may be stale.",4,"ngIf"],[1,"tag-options",3,"optionSelected"],["filterMatches","matAutocomplete"],["class","option",3,"value",4,"ngFor","ngForOf"],["class","and-more",4,"ngIf"],["svgIcon","error_24px","title","Invalid regex filter. The result may be stale.",1,"error-icon"],[1,"option",3,"value"],[1,"and-more"]],template:function(e,i){if(1&e&&(h(0,"div",0)(1,"tb-filter-input",1),I("input",function(o){return i.onRegexFilterValueChange.emit(o.target.value)}),g(),S(2,XBe,1,0,"mat-icon",2),g(),h(3,"mat-autocomplete",3,4),I("optionSelected",function(o){return i.onCompletionAccepted(o.option.value)}),S(5,QBe,2,3,"mat-option",5),S(6,ZBe,4,3,"div",6),g()),2&e){let r=it(4);v(1),_("value",i.regexFilterValue)("matAutocomplete",r),v(1),_("ngIf",!i.isRegexFilterValid),v(3),_("ngForOf",null==i.completions?null:i.completions.slice(0,25)),v(1),_("ngIf",(null==i.completions?null:i.completions.length)>25)}},dependencies:[nn,Fe,Sp,Ote,Us,En,La],styles:[".tag-filter[_ngcontent-%COMP%]{display:flex;position:relative}tb-filter-input[_ngcontent-%COMP%]{flex-grow:1}[_nghost-%COMP%]{color:#212121}body.dark-mode   [_nghost-%COMP%]{color:#fff}[_nghost-%COMP%]:not(.valid){color:#c62828}[_nghost-%COMP%]:not(.valid)   .error-icon[_ngcontent-%COMP%]{color:#c62828;position:absolute;right:0}  .tag-options .option,   .tag-options .and-more{-webkit-box-orient:vertical;-webkit-line-clamp:3;display:-webkit-box;font-size:14px;line-height:1.4;padding:8px 16px}  .tag-options .and-more{color:#616161}body.dark-mode[_nghost-%COMP%]     .tag-options .and-more, body.dark-mode   [_nghost-%COMP%]     .tag-options .and-more{color:rgba(255,255,255,.7)}"],changeDetection:0}),n})(),cne=(()=>{class n{constructor(e){this.store=e,this.tagFilter$=this.store.select(kl),this.isTagFilterRegexValid$=this.tagFilter$.pipe(N(i=>{try{return new RegExp(i),!0}catch{return!1}})),this.completions$=this.store.select(e1).pipe(Li(this.store.select(Dc)),N(([i,r])=>i.filter(({plugin:o})=>!r.size||r.has(o)).map(({tag:o})=>o)),N(i=>[...new Set(i)]),N(i=>i.sort(yy)),Li(this.store.select(kl)),N(([i,r])=>{try{return[i,new RegExp(r,"i")]}catch{return[i,null]}}),ke(([,i])=>null!==i),N(([i,r])=>i.filter(o=>r.test(o))))}onTagFilterChange(e){this.store.dispatch(RT({tagFilter:e}))}}return n.\u0275fac=function(e){return new(e||n)(C(Ae))},n.\u0275cmp=O({type:n,selectors:[["metrics-tag-filter"]],decls:4,vars:9,consts:[[3,"regexFilterValue","isRegexFilterValid","completions","onRegexFilterValueChange"]],template:function(e,i){1&e&&(h(0,"metrics-tag-filter-component",0),I("onRegexFilterValueChange",function(o){return i.onTagFilterChange(o)}),j(1,"async"),j(2,"async"),j(3,"async"),g()),2&e&&_("regexFilterValue",W(1,3,i.tagFilter$))("isRegexFilterValid",W(2,5,i.isTagFilterRegexValid$))("completions",W(3,7,i.completions$))},dependencies:[lne,ct],encapsulation:2,changeDetection:0}),n})();function $Be(n,t){if(1&n&&(h(0,"span",8),T(1),g()),2&n){let e=w();v(1),He("",e.cardIdsWithMetadata.length," cards")}}function eVe(n,t){1&n&&(h(0,"span",9),T(1,"New card pinned"),g()),2&n&&Be("data-id",t.$implicit)}function tVe(n,t){if(1&n&&P(0,"metrics-card-grid",10),2&n){let e=w();_("cardIdsWithMetadata",e.cardIdsWithMetadata)("cardObserver",e.cardObserver)}}function nVe(n,t){1&n&&(h(0,"div",11),T(1,"Pin cards for a quick view and comparison"),g())}var dne=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["metrics-pinned-view-component"]],inputs:{cardObserver:"cardObserver",cardIdsWithMetadata:"cardIdsWithMetadata",newCardPinnedIds:"newCardPinnedIds"},decls:10,vars:4,consts:[[1,"group-toolbar"],["svgIcon","keep_24px"],[1,"group-text"],["aria-role","heading","aria-level","3",1,"group-title"],["class","group-card-count",4,"ngIf"],["class","new-card-pinned",4,"ngFor","ngForOf"],[3,"cardIdsWithMetadata","cardObserver",4,"ngIf","ngIfElse"],["emptyPinnedView",""],[1,"group-card-count"],[1,"new-card-pinned"],[3,"cardIdsWithMetadata","cardObserver"],[1,"empty-message"]],template:function(e,i){if(1&e&&(h(0,"div",0),P(1,"mat-icon",1),h(2,"span",2)(3,"span",3),T(4,"Pinned"),g(),S(5,$Be,2,1,"span",4),S(6,eVe,2,1,"span",5),g()(),S(7,tVe,1,2,"metrics-card-grid",6),S(8,nVe,2,0,"ng-template",null,7,Wt)),2&e){let r=it(9);v(5),_("ngIf",i.cardIdsWithMetadata.length>1),v(1),_("ngForOf",i.newCardPinnedIds),v(1),_("ngIf",i.cardIdsWithMetadata.length)("ngIfElse",r)}},dependencies:[nn,Fe,En,p_],styles:["[_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{background-color:#fff;border-bottom:1px solid #ebebeb;align-items:center;background-color:#fff;display:flex;flex:none;height:42px;margin-bottom:-1px;padding:0 16px;position:sticky;top:0;z-index:1;box-shadow:0px 2px 4px 0px rgba(0,0,0,.15)}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{background-color:#303030}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{border-bottom:1px solid #555}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{box-shadow:0px 2px 4px 0px rgba(255,255,255,.15)}mat-icon[_ngcontent-%COMP%]{color:#616161;flex:none;margin-right:5px}body.dark-mode[_nghost-%COMP%]   mat-icon[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   mat-icon[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}.group-text[_ngcontent-%COMP%]{display:flex;align-items:baseline;gap:6px}.group-title[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.group-card-count[_ngcontent-%COMP%]{font-size:12px;font-weight:400;color:#616161}body.dark-mode[_nghost-%COMP%]   .group-card-count[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .group-card-count[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}.empty-message[_ngcontent-%COMP%]{color:#616161;font-size:13px;font-style:italic;padding:16px;text-align:center}body.dark-mode[_nghost-%COMP%]   .empty-message[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .empty-message[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}.new-card-pinned[_ngcontent-%COMP%]{animation:_ngcontent-%COMP%_pinned-view-fade-out 3s linear;background:#f44336;border-radius:5px;color:#fff;display:inline-block;font-size:13px;opacity:0;padding:3px 5px}@keyframes _ngcontent-%COMP%_pinned-view-fade-out{from{opacity:1}66%{opacity:.99}to{opacity:0}}"],changeDetection:0}),n})(),une=(()=>{class n{constructor(e){this.store=e,this.cardIdsWithMetadata$=this.store.select(yv).pipe(qn([])),this.newCardPinnedIds$=this.store.select(yv).pipe(ia(1),N(i=>i.map(r=>r.cardId)),Fm(),N(([i,r])=>{let o=new Set(i),s=new Set(r);for(let a of s)if(!o.has(a))return Date.now();return null}),qn(null),Fm(),N(([i,r])=>null===i&&null===r?null:null===r?[i]:[r]),ke(i=>null!==i),N(i=>[i[0]]))}}return n.\u0275fac=function(e){return new(e||n)(C(Ae))},n.\u0275cmp=O({type:n,selectors:[["metrics-pinned-view"]],inputs:{cardObserver:"cardObserver"},decls:3,vars:7,consts:[[3,"cardIdsWithMetadata","newCardPinnedIds","cardObserver"]],template:function(e,i){1&e&&(P(0,"metrics-pinned-view-component",0),j(1,"async"),j(2,"async")),2&e&&_("cardIdsWithMetadata",W(1,3,i.cardIdsWithMetadata$))("newCardPinnedIds",W(2,5,i.newCardPinnedIds$))("cardObserver",i.cardObserver)},dependencies:[dne,ct],encapsulation:2,changeDetection:0}),n})();function oVe(n,t){1&n&&P(0,"metrics-filtered-view",13),2&n&&_("cardObserver",w().cardObserver)}function sVe(n,t){1&n&&(h(0,"div",17),P(1,"mat-spinner",18),g())}var aVe=function(n){return{"slide-out-menu-expanded":n}};function lVe(n,t){if(1&n&&(h(0,"div",19),P(1,"metrics-scalar-column-editor"),g()),2&n){let e=w();_("ngClass",In(1,aVe,e.slideOutMenuOpen))}}function cVe(n,t){if(1&n){let e=ge();h(0,"div",20)(1,"div",21)(2,"h2",22),T(3,"Settings"),g(),h(4,"button",23),I("click",function(){return X(e),Q(w().onCloseSidepaneButtonClicked.emit())}),P(5,"mat-icon",24),g()(),P(6,"metrics-dashboard-right-pane"),g()}}var dVe=function(n){return{checked:n,"settings-button":!0}},uVe=new ie("Customizable Share Button"),pne=(()=>{class n{constructor(e,i){this.host=e,this.customShareButton=i,this.onSettingsButtonClicked=new F,this.onCloseSidepaneButtonClicked=new F,this.onPluginTypeToggled=new F,this.onPluginTypeAllToggled=new F,this.PluginType=zn,this.cardObserver=new xy(this.host.nativeElement,"600px 0px 600px 0px")}}return n.\u0275fac=function(e){return new(e||n)(C(Me),C(uVe,8))},n.\u0275cmp=O({type:n,selectors:[["metrics-main-view-component"]],inputs:{showFilteredView:"showFilteredView",isSidepaneOpen:"isSidepaneOpen",filteredPluginTypes:"filteredPluginTypes",initialTagsLoading:"initialTagsLoading",slideOutMenuOpen:"slideOutMenuOpen"},outputs:{onSettingsButtonClicked:"onSettingsButtonClicked",onCloseSidepaneButtonClicked:"onCloseSidepaneButtonClicked",onPluginTypeToggled:"onPluginTypeToggled",onPluginTypeAllToggled:"onPluginTypeAllToggled"},decls:24,vars:23,consts:function(){let t,e;return t=$localize`:Label on a toolbar button to toggle the settings side pane.␟d3516db6bbe6860a55beab66e4969dac625b8d72␟7659285445580838925:Toggle settings side pane`,e=$localize`:Label on a button to close the settings side pane.␟04521dc0b6a65cf5c382944c9a8b4b844a3e9598␟8156766997747165871:Close side pane`,[[1,"toolbar"],["multiple","","appearance","standard",1,"filter-view"],["mat-button","","role","checkbox","data-value","all",1,"filter-view-button",3,"click"],["mat-button","","role","checkbox","data-value","scalars",1,"filter-view-button",3,"click"],["mat-button","","role","checkbox","data-value","image",1,"filter-view-button",3,"click"],["mat-button","","role","checkbox","data-value","histogram",1,"filter-view-button",3,"click"],[3,"customizableComponent"],[1,"right-items"],["mat-stroked-button","","aria-label",t,3,"ngClass","click"],["svgIcon","settings_24px"],[1,"split-content"],["cdkScrollable",""],[3,"cardObserver",4,"ngIf"],[3,"cardObserver"],["class","loading-container",4,"ngIf"],["class","slide-out-menu",3,"ngClass",4,"ngIf"],["class","sidebar",4,"ngIf"],[1,"loading-container"],["diameter","36"],[1,"slide-out-menu",3,"ngClass"],[1,"sidebar"],[1,"header"],[1,"title"],["mat-icon-button","","aria-label",e,3,"click"],["svgIcon","close_24px"]]},template:function(e,i){1&e&&(h(0,"div",0),P(1,"metrics-tag-filter"),h(2,"mat-button-toggle-group",1)(3,"button",2),I("click",function(){return i.onPluginTypeAllToggled.emit()}),T(4," All "),g(),h(5,"button",3),I("click",function(){return i.onPluginTypeToggled.emit(i.PluginType.SCALARS)}),T(6," Scalars "),g(),h(7,"button",4),I("click",function(){return i.onPluginTypeToggled.emit(i.PluginType.IMAGES)}),T(8," Image "),g(),h(9,"button",5),I("click",function(){return i.onPluginTypeToggled.emit(i.PluginType.HISTOGRAMS)}),T(10," Histogram "),g()(),P(11,"tb-customization",6),h(12,"div",7)(13,"button",8),I("click",function(){return i.onSettingsButtonClicked.emit()}),P(14,"mat-icon",9),T(15," Settings "),g()()(),h(16,"div",10)(17,"div",11),S(18,oVe,1,1,"metrics-filtered-view",12),P(19,"metrics-pinned-view",13),S(20,sVe,2,0,"div",14),P(21,"metrics-card-groups",13),g(),S(22,lVe,2,3,"div",15),S(23,cVe,7,0,"div",16),g()),2&e&&(v(3),Be("aria-checked",0===i.filteredPluginTypes.size),v(2),Be("aria-checked",i.filteredPluginTypes.has(i.PluginType.SCALARS)),v(2),Be("aria-checked",i.filteredPluginTypes.has(i.PluginType.IMAGES)),v(2),Be("aria-checked",i.filteredPluginTypes.has(i.PluginType.HISTOGRAMS)),v(2),_("customizableComponent",i.customShareButton),v(2),_("ngClass",In(21,dVe,i.isSidepaneOpen)),Be("aria-pressed",i.isSidepaneOpen),v(4),nt("main",!0)("filter-view",i.showFilteredView),v(1),_("ngIf",i.showFilteredView),v(1),Tt("display",i.showFilteredView?"none":""),_("cardObserver",i.cardObserver),v(1),_("ngIf",i.initialTagsLoading),v(1),Tt("display",i.showFilteredView?"none":""),_("cardObserver",i.cardObserver),v(1),_("ngIf",i.isSidepaneOpen),v(1),_("ngIf",i.isSidepaneOpen))},dependencies:[yn,Fe,cQ,Cd,Ji,$i,RN,En,tl,bQ,CQ,ine,ane,cne,une],styles:["[_nghost-%COMP%]{display:flex;flex-direction:column;height:100%}.toolbar[_ngcontent-%COMP%]{border-bottom:1px solid #ebebeb;flex:none;display:flex;align-items:center;justify-content:space-between;height:48px;padding:0 16px}body.dark-mode[_nghost-%COMP%]   .toolbar[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .toolbar[_ngcontent-%COMP%]{border-bottom:1px solid #555}.toolbar[_ngcontent-%COMP%]   metrics-tag-filter[_ngcontent-%COMP%]{flex:1 1 100px}.toolbar[_ngcontent-%COMP%]   .right-items[_ngcontent-%COMP%]{border-left:1px solid #ebebeb;margin-left:16px;padding-left:16px}body.dark-mode[_nghost-%COMP%]   .toolbar[_ngcontent-%COMP%]   .right-items[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .toolbar[_ngcontent-%COMP%]   .right-items[_ngcontent-%COMP%]{border-left:1px solid #555}mat-button-toggle-group.filter-view[_ngcontent-%COMP%]{border:1px solid #ebebeb}body.dark-mode[_nghost-%COMP%]   mat-button-toggle-group.filter-view[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   mat-button-toggle-group.filter-view[_ngcontent-%COMP%]{border:1px solid #555}.filter-view[_ngcontent-%COMP%]{border-radius:4px;flex:none;margin-right:5px}.filter-view[_ngcontent-%COMP%]   button[_ngcontent-%COMP%]{border-radius:0;font-size:12px;font-weight:normal;height:25px;line-height:25px;min-width:unset;padding:0 12px}.filter-view[_ngcontent-%COMP%]   button[_ngcontent-%COMP%] + button[_ngcontent-%COMP%]{border-left:1px solid #ebebeb}body.dark-mode[_nghost-%COMP%]   .filter-view[_ngcontent-%COMP%]   button[_ngcontent-%COMP%] + button[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .filter-view[_ngcontent-%COMP%]   button[_ngcontent-%COMP%] + button[_ngcontent-%COMP%]{border-left:1px solid #555}.filter-view[_ngcontent-%COMP%]   button[aria-checked=true][_ngcontent-%COMP%]{background-color:#e0e0e0}body.dark-mode[_nghost-%COMP%]   .filter-view[_ngcontent-%COMP%]   button[aria-checked=true][_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .filter-view[_ngcontent-%COMP%]   button[aria-checked=true][_ngcontent-%COMP%]{background-color:#212121}.split-content[_ngcontent-%COMP%]{display:flex;overflow-y:auto;flex:1}.main[_ngcontent-%COMP%], .sidebar[_ngcontent-%COMP%]{contain:strict;background-color:#fff;overflow-x:hidden;overflow-y:auto;will-change:transform,scroll-position}body.dark-mode[_nghost-%COMP%]   .main[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .main[_ngcontent-%COMP%]{background-color:#303030}body.dark-mode[_nghost-%COMP%]   .sidebar[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .sidebar[_ngcontent-%COMP%]{background-color:#303030}.main[_ngcontent-%COMP%]{background-color:#f5f6f7;flex:1 1;display:flex;flex-direction:column}body.dark-mode[_nghost-%COMP%]   .main[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .main[_ngcontent-%COMP%]{background-color:#3a3a3a}.main[_ngcontent-%COMP%]   metrics-filtered-view[_ngcontent-%COMP%], .main[_ngcontent-%COMP%]   metrics-pinned-view[_ngcontent-%COMP%]{border-bottom:1px solid #ebebeb}body.dark-mode[_nghost-%COMP%]   .main[_ngcontent-%COMP%]   metrics-filtered-view[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .main[_ngcontent-%COMP%]   metrics-filtered-view[_ngcontent-%COMP%]{border-bottom:1px solid #555}body.dark-mode[_nghost-%COMP%]   .main[_ngcontent-%COMP%]   metrics-pinned-view[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .main[_ngcontent-%COMP%]   metrics-pinned-view[_ngcontent-%COMP%]{border-bottom:1px solid #555}.main.filter-view[_ngcontent-%COMP%]{overflow:hidden}.main.filter-view[_ngcontent-%COMP%]   metrics-filtered-view[_ngcontent-%COMP%]{contain:content;overflow:auto;will-change:transform,scroll-position}.loading-container[_ngcontent-%COMP%]{align-items:center;display:flex;justify-content:center;margin:20px 0}.sidebar[_ngcontent-%COMP%]{border-left:1px solid #ebebeb;flex:0 0 250px}body.dark-mode[_nghost-%COMP%]   .sidebar[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .sidebar[_ngcontent-%COMP%]{border-left:1px solid #555}.sidebar[_ngcontent-%COMP%]   .header[_ngcontent-%COMP%]{border-bottom:1px solid #ebebeb;display:flex;align-items:center;justify-content:space-between;height:42px;padding:0 16px}body.dark-mode[_nghost-%COMP%]   .sidebar[_ngcontent-%COMP%]   .header[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .sidebar[_ngcontent-%COMP%]   .header[_ngcontent-%COMP%]{border-bottom:1px solid #555}.sidebar[_ngcontent-%COMP%]   .header[_ngcontent-%COMP%]   .title[_ngcontent-%COMP%]{font-size:18px;font-weight:400;line-height:normal;margin:0}[_nghost-%COMP%]   .settings-button[_ngcontent-%COMP%]{color:#616161;display:inline-flex}body.dark-mode   [_nghost-%COMP%]   .settings-button[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}[_nghost-%COMP%]   .settings-button.checked[_ngcontent-%COMP%]{background-color:#e0e0e0;border-color:#e0e0e0}body.dark-mode   [_nghost-%COMP%]   .settings-button.checked[_ngcontent-%COMP%]{background-color:#212121}[_nghost-%COMP%]   .settings-button[_ngcontent-%COMP%]     .mat-button-wrapper{display:inline-flex;align-items:center}[_nghost-%COMP%]   .settings-button[_ngcontent-%COMP%]   mat-icon[_ngcontent-%COMP%]{margin-right:4px}.slide-out-menu[_ngcontent-%COMP%]{background-color:#fff;height:calc(100% - 49px);position:absolute;right:50px;top:49px;transition:all .75s ease;visibility:hidden;width:200px;border-left:1px solid #ebebeb}body.dark-mode[_nghost-%COMP%]   .slide-out-menu[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .slide-out-menu[_ngcontent-%COMP%]{border-left:1px solid #555}body.dark-mode[_nghost-%COMP%]   .slide-out-menu[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .slide-out-menu[_ngcontent-%COMP%]{background-color:#303030}.slide-out-menu-expanded[_ngcontent-%COMP%]{right:250px;visibility:visible}"],changeDetection:0}),n})(),fne=(()=>{class n{constructor(e){this.store=e,this.isSidepaneOpen$=this.store.select(a1),this.initialTagsLoading$=this.store.select(vv).pipe(A_(i=>null===i.lastLoadedTimeInMs,!0),N(i=>i.state===Te.LOADING&&null===i.lastLoadedTimeInMs)),this.showFilteredView$=this.store.select(kl).pipe(N(i=>i.length>0)),this.filteredPluginTypes$=this.store.select(Dc),this.isSlideoutMenuOpen$=this.store.select(l1)}onSettingsButtonClicked(){this.store.dispatch(oT())}onCloseSidepaneButtonClicked(){this.store.dispatch(rT())}onPluginVisibilityToggled(e){this.store.dispatch(OT({plugin:e}))}onShowAllPlugins(){this.store.dispatch(kT())}}return n.\u0275fac=function(e){return new(e||n)(C(Ae))},n.\u0275cmp=O({type:n,selectors:[["metrics-main-view"]],decls:6,vars:15,consts:[[3,"showFilteredView","isSidepaneOpen","initialTagsLoading","filteredPluginTypes","slideOutMenuOpen","onSettingsButtonClicked","onCloseSidepaneButtonClicked","onPluginTypeToggled","onPluginTypeAllToggled"]],template:function(e,i){1&e&&(h(0,"metrics-main-view-component",0),I("onSettingsButtonClicked",function(){return i.onSettingsButtonClicked()})("onCloseSidepaneButtonClicked",function(){return i.onCloseSidepaneButtonClicked()})("onPluginTypeToggled",function(o){return i.onPluginVisibilityToggled(o)})("onPluginTypeAllToggled",function(){return i.onShowAllPlugins()}),j(1,"async"),j(2,"async"),j(3,"async"),j(4,"async"),j(5,"async"),g()),2&e&&_("showFilteredView",W(1,5,i.showFilteredView$))("isSidepaneOpen",W(2,7,i.isSidepaneOpen$))("initialTagsLoading",W(3,9,i.initialTagsLoading$))("filteredPluginTypes",W(4,11,i.filteredPluginTypes$))("slideOutMenuOpen",W(5,13,i.isSlideoutMenuOpen$))},dependencies:[pne,ct],encapsulation:2,changeDetection:0}),n})(),bs=(()=>(function(n){n.CHECKBOX="checkbox",n.RUN_NAME="run_name",n.EXPERIMENT_NAME="experiment_name",n.RUN_COLOR="run_color"}(bs||(bs={})),bs))(),Ep=(()=>(function(n){n[n.BEFORE=0]="BEFORE",n[n.AFTER=1]="AFTER"}(Ep||(Ep={})),Ep))(),mne=new Set(["string","number"]),mVe={insertUndefined:Ep.AFTER};function hne(n){if("number"==typeof n)return isNaN(n)?void 0:n;if(!isNaN(parseInt(n)))return parseInt(n);for(let t=0;t<n.length;t++)if(isNaN(parseInt(n[t])))return 0===t?void 0:parseInt(n.slice(0,t))}var hVe=["dialogPopup"],gVe=["hueSlider"],_Ve=["alphaSlider"];function bVe(n,t){if(1&n&&P(0,"div"),2&n){let e=w();mb("arrow arrow-",e.cpUsePosition,""),Tt("top",e.arrowTop,"px")}}function vVe(n,t){if(1&n){let e=ge();h(0,"div",28),I("newValue",function(r){return X(e),Q(w().onColorChange(r))})("dragStart",function(){return X(e),Q(w().onDragStart("saturation-lightness"))})("dragEnd",function(){return X(e),Q(w().onDragEnd("saturation-lightness"))}),P(1,"div",14),g()}if(2&n){let e=w();Tt("background-color",e.hueSliderColor),_("rgX",1)("rgY",1),v(1),Tt("top",null==e.slider?null:e.slider.v,"px")("left",null==e.slider?null:e.slider.s,"px")}}function yVe(n,t){1&n&&(Nn(),h(0,"svg",29),P(1,"path",30)(2,"path",31),g())}function xVe(n,t){if(1&n){let e=ge();h(0,"button",32),I("click",function(r){X(e);let o=w();return Q(o.onAddPresetColor(r,o.selectedColor))}),T(1),g()}if(2&n){let e=w();As(e.cpAddColorButtonClass),_("disabled",e.cpPresetColors&&e.cpPresetColors.length>=e.cpMaxPresetColorsLength),v(1),He(" ",e.cpAddColorButtonText," ")}}function CVe(n,t){1&n&&P(0,"div",33)}function MVe(n,t){if(1&n){let e=ge();h(0,"input",39),I("keyup.enter",function(r){return X(e),Q(w(2).onAcceptColor(r))})("newValue",function(r){return X(e),Q(w(2).onAlphaInput(r))}),g()}if(2&n){let e=w(2);_("rg",1)("value",null==e.cmykText?null:e.cmykText.a)}}function wVe(n,t){1&n&&(h(0,"div"),T(1,"A"),g())}function SVe(n,t){if(1&n){let e=ge();h(0,"div",34)(1,"div",35)(2,"input",36),I("keyup.enter",function(r){return X(e),Q(w().onAcceptColor(r))})("newValue",function(r){return X(e),Q(w().onCyanInput(r))}),g(),h(3,"input",36),I("keyup.enter",function(r){return X(e),Q(w().onAcceptColor(r))})("newValue",function(r){return X(e),Q(w().onMagentaInput(r))}),g(),h(4,"input",36),I("keyup.enter",function(r){return X(e),Q(w().onAcceptColor(r))})("newValue",function(r){return X(e),Q(w().onYellowInput(r))}),g(),h(5,"input",36),I("keyup.enter",function(r){return X(e),Q(w().onAcceptColor(r))})("newValue",function(r){return X(e),Q(w().onBlackInput(r))}),g(),S(6,MVe,1,2,"input",37),g(),h(7,"div",35)(8,"div"),T(9,"C"),g(),h(10,"div"),T(11,"M"),g(),h(12,"div"),T(13,"Y"),g(),h(14,"div"),T(15,"K"),g(),S(16,wVe,2,0,"div",38),g()()}if(2&n){let e=w();Tt("display",3!==e.format?"none":"block"),v(2),_("rg",100)("value",null==e.cmykText?null:e.cmykText.c),v(1),_("rg",100)("value",null==e.cmykText?null:e.cmykText.m),v(1),_("rg",100)("value",null==e.cmykText?null:e.cmykText.y),v(1),_("rg",100)("value",null==e.cmykText?null:e.cmykText.k),v(1),_("ngIf","disabled"!==e.cpAlphaChannel),v(10),_("ngIf","disabled"!==e.cpAlphaChannel)}}function EVe(n,t){if(1&n){let e=ge();h(0,"input",39),I("keyup.enter",function(r){return X(e),Q(w(2).onAcceptColor(r))})("newValue",function(r){return X(e),Q(w(2).onAlphaInput(r))}),g()}if(2&n){let e=w(2);_("rg",1)("value",null==e.hslaText?null:e.hslaText.a)}}function TVe(n,t){1&n&&(h(0,"div"),T(1,"A"),g())}function DVe(n,t){if(1&n){let e=ge();h(0,"div",40)(1,"div",35)(2,"input",41),I("keyup.enter",function(r){return X(e),Q(w().onAcceptColor(r))})("newValue",function(r){return X(e),Q(w().onHueInput(r))}),g(),h(3,"input",36),I("keyup.enter",function(r){return X(e),Q(w().onAcceptColor(r))})("newValue",function(r){return X(e),Q(w().onSaturationInput(r))}),g(),h(4,"input",36),I("keyup.enter",function(r){return X(e),Q(w().onAcceptColor(r))})("newValue",function(r){return X(e),Q(w().onLightnessInput(r))}),g(),S(5,EVe,1,2,"input",37),g(),h(6,"div",35)(7,"div"),T(8,"H"),g(),h(9,"div"),T(10,"S"),g(),h(11,"div"),T(12,"L"),g(),S(13,TVe,2,0,"div",38),g()()}if(2&n){let e=w();Tt("display",2!==e.format?"none":"block"),v(2),_("rg",360)("value",null==e.hslaText?null:e.hslaText.h),v(1),_("rg",100)("value",null==e.hslaText?null:e.hslaText.s),v(1),_("rg",100)("value",null==e.hslaText?null:e.hslaText.l),v(1),_("ngIf","disabled"!==e.cpAlphaChannel),v(8),_("ngIf","disabled"!==e.cpAlphaChannel)}}function IVe(n,t){if(1&n){let e=ge();h(0,"input",39),I("keyup.enter",function(r){return X(e),Q(w(2).onAcceptColor(r))})("newValue",function(r){return X(e),Q(w(2).onAlphaInput(r))}),g()}if(2&n){let e=w(2);_("rg",1)("value",null==e.rgbaText?null:e.rgbaText.a)}}function AVe(n,t){1&n&&(h(0,"div"),T(1,"A"),g())}function RVe(n,t){if(1&n){let e=ge();h(0,"div",42)(1,"div",35)(2,"input",43),I("keyup.enter",function(r){return X(e),Q(w().onAcceptColor(r))})("newValue",function(r){return X(e),Q(w().onRedInput(r))}),g(),h(3,"input",43),I("keyup.enter",function(r){return X(e),Q(w().onAcceptColor(r))})("newValue",function(r){return X(e),Q(w().onGreenInput(r))}),g(),h(4,"input",43),I("keyup.enter",function(r){return X(e),Q(w().onAcceptColor(r))})("newValue",function(r){return X(e),Q(w().onBlueInput(r))}),g(),S(5,IVe,1,2,"input",37),g(),h(6,"div",35)(7,"div"),T(8,"R"),g(),h(9,"div"),T(10,"G"),g(),h(11,"div"),T(12,"B"),g(),S(13,AVe,2,0,"div",38),g()()}if(2&n){let e=w();Tt("display",1!==e.format?"none":"block"),v(2),_("rg",255)("value",null==e.rgbaText?null:e.rgbaText.r),v(1),_("rg",255)("value",null==e.rgbaText?null:e.rgbaText.g),v(1),_("rg",255)("value",null==e.rgbaText?null:e.rgbaText.b),v(1),_("ngIf","disabled"!==e.cpAlphaChannel),v(8),_("ngIf","disabled"!==e.cpAlphaChannel)}}function PVe(n,t){if(1&n){let e=ge();h(0,"input",39),I("keyup.enter",function(r){return X(e),Q(w(2).onAcceptColor(r))})("newValue",function(r){return X(e),Q(w(2).onAlphaInput(r))}),g()}if(2&n){let e=w(2);_("rg",1)("value",e.hexAlpha)}}function OVe(n,t){1&n&&(h(0,"div"),T(1,"A"),g())}function kVe(n,t){if(1&n){let e=ge();h(0,"div",44)(1,"div",35)(2,"input",45),I("blur",function(){return X(e),Q(w().onHexInput(null))})("keyup.enter",function(r){return X(e),Q(w().onAcceptColor(r))})("newValue",function(r){return X(e),Q(w().onHexInput(r))}),g(),S(3,PVe,1,2,"input",37),g(),h(4,"div",35)(5,"div"),T(6,"Hex"),g(),S(7,OVe,2,0,"div",38),g()()}if(2&n){let e=w();Tt("display",0!==e.format?"none":"block"),nt("hex-alpha","forced"===e.cpAlphaChannel),v(2),_("value",e.hexText),v(1),_("ngIf","forced"===e.cpAlphaChannel),v(4),_("ngIf","forced"===e.cpAlphaChannel)}}function FVe(n,t){if(1&n){let e=ge();h(0,"input",39),I("keyup.enter",function(r){return X(e),Q(w(2).onAcceptColor(r))})("newValue",function(r){return X(e),Q(w(2).onAlphaInput(r))}),g()}if(2&n){let e=w(2);_("rg",1)("value",null==e.hslaText?null:e.hslaText.a)}}function NVe(n,t){if(1&n){let e=ge();h(0,"div",46)(1,"div",35)(2,"input",36),I("keyup.enter",function(r){return X(e),Q(w().onAcceptColor(r))})("newValue",function(r){return X(e),Q(w().onValueInput(r))}),g(),S(3,FVe,1,2,"input",37),g(),h(4,"div",35)(5,"div"),T(6,"V"),g(),h(7,"div"),T(8,"A"),g()()()}if(2&n){let e=w();v(2),_("rg",100)("value",null==e.hslaText?null:e.hslaText.l),v(1),_("ngIf","disabled"!==e.cpAlphaChannel)}}function LVe(n,t){if(1&n){let e=ge();h(0,"div",47)(1,"span",48),I("click",function(){return X(e),Q(w().onFormatToggle(-1))}),g(),h(2,"span",48),I("click",function(){return X(e),Q(w().onFormatToggle(1))}),g()()}}function BVe(n,t){if(1&n){let e=ge();h(0,"span",55),I("click",function(r){X(e);let o=w().$implicit;return Q(w(3).onRemovePresetColor(r,o))}),g()}2&n&&As(w(4).cpRemoveColorButtonClass)}function VVe(n,t){if(1&n){let e=ge();h(0,"div",53),I("click",function(){let o=X(e).$implicit;return Q(w(3).setColorFromString(o))}),S(1,BVe,1,3,"span",54),g()}if(2&n){let e=t.$implicit,i=w(3);Tt("background-color",e),v(1),_("ngIf",i.cpAddColorButton)}}function HVe(n,t){if(1&n&&(h(0,"div"),S(1,VVe,2,3,"div",52),g()),2&n){let e=w(2);As(e.cpPresetColorsClass),v(1),_("ngForOf",e.cpPresetColors)}}function zVe(n,t){if(1&n&&(h(0,"div"),T(1),g()),2&n){let e=w(2);As(e.cpPresetEmptyMessageClass),v(1),bt(e.cpPresetEmptyMessage)}}function UVe(n,t){if(1&n&&(h(0,"div",49),P(1,"hr"),h(2,"div",50),T(3),g(),S(4,HVe,2,4,"div",51),S(5,zVe,2,4,"div",51),g()),2&n){let e=w();v(3),bt(e.cpPresetLabel),v(1),_("ngIf",null==e.cpPresetColors?null:e.cpPresetColors.length),v(1),_("ngIf",!(null!=e.cpPresetColors&&e.cpPresetColors.length)&&e.cpAddColorButton)}}function jVe(n,t){if(1&n){let e=ge();h(0,"button",58),I("click",function(r){return X(e),Q(w(2).onCancelColor(r))}),T(1),g()}if(2&n){let e=w(2);As(e.cpCancelButtonClass),v(1),bt(e.cpCancelButtonText)}}function GVe(n,t){if(1&n){let e=ge();h(0,"button",58),I("click",function(r){return X(e),Q(w(2).onAcceptColor(r))}),T(1),g()}if(2&n){let e=w(2);As(e.cpOKButtonClass),v(1),bt(e.cpOKButtonText)}}function WVe(n,t){if(1&n&&(h(0,"div",56),S(1,jVe,2,4,"button",57),S(2,GVe,2,4,"button",57),g()),2&n){let e=w();v(1),_("ngIf",e.cpCancelButton),v(1),_("ngIf",e.cpOKButton)}}function qVe(n,t){1&n&&li(0)}function YVe(n,t){if(1&n&&(h(0,"div",59),S(1,qVe,1,0,"ng-container",60),g()),2&n){let e=w();v(1),_("ngTemplateOutlet",e.cpExtraTemplate)}}var Ho=(()=>(function(n){n[n.HEX=0]="HEX",n[n.RGBA=1]="RGBA",n[n.HSLA=2]="HSLA",n[n.CMYK=3]="CMYK"}(Ho||(Ho={})),Ho))(),tc=class{constructor(t,e,i,r){this.r=t,this.g=e,this.b=i,this.a=r}},f_=class{constructor(t,e,i,r){this.h=t,this.s=e,this.v=i,this.a=r}},Yd=class{constructor(t,e,i,r){this.h=t,this.s=e,this.l=i,this.a=r}},xm=class{constructor(t,e,i,r,o=1){this.c=t,this.m=e,this.y=i,this.k=r,this.a=o}},ZVe=(()=>{class n{constructor(){this.newValue=new F}inputChange(e){let i=e.target.value;if(void 0===this.rg)this.newValue.emit(i);else{let r=parseFloat(i);this.newValue.emit({v:r,rg:this.rg})}}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275dir=we({type:n,selectors:[["","text",""]],hostBindings:function(e,i){1&e&&I("input",function(o){return i.inputChange(o)})},inputs:{rg:"rg",text:"text"},outputs:{newValue:"newValue"}}),n})(),KVe=(()=>{class n{constructor(e){this.elRef=e,this.dragEnd=new F,this.dragStart=new F,this.newValue=new F,this.listenerMove=i=>this.move(i),this.listenerStop=()=>this.stop()}mouseDown(e){this.start(e)}touchStart(e){this.start(e)}move(e){e.preventDefault(),this.setCursor(e)}start(e){this.setCursor(e),e.stopPropagation(),document.addEventListener("mouseup",this.listenerStop),document.addEventListener("touchend",this.listenerStop),document.addEventListener("mousemove",this.listenerMove),document.addEventListener("touchmove",this.listenerMove),this.dragStart.emit()}stop(){document.removeEventListener("mouseup",this.listenerStop),document.removeEventListener("touchend",this.listenerStop),document.removeEventListener("mousemove",this.listenerMove),document.removeEventListener("touchmove",this.listenerMove),this.dragEnd.emit()}getX(e){let i=this.elRef.nativeElement.getBoundingClientRect();return(void 0!==e.pageX?e.pageX:e.touches[0].pageX)-i.left-window.pageXOffset}getY(e){let i=this.elRef.nativeElement.getBoundingClientRect();return(void 0!==e.pageY?e.pageY:e.touches[0].pageY)-i.top-window.pageYOffset}setCursor(e){let i=this.elRef.nativeElement.offsetWidth,r=this.elRef.nativeElement.offsetHeight,o=Math.max(0,Math.min(this.getX(e),i)),s=Math.max(0,Math.min(this.getY(e),r));void 0!==this.rgX&&void 0!==this.rgY?this.newValue.emit({s:o/i,v:1-s/r,rgX:this.rgX,rgY:this.rgY}):void 0===this.rgX&&void 0!==this.rgY?this.newValue.emit({v:s/r,rgY:this.rgY}):void 0!==this.rgX&&void 0===this.rgY&&this.newValue.emit({v:o/i,rgX:this.rgX})}}return n.\u0275fac=function(e){return new(e||n)(C(Me))},n.\u0275dir=we({type:n,selectors:[["","slider",""]],hostBindings:function(e,i){1&e&&I("mousedown",function(o){return i.mouseDown(o)})("touchstart",function(o){return i.touchStart(o)})},inputs:{rgX:"rgX",rgY:"rgY",slider:"slider"},outputs:{dragEnd:"dragEnd",dragStart:"dragStart",newValue:"newValue"}}),n})(),mA=class{constructor(t,e,i,r){this.h=t,this.s=e,this.v=i,this.a=r}},hA=class{constructor(t,e,i,r){this.h=t,this.s=e,this.v=i,this.a=r}},EV=(()=>{class n{constructor(){this.active=null}setActive(e){this.active&&this.active!==e&&"inline"!==this.active.cpDialogDisplay&&this.active.closeDialog(),this.active=e}hsva2hsla(e){let i=e.h,r=e.s,o=e.v,s=e.a;if(0===o)return new Yd(i,0,0,s);if(0===r&&1===o)return new Yd(i,1,1,s);{let a=o*(2-r)/2;return new Yd(i,o*r/(1-Math.abs(2*a-1)),a,s)}}hsla2hsva(e){let i=Math.min(e.h,1),r=Math.min(e.s,1),o=Math.min(e.l,1),s=Math.min(e.a,1);if(0===o)return new f_(i,0,0,s);{let a=o+r*(1-Math.abs(2*o-1))/2;return new f_(i,2*(a-o)/a,a,s)}}hsvaToRgba(e){let i,r,o,s=e.h,a=e.s,l=e.v,c=e.a,d=Math.floor(6*s),u=6*s-d,p=l*(1-a),f=l*(1-u*a),m=l*(1-(1-u)*a);switch(d%6){case 0:i=l,r=m,o=p;break;case 1:i=f,r=l,o=p;break;case 2:i=p,r=l,o=m;break;case 3:i=p,r=f,o=l;break;case 4:i=m,r=p,o=l;break;case 5:i=l,r=p,o=f;break;default:i=0,r=0,o=0}return new tc(i,r,o,c)}cmykToRgb(e){return new tc((1-e.c)*(1-e.k),(1-e.m)*(1-e.k),(1-e.y)*(1-e.k),e.a)}rgbaToCmyk(e){let i=1-Math.max(e.r,e.g,e.b);return 1===i?new xm(0,0,0,1,e.a):new xm((1-e.r-i)/(1-i),(1-e.g-i)/(1-i),(1-e.b-i)/(1-i),i,e.a)}rgbaToHsva(e){let i,r,o=Math.min(e.r,1),s=Math.min(e.g,1),a=Math.min(e.b,1),l=Math.min(e.a,1),c=Math.max(o,s,a),d=Math.min(o,s,a),u=c,p=c-d;if(r=0===c?0:p/c,c===d)i=0;else{switch(c){case o:i=(s-a)/p+(s<a?6:0);break;case s:i=(a-o)/p+2;break;case a:i=(o-s)/p+4;break;default:i=0}i/=6}return new f_(i,r,u,l)}rgbaToHex(e,i){let r="#"+(16777216|e.r<<16|e.g<<8|e.b).toString(16).substr(1);return i&&(r+=(256|Math.round(255*e.a)).toString(16).substr(1)),r}normalizeCMYK(e){return new xm(e.c/100,e.m/100,e.y/100,e.k/100,e.a)}denormalizeCMYK(e){return new xm(Math.floor(100*e.c),Math.floor(100*e.m),Math.floor(100*e.y),Math.floor(100*e.k),e.a)}denormalizeRGBA(e){return new tc(Math.round(255*e.r),Math.round(255*e.g),Math.round(255*e.b),e.a)}stringToHsva(e="",i=!1){let r=null;e=(e||"").toLowerCase();let o=[{re:/(rgb)a?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*%?,\s*(\d{1,3})\s*%?(?:,\s*(\d+(?:\.\d+)?)\s*)?\)/,parse:function(s){return new tc(parseInt(s[2],10)/255,parseInt(s[3],10)/255,parseInt(s[4],10)/255,isNaN(parseFloat(s[5]))?1:parseFloat(s[5]))}},{re:/(hsl)a?\(\s*(\d{1,3})\s*,\s*(\d{1,3})%\s*,\s*(\d{1,3})%\s*(?:,\s*(\d+(?:\.\d+)?)\s*)?\)/,parse:function(s){return new Yd(parseInt(s[2],10)/360,parseInt(s[3],10)/100,parseInt(s[4],10)/100,isNaN(parseFloat(s[5]))?1:parseFloat(s[5]))}}];o.push(i?{re:/#([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})?$/,parse:function(s){return new tc(parseInt(s[1],16)/255,parseInt(s[2],16)/255,parseInt(s[3],16)/255,parseInt(s[4]||"FF",16)/255)}}:{re:/#([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})$/,parse:function(s){return new tc(parseInt(s[1],16)/255,parseInt(s[2],16)/255,parseInt(s[3],16)/255,1)}}),o.push({re:/#([a-fA-F0-9])([a-fA-F0-9])([a-fA-F0-9])$/,parse:function(s){return new tc(parseInt(s[1]+s[1],16)/255,parseInt(s[2]+s[2],16)/255,parseInt(s[3]+s[3],16)/255,1)}});for(let s in o)if(o.hasOwnProperty(s)){let a=o[s],l=a.re.exec(e),c=l&&a.parse(l);if(c)return c instanceof tc?r=this.rgbaToHsva(c):c instanceof Yd&&(r=this.hsla2hsva(c)),r}return r}outputFormat(e,i,r){switch("auto"===i&&(i=e.a<1?"rgba":"hex"),i){case"hsla":let o=this.hsva2hsla(e),s=new Yd(Math.round(360*o.h),Math.round(100*o.s),Math.round(100*o.l),Math.round(100*o.a)/100);return e.a<1||"always"===r?"hsla("+s.h+","+s.s+"%,"+s.l+"%,"+s.a+")":"hsl("+s.h+","+s.s+"%,"+s.l+"%)";case"rgba":let a=this.denormalizeRGBA(this.hsvaToRgba(e));return e.a<1||"always"===r?"rgba("+a.r+","+a.g+","+a.b+","+Math.round(100*a.a)/100+")":"rgb("+a.r+","+a.g+","+a.b+")";default:let l="always"===r||"forced"===r;return this.rgbaToHex(this.denormalizeRGBA(this.hsvaToRgba(e)),l)}}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),_ne=typeof window<"u"&&"ontouchstart"in window,JVe=(()=>{class n{constructor(e,i,r,o,s,a){this.ngZone=e,this.elRef=i,this.cdRef=r,this.document=o,this.platformId=s,this.service=a,this.isIE10=!1,this.dialogArrowSize=10,this.dialogArrowOffset=15,this.dialogInputFields=[Ho.HEX,Ho.RGBA,Ho.HSLA,Ho.CMYK],this.useRootViewContainer=!1,this.eyeDropperSupported=gw(this.platformId)&&"EyeDropper"in this.document.defaultView}handleEsc(e){this.show&&"popup"===this.cpDialogDisplay&&this.onCancelColor(e)}handleEnter(e){this.show&&"popup"===this.cpDialogDisplay&&this.onAcceptColor(e)}ngOnInit(){this.slider=new mA(0,0,0,0),this.sliderDimMax=new hA(this.hueSlider.nativeElement.offsetWidth||140,this.cpWidth,130,this.alphaSlider.nativeElement.offsetWidth||140),this.format=this.cpCmykEnabled?Ho.CMYK:"rgba"===this.cpOutputFormat?Ho.RGBA:"hsla"===this.cpOutputFormat?Ho.HSLA:Ho.HEX,this.listenerMouseDown=r=>{this.onMouseDown(r)},this.listenerResize=()=>{this.onResize()},this.openDialog(this.initialColor,!1)}ngOnDestroy(){this.closeDialog()}ngAfterViewInit(){230===this.cpWidth&&"inline"!==this.cpDialogDisplay||(this.sliderDimMax=new hA(this.hueSlider.nativeElement.offsetWidth||140,this.cpWidth,130,this.alphaSlider.nativeElement.offsetWidth||140),this.updateColorPicker(!1),this.cdRef.detectChanges())}openDialog(e,i=!0){this.service.setActive(this),this.width||(this.cpWidth=this.directiveElementRef.nativeElement.offsetWidth),this.height||(this.height=320),this.setInitialColor(e),this.setColorFromString(e,i),this.openColorPicker()}closeDialog(){this.closeColorPicker()}setupDialog(e,i,r,o,s,a,l,c,d,u,p,f,m,b,M,y,x,R,A,V,te,K,xe,Xe,De,D,re,ce,fe,be,ne,de,pe,je,Ce,Ne,lt,Mt){this.setInitialColor(r),this.setColorMode(c),this.isIE10=10===function(){let n="";typeof navigator<"u"&&(n=navigator.userAgent.toLowerCase());let t=n.indexOf("msie ");return t>0&&parseInt(n.substring(t+5,n.indexOf(".",t)),10)}(),this.directiveInstance=e,this.directiveElementRef=i,this.cpDisableInput=f,this.cpCmykEnabled=d,this.cpAlphaChannel=u,this.cpOutputFormat=p,this.cpDialogDisplay=a,this.cpIgnoredElements=m,this.cpSaveClickOutside=b,this.cpCloseClickOutside=M,this.useRootViewContainer=y,this.width=this.cpWidth=parseInt(o,10),this.height=this.cpHeight=parseInt(s,10),this.cpPosition=x,this.cpPositionOffset=parseInt(R,10),this.cpOKButton=D,this.cpOKButtonText=ce,this.cpOKButtonClass=re,this.cpCancelButton=fe,this.cpCancelButtonText=ne,this.cpCancelButtonClass=be,this.cpEyeDropper=Ne,this.fallbackColor=l||"#fff",this.setPresetConfig(V,te),this.cpPresetColorsClass=K,this.cpMaxPresetColorsLength=xe,this.cpPresetEmptyMessage=Xe,this.cpPresetEmptyMessageClass=De,this.cpAddColorButton=de,this.cpAddColorButtonText=je,this.cpAddColorButtonClass=pe,this.cpRemoveColorButtonClass=Ce,this.cpTriggerElement=lt,this.cpExtraTemplate=Mt,A||(this.dialogArrowOffset=0),"inline"===a&&(this.dialogArrowSize=0,this.dialogArrowOffset=0),"hex"===p&&"always"!==u&&"forced"!==u&&(this.cpAlphaChannel="disabled")}setColorMode(e){switch(e.toString().toUpperCase()){case"1":case"C":case"COLOR":default:this.cpColorMode=1;break;case"2":case"G":case"GRAYSCALE":this.cpColorMode=2;break;case"3":case"P":case"PRESETS":this.cpColorMode=3}}setInitialColor(e){this.initialColor=e}setPresetConfig(e,i){this.cpPresetLabel=e,this.cpPresetColors=i}setColorFromString(e,i=!0,r=!0){let o;"always"===this.cpAlphaChannel||"forced"===this.cpAlphaChannel?(o=this.service.stringToHsva(e,!0),!o&&!this.hsva&&(o=this.service.stringToHsva(e,!1))):o=this.service.stringToHsva(e,!1),!o&&!this.hsva&&(o=this.service.stringToHsva(this.fallbackColor,!1)),o&&(this.hsva=o,this.sliderH=this.hsva.h,"hex"===this.cpOutputFormat&&"disabled"===this.cpAlphaChannel&&(this.hsva.a=1),this.updateColorPicker(i,r))}onResize(){"fixed"===this.position?this.setDialogPosition():"inline"!==this.cpDialogDisplay&&this.closeColorPicker()}onDragEnd(e){this.directiveInstance.sliderDragEnd({slider:e,color:this.outputColor})}onDragStart(e){this.directiveInstance.sliderDragStart({slider:e,color:this.outputColor})}onMouseDown(e){this.show&&!this.isIE10&&"popup"===this.cpDialogDisplay&&e.target!==this.directiveElementRef.nativeElement&&!this.isDescendant(this.elRef.nativeElement,e.target)&&!this.isDescendant(this.directiveElementRef.nativeElement,e.target)&&0===this.cpIgnoredElements.filter(i=>i===e.target).length&&this.ngZone.run(()=>{this.cpSaveClickOutside?this.directiveInstance.colorSelected(this.outputColor):(this.hsva=null,this.setColorFromString(this.initialColor,!1),this.cpCmykEnabled&&this.directiveInstance.cmykChanged(this.cmykColor),this.directiveInstance.colorChanged(this.initialColor),this.directiveInstance.colorCanceled()),this.cpCloseClickOutside&&this.closeColorPicker()})}onAcceptColor(e){e.stopPropagation(),this.outputColor&&this.directiveInstance.colorSelected(this.outputColor),"popup"===this.cpDialogDisplay&&this.closeColorPicker()}onCancelColor(e){this.hsva=null,e.stopPropagation(),this.directiveInstance.colorCanceled(),this.setColorFromString(this.initialColor,!0),"popup"===this.cpDialogDisplay&&(this.cpCmykEnabled&&this.directiveInstance.cmykChanged(this.cmykColor),this.directiveInstance.colorChanged(this.initialColor,!0),this.closeColorPicker())}onEyeDropper(){this.eyeDropperSupported&&(new window.EyeDropper).open().then(i=>{this.setColorFromString(i.sRGBHex,!0)})}onFormatToggle(e){let i=this.dialogInputFields.length-(this.cpCmykEnabled?0:1),r=((this.dialogInputFields.indexOf(this.format)+e)%i+i)%i;this.format=this.dialogInputFields[r]}onColorChange(e){this.hsva.s=e.s/e.rgX,this.hsva.v=e.v/e.rgY,this.updateColorPicker(),this.directiveInstance.sliderChanged({slider:"lightness",value:this.hsva.v,color:this.outputColor}),this.directiveInstance.sliderChanged({slider:"saturation",value:this.hsva.s,color:this.outputColor})}onHueChange(e){this.hsva.h=e.v/e.rgX,this.sliderH=this.hsva.h,this.updateColorPicker(),this.directiveInstance.sliderChanged({slider:"hue",value:this.hsva.h,color:this.outputColor})}onValueChange(e){this.hsva.v=e.v/e.rgX,this.updateColorPicker(),this.directiveInstance.sliderChanged({slider:"value",value:this.hsva.v,color:this.outputColor})}onAlphaChange(e){this.hsva.a=e.v/e.rgX,this.updateColorPicker(),this.directiveInstance.sliderChanged({slider:"alpha",value:this.hsva.a,color:this.outputColor})}onHexInput(e){if(null===e)this.updateColorPicker();else{e&&"#"!==e[0]&&(e="#"+e);let i=/^#([a-f0-9]{3}|[a-f0-9]{6})$/gi;"always"===this.cpAlphaChannel&&(i=/^#([a-f0-9]{3}|[a-f0-9]{6}|[a-f0-9]{8})$/gi);let r=i.test(e);r&&(e.length<5&&(e="#"+e.substring(1).split("").map(o=>o+o).join("")),"forced"===this.cpAlphaChannel&&(e+=Math.round(255*this.hsva.a).toString(16)),this.setColorFromString(e,!0,!1)),this.directiveInstance.inputChanged({input:"hex",valid:r,value:e,color:this.outputColor})}}onRedInput(e){let i=this.service.hsvaToRgba(this.hsva),r=!isNaN(e.v)&&e.v>=0&&e.v<=e.rg;r&&(i.r=e.v/e.rg,this.hsva=this.service.rgbaToHsva(i),this.sliderH=this.hsva.h,this.updateColorPicker()),this.directiveInstance.inputChanged({input:"red",valid:r,value:i.r,color:this.outputColor})}onBlueInput(e){let i=this.service.hsvaToRgba(this.hsva),r=!isNaN(e.v)&&e.v>=0&&e.v<=e.rg;r&&(i.b=e.v/e.rg,this.hsva=this.service.rgbaToHsva(i),this.sliderH=this.hsva.h,this.updateColorPicker()),this.directiveInstance.inputChanged({input:"blue",valid:r,value:i.b,color:this.outputColor})}onGreenInput(e){let i=this.service.hsvaToRgba(this.hsva),r=!isNaN(e.v)&&e.v>=0&&e.v<=e.rg;r&&(i.g=e.v/e.rg,this.hsva=this.service.rgbaToHsva(i),this.sliderH=this.hsva.h,this.updateColorPicker()),this.directiveInstance.inputChanged({input:"green",valid:r,value:i.g,color:this.outputColor})}onHueInput(e){let i=!isNaN(e.v)&&e.v>=0&&e.v<=e.rg;i&&(this.hsva.h=e.v/e.rg,this.sliderH=this.hsva.h,this.updateColorPicker()),this.directiveInstance.inputChanged({input:"hue",valid:i,value:this.hsva.h,color:this.outputColor})}onValueInput(e){let i=!isNaN(e.v)&&e.v>=0&&e.v<=e.rg;i&&(this.hsva.v=e.v/e.rg,this.updateColorPicker()),this.directiveInstance.inputChanged({input:"value",valid:i,value:this.hsva.v,color:this.outputColor})}onAlphaInput(e){let i=!isNaN(e.v)&&e.v>=0&&e.v<=e.rg;i&&(this.hsva.a=e.v/e.rg,this.updateColorPicker()),this.directiveInstance.inputChanged({input:"alpha",valid:i,value:this.hsva.a,color:this.outputColor})}onLightnessInput(e){let i=this.service.hsva2hsla(this.hsva),r=!isNaN(e.v)&&e.v>=0&&e.v<=e.rg;r&&(i.l=e.v/e.rg,this.hsva=this.service.hsla2hsva(i),this.sliderH=this.hsva.h,this.updateColorPicker()),this.directiveInstance.inputChanged({input:"lightness",valid:r,value:i.l,color:this.outputColor})}onSaturationInput(e){let i=this.service.hsva2hsla(this.hsva),r=!isNaN(e.v)&&e.v>=0&&e.v<=e.rg;r&&(i.s=e.v/e.rg,this.hsva=this.service.hsla2hsva(i),this.sliderH=this.hsva.h,this.updateColorPicker()),this.directiveInstance.inputChanged({input:"saturation",valid:r,value:i.s,color:this.outputColor})}onCyanInput(e){!isNaN(e.v)&&e.v>=0&&e.v<=e.rg&&(this.cmyk.c=e.v,this.updateColorPicker(!1,!0,!0)),this.directiveInstance.inputChanged({input:"cyan",valid:!0,value:this.cmyk.c,color:this.outputColor})}onMagentaInput(e){!isNaN(e.v)&&e.v>=0&&e.v<=e.rg&&(this.cmyk.m=e.v,this.updateColorPicker(!1,!0,!0)),this.directiveInstance.inputChanged({input:"magenta",valid:!0,value:this.cmyk.m,color:this.outputColor})}onYellowInput(e){!isNaN(e.v)&&e.v>=0&&e.v<=e.rg&&(this.cmyk.y=e.v,this.updateColorPicker(!1,!0,!0)),this.directiveInstance.inputChanged({input:"yellow",valid:!0,value:this.cmyk.y,color:this.outputColor})}onBlackInput(e){!isNaN(e.v)&&e.v>=0&&e.v<=e.rg&&(this.cmyk.k=e.v,this.updateColorPicker(!1,!0,!0)),this.directiveInstance.inputChanged({input:"black",valid:!0,value:this.cmyk.k,color:this.outputColor})}onAddPresetColor(e,i){e.stopPropagation(),this.cpPresetColors.filter(r=>r===i).length||(this.cpPresetColors=this.cpPresetColors.concat(i),this.directiveInstance.presetColorsChanged(this.cpPresetColors))}onRemovePresetColor(e,i){e.stopPropagation(),this.cpPresetColors=this.cpPresetColors.filter(r=>r!==i),this.directiveInstance.presetColorsChanged(this.cpPresetColors)}openColorPicker(){this.show||(this.show=!0,this.hidden=!0,setTimeout(()=>{this.hidden=!1,this.setDialogPosition(),this.cdRef.detectChanges()},0),this.directiveInstance.stateChanged(!0),this.isIE10||this.ngZone.runOutsideAngular(()=>{_ne?document.addEventListener("touchstart",this.listenerMouseDown):document.addEventListener("mousedown",this.listenerMouseDown)}),window.addEventListener("resize",this.listenerResize))}closeColorPicker(){this.show&&(this.show=!1,this.directiveInstance.stateChanged(!1),this.isIE10||(_ne?document.removeEventListener("touchstart",this.listenerMouseDown):document.removeEventListener("mousedown",this.listenerMouseDown)),window.removeEventListener("resize",this.listenerResize),this.cdRef.destroyed||this.cdRef.detectChanges())}updateColorPicker(e=!0,i=!0,r=!1){if(this.sliderDimMax){2===this.cpColorMode&&(this.hsva.s=0);let o,s,a,l=this.outputColor;if(s=this.service.hsva2hsla(this.hsva),this.cpCmykEnabled?(r?(a=this.service.cmykToRgb(this.service.normalizeCMYK(this.cmyk)),this.hsva=this.service.rgbaToHsva(a)):(a=this.service.hsvaToRgba(this.hsva),this.cmyk=this.service.denormalizeCMYK(this.service.rgbaToCmyk(a))),a=this.service.denormalizeRGBA(a),this.sliderH=this.hsva.h):a=this.service.denormalizeRGBA(this.service.hsvaToRgba(this.hsva)),o=this.service.denormalizeRGBA(this.service.hsvaToRgba(new f_(this.sliderH||this.hsva.h,1,1,1))),i&&(this.hslaText=new Yd(Math.round(360*s.h),Math.round(100*s.s),Math.round(100*s.l),Math.round(100*s.a)/100),this.rgbaText=new tc(a.r,a.g,a.b,Math.round(100*a.a)/100),this.cpCmykEnabled&&(this.cmykText=new xm(this.cmyk.c,this.cmyk.m,this.cmyk.y,this.cmyk.k,Math.round(100*this.cmyk.a)/100)),this.hexText=this.service.rgbaToHex(a,"always"===this.cpAlphaChannel),this.hexAlpha=this.rgbaText.a),"auto"===this.cpOutputFormat&&this.format!==Ho.RGBA&&this.format!==Ho.CMYK&&this.format!==Ho.HSLA&&this.hsva.a<1&&(this.format=this.hsva.a<1?Ho.RGBA:Ho.HEX),this.hueSliderColor="rgb("+o.r+","+o.g+","+o.b+")",this.alphaSliderColor="rgb("+a.r+","+a.g+","+a.b+")",this.outputColor=this.service.outputFormat(this.hsva,this.cpOutputFormat,this.cpAlphaChannel),this.selectedColor=this.service.outputFormat(this.hsva,"rgba",null),this.format!==Ho.CMYK)this.cmykColor="";else if("always"===this.cpAlphaChannel||"enabled"===this.cpAlphaChannel||"forced"===this.cpAlphaChannel){let c=Math.round(100*this.cmyk.a)/100;this.cmykColor=`cmyka(${this.cmyk.c},${this.cmyk.m},${this.cmyk.y},${this.cmyk.k},${c})`}else this.cmykColor=`cmyk(${this.cmyk.c},${this.cmyk.m},${this.cmyk.y},${this.cmyk.k})`;this.slider=new mA((this.sliderH||this.hsva.h)*this.sliderDimMax.h-8,this.hsva.s*this.sliderDimMax.s-8,(1-this.hsva.v)*this.sliderDimMax.v-8,this.hsva.a*this.sliderDimMax.a-8),e&&l!==this.outputColor&&(this.cpCmykEnabled&&this.directiveInstance.cmykChanged(this.cmykColor),this.directiveInstance.colorChanged(this.outputColor))}}setDialogPosition(){if("inline"===this.cpDialogDisplay)this.position="relative";else{let r,e="static",i="",o=null,s=null,a=this.directiveElementRef.nativeElement.parentNode,l=this.dialogElement.nativeElement.offsetHeight;for(;null!==a&&"HTML"!==a.tagName;){if(r=window.getComputedStyle(a),e=r.getPropertyValue("position"),i=r.getPropertyValue("transform"),"static"!==e&&null===o&&(o=a),i&&"none"!==i&&null===s&&(s=a),"fixed"===e){o=s;break}a=a.parentNode}let c=this.createDialogBox(this.directiveElementRef.nativeElement,"fixed"!==e);if(this.useRootViewContainer||"fixed"===e&&(!o||o instanceof HTMLUnknownElement))this.top=c.top,this.left=c.left;else{null===o&&(o=a);let u=this.createDialogBox(o,"fixed"!==e);this.top=c.top-u.top,this.left=c.left-u.left}"fixed"===e&&(this.position="fixed");let d=this.cpPosition;"auto"===this.cpPosition&&(d=function(n,t){let e="right",i="bottom",{height:r,width:o}=n,{top:s,left:a}=t,l=s+t.height,c=a+t.width,d=s-r<0,u=l+r>(window.innerHeight||document.documentElement.clientHeight),p=a-o<0,f=c+o>(window.innerWidth||document.documentElement.clientWidth);return u&&(i="top"),d&&(i="bottom"),p&&(e="right"),f&&(e="left"),d&&u&&p&&f?["left","right","top","bottom"].reduce((M,y)=>n[M]>n[y]?M:y):p&&f?d?"bottom":u||s>l?"top":"bottom":d&&u?p?"right":f||a>c?"left":"right":`${i}-${e}`}(this.dialogElement.nativeElement.getBoundingClientRect(),this.cpTriggerElement.nativeElement.getBoundingClientRect())),"top"===d?(this.arrowTop=l-1,this.top-=l+this.dialogArrowSize,this.left+=this.cpPositionOffset/100*c.width-this.dialogArrowOffset):"bottom"===d?(this.top+=c.height+this.dialogArrowSize,this.left+=this.cpPositionOffset/100*c.width-this.dialogArrowOffset):"top-left"===d||"left-top"===d?(this.top-=l-c.height+c.height*this.cpPositionOffset/100,this.left-=this.cpWidth+this.dialogArrowSize-2-this.dialogArrowOffset):"top-right"===d||"right-top"===d?(this.top-=l-c.height+c.height*this.cpPositionOffset/100,this.left+=c.width+this.dialogArrowSize-2-this.dialogArrowOffset):"left"===d||"bottom-left"===d||"left-bottom"===d?(this.top+=c.height*this.cpPositionOffset/100-this.dialogArrowOffset,this.left-=this.cpWidth+this.dialogArrowSize-2):(this.top+=c.height*this.cpPositionOffset/100-this.dialogArrowOffset,this.left+=c.width+this.dialogArrowSize-2),this.cpUsePosition=d}}isDescendant(e,i){let r=i.parentNode;for(;null!==r;){if(r===e)return!0;r=r.parentNode}return!1}createDialogBox(e,i){let{top:r,left:o}=e.getBoundingClientRect();return{top:r+(i?window.pageYOffset:0),left:o+(i?window.pageXOffset:0),width:e.offsetWidth,height:e.offsetHeight}}}return n.\u0275fac=function(e){return new(e||n)(C(at),C(Me),C($t),C(Lt),C(vc),C(EV))},n.\u0275cmp=O({type:n,selectors:[["color-picker"]],viewQuery:function(e,i){if(1&e&&(Ge(hVe,7),Ge(gVe,7),Ge(_Ve,7)),2&e){let r;Se(r=Ee())&&(i.dialogElement=r.first),Se(r=Ee())&&(i.hueSlider=r.first),Se(r=Ee())&&(i.alphaSlider=r.first)}},hostBindings:function(e,i){1&e&&I("keyup.esc",function(o){return i.handleEsc(o)},0,hc)("keyup.enter",function(o){return i.handleEnter(o)},!1,hc)},decls:30,vars:51,consts:[[1,"color-picker",3,"click"],["dialogPopup",""],[3,"class","top",4,"ngIf"],["class","saturation-lightness",3,"slider","rgX","rgY","background-color","newValue","dragStart","dragEnd",4,"ngIf"],[1,"hue-alpha","box"],[1,"left"],[1,"selected-color-background"],[1,"selected-color",3,"click"],["class","eyedropper-icon","xmlns","http://www.w3.org/2000/svg","height","24px","viewBox","0 0 24 24","width","24px","fill","#000000",4,"ngIf"],["type","button",3,"class","disabled","click",4,"ngIf"],[1,"right"],["style","height: 16px;",4,"ngIf"],[1,"hue",3,"slider","rgX","newValue","dragStart","dragEnd"],["hueSlider",""],[1,"cursor"],[1,"value",3,"slider","rgX","newValue","dragStart","dragEnd"],["valueSlider",""],[1,"alpha",3,"slider","rgX","newValue","dragStart","dragEnd"],["alphaSlider",""],["class","cmyk-text",3,"display",4,"ngIf"],["class","hsla-text",3,"display",4,"ngIf"],["class","rgba-text",3,"display",4,"ngIf"],["class","hex-text",3,"hex-alpha","display",4,"ngIf"],["class","value-text",4,"ngIf"],["class","type-policy",4,"ngIf"],["class","preset-area",4,"ngIf"],["class","button-area",4,"ngIf"],["class","extra-template",4,"ngIf"],[1,"saturation-lightness",3,"slider","rgX","rgY","newValue","dragStart","dragEnd"],["xmlns","http://www.w3.org/2000/svg","height","24px","viewBox","0 0 24 24","width","24px","fill","#000000",1,"eyedropper-icon"],["d","M0 0h24v24H0V0z","fill","none"],["d","M17.66 5.41l.92.92-2.69 2.69-.92-.92 2.69-2.69M17.67 3c-.26 0-.51.1-.71.29l-3.12 3.12-1.93-1.91-1.41 1.41 1.42 1.42L3 16.25V21h4.75l8.92-8.92 1.42 1.42 1.41-1.41-1.92-1.92 3.12-3.12c.4-.4.4-1.03.01-1.42l-2.34-2.34c-.2-.19-.45-.29-.7-.29zM6.92 19L5 17.08l8.06-8.06 1.92 1.92L6.92 19z"],["type","button",3,"disabled","click"],[2,"height","16px"],[1,"cmyk-text"],[1,"box"],["type","number","pattern","[0-9]*","min","0","max","100",3,"text","rg","value","keyup.enter","newValue"],["type","number","pattern","[0-9]+([\\.,][0-9]{1,2})?","min","0","max","1","step","0.1",3,"text","rg","value","keyup.enter","newValue",4,"ngIf"],[4,"ngIf"],["type","number","pattern","[0-9]+([\\.,][0-9]{1,2})?","min","0","max","1","step","0.1",3,"text","rg","value","keyup.enter","newValue"],[1,"hsla-text"],["type","number","pattern","[0-9]*","min","0","max","360",3,"text","rg","value","keyup.enter","newValue"],[1,"rgba-text"],["type","number","pattern","[0-9]*","min","0","max","255",3,"text","rg","value","keyup.enter","newValue"],[1,"hex-text"],[3,"text","value","blur","keyup.enter","newValue"],[1,"value-text"],[1,"type-policy"],[1,"type-policy-arrow",3,"click"],[1,"preset-area"],[1,"preset-label"],[3,"class",4,"ngIf"],["class","preset-color",3,"backgroundColor","click",4,"ngFor","ngForOf"],[1,"preset-color",3,"click"],[3,"class","click",4,"ngIf"],[3,"click"],[1,"button-area"],["type","button",3,"class","click",4,"ngIf"],["type","button",3,"click"],[1,"extra-template"],[4,"ngTemplateOutlet"]],template:function(e,i){1&e&&(h(0,"div",0,1),I("click",function(o){return o.stopPropagation()}),S(2,bVe,1,5,"div",2),S(3,vVe,2,8,"div",3),h(4,"div",4)(5,"div",5),P(6,"div",6),h(7,"div",7),I("click",function(){return i.eyeDropperSupported&&i.cpEyeDropper&&i.onEyeDropper()}),S(8,yVe,3,0,"svg",8),g(),S(9,xVe,2,5,"button",9),g(),h(10,"div",10),S(11,CVe,1,0,"div",11),h(12,"div",12,13),I("newValue",function(o){return i.onHueChange(o)})("dragStart",function(){return i.onDragStart("hue")})("dragEnd",function(){return i.onDragEnd("hue")}),P(14,"div",14),g(),h(15,"div",15,16),I("newValue",function(o){return i.onValueChange(o)})("dragStart",function(){return i.onDragStart("value")})("dragEnd",function(){return i.onDragEnd("value")}),P(17,"div",14),g(),h(18,"div",17,18),I("newValue",function(o){return i.onAlphaChange(o)})("dragStart",function(){return i.onDragStart("alpha")})("dragEnd",function(){return i.onDragEnd("alpha")}),P(20,"div",14),g()()(),S(21,SVe,17,12,"div",19),S(22,DVe,14,10,"div",20),S(23,RVe,14,10,"div",21),S(24,kVe,8,7,"div",22),S(25,NVe,9,3,"div",23),S(26,LVe,3,0,"div",24),S(27,UVe,6,3,"div",25),S(28,WVe,3,2,"div",26),S(29,YVe,2,1,"div",27),g()),2&e&&(Tt("display",i.show?"block":"none")("visibility",i.hidden?"hidden":"visible")("top",i.top,"px")("left",i.left,"px")("position",i.position)("height",i.cpHeight,"px")("width",i.cpWidth,"px"),nt("open",i.show),v(2),_("ngIf","popup"===i.cpDialogDisplay),v(1),_("ngIf",1===(i.cpColorMode||1)),v(4),Tt("background-color",i.selectedColor)("cursor",i.eyeDropperSupported&&i.cpEyeDropper?"pointer":null),v(1),_("ngIf",i.eyeDropperSupported&&i.cpEyeDropper),v(1),_("ngIf",i.cpAddColorButton),v(2),_("ngIf","disabled"===i.cpAlphaChannel),v(1),Tt("display",1===(i.cpColorMode||1)?"block":"none"),_("rgX",1),v(2),Tt("left",null==i.slider?null:i.slider.h,"px"),v(1),Tt("display",2===(i.cpColorMode||1)?"block":"none"),_("rgX",1),v(2),Tt("right",null==i.slider?null:i.slider.v,"px"),v(1),Tt("display","disabled"===i.cpAlphaChannel?"none":"block")("background-color",i.alphaSliderColor),_("rgX",1),v(2),Tt("left",null==i.slider?null:i.slider.a,"px"),v(1),_("ngIf",!i.cpDisableInput&&1===(i.cpColorMode||1)),v(1),_("ngIf",!i.cpDisableInput&&1===(i.cpColorMode||1)),v(1),_("ngIf",!i.cpDisableInput&&1===(i.cpColorMode||1)),v(1),_("ngIf",!i.cpDisableInput&&1===(i.cpColorMode||1)),v(1),_("ngIf",!i.cpDisableInput&&2===(i.cpColorMode||1)),v(1),_("ngIf",!i.cpDisableInput&&1===(i.cpColorMode||1)),v(1),_("ngIf",(null==i.cpPresetColors?null:i.cpPresetColors.length)||i.cpAddColorButton),v(1),_("ngIf",i.cpOKButton||i.cpCancelButton),v(1),_("ngIf",i.cpExtraTemplate))},dependencies:[nn,Fe,Lr,ZVe,KVe],styles:['.color-picker{position:absolute;z-index:1000;width:230px;height:auto;border:#777 solid 1px;cursor:default;-webkit-user-select:none;user-select:none;background-color:#fff}.color-picker *{box-sizing:border-box;margin:0;font-size:11px}.color-picker input{width:0;height:26px;min-width:0;font-size:13px;text-align:center;color:#000}.color-picker input:invalid,.color-picker input:-moz-ui-invalid,.color-picker input:-moz-submit-invalid{box-shadow:none}.color-picker input::-webkit-inner-spin-button,.color-picker input::-webkit-outer-spin-button{margin:0;-webkit-appearance:none}.color-picker .arrow{position:absolute;z-index:999999;width:0;height:0;border-style:solid}.color-picker .arrow.arrow-top{left:8px;border-width:10px 5px;border-color:#777 rgba(0,0,0,0) rgba(0,0,0,0) rgba(0,0,0,0)}.color-picker .arrow.arrow-bottom{top:-20px;left:8px;border-width:10px 5px;border-color:rgba(0,0,0,0) rgba(0,0,0,0) #777 rgba(0,0,0,0)}.color-picker .arrow.arrow-top-left,.color-picker .arrow.arrow-left-top{right:-21px;bottom:8px;border-width:5px 10px;border-color:rgba(0,0,0,0) rgba(0,0,0,0) rgba(0,0,0,0) #777}.color-picker .arrow.arrow-top-right,.color-picker .arrow.arrow-right-top{bottom:8px;left:-20px;border-width:5px 10px;border-color:rgba(0,0,0,0) #777 rgba(0,0,0,0) rgba(0,0,0,0)}.color-picker .arrow.arrow-left,.color-picker .arrow.arrow-left-bottom,.color-picker .arrow.arrow-bottom-left{top:8px;right:-21px;border-width:5px 10px;border-color:rgba(0,0,0,0) rgba(0,0,0,0) rgba(0,0,0,0) #777}.color-picker .arrow.arrow-right,.color-picker .arrow.arrow-right-bottom,.color-picker .arrow.arrow-bottom-right{top:8px;left:-20px;border-width:5px 10px;border-color:rgba(0,0,0,0) #777 rgba(0,0,0,0) rgba(0,0,0,0)}.color-picker .cursor{position:relative;width:16px;height:16px;border:#222 solid 2px;border-radius:50%;cursor:default}.color-picker .box{display:flex;padding:4px 8px}.color-picker .left{position:relative;padding:16px 8px}.color-picker .right{flex:1 1 auto;padding:12px 8px}.color-picker .button-area{padding:0 16px 16px;text-align:right}.color-picker .button-area button{margin-left:8px}.color-picker .preset-area{padding:4px 15px}.color-picker .preset-area .preset-label{overflow:hidden;width:100%;padding:4px;font-size:11px;white-space:nowrap;text-align:left;text-overflow:ellipsis;color:#555}.color-picker .preset-area .preset-color{position:relative;display:inline-block;width:18px;height:18px;margin:4px 6px 8px;border:#a9a9a9 solid 1px;border-radius:25%;cursor:pointer}.color-picker .preset-area .preset-empty-message{min-height:18px;margin-top:4px;margin-bottom:8px;font-style:italic;text-align:center}.color-picker .hex-text{width:100%;padding:4px 8px;font-size:11px}.color-picker .hex-text .box{padding:0 24px 8px 8px}.color-picker .hex-text .box div{float:left;flex:1 1 auto;text-align:center;color:#555;clear:left}.color-picker .hex-text .box input{flex:1 1 auto;padding:1px;border:#a9a9a9 solid 1px}.color-picker .hex-alpha .box div:first-child,.color-picker .hex-alpha .box input:first-child{flex-grow:3;margin-right:8px}.color-picker .cmyk-text,.color-picker .hsla-text,.color-picker .rgba-text,.color-picker .value-text{width:100%;padding:4px 8px;font-size:11px}.color-picker .cmyk-text .box,.color-picker .hsla-text .box,.color-picker .rgba-text .box{padding:0 24px 8px 8px}.color-picker .value-text .box{padding:0 8px 8px}.color-picker .cmyk-text .box div,.color-picker .hsla-text .box div,.color-picker .rgba-text .box div,.color-picker .value-text .box div{flex:1 1 auto;margin-right:8px;text-align:center;color:#555}.color-picker .cmyk-text .box div:last-child,.color-picker .hsla-text .box div:last-child,.color-picker .rgba-text .box div:last-child,.color-picker .value-text .box div:last-child{margin-right:0}.color-picker .cmyk-text .box input,.color-picker .hsla-text .box input,.color-picker .rgba-text .box input,.color-picker .value-text .box input{float:left;flex:1;padding:1px;margin:0 8px 0 0;border:#a9a9a9 solid 1px}.color-picker .cmyk-text .box input:last-child,.color-picker .hsla-text .box input:last-child,.color-picker .rgba-text .box input:last-child,.color-picker .value-text .box input:last-child{margin-right:0}.color-picker .hue-alpha{align-items:center;margin-bottom:3px}.color-picker .hue{direction:ltr;width:100%;height:16px;margin-bottom:16px;border:none;cursor:pointer;background-size:100% 100%;background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAJYAAAAQCAYAAAD06IYnAAAABmJLR0QA/wD/AP+gvaeTAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAB3RJTUUH4AIWDwkUFWbCCAAAAFxJREFUaN7t0kEKg0AQAME2x83/n2qu5qCgD1iDhCoYdpnbQC9bbY1qVO/jvc6k3ad91s7/7F1/csgPrujuQ17BDYSFsBAWwgJhISyEBcJCWAgLhIWwEBYIi2f7Ar/1TCgFH2X9AAAAAElFTkSuQmCC)}.color-picker .value{direction:rtl;width:100%;height:16px;margin-bottom:16px;border:none;cursor:pointer;background-size:100% 100%;background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAJYAAAAQCAYAAAD06IYnAAACTklEQVR42u3SYUcrABhA4U2SkmRJMmWSJklKJiWZZpKUJJskKUmaTFImKZOUzMySpGRmliRNJilJSpKSJEtmSpIpmWmSdO736/6D+x7OP3gUCoWCv1cqlSQlJZGcnExKSgqpqamkpaWRnp5ORkYGmZmZqFQqsrKyyM7OJicnh9zcXNRqNXl5eeTn56PRaCgoKKCwsJCioiK0Wi3FxcWUlJRQWlpKWVkZ5eXlVFRUUFlZiU6no6qqiurqampqaqitraWurg69Xk99fT0GgwGj0UhDQwONjY00NTXR3NxMS0sLra2ttLW10d7ejslkwmw209HRQWdnJ11dXXR3d9PT00Nvby99fX309/czMDDA4OAgFouFoaEhrFYrw8PDjIyMMDo6ytjYGDabjfHxcSYmJpicnGRqagq73c709DQzMzPMzs4yNzfH/Pw8DocDp9OJy+XC7XazsLDA4uIiS0tLLC8vs7KywurqKmtra3g8HrxeLz6fD7/fz/r6OhsbG2xubrK1tcX29jaBQICdnR2CwSC7u7vs7e2xv7/PwcEBh4eHHB0dcXx8zMnJCaenp5ydnXF+fs7FxQWXl5dcXV1xfX3Nzc0Nt7e33N3dEQqFuL+/5+HhgXA4TCQS4fHxkaenJ56fn3l5eeH19ZVoNMrb2xvv7+98fHwQi8WIx+N8fn6SSCT4+vri+/ubn58ffn9/+VcKgSWwBJbAElgCS2AJLIElsASWwBJYAktgCSyBJbAElsASWAJLYAksgSWwBJbAElgCS2AJLIElsP4/WH8AmJ5Z6jHS4h8AAAAASUVORK5CYII=)}.color-picker .alpha{direction:ltr;width:100%;height:16px;border:none;cursor:pointer;background-size:100% 100%;background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAJYAAAAQCAYAAAD06IYnAAAABmJLR0QA/wD/AP+gvaeTAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAB3RJTUUH4AIWDwYQlZMa3gAAAWVJREFUaN7tmEGO6jAQRCsOArHgBpyAJYGjcGocxAm4A2IHpmoWE0eBH+ezmFlNvU06shJ3W6VEelWMUQAIIF9f6qZpimsA1LYtS2uF51/u27YVAFZVRUkEoGHdPV/sIcbIEIIkUdI/9Xa7neyv61+SWFUVAVCSct00TWn2fv6u3+Ecfd3tXzy/0+nEUu+SPjo/kqzrmiQpScN6v98XewfA8/lMkiLJ2WxGSUopcT6fM6U0NX9/frfbjev1WtfrlZfLhYfDQQHG/AIOlnGwjINlHCxjHCzjYJm/TJWdCwquJXseFFzGwDNNeiKMOJTO8xQdDQaeB29+K9efeLaBo9J7vdvtJj1RjFFjfiv7qv95tjx/7leSQgh93e1ffMeIp6O+YQjho/N791t1XVOSSI7N//K+4/GoxWLBx+PB5/Op5XLJ+/3OlJJWqxU3m83ovv5iGf8KjYNlHCxjHCzjYBkHy5gf5gusvQU7U37jTAAAAABJRU5ErkJggg==)}.color-picker .type-policy{position:absolute;top:218px;right:12px;width:16px;height:24px;background-size:8px 16px;background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABIAAAAgCAYAAAAffCjxAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAACewAAAnsB01CO3AAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAAAIASURBVEiJ7ZY9axRRFIafsxMStrLQJpAgpBFhi+C9w1YSo00I6RZ/g9vZpBf/QOr4GyRgkSKNSrAadsZqQGwCkuAWyRZJsySwvhZ7N/vhzrgbLH3Ld8597jlzz50zJokyxXH8DqDVar0qi6v8BbItqSGpEcfxdlmsFWXkvX8AfAVWg3UKPEnT9GKujMzsAFgZsVaCN1VTQd77XUnrgE1kv+6935268WRpzrnHZvYRWC7YvC3pRZZl3wozqtVqiyH9IgjAspkd1Gq1xUJQtVrdB9ZKIAOthdg/Qc65LUk7wNIMoCVJO865rYFhkqjX6/d7vV4GPJwBMqofURS5JEk6FYBer/eeYb/Mo9WwFnPOvQbeAvfuAAK4BN4sAJtAG/gJIElmNuiJyba3EGNmZiPeZuEVmVell/Y/6N+CzDn3AXhEOOo7Hv/3BeAz8IzQkMPnJbuPx1wC+yYJ7/0nYIP5S/0FHKdp+rwCEEXRS/rf5Hl1Gtb2M0iSpCOpCZzPATmX1EySpHMLAsiy7MjMDoHrGSDXZnaYZdnRwBh7J91utwmczAA6CbG3GgPleX4jqUH/a1CktqRGnuc3hSCAMB32gKspkCtgb3KCQMmkjeP4WNJThrNNZval1WptTIsv7JtQ4tmIdRa8qSoEpWl6YWZNoAN0zKxZNPehpLSBZv2t+Q0CJ9lLnARQLAAAAABJRU5ErkJggg==);background-repeat:no-repeat;background-position:center}.color-picker .type-policy .type-policy-arrow{display:block;width:100%;height:50%}.color-picker .selected-color{position:absolute;top:16px;left:8px;width:40px;height:40px;border:1px solid #a9a9a9;border-radius:50%}.color-picker .selected-color-background{width:40px;height:40px;border-radius:50%;background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAoCAYAAACM/rhtAAAAh0lEQVRYR+2W0QlAMQgD60zdfwOdqa8TmI/wQMr5K0I5bZLIzLOa2nt37VVVbd+dDx5obgCC3KBLwJ2ff4PnVidkf+ucIhw80HQaCLo3DMH3CRK3iFsmAWVl6hPNDwt8EvNE5q+YuEXcMgkonVM6SdyCoEvAnZ8v1Hjx817MilmxSUB5rdLJDycZgUAZUch/AAAAAElFTkSuQmCC)}.color-picker .saturation-lightness{direction:ltr;width:100%;height:130px;border:none;cursor:pointer;touch-action:manipulation;background-size:100% 100%;background-image:url(data:image/png;base64,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)}.color-picker .cp-add-color-button-class{position:absolute;display:inline;padding:0;margin:3px -3px;border:0;cursor:pointer;background:transparent}.color-picker .cp-add-color-button-class:hover{text-decoration:underline}.color-picker .cp-add-color-button-class:disabled{cursor:not-allowed;color:#999}.color-picker .cp-add-color-button-class:disabled:hover{text-decoration:none}.color-picker .cp-remove-color-button-class{position:absolute;top:-5px;right:-5px;display:block;width:10px;height:10px;border-radius:50%;cursor:pointer;text-align:center;background:#fff;box-shadow:1px 1px 5px #333}.color-picker .cp-remove-color-button-class:before{content:"x";position:relative;bottom:3.5px;display:inline-block;font-size:10px}.color-picker .eyedropper-icon{position:absolute;top:50%;left:50%;transform:translate(-50%,-50%);fill:#fff;mix-blend-mode:exclusion}\n'],encapsulation:2}),n})(),gA=(()=>{class n{constructor(e,i,r,o,s,a){this.injector=e,this.cfr=i,this.appRef=r,this.vcRef=o,this.elRef=s,this._service=a,this.dialogCreated=!1,this.ignoreChanges=!1,this.viewAttachedToAppRef=!1,this.cpWidth="230px",this.cpHeight="auto",this.cpToggle=!1,this.cpDisabled=!1,this.cpIgnoredElements=[],this.cpFallbackColor="",this.cpColorMode="color",this.cpCmykEnabled=!1,this.cpOutputFormat="auto",this.cpAlphaChannel="enabled",this.cpDisableInput=!1,this.cpDialogDisplay="popup",this.cpSaveClickOutside=!0,this.cpCloseClickOutside=!0,this.cpUseRootViewContainer=!1,this.cpPosition="auto",this.cpPositionOffset="0%",this.cpPositionRelativeToArrow=!1,this.cpOKButton=!1,this.cpOKButtonText="OK",this.cpOKButtonClass="cp-ok-button-class",this.cpCancelButton=!1,this.cpCancelButtonText="Cancel",this.cpCancelButtonClass="cp-cancel-button-class",this.cpEyeDropper=!1,this.cpPresetLabel="Preset colors",this.cpPresetColorsClass="cp-preset-colors-class",this.cpMaxPresetColorsLength=6,this.cpPresetEmptyMessage="No colors added",this.cpPresetEmptyMessageClass="preset-empty-message",this.cpAddColorButton=!1,this.cpAddColorButtonText="Add color",this.cpAddColorButtonClass="cp-add-color-button-class",this.cpRemoveColorButtonClass="cp-remove-color-button-class",this.cpInputChange=new F(!0),this.cpToggleChange=new F(!0),this.cpSliderChange=new F(!0),this.cpSliderDragEnd=new F(!0),this.cpSliderDragStart=new F(!0),this.colorPickerOpen=new F(!0),this.colorPickerClose=new F(!0),this.colorPickerCancel=new F(!0),this.colorPickerSelect=new F(!0),this.colorPickerChange=new F(!1),this.cpCmykColorChange=new F(!0),this.cpPresetColorsChange=new F(!0)}handleClick(){this.inputFocus()}handleFocus(){this.inputFocus()}handleInput(e){this.inputChange(e)}ngOnDestroy(){null!=this.cmpRef&&(this.viewAttachedToAppRef&&this.appRef.detachView(this.cmpRef.hostView),this.cmpRef.destroy(),this.cmpRef=null,this.dialog=null)}ngOnChanges(e){e.cpToggle&&!this.cpDisabled&&(e.cpToggle.currentValue?this.openDialog():e.cpToggle.currentValue||this.closeDialog()),e.colorPicker&&(this.dialog&&!this.ignoreChanges&&("inline"===this.cpDialogDisplay&&this.dialog.setInitialColor(e.colorPicker.currentValue),this.dialog.setColorFromString(e.colorPicker.currentValue,!1),this.cpUseRootViewContainer&&"inline"!==this.cpDialogDisplay&&this.cmpRef.changeDetectorRef.detectChanges()),this.ignoreChanges=!1),(e.cpPresetLabel||e.cpPresetColors)&&this.dialog&&this.dialog.setPresetConfig(this.cpPresetLabel,this.cpPresetColors)}openDialog(){if(this.dialogCreated)this.dialog&&this.dialog.openDialog(this.colorPicker);else{let e=this.vcRef;if(this.dialogCreated=!0,this.viewAttachedToAppRef=!1,this.cpUseRootViewContainer&&"inline"!==this.cpDialogDisplay){let o=this.injector.get(this.appRef.componentTypes[0],Mi.NULL);o!==Mi.NULL?e=o.vcRef||o.viewContainerRef||this.vcRef:this.viewAttachedToAppRef=!0}let i=this.cfr.resolveComponentFactory(JVe);if(this.viewAttachedToAppRef)this.cmpRef=i.create(this.injector),this.appRef.attachView(this.cmpRef.hostView),document.body.appendChild(this.cmpRef.hostView.rootNodes[0]);else{let r=Mi.create({providers:[],parent:e.injector});this.cmpRef=e.createComponent(i,0,r,[])}this.cmpRef.instance.setupDialog(this,this.elRef,this.colorPicker,this.cpWidth,this.cpHeight,this.cpDialogDisplay,this.cpFallbackColor,this.cpColorMode,this.cpCmykEnabled,this.cpAlphaChannel,this.cpOutputFormat,this.cpDisableInput,this.cpIgnoredElements,this.cpSaveClickOutside,this.cpCloseClickOutside,this.cpUseRootViewContainer,this.cpPosition,this.cpPositionOffset,this.cpPositionRelativeToArrow,this.cpPresetLabel,this.cpPresetColors,this.cpPresetColorsClass,this.cpMaxPresetColorsLength,this.cpPresetEmptyMessage,this.cpPresetEmptyMessageClass,this.cpOKButton,this.cpOKButtonClass,this.cpOKButtonText,this.cpCancelButton,this.cpCancelButtonClass,this.cpCancelButtonText,this.cpAddColorButton,this.cpAddColorButtonClass,this.cpAddColorButtonText,this.cpRemoveColorButtonClass,this.cpEyeDropper,this.elRef,this.cpExtraTemplate),this.dialog=this.cmpRef.instance,this.vcRef!==e&&this.cmpRef.changeDetectorRef.detectChanges()}}closeDialog(){this.dialog&&"popup"===this.cpDialogDisplay&&this.dialog.closeDialog()}cmykChanged(e){this.cpCmykColorChange.emit(e)}stateChanged(e){this.cpToggleChange.emit(e),e?this.colorPickerOpen.emit(this.colorPicker):this.colorPickerClose.emit(this.colorPicker)}colorChanged(e,i=!0){this.ignoreChanges=i,this.colorPickerChange.emit(e)}colorSelected(e){this.colorPickerSelect.emit(e)}colorCanceled(){this.colorPickerCancel.emit()}inputFocus(){let e=this.elRef.nativeElement,i=this.cpIgnoredElements.filter(r=>r===e);!this.cpDisabled&&!i.length&&(typeof document<"u"&&e===document.activeElement?this.openDialog():this.dialog&&this.dialog.show?this.closeDialog():this.openDialog())}inputChange(e){this.dialog?this.dialog.setColorFromString(e.target.value,!0):(this.colorPicker=e.target.value,this.colorPickerChange.emit(this.colorPicker))}inputChanged(e){this.cpInputChange.emit(e)}sliderChanged(e){this.cpSliderChange.emit(e)}sliderDragEnd(e){this.cpSliderDragEnd.emit(e)}sliderDragStart(e){this.cpSliderDragStart.emit(e)}presetColorsChanged(e){this.cpPresetColorsChange.emit(e)}}return n.\u0275fac=function(e){return new(e||n)(C(Mi),C(fo),C(yc),C(si),C(Me),C(EV))},n.\u0275dir=we({type:n,selectors:[["","colorPicker",""]],hostBindings:function(e,i){1&e&&I("click",function(){return i.handleClick()})("focus",function(){return i.handleFocus()})("input",function(o){return i.handleInput(o)})},inputs:{colorPicker:"colorPicker",cpWidth:"cpWidth",cpHeight:"cpHeight",cpToggle:"cpToggle",cpDisabled:"cpDisabled",cpIgnoredElements:"cpIgnoredElements",cpFallbackColor:"cpFallbackColor",cpColorMode:"cpColorMode",cpCmykEnabled:"cpCmykEnabled",cpOutputFormat:"cpOutputFormat",cpAlphaChannel:"cpAlphaChannel",cpDisableInput:"cpDisableInput",cpDialogDisplay:"cpDialogDisplay",cpSaveClickOutside:"cpSaveClickOutside",cpCloseClickOutside:"cpCloseClickOutside",cpUseRootViewContainer:"cpUseRootViewContainer",cpPosition:"cpPosition",cpPositionOffset:"cpPositionOffset",cpPositionRelativeToArrow:"cpPositionRelativeToArrow",cpOKButton:"cpOKButton",cpOKButtonText:"cpOKButtonText",cpOKButtonClass:"cpOKButtonClass",cpCancelButton:"cpCancelButton",cpCancelButtonText:"cpCancelButtonText",cpCancelButtonClass:"cpCancelButtonClass",cpEyeDropper:"cpEyeDropper",cpPresetLabel:"cpPresetLabel",cpPresetColors:"cpPresetColors",cpPresetColorsClass:"cpPresetColorsClass",cpMaxPresetColorsLength:"cpMaxPresetColorsLength",cpPresetEmptyMessage:"cpPresetEmptyMessage",cpPresetEmptyMessageClass:"cpPresetEmptyMessageClass",cpAddColorButton:"cpAddColorButton",cpAddColorButtonText:"cpAddColorButtonText",cpAddColorButtonClass:"cpAddColorButtonClass",cpRemoveColorButtonClass:"cpRemoveColorButtonClass",cpExtraTemplate:"cpExtraTemplate"},outputs:{cpInputChange:"cpInputChange",cpToggleChange:"cpToggleChange",cpSliderChange:"cpSliderChange",cpSliderDragEnd:"cpSliderDragEnd",cpSliderDragStart:"cpSliderDragStart",colorPickerOpen:"colorPickerOpen",colorPickerClose:"colorPickerClose",colorPickerCancel:"colorPickerCancel",colorPickerSelect:"colorPickerSelect",colorPickerChange:"colorPickerChange",cpCmykColorChange:"cpCmykColorChange",cpPresetColorsChange:"cpPresetColorsChange"},exportAs:["ngxColorPicker"],features:[Gt]}),n})(),bne=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({providers:[EV],imports:[Pe]}),n})(),e4e=["regexStringInput"];function t4e(n,t){if(1&n&&(Ot(0),h(1,"li",22),T(2),g(),kt()),2&n){let e=t.$implicit;v(1),_("title",e.name),v(1),bt(e.name)}}function n4e(n,t){if(1&n&&(h(0,"li",23)(1,"em"),T(2),j(3,"number"),g()()),2&n){let e=w().$implicit;v(2),He("and ",W(3,1,e.runs.length-5)," more")}}function i4e(n,t){1&n&&(h(0,"li",24)(1,"em"),T(2,"No runs are in the group"),g()())}var r4e=function(n){return{borderColor:n}},o4e=function(n){return{backgroundColor:n}};function s4e(n,t){if(1&n&&(h(0,"ul",16)(1,"li")(2,"label"),P(3,"span",17),h(4,"code",18),T(5),g()(),h(6,"ul"),S(7,t4e,3,2,"ng-container",19),j(8,"slice"),S(9,n4e,4,3,"li",20),S(10,i4e,3,0,"li",21),g()()()),2&n){let e=t.$implicit;_("ngStyle",In(11,r4e,e.color)),v(3),_("ngStyle",In(13,o4e,e.color)),v(1),_("title",e.groupId),v(1),bt(e.groupId),v(2),_("ngForOf",PO(8,7,e.runs,0,5)),v(2),_("ngIf",e.runs.length>5),v(1),_("ngIf",0===e.runs.length)}}function a4e(n,t){if(1&n&&(h(0,"div",14),S(1,s4e,11,15,"ul",15),g()),2&n){let e=w(2);v(1),_("ngForOf",e.colorRunPairList)}}function l4e(n,t){if(1&n&&(h(0,"div",25),T(1," There are no runs matching the regex, "),h(2,"code"),T(3),g(),T(4,". Please check if your regex string is correct. "),g()),2&n){let e=w(2);v(3),He("/",e.regexString,"/")}}function c4e(n,t){if(1&n&&(h(0,"div",10)(1,"h4"),T(2,"Color group preview"),g(),h(3,"div",11),S(4,a4e,2,1,"div",12),S(5,l4e,5,1,"ng-template",null,13,Wt),g()()),2&n){let e=it(6),i=w();v(4),_("ngIf",i.colorRunPairList.length)("ngIfElse",e)}}var yne=(()=>{class n{constructor(e,i){this.dialogRef=e,this.hostElRef=i,this.onSave=new F,this.regexInputOnChange=new F,this.timeOutId=0}resetFocus(){this.hostElRef.nativeElement.contains(document.activeElement)||this.regexStringInput.nativeElement.focus()}onEnter(e){this.onSaveClick(e),this.dialogRef.close()}onSaveClick(e){this.onSave.emit(e)}fillExample(e){this.regexString=e,this.regexInputChange(e)}regexInputChange(e){this.regexInputOnChange.emit(e)}handleFocusOut(){clearTimeout(this.timeOutId),this.timeOutId=setTimeout(this.resetFocus.bind(this),0)}}return n.\u0275fac=function(e){return new(e||n)(C(Ed),C(Me))},n.\u0275cmp=O({type:n,selectors:[["regex-edit-dialog-component"]],viewQuery:function(e,i){if(1&e&&Ge(e4e,7),2&e){let r;Se(r=Ee())&&(i.regexStringInput=r.first)}},inputs:{regexString:"regexString",colorRunPairList:"colorRunPairList"},outputs:{onSave:"onSave",regexInputOnChange:"regexInputOnChange"},decls:30,vars:2,consts:function(){let t;return t=$localize`:Color Runs by Regex Query␟15ed9f6fd2d4906a4803fc1255de3c5db2c56530␟9088985113960312808:Color Runs by Regex Query`,[[1,"regex-edit-dialog",3,"focusout"],["mat-dialog-title",""],["matInput","","aria-label",t,"cdkFocusInitial","",3,"value","keydown.enter","input"],["regexStringInput",""],[1,"example-details"],[3,"click"],["class","group-container",4,"ngIf"],["mat-dialog-actions","","align","end"],["mat-button","","mat-dialog-close",""],["mat-raised-button","","color","primary","mat-dialog-close","",1,"save-button",3,"click"],[1,"group-container"],[1,"grouping-preview"],["class","match-container",4,"ngIf","ngIfElse"],["empty",""],[1,"match-container"],["class","group",3,"ngStyle",4,"ngFor","ngForOf"],[1,"group",3,"ngStyle"],[1,"color-swatch",3,"ngStyle"],[1,"group-id",3,"title"],[4,"ngFor","ngForOf"],["class","more",4,"ngIf"],["class","no-match",4,"ngIf"],[3,"title"],[1,"more"],[1,"no-match"],[1,"warning"]]},template:function(e,i){if(1&e){let r=ge();h(0,"div",0),I("focusout",function(){return i.handleFocusOut()}),h(1,"h1",1),T(2,"Color runs by regex"),g(),h(3,"mat-dialog-content")(4,"p"),T(5,"Enter a regex with capturing groups to match against run names:"),g(),h(6,"mat-form-field")(7,"input",2,3),I("keydown.enter",function(s){return i.onEnter(s.target.value)})("input",function(s){return i.regexInputChange(s.target.value)}),g()()(),h(9,"div",4)(10,"p"),T(11,' Each matching run will be assigned a color based on the "key" formed by its matches to the capturing groups. '),P(12,"br"),h(13,"button",5),I("click",function(){return i.fillExample("(train|eval)")}),T(14," Try "),h(15,"code"),T(16,"(train|eval)"),g()(),T(17," to assign all runs containing "),h(18,"code"),T(19,"train"),g(),T(20," to one color and all runs containing "),h(21,"code"),T(22,"eval"),g(),T(23," to another color. "),g()(),S(24,c4e,7,2,"div",6),h(25,"div",7)(26,"button",8),T(27,"Cancel"),g(),h(28,"button",9),I("click",function(){X(r);let s=it(8);return Q(i.onSaveClick(s.value))}),T(29," Save "),g()()()}2&e&&(v(7),Wi("value",i.regexString),v(17),_("ngIf",i.regexString))},dependencies:[nn,Fe,pu,Ka,Ji,Z1,p9,K1,J1,Uu,jj,La],styles:[".example-details[_ngcontent-%COMP%]{padding:16px}.example-details[_ngcontent-%COMP%]   button[_ngcontent-%COMP%]{background-color:rgba(0,0,0,0);padding:0;border:none;cursor:pointer;text-decoration:underline;color:#1976d2}body.dark-mode[_nghost-%COMP%]   .example-details[_ngcontent-%COMP%]   button[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .example-details[_ngcontent-%COMP%]   button[_ngcontent-%COMP%]{color:#42a5f5}.example-details[_ngcontent-%COMP%]   button[_ngcontent-%COMP%]:visited{color:#7b1fa2}body.dark-mode[_nghost-%COMP%]   .example-details[_ngcontent-%COMP%]   button[_ngcontent-%COMP%]:visited, body.dark-mode   [_nghost-%COMP%]   .example-details[_ngcontent-%COMP%]   button[_ngcontent-%COMP%]:visited{color:#ba68c8}.group-container[_ngcontent-%COMP%]{margin:16px}.group-container[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%]{margin-bottom:16px}.group-container[_ngcontent-%COMP%]   .warning[_ngcontent-%COMP%]{color:#616161;font-size:.9em}body.dark-mode[_nghost-%COMP%]   .group-container[_ngcontent-%COMP%]   .warning[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .group-container[_ngcontent-%COMP%]   .warning[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}.grouping-preview[_ngcontent-%COMP%]{border:1px solid #ebebeb;max-height:50vh;overflow-y:auto;padding:16px}body.dark-mode[_nghost-%COMP%]   .grouping-preview[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .grouping-preview[_ngcontent-%COMP%]{border:1px solid #555}.match-container[_ngcontent-%COMP%]{align-items:flex-start;display:grid;flex-wrap:wrap;gap:10px;grid-template-columns:repeat(2, minmax(50%, 1fr))}.color-swatch[_ngcontent-%COMP%]{border-radius:50%;box-shadow:0 0 2px #000;display:inline-block;height:15px;width:15px}ul[_ngcontent-%COMP%]{list-style-type:none;padding:0}mat-form-field[_ngcontent-%COMP%]{width:100%}.group[_ngcontent-%COMP%]{border:1px solid #ebebeb;border-radius:3px;margin:0;padding:16px}body.dark-mode[_nghost-%COMP%]   .group[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .group[_ngcontent-%COMP%]{border:1px solid #555}.group[_ngcontent-%COMP%]   label[_ngcontent-%COMP%]{border-bottom:1px solid #ebebeb;align-items:center;display:grid;gap:10px;grid-template-columns:max-content auto;padding:16px 0}body.dark-mode[_nghost-%COMP%]   .group[_ngcontent-%COMP%]   label[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .group[_ngcontent-%COMP%]   label[_ngcontent-%COMP%]{border-bottom:1px solid #555}.group[_ngcontent-%COMP%]   label[_ngcontent-%COMP%]   .group-id[_ngcontent-%COMP%]{font-size:.95em;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.group[_ngcontent-%COMP%]   ul[_ngcontent-%COMP%]{font-size:.9em}.group[_ngcontent-%COMP%]   ul[_ngcontent-%COMP%]   li[_ngcontent-%COMP%]{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.group[_ngcontent-%COMP%]   .more[_ngcontent-%COMP%], .group[_ngcontent-%COMP%]   .no-match[_ngcontent-%COMP%]{color:#616161;margin-top:16px}body.dark-mode[_nghost-%COMP%]   .group[_ngcontent-%COMP%]   .more[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .group[_ngcontent-%COMP%]   .more[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}body.dark-mode[_nghost-%COMP%]   .group[_ngcontent-%COMP%]   .no-match[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .group[_ngcontent-%COMP%]   .no-match[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}.save-button[_ngcontent-%COMP%]{color:inherit}"],changeDetection:0}),n})(),xne=(()=>{class n{constructor(e,i,r){this.store=e,this.dialogRef=i,this.tentativeRegexString$=new Ie,this.groupByRegexString$=ta(()=>tn(this.store.select(v1).pipe(Yt(1)),this.tentativeRegexString$)).pipe(qn("")),this.colorRunPairList$=ta(()=>this.groupByRegexString$.pipe(wr(500),ke(o=>{try{let s=new RegExp(o);return Boolean(s)}catch{return!1}}),Li(this.allRuns$,this.runIdToEid$,this.store.select(Bs.getColorPalette),this.store.select(Rl)),N(([o,s,a,l,c])=>{let u=Sv({key:Yi.REGEX,regexString:o},s,a),p=new Map,f=[];for(let[m,b]of Object.entries(u.matches)){let M=p.get(m);if(!M){let y=l.colors[p.size%l.colors.length];M=c?y.darkHex:y.lightHex,p.set(m,M)}f.push({groupId:m,color:M,runs:b})}return f}))).pipe(qn([])),this.experimentIds=r.experimentIds,this.runIdToEid$=dn(this.experimentIds.map(o=>this.store.select(BW,{experimentId:o}).pipe(N(s=>({experimentId:o,runIds:s}))))).pipe(N(o=>{let s={};for(let{runIds:a,experimentId:l}of o)for(let c of a)s[c]=l;return s})),this.allRuns$=dn(this.experimentIds.map(o=>this.store.select(Du,{experimentId:o}))).pipe(N(o=>o.flat()))}onRegexInputOnChange(e){this.tentativeRegexString$.next(e)}onSave(e){this.store.dispatch(Hh({experimentIds:this.experimentIds,groupBy:{key:Yi.REGEX,regexString:e}}))}}return n.\u0275fac=function(e){return new(e||n)(C(Ae),C(Ed),C(Xv))},n.\u0275cmp=O({type:n,selectors:[["regex-edit-dialog"]],decls:3,vars:6,consts:[[3,"regexString","colorRunPairList","onSave","regexInputOnChange"]],template:function(e,i){1&e&&(h(0,"regex-edit-dialog-component",0),I("onSave",function(o){return i.onSave(o)})("regexInputOnChange",function(o){return i.onRegexInputOnChange(o)}),j(1,"async"),j(2,"async"),g()),2&e&&_("regexString",W(1,2,i.groupByRegexString$))("colorRunPairList",W(2,4,i.colorRunPairList$))},dependencies:[yne,ct],styles:["[_nghost-%COMP%], regex-edit-dialog-component[_ngcontent-%COMP%] {\n        display: block;\n        height: 100%;\n        width: 100%;\n      }"]}),n})();function p4e(n,t){1&n&&P(0,"mat-icon",14)}function f4e(n,t){if(1&n){let e=ge();h(0,"button",13),I("click",function(){X(e);let r=w();return Q(r.onGroupByChange.emit({key:r.GroupByKey.EXPERIMENT}))}),S(1,p4e,1,0,"mat-icon",7),h(2,"span"),T(3,"Experiment"),g()()}if(2&n){let e=w();Be("aria-checked",e.selectedGroupBy.key===e.GroupByKey.EXPERIMENT),v(1),_("ngIf",e.selectedGroupBy.key===e.GroupByKey.EXPERIMENT)}}function m4e(n,t){1&n&&P(0,"mat-icon",14)}function h4e(n,t){1&n&&P(0,"mat-icon",14)}function g4e(n,t){if(1&n&&(h(0,"span"),T(1),g()),2&n){let e=w();v(1),bt(e.regexString)}}function _4e(n,t){1&n&&(h(0,"span",15),T(1,"(none set)"),g())}var Cne=(()=>{class n{constructor(e){this.dialog=e,this.GroupByKey=Yi,this.onGroupByChange=new F}onRegexStringEdit(){this.dialog.open(xne,{maxHeight:"95vh",maxWidth:"80vw",data:{experimentIds:this.experimentIds}})}onGroupByRegexClick(){this.regexString?this.onGroupByChange.emit({key:Yi.REGEX,regexString:this.regexString}):this.onRegexStringEdit()}}return n.\u0275fac=function(e){return new(e||n)(C(zl))},n.\u0275cmp=O({type:n,selectors:[["runs-group-menu-button-component"]],inputs:{showExperimentsGroupBy:"showExperimentsGroupBy",experimentIds:"experimentIds",regexString:"regexString",selectedGroupBy:"selectedGroupBy"},outputs:{onGroupByChange:"onGroupByChange"},decls:19,vars:8,consts:[["mat-icon-button","","title","Color runs by...",3,"matMenuTriggerFor"],["svgIcon","palette_24px"],[1,"run-table-color-group-by"],["groupByMenu","matMenu"],[1,"label"],["mat-menu-item","","role","menuitemradio","data-value","experiment",3,"click",4,"ngIf"],["mat-menu-item","","role","menuitemradio","data-value","run",3,"click"],["svgIcon","done_24px",4,"ngIf"],["mat-menu-item","","role","menuitemradio","data-value","regex",3,"click"],["mat-menu-item","","role","menuitem","data-value","regex-edit",1,"display-regex-string",3,"click"],["svgIcon","edit_24px"],[4,"ngIf"],["class","none-set-string",4,"ngIf"],["mat-menu-item","","role","menuitemradio","data-value","experiment",3,"click"],["svgIcon","done_24px"],[1,"none-set-string"]],template:function(e,i){1&e&&(h(0,"button",0),P(1,"mat-icon",1),g(),h(2,"mat-menu",2,3)(4,"div",4),T(5,"Color runs by"),g(),S(6,f4e,4,2,"button",5),h(7,"button",6),I("click",function(){return i.onGroupByChange.emit({key:i.GroupByKey.RUN})}),S(8,m4e,1,0,"mat-icon",7),h(9,"span"),T(10,"Run"),g()(),h(11,"button",8),I("click",function(){return i.onGroupByRegexClick()}),S(12,h4e,1,0,"mat-icon",7),h(13,"span"),T(14,"Regex"),g()(),h(15,"button",9),I("click",function(){return i.onRegexStringEdit()}),P(16,"mat-icon",10),S(17,g4e,2,1,"span",11),S(18,_4e,2,0,"span",12),g()()),2&e&&(_("matMenuTriggerFor",it(3)),v(6),_("ngIf",i.showExperimentsGroupBy),v(1),Be("aria-checked",i.selectedGroupBy.key===i.GroupByKey.RUN),v(1),_("ngIf",i.selectedGroupBy.key===i.GroupByKey.RUN),v(3),Be("aria-checked",i.selectedGroupBy.key===i.GroupByKey.REGEX),v(1),_("ngIf",i.selectedGroupBy.key===i.GroupByKey.REGEX),v(5),_("ngIf",i.regexString),v(1),_("ngIf",!i.regexString))},dependencies:[Fe,$i,En,Nc,jl,Lc],styles:[".run-table-color-group-by{font-size:16px}  .run-table-color-group-by .label{color:#616161;font-size:.9em;margin:10px 0;padding:0 16px;pointer-events:none}  .run-table-color-group-by mat-icon{height:20px;width:20px}  .run-table-color-group-by .display-regex-string{padding-left:40px}  .run-table-color-group-by .display-regex-string .none-set-string{color:#616161}body.dark-mode[_nghost-%COMP%]     .run-table-color-group-by .display-regex-string .none-set-string, body.dark-mode   [_nghost-%COMP%]     .run-table-color-group-by .display-regex-string .none-set-string{color:rgba(255,255,255,.7)}"],changeDetection:0}),n})(),_A=(()=>{class n{constructor(e){this.store=e,this.showExperimentsGroupBy$=this.store.select(G8).pipe(N(i=>i.has(wn.COMPARE_EXPERIMENT))),this.selectedGroupBy$=this.store.select(HW),this.groupByRegexString$=this.store.select(v1)}onGroupByChange(e){this.store.dispatch(Hh({experimentIds:this.experimentIds,groupBy:e}))}}return n.\u0275fac=function(e){return new(e||n)(C(Ae))},n.\u0275cmp=O({type:n,selectors:[["runs-group-menu-button"]],inputs:{experimentIds:"experimentIds"},decls:4,vars:10,consts:[[3,"regexString","selectedGroupBy","showExperimentsGroupBy","experimentIds","onGroupByChange"]],template:function(e,i){1&e&&(h(0,"runs-group-menu-button-component",0),I("onGroupByChange",function(o){return i.onGroupByChange(o)}),j(1,"async"),j(2,"async"),j(3,"async"),g()),2&e&&_("regexString",W(1,4,i.groupByRegexString$))("selectedGroupBy",W(2,6,i.selectedGroupBy$))("showExperimentsGroupBy",W(3,8,i.showExperimentsGroupBy$))("experimentIds",i.experimentIds)},dependencies:[Cne,ct],encapsulation:2,changeDetection:0}),n})();function v4e(n,t){if(1&n){let e=ge();h(0,"div")(1,"mat-checkbox",15),I("click",function(r){return X(e),Q(w(3).handleSelectAll(r))}),g()()}if(2&n){let e=w(3);v(1),_("checked",e.allRowsSelected())("indeterminate",!e.allRowsSelected()&&e.someRowsSelected())}}function y4e(n,t){if(1&n&&(h(0,"span",16),P(1,"runs-group-menu-button",17),g()),2&n){let e=w(3);v(1),_("experimentIds",e.experimentIds)}}var wne=function(n){return[n]};function x4e(n,t){if(1&n&&(h(0,"tb-data-table-header-cell",11),Ot(1,12),S(2,v4e,2,2,"div",13),S(3,y4e,2,1,"span",14),kt(),g()),2&n){let e=w().$implicit,i=w();_("header",e)("sortingInfo",i.sortingInfo)("hparamsEnabled",!0)("ngClass",In(7,wne,"table-column-"+e.name)),v(1),_("ngSwitch",e.name),v(1),_("ngSwitchCase","selected"),v(1),_("ngSwitchCase","color")}}function C4e(n,t){if(1&n&&(Ot(0),S(1,x4e,4,9,"tb-data-table-header-cell",10),kt()),2&n){let e=t.$implicit;v(1),_("ngIf",e.enabled)}}function M4e(n,t){if(1&n){let e=ge();h(0,"span",21)(1,"button",22),I("colorPickerChange",function(r){X(e);let o=w(3).$implicit;return Q(w().onRunColorChange.emit({runId:o.id,newColor:r}))}),g()()}if(2&n){let e=w(3).$implicit;v(1),Tt("background",e.color),_("colorPicker",e.color)("cpDialogDisplay","popup")("cpPositionOffset",-20)("cpUseRootViewContainer",!0)("cpOutputFormat","hex")}}function w4e(n,t){if(1&n){let e=ge();h(0,"div")(1,"mat-checkbox",23),I("click",function(r){X(e);let o=w(3).$implicit;return Q(w().selectionClick(r,o.id))}),g()()}if(2&n){let e=w(3).$implicit;v(1),_("checked",e.selected)}}function S4e(n,t){if(1&n&&(h(0,"span"),P(1,"tb-experiment-alias",24),g()),2&n){let e=w(3).$implicit;v(1),_("alias",e.experimentAlias)}}function E4e(n,t){if(1&n&&(h(0,"tb-data-table-content-cell",19),Ot(1,12),S(2,M4e,2,7,"span",20),S(3,w4e,2,1,"div",13),S(4,S4e,2,1,"span",13),kt(),g()),2&n){let e=w().$implicit,i=w().$implicit;_("header",e)("datum",i[e.name])("ngClass",In(7,wne,"table-column-"+e.name)),v(1),_("ngSwitch",e.name),v(1),_("ngSwitchCase","color"),v(1),_("ngSwitchCase","selected"),v(1),_("ngSwitchCase","experimentAlias")}}function T4e(n,t){if(1&n&&(Ot(0),S(1,E4e,5,9,"tb-data-table-content-cell",18),kt()),2&n){let e=t.$implicit;v(1),_("ngIf",e.enabled)}}function D4e(n,t){if(1&n&&(Ot(0),h(1,"tb-data-table-content-row"),S(2,T4e,2,1,"ng-container",5),g(),kt()),2&n){let e=t.$implicit,i=w();v(1),Be("data-id",e.id),v(1),_("ngForOf",i.getHeaders())}}var I4e=function(n){return{"full-screen":n}},Sne=(()=>{class n{constructor(){this.ColumnHeaderType=ht,this.sortDataBy=new F,this.orderColumns=new F,this.onSelectionToggle=new F,this.onAllSelectionToggle=new F,this.onRegexFilterChange=new F,this.toggleFullScreen=new F,this.onRunColorChange=new F,this.addColumn=new F,this.removeColumn=new F,this.onSelectionDblClick=new F,this.addFilter=new F,this.beforeColumns=[{name:"selected",displayName:"",type:ht.CUSTOM,enabled:!0}],this.afterColumns=[{name:"color",displayName:"",type:ht.COLOR,enabled:!0}]}getHeaders(){return[].concat(this.beforeColumns,this.headers,this.afterColumns)}selectionClick(e,i){e.preventDefault(),1===e.detail&&this.onSelectionToggle.emit(i),2===e.detail&&this.onSelectionDblClick.emit(i)}allRowsSelected(){return this.data?.every(e=>e.selected)}someRowsSelected(){return this.data?.some(e=>e.selected)}handleSelectAll(e){e.preventDefault(),this.onAllSelectionToggle.emit(this.data?.map(i=>i.id))}onFilterKeyUp(e){this.onRegexFilterChange.emit(e.target.value)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["runs-data-table"]],inputs:{headers:"headers",data:"data",sortingInfo:"sortingInfo",experimentIds:"experimentIds",regexFilter:"regexFilter",isFullScreen:"isFullScreen",selectableColumns:"selectableColumns",loading:"loading",columnFilters:"columnFilters"},outputs:{sortDataBy:"sortDataBy",orderColumns:"orderColumns",onSelectionToggle:"onSelectionToggle",onAllSelectionToggle:"onAllSelectionToggle",onRegexFilterChange:"onRegexFilterChange",toggleFullScreen:"toggleFullScreen",onRunColorChange:"onRunColorChange",addColumn:"addColumn",removeColumn:"removeColumn",onSelectionDblClick:"onSelectionDblClick",addFilter:"addFilter"},decls:11,vars:14,consts:[[1,"filter-row"],["placeholder","Filter runs (regex)",1,"run-filter",3,"value","keyup"],[1,"table-container"],[3,"headers","sortingInfo","columnCustomizationEnabled","selectableColumns","columnFilters","loading","sortDataBy","orderColumns","addColumn","removeColumn","addFilter"],["header",""],[4,"ngFor","ngForOf"],["content",""],[1,"full-screen-toggle",3,"ngClass"],["mat-button","",1,"full-screen-btn",3,"ngClass","click"],[1,"expand-collapse-icon",3,"svgIcon"],[3,"header","sortingInfo","hparamsEnabled","ngClass",4,"ngIf"],[3,"header","sortingInfo","hparamsEnabled","ngClass"],[3,"ngSwitch"],[4,"ngSwitchCase"],["class","group-menu-container",4,"ngSwitchCase"],[3,"checked","indeterminate","click"],[1,"group-menu-container"],[3,"experimentIds"],[3,"header","datum","ngClass",4,"ngIf"],[3,"header","datum","ngClass"],["class","color-container",4,"ngSwitchCase"],[1,"color-container"],[1,"run-color-swatch",3,"colorPicker","cpDialogDisplay","cpPositionOffset","cpUseRootViewContainer","cpOutputFormat","colorPickerChange"],[3,"checked","click"],[3,"alias"]],template:function(e,i){1&e&&(h(0,"div",0)(1,"tb-filter-input",1),I("keyup",function(o){return i.onFilterKeyUp(o)}),g()(),h(2,"div",2)(3,"tb-data-table",3),I("sortDataBy",function(o){return i.sortDataBy.emit(o)})("orderColumns",function(o){return i.orderColumns.emit(o)})("addColumn",function(o){return i.addColumn.emit(o)})("removeColumn",function(o){return i.removeColumn.emit(o)})("addFilter",function(o){return i.addFilter.emit(o)}),Ot(4,4),S(5,C4e,2,1,"ng-container",5),kt(),Ot(6,6),S(7,D4e,3,2,"ng-container",5),kt(),g()(),h(8,"div",7)(9,"button",8),I("click",function(){return i.toggleFullScreen.emit()}),P(10,"mat-icon",9),g()()),2&e&&(v(1),Wi("value",i.regexFilter),v(2),_("headers",i.headers)("sortingInfo",i.sortingInfo)("columnCustomizationEnabled",!0)("selectableColumns",i.selectableColumns)("columnFilters",i.columnFilters)("loading",i.loading),v(2),_("ngForOf",i.getHeaders()),v(2),_("ngForOf",i.data),v(1),_("ngClass",In(12,I4e,i.isFullScreen)),v(1),_("ngClass",i.isFullScreen?"collapse":"expand"),v(1),_("svgIcon",i.isFullScreen?"arrow_back_24px":"arrow_forward_24px"))},dependencies:[gA,yn,nn,Fe,sr,Sr,d_,sA,uA,u_,Qu,Sp,Ji,ha,En,_A],styles:["[_nghost-%COMP%]{width:100%}[_nghost-%COMP%]{overflow-y:auto;width:100%}.color-container[_ngcontent-%COMP%]{display:flex;justify-content:center;width:100%}.run-color-swatch[_ngcontent-%COMP%]{border-radius:100%;border:1px solid #ebebeb;height:20px;width:20px;outline:none}.group-menu-container[_ngcontent-%COMP%]{display:flex;justify-content:center;width:100%}tb-data-table-content-row[_ngcontent-%COMP%], tb-data-table-header-cell[_ngcontent-%COMP%]{height:48px}tb-data-table-content-cell[_ngcontent-%COMP%], tb-data-table-header-cell[_ngcontent-%COMP%]{padding:0 4px;vertical-align:middle;border-bottom:1px solid #ebebeb}body.dark-mode[_nghost-%COMP%]   tb-data-table-content-cell[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   tb-data-table-content-cell[_ngcontent-%COMP%]{border-bottom:1px solid #555}body.dark-mode[_nghost-%COMP%]   tb-data-table-header-cell[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   tb-data-table-header-cell[_ngcontent-%COMP%]{border-bottom:1px solid #555}tb-data-table-content-cell[_ngcontent-%COMP%]:last-child, tb-data-table-header-cell[_ngcontent-%COMP%]:last-child{border-right:1px solid #ebebeb}body.dark-mode[_nghost-%COMP%]   tb-data-table-content-cell[_ngcontent-%COMP%]:last-child, body.dark-mode   [_nghost-%COMP%]   tb-data-table-content-cell[_ngcontent-%COMP%]:last-child{border-right:1px solid #555}body.dark-mode[_nghost-%COMP%]   tb-data-table-header-cell[_ngcontent-%COMP%]:last-child, body.dark-mode   [_nghost-%COMP%]   tb-data-table-header-cell[_ngcontent-%COMP%]:last-child{border-right:1px solid #555}tb-data-table-header-cell[_ngcontent-%COMP%]:last-of-type{border-right:1px solid #ebebeb}body.dark-mode[_nghost-%COMP%]   tb-data-table-header-cell[_ngcontent-%COMP%]:last-of-type, body.dark-mode   [_nghost-%COMP%]   tb-data-table-header-cell[_ngcontent-%COMP%]:last-of-type{border-right:1px solid #555}.table-column-selected[_ngcontent-%COMP%], .table-column-color[_ngcontent-%COMP%]{width:40px}.full-screen-toggle[_ngcontent-%COMP%]{opacity:0;position:absolute;height:100%;left:calc(100% + 2px);top:0;z-index:1;display:flex;align-items:center}.full-screen-toggle[_ngcontent-%COMP%]:hover{opacity:.8}.full-screen-toggle.full-screen[_ngcontent-%COMP%]{left:unset;right:0}.full-screen-toggle[_ngcontent-%COMP%]   .full-screen-btn[_ngcontent-%COMP%]{background-color:gray;padding:0;min-width:16px;width:16px}.full-screen-toggle[_ngcontent-%COMP%]   .full-screen-btn.expand[_ngcontent-%COMP%]{border-radius:0 16px 16px 0}.full-screen-toggle[_ngcontent-%COMP%]   .full-screen-btn.collapse[_ngcontent-%COMP%]{border-radius:16px 0 0 16px}.full-screen-toggle[_ngcontent-%COMP%]   .full-screen-btn[_ngcontent-%COMP%]   .expand-collapse-icon[_ngcontent-%COMP%]{font-size:16px;width:16px}.filter-row[_ngcontent-%COMP%]{border-bottom:1px solid #ebebeb;display:flex;align-items:center;height:48px;width:100%}body.dark-mode[_nghost-%COMP%]   .filter-row[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .filter-row[_ngcontent-%COMP%]{border-bottom:1px solid #555}.filter-row[_ngcontent-%COMP%]   tb-filter-input[_ngcontent-%COMP%]{padding-left:16px;flex-grow:1}.table-container[_ngcontent-%COMP%]{overflow-x:auto}"],changeDetection:0}),n})(),R4e=["tooltip"],Dne=new ie("mat-tooltip-scroll-strategy"),k4e={provide:Dne,deps:[zi],useFactory:function(n){return()=>n.scrollStrategies.reposition({scrollThrottle:20})}},N4e=new ie("mat-tooltip-default-options",{providedIn:"root",factory:function(){return{showDelay:0,hideDelay:0,touchendHideDelay:1500}}}),Ene="tooltip-panel",Tne=qo({passive:!0}),U4e=(()=>{class n{get position(){return this._position}set position(e){e!==this._position&&(this._position=e,this._overlayRef&&(this._updatePosition(this._overlayRef),this._tooltipInstance?.show(0),this._overlayRef.updatePosition()))}get positionAtOrigin(){return this._positionAtOrigin}set positionAtOrigin(e){this._positionAtOrigin=Rt(e),this._detach(),this._overlayRef=null}get disabled(){return this._disabled}set disabled(e){this._disabled=Rt(e),this._disabled?this.hide(0):this._setupPointerEnterEventsIfNeeded()}get showDelay(){return this._showDelay}set showDelay(e){this._showDelay=_i(e)}get hideDelay(){return this._hideDelay}set hideDelay(e){this._hideDelay=_i(e),this._tooltipInstance&&(this._tooltipInstance._mouseLeaveHideDelay=this._hideDelay)}get message(){return this._message}set message(e){this._ariaDescriber.removeDescription(this._elementRef.nativeElement,this._message,"tooltip"),this._message=null!=e?String(e).trim():"",!this._message&&this._isTooltipVisible()?this.hide(0):(this._setupPointerEnterEventsIfNeeded(),this._updateTooltipMessage(),this._ngZone.runOutsideAngular(()=>{Promise.resolve().then(()=>{this._ariaDescriber.describe(this._elementRef.nativeElement,this.message,"tooltip")})}))}get tooltipClass(){return this._tooltipClass}set tooltipClass(e){this._tooltipClass=e,this._tooltipInstance&&this._setTooltipClass(this._tooltipClass)}constructor(e,i,r,o,s,a,l,c,d,u,p,f){this._overlay=e,this._elementRef=i,this._scrollDispatcher=r,this._viewContainerRef=o,this._ngZone=s,this._platform=a,this._ariaDescriber=l,this._focusMonitor=c,this._dir=u,this._defaultOptions=p,this._position="below",this._positionAtOrigin=!1,this._disabled=!1,this._viewInitialized=!1,this._pointerExitEventsInitialized=!1,this._viewportMargin=8,this._cssClassPrefix="mat",this._showDelay=this._defaultOptions.showDelay,this._hideDelay=this._defaultOptions.hideDelay,this.touchGestures="auto",this._message="",this._passiveListeners=[],this._destroyed=new Ie,this._scrollStrategy=d,this._document=f,p&&(p.position&&(this.position=p.position),p.positionAtOrigin&&(this.positionAtOrigin=p.positionAtOrigin),p.touchGestures&&(this.touchGestures=p.touchGestures)),u.change.pipe(ot(this._destroyed)).subscribe(()=>{this._overlayRef&&this._updatePosition(this._overlayRef)})}ngAfterViewInit(){this._viewInitialized=!0,this._setupPointerEnterEventsIfNeeded(),this._focusMonitor.monitor(this._elementRef).pipe(ot(this._destroyed)).subscribe(e=>{e?"keyboard"===e&&this._ngZone.run(()=>this.show()):this._ngZone.run(()=>this.hide(0))})}ngOnDestroy(){let e=this._elementRef.nativeElement;clearTimeout(this._touchstartTimeout),this._overlayRef&&(this._overlayRef.dispose(),this._tooltipInstance=null),this._passiveListeners.forEach(([i,r])=>{e.removeEventListener(i,r,Tne)}),this._passiveListeners.length=0,this._destroyed.next(),this._destroyed.complete(),this._ariaDescriber.removeDescription(e,this.message,"tooltip"),this._focusMonitor.stopMonitoring(e)}show(e=this.showDelay,i){if(this.disabled||!this.message||this._isTooltipVisible())return void this._tooltipInstance?._cancelPendingAnimations();let r=this._createOverlay(i);this._detach(),this._portal=this._portal||new Vl(this._tooltipComponent,this._viewContainerRef);let o=this._tooltipInstance=r.attach(this._portal).instance;o._triggerElement=this._elementRef.nativeElement,o._mouseLeaveHideDelay=this._hideDelay,o.afterHidden().pipe(ot(this._destroyed)).subscribe(()=>this._detach()),this._setTooltipClass(this._tooltipClass),this._updateTooltipMessage(),o.show(e)}hide(e=this.hideDelay){let i=this._tooltipInstance;i&&(i.isVisible()?i.hide(e):(i._cancelPendingAnimations(),this._detach()))}toggle(e){this._isTooltipVisible()?this.hide():this.show(void 0,e)}_isTooltipVisible(){return!!this._tooltipInstance&&this._tooltipInstance.isVisible()}_createOverlay(e){if(this._overlayRef){let o=this._overlayRef.getConfig().positionStrategy;if((!this.positionAtOrigin||!e)&&o._origin instanceof Me)return this._overlayRef;this._detach()}let i=this._scrollDispatcher.getAncestorScrollContainers(this._elementRef),r=this._overlay.position().flexibleConnectedTo(this.positionAtOrigin&&e||this._elementRef).withTransformOriginOn(`.${this._cssClassPrefix}-tooltip`).withFlexibleDimensions(!1).withViewportMargin(this._viewportMargin).withScrollableContainers(i);return r.positionChanges.pipe(ot(this._destroyed)).subscribe(o=>{this._updateCurrentPositionClass(o.connectionPair),this._tooltipInstance&&o.scrollableViewProperties.isOverlayClipped&&this._tooltipInstance.isVisible()&&this._ngZone.run(()=>this.hide(0))}),this._overlayRef=this._overlay.create({direction:this._dir,positionStrategy:r,panelClass:`${this._cssClassPrefix}-${Ene}`,scrollStrategy:this._scrollStrategy()}),this._updatePosition(this._overlayRef),this._overlayRef.detachments().pipe(ot(this._destroyed)).subscribe(()=>this._detach()),this._overlayRef.outsidePointerEvents().pipe(ot(this._destroyed)).subscribe(()=>this._tooltipInstance?._handleBodyInteraction()),this._overlayRef.keydownEvents().pipe(ot(this._destroyed)).subscribe(o=>{this._isTooltipVisible()&&27===o.keyCode&&!vr(o)&&(o.preventDefault(),o.stopPropagation(),this._ngZone.run(()=>this.hide(0)))}),this._defaultOptions?.disableTooltipInteractivity&&this._overlayRef.addPanelClass(`${this._cssClassPrefix}-tooltip-panel-non-interactive`),this._overlayRef}_detach(){this._overlayRef&&this._overlayRef.hasAttached()&&this._overlayRef.detach(),this._tooltipInstance=null}_updatePosition(e){let i=e.getConfig().positionStrategy,r=this._getOrigin(),o=this._getOverlayPosition();i.withPositions([this._addOffset({...r.main,...o.main}),this._addOffset({...r.fallback,...o.fallback})])}_addOffset(e){return e}_getOrigin(){let r,e=!this._dir||"ltr"==this._dir.value,i=this.position;"above"==i||"below"==i?r={originX:"center",originY:"above"==i?"top":"bottom"}:"before"==i||"left"==i&&e||"right"==i&&!e?r={originX:"start",originY:"center"}:("after"==i||"right"==i&&e||"left"==i&&!e)&&(r={originX:"end",originY:"center"});let{x:o,y:s}=this._invertPosition(r.originX,r.originY);return{main:r,fallback:{originX:o,originY:s}}}_getOverlayPosition(){let r,e=!this._dir||"ltr"==this._dir.value,i=this.position;"above"==i?r={overlayX:"center",overlayY:"bottom"}:"below"==i?r={overlayX:"center",overlayY:"top"}:"before"==i||"left"==i&&e||"right"==i&&!e?r={overlayX:"end",overlayY:"center"}:("after"==i||"right"==i&&e||"left"==i&&!e)&&(r={overlayX:"start",overlayY:"center"});let{x:o,y:s}=this._invertPosition(r.overlayX,r.overlayY);return{main:r,fallback:{overlayX:o,overlayY:s}}}_updateTooltipMessage(){this._tooltipInstance&&(this._tooltipInstance.message=this.message,this._tooltipInstance._markForCheck(),this._ngZone.onMicrotaskEmpty.pipe(Yt(1),ot(this._destroyed)).subscribe(()=>{this._tooltipInstance&&this._overlayRef.updatePosition()}))}_setTooltipClass(e){this._tooltipInstance&&(this._tooltipInstance.tooltipClass=e,this._tooltipInstance._markForCheck())}_invertPosition(e,i){return"above"===this.position||"below"===this.position?"top"===i?i="bottom":"bottom"===i&&(i="top"):"end"===e?e="start":"start"===e&&(e="end"),{x:e,y:i}}_updateCurrentPositionClass(e){let s,{overlayY:i,originX:r,originY:o}=e;if(s="center"===i?this._dir&&"rtl"===this._dir.value?"end"===r?"left":"right":"start"===r?"left":"right":"bottom"===i&&"top"===o?"above":"below",s!==this._currentPosition){let a=this._overlayRef;if(a){let l=`${this._cssClassPrefix}-${Ene}-`;a.removePanelClass(l+this._currentPosition),a.addPanelClass(l+s)}this._currentPosition=s}}_setupPointerEnterEventsIfNeeded(){this._disabled||!this.message||!this._viewInitialized||this._passiveListeners.length||(this._platformSupportsMouseEvents()?this._passiveListeners.push(["mouseenter",e=>{let i;this._setupPointerExitEventsIfNeeded(),void 0!==e.x&&void 0!==e.y&&(i=e),this.show(void 0,i)}]):"off"!==this.touchGestures&&(this._disableNativeGesturesIfNecessary(),this._passiveListeners.push(["touchstart",e=>{let i=e.targetTouches?.[0],r=i?{x:i.clientX,y:i.clientY}:void 0;this._setupPointerExitEventsIfNeeded(),clearTimeout(this._touchstartTimeout),this._touchstartTimeout=setTimeout(()=>this.show(void 0,r),500)}])),this._addListeners(this._passiveListeners))}_setupPointerExitEventsIfNeeded(){if(this._pointerExitEventsInitialized)return;this._pointerExitEventsInitialized=!0;let e=[];if(this._platformSupportsMouseEvents())e.push(["mouseleave",i=>{let r=i.relatedTarget;(!r||!this._overlayRef?.overlayElement.contains(r))&&this.hide()}],["wheel",i=>this._wheelListener(i)]);else if("off"!==this.touchGestures){this._disableNativeGesturesIfNecessary();let i=()=>{clearTimeout(this._touchstartTimeout),this.hide(this._defaultOptions.touchendHideDelay)};e.push(["touchend",i],["touchcancel",i])}this._addListeners(e),this._passiveListeners.push(...e)}_addListeners(e){e.forEach(([i,r])=>{this._elementRef.nativeElement.addEventListener(i,r,Tne)})}_platformSupportsMouseEvents(){return!this._platform.IOS&&!this._platform.ANDROID}_wheelListener(e){if(this._isTooltipVisible()){let i=this._document.elementFromPoint(e.clientX,e.clientY),r=this._elementRef.nativeElement;i!==r&&!r.contains(i)&&this.hide()}}_disableNativeGesturesIfNecessary(){let e=this.touchGestures;if("off"!==e){let i=this._elementRef.nativeElement,r=i.style;("on"===e||"INPUT"!==i.nodeName&&"TEXTAREA"!==i.nodeName)&&(r.userSelect=r.msUserSelect=r.webkitUserSelect=r.MozUserSelect="none"),("on"===e||!i.draggable)&&(r.webkitUserDrag="none"),r.touchAction="none",r.webkitTapHighlightColor="transparent"}}}return n.\u0275fac=function(e){Is()},n.\u0275dir=we({type:n,inputs:{position:["matTooltipPosition","position"],positionAtOrigin:["matTooltipPositionAtOrigin","positionAtOrigin"],disabled:["matTooltipDisabled","disabled"],showDelay:["matTooltipShowDelay","showDelay"],hideDelay:["matTooltipHideDelay","hideDelay"],touchGestures:["matTooltipTouchGestures","touchGestures"],message:["matTooltip","message"],tooltipClass:["matTooltipClass","tooltipClass"]}}),n})(),Ine=(()=>{class n extends U4e{constructor(e,i,r,o,s,a,l,c,d,u,p,f){super(e,i,r,o,s,a,l,c,d,u,p,f),this._tooltipComponent=G4e,this._cssClassPrefix="mat-mdc",this._viewportMargin=8}_addOffset(e){let r=!this._dir||"ltr"==this._dir.value;return"top"===e.originY?e.offsetY=-8:"bottom"===e.originY?e.offsetY=8:"start"===e.originX?e.offsetX=r?-8:8:"end"===e.originX&&(e.offsetX=r?8:-8),e}}return n.\u0275fac=function(e){return new(e||n)(C(zi),C(Me),C(Nu),C(si),C(at),C(Gn),C(L1),C(Xr),C(Dne),C(Xi,8),C(N4e,8),C(Lt))},n.\u0275dir=we({type:n,selectors:[["","matTooltip",""]],hostAttrs:[1,"mat-mdc-tooltip-trigger"],exportAs:["matTooltip"],features:[Ke]}),n})(),j4e=(()=>{class n{constructor(e,i){this._changeDetectorRef=e,this._closeOnInteraction=!1,this._isVisible=!1,this._onHide=new Ie,this._animationsDisabled="NoopAnimations"===i}show(e){clearTimeout(this._hideTimeoutId),this._showTimeoutId=setTimeout(()=>{this._toggleVisibility(!0),this._showTimeoutId=void 0},e)}hide(e){clearTimeout(this._showTimeoutId),this._hideTimeoutId=setTimeout(()=>{this._toggleVisibility(!1),this._hideTimeoutId=void 0},e)}afterHidden(){return this._onHide}isVisible(){return this._isVisible}ngOnDestroy(){this._cancelPendingAnimations(),this._onHide.complete(),this._triggerElement=null}_handleBodyInteraction(){this._closeOnInteraction&&this.hide(0)}_markForCheck(){this._changeDetectorRef.markForCheck()}_handleMouseLeave({relatedTarget:e}){(!e||!this._triggerElement.contains(e))&&(this.isVisible()?this.hide(this._mouseLeaveHideDelay):this._finalizeAnimation(!1))}_onShow(){}_handleAnimationEnd({animationName:e}){(e===this._showAnimation||e===this._hideAnimation)&&this._finalizeAnimation(e===this._showAnimation)}_cancelPendingAnimations(){clearTimeout(this._showTimeoutId),clearTimeout(this._hideTimeoutId),this._showTimeoutId=this._hideTimeoutId=void 0}_finalizeAnimation(e){e?this._closeOnInteraction=!0:this.isVisible()||this._onHide.next()}_toggleVisibility(e){let i=this._tooltip.nativeElement,r=this._showAnimation,o=this._hideAnimation;if(i.classList.remove(e?o:r),i.classList.add(e?r:o),this._isVisible=e,e&&!this._animationsDisabled&&"function"==typeof getComputedStyle){let s=getComputedStyle(i);("0s"===s.getPropertyValue("animation-duration")||"none"===s.getPropertyValue("animation-name"))&&(this._animationsDisabled=!0)}e&&this._onShow(),this._animationsDisabled&&(i.classList.add("_mat-animation-noopable"),this._finalizeAnimation(e))}}return n.\u0275fac=function(e){return new(e||n)(C($t),C(hi,8))},n.\u0275dir=we({type:n}),n})(),G4e=(()=>{class n extends j4e{constructor(e,i,r){super(e,r),this._elementRef=i,this._isMultiline=!1,this._showAnimation="mat-mdc-tooltip-show",this._hideAnimation="mat-mdc-tooltip-hide"}_onShow(){this._isMultiline=this._isTooltipMultiline(),this._markForCheck()}_isTooltipMultiline(){let e=this._elementRef.nativeElement.getBoundingClientRect();return e.height>24&&e.width>=200}}return n.\u0275fac=function(e){return new(e||n)(C($t),C(Me),C(hi,8))},n.\u0275cmp=O({type:n,selectors:[["mat-tooltip-component"]],viewQuery:function(e,i){if(1&e&&Ge(R4e,7),2&e){let r;Se(r=Ee())&&(i._tooltip=r.first)}},hostAttrs:["aria-hidden","true"],hostVars:2,hostBindings:function(e,i){1&e&&I("mouseleave",function(o){return i._handleMouseLeave(o)}),2&e&&Tt("zoom",i.isVisible()?1:null)},features:[Ke],decls:4,vars:4,consts:[[1,"mdc-tooltip","mdc-tooltip--shown","mat-mdc-tooltip",3,"ngClass","animationend"],["tooltip",""],[1,"mdc-tooltip__surface","mdc-tooltip__surface-animation"]],template:function(e,i){1&e&&(h(0,"div",0,1),I("animationend",function(o){return i._handleAnimationEnd(o)}),h(2,"div",2),T(3),g()()),2&e&&(nt("mdc-tooltip--multiline",i._isMultiline),_("ngClass",i.tooltipClass),v(3),bt(i.message))},dependencies:[yn],styles:['.mdc-tooltip__surface{word-break:var(--mdc-tooltip-word-break, normal);overflow-wrap:anywhere}.mdc-tooltip{position:fixed;display:none;z-index:9}.mdc-tooltip-wrapper--rich{position:relative}.mdc-tooltip--shown,.mdc-tooltip--showing,.mdc-tooltip--hide{display:inline-flex}.mdc-tooltip--shown.mdc-tooltip--rich,.mdc-tooltip--showing.mdc-tooltip--rich,.mdc-tooltip--hide.mdc-tooltip--rich{display:inline-block;left:-320px;position:absolute}.mdc-tooltip__surface{line-height:16px;padding:4px 8px;min-width:40px;max-width:200px;min-height:24px;max-height:40vh;box-sizing:border-box;overflow:hidden;text-align:center}.mdc-tooltip__surface::before{position:absolute;box-sizing:border-box;width:100%;height:100%;top:0;left:0;border:1px solid rgba(0,0,0,0);border-radius:inherit;content:"";pointer-events:none}@media screen and (forced-colors: active){.mdc-tooltip__surface::before{border-color:CanvasText}}.mdc-tooltip--rich .mdc-tooltip__surface{align-items:flex-start;display:flex;flex-direction:column;min-height:24px;min-width:40px;max-width:320px;position:relative}.mdc-tooltip--multiline .mdc-tooltip__surface{text-align:left}[dir=rtl] .mdc-tooltip--multiline .mdc-tooltip__surface,.mdc-tooltip--multiline .mdc-tooltip__surface[dir=rtl]{text-align:right}.mdc-tooltip__surface .mdc-tooltip__title{margin:0 8px}.mdc-tooltip__surface .mdc-tooltip__content{max-width:calc(200px - (2 * 8px));margin:8px;text-align:left}[dir=rtl] .mdc-tooltip__surface .mdc-tooltip__content,.mdc-tooltip__surface .mdc-tooltip__content[dir=rtl]{text-align:right}.mdc-tooltip--rich .mdc-tooltip__surface .mdc-tooltip__content{max-width:calc(320px - (2 * 8px));align-self:stretch}.mdc-tooltip__surface .mdc-tooltip__content-link{text-decoration:none}.mdc-tooltip--rich-actions,.mdc-tooltip__content,.mdc-tooltip__title{z-index:1}.mdc-tooltip__surface-animation{opacity:0;transform:scale(0.8);will-change:transform,opacity}.mdc-tooltip--shown .mdc-tooltip__surface-animation{transform:scale(1);opacity:1}.mdc-tooltip--hide .mdc-tooltip__surface-animation{transform:scale(1)}.mdc-tooltip__caret-surface-top,.mdc-tooltip__caret-surface-bottom{position:absolute;height:24px;width:24px;transform:rotate(35deg) skewY(20deg) scaleX(0.9396926208)}.mdc-tooltip__caret-surface-top .mdc-elevation-overlay,.mdc-tooltip__caret-surface-bottom .mdc-elevation-overlay{width:100%;height:100%;top:0;left:0}.mdc-tooltip__caret-surface-bottom{outline:1px solid rgba(0,0,0,0);z-index:-1}@media screen and (forced-colors: active){.mdc-tooltip__caret-surface-bottom{outline-color:CanvasText}}.mdc-tooltip__surface{background-color:var(--mdc-plain-tooltip-container-color, #fff)}.mdc-tooltip__surface{border-radius:var(--mdc-plain-tooltip-container-shape, var(--mdc-shape-small, 4px))}.mdc-tooltip__caret-surface-top,.mdc-tooltip__caret-surface-bottom{border-radius:var(--mdc-plain-tooltip-container-shape, var(--mdc-shape-small, 4px))}.mdc-tooltip__surface{color:var(--mdc-plain-tooltip-supporting-text-color, #000)}.mdc-tooltip__surface{font-family:var(--mdc-plain-tooltip-supporting-text-font, inherit);font-size:var(--mdc-plain-tooltip-supporting-text-size, inherit);font-weight:var(--mdc-plain-tooltip-supporting-text-weight, inherit);letter-spacing:var(--mdc-plain-tooltip-supporting-text-tracking, inherit)}.mat-mdc-tooltip{position:relative;transform:scale(0)}.mat-mdc-tooltip::before{content:"";top:0;right:0;bottom:0;left:0;z-index:-1;position:absolute}.mat-mdc-tooltip-panel-below .mat-mdc-tooltip::before{top:-8px}.mat-mdc-tooltip-panel-above .mat-mdc-tooltip::before{bottom:-8px}.mat-mdc-tooltip-panel-right .mat-mdc-tooltip::before{left:-8px}.mat-mdc-tooltip-panel-left .mat-mdc-tooltip::before{right:-8px}.mat-mdc-tooltip._mat-animation-noopable{animation:none;transform:scale(1)}.mat-mdc-tooltip-panel-non-interactive{pointer-events:none}@keyframes mat-mdc-tooltip-show{0%{opacity:0;transform:scale(0.8)}100%{opacity:1;transform:scale(1)}}@keyframes mat-mdc-tooltip-hide{0%{opacity:1;transform:scale(1)}100%{opacity:0;transform:scale(0.8)}}.mat-mdc-tooltip-show{animation:mat-mdc-tooltip-show 150ms cubic-bezier(0, 0, 0.2, 1) forwards}.mat-mdc-tooltip-hide{animation:mat-mdc-tooltip-hide 75ms cubic-bezier(0.4, 0, 1, 1) forwards}'],encapsulation:2,changeDetection:0}),n})(),Ane=(_r("state",[wi("initial, void, hidden",rn({opacity:0,transform:"scale(0.8)"})),wi("visible",rn({transform:"scale(1)"})),gi("* => visible",Ci("150ms cubic-bezier(0, 0, 0.2, 1)")),gi("* => hidden",Ci("75ms cubic-bezier(0.4, 0, 1, 1)"))]),(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({providers:[k4e],imports:[lg,Pe,Co,fn,fn,Pc]}),n})());function q4e(n,t){if(1&n&&(h(0,"mat-option",19),T(1),g()),2&n){let e=t.$implicit;_("value",e),v(1),He(" ",e," ")}}function Y4e(n,t){if(1&n){let e=ge();h(0,"mat-form-field",16)(1,"mat-select",17),I("selectionChange",function(r){return X(e),Q(w(2)._changePageSize(r.value))}),S(2,q4e,2,2,"mat-option",18),g()()}if(2&n){let e=w(2);_("appearance",e._formFieldAppearance)("color",e.color),v(1),_("value",e.pageSize)("disabled",e.disabled)("aria-labelledby",e._pageSizeLabelId)("panelClass",e.selectConfig.panelClass||"")("disableOptionCentering",e.selectConfig.disableOptionCentering),v(1),_("ngForOf",e._displayedPageSizeOptions)}}function X4e(n,t){if(1&n&&(h(0,"div",20),T(1),g()),2&n){let e=w(2);v(1),bt(e.pageSize)}}function Q4e(n,t){if(1&n&&(h(0,"div",12)(1,"div",13),T(2),g(),S(3,Y4e,3,8,"mat-form-field",14),S(4,X4e,2,1,"div",15),g()),2&n){let e=w();v(1),Wi("id",e._pageSizeLabelId),v(1),He(" ",e._intl.itemsPerPageLabel," "),v(1),_("ngIf",e._displayedPageSizeOptions.length>1),v(1),_("ngIf",e._displayedPageSizeOptions.length<=1)}}function Z4e(n,t){if(1&n){let e=ge();h(0,"button",21),I("click",function(){return X(e),Q(w().firstPage())}),Nn(),h(1,"svg",7),P(2,"path",22),g()()}if(2&n){let e=w();_("matTooltip",e._intl.firstPageLabel)("matTooltipDisabled",e._previousButtonsDisabled())("matTooltipPosition","above")("disabled",e._previousButtonsDisabled()),Be("aria-label",e._intl.firstPageLabel)}}function K4e(n,t){if(1&n){let e=ge();Nn(),Oo(),h(0,"button",23),I("click",function(){return X(e),Q(w().lastPage())}),Nn(),h(1,"svg",7),P(2,"path",24),g()()}if(2&n){let e=w();_("matTooltip",e._intl.lastPageLabel)("matTooltipDisabled",e._nextButtonsDisabled())("matTooltipPosition","above")("disabled",e._nextButtonsDisabled()),Be("aria-label",e._intl.lastPageLabel)}}var Cm=(()=>{class n{constructor(){this.changes=new Ie,this.itemsPerPageLabel="Items per page:",this.nextPageLabel="Next page",this.previousPageLabel="Previous page",this.firstPageLabel="First page",this.lastPageLabel="Last page",this.getRangeLabel=(e,i,r)=>{if(0==r||0==i)return`0 of ${r}`;let o=e*i;return`${o+1} \u2013 ${o<(r=Math.max(r,0))?Math.min(o+i,r):o+i} of ${r}`}}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),$4e={provide:Cm,deps:[[new Ts,new sd,Cm]],useFactory:function(n){return n||new Cm}},tHe=new ie("MAT_PAGINATOR_DEFAULT_OPTIONS"),nHe=so(V1(class{})),iHe=(()=>{class n extends nHe{get pageIndex(){return this._pageIndex}set pageIndex(e){this._pageIndex=Math.max(_i(e),0),this._changeDetectorRef.markForCheck()}get length(){return this._length}set length(e){this._length=_i(e),this._changeDetectorRef.markForCheck()}get pageSize(){return this._pageSize}set pageSize(e){this._pageSize=Math.max(_i(e),0),this._updateDisplayedPageSizeOptions()}get pageSizeOptions(){return this._pageSizeOptions}set pageSizeOptions(e){this._pageSizeOptions=(e||[]).map(i=>_i(i)),this._updateDisplayedPageSizeOptions()}get hidePageSize(){return this._hidePageSize}set hidePageSize(e){this._hidePageSize=Rt(e)}get showFirstLastButtons(){return this._showFirstLastButtons}set showFirstLastButtons(e){this._showFirstLastButtons=Rt(e)}constructor(e,i,r){if(super(),this._intl=e,this._changeDetectorRef=i,this._pageIndex=0,this._length=0,this._pageSizeOptions=[],this._hidePageSize=!1,this._showFirstLastButtons=!1,this.selectConfig={},this.page=new F,this._intlChanges=e.changes.subscribe(()=>this._changeDetectorRef.markForCheck()),r){let{pageSize:o,pageSizeOptions:s,hidePageSize:a,showFirstLastButtons:l}=r;null!=o&&(this._pageSize=o),null!=s&&(this._pageSizeOptions=s),null!=a&&(this._hidePageSize=a),null!=l&&(this._showFirstLastButtons=l)}}ngOnInit(){this._initialized=!0,this._updateDisplayedPageSizeOptions(),this._markInitialized()}ngOnDestroy(){this._intlChanges.unsubscribe()}nextPage(){if(!this.hasNextPage())return;let e=this.pageIndex;this.pageIndex=this.pageIndex+1,this._emitPageEvent(e)}previousPage(){if(!this.hasPreviousPage())return;let e=this.pageIndex;this.pageIndex=this.pageIndex-1,this._emitPageEvent(e)}firstPage(){if(!this.hasPreviousPage())return;let e=this.pageIndex;this.pageIndex=0,this._emitPageEvent(e)}lastPage(){if(!this.hasNextPage())return;let e=this.pageIndex;this.pageIndex=this.getNumberOfPages()-1,this._emitPageEvent(e)}hasPreviousPage(){return this.pageIndex>=1&&0!=this.pageSize}hasNextPage(){let e=this.getNumberOfPages()-1;return this.pageIndex<e&&0!=this.pageSize}getNumberOfPages(){return this.pageSize?Math.ceil(this.length/this.pageSize):0}_changePageSize(e){let r=this.pageIndex;this.pageIndex=Math.floor(this.pageIndex*this.pageSize/e)||0,this.pageSize=e,this._emitPageEvent(r)}_nextButtonsDisabled(){return this.disabled||!this.hasNextPage()}_previousButtonsDisabled(){return this.disabled||!this.hasPreviousPage()}_updateDisplayedPageSizeOptions(){!this._initialized||(this.pageSize||(this._pageSize=0!=this.pageSizeOptions.length?this.pageSizeOptions[0]:50),this._displayedPageSizeOptions=this.pageSizeOptions.slice(),-1===this._displayedPageSizeOptions.indexOf(this.pageSize)&&this._displayedPageSizeOptions.push(this.pageSize),this._displayedPageSizeOptions.sort((e,i)=>e-i),this._changeDetectorRef.markForCheck())}_emitPageEvent(e){this.page.emit({previousPageIndex:e,pageIndex:this.pageIndex,pageSize:this.pageSize,length:this.length})}}return n.\u0275fac=function(e){Is()},n.\u0275dir=we({type:n,inputs:{color:"color",pageIndex:"pageIndex",length:"length",pageSize:"pageSize",pageSizeOptions:"pageSizeOptions",hidePageSize:"hidePageSize",showFirstLastButtons:"showFirstLastButtons",selectConfig:"selectConfig"},outputs:{page:"page"},features:[Ke]}),n})(),rHe=0,bA=(()=>{class n extends iHe{constructor(e,i,r){super(e,i,r),this._pageSizeLabelId="mat-paginator-page-size-label-"+rHe++,this._formFieldAppearance=r?.formFieldAppearance||"outline"}}return n.\u0275fac=function(e){return new(e||n)(C(Cm),C($t),C(tHe,8))},n.\u0275cmp=O({type:n,selectors:[["mat-paginator"]],hostAttrs:["role","group",1,"mat-mdc-paginator"],inputs:{disabled:"disabled"},exportAs:["matPaginator"],features:[Ke],decls:14,vars:14,consts:[[1,"mat-mdc-paginator-outer-container"],[1,"mat-mdc-paginator-container"],["class","mat-mdc-paginator-page-size",4,"ngIf"],[1,"mat-mdc-paginator-range-actions"],["aria-live","polite",1,"mat-mdc-paginator-range-label"],["mat-icon-button","","type","button","class","mat-mdc-paginator-navigation-first",3,"matTooltip","matTooltipDisabled","matTooltipPosition","disabled","click",4,"ngIf"],["mat-icon-button","","type","button",1,"mat-mdc-paginator-navigation-previous",3,"matTooltip","matTooltipDisabled","matTooltipPosition","disabled","click"],["viewBox","0 0 24 24","focusable","false",1,"mat-mdc-paginator-icon"],["d","M15.41 7.41L14 6l-6 6 6 6 1.41-1.41L10.83 12z"],["mat-icon-button","","type","button",1,"mat-mdc-paginator-navigation-next",3,"matTooltip","matTooltipDisabled","matTooltipPosition","disabled","click"],["d","M10 6L8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z"],["mat-icon-button","","type","button","class","mat-mdc-paginator-navigation-last",3,"matTooltip","matTooltipDisabled","matTooltipPosition","disabled","click",4,"ngIf"],[1,"mat-mdc-paginator-page-size"],[1,"mat-mdc-paginator-page-size-label",3,"id"],["class","mat-mdc-paginator-page-size-select",3,"appearance","color",4,"ngIf"],["class","mat-mdc-paginator-page-size-value",4,"ngIf"],[1,"mat-mdc-paginator-page-size-select",3,"appearance","color"],["hideSingleSelectionIndicator","",3,"value","disabled","aria-labelledby","panelClass","disableOptionCentering","selectionChange"],[3,"value",4,"ngFor","ngForOf"],[3,"value"],[1,"mat-mdc-paginator-page-size-value"],["mat-icon-button","","type","button",1,"mat-mdc-paginator-navigation-first",3,"matTooltip","matTooltipDisabled","matTooltipPosition","disabled","click"],["d","M18.41 16.59L13.82 12l4.59-4.59L17 6l-6 6 6 6zM6 6h2v12H6z"],["mat-icon-button","","type","button",1,"mat-mdc-paginator-navigation-last",3,"matTooltip","matTooltipDisabled","matTooltipPosition","disabled","click"],["d","M5.59 7.41L10.18 12l-4.59 4.59L7 18l6-6-6-6zM16 6h2v12h-2z"]],template:function(e,i){1&e&&(h(0,"div",0)(1,"div",1),S(2,Q4e,5,4,"div",2),h(3,"div",3)(4,"div",4),T(5),g(),S(6,Z4e,3,5,"button",5),h(7,"button",6),I("click",function(){return i.previousPage()}),Nn(),h(8,"svg",7),P(9,"path",8),g()(),Oo(),h(10,"button",9),I("click",function(){return i.nextPage()}),Nn(),h(11,"svg",7),P(12,"path",10),g()(),S(13,K4e,3,5,"button",11),g()()()),2&e&&(v(2),_("ngIf",!i.hidePageSize),v(3),He(" ",i._intl.getRangeLabel(i.pageIndex,i.pageSize,i.length)," "),v(1),_("ngIf",i.showFirstLastButtons),v(1),_("matTooltip",i._intl.previousPageLabel)("matTooltipDisabled",i._previousButtonsDisabled())("matTooltipPosition","above")("disabled",i._previousButtonsDisabled()),Be("aria-label",i._intl.previousPageLabel),v(3),_("matTooltip",i._intl.nextPageLabel)("matTooltipDisabled",i._nextButtonsDisabled())("matTooltipPosition","above")("disabled",i._nextButtonsDisabled()),Be("aria-label",i._intl.nextPageLabel),v(3),_("ngIf",i.showFirstLastButtons))},dependencies:[nn,Fe,$i,Ka,zu,Us,Ine],styles:[".mat-mdc-paginator{display:block}.mat-mdc-paginator .mat-mdc-form-field-subscript-wrapper{display:none}.mat-mdc-paginator .mat-mdc-select{line-height:1.5}.mat-mdc-paginator-outer-container{display:flex}.mat-mdc-paginator-container{display:flex;align-items:center;justify-content:flex-end;padding:0 8px;flex-wrap:wrap-reverse;width:100%}.mat-mdc-paginator-page-size{display:flex;align-items:baseline;margin-right:8px}[dir=rtl] .mat-mdc-paginator-page-size{margin-right:0;margin-left:8px}.mat-mdc-paginator-page-size-label{margin:0 4px}.mat-mdc-paginator-page-size-select{margin:0 4px;width:84px}.mat-mdc-paginator-range-label{margin:0 32px 0 24px}.mat-mdc-paginator-range-actions{display:flex;align-items:center}.mat-mdc-paginator-icon{display:inline-block;width:28px}[dir=rtl] .mat-mdc-paginator-icon{transform:rotate(180deg)}.cdk-high-contrast-active .mat-mdc-icon-button[disabled] .mat-mdc-paginator-icon,.cdk-high-contrast-active .mat-mdc-paginator-icon{fill:currentColor;fill:CanvasText}.cdk-high-contrast-active .mat-mdc-paginator-range-actions .mat-mdc-icon-button{outline:solid 1px}"],encapsulation:2,changeDetection:0}),n})(),Rne=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({providers:[$4e],imports:[Pe,ci,Ja,Ane]}),n})(),sHe=["mat-sort-header",""];function aHe(n,t){if(1&n){let e=ge();h(0,"div",3),I("@arrowPosition.start",function(){return X(e),Q(w()._disableViewStateAnimation=!0)})("@arrowPosition.done",function(){return X(e),Q(w()._disableViewStateAnimation=!1)}),P(1,"div",4),h(2,"div",5),P(3,"div",6)(4,"div",7)(5,"div",8),g()()}if(2&n){let e=w();_("@arrowOpacity",e._getArrowViewState())("@arrowPosition",e._getArrowViewState())("@allowChildren",e._getArrowDirectionState()),v(2),_("@indicator",e._getArrowDirectionState()),v(1),_("@leftPointer",e._getArrowDirectionState()),v(1),_("@rightPointer",e._getArrowDirectionState())}}var lHe=["*"],Pne=new ie("MAT_SORT_DEFAULT_OPTIONS"),cHe=V1(so(class{})),$x=(()=>{class n extends cHe{get direction(){return this._direction}set direction(e){this._direction=e}get disableClear(){return this._disableClear}set disableClear(e){this._disableClear=Rt(e)}constructor(e){super(),this._defaultOptions=e,this.sortables=new Map,this._stateChanges=new Ie,this.start="asc",this._direction="",this.sortChange=new F}register(e){this.sortables.set(e.id,e)}deregister(e){this.sortables.delete(e.id)}sort(e){this.active!=e.id?(this.active=e.id,this.direction=e.start?e.start:this.start):this.direction=this.getNextSortDirection(e),this.sortChange.emit({active:this.active,direction:this.direction})}getNextSortDirection(e){if(!e)return"";let r=function(n,t){let e=["asc","desc"];return"desc"==n&&e.reverse(),t||e.push(""),e}(e.start||this.start,e?.disableClear??this.disableClear??!!this._defaultOptions?.disableClear),o=r.indexOf(this.direction)+1;return o>=r.length&&(o=0),r[o]}ngOnInit(){this._markInitialized()}ngOnChanges(){this._stateChanges.next()}ngOnDestroy(){this._stateChanges.complete()}}return n.\u0275fac=function(e){return new(e||n)(C(Pne,8))},n.\u0275dir=we({type:n,selectors:[["","matSort",""]],hostAttrs:[1,"mat-sort"],inputs:{disabled:["matSortDisabled","disabled"],active:["matSortActive","active"],start:["matSortStart","start"],direction:["matSortDirection","direction"],disableClear:["matSortDisableClear","disableClear"]},outputs:{sortChange:"matSortChange"},exportAs:["matSort"],features:[Ke,Gt]}),n})(),Tp=T7.ENTERING+" "+E7.STANDARD_CURVE,m_={indicator:_r("indicator",[wi("active-asc, asc",rn({transform:"translateY(0px)"})),wi("active-desc, desc",rn({transform:"translateY(10px)"})),gi("active-asc <=> active-desc",Ci(Tp))]),leftPointer:_r("leftPointer",[wi("active-asc, asc",rn({transform:"rotate(-45deg)"})),wi("active-desc, desc",rn({transform:"rotate(45deg)"})),gi("active-asc <=> active-desc",Ci(Tp))]),rightPointer:_r("rightPointer",[wi("active-asc, asc",rn({transform:"rotate(45deg)"})),wi("active-desc, desc",rn({transform:"rotate(-45deg)"})),gi("active-asc <=> active-desc",Ci(Tp))]),arrowOpacity:_r("arrowOpacity",[wi("desc-to-active, asc-to-active, active",rn({opacity:1})),wi("desc-to-hint, asc-to-hint, hint",rn({opacity:.54})),wi("hint-to-desc, active-to-desc, desc, hint-to-asc, active-to-asc, asc, void",rn({opacity:0})),gi("* => asc, * => desc, * => active, * => hint, * => void",Ci("0ms")),gi("* <=> *",Ci(Tp))]),arrowPosition:_r("arrowPosition",[gi("* => desc-to-hint, * => desc-to-active",Ci(Tp,kb([rn({transform:"translateY(-25%)"}),rn({transform:"translateY(0)"})]))),gi("* => hint-to-desc, * => active-to-desc",Ci(Tp,kb([rn({transform:"translateY(0)"}),rn({transform:"translateY(25%)"})]))),gi("* => asc-to-hint, * => asc-to-active",Ci(Tp,kb([rn({transform:"translateY(25%)"}),rn({transform:"translateY(0)"})]))),gi("* => hint-to-asc, * => active-to-asc",Ci(Tp,kb([rn({transform:"translateY(0)"}),rn({transform:"translateY(-25%)"})]))),wi("desc-to-hint, asc-to-hint, hint, desc-to-active, asc-to-active, active",rn({transform:"translateY(0)"})),wi("hint-to-desc, active-to-desc, desc",rn({transform:"translateY(-25%)"})),wi("hint-to-asc, active-to-asc, asc",rn({transform:"translateY(25%)"}))]),allowChildren:_r("allowChildren",[gi("* <=> *",[Jp("@*",Kp(),{optional:!0})])])},vA=(()=>{class n{constructor(){this.changes=new Ie}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),pHe={provide:vA,deps:[[new Ts,new sd,vA]],useFactory:function(n){return n||new vA}},fHe=so(class{}),One=(()=>{class n extends fHe{get sortActionDescription(){return this._sortActionDescription}set sortActionDescription(e){this._updateSortActionDescription(e)}get disableClear(){return this._disableClear}set disableClear(e){this._disableClear=Rt(e)}constructor(e,i,r,o,s,a,l,c){super(),this._intl=e,this._changeDetectorRef=i,this._sort=r,this._columnDef=o,this._focusMonitor=s,this._elementRef=a,this._ariaDescriber=l,this._showIndicatorHint=!1,this._viewState={},this._arrowDirection="",this._disableViewStateAnimation=!1,this.arrowPosition="after",this._sortActionDescription="Sort",c?.arrowPosition&&(this.arrowPosition=c?.arrowPosition),this._handleStateChanges()}ngOnInit(){!this.id&&this._columnDef&&(this.id=this._columnDef.name),this._updateArrowDirection(),this._setAnimationTransitionState({toState:this._isSorted()?"active":this._arrowDirection}),this._sort.register(this),this._sortButton=this._elementRef.nativeElement.querySelector(".mat-sort-header-container"),this._updateSortActionDescription(this._sortActionDescription)}ngAfterViewInit(){this._focusMonitor.monitor(this._elementRef,!0).subscribe(e=>{let i=!!e;i!==this._showIndicatorHint&&(this._setIndicatorHintVisible(i),this._changeDetectorRef.markForCheck())})}ngOnDestroy(){this._focusMonitor.stopMonitoring(this._elementRef),this._sort.deregister(this),this._rerenderSubscription.unsubscribe()}_setIndicatorHintVisible(e){this._isDisabled()&&e||(this._showIndicatorHint=e,this._isSorted()||(this._updateArrowDirection(),this._setAnimationTransitionState(this._showIndicatorHint?{fromState:this._arrowDirection,toState:"hint"}:{fromState:"hint",toState:this._arrowDirection})))}_setAnimationTransitionState(e){this._viewState=e||{},this._disableViewStateAnimation&&(this._viewState={toState:e.toState})}_toggleOnInteraction(){this._sort.sort(this),("hint"===this._viewState.toState||"active"===this._viewState.toState)&&(this._disableViewStateAnimation=!0)}_handleClick(){this._isDisabled()||this._sort.sort(this)}_handleKeydown(e){!this._isDisabled()&&(32===e.keyCode||13===e.keyCode)&&(e.preventDefault(),this._toggleOnInteraction())}_isSorted(){return this._sort.active==this.id&&("asc"===this._sort.direction||"desc"===this._sort.direction)}_getArrowDirectionState(){return`${this._isSorted()?"active-":""}${this._arrowDirection}`}_getArrowViewState(){let e=this._viewState.fromState;return(e?`${e}-to-`:"")+this._viewState.toState}_updateArrowDirection(){this._arrowDirection=this._isSorted()?this._sort.direction:this.start||this._sort.start}_isDisabled(){return this._sort.disabled||this.disabled}_getAriaSortAttribute(){return this._isSorted()?"asc"==this._sort.direction?"ascending":"descending":"none"}_renderArrow(){return!this._isDisabled()||this._isSorted()}_updateSortActionDescription(e){this._sortButton&&(this._ariaDescriber?.removeDescription(this._sortButton,this._sortActionDescription),this._ariaDescriber?.describe(this._sortButton,e)),this._sortActionDescription=e}_handleStateChanges(){this._rerenderSubscription=tn(this._sort.sortChange,this._sort._stateChanges,this._intl.changes).subscribe(()=>{this._isSorted()&&(this._updateArrowDirection(),("hint"===this._viewState.toState||"active"===this._viewState.toState)&&(this._disableViewStateAnimation=!0),this._setAnimationTransitionState({fromState:this._arrowDirection,toState:"active"}),this._showIndicatorHint=!1),!this._isSorted()&&this._viewState&&"active"===this._viewState.toState&&(this._disableViewStateAnimation=!1,this._setAnimationTransitionState({fromState:"active",toState:this._arrowDirection})),this._changeDetectorRef.markForCheck()})}}return n.\u0275fac=function(e){return new(e||n)(C(vA),C($t),C($x,8),C("MAT_SORT_HEADER_COLUMN_DEF",8),C(Xr),C(Me),C(L1,8),C(Pne,8))},n.\u0275cmp=O({type:n,selectors:[["","mat-sort-header",""]],hostAttrs:[1,"mat-sort-header"],hostVars:3,hostBindings:function(e,i){1&e&&I("click",function(){return i._handleClick()})("keydown",function(o){return i._handleKeydown(o)})("mouseenter",function(){return i._setIndicatorHintVisible(!0)})("mouseleave",function(){return i._setIndicatorHintVisible(!1)}),2&e&&(Be("aria-sort",i._getAriaSortAttribute()),nt("mat-sort-header-disabled",i._isDisabled()))},inputs:{disabled:"disabled",id:["mat-sort-header","id"],arrowPosition:"arrowPosition",start:"start",sortActionDescription:"sortActionDescription",disableClear:"disableClear"},exportAs:["matSortHeader"],features:[Ke],attrs:sHe,ngContentSelectors:lHe,decls:4,vars:7,consts:[[1,"mat-sort-header-container","mat-focus-indicator"],[1,"mat-sort-header-content"],["class","mat-sort-header-arrow",4,"ngIf"],[1,"mat-sort-header-arrow"],[1,"mat-sort-header-stem"],[1,"mat-sort-header-indicator"],[1,"mat-sort-header-pointer-left"],[1,"mat-sort-header-pointer-right"],[1,"mat-sort-header-pointer-middle"]],template:function(e,i){1&e&&(Dn(),h(0,"div",0)(1,"div",1),zt(2),g(),S(3,aHe,6,6,"div",2),g()),2&e&&(nt("mat-sort-header-sorted",i._isSorted())("mat-sort-header-position-before","before"===i.arrowPosition),Be("tabindex",i._isDisabled()?null:0)("role",i._isDisabled()?null:"button"),v(3),_("ngIf",i._renderArrow()))},dependencies:[Fe],styles:[".mat-sort-header-container{display:flex;cursor:pointer;align-items:center;letter-spacing:normal;outline:0}[mat-sort-header].cdk-keyboard-focused .mat-sort-header-container,[mat-sort-header].cdk-program-focused .mat-sort-header-container{border-bottom:solid 1px currentColor}.mat-sort-header-disabled .mat-sort-header-container{cursor:default}.mat-sort-header-container::before{margin:calc(calc(var(--mat-focus-indicator-border-width, 3px) + 2px) * -1)}.mat-sort-header-content{text-align:center;display:flex;align-items:center}.mat-sort-header-position-before{flex-direction:row-reverse}.mat-sort-header-arrow{height:12px;width:12px;min-width:12px;position:relative;display:flex;opacity:0}.mat-sort-header-arrow,[dir=rtl] .mat-sort-header-position-before .mat-sort-header-arrow{margin:0 0 0 6px}.mat-sort-header-position-before .mat-sort-header-arrow,[dir=rtl] .mat-sort-header-arrow{margin:0 6px 0 0}.mat-sort-header-stem{background:currentColor;height:10px;width:2px;margin:auto;display:flex;align-items:center}.cdk-high-contrast-active .mat-sort-header-stem{width:0;border-left:solid 2px}.mat-sort-header-indicator{width:100%;height:2px;display:flex;align-items:center;position:absolute;top:0;left:0}.mat-sort-header-pointer-middle{margin:auto;height:2px;width:2px;background:currentColor;transform:rotate(45deg)}.cdk-high-contrast-active .mat-sort-header-pointer-middle{width:0;height:0;border-top:solid 2px;border-left:solid 2px}.mat-sort-header-pointer-left,.mat-sort-header-pointer-right{background:currentColor;width:6px;height:2px;position:absolute;top:0}.cdk-high-contrast-active .mat-sort-header-pointer-left,.cdk-high-contrast-active .mat-sort-header-pointer-right{width:0;height:0;border-left:solid 6px;border-top:solid 2px}.mat-sort-header-pointer-left{transform-origin:right;left:0}.mat-sort-header-pointer-right{transform-origin:left;right:0}"],encapsulation:2,data:{animation:[m_.indicator,m_.leftPointer,m_.rightPointer,m_.arrowOpacity,m_.arrowPosition,m_.allowChildren]},changeDetection:0}),n})(),kne=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({providers:[pHe],imports:[Pe,fn]}),n})();function AV(n){return class extends n{get sticky(){return this._sticky}set sticky(t){let e=this._sticky;this._sticky=Rt(t),this._hasStickyChanged=e!==this._sticky}hasStickyChanged(){let t=this._hasStickyChanged;return this._hasStickyChanged=!1,t}resetStickyChanged(){this._hasStickyChanged=!1}constructor(...t){super(...t),this._sticky=!1,this._hasStickyChanged=!1}}}var RV=new ie("CDK_TABLE"),Fne=(new ie("text-column-options"),AV(class{}),new ie("_COALESCED_STYLE_SCHEDULER"),(()=>{class n{constructor(e,i){this.template=e,this._differs=i}ngOnChanges(e){if(!this._columnsDiffer){let i=e.columns&&e.columns.currentValue||[];this._columnsDiffer=this._differs.find(i).create(),this._columnsDiffer.diff(i)}}getColumnsDiff(){return this._columnsDiffer.diff(this.columns)}extractCellTemplate(e){return this instanceof Nne?e.headerCell.template:this instanceof Lne?e.footerCell.template:e.cell.template}}return n.\u0275fac=function(e){return new(e||n)(C(Si),C(wl))},n.\u0275dir=we({type:n,features:[Gt]}),n})()),gHe=AV(class extends Fne{}),Nne=(()=>{class n extends gHe{constructor(e,i,r){super(e,i),this._table=r}ngOnChanges(e){super.ngOnChanges(e)}}return n.\u0275fac=function(e){return new(e||n)(C(Si),C(wl),C(RV,8))},n.\u0275dir=we({type:n,selectors:[["","cdkHeaderRowDef",""]],inputs:{columns:["cdkHeaderRowDef","columns"],sticky:["cdkHeaderRowDefSticky","sticky"]},features:[Ke,Gt]}),n})(),_He=AV(class extends Fne{}),Lne=(()=>{class n extends _He{constructor(e,i,r){super(e,i),this._table=r}ngOnChanges(e){super.ngOnChanges(e)}}return n.\u0275fac=function(e){return new(e||n)(C(Si),C(wl),C(RV,8))},n.\u0275dir=we({type:n,selectors:[["","cdkFooterRowDef",""]],inputs:{columns:["cdkFooterRowDef","columns"],sticky:["cdkFooterRowDefSticky","sticky"]},features:[Ke,Gt]}),n})(),Bne=(new ie("CDK_SPL"),(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Md]}),n})()),Vne=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[fn,Bne,fn]}),n})(),PV=class extends Wv{get data(){return this._data.value}set data(t){t=Array.isArray(t)?t:[],this._data.next(t),this._renderChangesSubscription||this._filterData(t)}get filter(){return this._filter.value}set filter(t){this._filter.next(t),this._renderChangesSubscription||this._filterData(this.data)}get sort(){return this._sort}set sort(t){this._sort=t,this._updateChangeSubscription()}get paginator(){return this._paginator}set paginator(t){this._paginator=t,this._updateChangeSubscription()}constructor(t=[]){super(),this._renderData=new Ai([]),this._filter=new Ai(""),this._internalPageChanges=new Ie,this._renderChangesSubscription=null,this.sortingDataAccessor=(e,i)=>{let r=e[i];if(s2(r)){let o=Number(r);return o<9007199254740991?o:r}return r},this.sortData=(e,i)=>{let r=i.active,o=i.direction;return r&&""!=o?e.sort((s,a)=>{let l=this.sortingDataAccessor(s,r),c=this.sortingDataAccessor(a,r),d=typeof l,u=typeof c;d!==u&&("number"===d&&(l+=""),"number"===u&&(c+=""));let p=0;return null!=l&&null!=c?l>c?p=1:l<c&&(p=-1):null!=l?p=1:null!=c&&(p=-1),p*("asc"==o?1:-1)}):e},this.filterPredicate=(e,i)=>{let r=Object.keys(e).reduce((s,a)=>s+e[a]+"\u25ec","").toLowerCase(),o=i.trim().toLowerCase();return-1!=r.indexOf(o)},this._data=new Ai(t),this._updateChangeSubscription()}_updateChangeSubscription(){let t=this._sort?tn(this._sort.sortChange,this._sort.initialized):Ht(null),e=this._paginator?tn(this._paginator.page,this._internalPageChanges,this._paginator.initialized):Ht(null),r=dn([this._data,this._filter]).pipe(N(([a])=>this._filterData(a))),o=dn([r,t]).pipe(N(([a])=>this._orderData(a))),s=dn([o,e]).pipe(N(([a])=>this._pageData(a)));this._renderChangesSubscription?.unsubscribe(),this._renderChangesSubscription=s.subscribe(a=>this._renderData.next(a))}_filterData(t){return this.filteredData=null==this.filter||""===this.filter?t:t.filter(e=>this.filterPredicate(e,this.filter)),this.paginator&&this._updatePaginator(this.filteredData.length),this.filteredData}_orderData(t){return this.sort?this.sortData(t.slice(),this.sort):t}_pageData(t){if(!this.paginator)return t;let e=this.paginator.pageIndex*this.paginator.pageSize;return t.slice(e,e+this.paginator.pageSize)}_updatePaginator(t){Promise.resolve().then(()=>{let e=this.paginator;if(e&&(e.length=t,e.pageIndex>0)){let i=Math.ceil(e.length/e.pageSize)-1||0,r=Math.min(e.pageIndex,i);r!==e.pageIndex&&(e.pageIndex=r,this._internalPageChanges.next())}})}connect(){return this._renderChangesSubscription||this._updateChangeSubscription(),this._renderData}disconnect(){this._renderChangesSubscription?.unsubscribe(),this._renderChangesSubscription=null}},yA=class extends PV{},yHe=["filter"];function xHe(n,t){1&n&&li(0)}function CHe(n,t){1&n&&li(0)}var MHe=function(n){return{item:n}};function wHe(n,t){if(1&n&&(Ot(0),S(1,CHe,1,0,"ng-container",12),kt()),2&n){let e=t.$implicit;w();let i=it(14);v(1),_("ngTemplateOutlet",i)("ngTemplateOutletContext",In(2,MHe,e))}}function SHe(n,t){1&n&&(h(0,"div",13),P(1,"mat-spinner",14),g())}function EHe(n,t){1&n&&(h(0,"div",15),T(1,"No Runs"),g())}function THe(n,t){if(1&n&&(h(0,"div",15)(1,"span"),T(2,'No runs match "'),h(3,"code"),T(4),g(),T(5,'"'),g()()),2&n){let e=w();v(4),bt(e.regexFilter)}}var DHe=function(){return[5,10,20]};function IHe(n,t){if(1&n){let e=ge();h(0,"mat-paginator",16),I("page",function(r){return X(e),Q(w().onPaginationChange.emit(r))}),g()}if(2&n){let e=w();_("pageSizeOptions",cu(4,DHe))("pageIndex",e.paginationOption.pageIndex)("pageSize",e.paginationOption.pageSize)("length",e.filteredItemsLength)}}function AHe(n,t){if(1&n){let e=ge();h(0,"mat-checkbox",26),I("change",function(){return X(e),Q(w(3).handlePageToggle())}),g()}if(2&n){let e=w(3);_("checked",e.allPageItemsSelected())("indeterminate",!e.allPageItemsSelected()&&e.somePageItemsSelected())}}var Hne=function(n){return{type:n}};function RHe(n,t){if(1&n&&(h(0,"span",27),T(1,"Experiment"),g()),2&n){let e=w(3);_("mat-sort-header",In(1,Hne,e.SortType.EXPERIMENT_NAME))}}function PHe(n,t){if(1&n&&(h(0,"span",27),T(1,"Run"),g()),2&n){let e=w(3);_("mat-sort-header",In(1,Hne,e.SortType.RUN_NAME))}}function OHe(n,t){if(1&n&&(h(0,"span"),P(1,"runs-group-menu-button",28),g()),2&n){let e=w(3);v(1),_("experimentIds",e.experimentIds)}}var zne=function(n){return["column",n]};function kHe(n,t){if(1&n&&(h(0,"span",21),Ot(1,22),S(2,AHe,1,2,"mat-checkbox",23),S(3,RHe,2,3,"span",24),S(4,PHe,2,3,"span",24),S(5,OHe,2,1,"span",25),kt(),g()),2&n){let e=t.$implicit,i=w(2);_("ngClass",In(6,zne,"tb-column-"+e)),v(1),_("ngSwitch",e),v(1),_("ngSwitchCase",i.RunsTableColumn.CHECKBOX),v(1),_("ngSwitchCase",i.RunsTableColumn.EXPERIMENT_NAME),v(1),_("ngSwitchCase",i.RunsTableColumn.RUN_NAME),v(1),_("ngSwitchCase",i.RunsTableColumn.RUN_COLOR)}}function FHe(n,t){if(1&n){let e=ge();Ot(0),h(1,"div",37),I("click",function(r){return r.stopPropagation()}),h(2,"tb-range-input",38),I("rangeValuesChanged",function(r){X(e);let o=w(2).$implicit;return Q(w(2).handleHparamIntervalChanged(o,r))}),g()(),kt()}if(2&n){let e=w(2).$implicit;v(2),_("min",e.filter.minValue)("max",e.filter.maxValue)("lowerValue",e.filter.filterLowerValue)("upperValue",e.filter.filterUpperValue)}}function NHe(n,t){if(1&n){let e=ge();h(0,"div",40),I("click",function(r){return r.stopPropagation()}),h(1,"mat-checkbox",36),I("change",function(){let o=X(e).$implicit,s=w(3).$implicit;return Q(w(2).handleHparamDiscreteChanged(s,o))}),h(2,"span"),T(3),g()()()}if(2&n){let e=t.$implicit,i=w(3).$implicit;v(1),_("checked",i.filter.filterValues.includes(e)),v(2),bt(e)}}function LHe(n,t){if(1&n&&(Ot(0),S(1,NHe,4,2,"div",39),kt()),2&n){let e=w(2).$implicit;v(1),_("ngForOf",e.filter.possibleValues)}}function BHe(n,t){if(1&n){let e=ge();Ot(0),h(1,"button",32),I("click",function(r){return r.stopPropagation()}),P(2,"mat-icon",33),g(),h(3,"mat-menu",null,34)(5,"div",35),I("click",function(r){return r.stopPropagation()}),h(6,"mat-checkbox",36),I("change",function(){X(e);let r=w().$implicit;return Q(w(2).handleHparamIncludeUndefinedToggled(r))}),h(7,"span"),T(8,"(show empty value)"),g()()(),S(9,FHe,3,4,"ng-container",31),S(10,LHe,2,1,"ng-container",31),g(),kt()}if(2&n){let e=it(4),i=w().$implicit,r=w(2);v(1),_("matMenuTriggerFor",e),Be("aria-label","Filter hparam "+(i.displayName||i.name)),v(5),_("checked",i.filter.includeUndefined),v(3),_("ngIf",i.filter.type===r.DomainType.INTERVAL),v(1),_("ngIf",i.filter.type===r.DomainType.DISCRETE)}}var VHe=function(n,t){return{type:n,name:t}};function HHe(n,t){if(1&n&&(h(0,"span",29)(1,"span",30),T(2),g(),S(3,BHe,11,5,"ng-container",31),g()),2&n){let e=t.$implicit,i=w(2);_("mat-sort-header",qr(3,VHe,i.SortType.HPARAM,e.name)),v(2),bt(e.displayName||e.name),v(1),_("ngIf",e.filter)}}function zHe(n,t){if(1&n){let e=ge();Ot(0),h(1,"button",32),I("click",function(r){return r.stopPropagation()}),P(2,"mat-icon",33),g(),h(3,"mat-menu",null,34)(5,"div",35),I("click",function(r){return r.stopPropagation()}),h(6,"mat-checkbox",36),I("change",function(){X(e);let r=w().$implicit;return Q(w(2).handleMetricIncludeUndefinedChanged(r))}),h(7,"span"),T(8,"(show empty value)"),g()()(),h(9,"div",37),I("click",function(r){return r.stopPropagation()}),h(10,"tb-range-input",38),I("rangeValuesChanged",function(r){X(e);let o=w().$implicit;return Q(w(2).handleMetricFilterChanged(o,r))}),g()()(),kt()}if(2&n){let e=it(4),i=w().$implicit;v(1),_("matMenuTriggerFor",e),Be("aria-label","Filter metric "+(i.displayName||i.tag)),v(5),_("checked",i.filter.includeUndefined),v(4),_("min",i.filter.minValue)("max",i.filter.maxValue)("lowerValue",i.filter.filterLowerValue)("upperValue",i.filter.filterUpperValue)}}var UHe=function(n,t){return{type:n,tag:t}};function jHe(n,t){if(1&n&&(h(0,"span",29)(1,"span",30),T(2),g(),S(3,zHe,11,7,"ng-container",31),g()),2&n){let e=t.$implicit,i=w(2);_("mat-sort-header",qr(3,UHe,i.SortType.METRIC,e.tag)),v(2),bt(e.displayName||e.tag),v(1),_("ngIf",e.filter)}}function GHe(n,t){if(1&n){let e=ge();h(0,"div",17)(1,"div",18),I("matSortChange",function(r){return X(e),Q(w().handleSortChange(r))}),S(2,kHe,6,8,"span",19),S(3,HHe,4,6,"span",20),S(4,jHe,4,6,"span",20),g()()}if(2&n){let e=w();v(1),_("matSortActive",e.sortOption.column),v(1),_("ngForOf",e.columns),v(1),_("ngForOf",e.hparamColumns)("ngForTrackBy",e.trackByHparamColumn),v(1),_("ngForOf",e.metricColumns)("ngForTrackBy",e.trackByMetricColumn)}}function WHe(n,t){if(1&n){let e=ge();h(0,"span")(1,"mat-checkbox",47),I("change",function(){X(e);let r=w(2).item;return Q(w().onSelectionToggle.emit(r))})("dblclick",function(){X(e);let r=w(2).item;return Q(w().onSelectionDblClick.emit(r.run.id))}),g()()}if(2&n){let e=w(2).item;v(1),_("checked",e.selected)}}function qHe(n,t){if(1&n&&P(0,"tb-experiment-alias",48),2&n){let e=w(2).item;_("alias",e.experimentAlias)("title",e.experimentName)}}function YHe(n,t){if(1&n&&(h(0,"span",30),T(1),g()),2&n){let e=w(2).item;v(1),bt(e.run.name)}}var XHe=function(n){return{"run-color-swatch":!0,"no-color":n}};function QHe(n,t){if(1&n){let e=ge();h(0,"span")(1,"button",49),I("colorPickerChange",function(r){X(e);let o=w(2).item;return Q(w().onRunColorChange.emit({runId:o.run.id,newColor:r}))}),g()()}if(2&n){let e=w(2).item;v(1),Tt("background",e.runColor),_("ngClass",In(8,XHe,!e.runColor))("colorPicker",e.runColor)("cpDialogDisplay","popup")("cpPositionOffset",-20)("cpUseRootViewContainer",!0)("cpOutputFormat","hex")}}function ZHe(n,t){if(1&n&&(h(0,"span",44),Ot(1,22),S(2,WHe,2,1,"span",25),S(3,qHe,1,2,"tb-experiment-alias",45),S(4,YHe,2,1,"span",46),S(5,QHe,2,10,"span",25),kt(),g()),2&n){let e=t.$implicit,i=w(2);_("ngClass",In(6,zne,"tb-column-"+e)),v(1),_("ngSwitch",e),v(1),_("ngSwitchCase",i.RunsTableColumn.CHECKBOX),v(1),_("ngSwitchCase",i.RunsTableColumn.EXPERIMENT_NAME),v(1),_("ngSwitchCase",i.RunsTableColumn.RUN_NAME),v(1),_("ngSwitchCase",i.RunsTableColumn.RUN_COLOR)}}function KHe(n,t){if(1&n&&(h(0,"span",50),T(1),g()),2&n){let e=t.$implicit,i=w().item;v(1),bt(i.hparams.get(e.name))}}function JHe(n,t){if(1&n&&(h(0,"span",50),T(1),g()),2&n){let e=t.$implicit,i=w().item;v(1),bt(i.metrics.get(e.tag))}}function $He(n,t){if(1&n&&(h(0,"div",41),S(1,ZHe,6,8,"span",42),S(2,KHe,2,1,"span",43),S(3,JHe,2,1,"span",43),g()),2&n){let e=t.item,i=w();Be("data-id",e.run.id),v(1),_("ngForOf",i.columns),v(1),_("ngForOf",i.hparamColumns),v(1),_("ngForOf",i.metricColumns)}}var e5e=(()=>{class n extends Cm{constructor(){super(...arguments),this.itemsPerPageLabel="Show runs:"}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),Une=(()=>{class n{constructor(){this.dataSource=new yA,this.DomainType=gn,this.RunsTableColumn=bs,this.SortType=Ic,this.onRegexFilterChange=new F,this.onSelectionToggle=new F,this.onSelectionDblClick=new F,this.onPageSelectionToggle=new F,this.onPaginationChange=new F,this.onSortChange=new F,this.onRunColorChange=new F,this.onHparamDiscreteFilterChanged=new F,this.onHparamIntervalFilterChanged=new F,this.onMetricFilterChanged=new F}ngOnChanges(){this.dataSource.data=this.pageItems}getHparamColumnId(e){return`h:${e.name}`}getMetricColumnId(e){return`m:${e.tag}`}getColumnIds(){return[...this.columns,...this.hparamColumns.map(this.getHparamColumnId),...this.metricColumns.map(this.getMetricColumnId)]}allPageItemsSelected(){return Boolean(this.pageItems.length)&&this.pageItems.every(e=>e.selected)}somePageItemsSelected(){return this.pageItems.some(e=>e.selected)}handlePageToggle(){this.onPageSelectionToggle.emit({items:this.pageItems})}handleSortChange(e){let i;switch(e.direction){case"asc":i=Ya.ASC;break;case"desc":i=Ya.DESC;break;default:i=Ya.UNSET}this.onSortChange.emit({key:e.active,direction:i})}onFilterKeyUp(e){this.onRegexFilterChange.emit(e.target.value)}tableTrackBy(e,i){return i.run.id}handleHparamIncludeUndefinedToggled(e){let{name:i,filter:r}=e;if(!r)throw new RangeError("Invariant error: require filter to exist for it to change");r.type===gn.DISCRETE?this.onHparamDiscreteFilterChanged.emit({hparamName:i,includeUndefined:!r.includeUndefined,filterValues:r.filterValues}):this.onHparamIntervalFilterChanged.emit({name:i,includeUndefined:!r.includeUndefined,filterLowerValue:r.filterLowerValue,filterUpperValue:r.filterUpperValue})}handleHparamIntervalChanged(e,i){let{name:r,filter:o}=e;if(!o)throw new RangeError("Invariant error: require filter to exist for it to change");this.onHparamIntervalFilterChanged.emit({name:r,includeUndefined:o.includeUndefined,filterLowerValue:i.lowerValue,filterUpperValue:i.upperValue})}handleHparamDiscreteChanged(e,i){let{name:r,filter:o}=e;if(!o)throw new RangeError("Invariant error: require filter to exist for it to change");if(o.type!==gn.DISCRETE)throw new RangeError(`Invariant error: expected discrete domain for ${r}`);let s=new Set([...o.filterValues]);s.has(i)?s.delete(i):s.add(i),this.onHparamDiscreteFilterChanged.emit({hparamName:r,includeUndefined:o.includeUndefined,filterValues:[...s]})}handleMetricIncludeUndefinedChanged(e){if(!e.filter)throw new RangeError("Invariant error: require filter to exist for it to change");this.onMetricFilterChanged.emit({name:e.tag,includeUndefined:!e.filter.includeUndefined,filterLowerValue:e.filter.filterLowerValue,filterUpperValue:e.filter.filterUpperValue})}handleMetricFilterChanged(e,i){if(!e.filter)throw new RangeError("Invariant error: require filter to exist for it to change");this.onMetricFilterChanged.emit({name:e.tag,includeUndefined:e.filter.includeUndefined,filterLowerValue:i.lowerValue,filterUpperValue:i.upperValue})}trackByHparamColumn(e){return e.name}trackByMetricColumn(e){return e.tag}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["runs-table-component"]],viewQuery:function(e,i){if(1&e&&(Ge(yHe,7,Me),Ge(bA,7),Ge($x,7)),2&e){let r;Se(r=Ee())&&(i.filter=r.first),Se(r=Ee())&&(i.paginator=r.first),Se(r=Ee())&&(i.sort=r.first)}},hostVars:2,hostBindings:function(e,i){2&e&&nt("flex-layout",i.useFlexibleLayout)},inputs:{experimentIds:"experimentIds",showExperimentName:"showExperimentName",columns:"columns",hparamColumns:"hparamColumns",metricColumns:"metricColumns",allItemsLength:"allItemsLength",filteredItemsLength:"filteredItemsLength",useFlexibleLayout:"useFlexibleLayout",usePagination:"usePagination",pageItems:"pageItems",loading:"loading",numSelectedItems:"numSelectedItems",sortOption:"sortOption",paginationOption:"paginationOption",regexFilter:"regexFilter"},outputs:{onRegexFilterChange:"onRegexFilterChange",onSelectionToggle:"onSelectionToggle",onSelectionDblClick:"onSelectionDblClick",onPageSelectionToggle:"onPageSelectionToggle",onPaginationChange:"onPaginationChange",onSortChange:"onSortChange",onRunColorChange:"onRunColorChange",onHparamDiscreteFilterChanged:"onHparamDiscreteFilterChanged",onHparamIntervalFilterChanged:"onHparamIntervalFilterChanged",onMetricFilterChanged:"onMetricFilterChanged"},features:[Qt([{provide:Cm,useClass:e5e}]),Gt],decls:15,vars:8,consts:[[1,"filter-row"],["placeholder","Filter runs (regex)",1,"run-filter",3,"value","keyup"],[1,"table-container"],["role","table"],[4,"ngTemplateOutlet"],["role","rowgroup",1,"rows"],[4,"ngFor","ngForOf","ngForTrackBy"],["class","loading",4,"ngIf"],["class","no-runs",4,"ngIf"],["showFirstLastButtons","",3,"pageSizeOptions","pageIndex","pageSize","length","page",4,"ngIf"],["header",""],["row",""],[4,"ngTemplateOutlet","ngTemplateOutletContext"],[1,"loading"],["mode","indeterminate","diameter","28"],[1,"no-runs"],["showFirstLastButtons","",3,"pageSizeOptions","pageIndex","pageSize","length","page"],["role","rowgroup",1,"header"],["matSort","","role","row",3,"matSortActive","matSortChange"],["role","columnheader",3,"ngClass",4,"ngFor","ngForOf"],["role","columnheader","class","column",3,"mat-sort-header",4,"ngFor","ngForOf","ngForTrackBy"],["role","columnheader",3,"ngClass"],[3,"ngSwitch"],[3,"checked","indeterminate","change",4,"ngSwitchCase"],[3,"mat-sort-header",4,"ngSwitchCase"],[4,"ngSwitchCase"],[3,"checked","indeterminate","change"],[3,"mat-sort-header"],[3,"experimentIds"],["role","columnheader",1,"column",3,"mat-sort-header"],[1,"name"],[4,"ngIf"],["mat-icon-button","",3,"matMenuTriggerFor","click"],["svgIcon","filter_alt_24px"],["filterMenu","matMenu"],["mat-menu-item","","role","menuitemcheckbox","disableRipple","",1,"filter-menu-checkbox-row",3,"click"],[3,"checked","change"],["disableRipple","","mat-menu-item","",1,"range-input-container",3,"click"],[3,"min","max","lowerValue","upperValue","rangeValuesChanged"],["mat-menu-item","","class","filter-menu-checkbox-row","role","menuitemcheckbox",3,"click",4,"ngFor","ngForOf"],["mat-menu-item","","role","menuitemcheckbox",1,"filter-menu-checkbox-row",3,"click"],["role","row"],["role","cell",3,"ngClass",4,"ngFor","ngForOf"],["role","cell","class","column",4,"ngFor","ngForOf"],["role","cell",3,"ngClass"],[3,"alias","title",4,"ngSwitchCase"],["class","name",4,"ngSwitchCase"],["title","Click to toggle run selection or double click to select only this run.",3,"checked","change","dblclick"],[3,"alias","title"],[3,"ngClass","colorPicker","cpDialogDisplay","cpPositionOffset","cpUseRootViewContainer","cpOutputFormat","colorPickerChange"],["role","cell",1,"column"]],template:function(e,i){if(1&e&&(h(0,"div",0)(1,"tb-filter-input",1),I("keyup",function(o){return i.onFilterKeyUp(o)}),g()(),h(2,"div",2)(3,"div",3),S(4,xHe,1,0,"ng-container",4),h(5,"div",5),S(6,wHe,2,4,"ng-container",6),g()(),S(7,SHe,2,0,"div",7),S(8,EHe,2,0,"div",8),S(9,THe,6,1,"div",8),g(),S(10,IHe,1,5,"mat-paginator",9),S(11,GHe,5,6,"ng-template",null,10,Wt),S(13,$He,4,4,"ng-template",null,11,Wt)),2&e){let r=it(12);v(1),Wi("value",i.regexFilter),v(3),_("ngTemplateOutlet",r),v(2),_("ngForOf",i.pageItems)("ngForTrackBy",i.tableTrackBy),v(1),_("ngIf",i.loading),v(1),_("ngIf",!i.loading&&0===i.allItemsLength),v(1),_("ngIf",!i.loading&&i.allItemsLength>0&&0===i.filteredItemsLength),v(1),_("ngIf",i.usePagination)}},dependencies:[gA,yn,nn,Fe,Lr,sr,Sr,Qu,Sp,$i,ha,En,Nc,jl,Lc,bA,tl,$x,One,dA,_A],styles:["[_nghost-%COMP%]{display:flex;flex-direction:column;font-size:13px;overflow:hidden}.filter-row[_ngcontent-%COMP%]{flex:none}.table-container[_ngcontent-%COMP%]{contain:layout paint;flex-grow:1;max-width:100%;overflow-x:auto;overflow-y:auto;will-change:transform,scroll-position}.flex-layout[_nghost-%COMP%]   .name[_ngcontent-%COMP%]{word-break:break-word;overflow-wrap:break-word}.flex-layout[_nghost-%COMP%]   mat-paginator[_ngcontent-%COMP%]{border-top:1px solid #ebebeb;padding-bottom:12px}body.dark-mode   .flex-layout[_nghost-%COMP%]   mat-paginator[_ngcontent-%COMP%]{border-top:1px solid #555}[role=table][_ngcontent-%COMP%]{display:table;width:100%}[role=table][_ngcontent-%COMP%]   .header[_ngcontent-%COMP%]{white-space:nowrap}[role=table][_ngcontent-%COMP%]   .header[_ngcontent-%COMP%]   [role=columnheader][_ngcontent-%COMP%]{background-color:#fff;position:sticky;top:0;z-index:1}body.dark-mode[_nghost-%COMP%]   [role=table][_ngcontent-%COMP%]   .header[_ngcontent-%COMP%]   [role=columnheader][_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   [role=table][_ngcontent-%COMP%]   .header[_ngcontent-%COMP%]   [role=columnheader][_ngcontent-%COMP%]{background-color:#303030}[role=table][_ngcontent-%COMP%]   [role=row][_ngcontent-%COMP%]{contain:strict;display:table-row;height:43px}[role=table][_ngcontent-%COMP%]   [role=row][_ngcontent-%COMP%]   .column[_ngcontent-%COMP%]{border-bottom:1px solid #ebebeb;display:table-cell;padding:5px;vertical-align:middle}body.dark-mode[_nghost-%COMP%]   [role=table][_ngcontent-%COMP%]   [role=row][_ngcontent-%COMP%]   .column[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   [role=table][_ngcontent-%COMP%]   [role=row][_ngcontent-%COMP%]   .column[_ngcontent-%COMP%]{border-bottom:1px solid #555}[role=table][_ngcontent-%COMP%]   [role=row][_ngcontent-%COMP%]   .column[_ngcontent-%COMP%]:first-child{padding-left:24px}[role=table][_ngcontent-%COMP%]   [role=row][_ngcontent-%COMP%]   .column[_ngcontent-%COMP%]:last-child{padding-right:24px}[role=rowgroup][_ngcontent-%COMP%]{display:table-row-group}[role=rowgroup].header[_ngcontent-%COMP%]{display:table-header-group}.loading[_ngcontent-%COMP%], .no-runs[_ngcontent-%COMP%]{align-items:center;border:0;border-bottom:1px solid #ebebeb;display:flex;height:48px;padding:0 24px}body.dark-mode[_nghost-%COMP%]   .loading[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .loading[_ngcontent-%COMP%]{border-bottom:1px solid #555}body.dark-mode[_nghost-%COMP%]   .no-runs[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .no-runs[_ngcontent-%COMP%]{border-bottom:1px solid #555}.loading[_ngcontent-%COMP%]{justify-content:center}.select-all[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]{padding-bottom:12px;padding-top:12px}.select-all-content[_ngcontent-%COMP%], .select-all-content[_ngcontent-%COMP%]   button[_ngcontent-%COMP%]{font-weight:400;line-height:1.6;text-align:left}.select-all-content[_ngcontent-%COMP%]   button[_ngcontent-%COMP%]{font-weight:500;padding:0 4px}.filter-row[_ngcontent-%COMP%]{border-bottom:1px solid #ebebeb;display:flex;align-items:center;height:48px;padding:0 16px 0 21px}body.dark-mode[_nghost-%COMP%]   .filter-row[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .filter-row[_ngcontent-%COMP%]{border-bottom:1px solid #555}.filter-row[_ngcontent-%COMP%]   tb-filter-input[_ngcontent-%COMP%]{flex-grow:1}.tb-column-checkbox[_ngcontent-%COMP%], .tb-column-run_color[_ngcontent-%COMP%]{width:20px}.tb-column-run_color[_ngcontent-%COMP%]{text-align:center}.run-color-swatch[_ngcontent-%COMP%]{border-radius:100%;border:1px solid #ebebeb;height:20px;width:20px;outline:none}.run-color-swatch.no-color[_ngcontent-%COMP%]{border-color:#c6cad1;border-width:2px}.range-input-container[_ngcontent-%COMP%]{height:auto}[_nghost-%COMP%]     mat-paginator mat-form-field{margin:0}.filter-menu-checkbox-row[_ngcontent-%COMP%]   mat-checkbox[_ngcontent-%COMP%]     label{display:flex;height:100%;align-items:center}.filter-menu-checkbox-row[_ngcontent-%COMP%]   mat-checkbox[_ngcontent-%COMP%]     label .mat-checkbox-inner-container{margin-left:0}.filter-menu-checkbox-row[_ngcontent-%COMP%]   mat-checkbox[_ngcontent-%COMP%]     label .mat-checkbox-label{overflow:hidden;text-overflow:ellipsis}body.dark-mode[_nghost-%COMP%]   mat-paginator[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   mat-paginator[_ngcontent-%COMP%]{background-color:#303030}"],changeDetection:0}),n})();function n5e(n,t){if(1&n){let e=ge();h(0,"runs-table-component",2),I("onSelectionToggle",function(r){return X(e),Q(w().onRunItemSelectionToggle(r))})("onSelectionDblClick",function(r){return X(e),Q(w().onRunSelectionDblClick(r))})("onPageSelectionToggle",function(r){return X(e),Q(w().onPageSelectionToggle(r))})("onPaginationChange",function(r){return X(e),Q(w().onPaginationChange(r))})("onRegexFilterChange",function(r){return X(e),Q(w().onRegexFilterChange(r))})("onSortChange",function(r){return X(e),Q(w().onSortChange(r))})("onRunColorChange",function(r){return X(e),Q(w().onRunColorChange(r))})("onHparamIntervalFilterChanged",function(r){return X(e),Q(w().onHparamIntervalFilterChanged(r))})("onHparamDiscreteFilterChanged",function(r){return X(e),Q(w().onHparamDiscreteFilterChanged(r))})("onMetricFilterChanged",function(r){return X(e),Q(w().onMetricFilterChanged(r))}),j(1,"async"),j(2,"async"),j(3,"async"),j(4,"async"),j(5,"async"),j(6,"async"),j(7,"async"),j(8,"async"),j(9,"async"),j(10,"async"),g()}if(2&n){let e=w();_("experimentIds",e.experimentIds)("useFlexibleLayout",e.useFlexibleLayout)("numSelectedItems",W(1,15,e.numSelectedItems$))("columns",e.columns)("hparamColumns",W(2,17,e.hparamColumns$))("metricColumns",W(3,19,e.metricColumns$))("showExperimentName",e.isExperimentNameVisible())("pageItems",W(4,21,e.pageItems$))("filteredItemsLength",W(5,23,e.filteredItemsLength$))("allItemsLength",W(6,25,e.allItemsLength$))("loading",W(7,27,e.loading$))("paginationOption",W(8,29,e.paginationOption$))("regexFilter",W(9,31,e.regexFilter$))("sortOption",W(10,33,e.sortOption$))("usePagination",e.usePagination)}}function i5e(n,t){if(1&n){let e=ge();h(0,"runs-data-table",3),I("sortDataBy",function(r){return X(e),Q(w().sortDataBy(r))})("orderColumns",function(r){return X(e),Q(w().orderColumns(r))})("onSelectionToggle",function(r){return X(e),Q(w().onRunSelectionToggle(r))})("onAllSelectionToggle",function(r){return X(e),Q(w().onAllSelectionToggle(r))})("onRunColorChange",function(r){return X(e),Q(w().onRunColorChange(r))})("onRegexFilterChange",function(r){return X(e),Q(w().onRegexFilterChange(r))})("onSelectionDblClick",function(r){return X(e),Q(w().onRunSelectionDblClick(r))})("toggleFullScreen",function(){return X(e),Q(w().toggleFullScreen())})("addColumn",function(r){return X(e),Q(w().addColumn(r))})("removeColumn",function(r){return X(e),Q(w().removeColumn(r))})("addFilter",function(r){return X(e),Q(w().addHparamFilter(r))}),j(1,"async"),j(2,"async"),j(3,"async"),j(4,"async"),j(5,"async"),j(6,"async"),j(7,"async"),j(8,"async"),g()}if(2&n){let e=w();_("headers",W(1,9,e.runsColumns$))("data",W(2,11,e.sortedRunsTableData$))("selectableColumns",W(3,13,e.selectableColumns$))("columnFilters",W(4,15,e.columnFilters$))("sortingInfo",W(5,17,e.sortingInfo$))("experimentIds",e.experimentIds)("regexFilter",W(6,19,e.regexFilter$))("isFullScreen",W(7,21,e.runsTableFullScreen$))("loading",W(8,23,e.loading$))}}var r5e=q(Ev,n=>n.state===Te.LOADING);function jne(n,t){switch(t.type){case Ic.EXPERIMENT_NAME:return[n.experimentAlias,n.run.name,n.run.id];case Ic.RUN_NAME:return[n.run.name,n.experimentAlias,n.run.id];case Ic.HPARAM:return[n.hparams.get(t.name),n.run.name,n.experimentAlias,n.run.id];case Ic.METRIC:return[n.metrics.get(t.tag),n.run.name,n.experimentAlias,n.run.id];default:throw new Error(`Not yet implemented: ${t}`)}}function Gne(n,t){return void 0===t?n.includeUndefined:n.type===gn.DISCRETE?n.filterValues.includes(t):n.type===gn.INTERVAL&&n.filterLowerValue<=t&&t<=n.filterUpperValue}var Wne=(()=>{class n{constructor(e){this.store=e,this.sortedRunsTableData$=Ht([]),this.loading$=null,this.sortingInfo$=this.store.select(WW),this.hparamColumns$=Ht([]),this.metricColumns$=Ht([]),this.useFlexibleLayout=!1,this.usePagination=!1,this.columns=[bs.RUN_NAME],this.showHparamsAndMetrics=!1,this.forceLegacyTable=!1,this.sortOption$=this.store.select(e2),this.paginationOption$=this.store.select($F),this.regexFilter$=this.store.select(vd),this.hparamsEnabled=new Ai(!1),this.runsColumns$=this.store.select(GW),this.runsTableFullScreen$=this.store.select(Lh),this.selectableColumns$=this.store.select(kN).pipe(Li(this.runsColumns$),N(([i,r])=>{let o=new Set(r.map(({name:s})=>s));return i.filter(s=>!o.has(s.name))})),this.columnFilters$=this.store.select(MQ),this.allRunsTableData$=this.store.select(ON).pipe(N(i=>i.map(r=>({...Object.fromEntries(r.hparams.entries()),id:r.run.id,run:r.run.name,experimentAlias:r.experimentAlias,selected:r.selected,color:r.runColor})))),this.ngUnsubscribe=new Ie}isExperimentNameVisible(){return this.columns.some(e=>e===bs.EXPERIMENT_NAME)}ngOnInit(){this.store.select(md).subscribe(s=>{this.hparamsEnabled.next(s)});let e=this.experimentIds.map(s=>this.getRunTableItemsForExperiment(s));this.sortedRunsTableData$=dn([this.allRunsTableData$,this.sortingInfo$]).pipe(N(([s,a])=>function(n,t){let e=[...n];return e.sort((r,o)=>{let s=r[t.name],a=o[t.name];if("experimentAlias"===t.name&&(s=s.aliasNumber,a=a.aliasNumber),s===a)return 0;if(void 0===s||void 0===a)return i(s,a);if(mne.has(typeof s)&&mne.has(typeof a)){let l=hne(s),c=hne(a);if((void 0===l||void 0===c)&&l!==c)return i(l,c,{insertUndefined:Ep.BEFORE});if(void 0!==l&&void 0!==c)return l===c?i(s.toString().slice(l.toString().length)||void 0,a.toString().slice(c.toString().length)||void 0,{insertUndefined:Ep.BEFORE}):i(l,c)}return i(s,a)}),e;function i(r,o,{insertUndefined:s}=mVe){return r===o?0:void 0===r?s===Ep.AFTER?1:-1:void 0===o?s===Ep.AFTER?-1:1:r<o==(t.order===io.ASCENDING)?-1:1}}(s,a)));let i=dn(e).pipe(N(s=>[].concat(...s)));this.allUnsortedRunTableItems$=i.pipe(ot(this.ngUnsubscribe),Ms(1)),this.allItemsLength$=this.allUnsortedRunTableItems$.pipe(N(s=>s.length));let r=this.getFilteredItems$(this.allUnsortedRunTableItems$).pipe(ot(this.ngUnsubscribe),Ms(1));this.filteredItemsLength$=r.pipe(N(s=>s.length)),this.pageItems$=this.sortedAndSlicedItems$(r),this.numSelectedItems$=this.allUnsortedRunTableItems$.pipe(N(s=>s.reduce((a,l)=>a+Number(l.selected),0)));let o=this.experimentIds.map(s=>this.store.select(r5e,{experimentId:s}));if(this.loading$=dn(o).pipe(N(s=>s.some(a=>a))),this.showHparamsAndMetrics){let s=this.store.select(Tu.getExperimentsHparamsAndMetricsSpecs,{experimentIds:this.experimentIds});this.hparamColumns$=dn([this.store.select(Tu.getHparamFilterMap,this.experimentIds),s]).pipe(N(([a,{hparams:l}])=>l.map(({name:c,displayName:d})=>{let p=a.get(c);if(!p)throw new RangeError(`Invariant error: a filter for ${c} must exist when the hparam exists`);return{displayName:d,name:c,filter:p}}))),this.metricColumns$=dn([this.store.select(Tu.getMetricFilterMap,this.experimentIds),s]).pipe(N(([a,{metrics:l}])=>l.map(({tag:c,displayName:d})=>{let u=a.get(c);if(!u)throw new RangeError(`Invariant error: a filter for ${c} must exist when the metric exists`);return{displayName:d,tag:c,filter:u}})))}this.columns.includes(bs.CHECKBOX)&&this.store.select(No).pipe(ot(this.ngUnsubscribe),Yn((a,l)=>Fo(a,l)),Jn(()=>i.pipe(ke(a=>a.length>500),Yt(1)))).subscribe(()=>{this.store.dispatch(Jh({localizedMessage:"The number of runs exceeds 500. New runs are unselected for performance reasons."}))}),this.store.dispatch(Vh({experimentIds:this.experimentIds}))}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}getFilteredItems$(e){return dn([e,this.store.select(vd)]).pipe(N(([i,r])=>{if(!r)return i;let o=this.columns.includes(bs.EXPERIMENT_NAME);return i.filter(s=>Qh({runName:s.run.name,experimentAlias:s.experimentAlias},r,o))}),Jn(i=>this.showHparamsAndMetrics?dn(this.store.select(Tu.getHparamFilterMap,this.experimentIds),this.store.select(Tu.getMetricFilterMap,this.experimentIds)).pipe(N(([r,o])=>i.filter(({hparams:s,metrics:a})=>[...r.entries()].every(([c,d])=>Gne(d,s.get(c)))&&[...o.entries()].every(([c,d])=>Gne(d,a.get(c)))))):Ht(i)))}sortedAndSlicedItems$(e){let i=dn([e,this.store.select(e2)]).pipe(N(([o,s])=>function(n,t){let e=t.key,i=[...n];return null===e||t.direction===Ya.UNSET||i.sort((r,o)=>{let s=jne(r,e),a=jne(o,e);if(s.length!==a.length)throw new Error(`Invariant error: a given sort should result in same number of items: ${t}`);for(let l=0;l<s.length;l++){let c=s[l],d=a[l];if(c!==d){if(void 0===c||void 0===d)return void 0===d?-1:1;if(typeof c!=typeof d)throw new Error(`Cannot compare values of different types: ${typeof c} vs. ${typeof d}`);return c<d==(t.direction===Ya.ASC)?-1:1}}return 0}),i}(o,s)));return dn([i,this.store.select($F)]).pipe(N(([o,s])=>{if(!this.usePagination)return o.slice();let{pageSize:a,pageIndex:l}=s;return o.slice(l*a,(l+1)*a)}),qn([]))}sortDataBy(e){this.store.dispatch(AS({sortingInfo:e}))}getRunTableItemsForExperiment(e){return dn([this.store.select(Du,{experimentId:e}),this.store.select(BS,{experimentId:e}),this.store.select(Iu),this.store.select(Au),this.store.select(za)]).pipe(N(([i,r,o,s,a])=>i.map(l=>{let c=new Map;(l.hparams||[]).forEach(u=>{c.set(u.name,u.value)});let d=new Map;return(l.metrics||[]).forEach(u=>{d.set(u.tag,u.value)}),{run:l,experimentName:r?.name||"",experimentAlias:a[e],selected:Boolean(o&&o.get(l.id)),runColor:s[l.id],hparams:c,metrics:d}})))}onRunItemSelectionToggle(e){this.store.dispatch(cv({runId:e.run.id}))}onRunSelectionToggle(e){this.store.dispatch(cv({runId:e}))}onRunSelectionDblClick(e){this.store.dispatch(wS({runId:e}))}onAllSelectionToggle(e){this.store.dispatch(dv({runIds:e}))}onPageSelectionToggle(e){let{items:i}=e,r=i.map(({run:o})=>o.id);this.store.dispatch(dv({runIds:r}))}onPaginationChange(e){if(!this.usePagination)throw new Error("Pagination events cannot be dispatched when pagination is disabled");let{pageIndex:i,pageSize:r}=e;this.store.dispatch(SS({pageIndex:i,pageSize:r}))}onSortChange(e){this.store.dispatch(ES(e))}onRegexFilterChange(e){this.store.dispatch(uv({regexString:e}))}onRunColorChange({runId:e,newColor:i}){this.store.dispatch(TS({runId:e,newColor:i}))}onHparamDiscreteFilterChanged(e){let{hparamName:i,filterValues:r,includeUndefined:o}=e;this.store.dispatch(Ec.hparamsDiscreteHparamFilterChanged({experimentIds:this.experimentIds,hparamName:i,filterValues:r,includeUndefined:o}))}onHparamIntervalFilterChanged(e){let{name:i,filterLowerValue:r,filterUpperValue:o,includeUndefined:s}=e;this.store.dispatch(Ec.hparamsIntervalHparamFilterChanged({experimentIds:this.experimentIds,hparamName:i,filterLowerValue:r,filterUpperValue:o,includeUndefined:s}))}onMetricFilterChanged(e){let{name:i,includeUndefined:r,filterLowerValue:o,filterUpperValue:s}=e;this.store.dispatch(Ec.hparamsMetricFilterChanged({experimentIds:this.experimentIds,metricTag:i,includeUndefined:r,filterLowerValue:o,filterUpperValue:s}))}toggleFullScreen(){this.store.dispatch(bS())}addColumn({header:e,index:i}){e.enabled=!0,this.store.dispatch(DS({header:{...e,enabled:!0},index:i}))}removeColumn(e){this.store.dispatch(zh({header:e}))}orderColumns(e){this.store.dispatch(IS({newHeaderOrder:e}))}useDataTable(){return this.hparamsEnabled.value&&!this.forceLegacyTable}addHparamFilter(e){this.store.dispatch(Ec.dashboardHparamFilterAdded({name:e.header.name,filter:e.value}))}}return n.\u0275fac=function(e){return new(e||n)(C(Ae))},n.\u0275cmp=O({type:n,selectors:[["runs-table"]],hostVars:2,hostBindings:function(e,i){2&e&&nt("flex-layout",i.useFlexibleLayout)},inputs:{useFlexibleLayout:"useFlexibleLayout",usePagination:"usePagination",columns:"columns",experimentIds:"experimentIds",showHparamsAndMetrics:"showHparamsAndMetrics",forceLegacyTable:"forceLegacyTable"},decls:2,vars:2,consts:[[3,"experimentIds","useFlexibleLayout","numSelectedItems","columns","hparamColumns","metricColumns","showExperimentName","pageItems","filteredItemsLength","allItemsLength","loading","paginationOption","regexFilter","sortOption","usePagination","onSelectionToggle","onSelectionDblClick","onPageSelectionToggle","onPaginationChange","onRegexFilterChange","onSortChange","onRunColorChange","onHparamIntervalFilterChanged","onHparamDiscreteFilterChanged","onMetricFilterChanged",4,"ngIf"],[3,"headers","data","selectableColumns","columnFilters","sortingInfo","experimentIds","regexFilter","isFullScreen","loading","sortDataBy","orderColumns","onSelectionToggle","onAllSelectionToggle","onRunColorChange","onRegexFilterChange","onSelectionDblClick","toggleFullScreen","addColumn","removeColumn","addFilter",4,"ngIf"],[3,"experimentIds","useFlexibleLayout","numSelectedItems","columns","hparamColumns","metricColumns","showExperimentName","pageItems","filteredItemsLength","allItemsLength","loading","paginationOption","regexFilter","sortOption","usePagination","onSelectionToggle","onSelectionDblClick","onPageSelectionToggle","onPaginationChange","onRegexFilterChange","onSortChange","onRunColorChange","onHparamIntervalFilterChanged","onHparamDiscreteFilterChanged","onMetricFilterChanged"],[3,"headers","data","selectableColumns","columnFilters","sortingInfo","experimentIds","regexFilter","isFullScreen","loading","sortDataBy","orderColumns","onSelectionToggle","onAllSelectionToggle","onRunColorChange","onRegexFilterChange","onSelectionDblClick","toggleFullScreen","addColumn","removeColumn","addFilter"]],template:function(e,i){1&e&&(S(0,n5e,11,35,"runs-table-component",0),S(1,i5e,9,25,"runs-data-table",1)),2&e&&(_("ngIf",!i.useDataTable()),v(1),_("ngIf",i.useDataTable()))},dependencies:[Fe,Sne,Une,ct],styles:["[_nghost-%COMP%] {\n        position: relative;\n      }\n\n      .flex-layout[_nghost-%COMP%] {\n        display: flex;\n      }\n\n      .flex-layout[_nghost-%COMP%]    > runs-table-component[_ngcontent-%COMP%] {\n        width: 100%;\n      }\n\n      .flex-layout[_nghost-%COMP%]    > tb-data-table[_ngcontent-%COMP%] {\n        overflow-y: scroll;\n        width: 100%;\n      }"],changeDetection:0}),n})(),qne=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["runs-selector-component"]],inputs:{experimentIds:"experimentIds",showHparamsAndMetrics:"showHparamsAndMetrics",columns:"columns"},decls:1,vars:4,consts:[[3,"useFlexibleLayout","columns","experimentIds","showHparamsAndMetrics"]],template:function(e,i){1&e&&P(0,"runs-table",0),2&e&&_("useFlexibleLayout",!0)("columns",i.columns)("experimentIds",i.experimentIds)("showHparamsAndMetrics",i.showHparamsAndMetrics)},dependencies:[Wne],styles:["runs-table[_ngcontent-%COMP%] {\n        height: 100%;\n      }"],changeDetection:0}),n})(),Yne=(()=>{class n{constructor(e){this.store=e,this.experimentIds$=this.store.select(lr).pipe(N(i=>i??[])),this.columns$=this.store.select(lr).pipe(N(i=>[bs.CHECKBOX,bs.RUN_NAME,i&&i.length>1?bs.EXPERIMENT_NAME:null,bs.RUN_COLOR].filter(r=>null!==r)))}}return n.\u0275fac=function(e){return new(e||n)(C(Ae))},n.\u0275cmp=O({type:n,selectors:[["runs-selector"]],inputs:{showHparamsAndMetrics:"showHparamsAndMetrics"},decls:3,vars:7,consts:[[3,"experimentIds","columns","showHparamsAndMetrics"]],template:function(e,i){1&e&&(P(0,"runs-selector-component",0),j(1,"async"),j(2,"async")),2&e&&_("experimentIds",W(1,3,i.experimentIds$))("columns",W(2,5,i.columns$))("showHparamsAndMetrics",i.showHparamsAndMetrics)},dependencies:[qne,ct],encapsulation:2,changeDetection:0}),n})();function c5e(n,t){1&n&&P(0,"metrics-main-view",2)}var Xne=(()=>{class n{constructor(e){this.store=e,this.showHparamsAndMetrics$=this.store.select(md),this.runsTableFullScreen$=this.store.select(Lh)}}return n.\u0275fac=function(e){return new(e||n)(C(Ae))},n.\u0275cmp=O({type:n,selectors:[["metrics-dashboard"]],decls:5,vars:6,consts:[["sidebar","",3,"showHparamsAndMetrics"],["main","",4,"ngIf"],["main",""]],template:function(e,i){1&e&&(h(0,"tb-dashboard-layout"),P(1,"runs-selector",0),j(2,"async"),S(3,c5e,1,0,"metrics-main-view",1),j(4,"async"),g()),2&e&&(v(1),_("showHparamsAndMetrics",W(2,2,i.showHparamsAndMetrics$)),v(2),_("ngIf",!W(4,4,i.runsTableFullScreen$)))},dependencies:[Fe,aQ,fne,Yne,ct],styles:["[_nghost-%COMP%]{contain:strict;display:flex;flex-direction:column;height:100%;justify-content:stretch;overflow:hidden}.notice[_ngcontent-%COMP%]{background-color:rgba(255,245,157,.85);border-bottom:1px solid #ffeb3b;color:#212121;display:block;flex:0 0}tb-dashboard-layout[_ngcontent-%COMP%]{flex:1 1;overflow:hidden}nav[_ngcontent-%COMP%]{background-color:#fff;border-right:1px solid #ebebeb;flex:none;width:340px}body.dark-mode[_nghost-%COMP%]   nav[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   nav[_ngcontent-%COMP%]{background-color:#303030;border-right-color:#555}metrics-main-view[_ngcontent-%COMP%]{flex:1 1}"],changeDetection:0}),n})(),OV=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Pe,di,ci]}),n})(),xA=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Pe]}),n})(),CA=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Pe,di]}),n})(),Qne=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Pe,di,$a,ci,xg]}),n})(),Zne=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Pe]}),n})(),h_=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Pe,qu]}),n})(),g_=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Pe,lA,di]}),n})(),Kne=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Pe,Fc,g_,h_]}),n})(),MA=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Pe,di,ci,nl,CA,Zne,Qne,Kne]}),n})(),Jne=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({}),n})(),__=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Pe,Jne]}),n})(),$ne=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[bne,Pe,MA,__,g_,Ef,ci,Fc,hg,$a,di,ju,Rne,nl,kne,Vne,h_,Q1]}),n})(),eie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Pe,$ne]}),n})(),b_=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({}),n})(),wA=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Pe,di]}),n})(),tie=(()=>{class n{constructor(){this.onTimeSelectionChanged=new F,this.onTimeSelectionToggled=new F,this.axisDirection=fs.VERTICAL,this.cardFobHelper={getStepHigherThanAxisPosition:this.getStepHigherThanAxisPosition.bind(this),getStepLowerThanAxisPosition:this.getStepLowerThanAxisPosition.bind(this)}}getAxisPositionFromStartStep(){return this.temporalScale(this.timeSelection.start.step)}getAxisPositionFromEndStep(){return null===this.timeSelection.end?null:this.temporalScale(this.timeSelection.end.step)}getHighestStep(){return this.steps[this.steps.length-1]}getLowestStep(){return this.steps[0]}getStepHigherThanAxisPosition(e){let i=0;for(;e>this.temporalScale(this.steps[i])&&i<this.steps.length-1;)i++;return this.steps[i]}getStepLowerThanAxisPosition(e){let i=this.steps.length-1;for(;e<this.temporalScale(this.steps[i])&&i>0;)i--;return this.steps[i]}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["histogram-card-fob-controller"]],inputs:{steps:"steps",timeSelection:"timeSelection",temporalScale:"temporalScale"},outputs:{onTimeSelectionChanged:"onTimeSelectionChanged",onTimeSelectionToggled:"onTimeSelectionToggled"},decls:1,vars:7,consts:[[3,"axisDirection","timeSelection","startStepAxisPosition","endStepAxisPosition","highestStep","lowestStep","cardFobHelper","onTimeSelectionChanged","onTimeSelectionToggled"]],template:function(e,i){1&e&&(h(0,"card-fob-controller",0),I("onTimeSelectionChanged",function(o){return i.onTimeSelectionChanged.emit(o)})("onTimeSelectionToggled",function(){return i.onTimeSelectionToggled.emit()}),g()),2&e&&_("axisDirection",i.axisDirection)("timeSelection",i.timeSelection)("startStepAxisPosition",i.getAxisPositionFromStartStep())("endStepAxisPosition",i.getAxisPositionFromEndStep())("highestStep",i.getHighestStep())("lowestStep",i.getLowestStep())("cardFobHelper",i.cardFobHelper)},dependencies:[pA],encapsulation:2,changeDetection:0}),n})(),nie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[wA,Pe,Yu,b_]}),n})();ib(fA,[nn,Fe,Of,qg,tie],[]);var v_=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Pe]}),n})(),SA=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Pe,__]}),n})(),y_=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Pe,di]}),n})(),iie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Pe,nie,ci,di,nl,SA,v_,y_]}),n})(),EA=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({}),n})(),rie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Pe,EA,ci,di,nl,qu,SA,v_,y_]}),n})(),oie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Pe,Co,ci,di,$a,ju]}),n})(),TA=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Pe,Co,oie,Yu]}),n})(),sie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Pe,EA,xg,ci,hg,$a,Ja,qS]}),n})(),aie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Pe,MA]}),n})(),lie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[wA,Pe,TA]}),n})(),cie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Pe,sie,__,b_,TA,ci,di,ju,nl,Yu,aie,lie,v_,y_]}),n})(),die=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Pe,rie,cie,iie,b_]}),n})(),uie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Pe,Ja]}),n})(),DA=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Pe,uie,ci,VT,Fc,di,Ja,qu,Wh,h_]}),n})(),pie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Pe,CA,Fc,vE,di,ci]}),n})(),fie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[die,Pe,xA,g_,lA,ci,VT,di,$a,nl,DA,pie,Md]}),n})(),mie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Pe,xA,OV,fie,di,DA,eie]}),n})(),p5e="Max pin limit exceeded. Remove existing pins before adding more. See https://github.com/tensorflow/tensorboard/issues/4242";function f5e(){return[{actionCreator:Hg,alertFromAction:n=>{let{wasPinned:t,canCreateNewPins:e}=n;return t||e?null:{localizedMessage:p5e}}}]}function m5e(){return q(bd,n=>({scalarSmoothing:n}))}function h5e(){return q(gf,n=>({ignoreOutliers:n}))}function g5e(){return q(hf,n=>({tooltipSort:String(n)}))}function _5e(){return q(a1,n=>({timeSeriesSettingsPaneOpened:n}))}function b5e(){return q(Xh,n=>({timeSeriesCardMinWidth:n}))}function v5e(){return q(xv,n=>({stepSelectorEnabled:n}))}function y5e(){return q(Su,n=>({rangeSelectionEnabled:n}))}function x5e(){return q(wu,n=>({linkedTimeEnabled:n}))}function C5e(){return q(Cv,n=>({singleSelectionHeaders:n}))}function M5e(){return q(Mv,n=>({rangeSelectionHeaders:n}))}var hie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({providers:[{provide:DN,useFactory:rQ,deps:[IN]},{provide:IN,useValue:XS}],imports:[Pe,Ih,Ga,Bc.forPlugin(gv,Xne),qS,mie,Tr.forFeature(YS,tQ,DN),to.forFeature([iQ]),Sc.registerAlertActions(f5e),Ki.defineGlobalSetting(m5e),Ki.defineGlobalSetting(h5e),Ki.defineGlobalSetting(g5e),Ki.defineGlobalSetting(_5e),Ki.defineGlobalSetting(b5e),Ki.defineGlobalSetting(v5e),Ki.defineGlobalSetting(y5e),Ki.defineGlobalSetting(x5e),Ki.defineGlobalSetting(C5e),Ki.defineGlobalSetting(M5e)]}),n})(),gie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[YX,hie]}),n})(),Xd=(()=>(function(n){n.CUSTOM_ELEMENT="CUSTOM_ELEMENT",n.IFRAME="IFRAME",n.NG_COMPONENT="NG_COMPONENT",n.NONE="NONE"}(Xd||(Xd={})),Xd))(),w5e=["pluginContainer"],S5e=["ngPluginContainer"];function E5e(n,t){1&n&&li(0)}function T5e(n,t){if(1&n&&(Ot(0),S(1,E5e,1,0,"ng-container",9),kt()),2&n){let e=w(2),i=it(6);v(1),_("ngTemplateOutlet",e.environmentFailureNotFoundTemplate?e.environmentFailureNotFoundTemplate:i)}}function D5e(n,t){1&n&&li(0)}function I5e(n,t){if(1&n&&(Ot(0),S(1,D5e,1,0,"ng-container",9),kt()),2&n){let e=w(2),i=it(6);v(1),_("ngTemplateOutlet",e.environmentFailurePermissionDeniedTemplate?e.environmentFailurePermissionDeniedTemplate:i)}}function A5e(n,t){1&n&&li(0)}function R5e(n,t){if(1&n&&(Ot(0),S(1,A5e,1,0,"ng-container",9),kt()),2&n){let e=w(2),i=it(6);v(1),_("ngTemplateOutlet",e.environmentFailureUnknownTemplate?e.environmentFailureUnknownTemplate:i)}}function P5e(n,t){if(1&n&&(Ot(0),h(1,"h3",10),T(2," There\u2019s no dashboard by the name of \u201c"),h(3,"code"),T(4),g(),T(5,"\u201d. "),g(),h(6,"p"),T(7,"You can select a dashboard from the list above."),g(),h(8,"p"),li(9,11),g(),kt()),2&n){let e=w(2),i=it(8);v(4),bt(e.activePluginId),v(5),_("ngTemplateOutlet",i)}}function O5e(n,t){if(1&n&&(Ot(0),h(1,"h3",12),T(2," No dashboards are active for the current data set. "),g(),h(3,"p"),T(4,"Probable causes:"),g(),h(5,"ul")(6,"li"),T(7,"You haven\u2019t written any data to your event files."),g(),h(8,"li"),T(9,"TensorBoard can\u2019t find your event files."),g()(),T(10," If you\u2019re new to using TensorBoard, and want to find out how to add data and set up your event files, check out the "),h(11,"a",13),T(12,"README"),g(),T(13," and perhaps the "),h(14,"a",14),T(15,"TensorBoard tutorial"),g(),T(16,". "),h(17,"p"),T(18," If you think TensorBoard is configured properly, please see "),h(19,"a",15),T(20,"the section of the README devoted to missing data problems"),g(),T(21," and consider filing an issue on GitHub. "),g(),h(22,"p"),li(23,11),g(),kt()),2&n){w(2);let e=it(8);v(23),_("ngTemplateOutlet",e)}}function k5e(n,t){if(1&n&&(h(0,"div",6)(1,"div",7),S(2,T5e,2,1,"ng-container",8),S(3,I5e,2,1,"ng-container",8),S(4,R5e,2,1,"ng-container",8),S(5,P5e,10,2,"ng-container",8),S(6,O5e,24,1,"ng-container",8),g()()),2&n){let e=w();_("ngSwitch",e.pluginLoadState),v(2),_("ngSwitchCase",e.PluginLoadState.ENVIRONMENT_FAILURE_NOT_FOUND),v(1),_("ngSwitchCase",e.PluginLoadState.ENVIRONMENT_FAILURE_PERMISSION_DENIED),v(1),_("ngSwitchCase",e.PluginLoadState.ENVIRONMENT_FAILURE_UNKNOWN),v(1),_("ngSwitchCase",e.PluginLoadState.UNKNOWN_PLUGIN_ID),v(1),_("ngSwitchCase",e.PluginLoadState.NO_ENABLED_PLUGINS)}}function F5e(n,t){if(1&n&&(h(0,"h3",16),T(1,"Data could not be loaded."),g(),h(2,"p"),T(3,"The TensorBoard server may be down or inaccessible."),g(),h(4,"p"),li(5,11),g()),2&n){w();let e=it(8);v(5),_("ngTemplateOutlet",e)}}function N5e(n,t){if(1&n&&(h(0,"p",19)(1,"i"),T(2,"Log directory: "),h(3,"span"),T(4),g()()()),2&n){let e=w(2);v(4),bt(e.dataLocation)}}function L5e(n,t){if(1&n&&(h(0,"span",17),T(1),j(2,"date"),g(),S(3,N5e,5,1,"p",18)),2&n){let e=w();v(1),He("Last reload: ",qp(2,2,e.lastUpdated,"medium"),""),v(2),_("ngIf",e.dataLocation)}}var B5e=function(n){return{plugins:!0,"is-first-party-plugin":n}},cl=(()=>(function(n){n[n.ENVIRONMENT_FAILURE_NOT_FOUND=0]="ENVIRONMENT_FAILURE_NOT_FOUND",n[n.ENVIRONMENT_FAILURE_PERMISSION_DENIED=1]="ENVIRONMENT_FAILURE_PERMISSION_DENIED",n[n.ENVIRONMENT_FAILURE_UNKNOWN=2]="ENVIRONMENT_FAILURE_UNKNOWN",n[n.NO_ENABLED_PLUGINS=3]="NO_ENABLED_PLUGINS",n[n.UNKNOWN_PLUGIN_ID=4]="UNKNOWN_PLUGIN_ID",n[n.LOADED=5]="LOADED",n[n.LOADING=6]="LOADING"}(cl||(cl={})),cl))(),_ie=(()=>{class n{constructor(e,i,r){this.componentFactoryResolver=e,this.pluginRegistry=i,this.pluginApiHost=r,this.PluginLoadState=cl,this.LoadingMechanismType=Xd,this.pluginInstances=new Map}ngOnChanges(e){if(!this.isFeatureFlagsLoaded||!this.activeKnownPlugin||this.settingsLoadState===Te.NOT_LOADED||this.settingsLoadState===Te.LOADING)return;let i=Boolean(this.activeKnownPlugin&&!this.pluginInstances.has(this.activeKnownPlugin.id));if(e.activeKnownPlugin||e.isFeatureFlagsLoaded||e.settingsLoadState){let r=e.activeKnownPlugin?.previousValue;if(r&&r.id!==this.activeKnownPlugin.id&&this.hidePlugin(r),i){let o=this.createPlugin(this.activeKnownPlugin);o&&this.pluginInstances.set(this.activeKnownPlugin.id,o)}else this.showPlugin(this.activeKnownPlugin)}(i||e.lastUpdated)&&this.reload(this.activeKnownPlugin,i)}hidePlugin(e){if(!this.pluginInstances.has(e.id))return;let i=this.pluginInstances.get(e.id);Object.assign(i.style,{maxHeight:0,overflow:"hidden",visibility:"hidden",position:"absolute"})}showPlugin(e){if(!this.pluginInstances.has(e.id))return;let i=this.pluginInstances.get(e.id);Object.assign(i.style,{maxHeight:null,overflow:null,visibility:null,position:null})}createPlugin(e){let i=null;switch(e.loading_mechanism.type){case Xd.CUSTOM_ELEMENT:i=document.createElement(e.loading_mechanism.element_name),i.reloadOnReady=!1,i.featureFlags=this.featureFlags,this.pluginsContainer.nativeElement.appendChild(i);break;case Xd.IFRAME:if(!this.pluginApiHost)throw Error(`IFRAME-based plugins not supported: ${e.id}`);i=document.createElement("iframe"),i.setAttribute("src",`data/plugin_entry.html?name=${e.id}`),this.pluginApiHost.registerPluginIframe(i,e.id),this.pluginsContainer.nativeElement.appendChild(i);break;case Xd.NG_COMPONENT:let r=this.pluginRegistry.getComponent(e.id);if(r){let o=this.componentFactoryResolver.resolveComponentFactory(r);i=this.ngPluginContainer.createComponent(o).location.nativeElement}else console.error(`No registered Angular component for plugin: ${e.id}`);break;case Xd.NONE:break;default:console.error("Unexpected plugin")}return i}reload(e,i){if(!i&&e.disable_reload)return;let r=this.pluginInstances.get(e.id);r&&r.reload&&r.reload()}}return n.\u0275fac=function(e){return new(e||n)(C(fo),C(Bc),C(I1,8))},n.\u0275cmp=O({type:n,selectors:[["plugins-component"]],viewQuery:function(e,i){if(1&e&&(Ge(w5e,7,Me),Ge(S5e,7,si)),2&e){let r;Se(r=Ee())&&(i.pluginsContainer=r.first),Se(r=Ee())&&(i.ngPluginContainer=r.first)}},inputs:{activePluginId:"activePluginId",activeKnownPlugin:"activeKnownPlugin",pluginLoadState:"pluginLoadState",dataLocation:"dataLocation",isFeatureFlagsLoaded:"isFeatureFlagsLoaded",settingsLoadState:"settingsLoadState",featureFlags:"featureFlags",lastUpdated:"lastUpdated",environmentFailureNotFoundTemplate:"environmentFailureNotFoundTemplate",environmentFailurePermissionDeniedTemplate:"environmentFailurePermissionDeniedTemplate",environmentFailureUnknownTemplate:"environmentFailureUnknownTemplate"},features:[Gt],decls:9,vars:4,consts:[[3,"ngClass"],["pluginContainer",""],["ngPluginContainer",""],["class","warning",3,"ngSwitch",4,"ngIf"],["environmentFailureDefaultTemplate",""],["dateAndDataLocation",""],[1,"warning",3,"ngSwitch"],[1,"warning-message"],[4,"ngSwitchCase"],[4,"ngTemplateOutlet"],[1,"unknown-plugin"],[3,"ngTemplateOutlet"],[1,"no-active-plugin"],["href","https://github.com/tensorflow/tensorboard/blob/master/README.md"],["href","https://www.tensorflow.org/get_started/summaries_and_tensorboard"],["href","https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"],[1,"environment-not-loaded"],[1,"last-reload-time"],["class","data-location",4,"ngIf"],[1,"data-location"]],template:function(e,i){1&e&&(h(0,"div",0,1),li(2,null,2),g(),S(4,k5e,7,6,"div",3),S(5,F5e,6,1,"ng-template",null,4,Wt),S(7,L5e,4,5,"ng-template",null,5,Wt)),2&e&&(_("ngClass",In(2,B5e,(null==i.activeKnownPlugin?null:i.activeKnownPlugin.loading_mechanism.type)!==i.LoadingMechanismType.IFRAME)),v(4),_("ngIf",i.pluginLoadState!==i.PluginLoadState.LOADED&&i.pluginLoadState!==i.PluginLoadState.LOADING))},dependencies:[yn,Fe,Lr,sr,Sr,gh],styles:["[_nghost-%COMP%]{background-color:#fff;color:#212121;display:block;position:relative}body.dark-mode   [_nghost-%COMP%]   .plugins.is-first-party-plugin[_ngcontent-%COMP%]{background-color:#303030;color:#fff}.plugins[_ngcontent-%COMP%]{height:100%;position:relative}.warning[_ngcontent-%COMP%]{background:#fff;bottom:0;left:0;position:absolute;right:0;top:0}body.dark-mode[_nghost-%COMP%]   .warning[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .warning[_ngcontent-%COMP%]{background:#303030}.warning-message[_ngcontent-%COMP%]{color:#212121;margin:80px auto 0;max-width:540px}body.dark-mode[_nghost-%COMP%]   .warning-message[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .warning-message[_ngcontent-%COMP%]{color:#fff}.last-reload-time[_ngcontent-%COMP%]{font-style:italic}.plugins[_ngcontent-%COMP%]     iframe{border:0;display:block;height:100%;width:100%}"],changeDetection:0}),n})(),V5e=q(Nh,Wo,(n,t)=>t&&n[t]?Object.assign({id:t},n[t]):null),IA=(()=>{class n{constructor(e){this.store=e,this.activeKnownPlugin$=this.store.select(V5e),this.activePluginId$=this.store.select(Wo),this.pluginLoadState$=dn(this.activeKnownPlugin$,this.activePluginId$,this.store.select(yS)).pipe(N(([i,r,o])=>null!==o.failureCode?o.failureCode===ja.NOT_FOUND?cl.ENVIRONMENT_FAILURE_NOT_FOUND:o.failureCode===ja.PERMISSION_DENIED?cl.ENVIRONMENT_FAILURE_PERMISSION_DENIED:cl.ENVIRONMENT_FAILURE_UNKNOWN:null!==i?cl.LOADED:null===o.lastLoadedTimeInMs&&o.state===Te.LOADING?cl.LOADING:r?cl.UNKNOWN_PLUGIN_ID:cl.NO_ENABLED_PLUGINS)),this.lastLoadedTimeInMs$=this.store.select(Fh),this.dataLocation$=this.store.select(xS).pipe(N(i=>i.data_location)),this.isFeatureFlagsLoaded$=this.store.select(vu),this.featureFlags$=this.store.select(ks),this.settingsLoadState$=this.store.select(Bs.getSettingsLoadState)}}return n.\u0275fac=function(e){return new(e||n)(C(Ae))},n.\u0275cmp=O({type:n,selectors:[["plugins"]],inputs:{environmentFailureNotFoundTemplate:"environmentFailureNotFoundTemplate",environmentFailurePermissionDeniedTemplate:"environmentFailurePermissionDeniedTemplate",environmentFailureUnknownTemplate:"environmentFailureUnknownTemplate"},decls:9,vars:27,consts:[[3,"activeKnownPlugin","activePluginId","dataLocation","lastUpdated","pluginLoadState","isFeatureFlagsLoaded","settingsLoadState","featureFlags","environmentFailureNotFoundTemplate","environmentFailurePermissionDeniedTemplate","environmentFailureUnknownTemplate"]],template:function(e,i){1&e&&(P(0,"plugins-component",0),j(1,"async"),j(2,"async"),j(3,"async"),j(4,"async"),j(5,"async"),j(6,"async"),j(7,"async"),j(8,"async")),2&e&&_("activeKnownPlugin",W(1,11,i.activeKnownPlugin$))("activePluginId",W(2,13,i.activePluginId$))("dataLocation",W(3,15,i.dataLocation$))("lastUpdated",W(4,17,i.lastLoadedTimeInMs$))("pluginLoadState",W(5,19,i.pluginLoadState$))("isFeatureFlagsLoaded",W(6,21,i.isFeatureFlagsLoaded$))("settingsLoadState",W(7,23,i.settingsLoadState$))("featureFlags",W(8,25,i.featureFlags$))("environmentFailureNotFoundTemplate",i.environmentFailureNotFoundTemplate)("environmentFailurePermissionDeniedTemplate",i.environmentFailurePermissionDeniedTemplate)("environmentFailureUnknownTemplate",i.environmentFailureUnknownTemplate)},styles:["plugins-component[_ngcontent-%COMP%] { height: 100%; }"],changeDetection:0}),n})(),AA=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Ga,Pe,Bc]}),n})();ib(IA,[_ie],[ct]);var bie=(()=>{class n{constructor(e,i){this.store=e,this.document=i,this.onVisibilityChange=this.onVisibilityChangeImpl.bind(this),this.reloadEnabled$=this.store.pipe(un(Bs.getReloadEnabled)),this.reloadPeriodInMs$=this.store.pipe(un(Bs.getReloadPeriodInMs)),this.reloadTimerId=null,this.missedAutoReload=!1,this.ngUnsubscribe=new Ie}ngOnInit(){this.document.addEventListener("visibilitychange",this.onVisibilityChange),dn(this.reloadEnabled$.pipe(Yn()),this.reloadPeriodInMs$.pipe(Yn())).pipe(ot(this.ngUnsubscribe)).subscribe(([e,i])=>{this.cancelLoad(),e&&this.load(i)})}onVisibilityChangeImpl(){"visible"===this.document.visibilityState&&this.missedAutoReload&&(this.missedAutoReload=!1,this.store.dispatch(cs()))}load(e){this.reloadTimerId=setTimeout(()=>{"visible"===this.document.visibilityState?this.store.dispatch(cs()):this.missedAutoReload=!0,this.load(e)},e)}cancelLoad(){null!==this.reloadTimerId&&clearTimeout(this.reloadTimerId),this.reloadTimerId=null}ngOnDestroy(){this.cancelLoad(),this.document.removeEventListener("visibilitychange",this.onVisibilityChange),this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}}return n.\u0275fac=function(e){return new(e||n)(C(Ae),C(Lt))},n.\u0275cmp=O({type:n,selectors:[["reloader"]],decls:0,vars:0,template:function(e,i){},encapsulation:2,changeDetection:0}),n})(),vie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=O({type:n,selectors:[["tensorboard-wrapper-component"]],decls:2,vars:0,consts:[[1,"plugins"]],template:function(e,i){1&e&&P(0,"plugins",0)(1,"reloader")},dependencies:[IA,bie],styles:["[_nghost-%COMP%] {\n        display: flex;\n        flex-direction: column;\n        height: 100%;\n      }\n\n      .plugins[_ngcontent-%COMP%] {\n        flex: 1 1;\n        overflow: auto;\n        position: relative;\n      }"],changeDetection:0}),n})(),yie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),kV="smoothing",FV="runColorGroup",NV="tagFilter",LV="runFilter",BV="regex:",RA=class extends yie{getMetricsPinnedCards(t){return dn([t.select(yv),t.select(xW)]).pipe(N(([e,i])=>{if(!e.length&&!i.length)return[];let o=[...e.map(({plugin:s,tag:a,sample:l,runId:c})=>{let d={plugin:s,tag:a};return pa(s)&&(d.runId=c),ua(s)&&(d.sample=l),d}),...i];return[{key:"pinnedCards",value:JSON.stringify(o)}]}))}serializeStateToQueryParams(t){return dn([this.getMetricsPinnedCards(t),t.select(kl).pipe(N(e=>e?[{key:NV,value:e}]:[])),dn([t.select(iv),t.select(cf)]).pipe(N(([e,i])=>function(n,t){return Object.entries(n).map(([e,i])=>{if(void 0===i)return{};let r=t[e];return r&&r.queryParamOverride?{key:r.queryParamOverride,value:i?.toString()}:{}}).filter(({key:e,value:i})=>e&&void 0!==i)}(e,i))),t.select(MW).pipe(N(e=>Number.isFinite(e.scalarSmoothing)?[{key:kV,value:String(e.scalarSmoothing)}]:[])),t.select(JF).pipe(N(e=>{if(!e)return[];let i;switch(e.key){case Yi.EXPERIMENT:i="experiment";break;case Yi.RUN:i="run";break;case Yi.REGEX:i=`${BV}${e.regexString}`;break;default:throw new RangeError("Serialization not implemented")}return[{key:FV,value:i}]})),t.select(vd).pipe(N(e=>e?[{key:LV,value:e}]:[]))]).pipe(N(e=>e.flat()))}deserializeQueryParams(t){let e=null,i=null,r=null,o=null,s=null;for(let{key:a,value:l}of t)switch(a){case"pinnedCards":e=U5e(l);break;case kV:i=Number(l);break;case FV:switch(l){case"experiment":o={key:Yi.EXPERIMENT};break;case"run":o={key:Yi.RUN}}if(l.startsWith(BV)){let c=l.slice(BV.length);o={key:Yi.REGEX,regexString:c}}break;case NV:r=l;break;case LV:s=l}return{metrics:{pinnedCards:e||[],smoothing:i,tagFilter:r},runs:{groupBy:o,regexFilter:s}}}};function U5e(n){let t;try{t=JSON.parse(n)}catch{return null}if(!Array.isArray(t))return null;let e=[];for(let i of t){let o="string"==typeof i.runId,s="number"==typeof i.sample;if(!("string"==typeof i.plugin&&"string"==typeof i.tag&&(o||typeof i.runId>"u")&&(s||typeof i.sample>"u")&&Z6(i.plugin)&&i.tag))continue;if(pa(i.plugin)){if(!i.runId)continue}else if(i.runId)continue;if(s&&(!ua(i.plugin)||!Number.isInteger(i.sample)||i.sample<0))continue;let d={plugin:i.plugin,tag:i.tag};o&&(d.runId=i.runId),s&&(d.sample=i.sample),e.push(d)}return e}function Cie(){return[{routeKind:wn.EXPERIMENT,path:"/",ngComponent:vie,defaultRoute:!0,deepLinkProvider:new RA}]}function Mie(){return n=>(t,e)=>n(t,e)}RA=R4([Ez()],RA);var wie=new ie("Root reducers token",{factory:()=>({})}),Sie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({providers:[{provide:yh,useFactory:Mie,multi:!0}],imports:[Tr.forRoot(wie,{runtimeChecks:{strictStateImmutability:!0,strictActionImmutability:!0,strictActionSerializability:!1,strictStateSerializability:!1}}),to.forRoot([])]}),n})(),Eie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({}),n})(),Tie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n}),n.\u0275inj=U({imports:[Pe,AA,Eie]}),n})(),VV=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=G({type:n,bootstrap:[bY]}),n.\u0275inj=U({imports:[Wh,DY,Mw,UG,Ih,vY,Dl.registerRoutes(Cie),Q1,X1,yY,Tie,Ga,EY,CY,AY,FS,RY,MY,mF,I1,AA,w1,yE,Sie,gie]}),n})();"loading"!==document.readyState?ak().bootstrapModule(VV):window.addEventListener("DOMContentLoaded",()=>{ak().bootstrapModule(VV)})})();
/** vim: et:ts=4:sw=4:sts=4
 * @license RequireJS 2.3.6 Copyright jQuery Foundation and other contributors.
 * Released under MIT license, https://github.com/requirejs/requirejs/blob/master/LICENSE
 */
//Not using strict: uneven strict support in browsers, #392, and causes
//problems with requirejs.exec()/transpiler plugins that may not be strict.
/*jslint regexp: true, nomen: true, sloppy: true */
/*global window, navigator, document, importScripts, setTimeout, opera */

var requirejs, require, define;
(function (global, setTimeout) {
    var req, s, head, baseElement, dataMain, src,
        interactiveScript, currentlyAddingScript, mainScript, subPath,
        version = '2.3.6',
        commentRegExp = /\/\*[\s\S]*?\*\/|([^:"'=]|^)\/\/.*$/mg,
        cjsRequireRegExp = /[^.]\s*require\s*\(\s*["']([^'"\s]+)["']\s*\)/g,
        jsSuffixRegExp = /\.js$/,
        currDirRegExp = /^\.\//,
        op = Object.prototype,
        ostring = op.toString,
        hasOwn = op.hasOwnProperty,
        isBrowser = !!(typeof window !== 'undefined' && typeof navigator !== 'undefined' && window.document),
        isWebWorker = !isBrowser && typeof importScripts !== 'undefined',
        //PS3 indicates loaded and complete, but need to wait for complete
        //specifically. Sequence is 'loading', 'loaded', execution,
        // then 'complete'. The UA check is unfortunate, but not sure how
        //to feature test w/o causing perf issues.
        readyRegExp = isBrowser && navigator.platform === 'PLAYSTATION 3' ?
                      /^complete$/ : /^(complete|loaded)$/,
        defContextName = '_',
        //Oh the tragedy, detecting opera. See the usage of isOpera for reason.
        isOpera = typeof opera !== 'undefined' && opera.toString() === '[object Opera]',
        contexts = {},
        cfg = {},
        globalDefQueue = [],
        useInteractive = false;

    //Could match something like ')//comment', do not lose the prefix to comment.
    function commentReplace(match, singlePrefix) {
        return singlePrefix || '';
    }

    function isFunction(it) {
        return ostring.call(it) === '[object Function]';
    }

    function isArray(it) {
        return ostring.call(it) === '[object Array]';
    }

    /**
     * Helper function for iterating over an array. If the func returns
     * a true value, it will break out of the loop.
     */
    function each(ary, func) {
        if (ary) {
            var i;
            for (i = 0; i < ary.length; i += 1) {
                if (ary[i] && func(ary[i], i, ary)) {
                    break;
                }
            }
        }
    }

    /**
     * Helper function for iterating over an array backwards. If the func
     * returns a true value, it will break out of the loop.
     */
    function eachReverse(ary, func) {
        if (ary) {
            var i;
            for (i = ary.length - 1; i > -1; i -= 1) {
                if (ary[i] && func(ary[i], i, ary)) {
                    break;
                }
            }
        }
    }

    function hasProp(obj, prop) {
        return hasOwn.call(obj, prop);
    }

    function getOwn(obj, prop) {
        return hasProp(obj, prop) && obj[prop];
    }

    /**
     * Cycles over properties in an object and calls a function for each
     * property value. If the function returns a truthy value, then the
     * iteration is stopped.
     */
    function eachProp(obj, func) {
        var prop;
        for (prop in obj) {
            if (hasProp(obj, prop)) {
                if (func(obj[prop], prop)) {
                    break;
                }
            }
        }
    }

    /**
     * Simple function to mix in properties from source into target,
     * but only if target does not already have a property of the same name.
     */
    function mixin(target, source, force, deepStringMixin) {
        if (source) {
            eachProp(source, function (value, prop) {
                if (force || !hasProp(target, prop)) {
                    if (deepStringMixin && typeof value === 'object' && value &&
                        !isArray(value) && !isFunction(value) &&
                        !(value instanceof RegExp)) {

                        if (!target[prop]) {
                            target[prop] = {};
                        }
                        mixin(target[prop], value, force, deepStringMixin);
                    } else {
                        target[prop] = value;
                    }
                }
            });
        }
        return target;
    }

    //Similar to Function.prototype.bind, but the 'this' object is specified
    //first, since it is easier to read/figure out what 'this' will be.
    function bind(obj, fn) {
        return function () {
            return fn.apply(obj, arguments);
        };
    }

    function scripts() {
        return document.getElementsByTagName('script');
    }

    function defaultOnError(err) {
        throw err;
    }

    //Allow getting a global that is expressed in
    //dot notation, like 'a.b.c'.
    function getGlobal(value) {
        if (!value) {
            return value;
        }
        var g = global;
        each(value.split('.'), function (part) {
            g = g[part];
        });
        return g;
    }

    /**
     * Constructs an error with a pointer to an URL with more information.
     * @param {String} id the error ID that maps to an ID on a web page.
     * @param {String} message human readable error.
     * @param {Error} [err] the original error, if there is one.
     *
     * @returns {Error}
     */
    function makeError(id, msg, err, requireModules) {
        var e = new Error(msg + '\nhttps://requirejs.org/docs/errors.html#' + id);
        e.requireType = id;
        e.requireModules = requireModules;
        if (err) {
            e.originalError = err;
        }
        return e;
    }

    if (typeof define !== 'undefined') {
        //If a define is already in play via another AMD loader,
        //do not overwrite.
        return;
    }

    if (typeof requirejs !== 'undefined') {
        if (isFunction(requirejs)) {
            //Do not overwrite an existing requirejs instance.
            return;
        }
        cfg = requirejs;
        requirejs = undefined;
    }

    //Allow for a require config object
    if (typeof require !== 'undefined' && !isFunction(require)) {
        //assume it is a config object.
        cfg = require;
        require = undefined;
    }

    function newContext(contextName) {
        var inCheckLoaded, Module, context, handlers,
            checkLoadedTimeoutId,
            config = {
                //Defaults. Do not set a default for map
                //config to speed up normalize(), which
                //will run faster if there is no default.
                waitSeconds: 7,
                baseUrl: './',
                paths: {},
                bundles: {},
                pkgs: {},
                shim: {},
                config: {}
            },
            registry = {},
            //registry of just enabled modules, to speed
            //cycle breaking code when lots of modules
            //are registered, but not activated.
            enabledRegistry = {},
            undefEvents = {},
            defQueue = [],
            defined = {},
            urlFetched = {},
            bundlesMap = {},
            requireCounter = 1,
            unnormalizedCounter = 1;

        /**
         * Trims the . and .. from an array of path segments.
         * It will keep a leading path segment if a .. will become
         * the first path segment, to help with module name lookups,
         * which act like paths, but can be remapped. But the end result,
         * all paths that use this function should look normalized.
         * NOTE: this method MODIFIES the input array.
         * @param {Array} ary the array of path segments.
         */
        function trimDots(ary) {
            var i, part;
            for (i = 0; i < ary.length; i++) {
                part = ary[i];
                if (part === '.') {
                    ary.splice(i, 1);
                    i -= 1;
                } else if (part === '..') {
                    // If at the start, or previous value is still ..,
                    // keep them so that when converted to a path it may
                    // still work when converted to a path, even though
                    // as an ID it is less than ideal. In larger point
                    // releases, may be better to just kick out an error.
                    if (i === 0 || (i === 1 && ary[2] === '..') || ary[i - 1] === '..') {
                        continue;
                    } else if (i > 0) {
                        ary.splice(i - 1, 2);
                        i -= 2;
                    }
                }
            }
        }

        /**
         * Given a relative module name, like ./something, normalize it to
         * a real name that can be mapped to a path.
         * @param {String} name the relative name
         * @param {String} baseName a real name that the name arg is relative
         * to.
         * @param {Boolean} applyMap apply the map config to the value. Should
         * only be done if this normalization is for a dependency ID.
         * @returns {String} normalized name
         */
        function normalize(name, baseName, applyMap) {
            var pkgMain, mapValue, nameParts, i, j, nameSegment, lastIndex,
                foundMap, foundI, foundStarMap, starI, normalizedBaseParts,
                baseParts = (baseName && baseName.split('/')),
                map = config.map,
                starMap = map && map['*'];

            //Adjust any relative paths.
            if (name) {
                name = name.split('/');
                lastIndex = name.length - 1;

                // If wanting node ID compatibility, strip .js from end
                // of IDs. Have to do this here, and not in nameToUrl
                // because node allows either .js or non .js to map
                // to same file.
                if (config.nodeIdCompat && jsSuffixRegExp.test(name[lastIndex])) {
                    name[lastIndex] = name[lastIndex].replace(jsSuffixRegExp, '');
                }

                // Starts with a '.' so need the baseName
                if (name[0].charAt(0) === '.' && baseParts) {
                    //Convert baseName to array, and lop off the last part,
                    //so that . matches that 'directory' and not name of the baseName's
                    //module. For instance, baseName of 'one/two/three', maps to
                    //'one/two/three.js', but we want the directory, 'one/two' for
                    //this normalization.
                    normalizedBaseParts = baseParts.slice(0, baseParts.length - 1);
                    name = normalizedBaseParts.concat(name);
                }

                trimDots(name);
                name = name.join('/');
            }

            //Apply map config if available.
            if (applyMap && map && (baseParts || starMap)) {
                nameParts = name.split('/');

                outerLoop: for (i = nameParts.length; i > 0; i -= 1) {
                    nameSegment = nameParts.slice(0, i).join('/');

                    if (baseParts) {
                        //Find the longest baseName segment match in the config.
                        //So, do joins on the biggest to smallest lengths of baseParts.
                        for (j = baseParts.length; j > 0; j -= 1) {
                            mapValue = getOwn(map, baseParts.slice(0, j).join('/'));

                            //baseName segment has config, find if it has one for
                            //this name.
                            if (mapValue) {
                                mapValue = getOwn(mapValue, nameSegment);
                                if (mapValue) {
                                    //Match, update name to the new value.
                                    foundMap = mapValue;
                                    foundI = i;
                                    break outerLoop;
                                }
                            }
                        }
                    }

                    //Check for a star map match, but just hold on to it,
                    //if there is a shorter segment match later in a matching
                    //config, then favor over this star map.
                    if (!foundStarMap && starMap && getOwn(starMap, nameSegment)) {
                        foundStarMap = getOwn(starMap, nameSegment);
                        starI = i;
                    }
                }

                if (!foundMap && foundStarMap) {
                    foundMap = foundStarMap;
                    foundI = starI;
                }

                if (foundMap) {
                    nameParts.splice(0, foundI, foundMap);
                    name = nameParts.join('/');
                }
            }

            // If the name points to a package's name, use
            // the package main instead.
            pkgMain = getOwn(config.pkgs, name);

            return pkgMain ? pkgMain : name;
        }

        function removeScript(name) {
            if (isBrowser) {
                each(scripts(), function (scriptNode) {
                    if (scriptNode.getAttribute('data-requiremodule') === name &&
                            scriptNode.getAttribute('data-requirecontext') === context.contextName) {
                        scriptNode.parentNode.removeChild(scriptNode);
                        return true;
                    }
                });
            }
        }

        function hasPathFallback(id) {
            var pathConfig = getOwn(config.paths, id);
            if (pathConfig && isArray(pathConfig) && pathConfig.length > 1) {
                //Pop off the first array value, since it failed, and
                //retry
                pathConfig.shift();
                context.require.undef(id);

                //Custom require that does not do map translation, since
                //ID is "absolute", already mapped/resolved.
                context.makeRequire(null, {
                    skipMap: true
                })([id]);

                return true;
            }
        }

        //Turns a plugin!resource to [plugin, resource]
        //with the plugin being undefined if the name
        //did not have a plugin prefix.
        function splitPrefix(name) {
            var prefix,
                index = name ? name.indexOf('!') : -1;
            if (index > -1) {
                prefix = name.substring(0, index);
                name = name.substring(index + 1, name.length);
            }
            return [prefix, name];
        }

        /**
         * Creates a module mapping that includes plugin prefix, module
         * name, and path. If parentModuleMap is provided it will
         * also normalize the name via require.normalize()
         *
         * @param {String} name the module name
         * @param {String} [parentModuleMap] parent module map
         * for the module name, used to resolve relative names.
         * @param {Boolean} isNormalized: is the ID already normalized.
         * This is true if this call is done for a define() module ID.
         * @param {Boolean} applyMap: apply the map config to the ID.
         * Should only be true if this map is for a dependency.
         *
         * @returns {Object}
         */
        function makeModuleMap(name, parentModuleMap, isNormalized, applyMap) {
            var url, pluginModule, suffix, nameParts,
                prefix = null,
                parentName = parentModuleMap ? parentModuleMap.name : null,
                originalName = name,
                isDefine = true,
                normalizedName = '';

            //If no name, then it means it is a require call, generate an
            //internal name.
            if (!name) {
                isDefine = false;
                name = '_@r' + (requireCounter += 1);
            }

            nameParts = splitPrefix(name);
            prefix = nameParts[0];
            name = nameParts[1];

            if (prefix) {
                prefix = normalize(prefix, parentName, applyMap);
                pluginModule = getOwn(defined, prefix);
            }

            //Account for relative paths if there is a base name.
            if (name) {
                if (prefix) {
                    if (isNormalized) {
                        normalizedName = name;
                    } else if (pluginModule && pluginModule.normalize) {
                        //Plugin is loaded, use its normalize method.
                        normalizedName = pluginModule.normalize(name, function (name) {
                            return normalize(name, parentName, applyMap);
                        });
                    } else {
                        // If nested plugin references, then do not try to
                        // normalize, as it will not normalize correctly. This
                        // places a restriction on resourceIds, and the longer
                        // term solution is not to normalize until plugins are
                        // loaded and all normalizations to allow for async
                        // loading of a loader plugin. But for now, fixes the
                        // common uses. Details in #1131
                        normalizedName = name.indexOf('!') === -1 ?
                                         normalize(name, parentName, applyMap) :
                                         name;
                    }
                } else {
                    //A regular module.
                    normalizedName = normalize(name, parentName, applyMap);

                    //Normalized name may be a plugin ID due to map config
                    //application in normalize. The map config values must
                    //already be normalized, so do not need to redo that part.
                    nameParts = splitPrefix(normalizedName);
                    prefix = nameParts[0];
                    normalizedName = nameParts[1];
                    isNormalized = true;

                    url = context.nameToUrl(normalizedName);
                }
            }

            //If the id is a plugin id that cannot be determined if it needs
            //normalization, stamp it with a unique ID so two matching relative
            //ids that may conflict can be separate.
            suffix = prefix && !pluginModule && !isNormalized ?
                     '_unnormalized' + (unnormalizedCounter += 1) :
                     '';

            return {
                prefix: prefix,
                name: normalizedName,
                parentMap: parentModuleMap,
                unnormalized: !!suffix,
                url: url,
                originalName: originalName,
                isDefine: isDefine,
                id: (prefix ?
                        prefix + '!' + normalizedName :
                        normalizedName) + suffix
            };
        }

        function getModule(depMap) {
            var id = depMap.id,
                mod = getOwn(registry, id);

            if (!mod) {
                mod = registry[id] = new context.Module(depMap);
            }

            return mod;
        }

        function on(depMap, name, fn) {
            var id = depMap.id,
                mod = getOwn(registry, id);

            if (hasProp(defined, id) &&
                    (!mod || mod.defineEmitComplete)) {
                if (name === 'defined') {
                    fn(defined[id]);
                }
            } else {
                mod = getModule(depMap);
                if (mod.error && name === 'error') {
                    fn(mod.error);
                } else {
                    mod.on(name, fn);
                }
            }
        }

        function onError(err, errback) {
            var ids = err.requireModules,
                notified = false;

            if (errback) {
                errback(err);
            } else {
                each(ids, function (id) {
                    var mod = getOwn(registry, id);
                    if (mod) {
                        //Set error on module, so it skips timeout checks.
                        mod.error = err;
                        if (mod.events.error) {
                            notified = true;
                            mod.emit('error', err);
                        }
                    }
                });

                if (!notified) {
                    req.onError(err);
                }
            }
        }

        /**
         * Internal method to transfer globalQueue items to this context's
         * defQueue.
         */
        function takeGlobalQueue() {
            //Push all the globalDefQueue items into the context's defQueue
            if (globalDefQueue.length) {
                each(globalDefQueue, function(queueItem) {
                    var id = queueItem[0];
                    if (typeof id === 'string') {
                        context.defQueueMap[id] = true;
                    }
                    defQueue.push(queueItem);
                });
                globalDefQueue = [];
            }
        }

        handlers = {
            'require': function (mod) {
                if (mod.require) {
                    return mod.require;
                } else {
                    return (mod.require = context.makeRequire(mod.map));
                }
            },
            'exports': function (mod) {
                mod.usingExports = true;
                if (mod.map.isDefine) {
                    if (mod.exports) {
                        return (defined[mod.map.id] = mod.exports);
                    } else {
                        return (mod.exports = defined[mod.map.id] = {});
                    }
                }
            },
            'module': function (mod) {
                if (mod.module) {
                    return mod.module;
                } else {
                    return (mod.module = {
                        id: mod.map.id,
                        uri: mod.map.url,
                        config: function () {
                            return getOwn(config.config, mod.map.id) || {};
                        },
                        exports: mod.exports || (mod.exports = {})
                    });
                }
            }
        };

        function cleanRegistry(id) {
            //Clean up machinery used for waiting modules.
            delete registry[id];
            delete enabledRegistry[id];
        }

        function breakCycle(mod, traced, processed) {
            var id = mod.map.id;

            if (mod.error) {
                mod.emit('error', mod.error);
            } else {
                traced[id] = true;
                each(mod.depMaps, function (depMap, i) {
                    var depId = depMap.id,
                        dep = getOwn(registry, depId);

                    //Only force things that have not completed
                    //being defined, so still in the registry,
                    //and only if it has not been matched up
                    //in the module already.
                    if (dep && !mod.depMatched[i] && !processed[depId]) {
                        if (getOwn(traced, depId)) {
                            mod.defineDep(i, defined[depId]);
                            mod.check(); //pass false?
                        } else {
                            breakCycle(dep, traced, processed);
                        }
                    }
                });
                processed[id] = true;
            }
        }

        function checkLoaded() {
            var err, usingPathFallback,
                waitInterval = config.waitSeconds * 1000,
                //It is possible to disable the wait interval by using waitSeconds of 0.
                expired = waitInterval && (context.startTime + waitInterval) < new Date().getTime(),
                noLoads = [],
                reqCalls = [],
                stillLoading = false,
                needCycleCheck = true;

            //Do not bother if this call was a result of a cycle break.
            if (inCheckLoaded) {
                return;
            }

            inCheckLoaded = true;

            //Figure out the state of all the modules.
            eachProp(enabledRegistry, function (mod) {
                var map = mod.map,
                    modId = map.id;

                //Skip things that are not enabled or in error state.
                if (!mod.enabled) {
                    return;
                }

                if (!map.isDefine) {
                    reqCalls.push(mod);
                }

                if (!mod.error) {
                    //If the module should be executed, and it has not
                    //been inited and time is up, remember it.
                    if (!mod.inited && expired) {
                        if (hasPathFallback(modId)) {
                            usingPathFallback = true;
                            stillLoading = true;
                        } else {
                            noLoads.push(modId);
                            removeScript(modId);
                        }
                    } else if (!mod.inited && mod.fetched && map.isDefine) {
                        stillLoading = true;
                        if (!map.prefix) {
                            //No reason to keep looking for unfinished
                            //loading. If the only stillLoading is a
                            //plugin resource though, keep going,
                            //because it may be that a plugin resource
                            //is waiting on a non-plugin cycle.
                            return (needCycleCheck = false);
                        }
                    }
                }
            });

            if (expired && noLoads.length) {
                //If wait time expired, throw error of unloaded modules.
                err = makeError('timeout', 'Load timeout for modules: ' + noLoads, null, noLoads);
                err.contextName = context.contextName;
                return onError(err);
            }

            //Not expired, check for a cycle.
            if (needCycleCheck) {
                each(reqCalls, function (mod) {
                    breakCycle(mod, {}, {});
                });
            }

            //If still waiting on loads, and the waiting load is something
            //other than a plugin resource, or there are still outstanding
            //scripts, then just try back later.
            if ((!expired || usingPathFallback) && stillLoading) {
                //Something is still waiting to load. Wait for it, but only
                //if a timeout is not already in effect.
                if ((isBrowser || isWebWorker) && !checkLoadedTimeoutId) {
                    checkLoadedTimeoutId = setTimeout(function () {
                        checkLoadedTimeoutId = 0;
                        checkLoaded();
                    }, 50);
                }
            }

            inCheckLoaded = false;
        }

        Module = function (map) {
            this.events = getOwn(undefEvents, map.id) || {};
            this.map = map;
            this.shim = getOwn(config.shim, map.id);
            this.depExports = [];
            this.depMaps = [];
            this.depMatched = [];
            this.pluginMaps = {};
            this.depCount = 0;

            /* this.exports this.factory
               this.depMaps = [],
               this.enabled, this.fetched
            */
        };

        Module.prototype = {
            init: function (depMaps, factory, errback, options) {
                options = options || {};

                //Do not do more inits if already done. Can happen if there
                //are multiple define calls for the same module. That is not
                //a normal, common case, but it is also not unexpected.
                if (this.inited) {
                    return;
                }

                this.factory = factory;

                if (errback) {
                    //Register for errors on this module.
                    this.on('error', errback);
                } else if (this.events.error) {
                    //If no errback already, but there are error listeners
                    //on this module, set up an errback to pass to the deps.
                    errback = bind(this, function (err) {
                        this.emit('error', err);
                    });
                }

                //Do a copy of the dependency array, so that
                //source inputs are not modified. For example
                //"shim" deps are passed in here directly, and
                //doing a direct modification of the depMaps array
                //would affect that config.
                this.depMaps = depMaps && depMaps.slice(0);

                this.errback = errback;

                //Indicate this module has be initialized
                this.inited = true;

                this.ignore = options.ignore;

                //Could have option to init this module in enabled mode,
                //or could have been previously marked as enabled. However,
                //the dependencies are not known until init is called. So
                //if enabled previously, now trigger dependencies as enabled.
                if (options.enabled || this.enabled) {
                    //Enable this module and dependencies.
                    //Will call this.check()
                    this.enable();
                } else {
                    this.check();
                }
            },

            defineDep: function (i, depExports) {
                //Because of cycles, defined callback for a given
                //export can be called more than once.
                if (!this.depMatched[i]) {
                    this.depMatched[i] = true;
                    this.depCount -= 1;
                    this.depExports[i] = depExports;
                }
            },

            fetch: function () {
                if (this.fetched) {
                    return;
                }
                this.fetched = true;

                context.startTime = (new Date()).getTime();

                var map = this.map;

                //If the manager is for a plugin managed resource,
                //ask the plugin to load it now.
                if (this.shim) {
                    context.makeRequire(this.map, {
                        enableBuildCallback: true
                    })(this.shim.deps || [], bind(this, function () {
                        return map.prefix ? this.callPlugin() : this.load();
                    }));
                } else {
                    //Regular dependency.
                    return map.prefix ? this.callPlugin() : this.load();
                }
            },

            load: function () {
                var url = this.map.url;

                //Regular dependency.
                if (!urlFetched[url]) {
                    urlFetched[url] = true;
                    context.load(this.map.id, url);
                }
            },

            /**
             * Checks if the module is ready to define itself, and if so,
             * define it.
             */
            check: function () {
                if (!this.enabled || this.enabling) {
                    return;
                }

                var err, cjsModule,
                    id = this.map.id,
                    depExports = this.depExports,
                    exports = this.exports,
                    factory = this.factory;

                if (!this.inited) {
                    // Only fetch if not already in the defQueue.
                    if (!hasProp(context.defQueueMap, id)) {
                        this.fetch();
                    }
                } else if (this.error) {
                    this.emit('error', this.error);
                } else if (!this.defining) {
                    //The factory could trigger another require call
                    //that would result in checking this module to
                    //define itself again. If already in the process
                    //of doing that, skip this work.
                    this.defining = true;

                    if (this.depCount < 1 && !this.defined) {
                        if (isFunction(factory)) {
                            //If there is an error listener, favor passing
                            //to that instead of throwing an error. However,
                            //only do it for define()'d  modules. require
                            //errbacks should not be called for failures in
                            //their callbacks (#699). However if a global
                            //onError is set, use that.
                            if ((this.events.error && this.map.isDefine) ||
                                req.onError !== defaultOnError) {
                                try {
                                    exports = context.execCb(id, factory, depExports, exports);
                                } catch (e) {
                                    err = e;
                                }
                            } else {
                                exports = context.execCb(id, factory, depExports, exports);
                            }

                            // Favor return value over exports. If node/cjs in play,
                            // then will not have a return value anyway. Favor
                            // module.exports assignment over exports object.
                            if (this.map.isDefine && exports === undefined) {
                                cjsModule = this.module;
                                if (cjsModule) {
                                    exports = cjsModule.exports;
                                } else if (this.usingExports) {
                                    //exports already set the defined value.
                                    exports = this.exports;
                                }
                            }

                            if (err) {
                                err.requireMap = this.map;
                                err.requireModules = this.map.isDefine ? [this.map.id] : null;
                                err.requireType = this.map.isDefine ? 'define' : 'require';
                                return onError((this.error = err));
                            }

                        } else {
                            //Just a literal value
                            exports = factory;
                        }

                        this.exports = exports;

                        if (this.map.isDefine && !this.ignore) {
                            defined[id] = exports;

                            if (req.onResourceLoad) {
                                var resLoadMaps = [];
                                each(this.depMaps, function (depMap) {
                                    resLoadMaps.push(depMap.normalizedMap || depMap);
                                });
                                req.onResourceLoad(context, this.map, resLoadMaps);
                            }
                        }

                        //Clean up
                        cleanRegistry(id);

                        this.defined = true;
                    }

                    //Finished the define stage. Allow calling check again
                    //to allow define notifications below in the case of a
                    //cycle.
                    this.defining = false;

                    if (this.defined && !this.defineEmitted) {
                        this.defineEmitted = true;
                        this.emit('defined', this.exports);
                        this.defineEmitComplete = true;
                    }

                }
            },

            callPlugin: function () {
                var map = this.map,
                    id = map.id,
                    //Map already normalized the prefix.
                    pluginMap = makeModuleMap(map.prefix);

                //Mark this as a dependency for this plugin, so it
                //can be traced for cycles.
                this.depMaps.push(pluginMap);

                on(pluginMap, 'defined', bind(this, function (plugin) {
                    var load, normalizedMap, normalizedMod,
                        bundleId = getOwn(bundlesMap, this.map.id),
                        name = this.map.name,
                        parentName = this.map.parentMap ? this.map.parentMap.name : null,
                        localRequire = context.makeRequire(map.parentMap, {
                            enableBuildCallback: true
                        });

                    //If current map is not normalized, wait for that
                    //normalized name to load instead of continuing.
                    if (this.map.unnormalized) {
                        //Normalize the ID if the plugin allows it.
                        if (plugin.normalize) {
                            name = plugin.normalize(name, function (name) {
                                return normalize(name, parentName, true);
                            }) || '';
                        }

                        //prefix and name should already be normalized, no need
                        //for applying map config again either.
                        normalizedMap = makeModuleMap(map.prefix + '!' + name,
                                                      this.map.parentMap,
                                                      true);
                        on(normalizedMap,
                            'defined', bind(this, function (value) {
                                this.map.normalizedMap = normalizedMap;
                                this.init([], function () { return value; }, null, {
                                    enabled: true,
                                    ignore: true
                                });
                            }));

                        normalizedMod = getOwn(registry, normalizedMap.id);
                        if (normalizedMod) {
                            //Mark this as a dependency for this plugin, so it
                            //can be traced for cycles.
                            this.depMaps.push(normalizedMap);

                            if (this.events.error) {
                                normalizedMod.on('error', bind(this, function (err) {
                                    this.emit('error', err);
                                }));
                            }
                            normalizedMod.enable();
                        }

                        return;
                    }

                    //If a paths config, then just load that file instead to
                    //resolve the plugin, as it is built into that paths layer.
                    if (bundleId) {
                        this.map.url = context.nameToUrl(bundleId);
                        this.load();
                        return;
                    }

                    load = bind(this, function (value) {
                        this.init([], function () { return value; }, null, {
                            enabled: true
                        });
                    });

                    load.error = bind(this, function (err) {
                        this.inited = true;
                        this.error = err;
                        err.requireModules = [id];

                        //Remove temp unnormalized modules for this module,
                        //since they will never be resolved otherwise now.
                        eachProp(registry, function (mod) {
                            if (mod.map.id.indexOf(id + '_unnormalized') === 0) {
                                cleanRegistry(mod.map.id);
                            }
                        });

                        onError(err);
                    });

                    //Allow plugins to load other code without having to know the
                    //context or how to 'complete' the load.
                    load.fromText = bind(this, function (text, textAlt) {
                        /*jslint evil: true */
                        var moduleName = map.name,
                            moduleMap = makeModuleMap(moduleName),
                            hasInteractive = useInteractive;

                        //As of 2.1.0, support just passing the text, to reinforce
                        //fromText only being called once per resource. Still
                        //support old style of passing moduleName but discard
                        //that moduleName in favor of the internal ref.
                        if (textAlt) {
                            text = textAlt;
                        }

                        //Turn off interactive script matching for IE for any define
                        //calls in the text, then turn it back on at the end.
                        if (hasInteractive) {
                            useInteractive = false;
                        }

                        //Prime the system by creating a module instance for
                        //it.
                        getModule(moduleMap);

                        //Transfer any config to this other module.
                        if (hasProp(config.config, id)) {
                            config.config[moduleName] = config.config[id];
                        }

                        try {
                            req.exec(text);
                        } catch (e) {
                            return onError(makeError('fromtexteval',
                                             'fromText eval for ' + id +
                                            ' failed: ' + e,
                                             e,
                                             [id]));
                        }

                        if (hasInteractive) {
                            useInteractive = true;
                        }

                        //Mark this as a dependency for the plugin
                        //resource
                        this.depMaps.push(moduleMap);

                        //Support anonymous modules.
                        context.completeLoad(moduleName);

                        //Bind the value of that module to the value for this
                        //resource ID.
                        localRequire([moduleName], load);
                    });

                    //Use parentName here since the plugin's name is not reliable,
                    //could be some weird string with no path that actually wants to
                    //reference the parentName's path.
                    plugin.load(map.name, localRequire, load, config);
                }));

                context.enable(pluginMap, this);
                this.pluginMaps[pluginMap.id] = pluginMap;
            },

            enable: function () {
                enabledRegistry[this.map.id] = this;
                this.enabled = true;

                //Set flag mentioning that the module is enabling,
                //so that immediate calls to the defined callbacks
                //for dependencies do not trigger inadvertent load
                //with the depCount still being zero.
                this.enabling = true;

                //Enable each dependency
                each(this.depMaps, bind(this, function (depMap, i) {
                    var id, mod, handler;

                    if (typeof depMap === 'string') {
                        //Dependency needs to be converted to a depMap
                        //and wired up to this module.
                        depMap = makeModuleMap(depMap,
                                               (this.map.isDefine ? this.map : this.map.parentMap),
                                               false,
                                               !this.skipMap);
                        this.depMaps[i] = depMap;

                        handler = getOwn(handlers, depMap.id);

                        if (handler) {
                            this.depExports[i] = handler(this);
                            return;
                        }

                        this.depCount += 1;

                        on(depMap, 'defined', bind(this, function (depExports) {
                            if (this.undefed) {
                                return;
                            }
                            this.defineDep(i, depExports);
                            this.check();
                        }));

                        if (this.errback) {
                            on(depMap, 'error', bind(this, this.errback));
                        } else if (this.events.error) {
                            // No direct errback on this module, but something
                            // else is listening for errors, so be sure to
                            // propagate the error correctly.
                            on(depMap, 'error', bind(this, function(err) {
                                this.emit('error', err);
                            }));
                        }
                    }

                    id = depMap.id;
                    mod = registry[id];

                    //Skip special modules like 'require', 'exports', 'module'
                    //Also, don't call enable if it is already enabled,
                    //important in circular dependency cases.
                    if (!hasProp(handlers, id) && mod && !mod.enabled) {
                        context.enable(depMap, this);
                    }
                }));

                //Enable each plugin that is used in
                //a dependency
                eachProp(this.pluginMaps, bind(this, function (pluginMap) {
                    var mod = getOwn(registry, pluginMap.id);
                    if (mod && !mod.enabled) {
                        context.enable(pluginMap, this);
                    }
                }));

                this.enabling = false;

                this.check();
            },

            on: function (name, cb) {
                var cbs = this.events[name];
                if (!cbs) {
                    cbs = this.events[name] = [];
                }
                cbs.push(cb);
            },

            emit: function (name, evt) {
                each(this.events[name], function (cb) {
                    cb(evt);
                });
                if (name === 'error') {
                    //Now that the error handler was triggered, remove
                    //the listeners, since this broken Module instance
                    //can stay around for a while in the registry.
                    delete this.events[name];
                }
            }
        };

        function callGetModule(args) {
            //Skip modules already defined.
            if (!hasProp(defined, args[0])) {
                getModule(makeModuleMap(args[0], null, true)).init(args[1], args[2]);
            }
        }

        function removeListener(node, func, name, ieName) {
            //Favor detachEvent because of IE9
            //issue, see attachEvent/addEventListener comment elsewhere
            //in this file.
            if (node.detachEvent && !isOpera) {
                //Probably IE. If not it will throw an error, which will be
                //useful to know.
                if (ieName) {
                    node.detachEvent(ieName, func);
                }
            } else {
                node.removeEventListener(name, func, false);
            }
        }

        /**
         * Given an event from a script node, get the requirejs info from it,
         * and then removes the event listeners on the node.
         * @param {Event} evt
         * @returns {Object}
         */
        function getScriptData(evt) {
            //Using currentTarget instead of target for Firefox 2.0's sake. Not
            //all old browsers will be supported, but this one was easy enough
            //to support and still makes sense.
            var node = evt.currentTarget || evt.srcElement;

            //Remove the listeners once here.
            removeListener(node, context.onScriptLoad, 'load', 'onreadystatechange');
            removeListener(node, context.onScriptError, 'error');

            return {
                node: node,
                id: node && node.getAttribute('data-requiremodule')
            };
        }

        function intakeDefines() {
            var args;

            //Any defined modules in the global queue, intake them now.
            takeGlobalQueue();

            //Make sure any remaining defQueue items get properly processed.
            while (defQueue.length) {
                args = defQueue.shift();
                if (args[0] === null) {
                    return onError(makeError('mismatch', 'Mismatched anonymous define() module: ' +
                        args[args.length - 1]));
                } else {
                    //args are id, deps, factory. Should be normalized by the
                    //define() function.
                    callGetModule(args);
                }
            }
            context.defQueueMap = {};
        }

        context = {
            config: config,
            contextName: contextName,
            registry: registry,
            defined: defined,
            urlFetched: urlFetched,
            defQueue: defQueue,
            defQueueMap: {},
            Module: Module,
            makeModuleMap: makeModuleMap,
            nextTick: req.nextTick,
            onError: onError,

            /**
             * Set a configuration for the context.
             * @param {Object} cfg config object to integrate.
             */
            configure: function (cfg) {
                //Make sure the baseUrl ends in a slash.
                if (cfg.baseUrl) {
                    if (cfg.baseUrl.charAt(cfg.baseUrl.length - 1) !== '/') {
                        cfg.baseUrl += '/';
                    }
                }

                // Convert old style urlArgs string to a function.
                if (typeof cfg.urlArgs === 'string') {
                    var urlArgs = cfg.urlArgs;
                    cfg.urlArgs = function(id, url) {
                        return (url.indexOf('?') === -1 ? '?' : '&') + urlArgs;
                    };
                }

                //Save off the paths since they require special processing,
                //they are additive.
                var shim = config.shim,
                    objs = {
                        paths: true,
                        bundles: true,
                        config: true,
                        map: true
                    };

                eachProp(cfg, function (value, prop) {
                    if (objs[prop]) {
                        if (!config[prop]) {
                            config[prop] = {};
                        }
                        mixin(config[prop], value, true, true);
                    } else {
                        config[prop] = value;
                    }
                });

                //Reverse map the bundles
                if (cfg.bundles) {
                    eachProp(cfg.bundles, function (value, prop) {
                        each(value, function (v) {
                            if (v !== prop) {
                                bundlesMap[v] = prop;
                            }
                        });
                    });
                }

                //Merge shim
                if (cfg.shim) {
                    eachProp(cfg.shim, function (value, id) {
                        //Normalize the structure
                        if (isArray(value)) {
                            value = {
                                deps: value
                            };
                        }
                        if ((value.exports || value.init) && !value.exportsFn) {
                            value.exportsFn = context.makeShimExports(value);
                        }
                        shim[id] = value;
                    });
                    config.shim = shim;
                }

                //Adjust packages if necessary.
                if (cfg.packages) {
                    each(cfg.packages, function (pkgObj) {
                        var location, name;

                        pkgObj = typeof pkgObj === 'string' ? {name: pkgObj} : pkgObj;

                        name = pkgObj.name;
                        location = pkgObj.location;
                        if (location) {
                            config.paths[name] = pkgObj.location;
                        }

                        //Save pointer to main module ID for pkg name.
                        //Remove leading dot in main, so main paths are normalized,
                        //and remove any trailing .js, since different package
                        //envs have different conventions: some use a module name,
                        //some use a file name.
                        config.pkgs[name] = pkgObj.name + '/' + (pkgObj.main || 'main')
                                     .replace(currDirRegExp, '')
                                     .replace(jsSuffixRegExp, '');
                    });
                }

                //If there are any "waiting to execute" modules in the registry,
                //update the maps for them, since their info, like URLs to load,
                //may have changed.
                eachProp(registry, function (mod, id) {
                    //If module already has init called, since it is too
                    //late to modify them, and ignore unnormalized ones
                    //since they are transient.
                    if (!mod.inited && !mod.map.unnormalized) {
                        mod.map = makeModuleMap(id, null, true);
                    }
                });

                //If a deps array or a config callback is specified, then call
                //require with those args. This is useful when require is defined as a
                //config object before require.js is loaded.
                if (cfg.deps || cfg.callback) {
                    context.require(cfg.deps || [], cfg.callback);
                }
            },

            makeShimExports: function (value) {
                function fn() {
                    var ret;
                    if (value.init) {
                        ret = value.init.apply(global, arguments);
                    }
                    return ret || (value.exports && getGlobal(value.exports));
                }
                return fn;
            },

            makeRequire: function (relMap, options) {
                options = options || {};

                function localRequire(deps, callback, errback) {
                    var id, map, requireMod;

                    if (options.enableBuildCallback && callback && isFunction(callback)) {
                        callback.__requireJsBuild = true;
                    }

                    if (typeof deps === 'string') {
                        if (isFunction(callback)) {
                            //Invalid call
                            return onError(makeError('requireargs', 'Invalid require call'), errback);
                        }

                        //If require|exports|module are requested, get the
                        //value for them from the special handlers. Caveat:
                        //this only works while module is being defined.
                        if (relMap && hasProp(handlers, deps)) {
                            return handlers[deps](registry[relMap.id]);
                        }

                        //Synchronous access to one module. If require.get is
                        //available (as in the Node adapter), prefer that.
                        if (req.get) {
                            return req.get(context, deps, relMap, localRequire);
                        }

                        //Normalize module name, if it contains . or ..
                        map = makeModuleMap(deps, relMap, false, true);
                        id = map.id;

                        if (!hasProp(defined, id)) {
                            return onError(makeError('notloaded', 'Module name "' +
                                        id +
                                        '" has not been loaded yet for context: ' +
                                        contextName +
                                        (relMap ? '' : '. Use require([])')));
                        }
                        return defined[id];
                    }

                    //Grab defines waiting in the global queue.
                    intakeDefines();

                    //Mark all the dependencies as needing to be loaded.
                    context.nextTick(function () {
                        //Some defines could have been added since the
                        //require call, collect them.
                        intakeDefines();

                        requireMod = getModule(makeModuleMap(null, relMap));

                        //Store if map config should be applied to this require
                        //call for dependencies.
                        requireMod.skipMap = options.skipMap;

                        requireMod.init(deps, callback, errback, {
                            enabled: true
                        });

                        checkLoaded();
                    });

                    return localRequire;
                }

                mixin(localRequire, {
                    isBrowser: isBrowser,

                    /**
                     * Converts a module name + .extension into an URL path.
                     * *Requires* the use of a module name. It does not support using
                     * plain URLs like nameToUrl.
                     */
                    toUrl: function (moduleNamePlusExt) {
                        var ext,
                            index = moduleNamePlusExt.lastIndexOf('.'),
                            segment = moduleNamePlusExt.split('/')[0],
                            isRelative = segment === '.' || segment === '..';

                        //Have a file extension alias, and it is not the
                        //dots from a relative path.
                        if (index !== -1 && (!isRelative || index > 1)) {
                            ext = moduleNamePlusExt.substring(index, moduleNamePlusExt.length);
                            moduleNamePlusExt = moduleNamePlusExt.substring(0, index);
                        }

                        return context.nameToUrl(normalize(moduleNamePlusExt,
                                                relMap && relMap.id, true), ext,  true);
                    },

                    defined: function (id) {
                        return hasProp(defined, makeModuleMap(id, relMap, false, true).id);
                    },

                    specified: function (id) {
                        id = makeModuleMap(id, relMap, false, true).id;
                        return hasProp(defined, id) || hasProp(registry, id);
                    }
                });

                //Only allow undef on top level require calls
                if (!relMap) {
                    localRequire.undef = function (id) {
                        //Bind any waiting define() calls to this context,
                        //fix for #408
                        takeGlobalQueue();

                        var map = makeModuleMap(id, relMap, true),
                            mod = getOwn(registry, id);

                        mod.undefed = true;
                        removeScript(id);

                        delete defined[id];
                        delete urlFetched[map.url];
                        delete undefEvents[id];

                        //Clean queued defines too. Go backwards
                        //in array so that the splices do not
                        //mess up the iteration.
                        eachReverse(defQueue, function(args, i) {
                            if (args[0] === id) {
                                defQueue.splice(i, 1);
                            }
                        });
                        delete context.defQueueMap[id];

                        if (mod) {
                            //Hold on to listeners in case the
                            //module will be attempted to be reloaded
                            //using a different config.
                            if (mod.events.defined) {
                                undefEvents[id] = mod.events;
                            }

                            cleanRegistry(id);
                        }
                    };
                }

                return localRequire;
            },

            /**
             * Called to enable a module if it is still in the registry
             * awaiting enablement. A second arg, parent, the parent module,
             * is passed in for context, when this method is overridden by
             * the optimizer. Not shown here to keep code compact.
             */
            enable: function (depMap) {
                var mod = getOwn(registry, depMap.id);
                if (mod) {
                    getModule(depMap).enable();
                }
            },

            /**
             * Internal method used by environment adapters to complete a load event.
             * A load event could be a script load or just a load pass from a synchronous
             * load call.
             * @param {String} moduleName the name of the module to potentially complete.
             */
            completeLoad: function (moduleName) {
                var found, args, mod,
                    shim = getOwn(config.shim, moduleName) || {},
                    shExports = shim.exports;

                takeGlobalQueue();

                while (defQueue.length) {
                    args = defQueue.shift();
                    if (args[0] === null) {
                        args[0] = moduleName;
                        //If already found an anonymous module and bound it
                        //to this name, then this is some other anon module
                        //waiting for its completeLoad to fire.
                        if (found) {
                            break;
                        }
                        found = true;
                    } else if (args[0] === moduleName) {
                        //Found matching define call for this script!
                        found = true;
                    }

                    callGetModule(args);
                }
                context.defQueueMap = {};

                //Do this after the cycle of callGetModule in case the result
                //of those calls/init calls changes the registry.
                mod = getOwn(registry, moduleName);

                if (!found && !hasProp(defined, moduleName) && mod && !mod.inited) {
                    if (config.enforceDefine && (!shExports || !getGlobal(shExports))) {
                        if (hasPathFallback(moduleName)) {
                            return;
                        } else {
                            return onError(makeError('nodefine',
                                             'No define call for ' + moduleName,
                                             null,
                                             [moduleName]));
                        }
                    } else {
                        //A script that does not call define(), so just simulate
                        //the call for it.
                        callGetModule([moduleName, (shim.deps || []), shim.exportsFn]);
                    }
                }

                checkLoaded();
            },

            /**
             * Converts a module name to a file path. Supports cases where
             * moduleName may actually be just an URL.
             * Note that it **does not** call normalize on the moduleName,
             * it is assumed to have already been normalized. This is an
             * internal API, not a public one. Use toUrl for the public API.
             */
            nameToUrl: function (moduleName, ext, skipExt) {
                var paths, syms, i, parentModule, url,
                    parentPath, bundleId,
                    pkgMain = getOwn(config.pkgs, moduleName);

                if (pkgMain) {
                    moduleName = pkgMain;
                }

                bundleId = getOwn(bundlesMap, moduleName);

                if (bundleId) {
                    return context.nameToUrl(bundleId, ext, skipExt);
                }

                //If a colon is in the URL, it indicates a protocol is used and it is just
                //an URL to a file, or if it starts with a slash, contains a query arg (i.e. ?)
                //or ends with .js, then assume the user meant to use an url and not a module id.
                //The slash is important for protocol-less URLs as well as full paths.
                if (req.jsExtRegExp.test(moduleName)) {
                    //Just a plain path, not module name lookup, so just return it.
                    //Add extension if it is included. This is a bit wonky, only non-.js things pass
                    //an extension, this method probably needs to be reworked.
                    url = moduleName + (ext || '');
                } else {
                    //A module that needs to be converted to a path.
                    paths = config.paths;

                    syms = moduleName.split('/');
                    //For each module name segment, see if there is a path
                    //registered for it. Start with most specific name
                    //and work up from it.
                    for (i = syms.length; i > 0; i -= 1) {
                        parentModule = syms.slice(0, i).join('/');

                        parentPath = getOwn(paths, parentModule);
                        if (parentPath) {
                            //If an array, it means there are a few choices,
                            //Choose the one that is desired
                            if (isArray(parentPath)) {
                                parentPath = parentPath[0];
                            }
                            syms.splice(0, i, parentPath);
                            break;
                        }
                    }

                    //Join the path parts together, then figure out if baseUrl is needed.
                    url = syms.join('/');
                    url += (ext || (/^data\:|^blob\:|\?/.test(url) || skipExt ? '' : '.js'));
                    url = (url.charAt(0) === '/' || url.match(/^[\w\+\.\-]+:/) ? '' : config.baseUrl) + url;
                }

                return config.urlArgs && !/^blob\:/.test(url) ?
                       url + config.urlArgs(moduleName, url) : url;
            },

            //Delegates to req.load. Broken out as a separate function to
            //allow overriding in the optimizer.
            load: function (id, url) {
                req.load(context, id, url);
            },

            /**
             * Executes a module callback function. Broken out as a separate function
             * solely to allow the build system to sequence the files in the built
             * layer in the right sequence.
             *
             * @private
             */
            execCb: function (name, callback, args, exports) {
                return callback.apply(exports, args);
            },

            /**
             * callback for script loads, used to check status of loading.
             *
             * @param {Event} evt the event from the browser for the script
             * that was loaded.
             */
            onScriptLoad: function (evt) {
                //Using currentTarget instead of target for Firefox 2.0's sake. Not
                //all old browsers will be supported, but this one was easy enough
                //to support and still makes sense.
                if (evt.type === 'load' ||
                        (readyRegExp.test((evt.currentTarget || evt.srcElement).readyState))) {
                    //Reset interactive script so a script node is not held onto for
                    //to long.
                    interactiveScript = null;

                    //Pull out the name of the module and the context.
                    var data = getScriptData(evt);
                    context.completeLoad(data.id);
                }
            },

            /**
             * Callback for script errors.
             */
            onScriptError: function (evt) {
                var data = getScriptData(evt);
                if (!hasPathFallback(data.id)) {
                    var parents = [];
                    eachProp(registry, function(value, key) {
                        if (key.indexOf('_@r') !== 0) {
                            each(value.depMaps, function(depMap) {
                                if (depMap.id === data.id) {
                                    parents.push(key);
                                    return true;
                                }
                            });
                        }
                    });
                    return onError(makeError('scripterror', 'Script error for "' + data.id +
                                             (parents.length ?
                                             '", needed by: ' + parents.join(', ') :
                                             '"'), evt, [data.id]));
                }
            }
        };

        context.require = context.makeRequire();
        return context;
    }

    /**
     * Main entry point.
     *
     * If the only argument to require is a string, then the module that
     * is represented by that string is fetched for the appropriate context.
     *
     * If the first argument is an array, then it will be treated as an array
     * of dependency string names to fetch. An optional function callback can
     * be specified to execute when all of those dependencies are available.
     *
     * Make a local req variable to help Caja compliance (it assumes things
     * on a require that are not standardized), and to give a short
     * name for minification/local scope use.
     */
    req = requirejs = function (deps, callback, errback, optional) {

        //Find the right context, use default
        var context, config,
            contextName = defContextName;

        // Determine if have config object in the call.
        if (!isArray(deps) && typeof deps !== 'string') {
            // deps is a config object
            config = deps;
            if (isArray(callback)) {
                // Adjust args if there are dependencies
                deps = callback;
                callback = errback;
                errback = optional;
            } else {
                deps = [];
            }
        }

        if (config && config.context) {
            contextName = config.context;
        }

        context = getOwn(contexts, contextName);
        if (!context) {
            context = contexts[contextName] = req.s.newContext(contextName);
        }

        if (config) {
            context.configure(config);
        }

        return context.require(deps, callback, errback);
    };

    /**
     * Support require.config() to make it easier to cooperate with other
     * AMD loaders on globally agreed names.
     */
    req.config = function (config) {
        return req(config);
    };

    /**
     * Execute something after the current tick
     * of the event loop. Override for other envs
     * that have a better solution than setTimeout.
     * @param  {Function} fn function to execute later.
     */
    req.nextTick = typeof setTimeout !== 'undefined' ? function (fn) {
        setTimeout(fn, 4);
    } : function (fn) { fn(); };

    /**
     * Export require as a global, but only if it does not already exist.
     */
    if (!require) {
        require = req;
    }

    req.version = version;

    //Used to filter out dependencies that are already paths.
    req.jsExtRegExp = /^\/|:|\?|\.js$/;
    req.isBrowser = isBrowser;
    s = req.s = {
        contexts: contexts,
        newContext: newContext
    };

    //Create default context.
    req({});

    //Exports some context-sensitive methods on global require.
    each([
        'toUrl',
        'undef',
        'defined',
        'specified'
    ], function (prop) {
        //Reference from contexts instead of early binding to default context,
        //so that during builds, the latest instance of the default context
        //with its config gets used.
        req[prop] = function () {
            var ctx = contexts[defContextName];
            return ctx.require[prop].apply(ctx, arguments);
        };
    });

    if (isBrowser) {
        head = s.head = document.getElementsByTagName('head')[0];
        //If BASE tag is in play, using appendChild is a problem for IE6.
        //When that browser dies, this can be removed. Details in this jQuery bug:
        //http://dev.jquery.com/ticket/2709
        baseElement = document.getElementsByTagName('base')[0];
        if (baseElement) {
            head = s.head = baseElement.parentNode;
        }
    }

    /**
     * Any errors that require explicitly generates will be passed to this
     * function. Intercept/override it if you want custom error handling.
     * @param {Error} err the error object.
     */
    req.onError = defaultOnError;

    /**
     * Creates the node for the load command. Only used in browser envs.
     */
    req.createNode = function (config, moduleName, url) {
        var node = config.xhtml ?
                document.createElementNS('http://www.w3.org/1999/xhtml', 'html:script') :
                document.createElement('script');
        node.type = config.scriptType || 'text/javascript';
        node.charset = 'utf-8';
        node.async = true;
        return node;
    };

    /**
     * Does the request to load a module for the browser case.
     * Make this a separate function to allow other environments
     * to override it.
     *
     * @param {Object} context the require context to find state.
     * @param {String} moduleName the name of the module.
     * @param {Object} url the URL to the module.
     */
    req.load = function (context, moduleName, url) {
        var config = (context && context.config) || {},
            node;
        if (isBrowser) {
            //In the browser so use a script tag
            node = req.createNode(config, moduleName, url);

            node.setAttribute('data-requirecontext', context.contextName);
            node.setAttribute('data-requiremodule', moduleName);

            //Set up load listener. Test attachEvent first because IE9 has
            //a subtle issue in its addEventListener and script onload firings
            //that do not match the behavior of all other browsers with
            //addEventListener support, which fire the onload event for a
            //script right after the script execution. See:
            //https://connect.microsoft.com/IE/feedback/details/648057/script-onload-event-is-not-fired-immediately-after-script-execution
            //UNFORTUNATELY Opera implements attachEvent but does not follow the script
            //script execution mode.
            if (node.attachEvent &&
                    //Check if node.attachEvent is artificially added by custom script or
                    //natively supported by browser
                    //read https://github.com/requirejs/requirejs/issues/187
                    //if we can NOT find [native code] then it must NOT natively supported.
                    //in IE8, node.attachEvent does not have toString()
                    //Note the test for "[native code" with no closing brace, see:
                    //https://github.com/requirejs/requirejs/issues/273
                    !(node.attachEvent.toString && node.attachEvent.toString().indexOf('[native code') < 0) &&
                    !isOpera) {
                //Probably IE. IE (at least 6-8) do not fire
                //script onload right after executing the script, so
                //we cannot tie the anonymous define call to a name.
                //However, IE reports the script as being in 'interactive'
                //readyState at the time of the define call.
                useInteractive = true;

                node.attachEvent('onreadystatechange', context.onScriptLoad);
                //It would be great to add an error handler here to catch
                //404s in IE9+. However, onreadystatechange will fire before
                //the error handler, so that does not help. If addEventListener
                //is used, then IE will fire error before load, but we cannot
                //use that pathway given the connect.microsoft.com issue
                //mentioned above about not doing the 'script execute,
                //then fire the script load event listener before execute
                //next script' that other browsers do.
                //Best hope: IE10 fixes the issues,
                //and then destroys all installs of IE 6-9.
                //node.attachEvent('onerror', context.onScriptError);
            } else {
                node.addEventListener('load', context.onScriptLoad, false);
                node.addEventListener('error', context.onScriptError, false);
            }
            node.src = url;

            //Calling onNodeCreated after all properties on the node have been
            //set, but before it is placed in the DOM.
            if (config.onNodeCreated) {
                config.onNodeCreated(node, config, moduleName, url);
            }

            //For some cache cases in IE 6-8, the script executes before the end
            //of the appendChild execution, so to tie an anonymous define
            //call to the module name (which is stored on the node), hold on
            //to a reference to this node, but clear after the DOM insertion.
            currentlyAddingScript = node;
            if (baseElement) {
                head.insertBefore(node, baseElement);
            } else {
                head.appendChild(node);
            }
            currentlyAddingScript = null;

            return node;
        } else if (isWebWorker) {
            try {
                //In a web worker, use importScripts. This is not a very
                //efficient use of importScripts, importScripts will block until
                //its script is downloaded and evaluated. However, if web workers
                //are in play, the expectation is that a build has been done so
                //that only one script needs to be loaded anyway. This may need
                //to be reevaluated if other use cases become common.

                // Post a task to the event loop to work around a bug in WebKit
                // where the worker gets garbage-collected after calling
                // importScripts(): https://webkit.org/b/153317
                setTimeout(function() {}, 0);
                importScripts(url);

                //Account for anonymous modules
                context.completeLoad(moduleName);
            } catch (e) {
                context.onError(makeError('importscripts',
                                'importScripts failed for ' +
                                    moduleName + ' at ' + url,
                                e,
                                [moduleName]));
            }
        }
    };

    function getInteractiveScript() {
        if (interactiveScript && interactiveScript.readyState === 'interactive') {
            return interactiveScript;
        }

        eachReverse(scripts(), function (script) {
            if (script.readyState === 'interactive') {
                return (interactiveScript = script);
            }
        });
        return interactiveScript;
    }

    //Look for a data-main script attribute, which could also adjust the baseUrl.
    if (isBrowser && !cfg.skipDataMain) {
        //Figure out baseUrl. Get it from the script tag with require.js in it.
        eachReverse(scripts(), function (script) {
            //Set the 'head' where we can append children by
            //using the script's parent.
            if (!head) {
                head = script.parentNode;
            }

            //Look for a data-main attribute to set main script for the page
            //to load. If it is there, the path to data main becomes the
            //baseUrl, if it is not already set.
            dataMain = script.getAttribute('data-main');
            if (dataMain) {
                //Preserve dataMain in case it is a path (i.e. contains '?')
                mainScript = dataMain;

                //Set final baseUrl if there is not already an explicit one,
                //but only do so if the data-main value is not a loader plugin
                //module ID.
                if (!cfg.baseUrl && mainScript.indexOf('!') === -1) {
                    //Pull off the directory of data-main for use as the
                    //baseUrl.
                    src = mainScript.split('/');
                    mainScript = src.pop();
                    subPath = src.length ? src.join('/')  + '/' : './';

                    cfg.baseUrl = subPath;
                }

                //Strip off any trailing .js since mainScript is now
                //like a module name.
                mainScript = mainScript.replace(jsSuffixRegExp, '');

                //If mainScript is still a path, fall back to dataMain
                if (req.jsExtRegExp.test(mainScript)) {
                    mainScript = dataMain;
                }

                //Put the data-main script in the files to load.
                cfg.deps = cfg.deps ? cfg.deps.concat(mainScript) : [mainScript];

                return true;
            }
        });
    }

    /**
     * The function that handles definitions of modules. Differs from
     * require() in that a string for the module should be the first argument,
     * and the function to execute after dependencies are loaded should
     * return a value to define the module corresponding to the first argument's
     * name.
     */
    define = function (name, deps, callback) {
        var node, context;

        //Allow for anonymous modules
        if (typeof name !== 'string') {
            //Adjust args appropriately
            callback = deps;
            deps = name;
            name = null;
        }

        //This module may not have dependencies
        if (!isArray(deps)) {
            callback = deps;
            deps = null;
        }

        //If no name, and callback is a function, then figure out if it a
        //CommonJS thing with dependencies.
        if (!deps && isFunction(callback)) {
            deps = [];
            //Remove comments from the callback string,
            //look for require calls, and pull them into the dependencies,
            //but only if there are function args.
            if (callback.length) {
                callback
                    .toString()
                    .replace(commentRegExp, commentReplace)
                    .replace(cjsRequireRegExp, function (match, dep) {
                        deps.push(dep);
                    });

                //May be a CommonJS thing even without require calls, but still
                //could use exports, and module. Avoid doing exports and module
                //work though if it just needs require.
                //REQUIRES the function to expect the CommonJS variables in the
                //order listed below.
                deps = (callback.length === 1 ? ['require'] : ['require', 'exports', 'module']).concat(deps);
            }
        }

        //If in IE 6-8 and hit an anonymous define() call, do the interactive
        //work.
        if (useInteractive) {
            node = currentlyAddingScript || getInteractiveScript();
            if (node) {
                if (!name) {
                    name = node.getAttribute('data-requiremodule');
                }
                context = contexts[node.getAttribute('data-requirecontext')];
            }
        }

        //Always save off evaluating the def call until the script onload handler.
        //This allows multiple modules to be in a file without prematurely
        //tracing dependencies, and allows for anonymous module support,
        //where the module name is not known until the script onload event
        //occurs. If no context, use the global queue, and get it processed
        //in the onscript load callback.
        if (context) {
            context.defQueue.push([name, deps, callback]);
            context.defQueueMap[name] = true;
        } else {
            globalDefQueue.push([name, deps, callback]);
        }
    };

    define.amd = {
        jQuery: true
    };

    /**
     * Executes the text. Normally just uses eval, but can be modified
     * to use a better, environment-specific call. Only used for transpiling
     * loader plugins, not for plain JS modules.
     * @param {String} text the text to execute/evaluate.
     */
    req.exec = function (text) {
        /*jslint evil: true */
        return eval(text);
    };

    //Set up with config info.
    req(cfg);
}(this, (typeof setTimeout === 'undefined' ? undefined : setTimeout)));

", + "ok": true, + "headers": [ + [ + "content-type", + "text/javascript; charset=utf-8" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6006/icon_bundle.svg": { + "data": "<?xml version="1.0" ?><svg><defs><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="add_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M19 13h-6v6h-2v-6H5v-2h6V5h2v6h6v2z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="arrow_back_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M20 11H7.83l5.59-5.59L12 4l-8 8 8 8 1.41-1.41L7.83 13H20v-2z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="arrow_downward_24px"><path fill="#010101" d="M20 12l-1.41-1.41L13 16.17V4h-2v12.17l-5.58-5.59L4 12l8 8 8-8z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="arrow_forward_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M12 4l-1.41 1.41L16.17 11H4v2h12.17l-5.58 5.59L12 20l8-8z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="arrow_upward_24px"><path d="M4 12l1.41 1.41L11 7.83V20h2V7.83l5.58 5.59L20 12l-8-8-8 8z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="brightness_6_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M20 15.31L23.31 12 20 8.69V4h-4.69L12 .69 8.69 4H4v4.69L.69 12 4 15.31V20h4.69L12 23.31 15.31 20H20v-4.69zM12 18V6c3.31 0 6 2.69 6 6s-2.69 6-6 6z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="bug_report_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M20 8h-2.81c-.45-.78-1.07-1.45-1.82-1.96L17 4.41 15.59 3l-2.17 2.17C12.96 5.06 12.49 5 12 5c-.49 0-.96.06-1.41.17L8.41 3 7 4.41l1.62 1.63C7.88 6.55 7.26 7.22 6.81 8H4v2h2.09c-.05.33-.09.66-.09 1v1H4v2h2v1c0 .34.04.67.09 1H4v2h2.81c1.04 1.79 2.97 3 5.19 3s4.15-1.21 5.19-3H20v-2h-2.09c.05-.33.09-.66.09-1v-1h2v-2h-2v-1c0-.34-.04-.67-.09-1H20V8zm-6 8h-4v-2h4v2zm0-4h-4v-2h4v2z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="cancel_24px"><path d="M12 2C6.47 2 2 6.47 2 12s4.47 10 10 10 10-4.47 10-10S17.53 2 12 2zm5 13.59L15.59 17 12 13.41 8.41 17 7 15.59 10.59 12 7 8.41 8.41 7 12 10.59 15.59 7 17 8.41 13.41 12 17 15.59z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="change_history_24px"><path d="M12 7.77L18.39 18H5.61L12 7.77M12 4L2 20h20L12 4z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="chevron_left_24px"><path d="M15.41 7.41L14 6l-6 6 6 6 1.41-1.41L10.83 12z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="chevron_right_24px"><path d="M10 6L8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="clear_24px"><path d="M19 6.41L17.59 5 12 10.59 6.41 5 5 6.41 10.59 12 5 17.59 6.41 19 12 13.41 17.59 19 19 17.59 13.41 12z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="close_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M19 6.41L17.59 5 12 10.59 6.41 5 5 6.41 10.59 12 5 17.59 6.41 19 12 13.41 17.59 19 19 17.59 13.41 12z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="content_copy_24px"><path d="M16 1H4c-1.1 0-2 .9-2 2v14h2V3h12V1zm3 4H8c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h11c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2zm0 16H8V7h11v14z"/></svg><svg xmlns="http://www.w3.org/2000/svg" enable-background="new 0 0 24 24" height="24" viewBox="0 0 24 24" width="24" id="dark_mode_24px"><rect fill="none" height="24" width="24"/><path d="M12,3c-4.97,0-9,4.03-9,9s4.03,9,9,9s9-4.03,9-9c0-0.46-0.04-0.92-0.1-1.36c-0.98,1.37-2.58,2.26-4.4,2.26 c-2.98,0-5.4-2.42-5.4-5.4c0-1.81,0.89-3.42,2.26-4.4C12.92,3.04,12.46,3,12,3L12,3z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="done_24px"><path d="M9 16.2L4.8 12l-1.4 1.4L9 19 21 7l-1.4-1.4L9 16.2z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="drag_indicator_24px"><path d="M0 0h24v24H0V0z" fill="none"/><path d="M11 18c0 1.1-.9 2-2 2s-2-.9-2-2 .9-2 2-2 2 .9 2 2zm-2-8c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm0-6c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm6 4c1.1 0 2-.9 2-2s-.9-2-2-2-2 .9-2 2 .9 2 2 2zm0 2c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm0 6c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="edit_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M3 17.25V21h3.75L17.81 9.94l-3.75-3.75L3 17.25zM20.71 7.04c.39-.39.39-1.02 0-1.41l-2.34-2.34c-.39-.39-1.02-.39-1.41 0l-1.83 1.83 3.75 3.75 1.83-1.83z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="error_24px"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm1 15h-2v-2h2v2zm0-4h-2V7h2v6z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="expand_less_24px"><path d="M12 8l-6 6 1.41 1.41L12 10.83l4.59 4.58L18 14z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="expand_more_24px"><path d="M16.59 8.59L12 13.17 7.41 8.59 6 10l6 6 6-6z"/></svg><svg xmlns="http://www.w3.org/2000/svg" enable-background="new 0 0 24 24" height="24" viewBox="0 0 24 24" width="24" id="filter_alt_24px"><g><path d="M0,0h24 M24,24H0" fill="none"/><path d="M4.25,5.61C6.27,8.2,10,13,10,13v6c0,0.55,0.45,1,1,1h2c0.55,0,1-0.45,1-1v-6c0,0,3.72-4.8,5.74-7.39 C20.25,4.95,19.78,4,18.95,4H5.04C4.21,4,3.74,4.95,4.25,5.61z"/><path d="M0,0h24v24H0V0z" fill="none"/></g></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="flag_24px"><path d="M14.4 6L14 4H5v17h2v-7h5.6l.4 2h7V6z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="fullscreen_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M7 14H5v5h5v-2H7v-3zm-2-4h2V7h3V5H5v5zm12 7h-3v2h5v-5h-2v3zM14 5v2h3v3h2V5h-5z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="fullscreen_exit_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M5 16h3v3h2v-5H5v2zm3-8H5v2h5V5H8v3zm6 11h2v-3h3v-2h-5v5zm2-11V5h-2v5h5V8h-3z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="get_app_24px"><path d="M19 9h-4V3H9v6H5l7 7 7-7zM5 18v2h14v-2H5z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="group_work_24px"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zM8 17.5c-1.38 0-2.5-1.12-2.5-2.5s1.12-2.5 2.5-2.5 2.5 1.12 2.5 2.5-1.12 2.5-2.5 2.5zM9.5 8c0-1.38 1.12-2.5 2.5-2.5s2.5 1.12 2.5 2.5-1.12 2.5-2.5 2.5S9.5 9.38 9.5 8zm6.5 9.5c-1.38 0-2.5-1.12-2.5-2.5s1.12-2.5 2.5-2.5 2.5 1.12 2.5 2.5-1.12 2.5-2.5 2.5z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="help_outline_24px"><path d="M11 18h2v-2h-2v2zm1-16C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8zm0-14c-2.21 0-4 1.79-4 4h2c0-1.1.9-2 2-2s2 .9 2 2c0 2-3 1.75-3 5h2c0-2.25 3-2.5 3-5 0-2.21-1.79-4-4-4z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="image_search_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M0 0h24v24H0V0z" fill="none"/><path d="M18 13v7H4V6h5.02c.05-.71.22-1.38.48-2H4c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2v-5l-2-2zm-1.5 5h-11l2.75-3.53 1.96 2.36 2.75-3.54zm2.8-9.11c.44-.7.7-1.51.7-2.39C20 4.01 17.99 2 15.5 2S11 4.01 11 6.5s2.01 4.5 4.49 4.5c.88 0 1.7-.26 2.39-.7L21 13.42 22.42 12 19.3 8.89zM15.5 9C14.12 9 13 7.88 13 6.5S14.12 4 15.5 4 18 5.12 18 6.5 16.88 9 15.5 9z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="info_outline_24px"><path d="M11 17h2v-6h-2v6zm1-15C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8zM11 9h2V7h-2v2z"/></svg><svg xmlns="http://www.w3.org/2000/svg" enable-background="new 0 0 24 24" height="24" viewBox="0 0 24 24" width="24" id="keep_24px"><g><rect fill="none" height="24" width="24"/></g><g><path d="M16,9V4l1,0c0.55,0,1-0.45,1-1v0c0-0.55-0.45-1-1-1H7C6.45,2,6,2.45,6,3v0 c0,0.55,0.45,1,1,1l1,0v5c0,1.66-1.34,3-3,3h0v2h5.97v7l1,1l1-1v-7H19v-2h0C17.34,12,16,10.66,16,9z" fill-rule="evenodd"/></g></svg><svg xmlns="http://www.w3.org/2000/svg" enable-background="new 0 0 24 24" height="24" viewBox="0 0 24 24" width="24" id="keep_outline_24px"><g><rect fill="none" height="24" width="24"/></g><g><path d="M14,4v5c0,1.12,0.37,2.16,1,3H9c0.65-0.86,1-1.9,1-3V4H14 M17,2H7C6.45,2,6,2.45,6,3c0,0.55,0.45,1,1,1c0,0,0,0,0,0l1,0v5 c0,1.66-1.34,3-3,3v2h5.97v7l1,1l1-1v-7H19v-2c0,0,0,0,0,0c-1.66,0-3-1.34-3-3V4l1,0c0,0,0,0,0,0c0.55,0,1-0.45,1-1 C18,2.45,17.55,2,17,2L17,2z"/></g></svg><svg xmlns="http://www.w3.org/2000/svg" enable-background="new 0 0 24 24" height="24" viewBox="0 0 24 24" width="24" id="light_mode_24px"><rect fill="none" height="24" width="24"/><path d="M12,7c-2.76,0-5,2.24-5,5s2.24,5,5,5s5-2.24,5-5S14.76,7,12,7L12,7z M2,13l2,0c0.55,0,1-0.45,1-1s-0.45-1-1-1l-2,0 c-0.55,0-1,0.45-1,1S1.45,13,2,13z M20,13l2,0c0.55,0,1-0.45,1-1s-0.45-1-1-1l-2,0c-0.55,0-1,0.45-1,1S19.45,13,20,13z M11,2v2 c0,0.55,0.45,1,1,1s1-0.45,1-1V2c0-0.55-0.45-1-1-1S11,1.45,11,2z M11,20v2c0,0.55,0.45,1,1,1s1-0.45,1-1v-2c0-0.55-0.45-1-1-1 C11.45,19,11,19.45,11,20z M5.99,4.58c-0.39-0.39-1.03-0.39-1.41,0c-0.39,0.39-0.39,1.03,0,1.41l1.06,1.06 c0.39,0.39,1.03,0.39,1.41,0s0.39-1.03,0-1.41L5.99,4.58z M18.36,16.95c-0.39-0.39-1.03-0.39-1.41,0c-0.39,0.39-0.39,1.03,0,1.41 l1.06,1.06c0.39,0.39,1.03,0.39,1.41,0c0.39-0.39,0.39-1.03,0-1.41L18.36,16.95z M19.42,5.99c0.39-0.39,0.39-1.03,0-1.41 c-0.39-0.39-1.03-0.39-1.41,0l-1.06,1.06c-0.39,0.39-0.39,1.03,0,1.41s1.03,0.39,1.41,0L19.42,5.99z M7.05,18.36 c0.39-0.39,0.39-1.03,0-1.41c-0.39-0.39-1.03-0.39-1.41,0l-1.06,1.06c-0.39,0.39-0.39,1.03,0,1.41s1.03,0.39,1.41,0L7.05,18.36z"/></svg><svg xmlns="http://www.w3.org/2000/svg" enable-background="new 0 0 24 24" height="24" viewBox="0 0 24 24" width="24" id="line_weight_24px"><g><rect fill="none" height="24" width="24" x="0"/></g><g><g><g><path d="M3,17h18v-2H3V17z M3,20h18v-1H3V20z M3,13h18v-3H3V13z M3,4v4h18V4H3z"/></g></g></g></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="more_vert_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M12 8c1.1 0 2-.9 2-2s-.9-2-2-2-2 .9-2 2 .9 2 2 2zm0 2c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm0 6c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="notifications_none_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M12 22c1.1 0 2-.9 2-2h-4c0 1.1.9 2 2 2zm6-6v-5c0-3.07-1.63-5.64-4.5-6.32V4c0-.83-.67-1.5-1.5-1.5s-1.5.67-1.5 1.5v.68C7.64 5.36 6 7.92 6 11v5l-2 2v1h16v-1l-2-2zm-2 1H8v-6c0-2.48 1.51-4.5 4-4.5s4 2.02 4 4.5v6z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="palette_24px"><path d="M12 3c-4.97 0-9 4.03-9 9s4.03 9 9 9c.83 0 1.5-.67 1.5-1.5 0-.39-.15-.74-.39-1.01-.23-.26-.38-.61-.38-.99 0-.83.67-1.5 1.5-1.5H16c2.76 0 5-2.24 5-5 0-4.42-4.03-8-9-8zm-5.5 9c-.83 0-1.5-.67-1.5-1.5S5.67 9 6.5 9 8 9.67 8 10.5 7.33 12 6.5 12zm3-4C8.67 8 8 7.33 8 6.5S8.67 5 9.5 5s1.5.67 1.5 1.5S10.33 8 9.5 8zm5 0c-.83 0-1.5-.67-1.5-1.5S13.67 5 14.5 5s1.5.67 1.5 1.5S15.33 8 14.5 8zm3 4c-.83 0-1.5-.67-1.5-1.5S16.67 9 17.5 9s1.5.67 1.5 1.5-.67 1.5-1.5 1.5z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="refresh_24px"><path d="M17.65 6.35C16.2 4.9 14.21 4 12 4c-4.42 0-7.99 3.58-7.99 8s3.57 8 7.99 8c3.73 0 6.84-2.55 7.73-6h-2.08c-.82 2.33-3.04 4-5.65 4-3.31 0-6-2.69-6-6s2.69-6 6-6c1.66 0 3.14.69 4.22 1.78L13 11h7V4l-2.35 2.35z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="search_24px"><path d="M15.5 14h-.79l-.28-.27C15.41 12.59 16 11.11 16 9.5 16 5.91 13.09 3 9.5 3S3 5.91 3 9.5 5.91 16 9.5 16c1.61 0 3.09-.59 4.23-1.57l.27.28v.79l5 4.99L20.49 19l-4.99-5zm-6 0C7.01 14 5 11.99 5 9.5S7.01 5 9.5 5 14 7.01 14 9.5 11.99 14 9.5 14z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="settings_24px"><path d="M19.43 12.98c.04-.32.07-.64.07-.98s-.03-.66-.07-.98l2.11-1.65c.19-.15.24-.42.12-.64l-2-3.46c-.12-.22-.39-.3-.61-.22l-2.49 1c-.52-.4-1.08-.73-1.69-.98l-.38-2.65C14.46 2.18 14.25 2 14 2h-4c-.25 0-.46.18-.49.42l-.38 2.65c-.61.25-1.17.59-1.69.98l-2.49-1c-.23-.09-.49 0-.61.22l-2 3.46c-.13.22-.07.49.12.64l2.11 1.65c-.04.32-.07.65-.07.98s.03.66.07.98l-2.11 1.65c-.19.15-.24.42-.12.64l2 3.46c.12.22.39.3.61.22l2.49-1c.52.4 1.08.73 1.69.98l.38 2.65c.03.24.24.42.49.42h4c.25 0 .46-.18.49-.42l.38-2.65c.61-.25 1.17-.59 1.69-.98l2.49 1c.23.09.49 0 .61-.22l2-3.46c.12-.22.07-.49-.12-.64l-2.11-1.65zM12 15.5c-1.93 0-3.5-1.57-3.5-3.5s1.57-3.5 3.5-3.5 3.5 1.57 3.5 3.5-1.57 3.5-3.5 3.5z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="settings_backup_restore_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M14 12c0-1.1-.9-2-2-2s-2 .9-2 2 .9 2 2 2 2-.9 2-2zm-2-9c-4.97 0-9 4.03-9 9H0l4 4 4-4H5c0-3.87 3.13-7 7-7s7 3.13 7 7-3.13 7-7 7c-1.51 0-2.91-.49-4.06-1.3l-1.42 1.44C8.04 20.3 9.94 21 12 21c4.97 0 9-4.03 9-9s-4.03-9-9-9z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="settings_overscan_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M12.01 5.5L10 8h4l-1.99-2.5zM18 10v4l2.5-1.99L18 10zM6 10l-2.5 2.01L6 14v-4zm8 6h-4l2.01 2.5L14 16zm7-13H3c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16.01H3V4.99h18v14.02z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="visibility_off_24px"><path d="M12 7c2.76 0 5 2.24 5 5 0 .65-.13 1.26-.36 1.83l2.92 2.92c1.51-1.26 2.7-2.89 3.43-4.75-1.73-4.39-6-7.5-11-7.5-1.4 0-2.74.25-3.98.7l2.16 2.16C10.74 7.13 11.35 7 12 7zM2 4.27l2.28 2.28.46.46C3.08 8.3 1.78 10.02 1 12c1.73 4.39 6 7.5 11 7.5 1.55 0 3.03-.3 4.38-.84l.42.42L19.73 22 21 20.73 3.27 3 2 4.27zM7.53 9.8l1.55 1.55c-.05.21-.08.43-.08.65 0 1.66 1.34 3 3 3 .22 0 .44-.03.65-.08l1.55 1.55c-.67.33-1.41.53-2.2.53-2.76 0-5-2.24-5-5 0-.79.2-1.53.53-2.2zm4.31-.78l3.15 3.15.02-.16c0-1.66-1.34-3-3-3l-.17.01z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="warning_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M1 21h22L12 2 1 21zm12-3h-2v-2h2v2zm0-4h-2v-4h2v4z"/></svg></defs></svg>
", + "ok": true, + "headers": [ + [ + "content-type", + "image/svg+xml; charset=utf-8" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6006/font-roboto/RxZJdnzeo3R5zSexge8UUZBw1xU1rKptJj_0jans920.woff2": { + "data": "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", + "ok": true, + "headers": [ + [ + "content-type", + "font/woff2" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6006/data/plugins_listing": { + "data": "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", + "ok": true, + "headers": [ + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6006/data/environment": { + "data": "eyJ2ZXJzaW9uIjogIjIuMTUuMSIsICJkYXRhX2xvY2F0aW9uIjogImxvZ3MvZml0IiwgIndpbmRvd190aXRsZSI6ICIiLCAiZXhwZXJpbWVudF9uYW1lIjogIiIsICJleHBlcmltZW50X2Rlc2NyaXB0aW9uIjogIiIsICJjcmVhdGlvbl90aW1lIjogMC4wLCAiZGVidWciOiB7ImRhdGFfcHJvdmlkZXIiOiAiR3JwY0RhdGFQcm92aWRlcihhZGRyPSdsb2NhbGhvc3Q6NDU5ODknKSIsICJmbGFncyI6IHsibG9nZGlyIjogImxvZ3MvZml0IiwgImxvZ2Rpcl9zcGVjIjogIiIsICJob3N0IjogbnVsbCwgImJpbmRfYWxsIjogZmFsc2UsICJwb3J0IjogbnVsbCwgInJldXNlX3BvcnQiOiBmYWxzZSwgImxvYWRfZmFzdCI6ICJhdXRvIiwgImV4dHJhX2RhdGFfc2VydmVyX2ZsYWdzIjogIiIsICJncnBjX2NyZWRzX3R5cGUiOiAibG9jYWwiLCAiZ3JwY19kYXRhX3Byb3ZpZGVyIjogIiIsICJwdXJnZV9vcnBoYW5lZF9kYXRhIjogdHJ1ZSwgImRiIjogIiIsICJkYl9pbXBvcnQiOiBmYWxzZSwgImluc3BlY3QiOiBmYWxzZSwgInZlcnNpb25fdGIiOiBmYWxzZSwgInRhZyI6ICIiLCAiZXZlbnRfZmlsZSI6ICIiLCAicGF0aF9wcmVmaXgiOiAiIiwgIndpbmRvd190aXRsZSI6ICIiLCAibWF4X3JlbG9hZF90aHJlYWRzIjogMSwgInJlbG9hZF9pbnRlcnZhbCI6IDUuMCwgInJlbG9hZF90YXNrIjogImF1dG8iLCAicmVsb2FkX211bHRpZmlsZSI6IG51bGwsICJyZWxvYWRfbXVsdGlmaWxlX2luYWN0aXZlX3NlY3MiOiA4NjQwMCwgImdlbmVyaWNfZGF0YSI6ICJhdXRvIiwgInNhbXBsZXNfcGVyX3BsdWdpbiI6IHt9LCAiZGV0ZWN0X2ZpbGVfcmVwbGFjZW1lbnQiOiBudWxsLCAiX190ZW5zb3Jib2FyZF9zdWJjb21tYW5kIjogInNlcnZlIn19fQ==", + "ok": true, + "headers": [ + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6006/data/runs": { + "data": "WyIxMF9wZXJjZW50X2ZlYXR1cmVfZXh0cmFjdC8yMDI0MDExNC0xMzM4MDgvdHJhaW4iLCAiMTBfcGVyY2VudF9mZWF0dXJlX2V4dHJhY3QvMjAyNDAxMTQtMTMzODA4L3ZhbGlkYXRpb24iLCAiMV9wZXJjZW50X2RhdGFfYXVnLzIwMjQwMTE0LTEzMzkxMy90cmFpbiIsICIxX3BlcmNlbnRfZGF0YV9hdWcvMjAyNDAxMTQtMTMzOTEzL3ZhbGlkYXRpb24iLCAiMTBfcGVyY2VudF9kYXRhX2F1Zy8yMDI0MDExNC0xMzQwMDkvdHJhaW4iLCAiMTBfcGVyY2VudF9kYXRhX2F1Zy8yMDI0MDExNC0xMzQwMDkvdmFsaWRhdGlvbiIsICIxMF9wZXJjZW50X2ZpbmVfdHVuZV9sYXN0XzEwLzIwMjQwMTE0LTEzNDMxMS90cmFpbiIsICIxMF9wZXJjZW50X2ZpbmVfdHVuZV9sYXN0XzEwLzIwMjQwMTE0LTEzNDMxMS92YWxpZGF0aW9uIiwgImZ1bGxfMTBfY2xhc3Nlc19maW5lX3R1bmVfbGFzdF8xMC8yMDI0MDExNC0xMzQ2MTIvdHJhaW4iLCAiZnVsbF8xMF9jbGFzc2VzX2ZpbmVfdHVuZV9sYXN0XzEwLzIwMjQwMTE0LTEzNDYxMi92YWxpZGF0aW9uIl0=", + "ok": true, + "headers": [ + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6006/experiment/defaultExperimentId/data/plugin/hparams/experiment?request=%7B%22experimentName%22:%22defaultExperimentId%22%7D": { + "data": "ewogICJuYW1lIjogIiIsCiAgImRlc2NyaXB0aW9uIjogIiIsCiAgInVzZXIiOiAiIiwKICAidGltZUNyZWF0ZWRTZWNzIjogMC4wLAogICJocGFyYW1JbmZvcyI6IFtdLAogICJtZXRyaWNJbmZvcyI6IFtdCn0=", + "ok": true, + "headers": [ + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6006/experiment/defaultExperimentId/data/runs": { + "data": "WyIxMF9wZXJjZW50X2ZlYXR1cmVfZXh0cmFjdC8yMDI0MDExNC0xMzM4MDgvdHJhaW4iLCAiMTBfcGVyY2VudF9mZWF0dXJlX2V4dHJhY3QvMjAyNDAxMTQtMTMzODA4L3ZhbGlkYXRpb24iLCAiMV9wZXJjZW50X2RhdGFfYXVnLzIwMjQwMTE0LTEzMzkxMy90cmFpbiIsICIxX3BlcmNlbnRfZGF0YV9hdWcvMjAyNDAxMTQtMTMzOTEzL3ZhbGlkYXRpb24iLCAiMTBfcGVyY2VudF9kYXRhX2F1Zy8yMDI0MDExNC0xMzQwMDkvdHJhaW4iLCAiMTBfcGVyY2VudF9kYXRhX2F1Zy8yMDI0MDExNC0xMzQwMDkvdmFsaWRhdGlvbiIsICIxMF9wZXJjZW50X2ZpbmVfdHVuZV9sYXN0XzEwLzIwMjQwMTE0LTEzNDMxMS90cmFpbiIsICIxMF9wZXJjZW50X2ZpbmVfdHVuZV9sYXN0XzEwLzIwMjQwMTE0LTEzNDMxMS92YWxpZGF0aW9uIiwgImZ1bGxfMTBfY2xhc3Nlc19maW5lX3R1bmVfbGFzdF8xMC8yMDI0MDExNC0xMzQ2MTIvdHJhaW4iLCAiZnVsbF8xMF9jbGFzc2VzX2ZpbmVfdHVuZV9sYXN0XzEwLzIwMjQwMTE0LTEzNDYxMi92YWxpZGF0aW9uIl0=", + "ok": true, + "headers": [ + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6006/experiment/defaultExperimentId/data/plugin/hparams/session_groups?request=%7B%22experimentName%22:%22defaultExperimentId%22,%22allowedStatuses%22:%5B%22STATUS_FAILURE%22,%22STATUS_RUNNING%22,%22STATUS_SUCCESS%22,%22STATUS_UNKNOWN%22%5D,%22colParams%22:%5B%5D,%22startIndex%22:0,%22sliceSize%22:1000000%7D": { + "data": "ewogICJzZXNzaW9uR3JvdXBzIjogW10sCiAgInRvdGFsU2l6ZSI6IDAKfQ==", + "ok": true, + "headers": [ + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6006/experiment/defaultExperimentId/data/plugin/timeseries/tags": { + "data": "eyJzY2FsYXJzIjogeyJydW5UYWdJbmZvIjogeyIxMF9wZXJjZW50X2ZpbmVfdHVuZV9sYXN0XzEwLzIwMjQwMTE0LTEzNDMxMS92YWxpZGF0aW9uIjogWyJlcG9jaF9hY2N1cmFjeSIsICJlcG9jaF9sb3NzIiwgImV2YWx1YXRpb25fYWNjdXJhY3lfdnNfaXRlcmF0aW9ucyIsICJldmFsdWF0aW9uX2xvc3NfdnNfaXRlcmF0aW9ucyJdLCAiMTBfcGVyY2VudF9mZWF0dXJlX2V4dHJhY3QvMjAyNDAxMTQtMTMzODA4L3RyYWluIjogWyJlcG9jaF9hY2N1cmFjeSIsICJlcG9jaF9sb3NzIl0sICIxMF9wZXJjZW50X2ZlYXR1cmVfZXh0cmFjdC8yMDI0MDExNC0xMzM4MDgvdmFsaWRhdGlvbiI6IFsiZXBvY2hfYWNjdXJhY3kiLCAiZXBvY2hfbG9zcyIsICJldmFsdWF0aW9uX2FjY3VyYWN5X3ZzX2l0ZXJhdGlvbnMiLCAiZXZhbHVhdGlvbl9sb3NzX3ZzX2l0ZXJhdGlvbnMiXSwgIjFfcGVyY2VudF9kYXRhX2F1Zy8yMDI0MDExNC0xMzM5MTMvdHJhaW4iOiBbImVwb2NoX2FjY3VyYWN5IiwgImVwb2NoX2xvc3MiXSwgIjFfcGVyY2VudF9kYXRhX2F1Zy8yMDI0MDExNC0xMzM5MTMvdmFsaWRhdGlvbiI6IFsiZXBvY2hfYWNjdXJhY3kiLCAiZXBvY2hfbG9zcyIsICJldmFsdWF0aW9uX2FjY3VyYWN5X3ZzX2l0ZXJhdGlvbnMiLCAiZXZhbHVhdGlvbl9sb3NzX3ZzX2l0ZXJhdGlvbnMiXSwgImZ1bGxfMTBfY2xhc3Nlc19maW5lX3R1bmVfbGFzdF8xMC8yMDI0MDExNC0xMzQ2MTIvdmFsaWRhdGlvbiI6IFsiZXBvY2hfYWNjdXJhY3kiLCAiZXBvY2hfbG9zcyIsICJldmFsdWF0aW9uX2FjY3VyYWN5X3ZzX2l0ZXJhdGlvbnMiLCAiZXZhbHVhdGlvbl9sb3NzX3ZzX2l0ZXJhdGlvbnMiXSwgIjEwX3BlcmNlbnRfZGF0YV9hdWcvMjAyNDAxMTQtMTM0MDA5L3ZhbGlkYXRpb24iOiBbImVwb2NoX2FjY3VyYWN5IiwgImVwb2NoX2xvc3MiLCAiZXZhbHVhdGlvbl9hY2N1cmFjeV92c19pdGVyYXRpb25zIiwgImV2YWx1YXRpb25fbG9zc192c19pdGVyYXRpb25zIl0sICJmdWxsXzEwX2NsYXNzZXNfZmluZV90dW5lX2xhc3RfMTAvMjAyNDAxMTQtMTM0NjEyL3RyYWluIjogWyJlcG9jaF9hY2N1cmFjeSIsICJlcG9jaF9sb3NzIl0sICIxMF9wZXJjZW50X2ZpbmVfdHVuZV9sYXN0XzEwLzIwMjQwMTE0LTEzNDMxMS90cmFpbiI6IFsiZXBvY2hfYWNjdXJhY3kiLCAiZXBvY2hfbG9zcyJdLCAiMTBfcGVyY2VudF9kYXRhX2F1Zy8yMDI0MDExNC0xMzQwMDkvdHJhaW4iOiBbImVwb2NoX2FjY3VyYWN5IiwgImVwb2NoX2xvc3MiXX0sICJ0YWdEZXNjcmlwdGlvbnMiOiB7fX0sICJoaXN0b2dyYW1zIjogeyJydW5UYWdJbmZvIjoge30sICJ0YWdEZXNjcmlwdGlvbnMiOiB7fX0sICJpbWFnZXMiOiB7InRhZ0Rlc2NyaXB0aW9ucyI6IHt9LCAidGFnUnVuU2FtcGxlZEluZm8iOiB7fX19", + "ok": true, + "headers": [ + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6006/font-roboto/vPcynSL0qHq_6dX7lKVByXYhjbSpvc47ee6xR_80Hnw.woff2": { + "data": "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", + "ok": true, + "headers": [ + [ + "content-type", + "font/woff2" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6006/font-roboto/d-6IYplOFocCacKzxwXSOJBw1xU1rKptJj_0jans920.woff2": { + "data": "d09GMgABAAAAACoMAA4AAAAAUsQAACm2AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGmQbmXocg0oGYACGTBEMCu5A1nULg14AATYCJAOHNgQgBYJ+ByAbIkSzoqzwsjiKkj2aj6JicZf9lwnmGDrzUL5ooaWgICnvqxcvLU1UUm052dq0PPEbkDL7t7A4c3dKponrEu8IjX2Sy0PoX9DLJNk9AHsAO6uC0MkqVZH48wM/t95fEVEDtBGpESMixmDAqNgYMLpGpmSIhFWEFSiIoIiFRIli3p2nHuksZyTDeXbXshPuAKlMlW53Zbg7HZue7/8N06wSlnxFE+rSAhYVkmR44D5FCo4yXQlcOX/hZsHaQuZYMcQ8fkufGldr+uACwqKNzkSGPbR7G1BVUZ3KOl0lGRYOQuDT2zTbfVpvBF5fojuuchvk6YE73cxV6dJS//W/1qu/X2vQGiTZDshHKx3JCpgmIwjIGl8FXKUCLIGkY12AuaMOqUzRXNWnLQmqS1HWqdIFnu/vG79/2raDcUAPMPAMtn38TkB/ouZjIAEmGGgThZmsWZkYwdIwtsYh6+N7ZqYra0NPaN1poDFKzhjB6Ep9/G4ZTnWidqQaNBB6+Y1RoPACsDkUTvsZQJjzgUiWDJEtGyJXLgQLC6JIEUSJMohOPVAu+QiBQAHTADNAgAKRDAGmosIAZt317VxBcvfkGAZI7h0THA6SB/jHRYIkDOBDaNj+e8ZEAjtwbBhGLXC2MFFLe6nWKwp1sS6WQ4VY39XdhkP/X4wChWLH4FC8KPFQDqMIiLjGjWJFabOIvvgn/jQ7N9ClKlWDRqlUq8XUxVp68cWGQ7/D+N36//YNN54bY0H9DUgUJtSPLQYOF25C9jvokMOOOE6FOg0EmrQR6dJnwJA1G3YcOXNB4obCkxdvvmrUqtfgksuuuOqa68ZNmDTlhpvue+ChRx6bteiVJa8t+2DFqjXrdnyE0M5bMIiE6TpAn6hZohBCyQ4q+IddgvVd259GlFOFNmHm+YZlbrMiWMMWJJCru+Uaj9zimRu8ySnLbXUJGnkTtMtp5Aqu4hquY1x71htzeI55LOCF9rJti3iFJbzGB6xgFWtY1zbasoktbGs7bfiYRnjlVP+hPoJCwSt7WIClnW8Rc4Vu7tDP12bBMR5M8483PCX8SrDD5C1uOcErZ0QkQ1pGyk5TrDylKDth8BBmTIBbLvMnBPCBG9uCt+WBq3CUc5cOYxpP8BQzexSGw49L58kUZJkbrABr2IJMeXnZ7NTgV8uoR4P2sg2LeIUlvK6OqM1GXCxzhxXBGrYgowwvsYhXWMLrdWPYEEahxosAu8OGlMtrXNyHhK8kWMUa1veMxZ95BFGHRjTRCLGDHexgBzsEexZimY2sYA1bh5RM5GSge4rzwqVs5y8Zi3iFJbzWPsS0glWsYV0g5P5oijmKkp9O3nw7kCfXGOc3/jcHxSZ3fc4WRHYgzYszl8Xt4s0nAnMbv+OWL1BmKuw9jcgRaflYdnZg5ZSinHQinwkpJtdyISq/Exs8UN0JBvTnxrwgTdysfiY754dWTK8Zted21jPU8/6ErTbDLJtDyepp3/I79jzdpwqjW9NkvFDxcrFn8ct7uyI/Nw20ef7NquSYG/mY2X3qX1lrwCxM5fcKo/9ELfnuZQg72j1T/muh/JezBlNxFtf0x58eYNG3oste6z3I1ae4pvIFyU8FzkQfejHes5fRm2qnDgIE807LfcaTOpsEUuLOw/wOZH8rylWi04VRGvkSdfjzXLcqGTZ0Ft8w4B8+d+iZ6+vzC6o0sWYSH/HEcH5jFetUsY0j935Npssg79F/4F6kHQmLa1Ms9Va9TLCHGVYlSVrgX3FCh77jG/+4Jd/AaEir86/WBqxJDUpC15D5baQ+bKJ1eAepuz3VUvN2vN56JxY2PSZ7AvMVJjZbZ/Wx571F+emsX0bLt4pUr261+xXWRibmZHFmW+n8uPjvZqdsHgYZaJrhAxFfgsQCHC4IflcVRfA32n6HYSjRwEGbwf3enCUJ1lCaXS7DmStZbirwzBVR+dinOD+oRqNDmr4ru+S145atI/8AunlBIbSLGGJIJak5i3JACQcVcEjEYbGU5XRcLiqKUhehoTBteejIiagkXcXpyU9fbgbyMRfHQjaWR5G4utgTpnSBQYJorrJxU4inHKgK8paDj7yKT2w/DkNMHU5SPxJDTCOU0qSUSznisnEoE/8JmHQT1n2PIabN4DRLObdnXsB5mYtY9Bq75SrGB+vQ4jU5EEAghAngKCphl/AJZwLlKIuirBh1UQiiaB15BevihAMRhOCDC/6lVKU1hC2fEJFAgwk0MkS4y81DLM9ndsFgDx65EKVUlLIqoko1UQkRQBgBhEPYRZxEAe6EEg8UHHAltutriGyg55hs2Ia9sP/pma3UcvNIgV4p7wPbWtuZ49ms4+I6jtZ3MR7rbeZo5+bGbm7taB/butgGVl5gXjGwzjQ6od7j9jgoKgIO/FOeB1A6gBbqD5oWvarVQfERMeBEXNJTXfov3YSsODZL10PI5bawcHipoWJqco0AdmG0Fahzlbqh2bDXCVXlnj+0tNzjd9JFoCEQNgJSIKK4OEEIjqMBwZ4QEBpHObSmwc1GiBZw3z09nPr16TVg0ElDThk+b/Qg+WyPShErzpjTzjjrnPNQEMJkgNr64xos6Fd0dVDm386rLwuJ+xGaHfI4sBiwjhfOBls4WgIeLDgTDv4A7DVuCsBDrgW0NfsYPDw0GIp54gptJc57XPaBKXbA6vAwxIFpZegI/5mdcMcTaz75i6gWUtyJxViaCOMl8bJ4BfwBPBFvhj8Cf9eCM/39C7yAR2e1EZPuemrdZ1JcdhbCi+OlD61TG8kfuUI0b+DMKZD/KL48Ms+I/9/7//zvc+8ypk6ZOG5Aj0fefn1zjikFLImVsdORlv+39+LZLrn3l/f7z5Fr2hNPzZiVJ98zc56bt+AFloK/wve6UJENm7Zs21HsI25A+fEeyGIo1rRLVExwDJpyHe7F9bgLuyt34z7cgwdxMB7C43hAeQLH40m8iAeVl3A/XsYbeApv4i2cgLfxPl7AB/gQJ+EjfI5XlS9wCr7Ej3hb+Qmn4mf8gU/wJ/7Cafgb/+MrZcAZSkrfq2UFjzO9ZWtpG4+z1HjC4xw13vE4V433PM7zTmY+8CwAzgeTOQ48F4ALwWQeaT6PS9TJgh6Xq5NFPa7wTtaQ1vS4Up2s63G1OjnC4xp1cpfHteqCM9mu+6jLZofKv/gMfuhW3pPiAU17HJjlQVDfAHEIQIeI+YlHYKEhpagtUCaan7BRoLDQThEoqCOLAJWzHoFQz5cnRaEgTFRYKkwRY+WMAUjjWkaXIJEwAoNOLUHcfDGMY644+bMo8P1hJLwSUN+asKZZ45uRjo1YMxyWKxyRtHwY9rOgmds0CKCF/jl3i3nj6npwDKJXOkiXSZbceUDhogx++TB31vdN6ZQnaxvAQgPbYXpfy/I6Gby5BrrAfAo57tf9GfB1tVXWWnuVU4GpY37ByDQpciH9rs9Fkp9P443DfcLcV8x96yyufmrJu5efcMIUsxvuc0q7GNZjpZHyRPs5yF+Nft3+yuA/6LcH2dFJjHAgZXAZJRIrN6goNldD9qlBbULVGSsaoh5oEK2LNnEsNozxNUMUkOcgY6GEwOWgXGdoIAytWzkWqXKsImVogtwlQ6QN8eIy43KaUgRlyCHLph1r2AI9X9Vp3ZzH4o1zI21kn+12int3NZc1cRD+pVws+BcrisPZ0GTWgzeWRs/8GTt0dqHtPLTxTW/D3C0Nb4WbLdHYNhtN3WpYVp50ki+pRNOGEQ3TGe1XMQgbZqEtbIgFv2GLob7lvxkOXHOrQVt7Ed5GWJeVDTwqrq9hZ66xSVL3jemdwJRJq1wbKtXMS5RsB3cd4wyxAPKkX7WsRqr4UBTVodqIhaMvIjaz6kPjla6hfx8DZaTPbfjoYxyuhqsJPQaOci4eSa7i9dxYeCq5d1aMAgpd2LR+JNLCmbR5fPmVlgbeuLah8bWrk7zjSbyg6uCwN0H2uIb1gvYbHvHHMPI78fT26Z1plmlY57237cR6slAinFkaTXsr8XAewr3w+momYZWzR5msF3pxUIdK5nei6fZM+2y4iu7NclQfbX/3oD9FtSFZjeVptS5YHdzJpO576objZkvUXNJktpdTQegVeg9Gzh5ZHQS/LZxulgBukUUnpQKlD+SqF0CN6zCTvb0ge2b2lOwzluW4B5tBiBIDlsULM1QhKCo1EytKj8N4somh9ur6hh11ciy3r59QPI4gw49GNFn7I8lyUorpYmXFzjZFpH0JWquDrEFBcpBGa8utTlysjL+82uit732iQ1pvhaCa2QM5MSLq0N1X7EzVecMmY510zPNyN+SKrEi8nktuL5OjLasS13VMy/usRnKieE17mxmz4I7q9uTejhz0H6VBrCCLktoO4Do0xSxgGguASIz1eDdRMHGDBqJH4xrWmfZU8FnFQKiplhMeNcfLAY7wkEeRkvNbHPtl1GhoqSMIr8zRc08vrfOrukNlnsFPH3XFAWJRHPJeKKpxULH9tiq5HwhfRkoogqAEVPNr/U1Gk4S0wo9pUSYUzhMD/Z2cKSKASmK6Q7XiprYN2yaK7MTN1lDiefZgXJDF/FFdp5SsqD0xumuYK3gTM/jD5bS40vIY0TEdlLp2etK4TCObfadRkLW26S3ICt+EabwQUb0NORjj9tOjnxs9HEXZAQfv8IxenpliLP26MSoQ+VEge76lti+2vQJFXjSImMBJx3JeyRNABXcr0jrwoOmkSCj8ow+n2qIquDBOM1bkfmRHQZxO66uEndYiMWz7Wg36SDwGTvrpVJ8M7WmLNRxIrMPxKynGGUzRXKIms/m16TyC3OwSC+PaSZzFqBVyXQfkAhKw2ODi0Q8bbOFZraQiMZYMOa193XxYXDO9SYRoLxcBkkPjzs36WsU8toTC1kPSKODcxrQN0RLjyLRGYOq4RmBPnDyqCNoi6dBIdQVIUEBK9wQVShR91SyrUlkWFbtzj5w13eK2As0rWE45U5zMAT982YojPiwMPrBKstKUGlMj0jMV1NsIworbxO3YX6FkvXjDXT7YnZ3giY5LPcMPCo4JoQPHhjEHWyI9+H5kBI7Jr2I9+t5IFpk+4lFZEfygX9jxrUCfWGTElirbElcxYKGs4GLzWiohxwyNi6K+CBbpYRU7/8WdHX+A4hbFFXkIf6XuFwodK7Yp3qX/QYZY7RAXjpn9tdnMGVqD4r83BTShxhFk7Dv29m2sUZsWbUA4pKLGbZGPPGjI6EQSrONDR103OGFBrMZiGP51aOrYVpprLdmIMnevqUA2g4lab3f2wt2O2dnVeztEQE1HIkZidCiJdDJyMNBV7+HYdDObwZ7Io2AGeZJ3vZI0s6ySFSg6wXlk+wuh4bCgL9DfL3KcmAxvo1uxtLlzSB2goNAWmSKvqtfOGRGdWHg5LkLOzkKGmFn7ZBPmULKaYlwt8nV4/YmGVWnhwAKUXjXS6hV2Zg4G3yG1GZvVT1HEQKvDK9Aw2sW1jP4ifj2x2E0Xs0YplhtsVEaRClGNl8uQ0ajYNQNZTdgRXNBE6H5tp+sv+fGrxNvsO8tz2cRj/q1d2Wwww4mV7VyCv4jm9lg6286I6NMyFpQcNGkvq4V2YYfaLZ7JhmUUSmamR0s+GYRiflL54FlmOlIgQaViIWKS5x0zaZlBvRgnzfLxqi/GMpaVV4zXW5ZliWVFPcc4jOTBaAJPjASuIvbLZ1nM4fZNaLjU2PHUB7gvgIBQ2o7YEXhLu61A6t80krAiF4C/rBsYkkz3cjJLN5ImOOVew3WXBhKDoQQaQKkbtzRiE4uO+8PY360dkcjskaGdYYSpzm3aQL6oE0RWUkwm4xF5qQuD65N63/eKXzz4u6tQLNff6J3+Pzu8epPi2nvxmg/2jtrxzyjFPQ2OngprCtnURD3WVrXyKG7A35twsKlr/wOzogN5v/vQdGLK8sTFvtKHU4iq1MYIm1X7BZJuSBdjr0b+u8bfnfoTinmaT5k/1TdA1T/TxdPvpXOrEzPMoCxgcGHhjMB8x8sx8bvfbsonBSSQXDyoLnbuXru+J1xpdK1Cr5PPnl0WvNt+55HIux+P5ROZGXRKMBWw3xpZw31lFcM9ZVYFw91l5SM9pRNYPTMrprG1gY2esTVRy9TKWC73eMFoT2n5SFeFFWuop6JyuLdoAq1laa+ZUmCnZ2rFNLUyRL6V2irFxZTagkVBMHOoPszIzbqRdHJ+7kL306mqkdG8KKf/FImxpT+kc0Zf/m9lQ+6gzbxAL29iwqg6srYOFNtQ90gGIhRv6x5tp9arZBlkbU00sHEEAUKEdM3Fg3OQ6ria3PrRoFhfq7kqvPumstzxzts1UVqNBXpbGqk16Ffgp72c3fnVsFhXq7GM3n0dJU842nW3Krre5kz8TMhrRi2BCOmGDoV4TjNNiHpLKFA5hXjBkDLD0cY8r3hWoi0cjgYep2FpjUKNdCy9QAguM+odFI1MkpGkd9/gLkRGvIeO/9Q31SG9zJxKtrCkks3NvFytLL1c4X7agjzr2AKYxngq/2u4t/tLB7WPW/V/3aVf2qh9eInzAT20EL8WVF/AGb9T4XTvXuQkyMt7UujbngtyYL12Z/67H43aaunvH+kVwGRFKuRnvFpPq3n/z8JtRtTbglobagyI11CaImkRXpQwfyopytNaPibl3FJw/jp26UZQcn+AUsrRpNGkG5Kbm4vCq9flXVJCPUPjGJ6Ln0+Abte+3s1eXXldMvf5/V8n9h1QLzVB4aHsIemDyp6ponaIZtzTbWSjLOHN65SGvPf0nCl0qiy7JyOIEkArzU5LzmWGfr8MWoSJXembqN3bYqOx8afH3/K9KU9ZfZdZviZpyBX28Qzd4c4SbL6wiLYaolRFd4V6x1THJ8ZWgZkIryKBV1XR7M7cFgaM847Rad1UFZpa6pnkG2zv7nC8n0pOPRumSlUJ66Zf+bn0fO6fRX51c9+IaG9qBNPPOzzaz4ceIfOK7BHi4uwRSHH3oPVQaKASY8GMbJhaZ39fkbb7Nq+08m1FKg8MhzNo7bY8FrD3ecTfOW4RZFmdWBPV6eMe1ZaUyGgECk3nnjhhJmJHDywORgFbGTsZrRXgGsPsgahmdMQ2vQyRYuA5Xmrae65DN0h7sMWG4ok4KiDjXxZm5zYfXSXb1vt4OdnZWnH660mrmXq6lXu6uXO4Wv4GQYSLOOffo9JNtzRrObPAks7q9u9C9wV6cuBuUVxFkPGWmjGHgyZJj5o6jx3mpxITCFPHbg6HcW7w+evm6JLO7zOW3X/i7rQKjT127kIblxyX0Ifzhbs/f/Xmz1YYZsdy5poW2qm6k6WdDr9gHI7NuAm62Uq8gUcN5VfHRBVExgzlZRkX8JAD2LE/HAIPboVHdPnvj5LKGkyd5Vr4iXAkFyH0hCCPe9MowWdvltGnA2Pc0mbBsWqVf0ubB8SNkqw9ZmsMBU9e+F+dR+yrEmcpK6O4vnYeeR+5U/6yqaQwgyOP81M9Oal8atDgoenDPt3jw+PAEXf9UdXY5VXkuf2biyunwWA50YjVs/cUsGPTX7u8jC5nkIxISmbyua+FSS+jE/6Sk99B+rnr0j1NOsizwMVqA+GBK2jFH5Lb+4TSCmOTTrSvwrL36vDmwKCl5S+B1/rgogJKTGsme7aSg7WDEkztY6D0fHgEn0tS5t7Glq0jWwvK4R7B/m7B8RFgbdnc3/H4HtTmnot5E41hyZseDobhz+l7g0xV8L1jYkF4MTN8cbmFY+UyI+K1+tPieXoyw+XjoeCCB6V9uePj7A9uX83k5FFwWb640GAqOXrxvNRwswnMWC00WUiOMHoyPYz547Da/bGxoXsLli3fdn9vaujcgWUYBoR16412zz+J+Utl8/t+oHFfuBPTosLC03MjESFwuXHxUa5SnOfe9fEBwj9WOlyTLcKfRFo/YjIosdXZuqw7OUSiC68JHs3+JTo1Jjg0Lj55D7ScM8iJnlpBnio/8z8k5F36J7S55SuT9ThXKSg9MiYymWpnWe5bfPiv3eaHk9dl5r8MCKVUPi87tocPT3QDu57r49eVrl/62gX22LGJT0dE0H+rCrX9QGmqojAn+Tea4z40hwn3WDrInR/TkasbswdHpIfbjPuoMGFMmffZdM+Vtzt5lNuVkw/D+QcOnb3C/92jf+bMa2+x3y7sPZO9hgcczMUrV1jJfOjgV+WvnklrmPj8Zo88dgzD8+Sr2SlQyJ8oB5x6+dsxYNsbA+hjBw/gjh0CeKPtovVtRYBof2lM1/C9tSPzs7LQKujAcoX8MwSKrg8+ChF0YVmzKCxuoP3pxdJTfy5+hnwDWzsPkrWLub68T2z7M8+8e1v3LjyHE4cdBATvGYVrt19hvOSpA01bczBdFsK8Vrg7FsbijsEADuQPBsZ133mnwI7H9ITWhxarM4c0oktKjxYJG4PKnFOgO2LFBxHxFx4FpW1wHcAI/cdxeOPhtzVkgg8hBYa5BIdU98r2B1eB8b7fy0dvt4XEH1IAHGB5YsJZJyfWlPA/GmmdwSxN5hCBmT8DfkK7RxS/Snenw1px7Zs/YkjCaR5aaSaj3zuprM3I63UIZ26SGz2WN7xaDPENDIPxkM65TuqFp/eu6bkJod5qa3SfcF+YWwgBs33/7hy/fyYgmSsYJ1qeNbMZ0Zr43kfHJnM0PKkpNjMlmhjI7L75WeV/PHtNfF9onnbAXZ2A7LCEQRCvuRVTNOKHaTwvP+ztSPHO1PZH5AEH8tChQFRQEzN2I9nauJOMTSikagoJJIWJ8Wev3zlra8q/qn0wtyRR9GFnvdtX+ufp0FCbb2+zIGlZCpt5sW4MJNhBhwLgQAHEVojsSTGlt2bse6J7no0NPZo+q3CGaunqlaOaCmvyp32sSR6pmsG/5YkgVktkT4utvHmq/z5y76r8Oaqji3eKXugveSIYH+hM/bVR1PRKmItvFbH+V0RpTvQoCs/WFNvFoMV3nG6I7w2nx/aA6azQf8tKUz1B0X/kAbvIzUELSx+89/ogBo9toHeHFKqFXtWgFz4B4wN/lw/eGQnJE2T+Aeyiwu9AZtfU6lH8v82MzsB8TdoEITgvKKITlL4e7T/WoxZ5S54owJblVtuk0gKXjhDC9GLFsp1+Vu5OTk3/mGqWN3B0Ils7GqureBIXjlhLrpCe1P6+cL9w1i9xIEAQbUdz9iC5GoB0nRnn5bnL0nrPjFUsXrlKeKpg1Szb5to44UcEPfv6yIW7yORt+auDTTWawX8UiPyA9rv3Qll0jiism1EG46misjExATPil0cDhu8td1KsdPT26Axw/jhvQlAXMDqoOUmaIGnJL7SagCagGu92aEppLCf5PXtraCT4aszFSZUmTxE7p68FVzYENnPG/m/f3QocAuvQ0CDG3Wdnnoyg78xdPvvhrJpWh62UfTGSMrt8xvOM14c5zGa9OnjxjAJufBTkbzcQ0NtzyxfcL7ivz6A3GrS1Os6onl2GiwvoOyNPzsy8ZPP2DQA7ksSVy+s1NhnavW0WRMtAh3nkyrn39Q6Zul1Npro2NDsYzNhDCX1WFzq/39SLXOpFZpFsxNnb3n78SOXkbJP01r3NKzLP5JZFF2fkr8m9u/e+S/rSa6SLHyEHhjiHBNdCu/xASCWoG2KLU/WtyvYU96iWAp2Y5q6dJtzygx+bT+b23k3Kkd08nE3c/P3Ylwk7YMof3pbx4GFrelZuaQWrMLD59iNGR0X1XqGssilm6kZTXEWNqVBTT297MOXfXFyKCtoxqQnhD8bjoiKVzP0SEsPvXY+NYoLg5w0UAtPequsY318cxcfiR/CiSqJqI2qxaqPfTO7rQiaPFEbqHuYHBqyn3l/opLCCr4wK3vmCyD5/iAePTJ9MZqyNoXGWMyPoUoRnHf1cJ7Ug5PKQ+Mynn3zv78u7p9DDIxPtzawjraP9b0R4N87E2BwONHexST342sRZ2dvA0yH+IIgRyAR7K30DW+swW5s0O5sZdU0nK6KugzVB4/TfCmA+69o40ml0be5c9Mj4XFv3qZ66Fj8vFwo1iAXM1PhgFtXDwymgN6+vTlrgZHc7f3eznGuTHH+fkeBgg5wzf/+DKx42d7Js7lzxePDouqfV7Ykpq7tXPcBrsinMzjktISeFFtmfNByinhlnbKWmcoonbCSrsKC5Il/PX8LJN/sQad9AId0WyLqqFNATSLiHSR0yBfILgat35n+Yh/9bLno6N7hINAwXZjCZ+tMqkT0403r+5qkOO2MT+9b8QhsfQw0LCyIVyoDQy3am/wywrYzFdHZGRrR1rLW1RDC6W/jYCWYWBA0zW7qlbZiVJRwhjVjtWTF+Mxz3HN1/C97G+G37wbkmRrEsMFVIYq6+asPHp+NOthbUdmQlWljGhrvVxPiCgHC0SyJFsUj1yIjM45CBlNyqkwnhiSzVukMVtAsZteVDeTHTCqYqGnpmitRkoIJgH+gKE7ZB8hYxKsMpIbBOK+yXPJEHa0qhFIZYKl2SB+wiFLM7rbH/nn/O8WftCGDHoOSSuRe5nEou9na1sPJ0AwpusE6yOvJCZh+uj+l8xETWBiNbDnxNj/ZdO9QWnyQEbEH+HeM3NCem+qzar95obbt+s3sEE0CNcHLwDAc/J39qhKMDlRECJ3Ly9bvbarQtpa2VWpvsPT0QJ3lkYm9+9vn2g2vtjY1+VOkD/ghFUdUVn4y4SsjmsRvvsyOp7h/7Z8eNN+DHzg5fEd0e8dAS0wGjODVtt9Bg/3FNFc0xdDirCuE4AUguzal19uSYu1ZeK9+7dSNMJ/W5pxdGi52tU6/mL5+5TSJm6Z5SYY5/s9ILbwT9ty4J07A/7OK6ubJ3Q9cOLINk8BjXWifsRmY+Yj0Q/voJ80VOHrBj+K/n3sZnx9/KSIxCYEDefunnx+WJtTtDDPqw/X49B3f7+vza06u3Fpxb5RIJK/7qyY4kK0NlMzdn47rEer+Ic44WFBezdswc2L8T/llcbWj2yD79yvPTna0/h77AgI6dE9nexcdCAy9Yh7n29FlsRHrUXWRuD7fR2sIZW5wcb58j56Zkd81Ka95QgzmnGqsUcL3HByJJ+tpOJqpqPZ6MGG5GhrSPWzAQRCT+YKHA5lSewMf6msrVjKx3hevfOacLw21VGuKY48n20Q1+sZY1Bzzffjx+Ovckwy56aNHUpSY6pjabmVgeEJp8rg3M1HQxa5huOTNPkpUl1cXc1MPFxtadtHVq0OOrEuwqbV7eGTJ7t9biXxGlLV8nCcuazpBn01V4nZxD9mgh/aP02J7xhph9zn/t5SFafAeYfiHM/oHM3wrA1qGguPTtuvN2Pxse199jHiF4ghDG+tPUL0+Uh3gjSOgTSh4Rqm7kRA3oD9fzC9eNpfYJxX3t9DLcNmR1W/vJ+IRy70TxUOq7L8EpwljfVXA50Jn833px03pJbX79PDL/HdlpK+dj5qSFkvPxzkoOV6x0XholbpbUFtXOCh9B49mamV0MenTHmROx3XRadDdxrMfeP5qPHiXpT/UHrbgN7rUTlScql/kPCg0AW/wxt+wEb2pOHIWcGevrnx4f46LUFtSmpDwSMAKawd+icxt9D3SEai1JKSLK/RxROc2+sg6JOq8kFPHKILCmUOBALkCV9K/W+4TNAbfi3rkiC1UxuNbsGTgD91Vks/bpqJrzu9ALlIDH8NSs3E7OR7W9WPgO+Hkv/rXiqeQaVNXCk/EA8Q16CazfYbnpYYysVCToaGhOGp2WlxoO9lyfyq+I5Qv16SvAf7Z5F756nf+pAk4y/ld5ObWWMY6Y6uqaZpqrrOJeqnQem5ok26/BxsG0wcYh/l96ojhajqziF285LylJvH2jY5ojGCq4+u74wvkE8elRQx7+WHpfMEk8vOsvHc5v8OCs0vO55yEFCkQF0DDHkzlsbvVbp42mwosfvCtydf3BXIOLHGC/KzQwI0Hc6lk33AzyayooxOkp8Cz+nWHOML714Fmlx2QeFk/msJVKmZYGzgfYZv6gtpXuNKGpo6+mrr0XqR5u7h6squ4eOvGQvZ4eiGbddtU0UgtGFQH/czz+71GoOaWf0v643ZOLFbQ7HTndNfcc3NIIDT+7nIRZW+Z5RbkpqYONJdln85CgabR5cFi0+il9tSP3QbF7/0B1FpnXw8woPCGvPDnuVEvhiaEuVK3+069bG82XHVUOpMYdM9ZXDYTTnTadL2wjB/oyod0wJlIrSzeL0ZVUVdmXxMjOITJ1mGGtiZxt8ZevOtNDnQ+VqhwvFQy3didb27uTYUnZRN0ptSQnN+l0X25lTx806r5YerEp0E33liEYkVoMsfbxNCWiuVY4dOScu3gu8ef6WkyzX1VVnbm8tWj21b827xXAoiD4lz9i7Pyt6nDQYjeJA37Ral/z+2QzEgCOrwXrb0HKMxeDvr9vUI3stCJywO4bN4ga0VrhO7BrfX8fo9rG96L565FJbRBtB7ClAVBGNYMFdGyA3WMjyFI5EBJi1Iqvhj1Zg/iC46vlHVeL0BKCbBBiF/IOQrbRY1ttECCa0Y9GZVA5qQwp6XBKGXaNTAkcCHQtaj/PArPCh2g6gfHlVmC567tXujMaK9K9qNYqim+pkw9qyeVW/pUPLzAzPzoIjC8lgeXyxtG1y8cCzZIVGI8YWJ4a4+jpaKmFKG9Y6rHJMoq6PKuoyw8VdXlOUZfXLJ3wrX9tCKUjCCzXP47uhqVPkksscwZ/DlDMm7VMeISS5dNJlWvkePomQAWebJZvA0vZGNbSyD4SEEptFVmItWQJ66Ova5VI2xPXng2PYC1uWWopVIYg9J2IS1iurSxSLHKzQpKd6kjYSEXC1iqSaw/Lw1duUDxkuzqPkvWOPvouljdBFpe94/SldWOqtTZ8YPcFIf8fW1L7P+Do/F5uNSqdoQY5O7809tJrR21BllZP12bBoB/UT3IF/fE+xgeMpsFe1RiuracaiQjXPktPJbOJVyxOgVXdi+URwMn5vceXwwjRHJN9jGWUxZl+CSEaz/5h5vw0YOHc7Nep+3CmkeKYRmmM8JclsvyKzljBBvoOY81EUVc4vzwV3AbV9qvfkgPa1mOdJJPn7xVQHmapzhPXtuYocCeGE7ePeeyHpi84VueWO095rAlFfQdOiGu9pyiOYEhDgfYjzNYAhwM0YP9Yc6jmwWRQrT+aAytaA9kRYLN9LgdAub3vYYE4m7zZisvRXP3SfhsNtOmxf5jEroHpCEAtg39O2HTw4SAIDT1scgjDmwI7BwFioZlex7GL+PR+Z5eYAgCPfYFlAXh9XN74T+X/51MWTBELwQEFUMD4gIEbYMozKs9AWAXEbF/fb6kgbWUYVollpEUVo3aLajeg9g2+3YhlsWUYT/wPZdah2kGq+dAp3yhWSZFBkhG/82ss92X0wwJG0AINQdCH71PtFibSQ4JOE6TZahU2BUn1l2Pjw2x7ALYuJafrcevqcloW8YDz1Fg+vb9KkNW1JIe6cCKRvWMU72POihWHt6arb0bbZt6+xryXzMR1XWyjv6DYRYi2L1DtJevQkVT9QKyBp2ZSqtWQ6KXRbJi1bFFNiUnLYdJIrOINmVbFvKUICzkRIZydZyEq5GSMPopqqWiNxcRHym+Nbe4rQzvO4aTXbFzA09+TboJEGgbQ84FtoodK4GD45VHoKuhhIqs1CWxTAnsx52aDMzCQ1dmAWq/xGVlwq2WK6l+wbzQZbs2GgoEqJaPZ8YhftPSXXCX6BbePSuo226ApjX0C4peCOiCh/gVyHxc8EuM6SuRTfzEf50M1I8Y9l3d7I79zQ8Foiklr4toqGbY8Jq1YdKhijSf4jbWQ6k+pcVJifSm+80LjSEpEeSuszCOW/5lUQ8xqzqrqMIl3Cvq2/MjACDqnWkU2fiG0Bh4tRk17Q7itkxlHJFPiP1oogCVUQIA5LKAOS800frEEAeawsNSLpqmGqSaT3Tl3tFR0SbXFdGUYimhesYS9Odo0rKnCmMZMHNUT1UxxE1HSTx4mh2oOeLC82drUrJ3CmDZF2GuFATQ0BPhBBVEOsBCA6UBArQgHAaYQAg1pHAB2AsddEdx8dkVhR98VTVTMoTG7Yh1QyHE+ZeSh8nJ1i6koTMli0IQKEwdPjQpVp+FZiiLwMwTv2VqkQMrc+AZGs4uHiHXiwWI1HiPBxoMo3+JRAhhxMFmZIShrxveFm088Fg0isn0oL1CnRTeYkVp+7mO07cw4TETHnZxYTZk/Jn+BwhKuzE6MUMdtNk2gYJFB3pNYx9mxZsqcAxJzx1ptUvlZcFlJF2QG", + "ok": true, + "headers": [ + [ + "content-type", + "font/woff2" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6006/experiment/defaultExperimentId/data/plugin/timeseries/timeSeries?requests=%5B%7B%22plugin%22:%22scalars%22,%22tag%22:%22epoch_accuracy%22%7D%5D": { + "data": "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", + "ok": true, + "headers": [ + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6006/experiment/defaultExperimentId/data/plugin/timeseries/timeSeries?requests=%5B%7B%22plugin%22:%22scalars%22,%22tag%22:%22epoch_loss%22%7D%5D": { + "data": "W3sicGx1Z2luIjogInNjYWxhcnMiLCAidGFnIjogImVwb2NoX2xvc3MiLCAicnVuVG9TZXJpZXMiOiB7IjEwX3BlcmNlbnRfZmluZV90dW5lX2xhc3RfMTAvMjAyNDAxMTQtMTM0MzExL3ZhbGlkYXRpb24iOiBbeyJ3YWxsVGltZSI6IDE3MDUyMzk4MjUuNzk3NjMxLCAic3RlcCI6IDQsICJ2YWx1ZSI6IDAuNDYwNzcwODQ1NDEzMjA4fSwgeyJ3YWxsVGltZSI6IDE3MDUyMzk4NDYuMTQyNjU3LCAic3RlcCI6IDUsICJ2YWx1ZSI6IDAuNDE0ODA5OTQyMjQ1NDgzNH0sIHsid2FsbFRpbWUiOiAxNzA1MjM5ODYwLjg5MjY3OSwgInN0ZXAiOiA2LCAidmFsdWUiOiAwLjQxNzg0MDcxOTIyMzAyMjQ2fSwgeyJ3YWxsVGltZSI6IDE3MDUyMzk4NzcuMDUyMjY5LCAic3RlcCI6IDcsICJ2YWx1ZSI6IDAuMzk4MDQwODYwODkxMzQyMTZ9LCB7IndhbGxUaW1lIjogMTcwNTIzOTg5Mi41NDQ3OTEsICJzdGVwIjogOCwgInZhbHVlIjogMC40MTQxOTY1ODA2NDg0MjIyNH0sIHsid2FsbFRpbWUiOiAxNzA1MjM5OTA4LjcyMjk2NywgInN0ZXAiOiA5LCAidmFsdWUiOiAwLjM5MDI2MzQwODQyMjQ3MDF9XSwgIjEwX3BlcmNlbnRfZmVhdHVyZV9leHRyYWN0LzIwMjQwMTE0LTEzMzgwOC90cmFpbiI6IFt7IndhbGxUaW1lIjogMTcwNTIzOTUwOS4zNTU3NDQsICJzdGVwIjogMCwgInZhbHVlIjogMS45MjgxNTgwNDQ4MTUwNjM1fSwgeyJ3YWxsVGltZSI6IDE3MDUyMzk1MTkuMzM3ODYzLCAic3RlcCI6IDEsICJ2YWx1ZSI6IDEuMTY0MDU2Nzc3OTU0MTAxNn0sIHsid2FsbFRpbWUiOiAxNzA1MjM5NTI1Ljk3NzA4OCwgInN0ZXAiOiAyLCAidmFsdWUiOiAwLjg1MDcxNDI2NjMwMDIwMTR9LCB7IndhbGxUaW1lIjogMTcwNTIzOTUzMC42MDcyMDYsICJzdGVwIjogMywgInZhbHVlIjogMC42ODc5MzI2NzAxMTY0MjQ2fSwgeyJ3YWxsVGltZSI6IDE3MDUyMzk1MzQuMTM1Mjk5LCAic3RlcCI6IDQsICJ2YWx1ZSI6IDAuNTk1NTQ3MTM5NjQ0NjIyOH1dLCAiMTBfcGVyY2VudF9mZWF0dXJlX2V4dHJhY3QvMjAyNDAxMTQtMTMzODA4L3ZhbGlkYXRpb24iOiBbeyJ3YWxsVGltZSI6IDE3MDUyMzk1MDkuMzU3NzU0LCAic3RlcCI6IDAsICJ2YWx1ZSI6IDEuMzQ1NTk1NzE3NDMwMTE0N30sIHsid2FsbFRpbWUiOiAxNzA1MjM5NTE5LjM0MDczOCwgInN0ZXAiOiAxLCAidmFsdWUiOiAwLjg4NDkxODYzMDEyMzEzODR9LCB7IndhbGxUaW1lIjogMTcwNTIzOTUyNS45NzkxODIsICJzdGVwIjogMiwgInZhbHVlIjogMC43MzM0NTM1NzE3OTY0MTcyfSwgeyJ3YWxsVGltZSI6IDE3MDUyMzk1MzAuNjA5NjYyLCAic3RlcCI6IDMsICJ2YWx1ZSI6IDAuNjM1MDQ1NTI4NDExODY1Mn0sIHsid2FsbFRpbWUiOiAxNzA1MjM5NTM0LjEzNzIyMiwgInN0ZXAiOiA0LCAidmFsdWUiOiAwLjU1MDc5NzA0NTIzMDg2NTV9XSwgIjFfcGVyY2VudF9kYXRhX2F1Zy8yMDI0MDExNC0xMzM5MTMvdHJhaW4iOiBbeyJ3YWxsVGltZSI6IDE3MDUyMzk1NjkuNDE0ODM0LCAic3RlcCI6IDAsICJ2YWx1ZSI6IDIuNDQ3MzIzMzIyMjk2MTQyNn0sIHsid2FsbFRpbWUiOiAxNzA1MjM5NTc3Ljg5MDQwMiwgInN0ZXAiOiAxLCAidmFsdWUiOiAyLjIwMzg5MTI3NzMxMzIzMjR9LCB7IndhbGxUaW1lIjogMTcwNTIzOTU4Mi42NDY2NjcsICJzdGVwIjogMiwgInZhbHVlIjogMi4wMjA3MzQzMTAxNTAxNDY1fSwgeyJ3YWxsVGltZSI6IDE3MDUyMzk1ODcuMDUzMDc3LCAic3RlcCI6IDMsICJ2YWx1ZSI6IDEuODM1NzE1NjUxNTEyMTQ2fSwgeyJ3YWxsVGltZSI6IDE3MDUyMzk1OTQuMDc2MzU5LCAic3RlcCI6IDQsICJ2YWx1ZSI6IDEuNjU4NTU5OTE4NDAzNjI1NX1dLCAiMV9wZXJjZW50X2RhdGFfYXVnLzIwMjQwMTE0LTEzMzkxMy92YWxpZGF0aW9uIjogW3sid2FsbFRpbWUiOiAxNzA1MjM5NTY5LjQxNjcwOCwgInN0ZXAiOiAwLCAidmFsdWUiOiAyLjI3NzQ5NDQzMDU0MTk5Mn0sIHsid2FsbFRpbWUiOiAxNzA1MjM5NTc3Ljg5MjUzMSwgInN0ZXAiOiAxLCAidmFsdWUiOiAyLjE1NDI0NzUyMjM1NDEyNn0sIHsid2FsbFRpbWUiOiAxNzA1MjM5NTgyLjY0OTM2NSwgInN0ZXAiOiAyLCAidmFsdWUiOiAyLjAxNzI2OTEzNDUyMTQ4NDR9LCB7IndhbGxUaW1lIjogMTcwNTIzOTU4Ny4wNTQ4OTcsICJzdGVwIjogMywgInZhbHVlIjogMS45NTIzNTQwNzM1MjQ0NzV9LCB7IndhbGxUaW1lIjogMTcwNTIzOTU5NC4wNzg1ODQsICJzdGVwIjogNCwgInZhbHVlIjogMS44NDQzNDQ0OTY3MjY5ODk3fV0sICJmdWxsXzEwX2NsYXNzZXNfZmluZV90dW5lX2xhc3RfMTAvMjAyNDAxMTQtMTM0NjEyL3ZhbGlkYXRpb24iOiBbeyJ3YWxsVGltZSI6IDE3MDUyNDAxMDMuNjQ5OTU5LCAic3RlcCI6IDQsICJ2YWx1ZSI6IDAuMzU0NTA5NTAyNjQ5MzA3MjV9LCB7IndhbGxUaW1lIjogMTcwNTI0MDIwMy4wOTU5NTcsICJzdGVwIjogNSwgInZhbHVlIjogMC4yOTMyMzk5ODA5MzYwNTA0fSwgeyJ3YWxsVGltZSI6IDE3MDUyNDAzMzQuMzY3NTU4LCAic3RlcCI6IDYsICJ2YWx1ZSI6IDAuMjgxNDYzNjUyODQ5MTk3NH0sIHsid2FsbFRpbWUiOiAxNzA1MjQwNDA5Ljk1NjAwMiwgInN0ZXAiOiA3LCAidmFsdWUiOiAwLjI2Mjk3NDE0MzAyODI1OTN9LCB7IndhbGxUaW1lIjogMTcwNTI0MDQ3Ni43MzY1ODIsICJzdGVwIjogOCwgInZhbHVlIjogMC4yNzI1NzMyMDI4NDg0MzQ0NX0sIHsid2FsbFRpbWUiOiAxNzA1MjQwNTM5LjY5NTk1NSwgInN0ZXAiOiA5LCAidmFsdWUiOiAwLjI2ODYyODk1NDg4NzM5MDE0fV0sICIxMF9wZXJjZW50X2RhdGFfYXVnLzIwMjQwMTE0LTEzNDAwOS92YWxpZGF0aW9uIjogW3sid2FsbFRpbWUiOiAxNzA1MjM5NjQ4LjY0OTI2OSwgInN0ZXAiOiAwLCAidmFsdWUiOiAxLjQ0MjY4NDQxMjAwMjU2MzV9LCB7IndhbGxUaW1lIjogMTcwNTIzOTY3NS4wNTQxNywgInN0ZXAiOiAxLCAidmFsdWUiOiAxLjAxOTc2ODU5NTY5NTQ5NTZ9LCB7IndhbGxUaW1lIjogMTcwNTIzOTY5Ni43OTAxNjksICJzdGVwIjogMiwgInZhbHVlIjogMC44MDk4MDA3NDQwNTY3MDE3fSwgeyJ3YWxsVGltZSI6IDE3MDUyMzk3MTcuNjg5NTgsICJzdGVwIjogMywgInZhbHVlIjogMC42OTA3ODc0OTQxODI1ODY3fSwgeyJ3YWxsVGltZSI6IDE3MDUyMzk3NTkuMTUyNDA5LCAic3RlcCI6IDQsICJ2YWx1ZSI6IDAuNjIwNDc4OTg3NjkzNzg2Nn1dLCAiZnVsbF8xMF9jbGFzc2VzX2ZpbmVfdHVuZV9sYXN0XzEwLzIwMjQwMTE0LTEzNDYxMi90cmFpbiI6IFt7IndhbGxUaW1lIjogMTcwNTI0MDEwMy42NDgwOTEsICJzdGVwIjogNCwgInZhbHVlIjogMC43MDgxOTk2MjAyNDY4ODcyfSwgeyJ3YWxsVGltZSI6IDE3MDUyNDAyMDMuMDkzNzExLCAic3RlcCI6IDUsICJ2YWx1ZSI6IDAuNTk0OTkwNjExMDc2MzU1fSwgeyJ3YWxsVGltZSI6IDE3MDUyNDAzMzQuMzY1NjQ0LCAic3RlcCI6IDYsICJ2YWx1ZSI6IDAuNTM5MTg3NjEwMTQ5MzgzNX0sIHsid2FsbFRpbWUiOiAxNzA1MjQwNDA5Ljk1Mzk2MSwgInN0ZXAiOiA3LCAidmFsdWUiOiAwLjQ5NjExMzM1OTkyODEzMTF9LCB7IndhbGxUaW1lIjogMTcwNTI0MDQ3Ni43MzQ0MzYsICJzdGVwIjogOCwgInZhbHVlIjogMC40NjY2NjY5OTY0NzkwMzQ0fSwgeyJ3YWxsVGltZSI6IDE3MDUyNDA1MzkuNjkzNzQ3LCAic3RlcCI6IDksICJ2YWx1ZSI6IDAuNDQ0MTk0NzkzNzAxMTcxOX1dLCAiMTBfcGVyY2VudF9maW5lX3R1bmVfbGFzdF8xMC8yMDI0MDExNC0xMzQzMTEvdHJhaW4iOiBbeyJ3YWxsVGltZSI6IDE3MDUyMzk4MjUuNzk1NzgzLCAic3RlcCI6IDQsICJ2YWx1ZSI6IDAuNzA3NDk1ODY4MjA2MDI0Mn0sIHsid2FsbFRpbWUiOiAxNzA1MjM5ODQ2LjE0MDkzOCwgInN0ZXAiOiA1LCAidmFsdWUiOiAwLjYxMzE1NDExMzI5MjY5NDF9LCB7IndhbGxUaW1lIjogMTcwNTIzOTg2MC44OTA2ODUsICJzdGVwIjogNiwgInZhbHVlIjogMC41NTQ2ODk5NDM3OTA0MzU4fSwgeyJ3YWxsVGltZSI6IDE3MDUyMzk4NzcuMDUwNjAzLCAic3RlcCI6IDcsICJ2YWx1ZSI6IDAuNTAyODA1ODI5MDQ4MTU2N30sIHsid2FsbFRpbWUiOiAxNzA1MjM5ODkyLjU0Mjk2LCAic3RlcCI6IDgsICJ2YWx1ZSI6IDAuNDc1NTQ1NjQ0NzYwMTMxODR9LCB7IndhbGxUaW1lIjogMTcwNTIzOTkwOC43MjA3MjcsICJzdGVwIjogOSwgInZhbHVlIjogMC40NDUzOTM0NDMxMDc2MDV9XSwgIjEwX3BlcmNlbnRfZGF0YV9hdWcvMjAyNDAxMTQtMTM0MDA5L3RyYWluIjogW3sid2FsbFRpbWUiOiAxNzA1MjM5NjQ4LjY0NzI4OCwgInN0ZXAiOiAwLCAidmFsdWUiOiAxLjk5MzYzNjM2OTcwNTIwMDJ9LCB7IndhbGxUaW1lIjogMTcwNTIzOTY3NS4wNTIxNzMsICJzdGVwIjogMSwgInZhbHVlIjogMS4zODQyNTQ2OTM5ODQ5ODU0fSwgeyJ3YWxsVGltZSI6IDE3MDUyMzk2OTYuNzg4MjE1LCAic3RlcCI6IDIsICJ2YWx1ZSI6IDEuMDk1MjYyNDA4MjU2NTMwOH0sIHsid2FsbFRpbWUiOiAxNzA1MjM5NzE3LjY4NDQzOSwgInN0ZXAiOiAzLCAidmFsdWUiOiAwLjkzNjMwNDM5MDQzMDQ1MDR9LCB7IndhbGxUaW1lIjogMTcwNTIzOTc1OS4xNTA1MDcsICJzdGVwIjogNCwgInZhbHVlIjogMC44Mjc4Nzc5Mzg3NDc0MDZ9XX19XQ==", + "ok": true, + "headers": [ + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6006/chart_worker.js?_file_hash=2c1e71c5": { + "data": "(()=>{var H0=Object.defineProperty,V0=Object.defineProperties;var G0=Object.getOwnPropertyDescriptors;var af=Object.getOwnPropertySymbols;var W0=Object.prototype.hasOwnProperty,q0=Object.prototype.propertyIsEnumerable;var cf=Math.pow,lf=(n,t,e)=>t in n?H0(n,t,{enumerable:!0,configurable:!0,writable:!0,value:e}):n[t]=e,No=(n,t)=>{for(var e in t||(t={}))W0.call(t,e)&&lf(n,e,t[e]);if(af)for(var e of af(t))q0.call(t,e)&&lf(n,e,t[e]);return n},uf=(n,t)=>V0(n,G0(t));var hf=(n,t,e)=>new Promise((i,r)=>{var s=l=>{try{a(e.next(l))}catch(c){r(c)}},o=l=>{try{a(e.throw(l))}catch(c){r(c)}},a=l=>l.done?i(l.value):Promise.resolve(l.value).then(s,o);a((e=e.apply(n,t)).next())});var on;(function(n){n[n.LINEAR=0]="LINEAR",n[n.LOG10=1]="LOG10",n[n.TIME=2]="TIME"})(on||(on={}));function an(n,t){return n<t?-1:n>t?1:n>=t?0:NaN}function is(n){return n.length===1&&(n=X0(n)),{left:function(t,e,i,r){for(i==null&&(i=0),r==null&&(r=t.length);i<r;){var s=i+r>>>1;n(t[s],e)<0?i=s+1:r=s}return i},right:function(t,e,i,r){for(i==null&&(i=0),r==null&&(r=t.length);i<r;){var s=i+r>>>1;n(t[s],e)>0?r=s:i=s+1}return i}}}function X0(n){return function(t,e){return an(n(t),e)}}var ff=is(an),df=ff.right,Y0=ff.left,Bn=df;var pf=Array.prototype,J0=pf.slice,$0=pf.map;var kl=Math.sqrt(50),Hl=Math.sqrt(10),Vl=Math.sqrt(2);function rs(n,t,e){var i,r=-1,s,o,a;if(t=+t,n=+n,e=+e,n===t&&e>0)return[n];if((i=t<n)&&(s=n,n=t,t=s),(a=Ji(n,t,e))===0||!isFinite(a))return[];if(a>0)for(n=Math.ceil(n/a),t=Math.floor(t/a),o=new Array(s=Math.ceil(t-n+1));++r<s;)o[r]=(n+r)*a;else for(n=Math.floor(n*a),t=Math.ceil(t*a),o=new Array(s=Math.ceil(n-t+1));++r<s;)o[r]=(n-r)/a;return i&&o.reverse(),o}function Ji(n,t,e){var i=(t-n)/Math.max(0,e),r=Math.floor(Math.log(i)/Math.LN10),s=i/Math.pow(10,r);return r>=0?(s>=kl?10:s>=Hl?5:s>=Vl?2:1)*Math.pow(10,r):-Math.pow(10,-r)/(s>=kl?10:s>=Hl?5:s>=Vl?2:1)}function _n(n,t,e){var i=Math.abs(t-n)/Math.max(0,e),r=Math.pow(10,Math.floor(Math.log(i)/Math.LN10)),s=i/r;return s>=kl?r*=10:s>=Hl?r*=5:s>=Vl&&(r*=2),t<n?-r:r}var ex=Array.prototype.slice;var nx={value:function(){}};function yf(){for(var n=0,t=arguments.length,e={},i;n<t;++n){if(!(i=arguments[n]+"")||i in e||/[\s.]/.test(i))throw new Error("illegal type: "+i);e[i]=[]}return new zo(e)}function zo(n){this._=n}function ix(n,t){return n.trim().split(/^|\s+/).map(function(e){var i="",r=e.indexOf(".");if(r>=0&&(i=e.slice(r+1),e=e.slice(0,r)),e&&!t.hasOwnProperty(e))throw new Error("unknown type: "+e);return{type:e,name:i}})}zo.prototype=yf.prototype={constructor:zo,on:function(n,t){var e=this._,i=ix(n+"",e),r,s=-1,o=i.length;if(arguments.length<2){for(;++s<o;)if((r=(n=i[s]).type)&&(r=rx(e[r],n.name)))return r;return}if(t!=null&&typeof t!="function")throw new Error("invalid callback: "+t);for(;++s<o;)if(r=(n=i[s]).type)e[r]=xf(e[r],n.name,t);else if(t==null)for(r in e)e[r]=xf(e[r],n.name,null);return this},copy:function(){var n={},t=this._;for(var e in t)n[e]=t[e].slice();return new zo(n)},call:function(n,t){if((r=arguments.length-2)>0)for(var e=new Array(r),i=0,r,s;i<r;++i)e[i]=arguments[i+2];if(!this._.hasOwnProperty(n))throw new Error("unknown type: "+n);for(s=this._[n],i=0,r=s.length;i<r;++i)s[i].value.apply(t,e)},apply:function(n,t,e){if(!this._.hasOwnProperty(n))throw new Error("unknown type: "+n);for(var i=this._[n],r=0,s=i.length;r<s;++r)i[r].value.apply(t,e)}};function rx(n,t){for(var e=0,i=n.length,r;e<i;++e)if((r=n[e]).name===t)return r.value}function xf(n,t,e){for(var i=0,r=n.length;i<r;++i)if(n[i].name===t){n[i]=nx,n=n.slice(0,i).concat(n.slice(i+1));break}return e!=null&&n.push({name:t,value:e}),n}var Wl=yf;var Uo="http://www.w3.org/1999/xhtml",ql={svg:"http://www.w3.org/2000/svg",xhtml:Uo,xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/"};function wn(n){var t=n+="",e=t.indexOf(":");return e>=0&&(t=n.slice(0,e))!=="xmlns"&&(n=n.slice(e+1)),ql.hasOwnProperty(t)?{space:ql[t],local:n}:n}function sx(n){return function(){var t=this.ownerDocument,e=this.namespaceURI;return e===Uo&&t.documentElement.namespaceURI===Uo?t.createElement(n):t.createElementNS(e,n)}}function ox(n){return function(){return this.ownerDocument.createElementNS(n.space,n.local)}}function Bo(n){var t=wn(n);return(t.local?ox:sx)(t)}function ax(){}function di(n){return n==null?ax:function(){return this.querySelector(n)}}function vf(n){typeof n!="function"&&(n=di(n));for(var t=this._groups,e=t.length,i=new Array(e),r=0;r<e;++r)for(var s=t[r],o=s.length,a=i[r]=new Array(o),l,c,u=0;u<o;++u)(l=s[u])&&(c=n.call(l,l.__data__,u,s))&&("__data__"in l&&(c.__data__=l.__data__),a[u]=c);return new ce(i,this._parents)}function lx(){return[]}function os(n){return n==null?lx:function(){return this.querySelectorAll(n)}}function _f(n){typeof n!="function"&&(n=os(n));for(var t=this._groups,e=t.length,i=[],r=[],s=0;s<e;++s)for(var o=t[s],a=o.length,l,c=0;c<a;++c)(l=o[c])&&(i.push(n.call(l,l.__data__,c,o)),r.push(l));return new ce(i,r)}function as(n){return function(){return this.matches(n)}}function wf(n){typeof n!="function"&&(n=as(n));for(var t=this._groups,e=t.length,i=new Array(e),r=0;r<e;++r)for(var s=t[r],o=s.length,a=i[r]=[],l,c=0;c<o;++c)(l=s[c])&&n.call(l,l.__data__,c,s)&&a.push(l);return new ce(i,this._parents)}function Oo(n){return new Array(n.length)}function Mf(){return new ce(this._enter||this._groups.map(Oo),this._parents)}function ls(n,t){this.ownerDocument=n.ownerDocument,this.namespaceURI=n.namespaceURI,this._next=null,this._parent=n,this.__data__=t}ls.prototype={constructor:ls,appendChild:function(n){return this._parent.insertBefore(n,this._next)},insertBefore:function(n,t){return this._parent.insertBefore(n,t)},querySelector:function(n){return this._parent.querySelector(n)},querySelectorAll:function(n){return this._parent.querySelectorAll(n)}};function bf(n){return function(){return n}}var Sf="$";function cx(n,t,e,i,r,s){for(var o=0,a,l=t.length,c=s.length;o<c;++o)(a=t[o])?(a.__data__=s[o],i[o]=a):e[o]=new ls(n,s[o]);for(;o<l;++o)(a=t[o])&&(r[o]=a)}function ux(n,t,e,i,r,s,o){var a,l,c={},u=t.length,h=s.length,f=new Array(u),d;for(a=0;a<u;++a)(l=t[a])&&(f[a]=d=Sf+o.call(l,l.__data__,a,t),d in c?r[a]=l:c[d]=l);for(a=0;a<h;++a)d=Sf+o.call(n,s[a],a,s),(l=c[d])?(i[a]=l,l.__data__=s[a],c[d]=null):e[a]=new ls(n,s[a]);for(a=0;a<u;++a)(l=t[a])&&c[f[a]]===l&&(r[a]=l)}function Ef(n,t){if(!n)return d=new Array(this.size()),c=-1,this.each(function(L){d[++c]=L}),d;var e=t?ux:cx,i=this._parents,r=this._groups;typeof n!="function"&&(n=bf(n));for(var s=r.length,o=new Array(s),a=new Array(s),l=new Array(s),c=0;c<s;++c){var u=i[c],h=r[c],f=h.length,d=n.call(u,u&&u.__data__,c,i),g=d.length,x=a[c]=new Array(g),v=o[c]=new Array(g),m=l[c]=new Array(f);e(u,h,x,v,m,d,t);for(var p=0,b=0,_,S;p<g;++p)if(_=x[p]){for(p>=b&&(b=p+1);!(S=v[b])&&++b<g;);_._next=S||null}}return o=new ce(o,i),o._enter=a,o._exit=l,o}function Tf(){return new ce(this._exit||this._groups.map(Oo),this._parents)}function Af(n,t,e){var i=this.enter(),r=this,s=this.exit();return i=typeof n=="function"?n(i):i.append(n+""),t!=null&&(r=t(r)),e==null?s.remove():e(s),i&&r?i.merge(r).order():r}function Cf(n){for(var t=this._groups,e=n._groups,i=t.length,r=e.length,s=Math.min(i,r),o=new Array(i),a=0;a<s;++a)for(var l=t[a],c=e[a],u=l.length,h=o[a]=new Array(u),f,d=0;d<u;++d)(f=l[d]||c[d])&&(h[d]=f);for(;a<i;++a)o[a]=t[a];return new ce(o,this._parents)}function Rf(){for(var n=this._groups,t=-1,e=n.length;++t<e;)for(var i=n[t],r=i.length-1,s=i[r],o;--r>=0;)(o=i[r])&&(s&&o.compareDocumentPosition(s)^4&&s.parentNode.insertBefore(o,s),s=o);return this}function Lf(n){n||(n=hx);function t(h,f){return h&&f?n(h.__data__,f.__data__):!h-!f}for(var e=this._groups,i=e.length,r=new Array(i),s=0;s<i;++s){for(var o=e[s],a=o.length,l=r[s]=new Array(a),c,u=0;u<a;++u)(c=o[u])&&(l[u]=c);l.sort(t)}return new ce(r,this._parents).order()}function hx(n,t){return n<t?-1:n>t?1:n>=t?0:NaN}function Pf(){var n=arguments[0];return arguments[0]=this,n.apply(null,arguments),this}function Df(){var n=new Array(this.size()),t=-1;return this.each(function(){n[++t]=this}),n}function If(){for(var n=this._groups,t=0,e=n.length;t<e;++t)for(var i=n[t],r=0,s=i.length;r<s;++r){var o=i[r];if(o)return o}return null}function Nf(){var n=0;return this.each(function(){++n}),n}function Ff(){return!this.node()}function zf(n){for(var t=this._groups,e=0,i=t.length;e<i;++e)for(var r=t[e],s=0,o=r.length,a;s<o;++s)(a=r[s])&&n.call(a,a.__data__,s,r);return this}function fx(n){return function(){this.removeAttribute(n)}}function dx(n){return function(){this.removeAttributeNS(n.space,n.local)}}function px(n,t){return function(){this.setAttribute(n,t)}}function mx(n,t){return function(){this.setAttributeNS(n.space,n.local,t)}}function gx(n,t){return function(){var e=t.apply(this,arguments);e==null?this.removeAttribute(n):this.setAttribute(n,e)}}function xx(n,t){return function(){var e=t.apply(this,arguments);e==null?this.removeAttributeNS(n.space,n.local):this.setAttributeNS(n.space,n.local,e)}}function Uf(n,t){var e=wn(n);if(arguments.length<2){var i=this.node();return e.local?i.getAttributeNS(e.space,e.local):i.getAttribute(e)}return this.each((t==null?e.local?dx:fx:typeof t=="function"?e.local?xx:gx:e.local?mx:px)(e,t))}function ko(n){return n.ownerDocument&&n.ownerDocument.defaultView||n.document&&n||n.defaultView}function yx(n){return function(){this.style.removeProperty(n)}}function vx(n,t,e){return function(){this.style.setProperty(n,t,e)}}function _x(n,t,e){return function(){var i=t.apply(this,arguments);i==null?this.style.removeProperty(n):this.style.setProperty(n,i,e)}}function Bf(n,t,e){return arguments.length>1?this.each((t==null?yx:typeof t=="function"?_x:vx)(n,t,e==null?"":e)):On(this.node(),n)}function On(n,t){return n.style.getPropertyValue(t)||ko(n).getComputedStyle(n,null).getPropertyValue(t)}function wx(n){return function(){delete this[n]}}function Mx(n,t){return function(){this[n]=t}}function bx(n,t){return function(){var e=t.apply(this,arguments);e==null?delete this[n]:this[n]=e}}function Of(n,t){return arguments.length>1?this.each((t==null?wx:typeof t=="function"?bx:Mx)(n,t)):this.node()[n]}function kf(n){return n.trim().split(/^|\s+/)}function Xl(n){return n.classList||new Hf(n)}function Hf(n){this._node=n,this._names=kf(n.getAttribute("class")||"")}Hf.prototype={add:function(n){var t=this._names.indexOf(n);t<0&&(this._names.push(n),this._node.setAttribute("class",this._names.join(" ")))},remove:function(n){var t=this._names.indexOf(n);t>=0&&(this._names.splice(t,1),this._node.setAttribute("class",this._names.join(" ")))},contains:function(n){return this._names.indexOf(n)>=0}};function Vf(n,t){for(var e=Xl(n),i=-1,r=t.length;++i<r;)e.add(t[i])}function Gf(n,t){for(var e=Xl(n),i=-1,r=t.length;++i<r;)e.remove(t[i])}function Sx(n){return function(){Vf(this,n)}}function Ex(n){return function(){Gf(this,n)}}function Tx(n,t){return function(){(t.apply(this,arguments)?Vf:Gf)(this,n)}}function Wf(n,t){var e=kf(n+"");if(arguments.length<2){for(var i=Xl(this.node()),r=-1,s=e.length;++r<s;)if(!i.contains(e[r]))return!1;return!0}return this.each((typeof t=="function"?Tx:t?Sx:Ex)(e,t))}function Ax(){this.textContent=""}function Cx(n){return function(){this.textContent=n}}function Rx(n){return function(){var t=n.apply(this,arguments);this.textContent=t==null?"":t}}function qf(n){return arguments.length?this.each(n==null?Ax:(typeof n=="function"?Rx:Cx)(n)):this.node().textContent}function Lx(){this.innerHTML=""}function Px(n){return function(){this.innerHTML=n}}function Dx(n){return function(){var t=n.apply(this,arguments);this.innerHTML=t==null?"":t}}function Xf(n){return arguments.length?this.each(n==null?Lx:(typeof n=="function"?Dx:Px)(n)):this.node().innerHTML}function Ix(){this.nextSibling&&this.parentNode.appendChild(this)}function Yf(){return this.each(Ix)}function Nx(){this.previousSibling&&this.parentNode.insertBefore(this,this.parentNode.firstChild)}function Zf(){return this.each(Nx)}function Jf(n){var t=typeof n=="function"?n:Bo(n);return this.select(function(){return this.appendChild(t.apply(this,arguments))})}function Fx(){return null}function $f(n,t){var e=typeof n=="function"?n:Bo(n),i=t==null?Fx:typeof t=="function"?t:di(t);return this.select(function(){return this.insertBefore(e.apply(this,arguments),i.apply(this,arguments)||null)})}function zx(){var n=this.parentNode;n&&n.removeChild(this)}function Kf(){return this.each(zx)}function Ux(){var n=this.cloneNode(!1),t=this.parentNode;return t?t.insertBefore(n,this.nextSibling):n}function Bx(){var n=this.cloneNode(!0),t=this.parentNode;return t?t.insertBefore(n,this.nextSibling):n}function Qf(n){return this.select(n?Bx:Ux)}function jf(n){return arguments.length?this.property("__data__",n):this.node().__data__}var ed={},Yl=null;typeof document!="undefined"&&(td=document.documentElement,"onmouseenter"in td||(ed={mouseenter:"mouseover",mouseleave:"mouseout"}));var td;function Ox(n,t,e){return n=nd(n,t,e),function(i){var r=i.relatedTarget;(!r||r!==this&&!(r.compareDocumentPosition(this)&8))&&n.call(this,i)}}function nd(n,t,e){return function(i){var r=Yl;Yl=i;try{n.call(this,this.__data__,t,e)}finally{Yl=r}}}function kx(n){return n.trim().split(/^|\s+/).map(function(t){var e="",i=t.indexOf(".");return i>=0&&(e=t.slice(i+1),t=t.slice(0,i)),{type:t,name:e}})}function Hx(n){return function(){var t=this.__on;if(!!t){for(var e=0,i=-1,r=t.length,s;e<r;++e)s=t[e],(!n.type||s.type===n.type)&&s.name===n.name?this.removeEventListener(s.type,s.listener,s.capture):t[++i]=s;++i?t.length=i:delete this.__on}}}function Vx(n,t,e){var i=ed.hasOwnProperty(n.type)?Ox:nd;return function(r,s,o){var a=this.__on,l,c=i(t,s,o);if(a){for(var u=0,h=a.length;u<h;++u)if((l=a[u]).type===n.type&&l.name===n.name){this.removeEventListener(l.type,l.listener,l.capture),this.addEventListener(l.type,l.listener=c,l.capture=e),l.value=t;return}}this.addEventListener(n.type,c,e),l={type:n.type,name:n.name,value:t,listener:c,capture:e},a?a.push(l):this.__on=[l]}}function id(n,t,e){var i=kx(n+""),r,s=i.length,o;if(arguments.length<2){var a=this.node().__on;if(a){for(var l=0,c=a.length,u;l<c;++l)for(r=0,u=a[l];r<s;++r)if((o=i[r]).type===u.type&&o.name===u.name)return u.value}return}for(a=t?Vx:Hx,e==null&&(e=!1),r=0;r<s;++r)this.each(a(i[r],t,e));return this}function rd(n,t,e){var i=ko(n),r=i.CustomEvent;typeof r=="function"?r=new r(t,e):(r=i.document.createEvent("Event"),e?(r.initEvent(t,e.bubbles,e.cancelable),r.detail=e.detail):r.initEvent(t,!1,!1)),n.dispatchEvent(r)}function Gx(n,t){return function(){return rd(this,n,t)}}function Wx(n,t){return function(){return rd(this,n,t.apply(this,arguments))}}function sd(n,t){return this.each((typeof t=="function"?Wx:Gx)(n,t))}var qx=[null];function ce(n,t){this._groups=n,this._parents=t}function od(){return new ce([[document.documentElement]],qx)}ce.prototype=od.prototype={constructor:ce,select:vf,selectAll:_f,filter:wf,data:Ef,enter:Mf,exit:Tf,join:Af,merge:Cf,order:Rf,sort:Lf,call:Pf,nodes:Df,node:If,size:Nf,empty:Ff,each:zf,attr:Uf,style:Bf,property:Of,classed:Wf,text:qf,html:Xf,raise:Yf,lower:Zf,append:Jf,insert:$f,remove:Kf,clone:Qf,datum:jf,on:id,dispatch:sd};var Mn=od;function Ho(n,t,e){n.prototype=t.prototype=e,e.constructor=n}function Zl(n,t){var e=Object.create(n.prototype);for(var i in t)e[i]=t[i];return e}function hs(){}var cs=.7,Go=1/cs,$i="\\s*([+-]?\\d+)\\s*",us="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",cn="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",Xx=/^#([0-9a-f]{3,8})$/,Yx=new RegExp("^rgb\\("+[$i,$i,$i]+"\\)$"),Zx=new RegExp("^rgb\\("+[cn,cn,cn]+"\\)$"),Jx=new RegExp("^rgba\\("+[$i,$i,$i,us]+"\\)$"),$x=new RegExp("^rgba\\("+[cn,cn,cn,us]+"\\)$"),Kx=new RegExp("^hsl\\("+[us,cn,cn]+"\\)$"),Qx=new RegExp("^hsla\\("+[us,cn,cn,us]+"\\)$"),ad={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};Ho(hs,Je,{copy:function(n){return Object.assign(new this.constructor,this,n)},displayable:function(){return this.rgb().displayable()},hex:ld,formatHex:ld,formatHsl:jx,formatRgb:cd,toString:cd});function ld(){return this.rgb().formatHex()}function jx(){return pd(this).formatHsl()}function cd(){return this.rgb().formatRgb()}function Je(n){var t,e;return n=(n+"").trim().toLowerCase(),(t=Xx.exec(n))?(e=t[1].length,t=parseInt(t[1],16),e===6?ud(t):e===3?new Ue(t>>8&15|t>>4&240,t>>4&15|t&240,(t&15)<<4|t&15,1):e===8?Vo(t>>24&255,t>>16&255,t>>8&255,(t&255)/255):e===4?Vo(t>>12&15|t>>8&240,t>>8&15|t>>4&240,t>>4&15|t&240,((t&15)<<4|t&15)/255):null):(t=Yx.exec(n))?new Ue(t[1],t[2],t[3],1):(t=Zx.exec(n))?new Ue(t[1]*255/100,t[2]*255/100,t[3]*255/100,1):(t=Jx.exec(n))?Vo(t[1],t[2],t[3],t[4]):(t=$x.exec(n))?Vo(t[1]*255/100,t[2]*255/100,t[3]*255/100,t[4]):(t=Kx.exec(n))?dd(t[1],t[2]/100,t[3]/100,1):(t=Qx.exec(n))?dd(t[1],t[2]/100,t[3]/100,t[4]):ad.hasOwnProperty(n)?ud(ad[n]):n==="transparent"?new Ue(NaN,NaN,NaN,0):null}function ud(n){return new Ue(n>>16&255,n>>8&255,n&255,1)}function Vo(n,t,e,i){return i<=0&&(n=t=e=NaN),new Ue(n,t,e,i)}function ty(n){return n instanceof hs||(n=Je(n)),n?(n=n.rgb(),new Ue(n.r,n.g,n.b,n.opacity)):new Ue}function Ki(n,t,e,i){return arguments.length===1?ty(n):new Ue(n,t,e,i==null?1:i)}function Ue(n,t,e,i){this.r=+n,this.g=+t,this.b=+e,this.opacity=+i}Ho(Ue,Ki,Zl(hs,{brighter:function(n){return n=n==null?Go:Math.pow(Go,n),new Ue(this.r*n,this.g*n,this.b*n,this.opacity)},darker:function(n){return n=n==null?cs:Math.pow(cs,n),new Ue(this.r*n,this.g*n,this.b*n,this.opacity)},rgb:function(){return this},displayable:function(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:hd,formatHex:hd,formatRgb:fd,toString:fd}));function hd(){return"#"+Jl(this.r)+Jl(this.g)+Jl(this.b)}function fd(){var n=this.opacity;return n=isNaN(n)?1:Math.max(0,Math.min(1,n)),(n===1?"rgb(":"rgba(")+Math.max(0,Math.min(255,Math.round(this.r)||0))+", "+Math.max(0,Math.min(255,Math.round(this.g)||0))+", "+Math.max(0,Math.min(255,Math.round(this.b)||0))+(n===1?")":", "+n+")")}function Jl(n){return n=Math.max(0,Math.min(255,Math.round(n)||0)),(n<16?"0":"")+n.toString(16)}function dd(n,t,e,i){return i<=0?n=t=e=NaN:e<=0||e>=1?n=t=NaN:t<=0&&(n=NaN),new ln(n,t,e,i)}function pd(n){if(n instanceof ln)return new ln(n.h,n.s,n.l,n.opacity);if(n instanceof hs||(n=Je(n)),!n)return new ln;if(n instanceof ln)return n;n=n.rgb();var t=n.r/255,e=n.g/255,i=n.b/255,r=Math.min(t,e,i),s=Math.max(t,e,i),o=NaN,a=s-r,l=(s+r)/2;return a?(t===s?o=(e-i)/a+(e<i)*6:e===s?o=(i-t)/a+2:o=(t-e)/a+4,a/=l<.5?s+r:2-s-r,o*=60):a=l>0&&l<1?0:o,new ln(o,a,l,n.opacity)}function pi(n,t,e,i){return arguments.length===1?pd(n):new ln(n,t,e,i==null?1:i)}function ln(n,t,e,i){this.h=+n,this.s=+t,this.l=+e,this.opacity=+i}Ho(ln,pi,Zl(hs,{brighter:function(n){return n=n==null?Go:Math.pow(Go,n),new ln(this.h,this.s,this.l*n,this.opacity)},darker:function(n){return n=n==null?cs:Math.pow(cs,n),new ln(this.h,this.s,this.l*n,this.opacity)},rgb:function(){var n=this.h%360+(this.h<0)*360,t=isNaN(n)||isNaN(this.s)?0:this.s,e=this.l,i=e+(e<.5?e:1-e)*t,r=2*e-i;return new Ue($l(n>=240?n-240:n+120,r,i),$l(n,r,i),$l(n<120?n+240:n-120,r,i),this.opacity)},displayable:function(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl:function(){var n=this.opacity;return n=isNaN(n)?1:Math.max(0,Math.min(1,n)),(n===1?"hsl(":"hsla(")+(this.h||0)+", "+(this.s||0)*100+"%, "+(this.l||0)*100+"%"+(n===1?")":", "+n+")")}}));function $l(n,t,e){return(n<60?t+(e-t)*n/60:n<180?e:n<240?t+(e-t)*(240-n)/60:t)*255}function Kl(n,t,e,i,r){var s=n*n,o=s*n;return((1-3*n+3*s-o)*t+(4-6*s+3*o)*e+(1+3*n+3*s-3*o)*i+o*r)/6}function md(n){var t=n.length-1;return function(e){var i=e<=0?e=0:e>=1?(e=1,t-1):Math.floor(e*t),r=n[i],s=n[i+1],o=i>0?n[i-1]:2*r-s,a=i<t-1?n[i+2]:2*s-r;return Kl((e-i/t)*t,o,r,s,a)}}function gd(n){var t=n.length;return function(e){var i=Math.floor(((e%=1)<0?++e:e)*t),r=n[(i+t-1)%t],s=n[i%t],o=n[(i+1)%t],a=n[(i+2)%t];return Kl((e-i/t)*t,r,s,o,a)}}function Qi(n){return function(){return n}}function xd(n,t){return function(e){return n+e*t}}function ey(n,t,e){return n=Math.pow(n,e),t=Math.pow(t,e)-n,e=1/e,function(i){return Math.pow(n+i*t,e)}}function yd(n,t){var e=t-n;return e?xd(n,e>180||e<-180?e-360*Math.round(e/360):e):Qi(isNaN(n)?t:n)}function vd(n){return(n=+n)==1?bn:function(t,e){return e-t?ey(t,e,n):Qi(isNaN(t)?e:t)}}function bn(n,t){var e=t-n;return e?xd(n,e):Qi(isNaN(n)?t:n)}var mi=function n(t){var e=vd(t);function i(r,s){var o=e((r=Ki(r)).r,(s=Ki(s)).r),a=e(r.g,s.g),l=e(r.b,s.b),c=bn(r.opacity,s.opacity);return function(u){return r.r=o(u),r.g=a(u),r.b=l(u),r.opacity=c(u),r+""}}return i.gamma=n,i}(1);function _d(n){return function(t){var e=t.length,i=new Array(e),r=new Array(e),s=new Array(e),o,a;for(o=0;o<e;++o)a=Ki(t[o]),i[o]=a.r||0,r[o]=a.g||0,s[o]=a.b||0;return i=n(i),r=n(r),s=n(s),a.opacity=1,function(l){return a.r=i(l),a.g=r(l),a.b=s(l),a+""}}}var ny=_d(md),iy=_d(gd);function wd(n,t){t||(t=[]);var e=n?Math.min(t.length,n.length):0,i=t.slice(),r;return function(s){for(r=0;r<e;++r)i[r]=n[r]*(1-s)+t[r]*s;return i}}function Md(n){return ArrayBuffer.isView(n)&&!(n instanceof DataView)}function bd(n,t){var e=t?t.length:0,i=n?Math.min(e,n.length):0,r=new Array(i),s=new Array(e),o;for(o=0;o<i;++o)r[o]=gi(n[o],t[o]);for(;o<e;++o)s[o]=t[o];return function(a){for(o=0;o<i;++o)s[o]=r[o](a);return s}}function Sd(n,t){var e=new Date;return n=+n,t=+t,function(i){return e.setTime(n*(1-i)+t*i),e}}function ye(n,t){return n=+n,t=+t,function(e){return n*(1-e)+t*e}}function Ed(n,t){var e={},i={},r;(n===null||typeof n!="object")&&(n={}),(t===null||typeof t!="object")&&(t={});for(r in t)r in n?e[r]=gi(n[r],t[r]):i[r]=t[r];return function(s){for(r in e)i[r]=e[r](s);return i}}var jl=/[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,Ql=new RegExp(jl.source,"g");function ry(n){return function(){return n}}function sy(n){return function(t){return n(t)+""}}function fs(n,t){var e=jl.lastIndex=Ql.lastIndex=0,i,r,s,o=-1,a=[],l=[];for(n=n+"",t=t+"";(i=jl.exec(n))&&(r=Ql.exec(t));)(s=r.index)>e&&(s=t.slice(e,s),a[o]?a[o]+=s:a[++o]=s),(i=i[0])===(r=r[0])?a[o]?a[o]+=r:a[++o]=r:(a[++o]=null,l.push({i:o,x:ye(i,r)})),e=Ql.lastIndex;return e<t.length&&(s=t.slice(e),a[o]?a[o]+=s:a[++o]=s),a.length<2?l[0]?sy(l[0].x):ry(t):(t=l.length,function(c){for(var u=0,h;u<t;++u)a[(h=l[u]).i]=h.x(c);return a.join("")})}function gi(n,t){var e=typeof t,i;return t==null||e==="boolean"?Qi(t):(e==="number"?ye:e==="string"?(i=Je(t))?(t=i,mi):fs:t instanceof Je?mi:t instanceof Date?Sd:Md(t)?wd:Array.isArray(t)?bd:typeof t.valueOf!="function"&&typeof t.toString!="function"||isNaN(t)?Ed:ye)(n,t)}function tc(n,t){return n=+n,t=+t,function(e){return Math.round(n*(1-e)+t*e)}}var Td=180/Math.PI,Wo={translateX:0,translateY:0,rotate:0,skewX:0,scaleX:1,scaleY:1};function ec(n,t,e,i,r,s){var o,a,l;return(o=Math.sqrt(n*n+t*t))&&(n/=o,t/=o),(l=n*e+t*i)&&(e-=n*l,i-=t*l),(a=Math.sqrt(e*e+i*i))&&(e/=a,i/=a,l/=a),n*i<t*e&&(n=-n,t=-t,l=-l,o=-o),{translateX:r,translateY:s,rotate:Math.atan2(t,n)*Td,skewX:Math.atan(l)*Td,scaleX:o,scaleY:a}}var ds,nc,Ad,qo;function Cd(n){return n==="none"?Wo:(ds||(ds=document.createElement("DIV"),nc=document.documentElement,Ad=document.defaultView),ds.style.transform=n,n=Ad.getComputedStyle(nc.appendChild(ds),null).getPropertyValue("transform"),nc.removeChild(ds),n=n.slice(7,-1).split(","),ec(+n[0],+n[1],+n[2],+n[3],+n[4],+n[5]))}function Rd(n){return n==null?Wo:(qo||(qo=document.createElementNS("http://www.w3.org/2000/svg","g")),qo.setAttribute("transform",n),(n=qo.transform.baseVal.consolidate())?(n=n.matrix,ec(n.a,n.b,n.c,n.d,n.e,n.f)):Wo)}function Ld(n,t,e,i){function r(c){return c.length?c.pop()+" ":""}function s(c,u,h,f,d,g){if(c!==h||u!==f){var x=d.push("translate(",null,t,null,e);g.push({i:x-4,x:ye(c,h)},{i:x-2,x:ye(u,f)})}else(h||f)&&d.push("translate("+h+t+f+e)}function o(c,u,h,f){c!==u?(c-u>180?u+=360:u-c>180&&(c+=360),f.push({i:h.push(r(h)+"rotate(",null,i)-2,x:ye(c,u)})):u&&h.push(r(h)+"rotate("+u+i)}function a(c,u,h,f){c!==u?f.push({i:h.push(r(h)+"skewX(",null,i)-2,x:ye(c,u)}):u&&h.push(r(h)+"skewX("+u+i)}function l(c,u,h,f,d,g){if(c!==h||u!==f){var x=d.push(r(d)+"scale(",null,",",null,")");g.push({i:x-4,x:ye(c,h)},{i:x-2,x:ye(u,f)})}else(h!==1||f!==1)&&d.push(r(d)+"scale("+h+","+f+")")}return function(c,u){var h=[],f=[];return c=n(c),u=n(u),s(c.translateX,c.translateY,u.translateX,u.translateY,h,f),o(c.rotate,u.rotate,h,f),a(c.skewX,u.skewX,h,f),l(c.scaleX,c.scaleY,u.scaleX,u.scaleY,h,f),c=u=null,function(d){for(var g=-1,x=f.length,v;++g<x;)h[(v=f[g]).i]=v.x(d);return h.join("")}}}var ic=Ld(Cd,"px, ","px)","deg)"),rc=Ld(Rd,", ",")",")");function Pd(n){return function(t,e){var i=n((t=pi(t)).h,(e=pi(e)).h),r=bn(t.s,e.s),s=bn(t.l,e.l),o=bn(t.opacity,e.opacity);return function(a){return t.h=i(a),t.s=r(a),t.l=s(a),t.opacity=o(a),t+""}}}var sc=Pd(yd),oy=Pd(bn);var ji=0,ms=0,ps=0,Id=1e3,Xo,gs,Yo=0,xi=0,Zo=0,xs=typeof performance=="object"&&performance.now?performance:Date,Nd=typeof window=="object"&&window.requestAnimationFrame?window.requestAnimationFrame.bind(window):function(n){setTimeout(n,17)};function tr(){return xi||(Nd(ay),xi=xs.now()+Zo)}function ay(){xi=0}function ys(){this._call=this._time=this._next=null}ys.prototype=Jo.prototype={constructor:ys,restart:function(n,t,e){if(typeof n!="function")throw new TypeError("callback is not a function");e=(e==null?tr():+e)+(t==null?0:+t),!this._next&&gs!==this&&(gs?gs._next=this:Xo=this,gs=this),this._call=n,this._time=e,oc()},stop:function(){this._call&&(this._call=null,this._time=1/0,oc())}};function Jo(n,t,e){var i=new ys;return i.restart(n,t,e),i}function Fd(){tr(),++ji;for(var n=Xo,t;n;)(t=xi-n._time)>=0&&n._call.call(null,t),n=n._next;--ji}function Dd(){xi=(Yo=xs.now())+Zo,ji=ms=0;try{Fd()}finally{ji=0,cy(),xi=0}}function ly(){var n=xs.now(),t=n-Yo;t>Id&&(Zo-=t,Yo=n)}function cy(){for(var n,t=Xo,e,i=1/0;t;)t._call?(i>t._time&&(i=t._time),n=t,t=t._next):(e=t._next,t._next=null,t=n?n._next=e:Xo=e);gs=n,oc(i)}function oc(n){if(!ji){ms&&(ms=clearTimeout(ms));var t=n-xi;t>24?(n<1/0&&(ms=setTimeout(Dd,n-xs.now()-Zo)),ps&&(ps=clearInterval(ps))):(ps||(Yo=xs.now(),ps=setInterval(ly,Id)),ji=1,Nd(Dd))}}function $o(n,t,e){var i=new ys;return t=t==null?0:+t,i.restart(function(r){i.stop(),n(r+t)},t,e),i}var uy=Wl("start","end","cancel","interrupt"),hy=[],Ud=0,ac=1,Qo=2,Ko=3,zd=4,jo=5,vs=6;function kn(n,t,e,i,r,s){var o=n.__transition;if(!o)n.__transition={};else if(e in o)return;fy(n,e,{name:t,index:i,group:r,on:uy,tween:hy,time:s.time,delay:s.delay,duration:s.duration,ease:s.ease,timer:null,state:Ud})}function _s(n,t){var e=ue(n,t);if(e.state>Ud)throw new Error("too late; already scheduled");return e}function Ae(n,t){var e=ue(n,t);if(e.state>Ko)throw new Error("too late; already running");return e}function ue(n,t){var e=n.__transition;if(!e||!(e=e[t]))throw new Error("transition not found");return e}function fy(n,t,e){var i=n.__transition,r;i[t]=e,e.timer=Jo(s,0,e.time);function s(c){e.state=ac,e.timer.restart(o,e.delay,e.time),e.delay<=c&&o(c-e.delay)}function o(c){var u,h,f,d;if(e.state!==ac)return l();for(u in i)if(d=i[u],d.name===e.name){if(d.state===Ko)return $o(o);d.state===zd?(d.state=vs,d.timer.stop(),d.on.call("interrupt",n,n.__data__,d.index,d.group),delete i[u]):+u<t&&(d.state=vs,d.timer.stop(),d.on.call("cancel",n,n.__data__,d.index,d.group),delete i[u])}if($o(function(){e.state===Ko&&(e.state=zd,e.timer.restart(a,e.delay,e.time),a(c))}),e.state=Qo,e.on.call("start",n,n.__data__,e.index,e.group),e.state===Qo){for(e.state=Ko,r=new Array(f=e.tween.length),u=0,h=-1;u<f;++u)(d=e.tween[u].value.call(n,n.__data__,e.index,e.group))&&(r[++h]=d);r.length=h+1}}function a(c){for(var u=c<e.duration?e.ease.call(null,c/e.duration):(e.timer.restart(l),e.state=jo,1),h=-1,f=r.length;++h<f;)r[h].call(n,u);e.state===jo&&(e.on.call("end",n,n.__data__,e.index,e.group),l())}function l(){e.state=vs,e.timer.stop(),delete i[t];for(var c in i)return;delete n.__transition}}function ws(n,t){var e=n.__transition,i,r,s=!0,o;if(!!e){t=t==null?null:t+"";for(o in e){if((i=e[o]).name!==t){s=!1;continue}r=i.state>Qo&&i.state<jo,i.state=vs,i.timer.stop(),i.on.call(r?"interrupt":"cancel",n,n.__data__,i.index,i.group),delete e[o]}s&&delete n.__transition}}function Bd(n){return this.each(function(){ws(this,n)})}function dy(n,t){var e,i;return function(){var r=Ae(this,n),s=r.tween;if(s!==e){i=e=s;for(var o=0,a=i.length;o<a;++o)if(i[o].name===t){i=i.slice(),i.splice(o,1);break}}r.tween=i}}function py(n,t,e){var i,r;if(typeof e!="function")throw new Error;return function(){var s=Ae(this,n),o=s.tween;if(o!==i){r=(i=o).slice();for(var a={name:t,value:e},l=0,c=r.length;l<c;++l)if(r[l].name===t){r[l]=a;break}l===c&&r.push(a)}s.tween=r}}function Od(n,t){var e=this._id;if(n+="",arguments.length<2){for(var i=ue(this.node(),e).tween,r=0,s=i.length,o;r<s;++r)if((o=i[r]).name===n)return o.value;return null}return this.each((t==null?dy:py)(e,n,t))}function er(n,t,e){var i=n._id;return n.each(function(){var r=Ae(this,i);(r.value||(r.value={}))[t]=e.apply(this,arguments)}),function(r){return ue(r,i).value[t]}}function ta(n,t){var e;return(typeof t=="number"?ye:t instanceof Je?mi:(e=Je(t))?(t=e,mi):fs)(n,t)}function my(n){return function(){this.removeAttribute(n)}}function gy(n){return function(){this.removeAttributeNS(n.space,n.local)}}function xy(n,t,e){var i,r=e+"",s;return function(){var o=this.getAttribute(n);return o===r?null:o===i?s:s=t(i=o,e)}}function yy(n,t,e){var i,r=e+"",s;return function(){var o=this.getAttributeNS(n.space,n.local);return o===r?null:o===i?s:s=t(i=o,e)}}function vy(n,t,e){var i,r,s;return function(){var o,a=e(this),l;return a==null?void this.removeAttribute(n):(o=this.getAttribute(n),l=a+"",o===l?null:o===i&&l===r?s:(r=l,s=t(i=o,a)))}}function _y(n,t,e){var i,r,s;return function(){var o,a=e(this),l;return a==null?void this.removeAttributeNS(n.space,n.local):(o=this.getAttributeNS(n.space,n.local),l=a+"",o===l?null:o===i&&l===r?s:(r=l,s=t(i=o,a)))}}function kd(n,t){var e=wn(n),i=e==="transform"?rc:ta;return this.attrTween(n,typeof t=="function"?(e.local?_y:vy)(e,i,er(this,"attr."+n,t)):t==null?(e.local?gy:my)(e):(e.local?yy:xy)(e,i,t))}function wy(n,t){return function(e){this.setAttribute(n,t.call(this,e))}}function My(n,t){return function(e){this.setAttributeNS(n.space,n.local,t.call(this,e))}}function by(n,t){var e,i;function r(){var s=t.apply(this,arguments);return s!==i&&(e=(i=s)&&My(n,s)),e}return r._value=t,r}function Sy(n,t){var e,i;function r(){var s=t.apply(this,arguments);return s!==i&&(e=(i=s)&&wy(n,s)),e}return r._value=t,r}function Hd(n,t){var e="attr."+n;if(arguments.length<2)return(e=this.tween(e))&&e._value;if(t==null)return this.tween(e,null);if(typeof t!="function")throw new Error;var i=wn(n);return this.tween(e,(i.local?by:Sy)(i,t))}function Ey(n,t){return function(){_s(this,n).delay=+t.apply(this,arguments)}}function Ty(n,t){return t=+t,function(){_s(this,n).delay=t}}function Vd(n){var t=this._id;return arguments.length?this.each((typeof n=="function"?Ey:Ty)(t,n)):ue(this.node(),t).delay}function Ay(n,t){return function(){Ae(this,n).duration=+t.apply(this,arguments)}}function Cy(n,t){return t=+t,function(){Ae(this,n).duration=t}}function Gd(n){var t=this._id;return arguments.length?this.each((typeof n=="function"?Ay:Cy)(t,n)):ue(this.node(),t).duration}function Ry(n,t){if(typeof t!="function")throw new Error;return function(){Ae(this,n).ease=t}}function Wd(n){var t=this._id;return arguments.length?this.each(Ry(t,n)):ue(this.node(),t).ease}function qd(n){typeof n!="function"&&(n=as(n));for(var t=this._groups,e=t.length,i=new Array(e),r=0;r<e;++r)for(var s=t[r],o=s.length,a=i[r]=[],l,c=0;c<o;++c)(l=s[c])&&n.call(l,l.__data__,c,s)&&a.push(l);return new we(i,this._parents,this._name,this._id)}function Xd(n){if(n._id!==this._id)throw new Error;for(var t=this._groups,e=n._groups,i=t.length,r=e.length,s=Math.min(i,r),o=new Array(i),a=0;a<s;++a)for(var l=t[a],c=e[a],u=l.length,h=o[a]=new Array(u),f,d=0;d<u;++d)(f=l[d]||c[d])&&(h[d]=f);for(;a<i;++a)o[a]=t[a];return new we(o,this._parents,this._name,this._id)}function Ly(n){return(n+"").trim().split(/^|\s+/).every(function(t){var e=t.indexOf(".");return e>=0&&(t=t.slice(0,e)),!t||t==="start"})}function Py(n,t,e){var i,r,s=Ly(t)?_s:Ae;return function(){var o=s(this,n),a=o.on;a!==i&&(r=(i=a).copy()).on(t,e),o.on=r}}function Yd(n,t){var e=this._id;return arguments.length<2?ue(this.node(),e).on.on(n):this.each(Py(e,n,t))}function Dy(n){return function(){var t=this.parentNode;for(var e in this.__transition)if(+e!==n)return;t&&t.removeChild(this)}}function Zd(){return this.on("end.remove",Dy(this._id))}function Jd(n){var t=this._name,e=this._id;typeof n!="function"&&(n=di(n));for(var i=this._groups,r=i.length,s=new Array(r),o=0;o<r;++o)for(var a=i[o],l=a.length,c=s[o]=new Array(l),u,h,f=0;f<l;++f)(u=a[f])&&(h=n.call(u,u.__data__,f,a))&&("__data__"in u&&(h.__data__=u.__data__),c[f]=h,kn(c[f],t,e,f,c,ue(u,e)));return new we(s,this._parents,t,e)}function $d(n){var t=this._name,e=this._id;typeof n!="function"&&(n=os(n));for(var i=this._groups,r=i.length,s=[],o=[],a=0;a<r;++a)for(var l=i[a],c=l.length,u,h=0;h<c;++h)if(u=l[h]){for(var f=n.call(u,u.__data__,h,l),d,g=ue(u,e),x=0,v=f.length;x<v;++x)(d=f[x])&&kn(d,t,e,x,f,g);s.push(f),o.push(u)}return new we(s,o,t,e)}var Iy=Mn.prototype.constructor;function Kd(){return new Iy(this._groups,this._parents)}function Ny(n,t){var e,i,r;return function(){var s=On(this,n),o=(this.style.removeProperty(n),On(this,n));return s===o?null:s===e&&o===i?r:r=t(e=s,i=o)}}function Qd(n){return function(){this.style.removeProperty(n)}}function Fy(n,t,e){var i,r=e+"",s;return function(){var o=On(this,n);return o===r?null:o===i?s:s=t(i=o,e)}}function zy(n,t,e){var i,r,s;return function(){var o=On(this,n),a=e(this),l=a+"";return a==null&&(l=a=(this.style.removeProperty(n),On(this,n))),o===l?null:o===i&&l===r?s:(r=l,s=t(i=o,a))}}function Uy(n,t){var e,i,r,s="style."+t,o="end."+s,a;return function(){var l=Ae(this,n),c=l.on,u=l.value[s]==null?a||(a=Qd(t)):void 0;(c!==e||r!==u)&&(i=(e=c).copy()).on(o,r=u),l.on=i}}function jd(n,t,e){var i=(n+="")=="transform"?ic:ta;return t==null?this.styleTween(n,Ny(n,i)).on("end.style."+n,Qd(n)):typeof t=="function"?this.styleTween(n,zy(n,i,er(this,"style."+n,t))).each(Uy(this._id,n)):this.styleTween(n,Fy(n,i,t),e).on("end.style."+n,null)}function By(n,t,e){return function(i){this.style.setProperty(n,t.call(this,i),e)}}function Oy(n,t,e){var i,r;function s(){var o=t.apply(this,arguments);return o!==r&&(i=(r=o)&&By(n,o,e)),i}return s._value=t,s}function tp(n,t,e){var i="style."+(n+="");if(arguments.length<2)return(i=this.tween(i))&&i._value;if(t==null)return this.tween(i,null);if(typeof t!="function")throw new Error;return this.tween(i,Oy(n,t,e==null?"":e))}function ky(n){return function(){this.textContent=n}}function Hy(n){return function(){var t=n(this);this.textContent=t==null?"":t}}function ep(n){return this.tween("text",typeof n=="function"?Hy(er(this,"text",n)):ky(n==null?"":n+""))}function Vy(n){return function(t){this.textContent=n.call(this,t)}}function Gy(n){var t,e;function i(){var r=n.apply(this,arguments);return r!==e&&(t=(e=r)&&Vy(r)),t}return i._value=n,i}function np(n){var t="text";if(arguments.length<1)return(t=this.tween(t))&&t._value;if(n==null)return this.tween(t,null);if(typeof n!="function")throw new Error;return this.tween(t,Gy(n))}function ip(){for(var n=this._name,t=this._id,e=ea(),i=this._groups,r=i.length,s=0;s<r;++s)for(var o=i[s],a=o.length,l,c=0;c<a;++c)if(l=o[c]){var u=ue(l,t);kn(l,n,e,c,o,{time:u.time+u.delay+u.duration,delay:0,duration:u.duration,ease:u.ease})}return new we(i,this._parents,n,e)}function rp(){var n,t,e=this,i=e._id,r=e.size();return new Promise(function(s,o){var a={value:o},l={value:function(){--r===0&&s()}};e.each(function(){var c=Ae(this,i),u=c.on;u!==n&&(t=(n=u).copy(),t._.cancel.push(a),t._.interrupt.push(a),t._.end.push(l)),c.on=t})})}var Wy=0;function we(n,t,e,i){this._groups=n,this._parents=t,this._name=e,this._id=i}function lc(n){return Mn().transition(n)}function ea(){return++Wy}var nr=Mn.prototype;we.prototype=lc.prototype={constructor:we,select:Jd,selectAll:$d,filter:qd,merge:Xd,selection:Kd,transition:ip,call:nr.call,nodes:nr.nodes,node:nr.node,size:nr.size,empty:nr.empty,each:nr.each,on:Yd,attr:kd,attrTween:Hd,style:jd,styleTween:tp,text:ep,textTween:np,remove:Zd,tween:Od,delay:Vd,duration:Gd,ease:Wd,end:rp};function na(n){return((n*=2)<=1?n*n*n:(n-=2)*n*n+2)/2}var cc={time:null,delay:0,duration:250,ease:na};function qy(n,t){for(var e;!(e=n.__transition)||!(e=e[t]);)if(!(n=n.parentNode))return cc.time=tr(),cc;return e}function sp(n){var t,e;n instanceof we?(t=n._id,n=n._name):(t=ea(),(e=cc).time=tr(),n=n==null?null:n+"");for(var i=this._groups,r=i.length,s=0;s<r;++s)for(var o=i[s],a=o.length,l,c=0;c<a;++c)(l=o[c])&&kn(l,n,t,c,o,e||qy(l,t));return new we(i,this._parents,n,t)}Mn.prototype.interrupt=Bd;Mn.prototype.transition=sp;function op(n){return[+n[0],+n[1]]}function Xy(n){return[op(n[0]),op(n[1])]}var GP={name:"x",handles:["w","e"].map(uc),input:function(n,t){return n==null?null:[[+n[0],t[0][1]],[+n[1],t[1][1]]]},output:function(n){return n&&[n[0][0],n[1][0]]}},WP={name:"y",handles:["n","s"].map(uc),input:function(n,t){return n==null?null:[[t[0][0],+n[0]],[t[1][0],+n[1]]]},output:function(n){return n&&[n[0][1],n[1][1]]}},qP={name:"xy",handles:["n","w","e","s","nw","ne","sw","se"].map(uc),input:function(n){return n==null?null:Xy(n)},output:function(n){return n}};function uc(n){return{type:n}}var ap=Math.PI,Yy=ap/2,Zy=ap*2;var Jy=Array.prototype.slice;var Be="$";function ia(){}ia.prototype=lp.prototype={constructor:ia,has:function(n){return Be+n in this},get:function(n){return this[Be+n]},set:function(n,t){return this[Be+n]=t,this},remove:function(n){var t=Be+n;return t in this&&delete this[t]},clear:function(){for(var n in this)n[0]===Be&&delete this[n]},keys:function(){var n=[];for(var t in this)t[0]===Be&&n.push(t.slice(1));return n},values:function(){var n=[];for(var t in this)t[0]===Be&&n.push(this[t]);return n},entries:function(){var n=[];for(var t in this)t[0]===Be&&n.push({key:t.slice(1),value:this[t]});return n},size:function(){var n=0;for(var t in this)t[0]===Be&&++n;return n},empty:function(){for(var n in this)if(n[0]===Be)return!1;return!0},each:function(n){for(var t in this)t[0]===Be&&n(this[t],t.slice(1),this)}};function lp(n,t){var e=new ia;if(n instanceof ia)n.each(function(a,l){e.set(l,a)});else if(Array.isArray(n)){var i=-1,r=n.length,s;if(t==null)for(;++i<r;)e.set(i,n[i]);else for(;++i<r;)e.set(t(s=n[i],i,n),s)}else if(n)for(var o in n)e.set(o,n[o]);return e}var yi=lp;function ra(){}var vi=yi.prototype;ra.prototype=$y.prototype={constructor:ra,has:vi.has,add:function(n){return n+="",this[Be+n]=n,this},remove:vi.remove,clear:vi.clear,values:vi.keys,size:vi.size,empty:vi.empty,each:vi.each};function $y(n,t){var e=new ra;if(n instanceof ra)n.each(function(s){e.add(s)});else if(n){var i=-1,r=n.length;if(t==null)for(;++i<r;)e.add(n[i]);else for(;++i<r;)e.add(t(n[i],i,n))}return e}var Ky=Array.prototype,cp=Ky.slice;var TI=Math.PI*(3-Math.sqrt(5));function hp(n){return Math.abs(n=Math.round(n))>=1e21?n.toLocaleString("en").replace(/,/g,""):n.toString(10)}function _i(n,t){if((e=(n=t?n.toExponential(t-1):n.toExponential()).indexOf("e"))<0)return null;var e,i=n.slice(0,e);return[i.length>1?i[0]+i.slice(2):i,+n.slice(e+1)]}function un(n){return n=_i(Math.abs(n)),n?n[1]:NaN}function fp(n,t){return function(e,i){for(var r=e.length,s=[],o=0,a=n[0],l=0;r>0&&a>0&&(l+a+1>i&&(a=Math.max(1,i-l)),s.push(e.substring(r-=a,r+a)),!((l+=a+1)>i));)a=n[o=(o+1)%n.length];return s.reverse().join(t)}}function dp(n){return function(t){return t.replace(/[0-9]/g,function(e){return n[+e]})}}var tv=/^(?:(.)?([<>=^]))?([+\-( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?(~)?([a-z%])?$/i;function Hn(n){if(!(t=tv.exec(n)))throw new Error("invalid format: "+n);var t;return new sa({fill:t[1],align:t[2],sign:t[3],symbol:t[4],zero:t[5],width:t[6],comma:t[7],precision:t[8]&&t[8].slice(1),trim:t[9],type:t[10]})}Hn.prototype=sa.prototype;function sa(n){this.fill=n.fill===void 0?" ":n.fill+"",this.align=n.align===void 0?">":n.align+"",this.sign=n.sign===void 0?"-":n.sign+"",this.symbol=n.symbol===void 0?"":n.symbol+"",this.zero=!!n.zero,this.width=n.width===void 0?void 0:+n.width,this.comma=!!n.comma,this.precision=n.precision===void 0?void 0:+n.precision,this.trim=!!n.trim,this.type=n.type===void 0?"":n.type+""}sa.prototype.toString=function(){return this.fill+this.align+this.sign+this.symbol+(this.zero?"0":"")+(this.width===void 0?"":Math.max(1,this.width|0))+(this.comma?",":"")+(this.precision===void 0?"":"."+Math.max(0,this.precision|0))+(this.trim?"~":"")+this.type};function pp(n){t:for(var t=n.length,e=1,i=-1,r;e<t;++e)switch(n[e]){case".":i=r=e;break;case"0":i===0&&(i=e),r=e;break;default:if(!+n[e])break t;i>0&&(i=0);break}return i>0?n.slice(0,i)+n.slice(r+1):n}var hc;function mp(n,t){var e=_i(n,t);if(!e)return n+"";var i=e[0],r=e[1],s=r-(hc=Math.max(-8,Math.min(8,Math.floor(r/3)))*3)+1,o=i.length;return s===o?i:s>o?i+new Array(s-o+1).join("0"):s>0?i.slice(0,s)+"."+i.slice(s):"0."+new Array(1-s).join("0")+_i(n,Math.max(0,t+s-1))[0]}function fc(n,t){var e=_i(n,t);if(!e)return n+"";var i=e[0],r=e[1];return r<0?"0."+new Array(-r).join("0")+i:i.length>r+1?i.slice(0,r+1)+"."+i.slice(r+1):i+new Array(r-i.length+2).join("0")}var dc={"%":function(n,t){return(n*100).toFixed(t)},b:function(n){return Math.round(n).toString(2)},c:function(n){return n+""},d:hp,e:function(n,t){return n.toExponential(t)},f:function(n,t){return n.toFixed(t)},g:function(n,t){return n.toPrecision(t)},o:function(n){return Math.round(n).toString(8)},p:function(n,t){return fc(n*100,t)},r:fc,s:mp,X:function(n){return Math.round(n).toString(16).toUpperCase()},x:function(n){return Math.round(n).toString(16)}};function pc(n){return n}var gp=Array.prototype.map,xp=["y","z","a","f","p","n","\xB5","m","","k","M","G","T","P","E","Z","Y"];function yp(n){var t=n.grouping===void 0||n.thousands===void 0?pc:fp(gp.call(n.grouping,Number),n.thousands+""),e=n.currency===void 0?"":n.currency[0]+"",i=n.currency===void 0?"":n.currency[1]+"",r=n.decimal===void 0?".":n.decimal+"",s=n.numerals===void 0?pc:dp(gp.call(n.numerals,String)),o=n.percent===void 0?"%":n.percent+"",a=n.minus===void 0?"-":n.minus+"",l=n.nan===void 0?"NaN":n.nan+"";function c(h){h=Hn(h);var f=h.fill,d=h.align,g=h.sign,x=h.symbol,v=h.zero,m=h.width,p=h.comma,b=h.precision,_=h.trim,S=h.type;S==="n"?(p=!0,S="g"):dc[S]||(b===void 0&&(b=12),_=!0,S="g"),(v||f==="0"&&d==="=")&&(v=!0,f="0",d="=");var L=x==="$"?e:x==="#"&&/[boxX]/.test(S)?"0"+S.toLowerCase():"",A=x==="$"?i:/[%p]/.test(S)?o:"",H=dc[S],tt=/[defgprs%]/.test(S);b=b===void 0?6:/[gprs]/.test(S)?Math.max(1,Math.min(21,b)):Math.max(0,Math.min(20,b));function X(y){var R=L,D=A,F,z,N;if(S==="c")D=H(y)+D,y="";else{y=+y;var V=y<0||1/y<0;if(y=isNaN(y)?l:H(Math.abs(y),b),_&&(y=pp(y)),V&&+y==0&&g!=="+"&&(V=!1),R=(V?g==="("?g:a:g==="-"||g==="("?"":g)+R,D=(S==="s"?xp[8+hc/3]:"")+D+(V&&g==="("?")":""),tt){for(F=-1,z=y.length;++F<z;)if(N=y.charCodeAt(F),48>N||N>57){D=(N===46?r+y.slice(F+1):y.slice(F))+D,y=y.slice(0,F);break}}}p&&!v&&(y=t(y,1/0));var Q=R.length+y.length+D.length,at=Q<m?new Array(m-Q+1).join(f):"";switch(p&&v&&(y=t(at+y,at.length?m-D.length:1/0),at=""),d){case"<":y=R+y+D+at;break;case"=":y=R+at+y+D;break;case"^":y=at.slice(0,Q=at.length>>1)+R+y+D+at.slice(Q);break;default:y=at+R+y+D;break}return s(y)}return X.toString=function(){return h+""},X}function u(h,f){var d=c((h=Hn(h),h.type="f",h)),g=Math.max(-8,Math.min(8,Math.floor(un(f)/3)))*3,x=Math.pow(10,-g),v=xp[8+g/3];return function(m){return d(x*m)+v}}return{format:c,formatPrefix:u}}var oa,Oe,aa;mc({decimal:".",thousands:",",grouping:[3],currency:["$",""],minus:"-"});function mc(n){return oa=yp(n),Oe=oa.format,aa=oa.formatPrefix,oa}function gc(n){return Math.max(0,-un(Math.abs(n)))}function xc(n,t){return Math.max(0,Math.max(-8,Math.min(8,Math.floor(un(t)/3)))*3-un(Math.abs(n)))}function yc(n,t){return n=Math.abs(n),t=Math.abs(t)-n,Math.max(0,un(t)-un(n))+1}function We(){return Math.random()}var ev=function n(t){function e(i,r){return i=i==null?0:+i,r=r==null?1:+r,arguments.length===1?(r=i,i=0):r-=i,function(){return t()*r+i}}return e.source=n,e}(We);var vc=function n(t){function e(i,r){var s,o;return i=i==null?0:+i,r=r==null?1:+r,function(){var a;if(s!=null)a=s,s=null;else do s=t()*2-1,a=t()*2-1,o=s*s+a*a;while(!o||o>1);return i+r*a*Math.sqrt(-2*Math.log(o)/o)}}return e.source=n,e}(We);var nv=function n(t){function e(){var i=vc.source(t).apply(this,arguments);return function(){return Math.exp(i())}}return e.source=n,e}(We);var _c=function n(t){function e(i){return function(){for(var r=0,s=0;s<i;++s)r+=t();return r}}return e.source=n,e}(We);var iv=function n(t){function e(i){var r=_c.source(t)(i);return function(){return r()/i}}return e.source=n,e}(We);var rv=function n(t){function e(i){return function(){return-Math.log(1-t())/i}}return e.source=n,e}(We);function Pe(n,t){switch(arguments.length){case 0:break;case 1:this.range(n);break;default:this.range(t).domain(n);break}return this}var vp=Array.prototype,bs=vp.map,wi=vp.slice;function _p(n){return function(){return n}}function wc(n){return+n}var wp=[0,1];function De(n){return n}function Mc(n,t){return(t-=n=+n)?function(e){return(e-n)/t}:_p(isNaN(t)?NaN:.5)}function Mp(n){var t=n[0],e=n[n.length-1],i;return t>e&&(i=t,t=e,e=i),function(r){return Math.max(t,Math.min(e,r))}}function ov(n,t,e){var i=n[0],r=n[1],s=t[0],o=t[1];return r<i?(i=Mc(r,i),s=e(o,s)):(i=Mc(i,r),s=e(s,o)),function(a){return s(i(a))}}function av(n,t,e){var i=Math.min(n.length,t.length)-1,r=new Array(i),s=new Array(i),o=-1;for(n[i]<n[0]&&(n=n.slice().reverse(),t=t.slice().reverse());++o<i;)r[o]=Mc(n[o],n[o+1]),s[o]=e(t[o],t[o+1]);return function(a){var l=Bn(n,a,1,i)-1;return s[l](r[l](a))}}function Vn(n,t){return t.domain(n.domain()).range(n.range()).interpolate(n.interpolate()).clamp(n.clamp()).unknown(n.unknown())}function Ss(){var n=wp,t=wp,e=gi,i,r,s,o=De,a,l,c;function u(){return a=Math.min(n.length,t.length)>2?av:ov,l=c=null,h}function h(f){return isNaN(f=+f)?s:(l||(l=a(n.map(i),t,e)))(i(o(f)))}return h.invert=function(f){return o(r((c||(c=a(t,n.map(i),ye)))(f)))},h.domain=function(f){return arguments.length?(n=bs.call(f,wc),o===De||(o=Mp(n)),u()):n.slice()},h.range=function(f){return arguments.length?(t=wi.call(f),u()):t.slice()},h.rangeRound=function(f){return t=wi.call(f),e=tc,u()},h.clamp=function(f){return arguments.length?(o=f?Mp(n):De,h):o!==De},h.interpolate=function(f){return arguments.length?(e=f,u()):e},h.unknown=function(f){return arguments.length?(s=f,h):s},function(f,d){return i=f,r=d,u()}}function Es(n,t){return Ss()(n,t)}function bc(n,t,e,i){var r=_n(n,t,e),s;switch(i=Hn(i==null?",f":i),i.type){case"s":{var o=Math.max(Math.abs(n),Math.abs(t));return i.precision==null&&!isNaN(s=xc(r,o))&&(i.precision=s),aa(i,o)}case"":case"e":case"g":case"p":case"r":{i.precision==null&&!isNaN(s=yc(r,Math.max(Math.abs(n),Math.abs(t))))&&(i.precision=s-(i.type==="e"));break}case"f":case"%":{i.precision==null&&!isNaN(s=gc(r))&&(i.precision=s-(i.type==="%")*2);break}}return Oe(i)}function Mi(n){var t=n.domain;return n.ticks=function(e){var i=t();return rs(i[0],i[i.length-1],e==null?10:e)},n.tickFormat=function(e,i){var r=t();return bc(r[0],r[r.length-1],e==null?10:e,i)},n.nice=function(e){e==null&&(e=10);var i=t(),r=0,s=i.length-1,o=i[r],a=i[s],l;return a<o&&(l=o,o=a,a=l,l=r,r=s,s=l),l=Ji(o,a,e),l>0?(o=Math.floor(o/l)*l,a=Math.ceil(a/l)*l,l=Ji(o,a,e)):l<0&&(o=Math.ceil(o*l)/l,a=Math.floor(a*l)/l,l=Ji(o,a,e)),l>0?(i[r]=Math.floor(o/l)*l,i[s]=Math.ceil(a/l)*l,t(i)):l<0&&(i[r]=Math.ceil(o*l)/l,i[s]=Math.floor(a*l)/l,t(i)),n},n}function ir(){var n=Es(De,De);return n.copy=function(){return Vn(n,ir())},Pe.apply(n,arguments),Mi(n)}function la(n,t){n=n.slice();var e=0,i=n.length-1,r=n[e],s=n[i],o;return s<r&&(o=e,e=i,i=o,o=r,r=s,s=o),n[e]=t.floor(r),n[i]=t.ceil(s),n}function bp(n){return Math.log(n)}function Sp(n){return Math.exp(n)}function lv(n){return-Math.log(-n)}function cv(n){return-Math.exp(-n)}function uv(n){return isFinite(n)?+("1e"+n):n<0?0:n}function hv(n){return n===10?uv:n===Math.E?Math.exp:function(t){return Math.pow(n,t)}}function fv(n){return n===Math.E?Math.log:n===10&&Math.log10||n===2&&Math.log2||(n=Math.log(n),function(t){return Math.log(t)/n})}function Ep(n){return function(t){return-n(-t)}}function Sc(n){var t=n(bp,Sp),e=t.domain,i=10,r,s;function o(){return r=fv(i),s=hv(i),e()[0]<0?(r=Ep(r),s=Ep(s),n(lv,cv)):n(bp,Sp),t}return t.base=function(a){return arguments.length?(i=+a,o()):i},t.domain=function(a){return arguments.length?(e(a),o()):e()},t.ticks=function(a){var l=e(),c=l[0],u=l[l.length-1],h;(h=u<c)&&(f=c,c=u,u=f);var f=r(c),d=r(u),g,x,v,m=a==null?10:+a,p=[];if(!(i%1)&&d-f<m){if(f=Math.round(f)-1,d=Math.round(d)+1,c>0){for(;f<d;++f)for(x=1,g=s(f);x<i;++x)if(v=g*x,!(v<c)){if(v>u)break;p.push(v)}}else for(;f<d;++f)for(x=i-1,g=s(f);x>=1;--x)if(v=g*x,!(v<c)){if(v>u)break;p.push(v)}}else p=rs(f,d,Math.min(d-f,m)).map(s);return h?p.reverse():p},t.tickFormat=function(a,l){if(l==null&&(l=i===10?".0e":","),typeof l!="function"&&(l=Oe(l)),a===1/0)return l;a==null&&(a=10);var c=Math.max(1,i*a/t.ticks().length);return function(u){var h=u/s(Math.round(r(u)));return h*i<i-.5&&(h*=i),h<=c?l(u):""}},t.nice=function(){return e(la(e(),{floor:function(a){return s(Math.floor(r(a)))},ceil:function(a){return s(Math.ceil(r(a)))}}))},t}function Ts(){var n=Sc(Ss()).domain([1,10]);return n.copy=function(){return Vn(n,Ts()).base(n.base())},Pe.apply(n,arguments),n}var Ec=new Date,Tc=new Date;function Yt(n,t,e,i){function r(s){return n(s=arguments.length===0?new Date:new Date(+s)),s}return r.floor=function(s){return n(s=new Date(+s)),s},r.ceil=function(s){return n(s=new Date(s-1)),t(s,1),n(s),s},r.round=function(s){var o=r(s),a=r.ceil(s);return s-o<a-s?o:a},r.offset=function(s,o){return t(s=new Date(+s),o==null?1:Math.floor(o)),s},r.range=function(s,o,a){var l=[],c;if(s=r.ceil(s),a=a==null?1:Math.floor(a),!(s<o)||!(a>0))return l;do l.push(c=new Date(+s)),t(s,a),n(s);while(c<s&&s<o);return l},r.filter=function(s){return Yt(function(o){if(o>=o)for(;n(o),!s(o);)o.setTime(o-1)},function(o,a){if(o>=o)if(a<0)for(;++a<=0;)for(;t(o,-1),!s(o););else for(;--a>=0;)for(;t(o,1),!s(o););})},e&&(r.count=function(s,o){return Ec.setTime(+s),Tc.setTime(+o),n(Ec),n(Tc),Math.floor(e(Ec,Tc))},r.every=function(s){return s=Math.floor(s),!isFinite(s)||!(s>0)?null:s>1?r.filter(i?function(o){return i(o)%s===0}:function(o){return r.count(0,o)%s===0}):r}),r}var ca=Yt(function(){},function(n,t){n.setTime(+n+t)},function(n,t){return t-n});ca.every=function(n){return n=Math.floor(n),!isFinite(n)||!(n>0)?null:n>1?Yt(function(t){t.setTime(Math.floor(t/n)*n)},function(t,e){t.setTime(+t+e*n)},function(t,e){return(e-t)/n}):ca};var ua=ca,Tp=ca.range;var bi=1e3,Sn=6e4,Ac=36e5,ha=864e5,fa=6048e5;var Ap=Yt(function(n){n.setTime(n-n.getMilliseconds())},function(n,t){n.setTime(+n+t*bi)},function(n,t){return(t-n)/bi},function(n){return n.getUTCSeconds()}),da=Ap,Cp=Ap.range;var Rp=Yt(function(n){n.setTime(n-n.getMilliseconds()-n.getSeconds()*bi)},function(n,t){n.setTime(+n+t*Sn)},function(n,t){return(t-n)/Sn},function(n){return n.getMinutes()}),Cc=Rp,dv=Rp.range;var Lp=Yt(function(n){n.setTime(n-n.getMilliseconds()-n.getSeconds()*bi-n.getMinutes()*Sn)},function(n,t){n.setTime(+n+t*Ac)},function(n,t){return(t-n)/Ac},function(n){return n.getHours()}),Rc=Lp,pv=Lp.range;var Pp=Yt(function(n){n.setHours(0,0,0,0)},function(n,t){n.setDate(n.getDate()+t)},function(n,t){return(t-n-(t.getTimezoneOffset()-n.getTimezoneOffset())*Sn)/ha},function(n){return n.getDate()-1}),rr=Pp,mv=Pp.range;function Si(n){return Yt(function(t){t.setDate(t.getDate()-(t.getDay()+7-n)%7),t.setHours(0,0,0,0)},function(t,e){t.setDate(t.getDate()+e*7)},function(t,e){return(e-t-(e.getTimezoneOffset()-t.getTimezoneOffset())*Sn)/fa})}var Ei=Si(0),sr=Si(1),Dp=Si(2),Ip=Si(3),Gn=Si(4),Np=Si(5),Fp=Si(6),zp=Ei.range,gv=sr.range,xv=Dp.range,yv=Ip.range,vv=Gn.range,_v=Np.range,wv=Fp.range;var Up=Yt(function(n){n.setDate(1),n.setHours(0,0,0,0)},function(n,t){n.setMonth(n.getMonth()+t)},function(n,t){return t.getMonth()-n.getMonth()+(t.getFullYear()-n.getFullYear())*12},function(n){return n.getMonth()}),Lc=Up,Mv=Up.range;var Pc=Yt(function(n){n.setMonth(0,1),n.setHours(0,0,0,0)},function(n,t){n.setFullYear(n.getFullYear()+t)},function(n,t){return t.getFullYear()-n.getFullYear()},function(n){return n.getFullYear()});Pc.every=function(n){return!isFinite(n=Math.floor(n))||!(n>0)?null:Yt(function(t){t.setFullYear(Math.floor(t.getFullYear()/n)*n),t.setMonth(0,1),t.setHours(0,0,0,0)},function(t,e){t.setFullYear(t.getFullYear()+e*n)})};var En=Pc,bv=Pc.range;var Bp=Yt(function(n){n.setUTCHours(0,0,0,0)},function(n,t){n.setUTCDate(n.getUTCDate()+t)},function(n,t){return(t-n)/ha},function(n){return n.getUTCDate()-1}),pa=Bp,Sv=Bp.range;function Ti(n){return Yt(function(t){t.setUTCDate(t.getUTCDate()-(t.getUTCDay()+7-n)%7),t.setUTCHours(0,0,0,0)},function(t,e){t.setUTCDate(t.getUTCDate()+e*7)},function(t,e){return(e-t)/fa})}var As=Ti(0),or=Ti(1),Op=Ti(2),kp=Ti(3),Wn=Ti(4),Hp=Ti(5),Vp=Ti(6),Gp=As.range,Ev=or.range,Tv=Op.range,Av=kp.range,Cv=Wn.range,Rv=Hp.range,Lv=Vp.range;var Dc=Yt(function(n){n.setUTCMonth(0,1),n.setUTCHours(0,0,0,0)},function(n,t){n.setUTCFullYear(n.getUTCFullYear()+t)},function(n,t){return t.getUTCFullYear()-n.getUTCFullYear()},function(n){return n.getUTCFullYear()});Dc.every=function(n){return!isFinite(n=Math.floor(n))||!(n>0)?null:Yt(function(t){t.setUTCFullYear(Math.floor(t.getUTCFullYear()/n)*n),t.setUTCMonth(0,1),t.setUTCHours(0,0,0,0)},function(t,e){t.setUTCFullYear(t.getUTCFullYear()+e*n)})};var Ai=Dc,Pv=Dc.range;function Ic(n){if(0<=n.y&&n.y<100){var t=new Date(-1,n.m,n.d,n.H,n.M,n.S,n.L);return t.setFullYear(n.y),t}return new Date(n.y,n.m,n.d,n.H,n.M,n.S,n.L)}function Nc(n){if(0<=n.y&&n.y<100){var t=new Date(Date.UTC(-1,n.m,n.d,n.H,n.M,n.S,n.L));return t.setUTCFullYear(n.y),t}return new Date(Date.UTC(n.y,n.m,n.d,n.H,n.M,n.S,n.L))}function Cs(n,t,e){return{y:n,m:t,d:e,H:0,M:0,S:0,L:0}}function Fc(n){var t=n.dateTime,e=n.date,i=n.time,r=n.periods,s=n.days,o=n.shortDays,a=n.months,l=n.shortMonths,c=Rs(r),u=Ls(r),h=Rs(s),f=Ls(s),d=Rs(o),g=Ls(o),x=Rs(a),v=Ls(a),m=Rs(l),p=Ls(l),b={a:V,A:Q,b:at,B:G,c:null,d:Jp,e:Jp,f:t_,g:u_,G:f_,H:Kv,I:Qv,j:jv,L:tm,m:e_,M:n_,p:$,q:lt,Q:Qp,s:jp,S:i_,u:r_,U:s_,V:o_,w:a_,W:l_,x:null,X:null,y:c_,Y:h_,Z:d_,"%":Kp},_={a:dt,A:xt,b:k,B:Ft,c:null,d:$p,e:$p,f:x_,g:A_,G:R_,H:p_,I:m_,j:g_,L:nm,m:y_,M:v_,p:mt,q:St,Q:Qp,s:jp,S:__,u:w_,U:M_,V:b_,w:S_,W:E_,x:null,X:null,y:T_,Y:C_,Z:L_,"%":Kp},S={a:X,A:y,b:R,B:D,c:F,d:Yp,e:Yp,f:Yv,g:Xp,G:qp,H:Zp,I:Zp,j:Gv,L:Xv,m:Vv,M:Wv,p:tt,q:Hv,Q:Jv,s:$v,S:qv,u:zv,U:Uv,V:Bv,w:Fv,W:Ov,x:z,X:N,y:Xp,Y:qp,Z:kv,"%":Zv};b.x=L(e,b),b.X=L(i,b),b.c=L(t,b),_.x=L(e,_),_.X=L(i,_),_.c=L(t,_);function L(B,st){return function(nt){var C=[],j=-1,J=0,it=B.length,et,vt,bt;for(nt instanceof Date||(nt=new Date(+nt));++j<it;)B.charCodeAt(j)===37&&(C.push(B.slice(J,j)),(vt=Wp[et=B.charAt(++j)])!=null?et=B.charAt(++j):vt=et==="e"?" ":"0",(bt=st[et])&&(et=bt(nt,vt)),C.push(et),J=j+1);return C.push(B.slice(J,j)),C.join("")}}function A(B,st){return function(nt){var C=Cs(1900,void 0,1),j=H(C,B,nt+="",0),J,it;if(j!=nt.length)return null;if("Q"in C)return new Date(C.Q);if("s"in C)return new Date(C.s*1e3+("L"in C?C.L:0));if(st&&!("Z"in C)&&(C.Z=0),"p"in C&&(C.H=C.H%12+C.p*12),C.m===void 0&&(C.m="q"in C?C.q:0),"V"in C){if(C.V<1||C.V>53)return null;"w"in C||(C.w=1),"Z"in C?(J=Nc(Cs(C.y,0,1)),it=J.getUTCDay(),J=it>4||it===0?or.ceil(J):or(J),J=pa.offset(J,(C.V-1)*7),C.y=J.getUTCFullYear(),C.m=J.getUTCMonth(),C.d=J.getUTCDate()+(C.w+6)%7):(J=Ic(Cs(C.y,0,1)),it=J.getDay(),J=it>4||it===0?sr.ceil(J):sr(J),J=rr.offset(J,(C.V-1)*7),C.y=J.getFullYear(),C.m=J.getMonth(),C.d=J.getDate()+(C.w+6)%7)}else("W"in C||"U"in C)&&("w"in C||(C.w="u"in C?C.u%7:"W"in C?1:0),it="Z"in C?Nc(Cs(C.y,0,1)).getUTCDay():Ic(Cs(C.y,0,1)).getDay(),C.m=0,C.d="W"in C?(C.w+6)%7+C.W*7-(it+5)%7:C.w+C.U*7-(it+6)%7);return"Z"in C?(C.H+=C.Z/100|0,C.M+=C.Z%100,Nc(C)):Ic(C)}}function H(B,st,nt,C){for(var j=0,J=st.length,it=nt.length,et,vt;j<J;){if(C>=it)return-1;if(et=st.charCodeAt(j++),et===37){if(et=st.charAt(j++),vt=S[et in Wp?st.charAt(j++):et],!vt||(C=vt(B,nt,C))<0)return-1}else if(et!=nt.charCodeAt(C++))return-1}return C}function tt(B,st,nt){var C=c.exec(st.slice(nt));return C?(B.p=u[C[0].toLowerCase()],nt+C[0].length):-1}function X(B,st,nt){var C=d.exec(st.slice(nt));return C?(B.w=g[C[0].toLowerCase()],nt+C[0].length):-1}function y(B,st,nt){var C=h.exec(st.slice(nt));return C?(B.w=f[C[0].toLowerCase()],nt+C[0].length):-1}function R(B,st,nt){var C=m.exec(st.slice(nt));return C?(B.m=p[C[0].toLowerCase()],nt+C[0].length):-1}function D(B,st,nt){var C=x.exec(st.slice(nt));return C?(B.m=v[C[0].toLowerCase()],nt+C[0].length):-1}function F(B,st,nt){return H(B,t,st,nt)}function z(B,st,nt){return H(B,e,st,nt)}function N(B,st,nt){return H(B,i,st,nt)}function V(B){return o[B.getDay()]}function Q(B){return s[B.getDay()]}function at(B){return l[B.getMonth()]}function G(B){return a[B.getMonth()]}function $(B){return r[+(B.getHours()>=12)]}function lt(B){return 1+~~(B.getMonth()/3)}function dt(B){return o[B.getUTCDay()]}function xt(B){return s[B.getUTCDay()]}function k(B){return l[B.getUTCMonth()]}function Ft(B){return a[B.getUTCMonth()]}function mt(B){return r[+(B.getUTCHours()>=12)]}function St(B){return 1+~~(B.getUTCMonth()/3)}return{format:function(B){var st=L(B+="",b);return st.toString=function(){return B},st},parse:function(B){var st=A(B+="",!1);return st.toString=function(){return B},st},utcFormat:function(B){var st=L(B+="",_);return st.toString=function(){return B},st},utcParse:function(B){var st=A(B+="",!0);return st.toString=function(){return B},st}}}var Wp={"-":"",_:" ",0:"0"},pe=/^\s*\d+/,Dv=/^%/,Iv=/[\\^$*+?|[\]().{}]/g;function Bt(n,t,e){var i=n<0?"-":"",r=(i?-n:n)+"",s=r.length;return i+(s<e?new Array(e-s+1).join(t)+r:r)}function Nv(n){return n.replace(Iv,"\\$&")}function Rs(n){return new RegExp("^(?:"+n.map(Nv).join("|")+")","i")}function Ls(n){for(var t={},e=-1,i=n.length;++e<i;)t[n[e].toLowerCase()]=e;return t}function Fv(n,t,e){var i=pe.exec(t.slice(e,e+1));return i?(n.w=+i[0],e+i[0].length):-1}function zv(n,t,e){var i=pe.exec(t.slice(e,e+1));return i?(n.u=+i[0],e+i[0].length):-1}function Uv(n,t,e){var i=pe.exec(t.slice(e,e+2));return i?(n.U=+i[0],e+i[0].length):-1}function Bv(n,t,e){var i=pe.exec(t.slice(e,e+2));return i?(n.V=+i[0],e+i[0].length):-1}function Ov(n,t,e){var i=pe.exec(t.slice(e,e+2));return i?(n.W=+i[0],e+i[0].length):-1}function qp(n,t,e){var i=pe.exec(t.slice(e,e+4));return i?(n.y=+i[0],e+i[0].length):-1}function Xp(n,t,e){var i=pe.exec(t.slice(e,e+2));return i?(n.y=+i[0]+(+i[0]>68?1900:2e3),e+i[0].length):-1}function kv(n,t,e){var i=/^(Z)|([+-]\d\d)(?::?(\d\d))?/.exec(t.slice(e,e+6));return i?(n.Z=i[1]?0:-(i[2]+(i[3]||"00")),e+i[0].length):-1}function Hv(n,t,e){var i=pe.exec(t.slice(e,e+1));return i?(n.q=i[0]*3-3,e+i[0].length):-1}function Vv(n,t,e){var i=pe.exec(t.slice(e,e+2));return i?(n.m=i[0]-1,e+i[0].length):-1}function Yp(n,t,e){var i=pe.exec(t.slice(e,e+2));return i?(n.d=+i[0],e+i[0].length):-1}function Gv(n,t,e){var i=pe.exec(t.slice(e,e+3));return i?(n.m=0,n.d=+i[0],e+i[0].length):-1}function Zp(n,t,e){var i=pe.exec(t.slice(e,e+2));return i?(n.H=+i[0],e+i[0].length):-1}function Wv(n,t,e){var i=pe.exec(t.slice(e,e+2));return i?(n.M=+i[0],e+i[0].length):-1}function qv(n,t,e){var i=pe.exec(t.slice(e,e+2));return i?(n.S=+i[0],e+i[0].length):-1}function Xv(n,t,e){var i=pe.exec(t.slice(e,e+3));return i?(n.L=+i[0],e+i[0].length):-1}function Yv(n,t,e){var i=pe.exec(t.slice(e,e+6));return i?(n.L=Math.floor(i[0]/1e3),e+i[0].length):-1}function Zv(n,t,e){var i=Dv.exec(t.slice(e,e+1));return i?e+i[0].length:-1}function Jv(n,t,e){var i=pe.exec(t.slice(e));return i?(n.Q=+i[0],e+i[0].length):-1}function $v(n,t,e){var i=pe.exec(t.slice(e));return i?(n.s=+i[0],e+i[0].length):-1}function Jp(n,t){return Bt(n.getDate(),t,2)}function Kv(n,t){return Bt(n.getHours(),t,2)}function Qv(n,t){return Bt(n.getHours()%12||12,t,2)}function jv(n,t){return Bt(1+rr.count(En(n),n),t,3)}function tm(n,t){return Bt(n.getMilliseconds(),t,3)}function t_(n,t){return tm(n,t)+"000"}function e_(n,t){return Bt(n.getMonth()+1,t,2)}function n_(n,t){return Bt(n.getMinutes(),t,2)}function i_(n,t){return Bt(n.getSeconds(),t,2)}function r_(n){var t=n.getDay();return t===0?7:t}function s_(n,t){return Bt(Ei.count(En(n)-1,n),t,2)}function em(n){var t=n.getDay();return t>=4||t===0?Gn(n):Gn.ceil(n)}function o_(n,t){return n=em(n),Bt(Gn.count(En(n),n)+(En(n).getDay()===4),t,2)}function a_(n){return n.getDay()}function l_(n,t){return Bt(sr.count(En(n)-1,n),t,2)}function c_(n,t){return Bt(n.getFullYear()%100,t,2)}function u_(n,t){return n=em(n),Bt(n.getFullYear()%100,t,2)}function h_(n,t){return Bt(n.getFullYear()%1e4,t,4)}function f_(n,t){var e=n.getDay();return n=e>=4||e===0?Gn(n):Gn.ceil(n),Bt(n.getFullYear()%1e4,t,4)}function d_(n){var t=n.getTimezoneOffset();return(t>0?"-":(t*=-1,"+"))+Bt(t/60|0,"0",2)+Bt(t%60,"0",2)}function $p(n,t){return Bt(n.getUTCDate(),t,2)}function p_(n,t){return Bt(n.getUTCHours(),t,2)}function m_(n,t){return Bt(n.getUTCHours()%12||12,t,2)}function g_(n,t){return Bt(1+pa.count(Ai(n),n),t,3)}function nm(n,t){return Bt(n.getUTCMilliseconds(),t,3)}function x_(n,t){return nm(n,t)+"000"}function y_(n,t){return Bt(n.getUTCMonth()+1,t,2)}function v_(n,t){return Bt(n.getUTCMinutes(),t,2)}function __(n,t){return Bt(n.getUTCSeconds(),t,2)}function w_(n){var t=n.getUTCDay();return t===0?7:t}function M_(n,t){return Bt(As.count(Ai(n)-1,n),t,2)}function im(n){var t=n.getUTCDay();return t>=4||t===0?Wn(n):Wn.ceil(n)}function b_(n,t){return n=im(n),Bt(Wn.count(Ai(n),n)+(Ai(n).getUTCDay()===4),t,2)}function S_(n){return n.getUTCDay()}function E_(n,t){return Bt(or.count(Ai(n)-1,n),t,2)}function T_(n,t){return Bt(n.getUTCFullYear()%100,t,2)}function A_(n,t){return n=im(n),Bt(n.getUTCFullYear()%100,t,2)}function C_(n,t){return Bt(n.getUTCFullYear()%1e4,t,4)}function R_(n,t){var e=n.getUTCDay();return n=e>=4||e===0?Wn(n):Wn.ceil(n),Bt(n.getUTCFullYear()%1e4,t,4)}function L_(){return"+0000"}function Kp(){return"%"}function Qp(n){return+n}function jp(n){return Math.floor(+n/1e3)}var ar,ma,rm,sm,om;zc({dateTime:"%x, %X",date:"%-m/%-d/%Y",time:"%-I:%M:%S %p",periods:["AM","PM"],days:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],shortDays:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],months:["January","February","March","April","May","June","July","August","September","October","November","December"],shortMonths:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]});function zc(n){return ar=Fc(n),ma=ar.format,rm=ar.parse,sm=ar.utcFormat,om=ar.utcParse,ar}var Ps=1e3,Ds=Ps*60,Is=Ds*60,Ns=Is*24,P_=Ns*7,am=Ns*30,Uc=Ns*365;function D_(n){return new Date(n)}function I_(n){return n instanceof Date?+n:+new Date(+n)}function Bc(n,t,e,i,r,s,o,a,l){var c=Es(De,De),u=c.invert,h=c.domain,f=l(".%L"),d=l(":%S"),g=l("%I:%M"),x=l("%I %p"),v=l("%a %d"),m=l("%b %d"),p=l("%B"),b=l("%Y"),_=[[o,1,Ps],[o,5,5*Ps],[o,15,15*Ps],[o,30,30*Ps],[s,1,Ds],[s,5,5*Ds],[s,15,15*Ds],[s,30,30*Ds],[r,1,Is],[r,3,3*Is],[r,6,6*Is],[r,12,12*Is],[i,1,Ns],[i,2,2*Ns],[e,1,P_],[t,1,am],[t,3,3*am],[n,1,Uc]];function S(A){return(o(A)<A?f:s(A)<A?d:r(A)<A?g:i(A)<A?x:t(A)<A?e(A)<A?v:m:n(A)<A?p:b)(A)}function L(A,H,tt,X){if(A==null&&(A=10),typeof A=="number"){var y=Math.abs(tt-H)/A,R=is(function(D){return D[2]}).right(_,y);R===_.length?(X=_n(H/Uc,tt/Uc,A),A=n):R?(R=_[y/_[R-1][2]<_[R][2]/y?R-1:R],X=R[1],A=R[0]):(X=Math.max(_n(H,tt,A),1),A=a)}return X==null?A:A.every(X)}return c.invert=function(A){return new Date(u(A))},c.domain=function(A){return arguments.length?h(bs.call(A,I_)):h().map(D_)},c.ticks=function(A,H){var tt=h(),X=tt[0],y=tt[tt.length-1],R=y<X,D;return R&&(D=X,X=y,y=D),D=L(A,X,y,H),D=D?D.range(X,y+1):[],R?D.reverse():D},c.tickFormat=function(A,H){return H==null?S:l(H)},c.nice=function(A,H){var tt=h();return(A=L(A,tt[0],tt[tt.length-1],H))?h(la(tt,A)):c},c.copy=function(){return Vn(c,Bc(n,t,e,i,r,s,o,a,l))},c}function Fs(){return Pe.apply(Bc(En,Lc,Ei,rr,Rc,Cc,da,ua,ma).domain([new Date(2e3,0,1),new Date(2e3,0,2)]),arguments)}function Oc(){this._=null}function lr(n){n.U=n.C=n.L=n.R=n.P=n.N=null}Oc.prototype={constructor:Oc,insert:function(n,t){var e,i,r;if(n){if(t.P=n,t.N=n.N,n.N&&(n.N.P=t),n.N=t,n.R){for(n=n.R;n.L;)n=n.L;n.L=t}else n.R=t;e=n}else this._?(n=cm(this._),t.P=null,t.N=n,n.P=n.L=t,e=n):(t.P=t.N=null,this._=t,e=null);for(t.L=t.R=null,t.U=e,t.C=!0,n=t;e&&e.C;)i=e.U,e===i.L?(r=i.R,r&&r.C?(e.C=r.C=!1,i.C=!0,n=i):(n===e.R&&(zs(this,e),n=e,e=n.U),e.C=!1,i.C=!0,Us(this,i))):(r=i.L,r&&r.C?(e.C=r.C=!1,i.C=!0,n=i):(n===e.L&&(Us(this,e),n=e,e=n.U),e.C=!1,i.C=!0,zs(this,i))),e=n.U;this._.C=!1},remove:function(n){n.N&&(n.N.P=n.P),n.P&&(n.P.N=n.N),n.N=n.P=null;var t=n.U,e,i=n.L,r=n.R,s,o;if(i?r?s=cm(r):s=i:s=r,t?t.L===n?t.L=s:t.R=s:this._=s,i&&r?(o=s.C,s.C=n.C,s.L=i,i.U=s,s!==r?(t=s.U,s.U=n.U,n=s.R,t.L=n,s.R=r,r.U=s):(s.U=t,t=s,n=s.R)):(o=n.C,n=s),n&&(n.U=t),!o){if(n&&n.C){n.C=!1;return}do{if(n===this._)break;if(n===t.L){if(e=t.R,e.C&&(e.C=!1,t.C=!0,zs(this,t),e=t.R),e.L&&e.L.C||e.R&&e.R.C){(!e.R||!e.R.C)&&(e.L.C=!1,e.C=!0,Us(this,e),e=t.R),e.C=t.C,t.C=e.R.C=!1,zs(this,t),n=this._;break}}else if(e=t.L,e.C&&(e.C=!1,t.C=!0,Us(this,t),e=t.L),e.L&&e.L.C||e.R&&e.R.C){(!e.L||!e.L.C)&&(e.R.C=!1,e.C=!0,zs(this,e),e=t.L),e.C=t.C,t.C=e.L.C=!1,Us(this,t),n=this._;break}e.C=!0,n=t,t=t.U}while(!n.C);n&&(n.C=!1)}}};function zs(n,t){var e=t,i=t.R,r=e.U;r?r.L===e?r.L=i:r.R=i:n._=i,i.U=r,e.U=i,e.R=i.L,e.R&&(e.R.U=e),i.L=e}function Us(n,t){var e=t,i=t.L,r=e.U;r?r.L===e?r.L=i:r.R=i:n._=i,i.U=r,e.U=i,e.L=i.R,e.L&&(e.L.U=e),i.R=e}function cm(n){for(;n.L;)n=n.L;return n}var kc=Oc;function cr(n,t,e,i){var r=[null,null],s=me.push(r)-1;return r.left=n,r.right=t,e&&Bs(r,n,t,e),i&&Bs(r,t,n,i),Ce[n.index].halfedges.push(s),Ce[t.index].halfedges.push(s),r}function ur(n,t,e){var i=[t,e];return i.left=n,i}function Bs(n,t,e,i){!n[0]&&!n[1]?(n[0]=i,n.left=t,n.right=e):n.left===e?n[1]=i:n[0]=i}function z_(n,t,e,i,r){var s=n[0],o=n[1],a=s[0],l=s[1],c=o[0],u=o[1],h=0,f=1,d=c-a,g=u-l,x;if(x=t-a,!(!d&&x>0)){if(x/=d,d<0){if(x<h)return;x<f&&(f=x)}else if(d>0){if(x>f)return;x>h&&(h=x)}if(x=i-a,!(!d&&x<0)){if(x/=d,d<0){if(x>f)return;x>h&&(h=x)}else if(d>0){if(x<h)return;x<f&&(f=x)}if(x=e-l,!(!g&&x>0)){if(x/=g,g<0){if(x<h)return;x<f&&(f=x)}else if(g>0){if(x>f)return;x>h&&(h=x)}if(x=r-l,!(!g&&x<0)){if(x/=g,g<0){if(x>f)return;x>h&&(h=x)}else if(g>0){if(x<h)return;x<f&&(f=x)}return!(h>0)&&!(f<1)||(h>0&&(n[0]=[a+h*d,l+h*g]),f<1&&(n[1]=[a+f*d,l+f*g])),!0}}}}}function U_(n,t,e,i,r){var s=n[1];if(s)return!0;var o=n[0],a=n.left,l=n.right,c=a[0],u=a[1],h=l[0],f=l[1],d=(c+h)/2,g=(u+f)/2,x,v;if(f===u){if(d<t||d>=i)return;if(c>h){if(!o)o=[d,e];else if(o[1]>=r)return;s=[d,r]}else{if(!o)o=[d,r];else if(o[1]<e)return;s=[d,e]}}else if(x=(c-h)/(f-u),v=g-x*d,x<-1||x>1)if(c>h){if(!o)o=[(e-v)/x,e];else if(o[1]>=r)return;s=[(r-v)/x,r]}else{if(!o)o=[(r-v)/x,r];else if(o[1]<e)return;s=[(e-v)/x,e]}else if(u<f){if(!o)o=[t,x*t+v];else if(o[0]>=i)return;s=[i,x*i+v]}else{if(!o)o=[i,x*i+v];else if(o[0]<t)return;s=[t,x*t+v]}return n[0]=o,n[1]=s,!0}function um(n,t,e,i){for(var r=me.length,s;r--;)(!U_(s=me[r],n,t,e,i)||!z_(s,n,t,e,i)||!(Math.abs(s[0][0]-s[1][0])>Xt||Math.abs(s[0][1]-s[1][1])>Xt))&&delete me[r]}function hm(n){return Ce[n.index]={site:n,halfedges:[]}}function B_(n,t){var e=n.site,i=t.left,r=t.right;return e===r&&(r=i,i=e),r?Math.atan2(r[1]-i[1],r[0]-i[0]):(e===i?(i=t[1],r=t[0]):(i=t[0],r=t[1]),Math.atan2(i[0]-r[0],r[1]-i[1]))}function Hc(n,t){return t[+(t.left!==n.site)]}function O_(n,t){return t[+(t.left===n.site)]}function fm(){for(var n=0,t=Ce.length,e,i,r,s;n<t;++n)if((e=Ce[n])&&(s=(i=e.halfedges).length)){var o=new Array(s),a=new Array(s);for(r=0;r<s;++r)o[r]=r,a[r]=B_(e,me[i[r]]);for(o.sort(function(l,c){return a[c]-a[l]}),r=0;r<s;++r)a[r]=i[o[r]];for(r=0;r<s;++r)i[r]=a[r]}}function dm(n,t,e,i){var r=Ce.length,s,o,a,l,c,u,h,f,d,g,x,v,m=!0;for(s=0;s<r;++s)if(o=Ce[s]){for(a=o.site,c=o.halfedges,l=c.length;l--;)me[c[l]]||c.splice(l,1);for(l=0,u=c.length;l<u;)g=O_(o,me[c[l]]),x=g[0],v=g[1],h=Hc(o,me[c[++l%u]]),f=h[0],d=h[1],(Math.abs(x-f)>Xt||Math.abs(v-d)>Xt)&&(c.splice(l,0,me.push(ur(a,g,Math.abs(x-n)<Xt&&i-v>Xt?[n,Math.abs(f-n)<Xt?d:i]:Math.abs(v-i)<Xt&&e-x>Xt?[Math.abs(d-i)<Xt?f:e,i]:Math.abs(x-e)<Xt&&v-t>Xt?[e,Math.abs(f-e)<Xt?d:t]:Math.abs(v-t)<Xt&&x-n>Xt?[Math.abs(d-t)<Xt?f:n,t]:null))-1),++u);u&&(m=!1)}if(m){var p,b,_,S=1/0;for(s=0,m=null;s<r;++s)(o=Ce[s])&&(a=o.site,p=a[0]-n,b=a[1]-t,_=p*p+b*b,_<S&&(S=_,m=o));if(m){var L=[n,t],A=[n,i],H=[e,i],tt=[e,t];m.halfedges.push(me.push(ur(a=m.site,L,A))-1,me.push(ur(a,A,H))-1,me.push(ur(a,H,tt))-1,me.push(ur(a,tt,L))-1)}}for(s=0;s<r;++s)(o=Ce[s])&&(o.halfedges.length||delete Ce[s])}var pm=[],ga;function k_(){lr(this),this.x=this.y=this.arc=this.site=this.cy=null}function Ci(n){var t=n.P,e=n.N;if(!(!t||!e)){var i=t.site,r=n.site,s=e.site;if(i!==s){var o=r[0],a=r[1],l=i[0]-o,c=i[1]-a,u=s[0]-o,h=s[1]-a,f=2*(l*h-c*u);if(!(f>=-mm)){var d=l*l+c*c,g=u*u+h*h,x=(h*d-c*g)/f,v=(l*g-u*d)/f,m=pm.pop()||new k_;m.arc=n,m.site=r,m.x=x+o,m.y=(m.cy=v+a)+Math.sqrt(x*x+v*v),n.circle=m;for(var p=null,b=hr._;b;)if(m.y<b.y||m.y===b.y&&m.x<=b.x)if(b.L)b=b.L;else{p=b.P;break}else if(b.R)b=b.R;else{p=b;break}hr.insert(p,m),p||(ga=m)}}}}function Ri(n){var t=n.circle;t&&(t.P||(ga=t.N),hr.remove(t),pm.push(t),lr(t),n.circle=null)}var xm=[];function H_(){lr(this),this.edge=this.site=this.circle=null}function gm(n){var t=xm.pop()||new H_;return t.site=n,t}function Vc(n){Ri(n),Li.remove(n),xm.push(n),lr(n)}function ym(n){var t=n.circle,e=t.x,i=t.cy,r=[e,i],s=n.P,o=n.N,a=[n];Vc(n);for(var l=s;l.circle&&Math.abs(e-l.circle.x)<Xt&&Math.abs(i-l.circle.cy)<Xt;)s=l.P,a.unshift(l),Vc(l),l=s;a.unshift(l),Ri(l);for(var c=o;c.circle&&Math.abs(e-c.circle.x)<Xt&&Math.abs(i-c.circle.cy)<Xt;)o=c.N,a.push(c),Vc(c),c=o;a.push(c),Ri(c);var u=a.length,h;for(h=1;h<u;++h)c=a[h],l=a[h-1],Bs(c.edge,l.site,c.site,r);l=a[0],c=a[u-1],c.edge=cr(l.site,c.site,null,r),Ci(l),Ci(c)}function vm(n){for(var t=n[0],e=n[1],i,r,s,o,a=Li._;a;)if(s=_m(a,e)-t,s>Xt)a=a.L;else if(o=t-V_(a,e),o>Xt){if(!a.R){i=a;break}a=a.R}else{s>-Xt?(i=a.P,r=a):o>-Xt?(i=a,r=a.N):i=r=a;break}hm(n);var l=gm(n);if(Li.insert(i,l),!(!i&&!r)){if(i===r){Ri(i),r=gm(i.site),Li.insert(l,r),l.edge=r.edge=cr(i.site,l.site),Ci(i),Ci(r);return}if(!r){l.edge=cr(i.site,l.site);return}Ri(i),Ri(r);var c=i.site,u=c[0],h=c[1],f=n[0]-u,d=n[1]-h,g=r.site,x=g[0]-u,v=g[1]-h,m=2*(f*v-d*x),p=f*f+d*d,b=x*x+v*v,_=[(v*p-d*b)/m+u,(f*b-x*p)/m+h];Bs(r.edge,c,g,_),l.edge=cr(c,n,null,_),r.edge=cr(n,g,null,_),Ci(i),Ci(r)}}function _m(n,t){var e=n.site,i=e[0],r=e[1],s=r-t;if(!s)return i;var o=n.P;if(!o)return-1/0;e=o.site;var a=e[0],l=e[1],c=l-t;if(!c)return a;var u=a-i,h=1/s-1/c,f=u/c;return h?(-f+Math.sqrt(f*f-2*h*(u*u/(-2*c)-l+c/2+r-s/2)))/h+i:(i+a)/2}function V_(n,t){var e=n.N;if(e)return _m(e,t);var i=n.site;return i[1]===t?i[0]:1/0}var Xt=1e-6,mm=1e-12,Li,Ce,hr,me;function G_(n,t,e){return(n[0]-e[0])*(t[1]-n[1])-(n[0]-t[0])*(e[1]-n[1])}function W_(n,t){return t[1]-n[1]||t[0]-n[0]}function xa(n,t){var e=n.sort(W_).pop(),i,r,s;for(me=[],Ce=new Array(n.length),Li=new kc,hr=new kc;;)if(s=ga,e&&(!s||e[1]<s.y||e[1]===s.y&&e[0]<s.x))(e[0]!==i||e[1]!==r)&&(vm(e),i=e[0],r=e[1]),e=n.pop();else if(s)ym(s.arc);else break;if(fm(),t){var o=+t[0][0],a=+t[0][1],l=+t[1][0],c=+t[1][1];um(o,a,l,c),dm(o,a,l,c)}this.edges=me,this.cells=Ce,Li=hr=me=Ce=null}xa.prototype={constructor:xa,polygons:function(){var n=this.edges;return this.cells.map(function(t){var e=t.halfedges.map(function(i){return Hc(t,n[i])});return e.data=t.site.data,e})},triangles:function(){var n=[],t=this.edges;return this.cells.forEach(function(e,i){if(!!(a=(s=e.halfedges).length))for(var r=e.site,s,o=-1,a,l,c=t[s[a-1]],u=c.left===r?c.right:c.left;++o<a;)l=u,c=t[s[o]],u=c.left===r?c.right:c.left,l&&u&&i<l.index&&i<u.index&&G_(r,l,u)<0&&n.push([r.data,l.data,u.data])}),n},links:function(){return this.edges.filter(function(n){return n.right}).map(function(n){return{source:n.left.data,target:n.right.data}})},find:function(n,t,e){for(var i=this,r,s=i._found||0,o=i.cells.length,a;!(a=i.cells[s]);)if(++s>=o)return null;var l=n-a.site[0],c=t-a.site[1],u=l*l+c*c;do a=i.cells[r=s],s=null,a.halfedges.forEach(function(h){var f=i.edges[h],d=f.left;if(!((d===a.site||!d)&&!(d=f.right))){var g=n-d[0],x=t-d[1],v=g*g+x*x;v<u&&(u=v,s=d.index)}});while(s!==null);return i._found=r,e==null||u<=e*e?a.site:null}};function Pi(n,t,e){this.k=n,this.x=t,this.y=e}Pi.prototype={constructor:Pi,scale:function(n){return n===1?this:new Pi(this.k*n,this.x,this.y)},translate:function(n,t){return n===0&t===0?this:new Pi(this.k,this.x+this.k*n,this.y+this.k*t)},apply:function(n){return[n[0]*this.k+this.x,n[1]*this.k+this.y]},applyX:function(n){return n*this.k+this.x},applyY:function(n){return n*this.k+this.y},invert:function(n){return[(n[0]-this.x)/this.k,(n[1]-this.y)/this.k]},invertX:function(n){return(n-this.x)/this.k},invertY:function(n){return(n-this.y)/this.k},rescaleX:function(n){return n.copy().domain(n.range().map(this.invertX,this).map(n.invert,n))},rescaleY:function(n){return n.copy().domain(n.range().map(this.invertY,this).map(n.invert,n))},toString:function(){return"translate("+this.x+","+this.y+") scale("+this.k+")"}};var Gc=new Pi(1,0,0);Wc.prototype=Pi.prototype;function Wc(n){for(;!n.__zoom;)if(!(n=n.parentNode))return Gc;return n.__zoom}var bm=1e4,Sm=.001,Em=Oe(".2~e"),q_=Oe(".4~r"),wm=Oe(",~");function Mm(n){if(n===0)return"0";let t=Math.abs(n);return t>=bm||t<Sm?Em(n):q_(n)}var Xc={formatTick:Mm,formatShort:Mm,formatReadable(n){let t=Math.abs(n);return t>=bm||t<Sm?Em(n):wm(n)},formatLong:wm},sk=new Intl.NumberFormat(void 0,{maximumFractionDigits:4});var ok=Oe("0.3~s"),ak=Oe(",.3~f");var X_=1e3,Y_=60*X_,Z_=60*Y_,J_=24*Z_,lk=365*J_,ck=Oe(".4~");var $_=Fs().tickFormat(),qc,Tm={formatTick(n){return $_(new Date(n))},formatShort(n){return new Date(n).toLocaleString(qc,{year:"numeric",month:"short",day:"numeric",hour:"numeric",minute:"numeric",second:"numeric"})},formatReadable(n){return new Date(n).toLocaleString(qc,{year:"numeric",month:"short",day:"numeric",hour:"numeric",minute:"numeric",second:"numeric",timeZoneName:"short"})},formatLong(n){return new Date(n).toLocaleString(qc,{year:"numeric",month:"long",day:"numeric",hour:"numeric",minute:"numeric",second:"numeric",timeZoneName:"short",fractionalSecondDigits:3})}};function fr(n){switch(n){case on.LINEAR:return new Yc;case on.LOG10:return new Zc;case on.TIME:return new Jc;default:let t=n;throw new RangeError(`ScaleType ${t} not supported.`)}}var K_=.05,Yc=class{constructor(){this.defaultFormatter=Xc}transform(t,e,i){let[r,s]=t,o=s-r,[a,l]=e,c=l-a;return o===0?a:c/o*(i-r)+a}forward(t,e,i){return this.transform(t,e,i)}reverse(t,e,i){return this.transform(e,t,i)}niceDomain(t){let[e,i]=t;if(i<e)throw new Error("Unexpected input: min is larger than max");if(i===e)return e===0?[-1,1]:e<0?[2*e,0]:[0,2*e];let r=ir(),s=(i-e+Number.EPSILON)*K_,[o,a]=r.domain([e-s,i+s]).nice().domain();return[o,a]}ticks(t,e){return ir().domain(t).ticks(e)}isSafeNumber(t){return Number.isFinite(t)}},Zc=class{constructor(){this.defaultFormatter=Xc}transform(t){return Math.log10(t>0?t:Number.MIN_VALUE)}untransform(t){return Math.exp(t/Math.LOG10E)}forward(t,e,i){if(i<=0)return e[0];let[r,s]=t,[o,a]=e,l=this.transform(r),u=this.transform(s)-l,h=a-o;return i=this.transform(i),h/(u+Number.EPSILON)*(i-l)+o}reverse(t,e,i){let[r,s]=t,[o,a]=e,l=this.transform(r),u=this.transform(s)-l,h=a-o,f=u/(h+Number.EPSILON)*(i-o)+l;return this.untransform(f)}niceDomain(t){let[e,i]=t;if(e>i)throw new Error("Unexpected input: min is larger than max");let r=Math.max(e,Number.MIN_VALUE),s=Math.max(i,Number.MIN_VALUE);return i<=0?[Number.MIN_VALUE,1]:[Math.max(Number.MIN_VALUE,r*.5),s*2]}ticks(t,e){let i=t[0]<=0?Number.MIN_VALUE:t[0],r=t[1]<=0?Number.MIN_VALUE:t[1],s=Ts().domain([i,r]).ticks(e);return s.length?s:t}isSafeNumber(t){return Number.isFinite(t)&&t>0}},Jc=class{constructor(){this.scale=Fs(),this.defaultFormatter=Tm}forward(t,e,i){return this.scale.domain(t).range(e)(i)}reverse(t,e,i){return this.scale.domain(t).range(e).invert(i).getTime()}niceDomain(t){let[e,i]=this.scale.domain(t).nice().domain();return[e.getTime(),i.getTime()]}ticks(t,e){return this.scale.domain(t).ticks(e).map(i=>i.getTime())}isSafeNumber(t){return Number.isFinite(t)}};function Q_(n){return{x:[n.x,n.x+n.width],y:[n.y,n.y+n.height]}}var $c=!1;if(self.hasOwnProperty("WebGL2RenderingContext")&&self.hasOwnProperty("document")){let n=document.createElement("canvas");n.addEventListener("webglcontextcreationerror",()=>{$c=!1});let t=n.getContext("webgl2");$c=Boolean(t)}function j_(){return $c}function tw(){if(!self.hasOwnProperty("OffscreenCanvas"))return!1;let n=new OffscreenCanvas(0,0).getContext("webgl2");return Boolean(n)}function ew(n,t){if(n.length!==t.length)return!1;for(let e=0;e<n.length;e++)if(n[e]!==t[e])return!1;return!0}function nw(n,t){return n.x[0]===t.x[0]&&n.x[1]===t.x[1]&&n.y[0]===t.y[0]&&n.y[1]===t.y[1]}var Di={convertRectToExtent:Q_,isWebGl2Supported:j_,isWebGl2OffscreenCanvasSupported:tw,arePolylinesEqual:ew,areExtentsEqual:nw};var dr=class{constructor(){this.xScale=fr(on.LINEAR),this.yScale=fr(on.LINEAR),this.domContainerRect={x:0,width:1,y:0,height:1},this.lastUpdated=0,this.currentViewBoxRect={x:0,width:1,y:0,height:1}}getUpdateIdentifier(){return this.lastUpdated}updateIdentifier(){this.lastUpdated++}isYAxisPointedDown(){return!0}setXScale(t){this.xScale=t,this.updateIdentifier()}setYScale(t){this.yScale=t,this.updateIdentifier()}getCurrentViewBoxRect(){return this.currentViewBoxRect}setViewBoxRect(t){this.currentViewBoxRect=t,this.updateIdentifier()}setDomContainerRect(t){this.domContainerRect=t,this.updateIdentifier()}transformDataToUiCoord(t,e){let i=t,r=Di.convertRectToExtent(this.currentViewBoxRect);return[this.xScale.forward(r.x,[i.x,i.x+i.width],e[0]),this.yScale.forward(r.y,this.isYAxisPointedDown()?[i.y+i.height,i.y]:[i.y,i.y+i.height],e[1])]}};var Tn;(function(n){n[n.SVG=0]="SVG",n[n.WEBGL=1]="WEBGL"})(Tn||(Tn={}));function ya(n,t,e,i){let{color:r,visible:s,opacity:o}=i,a=n;return!a&&!s?null:(a=a!=null?a:t(),a=e(a),a.style.display=s?"":"none",a.style.stroke=r,a.style.opacity=String(o!=null?o:1),a)}var Os=class{constructor(t){this.svg=t}flush(){}onResize(t){}destroyObject(t){this.svg.removeChild(t.dom)}setUseDarkMode(t){}createPathDString(t){if(!t.length)return"";let e=new Array(t.length/2);e[0]=`M${t[0]},${t[1]}`;for(let i=1;i<t.length/2;i++)e[i]=`L${t[i*2]},${t[i*2+1]}`;return e.join("")}createOrUpdateLineObject(t,e,i){let r=ya(t==null?void 0:t.dom,()=>{let s=document.createElementNS("http://www.w3.org/2000/svg","path");s.style.fill="none";let o=this.createPathDString(e);return s.setAttribute("d",o),this.svg.appendChild(s),s},s=>{if(!(t!=null&&t.data)||!Di.arePolylinesEqual(e,t==null?void 0:t.data)){let o=this.createPathDString(e);s.setAttribute("d",o)}return s},i);return r===null?null:(r.style.strokeWidth=String(i.width),{dom:r,data:e})}createOrUpdateTriangleObject(t,e,i){let{size:r,color:s}=i,o=r*Math.sqrt(3)/2,a=new Float32Array([e.x-r/2,e.y+o/3,e.x+r/2,e.y+o/3,e.x,e.y-o*2/3]),l=ya(t==null?void 0:t.dom,()=>{let c=document.createElementNS("http://www.w3.org/2000/svg","path");c.classList.add("triangle"),c.style.fill="none";let u=this.createPathDString(a);return c.setAttribute("d",u+"Z"),this.svg.appendChild(c),c},c=>{let u=this.createPathDString(a);return c.setAttribute("d",u+"Z"),c},i);return l===null?null:(l.style.fill=s,{dom:l,data:a})}createOrUpdateCircleObject(t,e,i){let{color:r,radius:s}=i,o=ya(t==null?void 0:t.dom,()=>{let a=document.createElementNS("http://www.w3.org/2000/svg","circle");return a.style.fill=r,a.setAttribute("cx",String(e.x)),a.setAttribute("cy",String(e.y)),a.setAttribute("r",String(s)),this.svg.appendChild(a),a},a=>(a.style.fill=r,a.setAttribute("cx",String(e.x)),a.setAttribute("cy",String(e.y)),a.setAttribute("r",String(s)),a),i);return o===null?null:{dom:o,data:e}}createOrUpdateTrapezoidObject(t,e,i,r){if(e.y!==i.y)throw new RangeError("Input error: start.y != end.y.");let{altitude:s,color:o}=r,a=2/Math.sqrt(3)*s,l=new Float32Array([e.x-a/2,e.y+s/2,e.x,e.y-s/2,i.x,i.y-s/2,i.x+a/2,i.y+s/2]),c=ya(t==null?void 0:t.dom,()=>{let u=document.createElementNS("http://www.w3.org/2000/svg","path");u.classList.add("trapezoid"),u.style.fill="none";let h=this.createPathDString(l);return u.setAttribute("d",h+"Z"),this.svg.appendChild(u),u},u=>{let h=this.createPathDString(l);return u.setAttribute("d",h+"Z"),u},r);return c===null?null:(c.style.fill=o,{dom:c,data:l})}dispose(){}};var $h="137";var iw=0,Am=1,rw=2;var l0=1,sw=2,Js=3,eo=0,he=1,Hr=2,c0=1;var jn=0,Ks=1,Cm=2,Rm=3,Lm=4,ow=5,Ir=100,aw=101,lw=102,Pm=103,Dm=104,cw=200,uw=201,hw=202,fw=203,u0=204,h0=205,dw=206,pw=207,mw=208,gw=209,xw=210,yw=0,vw=1,_w=2,zu=3,ww=4,Mw=5,bw=6,Sw=7,Cl=0,Ew=1,Tw=2,ti=0,Aw=1,Cw=2,Rw=3,Lw=4,Pw=5,f0=300,Ao=301,Co=302,Uu=303,Bu=304,Rl=306,Kh=307,Ou=1e3,Ve=1001,ku=1002,fe=1003,Im=1004;var Nm=1005;var be=1006,Dw=1007;var Ll=1008;var ei=1009,Iw=1010,Nw=1011,no=1012,Fw=1013,Qa=1014,Ui=1015,Ur=1016,zw=1017,Uw=1018,Br=1020,Bw=1021,Re=1023,Ow=1024,kw=1025,Oi=1026,Vr=1027,Hw=1028,Vw=1029,Gw=1030,Ww=1031,qw=1033,Kc=33776,Qc=33777,jc=33778,tu=33779,Fm=35840,zm=35841,Um=35842,Bm=35843,Xw=36196,Om=37492,km=37496,Hm=37808,Vm=37809,Gm=37810,Wm=37811,qm=37812,Xm=37813,Ym=37814,Zm=37815,Jm=37816,$m=37817,Km=37818,Qm=37819,jm=37820,tg=37821,eg=36492,Yw=2200,Zw=2201,Jw=2202,ja=2300,tl=2301,eu=2302,Nr=2400,Fr=2401,el=2402,Qh=2500,d0=2501,$w=0;var ri=3e3,$t=3001,Kw=3200,Qw=3201,ts=0,jw=1;var nu=7680;var tM=519,io=35044,nl=35048;var ng="300 es",Hu=1035,In=class{addEventListener(t,e){this._listeners===void 0&&(this._listeners={});let i=this._listeners;i[t]===void 0&&(i[t]=[]),i[t].indexOf(e)===-1&&i[t].push(e)}hasEventListener(t,e){if(this._listeners===void 0)return!1;let i=this._listeners;return i[t]!==void 0&&i[t].indexOf(e)!==-1}removeEventListener(t,e){if(this._listeners===void 0)return;let r=this._listeners[t];if(r!==void 0){let s=r.indexOf(e);s!==-1&&r.splice(s,1)}}dispatchEvent(t){if(this._listeners===void 0)return;let i=this._listeners[t.type];if(i!==void 0){t.target=this;let r=i.slice(0);for(let s=0,o=r.length;s<o;s++)r[s].call(this,t);t.target=null}}},ve=[];for(let n=0;n<256;n++)ve[n]=(n<16?"0":"")+n.toString(16);var iu=Math.PI/180,Vu=180/Math.PI;function tn(){let n=Math.random()*4294967295|0,t=Math.random()*4294967295|0,e=Math.random()*4294967295|0,i=Math.random()*4294967295|0;return(ve[n&255]+ve[n>>8&255]+ve[n>>16&255]+ve[n>>24&255]+"-"+ve[t&255]+ve[t>>8&255]+"-"+ve[t>>16&15|64]+ve[t>>24&255]+"-"+ve[e&63|128]+ve[e>>8&255]+"-"+ve[e>>16&255]+ve[e>>24&255]+ve[i&255]+ve[i>>8&255]+ve[i>>16&255]+ve[i>>24&255]).toUpperCase()}function Ie(n,t,e){return Math.max(t,Math.min(e,n))}function eM(n,t){return(n%t+t)%t}function ru(n,t,e){return(1-e)*n+e*t}function ig(n){return(n&n-1)===0&&n!==0}function nM(n){return Math.pow(2,Math.floor(Math.log(n)/Math.LN2))}var K=class{constructor(t=0,e=0){this.x=t,this.y=e}get width(){return this.x}set width(t){this.x=t}get height(){return this.y}set height(t){this.y=t}set(t,e){return this.x=t,this.y=e,this}setScalar(t){return this.x=t,this.y=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setComponent(t,e){switch(t){case 0:this.x=e;break;case 1:this.y=e;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y)}copy(t){return this.x=t.x,this.y=t.y,this}add(t,e){return e!==void 0?(console.warn("THREE.Vector2: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(t,e)):(this.x+=t.x,this.y+=t.y,this)}addScalar(t){return this.x+=t,this.y+=t,this}addVectors(t,e){return this.x=t.x+e.x,this.y=t.y+e.y,this}addScaledVector(t,e){return this.x+=t.x*e,this.y+=t.y*e,this}sub(t,e){return e!==void 0?(console.warn("THREE.Vector2: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),this.subVectors(t,e)):(this.x-=t.x,this.y-=t.y,this)}subScalar(t){return this.x-=t,this.y-=t,this}subVectors(t,e){return this.x=t.x-e.x,this.y=t.y-e.y,this}multiply(t){return this.x*=t.x,this.y*=t.y,this}multiplyScalar(t){return this.x*=t,this.y*=t,this}divide(t){return this.x/=t.x,this.y/=t.y,this}divideScalar(t){return this.multiplyScalar(1/t)}applyMatrix3(t){let e=this.x,i=this.y,r=t.elements;return this.x=r[0]*e+r[3]*i+r[6],this.y=r[1]*e+r[4]*i+r[7],this}min(t){return this.x=Math.min(this.x,t.x),this.y=Math.min(this.y,t.y),this}max(t){return this.x=Math.max(this.x,t.x),this.y=Math.max(this.y,t.y),this}clamp(t,e){return this.x=Math.max(t.x,Math.min(e.x,this.x)),this.y=Math.max(t.y,Math.min(e.y,this.y)),this}clampScalar(t,e){return this.x=Math.max(t,Math.min(e,this.x)),this.y=Math.max(t,Math.min(e,this.y)),this}clampLength(t,e){let i=this.length();return this.divideScalar(i||1).multiplyScalar(Math.max(t,Math.min(e,i)))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this}roundToZero(){return this.x=this.x<0?Math.ceil(this.x):Math.floor(this.x),this.y=this.y<0?Math.ceil(this.y):Math.floor(this.y),this}negate(){return this.x=-this.x,this.y=-this.y,this}dot(t){return this.x*t.x+this.y*t.y}cross(t){return this.x*t.y-this.y*t.x}lengthSq(){return this.x*this.x+this.y*this.y}length(){return Math.sqrt(this.x*this.x+this.y*this.y)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)}normalize(){return this.divideScalar(this.length()||1)}angle(){return Math.atan2(-this.y,-this.x)+Math.PI}distanceTo(t){return Math.sqrt(this.distanceToSquared(t))}distanceToSquared(t){let e=this.x-t.x,i=this.y-t.y;return e*e+i*i}manhattanDistanceTo(t){return Math.abs(this.x-t.x)+Math.abs(this.y-t.y)}setLength(t){return this.normalize().multiplyScalar(t)}lerp(t,e){return this.x+=(t.x-this.x)*e,this.y+=(t.y-this.y)*e,this}lerpVectors(t,e,i){return this.x=t.x+(e.x-t.x)*i,this.y=t.y+(e.y-t.y)*i,this}equals(t){return t.x===this.x&&t.y===this.y}fromArray(t,e=0){return this.x=t[e],this.y=t[e+1],this}toArray(t=[],e=0){return t[e]=this.x,t[e+1]=this.y,t}fromBufferAttribute(t,e,i){return i!==void 0&&console.warn("THREE.Vector2: offset has been removed from .fromBufferAttribute()."),this.x=t.getX(e),this.y=t.getY(e),this}rotateAround(t,e){let i=Math.cos(e),r=Math.sin(e),s=this.x-t.x,o=this.y-t.y;return this.x=s*i-o*r+t.x,this.y=s*r+o*i+t.y,this}random(){return this.x=Math.random(),this.y=Math.random(),this}*[Symbol.iterator](){yield this.x,yield this.y}};K.prototype.isVector2=!0;var de=class{constructor(){this.elements=[1,0,0,0,1,0,0,0,1],arguments.length>0&&console.error("THREE.Matrix3: the constructor no longer reads arguments. use .set() instead.")}set(t,e,i,r,s,o,a,l,c){let u=this.elements;return u[0]=t,u[1]=r,u[2]=a,u[3]=e,u[4]=s,u[5]=l,u[6]=i,u[7]=o,u[8]=c,this}identity(){return this.set(1,0,0,0,1,0,0,0,1),this}copy(t){let e=this.elements,i=t.elements;return e[0]=i[0],e[1]=i[1],e[2]=i[2],e[3]=i[3],e[4]=i[4],e[5]=i[5],e[6]=i[6],e[7]=i[7],e[8]=i[8],this}extractBasis(t,e,i){return t.setFromMatrix3Column(this,0),e.setFromMatrix3Column(this,1),i.setFromMatrix3Column(this,2),this}setFromMatrix4(t){let e=t.elements;return this.set(e[0],e[4],e[8],e[1],e[5],e[9],e[2],e[6],e[10]),this}multiply(t){return this.multiplyMatrices(this,t)}premultiply(t){return this.multiplyMatrices(t,this)}multiplyMatrices(t,e){let i=t.elements,r=e.elements,s=this.elements,o=i[0],a=i[3],l=i[6],c=i[1],u=i[4],h=i[7],f=i[2],d=i[5],g=i[8],x=r[0],v=r[3],m=r[6],p=r[1],b=r[4],_=r[7],S=r[2],L=r[5],A=r[8];return s[0]=o*x+a*p+l*S,s[3]=o*v+a*b+l*L,s[6]=o*m+a*_+l*A,s[1]=c*x+u*p+h*S,s[4]=c*v+u*b+h*L,s[7]=c*m+u*_+h*A,s[2]=f*x+d*p+g*S,s[5]=f*v+d*b+g*L,s[8]=f*m+d*_+g*A,this}multiplyScalar(t){let e=this.elements;return e[0]*=t,e[3]*=t,e[6]*=t,e[1]*=t,e[4]*=t,e[7]*=t,e[2]*=t,e[5]*=t,e[8]*=t,this}determinant(){let t=this.elements,e=t[0],i=t[1],r=t[2],s=t[3],o=t[4],a=t[5],l=t[6],c=t[7],u=t[8];return e*o*u-e*a*c-i*s*u+i*a*l+r*s*c-r*o*l}invert(){let t=this.elements,e=t[0],i=t[1],r=t[2],s=t[3],o=t[4],a=t[5],l=t[6],c=t[7],u=t[8],h=u*o-a*c,f=a*l-u*s,d=c*s-o*l,g=e*h+i*f+r*d;if(g===0)return this.set(0,0,0,0,0,0,0,0,0);let x=1/g;return t[0]=h*x,t[1]=(r*c-u*i)*x,t[2]=(a*i-r*o)*x,t[3]=f*x,t[4]=(u*e-r*l)*x,t[5]=(r*s-a*e)*x,t[6]=d*x,t[7]=(i*l-c*e)*x,t[8]=(o*e-i*s)*x,this}transpose(){let t,e=this.elements;return t=e[1],e[1]=e[3],e[3]=t,t=e[2],e[2]=e[6],e[6]=t,t=e[5],e[5]=e[7],e[7]=t,this}getNormalMatrix(t){return this.setFromMatrix4(t).invert().transpose()}transposeIntoArray(t){let e=this.elements;return t[0]=e[0],t[1]=e[3],t[2]=e[6],t[3]=e[1],t[4]=e[4],t[5]=e[7],t[6]=e[2],t[7]=e[5],t[8]=e[8],this}setUvTransform(t,e,i,r,s,o,a){let l=Math.cos(s),c=Math.sin(s);return this.set(i*l,i*c,-i*(l*o+c*a)+o+t,-r*c,r*l,-r*(-c*o+l*a)+a+e,0,0,1),this}scale(t,e){let i=this.elements;return i[0]*=t,i[3]*=t,i[6]*=t,i[1]*=e,i[4]*=e,i[7]*=e,this}rotate(t){let e=Math.cos(t),i=Math.sin(t),r=this.elements,s=r[0],o=r[3],a=r[6],l=r[1],c=r[4],u=r[7];return r[0]=e*s+i*l,r[3]=e*o+i*c,r[6]=e*a+i*u,r[1]=-i*s+e*l,r[4]=-i*o+e*c,r[7]=-i*a+e*u,this}translate(t,e){let i=this.elements;return i[0]+=t*i[2],i[3]+=t*i[5],i[6]+=t*i[8],i[1]+=e*i[2],i[4]+=e*i[5],i[7]+=e*i[8],this}equals(t){let e=this.elements,i=t.elements;for(let r=0;r<9;r++)if(e[r]!==i[r])return!1;return!0}fromArray(t,e=0){for(let i=0;i<9;i++)this.elements[i]=t[i+e];return this}toArray(t=[],e=0){let i=this.elements;return t[e]=i[0],t[e+1]=i[1],t[e+2]=i[2],t[e+3]=i[3],t[e+4]=i[4],t[e+5]=i[5],t[e+6]=i[6],t[e+7]=i[7],t[e+8]=i[8],t}clone(){return new this.constructor().fromArray(this.elements)}};de.prototype.isMatrix3=!0;function p0(n){for(let t=n.length-1;t>=0;--t)if(n[t]>65535)return!0;return!1}function ro(n){return document.createElementNS("http://www.w3.org/1999/xhtml",n)}var m0={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074},$e={h:0,s:0,l:0},va={h:0,s:0,l:0};function su(n,t,e){return e<0&&(e+=1),e>1&&(e-=1),e<1/6?n+(t-n)*6*e:e<1/2?t:e<2/3?n+(t-n)*6*(2/3-e):n}function Or(n){return n<.04045?n*.0773993808:Math.pow(n*.9478672986+.0521327014,2.4)}function ou(n){return n<.0031308?n*12.92:1.055*Math.pow(n,.41666)-.055}var ft=class{constructor(t,e,i){return e===void 0&&i===void 0?this.set(t):this.setRGB(t,e,i)}set(t){return t&&t.isColor?this.copy(t):typeof t=="number"?this.setHex(t):typeof t=="string"&&this.setStyle(t),this}setScalar(t){return this.r=t,this.g=t,this.b=t,this}setHex(t){return t=Math.floor(t),this.r=(t>>16&255)/255,this.g=(t>>8&255)/255,this.b=(t&255)/255,this}setRGB(t,e,i){return this.r=t,this.g=e,this.b=i,this}setHSL(t,e,i){if(t=eM(t,1),e=Ie(e,0,1),i=Ie(i,0,1),e===0)this.r=this.g=this.b=i;else{let r=i<=.5?i*(1+e):i+e-i*e,s=2*i-r;this.r=su(s,r,t+1/3),this.g=su(s,r,t),this.b=su(s,r,t-1/3)}return this}setStyle(t){function e(r){r!==void 0&&parseFloat(r)<1&&console.warn("THREE.Color: Alpha component of "+t+" will be ignored.")}let i;if(i=/^((?:rgb|hsl)a?)\(([^\)]*)\)/.exec(t)){let r,s=i[1],o=i[2];switch(s){case"rgb":case"rgba":if(r=/^\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(o))return this.r=Math.min(255,parseInt(r[1],10))/255,this.g=Math.min(255,parseInt(r[2],10))/255,this.b=Math.min(255,parseInt(r[3],10))/255,e(r[4]),this;if(r=/^\s*(\d+)\%\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(o))return this.r=Math.min(100,parseInt(r[1],10))/100,this.g=Math.min(100,parseInt(r[2],10))/100,this.b=Math.min(100,parseInt(r[3],10))/100,e(r[4]),this;break;case"hsl":case"hsla":if(r=/^\s*(\d*\.?\d+)\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(o)){let a=parseFloat(r[1])/360,l=parseInt(r[2],10)/100,c=parseInt(r[3],10)/100;return e(r[4]),this.setHSL(a,l,c)}break}}else if(i=/^\#([A-Fa-f\d]+)$/.exec(t)){let r=i[1],s=r.length;if(s===3)return this.r=parseInt(r.charAt(0)+r.charAt(0),16)/255,this.g=parseInt(r.charAt(1)+r.charAt(1),16)/255,this.b=parseInt(r.charAt(2)+r.charAt(2),16)/255,this;if(s===6)return this.r=parseInt(r.charAt(0)+r.charAt(1),16)/255,this.g=parseInt(r.charAt(2)+r.charAt(3),16)/255,this.b=parseInt(r.charAt(4)+r.charAt(5),16)/255,this}return t&&t.length>0?this.setColorName(t):this}setColorName(t){let e=m0[t.toLowerCase()];return e!==void 0?this.setHex(e):console.warn("THREE.Color: Unknown color "+t),this}clone(){return new this.constructor(this.r,this.g,this.b)}copy(t){return this.r=t.r,this.g=t.g,this.b=t.b,this}copySRGBToLinear(t){return this.r=Or(t.r),this.g=Or(t.g),this.b=Or(t.b),this}copyLinearToSRGB(t){return this.r=ou(t.r),this.g=ou(t.g),this.b=ou(t.b),this}convertSRGBToLinear(){return this.copySRGBToLinear(this),this}convertLinearToSRGB(){return this.copyLinearToSRGB(this),this}getHex(){return this.r*255<<16^this.g*255<<8^this.b*255<<0}getHexString(){return("000000"+this.getHex().toString(16)).slice(-6)}getHSL(t){let e=this.r,i=this.g,r=this.b,s=Math.max(e,i,r),o=Math.min(e,i,r),a,l,c=(o+s)/2;if(o===s)a=0,l=0;else{let u=s-o;switch(l=c<=.5?u/(s+o):u/(2-s-o),s){case e:a=(i-r)/u+(i<r?6:0);break;case i:a=(r-e)/u+2;break;case r:a=(e-i)/u+4;break}a/=6}return t.h=a,t.s=l,t.l=c,t}getStyle(){return"rgb("+(this.r*255|0)+","+(this.g*255|0)+","+(this.b*255|0)+")"}offsetHSL(t,e,i){return this.getHSL($e),$e.h+=t,$e.s+=e,$e.l+=i,this.setHSL($e.h,$e.s,$e.l),this}add(t){return this.r+=t.r,this.g+=t.g,this.b+=t.b,this}addColors(t,e){return this.r=t.r+e.r,this.g=t.g+e.g,this.b=t.b+e.b,this}addScalar(t){return this.r+=t,this.g+=t,this.b+=t,this}sub(t){return this.r=Math.max(0,this.r-t.r),this.g=Math.max(0,this.g-t.g),this.b=Math.max(0,this.b-t.b),this}multiply(t){return this.r*=t.r,this.g*=t.g,this.b*=t.b,this}multiplyScalar(t){return this.r*=t,this.g*=t,this.b*=t,this}lerp(t,e){return this.r+=(t.r-this.r)*e,this.g+=(t.g-this.g)*e,this.b+=(t.b-this.b)*e,this}lerpColors(t,e,i){return this.r=t.r+(e.r-t.r)*i,this.g=t.g+(e.g-t.g)*i,this.b=t.b+(e.b-t.b)*i,this}lerpHSL(t,e){this.getHSL($e),t.getHSL(va);let i=ru($e.h,va.h,e),r=ru($e.s,va.s,e),s=ru($e.l,va.l,e);return this.setHSL(i,r,s),this}equals(t){return t.r===this.r&&t.g===this.g&&t.b===this.b}fromArray(t,e=0){return this.r=t[e],this.g=t[e+1],this.b=t[e+2],this}toArray(t=[],e=0){return t[e]=this.r,t[e+1]=this.g,t[e+2]=this.b,t}fromBufferAttribute(t,e){return this.r=t.getX(e),this.g=t.getY(e),this.b=t.getZ(e),t.normalized===!0&&(this.r/=255,this.g/=255,this.b/=255),this}toJSON(){return this.getHex()}};ft.NAMES=m0;ft.prototype.isColor=!0;ft.prototype.r=1;ft.prototype.g=1;ft.prototype.b=1;var pr,Nn=class{static getDataURL(t){if(/^data:/i.test(t.src)||typeof HTMLCanvasElement=="undefined")return t.src;let e;if(t instanceof HTMLCanvasElement)e=t;else{pr===void 0&&(pr=ro("canvas")),pr.width=t.width,pr.height=t.height;let i=pr.getContext("2d");t instanceof ImageData?i.putImageData(t,0,0):i.drawImage(t,0,0,t.width,t.height),e=pr}return e.width>2048||e.height>2048?(console.warn("THREE.ImageUtils.getDataURL: Image converted to jpg for performance reasons",t),e.toDataURL("image/jpeg",.6)):e.toDataURL("image/png")}static sRGBToLinear(t){if(typeof HTMLImageElement!="undefined"&&t instanceof HTMLImageElement||typeof HTMLCanvasElement!="undefined"&&t instanceof HTMLCanvasElement||typeof ImageBitmap!="undefined"&&t instanceof ImageBitmap){let e=ro("canvas");e.width=t.width,e.height=t.height;let i=e.getContext("2d");i.drawImage(t,0,0,t.width,t.height);let r=i.getImageData(0,0,t.width,t.height),s=r.data;for(let o=0;o<s.length;o++)s[o]=Or(s[o]/255)*255;return i.putImageData(r,0,0),e}else if(t.data){let e=t.data.slice(0);for(let i=0;i<e.length;i++)e instanceof Uint8Array||e instanceof Uint8ClampedArray?e[i]=Math.floor(Or(e[i]/255)*255):e[i]=Or(e[i]);return{data:e,width:t.width,height:t.height}}else return console.warn("THREE.ImageUtils.sRGBToLinear(): Unsupported image type. No color space conversion applied."),t}},iM=0,ae=class extends In{constructor(t=ae.DEFAULT_IMAGE,e=ae.DEFAULT_MAPPING,i=Ve,r=Ve,s=be,o=Ll,a=Re,l=ei,c=1,u=ri){super(),Object.defineProperty(this,"id",{value:iM++}),this.uuid=tn(),this.name="",this.image=t,this.mipmaps=[],this.mapping=e,this.wrapS=i,this.wrapT=r,this.magFilter=s,this.minFilter=o,this.anisotropy=c,this.format=a,this.internalFormat=null,this.type=l,this.offset=new K(0,0),this.repeat=new K(1,1),this.center=new K(0,0),this.rotation=0,this.matrixAutoUpdate=!0,this.matrix=new de,this.generateMipmaps=!0,this.premultiplyAlpha=!1,this.flipY=!0,this.unpackAlignment=4,this.encoding=u,this.userData={},this.version=0,this.onUpdate=null,this.isRenderTargetTexture=!1,this.needsPMREMUpdate=!1}updateMatrix(){this.matrix.setUvTransform(this.offset.x,this.offset.y,this.repeat.x,this.repeat.y,this.rotation,this.center.x,this.center.y)}clone(){return new this.constructor().copy(this)}copy(t){return this.name=t.name,this.image=t.image,this.mipmaps=t.mipmaps.slice(0),this.mapping=t.mapping,this.wrapS=t.wrapS,this.wrapT=t.wrapT,this.magFilter=t.magFilter,this.minFilter=t.minFilter,this.anisotropy=t.anisotropy,this.format=t.format,this.internalFormat=t.internalFormat,this.type=t.type,this.offset.copy(t.offset),this.repeat.copy(t.repeat),this.center.copy(t.center),this.rotation=t.rotation,this.matrixAutoUpdate=t.matrixAutoUpdate,this.matrix.copy(t.matrix),this.generateMipmaps=t.generateMipmaps,this.premultiplyAlpha=t.premultiplyAlpha,this.flipY=t.flipY,this.unpackAlignment=t.unpackAlignment,this.encoding=t.encoding,this.userData=JSON.parse(JSON.stringify(t.userData)),this}toJSON(t){let e=t===void 0||typeof t=="string";if(!e&&t.textures[this.uuid]!==void 0)return t.textures[this.uuid];let i={metadata:{version:4.5,type:"Texture",generator:"Texture.toJSON"},uuid:this.uuid,name:this.name,mapping:this.mapping,repeat:[this.repeat.x,this.repeat.y],offset:[this.offset.x,this.offset.y],center:[this.center.x,this.center.y],rotation:this.rotation,wrap:[this.wrapS,this.wrapT],format:this.format,type:this.type,encoding:this.encoding,minFilter:this.minFilter,magFilter:this.magFilter,anisotropy:this.anisotropy,flipY:this.flipY,premultiplyAlpha:this.premultiplyAlpha,unpackAlignment:this.unpackAlignment};if(this.image!==void 0){let r=this.image;if(r.uuid===void 0&&(r.uuid=tn()),!e&&t.images[r.uuid]===void 0){let s;if(Array.isArray(r)){s=[];for(let o=0,a=r.length;o<a;o++)r[o].isDataTexture?s.push(au(r[o].image)):s.push(au(r[o]))}else s=au(r);t.images[r.uuid]={uuid:r.uuid,url:s}}i.image=r.uuid}return JSON.stringify(this.userData)!=="{}"&&(i.userData=this.userData),e||(t.textures[this.uuid]=i),i}dispose(){this.dispatchEvent({type:"dispose"})}transformUv(t){if(this.mapping!==f0)return t;if(t.applyMatrix3(this.matrix),t.x<0||t.x>1)switch(this.wrapS){case Ou:t.x=t.x-Math.floor(t.x);break;case Ve:t.x=t.x<0?0:1;break;case ku:Math.abs(Math.floor(t.x)%2)===1?t.x=Math.ceil(t.x)-t.x:t.x=t.x-Math.floor(t.x);break}if(t.y<0||t.y>1)switch(this.wrapT){case Ou:t.y=t.y-Math.floor(t.y);break;case Ve:t.y=t.y<0?0:1;break;case ku:Math.abs(Math.floor(t.y)%2)===1?t.y=Math.ceil(t.y)-t.y:t.y=t.y-Math.floor(t.y);break}return this.flipY&&(t.y=1-t.y),t}set needsUpdate(t){t===!0&&this.version++}};ae.DEFAULT_IMAGE=void 0;ae.DEFAULT_MAPPING=f0;ae.prototype.isTexture=!0;function au(n){return typeof HTMLImageElement!="undefined"&&n instanceof HTMLImageElement||typeof HTMLCanvasElement!="undefined"&&n instanceof HTMLCanvasElement||typeof ImageBitmap!="undefined"&&n instanceof ImageBitmap?Nn.getDataURL(n):n.data?{data:Array.prototype.slice.call(n.data),width:n.width,height:n.height,type:n.data.constructor.name}:(console.warn("THREE.Texture: Unable to serialize Texture."),{})}var Wt=class{constructor(t=0,e=0,i=0,r=1){this.x=t,this.y=e,this.z=i,this.w=r}get width(){return this.z}set width(t){this.z=t}get height(){return this.w}set height(t){this.w=t}set(t,e,i,r){return this.x=t,this.y=e,this.z=i,this.w=r,this}setScalar(t){return this.x=t,this.y=t,this.z=t,this.w=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setZ(t){return this.z=t,this}setW(t){return this.w=t,this}setComponent(t,e){switch(t){case 0:this.x=e;break;case 1:this.y=e;break;case 2:this.z=e;break;case 3:this.w=e;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;case 2:return this.z;case 3:return this.w;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y,this.z,this.w)}copy(t){return this.x=t.x,this.y=t.y,this.z=t.z,this.w=t.w!==void 0?t.w:1,this}add(t,e){return e!==void 0?(console.warn("THREE.Vector4: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(t,e)):(this.x+=t.x,this.y+=t.y,this.z+=t.z,this.w+=t.w,this)}addScalar(t){return this.x+=t,this.y+=t,this.z+=t,this.w+=t,this}addVectors(t,e){return this.x=t.x+e.x,this.y=t.y+e.y,this.z=t.z+e.z,this.w=t.w+e.w,this}addScaledVector(t,e){return this.x+=t.x*e,this.y+=t.y*e,this.z+=t.z*e,this.w+=t.w*e,this}sub(t,e){return e!==void 0?(console.warn("THREE.Vector4: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),this.subVectors(t,e)):(this.x-=t.x,this.y-=t.y,this.z-=t.z,this.w-=t.w,this)}subScalar(t){return this.x-=t,this.y-=t,this.z-=t,this.w-=t,this}subVectors(t,e){return this.x=t.x-e.x,this.y=t.y-e.y,this.z=t.z-e.z,this.w=t.w-e.w,this}multiply(t){return this.x*=t.x,this.y*=t.y,this.z*=t.z,this.w*=t.w,this}multiplyScalar(t){return this.x*=t,this.y*=t,this.z*=t,this.w*=t,this}applyMatrix4(t){let e=this.x,i=this.y,r=this.z,s=this.w,o=t.elements;return this.x=o[0]*e+o[4]*i+o[8]*r+o[12]*s,this.y=o[1]*e+o[5]*i+o[9]*r+o[13]*s,this.z=o[2]*e+o[6]*i+o[10]*r+o[14]*s,this.w=o[3]*e+o[7]*i+o[11]*r+o[15]*s,this}divideScalar(t){return this.multiplyScalar(1/t)}setAxisAngleFromQuaternion(t){this.w=2*Math.acos(t.w);let e=Math.sqrt(1-t.w*t.w);return e<1e-4?(this.x=1,this.y=0,this.z=0):(this.x=t.x/e,this.y=t.y/e,this.z=t.z/e),this}setAxisAngleFromRotationMatrix(t){let e,i,r,s,l=t.elements,c=l[0],u=l[4],h=l[8],f=l[1],d=l[5],g=l[9],x=l[2],v=l[6],m=l[10];if(Math.abs(u-f)<.01&&Math.abs(h-x)<.01&&Math.abs(g-v)<.01){if(Math.abs(u+f)<.1&&Math.abs(h+x)<.1&&Math.abs(g+v)<.1&&Math.abs(c+d+m-3)<.1)return this.set(1,0,0,0),this;e=Math.PI;let b=(c+1)/2,_=(d+1)/2,S=(m+1)/2,L=(u+f)/4,A=(h+x)/4,H=(g+v)/4;return b>_&&b>S?b<.01?(i=0,r=.707106781,s=.707106781):(i=Math.sqrt(b),r=L/i,s=A/i):_>S?_<.01?(i=.707106781,r=0,s=.707106781):(r=Math.sqrt(_),i=L/r,s=H/r):S<.01?(i=.707106781,r=.707106781,s=0):(s=Math.sqrt(S),i=A/s,r=H/s),this.set(i,r,s,e),this}let p=Math.sqrt((v-g)*(v-g)+(h-x)*(h-x)+(f-u)*(f-u));return Math.abs(p)<.001&&(p=1),this.x=(v-g)/p,this.y=(h-x)/p,this.z=(f-u)/p,this.w=Math.acos((c+d+m-1)/2),this}min(t){return this.x=Math.min(this.x,t.x),this.y=Math.min(this.y,t.y),this.z=Math.min(this.z,t.z),this.w=Math.min(this.w,t.w),this}max(t){return this.x=Math.max(this.x,t.x),this.y=Math.max(this.y,t.y),this.z=Math.max(this.z,t.z),this.w=Math.max(this.w,t.w),this}clamp(t,e){return this.x=Math.max(t.x,Math.min(e.x,this.x)),this.y=Math.max(t.y,Math.min(e.y,this.y)),this.z=Math.max(t.z,Math.min(e.z,this.z)),this.w=Math.max(t.w,Math.min(e.w,this.w)),this}clampScalar(t,e){return this.x=Math.max(t,Math.min(e,this.x)),this.y=Math.max(t,Math.min(e,this.y)),this.z=Math.max(t,Math.min(e,this.z)),this.w=Math.max(t,Math.min(e,this.w)),this}clampLength(t,e){let i=this.length();return this.divideScalar(i||1).multiplyScalar(Math.max(t,Math.min(e,i)))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this.z=Math.floor(this.z),this.w=Math.floor(this.w),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this.z=Math.ceil(this.z),this.w=Math.ceil(this.w),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this.z=Math.round(this.z),this.w=Math.round(this.w),this}roundToZero(){return this.x=this.x<0?Math.ceil(this.x):Math.floor(this.x),this.y=this.y<0?Math.ceil(this.y):Math.floor(this.y),this.z=this.z<0?Math.ceil(this.z):Math.floor(this.z),this.w=this.w<0?Math.ceil(this.w):Math.floor(this.w),this}negate(){return this.x=-this.x,this.y=-this.y,this.z=-this.z,this.w=-this.w,this}dot(t){return this.x*t.x+this.y*t.y+this.z*t.z+this.w*t.w}lengthSq(){return this.x*this.x+this.y*this.y+this.z*this.z+this.w*this.w}length(){return Math.sqrt(this.x*this.x+this.y*this.y+this.z*this.z+this.w*this.w)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)+Math.abs(this.z)+Math.abs(this.w)}normalize(){return this.divideScalar(this.length()||1)}setLength(t){return this.normalize().multiplyScalar(t)}lerp(t,e){return this.x+=(t.x-this.x)*e,this.y+=(t.y-this.y)*e,this.z+=(t.z-this.z)*e,this.w+=(t.w-this.w)*e,this}lerpVectors(t,e,i){return this.x=t.x+(e.x-t.x)*i,this.y=t.y+(e.y-t.y)*i,this.z=t.z+(e.z-t.z)*i,this.w=t.w+(e.w-t.w)*i,this}equals(t){return t.x===this.x&&t.y===this.y&&t.z===this.z&&t.w===this.w}fromArray(t,e=0){return this.x=t[e],this.y=t[e+1],this.z=t[e+2],this.w=t[e+3],this}toArray(t=[],e=0){return t[e]=this.x,t[e+1]=this.y,t[e+2]=this.z,t[e+3]=this.w,t}fromBufferAttribute(t,e,i){return i!==void 0&&console.warn("THREE.Vector4: offset has been removed from .fromBufferAttribute()."),this.x=t.getX(e),this.y=t.getY(e),this.z=t.getZ(e),this.w=t.getW(e),this}random(){return this.x=Math.random(),this.y=Math.random(),this.z=Math.random(),this.w=Math.random(),this}*[Symbol.iterator](){yield this.x,yield this.y,yield this.z,yield this.w}};Wt.prototype.isVector4=!0;var Ne=class extends In{constructor(t,e,i={}){super(),this.width=t,this.height=e,this.depth=1,this.scissor=new Wt(0,0,t,e),this.scissorTest=!1,this.viewport=new Wt(0,0,t,e),this.texture=new ae(void 0,i.mapping,i.wrapS,i.wrapT,i.magFilter,i.minFilter,i.format,i.type,i.anisotropy,i.encoding),this.texture.isRenderTargetTexture=!0,this.texture.image={width:t,height:e,depth:1},this.texture.generateMipmaps=i.generateMipmaps!==void 0?i.generateMipmaps:!1,this.texture.internalFormat=i.internalFormat!==void 0?i.internalFormat:null,this.texture.minFilter=i.minFilter!==void 0?i.minFilter:be,this.depthBuffer=i.depthBuffer!==void 0?i.depthBuffer:!0,this.stencilBuffer=i.stencilBuffer!==void 0?i.stencilBuffer:!1,this.depthTexture=i.depthTexture!==void 0?i.depthTexture:null}setTexture(t){t.image={width:this.width,height:this.height,depth:this.depth},this.texture=t}setSize(t,e,i=1){(this.width!==t||this.height!==e||this.depth!==i)&&(this.width=t,this.height=e,this.depth=i,this.texture.image.width=t,this.texture.image.height=e,this.texture.image.depth=i,this.dispose()),this.viewport.set(0,0,t,e),this.scissor.set(0,0,t,e)}clone(){return new this.constructor().copy(this)}copy(t){return this.width=t.width,this.height=t.height,this.depth=t.depth,this.viewport.copy(t.viewport),this.texture=t.texture.clone(),this.texture.image=Object.assign({},t.texture.image),this.depthBuffer=t.depthBuffer,this.stencilBuffer=t.stencilBuffer,this.depthTexture=t.depthTexture,this}dispose(){this.dispatchEvent({type:"dispose"})}};Ne.prototype.isWebGLRenderTarget=!0;var Gu=class extends Ne{constructor(t,e,i){super(t,e);let r=this.texture;this.texture=[];for(let s=0;s<i;s++)this.texture[s]=r.clone()}setSize(t,e,i=1){if(this.width!==t||this.height!==e||this.depth!==i){this.width=t,this.height=e,this.depth=i;for(let r=0,s=this.texture.length;r<s;r++)this.texture[r].image.width=t,this.texture[r].image.height=e,this.texture[r].image.depth=i;this.dispose()}return this.viewport.set(0,0,t,e),this.scissor.set(0,0,t,e),this}copy(t){this.dispose(),this.width=t.width,this.height=t.height,this.depth=t.depth,this.viewport.set(0,0,this.width,this.height),this.scissor.set(0,0,this.width,this.height),this.depthBuffer=t.depthBuffer,this.stencilBuffer=t.stencilBuffer,this.depthTexture=t.depthTexture,this.texture.length=0;for(let e=0,i=t.texture.length;e<i;e++)this.texture[e]=t.texture[e].clone();return this}};Gu.prototype.isWebGLMultipleRenderTargets=!0;var so=class extends Ne{constructor(t,e,i={}){super(t,e,i),this.samples=4,this.ignoreDepthForMultisampleCopy=i.ignoreDepth!==void 0?i.ignoreDepth:!0,this.useRenderToTexture=i.useRenderToTexture!==void 0?i.useRenderToTexture:!1,this.useRenderbuffer=this.useRenderToTexture===!1}copy(t){return super.copy.call(this,t),this.samples=t.samples,this.useRenderToTexture=t.useRenderToTexture,this.useRenderbuffer=t.useRenderbuffer,this}};so.prototype.isWebGLMultisampleRenderTarget=!0;var Ee=class{constructor(t=0,e=0,i=0,r=1){this._x=t,this._y=e,this._z=i,this._w=r}static slerp(t,e,i,r){return console.warn("THREE.Quaternion: Static .slerp() has been deprecated. Use qm.slerpQuaternions( qa, qb, t ) instead."),i.slerpQuaternions(t,e,r)}static slerpFlat(t,e,i,r,s,o,a){let l=i[r+0],c=i[r+1],u=i[r+2],h=i[r+3],f=s[o+0],d=s[o+1],g=s[o+2],x=s[o+3];if(a===0){t[e+0]=l,t[e+1]=c,t[e+2]=u,t[e+3]=h;return}if(a===1){t[e+0]=f,t[e+1]=d,t[e+2]=g,t[e+3]=x;return}if(h!==x||l!==f||c!==d||u!==g){let v=1-a,m=l*f+c*d+u*g+h*x,p=m>=0?1:-1,b=1-m*m;if(b>Number.EPSILON){let S=Math.sqrt(b),L=Math.atan2(S,m*p);v=Math.sin(v*L)/S,a=Math.sin(a*L)/S}let _=a*p;if(l=l*v+f*_,c=c*v+d*_,u=u*v+g*_,h=h*v+x*_,v===1-a){let S=1/Math.sqrt(l*l+c*c+u*u+h*h);l*=S,c*=S,u*=S,h*=S}}t[e]=l,t[e+1]=c,t[e+2]=u,t[e+3]=h}static multiplyQuaternionsFlat(t,e,i,r,s,o){let a=i[r],l=i[r+1],c=i[r+2],u=i[r+3],h=s[o],f=s[o+1],d=s[o+2],g=s[o+3];return t[e]=a*g+u*h+l*d-c*f,t[e+1]=l*g+u*f+c*h-a*d,t[e+2]=c*g+u*d+a*f-l*h,t[e+3]=u*g-a*h-l*f-c*d,t}get x(){return this._x}set x(t){this._x=t,this._onChangeCallback()}get y(){return this._y}set y(t){this._y=t,this._onChangeCallback()}get z(){return this._z}set z(t){this._z=t,this._onChangeCallback()}get w(){return this._w}set w(t){this._w=t,this._onChangeCallback()}set(t,e,i,r){return this._x=t,this._y=e,this._z=i,this._w=r,this._onChangeCallback(),this}clone(){return new this.constructor(this._x,this._y,this._z,this._w)}copy(t){return this._x=t.x,this._y=t.y,this._z=t.z,this._w=t.w,this._onChangeCallback(),this}setFromEuler(t,e){if(!(t&&t.isEuler))throw new Error("THREE.Quaternion: .setFromEuler() now expects an Euler rotation rather than a Vector3 and order.");let i=t._x,r=t._y,s=t._z,o=t._order,a=Math.cos,l=Math.sin,c=a(i/2),u=a(r/2),h=a(s/2),f=l(i/2),d=l(r/2),g=l(s/2);switch(o){case"XYZ":this._x=f*u*h+c*d*g,this._y=c*d*h-f*u*g,this._z=c*u*g+f*d*h,this._w=c*u*h-f*d*g;break;case"YXZ":this._x=f*u*h+c*d*g,this._y=c*d*h-f*u*g,this._z=c*u*g-f*d*h,this._w=c*u*h+f*d*g;break;case"ZXY":this._x=f*u*h-c*d*g,this._y=c*d*h+f*u*g,this._z=c*u*g+f*d*h,this._w=c*u*h-f*d*g;break;case"ZYX":this._x=f*u*h-c*d*g,this._y=c*d*h+f*u*g,this._z=c*u*g-f*d*h,this._w=c*u*h+f*d*g;break;case"YZX":this._x=f*u*h+c*d*g,this._y=c*d*h+f*u*g,this._z=c*u*g-f*d*h,this._w=c*u*h-f*d*g;break;case"XZY":this._x=f*u*h-c*d*g,this._y=c*d*h-f*u*g,this._z=c*u*g+f*d*h,this._w=c*u*h+f*d*g;break;default:console.warn("THREE.Quaternion: .setFromEuler() encountered an unknown order: "+o)}return e!==!1&&this._onChangeCallback(),this}setFromAxisAngle(t,e){let i=e/2,r=Math.sin(i);return this._x=t.x*r,this._y=t.y*r,this._z=t.z*r,this._w=Math.cos(i),this._onChangeCallback(),this}setFromRotationMatrix(t){let e=t.elements,i=e[0],r=e[4],s=e[8],o=e[1],a=e[5],l=e[9],c=e[2],u=e[6],h=e[10],f=i+a+h;if(f>0){let d=.5/Math.sqrt(f+1);this._w=.25/d,this._x=(u-l)*d,this._y=(s-c)*d,this._z=(o-r)*d}else if(i>a&&i>h){let d=2*Math.sqrt(1+i-a-h);this._w=(u-l)/d,this._x=.25*d,this._y=(r+o)/d,this._z=(s+c)/d}else if(a>h){let d=2*Math.sqrt(1+a-i-h);this._w=(s-c)/d,this._x=(r+o)/d,this._y=.25*d,this._z=(l+u)/d}else{let d=2*Math.sqrt(1+h-i-a);this._w=(o-r)/d,this._x=(s+c)/d,this._y=(l+u)/d,this._z=.25*d}return this._onChangeCallback(),this}setFromUnitVectors(t,e){let i=t.dot(e)+1;return i<Number.EPSILON?(i=0,Math.abs(t.x)>Math.abs(t.z)?(this._x=-t.y,this._y=t.x,this._z=0,this._w=i):(this._x=0,this._y=-t.z,this._z=t.y,this._w=i)):(this._x=t.y*e.z-t.z*e.y,this._y=t.z*e.x-t.x*e.z,this._z=t.x*e.y-t.y*e.x,this._w=i),this.normalize()}angleTo(t){return 2*Math.acos(Math.abs(Ie(this.dot(t),-1,1)))}rotateTowards(t,e){let i=this.angleTo(t);if(i===0)return this;let r=Math.min(1,e/i);return this.slerp(t,r),this}identity(){return this.set(0,0,0,1)}invert(){return this.conjugate()}conjugate(){return this._x*=-1,this._y*=-1,this._z*=-1,this._onChangeCallback(),this}dot(t){return this._x*t._x+this._y*t._y+this._z*t._z+this._w*t._w}lengthSq(){return this._x*this._x+this._y*this._y+this._z*this._z+this._w*this._w}length(){return Math.sqrt(this._x*this._x+this._y*this._y+this._z*this._z+this._w*this._w)}normalize(){let t=this.length();return t===0?(this._x=0,this._y=0,this._z=0,this._w=1):(t=1/t,this._x=this._x*t,this._y=this._y*t,this._z=this._z*t,this._w=this._w*t),this._onChangeCallback(),this}multiply(t,e){return e!==void 0?(console.warn("THREE.Quaternion: .multiply() now only accepts one argument. Use .multiplyQuaternions( a, b ) instead."),this.multiplyQuaternions(t,e)):this.multiplyQuaternions(this,t)}premultiply(t){return this.multiplyQuaternions(t,this)}multiplyQuaternions(t,e){let i=t._x,r=t._y,s=t._z,o=t._w,a=e._x,l=e._y,c=e._z,u=e._w;return this._x=i*u+o*a+r*c-s*l,this._y=r*u+o*l+s*a-i*c,this._z=s*u+o*c+i*l-r*a,this._w=o*u-i*a-r*l-s*c,this._onChangeCallback(),this}slerp(t,e){if(e===0)return this;if(e===1)return this.copy(t);let i=this._x,r=this._y,s=this._z,o=this._w,a=o*t._w+i*t._x+r*t._y+s*t._z;if(a<0?(this._w=-t._w,this._x=-t._x,this._y=-t._y,this._z=-t._z,a=-a):this.copy(t),a>=1)return this._w=o,this._x=i,this._y=r,this._z=s,this;let l=1-a*a;if(l<=Number.EPSILON){let d=1-e;return this._w=d*o+e*this._w,this._x=d*i+e*this._x,this._y=d*r+e*this._y,this._z=d*s+e*this._z,this.normalize(),this._onChangeCallback(),this}let c=Math.sqrt(l),u=Math.atan2(c,a),h=Math.sin((1-e)*u)/c,f=Math.sin(e*u)/c;return this._w=o*h+this._w*f,this._x=i*h+this._x*f,this._y=r*h+this._y*f,this._z=s*h+this._z*f,this._onChangeCallback(),this}slerpQuaternions(t,e,i){return this.copy(t).slerp(e,i)}random(){let t=Math.random(),e=Math.sqrt(1-t),i=Math.sqrt(t),r=2*Math.PI*Math.random(),s=2*Math.PI*Math.random();return this.set(e*Math.cos(r),i*Math.sin(s),i*Math.cos(s),e*Math.sin(r))}equals(t){return t._x===this._x&&t._y===this._y&&t._z===this._z&&t._w===this._w}fromArray(t,e=0){return this._x=t[e],this._y=t[e+1],this._z=t[e+2],this._w=t[e+3],this._onChangeCallback(),this}toArray(t=[],e=0){return t[e]=this._x,t[e+1]=this._y,t[e+2]=this._z,t[e+3]=this._w,t}fromBufferAttribute(t,e){return this._x=t.getX(e),this._y=t.getY(e),this._z=t.getZ(e),this._w=t.getW(e),this}_onChange(t){return this._onChangeCallback=t,this}_onChangeCallback(){}};Ee.prototype.isQuaternion=!0;var T=class{constructor(t=0,e=0,i=0){this.x=t,this.y=e,this.z=i}set(t,e,i){return i===void 0&&(i=this.z),this.x=t,this.y=e,this.z=i,this}setScalar(t){return this.x=t,this.y=t,this.z=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setZ(t){return this.z=t,this}setComponent(t,e){switch(t){case 0:this.x=e;break;case 1:this.y=e;break;case 2:this.z=e;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;case 2:return this.z;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y,this.z)}copy(t){return this.x=t.x,this.y=t.y,this.z=t.z,this}add(t,e){return e!==void 0?(console.warn("THREE.Vector3: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(t,e)):(this.x+=t.x,this.y+=t.y,this.z+=t.z,this)}addScalar(t){return this.x+=t,this.y+=t,this.z+=t,this}addVectors(t,e){return this.x=t.x+e.x,this.y=t.y+e.y,this.z=t.z+e.z,this}addScaledVector(t,e){return this.x+=t.x*e,this.y+=t.y*e,this.z+=t.z*e,this}sub(t,e){return e!==void 0?(console.warn("THREE.Vector3: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),this.subVectors(t,e)):(this.x-=t.x,this.y-=t.y,this.z-=t.z,this)}subScalar(t){return this.x-=t,this.y-=t,this.z-=t,this}subVectors(t,e){return this.x=t.x-e.x,this.y=t.y-e.y,this.z=t.z-e.z,this}multiply(t,e){return e!==void 0?(console.warn("THREE.Vector3: .multiply() now only accepts one argument. Use .multiplyVectors( a, b ) instead."),this.multiplyVectors(t,e)):(this.x*=t.x,this.y*=t.y,this.z*=t.z,this)}multiplyScalar(t){return this.x*=t,this.y*=t,this.z*=t,this}multiplyVectors(t,e){return this.x=t.x*e.x,this.y=t.y*e.y,this.z=t.z*e.z,this}applyEuler(t){return t&&t.isEuler||console.error("THREE.Vector3: .applyEuler() now expects an Euler rotation rather than a Vector3 and order."),this.applyQuaternion(rg.setFromEuler(t))}applyAxisAngle(t,e){return this.applyQuaternion(rg.setFromAxisAngle(t,e))}applyMatrix3(t){let e=this.x,i=this.y,r=this.z,s=t.elements;return this.x=s[0]*e+s[3]*i+s[6]*r,this.y=s[1]*e+s[4]*i+s[7]*r,this.z=s[2]*e+s[5]*i+s[8]*r,this}applyNormalMatrix(t){return this.applyMatrix3(t).normalize()}applyMatrix4(t){let e=this.x,i=this.y,r=this.z,s=t.elements,o=1/(s[3]*e+s[7]*i+s[11]*r+s[15]);return this.x=(s[0]*e+s[4]*i+s[8]*r+s[12])*o,this.y=(s[1]*e+s[5]*i+s[9]*r+s[13])*o,this.z=(s[2]*e+s[6]*i+s[10]*r+s[14])*o,this}applyQuaternion(t){let e=this.x,i=this.y,r=this.z,s=t.x,o=t.y,a=t.z,l=t.w,c=l*e+o*r-a*i,u=l*i+a*e-s*r,h=l*r+s*i-o*e,f=-s*e-o*i-a*r;return this.x=c*l+f*-s+u*-a-h*-o,this.y=u*l+f*-o+h*-s-c*-a,this.z=h*l+f*-a+c*-o-u*-s,this}project(t){return this.applyMatrix4(t.matrixWorldInverse).applyMatrix4(t.projectionMatrix)}unproject(t){return this.applyMatrix4(t.projectionMatrixInverse).applyMatrix4(t.matrixWorld)}transformDirection(t){let e=this.x,i=this.y,r=this.z,s=t.elements;return this.x=s[0]*e+s[4]*i+s[8]*r,this.y=s[1]*e+s[5]*i+s[9]*r,this.z=s[2]*e+s[6]*i+s[10]*r,this.normalize()}divide(t){return this.x/=t.x,this.y/=t.y,this.z/=t.z,this}divideScalar(t){return this.multiplyScalar(1/t)}min(t){return this.x=Math.min(this.x,t.x),this.y=Math.min(this.y,t.y),this.z=Math.min(this.z,t.z),this}max(t){return this.x=Math.max(this.x,t.x),this.y=Math.max(this.y,t.y),this.z=Math.max(this.z,t.z),this}clamp(t,e){return this.x=Math.max(t.x,Math.min(e.x,this.x)),this.y=Math.max(t.y,Math.min(e.y,this.y)),this.z=Math.max(t.z,Math.min(e.z,this.z)),this}clampScalar(t,e){return this.x=Math.max(t,Math.min(e,this.x)),this.y=Math.max(t,Math.min(e,this.y)),this.z=Math.max(t,Math.min(e,this.z)),this}clampLength(t,e){let i=this.length();return this.divideScalar(i||1).multiplyScalar(Math.max(t,Math.min(e,i)))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this.z=Math.floor(this.z),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this.z=Math.ceil(this.z),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this.z=Math.round(this.z),this}roundToZero(){return this.x=this.x<0?Math.ceil(this.x):Math.floor(this.x),this.y=this.y<0?Math.ceil(this.y):Math.floor(this.y),this.z=this.z<0?Math.ceil(this.z):Math.floor(this.z),this}negate(){return this.x=-this.x,this.y=-this.y,this.z=-this.z,this}dot(t){return this.x*t.x+this.y*t.y+this.z*t.z}lengthSq(){return this.x*this.x+this.y*this.y+this.z*this.z}length(){return Math.sqrt(this.x*this.x+this.y*this.y+this.z*this.z)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)+Math.abs(this.z)}normalize(){return this.divideScalar(this.length()||1)}setLength(t){return this.normalize().multiplyScalar(t)}lerp(t,e){return this.x+=(t.x-this.x)*e,this.y+=(t.y-this.y)*e,this.z+=(t.z-this.z)*e,this}lerpVectors(t,e,i){return this.x=t.x+(e.x-t.x)*i,this.y=t.y+(e.y-t.y)*i,this.z=t.z+(e.z-t.z)*i,this}cross(t,e){return e!==void 0?(console.warn("THREE.Vector3: .cross() now only accepts one argument. Use .crossVectors( a, b ) instead."),this.crossVectors(t,e)):this.crossVectors(this,t)}crossVectors(t,e){let i=t.x,r=t.y,s=t.z,o=e.x,a=e.y,l=e.z;return this.x=r*l-s*a,this.y=s*o-i*l,this.z=i*a-r*o,this}projectOnVector(t){let e=t.lengthSq();if(e===0)return this.set(0,0,0);let i=t.dot(this)/e;return this.copy(t).multiplyScalar(i)}projectOnPlane(t){return lu.copy(this).projectOnVector(t),this.sub(lu)}reflect(t){return this.sub(lu.copy(t).multiplyScalar(2*this.dot(t)))}angleTo(t){let e=Math.sqrt(this.lengthSq()*t.lengthSq());if(e===0)return Math.PI/2;let i=this.dot(t)/e;return Math.acos(Ie(i,-1,1))}distanceTo(t){return Math.sqrt(this.distanceToSquared(t))}distanceToSquared(t){let e=this.x-t.x,i=this.y-t.y,r=this.z-t.z;return e*e+i*i+r*r}manhattanDistanceTo(t){return Math.abs(this.x-t.x)+Math.abs(this.y-t.y)+Math.abs(this.z-t.z)}setFromSpherical(t){return this.setFromSphericalCoords(t.radius,t.phi,t.theta)}setFromSphericalCoords(t,e,i){let r=Math.sin(e)*t;return this.x=r*Math.sin(i),this.y=Math.cos(e)*t,this.z=r*Math.cos(i),this}setFromCylindrical(t){return this.setFromCylindricalCoords(t.radius,t.theta,t.y)}setFromCylindricalCoords(t,e,i){return this.x=t*Math.sin(e),this.y=i,this.z=t*Math.cos(e),this}setFromMatrixPosition(t){let e=t.elements;return this.x=e[12],this.y=e[13],this.z=e[14],this}setFromMatrixScale(t){let e=this.setFromMatrixColumn(t,0).length(),i=this.setFromMatrixColumn(t,1).length(),r=this.setFromMatrixColumn(t,2).length();return this.x=e,this.y=i,this.z=r,this}setFromMatrixColumn(t,e){return this.fromArray(t.elements,e*4)}setFromMatrix3Column(t,e){return this.fromArray(t.elements,e*3)}equals(t){return t.x===this.x&&t.y===this.y&&t.z===this.z}fromArray(t,e=0){return this.x=t[e],this.y=t[e+1],this.z=t[e+2],this}toArray(t=[],e=0){return t[e]=this.x,t[e+1]=this.y,t[e+2]=this.z,t}fromBufferAttribute(t,e,i){return i!==void 0&&console.warn("THREE.Vector3: offset has been removed from .fromBufferAttribute()."),this.x=t.getX(e),this.y=t.getY(e),this.z=t.getZ(e),this}random(){return this.x=Math.random(),this.y=Math.random(),this.z=Math.random(),this}randomDirection(){let t=(Math.random()-.5)*2,e=Math.random()*Math.PI*2,i=Math.sqrt(1-cf(t,2));return this.x=i*Math.cos(e),this.y=i*Math.sin(e),this.z=t,this}*[Symbol.iterator](){yield this.x,yield this.y,yield this.z}};T.prototype.isVector3=!0;var lu=new T,rg=new Ee,Ge=class{constructor(t=new T(1/0,1/0,1/0),e=new T(-1/0,-1/0,-1/0)){this.min=t,this.max=e}set(t,e){return this.min.copy(t),this.max.copy(e),this}setFromArray(t){let e=1/0,i=1/0,r=1/0,s=-1/0,o=-1/0,a=-1/0;for(let l=0,c=t.length;l<c;l+=3){let u=t[l],h=t[l+1],f=t[l+2];u<e&&(e=u),h<i&&(i=h),f<r&&(r=f),u>s&&(s=u),h>o&&(o=h),f>a&&(a=f)}return this.min.set(e,i,r),this.max.set(s,o,a),this}setFromBufferAttribute(t){let e=1/0,i=1/0,r=1/0,s=-1/0,o=-1/0,a=-1/0;for(let l=0,c=t.count;l<c;l++){let u=t.getX(l),h=t.getY(l),f=t.getZ(l);u<e&&(e=u),h<i&&(i=h),f<r&&(r=f),u>s&&(s=u),h>o&&(o=h),f>a&&(a=f)}return this.min.set(e,i,r),this.max.set(s,o,a),this}setFromPoints(t){this.makeEmpty();for(let e=0,i=t.length;e<i;e++)this.expandByPoint(t[e]);return this}setFromCenterAndSize(t,e){let i=Ii.copy(e).multiplyScalar(.5);return this.min.copy(t).sub(i),this.max.copy(t).add(i),this}setFromObject(t,e=!1){return this.makeEmpty(),this.expandByObject(t,e)}clone(){return new this.constructor().copy(this)}copy(t){return this.min.copy(t.min),this.max.copy(t.max),this}makeEmpty(){return this.min.x=this.min.y=this.min.z=1/0,this.max.x=this.max.y=this.max.z=-1/0,this}isEmpty(){return this.max.x<this.min.x||this.max.y<this.min.y||this.max.z<this.min.z}getCenter(t){return this.isEmpty()?t.set(0,0,0):t.addVectors(this.min,this.max).multiplyScalar(.5)}getSize(t){return this.isEmpty()?t.set(0,0,0):t.subVectors(this.max,this.min)}expandByPoint(t){return this.min.min(t),this.max.max(t),this}expandByVector(t){return this.min.sub(t),this.max.add(t),this}expandByScalar(t){return this.min.addScalar(-t),this.max.addScalar(t),this}expandByObject(t,e=!1){t.updateWorldMatrix(!1,!1);let i=t.geometry;if(i!==void 0)if(e&&i.attributes!=null&&i.attributes.position!==void 0){let s=i.attributes.position;for(let o=0,a=s.count;o<a;o++)Ii.fromBufferAttribute(s,o).applyMatrix4(t.matrixWorld),this.expandByPoint(Ii)}else i.boundingBox===null&&i.computeBoundingBox(),cu.copy(i.boundingBox),cu.applyMatrix4(t.matrixWorld),this.union(cu);let r=t.children;for(let s=0,o=r.length;s<o;s++)this.expandByObject(r[s],e);return this}containsPoint(t){return!(t.x<this.min.x||t.x>this.max.x||t.y<this.min.y||t.y>this.max.y||t.z<this.min.z||t.z>this.max.z)}containsBox(t){return this.min.x<=t.min.x&&t.max.x<=this.max.x&&this.min.y<=t.min.y&&t.max.y<=this.max.y&&this.min.z<=t.min.z&&t.max.z<=this.max.z}getParameter(t,e){return e.set((t.x-this.min.x)/(this.max.x-this.min.x),(t.y-this.min.y)/(this.max.y-this.min.y),(t.z-this.min.z)/(this.max.z-this.min.z))}intersectsBox(t){return!(t.max.x<this.min.x||t.min.x>this.max.x||t.max.y<this.min.y||t.min.y>this.max.y||t.max.z<this.min.z||t.min.z>this.max.z)}intersectsSphere(t){return this.clampPoint(t.center,Ii),Ii.distanceToSquared(t.center)<=t.radius*t.radius}intersectsPlane(t){let e,i;return t.normal.x>0?(e=t.normal.x*this.min.x,i=t.normal.x*this.max.x):(e=t.normal.x*this.max.x,i=t.normal.x*this.min.x),t.normal.y>0?(e+=t.normal.y*this.min.y,i+=t.normal.y*this.max.y):(e+=t.normal.y*this.max.y,i+=t.normal.y*this.min.y),t.normal.z>0?(e+=t.normal.z*this.min.z,i+=t.normal.z*this.max.z):(e+=t.normal.z*this.max.z,i+=t.normal.z*this.min.z),e<=-t.constant&&i>=-t.constant}intersectsTriangle(t){if(this.isEmpty())return!1;this.getCenter(ks),_a.subVectors(this.max,ks),mr.subVectors(t.a,ks),gr.subVectors(t.b,ks),xr.subVectors(t.c,ks),qn.subVectors(gr,mr),Xn.subVectors(xr,gr),Ni.subVectors(mr,xr);let e=[0,-qn.z,qn.y,0,-Xn.z,Xn.y,0,-Ni.z,Ni.y,qn.z,0,-qn.x,Xn.z,0,-Xn.x,Ni.z,0,-Ni.x,-qn.y,qn.x,0,-Xn.y,Xn.x,0,-Ni.y,Ni.x,0];return!uu(e,mr,gr,xr,_a)||(e=[1,0,0,0,1,0,0,0,1],!uu(e,mr,gr,xr,_a))?!1:(wa.crossVectors(qn,Xn),e=[wa.x,wa.y,wa.z],uu(e,mr,gr,xr,_a))}clampPoint(t,e){return e.copy(t).clamp(this.min,this.max)}distanceToPoint(t){return Ii.copy(t).clamp(this.min,this.max).sub(t).length()}getBoundingSphere(t){return this.getCenter(t.center),t.radius=this.getSize(Ii).length()*.5,t}intersect(t){return this.min.max(t.min),this.max.min(t.max),this.isEmpty()&&this.makeEmpty(),this}union(t){return this.min.min(t.min),this.max.max(t.max),this}applyMatrix4(t){return this.isEmpty()?this:(An[0].set(this.min.x,this.min.y,this.min.z).applyMatrix4(t),An[1].set(this.min.x,this.min.y,this.max.z).applyMatrix4(t),An[2].set(this.min.x,this.max.y,this.min.z).applyMatrix4(t),An[3].set(this.min.x,this.max.y,this.max.z).applyMatrix4(t),An[4].set(this.max.x,this.min.y,this.min.z).applyMatrix4(t),An[5].set(this.max.x,this.min.y,this.max.z).applyMatrix4(t),An[6].set(this.max.x,this.max.y,this.min.z).applyMatrix4(t),An[7].set(this.max.x,this.max.y,this.max.z).applyMatrix4(t),this.setFromPoints(An),this)}translate(t){return this.min.add(t),this.max.add(t),this}equals(t){return t.min.equals(this.min)&&t.max.equals(this.max)}};Ge.prototype.isBox3=!0;var An=[new T,new T,new T,new T,new T,new T,new T,new T],Ii=new T,cu=new Ge,mr=new T,gr=new T,xr=new T,qn=new T,Xn=new T,Ni=new T,ks=new T,_a=new T,wa=new T,Fi=new T;function uu(n,t,e,i,r){for(let s=0,o=n.length-3;s<=o;s+=3){Fi.fromArray(n,s);let a=r.x*Math.abs(Fi.x)+r.y*Math.abs(Fi.y)+r.z*Math.abs(Fi.z),l=t.dot(Fi),c=e.dot(Fi),u=i.dot(Fi);if(Math.max(-Math.max(l,c,u),Math.min(l,c,u))>a)return!1}return!0}var rM=new Ge,sg=new T,Ma=new T,hu=new T,si=class{constructor(t=new T,e=-1){this.center=t,this.radius=e}set(t,e){return this.center.copy(t),this.radius=e,this}setFromPoints(t,e){let i=this.center;e!==void 0?i.copy(e):rM.setFromPoints(t).getCenter(i);let r=0;for(let s=0,o=t.length;s<o;s++)r=Math.max(r,i.distanceToSquared(t[s]));return this.radius=Math.sqrt(r),this}copy(t){return this.center.copy(t.center),this.radius=t.radius,this}isEmpty(){return this.radius<0}makeEmpty(){return this.center.set(0,0,0),this.radius=-1,this}containsPoint(t){return t.distanceToSquared(this.center)<=this.radius*this.radius}distanceToPoint(t){return t.distanceTo(this.center)-this.radius}intersectsSphere(t){let e=this.radius+t.radius;return t.center.distanceToSquared(this.center)<=e*e}intersectsBox(t){return t.intersectsSphere(this)}intersectsPlane(t){return Math.abs(t.distanceToPoint(this.center))<=this.radius}clampPoint(t,e){let i=this.center.distanceToSquared(t);return e.copy(t),i>this.radius*this.radius&&(e.sub(this.center).normalize(),e.multiplyScalar(this.radius).add(this.center)),e}getBoundingBox(t){return this.isEmpty()?(t.makeEmpty(),t):(t.set(this.center,this.center),t.expandByScalar(this.radius),t)}applyMatrix4(t){return this.center.applyMatrix4(t),this.radius=this.radius*t.getMaxScaleOnAxis(),this}translate(t){return this.center.add(t),this}expandByPoint(t){hu.subVectors(t,this.center);let e=hu.lengthSq();if(e>this.radius*this.radius){let i=Math.sqrt(e),r=(i-this.radius)*.5;this.center.add(hu.multiplyScalar(r/i)),this.radius+=r}return this}union(t){return this.center.equals(t.center)===!0?Ma.set(0,0,1).multiplyScalar(t.radius):Ma.subVectors(t.center,this.center).normalize().multiplyScalar(t.radius),this.expandByPoint(sg.copy(t.center).add(Ma)),this.expandByPoint(sg.copy(t.center).sub(Ma)),this}equals(t){return t.center.equals(this.center)&&t.radius===this.radius}clone(){return new this.constructor().copy(this)}},Cn=new T,fu=new T,ba=new T,Yn=new T,du=new T,Sa=new T,pu=new T,oi=class{constructor(t=new T,e=new T(0,0,-1)){this.origin=t,this.direction=e}set(t,e){return this.origin.copy(t),this.direction.copy(e),this}copy(t){return this.origin.copy(t.origin),this.direction.copy(t.direction),this}at(t,e){return e.copy(this.direction).multiplyScalar(t).add(this.origin)}lookAt(t){return this.direction.copy(t).sub(this.origin).normalize(),this}recast(t){return this.origin.copy(this.at(t,Cn)),this}closestPointToPoint(t,e){e.subVectors(t,this.origin);let i=e.dot(this.direction);return i<0?e.copy(this.origin):e.copy(this.direction).multiplyScalar(i).add(this.origin)}distanceToPoint(t){return Math.sqrt(this.distanceSqToPoint(t))}distanceSqToPoint(t){let e=Cn.subVectors(t,this.origin).dot(this.direction);return e<0?this.origin.distanceToSquared(t):(Cn.copy(this.direction).multiplyScalar(e).add(this.origin),Cn.distanceToSquared(t))}distanceSqToSegment(t,e,i,r){fu.copy(t).add(e).multiplyScalar(.5),ba.copy(e).sub(t).normalize(),Yn.copy(this.origin).sub(fu);let s=t.distanceTo(e)*.5,o=-this.direction.dot(ba),a=Yn.dot(this.direction),l=-Yn.dot(ba),c=Yn.lengthSq(),u=Math.abs(1-o*o),h,f,d,g;if(u>0)if(h=o*l-a,f=o*a-l,g=s*u,h>=0)if(f>=-g)if(f<=g){let x=1/u;h*=x,f*=x,d=h*(h+o*f+2*a)+f*(o*h+f+2*l)+c}else f=s,h=Math.max(0,-(o*f+a)),d=-h*h+f*(f+2*l)+c;else f=-s,h=Math.max(0,-(o*f+a)),d=-h*h+f*(f+2*l)+c;else f<=-g?(h=Math.max(0,-(-o*s+a)),f=h>0?-s:Math.min(Math.max(-s,-l),s),d=-h*h+f*(f+2*l)+c):f<=g?(h=0,f=Math.min(Math.max(-s,-l),s),d=f*(f+2*l)+c):(h=Math.max(0,-(o*s+a)),f=h>0?s:Math.min(Math.max(-s,-l),s),d=-h*h+f*(f+2*l)+c);else f=o>0?-s:s,h=Math.max(0,-(o*f+a)),d=-h*h+f*(f+2*l)+c;return i&&i.copy(this.direction).multiplyScalar(h).add(this.origin),r&&r.copy(ba).multiplyScalar(f).add(fu),d}intersectSphere(t,e){Cn.subVectors(t.center,this.origin);let i=Cn.dot(this.direction),r=Cn.dot(Cn)-i*i,s=t.radius*t.radius;if(r>s)return null;let o=Math.sqrt(s-r),a=i-o,l=i+o;return a<0&&l<0?null:a<0?this.at(l,e):this.at(a,e)}intersectsSphere(t){return this.distanceSqToPoint(t.center)<=t.radius*t.radius}distanceToPlane(t){let e=t.normal.dot(this.direction);if(e===0)return t.distanceToPoint(this.origin)===0?0:null;let i=-(this.origin.dot(t.normal)+t.constant)/e;return i>=0?i:null}intersectPlane(t,e){let i=this.distanceToPlane(t);return i===null?null:this.at(i,e)}intersectsPlane(t){let e=t.distanceToPoint(this.origin);return e===0||t.normal.dot(this.direction)*e<0}intersectBox(t,e){let i,r,s,o,a,l,c=1/this.direction.x,u=1/this.direction.y,h=1/this.direction.z,f=this.origin;return c>=0?(i=(t.min.x-f.x)*c,r=(t.max.x-f.x)*c):(i=(t.max.x-f.x)*c,r=(t.min.x-f.x)*c),u>=0?(s=(t.min.y-f.y)*u,o=(t.max.y-f.y)*u):(s=(t.max.y-f.y)*u,o=(t.min.y-f.y)*u),i>o||s>r||((s>i||i!==i)&&(i=s),(o<r||r!==r)&&(r=o),h>=0?(a=(t.min.z-f.z)*h,l=(t.max.z-f.z)*h):(a=(t.max.z-f.z)*h,l=(t.min.z-f.z)*h),i>l||a>r)||((a>i||i!==i)&&(i=a),(l<r||r!==r)&&(r=l),r<0)?null:this.at(i>=0?i:r,e)}intersectsBox(t){return this.intersectBox(t,Cn)!==null}intersectTriangle(t,e,i,r,s){du.subVectors(e,t),Sa.subVectors(i,t),pu.crossVectors(du,Sa);let o=this.direction.dot(pu),a;if(o>0){if(r)return null;a=1}else if(o<0)a=-1,o=-o;else return null;Yn.subVectors(this.origin,t);let l=a*this.direction.dot(Sa.crossVectors(Yn,Sa));if(l<0)return null;let c=a*this.direction.dot(du.cross(Yn));if(c<0||l+c>o)return null;let u=-a*Yn.dot(pu);return u<0?null:this.at(u/o,s)}applyMatrix4(t){return this.origin.applyMatrix4(t),this.direction.transformDirection(t),this}equals(t){return t.origin.equals(this.origin)&&t.direction.equals(this.direction)}clone(){return new this.constructor().copy(this)}},wt=class{constructor(){this.elements=[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1],arguments.length>0&&console.error("THREE.Matrix4: the constructor no longer reads arguments. use .set() instead.")}set(t,e,i,r,s,o,a,l,c,u,h,f,d,g,x,v){let m=this.elements;return m[0]=t,m[4]=e,m[8]=i,m[12]=r,m[1]=s,m[5]=o,m[9]=a,m[13]=l,m[2]=c,m[6]=u,m[10]=h,m[14]=f,m[3]=d,m[7]=g,m[11]=x,m[15]=v,this}identity(){return this.set(1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1),this}clone(){return new wt().fromArray(this.elements)}copy(t){let e=this.elements,i=t.elements;return e[0]=i[0],e[1]=i[1],e[2]=i[2],e[3]=i[3],e[4]=i[4],e[5]=i[5],e[6]=i[6],e[7]=i[7],e[8]=i[8],e[9]=i[9],e[10]=i[10],e[11]=i[11],e[12]=i[12],e[13]=i[13],e[14]=i[14],e[15]=i[15],this}copyPosition(t){let e=this.elements,i=t.elements;return e[12]=i[12],e[13]=i[13],e[14]=i[14],this}setFromMatrix3(t){let e=t.elements;return this.set(e[0],e[3],e[6],0,e[1],e[4],e[7],0,e[2],e[5],e[8],0,0,0,0,1),this}extractBasis(t,e,i){return t.setFromMatrixColumn(this,0),e.setFromMatrixColumn(this,1),i.setFromMatrixColumn(this,2),this}makeBasis(t,e,i){return this.set(t.x,e.x,i.x,0,t.y,e.y,i.y,0,t.z,e.z,i.z,0,0,0,0,1),this}extractRotation(t){let e=this.elements,i=t.elements,r=1/yr.setFromMatrixColumn(t,0).length(),s=1/yr.setFromMatrixColumn(t,1).length(),o=1/yr.setFromMatrixColumn(t,2).length();return e[0]=i[0]*r,e[1]=i[1]*r,e[2]=i[2]*r,e[3]=0,e[4]=i[4]*s,e[5]=i[5]*s,e[6]=i[6]*s,e[7]=0,e[8]=i[8]*o,e[9]=i[9]*o,e[10]=i[10]*o,e[11]=0,e[12]=0,e[13]=0,e[14]=0,e[15]=1,this}makeRotationFromEuler(t){t&&t.isEuler||console.error("THREE.Matrix4: .makeRotationFromEuler() now expects a Euler rotation rather than a Vector3 and order.");let e=this.elements,i=t.x,r=t.y,s=t.z,o=Math.cos(i),a=Math.sin(i),l=Math.cos(r),c=Math.sin(r),u=Math.cos(s),h=Math.sin(s);if(t.order==="XYZ"){let f=o*u,d=o*h,g=a*u,x=a*h;e[0]=l*u,e[4]=-l*h,e[8]=c,e[1]=d+g*c,e[5]=f-x*c,e[9]=-a*l,e[2]=x-f*c,e[6]=g+d*c,e[10]=o*l}else if(t.order==="YXZ"){let f=l*u,d=l*h,g=c*u,x=c*h;e[0]=f+x*a,e[4]=g*a-d,e[8]=o*c,e[1]=o*h,e[5]=o*u,e[9]=-a,e[2]=d*a-g,e[6]=x+f*a,e[10]=o*l}else if(t.order==="ZXY"){let f=l*u,d=l*h,g=c*u,x=c*h;e[0]=f-x*a,e[4]=-o*h,e[8]=g+d*a,e[1]=d+g*a,e[5]=o*u,e[9]=x-f*a,e[2]=-o*c,e[6]=a,e[10]=o*l}else if(t.order==="ZYX"){let f=o*u,d=o*h,g=a*u,x=a*h;e[0]=l*u,e[4]=g*c-d,e[8]=f*c+x,e[1]=l*h,e[5]=x*c+f,e[9]=d*c-g,e[2]=-c,e[6]=a*l,e[10]=o*l}else if(t.order==="YZX"){let f=o*l,d=o*c,g=a*l,x=a*c;e[0]=l*u,e[4]=x-f*h,e[8]=g*h+d,e[1]=h,e[5]=o*u,e[9]=-a*u,e[2]=-c*u,e[6]=d*h+g,e[10]=f-x*h}else if(t.order==="XZY"){let f=o*l,d=o*c,g=a*l,x=a*c;e[0]=l*u,e[4]=-h,e[8]=c*u,e[1]=f*h+x,e[5]=o*u,e[9]=d*h-g,e[2]=g*h-d,e[6]=a*u,e[10]=x*h+f}return e[3]=0,e[7]=0,e[11]=0,e[12]=0,e[13]=0,e[14]=0,e[15]=1,this}makeRotationFromQuaternion(t){return this.compose(sM,t,oM)}lookAt(t,e,i){let r=this.elements;return ke.subVectors(t,e),ke.lengthSq()===0&&(ke.z=1),ke.normalize(),Zn.crossVectors(i,ke),Zn.lengthSq()===0&&(Math.abs(i.z)===1?ke.x+=1e-4:ke.z+=1e-4,ke.normalize(),Zn.crossVectors(i,ke)),Zn.normalize(),Ea.crossVectors(ke,Zn),r[0]=Zn.x,r[4]=Ea.x,r[8]=ke.x,r[1]=Zn.y,r[5]=Ea.y,r[9]=ke.y,r[2]=Zn.z,r[6]=Ea.z,r[10]=ke.z,this}multiply(t,e){return e!==void 0?(console.warn("THREE.Matrix4: .multiply() now only accepts one argument. Use .multiplyMatrices( a, b ) instead."),this.multiplyMatrices(t,e)):this.multiplyMatrices(this,t)}premultiply(t){return this.multiplyMatrices(t,this)}multiplyMatrices(t,e){let i=t.elements,r=e.elements,s=this.elements,o=i[0],a=i[4],l=i[8],c=i[12],u=i[1],h=i[5],f=i[9],d=i[13],g=i[2],x=i[6],v=i[10],m=i[14],p=i[3],b=i[7],_=i[11],S=i[15],L=r[0],A=r[4],H=r[8],tt=r[12],X=r[1],y=r[5],R=r[9],D=r[13],F=r[2],z=r[6],N=r[10],V=r[14],Q=r[3],at=r[7],G=r[11],$=r[15];return s[0]=o*L+a*X+l*F+c*Q,s[4]=o*A+a*y+l*z+c*at,s[8]=o*H+a*R+l*N+c*G,s[12]=o*tt+a*D+l*V+c*$,s[1]=u*L+h*X+f*F+d*Q,s[5]=u*A+h*y+f*z+d*at,s[9]=u*H+h*R+f*N+d*G,s[13]=u*tt+h*D+f*V+d*$,s[2]=g*L+x*X+v*F+m*Q,s[6]=g*A+x*y+v*z+m*at,s[10]=g*H+x*R+v*N+m*G,s[14]=g*tt+x*D+v*V+m*$,s[3]=p*L+b*X+_*F+S*Q,s[7]=p*A+b*y+_*z+S*at,s[11]=p*H+b*R+_*N+S*G,s[15]=p*tt+b*D+_*V+S*$,this}multiplyScalar(t){let e=this.elements;return e[0]*=t,e[4]*=t,e[8]*=t,e[12]*=t,e[1]*=t,e[5]*=t,e[9]*=t,e[13]*=t,e[2]*=t,e[6]*=t,e[10]*=t,e[14]*=t,e[3]*=t,e[7]*=t,e[11]*=t,e[15]*=t,this}determinant(){let t=this.elements,e=t[0],i=t[4],r=t[8],s=t[12],o=t[1],a=t[5],l=t[9],c=t[13],u=t[2],h=t[6],f=t[10],d=t[14],g=t[3],x=t[7],v=t[11],m=t[15];return g*(+s*l*h-r*c*h-s*a*f+i*c*f+r*a*d-i*l*d)+x*(+e*l*d-e*c*f+s*o*f-r*o*d+r*c*u-s*l*u)+v*(+e*c*h-e*a*d-s*o*h+i*o*d+s*a*u-i*c*u)+m*(-r*a*u-e*l*h+e*a*f+r*o*h-i*o*f+i*l*u)}transpose(){let t=this.elements,e;return e=t[1],t[1]=t[4],t[4]=e,e=t[2],t[2]=t[8],t[8]=e,e=t[6],t[6]=t[9],t[9]=e,e=t[3],t[3]=t[12],t[12]=e,e=t[7],t[7]=t[13],t[13]=e,e=t[11],t[11]=t[14],t[14]=e,this}setPosition(t,e,i){let r=this.elements;return t.isVector3?(r[12]=t.x,r[13]=t.y,r[14]=t.z):(r[12]=t,r[13]=e,r[14]=i),this}invert(){let t=this.elements,e=t[0],i=t[1],r=t[2],s=t[3],o=t[4],a=t[5],l=t[6],c=t[7],u=t[8],h=t[9],f=t[10],d=t[11],g=t[12],x=t[13],v=t[14],m=t[15],p=h*v*c-x*f*c+x*l*d-a*v*d-h*l*m+a*f*m,b=g*f*c-u*v*c-g*l*d+o*v*d+u*l*m-o*f*m,_=u*x*c-g*h*c+g*a*d-o*x*d-u*a*m+o*h*m,S=g*h*l-u*x*l-g*a*f+o*x*f+u*a*v-o*h*v,L=e*p+i*b+r*_+s*S;if(L===0)return this.set(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0);let A=1/L;return t[0]=p*A,t[1]=(x*f*s-h*v*s-x*r*d+i*v*d+h*r*m-i*f*m)*A,t[2]=(a*v*s-x*l*s+x*r*c-i*v*c-a*r*m+i*l*m)*A,t[3]=(h*l*s-a*f*s-h*r*c+i*f*c+a*r*d-i*l*d)*A,t[4]=b*A,t[5]=(u*v*s-g*f*s+g*r*d-e*v*d-u*r*m+e*f*m)*A,t[6]=(g*l*s-o*v*s-g*r*c+e*v*c+o*r*m-e*l*m)*A,t[7]=(o*f*s-u*l*s+u*r*c-e*f*c-o*r*d+e*l*d)*A,t[8]=_*A,t[9]=(g*h*s-u*x*s-g*i*d+e*x*d+u*i*m-e*h*m)*A,t[10]=(o*x*s-g*a*s+g*i*c-e*x*c-o*i*m+e*a*m)*A,t[11]=(u*a*s-o*h*s-u*i*c+e*h*c+o*i*d-e*a*d)*A,t[12]=S*A,t[13]=(u*x*r-g*h*r+g*i*f-e*x*f-u*i*v+e*h*v)*A,t[14]=(g*a*r-o*x*r-g*i*l+e*x*l+o*i*v-e*a*v)*A,t[15]=(o*h*r-u*a*r+u*i*l-e*h*l-o*i*f+e*a*f)*A,this}scale(t){let e=this.elements,i=t.x,r=t.y,s=t.z;return e[0]*=i,e[4]*=r,e[8]*=s,e[1]*=i,e[5]*=r,e[9]*=s,e[2]*=i,e[6]*=r,e[10]*=s,e[3]*=i,e[7]*=r,e[11]*=s,this}getMaxScaleOnAxis(){let t=this.elements,e=t[0]*t[0]+t[1]*t[1]+t[2]*t[2],i=t[4]*t[4]+t[5]*t[5]+t[6]*t[6],r=t[8]*t[8]+t[9]*t[9]+t[10]*t[10];return Math.sqrt(Math.max(e,i,r))}makeTranslation(t,e,i){return this.set(1,0,0,t,0,1,0,e,0,0,1,i,0,0,0,1),this}makeRotationX(t){let e=Math.cos(t),i=Math.sin(t);return this.set(1,0,0,0,0,e,-i,0,0,i,e,0,0,0,0,1),this}makeRotationY(t){let e=Math.cos(t),i=Math.sin(t);return this.set(e,0,i,0,0,1,0,0,-i,0,e,0,0,0,0,1),this}makeRotationZ(t){let e=Math.cos(t),i=Math.sin(t);return this.set(e,-i,0,0,i,e,0,0,0,0,1,0,0,0,0,1),this}makeRotationAxis(t,e){let i=Math.cos(e),r=Math.sin(e),s=1-i,o=t.x,a=t.y,l=t.z,c=s*o,u=s*a;return this.set(c*o+i,c*a-r*l,c*l+r*a,0,c*a+r*l,u*a+i,u*l-r*o,0,c*l-r*a,u*l+r*o,s*l*l+i,0,0,0,0,1),this}makeScale(t,e,i){return this.set(t,0,0,0,0,e,0,0,0,0,i,0,0,0,0,1),this}makeShear(t,e,i,r,s,o){return this.set(1,i,s,0,t,1,o,0,e,r,1,0,0,0,0,1),this}compose(t,e,i){let r=this.elements,s=e._x,o=e._y,a=e._z,l=e._w,c=s+s,u=o+o,h=a+a,f=s*c,d=s*u,g=s*h,x=o*u,v=o*h,m=a*h,p=l*c,b=l*u,_=l*h,S=i.x,L=i.y,A=i.z;return r[0]=(1-(x+m))*S,r[1]=(d+_)*S,r[2]=(g-b)*S,r[3]=0,r[4]=(d-_)*L,r[5]=(1-(f+m))*L,r[6]=(v+p)*L,r[7]=0,r[8]=(g+b)*A,r[9]=(v-p)*A,r[10]=(1-(f+x))*A,r[11]=0,r[12]=t.x,r[13]=t.y,r[14]=t.z,r[15]=1,this}decompose(t,e,i){let r=this.elements,s=yr.set(r[0],r[1],r[2]).length(),o=yr.set(r[4],r[5],r[6]).length(),a=yr.set(r[8],r[9],r[10]).length();this.determinant()<0&&(s=-s),t.x=r[12],t.y=r[13],t.z=r[14],Ke.copy(this);let c=1/s,u=1/o,h=1/a;return Ke.elements[0]*=c,Ke.elements[1]*=c,Ke.elements[2]*=c,Ke.elements[4]*=u,Ke.elements[5]*=u,Ke.elements[6]*=u,Ke.elements[8]*=h,Ke.elements[9]*=h,Ke.elements[10]*=h,e.setFromRotationMatrix(Ke),i.x=s,i.y=o,i.z=a,this}makePerspective(t,e,i,r,s,o){o===void 0&&console.warn("THREE.Matrix4: .makePerspective() has been redefined and has a new signature. Please check the docs.");let a=this.elements,l=2*s/(e-t),c=2*s/(i-r),u=(e+t)/(e-t),h=(i+r)/(i-r),f=-(o+s)/(o-s),d=-2*o*s/(o-s);return a[0]=l,a[4]=0,a[8]=u,a[12]=0,a[1]=0,a[5]=c,a[9]=h,a[13]=0,a[2]=0,a[6]=0,a[10]=f,a[14]=d,a[3]=0,a[7]=0,a[11]=-1,a[15]=0,this}makeOrthographic(t,e,i,r,s,o){let a=this.elements,l=1/(e-t),c=1/(i-r),u=1/(o-s),h=(e+t)*l,f=(i+r)*c,d=(o+s)*u;return a[0]=2*l,a[4]=0,a[8]=0,a[12]=-h,a[1]=0,a[5]=2*c,a[9]=0,a[13]=-f,a[2]=0,a[6]=0,a[10]=-2*u,a[14]=-d,a[3]=0,a[7]=0,a[11]=0,a[15]=1,this}equals(t){let e=this.elements,i=t.elements;for(let r=0;r<16;r++)if(e[r]!==i[r])return!1;return!0}fromArray(t,e=0){for(let i=0;i<16;i++)this.elements[i]=t[i+e];return this}toArray(t=[],e=0){let i=this.elements;return t[e]=i[0],t[e+1]=i[1],t[e+2]=i[2],t[e+3]=i[3],t[e+4]=i[4],t[e+5]=i[5],t[e+6]=i[6],t[e+7]=i[7],t[e+8]=i[8],t[e+9]=i[9],t[e+10]=i[10],t[e+11]=i[11],t[e+12]=i[12],t[e+13]=i[13],t[e+14]=i[14],t[e+15]=i[15],t}};wt.prototype.isMatrix4=!0;var yr=new T,Ke=new wt,sM=new T(0,0,0),oM=new T(1,1,1),Zn=new T,Ea=new T,ke=new T,og=new wt,ag=new Ee,ai=class{constructor(t=0,e=0,i=0,r=ai.DefaultOrder){this._x=t,this._y=e,this._z=i,this._order=r}get x(){return this._x}set x(t){this._x=t,this._onChangeCallback()}get y(){return this._y}set y(t){this._y=t,this._onChangeCallback()}get z(){return this._z}set z(t){this._z=t,this._onChangeCallback()}get order(){return this._order}set order(t){this._order=t,this._onChangeCallback()}set(t,e,i,r=this._order){return this._x=t,this._y=e,this._z=i,this._order=r,this._onChangeCallback(),this}clone(){return new this.constructor(this._x,this._y,this._z,this._order)}copy(t){return this._x=t._x,this._y=t._y,this._z=t._z,this._order=t._order,this._onChangeCallback(),this}setFromRotationMatrix(t,e=this._order,i=!0){let r=t.elements,s=r[0],o=r[4],a=r[8],l=r[1],c=r[5],u=r[9],h=r[2],f=r[6],d=r[10];switch(e){case"XYZ":this._y=Math.asin(Ie(a,-1,1)),Math.abs(a)<.9999999?(this._x=Math.atan2(-u,d),this._z=Math.atan2(-o,s)):(this._x=Math.atan2(f,c),this._z=0);break;case"YXZ":this._x=Math.asin(-Ie(u,-1,1)),Math.abs(u)<.9999999?(this._y=Math.atan2(a,d),this._z=Math.atan2(l,c)):(this._y=Math.atan2(-h,s),this._z=0);break;case"ZXY":this._x=Math.asin(Ie(f,-1,1)),Math.abs(f)<.9999999?(this._y=Math.atan2(-h,d),this._z=Math.atan2(-o,c)):(this._y=0,this._z=Math.atan2(l,s));break;case"ZYX":this._y=Math.asin(-Ie(h,-1,1)),Math.abs(h)<.9999999?(this._x=Math.atan2(f,d),this._z=Math.atan2(l,s)):(this._x=0,this._z=Math.atan2(-o,c));break;case"YZX":this._z=Math.asin(Ie(l,-1,1)),Math.abs(l)<.9999999?(this._x=Math.atan2(-u,c),this._y=Math.atan2(-h,s)):(this._x=0,this._y=Math.atan2(a,d));break;case"XZY":this._z=Math.asin(-Ie(o,-1,1)),Math.abs(o)<.9999999?(this._x=Math.atan2(f,c),this._y=Math.atan2(a,s)):(this._x=Math.atan2(-u,d),this._y=0);break;default:console.warn("THREE.Euler: .setFromRotationMatrix() encountered an unknown order: "+e)}return this._order=e,i===!0&&this._onChangeCallback(),this}setFromQuaternion(t,e,i){return og.makeRotationFromQuaternion(t),this.setFromRotationMatrix(og,e,i)}setFromVector3(t,e=this._order){return this.set(t.x,t.y,t.z,e)}reorder(t){return ag.setFromEuler(this),this.setFromQuaternion(ag,t)}equals(t){return t._x===this._x&&t._y===this._y&&t._z===this._z&&t._order===this._order}fromArray(t){return this._x=t[0],this._y=t[1],this._z=t[2],t[3]!==void 0&&(this._order=t[3]),this._onChangeCallback(),this}toArray(t=[],e=0){return t[e]=this._x,t[e+1]=this._y,t[e+2]=this._z,t[e+3]=this._order,t}toVector3(t){return t?t.set(this._x,this._y,this._z):new T(this._x,this._y,this._z)}_onChange(t){return this._onChangeCallback=t,this}_onChangeCallback(){}};ai.prototype.isEuler=!0;ai.DefaultOrder="XYZ";ai.RotationOrders=["XYZ","YZX","ZXY","XZY","YXZ","ZYX"];var il=class{constructor(){this.mask=1}set(t){this.mask=(1<<t|0)>>>0}enable(t){this.mask|=1<<t|0}enableAll(){this.mask=-1}toggle(t){this.mask^=1<<t|0}disable(t){this.mask&=~(1<<t|0)}disableAll(){this.mask=0}test(t){return(this.mask&t.mask)!==0}isEnabled(t){return(this.mask&(1<<t|0))!==0}},aM=0,lg=new T,vr=new Ee,Rn=new wt,Ta=new T,Hs=new T,lM=new T,cM=new Ee,cg=new T(1,0,0),ug=new T(0,1,0),hg=new T(0,0,1),uM={type:"added"},fg={type:"removed"},kt=class extends In{constructor(){super(),Object.defineProperty(this,"id",{value:aM++}),this.uuid=tn(),this.name="",this.type="Object3D",this.parent=null,this.children=[],this.up=kt.DefaultUp.clone();let t=new T,e=new ai,i=new Ee,r=new T(1,1,1);function s(){i.setFromEuler(e,!1)}function o(){e.setFromQuaternion(i,void 0,!1)}e._onChange(s),i._onChange(o),Object.defineProperties(this,{position:{configurable:!0,enumerable:!0,value:t},rotation:{configurable:!0,enumerable:!0,value:e},quaternion:{configurable:!0,enumerable:!0,value:i},scale:{configurable:!0,enumerable:!0,value:r},modelViewMatrix:{value:new wt},normalMatrix:{value:new de}}),this.matrix=new wt,this.matrixWorld=new wt,this.matrixAutoUpdate=kt.DefaultMatrixAutoUpdate,this.matrixWorldNeedsUpdate=!1,this.layers=new il,this.visible=!0,this.castShadow=!1,this.receiveShadow=!1,this.frustumCulled=!0,this.renderOrder=0,this.animations=[],this.userData={}}onBeforeRender(){}onAfterRender(){}applyMatrix4(t){this.matrixAutoUpdate&&this.updateMatrix(),this.matrix.premultiply(t),this.matrix.decompose(this.position,this.quaternion,this.scale)}applyQuaternion(t){return this.quaternion.premultiply(t),this}setRotationFromAxisAngle(t,e){this.quaternion.setFromAxisAngle(t,e)}setRotationFromEuler(t){this.quaternion.setFromEuler(t,!0)}setRotationFromMatrix(t){this.quaternion.setFromRotationMatrix(t)}setRotationFromQuaternion(t){this.quaternion.copy(t)}rotateOnAxis(t,e){return vr.setFromAxisAngle(t,e),this.quaternion.multiply(vr),this}rotateOnWorldAxis(t,e){return vr.setFromAxisAngle(t,e),this.quaternion.premultiply(vr),this}rotateX(t){return this.rotateOnAxis(cg,t)}rotateY(t){return this.rotateOnAxis(ug,t)}rotateZ(t){return this.rotateOnAxis(hg,t)}translateOnAxis(t,e){return lg.copy(t).applyQuaternion(this.quaternion),this.position.add(lg.multiplyScalar(e)),this}translateX(t){return this.translateOnAxis(cg,t)}translateY(t){return this.translateOnAxis(ug,t)}translateZ(t){return this.translateOnAxis(hg,t)}localToWorld(t){return t.applyMatrix4(this.matrixWorld)}worldToLocal(t){return t.applyMatrix4(Rn.copy(this.matrixWorld).invert())}lookAt(t,e,i){t.isVector3?Ta.copy(t):Ta.set(t,e,i);let r=this.parent;this.updateWorldMatrix(!0,!1),Hs.setFromMatrixPosition(this.matrixWorld),this.isCamera||this.isLight?Rn.lookAt(Hs,Ta,this.up):Rn.lookAt(Ta,Hs,this.up),this.quaternion.setFromRotationMatrix(Rn),r&&(Rn.extractRotation(r.matrixWorld),vr.setFromRotationMatrix(Rn),this.quaternion.premultiply(vr.invert()))}add(t){if(arguments.length>1){for(let e=0;e<arguments.length;e++)this.add(arguments[e]);return this}return t===this?(console.error("THREE.Object3D.add: object can't be added as a child of itself.",t),this):(t&&t.isObject3D?(t.parent!==null&&t.parent.remove(t),t.parent=this,this.children.push(t),t.dispatchEvent(uM)):console.error("THREE.Object3D.add: object not an instance of THREE.Object3D.",t),this)}remove(t){if(arguments.length>1){for(let i=0;i<arguments.length;i++)this.remove(arguments[i]);return this}let e=this.children.indexOf(t);return e!==-1&&(t.parent=null,this.children.splice(e,1),t.dispatchEvent(fg)),this}removeFromParent(){let t=this.parent;return t!==null&&t.remove(this),this}clear(){for(let t=0;t<this.children.length;t++){let e=this.children[t];e.parent=null,e.dispatchEvent(fg)}return this.children.length=0,this}attach(t){return this.updateWorldMatrix(!0,!1),Rn.copy(this.matrixWorld).invert(),t.parent!==null&&(t.parent.updateWorldMatrix(!0,!1),Rn.multiply(t.parent.matrixWorld)),t.applyMatrix4(Rn),this.add(t),t.updateWorldMatrix(!1,!0),this}getObjectById(t){return this.getObjectByProperty("id",t)}getObjectByName(t){return this.getObjectByProperty("name",t)}getObjectByProperty(t,e){if(this[t]===e)return this;for(let i=0,r=this.children.length;i<r;i++){let o=this.children[i].getObjectByProperty(t,e);if(o!==void 0)return o}}getWorldPosition(t){return this.updateWorldMatrix(!0,!1),t.setFromMatrixPosition(this.matrixWorld)}getWorldQuaternion(t){return this.updateWorldMatrix(!0,!1),this.matrixWorld.decompose(Hs,t,lM),t}getWorldScale(t){return this.updateWorldMatrix(!0,!1),this.matrixWorld.decompose(Hs,cM,t),t}getWorldDirection(t){this.updateWorldMatrix(!0,!1);let e=this.matrixWorld.elements;return t.set(e[8],e[9],e[10]).normalize()}raycast(){}traverse(t){t(this);let e=this.children;for(let i=0,r=e.length;i<r;i++)e[i].traverse(t)}traverseVisible(t){if(this.visible===!1)return;t(this);let e=this.children;for(let i=0,r=e.length;i<r;i++)e[i].traverseVisible(t)}traverseAncestors(t){let e=this.parent;e!==null&&(t(e),e.traverseAncestors(t))}updateMatrix(){this.matrix.compose(this.position,this.quaternion,this.scale),this.matrixWorldNeedsUpdate=!0}updateMatrixWorld(t){this.matrixAutoUpdate&&this.updateMatrix(),(this.matrixWorldNeedsUpdate||t)&&(this.parent===null?this.matrixWorld.copy(this.matrix):this.matrixWorld.multiplyMatrices(this.parent.matrixWorld,this.matrix),this.matrixWorldNeedsUpdate=!1,t=!0);let e=this.children;for(let i=0,r=e.length;i<r;i++)e[i].updateMatrixWorld(t)}updateWorldMatrix(t,e){let i=this.parent;if(t===!0&&i!==null&&i.updateWorldMatrix(!0,!1),this.matrixAutoUpdate&&this.updateMatrix(),this.parent===null?this.matrixWorld.copy(this.matrix):this.matrixWorld.multiplyMatrices(this.parent.matrixWorld,this.matrix),e===!0){let r=this.children;for(let s=0,o=r.length;s<o;s++)r[s].updateWorldMatrix(!1,!0)}}toJSON(t){let e=t===void 0||typeof t=="string",i={};e&&(t={geometries:{},materials:{},textures:{},images:{},shapes:{},skeletons:{},animations:{}},i.metadata={version:4.5,type:"Object",generator:"Object3D.toJSON"});let r={};r.uuid=this.uuid,r.type=this.type,this.name!==""&&(r.name=this.name),this.castShadow===!0&&(r.castShadow=!0),this.receiveShadow===!0&&(r.receiveShadow=!0),this.visible===!1&&(r.visible=!1),this.frustumCulled===!1&&(r.frustumCulled=!1),this.renderOrder!==0&&(r.renderOrder=this.renderOrder),JSON.stringify(this.userData)!=="{}"&&(r.userData=this.userData),r.layers=this.layers.mask,r.matrix=this.matrix.toArray(),this.matrixAutoUpdate===!1&&(r.matrixAutoUpdate=!1),this.isInstancedMesh&&(r.type="InstancedMesh",r.count=this.count,r.instanceMatrix=this.instanceMatrix.toJSON(),this.instanceColor!==null&&(r.instanceColor=this.instanceColor.toJSON()));function s(a,l){return a[l.uuid]===void 0&&(a[l.uuid]=l.toJSON(t)),l.uuid}if(this.isScene)this.background&&(this.background.isColor?r.background=this.background.toJSON():this.background.isTexture&&(r.background=this.background.toJSON(t).uuid)),this.environment&&this.environment.isTexture&&(r.environment=this.environment.toJSON(t).uuid);else if(this.isMesh||this.isLine||this.isPoints){r.geometry=s(t.geometries,this.geometry);let a=this.geometry.parameters;if(a!==void 0&&a.shapes!==void 0){let l=a.shapes;if(Array.isArray(l))for(let c=0,u=l.length;c<u;c++){let h=l[c];s(t.shapes,h)}else s(t.shapes,l)}}if(this.isSkinnedMesh&&(r.bindMode=this.bindMode,r.bindMatrix=this.bindMatrix.toArray(),this.skeleton!==void 0&&(s(t.skeletons,this.skeleton),r.skeleton=this.skeleton.uuid)),this.material!==void 0)if(Array.isArray(this.material)){let a=[];for(let l=0,c=this.material.length;l<c;l++)a.push(s(t.materials,this.material[l]));r.material=a}else r.material=s(t.materials,this.material);if(this.children.length>0){r.children=[];for(let a=0;a<this.children.length;a++)r.children.push(this.children[a].toJSON(t).object)}if(this.animations.length>0){r.animations=[];for(let a=0;a<this.animations.length;a++){let l=this.animations[a];r.animations.push(s(t.animations,l))}}if(e){let a=o(t.geometries),l=o(t.materials),c=o(t.textures),u=o(t.images),h=o(t.shapes),f=o(t.skeletons),d=o(t.animations);a.length>0&&(i.geometries=a),l.length>0&&(i.materials=l),c.length>0&&(i.textures=c),u.length>0&&(i.images=u),h.length>0&&(i.shapes=h),f.length>0&&(i.skeletons=f),d.length>0&&(i.animations=d)}return i.object=r,i;function o(a){let l=[];for(let c in a){let u=a[c];delete u.metadata,l.push(u)}return l}}clone(t){return new this.constructor().copy(this,t)}copy(t,e=!0){if(this.name=t.name,this.up.copy(t.up),this.position.copy(t.position),this.rotation.order=t.rotation.order,this.quaternion.copy(t.quaternion),this.scale.copy(t.scale),this.matrix.copy(t.matrix),this.matrixWorld.copy(t.matrixWorld),this.matrixAutoUpdate=t.matrixAutoUpdate,this.matrixWorldNeedsUpdate=t.matrixWorldNeedsUpdate,this.layers.mask=t.layers.mask,this.visible=t.visible,this.castShadow=t.castShadow,this.receiveShadow=t.receiveShadow,this.frustumCulled=t.frustumCulled,this.renderOrder=t.renderOrder,this.userData=JSON.parse(JSON.stringify(t.userData)),e===!0)for(let i=0;i<t.children.length;i++){let r=t.children[i];this.add(r.clone())}return this}};kt.DefaultUp=new T(0,1,0);kt.DefaultMatrixAutoUpdate=!0;kt.prototype.isObject3D=!0;var Qe=new T,Ln=new T,mu=new T,Pn=new T,_r=new T,wr=new T,dg=new T,gu=new T,xu=new T,yu=new T,re=class{constructor(t=new T,e=new T,i=new T){this.a=t,this.b=e,this.c=i}static getNormal(t,e,i,r){r.subVectors(i,e),Qe.subVectors(t,e),r.cross(Qe);let s=r.lengthSq();return s>0?r.multiplyScalar(1/Math.sqrt(s)):r.set(0,0,0)}static getBarycoord(t,e,i,r,s){Qe.subVectors(r,e),Ln.subVectors(i,e),mu.subVectors(t,e);let o=Qe.dot(Qe),a=Qe.dot(Ln),l=Qe.dot(mu),c=Ln.dot(Ln),u=Ln.dot(mu),h=o*c-a*a;if(h===0)return s.set(-2,-1,-1);let f=1/h,d=(c*l-a*u)*f,g=(o*u-a*l)*f;return s.set(1-d-g,g,d)}static containsPoint(t,e,i,r){return this.getBarycoord(t,e,i,r,Pn),Pn.x>=0&&Pn.y>=0&&Pn.x+Pn.y<=1}static getUV(t,e,i,r,s,o,a,l){return this.getBarycoord(t,e,i,r,Pn),l.set(0,0),l.addScaledVector(s,Pn.x),l.addScaledVector(o,Pn.y),l.addScaledVector(a,Pn.z),l}static isFrontFacing(t,e,i,r){return Qe.subVectors(i,e),Ln.subVectors(t,e),Qe.cross(Ln).dot(r)<0}set(t,e,i){return this.a.copy(t),this.b.copy(e),this.c.copy(i),this}setFromPointsAndIndices(t,e,i,r){return this.a.copy(t[e]),this.b.copy(t[i]),this.c.copy(t[r]),this}setFromAttributeAndIndices(t,e,i,r){return this.a.fromBufferAttribute(t,e),this.b.fromBufferAttribute(t,i),this.c.fromBufferAttribute(t,r),this}clone(){return new this.constructor().copy(this)}copy(t){return this.a.copy(t.a),this.b.copy(t.b),this.c.copy(t.c),this}getArea(){return Qe.subVectors(this.c,this.b),Ln.subVectors(this.a,this.b),Qe.cross(Ln).length()*.5}getMidpoint(t){return t.addVectors(this.a,this.b).add(this.c).multiplyScalar(1/3)}getNormal(t){return re.getNormal(this.a,this.b,this.c,t)}getPlane(t){return t.setFromCoplanarPoints(this.a,this.b,this.c)}getBarycoord(t,e){return re.getBarycoord(t,this.a,this.b,this.c,e)}getUV(t,e,i,r,s){return re.getUV(t,this.a,this.b,this.c,e,i,r,s)}containsPoint(t){return re.containsPoint(t,this.a,this.b,this.c)}isFrontFacing(t){return re.isFrontFacing(this.a,this.b,this.c,t)}intersectsBox(t){return t.intersectsTriangle(this)}closestPointToPoint(t,e){let i=this.a,r=this.b,s=this.c,o,a;_r.subVectors(r,i),wr.subVectors(s,i),gu.subVectors(t,i);let l=_r.dot(gu),c=wr.dot(gu);if(l<=0&&c<=0)return e.copy(i);xu.subVectors(t,r);let u=_r.dot(xu),h=wr.dot(xu);if(u>=0&&h<=u)return e.copy(r);let f=l*h-u*c;if(f<=0&&l>=0&&u<=0)return o=l/(l-u),e.copy(i).addScaledVector(_r,o);yu.subVectors(t,s);let d=_r.dot(yu),g=wr.dot(yu);if(g>=0&&d<=g)return e.copy(s);let x=d*c-l*g;if(x<=0&&c>=0&&g<=0)return a=c/(c-g),e.copy(i).addScaledVector(wr,a);let v=u*g-d*h;if(v<=0&&h-u>=0&&d-g>=0)return dg.subVectors(s,r),a=(h-u)/(h-u+(d-g)),e.copy(r).addScaledVector(dg,a);let m=1/(v+x+f);return o=x*m,a=f*m,e.copy(i).addScaledVector(_r,o).addScaledVector(wr,a)}equals(t){return t.a.equals(this.a)&&t.b.equals(this.b)&&t.c.equals(this.c)}},hM=0,xe=class extends In{constructor(){super(),Object.defineProperty(this,"id",{value:hM++}),this.uuid=tn(),this.name="",this.type="Material",this.fog=!0,this.blending=Ks,this.side=eo,this.vertexColors=!1,this.opacity=1,this.transparent=!1,this.blendSrc=u0,this.blendDst=h0,this.blendEquation=Ir,this.blendSrcAlpha=null,this.blendDstAlpha=null,this.blendEquationAlpha=null,this.depthFunc=zu,this.depthTest=!0,this.depthWrite=!0,this.stencilWriteMask=255,this.stencilFunc=tM,this.stencilRef=0,this.stencilFuncMask=255,this.stencilFail=nu,this.stencilZFail=nu,this.stencilZPass=nu,this.stencilWrite=!1,this.clippingPlanes=null,this.clipIntersection=!1,this.clipShadows=!1,this.shadowSide=null,this.colorWrite=!0,this.alphaWrite=!0,this.precision=null,this.polygonOffset=!1,this.polygonOffsetFactor=0,this.polygonOffsetUnits=0,this.dithering=!1,this.alphaToCoverage=!1,this.premultipliedAlpha=!1,this.visible=!0,this.toneMapped=!0,this.userData={},this.version=0,this._alphaTest=0}get alphaTest(){return this._alphaTest}set alphaTest(t){this._alphaTest>0!=t>0&&this.version++,this._alphaTest=t}onBuild(){}onBeforeRender(){}onBeforeCompile(){}customProgramCacheKey(){return this.onBeforeCompile.toString()}setValues(t){if(t!==void 0)for(let e in t){let i=t[e];if(i===void 0){console.warn("THREE.Material: '"+e+"' parameter is undefined.");continue}if(e==="shading"){console.warn("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead."),this.flatShading=i===c0;continue}let r=this[e];if(r===void 0){console.warn("THREE."+this.type+": '"+e+"' is not a property of this material.");continue}r&&r.isColor?r.set(i):r&&r.isVector3&&i&&i.isVector3?r.copy(i):this[e]=i}}toJSON(t){let e=t===void 0||typeof t=="string";e&&(t={textures:{},images:{}});let i={metadata:{version:4.5,type:"Material",generator:"Material.toJSON"}};i.uuid=this.uuid,i.type=this.type,this.name!==""&&(i.name=this.name),this.color&&this.color.isColor&&(i.color=this.color.getHex()),this.roughness!==void 0&&(i.roughness=this.roughness),this.metalness!==void 0&&(i.metalness=this.metalness),this.sheen!==void 0&&(i.sheen=this.sheen),this.sheenColor&&this.sheenColor.isColor&&(i.sheenColor=this.sheenColor.getHex()),this.sheenRoughness!==void 0&&(i.sheenRoughness=this.sheenRoughness),this.emissive&&this.emissive.isColor&&(i.emissive=this.emissive.getHex()),this.emissiveIntensity&&this.emissiveIntensity!==1&&(i.emissiveIntensity=this.emissiveIntensity),this.specular&&this.specular.isColor&&(i.specular=this.specular.getHex()),this.specularIntensity!==void 0&&(i.specularIntensity=this.specularIntensity),this.specularColor&&this.specularColor.isColor&&(i.specularColor=this.specularColor.getHex()),this.shininess!==void 0&&(i.shininess=this.shininess),this.clearcoat!==void 0&&(i.clearcoat=this.clearcoat),this.clearcoatRoughness!==void 0&&(i.clearcoatRoughness=this.clearcoatRoughness),this.clearcoatMap&&this.clearcoatMap.isTexture&&(i.clearcoatMap=this.clearcoatMap.toJSON(t).uuid),this.clearcoatRoughnessMap&&this.clearcoatRoughnessMap.isTexture&&(i.clearcoatRoughnessMap=this.clearcoatRoughnessMap.toJSON(t).uuid),this.clearcoatNormalMap&&this.clearcoatNormalMap.isTexture&&(i.clearcoatNormalMap=this.clearcoatNormalMap.toJSON(t).uuid,i.clearcoatNormalScale=this.clearcoatNormalScale.toArray()),this.map&&this.map.isTexture&&(i.map=this.map.toJSON(t).uuid),this.matcap&&this.matcap.isTexture&&(i.matcap=this.matcap.toJSON(t).uuid),this.alphaMap&&this.alphaMap.isTexture&&(i.alphaMap=this.alphaMap.toJSON(t).uuid),this.lightMap&&this.lightMap.isTexture&&(i.lightMap=this.lightMap.toJSON(t).uuid,i.lightMapIntensity=this.lightMapIntensity),this.aoMap&&this.aoMap.isTexture&&(i.aoMap=this.aoMap.toJSON(t).uuid,i.aoMapIntensity=this.aoMapIntensity),this.bumpMap&&this.bumpMap.isTexture&&(i.bumpMap=this.bumpMap.toJSON(t).uuid,i.bumpScale=this.bumpScale),this.normalMap&&this.normalMap.isTexture&&(i.normalMap=this.normalMap.toJSON(t).uuid,i.normalMapType=this.normalMapType,i.normalScale=this.normalScale.toArray()),this.displacementMap&&this.displacementMap.isTexture&&(i.displacementMap=this.displacementMap.toJSON(t).uuid,i.displacementScale=this.displacementScale,i.displacementBias=this.displacementBias),this.roughnessMap&&this.roughnessMap.isTexture&&(i.roughnessMap=this.roughnessMap.toJSON(t).uuid),this.metalnessMap&&this.metalnessMap.isTexture&&(i.metalnessMap=this.metalnessMap.toJSON(t).uuid),this.emissiveMap&&this.emissiveMap.isTexture&&(i.emissiveMap=this.emissiveMap.toJSON(t).uuid),this.specularMap&&this.specularMap.isTexture&&(i.specularMap=this.specularMap.toJSON(t).uuid),this.specularIntensityMap&&this.specularIntensityMap.isTexture&&(i.specularIntensityMap=this.specularIntensityMap.toJSON(t).uuid),this.specularColorMap&&this.specularColorMap.isTexture&&(i.specularColorMap=this.specularColorMap.toJSON(t).uuid),this.envMap&&this.envMap.isTexture&&(i.envMap=this.envMap.toJSON(t).uuid,this.combine!==void 0&&(i.combine=this.combine)),this.envMapIntensity!==void 0&&(i.envMapIntensity=this.envMapIntensity),this.reflectivity!==void 0&&(i.reflectivity=this.reflectivity),this.refractionRatio!==void 0&&(i.refractionRatio=this.refractionRatio),this.gradientMap&&this.gradientMap.isTexture&&(i.gradientMap=this.gradientMap.toJSON(t).uuid),this.transmission!==void 0&&(i.transmission=this.transmission),this.transmissionMap&&this.transmissionMap.isTexture&&(i.transmissionMap=this.transmissionMap.toJSON(t).uuid),this.thickness!==void 0&&(i.thickness=this.thickness),this.thicknessMap&&this.thicknessMap.isTexture&&(i.thicknessMap=this.thicknessMap.toJSON(t).uuid),this.attenuationDistance!==void 0&&(i.attenuationDistance=this.attenuationDistance),this.attenuationColor!==void 0&&(i.attenuationColor=this.attenuationColor.getHex()),this.size!==void 0&&(i.size=this.size),this.shadowSide!==null&&(i.shadowSide=this.shadowSide),this.sizeAttenuation!==void 0&&(i.sizeAttenuation=this.sizeAttenuation),this.blending!==Ks&&(i.blending=this.blending),this.side!==eo&&(i.side=this.side),this.vertexColors&&(i.vertexColors=!0),this.opacity<1&&(i.opacity=this.opacity),this.transparent===!0&&(i.transparent=this.transparent),i.depthFunc=this.depthFunc,i.depthTest=this.depthTest,i.depthWrite=this.depthWrite,i.colorWrite=this.colorWrite,i.alphaWrite=this.alphaWrite,i.stencilWrite=this.stencilWrite,i.stencilWriteMask=this.stencilWriteMask,i.stencilFunc=this.stencilFunc,i.stencilRef=this.stencilRef,i.stencilFuncMask=this.stencilFuncMask,i.stencilFail=this.stencilFail,i.stencilZFail=this.stencilZFail,i.stencilZPass=this.stencilZPass,this.rotation&&this.rotation!==0&&(i.rotation=this.rotation),this.polygonOffset===!0&&(i.polygonOffset=!0),this.polygonOffsetFactor!==0&&(i.polygonOffsetFactor=this.polygonOffsetFactor),this.polygonOffsetUnits!==0&&(i.polygonOffsetUnits=this.polygonOffsetUnits),this.linewidth&&this.linewidth!==1&&(i.linewidth=this.linewidth),this.dashSize!==void 0&&(i.dashSize=this.dashSize),this.gapSize!==void 0&&(i.gapSize=this.gapSize),this.scale!==void 0&&(i.scale=this.scale),this.dithering===!0&&(i.dithering=!0),this.alphaTest>0&&(i.alphaTest=this.alphaTest),this.alphaToCoverage===!0&&(i.alphaToCoverage=this.alphaToCoverage),this.premultipliedAlpha===!0&&(i.premultipliedAlpha=this.premultipliedAlpha),this.wireframe===!0&&(i.wireframe=this.wireframe),this.wireframeLinewidth>1&&(i.wireframeLinewidth=this.wireframeLinewidth),this.wireframeLinecap!=="round"&&(i.wireframeLinecap=this.wireframeLinecap),this.wireframeLinejoin!=="round"&&(i.wireframeLinejoin=this.wireframeLinejoin),this.flatShading===!0&&(i.flatShading=this.flatShading),this.visible===!1&&(i.visible=!1),this.toneMapped===!1&&(i.toneMapped=!1),JSON.stringify(this.userData)!=="{}"&&(i.userData=this.userData);function r(s){let o=[];for(let a in s){let l=s[a];delete l.metadata,o.push(l)}return o}if(e){let s=r(t.textures),o=r(t.images);s.length>0&&(i.textures=s),o.length>0&&(i.images=o)}return i}clone(){return new this.constructor().copy(this)}copy(t){this.name=t.name,this.fog=t.fog,this.blending=t.blending,this.side=t.side,this.vertexColors=t.vertexColors,this.opacity=t.opacity,this.transparent=t.transparent,this.blendSrc=t.blendSrc,this.blendDst=t.blendDst,this.blendEquation=t.blendEquation,this.blendSrcAlpha=t.blendSrcAlpha,this.blendDstAlpha=t.blendDstAlpha,this.blendEquationAlpha=t.blendEquationAlpha,this.depthFunc=t.depthFunc,this.depthTest=t.depthTest,this.depthWrite=t.depthWrite,this.stencilWriteMask=t.stencilWriteMask,this.stencilFunc=t.stencilFunc,this.stencilRef=t.stencilRef,this.stencilFuncMask=t.stencilFuncMask,this.stencilFail=t.stencilFail,this.stencilZFail=t.stencilZFail,this.stencilZPass=t.stencilZPass,this.stencilWrite=t.stencilWrite;let e=t.clippingPlanes,i=null;if(e!==null){let r=e.length;i=new Array(r);for(let s=0;s!==r;++s)i[s]=e[s].clone()}return this.clippingPlanes=i,this.clipIntersection=t.clipIntersection,this.clipShadows=t.clipShadows,this.shadowSide=t.shadowSide,this.colorWrite=t.colorWrite,this.alphaWrite=t.alphaWrite,this.precision=t.precision,this.polygonOffset=t.polygonOffset,this.polygonOffsetFactor=t.polygonOffsetFactor,this.polygonOffsetUnits=t.polygonOffsetUnits,this.dithering=t.dithering,this.alphaTest=t.alphaTest,this.alphaToCoverage=t.alphaToCoverage,this.premultipliedAlpha=t.premultipliedAlpha,this.visible=t.visible,this.toneMapped=t.toneMapped,this.userData=JSON.parse(JSON.stringify(t.userData)),this}dispose(){this.dispatchEvent({type:"dispose"})}set needsUpdate(t){t===!0&&this.version++}};xe.prototype.isMaterial=!0;var ki=class extends xe{constructor(t){super(),this.type="MeshBasicMaterial",this.color=new ft(16777215),this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.specularMap=null,this.alphaMap=null,this.envMap=null,this.combine=Cl,this.reflectivity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.specularMap=t.specularMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.combine=t.combine,this.reflectivity=t.reflectivity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this}};ki.prototype.isMeshBasicMaterial=!0;var Jt=new T,Aa=new K,Qt=class{constructor(t,e,i){if(Array.isArray(t))throw new TypeError("THREE.BufferAttribute: array should be a Typed Array.");this.name="",this.array=t,this.itemSize=e,this.count=t!==void 0?t.length/e:0,this.normalized=i===!0,this.usage=io,this.updateRange={offset:0,count:-1},this.version=0}onUploadCallback(){}set needsUpdate(t){t===!0&&this.version++}setUsage(t){return this.usage=t,this}copy(t){return this.name=t.name,this.array=new t.array.constructor(t.array),this.itemSize=t.itemSize,this.count=t.count,this.normalized=t.normalized,this.usage=t.usage,this}copyAt(t,e,i){t*=this.itemSize,i*=e.itemSize;for(let r=0,s=this.itemSize;r<s;r++)this.array[t+r]=e.array[i+r];return this}copyArray(t){return this.array.set(t),this}copyColorsArray(t){let e=this.array,i=0;for(let r=0,s=t.length;r<s;r++){let o=t[r];o===void 0&&(console.warn("THREE.BufferAttribute.copyColorsArray(): color is undefined",r),o=new ft),e[i++]=o.r,e[i++]=o.g,e[i++]=o.b}return this}copyVector2sArray(t){let e=this.array,i=0;for(let r=0,s=t.length;r<s;r++){let o=t[r];o===void 0&&(console.warn("THREE.BufferAttribute.copyVector2sArray(): vector is undefined",r),o=new K),e[i++]=o.x,e[i++]=o.y}return this}copyVector3sArray(t){let e=this.array,i=0;for(let r=0,s=t.length;r<s;r++){let o=t[r];o===void 0&&(console.warn("THREE.BufferAttribute.copyVector3sArray(): vector is undefined",r),o=new T),e[i++]=o.x,e[i++]=o.y,e[i++]=o.z}return this}copyVector4sArray(t){let e=this.array,i=0;for(let r=0,s=t.length;r<s;r++){let o=t[r];o===void 0&&(console.warn("THREE.BufferAttribute.copyVector4sArray(): vector is undefined",r),o=new Wt),e[i++]=o.x,e[i++]=o.y,e[i++]=o.z,e[i++]=o.w}return this}applyMatrix3(t){if(this.itemSize===2)for(let e=0,i=this.count;e<i;e++)Aa.fromBufferAttribute(this,e),Aa.applyMatrix3(t),this.setXY(e,Aa.x,Aa.y);else if(this.itemSize===3)for(let e=0,i=this.count;e<i;e++)Jt.fromBufferAttribute(this,e),Jt.applyMatrix3(t),this.setXYZ(e,Jt.x,Jt.y,Jt.z);return this}applyMatrix4(t){for(let e=0,i=this.count;e<i;e++)Jt.x=this.getX(e),Jt.y=this.getY(e),Jt.z=this.getZ(e),Jt.applyMatrix4(t),this.setXYZ(e,Jt.x,Jt.y,Jt.z);return this}applyNormalMatrix(t){for(let e=0,i=this.count;e<i;e++)Jt.x=this.getX(e),Jt.y=this.getY(e),Jt.z=this.getZ(e),Jt.applyNormalMatrix(t),this.setXYZ(e,Jt.x,Jt.y,Jt.z);return this}transformDirection(t){for(let e=0,i=this.count;e<i;e++)Jt.x=this.getX(e),Jt.y=this.getY(e),Jt.z=this.getZ(e),Jt.transformDirection(t),this.setXYZ(e,Jt.x,Jt.y,Jt.z);return this}set(t,e=0){return this.array.set(t,e),this}getX(t){return this.array[t*this.itemSize]}setX(t,e){return this.array[t*this.itemSize]=e,this}getY(t){return this.array[t*this.itemSize+1]}setY(t,e){return this.array[t*this.itemSize+1]=e,this}getZ(t){return this.array[t*this.itemSize+2]}setZ(t,e){return this.array[t*this.itemSize+2]=e,this}getW(t){return this.array[t*this.itemSize+3]}setW(t,e){return this.array[t*this.itemSize+3]=e,this}setXY(t,e,i){return t*=this.itemSize,this.array[t+0]=e,this.array[t+1]=i,this}setXYZ(t,e,i,r){return t*=this.itemSize,this.array[t+0]=e,this.array[t+1]=i,this.array[t+2]=r,this}setXYZW(t,e,i,r,s){return t*=this.itemSize,this.array[t+0]=e,this.array[t+1]=i,this.array[t+2]=r,this.array[t+3]=s,this}onUpload(t){return this.onUploadCallback=t,this}clone(){return new this.constructor(this.array,this.itemSize).copy(this)}toJSON(){let t={itemSize:this.itemSize,type:this.array.constructor.name,array:Array.prototype.slice.call(this.array),normalized:this.normalized};return this.name!==""&&(t.name=this.name),this.usage!==io&&(t.usage=this.usage),(this.updateRange.offset!==0||this.updateRange.count!==-1)&&(t.updateRange=this.updateRange),t}};Qt.prototype.isBufferAttribute=!0;var rl=class extends Qt{constructor(t,e,i){super(new Uint16Array(t),e,i)}};var sl=class extends Qt{constructor(t,e,i){super(new Uint32Array(t),e,i)}},Wu=class extends Qt{constructor(t,e,i){super(new Uint16Array(t),e,i)}};Wu.prototype.isFloat16BufferAttribute=!0;var ee=class extends Qt{constructor(t,e,i){super(new Float32Array(t),e,i)}};var fM=0,qe=new wt,vu=new kt,Mr=new T,He=new Ge,Vs=new Ge,ge=new T,Ht=class extends In{constructor(){super(),Object.defineProperty(this,"id",{value:fM++}),this.uuid=tn(),this.name="",this.type="BufferGeometry",this.index=null,this.attributes={},this.morphAttributes={},this.morphTargetsRelative=!1,this.groups=[],this.boundingBox=null,this.boundingSphere=null,this.drawRange={start:0,count:1/0},this.userData={}}getIndex(){return this.index}setIndex(t){return Array.isArray(t)?this.index=new(p0(t)?sl:rl)(t,1):this.index=t,this}getAttribute(t){return this.attributes[t]}setAttribute(t,e){return this.attributes[t]=e,this}deleteAttribute(t){return delete this.attributes[t],this}hasAttribute(t){return this.attributes[t]!==void 0}addGroup(t,e,i=0){this.groups.push({start:t,count:e,materialIndex:i})}clearGroups(){this.groups=[]}setDrawRange(t,e){this.drawRange.start=t,this.drawRange.count=e}applyMatrix4(t){let e=this.attributes.position;e!==void 0&&(e.applyMatrix4(t),e.needsUpdate=!0);let i=this.attributes.normal;if(i!==void 0){let s=new de().getNormalMatrix(t);i.applyNormalMatrix(s),i.needsUpdate=!0}let r=this.attributes.tangent;return r!==void 0&&(r.transformDirection(t),r.needsUpdate=!0),this.boundingBox!==null&&this.computeBoundingBox(),this.boundingSphere!==null&&this.computeBoundingSphere(),this}applyQuaternion(t){return qe.makeRotationFromQuaternion(t),this.applyMatrix4(qe),this}rotateX(t){return qe.makeRotationX(t),this.applyMatrix4(qe),this}rotateY(t){return qe.makeRotationY(t),this.applyMatrix4(qe),this}rotateZ(t){return qe.makeRotationZ(t),this.applyMatrix4(qe),this}translate(t,e,i){return qe.makeTranslation(t,e,i),this.applyMatrix4(qe),this}scale(t,e,i){return qe.makeScale(t,e,i),this.applyMatrix4(qe),this}lookAt(t){return vu.lookAt(t),vu.updateMatrix(),this.applyMatrix4(vu.matrix),this}center(){return this.computeBoundingBox(),this.boundingBox.getCenter(Mr).negate(),this.translate(Mr.x,Mr.y,Mr.z),this}setFromPoints(t){let e=[];for(let i=0,r=t.length;i<r;i++){let s=t[i];e.push(s.x,s.y,s.z||0)}return this.setAttribute("position",new ee(e,3)),this}computeBoundingBox(){this.boundingBox===null&&(this.boundingBox=new Ge);let t=this.attributes.position,e=this.morphAttributes.position;if(t&&t.isGLBufferAttribute){console.error('THREE.BufferGeometry.computeBoundingBox(): GLBufferAttribute requires a manual bounding box. Alternatively set "mesh.frustumCulled" to "false".',this),this.boundingBox.set(new T(-1/0,-1/0,-1/0),new T(1/0,1/0,1/0));return}if(t!==void 0){if(this.boundingBox.setFromBufferAttribute(t),e)for(let i=0,r=e.length;i<r;i++){let s=e[i];He.setFromBufferAttribute(s),this.morphTargetsRelative?(ge.addVectors(this.boundingBox.min,He.min),this.boundingBox.expandByPoint(ge),ge.addVectors(this.boundingBox.max,He.max),this.boundingBox.expandByPoint(ge)):(this.boundingBox.expandByPoint(He.min),this.boundingBox.expandByPoint(He.max))}}else this.boundingBox.makeEmpty();(isNaN(this.boundingBox.min.x)||isNaN(this.boundingBox.min.y)||isNaN(this.boundingBox.min.z))&&console.error('THREE.BufferGeometry.computeBoundingBox(): Computed min/max have NaN values. The "position" attribute is likely to have NaN values.',this)}computeBoundingSphere(){this.boundingSphere===null&&(this.boundingSphere=new si);let t=this.attributes.position,e=this.morphAttributes.position;if(t&&t.isGLBufferAttribute){console.error('THREE.BufferGeometry.computeBoundingSphere(): GLBufferAttribute requires a manual bounding sphere. Alternatively set "mesh.frustumCulled" to "false".',this),this.boundingSphere.set(new T,1/0);return}if(t){let i=this.boundingSphere.center;if(He.setFromBufferAttribute(t),e)for(let s=0,o=e.length;s<o;s++){let a=e[s];Vs.setFromBufferAttribute(a),this.morphTargetsRelative?(ge.addVectors(He.min,Vs.min),He.expandByPoint(ge),ge.addVectors(He.max,Vs.max),He.expandByPoint(ge)):(He.expandByPoint(Vs.min),He.expandByPoint(Vs.max))}He.getCenter(i);let r=0;for(let s=0,o=t.count;s<o;s++)ge.fromBufferAttribute(t,s),r=Math.max(r,i.distanceToSquared(ge));if(e)for(let s=0,o=e.length;s<o;s++){let a=e[s],l=this.morphTargetsRelative;for(let c=0,u=a.count;c<u;c++)ge.fromBufferAttribute(a,c),l&&(Mr.fromBufferAttribute(t,c),ge.add(Mr)),r=Math.max(r,i.distanceToSquared(ge))}this.boundingSphere.radius=Math.sqrt(r),isNaN(this.boundingSphere.radius)&&console.error('THREE.BufferGeometry.computeBoundingSphere(): Computed radius is NaN. The "position" attribute is likely to have NaN values.',this)}}computeTangents(){let t=this.index,e=this.attributes;if(t===null||e.position===void 0||e.normal===void 0||e.uv===void 0){console.error("THREE.BufferGeometry: .computeTangents() failed. Missing required attributes (index, position, normal or uv)");return}let i=t.array,r=e.position.array,s=e.normal.array,o=e.uv.array,a=r.length/3;e.tangent===void 0&&this.setAttribute("tangent",new Qt(new Float32Array(4*a),4));let l=e.tangent.array,c=[],u=[];for(let X=0;X<a;X++)c[X]=new T,u[X]=new T;let h=new T,f=new T,d=new T,g=new K,x=new K,v=new K,m=new T,p=new T;function b(X,y,R){h.fromArray(r,X*3),f.fromArray(r,y*3),d.fromArray(r,R*3),g.fromArray(o,X*2),x.fromArray(o,y*2),v.fromArray(o,R*2),f.sub(h),d.sub(h),x.sub(g),v.sub(g);let D=1/(x.x*v.y-v.x*x.y);!isFinite(D)||(m.copy(f).multiplyScalar(v.y).addScaledVector(d,-x.y).multiplyScalar(D),p.copy(d).multiplyScalar(x.x).addScaledVector(f,-v.x).multiplyScalar(D),c[X].add(m),c[y].add(m),c[R].add(m),u[X].add(p),u[y].add(p),u[R].add(p))}let _=this.groups;_.length===0&&(_=[{start:0,count:i.length}]);for(let X=0,y=_.length;X<y;++X){let R=_[X],D=R.start,F=R.count;for(let z=D,N=D+F;z<N;z+=3)b(i[z+0],i[z+1],i[z+2])}let S=new T,L=new T,A=new T,H=new T;function tt(X){A.fromArray(s,X*3),H.copy(A);let y=c[X];S.copy(y),S.sub(A.multiplyScalar(A.dot(y))).normalize(),L.crossVectors(H,y);let D=L.dot(u[X])<0?-1:1;l[X*4]=S.x,l[X*4+1]=S.y,l[X*4+2]=S.z,l[X*4+3]=D}for(let X=0,y=_.length;X<y;++X){let R=_[X],D=R.start,F=R.count;for(let z=D,N=D+F;z<N;z+=3)tt(i[z+0]),tt(i[z+1]),tt(i[z+2])}}computeVertexNormals(){let t=this.index,e=this.getAttribute("position");if(e!==void 0){let i=this.getAttribute("normal");if(i===void 0)i=new Qt(new Float32Array(e.count*3),3),this.setAttribute("normal",i);else for(let f=0,d=i.count;f<d;f++)i.setXYZ(f,0,0,0);let r=new T,s=new T,o=new T,a=new T,l=new T,c=new T,u=new T,h=new T;if(t)for(let f=0,d=t.count;f<d;f+=3){let g=t.getX(f+0),x=t.getX(f+1),v=t.getX(f+2);r.fromBufferAttribute(e,g),s.fromBufferAttribute(e,x),o.fromBufferAttribute(e,v),u.subVectors(o,s),h.subVectors(r,s),u.cross(h),a.fromBufferAttribute(i,g),l.fromBufferAttribute(i,x),c.fromBufferAttribute(i,v),a.add(u),l.add(u),c.add(u),i.setXYZ(g,a.x,a.y,a.z),i.setXYZ(x,l.x,l.y,l.z),i.setXYZ(v,c.x,c.y,c.z)}else for(let f=0,d=e.count;f<d;f+=3)r.fromBufferAttribute(e,f+0),s.fromBufferAttribute(e,f+1),o.fromBufferAttribute(e,f+2),u.subVectors(o,s),h.subVectors(r,s),u.cross(h),i.setXYZ(f+0,u.x,u.y,u.z),i.setXYZ(f+1,u.x,u.y,u.z),i.setXYZ(f+2,u.x,u.y,u.z);this.normalizeNormals(),i.needsUpdate=!0}}merge(t,e){if(!(t&&t.isBufferGeometry)){console.error("THREE.BufferGeometry.merge(): geometry not an instance of THREE.BufferGeometry.",t);return}e===void 0&&(e=0,console.warn("THREE.BufferGeometry.merge(): Overwriting original geometry, starting at offset=0. Use BufferGeometryUtils.mergeBufferGeometries() for lossless merge."));let i=this.attributes;for(let r in i){if(t.attributes[r]===void 0)continue;let o=i[r].array,a=t.attributes[r],l=a.array,c=a.itemSize*e,u=Math.min(l.length,o.length-c);for(let h=0,f=c;h<u;h++,f++)o[f]=l[h]}return this}normalizeNormals(){let t=this.attributes.normal;for(let e=0,i=t.count;e<i;e++)ge.fromBufferAttribute(t,e),ge.normalize(),t.setXYZ(e,ge.x,ge.y,ge.z)}toNonIndexed(){function t(a,l){let c=a.array,u=a.itemSize,h=a.normalized,f=new c.constructor(l.length*u),d=0,g=0;for(let x=0,v=l.length;x<v;x++){a.isInterleavedBufferAttribute?d=l[x]*a.data.stride+a.offset:d=l[x]*u;for(let m=0;m<u;m++)f[g++]=c[d++]}return new Qt(f,u,h)}if(this.index===null)return console.warn("THREE.BufferGeometry.toNonIndexed(): BufferGeometry is already non-indexed."),this;let e=new Ht,i=this.index.array,r=this.attributes;for(let a in r){let l=r[a],c=t(l,i);e.setAttribute(a,c)}let s=this.morphAttributes;for(let a in s){let l=[],c=s[a];for(let u=0,h=c.length;u<h;u++){let f=c[u],d=t(f,i);l.push(d)}e.morphAttributes[a]=l}e.morphTargetsRelative=this.morphTargetsRelative;let o=this.groups;for(let a=0,l=o.length;a<l;a++){let c=o[a];e.addGroup(c.start,c.count,c.materialIndex)}return e}toJSON(){let t={metadata:{version:4.5,type:"BufferGeometry",generator:"BufferGeometry.toJSON"}};if(t.uuid=this.uuid,t.type=this.type,this.name!==""&&(t.name=this.name),Object.keys(this.userData).length>0&&(t.userData=this.userData),this.parameters!==void 0){let l=this.parameters;for(let c in l)l[c]!==void 0&&(t[c]=l[c]);return t}t.data={attributes:{}};let e=this.index;e!==null&&(t.data.index={type:e.array.constructor.name,array:Array.prototype.slice.call(e.array)});let i=this.attributes;for(let l in i){let c=i[l];t.data.attributes[l]=c.toJSON(t.data)}let r={},s=!1;for(let l in this.morphAttributes){let c=this.morphAttributes[l],u=[];for(let h=0,f=c.length;h<f;h++){let d=c[h];u.push(d.toJSON(t.data))}u.length>0&&(r[l]=u,s=!0)}s&&(t.data.morphAttributes=r,t.data.morphTargetsRelative=this.morphTargetsRelative);let o=this.groups;o.length>0&&(t.data.groups=JSON.parse(JSON.stringify(o)));let a=this.boundingSphere;return a!==null&&(t.data.boundingSphere={center:a.center.toArray(),radius:a.radius}),t}clone(){return new this.constructor().copy(this)}copy(t){this.index=null,this.attributes={},this.morphAttributes={},this.groups=[],this.boundingBox=null,this.boundingSphere=null;let e={};this.name=t.name;let i=t.index;i!==null&&this.setIndex(i.clone(e));let r=t.attributes;for(let c in r){let u=r[c];this.setAttribute(c,u.clone(e))}let s=t.morphAttributes;for(let c in s){let u=[],h=s[c];for(let f=0,d=h.length;f<d;f++)u.push(h[f].clone(e));this.morphAttributes[c]=u}this.morphTargetsRelative=t.morphTargetsRelative;let o=t.groups;for(let c=0,u=o.length;c<u;c++){let h=o[c];this.addGroup(h.start,h.count,h.materialIndex)}let a=t.boundingBox;a!==null&&(this.boundingBox=a.clone());let l=t.boundingSphere;return l!==null&&(this.boundingSphere=l.clone()),this.drawRange.start=t.drawRange.start,this.drawRange.count=t.drawRange.count,this.userData=t.userData,t.parameters!==void 0&&(this.parameters=Object.assign({},t.parameters)),this}dispose(){this.dispatchEvent({type:"dispose"})}};Ht.prototype.isBufferGeometry=!0;var pg=new wt,br=new oi,_u=new si,Jn=new T,$n=new T,Kn=new T,wu=new T,Mu=new T,bu=new T,Ca=new T,Ra=new T,La=new T,Pa=new K,Da=new K,Ia=new K,Su=new T,Na=new T,oe=class extends kt{constructor(t=new Ht,e=new ki){super(),this.type="Mesh",this.geometry=t,this.material=e,this.updateMorphTargets()}copy(t){return super.copy(t),t.morphTargetInfluences!==void 0&&(this.morphTargetInfluences=t.morphTargetInfluences.slice()),t.morphTargetDictionary!==void 0&&(this.morphTargetDictionary=Object.assign({},t.morphTargetDictionary)),this.material=t.material,this.geometry=t.geometry,this}updateMorphTargets(){let t=this.geometry;if(t.isBufferGeometry){let e=t.morphAttributes,i=Object.keys(e);if(i.length>0){let r=e[i[0]];if(r!==void 0){this.morphTargetInfluences=[],this.morphTargetDictionary={};for(let s=0,o=r.length;s<o;s++){let a=r[s].name||String(s);this.morphTargetInfluences.push(0),this.morphTargetDictionary[a]=s}}}}else{let e=t.morphTargets;e!==void 0&&e.length>0&&console.error("THREE.Mesh.updateMorphTargets() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}}raycast(t,e){let i=this.geometry,r=this.material,s=this.matrixWorld;if(r===void 0||(i.boundingSphere===null&&i.computeBoundingSphere(),_u.copy(i.boundingSphere),_u.applyMatrix4(s),t.ray.intersectsSphere(_u)===!1)||(pg.copy(s).invert(),br.copy(t.ray).applyMatrix4(pg),i.boundingBox!==null&&br.intersectsBox(i.boundingBox)===!1))return;let o;if(i.isBufferGeometry){let a=i.index,l=i.attributes.position,c=i.morphAttributes.position,u=i.morphTargetsRelative,h=i.attributes.uv,f=i.attributes.uv2,d=i.groups,g=i.drawRange;if(a!==null)if(Array.isArray(r))for(let x=0,v=d.length;x<v;x++){let m=d[x],p=r[m.materialIndex],b=Math.max(m.start,g.start),_=Math.min(a.count,Math.min(m.start+m.count,g.start+g.count));for(let S=b,L=_;S<L;S+=3){let A=a.getX(S),H=a.getX(S+1),tt=a.getX(S+2);o=Fa(this,p,t,br,l,c,u,h,f,A,H,tt),o&&(o.faceIndex=Math.floor(S/3),o.face.materialIndex=m.materialIndex,e.push(o))}}else{let x=Math.max(0,g.start),v=Math.min(a.count,g.start+g.count);for(let m=x,p=v;m<p;m+=3){let b=a.getX(m),_=a.getX(m+1),S=a.getX(m+2);o=Fa(this,r,t,br,l,c,u,h,f,b,_,S),o&&(o.faceIndex=Math.floor(m/3),e.push(o))}}else if(l!==void 0)if(Array.isArray(r))for(let x=0,v=d.length;x<v;x++){let m=d[x],p=r[m.materialIndex],b=Math.max(m.start,g.start),_=Math.min(l.count,Math.min(m.start+m.count,g.start+g.count));for(let S=b,L=_;S<L;S+=3){let A=S,H=S+1,tt=S+2;o=Fa(this,p,t,br,l,c,u,h,f,A,H,tt),o&&(o.faceIndex=Math.floor(S/3),o.face.materialIndex=m.materialIndex,e.push(o))}}else{let x=Math.max(0,g.start),v=Math.min(l.count,g.start+g.count);for(let m=x,p=v;m<p;m+=3){let b=m,_=m+1,S=m+2;o=Fa(this,r,t,br,l,c,u,h,f,b,_,S),o&&(o.faceIndex=Math.floor(m/3),e.push(o))}}}else i.isGeometry&&console.error("THREE.Mesh.raycast() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}};oe.prototype.isMesh=!0;function dM(n,t,e,i,r,s,o,a){let l;if(t.side===he?l=i.intersectTriangle(o,s,r,!0,a):l=i.intersectTriangle(r,s,o,t.side!==Hr,a),l===null)return null;Na.copy(a),Na.applyMatrix4(n.matrixWorld);let c=e.ray.origin.distanceTo(Na);return c<e.near||c>e.far?null:{distance:c,point:Na.clone(),object:n}}function Fa(n,t,e,i,r,s,o,a,l,c,u,h){Jn.fromBufferAttribute(r,c),$n.fromBufferAttribute(r,u),Kn.fromBufferAttribute(r,h);let f=n.morphTargetInfluences;if(s&&f){Ca.set(0,0,0),Ra.set(0,0,0),La.set(0,0,0);for(let g=0,x=s.length;g<x;g++){let v=f[g],m=s[g];v!==0&&(wu.fromBufferAttribute(m,c),Mu.fromBufferAttribute(m,u),bu.fromBufferAttribute(m,h),o?(Ca.addScaledVector(wu,v),Ra.addScaledVector(Mu,v),La.addScaledVector(bu,v)):(Ca.addScaledVector(wu.sub(Jn),v),Ra.addScaledVector(Mu.sub($n),v),La.addScaledVector(bu.sub(Kn),v)))}Jn.add(Ca),$n.add(Ra),Kn.add(La)}n.isSkinnedMesh&&(n.boneTransform(c,Jn),n.boneTransform(u,$n),n.boneTransform(h,Kn));let d=dM(n,t,e,i,Jn,$n,Kn,Su);if(d){a&&(Pa.fromBufferAttribute(a,c),Da.fromBufferAttribute(a,u),Ia.fromBufferAttribute(a,h),d.uv=re.getUV(Su,Jn,$n,Kn,Pa,Da,Ia,new K)),l&&(Pa.fromBufferAttribute(l,c),Da.fromBufferAttribute(l,u),Ia.fromBufferAttribute(l,h),d.uv2=re.getUV(Su,Jn,$n,Kn,Pa,Da,Ia,new K));let g={a:c,b:u,c:h,normal:new T,materialIndex:0};re.getNormal(Jn,$n,Kn,g.normal),d.face=g}return d}var Hi=class extends Ht{constructor(t=1,e=1,i=1,r=1,s=1,o=1){super(),this.type="BoxGeometry",this.parameters={width:t,height:e,depth:i,widthSegments:r,heightSegments:s,depthSegments:o};let a=this;r=Math.floor(r),s=Math.floor(s),o=Math.floor(o);let l=[],c=[],u=[],h=[],f=0,d=0;g("z","y","x",-1,-1,i,e,t,o,s,0),g("z","y","x",1,-1,i,e,-t,o,s,1),g("x","z","y",1,1,t,i,e,r,o,2),g("x","z","y",1,-1,t,i,-e,r,o,3),g("x","y","z",1,-1,t,e,i,r,s,4),g("x","y","z",-1,-1,t,e,-i,r,s,5),this.setIndex(l),this.setAttribute("position",new ee(c,3)),this.setAttribute("normal",new ee(u,3)),this.setAttribute("uv",new ee(h,2));function g(x,v,m,p,b,_,S,L,A,H,tt){let X=_/A,y=S/H,R=_/2,D=S/2,F=L/2,z=A+1,N=H+1,V=0,Q=0,at=new T;for(let G=0;G<N;G++){let $=G*y-D;for(let lt=0;lt<z;lt++){let dt=lt*X-R;at[x]=dt*p,at[v]=$*b,at[m]=F,c.push(at.x,at.y,at.z),at[x]=0,at[v]=0,at[m]=L>0?1:-1,u.push(at.x,at.y,at.z),h.push(lt/A),h.push(1-G/H),V+=1}}for(let G=0;G<H;G++)for(let $=0;$<A;$++){let lt=f+$+z*G,dt=f+$+z*(G+1),xt=f+($+1)+z*(G+1),k=f+($+1)+z*G;l.push(lt,dt,k),l.push(dt,xt,k),Q+=6}a.addGroup(d,Q,tt),d+=Q,f+=V}}static fromJSON(t){return new Hi(t.width,t.height,t.depth,t.widthSegments,t.heightSegments,t.depthSegments)}};function Gr(n){let t={};for(let e in n){t[e]={};for(let i in n[e]){let r=n[e][i];r&&(r.isColor||r.isMatrix3||r.isMatrix4||r.isVector2||r.isVector3||r.isVector4||r.isTexture||r.isQuaternion)?t[e][i]=r.clone():Array.isArray(r)?t[e][i]=r.slice():t[e][i]=r}}return t}function Me(n){let t={};for(let e=0;e<n.length;e++){let i=Gr(n[e]);for(let r in i)t[r]=i[r]}return t}var pM={clone:Gr,merge:Me},mM=`void main() {
	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
}`,gM=`void main() {
	gl_FragColor = vec4( 1.0, 0.0, 0.0, 1.0 );
}`,Fn=class extends xe{constructor(t){super(),this.type="ShaderMaterial",this.defines={},this.uniforms={},this.vertexShader=mM,this.fragmentShader=gM,this.linewidth=1,this.wireframe=!1,this.wireframeLinewidth=1,this.fog=!1,this.lights=!1,this.clipping=!1,this.extensions={derivatives:!1,fragDepth:!1,drawBuffers:!1,shaderTextureLOD:!1},this.defaultAttributeValues={color:[1,1,1],uv:[0,0],uv2:[0,0]},this.index0AttributeName=void 0,this.uniformsNeedUpdate=!1,this.glslVersion=null,t!==void 0&&(t.attributes!==void 0&&console.error("THREE.ShaderMaterial: attributes should now be defined in THREE.BufferGeometry instead."),this.setValues(t))}copy(t){return super.copy(t),this.fragmentShader=t.fragmentShader,this.vertexShader=t.vertexShader,this.uniforms=Gr(t.uniforms),this.defines=Object.assign({},t.defines),this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.lights=t.lights,this.clipping=t.clipping,this.extensions=Object.assign({},t.extensions),this.glslVersion=t.glslVersion,this}toJSON(t){let e=super.toJSON(t);e.glslVersion=this.glslVersion,e.uniforms={};for(let r in this.uniforms){let o=this.uniforms[r].value;o&&o.isTexture?e.uniforms[r]={type:"t",value:o.toJSON(t).uuid}:o&&o.isColor?e.uniforms[r]={type:"c",value:o.getHex()}:o&&o.isVector2?e.uniforms[r]={type:"v2",value:o.toArray()}:o&&o.isVector3?e.uniforms[r]={type:"v3",value:o.toArray()}:o&&o.isVector4?e.uniforms[r]={type:"v4",value:o.toArray()}:o&&o.isMatrix3?e.uniforms[r]={type:"m3",value:o.toArray()}:o&&o.isMatrix4?e.uniforms[r]={type:"m4",value:o.toArray()}:e.uniforms[r]={value:o}}Object.keys(this.defines).length>0&&(e.defines=this.defines),e.vertexShader=this.vertexShader,e.fragmentShader=this.fragmentShader;let i={};for(let r in this.extensions)this.extensions[r]===!0&&(i[r]=!0);return Object.keys(i).length>0&&(e.extensions=i),e}};Fn.prototype.isShaderMaterial=!0;var oo=class extends kt{constructor(){super(),this.type="Camera",this.matrixWorldInverse=new wt,this.projectionMatrix=new wt,this.projectionMatrixInverse=new wt}copy(t,e){return super.copy(t,e),this.matrixWorldInverse.copy(t.matrixWorldInverse),this.projectionMatrix.copy(t.projectionMatrix),this.projectionMatrixInverse.copy(t.projectionMatrixInverse),this}getWorldDirection(t){this.updateWorldMatrix(!0,!1);let e=this.matrixWorld.elements;return t.set(-e[8],-e[9],-e[10]).normalize()}updateMatrixWorld(t){super.updateMatrixWorld(t),this.matrixWorldInverse.copy(this.matrixWorld).invert()}updateWorldMatrix(t,e){super.updateWorldMatrix(t,e),this.matrixWorldInverse.copy(this.matrixWorld).invert()}clone(){return new this.constructor().copy(this)}};oo.prototype.isCamera=!0;var Se=class extends oo{constructor(t=50,e=1,i=.1,r=2e3){super(),this.type="PerspectiveCamera",this.fov=t,this.zoom=1,this.near=i,this.far=r,this.focus=10,this.aspect=e,this.view=null,this.filmGauge=35,this.filmOffset=0,this.updateProjectionMatrix()}copy(t,e){return super.copy(t,e),this.fov=t.fov,this.zoom=t.zoom,this.near=t.near,this.far=t.far,this.focus=t.focus,this.aspect=t.aspect,this.view=t.view===null?null:Object.assign({},t.view),this.filmGauge=t.filmGauge,this.filmOffset=t.filmOffset,this}setFocalLength(t){let e=.5*this.getFilmHeight()/t;this.fov=Vu*2*Math.atan(e),this.updateProjectionMatrix()}getFocalLength(){let t=Math.tan(iu*.5*this.fov);return .5*this.getFilmHeight()/t}getEffectiveFOV(){return Vu*2*Math.atan(Math.tan(iu*.5*this.fov)/this.zoom)}getFilmWidth(){return this.filmGauge*Math.min(this.aspect,1)}getFilmHeight(){return this.filmGauge/Math.max(this.aspect,1)}setViewOffset(t,e,i,r,s,o){this.aspect=t/e,this.view===null&&(this.view={enabled:!0,fullWidth:1,fullHeight:1,offsetX:0,offsetY:0,width:1,height:1}),this.view.enabled=!0,this.view.fullWidth=t,this.view.fullHeight=e,this.view.offsetX=i,this.view.offsetY=r,this.view.width=s,this.view.height=o,this.updateProjectionMatrix()}clearViewOffset(){this.view!==null&&(this.view.enabled=!1),this.updateProjectionMatrix()}updateProjectionMatrix(){let t=this.near,e=t*Math.tan(iu*.5*this.fov)/this.zoom,i=2*e,r=this.aspect*i,s=-.5*r,o=this.view;if(this.view!==null&&this.view.enabled){let l=o.fullWidth,c=o.fullHeight;s+=o.offsetX*r/l,e-=o.offsetY*i/c,r*=o.width/l,i*=o.height/c}let a=this.filmOffset;a!==0&&(s+=t*a/this.getFilmWidth()),this.projectionMatrix.makePerspective(s,s+r,e,e-i,t,this.far),this.projectionMatrixInverse.copy(this.projectionMatrix).invert()}toJSON(t){let e=super.toJSON(t);return e.object.fov=this.fov,e.object.zoom=this.zoom,e.object.near=this.near,e.object.far=this.far,e.object.focus=this.focus,e.object.aspect=this.aspect,this.view!==null&&(e.object.view=Object.assign({},this.view)),e.object.filmGauge=this.filmGauge,e.object.filmOffset=this.filmOffset,e}};Se.prototype.isPerspectiveCamera=!0;var Sr=90,Er=1,ao=class extends kt{constructor(t,e,i){if(super(),this.type="CubeCamera",i.isWebGLCubeRenderTarget!==!0){console.error("THREE.CubeCamera: The constructor now expects an instance of WebGLCubeRenderTarget as third parameter.");return}this.renderTarget=i;let r=new Se(Sr,Er,t,e);r.layers=this.layers,r.up.set(0,-1,0),r.lookAt(new T(1,0,0)),this.add(r);let s=new Se(Sr,Er,t,e);s.layers=this.layers,s.up.set(0,-1,0),s.lookAt(new T(-1,0,0)),this.add(s);let o=new Se(Sr,Er,t,e);o.layers=this.layers,o.up.set(0,0,1),o.lookAt(new T(0,1,0)),this.add(o);let a=new Se(Sr,Er,t,e);a.layers=this.layers,a.up.set(0,0,-1),a.lookAt(new T(0,-1,0)),this.add(a);let l=new Se(Sr,Er,t,e);l.layers=this.layers,l.up.set(0,-1,0),l.lookAt(new T(0,0,1)),this.add(l);let c=new Se(Sr,Er,t,e);c.layers=this.layers,c.up.set(0,-1,0),c.lookAt(new T(0,0,-1)),this.add(c)}update(t,e){this.parent===null&&this.updateMatrixWorld();let i=this.renderTarget,[r,s,o,a,l,c]=this.children,u=t.xr.enabled,h=t.getRenderTarget();t.xr.enabled=!1;let f=i.texture.generateMipmaps;i.texture.generateMipmaps=!1,t.setRenderTarget(i,0),t.render(e,r),t.setRenderTarget(i,1),t.render(e,s),t.setRenderTarget(i,2),t.render(e,o),t.setRenderTarget(i,3),t.render(e,a),t.setRenderTarget(i,4),t.render(e,l),i.texture.generateMipmaps=f,t.setRenderTarget(i,5),t.render(e,c),t.setRenderTarget(h),t.xr.enabled=u,i.texture.needsPMREMUpdate=!0}},Wr=class extends ae{constructor(t,e,i,r,s,o,a,l,c,u){t=t!==void 0?t:[],e=e!==void 0?e:Ao,super(t,e,i,r,s,o,a,l,c,u),this.flipY=!1}get images(){return this.image}set images(t){this.image=t}};Wr.prototype.isCubeTexture=!0;var ol=class extends Ne{constructor(t,e,i){Number.isInteger(e)&&(console.warn("THREE.WebGLCubeRenderTarget: constructor signature is now WebGLCubeRenderTarget( size, options )"),e=i),super(t,t,e),e=e||{},this.texture=new Wr(void 0,e.mapping,e.wrapS,e.wrapT,e.magFilter,e.minFilter,e.format,e.type,e.anisotropy,e.encoding),this.texture.isRenderTargetTexture=!0,this.texture.generateMipmaps=e.generateMipmaps!==void 0?e.generateMipmaps:!1,this.texture.minFilter=e.minFilter!==void 0?e.minFilter:be}fromEquirectangularTexture(t,e){this.texture.type=e.type,this.texture.format=Re,this.texture.encoding=e.encoding,this.texture.generateMipmaps=e.generateMipmaps,this.texture.minFilter=e.minFilter,this.texture.magFilter=e.magFilter;let i={uniforms:{tEquirect:{value:null}},vertexShader:`

				varying vec3 vWorldDirection;

				vec3 transformDirection( in vec3 dir, in mat4 matrix ) {

					return normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );

				}

				void main() {

					vWorldDirection = transformDirection( position, modelMatrix );

					#include <begin_vertex>
					#include <project_vertex>

				}
			`,fragmentShader:`

				uniform sampler2D tEquirect;

				varying vec3 vWorldDirection;

				#include <common>

				void main() {

					vec3 direction = normalize( vWorldDirection );

					vec2 sampleUV = equirectUv( direction );

					gl_FragColor = texture2D( tEquirect, sampleUV );

				}
			`},r=new Hi(5,5,5),s=new Fn({name:"CubemapFromEquirect",uniforms:Gr(i.uniforms),vertexShader:i.vertexShader,fragmentShader:i.fragmentShader,side:he,blending:jn});s.uniforms.tEquirect.value=e;let o=new oe(r,s),a=e.minFilter;return e.minFilter===Ll&&(e.minFilter=be),new ao(1,10,this).update(t,o),e.minFilter=a,o.geometry.dispose(),o.material.dispose(),this}clear(t,e,i,r){let s=t.getRenderTarget();for(let o=0;o<6;o++)t.setRenderTarget(this,o),t.clear(e,i,r);t.setRenderTarget(s)}};ol.prototype.isWebGLCubeRenderTarget=!0;var Eu=new T,xM=new T,yM=new de,je=class{constructor(t=new T(1,0,0),e=0){this.normal=t,this.constant=e}set(t,e){return this.normal.copy(t),this.constant=e,this}setComponents(t,e,i,r){return this.normal.set(t,e,i),this.constant=r,this}setFromNormalAndCoplanarPoint(t,e){return this.normal.copy(t),this.constant=-e.dot(this.normal),this}setFromCoplanarPoints(t,e,i){let r=Eu.subVectors(i,e).cross(xM.subVectors(t,e)).normalize();return this.setFromNormalAndCoplanarPoint(r,t),this}copy(t){return this.normal.copy(t.normal),this.constant=t.constant,this}normalize(){let t=1/this.normal.length();return this.normal.multiplyScalar(t),this.constant*=t,this}negate(){return this.constant*=-1,this.normal.negate(),this}distanceToPoint(t){return this.normal.dot(t)+this.constant}distanceToSphere(t){return this.distanceToPoint(t.center)-t.radius}projectPoint(t,e){return e.copy(this.normal).multiplyScalar(-this.distanceToPoint(t)).add(t)}intersectLine(t,e){let i=t.delta(Eu),r=this.normal.dot(i);if(r===0)return this.distanceToPoint(t.start)===0?e.copy(t.start):null;let s=-(t.start.dot(this.normal)+this.constant)/r;return s<0||s>1?null:e.copy(i).multiplyScalar(s).add(t.start)}intersectsLine(t){let e=this.distanceToPoint(t.start),i=this.distanceToPoint(t.end);return e<0&&i>0||i<0&&e>0}intersectsBox(t){return t.intersectsPlane(this)}intersectsSphere(t){return t.intersectsPlane(this)}coplanarPoint(t){return t.copy(this.normal).multiplyScalar(-this.constant)}applyMatrix4(t,e){let i=e||yM.getNormalMatrix(t),r=this.coplanarPoint(Eu).applyMatrix4(t),s=this.normal.applyMatrix3(i).normalize();return this.constant=-r.dot(s),this}translate(t){return this.constant-=t.dot(this.normal),this}equals(t){return t.normal.equals(this.normal)&&t.constant===this.constant}clone(){return new this.constructor().copy(this)}};je.prototype.isPlane=!0;var Tr=new si,za=new T,qr=class{constructor(t=new je,e=new je,i=new je,r=new je,s=new je,o=new je){this.planes=[t,e,i,r,s,o]}set(t,e,i,r,s,o){let a=this.planes;return a[0].copy(t),a[1].copy(e),a[2].copy(i),a[3].copy(r),a[4].copy(s),a[5].copy(o),this}copy(t){let e=this.planes;for(let i=0;i<6;i++)e[i].copy(t.planes[i]);return this}setFromProjectionMatrix(t){let e=this.planes,i=t.elements,r=i[0],s=i[1],o=i[2],a=i[3],l=i[4],c=i[5],u=i[6],h=i[7],f=i[8],d=i[9],g=i[10],x=i[11],v=i[12],m=i[13],p=i[14],b=i[15];return e[0].setComponents(a-r,h-l,x-f,b-v).normalize(),e[1].setComponents(a+r,h+l,x+f,b+v).normalize(),e[2].setComponents(a+s,h+c,x+d,b+m).normalize(),e[3].setComponents(a-s,h-c,x-d,b-m).normalize(),e[4].setComponents(a-o,h-u,x-g,b-p).normalize(),e[5].setComponents(a+o,h+u,x+g,b+p).normalize(),this}intersectsObject(t){let e=t.geometry;return e.boundingSphere===null&&e.computeBoundingSphere(),Tr.copy(e.boundingSphere).applyMatrix4(t.matrixWorld),this.intersectsSphere(Tr)}intersectsSprite(t){return Tr.center.set(0,0,0),Tr.radius=.7071067811865476,Tr.applyMatrix4(t.matrixWorld),this.intersectsSphere(Tr)}intersectsSphere(t){let e=this.planes,i=t.center,r=-t.radius;for(let s=0;s<6;s++)if(e[s].distanceToPoint(i)<r)return!1;return!0}intersectsBox(t){let e=this.planes;for(let i=0;i<6;i++){let r=e[i];if(za.x=r.normal.x>0?t.max.x:t.min.x,za.y=r.normal.y>0?t.max.y:t.min.y,za.z=r.normal.z>0?t.max.z:t.min.z,r.distanceToPoint(za)<0)return!1}return!0}containsPoint(t){let e=this.planes;for(let i=0;i<6;i++)if(e[i].distanceToPoint(t)<0)return!1;return!0}clone(){return new this.constructor().copy(this)}};function g0(){let n=null,t=!1,e=null,i=null;function r(s,o){e(s,o),i=n.requestAnimationFrame(r)}return{start:function(){t!==!0&&e!==null&&(i=n.requestAnimationFrame(r),t=!0)},stop:function(){n.cancelAnimationFrame(i),t=!1},setAnimationLoop:function(s){e=s},setContext:function(s){n=s}}}function vM(n,t){let e=t.isWebGL2,i=new WeakMap;function r(c,u){let h=c.array,f=c.usage,d=n.createBuffer();n.bindBuffer(u,d),n.bufferData(u,h,f),c.onUploadCallback();let g=5126;return h instanceof Float32Array?g=5126:h instanceof Float64Array?console.warn("THREE.WebGLAttributes: Unsupported data buffer format: Float64Array."):h instanceof Uint16Array?c.isFloat16BufferAttribute?e?g=5131:console.warn("THREE.WebGLAttributes: Usage of Float16BufferAttribute requires WebGL2."):g=5123:h instanceof Int16Array?g=5122:h instanceof Uint32Array?g=5125:h instanceof Int32Array?g=5124:h instanceof Int8Array?g=5120:(h instanceof Uint8Array||h instanceof Uint8ClampedArray)&&(g=5121),{buffer:d,type:g,bytesPerElement:h.BYTES_PER_ELEMENT,version:c.version}}function s(c,u,h){let f=u.array,d=u.updateRange;n.bindBuffer(h,c),d.count===-1?n.bufferSubData(h,0,f):(e?n.bufferSubData(h,d.offset*f.BYTES_PER_ELEMENT,f,d.offset,d.count):n.bufferSubData(h,d.offset*f.BYTES_PER_ELEMENT,f.subarray(d.offset,d.offset+d.count)),d.count=-1)}function o(c){return c.isInterleavedBufferAttribute&&(c=c.data),i.get(c)}function a(c){c.isInterleavedBufferAttribute&&(c=c.data);let u=i.get(c);u&&(n.deleteBuffer(u.buffer),i.delete(c))}function l(c,u){if(c.isGLBufferAttribute){let f=i.get(c);(!f||f.version<c.version)&&i.set(c,{buffer:c.buffer,type:c.type,bytesPerElement:c.elementSize,version:c.version});return}c.isInterleavedBufferAttribute&&(c=c.data);let h=i.get(c);h===void 0?i.set(c,r(c,u)):h.version<c.version&&(s(h.buffer,c,u),h.version=c.version)}return{get:o,remove:a,update:l}}var lo=class extends Ht{constructor(t=1,e=1,i=1,r=1){super(),this.type="PlaneGeometry",this.parameters={width:t,height:e,widthSegments:i,heightSegments:r};let s=t/2,o=e/2,a=Math.floor(i),l=Math.floor(r),c=a+1,u=l+1,h=t/a,f=e/l,d=[],g=[],x=[],v=[];for(let m=0;m<u;m++){let p=m*f-o;for(let b=0;b<c;b++){let _=b*h-s;g.push(_,-p,0),x.push(0,0,1),v.push(b/a),v.push(1-m/l)}}for(let m=0;m<l;m++)for(let p=0;p<a;p++){let b=p+c*m,_=p+c*(m+1),S=p+1+c*(m+1),L=p+1+c*m;d.push(b,_,L),d.push(_,S,L)}this.setIndex(d),this.setAttribute("position",new ee(g,3)),this.setAttribute("normal",new ee(x,3)),this.setAttribute("uv",new ee(v,2))}static fromJSON(t){return new lo(t.width,t.height,t.widthSegments,t.heightSegments)}},_M=`#ifdef USE_ALPHAMAP
	diffuseColor.a *= texture2D( alphaMap, vUv ).g;
#endif`,wM=`#ifdef USE_ALPHAMAP
	uniform sampler2D alphaMap;
#endif`,MM=`#ifdef USE_ALPHATEST
	if ( diffuseColor.a < alphaTest ) discard;
#endif`,bM=`#ifdef USE_ALPHATEST
	uniform float alphaTest;
#endif`,SM=`#ifdef USE_AOMAP
	float ambientOcclusion = ( texture2D( aoMap, vUv2 ).r - 1.0 ) * aoMapIntensity + 1.0;
	reflectedLight.indirectDiffuse *= ambientOcclusion;
	#if defined( USE_ENVMAP ) && defined( STANDARD )
		float dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );
		reflectedLight.indirectSpecular *= computeSpecularOcclusion( dotNV, ambientOcclusion, material.roughness );
	#endif
#endif`,EM=`#ifdef USE_AOMAP
	uniform sampler2D aoMap;
	uniform float aoMapIntensity;
#endif`,TM="vec3 transformed = vec3( position );",AM=`vec3 objectNormal = vec3( normal );
#ifdef USE_TANGENT
	vec3 objectTangent = vec3( tangent.xyz );
#endif`,CM=`vec3 BRDF_Lambert( const in vec3 diffuseColor ) {
	return RECIPROCAL_PI * diffuseColor;
}
vec3 F_Schlick( const in vec3 f0, const in float f90, const in float dotVH ) {
	float fresnel = exp2( ( - 5.55473 * dotVH - 6.98316 ) * dotVH );
	return f0 * ( 1.0 - fresnel ) + ( f90 * fresnel );
}
float V_GGX_SmithCorrelated( const in float alpha, const in float dotNL, const in float dotNV ) {
	float a2 = pow2( alpha );
	float gv = dotNL * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );
	float gl = dotNV * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );
	return 0.5 / max( gv + gl, EPSILON );
}
float D_GGX( const in float alpha, const in float dotNH ) {
	float a2 = pow2( alpha );
	float denom = pow2( dotNH ) * ( a2 - 1.0 ) + 1.0;
	return RECIPROCAL_PI * a2 / pow2( denom );
}
vec3 BRDF_GGX( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in vec3 f0, const in float f90, const in float roughness ) {
	float alpha = pow2( roughness );
	vec3 halfDir = normalize( lightDir + viewDir );
	float dotNL = saturate( dot( normal, lightDir ) );
	float dotNV = saturate( dot( normal, viewDir ) );
	float dotNH = saturate( dot( normal, halfDir ) );
	float dotVH = saturate( dot( viewDir, halfDir ) );
	vec3 F = F_Schlick( f0, f90, dotVH );
	float V = V_GGX_SmithCorrelated( alpha, dotNL, dotNV );
	float D = D_GGX( alpha, dotNH );
	return F * ( V * D );
}
vec2 LTC_Uv( const in vec3 N, const in vec3 V, const in float roughness ) {
	const float LUT_SIZE = 64.0;
	const float LUT_SCALE = ( LUT_SIZE - 1.0 ) / LUT_SIZE;
	const float LUT_BIAS = 0.5 / LUT_SIZE;
	float dotNV = saturate( dot( N, V ) );
	vec2 uv = vec2( roughness, sqrt( 1.0 - dotNV ) );
	uv = uv * LUT_SCALE + LUT_BIAS;
	return uv;
}
float LTC_ClippedSphereFormFactor( const in vec3 f ) {
	float l = length( f );
	return max( ( l * l + f.z ) / ( l + 1.0 ), 0.0 );
}
vec3 LTC_EdgeVectorFormFactor( const in vec3 v1, const in vec3 v2 ) {
	float x = dot( v1, v2 );
	float y = abs( x );
	float a = 0.8543985 + ( 0.4965155 + 0.0145206 * y ) * y;
	float b = 3.4175940 + ( 4.1616724 + y ) * y;
	float v = a / b;
	float theta_sintheta = ( x > 0.0 ) ? v : 0.5 * inversesqrt( max( 1.0 - x * x, 1e-7 ) ) - v;
	return cross( v1, v2 ) * theta_sintheta;
}
vec3 LTC_Evaluate( const in vec3 N, const in vec3 V, const in vec3 P, const in mat3 mInv, const in vec3 rectCoords[ 4 ] ) {
	vec3 v1 = rectCoords[ 1 ] - rectCoords[ 0 ];
	vec3 v2 = rectCoords[ 3 ] - rectCoords[ 0 ];
	vec3 lightNormal = cross( v1, v2 );
	if( dot( lightNormal, P - rectCoords[ 0 ] ) < 0.0 ) return vec3( 0.0 );
	vec3 T1, T2;
	T1 = normalize( V - N * dot( V, N ) );
	T2 = - cross( N, T1 );
	mat3 mat = mInv * transposeMat3( mat3( T1, T2, N ) );
	vec3 coords[ 4 ];
	coords[ 0 ] = mat * ( rectCoords[ 0 ] - P );
	coords[ 1 ] = mat * ( rectCoords[ 1 ] - P );
	coords[ 2 ] = mat * ( rectCoords[ 2 ] - P );
	coords[ 3 ] = mat * ( rectCoords[ 3 ] - P );
	coords[ 0 ] = normalize( coords[ 0 ] );
	coords[ 1 ] = normalize( coords[ 1 ] );
	coords[ 2 ] = normalize( coords[ 2 ] );
	coords[ 3 ] = normalize( coords[ 3 ] );
	vec3 vectorFormFactor = vec3( 0.0 );
	vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 0 ], coords[ 1 ] );
	vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 1 ], coords[ 2 ] );
	vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 2 ], coords[ 3 ] );
	vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 3 ], coords[ 0 ] );
	float result = LTC_ClippedSphereFormFactor( vectorFormFactor );
	return vec3( result );
}
float G_BlinnPhong_Implicit( ) {
	return 0.25;
}
float D_BlinnPhong( const in float shininess, const in float dotNH ) {
	return RECIPROCAL_PI * ( shininess * 0.5 + 1.0 ) * pow( dotNH, shininess );
}
vec3 BRDF_BlinnPhong( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in vec3 specularColor, const in float shininess ) {
	vec3 halfDir = normalize( lightDir + viewDir );
	float dotNH = saturate( dot( normal, halfDir ) );
	float dotVH = saturate( dot( viewDir, halfDir ) );
	vec3 F = F_Schlick( specularColor, 1.0, dotVH );
	float G = G_BlinnPhong_Implicit( );
	float D = D_BlinnPhong( shininess, dotNH );
	return F * ( G * D );
}
#if defined( USE_SHEEN )
float D_Charlie( float roughness, float dotNH ) {
	float alpha = pow2( roughness );
	float invAlpha = 1.0 / alpha;
	float cos2h = dotNH * dotNH;
	float sin2h = max( 1.0 - cos2h, 0.0078125 );
	return ( 2.0 + invAlpha ) * pow( sin2h, invAlpha * 0.5 ) / ( 2.0 * PI );
}
float V_Neubelt( float dotNV, float dotNL ) {
	return saturate( 1.0 / ( 4.0 * ( dotNL + dotNV - dotNL * dotNV ) ) );
}
vec3 BRDF_Sheen( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, vec3 sheenColor, const in float sheenRoughness ) {
	vec3 halfDir = normalize( lightDir + viewDir );
	float dotNL = saturate( dot( normal, lightDir ) );
	float dotNV = saturate( dot( normal, viewDir ) );
	float dotNH = saturate( dot( normal, halfDir ) );
	float D = D_Charlie( sheenRoughness, dotNH );
	float V = V_Neubelt( dotNV, dotNL );
	return sheenColor * ( D * V );
}
#endif`,RM=`#ifdef USE_BUMPMAP
	uniform sampler2D bumpMap;
	uniform float bumpScale;
	vec2 dHdxy_fwd() {
		vec2 dSTdx = dFdx( vUv );
		vec2 dSTdy = dFdy( vUv );
		float Hll = bumpScale * texture2D( bumpMap, vUv ).x;
		float dBx = bumpScale * texture2D( bumpMap, vUv + dSTdx ).x - Hll;
		float dBy = bumpScale * texture2D( bumpMap, vUv + dSTdy ).x - Hll;
		return vec2( dBx, dBy );
	}
	vec3 perturbNormalArb( vec3 surf_pos, vec3 surf_norm, vec2 dHdxy, float faceDirection ) {
		vec3 vSigmaX = vec3( dFdx( surf_pos.x ), dFdx( surf_pos.y ), dFdx( surf_pos.z ) );
		vec3 vSigmaY = vec3( dFdy( surf_pos.x ), dFdy( surf_pos.y ), dFdy( surf_pos.z ) );
		vec3 vN = surf_norm;
		vec3 R1 = cross( vSigmaY, vN );
		vec3 R2 = cross( vN, vSigmaX );
		float fDet = dot( vSigmaX, R1 ) * faceDirection;
		vec3 vGrad = sign( fDet ) * ( dHdxy.x * R1 + dHdxy.y * R2 );
		return normalize( abs( fDet ) * surf_norm - vGrad );
	}
#endif`,LM=`#if NUM_CLIPPING_PLANES > 0
	vec4 plane;
	#pragma unroll_loop_start
	for ( int i = 0; i < UNION_CLIPPING_PLANES; i ++ ) {
		plane = clippingPlanes[ i ];
		if ( dot( vClipPosition, plane.xyz ) > plane.w ) discard;
	}
	#pragma unroll_loop_end
	#if UNION_CLIPPING_PLANES < NUM_CLIPPING_PLANES
		bool clipped = true;
		#pragma unroll_loop_start
		for ( int i = UNION_CLIPPING_PLANES; i < NUM_CLIPPING_PLANES; i ++ ) {
			plane = clippingPlanes[ i ];
			clipped = ( dot( vClipPosition, plane.xyz ) > plane.w ) && clipped;
		}
		#pragma unroll_loop_end
		if ( clipped ) discard;
	#endif
#endif`,PM=`#if NUM_CLIPPING_PLANES > 0
	varying vec3 vClipPosition;
	uniform vec4 clippingPlanes[ NUM_CLIPPING_PLANES ];
#endif`,DM=`#if NUM_CLIPPING_PLANES > 0
	varying vec3 vClipPosition;
#endif`,IM=`#if NUM_CLIPPING_PLANES > 0
	vClipPosition = - mvPosition.xyz;
#endif`,NM=`#if defined( USE_COLOR_ALPHA )
	diffuseColor *= vColor;
#elif defined( USE_COLOR )
	diffuseColor.rgb *= vColor;
#endif`,FM=`#if defined( USE_COLOR_ALPHA )
	varying vec4 vColor;
#elif defined( USE_COLOR )
	varying vec3 vColor;
#endif`,zM=`#if defined( USE_COLOR_ALPHA )
	varying vec4 vColor;
#elif defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR )
	varying vec3 vColor;
#endif`,UM=`#if defined( USE_COLOR_ALPHA )
	vColor = vec4( 1.0 );
#elif defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR )
	vColor = vec3( 1.0 );
#endif
#ifdef USE_COLOR
	vColor *= color;
#endif
#ifdef USE_INSTANCING_COLOR
	vColor.xyz *= instanceColor.xyz;
#endif`,BM=`#define PI 3.141592653589793
#define PI2 6.283185307179586
#define PI_HALF 1.5707963267948966
#define RECIPROCAL_PI 0.3183098861837907
#define RECIPROCAL_PI2 0.15915494309189535
#define EPSILON 1e-6
#ifndef saturate
#define saturate( a ) clamp( a, 0.0, 1.0 )
#endif
#define whiteComplement( a ) ( 1.0 - saturate( a ) )
float pow2( const in float x ) { return x*x; }
float pow3( const in float x ) { return x*x*x; }
float pow4( const in float x ) { float x2 = x*x; return x2*x2; }
float max3( const in vec3 v ) { return max( max( v.x, v.y ), v.z ); }
float average( const in vec3 color ) { return dot( color, vec3( 0.3333 ) ); }
highp float rand( const in vec2 uv ) {
	const highp float a = 12.9898, b = 78.233, c = 43758.5453;
	highp float dt = dot( uv.xy, vec2( a,b ) ), sn = mod( dt, PI );
	return fract( sin( sn ) * c );
}
#ifdef HIGH_PRECISION
	float precisionSafeLength( vec3 v ) { return length( v ); }
#else
	float precisionSafeLength( vec3 v ) {
		float maxComponent = max3( abs( v ) );
		return length( v / maxComponent ) * maxComponent;
	}
#endif
struct IncidentLight {
	vec3 color;
	vec3 direction;
	bool visible;
};
struct ReflectedLight {
	vec3 directDiffuse;
	vec3 directSpecular;
	vec3 indirectDiffuse;
	vec3 indirectSpecular;
};
struct GeometricContext {
	vec3 position;
	vec3 normal;
	vec3 viewDir;
#ifdef USE_CLEARCOAT
	vec3 clearcoatNormal;
#endif
};
vec3 transformDirection( in vec3 dir, in mat4 matrix ) {
	return normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );
}
vec3 inverseTransformDirection( in vec3 dir, in mat4 matrix ) {
	return normalize( ( vec4( dir, 0.0 ) * matrix ).xyz );
}
mat3 transposeMat3( const in mat3 m ) {
	mat3 tmp;
	tmp[ 0 ] = vec3( m[ 0 ].x, m[ 1 ].x, m[ 2 ].x );
	tmp[ 1 ] = vec3( m[ 0 ].y, m[ 1 ].y, m[ 2 ].y );
	tmp[ 2 ] = vec3( m[ 0 ].z, m[ 1 ].z, m[ 2 ].z );
	return tmp;
}
float linearToRelativeLuminance( const in vec3 color ) {
	vec3 weights = vec3( 0.2126, 0.7152, 0.0722 );
	return dot( weights, color.rgb );
}
bool isPerspectiveMatrix( mat4 m ) {
	return m[ 2 ][ 3 ] == - 1.0;
}
vec2 equirectUv( in vec3 dir ) {
	float u = atan( dir.z, dir.x ) * RECIPROCAL_PI2 + 0.5;
	float v = asin( clamp( dir.y, - 1.0, 1.0 ) ) * RECIPROCAL_PI + 0.5;
	return vec2( u, v );
}`,OM=`#ifdef ENVMAP_TYPE_CUBE_UV
	#define cubeUV_maxMipLevel 8.0
	#define cubeUV_minMipLevel 4.0
	#define cubeUV_maxTileSize 256.0
	#define cubeUV_minTileSize 16.0
	float getFace( vec3 direction ) {
		vec3 absDirection = abs( direction );
		float face = - 1.0;
		if ( absDirection.x > absDirection.z ) {
			if ( absDirection.x > absDirection.y )
				face = direction.x > 0.0 ? 0.0 : 3.0;
			else
				face = direction.y > 0.0 ? 1.0 : 4.0;
		} else {
			if ( absDirection.z > absDirection.y )
				face = direction.z > 0.0 ? 2.0 : 5.0;
			else
				face = direction.y > 0.0 ? 1.0 : 4.0;
		}
		return face;
	}
	vec2 getUV( vec3 direction, float face ) {
		vec2 uv;
		if ( face == 0.0 ) {
			uv = vec2( direction.z, direction.y ) / abs( direction.x );
		} else if ( face == 1.0 ) {
			uv = vec2( - direction.x, - direction.z ) / abs( direction.y );
		} else if ( face == 2.0 ) {
			uv = vec2( - direction.x, direction.y ) / abs( direction.z );
		} else if ( face == 3.0 ) {
			uv = vec2( - direction.z, direction.y ) / abs( direction.x );
		} else if ( face == 4.0 ) {
			uv = vec2( - direction.x, direction.z ) / abs( direction.y );
		} else {
			uv = vec2( direction.x, direction.y ) / abs( direction.z );
		}
		return 0.5 * ( uv + 1.0 );
	}
	vec3 bilinearCubeUV( sampler2D envMap, vec3 direction, float mipInt ) {
		float face = getFace( direction );
		float filterInt = max( cubeUV_minMipLevel - mipInt, 0.0 );
		mipInt = max( mipInt, cubeUV_minMipLevel );
		float faceSize = exp2( mipInt );
		float texelSize = 1.0 / ( 3.0 * cubeUV_maxTileSize );
		vec2 uv = getUV( direction, face ) * ( faceSize - 1.0 ) + 0.5;
		if ( face > 2.0 ) {
			uv.y += faceSize;
			face -= 3.0;
		}
		uv.x += face * faceSize;
		if ( mipInt < cubeUV_maxMipLevel ) {
			uv.y += 2.0 * cubeUV_maxTileSize;
		}
		uv.y += filterInt * 2.0 * cubeUV_minTileSize;
		uv.x += 3.0 * max( 0.0, cubeUV_maxTileSize - 2.0 * faceSize );
		uv *= texelSize;
		return texture2D( envMap, uv ).rgb;
	}
	#define r0 1.0
	#define v0 0.339
	#define m0 - 2.0
	#define r1 0.8
	#define v1 0.276
	#define m1 - 1.0
	#define r4 0.4
	#define v4 0.046
	#define m4 2.0
	#define r5 0.305
	#define v5 0.016
	#define m5 3.0
	#define r6 0.21
	#define v6 0.0038
	#define m6 4.0
	float roughnessToMip( float roughness ) {
		float mip = 0.0;
		if ( roughness >= r1 ) {
			mip = ( r0 - roughness ) * ( m1 - m0 ) / ( r0 - r1 ) + m0;
		} else if ( roughness >= r4 ) {
			mip = ( r1 - roughness ) * ( m4 - m1 ) / ( r1 - r4 ) + m1;
		} else if ( roughness >= r5 ) {
			mip = ( r4 - roughness ) * ( m5 - m4 ) / ( r4 - r5 ) + m4;
		} else if ( roughness >= r6 ) {
			mip = ( r5 - roughness ) * ( m6 - m5 ) / ( r5 - r6 ) + m5;
		} else {
			mip = - 2.0 * log2( 1.16 * roughness );		}
		return mip;
	}
	vec4 textureCubeUV( sampler2D envMap, vec3 sampleDir, float roughness ) {
		float mip = clamp( roughnessToMip( roughness ), m0, cubeUV_maxMipLevel );
		float mipF = fract( mip );
		float mipInt = floor( mip );
		vec3 color0 = bilinearCubeUV( envMap, sampleDir, mipInt );
		if ( mipF == 0.0 ) {
			return vec4( color0, 1.0 );
		} else {
			vec3 color1 = bilinearCubeUV( envMap, sampleDir, mipInt + 1.0 );
			return vec4( mix( color0, color1, mipF ), 1.0 );
		}
	}
#endif`,kM=`vec3 transformedNormal = objectNormal;
#ifdef USE_INSTANCING
	mat3 m = mat3( instanceMatrix );
	transformedNormal /= vec3( dot( m[ 0 ], m[ 0 ] ), dot( m[ 1 ], m[ 1 ] ), dot( m[ 2 ], m[ 2 ] ) );
	transformedNormal = m * transformedNormal;
#endif
transformedNormal = normalMatrix * transformedNormal;
#ifdef FLIP_SIDED
	transformedNormal = - transformedNormal;
#endif
#ifdef USE_TANGENT
	vec3 transformedTangent = ( modelViewMatrix * vec4( objectTangent, 0.0 ) ).xyz;
	#ifdef FLIP_SIDED
		transformedTangent = - transformedTangent;
	#endif
#endif`,HM=`#ifdef USE_DISPLACEMENTMAP
	uniform sampler2D displacementMap;
	uniform float displacementScale;
	uniform float displacementBias;
#endif`,VM=`#ifdef USE_DISPLACEMENTMAP
	transformed += normalize( objectNormal ) * ( texture2D( displacementMap, vUv ).x * displacementScale + displacementBias );
#endif`,GM=`#ifdef USE_EMISSIVEMAP
	vec4 emissiveColor = texture2D( emissiveMap, vUv );
	totalEmissiveRadiance *= emissiveColor.rgb;
#endif`,WM=`#ifdef USE_EMISSIVEMAP
	uniform sampler2D emissiveMap;
#endif`,qM="gl_FragColor = linearToOutputTexel( gl_FragColor );",XM=`vec4 LinearToLinear( in vec4 value ) {
	return value;
}
vec4 LinearTosRGB( in vec4 value ) {
	return vec4( mix( pow( value.rgb, vec3( 0.41666 ) ) * 1.055 - vec3( 0.055 ), value.rgb * 12.92, vec3( lessThanEqual( value.rgb, vec3( 0.0031308 ) ) ) ), value.a );
}`,YM=`#ifdef USE_ENVMAP
	#ifdef ENV_WORLDPOS
		vec3 cameraToFrag;
		if ( isOrthographic ) {
			cameraToFrag = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );
		} else {
			cameraToFrag = normalize( vWorldPosition - cameraPosition );
		}
		vec3 worldNormal = inverseTransformDirection( normal, viewMatrix );
		#ifdef ENVMAP_MODE_REFLECTION
			vec3 reflectVec = reflect( cameraToFrag, worldNormal );
		#else
			vec3 reflectVec = refract( cameraToFrag, worldNormal, refractionRatio );
		#endif
	#else
		vec3 reflectVec = vReflect;
	#endif
	#ifdef ENVMAP_TYPE_CUBE
		vec4 envColor = textureCube( envMap, vec3( flipEnvMap * reflectVec.x, reflectVec.yz ) );
	#elif defined( ENVMAP_TYPE_CUBE_UV )
		vec4 envColor = textureCubeUV( envMap, reflectVec, 0.0 );
	#else
		vec4 envColor = vec4( 0.0 );
	#endif
	#ifdef ENVMAP_BLENDING_MULTIPLY
		outgoingLight = mix( outgoingLight, outgoingLight * envColor.xyz, specularStrength * reflectivity );
	#elif defined( ENVMAP_BLENDING_MIX )
		outgoingLight = mix( outgoingLight, envColor.xyz, specularStrength * reflectivity );
	#elif defined( ENVMAP_BLENDING_ADD )
		outgoingLight += envColor.xyz * specularStrength * reflectivity;
	#endif
#endif`,ZM=`#ifdef USE_ENVMAP
	uniform float envMapIntensity;
	uniform float flipEnvMap;
	#ifdef ENVMAP_TYPE_CUBE
		uniform samplerCube envMap;
	#else
		uniform sampler2D envMap;
	#endif
	
#endif`,JM=`#ifdef USE_ENVMAP
	uniform float reflectivity;
	#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG )
		#define ENV_WORLDPOS
	#endif
	#ifdef ENV_WORLDPOS
		varying vec3 vWorldPosition;
		uniform float refractionRatio;
	#else
		varying vec3 vReflect;
	#endif
#endif`,$M=`#ifdef USE_ENVMAP
	#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) ||defined( PHONG )
		#define ENV_WORLDPOS
	#endif
	#ifdef ENV_WORLDPOS
		
		varying vec3 vWorldPosition;
	#else
		varying vec3 vReflect;
		uniform float refractionRatio;
	#endif
#endif`,KM=`#ifdef USE_ENVMAP
	#ifdef ENV_WORLDPOS
		vWorldPosition = worldPosition.xyz;
	#else
		vec3 cameraToVertex;
		if ( isOrthographic ) {
			cameraToVertex = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );
		} else {
			cameraToVertex = normalize( worldPosition.xyz - cameraPosition );
		}
		vec3 worldNormal = inverseTransformDirection( transformedNormal, viewMatrix );
		#ifdef ENVMAP_MODE_REFLECTION
			vReflect = reflect( cameraToVertex, worldNormal );
		#else
			vReflect = refract( cameraToVertex, worldNormal, refractionRatio );
		#endif
	#endif
#endif`,QM=`#ifdef USE_FOG
	vFogDepth = - mvPosition.z;
#endif`,jM=`#ifdef USE_FOG
	varying float vFogDepth;
#endif`,tb=`#ifdef USE_FOG
	#ifdef FOG_EXP2
		float fogFactor = 1.0 - exp( - fogDensity * fogDensity * vFogDepth * vFogDepth );
	#else
		float fogFactor = smoothstep( fogNear, fogFar, vFogDepth );
	#endif
	gl_FragColor.rgb = mix( gl_FragColor.rgb, fogColor, fogFactor );
#endif`,eb=`#ifdef USE_FOG
	uniform vec3 fogColor;
	varying float vFogDepth;
	#ifdef FOG_EXP2
		uniform float fogDensity;
	#else
		uniform float fogNear;
		uniform float fogFar;
	#endif
#endif`,nb=`#ifdef USE_GRADIENTMAP
	uniform sampler2D gradientMap;
#endif
vec3 getGradientIrradiance( vec3 normal, vec3 lightDirection ) {
	float dotNL = dot( normal, lightDirection );
	vec2 coord = vec2( dotNL * 0.5 + 0.5, 0.0 );
	#ifdef USE_GRADIENTMAP
		return vec3( texture2D( gradientMap, coord ).r );
	#else
		return ( coord.x < 0.7 ) ? vec3( 0.7 ) : vec3( 1.0 );
	#endif
}`,ib=`#ifdef USE_LIGHTMAP
	vec4 lightMapTexel = texture2D( lightMap, vUv2 );
	vec3 lightMapIrradiance = lightMapTexel.rgb * lightMapIntensity;
	#ifndef PHYSICALLY_CORRECT_LIGHTS
		lightMapIrradiance *= PI;
	#endif
	reflectedLight.indirectDiffuse += lightMapIrradiance;
#endif`,rb=`#ifdef USE_LIGHTMAP
	uniform sampler2D lightMap;
	uniform float lightMapIntensity;
#endif`,sb=`vec3 diffuse = vec3( 1.0 );
GeometricContext geometry;
geometry.position = mvPosition.xyz;
geometry.normal = normalize( transformedNormal );
geometry.viewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( -mvPosition.xyz );
GeometricContext backGeometry;
backGeometry.position = geometry.position;
backGeometry.normal = -geometry.normal;
backGeometry.viewDir = geometry.viewDir;
vLightFront = vec3( 0.0 );
vIndirectFront = vec3( 0.0 );
#ifdef DOUBLE_SIDED
	vLightBack = vec3( 0.0 );
	vIndirectBack = vec3( 0.0 );
#endif
IncidentLight directLight;
float dotNL;
vec3 directLightColor_Diffuse;
vIndirectFront += getAmbientLightIrradiance( ambientLightColor );
vIndirectFront += getLightProbeIrradiance( lightProbe, geometry.normal );
#ifdef DOUBLE_SIDED
	vIndirectBack += getAmbientLightIrradiance( ambientLightColor );
	vIndirectBack += getLightProbeIrradiance( lightProbe, backGeometry.normal );
#endif
#if NUM_POINT_LIGHTS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {
		getPointLightInfo( pointLights[ i ], geometry, directLight );
		dotNL = dot( geometry.normal, directLight.direction );
		directLightColor_Diffuse = directLight.color;
		vLightFront += saturate( dotNL ) * directLightColor_Diffuse;
		#ifdef DOUBLE_SIDED
			vLightBack += saturate( - dotNL ) * directLightColor_Diffuse;
		#endif
	}
	#pragma unroll_loop_end
#endif
#if NUM_SPOT_LIGHTS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {
		getSpotLightInfo( spotLights[ i ], geometry, directLight );
		dotNL = dot( geometry.normal, directLight.direction );
		directLightColor_Diffuse = directLight.color;
		vLightFront += saturate( dotNL ) * directLightColor_Diffuse;
		#ifdef DOUBLE_SIDED
			vLightBack += saturate( - dotNL ) * directLightColor_Diffuse;
		#endif
	}
	#pragma unroll_loop_end
#endif
#if NUM_DIR_LIGHTS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {
		getDirectionalLightInfo( directionalLights[ i ], geometry, directLight );
		dotNL = dot( geometry.normal, directLight.direction );
		directLightColor_Diffuse = directLight.color;
		vLightFront += saturate( dotNL ) * directLightColor_Diffuse;
		#ifdef DOUBLE_SIDED
			vLightBack += saturate( - dotNL ) * directLightColor_Diffuse;
		#endif
	}
	#pragma unroll_loop_end
#endif
#if NUM_HEMI_LIGHTS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {
		vIndirectFront += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry.normal );
		#ifdef DOUBLE_SIDED
			vIndirectBack += getHemisphereLightIrradiance( hemisphereLights[ i ], backGeometry.normal );
		#endif
	}
	#pragma unroll_loop_end
#endif`,ob=`uniform bool receiveShadow;
uniform vec3 ambientLightColor;
uniform vec3 lightProbe[ 9 ];
vec3 shGetIrradianceAt( in vec3 normal, in vec3 shCoefficients[ 9 ] ) {
	float x = normal.x, y = normal.y, z = normal.z;
	vec3 result = shCoefficients[ 0 ] * 0.886227;
	result += shCoefficients[ 1 ] * 2.0 * 0.511664 * y;
	result += shCoefficients[ 2 ] * 2.0 * 0.511664 * z;
	result += shCoefficients[ 3 ] * 2.0 * 0.511664 * x;
	result += shCoefficients[ 4 ] * 2.0 * 0.429043 * x * y;
	result += shCoefficients[ 5 ] * 2.0 * 0.429043 * y * z;
	result += shCoefficients[ 6 ] * ( 0.743125 * z * z - 0.247708 );
	result += shCoefficients[ 7 ] * 2.0 * 0.429043 * x * z;
	result += shCoefficients[ 8 ] * 0.429043 * ( x * x - y * y );
	return result;
}
vec3 getLightProbeIrradiance( const in vec3 lightProbe[ 9 ], const in vec3 normal ) {
	vec3 worldNormal = inverseTransformDirection( normal, viewMatrix );
	vec3 irradiance = shGetIrradianceAt( worldNormal, lightProbe );
	return irradiance;
}
vec3 getAmbientLightIrradiance( const in vec3 ambientLightColor ) {
	vec3 irradiance = ambientLightColor;
	return irradiance;
}
float getDistanceAttenuation( const in float lightDistance, const in float cutoffDistance, const in float decayExponent ) {
	#if defined ( PHYSICALLY_CORRECT_LIGHTS )
		float distanceFalloff = 1.0 / max( pow( lightDistance, decayExponent ), 0.01 );
		if ( cutoffDistance > 0.0 ) {
			distanceFalloff *= pow2( saturate( 1.0 - pow4( lightDistance / cutoffDistance ) ) );
		}
		return distanceFalloff;
	#else
		if ( cutoffDistance > 0.0 && decayExponent > 0.0 ) {
			return pow( saturate( - lightDistance / cutoffDistance + 1.0 ), decayExponent );
		}
		return 1.0;
	#endif
}
float getSpotAttenuation( const in float coneCosine, const in float penumbraCosine, const in float angleCosine ) {
	return smoothstep( coneCosine, penumbraCosine, angleCosine );
}
#if NUM_DIR_LIGHTS > 0
	struct DirectionalLight {
		vec3 direction;
		vec3 color;
	};
	uniform DirectionalLight directionalLights[ NUM_DIR_LIGHTS ];
	void getDirectionalLightInfo( const in DirectionalLight directionalLight, const in GeometricContext geometry, out IncidentLight light ) {
		light.color = directionalLight.color;
		light.direction = directionalLight.direction;
		light.visible = true;
	}
#endif
#if NUM_POINT_LIGHTS > 0
	struct PointLight {
		vec3 position;
		vec3 color;
		float distance;
		float decay;
	};
	uniform PointLight pointLights[ NUM_POINT_LIGHTS ];
	void getPointLightInfo( const in PointLight pointLight, const in GeometricContext geometry, out IncidentLight light ) {
		vec3 lVector = pointLight.position - geometry.position;
		light.direction = normalize( lVector );
		float lightDistance = length( lVector );
		light.color = pointLight.color;
		light.color *= getDistanceAttenuation( lightDistance, pointLight.distance, pointLight.decay );
		light.visible = ( light.color != vec3( 0.0 ) );
	}
#endif
#if NUM_SPOT_LIGHTS > 0
	struct SpotLight {
		vec3 position;
		vec3 direction;
		vec3 color;
		float distance;
		float decay;
		float coneCos;
		float penumbraCos;
	};
	uniform SpotLight spotLights[ NUM_SPOT_LIGHTS ];
	void getSpotLightInfo( const in SpotLight spotLight, const in GeometricContext geometry, out IncidentLight light ) {
		vec3 lVector = spotLight.position - geometry.position;
		light.direction = normalize( lVector );
		float angleCos = dot( light.direction, spotLight.direction );
		float spotAttenuation = getSpotAttenuation( spotLight.coneCos, spotLight.penumbraCos, angleCos );
		if ( spotAttenuation > 0.0 ) {
			float lightDistance = length( lVector );
			light.color = spotLight.color * spotAttenuation;
			light.color *= getDistanceAttenuation( lightDistance, spotLight.distance, spotLight.decay );
			light.visible = ( light.color != vec3( 0.0 ) );
		} else {
			light.color = vec3( 0.0 );
			light.visible = false;
		}
	}
#endif
#if NUM_RECT_AREA_LIGHTS > 0
	struct RectAreaLight {
		vec3 color;
		vec3 position;
		vec3 halfWidth;
		vec3 halfHeight;
	};
	uniform sampler2D ltc_1;	uniform sampler2D ltc_2;
	uniform RectAreaLight rectAreaLights[ NUM_RECT_AREA_LIGHTS ];
#endif
#if NUM_HEMI_LIGHTS > 0
	struct HemisphereLight {
		vec3 direction;
		vec3 skyColor;
		vec3 groundColor;
	};
	uniform HemisphereLight hemisphereLights[ NUM_HEMI_LIGHTS ];
	vec3 getHemisphereLightIrradiance( const in HemisphereLight hemiLight, const in vec3 normal ) {
		float dotNL = dot( normal, hemiLight.direction );
		float hemiDiffuseWeight = 0.5 * dotNL + 0.5;
		vec3 irradiance = mix( hemiLight.groundColor, hemiLight.skyColor, hemiDiffuseWeight );
		return irradiance;
	}
#endif`,ab=`#if defined( USE_ENVMAP )
	#ifdef ENVMAP_MODE_REFRACTION
		uniform float refractionRatio;
	#endif
	vec3 getIBLIrradiance( const in vec3 normal ) {
		#if defined( ENVMAP_TYPE_CUBE_UV )
			vec3 worldNormal = inverseTransformDirection( normal, viewMatrix );
			vec4 envMapColor = textureCubeUV( envMap, worldNormal, 1.0 );
			return PI * envMapColor.rgb * envMapIntensity;
		#else
			return vec3( 0.0 );
		#endif
	}
	vec3 getIBLRadiance( const in vec3 viewDir, const in vec3 normal, const in float roughness ) {
		#if defined( ENVMAP_TYPE_CUBE_UV )
			vec3 reflectVec;
			#ifdef ENVMAP_MODE_REFLECTION
				reflectVec = reflect( - viewDir, normal );
				reflectVec = normalize( mix( reflectVec, normal, roughness * roughness) );
			#else
				reflectVec = refract( - viewDir, normal, refractionRatio );
			#endif
			reflectVec = inverseTransformDirection( reflectVec, viewMatrix );
			vec4 envMapColor = textureCubeUV( envMap, reflectVec, roughness );
			return envMapColor.rgb * envMapIntensity;
		#else
			return vec3( 0.0 );
		#endif
	}
#endif`,lb=`ToonMaterial material;
material.diffuseColor = diffuseColor.rgb;`,cb=`varying vec3 vViewPosition;
struct ToonMaterial {
	vec3 diffuseColor;
};
void RE_Direct_Toon( const in IncidentLight directLight, const in GeometricContext geometry, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {
	vec3 irradiance = getGradientIrradiance( geometry.normal, directLight.direction ) * directLight.color;
	reflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
}
void RE_IndirectDiffuse_Toon( const in vec3 irradiance, const in GeometricContext geometry, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {
	reflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
}
#define RE_Direct				RE_Direct_Toon
#define RE_IndirectDiffuse		RE_IndirectDiffuse_Toon
#define Material_LightProbeLOD( material )	(0)`,ub=`BlinnPhongMaterial material;
material.diffuseColor = diffuseColor.rgb;
material.specularColor = specular;
material.specularShininess = shininess;
material.specularStrength = specularStrength;`,hb=`varying vec3 vViewPosition;
struct BlinnPhongMaterial {
	vec3 diffuseColor;
	vec3 specularColor;
	float specularShininess;
	float specularStrength;
};
void RE_Direct_BlinnPhong( const in IncidentLight directLight, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {
	float dotNL = saturate( dot( geometry.normal, directLight.direction ) );
	vec3 irradiance = dotNL * directLight.color;
	reflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
	reflectedLight.directSpecular += irradiance * BRDF_BlinnPhong( directLight.direction, geometry.viewDir, geometry.normal, material.specularColor, material.specularShininess ) * material.specularStrength;
}
void RE_IndirectDiffuse_BlinnPhong( const in vec3 irradiance, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {
	reflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
}
#define RE_Direct				RE_Direct_BlinnPhong
#define RE_IndirectDiffuse		RE_IndirectDiffuse_BlinnPhong
#define Material_LightProbeLOD( material )	(0)`,fb=`PhysicalMaterial material;
material.diffuseColor = diffuseColor.rgb * ( 1.0 - metalnessFactor );
vec3 dxy = max( abs( dFdx( geometryNormal ) ), abs( dFdy( geometryNormal ) ) );
float geometryRoughness = max( max( dxy.x, dxy.y ), dxy.z );
material.roughness = max( roughnessFactor, 0.0525 );material.roughness += geometryRoughness;
material.roughness = min( material.roughness, 1.0 );
#ifdef IOR
	#ifdef SPECULAR
		float specularIntensityFactor = specularIntensity;
		vec3 specularColorFactor = specularColor;
		#ifdef USE_SPECULARINTENSITYMAP
			specularIntensityFactor *= texture2D( specularIntensityMap, vUv ).a;
		#endif
		#ifdef USE_SPECULARCOLORMAP
			specularColorFactor *= texture2D( specularColorMap, vUv ).rgb;
		#endif
		material.specularF90 = mix( specularIntensityFactor, 1.0, metalnessFactor );
	#else
		float specularIntensityFactor = 1.0;
		vec3 specularColorFactor = vec3( 1.0 );
		material.specularF90 = 1.0;
	#endif
	material.specularColor = mix( min( pow2( ( ior - 1.0 ) / ( ior + 1.0 ) ) * specularColorFactor, vec3( 1.0 ) ) * specularIntensityFactor, diffuseColor.rgb, metalnessFactor );
#else
	material.specularColor = mix( vec3( 0.04 ), diffuseColor.rgb, metalnessFactor );
	material.specularF90 = 1.0;
#endif
#ifdef USE_CLEARCOAT
	material.clearcoat = clearcoat;
	material.clearcoatRoughness = clearcoatRoughness;
	material.clearcoatF0 = vec3( 0.04 );
	material.clearcoatF90 = 1.0;
	#ifdef USE_CLEARCOATMAP
		material.clearcoat *= texture2D( clearcoatMap, vUv ).x;
	#endif
	#ifdef USE_CLEARCOAT_ROUGHNESSMAP
		material.clearcoatRoughness *= texture2D( clearcoatRoughnessMap, vUv ).y;
	#endif
	material.clearcoat = saturate( material.clearcoat );	material.clearcoatRoughness = max( material.clearcoatRoughness, 0.0525 );
	material.clearcoatRoughness += geometryRoughness;
	material.clearcoatRoughness = min( material.clearcoatRoughness, 1.0 );
#endif
#ifdef USE_SHEEN
	material.sheenColor = sheenColor;
	#ifdef USE_SHEENCOLORMAP
		material.sheenColor *= texture2D( sheenColorMap, vUv ).rgb;
	#endif
	material.sheenRoughness = clamp( sheenRoughness, 0.07, 1.0 );
	#ifdef USE_SHEENROUGHNESSMAP
		material.sheenRoughness *= texture2D( sheenRoughnessMap, vUv ).a;
	#endif
#endif`,db=`struct PhysicalMaterial {
	vec3 diffuseColor;
	float roughness;
	vec3 specularColor;
	float specularF90;
	#ifdef USE_CLEARCOAT
		float clearcoat;
		float clearcoatRoughness;
		vec3 clearcoatF0;
		float clearcoatF90;
	#endif
	#ifdef USE_SHEEN
		vec3 sheenColor;
		float sheenRoughness;
	#endif
};
vec3 clearcoatSpecular = vec3( 0.0 );
vec3 sheenSpecular = vec3( 0.0 );
float IBLSheenBRDF( const in vec3 normal, const in vec3 viewDir, const in float roughness) {
	float dotNV = saturate( dot( normal, viewDir ) );
	float r2 = roughness * roughness;
	float a = roughness < 0.25 ? -339.2 * r2 + 161.4 * roughness - 25.9 : -8.48 * r2 + 14.3 * roughness - 9.95;
	float b = roughness < 0.25 ? 44.0 * r2 - 23.7 * roughness + 3.26 : 1.97 * r2 - 3.27 * roughness + 0.72;
	float DG = exp( a * dotNV + b ) + ( roughness < 0.25 ? 0.0 : 0.1 * ( roughness - 0.25 ) );
	return saturate( DG * RECIPROCAL_PI );
}
vec2 DFGApprox( const in vec3 normal, const in vec3 viewDir, const in float roughness ) {
	float dotNV = saturate( dot( normal, viewDir ) );
	const vec4 c0 = vec4( - 1, - 0.0275, - 0.572, 0.022 );
	const vec4 c1 = vec4( 1, 0.0425, 1.04, - 0.04 );
	vec4 r = roughness * c0 + c1;
	float a004 = min( r.x * r.x, exp2( - 9.28 * dotNV ) ) * r.x + r.y;
	vec2 fab = vec2( - 1.04, 1.04 ) * a004 + r.zw;
	return fab;
}
vec3 EnvironmentBRDF( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float roughness ) {
	vec2 fab = DFGApprox( normal, viewDir, roughness );
	return specularColor * fab.x + specularF90 * fab.y;
}
void computeMultiscattering( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float roughness, inout vec3 singleScatter, inout vec3 multiScatter ) {
	vec2 fab = DFGApprox( normal, viewDir, roughness );
	vec3 FssEss = specularColor * fab.x + specularF90 * fab.y;
	float Ess = fab.x + fab.y;
	float Ems = 1.0 - Ess;
	vec3 Favg = specularColor + ( 1.0 - specularColor ) * 0.047619;	vec3 Fms = FssEss * Favg / ( 1.0 - Ems * Favg );
	singleScatter += FssEss;
	multiScatter += Fms * Ems;
}
#if NUM_RECT_AREA_LIGHTS > 0
	void RE_Direct_RectArea_Physical( const in RectAreaLight rectAreaLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {
		vec3 normal = geometry.normal;
		vec3 viewDir = geometry.viewDir;
		vec3 position = geometry.position;
		vec3 lightPos = rectAreaLight.position;
		vec3 halfWidth = rectAreaLight.halfWidth;
		vec3 halfHeight = rectAreaLight.halfHeight;
		vec3 lightColor = rectAreaLight.color;
		float roughness = material.roughness;
		vec3 rectCoords[ 4 ];
		rectCoords[ 0 ] = lightPos + halfWidth - halfHeight;		rectCoords[ 1 ] = lightPos - halfWidth - halfHeight;
		rectCoords[ 2 ] = lightPos - halfWidth + halfHeight;
		rectCoords[ 3 ] = lightPos + halfWidth + halfHeight;
		vec2 uv = LTC_Uv( normal, viewDir, roughness );
		vec4 t1 = texture2D( ltc_1, uv );
		vec4 t2 = texture2D( ltc_2, uv );
		mat3 mInv = mat3(
			vec3( t1.x, 0, t1.y ),
			vec3(    0, 1,    0 ),
			vec3( t1.z, 0, t1.w )
		);
		vec3 fresnel = ( material.specularColor * t2.x + ( vec3( 1.0 ) - material.specularColor ) * t2.y );
		reflectedLight.directSpecular += lightColor * fresnel * LTC_Evaluate( normal, viewDir, position, mInv, rectCoords );
		reflectedLight.directDiffuse += lightColor * material.diffuseColor * LTC_Evaluate( normal, viewDir, position, mat3( 1.0 ), rectCoords );
	}
#endif
void RE_Direct_Physical( const in IncidentLight directLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {
	float dotNL = saturate( dot( geometry.normal, directLight.direction ) );
	vec3 irradiance = dotNL * directLight.color;
	#ifdef USE_CLEARCOAT
		float dotNLcc = saturate( dot( geometry.clearcoatNormal, directLight.direction ) );
		vec3 ccIrradiance = dotNLcc * directLight.color;
		clearcoatSpecular += ccIrradiance * BRDF_GGX( directLight.direction, geometry.viewDir, geometry.clearcoatNormal, material.clearcoatF0, material.clearcoatF90, material.clearcoatRoughness );
	#endif
	#ifdef USE_SHEEN
		sheenSpecular += irradiance * BRDF_Sheen( directLight.direction, geometry.viewDir, geometry.normal, material.sheenColor, material.sheenRoughness );
	#endif
	reflectedLight.directSpecular += irradiance * BRDF_GGX( directLight.direction, geometry.viewDir, geometry.normal, material.specularColor, material.specularF90, material.roughness );
	reflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
}
void RE_IndirectDiffuse_Physical( const in vec3 irradiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {
	reflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
}
void RE_IndirectSpecular_Physical( const in vec3 radiance, const in vec3 irradiance, const in vec3 clearcoatRadiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight) {
	#ifdef USE_CLEARCOAT
		clearcoatSpecular += clearcoatRadiance * EnvironmentBRDF( geometry.clearcoatNormal, geometry.viewDir, material.clearcoatF0, material.clearcoatF90, material.clearcoatRoughness );
	#endif
	#ifdef USE_SHEEN
		sheenSpecular += irradiance * material.sheenColor * IBLSheenBRDF( geometry.normal, geometry.viewDir, material.sheenRoughness );
	#endif
	vec3 singleScattering = vec3( 0.0 );
	vec3 multiScattering = vec3( 0.0 );
	vec3 cosineWeightedIrradiance = irradiance * RECIPROCAL_PI;
	computeMultiscattering( geometry.normal, geometry.viewDir, material.specularColor, material.specularF90, material.roughness, singleScattering, multiScattering );
	vec3 diffuse = material.diffuseColor * ( 1.0 - ( singleScattering + multiScattering ) );
	reflectedLight.indirectSpecular += radiance * singleScattering;
	reflectedLight.indirectSpecular += multiScattering * cosineWeightedIrradiance;
	reflectedLight.indirectDiffuse += diffuse * cosineWeightedIrradiance;
}
#define RE_Direct				RE_Direct_Physical
#define RE_Direct_RectArea		RE_Direct_RectArea_Physical
#define RE_IndirectDiffuse		RE_IndirectDiffuse_Physical
#define RE_IndirectSpecular		RE_IndirectSpecular_Physical
float computeSpecularOcclusion( const in float dotNV, const in float ambientOcclusion, const in float roughness ) {
	return saturate( pow( dotNV + ambientOcclusion, exp2( - 16.0 * roughness - 1.0 ) ) - 1.0 + ambientOcclusion );
}`,pb=`
GeometricContext geometry;
geometry.position = - vViewPosition;
geometry.normal = normal;
geometry.viewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( vViewPosition );
#ifdef USE_CLEARCOAT
	geometry.clearcoatNormal = clearcoatNormal;
#endif
IncidentLight directLight;
#if ( NUM_POINT_LIGHTS > 0 ) && defined( RE_Direct )
	PointLight pointLight;
	#if defined( USE_SHADOWMAP ) && NUM_POINT_LIGHT_SHADOWS > 0
	PointLightShadow pointLightShadow;
	#endif
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {
		pointLight = pointLights[ i ];
		getPointLightInfo( pointLight, geometry, directLight );
		#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_POINT_LIGHT_SHADOWS )
		pointLightShadow = pointLightShadows[ i ];
		directLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getPointShadow( pointShadowMap[ i ], pointLightShadow.shadowMapSize, pointLightShadow.shadowBias, pointLightShadow.shadowRadius, vPointShadowCoord[ i ], pointLightShadow.shadowCameraNear, pointLightShadow.shadowCameraFar ) : 1.0;
		#endif
		RE_Direct( directLight, geometry, material, reflectedLight );
	}
	#pragma unroll_loop_end
#endif
#if ( NUM_SPOT_LIGHTS > 0 ) && defined( RE_Direct )
	SpotLight spotLight;
	#if defined( USE_SHADOWMAP ) && NUM_SPOT_LIGHT_SHADOWS > 0
	SpotLightShadow spotLightShadow;
	#endif
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {
		spotLight = spotLights[ i ];
		getSpotLightInfo( spotLight, geometry, directLight );
		#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )
		spotLightShadow = spotLightShadows[ i ];
		directLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getShadow( spotShadowMap[ i ], spotLightShadow.shadowMapSize, spotLightShadow.shadowBias, spotLightShadow.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;
		#endif
		RE_Direct( directLight, geometry, material, reflectedLight );
	}
	#pragma unroll_loop_end
#endif
#if ( NUM_DIR_LIGHTS > 0 ) && defined( RE_Direct )
	DirectionalLight directionalLight;
	#if defined( USE_SHADOWMAP ) && NUM_DIR_LIGHT_SHADOWS > 0
	DirectionalLightShadow directionalLightShadow;
	#endif
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {
		directionalLight = directionalLights[ i ];
		getDirectionalLightInfo( directionalLight, geometry, directLight );
		#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS )
		directionalLightShadow = directionalLightShadows[ i ];
		directLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getShadow( directionalShadowMap[ i ], directionalLightShadow.shadowMapSize, directionalLightShadow.shadowBias, directionalLightShadow.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;
		#endif
		RE_Direct( directLight, geometry, material, reflectedLight );
	}
	#pragma unroll_loop_end
#endif
#if ( NUM_RECT_AREA_LIGHTS > 0 ) && defined( RE_Direct_RectArea )
	RectAreaLight rectAreaLight;
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_RECT_AREA_LIGHTS; i ++ ) {
		rectAreaLight = rectAreaLights[ i ];
		RE_Direct_RectArea( rectAreaLight, geometry, material, reflectedLight );
	}
	#pragma unroll_loop_end
#endif
#if defined( RE_IndirectDiffuse )
	vec3 iblIrradiance = vec3( 0.0 );
	vec3 irradiance = getAmbientLightIrradiance( ambientLightColor );
	irradiance += getLightProbeIrradiance( lightProbe, geometry.normal );
	#if ( NUM_HEMI_LIGHTS > 0 )
		#pragma unroll_loop_start
		for ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {
			irradiance += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry.normal );
		}
		#pragma unroll_loop_end
	#endif
#endif
#if defined( RE_IndirectSpecular )
	vec3 radiance = vec3( 0.0 );
	vec3 clearcoatRadiance = vec3( 0.0 );
#endif`,mb=`#if defined( RE_IndirectDiffuse )
	#ifdef USE_LIGHTMAP
		vec4 lightMapTexel = texture2D( lightMap, vUv2 );
		vec3 lightMapIrradiance = lightMapTexel.rgb * lightMapIntensity;
		#ifndef PHYSICALLY_CORRECT_LIGHTS
			lightMapIrradiance *= PI;
		#endif
		irradiance += lightMapIrradiance;
	#endif
	#if defined( USE_ENVMAP ) && defined( STANDARD ) && defined( ENVMAP_TYPE_CUBE_UV )
		iblIrradiance += getIBLIrradiance( geometry.normal );
	#endif
#endif
#if defined( USE_ENVMAP ) && defined( RE_IndirectSpecular )
	radiance += getIBLRadiance( geometry.viewDir, geometry.normal, material.roughness );
	#ifdef USE_CLEARCOAT
		clearcoatRadiance += getIBLRadiance( geometry.viewDir, geometry.clearcoatNormal, material.clearcoatRoughness );
	#endif
#endif`,gb=`#if defined( RE_IndirectDiffuse )
	RE_IndirectDiffuse( irradiance, geometry, material, reflectedLight );
#endif
#if defined( RE_IndirectSpecular )
	RE_IndirectSpecular( radiance, iblIrradiance, clearcoatRadiance, geometry, material, reflectedLight );
#endif`,xb=`#if defined( USE_LOGDEPTHBUF ) && defined( USE_LOGDEPTHBUF_EXT )
	gl_FragDepthEXT = vIsPerspective == 0.0 ? gl_FragCoord.z : log2( vFragDepth ) * logDepthBufFC * 0.5;
#endif`,yb=`#if defined( USE_LOGDEPTHBUF ) && defined( USE_LOGDEPTHBUF_EXT )
	uniform float logDepthBufFC;
	varying float vFragDepth;
	varying float vIsPerspective;
#endif`,vb=`#ifdef USE_LOGDEPTHBUF
	#ifdef USE_LOGDEPTHBUF_EXT
		varying float vFragDepth;
		varying float vIsPerspective;
	#else
		uniform float logDepthBufFC;
	#endif
#endif`,_b=`#ifdef USE_LOGDEPTHBUF
	#ifdef USE_LOGDEPTHBUF_EXT
		vFragDepth = 1.0 + gl_Position.w;
		vIsPerspective = float( isPerspectiveMatrix( projectionMatrix ) );
	#else
		if ( isPerspectiveMatrix( projectionMatrix ) ) {
			gl_Position.z = log2( max( EPSILON, gl_Position.w + 1.0 ) ) * logDepthBufFC - 1.0;
			gl_Position.z *= gl_Position.w;
		}
	#endif
#endif`,wb=`#ifdef USE_MAP
	vec4 sampledDiffuseColor = texture2D( map, vUv );
	#ifdef DECODE_VIDEO_TEXTURE
		sampledDiffuseColor = vec4( mix( pow( sampledDiffuseColor.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), sampledDiffuseColor.rgb * 0.0773993808, vec3( lessThanEqual( sampledDiffuseColor.rgb, vec3( 0.04045 ) ) ) ), sampledDiffuseColor.w );
	#endif
	diffuseColor *= sampledDiffuseColor;
#endif`,Mb=`#ifdef USE_MAP
	uniform sampler2D map;
#endif`,bb=`#if defined( USE_MAP ) || defined( USE_ALPHAMAP )
	vec2 uv = ( uvTransform * vec3( gl_PointCoord.x, 1.0 - gl_PointCoord.y, 1 ) ).xy;
#endif
#ifdef USE_MAP
	diffuseColor *= texture2D( map, uv );
#endif
#ifdef USE_ALPHAMAP
	diffuseColor.a *= texture2D( alphaMap, uv ).g;
#endif`,Sb=`#if defined( USE_MAP ) || defined( USE_ALPHAMAP )
	uniform mat3 uvTransform;
#endif
#ifdef USE_MAP
	uniform sampler2D map;
#endif
#ifdef USE_ALPHAMAP
	uniform sampler2D alphaMap;
#endif`,Eb=`float metalnessFactor = metalness;
#ifdef USE_METALNESSMAP
	vec4 texelMetalness = texture2D( metalnessMap, vUv );
	metalnessFactor *= texelMetalness.b;
#endif`,Tb=`#ifdef USE_METALNESSMAP
	uniform sampler2D metalnessMap;
#endif`,Ab=`#ifdef USE_MORPHNORMALS
	objectNormal *= morphTargetBaseInfluence;
	#ifdef MORPHTARGETS_TEXTURE
		for ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {
			if ( morphTargetInfluences[ i ] != 0.0 ) objectNormal += getMorph( gl_VertexID, i, 1, 2 ) * morphTargetInfluences[ i ];
		}
	#else
		objectNormal += morphNormal0 * morphTargetInfluences[ 0 ];
		objectNormal += morphNormal1 * morphTargetInfluences[ 1 ];
		objectNormal += morphNormal2 * morphTargetInfluences[ 2 ];
		objectNormal += morphNormal3 * morphTargetInfluences[ 3 ];
	#endif
#endif`,Cb=`#ifdef USE_MORPHTARGETS
	uniform float morphTargetBaseInfluence;
	#ifdef MORPHTARGETS_TEXTURE
		uniform float morphTargetInfluences[ MORPHTARGETS_COUNT ];
		uniform sampler2DArray morphTargetsTexture;
		uniform vec2 morphTargetsTextureSize;
		vec3 getMorph( const in int vertexIndex, const in int morphTargetIndex, const in int offset, const in int stride ) {
			float texelIndex = float( vertexIndex * stride + offset );
			float y = floor( texelIndex / morphTargetsTextureSize.x );
			float x = texelIndex - y * morphTargetsTextureSize.x;
			vec3 morphUV = vec3( ( x + 0.5 ) / morphTargetsTextureSize.x, y / morphTargetsTextureSize.y, morphTargetIndex );
			return texture( morphTargetsTexture, morphUV ).xyz;
		}
	#else
		#ifndef USE_MORPHNORMALS
			uniform float morphTargetInfluences[ 8 ];
		#else
			uniform float morphTargetInfluences[ 4 ];
		#endif
	#endif
#endif`,Rb=`#ifdef USE_MORPHTARGETS
	transformed *= morphTargetBaseInfluence;
	#ifdef MORPHTARGETS_TEXTURE
		for ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {
			#ifndef USE_MORPHNORMALS
				if ( morphTargetInfluences[ i ] != 0.0 ) transformed += getMorph( gl_VertexID, i, 0, 1 ) * morphTargetInfluences[ i ];
			#else
				if ( morphTargetInfluences[ i ] != 0.0 ) transformed += getMorph( gl_VertexID, i, 0, 2 ) * morphTargetInfluences[ i ];
			#endif
		}
	#else
		transformed += morphTarget0 * morphTargetInfluences[ 0 ];
		transformed += morphTarget1 * morphTargetInfluences[ 1 ];
		transformed += morphTarget2 * morphTargetInfluences[ 2 ];
		transformed += morphTarget3 * morphTargetInfluences[ 3 ];
		#ifndef USE_MORPHNORMALS
			transformed += morphTarget4 * morphTargetInfluences[ 4 ];
			transformed += morphTarget5 * morphTargetInfluences[ 5 ];
			transformed += morphTarget6 * morphTargetInfluences[ 6 ];
			transformed += morphTarget7 * morphTargetInfluences[ 7 ];
		#endif
	#endif
#endif`,Lb=`float faceDirection = gl_FrontFacing ? 1.0 : - 1.0;
#ifdef FLAT_SHADED
	vec3 fdx = vec3( dFdx( vViewPosition.x ), dFdx( vViewPosition.y ), dFdx( vViewPosition.z ) );
	vec3 fdy = vec3( dFdy( vViewPosition.x ), dFdy( vViewPosition.y ), dFdy( vViewPosition.z ) );
	vec3 normal = normalize( cross( fdx, fdy ) );
#else
	vec3 normal = normalize( vNormal );
	#ifdef DOUBLE_SIDED
		normal = normal * faceDirection;
	#endif
	#ifdef USE_TANGENT
		vec3 tangent = normalize( vTangent );
		vec3 bitangent = normalize( vBitangent );
		#ifdef DOUBLE_SIDED
			tangent = tangent * faceDirection;
			bitangent = bitangent * faceDirection;
		#endif
		#if defined( TANGENTSPACE_NORMALMAP ) || defined( USE_CLEARCOAT_NORMALMAP )
			mat3 vTBN = mat3( tangent, bitangent, normal );
		#endif
	#endif
#endif
vec3 geometryNormal = normal;`,Pb=`#ifdef OBJECTSPACE_NORMALMAP
	normal = texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;
	#ifdef FLIP_SIDED
		normal = - normal;
	#endif
	#ifdef DOUBLE_SIDED
		normal = normal * faceDirection;
	#endif
	normal = normalize( normalMatrix * normal );
#elif defined( TANGENTSPACE_NORMALMAP )
	vec3 mapN = texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;
	mapN.xy *= normalScale;
	#ifdef USE_TANGENT
		normal = normalize( vTBN * mapN );
	#else
		normal = perturbNormal2Arb( - vViewPosition, normal, mapN, faceDirection );
	#endif
#elif defined( USE_BUMPMAP )
	normal = perturbNormalArb( - vViewPosition, normal, dHdxy_fwd(), faceDirection );
#endif`,Db=`#ifndef FLAT_SHADED
	varying vec3 vNormal;
	#ifdef USE_TANGENT
		varying vec3 vTangent;
		varying vec3 vBitangent;
	#endif
#endif`,Ib=`#ifndef FLAT_SHADED
	varying vec3 vNormal;
	#ifdef USE_TANGENT
		varying vec3 vTangent;
		varying vec3 vBitangent;
	#endif
#endif`,Nb=`#ifndef FLAT_SHADED
	vNormal = normalize( transformedNormal );
	#ifdef USE_TANGENT
		vTangent = normalize( transformedTangent );
		vBitangent = normalize( cross( vNormal, vTangent ) * tangent.w );
	#endif
#endif`,Fb=`#ifdef USE_NORMALMAP
	uniform sampler2D normalMap;
	uniform vec2 normalScale;
#endif
#ifdef OBJECTSPACE_NORMALMAP
	uniform mat3 normalMatrix;
#endif
#if ! defined ( USE_TANGENT ) && ( defined ( TANGENTSPACE_NORMALMAP ) || defined ( USE_CLEARCOAT_NORMALMAP ) )
	vec3 perturbNormal2Arb( vec3 eye_pos, vec3 surf_norm, vec3 mapN, float faceDirection ) {
		vec3 q0 = vec3( dFdx( eye_pos.x ), dFdx( eye_pos.y ), dFdx( eye_pos.z ) );
		vec3 q1 = vec3( dFdy( eye_pos.x ), dFdy( eye_pos.y ), dFdy( eye_pos.z ) );
		vec2 st0 = dFdx( vUv.st );
		vec2 st1 = dFdy( vUv.st );
		vec3 N = surf_norm;
		vec3 q1perp = cross( q1, N );
		vec3 q0perp = cross( N, q0 );
		vec3 T = q1perp * st0.x + q0perp * st1.x;
		vec3 B = q1perp * st0.y + q0perp * st1.y;
		float det = max( dot( T, T ), dot( B, B ) );
		float scale = ( det == 0.0 ) ? 0.0 : faceDirection * inversesqrt( det );
		return normalize( T * ( mapN.x * scale ) + B * ( mapN.y * scale ) + N * mapN.z );
	}
#endif`,zb=`#ifdef USE_CLEARCOAT
	vec3 clearcoatNormal = geometryNormal;
#endif`,Ub=`#ifdef USE_CLEARCOAT_NORMALMAP
	vec3 clearcoatMapN = texture2D( clearcoatNormalMap, vUv ).xyz * 2.0 - 1.0;
	clearcoatMapN.xy *= clearcoatNormalScale;
	#ifdef USE_TANGENT
		clearcoatNormal = normalize( vTBN * clearcoatMapN );
	#else
		clearcoatNormal = perturbNormal2Arb( - vViewPosition, clearcoatNormal, clearcoatMapN, faceDirection );
	#endif
#endif`,Bb=`#ifdef USE_CLEARCOATMAP
	uniform sampler2D clearcoatMap;
#endif
#ifdef USE_CLEARCOAT_ROUGHNESSMAP
	uniform sampler2D clearcoatRoughnessMap;
#endif
#ifdef USE_CLEARCOAT_NORMALMAP
	uniform sampler2D clearcoatNormalMap;
	uniform vec2 clearcoatNormalScale;
#endif`,Ob=`#ifdef OPAQUE
diffuseColor.a = 1.0;
#endif
#ifdef USE_TRANSMISSION
diffuseColor.a *= transmissionAlpha + 0.1;
#endif
gl_FragColor = vec4( outgoingLight, diffuseColor.a );`,kb=`vec3 packNormalToRGB( const in vec3 normal ) {
	return normalize( normal ) * 0.5 + 0.5;
}
vec3 unpackRGBToNormal( const in vec3 rgb ) {
	return 2.0 * rgb.xyz - 1.0;
}
const float PackUpscale = 256. / 255.;const float UnpackDownscale = 255. / 256.;
const vec3 PackFactors = vec3( 256. * 256. * 256., 256. * 256., 256. );
const vec4 UnpackFactors = UnpackDownscale / vec4( PackFactors, 1. );
const float ShiftRight8 = 1. / 256.;
vec4 packDepthToRGBA( const in float v ) {
	vec4 r = vec4( fract( v * PackFactors ), v );
	r.yzw -= r.xyz * ShiftRight8;	return r * PackUpscale;
}
float unpackRGBAToDepth( const in vec4 v ) {
	return dot( v, UnpackFactors );
}
vec4 pack2HalfToRGBA( vec2 v ) {
	vec4 r = vec4( v.x, fract( v.x * 255.0 ), v.y, fract( v.y * 255.0 ) );
	return vec4( r.x - r.y / 255.0, r.y, r.z - r.w / 255.0, r.w );
}
vec2 unpackRGBATo2Half( vec4 v ) {
	return vec2( v.x + ( v.y / 255.0 ), v.z + ( v.w / 255.0 ) );
}
float viewZToOrthographicDepth( const in float viewZ, const in float near, const in float far ) {
	return ( viewZ + near ) / ( near - far );
}
float orthographicDepthToViewZ( const in float linearClipZ, const in float near, const in float far ) {
	return linearClipZ * ( near - far ) - near;
}
float viewZToPerspectiveDepth( const in float viewZ, const in float near, const in float far ) {
	return ( ( near + viewZ ) * far ) / ( ( far - near ) * viewZ );
}
float perspectiveDepthToViewZ( const in float invClipZ, const in float near, const in float far ) {
	return ( near * far ) / ( ( far - near ) * invClipZ - far );
}`,Hb=`#ifdef PREMULTIPLIED_ALPHA
	gl_FragColor.rgb *= gl_FragColor.a;
#endif`,Vb=`vec4 mvPosition = vec4( transformed, 1.0 );
#ifdef USE_INSTANCING
	mvPosition = instanceMatrix * mvPosition;
#endif
mvPosition = modelViewMatrix * mvPosition;
gl_Position = projectionMatrix * mvPosition;`,Gb=`#ifdef DITHERING
	gl_FragColor.rgb = dithering( gl_FragColor.rgb );
#endif`,Wb=`#ifdef DITHERING
	vec3 dithering( vec3 color ) {
		float grid_position = rand( gl_FragCoord.xy );
		vec3 dither_shift_RGB = vec3( 0.25 / 255.0, -0.25 / 255.0, 0.25 / 255.0 );
		dither_shift_RGB = mix( 2.0 * dither_shift_RGB, -2.0 * dither_shift_RGB, grid_position );
		return color + dither_shift_RGB;
	}
#endif`,qb=`float roughnessFactor = roughness;
#ifdef USE_ROUGHNESSMAP
	vec4 texelRoughness = texture2D( roughnessMap, vUv );
	roughnessFactor *= texelRoughness.g;
#endif`,Xb=`#ifdef USE_ROUGHNESSMAP
	uniform sampler2D roughnessMap;
#endif`,Yb=`#ifdef USE_SHADOWMAP
	#if NUM_DIR_LIGHT_SHADOWS > 0
		uniform sampler2D directionalShadowMap[ NUM_DIR_LIGHT_SHADOWS ];
		varying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];
		struct DirectionalLightShadow {
			float shadowBias;
			float shadowNormalBias;
			float shadowRadius;
			vec2 shadowMapSize;
		};
		uniform DirectionalLightShadow directionalLightShadows[ NUM_DIR_LIGHT_SHADOWS ];
	#endif
	#if NUM_SPOT_LIGHT_SHADOWS > 0
		uniform sampler2D spotShadowMap[ NUM_SPOT_LIGHT_SHADOWS ];
		varying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHT_SHADOWS ];
		struct SpotLightShadow {
			float shadowBias;
			float shadowNormalBias;
			float shadowRadius;
			vec2 shadowMapSize;
		};
		uniform SpotLightShadow spotLightShadows[ NUM_SPOT_LIGHT_SHADOWS ];
	#endif
	#if NUM_POINT_LIGHT_SHADOWS > 0
		uniform sampler2D pointShadowMap[ NUM_POINT_LIGHT_SHADOWS ];
		varying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];
		struct PointLightShadow {
			float shadowBias;
			float shadowNormalBias;
			float shadowRadius;
			vec2 shadowMapSize;
			float shadowCameraNear;
			float shadowCameraFar;
		};
		uniform PointLightShadow pointLightShadows[ NUM_POINT_LIGHT_SHADOWS ];
	#endif
	float texture2DCompare( sampler2D depths, vec2 uv, float compare ) {
		return step( compare, unpackRGBAToDepth( texture2D( depths, uv ) ) );
	}
	vec2 texture2DDistribution( sampler2D shadow, vec2 uv ) {
		return unpackRGBATo2Half( texture2D( shadow, uv ) );
	}
	float VSMShadow (sampler2D shadow, vec2 uv, float compare ){
		float occlusion = 1.0;
		vec2 distribution = texture2DDistribution( shadow, uv );
		float hard_shadow = step( compare , distribution.x );
		if (hard_shadow != 1.0 ) {
			float distance = compare - distribution.x ;
			float variance = max( 0.00000, distribution.y * distribution.y );
			float softness_probability = variance / (variance + distance * distance );			softness_probability = clamp( ( softness_probability - 0.3 ) / ( 0.95 - 0.3 ), 0.0, 1.0 );			occlusion = clamp( max( hard_shadow, softness_probability ), 0.0, 1.0 );
		}
		return occlusion;
	}
	float getShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord ) {
		float shadow = 1.0;
		shadowCoord.xyz /= shadowCoord.w;
		shadowCoord.z += shadowBias;
		bvec4 inFrustumVec = bvec4 ( shadowCoord.x >= 0.0, shadowCoord.x <= 1.0, shadowCoord.y >= 0.0, shadowCoord.y <= 1.0 );
		bool inFrustum = all( inFrustumVec );
		bvec2 frustumTestVec = bvec2( inFrustum, shadowCoord.z <= 1.0 );
		bool frustumTest = all( frustumTestVec );
		if ( frustumTest ) {
		#if defined( SHADOWMAP_TYPE_PCF )
			vec2 texelSize = vec2( 1.0 ) / shadowMapSize;
			float dx0 = - texelSize.x * shadowRadius;
			float dy0 = - texelSize.y * shadowRadius;
			float dx1 = + texelSize.x * shadowRadius;
			float dy1 = + texelSize.y * shadowRadius;
			float dx2 = dx0 / 2.0;
			float dy2 = dy0 / 2.0;
			float dx3 = dx1 / 2.0;
			float dy3 = dy1 / 2.0;
			shadow = (
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, dy2 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy2 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, dy2 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, 0.0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, 0.0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, 0.0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, 0.0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, dy3 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy3 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, dy3 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy1 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy1 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy1 ), shadowCoord.z )
			) * ( 1.0 / 17.0 );
		#elif defined( SHADOWMAP_TYPE_PCF_SOFT )
			vec2 texelSize = vec2( 1.0 ) / shadowMapSize;
			float dx = texelSize.x;
			float dy = texelSize.y;
			vec2 uv = shadowCoord.xy;
			vec2 f = fract( uv * shadowMapSize + 0.5 );
			uv -= f * texelSize;
			shadow = (
				texture2DCompare( shadowMap, uv, shadowCoord.z ) +
				texture2DCompare( shadowMap, uv + vec2( dx, 0.0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, uv + vec2( 0.0, dy ), shadowCoord.z ) +
				texture2DCompare( shadowMap, uv + texelSize, shadowCoord.z ) +
				mix( texture2DCompare( shadowMap, uv + vec2( -dx, 0.0 ), shadowCoord.z ), 
					 texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, 0.0 ), shadowCoord.z ),
					 f.x ) +
				mix( texture2DCompare( shadowMap, uv + vec2( -dx, dy ), shadowCoord.z ), 
					 texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, dy ), shadowCoord.z ),
					 f.x ) +
				mix( texture2DCompare( shadowMap, uv + vec2( 0.0, -dy ), shadowCoord.z ), 
					 texture2DCompare( shadowMap, uv + vec2( 0.0, 2.0 * dy ), shadowCoord.z ),
					 f.y ) +
				mix( texture2DCompare( shadowMap, uv + vec2( dx, -dy ), shadowCoord.z ), 
					 texture2DCompare( shadowMap, uv + vec2( dx, 2.0 * dy ), shadowCoord.z ),
					 f.y ) +
				mix( mix( texture2DCompare( shadowMap, uv + vec2( -dx, -dy ), shadowCoord.z ), 
						  texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, -dy ), shadowCoord.z ),
						  f.x ),
					 mix( texture2DCompare( shadowMap, uv + vec2( -dx, 2.0 * dy ), shadowCoord.z ), 
						  texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, 2.0 * dy ), shadowCoord.z ),
						  f.x ),
					 f.y )
			) * ( 1.0 / 9.0 );
		#elif defined( SHADOWMAP_TYPE_VSM )
			shadow = VSMShadow( shadowMap, shadowCoord.xy, shadowCoord.z );
		#else
			shadow = texture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z );
		#endif
		}
		return shadow;
	}
	vec2 cubeToUV( vec3 v, float texelSizeY ) {
		vec3 absV = abs( v );
		float scaleToCube = 1.0 / max( absV.x, max( absV.y, absV.z ) );
		absV *= scaleToCube;
		v *= scaleToCube * ( 1.0 - 2.0 * texelSizeY );
		vec2 planar = v.xy;
		float almostATexel = 1.5 * texelSizeY;
		float almostOne = 1.0 - almostATexel;
		if ( absV.z >= almostOne ) {
			if ( v.z > 0.0 )
				planar.x = 4.0 - v.x;
		} else if ( absV.x >= almostOne ) {
			float signX = sign( v.x );
			planar.x = v.z * signX + 2.0 * signX;
		} else if ( absV.y >= almostOne ) {
			float signY = sign( v.y );
			planar.x = v.x + 2.0 * signY + 2.0;
			planar.y = v.z * signY - 2.0;
		}
		return vec2( 0.125, 0.25 ) * planar + vec2( 0.375, 0.75 );
	}
	float getPointShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord, float shadowCameraNear, float shadowCameraFar ) {
		vec2 texelSize = vec2( 1.0 ) / ( shadowMapSize * vec2( 4.0, 2.0 ) );
		vec3 lightToPosition = shadowCoord.xyz;
		float dp = ( length( lightToPosition ) - shadowCameraNear ) / ( shadowCameraFar - shadowCameraNear );		dp += shadowBias;
		vec3 bd3D = normalize( lightToPosition );
		#if defined( SHADOWMAP_TYPE_PCF ) || defined( SHADOWMAP_TYPE_PCF_SOFT ) || defined( SHADOWMAP_TYPE_VSM )
			vec2 offset = vec2( - 1, 1 ) * shadowRadius * texelSize.y;
			return (
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyy, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyy, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyx, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyx, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxy, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxy, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxx, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxx, texelSize.y ), dp )
			) * ( 1.0 / 9.0 );
		#else
			return texture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp );
		#endif
	}
#endif`,Zb=`#ifdef USE_SHADOWMAP
	#if NUM_DIR_LIGHT_SHADOWS > 0
		uniform mat4 directionalShadowMatrix[ NUM_DIR_LIGHT_SHADOWS ];
		varying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];
		struct DirectionalLightShadow {
			float shadowBias;
			float shadowNormalBias;
			float shadowRadius;
			vec2 shadowMapSize;
		};
		uniform DirectionalLightShadow directionalLightShadows[ NUM_DIR_LIGHT_SHADOWS ];
	#endif
	#if NUM_SPOT_LIGHT_SHADOWS > 0
		uniform mat4 spotShadowMatrix[ NUM_SPOT_LIGHT_SHADOWS ];
		varying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHT_SHADOWS ];
		struct SpotLightShadow {
			float shadowBias;
			float shadowNormalBias;
			float shadowRadius;
			vec2 shadowMapSize;
		};
		uniform SpotLightShadow spotLightShadows[ NUM_SPOT_LIGHT_SHADOWS ];
	#endif
	#if NUM_POINT_LIGHT_SHADOWS > 0
		uniform mat4 pointShadowMatrix[ NUM_POINT_LIGHT_SHADOWS ];
		varying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];
		struct PointLightShadow {
			float shadowBias;
			float shadowNormalBias;
			float shadowRadius;
			vec2 shadowMapSize;
			float shadowCameraNear;
			float shadowCameraFar;
		};
		uniform PointLightShadow pointLightShadows[ NUM_POINT_LIGHT_SHADOWS ];
	#endif
#endif`,Jb=`#ifdef USE_SHADOWMAP
	#if NUM_DIR_LIGHT_SHADOWS > 0 || NUM_SPOT_LIGHT_SHADOWS > 0 || NUM_POINT_LIGHT_SHADOWS > 0
		vec3 shadowWorldNormal = inverseTransformDirection( transformedNormal, viewMatrix );
		vec4 shadowWorldPosition;
	#endif
	#if NUM_DIR_LIGHT_SHADOWS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {
		shadowWorldPosition = worldPosition + vec4( shadowWorldNormal * directionalLightShadows[ i ].shadowNormalBias, 0 );
		vDirectionalShadowCoord[ i ] = directionalShadowMatrix[ i ] * shadowWorldPosition;
	}
	#pragma unroll_loop_end
	#endif
	#if NUM_SPOT_LIGHT_SHADOWS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_SPOT_LIGHT_SHADOWS; i ++ ) {
		shadowWorldPosition = worldPosition + vec4( shadowWorldNormal * spotLightShadows[ i ].shadowNormalBias, 0 );
		vSpotShadowCoord[ i ] = spotShadowMatrix[ i ] * shadowWorldPosition;
	}
	#pragma unroll_loop_end
	#endif
	#if NUM_POINT_LIGHT_SHADOWS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {
		shadowWorldPosition = worldPosition + vec4( shadowWorldNormal * pointLightShadows[ i ].shadowNormalBias, 0 );
		vPointShadowCoord[ i ] = pointShadowMatrix[ i ] * shadowWorldPosition;
	}
	#pragma unroll_loop_end
	#endif
#endif`,$b=`float getShadowMask() {
	float shadow = 1.0;
	#ifdef USE_SHADOWMAP
	#if NUM_DIR_LIGHT_SHADOWS > 0
	DirectionalLightShadow directionalLight;
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {
		directionalLight = directionalLightShadows[ i ];
		shadow *= receiveShadow ? getShadow( directionalShadowMap[ i ], directionalLight.shadowMapSize, directionalLight.shadowBias, directionalLight.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;
	}
	#pragma unroll_loop_end
	#endif
	#if NUM_SPOT_LIGHT_SHADOWS > 0
	SpotLightShadow spotLight;
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_SPOT_LIGHT_SHADOWS; i ++ ) {
		spotLight = spotLightShadows[ i ];
		shadow *= receiveShadow ? getShadow( spotShadowMap[ i ], spotLight.shadowMapSize, spotLight.shadowBias, spotLight.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;
	}
	#pragma unroll_loop_end
	#endif
	#if NUM_POINT_LIGHT_SHADOWS > 0
	PointLightShadow pointLight;
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {
		pointLight = pointLightShadows[ i ];
		shadow *= receiveShadow ? getPointShadow( pointShadowMap[ i ], pointLight.shadowMapSize, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ i ], pointLight.shadowCameraNear, pointLight.shadowCameraFar ) : 1.0;
	}
	#pragma unroll_loop_end
	#endif
	#endif
	return shadow;
}`,Kb=`#ifdef USE_SKINNING
	mat4 boneMatX = getBoneMatrix( skinIndex.x );
	mat4 boneMatY = getBoneMatrix( skinIndex.y );
	mat4 boneMatZ = getBoneMatrix( skinIndex.z );
	mat4 boneMatW = getBoneMatrix( skinIndex.w );
#endif`,Qb=`#ifdef USE_SKINNING
	uniform mat4 bindMatrix;
	uniform mat4 bindMatrixInverse;
	#ifdef BONE_TEXTURE
		uniform highp sampler2D boneTexture;
		uniform int boneTextureSize;
		mat4 getBoneMatrix( const in float i ) {
			float j = i * 4.0;
			float x = mod( j, float( boneTextureSize ) );
			float y = floor( j / float( boneTextureSize ) );
			float dx = 1.0 / float( boneTextureSize );
			float dy = 1.0 / float( boneTextureSize );
			y = dy * ( y + 0.5 );
			vec4 v1 = texture2D( boneTexture, vec2( dx * ( x + 0.5 ), y ) );
			vec4 v2 = texture2D( boneTexture, vec2( dx * ( x + 1.5 ), y ) );
			vec4 v3 = texture2D( boneTexture, vec2( dx * ( x + 2.5 ), y ) );
			vec4 v4 = texture2D( boneTexture, vec2( dx * ( x + 3.5 ), y ) );
			mat4 bone = mat4( v1, v2, v3, v4 );
			return bone;
		}
	#else
		uniform mat4 boneMatrices[ MAX_BONES ];
		mat4 getBoneMatrix( const in float i ) {
			mat4 bone = boneMatrices[ int(i) ];
			return bone;
		}
	#endif
#endif`,jb=`#ifdef USE_SKINNING
	vec4 skinVertex = bindMatrix * vec4( transformed, 1.0 );
	vec4 skinned = vec4( 0.0 );
	skinned += boneMatX * skinVertex * skinWeight.x;
	skinned += boneMatY * skinVertex * skinWeight.y;
	skinned += boneMatZ * skinVertex * skinWeight.z;
	skinned += boneMatW * skinVertex * skinWeight.w;
	transformed = ( bindMatrixInverse * skinned ).xyz;
#endif`,t1=`#ifdef USE_SKINNING
	mat4 skinMatrix = mat4( 0.0 );
	skinMatrix += skinWeight.x * boneMatX;
	skinMatrix += skinWeight.y * boneMatY;
	skinMatrix += skinWeight.z * boneMatZ;
	skinMatrix += skinWeight.w * boneMatW;
	skinMatrix = bindMatrixInverse * skinMatrix * bindMatrix;
	objectNormal = vec4( skinMatrix * vec4( objectNormal, 0.0 ) ).xyz;
	#ifdef USE_TANGENT
		objectTangent = vec4( skinMatrix * vec4( objectTangent, 0.0 ) ).xyz;
	#endif
#endif`,e1=`float specularStrength;
#ifdef USE_SPECULARMAP
	vec4 texelSpecular = texture2D( specularMap, vUv );
	specularStrength = texelSpecular.r;
#else
	specularStrength = 1.0;
#endif`,n1=`#ifdef USE_SPECULARMAP
	uniform sampler2D specularMap;
#endif`,i1=`#if defined( TONE_MAPPING )
	gl_FragColor.rgb = toneMapping( gl_FragColor.rgb );
#endif`,r1=`#ifndef saturate
#define saturate( a ) clamp( a, 0.0, 1.0 )
#endif
uniform float toneMappingExposure;
vec3 LinearToneMapping( vec3 color ) {
	return toneMappingExposure * color;
}
vec3 ReinhardToneMapping( vec3 color ) {
	color *= toneMappingExposure;
	return saturate( color / ( vec3( 1.0 ) + color ) );
}
vec3 OptimizedCineonToneMapping( vec3 color ) {
	color *= toneMappingExposure;
	color = max( vec3( 0.0 ), color - 0.004 );
	return pow( ( color * ( 6.2 * color + 0.5 ) ) / ( color * ( 6.2 * color + 1.7 ) + 0.06 ), vec3( 2.2 ) );
}
vec3 RRTAndODTFit( vec3 v ) {
	vec3 a = v * ( v + 0.0245786 ) - 0.000090537;
	vec3 b = v * ( 0.983729 * v + 0.4329510 ) + 0.238081;
	return a / b;
}
vec3 ACESFilmicToneMapping( vec3 color ) {
	const mat3 ACESInputMat = mat3(
		vec3( 0.59719, 0.07600, 0.02840 ),		vec3( 0.35458, 0.90834, 0.13383 ),
		vec3( 0.04823, 0.01566, 0.83777 )
	);
	const mat3 ACESOutputMat = mat3(
		vec3(  1.60475, -0.10208, -0.00327 ),		vec3( -0.53108,  1.10813, -0.07276 ),
		vec3( -0.07367, -0.00605,  1.07602 )
	);
	color *= toneMappingExposure / 0.6;
	color = ACESInputMat * color;
	color = RRTAndODTFit( color );
	color = ACESOutputMat * color;
	return saturate( color );
}
vec3 CustomToneMapping( vec3 color ) { return color; }`,s1=`#ifdef USE_TRANSMISSION
	float transmissionAlpha = 1.0;
	float transmissionFactor = transmission;
	float thicknessFactor = thickness;
	#ifdef USE_TRANSMISSIONMAP
		transmissionFactor *= texture2D( transmissionMap, vUv ).r;
	#endif
	#ifdef USE_THICKNESSMAP
		thicknessFactor *= texture2D( thicknessMap, vUv ).g;
	#endif
	vec3 pos = vWorldPosition;
	vec3 v = normalize( cameraPosition - pos );
	vec3 n = inverseTransformDirection( normal, viewMatrix );
	vec4 transmission = getIBLVolumeRefraction(
		n, v, roughnessFactor, material.diffuseColor, material.specularColor, material.specularF90,
		pos, modelMatrix, viewMatrix, projectionMatrix, ior, thicknessFactor,
		attenuationColor, attenuationDistance );
	totalDiffuse = mix( totalDiffuse, transmission.rgb, transmissionFactor );
	transmissionAlpha = mix( transmissionAlpha, transmission.a, transmissionFactor );
#endif`,o1=`#ifdef USE_TRANSMISSION
	uniform float transmission;
	uniform float thickness;
	uniform float attenuationDistance;
	uniform vec3 attenuationColor;
	#ifdef USE_TRANSMISSIONMAP
		uniform sampler2D transmissionMap;
	#endif
	#ifdef USE_THICKNESSMAP
		uniform sampler2D thicknessMap;
	#endif
	uniform vec2 transmissionSamplerSize;
	uniform sampler2D transmissionSamplerMap;
	uniform mat4 modelMatrix;
	uniform mat4 projectionMatrix;
	varying vec3 vWorldPosition;
	vec3 getVolumeTransmissionRay( const in vec3 n, const in vec3 v, const in float thickness, const in float ior, const in mat4 modelMatrix ) {
		vec3 refractionVector = refract( - v, normalize( n ), 1.0 / ior );
		vec3 modelScale;
		modelScale.x = length( vec3( modelMatrix[ 0 ].xyz ) );
		modelScale.y = length( vec3( modelMatrix[ 1 ].xyz ) );
		modelScale.z = length( vec3( modelMatrix[ 2 ].xyz ) );
		return normalize( refractionVector ) * thickness * modelScale;
	}
	float applyIorToRoughness( const in float roughness, const in float ior ) {
		return roughness * clamp( ior * 2.0 - 2.0, 0.0, 1.0 );
	}
	vec4 getTransmissionSample( const in vec2 fragCoord, const in float roughness, const in float ior ) {
		float framebufferLod = log2( transmissionSamplerSize.x ) * applyIorToRoughness( roughness, ior );
		#ifdef TEXTURE_LOD_EXT
			return texture2DLodEXT( transmissionSamplerMap, fragCoord.xy, framebufferLod );
		#else
			return texture2D( transmissionSamplerMap, fragCoord.xy, framebufferLod );
		#endif
	}
	vec3 applyVolumeAttenuation( const in vec3 radiance, const in float transmissionDistance, const in vec3 attenuationColor, const in float attenuationDistance ) {
		if ( attenuationDistance == 0.0 ) {
			return radiance;
		} else {
			vec3 attenuationCoefficient = -log( attenuationColor ) / attenuationDistance;
			vec3 transmittance = exp( - attenuationCoefficient * transmissionDistance );			return transmittance * radiance;
		}
	}
	vec4 getIBLVolumeRefraction( const in vec3 n, const in vec3 v, const in float roughness, const in vec3 diffuseColor,
		const in vec3 specularColor, const in float specularF90, const in vec3 position, const in mat4 modelMatrix,
		const in mat4 viewMatrix, const in mat4 projMatrix, const in float ior, const in float thickness,
		const in vec3 attenuationColor, const in float attenuationDistance ) {
		vec3 transmissionRay = getVolumeTransmissionRay( n, v, thickness, ior, modelMatrix );
		vec3 refractedRayExit = position + transmissionRay;
		vec4 ndcPos = projMatrix * viewMatrix * vec4( refractedRayExit, 1.0 );
		vec2 refractionCoords = ndcPos.xy / ndcPos.w;
		refractionCoords += 1.0;
		refractionCoords /= 2.0;
		vec4 transmittedLight = getTransmissionSample( refractionCoords, roughness, ior );
		vec3 attenuatedColor = applyVolumeAttenuation( transmittedLight.rgb, length( transmissionRay ), attenuationColor, attenuationDistance );
		vec3 F = EnvironmentBRDF( n, v, specularColor, specularF90, roughness );
		return vec4( ( 1.0 - F ) * attenuatedColor * diffuseColor, transmittedLight.a );
	}
#endif`,a1=`#if ( defined( USE_UV ) && ! defined( UVS_VERTEX_ONLY ) )
	varying vec2 vUv;
#endif`,l1=`#ifdef USE_UV
	#ifdef UVS_VERTEX_ONLY
		vec2 vUv;
	#else
		varying vec2 vUv;
	#endif
	uniform mat3 uvTransform;
#endif`,c1=`#ifdef USE_UV
	vUv = ( uvTransform * vec3( uv, 1 ) ).xy;
#endif`,u1=`#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )
	varying vec2 vUv2;
#endif`,h1=`#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )
	attribute vec2 uv2;
	varying vec2 vUv2;
	uniform mat3 uv2Transform;
#endif`,f1=`#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )
	vUv2 = ( uv2Transform * vec3( uv2, 1 ) ).xy;
#endif`,d1=`#if defined( USE_ENVMAP ) || defined( DISTANCE ) || defined ( USE_SHADOWMAP ) || defined ( USE_TRANSMISSION )
	vec4 worldPosition = vec4( transformed, 1.0 );
	#ifdef USE_INSTANCING
		worldPosition = instanceMatrix * worldPosition;
	#endif
	worldPosition = modelMatrix * worldPosition;
#endif`,p1=`varying vec2 vUv;
uniform mat3 uvTransform;
void main() {
	vUv = ( uvTransform * vec3( uv, 1 ) ).xy;
	gl_Position = vec4( position.xy, 1.0, 1.0 );
}`,m1=`uniform sampler2D t2D;
varying vec2 vUv;
void main() {
	gl_FragColor = texture2D( t2D, vUv );
	#include <tonemapping_fragment>
	#include <encodings_fragment>
}`,g1=`varying vec3 vWorldDirection;
#include <common>
void main() {
	vWorldDirection = transformDirection( position, modelMatrix );
	#include <begin_vertex>
	#include <project_vertex>
	gl_Position.z = gl_Position.w;
}`,x1=`#include <envmap_common_pars_fragment>
uniform float opacity;
varying vec3 vWorldDirection;
#include <cube_uv_reflection_fragment>
void main() {
	vec3 vReflect = vWorldDirection;
	#include <envmap_fragment>
	gl_FragColor = envColor;
	gl_FragColor.a *= opacity;
	#include <tonemapping_fragment>
	#include <encodings_fragment>
}`,y1=`#include <common>
#include <uv_pars_vertex>
#include <displacementmap_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
varying vec2 vHighPrecisionZW;
void main() {
	#include <uv_vertex>
	#include <skinbase_vertex>
	#ifdef USE_DISPLACEMENTMAP
		#include <beginnormal_vertex>
		#include <morphnormal_vertex>
		#include <skinnormal_vertex>
	#endif
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	vHighPrecisionZW = gl_Position.zw;
}`,v1=`#if DEPTH_PACKING == 3200
	uniform float opacity;
#endif
#include <common>
#include <packing>
#include <uv_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
varying vec2 vHighPrecisionZW;
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( 1.0 );
	#if DEPTH_PACKING == 3200
		diffuseColor.a = opacity;
	#endif
	#include <map_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <logdepthbuf_fragment>
	float fragCoordZ = 0.5 * vHighPrecisionZW[0] / vHighPrecisionZW[1] + 0.5;
	#if DEPTH_PACKING == 3200
		gl_FragColor = vec4( vec3( 1.0 - fragCoordZ ), opacity );
	#elif DEPTH_PACKING == 3201
		gl_FragColor = packDepthToRGBA( fragCoordZ );
	#endif
}`,_1=`#define DISTANCE
varying vec3 vWorldPosition;
#include <common>
#include <uv_pars_vertex>
#include <displacementmap_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <skinbase_vertex>
	#ifdef USE_DISPLACEMENTMAP
		#include <beginnormal_vertex>
		#include <morphnormal_vertex>
		#include <skinnormal_vertex>
	#endif
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <worldpos_vertex>
	#include <clipping_planes_vertex>
	vWorldPosition = worldPosition.xyz;
}`,w1=`#define DISTANCE
uniform vec3 referencePosition;
uniform float nearDistance;
uniform float farDistance;
varying vec3 vWorldPosition;
#include <common>
#include <packing>
#include <uv_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <clipping_planes_pars_fragment>
void main () {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( 1.0 );
	#include <map_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	float dist = length( vWorldPosition - referencePosition );
	dist = ( dist - nearDistance ) / ( farDistance - nearDistance );
	dist = saturate( dist );
	gl_FragColor = packDepthToRGBA( dist );
}`,M1=`varying vec3 vWorldDirection;
#include <common>
void main() {
	vWorldDirection = transformDirection( position, modelMatrix );
	#include <begin_vertex>
	#include <project_vertex>
}`,b1=`uniform sampler2D tEquirect;
varying vec3 vWorldDirection;
#include <common>
void main() {
	vec3 direction = normalize( vWorldDirection );
	vec2 sampleUV = equirectUv( direction );
	gl_FragColor = texture2D( tEquirect, sampleUV );
	#include <tonemapping_fragment>
	#include <encodings_fragment>
}`,S1=`uniform float scale;
attribute float lineDistance;
varying float vLineDistance;
#include <common>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <morphtarget_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	vLineDistance = scale * lineDistance;
	#include <color_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	#include <fog_vertex>
}`,E1=`uniform vec3 diffuse;
uniform float opacity;
uniform float dashSize;
uniform float totalSize;
varying float vLineDistance;
#include <common>
#include <color_pars_fragment>
#include <fog_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	if ( mod( vLineDistance, totalSize ) > dashSize ) {
		discard;
	}
	vec3 outgoingLight = vec3( 0.0 );
	vec4 diffuseColor = vec4( diffuse, opacity );
	#include <logdepthbuf_fragment>
	#include <color_fragment>
	outgoingLight = diffuseColor.rgb;
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
}`,T1=`#include <common>
#include <uv_pars_vertex>
#include <uv2_pars_vertex>
#include <envmap_pars_vertex>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <uv2_vertex>
	#include <color_vertex>
	#if defined ( USE_ENVMAP ) || defined ( USE_SKINNING )
		#include <beginnormal_vertex>
		#include <morphnormal_vertex>
		#include <skinbase_vertex>
		#include <skinnormal_vertex>
		#include <defaultnormal_vertex>
	#endif
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	#include <worldpos_vertex>
	#include <envmap_vertex>
	#include <fog_vertex>
}`,A1=`uniform vec3 diffuse;
uniform float opacity;
#ifndef FLAT_SHADED
	varying vec3 vNormal;
#endif
#include <common>
#include <dithering_pars_fragment>
#include <color_pars_fragment>
#include <uv_pars_fragment>
#include <uv2_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <aomap_pars_fragment>
#include <lightmap_pars_fragment>
#include <envmap_common_pars_fragment>
#include <envmap_pars_fragment>
#include <cube_uv_reflection_fragment>
#include <fog_pars_fragment>
#include <specularmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( diffuse, opacity );
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <color_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <specularmap_fragment>
	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
	#ifdef USE_LIGHTMAP
		vec4 lightMapTexel= texture2D( lightMap, vUv2 );
		reflectedLight.indirectDiffuse += lightMapTexel.rgb * lightMapIntensity;
	#else
		reflectedLight.indirectDiffuse += vec3( 1.0 );
	#endif
	#include <aomap_fragment>
	reflectedLight.indirectDiffuse *= diffuseColor.rgb;
	vec3 outgoingLight = reflectedLight.indirectDiffuse;
	#include <envmap_fragment>
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
	#include <dithering_fragment>
}`,C1=`#define LAMBERT
varying vec3 vLightFront;
varying vec3 vIndirectFront;
#ifdef DOUBLE_SIDED
	varying vec3 vLightBack;
	varying vec3 vIndirectBack;
#endif
#include <common>
#include <uv_pars_vertex>
#include <uv2_pars_vertex>
#include <envmap_pars_vertex>
#include <bsdfs>
#include <lights_pars_begin>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <shadowmap_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <uv2_vertex>
	#include <color_vertex>
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	#include <worldpos_vertex>
	#include <envmap_vertex>
	#include <lights_lambert_vertex>
	#include <shadowmap_vertex>
	#include <fog_vertex>
}`,R1=`uniform vec3 diffuse;
uniform vec3 emissive;
uniform float opacity;
varying vec3 vLightFront;
varying vec3 vIndirectFront;
#ifdef DOUBLE_SIDED
	varying vec3 vLightBack;
	varying vec3 vIndirectBack;
#endif
#include <common>
#include <packing>
#include <dithering_pars_fragment>
#include <color_pars_fragment>
#include <uv_pars_fragment>
#include <uv2_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <aomap_pars_fragment>
#include <lightmap_pars_fragment>
#include <emissivemap_pars_fragment>
#include <envmap_common_pars_fragment>
#include <envmap_pars_fragment>
#include <cube_uv_reflection_fragment>
#include <bsdfs>
#include <lights_pars_begin>
#include <fog_pars_fragment>
#include <shadowmap_pars_fragment>
#include <shadowmask_pars_fragment>
#include <specularmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( diffuse, opacity );
	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
	vec3 totalEmissiveRadiance = emissive;
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <color_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <specularmap_fragment>
	#include <emissivemap_fragment>
	#ifdef DOUBLE_SIDED
		reflectedLight.indirectDiffuse += ( gl_FrontFacing ) ? vIndirectFront : vIndirectBack;
	#else
		reflectedLight.indirectDiffuse += vIndirectFront;
	#endif
	#include <lightmap_fragment>
	reflectedLight.indirectDiffuse *= BRDF_Lambert( diffuseColor.rgb );
	#ifdef DOUBLE_SIDED
		reflectedLight.directDiffuse = ( gl_FrontFacing ) ? vLightFront : vLightBack;
	#else
		reflectedLight.directDiffuse = vLightFront;
	#endif
	reflectedLight.directDiffuse *= BRDF_Lambert( diffuseColor.rgb ) * getShadowMask();
	#include <aomap_fragment>
	vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;
	#include <envmap_fragment>
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
	#include <dithering_fragment>
}`,L1=`#define MATCAP
varying vec3 vViewPosition;
#include <common>
#include <uv_pars_vertex>
#include <color_pars_vertex>
#include <displacementmap_pars_vertex>
#include <fog_pars_vertex>
#include <normal_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <color_vertex>
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <normal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	#include <fog_vertex>
	vViewPosition = - mvPosition.xyz;
}`,P1=`#define MATCAP
uniform vec3 diffuse;
uniform float opacity;
uniform sampler2D matcap;
varying vec3 vViewPosition;
#include <common>
#include <dithering_pars_fragment>
#include <color_pars_fragment>
#include <uv_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <fog_pars_fragment>
#include <normal_pars_fragment>
#include <bumpmap_pars_fragment>
#include <normalmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( diffuse, opacity );
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <color_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <normal_fragment_begin>
	#include <normal_fragment_maps>
	vec3 viewDir = normalize( vViewPosition );
	vec3 x = normalize( vec3( viewDir.z, 0.0, - viewDir.x ) );
	vec3 y = cross( viewDir, x );
	vec2 uv = vec2( dot( x, normal ), dot( y, normal ) ) * 0.495 + 0.5;
	#ifdef USE_MATCAP
		vec4 matcapColor = texture2D( matcap, uv );
	#else
		vec4 matcapColor = vec4( vec3( mix( 0.2, 0.8, uv.y ) ), 1.0 );
	#endif
	vec3 outgoingLight = diffuseColor.rgb * matcapColor.rgb;
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
	#include <dithering_fragment>
}`,D1=`#define NORMAL
#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )
	varying vec3 vViewPosition;
#endif
#include <common>
#include <uv_pars_vertex>
#include <displacementmap_pars_vertex>
#include <normal_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <normal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )
	vViewPosition = - mvPosition.xyz;
#endif
}`,I1=`#define NORMAL
uniform float opacity;
#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )
	varying vec3 vViewPosition;
#endif
#include <packing>
#include <uv_pars_fragment>
#include <normal_pars_fragment>
#include <bumpmap_pars_fragment>
#include <normalmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	#include <logdepthbuf_fragment>
	#include <normal_fragment_begin>
	#include <normal_fragment_maps>
	gl_FragColor = vec4( packNormalToRGB( normal ), opacity );
}`,N1=`#define PHONG
varying vec3 vViewPosition;
#include <common>
#include <uv_pars_vertex>
#include <uv2_pars_vertex>
#include <displacementmap_pars_vertex>
#include <envmap_pars_vertex>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <normal_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <shadowmap_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <uv2_vertex>
	#include <color_vertex>
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <normal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	vViewPosition = - mvPosition.xyz;
	#include <worldpos_vertex>
	#include <envmap_vertex>
	#include <shadowmap_vertex>
	#include <fog_vertex>
}`,F1=`#define PHONG
uniform vec3 diffuse;
uniform vec3 emissive;
uniform vec3 specular;
uniform float shininess;
uniform float opacity;
#include <common>
#include <packing>
#include <dithering_pars_fragment>
#include <color_pars_fragment>
#include <uv_pars_fragment>
#include <uv2_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <aomap_pars_fragment>
#include <lightmap_pars_fragment>
#include <emissivemap_pars_fragment>
#include <envmap_common_pars_fragment>
#include <envmap_pars_fragment>
#include <cube_uv_reflection_fragment>
#include <fog_pars_fragment>
#include <bsdfs>
#include <lights_pars_begin>
#include <normal_pars_fragment>
#include <lights_phong_pars_fragment>
#include <shadowmap_pars_fragment>
#include <bumpmap_pars_fragment>
#include <normalmap_pars_fragment>
#include <specularmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( diffuse, opacity );
	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
	vec3 totalEmissiveRadiance = emissive;
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <color_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <specularmap_fragment>
	#include <normal_fragment_begin>
	#include <normal_fragment_maps>
	#include <emissivemap_fragment>
	#include <lights_phong_fragment>
	#include <lights_fragment_begin>
	#include <lights_fragment_maps>
	#include <lights_fragment_end>
	#include <aomap_fragment>
	vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance;
	#include <envmap_fragment>
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
	#include <dithering_fragment>
}`,z1=`#define STANDARD
varying vec3 vViewPosition;
#ifdef USE_TRANSMISSION
	varying vec3 vWorldPosition;
#endif
#include <common>
#include <uv_pars_vertex>
#include <uv2_pars_vertex>
#include <displacementmap_pars_vertex>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <normal_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <shadowmap_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <uv2_vertex>
	#include <color_vertex>
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <normal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	vViewPosition = - mvPosition.xyz;
	#include <worldpos_vertex>
	#include <shadowmap_vertex>
	#include <fog_vertex>
#ifdef USE_TRANSMISSION
	vWorldPosition = worldPosition.xyz;
#endif
}`,U1=`#define STANDARD
#ifdef PHYSICAL
	#define IOR
	#define SPECULAR
#endif
uniform vec3 diffuse;
uniform vec3 emissive;
uniform float roughness;
uniform float metalness;
uniform float opacity;
#ifdef IOR
	uniform float ior;
#endif
#ifdef SPECULAR
	uniform float specularIntensity;
	uniform vec3 specularColor;
	#ifdef USE_SPECULARINTENSITYMAP
		uniform sampler2D specularIntensityMap;
	#endif
	#ifdef USE_SPECULARCOLORMAP
		uniform sampler2D specularColorMap;
	#endif
#endif
#ifdef USE_CLEARCOAT
	uniform float clearcoat;
	uniform float clearcoatRoughness;
#endif
#ifdef USE_SHEEN
	uniform vec3 sheenColor;
	uniform float sheenRoughness;
	#ifdef USE_SHEENCOLORMAP
		uniform sampler2D sheenColorMap;
	#endif
	#ifdef USE_SHEENROUGHNESSMAP
		uniform sampler2D sheenRoughnessMap;
	#endif
#endif
varying vec3 vViewPosition;
#include <common>
#include <packing>
#include <dithering_pars_fragment>
#include <color_pars_fragment>
#include <uv_pars_fragment>
#include <uv2_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <aomap_pars_fragment>
#include <lightmap_pars_fragment>
#include <emissivemap_pars_fragment>
#include <bsdfs>
#include <cube_uv_reflection_fragment>
#include <envmap_common_pars_fragment>
#include <envmap_physical_pars_fragment>
#include <fog_pars_fragment>
#include <lights_pars_begin>
#include <normal_pars_fragment>
#include <lights_physical_pars_fragment>
#include <transmission_pars_fragment>
#include <shadowmap_pars_fragment>
#include <bumpmap_pars_fragment>
#include <normalmap_pars_fragment>
#include <clearcoat_pars_fragment>
#include <roughnessmap_pars_fragment>
#include <metalnessmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( diffuse, opacity );
	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
	vec3 totalEmissiveRadiance = emissive;
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <color_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <roughnessmap_fragment>
	#include <metalnessmap_fragment>
	#include <normal_fragment_begin>
	#include <normal_fragment_maps>
	#include <clearcoat_normal_fragment_begin>
	#include <clearcoat_normal_fragment_maps>
	#include <emissivemap_fragment>
	#include <lights_physical_fragment>
	#include <lights_fragment_begin>
	#include <lights_fragment_maps>
	#include <lights_fragment_end>
	#include <aomap_fragment>
	vec3 totalDiffuse = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse;
	vec3 totalSpecular = reflectedLight.directSpecular + reflectedLight.indirectSpecular;
	#include <transmission_fragment>
	vec3 outgoingLight = totalDiffuse + totalSpecular + totalEmissiveRadiance;
	#ifdef USE_SHEEN
		float sheenEnergyComp = 1.0 - 0.157 * max3( material.sheenColor );
		outgoingLight = outgoingLight * sheenEnergyComp + sheenSpecular;
	#endif
	#ifdef USE_CLEARCOAT
		float dotNVcc = saturate( dot( geometry.clearcoatNormal, geometry.viewDir ) );
		vec3 Fcc = F_Schlick( material.clearcoatF0, material.clearcoatF90, dotNVcc );
		outgoingLight = outgoingLight * ( 1.0 - material.clearcoat * Fcc ) + clearcoatSpecular * material.clearcoat;
	#endif
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
	#include <dithering_fragment>
}`,B1=`#define TOON
varying vec3 vViewPosition;
#include <common>
#include <uv_pars_vertex>
#include <uv2_pars_vertex>
#include <displacementmap_pars_vertex>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <normal_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <shadowmap_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <uv2_vertex>
	#include <color_vertex>
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <normal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	vViewPosition = - mvPosition.xyz;
	#include <worldpos_vertex>
	#include <shadowmap_vertex>
	#include <fog_vertex>
}`,O1=`#define TOON
uniform vec3 diffuse;
uniform vec3 emissive;
uniform float opacity;
#include <common>
#include <packing>
#include <dithering_pars_fragment>
#include <color_pars_fragment>
#include <uv_pars_fragment>
#include <uv2_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <aomap_pars_fragment>
#include <lightmap_pars_fragment>
#include <emissivemap_pars_fragment>
#include <gradientmap_pars_fragment>
#include <fog_pars_fragment>
#include <bsdfs>
#include <lights_pars_begin>
#include <normal_pars_fragment>
#include <lights_toon_pars_fragment>
#include <shadowmap_pars_fragment>
#include <bumpmap_pars_fragment>
#include <normalmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( diffuse, opacity );
	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
	vec3 totalEmissiveRadiance = emissive;
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <color_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <normal_fragment_begin>
	#include <normal_fragment_maps>
	#include <emissivemap_fragment>
	#include <lights_toon_fragment>
	#include <lights_fragment_begin>
	#include <lights_fragment_maps>
	#include <lights_fragment_end>
	#include <aomap_fragment>
	vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
	#include <dithering_fragment>
}`,k1=`uniform float size;
uniform float scale;
#include <common>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <morphtarget_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <color_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <project_vertex>
	gl_PointSize = size;
	#ifdef USE_SIZEATTENUATION
		bool isPerspective = isPerspectiveMatrix( projectionMatrix );
		if ( isPerspective ) gl_PointSize *= ( scale / - mvPosition.z );
	#endif
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	#include <worldpos_vertex>
	#include <fog_vertex>
}`,H1=`uniform vec3 diffuse;
uniform float opacity;
#include <common>
#include <color_pars_fragment>
#include <map_particle_pars_fragment>
#include <alphatest_pars_fragment>
#include <fog_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec3 outgoingLight = vec3( 0.0 );
	vec4 diffuseColor = vec4( diffuse, opacity );
	#include <logdepthbuf_fragment>
	#include <map_particle_fragment>
	#include <color_fragment>
	#include <alphatest_fragment>
	outgoingLight = diffuseColor.rgb;
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
}`,V1=`#include <common>
#include <fog_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <shadowmap_pars_vertex>
void main() {
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <project_vertex>
	#include <worldpos_vertex>
	#include <shadowmap_vertex>
	#include <fog_vertex>
}`,G1=`uniform vec3 color;
uniform float opacity;
#include <common>
#include <packing>
#include <fog_pars_fragment>
#include <bsdfs>
#include <lights_pars_begin>
#include <shadowmap_pars_fragment>
#include <shadowmask_pars_fragment>
void main() {
	gl_FragColor = vec4( color, opacity * ( 1.0 - getShadowMask() ) );
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
}`,W1=`uniform float rotation;
uniform vec2 center;
#include <common>
#include <uv_pars_vertex>
#include <fog_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	vec4 mvPosition = modelViewMatrix * vec4( 0.0, 0.0, 0.0, 1.0 );
	vec2 scale;
	scale.x = length( vec3( modelMatrix[ 0 ].x, modelMatrix[ 0 ].y, modelMatrix[ 0 ].z ) );
	scale.y = length( vec3( modelMatrix[ 1 ].x, modelMatrix[ 1 ].y, modelMatrix[ 1 ].z ) );
	#ifndef USE_SIZEATTENUATION
		bool isPerspective = isPerspectiveMatrix( projectionMatrix );
		if ( isPerspective ) scale *= - mvPosition.z;
	#endif
	vec2 alignedPosition = ( position.xy - ( center - vec2( 0.5 ) ) ) * scale;
	vec2 rotatedPosition;
	rotatedPosition.x = cos( rotation ) * alignedPosition.x - sin( rotation ) * alignedPosition.y;
	rotatedPosition.y = sin( rotation ) * alignedPosition.x + cos( rotation ) * alignedPosition.y;
	mvPosition.xy += rotatedPosition;
	gl_Position = projectionMatrix * mvPosition;
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	#include <fog_vertex>
}`,q1=`uniform vec3 diffuse;
uniform float opacity;
#include <common>
#include <uv_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <fog_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec3 outgoingLight = vec3( 0.0 );
	vec4 diffuseColor = vec4( diffuse, opacity );
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	outgoingLight = diffuseColor.rgb;
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
}`,Pt={alphamap_fragment:_M,alphamap_pars_fragment:wM,alphatest_fragment:MM,alphatest_pars_fragment:bM,aomap_fragment:SM,aomap_pars_fragment:EM,begin_vertex:TM,beginnormal_vertex:AM,bsdfs:CM,bumpmap_pars_fragment:RM,clipping_planes_fragment:LM,clipping_planes_pars_fragment:PM,clipping_planes_pars_vertex:DM,clipping_planes_vertex:IM,color_fragment:NM,color_pars_fragment:FM,color_pars_vertex:zM,color_vertex:UM,common:BM,cube_uv_reflection_fragment:OM,defaultnormal_vertex:kM,displacementmap_pars_vertex:HM,displacementmap_vertex:VM,emissivemap_fragment:GM,emissivemap_pars_fragment:WM,encodings_fragment:qM,encodings_pars_fragment:XM,envmap_fragment:YM,envmap_common_pars_fragment:ZM,envmap_pars_fragment:JM,envmap_pars_vertex:$M,envmap_physical_pars_fragment:ab,envmap_vertex:KM,fog_vertex:QM,fog_pars_vertex:jM,fog_fragment:tb,fog_pars_fragment:eb,gradientmap_pars_fragment:nb,lightmap_fragment:ib,lightmap_pars_fragment:rb,lights_lambert_vertex:sb,lights_pars_begin:ob,lights_toon_fragment:lb,lights_toon_pars_fragment:cb,lights_phong_fragment:ub,lights_phong_pars_fragment:hb,lights_physical_fragment:fb,lights_physical_pars_fragment:db,lights_fragment_begin:pb,lights_fragment_maps:mb,lights_fragment_end:gb,logdepthbuf_fragment:xb,logdepthbuf_pars_fragment:yb,logdepthbuf_pars_vertex:vb,logdepthbuf_vertex:_b,map_fragment:wb,map_pars_fragment:Mb,map_particle_fragment:bb,map_particle_pars_fragment:Sb,metalnessmap_fragment:Eb,metalnessmap_pars_fragment:Tb,morphnormal_vertex:Ab,morphtarget_pars_vertex:Cb,morphtarget_vertex:Rb,normal_fragment_begin:Lb,normal_fragment_maps:Pb,normal_pars_fragment:Db,normal_pars_vertex:Ib,normal_vertex:Nb,normalmap_pars_fragment:Fb,clearcoat_normal_fragment_begin:zb,clearcoat_normal_fragment_maps:Ub,clearcoat_pars_fragment:Bb,output_fragment:Ob,packing:kb,premultiplied_alpha_fragment:Hb,project_vertex:Vb,dithering_fragment:Gb,dithering_pars_fragment:Wb,roughnessmap_fragment:qb,roughnessmap_pars_fragment:Xb,shadowmap_pars_fragment:Yb,shadowmap_pars_vertex:Zb,shadowmap_vertex:Jb,shadowmask_pars_fragment:$b,skinbase_vertex:Kb,skinning_pars_vertex:Qb,skinning_vertex:jb,skinnormal_vertex:t1,specularmap_fragment:e1,specularmap_pars_fragment:n1,tonemapping_fragment:i1,tonemapping_pars_fragment:r1,transmission_fragment:s1,transmission_pars_fragment:o1,uv_pars_fragment:a1,uv_pars_vertex:l1,uv_vertex:c1,uv2_pars_fragment:u1,uv2_pars_vertex:h1,uv2_vertex:f1,worldpos_vertex:d1,background_vert:p1,background_frag:m1,cube_vert:g1,cube_frag:x1,depth_vert:y1,depth_frag:v1,distanceRGBA_vert:_1,distanceRGBA_frag:w1,equirect_vert:M1,equirect_frag:b1,linedashed_vert:S1,linedashed_frag:E1,meshbasic_vert:T1,meshbasic_frag:A1,meshlambert_vert:C1,meshlambert_frag:R1,meshmatcap_vert:L1,meshmatcap_frag:P1,meshnormal_vert:D1,meshnormal_frag:I1,meshphong_vert:N1,meshphong_frag:F1,meshphysical_vert:z1,meshphysical_frag:U1,meshtoon_vert:B1,meshtoon_frag:O1,points_vert:k1,points_frag:H1,shadow_vert:V1,shadow_frag:G1,sprite_vert:W1,sprite_frag:q1},ot={common:{diffuse:{value:new ft(16777215)},opacity:{value:1},map:{value:null},uvTransform:{value:new de},uv2Transform:{value:new de},alphaMap:{value:null},alphaTest:{value:0}},specularmap:{specularMap:{value:null}},envmap:{envMap:{value:null},flipEnvMap:{value:-1},reflectivity:{value:1},ior:{value:1.5},refractionRatio:{value:.98}},aomap:{aoMap:{value:null},aoMapIntensity:{value:1}},lightmap:{lightMap:{value:null},lightMapIntensity:{value:1}},emissivemap:{emissiveMap:{value:null}},bumpmap:{bumpMap:{value:null},bumpScale:{value:1}},normalmap:{normalMap:{value:null},normalScale:{value:new K(1,1)}},displacementmap:{displacementMap:{value:null},displacementScale:{value:1},displacementBias:{value:0}},roughnessmap:{roughnessMap:{value:null}},metalnessmap:{metalnessMap:{value:null}},gradientmap:{gradientMap:{value:null}},fog:{fogDensity:{value:25e-5},fogNear:{value:1},fogFar:{value:2e3},fogColor:{value:new ft(16777215)}},lights:{ambientLightColor:{value:[]},lightProbe:{value:[]},directionalLights:{value:[],properties:{direction:{},color:{}}},directionalLightShadows:{value:[],properties:{shadowBias:{},shadowNormalBias:{},shadowRadius:{},shadowMapSize:{}}},directionalShadowMap:{value:[]},directionalShadowMatrix:{value:[]},spotLights:{value:[],properties:{color:{},position:{},direction:{},distance:{},coneCos:{},penumbraCos:{},decay:{}}},spotLightShadows:{value:[],properties:{shadowBias:{},shadowNormalBias:{},shadowRadius:{},shadowMapSize:{}}},spotShadowMap:{value:[]},spotShadowMatrix:{value:[]},pointLights:{value:[],properties:{color:{},position:{},decay:{},distance:{}}},pointLightShadows:{value:[],properties:{shadowBias:{},shadowNormalBias:{},shadowRadius:{},shadowMapSize:{},shadowCameraNear:{},shadowCameraFar:{}}},pointShadowMap:{value:[]},pointShadowMatrix:{value:[]},hemisphereLights:{value:[],properties:{direction:{},skyColor:{},groundColor:{}}},rectAreaLights:{value:[],properties:{color:{},position:{},width:{},height:{}}},ltc_1:{value:null},ltc_2:{value:null}},points:{diffuse:{value:new ft(16777215)},opacity:{value:1},size:{value:1},scale:{value:1},map:{value:null},alphaMap:{value:null},alphaTest:{value:0},uvTransform:{value:new de}},sprite:{diffuse:{value:new ft(16777215)},opacity:{value:1},center:{value:new K(.5,.5)},rotation:{value:0},map:{value:null},alphaMap:{value:null},alphaTest:{value:0},uvTransform:{value:new de}}},fn={basic:{uniforms:Me([ot.common,ot.specularmap,ot.envmap,ot.aomap,ot.lightmap,ot.fog]),vertexShader:Pt.meshbasic_vert,fragmentShader:Pt.meshbasic_frag},lambert:{uniforms:Me([ot.common,ot.specularmap,ot.envmap,ot.aomap,ot.lightmap,ot.emissivemap,ot.fog,ot.lights,{emissive:{value:new ft(0)}}]),vertexShader:Pt.meshlambert_vert,fragmentShader:Pt.meshlambert_frag},phong:{uniforms:Me([ot.common,ot.specularmap,ot.envmap,ot.aomap,ot.lightmap,ot.emissivemap,ot.bumpmap,ot.normalmap,ot.displacementmap,ot.fog,ot.lights,{emissive:{value:new ft(0)},specular:{value:new ft(1118481)},shininess:{value:30}}]),vertexShader:Pt.meshphong_vert,fragmentShader:Pt.meshphong_frag},standard:{uniforms:Me([ot.common,ot.envmap,ot.aomap,ot.lightmap,ot.emissivemap,ot.bumpmap,ot.normalmap,ot.displacementmap,ot.roughnessmap,ot.metalnessmap,ot.fog,ot.lights,{emissive:{value:new ft(0)},roughness:{value:1},metalness:{value:0},envMapIntensity:{value:1}}]),vertexShader:Pt.meshphysical_vert,fragmentShader:Pt.meshphysical_frag},toon:{uniforms:Me([ot.common,ot.aomap,ot.lightmap,ot.emissivemap,ot.bumpmap,ot.normalmap,ot.displacementmap,ot.gradientmap,ot.fog,ot.lights,{emissive:{value:new ft(0)}}]),vertexShader:Pt.meshtoon_vert,fragmentShader:Pt.meshtoon_frag},matcap:{uniforms:Me([ot.common,ot.bumpmap,ot.normalmap,ot.displacementmap,ot.fog,{matcap:{value:null}}]),vertexShader:Pt.meshmatcap_vert,fragmentShader:Pt.meshmatcap_frag},points:{uniforms:Me([ot.points,ot.fog]),vertexShader:Pt.points_vert,fragmentShader:Pt.points_frag},dashed:{uniforms:Me([ot.common,ot.fog,{scale:{value:1},dashSize:{value:1},totalSize:{value:2}}]),vertexShader:Pt.linedashed_vert,fragmentShader:Pt.linedashed_frag},depth:{uniforms:Me([ot.common,ot.displacementmap]),vertexShader:Pt.depth_vert,fragmentShader:Pt.depth_frag},normal:{uniforms:Me([ot.common,ot.bumpmap,ot.normalmap,ot.displacementmap,{opacity:{value:1}}]),vertexShader:Pt.meshnormal_vert,fragmentShader:Pt.meshnormal_frag},sprite:{uniforms:Me([ot.sprite,ot.fog]),vertexShader:Pt.sprite_vert,fragmentShader:Pt.sprite_frag},background:{uniforms:{uvTransform:{value:new de},t2D:{value:null}},vertexShader:Pt.background_vert,fragmentShader:Pt.background_frag},cube:{uniforms:Me([ot.envmap,{opacity:{value:1}}]),vertexShader:Pt.cube_vert,fragmentShader:Pt.cube_frag},equirect:{uniforms:{tEquirect:{value:null}},vertexShader:Pt.equirect_vert,fragmentShader:Pt.equirect_frag},distanceRGBA:{uniforms:Me([ot.common,ot.displacementmap,{referencePosition:{value:new T},nearDistance:{value:1},farDistance:{value:1e3}}]),vertexShader:Pt.distanceRGBA_vert,fragmentShader:Pt.distanceRGBA_frag},shadow:{uniforms:Me([ot.lights,ot.fog,{color:{value:new ft(0)},opacity:{value:1}}]),vertexShader:Pt.shadow_vert,fragmentShader:Pt.shadow_frag}};fn.physical={uniforms:Me([fn.standard.uniforms,{clearcoat:{value:0},clearcoatMap:{value:null},clearcoatRoughness:{value:0},clearcoatRoughnessMap:{value:null},clearcoatNormalScale:{value:new K(1,1)},clearcoatNormalMap:{value:null},sheen:{value:0},sheenColor:{value:new ft(0)},sheenColorMap:{value:null},sheenRoughness:{value:1},sheenRoughnessMap:{value:null},transmission:{value:0},transmissionMap:{value:null},transmissionSamplerSize:{value:new K},transmissionSamplerMap:{value:null},thickness:{value:0},thicknessMap:{value:null},attenuationDistance:{value:0},attenuationColor:{value:new ft(0)},specularIntensity:{value:1},specularIntensityMap:{value:null},specularColor:{value:new ft(1,1,1)},specularColorMap:{value:null}}]),vertexShader:Pt.meshphysical_vert,fragmentShader:Pt.meshphysical_frag};function X1(n,t,e,i,r,s){let o=new ft(0),a=r===!0?0:1,l,c,u=null,h=0,f=null;function d(x,v){let m=!1,p=v.isScene===!0?v.background:null;p&&p.isTexture&&(p=t.get(p));let b=n.xr,_=b.getSession&&b.getSession();_&&_.environmentBlendMode==="additive"&&(p=null),p===null?g(o,a):p&&p.isColor&&(g(p,1),m=!0),(n.autoClear||m)&&n.clear(n.autoClearColor,n.autoClearDepth,n.autoClearStencil),p&&(p.isCubeTexture||p.mapping===Rl)?(c===void 0&&(c=new oe(new Hi(1,1,1),new Fn({name:"BackgroundCubeMaterial",uniforms:Gr(fn.cube.uniforms),vertexShader:fn.cube.vertexShader,fragmentShader:fn.cube.fragmentShader,side:he,depthTest:!1,depthWrite:!1,fog:!1})),c.geometry.deleteAttribute("normal"),c.geometry.deleteAttribute("uv"),c.onBeforeRender=function(S,L,A){this.matrixWorld.copyPosition(A.matrixWorld)},Object.defineProperty(c.material,"envMap",{get:function(){return this.uniforms.envMap.value}}),i.update(c)),c.material.uniforms.envMap.value=p,c.material.uniforms.flipEnvMap.value=p.isCubeTexture&&p.isRenderTargetTexture===!1?-1:1,(u!==p||h!==p.version||f!==n.toneMapping)&&(c.material.needsUpdate=!0,u=p,h=p.version,f=n.toneMapping),x.unshift(c,c.geometry,c.material,0,0,null)):p&&p.isTexture&&(l===void 0&&(l=new oe(new lo(2,2),new Fn({name:"BackgroundMaterial",uniforms:Gr(fn.background.uniforms),vertexShader:fn.background.vertexShader,fragmentShader:fn.background.fragmentShader,side:eo,depthTest:!1,depthWrite:!1,fog:!1})),l.geometry.deleteAttribute("normal"),Object.defineProperty(l.material,"map",{get:function(){return this.uniforms.t2D.value}}),i.update(l)),l.material.uniforms.t2D.value=p,p.matrixAutoUpdate===!0&&p.updateMatrix(),l.material.uniforms.uvTransform.value.copy(p.matrix),(u!==p||h!==p.version||f!==n.toneMapping)&&(l.material.needsUpdate=!0,u=p,h=p.version,f=n.toneMapping),x.unshift(l,l.geometry,l.material,0,0,null))}function g(x,v){e.buffers.color.setClear(x.r,x.g,x.b,v,s)}return{getClearColor:function(){return o},setClearColor:function(x,v=1){o.set(x),a=v,g(o,a)},getClearAlpha:function(){return a},setClearAlpha:function(x){a=x,g(o,a)},render:d}}function Y1(n,t,e,i){let r=n.getParameter(34921),s=i.isWebGL2?null:t.get("OES_vertex_array_object"),o=i.isWebGL2||s!==null,a={},l=x(null),c=l;function u(D,F,z,N,V){let Q=!1;if(o){let at=g(N,z,F);c!==at&&(c=at,f(c.object)),Q=v(N,V),Q&&m(N,V)}else{let at=F.wireframe===!0;(c.geometry!==N.id||c.program!==z.id||c.wireframe!==at)&&(c.geometry=N.id,c.program=z.id,c.wireframe=at,Q=!0)}D.isInstancedMesh===!0&&(Q=!0),V!==null&&e.update(V,34963),Q&&(A(D,F,z,N),V!==null&&n.bindBuffer(34963,e.get(V).buffer))}function h(){return i.isWebGL2?n.createVertexArray():s.createVertexArrayOES()}function f(D){return i.isWebGL2?n.bindVertexArray(D):s.bindVertexArrayOES(D)}function d(D){return i.isWebGL2?n.deleteVertexArray(D):s.deleteVertexArrayOES(D)}function g(D,F,z){let N=z.wireframe===!0,V=a[D.id];V===void 0&&(V={},a[D.id]=V);let Q=V[F.id];Q===void 0&&(Q={},V[F.id]=Q);let at=Q[N];return at===void 0&&(at=x(h()),Q[N]=at),at}function x(D){let F=[],z=[],N=[];for(let V=0;V<r;V++)F[V]=0,z[V]=0,N[V]=0;return{geometry:null,program:null,wireframe:!1,newAttributes:F,enabledAttributes:z,attributeDivisors:N,object:D,attributes:{},index:null}}function v(D,F){let z=c.attributes,N=D.attributes,V=0;for(let Q in N){let at=z[Q],G=N[Q];if(at===void 0||at.attribute!==G||at.data!==G.data)return!0;V++}return c.attributesNum!==V||c.index!==F}function m(D,F){let z={},N=D.attributes,V=0;for(let Q in N){let at=N[Q],G={};G.attribute=at,at.data&&(G.data=at.data),z[Q]=G,V++}c.attributes=z,c.attributesNum=V,c.index=F}function p(){let D=c.newAttributes;for(let F=0,z=D.length;F<z;F++)D[F]=0}function b(D){_(D,0)}function _(D,F){let z=c.newAttributes,N=c.enabledAttributes,V=c.attributeDivisors;z[D]=1,N[D]===0&&(n.enableVertexAttribArray(D),N[D]=1),V[D]!==F&&((i.isWebGL2?n:t.get("ANGLE_instanced_arrays"))[i.isWebGL2?"vertexAttribDivisor":"vertexAttribDivisorANGLE"](D,F),V[D]=F)}function S(){let D=c.newAttributes,F=c.enabledAttributes;for(let z=0,N=F.length;z<N;z++)F[z]!==D[z]&&(n.disableVertexAttribArray(z),F[z]=0)}function L(D,F,z,N,V,Q){i.isWebGL2===!0&&(z===5124||z===5125)?n.vertexAttribIPointer(D,F,z,V,Q):n.vertexAttribPointer(D,F,z,N,V,Q)}function A(D,F,z,N){if(i.isWebGL2===!1&&(D.isInstancedMesh||N.isInstancedBufferGeometry)&&t.get("ANGLE_instanced_arrays")===null)return;p();let V=N.attributes,Q=z.getAttributes(),at=F.defaultAttributeValues;for(let G in Q){let $=Q[G];if($.location>=0){let lt=V[G];if(lt===void 0&&(G==="instanceMatrix"&&D.instanceMatrix&&(lt=D.instanceMatrix),G==="instanceColor"&&D.instanceColor&&(lt=D.instanceColor)),lt!==void 0){let dt=lt.normalized,xt=lt.itemSize,k=e.get(lt);if(k===void 0)continue;let Ft=k.buffer,mt=k.type,St=k.bytesPerElement;if(lt.isInterleavedBufferAttribute){let B=lt.data,st=B.stride,nt=lt.offset;if(B&&B.isInstancedInterleavedBuffer){for(let C=0;C<$.locationSize;C++)_($.location+C,B.meshPerAttribute);D.isInstancedMesh!==!0&&N._maxInstanceCount===void 0&&(N._maxInstanceCount=B.meshPerAttribute*B.count)}else for(let C=0;C<$.locationSize;C++)b($.location+C);n.bindBuffer(34962,Ft);for(let C=0;C<$.locationSize;C++)L($.location+C,xt/$.locationSize,mt,dt,st*St,(nt+xt/$.locationSize*C)*St)}else{if(lt.isInstancedBufferAttribute){for(let B=0;B<$.locationSize;B++)_($.location+B,lt.meshPerAttribute);D.isInstancedMesh!==!0&&N._maxInstanceCount===void 0&&(N._maxInstanceCount=lt.meshPerAttribute*lt.count)}else for(let B=0;B<$.locationSize;B++)b($.location+B);n.bindBuffer(34962,Ft);for(let B=0;B<$.locationSize;B++)L($.location+B,xt/$.locationSize,mt,dt,xt*St,xt/$.locationSize*B*St)}}else if(at!==void 0){let dt=at[G];if(dt!==void 0)switch(dt.length){case 2:n.vertexAttrib2fv($.location,dt);break;case 3:n.vertexAttrib3fv($.location,dt);break;case 4:n.vertexAttrib4fv($.location,dt);break;default:n.vertexAttrib1fv($.location,dt)}}}}S()}function H(){y();for(let D in a){let F=a[D];for(let z in F){let N=F[z];for(let V in N)d(N[V].object),delete N[V];delete F[z]}delete a[D]}}function tt(D){if(a[D.id]===void 0)return;let F=a[D.id];for(let z in F){let N=F[z];for(let V in N)d(N[V].object),delete N[V];delete F[z]}delete a[D.id]}function X(D){for(let F in a){let z=a[F];if(z[D.id]===void 0)continue;let N=z[D.id];for(let V in N)d(N[V].object),delete N[V];delete z[D.id]}}function y(){R(),c!==l&&(c=l,f(c.object))}function R(){l.geometry=null,l.program=null,l.wireframe=!1}return{setup:u,reset:y,resetDefaultState:R,dispose:H,releaseStatesOfGeometry:tt,releaseStatesOfProgram:X,initAttributes:p,enableAttribute:b,disableUnusedAttributes:S}}function Z1(n,t,e,i){let r=i.isWebGL2,s;function o(c){s=c}function a(c,u){n.drawArrays(s,c,u),e.update(u,s,1)}function l(c,u,h){if(h===0)return;let f,d;if(r)f=n,d="drawArraysInstanced";else if(f=t.get("ANGLE_instanced_arrays"),d="drawArraysInstancedANGLE",f===null){console.error("THREE.WebGLBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.");return}f[d](s,c,u,h),e.update(u,s,h)}this.setMode=o,this.render=a,this.renderInstances=l}function J1(n,t,e){let i;function r(){if(i!==void 0)return i;if(t.has("EXT_texture_filter_anisotropic")===!0){let A=t.get("EXT_texture_filter_anisotropic");i=n.getParameter(A.MAX_TEXTURE_MAX_ANISOTROPY_EXT)}else i=0;return i}function s(A){if(A==="highp"){if(n.getShaderPrecisionFormat(35633,36338).precision>0&&n.getShaderPrecisionFormat(35632,36338).precision>0)return"highp";A="mediump"}return A==="mediump"&&n.getShaderPrecisionFormat(35633,36337).precision>0&&n.getShaderPrecisionFormat(35632,36337).precision>0?"mediump":"lowp"}let o=typeof WebGL2RenderingContext!="undefined"&&n instanceof WebGL2RenderingContext||typeof WebGL2ComputeRenderingContext!="undefined"&&n instanceof WebGL2ComputeRenderingContext,a=e.precision!==void 0?e.precision:"highp",l=s(a);l!==a&&(console.warn("THREE.WebGLRenderer:",a,"not supported, using",l,"instead."),a=l);let c=o||t.has("WEBGL_draw_buffers"),u=e.logarithmicDepthBuffer===!0,h=n.getParameter(34930),f=n.getParameter(35660),d=n.getParameter(3379),g=n.getParameter(34076),x=n.getParameter(34921),v=n.getParameter(36347),m=n.getParameter(36348),p=n.getParameter(36349),b=f>0,_=o||t.has("OES_texture_float"),S=b&&_,L=o?n.getParameter(36183):0;return{isWebGL2:o,drawBuffers:c,getMaxAnisotropy:r,getMaxPrecision:s,precision:a,logarithmicDepthBuffer:u,maxTextures:h,maxVertexTextures:f,maxTextureSize:d,maxCubemapSize:g,maxAttributes:x,maxVertexUniforms:v,maxVaryings:m,maxFragmentUniforms:p,vertexTextures:b,floatFragmentTextures:_,floatVertexTextures:S,maxSamples:L}}function $1(n){let t=this,e=null,i=0,r=!1,s=!1,o=new je,a=new de,l={value:null,needsUpdate:!1};this.uniform=l,this.numPlanes=0,this.numIntersection=0,this.init=function(h,f,d){let g=h.length!==0||f||i!==0||r;return r=f,e=u(h,d,0),i=h.length,g},this.beginShadows=function(){s=!0,u(null)},this.endShadows=function(){s=!1,c()},this.setState=function(h,f,d){let g=h.clippingPlanes,x=h.clipIntersection,v=h.clipShadows,m=n.get(h);if(!r||g===null||g.length===0||s&&!v)s?u(null):c();else{let p=s?0:i,b=p*4,_=m.clippingState||null;l.value=_,_=u(g,f,b,d);for(let S=0;S!==b;++S)_[S]=e[S];m.clippingState=_,this.numIntersection=x?this.numPlanes:0,this.numPlanes+=p}};function c(){l.value!==e&&(l.value=e,l.needsUpdate=i>0),t.numPlanes=i,t.numIntersection=0}function u(h,f,d,g){let x=h!==null?h.length:0,v=null;if(x!==0){if(v=l.value,g!==!0||v===null){let m=d+x*4,p=f.matrixWorldInverse;a.getNormalMatrix(p),(v===null||v.length<m)&&(v=new Float32Array(m));for(let b=0,_=d;b!==x;++b,_+=4)o.copy(h[b]).applyMatrix4(p,a),o.normal.toArray(v,_),v[_+3]=o.constant}l.value=v,l.needsUpdate=!0}return t.numPlanes=x,t.numIntersection=0,v}}function K1(n){let t=new WeakMap;function e(o,a){return a===Uu?o.mapping=Ao:a===Bu&&(o.mapping=Co),o}function i(o){if(o&&o.isTexture&&o.isRenderTargetTexture===!1){let a=o.mapping;if(a===Uu||a===Bu)if(t.has(o)){let l=t.get(o).texture;return e(l,o.mapping)}else{let l=o.image;if(l&&l.height>0){let c=new ol(l.height/2);return c.fromEquirectangularTexture(n,o),t.set(o,c),o.addEventListener("dispose",r),e(c.texture,o.mapping)}else return null}}return o}function r(o){let a=o.target;a.removeEventListener("dispose",r);let l=t.get(a);l!==void 0&&(t.delete(a),l.dispose())}function s(){t=new WeakMap}return{get:i,dispose:s}}var Vi=class extends oo{constructor(t=-1,e=1,i=1,r=-1,s=.1,o=2e3){super(),this.type="OrthographicCamera",this.zoom=1,this.view=null,this.left=t,this.right=e,this.top=i,this.bottom=r,this.near=s,this.far=o,this.updateProjectionMatrix()}copy(t,e){return super.copy(t,e),this.left=t.left,this.right=t.right,this.top=t.top,this.bottom=t.bottom,this.near=t.near,this.far=t.far,this.zoom=t.zoom,this.view=t.view===null?null:Object.assign({},t.view),this}setViewOffset(t,e,i,r,s,o){this.view===null&&(this.view={enabled:!0,fullWidth:1,fullHeight:1,offsetX:0,offsetY:0,width:1,height:1}),this.view.enabled=!0,this.view.fullWidth=t,this.view.fullHeight=e,this.view.offsetX=i,this.view.offsetY=r,this.view.width=s,this.view.height=o,this.updateProjectionMatrix()}clearViewOffset(){this.view!==null&&(this.view.enabled=!1),this.updateProjectionMatrix()}updateProjectionMatrix(){let t=(this.right-this.left)/(2*this.zoom),e=(this.top-this.bottom)/(2*this.zoom),i=(this.right+this.left)/2,r=(this.top+this.bottom)/2,s=i-t,o=i+t,a=r+e,l=r-e;if(this.view!==null&&this.view.enabled){let c=(this.right-this.left)/this.view.fullWidth/this.zoom,u=(this.top-this.bottom)/this.view.fullHeight/this.zoom;s+=c*this.view.offsetX,o=s+c*this.view.width,a-=u*this.view.offsetY,l=a-u*this.view.height}this.projectionMatrix.makeOrthographic(s,o,a,l,this.near,this.far),this.projectionMatrixInverse.copy(this.projectionMatrix).invert()}toJSON(t){let e=super.toJSON(t);return e.object.zoom=this.zoom,e.object.left=this.left,e.object.right=this.right,e.object.top=this.top,e.object.bottom=this.bottom,e.object.near=this.near,e.object.far=this.far,this.view!==null&&(e.object.view=Object.assign({},this.view)),e}};Vi.prototype.isOrthographicCamera=!0;var Xr=class extends Fn{constructor(t){super(t),this.type="RawShaderMaterial"}};Xr.prototype.isRawShaderMaterial=!0;var kr=4,ni=8,hn=Math.pow(2,ni),x0=[.125,.215,.35,.446,.526,.582],y0=ni-kr+1+x0.length,Ar=20,Tu=new Vi,{_lodPlanes:Gs,_sizeLods:mg,_sigmas:Ua}=Q1(),gg=new ft,Au=null,zi=(1+Math.sqrt(5))/2,Cr=1/zi,xg=[new T(1,1,1),new T(-1,1,1),new T(1,1,-1),new T(-1,1,-1),new T(0,zi,Cr),new T(0,zi,-Cr),new T(Cr,0,zi),new T(-Cr,0,zi),new T(zi,Cr,0),new T(-zi,Cr,0)],al=class{constructor(t){this._renderer=t,this._pingPongRenderTarget=null,this._blurMaterial=j1(Ar),this._equirectShader=null,this._cubemapShader=null,this._compileMaterial(this._blurMaterial)}fromScene(t,e=0,i=.1,r=100){Au=this._renderer.getRenderTarget();let s=this._allocateTargets();return this._sceneToCubeUV(t,i,r,s),e>0&&this._blur(s,0,0,e),this._applyPMREM(s),this._cleanup(s),s}fromEquirectangular(t,e=null){return this._fromTexture(t,e)}fromCubemap(t,e=null){return this._fromTexture(t,e)}compileCubemapShader(){this._cubemapShader===null&&(this._cubemapShader=_g(),this._compileMaterial(this._cubemapShader))}compileEquirectangularShader(){this._equirectShader===null&&(this._equirectShader=vg(),this._compileMaterial(this._equirectShader))}dispose(){this._blurMaterial.dispose(),this._pingPongRenderTarget!==null&&this._pingPongRenderTarget.dispose(),this._cubemapShader!==null&&this._cubemapShader.dispose(),this._equirectShader!==null&&this._equirectShader.dispose();for(let t=0;t<Gs.length;t++)Gs[t].dispose()}_cleanup(t){this._renderer.setRenderTarget(Au),t.scissorTest=!1,Ba(t,0,0,t.width,t.height)}_fromTexture(t,e){Au=this._renderer.getRenderTarget();let i=e||this._allocateTargets(t);return this._textureToCubeUV(t,i),this._applyPMREM(i),this._cleanup(i),i}_allocateTargets(t){let e={magFilter:be,minFilter:be,generateMipmaps:!1,type:Ur,format:Re,encoding:ri,depthBuffer:!1},i=yg(e);return i.depthBuffer=!t,this._pingPongRenderTarget===null&&(this._pingPongRenderTarget=yg(e)),i}_compileMaterial(t){let e=new oe(Gs[0],t);this._renderer.compile(e,Tu)}_sceneToCubeUV(t,e,i,r){let a=new Se(90,1,e,i),l=[1,-1,1,1,1,1],c=[1,1,1,-1,-1,-1],u=this._renderer,h=u.autoClear,f=u.toneMapping;u.getClearColor(gg),u.toneMapping=ti,u.autoClear=!1;let d=new ki({name:"PMREM.Background",side:he,depthWrite:!1,depthTest:!1}),g=new oe(new Hi,d),x=!1,v=t.background;v?v.isColor&&(d.color.copy(v),t.background=null,x=!0):(d.color.copy(gg),x=!0);for(let m=0;m<6;m++){let p=m%3;p===0?(a.up.set(0,l[m],0),a.lookAt(c[m],0,0)):p===1?(a.up.set(0,0,l[m]),a.lookAt(0,c[m],0)):(a.up.set(0,l[m],0),a.lookAt(0,0,c[m])),Ba(r,p*hn,m>2?hn:0,hn,hn),u.setRenderTarget(r),x&&u.render(g,a),u.render(t,a)}g.geometry.dispose(),g.material.dispose(),u.toneMapping=f,u.autoClear=h,t.background=v}_textureToCubeUV(t,e){let i=this._renderer,r=t.mapping===Ao||t.mapping===Co;r?(this._cubemapShader===null&&(this._cubemapShader=_g()),this._cubemapShader.uniforms.flipEnvMap.value=t.isRenderTargetTexture===!1?-1:1):this._equirectShader===null&&(this._equirectShader=vg());let s=r?this._cubemapShader:this._equirectShader,o=new oe(Gs[0],s),a=s.uniforms;a.envMap.value=t,r||a.texelSize.value.set(1/t.image.width,1/t.image.height),Ba(e,0,0,3*hn,2*hn),i.setRenderTarget(e),i.render(o,Tu)}_applyPMREM(t){let e=this._renderer,i=e.autoClear;e.autoClear=!1;for(let r=1;r<y0;r++){let s=Math.sqrt(Ua[r]*Ua[r]-Ua[r-1]*Ua[r-1]),o=xg[(r-1)%xg.length];this._blur(t,r-1,r,s,o)}e.autoClear=i}_blur(t,e,i,r,s){let o=this._pingPongRenderTarget;this._halfBlur(t,o,e,i,r,"latitudinal",s),this._halfBlur(o,t,i,i,r,"longitudinal",s)}_halfBlur(t,e,i,r,s,o,a){let l=this._renderer,c=this._blurMaterial;o!=="latitudinal"&&o!=="longitudinal"&&console.error("blur direction must be either latitudinal or longitudinal!");let u=3,h=new oe(Gs[r],c),f=c.uniforms,d=mg[i]-1,g=isFinite(s)?Math.PI/(2*d):2*Math.PI/(2*Ar-1),x=s/g,v=isFinite(s)?1+Math.floor(u*x):Ar;v>Ar&&console.warn(`sigmaRadians, ${s}, is too large and will clip, as it requested ${v} samples when the maximum is set to ${Ar}`);let m=[],p=0;for(let L=0;L<Ar;++L){let A=L/x,H=Math.exp(-A*A/2);m.push(H),L===0?p+=H:L<v&&(p+=2*H)}for(let L=0;L<m.length;L++)m[L]=m[L]/p;f.envMap.value=t.texture,f.samples.value=v,f.weights.value=m,f.latitudinal.value=o==="latitudinal",a&&(f.poleAxis.value=a),f.dTheta.value=g,f.mipInt.value=ni-i;let b=mg[r],_=3*Math.max(0,hn-2*b),S=(r===0?0:2*hn)+2*b*(r>ni-kr?r-ni+kr:0);Ba(e,_,S,3*b,2*b),l.setRenderTarget(e),l.render(h,Tu)}};function Q1(){let n=[],t=[],e=[],i=ni;for(let r=0;r<y0;r++){let s=Math.pow(2,i);t.push(s);let o=1/s;r>ni-kr?o=x0[r-ni+kr-1]:r===0&&(o=0),e.push(o);let a=1/(s-1),l=-a/2,c=1+a/2,u=[l,l,c,l,c,c,l,l,c,c,l,c],h=6,f=6,d=3,g=2,x=1,v=new Float32Array(d*f*h),m=new Float32Array(g*f*h),p=new Float32Array(x*f*h);for(let _=0;_<h;_++){let S=_%3*2/3-1,L=_>2?0:-1,A=[S,L,0,S+2/3,L,0,S+2/3,L+1,0,S,L,0,S+2/3,L+1,0,S,L+1,0];v.set(A,d*f*_),m.set(u,g*f*_);let H=[_,_,_,_,_,_];p.set(H,x*f*_)}let b=new Ht;b.setAttribute("position",new Qt(v,d)),b.setAttribute("uv",new Qt(m,g)),b.setAttribute("faceIndex",new Qt(p,x)),n.push(b),i>kr&&i--}return{_lodPlanes:n,_sizeLods:t,_sigmas:e}}function yg(n){let t=new Ne(3*hn,3*hn,n);return t.texture.mapping=Rl,t.texture.name="PMREM.cubeUv",t.scissorTest=!0,t}function Ba(n,t,e,i,r){n.viewport.set(t,e,i,r),n.scissor.set(t,e,i,r)}function j1(n){let t=new Float32Array(n),e=new T(0,1,0);return new Xr({name:"SphericalGaussianBlur",defines:{n},uniforms:{envMap:{value:null},samples:{value:1},weights:{value:t},latitudinal:{value:!1},dTheta:{value:0},mipInt:{value:0},poleAxis:{value:e}},vertexShader:jh(),fragmentShader:`

			precision mediump float;
			precision mediump int;

			varying vec3 vOutputDirection;

			uniform sampler2D envMap;
			uniform int samples;
			uniform float weights[ n ];
			uniform bool latitudinal;
			uniform float dTheta;
			uniform float mipInt;
			uniform vec3 poleAxis;

			#define ENVMAP_TYPE_CUBE_UV
			#include <cube_uv_reflection_fragment>

			vec3 getSample( float theta, vec3 axis ) {

				float cosTheta = cos( theta );
				// Rodrigues' axis-angle rotation
				vec3 sampleDirection = vOutputDirection * cosTheta
					+ cross( axis, vOutputDirection ) * sin( theta )
					+ axis * dot( axis, vOutputDirection ) * ( 1.0 - cosTheta );

				return bilinearCubeUV( envMap, sampleDirection, mipInt );

			}

			void main() {

				vec3 axis = latitudinal ? poleAxis : cross( poleAxis, vOutputDirection );

				if ( all( equal( axis, vec3( 0.0 ) ) ) ) {

					axis = vec3( vOutputDirection.z, 0.0, - vOutputDirection.x );

				}

				axis = normalize( axis );

				gl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 );
				gl_FragColor.rgb += weights[ 0 ] * getSample( 0.0, axis );

				for ( int i = 1; i < n; i++ ) {

					if ( i >= samples ) {

						break;

					}

					float theta = dTheta * float( i );
					gl_FragColor.rgb += weights[ i ] * getSample( -1.0 * theta, axis );
					gl_FragColor.rgb += weights[ i ] * getSample( theta, axis );

				}

			}
		`,blending:jn,depthTest:!1,depthWrite:!1})}function vg(){let n=new K(1,1);return new Xr({name:"EquirectangularToCubeUV",uniforms:{envMap:{value:null},texelSize:{value:n}},vertexShader:jh(),fragmentShader:`

			precision mediump float;
			precision mediump int;

			varying vec3 vOutputDirection;

			uniform sampler2D envMap;
			uniform vec2 texelSize;

			#include <common>

			void main() {

				gl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 );

				vec3 outputDirection = normalize( vOutputDirection );
				vec2 uv = equirectUv( outputDirection );

				vec2 f = fract( uv / texelSize - 0.5 );
				uv -= f * texelSize;
				vec3 tl = texture2D ( envMap, uv ).rgb;
				uv.x += texelSize.x;
				vec3 tr = texture2D ( envMap, uv ).rgb;
				uv.y += texelSize.y;
				vec3 br = texture2D ( envMap, uv ).rgb;
				uv.x -= texelSize.x;
				vec3 bl = texture2D ( envMap, uv ).rgb;

				vec3 tm = mix( tl, tr, f.x );
				vec3 bm = mix( bl, br, f.x );
				gl_FragColor.rgb = mix( tm, bm, f.y );

			}
		`,blending:jn,depthTest:!1,depthWrite:!1})}function _g(){return new Xr({name:"CubemapToCubeUV",uniforms:{envMap:{value:null},flipEnvMap:{value:-1}},vertexShader:jh(),fragmentShader:`

			precision mediump float;
			precision mediump int;

			uniform float flipEnvMap;

			varying vec3 vOutputDirection;

			uniform samplerCube envMap;

			void main() {

				gl_FragColor = textureCube( envMap, vec3( flipEnvMap * vOutputDirection.x, vOutputDirection.yz ) );

			}
		`,blending:jn,depthTest:!1,depthWrite:!1})}function jh(){return`

		precision mediump float;
		precision mediump int;

		attribute vec3 position;
		attribute vec2 uv;
		attribute float faceIndex;

		varying vec3 vOutputDirection;

		// RH coordinate system; PMREM face-indexing convention
		vec3 getDirection( vec2 uv, float face ) {

			uv = 2.0 * uv - 1.0;

			vec3 direction = vec3( uv, 1.0 );

			if ( face == 0.0 ) {

				direction = direction.zyx; // ( 1, v, u ) pos x

			} else if ( face == 1.0 ) {

				direction = direction.xzy;
				direction.xz *= -1.0; // ( -u, 1, -v ) pos y

			} else if ( face == 2.0 ) {

				direction.x *= -1.0; // ( -u, v, 1 ) pos z

			} else if ( face == 3.0 ) {

				direction = direction.zyx;
				direction.xz *= -1.0; // ( -1, v, -u ) neg x

			} else if ( face == 4.0 ) {

				direction = direction.xzy;
				direction.xy *= -1.0; // ( -u, -1, v ) neg y

			} else if ( face == 5.0 ) {

				direction.z *= -1.0; // ( u, v, -1 ) neg z

			}

			return direction;

		}

		void main() {

			vOutputDirection = getDirection( uv, faceIndex );
			gl_Position = vec4( position, 1.0 );

		}
	`}function tS(n){let t=new WeakMap,e=null;function i(a){if(a&&a.isTexture){let l=a.mapping,c=l===Uu||l===Bu,u=l===Ao||l===Co;if(c||u)if(a.isRenderTargetTexture&&a.needsPMREMUpdate===!0){a.needsPMREMUpdate=!1;let h=t.get(a);return e===null&&(e=new al(n)),h=c?e.fromEquirectangular(a,h):e.fromCubemap(a,h),t.set(a,h),h.texture}else{if(t.has(a))return t.get(a).texture;{let h=a.image;if(c&&h&&h.height>0||u&&h&&r(h)){e===null&&(e=new al(n));let f=c?e.fromEquirectangular(a):e.fromCubemap(a);return t.set(a,f),a.addEventListener("dispose",s),f.texture}else return null}}}return a}function r(a){let l=0,c=6;for(let u=0;u<c;u++)a[u]!==void 0&&l++;return l===c}function s(a){let l=a.target;l.removeEventListener("dispose",s);let c=t.get(l);c!==void 0&&(t.delete(l),c.dispose())}function o(){t=new WeakMap,e!==null&&(e.dispose(),e=null)}return{get:i,dispose:o}}function eS(n){let t={};function e(i){if(t[i]!==void 0)return t[i];let r;switch(i){case"WEBGL_depth_texture":r=n.getExtension("WEBGL_depth_texture")||n.getExtension("MOZ_WEBGL_depth_texture")||n.getExtension("WEBKIT_WEBGL_depth_texture");break;case"EXT_texture_filter_anisotropic":r=n.getExtension("EXT_texture_filter_anisotropic")||n.getExtension("MOZ_EXT_texture_filter_anisotropic")||n.getExtension("WEBKIT_EXT_texture_filter_anisotropic");break;case"WEBGL_compressed_texture_s3tc":r=n.getExtension("WEBGL_compressed_texture_s3tc")||n.getExtension("MOZ_WEBGL_compressed_texture_s3tc")||n.getExtension("WEBKIT_WEBGL_compressed_texture_s3tc");break;case"WEBGL_compressed_texture_pvrtc":r=n.getExtension("WEBGL_compressed_texture_pvrtc")||n.getExtension("WEBKIT_WEBGL_compressed_texture_pvrtc");break;default:r=n.getExtension(i)}return t[i]=r,r}return{has:function(i){return e(i)!==null},init:function(i){i.isWebGL2?e("EXT_color_buffer_float"):(e("WEBGL_depth_texture"),e("OES_texture_float"),e("OES_texture_half_float"),e("OES_texture_half_float_linear"),e("OES_standard_derivatives"),e("OES_element_index_uint"),e("OES_vertex_array_object"),e("ANGLE_instanced_arrays")),e("OES_texture_float_linear"),e("EXT_color_buffer_half_float"),e("WEBGL_multisampled_render_to_texture")},get:function(i){let r=e(i);return r===null&&console.warn("THREE.WebGLRenderer: "+i+" extension not supported."),r}}}function nS(n,t,e,i){let r={},s=new WeakMap;function o(h){let f=h.target;f.index!==null&&t.remove(f.index);for(let g in f.attributes)t.remove(f.attributes[g]);f.removeEventListener("dispose",o),delete r[f.id];let d=s.get(f);d&&(t.remove(d),s.delete(f)),i.releaseStatesOfGeometry(f),f.isInstancedBufferGeometry===!0&&delete f._maxInstanceCount,e.memory.geometries--}function a(h,f){return r[f.id]===!0||(f.addEventListener("dispose",o),r[f.id]=!0,e.memory.geometries++),f}function l(h){let f=h.attributes;for(let g in f)t.update(f[g],34962);let d=h.morphAttributes;for(let g in d){let x=d[g];for(let v=0,m=x.length;v<m;v++)t.update(x[v],34962)}}function c(h){let f=[],d=h.index,g=h.attributes.position,x=0;if(d!==null){let p=d.array;x=d.version;for(let b=0,_=p.length;b<_;b+=3){let S=p[b+0],L=p[b+1],A=p[b+2];f.push(S,L,L,A,A,S)}}else{let p=g.array;x=g.version;for(let b=0,_=p.length/3-1;b<_;b+=3){let S=b+0,L=b+1,A=b+2;f.push(S,L,L,A,A,S)}}let v=new(p0(f)?sl:rl)(f,1);v.version=x;let m=s.get(h);m&&t.remove(m),s.set(h,v)}function u(h){let f=s.get(h);if(f){let d=h.index;d!==null&&f.version<d.version&&c(h)}else c(h);return s.get(h)}return{get:a,update:l,getWireframeAttribute:u}}function iS(n,t,e,i){let r=i.isWebGL2,s;function o(f){s=f}let a,l;function c(f){a=f.type,l=f.bytesPerElement}function u(f,d){n.drawElements(s,d,a,f*l),e.update(d,s,1)}function h(f,d,g){if(g===0)return;let x,v;if(r)x=n,v="drawElementsInstanced";else if(x=t.get("ANGLE_instanced_arrays"),v="drawElementsInstancedANGLE",x===null){console.error("THREE.WebGLIndexedBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.");return}x[v](s,d,a,f*l,g),e.update(d,s,g)}this.setMode=o,this.setIndex=c,this.render=u,this.renderInstances=h}function rS(n){let t={geometries:0,textures:0},e={frame:0,calls:0,triangles:0,points:0,lines:0};function i(s,o,a){switch(e.calls++,o){case 4:e.triangles+=a*(s/3);break;case 1:e.lines+=a*(s/2);break;case 3:e.lines+=a*(s-1);break;case 2:e.lines+=a*s;break;case 0:e.points+=a*s;break;default:console.error("THREE.WebGLInfo: Unknown draw mode:",o);break}}function r(){e.frame++,e.calls=0,e.triangles=0,e.points=0,e.lines=0}return{memory:t,render:e,programs:null,autoReset:!0,reset:r,update:i}}var co=class extends ae{constructor(t=null,e=1,i=1,r=1){super(null),this.image={data:t,width:e,height:i,depth:r},this.magFilter=fe,this.minFilter=fe,this.wrapR=Ve,this.generateMipmaps=!1,this.flipY=!1,this.unpackAlignment=1}};co.prototype.isDataTexture2DArray=!0;function sS(n,t){return n[0]-t[0]}function oS(n,t){return Math.abs(t[1])-Math.abs(n[1])}function wg(n,t){let e=1,i=t.isInterleavedBufferAttribute?t.data.array:t.array;i instanceof Int8Array?e=127:i instanceof Int16Array?e=32767:i instanceof Int32Array?e=2147483647:console.error("THREE.WebGLMorphtargets: Unsupported morph attribute data type: ",i),n.divideScalar(e)}function aS(n,t,e){let i={},r=new Float32Array(8),s=new WeakMap,o=new T,a=[];for(let c=0;c<8;c++)a[c]=[c,0];function l(c,u,h,f){let d=c.morphTargetInfluences;if(t.isWebGL2===!0){let g=u.morphAttributes.position.length,x=s.get(u);if(x===void 0||x.count!==g){let R=function(){X.dispose(),s.delete(u),u.removeEventListener("dispose",R)};x!==void 0&&x.texture.dispose();let p=u.morphAttributes.normal!==void 0,b=u.morphAttributes.position,_=u.morphAttributes.normal||[],S=u.attributes.position.count,L=p===!0?2:1,A=S*L,H=1;A>t.maxTextureSize&&(H=Math.ceil(A/t.maxTextureSize),A=t.maxTextureSize);let tt=new Float32Array(A*H*4*g),X=new co(tt,A,H,g);X.format=Re,X.type=Ui,X.needsUpdate=!0;let y=L*4;for(let D=0;D<g;D++){let F=b[D],z=_[D],N=A*H*4*D;for(let V=0;V<F.count;V++){o.fromBufferAttribute(F,V),F.normalized===!0&&wg(o,F);let Q=V*y;tt[N+Q+0]=o.x,tt[N+Q+1]=o.y,tt[N+Q+2]=o.z,tt[N+Q+3]=0,p===!0&&(o.fromBufferAttribute(z,V),z.normalized===!0&&wg(o,z),tt[N+Q+4]=o.x,tt[N+Q+5]=o.y,tt[N+Q+6]=o.z,tt[N+Q+7]=0)}}x={count:g,texture:X,size:new K(A,H)},s.set(u,x),u.addEventListener("dispose",R)}let v=0;for(let p=0;p<d.length;p++)v+=d[p];let m=u.morphTargetsRelative?1:1-v;f.getUniforms().setValue(n,"morphTargetBaseInfluence",m),f.getUniforms().setValue(n,"morphTargetInfluences",d),f.getUniforms().setValue(n,"morphTargetsTexture",x.texture,e),f.getUniforms().setValue(n,"morphTargetsTextureSize",x.size)}else{let g=d===void 0?0:d.length,x=i[u.id];if(x===void 0||x.length!==g){x=[];for(let _=0;_<g;_++)x[_]=[_,0];i[u.id]=x}for(let _=0;_<g;_++){let S=x[_];S[0]=_,S[1]=d[_]}x.sort(oS);for(let _=0;_<8;_++)_<g&&x[_][1]?(a[_][0]=x[_][0],a[_][1]=x[_][1]):(a[_][0]=Number.MAX_SAFE_INTEGER,a[_][1]=0);a.sort(sS);let v=u.morphAttributes.position,m=u.morphAttributes.normal,p=0;for(let _=0;_<8;_++){let S=a[_],L=S[0],A=S[1];L!==Number.MAX_SAFE_INTEGER&&A?(v&&u.getAttribute("morphTarget"+_)!==v[L]&&u.setAttribute("morphTarget"+_,v[L]),m&&u.getAttribute("morphNormal"+_)!==m[L]&&u.setAttribute("morphNormal"+_,m[L]),r[_]=A,p+=A):(v&&u.hasAttribute("morphTarget"+_)===!0&&u.deleteAttribute("morphTarget"+_),m&&u.hasAttribute("morphNormal"+_)===!0&&u.deleteAttribute("morphNormal"+_),r[_]=0)}let b=u.morphTargetsRelative?1:1-p;f.getUniforms().setValue(n,"morphTargetBaseInfluence",b),f.getUniforms().setValue(n,"morphTargetInfluences",r)}}return{update:l}}function lS(n,t,e,i){let r=new WeakMap;function s(l){let c=i.render.frame,u=l.geometry,h=t.get(l,u);return r.get(h)!==c&&(t.update(h),r.set(h,c)),l.isInstancedMesh&&(l.hasEventListener("dispose",a)===!1&&l.addEventListener("dispose",a),e.update(l.instanceMatrix,34962),l.instanceColor!==null&&e.update(l.instanceColor,34962)),h}function o(){r=new WeakMap}function a(l){let c=l.target;c.removeEventListener("dispose",a),e.remove(c.instanceMatrix),c.instanceColor!==null&&e.remove(c.instanceColor)}return{update:s,dispose:o}}var ll=class extends ae{constructor(t=null,e=1,i=1,r=1){super(null),this.image={data:t,width:e,height:i,depth:r},this.magFilter=fe,this.minFilter=fe,this.wrapR=Ve,this.generateMipmaps=!1,this.flipY=!1,this.unpackAlignment=1}};ll.prototype.isDataTexture3D=!0;var v0=new ae,_0=new co,w0=new ll,M0=new Wr,Mg=[],bg=[],Sg=new Float32Array(16),Eg=new Float32Array(9),Tg=new Float32Array(4);function es(n,t,e){let i=n[0];if(i<=0||i>0)return n;let r=t*e,s=Mg[r];if(s===void 0&&(s=new Float32Array(r),Mg[r]=s),t!==0){i.toArray(s,0);for(let o=1,a=0;o!==t;++o)a+=e,n[o].toArray(s,a)}return s}function Le(n,t){if(n.length!==t.length)return!1;for(let e=0,i=n.length;e<i;e++)if(n[e]!==t[e])return!1;return!0}function Te(n,t){for(let e=0,i=t.length;e<i;e++)n[e]=t[e]}function Pl(n,t){let e=bg[t];e===void 0&&(e=new Int32Array(t),bg[t]=e);for(let i=0;i!==t;++i)e[i]=n.allocateTextureUnit();return e}function cS(n,t){let e=this.cache;e[0]!==t&&(n.uniform1f(this.addr,t),e[0]=t)}function uS(n,t){let e=this.cache;if(t.x!==void 0)(e[0]!==t.x||e[1]!==t.y)&&(n.uniform2f(this.addr,t.x,t.y),e[0]=t.x,e[1]=t.y);else{if(Le(e,t))return;n.uniform2fv(this.addr,t),Te(e,t)}}function hS(n,t){let e=this.cache;if(t.x!==void 0)(e[0]!==t.x||e[1]!==t.y||e[2]!==t.z)&&(n.uniform3f(this.addr,t.x,t.y,t.z),e[0]=t.x,e[1]=t.y,e[2]=t.z);else if(t.r!==void 0)(e[0]!==t.r||e[1]!==t.g||e[2]!==t.b)&&(n.uniform3f(this.addr,t.r,t.g,t.b),e[0]=t.r,e[1]=t.g,e[2]=t.b);else{if(Le(e,t))return;n.uniform3fv(this.addr,t),Te(e,t)}}function fS(n,t){let e=this.cache;if(t.x!==void 0)(e[0]!==t.x||e[1]!==t.y||e[2]!==t.z||e[3]!==t.w)&&(n.uniform4f(this.addr,t.x,t.y,t.z,t.w),e[0]=t.x,e[1]=t.y,e[2]=t.z,e[3]=t.w);else{if(Le(e,t))return;n.uniform4fv(this.addr,t),Te(e,t)}}function dS(n,t){let e=this.cache,i=t.elements;if(i===void 0){if(Le(e,t))return;n.uniformMatrix2fv(this.addr,!1,t),Te(e,t)}else{if(Le(e,i))return;Tg.set(i),n.uniformMatrix2fv(this.addr,!1,Tg),Te(e,i)}}function pS(n,t){let e=this.cache,i=t.elements;if(i===void 0){if(Le(e,t))return;n.uniformMatrix3fv(this.addr,!1,t),Te(e,t)}else{if(Le(e,i))return;Eg.set(i),n.uniformMatrix3fv(this.addr,!1,Eg),Te(e,i)}}function mS(n,t){let e=this.cache,i=t.elements;if(i===void 0){if(Le(e,t))return;n.uniformMatrix4fv(this.addr,!1,t),Te(e,t)}else{if(Le(e,i))return;Sg.set(i),n.uniformMatrix4fv(this.addr,!1,Sg),Te(e,i)}}function gS(n,t){let e=this.cache;e[0]!==t&&(n.uniform1i(this.addr,t),e[0]=t)}function xS(n,t){let e=this.cache;Le(e,t)||(n.uniform2iv(this.addr,t),Te(e,t))}function yS(n,t){let e=this.cache;Le(e,t)||(n.uniform3iv(this.addr,t),Te(e,t))}function vS(n,t){let e=this.cache;Le(e,t)||(n.uniform4iv(this.addr,t),Te(e,t))}function _S(n,t){let e=this.cache;e[0]!==t&&(n.uniform1ui(this.addr,t),e[0]=t)}function wS(n,t){let e=this.cache;Le(e,t)||(n.uniform2uiv(this.addr,t),Te(e,t))}function MS(n,t){let e=this.cache;Le(e,t)||(n.uniform3uiv(this.addr,t),Te(e,t))}function bS(n,t){let e=this.cache;Le(e,t)||(n.uniform4uiv(this.addr,t),Te(e,t))}function SS(n,t,e){let i=this.cache,r=e.allocateTextureUnit();i[0]!==r&&(n.uniform1i(this.addr,r),i[0]=r),e.safeSetTexture2D(t||v0,r)}function ES(n,t,e){let i=this.cache,r=e.allocateTextureUnit();i[0]!==r&&(n.uniform1i(this.addr,r),i[0]=r),e.setTexture3D(t||w0,r)}function TS(n,t,e){let i=this.cache,r=e.allocateTextureUnit();i[0]!==r&&(n.uniform1i(this.addr,r),i[0]=r),e.safeSetTextureCube(t||M0,r)}function AS(n,t,e){let i=this.cache,r=e.allocateTextureUnit();i[0]!==r&&(n.uniform1i(this.addr,r),i[0]=r),e.setTexture2DArray(t||_0,r)}function CS(n){switch(n){case 5126:return cS;case 35664:return uS;case 35665:return hS;case 35666:return fS;case 35674:return dS;case 35675:return pS;case 35676:return mS;case 5124:case 35670:return gS;case 35667:case 35671:return xS;case 35668:case 35672:return yS;case 35669:case 35673:return vS;case 5125:return _S;case 36294:return wS;case 36295:return MS;case 36296:return bS;case 35678:case 36198:case 36298:case 36306:case 35682:return SS;case 35679:case 36299:case 36307:return ES;case 35680:case 36300:case 36308:case 36293:return TS;case 36289:case 36303:case 36311:case 36292:return AS}}function RS(n,t){n.uniform1fv(this.addr,t)}function LS(n,t){let e=es(t,this.size,2);n.uniform2fv(this.addr,e)}function PS(n,t){let e=es(t,this.size,3);n.uniform3fv(this.addr,e)}function DS(n,t){let e=es(t,this.size,4);n.uniform4fv(this.addr,e)}function IS(n,t){let e=es(t,this.size,4);n.uniformMatrix2fv(this.addr,!1,e)}function NS(n,t){let e=es(t,this.size,9);n.uniformMatrix3fv(this.addr,!1,e)}function FS(n,t){let e=es(t,this.size,16);n.uniformMatrix4fv(this.addr,!1,e)}function zS(n,t){n.uniform1iv(this.addr,t)}function US(n,t){n.uniform2iv(this.addr,t)}function BS(n,t){n.uniform3iv(this.addr,t)}function OS(n,t){n.uniform4iv(this.addr,t)}function kS(n,t){n.uniform1uiv(this.addr,t)}function HS(n,t){n.uniform2uiv(this.addr,t)}function VS(n,t){n.uniform3uiv(this.addr,t)}function GS(n,t){n.uniform4uiv(this.addr,t)}function WS(n,t,e){let i=t.length,r=Pl(e,i);n.uniform1iv(this.addr,r);for(let s=0;s!==i;++s)e.safeSetTexture2D(t[s]||v0,r[s])}function qS(n,t,e){let i=t.length,r=Pl(e,i);n.uniform1iv(this.addr,r);for(let s=0;s!==i;++s)e.setTexture3D(t[s]||w0,r[s])}function XS(n,t,e){let i=t.length,r=Pl(e,i);n.uniform1iv(this.addr,r);for(let s=0;s!==i;++s)e.safeSetTextureCube(t[s]||M0,r[s])}function YS(n,t,e){let i=t.length,r=Pl(e,i);n.uniform1iv(this.addr,r);for(let s=0;s!==i;++s)e.setTexture2DArray(t[s]||_0,r[s])}function ZS(n){switch(n){case 5126:return RS;case 35664:return LS;case 35665:return PS;case 35666:return DS;case 35674:return IS;case 35675:return NS;case 35676:return FS;case 5124:case 35670:return zS;case 35667:case 35671:return US;case 35668:case 35672:return BS;case 35669:case 35673:return OS;case 5125:return kS;case 36294:return HS;case 36295:return VS;case 36296:return GS;case 35678:case 36198:case 36298:case 36306:case 35682:return WS;case 35679:case 36299:case 36307:return qS;case 35680:case 36300:case 36308:case 36293:return XS;case 36289:case 36303:case 36311:case 36292:return YS}}function JS(n,t,e){this.id=n,this.addr=e,this.cache=[],this.setValue=CS(t.type)}function b0(n,t,e){this.id=n,this.addr=e,this.cache=[],this.size=t.size,this.setValue=ZS(t.type)}b0.prototype.updateCache=function(n){let t=this.cache;n instanceof Float32Array&&t.length!==n.length&&(this.cache=new Float32Array(n.length)),Te(t,n)};function S0(n){this.id=n,this.seq=[],this.map={}}S0.prototype.setValue=function(n,t,e){let i=this.seq;for(let r=0,s=i.length;r!==s;++r){let o=i[r];o.setValue(n,t[o.id],e)}};var Cu=/(\w+)(\])?(\[|\.)?/g;function Ag(n,t){n.seq.push(t),n.map[t.id]=t}function $S(n,t,e){let i=n.name,r=i.length;for(Cu.lastIndex=0;;){let s=Cu.exec(i),o=Cu.lastIndex,a=s[1],l=s[2]==="]",c=s[3];if(l&&(a=a|0),c===void 0||c==="["&&o+2===r){Ag(e,c===void 0?new JS(a,n,t):new b0(a,n,t));break}else{let h=e.map[a];h===void 0&&(h=new S0(a),Ag(e,h)),e=h}}}function ii(n,t){this.seq=[],this.map={};let e=n.getProgramParameter(t,35718);for(let i=0;i<e;++i){let r=n.getActiveUniform(t,i),s=n.getUniformLocation(t,r.name);$S(r,s,this)}}ii.prototype.setValue=function(n,t,e,i){let r=this.map[t];r!==void 0&&r.setValue(n,e,i)};ii.prototype.setOptional=function(n,t,e){let i=t[e];i!==void 0&&this.setValue(n,e,i)};ii.upload=function(n,t,e,i){for(let r=0,s=t.length;r!==s;++r){let o=t[r],a=e[o.id];a.needsUpdate!==!1&&o.setValue(n,a.value,i)}};ii.seqWithValue=function(n,t){let e=[];for(let i=0,r=n.length;i!==r;++i){let s=n[i];s.id in t&&e.push(s)}return e};function Cg(n,t,e){let i=n.createShader(t);return n.shaderSource(i,e),n.compileShader(i),i}var KS=0;function QS(n){let t=n.split(`
`);for(let e=0;e<t.length;e++)t[e]=e+1+": "+t[e];return t.join(`
`)}function jS(n){switch(n){case ri:return["Linear","( value )"];case $t:return["sRGB","( value )"];default:return console.warn("THREE.WebGLProgram: Unsupported encoding:",n),["Linear","( value )"]}}function Rg(n,t,e){let i=n.getShaderParameter(t,35713),r=n.getShaderInfoLog(t).trim();return i&&r===""?"":e.toUpperCase()+`

`+r+`

`+QS(n.getShaderSource(t))}function tE(n,t){let e=jS(t);return"vec4 "+n+"( vec4 value ) { return LinearTo"+e[0]+e[1]+"; }"}function eE(n,t){let e;switch(t){case Aw:e="Linear";break;case Cw:e="Reinhard";break;case Rw:e="OptimizedCineon";break;case Lw:e="ACESFilmic";break;case Pw:e="Custom";break;default:console.warn("THREE.WebGLProgram: Unsupported toneMapping:",t),e="Linear"}return"vec3 "+n+"( vec3 color ) { return "+e+"ToneMapping( color ); }"}function nE(n){return[n.extensionDerivatives||n.envMapCubeUV||n.bumpMap||n.tangentSpaceNormalMap||n.clearcoatNormalMap||n.flatShading||n.shaderID==="physical"?"#extension GL_OES_standard_derivatives : enable":"",(n.extensionFragDepth||n.logarithmicDepthBuffer)&&n.rendererExtensionFragDepth?"#extension GL_EXT_frag_depth : enable":"",n.extensionDrawBuffers&&n.rendererExtensionDrawBuffers?"#extension GL_EXT_draw_buffers : require":"",(n.extensionShaderTextureLOD||n.envMap||n.transmission)&&n.rendererExtensionShaderTextureLod?"#extension GL_EXT_shader_texture_lod : enable":""].filter($s).join(`
`)}function iE(n){let t=[];for(let e in n){let i=n[e];i!==!1&&t.push("#define "+e+" "+i)}return t.join(`
`)}function rE(n,t){let e={},i=n.getProgramParameter(t,35721);for(let r=0;r<i;r++){let s=n.getActiveAttrib(t,r),o=s.name,a=1;s.type===35674&&(a=2),s.type===35675&&(a=3),s.type===35676&&(a=4),e[o]={type:s.type,location:n.getAttribLocation(t,o),locationSize:a}}return e}function $s(n){return n!==""}function Lg(n,t){return n.replace(/NUM_DIR_LIGHTS/g,t.numDirLights).replace(/NUM_SPOT_LIGHTS/g,t.numSpotLights).replace(/NUM_RECT_AREA_LIGHTS/g,t.numRectAreaLights).replace(/NUM_POINT_LIGHTS/g,t.numPointLights).replace(/NUM_HEMI_LIGHTS/g,t.numHemiLights).replace(/NUM_DIR_LIGHT_SHADOWS/g,t.numDirLightShadows).replace(/NUM_SPOT_LIGHT_SHADOWS/g,t.numSpotLightShadows).replace(/NUM_POINT_LIGHT_SHADOWS/g,t.numPointLightShadows)}function Pg(n,t){return n.replace(/NUM_CLIPPING_PLANES/g,t.numClippingPlanes).replace(/UNION_CLIPPING_PLANES/g,t.numClippingPlanes-t.numClipIntersection)}var sE=/^[ \t]*#include +<([\w\d./]+)>/gm;function qu(n){return n.replace(sE,oE)}function oE(n,t){let e=Pt[t];if(e===void 0)throw new Error("Can not resolve #include <"+t+">");return qu(e)}var aE=/#pragma unroll_loop[\s]+?for \( int i \= (\d+)\; i < (\d+)\; i \+\+ \) \{([\s\S]+?)(?=\})\}/g,lE=/#pragma unroll_loop_start\s+for\s*\(\s*int\s+i\s*=\s*(\d+)\s*;\s*i\s*<\s*(\d+)\s*;\s*i\s*\+\+\s*\)\s*{([\s\S]+?)}\s+#pragma unroll_loop_end/g;function Dg(n){return n.replace(lE,E0).replace(aE,cE)}function cE(n,t,e,i){return console.warn("WebGLProgram: #pragma unroll_loop shader syntax is deprecated. Please use #pragma unroll_loop_start syntax instead."),E0(n,t,e,i)}function E0(n,t,e,i){let r="";for(let s=parseInt(t);s<parseInt(e);s++)r+=i.replace(/\[\s*i\s*\]/g,"[ "+s+" ]").replace(/UNROLLED_LOOP_INDEX/g,s);return r}function Ig(n){let t="precision "+n.precision+` float;
precision `+n.precision+" int;";return n.precision==="highp"?t+=`
#define HIGH_PRECISION`:n.precision==="mediump"?t+=`
#define MEDIUM_PRECISION`:n.precision==="lowp"&&(t+=`
#define LOW_PRECISION`),t}function uE(n){let t="SHADOWMAP_TYPE_BASIC";return n.shadowMapType===l0?t="SHADOWMAP_TYPE_PCF":n.shadowMapType===sw?t="SHADOWMAP_TYPE_PCF_SOFT":n.shadowMapType===Js&&(t="SHADOWMAP_TYPE_VSM"),t}function hE(n){let t="ENVMAP_TYPE_CUBE";if(n.envMap)switch(n.envMapMode){case Ao:case Co:t="ENVMAP_TYPE_CUBE";break;case Rl:case Kh:t="ENVMAP_TYPE_CUBE_UV";break}return t}function fE(n){let t="ENVMAP_MODE_REFLECTION";if(n.envMap)switch(n.envMapMode){case Co:case Kh:t="ENVMAP_MODE_REFRACTION";break}return t}function dE(n){let t="ENVMAP_BLENDING_NONE";if(n.envMap)switch(n.combine){case Cl:t="ENVMAP_BLENDING_MULTIPLY";break;case Ew:t="ENVMAP_BLENDING_MIX";break;case Tw:t="ENVMAP_BLENDING_ADD";break}return t}function pE(n,t,e,i){let r=n.getContext(),s=e.defines,o=e.vertexShader,a=e.fragmentShader,l=uE(e),c=hE(e),u=fE(e),h=dE(e),f=e.isWebGL2?"":nE(e),d=iE(s),g=r.createProgram(),x,v,m=e.glslVersion?"#version "+e.glslVersion+`
`:"";e.isRawShaderMaterial?(x=[d].filter($s).join(`
`),x.length>0&&(x+=`
`),v=[f,d].filter($s).join(`
`),v.length>0&&(v+=`
`)):(x=[Ig(e),"#define SHADER_NAME "+e.shaderName,d,e.instancing?"#define USE_INSTANCING":"",e.instancingColor?"#define USE_INSTANCING_COLOR":"",e.supportsVertexTextures?"#define VERTEX_TEXTURES":"","#define MAX_BONES "+e.maxBones,e.useFog&&e.fog?"#define USE_FOG":"",e.useFog&&e.fogExp2?"#define FOG_EXP2":"",e.map?"#define USE_MAP":"",e.envMap?"#define USE_ENVMAP":"",e.envMap?"#define "+u:"",e.lightMap?"#define USE_LIGHTMAP":"",e.aoMap?"#define USE_AOMAP":"",e.emissiveMap?"#define USE_EMISSIVEMAP":"",e.bumpMap?"#define USE_BUMPMAP":"",e.normalMap?"#define USE_NORMALMAP":"",e.normalMap&&e.objectSpaceNormalMap?"#define OBJECTSPACE_NORMALMAP":"",e.normalMap&&e.tangentSpaceNormalMap?"#define TANGENTSPACE_NORMALMAP":"",e.clearcoatMap?"#define USE_CLEARCOATMAP":"",e.clearcoatRoughnessMap?"#define USE_CLEARCOAT_ROUGHNESSMAP":"",e.clearcoatNormalMap?"#define USE_CLEARCOAT_NORMALMAP":"",e.displacementMap&&e.supportsVertexTextures?"#define USE_DISPLACEMENTMAP":"",e.specularMap?"#define USE_SPECULARMAP":"",e.specularIntensityMap?"#define USE_SPECULARINTENSITYMAP":"",e.specularColorMap?"#define USE_SPECULARCOLORMAP":"",e.roughnessMap?"#define USE_ROUGHNESSMAP":"",e.metalnessMap?"#define USE_METALNESSMAP":"",e.alphaMap?"#define USE_ALPHAMAP":"",e.transmission?"#define USE_TRANSMISSION":"",e.transmissionMap?"#define USE_TRANSMISSIONMAP":"",e.thicknessMap?"#define USE_THICKNESSMAP":"",e.sheenColorMap?"#define USE_SHEENCOLORMAP":"",e.sheenRoughnessMap?"#define USE_SHEENROUGHNESSMAP":"",e.vertexTangents?"#define USE_TANGENT":"",e.vertexColors?"#define USE_COLOR":"",e.vertexAlphas?"#define USE_COLOR_ALPHA":"",e.vertexUvs?"#define USE_UV":"",e.uvsVertexOnly?"#define UVS_VERTEX_ONLY":"",e.flatShading?"#define FLAT_SHADED":"",e.skinning?"#define USE_SKINNING":"",e.useVertexTexture?"#define BONE_TEXTURE":"",e.morphTargets?"#define USE_MORPHTARGETS":"",e.morphNormals&&e.flatShading===!1?"#define USE_MORPHNORMALS":"",e.morphTargets&&e.isWebGL2?"#define MORPHTARGETS_TEXTURE":"",e.morphTargets&&e.isWebGL2?"#define MORPHTARGETS_COUNT "+e.morphTargetsCount:"",e.doubleSided?"#define DOUBLE_SIDED":"",e.flipSided?"#define FLIP_SIDED":"",e.shadowMapEnabled?"#define USE_SHADOWMAP":"",e.shadowMapEnabled?"#define "+l:"",e.sizeAttenuation?"#define USE_SIZEATTENUATION":"",e.logarithmicDepthBuffer?"#define USE_LOGDEPTHBUF":"",e.logarithmicDepthBuffer&&e.rendererExtensionFragDepth?"#define USE_LOGDEPTHBUF_EXT":"","uniform mat4 modelMatrix;","uniform mat4 modelViewMatrix;","uniform mat4 projectionMatrix;","uniform mat4 viewMatrix;","uniform mat3 normalMatrix;","uniform vec3 cameraPosition;","uniform bool isOrthographic;","#ifdef USE_INSTANCING","	attribute mat4 instanceMatrix;","#endif","#ifdef USE_INSTANCING_COLOR","	attribute vec3 instanceColor;","#endif","attribute vec3 position;","attribute vec3 normal;","attribute vec2 uv;","#ifdef USE_TANGENT","	attribute vec4 tangent;","#endif","#if defined( USE_COLOR_ALPHA )","	attribute vec4 color;","#elif defined( USE_COLOR )","	attribute vec3 color;","#endif","#if ( defined( USE_MORPHTARGETS ) && ! defined( MORPHTARGETS_TEXTURE ) )","	attribute vec3 morphTarget0;","	attribute vec3 morphTarget1;","	attribute vec3 morphTarget2;","	attribute vec3 morphTarget3;","	#ifdef USE_MORPHNORMALS","		attribute vec3 morphNormal0;","		attribute vec3 morphNormal1;","		attribute vec3 morphNormal2;","		attribute vec3 morphNormal3;","	#else","		attribute vec3 morphTarget4;","		attribute vec3 morphTarget5;","		attribute vec3 morphTarget6;","		attribute vec3 morphTarget7;","	#endif","#endif","#ifdef USE_SKINNING","	attribute vec4 skinIndex;","	attribute vec4 skinWeight;","#endif",`
`].filter($s).join(`
`),v=[f,Ig(e),"#define SHADER_NAME "+e.shaderName,d,e.useFog&&e.fog?"#define USE_FOG":"",e.useFog&&e.fogExp2?"#define FOG_EXP2":"",e.map?"#define USE_MAP":"",e.matcap?"#define USE_MATCAP":"",e.envMap?"#define USE_ENVMAP":"",e.envMap?"#define "+c:"",e.envMap?"#define "+u:"",e.envMap?"#define "+h:"",e.lightMap?"#define USE_LIGHTMAP":"",e.aoMap?"#define USE_AOMAP":"",e.emissiveMap?"#define USE_EMISSIVEMAP":"",e.bumpMap?"#define USE_BUMPMAP":"",e.normalMap?"#define USE_NORMALMAP":"",e.normalMap&&e.objectSpaceNormalMap?"#define OBJECTSPACE_NORMALMAP":"",e.normalMap&&e.tangentSpaceNormalMap?"#define TANGENTSPACE_NORMALMAP":"",e.clearcoat?"#define USE_CLEARCOAT":"",e.clearcoatMap?"#define USE_CLEARCOATMAP":"",e.clearcoatRoughnessMap?"#define USE_CLEARCOAT_ROUGHNESSMAP":"",e.clearcoatNormalMap?"#define USE_CLEARCOAT_NORMALMAP":"",e.specularMap?"#define USE_SPECULARMAP":"",e.specularIntensityMap?"#define USE_SPECULARINTENSITYMAP":"",e.specularColorMap?"#define USE_SPECULARCOLORMAP":"",e.roughnessMap?"#define USE_ROUGHNESSMAP":"",e.metalnessMap?"#define USE_METALNESSMAP":"",e.alphaMap?"#define USE_ALPHAMAP":"",e.alphaTest?"#define USE_ALPHATEST":"",e.sheen?"#define USE_SHEEN":"",e.sheenColorMap?"#define USE_SHEENCOLORMAP":"",e.sheenRoughnessMap?"#define USE_SHEENROUGHNESSMAP":"",e.transmission?"#define USE_TRANSMISSION":"",e.transmissionMap?"#define USE_TRANSMISSIONMAP":"",e.thicknessMap?"#define USE_THICKNESSMAP":"",e.decodeVideoTexture?"#define DECODE_VIDEO_TEXTURE":"",e.vertexTangents?"#define USE_TANGENT":"",e.vertexColors||e.instancingColor?"#define USE_COLOR":"",e.vertexAlphas?"#define USE_COLOR_ALPHA":"",e.vertexUvs?"#define USE_UV":"",e.uvsVertexOnly?"#define UVS_VERTEX_ONLY":"",e.gradientMap?"#define USE_GRADIENTMAP":"",e.flatShading?"#define FLAT_SHADED":"",e.doubleSided?"#define DOUBLE_SIDED":"",e.flipSided?"#define FLIP_SIDED":"",e.shadowMapEnabled?"#define USE_SHADOWMAP":"",e.shadowMapEnabled?"#define "+l:"",e.premultipliedAlpha?"#define PREMULTIPLIED_ALPHA":"",e.physicallyCorrectLights?"#define PHYSICALLY_CORRECT_LIGHTS":"",e.logarithmicDepthBuffer?"#define USE_LOGDEPTHBUF":"",e.logarithmicDepthBuffer&&e.rendererExtensionFragDepth?"#define USE_LOGDEPTHBUF_EXT":"",(e.extensionShaderTextureLOD||e.envMap)&&e.rendererExtensionShaderTextureLod?"#define TEXTURE_LOD_EXT":"","uniform mat4 viewMatrix;","uniform vec3 cameraPosition;","uniform bool isOrthographic;",e.toneMapping!==ti?"#define TONE_MAPPING":"",e.toneMapping!==ti?Pt.tonemapping_pars_fragment:"",e.toneMapping!==ti?eE("toneMapping",e.toneMapping):"",e.dithering?"#define DITHERING":"",e.alphaWrite?"":"#define OPAQUE",Pt.encodings_pars_fragment,tE("linearToOutputTexel",e.outputEncoding),e.depthPacking?"#define DEPTH_PACKING "+e.depthPacking:"",`
`].filter($s).join(`
`)),o=qu(o),o=Lg(o,e),o=Pg(o,e),a=qu(a),a=Lg(a,e),a=Pg(a,e),o=Dg(o),a=Dg(a),e.isWebGL2&&e.isRawShaderMaterial!==!0&&(m=`#version 300 es
`,x=["precision mediump sampler2DArray;","#define attribute in","#define varying out","#define texture2D texture"].join(`
`)+`
`+x,v=["#define varying in",e.glslVersion===ng?"":"layout(location = 0) out highp vec4 pc_fragColor;",e.glslVersion===ng?"":"#define gl_FragColor pc_fragColor","#define gl_FragDepthEXT gl_FragDepth","#define texture2D texture","#define textureCube texture","#define texture2DProj textureProj","#define texture2DLodEXT textureLod","#define texture2DProjLodEXT textureProjLod","#define textureCubeLodEXT textureLod","#define texture2DGradEXT textureGrad","#define texture2DProjGradEXT textureProjGrad","#define textureCubeGradEXT textureGrad"].join(`
`)+`
`+v);let p=m+x+o,b=m+v+a,_=Cg(r,35633,p),S=Cg(r,35632,b);if(r.attachShader(g,_),r.attachShader(g,S),e.index0AttributeName!==void 0?r.bindAttribLocation(g,0,e.index0AttributeName):e.morphTargets===!0&&r.bindAttribLocation(g,0,"position"),r.linkProgram(g),n.debug.checkShaderErrors){let H=r.getProgramInfoLog(g).trim(),tt=r.getShaderInfoLog(_).trim(),X=r.getShaderInfoLog(S).trim(),y=!0,R=!0;if(r.getProgramParameter(g,35714)===!1){y=!1;let D=Rg(r,_,"vertex"),F=Rg(r,S,"fragment");console.error("THREE.WebGLProgram: Shader Error "+r.getError()+" - VALIDATE_STATUS "+r.getProgramParameter(g,35715)+`

Program Info Log: `+H+`
`+D+`
`+F)}else H!==""?console.warn("THREE.WebGLProgram: Program Info Log:",H):(tt===""||X==="")&&(R=!1);R&&(this.diagnostics={runnable:y,programLog:H,vertexShader:{log:tt,prefix:x},fragmentShader:{log:X,prefix:v}})}r.deleteShader(_),r.deleteShader(S);let L;this.getUniforms=function(){return L===void 0&&(L=new ii(r,g)),L};let A;return this.getAttributes=function(){return A===void 0&&(A=rE(r,g)),A},this.destroy=function(){i.releaseStatesOfProgram(this),r.deleteProgram(g),this.program=void 0},this.name=e.shaderName,this.id=KS++,this.cacheKey=t,this.usedTimes=1,this.program=g,this.vertexShader=_,this.fragmentShader=S,this}var mE=0,Xu=class{constructor(){this.shaderCache=new Map,this.materialCache=new Map}update(t){let e=t.vertexShader,i=t.fragmentShader,r=this._getShaderStage(e),s=this._getShaderStage(i),o=this._getShaderCacheForMaterial(t);return o.has(r)===!1&&(o.add(r),r.usedTimes++),o.has(s)===!1&&(o.add(s),s.usedTimes++),this}remove(t){let e=this.materialCache.get(t);for(let i of e)i.usedTimes--,i.usedTimes===0&&this.shaderCache.delete(i);return this.materialCache.delete(t),this}getVertexShaderID(t){return this._getShaderStage(t.vertexShader).id}getFragmentShaderID(t){return this._getShaderStage(t.fragmentShader).id}dispose(){this.shaderCache.clear(),this.materialCache.clear()}_getShaderCacheForMaterial(t){let e=this.materialCache;return e.has(t)===!1&&e.set(t,new Set),e.get(t)}_getShaderStage(t){let e=this.shaderCache;if(e.has(t)===!1){let i=new Yu;e.set(t,i)}return e.get(t)}},Yu=class{constructor(){this.id=mE++,this.usedTimes=0}};function gE(n,t,e,i,r,s,o){let a=new il,l=new Xu,c=[],u=r.isWebGL2,h=r.logarithmicDepthBuffer,f=r.floatVertexTextures,d=r.maxVertexUniforms,g=r.vertexTextures,x=r.precision,v={MeshDepthMaterial:"depth",MeshDistanceMaterial:"distanceRGBA",MeshNormalMaterial:"normal",MeshBasicMaterial:"basic",MeshLambertMaterial:"lambert",MeshPhongMaterial:"phong",MeshToonMaterial:"toon",MeshStandardMaterial:"physical",MeshPhysicalMaterial:"physical",MeshMatcapMaterial:"matcap",LineBasicMaterial:"basic",LineDashedMaterial:"dashed",PointsMaterial:"points",ShadowMaterial:"shadow",SpriteMaterial:"sprite"};function m(y){let D=y.skeleton.bones;if(f)return 1024;{let z=Math.floor((d-20)/4),N=Math.min(z,D.length);return N<D.length?(console.warn("THREE.WebGLRenderer: Skeleton has "+D.length+" bones. This GPU supports "+N+"."),0):N}}function p(y,R,D,F,z){let N=F.fog,V=y.isMeshStandardMaterial?F.environment:null,Q=(y.isMeshStandardMaterial?e:t).get(y.envMap||V),at=v[y.type],G=z.isSkinnedMesh?m(z):0;y.precision!==null&&(x=r.getMaxPrecision(y.precision),x!==y.precision&&console.warn("THREE.WebGLProgram.getParameters:",y.precision,"not supported, using",x,"instead."));let $,lt,dt,xt;if(at){let B=fn[at];$=B.vertexShader,lt=B.fragmentShader}else $=y.vertexShader,lt=y.fragmentShader,l.update(y),dt=l.getVertexShaderID(y),xt=l.getFragmentShaderID(y);let k=n.getRenderTarget(),Ft=y.alphaTest>0,mt=y.clearcoat>0;return{isWebGL2:u,shaderID:at,shaderName:y.type,vertexShader:$,fragmentShader:lt,defines:y.defines,customVertexShaderID:dt,customFragmentShaderID:xt,isRawShaderMaterial:y.isRawShaderMaterial===!0,glslVersion:y.glslVersion,precision:x,instancing:z.isInstancedMesh===!0,instancingColor:z.isInstancedMesh===!0&&z.instanceColor!==null,supportsVertexTextures:g,outputEncoding:k===null?n.outputEncoding:k.isXRRenderTarget===!0?k.texture.encoding:ri,map:!!y.map,matcap:!!y.matcap,envMap:!!Q,envMapMode:Q&&Q.mapping,envMapCubeUV:!!Q&&(Q.mapping===Rl||Q.mapping===Kh),lightMap:!!y.lightMap,aoMap:!!y.aoMap,emissiveMap:!!y.emissiveMap,bumpMap:!!y.bumpMap,normalMap:!!y.normalMap,objectSpaceNormalMap:y.normalMapType===jw,tangentSpaceNormalMap:y.normalMapType===ts,decodeVideoTexture:!!y.map&&y.map.isVideoTexture===!0&&y.map.encoding===$t,clearcoat:mt,clearcoatMap:mt&&!!y.clearcoatMap,clearcoatRoughnessMap:mt&&!!y.clearcoatRoughnessMap,clearcoatNormalMap:mt&&!!y.clearcoatNormalMap,displacementMap:!!y.displacementMap,roughnessMap:!!y.roughnessMap,metalnessMap:!!y.metalnessMap,specularMap:!!y.specularMap,specularIntensityMap:!!y.specularIntensityMap,specularColorMap:!!y.specularColorMap,alphaMap:!!y.alphaMap,alphaTest:Ft,alphaWrite:y.alphaWrite||y.transparent,gradientMap:!!y.gradientMap,sheen:y.sheen>0,sheenColorMap:!!y.sheenColorMap,sheenRoughnessMap:!!y.sheenRoughnessMap,transmission:y.transmission>0,transmissionMap:!!y.transmissionMap,thicknessMap:!!y.thicknessMap,combine:y.combine,vertexTangents:!!y.normalMap&&!!z.geometry&&!!z.geometry.attributes.tangent,vertexColors:y.vertexColors,vertexAlphas:y.vertexColors===!0&&!!z.geometry&&!!z.geometry.attributes.color&&z.geometry.attributes.color.itemSize===4,vertexUvs:!!y.map||!!y.bumpMap||!!y.normalMap||!!y.specularMap||!!y.alphaMap||!!y.emissiveMap||!!y.roughnessMap||!!y.metalnessMap||!!y.clearcoatMap||!!y.clearcoatRoughnessMap||!!y.clearcoatNormalMap||!!y.displacementMap||!!y.transmissionMap||!!y.thicknessMap||!!y.specularIntensityMap||!!y.specularColorMap||!!y.sheenColorMap||!!y.sheenRoughnessMap,uvsVertexOnly:!(!!y.map||!!y.bumpMap||!!y.normalMap||!!y.specularMap||!!y.alphaMap||!!y.emissiveMap||!!y.roughnessMap||!!y.metalnessMap||!!y.clearcoatNormalMap||y.transmission>0||!!y.transmissionMap||!!y.thicknessMap||!!y.specularIntensityMap||!!y.specularColorMap||y.sheen>0||!!y.sheenColorMap||!!y.sheenRoughnessMap)&&!!y.displacementMap,fog:!!N,useFog:y.fog,fogExp2:N&&N.isFogExp2,flatShading:!!y.flatShading,sizeAttenuation:y.sizeAttenuation,logarithmicDepthBuffer:h,skinning:z.isSkinnedMesh===!0&&G>0,maxBones:G,useVertexTexture:f,morphTargets:!!z.geometry&&!!z.geometry.morphAttributes.position,morphNormals:!!z.geometry&&!!z.geometry.morphAttributes.normal,morphTargetsCount:!!z.geometry&&!!z.geometry.morphAttributes.position?z.geometry.morphAttributes.position.length:0,numDirLights:R.directional.length,numPointLights:R.point.length,numSpotLights:R.spot.length,numRectAreaLights:R.rectArea.length,numHemiLights:R.hemi.length,numDirLightShadows:R.directionalShadowMap.length,numPointLightShadows:R.pointShadowMap.length,numSpotLightShadows:R.spotShadowMap.length,numClippingPlanes:o.numPlanes,numClipIntersection:o.numIntersection,dithering:y.dithering,shadowMapEnabled:n.shadowMap.enabled&&D.length>0,shadowMapType:n.shadowMap.type,toneMapping:y.toneMapped?n.toneMapping:ti,physicallyCorrectLights:n.physicallyCorrectLights,premultipliedAlpha:y.premultipliedAlpha,doubleSided:y.side===Hr,flipSided:y.side===he,depthPacking:y.depthPacking!==void 0?y.depthPacking:!1,index0AttributeName:y.index0AttributeName,extensionDerivatives:y.extensions&&y.extensions.derivatives,extensionFragDepth:y.extensions&&y.extensions.fragDepth,extensionDrawBuffers:y.extensions&&y.extensions.drawBuffers,extensionShaderTextureLOD:y.extensions&&y.extensions.shaderTextureLOD,rendererExtensionFragDepth:u||i.has("EXT_frag_depth"),rendererExtensionDrawBuffers:u||i.has("WEBGL_draw_buffers"),rendererExtensionShaderTextureLod:u||i.has("EXT_shader_texture_lod"),customProgramCacheKey:y.customProgramCacheKey()}}function b(y){let R=[];if(y.shaderID?R.push(y.shaderID):(R.push(y.customVertexShaderID),R.push(y.customFragmentShaderID)),y.defines!==void 0)for(let D in y.defines)R.push(D),R.push(y.defines[D]);return y.isRawShaderMaterial===!1&&(_(R,y),S(R,y),R.push(n.outputEncoding)),R.push(y.customProgramCacheKey),R.join()}function _(y,R){y.push(R.precision),y.push(R.outputEncoding),y.push(R.envMapMode),y.push(R.combine),y.push(R.vertexUvs),y.push(R.fogExp2),y.push(R.sizeAttenuation),y.push(R.maxBones),y.push(R.morphTargetsCount),y.push(R.numDirLights),y.push(R.numPointLights),y.push(R.numSpotLights),y.push(R.numHemiLights),y.push(R.numRectAreaLights),y.push(R.numDirLightShadows),y.push(R.numPointLightShadows),y.push(R.numSpotLightShadows),y.push(R.shadowMapType),y.push(R.toneMapping),y.push(R.numClippingPlanes),y.push(R.numClipIntersection),y.push(R.alphaWrite)}function S(y,R){a.disableAll(),R.isWebGL2&&a.enable(0),R.supportsVertexTextures&&a.enable(1),R.instancing&&a.enable(2),R.instancingColor&&a.enable(3),R.map&&a.enable(4),R.matcap&&a.enable(5),R.envMap&&a.enable(6),R.envMapCubeUV&&a.enable(7),R.lightMap&&a.enable(8),R.aoMap&&a.enable(9),R.emissiveMap&&a.enable(10),R.bumpMap&&a.enable(11),R.normalMap&&a.enable(12),R.objectSpaceNormalMap&&a.enable(13),R.tangentSpaceNormalMap&&a.enable(14),R.clearcoat&&a.enable(15),R.clearcoatMap&&a.enable(16),R.clearcoatRoughnessMap&&a.enable(17),R.clearcoatNormalMap&&a.enable(18),R.displacementMap&&a.enable(19),R.specularMap&&a.enable(20),R.roughnessMap&&a.enable(21),R.metalnessMap&&a.enable(22),R.gradientMap&&a.enable(23),R.alphaMap&&a.enable(24),R.alphaTest&&a.enable(25),R.vertexColors&&a.enable(26),R.vertexAlphas&&a.enable(27),R.vertexUvs&&a.enable(28),R.vertexTangents&&a.enable(29),R.uvsVertexOnly&&a.enable(30),R.fog&&a.enable(31),y.push(a.mask),a.disableAll(),R.useFog&&a.enable(0),R.flatShading&&a.enable(1),R.logarithmicDepthBuffer&&a.enable(2),R.skinning&&a.enable(3),R.useVertexTexture&&a.enable(4),R.morphTargets&&a.enable(5),R.morphNormals&&a.enable(6),R.premultipliedAlpha&&a.enable(7),R.shadowMapEnabled&&a.enable(8),R.physicallyCorrectLights&&a.enable(9),R.doubleSided&&a.enable(10),R.flipSided&&a.enable(11),R.depthPacking&&a.enable(12),R.dithering&&a.enable(13),R.specularIntensityMap&&a.enable(14),R.specularColorMap&&a.enable(15),R.transmission&&a.enable(16),R.transmissionMap&&a.enable(17),R.thicknessMap&&a.enable(18),R.sheen&&a.enable(19),R.sheenColorMap&&a.enable(20),R.sheenRoughnessMap&&a.enable(21),R.decodeVideoTexture&&a.enable(22),y.push(a.mask)}function L(y){let R=v[y.type],D;if(R){let F=fn[R];D=pM.clone(F.uniforms)}else D=y.uniforms;return D}function A(y,R){let D;for(let F=0,z=c.length;F<z;F++){let N=c[F];if(N.cacheKey===R){D=N,++D.usedTimes;break}}return D===void 0&&(D=new pE(n,R,y,s),c.push(D)),D}function H(y){if(--y.usedTimes===0){let R=c.indexOf(y);c[R]=c[c.length-1],c.pop(),y.destroy()}}function tt(y){l.remove(y)}function X(){l.dispose()}return{getParameters:p,getProgramCacheKey:b,getUniforms:L,acquireProgram:A,releaseProgram:H,releaseShaderCache:tt,programs:c,dispose:X}}function xE(){let n=new WeakMap;function t(s){let o=n.get(s);return o===void 0&&(o={},n.set(s,o)),o}function e(s){n.delete(s)}function i(s,o,a){n.get(s)[o]=a}function r(){n=new WeakMap}return{get:t,remove:e,update:i,dispose:r}}function yE(n,t){return n.groupOrder!==t.groupOrder?n.groupOrder-t.groupOrder:n.renderOrder!==t.renderOrder?n.renderOrder-t.renderOrder:n.material.id!==t.material.id?n.material.id-t.material.id:n.z!==t.z?n.z-t.z:n.id-t.id}function Ng(n,t){return n.groupOrder!==t.groupOrder?n.groupOrder-t.groupOrder:n.renderOrder!==t.renderOrder?n.renderOrder-t.renderOrder:n.z!==t.z?t.z-n.z:n.id-t.id}function Fg(){let n=[],t=0,e=[],i=[],r=[];function s(){t=0,e.length=0,i.length=0,r.length=0}function o(h,f,d,g,x,v){let m=n[t];return m===void 0?(m={id:h.id,object:h,geometry:f,material:d,groupOrder:g,renderOrder:h.renderOrder,z:x,group:v},n[t]=m):(m.id=h.id,m.object=h,m.geometry=f,m.material=d,m.groupOrder=g,m.renderOrder=h.renderOrder,m.z=x,m.group=v),t++,m}function a(h,f,d,g,x,v){let m=o(h,f,d,g,x,v);d.transmission>0?i.push(m):d.transparent===!0?r.push(m):e.push(m)}function l(h,f,d,g,x,v){let m=o(h,f,d,g,x,v);d.transmission>0?i.unshift(m):d.transparent===!0?r.unshift(m):e.unshift(m)}function c(h,f){e.length>1&&e.sort(h||yE),i.length>1&&i.sort(f||Ng),r.length>1&&r.sort(f||Ng)}function u(){for(let h=t,f=n.length;h<f;h++){let d=n[h];if(d.id===null)break;d.id=null,d.object=null,d.geometry=null,d.material=null,d.group=null}}return{opaque:e,transmissive:i,transparent:r,init:s,push:a,unshift:l,finish:u,sort:c}}function vE(){let n=new WeakMap;function t(i,r){let s;return n.has(i)===!1?(s=new Fg,n.set(i,[s])):r>=n.get(i).length?(s=new Fg,n.get(i).push(s)):s=n.get(i)[r],s}function e(){n=new WeakMap}return{get:t,dispose:e}}function _E(){let n={};return{get:function(t){if(n[t.id]!==void 0)return n[t.id];let e;switch(t.type){case"DirectionalLight":e={direction:new T,color:new ft};break;case"SpotLight":e={position:new T,direction:new T,color:new ft,distance:0,coneCos:0,penumbraCos:0,decay:0};break;case"PointLight":e={position:new T,color:new ft,distance:0,decay:0};break;case"HemisphereLight":e={direction:new T,skyColor:new ft,groundColor:new ft};break;case"RectAreaLight":e={color:new ft,position:new T,halfWidth:new T,halfHeight:new T};break}return n[t.id]=e,e}}}function wE(){let n={};return{get:function(t){if(n[t.id]!==void 0)return n[t.id];let e;switch(t.type){case"DirectionalLight":e={shadowBias:0,shadowNormalBias:0,shadowRadius:1,shadowMapSize:new K};break;case"SpotLight":e={shadowBias:0,shadowNormalBias:0,shadowRadius:1,shadowMapSize:new K};break;case"PointLight":e={shadowBias:0,shadowNormalBias:0,shadowRadius:1,shadowMapSize:new K,shadowCameraNear:1,shadowCameraFar:1e3};break}return n[t.id]=e,e}}}var ME=0;function bE(n,t){return(t.castShadow?1:0)-(n.castShadow?1:0)}function SE(n,t){let e=new _E,i=wE(),r={version:0,hash:{directionalLength:-1,pointLength:-1,spotLength:-1,rectAreaLength:-1,hemiLength:-1,numDirectionalShadows:-1,numPointShadows:-1,numSpotShadows:-1},ambient:[0,0,0],probe:[],directional:[],directionalShadow:[],directionalShadowMap:[],directionalShadowMatrix:[],spot:[],spotShadow:[],spotShadowMap:[],spotShadowMatrix:[],rectArea:[],rectAreaLTC1:null,rectAreaLTC2:null,point:[],pointShadow:[],pointShadowMap:[],pointShadowMatrix:[],hemi:[]};for(let u=0;u<9;u++)r.probe.push(new T);let s=new T,o=new wt,a=new wt;function l(u,h){let f=0,d=0,g=0;for(let tt=0;tt<9;tt++)r.probe[tt].set(0,0,0);let x=0,v=0,m=0,p=0,b=0,_=0,S=0,L=0;u.sort(bE);let A=h!==!0?Math.PI:1;for(let tt=0,X=u.length;tt<X;tt++){let y=u[tt],R=y.color,D=y.intensity,F=y.distance,z=y.shadow&&y.shadow.map?y.shadow.map.texture:null;if(y.isAmbientLight)f+=R.r*D*A,d+=R.g*D*A,g+=R.b*D*A;else if(y.isLightProbe)for(let N=0;N<9;N++)r.probe[N].addScaledVector(y.sh.coefficients[N],D);else if(y.isDirectionalLight){let N=e.get(y);if(N.color.copy(y.color).multiplyScalar(y.intensity*A),y.castShadow){let V=y.shadow,Q=i.get(y);Q.shadowBias=V.bias,Q.shadowNormalBias=V.normalBias,Q.shadowRadius=V.radius,Q.shadowMapSize=V.mapSize,r.directionalShadow[x]=Q,r.directionalShadowMap[x]=z,r.directionalShadowMatrix[x]=y.shadow.matrix,_++}r.directional[x]=N,x++}else if(y.isSpotLight){let N=e.get(y);if(N.position.setFromMatrixPosition(y.matrixWorld),N.color.copy(R).multiplyScalar(D*A),N.distance=F,N.coneCos=Math.cos(y.angle),N.penumbraCos=Math.cos(y.angle*(1-y.penumbra)),N.decay=y.decay,y.castShadow){let V=y.shadow,Q=i.get(y);Q.shadowBias=V.bias,Q.shadowNormalBias=V.normalBias,Q.shadowRadius=V.radius,Q.shadowMapSize=V.mapSize,r.spotShadow[m]=Q,r.spotShadowMap[m]=z,r.spotShadowMatrix[m]=y.shadow.matrix,L++}r.spot[m]=N,m++}else if(y.isRectAreaLight){let N=e.get(y);N.color.copy(R).multiplyScalar(D),N.halfWidth.set(y.width*.5,0,0),N.halfHeight.set(0,y.height*.5,0),r.rectArea[p]=N,p++}else if(y.isPointLight){let N=e.get(y);if(N.color.copy(y.color).multiplyScalar(y.intensity*A),N.distance=y.distance,N.decay=y.decay,y.castShadow){let V=y.shadow,Q=i.get(y);Q.shadowBias=V.bias,Q.shadowNormalBias=V.normalBias,Q.shadowRadius=V.radius,Q.shadowMapSize=V.mapSize,Q.shadowCameraNear=V.camera.near,Q.shadowCameraFar=V.camera.far,r.pointShadow[v]=Q,r.pointShadowMap[v]=z,r.pointShadowMatrix[v]=y.shadow.matrix,S++}r.point[v]=N,v++}else if(y.isHemisphereLight){let N=e.get(y);N.skyColor.copy(y.color).multiplyScalar(D*A),N.groundColor.copy(y.groundColor).multiplyScalar(D*A),r.hemi[b]=N,b++}}p>0&&(t.isWebGL2||n.has("OES_texture_float_linear")===!0?(r.rectAreaLTC1=ot.LTC_FLOAT_1,r.rectAreaLTC2=ot.LTC_FLOAT_2):n.has("OES_texture_half_float_linear")===!0?(r.rectAreaLTC1=ot.LTC_HALF_1,r.rectAreaLTC2=ot.LTC_HALF_2):console.error("THREE.WebGLRenderer: Unable to use RectAreaLight. Missing WebGL extensions.")),r.ambient[0]=f,r.ambient[1]=d,r.ambient[2]=g;let H=r.hash;(H.directionalLength!==x||H.pointLength!==v||H.spotLength!==m||H.rectAreaLength!==p||H.hemiLength!==b||H.numDirectionalShadows!==_||H.numPointShadows!==S||H.numSpotShadows!==L)&&(r.directional.length=x,r.spot.length=m,r.rectArea.length=p,r.point.length=v,r.hemi.length=b,r.directionalShadow.length=_,r.directionalShadowMap.length=_,r.pointShadow.length=S,r.pointShadowMap.length=S,r.spotShadow.length=L,r.spotShadowMap.length=L,r.directionalShadowMatrix.length=_,r.pointShadowMatrix.length=S,r.spotShadowMatrix.length=L,H.directionalLength=x,H.pointLength=v,H.spotLength=m,H.rectAreaLength=p,H.hemiLength=b,H.numDirectionalShadows=_,H.numPointShadows=S,H.numSpotShadows=L,r.version=ME++)}function c(u,h){let f=0,d=0,g=0,x=0,v=0,m=h.matrixWorldInverse;for(let p=0,b=u.length;p<b;p++){let _=u[p];if(_.isDirectionalLight){let S=r.directional[f];S.direction.setFromMatrixPosition(_.matrixWorld),s.setFromMatrixPosition(_.target.matrixWorld),S.direction.sub(s),S.direction.transformDirection(m),f++}else if(_.isSpotLight){let S=r.spot[g];S.position.setFromMatrixPosition(_.matrixWorld),S.position.applyMatrix4(m),S.direction.setFromMatrixPosition(_.matrixWorld),s.setFromMatrixPosition(_.target.matrixWorld),S.direction.sub(s),S.direction.transformDirection(m),g++}else if(_.isRectAreaLight){let S=r.rectArea[x];S.position.setFromMatrixPosition(_.matrixWorld),S.position.applyMatrix4(m),a.identity(),o.copy(_.matrixWorld),o.premultiply(m),a.extractRotation(o),S.halfWidth.set(_.width*.5,0,0),S.halfHeight.set(0,_.height*.5,0),S.halfWidth.applyMatrix4(a),S.halfHeight.applyMatrix4(a),x++}else if(_.isPointLight){let S=r.point[d];S.position.setFromMatrixPosition(_.matrixWorld),S.position.applyMatrix4(m),d++}else if(_.isHemisphereLight){let S=r.hemi[v];S.direction.setFromMatrixPosition(_.matrixWorld),S.direction.transformDirection(m),S.direction.normalize(),v++}}}return{setup:l,setupView:c,state:r}}function zg(n,t){let e=new SE(n,t),i=[],r=[];function s(){i.length=0,r.length=0}function o(h){i.push(h)}function a(h){r.push(h)}function l(h){e.setup(i,h)}function c(h){e.setupView(i,h)}return{init:s,state:{lightsArray:i,shadowsArray:r,lights:e},setupLights:l,setupLightsView:c,pushLight:o,pushShadow:a}}function EE(n,t){let e=new WeakMap;function i(s,o=0){let a;return e.has(s)===!1?(a=new zg(n,t),e.set(s,[a])):o>=e.get(s).length?(a=new zg(n,t),e.get(s).push(a)):a=e.get(s)[o],a}function r(){e=new WeakMap}return{get:i,dispose:r}}var cl=class extends xe{constructor(t){super(),this.type="MeshDepthMaterial",this.depthPacking=Kw,this.map=null,this.alphaMap=null,this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.wireframe=!1,this.wireframeLinewidth=1,this.fog=!1,this.setValues(t)}copy(t){return super.copy(t),this.depthPacking=t.depthPacking,this.map=t.map,this.alphaMap=t.alphaMap,this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this}};cl.prototype.isMeshDepthMaterial=!0;var ul=class extends xe{constructor(t){super(),this.type="MeshDistanceMaterial",this.referencePosition=new T,this.nearDistance=1,this.farDistance=1e3,this.map=null,this.alphaMap=null,this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.fog=!1,this.setValues(t)}copy(t){return super.copy(t),this.referencePosition.copy(t.referencePosition),this.nearDistance=t.nearDistance,this.farDistance=t.farDistance,this.map=t.map,this.alphaMap=t.alphaMap,this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this}};ul.prototype.isMeshDistanceMaterial=!0;var TE=`void main() {
	gl_Position = vec4( position, 1.0 );
}`,AE=`uniform sampler2D shadow_pass;
uniform vec2 resolution;
uniform float radius;
#include <packing>
void main() {
	const float samples = float( VSM_SAMPLES );
	float mean = 0.0;
	float squared_mean = 0.0;
	float uvStride = samples <= 1.0 ? 0.0 : 2.0 / ( samples - 1.0 );
	float uvStart = samples <= 1.0 ? 0.0 : - 1.0;
	for ( float i = 0.0; i < samples; i ++ ) {
		float uvOffset = uvStart + i * uvStride;
		#ifdef HORIZONTAL_PASS
			vec2 distribution = unpackRGBATo2Half( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( uvOffset, 0.0 ) * radius ) / resolution ) );
			mean += distribution.x;
			squared_mean += distribution.y * distribution.y + distribution.x * distribution.x;
		#else
			float depth = unpackRGBAToDepth( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( 0.0, uvOffset ) * radius ) / resolution ) );
			mean += depth;
			squared_mean += depth * depth;
		#endif
	}
	mean = mean / samples;
	squared_mean = squared_mean / samples;
	float std_dev = sqrt( squared_mean - mean * mean );
	gl_FragColor = pack2HalfToRGBA( vec2( mean, std_dev ) );
}`;function T0(n,t,e){let i=new qr,r=new K,s=new K,o=new Wt,a=new cl({depthPacking:Qw}),l=new ul,c={},u=e.maxTextureSize,h={0:he,1:eo,2:Hr},f=new Fn({defines:{VSM_SAMPLES:8},uniforms:{shadow_pass:{value:null},resolution:{value:new K},radius:{value:4}},vertexShader:TE,fragmentShader:AE}),d=f.clone();d.defines.HORIZONTAL_PASS=1;let g=new Ht;g.setAttribute("position",new Qt(new Float32Array([-1,-1,.5,3,-1,.5,-1,3,.5]),3));let x=new oe(g,f),v=this;this.enabled=!1,this.autoUpdate=!0,this.needsUpdate=!1,this.type=l0,this.render=function(_,S,L){if(v.enabled===!1||v.autoUpdate===!1&&v.needsUpdate===!1||_.length===0)return;let A=n.getRenderTarget(),H=n.getActiveCubeFace(),tt=n.getActiveMipmapLevel(),X=n.state;X.setBlending(jn),X.buffers.color.setClear(1,1,1,1),X.buffers.depth.setTest(!0),X.setScissorTest(!1);for(let y=0,R=_.length;y<R;y++){let D=_[y],F=D.shadow;if(F===void 0){console.warn("THREE.WebGLShadowMap:",D,"has no shadow.");continue}if(F.autoUpdate===!1&&F.needsUpdate===!1)continue;r.copy(F.mapSize);let z=F.getFrameExtents();if(r.multiply(z),s.copy(F.mapSize),(r.x>u||r.y>u)&&(r.x>u&&(s.x=Math.floor(u/z.x),r.x=s.x*z.x,F.mapSize.x=s.x),r.y>u&&(s.y=Math.floor(u/z.y),r.y=s.y*z.y,F.mapSize.y=s.y)),F.map===null&&!F.isPointLightShadow&&this.type===Js){let V={minFilter:be,magFilter:be,format:Re};F.map=new Ne(r.x,r.y,V),F.map.texture.name=D.name+".shadowMap",F.mapPass=new Ne(r.x,r.y,V),F.camera.updateProjectionMatrix()}if(F.map===null){let V={minFilter:fe,magFilter:fe,format:Re};F.map=new Ne(r.x,r.y,V),F.map.texture.name=D.name+".shadowMap",F.camera.updateProjectionMatrix()}n.setRenderTarget(F.map),n.clear();let N=F.getViewportCount();for(let V=0;V<N;V++){let Q=F.getViewport(V);o.set(s.x*Q.x,s.y*Q.y,s.x*Q.z,s.y*Q.w),X.viewport(o),F.updateMatrices(D,V),i=F.getFrustum(),b(S,L,F.camera,D,this.type)}!F.isPointLightShadow&&this.type===Js&&m(F,L),F.needsUpdate=!1}v.needsUpdate=!1,n.setRenderTarget(A,H,tt)};function m(_,S){let L=t.update(x);f.defines.VSM_SAMPLES!==_.blurSamples&&(f.defines.VSM_SAMPLES=_.blurSamples,d.defines.VSM_SAMPLES=_.blurSamples,f.needsUpdate=!0,d.needsUpdate=!0),f.uniforms.shadow_pass.value=_.map.texture,f.uniforms.resolution.value=_.mapSize,f.uniforms.radius.value=_.radius,n.setRenderTarget(_.mapPass),n.clear(),n.renderBufferDirect(S,null,L,f,x,null),d.uniforms.shadow_pass.value=_.mapPass.texture,d.uniforms.resolution.value=_.mapSize,d.uniforms.radius.value=_.radius,n.setRenderTarget(_.map),n.clear(),n.renderBufferDirect(S,null,L,d,x,null)}function p(_,S,L,A,H,tt,X){let y=null,R=A.isPointLight===!0?_.customDistanceMaterial:_.customDepthMaterial;if(R!==void 0?y=R:y=A.isPointLight===!0?l:a,n.localClippingEnabled&&L.clipShadows===!0&&L.clippingPlanes.length!==0||L.displacementMap&&L.displacementScale!==0||L.alphaMap&&L.alphaTest>0){let D=y.uuid,F=L.uuid,z=c[D];z===void 0&&(z={},c[D]=z);let N=z[F];N===void 0&&(N=y.clone(),z[F]=N),y=N}return y.visible=L.visible,y.wireframe=L.wireframe,X===Js?y.side=L.shadowSide!==null?L.shadowSide:L.side:y.side=L.shadowSide!==null?L.shadowSide:h[L.side],y.alphaMap=L.alphaMap,y.alphaTest=L.alphaTest,y.clipShadows=L.clipShadows,y.clippingPlanes=L.clippingPlanes,y.clipIntersection=L.clipIntersection,y.displacementMap=L.displacementMap,y.displacementScale=L.displacementScale,y.displacementBias=L.displacementBias,y.wireframeLinewidth=L.wireframeLinewidth,y.linewidth=L.linewidth,A.isPointLight===!0&&y.isMeshDistanceMaterial===!0&&(y.referencePosition.setFromMatrixPosition(A.matrixWorld),y.nearDistance=H,y.farDistance=tt),y}function b(_,S,L,A,H){if(_.visible===!1)return;if(_.layers.test(S.layers)&&(_.isMesh||_.isLine||_.isPoints)&&(_.castShadow||_.receiveShadow&&H===Js)&&(!_.frustumCulled||i.intersectsObject(_))){_.modelViewMatrix.multiplyMatrices(L.matrixWorldInverse,_.matrixWorld);let y=t.update(_),R=_.material;if(Array.isArray(R)){let D=y.groups;for(let F=0,z=D.length;F<z;F++){let N=D[F],V=R[N.materialIndex];if(V&&V.visible){let Q=p(_,y,V,A,L.near,L.far,H);n.renderBufferDirect(L,null,y,Q,_,N)}}}else if(R.visible){let D=p(_,y,R,A,L.near,L.far,H);n.renderBufferDirect(L,null,y,D,_,null)}}let X=_.children;for(let y=0,R=X.length;y<R;y++)b(X[y],S,L,A,H)}}function CE(n,t,e){let i=e.isWebGL2;function r(){let P=!1,pt=new Wt,ht=null,Et=new Wt(0,0,0,0);return{setMask:function(Y){ht!==Y&&!P&&(n.colorMask(Y,Y,Y,Y),ht=Y)},setLocked:function(Y){P=Y},setClear:function(Y,Mt,Dt,jt,ze){ze===!0&&(Y*=jt,Mt*=jt,Dt*=jt),pt.set(Y,Mt,Dt,jt),Et.equals(pt)===!1&&(n.clearColor(Y,Mt,Dt,jt),Et.copy(pt))},reset:function(){P=!1,ht=null,Et.set(-1,0,0,0)}}}function s(){let P=!1,pt=null,ht=null,Et=null;return{setTest:function(Y){Y?k(2929):Ft(2929)},setMask:function(Y){pt!==Y&&!P&&(n.depthMask(Y),pt=Y)},setFunc:function(Y){if(ht!==Y){if(Y)switch(Y){case yw:n.depthFunc(512);break;case vw:n.depthFunc(519);break;case _w:n.depthFunc(513);break;case zu:n.depthFunc(515);break;case ww:n.depthFunc(514);break;case Mw:n.depthFunc(518);break;case bw:n.depthFunc(516);break;case Sw:n.depthFunc(517);break;default:n.depthFunc(515)}else n.depthFunc(515);ht=Y}},setLocked:function(Y){P=Y},setClear:function(Y){Et!==Y&&(n.clearDepth(Y),Et=Y)},reset:function(){P=!1,pt=null,ht=null,Et=null}}}function o(){let P=!1,pt=null,ht=null,Et=null,Y=null,Mt=null,Dt=null,jt=null,ze=null;return{setTest:function(ne){P||(ne?k(2960):Ft(2960))},setMask:function(ne){pt!==ne&&!P&&(n.stencilMask(ne),pt=ne)},setFunc:function(ne,en,yn){(ht!==ne||Et!==en||Y!==yn)&&(n.stencilFunc(ne,en,yn),ht=ne,Et=en,Y=yn)},setOp:function(ne,en,yn){(Mt!==ne||Dt!==en||jt!==yn)&&(n.stencilOp(ne,en,yn),Mt=ne,Dt=en,jt=yn)},setLocked:function(ne){P=ne},setClear:function(ne){ze!==ne&&(n.clearStencil(ne),ze=ne)},reset:function(){P=!1,pt=null,ht=null,Et=null,Y=null,Mt=null,Dt=null,jt=null,ze=null}}}let a=new r,l=new s,c=new o,u={},h={},f=new WeakMap,d=[],g=null,x=!1,v=null,m=null,p=null,b=null,_=null,S=null,L=null,A=!1,H=null,tt=null,X=null,y=null,R=null,D=n.getParameter(35661),F=!1,z=0,N=n.getParameter(7938);N.indexOf("WebGL")!==-1?(z=parseFloat(/^WebGL (\d)/.exec(N)[1]),F=z>=1):N.indexOf("OpenGL ES")!==-1&&(z=parseFloat(/^OpenGL ES (\d)/.exec(N)[1]),F=z>=2);let V=null,Q={},at=n.getParameter(3088),G=n.getParameter(2978),$=new Wt().fromArray(at),lt=new Wt().fromArray(G);function dt(P,pt,ht){let Et=new Uint8Array(4),Y=n.createTexture();n.bindTexture(P,Y),n.texParameteri(P,10241,9728),n.texParameteri(P,10240,9728);for(let Mt=0;Mt<ht;Mt++)n.texImage2D(pt+Mt,0,6408,1,1,0,6408,5121,Et);return Y}let xt={};xt[3553]=dt(3553,3553,1),xt[34067]=dt(34067,34069,6),a.setClear(0,0,0,1),l.setClear(1),c.setClear(0),k(2929),l.setFunc(zu),J(!1),it(Am),k(2884),C(jn);function k(P){u[P]!==!0&&(n.enable(P),u[P]=!0)}function Ft(P){u[P]!==!1&&(n.disable(P),u[P]=!1)}function mt(P,pt){return h[P]!==pt?(n.bindFramebuffer(P,pt),h[P]=pt,i&&(P===36009&&(h[36160]=pt),P===36160&&(h[36009]=pt)),!0):!1}function St(P,pt){let ht=d,Et=!1;if(P)if(ht=f.get(pt),ht===void 0&&(ht=[],f.set(pt,ht)),P.isWebGLMultipleRenderTargets){let Y=P.texture;if(ht.length!==Y.length||ht[0]!==36064){for(let Mt=0,Dt=Y.length;Mt<Dt;Mt++)ht[Mt]=36064+Mt;ht.length=Y.length,Et=!0}}else ht[0]!==36064&&(ht[0]=36064,Et=!0);else ht[0]!==1029&&(ht[0]=1029,Et=!0);Et&&(e.isWebGL2?n.drawBuffers(ht):t.get("WEBGL_draw_buffers").drawBuffersWEBGL(ht))}function B(P){return g!==P?(n.useProgram(P),g=P,!0):!1}let st={[Ir]:32774,[aw]:32778,[lw]:32779};if(i)st[Pm]=32775,st[Dm]=32776;else{let P=t.get("EXT_blend_minmax");P!==null&&(st[Pm]=P.MIN_EXT,st[Dm]=P.MAX_EXT)}let nt={[cw]:0,[uw]:1,[hw]:768,[u0]:770,[xw]:776,[mw]:774,[dw]:772,[fw]:769,[h0]:771,[gw]:775,[pw]:773};function C(P,pt,ht,Et,Y,Mt,Dt,jt){if(P===jn){x===!0&&(Ft(3042),x=!1);return}if(x===!1&&(k(3042),x=!0),P!==ow){if(P!==v||jt!==A){if((m!==Ir||_!==Ir)&&(n.blendEquation(32774),m=Ir,_=Ir),jt)switch(P){case Ks:n.blendFuncSeparate(1,771,1,771);break;case Cm:n.blendFunc(1,1);break;case Rm:n.blendFuncSeparate(0,769,0,1);break;case Lm:n.blendFuncSeparate(0,768,0,770);break;default:console.error("THREE.WebGLState: Invalid blending: ",P);break}else switch(P){case Ks:n.blendFuncSeparate(770,771,1,771);break;case Cm:n.blendFunc(770,1);break;case Rm:n.blendFuncSeparate(0,769,0,1);break;case Lm:n.blendFunc(0,768);break;default:console.error("THREE.WebGLState: Invalid blending: ",P);break}p=null,b=null,S=null,L=null,v=P,A=jt}return}Y=Y||pt,Mt=Mt||ht,Dt=Dt||Et,(pt!==m||Y!==_)&&(n.blendEquationSeparate(st[pt],st[Y]),m=pt,_=Y),(ht!==p||Et!==b||Mt!==S||Dt!==L)&&(n.blendFuncSeparate(nt[ht],nt[Et],nt[Mt],nt[Dt]),p=ht,b=Et,S=Mt,L=Dt),v=P,A=null}function j(P,pt){P.side===Hr?Ft(2884):k(2884);let ht=P.side===he;pt&&(ht=!ht),J(ht),P.blending===Ks&&P.transparent===!1?C(jn):C(P.blending,P.blendEquation,P.blendSrc,P.blendDst,P.blendEquationAlpha,P.blendSrcAlpha,P.blendDstAlpha,P.premultipliedAlpha),l.setFunc(P.depthFunc),l.setTest(P.depthTest),l.setMask(P.depthWrite),a.setMask(P.colorWrite);let Et=P.stencilWrite;c.setTest(Et),Et&&(c.setMask(P.stencilWriteMask),c.setFunc(P.stencilFunc,P.stencilRef,P.stencilFuncMask),c.setOp(P.stencilFail,P.stencilZFail,P.stencilZPass)),vt(P.polygonOffset,P.polygonOffsetFactor,P.polygonOffsetUnits),P.alphaToCoverage===!0?k(32926):Ft(32926)}function J(P){H!==P&&(P?n.frontFace(2304):n.frontFace(2305),H=P)}function it(P){P!==iw?(k(2884),P!==tt&&(P===Am?n.cullFace(1029):P===rw?n.cullFace(1028):n.cullFace(1032))):Ft(2884),tt=P}function et(P){P!==X&&(F&&n.lineWidth(P),X=P)}function vt(P,pt,ht){P?(k(32823),(y!==pt||R!==ht)&&(n.polygonOffset(pt,ht),y=pt,R=ht)):Ft(32823)}function bt(P){P?k(3089):Ft(3089)}function It(P){P===void 0&&(P=33984+D-1),V!==P&&(n.activeTexture(P),V=P)}function Zt(P,pt){V===null&&It();let ht=Q[V];ht===void 0&&(ht={type:void 0,texture:void 0},Q[V]=ht),(ht.type!==P||ht.texture!==pt)&&(n.bindTexture(P,pt||xt[P]),ht.type=P,ht.texture=pt)}function qt(){let P=Q[V];P!==void 0&&P.type!==void 0&&(n.bindTexture(P.type,null),P.type=void 0,P.texture=void 0)}function E(){try{n.compressedTexImage2D.apply(n,arguments)}catch(P){console.error("THREE.WebGLState:",P)}}function w(){try{n.texSubImage2D.apply(n,arguments)}catch(P){console.error("THREE.WebGLState:",P)}}function q(){try{n.texSubImage3D.apply(n,arguments)}catch(P){console.error("THREE.WebGLState:",P)}}function rt(){try{n.compressedTexSubImage2D.apply(n,arguments)}catch(P){console.error("THREE.WebGLState:",P)}}function gt(){try{n.texStorage2D.apply(n,arguments)}catch(P){console.error("THREE.WebGLState:",P)}}function W(){try{n.texStorage3D.apply(n,arguments)}catch(P){console.error("THREE.WebGLState:",P)}}function _t(){try{n.texImage2D.apply(n,arguments)}catch(P){console.error("THREE.WebGLState:",P)}}function yt(){try{n.texImage3D.apply(n,arguments)}catch(P){console.error("THREE.WebGLState:",P)}}function ut(P){$.equals(P)===!1&&(n.scissor(P.x,P.y,P.z,P.w),$.copy(P))}function ct(P){lt.equals(P)===!1&&(n.viewport(P.x,P.y,P.z,P.w),lt.copy(P))}function At(){n.disable(3042),n.disable(2884),n.disable(2929),n.disable(32823),n.disable(3089),n.disable(2960),n.disable(32926),n.blendEquation(32774),n.blendFunc(1,0),n.blendFuncSeparate(1,0,1,0),n.colorMask(!0,!0,!0,!0),n.clearColor(0,0,0,0),n.depthMask(!0),n.depthFunc(513),n.clearDepth(1),n.stencilMask(4294967295),n.stencilFunc(519,0,4294967295),n.stencilOp(7680,7680,7680),n.clearStencil(0),n.cullFace(1029),n.frontFace(2305),n.polygonOffset(0,0),n.activeTexture(33984),n.bindFramebuffer(36160,null),i===!0&&(n.bindFramebuffer(36009,null),n.bindFramebuffer(36008,null)),n.useProgram(null),n.lineWidth(1),n.scissor(0,0,n.canvas.width,n.canvas.height),n.viewport(0,0,n.canvas.width,n.canvas.height),u={},V=null,Q={},h={},f=new WeakMap,d=[],g=null,x=!1,v=null,m=null,p=null,b=null,_=null,S=null,L=null,A=!1,H=null,tt=null,X=null,y=null,R=null,$.set(0,0,n.canvas.width,n.canvas.height),lt.set(0,0,n.canvas.width,n.canvas.height),a.reset(),l.reset(),c.reset()}return{buffers:{color:a,depth:l,stencil:c},enable:k,disable:Ft,bindFramebuffer:mt,drawBuffers:St,useProgram:B,setBlending:C,setMaterial:j,setFlipSided:J,setCullFace:it,setLineWidth:et,setPolygonOffset:vt,setScissorTest:bt,activeTexture:It,bindTexture:Zt,unbindTexture:qt,compressedTexImage2D:E,texImage2D:_t,texImage3D:yt,texStorage2D:gt,texStorage3D:W,texSubImage2D:w,texSubImage3D:q,compressedTexSubImage2D:rt,scissor:ut,viewport:ct,reset:At}}function RE(n,t,e,i,r,s,o){let a=r.isWebGL2,l=r.maxTextures,c=r.maxCubemapSize,u=r.maxTextureSize,h=r.maxSamples,d=t.has("WEBGL_multisampled_render_to_texture")?t.get("WEBGL_multisampled_render_to_texture"):void 0,g=new WeakMap,x,v=!1;try{v=typeof OffscreenCanvas!="undefined"&&new OffscreenCanvas(1,1).getContext("2d")!==null}catch(E){}function m(E,w){return v?new OffscreenCanvas(E,w):ro("canvas")}function p(E,w,q,rt){let gt=1;if((E.width>rt||E.height>rt)&&(gt=rt/Math.max(E.width,E.height)),gt<1||w===!0)if(typeof HTMLImageElement!="undefined"&&E instanceof HTMLImageElement||typeof HTMLCanvasElement!="undefined"&&E instanceof HTMLCanvasElement||typeof ImageBitmap!="undefined"&&E instanceof ImageBitmap){let W=w?nM:Math.floor,_t=W(gt*E.width),yt=W(gt*E.height);x===void 0&&(x=m(_t,yt));let ut=q?m(_t,yt):x;return ut.width=_t,ut.height=yt,ut.getContext("2d").drawImage(E,0,0,_t,yt),console.warn("THREE.WebGLRenderer: Texture has been resized from ("+E.width+"x"+E.height+") to ("+_t+"x"+yt+")."),ut}else return"data"in E&&console.warn("THREE.WebGLRenderer: Image in DataTexture is too big ("+E.width+"x"+E.height+")."),E;return E}function b(E){return ig(E.width)&&ig(E.height)}function _(E){return a?!1:E.wrapS!==Ve||E.wrapT!==Ve||E.minFilter!==fe&&E.minFilter!==be}function S(E,w){return E.generateMipmaps&&w&&E.minFilter!==fe&&E.minFilter!==be}function L(E){n.generateMipmap(E)}function A(E,w,q,rt,gt=!1){if(a===!1)return w;if(E!==null){if(n[E]!==void 0)return n[E];console.warn("THREE.WebGLRenderer: Attempt to use non-existing WebGL internal format '"+E+"'")}let W=w;return w===6403&&(q===5126&&(W=33326),q===5131&&(W=33325),q===5121&&(W=33321)),w===33319&&(q===5126&&(W=33328),q===5131&&(W=33327),q===5121&&(W=33323)),w===6408&&(q===5126&&(W=34836),q===5131&&(W=34842),q===5121&&(W=rt===$t&&gt===!1?35907:32856),q===32819&&(W=32854),q===32820&&(W=32855)),(W===33325||W===33326||W===33327||W===33328||W===34842||W===34836)&&t.get("EXT_color_buffer_float"),W}function H(E,w,q){return S(E,q)===!0||E.isFramebufferTexture&&E.minFilter!==fe&&E.minFilter!==be?Math.log2(Math.max(w.width,w.height))+1:E.mipmaps!==void 0&&E.mipmaps.length>0?E.mipmaps.length:E.isCompressedTexture&&Array.isArray(E.image)?w.mipmaps.length:1}function tt(E){return E===fe||E===Im||E===Nm?9728:9729}function X(E){let w=E.target;w.removeEventListener("dispose",X),R(w),w.isVideoTexture&&g.delete(w),o.memory.textures--}function y(E){let w=E.target;w.removeEventListener("dispose",y),D(w)}function R(E){let w=i.get(E);w.__webglInit!==void 0&&(n.deleteTexture(w.__webglTexture),i.remove(E))}function D(E){let w=E.texture,q=i.get(E),rt=i.get(w);if(!!E){if(rt.__webglTexture!==void 0&&(n.deleteTexture(rt.__webglTexture),o.memory.textures--),E.depthTexture&&E.depthTexture.dispose(),E.isWebGLCubeRenderTarget)for(let gt=0;gt<6;gt++)n.deleteFramebuffer(q.__webglFramebuffer[gt]),q.__webglDepthbuffer&&n.deleteRenderbuffer(q.__webglDepthbuffer[gt]);else n.deleteFramebuffer(q.__webglFramebuffer),q.__webglDepthbuffer&&n.deleteRenderbuffer(q.__webglDepthbuffer),q.__webglMultisampledFramebuffer&&n.deleteFramebuffer(q.__webglMultisampledFramebuffer),q.__webglColorRenderbuffer&&n.deleteRenderbuffer(q.__webglColorRenderbuffer),q.__webglDepthRenderbuffer&&n.deleteRenderbuffer(q.__webglDepthRenderbuffer);if(E.isWebGLMultipleRenderTargets)for(let gt=0,W=w.length;gt<W;gt++){let _t=i.get(w[gt]);_t.__webglTexture&&(n.deleteTexture(_t.__webglTexture),o.memory.textures--),i.remove(w[gt])}i.remove(w),i.remove(E)}}let F=0;function z(){F=0}function N(){let E=F;return E>=l&&console.warn("THREE.WebGLTextures: Trying to use "+E+" texture units while this GPU supports only "+l),F+=1,E}function V(E,w){let q=i.get(E);if(E.isVideoTexture&&et(E),E.version>0&&q.__version!==E.version){let rt=E.image;if(rt===void 0)console.warn("THREE.WebGLRenderer: Texture marked for update but image is undefined");else if(rt.complete===!1)console.warn("THREE.WebGLRenderer: Texture marked for update but image is incomplete");else{k(q,E,w);return}}e.activeTexture(33984+w),e.bindTexture(3553,q.__webglTexture)}function Q(E,w){let q=i.get(E);if(E.version>0&&q.__version!==E.version){k(q,E,w);return}e.activeTexture(33984+w),e.bindTexture(35866,q.__webglTexture)}function at(E,w){let q=i.get(E);if(E.version>0&&q.__version!==E.version){k(q,E,w);return}e.activeTexture(33984+w),e.bindTexture(32879,q.__webglTexture)}function G(E,w){let q=i.get(E);if(E.version>0&&q.__version!==E.version){Ft(q,E,w);return}e.activeTexture(33984+w),e.bindTexture(34067,q.__webglTexture)}let $={[Ou]:10497,[Ve]:33071,[ku]:33648},lt={[fe]:9728,[Im]:9984,[Nm]:9986,[be]:9729,[Dw]:9985,[Ll]:9987};function dt(E,w,q){if(q?(n.texParameteri(E,10242,$[w.wrapS]),n.texParameteri(E,10243,$[w.wrapT]),(E===32879||E===35866)&&n.texParameteri(E,32882,$[w.wrapR]),n.texParameteri(E,10240,lt[w.magFilter]),n.texParameteri(E,10241,lt[w.minFilter])):(n.texParameteri(E,10242,33071),n.texParameteri(E,10243,33071),(E===32879||E===35866)&&n.texParameteri(E,32882,33071),(w.wrapS!==Ve||w.wrapT!==Ve)&&console.warn("THREE.WebGLRenderer: Texture is not power of two. Texture.wrapS and Texture.wrapT should be set to THREE.ClampToEdgeWrapping."),n.texParameteri(E,10240,tt(w.magFilter)),n.texParameteri(E,10241,tt(w.minFilter)),w.minFilter!==fe&&w.minFilter!==be&&console.warn("THREE.WebGLRenderer: Texture is not power of two. Texture.minFilter should be set to THREE.NearestFilter or THREE.LinearFilter.")),t.has("EXT_texture_filter_anisotropic")===!0){let rt=t.get("EXT_texture_filter_anisotropic");if(w.type===Ui&&t.has("OES_texture_float_linear")===!1||a===!1&&w.type===Ur&&t.has("OES_texture_half_float_linear")===!1)return;(w.anisotropy>1||i.get(w).__currentAnisotropy)&&(n.texParameterf(E,rt.TEXTURE_MAX_ANISOTROPY_EXT,Math.min(w.anisotropy,r.getMaxAnisotropy())),i.get(w).__currentAnisotropy=w.anisotropy)}}function xt(E,w){E.__webglInit===void 0&&(E.__webglInit=!0,w.addEventListener("dispose",X),E.__webglTexture=n.createTexture(),o.memory.textures++)}function k(E,w,q){let rt=3553;w.isDataTexture2DArray&&(rt=35866),w.isDataTexture3D&&(rt=32879),xt(E,w),e.activeTexture(33984+q),e.bindTexture(rt,E.__webglTexture),n.pixelStorei(37440,w.flipY),n.pixelStorei(37441,w.premultiplyAlpha),n.pixelStorei(3317,w.unpackAlignment),n.pixelStorei(37443,0);let gt=_(w)&&b(w.image)===!1,W=p(w.image,gt,!1,u);W=vt(w,W);let _t=b(W)||a,yt=s.convert(w.format,w.encoding),ut=s.convert(w.type),ct=A(w.internalFormat,yt,ut,w.encoding,w.isVideoTexture);dt(rt,w,_t);let At,P=w.mipmaps,pt=a&&w.isVideoTexture!==!0,ht=E.__version===void 0,Et=H(w,W,_t);if(w.isDepthTexture)ct=6402,a?w.type===Ui?ct=36012:w.type===Qa?ct=33190:w.type===Br?ct=35056:ct=33189:w.type===Ui&&console.error("WebGLRenderer: Floating point depth texture requires WebGL2."),w.format===Oi&&ct===6402&&w.type!==no&&w.type!==Qa&&(console.warn("THREE.WebGLRenderer: Use UnsignedShortType or UnsignedIntType for DepthFormat DepthTexture."),w.type=no,ut=s.convert(w.type)),w.format===Vr&&ct===6402&&(ct=34041,w.type!==Br&&(console.warn("THREE.WebGLRenderer: Use UnsignedInt248Type for DepthStencilFormat DepthTexture."),w.type=Br,ut=s.convert(w.type))),pt&&ht?e.texStorage2D(3553,1,ct,W.width,W.height):e.texImage2D(3553,0,ct,W.width,W.height,0,yt,ut,null);else if(w.isDataTexture)if(P.length>0&&_t){pt&&ht&&e.texStorage2D(3553,Et,ct,P[0].width,P[0].height);for(let Y=0,Mt=P.length;Y<Mt;Y++)At=P[Y],pt?e.texSubImage2D(3553,0,0,0,At.width,At.height,yt,ut,At.data):e.texImage2D(3553,Y,ct,At.width,At.height,0,yt,ut,At.data);w.generateMipmaps=!1}else pt?(ht&&e.texStorage2D(3553,Et,ct,W.width,W.height),e.texSubImage2D(3553,0,0,0,W.width,W.height,yt,ut,W.data)):e.texImage2D(3553,0,ct,W.width,W.height,0,yt,ut,W.data);else if(w.isCompressedTexture){pt&&ht&&e.texStorage2D(3553,Et,ct,P[0].width,P[0].height);for(let Y=0,Mt=P.length;Y<Mt;Y++)At=P[Y],w.format!==Re?yt!==null?pt?e.compressedTexSubImage2D(3553,Y,0,0,At.width,At.height,yt,At.data):e.compressedTexImage2D(3553,Y,ct,At.width,At.height,0,At.data):console.warn("THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .uploadTexture()"):pt?e.texSubImage2D(3553,Y,0,0,At.width,At.height,yt,ut,At.data):e.texImage2D(3553,Y,ct,At.width,At.height,0,yt,ut,At.data)}else if(w.isDataTexture2DArray)pt?(ht&&e.texStorage3D(35866,Et,ct,W.width,W.height,W.depth),e.texSubImage3D(35866,0,0,0,0,W.width,W.height,W.depth,yt,ut,W.data)):e.texImage3D(35866,0,ct,W.width,W.height,W.depth,0,yt,ut,W.data);else if(w.isDataTexture3D)pt?(ht&&e.texStorage3D(32879,Et,ct,W.width,W.height,W.depth),e.texSubImage3D(32879,0,0,0,0,W.width,W.height,W.depth,yt,ut,W.data)):e.texImage3D(32879,0,ct,W.width,W.height,W.depth,0,yt,ut,W.data);else if(w.isFramebufferTexture)pt&&ht?e.texStorage2D(3553,Et,ct,W.width,W.height):e.texImage2D(3553,0,ct,W.width,W.height,0,yt,ut,null);else if(P.length>0&&_t){pt&&ht&&e.texStorage2D(3553,Et,ct,P[0].width,P[0].height);for(let Y=0,Mt=P.length;Y<Mt;Y++)At=P[Y],pt?e.texSubImage2D(3553,Y,0,0,yt,ut,At):e.texImage2D(3553,Y,ct,yt,ut,At);w.generateMipmaps=!1}else pt?(ht&&e.texStorage2D(3553,Et,ct,W.width,W.height),e.texSubImage2D(3553,0,0,0,yt,ut,W)):e.texImage2D(3553,0,ct,yt,ut,W);S(w,_t)&&L(rt),E.__version=w.version,w.onUpdate&&w.onUpdate(w)}function Ft(E,w,q){if(w.image.length!==6)return;xt(E,w),e.activeTexture(33984+q),e.bindTexture(34067,E.__webglTexture),n.pixelStorei(37440,w.flipY),n.pixelStorei(37441,w.premultiplyAlpha),n.pixelStorei(3317,w.unpackAlignment),n.pixelStorei(37443,0);let rt=w&&(w.isCompressedTexture||w.image[0].isCompressedTexture),gt=w.image[0]&&w.image[0].isDataTexture,W=[];for(let Y=0;Y<6;Y++)!rt&&!gt?W[Y]=p(w.image[Y],!1,!0,c):W[Y]=gt?w.image[Y].image:w.image[Y],W[Y]=vt(w,W[Y]);let _t=W[0],yt=b(_t)||a,ut=s.convert(w.format,w.encoding),ct=s.convert(w.type),At=A(w.internalFormat,ut,ct,w.encoding),P=a&&w.isVideoTexture!==!0,pt=E.__version===void 0,ht=H(w,_t,yt);dt(34067,w,yt);let Et;if(rt){P&&pt&&e.texStorage2D(34067,ht,At,_t.width,_t.height);for(let Y=0;Y<6;Y++){Et=W[Y].mipmaps;for(let Mt=0;Mt<Et.length;Mt++){let Dt=Et[Mt];w.format!==Re?ut!==null?P?e.compressedTexSubImage2D(34069+Y,Mt,0,0,Dt.width,Dt.height,ut,Dt.data):e.compressedTexImage2D(34069+Y,Mt,At,Dt.width,Dt.height,0,Dt.data):console.warn("THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .setTextureCube()"):P?e.texSubImage2D(34069+Y,Mt,0,0,Dt.width,Dt.height,ut,ct,Dt.data):e.texImage2D(34069+Y,Mt,At,Dt.width,Dt.height,0,ut,ct,Dt.data)}}}else{Et=w.mipmaps,P&&pt&&(Et.length>0&&ht++,e.texStorage2D(34067,ht,At,W[0].width,W[0].height));for(let Y=0;Y<6;Y++)if(gt){P?e.texSubImage2D(34069+Y,0,0,0,W[Y].width,W[Y].height,ut,ct,W[Y].data):e.texImage2D(34069+Y,0,At,W[Y].width,W[Y].height,0,ut,ct,W[Y].data);for(let Mt=0;Mt<Et.length;Mt++){let jt=Et[Mt].image[Y].image;P?e.texSubImage2D(34069+Y,Mt+1,0,0,jt.width,jt.height,ut,ct,jt.data):e.texImage2D(34069+Y,Mt+1,At,jt.width,jt.height,0,ut,ct,jt.data)}}else{P?e.texSubImage2D(34069+Y,0,0,0,ut,ct,W[Y]):e.texImage2D(34069+Y,0,At,ut,ct,W[Y]);for(let Mt=0;Mt<Et.length;Mt++){let Dt=Et[Mt];P?e.texSubImage2D(34069+Y,Mt+1,0,0,ut,ct,Dt.image[Y]):e.texImage2D(34069+Y,Mt+1,At,ut,ct,Dt.image[Y])}}}S(w,yt)&&L(34067),E.__version=w.version,w.onUpdate&&w.onUpdate(w)}function mt(E,w,q,rt,gt){let W=s.convert(q.format,q.encoding),_t=s.convert(q.type),yt=A(q.internalFormat,W,_t,q.encoding);i.get(w).__hasExternalTextures||(gt===32879||gt===35866?e.texImage3D(gt,0,yt,w.width,w.height,w.depth,0,W,_t,null):e.texImage2D(gt,0,yt,w.width,w.height,0,W,_t,null)),e.bindFramebuffer(36160,E),w.useRenderToTexture?d.framebufferTexture2DMultisampleEXT(36160,rt,gt,i.get(q).__webglTexture,0,it(w)):n.framebufferTexture2D(36160,rt,gt,i.get(q).__webglTexture,0),e.bindFramebuffer(36160,null)}function St(E,w,q){if(n.bindRenderbuffer(36161,E),w.depthBuffer&&!w.stencilBuffer){let rt=33189;if(q||w.useRenderToTexture){let gt=w.depthTexture;gt&&gt.isDepthTexture&&(gt.type===Ui?rt=36012:gt.type===Qa&&(rt=33190));let W=it(w);w.useRenderToTexture?d.renderbufferStorageMultisampleEXT(36161,W,rt,w.width,w.height):n.renderbufferStorageMultisample(36161,W,rt,w.width,w.height)}else n.renderbufferStorage(36161,rt,w.width,w.height);n.framebufferRenderbuffer(36160,36096,36161,E)}else if(w.depthBuffer&&w.stencilBuffer){let rt=it(w);q&&w.useRenderbuffer?n.renderbufferStorageMultisample(36161,rt,35056,w.width,w.height):w.useRenderToTexture?d.renderbufferStorageMultisampleEXT(36161,rt,35056,w.width,w.height):n.renderbufferStorage(36161,34041,w.width,w.height),n.framebufferRenderbuffer(36160,33306,36161,E)}else{let rt=w.isWebGLMultipleRenderTargets===!0?w.texture[0]:w.texture,gt=s.convert(rt.format,rt.encoding),W=s.convert(rt.type),_t=A(rt.internalFormat,gt,W,rt.encoding),yt=it(w);q&&w.useRenderbuffer?n.renderbufferStorageMultisample(36161,yt,_t,w.width,w.height):w.useRenderToTexture?d.renderbufferStorageMultisampleEXT(36161,yt,_t,w.width,w.height):n.renderbufferStorage(36161,_t,w.width,w.height)}n.bindRenderbuffer(36161,null)}function B(E,w){if(w&&w.isWebGLCubeRenderTarget)throw new Error("Depth Texture with cube render targets is not supported");if(e.bindFramebuffer(36160,E),!(w.depthTexture&&w.depthTexture.isDepthTexture))throw new Error("renderTarget.depthTexture must be an instance of THREE.DepthTexture");(!i.get(w.depthTexture).__webglTexture||w.depthTexture.image.width!==w.width||w.depthTexture.image.height!==w.height)&&(w.depthTexture.image.width=w.width,w.depthTexture.image.height=w.height,w.depthTexture.needsUpdate=!0),V(w.depthTexture,0);let rt=i.get(w.depthTexture).__webglTexture,gt=it(w);if(w.depthTexture.format===Oi)w.useRenderToTexture?d.framebufferTexture2DMultisampleEXT(36160,36096,3553,rt,0,gt):n.framebufferTexture2D(36160,36096,3553,rt,0);else if(w.depthTexture.format===Vr)w.useRenderToTexture?d.framebufferTexture2DMultisampleEXT(36160,33306,3553,rt,0,gt):n.framebufferTexture2D(36160,33306,3553,rt,0);else throw new Error("Unknown depthTexture format")}function st(E){let w=i.get(E),q=E.isWebGLCubeRenderTarget===!0;if(E.depthTexture&&!w.__autoAllocateDepthBuffer){if(q)throw new Error("target.depthTexture not supported in Cube render targets");B(w.__webglFramebuffer,E)}else if(q){w.__webglDepthbuffer=[];for(let rt=0;rt<6;rt++)e.bindFramebuffer(36160,w.__webglFramebuffer[rt]),w.__webglDepthbuffer[rt]=n.createRenderbuffer(),St(w.__webglDepthbuffer[rt],E,!1)}else e.bindFramebuffer(36160,w.__webglFramebuffer),w.__webglDepthbuffer=n.createRenderbuffer(),St(w.__webglDepthbuffer,E,!1);e.bindFramebuffer(36160,null)}function nt(E,w,q){let rt=i.get(E);w!==void 0&&mt(rt.__webglFramebuffer,E,E.texture,36064,3553),q!==void 0&&st(E)}function C(E){let w=E.texture,q=i.get(E),rt=i.get(w);E.addEventListener("dispose",y),E.isWebGLMultipleRenderTargets!==!0&&(rt.__webglTexture===void 0&&(rt.__webglTexture=n.createTexture()),rt.__version=w.version,o.memory.textures++);let gt=E.isWebGLCubeRenderTarget===!0,W=E.isWebGLMultipleRenderTargets===!0,_t=w.isDataTexture3D||w.isDataTexture2DArray,yt=b(E)||a;if(gt){q.__webglFramebuffer=[];for(let ut=0;ut<6;ut++)q.__webglFramebuffer[ut]=n.createFramebuffer()}else if(q.__webglFramebuffer=n.createFramebuffer(),W)if(r.drawBuffers){let ut=E.texture;for(let ct=0,At=ut.length;ct<At;ct++){let P=i.get(ut[ct]);P.__webglTexture===void 0&&(P.__webglTexture=n.createTexture(),o.memory.textures++)}}else console.warn("THREE.WebGLRenderer: WebGLMultipleRenderTargets can only be used with WebGL2 or WEBGL_draw_buffers extension.");else if(E.useRenderbuffer)if(a){q.__webglMultisampledFramebuffer=n.createFramebuffer(),q.__webglColorRenderbuffer=n.createRenderbuffer(),n.bindRenderbuffer(36161,q.__webglColorRenderbuffer);let ut=s.convert(w.format,w.encoding),ct=s.convert(w.type),At=A(w.internalFormat,ut,ct,w.encoding),P=it(E);n.renderbufferStorageMultisample(36161,P,At,E.width,E.height),e.bindFramebuffer(36160,q.__webglMultisampledFramebuffer),n.framebufferRenderbuffer(36160,36064,36161,q.__webglColorRenderbuffer),n.bindRenderbuffer(36161,null),E.depthBuffer&&(q.__webglDepthRenderbuffer=n.createRenderbuffer(),St(q.__webglDepthRenderbuffer,E,!0)),e.bindFramebuffer(36160,null)}else console.warn("THREE.WebGLRenderer: WebGLMultisampleRenderTarget can only be used with WebGL2.");if(gt){e.bindTexture(34067,rt.__webglTexture),dt(34067,w,yt);for(let ut=0;ut<6;ut++)mt(q.__webglFramebuffer[ut],E,w,36064,34069+ut);S(w,yt)&&L(34067),e.unbindTexture()}else if(W){let ut=E.texture;for(let ct=0,At=ut.length;ct<At;ct++){let P=ut[ct],pt=i.get(P);e.bindTexture(3553,pt.__webglTexture),dt(3553,P,yt),mt(q.__webglFramebuffer,E,P,36064+ct,3553),S(P,yt)&&L(3553)}e.unbindTexture()}else{let ut=3553;_t&&(a?ut=w.isDataTexture3D?32879:35866:console.warn("THREE.DataTexture3D and THREE.DataTexture2DArray only supported with WebGL2.")),e.bindTexture(ut,rt.__webglTexture),dt(ut,w,yt),mt(q.__webglFramebuffer,E,w,36064,ut),S(w,yt)&&L(ut),e.unbindTexture()}E.depthBuffer&&st(E)}function j(E){let w=b(E)||a,q=E.isWebGLMultipleRenderTargets===!0?E.texture:[E.texture];for(let rt=0,gt=q.length;rt<gt;rt++){let W=q[rt];if(S(W,w)){let _t=E.isWebGLCubeRenderTarget?34067:3553,yt=i.get(W).__webglTexture;e.bindTexture(_t,yt),L(_t),e.unbindTexture()}}}function J(E){if(E.useRenderbuffer)if(a){let w=E.width,q=E.height,rt=16384,gt=[36064],W=E.stencilBuffer?33306:36096;E.depthBuffer&&gt.push(W),E.ignoreDepthForMultisampleCopy||(E.depthBuffer&&(rt|=256),E.stencilBuffer&&(rt|=1024));let _t=i.get(E);e.bindFramebuffer(36008,_t.__webglMultisampledFramebuffer),e.bindFramebuffer(36009,_t.__webglFramebuffer),E.ignoreDepthForMultisampleCopy&&(n.invalidateFramebuffer(36008,[W]),n.invalidateFramebuffer(36009,[W])),n.blitFramebuffer(0,0,w,q,0,0,w,q,rt,9728),n.invalidateFramebuffer(36008,gt),e.bindFramebuffer(36008,null),e.bindFramebuffer(36009,_t.__webglMultisampledFramebuffer)}else console.warn("THREE.WebGLRenderer: WebGLMultisampleRenderTarget can only be used with WebGL2.")}function it(E){return a&&(E.useRenderbuffer||E.useRenderToTexture)?Math.min(h,E.samples):0}function et(E){let w=o.render.frame;g.get(E)!==w&&(g.set(E,w),E.update())}function vt(E,w){let q=E.encoding,rt=E.format,gt=E.type;return E.isCompressedTexture===!0||E.isVideoTexture===!0||E.format===Hu||q!==ri&&(q===$t?a===!1?t.has("EXT_sRGB")===!0&&rt===Re?(E.format=Hu,E.minFilter=be,E.generateMipmaps=!1):w=Nn.sRGBToLinear(w):(rt!==Re||gt!==ei)&&console.warn("THREE.WebGLTextures: sRGB encoded textures have to use RGBAFormat and UnsignedByteType."):console.error("THREE.WebGLTextures: Unsupported texture encoding:",q)),w}let bt=!1,It=!1;function Zt(E,w){E&&E.isWebGLRenderTarget&&(bt===!1&&(console.warn("THREE.WebGLTextures.safeSetTexture2D: don't use render targets as textures. Use their .texture property instead."),bt=!0),E=E.texture),V(E,w)}function qt(E,w){E&&E.isWebGLCubeRenderTarget&&(It===!1&&(console.warn("THREE.WebGLTextures.safeSetTextureCube: don't use cube render targets as textures. Use their .texture property instead."),It=!0),E=E.texture),G(E,w)}this.allocateTextureUnit=N,this.resetTextureUnits=z,this.setTexture2D=V,this.setTexture2DArray=Q,this.setTexture3D=at,this.setTextureCube=G,this.rebindTextures=nt,this.setupRenderTarget=C,this.updateRenderTargetMipmap=j,this.updateMultisampleRenderTarget=J,this.setupDepthRenderbuffer=st,this.setupFrameBufferTexture=mt,this.safeSetTexture2D=Zt,this.safeSetTextureCube=qt}function LE(n,t,e){let i=e.isWebGL2;function r(s,o=null){let a;if(s===ei)return 5121;if(s===zw)return 32819;if(s===Uw)return 32820;if(s===Iw)return 5120;if(s===Nw)return 5122;if(s===no)return 5123;if(s===Fw)return 5124;if(s===Qa)return 5125;if(s===Ui)return 5126;if(s===Ur)return i?5131:(a=t.get("OES_texture_half_float"),a!==null?a.HALF_FLOAT_OES:null);if(s===Bw)return 6406;if(s===Re)return 6408;if(s===Ow)return 6409;if(s===kw)return 6410;if(s===Oi)return 6402;if(s===Vr)return 34041;if(s===Hw)return 6403;if(s===Hu)return a=t.get("EXT_sRGB"),a!==null?a.SRGB_ALPHA_EXT:null;if(s===Vw)return 36244;if(s===Gw)return 33319;if(s===Ww)return 33320;if(s===qw)return 36249;if(s===Kc||s===Qc||s===jc||s===tu)if(o===$t)if(a=t.get("WEBGL_compressed_texture_s3tc_srgb"),a!==null){if(s===Kc)return a.COMPRESSED_SRGB_S3TC_DXT1_EXT;if(s===Qc)return a.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT;if(s===jc)return a.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT;if(s===tu)return a.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT}else return null;else if(a=t.get("WEBGL_compressed_texture_s3tc"),a!==null){if(s===Kc)return a.COMPRESSED_RGB_S3TC_DXT1_EXT;if(s===Qc)return a.COMPRESSED_RGBA_S3TC_DXT1_EXT;if(s===jc)return a.COMPRESSED_RGBA_S3TC_DXT3_EXT;if(s===tu)return a.COMPRESSED_RGBA_S3TC_DXT5_EXT}else return null;if(s===Fm||s===zm||s===Um||s===Bm)if(a=t.get("WEBGL_compressed_texture_pvrtc"),a!==null){if(s===Fm)return a.COMPRESSED_RGB_PVRTC_4BPPV1_IMG;if(s===zm)return a.COMPRESSED_RGB_PVRTC_2BPPV1_IMG;if(s===Um)return a.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG;if(s===Bm)return a.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG}else return null;if(s===Xw)return a=t.get("WEBGL_compressed_texture_etc1"),a!==null?a.COMPRESSED_RGB_ETC1_WEBGL:null;if(s===Om||s===km)if(a=t.get("WEBGL_compressed_texture_etc"),a!==null){if(s===Om)return o===$t?a.COMPRESSED_SRGB8_ETC2:a.COMPRESSED_RGB8_ETC2;if(s===km)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:a.COMPRESSED_RGBA8_ETC2_EAC}else return null;if(s===Hm||s===Vm||s===Gm||s===Wm||s===qm||s===Xm||s===Ym||s===Zm||s===Jm||s===$m||s===Km||s===Qm||s===jm||s===tg)if(a=t.get("WEBGL_compressed_texture_astc"),a!==null){if(s===Hm)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR:a.COMPRESSED_RGBA_ASTC_4x4_KHR;if(s===Vm)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR:a.COMPRESSED_RGBA_ASTC_5x4_KHR;if(s===Gm)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR:a.COMPRESSED_RGBA_ASTC_5x5_KHR;if(s===Wm)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR:a.COMPRESSED_RGBA_ASTC_6x5_KHR;if(s===qm)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR:a.COMPRESSED_RGBA_ASTC_6x6_KHR;if(s===Xm)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR:a.COMPRESSED_RGBA_ASTC_8x5_KHR;if(s===Ym)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR:a.COMPRESSED_RGBA_ASTC_8x6_KHR;if(s===Zm)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR:a.COMPRESSED_RGBA_ASTC_8x8_KHR;if(s===Jm)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR:a.COMPRESSED_RGBA_ASTC_10x5_KHR;if(s===$m)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR:a.COMPRESSED_RGBA_ASTC_10x6_KHR;if(s===Km)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR:a.COMPRESSED_RGBA_ASTC_10x8_KHR;if(s===Qm)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR:a.COMPRESSED_RGBA_ASTC_10x10_KHR;if(s===jm)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR:a.COMPRESSED_RGBA_ASTC_12x10_KHR;if(s===tg)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR:a.COMPRESSED_RGBA_ASTC_12x12_KHR}else return null;if(s===eg)if(a=t.get("EXT_texture_compression_bptc"),a!==null){if(s===eg)return o===$t?a.COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT:a.COMPRESSED_RGBA_BPTC_UNORM_EXT}else return null;if(s===Br)return i?34042:(a=t.get("WEBGL_depth_texture"),a!==null?a.UNSIGNED_INT_24_8_WEBGL:null)}return{convert:r}}var hl=class extends Se{constructor(t=[]){super(),this.cameras=t}};hl.prototype.isArrayCamera=!0;var Bi=class extends kt{constructor(){super(),this.type="Group"}};Bi.prototype.isGroup=!0;var PE={type:"move"},Qs=class{constructor(){this._targetRay=null,this._grip=null,this._hand=null}getHandSpace(){return this._hand===null&&(this._hand=new Bi,this._hand.matrixAutoUpdate=!1,this._hand.visible=!1,this._hand.joints={},this._hand.inputState={pinching:!1}),this._hand}getTargetRaySpace(){return this._targetRay===null&&(this._targetRay=new Bi,this._targetRay.matrixAutoUpdate=!1,this._targetRay.visible=!1,this._targetRay.hasLinearVelocity=!1,this._targetRay.linearVelocity=new T,this._targetRay.hasAngularVelocity=!1,this._targetRay.angularVelocity=new T),this._targetRay}getGripSpace(){return this._grip===null&&(this._grip=new Bi,this._grip.matrixAutoUpdate=!1,this._grip.visible=!1,this._grip.hasLinearVelocity=!1,this._grip.linearVelocity=new T,this._grip.hasAngularVelocity=!1,this._grip.angularVelocity=new T),this._grip}dispatchEvent(t){return this._targetRay!==null&&this._targetRay.dispatchEvent(t),this._grip!==null&&this._grip.dispatchEvent(t),this._hand!==null&&this._hand.dispatchEvent(t),this}disconnect(t){return this.dispatchEvent({type:"disconnected",data:t}),this._targetRay!==null&&(this._targetRay.visible=!1),this._grip!==null&&(this._grip.visible=!1),this._hand!==null&&(this._hand.visible=!1),this}update(t,e,i){let r=null,s=null,o=null,a=this._targetRay,l=this._grip,c=this._hand;if(t&&e.session.visibilityState!=="visible-blurred")if(a!==null&&(r=e.getPose(t.targetRaySpace,i),r!==null&&(a.matrix.fromArray(r.transform.matrix),a.matrix.decompose(a.position,a.rotation,a.scale),r.linearVelocity?(a.hasLinearVelocity=!0,a.linearVelocity.copy(r.linearVelocity)):a.hasLinearVelocity=!1,r.angularVelocity?(a.hasAngularVelocity=!0,a.angularVelocity.copy(r.angularVelocity)):a.hasAngularVelocity=!1,this.dispatchEvent(PE))),c&&t.hand){o=!0;for(let x of t.hand.values()){let v=e.getJointPose(x,i);if(c.joints[x.jointName]===void 0){let p=new Bi;p.matrixAutoUpdate=!1,p.visible=!1,c.joints[x.jointName]=p,c.add(p)}let m=c.joints[x.jointName];v!==null&&(m.matrix.fromArray(v.transform.matrix),m.matrix.decompose(m.position,m.rotation,m.scale),m.jointRadius=v.radius),m.visible=v!==null}let u=c.joints["index-finger-tip"],h=c.joints["thumb-tip"],f=u.position.distanceTo(h.position),d=.02,g=.005;c.inputState.pinching&&f>d+g?(c.inputState.pinching=!1,this.dispatchEvent({type:"pinchend",handedness:t.handedness,target:this})):!c.inputState.pinching&&f<=d-g&&(c.inputState.pinching=!0,this.dispatchEvent({type:"pinchstart",handedness:t.handedness,target:this}))}else l!==null&&t.gripSpace&&(s=e.getPose(t.gripSpace,i),s!==null&&(l.matrix.fromArray(s.transform.matrix),l.matrix.decompose(l.position,l.rotation,l.scale),s.linearVelocity?(l.hasLinearVelocity=!0,l.linearVelocity.copy(s.linearVelocity)):l.hasLinearVelocity=!1,s.angularVelocity?(l.hasAngularVelocity=!0,l.angularVelocity.copy(s.angularVelocity)):l.hasAngularVelocity=!1));return a!==null&&(a.visible=r!==null),l!==null&&(l.visible=s!==null),c!==null&&(c.visible=o!==null),this}},uo=class extends ae{constructor(t,e,i,r,s,o,a,l,c,u){if(u=u!==void 0?u:Oi,u!==Oi&&u!==Vr)throw new Error("DepthTexture format must be either THREE.DepthFormat or THREE.DepthStencilFormat");i===void 0&&u===Oi&&(i=no),i===void 0&&u===Vr&&(i=Br),super(null,r,s,o,a,l,u,i,c),this.image={width:t,height:e},this.magFilter=a!==void 0?a:fe,this.minFilter=l!==void 0?l:fe,this.flipY=!1,this.generateMipmaps=!1}};uo.prototype.isDepthTexture=!0;var Zu=class extends In{constructor(t,e){super();let i=this,r=null,s=1,o=null,a="local-floor",l=t.extensions.has("WEBGL_multisampled_render_to_texture"),c=null,u=null,h=null,f=null,d=!1,g=null,x=e.getContextAttributes(),v=null,m=null,p=[],b=new Map,_=new Se;_.layers.enable(1),_.viewport=new Wt;let S=new Se;S.layers.enable(2),S.viewport=new Wt;let L=[_,S],A=new hl;A.layers.enable(1),A.layers.enable(2);let H=null,tt=null;this.cameraAutoUpdate=!0,this.enabled=!1,this.isPresenting=!1,this.getController=function(G){let $=p[G];return $===void 0&&($=new Qs,p[G]=$),$.getTargetRaySpace()},this.getControllerGrip=function(G){let $=p[G];return $===void 0&&($=new Qs,p[G]=$),$.getGripSpace()},this.getHand=function(G){let $=p[G];return $===void 0&&($=new Qs,p[G]=$),$.getHandSpace()};function X(G){let $=b.get(G.inputSource);$&&$.dispatchEvent({type:G.type,data:G.inputSource})}function y(){b.forEach(function(G,$){G.disconnect($)}),b.clear(),H=null,tt=null,t.setRenderTarget(v),f=null,h=null,u=null,r=null,m=null,at.stop(),i.isPresenting=!1,i.dispatchEvent({type:"sessionend"})}this.setFramebufferScaleFactor=function(G){s=G,i.isPresenting===!0&&console.warn("THREE.WebXRManager: Cannot change framebuffer scale while presenting.")},this.setReferenceSpaceType=function(G){a=G,i.isPresenting===!0&&console.warn("THREE.WebXRManager: Cannot change reference space type while presenting.")},this.getReferenceSpace=function(){return o},this.getBaseLayer=function(){return h!==null?h:f},this.getBinding=function(){return u},this.getFrame=function(){return g},this.getSession=function(){return r},this.setSession=function(G){return hf(this,null,function*(){if(r=G,r!==null){if(v=t.getRenderTarget(),r.addEventListener("select",X),r.addEventListener("selectstart",X),r.addEventListener("selectend",X),r.addEventListener("squeeze",X),r.addEventListener("squeezestart",X),r.addEventListener("squeezeend",X),r.addEventListener("end",y),r.addEventListener("inputsourceschange",R),x.xrCompatible!==!0&&(yield e.makeXRCompatible()),r.renderState.layers===void 0||t.capabilities.isWebGL2===!1){let $={antialias:r.renderState.layers===void 0?x.antialias:!0,alpha:x.alpha,depth:x.depth,stencil:x.stencil,framebufferScaleFactor:s};f=new XRWebGLLayer(r,e,$),r.updateRenderState({baseLayer:f}),m=new Ne(f.framebufferWidth,f.framebufferHeight,{format:Re,type:ei,encoding:t.outputEncoding})}else{d=x.antialias;let $=null,lt=null,dt=null;x.depth&&(dt=x.stencil?35056:33190,$=x.stencil?Vr:Oi,lt=x.stencil?Br:no);let xt={colorFormat:t.outputEncoding===$t?35907:32856,depthFormat:dt,scaleFactor:s};u=new XRWebGLBinding(r,e),h=u.createProjectionLayer(xt),r.updateRenderState({layers:[h]}),d?m=new so(h.textureWidth,h.textureHeight,{format:Re,type:ei,depthTexture:new uo(h.textureWidth,h.textureHeight,lt,void 0,void 0,void 0,void 0,void 0,void 0,$),stencilBuffer:x.stencil,ignoreDepth:h.ignoreDepthValues,useRenderToTexture:l,encoding:t.outputEncoding}):m=new Ne(h.textureWidth,h.textureHeight,{format:Re,type:ei,depthTexture:new uo(h.textureWidth,h.textureHeight,lt,void 0,void 0,void 0,void 0,void 0,void 0,$),stencilBuffer:x.stencil,ignoreDepth:h.ignoreDepthValues,encoding:t.outputEncoding})}m.isXRRenderTarget=!0,this.setFoveation(1),o=yield r.requestReferenceSpace(a),at.setContext(r),at.start(),i.isPresenting=!0,i.dispatchEvent({type:"sessionstart"})}})};function R(G){let $=r.inputSources;for(let lt=0;lt<p.length;lt++)b.set($[lt],p[lt]);for(let lt=0;lt<G.removed.length;lt++){let dt=G.removed[lt],xt=b.get(dt);xt&&(xt.dispatchEvent({type:"disconnected",data:dt}),b.delete(dt))}for(let lt=0;lt<G.added.length;lt++){let dt=G.added[lt],xt=b.get(dt);xt&&xt.dispatchEvent({type:"connected",data:dt})}}let D=new T,F=new T;function z(G,$,lt){D.setFromMatrixPosition($.matrixWorld),F.setFromMatrixPosition(lt.matrixWorld);let dt=D.distanceTo(F),xt=$.projectionMatrix.elements,k=lt.projectionMatrix.elements,Ft=xt[14]/(xt[10]-1),mt=xt[14]/(xt[10]+1),St=(xt[9]+1)/xt[5],B=(xt[9]-1)/xt[5],st=(xt[8]-1)/xt[0],nt=(k[8]+1)/k[0],C=Ft*st,j=Ft*nt,J=dt/(-st+nt),it=J*-st;$.matrixWorld.decompose(G.position,G.quaternion,G.scale),G.translateX(it),G.translateZ(J),G.matrixWorld.compose(G.position,G.quaternion,G.scale),G.matrixWorldInverse.copy(G.matrixWorld).invert();let et=Ft+J,vt=mt+J,bt=C-it,It=j+(dt-it),Zt=St*mt/vt*et,qt=B*mt/vt*et;G.projectionMatrix.makePerspective(bt,It,Zt,qt,et,vt)}function N(G,$){$===null?G.matrixWorld.copy(G.matrix):G.matrixWorld.multiplyMatrices($.matrixWorld,G.matrix),G.matrixWorldInverse.copy(G.matrixWorld).invert()}this.updateCamera=function(G){if(r===null)return;A.near=S.near=_.near=G.near,A.far=S.far=_.far=G.far,(H!==A.near||tt!==A.far)&&(r.updateRenderState({depthNear:A.near,depthFar:A.far}),H=A.near,tt=A.far);let $=G.parent,lt=A.cameras;N(A,$);for(let xt=0;xt<lt.length;xt++)N(lt[xt],$);A.matrixWorld.decompose(A.position,A.quaternion,A.scale),G.position.copy(A.position),G.quaternion.copy(A.quaternion),G.scale.copy(A.scale),G.matrix.copy(A.matrix),G.matrixWorld.copy(A.matrixWorld);let dt=G.children;for(let xt=0,k=dt.length;xt<k;xt++)dt[xt].updateMatrixWorld(!0);lt.length===2?z(A,_,S):A.projectionMatrix.copy(_.projectionMatrix)},this.getCamera=function(){return A},this.getFoveation=function(){if(h!==null)return h.fixedFoveation;if(f!==null)return f.fixedFoveation},this.setFoveation=function(G){h!==null&&(h.fixedFoveation=G),f!==null&&f.fixedFoveation!==void 0&&(f.fixedFoveation=G)};let V=null;function Q(G,$){if(c=$.getViewerPose(o),g=$,c!==null){let dt=c.views;f!==null&&(t.setRenderTargetFramebuffer(m,f.framebuffer),t.setRenderTarget(m));let xt=!1;dt.length!==A.cameras.length&&(A.cameras.length=0,xt=!0);for(let k=0;k<dt.length;k++){let Ft=dt[k],mt=null;if(f!==null)mt=f.getViewport(Ft);else{let B=u.getViewSubImage(h,Ft);mt=B.viewport,k===0&&(t.setRenderTargetTextures(m,B.colorTexture,h.ignoreDepthValues?void 0:B.depthStencilTexture),t.setRenderTarget(m))}let St=L[k];St.matrix.fromArray(Ft.transform.matrix),St.projectionMatrix.fromArray(Ft.projectionMatrix),St.viewport.set(mt.x,mt.y,mt.width,mt.height),k===0&&A.matrix.copy(St.matrix),xt===!0&&A.cameras.push(St)}}let lt=r.inputSources;for(let dt=0;dt<p.length;dt++){let xt=p[dt],k=lt[dt];xt.update(k,$,o)}V&&V(G,$),g=null}let at=new g0;at.setAnimationLoop(Q),this.setAnimationLoop=function(G){V=G},this.dispose=function(){}}};function DE(n){function t(m,p){m.fogColor.value.copy(p.color),p.isFog?(m.fogNear.value=p.near,m.fogFar.value=p.far):p.isFogExp2&&(m.fogDensity.value=p.density)}function e(m,p,b,_,S){p.isMeshBasicMaterial?i(m,p):p.isMeshLambertMaterial?(i(m,p),l(m,p)):p.isMeshToonMaterial?(i(m,p),u(m,p)):p.isMeshPhongMaterial?(i(m,p),c(m,p)):p.isMeshStandardMaterial?(i(m,p),p.isMeshPhysicalMaterial?f(m,p,S):h(m,p)):p.isMeshMatcapMaterial?(i(m,p),d(m,p)):p.isMeshDepthMaterial?(i(m,p),g(m,p)):p.isMeshDistanceMaterial?(i(m,p),x(m,p)):p.isMeshNormalMaterial?(i(m,p),v(m,p)):p.isLineBasicMaterial?(r(m,p),p.isLineDashedMaterial&&s(m,p)):p.isPointsMaterial?o(m,p,b,_):p.isSpriteMaterial?a(m,p):p.isShadowMaterial?(m.color.value.copy(p.color),m.opacity.value=p.opacity):p.isShaderMaterial&&(p.uniformsNeedUpdate=!1)}function i(m,p){m.opacity.value=p.opacity,p.color&&m.diffuse.value.copy(p.color),p.emissive&&m.emissive.value.copy(p.emissive).multiplyScalar(p.emissiveIntensity),p.map&&(m.map.value=p.map),p.alphaMap&&(m.alphaMap.value=p.alphaMap),p.specularMap&&(m.specularMap.value=p.specularMap),p.alphaTest>0&&(m.alphaTest.value=p.alphaTest);let b=n.get(p).envMap;b&&(m.envMap.value=b,m.flipEnvMap.value=b.isCubeTexture&&b.isRenderTargetTexture===!1?-1:1,m.reflectivity.value=p.reflectivity,m.ior.value=p.ior,m.refractionRatio.value=p.refractionRatio),p.lightMap&&(m.lightMap.value=p.lightMap,m.lightMapIntensity.value=p.lightMapIntensity),p.aoMap&&(m.aoMap.value=p.aoMap,m.aoMapIntensity.value=p.aoMapIntensity);let _;p.map?_=p.map:p.specularMap?_=p.specularMap:p.displacementMap?_=p.displacementMap:p.normalMap?_=p.normalMap:p.bumpMap?_=p.bumpMap:p.roughnessMap?_=p.roughnessMap:p.metalnessMap?_=p.metalnessMap:p.alphaMap?_=p.alphaMap:p.emissiveMap?_=p.emissiveMap:p.clearcoatMap?_=p.clearcoatMap:p.clearcoatNormalMap?_=p.clearcoatNormalMap:p.clearcoatRoughnessMap?_=p.clearcoatRoughnessMap:p.specularIntensityMap?_=p.specularIntensityMap:p.specularColorMap?_=p.specularColorMap:p.transmissionMap?_=p.transmissionMap:p.thicknessMap?_=p.thicknessMap:p.sheenColorMap?_=p.sheenColorMap:p.sheenRoughnessMap&&(_=p.sheenRoughnessMap),_!==void 0&&(_.isWebGLRenderTarget&&(_=_.texture),_.matrixAutoUpdate===!0&&_.updateMatrix(),m.uvTransform.value.copy(_.matrix));let S;p.aoMap?S=p.aoMap:p.lightMap&&(S=p.lightMap),S!==void 0&&(S.isWebGLRenderTarget&&(S=S.texture),S.matrixAutoUpdate===!0&&S.updateMatrix(),m.uv2Transform.value.copy(S.matrix))}function r(m,p){m.diffuse.value.copy(p.color),m.opacity.value=p.opacity}function s(m,p){m.dashSize.value=p.dashSize,m.totalSize.value=p.dashSize+p.gapSize,m.scale.value=p.scale}function o(m,p,b,_){m.diffuse.value.copy(p.color),m.opacity.value=p.opacity,m.size.value=p.size*b,m.scale.value=_*.5,p.map&&(m.map.value=p.map),p.alphaMap&&(m.alphaMap.value=p.alphaMap),p.alphaTest>0&&(m.alphaTest.value=p.alphaTest);let S;p.map?S=p.map:p.alphaMap&&(S=p.alphaMap),S!==void 0&&(S.matrixAutoUpdate===!0&&S.updateMatrix(),m.uvTransform.value.copy(S.matrix))}function a(m,p){m.diffuse.value.copy(p.color),m.opacity.value=p.opacity,m.rotation.value=p.rotation,p.map&&(m.map.value=p.map),p.alphaMap&&(m.alphaMap.value=p.alphaMap),p.alphaTest>0&&(m.alphaTest.value=p.alphaTest);let b;p.map?b=p.map:p.alphaMap&&(b=p.alphaMap),b!==void 0&&(b.matrixAutoUpdate===!0&&b.updateMatrix(),m.uvTransform.value.copy(b.matrix))}function l(m,p){p.emissiveMap&&(m.emissiveMap.value=p.emissiveMap)}function c(m,p){m.specular.value.copy(p.specular),m.shininess.value=Math.max(p.shininess,1e-4),p.emissiveMap&&(m.emissiveMap.value=p.emissiveMap),p.bumpMap&&(m.bumpMap.value=p.bumpMap,m.bumpScale.value=p.bumpScale,p.side===he&&(m.bumpScale.value*=-1)),p.normalMap&&(m.normalMap.value=p.normalMap,m.normalScale.value.copy(p.normalScale),p.side===he&&m.normalScale.value.negate()),p.displacementMap&&(m.displacementMap.value=p.displacementMap,m.displacementScale.value=p.displacementScale,m.displacementBias.value=p.displacementBias)}function u(m,p){p.gradientMap&&(m.gradientMap.value=p.gradientMap),p.emissiveMap&&(m.emissiveMap.value=p.emissiveMap),p.bumpMap&&(m.bumpMap.value=p.bumpMap,m.bumpScale.value=p.bumpScale,p.side===he&&(m.bumpScale.value*=-1)),p.normalMap&&(m.normalMap.value=p.normalMap,m.normalScale.value.copy(p.normalScale),p.side===he&&m.normalScale.value.negate()),p.displacementMap&&(m.displacementMap.value=p.displacementMap,m.displacementScale.value=p.displacementScale,m.displacementBias.value=p.displacementBias)}function h(m,p){m.roughness.value=p.roughness,m.metalness.value=p.metalness,p.roughnessMap&&(m.roughnessMap.value=p.roughnessMap),p.metalnessMap&&(m.metalnessMap.value=p.metalnessMap),p.emissiveMap&&(m.emissiveMap.value=p.emissiveMap),p.bumpMap&&(m.bumpMap.value=p.bumpMap,m.bumpScale.value=p.bumpScale,p.side===he&&(m.bumpScale.value*=-1)),p.normalMap&&(m.normalMap.value=p.normalMap,m.normalScale.value.copy(p.normalScale),p.side===he&&m.normalScale.value.negate()),p.displacementMap&&(m.displacementMap.value=p.displacementMap,m.displacementScale.value=p.displacementScale,m.displacementBias.value=p.displacementBias),n.get(p).envMap&&(m.envMapIntensity.value=p.envMapIntensity)}function f(m,p,b){h(m,p),m.ior.value=p.ior,p.sheen>0&&(m.sheenColor.value.copy(p.sheenColor).multiplyScalar(p.sheen),m.sheenRoughness.value=p.sheenRoughness,p.sheenColorMap&&(m.sheenColorMap.value=p.sheenColorMap),p.sheenRoughnessMap&&(m.sheenRoughnessMap.value=p.sheenRoughnessMap)),p.clearcoat>0&&(m.clearcoat.value=p.clearcoat,m.clearcoatRoughness.value=p.clearcoatRoughness,p.clearcoatMap&&(m.clearcoatMap.value=p.clearcoatMap),p.clearcoatRoughnessMap&&(m.clearcoatRoughnessMap.value=p.clearcoatRoughnessMap),p.clearcoatNormalMap&&(m.clearcoatNormalScale.value.copy(p.clearcoatNormalScale),m.clearcoatNormalMap.value=p.clearcoatNormalMap,p.side===he&&m.clearcoatNormalScale.value.negate())),p.transmission>0&&(m.transmission.value=p.transmission,m.transmissionSamplerMap.value=b.texture,m.transmissionSamplerSize.value.set(b.width,b.height),p.transmissionMap&&(m.transmissionMap.value=p.transmissionMap),m.thickness.value=p.thickness,p.thicknessMap&&(m.thicknessMap.value=p.thicknessMap),m.attenuationDistance.value=p.attenuationDistance,m.attenuationColor.value.copy(p.attenuationColor)),m.specularIntensity.value=p.specularIntensity,m.specularColor.value.copy(p.specularColor),p.specularIntensityMap&&(m.specularIntensityMap.value=p.specularIntensityMap),p.specularColorMap&&(m.specularColorMap.value=p.specularColorMap)}function d(m,p){p.matcap&&(m.matcap.value=p.matcap),p.bumpMap&&(m.bumpMap.value=p.bumpMap,m.bumpScale.value=p.bumpScale,p.side===he&&(m.bumpScale.value*=-1)),p.normalMap&&(m.normalMap.value=p.normalMap,m.normalScale.value.copy(p.normalScale),p.side===he&&m.normalScale.value.negate()),p.displacementMap&&(m.displacementMap.value=p.displacementMap,m.displacementScale.value=p.displacementScale,m.displacementBias.value=p.displacementBias)}function g(m,p){p.displacementMap&&(m.displacementMap.value=p.displacementMap,m.displacementScale.value=p.displacementScale,m.displacementBias.value=p.displacementBias)}function x(m,p){p.displacementMap&&(m.displacementMap.value=p.displacementMap,m.displacementScale.value=p.displacementScale,m.displacementBias.value=p.displacementBias),m.referencePosition.value.copy(p.referencePosition),m.nearDistance.value=p.nearDistance,m.farDistance.value=p.farDistance}function v(m,p){p.bumpMap&&(m.bumpMap.value=p.bumpMap,m.bumpScale.value=p.bumpScale,p.side===he&&(m.bumpScale.value*=-1)),p.normalMap&&(m.normalMap.value=p.normalMap,m.normalScale.value.copy(p.normalScale),p.side===he&&m.normalScale.value.negate()),p.displacementMap&&(m.displacementMap.value=p.displacementMap,m.displacementScale.value=p.displacementScale,m.displacementBias.value=p.displacementBias)}return{refreshFogUniforms:t,refreshMaterialUniforms:e}}function IE(){let n=ro("canvas");return n.style.display="block",n}function Vt(n={}){let t=n.canvas!==void 0?n.canvas:IE(),e=n.context!==void 0?n.context:null,i=n.alpha!==void 0?n.alpha:!1,r=n.depth!==void 0?n.depth:!0,s=n.stencil!==void 0?n.stencil:!0,o=n.antialias!==void 0?n.antialias:!1,a=n.premultipliedAlpha!==void 0?n.premultipliedAlpha:!0,l=n.preserveDrawingBuffer!==void 0?n.preserveDrawingBuffer:!1,c=n.powerPreference!==void 0?n.powerPreference:"default",u=n.failIfMajorPerformanceCaveat!==void 0?n.failIfMajorPerformanceCaveat:!1,h=null,f=null,d=[],g=[];this.domElement=t,this.debug={checkShaderErrors:!0},this.autoClear=!0,this.autoClearColor=!0,this.autoClearDepth=!0,this.autoClearStencil=!0,this.sortObjects=!0,this.clippingPlanes=[],this.localClippingEnabled=!1,this.outputEncoding=ri,this.physicallyCorrectLights=!1,this.toneMapping=ti,this.toneMappingExposure=1;let x=this,v=!1,m=0,p=0,b=null,_=-1,S=null,L=new Wt,A=new Wt,H=null,tt=t.width,X=t.height,y=1,R=null,D=null,F=new Wt(0,0,tt,X),z=new Wt(0,0,tt,X),N=!1,V=new qr,Q=!1,at=!1,G=null,$=new wt,lt=new T,dt={background:null,fog:null,environment:null,overrideMaterial:null,isScene:!0};function xt(){return b===null?y:1}let k=e;function Ft(M,I){for(let O=0;O<M.length;O++){let U=M[O],Z=t.getContext(U,I);if(Z!==null)return Z}return null}try{let M={alpha:!0,depth:r,stencil:s,antialias:o,premultipliedAlpha:a,preserveDrawingBuffer:l,powerPreference:c,failIfMajorPerformanceCaveat:u};if("setAttribute"in t&&t.setAttribute("data-engine",`three.js r${$h}`),t.addEventListener("webglcontextlost",At,!1),t.addEventListener("webglcontextrestored",P,!1),k===null){let I=["webgl2","webgl","experimental-webgl"];if(x.isWebGL1Renderer===!0&&I.shift(),k=Ft(I,M),k===null)throw Ft(I)?new Error("Error creating WebGL context with your selected attributes."):new Error("Error creating WebGL context.")}k.getShaderPrecisionFormat===void 0&&(k.getShaderPrecisionFormat=function(){return{rangeMin:1,rangeMax:1,precision:1}})}catch(M){throw console.error("THREE.WebGLRenderer: "+M.message),M}let mt,St,B,st,nt,C,j,J,it,et,vt,bt,It,Zt,qt,E,w,q,rt,gt,W,_t,yt;function ut(){mt=new eS(k),St=new J1(k,mt,n),mt.init(St),_t=new LE(k,mt,St),B=new CE(k,mt,St),st=new rS(k),nt=new xE,C=new RE(k,mt,B,nt,St,_t,st),j=new K1(x),J=new tS(x),it=new vM(k,St),yt=new Y1(k,mt,it,St),et=new nS(k,it,st,yt),vt=new lS(k,et,it,st),rt=new aS(k,St,C),E=new $1(nt),bt=new gE(x,j,J,mt,St,yt,E),It=new DE(nt),Zt=new vE,qt=new EE(mt,St),q=new X1(x,j,B,vt,i,a),w=new T0(x,vt,St),gt=new Z1(k,mt,st,St),W=new iS(k,mt,st,St),st.programs=bt.programs,x.capabilities=St,x.extensions=mt,x.properties=nt,x.renderLists=Zt,x.shadowMap=w,x.state=B,x.info=st}ut();let ct=new Zu(x,k);this.xr=ct,this.getContext=function(){return k},this.getContextAttributes=function(){return k.getContextAttributes()},this.forceContextLoss=function(){let M=mt.get("WEBGL_lose_context");M&&M.loseContext()},this.forceContextRestore=function(){let M=mt.get("WEBGL_lose_context");M&&M.restoreContext()},this.getPixelRatio=function(){return y},this.setPixelRatio=function(M){M!==void 0&&(y=M,this.setSize(tt,X,!1))},this.getSize=function(M){return M.set(tt,X)},this.setSize=function(M,I,O){if(ct.isPresenting){console.warn("THREE.WebGLRenderer: Can't change size while VR device is presenting.");return}tt=M,X=I,t.width=Math.floor(M*y),t.height=Math.floor(I*y),O!==!1&&(t.style.width=M+"px",t.style.height=I+"px"),this.setViewport(0,0,M,I)},this.getDrawingBufferSize=function(M){return M.set(tt*y,X*y).floor()},this.setDrawingBufferSize=function(M,I,O){tt=M,X=I,y=O,t.width=Math.floor(M*O),t.height=Math.floor(I*O),this.setViewport(0,0,M,I)},this.getCurrentViewport=function(M){return M.copy(L)},this.getViewport=function(M){return M.copy(F)},this.setViewport=function(M,I,O,U){M.isVector4?F.set(M.x,M.y,M.z,M.w):F.set(M,I,O,U),B.viewport(L.copy(F).multiplyScalar(y).floor())},this.getScissor=function(M){return M.copy(z)},this.setScissor=function(M,I,O,U){M.isVector4?z.set(M.x,M.y,M.z,M.w):z.set(M,I,O,U),B.scissor(A.copy(z).multiplyScalar(y).floor())},this.getScissorTest=function(){return N},this.setScissorTest=function(M){B.setScissorTest(N=M)},this.setOpaqueSort=function(M){R=M},this.setTransparentSort=function(M){D=M},this.getClearColor=function(M){return M.copy(q.getClearColor())},this.setClearColor=function(){q.setClearColor.apply(q,arguments)},this.getClearAlpha=function(){return q.getClearAlpha()},this.setClearAlpha=function(){q.setClearAlpha.apply(q,arguments)},this.clear=function(M,I,O){let U=0;(M===void 0||M)&&(U|=16384),(I===void 0||I)&&(U|=256),(O===void 0||O)&&(U|=1024),k.clear(U)},this.clearColor=function(){this.clear(!0,!1,!1)},this.clearDepth=function(){this.clear(!1,!0,!1)},this.clearStencil=function(){this.clear(!1,!1,!0)},this.dispose=function(){t.removeEventListener("webglcontextlost",At,!1),t.removeEventListener("webglcontextrestored",P,!1),Zt.dispose(),qt.dispose(),nt.dispose(),j.dispose(),J.dispose(),vt.dispose(),yt.dispose(),bt.dispose(),ct.dispose(),ct.removeEventListener("sessionstart",Dt),ct.removeEventListener("sessionend",jt),G&&(G.dispose(),G=null),ze.stop()};function At(M){M.preventDefault(),console.log("THREE.WebGLRenderer: Context Lost."),v=!0}function P(){console.log("THREE.WebGLRenderer: Context Restored."),v=!1;let M=st.autoReset,I=w.enabled,O=w.autoUpdate,U=w.needsUpdate,Z=w.type;ut(),st.autoReset=M,w.enabled=I,w.autoUpdate=O,w.needsUpdate=U,w.type=Z}function pt(M){let I=M.target;I.removeEventListener("dispose",pt),ht(I)}function ht(M){Et(M),nt.remove(M)}function Et(M){let I=nt.get(M).programs;I!==void 0&&(I.forEach(function(O){bt.releaseProgram(O)}),M.isShaderMaterial&&bt.releaseShaderCache(M))}this.renderBufferDirect=function(M,I,O,U,Z,Tt){I===null&&(I=dt);let Ct=Z.isMesh&&Z.matrixWorld.determinant()<0,Lt=B0(M,I,O,U,Z);B.setMaterial(U,Ct);let Rt=O.index,Gt=O.attributes.position;if(Rt===null){if(Gt===void 0||Gt.count===0)return}else if(Rt.count===0)return;let zt=1;U.wireframe===!0&&(Rt=et.getWireframeAttribute(O),zt=2),yt.setup(Z,U,Lt,O,Rt);let Ut,ie=gt;Rt!==null&&(Ut=it.get(Rt),ie=W,ie.setIndex(Ut));let fi=Rt!==null?Rt.count:Gt.count,Zi=O.drawRange.start*zt,Ot=O.drawRange.count*zt,nn=Tt!==null?Tt.start*zt:0,le=Tt!==null?Tt.count*zt:1/0,rn=Math.max(Zi,nn),Io=Math.min(fi,Zi+Ot,nn+le)-1,sn=Math.max(0,Io-rn+1);if(sn!==0){if(Z.isMesh)U.wireframe===!0?(B.setLineWidth(U.wireframeLinewidth*xt()),ie.setMode(1)):ie.setMode(4);else if(Z.isLine){let vn=U.linewidth;vn===void 0&&(vn=1),B.setLineWidth(vn*xt()),Z.isLineSegments?ie.setMode(1):Z.isLineLoop?ie.setMode(2):ie.setMode(3)}else Z.isPoints?ie.setMode(0):Z.isSprite&&ie.setMode(4);if(Z.isInstancedMesh)ie.renderInstances(rn,sn,Z.count);else if(O.isInstancedBufferGeometry){let vn=Math.min(O.instanceCount,O._maxInstanceCount);ie.renderInstances(rn,sn,vn)}else ie.render(rn,sn)}},this.compile=function(M,I){f=qt.get(M),f.init(),g.push(f),M.traverseVisible(function(O){O.isLight&&O.layers.test(I.layers)&&(f.pushLight(O),O.castShadow&&f.pushShadow(O))}),f.setupLights(x.physicallyCorrectLights),M.traverse(function(O){let U=O.material;if(U)if(Array.isArray(U))for(let Z=0;Z<U.length;Z++){let Tt=U[Z];Ol(Tt,M,O)}else Ol(U,M,O)}),g.pop(),f=null};let Y=null;function Mt(M){Y&&Y(M)}function Dt(){ze.stop()}function jt(){ze.start()}let ze=new g0;ze.setAnimationLoop(Mt),typeof window!="undefined"&&ze.setContext(window),this.setAnimationLoop=function(M){Y=M,ct.setAnimationLoop(M),M===null?ze.stop():ze.start()},ct.addEventListener("sessionstart",Dt),ct.addEventListener("sessionend",jt),this.render=function(M,I){if(I!==void 0&&I.isCamera!==!0){console.error("THREE.WebGLRenderer.render: camera is not an instance of THREE.Camera.");return}if(v===!0)return;M.autoUpdate===!0&&M.updateMatrixWorld(),I.parent===null&&I.updateMatrixWorld(),ct.enabled===!0&&ct.isPresenting===!0&&(ct.cameraAutoUpdate===!0&&ct.updateCamera(I),I=ct.getCamera()),M.isScene===!0&&M.onBeforeRender(x,M,I,b),f=qt.get(M,g.length),f.init(),g.push(f),$.multiplyMatrices(I.projectionMatrix,I.matrixWorldInverse),V.setFromProjectionMatrix($),at=this.localClippingEnabled,Q=E.init(this.clippingPlanes,at,I),h=Zt.get(M,d.length),h.init(),d.push(h),ne(M,I,0,x.sortObjects),h.finish(),x.sortObjects===!0&&h.sort(R,D),Q===!0&&E.beginShadows();let O=f.state.shadowsArray;if(w.render(O,M,I),Q===!0&&E.endShadows(),this.info.autoReset===!0&&this.info.reset(),q.render(h,M),f.setupLights(x.physicallyCorrectLights),I.isArrayCamera){let U=I.cameras;for(let Z=0,Tt=U.length;Z<Tt;Z++){let Ct=U[Z];en(h,M,Ct,Ct.viewport)}}else en(h,M,I);b!==null&&(C.updateMultisampleRenderTarget(b),C.updateRenderTargetMipmap(b)),M.isScene===!0&&M.onAfterRender(x,M,I),B.buffers.depth.setTest(!0),B.buffers.depth.setMask(!0),B.buffers.color.setMask(!0),B.setPolygonOffset(!1),yt.resetDefaultState(),_=-1,S=null,g.pop(),g.length>0?f=g[g.length-1]:f=null,d.pop(),d.length>0?h=d[d.length-1]:h=null};function ne(M,I,O,U){if(M.visible===!1)return;if(M.layers.test(I.layers)){if(M.isGroup)O=M.renderOrder;else if(M.isLOD)M.autoUpdate===!0&&M.update(I);else if(M.isLight)f.pushLight(M),M.castShadow&&f.pushShadow(M);else if(M.isSprite){if(!M.frustumCulled||V.intersectsSprite(M)){U&&lt.setFromMatrixPosition(M.matrixWorld).applyMatrix4($);let Ct=vt.update(M),Lt=M.material;Lt.visible&&h.push(M,Ct,Lt,O,lt.z,null)}}else if((M.isMesh||M.isLine||M.isPoints)&&(M.isSkinnedMesh&&M.skeleton.frame!==st.render.frame&&(M.skeleton.update(),M.skeleton.frame=st.render.frame),!M.frustumCulled||V.intersectsObject(M))){U&&lt.setFromMatrixPosition(M.matrixWorld).applyMatrix4($);let Ct=vt.update(M),Lt=M.material;if(Array.isArray(Lt)){let Rt=Ct.groups;for(let Gt=0,zt=Rt.length;Gt<zt;Gt++){let Ut=Rt[Gt],ie=Lt[Ut.materialIndex];ie&&ie.visible&&h.push(M,Ct,ie,O,lt.z,Ut)}}else Lt.visible&&h.push(M,Ct,Lt,O,lt.z,null)}}let Tt=M.children;for(let Ct=0,Lt=Tt.length;Ct<Lt;Ct++)ne(Tt[Ct],I,O,U)}function en(M,I,O,U){let Z=M.opaque,Tt=M.transmissive,Ct=M.transparent;f.setupLightsView(O),Tt.length>0&&yn(Z,I,O),U&&B.viewport(L.copy(U)),Z.length>0&&Do(Z,I,O),Tt.length>0&&Do(Tt,I,O),Ct.length>0&&Do(Ct,I,O)}function yn(M,I,O){if(G===null){let Ct=o===!0&&St.isWebGL2===!0?so:Ne;G=new Ct(1024,1024,{generateMipmaps:!0,type:_t.convert(Ur)!==null?Ur:ei,minFilter:Ll,magFilter:fe,wrapS:Ve,wrapT:Ve,useRenderToTexture:mt.has("WEBGL_multisampled_render_to_texture")})}let U=x.getRenderTarget();x.setRenderTarget(G),x.clear();let Z=x.toneMapping;x.toneMapping=ti,Do(M,I,O),x.toneMapping=Z,C.updateMultisampleRenderTarget(G),C.updateRenderTargetMipmap(G),x.setRenderTarget(U)}function Do(M,I,O){let U=I.isScene===!0?I.overrideMaterial:null;for(let Z=0,Tt=M.length;Z<Tt;Z++){let Ct=M[Z],Lt=Ct.object,Rt=Ct.geometry,Gt=U===null?Ct.material:U,zt=Ct.group;Lt.layers.test(O.layers)&&U0(Lt,I,O,Rt,Gt,zt)}}function U0(M,I,O,U,Z,Tt){M.onBeforeRender(x,I,O,U,Z,Tt),M.modelViewMatrix.multiplyMatrices(O.matrixWorldInverse,M.matrixWorld),M.normalMatrix.getNormalMatrix(M.modelViewMatrix),Z.onBeforeRender(x,I,O,U,M,Tt),Z.transparent===!0&&Z.side===Hr?(Z.side=he,Z.needsUpdate=!0,x.renderBufferDirect(O,I,U,Z,M,Tt),Z.side=eo,Z.needsUpdate=!0,x.renderBufferDirect(O,I,U,Z,M,Tt),Z.side=Hr):x.renderBufferDirect(O,I,U,Z,M,Tt),M.onAfterRender(x,I,O,U,Z,Tt)}function Ol(M,I,O){I.isScene!==!0&&(I=dt);let U=nt.get(M),Z=f.state.lights,Tt=f.state.shadowsArray,Ct=Z.state.version,Lt=bt.getParameters(M,Z.state,Tt,I,O),Rt=bt.getProgramCacheKey(Lt),Gt=U.programs;U.environment=M.isMeshStandardMaterial?I.environment:null,U.fog=I.fog,U.envMap=(M.isMeshStandardMaterial?J:j).get(M.envMap||U.environment),Gt===void 0&&(M.addEventListener("dispose",pt),Gt=new Map,U.programs=Gt);let zt=Gt.get(Rt);if(zt!==void 0){if(U.currentProgram===zt&&U.lightsStateVersion===Ct)return of(M,Lt),zt}else Lt.uniforms=bt.getUniforms(M),M.onBuild(O,Lt,x),M.onBeforeCompile(Lt,x),zt=bt.acquireProgram(Lt,Rt),Gt.set(Rt,zt),U.uniforms=Lt.uniforms;let Ut=U.uniforms;(!M.isShaderMaterial&&!M.isRawShaderMaterial||M.clipping===!0)&&(Ut.clippingPlanes=E.uniform),of(M,Lt),U.needsLights=k0(M),U.lightsStateVersion=Ct,U.needsLights&&(Ut.ambientLightColor.value=Z.state.ambient,Ut.lightProbe.value=Z.state.probe,Ut.directionalLights.value=Z.state.directional,Ut.directionalLightShadows.value=Z.state.directionalShadow,Ut.spotLights.value=Z.state.spot,Ut.spotLightShadows.value=Z.state.spotShadow,Ut.rectAreaLights.value=Z.state.rectArea,Ut.ltc_1.value=Z.state.rectAreaLTC1,Ut.ltc_2.value=Z.state.rectAreaLTC2,Ut.pointLights.value=Z.state.point,Ut.pointLightShadows.value=Z.state.pointShadow,Ut.hemisphereLights.value=Z.state.hemi,Ut.directionalShadowMap.value=Z.state.directionalShadowMap,Ut.directionalShadowMatrix.value=Z.state.directionalShadowMatrix,Ut.spotShadowMap.value=Z.state.spotShadowMap,Ut.spotShadowMatrix.value=Z.state.spotShadowMatrix,Ut.pointShadowMap.value=Z.state.pointShadowMap,Ut.pointShadowMatrix.value=Z.state.pointShadowMatrix);let ie=zt.getUniforms(),fi=ii.seqWithValue(ie.seq,Ut);return U.currentProgram=zt,U.uniformsList=fi,zt}function of(M,I){let O=nt.get(M);O.outputEncoding=I.outputEncoding,O.instancing=I.instancing,O.skinning=I.skinning,O.morphTargets=I.morphTargets,O.morphNormals=I.morphNormals,O.morphTargetsCount=I.morphTargetsCount,O.numClippingPlanes=I.numClippingPlanes,O.numIntersection=I.numClipIntersection,O.vertexAlphas=I.vertexAlphas,O.vertexTangents=I.vertexTangents,O.toneMapping=I.toneMapping}function B0(M,I,O,U,Z){I.isScene!==!0&&(I=dt),C.resetTextureUnits();let Tt=I.fog,Ct=U.isMeshStandardMaterial?I.environment:null,Lt=b===null?x.outputEncoding:b.isXRRenderTarget===!0?b.texture.encoding:ri,Rt=(U.isMeshStandardMaterial?J:j).get(U.envMap||Ct),Gt=U.vertexColors===!0&&!!O.attributes.color&&O.attributes.color.itemSize===4,zt=!!U.normalMap&&!!O.attributes.tangent,Ut=!!O.morphAttributes.position,ie=!!O.morphAttributes.normal,fi=O.morphAttributes.position?O.morphAttributes.position.length:0,Zi=U.toneMapped?x.toneMapping:ti,Ot=nt.get(U),nn=f.state.lights;if(Q===!0&&(at===!0||M!==S)){let Ze=M===S&&U.id===_;E.setState(U,M,Ze)}let le=!1;U.version===Ot.__version?(Ot.needsLights&&Ot.lightsStateVersion!==nn.state.version||Ot.outputEncoding!==Lt||Z.isInstancedMesh&&Ot.instancing===!1||!Z.isInstancedMesh&&Ot.instancing===!0||Z.isSkinnedMesh&&Ot.skinning===!1||!Z.isSkinnedMesh&&Ot.skinning===!0||Ot.envMap!==Rt||U.fog&&Ot.fog!==Tt||Ot.numClippingPlanes!==void 0&&(Ot.numClippingPlanes!==E.numPlanes||Ot.numIntersection!==E.numIntersection)||Ot.vertexAlphas!==Gt||Ot.vertexTangents!==zt||Ot.morphTargets!==Ut||Ot.morphNormals!==ie||Ot.toneMapping!==Zi||St.isWebGL2===!0&&Ot.morphTargetsCount!==fi)&&(le=!0):(le=!0,Ot.__version=U.version);let rn=Ot.currentProgram;le===!0&&(rn=Ol(U,I,Z));let Io=!1,sn=!1,vn=!1,_e=rn.getUniforms(),ns=Ot.uniforms;if(B.useProgram(rn.program)&&(Io=!0,sn=!0,vn=!0),U.id!==_&&(_=U.id,sn=!0),Io||S!==M){if(_e.setValue(k,"projectionMatrix",M.projectionMatrix),St.logarithmicDepthBuffer&&_e.setValue(k,"logDepthBufFC",2/(Math.log(M.far+1)/Math.LN2)),S!==M&&(S=M,sn=!0,vn=!0),U.isShaderMaterial||U.isMeshPhongMaterial||U.isMeshToonMaterial||U.isMeshStandardMaterial||U.envMap){let Ze=_e.map.cameraPosition;Ze!==void 0&&Ze.setValue(k,lt.setFromMatrixPosition(M.matrixWorld))}(U.isMeshPhongMaterial||U.isMeshToonMaterial||U.isMeshLambertMaterial||U.isMeshBasicMaterial||U.isMeshStandardMaterial||U.isShaderMaterial)&&_e.setValue(k,"isOrthographic",M.isOrthographicCamera===!0),(U.isMeshPhongMaterial||U.isMeshToonMaterial||U.isMeshLambertMaterial||U.isMeshBasicMaterial||U.isMeshStandardMaterial||U.isShaderMaterial||U.isShadowMaterial||Z.isSkinnedMesh)&&_e.setValue(k,"viewMatrix",M.matrixWorldInverse)}if(Z.isSkinnedMesh){_e.setOptional(k,Z,"bindMatrix"),_e.setOptional(k,Z,"bindMatrixInverse");let Ze=Z.skeleton;Ze&&(St.floatVertexTextures?(Ze.boneTexture===null&&Ze.computeBoneTexture(),_e.setValue(k,"boneTexture",Ze.boneTexture,C),_e.setValue(k,"boneTextureSize",Ze.boneTextureSize)):_e.setOptional(k,Ze,"boneMatrices"))}return!!O&&(O.morphAttributes.position!==void 0||O.morphAttributes.normal!==void 0)&&rt.update(Z,O,U,rn),(sn||Ot.receiveShadow!==Z.receiveShadow)&&(Ot.receiveShadow=Z.receiveShadow,_e.setValue(k,"receiveShadow",Z.receiveShadow)),sn&&(_e.setValue(k,"toneMappingExposure",x.toneMappingExposure),Ot.needsLights&&O0(ns,vn),Tt&&U.fog&&It.refreshFogUniforms(ns,Tt),It.refreshMaterialUniforms(ns,U,y,X,G),ii.upload(k,Ot.uniformsList,ns,C)),U.isShaderMaterial&&U.uniformsNeedUpdate===!0&&(ii.upload(k,Ot.uniformsList,ns,C),U.uniformsNeedUpdate=!1),U.isSpriteMaterial&&_e.setValue(k,"center",Z.center),_e.setValue(k,"modelViewMatrix",Z.modelViewMatrix),_e.setValue(k,"normalMatrix",Z.normalMatrix),_e.setValue(k,"modelMatrix",Z.matrixWorld),rn}function O0(M,I){M.ambientLightColor.needsUpdate=I,M.lightProbe.needsUpdate=I,M.directionalLights.needsUpdate=I,M.directionalLightShadows.needsUpdate=I,M.pointLights.needsUpdate=I,M.pointLightShadows.needsUpdate=I,M.spotLights.needsUpdate=I,M.spotLightShadows.needsUpdate=I,M.rectAreaLights.needsUpdate=I,M.hemisphereLights.needsUpdate=I}function k0(M){return M.isMeshLambertMaterial||M.isMeshToonMaterial||M.isMeshPhongMaterial||M.isMeshStandardMaterial||M.isShadowMaterial||M.isShaderMaterial&&M.lights===!0}this.getActiveCubeFace=function(){return m},this.getActiveMipmapLevel=function(){return p},this.getRenderTarget=function(){return b},this.setRenderTargetTextures=function(M,I,O){nt.get(M.texture).__webglTexture=I,nt.get(M.depthTexture).__webglTexture=O;let U=nt.get(M);U.__hasExternalTextures=!0,U.__hasExternalTextures&&(U.__autoAllocateDepthBuffer=O===void 0,U.__autoAllocateDepthBuffer||M.useRenderToTexture&&(console.warn("render-to-texture extension was disabled because an external texture was provided"),M.useRenderToTexture=!1,M.useRenderbuffer=!0))},this.setRenderTargetFramebuffer=function(M,I){let O=nt.get(M);O.__webglFramebuffer=I,O.__useDefaultFramebuffer=I===void 0},this.setRenderTarget=function(M,I=0,O=0){b=M,m=I,p=O;let U=!0;if(M){let Rt=nt.get(M);Rt.__useDefaultFramebuffer!==void 0?(B.bindFramebuffer(36160,null),U=!1):Rt.__webglFramebuffer===void 0?C.setupRenderTarget(M):Rt.__hasExternalTextures&&C.rebindTextures(M,nt.get(M.texture).__webglTexture,nt.get(M.depthTexture).__webglTexture)}let Z=null,Tt=!1,Ct=!1;if(M){let Rt=M.texture;(Rt.isDataTexture3D||Rt.isDataTexture2DArray)&&(Ct=!0);let Gt=nt.get(M).__webglFramebuffer;M.isWebGLCubeRenderTarget?(Z=Gt[I],Tt=!0):M.useRenderbuffer?Z=nt.get(M).__webglMultisampledFramebuffer:Z=Gt,L.copy(M.viewport),A.copy(M.scissor),H=M.scissorTest}else L.copy(F).multiplyScalar(y).floor(),A.copy(z).multiplyScalar(y).floor(),H=N;if(B.bindFramebuffer(36160,Z)&&St.drawBuffers&&U&&B.drawBuffers(M,Z),B.viewport(L),B.scissor(A),B.setScissorTest(H),Tt){let Rt=nt.get(M.texture);k.framebufferTexture2D(36160,36064,34069+I,Rt.__webglTexture,O)}else if(Ct){let Rt=nt.get(M.texture),Gt=I||0;k.framebufferTextureLayer(36160,36064,Rt.__webglTexture,O||0,Gt)}_=-1},this.readRenderTargetPixels=function(M,I,O,U,Z,Tt,Ct){if(!(M&&M.isWebGLRenderTarget)){console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not THREE.WebGLRenderTarget.");return}let Lt=nt.get(M).__webglFramebuffer;if(M.isWebGLCubeRenderTarget&&Ct!==void 0&&(Lt=Lt[Ct]),Lt){B.bindFramebuffer(36160,Lt);try{let Rt=M.texture,Gt=Rt.format,zt=Rt.type;if(Gt!==Re&&_t.convert(Gt)!==k.getParameter(35739)){console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in RGBA or implementation defined format.");return}let Ut=zt===Ur&&(mt.has("EXT_color_buffer_half_float")||St.isWebGL2&&mt.has("EXT_color_buffer_float"));if(zt!==ei&&_t.convert(zt)!==k.getParameter(35738)&&!(zt===Ui&&(St.isWebGL2||mt.has("OES_texture_float")||mt.has("WEBGL_color_buffer_float")))&&!Ut){console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in UnsignedByteType or implementation defined type.");return}k.checkFramebufferStatus(36160)===36053?I>=0&&I<=M.width-U&&O>=0&&O<=M.height-Z&&k.readPixels(I,O,U,Z,_t.convert(Gt),_t.convert(zt),Tt):console.error("THREE.WebGLRenderer.readRenderTargetPixels: readPixels from renderTarget failed. Framebuffer not complete.")}finally{let Rt=b!==null?nt.get(b).__webglFramebuffer:null;B.bindFramebuffer(36160,Rt)}}},this.copyFramebufferToTexture=function(M,I,O=0){if(I.isFramebufferTexture!==!0){console.error("THREE.WebGLRenderer: copyFramebufferToTexture() can only be used with FramebufferTexture.");return}let U=Math.pow(2,-O),Z=Math.floor(I.image.width*U),Tt=Math.floor(I.image.height*U);C.setTexture2D(I,0),k.copyTexSubImage2D(3553,O,0,0,M.x,M.y,Z,Tt),B.unbindTexture()},this.copyTextureToTexture=function(M,I,O,U=0){let Z=I.image.width,Tt=I.image.height,Ct=_t.convert(O.format),Lt=_t.convert(O.type);C.setTexture2D(O,0),k.pixelStorei(37440,O.flipY),k.pixelStorei(37441,O.premultiplyAlpha),k.pixelStorei(3317,O.unpackAlignment),I.isDataTexture?k.texSubImage2D(3553,U,M.x,M.y,Z,Tt,Ct,Lt,I.image.data):I.isCompressedTexture?k.compressedTexSubImage2D(3553,U,M.x,M.y,I.mipmaps[0].width,I.mipmaps[0].height,Ct,I.mipmaps[0].data):k.texSubImage2D(3553,U,M.x,M.y,Ct,Lt,I.image),U===0&&O.generateMipmaps&&k.generateMipmap(3553),B.unbindTexture()},this.copyTextureToTexture3D=function(M,I,O,U,Z=0){if(x.isWebGL1Renderer){console.warn("THREE.WebGLRenderer.copyTextureToTexture3D: can only be used with WebGL2.");return}let Tt=M.max.x-M.min.x+1,Ct=M.max.y-M.min.y+1,Lt=M.max.z-M.min.z+1,Rt=_t.convert(U.format),Gt=_t.convert(U.type),zt;if(U.isDataTexture3D)C.setTexture3D(U,0),zt=32879;else if(U.isDataTexture2DArray)C.setTexture2DArray(U,0),zt=35866;else{console.warn("THREE.WebGLRenderer.copyTextureToTexture3D: only supports THREE.DataTexture3D and THREE.DataTexture2DArray.");return}k.pixelStorei(37440,U.flipY),k.pixelStorei(37441,U.premultiplyAlpha),k.pixelStorei(3317,U.unpackAlignment);let Ut=k.getParameter(3314),ie=k.getParameter(32878),fi=k.getParameter(3316),Zi=k.getParameter(3315),Ot=k.getParameter(32877),nn=O.isCompressedTexture?O.mipmaps[0]:O.image;k.pixelStorei(3314,nn.width),k.pixelStorei(32878,nn.height),k.pixelStorei(3316,M.min.x),k.pixelStorei(3315,M.min.y),k.pixelStorei(32877,M.min.z),O.isDataTexture||O.isDataTexture3D?k.texSubImage3D(zt,Z,I.x,I.y,I.z,Tt,Ct,Lt,Rt,Gt,nn.data):O.isCompressedTexture?(console.warn("THREE.WebGLRenderer.copyTextureToTexture3D: untested support for compressed srcTexture."),k.compressedTexSubImage3D(zt,Z,I.x,I.y,I.z,Tt,Ct,Lt,Rt,nn.data)):k.texSubImage3D(zt,Z,I.x,I.y,I.z,Tt,Ct,Lt,Rt,Gt,nn),k.pixelStorei(3314,Ut),k.pixelStorei(32878,ie),k.pixelStorei(3316,fi),k.pixelStorei(3315,Zi),k.pixelStorei(32877,Ot),Z===0&&U.generateMipmaps&&k.generateMipmap(zt),B.unbindTexture()},this.initTexture=function(M){C.setTexture2D(M,0),B.unbindTexture()},this.resetState=function(){m=0,p=0,b=null,B.reset(),yt.reset()},typeof __THREE_DEVTOOLS__!="undefined"&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("observe",{detail:this}))}Vt.prototype.isWebGLRenderer=!0;var Ju=class extends Vt{};Ju.prototype.isWebGL1Renderer=!0;var ho=class{constructor(t,e=25e-5){this.name="",this.color=new ft(t),this.density=e}clone(){return new ho(this.color,this.density)}toJSON(){return{type:"FogExp2",color:this.color.getHex(),density:this.density}}};ho.prototype.isFogExp2=!0;var fo=class{constructor(t,e=1,i=1e3){this.name="",this.color=new ft(t),this.near=e,this.far=i}clone(){return new fo(this.color,this.near,this.far)}toJSON(){return{type:"Fog",color:this.color.getHex(),near:this.near,far:this.far}}};fo.prototype.isFog=!0;var Yr=class extends kt{constructor(){super(),this.type="Scene",this.background=null,this.environment=null,this.fog=null,this.overrideMaterial=null,this.autoUpdate=!0,typeof __THREE_DEVTOOLS__!="undefined"&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("observe",{detail:this}))}copy(t,e){return super.copy(t,e),t.background!==null&&(this.background=t.background.clone()),t.environment!==null&&(this.environment=t.environment.clone()),t.fog!==null&&(this.fog=t.fog.clone()),t.overrideMaterial!==null&&(this.overrideMaterial=t.overrideMaterial.clone()),this.autoUpdate=t.autoUpdate,this.matrixAutoUpdate=t.matrixAutoUpdate,this}toJSON(t){let e=super.toJSON(t);return this.fog!==null&&(e.object.fog=this.fog.toJSON()),e}};Yr.prototype.isScene=!0;var Gi=class{constructor(t,e){this.array=t,this.stride=e,this.count=t!==void 0?t.length/e:0,this.usage=io,this.updateRange={offset:0,count:-1},this.version=0,this.uuid=tn()}onUploadCallback(){}set needsUpdate(t){t===!0&&this.version++}setUsage(t){return this.usage=t,this}copy(t){return this.array=new t.array.constructor(t.array),this.count=t.count,this.stride=t.stride,this.usage=t.usage,this}copyAt(t,e,i){t*=this.stride,i*=e.stride;for(let r=0,s=this.stride;r<s;r++)this.array[t+r]=e.array[i+r];return this}set(t,e=0){return this.array.set(t,e),this}clone(t){t.arrayBuffers===void 0&&(t.arrayBuffers={}),this.array.buffer._uuid===void 0&&(this.array.buffer._uuid=tn()),t.arrayBuffers[this.array.buffer._uuid]===void 0&&(t.arrayBuffers[this.array.buffer._uuid]=this.array.slice(0).buffer);let e=new this.array.constructor(t.arrayBuffers[this.array.buffer._uuid]),i=new this.constructor(e,this.stride);return i.setUsage(this.usage),i}onUpload(t){return this.onUploadCallback=t,this}toJSON(t){return t.arrayBuffers===void 0&&(t.arrayBuffers={}),this.array.buffer._uuid===void 0&&(this.array.buffer._uuid=tn()),t.arrayBuffers[this.array.buffer._uuid]===void 0&&(t.arrayBuffers[this.array.buffer._uuid]=Array.prototype.slice.call(new Uint32Array(this.array.buffer))),{uuid:this.uuid,buffer:this.array.buffer._uuid,type:this.array.constructor.name,stride:this.stride}}};Gi.prototype.isInterleavedBuffer=!0;var se=new T,Wi=class{constructor(t,e,i,r=!1){this.name="",this.data=t,this.itemSize=e,this.offset=i,this.normalized=r===!0}get count(){return this.data.count}get array(){return this.data.array}set needsUpdate(t){this.data.needsUpdate=t}applyMatrix4(t){for(let e=0,i=this.data.count;e<i;e++)se.x=this.getX(e),se.y=this.getY(e),se.z=this.getZ(e),se.applyMatrix4(t),this.setXYZ(e,se.x,se.y,se.z);return this}applyNormalMatrix(t){for(let e=0,i=this.count;e<i;e++)se.x=this.getX(e),se.y=this.getY(e),se.z=this.getZ(e),se.applyNormalMatrix(t),this.setXYZ(e,se.x,se.y,se.z);return this}transformDirection(t){for(let e=0,i=this.count;e<i;e++)se.x=this.getX(e),se.y=this.getY(e),se.z=this.getZ(e),se.transformDirection(t),this.setXYZ(e,se.x,se.y,se.z);return this}setX(t,e){return this.data.array[t*this.data.stride+this.offset]=e,this}setY(t,e){return this.data.array[t*this.data.stride+this.offset+1]=e,this}setZ(t,e){return this.data.array[t*this.data.stride+this.offset+2]=e,this}setW(t,e){return this.data.array[t*this.data.stride+this.offset+3]=e,this}getX(t){return this.data.array[t*this.data.stride+this.offset]}getY(t){return this.data.array[t*this.data.stride+this.offset+1]}getZ(t){return this.data.array[t*this.data.stride+this.offset+2]}getW(t){return this.data.array[t*this.data.stride+this.offset+3]}setXY(t,e,i){return t=t*this.data.stride+this.offset,this.data.array[t+0]=e,this.data.array[t+1]=i,this}setXYZ(t,e,i,r){return t=t*this.data.stride+this.offset,this.data.array[t+0]=e,this.data.array[t+1]=i,this.data.array[t+2]=r,this}setXYZW(t,e,i,r,s){return t=t*this.data.stride+this.offset,this.data.array[t+0]=e,this.data.array[t+1]=i,this.data.array[t+2]=r,this.data.array[t+3]=s,this}clone(t){if(t===void 0){console.log("THREE.InterleavedBufferAttribute.clone(): Cloning an interlaved buffer attribute will deinterleave buffer data.");let e=[];for(let i=0;i<this.count;i++){let r=i*this.data.stride+this.offset;for(let s=0;s<this.itemSize;s++)e.push(this.data.array[r+s])}return new Qt(new this.array.constructor(e),this.itemSize,this.normalized)}else return t.interleavedBuffers===void 0&&(t.interleavedBuffers={}),t.interleavedBuffers[this.data.uuid]===void 0&&(t.interleavedBuffers[this.data.uuid]=this.data.clone(t)),new Wi(t.interleavedBuffers[this.data.uuid],this.itemSize,this.offset,this.normalized)}toJSON(t){if(t===void 0){console.log("THREE.InterleavedBufferAttribute.toJSON(): Serializing an interlaved buffer attribute will deinterleave buffer data.");let e=[];for(let i=0;i<this.count;i++){let r=i*this.data.stride+this.offset;for(let s=0;s<this.itemSize;s++)e.push(this.data.array[r+s])}return{itemSize:this.itemSize,type:this.array.constructor.name,array:e,normalized:this.normalized}}else return t.interleavedBuffers===void 0&&(t.interleavedBuffers={}),t.interleavedBuffers[this.data.uuid]===void 0&&(t.interleavedBuffers[this.data.uuid]=this.data.toJSON(t)),{isInterleavedBufferAttribute:!0,itemSize:this.itemSize,data:this.data.uuid,offset:this.offset,normalized:this.normalized}}};Wi.prototype.isInterleavedBufferAttribute=!0;var fl=class extends xe{constructor(t){super(),this.type="SpriteMaterial",this.color=new ft(16777215),this.map=null,this.alphaMap=null,this.rotation=0,this.sizeAttenuation=!0,this.transparent=!0,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.alphaMap=t.alphaMap,this.rotation=t.rotation,this.sizeAttenuation=t.sizeAttenuation,this}};fl.prototype.isSpriteMaterial=!0;var Rr,Ws=new T,Lr=new T,Pr=new T,Dr=new K,qs=new K,A0=new wt,Oa=new T,Xs=new T,ka=new T,Ug=new K,Ru=new K,Bg=new K,$u=class extends kt{constructor(t){if(super(),this.type="Sprite",Rr===void 0){Rr=new Ht;let e=new Float32Array([-.5,-.5,0,0,0,.5,-.5,0,1,0,.5,.5,0,1,1,-.5,.5,0,0,1]),i=new Gi(e,5);Rr.setIndex([0,1,2,0,2,3]),Rr.setAttribute("position",new Wi(i,3,0,!1)),Rr.setAttribute("uv",new Wi(i,2,3,!1))}this.geometry=Rr,this.material=t!==void 0?t:new fl,this.center=new K(.5,.5)}raycast(t,e){t.camera===null&&console.error('THREE.Sprite: "Raycaster.camera" needs to be set in order to raycast against sprites.'),Lr.setFromMatrixScale(this.matrixWorld),A0.copy(t.camera.matrixWorld),this.modelViewMatrix.multiplyMatrices(t.camera.matrixWorldInverse,this.matrixWorld),Pr.setFromMatrixPosition(this.modelViewMatrix),t.camera.isPerspectiveCamera&&this.material.sizeAttenuation===!1&&Lr.multiplyScalar(-Pr.z);let i=this.material.rotation,r,s;i!==0&&(s=Math.cos(i),r=Math.sin(i));let o=this.center;Ha(Oa.set(-.5,-.5,0),Pr,o,Lr,r,s),Ha(Xs.set(.5,-.5,0),Pr,o,Lr,r,s),Ha(ka.set(.5,.5,0),Pr,o,Lr,r,s),Ug.set(0,0),Ru.set(1,0),Bg.set(1,1);let a=t.ray.intersectTriangle(Oa,Xs,ka,!1,Ws);if(a===null&&(Ha(Xs.set(-.5,.5,0),Pr,o,Lr,r,s),Ru.set(0,1),a=t.ray.intersectTriangle(Oa,ka,Xs,!1,Ws),a===null))return;let l=t.ray.origin.distanceTo(Ws);l<t.near||l>t.far||e.push({distance:l,point:Ws.clone(),uv:re.getUV(Ws,Oa,Xs,ka,Ug,Ru,Bg,new K),face:null,object:this})}copy(t){return super.copy(t),t.center!==void 0&&this.center.copy(t.center),this.material=t.material,this}};$u.prototype.isSprite=!0;function Ha(n,t,e,i,r,s){Dr.subVectors(n,e).addScalar(.5).multiply(i),r!==void 0?(qs.x=s*Dr.x-r*Dr.y,qs.y=r*Dr.x+s*Dr.y):qs.copy(Dr),n.copy(t),n.x+=qs.x,n.y+=qs.y,n.applyMatrix4(A0)}var Og=new T,kg=new Wt,Hg=new Wt,NE=new T,Vg=new wt,dl=class extends oe{constructor(t,e){super(t,e),this.type="SkinnedMesh",this.bindMode="attached",this.bindMatrix=new wt,this.bindMatrixInverse=new wt}copy(t){return super.copy(t),this.bindMode=t.bindMode,this.bindMatrix.copy(t.bindMatrix),this.bindMatrixInverse.copy(t.bindMatrixInverse),this.skeleton=t.skeleton,this}bind(t,e){this.skeleton=t,e===void 0&&(this.updateMatrixWorld(!0),this.skeleton.calculateInverses(),e=this.matrixWorld),this.bindMatrix.copy(e),this.bindMatrixInverse.copy(e).invert()}pose(){this.skeleton.pose()}normalizeSkinWeights(){let t=new Wt,e=this.geometry.attributes.skinWeight;for(let i=0,r=e.count;i<r;i++){t.x=e.getX(i),t.y=e.getY(i),t.z=e.getZ(i),t.w=e.getW(i);let s=1/t.manhattanLength();s!==1/0?t.multiplyScalar(s):t.set(1,0,0,0),e.setXYZW(i,t.x,t.y,t.z,t.w)}}updateMatrixWorld(t){super.updateMatrixWorld(t),this.bindMode==="attached"?this.bindMatrixInverse.copy(this.matrixWorld).invert():this.bindMode==="detached"?this.bindMatrixInverse.copy(this.bindMatrix).invert():console.warn("THREE.SkinnedMesh: Unrecognized bindMode: "+this.bindMode)}boneTransform(t,e){let i=this.skeleton,r=this.geometry;kg.fromBufferAttribute(r.attributes.skinIndex,t),Hg.fromBufferAttribute(r.attributes.skinWeight,t),Og.copy(e).applyMatrix4(this.bindMatrix),e.set(0,0,0);for(let s=0;s<4;s++){let o=Hg.getComponent(s);if(o!==0){let a=kg.getComponent(s);Vg.multiplyMatrices(i.bones[a].matrixWorld,i.boneInverses[a]),e.addScaledVector(NE.copy(Og).applyMatrix4(Vg),o)}}return e.applyMatrix4(this.bindMatrixInverse)}};dl.prototype.isSkinnedMesh=!0;var Ku=class extends kt{constructor(){super(),this.type="Bone"}};Ku.prototype.isBone=!0;var Qu=class extends ae{constructor(t=null,e=1,i=1,r,s,o,a,l,c=fe,u=fe,h,f){super(null,o,a,l,c,u,r,s,h,f),this.image={data:t,width:e,height:i},this.magFilter=c,this.minFilter=u,this.generateMipmaps=!1,this.flipY=!1,this.unpackAlignment=1}};Qu.prototype.isDataTexture=!0;var po=class extends Qt{constructor(t,e,i,r=1){typeof i=="number"&&(r=i,i=!1,console.error("THREE.InstancedBufferAttribute: The constructor now expects normalized as the third argument.")),super(t,e,i),this.meshPerAttribute=r}copy(t){return super.copy(t),this.meshPerAttribute=t.meshPerAttribute,this}toJSON(){let t=super.toJSON();return t.meshPerAttribute=this.meshPerAttribute,t.isInstancedBufferAttribute=!0,t}};po.prototype.isInstancedBufferAttribute=!0;var Gg=new wt,Wg=new wt,Va=[],Ys=new oe,ju=class extends oe{constructor(t,e,i){super(t,e),this.instanceMatrix=new po(new Float32Array(i*16),16),this.instanceColor=null,this.count=i,this.frustumCulled=!1}copy(t){return super.copy(t),this.instanceMatrix.copy(t.instanceMatrix),t.instanceColor!==null&&(this.instanceColor=t.instanceColor.clone()),this.count=t.count,this}getColorAt(t,e){e.fromArray(this.instanceColor.array,t*3)}getMatrixAt(t,e){e.fromArray(this.instanceMatrix.array,t*16)}raycast(t,e){let i=this.matrixWorld,r=this.count;if(Ys.geometry=this.geometry,Ys.material=this.material,Ys.material!==void 0)for(let s=0;s<r;s++){this.getMatrixAt(s,Gg),Wg.multiplyMatrices(i,Gg),Ys.matrixWorld=Wg,Ys.raycast(t,Va);for(let o=0,a=Va.length;o<a;o++){let l=Va[o];l.instanceId=s,l.object=this,e.push(l)}Va.length=0}}setColorAt(t,e){this.instanceColor===null&&(this.instanceColor=new po(new Float32Array(this.instanceMatrix.count*3),3)),e.toArray(this.instanceColor.array,t*3)}setMatrixAt(t,e){e.toArray(this.instanceMatrix.array,t*16)}updateMorphTargets(){}dispose(){this.dispatchEvent({type:"dispose"})}};ju.prototype.isInstancedMesh=!0;var zn=class extends xe{constructor(t){super(),this.type="LineBasicMaterial",this.color=new ft(16777215),this.linewidth=1,this.linecap="round",this.linejoin="round",this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.linewidth=t.linewidth,this.linecap=t.linecap,this.linejoin=t.linejoin,this}};zn.prototype.isLineBasicMaterial=!0;var qg=new T,Xg=new T,Yg=new wt,Lu=new oi,Ga=new si,mo=class extends kt{constructor(t=new Ht,e=new zn){super(),this.type="Line",this.geometry=t,this.material=e,this.updateMorphTargets()}copy(t){return super.copy(t),this.material=t.material,this.geometry=t.geometry,this}computeLineDistances(){let t=this.geometry;if(t.isBufferGeometry)if(t.index===null){let e=t.attributes.position,i=[0];for(let r=1,s=e.count;r<s;r++)qg.fromBufferAttribute(e,r-1),Xg.fromBufferAttribute(e,r),i[r]=i[r-1],i[r]+=qg.distanceTo(Xg);t.setAttribute("lineDistance",new ee(i,1))}else console.warn("THREE.Line.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.");else t.isGeometry&&console.error("THREE.Line.computeLineDistances() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.");return this}raycast(t,e){let i=this.geometry,r=this.matrixWorld,s=t.params.Line.threshold,o=i.drawRange;if(i.boundingSphere===null&&i.computeBoundingSphere(),Ga.copy(i.boundingSphere),Ga.applyMatrix4(r),Ga.radius+=s,t.ray.intersectsSphere(Ga)===!1)return;Yg.copy(r).invert(),Lu.copy(t.ray).applyMatrix4(Yg);let a=s/((this.scale.x+this.scale.y+this.scale.z)/3),l=a*a,c=new T,u=new T,h=new T,f=new T,d=this.isLineSegments?2:1;if(i.isBufferGeometry){let g=i.index,v=i.attributes.position;if(g!==null){let m=Math.max(0,o.start),p=Math.min(g.count,o.start+o.count);for(let b=m,_=p-1;b<_;b+=d){let S=g.getX(b),L=g.getX(b+1);if(c.fromBufferAttribute(v,S),u.fromBufferAttribute(v,L),Lu.distanceSqToSegment(c,u,f,h)>l)continue;f.applyMatrix4(this.matrixWorld);let H=t.ray.origin.distanceTo(f);H<t.near||H>t.far||e.push({distance:H,point:h.clone().applyMatrix4(this.matrixWorld),index:b,face:null,faceIndex:null,object:this})}}else{let m=Math.max(0,o.start),p=Math.min(v.count,o.start+o.count);for(let b=m,_=p-1;b<_;b+=d){if(c.fromBufferAttribute(v,b),u.fromBufferAttribute(v,b+1),Lu.distanceSqToSegment(c,u,f,h)>l)continue;f.applyMatrix4(this.matrixWorld);let L=t.ray.origin.distanceTo(f);L<t.near||L>t.far||e.push({distance:L,point:h.clone().applyMatrix4(this.matrixWorld),index:b,face:null,faceIndex:null,object:this})}}}else i.isGeometry&&console.error("THREE.Line.raycast() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}updateMorphTargets(){let t=this.geometry;if(t.isBufferGeometry){let e=t.morphAttributes,i=Object.keys(e);if(i.length>0){let r=e[i[0]];if(r!==void 0){this.morphTargetInfluences=[],this.morphTargetDictionary={};for(let s=0,o=r.length;s<o;s++){let a=r[s].name||String(s);this.morphTargetInfluences.push(0),this.morphTargetDictionary[a]=s}}}}else{let e=t.morphTargets;e!==void 0&&e.length>0&&console.error("THREE.Line.updateMorphTargets() does not support THREE.Geometry. Use THREE.BufferGeometry instead.")}}};mo.prototype.isLine=!0;var Zg=new T,Jg=new T,go=class extends mo{constructor(t,e){super(t,e),this.type="LineSegments"}computeLineDistances(){let t=this.geometry;if(t.isBufferGeometry)if(t.index===null){let e=t.attributes.position,i=[];for(let r=0,s=e.count;r<s;r+=2)Zg.fromBufferAttribute(e,r),Jg.fromBufferAttribute(e,r+1),i[r]=r===0?0:i[r-1],i[r+1]=i[r]+Zg.distanceTo(Jg);t.setAttribute("lineDistance",new ee(i,1))}else console.warn("THREE.LineSegments.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.");else t.isGeometry&&console.error("THREE.LineSegments.computeLineDistances() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.");return this}};go.prototype.isLineSegments=!0;var th=class extends mo{constructor(t,e){super(t,e),this.type="LineLoop"}};th.prototype.isLineLoop=!0;var pl=class extends xe{constructor(t){super(),this.type="PointsMaterial",this.color=new ft(16777215),this.map=null,this.alphaMap=null,this.size=1,this.sizeAttenuation=!0,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.alphaMap=t.alphaMap,this.size=t.size,this.sizeAttenuation=t.sizeAttenuation,this}};pl.prototype.isPointsMaterial=!0;var $g=new wt,eh=new oi,Wa=new si,qa=new T,nh=class extends kt{constructor(t=new Ht,e=new pl){super(),this.type="Points",this.geometry=t,this.material=e,this.updateMorphTargets()}copy(t){return super.copy(t),this.material=t.material,this.geometry=t.geometry,this}raycast(t,e){let i=this.geometry,r=this.matrixWorld,s=t.params.Points.threshold,o=i.drawRange;if(i.boundingSphere===null&&i.computeBoundingSphere(),Wa.copy(i.boundingSphere),Wa.applyMatrix4(r),Wa.radius+=s,t.ray.intersectsSphere(Wa)===!1)return;$g.copy(r).invert(),eh.copy(t.ray).applyMatrix4($g);let a=s/((this.scale.x+this.scale.y+this.scale.z)/3),l=a*a;if(i.isBufferGeometry){let c=i.index,h=i.attributes.position;if(c!==null){let f=Math.max(0,o.start),d=Math.min(c.count,o.start+o.count);for(let g=f,x=d;g<x;g++){let v=c.getX(g);qa.fromBufferAttribute(h,v),Kg(qa,v,l,r,t,e,this)}}else{let f=Math.max(0,o.start),d=Math.min(h.count,o.start+o.count);for(let g=f,x=d;g<x;g++)qa.fromBufferAttribute(h,g),Kg(qa,g,l,r,t,e,this)}}else console.error("THREE.Points.raycast() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}updateMorphTargets(){let t=this.geometry;if(t.isBufferGeometry){let e=t.morphAttributes,i=Object.keys(e);if(i.length>0){let r=e[i[0]];if(r!==void 0){this.morphTargetInfluences=[],this.morphTargetDictionary={};for(let s=0,o=r.length;s<o;s++){let a=r[s].name||String(s);this.morphTargetInfluences.push(0),this.morphTargetDictionary[a]=s}}}}else{let e=t.morphTargets;e!==void 0&&e.length>0&&console.error("THREE.Points.updateMorphTargets() does not support THREE.Geometry. Use THREE.BufferGeometry instead.")}}};nh.prototype.isPoints=!0;function Kg(n,t,e,i,r,s,o){let a=eh.distanceSqToPoint(n);if(a<e){let l=new T;eh.closestPointToPoint(n,l),l.applyMatrix4(i);let c=r.ray.origin.distanceTo(l);if(c<r.near||c>r.far)return;s.push({distance:c,distanceToRay:Math.sqrt(a),point:l,index:t,face:null,object:o})}}var ih=class extends ae{constructor(t,e,i,r,s,o,a,l,c){super(t,e,i,r,s,o,a,l,c),this.minFilter=o!==void 0?o:be,this.magFilter=s!==void 0?s:be,this.generateMipmaps=!1;let u=this;function h(){u.needsUpdate=!0,t.requestVideoFrameCallback(h)}"requestVideoFrameCallback"in t&&t.requestVideoFrameCallback(h)}clone(){return new this.constructor(this.image).copy(this)}update(){let t=this.image;"requestVideoFrameCallback"in t===!1&&t.readyState>=t.HAVE_CURRENT_DATA&&(this.needsUpdate=!0)}};ih.prototype.isVideoTexture=!0;var rh=class extends ae{constructor(t,e,i){super({width:t,height:e}),this.format=i,this.magFilter=fe,this.minFilter=fe,this.generateMipmaps=!1,this.needsUpdate=!0}};rh.prototype.isFramebufferTexture=!0;var sh=class extends ae{constructor(t,e,i,r,s,o,a,l,c,u,h,f){super(null,o,a,l,c,u,r,s,h,f),this.image={width:e,height:i},this.mipmaps=t,this.flipY=!1,this.generateMipmaps=!1}};sh.prototype.isCompressedTexture=!0;var oh=class extends ae{constructor(t,e,i,r,s,o,a,l,c){super(t,e,i,r,s,o,a,l,c),this.needsUpdate=!0}};oh.prototype.isCanvasTexture=!0;var Zr=class extends Ht{constructor(t=1,e=8,i=0,r=Math.PI*2){super(),this.type="CircleGeometry",this.parameters={radius:t,segments:e,thetaStart:i,thetaLength:r},e=Math.max(3,e);let s=[],o=[],a=[],l=[],c=new T,u=new K;o.push(0,0,0),a.push(0,0,1),l.push(.5,.5);for(let h=0,f=3;h<=e;h++,f+=3){let d=i+h/e*r;c.x=t*Math.cos(d),c.y=t*Math.sin(d),o.push(c.x,c.y,c.z),a.push(0,0,1),u.x=(o[f]/t+1)/2,u.y=(o[f+1]/t+1)/2,l.push(u.x,u.y)}for(let h=1;h<=e;h++)s.push(h,h+1,0);this.setIndex(s),this.setAttribute("position",new ee(o,3)),this.setAttribute("normal",new ee(a,3)),this.setAttribute("uv",new ee(l,2))}static fromJSON(t){return new Zr(t.radius,t.segments,t.thetaStart,t.thetaLength)}};var Sk=new T,Ek=new T,Tk=new T,Ak=new re;var Fe=class{constructor(){this.type="Curve",this.arcLengthDivisions=200}getPoint(){return console.warn("THREE.Curve: .getPoint() not implemented."),null}getPointAt(t,e){let i=this.getUtoTmapping(t);return this.getPoint(i,e)}getPoints(t=5){let e=[];for(let i=0;i<=t;i++)e.push(this.getPoint(i/t));return e}getSpacedPoints(t=5){let e=[];for(let i=0;i<=t;i++)e.push(this.getPointAt(i/t));return e}getLength(){let t=this.getLengths();return t[t.length-1]}getLengths(t=this.arcLengthDivisions){if(this.cacheArcLengths&&this.cacheArcLengths.length===t+1&&!this.needsUpdate)return this.cacheArcLengths;this.needsUpdate=!1;let e=[],i,r=this.getPoint(0),s=0;e.push(0);for(let o=1;o<=t;o++)i=this.getPoint(o/t),s+=i.distanceTo(r),e.push(s),r=i;return this.cacheArcLengths=e,e}updateArcLengths(){this.needsUpdate=!0,this.getLengths()}getUtoTmapping(t,e){let i=this.getLengths(),r=0,s=i.length,o;e?o=e:o=t*i[s-1];let a=0,l=s-1,c;for(;a<=l;)if(r=Math.floor(a+(l-a)/2),c=i[r]-o,c<0)a=r+1;else if(c>0)l=r-1;else{l=r;break}if(r=l,i[r]===o)return r/(s-1);let u=i[r],f=i[r+1]-u,d=(o-u)/f;return(r+d)/(s-1)}getTangent(t,e){let r=t-1e-4,s=t+1e-4;r<0&&(r=0),s>1&&(s=1);let o=this.getPoint(r),a=this.getPoint(s),l=e||(o.isVector2?new K:new T);return l.copy(a).sub(o).normalize(),l}getTangentAt(t,e){let i=this.getUtoTmapping(t);return this.getTangent(i,e)}computeFrenetFrames(t,e){let i=new T,r=[],s=[],o=[],a=new T,l=new wt;for(let d=0;d<=t;d++){let g=d/t;r[d]=this.getTangentAt(g,new T)}s[0]=new T,o[0]=new T;let c=Number.MAX_VALUE,u=Math.abs(r[0].x),h=Math.abs(r[0].y),f=Math.abs(r[0].z);u<=c&&(c=u,i.set(1,0,0)),h<=c&&(c=h,i.set(0,1,0)),f<=c&&i.set(0,0,1),a.crossVectors(r[0],i).normalize(),s[0].crossVectors(r[0],a),o[0].crossVectors(r[0],s[0]);for(let d=1;d<=t;d++){if(s[d]=s[d-1].clone(),o[d]=o[d-1].clone(),a.crossVectors(r[d-1],r[d]),a.length()>Number.EPSILON){a.normalize();let g=Math.acos(Ie(r[d-1].dot(r[d]),-1,1));s[d].applyMatrix4(l.makeRotationAxis(a,g))}o[d].crossVectors(r[d],s[d])}if(e===!0){let d=Math.acos(Ie(s[0].dot(s[t]),-1,1));d/=t,r[0].dot(a.crossVectors(s[0],s[t]))>0&&(d=-d);for(let g=1;g<=t;g++)s[g].applyMatrix4(l.makeRotationAxis(r[g],d*g)),o[g].crossVectors(r[g],s[g])}return{tangents:r,normals:s,binormals:o}}clone(){return new this.constructor().copy(this)}copy(t){return this.arcLengthDivisions=t.arcLengthDivisions,this}toJSON(){let t={metadata:{version:4.5,type:"Curve",generator:"Curve.toJSON"}};return t.arcLengthDivisions=this.arcLengthDivisions,t.type=this.type,t}fromJSON(t){return this.arcLengthDivisions=t.arcLengthDivisions,this}},Jr=class extends Fe{constructor(t=0,e=0,i=1,r=1,s=0,o=Math.PI*2,a=!1,l=0){super(),this.type="EllipseCurve",this.aX=t,this.aY=e,this.xRadius=i,this.yRadius=r,this.aStartAngle=s,this.aEndAngle=o,this.aClockwise=a,this.aRotation=l}getPoint(t,e){let i=e||new K,r=Math.PI*2,s=this.aEndAngle-this.aStartAngle,o=Math.abs(s)<Number.EPSILON;for(;s<0;)s+=r;for(;s>r;)s-=r;s<Number.EPSILON&&(o?s=0:s=r),this.aClockwise===!0&&!o&&(s===r?s=-r:s=s-r);let a=this.aStartAngle+t*s,l=this.aX+this.xRadius*Math.cos(a),c=this.aY+this.yRadius*Math.sin(a);if(this.aRotation!==0){let u=Math.cos(this.aRotation),h=Math.sin(this.aRotation),f=l-this.aX,d=c-this.aY;l=f*u-d*h+this.aX,c=f*h+d*u+this.aY}return i.set(l,c)}copy(t){return super.copy(t),this.aX=t.aX,this.aY=t.aY,this.xRadius=t.xRadius,this.yRadius=t.yRadius,this.aStartAngle=t.aStartAngle,this.aEndAngle=t.aEndAngle,this.aClockwise=t.aClockwise,this.aRotation=t.aRotation,this}toJSON(){let t=super.toJSON();return t.aX=this.aX,t.aY=this.aY,t.xRadius=this.xRadius,t.yRadius=this.yRadius,t.aStartAngle=this.aStartAngle,t.aEndAngle=this.aEndAngle,t.aClockwise=this.aClockwise,t.aRotation=this.aRotation,t}fromJSON(t){return super.fromJSON(t),this.aX=t.aX,this.aY=t.aY,this.xRadius=t.xRadius,this.yRadius=t.yRadius,this.aStartAngle=t.aStartAngle,this.aEndAngle=t.aEndAngle,this.aClockwise=t.aClockwise,this.aRotation=t.aRotation,this}};Jr.prototype.isEllipseCurve=!0;var ml=class extends Jr{constructor(t,e,i,r,s,o){super(t,e,i,i,r,s,o),this.type="ArcCurve"}};ml.prototype.isArcCurve=!0;function tf(){let n=0,t=0,e=0,i=0;function r(s,o,a,l){n=s,t=a,e=-3*s+3*o-2*a-l,i=2*s-2*o+a+l}return{initCatmullRom:function(s,o,a,l,c){r(o,a,c*(a-s),c*(l-o))},initNonuniformCatmullRom:function(s,o,a,l,c,u,h){let f=(o-s)/c-(a-s)/(c+u)+(a-o)/u,d=(a-o)/u-(l-o)/(u+h)+(l-a)/h;f*=u,d*=u,r(o,a,f,d)},calc:function(s){let o=s*s,a=o*s;return n+t*s+e*o+i*a}}}var Xa=new T,Pu=new tf,Du=new tf,Iu=new tf,gl=class extends Fe{constructor(t=[],e=!1,i="centripetal",r=.5){super(),this.type="CatmullRomCurve3",this.points=t,this.closed=e,this.curveType=i,this.tension=r}getPoint(t,e=new T){let i=e,r=this.points,s=r.length,o=(s-(this.closed?0:1))*t,a=Math.floor(o),l=o-a;this.closed?a+=a>0?0:(Math.floor(Math.abs(a)/s)+1)*s:l===0&&a===s-1&&(a=s-2,l=1);let c,u;this.closed||a>0?c=r[(a-1)%s]:(Xa.subVectors(r[0],r[1]).add(r[0]),c=Xa);let h=r[a%s],f=r[(a+1)%s];if(this.closed||a+2<s?u=r[(a+2)%s]:(Xa.subVectors(r[s-1],r[s-2]).add(r[s-1]),u=Xa),this.curveType==="centripetal"||this.curveType==="chordal"){let d=this.curveType==="chordal"?.5:.25,g=Math.pow(c.distanceToSquared(h),d),x=Math.pow(h.distanceToSquared(f),d),v=Math.pow(f.distanceToSquared(u),d);x<1e-4&&(x=1),g<1e-4&&(g=x),v<1e-4&&(v=x),Pu.initNonuniformCatmullRom(c.x,h.x,f.x,u.x,g,x,v),Du.initNonuniformCatmullRom(c.y,h.y,f.y,u.y,g,x,v),Iu.initNonuniformCatmullRom(c.z,h.z,f.z,u.z,g,x,v)}else this.curveType==="catmullrom"&&(Pu.initCatmullRom(c.x,h.x,f.x,u.x,this.tension),Du.initCatmullRom(c.y,h.y,f.y,u.y,this.tension),Iu.initCatmullRom(c.z,h.z,f.z,u.z,this.tension));return i.set(Pu.calc(l),Du.calc(l),Iu.calc(l)),i}copy(t){super.copy(t),this.points=[];for(let e=0,i=t.points.length;e<i;e++){let r=t.points[e];this.points.push(r.clone())}return this.closed=t.closed,this.curveType=t.curveType,this.tension=t.tension,this}toJSON(){let t=super.toJSON();t.points=[];for(let e=0,i=this.points.length;e<i;e++){let r=this.points[e];t.points.push(r.toArray())}return t.closed=this.closed,t.curveType=this.curveType,t.tension=this.tension,t}fromJSON(t){super.fromJSON(t),this.points=[];for(let e=0,i=t.points.length;e<i;e++){let r=t.points[e];this.points.push(new T().fromArray(r))}return this.closed=t.closed,this.curveType=t.curveType,this.tension=t.tension,this}};gl.prototype.isCatmullRomCurve3=!0;function Qg(n,t,e,i,r){let s=(i-t)*.5,o=(r-e)*.5,a=n*n,l=n*a;return(2*e-2*i+s+o)*l+(-3*e+3*i-2*s-o)*a+s*n+e}function FE(n,t){let e=1-n;return e*e*t}function zE(n,t){return 2*(1-n)*n*t}function UE(n,t){return n*n*t}function js(n,t,e,i){return FE(n,t)+zE(n,e)+UE(n,i)}function BE(n,t){let e=1-n;return e*e*e*t}function OE(n,t){let e=1-n;return 3*e*e*n*t}function kE(n,t){return 3*(1-n)*n*n*t}function HE(n,t){return n*n*n*t}function to(n,t,e,i,r){return BE(n,t)+OE(n,e)+kE(n,i)+HE(n,r)}var xo=class extends Fe{constructor(t=new K,e=new K,i=new K,r=new K){super(),this.type="CubicBezierCurve",this.v0=t,this.v1=e,this.v2=i,this.v3=r}getPoint(t,e=new K){let i=e,r=this.v0,s=this.v1,o=this.v2,a=this.v3;return i.set(to(t,r.x,s.x,o.x,a.x),to(t,r.y,s.y,o.y,a.y)),i}copy(t){return super.copy(t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this.v3.copy(t.v3),this}toJSON(){let t=super.toJSON();return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t.v3=this.v3.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this.v3.fromArray(t.v3),this}};xo.prototype.isCubicBezierCurve=!0;var xl=class extends Fe{constructor(t=new T,e=new T,i=new T,r=new T){super(),this.type="CubicBezierCurve3",this.v0=t,this.v1=e,this.v2=i,this.v3=r}getPoint(t,e=new T){let i=e,r=this.v0,s=this.v1,o=this.v2,a=this.v3;return i.set(to(t,r.x,s.x,o.x,a.x),to(t,r.y,s.y,o.y,a.y),to(t,r.z,s.z,o.z,a.z)),i}copy(t){return super.copy(t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this.v3.copy(t.v3),this}toJSON(){let t=super.toJSON();return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t.v3=this.v3.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this.v3.fromArray(t.v3),this}};xl.prototype.isCubicBezierCurve3=!0;var $r=class extends Fe{constructor(t=new K,e=new K){super(),this.type="LineCurve",this.v1=t,this.v2=e}getPoint(t,e=new K){let i=e;return t===1?i.copy(this.v2):(i.copy(this.v2).sub(this.v1),i.multiplyScalar(t).add(this.v1)),i}getPointAt(t,e){return this.getPoint(t,e)}getTangent(t,e){let i=e||new K;return i.copy(this.v2).sub(this.v1).normalize(),i}copy(t){return super.copy(t),this.v1.copy(t.v1),this.v2.copy(t.v2),this}toJSON(){let t=super.toJSON();return t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this}};$r.prototype.isLineCurve=!0;var ah=class extends Fe{constructor(t=new T,e=new T){super(),this.type="LineCurve3",this.isLineCurve3=!0,this.v1=t,this.v2=e}getPoint(t,e=new T){let i=e;return t===1?i.copy(this.v2):(i.copy(this.v2).sub(this.v1),i.multiplyScalar(t).add(this.v1)),i}getPointAt(t,e){return this.getPoint(t,e)}copy(t){return super.copy(t),this.v1.copy(t.v1),this.v2.copy(t.v2),this}toJSON(){let t=super.toJSON();return t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this}},yo=class extends Fe{constructor(t=new K,e=new K,i=new K){super(),this.type="QuadraticBezierCurve",this.v0=t,this.v1=e,this.v2=i}getPoint(t,e=new K){let i=e,r=this.v0,s=this.v1,o=this.v2;return i.set(js(t,r.x,s.x,o.x),js(t,r.y,s.y,o.y)),i}copy(t){return super.copy(t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this}toJSON(){let t=super.toJSON();return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this}};yo.prototype.isQuadraticBezierCurve=!0;var yl=class extends Fe{constructor(t=new T,e=new T,i=new T){super(),this.type="QuadraticBezierCurve3",this.v0=t,this.v1=e,this.v2=i}getPoint(t,e=new T){let i=e,r=this.v0,s=this.v1,o=this.v2;return i.set(js(t,r.x,s.x,o.x),js(t,r.y,s.y,o.y),js(t,r.z,s.z,o.z)),i}copy(t){return super.copy(t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this}toJSON(){let t=super.toJSON();return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this}};yl.prototype.isQuadraticBezierCurve3=!0;var vo=class extends Fe{constructor(t=[]){super(),this.type="SplineCurve",this.points=t}getPoint(t,e=new K){let i=e,r=this.points,s=(r.length-1)*t,o=Math.floor(s),a=s-o,l=r[o===0?o:o-1],c=r[o],u=r[o>r.length-2?r.length-1:o+1],h=r[o>r.length-3?r.length-1:o+2];return i.set(Qg(a,l.x,c.x,u.x,h.x),Qg(a,l.y,c.y,u.y,h.y)),i}copy(t){super.copy(t),this.points=[];for(let e=0,i=t.points.length;e<i;e++){let r=t.points[e];this.points.push(r.clone())}return this}toJSON(){let t=super.toJSON();t.points=[];for(let e=0,i=this.points.length;e<i;e++){let r=this.points[e];t.points.push(r.toArray())}return t}fromJSON(t){super.fromJSON(t),this.points=[];for(let e=0,i=t.points.length;e<i;e++){let r=t.points[e];this.points.push(new K().fromArray(r))}return this}};vo.prototype.isSplineCurve=!0;var C0=Object.freeze({__proto__:null,ArcCurve:ml,CatmullRomCurve3:gl,CubicBezierCurve:xo,CubicBezierCurve3:xl,EllipseCurve:Jr,LineCurve:$r,LineCurve3:ah,QuadraticBezierCurve:yo,QuadraticBezierCurve3:yl,SplineCurve:vo}),lh=class extends Fe{constructor(){super(),this.type="CurvePath",this.curves=[],this.autoClose=!1}add(t){this.curves.push(t)}closePath(){let t=this.curves[0].getPoint(0),e=this.curves[this.curves.length-1].getPoint(1);t.equals(e)||this.curves.push(new $r(e,t))}getPoint(t,e){let i=t*this.getLength(),r=this.getCurveLengths(),s=0;for(;s<r.length;){if(r[s]>=i){let o=r[s]-i,a=this.curves[s],l=a.getLength(),c=l===0?0:1-o/l;return a.getPointAt(c,e)}s++}return null}getLength(){let t=this.getCurveLengths();return t[t.length-1]}updateArcLengths(){this.needsUpdate=!0,this.cacheLengths=null,this.getCurveLengths()}getCurveLengths(){if(this.cacheLengths&&this.cacheLengths.length===this.curves.length)return this.cacheLengths;let t=[],e=0;for(let i=0,r=this.curves.length;i<r;i++)e+=this.curves[i].getLength(),t.push(e);return this.cacheLengths=t,t}getSpacedPoints(t=40){let e=[];for(let i=0;i<=t;i++)e.push(this.getPoint(i/t));return this.autoClose&&e.push(e[0]),e}getPoints(t=12){let e=[],i;for(let r=0,s=this.curves;r<s.length;r++){let o=s[r],a=o&&o.isEllipseCurve?t*2:o&&(o.isLineCurve||o.isLineCurve3)?1:o&&o.isSplineCurve?t*o.points.length:t,l=o.getPoints(a);for(let c=0;c<l.length;c++){let u=l[c];i&&i.equals(u)||(e.push(u),i=u)}}return this.autoClose&&e.length>1&&!e[e.length-1].equals(e[0])&&e.push(e[0]),e}copy(t){super.copy(t),this.curves=[];for(let e=0,i=t.curves.length;e<i;e++){let r=t.curves[e];this.curves.push(r.clone())}return this.autoClose=t.autoClose,this}toJSON(){let t=super.toJSON();t.autoClose=this.autoClose,t.curves=[];for(let e=0,i=this.curves.length;e<i;e++){let r=this.curves[e];t.curves.push(r.toJSON())}return t}fromJSON(t){super.fromJSON(t),this.autoClose=t.autoClose,this.curves=[];for(let e=0,i=t.curves.length;e<i;e++){let r=t.curves[e];this.curves.push(new C0[r.type]().fromJSON(r))}return this}},_o=class extends lh{constructor(t){super(),this.type="Path",this.currentPoint=new K,t&&this.setFromPoints(t)}setFromPoints(t){this.moveTo(t[0].x,t[0].y);for(let e=1,i=t.length;e<i;e++)this.lineTo(t[e].x,t[e].y);return this}moveTo(t,e){return this.currentPoint.set(t,e),this}lineTo(t,e){let i=new $r(this.currentPoint.clone(),new K(t,e));return this.curves.push(i),this.currentPoint.set(t,e),this}quadraticCurveTo(t,e,i,r){let s=new yo(this.currentPoint.clone(),new K(t,e),new K(i,r));return this.curves.push(s),this.currentPoint.set(i,r),this}bezierCurveTo(t,e,i,r,s,o){let a=new xo(this.currentPoint.clone(),new K(t,e),new K(i,r),new K(s,o));return this.curves.push(a),this.currentPoint.set(s,o),this}splineThru(t){let e=[this.currentPoint.clone()].concat(t),i=new vo(e);return this.curves.push(i),this.currentPoint.copy(t[t.length-1]),this}arc(t,e,i,r,s,o){let a=this.currentPoint.x,l=this.currentPoint.y;return this.absarc(t+a,e+l,i,r,s,o),this}absarc(t,e,i,r,s,o){return this.absellipse(t,e,i,i,r,s,o),this}ellipse(t,e,i,r,s,o,a,l){let c=this.currentPoint.x,u=this.currentPoint.y;return this.absellipse(t+c,e+u,i,r,s,o,a,l),this}absellipse(t,e,i,r,s,o,a,l){let c=new Jr(t,e,i,r,s,o,a,l);if(this.curves.length>0){let h=c.getPoint(0);h.equals(this.currentPoint)||this.lineTo(h.x,h.y)}this.curves.push(c);let u=c.getPoint(1);return this.currentPoint.copy(u),this}copy(t){return super.copy(t),this.currentPoint.copy(t.currentPoint),this}toJSON(){let t=super.toJSON();return t.currentPoint=this.currentPoint.toArray(),t}fromJSON(t){return super.fromJSON(t),this.currentPoint.fromArray(t.currentPoint),this}},Un=class extends _o{constructor(t){super(t),this.uuid=tn(),this.type="Shape",this.holes=[]}getPointsHoles(t){let e=[];for(let i=0,r=this.holes.length;i<r;i++)e[i]=this.holes[i].getPoints(t);return e}extractPoints(t){return{shape:this.getPoints(t),holes:this.getPointsHoles(t)}}copy(t){super.copy(t),this.holes=[];for(let e=0,i=t.holes.length;e<i;e++){let r=t.holes[e];this.holes.push(r.clone())}return this}toJSON(){let t=super.toJSON();t.uuid=this.uuid,t.holes=[];for(let e=0,i=this.holes.length;e<i;e++){let r=this.holes[e];t.holes.push(r.toJSON())}return t}fromJSON(t){super.fromJSON(t),this.uuid=t.uuid,this.holes=[];for(let e=0,i=t.holes.length;e<i;e++){let r=t.holes[e];this.holes.push(new _o().fromJSON(r))}return this}},VE={triangulate:function(n,t,e=2){let i=t&&t.length,r=i?t[0]*e:n.length,s=R0(n,0,r,e,!0),o=[];if(!s||s.next===s.prev)return o;let a,l,c,u,h,f,d;if(i&&(s=YE(n,t,s,e)),n.length>80*e){a=c=n[0],l=u=n[1];for(let g=e;g<r;g+=e)h=n[g],f=n[g+1],h<a&&(a=h),f<l&&(l=f),h>c&&(c=h),f>u&&(u=f);d=Math.max(c-a,u-l),d=d!==0?1/d:0}return wo(s,o,e,a,l,d),o}};function R0(n,t,e,i,r){let s,o;if(r===rT(n,t,e,i)>0)for(s=t;s<e;s+=i)o=jg(s,n[s],n[s+1],o);else for(s=e-i;s>=t;s-=i)o=jg(s,n[s],n[s+1],o);return o&&Dl(o,o.next)&&(bo(o),o=o.next),o}function li(n,t){if(!n)return n;t||(t=n);let e=n,i;do if(i=!1,!e.steiner&&(Dl(e,e.next)||te(e.prev,e,e.next)===0)){if(bo(e),e=t=e.prev,e===e.next)break;i=!0}else e=e.next;while(i||e!==t);return t}function wo(n,t,e,i,r,s,o){if(!n)return;!o&&s&&QE(n,i,r,s);let a=n,l,c;for(;n.prev!==n.next;){if(l=n.prev,c=n.next,s?WE(n,i,r,s):GE(n)){t.push(l.i/e),t.push(n.i/e),t.push(c.i/e),bo(n),n=c.next,a=c.next;continue}if(n=c,n===a){o?o===1?(n=qE(li(n),t,e),wo(n,t,e,i,r,s,2)):o===2&&XE(n,t,e,i,r,s):wo(li(n),t,e,i,r,s,1);break}}}function GE(n){let t=n.prev,e=n,i=n.next;if(te(t,e,i)>=0)return!1;let r=n.next.next;for(;r!==n.prev;){if(zr(t.x,t.y,e.x,e.y,i.x,i.y,r.x,r.y)&&te(r.prev,r,r.next)>=0)return!1;r=r.next}return!0}function WE(n,t,e,i){let r=n.prev,s=n,o=n.next;if(te(r,s,o)>=0)return!1;let a=r.x<s.x?r.x<o.x?r.x:o.x:s.x<o.x?s.x:o.x,l=r.y<s.y?r.y<o.y?r.y:o.y:s.y<o.y?s.y:o.y,c=r.x>s.x?r.x>o.x?r.x:o.x:s.x>o.x?s.x:o.x,u=r.y>s.y?r.y>o.y?r.y:o.y:s.y>o.y?s.y:o.y,h=ch(a,l,t,e,i),f=ch(c,u,t,e,i),d=n.prevZ,g=n.nextZ;for(;d&&d.z>=h&&g&&g.z<=f;){if(d!==n.prev&&d!==n.next&&zr(r.x,r.y,s.x,s.y,o.x,o.y,d.x,d.y)&&te(d.prev,d,d.next)>=0||(d=d.prevZ,g!==n.prev&&g!==n.next&&zr(r.x,r.y,s.x,s.y,o.x,o.y,g.x,g.y)&&te(g.prev,g,g.next)>=0))return!1;g=g.nextZ}for(;d&&d.z>=h;){if(d!==n.prev&&d!==n.next&&zr(r.x,r.y,s.x,s.y,o.x,o.y,d.x,d.y)&&te(d.prev,d,d.next)>=0)return!1;d=d.prevZ}for(;g&&g.z<=f;){if(g!==n.prev&&g!==n.next&&zr(r.x,r.y,s.x,s.y,o.x,o.y,g.x,g.y)&&te(g.prev,g,g.next)>=0)return!1;g=g.nextZ}return!0}function qE(n,t,e){let i=n;do{let r=i.prev,s=i.next.next;!Dl(r,s)&&L0(r,i,i.next,s)&&Mo(r,s)&&Mo(s,r)&&(t.push(r.i/e),t.push(i.i/e),t.push(s.i/e),bo(i),bo(i.next),i=n=s),i=i.next}while(i!==n);return li(i)}function XE(n,t,e,i,r,s){let o=n;do{let a=o.next.next;for(;a!==o.prev;){if(o.i!==a.i&&eT(o,a)){let l=P0(o,a);o=li(o,o.next),l=li(l,l.next),wo(o,t,e,i,r,s),wo(l,t,e,i,r,s);return}a=a.next}o=o.next}while(o!==n)}function YE(n,t,e,i){let r=[],s,o,a,l,c;for(s=0,o=t.length;s<o;s++)a=t[s]*i,l=s<o-1?t[s+1]*i:n.length,c=R0(n,a,l,i,!1),c===c.next&&(c.steiner=!0),r.push(tT(c));for(r.sort(ZE),s=0;s<r.length;s++)JE(r[s],e),e=li(e,e.next);return e}function ZE(n,t){return n.x-t.x}function JE(n,t){if(t=$E(n,t),t){let e=P0(t,n);li(t,t.next),li(e,e.next)}}function $E(n,t){let e=t,i=n.x,r=n.y,s=-1/0,o;do{if(r<=e.y&&r>=e.next.y&&e.next.y!==e.y){let f=e.x+(r-e.y)*(e.next.x-e.x)/(e.next.y-e.y);if(f<=i&&f>s){if(s=f,f===i){if(r===e.y)return e;if(r===e.next.y)return e.next}o=e.x<e.next.x?e:e.next}}e=e.next}while(e!==t);if(!o)return null;if(i===s)return o;let a=o,l=o.x,c=o.y,u=1/0,h;e=o;do i>=e.x&&e.x>=l&&i!==e.x&&zr(r<c?i:s,r,l,c,r<c?s:i,r,e.x,e.y)&&(h=Math.abs(r-e.y)/(i-e.x),Mo(e,n)&&(h<u||h===u&&(e.x>o.x||e.x===o.x&&KE(o,e)))&&(o=e,u=h)),e=e.next;while(e!==a);return o}function KE(n,t){return te(n.prev,n,t.prev)<0&&te(t.next,n,n.next)<0}function QE(n,t,e,i){let r=n;do r.z===null&&(r.z=ch(r.x,r.y,t,e,i)),r.prevZ=r.prev,r.nextZ=r.next,r=r.next;while(r!==n);r.prevZ.nextZ=null,r.prevZ=null,jE(r)}function jE(n){let t,e,i,r,s,o,a,l,c=1;do{for(e=n,n=null,s=null,o=0;e;){for(o++,i=e,a=0,t=0;t<c&&(a++,i=i.nextZ,!!i);t++);for(l=c;a>0||l>0&&i;)a!==0&&(l===0||!i||e.z<=i.z)?(r=e,e=e.nextZ,a--):(r=i,i=i.nextZ,l--),s?s.nextZ=r:n=r,r.prevZ=s,s=r;e=i}s.nextZ=null,c*=2}while(o>1);return n}function ch(n,t,e,i,r){return n=32767*(n-e)*r,t=32767*(t-i)*r,n=(n|n<<8)&16711935,n=(n|n<<4)&252645135,n=(n|n<<2)&858993459,n=(n|n<<1)&1431655765,t=(t|t<<8)&16711935,t=(t|t<<4)&252645135,t=(t|t<<2)&858993459,t=(t|t<<1)&1431655765,n|t<<1}function tT(n){let t=n,e=n;do(t.x<e.x||t.x===e.x&&t.y<e.y)&&(e=t),t=t.next;while(t!==n);return e}function zr(n,t,e,i,r,s,o,a){return(r-o)*(t-a)-(n-o)*(s-a)>=0&&(n-o)*(i-a)-(e-o)*(t-a)>=0&&(e-o)*(s-a)-(r-o)*(i-a)>=0}function eT(n,t){return n.next.i!==t.i&&n.prev.i!==t.i&&!nT(n,t)&&(Mo(n,t)&&Mo(t,n)&&iT(n,t)&&(te(n.prev,n,t.prev)||te(n,t.prev,t))||Dl(n,t)&&te(n.prev,n,n.next)>0&&te(t.prev,t,t.next)>0)}function te(n,t,e){return(t.y-n.y)*(e.x-t.x)-(t.x-n.x)*(e.y-t.y)}function Dl(n,t){return n.x===t.x&&n.y===t.y}function L0(n,t,e,i){let r=Za(te(n,t,e)),s=Za(te(n,t,i)),o=Za(te(e,i,n)),a=Za(te(e,i,t));return!!(r!==s&&o!==a||r===0&&Ya(n,e,t)||s===0&&Ya(n,i,t)||o===0&&Ya(e,n,i)||a===0&&Ya(e,t,i))}function Ya(n,t,e){return t.x<=Math.max(n.x,e.x)&&t.x>=Math.min(n.x,e.x)&&t.y<=Math.max(n.y,e.y)&&t.y>=Math.min(n.y,e.y)}function Za(n){return n>0?1:n<0?-1:0}function nT(n,t){let e=n;do{if(e.i!==n.i&&e.next.i!==n.i&&e.i!==t.i&&e.next.i!==t.i&&L0(e,e.next,n,t))return!0;e=e.next}while(e!==n);return!1}function Mo(n,t){return te(n.prev,n,n.next)<0?te(n,t,n.next)>=0&&te(n,n.prev,t)>=0:te(n,t,n.prev)<0||te(n,n.next,t)<0}function iT(n,t){let e=n,i=!1,r=(n.x+t.x)/2,s=(n.y+t.y)/2;do e.y>s!=e.next.y>s&&e.next.y!==e.y&&r<(e.next.x-e.x)*(s-e.y)/(e.next.y-e.y)+e.x&&(i=!i),e=e.next;while(e!==n);return i}function P0(n,t){let e=new uh(n.i,n.x,n.y),i=new uh(t.i,t.x,t.y),r=n.next,s=t.prev;return n.next=t,t.prev=n,e.next=r,r.prev=e,i.next=e,e.prev=i,s.next=i,i.prev=s,i}function jg(n,t,e,i){let r=new uh(n,t,e);return i?(r.next=i.next,r.prev=i,i.next.prev=r,i.next=r):(r.prev=r,r.next=r),r}function bo(n){n.next.prev=n.prev,n.prev.next=n.next,n.prevZ&&(n.prevZ.nextZ=n.nextZ),n.nextZ&&(n.nextZ.prevZ=n.prevZ)}function uh(n,t,e){this.i=n,this.x=t,this.y=e,this.prev=null,this.next=null,this.z=null,this.prevZ=null,this.nextZ=null,this.steiner=!1}function rT(n,t,e,i){let r=0;for(let s=t,o=e-i;s<e;s+=i)r+=(n[o]-n[s])*(n[s+1]+n[o+1]),o=s;return r}var dn=class{static area(t){let e=t.length,i=0;for(let r=e-1,s=0;s<e;r=s++)i+=t[r].x*t[s].y-t[s].x*t[r].y;return i*.5}static isClockWise(t){return dn.area(t)<0}static triangulateShape(t,e){let i=[],r=[],s=[];t0(t),e0(i,t);let o=t.length;e.forEach(t0);for(let l=0;l<e.length;l++)r.push(o),o+=e[l].length,e0(i,e[l]);let a=VE.triangulate(i,r);for(let l=0;l<a.length;l+=3)s.push(a.slice(l,l+3));return s}};function t0(n){let t=n.length;t>2&&n[t-1].equals(n[0])&&n.pop()}function e0(n,t){for(let e=0;e<t.length;e++)n.push(t[e].x),n.push(t[e].y)}var ci=class extends Ht{constructor(t=new Un([new K(.5,.5),new K(-.5,.5),new K(-.5,-.5),new K(.5,-.5)]),e={}){super(),this.type="ExtrudeGeometry",this.parameters={shapes:t,options:e},t=Array.isArray(t)?t:[t];let i=this,r=[],s=[];for(let a=0,l=t.length;a<l;a++){let c=t[a];o(c)}this.setAttribute("position",new ee(r,3)),this.setAttribute("uv",new ee(s,2)),this.computeVertexNormals();function o(a){let l=[],c=e.curveSegments!==void 0?e.curveSegments:12,u=e.steps!==void 0?e.steps:1,h=e.depth!==void 0?e.depth:1,f=e.bevelEnabled!==void 0?e.bevelEnabled:!0,d=e.bevelThickness!==void 0?e.bevelThickness:.2,g=e.bevelSize!==void 0?e.bevelSize:d-.1,x=e.bevelOffset!==void 0?e.bevelOffset:0,v=e.bevelSegments!==void 0?e.bevelSegments:3,m=e.extrudePath,p=e.UVGenerator!==void 0?e.UVGenerator:sT;e.amount!==void 0&&(console.warn("THREE.ExtrudeBufferGeometry: amount has been renamed to depth."),h=e.amount);let b,_=!1,S,L,A,H;m&&(b=m.getSpacedPoints(u),_=!0,f=!1,S=m.computeFrenetFrames(u,!1),L=new T,A=new T,H=new T),f||(v=0,d=0,g=0,x=0);let tt=a.extractPoints(c),X=tt.shape,y=tt.holes;if(!dn.isClockWise(X)){X=X.reverse();for(let C=0,j=y.length;C<j;C++){let J=y[C];dn.isClockWise(J)&&(y[C]=J.reverse())}}let D=dn.triangulateShape(X,y),F=X;for(let C=0,j=y.length;C<j;C++){let J=y[C];X=X.concat(J)}function z(C,j,J){return j||console.error("THREE.ExtrudeGeometry: vec does not exist"),j.clone().multiplyScalar(J).add(C)}let N=X.length,V=D.length;function Q(C,j,J){let it,et,vt,bt=C.x-j.x,It=C.y-j.y,Zt=J.x-C.x,qt=J.y-C.y,E=bt*bt+It*It,w=bt*qt-It*Zt;if(Math.abs(w)>Number.EPSILON){let q=Math.sqrt(E),rt=Math.sqrt(Zt*Zt+qt*qt),gt=j.x-It/q,W=j.y+bt/q,_t=J.x-qt/rt,yt=J.y+Zt/rt,ut=((_t-gt)*qt-(yt-W)*Zt)/(bt*qt-It*Zt);it=gt+bt*ut-C.x,et=W+It*ut-C.y;let ct=it*it+et*et;if(ct<=2)return new K(it,et);vt=Math.sqrt(ct/2)}else{let q=!1;bt>Number.EPSILON?Zt>Number.EPSILON&&(q=!0):bt<-Number.EPSILON?Zt<-Number.EPSILON&&(q=!0):Math.sign(It)===Math.sign(qt)&&(q=!0),q?(it=-It,et=bt,vt=Math.sqrt(E)):(it=bt,et=It,vt=Math.sqrt(E/2))}return new K(it/vt,et/vt)}let at=[];for(let C=0,j=F.length,J=j-1,it=C+1;C<j;C++,J++,it++)J===j&&(J=0),it===j&&(it=0),at[C]=Q(F[C],F[J],F[it]);let G=[],$,lt=at.concat();for(let C=0,j=y.length;C<j;C++){let J=y[C];$=[];for(let it=0,et=J.length,vt=et-1,bt=it+1;it<et;it++,vt++,bt++)vt===et&&(vt=0),bt===et&&(bt=0),$[it]=Q(J[it],J[vt],J[bt]);G.push($),lt=lt.concat($)}for(let C=0;C<v;C++){let j=C/v,J=d*Math.cos(j*Math.PI/2),it=g*Math.sin(j*Math.PI/2)+x;for(let et=0,vt=F.length;et<vt;et++){let bt=z(F[et],at[et],it);mt(bt.x,bt.y,-J)}for(let et=0,vt=y.length;et<vt;et++){let bt=y[et];$=G[et];for(let It=0,Zt=bt.length;It<Zt;It++){let qt=z(bt[It],$[It],it);mt(qt.x,qt.y,-J)}}}let dt=g+x;for(let C=0;C<N;C++){let j=f?z(X[C],lt[C],dt):X[C];_?(A.copy(S.normals[0]).multiplyScalar(j.x),L.copy(S.binormals[0]).multiplyScalar(j.y),H.copy(b[0]).add(A).add(L),mt(H.x,H.y,H.z)):mt(j.x,j.y,0)}for(let C=1;C<=u;C++)for(let j=0;j<N;j++){let J=f?z(X[j],lt[j],dt):X[j];_?(A.copy(S.normals[C]).multiplyScalar(J.x),L.copy(S.binormals[C]).multiplyScalar(J.y),H.copy(b[C]).add(A).add(L),mt(H.x,H.y,H.z)):mt(J.x,J.y,h/u*C)}for(let C=v-1;C>=0;C--){let j=C/v,J=d*Math.cos(j*Math.PI/2),it=g*Math.sin(j*Math.PI/2)+x;for(let et=0,vt=F.length;et<vt;et++){let bt=z(F[et],at[et],it);mt(bt.x,bt.y,h+J)}for(let et=0,vt=y.length;et<vt;et++){let bt=y[et];$=G[et];for(let It=0,Zt=bt.length;It<Zt;It++){let qt=z(bt[It],$[It],it);_?mt(qt.x,qt.y+b[u-1].y,b[u-1].x+J):mt(qt.x,qt.y,h+J)}}}xt(),k();function xt(){let C=r.length/3;if(f){let j=0,J=N*j;for(let it=0;it<V;it++){let et=D[it];St(et[2]+J,et[1]+J,et[0]+J)}j=u+v*2,J=N*j;for(let it=0;it<V;it++){let et=D[it];St(et[0]+J,et[1]+J,et[2]+J)}}else{for(let j=0;j<V;j++){let J=D[j];St(J[2],J[1],J[0])}for(let j=0;j<V;j++){let J=D[j];St(J[0]+N*u,J[1]+N*u,J[2]+N*u)}}i.addGroup(C,r.length/3-C,0)}function k(){let C=r.length/3,j=0;Ft(F,j),j+=F.length;for(let J=0,it=y.length;J<it;J++){let et=y[J];Ft(et,j),j+=et.length}i.addGroup(C,r.length/3-C,1)}function Ft(C,j){let J=C.length;for(;--J>=0;){let it=J,et=J-1;et<0&&(et=C.length-1);for(let vt=0,bt=u+v*2;vt<bt;vt++){let It=N*vt,Zt=N*(vt+1),qt=j+it+It,E=j+et+It,w=j+et+Zt,q=j+it+Zt;B(qt,E,w,q)}}}function mt(C,j,J){l.push(C),l.push(j),l.push(J)}function St(C,j,J){st(C),st(j),st(J);let it=r.length/3,et=p.generateTopUV(i,r,it-3,it-2,it-1);nt(et[0]),nt(et[1]),nt(et[2])}function B(C,j,J,it){st(C),st(j),st(it),st(j),st(J),st(it);let et=r.length/3,vt=p.generateSideWallUV(i,r,et-6,et-3,et-2,et-1);nt(vt[0]),nt(vt[1]),nt(vt[3]),nt(vt[1]),nt(vt[2]),nt(vt[3])}function st(C){r.push(l[C*3+0]),r.push(l[C*3+1]),r.push(l[C*3+2])}function nt(C){s.push(C.x),s.push(C.y)}}}toJSON(){let t=super.toJSON(),e=this.parameters.shapes,i=this.parameters.options;return oT(e,i,t)}static fromJSON(t,e){let i=[];for(let s=0,o=t.shapes.length;s<o;s++){let a=e[t.shapes[s]];i.push(a)}let r=t.options.extrudePath;return r!==void 0&&(t.options.extrudePath=new C0[r.type]().fromJSON(r)),new ci(i,t.options)}},sT={generateTopUV:function(n,t,e,i,r){let s=t[e*3],o=t[e*3+1],a=t[i*3],l=t[i*3+1],c=t[r*3],u=t[r*3+1];return[new K(s,o),new K(a,l),new K(c,u)]},generateSideWallUV:function(n,t,e,i,r,s){let o=t[e*3],a=t[e*3+1],l=t[e*3+2],c=t[i*3],u=t[i*3+1],h=t[i*3+2],f=t[r*3],d=t[r*3+1],g=t[r*3+2],x=t[s*3],v=t[s*3+1],m=t[s*3+2];return Math.abs(a-u)<Math.abs(o-c)?[new K(o,1-l),new K(c,1-h),new K(f,1-g),new K(x,1-m)]:[new K(a,1-l),new K(u,1-h),new K(d,1-g),new K(v,1-m)]}};function oT(n,t,e){if(e.shapes=[],Array.isArray(n))for(let i=0,r=n.length;i<r;i++){let s=n[i];e.shapes.push(s.uuid)}else e.shapes.push(n.uuid);return t.extrudePath!==void 0&&(e.options.extrudePath=t.extrudePath.toJSON()),e}var qi=class extends Ht{constructor(t=new Un([new K(0,.5),new K(-.5,-.5),new K(.5,-.5)]),e=12){super(),this.type="ShapeGeometry",this.parameters={shapes:t,curveSegments:e};let i=[],r=[],s=[],o=[],a=0,l=0;if(Array.isArray(t)===!1)c(t);else for(let u=0;u<t.length;u++)c(t[u]),this.addGroup(a,l,u),a+=l,l=0;this.setIndex(i),this.setAttribute("position",new ee(r,3)),this.setAttribute("normal",new ee(s,3)),this.setAttribute("uv",new ee(o,2));function c(u){let h=r.length/3,f=u.extractPoints(e),d=f.shape,g=f.holes;dn.isClockWise(d)===!1&&(d=d.reverse());for(let v=0,m=g.length;v<m;v++){let p=g[v];dn.isClockWise(p)===!0&&(g[v]=p.reverse())}let x=dn.triangulateShape(d,g);for(let v=0,m=g.length;v<m;v++){let p=g[v];d=d.concat(p)}for(let v=0,m=d.length;v<m;v++){let p=d[v];r.push(p.x,p.y,0),s.push(0,0,1),o.push(p.x,p.y)}for(let v=0,m=x.length;v<m;v++){let p=x[v],b=p[0]+h,_=p[1]+h,S=p[2]+h;i.push(b,_,S),l+=3}}}toJSON(){let t=super.toJSON(),e=this.parameters.shapes;return aT(e,t)}static fromJSON(t,e){let i=[];for(let r=0,s=t.shapes.length;r<s;r++){let o=e[t.shapes[r]];i.push(o)}return new qi(i,t.curveSegments)}};function aT(n,t){if(t.shapes=[],Array.isArray(n))for(let e=0,i=n.length;e<i;e++){let r=n[e];t.shapes.push(r.uuid)}else t.shapes.push(n.uuid);return t}var hh=class extends xe{constructor(t){super(),this.type="ShadowMaterial",this.color=new ft(0),this.transparent=!0,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this}};hh.prototype.isShadowMaterial=!0;var vl=class extends xe{constructor(t){super(),this.defines={STANDARD:""},this.type="MeshStandardMaterial",this.color=new ft(16777215),this.roughness=1,this.metalness=0,this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new ft(0),this.emissiveIntensity=1,this.emissiveMap=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=ts,this.normalScale=new K(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.roughnessMap=null,this.metalnessMap=null,this.alphaMap=null,this.envMap=null,this.envMapIntensity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.flatShading=!1,this.setValues(t)}copy(t){return super.copy(t),this.defines={STANDARD:""},this.color.copy(t.color),this.roughness=t.roughness,this.metalness=t.metalness,this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.roughnessMap=t.roughnessMap,this.metalnessMap=t.metalnessMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.envMapIntensity=t.envMapIntensity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this.flatShading=t.flatShading,this}};vl.prototype.isMeshStandardMaterial=!0;var fh=class extends vl{constructor(t){super(),this.defines={STANDARD:"",PHYSICAL:""},this.type="MeshPhysicalMaterial",this.clearcoatMap=null,this.clearcoatRoughness=0,this.clearcoatRoughnessMap=null,this.clearcoatNormalScale=new K(1,1),this.clearcoatNormalMap=null,this.ior=1.5,Object.defineProperty(this,"reflectivity",{get:function(){return Ie(2.5*(this.ior-1)/(this.ior+1),0,1)},set:function(e){this.ior=(1+.4*e)/(1-.4*e)}}),this.sheenColor=new ft(0),this.sheenColorMap=null,this.sheenRoughness=1,this.sheenRoughnessMap=null,this.transmissionMap=null,this.thickness=0,this.thicknessMap=null,this.attenuationDistance=0,this.attenuationColor=new ft(1,1,1),this.specularIntensity=1,this.specularIntensityMap=null,this.specularColor=new ft(1,1,1),this.specularColorMap=null,this._sheen=0,this._clearcoat=0,this._transmission=0,this.setValues(t)}get sheen(){return this._sheen}set sheen(t){this._sheen>0!=t>0&&this.version++,this._sheen=t}get clearcoat(){return this._clearcoat}set clearcoat(t){this._clearcoat>0!=t>0&&this.version++,this._clearcoat=t}get transmission(){return this._transmission}set transmission(t){this._transmission>0!=t>0&&this.version++,this._transmission=t}copy(t){return super.copy(t),this.defines={STANDARD:"",PHYSICAL:""},this.clearcoat=t.clearcoat,this.clearcoatMap=t.clearcoatMap,this.clearcoatRoughness=t.clearcoatRoughness,this.clearcoatRoughnessMap=t.clearcoatRoughnessMap,this.clearcoatNormalMap=t.clearcoatNormalMap,this.clearcoatNormalScale.copy(t.clearcoatNormalScale),this.ior=t.ior,this.sheen=t.sheen,this.sheenColor.copy(t.sheenColor),this.sheenColorMap=t.sheenColorMap,this.sheenRoughness=t.sheenRoughness,this.sheenRoughnessMap=t.sheenRoughnessMap,this.transmission=t.transmission,this.transmissionMap=t.transmissionMap,this.thickness=t.thickness,this.thicknessMap=t.thicknessMap,this.attenuationDistance=t.attenuationDistance,this.attenuationColor.copy(t.attenuationColor),this.specularIntensity=t.specularIntensity,this.specularIntensityMap=t.specularIntensityMap,this.specularColor.copy(t.specularColor),this.specularColorMap=t.specularColorMap,this}};fh.prototype.isMeshPhysicalMaterial=!0;var dh=class extends xe{constructor(t){super(),this.type="MeshPhongMaterial",this.color=new ft(16777215),this.specular=new ft(1118481),this.shininess=30,this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new ft(0),this.emissiveIntensity=1,this.emissiveMap=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=ts,this.normalScale=new K(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.specularMap=null,this.alphaMap=null,this.envMap=null,this.combine=Cl,this.reflectivity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.flatShading=!1,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.specular.copy(t.specular),this.shininess=t.shininess,this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.specularMap=t.specularMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.combine=t.combine,this.reflectivity=t.reflectivity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this.flatShading=t.flatShading,this}};dh.prototype.isMeshPhongMaterial=!0;var ph=class extends xe{constructor(t){super(),this.defines={TOON:""},this.type="MeshToonMaterial",this.color=new ft(16777215),this.map=null,this.gradientMap=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new ft(0),this.emissiveIntensity=1,this.emissiveMap=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=ts,this.normalScale=new K(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.alphaMap=null,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.gradientMap=t.gradientMap,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.alphaMap=t.alphaMap,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this}};ph.prototype.isMeshToonMaterial=!0;var mh=class extends xe{constructor(t){super(),this.type="MeshNormalMaterial",this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=ts,this.normalScale=new K(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.wireframe=!1,this.wireframeLinewidth=1,this.fog=!1,this.flatShading=!1,this.setValues(t)}copy(t){return super.copy(t),this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.flatShading=t.flatShading,this}};mh.prototype.isMeshNormalMaterial=!0;var gh=class extends xe{constructor(t){super(),this.type="MeshLambertMaterial",this.color=new ft(16777215),this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new ft(0),this.emissiveIntensity=1,this.emissiveMap=null,this.specularMap=null,this.alphaMap=null,this.envMap=null,this.combine=Cl,this.reflectivity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.specularMap=t.specularMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.combine=t.combine,this.reflectivity=t.reflectivity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this}};gh.prototype.isMeshLambertMaterial=!0;var xh=class extends xe{constructor(t){super(),this.defines={MATCAP:""},this.type="MeshMatcapMaterial",this.color=new ft(16777215),this.matcap=null,this.map=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=ts,this.normalScale=new K(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.alphaMap=null,this.flatShading=!1,this.setValues(t)}copy(t){return super.copy(t),this.defines={MATCAP:""},this.color.copy(t.color),this.matcap=t.matcap,this.map=t.map,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.alphaMap=t.alphaMap,this.flatShading=t.flatShading,this}};xh.prototype.isMeshMatcapMaterial=!0;var yh=class extends zn{constructor(t){super(),this.type="LineDashedMaterial",this.scale=1,this.dashSize=3,this.gapSize=1,this.setValues(t)}copy(t){return super.copy(t),this.scale=t.scale,this.dashSize=t.dashSize,this.gapSize=t.gapSize,this}};yh.prototype.isLineDashedMaterial=!0;var Kt={arraySlice:function(n,t,e){return Kt.isTypedArray(n)?new n.constructor(n.subarray(t,e!==void 0?e:n.length)):n.slice(t,e)},convertArray:function(n,t,e){return!n||!e&&n.constructor===t?n:typeof t.BYTES_PER_ELEMENT=="number"?new t(n):Array.prototype.slice.call(n)},isTypedArray:function(n){return ArrayBuffer.isView(n)&&!(n instanceof DataView)},getKeyframeOrder:function(n){function t(r,s){return n[r]-n[s]}let e=n.length,i=new Array(e);for(let r=0;r!==e;++r)i[r]=r;return i.sort(t),i},sortedArray:function(n,t,e){let i=n.length,r=new n.constructor(i);for(let s=0,o=0;o!==i;++s){let a=e[s]*t;for(let l=0;l!==t;++l)r[o++]=n[a+l]}return r},flattenJSON:function(n,t,e,i){let r=1,s=n[0];for(;s!==void 0&&s[i]===void 0;)s=n[r++];if(s===void 0)return;let o=s[i];if(o!==void 0)if(Array.isArray(o))do o=s[i],o!==void 0&&(t.push(s.time),e.push.apply(e,o)),s=n[r++];while(s!==void 0);else if(o.toArray!==void 0)do o=s[i],o!==void 0&&(t.push(s.time),o.toArray(e,e.length)),s=n[r++];while(s!==void 0);else do o=s[i],o!==void 0&&(t.push(s.time),e.push(o)),s=n[r++];while(s!==void 0)},subclip:function(n,t,e,i,r=30){let s=n.clone();s.name=t;let o=[];for(let l=0;l<s.tracks.length;++l){let c=s.tracks[l],u=c.getValueSize(),h=[],f=[];for(let d=0;d<c.times.length;++d){let g=c.times[d]*r;if(!(g<e||g>=i)){h.push(c.times[d]);for(let x=0;x<u;++x)f.push(c.values[d*u+x])}}h.length!==0&&(c.times=Kt.convertArray(h,c.times.constructor),c.values=Kt.convertArray(f,c.values.constructor),o.push(c))}s.tracks=o;let a=1/0;for(let l=0;l<s.tracks.length;++l)a>s.tracks[l].times[0]&&(a=s.tracks[l].times[0]);for(let l=0;l<s.tracks.length;++l)s.tracks[l].shift(-1*a);return s.resetDuration(),s},makeClipAdditive:function(n,t=0,e=n,i=30){i<=0&&(i=30);let r=e.tracks.length,s=t/i;for(let o=0;o<r;++o){let a=e.tracks[o],l=a.ValueTypeName;if(l==="bool"||l==="string")continue;let c=n.tracks.find(function(m){return m.name===a.name&&m.ValueTypeName===l});if(c===void 0)continue;let u=0,h=a.getValueSize();a.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline&&(u=h/3);let f=0,d=c.getValueSize();c.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline&&(f=d/3);let g=a.times.length-1,x;if(s<=a.times[0]){let m=u,p=h-u;x=Kt.arraySlice(a.values,m,p)}else if(s>=a.times[g]){let m=g*h+u,p=m+h-u;x=Kt.arraySlice(a.values,m,p)}else{let m=a.createInterpolant(),p=u,b=h-u;m.evaluate(s),x=Kt.arraySlice(m.resultBuffer,p,b)}l==="quaternion"&&new Ee().fromArray(x).normalize().conjugate().toArray(x);let v=c.times.length;for(let m=0;m<v;++m){let p=m*d+f;if(l==="quaternion")Ee.multiplyQuaternionsFlat(c.values,p,x,0,c.values,p);else{let b=d-f*2;for(let _=0;_<b;++_)c.values[p+_]-=x[_]}}}return n.blendMode=d0,n}},pn=class{constructor(t,e,i,r){this.parameterPositions=t,this._cachedIndex=0,this.resultBuffer=r!==void 0?r:new e.constructor(i),this.sampleValues=e,this.valueSize=i,this.settings=null,this.DefaultSettings_={}}evaluate(t){let e=this.parameterPositions,i=this._cachedIndex,r=e[i],s=e[i-1];t:{e:{let o;n:{i:if(!(t<r)){for(let a=i+2;;){if(r===void 0){if(t<s)break i;return i=e.length,this._cachedIndex=i,this.afterEnd_(i-1,t,s)}if(i===a)break;if(s=r,r=e[++i],t<r)break e}o=e.length;break n}if(!(t>=s)){let a=e[1];t<a&&(i=2,s=a);for(let l=i-2;;){if(s===void 0)return this._cachedIndex=0,this.beforeStart_(0,t,r);if(i===l)break;if(r=s,s=e[--i-1],t>=s)break e}o=i,i=0;break n}break t}for(;i<o;){let a=i+o>>>1;t<e[a]?o=a:i=a+1}if(r=e[i],s=e[i-1],s===void 0)return this._cachedIndex=0,this.beforeStart_(0,t,r);if(r===void 0)return i=e.length,this._cachedIndex=i,this.afterEnd_(i-1,s,t)}this._cachedIndex=i,this.intervalChanged_(i,s,r)}return this.interpolate_(i,s,t,r)}getSettings_(){return this.settings||this.DefaultSettings_}copySampleValue_(t){let e=this.resultBuffer,i=this.sampleValues,r=this.valueSize,s=t*r;for(let o=0;o!==r;++o)e[o]=i[s+o];return e}interpolate_(){throw new Error("call to abstract method")}intervalChanged_(){}};pn.prototype.beforeStart_=pn.prototype.copySampleValue_;pn.prototype.afterEnd_=pn.prototype.copySampleValue_;var vh=class extends pn{constructor(t,e,i,r){super(t,e,i,r),this._weightPrev=-0,this._offsetPrev=-0,this._weightNext=-0,this._offsetNext=-0,this.DefaultSettings_={endingStart:Nr,endingEnd:Nr}}intervalChanged_(t,e,i){let r=this.parameterPositions,s=t-2,o=t+1,a=r[s],l=r[o];if(a===void 0)switch(this.getSettings_().endingStart){case Fr:s=t,a=2*e-i;break;case el:s=r.length-2,a=e+r[s]-r[s+1];break;default:s=t,a=i}if(l===void 0)switch(this.getSettings_().endingEnd){case Fr:o=t,l=2*i-e;break;case el:o=1,l=i+r[1]-r[0];break;default:o=t-1,l=e}let c=(i-e)*.5,u=this.valueSize;this._weightPrev=c/(e-a),this._weightNext=c/(l-i),this._offsetPrev=s*u,this._offsetNext=o*u}interpolate_(t,e,i,r){let s=this.resultBuffer,o=this.sampleValues,a=this.valueSize,l=t*a,c=l-a,u=this._offsetPrev,h=this._offsetNext,f=this._weightPrev,d=this._weightNext,g=(i-e)/(r-e),x=g*g,v=x*g,m=-f*v+2*f*x-f*g,p=(1+f)*v+(-1.5-2*f)*x+(-.5+f)*g+1,b=(-1-d)*v+(1.5+d)*x+.5*g,_=d*v-d*x;for(let S=0;S!==a;++S)s[S]=m*o[u+S]+p*o[c+S]+b*o[l+S]+_*o[h+S];return s}},_l=class extends pn{constructor(t,e,i,r){super(t,e,i,r)}interpolate_(t,e,i,r){let s=this.resultBuffer,o=this.sampleValues,a=this.valueSize,l=t*a,c=l-a,u=(i-e)/(r-e),h=1-u;for(let f=0;f!==a;++f)s[f]=o[c+f]*h+o[l+f]*u;return s}},_h=class extends pn{constructor(t,e,i,r){super(t,e,i,r)}interpolate_(t){return this.copySampleValue_(t-1)}},Xe=class{constructor(t,e,i,r){if(t===void 0)throw new Error("THREE.KeyframeTrack: track name is undefined");if(e===void 0||e.length===0)throw new Error("THREE.KeyframeTrack: no keyframes in track named "+t);this.name=t,this.times=Kt.convertArray(e,this.TimeBufferType),this.values=Kt.convertArray(i,this.ValueBufferType),this.setInterpolation(r||this.DefaultInterpolation)}static toJSON(t){let e=t.constructor,i;if(e.toJSON!==this.toJSON)i=e.toJSON(t);else{i={name:t.name,times:Kt.convertArray(t.times,Array),values:Kt.convertArray(t.values,Array)};let r=t.getInterpolation();r!==t.DefaultInterpolation&&(i.interpolation=r)}return i.type=t.ValueTypeName,i}InterpolantFactoryMethodDiscrete(t){return new _h(this.times,this.values,this.getValueSize(),t)}InterpolantFactoryMethodLinear(t){return new _l(this.times,this.values,this.getValueSize(),t)}InterpolantFactoryMethodSmooth(t){return new vh(this.times,this.values,this.getValueSize(),t)}setInterpolation(t){let e;switch(t){case ja:e=this.InterpolantFactoryMethodDiscrete;break;case tl:e=this.InterpolantFactoryMethodLinear;break;case eu:e=this.InterpolantFactoryMethodSmooth;break}if(e===void 0){let i="unsupported interpolation for "+this.ValueTypeName+" keyframe track named "+this.name;if(this.createInterpolant===void 0)if(t!==this.DefaultInterpolation)this.setInterpolation(this.DefaultInterpolation);else throw new Error(i);return console.warn("THREE.KeyframeTrack:",i),this}return this.createInterpolant=e,this}getInterpolation(){switch(this.createInterpolant){case this.InterpolantFactoryMethodDiscrete:return ja;case this.InterpolantFactoryMethodLinear:return tl;case this.InterpolantFactoryMethodSmooth:return eu}}getValueSize(){return this.values.length/this.times.length}shift(t){if(t!==0){let e=this.times;for(let i=0,r=e.length;i!==r;++i)e[i]+=t}return this}scale(t){if(t!==1){let e=this.times;for(let i=0,r=e.length;i!==r;++i)e[i]*=t}return this}trim(t,e){let i=this.times,r=i.length,s=0,o=r-1;for(;s!==r&&i[s]<t;)++s;for(;o!==-1&&i[o]>e;)--o;if(++o,s!==0||o!==r){s>=o&&(o=Math.max(o,1),s=o-1);let a=this.getValueSize();this.times=Kt.arraySlice(i,s,o),this.values=Kt.arraySlice(this.values,s*a,o*a)}return this}validate(){let t=!0,e=this.getValueSize();e-Math.floor(e)!==0&&(console.error("THREE.KeyframeTrack: Invalid value size in track.",this),t=!1);let i=this.times,r=this.values,s=i.length;s===0&&(console.error("THREE.KeyframeTrack: Track is empty.",this),t=!1);let o=null;for(let a=0;a!==s;a++){let l=i[a];if(typeof l=="number"&&isNaN(l)){console.error("THREE.KeyframeTrack: Time is not a valid number.",this,a,l),t=!1;break}if(o!==null&&o>l){console.error("THREE.KeyframeTrack: Out of order keys.",this,a,l,o),t=!1;break}o=l}if(r!==void 0&&Kt.isTypedArray(r))for(let a=0,l=r.length;a!==l;++a){let c=r[a];if(isNaN(c)){console.error("THREE.KeyframeTrack: Value is not a valid number.",this,a,c),t=!1;break}}return t}optimize(){let t=Kt.arraySlice(this.times),e=Kt.arraySlice(this.values),i=this.getValueSize(),r=this.getInterpolation()===eu,s=t.length-1,o=1;for(let a=1;a<s;++a){let l=!1,c=t[a],u=t[a+1];if(c!==u&&(a!==1||c!==t[0]))if(r)l=!0;else{let h=a*i,f=h-i,d=h+i;for(let g=0;g!==i;++g){let x=e[h+g];if(x!==e[f+g]||x!==e[d+g]){l=!0;break}}}if(l){if(a!==o){t[o]=t[a];let h=a*i,f=o*i;for(let d=0;d!==i;++d)e[f+d]=e[h+d]}++o}}if(s>0){t[o]=t[s];for(let a=s*i,l=o*i,c=0;c!==i;++c)e[l+c]=e[a+c];++o}return o!==t.length?(this.times=Kt.arraySlice(t,0,o),this.values=Kt.arraySlice(e,0,o*i)):(this.times=t,this.values=e),this}clone(){let t=Kt.arraySlice(this.times,0),e=Kt.arraySlice(this.values,0),i=this.constructor,r=new i(this.name,t,e);return r.createInterpolant=this.createInterpolant,r}};Xe.prototype.TimeBufferType=Float32Array;Xe.prototype.ValueBufferType=Float32Array;Xe.prototype.DefaultInterpolation=tl;var ui=class extends Xe{};ui.prototype.ValueTypeName="bool";ui.prototype.ValueBufferType=Array;ui.prototype.DefaultInterpolation=ja;ui.prototype.InterpolantFactoryMethodLinear=void 0;ui.prototype.InterpolantFactoryMethodSmooth=void 0;var wl=class extends Xe{};wl.prototype.ValueTypeName="color";var Kr=class extends Xe{};Kr.prototype.ValueTypeName="number";var wh=class extends pn{constructor(t,e,i,r){super(t,e,i,r)}interpolate_(t,e,i,r){let s=this.resultBuffer,o=this.sampleValues,a=this.valueSize,l=(i-e)/(r-e),c=t*a;for(let u=c+a;c!==u;c+=4)Ee.slerpFlat(s,0,o,c-a,o,c,l);return s}},Xi=class extends Xe{InterpolantFactoryMethodLinear(t){return new wh(this.times,this.values,this.getValueSize(),t)}};Xi.prototype.ValueTypeName="quaternion";Xi.prototype.DefaultInterpolation=tl;Xi.prototype.InterpolantFactoryMethodSmooth=void 0;var hi=class extends Xe{};hi.prototype.ValueTypeName="string";hi.prototype.ValueBufferType=Array;hi.prototype.DefaultInterpolation=ja;hi.prototype.InterpolantFactoryMethodLinear=void 0;hi.prototype.InterpolantFactoryMethodSmooth=void 0;var Qr=class extends Xe{};Qr.prototype.ValueTypeName="vector";var Ml=class{constructor(t,e=-1,i,r=Qh){this.name=t,this.tracks=i,this.duration=e,this.blendMode=r,this.uuid=tn(),this.duration<0&&this.resetDuration()}static parse(t){let e=[],i=t.tracks,r=1/(t.fps||1);for(let o=0,a=i.length;o!==a;++o)e.push(cT(i[o]).scale(r));let s=new this(t.name,t.duration,e,t.blendMode);return s.uuid=t.uuid,s}static toJSON(t){let e=[],i=t.tracks,r={name:t.name,duration:t.duration,tracks:e,uuid:t.uuid,blendMode:t.blendMode};for(let s=0,o=i.length;s!==o;++s)e.push(Xe.toJSON(i[s]));return r}static CreateFromMorphTargetSequence(t,e,i,r){let s=e.length,o=[];for(let a=0;a<s;a++){let l=[],c=[];l.push((a+s-1)%s,a,(a+1)%s),c.push(0,1,0);let u=Kt.getKeyframeOrder(l);l=Kt.sortedArray(l,1,u),c=Kt.sortedArray(c,1,u),!r&&l[0]===0&&(l.push(s),c.push(c[0])),o.push(new Kr(".morphTargetInfluences["+e[a].name+"]",l,c).scale(1/i))}return new this(t,-1,o)}static findByName(t,e){let i=t;if(!Array.isArray(t)){let r=t;i=r.geometry&&r.geometry.animations||r.animations}for(let r=0;r<i.length;r++)if(i[r].name===e)return i[r];return null}static CreateClipsFromMorphTargetSequences(t,e,i){let r={},s=/^([\w-]*?)([\d]+)$/;for(let a=0,l=t.length;a<l;a++){let c=t[a],u=c.name.match(s);if(u&&u.length>1){let h=u[1],f=r[h];f||(r[h]=f=[]),f.push(c)}}let o=[];for(let a in r)o.push(this.CreateFromMorphTargetSequence(a,r[a],e,i));return o}static parseAnimation(t,e){if(!t)return console.error("THREE.AnimationClip: No animation in JSONLoader data."),null;let i=function(h,f,d,g,x){if(d.length!==0){let v=[],m=[];Kt.flattenJSON(d,v,m,g),v.length!==0&&x.push(new h(f,v,m))}},r=[],s=t.name||"default",o=t.fps||30,a=t.blendMode,l=t.length||-1,c=t.hierarchy||[];for(let h=0;h<c.length;h++){let f=c[h].keys;if(!(!f||f.length===0))if(f[0].morphTargets){let d={},g;for(g=0;g<f.length;g++)if(f[g].morphTargets)for(let x=0;x<f[g].morphTargets.length;x++)d[f[g].morphTargets[x]]=-1;for(let x in d){let v=[],m=[];for(let p=0;p!==f[g].morphTargets.length;++p){let b=f[g];v.push(b.time),m.push(b.morphTarget===x?1:0)}r.push(new Kr(".morphTargetInfluence["+x+"]",v,m))}l=d.length*(o||1)}else{let d=".bones["+e[h].name+"]";i(Qr,d+".position",f,"pos",r),i(Xi,d+".quaternion",f,"rot",r),i(Qr,d+".scale",f,"scl",r)}}return r.length===0?null:new this(s,l,r,a)}resetDuration(){let t=this.tracks,e=0;for(let i=0,r=t.length;i!==r;++i){let s=this.tracks[i];e=Math.max(e,s.times[s.times.length-1])}return this.duration=e,this}trim(){for(let t=0;t<this.tracks.length;t++)this.tracks[t].trim(0,this.duration);return this}validate(){let t=!0;for(let e=0;e<this.tracks.length;e++)t=t&&this.tracks[e].validate();return t}optimize(){for(let t=0;t<this.tracks.length;t++)this.tracks[t].optimize();return this}clone(){let t=[];for(let e=0;e<this.tracks.length;e++)t.push(this.tracks[e].clone());return new this.constructor(this.name,this.duration,t,this.blendMode)}toJSON(){return this.constructor.toJSON(this)}};function lT(n){switch(n.toLowerCase()){case"scalar":case"double":case"float":case"number":case"integer":return Kr;case"vector":case"vector2":case"vector3":case"vector4":return Qr;case"color":return wl;case"quaternion":return Xi;case"bool":case"boolean":return ui;case"string":return hi}throw new Error("THREE.KeyframeTrack: Unsupported typeName: "+n)}function cT(n){if(n.type===void 0)throw new Error("THREE.KeyframeTrack: track type undefined, can not parse");let t=lT(n.type);if(n.times===void 0){let e=[],i=[];Kt.flattenJSON(n.keys,e,i,"value"),n.times=e,n.values=i}return t.parse!==void 0?t.parse(n):new t(n.name,n.times,n.values,n.interpolation)}var jr={enabled:!1,files:{},add:function(n,t){this.enabled!==!1&&(this.files[n]=t)},get:function(n){if(this.enabled!==!1)return this.files[n]},remove:function(n){delete this.files[n]},clear:function(){this.files={}}},Mh=class{constructor(t,e,i){let r=this,s=!1,o=0,a=0,l,c=[];this.onStart=void 0,this.onLoad=t,this.onProgress=e,this.onError=i,this.itemStart=function(u){a++,s===!1&&r.onStart!==void 0&&r.onStart(u,o,a),s=!0},this.itemEnd=function(u){o++,r.onProgress!==void 0&&r.onProgress(u,o,a),o===a&&(s=!1,r.onLoad!==void 0&&r.onLoad())},this.itemError=function(u){r.onError!==void 0&&r.onError(u)},this.resolveURL=function(u){return l?l(u):u},this.setURLModifier=function(u){return l=u,this},this.addHandler=function(u,h){return c.push(u,h),this},this.removeHandler=function(u){let h=c.indexOf(u);return h!==-1&&c.splice(h,2),this},this.getHandler=function(u){for(let h=0,f=c.length;h<f;h+=2){let d=c[h],g=c[h+1];if(d.global&&(d.lastIndex=0),d.test(u))return g}return null}}},uT=new Mh,mn=class{constructor(t){this.manager=t!==void 0?t:uT,this.crossOrigin="anonymous",this.withCredentials=!1,this.path="",this.resourcePath="",this.requestHeader={}}load(){}loadAsync(t,e){let i=this;return new Promise(function(r,s){i.load(t,r,e,s)})}parse(){}setCrossOrigin(t){return this.crossOrigin=t,this}setWithCredentials(t){return this.withCredentials=t,this}setPath(t){return this.path=t,this}setResourcePath(t){return this.resourcePath=t,this}setRequestHeader(t){return this.requestHeader=t,this}},Dn={},bh=class extends mn{constructor(t){super(t)}load(t,e,i,r){t===void 0&&(t=""),this.path!==void 0&&(t=this.path+t),t=this.manager.resolveURL(t);let s=jr.get(t);if(s!==void 0)return this.manager.itemStart(t),setTimeout(()=>{e&&e(s),this.manager.itemEnd(t)},0),s;if(Dn[t]!==void 0){Dn[t].push({onLoad:e,onProgress:i,onError:r});return}Dn[t]=[],Dn[t].push({onLoad:e,onProgress:i,onError:r});let o=new Request(t,{headers:new Headers(this.requestHeader),credentials:this.withCredentials?"include":"same-origin"}),a=this.mimeType,l=this.responseType;fetch(o).then(c=>{if(c.status===200||c.status===0){if(c.status===0&&console.warn("THREE.FileLoader: HTTP Status 0 received."),typeof ReadableStream=="undefined"||c.body.getReader===void 0)return c;let u=Dn[t],h=c.body.getReader(),f=c.headers.get("Content-Length"),d=f?parseInt(f):0,g=d!==0,x=0,v=new ReadableStream({start(m){p();function p(){h.read().then(({done:b,value:_})=>{if(b)m.close();else{x+=_.byteLength;let S=new ProgressEvent("progress",{lengthComputable:g,loaded:x,total:d});for(let L=0,A=u.length;L<A;L++){let H=u[L];H.onProgress&&H.onProgress(S)}m.enqueue(_),p()}})}}});return new Response(v)}else throw Error(`fetch for "${c.url}" responded with ${c.status}: ${c.statusText}`)}).then(c=>{switch(l){case"arraybuffer":return c.arrayBuffer();case"blob":return c.blob();case"document":return c.text().then(u=>new DOMParser().parseFromString(u,a));case"json":return c.json();default:if(a===void 0)return c.text();{let h=/charset="?([^;"\s]*)"?/i.exec(a),f=h&&h[1]?h[1].toLowerCase():void 0,d=new TextDecoder(f);return c.arrayBuffer().then(g=>d.decode(g))}}}).then(c=>{jr.add(t,c);let u=Dn[t];delete Dn[t];for(let h=0,f=u.length;h<f;h++){let d=u[h];d.onLoad&&d.onLoad(c)}}).catch(c=>{let u=Dn[t];if(u===void 0)throw this.manager.itemError(t),c;delete Dn[t];for(let h=0,f=u.length;h<f;h++){let d=u[h];d.onError&&d.onError(c)}this.manager.itemError(t)}).finally(()=>{this.manager.itemEnd(t)}),this.manager.itemStart(t)}setResponseType(t){return this.responseType=t,this}setMimeType(t){return this.mimeType=t,this}};var bl=class extends mn{constructor(t){super(t)}load(t,e,i,r){this.path!==void 0&&(t=this.path+t),t=this.manager.resolveURL(t);let s=this,o=jr.get(t);if(o!==void 0)return s.manager.itemStart(t),setTimeout(function(){e&&e(o),s.manager.itemEnd(t)},0),o;let a=ro("img");function l(){u(),jr.add(t,this),e&&e(this),s.manager.itemEnd(t)}function c(h){u(),r&&r(h),s.manager.itemError(t),s.manager.itemEnd(t)}function u(){a.removeEventListener("load",l,!1),a.removeEventListener("error",c,!1)}return a.addEventListener("load",l,!1),a.addEventListener("error",c,!1),t.substr(0,5)!=="data:"&&this.crossOrigin!==void 0&&(a.crossOrigin=this.crossOrigin),s.manager.itemStart(t),a.src=t,a}},Sh=class extends mn{constructor(t){super(t)}load(t,e,i,r){let s=new Wr,o=new bl(this.manager);o.setCrossOrigin(this.crossOrigin),o.setPath(this.path);let a=0;function l(c){o.load(t[c],function(u){s.images[c]=u,a++,a===6&&(s.needsUpdate=!0,e&&e(s))},void 0,r)}for(let c=0;c<t.length;++c)l(c);return s}};var Eh=class extends mn{constructor(t){super(t)}load(t,e,i,r){let s=new ae,o=new bl(this.manager);return o.setCrossOrigin(this.crossOrigin),o.setPath(this.path),o.load(t,function(a){s.image=a,s.needsUpdate=!0,e!==void 0&&e(s)},i,r),s}},Ye=class extends kt{constructor(t,e=1){super(),this.type="Light",this.color=new ft(t),this.intensity=e}dispose(){}copy(t){return super.copy(t),this.color.copy(t.color),this.intensity=t.intensity,this}toJSON(t){let e=super.toJSON(t);return e.object.color=this.color.getHex(),e.object.intensity=this.intensity,this.groundColor!==void 0&&(e.object.groundColor=this.groundColor.getHex()),this.distance!==void 0&&(e.object.distance=this.distance),this.angle!==void 0&&(e.object.angle=this.angle),this.decay!==void 0&&(e.object.decay=this.decay),this.penumbra!==void 0&&(e.object.penumbra=this.penumbra),this.shadow!==void 0&&(e.object.shadow=this.shadow.toJSON()),e}};Ye.prototype.isLight=!0;var Th=class extends Ye{constructor(t,e,i){super(t,i),this.type="HemisphereLight",this.position.copy(kt.DefaultUp),this.updateMatrix(),this.groundColor=new ft(e)}copy(t){return Ye.prototype.copy.call(this,t),this.groundColor.copy(t.groundColor),this}};Th.prototype.isHemisphereLight=!0;var n0=new wt,i0=new T,r0=new T,So=class{constructor(t){this.camera=t,this.bias=0,this.normalBias=0,this.radius=1,this.blurSamples=8,this.mapSize=new K(512,512),this.map=null,this.mapPass=null,this.matrix=new wt,this.autoUpdate=!0,this.needsUpdate=!1,this._frustum=new qr,this._frameExtents=new K(1,1),this._viewportCount=1,this._viewports=[new Wt(0,0,1,1)]}getViewportCount(){return this._viewportCount}getFrustum(){return this._frustum}updateMatrices(t){let e=this.camera,i=this.matrix;i0.setFromMatrixPosition(t.matrixWorld),e.position.copy(i0),r0.setFromMatrixPosition(t.target.matrixWorld),e.lookAt(r0),e.updateMatrixWorld(),n0.multiplyMatrices(e.projectionMatrix,e.matrixWorldInverse),this._frustum.setFromProjectionMatrix(n0),i.set(.5,0,0,.5,0,.5,0,.5,0,0,.5,.5,0,0,0,1),i.multiply(e.projectionMatrix),i.multiply(e.matrixWorldInverse)}getViewport(t){return this._viewports[t]}getFrameExtents(){return this._frameExtents}dispose(){this.map&&this.map.dispose(),this.mapPass&&this.mapPass.dispose()}copy(t){return this.camera=t.camera.clone(),this.bias=t.bias,this.radius=t.radius,this.mapSize.copy(t.mapSize),this}clone(){return new this.constructor().copy(this)}toJSON(){let t={};return this.bias!==0&&(t.bias=this.bias),this.normalBias!==0&&(t.normalBias=this.normalBias),this.radius!==1&&(t.radius=this.radius),(this.mapSize.x!==512||this.mapSize.y!==512)&&(t.mapSize=this.mapSize.toArray()),t.camera=this.camera.toJSON(!1).object,delete t.camera.matrix,t}},Sl=class extends So{constructor(){super(new Se(50,1,.5,500)),this.focus=1}updateMatrices(t){let e=this.camera,i=Vu*2*t.angle*this.focus,r=this.mapSize.width/this.mapSize.height,s=t.distance||e.far;(i!==e.fov||r!==e.aspect||s!==e.far)&&(e.fov=i,e.aspect=r,e.far=s,e.updateProjectionMatrix()),super.updateMatrices(t)}copy(t){return super.copy(t),this.focus=t.focus,this}};Sl.prototype.isSpotLightShadow=!0;var Ah=class extends Ye{constructor(t,e,i=0,r=Math.PI/3,s=0,o=1){super(t,e),this.type="SpotLight",this.position.copy(kt.DefaultUp),this.updateMatrix(),this.target=new kt,this.distance=i,this.angle=r,this.penumbra=s,this.decay=o,this.shadow=new Sl}get power(){return this.intensity*Math.PI}set power(t){this.intensity=t/Math.PI}dispose(){this.shadow.dispose()}copy(t){return super.copy(t),this.distance=t.distance,this.angle=t.angle,this.penumbra=t.penumbra,this.decay=t.decay,this.target=t.target.clone(),this.shadow=t.shadow.clone(),this}};Ah.prototype.isSpotLight=!0;var s0=new wt,Zs=new T,Nu=new T,El=class extends So{constructor(){super(new Se(90,1,.5,500)),this._frameExtents=new K(4,2),this._viewportCount=6,this._viewports=[new Wt(2,1,1,1),new Wt(0,1,1,1),new Wt(3,1,1,1),new Wt(1,1,1,1),new Wt(3,0,1,1),new Wt(1,0,1,1)],this._cubeDirections=[new T(1,0,0),new T(-1,0,0),new T(0,0,1),new T(0,0,-1),new T(0,1,0),new T(0,-1,0)],this._cubeUps=[new T(0,1,0),new T(0,1,0),new T(0,1,0),new T(0,1,0),new T(0,0,1),new T(0,0,-1)]}updateMatrices(t,e=0){let i=this.camera,r=this.matrix,s=t.distance||i.far;s!==i.far&&(i.far=s,i.updateProjectionMatrix()),Zs.setFromMatrixPosition(t.matrixWorld),i.position.copy(Zs),Nu.copy(i.position),Nu.add(this._cubeDirections[e]),i.up.copy(this._cubeUps[e]),i.lookAt(Nu),i.updateMatrixWorld(),r.makeTranslation(-Zs.x,-Zs.y,-Zs.z),s0.multiplyMatrices(i.projectionMatrix,i.matrixWorldInverse),this._frustum.setFromProjectionMatrix(s0)}};El.prototype.isPointLightShadow=!0;var Ch=class extends Ye{constructor(t,e,i=0,r=1){super(t,e),this.type="PointLight",this.distance=i,this.decay=r,this.shadow=new El}get power(){return this.intensity*4*Math.PI}set power(t){this.intensity=t/(4*Math.PI)}dispose(){this.shadow.dispose()}copy(t){return super.copy(t),this.distance=t.distance,this.decay=t.decay,this.shadow=t.shadow.clone(),this}};Ch.prototype.isPointLight=!0;var Tl=class extends So{constructor(){super(new Vi(-5,5,5,-5,.5,500))}};Tl.prototype.isDirectionalLightShadow=!0;var Rh=class extends Ye{constructor(t,e){super(t,e),this.type="DirectionalLight",this.position.copy(kt.DefaultUp),this.updateMatrix(),this.target=new kt,this.shadow=new Tl}dispose(){this.shadow.dispose()}copy(t){return super.copy(t),this.target=t.target.clone(),this.shadow=t.shadow.clone(),this}};Rh.prototype.isDirectionalLight=!0;var Lh=class extends Ye{constructor(t,e){super(t,e),this.type="AmbientLight"}};Lh.prototype.isAmbientLight=!0;var Ph=class extends Ye{constructor(t,e,i=10,r=10){super(t,e),this.type="RectAreaLight",this.width=i,this.height=r}get power(){return this.intensity*this.width*this.height*Math.PI}set power(t){this.intensity=t/(this.width*this.height*Math.PI)}copy(t){return super.copy(t),this.width=t.width,this.height=t.height,this}toJSON(t){let e=super.toJSON(t);return e.object.width=this.width,e.object.height=this.height,e}};Ph.prototype.isRectAreaLight=!0;var Al=class{constructor(){this.coefficients=[];for(let t=0;t<9;t++)this.coefficients.push(new T)}set(t){for(let e=0;e<9;e++)this.coefficients[e].copy(t[e]);return this}zero(){for(let t=0;t<9;t++)this.coefficients[t].set(0,0,0);return this}getAt(t,e){let i=t.x,r=t.y,s=t.z,o=this.coefficients;return e.copy(o[0]).multiplyScalar(.282095),e.addScaledVector(o[1],.488603*r),e.addScaledVector(o[2],.488603*s),e.addScaledVector(o[3],.488603*i),e.addScaledVector(o[4],1.092548*(i*r)),e.addScaledVector(o[5],1.092548*(r*s)),e.addScaledVector(o[6],.315392*(3*s*s-1)),e.addScaledVector(o[7],1.092548*(i*s)),e.addScaledVector(o[8],.546274*(i*i-r*r)),e}getIrradianceAt(t,e){let i=t.x,r=t.y,s=t.z,o=this.coefficients;return e.copy(o[0]).multiplyScalar(.886227),e.addScaledVector(o[1],2*.511664*r),e.addScaledVector(o[2],2*.511664*s),e.addScaledVector(o[3],2*.511664*i),e.addScaledVector(o[4],2*.429043*i*r),e.addScaledVector(o[5],2*.429043*r*s),e.addScaledVector(o[6],.743125*s*s-.247708),e.addScaledVector(o[7],2*.429043*i*s),e.addScaledVector(o[8],.429043*(i*i-r*r)),e}add(t){for(let e=0;e<9;e++)this.coefficients[e].add(t.coefficients[e]);return this}addScaledSH(t,e){for(let i=0;i<9;i++)this.coefficients[i].addScaledVector(t.coefficients[i],e);return this}scale(t){for(let e=0;e<9;e++)this.coefficients[e].multiplyScalar(t);return this}lerp(t,e){for(let i=0;i<9;i++)this.coefficients[i].lerp(t.coefficients[i],e);return this}equals(t){for(let e=0;e<9;e++)if(!this.coefficients[e].equals(t.coefficients[e]))return!1;return!0}copy(t){return this.set(t.coefficients)}clone(){return new this.constructor().copy(this)}fromArray(t,e=0){let i=this.coefficients;for(let r=0;r<9;r++)i[r].fromArray(t,e+r*3);return this}toArray(t=[],e=0){let i=this.coefficients;for(let r=0;r<9;r++)i[r].toArray(t,e+r*3);return t}static getBasisAt(t,e){let i=t.x,r=t.y,s=t.z;e[0]=.282095,e[1]=.488603*r,e[2]=.488603*s,e[3]=.488603*i,e[4]=1.092548*i*r,e[5]=1.092548*r*s,e[6]=.315392*(3*s*s-1),e[7]=1.092548*i*s,e[8]=.546274*(i*i-r*r)}};Al.prototype.isSphericalHarmonics3=!0;var Eo=class extends Ye{constructor(t=new Al,e=1){super(void 0,e),this.sh=t}copy(t){return super.copy(t),this.sh.copy(t.sh),this}fromJSON(t){return this.intensity=t.intensity,this.sh.fromArray(t.sh),this}toJSON(t){let e=super.toJSON(t);return e.object.sh=this.sh.toArray(),e}};Eo.prototype.isLightProbe=!0;var Dh=class{static decodeText(t){if(typeof TextDecoder!="undefined")return new TextDecoder().decode(t);let e="";for(let i=0,r=t.length;i<r;i++)e+=String.fromCharCode(t[i]);try{return decodeURIComponent(escape(e))}catch(i){return e}}static extractUrlBase(t){let e=t.lastIndexOf("/");return e===-1?"./":t.substr(0,e+1)}static resolveURL(t,e){return typeof t!="string"||t===""?"":(/^https?:\/\//i.test(e)&&/^\//.test(t)&&(e=e.replace(/(^https?:\/\/[^\/]+).*/i,"$1")),/^(https?:)?\/\//i.test(t)||/^data:.*,.*$/i.test(t)||/^blob:.*$/i.test(t)?t:e+t)}},Ih=class extends Ht{constructor(){super(),this.type="InstancedBufferGeometry",this.instanceCount=1/0}copy(t){return super.copy(t),this.instanceCount=t.instanceCount,this}clone(){return new this.constructor().copy(this)}toJSON(){let t=super.toJSON(this);return t.instanceCount=this.instanceCount,t.isInstancedBufferGeometry=!0,t}};Ih.prototype.isInstancedBufferGeometry=!0;var Nh=class extends mn{constructor(t){super(t),typeof createImageBitmap=="undefined"&&console.warn("THREE.ImageBitmapLoader: createImageBitmap() not supported."),typeof fetch=="undefined"&&console.warn("THREE.ImageBitmapLoader: fetch() not supported."),this.options={premultiplyAlpha:"none"}}setOptions(t){return this.options=t,this}load(t,e,i,r){t===void 0&&(t=""),this.path!==void 0&&(t=this.path+t),t=this.manager.resolveURL(t);let s=this,o=jr.get(t);if(o!==void 0)return s.manager.itemStart(t),setTimeout(function(){e&&e(o),s.manager.itemEnd(t)},0),o;let a={};a.credentials=this.crossOrigin==="anonymous"?"same-origin":"include",a.headers=this.requestHeader,fetch(t,a).then(function(l){return l.blob()}).then(function(l){return createImageBitmap(l,Object.assign(s.options,{colorSpaceConversion:"none"}))}).then(function(l){jr.add(t,l),e&&e(l),s.manager.itemEnd(t)}).catch(function(l){r&&r(l),s.manager.itemError(t),s.manager.itemEnd(t)}),s.manager.itemStart(t)}};Nh.prototype.isImageBitmapLoader=!0;var Ja,hT={getContext:function(){return Ja===void 0&&(Ja=new(window.AudioContext||window.webkitAudioContext)),Ja},setContext:function(n){Ja=n}},Fh=class extends mn{constructor(t){super(t)}load(t,e,i,r){let s=this,o=new bh(this.manager);o.setResponseType("arraybuffer"),o.setPath(this.path),o.setRequestHeader(this.requestHeader),o.setWithCredentials(this.withCredentials),o.load(t,function(a){try{let l=a.slice(0);hT.getContext().decodeAudioData(l,function(u){e(u)})}catch(l){r?r(l):console.error(l),s.manager.itemError(t)}},i,r)}},zh=class extends Eo{constructor(t,e,i=1){super(void 0,i);let r=new ft().set(t),s=new ft().set(e),o=new T(r.r,r.g,r.b),a=new T(s.r,s.g,s.b),l=Math.sqrt(Math.PI),c=l*Math.sqrt(.75);this.sh.coefficients[0].copy(o).add(a).multiplyScalar(l),this.sh.coefficients[1].copy(o).sub(a).multiplyScalar(c)}};zh.prototype.isHemisphereLightProbe=!0;var Uh=class extends Eo{constructor(t,e=1){super(void 0,e);let i=new ft().set(t);this.sh.coefficients[0].set(i.r,i.g,i.b).multiplyScalar(2*Math.sqrt(Math.PI))}};Uh.prototype.isAmbientLightProbe=!0;var Bh=class extends kt{constructor(t){super(),this.type="Audio",this.listener=t,this.context=t.context,this.gain=this.context.createGain(),this.gain.connect(t.getInput()),this.autoplay=!1,this.buffer=null,this.detune=0,this.loop=!1,this.loopStart=0,this.loopEnd=0,this.offset=0,this.duration=void 0,this.playbackRate=1,this.isPlaying=!1,this.hasPlaybackControl=!0,this.source=null,this.sourceType="empty",this._startedAt=0,this._progress=0,this._connected=!1,this.filters=[]}getOutput(){return this.gain}setNodeSource(t){return this.hasPlaybackControl=!1,this.sourceType="audioNode",this.source=t,this.connect(),this}setMediaElementSource(t){return this.hasPlaybackControl=!1,this.sourceType="mediaNode",this.source=this.context.createMediaElementSource(t),this.connect(),this}setMediaStreamSource(t){return this.hasPlaybackControl=!1,this.sourceType="mediaStreamNode",this.source=this.context.createMediaStreamSource(t),this.connect(),this}setBuffer(t){return this.buffer=t,this.sourceType="buffer",this.autoplay&&this.play(),this}play(t=0){if(this.isPlaying===!0){console.warn("THREE.Audio: Audio is already playing.");return}if(this.hasPlaybackControl===!1){console.warn("THREE.Audio: this Audio has no playback control.");return}this._startedAt=this.context.currentTime+t;let e=this.context.createBufferSource();return e.buffer=this.buffer,e.loop=this.loop,e.loopStart=this.loopStart,e.loopEnd=this.loopEnd,e.onended=this.onEnded.bind(this),e.start(this._startedAt,this._progress+this.offset,this.duration),this.isPlaying=!0,this.source=e,this.setDetune(this.detune),this.setPlaybackRate(this.playbackRate),this.connect()}pause(){if(this.hasPlaybackControl===!1){console.warn("THREE.Audio: this Audio has no playback control.");return}return this.isPlaying===!0&&(this._progress+=Math.max(this.context.currentTime-this._startedAt,0)*this.playbackRate,this.loop===!0&&(this._progress=this._progress%(this.duration||this.buffer.duration)),this.source.stop(),this.source.onended=null,this.isPlaying=!1),this}stop(){if(this.hasPlaybackControl===!1){console.warn("THREE.Audio: this Audio has no playback control.");return}return this._progress=0,this.source.stop(),this.source.onended=null,this.isPlaying=!1,this}connect(){if(this.filters.length>0){this.source.connect(this.filters[0]);for(let t=1,e=this.filters.length;t<e;t++)this.filters[t-1].connect(this.filters[t]);this.filters[this.filters.length-1].connect(this.getOutput())}else this.source.connect(this.getOutput());return this._connected=!0,this}disconnect(){if(this.filters.length>0){this.source.disconnect(this.filters[0]);for(let t=1,e=this.filters.length;t<e;t++)this.filters[t-1].disconnect(this.filters[t]);this.filters[this.filters.length-1].disconnect(this.getOutput())}else this.source.disconnect(this.getOutput());return this._connected=!1,this}getFilters(){return this.filters}setFilters(t){return t||(t=[]),this._connected===!0?(this.disconnect(),this.filters=t.slice(),this.connect()):this.filters=t.slice(),this}setDetune(t){if(this.detune=t,this.source.detune!==void 0)return this.isPlaying===!0&&this.source.detune.setTargetAtTime(this.detune,this.context.currentTime,.01),this}getDetune(){return this.detune}getFilter(){return this.getFilters()[0]}setFilter(t){return this.setFilters(t?[t]:[])}setPlaybackRate(t){if(this.hasPlaybackControl===!1){console.warn("THREE.Audio: this Audio has no playback control.");return}return this.playbackRate=t,this.isPlaying===!0&&this.source.playbackRate.setTargetAtTime(this.playbackRate,this.context.currentTime,.01),this}getPlaybackRate(){return this.playbackRate}onEnded(){this.isPlaying=!1}getLoop(){return this.hasPlaybackControl===!1?(console.warn("THREE.Audio: this Audio has no playback control."),!1):this.loop}setLoop(t){if(this.hasPlaybackControl===!1){console.warn("THREE.Audio: this Audio has no playback control.");return}return this.loop=t,this.isPlaying===!0&&(this.source.loop=this.loop),this}setLoopStart(t){return this.loopStart=t,this}setLoopEnd(t){return this.loopEnd=t,this}getVolume(){return this.gain.gain.value}setVolume(t){return this.gain.gain.setTargetAtTime(t,this.context.currentTime,.01),this}};var Oh=class{constructor(t,e=2048){this.analyser=t.context.createAnalyser(),this.analyser.fftSize=e,this.data=new Uint8Array(this.analyser.frequencyBinCount),t.getOutput().connect(this.analyser)}getFrequencyData(){return this.analyser.getByteFrequencyData(this.data),this.data}getAverageFrequency(){let t=0,e=this.getFrequencyData();for(let i=0;i<e.length;i++)t+=e[i];return t/e.length}},kh=class{constructor(t,e,i){this.binding=t,this.valueSize=i;let r,s,o;switch(e){case"quaternion":r=this._slerp,s=this._slerpAdditive,o=this._setAdditiveIdentityQuaternion,this.buffer=new Float64Array(i*6),this._workIndex=5;break;case"string":case"bool":r=this._select,s=this._select,o=this._setAdditiveIdentityOther,this.buffer=new Array(i*5);break;default:r=this._lerp,s=this._lerpAdditive,o=this._setAdditiveIdentityNumeric,this.buffer=new Float64Array(i*5)}this._mixBufferRegion=r,this._mixBufferRegionAdditive=s,this._setIdentity=o,this._origIndex=3,this._addIndex=4,this.cumulativeWeight=0,this.cumulativeWeightAdditive=0,this.useCount=0,this.referenceCount=0}accumulate(t,e){let i=this.buffer,r=this.valueSize,s=t*r+r,o=this.cumulativeWeight;if(o===0){for(let a=0;a!==r;++a)i[s+a]=i[a];o=e}else{o+=e;let a=e/o;this._mixBufferRegion(i,s,0,a,r)}this.cumulativeWeight=o}accumulateAdditive(t){let e=this.buffer,i=this.valueSize,r=i*this._addIndex;this.cumulativeWeightAdditive===0&&this._setIdentity(),this._mixBufferRegionAdditive(e,r,0,t,i),this.cumulativeWeightAdditive+=t}apply(t){let e=this.valueSize,i=this.buffer,r=t*e+e,s=this.cumulativeWeight,o=this.cumulativeWeightAdditive,a=this.binding;if(this.cumulativeWeight=0,this.cumulativeWeightAdditive=0,s<1){let l=e*this._origIndex;this._mixBufferRegion(i,r,l,1-s,e)}o>0&&this._mixBufferRegionAdditive(i,r,this._addIndex*e,1,e);for(let l=e,c=e+e;l!==c;++l)if(i[l]!==i[l+e]){a.setValue(i,r);break}}saveOriginalState(){let t=this.binding,e=this.buffer,i=this.valueSize,r=i*this._origIndex;t.getValue(e,r);for(let s=i,o=r;s!==o;++s)e[s]=e[r+s%i];this._setIdentity(),this.cumulativeWeight=0,this.cumulativeWeightAdditive=0}restoreOriginalState(){let t=this.valueSize*3;this.binding.setValue(this.buffer,t)}_setAdditiveIdentityNumeric(){let t=this._addIndex*this.valueSize,e=t+this.valueSize;for(let i=t;i<e;i++)this.buffer[i]=0}_setAdditiveIdentityQuaternion(){this._setAdditiveIdentityNumeric(),this.buffer[this._addIndex*this.valueSize+3]=1}_setAdditiveIdentityOther(){let t=this._origIndex*this.valueSize,e=this._addIndex*this.valueSize;for(let i=0;i<this.valueSize;i++)this.buffer[e+i]=this.buffer[t+i]}_select(t,e,i,r,s){if(r>=.5)for(let o=0;o!==s;++o)t[e+o]=t[i+o]}_slerp(t,e,i,r){Ee.slerpFlat(t,e,t,e,t,i,r)}_slerpAdditive(t,e,i,r,s){let o=this._workIndex*s;Ee.multiplyQuaternionsFlat(t,o,t,e,t,i),Ee.slerpFlat(t,e,t,e,t,o,r)}_lerp(t,e,i,r,s){let o=1-r;for(let a=0;a!==s;++a){let l=e+a;t[l]=t[l]*o+t[i+a]*r}}_lerpAdditive(t,e,i,r,s){for(let o=0;o!==s;++o){let a=e+o;t[a]=t[a]+t[i+o]*r}}},ef="\\[\\]\\.:\\/",fT=new RegExp("["+ef+"]","g"),nf="[^"+ef+"]",dT="[^"+ef.replace("\\.","")+"]",pT=/((?:WC+[\/:])*)/.source.replace("WC",nf),mT=/(WCOD+)?/.source.replace("WCOD",dT),gT=/(?:\.(WC+)(?:\[(.+)\])?)?/.source.replace("WC",nf),xT=/\.(WC+)(?:\[(.+)\])?/.source.replace("WC",nf),yT=new RegExp("^"+pT+mT+gT+xT+"$"),vT=["material","materials","bones"],Hh=class{constructor(t,e,i){let r=i||Nt.parseTrackName(e);this._targetGroup=t,this._bindings=t.subscribe_(e,r)}getValue(t,e){this.bind();let i=this._targetGroup.nCachedObjects_,r=this._bindings[i];r!==void 0&&r.getValue(t,e)}setValue(t,e){let i=this._bindings;for(let r=this._targetGroup.nCachedObjects_,s=i.length;r!==s;++r)i[r].setValue(t,e)}bind(){let t=this._bindings;for(let e=this._targetGroup.nCachedObjects_,i=t.length;e!==i;++e)t[e].bind()}unbind(){let t=this._bindings;for(let e=this._targetGroup.nCachedObjects_,i=t.length;e!==i;++e)t[e].unbind()}},Nt=class{constructor(t,e,i){this.path=e,this.parsedPath=i||Nt.parseTrackName(e),this.node=Nt.findNode(t,this.parsedPath.nodeName)||t,this.rootNode=t,this.getValue=this._getValue_unbound,this.setValue=this._setValue_unbound}static create(t,e,i){return t&&t.isAnimationObjectGroup?new Nt.Composite(t,e,i):new Nt(t,e,i)}static sanitizeNodeName(t){return t.replace(/\s/g,"_").replace(fT,"")}static parseTrackName(t){let e=yT.exec(t);if(!e)throw new Error("PropertyBinding: Cannot parse trackName: "+t);let i={nodeName:e[2],objectName:e[3],objectIndex:e[4],propertyName:e[5],propertyIndex:e[6]},r=i.nodeName&&i.nodeName.lastIndexOf(".");if(r!==void 0&&r!==-1){let s=i.nodeName.substring(r+1);vT.indexOf(s)!==-1&&(i.nodeName=i.nodeName.substring(0,r),i.objectName=s)}if(i.propertyName===null||i.propertyName.length===0)throw new Error("PropertyBinding: can not parse propertyName from trackName: "+t);return i}static findNode(t,e){if(!e||e===""||e==="."||e===-1||e===t.name||e===t.uuid)return t;if(t.skeleton){let i=t.skeleton.getBoneByName(e);if(i!==void 0)return i}if(t.children){let i=function(s){for(let o=0;o<s.length;o++){let a=s[o];if(a.name===e||a.uuid===e)return a;let l=i(a.children);if(l)return l}return null},r=i(t.children);if(r)return r}return null}_getValue_unavailable(){}_setValue_unavailable(){}_getValue_direct(t,e){t[e]=this.targetObject[this.propertyName]}_getValue_array(t,e){let i=this.resolvedProperty;for(let r=0,s=i.length;r!==s;++r)t[e++]=i[r]}_getValue_arrayElement(t,e){t[e]=this.resolvedProperty[this.propertyIndex]}_getValue_toArray(t,e){this.resolvedProperty.toArray(t,e)}_setValue_direct(t,e){this.targetObject[this.propertyName]=t[e]}_setValue_direct_setNeedsUpdate(t,e){this.targetObject[this.propertyName]=t[e],this.targetObject.needsUpdate=!0}_setValue_direct_setMatrixWorldNeedsUpdate(t,e){this.targetObject[this.propertyName]=t[e],this.targetObject.matrixWorldNeedsUpdate=!0}_setValue_array(t,e){let i=this.resolvedProperty;for(let r=0,s=i.length;r!==s;++r)i[r]=t[e++]}_setValue_array_setNeedsUpdate(t,e){let i=this.resolvedProperty;for(let r=0,s=i.length;r!==s;++r)i[r]=t[e++];this.targetObject.needsUpdate=!0}_setValue_array_setMatrixWorldNeedsUpdate(t,e){let i=this.resolvedProperty;for(let r=0,s=i.length;r!==s;++r)i[r]=t[e++];this.targetObject.matrixWorldNeedsUpdate=!0}_setValue_arrayElement(t,e){this.resolvedProperty[this.propertyIndex]=t[e]}_setValue_arrayElement_setNeedsUpdate(t,e){this.resolvedProperty[this.propertyIndex]=t[e],this.targetObject.needsUpdate=!0}_setValue_arrayElement_setMatrixWorldNeedsUpdate(t,e){this.resolvedProperty[this.propertyIndex]=t[e],this.targetObject.matrixWorldNeedsUpdate=!0}_setValue_fromArray(t,e){this.resolvedProperty.fromArray(t,e)}_setValue_fromArray_setNeedsUpdate(t,e){this.resolvedProperty.fromArray(t,e),this.targetObject.needsUpdate=!0}_setValue_fromArray_setMatrixWorldNeedsUpdate(t,e){this.resolvedProperty.fromArray(t,e),this.targetObject.matrixWorldNeedsUpdate=!0}_getValue_unbound(t,e){this.bind(),this.getValue(t,e)}_setValue_unbound(t,e){this.bind(),this.setValue(t,e)}bind(){let t=this.node,e=this.parsedPath,i=e.objectName,r=e.propertyName,s=e.propertyIndex;if(t||(t=Nt.findNode(this.rootNode,e.nodeName)||this.rootNode,this.node=t),this.getValue=this._getValue_unavailable,this.setValue=this._setValue_unavailable,!t){console.error("THREE.PropertyBinding: Trying to update node for track: "+this.path+" but it wasn't found.");return}if(i){let c=e.objectIndex;switch(i){case"materials":if(!t.material){console.error("THREE.PropertyBinding: Can not bind to material as node does not have a material.",this);return}if(!t.material.materials){console.error("THREE.PropertyBinding: Can not bind to material.materials as node.material does not have a materials array.",this);return}t=t.material.materials;break;case"bones":if(!t.skeleton){console.error("THREE.PropertyBinding: Can not bind to bones as node does not have a skeleton.",this);return}t=t.skeleton.bones;for(let u=0;u<t.length;u++)if(t[u].name===c){c=u;break}break;default:if(t[i]===void 0){console.error("THREE.PropertyBinding: Can not bind to objectName of node undefined.",this);return}t=t[i]}if(c!==void 0){if(t[c]===void 0){console.error("THREE.PropertyBinding: Trying to bind to objectIndex of objectName, but is undefined.",this,t);return}t=t[c]}}let o=t[r];if(o===void 0){let c=e.nodeName;console.error("THREE.PropertyBinding: Trying to update property for track: "+c+"."+r+" but it wasn't found.",t);return}let a=this.Versioning.None;this.targetObject=t,t.needsUpdate!==void 0?a=this.Versioning.NeedsUpdate:t.matrixWorldNeedsUpdate!==void 0&&(a=this.Versioning.MatrixWorldNeedsUpdate);let l=this.BindingType.Direct;if(s!==void 0){if(r==="morphTargetInfluences"){if(!t.geometry){console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.",this);return}if(t.geometry.isBufferGeometry){if(!t.geometry.morphAttributes){console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.morphAttributes.",this);return}t.morphTargetDictionary[s]!==void 0&&(s=t.morphTargetDictionary[s])}else{console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences on THREE.Geometry. Use THREE.BufferGeometry instead.",this);return}}l=this.BindingType.ArrayElement,this.resolvedProperty=o,this.propertyIndex=s}else o.fromArray!==void 0&&o.toArray!==void 0?(l=this.BindingType.HasFromToArray,this.resolvedProperty=o):Array.isArray(o)?(l=this.BindingType.EntireArray,this.resolvedProperty=o):this.propertyName=r;this.getValue=this.GetterByBindingType[l],this.setValue=this.SetterByBindingTypeAndVersioning[l][a]}unbind(){this.node=null,this.getValue=this._getValue_unbound,this.setValue=this._setValue_unbound}};Nt.Composite=Hh;Nt.prototype.BindingType={Direct:0,EntireArray:1,ArrayElement:2,HasFromToArray:3};Nt.prototype.Versioning={None:0,NeedsUpdate:1,MatrixWorldNeedsUpdate:2};Nt.prototype.GetterByBindingType=[Nt.prototype._getValue_direct,Nt.prototype._getValue_array,Nt.prototype._getValue_arrayElement,Nt.prototype._getValue_toArray];Nt.prototype.SetterByBindingTypeAndVersioning=[[Nt.prototype._setValue_direct,Nt.prototype._setValue_direct_setNeedsUpdate,Nt.prototype._setValue_direct_setMatrixWorldNeedsUpdate],[Nt.prototype._setValue_array,Nt.prototype._setValue_array_setNeedsUpdate,Nt.prototype._setValue_array_setMatrixWorldNeedsUpdate],[Nt.prototype._setValue_arrayElement,Nt.prototype._setValue_arrayElement_setNeedsUpdate,Nt.prototype._setValue_arrayElement_setMatrixWorldNeedsUpdate],[Nt.prototype._setValue_fromArray,Nt.prototype._setValue_fromArray_setNeedsUpdate,Nt.prototype._setValue_fromArray_setMatrixWorldNeedsUpdate]];var Vh=class{constructor(){this.uuid=tn(),this._objects=Array.prototype.slice.call(arguments),this.nCachedObjects_=0;let t={};this._indicesByUUID=t;for(let i=0,r=arguments.length;i!==r;++i)t[arguments[i].uuid]=i;this._paths=[],this._parsedPaths=[],this._bindings=[],this._bindingsIndicesByPath={};let e=this;this.stats={objects:{get total(){return e._objects.length},get inUse(){return this.total-e.nCachedObjects_}},get bindingsPerObject(){return e._bindings.length}}}add(){let t=this._objects,e=this._indicesByUUID,i=this._paths,r=this._parsedPaths,s=this._bindings,o=s.length,a,l=t.length,c=this.nCachedObjects_;for(let u=0,h=arguments.length;u!==h;++u){let f=arguments[u],d=f.uuid,g=e[d];if(g===void 0){g=l++,e[d]=g,t.push(f);for(let x=0,v=o;x!==v;++x)s[x].push(new Nt(f,i[x],r[x]))}else if(g<c){a=t[g];let x=--c,v=t[x];e[v.uuid]=g,t[g]=v,e[d]=x,t[x]=f;for(let m=0,p=o;m!==p;++m){let b=s[m],_=b[x],S=b[g];b[g]=_,S===void 0&&(S=new Nt(f,i[m],r[m])),b[x]=S}}else t[g]!==a&&console.error("THREE.AnimationObjectGroup: Different objects with the same UUID detected. Clean the caches or recreate your infrastructure when reloading scenes.")}this.nCachedObjects_=c}remove(){let t=this._objects,e=this._indicesByUUID,i=this._bindings,r=i.length,s=this.nCachedObjects_;for(let o=0,a=arguments.length;o!==a;++o){let l=arguments[o],c=l.uuid,u=e[c];if(u!==void 0&&u>=s){let h=s++,f=t[h];e[f.uuid]=u,t[u]=f,e[c]=h,t[h]=l;for(let d=0,g=r;d!==g;++d){let x=i[d],v=x[h],m=x[u];x[u]=v,x[h]=m}}}this.nCachedObjects_=s}uncache(){let t=this._objects,e=this._indicesByUUID,i=this._bindings,r=i.length,s=this.nCachedObjects_,o=t.length;for(let a=0,l=arguments.length;a!==l;++a){let c=arguments[a],u=c.uuid,h=e[u];if(h!==void 0)if(delete e[u],h<s){let f=--s,d=t[f],g=--o,x=t[g];e[d.uuid]=h,t[h]=d,e[x.uuid]=f,t[f]=x,t.pop();for(let v=0,m=r;v!==m;++v){let p=i[v],b=p[f],_=p[g];p[h]=b,p[f]=_,p.pop()}}else{let f=--o,d=t[f];f>0&&(e[d.uuid]=h),t[h]=d,t.pop();for(let g=0,x=r;g!==x;++g){let v=i[g];v[h]=v[f],v.pop()}}}this.nCachedObjects_=s}subscribe_(t,e){let i=this._bindingsIndicesByPath,r=i[t],s=this._bindings;if(r!==void 0)return s[r];let o=this._paths,a=this._parsedPaths,l=this._objects,c=l.length,u=this.nCachedObjects_,h=new Array(c);r=s.length,i[t]=r,o.push(t),a.push(e),s.push(h);for(let f=u,d=l.length;f!==d;++f){let g=l[f];h[f]=new Nt(g,t,e)}return h}unsubscribe_(t){let e=this._bindingsIndicesByPath,i=e[t];if(i!==void 0){let r=this._paths,s=this._parsedPaths,o=this._bindings,a=o.length-1,l=o[a],c=t[a];e[c]=i,o[i]=l,o.pop(),s[i]=s[a],s.pop(),r[i]=r[a],r.pop()}}};Vh.prototype.isAnimationObjectGroup=!0;var Gh=class{constructor(t,e,i=null,r=e.blendMode){this._mixer=t,this._clip=e,this._localRoot=i,this.blendMode=r;let s=e.tracks,o=s.length,a=new Array(o),l={endingStart:Nr,endingEnd:Nr};for(let c=0;c!==o;++c){let u=s[c].createInterpolant(null);a[c]=u,u.settings=l}this._interpolantSettings=l,this._interpolants=a,this._propertyBindings=new Array(o),this._cacheIndex=null,this._byClipCacheIndex=null,this._timeScaleInterpolant=null,this._weightInterpolant=null,this.loop=Zw,this._loopCount=-1,this._startTime=null,this.time=0,this.timeScale=1,this._effectiveTimeScale=1,this.weight=1,this._effectiveWeight=1,this.repetitions=1/0,this.paused=!1,this.enabled=!0,this.clampWhenFinished=!1,this.zeroSlopeAtStart=!0,this.zeroSlopeAtEnd=!0}play(){return this._mixer._activateAction(this),this}stop(){return this._mixer._deactivateAction(this),this.reset()}reset(){return this.paused=!1,this.enabled=!0,this.time=0,this._loopCount=-1,this._startTime=null,this.stopFading().stopWarping()}isRunning(){return this.enabled&&!this.paused&&this.timeScale!==0&&this._startTime===null&&this._mixer._isActiveAction(this)}isScheduled(){return this._mixer._isActiveAction(this)}startAt(t){return this._startTime=t,this}setLoop(t,e){return this.loop=t,this.repetitions=e,this}setEffectiveWeight(t){return this.weight=t,this._effectiveWeight=this.enabled?t:0,this.stopFading()}getEffectiveWeight(){return this._effectiveWeight}fadeIn(t){return this._scheduleFading(t,0,1)}fadeOut(t){return this._scheduleFading(t,1,0)}crossFadeFrom(t,e,i){if(t.fadeOut(e),this.fadeIn(e),i){let r=this._clip.duration,s=t._clip.duration,o=s/r,a=r/s;t.warp(1,o,e),this.warp(a,1,e)}return this}crossFadeTo(t,e,i){return t.crossFadeFrom(this,e,i)}stopFading(){let t=this._weightInterpolant;return t!==null&&(this._weightInterpolant=null,this._mixer._takeBackControlInterpolant(t)),this}setEffectiveTimeScale(t){return this.timeScale=t,this._effectiveTimeScale=this.paused?0:t,this.stopWarping()}getEffectiveTimeScale(){return this._effectiveTimeScale}setDuration(t){return this.timeScale=this._clip.duration/t,this.stopWarping()}syncWith(t){return this.time=t.time,this.timeScale=t.timeScale,this.stopWarping()}halt(t){return this.warp(this._effectiveTimeScale,0,t)}warp(t,e,i){let r=this._mixer,s=r.time,o=this.timeScale,a=this._timeScaleInterpolant;a===null&&(a=r._lendControlInterpolant(),this._timeScaleInterpolant=a);let l=a.parameterPositions,c=a.sampleValues;return l[0]=s,l[1]=s+i,c[0]=t/o,c[1]=e/o,this}stopWarping(){let t=this._timeScaleInterpolant;return t!==null&&(this._timeScaleInterpolant=null,this._mixer._takeBackControlInterpolant(t)),this}getMixer(){return this._mixer}getClip(){return this._clip}getRoot(){return this._localRoot||this._mixer._root}_update(t,e,i,r){if(!this.enabled){this._updateWeight(t);return}let s=this._startTime;if(s!==null){let l=(t-s)*i;if(l<0||i===0)return;this._startTime=null,e=i*l}e*=this._updateTimeScale(t);let o=this._updateTime(e),a=this._updateWeight(t);if(a>0){let l=this._interpolants,c=this._propertyBindings;switch(this.blendMode){case d0:for(let u=0,h=l.length;u!==h;++u)l[u].evaluate(o),c[u].accumulateAdditive(a);break;case Qh:default:for(let u=0,h=l.length;u!==h;++u)l[u].evaluate(o),c[u].accumulate(r,a)}}}_updateWeight(t){let e=0;if(this.enabled){e=this.weight;let i=this._weightInterpolant;if(i!==null){let r=i.evaluate(t)[0];e*=r,t>i.parameterPositions[1]&&(this.stopFading(),r===0&&(this.enabled=!1))}}return this._effectiveWeight=e,e}_updateTimeScale(t){let e=0;if(!this.paused){e=this.timeScale;let i=this._timeScaleInterpolant;i!==null&&(e*=i.evaluate(t)[0],t>i.parameterPositions[1]&&(this.stopWarping(),e===0?this.paused=!0:this.timeScale=e))}return this._effectiveTimeScale=e,e}_updateTime(t){let e=this._clip.duration,i=this.loop,r=this.time+t,s=this._loopCount,o=i===Jw;if(t===0)return s===-1?r:o&&(s&1)===1?e-r:r;if(i===Yw){s===-1&&(this._loopCount=0,this._setEndings(!0,!0,!1));t:{if(r>=e)r=e;else if(r<0)r=0;else{this.time=r;break t}this.clampWhenFinished?this.paused=!0:this.enabled=!1,this.time=r,this._mixer.dispatchEvent({type:"finished",action:this,direction:t<0?-1:1})}}else{if(s===-1&&(t>=0?(s=0,this._setEndings(!0,this.repetitions===0,o)):this._setEndings(this.repetitions===0,!0,o)),r>=e||r<0){let a=Math.floor(r/e);r-=e*a,s+=Math.abs(a);let l=this.repetitions-s;if(l<=0)this.clampWhenFinished?this.paused=!0:this.enabled=!1,r=t>0?e:0,this.time=r,this._mixer.dispatchEvent({type:"finished",action:this,direction:t>0?1:-1});else{if(l===1){let c=t<0;this._setEndings(c,!c,o)}else this._setEndings(!1,!1,o);this._loopCount=s,this.time=r,this._mixer.dispatchEvent({type:"loop",action:this,loopDelta:a})}}else this.time=r;if(o&&(s&1)===1)return e-r}return r}_setEndings(t,e,i){let r=this._interpolantSettings;i?(r.endingStart=Fr,r.endingEnd=Fr):(t?r.endingStart=this.zeroSlopeAtStart?Fr:Nr:r.endingStart=el,e?r.endingEnd=this.zeroSlopeAtEnd?Fr:Nr:r.endingEnd=el)}_scheduleFading(t,e,i){let r=this._mixer,s=r.time,o=this._weightInterpolant;o===null&&(o=r._lendControlInterpolant(),this._weightInterpolant=o);let a=o.parameterPositions,l=o.sampleValues;return a[0]=s,l[0]=e,a[1]=s+t,l[1]=i,this}},Wh=class extends In{constructor(t){super(),this._root=t,this._initMemoryManager(),this._accuIndex=0,this.time=0,this.timeScale=1}_bindAction(t,e){let i=t._localRoot||this._root,r=t._clip.tracks,s=r.length,o=t._propertyBindings,a=t._interpolants,l=i.uuid,c=this._bindingsByRootAndName,u=c[l];u===void 0&&(u={},c[l]=u);for(let h=0;h!==s;++h){let f=r[h],d=f.name,g=u[d];if(g!==void 0)++g.referenceCount,o[h]=g;else{if(g=o[h],g!==void 0){g._cacheIndex===null&&(++g.referenceCount,this._addInactiveBinding(g,l,d));continue}let x=e&&e._propertyBindings[h].binding.parsedPath;g=new kh(Nt.create(i,d,x),f.ValueTypeName,f.getValueSize()),++g.referenceCount,this._addInactiveBinding(g,l,d),o[h]=g}a[h].resultBuffer=g.buffer}}_activateAction(t){if(!this._isActiveAction(t)){if(t._cacheIndex===null){let i=(t._localRoot||this._root).uuid,r=t._clip.uuid,s=this._actionsByClip[r];this._bindAction(t,s&&s.knownActions[0]),this._addInactiveAction(t,r,i)}let e=t._propertyBindings;for(let i=0,r=e.length;i!==r;++i){let s=e[i];s.useCount++===0&&(this._lendBinding(s),s.saveOriginalState())}this._lendAction(t)}}_deactivateAction(t){if(this._isActiveAction(t)){let e=t._propertyBindings;for(let i=0,r=e.length;i!==r;++i){let s=e[i];--s.useCount===0&&(s.restoreOriginalState(),this._takeBackBinding(s))}this._takeBackAction(t)}}_initMemoryManager(){this._actions=[],this._nActiveActions=0,this._actionsByClip={},this._bindings=[],this._nActiveBindings=0,this._bindingsByRootAndName={},this._controlInterpolants=[],this._nActiveControlInterpolants=0;let t=this;this.stats={actions:{get total(){return t._actions.length},get inUse(){return t._nActiveActions}},bindings:{get total(){return t._bindings.length},get inUse(){return t._nActiveBindings}},controlInterpolants:{get total(){return t._controlInterpolants.length},get inUse(){return t._nActiveControlInterpolants}}}}_isActiveAction(t){let e=t._cacheIndex;return e!==null&&e<this._nActiveActions}_addInactiveAction(t,e,i){let r=this._actions,s=this._actionsByClip,o=s[e];if(o===void 0)o={knownActions:[t],actionByRoot:{}},t._byClipCacheIndex=0,s[e]=o;else{let a=o.knownActions;t._byClipCacheIndex=a.length,a.push(t)}t._cacheIndex=r.length,r.push(t),o.actionByRoot[i]=t}_removeInactiveAction(t){let e=this._actions,i=e[e.length-1],r=t._cacheIndex;i._cacheIndex=r,e[r]=i,e.pop(),t._cacheIndex=null;let s=t._clip.uuid,o=this._actionsByClip,a=o[s],l=a.knownActions,c=l[l.length-1],u=t._byClipCacheIndex;c._byClipCacheIndex=u,l[u]=c,l.pop(),t._byClipCacheIndex=null;let h=a.actionByRoot,f=(t._localRoot||this._root).uuid;delete h[f],l.length===0&&delete o[s],this._removeInactiveBindingsForAction(t)}_removeInactiveBindingsForAction(t){let e=t._propertyBindings;for(let i=0,r=e.length;i!==r;++i){let s=e[i];--s.referenceCount===0&&this._removeInactiveBinding(s)}}_lendAction(t){let e=this._actions,i=t._cacheIndex,r=this._nActiveActions++,s=e[r];t._cacheIndex=r,e[r]=t,s._cacheIndex=i,e[i]=s}_takeBackAction(t){let e=this._actions,i=t._cacheIndex,r=--this._nActiveActions,s=e[r];t._cacheIndex=r,e[r]=t,s._cacheIndex=i,e[i]=s}_addInactiveBinding(t,e,i){let r=this._bindingsByRootAndName,s=this._bindings,o=r[e];o===void 0&&(o={},r[e]=o),o[i]=t,t._cacheIndex=s.length,s.push(t)}_removeInactiveBinding(t){let e=this._bindings,i=t.binding,r=i.rootNode.uuid,s=i.path,o=this._bindingsByRootAndName,a=o[r],l=e[e.length-1],c=t._cacheIndex;l._cacheIndex=c,e[c]=l,e.pop(),delete a[s],Object.keys(a).length===0&&delete o[r]}_lendBinding(t){let e=this._bindings,i=t._cacheIndex,r=this._nActiveBindings++,s=e[r];t._cacheIndex=r,e[r]=t,s._cacheIndex=i,e[i]=s}_takeBackBinding(t){let e=this._bindings,i=t._cacheIndex,r=--this._nActiveBindings,s=e[r];t._cacheIndex=r,e[r]=t,s._cacheIndex=i,e[i]=s}_lendControlInterpolant(){let t=this._controlInterpolants,e=this._nActiveControlInterpolants++,i=t[e];return i===void 0&&(i=new _l(new Float32Array(2),new Float32Array(2),1,this._controlInterpolantsResultBuffer),i.__cacheIndex=e,t[e]=i),i}_takeBackControlInterpolant(t){let e=this._controlInterpolants,i=t.__cacheIndex,r=--this._nActiveControlInterpolants,s=e[r];t.__cacheIndex=r,e[r]=t,s.__cacheIndex=i,e[i]=s}clipAction(t,e,i){let r=e||this._root,s=r.uuid,o=typeof t=="string"?Ml.findByName(r,t):t,a=o!==null?o.uuid:t,l=this._actionsByClip[a],c=null;if(i===void 0&&(o!==null?i=o.blendMode:i=Qh),l!==void 0){let h=l.actionByRoot[s];if(h!==void 0&&h.blendMode===i)return h;c=l.knownActions[0],o===null&&(o=c._clip)}if(o===null)return null;let u=new Gh(this,o,e,i);return this._bindAction(u,c),this._addInactiveAction(u,a,s),u}existingAction(t,e){let i=e||this._root,r=i.uuid,s=typeof t=="string"?Ml.findByName(i,t):t,o=s?s.uuid:t,a=this._actionsByClip[o];return a!==void 0&&a.actionByRoot[r]||null}stopAllAction(){let t=this._actions,e=this._nActiveActions;for(let i=e-1;i>=0;--i)t[i].stop();return this}update(t){t*=this.timeScale;let e=this._actions,i=this._nActiveActions,r=this.time+=t,s=Math.sign(t),o=this._accuIndex^=1;for(let c=0;c!==i;++c)e[c]._update(r,t,s,o);let a=this._bindings,l=this._nActiveBindings;for(let c=0;c!==l;++c)a[c].apply(o);return this}setTime(t){this.time=0;for(let e=0;e<this._actions.length;e++)this._actions[e].time=0;return this.update(t)}getRoot(){return this._root}uncacheClip(t){let e=this._actions,i=t.uuid,r=this._actionsByClip,s=r[i];if(s!==void 0){let o=s.knownActions;for(let a=0,l=o.length;a!==l;++a){let c=o[a];this._deactivateAction(c);let u=c._cacheIndex,h=e[e.length-1];c._cacheIndex=null,c._byClipCacheIndex=null,h._cacheIndex=u,e[u]=h,e.pop(),this._removeInactiveBindingsForAction(c)}delete r[i]}}uncacheRoot(t){let e=t.uuid,i=this._actionsByClip;for(let o in i){let a=i[o].actionByRoot,l=a[e];l!==void 0&&(this._deactivateAction(l),this._removeInactiveAction(l))}let r=this._bindingsByRootAndName,s=r[e];if(s!==void 0)for(let o in s){let a=s[o];a.restoreOriginalState(),this._removeInactiveBinding(a)}}uncacheAction(t,e){let i=this.existingAction(t,e);i!==null&&(this._deactivateAction(i),this._removeInactiveAction(i))}};Wh.prototype._controlInterpolantsResultBuffer=new Float32Array(1);var To=class{constructor(t){typeof t=="string"&&(console.warn("THREE.Uniform: Type parameter is no longer needed."),t=arguments[1]),this.value=t}clone(){return new To(this.value.clone===void 0?this.value:this.value.clone())}},qh=class extends Gi{constructor(t,e,i=1){super(t,e),this.meshPerAttribute=i}copy(t){return super.copy(t),this.meshPerAttribute=t.meshPerAttribute,this}clone(t){let e=super.clone(t);return e.meshPerAttribute=this.meshPerAttribute,e}toJSON(t){let e=super.toJSON(t);return e.isInstancedInterleavedBuffer=!0,e.meshPerAttribute=this.meshPerAttribute,e}};qh.prototype.isInstancedInterleavedBuffer=!0;var Xh=class{constructor(t,e,i,r,s){this.buffer=t,this.type=e,this.itemSize=i,this.elementSize=r,this.count=s,this.version=0}set needsUpdate(t){t===!0&&this.version++}setBuffer(t){return this.buffer=t,this}setType(t,e){return this.type=t,this.elementSize=e,this}setItemSize(t){return this.itemSize=t,this}setCount(t){return this.count=t,this}};Xh.prototype.isGLBufferAttribute=!0;var o0=new K,Yi=class{constructor(t=new K(1/0,1/0),e=new K(-1/0,-1/0)){this.min=t,this.max=e}set(t,e){return this.min.copy(t),this.max.copy(e),this}setFromPoints(t){this.makeEmpty();for(let e=0,i=t.length;e<i;e++)this.expandByPoint(t[e]);return this}setFromCenterAndSize(t,e){let i=o0.copy(e).multiplyScalar(.5);return this.min.copy(t).sub(i),this.max.copy(t).add(i),this}clone(){return new this.constructor().copy(this)}copy(t){return this.min.copy(t.min),this.max.copy(t.max),this}makeEmpty(){return this.min.x=this.min.y=1/0,this.max.x=this.max.y=-1/0,this}isEmpty(){return this.max.x<this.min.x||this.max.y<this.min.y}getCenter(t){return this.isEmpty()?t.set(0,0):t.addVectors(this.min,this.max).multiplyScalar(.5)}getSize(t){return this.isEmpty()?t.set(0,0):t.subVectors(this.max,this.min)}expandByPoint(t){return this.min.min(t),this.max.max(t),this}expandByVector(t){return this.min.sub(t),this.max.add(t),this}expandByScalar(t){return this.min.addScalar(-t),this.max.addScalar(t),this}containsPoint(t){return!(t.x<this.min.x||t.x>this.max.x||t.y<this.min.y||t.y>this.max.y)}containsBox(t){return this.min.x<=t.min.x&&t.max.x<=this.max.x&&this.min.y<=t.min.y&&t.max.y<=this.max.y}getParameter(t,e){return e.set((t.x-this.min.x)/(this.max.x-this.min.x),(t.y-this.min.y)/(this.max.y-this.min.y))}intersectsBox(t){return!(t.max.x<this.min.x||t.min.x>this.max.x||t.max.y<this.min.y||t.min.y>this.max.y)}clampPoint(t,e){return e.copy(t).clamp(this.min,this.max)}distanceToPoint(t){return o0.copy(t).clamp(this.min,this.max).sub(t).length()}intersect(t){return this.min.max(t.min),this.max.min(t.max),this}union(t){return this.min.min(t.min),this.max.max(t.max),this}translate(t){return this.min.add(t),this.max.add(t),this}equals(t){return t.min.equals(this.min)&&t.max.equals(this.max)}};Yi.prototype.isBox2=!0;var a0=new T,$a=new T,Yh=class{constructor(t=new T,e=new T){this.start=t,this.end=e}set(t,e){return this.start.copy(t),this.end.copy(e),this}copy(t){return this.start.copy(t.start),this.end.copy(t.end),this}getCenter(t){return t.addVectors(this.start,this.end).multiplyScalar(.5)}delta(t){return t.subVectors(this.end,this.start)}distanceSq(){return this.start.distanceToSquared(this.end)}distance(){return this.start.distanceTo(this.end)}at(t,e){return this.delta(e).multiplyScalar(t).add(this.start)}closestPointToPointParameter(t,e){a0.subVectors(t,this.start),$a.subVectors(this.end,this.start);let i=$a.dot($a),s=$a.dot(a0)/i;return e&&(s=Ie(s,0,1)),s}closestPointToPoint(t,e,i){let r=this.closestPointToPointParameter(t,e);return this.delta(i).multiplyScalar(r).add(this.start)}applyMatrix4(t){return this.start.applyMatrix4(t),this.end.applyMatrix4(t),this}equals(t){return t.start.equals(this.start)&&t.end.equals(this.end)}clone(){return new this.constructor().copy(this)}};var Qn=new T,Ka=new wt,Fu=new wt,Zh=class extends go{constructor(t){let e=D0(t),i=new Ht,r=[],s=[],o=new ft(0,0,1),a=new ft(0,1,0);for(let c=0;c<e.length;c++){let u=e[c];u.parent&&u.parent.isBone&&(r.push(0,0,0),r.push(0,0,0),s.push(o.r,o.g,o.b),s.push(a.r,a.g,a.b))}i.setAttribute("position",new ee(r,3)),i.setAttribute("color",new ee(s,3));let l=new zn({vertexColors:!0,depthTest:!1,depthWrite:!1,toneMapped:!1,transparent:!0});super(i,l),this.type="SkeletonHelper",this.isSkeletonHelper=!0,this.root=t,this.bones=e,this.matrix=t.matrixWorld,this.matrixAutoUpdate=!1}updateMatrixWorld(t){let e=this.bones,i=this.geometry,r=i.getAttribute("position");Fu.copy(this.root.matrixWorld).invert();for(let s=0,o=0;s<e.length;s++){let a=e[s];a.parent&&a.parent.isBone&&(Ka.multiplyMatrices(Fu,a.matrixWorld),Qn.setFromMatrixPosition(Ka),r.setXYZ(o,Qn.x,Qn.y,Qn.z),Ka.multiplyMatrices(Fu,a.parent.matrixWorld),Qn.setFromMatrixPosition(Ka),r.setXYZ(o+1,Qn.x,Qn.y,Qn.z),o+=2)}i.getAttribute("position").needsUpdate=!0,super.updateMatrixWorld(t)}};function D0(n){let t=[];n&&n.isBone&&t.push(n);for(let e=0;e<n.children.length;e++)t.push.apply(t,D0(n.children[e]));return t}var Jh=class extends go{constructor(t=10,e=10,i=4473924,r=8947848){i=new ft(i),r=new ft(r);let s=e/2,o=t/e,a=t/2,l=[],c=[];for(let f=0,d=0,g=-a;f<=e;f++,g+=o){l.push(-a,0,g,a,0,g),l.push(g,0,-a,g,0,a);let x=f===s?i:r;x.toArray(c,d),d+=3,x.toArray(c,d),d+=3,x.toArray(c,d),d+=3,x.toArray(c,d),d+=3}let u=new Ht;u.setAttribute("position",new ee(l,3)),u.setAttribute("color",new ee(c,3));let h=new zn({vertexColors:!0,toneMapped:!1});super(u,h),this.type="GridHelper"}};var _T=new Float32Array(1),Ck=new Int32Array(_T.buffer);Fe.create=function(n,t){return console.log("THREE.Curve.create() has been deprecated"),n.prototype=Object.create(Fe.prototype),n.prototype.constructor=n,n.prototype.getPoint=t,n};_o.prototype.fromPoints=function(n){return console.warn("THREE.Path: .fromPoints() has been renamed to .setFromPoints()."),this.setFromPoints(n)};Jh.prototype.setColors=function(){console.error("THREE.GridHelper: setColors() has been deprecated, pass them in the constructor instead.")};Zh.prototype.update=function(){console.error("THREE.SkeletonHelper: update() no longer needs to be called.")};mn.prototype.extractUrlBase=function(n){return console.warn("THREE.Loader: .extractUrlBase() has been deprecated. Use THREE.LoaderUtils.extractUrlBase() instead."),Dh.extractUrlBase(n)};mn.Handlers={add:function(){console.error("THREE.Loader: Handlers.add() has been removed. Use LoadingManager.addHandler() instead.")},get:function(){console.error("THREE.Loader: Handlers.get() has been removed. Use LoadingManager.getHandler() instead.")}};Yi.prototype.center=function(n){return console.warn("THREE.Box2: .center() has been renamed to .getCenter()."),this.getCenter(n)};Yi.prototype.empty=function(){return console.warn("THREE.Box2: .empty() has been renamed to .isEmpty()."),this.isEmpty()};Yi.prototype.isIntersectionBox=function(n){return console.warn("THREE.Box2: .isIntersectionBox() has been renamed to .intersectsBox()."),this.intersectsBox(n)};Yi.prototype.size=function(n){return console.warn("THREE.Box2: .size() has been renamed to .getSize()."),this.getSize(n)};Ge.prototype.center=function(n){return console.warn("THREE.Box3: .center() has been renamed to .getCenter()."),this.getCenter(n)};Ge.prototype.empty=function(){return console.warn("THREE.Box3: .empty() has been renamed to .isEmpty()."),this.isEmpty()};Ge.prototype.isIntersectionBox=function(n){return console.warn("THREE.Box3: .isIntersectionBox() has been renamed to .intersectsBox()."),this.intersectsBox(n)};Ge.prototype.isIntersectionSphere=function(n){return console.warn("THREE.Box3: .isIntersectionSphere() has been renamed to .intersectsSphere()."),this.intersectsSphere(n)};Ge.prototype.size=function(n){return console.warn("THREE.Box3: .size() has been renamed to .getSize()."),this.getSize(n)};si.prototype.empty=function(){return console.warn("THREE.Sphere: .empty() has been renamed to .isEmpty()."),this.isEmpty()};qr.prototype.setFromMatrix=function(n){return console.warn("THREE.Frustum: .setFromMatrix() has been renamed to .setFromProjectionMatrix()."),this.setFromProjectionMatrix(n)};Yh.prototype.center=function(n){return console.warn("THREE.Line3: .center() has been renamed to .getCenter()."),this.getCenter(n)};de.prototype.flattenToArrayOffset=function(n,t){return console.warn("THREE.Matrix3: .flattenToArrayOffset() has been deprecated. Use .toArray() instead."),this.toArray(n,t)};de.prototype.multiplyVector3=function(n){return console.warn("THREE.Matrix3: .multiplyVector3() has been removed. Use vector.applyMatrix3( matrix ) instead."),n.applyMatrix3(this)};de.prototype.multiplyVector3Array=function(){console.error("THREE.Matrix3: .multiplyVector3Array() has been removed.")};de.prototype.applyToBufferAttribute=function(n){return console.warn("THREE.Matrix3: .applyToBufferAttribute() has been removed. Use attribute.applyMatrix3( matrix ) instead."),n.applyMatrix3(this)};de.prototype.applyToVector3Array=function(){console.error("THREE.Matrix3: .applyToVector3Array() has been removed.")};de.prototype.getInverse=function(n){return console.warn("THREE.Matrix3: .getInverse() has been removed. Use matrixInv.copy( matrix ).invert(); instead."),this.copy(n).invert()};wt.prototype.extractPosition=function(n){return console.warn("THREE.Matrix4: .extractPosition() has been renamed to .copyPosition()."),this.copyPosition(n)};wt.prototype.flattenToArrayOffset=function(n,t){return console.warn("THREE.Matrix4: .flattenToArrayOffset() has been deprecated. Use .toArray() instead."),this.toArray(n,t)};wt.prototype.getPosition=function(){return console.warn("THREE.Matrix4: .getPosition() has been removed. Use Vector3.setFromMatrixPosition( matrix ) instead."),new T().setFromMatrixColumn(this,3)};wt.prototype.setRotationFromQuaternion=function(n){return console.warn("THREE.Matrix4: .setRotationFromQuaternion() has been renamed to .makeRotationFromQuaternion()."),this.makeRotationFromQuaternion(n)};wt.prototype.multiplyToArray=function(){console.warn("THREE.Matrix4: .multiplyToArray() has been removed.")};wt.prototype.multiplyVector3=function(n){return console.warn("THREE.Matrix4: .multiplyVector3() has been removed. Use vector.applyMatrix4( matrix ) instead."),n.applyMatrix4(this)};wt.prototype.multiplyVector4=function(n){return console.warn("THREE.Matrix4: .multiplyVector4() has been removed. Use vector.applyMatrix4( matrix ) instead."),n.applyMatrix4(this)};wt.prototype.multiplyVector3Array=function(){console.error("THREE.Matrix4: .multiplyVector3Array() has been removed.")};wt.prototype.rotateAxis=function(n){console.warn("THREE.Matrix4: .rotateAxis() has been removed. Use Vector3.transformDirection( matrix ) instead."),n.transformDirection(this)};wt.prototype.crossVector=function(n){return console.warn("THREE.Matrix4: .crossVector() has been removed. Use vector.applyMatrix4( matrix ) instead."),n.applyMatrix4(this)};wt.prototype.translate=function(){console.error("THREE.Matrix4: .translate() has been removed.")};wt.prototype.rotateX=function(){console.error("THREE.Matrix4: .rotateX() has been removed.")};wt.prototype.rotateY=function(){console.error("THREE.Matrix4: .rotateY() has been removed.")};wt.prototype.rotateZ=function(){console.error("THREE.Matrix4: .rotateZ() has been removed.")};wt.prototype.rotateByAxis=function(){console.error("THREE.Matrix4: .rotateByAxis() has been removed.")};wt.prototype.applyToBufferAttribute=function(n){return console.warn("THREE.Matrix4: .applyToBufferAttribute() has been removed. Use attribute.applyMatrix4( matrix ) instead."),n.applyMatrix4(this)};wt.prototype.applyToVector3Array=function(){console.error("THREE.Matrix4: .applyToVector3Array() has been removed.")};wt.prototype.makeFrustum=function(n,t,e,i,r,s){return console.warn("THREE.Matrix4: .makeFrustum() has been removed. Use .makePerspective( left, right, top, bottom, near, far ) instead."),this.makePerspective(n,t,i,e,r,s)};wt.prototype.getInverse=function(n){return console.warn("THREE.Matrix4: .getInverse() has been removed. Use matrixInv.copy( matrix ).invert(); instead."),this.copy(n).invert()};je.prototype.isIntersectionLine=function(n){return console.warn("THREE.Plane: .isIntersectionLine() has been renamed to .intersectsLine()."),this.intersectsLine(n)};Ee.prototype.multiplyVector3=function(n){return console.warn("THREE.Quaternion: .multiplyVector3() has been removed. Use is now vector.applyQuaternion( quaternion ) instead."),n.applyQuaternion(this)};Ee.prototype.inverse=function(){return console.warn("THREE.Quaternion: .inverse() has been renamed to invert()."),this.invert()};oi.prototype.isIntersectionBox=function(n){return console.warn("THREE.Ray: .isIntersectionBox() has been renamed to .intersectsBox()."),this.intersectsBox(n)};oi.prototype.isIntersectionPlane=function(n){return console.warn("THREE.Ray: .isIntersectionPlane() has been renamed to .intersectsPlane()."),this.intersectsPlane(n)};oi.prototype.isIntersectionSphere=function(n){return console.warn("THREE.Ray: .isIntersectionSphere() has been renamed to .intersectsSphere()."),this.intersectsSphere(n)};re.prototype.area=function(){return console.warn("THREE.Triangle: .area() has been renamed to .getArea()."),this.getArea()};re.prototype.barycoordFromPoint=function(n,t){return console.warn("THREE.Triangle: .barycoordFromPoint() has been renamed to .getBarycoord()."),this.getBarycoord(n,t)};re.prototype.midpoint=function(n){return console.warn("THREE.Triangle: .midpoint() has been renamed to .getMidpoint()."),this.getMidpoint(n)};re.prototypenormal=function(n){return console.warn("THREE.Triangle: .normal() has been renamed to .getNormal()."),this.getNormal(n)};re.prototype.plane=function(n){return console.warn("THREE.Triangle: .plane() has been renamed to .getPlane()."),this.getPlane(n)};re.barycoordFromPoint=function(n,t,e,i,r){return console.warn("THREE.Triangle: .barycoordFromPoint() has been renamed to .getBarycoord()."),re.getBarycoord(n,t,e,i,r)};re.normal=function(n,t,e,i){return console.warn("THREE.Triangle: .normal() has been renamed to .getNormal()."),re.getNormal(n,t,e,i)};Un.prototype.extractAllPoints=function(n){return console.warn("THREE.Shape: .extractAllPoints() has been removed. Use .extractPoints() instead."),this.extractPoints(n)};Un.prototype.extrude=function(n){return console.warn("THREE.Shape: .extrude() has been removed. Use ExtrudeGeometry() instead."),new ci(this,n)};Un.prototype.makeGeometry=function(n){return console.warn("THREE.Shape: .makeGeometry() has been removed. Use ShapeGeometry() instead."),new qi(this,n)};K.prototype.fromAttribute=function(n,t,e){return console.warn("THREE.Vector2: .fromAttribute() has been renamed to .fromBufferAttribute()."),this.fromBufferAttribute(n,t,e)};K.prototype.distanceToManhattan=function(n){return console.warn("THREE.Vector2: .distanceToManhattan() has been renamed to .manhattanDistanceTo()."),this.manhattanDistanceTo(n)};K.prototype.lengthManhattan=function(){return console.warn("THREE.Vector2: .lengthManhattan() has been renamed to .manhattanLength()."),this.manhattanLength()};T.prototype.setEulerFromRotationMatrix=function(){console.error("THREE.Vector3: .setEulerFromRotationMatrix() has been removed. Use Euler.setFromRotationMatrix() instead.")};T.prototype.setEulerFromQuaternion=function(){console.error("THREE.Vector3: .setEulerFromQuaternion() has been removed. Use Euler.setFromQuaternion() instead.")};T.prototype.getPositionFromMatrix=function(n){return console.warn("THREE.Vector3: .getPositionFromMatrix() has been renamed to .setFromMatrixPosition()."),this.setFromMatrixPosition(n)};T.prototype.getScaleFromMatrix=function(n){return console.warn("THREE.Vector3: .getScaleFromMatrix() has been renamed to .setFromMatrixScale()."),this.setFromMatrixScale(n)};T.prototype.getColumnFromMatrix=function(n,t){return console.warn("THREE.Vector3: .getColumnFromMatrix() has been renamed to .setFromMatrixColumn()."),this.setFromMatrixColumn(t,n)};T.prototype.applyProjection=function(n){return console.warn("THREE.Vector3: .applyProjection() has been removed. Use .applyMatrix4( m ) instead."),this.applyMatrix4(n)};T.prototype.fromAttribute=function(n,t,e){return console.warn("THREE.Vector3: .fromAttribute() has been renamed to .fromBufferAttribute()."),this.fromBufferAttribute(n,t,e)};T.prototype.distanceToManhattan=function(n){return console.warn("THREE.Vector3: .distanceToManhattan() has been renamed to .manhattanDistanceTo()."),this.manhattanDistanceTo(n)};T.prototype.lengthManhattan=function(){return console.warn("THREE.Vector3: .lengthManhattan() has been renamed to .manhattanLength()."),this.manhattanLength()};Wt.prototype.fromAttribute=function(n,t,e){return console.warn("THREE.Vector4: .fromAttribute() has been renamed to .fromBufferAttribute()."),this.fromBufferAttribute(n,t,e)};Wt.prototype.lengthManhattan=function(){return console.warn("THREE.Vector4: .lengthManhattan() has been renamed to .manhattanLength()."),this.manhattanLength()};kt.prototype.getChildByName=function(n){return console.warn("THREE.Object3D: .getChildByName() has been renamed to .getObjectByName()."),this.getObjectByName(n)};kt.prototype.renderDepth=function(){console.warn("THREE.Object3D: .renderDepth has been removed. Use .renderOrder, instead.")};kt.prototype.translate=function(n,t){return console.warn("THREE.Object3D: .translate() has been removed. Use .translateOnAxis( axis, distance ) instead."),this.translateOnAxis(t,n)};kt.prototype.getWorldRotation=function(){console.error("THREE.Object3D: .getWorldRotation() has been removed. Use THREE.Object3D.getWorldQuaternion( target ) instead.")};kt.prototype.applyMatrix=function(n){return console.warn("THREE.Object3D: .applyMatrix() has been renamed to .applyMatrix4()."),this.applyMatrix4(n)};Object.defineProperties(kt.prototype,{eulerOrder:{get:function(){return console.warn("THREE.Object3D: .eulerOrder is now .rotation.order."),this.rotation.order},set:function(n){console.warn("THREE.Object3D: .eulerOrder is now .rotation.order."),this.rotation.order=n}},useQuaternion:{get:function(){console.warn("THREE.Object3D: .useQuaternion has been removed. The library now uses quaternions by default.")},set:function(){console.warn("THREE.Object3D: .useQuaternion has been removed. The library now uses quaternions by default.")}}});oe.prototype.setDrawMode=function(){console.error("THREE.Mesh: .setDrawMode() has been removed. The renderer now always assumes THREE.TrianglesDrawMode. Transform your geometry via BufferGeometryUtils.toTrianglesDrawMode() if necessary.")};Object.defineProperties(oe.prototype,{drawMode:{get:function(){return console.error("THREE.Mesh: .drawMode has been removed. The renderer now always assumes THREE.TrianglesDrawMode."),$w},set:function(){console.error("THREE.Mesh: .drawMode has been removed. The renderer now always assumes THREE.TrianglesDrawMode. Transform your geometry via BufferGeometryUtils.toTrianglesDrawMode() if necessary.")}}});dl.prototype.initBones=function(){console.error("THREE.SkinnedMesh: initBones() has been removed.")};Se.prototype.setLens=function(n,t){console.warn("THREE.PerspectiveCamera.setLens is deprecated. Use .setFocalLength and .filmGauge for a photographic setup."),t!==void 0&&(this.filmGauge=t),this.setFocalLength(n)};Object.defineProperties(Ye.prototype,{onlyShadow:{set:function(){console.warn("THREE.Light: .onlyShadow has been removed.")}},shadowCameraFov:{set:function(n){console.warn("THREE.Light: .shadowCameraFov is now .shadow.camera.fov."),this.shadow.camera.fov=n}},shadowCameraLeft:{set:function(n){console.warn("THREE.Light: .shadowCameraLeft is now .shadow.camera.left."),this.shadow.camera.left=n}},shadowCameraRight:{set:function(n){console.warn("THREE.Light: .shadowCameraRight is now .shadow.camera.right."),this.shadow.camera.right=n}},shadowCameraTop:{set:function(n){console.warn("THREE.Light: .shadowCameraTop is now .shadow.camera.top."),this.shadow.camera.top=n}},shadowCameraBottom:{set:function(n){console.warn("THREE.Light: .shadowCameraBottom is now .shadow.camera.bottom."),this.shadow.camera.bottom=n}},shadowCameraNear:{set:function(n){console.warn("THREE.Light: .shadowCameraNear is now .shadow.camera.near."),this.shadow.camera.near=n}},shadowCameraFar:{set:function(n){console.warn("THREE.Light: .shadowCameraFar is now .shadow.camera.far."),this.shadow.camera.far=n}},shadowCameraVisible:{set:function(){console.warn("THREE.Light: .shadowCameraVisible has been removed. Use new THREE.CameraHelper( light.shadow.camera ) instead.")}},shadowBias:{set:function(n){console.warn("THREE.Light: .shadowBias is now .shadow.bias."),this.shadow.bias=n}},shadowDarkness:{set:function(){console.warn("THREE.Light: .shadowDarkness has been removed.")}},shadowMapWidth:{set:function(n){console.warn("THREE.Light: .shadowMapWidth is now .shadow.mapSize.width."),this.shadow.mapSize.width=n}},shadowMapHeight:{set:function(n){console.warn("THREE.Light: .shadowMapHeight is now .shadow.mapSize.height."),this.shadow.mapSize.height=n}}});Object.defineProperties(Qt.prototype,{length:{get:function(){return console.warn("THREE.BufferAttribute: .length has been deprecated. Use .count instead."),this.array.length}},dynamic:{get:function(){return console.warn("THREE.BufferAttribute: .dynamic has been deprecated. Use .usage instead."),this.usage===nl},set:function(){console.warn("THREE.BufferAttribute: .dynamic has been deprecated. Use .usage instead."),this.setUsage(nl)}}});Qt.prototype.setDynamic=function(n){return console.warn("THREE.BufferAttribute: .setDynamic() has been deprecated. Use .setUsage() instead."),this.setUsage(n===!0?nl:io),this};Qt.prototype.copyIndicesArray=function(){console.error("THREE.BufferAttribute: .copyIndicesArray() has been removed.")},Qt.prototype.setArray=function(){console.error("THREE.BufferAttribute: .setArray has been removed. Use BufferGeometry .setAttribute to replace/resize attribute buffers")};Ht.prototype.addIndex=function(n){console.warn("THREE.BufferGeometry: .addIndex() has been renamed to .setIndex()."),this.setIndex(n)};Ht.prototype.addAttribute=function(n,t){return console.warn("THREE.BufferGeometry: .addAttribute() has been renamed to .setAttribute()."),!(t&&t.isBufferAttribute)&&!(t&&t.isInterleavedBufferAttribute)?(console.warn("THREE.BufferGeometry: .addAttribute() now expects ( name, attribute )."),this.setAttribute(n,new Qt(arguments[1],arguments[2]))):n==="index"?(console.warn("THREE.BufferGeometry.addAttribute: Use .setIndex() for index attribute."),this.setIndex(t),this):this.setAttribute(n,t)};Ht.prototype.addDrawCall=function(n,t,e){e!==void 0&&console.warn("THREE.BufferGeometry: .addDrawCall() no longer supports indexOffset."),console.warn("THREE.BufferGeometry: .addDrawCall() is now .addGroup()."),this.addGroup(n,t)};Ht.prototype.clearDrawCalls=function(){console.warn("THREE.BufferGeometry: .clearDrawCalls() is now .clearGroups()."),this.clearGroups()};Ht.prototype.computeOffsets=function(){console.warn("THREE.BufferGeometry: .computeOffsets() has been removed.")};Ht.prototype.removeAttribute=function(n){return console.warn("THREE.BufferGeometry: .removeAttribute() has been renamed to .deleteAttribute()."),this.deleteAttribute(n)};Ht.prototype.applyMatrix=function(n){return console.warn("THREE.BufferGeometry: .applyMatrix() has been renamed to .applyMatrix4()."),this.applyMatrix4(n)};Object.defineProperties(Ht.prototype,{drawcalls:{get:function(){return console.error("THREE.BufferGeometry: .drawcalls has been renamed to .groups."),this.groups}},offsets:{get:function(){return console.warn("THREE.BufferGeometry: .offsets has been renamed to .groups."),this.groups}}});Gi.prototype.setDynamic=function(n){return console.warn("THREE.InterleavedBuffer: .setDynamic() has been deprecated. Use .setUsage() instead."),this.setUsage(n===!0?nl:io),this};Gi.prototype.setArray=function(){console.error("THREE.InterleavedBuffer: .setArray has been removed. Use BufferGeometry .setAttribute to replace/resize attribute buffers")};ci.prototype.getArrays=function(){console.error("THREE.ExtrudeGeometry: .getArrays() has been removed.")};ci.prototype.addShapeList=function(){console.error("THREE.ExtrudeGeometry: .addShapeList() has been removed.")};ci.prototype.addShape=function(){console.error("THREE.ExtrudeGeometry: .addShape() has been removed.")};Yr.prototype.dispose=function(){console.error("THREE.Scene: .dispose() has been removed.")};To.prototype.onUpdate=function(){return console.warn("THREE.Uniform: .onUpdate() has been removed. Use object.onBeforeRender() instead."),this};Object.defineProperties(xe.prototype,{wrapAround:{get:function(){console.warn("THREE.Material: .wrapAround has been removed.")},set:function(){console.warn("THREE.Material: .wrapAround has been removed.")}},overdraw:{get:function(){console.warn("THREE.Material: .overdraw has been removed.")},set:function(){console.warn("THREE.Material: .overdraw has been removed.")}},wrapRGB:{get:function(){return console.warn("THREE.Material: .wrapRGB has been removed."),new ft}},shading:{get:function(){console.error("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead.")},set:function(n){console.warn("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead."),this.flatShading=n===c0}},stencilMask:{get:function(){return console.warn("THREE."+this.type+": .stencilMask has been removed. Use .stencilFuncMask instead."),this.stencilFuncMask},set:function(n){console.warn("THREE."+this.type+": .stencilMask has been removed. Use .stencilFuncMask instead."),this.stencilFuncMask=n}},vertexTangents:{get:function(){console.warn("THREE."+this.type+": .vertexTangents has been removed.")},set:function(){console.warn("THREE."+this.type+": .vertexTangents has been removed.")}}});Object.defineProperties(Fn.prototype,{derivatives:{get:function(){return console.warn("THREE.ShaderMaterial: .derivatives has been moved to .extensions.derivatives."),this.extensions.derivatives},set:function(n){console.warn("THREE. ShaderMaterial: .derivatives has been moved to .extensions.derivatives."),this.extensions.derivatives=n}}});Vt.prototype.clearTarget=function(n,t,e,i){console.warn("THREE.WebGLRenderer: .clearTarget() has been deprecated. Use .setRenderTarget() and .clear() instead."),this.setRenderTarget(n),this.clear(t,e,i)};Vt.prototype.animate=function(n){console.warn("THREE.WebGLRenderer: .animate() is now .setAnimationLoop()."),this.setAnimationLoop(n)};Vt.prototype.getCurrentRenderTarget=function(){return console.warn("THREE.WebGLRenderer: .getCurrentRenderTarget() is now .getRenderTarget()."),this.getRenderTarget()};Vt.prototype.getMaxAnisotropy=function(){return console.warn("THREE.WebGLRenderer: .getMaxAnisotropy() is now .capabilities.getMaxAnisotropy()."),this.capabilities.getMaxAnisotropy()};Vt.prototype.getPrecision=function(){return console.warn("THREE.WebGLRenderer: .getPrecision() is now .capabilities.precision."),this.capabilities.precision};Vt.prototype.resetGLState=function(){return console.warn("THREE.WebGLRenderer: .resetGLState() is now .state.reset()."),this.state.reset()};Vt.prototype.supportsFloatTextures=function(){return console.warn("THREE.WebGLRenderer: .supportsFloatTextures() is now .extensions.get( 'OES_texture_float' )."),this.extensions.get("OES_texture_float")};Vt.prototype.supportsHalfFloatTextures=function(){return console.warn("THREE.WebGLRenderer: .supportsHalfFloatTextures() is now .extensions.get( 'OES_texture_half_float' )."),this.extensions.get("OES_texture_half_float")};Vt.prototype.supportsStandardDerivatives=function(){return console.warn("THREE.WebGLRenderer: .supportsStandardDerivatives() is now .extensions.get( 'OES_standard_derivatives' )."),this.extensions.get("OES_standard_derivatives")};Vt.prototype.supportsCompressedTextureS3TC=function(){return console.warn("THREE.WebGLRenderer: .supportsCompressedTextureS3TC() is now .extensions.get( 'WEBGL_compressed_texture_s3tc' )."),this.extensions.get("WEBGL_compressed_texture_s3tc")};Vt.prototype.supportsCompressedTexturePVRTC=function(){return console.warn("THREE.WebGLRenderer: .supportsCompressedTexturePVRTC() is now .extensions.get( 'WEBGL_compressed_texture_pvrtc' )."),this.extensions.get("WEBGL_compressed_texture_pvrtc")};Vt.prototype.supportsBlendMinMax=function(){return console.warn("THREE.WebGLRenderer: .supportsBlendMinMax() is now .extensions.get( 'EXT_blend_minmax' )."),this.extensions.get("EXT_blend_minmax")};Vt.prototype.supportsVertexTextures=function(){return console.warn("THREE.WebGLRenderer: .supportsVertexTextures() is now .capabilities.vertexTextures."),this.capabilities.vertexTextures};Vt.prototype.supportsInstancedArrays=function(){return console.warn("THREE.WebGLRenderer: .supportsInstancedArrays() is now .extensions.get( 'ANGLE_instanced_arrays' )."),this.extensions.get("ANGLE_instanced_arrays")};Vt.prototype.enableScissorTest=function(n){console.warn("THREE.WebGLRenderer: .enableScissorTest() is now .setScissorTest()."),this.setScissorTest(n)};Vt.prototype.initMaterial=function(){console.warn("THREE.WebGLRenderer: .initMaterial() has been removed.")};Vt.prototype.addPrePlugin=function(){console.warn("THREE.WebGLRenderer: .addPrePlugin() has been removed.")};Vt.prototype.addPostPlugin=function(){console.warn("THREE.WebGLRenderer: .addPostPlugin() has been removed.")};Vt.prototype.updateShadowMap=function(){console.warn("THREE.WebGLRenderer: .updateShadowMap() has been removed.")};Vt.prototype.setFaceCulling=function(){console.warn("THREE.WebGLRenderer: .setFaceCulling() has been removed.")};Vt.prototype.allocTextureUnit=function(){console.warn("THREE.WebGLRenderer: .allocTextureUnit() has been removed.")};Vt.prototype.setTexture=function(){console.warn("THREE.WebGLRenderer: .setTexture() has been removed.")};Vt.prototype.setTexture2D=function(){console.warn("THREE.WebGLRenderer: .setTexture2D() has been removed.")};Vt.prototype.setTextureCube=function(){console.warn("THREE.WebGLRenderer: .setTextureCube() has been removed.")};Vt.prototype.getActiveMipMapLevel=function(){return console.warn("THREE.WebGLRenderer: .getActiveMipMapLevel() is now .getActiveMipmapLevel()."),this.getActiveMipmapLevel()};Object.defineProperties(Vt.prototype,{shadowMapEnabled:{get:function(){return this.shadowMap.enabled},set:function(n){console.warn("THREE.WebGLRenderer: .shadowMapEnabled is now .shadowMap.enabled."),this.shadowMap.enabled=n}},shadowMapType:{get:function(){return this.shadowMap.type},set:function(n){console.warn("THREE.WebGLRenderer: .shadowMapType is now .shadowMap.type."),this.shadowMap.type=n}},shadowMapCullFace:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMapCullFace has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMapCullFace has been removed. Set Material.shadowSide instead.")}},context:{get:function(){return console.warn("THREE.WebGLRenderer: .context has been removed. Use .getContext() instead."),this.getContext()}},vr:{get:function(){return console.warn("THREE.WebGLRenderer: .vr has been renamed to .xr"),this.xr}},gammaInput:{get:function(){return console.warn("THREE.WebGLRenderer: .gammaInput has been removed. Set the encoding for textures via Texture.encoding instead."),!1},set:function(){console.warn("THREE.WebGLRenderer: .gammaInput has been removed. Set the encoding for textures via Texture.encoding instead.")}},gammaOutput:{get:function(){return console.warn("THREE.WebGLRenderer: .gammaOutput has been removed. Set WebGLRenderer.outputEncoding instead."),!1},set:function(n){console.warn("THREE.WebGLRenderer: .gammaOutput has been removed. Set WebGLRenderer.outputEncoding instead."),this.outputEncoding=n===!0?$t:ri}},toneMappingWhitePoint:{get:function(){return console.warn("THREE.WebGLRenderer: .toneMappingWhitePoint has been removed."),1},set:function(){console.warn("THREE.WebGLRenderer: .toneMappingWhitePoint has been removed.")}},gammaFactor:{get:function(){return console.warn("THREE.WebGLRenderer: .gammaFactor has been removed."),2},set:function(){console.warn("THREE.WebGLRenderer: .gammaFactor has been removed.")}}});Object.defineProperties(T0.prototype,{cullFace:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMap.cullFace has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMap.cullFace has been removed. Set Material.shadowSide instead.")}},renderReverseSided:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderReverseSided has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderReverseSided has been removed. Set Material.shadowSide instead.")}},renderSingleSided:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderSingleSided has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderSingleSided has been removed. Set Material.shadowSide instead.")}}});Object.defineProperties(Ne.prototype,{wrapS:{get:function(){return console.warn("THREE.WebGLRenderTarget: .wrapS is now .texture.wrapS."),this.texture.wrapS},set:function(n){console.warn("THREE.WebGLRenderTarget: .wrapS is now .texture.wrapS."),this.texture.wrapS=n}},wrapT:{get:function(){return console.warn("THREE.WebGLRenderTarget: .wrapT is now .texture.wrapT."),this.texture.wrapT},set:function(n){console.warn("THREE.WebGLRenderTarget: .wrapT is now .texture.wrapT."),this.texture.wrapT=n}},magFilter:{get:function(){return console.warn("THREE.WebGLRenderTarget: .magFilter is now .texture.magFilter."),this.texture.magFilter},set:function(n){console.warn("THREE.WebGLRenderTarget: .magFilter is now .texture.magFilter."),this.texture.magFilter=n}},minFilter:{get:function(){return console.warn("THREE.WebGLRenderTarget: .minFilter is now .texture.minFilter."),this.texture.minFilter},set:function(n){console.warn("THREE.WebGLRenderTarget: .minFilter is now .texture.minFilter."),this.texture.minFilter=n}},anisotropy:{get:function(){return console.warn("THREE.WebGLRenderTarget: .anisotropy is now .texture.anisotropy."),this.texture.anisotropy},set:function(n){console.warn("THREE.WebGLRenderTarget: .anisotropy is now .texture.anisotropy."),this.texture.anisotropy=n}},offset:{get:function(){return console.warn("THREE.WebGLRenderTarget: .offset is now .texture.offset."),this.texture.offset},set:function(n){console.warn("THREE.WebGLRenderTarget: .offset is now .texture.offset."),this.texture.offset=n}},repeat:{get:function(){return console.warn("THREE.WebGLRenderTarget: .repeat is now .texture.repeat."),this.texture.repeat},set:function(n){console.warn("THREE.WebGLRenderTarget: .repeat is now .texture.repeat."),this.texture.repeat=n}},format:{get:function(){return console.warn("THREE.WebGLRenderTarget: .format is now .texture.format."),this.texture.format},set:function(n){console.warn("THREE.WebGLRenderTarget: .format is now .texture.format."),this.texture.format=n}},type:{get:function(){return console.warn("THREE.WebGLRenderTarget: .type is now .texture.type."),this.texture.type},set:function(n){console.warn("THREE.WebGLRenderTarget: .type is now .texture.type."),this.texture.type=n}},generateMipmaps:{get:function(){return console.warn("THREE.WebGLRenderTarget: .generateMipmaps is now .texture.generateMipmaps."),this.texture.generateMipmaps},set:function(n){console.warn("THREE.WebGLRenderTarget: .generateMipmaps is now .texture.generateMipmaps."),this.texture.generateMipmaps=n}}});Bh.prototype.load=function(n){console.warn("THREE.Audio: .load has been deprecated. Use THREE.AudioLoader instead.");let t=this;return new Fh().load(n,function(i){t.setBuffer(i)}),this};Oh.prototype.getData=function(){return console.warn("THREE.AudioAnalyser: .getData() is now .getFrequencyData()."),this.getFrequencyData()};ao.prototype.updateCubeMap=function(n,t){return console.warn("THREE.CubeCamera: .updateCubeMap() is now .update()."),this.update(n,t)};ao.prototype.clear=function(n,t,e,i){return console.warn("THREE.CubeCamera: .clear() is now .renderTarget.clear()."),this.renderTarget.clear(n,t,e,i)};Nn.crossOrigin=void 0;Nn.loadTexture=function(n,t,e,i){console.warn("THREE.ImageUtils.loadTexture has been deprecated. Use THREE.TextureLoader() instead.");let r=new Eh;r.setCrossOrigin(this.crossOrigin);let s=r.load(n,e,void 0,i);return t&&(s.mapping=t),s};Nn.loadTextureCube=function(n,t,e,i){console.warn("THREE.ImageUtils.loadTextureCube has been deprecated. Use THREE.CubeTextureLoader() instead.");let r=new Sh;r.setCrossOrigin(this.crossOrigin);let s=r.load(n,e,void 0,i);return t&&(s.mapping=t),s};Nn.loadCompressedTexture=function(){console.error("THREE.ImageUtils.loadCompressedTexture has been removed. Use THREE.DDSLoader instead.")};Nn.loadCompressedTextureCube=function(){console.error("THREE.ImageUtils.loadCompressedTextureCube has been removed. Use THREE.DDSLoader instead.")};typeof __THREE_DEVTOOLS__!="undefined"&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("register",{detail:{revision:$h}}));typeof window!="undefined"&&(window.__THREE__?console.warn("WARNING: Multiple instances of Three.js being imported."):window.__THREE__=$h);function rf(n,t,e){if(e===1)return new ft(t);let i=pi(t);if(!i)throw new Error(`d3 failed to recognize the color: ${t}`);return new ft(sc(i,n)(1-e))}var gn;(function(n){n[n.CIRCLE=0]="CIRCLE",n[n.LINE=1]="LINE",n[n.TRIANGLE=2]="TRIANGLE",n[n.TRAPEZOID=3]="TRAPEZOID"})(gn||(gn={}));function N0(n,t){let e=t.length/2,i=n.attributes.position;(!i||i.count!==e*3)&&(i=new Qt(new Float32Array(e*3),3),n.setAttribute("position",i));let r=i.array;for(let s=0;s<e;s++)r[s*3]=t[s*2],r[s*3+1]=t[s*2+1];i.needsUpdate=!0,n.setDrawRange(0,e*3),n.computeBoundingSphere()}function F0(n,t,e){let i=Math.max(t.length/2-1,0),r=i*2*3,s=r*3,o=n.attributes.position;(!o||o.count!==r)&&(o=new Qt(new Float32Array(s),3),n.setAttribute("position",o));let a=o.array;for(let l=0;l<i;l++){let[c,u,h,f]=[t[2*l],t[2*l+1],t[2*l+2],t[2*l+3]],d=new K(c,u),g=new K(h,f),x=new K(h-c,f-u),v=new K(-x.y,x.x).setLength(e/2),m=d.clone().add(v),p=d.clone().sub(v),b=g.clone().add(v),_=g.clone().sub(v),S=[m.x,m.y,0,p.x,p.y,0,b.x,b.y,0,b.x,b.y,0,p.x,p.y,0,_.x,_.y,0];a.set(S,l*S.length)}o.needsUpdate=!0,n.setDrawRange(0,s),n.computeBoundingSphere()}function Il(n,t,e,i){let{visible:r,color:s,opacity:o}=i;if(Array.isArray(t.material))throw new Error("Invariant error: only expect one material on an object");let a=t.material;if(a.visible!==r&&(a.visible=r,a.needsUpdate=!0),!r)return!1;let l=rf(n,s,o!=null?o:1),c=e(t.geometry);return t.geometry!==c&&(t.geometry=c),a.color.equals(l)||(a.color.set(l),a.needsUpdate=!0),!0}var wT={createScene:()=>new Yr},Ro=class{constructor(t,e,i,r){this.coordinator=e,this.scene=wT.createScene(),this.backgroundColor="#fff",Di.isWebGl2OffscreenCanvasSupported()&&t instanceof OffscreenCanvas&&(t.style=t.style||{}),r&&t.addEventListener("webglcontextlost",r),this.renderer=new Vt({canvas:t,antialias:!0,alpha:!0}),this.renderer.setPixelRatio(i)}onResize(t){this.renderer.setSize(t.width,t.height)}destroyObject(t){let e=t.obj3d;if(this.scene.remove(e),e instanceof oe){e.geometry.dispose();let i=Array.isArray(e.material)?e.material:[e.material];for(let r of i)r.dispose()}}setUseDarkMode(t){this.backgroundColor=t?"#303030":"#fff"}createOrUpdateLineObject(t,e,i){var u;if(!t&&!i.visible)return null;let{visible:r,width:s}=i;if(!t){let h=rf(this.backgroundColor,i.color,(u=i.opacity)!=null?u:1),f=new Ht,d=new zn({color:h}),g=new oe(f,d);return d.visible=r,F0(f,e,s),this.scene.add(g),{type:gn.LINE,data:e,obj3d:g,width:s}}let{data:o,obj3d:a,width:l}=t;return Il(this.backgroundColor,a,h=>((s!==l||!o||!Di.arePolylinesEqual(o,e))&&F0(h,e,s),h),i)?{type:gn.LINE,data:e,obj3d:a,width:s}:t}createMesh(t,e){if(!e.visible)return null;let{visible:i,color:r,opacity:s}=e,o=rf(this.backgroundColor,r,s!=null?s:1),a=new ki({color:o,visible:i});return new oe(t,a)}createOrUpdateTriangleObject(t,e,i){let{size:r}=i,s=r*Math.sqrt(3)/2,o=new Float32Array([e.x-r/2,e.y-s/3,e.x+r/2,e.y-s/3,e.x,e.y+s*2/3]);if(!t){let l=new Ht;N0(l,o);let c=this.createMesh(l,i);return c===null?null:(this.scene.add(c),{type:gn.TRIANGLE,data:e,obj3d:c})}return Il(this.backgroundColor,t.obj3d,l=>(N0(l,o),l),i)?{type:gn.TRIANGLE,data:e,obj3d:t.obj3d}:t}createOrUpdateCircleObject(t,e,i){let{radius:r}=i,s=new Zr(i.radius);if(!t){let a=this.createMesh(s,i);return a===null?null:(a.position.set(e.x,e.y,0),this.scene.add(a),{type:gn.CIRCLE,data:{loc:e,radius:r},obj3d:a})}return Il(this.backgroundColor,t.obj3d,()=>s,i)?(t.obj3d.position.set(e.x,e.y,0),{type:gn.CIRCLE,data:{loc:e,radius:r},obj3d:t.obj3d}):t}createOrUpdateTrapezoidObject(t,e,i,r){if(e.y!==i.y)throw new RangeError("Input error: start.y != end.y.");let{altitude:s}=r,o=2/Math.sqrt(3)*s,a=new Un([new K(e.x-o/2,e.y-s/2),new K(e.x,e.y+s/2),new K(i.x,i.y+s/2),new K(i.x+o/2,i.y-s/2)]);a.autoClose=!0;let l=new qi(a);if(!t){let u=this.createMesh(l,r);return u===null?null:(this.scene.add(u),{type:gn.TRAPEZOID,data:[e,i],obj3d:u})}return Il(this.backgroundColor,t.obj3d,()=>l,r)?{type:gn.TRAPEZOID,data:[e,i],obj3d:t.obj3d}:t}flush(){this.renderer.render(this.scene,this.coordinator.getCamera())}dispose(){this.renderer.dispose()}};var Nl=class{constructor(t,e){this.renderCache=t,this.renderer=e}setLine(t,e,i){let r=this.renderer.createOrUpdateLineObject(this.renderCache.getFromPreviousFrame(t),e,i);r&&this.renderCache.setToCurrentFrame(t,r)}setTriangle(t,e,i){let r=this.renderer.createOrUpdateTriangleObject(this.renderCache.getFromPreviousFrame(t),e,i);r&&this.renderCache.setToCurrentFrame(t,r)}setCircle(t,e,i){let r=this.renderer.createOrUpdateCircleObject(this.renderCache.getFromPreviousFrame(t),e,i);r&&this.renderCache.setToCurrentFrame(t,r)}setTrapezoid(t,e,i,r){let s=this.renderer.createOrUpdateTrapezoidObject(this.renderCache.getFromPreviousFrame(t),e,i,r);s&&this.renderCache.setToCurrentFrame(t,s)}};var sf=class{constructor(){this.prevFrameCache=new Map,this.currFrameCache=new Map}getFromPreviousFrame(t){let e=this.prevFrameCache.get(t);return e!=null?e:null}setToCurrentFrame(t,e){this.currFrameCache.set(t,e)}finalizeFrameAndGetRemoved(){let t=[];for(let[e,i]of this.prevFrameCache.entries())this.currFrameCache.has(e)||t.push(i);return this.prevFrameCache=this.currFrameCache,this.currFrameCache=new Map,t}},Fl=class{constructor(t){this.rawSeriesData=[],this.series=[],this.paintDirty=!0,this.renderCache=new sf,this.coordinateIdentifier=null,this.layout={x:0,width:1,y:0,height:1},this.getMetadataMapImpl=t.getMetadataMap,this.coordinator=t.coordinator,this.renderer=t.renderer,this.paintBrush=new Nl(this.renderCache,this.renderer)}setLayoutRect(t){(this.layout.x!==t.x||this.layout.width!==t.width||this.layout.y!==t.y||this.layout.height!==t.height)&&(this.paintDirty=!0),this.layout=t}getLayoutRect(){return this.layout}getMetadataMap(){return this.getMetadataMapImpl()}markAsPaintDirty(){this.paintDirty=!0}render(){if(this.transformCoordinatesIfStale(),!!this.paintDirty){this.redraw();for(let t of this.renderCache.finalizeFrameAndGetRemoved())this.renderer.destroyObject(t);this.paintDirty=!1}}isCoordinateUpdated(){return this.coordinator.getUpdateIdentifier()!==this.coordinateIdentifier}clearCoordinateIdentifier(){this.coordinateIdentifier=null}setData(t){this.clearCoordinateIdentifier(),this.rawSeriesData=t}transformCoordinatesIfStale(){if(!this.isCoordinateUpdated())return;let t=this.getLayoutRect();this.series=new Array(this.rawSeriesData.length);for(let e=0;e<this.rawSeriesData.length;e++){let i=this.rawSeriesData[e];this.series[e]={id:i.id,polyline:new Float32Array(i.points.length*2)};for(let r=0;r<i.points.length;r++){let[s,o]=this.coordinator.transformDataToUiCoord(t,[i.points[r].x,i.points[r].y]);this.series[e].polyline[r*2]=s,this.series[e].polyline[r*2+1]=o}}this.coordinateIdentifier=this.coordinator.getUpdateIdentifier(),this.markAsPaintDirty()}};var Lo;(function(n){n[n.NUMBER=0]="NUMBER",n[n.NAN=1]="NAN"})(Lo||(Lo={}));var zl=class extends Fl{recordPartition(t,e,i){return t?{type:Lo.NUMBER,polyline:e}:{type:Lo.NAN,polyline:e.map((r,s)=>isNaN(r)?s%2===0?i.x:i.y:r)}}partitionPolyline(t){let e=[],i=0,r=!1,s=this.coordinator.transformDataToUiCoord(this.getLayoutRect(),[0,0]),o={x:s[0],y:s[1]},a=null;for(let l=0;l<t.length;l+=2){let c=t[l],u=t[l+1],h=isNaN(c)||isNaN(u);h!==r&&i!==l&&(e.push(this.recordPartition(!r,t.slice(i,l),a===null?{x:c,y:u}:a)),i=l),h||(a={x:c,y:u}),r=h}return i!==t.length-1&&e.push(this.recordPartition(!r,t.slice(i,t.length),a!=null?a:o)),e}redraw(){var t,e,i;for(let r of this.series){let o=this.getMetadataMap()[r.id];if(!o)continue;if(r.polyline.length%2!==0)throw new Error(`Cannot have odd length-ed polyline: ${r.polyline.length}`);let a=this.partitionPolyline(r.polyline);for(let[l,{type:c,polyline:u}]of a.entries())if(c===Lo.NUMBER)u.length===2?this.paintBrush.setCircle(JSON.stringify(["circle",r.id,l]),{x:u[0],y:u[1]},{color:o.color,visible:o.visible,opacity:(t=o.opacity)!=null?t:1,radius:4}):this.paintBrush.setLine(JSON.stringify(["line",r.id,l]),u,{color:o.color,visible:o.visible,opacity:(e=o.opacity)!=null?e:1,width:2});else if(!o.aux)for(let h=0;h<u.length;h+=2)this.paintBrush.setTriangle(JSON.stringify(["NaN",r.id,u[h],u[h+1]]),{x:u[h],y:u[h+1]},{color:o.color,visible:o.visible,opacity:(i=o.opacity)!=null?i:1,size:12})}}};var Ul=class extends dr{constructor(){super(...arguments),this.camera=new Vi(0,1e3,1e3,0,0,100)}isYAxisPointedDown(){return!1}setDomContainerRect(t){super.setDomContainerRect(t),this.camera.left=t.x,this.camera.right=t.x+t.width,this.camera.top=t.y+t.height,this.camera.bottom=t.y,this.camera.updateProjectionMatrix()}getCamera(){return this.camera}};var MT={requestAnimationFrame:n=>self.requestAnimationFrame(n)},Bl=class{constructor(t){switch(this.metadataMap={},this.shouldRepaint=!1,this.callbacks=t.callbacks,t.type){case Tn.SVG:{this.coordinator=new dr,this.renderer=new Os(t.container);break}case Tn.WEBGL:{let e=new Ul;this.coordinator=e,this.renderer=new Ro(t.container,e,t.devicePixelRatio,t.callbacks.onContextLost);break}}this.renderer.setUseDarkMode(t.useDarkMode),this.seriesLineView=new zl({renderer:this.renderer,coordinator:this.coordinator,getMetadataMap:()=>this.metadataMap}),this.resize(t.domDimension)}dispose(){}setXScaleType(t){this.coordinator.setXScale(fr(t)),this.scheduleRepaint()}setYScaleType(t){this.coordinator.setYScale(fr(t)),this.scheduleRepaint()}resize(t){this.coordinator.setDomContainerRect(No({x:0,y:0},t)),this.renderer.onResize(No({x:0,y:0},t)),this.seriesLineView.setLayoutRect(uf(No({},t),{x:0,y:0})),this.scheduleRepaint()}setMetadata(t){let e=!1;Object.entries(t).forEach(([i,r])=>{let s=this.metadataMap[i];(!s||r.color!==s.color||r.visible!==s.visible||r.opacity!==s.opacity)&&(e=!0),this.metadataMap[i]=r}),e&&this.seriesLineView.markAsPaintDirty(),this.scheduleRepaint()}setViewBox(t){this.coordinator.setViewBoxRect({x:t.x[0],width:t.x[1]-t.x[0],y:t.y[0],height:t.y[1]-t.y[0]}),this.scheduleRepaint()}setData(t){this.seriesLineView.setData(t),this.scheduleRepaint()}setUseDarkMode(t){this.renderer.setUseDarkMode(t),this.seriesLineView.markAsPaintDirty(),this.scheduleRepaint()}scheduleRepaint(){this.shouldRepaint||(this.shouldRepaint=!0,MT.requestAnimationFrame(()=>{this.repaint(),this.shouldRepaint=!1}))}repaint(){this.seriesLineView.render(),this.renderer.flush(),this.callbacks.onDrawEnd()}};function z0(n){let{flattenedSeries:t,idsAndLengths:e}=n,i=new Float64Array(t),r=[];if(i.length%2!==0)throw new Error("`flattenedSeries` must have even number of elements");let s=0;for(let{id:o,length:a}of e){let l=[];for(let c=0;c<a;c++)l.push({x:i[s++],y:i[s++]});r.push({id:o,points:l})}return r}var xn;(function(n){n[n.SERIES_DATA_UPDATED=0]="SERIES_DATA_UPDATED",n[n.SERIES_METADATA_CHANGED=1]="SERIES_METADATA_CHANGED",n[n.SCALE_UPDATED=2]="SCALE_UPDATED",n[n.VIEW_BOX_UPDATED=3]="VIEW_BOX_UPDATED",n[n.INIT=4]="INIT",n[n.DOM_RESIZED=5]="DOM_RESIZED",n[n.DARK_MODE_UPDATED=6]="DARK_MODE_UPDATED",n[n.DISPOSED=7]="DISPOSED"})(xn||(xn={}));var Po;(function(n){n[n.ON_REDRAW_END=0]="ON_REDRAW_END",n[n.ON_CONTEXT_LOST=1]="ON_CONTEXT_LOST"})(Po||(Po={}));self.addEventListener("message",n=>{bT(n.ports[0],n.data)});function bT(n,t){let{canvas:e,devicePixelRatio:i,dim:r,rendererType:s,useDarkMode:o}=t,a={onDrawEnd:()=>{n.postMessage({type:Po.ON_REDRAW_END})},onContextLost:()=>{n.postMessage({type:Po.ON_CONTEXT_LOST})}},l;switch(s){case Tn.WEBGL:l={type:Tn.WEBGL,domDimension:r,callbacks:a,container:e,devicePixelRatio:i,useDarkMode:o};break;default:throw new RangeError(`Invariant error: cannot have Offscreen chart for renderer type: ${s}`)}let c=new Bl(l);n.onmessage=function(u){let h=u.data;switch(h.type){case xn.SERIES_DATA_UPDATED:{let f=z0(h.compactDataSeries);c.setData(f);break}case xn.SERIES_METADATA_CHANGED:{c.setMetadata(h.metadata);break}case xn.VIEW_BOX_UPDATED:{c.setViewBox(h.extent);break}case xn.DOM_RESIZED:{c.resize(h.dim);break}case xn.DARK_MODE_UPDATED:{c.setUseDarkMode(h.useDarkMode);break}case xn.SCALE_UPDATED:{switch(h.axis){case"x":c.setXScaleType(h.scaleType);break;case"y":c.setYScaleType(h.scaleType);break;default:let f=h.axis;throw new RangeError(`Unknown axis: ${f}`)}break}case xn.DISPOSED:{c.dispose();break}}}}})();
/**
 * @license
 * Copyright 2010-2022 Three.js Authors
 * SPDX-License-Identifier: MIT
 */
//# sourceMappingURL=chart_worker.js.map
", + "ok": true, + "headers": [ + [ + "content-type", + "text/javascript; charset=utf-8" + ] + ], + "status": 200, + "status_text": "" + } + }, + "base_uri": "https://localhost:8080/", + "height": 821 + }, + "id": "MD7xsURDMNS7", + "outputId": "7b8f2484-062e-47fa-da47-9de26a9e59dc" + }, + "execution_count": 74, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "application/javascript": [ + "\n", + " (async () => {\n", + " const url = new URL(await google.colab.kernel.proxyPort(6006, {'cache': true}));\n", + " url.searchParams.set('tensorboardColab', 'true');\n", + " const iframe = document.createElement('iframe');\n", + " iframe.src = url;\n", + " iframe.setAttribute('width', '100%');\n", + " iframe.setAttribute('height', '800');\n", + " iframe.setAttribute('frameborder', 0);\n", + " document.body.appendChild(iframe);\n", + " })();\n", + " " + ] + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "execution_count": 75, "metadata": { "id": "u_OCtijuI7gv" }, @@ -5736,7 +6030,7 @@ }, { "cell_type": "code", - "execution_count": 72, + "execution_count": 76, "metadata": { "id": "dy4FuwhrLKzr" }, @@ -5760,7 +6054,7 @@ }, { "cell_type": "code", - "execution_count": 73, + "execution_count": 77, "metadata": { "id": "a4zeQFbF9XLm" }, @@ -5804,10 +6098,7 @@ "colab": { "machine_shape": "hm", "provenance": [], - "gpuType": "V100", - "mount_file_id": "1alsWE48suOuUXaoAJQpo3-kuU2UJYXKR", - "authorship_tag": "ABX9TyObfpBhwmNpqCwlzBRknm+c", - "include_colab_link": true + "gpuType": "T4" }, "kernelspec": { "display_name": "Python 3", diff --git a/06_transfer_learning_in_tensorflow_part_3_scaling_up.ipynb b/06_transfer_learning_in_tensorflow_part_3_scaling_up.ipynb index 1137434..5a50d87 100644 --- a/06_transfer_learning_in_tensorflow_part_3_scaling_up.ipynb +++ b/06_transfer_learning_in_tensorflow_part_3_scaling_up.ipynb @@ -5,10 +5,7 @@ "colab": { "provenance": [], "machine_shape": "hm", - "gpuType": "A100", - "mount_file_id": "1WbPqk3XTXrHdu181_3KgdtU5EY3CteNM", - "authorship_tag": "ABX9TyNY6pm5bSDVhJC3Z1vQ1GUI", - "include_colab_link": true + "gpuType": "A100" }, "kernelspec": { "name": "python3", @@ -21,8 +18,7 @@ { "cell_type": "markdown", "metadata": { - "id": "view-in-github", - "colab_type": "text" + "id": "view-in-github" }, "source": [ "\"Open" @@ -75,9 +71,9 @@ "\n", "Don't worry if you make mistakes, we all do. The way to get better and make less mistakes is to **write more code**.\n", "\n", - "> 📖 **Resources:** \n", + "> 📖 **Resources:**\n", "> * See the full set of course materials on GitHub: https://github.com/mrdbourke/tensorflow-deep-learning\n", - "> * See updates for this notebook here: https://github.com/mrdbourke/tensorflow-deep-learning/discussions/549 " + "> * See updates for this notebook here: https://github.com/mrdbourke/tensorflow-deep-learning/discussions/549" ] }, { @@ -90,11 +86,11 @@ "outputId": "9ac3e7c3-3eb7-4344-f8e9-af5583fd7da6" }, "source": [ - "# Are we using a GPU? \n", + "# Are we using a GPU?\n", "# If not, and you're in Google Colab, go to Runtime -> Change runtime type -> Hardware accelerator -> GPU\n", "!nvidia-smi" ], - "execution_count": 1, + "execution_count": null, "outputs": [ { "output_type": "stream", @@ -124,6 +120,32 @@ } ] }, + { + "cell_type": "code", + "source": [ + "# Settings Tensorboard\n", + "\n", + "# Load the TensorBoard notebook extension\n", + "%load_ext tensorboard" + ], + "metadata": { + "id": "KOeQi-H5MgdK" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Clear any logs from previous runs\n", + "!rm -rf ./logs/" + ], + "metadata": { + "id": "qT1CL83nMmHl" + }, + "execution_count": null, + "outputs": [] + }, { "cell_type": "code", "source": [ @@ -137,7 +159,7 @@ "id": "pCN9joRSpsbw", "outputId": "497639be-27cc-4540-821e-6f3db1908ed8" }, - "execution_count": 2, + "execution_count": null, "outputs": [ { "output_type": "stream", @@ -172,7 +194,7 @@ "# Get helper functions file\n", "!wget https://raw.githubusercontent.com/mrdbourke/tensorflow-deep-learning/main/extras/helper_functions.py" ], - "execution_count": 3, + "execution_count": null, "outputs": [ { "output_type": "stream", @@ -193,6 +215,29 @@ } ] }, + { + "cell_type": "code", + "source": [ + "# New TensorBoard\n", + "\n", + "# Create tensorboard callback (functionized because need to create a new one for each model)\n", + "import datetime\n", + "import os\n", + "def create_tensorboard_callback(experiment_name):\n", + " logfit_dir = \"logs/fit/\"\n", + " path_experiment = os.path.join(logfit_dir, experiment_name, datetime.datetime.now().strftime(\"%Y%m%d-%H%M%S\"))\n", + " tensorboard_callback = tf.keras.callbacks.TensorBoard(\n", + " log_dir=path_experiment\n", + " )\n", + " print(f\"Saving TensorBoard log files to: {logfit_dir}\")\n", + " return tensorboard_callback" + ], + "metadata": { + "id": "UI7lWGINMbcT" + }, + "execution_count": null, + "outputs": [] + }, { "cell_type": "code", "metadata": { @@ -200,9 +245,9 @@ }, "source": [ "# Import series of helper functions for the notebook (we've created/used these in previous notebooks)\n", - "from helper_functions import create_tensorboard_callback, plot_loss_curves, unzip_data, compare_historys, walk_through_dir" + "from helper_functions import plot_loss_curves, unzip_data, compare_historys, walk_through_dir" ], - "execution_count": 4, + "execution_count": null, "outputs": [] }, { @@ -246,14 +291,14 @@ }, "source": [ "# Download data from Google Storage (already preformatted)\n", - "!wget https://storage.googleapis.com/ztm_tf_course/food_vision/101_food_classes_10_percent.zip \n", + "!wget https://storage.googleapis.com/ztm_tf_course/food_vision/101_food_classes_10_percent.zip\n", "\n", "unzip_data(\"101_food_classes_10_percent.zip\")\n", "\n", "train_dir = \"101_food_classes_10_percent/train/\"\n", "test_dir = \"101_food_classes_10_percent/test/\"" ], - "execution_count": 5, + "execution_count": null, "outputs": [ { "output_type": "stream", @@ -287,7 +332,7 @@ "# How many images/classes are there?\n", "walk_through_dir(\"101_food_classes_10_percent\")" ], - "execution_count": 6, + "execution_count": null, "outputs": [ { "output_type": "stream", @@ -556,13 +601,13 @@ "train_data_all_10_percent = tf.keras.preprocessing.image_dataset_from_directory(train_dir,\n", " label_mode=\"categorical\",\n", " image_size=IMG_SIZE)\n", - " \n", + "\n", "test_data = tf.keras.preprocessing.image_dataset_from_directory(test_dir,\n", " label_mode=\"categorical\",\n", " image_size=IMG_SIZE,\n", " shuffle=False) # don't shuffle test data for prediction analysis" ], - "execution_count": 7, + "execution_count": null, "outputs": [ { "output_type": "stream", @@ -580,7 +625,7 @@ "id": "GRWVadimqFeg" }, "source": [ - "Wonderful! It looks like our data has been imported as expected with 75 images per class in the training set (75 images * 101 classes = 7575 images) and 25250 images in the test set (250 images * 101 classes = 25250 images). \n", + "Wonderful! It looks like our data has been imported as expected with 75 images per class in the training set (75 images * 101 classes = 7575 images) and 25250 images in the test set (250 images * 101 classes = 25250 images).\n", "\n", "\n", "## Train a big dog model with transfer learning on 10% of 101 food classes\n", @@ -600,7 +645,7 @@ "\n", "It seems like a lot but these are all things we've covered before in the [Transfer Learning in TensorFlow Part 2: Fine-tuning notebook](https://github.com/mrdbourke/tensorflow-deep-learning/blob/main/05_transfer_learning_in_tensorflow_part_2_fine_tuning.ipynb).\n", "\n", - "Let's start by creating the `ModelCheckpoint` callback. \n", + "Let's start by creating the `ModelCheckpoint` callback.\n", "\n", "Since we want our model to perform well on unseen data we'll set it to monitor the validation accuracy metric and save the model weights which score the best on that." ] @@ -618,7 +663,7 @@ " monitor=\"val_accuracy\", # save the model weights which score the best validation accuracy\n", " save_best_only=True) # only keep the best model weights on file (delete the rest)" ], - "execution_count": 8, + "execution_count": null, "outputs": [] }, { @@ -662,7 +707,7 @@ "# # preprocessing.Rescaling(1./255) # keep for models like ResNet50V2, remove for EfficientNet\n", "# ], name=\"data_augmentation\")" ], - "execution_count": 9, + "execution_count": null, "outputs": [] }, { @@ -700,7 +745,7 @@ "outputs = layers.Dense(len(train_data_all_10_percent.class_names), activation=\"softmax\", name=\"output_layer\")(x) # same number of outputs as classes\n", "model = tf.keras.Model(inputs, outputs)" ], - "execution_count": 10, + "execution_count": null, "outputs": [ { "output_type": "stream", @@ -737,7 +782,7 @@ "# Get a summary of our model\n", "model.summary()" ], - "execution_count": 11, + "execution_count": null, "outputs": [ { "output_type": "stream", @@ -803,7 +848,7 @@ " validation_steps=int(0.15 * len(test_data)), # evaluate on smaller portion of test data\n", " callbacks=[checkpoint_callback]) # save best model weights to file" ], - "execution_count": 12, + "execution_count": null, "outputs": [ { "output_type": "stream", @@ -842,11 +887,11 @@ "outputId": "712e6988-1c0e-4cc9-d979-717eb1d2cf60" }, "source": [ - "# Evaluate model \n", + "# Evaluate model\n", "results_feature_extraction_model = model.evaluate(test_data)\n", "results_feature_extraction_model" ], - "execution_count": 13, + "execution_count": null, "outputs": [ { "output_type": "stream", @@ -891,7 +936,7 @@ "source": [ "plot_loss_curves(history_all_classes_10_percent)" ], - "execution_count": 14, + "execution_count": null, "outputs": [ { "output_type": "display_data", @@ -954,7 +999,7 @@ "for layer in base_model.layers[:-5]:\n", " layer.trainable = False" ], - "execution_count": 15, + "execution_count": null, "outputs": [] }, { @@ -984,7 +1029,7 @@ " optimizer=tf.keras.optimizers.Adam(1e-4), # 10x lower learning rate than default\n", " metrics=['accuracy'])" ], - "execution_count": 16, + "execution_count": null, "outputs": [] }, { @@ -1010,7 +1055,7 @@ "for layer in model.layers:\n", " print(layer.name, layer.trainable)" ], - "execution_count": 17, + "execution_count": null, "outputs": [ { "output_type": "stream", @@ -1039,7 +1084,7 @@ "for layer_number, layer in enumerate(base_model.layers):\n", " print(layer_number, layer.name, layer.trainable)" ], - "execution_count": 18, + "execution_count": null, "outputs": [ { "output_type": "stream", @@ -1319,7 +1364,7 @@ " validation_steps=int(0.15 * len(test_data)), # validate on 15% of the test data\n", " initial_epoch=history_all_classes_10_percent.epoch[-1]) # start from previous last epoch" ], - "execution_count": 19, + "execution_count": null, "outputs": [ { "output_type": "stream", @@ -1364,7 +1409,7 @@ "results_all_classes_10_percent_fine_tune = model.evaluate(test_data)\n", "results_all_classes_10_percent_fine_tune" ], - "execution_count": 20, + "execution_count": null, "outputs": [ { "output_type": "stream", @@ -1391,7 +1436,7 @@ "id": "bMSF7Qfe9cJI" }, "source": [ - "Hmm... it seems like our model got a slight boost from fine-tuning. \n", + "Hmm... it seems like our model got a slight boost from fine-tuning.\n", "\n", "We might get a better picture by using our `compare_historys()` function and seeing what the training curves say." ] @@ -1411,7 +1456,7 @@ " new_history=history_all_classes_10_percent_fine_tune,\n", " initial_epochs=5)" ], - "execution_count": 21, + "execution_count": null, "outputs": [ { "output_type": "display_data", @@ -1431,7 +1476,7 @@ "id": "qW03mqzx9z3R" }, "source": [ - "It seems that after fine-tuning, our model's training metrics improved significantly but validation, not so much. Looks like our model is starting to overfit. \n", + "It seems that after fine-tuning, our model's training metrics improved significantly but validation, not so much. Looks like our model is starting to overfit.\n", "\n", "This is okay though, its very often the case that fine-tuning leads to overfitting when the data a pre-trained model has been trained on is similar to your custom data.\n", "\n", @@ -1457,10 +1502,10 @@ "id": "b_n1TFbl_FPp" }, "source": [ - "# # Save model to drive so it can be used later \n", + "# # Save model to drive so it can be used later\n", "# model.save(\"drive/My Drive/tensorflow_course/101_food_class_10_percent_saved_big_dog_model\")" ], - "execution_count": 22, + "execution_count": null, "outputs": [] }, { @@ -1524,7 +1569,7 @@ "loaded_loss, loaded_accuracy = model.evaluate(test_data)\n", "loaded_loss, loaded_accuracy" ], - "execution_count": 24, + "execution_count": null, "outputs": [ { "output_type": "stream", @@ -1584,9 +1629,9 @@ }, "source": [ "# Make predictions with model\n", - "pred_probs = model.predict(test_data, verbose=1) # set verbosity to see how long it will take " + "pred_probs = model.predict(test_data, verbose=1) # set verbosity to see how long it will take" ], - "execution_count": 25, + "execution_count": null, "outputs": [ { "output_type": "stream", @@ -1621,7 +1666,7 @@ "# How many predictions are there?\n", "len(pred_probs)" ], - "execution_count": 26, + "execution_count": null, "outputs": [ { "output_type": "execute_result", @@ -1657,7 +1702,7 @@ "# What's the shape of our predictions?\n", "pred_probs.shape" ], - "execution_count": 27, + "execution_count": null, "outputs": [ { "output_type": "execute_result", @@ -1695,7 +1740,7 @@ "# How do they look?\n", "pred_probs[:10]" ], - "execution_count": 28, + "execution_count": null, "outputs": [ { "output_type": "execute_result", @@ -1745,7 +1790,7 @@ "print(f\"What prediction probability sample 0 looks like:\\n {pred_probs[0]}\")\n", "print(f\"The class with the highest predicted probability by the model for sample 0: {pred_probs[0].argmax()}\")" ], - "execution_count": 29, + "execution_count": null, "outputs": [ { "output_type": "stream", @@ -1815,7 +1860,7 @@ "# How do they look?\n", "pred_classes[:10]" ], - "execution_count": 30, + "execution_count": null, "outputs": [ { "output_type": "execute_result", @@ -1862,7 +1907,7 @@ " y_labels.append(labels.numpy().argmax()) # append the index which has the largest value (labels are one-hot)\n", "y_labels[:10] # check what they look like (unshuffled)" ], - "execution_count": 31, + "execution_count": null, "outputs": [ { "output_type": "execute_result", @@ -1900,7 +1945,7 @@ "# How many labels are there? (should be the same as how many prediction probabilities we have)\n", "len(y_labels)" ], - "execution_count": 32, + "execution_count": null, "outputs": [ { "output_type": "execute_result", @@ -1951,7 +1996,7 @@ "sklearn_accuracy = accuracy_score(y_labels, pred_classes)\n", "sklearn_accuracy" ], - "execution_count": 33, + "execution_count": null, "outputs": [ { "output_type": "execute_result", @@ -1979,7 +2024,7 @@ "import numpy as np\n", "print(f\"Close? {np.isclose(loaded_accuracy, sklearn_accuracy)} | Difference: {loaded_accuracy - sklearn_accuracy}\")" ], - "execution_count": 34, + "execution_count": null, "outputs": [ { "output_type": "stream", @@ -2009,12 +2054,12 @@ "id": "K6jZXmXUYUf_" }, "source": [ - "# We'll import our make_confusion_matrix function from https://github.com/mrdbourke/tensorflow-deep-learning/blob/main/extras/helper_functions.py \n", + "# We'll import our make_confusion_matrix function from https://github.com/mrdbourke/tensorflow-deep-learning/blob/main/extras/helper_functions.py\n", "# But if you run it out of the box, it doesn't really work for 101 classes...\n", "# the cell below adds a little functionality to make it readable.\n", "from helper_functions import make_confusion_matrix" ], - "execution_count": 35, + "execution_count": null, "outputs": [] }, { @@ -2023,7 +2068,7 @@ "id": "oMp8hlTZYXw-" }, "source": [ - "# Note: The following confusion matrix code is a remix of Scikit-Learn's \n", + "# Note: The following confusion matrix code is a remix of Scikit-Learn's\n", "# plot_confusion_matrix function - https://scikit-learn.org/stable/modules/generated/sklearn.metrics.plot_confusion_matrix.html\n", "import itertools\n", "import matplotlib.pyplot as plt\n", @@ -2031,7 +2076,7 @@ "from sklearn.metrics import confusion_matrix\n", "\n", "# Our function needs a different name to sklearn's plot_confusion_matrix\n", - "def make_confusion_matrix(y_true, y_pred, classes=None, figsize=(10, 10), text_size=15, norm=False, savefig=False): \n", + "def make_confusion_matrix(y_true, y_pred, classes=None, figsize=(10, 10), text_size=15, norm=False, savefig=False):\n", " \"\"\"Makes a labelled confusion matrix comparing predictions and ground truth labels.\n", "\n", " If classes is passed, confusion matrix will be labelled, if not, integer class values\n", @@ -2045,7 +2090,7 @@ " text_size: Size of output figure text (default=15).\n", " norm: normalize values or not (default=False).\n", " savefig: save confusion matrix to file (default=False).\n", - " \n", + "\n", " Returns:\n", " A labelled confusion matrix plot comparing y_true and y_pred.\n", "\n", @@ -2055,7 +2100,7 @@ " classes=class_names, # array of class label names\n", " figsize=(15, 15),\n", " text_size=10)\n", - " \"\"\" \n", + " \"\"\"\n", " # Create the confustion matrix\n", " cm = confusion_matrix(y_true, y_pred)\n", " cm_norm = cm.astype(\"float\") / cm.sum(axis=1)[:, np.newaxis] # normalize it\n", @@ -2071,16 +2116,16 @@ " labels = classes\n", " else:\n", " labels = np.arange(cm.shape[0])\n", - " \n", + "\n", " # Label the axes\n", " ax.set(title=\"Confusion Matrix\",\n", " xlabel=\"Predicted label\",\n", " ylabel=\"True label\",\n", " xticks=np.arange(n_classes), # create enough axis slots for each class\n", - " yticks=np.arange(n_classes), \n", + " yticks=np.arange(n_classes),\n", " xticklabels=labels, # axes will labeled with class names (if they exist) or ints\n", " yticklabels=labels)\n", - " \n", + "\n", " # Make x-axis labels appear on bottom\n", " ax.xaxis.set_label_position(\"bottom\")\n", " ax.xaxis.tick_bottom()\n", @@ -2109,7 +2154,7 @@ " if savefig:\n", " fig.savefig(\"confusion_matrix.png\")" ], - "execution_count": 36, + "execution_count": null, "outputs": [] }, { @@ -2135,7 +2180,7 @@ "class_names = test_data.class_names\n", "class_names[:10]" ], - "execution_count": 54, + "execution_count": null, "outputs": [ { "output_type": "execute_result", @@ -2187,7 +2232,7 @@ " norm=False,\n", " savefig=True)" ], - "execution_count": 38, + "execution_count": null, "outputs": [ { "output_type": "display_data", @@ -2230,7 +2275,7 @@ "from sklearn.metrics import classification_report\n", "print(classification_report(y_labels, pred_classes))" ], - "execution_count": 39, + "execution_count": null, "outputs": [ { "output_type": "stream", @@ -2382,7 +2427,7 @@ "classification_report_dict = classification_report(y_labels, pred_classes, output_dict=True)\n", "classification_report_dict" ], - "execution_count": 58, + "execution_count": null, "outputs": [ { "output_type": "execute_result", @@ -2811,7 +2856,7 @@ "id": "ahHfjQmcVc5x" }, "source": [ - "Alright, there's still a fair few values here, how about we narrow down? \n", + "Alright, there's still a fair few values here, how about we narrow down?\n", "\n", "Since the f1-score combines precision and recall in one metric, let's focus on that.\n", "\n", @@ -2839,7 +2884,7 @@ " class_f1_scores[class_names[int(k)]] = v[\"f1-score\"]\n", "class_f1_scores" ], - "execution_count": 41, + "execution_count": null, "outputs": [ { "output_type": "execute_result", @@ -2983,7 +3028,7 @@ " \"f1-score\": list(class_f1_scores.values())}).sort_values(\"f1-score\", ascending=False)\n", "f1_scores.head()" ], - "execution_count": 59, + "execution_count": null, "outputs": [ { "output_type": "execute_result", @@ -3177,7 +3222,7 @@ "\n", "autolabel(scores)" ], - "execution_count": 43, + "execution_count": null, "outputs": [ { "output_type": "display_data", @@ -3260,7 +3305,7 @@ " else:\n", " return img" ], - "execution_count": 44, + "execution_count": null, "outputs": [] }, { @@ -3271,7 +3316,7 @@ "source": [ "Image loading and preprocessing function ready.\n", "\n", - "Now let's write some code to: \n", + "Now let's write some code to:\n", "\n", "1. Load a few random images from the test dataset.\n", "2. Make predictions on them.\n", @@ -3295,7 +3340,7 @@ "\n", "plt.figure(figsize=(17, 10))\n", "for i in range(3):\n", - " # Choose a random image from a random class \n", + " # Choose a random image from a random class\n", " class_name = random.choice(class_names)\n", " filename = random.choice(os.listdir(test_dir + \"/\" + class_name))\n", " filepath = test_dir + class_name + \"/\" + filename\n", @@ -3303,7 +3348,7 @@ " # Load the image and make predictions\n", " img = load_and_prep_image(filepath, scale=False) # don't scale images for EfficientNet predictions\n", " pred_prob = model.predict(tf.expand_dims(img, axis=0)) # model accepts tensors of shape [None, 224, 224, 3]\n", - " pred_class = class_names[pred_prob.argmax()] # find the predicted class \n", + " pred_class = class_names[pred_prob.argmax()] # find the predicted class\n", "\n", " # Plot the image(s)\n", " plt.subplot(1, 3, i+1)\n", @@ -3315,7 +3360,7 @@ " plt.title(f\"actual: {class_name}, pred: {pred_class}, prob: {pred_prob.max():.2f}\", c=title_color)\n", " plt.axis(False);" ], - "execution_count": 45, + "execution_count": null, "outputs": [ { "output_type": "stream", @@ -3384,12 +3429,12 @@ "source": [ "# 1. Get the filenames of all of our test data\n", "filepaths = []\n", - "for filepath in test_data.list_files(\"101_food_classes_10_percent/test/*/*.jpg\", \n", + "for filepath in test_data.list_files(\"101_food_classes_10_percent/test/*/*.jpg\",\n", " shuffle=False):\n", " filepaths.append(filepath.numpy())\n", "filepaths[:10]" ], - "execution_count": 46, + "execution_count": null, "outputs": [ { "output_type": "execute_result", @@ -3423,7 +3468,7 @@ "* The class the model predicted (`pred_classes`).\n", "* The maximum prediction probabilitity value (`pred_probs.max(axis=1)`).\n", "* The ground truth class names.\n", - "* The predicted class names. " + "* The predicted class names." ] }, { @@ -3444,10 +3489,10 @@ " \"y_pred\": pred_classes,\n", " \"pred_conf\": pred_probs.max(axis=1), # get the maximum prediction probability value\n", " \"y_true_classname\": [class_names[i] for i in y_labels],\n", - " \"y_pred_classname\": [class_names[i] for i in pred_classes]}) \n", + " \"y_pred_classname\": [class_names[i] for i in pred_classes]})\n", "pred_df.head()" ], - "execution_count": 47, + "execution_count": null, "outputs": [ { "output_type": "execute_result", @@ -3653,7 +3698,7 @@ "pred_df[\"pred_correct\"] = pred_df[\"y_true\"] == pred_df[\"y_pred\"]\n", "pred_df.head()" ], - "execution_count": 48, + "execution_count": null, "outputs": [ { "output_type": "execute_result", @@ -3865,7 +3910,7 @@ "top_100_wrong = pred_df[pred_df[\"pred_correct\"] == False].sort_values(\"pred_conf\", ascending=False)[:100]\n", "top_100_wrong.head(20)" ], - "execution_count": 49, + "execution_count": null, "outputs": [ { "output_type": "execute_result", @@ -4259,7 +4304,7 @@ "images_to_view = 9\n", "start_index = 10 # change the start index to view more\n", "plt.figure(figsize=(15, 10))\n", - "for i, row in enumerate(top_100_wrong[start_index:start_index+images_to_view].itertuples()): \n", + "for i, row in enumerate(top_100_wrong[start_index:start_index+images_to_view].itertuples()):\n", " plt.subplot(3, 3, i+1)\n", " img = load_and_prep_image(row[1], scale=True)\n", " _, _, _, _, pred_prob, y_true, y_pred, _ = row # only interested in a few parameters of each row\n", @@ -4267,7 +4312,7 @@ " plt.title(f\"actual: {y_true}, pred: {y_pred} \\nprob: {pred_prob:.2f}\")\n", " plt.axis(False)" ], - "execution_count": 50, + "execution_count": null, "outputs": [ { "output_type": "display_data", @@ -4298,7 +4343,7 @@ "id": "clDOL-NhDqfd" }, "source": [ - "## Test out the big dog model on test images as well as custom images of food \n", + "## Test out the big dog model on test images as well as custom images of food\n", "\n", "So far we've visualized some our model's predictions from the test dataset but it's time for the real test: using our model to make predictions on our own custom images of food.\n", "\n", @@ -4323,9 +4368,9 @@ "# Note: you can upload your own custom images to Google Colab using the \"upload\" button in the Files tab\n", "!wget https://storage.googleapis.com/ztm_tf_course/food_vision/custom_food_images.zip\n", "\n", - "unzip_data(\"custom_food_images.zip\") " + "unzip_data(\"custom_food_images.zip\")" ], - "execution_count": 51, + "execution_count": null, "outputs": [ { "output_type": "stream", @@ -4369,7 +4414,7 @@ "custom_food_images = [\"custom_food_images/\" + img_path for img_path in os.listdir(\"custom_food_images\")]\n", "custom_food_images" ], - "execution_count": 52, + "execution_count": null, "outputs": [ { "output_type": "execute_result", @@ -4419,7 +4464,7 @@ " plt.title(f\"pred: {pred_class}, prob: {pred_prob.max():.2f}\")\n", " plt.axis(False)" ], - "execution_count": 53, + "execution_count": null, "outputs": [ { "output_type": "stream", @@ -4520,9 +4565,9 @@ "\n", "1. Take 3 of your own photos of food and use the trained model to make predictions on them, share your predictions with the other students in Discord and show off your Food Vision model 🍔👁.\n", "2. Train a feature-extraction transfer learning model for 10 epochs on the same data and compare its performance versus a model which used feature extraction for 5 epochs and fine-tuning for 5 epochs (like we've used in this notebook). Which method is better?\n", - "3. Recreate our first model (the feature extraction model) with [`mixed_precision`](https://www.tensorflow.org/guide/mixed_precision) turned on. \n", - " * Does it make the model train faster? \n", - " * Does it effect the accuracy or performance of our model? \n", + "3. Recreate our first model (the feature extraction model) with [`mixed_precision`](https://www.tensorflow.org/guide/mixed_precision) turned on.\n", + " * Does it make the model train faster?\n", + " * Does it effect the accuracy or performance of our model?\n", " * What's the advatanges of using `mixed_precision` training?" ] }, diff --git a/extras/helper_functions.py b/extras/helper_functions.py index a5d604f..dd4b28a 100644 --- a/extras/helper_functions.py +++ b/extras/helper_functions.py @@ -2,6 +2,8 @@ ### Storing them here so they're easily accessible. import tensorflow as tf +import datetime +import os # Create a function to import an image and resize it to be able to be used with our model def load_and_prep_image(filename, img_shape=224, scale=True): @@ -131,27 +133,28 @@ def pred_and_plot(model, filename, class_names): plt.imshow(img) plt.title(f"Prediction: {pred_class}") plt.axis(False); - -import datetime -def create_tensorboard_callback(dir_name, experiment_name): + +def create_tensorboard_callback(experiment_name): """ - Creates a TensorBoard callback instand to store log files. + Creates a TensorBoard callback instand to store log files. - Stores log files with the filepath: - "dir_name/experiment_name/current_datetime/" + Stores log files with the filepath: + "dir_name/experiment_name/current_datetime/" - Args: - dir_name: target directory to store TensorBoard log files - experiment_name: name of experiment directory (e.g. efficientnet_model_1) + Args: + dir_name: target directory to store TensorBoard log files + experiment_name: name of experiment directory (e.g. efficientnet_model_1) """ - log_dir = dir_name + "/" + experiment_name + "/" + datetime.datetime.now().strftime("%Y%m%d-%H%M%S") + logfit_dir = "logs/fit/" + path_experiment = (os.path.join(logfit_dir, experiment_name, datetime.datetime.now().strftime("%Y%m%d-%H%M%S"))) tensorboard_callback = tf.keras.callbacks.TensorBoard( - log_dir=log_dir + log_dir=path_experiment ) - print(f"Saving TensorBoard log files to: {log_dir}") + print(f"Saving TensorBoard log files to: {logfit_dir}") return tensorboard_callback + # Plot the validation and training data separately import matplotlib.pyplot as plt